From 724af109a84a7daa9c721e2091f0e8b68fb156fd Mon Sep 17 00:00:00 2001 From: Rohit Durvasula Date: Sat, 7 Mar 2015 11:00:40 -0500 Subject: [PATCH 001/331] Update readme.md In the resume training option.. the name of the solver state changed to 'caffenet_train_iter_10000.solverstate' --- examples/imagenet/readme.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/imagenet/readme.md b/examples/imagenet/readme.md index a6bdf49ca4d..b1ebfafbf46 100644 --- a/examples/imagenet/readme.md +++ b/examples/imagenet/readme.md @@ -91,9 +91,9 @@ Resume Training? We all experience times when the power goes out, or we feel like rewarding ourself a little by playing Battlefield (does anyone still remember Quake?). Since we are snapshotting intermediate results during training, we will be able to resume from snapshots. This can be done as easy as: - ./build/tools/caffe train --solver=models/bvlc_reference_caffenet/solver.prototxt --snapshot=models/bvlc_reference_caffenet/caffenet_train_10000.solverstate + ./build/tools/caffe train --solver=models/bvlc_reference_caffenet/solver.prototxt --snapshot=models/bvlc_reference_caffenet/caffenet_train_iter_10000.solverstate -where in the script `caffenet_train_10000.solverstate` is the solver state snapshot that stores all necessary information to recover the exact solver state (including the parameters, momentum history, etc). +where in the script `caffenet_train_iter_10000.solverstate` is the solver state snapshot that stores all necessary information to recover the exact solver state (including the parameters, momentum history, etc). Parting Words ------------- From ba933d3f9714d7aa6836842158829aba7c279c60 Mon Sep 17 00:00:00 2001 From: Zifei Tong Date: Thu, 12 Mar 2015 20:09:36 +0800 Subject: [PATCH 002/331] [docs] Add missing command in OS X installation guide --- docs/install_osx.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/install_osx.md b/docs/install_osx.md index 0373a417847..e1a1d569171 100644 --- a/docs/install_osx.md +++ b/docs/install_osx.md @@ -18,7 +18,7 @@ In other `ENV` settings, things may not work as expected. brew install --fresh -vd snappy leveldb gflags glog szip lmdb # need the homebrew science source for OpenCV and hdf5 brew tap homebrew/science - hdf5 opencv + brew install hdf5 opencv If using Anaconda Python, a modification to the OpenCV formula might be needed Do `brew edit opencv` and change the lines that look like the two lines below to exactly the two lines below. From 58deb58084a61f70986e2ba6c2e98709febd6e35 Mon Sep 17 00:00:00 2001 From: Zifei Tong Date: Thu, 12 Mar 2015 20:11:52 +0800 Subject: [PATCH 003/331] [docs] Remove `--fresh` Homebrew option Since it's removed from Homebrew [1]. [1]: Homebrew/homebrew@8cdf4d8ebf439eb9a9ffcaa0e455ced9459e1e41 --- docs/install_osx.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/install_osx.md b/docs/install_osx.md index e1a1d569171..fbfc71e8f39 100644 --- a/docs/install_osx.md +++ b/docs/install_osx.md @@ -15,7 +15,7 @@ In other `ENV` settings, things may not work as expected. **General dependencies** - brew install --fresh -vd snappy leveldb gflags glog szip lmdb + brew install -vd snappy leveldb gflags glog szip lmdb # need the homebrew science source for OpenCV and hdf5 brew tap homebrew/science brew install hdf5 opencv @@ -31,8 +31,8 @@ If using Anaconda Python, HDF5 is bundled and the `hdf5` formula can be skipped. **Remaining dependencies, with / without Python** # with Python pycaffe needs dependencies built from source - brew install --build-from-source --with-python --fresh -vd protobuf - brew install --build-from-source --fresh -vd boost boost-python + brew install --build-from-source --with-python -vd protobuf + brew install --build-from-source -vd boost boost-python # without Python the usual installation suffices brew install protobuf boost @@ -78,9 +78,9 @@ To edit the formulae in turn, run After this, run - for x in snappy leveldb gflags glog szip lmdb homebrew/science/opencv; do brew uninstall $x; brew install --build-from-source --fresh -vd $x; done - brew uninstall protobuf; brew install --build-from-source --with-python --fresh -vd protobuf - brew install --build-from-source --fresh -vd boost boost-python + for x in snappy leveldb gflags glog szip lmdb homebrew/science/opencv; do brew uninstall $x; brew install --build-from-source -vd $x; done + brew uninstall protobuf; brew install --build-from-source --with-python -vd protobuf + brew install --build-from-source -vd boost boost-python If this is not done exactly right then linking errors will trouble you. From dfdf2bbe296fa42361b3984c112d7fcffde6df78 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Thu, 19 Mar 2015 11:31:17 -0700 Subject: [PATCH 004/331] CUDA kernels for {Slice,Concat}Layer --- src/caffe/layers/concat_layer.cu | 44 ++++++++++++++++++++++-------- src/caffe/layers/slice_layer.cu | 47 ++++++++++++++++++++++---------- 2 files changed, 66 insertions(+), 25 deletions(-) diff --git a/src/caffe/layers/concat_layer.cu b/src/caffe/layers/concat_layer.cu index dbadb5aeb30..8f2e85d8f52 100644 --- a/src/caffe/layers/concat_layer.cu +++ b/src/caffe/layers/concat_layer.cu @@ -6,21 +6,41 @@ namespace caffe { +template +__global__ void Concat(const int nthreads, const Dtype* in_data, + const bool forward, const int num_concats, const int concat_size, + const int top_concat_axis, const int bottom_concat_axis, + const int offset_concat_axis, Dtype* out_data) { + CUDA_KERNEL_LOOP(index, nthreads) { + const int total_concat_size = concat_size * bottom_concat_axis; + const int concat_num = index / total_concat_size; + const int concat_index = index % total_concat_size; + const int top_index = concat_index + + (concat_num * top_concat_axis + offset_concat_axis) * concat_size; + if (forward) { + out_data[top_index] = in_data[index]; + } else { + out_data[index] = in_data[top_index]; + } + } +} + template void ConcatLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { Dtype* top_data = top[0]->mutable_gpu_data(); int offset_concat_axis = 0; const int top_concat_axis = top[0]->shape(concat_axis_); + const bool kForward = true; for (int i = 0; i < bottom.size(); ++i) { const Dtype* bottom_data = bottom[i]->gpu_data(); const int bottom_concat_axis = bottom[i]->shape(concat_axis_); - for (int n = 0; n < num_concats_; ++n) { - caffe_copy(bottom_concat_axis * concat_input_size_, - bottom_data + n * bottom_concat_axis * concat_input_size_, - top_data + (n * top_concat_axis + offset_concat_axis) - * concat_input_size_); - } + const int bottom_concat_size = bottom_concat_axis * concat_input_size_; + const int nthreads = bottom_concat_size * num_concats_; + Concat // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + nthreads, bottom_data, kForward, num_concats_, concat_input_size_, + top_concat_axis, bottom_concat_axis, offset_concat_axis, top_data); offset_concat_axis += bottom_concat_axis; } } @@ -31,15 +51,17 @@ void ConcatLayer::Backward_gpu(const vector*>& top, const Dtype* top_diff = top[0]->gpu_diff(); int offset_concat_axis = 0; const int top_concat_axis = top[0]->shape(concat_axis_); + const bool kForward = false; for (int i = 0; i < bottom.size(); ++i) { if (!propagate_down[i]) { continue; } Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); const int bottom_concat_axis = bottom[i]->shape(concat_axis_); - for (int n = 0; n < num_concats_; ++n) { - caffe_copy(bottom_concat_axis * concat_input_size_, top_diff + - (n * top_concat_axis + offset_concat_axis) * concat_input_size_, - bottom_diff + n * bottom_concat_axis * concat_input_size_); - } + const int bottom_concat_size = bottom_concat_axis * concat_input_size_; + const int nthreads = bottom_concat_size * num_concats_; + Concat // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + nthreads, top_diff, kForward, num_concats_, concat_input_size_, + top_concat_axis, bottom_concat_axis, offset_concat_axis, bottom_diff); offset_concat_axis += bottom_concat_axis; } } diff --git a/src/caffe/layers/slice_layer.cu b/src/caffe/layers/slice_layer.cu index e6e65677bd8..796841d3f52 100644 --- a/src/caffe/layers/slice_layer.cu +++ b/src/caffe/layers/slice_layer.cu @@ -6,22 +6,41 @@ namespace caffe { +template +__global__ void Slice(const int nthreads, const Dtype* in_data, + const bool forward, const int num_slices, const int slice_size, + const int bottom_slice_axis, const int top_slice_axis, + const int offset_slice_axis, Dtype* out_data) { + CUDA_KERNEL_LOOP(index, nthreads) { + const int total_slice_size = slice_size * top_slice_axis; + const int slice_num = index / total_slice_size; + const int slice_index = index % total_slice_size; + const int bottom_index = slice_index + + (slice_num * bottom_slice_axis + offset_slice_axis) * slice_size; + if (forward) { + out_data[index] = in_data[bottom_index]; + } else { + out_data[bottom_index] = in_data[index]; + } + } +} + template void SliceLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { int offset_slice_axis = 0; const Dtype* bottom_data = bottom[0]->gpu_data(); const int bottom_slice_axis = bottom[0]->shape(slice_axis_); + const bool kForward = true; for (int i = 0; i < top.size(); ++i) { Dtype* top_data = top[i]->mutable_gpu_data(); const int top_slice_axis = top[i]->shape(slice_axis_); - for (int n = 0; n < num_slices_; ++n) { - const int top_offset = n * top_slice_axis * slice_size_; - const int bottom_offset = - (n * bottom_slice_axis + offset_slice_axis) * slice_size_; - caffe_copy(top_slice_axis * slice_size_, - bottom_data + bottom_offset, top_data + top_offset); - } + const int top_slice_size = top_slice_axis * slice_size_; + const int nthreads = top_slice_size * num_slices_; + Slice // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + nthreads, bottom_data, kForward, num_slices_, slice_size_, + bottom_slice_axis, top_slice_axis, offset_slice_axis, top_data); offset_slice_axis += top_slice_axis; } } @@ -33,16 +52,16 @@ void SliceLayer::Backward_gpu(const vector*>& top, int offset_slice_axis = 0; Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); const int bottom_slice_axis = bottom[0]->shape(slice_axis_); + const bool kForward = false; for (int i = 0; i < top.size(); ++i) { const Dtype* top_diff = top[i]->gpu_diff(); const int top_slice_axis = top[i]->shape(slice_axis_); - for (int n = 0; n < num_slices_; ++n) { - const int top_offset = n * top_slice_axis * slice_size_; - const int bottom_offset = - (n * bottom_slice_axis + offset_slice_axis) * slice_size_; - caffe_copy(top_slice_axis * slice_size_, - top_diff + top_offset, bottom_diff + bottom_offset); - } + const int top_slice_size = top_slice_axis * slice_size_; + const int nthreads = top_slice_size * num_slices_; + Slice // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + nthreads, top_diff, kForward, num_slices_, slice_size_, + bottom_slice_axis, top_slice_axis, offset_slice_axis, bottom_diff); offset_slice_axis += top_slice_axis; } } From 10ddfd32cb5ca4132902e9453fb05242ef52ec07 Mon Sep 17 00:00:00 2001 From: Nuno Subtil Date: Wed, 1 Apr 2015 19:10:55 -0700 Subject: [PATCH 005/331] Build gflags and glog through CMake if not found in the system This adds functionality to fetch gflags and glog from GitHub and build them during the Caffe build. This happens only if a system-wide installed version is not found (i.e., when find_package() fails). If built as part of the Caffe build, gflags and glog are compiled as position-independent static libraries. This avoids doing a system-wide install of these libraries during the Caffe install target. --- CMakeLists.txt | 2 ++ cmake/Dependencies.cmake | 4 +-- cmake/External/gflags.cmake | 56 +++++++++++++++++++++++++++++++++++++ cmake/External/glog.cmake | 56 +++++++++++++++++++++++++++++++++++++ cmake/Targets.cmake | 4 +++ 5 files changed, 120 insertions(+), 2 deletions(-) create mode 100644 cmake/External/gflags.cmake create mode 100644 cmake/External/glog.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index 74fa70c9d20..f22aa5763a3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,6 +6,8 @@ project(Caffe C CXX) # ---[ Using cmake scripts and modules list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules) +include(ExternalProject) + include(cmake/Utils.cmake) include(cmake/Targets.cmake) include(cmake/Misc.cmake) diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake index f328e8246ab..7cae5c9da25 100644 --- a/cmake/Dependencies.cmake +++ b/cmake/Dependencies.cmake @@ -11,12 +11,12 @@ find_package(Threads REQUIRED) list(APPEND Caffe_LINKER_LIBS ${CMAKE_THREAD_LIBS_INIT}) # ---[ Google-glog -find_package(Glog REQUIRED) +include("cmake/External/glog.cmake") include_directories(SYSTEM ${GLOG_INCLUDE_DIRS}) list(APPEND Caffe_LINKER_LIBS ${GLOG_LIBRARIES}) # ---[ Google-gflags -find_package(GFlags REQUIRED) +include("cmake/External/gflags.cmake") include_directories(SYSTEM ${GFLAGS_INCLUDE_DIRS}) list(APPEND Caffe_LINKER_LIBS ${GFLAGS_LIBRARIES}) diff --git a/cmake/External/gflags.cmake b/cmake/External/gflags.cmake new file mode 100644 index 00000000000..a50a0925086 --- /dev/null +++ b/cmake/External/gflags.cmake @@ -0,0 +1,56 @@ +if (NOT __GFLAGS_INCLUDED) # guard against multiple includes + set(__GFLAGS_INCLUDED TRUE) + + # use the system-wide gflags if present + find_package(GFlags) + if (GFLAGS_FOUND) + set(GFLAGS_EXTERNAL FALSE) + else() + # gflags will use pthreads if it's available in the system, so we must link with it + find_package(Threads) + + # build directory + set(gflags_PREFIX ${CMAKE_BINARY_DIR}/external/gflags-prefix) + # install directory + set(gflags_INSTALL ${CMAKE_BINARY_DIR}/external/gflags-install) + + # we build gflags statically, but want to link it into the caffe shared library + # this requires position-independent code + if (UNIX) + set(GFLAGS_EXTRA_COMPILER_FLAGS "-fPIC") + endif() + + set(GFLAGS_CXX_FLAGS ${CMAKE_CXX_FLAGS} ${GFLAGS_EXTRA_COMPILER_FLAGS}) + set(GFLAGS_C_FLAGS ${CMAKE_C_FLAGS} ${GFLAGS_EXTRA_COMPILER_FLAGS}) + + ExternalProject_Add(gflags + PREFIX ${gflags_PREFIX} + GIT_REPOSITORY "https://github.com/gflags/gflags.git" + GIT_TAG "v2.1.2" + UPDATE_COMMAND "" + INSTALL_DIR ${gflags_INSTALL} + CMAKE_ARGS -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} + -DCMAKE_INSTALL_PREFIX=${gflags_INSTALL} + -DBUILD_SHARED_LIBS=OFF + -DBUILD_STATIC_LIBS=ON + -DBUILD_PACKAGING=OFF + -DBUILD_TESTING=OFF + -DBUILD_NC_TESTS=OFF + -BUILD_CONFIG_TESTS=OFF + -DINSTALL_HEADERS=ON + -DCMAKE_C_FLAGS=${GFLAGS_C_FLAGS} + -DCMAKE_CXX_FLAGS=${GFLAGS_CXX_FLAGS} + LOG_DOWNLOAD 1 + LOG_INSTALL 1 + ) + + set(GFLAGS_FOUND TRUE) + set(GFLAGS_INCLUDE_DIRS ${gflags_INSTALL}/include) + set(GFLAGS_LIBRARIES ${gflags_INSTALL}/lib/libgflags.a ${CMAKE_THREAD_LIBS_INIT}) + set(GFLAGS_LIBRARY_DIRS ${gflags_INSTALL}/lib) + set(GFLAGS_EXTERNAL TRUE) + + list(APPEND external_project_dependencies gflags) + endif() + +endif() diff --git a/cmake/External/glog.cmake b/cmake/External/glog.cmake new file mode 100644 index 00000000000..02b39dde676 --- /dev/null +++ b/cmake/External/glog.cmake @@ -0,0 +1,56 @@ +# glog depends on gflags +include("cmake/External/gflags.cmake") + +if (NOT __GLOG_INCLUDED) + set(__GLOG_INCLUDED TRUE) + + # try the system-wide glog first + find_package(Glog) + if (GLOG_FOUND) + set(GLOG_EXTERNAL FALSE) + else() + # fetch and build glog from github + + # build directory + set(glog_PREFIX ${CMAKE_BINARY_DIR}/external/glog-prefix) + # install directory + set(glog_INSTALL ${CMAKE_BINARY_DIR}/external/glog-install) + + # we build glog statically, but want to link it into the caffe shared library + # this requires position-independent code + if (UNIX) + set(GLOG_EXTRA_COMPILER_FLAGS "-fPIC") + endif() + + set(GLOG_CXX_FLAGS ${CMAKE_CXX_FLAGS} ${GLOG_EXTRA_COMPILER_FLAGS}) + set(GLOG_C_FLAGS ${CMAKE_C_FLAGS} ${GLOG_EXTRA_COMPILER_FLAGS}) + + # depend on gflags if we're also building it + if (GFLAGS_EXTERNAL) + set(GLOG_DEPENDS gflags) + endif() + + ExternalProject_Add(glog + DEPENDS ${GLOG_DEPENDS} + PREFIX ${glog_PREFIX} + GIT_REPOSITORY "https://github.com/google/glog" + GIT_TAG "v0.3.4" + UPDATE_COMMAND "" + INSTALL_DIR ${gflags_INSTALL} + CONFIGURE_COMMAND env "CFLAGS=${GLOG_C_FLAGS}" "CXXFLAGS=${GLOG_CXX_FLAGS}" ${glog_PREFIX}/src/glog/configure --prefix=${glog_INSTALL} --enable-shared=no --enable-static=yes --with-gflags=${GFLAGS_LIBRARY_DIRS}/.. + LOG_DOWNLOAD 1 + LOG_CONFIGURE 1 + LOG_INSTALL 1 + ) + + set(GLOG_FOUND TRUE) + set(GLOG_INCLUDE_DIRS ${glog_INSTALL}/include) + set(GLOG_LIBRARIES ${GFLAGS_LIBRARIES} ${glog_INSTALL}/lib/libglog.a) + set(GLOG_LIBRARY_DIRS ${glog_INSTALL}/lib) + set(GLOG_EXTERNAL TRUE) + + list(APPEND external_project_dependencies glog) + endif() + +endif() + diff --git a/cmake/Targets.cmake b/cmake/Targets.cmake index e3ad872313b..ed0ff9660fd 100644 --- a/cmake/Targets.cmake +++ b/cmake/Targets.cmake @@ -110,6 +110,10 @@ function(caffe_default_properties target) ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib" LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib" RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin") + # make sure we build all external depepdencies first + if (DEFINED external_project_dependencies) + add_dependencies(${target} ${external_project_dependencies}) + endif() endfunction() ################################################################################################ From b45afa216deb99eecf838d1e927ee517a85b898f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Ha=CC=88cker?= Date: Thu, 2 Apr 2015 22:50:55 +0200 Subject: [PATCH 006/331] Add commented out helpers for homebrew users --- Makefile.config.example | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/Makefile.config.example b/Makefile.config.example index 7a8aafd7c9f..a873502559f 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -37,6 +37,10 @@ BLAS := atlas # BLAS_INCLUDE := /path/to/your/blas # BLAS_LIB := /path/to/your/blas +# Homebrew puts openblas in a directory that is not on the standard search path +# BLAS_INCLUDE := $(shell brew --prefix openblas)/include +# BLAS_LIB := $(shell brew --prefix openblas)/lib + # This is required only if you will compile the matlab interface. # MATLAB directory should contain the mex binary in /bin. # MATLAB_DIR := /usr/local @@ -57,6 +61,10 @@ PYTHON_INCLUDE := /usr/include/python2.7 \ PYTHON_LIB := /usr/lib # PYTHON_LIB := $(ANACONDA_HOME)/lib +# Homebrew installs numpy in a non standard path (keg only) +# PYTHON_INCLUDE += $(dir $(shell python -c 'import numpy.core; print(numpy.core.__file__)'))/include +# PYTHON_LIB += $(shell brew --prefix numpy)/lib + # Uncomment to support layers written in Python (will link against Python libs) # WITH_PYTHON_LAYER := 1 @@ -64,6 +72,10 @@ PYTHON_LIB := /usr/lib INCLUDE_DIRS := $(PYTHON_INCLUDE) /usr/local/include LIBRARY_DIRS := $(PYTHON_LIB) /usr/local/lib /usr/lib +# If Homebrew is installed at a non standard location (for example your home directory) and you use it for general dependencies +# INCLUDE_DIRS += $(shell brew --prefix)/include +# LIBRARY_DIRS += $(shell brew --prefix)/lib + # Uncomment to use `pkg-config` to specify OpenCV library paths. # (Usually not necessary -- OpenCV libraries are normally installed in one of the above $LIBRARY_DIRS.) # USE_PKG_CONFIG := 1 From b963008a6591600e60ed6746d208e82e107f6a89 Mon Sep 17 00:00:00 2001 From: Sergio Guadarrama Date: Tue, 7 Apr 2015 17:51:22 -0700 Subject: [PATCH 007/331] Allow Transform of encoded datum. Allow initialize transformed_blob from datum or transform params. Allow force_color and force_gray as transform params. --- src/caffe/data_transformer.cpp | 59 +++++++++++++++++++++++++++++++--- src/caffe/proto/caffe.proto | 4 +++ 2 files changed, 59 insertions(+), 4 deletions(-) diff --git a/src/caffe/data_transformer.cpp b/src/caffe/data_transformer.cpp index b0b98e478c1..454dabbebfd 100644 --- a/src/caffe/data_transformer.cpp +++ b/src/caffe/data_transformer.cpp @@ -125,10 +125,40 @@ void DataTransformer::Transform(const Datum& datum, template void DataTransformer::Transform(const Datum& datum, Blob* transformed_blob) { + // If datum is encoded, decoded and transform the cv::image. + if (datum.encoded()) { + CHECK(!param_.force_color() && !param_.force_gray()) + << "cannot set both force_color and force_gray"; + cv::Mat cv_img; + if (param_.force_color() || param_.force_gray()) { + // If force_color then decode in color otherwise decode in gray. + cv_img = DecodeDatumToCVMat(datum, param_.force_color()); + } else { + cv_img = DecodeDatumToCVMatNative(datum); + } + // Transform the cv::image into blob. + return Transform(cv_img, transformed_blob); + } else { + if (param_.force_color() || param_.force_gray()) { + LOG(ERROR) << "force_color and force_gray only for encoded datum"; + } + } + const int datum_channels = datum.channels(); const int datum_height = datum.height(); const int datum_width = datum.width(); + const int crop_size = param_.crop_size(); + + if (transformed_blob->count() == 0) { + // Initialize it. + if (crop_size) { + transformed_blob->Reshape(1, datum_channels, crop_size, crop_size); + } else { + transformed_blob->Reshape(1, datum_channels, datum_height, datum_width); + } + } + // Check dimensions. const int channels = transformed_blob->channels(); const int height = transformed_blob->height(); const int width = transformed_blob->width(); @@ -139,8 +169,6 @@ void DataTransformer::Transform(const Datum& datum, CHECK_LE(width, datum_width); CHECK_GE(num, 1); - const int crop_size = param_.crop_size(); - if (crop_size) { CHECK_EQ(crop_size, height); CHECK_EQ(crop_size, width); @@ -200,6 +228,17 @@ void DataTransformer::Transform(const cv::Mat& cv_img, const int img_height = cv_img.rows; const int img_width = cv_img.cols; + const int crop_size = param_.crop_size(); + + if (transformed_blob->count() == 0) { + // Initialize it. + if (crop_size) { + transformed_blob->Reshape(1, img_channels, crop_size, crop_size); + } else { + transformed_blob->Reshape(1, img_channels, img_height, img_width); + } + } + const int channels = transformed_blob->channels(); const int height = transformed_blob->height(); const int width = transformed_blob->width(); @@ -212,7 +251,6 @@ void DataTransformer::Transform(const cv::Mat& cv_img, CHECK(cv_img.depth() == CV_8U) << "Image data type must be unsigned byte"; - const int crop_size = param_.crop_size(); const Dtype scale = param_.scale(); const bool do_mirror = param_.mirror() && Rand(2); const bool has_mean_file = param_.has_mean_file(); @@ -302,6 +340,19 @@ void DataTransformer::Transform(Blob* input_blob, const int input_height = input_blob->height(); const int input_width = input_blob->width(); + const int crop_size = param_.crop_size(); + + if (transformed_blob->count() == 0) { + // Initialize it. + if (crop_size) { + transformed_blob->Reshape(input_num, input_channels, + crop_size, crop_size); + } else { + transformed_blob->Reshape(input_num, input_channels, + input_height, input_width); + } + } + const int num = transformed_blob->num(); const int channels = transformed_blob->channels(); const int height = transformed_blob->height(); @@ -313,7 +364,7 @@ void DataTransformer::Transform(Blob* input_blob, CHECK_GE(input_height, height); CHECK_GE(input_width, width); - const int crop_size = param_.crop_size(); + const Dtype scale = param_.scale(); const bool do_mirror = param_.mirror() && Rand(2); const bool has_mean_file = param_.has_mean_file(); diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 5b21cf20028..d66167eefc8 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -351,6 +351,10 @@ message TransformationParameter { // or can be repeated the same number of times as channels // (would subtract them from the corresponding channel) repeated float mean_value = 5; + // Force the decoded image to have 3 color channels. + optional bool force_color = 6 [default = false]; + // Force the decoded image to have 1 color channels. + optional bool force_gray = 7 [default = false]; } // Message that stores parameters shared by loss layers From c3cd3c4d8c25c7b227e15aff0fe93e4151ffd8f6 Mon Sep 17 00:00:00 2001 From: Sergio Guadarrama Date: Wed, 8 Apr 2015 12:08:56 -0700 Subject: [PATCH 008/331] Added InferBlobShape to data_transformer. --- include/caffe/data_transformer.hpp | 36 ++++++++++ src/caffe/data_transformer.cpp | 105 ++++++++++++++++++++++------- 2 files changed, 117 insertions(+), 24 deletions(-) diff --git a/include/caffe/data_transformer.hpp b/include/caffe/data_transformer.hpp index 880356601a4..0ad68c80216 100644 --- a/include/caffe/data_transformer.hpp +++ b/include/caffe/data_transformer.hpp @@ -62,6 +62,7 @@ class DataTransformer { */ void Transform(const vector & mat_vector, Blob* transformed_blob); + /** * @brief Applies the transformation defined in the data layer's * transform_param block to a cv::Mat @@ -87,6 +88,41 @@ class DataTransformer { */ void Transform(Blob* input_blob, Blob* transformed_blob); + /** + * @brief Infers the shape of transformed_blob will have when + * the transformation is applied to the data. + * + * @param datum + * Datum containing the data to be transformed. + */ + vector InferBlobShape(const Datum& datum); + /** + * @brief Infers the shape of transformed_blob will have when + * the transformation is applied to the data. + * It uses the first element to infer the shape of the blob. + * + * @param datum_vector + * A vector of Datum containing the data to be transformed. + */ + vector InferBlobShape(const vector & datum_vector); + /** + * @brief Infers the shape of transformed_blob will have when + * the transformation is applied to the data. + * It uses the first element to infer the shape of the blob. + * + * @param mat_vector + * A vector of Mat containing the data to be transformed. + */ + vector InferBlobShape(const vector & mat_vector); + /** + * @brief Infers the shape of transformed_blob will have when + * the transformation is applied to the data. + * + * @param cv_img + * cv::Mat containing the data to be transformed. + */ + vector InferBlobShape(const cv::Mat& cv_img); + protected: /** * @brief Generates a random integer from Uniform({0, 1, ..., n-1}). diff --git a/src/caffe/data_transformer.cpp b/src/caffe/data_transformer.cpp index 454dabbebfd..6f75bdb3852 100644 --- a/src/caffe/data_transformer.cpp +++ b/src/caffe/data_transformer.cpp @@ -144,20 +144,11 @@ void DataTransformer::Transform(const Datum& datum, } } + const int crop_size = param_.crop_size(); const int datum_channels = datum.channels(); const int datum_height = datum.height(); const int datum_width = datum.width(); - const int crop_size = param_.crop_size(); - - if (transformed_blob->count() == 0) { - // Initialize it. - if (crop_size) { - transformed_blob->Reshape(1, datum_channels, crop_size, crop_size); - } else { - transformed_blob->Reshape(1, datum_channels, datum_height, datum_width); - } - } // Check dimensions. const int channels = transformed_blob->channels(); const int height = transformed_blob->height(); @@ -224,21 +215,12 @@ void DataTransformer::Transform(const vector & mat_vector, template void DataTransformer::Transform(const cv::Mat& cv_img, Blob* transformed_blob) { + const int crop_size = param_.crop_size(); const int img_channels = cv_img.channels(); const int img_height = cv_img.rows; const int img_width = cv_img.cols; - const int crop_size = param_.crop_size(); - - if (transformed_blob->count() == 0) { - // Initialize it. - if (crop_size) { - transformed_blob->Reshape(1, img_channels, crop_size, crop_size); - } else { - transformed_blob->Reshape(1, img_channels, img_height, img_width); - } - } - + // Check dimensions. const int channels = transformed_blob->channels(); const int height = transformed_blob->height(); const int width = transformed_blob->width(); @@ -335,15 +317,14 @@ void DataTransformer::Transform(const cv::Mat& cv_img, template void DataTransformer::Transform(Blob* input_blob, Blob* transformed_blob) { + const int crop_size = param_.crop_size(); const int input_num = input_blob->num(); const int input_channels = input_blob->channels(); const int input_height = input_blob->height(); const int input_width = input_blob->width(); - const int crop_size = param_.crop_size(); - if (transformed_blob->count() == 0) { - // Initialize it. + // Initialize transformed_blob with the right shape. if (crop_size) { transformed_blob->Reshape(input_num, input_channels, crop_size, crop_size); @@ -446,6 +427,82 @@ void DataTransformer::Transform(Blob* input_blob, } } +template +vector DataTransformer::InferBlobShape(const Datum& datum) { + if (datum.encoded()) { + CHECK(!param_.force_color() && !param_.force_gray()) + << "cannot set both force_color and force_gray"; + cv::Mat cv_img; + if (param_.force_color() || param_.force_gray()) { + // If force_color then decode in color otherwise decode in gray. + cv_img = DecodeDatumToCVMat(datum, param_.force_color()); + } else { + cv_img = DecodeDatumToCVMatNative(datum); + } + // InferBlobShape using the cv::image. + return InferBlobShape(cv_img); + } + + const int crop_size = param_.crop_size(); + const int datum_channels = datum.channels(); + const int datum_height = datum.height(); + const int datum_width = datum.width(); + // Check dimensions. + CHECK_GT(datum_channels, 0); + CHECK_GE(datum_height, crop_size); + CHECK_GE(datum_width, crop_size); + // Build BlobShape. + vector shape(4); + shape[0] = 1; + shape[1] = datum_channels; + shape[2] = (crop_size)? crop_size: datum_height; + shape[3] = (crop_size)? crop_size: datum_width; + return shape; +} + +template +vector DataTransformer::InferBlobShape( + const vector & datum_vector) { + const int num = datum_vector.size(); + CHECK_GT(num, 0) << "There is no datum to in the vector"; + // Use first datum in the vector to InferBlobShape. + vector shape = InferBlobShape(datum_vector[0]); + // Adjust num to the size of the vector. + shape[0] = num; + return shape; +} + +template +vector DataTransformer::InferBlobShape(const cv::Mat& cv_img) { + const int crop_size = param_.crop_size(); + const int img_channels = cv_img.channels(); + const int img_height = cv_img.rows; + const int img_width = cv_img.cols; + // Check dimensions. + CHECK_GT(img_channels, 0); + CHECK_GE(img_height, crop_size); + CHECK_GE(img_width, crop_size); + // Build BlobShape. + vector shape(4); + shape[0] = 1; + shape[1] = img_channels; + shape[2] = (crop_size)? crop_size: img_height; + shape[3] = (crop_size)? crop_size: img_width; + return shape; +} + +template +vector DataTransformer::InferBlobShape( + const vector & mat_vector) { + const int num = mat_vector.size(); + CHECK_GT(num, 0) << "There is no cv_img to in the vector"; + // Use first cv_img in the vector to InferBlobShape. + vector shape = InferBlobShape(mat_vector[0]); + // Adjust num to the size of the vector. + shape[0] = num; + return shape; +} + template void DataTransformer::InitRand() { const bool needs_rand = param_.mirror() || From 3c46df772247e7bccfd23e340c75245f921ad0d1 Mon Sep 17 00:00:00 2001 From: Sergio Guadarrama Date: Wed, 8 Apr 2015 12:09:33 -0700 Subject: [PATCH 009/331] Simplify data_layer reshapes and encodings by letting data_transformer do the job. --- src/caffe/layers/base_data_layer.cpp | 10 ++-- src/caffe/layers/base_data_layer.cu | 6 +- src/caffe/layers/data_layer.cpp | 90 ++++++++-------------------- 3 files changed, 35 insertions(+), 71 deletions(-) diff --git a/src/caffe/layers/base_data_layer.cpp b/src/caffe/layers/base_data_layer.cpp index 352200915d7..aa3f613d1a3 100644 --- a/src/caffe/layers/base_data_layer.cpp +++ b/src/caffe/layers/base_data_layer.cpp @@ -21,11 +21,11 @@ void BaseDataLayer::LayerSetUp(const vector*>& bottom, } else { output_labels_ = true; } - // The subclasses should setup the size of bottom and top - DataLayerSetUp(bottom, top); data_transformer_.reset( new DataTransformer(transform_param_, this->phase_)); data_transformer_->InitRand(); + // The subclasses should setup the size of bottom and top + DataLayerSetUp(bottom, top); } template @@ -63,13 +63,15 @@ void BasePrefetchingDataLayer::Forward_cpu( JoinPrefetchThread(); DLOG(INFO) << "Thread joined"; // Reshape to loaded data. - top[0]->Reshape(this->prefetch_data_.num(), this->prefetch_data_.channels(), - this->prefetch_data_.height(), this->prefetch_data_.width()); + top[0]->ReshapeLike(prefetch_data_); // Copy the data caffe_copy(prefetch_data_.count(), prefetch_data_.cpu_data(), top[0]->mutable_cpu_data()); DLOG(INFO) << "Prefetch copied"; if (this->output_labels_) { + // Reshape to loaded labels. + top[1]->ReshapeLike(prefetch_label_); + // Copy the labels. caffe_copy(prefetch_label_.count(), prefetch_label_.cpu_data(), top[1]->mutable_cpu_data()); } diff --git a/src/caffe/layers/base_data_layer.cu b/src/caffe/layers/base_data_layer.cu index 775f6c47f7e..9335a5bc9a9 100644 --- a/src/caffe/layers/base_data_layer.cu +++ b/src/caffe/layers/base_data_layer.cu @@ -10,12 +10,14 @@ void BasePrefetchingDataLayer::Forward_gpu( // First, join the thread JoinPrefetchThread(); // Reshape to loaded data. - top[0]->Reshape(this->prefetch_data_.num(), this->prefetch_data_.channels(), - this->prefetch_data_.height(), this->prefetch_data_.width()); + top[0]->ReshapeLike(this->prefetch_data_); // Copy the data caffe_copy(prefetch_data_.count(), prefetch_data_.cpu_data(), top[0]->mutable_gpu_data()); if (this->output_labels_) { + // Reshape to loaded labels. + top[1]->ReshapeLike(prefetch_label_); + // Copy the labels. caffe_copy(prefetch_label_.count(), prefetch_label_.cpu_data(), top[1]->mutable_gpu_data()); } diff --git a/src/caffe/layers/data_layer.cpp b/src/caffe/layers/data_layer.cpp index 0f2d66776a9..161a75e0c8c 100644 --- a/src/caffe/layers/data_layer.cpp +++ b/src/caffe/layers/data_layer.cpp @@ -38,32 +38,17 @@ void DataLayer::DataLayerSetUp(const vector*>& bottom, cursor_->Next(); } } - // Read a data point, and use it to initialize the top blob. + // Read a data point, to initialize the prefetch and top blobs. Datum datum; datum.ParseFromString(cursor_->value()); + // Use data_transformer to infer the expected blob shape from datum. + vector top_shape = this->data_transformer_->InferBlobShape(datum); + this->transformed_data_.Reshape(top_shape); + // Reshape top[0] and prefetch_data according to the batch_size. + top_shape[0] = this->layer_param_.data_param().batch_size(); + this->prefetch_data_.Reshape(top_shape); + top[0]->ReshapeLike(this->prefetch_data_); - bool force_color = this->layer_param_.data_param().force_encoded_color(); - if ((force_color && DecodeDatum(&datum, true)) || - DecodeDatumNative(&datum)) { - LOG(INFO) << "Decoding Datum"; - } - // image - int crop_size = this->layer_param_.transform_param().crop_size(); - if (crop_size > 0) { - top[0]->Reshape(this->layer_param_.data_param().batch_size(), - datum.channels(), crop_size, crop_size); - this->prefetch_data_.Reshape(this->layer_param_.data_param().batch_size(), - datum.channels(), crop_size, crop_size); - this->transformed_data_.Reshape(1, datum.channels(), crop_size, crop_size); - } else { - top[0]->Reshape( - this->layer_param_.data_param().batch_size(), datum.channels(), - datum.height(), datum.width()); - this->prefetch_data_.Reshape(this->layer_param_.data_param().batch_size(), - datum.channels(), datum.height(), datum.width()); - this->transformed_data_.Reshape(1, datum.channels(), - datum.height(), datum.width()); - } LOG(INFO) << "output data size: " << top[0]->num() << "," << top[0]->channels() << "," << top[0]->height() << "," << top[0]->width(); @@ -86,25 +71,17 @@ void DataLayer::InternalThreadEntry() { CHECK(this->prefetch_data_.count()); CHECK(this->transformed_data_.count()); - // Reshape on single input batches for inputs of varying dimension. + // Reshape according to the first datum of each batch + // on single input batches allows for inputs of varying dimension. const int batch_size = this->layer_param_.data_param().batch_size(); - const int crop_size = this->layer_param_.transform_param().crop_size(); - bool force_color = this->layer_param_.data_param().force_encoded_color(); - if (batch_size == 1 && crop_size == 0) { - Datum datum; - datum.ParseFromString(cursor_->value()); - if (datum.encoded()) { - if (force_color) { - DecodeDatum(&datum, true); - } else { - DecodeDatumNative(&datum); - } - } - this->prefetch_data_.Reshape(1, datum.channels(), - datum.height(), datum.width()); - this->transformed_data_.Reshape(1, datum.channels(), - datum.height(), datum.width()); - } + Datum datum; + datum.ParseFromString(cursor_->value()); + // Use data_transformer to infer the expected blob shape from datum. + vector top_shape = this->data_transformer_->InferBlobShape(datum); + this->transformed_data_.Reshape(top_shape); + // Reshape prefetch_data according to the batch_size. + top_shape[0] = batch_size; + this->prefetch_data_.Reshape(top_shape); Dtype* top_data = this->prefetch_data_.mutable_cpu_data(); Dtype* top_label = NULL; // suppress warnings about uninitialized variables @@ -112,48 +89,31 @@ void DataLayer::InternalThreadEntry() { if (this->output_labels_) { top_label = this->prefetch_label_.mutable_cpu_data(); } + timer.Start(); for (int item_id = 0; item_id < batch_size; ++item_id) { - timer.Start(); - // get a blob + // get a datum Datum datum; datum.ParseFromString(cursor_->value()); - - cv::Mat cv_img; - if (datum.encoded()) { - if (force_color) { - cv_img = DecodeDatumToCVMat(datum, true); - } else { - cv_img = DecodeDatumToCVMatNative(datum); - } - if (cv_img.channels() != this->transformed_data_.channels()) { - LOG(WARNING) << "Your dataset contains encoded images with mixed " - << "channel sizes. Consider adding a 'force_color' flag to the " - << "model definition, or rebuild your dataset using " - << "convert_imageset."; - } - } read_time += timer.MicroSeconds(); timer.Start(); - // Apply data transformations (mirror, scale, crop...) int offset = this->prefetch_data_.offset(item_id); this->transformed_data_.set_cpu_data(top_data + offset); - if (datum.encoded()) { - this->data_transformer_->Transform(cv_img, &(this->transformed_data_)); - } else { - this->data_transformer_->Transform(datum, &(this->transformed_data_)); - } + this->data_transformer_->Transform(datum, &(this->transformed_data_)); + // Copy label. if (this->output_labels_) { top_label[item_id] = datum.label(); } trans_time += timer.MicroSeconds(); - // go to the next iter + timer.Start(); + // go to the next item. cursor_->Next(); if (!cursor_->valid()) { DLOG(INFO) << "Restarting data prefetching from start."; cursor_->SeekToFirst(); } } + timer.Stop(); batch_timer.Stop(); DLOG(INFO) << "Prefetch batch: " << batch_timer.MilliSeconds() << " ms."; DLOG(INFO) << " Read time: " << read_time / 1000 << " ms."; From e048b1741e8a5dfafeecff96c5a69d3211224fd6 Mon Sep 17 00:00:00 2001 From: Sergio Guadarrama Date: Wed, 8 Apr 2015 12:44:48 -0700 Subject: [PATCH 010/331] Simplify image_data_layer reshapes by letting data_transformer do the job. --- src/caffe/layers/image_data_layer.cpp | 42 ++++++++++++--------------- 1 file changed, 18 insertions(+), 24 deletions(-) diff --git a/src/caffe/layers/image_data_layer.cpp b/src/caffe/layers/image_data_layer.cpp index 38ebbd5ec14..18c035cba9d 100644 --- a/src/caffe/layers/image_data_layer.cpp +++ b/src/caffe/layers/image_data_layer.cpp @@ -62,21 +62,15 @@ void ImageDataLayer::DataLayerSetUp(const vector*>& bottom, // Read an image, and use it to initialize the top blob. cv::Mat cv_img = ReadImageToCVMat(root_folder + lines_[lines_id_].first, new_height, new_width, is_color); - const int channels = cv_img.channels(); - const int height = cv_img.rows; - const int width = cv_img.cols; - // image - const int crop_size = this->layer_param_.transform_param().crop_size(); + // Use data_transformer to infer the expected blob shape from a cv_image. + vector top_shape = this->data_transformer_->InferBlobShape(cv_img); + this->transformed_data_.Reshape(top_shape); + // Reshape prefetch_data and top[0] according to the batch_size. const int batch_size = this->layer_param_.image_data_param().batch_size(); - if (crop_size > 0) { - top[0]->Reshape(batch_size, channels, crop_size, crop_size); - this->prefetch_data_.Reshape(batch_size, channels, crop_size, crop_size); - this->transformed_data_.Reshape(1, channels, crop_size, crop_size); - } else { - top[0]->Reshape(batch_size, channels, height, width); - this->prefetch_data_.Reshape(batch_size, channels, height, width); - this->transformed_data_.Reshape(1, channels, height, width); - } + top_shape[0] = batch_size; + this->prefetch_data_.Reshape(top_shape); + top[0]->ReshapeLike(this->prefetch_data_); + LOG(INFO) << "output data size: " << top[0]->num() << "," << top[0]->channels() << "," << top[0]->height() << "," << top[0]->width(); @@ -107,19 +101,19 @@ void ImageDataLayer::InternalThreadEntry() { const int batch_size = image_data_param.batch_size(); const int new_height = image_data_param.new_height(); const int new_width = image_data_param.new_width(); - const int crop_size = this->layer_param_.transform_param().crop_size(); const bool is_color = image_data_param.is_color(); string root_folder = image_data_param.root_folder(); - // Reshape on single input batches for inputs of varying dimension. - if (batch_size == 1 && crop_size == 0 && new_height == 0 && new_width == 0) { - cv::Mat cv_img = ReadImageToCVMat(root_folder + lines_[lines_id_].first, - 0, 0, is_color); - this->prefetch_data_.Reshape(1, cv_img.channels(), - cv_img.rows, cv_img.cols); - this->transformed_data_.Reshape(1, cv_img.channels(), - cv_img.rows, cv_img.cols); - } + // Reshape according to the first image of each batch + // on single input batches allows for inputs of varying dimension. + cv::Mat cv_img = ReadImageToCVMat(root_folder + lines_[lines_id_].first, + new_height, new_width, is_color); + // Use data_transformer to infer the expected blob shape from a cv_img. + vector top_shape = this->data_transformer_->InferBlobShape(cv_img); + this->transformed_data_.Reshape(top_shape); + // Reshape prefetch_data according to the batch_size. + top_shape[0] = batch_size; + this->prefetch_data_.Reshape(top_shape); Dtype* prefetch_data = this->prefetch_data_.mutable_cpu_data(); Dtype* prefetch_label = this->prefetch_label_.mutable_cpu_data(); From 23d28fdef8ba936b2a6a4a123de625084faec1dd Mon Sep 17 00:00:00 2001 From: Daniel Golden Date: Tue, 9 Dec 2014 09:20:38 -0800 Subject: [PATCH 011/331] Improvements to python log parser Over version introduced in https://github.com/BVLC/caffe/pull/1384 Highlights: * Interface change: column order is now determined by using a list of `OrderedDict` objects instead of `dict` objects, which obviates the need to pass around a tuple with the column orders. * The outputs are now named according to their names in the network protobuffer; e.g., if your top is named `loss`, then the corresponding column header will also be `loss`; we no longer rename it to, e.g., `TrainingLoss` or `TestLoss`. * Fixed the bug/feature of the first version where the initial learning rate was always NaN. * Add optional parameter to specify output table delimiter. It's still a comma by default. You can use Matlab code from [this gist](https://gist.github.com/drdan14/d8b45999c4a1cbf7ad85) to verify that your results are the same before and after the changes introduced in this pull request. That code assumes that your `top` names are `accuracy` and `loss`, but you can modify the code if that's not true. --- tools/extra/parse_log.py | 165 ++++++++++++++++++++++++--------------- 1 file changed, 102 insertions(+), 63 deletions(-) diff --git a/tools/extra/parse_log.py b/tools/extra/parse_log.py index 16ba077aee6..09ea216ced3 100755 --- a/tools/extra/parse_log.py +++ b/tools/extra/parse_log.py @@ -3,7 +3,7 @@ """ Parse training log -Competitor to parse_log.sh +Evolved from parse_log.sh """ import os @@ -11,18 +11,7 @@ import extract_seconds import argparse import csv - - -def get_line_type(line): - """Return either 'test' or 'train' depending on line type - """ - - line_type = None - if line.find('Train') != -1: - line_type = 'train' - elif line.find('Test') != -1: - line_type = 'test' - return line_type +from collections import OrderedDict def parse_log(path_to_log): @@ -36,70 +25,112 @@ def parse_log(path_to_log): for the two dict_lists """ - re_iteration = re.compile('Iteration (\d+)') - re_accuracy = re.compile('output #\d+: accuracy = ([\.\d]+)') - re_train_loss = re.compile('Iteration \d+, loss = ([\.\d]+)') - re_output_loss = re.compile('output #\d+: loss = ([\.\d]+)') - re_lr = re.compile('lr = ([\.\d]+)') + regex_iteration = re.compile('Iteration (\d+)') + regex_train_output = re.compile('Train net output #(\d+): (\S+) = ([\.\deE+-]+)') + regex_test_output = re.compile('Test net output #(\d+): (\S+) = ([\.\deE+-]+)') + regex_learning_rate = re.compile('lr = ([\.\d]+)') # Pick out lines of interest iteration = -1 - test_accuracy = -1 learning_rate = float('NaN') train_dict_list = [] test_dict_list = [] - train_dict_names = ('NumIters', 'Seconds', 'TrainingLoss', 'LearningRate') - test_dict_names = ('NumIters', 'Seconds', 'TestAccuracy', 'TestLoss') + train_row = None + test_row = None logfile_year = extract_seconds.get_log_created_year(path_to_log) with open(path_to_log) as f: start_time = extract_seconds.get_start_time(f, logfile_year) for line in f: - iteration_match = re_iteration.search(line) + iteration_match = regex_iteration.search(line) if iteration_match: iteration = float(iteration_match.group(1)) if iteration == -1: - # Only look for other stuff if we've found the first iteration + # Only start parsing for other stuff if we've found the first + # iteration continue time = extract_seconds.extract_datetime_from_line(line, logfile_year) seconds = (time - start_time).total_seconds() - lr_match = re_lr.search(line) - if lr_match: - learning_rate = float(lr_match.group(1)) - - accuracy_match = re_accuracy.search(line) - if accuracy_match and get_line_type(line) == 'test': - test_accuracy = float(accuracy_match.group(1)) - - train_loss_match = re_train_loss.search(line) - if train_loss_match: - train_loss = float(train_loss_match.group(1)) - train_dict_list.append({'NumIters': iteration, - 'Seconds': seconds, - 'TrainingLoss': train_loss, - 'LearningRate': learning_rate}) - - output_loss_match = re_output_loss.search(line) - if output_loss_match and get_line_type(line) == 'test': - test_loss = float(output_loss_match.group(1)) - # NOTE: we assume that (1) accuracy always comes right before - # loss for test data so the test_accuracy variable is already - # correctly populated and (2) there's one and only one output - # named "accuracy" for the test net - test_dict_list.append({'NumIters': iteration, - 'Seconds': seconds, - 'TestAccuracy': test_accuracy, - 'TestLoss': test_loss}) - - return train_dict_list, train_dict_names, test_dict_list, test_dict_names - - -def save_csv_files(logfile_path, output_dir, train_dict_list, train_dict_names, - test_dict_list, test_dict_names, verbose=False): + learning_rate_match = regex_learning_rate.search(line) + if learning_rate_match: + learning_rate = float(learning_rate_match.group(1)) + + train_dict_list, train_row = parse_line_for_net_output( + regex_train_output, train_row, train_dict_list, + line, iteration, seconds, learning_rate + ) + test_dict_list, test_row = parse_line_for_net_output( + regex_test_output, test_row, test_dict_list, + line, iteration, seconds, learning_rate + ) + + fix_initial_nan_learning_rate(train_dict_list) + fix_initial_nan_learning_rate(test_dict_list) + + return train_dict_list, test_dict_list + + +def parse_line_for_net_output(regex_obj, row, row_dict_list, + line, iteration, seconds, learning_rate): + """Parse a single line for training or test output + + Returns a a tuple with (row_dict_list, row) + row: may be either a new row or an augmented version of the current row + row_dict_list: may be either the current row_dict_list or an augmented + version of the current row_dict_list + """ + + output_match = regex_obj.search(line) + if output_match: + if not row or row['NumIters'] != iteration: + # Push the last row and start a new one + if row: + # If we're on a new iteration, push the last row + # This will probably only happen for the first row; otherwise + # the full row checking logic below will push and clear full + # rows + row_dict_list.append(row) + + row = OrderedDict([ + ('NumIters', iteration), + ('Seconds', seconds), + ('LearningRate', learning_rate) + ]) + + # output_num is not used; may be used in the future + # output_num = output_match.group(1) + output_name = output_match.group(2) + output_val = output_match.group(3) + row[output_name] = float(output_val) + + if row and len(row_dict_list) >= 1 and len(row) == len(row_dict_list[0]): + # The row is full, based on the fact that it has the same number of + # columns as the first row; append it to the list + row_dict_list.append(row) + row = None + + return row_dict_list, row + + +def fix_initial_nan_learning_rate(dict_list): + """Correct initial value of learning rate + + Learning rate is normally not printed until after the initial test and + training step, which means the initial testing and training rows have + LearningRate = NaN. Fix this by copying over the LearningRate from the + second row, if it exists. + """ + + if len(dict_list) > 1: + dict_list[0]['LearningRate'] = dict_list[1]['LearningRate'] + + +def save_csv_files(logfile_path, output_dir, train_dict_list, test_dict_list, + delimiter=',', verbose=False): """Save CSV files to output_dir If the input log file is, e.g., caffe.INFO, the names will be @@ -108,18 +139,22 @@ def save_csv_files(logfile_path, output_dir, train_dict_list, train_dict_names, log_basename = os.path.basename(logfile_path) train_filename = os.path.join(output_dir, log_basename + '.train') - write_csv(train_filename, train_dict_list, train_dict_names, verbose) + write_csv(train_filename, train_dict_list, delimiter, verbose) test_filename = os.path.join(output_dir, log_basename + '.test') - write_csv(test_filename, test_dict_list, test_dict_names, verbose) + write_csv(test_filename, test_dict_list, delimiter, verbose) -def write_csv(output_filename, dict_list, header_names, verbose=False): +def write_csv(output_filename, dict_list, delimiter, verbose=False): """Write a CSV file """ + dialect = csv.excel + dialect.delimiter = delimiter + with open(output_filename, 'w') as f: - dict_writer = csv.DictWriter(f, header_names) + dict_writer = csv.DictWriter(f, fieldnames=dict_list[0].keys(), + dialect=dialect) dict_writer.writeheader() dict_writer.writerows(dict_list) if verbose: @@ -141,16 +176,20 @@ def parse_args(): action='store_true', help='Print some extra info (e.g., output filenames)') + parser.add_argument('--delimiter', + default=',', + help=('Column delimiter in output files ' + '(default: \'%(default)s\')')) + args = parser.parse_args() return args def main(): args = parse_args() - train_dict_list, train_dict_names, test_dict_list, test_dict_names = \ - parse_log(args.logfile_path) + train_dict_list, test_dict_list = parse_log(args.logfile_path) save_csv_files(args.logfile_path, args.output_dir, train_dict_list, - train_dict_names, test_dict_list, test_dict_names) + test_dict_list, delimiter=args.delimiter) if __name__ == '__main__': From 63703edb0a4debd92c2b4e843612502c6015d203 Mon Sep 17 00:00:00 2001 From: Delbert Date: Thu, 30 Apr 2015 10:15:58 +0800 Subject: [PATCH 012/331] Correct the REPO_DIRNAME --- examples/web_demo/app.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/web_demo/app.py b/examples/web_demo/app.py index c667ea94c11..09411f33f10 100644 --- a/examples/web_demo/app.py +++ b/examples/web_demo/app.py @@ -17,7 +17,7 @@ import caffe -REPO_DIRNAME = os.path.abspath(os.path.dirname(__file__) + '/../..') +REPO_DIRNAME = os.path.abspath(os.path.dirname(os.path.abspath(__file__)) + '/../..') UPLOAD_FOLDER = '/tmp/caffe_demos_uploads' ALLOWED_IMAGE_EXTENSIONS = set(['png', 'bmp', 'jpg', 'jpe', 'jpeg', 'gif']) From 41d13c08e883588badf9d00b60c0dc24c7905fd1 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 14 May 2015 22:14:13 -0700 Subject: [PATCH 013/331] [pycaffe] correct exceptions from Python; remove PyErr_Print Previously, PyErr_Print was used to print Python exceptions. This has the side effect of clearing the exception, which results in (an additional) SystemError in the Python interpreter. Exception printing from the caffe binary tool is re-added in a future commit. --- include/caffe/python_layer.hpp | 29 ++++------------------------- 1 file changed, 4 insertions(+), 25 deletions(-) diff --git a/include/caffe/python_layer.hpp b/include/caffe/python_layer.hpp index 19cf18c9742..9c30250c1b5 100644 --- a/include/caffe/python_layer.hpp +++ b/include/caffe/python_layer.hpp @@ -18,22 +18,11 @@ class PythonLayer : public Layer { virtual void LayerSetUp(const vector*>& bottom, const vector*>& top) { - try { - self_.attr("setup")(bottom, top); - } catch (bp::error_already_set) { - PyErr_Print(); - throw; - } + self_.attr("setup")(bottom, top); } - virtual void Reshape(const vector*>& bottom, const vector*>& top) { - try { - self_.attr("reshape")(bottom, top); - } catch (bp::error_already_set) { - PyErr_Print(); - throw; - } + self_.attr("reshape")(bottom, top); } virtual inline const char* type() const { return "Python"; } @@ -41,21 +30,11 @@ class PythonLayer : public Layer { protected: virtual void Forward_cpu(const vector*>& bottom, const vector*>& top) { - try { - self_.attr("forward")(bottom, top); - } catch (bp::error_already_set) { - PyErr_Print(); - throw; - } + self_.attr("forward")(bottom, top); } virtual void Backward_cpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { - try { - self_.attr("backward")(top, propagate_down, bottom); - } catch (bp::error_already_set) { - PyErr_Print(); - throw; - } + self_.attr("backward")(top, propagate_down, bottom); } private: From cebce771309b1c07dd0fb2eb18b9b37667d955dc Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 14 May 2015 22:17:19 -0700 Subject: [PATCH 014/331] print Python exceptions when using Python layer with the caffe tool --- tools/caffe.cpp | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/tools/caffe.cpp b/tools/caffe.cpp index 70b15f890f7..6967a46f758 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -8,6 +8,11 @@ #include "boost/algorithm/string.hpp" #include "caffe/caffe.hpp" +#ifdef WITH_PYTHON_LAYER +#include "boost/python.hpp" +namespace bp = boost::python; +#endif + using caffe::Blob; using caffe::Caffe; using caffe::Net; @@ -304,7 +309,16 @@ int main(int argc, char** argv) { // Run tool or show usage. caffe::GlobalInit(&argc, &argv); if (argc == 2) { - return GetBrewFunction(caffe::string(argv[1]))(); +#ifdef WITH_PYTHON_LAYER + try { +#endif + return GetBrewFunction(caffe::string(argv[1]))(); +#ifdef WITH_PYTHON_LAYER + } catch (bp::error_already_set) { + PyErr_Print(); + return 1; + } +#endif } else { gflags::ShowUsageWithFlagsRestrict(argv[0], "tools/caffe"); } From 977023f171da5ff04253d413f1d2440f22dd510b Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 14 May 2015 22:20:58 -0700 Subject: [PATCH 015/331] [pytest] check that Python receives (correct) exceptions from Python layers --- python/caffe/test/test_python_layer.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/python/caffe/test/test_python_layer.py b/python/caffe/test/test_python_layer.py index 6fba49143bb..46c6e885d53 100644 --- a/python/caffe/test/test_python_layer.py +++ b/python/caffe/test/test_python_layer.py @@ -21,6 +21,13 @@ def backward(self, top, propagate_down, bottom): bottom[0].diff[...] = 10 * top[0].diff +class ExceptionLayer(caffe.Layer): + """A layer for checking exceptions from Python""" + + def setup(self, bottom, top): + raise RuntimeError + + def python_net_file(): with tempfile.NamedTemporaryFile(delete=False) as f: f.write("""name: 'pythonnet' force_backward: true @@ -34,6 +41,16 @@ def python_net_file(): return f.name +def exception_net_file(): + with tempfile.NamedTemporaryFile(delete=False) as f: + f.write("""name: 'pythonnet' force_backward: true + input: 'data' input_shape { dim: 10 dim: 9 dim: 8 } + layer { type: 'Python' name: 'layer' bottom: 'data' top: 'top' + python_param { module: 'test_python_layer' layer: 'ExceptionLayer' } } + """) + return f.name + + class TestPythonLayer(unittest.TestCase): def setUp(self): net_file = python_net_file() @@ -61,3 +78,8 @@ def test_reshape(self): for blob in self.net.blobs.itervalues(): for d in blob.data.shape: self.assertEqual(s, d) + + def test_exception(self): + net_file = exception_net_file() + self.assertRaises(RuntimeError, caffe.Net, net_file, caffe.TEST) + os.remove(net_file) From 749306eb6438b4a09089f785471d1d9cb00b6666 Mon Sep 17 00:00:00 2001 From: Anatoly Baksheev Date: Fri, 15 May 2015 17:39:11 +0300 Subject: [PATCH 016/331] minor fix in cmake.config generation - do not force client libs to include numpy include dirs --- cmake/ConfigGen.cmake | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/cmake/ConfigGen.cmake b/cmake/ConfigGen.cmake index c82047dcc5f..a9101e34350 100644 --- a/cmake/ConfigGen.cmake +++ b/cmake/ConfigGen.cmake @@ -11,6 +11,17 @@ function(caffe_get_current_includes includes_variable) list(FIND current_includes ${PROJECT_BINARY_DIR} __index) list(REMOVE_AT current_includes ${__index}) + # removing numpy includes (since not required for client libs) + set(__toremove "") + foreach(__i ${current_includes}) + if(${__i} MATCHES "python") + list(APPEND __toremove ${__i}) + endif() + endforeach() + if(__toremove) + list(REMOVE_ITEM current_includes ${__toremove}) + endif() + caffe_list_unique(current_includes) set(${includes_variable} ${current_includes} PARENT_SCOPE) endfunction() From 2fed2a998ae8c8894866c9adb4afccc046620c4d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Ram=C3=ADrez?= Date: Mon, 18 May 2015 10:21:44 -0500 Subject: [PATCH 017/331] Update IPython Notebooks to version 4 --- examples/classification.ipynb | 3667 ++++++- examples/detection.ipynb | 9253 +++++++++++++++-- examples/filter_visualization.ipynb | 13754 +++++++++++++++++++++++-- examples/hdf5_classification.ipynb | 7329 +++++++++++-- examples/net_surgery.ipynb | 7231 ++++++++++++- examples/siamese/mnist_siamese.ipynb | 2049 +++- 6 files changed, 39807 insertions(+), 3476 deletions(-) diff --git a/examples/classification.ipynb b/examples/classification.ipynb index 0babf79f304..a76cfb10773 100644 --- a/examples/classification.ipynb +++ b/examples/classification.ipynb @@ -1,397 +1,3342 @@ { - "metadata": { - "description": "Use the pre-trained ImageNet model to classify images with the Python interface.", - "example_name": "ImageNet classification", - "include_in_docs": true, - "priority": 1, - "signature": "sha256:a2b12abaa1eb252f436d59833c08ab97948c8a7a0513197f31afad0a0690e318" - }, - "nbformat": 3, - "nbformat_minor": 0, - "worksheets": [ + "cells": [ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Classifying ImageNet: the instant Caffe way\n", - "===========================================\n", - "\n", - "Caffe has a Python interface, pycaffe, with a `caffe.Net` interface for models. There are both Python and MATLAB interfaces. While this example uses the off-the-shelf Python `caffe.Classifier` interface there is also a MATLAB example at `matlab/caffe/matcaffe_demo.m`.\n", - "\n", - "Before we begin, you must compile Caffe. You should add the Caffe module to your `PYTHONPATH` although this example includes it automatically. If you haven't yet done so, please refer to the [installation instructions](http://caffe.berkeleyvision.org/installation.html). This example uses our pre-trained CaffeNet model, an ILSVRC12 image classifier. You can download it by running `./scripts/download_model_binary.py models/bvlc_reference_caffenet` or let the first step of this example download it for you.\n", - "\n", - "Ready? Let's start." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "\n", - "# Make sure that caffe is on the python path:\n", - "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", - "import sys\n", - "sys.path.insert(0, caffe_root + 'python')\n", - "\n", - "import caffe\n", - "\n", - "# Set the right path to your model definition file, pretrained model weights,\n", - "# and the image you would like to classify.\n", - "MODEL_FILE = '../models/bvlc_reference_caffenet/deploy.prototxt'\n", - "PRETRAINED = '../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'\n", - "IMAGE_FILE = 'images/cat.jpg'\n", - "\n", - "import os\n", - "if not os.path.isfile(PRETRAINED):\n", - " print(\"Downloading pre-trained CaffeNet model...\")\n", - " !../scripts/download_model_binary.py ../models/bvlc_reference_caffenet" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 1 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Loading a network is easy. `caffe.Classifier` takes care of everything. Note the arguments for configuring input preprocessing: mean subtraction switched on by giving a mean array, input channel swapping takes care of mapping RGB into the reference ImageNet model's BGR order, and raw scaling multiplies the feature scale from the input [0,1] to the ImageNet model's [0,255].\n", - "\n", - "We will set the phase to test since we are doing testing, and will first use CPU for the computation." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "caffe.set_mode_cpu()\n", - "net = caffe.Classifier(MODEL_FILE, PRETRAINED,\n", - " mean=np.load(caffe_root + 'python/caffe/imagenet/ilsvrc_2012_mean.npy').mean(1).mean(1),\n", - " channel_swap=(2,1,0),\n", - " raw_scale=255,\n", - " image_dims=(256, 256))" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 2 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's take a look at our example image with Caffe's image loading helper." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "input_image = caffe.io.load_image(IMAGE_FILE)\n", - "plt.imshow(input_image)" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "pyout", - "prompt_number": 3, - "text": [ - "" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAU0AAAEACAYAAAA3NiR2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMcdrwP8F7/c7xJLyUh8AAAAASUVORK5CYII=\n", - "text": [ - "" - ] - } - ], - "prompt_number": 3 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Time to classify. The default is to actually do 10 predictions, cropping the center and corners of the image as well as their mirrored versions, and average over the predictions:" - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "prediction = net.predict([input_image]) # predict takes any number of images, and formats them for the Caffe net automatically\n", - "print 'prediction shape:', prediction[0].shape\n", - "plt.plot(prediction[0])\n", - "print 'predicted class:', prediction[0].argmax()" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "prediction shape: (1000,)\n", - "predicted class: 281\n" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEACAYAAAC+gnFaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nBABgOYIAACxHEACA5QgCALDc/wN1ylfVql6MNwAAAABJRU5ErkJggg==\n", - "text": [ - "" - ] - } - ], - "prompt_number": 4 - }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Classifying ImageNet: the instant Caffe way\n", + "===========================================\n", + "\n", + "Caffe has a Python interface, pycaffe, with a `caffe.Net` interface for models. There are both Python and MATLAB interfaces. While this example uses the off-the-shelf Python `caffe.Classifier` interface there is also a MATLAB example at `matlab/caffe/matcaffe_demo.m`.\n", + "\n", + "Before we begin, you must compile Caffe. You should add the Caffe module to your `PYTHONPATH` although this example includes it automatically. If you haven't yet done so, please refer to the [installation instructions](http://caffe.berkeleyvision.org/installation.html). This example uses our pre-trained CaffeNet model, an ILSVRC12 image classifier. You can download it by running `./scripts/download_model_binary.py models/bvlc_reference_caffenet` or let the first step of this example download it for you.\n", + "\n", + "Ready? Let's start." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Make sure that caffe is on the python path:\n", + "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", + "import sys\n", + "sys.path.insert(0, caffe_root + 'python')\n", + "\n", + "import caffe\n", + "\n", + "# Set the right path to your model definition file, pretrained model weights,\n", + "# and the image you would like to classify.\n", + "MODEL_FILE = '../models/bvlc_reference_caffenet/deploy.prototxt'\n", + "PRETRAINED = '../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'\n", + "IMAGE_FILE = 'images/cat.jpg'\n", + "\n", + "import os\n", + "if not os.path.isfile(PRETRAINED):\n", + " print(\"Downloading pre-trained CaffeNet model...\")\n", + " !../scripts/download_model_binary.py ../models/bvlc_reference_caffenet" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Loading a network is easy. `caffe.Classifier` takes care of everything. Note the arguments for configuring input preprocessing: mean subtraction switched on by giving a mean array, input channel swapping takes care of mapping RGB into the reference ImageNet model's BGR order, and raw scaling multiplies the feature scale from the input [0,1] to the ImageNet model's [0,255].\n", + "\n", + "We will set the phase to test since we are doing testing, and will first use CPU for the computation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "caffe.set_mode_cpu()\n", + "net = caffe.Classifier(MODEL_FILE, PRETRAINED,\n", + " mean=np.load(caffe_root + 'python/caffe/imagenet/ilsvrc_2012_mean.npy').mean(1).mean(1),\n", + " channel_swap=(2,1,0),\n", + " raw_scale=255,\n", + " image_dims=(256, 256))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's take a look at our example image with Caffe's image loading helper." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, "metadata": {}, - "source": [ - "You can see that the prediction is 1000-dimensional, and is pretty sparse.\n", - "\n", - "The predicted class 281 is \"Tabby cat.\" Our pretrained model uses the synset ID ordering of the classes, as listed in `../data/ilsvrc12/synset_words.txt` if you fetch the auxiliary imagenet data by `../data/ilsvrc12/get_ilsvrc_aux.sh`. If you look at the top indices that maximize the prediction score, they are cats, foxes, and other cute mammals. Not unreasonable predictions, right?\n", - "\n", - "Now let's classify by the center crop alone by turning off oversampling. Note that this makes a single input, although if you inspect the model definition prototxt you'll see the network has a batch size of 10. The python wrapper handles batching and padding for you!" - ] + "output_type": "execute_result" }, { - "cell_type": "code", - "collapsed": false, - "input": [ - "prediction = net.predict([input_image], oversample=False)\n", - "print 'prediction shape:', prediction[0].shape\n", - "plt.plot(prediction[0])\n", - "print 'predicted class:', prediction[0].argmax()" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAU0AAAEACAYAAAA3NiR2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvU2sbVt23/UbY8y51t77nHPvfa9euSpVZXAqrthWYgWS\n", + "2MIdPpJITkkE6EAiBAIpoLQQSPRoICEhpEjQwh1EI42AIiQ6ER8xKFG+MEEmUqQkhpjICqRcrirX\n", + "q/fuxzln77XmnGPQGHOfVyahiKWKXiGd0XjvnXfP3WvvteYc8z/+//8YWyIieI7neI7neI5/oNBP\n", + "+w08x3M8x3P8/ymek+ZzPMdzPMdvIp6T5nM8x3M8x28inpPmczzHczzHbyKek+ZzPMdzPMdvIp6T\n", + "5nM8x3M8x28i/qEkzZ//+Z/nx3/8x/nKV77CH//jf/wfxiWe4zme4zk+lZDvt09zjMGP/diP8Wf/\n", + "7J/li1/8Ij/1Uz/Fn/pTf4qf+Imf+H5e5jme4zme41OJ7zvS/MVf/EV+9Ed/lB/5kR+h1sof+SN/\n", + "hD/9p//09/syz/Ecz/Ecn0p835Pm17/+dX74h3/46ecvfelLfP3rX/9+X+Y5nuM5nuNTie970hSR\n", + "7/dLPsdzPMdz/MBE+X6/4Be/+EW+9rWvPf38ta99jS996Uu/4XfssOLb/v2+9HM8x3M8x/clTu8t\n", + "PHy0/X3/7PsuBPXe+bEf+zH+3J/7c3zhC1/gp3/6p/8eIUhE+MLP/ONogBMQgpoSxPxzQwxCBS1C\n", + "GIQ5boqqgIEqRAgCOOT/l/xZAAkQH9AHo+0wBoKjEeCO4hiOCSCDESAKioMHEfluxANEiBCut0o1\n", + "P4OaICK4O+4OBGMEvQWjO/u+M4aDBBE7D99s3Hx+IQLMDJGCiFKKYgalGrUWaq3UWliW/LdZYVkW\n", + "1lqxYpgoRNB753x+5P7xzP3DmfO5sW2NCKdY3juxQEwQBaoSDNQCUUFVKMXyZ1HcAx/OaM62OyEt\n", + "72s+WSIEsLw37nlPXBEpqAaHo1GrUExgBG0TpAu/9r+94zNffkFvsG8bbQ9GF9zzulag1GA9GKUK\n", + "ughlKQigNvAwRjfCFVwYwxEq+Tg6IoFgCPDdyzkiGCGz+gnwQFXBBBS0Cq5B+EBFcAF3J3zQ+4Ch\n", + "MPJ9ehdKAK6UItjRuHlx4ObFLafblfUgHA4r67Gw3hxZ7w78tf/ub/H7/rWfoS6VshaC4LJvnM8X\n", + "Hh8eePP6De/evOXDb3/E/duNvsH2sLHdN3wXGDafc+DdkS4QBn1ABMbAVEACUcUUzGLeTwUCMcdC\n", + "IRQRwyNwhNYdpOAilINQD4VyUtablfUYHG9WSg1KBYmChDLGYLt02uZcHgbbBdpl0M/BuAwujwPf\n", + "Bx997SNuPrjFzPK+K0AQ4lACnXtHRaiHhcN7Ky8+eMXp1YEXN8d83yJEOGM4rQeP7x75+Ftvefxo\n", + "J9xRA7VPXlfNUIQhc7+6IDFYF2E55L4q2hACFUULqDoigxiWa9KdEMOXxl/5E1/j/y01ft+RZimF\n", + "n/u5n+Nnf/ZnGWPwR//oH/37KudaKt4GwUx4QSY9EUQgYgBKhOYfISjg4ij6lDAhkyQB4YA4IYNC\n", + "YDIoq6Gl0M6dPjoxBqaGEIgDEngIoiMToMyNN19cPCDi6VqOgxiiMh9sbkQRYYyBqmNlJqFY88H7\n", + "eb5LBTLxixQEg4DegkAYOhgREIqHEATJdijeYATECLD81L1Bb4K74iPoe6P3garOBBeZwAx0MVAw\n", + "NUZ0tBgqmUyviT9cGCMYw1ENIhaIMW9uefqMIiCihBeg43FmXY6UQ6euhaJC352qxngIIqDtjbY7\n", + "owV9z/cWHojl9a0qYoGZYqpcj79wZXRyHYRAKCqF4aASoDXzofd8FiL5+d0RhGqCXDev5AFiZgzp\n", + "SJnPORyrSo+BAqM5NgZhSmwDcbDN6VtBeyYONuH87pHLw8bjyxM3dwsv34fTqyM3r46cXrxgOazc\n", + "feYOWYJiFY9At9ywIY2tVS7bwuHuiKixbTuH20I7DN69vbA/7EQTdBRkKB4DjQEGJkZ4ZNJUEAlq\n", + "hZDAaq5PJZ+viYFn0lQPRh9zXTaKFRZdnmg1M6MWkLl+Egx0TBfCBVsKSHA5D1rv9A7hQu8dhuT6\n", + "JBAJIgaiiqjgRB7immtHRZBFKTcrL95/xfvvv+LmbqUcSv69ubdaayxR8b1TF2W5FaIHixo+X8s1\n", + "mG/3KaG5Zx5pM/nijqAYg6aDKoao4gwwwU55b0SMKN87LX7fkybAV7/6Vb761a9+718SwSzRjTig\n", + "88ORH1b0mkfzhoRoogTN7B+Rp+v1NMhkm6drELnxuhMMajFuXt4xfGc7X2iXnidRglMsBI+ep5Ab\n", + "EfkqgyAkF18mi0zd4ZEIGZ/XnclTlMiMT4RTl4HQaT1w/2RRMpOh4KgKnussrxtBHw0UejcusbFW\n", + "RWNHCWQoQ5OK7n3QwxnuQKKLNhpqsB4OlCrUGmg13AAdDAYmhooiJjh5yKhmUlYV3EBHPoThAeIQ\n", + "Mp9ZJm7H5mETnI4Lx9tgOQliA4ZgKD2AYkQIexvsO4wdeELsibK1QOj13uQBOno8rY8IRdUYYyRq\n", + "FzIhIBPx8rQGAuhjAFBrQUxAwEVAE9HnQQdhWeGYDELnAYNTVmMfMHygVRg9oARWwS+wD0d6QRDe\n", + "vr7w0BqXccROyp28gMUopwJFqIeKLIbMe9vGeDpwSzXWm8K6wyDwIvS9JRK6ObK/W7j/9oX9sYEb\n", + "oSNzP4rYwEIQCUxjomynmKICGk6ZC1wJ1PLPR0RWSOQzwjTXXR94KKN3iqy5RlBUHTzXd0QmaZeg\n", + "LsZSYWyd3A0xEyLzH3OPQu4hlUR3ZghKVcOWwuF4YFmPrMuBZV04HAqiwnCn957PtIFVYb1Z8OHE\n", + "KHmP5i4UCURyHbhnyaiRFUJ44EM4+0Y3yfuDEB2MzBmqFVOhVAFzQj+FpPkPEjL/qSKEOshEkzbL\n", + "ilBQcORpk43rQ4h4SlT539eNELhDFUUjN10RQ3VAbNSiLDcHeu1c9gt9T7geIWjovI7P12MmP74L\n", + "8SWVEKGEg5RcKD7y/aACkYm6mBAmSIFoC4Ryeu+ClYKpJpKer5mnnoEFEuARiVolMXb4pBw8KKXg\n", + "lkjZfUzkrBwOB9bjymHfGGOw1EpdjLKSi5CBqyIRhAxCZuIXQJU+OohhVsCDEUEbI8+oSITs7vQB\n", + "ogrSMAuWg/DifVhuNqJ21A+MJjiCNzi3TnlhbOcgXAkXEMe0oDYPLQtM9IkS8WAeool4BEMi37tP\n", + "NOnfvZYmGhfJTaPFMBNKrQz6TBx5KAcBcj0AIaJDIWmLAmGB0ykO6gEDYh9ggZNVSvUFaUZcgojO\n", + "6J1gpYnjAl0D1+BHfvcXaTJYrDKGE70zxsCH4zFo0enS0INj4Zg5UQUW0E3QWhi2EEB7O7CuFBNE\n", + "BdOspBhBsSUPqxCqKhIdm9QRVzRPTBQyEqjoRHs2KYlwSih771wuykJgItgslSHmNszDxUywItTV\n", + "6K1Ti9JbJv/lZpnPJaslwpEJKlSUoka1QlkKh+XEoRZKMZZlpZaClGBBGT5orbGzs5SFtRY4rbTm\n", + "TFLuqfLJ9ZlUwPDcWx6DsIBYCFcaTphQXJGYn18NJ5O6VLBSErF9j/jUkmaCJUWAMXeAqE7EJYQp\n", + "KoFcmc4IPCCuvBSfJE8RJcITytdKicAkKNIxDRYzwsFjQxzUnGUxii301pHJYfpwfMRTeafzupFv\n", + "7lrJ4T4QUfoOVgIrExEJ4IqVitqgnhZKPSAiXLbB7atKayMXMgvugjtIZuanUl9nudx6cnKmgscZ\n", + "P8KB/Jn5bNdSqVGAFQTMXib61kS7Ho7rQNhp44IF7JGJIyyImfSxPJ3H2PEqIAY9kZzoYIhjIZiC\n", + "LiCl0hnU96DcDpbbSlaOBY/B/RBcKiMa5WahP+4QA7OSaJyGmKFFn0rJCcbxAI2sGFTyf4RMOK4L\n", + "3R1RY4yGzsSgargPVAUrhmqiDzyTjE80ThTcFYsA2ajacauUUhi649GIIkgRNGCMPHw5G9zm87LN\n", + "6UzKJoKbm5XbuyOn2yNDgt4b22XjR37yi2z3G23PZ3t+PON743x+zeVypp3PtP0NqjvLKowYSBWk\n", + "O+NQGJcLCw3dhU2U9jigTbRkA3VBqkB0ihVkdJLjVbwHVibj75J8ogcWSROFg5NUjlaoy0KilGDz\n", + "Tq2SPKFYrgFJ8OAjiA4SShGlW8dLJxi5R0Q43i6zapqJ0z0Pvh1sAVkLulbKWlELukyeuRi2VpSB\n", + "hFAtEbofhXLZWG+PSZ89XvDBpMUS6EQkZhkek26KWXlO7UNmbTIUrTrRaVI1VuJJpyil8P8l8nx6\n", + "SDOSnwyUrJmumTORg07ElaejZtUmgWEwq0Wd5XnMcpgIRmt4EYp48jMiecqq42MiQXd8DHrvDB/I\n", + "TMSlVsL8u04vwefrf/edlHK9LvhIvsZUQRwtgZWgHhZsFY63hWU1RKB35/FhsF0arXnylCMYzfGW\n", + "5ZGoZVKVeXi40EYnAmrvdDUEo0jBiqUoYZqCilluAjVUoHvnYXtg6xfcdS4qMIzuSQG4CItpJnxA\n", + "SX4UPDedAmoUMYLOUozD8UBI54P3P0Drh/jq1JPz8nDDh6/fsNgtnzt8jm88fHseBj756iyd1RSr\n", + "mgjTcvFqkSREAiRsIlJwyYSeqEWvRWUeXJoHGddKw6CU5EbzYG2UsmR6UxLtzXXm4ZgX1Au+7/TW\n", + "oQRis8asjmqWky12OAyMCj2RsoTRVChm2K2yvLBEiQS9Oful8RgX1JTe79mac7lsbPdvGHGh7Rf2\n", + "2MAiS1frHI6aCL13aAOTQBvUlwkdhnX0Uiie15FZhYnluhZNMfKarCTy8wwfyaGP/FvJD6eeMAZZ\n", + "ZS2V5WTIKqyrUEsKkeG59FMkhNGdvjnnh86+C5dLZ+zbU4KSKciGT6otrpz5YIggA9gbUTM5aVFq\n", + "dbCgmlKXOvn+POiKQCFYa6GvC6MP6J6v1zt1sdzXwBgdCUF1lunzfYcPUJ8rBzx6ygJk0qxLUIpS\n", + "S0U0GL+hjvl741NLmqhkCc5MjoCpPiGCiSvQma8yb11RZUzy//9Rpo/AcbokX+EST6XXVXggBmMm\n", + "TG8d94GZTFRjHI4LrXX2vefvzIQaYYl5NUvXCEekEJHoIyIokjff1mA9GstN5XhbWVflcCyEwPkx\n", + "eHwYXB4b27nR2qBdBu3S8eZJ2GfxDfgk1mEWWIxwKolOTSzLmnV5EkAQmSxB5O8YmAh9zFIzoOMM\n", + "aUhIqoWqeYqFI8WoXRlTUNOqXJmLZTEOp5VYC7UYt3cLn7n9IqfjwtkeaKNxexi8uzQk7nPjemAB\n", + "AyGELL/MU/CxLLVtHprpKsgDIAZoLYgGoYpDCjoB1wyvT/xxJl+1T1wUY3SsMJ0L8w5OukMlGHvD\n", + "ZdAt+V4phg6HklxIrAMxsGQEkTWy7GvC0MBiEFaxCuvLhVE9OWIf7K1j543LpeNjsD1sPD5cOD8+\n", + "4P0xHQJl0HQDazS/oKvNAwJEByYriwh+R1IoRehqxMfg507VAhPtqkyaYUqm10rIiUTskyPOklQZ\n", + "ozM8mLUUVSpWFg43leW2cKgFLYHISKFkCnIqwj6cCKX3oO1B9Cy7e8S87m/c5nGlgOZz8p4Hl1Zj\n", + "Pa1YrZSS/H4EeB/YkodkH0kjKZ6ARBNlsxQuW0ct96EVoTfHPZ72dkSKUzE58YhI54kFBcdKckOi\n", + "nWU5pEtFDWSko+Z7xKeWNEMy70fko3sCciL5mCTRT2j2s6MFF33iD6/8V4RTEcIMCc/Nt3dambwF\n", + "QtVU8ojIE9P9k0SLECMtC5D8zuF4YD2m0HJ+uNB6x2NPK5RADAfRabfJBbt74ApWVpZDpRwGp6Nx\n", + "WIPDTeFwLGgRDkflcNx5fCfcm7JdHBUnuCT/NhJ0p+UmiDYXm6Sdq5jh3hjREQolDhNt8CSSjRjJ\n", + "XclALEux8EzAw53Gmc4l1cZY6VKolKRDYqS1q4BJSWuOOGbCertQqnBT065TS+czLz7L7/itv4Nf\n", + "e/Mr/O1f+zt85Ys/zq/8nb/Nu965XByLI/Q2bWRB8eTqVPI9myWpn44FmRtZkGL4LPcEUCtoKH0S\n", + "vCIQPbL8fqK9PxEgrg4CVU1kOhz3ndECuqNXLgDHqyM1cAt0CUQDOxuyBl47elBsGBKDMMdYGAyO\n", + "y8COJ0oNTAcRjR6F8/meve2MJmwPG5f7C+3hkbZtuDll2bEykkKpG8MajLyeYSx2xEuj2IWVRJ9d\n", + "hNIEzpLKdkvuVmJndJ83oGJy5btzPRZN5biPYPSOSSW0pmvJgsPBkIOiRTFRFikcyoIuSkiH6rTW\n", + "cXZ8DA7HQpNOsVxnQbD3TGii0PqGT+FI5Fqp8aRUO8mHdmAbjRfiRBhmlRAYGoh3+tQXPAaDYIud\n", + "7htCY8QOkVYzIoVH3NHh6LSMJcJ0Rneiz+pUAz0IshSIgmpJkDN51qvw+APLaRIjM2JMFRtJdKSz\n", + "5LiKPpPXCkB6Ehd+tasAV718jIZ5CkCNkYmtgXnB5waN5jBh/ZWQDx/JWV3FHk21eC2Z6A6HyuPD\n", + "hcdto/WRaFWZpWJakCTrAXxA2zqH20P65pbkbZbDwuFYWU4FD+V0e8SWM8FGyMZwp7qiZlkuiVJK\n", + "ydN5xKQRnH0MtHVEEyUMz2tLgaozuYgR6oSk/t9bo3suuK3vNG9PfrlSBGJDLeZSUMIiLV0T1Ys6\n", + "IWDVsLUgFZoGv/23fIHPHo9svvGtb3+D3/87/0V+5oe/wf/6N/9n5L2v8L+//jq3qnzUO92CauAO\n", + "LIGaohqppAqI9kSNCBKJADQEUZ3I9FoiOurTeoMwiMl761RPAw/PezDXz+ipsPY2GHtJKoYrR8p8\n", + "YYgxcl3tqfKKAppcnmrSC0U0S7dDAzOqVqiOLIauyhiN7aK0PfJ+P3YuD432bmfsG9EHIhvlCOut\n", + "oSURFBJIbKgsyQwcrnROPtMuQg1lbEKcY4pIggxJRxiWSr8k7SA4Irk+xp5IawyHMAaKj05gLKcD\n", + "68koZcU0RZUg6KNjPf2zWst0qCw0WtIYUliOh/SO0ogubOdt/p5M3t8JHJWCBnRvqFmaMKZvWNRp\n", + "ozPoNG/s7YxvO8uS1+y9MUba1EZL2iwrvClyxRQNfSTX6mndU7Mnx8eQQdHpwQ2f+UYoRVmXSin2\n", + "G4QuUcVlfM/U9aklTZ8+Sy06b3Au4pjE+xgdsykKiKVyHkGPSJ/dGBRVfDgGFE0exSOQKIQ3ugSP\n", + "rU34n9xGjA0fDfeOBti0OokUcvdMo7RBKcLhcOBwXFgvncvlwrY1tjZo29xtAAxUChLBtjXKo3B7\n", + "d0fg1CWtDHZQyrJSy4HlvRPLek/Eh7QY7L1zu55YygGPTmudPhQfAx87Mgpsg74722hEG3SEWivs\n", + "gdpASqVoIWzgPvAQLm3nvF84b488bI8Eg903rM4DySPft1hSIbO8l6sX6+oIsKQWTOGkynJQpHVe\n", + "2ZHf+ZP/FLYrv/0zX+b27vfwMz/yz/A//MKf4f/4q/85v/fL/xi/8Ou/zDikx/Z83pCaIqBZmYRD\n", + "Jo5UhI+ZrIuiYmkKXyopWUQ+njYdBt+t6k4hr0CiVfEnQa2NgOFEGxhpObqKBOGChzMaRE90G8WJ\n", + "qsk14pk4C1kKSmBK+iSrYBLImrfJbeDhyfH5YL9snB+ddx8/0t/uVDWWopgKVuMToUYLIwaVymp3\n", + "3NzeUauAdc77zo7j0YmtYQeHm4J32NoguiEudM8N371T1Kag6ogpe480t4/OQPDRQQcNoUb6pcti\n", + "T5zkvjfK/IziwEguOBs4sgkgXfRKWQveAquCbB18fJfGkBYyTZYcRxBT6lKwalAFl0GLneYLe2vQ\n", + "glWNEQXV5OhNwLeWHGzkc5PJSUgk/yuRe3vEpOCuGoM5lQWmgFVMcJKes3JkXdd0gJRCqXVSAntW\n", + "pd8jPj31nBQ3+mB6IZlewdzQViRVVsnSSiVPKSQ3gSHQR24gdySSU4pwNAQkOzBa2+iXjnpj0Blt\n", + "J8Y+OTyoJflGjx2TgtkxN7QoIYWQfNAvbeF4WHh4PHMa0PadbQwue08rTfTUskK4PAweHxo3Lw4E\n", + "wlLTnrHUA6flDimV918tiC+If4TxbnbnFIQjrScvs22d7dHYt473nRYP9J6kPlJQFfZ9ENbYtbB4\n", + "ohcXGF3Y28alP7KNgUewj45YLjoTQdWmT81SkY9MnIOs9lTBtFx1OKQrx9sT6+Lc3N5Rjq/4/PEL\n", + "fPlLvxV/vfH2419lffmKP/jVf4vP/fBP8wt/6b/hW5/7NV6fjW++u2dZjjz0dygdvVIdIZSyMq7W\n", + "hPnMy1I4nJLTBFAXvEs2yfhAwhJxTluLePpOccdJOmJIcqkEhCYnnXam7LRxRooCkV7S2CMN/qXh\n", + "CmudZZr4bAzIikQjX98UlIJqZfSBx4bvjb4p9/cX+tvGeNtoPQUtWRUqtL1Te0lDvg9KPXJ7vOXl\n", + "y/c5HVfqakg1tv4er998RPgD+znAHDejEVSpuAShIz3HbsndKwSOaFBMaZGiY0hhdJn7xXCH8/1G\n", + "XQwrhePNTXKYnkKIaf5/d8cJXITQBSc7xmxeWwvEErBoHq4klWOWrzGAUbIjx4pS14Itii5CXZZs\n", + "NAmdNEqW9b11zIy+t7S5tZ029nQXaHYAmRmjd9LZP3NHa6mID5u2oxRnrYBowT33vYizrpX1sLAe\n", + "jLUYIqlpmFZa1O+Zuz49pDnS7iAI4leTakHEP7EZceWnpol5yubCTJSTtzCYvkdBNZK8n5xIzD/r\n", + "YzAi7RfZQTOSIbAAUhmtxZ6UV7OSnq0s5pLnEuF0szK60KpQx+CwFHrb2fZODMcjO0revL5nPQll\n", + "MQ7HQT1m6SlWKFaxVbi9VfyzxuF4w2W7YJZl5RhpnyrbBafTxlXMgt4b3Tt7V5or9ECbU7egnAxq\n", + "cl2+5+LufdA9aOFYKVMsSSKeef9TdU9RRlyTR1VFDFRScAg6g0HbGp9/8RnevXng85/5Erftlr/z\n", + "S7/Cm49+jYfvfJtaFo6fu+N3/b5/ld/ze/8A/8if/I/4r//yn8Hlhnp3w6987R1aKsQnXklXxyXQ\n", + "sEQja+F4c6QsyTWNMdDJ0UU40pUryv/u5gbvPqkLAEdCU+SB9H0yBcSrH4aJOOePfrU2hVKuwiHz\n", + "z53Z3ZKcuE4TOdf1KmndGgO2fWc/N8Yl27hkFDw6wwItBfMs4WXN7qdiJ17cvM/7Lz7g9vaGuq5I\n", + "FfZ9o8gB+A7b43eQ/cJ+DMbB6eekMwh7uo+1LBA7alBPK7oWLAxvg+0hGPeT8x7ZUCEhPJ4b9VhY\n", + "o3EoilSddIfOvXNt5Eihp/fB6Lk+YySFVCLFNa1KXQ3PooAgK0A1RRelLlnBWVXKalACqoMGfexI\n", + "V0bIVO19rvdBa3vqCp5VRhvZpZX0tqAy1/LBaHujR7owxkTbeD5bs0o9rBxPaQNc6srxsLCWkteL\n", + "QMIY3r5n7vr0OE3Ph2C1ZJeCpOBzTRzERA+S6qszH+LszNHZJ83Idjks0aeMTzbjCKaBNzc+I4ne\n", + "LPcdGY73YHfH/AErN1gR1rqS3q+Yfr+rutd5ajfL5ne0DIoaRYXdoc9+8+0cfPThmVIry3rg9rii\n", + "hxUoSBRKqdzeGuJGPR54eHxLaz1vjTuLK37vlMuGXXZUUwhKFAoUZ42A4ughWGrnMLLvO4ZlohXA\n", + "FoSgKAglPWmmaEn0e3UH2DTWm2kqnJCoJUBQNAr76KjAD91+wKFXfvt7P8rf/ut/nXePH2EBN/XA\n", + "/XZh+9XBn/+T/zE/+dP/NH/oX/73OL56j5/7E/8pt+v71GJ4AZGaz0b0iV+8dpUsa+F4WLBiBDui\n", + "0JvinvdnjJ6IEUnVOAQRw0cne5wqk5BJ1VTTf4jMxJdaPN6nNcOnZW1azBhp9XIP1K/qe3aK4TyV\n", + "junnzbkCY0AMy0NqG/jWaJeOdJk+YOjNqcXYtz1bCncwX3hx9xlenD7DzeE9bk93nG5usQIP50cI\n", + "wQfsl8Gb/jHRO3V3ojvS0vWQXtqYB5ywHhdOdyf0JJhku+GlDdo7eHh9xs+JArUa9aRgnTF2RI55\n", + "iMXI9TNdCqIyu5gSPCCOidIh6RuFRQXqVRidcxtm5YJp0hkraJmwsOiT1xgJ3ButAT0PxmseiLiW\n", + "2/lkR+9T4BngKfaN4Skmdke1JsiKhrhPNG+zg0hYl5V1rRwPh+zIWldWs3loOs4O7QfUcmSTe/D9\n", + "jJSSCpqSCASSlwzQ6vQQstcgRRIfYz44R0pQ/CougOosETQXvXkQYQwF1cYwS1IcoyNEG8TeOaO4\n", + "XUAUK2dCVtaoRB34HG5BTP9ZJG84vCcnNmyqvoNSFkTS7LudG+8+3jidjlxewl0o+9mRNXtzl/WA\n", + "vFzgcia0c748QIDIApGlt9pIm4g7Ixr7bA07VAVrVFtY187xFnQFLWPaKwpjgA9FRxq/hcAlBapa\n", + "O1i2syVZmIdEH3NjWCAtu0v6CGo5cVLj4eEB2+F3fekn+ejr3+Dxow9ZxAg1ugifffUB948Xei/8\n", + "rV/8Cyw37/Oz/+y/w9d+/SN+/n/6b1lfHBmSYkWIgQ6izxMeqFU4HoWyDrCsJtRn+2oYLn3mP8s2\n", + "ukhrTY+emzEUdT7pdgoluyolr4kQs0datUz/YCdIIm8EWHNkh2FO1Nm3Lx3X7E4yZuPA7JwKLwyX\n", + "RPbbYGwD3yDcEOk4ua58L+wE6+TkRwsqxs1y5ObVK9774DO8ePmCYiU7uCzovKC1zsP9zrYHizVO\n", + "1nnjZ+7bA/IoyKVMm9lgPS0stwW9Cepp5XCsBMLahX4Hx/cPPJwH/bJDFCwqlB2PQffOEoURG/tG\n", + "OjIk91wtK6LC4iV9n0w6wOLJ70tJ2mdEZNktcxCPZouv2RzEY2mWKprrPGIwRlYZqOe69bRQ9dbT\n", + "XBzCooqr4laQEXRaUuIy76dfe87T0kYUCGhxRqiUpWBVuT0cuD0cOZaVKglg0npos+mmf8/c9elZ\n", + "jnyfiDAVQNFZcj8ZvQLXASOTBggtJjNNijSKQ/Rs51qmy19nt1HIkxXa3RmuhNucmtJxMSANt2NT\n", + "/OzgDRmsCARtAAAgAElEQVSPWWbfCj65l08UthTXR/fkUz2RLmNkyTNVPFEIbSDG+bxxftx58/qB\n", + "m9MtL16s9H1QbUF14WYtk9jOz9xGQ9XoPvuFZRDijPikx/r2xYH1MHAdHA7K6WWlHoUoWfr0lkZw\n", + "ruW2zO4JND9LEepyzIX1hJwTyQ5JZV7EEynIgnrHZUe78uV/9CvUR+OD5Y6/+61fJlXHzt3xltZ3\n", + "3t5vrMfC7c0N3/z4kf/rf/l5ylD+zX/jP+R0+Zj/4m/+Rb51/0Ctgmu2W8YO++zAWtbZ/qm5NoZI\n", + "zh0wJaIlGvdrt3N8cjhOGxpC2pLmShH35MrmPQ7vmcBmqf7JzIJZhSBEd6IVtCjRUoHu4ZSSKOuK\n", + "SmqtU70W+tU4H0LISAQmMS11uc1CheY7qxvsQl93TI4UO3E63PLi7iUffPABPjrNOzymdWg7nzke\n", + "T5z2DZeGSHBTXvGuvuXDb3zMw3lnGdliWQ8L66lk8jyuuDk3NycCo/dGa4VT6+xn5fLYiJ52PilO\n", + "jw2NQHykMyOSJx7e6K0hGMULyFUY2umN3HBLfkovCsw2To90dqxLcsIyRV/NykCQp30l0/+sEbPn\n", + "PEFV74225fssnr3xyMjhLpLDb6JLCqSztVKuA0csoAsegg+nVFhW4+Z05Pbultu7dfqFNd8vzijG\n", + "/vefCPcUn155PgYh8+w3YThPnTbp7+pc+8Bllk3ppEyrjEqOrSo27ceWVpxSCuJpDk+vapL47sDI\n", + "pGmtMGRgutK2ThPJKUj74DGUMc7szVnXjWWtLKt94iec01uyIyEX1xhBDOjj6pcL1CqqQRsbb988\n", + "UmrhsJ44LnfoonQFkywHaq3p/POV/WFn0HPARd+y93bsiDl1hdPNwrokOswxXoV67Gi1ORbLKUXx\n", + "UHwIwVXgSVXViiYpL0tynJqTqRQYdWTpu++0lpOHIpJ77mPjaJWPP/xVftvv/hnefvsdKsG6npIH\n", + "NmeRRA0qha1tfOkzn+fx0rj/5i9RfkX5g//Sv8svfONv8MADodn1cfGg6YDmqBr1VNIjWtIqU1C6\n", + "pxjYe/baf3e0qajmXQfIlsFaKzfHwxTUtlkh5GYlkvtm+BMnep2sk5vYGLvixSk9J0xZrfh4wCyr\n", + "lFzCA29ZxspIe1iQliip2dzgF6Gfn5oucR+0PUveqkdUC3VdORxuOBxvETXWpULfWMeB0Z26HKhL\n", + "lpSDRGRbdG5e3hFeKPGW/aPH2ZUWSBXKsaJVOJ1uoBbWdSV0ZfTO5XHDlkI5dqKD9wk2ypwDoU6t\n", + "lhO9NG1EWYykJYk0VFDGgqrnKMQBIUmDqFi2sorOOQXTLzsV7xR05+i3FlweL/TR5yjDK8c+QUjP\n", + "fUkkIGF4WpF6Guk9YLFCqSkAEvDJZDRAIl0lngNc7u5uuXtxw+m0Po1eTJM7iHcue6MuP6ADO0Yf\n", + "T5N2ZCLM1HImYS8pcrhC9l5lAi0CFk6d8wPTbhMsdZYDGlgkz6n2CZcFOS2lt0GRwjCj2Zhtdxtl\n", + "Wejnwd6D7XEQY6fVQV3aJLCvcx9zEYw5b2NEmuNHS8sJMlArBDmVRkR4e/8OOSjxLXhxukNule7C\n", + "8IEtAUsmEMSIcPq+0bad1s7I9CKaBq/eu+WwVsZoLMvKchrYMrCl0n0wYswSqLL1gUvgmgg0Zktd\n", + "sbQYqU0fnVXMjFIWyhhAx03odbYPSXZTvYwjivCFFx8g0tiaU2UlAmo9pApcChLM6gDO+4X1uHL/\n", + "4Lz5pb/CT/wTX+SP/eF/m3//P/sPuL9JwWu5zA6WCksRahG0xJPtIzwV7D4850o+dUgBksXyJ2P5\n", + "jOHOejjw4sUt77/3ilILb9685fXrj3l4uMfDnoaBgExf8LU1M5FKDGYPclYUNpzLvufAiOFoyefk\n", + "PRNEMk2zUYKBrcZSCvTCWCp9aVzuJ6obOfEpFnjv8IrD8cSyrqyHBZH0SNZ1ReYcz701xhhUKxzr\n", + "gssBr45qowSMsROXlcswtod7aBujVdyDUgt2LGjNTq5kjVfKslJOO/t5m+28OfijjzkZRnsm9YnI\n", + "HXlqSxwRRBmIVdbjCg2iOccbxyOT6/D+VDWqXscOJpqH+bwRfAR+cRxj905ZDanzOn16Z/tgvzTc\n", + "W3LR7knnSA7nMRH20ZKl1jH76XPWREQOTtECxQr1YNzeHTkcj0lRLWtWpSVRlUj6xkf/AeU0cytk\n", + "+SFkyRQMrmZ3tzTj5si1QDTJXiEnpkT4PB2DtQa1+PT3pQl57gmUmq/nadkQM+zKfdiGNUVN6G1A\n", + "KWzbYN+cfR/0NnBf2C5tNpMpUiSRriZ6y0YWnzMKp4dNHSkjrTEWGJX2cOb16Pzdb36d3/ZbV+ql\n", + "54K14HBac+bnvjP2nfP5TO8pHKSAGxxujJvDylJyKLGWkbaNWnFt+O4U0hAeDlYUbZLWIolsYwyn\n", + "xZ6KrCwIimkBsVSEJekMWZMnHb4jmsNdDwJrOfDecsdNVB4+/pgbLdih5tP0nRiK1kMS+aXgbbBv\n", + "O/YqWC+V//Ov/UV+8g/8K/z+n/oL/Pd/43+cLYw5GrBKJoXjsiSnrQKec0WH5+DbffPsmGKq5h6I\n", + "lqfrhcNyKNze3fDy1S3H08pxWXl5e+KDD17xne98h29/+BHnyzbR6bUrLFFVQIp7qkm7tDm1qCjV\n", + "jL515uSXXI+aqNZj5EEkUCqs64Hb5cAit7Rd2S8b928eeff6zP39DqYcTwq1c7q94XS8RTG2fWM5\n", + "Lextp/fOvu88PNxz2R4QOoe1EEvlfGmsGAdZWPVA2St+vmdvDwTBeNzwF6d8TxROp2MCCM3Zouth\n", + "obbKflh4OKclz0ebFVrgUVHNIdDi/kRtiKcAqnJAerLAbopYzdkNVhJZzohJKfXeuZx39r2x7+Np\n", + "zGIO4pYUxlBa7Fhkg4dEosrRB96zStDIqnP39GZqUTyViXRWkKwIZF4ID4oIKsrN7YHT6Zb1aJRV\n", + "WQ9lzj8wsGn4bx13aO0HVD3/xFwtaQVi5Cg1zSnp0ixV1atZOdLRr5aw3FBMB0s1ShnUIpgFWJ/J\n", + "LHuzr3PVDKDniTNc2fpgsYWxdawavhleB1I6WgKisKwLpeQEpcfLzn7pKeTo7MCxMk3Wyal136lr\n", + "JUkVsCW9oqFO2zZ6DL718Yf80Oc/4OXhkEZ8qeyXC2WtjP2Rbb9w2c70FhCCSaGWLBnWY6GaUWxk\n", + "H+0sZ5qnr82jTZ6OXGhYDkNhGo/JMreNQWhnpWZJGRAaDOlYUYqmN9Vpc5EoL25vKBfjy7/ld8C3\n", + "hLt6YHt4pB7WLOE054TevXrBxx9/hPeWNhSUr3/9V/mhz36Z9fwhb//6X+IP/8F/nb/8N/8i3ZXG\n", + "QyIigXWxnA0pyb9ezWe956Tx60H5NFVPZQ7mzYnd9Vi5u7nh1csbbm6OqcKvhplxPKSvdWuNfd/p\n", + "Pd0CwnWKj0x6NysTF52dQpr8Y3VKU9ymYMl1jmpWQMigLJWDrhzWE3eHWw71hqWcGA6PH1/48Nuv\n", + "+fZHr1EbHN8rHF/d8uLlC+7ubvPAD6HtO+7Ctu28ffOOd2/f8e7+Na0/Um0lUEyDoZn0rRq3L+6I\n", + "XbDYuNw/Evtge7dRj5V6WukjgYea5VDiqhxKpdQch7bV5PEul8s0sE8PrCYqL2SjQ04eWlOk1exl\n", + "t9WmUi6ILIlLp1Yh02UQwzmd8gC9v7+wXXb2ts/uuizbr7NSfXeipBIeIzuCZAPYYXaQpQ+0oHPY\n", + "ycApcwBvG+PJ76vzWxFuDyeOxxOvXr1gXVaWo2FV0/5lqSkMz4aRFER/QJGmj45IycEMRRmRfkui\n", + "Jt+Rhro0LwvgWW6L7FgoGg3F0BhpXrUxOREy2czBD3MOzjRx56i0ll4kpKV5e3RhWBL+DeH2cORw\n", + "OFFsdiaUnBR+ebzw9s0Db17fs507Rk/BNkp2hOqVxNbs+RafbX7JZVUMH43X9x9zOn1uztXsqTz7\n", + "YPSd7fHMtu2Mnh41s0JZjPVQONSKlZz5V6bYpFVpTRk9T/wY+ZUbY8tNj4wcvzY0v+IghOaN4bOT\n", + "IwrLkgR8XWT2mRuiwaEe8++P7D3+0c/9BF+qX+ax/938Co6b0xwiHUg4TYPXbx6AlXZ5xzG/f4HP\n", + "fvB5Hi7fpK7v8+4bv8wPff738y/83j/Af/VX/zxvR1qCFiss5TpUSfF0lNC60z0TepROFaNb2oWC\n", + "wFsSbOoNZ2M93fHi9pZDNQ51Qc1YjyvVDIrycH/P23fvGPc76ehVcjao0XOZZVurCuhC7w3tig4l\n", + "6GlZMsdKKsjZu5hVyEEX6nLDq/d/iLvbG16sL6aQZoyXzvuvXvDZ+5d85/W3sdX47Puf4eble6y3\n", + "K0Kjj0LZO/ulcf9w4e3rd3z00Xd4/fARgrPW4HicIxMt2GfydFFqNWQ90B5StNk+OqPrgtR7mjin\n", + "21uMPue51vQDke6UOpgT/+fEKYzer5a7q8CqmOdXiuTwlIqxULUg6khMblAmDz77uNPGk8ffuhZK\n", + "OXHZCvePxuM5u/PC95wd6qlpjL4TfXB5POM9hwgXGSwL1BIsy0IplXWtLMuCLalh9HC6j8wt4U9J\n", + "9VRvuL25Y11XXty+pC7G4XBANfn9ER0L5RI508H5Ae0Iuk5d1+tT0FSiPQRkmp9jzgGUVMJGTB/j\n", + "FAnSAjS9dpITjuY3xeRF4koOJ/yaQme2iIlyKNlto0L2FYuyHBbWdU2Or1RqKdRSMV3Y98bdi3tO\n", + "tx/z0YevuTyc6Z6nk7iglr3P3jvesmUudqEV4bgYx0Oin/P2Fi2vsFoJCbrkIInNd7p3RmvM1g4g\n", + "DwA1zQEMlZwl6UlXjFAue6c/jfDKBKo6UfbQVIs9h8z24TkZvu3IKsgxv8bCloXR82suiBVc6OMd\n", + "WoTb21t077w+v0XLhm0N5zqCbo7iGjmI4d2bD/nsZ36Yh95n947zcP+O4+nA/bt36M2R7fU3+ee+\n", + "+sf4X375l3j75g03dzcMyQpBMa6DUXRaVpxHaknk7D3QEYSkn1RqtsbJUNpwzucNPiOU4xGryvGQ\n", + "ooSp8uLFgQ8+95LH7Z5vje8kVxZpbxsC6PUrD3TylDlBx2PktPAROS1I8neK1Uyk85BcS+Vwd+Du\n", + "xYn37t7n7sUdh+OJ0oz7hweWg1AfC7fvHXHpvHjvFasV9svGUlf2Lb9ZYL888u7dW968+YjH+zf0\n", + "7ZGtbVzsQu+DQz3gvdFDszWydHacy0gSSfzAdhm8/vV7usP7ZaWXHbMDZXa72PySnVEDjTa/miXY\n", + "tj7tO9k549OcWgRQzf3lmQTTHZB7K+Q6jm9OLpC04F2/qWAE00+qHE8rUrLH+3IZ9CHZreZz8n7f\n", + "aXtntJH2sJ4zMKPlvpXIr4qp9cjt7Q2nwytKBZeNbey07SEPAEBLYVFjXRdOpxN1LSyHhbCYQ2EC\n", + "xmDrF1pv89/fWz7/FAd2ZNuAzgHCXGf9jUC0409TaHKAwtWAPCS/U8eM2Zs98E52fkzbjuic3Dx5\n", + "bUiofp2TF0ROCxqwrjkcIJozKpSysKwHii0c1jW/6KwsKOl7XA7r5EQWXn/4joe3Z9plRy0ntbh+\n", + "ktDpc4I5QSmV42lhvalYce7PH3O73GElT+Y2bR4RSXDHSNEjSXNNFXUtOXE9AmYPbW+dy2VLq5AH\n", + "MYxxnbcYQrVC77nZcUVcKFa4tAtEQ9iyfAtlWXJQyPAN3LG2sNO4XDqrD17e/hCXX9/SMjJycIRa\n", + "nVPAgzF2TssC4dzcvZptjZ398SMez4NSKr/6jW8jy1/jK+99jj/0T/7z/PJ/+Z9wLEZjfjeQ/t/M\n", + "vcuvbetZ5vd7v9sYY17W2nvt29nn+HCOC4gNGENFhIJAJaTAlCJVLKxE0KBBC/EfQJOuaaeRTlDk\n", + "VhR6oZGUCClBJKSSowJUVCqYMhj7HNt7n3P23us25xjju6bxfnNtV2GIlMgyq2Nr2WvtteYa8/ve\n", + "y/P8Hs23sdYgtZGybmpraXhpJKk0Y+54BDStZoI4Uq4cDgtXN1ec398zDIFh0FZOrEYzhOB49PiC\n", + "ahvXr266r1pfr9YXFjnmTp8bKHXFGkixUF3FB1TErdPDO9mSbWqw8N4xhMD5/fucPzjDe4+tlrAd\n", + "uPEWDgYfPc4Z9puJQQxnxtFiobXMsi5c31xze3vD4XDF7e0VS7phSQsihnlZ2O/u6Wyx6u9caiEJ\n", + "OpvOlVrVEz5fZzARP80M06hRGl5Uyubc6+24Bawhi/q+aiukmulNtrb2rqPoRNkQphs/dGTiVePb\n", + "dC4u5cQiNd1VhUqIOlQG0wgDnLEhBMfN8UiNSlEqRa2cNYFUreItDpXtV4wNeLdhu92xmzZshq0C\n", + "xZ3Hmi17L1hTqCgDoLSEM6qmGKcR5x1uUFB1k9pdXFFxeSV2Tei3LBu/zcd379BEy/4iXXFXdb7k\n", + "WtJivvVApqpOnrvjr/Uf2UdIunhpqVIdd7MRbZlVx1V74pLeiKYvPPTw8Bo2o5s40zfiRgjOstls\n", + "GYeRcRxx1iuBKOuhaZ3BMWBQPt9xbiTNgcCJVShAFjBOHQ6dwBO65GHYO1YRQo440YNxXSNxrup0\n", + "qk33EDkT46qZLs6S1qhwXhJiEo1MzpUcE615qlFDgDRdojhjkGI1tbAKOVrEWZzViAINY1PPvCaO\n", + "BBoRJqE0YbAB4zakCO9sn7CPF0w1cYNWsH5w6sqqpwvLYGzg8vaSabNhubnCecMwnVFqphwzbz15\n", + "g+XmwOHrX+Znf/zn+Bf/4n/ha+19nNsCq3YBFqDqa+gjdUkwVmqquGpQ3bNu6FNqSHVE0diMdV14\n", + "eXXFk/IGD8IG4516tmuiWgFfkFDZbhzN7YhJcWLGwJp01umyypJqq6TVUYpeUp0fBO1kvdRZMqeq\n", + "DDBVl0Zhb5jOBzZ+UKfbMCo9R1aIG87DxGZNPGSkvYqsQVGGLIklZYiZ4/UVx/mS1BJLnBFjiC2D\n", + "E0Z/hqnKnKxZPfRNoHpHWbJ+ThzXlzPNw+ZsD64gJlGKZbMdddTjlTamDjHbLzpNIzDdDeYkqGrh\n", + "5MrpTh/bCrY1SrIKuqgOkYwRjWDxQWf76uvuyz0xVGlY8QTPHf9gdiuHw1GXrwlaRN1+uZFlxuUB\n", + "2ViaNUzjxHbYMQ0bvB3V3STKkQ120FmtrWRWirFIUadbk4IPAw6Hb5aSC/lUqORMy0pAq+Xv6UwT\n", + "6SFZdz+fOgyaaCWoriClT3N3WylcNiZBYqF1ISum4Tps2HWFlo6aNGa2S167hks3cIVKNeofdlZh\n", + "DtI028d5Sxgs+/OJadqrjtFoBoqde3RGUslQKklv6Vw4wZGbvE4/zK2oyrp5gtsx+R1TCNigyyuR\n", + "QsxJt/ZLJSZ9E7QsrMtKyqsuSky7A8giEbGJWpR2k4tTDmHWxcXrWbGnpEyNQop6SbUCcS1amlt9\n", + "bZwoHCVWVSzkagnWUMUxsiWII7cNm+0F66uEkw5wreC869pGo1HJphKCZ5y2WoVSqcvCZr+l5Myz\n", + "D56x22z42p//Gf/g0Rv8V//0v+R/+Of/PTkEmmtQhdKxXsYUjFSVeVV18ogDk/tle9JoGkGauoOs\n", + "sVzPt3zt2ftsxu9hkj7/kaa8gyD4yTIyQBQQ3RLT41IUM1gpuRGXSkr6+doyyaQ7HW6tpcdJvO6W\n", + "StKDywendHqr9POCpaaFbbDkJvy4e4N7a+DcT9w3AYwQpTIvK7Oc8X+t7/PR7XNujrfUZkirLvhy\n", + "rXqpmRulU2WV7RRRDmVsC5nS/45e9Ze1cvvBDS/GAevvs8aEn1RY7oMCoXWsk/DekrOhFqPmg6Tp\n", + "nCLd107/9UXu9K+mGorM6oTqCg3bVLLlB8846Pxd7xYtairaPRlrcALDIBgzUGMmL4WYViiJlrTD\n", + "yAWS0UA6v6E7fYI6sbLR9FfjcE4BIPr3qV1t+FqLLKKwYrFJ30cN/bvGQkyJuKQOxLF/59H13Ztp\n", + "dlfBqY3WNqeTb/rMpIOsdTrfK02kUpKhdIFwSXRBr27VSq5Iy9Seoy5NEyJbvROVUKRiWve1287x\n", + "FEczSiy3HvxgmTYT27MN3o2KGUsKBcmxMK6BKY5s4uaO1g3ST2W1Iqa06OwxeLwdsAw4ExjchA0W\n", + "ZxulLpS8klMhRo3CyOtCSYa0rJSTfdScqC0ZMYma9WbPWR/BlAo0qy16zrTciEbjjktUgIG3VgXK\n", + "0jiFyRlRupK1SnhxNuDMhLUBa7eYbHnw6IKyWDx7xHxEWTOjm4g10woKOult2zyvuOC5ubzGjBta\n", + "jkzW8uryFTUlHj96wBJX9tvMB1/6E37ox36G+//b/8jNEClOFxDS89RrLd0e2bBapLD2zWjlhOzQ\n", + "w7vQ8M7gnM6xrg4vef+F58mDM7y3Pa4WsJZpPyC+4qJQxTBYi3T/sRFHyY2SE/MSiVEp/mldOKQG\n", + "vtBM6iqP8vq5pFE6UKRVJZqvy8xgLRbLRZnYfCTcT9/DVC2JzM37H7B6SxHYuYFxN7ELZ3zv/glf\n", + "+uAveGAGbuZKapZYI82IitPXWxpgm7rLytooR0OqhbVkltyQRVtrki56Pnr/JdP5xHDuqXXVgz5l\n", + "CILYQqPrjBXiRm2nw1SzwRGj0SFND8ZhHMA7ciwsOWGDskpjKhzXhMSFdJOZRs9uF9gOk2o+OyRY\n", + "22n9G3svCI7gJ4ZQSUtiTUKLalWt2WqFLVCvIZgZbzcIXuVqhm5kad1YYMBqvIzUih8HctKteLFV\n", + "x/xiaU3HW3FJzMeF5Rh11FW+g4ugd999l7OzM83Z8J4vfvGLvHz5kl/6pV/iq1/9Ku+++y6/8zu/\n", + "w7179/7G175OlNSbrJHVR9zpJpos2a1xfQcuIrgGjUpJFuO7dMQ14qr/L+8btVq1OJ4KPqldSdJd\n", + "H01Uw9lEgQp9aH0X7Gb00LRGfaw+iEJ4s0Ir3OIxIeCCxzlPGAaMtZ3TWDFOISRYj2uVYQgEO1Gy\n", + "Ja6OtDpdAlkV6qYFak6QTNcjJtZZ9W1VNN9kjSpPkl4VlmKp1ai8qTVsseSi1ViJ6n/OUgk+3AnC\n", + "a+1hal23ak19DZ9wJwG/J4wDQ9jiTGBqgfUIb5w/oBwPpNaIWTAlUoyiuaydsHgMlhAiYhWovJ0m\n", + "lqWCEwYvxPnAMs/s7p+zpIS/PTB88+v83D/6z/jn/+6PWK0jsZJboqRIMVEF/6iQvORCzoaUWgf9\n", + "0mVDMA5CmCy4SrADYhu3x2umyTKNI6hXgmBaz6HRUUtqeoFaa7E24K2CQYQ9rQrLvHJ7ODLHhU0Z\n", + "WeLCXG4xJkFLOkaSrhuVSklJM97XSEuV+fLAxa3jwYeCuy0cb2+4LZDXqCvLWQ/cZ/kV/iPL2+++\n", + "y/c9/h5+4KO3uXl+xY0zxCVpR6axkrQmpLqSciJHS02ZWAbmrAtJyR3S3XkCCUtd4OrFFQ/HM5oz\n", + "HOOqxPKm443aL9ySiy4N+6IIUR2rsV2mIxZnjZLWq4XNwJALcU0cjwu2CdNk77KominMecUNgc12\n", + "o6yDlElrImW1DFNs/zcrwUAwCpyJUS2STVYqwjpXYm6YfKlR2wnqturys2TCoNI8qRYxuduZNdrE\n", + "ekcq2n6nfpaczqHjcSHOibgWUhJS/A7qNEWEP/iDP+Di4uLuc5///Of5zGc+w6//+q/zW7/1W3z+\n", + "85/n85///N/6PU4kZv3oOSdCnxudQLP1TsogTdl+NMHkRk4qNA4SqCYrDKJKX8a0u2zj/gPTR9HK\n", + "6qz6uRNlqVUQr5xJgFpXWvVggjobMD21TrOAELo9TN90rudoG6cVjLGRXArjtGU7brStzUJZofju\n", + "UCpCOhrijOaxx0ZaK+sSaTT9Xn2EscwrPnh9fcTTTg95s0rYKfSZkA7Sa4/EoGenJDTATBoqwDf9\n", + "EO6vs8pLBCtaDQ9up5KvJhjjGMQyGk8LmbYqbanagmGhOYcxuvAyVqt2kcJmuyEVsK0xjXpYHG9u\n", + "GaaRq5tr7t0842d/8rP82Xt/ydfSh+SSya3orLaIuoBSoyyVtBby0sgLULyObkzDDuC8vaPpYDQW\n", + "pKyJ25sbUkyEweKCUHGEfpkMwZNbRw6ekgC8I5gJjF6qwzjihsBUVtbllmUNuBlSOWCcJebYyVkC\n", + "RRcjKUdiysiHkfuz5+0bwVwduKwLU9OkRusnrOjfJcaVIJ64rnz5L/4d319/mB98+in+zasvs66X\n", + "FGuRJp0/UJWfWbqBoSVNAfWNMBmW65XctG03RSU3tRsv1nUlpoStXp+JpAckXWwOkHOjVas6FG2a\n", + "OiZQ7Z4h6ILUOafs0aIFScqFfdxwezgwHw/Eoh2QGMFbr9W5JKbdRE5WUw1it0hK6amf0iNQFCNX\n", + "cyPmiNCjb1rGtsIyF25upG/3E7mMrEvGByEEh5/UVolJ+NGSOvaN1rrRRTPVQYXsy7IS55V1jeSU\n", + "KMt3eHt+8u6ePn73d3+XP/zDPwTgV37lV/iZn/mZb3tont6s3/phbNOZAkKp33LYwWvBqVJU+x8d\n", + "shSsbRQXkbU7Tq15LTru3unW5yxqdQPQf79CR3wBVlP4bBfcGltAMrlGyEYPpZyhFRoJPXVLt1bS\n", + "ZUfqMDLG6h97njFiGMcJEU/JaArlbKmmcZyPzIfMfCzkJTHPmbQUzdWxRl+HouJbZyykohCPTnCp\n", + "ySjdJau+sOZKjZpPXkpDSHeD7VrBe/Martv/DrXWOyzfaRZk7cQwTDRv8VVIMbPcrNTrhZVMKIYY\n", + "Mz4YzWfCd7NMxroADY5x5d75A24ub/FFBdvkhB0t8zLz8Pycj97/Ovff/FF+4lM/ydf+j/+JabAc\n", + "Y6T2A3NdM3Ut5LlqJbCo2L1mBT8Yo8utagHJONFlTy7Kxb28vmYcItPkGEZL9pZWR3VWiWpwDUo4\n", + "z7lSKrjB4MWQe8bMtJ3YuZFlCdwebjAG5iiUfGCps87aa2XrNXfGN4t/duRxGfjeFlhc5mAaZ5wx\n", + "S2UYJw7zwmR9lxBN1LyqQkwKV69eYt/c8Or2JZoHRReC96F8Fc1Ql0IVD07hNrEmTFAgS4eIdcfd\n", + "CZD6p0IAACAASURBVDoNa0yEbGhJ1FhCz0/vmVf6uqMSoqoXrHilrofRM00j3oZupqg40SXMzjpq\n", + "buzTxHHZcnV7w7zOtFqY/IgfAlI1Q8iEgSEMuGMk20ReGrFFSk19G68W0CirFilNM6tM0B2GNZZl\n", + "nSmXmeNyrQzXcSCMls12wE+DBhsOhtCEIXhFyrU+jhO6wSF3t9JCXldiWslrgfU72J6LCD/3cz+H\n", + "tZZf+7Vf41d/9Vd5/vw5T548AeDJkyc8f/78237ta1be6Zv1P7DIXctzIhrd2d1EKE3FxQa135mm\n", + "by6J+i6pJx1dVt95NjrrFBFqUjSYc55SFbTbEJWcSMZIo4lDpCAtU2RPrhXmmep6NOs6M6cDS5qZ\n", + "8y2prORYAX2w9LDUnJIGhOBZ40KxaMpfc8S1YGRFjHBcGtc3M2kuxHVlXVeVt1RdfkjVw9qIoRjd\n", + "IOv87UQ9cuS10LJmFOWssaynJM2c1v6Aa5a1uKAxp8WQ14R3iSpCjJkmVk0CywHrrxiGDZs2EazD\n", + "JmCtuGnicHmlrg0nHNZbgjOUYjRDSCZSg1YL66sDh5eXOGtYBEzVWNpcDdthIObG/uycD//ij/mR\n", + "T/ww/3L7v/OX6ZZUEsc4M8+FNmfirJKpnKXbS4umI3Zhdblr84RSBEkD2MZcBSOZeT1C81hGbDVU\n", + "pwsHR0XEkkwiZzU9uGYoxmgkgwjWgbc6F7fOM40T1hnCYpkXT8yRVBe25owQduzsxIOD8CO7e3xc\n", + "7rHUxHqzMPiBYhrBGHKMnE8bWhWsUe5jEcveTxxuEzfpmrfDW+yGLeG4IGsiUfBioTikQnWQS8M2\n", + "9Xnr4ee7vrLhTO0wDkHGwjCNWGewZFpxd/nnxjqtkpshlwIUvPEdmA1iqrpovFM1iDW4UQEvKmwX\n", + "RJTKXhoEE/DREvaWnHfknDEoE5QMGGEQHb/JJFTRzitTcK4RPKSTWcVrp+hcn7sbcM5SpFCaKIz7\n", + "NgOXuGDY7LesbceGQMaTimVNwuId3ulyznm1YueUe9RyJMeiFW9s5Hmlxu+g5OiP/uiPePr0KR9+\n", + "+CGf+cxn+OQnP/nv/e+vqTF/80PUmdXlHHInST+146f5+ikgS4QOF+3kI6NfUUrFVukar0YxWpkZ\n", + "V1WqYw0l65JCNYB6sLSTLMk6rBXls58I8U1L+JRXTLLUatX/nArH+cC8HJnna+bllmWZoViMBJp5\n", + "veVXH6ySgmoqLMvMZtiQUiQ3bcucc/0Pp8No1ahJH1r3oLc+kC+iW2X1vBdUK2UoTQ+UtqpUKcUe\n", + "W1o1N8VZXdJ4EUarC58UEw5oXn2/YswdNCWiVcmRW47+gN84gqn4PGKrkHIilcyaMmEwTNsdN8st\n", + "U0uEOoDxiHVs9+dszy6IaWY77ri6ecE0Om5vrrm5veb6VeKNh4+Qltm9NTGlmf/6P/9l/tv/+b+j\n", + "lMIyQ1qgLEarqtylUaJtaSlZ27NiNPrCKoW+iHYh1itGLFfUd2kaDs8YLC0LJVaKqVhbiKmwxEQs\n", + "mqMtxdB8xY2eWqF0o4A0dVtJM+w2e4ILrGVFZsuZ3+M2W+5lwz+e3uZiuCAXmDtb0tlBnUbe9+RP\n", + "hdUogDnjXGBZCyE4lpLwBDYMKtGxFltQJxuCcQaKYDyctJPQKDWrFdkaNYJUARzOC2Fy+NFgBw3P\n", + "Q4yqRlrvztAMoFpPIy3N+LHO9feqUEoCRnJdGYYRNzjcCZhCwxudt4vZ4LxTYlaHd6SYVKhewVbB\n", + "Wc8QBuDAvC60RZdR08ZTbVWr4xhZDlFjqF3f9tNwOEXxlUbOTQ0RTmfRy3LEONXLRlJfZilL1omn\n", + "lKasziqdnJXJJVFqZZkzyzFRv5OV5tOnTwF49OgRn/vc5/jiF7/IkydPePbsGW+88Qbf/OY3efz4\n", + "8bf92stnrwDtNqbdyLAbUT3layvWa2xXu2sjT8sjWu6pg1p1lOI07a81Vgq+GcV1me7LLk1th8Zg\n", + "bNX5lxX0+hMQreAQIeXMklaIQpOgiYhZWJaVNR5Z1iNrPJLyrJj+asA0Wgl3F0XL6qbQxVbhcLhh\n", + "M20VZpwaxs6a19wiKa+sKdFK1SqqNUrJuuHsc9fT5VOMEulVGpMxTbFcJXU1QtVWrhbNvs654Jpm\n", + "zojoaxKs5qUIQkmZbBO1VWUmjlsMBmlHrl6+oK0Jxj3b4QzTImtcwBnScSGnwjhZvudjH+ODZ89Y\n", + "0g3jMBHCfVJSSc5mdw/xgfvT2NmNG26vn2N8YH9+xhoLKcPh+Ue8/R/9Q3783U9z/ef/Nx/MN7QI\n", + "u805t7c3Cg2WqJiraoAeGytqlz3NEyv639MSSbkgJVJz5tg0B3232TC6iRIrkQhtJRY4zImr2wNi\n", + "Mvv9ljBqhowbBoLPTKOCoNUVr4F+Dstu2rO3E/th4o068Zk3f5S93TOvM740hmYhBGpT6DT03CVR\n", + "SIRzWq3pZWg41JlgGhu74dH5Y/7s+AxrvEZIVLUnnuqgE6mpIYjR7J1sKhk1SEgGsa0nllb85PU5\n", + "NaghoZk+H9ffp5TC66m/3DmfWqtahRYhpqiyryK4ZmlOR1Kuazg1rNUQ/EjWLRclFfzgKKlCM0hS\n", + "DTVFCFNgiIFcArRMzTAFlUs1Wxi3E0LpqLnOSejjqrhWrC+YqtCY1jKlrqpZbplgQ1d13Dlf7l6z\n", + "lBIpJXKO1Fp5/tdXfPhXt+RcqPE7BCE+Ho+UUtjv9xwOB37v936P3/zN3+Szn/0sX/jCF/iN3/gN\n", + "vvCFL/ALv/AL3/br7795djeiAdSqJiqmPX3uDlD6H1SrmvJraDZjUIlSqRWyg1qpNlNXOsFEeh4R\n", + "1B745O4eDEOvb/UQrSpizjWyRGg2U9vAYi22GWKMrHHVLOaaMJ1mVNbaIxIKxkxajUiPR2hCSUJm\n", + "5uXVM7abneY7o/zA0jJrXllTpKZEzYVcix5+rUFfzuil0cgov1Oquo5qLf1BquSiF4ARnWFq6p4+\n", + "zCCkjuRqtYDXaly67CPGhKRCyer3jqtWx9fHW4bdO2zfHmn2QBZDrTD4wDzfssyZr/71e3zqhz/F\n", + "+1/7K26uL1lyxQ8b5sMVu/MLzh89ZTMGrq5eYa3j/OyCZZ55/uwDLh494ZvPvsHTx+fYv/5Lfuan\n", + "/xn/65/8MW4WHm7P+XC+YTAWPwwUJ0jSeW1PG1G5eYNWtQuJKSFkUk56yJSTzS9xc3Xk3v2MjBaa\n", + "oSZlBaRUSEvh6sUNl7cvOD/fst9tcYMwbUe2uy15u6FVheJmKqVlBhF2ZsO0sTyInp9959O80SZu\n", + "jwuSM1WUFlSoDNMWQQPdTprBahumVYZh1AurwWAKh+XA9dVLdkFVBiOGZB3WCElS15UqDCXVokAN\n", + "U2miF6W601RGl2vEhgk7DVRfcWFg8K8XgLYrm2vTrbyzHim6CBWULGSD0c25reSyIPOIUEFmNpuK\n", + "9VtCCORatGNzhULGi6cUNTzU0sPYGt262JSiZRvDOOjrmjLZqMSsxcKwV0K7GBX+16Yjt5Z7jIjV\n", + "51WqoVWnQBJbVS0jBeuaOrJ6mCC9u5XqNTynRV0sp8b5oy2bzUg8JuIx8t6Xbv7Ws+//86H5/Plz\n", + "Pve5zwE6P/vlX/5lfv7nf54f+7Ef4xd/8Rf57d/+7TvJ0bf76J0sp0xzK2jVKGic6re056elDWiL\n", + "3i9HGtLnMbpRTC1jvGCLdPCCCsuNMTin8y7ndYBtG5r/glXnUGl3ede1ZlIWTH9TeR/0Ae3i59YK\n", + "4xheB2nVqJktNHJZFQTRFJNVWwKJ0IQ1rgoiMbn74BVmvCwzKS7qta1Va5keACdNBf1VDA3bIQiN\n", + "FCPG+O4QUjtYw6hFDpVlqQhAgRi5rEjzlKaREnpfFBrSWZX6b+cIccmMPlGHLWVqTFPlgZ94hVCL\n", + "UFUXDMZSa8YCf/rH/yef+MQPcHtcsEH9vc4Gbg5HLm/+kuAd5/strWbiqmg2v9lxefmCN54+4OZq\n", + "5vw88cbFY/7Jp36SP/q3/4rnty8YmiV34PTAlmpusUVVB6XnydSSVVtZdBsc/EQrleAEcRXjCsJE\n", + "KZlliZRRC6zcMrWVO/J7nBeOlzfUw8K6P+p22hu2+w2PHj1inEZtNaVhqWyGkdYMj2vgc29/miFO\n", + "xDhD0xnldrNVa3ATmjgN9rJdPmd0gSc16xtZrRq6SGzCMkemYSRYhY2IFHKacVbI0lmp1K6RBZOF\n", + "MAlpThSbSM4gTnFw45nHDgVnNeu79vddKZVq9eIsuWBFwcEVjc5Ver6WGEY8wWh4fa3CIR+otxnY\n", + "E/xW8YFu0N/XFJodqV0dkOaF2hrFaMpqq9rV1FzJMeqi1SbCKBjriCWpzM/aHgtv+7Kykis4qwFy\n", + "0rGPLVusCYTRYfxJQ5vIWT3nxkgPxItaYFRNXC3VkqqqTuJaybGyLJXj4TtUaX784x/nT//0T//G\n", + "5y8uLvj93//9/9evrwKmtf7mPekoe0tgu9ZSTg4EFd2eYi8a+qZvBrJpOow+fd+iiYJyCoWyRoPi\n", + "S8UanYU5Z7A2K1PPgh+LDve71ar17Jic9UAquY8F+qLKOxWA6sxRMMWyrqdZYqbQNG60mbufVcdG\n", + "lRhvaWRSU72kob/Z+7ZTsOoRb4Kp+gJI36DrBqBSS69eOxbtpEmqFhpaVZ9uHenieDGNTjygWgtS\n", + "lEcqXd6TpcNdoZL1FouWkhqPvu8cYiHmqhlMElX0WDu/Uyrb7RnvvfdN3nz6vdzcHkA8GcfZ2YgV\n", + "dS6VmDnMt4xjUCjDmrCSuL6+5XyzYbm5ZvjgBf/sn36Wr733ZV4cXnF/u+XlcoOzjkomiNcZdW4k\n", + "03RpRqVEyCUzjVu2W0+jMUzCvFzjAhgCqRRyOXYdaB+dtEYuCr8wRghiKSlz8+pW+QS2sRxXnHiG\n", + "cSJ4RySzwxCmDT/y+GN8cvMIEK7jS9YCgx2ZvCcX5RAE56gYrCjg2DptH1VDbLpywVFMpR0q0zhA\n", + "Wpn8xG7aKyuyRCyQ5Uij6mLKWIokaqcRxVxUy+ks1hayy2x2I35rNZfKqYXRWM2JKj00pKRCSeCM\n", + "1wVRq524btS/HzzGKQ6u5EJMl51PGzi8EgZZ1LwxeJwV8EHnzhQFbVdhqQkJVhdVNMRo3IwxBvEC\n", + "nVFjQsVno+i5oFg5yYaUdVnVbKSkQkon2ZDRY91qt+qNJ4y6yHNWL/VTlWW1MqM0HcHlXCgRSizU\n", + "Ykml9aPoO7gI+v/3oRs/c1IS1ZM7p5OOiLTmOOW3tKa1daMg1moOcwNnXs8qTouYWjqUoOmGnW57\n", + "yyYpUzM7hsHgq1Zj22nLZqsD7dyqQkAQ0mkrbjTN0fSwKO+d5ooYofRUTREhx6w57l0Z0HLpv6lq\n", + "R0Gp1o1CKrlfGJrjLFYfCqnKkVSajkBVgo+SdwoUpz7xUlVKJOqNNlYlIkYErJrBDfS8JHUBFQGR\n", + "3CUojWp6oJhUjCkK9E1eLwmbVTJSKr7B8fYVMS6opDFhndYgpVQwAy5MeD/y0asPuLh4yJoru90e\n", + "Zz23h2vGacNus+XcPOL58/eYxomSHMsxEpdCsoU1FW4un3Hx7k/wE9//aa7TNe9dHzkbd2Az2Rj8\n", + "qkaD6xTJx1UjiaNqM59sdmRnGMbG7myPcUc2dVBMbavYo2ps1zJTo6h0pxr1xddKSbMeqE1wOIVE\n", + "r7AsMz5/hJ82XDy8z2255GJ7n59++sO8u9sjJXJzfcAUFYV7rwsRjMEHjbSQvtALztJqwp26qqYZ\n", + "NmK0NZ62E/EwM4yeV9dHrVBdY/RCTAZpIyUDbdWLtVlKK7SWaM1Sii6XmhfCzjE+DPidYfQBEUOU\n", + "hvcN6W1+6TEtIpZBHN7qIsZ77cDCqBKe0tRJYIxgzaDPnLFQ4HCMhE3C+gDW6vadRnCW1CIpG1zp\n", + "C9ng1NPuDFasVpmtUWyCoHsAK4YqOq/ORjBNPeKlQcqOtCzUZIjRYTE44zRTHr00jASs1Y37CYGn\n", + "Iy61S5vWcKicz9TW464bOTZiSbi/r3EXgMqMmm5rT4eCHpKtE8jl7gA6tes6gzuFM51sXv2bcXJm\n", + "tDtB+LfmYnd0DV3NgwSHDRbvLWMYGEZN3FvmRVvp00hA1NPsumzhxBmsIvhaGfOAqZG1+5I1ykSF\n", + "yLVqKJrOJAvFJppUnDV3bgv1wTYQBS93mlaXgABFb1LT3VG1FTQlSPNShEaNGTcG1UxKw9rcD0ND\n", + "M5ZmAdvUTdQS1hU9/MTqDRwc9USir6LkFxrpMjJWi7OenCEdM8Y63f6LVn9Kuj5SSmO7vY+zW/bn\n", + "O168eEkpN5SauL255HmtvPnWx/De8eLFR1zcP2fabnl5+QpjYFomjF2Yn32dn/ipf8KrZ+9x5Ov6\n", + "ppLGmhd29wIpZ/7qo4/YbM+5OR65TTMbO9Bc4p2PvcmHh29wfm9kGs85Jku1lZeHSwbXoMys9ZqW\n", + "AikaDesSDWrLVZNQXX/YjHFsQuD6eMN8dWCsaoQYbeazn/5xfujiHuUYmY8R7zwiFes8pYC1jorq\n", + "fo045XKaDtyutTsp9DlX6rkueIpVNuvZxQXXVwvbJ/eQJUPziDkieSWWAlUXh03oWe1dIWIbzQrN\n", + "VcbBsD8bGTZgR8GNFuuUXytGSfO5RJzVwD1bDcFZpmGDsxbvRkQsRTLOWFJO+ny4/m9W3SmUWJmv\n", + "FoxYttsNxWVyqXixGGcYx1HPsz6qKEUXvg19H5V0SkJVXZKxKqwvVcXnpWRqEciVFjMlVlJUMlct\n", + "hdU1BgwhDIjVuBTnLNbyLZlDndVZirrJ1vqaqNRGhEhrSTtK//c0jfKu3UUPPsOp9VZHkMFQ4c5m\n", + "CXoAKjS7VwlWv77vS3SYfWqbTw37yaqJnMpRxBhcCGqNtJ3ebNWiNgSLdxv8alkWFcDqH9dijMU5\n", + "na8omEARc8VXSrDYnLQl6W6cRiPX7p/tP6PQML2i1viOhrf2bqEj5uTY0SF8rqj1sTWdX9am7pWm\n", + "RJ2W1UV1d9mIuqfEZHXJGB1PmNAQV7HeYoyuVq3ROAzNZtLqtIpmN520qw92FwxGPcfjtGG+vcY2\n", + "1UZiHbmCxzBtdngfwFQ+evGczXJg3OxIGRqBy1czKR758z/71/zgpz/F17/2NeI6s9tO2GCY14VX\n", + "h1um7Yb84gVnP/Kj3H/ykI/HW00ARZi2EzZnnl29Ip4rmSlu93zp+is8fHyfD28+ZHSZj12csXGJ\n", + "Jw8ekWXDh7cfUBrMqK885VVdU6shNa+xx1WbMmt9r6bVz38+jki6ZTNtOBPLMC/88md+gU/de4tU\n", + "F5a09upFHUk0i3WBhjCOEzElggHvut1VUFlO1bmzdO2d9JjosvYRSDDsz8552jK35kCuHieC9Y5Y\n", + "i+bitKjwi84AFQFjlWsqo1FavSuIE0wAbMV5T+tFw5ISwTlcNUwuMEhg8pMCZazHSCCforbRrPOC\n", + "5s63imqdaXjxpJgoa6KEggwajCi53bENNtsNyzFS69oXOI1CVzyU0hdbqOSuamc2LwstV1I0qoVe\n", + "LXEplCSkNTLaAWMD+KZkI9cjgkULqVP6jEijFLW81pz10ExVgxQPK8ejkFflzIqTjsH72z++e8Fq\n", + "Rf/QRvSFp+mbvdaipp8mCBpqryiqPgyuOgepqD5LpTUK4ajVorSk1IGo3FWXTbRFo2Vq0YfYW0dw\n", + "oy5UGioaF314x2HC4Dgcjl3Ocqo6O97fCMFbWjEUEbJvNJ9otWeaoBSkKq0nJipX05RKaxZj0QPK\n", + "9Lx2eY22o6n2MBjBmkqRqnlBVUEVJUt34OjiQ0zGjhMEtap5GxDvsR5wGnFsXL98pGCMvoFd4y4a\n", + "WMRhqlVxdwNTg+YvDY79/XNcUcDCZjtxuJppAkuKBD8xbnZYv8UET8bw8OkTps0WFwIvL1+Sc+Lt\n", + "d76P977yZfzG8+df+jI/+MlP8sf/6l9yPFgGb3jj0WPECkuJyKsPOcfwo+98Am5vucyVEBwfv3jA\n", + "9e0NJjeePnjMzdUlizMMt41798953yjQ5HsffZzn5X324Yy2OXLEkfMOKyvz0VCiY8kZlwoHkxlS\n", + "ouWMlcTmbOA4Z1gjUhX6EHwgWOHt84f84x/9NJ969CbpcMPcFPSw3Z6RlswQBsRbqjNsNrt+IXqC\n", + "9V33m2hetBIsmnleamUYPFYg10Krkc10RmuRcXMPkcI9v6UdLjnWiomOOFTWmPsyI2Kr5urUqOaO\n", + "Jo0weYwfyMYQrMf0fUFqakuMVbn1ZBhdIIhl6x0Wjag2VCQkrFU5W0yR2FK3fUY1VxT1cduxQmgQ\n", + "J8qxIb4XBkarXoBhGJCq7qElFZJkxDiMFFwTYp8n5qQzepXr6cHsciYvwrqoAaTMIAzEVthsiuaZ\n", + "O/CmEJyG7ZmT9K91OI0ESrcdi6gKYlmL8guMKnHsRjBBL76/6+O72p63pi+Oge4F77rMXmm21tQX\n", + "jLa2xugGmb5p1LjYPutsmljZjOgyhdfaxtPGWXqkaIqVZUls9hO9dtWqrzXIKjo2aKyptUIzlsF4\n", + "rDha1tK3lNMNqRKHU6UiGMToVrJWXQ7pz62pjjqf1W21c6cSWjOhRQRvnLYwUqmx53mbviGl9Vwh\n", + "fanMqbrwDlyfMwaHuAwOqgc7GKp0XaoRcA0k60yYimShJQel4+SqajuNq4zTlsfnb9FWSJJw3tFq\n", + "VH1pFkIYGMcBP05M2y1YYT9MGBFefPCclBPWGY6HI6yRRw8e8M1n79PSzAfPP+CNt76Hjz74BmFz\n", + "RqyF+TBzvt/pDHK+4uzhQz5+cc6rm8jufM9977l3fl83tH7gvQx2O/KwOYyfeHRxH2Hm3v6CXWp8\n", + "//13uLp5id8Zvr6+ZM8NcyxMmzd4P36ks79lIZXM4JyS1SXwYbxh8R4jjr0LvHlxj3cenPPf/NRn\n", + "eGN/Rl5mlqTaVu88Ka4YY0k0gvWEMJKStnqDN5QSsc4zGk/OCUtTdUfuz3SpHMsKtTH4wCEWpu05\n", + "ro5sZEOTGbd6jNsoXGRdsMZhyoptVrPcsy4BaxOs8TpOGnrEC5mExfcwOVsLMWdsFbybdDzTo2AM\n", + "SaVsfa5ejWo9Tc1IyTQSSCFnPTiVSdmIrXC7Zvb7lUlGhtFjijDZAamewVl2O/WsewKt3WLrwhIL\n", + "xo+43EipUPJy10bXIoBV1q0pYJJKioJHMJ3/adhsu9bVVR07OF1mqmtOSKXLkKqmfeaEOu6KMhpK\n", + "1ahsFzSIzU/+7zy3vrszTbT6Oom3W+2HJ3AKR6L1tvzkBjIoubx/TalVB7683qCfZo5aHDZOoVld\n", + "vEQzwuF2ZbNb2EwOcKr7bCpjki7dkWRUYA69OtPvI13Aa8RQS9QNdgcCtKri9CZFK0TRn5mTELk7\n", + "nBS83K8EY3pbpUxRi+oIMbW3QF2bK3rR9F8S+kzIOoEeZdxsw01NF0seTeBEEF9ptkLPTbGilKSa\n", + "KtYE8iqUpdJywTrHxcWOwex56/HHsOK6Hzjg3MqKWk+XVfPZU64Y59me7VnXSC2Z/fmZujC85WuH\n", + "A1evXjKNI8M4kuLC8xcf8AM/+EOknBmsYdpOLGlmGEY2wSKrMJw95ixMyNYwhUBdZ0QM98eA9SOb\n", + "p29STOOtccNu2vPs8hXjNDKd7Xh2GHiQd7x9vuffvJrxZ3tWU4ntkm3YULeJOc483Yy8vLnlwdl9\n", + "fG605tgbz/vXVwxhw/fdf8Q7F+d89h/9F9wbhOVwydoy2RmV46SIcx7Es92fY73vz6L056HHZ8So\n", + "TW7OYBuVQs3qFqqtasY8jRIj1lhsCLhhYhMyqTQ2cUtKGXJDCBjxCJZWsorUq2qFQZeCdCq7cRrz\n", + "UqjqdksNU1tnKEARRzKRwU+9iKl6mLSEC0G7upopLRLLQm2FXA7qkIuJXCprblwePM46tod7PKhP\n", + "2J9tcIMWCwMjQbwK2YcBycJmrBzXSjQrrx9whYYbjErvWud2Rt3mi7dqTPAddejAhQaSlKVp0d+0\n", + "Fc1lygYzBE21LA2apZTKumbWORNnhX+XWjFWW3rrDcP47+vC/8OP7/KhCfpCofIL033gXfZvxHUv\n", + "d+kHpipUbW/PS3cIlVJOFKveakp34vTWnL6R6/IbmqFkuL667TPMSpOJ3CrbUZBmsdbgjGVwpzeB\n", + "CnPTekrb67DTpkQjZzUpsjoLuVGKUEp3bzQdB2holaiQGdvtXfrztKrbbGvVnaGhXU2jjI36rG0p\n", + "5HKaX2lb7iw0WxHXNATTA7Zhg1KLijQ9OJ1okFpVhF5tCWkeY0aoCr1Qt2DkyeN7PH34CNsGbMvg\n", + "Ki2PtKKAjpwEpJKPK9Iqty8+5MP3/xpjG/cvnnDx+BFzPGKaxq2+9e7bfOO9b3B1q159Y4R4jOTa\n", + "uP/oCfHmIx7eP4N2TsorZRgpV88oObLZbNWzVQo4S1kLj7b3cIOHs53SccxASjMPthuqcWw3W94Z\n", + "d9gQaFiG9imeHS555Z5x9uAdvvTBMz795E3m45GXV1d879P7BPFsd3tu5oX74wZK4/H5nk8+fMQ/\n", + "/PinGGWhRFiKWu2sVbCwYMi5Me0m1pjxTdhMIyVnpFYG1w0XosJv64yGltWTdjDjxNw5uBKVkmEc\n", + "dxAdO+e42Qy4ecB7XbJY77DJY6rD2ULOq0qAqmDpcRT6pGHtQG1d53yKRM6ZmhuI4UDC1AysbFwm\n", + "WIO0QVv5fEvNmTVHYlUeQGwZSlSN5YK6r1pmjSDGsqQETnD2EVszUZdMc43iCjFFsOrnd04Rc2Du\n", + "0IU5V1pXn9RYWWNUdUZRPKDVNEGNRRFwTl9DOVXK6Pe15nU8cKuo3TJpNE7qsSKNfFeolFqwwTMM\n", + "hjAWXPh7f2i+/jixNBv0pMZvgXoIdzOKk53Sul7CSX+h6fk8aJusYWv6/U4xF70gBAO31wnhQMqV\n", + "NVWmrUJ9N6MneIcT3ZjX2rpVswe7Vb3JTy16y6XPZQVDwFshdXKQNPX4nkLaRITqdcZVa1R3UZ9j\n", + "6u+r80UxggkOX1RHKQgEIdV29zUiaNC9z9iA8kOd/qcYAaswZDpyq1FxVue+NTVyEgIDtVpapBI6\n", + "WQAAIABJREFUUo3b07ce8+TRA3bTlk044/F0TrBgSurrgIL1VhmMLH2hNeCCYfCedTny7OvvEUth\n", + "u91z794FN1c3WGs5zkdKSazHa7bbDX/xb/81/8lP/KdctZkWI48fPuLZB99kcA9YXl1i6kIRw/78\n", + "PrfXN6ypcphn9uf32IxTv0QNVgJxsbjB89GLj5iypw0BaY1pCGzangsDN8Zy7/yC4SgcWdk8fchX\n", + "83s8vbhPPMxcPHyDD66v2JqBUCrf87E3+cTj7+dj5+dcHT4iV6f2RBFiTAyDh2QI2x0N6UxOtex5\n", + "P1DWhDFe4ztST1lE9YGaDy5d9lPuFoFUNWPklgnbAak3mCxYp6JxCZZpGFiSJ1dPK0k1nhTFEXqL\n", + "L04vbhqpapvbYsGKkFrPdqrQnG7zfY2INMiWZBuILrcKSllPdSHWrC05/b2W0MVKz7KyzRDXylwX\n", + "Xplrght64oAn5MY6Ry0ehoAzFhesdi5W319xSazr2rsvPUz1jQ00jc/A9ILGa4/qnLbozlqM1bHV\n", + "a+ePQnNqz3vWKpoukleik3UwjA6sLsbcYLvG8+9pe15rveM3fqssqBSdU7aqq55vdVB+KxVJ+v/H\n", + "nryx5nU7XyuaBInQTL37uvYtjM5cMs46bm4iqVRSTZzX0JdNI1PIBOd0DlT7ULo7TkAlSLW34rU2\n", + "agGj8mNEVMPYnL+LALbGMAR9YGiNWAspWWJe74hEDelEeSVP22Y6PKFSzWuqE1VlQTnnXnWrD99Y\n", + "wViFejRBZ5nmjm+OGBVz1yq06vEmkIuS8FsuPLh/wcMHFzw4e8BmDNwbLxgZdDRSFSqB8zx84wmv\n", + "Xn5IqAmHo5aG854wOAbvGPbqsX/23vt8+MFHfOUrf81P/vRPsRwOLPOR7Wbk5uol/+Ddp3zlS3/O\n", + "D3ziXdLhiufPv8nmbMtye0s8Lvg2M222iBg2+x3Pv/pVWNVyejHe5xvPn/Hw/mNeXr7EuMCLb3wd\n", + "Hwxj8JhmGYeAmxz1mJmM5fzBY4b9OZ98p7KsR17cXvIf/8AnkOtb2rinmcb5kze4tzvyMGy47x5w\n", + "cXafZK5osVCs3rZSKtM0shxuGMN9lsMKrjAMELzrVaNjGEZqzliriZZQWNcF0IViijoOCdZp4JnR\n", + "SnActhgLqUaVLDmDCZbNdqJJwiXLbrPFuMrgDYebW81CRyur0kdbrSmAV4weuEtOlL5V9qK5rdYp\n", + "Lei46mImu0YVhYAUGhh9VnMpGnpopetE1TByYnWS+6MW4eb2Fucsu/2OcRhZjqtqM/si11bDctDs\n", + "cwDnBlo7kuJJDK/b7VbpqpXX73lpFWdVV+q8RqI4b9FDtmJtB4nzugixYvBO+gy5c28HQ0mJEDyS\n", + "gzrbjGrAXY/2+Ns+vquSI+DuEKu1du95l9oYoFlat7gVHSzqnKgJtelsspygAuY1asC6Rq5ZM4Yy\n", + "3Umk2+r+r2OMVf1kFY63ysa0UnHNYeqBOghl2ECnvKScSSmizW3oSZDdjYHgaHprmwZOyCjWzVqD\n", + "d0q+DtbgmlMJBnBjjM4VzYKS418j8DTdjy5FUfCIN7YTiXR2pd7i3IPiQKQgUjHSidsVpHiaK2Qa\n", + "vnmSUYBIM4ZWDCYL1IQ4x2bjubefODsfCGGiBRi85+XhBn9defzkTUJwvHp5yW67Zz2uHG6uiWui\n", + "UjCtcn7/PuZwTQMev/kWZ9s911ev+LM/+VM++ekf4qNnH7DdDVw8vuDMGNK4cogL5XCrm80mOF+g\n", + "CXPNjOOGKrCuhfl2xo8Da0y8ujlQU+ErX/lyH9OA84Hj8dD5pQHnhGff+CbzfOT83j22Z1tKK2wG\n", + "z9n+Id4HakvM2wopsd+fU+xAXiqExPm9LZvBkOIGsQutedqyYMUQ55lhs+sXKQQ3YL1TBkBc9Fkd\n", + "J4IPCBnEqTzHW3JaWY4LKRXEZIpz+Ko/r1jLfn+POFiOhyN1qDgafoCxGoQJKZnaIjkPYCtlEmo8\n", + "4moiidCS5j9oag9IQQnoJyeYGIx3CoNpWo3mDIioUcD2SA/XsDSyFHzQYMFWtJihQq4KIq5ZFSOl\n", + "CMYob/ZwecUz/wyqsNtWSiqE4LHHSMtqZknHhXk+/j/MvcmvrdlZ5vlb7dfs5nS3jcYOmwhjmyKr\n", + "SilRDBIJCZlRCeWgZMlMEAwZMgF5yAT/BcwYeISgBlWQVUqLQlnlkqoGlAqSxiaxwY5w+Ebc5tzT\n", + "7eZrVleDd+19I0hjJFIle0sRuvecc/c5++zvW+td7/s8v4cYhaNprcTYYKDEw2KIYACVlrQXihDh\n", + "c6Jkg9IOjppP0cjK6VCKJ62r4L+A0bWXrGaKRrK9cqwDM5ltGG1/vKfnwMcqzX/0mVfOGmqv8h99\n", + "XlEOY2SxGVKqVbLI8fwjD60QQnst8w+Lk6pH+3GIDDvwaiJnTYiaGPck7yqVOxFTFE2oqlknRY5U\n", + "qVqvlBHro9FinStZdj5rrERj4HDaCRMwZzrVyUBr1MQYqhxIgBgylEIGYkWO50ZrlLfkHGqbQZOj\n", + "7LCHkwxoYrSYbOUGMZkSLCUoCV9zcqOWHIGMtgbtpKeGLXQLT7ds8b7BuYY57ZiswmmPdYbOr8mx\n", + "sN1tMcajbcN0e43V4ox6+u4VpvOsViu2bcc07Gm859Of/gmm7Y433nmTvNthUmK7v+bkZMX1hx9w\n", + "fv+CJga2uz06BMGwzZHOO5yzvHjxkhAjp8uHjBHK7RalFL5t2dzeYpuWm82OxssNM4fIZrNjs91h\n", + "naVfLhj3e263ezrXUHLidLVgmie2Nzfcf3Bf/PdxZne3wWnNG68/Zp4n5mEHRhP2E2gIIeO7jt00\n", + "su7PMdqhlMag0bFgtMVqjw6ZkieiEl1tSokYA2GejxswKMI8YxorJ6ZQUG3DZdyym7c1xniWa1sJ\n", + "Dcl1FhcVTaphazmA0hhdN8hckBRr6amrXIS6laXvaKyBVNGJlcKotSYiLR9t60BGIwuvgpwSxoh7\n", + "CsS8IZDMA0ZRNvEUFSpl9nEghOeooon3LujHmaZtZd6T64YeM/M0EsJUr3+wVvqxWouc0FgjZDD1\n", + "aiCsC5V7K9e+pO4KmPsA0v742iLyv5gTqYj7KxdxbemawKlUjY0+SBN/yONHtmjqf9yzRGq4Ut+g\n", + "I3mCQ4FZezG8cuSInEfE4PGwIGapzgyaVGVDpQgdCOoRP5WjiPyQy1xSZthEWpeksiuRkAQG0ThL\n", + "DHPNZBf9qBzZ85GiUoo6vi6VJf85o+QGsharZQLsdYNx4sFl1tTEVA5BTyDiYTnO1ViNUqOMNYA0\n", + "qmUn1eQKtIgpYrNIgVQpJDLGGrKumlFAWS0kJguUQiLgUGRtBGSiJpKNWK/xSysAidDgVcPD0/t4\n", + "K+mK67IQx0sSIbK+9eSSmELAuoZFvyYXzYffe5/F6ZqT+2cMl3tWXcN6/SaTUcTL57SrnpvrK/Yv\n", + "X3D/8Wu8eHHLul+w2Y2c9AbXOF6+vGS9PmGz2Qhncx4pwHK54GZ3zcOzc8bNljnDFBPOCZBiux+5\n", + "d/+Ceb7m7PSMNBdu7255eXXLerFivVrSdC0fPr3CacP2bsucAsY1nJ+tefTGJ0SeluV9UEmTciHm\n", + "wmK5YgqR1fKUNBfZ7IxE4BqjccaJ/5pMjjMpCyE85UQMs4Cmwwwo2rY52nCLMjTOYxcL7uKeq5uX\n", + "wgUtmWkeIEbmKIR25zTBadrOE2Ni3O0rdLoQJ6kQS0lgBfAr38NIrG6U662WbsJIKEUifhUQ5bpT\n", + "1eNOEi11CK84rZJBZCtf1EoLqUZWlCLAmTgmri+vZNE+OyPOcy0KshRAsTCPI/txT9FZ7KwpCs0I\n", + "6iQ/k5Wquus6NM4ch0EyAINMwRxTGsqx1RdzrJWpQmx11Vef00eSVDPGWKhmA6V+UBH36vGjO57X\n", + "Kfehsayr+FBRE28r6qtUVwzIjpiPlkRZMGUQJNNI0ZfVxVGlSjupLYBiKDYfK1aDOmorD4L6YZtw\n", + "ZpDQpghqSjAVoq9asaDQyuBs4BjXiyzS6bC7aVCliC895goIsXjvcc5KE9xqnFEoX4SkREIhUoic\n", + "5NicsqC0EqlGlGaKjihV0KXukC7W/qYTF1EoqCiIrJRmitYYbckEjBdbpvYIlVtr5O4B53pwimz2\n", + "xDzifSGXPaFY2nmBCYqzR2s2+y0pBzbbDfMocqhp2DHPE8462sUp1ipM0zPFkbOLcxbLjvNlT0jS\n", + "/nj3L/+Kd/71v+LqTmPCgEmRxcUZN7fXvPapT3L93nuEOJCKoNTGlMnbLVOKdIuWq5srTk9PSCQu\n", + "Ts6YNgP7KLa50/MzPDBOYwXxJprGM44j05S4urpmmvZ86lOfZp4GXly+YBpGtBN6eVYaUuLi4h4F\n", + "cb3EGNDKMKeA0oaucQzDjHONcAy04N+sbzHGVtmcoTEaTINxHh12cq2VhHMN+/2eGCN93xNCkHgV\n", + "Je6tUqDrFjx78X2ef/ABru+xSq7nmGchUmVJUSQrrHJ4l1ktLDfzHXk7Q1LkFEhKYZRU3toqSTyo\n", + "7jsV5BBDko3VWlX1xCJbK1lAMamIrTQX5BieM2VWFewKqjipdHMtbogYJTlI0lYJ3G13GGtoYosE\n", + "oxzmAZk5jMQ0H2OS8yENU2URmpNxxcKhaq5/yjmLpTkXQowSeVIymYCr8ORSCimK9KpkGf6QX7nv\n", + "cs51eGfr+iLfI//Ak++rx4/OEaTKUYIDB+2lLHBCUBdZDXAssQ+7wLEPWiQQLZcsLoBUyKYQFEg2\n", + "ckHqPYR9WX8Xh1+MbDIZrYAogtj9JqOTw3owLjK56tiw1b+qEyobcpHgsJTLEXKc0qGdcPh56xtd\n", + "bwaZ+CuU1TjnUEWmfzEXYpIqIcVAzpk4S7RHURHbFWleV2C7OC0K2inKLIMnEjArspLdVSI9IJUg\n", + "WLxQdZsFsArlEsYVos4YPeC1RRfPdrxjl7csWZLuAovS8PjkIXe7O66vrgmDwD/urjcEZSHPlJgY\n", + "54S1E9ukefjmms99/qd57zvfYb67YX3SsupaQhgJceYf/vIv+G9+4d/wja/9B9rVgqurS6ZhYtUt\n", + "uRkSn3jtNS4vn2Gd4/ziAc+ePmGeRjmBmIauW7PZDjx6dJ80jnQLz24/sV6c0FvDkw+f8Nrj17i9\n", + "2XJxep9nl89ZrxdcX1/z+puPuL29xRvLZrPj5u6Os7Mz5jDTdT3TMLK5vaZLgYQn7AdCgnEcsbZh\n", + "ChPWivrBaiuMQ1176El6b5TCFDOuRFrvsW5N42e2mzumecD7BmuFzwoCRlZaFqjlssV5zwfPnvP0\n", + "2XMuFhe4zoAWlF0kiFFCCYQ51GhapRR9t8SsHbt5T4gVBKMVKsrXG62kx6qUXPPUggGJulC6oJU+\n", + "Xmdy71WIlqKqTwpWNWCM0NNVwRpbr3sNCKwDJaAsZz0kxeZmT5hmGdQkjfe6PneqqQvpeKzWRr65\n", + "qeAZV4X2By01B6VzyoQoziiVEsWIYF2pQkkypA05o1MWTW1R9VRXYR4cZisHxY3cqzH/mC6ah8FN\n", + "Lq/iLOo7I4vdgbhxkKRXMbfi1cBHURfUA5XZiCDWR4EelMwhcFIWFV0X6rrgVqm7INiQ4cM0RAiF\n", + "ttMoW3CNJgWNdWCsxCFIz7TKepRYOEvtm8ixvL4ULdVsmGe8d4KoU7LQowtWaVAGby2N9xLsNUvM\n", + "aB7lmK5cpiB+3qKLQFMLR+WBfA+FSjWHRcvxPCdEC1o00ywyIVsQITQKrWTCi7MoNF5bvFdkNTFM\n", + "I5RCG1f0vuN8dcrt7UvCPLPd7RiHQJpnYg1cM1ozTyMxwGq1wBL48L2/5/VPvsl62fLdb/8lq8US\n", + "p2WzGO5u+fP/5d/z1ud/ir/+iz/nwcUFm+sb/vav/4q3P/ffcnX9FGMbjDHcbTaM48D1zTWnJ6cY\n", + "LTIVUMSY2I4TyljaznF7e8Pq3n3axtM0nozi5m7HOAXWyhJL4fziPjFl7u62dZIt/dnVeslu2HN+\n", + "fo9xtyGOA0oX9rsNBYX3PbFkjLaUSI2BkBbSPM1oqzDVLjmXgjfilx/nGcg4q+mXC9JmxgZLiKn2\n", + "8CyHzDRvBTeXyPzlX/45T29eMnYzTetwrUQ+Jz3jfI01JjCHVI/+FT1HxjhHCCMxZZhmisp4pbGA\n", + "LRlnPUolChpTYEaOxipp8ZhrOZarUiQnqCpIYpLXb3QrfdaiK9owixWZOkDJNeKjEZyeM1aAJFFm\n", + "AikEUpTFNsSZnEWPmVJ5JSMkkUqRHKIiyo+SpS2WDjdYdfqlGsNcRDZDKhFbZGk7LJwciiSqSaYc\n", + "rNnyvZRSQrSncDDq/VOPH11PsxyqSFV1VQg44qCjrLuJPF5Rjg7H+bruHJ0/iXR0CxVyhVBUmYKR\n", + "Y4fiEJdRq1qy+ItTRFUQRo6ZMEeICtNoUnSklHA54bOt/VQBuiot3nKJGJXWgNa22tEOPyykaSJo\n", + "QzSOxtZe4XEQZWmsY7YB7yzBmlqBF+Y5keeCDomSJSMFPVPQ1RoKRjt57cXUhn/15FcBe0GsZDJJ\n", + "FN8zUegzmoLL0ghPJoMyqByJ88CoC4vwAKcdsUwsuyVX5oq+7xm319xeXaJoCHMgH/gBKbEbtpxz\n", + "xmq95sXT9+HBPd5656d4/zvfIE0z69UpJc682NyS/tM3eOO1Bzx/dokFXBtRZUsumq5tmcY9BhjH\n", + "PSFNDPtI5yaGaWCxXHJ7s8F7z+WzF9x7cI+SLeM00jRSCQ37mfWiZ5w94zhzfv8++ylinUTC3m02\n", + "dG3HFAZKWYoBooDxHTEENpfPKRZ8t2A/7ijKyDG6gkpiEqG3MQ6jLeO0A6TnOauMVgJoJmZ22z3e\n", + "GZq2QSvN7V1G61F87U3HOI+c2BV923KXJt77/hOur2/Z+z22c/he4zpDthHjFV3nBbxBIodMjBai\n", + "QxdNmEdCrKzMHCkqQSOOGacSrRYzSCajkifmPakkYhIt84GiZbIWm62WdpPFoaNmziMgRKyiD/1F\n", + "K4VDKaLcQGOVxRSDLiL3keZjPX7HGo42SZ/2oIDIOWONxFeQZHIe6z2eD0NhpK96bI/V1hx1tqCQ\n", + "VFuQhfEwbyh1iKWMrprqKh1E5hhay7Nr82Mqbn+Vt13qBFt2NGp/88AaLCV/bGj06t9RyeiH6boS\n", + "EraWX5pWhwGRSJmk5M+QVfWt17yRGiQlRHZAHdItFdSduyCykhI1cQbrFNkdFmQ4tA448Pp01YpV\n", + "NBwqEWKQiiBGqHEDugajaW3w1jGpiFHi5dAoSkiEVFBBmJqlKSinyCqi1KvAN61q37dWwClHYhZ9\n", + "KPXn0VZhrbgojBNXhjLC8RSQsCYVS8iFOW7QU8PKn/L47AF3l9c8fPSQftkTrOVluSTMU82sBg55\n", + "3EphlGYYJvopsl4uuHz2lMvnT7hYn7FJNzy/fEbfOCiZZ88+AC2SGLdoSHNks5/plmvStK9V3YzC\n", + "4F3LfphZX5wzzxE9zJQ0k2oPeT8MeO8Z9oO4QQrM88RtDOKAiol7D14HJTn0z5/eYGzLNO3BKIZh\n", + "kP6vuqFpGqZpIhlRLNxe34C1LBYrtDVstnu0abGuYZ7F1ROmrbA9jWGkYIxo/fpepEj9qidOEyXB\n", + "drdn2O9o/ALvWrEMpMTJ6QJyYZgC733wnMu7O5xzaFNwnaNdGfyyoJpCXHd0q4Vs/AppHxVHs7Aw\n", + "OOJ4K3ALZ1A6Y3SpqY6gTERp0WpqbZhjBcUoI06zeurKWRYQlaQXKC4mhdctkVxpXZBcgiynrZIL\n", + "RclADJDqsDpzBOv4SjM9jfNRUVCQxAKclTgMkHUAKY5ShXfklOramytsvLb0ULIgV53mEdgjq42s\n", + "7kjvOINQ7KuOWhuH0kl6vJQf3+k5HBbOTDmYs0uuOLgiQNzDVLEucB97lI/8d6hCCzLhlimTTNGV\n", + "vJFaIZPAw/EcqpRH/mFOUvpLT0QGSHHO6KQga0nSCwnrCjmJE8JYLUiwKi0qJVUx7qufOWVJT5Rp\n", + "txytS90YY4likVTIgEhpSbA8euULKUZ01sxFKhvTypEJVWnrSZr26EKJSrrvSO/U1ERO6zTag2uy\n", + "IL+0COad0WijqbJOUimMsRCDbFLrk4aTbsEwBi6ffUhjpO/WdS3tYsk2jcyzBFN578kx0batVK45\n", + "sb3boYnshw2Xc+DexRnjtJFoBQPTOPD8xQvefvsdNlc33HvwmDgnQghcv7zk/sWFHGORPG5jFM45\n", + "xmHA2Uam0WRiCWij6NqWZ9fXtMuO3VYyrMI0cXJyIr5+BfMc2L94xmZ3yxwGVB45Wd6TCtNZ2q5j\n", + "v9virGV5cspwe4NJCbwnzAHintPTU4zt2IcEqUNhmOfAMEycrHpy0ORxR0ozYSeSNYmaMIwFxmHC\n", + "WE/by6K3ubnm3sU9Wt+hXM8Hm0uevHyJ0p6cDMVltC5km5nVhFWKcVSYxmB9i9IF7xxOt8wh0DeG\n", + "soKUb9jHGWxmGCYWyxatQz1Wa7xzYo1FIi5CkT6hdhUEY1/dIyVFnLboYmRTNw1FaXKNyYgli/xJ\n", + "ga7tE+n1p2qNTuLQqb7yRCFHavKq8B68cyhlRKtr5FoupRC1lJQSAaOEu1nVMkpJhlFKkoSQs2yi\n", + "JZd6T8rgU4YBsk5Y06Br2KG1hm7RSLZ6DbhL8cd00TxIjUReedAhKlIMtWcpi5+2mhhe6a5yrTbl\n", + "NFjf0HpM+Lje87BTyoJgYiYZKcVTPdsf1tuDpKGkKE1sIMcoURlZk5CeobURX6TCi6Fgva6yBQDZ\n", + "0XMppChSDk2d6EeRBYUQiTkR6psuTWhJSTRabiyDwhqDbwzOO8Is0R85QYqRFICoanWXKmBV1fgQ\n", + "RYnVfmYy2hZ8b7FOgrGMtoKhsxFjLNZqvFckE8W3rjNzLAxDQbk9s53ZtXckHekax3Y7oYssXNp7\n", + "ulNFuYvsbkRKc3HvgnEaySj2wx5SpHWiGUx64Oo68c47n+XvvvUNcewYx9I2/MPf/h2ffPttbi6v\n", + "+fRbb7PZTgxJrKnzJPaTaZrxvrC5u6YUGf1q12L0BAbmaeT2+lrg0SqzPGnJCfplj7YWbRQhDeSY\n", + "mcZb5uGOOAdWi5VsirqwPD0lJFiuV+y2d2yv97RG0a869llhrKdbrEjKMMwSvqeLx1jP8uSUk3NF\n", + "gyaVAHRMwzU5J5p2KWLwlNjc3qBsz6pf45y0kvb7iZO3OqY4sXrwCd77f/4jw/aW1dlpBaVYtBLI\n", + "hhDQJUp5P+5wRdNYjVcJXSTuVlXsoTWWtN9TIuwS9IuZ3uoqERIQh/Wg54TOSbSdup5ejCIHkU9J\n", + "jnrBGY/NrYQJHgLZGoUmE7JGzXO9oxM5Qc4SVZyj4OhCzLWQkNNbmEdpsymBe2tjUDljrZF+qpKI\n", + "4bnk2tssmKKw1hNyoqQk9xv6mPpgjAPycUElI7ZkdTi1KuI+cHnzkhRnHjy4II6RppW8oZQzRf2Y\n", + "LpoC0BAUk0iMKiZOEtOIWnoVqtotRUx+LCrrwlkXSfWRj9XHocTO1cubqGNAo2rPpWo/cxEyelKU\n", + "JLk7KktUa0lCK1JFILMly2StuFjfWKAovNPC0NTuOM3XSgshvsZ4UGRqqBIQMmg5yislvUgjdEUW\n", + "bcErh9OWOCbmKTCOkvFcUiTPDiUbOdbV12IsJgvFSFVdZrEK22iMB+eFzI0S/ak24FtF02qMkwgG\n", + "rBFpE5EYAmPWXM43fPrkEc5Ydvs91iomHdBG07Qe9rKgdYuWGAz7aUPftpR5R396j/0+sNvtBE82\n", + "J1TK/PVf/0fOTh+gmHGNQE4eP3rI9uYWqy0fPn+fxp5xcfE6c5oxjUaFhtXpqWTEh5HdfoNvV7ic\n", + "aZwjR9htd4zjKJRwZRh2O7a7HW3/QBiQIUIqdG3Dk/c/IAwDXb8mYzBNizWKaRbyz26Y2O129P1C\n", + "2jza4eLMer1kDjLU6bqe9dKRkmEaA8MwootiSCNpDuQSyGmQDW2ScLxpmtBo+sYR0kTYzgy7Hc57\n", + "ijVMIbFaeP7d//m/0Txa4XAYnUUupAs1KU+ST1NiniKxbAkObKuxeJQS3bBzHmcsGkkXVSiGu8Rs\n", + "PKpLoFVFDc44BxFFUoliSpXhyLfKKtNkjVWiKfZGQMRK16VDK2KJWKPI2crgNUFSkitOkUwrVTJT\n", + "nIlzln6kkg3DWo1zB8qZQLJzViLfos4dkCO10QarHEolnLFkHUUnbF3NCwLRWpqjrpM6EKYoGVbl\n", + "QibSNg3Ft+Tksd6hjSPlSfqp6scUQnyAGR0wb8fZuFIiaoU6yeEYaPbRQjJTDoP2o8Tn45VmpZm/\n", + "miVVRL98v3zog6QiiZXVISA0+Y+gvQq1qitErUizxnhD8cKaNxWHLFNosa4dgMkaRHtq4JWGA0pO\n", + "hAmprq0Qk1QRr3u2EauMXOTdhB1mzJjJMZNjrSoz2MYKNUf6C7KxqFe9YmMV1im5+E2W66AUjC40\n", + "raZpHd6DaYSAn4niFMmaOCXaRuI8rm7uWPcdhsLd3Z0MPazCOkt0jq7vGPeFxapH6YTThWkaCeO2\n", + "ciMLYZ7oGqH99E3L9dVTHtx7ROt6YphYLlbcXN+xWK9QOjCOI48/+SmuLj+gKEXTdljfcHl5xbpd\n", + "cnNzx93VjtWZ5fz8gs11IsxbtNUVkjvim8T6ZIUpmWG3I+QgOdg5s725pW0ti2WPdQuZhDvHHCJa\n", + "KdI0sugX7DcbfLdkyju6rmO/H2i7lXi3e8cU5PifS8Y7xbAfiWHG1XymIpGobMcN8zyhtWPRnZBL\n", + "ZtqNxGlHKon12Ymg0Lzj+vkLnjz/AN87mqmAleA6Y+RERFKQqZrDRCwTRlv2Yc+yPZNqwxictXjd\n", + "YFVDiCMFxbDN7Lwck1Gi9TTagilYI7fGISNLGSeSKsAZI8d57VE1V0cAGEoKmzpdBxk2ksEZTZgF\n", + "NkO1MYY5kWJ9fq2wXqI+DiqUgtDyrRHNqlzLhzM3KKOw1uDqghiTwgihXE6etRcL0oM9UPG1yseZ\n", + "iDUGv2jp+xatM86J6qEUSbmUwuzHdBCUq5ZLIUMfXahhSgAKmwAlFBZtxHaoaqbFEcArueflAAAg\n", + "AElEQVRRF9hXw6GPZgq9EraX45RdKtlS4RgHyVNRUSjodU2VEAohtFMOQA55MyV/R1GiXJ9aFYGf\n", + "ZmHGKyVVs/hhM0YJRM4aJX3IFDDJCFiuTsCtNRQVBfZqFWhNa3raKdK3kbwfGUOFk6gkGdTe4LxU\n", + "mqk6LFQtD7SSnVokaHVaWbmOxmqUVShvoSngAkZ7VIkURiFcR/D0LHpDmjOjGlFpZr/fkRIoxO9r\n", + "nQUlWTSqBFoHbdfgGyhlJudEiDu6bk3Md5gMVi3o+o5p3kHxvPnmW3zn3e/yzk+8zTzPLJfnjGbH\n", + "5uYFaIfRPa6L4Bpuxog/WbIcBnxVP+xToT/p+eD9K/pepDD73Z5TdyF2R6u5fnmDNgPm9DF3t3ek\n", + "NNH3F8Rkmcuei3v3uL7b0/SWYb9DKU0aB5TRbHd3+EWPbXq2d7L4KevYjQN9f4ZrBMwcY8J7yzwO\n", + "THkmhBFFpgQRfm93O87O7jGFgF94EnK8bBYti9USrS3t+Rnf2wxk73AlYZtCUmIIVlqoXpF4XKSU\n", + "EsfbHDNFz9yN1/i8RBdHzDOt1TTGMqDx2ZJT5Go3o01Dp6qETYFuwCiLs4qcEt5ZVC7YUslhGkHM\n", + "YYkFbDkc7USlkkoiHtUwBaNcdf8GcgzEQB04zVUmJNerwcnwqZpQBD5RjgNUfcisKoK5s1buMa2l\n", + "3YIyGH0YAqnqbKL+HBmKrnVXkfsBI7MLE3De45ykJuQoPx9VlZPSD1809Q/9LPBrv/ZrPHz4kJ/+\n", + "6Z8+fuzq6oovfOELfOYzn+EXf/EXubm5OX7ud37nd3jnnXf47Gc/y5/8yZ/8c08vj4N/vPYqi6rR\n", + "t9TFjvqi+PgR/KN//ygp6aBhlGrzFU6uZE2O0kxOSSJAZYJupP+Saxxo+Qim7vC8xUjed9LkkEgh\n", + "Sc7MfOAAFoTCpmsDWwT6KJnYaW3QqsKOs0zopykyz7Euyg5Kg1Je2Jna0zStOIk84uTxBdvKzSNg\n", + "l1xTMevrTa/y3MmJynmqP4shR/m+ISbIM8YWrAXnoes6rOnRJTGUHWPZsxuu2Q0bbjc3vHh5RQgJ\n", + "YxTDeIN3CZ1Hzk96lkvHciU8zv2wJZfMIVdJFmqDcyu6xQOa7oymXbFYnqKU5/33P+TRw4dcvnxG\n", + "TIre9YADpRiGHXPYE5MMhz796bfwfsVifYJftAy7O9beM+4Gcins9wPGWsZpBuPxTcsHz5/z4vIJ\n", + "BMUcM67rQHmysvSrNY8fv85mKFjXs9/sscoR58A4T0xxxvqOkh2XT58yzwPzvEOrTN8t0NozDxM5\n", + "RG6vrnn54TO217fs73aM+5lpNzEOE8OUQFnGMNP0XiDEKtPeO8UvehrXUIylu3+P7zz9Pvcf3Wfd\n", + "tjSLBu8U2kjYnrVycpAUSlkochBy0JQi23nLxJ4x78FM+D6zXlv6torFi6HMMIbMHCAmzRggBoNS\n", + "Fm0tbevr0EyKGWNkMYkxEmMgFSGfx5hkkJOkV5tCPA4Fj8jEOqwxWgoJp41cq2QUkZCmap1Mr9w7\n", + "RR/RhyLaB6UjSsufnddoF9A24HzCuYixSf7zGm21qEMMaJNBiUXy0IpTyqBoUEi7TazI0stMWQox\n", + "6Yv+049/dtH81V/9Vb72ta997GNf+cpX+MIXvsC3vvUtfuEXfoGvfOUrAHzzm9/kD/7gD/jmN7/J\n", + "1772NX7913/9uPj8oEdGFsvDELwug/X/5Vg1fvSzr0Ab//ni+bHkSerRvWo+ZceSyXL+yFG+1GqT\n", + "+nX1tCvJj/XjqiANaG1FxhRKtUhKtGhIgv0vIZDCBFW+lEpNxdR1YUNJZGrIzFMgBElyFMw/5FRQ\n", + "VRohlHjJWG9aS9cbbAUMU48bh81B1WlYSZKBkqJQwXPI0pBPuX6fyDwLFCLGgNHgar6KseBcg7aG\n", + "pHZ8cPuEd3dP2OYdc4qgDa5pxHnSt3hvuDg/5/R0yfn5mrOzM05Pz1gsOmE/FoHGNm0DBbx3oBNN\n", + "p2n8guX6gnv3HrNYOJ49fcbJ6j7OeG62W+7fu8+434hudZplCOQcWmlc03N2eo/t5pYQB65vXorE\n", + "qesoCJOxX52itGEeZ26fvc9ivcCt7nNyfkK/WHHv4QPWZ2cobdjtJm5vrrm++pC+cey3G6awx/se\n", + "oxfsx5Fh2mL1hM6Z8/UDUjDibppuyDGyud0QQ8A0kmaaKKI/HOp7W2QUvVguRZCeAv1qwfLslO5s\n", + "LbT51Yrruy17HfG94/75fVbLBd3C07RGqqLDFVrNC5XlAsUQ8syU90Q1oWzCdOA6WPaaVW/wDkzt\n", + "V8YkR9uUNTlpUqi5U5UmZBCpFfWkllI+XqspREJM1cGW5c8xEw+pkTlTciQf/PZRTl1Gyb0VQ5UX\n", + "GTnK55q4KvzLOoStGtgYY03AkT69RlULMlhbcB7a3tItDL4zdI2l71raxtO2LevVkpOTnqYRZkLT\n", + "avqlZ7ly+KbgnEKbVDcIaWtIeOJ/IRru537u53j33Xc/9rE//uM/5utf/zoAv/Irv8LP//zP85Wv\n", + "fIU/+qM/4ktf+hLOOd566y3efvtt/uzP/oyf/dmf/c+fWMsvIacCSvRb0piWX9Cx6kS/6k1KTX+E\n", + "EGuZ4XyM2P7RBVVrBVq9qhrriqhyjf/MWaQQdVoPULI97mo5She5QJ2Ki0DXeEQXGgvojJssuWhm\n", + "n9FZQ8hYK3176QZpjCiRoShhWNbc8hAKJY246pXNsdSpe0algtUG3zREBXkSUg6i6yUa6cnkXCS0\n", + "qr5IATJnUjKUSRImFRBjFHCulvzoccpY36CPfv5MLIqcHMkpxjIxTBONkyHAbhhYdh1N29F2PeTC\n", + "NG9xbo1SwqhU5oT9docqEll7fnZOTIFpP7Jen7DoFuy2W9K8JStD35+wWl5wcnpKVg7TNmw2L2na\n", + "Fp01u6TwVjbOvmnYDhNusURbh1WW/uSE7WYAApu7Wxrb85nP/Fdsdrc8+f57tM7z4P4bvPbmJ0gl\n", + "MV9d89rjN5nChDKFEGG5bBh3E0+ffoD3La5bMgZxPWmVmLaJ7DpMo3l+9ZIY4cy1kgw5z6xPLzi/\n", + "53jy/SfcO7/H9X4jmswMeC908aLY70Zw8NrZI4oWX/bJeoluFXGx5H//xv/L3zz/FtsyEp2mMy14\n", + "h5kDcc6EFFFJevnaqio9VJALTssQc4pB+JxaPN6qUyxnTUqa3ZSE0IUmK1sHOmIazznRKJlex3q/\n", + "JICUKEEd4cCKQpyh1Pwe0Ex5IqUgpwojPXtdRDqUYpYTT01dEO5blT1pTVGFOc0it4PqkmtEH23E\n", + "NmqMZH5pq3CtxpoGYyX3xxhJzhy2SbiwyBRca8EyppSITiJxnBNiVkqprguHQgqUkeDAnDMhHBCS\n", + "P/jxL+ppPnv2jIcPHwLw8OFDnj17BsAHH3zwsQXyjTfe4MmTJz/wOT7adzQcgsc49muq3bUSjvLR\n", + "yK+UrrDWcjTWl8IR60TtKepqrj18ja7QYPkeH83q4VhRgoAxZNFUGBdFFxbqil0XlxhklzJWUUik\n", + "qAm1v2q0k95TKFU8bI92LZVEB2elAylH5TAT50LjG3kNCKwjhFirZI1SBqPNqw2h1I5sqNP8pMnx\n", + "kPBZ+6ReE1MBM1G0JlVBcAwBsMS2MPvMoDNNK/EfKYoeUmuYcyYUacDHEOmXC3y3EKeINpQs+sim\n", + "aYUrmmINw5JjVdd1NWM6c//+fa65JRfRqz6494gQAuv1itubS7TShCny6c+/w83dnl2YCbtbhmnk\n", + "9OSUUCJZa4qFRb9gGHdSoSjLfjexWq65ut1IvjuGueZzj+PAyeM3OT27EKmV8cxo2qYVlBkOrQOb\n", + "l89xzrBan5OyZthtKWlmmjeQYdlfoIxFKdER3n9Q/46i6xpyyTx79pSYAxeffMT2OyPblGm7lmIU\n", + "u+2OtutJKbFatGxv72hXDSenj1gverrO8J3NFf/p+nu8v3uG7Q0tDTFMmCRHxphE5K+0rRVZvfGL\n", + "5D3p6oTJMZLNjG4MVkv12CdNVIrxuqBtQRnprYegMNbJ0VwpYsxYZ7DaEGOULKGUpKWUoBQB24RZ\n", + "3leRwolERybhTlwWShxvJdWwQ6gnM0TmZOXkVTJgiuhslcVah/UCSMhZUHRCj1KSmNmAb8GZhPca\n", + "Y9va7oJu4cjRoorDWMQXXzLGKpqmoWkl70iUNLb2TC1GV3dcHaKK2P6HH8D/iwdBP+io/I8//4Me\n", + "IgmSALN/zL8TfdXB+FhQpmAKlBIp2XEEeKCO2DittZScJNFZKSXSAw5ypY9oPXP9/HHZlOpOIZWp\n", + "NfXC1BIs74wmjCKyLkXcRaKPLBRd0CTZfQtkm2qLtmCcrj9HlSGVOsjSSE+lJFIqpDCRU8HZBoGU\n", + "JOmrjZNkpHBwMR0UBOKEyCmjkiLO6SieFzjIQVaVRdJZkXMlJ5LJOGuYhkIxQfrHFe2liyUHhS6G\n", + "zi54uHqDvl/TUsgpoqzDGcc8jQi/sJDngFWaqfqSYw5cXFwwz/Nx+vnixS33zs9wzrHb7UBp2ral\n", + "FMVPvP15vvWtv2Wzu+LZ0w94/fWfYNjcwVHEHHDdGqU1TdNChBQdMcJPfuazDHEmMciChuP+o/u0\n", + "bUNMM6ZpOb+4z9nFPYpSOFPY2ySuMNNgrOXy+QuUdbz1zuf47nffYxxmjDLiZz95gMKwvd0xlw3O\n", + "dSyWKy6vXuCbBU2zYJpmSJa2dTx+8wHZJKxSWO/YDDuG/R6nC64xWCzzmNmPBdOeUryje3CPsr1l\n", + "jiNX821VWoDTTrB+hwQDa8QEgUcr2VBVOjA2xd7pc8ah8ErhdcG7wBwLTWewU8LagvYKZQpJQcgK\n", + "NUe0qbBvI1APpWRjDCnKSbC2mUrMpJCJUyRGYWgKgjFBHcY454RKH4Pcj1Wxcrz/tPS6C5BzwGmH\n", + "a71Uxl70yVqVOiQqaGuxTtFYg28yxgW8BAhgTal9SbknQjWuaCXT+5ypVklRfIAMcUVHm9FWdNZt\n", + "6zikMKhUcM3/D3EXDx8+5OnTpzx69IgPP/yQBw8eAPD666/z/vvvH7/u+9//Pq+//voPfI67Jzu5\n", + "kQv4padZ+WNVqJR4pMtBi6mUWKuSohjJDT+wLYUTqOsELtdS/vCoerAiE7dSEmSxWMaDyOkwCSTX\n", + "aaRGm7ojK4NqZGGLIZNDwWpH04rbxji5oLTWhH0kpULT1J/dlOqSSKSkK1XFCkjDaKxxWA1RCdx4\n", + "DjPZiIsppsA0z4R5QhXJadZV0xqSLIpZH/BdhjxLdaoVwg9VwjQsRqAK0uYQOUaJMG1hZ8sRlkKU\n", + "doJRGp09UUsomJrBny5oncbNMyUXxjjKz+IMOUZK1sxB+JA5JxZ9j9aG09NzciyElLj/+E3G3a1c\n", + "I2+8idKW1Xotv/+m5VPvfI4Pnnyf9959j+1mplt6qbZjYIozTnesml7iPTDs9jte++TbkuGtIiGk\n", + "6nDxbLY3tG0HSvPaozdZn5+TgaZtGO+u2Q43MLeYvuN285KLizOM6/nekw/RKtEvBd3m3IJhGJjD\n", + "gHWFdXeKxkPWdI2rA5FQY09mXGMw3nJ9ec3uZstut8PogrcZ7x0lK+ZRMspt79jfbXjzE4bu8Rvo\n", + "uwXv/9XfEM2MQYYyRVX5TDKkPImLTReMqqJvJQM+U8BhsEqBCoJGVGKWMCmiVBRrsU4UHcnKCjZP\n", + "F7GwKtBZFnqdIM+RZORkpuosoOTD0KmQgmQCkWXwKTi2cqziZHZQsFpegzGWFBKN90zzWJGQMuxx\n", + "rcG3nq5vsQYxY1hwthzbVd45lNXi7KvidK1r642KStRCGZujYOw+coYk5CiRv0pjjJWN4OgwFGtp\n", + "IvLdv3nGu3/94Q+dwRwe/6JF85d+6Zf46le/ym/+5m/y1a9+lX/7b//t8eO//Mu/zG/8xm/w5MkT\n", + "vv3tb/MzP/MzP/A5Vo9XVfIjFSdksV8ddySEr1elA3Jw1cRa7hcRdtUjuyx6xoBSEimQ84E8pKpt\n", + "sFbFQFQfHRgdUG4zrmkkOVfN8sYoA0p6J9Za5jmjdcQ6L5ZEK0d+ozI5S3pmSQWxIZQ6SZTpPFQ/\n", + "rlYi7jXifGjblrlMYu8bdhIfkITunUuufmbpR+aUyVNCZU2pvvNcokicauUcVUI5och7a4gFQpBc\n", + "l5w1WhfiPjGbgioOFQNlNhhvcDrR+syyPeXUtnzm4ac471bEcU9OmWke8VaxWq8YpxHvHFMlehsj\n", + "nFBrLM43pPgq42XYb3nw6BNobbi9veVs1RGjZg6RaR65f++Cvuu4vLzhO999n2gG3rh4yJwT2jSg\n", + "Ds9ZKKowTBPOedanp3zn77/FovEMw0DXLTg7O2fYT7z+xuvc3m7Q1lHIzPOM1g5t13jvmXNitTzD\n", + "G8vlZsv5w8dcf/A9bm7uWCwXjONIyTNKJRq/JIaZGGa58ULAupZs9pLd03eUEthubpiGPdfXLwDY\n", + "3N2hSsE1vQw2w0xSDq8aSky0fYvq1ijjoFhSgXGaiDGRYiAVIfhIQF9B61ytgoLnO3jWXRECu0Na\n", + "BU6rWv8dHG6vrkmrjBynDQKoyAe8oa3uPNBRKkGlDEY1zLGQ54N9OAtLU2oZ6acai/fNkfcgdU71\n", + "hVPo2p4UM646lUB6srp19AtH0xisAWUkQlergFJgncMYhVUahRGJYs6kOZLTLImWSlxHWsnwNs6B\n", + "YowMyZATZizglUdXRUkusR7PxVmlMbz+2TNe/+yZIPKA/+t//Ma/fNH80pe+xNe//nUuLy958803\n", + "+e3f/m1+67d+iy9+8Yv83u/9Hm+99RZ/+Id/CMDnP/95vvjFL/L5z38eay2/+7u/+08ez4+aqrrg\n", + "CZC4UrLR9XhZ5UPVN3rYXcm8gnqkmuOti6TU1STHksrxWB5zPvZCAUzJpFLnMiVJRdA29F2H8VF6\n", + "L0XIJ1YbYgAz136rivi24BuFtkUC7XN9jdnKwqZleFUq+T2XGetkd1RGKuoYM41r8N7RdR3DduDl\n", + "dMU0BvKcpbF+yIuKEFKQDPQ5k6JCKMmHY7ipAyC56o3NtI2jWyhiKYxzJk6GaS/oOa0tYaMoKRLH\n", + "TJgKrs94VyBqmjLJZFt15HlgHG5J0xZrPVq3oqdcLLi7vhVkWJQWgvdtrU6ksg4xSnWQC3fbLYvl\n", + "ik++9QmmcWAeBm5vXnL18il/8xd7Ht2/z+rsdX7ycz/J//F//weefO97/MSn3yYXR9c2BDTDFGhM\n", + "pm1blsueYRj51Cc+zbe+9Q26rkFpw6Jfc3v9HsZYuq6TSW5p0CkyDAFtehIR5zy+6VEYXn/rPsN2\n", + "R86FRWvZ3lwS4oz1lkW3JMRE36+Y9B6tYRp25JKwbc+6OSWVSNt2xDBDEpr/9vaGEiaWp/fI2rHd\n", + "3rFcNCRr0M5ycn7CYrkmF0mYNMpxd33Hbh4Yx5FhGgU0nKJkJ6ksiNxKJwopShtKS3WIl7gMp01t\n", + "NRVUyWJ4MNXiSyKpLHpiFKUkZG4p75EwvVW1Hh6SDV5N0UtSpMoAUFEwN8pomsZhjaGUuinHVPkL\n", + "Gu8NzmSckX+fi8J4g3GGoDLFCM/TaIO38u/RPVZXPkSWe/GwDSgtAYJWVYedE3ScqcPWOeXaz5Sh\n", + "cs4JlQrTQX+qFBCgCHoxxIBxogeVGBppt/2wxz+7aP7+7//+D/z4n/7pn/7Aj3/5y1/my1/+8j/3\n", + "tK8m4NUNJJVgkXlLERqRcDJTnWAXstIiydE1bkIBTkg9Tafw3pCTkaEHWY45RSo0rZVcZIXK0xSC\n", + "dcoK1zgan3FNxncKimc/BrKKQELbhG0NeiygDcoUrAdlCphMyV7CqGIkZ7l4UxFWoSKhTcaYXPuV\n", + "GaOl6mwbg/eeohS+MSSVuHz6kjkEAoKK0y6jYqmVhGY8QDqqXEtVRpNUmiLlaHvD6tSgfcZrw1It\n", + "2N4kGq2YhpEwZfJYyFp+8XGXKXNBLRznbcujfoFDs58msNJ3RmucteL7nQMvty/pu4btMBJDBZUo\n", + "6R0ZbZhjlSkpzzSMoLdYlfi7Zx9wfXXN9dUVz5+/YDdIFev1t1mfLvmpf/Vf89/963/Dv/v3/ytP\n", + "nl/x+MHbqG7BTEJPhbaXSt16h1WGzdUl/aKl5IjSjpgi5xcXtL6RIUYWC2lKgawbUt4wT3usbWkX\n", + "ltPzB6QUMe3E1jtuNldYW+i6nqZfoopBm1xRfAVdijhknFjvYpDB11hGwhS5fnGFsZrVyZI5QL84\n", + "5W7Y0PYNy/Ua27W0y5azi1M2u0su5k9Cu+bDZ8+5vb5miJFxHIhzYB4nWShVPYtpAzqRmBA8oEIX\n", + "y36YaJzCIu6hkhPikbAEXcSh5DWq9RyQlyrVe00rmXLPAUxDVkoWBV1zgIqjxICYLsU0obMs2IqC\n", + "jBI0WjtSFoShdUokczpjncbbhpIj1ovTx7aerDIlTqLFTEWye3BY29SvzxIFkyX+IicFSuzBRTli\n", + "mtHKUOZCiZF5NkyzZbubGMIEWgkNPgoj8pCDbg6U/hRBlZqoIL1Nd6DXp/BD164fKbCjFJATq6qN\n", + "YXH/qIM48iPi9EMCpVGCqJIcHzmqd31D24qPtWTBuY17GbikRKWdxOoBp5LeqagqhfbQLh2ujWhT\n", + "8N4ypkn6NrqQdMImi7UyDFJolI4YrchESpnluZMcC3IpGCQVUlPQJgoCDukjde0Kpx1N4+m6Duct\n", + "y9jSOokOuLqNbG4mlAuYVgLGhF6taZaWMCa5iSszS+kqyDUR7TX9PY9fB5yDtumJsyLuExaNMZ69\n", + "lmCvRjmWbY9y4lo67dc8XN3jnj9l3ZyQ1MQ4RlSINLaVI3ISLWSeZ7Z3W5rGUUqmaXrZrV1DKYqm\n", + "kdbFOAa0dQy7kWnO7KbEbtS8++Gev/+HW242G5JS+Kbh9QeRy9s/5zNvveCX/vv/gf/5j/8nFosJ\n", + "vRtYeMPJYsFmuCMn8MUxM4ht1cL+LvLo0QV977FuSbdeMyvNarmsCAnNy+vn5JK52+559PiEZtET\n", + "EAvmzfVLtrdXLFYdXq0oWjPWSXDTL9hvZeEjwzQWYgr4GJiTbP7TfgtoFqsWf7Hg2Ycfcu/8TbZb\n", + "QdidP3zEEGZWi56mb5hzJk2JtL/FLs9p+zXDuGUcAvshUKZACAGlCr4xKGelX6ml5RGTBOOFLEfd\n", + "ORWsKSiJepTrIWvJO9eqWl9FjWKdwIbLMSZIevmpJKEcYY60olgzkkKYyLmtw9ODdTKitUPZQirz\n", + "QbRHqRFfh7Ay14ipxBhF03is0+zDhEkVcJPF2lmqy+tQpYaQmWcxoqQgVLE4R9om0fUwjwOBgRIT\n", + "m6DZD4qbzcR2lKm9DKk1TjdgJbxwt79lLodKNGKUEkvtosd7h/WWQ2DcP/X4EaLhxOJU6gtQSoYg\n", + "Rx9UFWaWckj9Oeg2D+HvgCo0XmOdZrHw1TJoCbGQs0Skmiy8yBSrDZNSM3KAotCpoHShWQqCX9si\n", + "u/ZeMY0HEbkSYbCDFKQDqo1ESxircFaO7UXJMUOha09FYbwFLYi2WApeC2jDGk2/6GjblsY5jDGs\n", + "lyswCd0WpjxQVEA1IkBnjLgg0o12YSp9SZMr5i3lgDbQriz9RWa9drKDZssImObwW1XYAF2/oG8b\n", + "2qbHWEdUkd0w8e6T99mtbnltfcp+85I3Lh7RGw/aMM0zaZoYdgMlzOQc0GaBd43QhXJExZ0MF6xw\n", + "Cr1zTMEw0/L0ww03+4Fv/8O79CcnPP7cZ7kIgeeXz7nd3vHdZ5F333/C1d3ELibefucdJh1ZLk7J\n", + "aSag2Q8z99Yrht2OptFYrQXs3HXMY8CcONq2JQOnJ+eEPGHs/8fcu/xalt33fZ/13o9z7rOqu7r6\n", + "zSbFpkhaEvVwYDgJLAhOAliInVGcQQaZZJSBPbATJAYyyT8RBHk7GWaQIDCSSHAUKxLsmBIpUXw0\n", + "m81mV3W97+vcc/be65nBb1eLA4sZBc0DFLpRqH7ce89Ze631+34/n446RXy/5fLFQ6wLhG7A+kBM\n", + "C8SCwfDqvftkJUoNcsXTOOwP5BhxWqC6ymmJPOVMLjfg5DAcQicDSdMxT3tev3+PB59c0ppiczRS\n", + "NRyfHXN6fkyuQvLqug7jHMvNA3708fdY9o04F7FeVsixYL2mZWimop2Q4i2GyILSYJQBU1lqojMO\n", + "lSt1VaqY1jAWYlshwkbaSM0UrLXSaRe1IyCDRWHBriWQJJAVsT2CUQLDkNhbxTmDcxalxYrpjbjU\n", + "BXotvp+YIsGDs4JIpCVaVXTGkVWVmrRePzfr1UBeCkY5TLWYWiglU1IiJfkstlUJ01lJ2sScoDkU\n", + "VhbYtVmkjZH1oxayyRIRsxtUymIgiEmmGX1mmaUGq435jIvyF70+Z+95+wz1Jt/sP0fSr2A1WAO3\n", + "L3+3rTEGVYUFaWzFdwkb5GjYlILcWIpoIIwHlREqi1pJSUbqjTlXtBZPugtip2tmRgeD6RRlFiCG\n", + "ImH9+u9vhqZWYruTqaU1gWEDeYESMzQn1VBTwRaMl6M0LUl7Ind4FwjB0XeeEHqckxxZVpFsMvt6\n", + "zX56IZrcJhi6MkFXGjaA7WXHnRbQLpBKoSroNjCeKIaNXXFfmRw1rpNFrJqMpxG6wPHJOcZoAhrr\n", + "HXOb8V3h7Oics/GEwVgOseF0QetITYllEk4lREqOtEPDHVmuby6I6YZBC6GpkbHe4t0R2zvvEY7P\n", + "eXH7Kd/5o9/nS1/9Oq7r6LrAl97/Bh/88EN+7/f+T6q/pMUT/tn3f0CMld/8rbukktDWc/f8LhfX\n", + "j1HKkMtEHzakODN0HfvrG4KznN09Wz8omhgnNuOI2XakRUAkS70lFs27b71F6I642k2c3DkjNU0f\n", + "erQylPl2zQg3pts9mgNohesH5mlh3AZOjqXiSU1y3FuD2j5Yxr6nHvU8fnZN1QtDOKK0iA+GO+db\n", + "qJFgFJvgKB7wgYcffI9Hz58zTTccrpMsGlrR9T2bTc849CxlJppJdoDak+uNkOQlWAbVUFpAN71i\n", + "2xTegY+VXAyKitMQ1ysipatMrLXsxqgNlWSw+nJ+3JIwF1KR4zamAQml1kSH0aVrHpcAACAASURB\n", + "VDQysEK1Jf8n12vNkHNB6cjiKnZYJ/LKUldNtWT0oLRK1U1qlsViq5XcZpVKcq4Fo8UXXzLoVtF2\n", + "wVuPxYKpGJWwFJwq5GWPVgMUS6kJ1Qq4Jn6kYggaxjuvEHPh8nrHHPekXHFertLszyu5vRSZZsqd\n", + "nFrzjGv+8qf65K29zFiugVOlXraqcM4SuoIPDe0LXS8Edpc1cTbSDW8F443UCpu8QawxEjlSBpct\n", + "2qR198jKnWwMfaAsipYk+F5awwaZbDvv8J2RWFJrGF0Yj0V0P++gpor1iuDXi3AnU9+cI2mKtGqF\n", + "PpMS7ugE5y2hF6PkZjzmPBcu98+xfqbmRM1CoWlORFXdoOm2kJthmjW5REZnJKtoCmFIaCeu65wz\n", + "ph8IW1gOGaMrfefx1tBvDMEFOhdECZIKy7JnKntS66H5FYispBJXJINKa8Rc0cpRauPFxTNKXUgp\n", + "0XIkp0I/BgZruXvnNV778td5elV4dPVdXvvSe5QK3/uT7/MLv/g1fvO3/hX+n29+k0+eP2feXfDF\n", + "d9/gS1/9Ot/842/y5a98iXffe4/gPcZaxn5kOeyYpz2b7QmHQyIue8btiJHhMNvxiMOyMHYdZjOy\n", + "VIfpNOWQOTo/5o3XX2XaXbHbz6S4MN08xPiG1h7vLJ0ZBUZmJV429gPTYcfN7oZuMzDFBa0R1umc\n", + "MK1huw7f9YzjBmM83gXcsGXcnnB9cYVVA3fvnNIocmVUwXjH0d17tJz40z/9No8+/ZQ6FTau43ba\n", + "E7xn4wc6O7DpRo7tKfs6cR2fktSy8hKURI0I2CLXlcZUnMpY5VEYKWGohrEO48R/o53BrNhV+TA2\n", + "uQ992chTRsRkGmhaej9KUG2yG9QYJ5pqsSQUOm9RiIJXK0k+a2TXmLxCKScnQZWoTYFyEhlMDWoW\n", + "GEhNtCKAYqMqfRjwrseYnkPckXMirnCUkjLRRqq2FCZy1fL3bYZWmKY9Rsl132YY6EMnAyOrcXZA\n", + "awhdx9vH97mYdlzuXnCz7NGe1UH1F78+t0XTB0uKbUVArcfml0H5NWb1Mhz9EtaxBieAFcNvFNo1\n", + "jAcbGtrJMKm1l80HjTfSxilajJXyTzeslrYBTVD31qywXmtQBkKviRMsrdCK7DiNK7heoY3wMp11\n", + "OCPH+1RkCOObJk0N4xXOKZxhrbjJlDtHxcX+lqCPmDcLpUas6yROYaDre7p54OhoQ1ZX5JhQTiqY\n", + "rgvUMdN1DhsMyji6ZJnnjHFS5TQ6Y8MeY0UP0GxbFRsQ9QE68MbjHdig2Pa9ELYNdN7QdVuUlye/\n", + "VnL9L1GOSM6JZZqwSuGsW5tLkcN+x9D1UPt1Ejzhui1Hd+9zcv9dZj3w8NGPuLy65v57r/P8yVN+\n", + "8vDH/LNv/Qm/+3/9IRcXz4nLRIqJHz98yF/+pd/g6M5jHj+/4c37C1pprHM4a7hOM1pD7yzZW5zZ\n", + "4BxY5dgenzIvB45OR7qjc4w/wVbZNfphw4nd8L1vf4snj55x8eIBaVmY9gec9Yxjz9mrp7z9hV9g\n", + "u93Shy37NGP7wKA1lcQ8J+xKj3LayIOpCSHcOIu1gVIKSxLL5J27W8bRUXOlqYRRFqu05Hi1wjjH\n", + "zcVTPnn0Y9699xp3230+fPCIfdszhi3eeoJRBKNxztIY2ecOtMLrmUVsgVgqqgnqzVu56pG2TRVz\n", + "6Vqtc1atPhwBXb9s4em25pVfTsl5GRtS6+S9odVab24SxdOr2kVc5w1ri4TKtSGmJHnjWslVeAcp\n", + "N7QpKGPXBl6FaohTZlkSk4ocbccVGCKxQVVlUKysIlRH6yx6Fh9nqolQJSPaVERVRa0RrfLKh5AB\n", + "0tiPOBRBWbquxxmHVQFnnQC1vWc7HnP/9BUe3zzmYvecpuLPXLs+t0Xz+GTgdrcQUxZPzcsLYP4c\n", + "4stP4d4AUNKAQAvFxHsJmSstbQZlGs4aSqmr7mE9NllLzXKx/vKeFORSnGbQZgAq3stCDOA9uN6x\n", + "RHnymlYwfjUIBolGeBPwfkEZTSoG1wA9Y7zF6x5tLM4K0FVlJT/sotk927HtDoybA7eHK4btQMuS\n", + "c6ytYD30fSAsHTATtIcoH8yqG8PoQVXG/oT9fpYpu+mpLZFLxnmLUwtNW2ZdiWbGhICNkmY2TsCv\n", + "1ii8tZIosApvBJhrqyKTOJQdTlUWBsosQXtnDLFkAoZaktT7FEzTgjEdyjnunG157d67vPruF1Fu\n", + "wyFNPH36BNf1nB+f8Gff/CapVWqFBx//CDRMhwP/xt/4bf77/+a/4O//nb+P/tqv8emTD5jmSQZh\n", + "Rhofxjd06Zj3B4bBc31xJQCCznF1mDg/GdFO0Z28giagUmF/mLlzdpd/8r/9z3z3ex8w2Fe5nF7h\n", + "2fMLUq4M1nKeNM+fP+LTjx/wi7/yPl94+8sMR1tKzizTAaUNNU/CvQS095ycbjikPc5YOmuI87S+\n", + "NzPOBQwNezRQqyLGiDWWuCSq0WxPT9A1UQ/XfOHNt3iy3/HRRz8GBdtuQ0sVf9TjjAwyfRBlrrcG\n", + "pwNRdygTsdqgkLxuLprm9FposCglXAXVBD7dWhH+6hrRAbWqRwQFh6prAw10s2gEhahsxdoKpf4U\n", + "4Ud2nKnW9YQmdtVUM1o1Ui3EJlnjlCsxa5wzlMZaCknYplC50BJMJaN1wnuPMnq9nKsoVait4K1e\n", + "DaWN62VHrQs0TWsGihFmZs2oJnGiVioVjcngbQC1kIvm6PiIwQ60FuQUZhUai3eee+4eY7BcTU9+\n", + "5tr1uS2awxhw3nB7e2Besjy5SgEr942q/XQUSa1h1NXDoxrOOYxLEqh2Gucb1jWMyWhb6HsheiuE\n", + "7qK9J1QJJmtt0cqwLGnNZymMqWgjfnOaHKe74IheqC66GZQyhKBxTmMs1LZQjYAEjG+4FUCsek/n\n", + "A7WsrMyWASWiq1gpB3j2+BofDJvjgO93bMfGNJUVUxXX+1rDoAZc8TQnaDnnLMFo+o28uZRqzKkJ\n", + "7q4KZ9BqhcLKw6hmQYaYgg8V5QzKVpyWIz9mvUe2BauVuMbNiCuyyz6khKoTtUZYEt4Y+q4jRdGu\n", + "xtW7XltjGMQPNIyn2G6gKcPp6Qm7h8+RDnLj+cUNMSmuLm9Ad1gteVrnO37040+otfLbf/O3+S//\n", + "q3/IvDT6oxP6IIMZqx01JU7PXkF3hpxuGTZbWs5sjo4YTu5Q5z0ta1rTlNDTmOi6jo++/wGPH+15\n", + "8Awe3XzE6at3GO69SscJ0xL54GKHSZ63tOKjP31AjI53v/AOqlZiqmjX04+NmtOqa5CHYHCOUiqH\n", + "aY8PPb0fUUrG0k0BtcoO0BliWghDx3B8ynByxhIXfvDwh3zrwz/l+z/5EbXA6XjKrB03h2uMKhjr\n", + "cc5InK5W+uRYioAtVDWopjE6YDGonDBNTlROGwmSe0VulUknNJGsKraBWjcO3ggVXcwGMjh+WVZQ\n", + "VUyT3stASSNRvxgzVgVKE06s0w2vqzBZdaUoyKWJ3tk6yVhmwcm95HXINimhrDT6jLaUbFiiIRgH\n", + "2kjqELk6qLqimlwnbetWhIntIImRKjXOYA2da4x9YZrAKQFuKz1Lxls1DtMz+uO36J0nzU4aVl6W\n", + "wT4m1HAE7ed0pzkMjloNobdcXx2YJiGfNNYIUv3puFFba1NiO3ReM246fC8cPa0kS6hVA93oe7+6\n", + "YNS6YKg1qwc+dNJ9rQ3tNM6vE3IjrR9RCwhAQmmBvCrVoAkbsh86hlGhzUKtiVI02hmCl6GUKwaa\n", + "wakGbV2EWeuUOdJW588yRfa3M5eXN4S+R9xRilwjSxF3SrBeYhtao5RH6Q5tDM42uiDTz1wNpiTJ\n", + "pc0FRZEPRJOprjOO1OSoHYJFd4amFQ6L0o1qRNeqkF2MqpB0o3eWPjt80Zgsu4hq5ft2OEw4q+XX\n", + "ZkPKGW89tcF2M2CsYhwD/bDBe8/gLGfnW27+7Pu8+dY79F1PMJacG0XpzwLhD370ff7hf/s/UpeF\n", + "/e6W3X5iszlhHHqJjljD8WaLMdIKGq3nZnfFyXaD7TrKelS2fkS7Hpwn7W9Jh8R3v/MB3/zuAw6+\n", + "45VffIXT8Q0ePnzEhx//kDvHI+//4teY9ws/+PBDju/cY7drPH1yyenJiHOOuExy4nAKq+Glg0bK\n", + "ZdLgUbVQc8UHUdDqpigUfDCklCQE3nm2x6coHXjw4Xf5J//093mRbtlYj9EBZTs6Z2m6kNNM7TW1\n", + "RGo1KJ3pQ0edQStHkCIdpq4+cmXQzQg7QSm8C/SdwwWDs6BD5Ho+UNNCSUmKB3ZVVFQls0tlaUVh\n", + "rBF7pWmEFSv30lOkqqKkLKcjYzG6rgYDOS1ar+mzo2QrNWaiXMGpTKNQysusk7h9jLXY1qNVYL9L\n", + "GDLWBjkJqoquoFzFAjkVgnb04QTtDU3vaU0iYFopnFV0vWYzGgyWcXC4oPBBiGW57Hmx+4Q7x2/R\n", + "hwFT22rWNPTeAp7iNz9z7frcFs0QAs7JHZA1jt3uwP5WlJ4vgRq8LEz+1G7TOE0/eMaNoRuMuG90\n", + "lvsMI6FV6xq+M4RexPQheIyR6FLJFec8VnvsnFhUpLTMuDnB+0xT6bOKmLEK6y25zdSoscFiOnBB\n", + "g7LoamRjnApKa7rBQ9MrLagILNYoaq7ElKipsCyQdWF0jjYbbq8X9ts9ZOh6y7RMxJrIRIzSWNdj\n", + "SqWgsKbjM5J17VE+YXUBZkqWuIi1A9YYalpoTeGV9G2TW9bduZfKXLQYxI1u7LojFiqKzE+zplMO\n", + "ry3WK/SsiCtCrFE47G8pSViK25MTmmr0vYUSUXrDxdPnvPb2O8R5z52zM774ZuEfpT9kOSTefvct\n", + "nt0850++/REgWUCjNF/+4mt8+4/+Kbe7iR9+8AO2RkMRpe322HP1/AZlBpZS6b1DqUzfeWJtnNhA\n", + "t9mQ9w1/ciJUpDljbceHP/4JnzzZ83yuvPHOa/zb/87f5s75u/zdv/ef8uD5Nd/7zg958viCv/pX\n", + "fo2v/Pqv8sff+hP+tfvf4Oj4dUKXSdMlU1zojUFjMEoTYxSCjvNQM1o5nFuHe84SvAw68pLRSpw0\n", + "g+9x/YDfbEna8L2PvkOsezpVOD8/58X1Itlb69mwYZ+ek8oVcx6wBRoJrxVZ289UFMY0MhHVEk5t\n", + "2dhO+tvOSZSu8/ihw3lFNzju5sJuOnB9c8M0H1jqAd0ke9yZDucttQh/0nmFdRmnEzDjjBEWrPLE\n", + "JpVKhUK3QqsZYy1Gd+jScH2PqWsN2hoMk7zPXKOUSM2Wisf5AVqAOhDchsZCLpXbaUEph/ca1Uv+\n", + "1JoV6OPXarQB6zqimmipUqjYDlzW9J0g5cxQ5RRq/jx7OcULPn66cP/8C5wNJ+haSXkBJVdb3f/H\n", + "svi5LZr96HHWYe1I3/d0/gZjrjgcFva3cpyV1qNM1Guta/WtEbqCcQ0XLMFLmF0ZiSLVlkFlQteT\n", + "JsVcpW4odxfSQddKjpTOy1SxNodzDesqqA6aYNtKzryknqPAGkfXebqukss6BHDI/asKYntUbYUr\n", + "yNepSGtv+eUxVuIYxgcRryWIU8GwQC0scWYpM9XIXalZwR6sldAubISEvfqCFAbdMt6IgtWoRrCB\n", + "hiYhcBOQnacLgeAHjLYktABQKAIidoWiBdXkzIitDpUUMSWhINGIKUFp8vWUyjBs6LQllyo9YR3I\n", + "OTJNM9lm/vD3f4e3vvB1+u3rHA2av/Vb/yr/0//xj/nSL7zDF997B4PnweNP6fuee/fu8fWvfZm4\n", + "ND768SdcPH/GN/7KN0QzXKHGSrCOpDRdCDjdqPNMS4mTk3OUlxplVQbjN+QqErDDTeGTTx7zB9/+\n", + "gK/9yi/zw598n//g7/wndP2WDz78gPmwZ9kv/PG3v8PdOye880XFe3/p1/nkOvKV8R7kSyyXONWo\n", + "K2A6z2IB9V7urdMyEXzHkma0giXKdYVzDmsstam10VPo77yKPrtHTjNHJ+ecbk7YPf2Evh+4q0dq\n", + "ysyt4sII80TmgPEFpSeMlpZbDYqQDaZVgtOkIgMmr4S63nsrv8a1mugMOnR0uSemzHg0cLQ95mZ3\n", + "y+72ksN+xqAI1tE5h/cb4U96hQuZVtedbo0yU6iRqhsZvaZHDJBBFbQu9DqQGthNL8PCatA64taY\n", + "k1rvPIPVVKNEj1ECPnj6LqCryNqmZaJZx3So9J0G3SCArQplRThnnUJbQ1MLyiqqUvRViXe+WZyr\n", + "eC9XC0Z7sSboyrwkLnaP8KYRXAdqkayzbjjf/oVr1svX57doBo93HqOt/KCcpZmInNYa8yFRqxT1\n", + "Gy/955m+9/iu4AM43wh9FcJJlcXVGPlzWmV8F8jr4sI6IUc1ako45yXvWcBqTT+IoldhMFqOKJOW\n", + "aZy1ilzEL2StxgVoy8vJPqu9z4mveY1zxJZQupFLpNSFnCulKKmDNcU0HTg5O2PTDeikaLYxlURZ\n", + "nT/OOrQR7p/SBqUqS5oZx9O1RVUxqqBbXZtKUmFzyqErNGVRukDVaDwGg9U9gx9AVYJ2kOVOx6zD\n", + "BvneZ3JeiMXR2gAKcs2oZaLEQlwWnDUMw4ANFopmGAYhJDXQ1jDf7lG9ZRy3PPrJj3n9vQ7dMr/0\n", + "pdeY6q/zO7/7+7z/9S/T9Rve/fJbbLqO09Nznj6LfP+7P+BHH36fr73/Dr/6K18n51tyilxfLKS4\n", + "wzuN9YY4z6Igrl4yltZhXKCyx2yOKMnQlsxH3/shf/BH3+Z6aSjfSMvEd7/7LYoCVw3T7pr/6B/8\n", + "A/7yb3yD//jv/V3unt/n9LhwnW451MqQG9fPP2W6ekxOC40qtdtuJMaBzck5J9tTrm8uqLWseVvx\n", + "J2ljsM4Anlwiwzigjo6hH6BERhc48h3v3X+dw1KYOs9+Mgza8Dwe8FnkX239MMtubyQXRauJ4Axj\n", + "CDTA6kbJDeclVmadwXeBzjuM6/BqJCdPypUua4au0XUbhnFk2S+keY+qRQoRVkl+uFMoU6lVMH5W\n", + "Jw77HSXLsIcqiw9V0Q2FlAvbsRfcm7XEWeP9Fu97Urui8ARDouodxkqluet65grKVrypbMcNXncU\n", + "VdlNF+ymW1TQtAjKKqwuWCdYN6011q8AHyWcz1YtGs8QPIqwxheVXH3QQTFUlfEqYIrh+uoJ52d3\n", + "ZPixXh8Y83O6aG76NdCtjMBya+Ps7JRSILW8VtMEgMrK66ssoJxEebyiD4ouFHI2tKLWO03kiWcq\n", + "NiRMFOWDkG6KtBVoxDThrCcEjzYNZwvBO5yR3JsmsPSJeZopRdOMHBWcl0CwIPEtygvNR9zQYgAs\n", + "VLIppCyRomqjPA0nYWi6AK1Gzk+2nJ6dQoNgDM0UplZoqaGrwuHIaiZXycwZnal1xuhe4AhK0Fah\n", + "OaHeNCTIi7ixFW6twQkyK1hH7+SqokSLsT2siC7B6FWyBdMaNWVu0h4VG33z2LiQp0XUqTkx7TOh\n", + "eHyQgZeyipgKeUlSIa2ezThgmfjuP/89su94/c0v8o333+W0s3zvhx9i0gFXMjePdlx88phSKu/e\n", + "Gfg3//2/zZ2796hzIS3XPHvygPv3z6EWtF6PxkZTS2McB2JrdLkQdzs2J2eUacH4nsvHL7g+FL71\n", + "g4+49+Z7pCWTpkqnFRGDMpqlwNnZKb/x67+GdT2tNQ7zhI6iCDk6GZkuO/YVbndX+NCxnw6ELrM9\n", + "0jSuSV0ip8SyHDCbYzKRmCaC79kenUjxAiM7nZRQOTLtrki7K0almWohLTuGcIwfey7iHmsUm2HD\n", + "bZJjbQWsHtf7+cIYLE1B54VUbnXF9p5SZ5TJglA0Ct91hG5L1R0QSKWyRMc0z2C0gDP8TIkdqlZp\n", + "eWFEEREktldKlWBTjTgPSjvB9qVGikAViI21DaWSzBSsx9uOo82rWN1YUqDZHuV2LDlwe9iRUsS6\n", + "xmazoWaNN06aV53cnw4qkNrMVdqhqsNGjeoq1RacrWuDp6xDngoqY7TDmxWajNz9irDN0srq7LIj\n", + "NWmUFUndFK8Zh1O0scQ0r3nxv/j1uS2azkv9EJCFrhmiMvSDIyxGNBGqME9xJZJL9bC0ggua0AnP\n", + "0jrJTc77RKmyEzS2p7UolkhdaMWTM7TqSEkupYU7WNCu4L2T+xEb8N6jlYdWONqMlBS5vsnUrNc7\n", + "GcRKycrkM+IX0drjjBezo67YmlnSLYKWU7hQiVPEeU1Vmlfuvspmu2Wz3UgWU1W013L5r2X4Y1cS\n", + "ea1if8bIrk+3BCVjVlOnLprcDlhnKRHaOgQCjXUeE2cKUXD/1mF1IxuDNR1UK7peDlSiBPo1JNUo\n", + "LdE7j60e7TOuNlIsLPNMP46oYiTuYySvp1sl1cIUE/vDnsvbK95++13Oj04wXeDFowdcXt5w92TD\n", + "X/3Vr5BiY5lneWNrRW+hlJllitxMz+jdBlPAuca0v8Fby3xYON4OTIcDvQEzeEw/cJgPbE7OmA4H\n", + "NqFnuYxc3+y4uV0wdsvN7S3O3+fOK3fwXaDOGVrl5PiEf/S//y6qFbbjBtMbjIIWNcErNnd72vwm\n", + "h90Fp0bx/OICq2V09vzqkm4/8corr6KUIoRBuKJNpsTBD2I+VY3edeKaqmKodNMtm03HJm6YLg+0\n", + "znOxXBH1wpwjyhp6pVB0JCf1Ya07uk6MAlMLUgv0hqYrugmk2DmLd4qSIzkq2mmPHR3OBJoeyAXc\n", + "tKp7lVx5RQ25M1AarcgDSWthJgiLM0kkqVYMCquyBMerPLjKSidzToNKGKcYuzOcOYNqMTqBKiTE\n", + "VOq9JseCUgspX7AdTmjFrWH0mboOX63PuNQYlELVSFLSdRqURtsqR3KdsG6FgWtDUgqlsmxkEIkh\n", + "hJUUbyhZfOxOW1rVkppRjlIP9H0AJbi4n/X63BZNay1o8XDXLOpaXRpdZ+iCZc4T4ybgTGY/JUqu\n", + "n4WtG/mzPndTQv0wVgvWScslMQqUroReYkq1WLHplSKZtYroWNVA6BogObDgB5qydA1s66gloWjk\n", + "crv+wCvaK3QV1YQAYQPBBLwPQKNUsM4yqI45TqRUsUHTDYZ50vih4/U3XmXcdDgnVTitGlUlDI4Q\n", + "eqxX8jU2yZW+pNekdMBqh9LSNzduHZTVdadtFZS6LoiyaNZOo7XBG9lRvsTkybXCEcE3GpXU5Ii3\n", + "nwoB2PqROkWKlu+BtZYUM5vtlu7oiFI0ZmUeqpZJSYYBtVVMU3QedjfXvPH6mfiqtz1LSVw8fc4Y\n", + "Arlmjjcdoe9oxmH9wO7qGTomTscNNzfXHPY3TFNhfOcdrm9v2Y6BGjOaJpPU0IOSae50u2N7fEpe\n", + "djz7dMfuUBmC4rXzI77zk4+pX32P19865+3X3uDPfvADjDZYY/jHv/O/8qMPvsmXv/T+ykrt8LbS\n", + "O8twukFdn/Puu1/kxbNPyc1y2F3QmmHTBZncpnlttOn1IW6wrqMBuSRc8uAaug/i2Zl25NsLnLFY\n", + "29OFnpu0A5XAaLabgaUWmWprRykL3ajpjaLvT8FodLhhng4YD2gLGeIc6Xyj1SJd8fWBbrzH2YDv\n", + "B1KqGH1YYduW/X597yyALXKPnw3WeJSVHKMpUJIE0xMOoyPBGg5UdHEol0Qlo8D5QOMa609lk5My\n", + "zjqqahiV0NoQ281q2fTE2XGYLjg5fo08Z1ItECVxYK1m7B3WOZYYiSWitFkD+3+u2VDKMvQD2Ypu\n", + "JtlF1gttaFlgzlKXl79mPa951baeLOW9NC+3Mu3/C3CWn61d/7+ujD/jJeShArVKuV9brLUYI/Gd\n", + "WgRY0CqMyrHEBdUMVpfVDCnys0bEuoG+98zzywnZOn1fp2GtGuaDApU+oyvVqqkolpToq5aGh9Vg\n", + "wCiH9oZgBmo9xVmDdSO17QleKCulVlQuOLOh5p7gPFYHlrJfw/iWvpcAcs6WohphmznGcbo55+ho\n", + "KzY8rTFBKEwtKbSy+H5DbQmMIscZVIUKMU0S3DcOVQET6WwGnagpoZR72Q+hqroi/leVr1I4o3DW\n", + "UlvGBo1Vspt1K2gipQOqNI5tj6odaoLebzAEbEhUnfG6k2+xNozjSKvSvrDaYpwjl4LzgZpmctEs\n", + "S+Lxo4+5c/9NSoHTYWTjE8PRlvHkFaiF4zt3GY/OuX5xzWF3QUkHOle4uXpIKYUvv/8+F8+eoI3m\n", + "bDvScsUqOT7Pc6Y3iZZmbueJrvM43TPd3FJj4Pz8Lr/9r/81Hv7X/wOf/OQpb75zl9/4l36F2A48\n", + "ePCYWitf+8oXefvdN7h//11OTs958vED/sYv/wqnr56gN0foo552Bcenp9wcJqyONDRTWtAYrq6v\n", + "GccNm80RxmmUshgbcM5RFcRW6Y0FF1Bec3j8kHLYM4YNZ5tESbc4/SrbfmYphbkVDrUxk6nOoHVP\n", + "6HsGd4T1HSEE+nHDzf6S/byjUuQIrysxzjSV0M6QSkGpQG4d1sppKlgPJlNVBAW6Wpy1JGeIy56s\n", + "IDPLe7guKDVjdKSqeY0IaawRipX3mezteo+/R2vppVciqT2nFU3n7pFrwXlDbR5lNeDJfYerFas9\n", + "KWWW+QpvNkJKapF5Fv5lsOBdwCpgiUIpq41aHcF7vDOSteQW5w+0ujraW6ZmRdN23fgYAXYrTTBO\n", + "OunKgPIS09OVWhXBO8Eu/ozX57Zozsse5yw5JeYkk6/WCtosuFDJ1aKbQHwVZsVUZZkYa6FOC3rK\n", + "ShTBNVLSq2BNtBbSNRU8lbXSHqhVtBTOGErJtJYpRa9g4EwLUtnT1kF0bLfH9P2GTZeJ5YqmL3B+\n", + "ljC5bTjbQzkWt7KKBNfT5pnSFlALzje6wZBTo1o4GjtxWgeDcVEqnNaSSmWeD1SV0aoHbWUDUQw5\n", + "HagkSjtIUDoIoqxNGUwht5lSo0Bei+wuYVWAVAEBWwOKjKLInSOCwKMqtHZYs8VnMG5gNANdf0IY\n", + "HFY1HBB3EzlNLHEGVium0lhvMc4yH3bM+1tKkhjQ2HfEqdF3R9jecXl9ydtvvkONlXG7pdSMbxMm\n", + "bHj+6QOunj1h2d+yu3hM33mePXuMVpnt8cDFi6csy8LdO2cYldjvd1itCDA5DgAAIABJREFUSVKE\n", + "58WzJ3ivWeaFw/U1tw+fkPaNkgqb7RFvnAX+s//w3+U//+/+Fy4edrz11Xv89d/8a3zy8BOMabxy\n", + "9zXeuP8Wu/mWxx9/yq+/8zavvL3l7ntvENOO2nYMznN58wJvNH7csp8TNUJTijgnXGgY19H1PbUm\n", + "jBH7YdNKHtzGY+xIvd1hlz1VGXql2SpPsyNJOYJzXM97VFogGNCS7w1e0/UndO6YMHhMcxx5y2Zz\n", + "wtNnn3K9e7bGrzr2+8g8LWgTaNVBtXInj2NOGWOk6tj1jlqiYNycpnnDrUoc8oy1CUUBFamp4UxG\n", + "WVjyAWtlAGt9wfdmtRnI/6tICQu0Qk4HtNtRWo9xQfxUdU+rC5WJ0BlKMXgzUqsmR6lXagO5zhgD\n", + "NUds8Cg0g3e05qh5Amsx1WOUxZse50CZDbncktUe40TMlpug9MraFnK+k2poquJEbwrvRNmiKqCN\n", + "6GzG7meuXZ/bohnTRENyeDHvqVl0F8ZIRKBVTQSUEuhtwGJcJ9Uwm0W25gWwga4Yi1BMELxbKcKv\n", + "bKVgrFu9IhKmhZdUTCONBiv5u5yjkL6LvOmtCxhtmKcDfhhRJlAIxPKcqsTD4swGyga0Jq/k6sqB\n", + "Jc1CNNcW7wAS2jtG7wlmwYcJpXpimah4puWWm9tLjo+PBebrLNpAyh5SpSk5VueSPzP61VaIS0Fb\n", + "Q4pK9BLrG8Q4g2qS16str+0kyHmRlpSuWGMw1mOtxXvFIWWWekWOL6h6ppYOE4XJaIG8zITQybHW\n", + "u7WTr0lZuJnKDAyuEuc9Lw4HIIPNDGUglUaKH/HK2V0ePPgJJRceeYPxnWRdafTbY4KRxS9XqMby\n", + "6MULKJU7Z2fs9rd4pWQ40aDvB168eI6zQrSquZCnmZsXF1w+u+L8lXvoAo7Ckd3w7/1b/zIfPXzO\n", + "dz++4MDM66+9QWuJki0vntywzJf80uv3eP+9u/zCL71NPFxx8/wB5uIFF7tLpsOtRNfMgFUJ1xQl\n", + "Svsspsjzi6cMw8B2M6JS46AawTt8Bbc9po0D+dFT2rJnOUxM0wGdIyddx20x7KaCcQXtoOkMpTAE\n", + "T7YNZQSC4s2Gznfkkuk2W5zqiNPCNF/LvbjW1GaISyYtkcM8448hN6l/UiKtIVc7KpHVhFGe3MQT\n", + "1DnPNEUaiaZEC6Faoa4blqqU+MZ7zdHW08pMZkGpRllBzbktUCAXzUSiFXmAh07T8i3GZUInylxl\n", + "Da14kjKUJBuhbtys5soElFWeqBlcRyHijRPvUtbgBVVndQfN0/meXK8peVo3DQVjwtqZBqc0tS7r\n", + "51+WP2tlSFeLlEN0/TnNaWpdxcNCJpcDiYhuDioSKUBBlQZQ5wXIoHWguYnQW6yptDavaCtR7zpr\n", + "KElo1sZ7UrkGEs1KnSsXoVlrLWR4FwasT8LXxK6K30xpkRorw3CXlGTh6e0GZQaU3bCbHXMWIIc3\n", + "5wKqMI1UHCndoE3GFE2pGZrC2gBKpuzGWvlv+j0tWWJaiAV2tztyjSgtu1aJT4H3niUp6ewa4Wc2\n", + "GtqtDqLaKDHJhL0sco9U5B7JWCs6Y9NWe6a8d4wWZmBrmZxn0E52ACoxc8tSr9lPC12+w5Ee2FgP\n", + "RaqDu5uduFmsGPuU0kLsBrR1HOYbye3pxnSY6XoRWXnvSDFyfXPNq/ff5uLyOcZa+n4kx4VaFqZp\n", + "Yd7PlFqIy57aDK0FmorEVLnjRpwfscGzpETOMHQdtUZKnEkx8uR2xnUd6Jk0PacuYMKWzXZkON9i\n", + "deH9t+/zycOnPH52w9WhcXQUMK3yyhtv8PZbb/De19+FJVGvP2L+9IfcPnvMze4KZzsyho0fGLU4\n", + "bOIhk2Jmmm9wzhC8kJ+stoSuF6Tg0TH0IzlFvNZEJ2HzlGZSVVANWhX60DMDUWuKiuhciTagVGJJ\n", + "t+SaODs6EgbAygTt/REUePjoA/aHF3inIMuCU/ItOU8sKWKa0NM9AmRuFQFYl4m4FEoVgLczA3bs\n", + "iHHHkjMxXeNMxNpMKQalPdZHhtZDVZSmOExaNhQ5SUi8jRSVoO1FkFYDBkNrBq0DqlkUhuDFclow\n", + "9ENPjpZaBHitnZfvT9mjtJPscZ05LAeRB7aCMnI6Va2X+0oEOqJVh9FJ2lrKgupQKtBqWIEhhVoj\n", + "OcvGwPuOlj2tgGoR6s9pjdIYQ4xNIjlNpms0yShaYylruNYag1UGmmgLjAsYK64YZwMtTWhrsM1h\n", + "6ClaiRLaQjOe3MS0aB2kHCEJpspYjXWGfpRBhjaGSmFJB3ptSWni+vYnbPu36foBimIcenAa48+5\n", + "vp2lNaS9YK4UKGeobQdzQrsiCdOyUJvBWJFgaVfASrUs1SuZlKpGinvAgJqxrhCzaEyd2WKtIbVI\n", + "6KRKp8xCa2LYqxUKhiVK5lTZgpzFtag0qoK4oLVYFGO6JeaE1zMJLcO1FigtAguaIkcU1zHYjhob\n", + "+3TAZkF4lZro1EDLhXlZqLWSSuRmd71mPRVD13G8GTi9c87N1SUX1zvSsuf46JScMod55gvvfYmH\n", + "Dx7S9QOvvfE6F8+eMh92jGPP1e4GbTXLbqbrNjjb04eRrj+nWSdA6QpVa3I1tNS4vdkxzwvOGXot\n", + "QNlGoWsVPzpivOH8zffp7r3Ch3/wf/PmGz3vvH2OMj26t2yPTzk+7qmxsH/xEy4fP+D5xx/R5oiy\n", + "im7jsb6nU4Z5lnB/qzCOPQd1YIry4LDWMo69UNBpnBydoc5fgeNT1IsnlFzXHZ0jayO6Z20INnDU\n", + "JIJH0nhvOajKbCpHpmeXPLc3V5wd3af3G4nJBYPzPefxNTbdEdfXT/n44T9HuwPGKmq9JOdLynJC\n", + "PHhaH4C0CtosVXXM2UFVWBVANXKFli2dOcYbj2k9MT2RoUqTzLJKgeIK/WCJ2RJCR8x7piVR5obu\n", + "BEJMS9Qyr0kTvy66cqIzSWGNk567ttRk8bYHq0lpwdgkLFnVr0fpjPEBuItyO4LvX24eSWXCak2t\n", + "mSVONGZKlbt/o3vJLFcDyqKUwfYj8yIAk1QWYmr04QyyktPvT2FJ/kWvz23RrFVQ96kUytr91LD6\n", + "aCq6VZzXaOWwTdzlxoAz0ot1Roldztj13sauHDwLWix8unqsTqSa0EYyYbWKMdGg6JyROp6uq3St\n", + "Usokd6M6MMdLunCK1SdY72kCCsQYQxf6z3KYRksFsdZFyDMeWoaildgoyYD4VKqKNO0pTWAM2lRy\n", + "3mO7Ri1Q24RSSTwprWCto+sGCjuSSrgmKlKFIdcijd9myFmm56U1nFoJ1qXgXUCrgRQTpR7k+AfU\n", + "ektplkqgpkLThUZEo3AtYJrDNkcXPDpWdC0UK62l2+tLUYW0yjJn5uWAptCyoTs6ocVIOizslkjJ\n", + "9bOd79X1FVrf0lSltIWvfuWXePH0Mc8fTZyennB21HF5c8upOyU9ayydZZonjk7vcPfVN+m6EyE9\n", + "xYQvWSbyXjHlmYahtURqBpcFUG2NZnd7wRv37tKsZrl8gj67yxd/+S9xuLzi6vKSZX7GWE+YLw/c\n", + "PJ2J88J8uEEtM94o2mA45Mh8dWAzCHyjOsGMeec53EykHOmHHtXg5uqSVhPD0YZNv8EcnaKOz2go\n", + "9IpMW3JiOczUIj+LluVr6Y2hGUtVPddKCEO6ZpK1wr9Mt1wfPsX61wl6xChH5yz2aOSw71HV0+5n\n", + "rvZ/xpye0uxMXq5ZDs9xfSBnoYLV6oQ1mxUwUtIt1AVTe+mFV9FFGGMZ/AmhGFK5IOUdjUxDtMJK\n", + "K/ou0ErF6A6rDSVngZqstCSjG0pVai4sU0S1tVefK615tArCRFTSW6daWhMyu3cG321Qpch9fkkE\n", + "7cjVoKoUOlByoqux0SjUFslFct3OeKwNsoM0DZqE31EapZw8BBzMywGaJfhjVPOU+HOqu1BK3tgq\n", + "G7SWjJbVegUFQ6wCcVCARQvJ2YppUhuDMgVp8ldas9SqpTutxZHeapbpWDNYW6muEhdhIWoT8Xoj\n", + "YjM0xitqFQ+RapWUrlFuizKB6/1Djke5K22x4buXwidFaYWSK1EpDJXKxFInrO8BMd9pZYl5QmHJ\n", + "daaWiZID2lnG0Et3NlnmQ+JwuCbVayrnaNzafy90HJPrgaYupfOOXrFdkuAVG6UciZuWqJUCSiwU\n", + "5I1idKCxrLU+QW61lqAmStPkKJpglS0dhqNui8uOkjLKqhXkkIVNSqRMkTlm5qmQcyKVxGZ7wsWz\n", + "5xjdOPy/zL1brG7pVab3jO8wD/9pnfehdh1N2RhDuZ1uh0MIJCg0EUlDK4mEZBQhYaEkROLG3FkC\n", + "gRLBFTcQISEBUhMpBDURQQpK0lHSdtJpCQeBSbnLUGW7ylV7V9U+rb0O///POb9jLsasouk2Jgpp\n", + "wX9Vqlq1dtVac47vG2O87/N6FEmGChmmcSLGxOZgzfrgiKOjM3IqvPDCs+zGHavNIeN+INQ9MSVy\n", + "dVRnOL15BLXh+nLEhIFbTx0TnaNkwTlHJmDWJ7hcMXGvpoNqGKdrbPGsVyfUccIddEzbC8y45fLd\n", + "u9im4Wx1wGVxXDy5R9e07C6vKbVyfLghL1vefecBl+f3WbcGfKdAZtcTayElyFMk5kSqM6jD6R1l\n", + "HAb65ZLF+pDatdRwjc2VGgdKSnjXEGVPDpGcktKlqMQQMLnQW0ssFpGWnIWpFLzvWYpl2l1zWb9M\n", + "v3ma3i1orMMsFhgimZHt2HNkn2efWoZ4nxICDDvSfqs6xqDvW04VyQZrOpAd15fnODZYezyjGS3W\n", + "Ohpr1RSSRyKJmCeEiOBAHH3vyTFgRaliOSudLMakl5hqscZjrUKRY1R9dUwT02Rp/UL5VzWSwg6K\n", + "x+BJAQyVVa+yqZoMtRQlgBkDZSDGgWI9Xgy5VlLVDbjUhUJzzCGWDtPuNEkzKXlKELzvNBa7BITM\n", + "MD1SWZ1Z657k63z+GjOC5kB5r7nWmsEjs/hc3t9mOycqZzFKpX5PD2fm63jKf5ZoGYPyojMN1im5\n", + "yNCSMlAz1hS6pgeqwoaNqP3OVEQmqmQwmVInYk4IC6RmLq/e4fDgBuDIRXT+VxI5JVLKpLxTgrYU\n", + "ckq6RHJqgWxblcCUAsUtqDVibY+zepO0pqPvT3F+S2RLLDtiuqDvnJ7oWelKIgbnvMaZlkipmSI6\n", + "hzIUWtNoBAcWqnIUS6nkpA+JGEFEN/zvKSpSiZgSKAmN8ciVGDO5JCTvWNPgm4a0D6SQsKUQxokw\n", + "BmpK7Pd7chZNZDSW3TjirKPdrBXskRMAXbfA9ZGr6y3FdmxObhFKg+1WnO8musUhX757ztnRMXee\n", + "v8F2u6e0D7n7ypc5f3BFzg/ZtI6lF+69fsTJ2W0WywPEeprFEu97olmS3AlLH/C+4DZrSgTEsNs/\n", + "4cbpDTha4oZAazsePHqXEgL7aUByxswz477teP0rX4YaadqOg8MjnDEKl0HIJCgRb1pa17NceIZB\n", + "/eW1JqRUGu9ZLdeYtgNjMPstNU6YUqjWEseJrmuZRk8qkRgnjDgWtqERy7YEVhha47G1YlIilIqn\n", + "Y5smhu05sY4smobGPo3FIRSkOPpuwRguWDVHyJSZ0iU5XRPHLUVavFgsaY6/zqSUNVnSV/bjE0wa\n", + "6Zo1OYGd419qjXMn0yLonF55CwqVWy5WDDISgyoWUlE6OrViTYt3DWBneDGAI8WRfd1SS4NrWkpu\n", + "dOEU1a5sciGlwJY96/VqhtG8N1vPxKBxwKVkcoFMBJOpMlFKxbuOXFXor/G/aoKJaU9JmZh02VWq\n", + "dqG1JKb0LtFczDXiL/78pUXzk5/8JL/3e7/HjRs3ePnllwH4mZ/5GX71V3+Vs7MzAH7u536O7//+\n", + "7wfg53/+5/n1X/91rLX84i/+It/3fd/3Nb+viC4nKt3s305gC4JSjpwR8pzFY5v3tt/yXnKQMi9R\n", + "iY1YzctxzlKyzEVmxsph3kd62QlKcTNuTdmUzluMVep0ISNNpERDzZYiW2qqlNKw3cJqfYgkUYAB\n", + "mVK19ZzSSI5q/apkataxQtuojtE53a6mFKnG4Eyjsakl4myHcUZD19qWFCdiCdi0V2xXcmAyRty8\n", + "7WcmQFlynAnbiJ7mTuVWxugIoyQV8DurDqsc0dmxoEWcQs2JWjzTOGhJKBliofUecR1UQ9s21DxQ\n", + "cqBpO+IwEXJksdxoiJWx5GJ0tmxVuTDlQtf2iAhXY8BSOTy9ycFmzWpzwLMf+AZOT4/BONq25+Do\n", + "Nk8eP6bajnbTsYqJk5MbvPbwVcouIl1ldbpg2j3h9Qdv0fmWbrlieXQD3y9JtmNxeIy3idZOVGNY\n", + "r9dIqSwWjmF/xfL4iJAM3fqYdYpc73f4pufsxjHbJxeEkNltH9F2HbZ2NL7BOa83yRw1frbRW9A4\n", + "bnWGPRSsc7TekSZVKKyWG3yrQOZsG8yUYHdNiokcJ1IMTMM1UGkbjbMVa8gxYhH6WlVbWwpL4/E4\n", + "kghXFIZiCCYTtw94bJbUpaN1C3JRrKAmpToEza7KeUFMetMEVYDEOqn0BiFlCOMEJErdM8VrQrmi\n", + "9z01Cg36zNSayblSSppvmZqoYK3yI9qq7X+pou191SDDvl9iMPqezrNCTYwVfXem/ZyfBbVUcnZI\n", + "jhoYR2W/nelIbn7sJapZZU6xtGJIUUdVxhWwGiUtoo4nIwHnNEUzJV30pvnSAQXrtBuyAqWOlDoS\n", + "yvBXK5o/+qM/yk/8xE/wIz/yI/9cwRM+9alP8alPferPfe0rr7zCb/3Wb/HKK69w7949vvd7v5dX\n", + "X311nhf++U+tVbl/ttHYUCNQC9Zape0wkqvVxDqCbnhJNKI3rxjTzOkDmQuKVNHi957uigrGYygq\n", + "ircg1WGKx2LmRL74fia6sqwFcZaCJeWJWjOpDkyx0BeDoyekRAwjSCKTKZIJYaTxnoJGY3jjqGKU\n", + "vJPVt15KoWSjVvr5T7M2Yp0QksH6AC4wpiv9b8yNZsGkNLunWphzZkSMivQFUi6zrEpUJ0dRmRGG\n", + "mCKlWGy0+FZjQnJVelOuFakRi1KsS43EMuKlIcZMcYWmXcJYsDZQ2w5iQdaJ5bLjYjtQykTTAzmz\n", + "3+6IKekhUISLqyd60zLCcnmDao84e+oZPvrSN9H6lkcXW/bjyFO3b5Oy4YN/62N4t+Dy+gorHmc3\n", + "XFxPfOXz1/zR73+BF24t+JaPPoUlMeFZtisuL3c0IXCVPM+uDtlNe45vbog5YFLEdZ4qlrbrKX1H\n", + "d/sG5tYzHN+/x/jqFxjHS3Z3H9N4w+1bSx7e23G12zHFxNAf0blC23bQ9fSLHus62sYxjYFxGui6\n", + "nlwy26vHQCRknQ93scDVpb7o/QozteTrc0ouWCKLpiVadfE470i50jjtUDo8aTfSkjFVD9nRGLwJ\n", + "9HhibsnumsvdVynZ4lhi7IYadSkSoiY/1mxxtOSSiEOiykBtqjqPqnYvOWWmKZB2O4QRa4WQ99Ti\n", + "6KXHu1ap/m1FopAmsFKJRWN/a7FIY3BY2oUF02GmaY4BcTRe4d1TCKoksT0xB8RaSgnEOmKDByIl\n", + "tYTksSlTcTS+o5TI5dU7aqSQgSlcKlzD6OVKRMhlrzKq7HAiiK1zLIe+B1PYIXTknBATZ+Kk0tGQ\n", + "pJbMKjjjYUYy/5WK5nd913fxxhtvfM2i9y9+fvd3f5dPfOITeO95/vnnefHFF/nc5z7Ht3/7t/9L\n", + "X+uNvvRGBGyjt0OTKSXibEPOAbFgiuipUKNqKv0KQTFkMSdy0V90KoWU1VObS6amjPVG0+oEIoHW\n", + "VlIxiFiM6OnnPVQ0LIuZ0QeGkPIcE6wLErHCMF2oDSvpD1tT60S3/jWr+DZ7sjiMc6S5ODnX6QLK\n", + "FVItTONE13dUKYS8x+aEMZX16pgQd+z3e8ZwjrMLjGm0fTZRRxjG6MNahWqFWNRDrbkvGp0rkrUN\n", + "yUKIELnCGk9xhhIVaZfShHULRNOz5t9pIZcJTMDWR+yCpaSJlVvhmoZp3BFKQpwCpFdHvYKSjbbx\n", + "65UaAXKBmAFnODg8ZsqFwyO9lbZOKDRELP36iKlccf/xjt12z9uPLrHOcfvOM7THt7l9dJMPXW11\n", + "sRUmDpuJ633keNVzevMp/uS1h0yp5dadO9x57gOYruWp0yOOT9bUFNhuBxKVg6NbNLc+CLYjhx5q\n", + "ojt8hoPlQ3Yh8nAI7Act+vSHLLtDzfrZXrMb9Sa0OTymGkOqajtslits15NToml6DmxHGa8xs20x\n", + "Hqxpjtb6uxq35HHPFBJTmFMTjZBzVZwgWfOcaiVXzdVp51a2lsw+XVMEnC3Y+Z9FK0S27MI9pK7I\n", + "6SGmNNRkQTKd8zizYAhxfi4jebzUpY+gJK8qlCKkOBJzoHEeEPVgl4lq9qSyxUmL8Zpe0JVeo28L\n", + "SrSXgLEVIVHKpLduseSUEaPgnJzUpGKtJeegkjkRGt+QkzCFa4yxMxW/o+L0WYwTvrHkEgjxShe2\n", + "0mO9R2zByBFIZgyXhDhhTNUcsBn9WEqdF1JCjhM5F0rN5CqkOlAp2NohUtQdZRW/WP+qRfMv+vzS\n", + "L/0Sv/Ebv8HHP/5xfuEXfoHDw0PefvvtP1cgn376ae7du/e1/2BrEeOYYp2lKrrFVqlExTlLa3ty\n", + "LlTRjG3bqlfbmo4ULMYmzWQmYavoILqEORTKo1kpKmpXrFuFbGakm26gQUnUqSZsowNwEYuxBUmW\n", + "lANWGp2fJiHEHSXb2YqZlTCPLmNKhpw1j2WUQWODEaxJc6H2GDMRAux3ezAR5zO+eLpuTetPWPVP\n", + "I/Uu17sLYtjibY9U+/4c0tiZYiX6M8xZPfgiyjW01qqEi0KpGjuQc9B4WrF0c3ZMqUIJ2pZUSaQ8\n", + "IaK3zVoSsXqkOyVLItSMsR0HN26zuLNApsqwv+TJxQPyZLi4esiUIvshsGgdq4NjlssjusWK6/GC\n", + "guXeW4nOt9y8ecaqc3T9jBBrMuv1Ac5fc3LrBl3bcb0duNzuaUzhw9/yEgeHJ7z9lS/TDQ8o2XP+\n", + "eMCvRl76+Hdw69mPcbU9x/vM8e2Ws9MD2s0B5xeX1NxTs2WwRyAdvjsF72jMligThy++yMM/PCeb\n", + "x4y7rVoYt5eEMbA4WOvopqpDZXf+gCJCzJnVoqftOnWN5cQ021R3uyusF9YHN5HgmLYT1idSSXTW\n", + "0y/WWDNAmZT0Po+EUoogRu2BSaOYqcpisLXi502xKZVDJzgMe3Fkk9QcURMxOnIQvKxxzpCix/ke\n", + "7xK77agtcBj0MRJQu4Ih10gKATu3rwY7O+garNXCGeuEbxtyTjOQxkLRGbkYQwwR6wKYmRFh1IZc\n", + "a0Yo1JSQrIsakYRrdLRmnWoxU94CDlPXWNeSY9ZuMaFJmX03L5YMYj1iFT5uZgxkLxus25LLJTBS\n", + "1OxDSAHnwcqKWiGGogCcGpWKxHzbzrPppWgumYrq/38umj/+4z/OT//0TwPwUz/1U/zkT/4kv/Zr\n", + "v/Y1v/a9ON5/8WOtnTfoWa/IxmJMM5vwA9Zq6h3WzqFLHm86naFIA85i6grJlVx3FBEgUquhcUul\n", + "PjuLdZPawWrFiH7PnMBZg2+8puxVbaVTAcl+ZmpWHVybCERCKO+HUzm7JEwRbCTmQsxRs31CJJWi\n", + "Pvbq8Y1FJLHdbWmadhbPR20p5jYup0grG7xd422Pk451/xTDkNlPO6Tm2e/bAQNGkpKTcPP2XDeA\n", + "1ugiyljBiNWFTp6dV8XqwshZoo0qLZJWgckm6AbaZowpNFkYh8LyYM1ivWDV3uTQnTJdDVxtdzwJ\n", + "19Rhy7i9Zhqu2F0N3H76aZquo2B4/O4lj999xL38FhXP089+AyenJxyenUJNXA7XHIVDLt58AycL\n", + "Do6OwRoODk8Yc2bTb7i9OeH+w3dxVuUvB0enfM/f+wH+19/+B7QhUcdATi37sRDjRCpPONxsOOpb\n", + "jOtwfsnpc6cQoaaM+DXVOmhWWFGL7vnddxievMO7b9+ltwmXA5dPHrLslvjNCuMdxjX43lCqYYoj\n", + "fb/AWa8EoahMz8P1ijQGas2s12uOjs/YnJzSHB6Abagxk7ePmcIEUeVhecqUaWAqI63oZrmWqA6w\n", + "mHR05bRDMqniqtfDvC20thKz5To4aDydh33Ql9xKo6qJohCcVM3srMmkvFfCUoGUE1QN1CsykpNV\n", + "EnzJWlBQ+pFoQAHWRGqNtIueahLRWBgsMQmNW2BcYZwG7cAwlBowRlvjVDKlCGMcEGuxThF072mM\n", + "MQWLoRSZY208+KhxKJPDUNiPmvNkrcyLJDNnqKs7jllPgniqKKshhAnnM/tpoG+1jmAMgsfZFskt\n", + "xuiFQsShO0tl5FL9161//5+K5o0bN97/6x/7sR/jB37gBwC4c+cOb7311vv/7O7du9y5c+drfo/P\n", + "/eM3qRVSKTz1wiHPvniqEI85O8S5npJVY2ktONfg3FLnelUJPYYGpKGEgEiac350Xul9jzGC9wbj\n", + "G6wplDqR7Lxln617OWVyiSTUSeRqg/MK381moFpLiorGSjGTkm4TEV2ipAKIRlpQIcailBSXyEVb\n", + "IWcs03SN80IuFZlDnlKsOK9F3JoVtRpqHbVlMw2gkASZ2xVrPDGN81zGUYujSsYaQ6lxPvk1SraW\n", + "qENzdHhvRJcDuWj2UZ3lSrlEKhNIZtGsOexucvr8HeLQIKFnex6ZhndZ9g0GtaTWdkUuHmkOufW0\n", + "5+LinDe/9Ab73QXtwnF4+BQf/eC/wWp9xPVuz8PHjxjjE1YHa77xQ99MHPfce/iQTX/E4+2W7sGC\n", + "WoVu1fL2vXcxxnHj7AbX045xu2WzOebkzvP87b/793n5s58hJE9ZnnL81B3cBm4cHrJZLDHec/7o\n", + "ios3H2C7Hu8cTbfm8LShXy+xNVGNxTcd6/URnD/i6GTNW19+nX7V4w9vsQ8DZRppqeQpEKdJRxC+\n", + "YbvdUYoWx265pm87ckos+p6LS4UQu25JuzwhWdF5bs74/oAigWQm0u4aMZaQi3ZEVrshXcyAGKFx\n", + "DbUUMELrhBQqYy6klJFSaMTSySG1joQ8gBkoVZ041rYgfoZXN0C/ZgpTAAAgAElEQVRPrU6f8zxh\n", + "rGbYl3ylMr3iKRSyUR4BFWTUILWVayg5YN1E4zMljJjOcdgvCM4x7D0pZKztsPaQGJ+Q8ohIIZdM\n", + "KhFqQy5CrIkaGjwJYytNM8dSe0cMy5leNsfVWIupomyErP77lNQs0EkD0VKsxo4IhlQmSt2T614V\n", + "E1ZZm3lWRUzhCmpLpdP8I2kwTuO8pS5IKfD6K+e89eql3lL/VbTn77zzDrdv3wbgd37nd3jppZcA\n", + "+MEf/EF++Id/mE996lPcu3eP1157jW/91m/9mt/j3/73v4mSLcXO5vqU5jmhQ2hwVsiibWlMSUXa\n", + "1QCt+k6LI5WCE0vI+u9b22Do1IZFo6mRjSeXHV1vqDkxEkGqnlJJiKkorTwXXGmg7xDrtOA2hTJp\n", + "BnhKkZQLuQamXBTDZpMSocVQUO0mYhlDJKSIiQXn3ay3TDTGULLKqaYIJWsfcV0u6PsVy/6UGHVT\n", + "aXH0fkkpdT5FC7mIbrxLmhdeWbfr8wbdSEVqwdmebMCZTOM6hrgn1R25Nljmr6/Ky6ypIibxkQ+/\n", + "hPWW+++8zZdff4XjzS18OWLhT1m2h5hs6FxiGAeSeI5vHZND4atv/CmXjx7gTOVbv+M7uXX7w7zz\n", + "zlf5Pz7zP/L4yQNOb93k3/t7/yG2P+Ltu2/xv/zP/4iTm2f87Y+9RO8UwzeNE+MYWB+uMMayu97x\n", + "R3/4RxwfH2Oq4dE7j7nc7tlsTnBHN3HrAxY3bmAWHuMNi/6IkkaGYSCFhHGVcfeY1K7Adjx5/ISQ\n", + "LKuasZ3HtC3d8U18SSQbwXekNFFCIFahwRCmHVUycRjJYSKHiHcObx0xRMKoSyAaj3HCwWbNen1K\n", + "vzmgmozPLRJH0sUjdtdXpLDHOEPI0DUdp7efZ7jest8/JoWB1aLDWIMJ6EHpHCYF4n5AaqUzKp0x\n", + "xutMtQoRyxBVZ1tzJadJl57WIuqkwJSG3h0Spy2IJrkaosbCFKEkQ1YzsxobrCXs37MROtYH2pF4\n", + "V0gZSjaKL2w6pLYkFwnRYUxHKZDynpIdvtHn2xqdMUIllqQ/R++UkWsV2+adI9UIWCV/Va85WFY7\n", + "z6XrVQsctuR8Tb8y1AnaWikUxEKOI5hKiAlXHdU1eL8ghsxuesyyb+etv1f6mVOQdywJsYYXPnLE\n", + "cx8+QKowhC3/9H9462vWrf9XRfMTn/gEn/3sZ3n06BHPPPMMP/uzP8tnPvMZPv/5zyMivPDCC/zK\n", + "r/wKAB/5yEf4oR/6IT7ykY/gnOOXf/mX/8L2vMgcipSTesffw9I7BeVConEdORmkRkqqiPuz+SEG\n", + "lRsUwDjEZ1KqWNOQq0EsGiJmCkjA+kh1FY/mm9TsEAc1CTm1GjcqC1JQ6Ib3YEW0fS8wBdVUZqNy\n", + "hZgHyBVvq1ows84PU1BtJKIRHW1u8M08O6oVisbLhqjxqCkZELi8ejzHbLznoAFXe4SemPbEFEgV\n", + "clVBv3W6jSxzWqcK2i0UQ5oSJcssU6q0zZKuB3GaLe3m2zaSuPnUs3hOePfuu2SuEWs4O7kFucEY\n", + "mPKWkgJtWugJbVsOT3qur7ZcPH7EnTsv8JFveYm7b36Jr7z+FV794hd58OQRd24/w3f/O/8uu/0V\n", + "/+Sz/5TqLN572u6YF198kTdef5M7d55mHCecbbHWE6fEOG6ZJpVJxRC4utpzujnA24Htbou4hoPN\n", + "AY/P90z5Psv+CTfONrQu4UzFeej7jpOTm7SLNdV1rFanGNPpIq0IaT9Q6khdLlie3eHZzSnj9RXD\n", + "9SXjuGcct6zmm0owHaNcEseRadKQvkW7YBq2pDDSL1YU69gcbug2HTXuyUPBNAM5QWk6+o0hx54Y\n", + "RmydSNOOy7CjGEO3OqJpn4IcidMOjCPnqEaDKrRNgxTLEAdKyowpgTesxBOqILXDDpkxXjDFJ4xD\n", + "ZLV4RouuiUryMSsOl08zxUsqo8qCbCCTSLEyxVEXN2gGFrVh3KksTySyMUvw4FwkxURI+3kZOy9x\n", + "65JMT24qIYAQSHFAjM5HmRUvalLR/QWS0YztoiYXo4QjY4TO95QIgiHUSs1C4zqkVqZ4xeXlfayD\n", + "fqnvqpgAkqi54F0z15AeZ1qa3lFYoFJ5g7hCpcWZTsHNTdSkBCI5q/ba/SVV8S8tmr/5m7/5L/29\n", + "T37yk3/h13/605/m05/+9F/2bYmlYpyGlcU0v/RZaSapZhppMM6xWDjGFEghKKjABYpzGKObOKmG\n", + "mqxawqrOZJxfKonHWdVyWYc1hmyCYuQmIU5A1gF7qoacHGGyODQxrzoza9EADM6uqLVqtojrSbkh\n", + "1nN1Jc3a0VqKbuxKVsmFE1KpaOx5hFgBSwwZZmiBtyr83Q9bUglslgsMjW7NrcXiqWVFyjvCNFBw\n", + "iNtTUNKRcVlvAKUSo2K6StGM8YrON7vG03pH1zvE7hjGa5aLDacnL/LmW6+T6+ucrI+QamjoFb5Q\n", + "ITPhbYtNPUaWNNbRNR3biz3Wej70Td/MeL3j5Ve+QOcMfdfx4OKa7/7u78G1K/7P//2zxLjj1s2n\n", + "GYqwWJzxw//xJ/iHv/UP+Q/+o7/P7/9ff8hzT9/h6upaSThiSSkSQqDrOq6vr2lcwzaO7Ic9YRh5\n", + "67WvIN/wHIfPnCHeEXPmajeR88CN40Me3H+A9x0HRx7rJ+7cfkZZpCXAJNjFzLdKUJuO9vgU2e51\n", + "E2w8hkfE7SXTtKdQcVI5ONpALJQc5meqkFNlCnqYnR2fIdXQr49w/ZI0RcZxS9uv8G0PNTKeP2bY\n", + "bRl3V0jNNK3DiiOnSIgjWI/3K4pMLG0l5UoIIyEZhW+UTK2FphqmkiEbGtPT5USolTjt2A2JWi5w\n", + "5gDX9+/bcL1dUoP63UuN1NqyD+eITIhMM6NSI3Bz0flmKY5hp++HlBYrmb53FPTZLjlhaHS2Xg2m\n", + "dLTmlFXbMsaH5CqUule1B0LfeyIoC1Z0ZiuE+R0TBcjkQJGJUrdYv0RqZWF7alpQyTR+iY0dU3lI\n", + "SFt2+y2+KRgbEWOwRm2/zneA0o8QMKihxXghpkmBOkbf1ThumR0gmmprdIn69T5/fY6gbCgygTQz\n", + "8NSSqTTV4n3LNAVaa2jcir4tXG4fkSUgU5mlB41uHnMC9AdQcsa4oNxNsYzDiPMC1ulySToKAeej\n", + "UtCz/rKcF6YxE2Mh2Y4YIxjNQwHVvJms1rOUIq1vlTifVSjvnCFRkFyBMoOOtYDlEqBYEL0RxhjI\n", + "sRCniHWGtikgSn6JEhhMZdEssEbHECnOA/PiKWlkShHxgabNiFFRu2TVfOZcGadA0/zZdtM3LV4E\n", + "ZwYaByI9d57/Zu69fY+vfPWPqUUwsmLcQ99lSh4JZYtzKxwdhkRM51AHSlpTa+Xm7UN22z1fffNN\n", + "JBuevfUcFxfnLI6f4sN/69v4/B98jjhds1lYmsVtrvaBb/nYt/Hxj38b/+V/8TP8Z//pT/Bf/4P/\n", + "hm//ju/k1Ve/hFA5O7vJbruj6zpqrTx++Ihpmtjt9ioFipk4BA6Ojhl2E/HeWzz97B265YIQlOCe\n", + "MRyenOHbJbVaFosNF5dbQqpgLSdnB8RBA+TEClbAJGidw5wcY8eBtm+RWhkuH9BZy7Db0TjPjds9\n", + "1xdPiGEkpYiVwmrhNUveGbp2Qc0CpsUedjAtVYQ97tmdPyHur4lBpW2N8aQQKTON3wZlH9RuQSmV\n", + "UHSTLUZwXU+I4LKng3mmLjqvNJ79NJHjBTV7pqnHSmHYD3Re7YZ91+ozbB1hnB11pcFWxaxZVzEp\n", + "46rSqqCS0pZaW0qx+MYTbeHySdQZek2EMJIHi6kTzjQYY7TdnaCxPTUdkmwhSyHViJVWDRadJ6Wi\n", + "IXwqpHx/UWWtxmbkvCWRcK2nMQdI7WgWPYIlhKDQ8nSEMiYs5J3alSnMvkCcPaDooBhrdQyQUyZE\n", + "3WVQCqkGQkiMYSKFLaVWXGPUVPCvSnL0V/3EkAjTiJvjGnIqhJqQMeNNi/MNVcA1SxZFmEJhzBfs\n", + "pi3WRxq7whg/pz0mck6UbAgM1HpB9Su8OIzpwSpk2MSilBMTSJIR4/QWmg3eiQq6KeyHPb0bITYq\n", + "LaoTvuk059k1FCrGFHzV+AJbzfxjLv9cu/xeXLBF5ozolLOCC8bAOBS865CaMWbS7BVvmaaEYWTR\n", + "GMQKxjRYBx5Dmx1TZn7QoFSwaJ5QxpCLbktJSrfPuSLGzeR5jxg4Ojzi0ePXCGGHtR0xGYpkprRD\n", + "ksG6hIREi6Pxa8R6nGuoudL3K45Wxzx6cI/d9YC3DYt2yZQTdz7wQbZXF7z8xy/T9Au805z4YYQP\n", + "ffgFnrn9AX7lV/4r/pP//Mf5zP/2Wb773/wuXv3Sq2w2a8ZhQIxmT5ch8cbrX+XR/UecnpxinMfk\n", + "Qq2Zg4M17vSMkBLjbse7b7/D4eaQk9MDrFjeuX/F0dGGzvQcbNa0y56K0K06uq5lNw50bUsOgabt\n", + "mcaBEAM5BFLcUYYtIcPqqedYnN7m4s1XGcdHnD95GxPBt7phjiFQbWbReY4Pb3P7+Q/DZoOzjuni\n", + "MTlc0EjLlDP7ccRkQxj25BQZ91uysbTeYrzRXJ9mgTiPEXBujlV2lpgScRqQFOhqxSBEgUollUDK\n", + "E7lGTA7kvJs5sC0lwn63xVqPkYauW1Cyw9kFOQ+kkIkBqjXkojALg1DS7PgRg9CQkyWFJc1yiacy\n", + "bHcKxk6BEAakXNJ6S9ecaLyGabEkvPWk7Ei1YJ06gxrjKEYPd71ZJvLM6FRaewVUG13rRIxbjFuz\n", + "Xh2wENW7jrKnZqWB7YbCNE2IK7iawaV5plkwztN3R/pnWYHaIpKodZiXXwZhAvSgiOqzxiSVfRlr\n", + "v27t+usrmiUyjiNtSTTek0tmCDtSzIjNLBdHONtpzo/vWC832LFwNV2TUsDUESNxFr4Gcs7EGDUT\n", + "GWGfEr3vMTYjOKwpeJkzU7zHWkimYm2msUJpHWY+bXOZaHKkOnUNWDMvWholqk/TqCOB2a6prUhB\n", + "yTCGnCI5B1LqcdbTti2lTKScybXMG+1CzoaUMzU7oq2UKdFgKJyrUNc26lX3lloNrfMsuzW7MBHT\n", + "VmlKUjRUSixFmBcCajfNRU/YvtlQSsuN0zPOn9wF+5i2OSCMnpIHjEtghXGaMCVi8h5rWqbc4Rdr\n", + "4li4cfQ8ve/5kz/9v7l5csZ6fUzXrrj31bf5pg9/I6+9/iW8t6yOj5CSkXrAoycP+ZaX/g7eH/Df\n", + "/fe/yd/9vn+L3/nt3+a5Zz/A5/7g9/nGb/wQr7zyxXnG+VVCCIQQuLq65GCjMN/N5pCcEturK6RU\n", + "uuWas9WCxw8ekuLEw0cPuLw+5/T0iNMbZ+yCoV16Lq52iLUa5RA9uSRWBxv2+z2b9SExRFzXcbHb\n", + "UcdL7t9/h+ODNY3AG1/8PDHD3/m27+H83Xe4eueLnJ/fI11fQplYrU91+WcdpUSeXL3DwapB/A3a\n", + "BUAi7LfUkDhoWmKBq8d79rtLdcE5S0Xm5aVlGAZsm+maDubBijGWFEdqyph5dj2OW6Y8gZup/Bly\n", + "mHAZGlEHulRhypk07Fl2C/bD1fsCb+sqOVtisgyhII0+j84pyMK5TIoTxmgIXLvo53QFo4J3YzFS\n", + "2E/3lXNZLLV6apm100kLaqma1aU3Ce2GfNO+L7w3tkKNeN+r7ZmsSapSFa5dKk3TUstECFes+mPl\n", + "JFhd+jhf8dkwDjJv3IWUIyYXXFfYDXexLuHsmpiEPMdo5+TJcUnbWmU3lEDXGZxtKNkwTbrYDePf\n", + "0GC1qVyDKeQ6ErNHxFIZGdOAnzKr5SHOepyt2OrJ3qggPHliHLFmIr0XOlaqRlcUodSorbLRdMqU\n", + "LVAwrqG6pNnec0vPHMokBhonSIvaIst7zoyBRkPGtSUznnGaCCniHag4VnN+SBZKpWajPmURaq4U\n", + "KmlSx4/MWlFrLN5rzChZZkBJYdpPVNyMk1Oh/LI5wpleTz9vSaWlNGumEig5YlwFU6FWpBiqVIyp\n", + "1Fmom9LAdl947rlnefvRG1h2UNfEIroYSoYqhSkN5DzRsMTnlkkCrrnk4vGWF5/+19hdXbCLV5yc\n", + "HENtmabI44d3ufXUU7z8z15muV5QK3T9gtZ1XFxc8tI3/+vEEHn5C5/l27/zW7n/8DE3zm6SU+aD\n", + "H/wgX/zin/Dss89y9+5d2lZVCKvVCu8skirGZEoZOTo80JgFI7RNT6Vy+/YJVMPl9SVXF1ecn1/g\n", + "ugWb444QE32ni5zlYgFU+r7Hzo1XihN2sSCnyNFiwa4OrPsFD+6/RdjuONtsuLx4zD/5n/5bbjz1\n", + "FL6D06eeY7g8Z395TuM965MbHB6esD68oQsnMileUfFE14GfGK63jPsd18MexLJaHjAN16qysGa2\n", + "A8d5vqejHZm35KUW+kVHLiqvm8aBputY5ol9HNmWwqGz7GImEVnWSmggYohVw/rGcYvIUpkHBUQs\n", + "MUWG8Zox7hC2tF1WCdqcJeVQqVzruzkmV0h1UoC3/vRm91zB2EAM19QSadwRpQqBnapMZMJaNY/k\n", + "EjDFYEw/R1+XOVl2whqoRa2kahax6ihLic57pjFwUe+x6I8pEsEkMgmxMrflnpQCY87UMtKIp6Vw\n", + "ffkO3j/COqvx1tki9YCaOu0ygVwTMQ/EGGdjiiNGKPFv6E2TrPDdnLK6dSx0nWcaEyFOxHLNwqxZ\n", + "NGcEM5CLpfEL7ORJcUtyI8Z4YswouF6jbpGqyXw1YcqIsR6pBZ8d2WScq+SsLoycDGAVBlDnM74k\n", + "jAipVqQkBZnalpwrw7BlioFiMsVokdKMZIOVBc4bTAbJjlwi3gtQsEXtcM5aUlG8mjbWKlMSGrpm\n", + "llmFcbZ/JShVXTOdwxl1LZkUqVkfrpLVe2uZ/we8JUwqSUIEyYa0h8PTY9746p+yPBgxlHnjuJqh\n", + "KYUsdXYyaeZOqZ4k1+z3hg/c/jj7/Y4ahb5Zs9+NeoueLM8/8wyvfenLrJYLhv2OzcEhi37Fdrfl\n", + "2eeeo1a4/85dTk5usOg3vPbaGzz3zHNA4Qv/7GWevnOHR48eaWyyMSz7Fftxh9TKwcGGtm2pAuOw\n", + "pXVC03gODtbst9c69jCew5M7PHzQcvXkknHcsswrqJ6+W9I0DavVipwTMSg9q+97Lq4uOHAG41qe\n", + "7C6RGJUcHo9ADE/Oz+lax7O3Trm8eEBtW+g8x2c3uXHnWcIQOD48YLM+wK6PMAfHlKEgjOzTRLs+\n", + "Y3d3R9pPbC8fkqo6srx1WLGUnCmmQPmzMMGma2dhesEaozKckqhZC4hm2SuN3GZoMiQRjmeaUBTh\n", + "yiVSjTQoKWiaRkIccLadZ/4z19UaTGGW2k10Tm3MRipZQEqmMlLZk0ulaRZshx3rZTN3UKoTLlVB\n", + "Gjls2UehWkcou7mbmt5HKBZJ1JIVeGJ7PeDJOKOHRapBUw1MS6094oLO/8OEAa53T8jZqgqFHanu\n", + "dHmGKlVymRe5sUFqxVLIdk9KQuN7jHOIqCQql4EyKjFMjCGXSEwDIKRkoQo1t1+3dP01RviaeQ7S\n", + "KKKJSOs7pCyZpoHtOHKwajGuxVGxblLXkBVSEUJIWFtBVBDsrCOZjFRtGWKcEDNSR1FakCt0uRJT\n", + "wMyc1VLyvEEUbYExpAQlZ2pW8lE2GtAmaOpiipHqC756jNGtvJEFIk4hqbbBeI+RhHOVkPbEnBQt\n", + "VrRtLwXiBN50c/FToXrjlpi2ZUwDMURGChd5i0jLctHiOvXimwIkBSqn6LDOg2hL5LzeXlLOTIPn\n", + "Q89/lIeP32KzPsSWazADtVQsFRFN4as1YlymJH0kjLVIgeeeeZHHF/eRMLGuZ7iiAWteOk6P7vDG\n", + "V17n5umZio77BdUIpcLpjTO22z3GgnUNH3vp4/zjz/wjPvyhb+T8/AnWF87Ojjh/8gjB0nXKDh3G\n", + "HcO4Q1JkHK8IQfM5bhydslouefLkCSenx5yeHXF9ecli4agi3Lp5yGbdIc5iuobVao1vGpbLJdaq\n", + "1CnnTAiBtmlZbw6o0x6RzOlzL/LojS/QWsvh+gM8fniPrvWMwxUYy53100zTiPctzjiadsPJnZsI\n", + "hdy2uNWhFrrGEEbP6mBDyBPrm8+zDEBJXFzen2d9FeySXMZ55q2diogwjRpYJyIU+54CQsEsJRUQ\n", + "S6lFlyZiaEUo1tOkQtpFsjP0qwMIV4SUMaaS9iMhTCwXB4AlxEiuI0imbR1RHE2j89Guaahp0pC/\n", + "monhgiJWOZXFYnCEKeC9YQrTLMszOBOgRGIKZFpiyGT03ZOis1GRoss3FC9XSsJURwoyRz7vKGlC\n", + "TMWagtARoyOlMPNfJ652d/HhPUyiBriJcdQYiThSEVrnkVygeFKdKKZipSWWALMOVYojlUCpCesK\n", + "lIyYNM//PWHc4+RvaEZQygPWtojxWHFAIcWCwWKko5YFpQqZCUQzTTRgScXoZHW3eN9oVKlRkWxO\n", + "7/nCYRyjwoSqo+yBRnBZ/d4xJmqpqiEzBUyedZuaUEmGUova10WF4GIgprmY+qQRoq6j5E7BHKK8\n", + "zda2GKcLJOfNvL1PupSxLcU6ohUEjzcLGtvSOE/jIeRA53pijcSQcWLYb/e0jcE0dt6oW8Y556Wm\n", + "hjKT76sxQAAKYaqcnT7H/XffxjaBxi0QseRiqSYhcxiW85USVf1qrCK0ah443HyA7W7HdvcWB+55\n", + "akmkOCI4bp09y8NHjzg9OSGmeZBuhOVmw9XVBSKWRb/g3r03uXXrDn/0x3/A8y88z+XlltPTGzx4\n", + "cE+p9zljrTCMe7xvFAdWBWsqzgklRxrXYGaKlKGw357jDg9ZrRfUkvGNY7064OD4kLZfINbRtgsW\n", + "iwVd24ERmn6hpgmjywZrPbUBKRH2W47ufIAHb75C3T5hc/MWw2WDua6EZHCupV2fUtLI4vAUsiEN\n", + "I4uT27THx6TthLhMjpPCda+22q3gKd2SxcGxAnfHa6ZYKPmarms0d9xYpVNZR9M2egAblbqJiOIE\n", + "Q8F6LSDGGozRg6LWwhgnplKYxFKrw7mGRWtpmqK5QK4S4kBMHdBQyUxhwHswNapzJyWaRjFtSmjT\n", + "Amd9VdK/tUxBLyPjvtIvFH6d0h7nEoUM3s2Yt5E4WZIMNK2mBxhTVLeZBExHqRNWhDpbPWtOqtU2\n", + "EVOVzCTFkoIup8I0qYun0bGadQYMiOkQM5JKUbaCabAuYUwmx4TxLbZWUkiMMWJNpvUVI3OBbCwp\n", + "R1KNs+e/zHlaUMr+69auv772vCZS7sBA5xtsFUKs1GKhqHDdmlZBGCXjnNJ93nMPCS3VFQwJsLPM\n", + "x82g3YSxnpwLY5gwNlOLV1hxVp5aLUp+0ZO9Yo3CE4ypuuWOCduo9KMQlQotAjMcQzX7HlNaqB7v\n", + "LUUqJe6wzilphULXtGAt++lKmZvGaaywEUqGxnm8bVl2a7rWM8UdU4o0pmFXB8JUaAlM4zWtXSkd\n", + "vG/ZB8MYKiU2GmIlBicNzlViyNw4O2F7caXpgbaB4mjajlAKyE7J5+8jtBrILY3bYMQxDomD9YZ3\n", + "732VVb+BFJgkkPMa7AGPLh9TpXJ5dUFIyg04OT3j6uqKp59+hkcPLxmnLauVjgCaxlJroW09T548\n", + "nscPlff0raoxDVTn8NbjDHRtw/XVSLaW/bDn8KCja73696vaOa+udtw6WrFYHFMEuuUK27T0i15F\n", + "1IAY8G2H9w0pjzSLjriLtIs1aRwo4xYxS25+4KNs33qVOI3cfP5DPL7b0qYBI57FcoWjoS48aZ9o\n", + "xOCmQLm6wm6OKTkzXu4pV/dZmEx69JBtrSzXR0zDgDE6R+X/Ye7NlW1J0zLN55/dfQ17n32miCQg\n", + "s4ukDVrowgwBRASSG0DAUEBDROQWSCQMLgBk0OAOUFpAwdq6O7FKoMkhpjPsca3l7v/cwufnVFV3\n", + "VQqUtWW62bYIizixYw/uv3/D+z5v1zhnWNeIsQYTmtzjenvRd3HRhBBEC9nZjBOdnGXkYrRDaUta\n", + "nphTpGnPYdhJHO5gWZJYIbtRuNWQk2VeT9D9ds+KesPRKFo4Ca3KLDU3SX5sTaMZaF2itoUvq2gt\n", + "c1kru92IcYXaTjgnBY+2jTqLz7wiJDBrO62tKG2ofaW1E96MgIauaaWQcyVRML6gmhzmtIzuEymD\n", + "JK9a6F46w54Fa7hNYbGGXkT/2VWXOOLSpaBQss+Iq4Je6H7BDxJG2FKhfUjcrJ1WNIogyy31MzrT\n", + "bBvqTXVFjhqtPYpCqVWsV6nTcqVuqYuyUXMYNciNg6c3yFFKcKUyylqWRbblWoEJltI1ikqtmbhK\n", + "lk9JbWuL5O2OUpIE3iHnCCB6RzdAkSiCtiG7lO503clFMziPUpJzYqwn94w1Ha0LxjlqCyhdBEpg\n", + "FLordJUMdmsVpWu6FvJ5SR2722HtDrWcRRxtoaGovZETOCcthTWGYZjIbaZWsPVIo1BVRgH7/RXn\n", + "+cycCzv/EmcCtI7WAa+vyF0R88Jgd9TWJPXFBLx9jlaBX/z5l3z+w39hMoGaKr2dUfWKYbrmG598\n", + "k68/f0OZV7qWyInr6xsen554/vIF3//+P/Pi+Svubu/55V/+Ff71X/+VX/qlX+KLL77g6uqKGFcR\n", + "HOsPQmdFSkkywjuEwaM6nE4nhmHk6fTENE6s64W0rLw8TtRaxZpqBLJ82DesGxiHEesDKSamacI5\n", + "R6kF6x1ohTEO2oAZO117TAi0oKhLwWXN/tU36U93XO4fufrGLxMvt9S4+f9DwAwHFBk7OXGAXRa8\n", + "uUfvj+xfvCRbg56fCFeK+ct/4uuv/o3p+jmPj3d46+RB3iRp1li0spRc0ErjtNogNop1XaUwUBIs\n", + "2BVoNdHxLGmGXrk+7FF5x12qtH5mbZDTTK+Sj6V6YZomtAqcTpF1jZSaBeirNXGJmMFQomzhhQon\n", + "M3rNjpREwtc7Qh0qAoQhN6xZGLXfOq8L2ngheqlGzI3aJZxMdSf604o4cVqm1PMm+2lbThiAIkWH\n", + "cQ3NIvdq06QkdDBjhMerlNsWNtszvum7lb6IDhrp3owR+/AbxAAAACAASURBVHWvAtxOuYg7q1XW\n", + "MqNtwdoslXU1lGLpzVFLxRoveUI/4fqpHZp+2AnduUHJjaajBJRtwnA5SCJzF/pJ2fBmwe+oXMki\n", + "pxvZVHvxoIPB2RG1zYOs8wQcqFXmOUXkFtrtKC1vURqajuQ61y7SnlIaOVfOc2S/G2TOojpm433S\n", + "pVItLuOdxikv0onuWOKZ1i5MUwOdgYIEQDVJ3WsrdIv3AarYR60bKdmS5sJuvyPYRjaR0mQTXkpk\n", + "XTXeR6CjlRV3jpM3sO576CsKodeHwfJ4XnHO01VGmRFl7AaI8Oi6hy62UWc/6FjLlkJ5zeUpMgwT\n", + "1BGfO0EPOG7Y2WfcvbkjXy5oFKV0xmnk9HRiHCd6E6dHCIFp2vHu3TumaSLGyDAMzPMsdjpjhWfa\n", + "t5ZIa4knbmKpM9oTnCHGlWEnkN+YVnqTQC4Gxel8wRhFro1GYwgB50Xb+2Gx1HrDh4FaZcxhg6Om\n", + "hvaetm2Te9cYP9DWSB8CanrJLs3M64ndzWfky4kWn1hrweeIP1yRY0aHgJue0R8+h3c/og0HejpT\n", + "0z3r03v8/gbTFKf7222LLCaJRscZs7045FBkMz2AYAx7b4I+0x9iXRrSTWn2g8jg1iR4udorFcNd\n", + "bbSSQXcqmVoiRg9Mg4OaKOmBGCtLWrFGqEWmNmzQ+CAVGXTK5k8vRdGKEeZml46sYzBaM8+yXFIK\n", + "DFXmpOww2tFLISZFKxYVBkxQqCwyI6UaKS0SZ6GEHlWoEmWhBzoC/daA6uJb781RUsEZxRB2tB5F\n", + "Ytg6ujesK3QlBQTNCpRZO4FwN9GE9mYpBVFjULEqg4o4ZSjZkbOmpUZXmpYLdvgZrTQHfy0WyOwo\n", + "KFqPeOPQxrCmyBwv3J9umYYj0KXKo1ArKDWBmjddl7Tv3QaqlhmXqp3et4fTGIFxaKEP9cK2HVOA\n", + "EKJbU9sDJDeGNQH6hbgW9vuOG/Q2MO7krIix0bUixogzCWf3eOvQ2rDbR5Y509uKdaLZbVU4oSkn\n", + "eVEgeUcuKHEfYaA7atEiLfEGHQ0oRUVuonVNKLsyDQO78cBoNc1pqvZYHEp3Yl1xRnOJD0yjJUdP\n", + "K4VuMqUqbHc4rTFtxFkwBHTb4d0gVVksHMOOy9OZgz3SVJMOIBse5hPXV6+5e7zDKYGlDMOIQuGd\n", + "YxwG3r95SxhHvn7zJS9evODh4Y6XL19zf/+Ic4ac8ybR2iJHtmiTEAK5iK+70+jaUir43Z7eKrU1\n", + "NIpxN1FqZZ4XEf47jzKB1BqmV1IpDONI2WQ8y7Kg0HKYaygRsHqbl1W6CqjuZAY5WEzLtGGCDr4/\n", + "kk7vsYcrWl6xqXJ+/46bb+ywuwnSSp9n7KtvMv/433DvvxT4SF55eHrPQOHF8xvm+T09RpQL4hLb\n", + "wgFr6+Q1Mg4GoyzeSpT0B8j1sqx4v8G5FYCSw1MV0TJjMaax844lZ56Ne0qurOXCmmZCcGizE5vj\n", + "YNFHg+meLx++IFKElFY7YevKaq7kmqQj0pnWRDrnnYwP6GKfrE0zhhsRoVdIpQsQGLEGD25giYW4\n", + "yjxTbMgdnTb+ZWvbjsCgrZDFvDV4Z2isxHihtYzqBZA5bvCBcdhht0iX3gxWw5wixhQqQgRbo8w2\n", + "U0bAHKiNd2vRulFrxgfRoxqzjRyylo8mlXHpmVx/RoPVDJ5gDmgr8bOlLJS0bjnnlkzhfLkXa6SW\n", + "qE6lNVa5LREvMPmA1ppS1y0ULWP1jGk7ehW3g9YWp8IWwCRZLKAwymHUxs3rRqjtqm5JjVKtSFUp\n", + "6C5rJZxsqEbiR0uh5UYunao0zhq8t7Q+SDVZJXWwdkPOiVaykJJKlcTLFElRlk1392959dwyL9Ji\n", + "lGaxdkRl2R5qFDFLtrgzA9UZhvAcEwaWdKavHW0c2npifmQYnLTqXaHsHoPCWaFYm+oxRuOqpleL\n", + "cTvAcnV8xXxeOJ9OKBI1GxSNuD6h88Cr5z+HKo79eKCuM2prgWrrxLTgvRx8g9lJfksVa2PvneO2\n", + "ICqlbGF5cttp7bYqSmaYzmvJvbcOY6VNMgZoFacNgx+2vCiDHwd8mBj2V3Q8rXUenx4BmRvO84zS\n", + "ipQiznviUjHe4ZTjclkIVtFVx45OmKR1E4H1SLcKFTVNr8S7hJ5uaJcTo3W8/+G/8uyTz6RdX26J\n", + "vRBePKf+4McYgO45fOOXePt//m88vPkRLz77D8RZtIDaGMmX6h3nPGGaCEHGCKlmgfkag9EWPzr8\n", + "9r0C1JIxppGy8FNjSlIEKC2Fxnrm8fw1l5pAG5TzaGeFgNQUjoCzEiq3JOEjYDU5Su66OHGCaBiV\n", + "sD2tVXS1opQjZzAmiPssy8Go9wGlB1pdSB9g3KajjYjVY0qYZlBNQdViR9ZCendWGJqqK1T7z+kB\n", + "tQticc0XtG5Y17m6eo1zA7VsYyozoLTicr5I4eQTJSlS7SyXLM/MpuQAaF1jtMI6hTENpbYqtgac\n", + "OdKLoSB2Za0lhO0nXT+1Q9OpPaYZtAk4N5BxzLVTW0aj8S6wxJU1nTFesQs7DAeUdgz+CGklaIcP\n", + "GnTeAqFWrE54HajFoaISnJIWR4XzGt0967yKda1rdGvycGpopQq0wDS0lQNatQ2nZbbMEe+wRpGy\n", + "Yl0TzhfWPuO8wdFxrjMER1qlUmTTZNLlZumqySKqI5lGrXE5X1j2F1Qw9BYoOVNNZxpGYlwJYUTF\n", + "zGVRlLyjIVCC4Ce8c5yLAGC1dfQu0QnBj2QMrUhOumhNxbERgsfoAaUHvN2DgnXtWBfI/kRaErZp\n", + "VK2YlnFqx9AmYpzJdUVr0EozrwnrPNdXVzydTgzTtOU0qY9SH2OkwvwA1wUIIXC5XND6gzlAMQyB\n", + "TsVaK2OYMCBZ9wpUZxwG7BYlEfwgIW7DhDKe1BoqJva7A5fLiePxKG1u65QqyYveWWiOukS8NeT5\n", + "gp08ywK+5S0pUkGXl/MyZ3pMrOnCZB3T1TPq0z0vvvENyuUkP7PcCfmO0s7oZ695/Ofvoawldc3u\n", + "k5/n4cf/F+fLLdevXvD27VtqlReGdyKxqimTlHjZldabg8nLyEgrwiBZ6jFK0FeMK7VVtLWMNnBO\n", + "kXldeZjPrCWjTGAwikstzPPC3h7FnUijI1tmo7SMl/qm70UOwdYzyjSqACkJZuMo0FG1MbgBqyUX\n", + "vRdDKZr728TVcRIYNkUqxNZxWuawpUpFV0qDnnCILrX3iDMNYw3oSm0rusmIqNVVKkDElaONQemM\n", + "s0estqIGSBIVrIxke3kDuED1nRihlLqlvYo0ySiZaTsnWVdKO5Qa2U0vyGaQxaI21CpuQO1+Rmea\n", + "kk1TofdN+DvhfWNNT+KdNhbvR56Wd7QS8UZt9HPwbsSbidzWTfsFzg60okS64B5BDbQaKLFTtAhs\n", + "a9XC9nNQKDg1UreHxRtDaxlvLao5isloFN5orO6iXELhtPxdR0Lq1+XCeB1o3dFaANWxQZOrge1r\n", + "s8pRlMAEjJYb1XoHraKLcAPn+ZGbqyNaiW6y5YK2kjSosRwOB5ENaYPVO4awxxiLVp2zuqepRFwi\n", + "KkTZK5pRkhNVp7VOR6RVrWdSrih2eDOizIDVgbwmrG1sCmBUy9hoUHqgl443UHLlMI3E1GTUgMSs\n", + "Pj4+YKwlx4Q10qpba7m7u+Pq6or7+/tNXiRV04dq80Ni6DhOrOuCUshh2TshDKSUtj8HtSn5mRlL\n", + "VYq4JmrjowbTasPlcmEcR5ZlYRwlCbM2eeiXMjOZgU6j5UaKhbXeY4Zn1HVBlRk3TvQMl/nEOO2p\n", + "rGgF8f6O6Rf+Fx7fvWF8e8f0/IrqwexeU8pKffsVJhb218+5/fF/4urFS+IYKDevWc5PtKoJw7At\n", + "sDYiVu8EL9G7wcsipSGc0941Tlvymj62s9YY3OFI7o35MpNSpG0pjmG346palqfKaX3LEmfS2jFq\n", + "QuuBVC4ilLcJ6zp7Y+lNwYevpXaMlTmgNisKAfH2DrZ7yT1SAaqHaqjZU3OlVsNJty0tcoPGoDG6\n", + "C1bRCFXJmwFtG0rLi1ObSiqPBBPoutMpxGRoFEHf1YZSWaJtbKerFW36xh4SF19vRbSuVlIWgtUk\n", + "J+T7WjspCsy406FLuF+viao6VlmG6RlKTRgUe/bkbOmtkcojVSV+0vVTOzTnfMtgrtC9ojbCiTay\n", + "6OlV0uEmt8d5x93Tl6QU8fpMV54YFVO4olQoKeOHQK1P8mYhSQSu3WEHCTYrZZD5YK2gIygJs+pd\n", + "5BklNoqRXObRB1RqLMwYZSQqootz6YMsROkuVBVTqIjrInjJk9EKEd8a+eUaJzeSUoa9tvQy05um\n", + "akOqCJCiG3qT4Ks+jiKf8ZZUErvdDaqPeD9ymDQlCxLO6B3GgGEH1jEvd0DDtSQRAz0RwohWipY2\n", + "ao6pgCGuBWMWaCe0GnBmwJgglrhe0LYQ14WmRlyxeKXpaRbKTNfkUknrSk4JlMFqLfkq2hBjZH91\n", + "5O27dx8rypQS3nuW5cJ+v8d7z+l0YrfbkXMmhMDT04mXL19QqyxBlFIfK9UPWUygoAnspdZCrY3d\n", + "bk/vjXmetxmgVLmC5pMo5bxmlviIdo7BD6TSucQFc04ML8SJlWOjR3lpOmeIcaHWxM4NnO8e+fL7\n", + "/8jNy5+jvPu/adFhwp5iQD9F3PGKy/07rFIMw8jdm7ccryZGF2DY0Uve7k2E1xiCAChixDtHTAml\n", + "Ky5Im26bPOTGGKyXWeCHq5ZKCAFjLct6lphcPOt2pOSaxXFE493T14zuSuI5aqT0SDcL1hT0Rifq\n", + "vWGUp9OpathqywtOG6ySzkwrRy2WViRZNadG75rWDJfTgh3k0LReSRFkOj4I1xZjsMbibGdwndpW\n", + "Yl3pXCQpVgVSziyLQG5ayWggBCEUDZOXhV95IkVLTk30oCmBVRgVaFay2IfSUWNl1Zp1rdRuMC0I\n", + "0awIXm/cG6zaY9WO1py08mHCWUdKUSKA3f9g7vn/X9fp8ojZH7AUUJ2GJsaMtRrndtSS5Bdn9lyN\n", + "rzjPb6jB0FslxotkjWi2llMeql5Fv9W7QrmIUhZMxaKgaBHL90JXmVTYHsRN/4lCtYZz8suy24NX\n", + "SmOZq1Sw6C0TqFK1QmNoPdF0Yq0z2IrtssyATteaMHi6lh9zp6KVIy6Fbi2WQi8Kqy0WR68LuimU\n", + "8YKUQ1My3Fw/Y5qODM6RYmEpi1RX1kNrWHvAu3vOl4WqFAfrqClS1IK1E3FplJjItUhueis059E6\n", + "MS93aDRTONBKw3gjej0ndkzTPWVNzDYyhonSqryI6CJaTgqFpQdNbBmLxj+/kQwkYJ5nhmHYZEVB\n", + "smeU4ng8CrAlBJZlEbjvtP+4LFJKMQyDuKmMJ6XEOE7kmGhSkxFC4P7+npcvX7LOy391GNecOVwd\n", + "uL99x/X1M5ZLZH8s3J4fuLm6RiEba7eeMeFImAZaKuS84rUhq0Zm4PHrH3E87Lj/8l94Gi07N5Lm\n", + "i1TTJZL2Gn54z3R9ze0XP6CkwmE3cT4tPLs6kNJM12L0Lbl9nOHK+CJsml8ZZWhtsWic3WZ8XcDS\n", + "vUs2t1bS6Sjr6EoxuoGzi1we77mfH0jlLAdu0ZRUeYgnZp/QGmrNaJU+OsCUg94dk79CYcglYowm\n", + "10rvHqMLRjmc3knhUA0tKzEzZNFK9l5IJZPRTIMB3bHO43SVPYF10D3WC1KOrWPTBVIrQi3qhpw6\n", + "KRnohl6rdHuDB1Up+QzuyBobcQ7kLMvTulmTp2AkGkQVlC0EZbFOobUjzhLlba2Xdp5Or2DMQO8G\n", + "7wa0ChQKKINRgg9T7mfUEbSmR5Z1ZBeeb5KFCWcCKZ9EzqC32IduOQ5HtIrkItqqSuXh8pbReUqJ\n", + "uA7eKazZ0zr0ulJUxqpCGAbWtRC0I66NUjvNJNCN2CKaCY8sLGT5M6OtQRtLWiK0DbRhJVI150Ip\n", + "mdaEValUY00n8XPTaVoOM60VvWe6dttG0kur0RtUqaR072S1Bb51IcBIbnmhNJHMzOsjn4ZfwJsg\n", + "EAVT0dkwr7eEEBj8Adt3jO45hMjcIKcFZTqxrTgzC4k7RnICrRONhUHdYFyj5ZleHshpQetCbRWL\n", + "x7qGriOmj0yHPd5fk5cVb7WI6WnUkhmcRKo2YAoDVhtxFXVZDGj9n6EUtVa8DwJX6bKkG4aBN2/e\n", + "cHPzDLdBG5xzWGs+VozeuY9V0RpXrLFY53DOMY7j9nk9zm2LpdZQVmJkj8cDJSd24w4qjONEuTxy\n", + "OFyRtUF1ETsv8yODdZS4ELPEn4TjDdEZ7h/uOYwTt1/8E/rqG4zGkG8L1Ir95FPKFFCnB24++ZSv\n", + "Ht/TrQHVuL29YzcdOF2eRGvYJc9J5nqiN9RagxYW67AtyHLOoJBFYt0E7dYAGmUaVhuK8HtRKdNa\n", + "Y24rl7qSeiOiaMoxmj2xLJS6oFXHqI61nW7M9nU4jHVYHNZ5lnRCa0/vGqUiJQtxyfQAzWB6p6pl\n", + "G9VnecF1gav0UtFG461k+5QGWNH/OqOoTZ4HYz2mRGoyxFxBJWqFWgaBzKgmErhWoFl6zazpTMsT\n", + "OWvWdQP0tI6ycD4XdqPGeEXTG5WsN3ZTwDTHujRUUzhjaShsC+ju6AhRiarRtpOWZdufVMxPXp7/\n", + "FMXtbSHmO5x1uBSw2tONgTwyL3dMwyizlS5zsv3wnKfLV+QCtVXWtLBGAXRMm4TFeS2zzKagOpqR\n", + "OIphkAfXDdCzJrfN2VPESmfVgGl92+LJNlVLUgxKd2qVhUXpUQSwKGJt5FwYxrAh5SCXBmRUQ97o\n", + "CJ/QOgvdoLB4pyj5JAN322QY35QwGlUndYEs126xztPqSswzV4dPUKbLzFBrni7vWdcz03jFoK9J\n", + "JRF0pPREzFluhtqJbUYDS8ykKNlI1ncos2zSlWdeH+h1xFnFNDq8HWlREkDDMKGyaAlRnZIbtYm7\n", + "x9gdcXbUZkTq5RzLecHN80dLoLyIGikl9nuh37dtrbnbTayb5zqEAVDs9zu0tqS0fmzRx2nClSJt\n", + "/MMTGD6K1/f7PTFGpnHcBPId7zxdS8Rxb3A47jmfThjAaIV3lrXJdj+WiGqVwVlakQz5h9uvIK3M\n", + "737M1WffZtDCn0zv7qnXL1DK4lJh6RH/byfc//xt3v7v/8LNp8/ZjYHzwwO7aeTd4z2n8+NGtZKv\n", + "rVUxcAzDAMh8d11npv2O3iraeozzBC9RtV0Zuh8lCKw2lLHk0wMqZ7w2vLh+jgk79DDA3UiNtzy1\n", + "e7QCbyy9CjUJIroVvHIYv3EKrAZkL6CUbO178xQWcfg0JH6lCRWsNhlx5RIFbdiqIOBwsvRp0KqM\n", + "vLTptB7Fc648Vn769FpRykN15GI3ZoKl1UBvHTcYjG04L0WKRnOZ35PmHTmOxLXJjNJ6dDM0ldFt\n", + "4MrvQHkST7Re8V6j9xrVNfMaZYNPk2Vr0ZhmqGmFFilkqi5gsgC/8/oTz66fno1Sw5qfcG6P1TuU\n", + "ndBqZPCKFBtrOuN0gKowoWOdZXI75rISa6SRUKVuIAArc0qt6RgoFmM7kMi5YCwonbFuFGlFtuKx\n", + "NUJ/Nmhx62jZXtPWbVEVRCjcEyVv4VUtUaumFiOtUnUEtxPykM7EtG1szULXDVKTA6FqdA+ovsOH\n", + "ziU+UVSkmYyzshkuOXOJDesbxgbAYJzh9uErXtz8Aik7CcXScnA9nS54E6BKK616geoobQLdsE1J\n", + "+FpbKa0TS8FqGfw7Mq0t6C6ynlI1hgnTHbrBLniBJ8dEqQrVEzXLR1eKmhOldvHWu471Qt4P4yia\n", + "OrulHFY57D4Qh0TgvmXRa9Ee7vd7Wus4J3ZUrS0xLh9b9BAGrG0Mg8zyhmHAWMM0TRhjOBwO0PqW\n", + "FLknWEspBeckisFay36/E0xYl9gKYzzn85PELFdLywpNpZXG6Acent7gW+bu/Z6XQ8COBz55/T9x\n", + "+/4d7ue+RX16ZBhhiSf8j/6F558+Z/76nZDCVSYuhW/+h1/k/dfvyXnevOaaopRoDXunlYK2hnHc\n", + "IaFpSuRgLqB1oPeCsQpKomYhX5Wt01FKScSDMRzGEW0dqnu8GegEPn94y5wWUm9oHRjchCJhTaG3\n", + "TKcIPamL+kRCVWXT3XWjVqlMW51lkdgtrYkoX+J3RWHSexZwRt/o80qE93wQ8BuRC1qv6N1Qm0fr\n", + "inEDKmd6DeI9R+GcYRccIXSsEUhJbiJfyzWSqwLlaV2UAKObMHovFKeicf451u4p5URKYqQIo6fS\n", + "SKlvTkKDVp6SK2x5W1VLBr21kjjb1c/q9hxPa4o1NbwqGApD6Fg0IYw8rrd4XXDW0EvE64Hgr2n9\n", + "kdzF8dN6wiiFqSIPao0tpElRyirC9p5lnmM6Sq14H7DWU0plXcVFYXyTz7NxCFs3KJFnUkoTkbeS\n", + "GWjJ4pUuWYkLyUo1MI47Sl1ZyoXYErpLoJtE5jaCuqYWkT7RA9ZN9HShq0JuCxpLN3KTqKbopaD0\n", + "gm6OmO+5vXvLfnwFOpG2lus8v6e3GWsmYl7prOJe6hatnQibVREUl1KbW8cwjNB1pLVE61oAI7Xj\n", + "tcY0jQ0QlxnXxARQc2W/M3g9osJILpm4gVOUaXRdNqsr2CBkoVIETXZ1dSClzDAMIjbfYj92uz3r\n", + "ulJrY5p2HA5Hdrsd1op97oOzyFpxT8nmvTOOAyGEjx/ee7z3lJSZlxnrLd44qe6MwbmBjmyrVRea\n", + "VV1FD2lNJ81n3NghK+L6QFsj3hnCbiQ/PpKfvuTHj4Gfe31D1pnnXlH6SmkrRCT1MxcuD2/ZP7+m\n", + "rhee3bzmdP+WXBIvPvuM09svyFXo4GEMpCTQbBMsHwTYWlsJBTMGyII81HK4am3khY5Ceydqg2XG\n", + "KcNazqytMNdE7wXbO/tp4lW/4evHewGJWIt1Fm+D6BSRDmRNM4oi4nVlqB2sGSkUcswbxEbRS2aZ\n", + "E7oPtN7QSqGNJrWI851OpKlOTBk/aOZ4gSyide0SPWUGdcCa8JEnG+wONUzM55WUZ5zpjMYzmhFv\n", + "K86Lrri2TlyQbqUWepOK3VrhPxz2V+ieiWuCZgnhiLKNeX4AEtYcCWOnd0OvAzl3es843/G+ir1T\n", + "ic+/94rRSqKMf8L10zs0FXSlSG0m1hljLwxKAp2s8wx1YIknum/YNkGS+IeKwZqBsXsqia4KBkVb\n", + "Km70wqjUGtUqpURJOcwFctvym4Novxjxe8e79480FqnscmfQRuhDNlDsQoqZ0jTBAV1EuqWA5I47\n", + "0bg5D21i0CNJi2zKtoaxmtwzSwLvj2gl4WdrljjgXhW5JKE86UbDbfNAjbV+i+NtoDR3t29wrweM\n", + "caScSOWRtXzF093KtH9G7hdyi1g/4LqW7BZlZX5qOmaUWZPqnXGwdO1QNWJUQbWC1RqrKipXWulY\n", + "5xDnu2VSE9bA6XLmcpGFizGKaTdSK4T9kdOcGIYgUJMudspRDdQqsQRirZy2KgkeHx8BmKYdu518\n", + "eO8JwZHzmXEcGcdRljq1E0JgXdeP9CJrRfP3ca5pHdNuJOWIUrCuM8PwjN6bzFFLFluldbC5t4Zx\n", + "ZD6f6CZzefcVe1+ZT48s85lvvP4mLdywdM903HP75T/xySefcvf5VxjT2SnHl1+95XD9guiaZK6/\n", + "+RHP9s95eHfL1fXI/d0bJr+yuzqIRKoWtNGUUkgpg24E5+RFirTqc4p47whWMoDEe23Q1goDUll6\n", + "q3gNy3Jh5wOJjitS3HVVBa24nDFGMypP6xVrDc4OaIwkduoXxBC5f3zL+SyONeUs1lusgmwqS75g\n", + "nXQDFZjjLFwIoHUlraxydH0RVQmG03oSY4RRYCq6bpK3dmIc5eVllMW3IyWDqQrdheVpjRH+rZIx\n", + "ilKVZY7QPb2JySPVKPCVloglsafSssbg0X2AakAdaNVj3Ap6wSAb/NI6KXZyUpTSNi9+xgdJjnDb\n", + "DN2Z6SeeXT89R5Br6C4zpFge0XiMsiI5oqGapavOvC5iGUTLJrE0oTAri3OKXuWfobbEQatRAUFz\n", + "9coaIygoPTHqCa0cznmaHtBq5LNPb7jMicvyQAiNMN7gCEBhnI7kAvG0sPaM7o3S1QYXUZQU2Y2f\n", + "YNgLIkvDGI5c1kRKJ2yvKKMoqfOQ37OfOqVaaqqkXIm5bjT5gtEHBBIv+jnVtWg6G4xDwKiOplNz\n", + "kr+WzLw8kvoT69OdiMC3MYN1OwYT6JQta0baMR8MLYPVFuMHgSakAmSUMmhd8d7hzEAps+DwSmJe\n", + "H+mpU3vn2fNrOUq1IZWKKo3z+ZEQjlgn/u9hCDyezqRU8Erx/PkL9vud5JJvEQ/DMG4H3n7TWgpE\n", + "pWSZFV9dHZimHcZotG7sdjvWdcUHoRjZTY5kjCGEQNUGpRBrZ63sDgeeTiee37zg4f4e7w0lixV3\n", + "Nw6cLxd0a0yDJ7aMSjO3T3eoBn1duP36x5jBUO1I5omrqxuens7cvP4Gn7/7Avv8E477Z8QUqTVz\n", + "PF5xONzw7t3XKNu5vb0n+EA3iqfTheD8RqeXw7H3TsuZ0jYtgPak3rHaMPgRawPaOLrpIkvTjtaF\n", + "lqQ3yrpC4Yzj5d4z+MBaklSrStHpzOs9RTfGcKR3wzAcGcKEphH8EWMGPrkpLJeVd7dvWeo9RhWC\n", + "fYbe7L8xztgtHdVaoEv2eU6ZXCF4jZ1E7dF6kQhfJfNhpQR47Wyj1UxbMt5NtLrdq2iMGpBcjErX\n", + "CrSltUYpIvPLqZPTB/aDRPaiOlY5es88Pb3n+fFTDB7VusiRasWaG7R+BCWfW0LTJNYiZ7VV8Uqe\n", + "myaYR8MHXefwE8+un3ho/vjHP+b3f//3efv2LUop/vAP/5A/+qM/4u7ujt/93d/lhz/8Id/61rf4\n", + "m7/5G66vrwH4kz/5E/7yL/8SYwx/8Rd/wW//9m//Nz+36orWq0Rp1kwqC75OqCIOELxFN0uqmiVG\n", + "nNFQQVdDa1pwZ13TKjirqemM1pq4dHTtTOOAM0bkQaUzhAOtSvrdECzDOEKfCPaKF892XJYH3t99\n", + "Tm4LNIdwKR3jMDLPE2s8YY2nZkuwHqcNKRXScsF5i1ZY7wAAIABJREFUaVm1FjeLVY5zFL+u84Za\n", + "t/xwFE6PLHGhFkWpHaONbMxVxLoBowLOOnSWUQF0equMe0uKZ4z2oLqANnSllSjJkxpkiORQ2tN1\n", + "wiAb+a4auWSRfmhp/yydpkT034hUHKlHzukJy1lSohs4PH4I7PwBeqOguLl+xjxfYF3J6cJu3OHD\n", + "hA97wuS5vX+idTgcrlCqc331nDWeWNcVrcXtI9g4mMYjp9PTBmfQNKWYxon9/kAInpTyVmEpnj17\n", + "xt1dxWwV5gexfGsN7yXV1DpZOdQqmTvaWnKOzJcLtSR208Td+4XdOJDnMzUvDMcXvHn4isMhcHla\n", + "uTruWZeFyd6gwkA4HHn/wx9w9ewZb96+55PjC+o0YlYIKnH77i21FA5XR6ZxR4ozTVvWmBmN5zAd\n", + "RGtKYxxHcimiojDSfovovaOVAFdKzegP35/RMnvf7gatRRpH7/hR6FV3T4903dlPI4dhz36c2ccT\n", + "T0mTU6GVClYq/nG6Yh+uOeyu2E/PUN0SS+QXPvslvrr9IXePn5PiBW/2NFuJMZNVkQWa9xKGaHe0\n", + "ZkQutBZx9li9LZY6zu2gdlqJ5JrQo4y41lzw2aKVkxl5k1lo8I4Q5EBsVSSDtRbJHMqWmkFbISdZ\n", + "3alNXjoyW83McUT3HdRKZyG2jPONro0I6mkYW+ktCwxcNaHLl04plVITpRb2uyucPQhE5d97aDrn\n", + "+LM/+zN+9Vd/lfP5zK/92q/xne98h7/6q7/iO9/5Dn/8x3/Mn/7pn/Ld736X7373u3zve9/jr//6\n", + "r/ne977HF198wW/91m/x/e9/X2QV/6/LYKh903O1TOHCZVU0taertJGPGk4HcpZUvkakRdj5a47h\n", + "haD2XSLHldgiS5rx4UBchAu42+252u2J8YFORjtDK5116YRjYAzXeHvEENiFa6Zw5P3jj2g9QhE6\n", + "UisNbwaKXVBN4Y3HmkYwBpUr8+kdfhzpeBQrzhvCMFCqIpVHEbmXSm6Juj6gmKk0YumorkmLgdGg\n", + "bRHvevEYHRh2I70kIIJaSOVBbHVaAA678RXH/beID6t45muWoXZNGL2QS6WrA8ZWlJlRJBqFcdhR\n", + "Y4Ju0L3QcpbwKazE2jrPNO5RpTEazeCuoVr53sPAYRhJRUKMWmvsD3uUCyjlURYRwANXV1fUWhhH\n", + "yS9XunwUsj9//nwTsEtK5ziO22adDYzsNreQHIYfDsZpmnj7NhPCFa21TbrTpYI1MgPNKWO8/Pdh\n", + "HDDOc7i6Iq+GWiJ5XbG9sTzcUtcz58d77GXB9Mz8eGE/HokloYPjtF7o68qL0ePGgct84ebFCy7v\n", + "3uF3Ab0fiY8Lz25umC8X7u/uuDkcCKMXPWw3hOA30IYs+h7u77cZK/Qm1fUHhUHPldzAB0tKCaU9\n", + "1riPv9vWq+h4lf6IMCylQJdIjF4aow84RN6kdUeZTiORkmY5F6bxGXaaOB6vuT6+4rB7xhIX3rz5\n", + "kqvpGSVfeGgXNAGln9GaY0l3aFXQrmLM5rxTMkpSJtFKQiNqBR8CTnmcG8TH3RIlz0JLV52CAKZ1\n", + "lRli8I7RGYxr9J7oWVGsGNNK06I4CRI3Y4wHMqUs1NzQxmOM5f3jO3bDjGpGzBy9YbSn1jMKYUl8\n", + "yO2yXuM0lFRQ6kOsTCHVC+c5c9wNeHf49x+an3zyCZ988gkA+/2eX/mVX+GLL77g7/7u7/j7v/97\n", + "AP7gD/6A3/zN3+S73/0uf/u3f8vv/d7v4ZzjW9/6Ft/+9rf5h3/4B37jN37j//O5JzvSWyK1TGli\n", + "V2tVUZe66e0qTYkQWGlFJYmoto1b+h3spmthL/LAU5xJtdNyYhoOkBWmeXb7ieA8a7yAltzndZ15\n", + "7E8ML59htcFbQ8kGo0fGcENuj/QegSeabTiXULEzBI9XFt0VrgutPPaV27efc7x5QQsabSfGMDG5\n", + "a86LYcm3lO1Gbz3JlhsvM8MipCFqh6rJCcJHaYoCZUFVnPHkvLIsDxwPn6AqTGHPZy/+IyVV7i//\n", + "SeZH6oMkI0qchfXshh25LqIAKKvQopqnFIM10JDo5KoSXg+UXrisMwOW0h2Pl3u83qO8pqyJyzLT\n", + "miZ4s0UDS9SALN+EAfnq1SvKVi30bQm1LAvGWH7+s2+RS6Q3LZG4RnM8HolReI+dzm7aM4SBXArW\n", + "KEoteO+ptQqCbjuwpZ3PMtPMZSNGyU2ttKLUJhZdOo+nE5BklEEhzRfIkV4SukpIXXCOuKzowaGt\n", + "YzCOUg2X04x3CrosnMabK+7e36L2N3TVySUz7Sdomdoy9/f3XB8PInPDMM8Xrp+/YM0rOWWBEpdK\n", + "iuvHEYPzAsPQxklr7iy1ZtoqG3bjLEZ7So7kKtG3Wmv8BufI85lh0EwEhtMD5tFChTVGmqlMo0MZ\n", + "y/3jV7y4fkWvhiHsuLk5EOwLnu0nvv+jhbm845Q0eVnoNELwKP2MuDyilUU7K9k6WgZmgl+zdCUW\n", + "Ua8HfAuophl0ABWYlSL2JMnkCUyX58E6w+Ac1gMqkVKlFU3NTYwozWH1bkt2kJbc2iAsU06UdkH3\n", + "hNFB8orMnpKFiNbmFT/UjZMg64jSIjU3UAPaKNKa0FYJPV+tdHVmXj/HaPfvPzT/y+sHP/gB//iP\n", + "/8iv//qv8+bNG16/fg3A69evefPmDQBffvnlf3VAfvbZZ3zxxRf/7f+xcijlqBRSTRhjqO2JSiRV\n", + "v7Vkkhipbcf0Tm4ZqsU5jfeGw/4oMAtreVgf2NsdMSe0ajizoxdNTYohHHB2YM1nUok4P/F0eqTz\n", + "Bd94MdA9aCuzxNYqKWeULliF/HmXGaxjcCNOd0wV0EfsGaM763xPf+y8fPmK1mBwE6PbswuB20fF\n", + "pT6hraLrKHxLFGMYKWuGbih0cqwSiDZIjk1FeI9KDTQ0qJllecNuv8e7a4bg2ZmBb776X0lfPvC4\n", + "/hCtZEPbe2I3DpvMoxHcHq3gcjkB201eC1V1lJfwq2VZqRmmkBn7me6P1DJw5SdUU+RaGQbL/d0D\n", + "x+MzTqcneu8Mg8P6A4+PD9y8es311TWXNRLCSK0S6XB7e0drleurl2LnxEiQW1NcXV1tNB/NZS6k\n", + "lDDabAu8ytaJopTaFkoj3gfmOdM2J9jp8Ynj8Sgb/FqZt4N0WVactWhVmLzhy8+/YHm4Z/LCIKgx\n", + "4vcTu9GRfMCYAT1o1rTQc0Gnxv7qOQ3QXWOMIzjPeHAYF7h9eKQvJ3opXB33LJcTZRj49NNPuX+4\n", + "58XrV8znM7tJ9KjDuBdjREnkFDc1gWKaJjoKHwLBObQJUmEqUYP4wYMSwjqqSmLqFq/SNnG+dxPv\n", + "L4/MpdCCpVlLSsLPXGtDK0/wisuy8vmX/we7ceI4Hyl5x/PjDU5rUv9FLvXE+9uvUf1CJ1GaZGgN\n", + "fkdKCa278E+9kpyhJFEukUyMib0RuLfqMkoz2uF1xemVljO6D2Iv9g7nxfDhQgXtaAykBj0tpJKh\n", + "BUzwjG5P02xyIcewv+Hkbrms70At4uFvidwu9A65J9GLFoX9oFelkjfKliLJfkQrIZ/Z7RD3HcqF\n", + "8/zP/+OH5vl85nd+53f48z//c9HE/RfXB8vbf+/67/673ii1UrYYn1pWKo1mVxnO9gGjPNrIW0Yp\n", + "acdKO+NDYhiOsmEd9pSW2T0deZxPaKM45/eEyZHrHr1WyUr2Ft0HbBP/uHMr727fEHPjsDswjBMG\n", + "jzOdOTZifYR2odPxg8W5PaYNIpnohbJErG20WMmt0taF+fLEzfUrCXejE8KB/f6GckpUpWndbGgs\n", + "Je2TVdSkaNVSeqF3Ta9ZiNeuYLRDY+gqU2sh1RN3p5Gff30jLhljGMKB11f/kVo7T+vnQKeUwjTu\n", + "aF3SDZ11OH2F1VUwWcpJHISKWOeYumfyE2WttFpRekQj8Rg5NXQrTNOe8/mJw37PMl9wfmC3P3B3\n", + "/57RFl6+ekFXmmVd0MayrCvOWR4fH8URZQYOhz3DMHK5nJnnCyE8p5SM924jGhlp0+ms64pzbnNg\n", + "lc1hJXKlEAKlZHIpuG2+ef/wQPCe3ThRUmJdVuhwe/cWXSNadW5uXjJrRTzdk0vDGst8ufD/MPcu\n", + "rZZ1973eM+7zttbat6q3pFeWZNmcY78kJibELUO+gTAY1DC45S9g3LHRB3HPDYG/RMAEQo4gB9xw\n", + "GrId2ZYlvZe67NqXdZtzjnsaY1WdkNg6EHOQV6vYULuovdcac4zx//2eZ+yv2dy8gKLbzkRr1uVE\n", + "UorT4T2ygpu65iHPjsfHI8O04+52y/qUOe+fmU97XNfaSe/u75nGDfN+RilNFokiFMFHFAbtDErp\n", + "j4H3Vsxw9F3rPAtZGwbxwxVGlQgtEQiUbci3dtfdSESyNpr/Vt3w/v0jMUk0msE5+tz66j7MgEJp\n", + "eL//Cv3F36CtwnaSimDqtwzdlpdX3+Dh7jWff/6IjzPCtFaesQYjRiiFGtvcIfrWfhNIUI4cBefD\n", + "gt45VNHMOWGNolcdur7gKZ9ZRWlZ6iqa+cC0jVHJ7T2eC6RcCD4w2h55qTJb07cCTLUgKy+mDdvp\n", + "ijl8SSoeZEURyLJiddvFWqeRMreadS2XO1Ao5YxSQwMeqwqioK1AiBXnRkr+N4bbY4z8/u//Pn/4\n", + "h3/I7/3e7wFtd/nmzRtevXrF69evefnyJQCffvopn3/++ce/+8UXX/Dpp5/+i9/3h//rW2JNxJK4\n", + "+9Ty8lcEVEMthZgEVUeEVReat7oEsFeUrszr/jItBmU007Bju7nllN5SCVijOK73TE6SF0WuLdxs\n", + "pCXXgJKVWh1VrNw//YSzH9gNtw1cIQ1CJEQphBRQyrDbXiHERF41JVQonkWciKLhvKw1CFVZjgdi\n", + "WNogR0iMNjjtMKZvRCOhkUpSLvoNUQFRkKK0BlOBVFocxcgOaL/QIvPlcnxl9s8clxOje4EWLW7j\n", + "zBUvdr9ByoXT8p5KIMTIqGWjVYs2IMrZYoRDyg5YqUJgNFg9oMUARmPLRE3QiQEdO6ZhwKoOsmEY\n", + "d7iuY3vlGKaev/+7v2e3u8ZYx7ysjNuOEAPr6Uw/NobmujRYx+3tLc51CFF4fHzPOLZp+jRNbXep\n", + "FKZ29H1HLpHT6ch2uyOlALWyrh5rLc/Pz0xTc5nHED6S32spl7ZKQCuFjw3m3BnN4WlPCSs5htbb\n", + "lgWRweieYbzhvMz0zmKcJJemIckVRIwMux1P9+/x6wnbdWAT4zBy3O8JMWBy4Wq343n/RCmF1c9M\n", + "0w6hNUoYYggNM2gsOa9kUdoA0XtC9CjVfFG1aKiZrnOkmiklI7NoaZAKorQKrtIGkE1r4VQ7pudE\n", + "DgETNbdXdyzWsT8f2S8PjKnjED2lrgg1gGjYti/f/iNSKazrSXnlbnuHEYZBbunMSLWW6CObItGm\n", + "5XWFlKQkkFmRL3lNShvgODmQtSbkxNPxPb3Z4OiQ2aJ1h7MSJXr2cSaWBvsuQtJbjWZkCXsomVJm\n", + "cqio3CGqJa2ROezJNtL3V1gzIWTGdgNOOUa34RBfk+LCGmeKqJc6skBpUFISfCalSow0r3pq7xep\n", + "a8PAicRX/7Ty1U+W1s//r6yJv3DRrLXyR3/0R3z22Wf88R//8cevf/e73+UHP/gBf/qnf8oPfvCD\n", + "j4vpd7/7Xf7gD/6AP/mTP+HLL7/kH/7hH/id3/mdf/F7/4//8zfJpRBrJuWFXFdSWdCqxYtibHcb\n", + "QrYJtNL1cjdROPs9S36mzxMmdWip2W22PCwjtcyoAD6vPB/fMdoNPoJQ7TghadNUAeTY4B3ePxGl\n", + "QVjPcmEAlizQ3HF3c8fY3TVwh/QEAqufqVpSrKFmz0brtkusijfvf87XXv065yAoqtnu+q6HdabU\n", + "5mePRTQdgdJIIxEytyhEahPU6FdWAcM4UoS89LgFBcUaZ87+ieN8ze3uZfPKSIUSjk9ufpV8Hzmu\n", + "X+L9kSC3qOwoJVy4ghaKpaa2g7fGUvWpJROKpDcj4dAmlbJUdtOG1XtOpwd0sYgL0GEzGX70ox8x\n", + "jgPDONIPIz4lfPCICs5ZYlp5enqk70fu7l4yjVukhOPpCaUk0zQB7RSz27XBTtf1tLB3y69WEss6\n", + "s9lseHh44Pb2FiEEj4+P1NwWy+PxyMuXLy809ERYoSpNDGfC0hQpndGsK5yWGSdVU+4qWmSnc6zL\n", + "yuG4x6UOpzegHNYO+POeZVnZXd8yn54pue2Au2FouUc0i5+RznB9cwOykfZP85nOGPq7G8QaiOcj\n", + "KfiW8kiSkPMlydFskENvWdelmQDMCduPdH2mG9rPTMomA8Q6Pqh8MYUaEuG8UksAZZpHvCaS9yhn\n", + "wQqqKaAFKSZCWDG6Q0mNUvD5F/+M667oht+hlzOdcYxW851Xv8H+/Mhxfk+qnmnYYK1hWTzeJ2Ke\n", + "CUu7vza6R4hCyjQYi5asy8LRn+m3GwSSXAtaaqZuRPc9SyxU1zXOaxFICVZMnMuKXzPRV2qWrCVi\n", + "RLrIFCO+FHZXDis7qgAtBmy3xfY3nJY31PPn+HJoGWSRiaGgOgsIcmr5YWhai0qDfEAipsCr7zi+\n", + "+R8HlJCImvk//pf9/79F84c//CF/+Zd/yW/91m/x27/920CLFP3Zn/0Z3/ve9/iLv/iLj5EjgM8+\n", + "+4zvfe97fPbZZ2it+fM///N/9XjuQ4czFikKCkepM+ckiGmhkknRIGjw35wT2l7qZ7EQi+fLx58w\n", + "bW953qt2SS8zfW8ISyHXuf2Q54AQCSU7nvaK3Wak73vO54hfT0gSqkxIHS7cHIGolXUNdGbkV7/1\n", + "m/TDruUAQ+V1fssy+5bDTBXdSaSwlLDgtKJURxWS4/Kewd0Qz8fWuKitoytLRVfRKoNSkWnKYmpB\n", + "mBWnHSUbEIXKSqVVz1IGrSRGj8zeU2rgsL6j74fLfe1jO2IIy4urXyU/FaI/c8jP1G5Cp4qQBSkc\n", + "2hhyKtSqMGXCygGlM1Jl4joTpKIsgo2zHI9PreVhHUo259I4DLx9+0UjqovK8/MDX73+OV0/sd18\n", + "gh07UinUXBjGka+/+pSrq2uMdhxPe0KI9EN/OXpHaq3EGNntdh8BHfMcLsdzTd/37bQh5UdO5vG4\n", + "J/rQdtnOMc8zwziwzDNaN5htColaEufTPTfjhtP+EeUUFMnQb4j+jDaKsAREbazW+XAg65V+c0Pt\n", + "BnyKxGVFhMD26go/e7TRLbtoNLl4csnMMXO3vWVdA/2wxcT29efHR8ZpS5LtM9Cwd5okFbM/o4yk\n", + "5EqKsXm7bX8ZDLUHpQ8eJ1U7ndRMDhklaJ4JKRrwVwm8j6SQ8FWSlwUrC8ZoNtMVaz7g18ISPSmH\n", + "VnfEYo1GyMI//uSv2W6uGL/1PyDoMJ3gdvc1/uM3/idKFnz19GMEI+Nwze1uYH/Yc1LvEOKE92fW\n", + "/ICzFzygvOw8naLkzNN8pNs4pDQNENJptLPoc6Fae7kyS42BGUQLpqfmBQo+tCsrY1DWscaIkCfm\n", + "+8+53n7ClXFoO2DcyMYILA5ZBI/hn6mybT5yDm2hDyshFqQwH2lRSsumRFY09XcpiNq0M/LfIlb7\n", + "3d/93Y8oq//366/+6q/+xa9///vf5/vf//4v/EcBQig47dpCVUCJgiiJnCIV0RSvpd3N5JCIPmN0\n", + "m4zFUnm/f83d0xsm93XmpVUmye0NFXIlpkSshf3ZM3Y3lKgJtsNpxdhtmJdnUjzgOo2SrvnSjUPb\n", + "HiETV7trxqHj+uqWq90OqiNEeH3/jjXNxDxf2hodZmgEHlEFQsHZH1DCkmtFCY8VmlLSxXxZESRq\n", + "URin6VyrF8pSqEVSs0QbgXWCnFZaorhN86SwGJM4nZ64+frXOPnnRjLvO+pBIqTG6Q1fu/5Nnvfv\n", + "OK9foeUjgxyaAKt4Fu/ph5coeYWqE05YtPOs8YksV6TusK5HSIVUltubHRKFMztC8CynM1bDUtpA\n", + "x/uFnDxT/xKt4HTaE1LhfPZ859e+Q98PCCEoNeD9Quf6jz30+/t7hGhd664bPvbF5/kdp+MMyI8E\n", + "+PP5TM4fCEj6Y0BcKdWwc0rizzPdVraf46XYsBkG5vnEMA6cTvtWTJCCHFuGWYgmrjPKMA098zyz\n", + "vv+Sq5sbbq5v2L/9CttZ5uPMze0tx+MRZzTOdsQYCV6xzCt5J+j79m/UonheVl7cjPjz8UJNL5ew\n", + "+Bk/z1TRrlza/90QQuMoKGVw1l52Z1ByJoX2IPDzjFatPYMAbR3KGjrbcz4eeD6d8aWRiaZ+yznc\n", + "EvPCMkfWJTYfuJIUmQkRlKoUEj/6ux+yGya+/fX/jhIVWldeXL8kpP+erhs47U84c03fD+yuvsHx\n", + "4Ve4f/gJ++NXHM6PeB9wncbYDi070twUFN4vHOOxDXykRlbVwNG6UnXFWNG87qLVRMmKkgRaSZIE\n", + "WSrXV3dkekKa8XFhvz4xrzPIntF9gmFA5IXBbhCinQjW/Eyi5WLX1V/uvzPOfsgzf1BsV5QuiNbQ\n", + "JaRMZ3uQ/17RcOfMaGwjc9PYeLV4cu4oVUIW5MQHrCA5Z3yBVNtRu8SZr97/mE9fCKiJimKNz4S0\n", + "kGvB5+bXyyWR88zN9R2iWPws0dYyjS9ZQrvDsMqhVU8uht6OSJcY+h1Kdk06prbM80zvJl7dvuJ0\n", + "fI8SO3JMUCOhNMGbkvJSiSss8XyZ/C50ykINjbaUF9AOoVvOTSrDbtfjw8p5XcEU9AWYrKSCojC2\n", + "w2iHVBUZKynOlOxRYuR0PDQajNSE6HGuVe/udt9i6Eaej1+iZGQcBFIYivCs65HN+ALBgLFbjI4U\n", + "LGt6BBEQUrGWGajUOWDUwHwukD2H4x4pC1c3Lxj7Dc+lMPYtP/ru/Vuej0du716243e5AIFpQWVj\n", + "2uJvreX9+/eXhoy41DIVKSViiHRdj9IS7/3HAHvXtUWqlIyzjsfHR/SkLsf6jhQjSkgO+0e6ziFq\n", + "RgvB6Ximc5pcazPQxhN+nRnHER884FHVU0MgKUvXD6zzidPTezCK65s7jvsjt3fXxBSZthPrPJPi\n", + "mb4f2U4bttOWdfWYouiHphARQjCfT6ScCMljRcsQCpp5UymLD5HFR2a/MriOrhuoJbdrBaVJYgGT\n", + "kVXj3Ii5urqAMhQN1NVsrKob2AjJQmV92rPMR1IJ7Rje9YzTyLIE4hIRNAB3aSU6lNaczvf89d/8\n", + "b5Ss+PrLb7d2jFDcXO2o5lusV4HT6YC+xKF22xsqM6kcUVqwhiM+r0S/UomoqrDSgk7s/RGNxSnX\n", + "4LcopJaI4gk+UoQghJYr5jKEoxS6fuRq801GewuiEFLi7I+cl4hfV758/VOuxyt0jUQhkSqRksLq\n", + "TdP81pmQJRdv8uVqr/XV1eWar7ZdFsj2NakUVStk+TfsNP9bvvbHGacDV9cdRjmKTAwyEQ+V85KQ\n", + "uQnlc1kuR1RNSp5UC9oUtJY8Hx7oup/Qu5EqAnPZs/gjJTUFcC0OqWCNCz7OTHaklsQ6F5TpGPot\n", + "Ph7QemDsb7B2aMeldCDGxHz21BvFYb/ncDxxPjcV8Nh1aFGIoZBqpXHnWzNCqMqy+Eu8pznbawl0\n", + "tt1lxRIhFXrXQ8qkNaJ6h9EO1zUZWi2KnNs9kawNrzapAbSgUz3n5Z4YjigGCisCjZaegKfi0Moi\n", + "q2BSX7vcC74hpUpne4QYWVeNjwnrBDUbZOlRCHpjWOQjiQI54LRh9YE1eHq1peZGHdpuBlAdb+/f\n", + "4OxEjoJ3h7ec5hM3n3wNJRWd69vRNCWmqT10Qkht0v30TN+3qpq79MihkY989BcknL6I6Nrfcc5d\n", + "oNARqSQ3Nzc83L/Hdc0XFGNAKcm6BnJccVpTSiCXiPft3rBc7Jc5R87zM5vNFcEXVKcbbtCvdB2N\n", + "NKQkKWdCDOzubgn5kqm0FpcrNRfOxxkloO97hqHHh4WwJmTXkUtmu9sRU2L1C4f9kZrzZYCi0VLg\n", + "On1JBWTIzTJpO4nqDLU2JqUulSpbYFt+EH/FSK6Vai/RsdwIUVPXU64Fh1LZ79+jRaXTGzbjgq6K\n", + "02HF+4gVklASWVaUMdhcuH//M/7PH/0nfPZ848W3ccqhtWHbXzEOhdENHA/PZALaaLQZGadrQj5j\n", + "0SjRsXhPyAUtJKVUlNLUKnhaTxTl6I2mzw6pLqSitSnMvPctDlQTQgtyaMbLu5tvoUXXShI0OEp9\n", + "tvTdhLWCh+efoeQrSslYZ5CyIIzF6S2pKPyyknIml4y1HUqJy7C1zQjgQyIjooxDCkWOYH5xTPOX\n", + "iIZLkfl8YDM5hrEDmdAqYa4gh6bjNMYSM/gwk2rGmB6n5kbctiPGdZyWGaUkQq2kegbaNNoZSy2O\n", + "abJ4v/D+6QuGr18ha22MzFoROLRyl1qkoTcTZuh4OmWO85lKZv4nz83mU06nBUSl5hWlc0OvCYPK\n", + "iVxFIwApLioKhdKSdW6KjBAXIpWYC0JLYjpTo8SwQxSDjAnjGii1ArkmBBJRNGRLCZViKlp0F43F\n", + "wNPhLS+vu0akl0Cd0SWha0SpnpBadbLvJrT+hFoDUg50/Q6hAotfGIis89owZFJSssO5a4QplCUQ\n", + "14BxPeM4YVNPiJXr6Q5VC8fZ8yvf+hXevXnP+XRqLY0cWY5n3O2IVpV1OaOt5enpkZQCSld+/vN/\n", + "5Pq6NYKstYxj25WllFiWGWiLkD3b1pqp5eNdJ4BSbSciEfSuw88LSrQdU83LJXDdVCZaSaTRzOcj\n", + "cTkxdo41ZpSybUcXPO0wa3Fdh5Aa70/EGMi+0ZdKicTk2YwDawjEktsdWC1oVck5cpwPOGcxylKF\n", + "pdT2sDydz4zDyDhtCD4RvWc5zIS13dtvNiOqSoxqdk1pNNurO0w3kLIn54rWDmUciDa4pMS2U0WS\n", + "lxVBJWQ4nw48HA68ftrzbj7gkyeIRDG5/TwVOGOZz4G4JChdyzOGhNCOodO8efszUg6sv1759ovv\n", + "0HcO63S75pi2pOh53D8gnUF2EpcGtO/I3iNyRFJxolWXhbokGWwPUfO4PLJhRxKgZcQo00AePrGS\n", + "CNG3WddgqFIy9Fu2VxMSxTpLUo2EJ09vOzrSWSKjAAAgAElEQVTnmlCxZp4Ob6gioYPCWkcVCi47\n", + "6RAj0Ue0tXTdBqvatU7MzQrbGnQRoSD6hBQSK3qK+sXz81/aoqmlhFqZTytXu2us1cTSnMtXW8Vj\n", + "gZwCAtOo56WpGly3oTjT1AxjwVrTvNZGokoDq9bSlBVC1Qt6bCLlhbeHn7Ht76Cohk5T9UIbtyhp\n", + "2yW5qFg3cP/wnv3hnnX9O17efpMcaFRp2eqISjXcfwVUvdxVivYhp2Ss0qjBEmLEuYlcPRWIaUbr\n", + "ZtWTukns269BoXTziecUSRG0cKRcWVLAJok0AlEiJSV8mdmfvsLWgXTZhZTk8Su4XiOwkAWlOIxq\n", + "x0YhLEoqpiHyuDzy7t2XTOOZJVq6YUPJDZXXOUlSDWnXS0mMLdw6biZiSuyPDxg7cnw68vz8gKzt\n", + "vrTvNtxeX/O8f0Ybiw0Lm92WL7/6nOvra16//ooQPafzkevrW8Zx+phVTKl5fz6oMT5YLJ1rmubz\n", + "+dx2Bfm/MDq9Wojec8yBcTNhjcTatpNNutIZTY4eZzRpXTkdnrGuQ0nVMqy5otRF7LVmlFGM44jo\n", + "R5JfiSXhpMJeIk1Om1ZZzAnjDMopSrEcjnuO55mrjWn0nDQzbTacj0eSDyBFu7pRsu0wNxtiipxO\n", + "J6Z+YOgmXNdhhrEtkFKjPmgpmga16XoL7YGQMyBJoYW4s9BUJEIalNYIWQnLypJX/OTprEJ3XfOM\n", + "a8WiI/EUKKugSHFRv2is1ty/e8sc/xM5BL756tdQoX2m5vMJaRVCS/aHR/pBtkrszTeYl4Gnxy8x\n", + "KlFqBFlBZ6SthLDgbEUlSUpnghUYYREUSszUlFAUkvck2XgBrncM49DsnLLHq4CfF47HAzkVrO7o\n", + "rEFRKTUT80yh2TWUdK0EUAs1GbTaojAUb9D9gFEFLSvndGxBeB8oGVAtIlaVYKn/ThfNHI9gtoQQ\n", + "CCEwTA7NhoRnmjwRzfPDSsmghUAqS28t1gq0Nvi4UHxBd2CUwilATCQ/E3K41MzEx12M0gahInN6\n", + "i6k9m34HF8dPygZtRLt7y56aKyEk9qcHUjmy//k7jDKY3jDaHVaNzMcVqWjVthTaUSSLFh8qqWXY\n", + "ZGTsNaVWau2QqhJjZQkLvTYYs9CytVuCr9jSpFSyGIiBUDxCKM4pkTkzpAPWmuY5qonj/LYRmYrF\n", + "KoftDPO6EE8RUUeCV6hOI9DkpNqOUUpKjNxsFW/ev+Hx8AZ1MvT9ytiPaFnwteLcgLUghENpg8qw\n", + "PzwRvCfFE7d24Hw4YmQzgcYsub75GjFHpmni1atPmFfPmy9+xm5q5HTvW9TLdR1StshN8JFxMjw9\n", + "PV3yl+31AcDxYfhTSpOnTcPA6XxmK1ts6f79PUZK9scnbqeJnAO3V9e8ffMFXiRkbeFvZyRa0abm\n", + "Wrc8roSUVrpeUzIICjlGejsyXG9Z4kIJTbFbasEaw4VbRhQVp027q1OSw+GJ0/HIq699yuFw4N3b\n", + "t83t5DoO5yMhBtLlYaC0ph8GnGs09hhbttQiSDEg6oVxWVV7L1mHVB0oi46+pS1qq64GH0ihDTu2\n", + "04RPiYf5QCclOkXWOVOkQbu28NNVdKwImcA051b2hSpohW/gq89/wrwEYg584+V30KpQiKyp7Ww7\n", + "CeG0UI3E6R7Z31J3iXV9wi8ngo+X5Ac032ZsgjVdUbJgVNOMiOSpBQwtkJ5JpBwbxNrIS98+YK2k\n", + "zvmikPas3uC6DRh5GZY1sHEunkqhpEoMmZqb6loWSVojUQiU0hQRm0yvKkTdkM4BZXqKEFQ84r9y\n", + "Pv+lLZr90OP9E30/8PhwYhhU252oDauakST6YUD0hvPhhFGGrhsuDp2INY6YAn71dKYnZUsuLfUQ\n", + "fSHGjNECa8XHAHGpoETFGoEPp8tgInFa3qOtonNXH2VrStoW1PYNlNt3CWU8dph4dfdNBBM/+/Jv\n", + "ebf/ClmbyTKn0o7tSuC0xGhL13Ut2hJjy0ZagekkoiYkFS1qo7NUQwoNuV+rAjp88uTmfOIQTvS9\n", + "pB8dne2ggNAaH32DHaeKQ1KF5zwfSXFPyZqBLcpZQgItJML2lJwxquP2+hPun97wcHzGnheuNjcM\n", + "00iXHZ3u6KcemTVhXolxJYVMSTC4HTEG1nDk+uaalGDrOsZp4t27NyiT+ed/+DGuH7HWYTrL/PiA\n", + "URqjWz70eDxeXEqS8zk3/mXfcH5KN9ybMYZ1XS84OUEtGUTFOcu6rvRdj7aanBJSVR73z5hSwcgW\n", + "GM9ND5piJPuVvu8uAFt58XFnapXE+YyUCu16ZLdp/p5S6bqR3Ar6SGVJJaJMg0+XUvDBo7qO67tX\n", + "DNsrnt+84Xm/Z+x7us7h13AxcepmKTWSYwyksJKjp+s143aLVh1VgpECaRRVqubp0QqhJBUDCIQz\n", + "0PeNy3BxJclcyXElicLTwz0n38oRpWac6YhCQinEWkFJiImqE9ppyuovVdW20DQQh0QKx+P7e/7m\n", + "b/8zPp24Gq+RSiAu71XlWjIkIVC0qJAsDqc2SC0QKbLGGZGb6ydnqFUgVaW3rS1XayXlBn5JJSFk\n", + "xSrNEpvXKuWZlFekVvjYGkGf3L7i6fme/eEJ7QqmtpSJvLBfU84ocaHQy0ZCC0uiSgdF4FWh7yyS\n", + "1GJ3XGYfQbOGNixKsqJS/oVr1y9t0Zys4RQWlvM7jOm4f3/k7uUEWDp3g9GF2hX62qGLwJem1JVa\n", + "tKlXcSQRqMITsm/UHjRUDThO5yOCM65TTFOPu3iEetdjpCJVQb1kJiNn3j19zvUGet2DGpBCUbOm\n", + "5nY5LJxgMNdcT99mO37CZnjFze7r/PWPfsj7h59TRW0B4uSRMjO6yt3NLUYreteUDSkXpDSs0YNs\n", + "ts0aExrP7BM1FnKqpNqqc7m0vr0UhVI9i5cg2/VDpyRVt+ZUjpmcBDEDBGourEsipoUYMrbv0VpR\n", + "wkLXW3o3MqqRQXbcbF6yhsrhcEDU5/Zhu/qEECR56NGmwpKY1xNWOKRuFcnNZsfXP/02KWeq8Fjn\n", + "ePP6S5b1RD9MdN2G+XyiH0Z+9vnnOGXQUtJNY2u7SIXWmvP5xDgOWNsC3s65jznFD3Gj/X7fgtnW\n", + "EGKk63vev3+P1ppu6Dk8PGClQZTKaT6TXUOsHU4rRla2g+W033O+IOS6TpJyAsAZ1/QlpDbMk8NF\n", + "GZspa6RzhpBmqkxMw451CSBic/YkmOcjMa64vufFq2/i/YnleMRoST+OLMuZ4/lInBe6TtNPPTkb\n", + "zueZ4ANWWaYXV+3+rTRzgda2eZQuURwhVdNaI6iqIoYBM46UdcFYxW605KdHpDyzX4+c08KSMilX\n", + "slJUmSkioDqBUZJqNV0nWJc2/AqhVReLbzGdUgUIeH58z4/+/m/45qffZhpHxn7AaYPAst3eEtOK\n", + "DydKUYhqqNGSo6GESi3DZWfYiO7KSGxpKLZQfBt4iiYPTBSMtcS6oIUghDMxzfh0akT7rjE2x75H\n", + "ih1yaaQj1ztq1ZegeoMlR5/QyiCkwmjbZidrq0NXEUAketvwjSVWYvCIZC8Rx3ZdQ/h36j2vIjP0\n", + "A6dlJoVn6F7g54J2GmuuGDcCfV7ZoHBKcU6CnBacvsXYG1b/TEgr5XLEEwKMbXT3KuVHr3QRreMt\n", + "lMNoSQq0hpGUIETLsJUja/Q4s0HYgnEOo3uM2TAvM7UmYghYM3F39Zv0tqfmhCw933rxm8znPT4H\n", + "JJrgY8uUjltyEcRU2WiL1YoQKyk+42yliBUtFdoayIHJTCgcp/O5VUljAVqCoNZWH40hIoTByIEq\n", + "G3fRyFYFS6KBRmqK5NoiS/NpIaiKXQPCtjsmuwpeXX3CtmtQiERhko5jKfgQsOHMed1zd3tHiBqn\n", + "FdKMCF04HE6IAnfXL1HGcV5W3r774qPjJ8bENN0xTRv2x2eoojVpqsCLzO3dHftzq0d+sEs25rK4\n", + "HMWbgE1r3QAuOV+iSOFy55kv9Pf00Zl+Ph5RylCTR2uFs5r90wMvXtzSDz3r4YGH0zPbybEm0MoR\n", + "Q6HrLcfDkd12i9SGlAS12ksZQ9F3tu2m5xnnNCFmTqcTt3d3HPcHjO4oshDXM4PTxNORrFY2dy+J\n", + "OWNKRltDN71k/+4eZwe++vKnpBC4ubnBWktc1vb7Fhlte7a3r5C2mSflpScNgKwtIuQTMqbW/xYa\n", + "cmwnllLYdgP2hSQZOKfM87lQlcKpiNADj0vCqMCm2yBFpOQTw0ayrILj8cw8n5HFIatuaggZGaYe\n", + "USNvHn7OLlyh9dcbzk2AdGNLgNTAcT6gpCOUBtnI2beNRrGUBEWIdp2AQKhMEZW4FqSQpJKJoume\n", + "2+czQ2ktwef9G0LvuZpeUvHYrilobuzAGp5QQiNFBzQIzodOe4tTNU2IIDaepmmyt5RXUukaM0MZ\n", + "KB05RbQUGGu4dFZ/4dr1S1s0k8iMQ0c/3HHyJ4SZEGLT9JwBrOzppx7hA1pKBJFiDLa/xmiLkY6Q\n", + "YF3uyaygBFW15shuGljXhZTbMSWm1uKxxlKkbpI0UdD64kFXCnLi6XSPmiwpnUDAYCdm/UxJBb9K\n", + "3r2759tfe2QavkXOFSkyJQaMsmQyWktyGfDBE6KmRosIlXhKmF4jRW6999I+vKWeiRlUNdhO0Nlb\n", + "lNny9uH+Y/+4ikBOLbspJdSYqakSq8DUShIJbRTSgiYRsyHmhsRSKGpaSTWQciPrTOPAw9Mbuo1m\n", + "7HbIkjGiRX+SDAglCOXA4fSaT6b/QPYK6yaYoMTEzk0NxpwD7+/fUWtqbABt2F7tCCHhfWiWQQHz\n", + "6QRKYe3QQvxSfiSYa60IgRaOdhbrNMvSnO7QuAfjOBKCR0rFPM/t2K7bqUFKgZKNJZpCQEuHEbC9\n", + "vuLx8REZEzEGttuJ4+FEN4wfOZwpRsZxIKaI0rIF+vmQs227NKk1JE2uimHsiTFwf/+Wl3evOJ7O\n", + "KJUxtuP5dOb26opcM++++hmlVM7BU3NmGCc2V9cc90c20w6hKvM8ozyQMr1qDS1rm/q4TclXlO4v\n", + "u0xBFQahCnFdUGGFWSCsacdS27QYpsws5zNb2/Mru1ucsnw1z5xLIRvNQGINz+AGpk3LKgtxJMTE\n", + "vEZOx5XcrjnJaaUfR7b9BmMEQhTm84F1c8vmxR1OmLa25EynDaUfeNo/XBYiC0ZSc4Es0cIhUUhd\n", + "sNpSi0RZgx4reWmd8ErLU5cSL2UHTQwLylme956UVzrdkcWC7iVGTLiiqaIgtUZoSfBLi24BH8Dd\n", + "7f4Yul4DGefMx0qyEBpotHlsAiGRJmF0uRg2//XXL296bizKGLTpuBp7ioyE8oDjmiwcaT1jXYc0\n", + "Pesl/NpNO7RS5JyweoOSezIQlkAWK5PucHagc4VPXmx4MoXj6dCO7FExrwnZVbJIjTCUmlSpVok2\n", + "I+vqOfoDvag423QazlpKDZxPlefDwt/++D/zW5+ZVndEUOqMlCu9SWRfsbZQqEho9KJUWLwn1orU\n", + "DbyKaoMHZS0CxTBsScnS2Z6uf0mVjp99+VNiXtsuJxRSTGhVESLjwxFpB2QoCGsopSURjA3U2Mjt\n", + "qUY6o3BaYYwiCMNSDHHNZCk4HB5Y5xUh2xGp1thABxRInqent0z2BZPZtTiPMbhh4P2bB8Z+CxSU\n", + "smyGLb/2nc/453/+Jw7He4ZuS+d6brc3/PSffsonX/sGr9+94WqnccbRW3WpTY4s67mJ8IRsP8tS\n", + "Wq71MgD6EHgvpeK6vhGPYgLrMKp9sErwuK4tvg9fvaHvJeN2CzE2WIZSnOaZzWb70QETQkCbRhHq\n", + "ur5JxXKlFo8QpimgqUilMMZe/izo9cgyw+FwYBgG9od3TN2WF3cvORxOaKfYTVODLitNkYqUM0+P\n", + "73lx94IcZmZ/wtiOlANaKmr94KsppGVGmw0FhYgRTKUK26RqQmA3E8IbalgpORBTahKYbkQUhZZH\n", + "SGecKtwMlqoVr8+efQxQBIO5wtaBoRvoXMDIp5YjTQurt/iTwMqB/spwffUJzmqqDEhbkRLu379G\n", + "a8fd9pN2v1wjOZ4pdcXYTAhz0/vW0uj6SJTgwlsNSN02Kr3pQYS2PxQaUxMxL6TadMBSiEsN0lOr\n", + "4GH/JZ3ZXOJ8zask6RrxSemW05QTMQRO50dKiVAqRlqkikguIjvTYMZVRBCy0RxUQRuL0xatE1bn\n", + "prz4RWvXf+O18V99VaVAWarVbMaJUjLzfCRXg08Hamn+E1krSYEnI0tE1waWrSWyrivzOTRAq44E\n", + "14LgqhNcOU1nenYj+FXh14qisqwLvWuSeGj05pp0Cy3r5v9pwb9C10nc6ojF4+yGOK+8fvuOkP93\n", + "ttMNuaxAArmiRcV2IHOls5UYPbFYjrFFTQgLpVS0SWjT3ogld030Rs/V9A1EaRW/V3efEjx8+e4f\n", + "qaWFcEG10HcnUCq2iJVySBkRRuJkAxBEfXGvi4LtLBulsFaQlWGsEKpAZkGqmTA/Q1EsKlNqbCqN\n", + "GttRKwc+v/8x3/jkN0i1w4q+xaWMIeUASD799BsA/F9/+yPO8xO77QbjWiXy5z/9CeO4JXiP9yu3\n", + "d3e8ffuWm5e3TNuG9bu/v+f25u4CDzbMS9stlJIJIbDZbNrRSim899jO4ueVGCPqAhwRVTKfZ3rl\n", + "uNqNvH79c9bTe7bTNVE6jocjoiaiDNirzQUPlsn5kv+knci0MRjlCGH+2ELi4vVOObPMbYrvuo7g\n", + "M8sS6PuJZVlBSvrBcT7sSUXShhIJrTQxBISsPD68Y7vZ4lNEpYjrOiqFGgPNrVoRKJS2zQ304S5b\n", + "tGabVIJcBNJOVNEhZUaW1MLt8xnVDdgXLyh+YSkHAhmtNRsHPgbOWaDdyOReYTC4qcWpqJlUA870\n", + "HO7PiNzz4u4ThmF78RK10xpyxasTb17/Pev8wNV010hBok2tMx4pK7YzFCKB3BIJuplVUQ19mIkU\n", + "EZqqmdafrykTc7nASTS6Siq1UaCkYhCCHGdiLJixI4aAsj1KdBQEqmq06jA2kPKBXNcWXS8zri+Y\n", + "mljXREx7ktCEHBGlqbu33USphaGTaB2bjA33C9euX9qiOfvAOAi0aag0aQxVah6O920abUZCdZQQ\n", + "WrCVRI0Lvd2SS8FHj0+peZSrIgVYl5Whg4JGqRbYNWzxIpFkowgtKZDw1CpRuV4UqRZNh7UGLSud\n", + "lm2yLjxX04CslV5qzsVzPj/zOjxwb+4xNtFPmqFr1O1Mou8UWjtqtpeL9sA+Fjo7UWqLcZiaEVGw\n", + "mUZSquwPR5xZ6eyOlAqQuN1cc55f8Lh/wNBThUaKFWsb+LemTEwKZI8o7d42lUwRCaEqVV44jbJi\n", + "KDizwQjLyIhRjrTu8enAcTmQNVgh0GS0MlAbBWjxJ14//Jhv3PwHyJZu6jjOZ5xUjN3Efr+/tHhm\n", + "NtsbUvE8vH3N6eQpJeI6SQyBX//VX+ft29dY02Ru1jpef/UVn7x6BVUQY6TrCtZYDoc922nHshzY\n", + "TLtLlbRdrdRakDajZEsfGC3pOsvhcKaUFS0lN7sbnh6+QNTCZnvNZrtlXRe0s5TcFBBGyubsLhm/\n", + "zjg7UnIGKdGqhdOtMeSU8GvEOsuynqi1Y5pGqJEUIyRaHXOeyWGl7xpBvGSDQpBLxnUd59ORUFa8\n", + "X+mGvlkwz+0B0Q0jqHafVz6AeJAI05BtKmeogqQMJa9I27KE+IK4eHLIiTqf6LRlGHf0VO7ffcUx\n", + "nniKkUNacWZCY1HG4cyAKJ6huyHnzHl5xJlM303kMGGMwvUtu1yyJKXK4s8IUTBWcDw/tgGKAEgY\n", + "bck1YvSFwCRUg6aUAAiybKcHmVdkrcTiUFXQVsmCEAYpt2hVkKpeNCAFrcCo0qrDBXLNnNcFYyZk\n", + "OCGkoOsbGyGXQpUeNwhysq1LHs6UvICUCFXwoZBqRgtahFB1SKGJyUPJVDKF2OKCv+D1y2sERUkJ\n", + "le3VjkRE6UqVkseHZ4jw8muaki8O7ViRFUiZY3gi58TqC7mAFhZyu9soXrAuC73bNAmV0mil0Bdl\n", + "bcqFvliCbUOUvCZCWAgpoVXHdnxBpw0+nZEyo3XH1c6ghCEnxe1oefde8e7xXbPuBUFBQE4waobR\n", + "0VnZuvI10/ctUnOYPdkLZG2hapEkgzPMS2AcJ7yP3L9/y6sXV6z+YisUhc4aNuNI8hljJ6o4Y1UL\n", + "+Qt1MXHWDySkTCqSKhoGLuXEWhLe9Qih2ViHliNW7VDSUI3hKOG0LOSwYq1GVYmWilRWlKzNER5P\n", + "rPEA2mEojLdb8v7I8/6JfhiJMTNNI09PBw7HB+5uv8U0bqAmzucZKTWkipWKzYUyNZ/OKKm43l3x\n", + "7v7ho+N8XVeMdg2EIhukN6WCUpKu69r3EwJrNOfzEeU0QlQ2zvHw8AXbaUQIz3a3Y55nUlrRuqMf\n", + "24NAFHGpLRaMdnRdxzzPLMvyEa4thEbUQq0CbQ0+Rs7zievrLafTzMPDIy/vXvD4OFOK4Gk9s5sm\n", + "1tNCzqBNm/RKa8gRDscTY99zOh6J/szT8YneTtjLsV9oyTCMyFqoQiCMo4hmapTSgVLUmlDaoeQW\n", + "crhANwAfyH5FCkHIgZzB1IzTlRe7G/LxyCmcieFEbx0URUyZcRD4NSIk9O6KbX9NTM+MVxW/Loha\n", + "qdpRirg0sTy5nMkl0HUdJVuir+QSiHFFyMYjTSlQSiXn5q5PITUhmpTUoghhRTnJKldqoRVXmsUH\n", + "ozqEbBVG45rihByoObV7T1EJKbWHtp3p+x4fzyBKk/LVSsq+VZnlhFaOsbviuL9nXj1aWwalOC8r\n", + "RkqMdnARNFZhyekEuhD8ihT/X6fZ//P1S1s0t71jUAInM70dqFWysZLBXrHmt1hp0aLlwFKudELj\n", + "bE/RGqrA6cSgFee1Vep0EY0XGSvZO2Q3taiGjE1BimxPMilwvSWnyiIysVZE1AhhsWbikxffYl7/\n", + "b+beJNTSNa/XfN7269Zae+29Y0fE6bIxU296bK6n9EpOBR0qgiIoznTiTNKx4khHIioIDpyIII7E\n", + "kYXDohLqChctb1VyzVTzZJ5zot3N6r7m7WvwroyqW6VZhVLogphEnNjBiR3rXd/7//9+z7PnOD4j\n", + "J4+2mpubS6IzKDpW/UBGcbe/ZXYBKQoKgdGC0hmkUAhTSKma9YRQ9L0h+nolzFIiiq7umcmTS0DI\n", + "zOJ2LP7vWHVXuCWQS0HLTGcU2RhSSRg91Ou9ol7btUarjiUcKTkTS2UD6kZgh4w/FqaiSdHBfKRr\n", + "W5SJGCFJQK8bGtkQikdJg5YKkSW2saQSaewaQuFweoa+6DFqjUYhhwHKwjgfkFJxWhzOjzx69ISr\n", + "qytuX33E7Caur9+mbXrGaWK9vcD5wIVSCKl5++23efnyJePk+NSn3mOaljdELa0N2+0ly+Kxjalx\n", + "MmWwtiOnQAiBrushR0xjCcmTYu2Jn05HHt88JmVwsdDKTGvrh1dyS/3gbDooVcXQNSu8dOfZaV0S\n", + "SVn70KlEurZhnjPLnLCmwznHw8M9xtQigRCa2SX61YrgHcEtdH3PsjiWeSHFwKtX+3OgO5FdYHIP\n", + "hEZj275GqYxita2JhCIqsizODqEkYtVRlKFkWUEdWSNFQdiEED3KSJILLLNjijO7ZeK0OIrQrPo1\n", + "hyVhVENIYBC42cEago8UkbBWM6yumdPIEu/IzUJJAp8e0GUGIGSHaSJWgNaJFCaEsKTYknJmXmYK\n", + "qna/JW++RyGCKHUZUx/eWpIrVU2uFcklUq5tp5Qine1pTUORid4KiAnvF4KfCAGWpbCEfIZ5zzSN\n", + "xbk7tLGVwi5bYFWp7EniXSX7bzcVP3hajmjTUqIgRo3VCs4L1uDBn+pGPabp255d/3aH5tqwsRql\n", + "Ftp2wzQJSpkYuoGS12gpKTERz+FkciblRC9aaAaiTgghiWEhqyoTKylhZE/2hihNdWAz47ynKQUl\n", + "ar5xju5MeIGmM0QKvbUY0SEpDM0VMc3sTx+ChL59RKs3yGLpTM+0VIoRaaHESD7ToJdTRKSCtZpG\n", + "9WdToMAXhzQWYxQJIEsEhpg0+8MBoWd8zsjjkb69w+qW6DMajZamwouVAvmt3jRQSl0mKNBKAwIr\n", + "WpSEGD1DbyF6Tm4ha0EYX1GUpIjAut/i00JIlSWpkFhjsabDKEGRlc5UdEIBIXscR6zqsM0KHyKJ\n", + "qhA4Ho5El7h5/Ji+37J7eMY4H3n65G3mecY5z+X2CUJIVkOL0holBHd3t9w/3HHz+CnzMrIsns1q\n", + "hVKKZZkZhoHj8UROkdbWapwyAuVqVEkBCPA5I5SpfFBr0aIjRWhMzcVaa3HecXGxxRVPDJGcEkmI\n", + "c/8YTNuQU8KnRCqFxiqkqm/4cVxYr9ZvxHBdV1MAuHiuejqUUCRU9dwI2J9G+qZFSUmRir4feHh4\n", + "oDnHifw8UjAVXK01XhliCOhhoOjKU61KiwzBo64eE6aAUpnsApSq/CVDDAUzbBj6LfnwgMl18TJG\n", + "KNKCaVBG1LZLFizzxHF8IBaPX2ZcsJjBYNuO4nvwBecLKR1JZT5j9gyZDKUGe3RDbeyUttKCZAZR\n", + "HxSSW5BZosr5aZOAGAwogZAVWVZKZYj6kKr8LRaSN1jbo3Vt/OUSydSki/cRHwUuZsS5Mmp0tZ9m\n", + "GRi9QGaFVZZuuGTVXrNeXxOd53C8Y5qPZHGkbwUmRIoKLMHVqBqCXCIhwBwliK5iJvkXQoj//3w1\n", + "RtI2trq1FRhTryddq/CpJfpIjo5cEsvoKWVG5IK1HVIFCglrDaaz+LhQcq1MllyQGESxBC9Rsiea\n", + "zO5wpJG6ysaspaTKEqQoYtrhwx4hIvMUMUbig6vzE6tZ3IGry4E4S6weuH6UOExvc39KhDATfSSo\n", + "SoXPEaKtwXNFi5WFqD0u1ANUS0k+b4rJCkGllZMnUvZMywHPiChQVIPVfUX3S0sphhQkQhWgAmV9\n", + "PKKNIIY6P7PyrE5NESNn9oeZEDKpLNztPmHoPM5XdQKxkPSZ2t73KNVQVyOBIjM5T0jbkRPcPbxE\n", + "bS24QisLwgjcMWCUZnWxIqXCeDoxz3rBPMkAACAASURBVBNX14/Z74/1aq1tzVamVH/EyOu7ez77\n", + "HZ9hca7WQY97Hj16yv7h/owKzMxThWGAwuiB4GfOiRysEqQUiH7BTROXF5taywye7eWWw37H9vKC\n", + "02nE+wUhJIfDEagHsPOOTisWv9D3PdJISrbgPTEEjscJrQT9sEIgz2MGzpXfhbbtz0+kAqUkh/2B\n", + "8TSzGjoW5xEUFpY3/fPxcGC1WrP4hRQyTb9G5IigHhBKK5J3lJwpfYcwinKcEclTlCGdTuimrU+h\n", + "WpLvjmiREDKjiudwe0Q1HY0qXLQNThbyIlmK5ubyMSFN3O33eD+RpePV/oHV0BKEJ5eGuHiCzwQn\n", + "id4Ql8DiHVJGyLZmhRHEFBAo2tUKJSoo2OiCO39fJQqBIvuICoUewGqyKkQZ0SrTtrrelMjEGFic\n", + "Z/aFwV4xzwt9K8hFkEWAXJdMQRRiiZVupiRDZxCi1DHTmUlh9JpW3vD46nM82twwjoHCxNXmKa1d\n", + "c7f7CCJ1dKUWBq3eIBVLTujGIpJliZ7i2297dv3b1SgHiyiFFALH/Q6UQYo621S6kEX9Sz2Od+wf\n", + "DjS6oJuMloZh3VFE1c9WUrdF6Dp7CdEz+wNCGUw+E2SaNaNxjNNIdgIRBVJJ5iwIUZCF4XZ/y3a7\n", + "q8Dd0uPdQnChXne1ZD/usFim+QHw3FxeINSReWmrkz0F3OLqUkValDQYJRBaILNAy0QKM2Ahq/NT\n", + "UD0UpU6ktBDSkRhqK4LikaUgSyKmA0J1oCwpS+KSyalS6XGJfhgw1pJivW5pWQsB7YWmNz3TtDCO\n", + "AhkHUjGcXKhPivFsNrR1xqmlBhxG1MZMEZ4iCjlZnHPsDrfotkFjq6DNtJVlKgSSCiu5unrKadwT\n", + "YtV7vP3k3TpfzJlH6zXHw4lPv/cet/d3XGy3xBh58uQtUsx1JGEMOUVOxwNaSWyzRpy5h1JCDg6s\n", + "psSAVpLGKFLwrFYrlE44t2CMZVkiTdugtSCEeMbGVfSe1QrvPBfbC1JKxByxTVvbSEBWgtNpVxcN\n", + "7Ror1HlhmM864umNh72x9UPh9vY1fjlgm4YYI+Mx0bYLfdcwrHv2uwNKKkzX10WHqX6pJASpZHxw\n", + "WL+gF08p1aCZRK6HQ/S1zFAKClCbgTQekbkgbEtneg73d5yWE+nsFh/6Lct+BOnoW9jtT8jGs6Q9\n", + "Jln2YzVLKmUR3hInRXQDy5w5jJVNmXKC7GsfW0jadgC7xk2FtssIFWh7jy+ZEBYSpo6/tCKWQCFU\n", + "nq/MCBnq+Kfkao4MicUlTpOna5+y7t7i6vKai83A5F/zcPyYEO9x3hFLg24ErTL16+iqjZFKE0Mh\n", + "e4UdejbdJYNZc3XxDoY9tz5wOh14ON0RwoJuEiFONd8pQYi68Gy7hiQKiBUsmRj+nYbb297ApPHO\n", + "czq+xjSmxjWyZNV3yNJwmgKHybM/ZYwKqDnigudSdEjRoHSmUEg5gqgCr5Qz0/LA5CND+4SuazHS\n", + "0A9bTjnivEefq15zEAQCKjfEOPH8xdcpV1DGW3w5kUpkmjza1GaJYiE6U7FtMrNqVjTaMmuNDxM+\n", + "LMScCalW7YRq6maOgsypBsfDRI6ZVBqUsjTNgNYFkTuK2ODcPT48ILMl5UTIM0JrcpwRMiHP1/Pg\n", + "M7M7YpWg0R297VFWsQSH1LkKoyRoC13pWPWXiLhinBwhSHwSOD+9oUvtlyNm2FbKs4ykkojZV1e7\n", + "tEjdcvKvsdIi9ROUMhiRKEawGqo+t1n1+HFkWWZKVjx69JS+33B3e0+32WD7DlMK4zgikqQfVgxD\n", + "V0lFxyPbq2umcYQMKQSsaikxcDw6LraX3N+/oLOWHD3ZO/quw5fMeNzTtIYQJW4Zsaa67Y01SNmz\n", + "WV8wzyNd2xJDOh+q8/8JORaQ00xjLYg67xv6LUIIgq9KjrbTlKzIudAPHYfDgRcvnzF0PRebK548\n", + "fpvd3QuCTwx9j5tOuHGPnwTTNJNzOi8pwCiLtfpMbm9R0p4TFxnChMiauHj0Zo2QiuiOqBix62ui\n", + "PyF9QtkBSCQqLu+yHfDPP+R2f8uUAkEuZGUoZUbKiaZzTOEViQPBmRoklwZjesRi8D4zjrA/OvxZ\n", + "QlZvbhFx1geHxdNqiRYFtzikWghpJJexWjdjoSRLxqOQFGEpSiAI6BjBZ1xQeFVdSrFIVsMN7zx5\n", + "n6vVu2zWG1a9Yeh/AKnheHrJ1z/6W57tv0orAkpESqnq7ywlzkkoKyAyzyPvvbWpbaaU+fx738Wq\n", + "7fmHb3pe3H5Y4eQsKF2hI6UkKIWURZXO6ILKNbJozL/TnKbPdX7kCow+oksGpdGmpVUXQE/Ojt5O\n", + "3JUT2SWkj7gQCWWh7zu0qTQcKRNSFGRRBCdIrJn8wji/5C39Do2xGGMQ66dod2JZqlrVipZpP+KS\n", + "xwrLsowclxcVwyUKWmlSgcUHjLYcdg/4paC1odEGYzS26ZGqQTqF0IpCQmhLKopQMklqgqMK1BAo\n", + "Ua+WQtZ2itEKq6uymBKxfctpUszuJShIaFrTn22UkZI92qgabBYWLTuiU3iZsb1B0+KnIy7O5/mQ\n", + "QooNio5UFG3TI2UghD2NjlA8lurTnuIeEQM5LUThESajpKOUE0I2LF5xmg1t09HR0nYtXdtjTYub\n", + "Z1IonI4npFBcPnpUuZ+7B7qhZ7PZUHI6U6cSw7CiH3oohf1+z/X1FdE5RKo0odf3J64uL5nmkZIT\n", + "W65oGo0WEENiPj3QW02jLe54D7LQNQNzeYAigVIhLTEwng5n5FxmtaoHXt32VjlYXUBFSkp0bUfS\n", + "mmVxtG1DznW54X2g71bEWGNKSgha27DMMyXfsdmsWW+2hODZHY4VxiIV0XuGvntTj00xIQwYU3v1\n", + "QoiazTTVWipU5UnqbkXBgjJgRM1r+hmtFeRQbQdnW0DJGZEzT5++B9ri7l8Rhee4vCblhcXvCGXk\n", + "dDrizn3xeXYYtaFrVlgJKRZyjvgUmZaEoiLmpDg7dUx1HJ3GIzEYusFTxIlCpKSFrDSlVEXF6EFJ\n", + "UwWFIuKSRFCgKIzsUVGAkLS6RciOEgt913GxueHpkxsarTns93g1crN9j8yEH59jVSRmQUianFqM\n", + "3dD1F6iS2O0fuHvY812f+QL5jHzr9MC63WClrjsI6asvXNYuegoCimZJsRKvSkZbyPw7BXZEIkEW\n", + "5pyI0pKlQsuMLJGL1Q0hSBQXhLXguf6YXBQlJUpSnA4FONL1PTmPGFMDbp0d0EqyoBBpYjpOHOwD\n", + "rTU0/YDShq7d8iBecHA7pMq0zQq3jLRSI3Jgmk8Mmw7vBdZ2KFWVwf1gQQpcmPAxUaymaxuMWpOU\n", + "ITdUgnjyGNNV8nZMiMZizIY5PaBVgVIoKEqpbETnHJLK8gOBFANGXTKKHRBpdEtOLa1tyTrjYs1A\n", + "alWXFRVsIRHRkEZV86xCkkPBC8+q7UFEIhFtDZKIFhkjEiLnKuk6I9GWIFncEZjRtlBSoVMADqkm\n", + "pO5I4YiLJ1rVMHQ9Rq6IxSMULKcaBVmWzGk8ETNcXFxiTUsKgaI1Xd9xcg7bKEJ0SKrKohSYjgeG\n", + "vmVZJtabFTF5jBG0tscoECWTcsS5E0oVUnI1UZEWpDLVWEpE65ZMYZwmLjYXLG7CNvWfeqUOWVLK\n", + "GFPjXW8iT/PMfr+naRpWq4GU0huqfPCR++WevmvP1sz6d6+FIoSR/W7hcntDLoK+H7i/f8BqiSgF\n", + "v8xo3ZBSoJTacJJS1+9TLoRcKNqQpT4TlASibWrwXguU6hBSIxKk/R1Q21LFO4qs4JkSPCc3UWRB\n", + "Nw05BlycuN+9oGstrdnQMHLce3az53RyrPqM3mikFZDO/nFGjLXIXFMORlukqDPwlAohJKQQ5HEh\n", + "ixkIZAFBJkgLGQe2xZeCKpm1tQyqR5uhjiMSZBQx1kSA1pnFveTVvaiEMK25vlhjrELOBecWwhgQ\n", + "sSDIWFmXQEre0PVPCaXOPjs78er2I5689R6Prr5AUYW2s1xfrXi03xLSx0SRa65ZZGJ25ORxzuEz\n", + "JPzZDJvPJLV//vVv5wgKEzEbtG257K5IOVLKgpaWrunJJSHDgm0MRilCiQg6SkkIIlZ3qGKxSqLE\n", + "hAoZGQSbboPNhUZdcZyPLPmOw/GBTf8IoSRGrumur/H3/4U53IJd0+aWrlEYOVQOJ9D1AqvN+bF9\n", + "wC8nstJEoSBnTJEsPqNtpu068uQQwtW8aCok5ShJIl1EN5aGgWV5XbvEMiEIpNhwGg8cJ8fQXtI3\n", + "HSUvFDJWDUCkby7JyRBjQaqza8UkUhpBPDCHha5oYIVIdbM8xkxCkUtdhDR2oTW1nTO76i7q2hUX\n", + "2zVQuL+/I+uId9Xc6UMgLjPWgJszpqmdfiMzQi/kotCmo1jNND1wOFSlriiVQCWFpu/W9MOatm1x\n", + "s6dRmaF9xGH3GqF1rcXqBpEj0S8c3EyjdPUmiVxjN3Ehec+6a9jvXzEejzy+vODV4YG+lQgJ8zIi\n", + "lOJ4ONHHTJG1kqlE3U5zBoHM04K19o2TSBsNpZBTdY3Ps6NpW1JM3N3f0vcrbNvWLf0ZNt2d5W9K\n", + "ZdrWIpUEHXC61EP19R3DaqCEwFs3lxyPJ0JShHlkiieaRqHRGKXxbq5e7qahs7qKxUyd1UqpiKke\n", + "foWCaM/he+ERTUvyHt0aiqhzPZECx2VknE+83L0mGkFBsrhYYRrqCoWl1VfM44Hd7oEsOoRYY2KD\n", + "NqW2kETBohhLFewJoVG2RnwMFkpBSYUQ4MORfI6DZxRRxooaTQqlItdNw+PVmsthwDaSLAVzgNPk\n", + "ObrEcfKcUm30lfLA7vACNx853u94uVGYznKYXvL89h+Z3XNaEZCl7gckgBjJZa45UuERJhCOr/i7\n", + "r/3PXPcXyF5APBGCQ8tqQ4gEQGOFRaRMSaEWHtAI1ZKjQxlRuanf5vVvdz0PJ6Rs0KahbVq0lrip\n", + "QaCwpgEFJ39kH1/SrQXaQXKecv4ETOH8jywXhLFI4wHP0GoGtcblhq7tmZLG+z2H6TU3209hZUvX\n", + "bXmL7+Qfnx1QYkZbjdEdnemQMhNyouRSJV66buL9NOOWisQP2RNzoDNriO1ZfaHIxaAVLDEzLuNZ\n", + "2FZD901ziWots9tTyvyGAF8yTNOEWwpldQlQ65lCVqmbttj2gtM0VrhAUUjVsuo3iNJyyrecxiOl\n", + "hUb1VVtRMt4Hiqg09NRIkq7UGe8ybbeisxe0cottNa26ZjzesU/3BALBVSYnQ4tKESkbRMmoJmLb\n", + "REkHXFmzmyJ5dPXJRGjcOCGlYXt5jdEtPsSq3W07Lrcrnj//JqfjkSfvvQcKopuYjvszqXtFSZ5C\n", + "FXAe9g9Ya1itN+weHhASrFU4vxBDJGqJ946MwDYtK0TFi4WA0uCj5+pySwyetqnb0BTDGdYAzqeK\n", + "CHSeO7fQdT3OObp+4Mlb7/Lq9UuO00jfGPq2Qcq6aJOqRl4QNc8aWBAZjNU0na7Cs5TY7x5oVitk\n", + "yIhgAM8yzmiRSUnSNC0zdRHTtpG+ZKQSFFXfwMYoUg7ItgPbU3wi+wVtDUptIEdozxoQkbFNS7zP\n", + "HN3Ifl6QdkXfX7FeCkaBLJmhyWhtiCURYoUECypAJlMjfNZYErqOnKRGK4kSkkZZrGjRQuPLTGMf\n", + "M3mJW+5IsiYUdJGs1JqbzYpPXz/iyXpFv24RMnBYPHcnRwiB3RRZ/MJ4nPB+JBVouxZ1+DrNKuOO\n", + "EPeeyb3mxcM/kHJgZQ2gWfWSlBYSHb19St/0nEaHEBNN43jYfZ2//+Z/5en6RAwPhGhIImOaNSUL\n", + "/LmymZLCqh5tFBEFUpGwCBOqR/7bvL5t9P2jjz7iR37kR/ie7/kevvd7v5ff/d3fBeDXf/3Xeffd\n", + "d/nggw/44IMP+Iu/+Is3v+c3f/M3+c7v/E6+8IUv8Jd/+Zf/7NcOIZKLQ8hMzkv1nZfMen3JdvOU\n", + "pzfvMQwbRveMdhVYXRT6TcB2ASHrFSfFRAya6BRSdPVAzbAeOq5XF2yGnuv+mlV3we7wCgFo2aLx\n", + "PN58iveu36czgraVaJ1QytVIk9ZIaZGy5v+ktJTSkuJZbpfALSNC+/N1t8GqeoCWIhEFZJa4eUKT\n", + "MdpSksKaNav+hsZu0FqjZe31CmGYp4UYCyEJTvOMiwVEAwi0tFjTEuIJpQsiG6zoeXz5ad55/AVW\n", + "/ZaiPBMHTmHP4mfmZWaaPYsreJfZ7w8cDjvm6cBht6ttotRUOycN7z39Tj799HNsGougkqXisuBO\n", + "keN9rp4inyk5ktSBOd/hOKG6Ft30zC6wubzmydNPMc+eh4cHjDFcX1+z3qxxznN7901W6wuG1ZbD\n", + "6YG7F59gDXSdQYuq2kjeQ6r+nq7rsEaRo8cIwaprefHsI6wyiGSJMRFchALO+zMyrkNKQThrNZSq\n", + "nX111quk6Dju7vHzEb+csEaQUw0/q3MmtqB4/OQduq5nvz9wGkeUrmizGCO7wwEfIz4EcoL15oKH\n", + "w5HddMJ2LaJt0P2a3etbxt09IUfW6xUXl5fYvieWwuQ8Snwr9F0oySNLQJQAGpLpKcMlMRnSNCGp\n", + "+DhhWlIRFVySHFIXomlo+p533/4UTy4eY0zl0gbXsu4/xVtPvoNOX9CZgb6tbRmtDcfjAURkmiZO\n", + "y8R8vu73tqXTit5IOhtoDRgJuhSsFGyaLevmKZerz7HuHtOkjkH2XAvLu7blbWu5UILWSkRxhGnB\n", + "jQun08j9fsc4jZyOB+bjgbwkmiKxpUUjmdwdiz+yLFNd1MkGpTRTXNiHPTv3QFAW2RhCmXBhR9s4\n", + "lEooJRlsyzc+/irf/OhrfPTqI54fXzMGWK3fZbv5LEZe4JxEiZZGrmjyUOfz9DR6oATx/4bT/PZP\n", + "msYYfvu3f5sf+IEf4HQ68YM/+IP82I/9GEIIvvSlL/GlL33pv/vvv/KVr/Cnf/qnfOUrX+GTTz7h\n", + "R3/0R/nqV7+KlP/Ps1lxhZtmdLfgXUEWTQiRt578B9596wuUsuBS5sNP/jPez2hhSUYz2oCbKqHI\n", + "O4cxliIbsrYYJfDeE5zHdtC3A6fFMTQXqAj7/WtWj24Yx6W2ClJDay9rdCfkSvEuCylT4RpKkTNo\n", + "qWh1wyIDIS7YViMzhDDRdT2GprYTvMQvlc0nSsEKj3Mv6e3bKDWgTZ1P9U3H3eElTlbfjRCgVY8P\n", + "lbqT8j0Pty+xb71Ha3XtKDeKcYEYj6z7CyQNiUzXb2l6y358zuLuoHi6ovEuMnuP6HuKbmqQN1Uw\n", + "8TQGXvARZMl2dclquIQQWA8DJT/Gzffczo7jMiNkA3OkbQqrZoVSGm01OSRUabHa0AhLc9lQfOD+\n", + "7q4elo+vaZu+1lml4pOXz7m+fsJ6PfCwv8UYxcXVJdN0QEpJ1oZUMjEFvHdcblaEZaZvLG480VmY\n", + "TgtuXhj6nlwiKUPKmcOhvvkzXa2qJgelAmbHVJdPFXuSaZuG1bqOKhLgfKTtDEZZlNFEIjlESi5c\n", + "bC7Y9APjeOJ4mtms18gMGs04n2hNSy6F3W7Per3GTSMvnz3HGE3TWpRWzPOEpFCyrebNdsVqe1kV\n", + "Iqo635XW0DSUosguIMWC6K+QpgoH8zJRlrlqCbSEvq/+7qUS4LU1+NnhxolPferzqN0dX/v4GVoK\n", + "TuNIDg2d7ZicpzENmhZkIibPi/sXFJHq6MoKQvS0ZkEbRUaR0SBnogiEEsjyknVnKdFik+J6/S65\n", + "uUC4F6ysoMkZ5yIPuwPTMqEk7JfC3Tjxej7x4E64OZJDYtMKBivpO0XTF2g8BIjygAs13VECxKjQ\n", + "RuG8O2+7Z7aXAypIlATTSvQIRmmy1bi951n4BkJbHt2sgQYtOnLxqDKh5QLOIYui0R0uOiKe4AML\n", + "GlX+FcCOp0+f8vTpUwBWqxXf/d3fzSeffALwxg74f339+Z//OT/7sz+LMYbPfOYzfP7zn+ev/uqv\n", + "+OIXv/hPHJpbZp84+D3W9oQFJIahWVdBfFpYL9W5nZR6046RGlbrBqM2LCkyhxlphor3EpqlJJSb\n", + "yMqCsIAi+oLWAykVbnevkbmp4XEkKvYIM5HkQhARce7OFmS1I0qJwKKlZm0vEGEGlSgKYl5IxTH5\n", + "U53uiHqlL99CTmmDY8L5HW2nUXrAqJau27Beb/jG65dM4+35qtdiTIuUVQal1YlXt/d0dosT1WNz\n", + "dXHJcXpgnF/RmiusuaKcQ75XF29xeNDMp+fINCJUotEdRl3TmB7dZvan27MHBV69foVbAqerK1IJ\n", + "NKrQt1DiXDvaoiW7QhG1wx+cQkSNRmN1vY4XH3DRE1IkeY/NCmM1Q99TsuB4PNJ0Lc+fP+Nie0Hw\n", + "mXEckcbw+c9/jr/+27/h6aMrcsrsp111YC8zq6ElZ0PwkcM+IygYpRinkbZpWa17jscDQhj6Vcv9\n", + "rmC0rhSc3rJarzmNI9oY/DRhbfMGnpFFbWV1wxpx9svHDBAp3iEbQ46RFCLj4YG+X3FxdUmIBedm\n", + "tNL4eanlCJHIIp975NWImbzHjSeWKb+BYecYqlObgrK1hWIaSztssNpiuh7dr8lCIa2mNC1JCESM\n", + "KK2RwwXFebI/wTzXRc/1DdkH1P2O5eEV47Tj5e6WsOtYUmRZPHPUzCGw+J6SMiG56tRqMiUlYkzM\n", + "yz0+JhKZxjYIJRAFAgUlGwodStcMtRCKJR5psqRrLCIYNGtK9ljRYUUmBcu0X7gtRxyZLDPTIhlT\n", + "Yi4LQTtEThgtuegaOhPZXGhUA15kfKpqbOcL0StEbpFZE1yocbsEh3Jkt3/BzUoipSbHiCSQvSN6\n", + "iE4xlT1Stmw3M/msKslE5tlV93yWlBAJFBYSQUaibRBpg1Hffmr5/3mm+eGHH/LXf/3XfPGLX+TL\n", + "X/4yv/d7v8cf/dEf8UM/9EP81m/9FtvtlmfPnv13B+S777775pD9v79SEhi1wvsRNweCz6iSaZSm\n", + "1ZpkWhSCea6aValVte0ZjcgtBcNmteKqeco8T1WwhKIYSZQGtzhyWPAkQgo0XUuWksNph5VbEAJj\n", + "11ytFHeHbxBZcHmuaLhcnT/ZjKQEgS1aazZDz0Zt2c17TvGOKALLcsZJFw1FoduGWE6YojClkLIh\n", + "5SMhasQk6C+2tM0Vq6EHteE4ThWSoPSZZF5omxXHk2Fa7rnbPVA2a1IUNI1ECc8Sa5DZNjPdsEJi\n", + "0Wrg6fYRi+p58fHfgiv0ZkU7bOmGC5QtTHHkOJ8qs9IXdrvXTPMDBsXFdnOe9QREm9GjxCpDSB4p\n", + "E3lpKX5N9KDNiFEQciDm6zr8lxXV1qw65tnRdoqnT59wOB5RQvHq1Wusbei7NZ9+99P8t7/7GtdX\n", + "V3TdmuPhgYeH1zTdmuurS8iRaRpZrdbM85HrzTXeBwBWw4qUMlKqs8O8sNms6due/f6OEEGZHtsN\n", + "hBAZNmdVbIpIqzDKAoJEobGWzg71piOr/iLOrt5glKZvh7pYGyvbVSnF8bDDLRNWVUtmEYKEYOg7\n", + "ZlFIOVXqjq85wKZt8E6RSr2xaCUxuuaTtTrSX9yg2w5t69LHLQt62KJNDwSyc8hmjegNqlXgM3He\n", + "IfYH5OYKcWOxsvDJ6094fjowLq/5+otneODF7h6Po/AZTE4clyPOzyi5YLRAqkxafCVoISg5k4vk\n", + "NBXarFDaI7KCoklCY3VCNgdOfkY3BqRkWU40IhFFQUjBROGYIsfZMecavzO65iqNiBiR8aIS+41J\n", + "dH1Bq4RUdea8uMw4TixeELwm5ojRhpAkUjUEqWhE4vXtc4gnNufyAX7EAKdQiHFGiIAgcnf7Tebh\n", + "KTkmsnAc3T0XKjMYDSkhcmEUkalE/KK56a9Q5w/Bf9WheTqd+Omf/ml+53d+h9VqxS/90i/xa7/2\n", + "awD86q/+Kr/yK7/CH/7hH/6Tv1f8M5ilGucwqLJhXgJSVoxULIXZnwgxMs47Rn9A5IJoBFYKrOpo\n", + "9AUla5Jy+HikGQwlJ4zUGFVpLjELvJ84TntciVhf2GyvaTuDygqjNFIolLlgaJ9wf5gpeaKQ0BKi\n", + "jPicKSrSNnc04pKuu6YdOuSomV4/4L1jv7xEiRmp1hQSF72GkBBSMPuCy4IiMzEsRE40/r5GqmbF\n", + "oK+5uthyFw+IfCLnBiE6rOm5WN/AKfCwu0UJwaShT4XMVNWj/sjD8ZZtepvt+lNArZBerD+DfnfN\n", + "N/7xbzkd9vSPFG3XYVtFGwZkuWP2gbDEimqTkte3LwnsWPIDxobqZVlBn0ut1eWIEoWUFX4JFH0i\n", + "qAUtH2E4ouWKxqzISXF4ONK1HfM48Y/jN1BKEkLNOA7DQD/03O3uiTHR9xd47xjHIymW6q0uha7v\n", + "OR12lcK/2WJajVsqjs1acz5AyzlHCU1T42TadmhdAc/GtpWsriD4hGpqx9jljJCSMHtcEEgRUUbS\n", + "2aoqISWCd6hGUHRD3/QIUcHSylq6bgC3MM6vMUWhbIekxTkwZ/p7CpZiAinX5Y5pC877c44XbGvr\n", + "QqoURM4IUkUgCkW7ucaFgC6JTINIB3KYEHKgytUGlFmT7j9EHl6T+h55ec3b/+EDPvzPf0mW9T30\n", + "jRdfZ4wTRXo+fLbQiQaXAofTARc9UkuESNhVwQSNVBaihCxQtuaJBRKp2krRChmlIlLOWKGZ/TdJ\n", + "cVUXSrrGvJacOYXEXARzkYRcMEiKqu0+qUvt9KuEVpLcSGZZKusgBMZZMB4i4+hZXCb4ephmW+f7\n", + "wibSmVOaReRwuEOkiU27JkYoUWKCIMflHMWK+HBifviIlBNKZrTOKFtvCaWJpHi2N+RMYw1Jefru\n", + "X7k9DyHwUz/1U/z8z/88P/mTPwnA48eP3/z6L/7iL/LjP/7jALzzzjt89NFHb37t448/5p133vkn\n", + "v+5/+Z/+/kxoVty8teHybUuKmcU79uMB5wOH/S3eLbRGMS+JqDyLFqykp2kC2mRC9PgY0CgKgZjP\n", + "V/GcKRJO055AJkuDcQeU3JBKwrYDOTlKVhjb0OgLpjlgZQ26mk4QvScUj0gBGwXGfpqhu8Z018wh\n", + "8PGzr1AIuHjEWoW2mnlyaJ2Q79/8sAAAIABJREFUWlFK3WA7F9A6EOKBdB9ZNY8QZUHogKKwGjqS\n", + "DxSxME0FpSqceD0MjPM9u+MrtG6YXKaxEOJCjgHvPR8/+wrLTeDJ9feizUAShmb9Fk8/2/HhP/5X\n", + "9tPI6skVUjWo0lBCIXldFx8CSpbEUAizplvdMIdbpAjIRtFdaeJSmGeFNgNaX2MLZH9PbAIxHxFR\n", + "I1WHDoH5NLLpB4KvxCI7rJFS0RlDTInt1TW73Y5h0Ogz3m3dN9w/3LHuVmy3W3IOKKVYbS5Amjdv\n", + "vNM4s12tOE1HrG3Z7SaGtUBpzeLmKoQ7Pw1qrVmcxzYNIThs31XVcvJvspdNq4gxMR5nZMzAiuAr\n", + "EFcpW+G2UnI6nehaSzM0zKfT+f+rp5iEP3n6tkWYpi5nlqX+mecWUUqVFamVRtrqPEIpUlS0bUvX\n", + "dRUknQRlWtC2JwuDac5z2W4LpiPsvokpGdVsyCkjRQM3nyGPr1DffAGtojOC7/v89/K//M3/yn48\n", + "sJ/uSCS6wfIwP/BqzggMi3cou0HKUkc4rcVgKElA0JAkWRZEydim5leDK6QQiaoQVaAQSbZCkqNo\n", + "WChY1ZEIeLHgviUIjImYqjCuINFZo4yg6zLyXPcURZC9AxJ+VJyOiekUWXzVGIuUEHhsX53uPhRC\n", + "dCTVEMicyozKLQVFzJVQZa0iJJDKkDxM4YQ6j6W6tUXiybISx6IUuCXx7Bsn7l7cncE16l9+aJZS\n", + "+IVf+AXef/99fvmXf/nNzz9//py33noLgD/7sz/j+77v+wD4iZ/4CX7u536OL33pS3zyySd87Wtf\n", + "44d/+If/ya/9H//TBdoMIAzRC5YyIZC4ZWK3f4VLidP4gJERYwaQmhgLlMQpnghiRpZEKgkfDEZ2\n", + "CJmxskMKgVD1G92te+bjHdnMFAwpC5Q2zEtAm4aSJBrNevUIqzuaMjL7W0optZonagth8iNZjBhj\n", + "sKbn8fXnuL3/iHk+IpVCSiAJ/OJIOoCqylZRIrJJYBw6K0JY+Prz/4bWF2i1QPEY0RKyJ+WZpjEg\n", + "fKWzF8WFvWI8LpymhRAKMcqza71qZmMuPHv5dVJWvPP4u1D2hhI1Gcv25m1mvyOETG4ljeggW6L3\n", + "xGgYQ8SoHtE0ZG/IrmBMyywmRPFoCbLJaKno+2s60dPrDi8Fc/gYKffEPKBLICRXXeUkxnlEK8ug\n", + "NSllUilst1v+/u+/xv/wwX/if/vf/5qbx49oGsXXP/wqQiQutluM0qjGsj/sePzkKePphDEaHzJN\n", + "P+BToghJpLDaXOCWTN8LSnFI+a12jSblTNf3eOfQ2iCVQWtbI0kxYVqLDxkpC7KVtEaxe3jgYrth\n", + "ihGEZokZOZ1q9p+M8yNWGkpJBDKt7VndXNdyQdOQUgaqpiPlREn10Dge9nSdRat6GwolYDVkXfCh\n", + "epKQVG6mkYgYEcaC6Wq0SWqay7eJ+2fkIjFdS+aeUnpUs8V3B+bXn5BVYcyF9XbL48sbnt89I4hY\n", + "87O6oGxLTj2rvqM1LcZKpCq0rcboqu31k4JiaTtbCejLA94fmVnwpTCeIsUrsA4ZJ3Tj6Lp3adUF\n", + "OUHy4P2eafIsLlTsosi0ItF1DcZUkHbbdKTkKdmjlCVlT05VCZzzWe1LzQbbRqI0lXrkoWk6vPPc\n", + "LxNWSfrekohIlcgxsyQFyPqEGjOpVKhKCrXEMC9zfZ+KQpGZOUNA8vZ3XfDZ/whXqwFjFV/+H//h\n", + "X3ZofvnLX+aP//iP+f7v/34++OADAH7jN36DP/mTP+Fv/uZvEELw2c9+lj/4gz8A4P333+dnfuZn\n", + "eP/999Fa8/u///v/7PX8cHqgazyStnqJiyXnzBxOPBzu8b6a49Z2i25XhOgJYkHkiBSRJXiS32FV\n", + "T/ISZMQaSaIQ0gzFUHTLoK7IMjK6Awy26jCo/VifJTFmerNiMFcQJSVJlPUUuWBkZSDGVMgyszu+\n", + "5mb7HeTsaDq4ur7k2e0BXQSkSoHx0TN0kjALSiORsqX42oM2dmBynslNMM5YLek6Q87pjLwCY2oF\n", + "MJfIsLpg1fXEdebFq5fs9vckqVFaVeZhiAjVo2Th7uFjUg68dfk5OvUIUsCIguk2XF3cYGzDqZko\n", + "paOkhCaz+MDt/YG+axGy8iBLzmRhEDoQpcen/4O5N9mRJMvS9L47i4gOZu4WHkNmZHcVGgTZbIAg\n", + "9/UC9Ur5cmyuueGAZhWrKueIyPDJzHQSufPh4mpGc0EmF6xGpgKxCSDcAm6qovee8//fl8EEcHdb\n", + "oLQRwEYwtoMWWi2IKijlOa0r5EY4WJ6fX9jvd4Qw8f33P/DNN1/xL7/6B5wZtbrf/+636F55evyC\n", + "KUykkoiXiHOO82l4eHrvtDr6zxWF9YOwn9KfKDhlPPy0AVWJMRKCxyjLFAxVOmhNR4+5dqpM00KT\n", + "RK6J4+MjedvItbHFhJsCKW7Mflyha9koKJYlEHNEofB+wqBBm6ESL2UE3YWfuJzr7UzcVnRXPF+e\n", + "cd4w+YD3E7pXVM20nPACm9Ys+wfcvEBwo5LYG6bcEKVR2qN3T7TbiaYKegoYSSgtuG++5eVy5nb5\n", + "RHKKj+cX3p+eMc6B8ij1pwi6IriF4A+j666G/91Zj7dCr4ZpWjDaUWrGs2daPGcacdvopSC90BGq\n", + "BUO8q6UjvTukz6TYiWtmjYlbTIAaGpHeQBvspLDOYpRgldAESu3kMmJjIhWrh2TOK8+Wr2g/44Oj\n", + "d0gxD0RkNqzrOGA0SXTRzCEgTci5YJpDzDQQcn3g6FQVaImWhZsWrlbTZLy37U4IobMsBh3+v3Oa\n", + "f/ah+Xd/93c/gWH/76+///u//3/9b375y1/yy1/+8s/+UBj94TWfca7RdUfZPVPY0ZtmXdOgU5fG\n", + "tz/7D5SWOMcLyDO5faZTQBlogRiBJkODII7dsqO3kb0z2iJFcVy+YL87spUTWxQeDwGjZ2IWrLe0\n", + "BkuYmMKe9y8nagXXDeLiiGMoj9SNy/ojn86/Yjd9Te0NbMM6sDRaavTqUf1AXDOKMOaAknC8xbUZ\n", + "b2ZYAiU1aio4PRzXa7xhnFB1Q9kNq4VcGofDAY1i8hM/00/E9XXwIIvCujD84UaYvMd5TS03vnv/\n", + "jxz3X7OoPUYV/Lzjq6dvyaWx7TNbbKOrrAf8tbfKx+dnphmmaYjbylapJmG9Gg9lo7nF75kWsGqi\n", + "S7yfrByT93QanUatCaMZyYIyZoctJ7aSsNrivef50yeOx4Xv//D9eKMz/j/WbeNhmpA70GNZFkQG\n", + "kLjc2YcpJXbzQmmVNSWO+x3WG0KraGNxrt/9Phq/hCHOy4mmDH6aUDagm6F0jbYW74XaKq11LuvG\n", + "ljPv3r3BaMvlcsW54aWfpkAscq+0Dr1DrfXuENIoLeQUWXYHBMXL8zMljQ/eut0GacvNpLjS04aU\n", + "GakJ3x4IfiFMmVJWbB71T6MPEA7UeMVsK6IEtV9wDwd6LdTSMLpBE1CKL56+5uX0mc/PF7ZaWePG\n", + "tm5k08fpTndy6TQuI6tsPbkrdHXEJOwmhcjQPEwTYxstg7+QbhVaweiK6hX63TSqG0pXGmdiHeSt\n", + "XMqgcNVKz5mm1MjQWs1OHCg3oN3ajB5+2oh5wLp7qzjlRvtIKczkqBIQGf1w6dBqZ70lau3EaMip\n", + "4/w8yg73IH7NQ7ehlEFLH5BzaYgRck5ENKkKa804r9k9OoKFJSh2wdFaQ1r9s8+uvxwazjnS1kg9\n", + "YnxAKBSdudyeqTXhvCXXCBicmXncdVo7U7chdO8yqDG9empLBHugZ6EmjVaanM8Y0zFuR68BRWPv\n", + "h7K2l46yDW8tpVWsbeRypslGqRu39YRvCj9BZ/ws6xXNVT68fsebQ6MVR+sJa0H1hCh/Z2R6qqgB\n", + "WK0VVEMrQ6qdXirajV+msyMEj3SkN1rLoDOVCIyt7JY7x/ln0AXvK7/4m6+haT5+PHNLV7putAKH\n", + "3cRiPF51bmnlu+//Tx7nRxYd+PnjE856ch4PumYTfVfQSeMFUBrnMqfzZ7raY6XR0PTKuAFg8NOM\n", + "85q1vqfVTlkFPwV200RRrzg9I8rRm6XVisWQ8joUtL0R48qbp2/44YcfmCfH6XRGKQaiy4wrdVdw\n", + "Pg/n0G635/X1xJdffjWsj6fCNM+gFMoYKH0YI5WltIZYO/r3yoMa1BqAJh3nApZBaRdtcEGjtSPX\n", + "BsqwxZUUE8q6oQ+uMiAgOpJK5jDPpFqZlpnSMlPwo0mj9D1/fIfzKsWnjx8J0+CZbnFFeufh+EiK\n", + "ka7g+PSEFY2x5u52H7cKYYTzbcp4PyNxRT407ONEV51WNkzuML9BGY1uGz1HdBXaNfHx40fEzuS2\n", + "8Xx5j5squ92euD4TbxFo1N7RVHK6jat4y+RcoQq73TCCauUIITD7iUU5ZgsiJ/SdhRlQZMbcV1VH\n", + "T5XSLoia6WLvDSM9AOJNUAq6btTauW0rNozigWqVmjI5CekOTdm2lV1YkO4IxqCU5rAciCXS2jDK\n", + "tDb+yalTSkcpjXSLRsi5k3sbC0Pt8C4xW1i8wUil2g1RmtOlccvj2h72GvyKd37YTdNoJ7X8V4qG\n", + "c2FHrhfAUnrGGs/pdObhcCOnip8VKZ1wxtEqxL6CgmnxQ78rHdXGcBelqNmA7dziCe/f0rumcyNY\n", + "cO5Aip7SE95CSRWhIDqPq5WFLV5ptbKmZ863Z3ZlnGSV7gPApRQ9Cj5ETrf3g7zeN4RBnDEujU1c\n", + "H5zEIh1rhFYrNXYOh4mSIg5Hr3chFgOH1824iqzxmUwgeINqhnW7UQ8Nz8x+djzME7vpHYf9O/7w\n", + "4+9pl2eul/Gh/+L4gBVFsAe28+/59OkHvnr6hiadmCOlFc7XDzhT8AcLixpX3tzwzbDfPxKmHdIL\n", + "pDNUQy0a/7CgWNjNe1p+5fPtA7k70mU8mGpfCbawVw5pFmMMPXd6r9SsaGosdq7nC252XC8bxhiW\n", + "ZRhInQtsMfP09oHT+YXH4wMxRnIuOO/ZSqcINEA7RxVBOTs6/jLc7uDoArl1nBvE/lwaunQwmi4G\n", + "Zx3KeLQzpFTv4xAhpcYWV7a4skx+LKrmiS7g7IDS7uaZUitGxod88iOS0nsfriYUSltSSnz3u9/w\n", + "b//Nv+Hrr3/Bjz/+BnTjiy+/wpiRJHHO470bD5SaENXJvTPZUVtsqaD8DTm9EqNhevcNHWiXFeff\n", + "gJkGV1QXsELKkefXD7zPGZlHfXQrG4kbpd7G+7s7QJN6YgrDytNrQVqktsjrueOdwXrNLVVs1zz6\n", + "Pcl5TBgYD20K2gjkgbpDOYIa8jltB8XeaI3TI2/s7EZXI+erlIx54zZKJaWPU3LrkLeC6IW0NqR0\n", + "Jit4Y/B6HC4SlpJBRKGVxehxeh6KZ+550/GQa02Ry8C8Od2Z95rFrrQ7sT/eOi0Pm6qbFNoPepNS\n", + "jVYNRSlqG4zOP/f6yz005wesFIx19GqpqXLcHXF2QmvL+faZ18v3iOlM7BFtx8JFZjQe4xV0oVHJ\n", + "pfJ6+xGjHtArHB8LQWucsmxboZYXlHioig0hx4gJjU6lScHaDe8CMa+IGTf/2iupjCFyF0XXCgPk\n", + "2NCS0Hp8AJZpJsWI6Z3gFKVrRDtKL3Qaxnms7uSWsQooFYWjNQH00AAohTUeJzPxDFkrdodHLrcb\n", + "f3z/ax53C99+845vvvwFD8cHHrQhTI7+u8Yy7yFXelcYP0LM+/2BXDK5V9a0cr48U6VzXj8RwsDR\n", + "YRgf5GaQ5Hk8vkOapddE0itdPL2AlQVd9uSbY3ZPvNnt+fj8StwivSd2e0tbMsZEFAmn92ith7iu\n", + "Fba0sVv2LHs9xFutsBzH0qd0CH5mmie2uDJNM1uM9AYPj2/oSpFKHw+TpihlXL+rVGwIpFrR2jNN\n", + "y/jyFI3xI8NrrMXNilbBGwvaYZyn3Te71lpyznf1wn+mqJ/Pr6ScefPmDet2pbdBRSqxsJs1LXWs\n", + "1njrEOnEmO5kp8jkA61XfvzhD3z19dd8/fW/BaUQ1bB+GuZJ7bHOjcC+M7h5ZpoPzMsB4xe6UpSU\n", + "MRpsTNRPH3GPj8jjI42CloluHmii6Ndn5nnP8eGJf/iX/4Xn93/EmsZuObClMyEkSsuk7LDG4OyE\n", + "NdPYWDNcVUggpzxywKKwNhCmGcGSRWFhLGiUGspd5ehFE28VoxacdWA9AjQp0CsKIdgwyFqzwnlF\n", + "CBZnFBpNbR26RpthfC250prmst3wjzO5dRA9mBK6k1MdOc5eB63egg8WYwVQ1NIHPakWcrYEzVh0\n", + "6UZxnRwza4VbKSQq1iumxRB8I3hP742YKq1rRCzS/0rJ7U077HRAq8zsZ3KvfPH0JUYpemsEtZDi\n", + "iDCINzgmnA/jgxRP6K6xxg0Ule4om1jjCxpDv67sl4XQdhgZbMRa4sig94G50tqOrZwSWjszzxb6\n", + "gJlao+mtUbvQRaFUgDpIKVcK5tHjvdC7EPzEbgqslwgWKp6qHOZ+klB6DMOnMLGbZ/J25XrbqAXQ\n", + "4CaLNwatpmGvrBOaPb3N+DlRz3/g9eVHlnnisMAXTzPHnceiua4nvn//gd2bA1MIeOOJsWDCwu4h\n", + "Yr0CW7mtz3QVWKYv2C2vxPiKnxpOCcaD2x/Z72YkG3pxpO2EC4qmDfEcMfOMrgYzWVrzLDaQ1Hu2\n", + "mDFGoRVUK2O2qTu9ji53b8PvPc0T5+sz1gbmeRlRkA5Ke9Y18fbpie+++z273Z7gw4gN+YnaNKVW\n", + "pAqIHle02rDmDnVBsN4Nin8D6zytgzaGLg1hxMmUsQgWZfRYggUFfcBMjDFsqRKWHefbjTVVpt2R\n", + "VDo1VXoflUolQtwi1mpKE7yFECZqrVwul9GDr5Wf/+xnbJcTeUtMjxPGegwd0YpcK34ariitNdOy\n", + "sBwextbfW3Iu2DCuyD2X4QxPJ9qm0buvIK6IrKjpAWccEma4PuOsHeOTlyHY29k95vgLrK4oc+GG\n", + "vs8y1RgnyZ3VgB32RV3Gybffb0DaAoGtZShCVwXNAMH0IujukdIpq8YuC10P1GGTQuuDNWrQGK2w\n", + "QQiTxShwWg0zwjTTBbw2gGeLK70m1nPldo4sy4GR+7MjXqXymG0CzgXmec962+hSaE1Ri7q/N6A3\n", + "OwDINlH1MGLm0jldOtdN0Yxi2WvCzjCFjrSVpjS1C6VYtBrM0z/3+os9NL01IybCkLYb78nlxtOb\n", + "J2rtvNxWbudMmAWxYCeHtjOmG87xhC6FyVdSLpSc7g8gAx3QFTGKTEGVTFegzPAblwI1Czlf6G1g\n", + "uIy1XM8JEzKVhhaNsY6qBK8ciKPrQhXF7RLZamKeZp6O45erDBwf91AOqIcnfHjAqMp1e+b19oHZ\n", + "WeZ5D01hQmC73bBuIlcNbUCN7WzQCLrPTPOX5GLGKfSp88fTBekG3SeoAas9wWfeHB95ef2MOGGa\n", + "lhFGVgWdGn7nx5zPlLH0SRXfHYfpW9bbRr6dmQ8TlEzVnVITxnhs6zwePJodtyKct8TL64nZK9Z5\n", + "YvIPtCYs08PgErYMd2+Rc6M4UHXGKk0Feol8+nBBgKevfkbDoMxCmAMvrx/52Zff8sfvfxwZRm3I\n", + "tXE47FDGjkhVjHhn0UrTWiN4R64VY8CacdtQxlJKxPtxTUYrSgXrJ1BmnOzU2FDlPh4Qt22jtE5p\n", + "DWUMcbuODnwFby3r7QXJmeAceS2INJyC2jKZxGwDKY/TNL1St/HFPNnA49OXAzCtRpyJOzfT0Gjr\n", + "mZRvzPsdLQpFG4yzFOn4w5ekmKjbjWl3pNsZky60mJDtgvIzkm/0P/4fyPQWezgSVeX5dEW2yHZ+\n", + "ZuszyI5gF477RJPfoXpDZKG1hrIRo4/oCns9+KpbHtdcYxzWTDg3k5uQG7QtA4nJzxirsLqC9ohq\n", + "9GLp2YMYel6RlqhS0V2wJqKsYl48ypQxRtEapRxzWDBGEawd1U06JVWMM1y3zjxZSnPM3bHYTm6G\n", + "VjOTdxg9YZVn3h8oNVLbSk2dLoUUy1j+6jHbzkAqmetFOJ8FUY6wWNwsuKlgXMegKUnIfWhzQCH1\n", + "r3QRVMuYWcl9EaKsofTMNV6IceNyW3HGs5sDSge8d7QeUUoI1nHdMrSh37TGIaqhpTPUW42crmjt\n", + "ccphfECJHpY8IxQjGDvRkqGXQkp1IPprGTESA62PbzZlBO80UjRvDm/4+Td/wzTNaNOhCS7c56yS\n", + "CW7iyy//luPxC2JK/PDjd/z695bz6zM5rkNI3zqajh3GdHppJKlYZfF+wYig1Mpu9wWxJKbgOe7e\n", + "4MzMPL/BqB1KAjnf0JQRo7gHko0CXeH48AUprShVqHWj1Igxuzv4WKAaugTWYlmCR+lGca8UmQkd\n", + "5skxhwdCE6pe2eKVz6eVfRHK3FHWoy1oGT5yuqL3CREH2qJ0RekRwSmlUGseDvNcUaaBqvzmt9/x\n", + "9ddf8v2P3yO9sdsvtD4WI85P1NrxbnjBrXMIf4IVN2rNlNrorbHMCwc/0dCIchjr7wWHgFJ37FkT\n", + "nNOU2n6KBLUO1gZqPQGG2mC7nam1st1WbrcTuzCBGsQkWsHcDZGX9IL0whfv3nF6fcEpNUAtkwY9\n", + "tM3T5H/qthszTl0io0NfSqVfV3aPM6Y3jAo4/wjdMC2PbJfPlFJwfqHPCsoNtZ3BHVDLzxHZ8/rb\n", + "f+bzP/2KLob3z594//KRy/VK1lCbsJ92NBzWO7y6Djd69KMFZzqiLcoY9kbBmtniddy+zKid9ju0\n", + "ptQ6NLeto5qMLyUzbk/WTAiW1jNZVaQP06OdBR9G5dlODu0sCk+lI6rjvGM3Hwhu4eHBYtUHav6B\n", + "OAvbrZJLRuvx+xoUiEapBW0NIQSkWqyxOGu4rnc9R+1IuzvWReiiSWVcu1MeYBcfNPvZsgudyXno\n", + "id4b/Z55blJxZsb8P6ckf3r9xR6aqEbv+k6zHkT2qi2xVEobG7XD4ZFlDihrgKFBqG3FOo3JhpQv\n", + "aGtwRmGdoPR9Y9ehtYj60/bUGIKdgAPbdiXnQi1C8w6p4HKjI6R+oUqixEIIO6Rrbr1QneLt48x/\n", + "8/P/jv/2v/rv+dt/9wuss3x+/cQ1PpPWG26C3DYel4nDMiRlwU5oNLftihFFr6NO6Ztl9o4sjIhI\n", + "S3gtaDK+Grb0wu6gueULVW20vBEOD2htqbXT+9hSeiyLm/l4u3G2it20sJsfUXpmtzRKfSG3C7E+\n", + "Y00DL+g0FCG+30+F10pvmcYNqxWeEcTWdOadZ+qOx/7AWRviekE0zIZBylEdqZ0wz9AV0tSoymmL\n", + "2HFV6q3B/YPY7vnQ3333K969/YLT+cJ6O/P27RPazcQ1sd/vRyiZP+Udb0zOUWvBe8/1dkKAdU1Y\n", + "a6ldc7psKAWld4K1pNvoVrfWMcbSu6I1iDGN8Hkbm9dSCqVUSmlsa+Xz51e+eHrL6XxBpDIdJ3JJ\n", + "tBJx0ri2+1IoR1pd2S2evN3AGLzzlJqZd/4u7ZL7hl3d7aCjWitWMc07nLdjsWEsYhyXFAl0gvP4\n", + "p7e06wv9uiIHg1kOSK9Qb4h/pO++4vHbyH/6n/4j//M//AO4M9fyabjLS6HWQGlXOpW1FppdmafG\n", + "pHf0OqEoI73RHEV7Ql0oNaOVQ0RRW6U3RS2ZnDPoERa3SmGNJUxDhWH0WDDltpFawWiYZo/tA+Tr\n", + "gkWcR9shPs850aVj3MTh+MTXX/wtzhx4c3jl4fBb/ln+kZM54e2Edp4snZYiXYReKjFtLOENKEMf\n", + "uGqUsrSqqVkjgOl2JDNEaNVy2xqpNFxwhAm8TUx3m2vpnVo11niyFrRMd57vX+tJ8543g3ESUDSc\n", + "TOymhWI1XZ/RZUQPVFekkjFW44Nj1jOtVXJ2pH5jbQUjDi0aZw2iG14rrC4oveLtxG5+xNsdwS18\n", + "ev4j1gveeFp1EAYo0xZDa4WrnEl5xbCguyG2xBY91li8cjg14MfGgHeelQvX15WYIzVr1tS5rJ0f\n", + "33/m5flCiiCt0krDNs1kNK00tm1lNUJxYL0ltYoWg2qZ6+U7KkLqCS3C7fXEef+CF4NSAa+F/fSW\n", + "4+HKy7aybitKK7x9Ox6cCJITKT4jurGVThNDVxvzPmAy2KbpzpPFjLiWFk66U0xlaZGpFh72Dqsb\n", + "1u3YLkJON6Rluil4v0PUoJ13pWm609Wg46AVojaUcfTcsZOllcjlU8SGiV4759OGsZqUG751nBrz\n", + "59UnShdyrSNTWBtNIEwzCkstiVoax/0D223FOYc2lnkaCgWFvnfSp3GyZhgpY4zj/dY7Ip31toIo\n", + "Ut643D5hnaVLG9AMXbhdr5S0oiXzeDxyO50IZNbrhcl8wac/vh/2yZTYHT26O2LMLMtEznXUaMVj\n", + "TP+JdQB2RKMYlUJjA8YEWi2ktdJaY3n7Du0P6ByRpun+3gGvAv0MeofeP/Hv/uv/wD/+8Hv+99/+\n", + "r3T9ylpWzmuhiUVrR2/Cml75+tsvMbqgJkWJjV4r8IQyDqOuuOZweQHGKFHQxBKJWyKWfJf5VbzX\n", + "xNqY50GfN3ocerZSSWnkenEW43fYZcb53d0h3qk1oSTj3XDDa7ND2z1xSxhr2M3HMfOvt3Ejkk6p\n", + "ZXiU0jCBSm9czs/jBN7Htr60ipLhgNfOYK3+aVufa6InBW0sjp3rBBfAdjQNozphGl+qR5ko3dGK\n", + "DMHjn3n95cjtMeKMwWlzr7Q5THBcrxvWCloguPHQjPFGLBFRsLSZMGkOuz2rrtS1UHulS0fLoHJ7\n", + "C0YYw3Rf0KZx2O+w6oA2ls+nD6y3V5x2KNnRdUfj8GomxYbRltpGONvooQF4eb3yL7/5Nc7suNTz\n", + "YFheTpQ2rI3X24mPn36NcQarAqfXxIfPn1jjlWXeMS8LSsCUglUDRnBrmdjHA0Gb4ZZWtfHghg8n\n", + "aQVdY5ipW+Ny+gy9UfQjXz88sMw7nt58yefXZ9Z6GVGq3WBySu+kaqmtoVoD8dTSaH34fIqqdDO+\n", + "YLRW6BAQZcapq8hgN3ZB3bONvloyDjfNKKkUqdC2QQdqCuM0hULFI8oiUmm9jTZPH4AQcR1piilM\n", + "nE4nhi3MQlfUNmZZ27Z0IWaHAAAgAElEQVSCunC+3vjyqy8HWehyuecazXCPp8w8zeMa1vv9RDkY\n", + "q3/qfY8H47h55DtV9k9+oD/9meODmVm3G406tueXC4/7Hb0UtFbUtOGdovaK0JA2ImatVopsTPt3\n", + "aFHEuKHNTMuRVQYF3ShFanVwWY1Fa03YLfhl5rBMVKNBGroLc5gpKaNrpX7+hFkmZHa02pCcUfMC\n", + "0zRoTXpDWmc7XxBG8uLj68aWO7dYQFdyuRG3wldf/pyD/hanT5jpwq2/0kxFyQL9LVrNGNMIYYgO\n", + "u3RqKZSSiDWTa4bcyCkO17sx1NbYz46mGr0X8jWTSqJUUPPCPFs6boxQSgUKva1UOZNLosY9f/yY\n", + "sbYT7ESqhZg/YU3n4XHHFjWtCm6294fb2LTnpEgp3rfcBqPGOMRqS1EdxThl1gopCzEVchLGokMw\n", + "xoy6pWWAebzGO0tKZahpRLHWjub/R/f8v+RLaATXMKJHBrI0UhqnhtIyOZ7Hxls7YnolVzWO5a2j\n", + "ZMZO4M3E5CP5ehuqXOtxXY9YRs3k3FhvV3IJPB5W/LKH0jG2UdXr+FbtZ6RbSt9jJQyStnJoBUYH\n", + "gnN4O1F741e/+z3/8uvfop3CTJa3bx55+/gFh4eFUjZu6UapFxwzt9fGLV2xFtAZBSxhRk0GKYmq\n", + "wfSArgUboDFmf32r7H1gsYbJeow2bDKheuLy+n5kG6eJNh/wy8Rxf+Srh3f87v2FRiTnlZjPKJ1p\n", + "94pbqwktBZqjlkpKEe9nuvVIzdA6k3M0IJhAAbZWKWvG+U4XQ1MNZcrY9IuhlkypeXTnjUc14ZZH\n", + "TW5nFE4pHGNAPyJIldzbnULUiDFhrCOlzPLwSO+dDx8/cpwWvv/+B6YwUVNhrRdu68rueMB7T9o2\n", + "1nXj8dEPsdm9315rxTlLrZVa68C2CVwul3tL6D9L1FobN5zWGtfrdbBhxRBzQovCu5lKxYVBUerS\n", + "cV4zLxZjLct0pPeKnSdaqWitkNp5ef0BxDDNHWsNlQGyLoB3jjBNxNsFowrOdMy0oEyFlkltVFKV\n", + "tlAvUAqiH4aTJwQqDTEOI4JeV+rrhfcfP/JyXVmvQ3O8RiGn0SyrTXg4vOXbL/6GhQmLIpYzWkew\n", + "ClUv9KwxZsFPE6WPnUAtFd0rVerQUqfR66dq1hgxdqGlMm6B2g2mahq3rOY6giJYj5Kx2LHGsPUT\n", + "XRVEbvSWSOtGjJ+J2zOPh2+Zw0RMCR8c662jVccEsPZuFVVQ+zCmClDzaGUhFSUdLaOiKqLQopEG\n", + "25pIqdA6GKNw3ozruW+IdcN57jRVMiP8L2wJtiRM4V+Jp/mv/XrwDm+5K2YH7TnmV0ryvHnzjsUu\n", + "fHx5z7a90EVRS2ErK7FmuiSWOjBbZWtQzAiktj4WI1XoVdOSI7WMtMQn/xn9zlNqQklCqzG3EN3o\n", + "oii1ULrDyILHD7ivVZjgUNoRBIyZuJzPnF5P5Jz58Mdn/v2/V0yuE/yOrA9svY9N/tzYK4NqwqQ0\n", + "Ttvx0DAWpgmsEFTAtoIymg4oZ8BXmgMdZoyzhFLoUpE64Llbu7HGV05x5th27O2ex8M7fnz5nmu6\n", + "cr2+J/jOYdlBqdjm0c3ff37lzfwWdQj46YAoxWU7QT4RtMEoD8ZyjYlSE5f1RpOCNhZtLDY4HIqq\n", + "QXV9l4BB64muNbk0ok4EPYbs0jXUBikNrQcOJZrb+TNu2pNTZtk90NPGrVSU0ny6vhBzxBrN9XIe\n", + "UZ6Scc5wBtZ1Gw/h2snlNnK0XVjcbniRRKi1Ms8zp9PpThsadcd1Xcfv/P7vtm37CaY99LqZ/f6I\n", + "UqM9Y5TCTWPkQ4M57BAl6DDes61Vcjoz+QnpQ5d8OX8ibpUw7/BuT9eakhPJW6TMWGvoTlNTHn/f\n", + "wRBbI5aRzQzeDjZlqZh2pXmHnhxmWmgNVG+U68avfvN7/uXD77muzzgdoAYkJWY3Y51BGcvXX33F\n", + "7BXOCVtq3HqmGcHYhFIXtHXjz1SeZV4oudDKqN5IbtAVGktPI9LVyoCj5MVwq1fmeWQca2koMQQL\n", + "SCSKRvWIlUJsbewhzNAvCwPZVrZGo9ELNCMcDo8oPJftB4xrhBCwviKS6EWhzUJOJ4yqgELJilEe\n", + "pQKixjiuGwNWUyWSa0VQ+ODYLZ1lhmmx5JagZkSpkW+WTKuOUgZYZkBF/krD7UErjO33DXojpk5O\n", + "K0/Hbzkub0Y2Us/84z9/pPU0HONKsa5XttuJh/2Mtm6ItupYAmQlOKOQqUEdgeheDFvLnP0ZZyeU\n", + "AtUnAoEQMjFnYumjx91nYAZG8K/lhBiPCWPp4Zzn7dMX7HY7Pn/8zHU7cT4/8+44MVuP6tC2Sjea\n", + "OczsbR3+6zxO0s1BkYauAaU0Ljgs4NQIuucOvSRQQlGB3BvKWqxvGNSY23hPlsI5XbmkA0fj2IWJ\n", + "p2XP6+U9qRRiFmb/DmeHL8mat7Si2amGNxPz/oANe2La8BfD5VO+iw06TRJIJOc0gt6pYIzCTIFv\n", + "3h7ZKU3SsJZOukW0K+zDI4ufccaNXnDPTK3fg933LwR1n5eJkOJGRzEvO9bbhWW3ENeV4+MT6/VG\n", + "SRG923G5XNhi4njYk2ImbgmlNdZYXs8npmkaWDPpdBG2OGAfXYSYEus2HrC993tVbxtvejvaO9fr\n", + "dWxjz40uHRTMywwyfN/r9cThuCdtEWc9pQhKM+qTrXK73FgOjmIq3i+4NjKWNVWomc4V5WdCCOS6\n", + "sW7Cw/ENohy1DR2LcTswBlVvpG3F6IllHgUBNOgp0BGUDVg90Z8/cPn0TDeGuml+/MMHrvUT3k/0\n", + "3tHGMoXAl199ibUORedlfeHDyw80fWJ61BxnTdcRpS/jRF4UGoc23Jd7g9Kkm8KJRoymls6YFiuk\n", + "CjoMK6RSo+mk7EgIaFvB3mjK0GrEOIULhclorJ6hCqUWrPd4Z0cypQbEafYPE08yE/OFsBS0SShR\n", + "pG3wPL9498DlFeJWUVSsHp8jcYJhFFCSLvRaUQaUUYRZERaNDZbSOp2OypbWG0oNpTBMA1NpwQTB\n", + "yl9pjTKtlZ11dFNH1hGN08JuXpCm6MoMC2QB5zyT9xgKOnVi6WyxjhwiHiWayc+4YEal0baBi5KG\n", + "t51eG6VuxHTCe4cRC0mz5YR1liUEeh6/TGTF6BmnNSlXIhFrHEoP4rbWGn98YFn2bNuFGk+DuRiO\n", + "HN0RffS83k9oIqAFnA3U7BBjcXbw/oy5S9qATsEog6pCkUpRnbMUVJNRF9SKZADdmQyUllm3C9tt\n", + "RvuFTEdC4OndA0k2QtBYC9buaWVUDKedQjEBit1hzIK6DJJU6wVVG8YplO5oE8FEzAQOIXiNdwnL\n", + "mf3uiK6VnDI9bbTkaaIJy8wuHPA6INlR9YZ1imneU5Wl5xNKN6RrvLVYI5R44+HNlwOWvD9wev1M\n", + "q4WWxxzw/YfPHI5HjBlX8E+fPvL27RuUh3LLPD48sm2RN28ef7pm7/f7n+aZOWeUUsQYUUpRSvmp\n", + "CTQ25xmRTrlHXJwbMaF1u6HkhlWBh+ndUHtojbYBoxXH/UJNkZYL/t6AyjlhreHx+ESO86gKqjbi\n", + "Odpg7Iy1HtEOUYppWTB+GsUBo5hbQ/WKiKaimINHMCjrUNOC6ICoQNeW//Trf+KfvnvPh/NHVKiU\n", + "tA3KlGkIwuPbr1h2A2Rx2VY+f3rPFiO4CQXcqmCnjHURzYLCIvThTxehlIpFERglDzEK5UHyIDz5\n", + "YO+Nm3FCV25kjMV2mlKUNFzsSnsmPEo6vYEOink/IfWBXBP0QpMzxweHkjL8RLPGBM9l/YEuheAe\n", + "SUVRu4yR3tKGQTIPp7xIRWlFMJZbzQgNpTpKKs4K1irknrm2MuwOufWfHvYuBJwarTyRAbBx/xrk\n", + "9v8Sr8slY50mALlVSjOkuPHp+Xt+9tWBVDJxPWHEsw/CbjI4q7FWeLlBRqOVZ/Ka2XtM0MyHHdZN\n", + "lL6RY2S9XkjxOnKIchotcbE03Jhn1PvpsFd6NuRN0ck4Y+5XuvEQli5o1dniRpiGqc8FP5iYhwOt\n", + "NXLqGDE8zE+05rhsz+Rshgb48RHvHI0Vra9YX5jDhG2jlXGTxDW+4MwdZ6bicDxrj9YzRjvcpoib\n", + "kGVDtcLna0QrxZvlgFiFXSbeHt9R6ooLmqZPoFa6CMbtKd2gdR2LktsLVTSnS+Ll8wtsDe7+GusL\n", + "k+3kVunsKJPGqJFr87OlGTC94k3BecV2U9xuK/UhY/WEXyaUHREQXTJKDwyc9g8joF4bQqO2cYUu\n", + "dR0qZxO4pjOldcJyIK15zKna6HbHkng5n3h4HPNPay1GG968eTMeinDPVJbh/aljoztNE9u2jb//\n", + "+wzTe8/lcgHgdrthZHhxlNbkFDE0nA5My3Fc+Vvnej3z+PCGuG2U3hEFT1++o1RBGYPVHWsUVluc\n", + "3yFaKDXfm2GVLiN/+vTuS3YPb5kPB9x8RIkaUI0uLPs9vRWMKFAB8QaMHZXHsg3FcRPCwxf8b//j\n", + "f+TD6df0vv6UQDjfVp7evmVZHEoUrQufP30iniKzHW2p2mHtiakr+pxYpkingezo3dK74Gj0ejeS\n", + "unGSVxoIgrEN6z27aUJJZasNVYcfyyuDVxaqJhfF5B26KrQH7S1NC0lFgrfsd/OoZPaVXIR5emB2\n", + "FpigVGb3htPpmddPL0gFbwIOi9WabhTNa0pTNO3YO4uqFacVVVtuUimM6qyzjl5GGqOYjLJg/HBK\n", + "WQPBarrKlNSJK/SiMGn+s8+uv9hD85oyNgq1e5oWam5oBc+ff6BmMyJJLWFlRffApCec7lQ3Yy3k\n", + "VkZ9TMHD5Jh3HrfMGLejmQNXdUX3Caf2bOmVLpFcL2jjKHQipyGtCgFTO11VttypWZhnB6JxRvDe\n", + "EoJlmhYutwvPn39ktxzY7WfmcP+Wlooylqo0cY14M1OjpfdACID2I3RdLsR6xkjENU+wTyixOCX4\n", + "vlH7GRcssx6dd288qAEi6C1S03nMlKqm4PlwvbDFA27aMQWDMeMq6MLQO9RUOKdniM/YkUYnpcSH\n", + "l5VShM5Mq56p7VmcxVhN5ca0CNYFzjdhuy1j6y6a2DSua4ybsF4xz4MzGvPGc7zidxkphtnNeCzW\n", + "avLWcfOE7ZaaEkKjtYa3Dq0UIo15suR4ozUZAj00r6+fefP2iefTK49vj2y3iDXjoTgAKQO48adT\n", + "Jff67Z9etZafTpatNZoxrNt2r9BqYtxYt43eCiOUNFpNKWXePS4/PTRKSdS8spv2aDXmluvtAtKo\n", + "1bBf9khrTLMHYbjCQxgErjLmarMfdkNrDfv9E8e3XxCWI9rsyLWjdb6XPDSH41ukVKp07HxAlnkU\n", + "BWIlv5747e/+wGVd+earb/nj8+85XzeMgRwLtXQeH49wd/Cs68Z2Lez9AUenqs5WM68fG8dumCWR\n", + "7DOTeUPTHtTQjKlJYaqm9ErpY9bX7VisFQ17Y9Cljk1+7WgpBKPwxuE6ZEbV1iuL3DZqhGYbehKy\n", + "1ci8koxBh4CzgbgmSnlh8gNUbO1QZtvDzzkaOH/8gVqFXtdxJnZHlt1Eah1FR0pEK1i8oxlBZ0XR\n", + "E7FU8pboRqFswYWCt5rJg7YN26HmSC2QN01ZHSp5YvsrnWkuy0KpkdZWRBqt2tHzlcTp9Y/3VH9F\n", + "W02siTU5fLPUPkK1qmpqVxhbocURTm+Cs+D6xBwCNMgxo9lTsuf0ciHvRlddazPcLzIUGZ17xMhW\n", + "ctpwdqIrPYbMYeC83rx5IuXILV9YX68s857DdGSZLR9Pn3BhgipjaeKF7bIyLTNh3mF04LJ+4PVy\n", + "5XROHObC23kiqJlqCwozlBRYTO/obuhVYa0Qe8HQ2DtN1oMGX8qAGcd8xeU9O79jWjy73YS3O1Sy\n", + "vJke+eoX/wPPn37g0/M/0dSVlBSXS6ErS+fGXsFxbsxmJpeCWGg1oq1nN+2gdza5QWtoNZHFIKWA\n", + "DYSjwklGutDymdf1PVZ/g4jgsfTOYCcC3LvD3rkxrG+dXjvzztFyRCvN3g2cW1pfCdPCbT3z8HCk\n", + "10pcL1glaKXotXF6eeXd0zukjzd4yRljx/Z8IN7+L+beJNby9Sz3+339v1nN3ru602EfFEMikygB\n", + "RYQBEkh0Uq5kGBnBFfKYKQMYMopspgyYRCA5ygRmWBlEYWAREUXhhoT45vrS2DH2aeqcOlW7W2v9\n", + "m6/N4F217atgBiAFtlQ6Vadqr1q191rv937v+zy/R+ZSOWdijJJ/DsQo4vbTaSKlRCuvt+2KkgtD\n", + "H/AuUHVjjgu6Zoy2BH9maDY4nQ5YGipYliYi/FaFx6qdRnmPswb9WhbVKn3XMwwD3f6CrBxUxXq6\n", + "5jid0CbThxHnAiUXnO9oztGspSkL2gMr3lhiyfy7v/33vLr/iN1uy5yP3J9uqWvhU+/8AJ3XeCNJ\n", + "qofjAWt6eV2WlVwSuSGw7MXhOk+ZC2VzQtuK6zp8UZxSIqtCMZpSC2luFF0fJEeuKGiVEhNaQQBs\n", + "p9G64XUvwG01YDLoWjktjdwSTWf6QdFSo6nCEg+0dqCzju3FwHYfGIeA9wNX4wZCY3GRwV4S14o1\n", + "A9vdFbYfhczeCnGdSYtEcMeUeHl7R06FORvm0jAm41wRQ4yz1FpIs0C8VYOSLGV2xFPDrB6ve0z7\n", + "Fyo5Gi4uuJuusSVTcgYiqIR1ipKKdHraURCR89204r0m58S0JqoRH3BSlpNu3N4vdMkS8oIxHQZD\n", + "w+K9YT5pWnLoOpIOBWUzxgaqWSmqkJJGK4PrpOdo1cDZ5ulMYwwabR3abPj0O45vf/gNTvPMy08+\n", + "5tRdc7l/BDTmm48opfHo4ilPn7zB0I90YeAHnn2GmDKn4w3r9E0Oh4lbNLf9S56MG0n266C6LfME\n", + "QWU2WiDGs8nMJEqKjE6jq8dr8G1hVZWsZiiau2Ml5Z6SC7p0XF5ese/fZdvt+KG3/yte3H6H//1r\n", + "/wN38TvEtWPJkRAayWmqkhmiAnJRJG2gVjoFbhzoQ89xOgrUYI6yVTUa4wyDC5AVLQTmNbLkGYMi\n", + "GI0xBqcDLWbmdcF7D61xup9wVok/fbqnlIzzHSVquu2Iao1x9DQUlxcDS0xoMn0X6F3P3emO0AXm\n", + "VYrjZr9jXVdcrcw5nzfZ0mEus6DoyrmY1lq5uXkFWoAqmgYt01plCAFn5Vq9HTa8evkhbz15yuHu\n", + "Fu+9pFI6KwuPWijrBGdKToyZYbCgNUZLOqf1DgUyp14X6Hqs1eJkKglrDa0mjtMdwfb0u0EWG95R\n", + "fcBUIc7raojHGz54/1u8uHvJ9f0Nz199R6j01uGc4eLiEfvdgLOVdV356KNbTktDI26XhmEtM80o\n", + "rOlIK8S5yb93XQkdWCNjmOg10SpUBEcilYpKGl9hcAaSjK600mSVcd5RKGjnKM2gtEWXgi6NnAo6\n", + "F+I6EXae0hzzqbKmzHyKrLFi9cLjRTS4p+0rri6u2A+DxHB0mkfjO/Rhiwt73GbABY0xhZRX5mXh\n", + "+vqOV6+uocHF5R4bNsS7W1TJdDtL7zpay6y5EY8rLTYohloN61xpc6bXjkELWMe2f6GSo87vOc6F\n", + "lQnlLOhMipmG+I21kZAsVQotruSaSfNJgsCq0JnXCjfHhbuT2KSmkOk3hW6IQnFO5iw9qEK9WSva\n", + "GVS15LWSqRjv0EY6unHTaFVRqmT9NB3RHu6mD3j2dEtJjS4MPL18i/fXvyPrwu31zHRcxdNeV1pT\n", + "XG7fIM6Wd978FLvNFbvxgike2fR7rNow9oabFwvHm8jBRC52HVePB/RgqRhul0obAiEYjAsiOM4z\n", + "sRS6rsc6y3T8BF2PaF0xulDaTC6NnC2n48J0es7gnvLOm/8xb1y+w5uPP8Wn3voM/8u/+R/52l//\n", + "T6yHzLp05OVE3xl6s2JdQNWOPEWWtkBXCFYxBCGK53Vlzo04SdTy2G/orKKpTDYGFTpaS5RUJJzL\n", + "K8iKkiJ96Mgpcjyd2O53jENHmheO04EudMSc2GxGXFBSdFpiv93TGUUsM2NQ1FpJ8Y68HNlueu5v\n", + "biT69h7iukrn2Bpd14MSmnoumRACy7JwOp1kZJAWjHXn5UcVmIZS4g8vgn5TJTEEz3S4ZV2OHA+e\n", + "0gqXF1tKOkEsOCu2Q60tznmWZaF3Fo1s2FVDiE3G0YwE/SkgpUVI8GEghJ6UhbS+2xUI4rVXm4GS\n", + "gWWlDoaM5q/fe59/+81/y4fX32SOJ2Ku1Kp548ljxrHSBUXOlVcvb3n+4hYY6IIccFrbM81HijUq\n", + "sy7SYaMbxhSMWUFl2R1o4W4qZTCjpy7g0QQaRlVKOkvrLChjMNbTqkXRYVPB1oqJCW01oRsIF5aq\n", + "K3OEnCPxpFiPjiVXmlnAXkNvqaFhjpW4WjZ+w0X3BGsD7ZxqmdSM0x4bBI49jFsuL57wxpuRTz65\n", + "44P33iOfPmG3UzzqL1FBYYphmRPrfOB0EzmdGjVFKJaaITToOovqAkJs/Bdqo2xoaB2d71AqiaTH\n", + "DOSUiFFyzp13GD0Ql0CtMh9bU6KzjjUlcVykTFpBH1Zs0PRzYdxXxsHTqohVU2nCUlSJuTRUajit\n", + "UFiWVLGuoh0YW9FaydDeKVQrhDFh9Mpx/ojBvcsyF7TSBNsR24q1lWUR4nethloa1+M9bz1+F3Lg\n", + "8cXbjJst6dUHaOUwvrAbetYJXnx4YIqRVhMXfWDjOprSLLVxN50Y7Z5td0FvLe34ipom5tbwLbDt\n", + "34DlFuc1zjlims/QAkVVmrQm/upvvoYLHeMw8uTqMS51/OCn/1OO80u+8d7XONwt5FQ5qsSuOxGM\n", + "p9Mb5iyzoLu0MnpLPwjBPaVEzYgcrCpS1phFlgepSIqn7y3OB4oxnEpCL5FRaZZlYl0Wrq6u8EZh\n", + "VAVvGVpHzZntdqTrN9Si0V7Thw5vDCUeCUSosjBap2uCNaTpnhYGTscD/bgTwIVzkrJpZCZean5g\n", + "Zq7ritYwTUe0aajqaOcgNHWeIUuMq0dTWOYDeZ2YVsl3WtdZ5ERF5qStlnOeU6WWgtGgqJS4QgjU\n", + "1rBKYYyhs4EWDEVDSoKHG1xgniM5icbXW3k+Xntq06jUoB9pcaHe3VLWirM90ymTJ0U+Serpo8db\n", + "hsFgHVRjubm/4eXdidOcqesEO4cxFutlCaRMwKoZYw25emocSWskuogPoFWl1RWnNZUKVRH8GdJR\n", + "FMYKvKPVJjBjqvhnlBZdrtISyZETxjZ8Z1EGtLKc0ip09amRbgQKgo0oV+l3FuMNWgeWKPpNoiYd\n", + "EyHMeKso9wsLM6YVhjGw216x3TwiBIczPU8eBTbDnqvbF1zfv6KUxnZ8QlpmDm3F5owK9zy1PT6c\n", + "YT7aYrRlMIqh6zDeiPyMr33f2vXPVjSXQ5acaWAcOqiZFCGlI8ZkrLayJOlGrNqIb7hvGOWpDaxL\n", + "6NZYlWexiXmeOR4jaVXUOlNzwzuDq1ZOKISEVFum1gIUNp1GNxF9l1ihNpoS2rc3UgAiE8503E8f\n", + "oLqOMnfkUtmNjzHW8uLlR5RpZp6gFYPWhu988G12+0uc2zDPE873rOuRu9PHXGz3krD5ZkeeE+tt\n", + "xVlHKRODGtHN8DJ51rjS2sowBDbhEp01Lz/5K7rtBp0qtTRGu+Oi30q6Yp44rkfmGJnyRMmam9MN\n", + "f/6X/yt3t/d89jM/gtUGSmO3fcKn3/407/Gc29uFqiprToS0oPyGzfiIQ4rUGkFV5uWeJTdKtTJL\n", + "MgmlBKRyiAttlYOk+gVdgKywxeMqhFY5pMJgPOPFSO87ghdyUErnRFDr6PoRb3qqnUgx4ozDqkxK\n", + "K51dUbaS80IrYgGc54zfVJTuuD0cqC1RDwJ12Y0b7m7vcd6xLKLNXBahlNf2mmozUUo9098tuSa8\n", + "s8AEGskncobpFMnLiYvNDmca03Tk8uIp0+GOmO7prCXHRFpnlAmyFFSNblOxbgfKsdTIfvMIrQ2+\n", + "GyjKcThNxHXC2kAXenRLaDxVWZQt4CTN0mNJS+Rb732b++PE1vf0xjP2yDLSyra7ZMf94cR8TFIc\n", + "tccGxKBhOoxR37Wdnu3LffDUmolFU6dCLQYQNia6Uo2makfTYABt5UqulML6RpY/TamKmjWqaZRr\n", + "oHvsRtN3VojwRnYRap5I8wlaxYxKlokjmJ2hHzWh02KAqA2Fx+pHBHeJtwMxRo7HE/Oc0UZzGg05\n", + "yt7j0m0Y+g3BJoIt9H7PW49/GENHa5ZaDCUq1rlQP6MYnKfzHdbJLTMYJ7Q0ax++Rv8N//33rV3/\n", + "fDrN5UDKB0kyZINqipxWpmmm1kjfR7p+g2pQq6LmLATnM3WaJqZ8ay0jSmJyqcSaSathNivFiqBW\n", + "a08fgszq2kyqCe00uMS2M5wmwzppdNbiG7YVYzPNOppuxBwxBF68eg/PHqU3NGkthIjtelaywGyD\n", + "wxnP+x98h9AN7LZbDtOR+/mG+9MNxq4EFeid5nK/55hmVFPo1jHHhc4lnqrK382J2Hl2/SX7/VNm\n", + "ZZluPySeJmaibHudx7nGZXB4N2JjYjsollMjtoK1ntPxjv/t//qf+Xff+Dc8urxku+mwNjP0I48f\n", + "PyWmV/i6iAf6rEft9Y43LwYOp48ZvCLnzBAMJxZaE37omgpzOUkKpEnknGk4ks4Y1VAtE7Qg+fph\n", + "wGW5dsv3fmWNM85ZpunEMIxst1tSLCynhbEfaeWEVoLlc26LNaI7NCVxfX9iXjPKG9CF0hyHw7Wk\n", + "AAw913c33NzdsRlH1nVBKc00HSlF5EhKyespJSEntZrpQ0cXNIOz9M5yf7pjnRZyylAq83xiWRrj\n", + "uKVEobXXgFCeBs2yLgzWA41lmmhV4ZTFKI33nhxXjA8YZzDGMyiDorEsq6Qvup7aCto7SmuoBr4k\n", + "yjzz8ccv+etvfIO//MZfcHf6gOYXHj/a0myhtcLpkFnTkVOurKVgvKMbPZTCdjcy9h2aSlJnVcbm\n", + "Cb4TbaZzmlgaWicutht6N2LoUCWgm8XQU2qmxInj/TUxLijl2G1HlIJ1Xak0tPUobfHdQN+PDIPH\n", + "aehCj7EdtSliTGwAOkkAACAASURBVCzTQorpLMTXkhHVa7qz80ocQw5dLVY5Oj/gnDBnVRNHkYxh\n", + "BDOnbMPj2bstu80gB+W8SsxMbnIo6gBFY7XHKY/ukSz6c0SH1eZBp9lqFiPJP/Dxz1Y0a5uxOhHr\n", + "wuE+sq6VFtND91nmhTxG5tmiULQzubupDMrRcOIjVwpbIZhG8g6jPSYvlAWqK6gQ0dbQSsIahx3E\n", + "RdR10A+KYB29hmM9Qlppi2KKhUV1pDUJ+aYWrK2ouhBLxthKwZNyQilN8IHSe5SeUUWu9sYUvvP8\n", + "Gyid2Q2PyO2e0+kTXIhol9G5YzAGtxnIqbImQZyVjcMY6Cx0fsvji0/x1tvv8ol5j+PL73B3WGml\n", + "cDyd6IY9YdMxnTLDtmfoCqWeaAFiabRS6XqHTolPPvkOH37473l8teGNN58w9I8IYcPVo0q8+wit\n", + "MzEfGDcDkQmtd2wv34R6i+saiix+9ZTJRlHNQqmFTEZViYNdzcIyZ2JJGBVQYQsEbINge2qTQ26Z\n", + "pGDe39+x3++5urrieDwynU6otjDsL7g93NNdPEYpS+i9CI9z47TO1GJI6Zq4HInNsKZMWTKzUjQt\n", + "9KKGQtXCmuUNmlI6R3CUhyXR667Ce8eTx5dsvaWlmZwnliXy6PFT4hSIy0Q7x15QIjku+H7EdgMt\n", + "ZVQteJSwJ5uj1gz1nrsScRaa3mJ1Y7vdcDzNlJZIVVB1ApJwaO0lgaCumM0jeY8c7rh+/oIPn3/M\n", + "x7c3nO6OaGcwwaNolFyIEab7RsmKYbNj8IrFNHQY6Hzgan/FdhiFSmQ8wXdsLzZ4L8mfKQudPtjA\n", + "dtyIy8p38r4IHVppUiwcTkfu7m5Zo5Cp+kFuRcu6cjyJv38cekLoCEG6Z9UUygguUJ0txXFZiSmz\n", + "pgWrDM7tGMeK7x1WG3I2olKgoXWjKY03Hd45tFYYbUFDbN+dR9faRGRfNUTD4EY5TG2hGTEtdGEg\n", + "GI9WiqLyg5Y3p4I6w1QAsO67P/8+H/9g0VyWhZ/6qZ9iXVdijPziL/4iX/ziF7m+vuaXf/mX+fa3\n", + "v827777LH/3RH3FxcQHAF7/4Rf7gD/4AYwy/+7u/y8///M//vY/dOw0hgKrEXEgZ5lJZcoECukLJ\n", + "M9oIfaUh80bJc3a05mhrJcUV7wLaefY7OUW07mlppuaIpkIR6VDJMj/a767w3jF0AdUiqEzIlVA8\n", + "g018eEicUqYUxTpHmd7rSeI1cqPxglgcnLfE/TBgfcVNQqxxvWPcdmz3T1iWlev7b1DLgVpWbIzM\n", + "rDwO9tz1OIKrtBJRduSYEl1o7DaOZ88e8/jxUy67C9buFlXAlkKrhUe7LcoM1KgZdltyitg+QKr0\n", + "pZDVyoSilBVrGvvNwP1d5MXHL6jMPH2c8DawsYWTs7RSqWVhmV+gxyfUXHHdTlIyucUYj9JwStco\n", + "Y3k0BjCa6bByHQ/MLROaENKXNRKsA2/Zb67O2DdNcJ51mUkl4rVmMw48unrGy0+eMy1HnLVc7SQG\n", + "dzNusVYWGN6LXY7acH3A24BWjpf396Qlsqwr83EFa7DBEueID4776YCwpBMgkFmQhVLOQjGy1nC1\n", + "v2IIA0ZlirHM94l+GIjrwnZ/xW1NqFow55woQ8W2iqmGaj01rSilKXVmTSuXF5fM00xL99xdZ+zj\n", + "T5PKQNMQOkHxURVGa3JKZ2dKh+o8ynmq38nz5IZP7u+4Oy08uXiM/6H/jGm5p5HwrsPajnlNxGfL\n", + "OQGhscaZXCpaeTb9hmEYHqyk47hjsxnZ9iPeiGhdW9n0O+dQSjosbRRd1xFCh3eeUhIXy8DlVjp3\n", + "5zzb7e7MACikuJJLpgudbNJzIedyDj0E5+SK77Ulzok1r2dDgqYbAn034jvRaFI0OS8ykz4nWirV\n", + "MEZUB9Y6ikIKcFwpJeGsoZ7/LmMUIcgSucnRiTL6HGanRaifG6Um1rgQ10gqAe8lu0lrJSO6f2zR\n", + "7LqOr371qwzDQM6Zn/zJn+TP/uzP+MpXvsLP/dzP8Zu/+Zv8zu/8Dl/60pf40pe+xNe//nX+8A//\n", + "kK9//et88MEH/OzP/ix/8zd/8/dW7poKYRsoNWK8JNNRZPifFsGKtdJoWUuIVMs4ozGl4QdLaxXj\n", + "DZhA5xzdxjNsAkoXKopaxE2tamNNEwUoxUFRWLOhZkvJCkVgXQpDq2gmLjaFu9g4LE10m6YHKrVF\n", + "lqXQsqbWTG0S8qOdQ3fgg8HZXmjqzvHG07f4of/ov8Bbz7fe/xbf/Luvs5wUoUmM6ZRAG8/2Yo9K\n", + "lbzcc7idoFdk3bBDwPhKrZHDceb6+sjLF3f41qgGlKlsdwFthUpetaWVcqbTa954uqdUwzFNHE43\n", + "ZBaGYHF6ZDpMHNwtu81GFhVdRzxmsIaqInF+IYmH6xPG/m1iseR6h7MeZ7doneiDpRs2dDoSE9yc\n", + "FgyB3vf4UlHNo7GkXLCt0azjOC+o2hg3e8iJYeu5u33Fzc0Nl1dbtv2INrJcCH4khI6mDCF0D1dq\n", + "aHTjwEWqJCDWW6YFUUmkxGStZLyoRo4J24UHGLGz7pyD03AorFUMw0DvPYf7W0o80PU9SlucMUzH\n", + "e4YRnB8gr7LsoFFKpFWPM456pp1H5Yhacr5zruwvLjmd7uhCTyurOE/WBW0CuiIdDlbwc3GlbXaY\n", + "MNCsh7SgSiXlRjfs2I6ZZiTMbVn2dEPg0aMrNuOeGhuH21vpuJTiOJ9Y14jVrylBomGNMaFaIS4z\n", + "t/OMtZ7NMOBMwDYjh0op524uMPQD3ovqIKUVrTQXux05DyLIV1qusUZ0qb3pqa2RYjrT+gW113Ui\n", + "9NdnorrtNLaN9L1Yer13aO/wzsuN0jaJm2lGtJXGnIt+oVWkm7fyWqi1YJ1wPY0xZ3aqzKONMd/z\n", + "uZWS8tm2LJg4CTMUghTnAltKQimLUv9EneYwCJw0xkgphcvLS77yla/wp3/6pwB84Qtf4Kd/+qf5\n", + "0pe+xB//8R/zK7/yKzjnePfdd/nMZz7Dn//5n/MTP/ET/9+iWSo6V7yFOSqcC1SfRPisFceoqFWL\n", + "ayTLBlRZ2QR621EoBN/jrcUbycbJNVNSQmdY50qNkOsRnCfVTMuB1UtnO44bSgroalEUTmlB94pW\n", + "DugQSFlRasZZyTQZbEdqiftjJldDQ6AAqTVaPREGJ5BTU3Ej/MCnfojPfuY/x6qK046PXnzE/f2E\n", + "jtJt5AQXuz1WW2wtlGZJC5KP3hJD0KQ8c3P9Ia/UHX/34q/48Po9Ll2g63uqipxO94wXgeN0j/eO\n", + "lGa0KoybjkeXT3Buw/NPPiTHE24TKN3EkgI5J5blBV3fcHpg8BvcbsAUha6Neb5B2yNGPcFvR3a7\n", + "d7m++xZ5XdHtEqvv6buesd+zHu+oMWN1xVnLRe8QjH3FdT00QzCw5sQ4bER6NE9opzkeT9zdv2QY\n", + "HZvNjqv9hlfXL7GqYLsgXXgIkrfjHFiDaQrvDP1mZFMzqSTiWjidEsfpAKeJvh9IUZZltsnIph8H\n", + "KlYOg1JxWrz/4zCgyHLVX2dQsiGOayL0O5EJaYO2jtiaSHRaIZfI8djo9wNKnWMluktyKnir0dbw\n", + "zqd+mGWd2T96xnD5DKUDx6UyV1BG9LY2eJzWGKVpzlNNQKV7VAGtB7zf0IcTyzpRjaLb7ri8uODy\n", + "4pJh2EjUsdH0XY91jmVZKFkkduK3j5xOJ+b5dPbbJ6ZpIsY7DqFjt9uy2Q74Jn7rLnTs93vGcXz4\n", + "fHDnrtxyOk2Y2oQUdWZUil9dxiDi61+lUaqglIwBpkmwj9aKPMsaJ4qF1sBompJIihZlPCdxx3JV\n", + "zqpRqiZXYQmQwHmPMkY6RO8enGEpJVSTW7LW8n1QTUAx2hpZMBswRRZUtVbQ5gHqYq196Lj/0UWz\n", + "1sqP/diP8c1vfpNf//Vf50d+5Ef4+OOPefbsGQDPnj3j448/BuDDDz/8DwrkO++8wwcffPD3P25u\n", + "lCmTnae0haABbSjFY3xgbZNs3LSi7yWC1DqHU2J5lEJZaGRSEYJJmRN388I6LTgsJoM1nuoKWIVu\n", + "hbicOByO3L4K9F0QMSuNViOxBrQJVLPQbRSHa0dFY7qKbQHvOmp/4hQTtXYUVYi5PhTYMCxUr9mr\n", + "C9544xlXF48peUVVw37c8qJlNBIYVpwE+pg+MKnM7f2R6/mEMQGtQJnCqb/nRfiAOVWu779NtzfE\n", + "lgBDsCMFQ1wWYrvHWk8uiZQn3uQtSiiEccUHUQ+onOm2PV2J5KKobZIfOKKSuU9RlWUqnBbP4fiS\n", + "Z08fMQ47jDOM+7eYDq9wppBOirwo7lMUJF+16Ozo+gGvBjm9rSOYLRvTY6rlauOo6cRyuiW4jpvr\n", + "a4xpPHr8DtRM3/XMa5ZD0Y84789dj6YhBPccFYYGRqDD8mc7XBfpw0zKhlbzeSYGnKHUm82Wcbcj\n", + "OE9MkZqLLIBKRut2lrkJF7SVhu+Eo9n3O6gRawu1NXqlUTHRvCKnhXW9w/pLbNidA/ok3qLre7zx\n", + "mK7nnTffod9foL2HohiCJc0L67LQWmW730BwYBzkKDPArMhzZl4i5ew4AmRDHDw0zatXN7y8vqEV\n", + "yQH33uGUYxwHWoMQgiyrajkXzZmU8vnAXB6893LTkKu5UiK3m6bpAfrcmowyrLXM88yyLNQqEi5j\n", + "DKVkEbqfIz2kKFoERSPFS2l9ZgVovHN4f54tCpdOCEVnGVPOhVrb+eov/NOmhVXwmkxkjWZdV/kW\n", + "N5lnanWmWdUm+EctexClGhr9kDBbUkZ5f44i0UJ6Nxqjzw2aev3M/wlFU2vNX/7lX3J3d8cv/MIv\n", + "8NWvfvU/+P3XX+zv9/H9fi/mgtFZgAQpYpXHGk2KldYK3pxD0Kro/5SRWYvSQBEhfDWOWh26JpZD\n", + "4nS98vIwk1Oh6xSb3lOb5MEoLcuAJRaq0SRWYrQsrifYQBccL68n+gtHVY1hyJAr8ZSgBZR1WNfh\n", + "ioZyJ/nLFZSy1JKJSyG3SquVzeaCNx5/mj4M3OSZD6+/jfeZ7a5nmmdMMmBlOuZ8ILuMTobB9ejU\n", + "CQxWWabVYA8n1nQgzi9pZkFZQ26RYHrB6ulMqxPTfCShOC0LLb6grImhsywqSd702KFMorkisGXj\n", + "KK2iW08rnqaCDNO1Y+su0N3Eegf2kcOtmlI1Y318BpPs6JqjJbA6wcUbGDXSeUPvvPBPK5hShF41\n", + "DKzTkRQXvGrc3L5CO83F5QVxbXKFBeblRIorm8ExDAO1NmJcQMm8TClNy8vZtpjovSU6z6bvuTN3\n", + "0hUpiylFdILG4IxArrXWeCMAZBUsYFC2QVlYzjnjm80W5ywxR1RTnI43XG43KNtBNVir0F09P2ZD\n", + "58Y6RazOWCdSHKWNiPODIww9aANGgzHUVMklo2qWZMscictEf3EhDiWdITbJVsqZw/0d02k6LyKl\n", + "2PT9wLIs3Nxco5S8P/tersDzvJyD3Cz7/Y6uCzLiOHfIr7u3lArH40HspmfqfWuV1uB0OrLMH3N3\n", + "d0MIgRDCAyFKnb338nfIFbaU190mYrw4X8VlJKcEuXj+tTHnYLRzRyiFT50PSFHECCSnUUqm1Moa\n", + "V6qpGCVhaspYVGvUKs+n1so6L7RaH4qsMkayl16zCUomrvVBOUFcsNbx+pruvQdtaFqTW32AVP+j\n", + "i+brj/1+z7/6V/+Kv/iLv+DZs2d89NFHvPHGGzx//pynT58C8Pbbb/Pee+89fM7777/P22+//fc+\n", + "3v/99Y9x2tMMXL7lePo4Y7xnurunFnFoNK1QrbEulWwqpSgpKDnSqFhbJbK2VMzicXi62lhyQhfO\n", + "GdgeTSLHRq4Sp0qsZBw1Q5xXJn3eghtLjoaLC4+34AbFXcncn+7ohx5rHf1wyWEqrPEezvFOzhla\n", + "c+RsmOPMxXjFhd8Q14nnn3zExzffQrUZHxw3Nzc0IxDbJ7uACZ5NcFjXuDkcZJ6yLmTlKcawpoWa\n", + "Vkzw9IMQw9c5UrnD1o5QJdEztpk0GVzbcIpwrVZM6XH9QB+8EORbBCO54NYYKJqaDE0HIY6PIwyW\n", + "KSzU8QjFoE4Kq3qGbDC6EW0lqgWDJQSPs45PP+lQWEpJ1FqYl4n7+xM0MH3HEld5ATfLcT5Ry0IX\n", + "NixRiqqyclDdHu/Y9p1kmbcGCKbMe0MrIm+J64RzIqExquK9xmnYbDYsuXB7d+B0ukcrwDlijKzr\n", + "AkfN1I6SMW7FF99q5GLbCexht5e0TC0Sq85Z1ttb2sZBbfS6x/WOlFdsU+cCsaJapTTJZu96j8Kg\n", + "zsTx7cUe223QSuyVpVWOcSXFjEfRB4vTDWKhPbmkWYM+rqT7I8dZlko5SXSGtU7kXTRyyec3/NmS\n", + "mTPT8ciyrkIpcpZ1PjJNJ7ou0JBu8fX1WOHOM8DK/f09SqlzMauU0liWiWUR2+v3Fs1hGCSUz/uH\n", + "AtT3g8iBlOhAjTFy/T5fc9ezU8taKbKvwc/LspBWuW7HlOi67mGjXYtkyOcsW+5qGt5KAR8Gj7Fg\n", + "7fCgiihFkkm1MSitqede0Z4PyTXGh9uHMQbTmmzw14WcCzFG/s+vfZ3/42tfFylj/Scsgl6+fIm1\n", + "louLC+Z55k/+5E/47d/+bT73uc/x5S9/md/6rd/iy1/+Mr/0S78EwOc+9zl+9Vd/ld/4jd/ggw8+\n", + "4G//9m/58R//8b/3sT/7YwO9eiz+2dFQ6wlyxnfw4sVKcJqu81hgjSvT2vCqoFRBGY0yCjU0MBFl\n", + "PM5ruVoFUNbiOivZ5VU22spZgoOyFqa1YKyXZYFqpFLRLZ+THg22NvrBUEzE+QzOoa1m2z/CqoKu\n", + "N0x3M94CZ4+1NWBqxXaG1CIf3X1M5yZefPg+19cv0eZIaRptM7nOzAvczgObNHDZ7zCdYiqVw3xA\n", + "GYM2nhCs/Ht1o9MObS0xrqAVORcMwhztzCP6TpZSzmwJYWQbthLmZQyoSs1gDOfPUZAanRHKN0bh\n", + "tccFT86J2S/kNGKMdAutKbx1YjXsM3ot0BReW0LoZCanFUUZ5lQQf4BcjzQKpTqSgiUdqLVicDgV\n", + "HsAI3nqm5SUpVfzl5gEILJ7uCBV678lpppT1nJ8tbhurKtZByRO6FayGHItsU62jtQLos/0246yV\n", + "DHNj8WFkmSe0Llxfv+TyYoe1IosxJlApxCi55sO2QzdF7zpqLuTWsF3AOYFatNbIpbDbbjHeo6zn\n", + "1ctXPH3mqOMWVRqtrJSYUaWQ64o1PdpqYKZZi7IXKDdxP7/iww+e8/HdNUkW/jjvscawLoaYkyw0\n", + "tGFOK/bsA0dp3BgYXYeicXNz89Bhei9xG4r4sJUuRcj7OWdakw16CBKXHaMkUU7TdP5//gF88vq/\n", + "IJ2usQZjNOsaWdaFnGXMIrIhucKv6/Ig88qlkHKkFkkCNdayrAGjDbkVSqr44Eg1c384UOpKF0Z2\n", + "ux1d19O7QMqZw/2B29tbDqcjxlr6vuNif0EfgoCUUeQYUUqMCih1llFJUsPhuHB7e0NOmR/+zNt8\n", + "9j95F+dFq/zf/nd/9I8rms+fP+cLX/gCtVZqrfzar/0aP/MzP8OP/uiP8vnPf57f//3ff5AcAXz2\n", + "s5/l85//PJ/97Gex1vJ7v/d73/d63vyENZFtuGQ2ilLPGcfaMs+Z+5tCMKBtorcBXRKndcEogY+a\n", + "rHCDY+g8JSlcsNDg0lqWLI+XSyO1QisyMxuCFkZhtZJvU62QT8iCu6cxFQM5syaNHQuutyhAtRVq\n", + "BiqVxjIlqjc0I7EYncl0TvNocwWp8sHHf4WzG56/eJ9WDPenhDXggmE6zhjTeHX7kt4KU9N6RNQb\n", + "PZ0bCf2Oi2GDM0DNkrnjLWsEUc4UvB3RtcNqATPoWvE+0PUbhnGE1yf9OqNR9L4HrTgdjszLRNKJ\n", + "ru9ltjNaaJW+66BJvLGz9uEaVasUoteZ4UpBU4p5mriLws0M3p+hyg1rRcQtHmxJeu/GkRotnRH5\n", + "WEqJp0+eMM8zHz3/BOcNRgVSqVhjOR4OpDQzhL0AOYzMvDVGYieA2haM0fRDx4tPbkWW3JoIxZXC\n", + "KI2zjqurJ9BWWhbijjOWOC+0GllOB5Z1RqvHXL98ydh1TMtECD2lJHrvWeMJ66BhGEJ4GMUY00sQ\n", + "4HlGti4L237EauiHDdZJHC3NYEfHlStCrm+Z0PWEQUTyqhlQAeUtZvOYqX3C7TFyuLvBe8/FxQXF\n", + "WpLWaGPZbHfU2ui0wbuOoI3okd3rA0ZE7q+v0n3fY85zP60bzjmGYWS3u5CRgdbnua49E8gkvdOd\n", + "O8bXWUwCdk4Piph5nnHeS4OSBe5Mk830OA6M45bLqyvmaWJdI6VkOqupteN0OhHTkdPpwLJIcbbW\n", + "ncEflZgip/lETiu1aVzo8NNEWuezA/DI8XhkXiPuPCstVSj8RhtqFfeQ83J4euvgPH+NecV5z+XV\n", + "pcwyOaMFjcK67h8qi6j2OiTl/8cPpRT/9b9+xFX/Dt5uyQ5iuWcMEZrjcJ/45l+/YDka9lsnp38p\n", + "FKvIpSCjUINVme2mI3QjmoqKjsNaOcwnSaOLlTjNDL1hM3rGvqOawhqrJBfOhWUuAv+gULWCUghK\n", + "M3aO4aLhR40OHYO+4HLzg3S2Q9dCigVnDJxPcnFFaC4vt2x3nmEXOM3w6nrioxfvcThd03WGMfTo\n", + "JvT4YB2d9+x2O3zwpCrdo9eGYRwYepGElJwoWb5NiiKFq2XJX4mggWA6cbycN/7aSAcQzydtP/RY\n", + "Y5mWmbvbe3lxlYo1hmHo2WxGxmF4mG0dj8eHjeL3pjvGlKA1Qghnj3dmWibB4VmLbrIFfb0o8F4C\n", + "0JoGciEtM6ZFSly4uhg5He+5vX9B73dYp3j25BHeBfb9lo8+/g7WFcYwsNtfCuyiNpSy5FpZU2Wa\n", + "Fw7LwifXB97/4GOub++JWb4G+/2ex0/f4PLJG+wvnmBVY4kzrSJ59Icb7u8+oKYTTx5dklfogkbY\n", + "QpXdZqTkiNVGDudc2O+3gsKrhZQSwYqbZLe/QBspMGM/0Pee8fIZ48Vj2pOnKLOhxkTLneSo20Kz\n", + "vciMjKFph1YOSuTmo+d85+/+H24Ptxxu7x6u4bVU0Ss6j3UioUI1lFUM3mOwMkP1RmakSa63nfdy\n", + "SMT1IS/JWodzDucsrXGe47XzHDk+gJ67rqM7y7YOh8MD8b7WzLKs8pjneAitxf0UnCyRdhd7nj59\n", + "xnZ3KVfumOWmpCrLsnB3e8vxcORwPMjV3srn2xDIOXN7e8vLly9JKbPZbNluZZmnkATS1mSL7zrp\n", + "hH3weOdECtXAhwBnFUEuhVYboQt03eZc4KUZUKoS1zMFC0VThv/yJ3+R71ca//kgxEeFzge2fUdd\n", + "M6d8g3GOjfU82ffMn7rk2397y2mqDIOh2zhqSOjiME1hKhh1doqgaBoh6yCnfl5W5iliUZgGHoXX\n", + "imYsuoN1bdQSsa3KqZwbLUqspwma4iq5NS7CFbvxMY/3b3K5f8p+vKKzYvJ33uOtxxpFzHIN9MHi\n", + "g6FSybvKm/uFT10+IpcsWDAjsNqaC50PKNvYDJszYl+uuaa91ir6c4aSzNliEgtaWiJNV7rSmNoK\n", + "iODdOoMGefyWWE8TxmhCL9rQZZk4HO6JWeIdxl5ebM77h1iI1xKSnDOnaZJFmhbi+rzMoDV9CILN\n", + "01rI7Naizz9qqSgthb9RRXCuLaBIZaKoxrrOOF14dfOKdZ7o+w3LtDDaAE3jfeDlzQtqbVgrS6uU\n", + "qzzXM1Vf5k6iLWy1UVOmC5a+C5S5orREGQybPdZY1vnEVCGXjA+S0ClBa5rgNwQ3QlmE4k/jcrsB\n", + "LfTzoR+pqklUtFLCyqyiHTRao7TidDyw2V8IP1QbjPOoZTnfbJqMKvQGNiNGXwKysGhny56iUXNk\n", + "eXXN6e4gB50L2P2FJD2WfN7MB9koo2i1CB5PVWZnqakS15Xt5Z7ddk9wjqYNnCU3uciBWEsl5QXO\n", + "xeT13FGff52LBJuFcWDcbc+EKrGc5pxoSjrMaZo4HA7c3d09LGGs9egQ2GxHfDeQcuF4f0Ab0Mgs\n", + "/fV4oWqF6RyX/ZXcSM4jl5ST3Dy1kg6ZlZYLeV3xRrSy5pynDkriWrSVOBWQvQWadT1RaiatmeW8\n", + "bR+Ggc1GvpbLPBNjkgYq5XMBVees9u//8c9WNH3bcbrLtOW5CJq7ws0nmv4J+ACf/oFHGAzPn9/i\n", + "vEH5c+yqq+xtx4gGa7g/LcR5ohs7dE2oktGnBZsye2NR/ryFL5XjdMQag7Yeby1mdDhvWJaVtGSc\n", + "h2RX3NjRjY4n+ye8ffGDvH3xKXYXe2H6WQ1O4a0sQTabDS4IJ9IqGUKXlCk1k1MieMX+SSDHldqg\n", + "INEBSiuBV3SdbBfPL5h67mCEd/td3ZhzmhAcMWWiX86uliz5QylTS5brM5KSmJOMw5WW7Pi4RilC\n", + "zsP5DeD77sF3W0ohnfWQ4qaQN8b17Q0pZ7quE4huEOdE04pMo2mFdQ5jxaJntEafdW+vO1SllAjN\n", + "ncNkQ7MG1SpLPKF15XQqOGfYbnag4P7uFqsbm82IUvUsp6ronBnGwOmUKCUDlvo9XfAyz0Ja8oHQ\n", + "Dbh+wzQvLGsidCOpFtZ5ZbMZ8EaWNY0sgXBnneG8TDy52pFjBGvpg5C3cl4ZN/1ZfuNxzrMuC7rz\n", + "cjA5fxaEe7SVyAu/20O/QdmRPCW0bhBGtOlpVQvLE6gVlBbJzauX13zw4YdM6wQlM08nTtOdzPL6\n", + "Ea3V97hb5HaTUsYax/1yYlkL3amiRkNOSQomfE+scXsgQb3+Xi/Lwv39PdM0scZIN/S89dZbDJsR\n", + "4yxxXclrZD0rEow1DMPwsF3f7/fAdztN+/pKDMynE7fLNSEEodpbKzCQWumdZQi7h+0+CAXKoCg6\n", + "EZyHYaD14/nP6PMySyRCtTWm04lY8kMXXbKMI4a+l9exEnfh60VRjJF5nmitMc8z6yJLSmss1snz\n", + "s/9Si2Zve7RqlHRkCA7V7cWXvESc9+xt4AfeucKFjhc3L1FaYZtiXVZSD+5iQ3/G498dFkhRoku7\n", + "TB4LtjPUmMG0eQAAIABJREFUoqnKEquiaocLms4HNv1I3/f40KO0YskLyxSJKVN1A5vpg+fZ/tM8\n", + "uXiT/WbDMPY0XUhkbLUscSJXi1kVpUgGuFyZemouaM15+9hByyyLZV1mbGuyMVYKdb4G6irSB+et\n", + "ZFub72ZzA2c9nAzvu+AYh16uxdMk/EFlRcQ8zdze38pGlEbXS0Lh8XiUF9w5GO615lUhOrq+7+Vq\n", + "fZaGvC5C1lp22x2lVbq+Yxz+X+bepGeyLM3r/J3pztfM3smHcI/IqYrOLkSjVrNEQq1GqFnxXeoT\n", + "sKL2tUbs+RT0gk2rQSWoJIvKqsoks9Ij3P0dbbjjueecXjzXLCIFFBIIZdomIjzcX39fs3vPfZ7/\n", + "WGGM6PVe9nuJOCsr6rqhyCu0lptZJEHyNUIMhLAQhQznHPIsxXAHCldgjBBKRdGilLx3m82WcehR\n", + "Sg7FvMxWHd+yfo+JkIJgbnoWZllpwuJxrqAsWsqsJCjFOAWS8uz38t5UVc3tbie9PhaGqaeuc5Yw\n", + "0hQ5hc0YTkeCNjRXV3g/MUynNeszl4YAl2GcJXhP7iqZdqNMuBZNVVaw3ZKymuQK3GYrlsnFk5jB\n", + "ymYBSph+FMZktO0VRfnEkiLRzxwO3/D88rRKeewq2xF2Os8zMuOIRIpM/N7ZbkueWU7dHhEQuMsU\n", + "dy6VOz/Izoeoc46721sSawBHSrRNg9WGw+FItz+s+K3ARvJgFqZbGPSSIi/QRkuYxuIFikiJU9/L\n", + "A9l7yrISJUP6Nq8ykYhB4JxEEv95Euy0LkvaugZlLrBCjBFFwqzSp7KssOuD89xeuoSAD5Gqqqjq\n", + "mmLViV5+Zq3kvSlydGbXe0ykT0WW4/TvbAixJnoPPqfKKrJNS+UyhrlnmSPeaqqq5v3bjMwq9i8H\n", + "liWyLIlhWhhiorKGMgcdCvzoJaGncTTtNdYUQo5Yh1M1xhU4aynyirKQMIMsK6Q3WwdZyxbpd344\n", + "fiSGhev6hqou0U6zxLA6HNSao2mZpp4YZrF/kciLmk0JeZZTlIUUh/kZP0uWIwhulFKQkquQ6PoR\n", + "SFRVCX5ZL3AB2ZVi9eAuaGNBrZKKtbLWr5IMEDYzL3NKX9P3IwuBarNBh4SfZiIwrDILCfOdRBSs\n", + "pZVzWgXMbuXtTOZothsaJdqtlBJKG8bJczqdAMhdTeZaNs3u4txZ/MwSIxE57Bfv6U8DIUiwRfKB\n", + "yU/4JWBciXMF1mXcXr+WsrtxRqnINI0UWc4wdaAWrLLYPGNaZpRWFFlJ52eWBMZklJXc0KdpkYdp\n", + "ntFNkTQNWJMx+wWlJNxDjxPj1LFpDP1hpMlyEZv7marekOJCUZQcDnu0u5O2x2WCxRExxEzj/Uy7\n", + "2TF0J2JCFB2ro0XXGSkvya6+ItgG/AI5glkOMwzPqDojZtfEpDBpQUnjF80XX/J3337BMhz5qz/7\n", + "dxzHB2KeePz6nqfD1xibc321u5AuVlnqqqGtagJyUJ2hlixzvH37PUzmmP24fo9CjhVZxjSK5dI5\n", + "IZqauqapRQealoX+cGCaPbP3KK0IIRH6k9T4xoRf2z6dM0xDj1Ia5ySVPsRAWA9VpRUuUxLfFwPH\n", + "/UHE9SnispykzGXyzeoSvSzUZXN5mH9XWnTeXmKU+u+m3pBWXaa7hG2k9UGcX4YPpZSQv0mhjTQ0\n", + "GONQqIsSIMaIWUX9f9Prt3ZoLnFBK4/NDCoWVLrCqIG0KI6nhRQHqrImBEXmSvIs0HUvMsGlDOcr\n", + "0tLQ1huuq4wY9Lo2OZQrJVUFhTIGZ3K0cVhjQYmDIHPCEtZ1KxPDClQPfU8Cjv0BZcSVoIgsS7gI\n", + "+ZVSq0wj4iexeCYSKsJiLYVzpBgIyyzZgSvZkueZiHaDpLOEEBjWbm45KBUi8ZGJKqZEiiKCzrKM\n", + "oqwvTPY0jUyT4HLLslDXNUVRURQ5TVOxhAVDoqgKMmfxy8Lce0IKAlFoI6ttWC5TkmBS9rK2GWOY\n", + "p4l5mmTiU5ZxmIgxUhQVNrOU69pujWFaA3/PjO15Gk4pMs8TQ7cnLTNKGfKspLAZdVHJzzvPpLSg\n", + "Y8QYBFLw4qBSZMwhYFxiGnuqqsH7URKudIQo4vQsd7RNQ5HXmCzn48Mzh9ORxUc2mx3vvnjDbrOh\n", + "73u6voMAVZGRuYx5HCmcxRkLSVOVkjTfDz1KKdrtFWGWNsNpGkQGVor10DpHWVUYZ3BlQZFl2DUo\n", + "JGnQRU1aRsKxZ3g8rY2hGcX1jG2vSTq7hJFZq0kYrLvhi9/7MU+nF477gapqsZklzwqKPFuvnZ55\n", + "nkgxME4js19YlgljLLMf6Too8ieKsuTUHUgpkWeZEILrwdD3PVlWcjqdZHWGy8bhXEZVlRiV8OMs\n", + "Ns3ei6xodf+UZUWM/jt4oGwBXXdinuW6PV9XRVGs15ambdtviUb17bqfZdkFVz8fpHKvpQsp6b24\n", + "mqyRa1ivv99p0FYmdgkcyQVKAiB9+3UwKCUHrXYZyWppnV0DPlD/AylH/zNfh9MjTkVad0sKOfMx\n", + "oFxiGRfSHPn0zTObNtC2DZkp2ZSGuQukEHl1/Zrr3WvyesMu22BNjlaigynyAmMLlEbSVpLIX6y1\n", + "oGRN8OvqIAeX9EVLWnPEWk1T1qsVTNaIZQmrmV9d7GXTPENKmJRYonxf+ECVZXijSXEhLdIzlOXZ\n", + "Kr1S+Dms2ZNizTPWSsuhkTCJuMo6Yowi8rbi1sA4gFU/N6EU6+Ela5ExhmHo6LpOMgE1pCUwLx1+\n", + "WZiC/AwaefLHFPGTX8F3LeRRFCLhzHzLf8t6RQIfRkI4C38FY8ryXHzh66/F+K2j4lw/odbg2vND\n", + "IYSIQZJ9hmmQWgilqVxJXjgWP5BiZJ685DK6XJLTrSIGYT2VAhVEwZAZS68TEHCZJS8KglJM00w/\n", + "TPhp4XDoqKuCGBOnrictmmxXoEt3mVwkT9ThZ880B6q6YRwG8ixDJcNmc0VcEnYVfC9BbtgYI9ZZ\n", + "lLVEpaluXxN3tySbo7oeUg8qI/jIX374OUVmuKtaYcVdSary79wZUnlMgs3NG7549yO6pwOFK1Eq\n", + "SZV6pqW1YBIcrxvkM86yjKqqxdIYJ1lXh4G2kmSjYRhIITJ6SSoyRg7Hvu9Wd1BYlRSNaC5Xq+cw\n", + "dixhoWkbGTwiNM2GqtIcjwf64USMyyr7yUlJrlO9ypjkwZku4vjCZes1I8RTiCJ2n+eFuo4r/qkv\n", + "EMAZKsoy+XPnr51glXrJQzfME36Wo89PI5MThcdZ9pitzqNgFpnwo8HEGWbNWVMqldN/8+u3dmjO\n", + "UyCoRGkUySjmaWHqRvrxBb8EZj/zsRvxc+Lu9jWmKtlsDUVW8e7mHbv2FrQmNxlKJ6zREuu/AtUp\n", + "wcSCw3CJl7IGa40kq6yyC1Rk8eKYALAObu82aGNEgBvlaTyO4wVXSUn8yrIeKYw1+CBss589duvE\n", + "MWIsWV6gjVi2/DIRkwR9kLToKp0jhcA8Txy7E+MwMowDbdNSqeoiJHamurgtzo4MEePL10BFEfCu\n", + "MonMZczLjJ9mhmkErciMIXOWuOoXTQZunTq/a3ubVveE957JB/F5a0Nu5UIOIaCtpmk2NHV7kRWF\n", + "EDiFI8t6A5+dFUI0yeQQFvGDn1e6wuVYbSizjLYueHr6CNGxq0tO/oWKjBQ8y9hhq4qqKAhLIM+E\n", + "UQ/TgnMFmQs426MmyfkMFKAMVjt0bqW6+PM9dV1TFgXGyEOkLFrCPFO3GxSRoqqZ/TOBGT/1oGCe\n", + "J9qqFnmZFU2fNo4UDTGuh8PoubpuqauKJSqy7VswLWSWw4e/RqcjPnlMNAyHgU45XB1YhpGs+vY2\n", + "lTpiLg+Zm1df8Oviz3GZY5h64hIwVuF9ICoo6hq9NmXmeS4tkSHQj5AXEv12GDr5DFCUeU6TlRdn\n", + "z3kbODtmzhOhXTW6j4/PdN0JbRREST5rNzV5YdEm8fT4wsdP39ANJ3bba7768h1lXtKspBgK/Cwb\n", + "zjRPdF3H4gJ1VVG3LfXaR39evc8PWuCChYIceHVdy7UGoA2ZFYkRJIJdBM+Sd3EV1cfLwQ1ctKXa\n", + "aFKEQCCayELCL15yDmKicNnfeHb9FomgDc5pMlugtbyxi5/RSTpG8BIq6k+BpZYUly9ur2nrK7b1\n", + "TmK5UhC8hUQyCjLQWhG9BJRao1mSRitEl5bpyxt3ZohTko4Xu+IhLsukSN7KCL8sM2UpxMs4jhd5\n", + "xrmHxmZ29UUrTl3HN58/scTIZrsR3HQeybIc1hX+PKGldT0/rxoX7EULk33qTvSD1My2bSvryGUd\n", + "EtC77/vVoWFZwsQ0zWKxXJn1EBc04jcW94fGZTmgICWcXTMMUWi9dgBF0QE65zBbwzhLXUSWyYrc\n", + "nXrGcaKuazabZvVcS0NvjCIFOq9Z5xtAJpbl4i1OUTqDrpqC6COb3YbSWvpTR4oJrSKzHykLwTy7\n", + "/sC81vzqpIhKcTx2FIV0gqu157vKCoZhZhoGfFJorajrEu8DSsmNOM+zrGEuUVcbwjTJpK4NRV6y\n", + "Px3ohw5nG0l2dw6rBWtdXIY5k01Wo9VC5uThYIzCLyN+UZR1Toi9TDA6Z/P+K8bDE/7lhW8+foMz\n", + "gaYucbnF5AYIkIwM4knaMaOWKpa8bAjW0r/sCSmwPzwTg5Aq2+0V1ze3sIZshBDo+46UEnVZ4ceJ\n", + "/ngi2+4omxpbS6CH2B4lQrBpGm5uJPT4fA2KvEmz2Wx49eoV0zSITzzB1dU1VV0SwsLsPVXdsNle\n", + "M82B47Hn06cHrq+ueHV3R71piSlRpMQ0jpKb6ztIMiUGoCqr3/CrT9N0aQ09r+TnCfOynodlleEN\n", + "xBjIs1xS+6MoR2QTU6uMz2Dtmv4UemIUPagxFqs1uRFJol88AZlcx3WA+q+9fmuH5tWmZOo9MSwM\n", + "hw5jwE8LyinyvMItmsXmuNQQBrBVw1V9x6bOsZmkqYdF8MHMalH0L4F4PpBSXHG7sKYxi9XrPK6f\n", + "ZTaSr6jJMrOu3oLJ+CVAEv+rXV0SRZbz+eH+kuSiyXHGkjvHvHhM7ng+inSjrCqxfeVyMAlzZ1as\n", + "UA58s7KBXd9jnKXJCsLK9AlQnqjq+nIhLWGhLAu0MnTdSSRHrpAkmjBLZmDiAp6b8wQZpAoEJd59\n", + "rQTrVYq18iH/jZCFFAJ1UYhAvGlWYfTMYerxheCnu6tbqqoGIn6Z6PsRP01oLe4TQBhz1CWsoZ9n\n", + "LJEYFEVeQ0pcX2+x1jDME85qJj9ztWvx84DLNNMYGYYJZw3TNK6NjoIpS6yXIsQIEYzWlNYxjjOn\n", + "3uOniW4c8CESl8DQd8QUCT7w5Rc7UqhFHpOL373relymyLKckBJd3+Gt43Z3Rbc/kpU5S0oYgqRN\n", + "BU+7uZJA3wh1VWOyGrQ4gcKi8IcnPBkuA11Zrq5b/vwnf8qmbvDza8oUSGsaE8iEuQx7VLklJWF4\n", + "v/zRj/j4lwv744GUIqdjx+k0kJLGaEtdlJTOUWy2PGnF4+MTY9cT5gU/TizlTGa27DYbrLMSkhOj\n", + "sNbzTNvUVFV9WdG11mtAh+bqakeMLafTEaUUd3d34iJaFvq+o65O5HlJ07Q8PT3z+PTC5/vPfHp6\n", + "4Pbujqvtlm2zo212tM32ou8U0tBzCke01pdUJqXTSiiZ1RyRo/X5wZ/our1wEVXNHAPBB/GwG4X3\n", + "C113YpommqbBGHtJdYor6bksC/Mc1nskUXgJGZnGEW3MxXb5N71+e8VqemZUPYtfyJaAmjXJTDgN\n", + "RhtsUZLbK7K8pCwKCmtxdiZgCLOsEiHKSqqdQa+xVj5FjDMQICTBmvLcYa1MQpAuIl05MLlMmSEE\n", + "5nmUcf68hi/yBmuV8F6qgeOqlVu0WlnjtDohMkyDaB+NxFHJhybd203TMI6eGPuL5kwpWLynO504\n", + "cE65VhR5ToiR0U/MYcFpg8NyOp4wWpo6i3ydGgHWEAaRDpkL5ikXi8DcahU653l2cYGM47hitiv5\n", + "FANZlvO83xNDpCpFdTBNE0HJBK9NRuaKlRyTG+ywfwECmSvQOjEMo4ivh55plp75dnOFigtFkVNm\n", + "iV2dEUbP4gdcXkBYeP/2C+KS8L6XzMruAwQoXcWSojixnEaz4JcRl9cYrVAssOLaPniGceI4zvTd\n", + "RAiCi0nO5ExhDJlVZIUjq1ucjnT7e3Z1ydPjC29fv5Y8xqComwpjDXld0U8T280Oo5xYYo1hmEbK\n", + "pqZsasYp8ub1DVy/JaQM5XLy3Zb+4RP3nz6TOcvbt2/59//u33P/8sj7sUO/PNOWLcnWItVWwGJQ\n", + "pxdSs0OpjPdffJ8Pv/hLDv2Rtm6piw3jPOD9zNPzJ47OkdmKmzu1TtQRYxXbqw3zMnE47tlebZn8\n", + "SIhrkWBcUAmU1pAEHkopSVp7lq+Qll7rj4cVzrIcDge6rl8Dhguurm/ZXd8RCPRdz/PzE49PD3g/\n", + "iYzHOGIA0LRtQ55XpKSYppE8zy4yojPeWOQNqhCrslRcGLxfmKYJBeKcI7IgZo5+HgnzWc0i4Sze\n", + "L2v0nVrdTIEQ4noGCHzRdd0lA/RM6PW9pD45+12M+T9//faIoP7E5AdKlwguooJCe09MkTLfosoC\n", + "Ywrx1TpxgsxhIU6TlCKtk1GWief0zGivDiohWLQiz865ghHvJ2G8/bcHyiUVfF1pl0WyFe2Ke6Yk\n", + "2OHxuK7Sw4DLheE7O3bM2nuTZr+ub7IizPM5czBcJlxJwvYXllBrzTCMeC/+2YD0dmfWiSc4QZFn\n", + "FEWJ0eYC2iv4DiOZ0XWdgOyrpSyEFaNdGVH5uycRDxsJgvV+XqUZkl0ZY2LoJ2IKl/W6Gwb6oWee\n", + "PdZpbF7gssTsZwhyYE/jyDxNdP2RTbtjWcIK7HuOxzVFJ8u4u7kis5aizNg2FXVVCFZaiF729PyJ\n", + "w8Mv8YcDc9IoNG2bM55GbL6h84noJ2LI0MqKgN8EXJ6TxwI7RwKzWFo1FFlO7qR21/tZxP6xoMoM\n", + "bdtgtcUoxTwsbOqa0+FAWTl89EzTgM4MHgW2QmtEZRE1KnMkrcmaAqst4xy4zgTP9OOIRaP1DSF6\n", + "dJrFapkUx+7Ept3xB3/wd3h8/JquHzD5iDsdKHclKhkUAW0d3edPVDZHlY6sqrE2x08Tg19IC1zd\n", + "7mStNdB1HafTI58eP1EWJXmWUazGhbquUEpRVZIxMPtZ7voUZejQjmEYOBwOxBi4vZWKFdHjiuPn\n", + "PH1qLeLw4/FZtJ13t/JwTlKS5rRm27SUucXPM9Za2rZBK/F+T9MorbJ8S8qcmwMuye7WYZ04dM6u\n", + "IMlFVThrYSUV1QrjOKVJRki/ZTVhxDhwOBzXjZL1vg5r3qdZN8V2Jak6nh73DGMPCGRF+TvKnqcR\n", + "ESMrUM6RaRiGCR8WlrGndRtslmNNgbGOkAIsGkXAGntxCACXD/XsASclafjLS6rvaL2ka8Rc1g9Y\n", + "Q0xXMa0EBujL106KNQ1mIS5hxSSFlT9HZpWlxPwvK5bitEy9uctIiouo9ltWWUrIziSJfF8SbWat\n", + "JcQomG4EqzWFzSgr+Tnm4HGupa7ri697s9lewHytRdtaFPmqC12ra5dFLs7VSdL3PcMgWOU0DAzO\n", + "kWVigVuWxPEkSfBFWTLNM9o5cmsIfmJZFvwsaeDGKDSKvpcAhU8fP6NwZJlnWWaOpwPzMlJXFUVu\n", + "icFzc3eDtYZlCey7EaXhi3bL9faaN6/f8Xh/x/7+gWo+kcaJ/f091bZk9F6G6lkMAWfLqSYxLjPa\n", + "ZGA9arUY1k1NTYExUltytqEGP1KXGVVZsGtaupdnmrZlmjqKssT7yH4/EKKmrHLy8gadXVFVt6Ak\n", + "eYswsIye/bFn2265vrphnALl1pJttlJ9y4RCM+/vUVNiu71iel6Y55EYpJ/o6fEJbMb27g1EL3AS\n", + "kIzm9HykMAfM+w1oQ1ltyMuS3S4j+cSyPtjyvODrD595fPqGGBM313fc3t7y+PxMW0vL5zzP7Pey\n", + "1nrvwUDbtiglXUDO5uvDe8D7wPF4vMh+nHPUdU2MC13XARITmWXiXX+8f+DTpw+yTWWObdPy1Vdf\n", + "0r55K06j05HD8WF1Ckkk33czCaZpRmu7CtVzyjKnH06rFCojhcg0+TU1aQ2YDpEUSoGB1jXf+4Bz\n", + "UmqntWKzqfF+4vNniaIry5K2bVeyaebx8ZFxnHDOrvDCZiWa3O+uTtPEDOMVKCNd5EoKtJZFoW0F\n", + "WYHLLc4K0aC11HpecDrkzUerywFkrcUqIYOKoqCupaojBE9KiAsok1FcyIkkuHtiDSYoiFFWORGP\n", + "e0L4NhzgzOD5daJVSuHHia7vGY4dmRNMtClKiqJgipIeY1dbodZKAlFXUbDRTjInnUWv/dAoRVrF\n", + "vKz4Y4wLXX+6iG/zLMO6HGsN4yhavaqStUowWfEYS32tiHeXlYW3VtjgruuwmSMsnvG059T1LEvE\n", + "ZmIPtNay3W5/QzOX55Ksk+LMNIm+b5omZu9ZQkClwOnwJAfz0JOSNP0p4yQY1hpO/YncOUyW0TQb\n", + "rLYsQfHwsse5QFbUXL91vHaa0/FAXjfsXx4Zu0dC6DExoDOJnlviggkGFmljTCEJfItDkeOTxypH\n", + "DJL8bZyE8laZo6xyen9iAQ7Hg0yJGspNw7a9JUYYl4mb2zt22yva2zuBd1JCDSOLn2jaLVpBmgeK\n", + "jdRzLLYQh5fWpARZvaUfn3Am4/bqmsPhhcEPzPPCz3/+CxSK7//+75O0k68NLENPvWsgh6QCCsgt\n", + "/PD9V8zeczoeOXQHpmmgqSt+9L0vsSry+PyAXyZAc3V1g9FCvC0xrA9qgUaSMliTA4nuNFKW0LZb\n", + "rnb1mskpwSBVVZDnJUopjsc9XX9gHCeuru4oipJhGJn8gnEWF6V2YkmBj/cPlE3D7etXzEHkXt1p\n", + "WLFKt96TgaKQa9b7hXEcOBxeqJucsfekGKlva5Q2pCIxDiOPT0e60wltNWVers2ZjmmaqesaEDIu\n", + "xPFyXy9eMMrDfuR4eEFrzaHr6LueLHe4cofNc0ku8zMYTZP/jq7n169v8VNkGkeiTwyLx6sBHcRW\n", + "Zs25qyOuU1Ip4vXsnA+YrSkt7nJTn2/wlL4jDVq+c0iZ6mL9OjtYRK8JWtnV52xpmoYQI6dOBL/S\n", + "sLdcIIGzjCHpRNAiV9puWvJM8J8lSHXo9fZaLtKUmGbP6XhAK2Es86ykbRpJYylyAqITDCs84MMC\n", + "IaDVWZs5X1b9GCPTNNB1i4Dn68SrteF06pimiboqGMZBNG3GMPtZ+sankaEfsCv7b5xcAn6eVjxH\n", + "ft6z/XKz2aCUtA6e8VMFDONpxTRXPawPjOPE6fiMso5p8VxVLTEEnl+eKd+8Is8ykYFUjt3VNWVV\n", + "UxWVuFNmzzCd6PYPnA5PEEautjt+8O57DO+/Ii2a//ThF8TjC/M8UBYFyzzQjyNLWr83ZQlrMM3p\n", + "dKTcVORFQYqRXFUoq8iNwSlDSgshKRIZ9W4DStFsdnz1/d8nRkVV1fT9kdevXrPZ7uSzAsZhZPHS\n", + "VomC2jn8KORDkWmMyUg6kdSEMRuGx4+kceLr0wOzX7hqS5bVgRWXSFVXzLOnRLIG5tOe51/+Bdu2\n", + "wm4qYZpVYNuUlOYGH0fKMqOdpRRPA3nm+FvF3+Lnv7B8un/k+fmB7XZLntfEGKiKkjyXNVyj6XyP\n", + "Topm2+C0Y1p7hGT6i4Q4k+ctLjP4ZeCwP/L49CAxcC6jyItLy+XpdKTdbMgyx+l0knzL4+kCB4ht\n", + "1zJ0vRSs5Rlx7VgaZ4VZZpZl4nQ6CEz1QaIIt1c7bGkoixLWskDnMvK8pG7KNekrokIU6G6Wa1v+\n", + "TrvKCAPWZWLVVIa2btBGcX3zCpc7zJpBavMMozUhCsxQFL+jh+btF28osoKnw4n7j585PA1inTMZ\n", + "tXOitUSBVpRlQdPWWJPjMnVJoAYuZv8zmaNUuuiyzuvH+d/PLpUzYXLGGF1WkBc5i5/x80yWFeRG\n", + "rViIsLQ2Ly4+2XEYGIee66trEQMXcmANg3xogx9YDp7MKqyCpC3d6cTz8wtfvntLXVXkRUnbbDge\n", + "j2RFQZY7lJak6a7vpZaBCEmmzvOheT70x3lmGAaaprlINc42TWM0p+6E956Hhwe0MXTTwDgMWG0w\n", + "SuOXBd+dVhVBlCoKl6NJGCsuisPhcCGszsnd54fUsixM034lnOB4OrDfH3h8fKSpa3RuMVGRVSW3\n", + "uxs2my1ZkbFta3a7G6pmR1GWGCX95C5z+JAzY3DGsn/uUcuCWvbUu3coVfLV997xfN+ilUiI5smj\n", + "D88s9585hYVpWfAexmmW6LbZc4onMSNME0VdUDStuE8Kmdqb4payraiqkvfv39O0Ow7HA8vKwFq7\n", + "XmtKrrslLmirxGmVF1BvMCiKyRPTQAgDOiSUySHNBDxZ2XJX1fzk3/xb/NzS9z37/Z6rZkOe5/ix\n", + "o1x6lMk4PN8L4280b5XDKo1KnqvrLb/65SPT2K2rbCl/1ntUSmy3G7Kywv3VL3h6+sinTz273Q0x\n", + "BjZNQ5ZZ6rrmuD/il4XH+ZFpmWSbsIa+P7E/CN44jtJL3zTthTQ5HjsUllevdmts2+OKIeZkueCm\n", + "0zRR1xUhRP7kT/6EP/3TP+XHP/4x0+zpxp4iL4h9T4wzeZ5d/h5JaNe0zQ0xCRmaVTmH08Tj05FN\n", + "XVJVFW1b0TQVXXciRqjrnM2mxdiceJZbxcg4S47mVbMVuWCKLOtkq5VaO+DNqj6R7M5IosxzMZro\n", + "39H1XCmDczk3NyUQ0FnkeFAEH7E6J6LJy5zd5opms6XZNOTrSnp2qyzf0VOF4MkywS+/i/mdRbtn\n", + "nPIcTHHWgInk50heOPIiByVumRDkSSZhxoFc2YuXGkRcneKCHwdZ0+O0Jr60zPNI13e87F94fHkG\n", + "lRj6kbKocHm5WiYTrnBUqabrexILeV7Q1jVxmXl4eJQbNSvIigKz2slUFAD/bJ2c5/miH1XKsN1u\n", + "sVYzjsI4ZllGUorKVGItMxY/ewY/oUlkRhK5+yUyDEeybOLq+oZN26JJJKU5nU6Xaf6svRzGQdjK\n", + "Uf6LLWYlAAAgAElEQVTex+dH9t2Rp+cXulNHXhTYt2+otwVX11dc7XZCQOUFxlqsSVS5BNs27ZaY\n", + "FK4UVn3MwcQFtZwYDs8Mx4GivmbRkbjk6GILNuLMQomimwbSwwt+karaFCMPj5+wx4If/eAHl/Vc\n", + "o1j8zDAPlM0NeVniikxcTVkOSjP0A8EvzCHgQyIc9lSbjYRIjKO0hxqHcQU6q0jWkrRDZS1qGVB6\n", + "QesKEPIjb24ZP3/i48NHvDb8xV/8nM/396QFfBE49Cc2w8j8/Mi8eA4PnxiXhTSOPPz6F+yu3+CH\n", + "Pb4/cjj0EjOnxBhxtuFaZ9iUW66tRanv86tfOT5//rhKdfI1/s1TlusDMATGeeZl/0K9afneF1/g\n", + "/czxuGcYOmL0zLPn/v4TXdfTdT3eB65217zs7/n6m18SI7y6e8ubN29Y/MTj0yOn0wHnpNI4z3NO\n", + "pxN/+pOfiHTKWdqqxqCwTkNYyLIKm+cUdbtWZGjyvOTq6gprHX3fryVv35JFz8/PWFtRNzkQ6YaZ\n", + "rLAUNqNtM1giWbkQl0hW5NLSmTkSCa3MCi8FhtXtpKORBCStUTERU2T5b2iOfntEECXeG3Kn2VXX\n", + "GBzzkMCBI2e33XF7fcP17jW77YaiynBOHB7nKfNcFTqvnuez1quu68t0dsZQzj7Yc9/JOS2nKKTD\n", + "Zp7nNSDArL0yE33X4WfJGYwhMa9C7127ZZwGrHPc3tzIwTVJEnSWiYD4ZneLyRzH7shf//WvCDGi\n", + "jOXj/Wc2VcGXX30PgHfvvyCEwK9+/Us+3X/kkOUoJG1GaU3V1CTiRQTfdT1aq8vPcy7SynPBrE6n\n", + "wwWOOE/ZMSUqJ1FZcQmkCjI/s/hAXdcEv1A3JcfjccV2Bcaoqopp9pfAYRAm0ntPdxrI85xpnOjH\n", + "gY+fvuHjxw88Pwhb3jQbumGmaXbcXr+T99UPhJTT9x1h8fh55vr6GpcLARaOnqurW+Yiw6RI/+J5\n", + "+viRcd7zVXVDCIldozF5ZAolKRNFRGYbrOlYgidFD1EIDJc5SQxfN4+4RGydUVUtZV3LgzfEi99e\n", + "4sImqcXNHE1TrVCIhF/0/cD13Q1125JcQTQWyTQya15mJcFF0YCW4GVtMvy8sH945Pj4wsPXT0yn\n", + "Weqf/cKnrx+wtuB0OrI/nHh5fqRwjrhpef7FZ54//CeywnA49Rhtubq55tgdmH2gbVuOxyMpKZ6f\n", + "n8St07a8e/fFKsEZaZqKupRJLYRAls3cvXmDyzJeDns+P9zz/ov3tM12TVAf8T6QkmaaPMMwApqq\n", + "koHl5WV/SYoqy5LNZosxihjF5eX9xDDMNI0EbvR9j1v7fbz3LGFhiZolaMl1tTlX17dkWcbxKH71\n", + "h4cHlFK8evWKqqp4eXlcZXuSYVpWFU1VMS+yyjvn1i3KsqkacqtghY1iCMyT3D/F6oTqlxHnrGQQ\n", + "nE7UZUVd1+R5Ljbk/0Yu+2/t0AxpISKgeZFXWFUS3xZM/YlaVby5e82ruy9oipq8EEYanyBPl7gr\n", + "1oiqM3N+tvJ1XXfxp54tYdLaV14sW8B6EUly+tlNsXgpp1rWN9yt2KpKkXkQkWy9tby+vcNZtx5u\n", + "8gEPw8DD4yPv33/Fm7tXUkZvv+TVq9c8PT0xzJ77h88kXbLZbkgxsd/vGaeBh4fPgjkaReYKwHA6\n", + "ndgfXyTZPROc5RzY0TTNd6AGuaG/G+R6tn5m1jJ7z9j1qAQYOYjbrCYlzdiPnDpJuznfCCmxlmFJ\n", + "x1CxrjIXC6XWXF1dMa0Ppbws0MawaVv2N0JSkBJN3bDEiePpEaVE8L4sHhY4HY9U1bhiX0qmmWmi\n", + "dBZlSurtDj8e+PXHT2TFDbbaoSyyEptIlVXERRN9pCsjKd2vm4NnXiJFWWKz7BKUa4zh1d0rnJMY\n", + "M6Mcr17dkGc5Smu600BTx7MLlTwX1Ua2BleUVS3/zCrCojDOkDAoVZEQuCAlSbVHF4A4epIzfNg/\n", + "8f/+2/+PD998IKCJfqQuSmY/cBr2fHr6mqou2DQ1db2lbAQuaOoaP0387K//gk/ffObv/Ph/pe8l\n", + "iKZpNlxdXVMUBT/7iz9fRd0DTdNye/uat29fs9+/YIzhZb8X4s9avvjiC169fo1fAtoaxmXhl7/8\n", + "FdYYnLPU1Q6tBfcOiyZGzTh2PD4+StRaVWDXPM2UEsfjYb0XDX5OzD6gtSXPhRG/3l1T5jVFVZGX\n", + "BdPipWFg9my312SZoyqrS16rQFzfJg8NQ8fT88PFw+6co2l3XO+uuHr9BaeXPX/585+hSbRNy+Hl\n", + "hbZpycqC4CUYORAxxooJZjkHWK/KGaSl4BwbR0qc1nrj/9rrt3Zo3t8/sGkmRruKzzG0141UQsSG\n", + "XXvDtmkotCUCfpRwglIlZtZCpzVXkRDxa4rJsiwoo4khUq/OlHPIhjFu9UBbskyCMJTSoq1MC2kJ\n", + "4EXCEpcAfrm4hwCqoiTGhDUZuStYQqAbeqq8FDfOSshkmcUVEiwQxgmrNTdXUk5XOccw9Nx/vuf2\n", + "assSPC+Pj8z9RLbKOwCU8gyjIgTNPC8CboeFLJfq3yWIHVBSXixl5ZjnhXx195wTZMqy4unpiaKU\n", + "ySMlOB06rBV87qwiyPNMCLAQmfyCKwumcea0P2KMpWkqxphEYO69YHda46yWpKNXd1xvNyxfLKtJ\n", + "QDJGq7IUW+QkkpAQ5b3U2nDqO0IUIXzhMtQKxGtt0NuWvN+RFa/44d/+3zDlTpLZ2walZNKeiUSX\n", + "oQqLBzSWmAL9OEiuwBLopxlrxVgQ47zqV8WWmzl5EDlrOa4Gg3zTYLFYZRiGgWzNHd1sr6QzaehZ\n", + "lomca3S5Idll7UDSoC1nhV+CNagEfvQH/zv/6ee/4jQOtE0tU/cyMQ4dJlP0/Yk8y9nubri9ueUc\n", + "5qu1JS8L6sctX35ZUa5OnKquIEV+/eGXQpLmJWFJtM2WLMvoTh1FUXFzcydSo6IQm2nV8vbNe77+\n", + "5gP3j4/c3d7yvbfvOBz2F8hrGAbpVHp3zevXr3l4eOSbbz6SuQ7nrEz722vubl9dwjPOYRq3t6+p\n", + "65qqKlf5kl8HHHNJOPLe03Un3Natw4oEs3x4/MA0DRgDr169pmkaGWJmj06ah8+P2Czj/Zc/4G53\n", + "R9k2GOeot81ls+ymkeADjAPVGqtY6vKSraCNYVomdNBkuRB2LneMU8fz45MMNGnC9/8DbZT/M1+/\n", + "/tUHmjpDZZYyL6jKkqooyLSjqm/RFgkpjp558sR1/XaZ/U6auWiqtDWYFEkhkrmMMs8l629Vult3\n", + "nhYDmdMoDGktcwshMg+C26QkB3BcPOM8SYHbGk+V5zm3t7frwRLYv+zp+452u6GwGeM4UlQlN19+\n", + "eak0PtvSxnHk4eFhLbOqMKZmGgY+r/0q4zhSlRLndr7Y4FtJlbgwugvpdXZInH/+cxqMnwO6lYi8\n", + "tt3S9z3eL7jVH332rc+zZBNaZ3nz5i0g/eJCei1opfGTQBhXV7sLC5pXMoV2XUffC9t6PnSLorh8\n", + "3+ccRFSJ0VZY+FamfT/NaGfxi6fdNChk4o+sh6VWGKvJ7RV9deQP/u7/waQMZbtBWYXSGWVRofTA\n", + "dDqt33Mizxv6IfD80l1i82JMKxar6fuB4/GItQLhVGugsjESfgFwGnpcnZM7R54bCu1gncBimFkW\n", + "RVoWMpOhokYKdQORhcXPZKYkGSUh08ikJOk+G/7P/+v/5u2rK37603+HsYbr7Fp0kJmlKmtubm7X\n", + "JPSSw+GF4/F4iUu72l5T1xXGaKbZo5VmGEWQvt/v2bTXK+Qkh1TbtlRlKY4aIh8/9WilKeuKx+dH\n", + "bK7ZXskWMA/xAvecw6oBHh+fmaYB0Lx69YpxnMgykQVuNpsVd5TjQ1Lly4uape+7i5nj7LRLKXE6\n", + "yQR37j4XJ5D0FMUkxpKX/QvHriOzlqauiSHyV3/1V2RZxve/9z22Vxv6sWcYOlh10K+ubjl2B+7v\n", + "H9i/vNDnZ9jKrCYSe7FRyv3rmWfhIEC63vcvjyRlJfvgdzWEeH88Mc2iQSNIjG/b5Hz55gdE84qX\n", + "pyd0DNRFBepb50BdVaJnRMI2Fu/JraMtC+k39h5rDFldSTXEPF1shHrtdRbyZLhE5KdVxmNWvLTM\n", + "C7nZMs1ut7vIm25ubnDO8eHrD8zBU9QVZZXTHU7c3N5we3vLw8MDnz59wlnL/f092VoS9e7de4wx\n", + "3N/fr/F0E3lmKcpC+kvSt7UN5ylRGSFhznCEtZaqqhnHkTybmP18CWfV2pDl2XphavHTTtMlmV0c\n", + "PmnFRIUQOHXdhXk/43bLEvh0/0jbtmw3rUxhxz3GODJbgIKizDBWoddE7XntlT7fKMMwrCYCdZF8\n", + "nQ/9LMvwSSo/vPegFJlzPD0+sWlb+To2IyxQb2+ZZoULkWgUS4gok+gmcVAtYSEsC8M4EJWlGxf2\n", + "h46uFwunwDBiebXW8fLygtbuO5mNEa3lgPzVr555/fYNGsU8e2bnycqC3Dlub28pXM43H37Nq1ev\n", + "sFVNyguCtuhkUWnGkljmIyrP0bpcxVmyyQTv+cu/+DPmZWK33RFTZJonbm9uL9iftW69iRXb7U7M\n", + "A9rQHY9kdg3sjoq5H3jqj4yr26wsK3G+5Tmn0/Hi4ImLvDcxRNp2Szf03D/c83R4pMxzkZut3u5z\n", + "XsHNzc3l2pOHsagHzBpLaKylyHOqqryQqPMsB/X5ofndjNdL1cmykGVO+n6MkaSjxfPpc4fWSmSH\n", + "MbHbXTFOE4fjI6fF8/z8QJFJJuayBP7sz/4jP/Q/4u76ltNpz+H5hbKsKeoKZwwWRZ45lEo8PT1y\n", + "f/9A359omoa2bWnblqcnh1KGzWazev6lffLNmx+Q5zKV+rj8F06sb1+/tUMzTp7oEqV2LICfF44v\n", + "PeE24pXnef+AX2bu7u5oqwbjDNoq1BpSEFPA++VCWFT5ObjiW7wyLAvjMBBmKas/J8HM87eHTYzL\n", + "mh5UsiyR56cnttutTK1VQZ6L62IYBu7v7+WA8UK01GVF6XJCLvjfsizs93uO+z3v3r1DAc9Pj/Rj\n", + "j3WaqqrWsFa5AH0MTMcjLpPDuluxRa01TV2vpU8JZw2PDwL03968wmhL22zWFKRpFSHnjOPEp0+f\n", + "eX5+pq4ltm0YJo7HDpd7hmGgO57ouo43b94wjxOHNT6r7wf2LzIJhKVj/zwyDSdcVjL7QAhHUIrd\n", + "VmpJhn68HPLnGLGzjEOcHhNdf6IsKspyxNiMdp34UcJi+7Xcarfd8vXXXzMOA+/fv6O2goe5rES7\n", + "gnaT0w8Dv/jFL/nxj/8XdNSXz88vC90wsz88S8p9DGuOPr8RzuL9zPF05Pvf/6GErxQFIUWeXp65\n", + "2u1YYpAwZW0ZhxG9zfnw4QNX2x13r19jrq/45k/+hKrOuaozlNuArlEklrEnxp6suiElK7imAtZl\n", + "/bR/xk8vDHMvkJFWtHrL8bBnHEf+3t/7eyil0Vrx8rJH0v2hH0aWxXM8dvTDns2mpa52GJuhF79i\n", + "c4oQFowRn/iZBBzXg+v29pab3Ya//cVb/uOf/5Rjd2QaF6Zhkv4nH3jz5s3qmCmwVrHf79e+c4GL\n", + "lBLr7bHvsNrwZfkeQDDecg2RXhsGnHMiL8vkIXU4HJimidPpRFmKGaIfB5pGjCfjMKOSyNuGoefN\n", + "my949+Y14zjwk5/8hIfPz6T1QZc7xy9/8SuOTy8ENRPnyDB5nv/6F9zdvYIgfEc/dMzzxPX1Ne/e\n", + "vUcptfIC2SUrFmRj894zTmInPnvp+R9xBI3jyD/4B/9AXB/zzD/5J/+EP/qjP+Kf/tN/yj//5/+c\n", + "u7s7AP7ZP/tn/ON//I8B+KM/+iP+xb/4Fxhj+OM//mP+0T/6R//Fr711mrKwuCJn6AaMsWzaKyqX\n", + "EyaxsXn/LIxgVYuX1lqWMBMneRKcw3q994zr0yuFQHc8Mq3s+TRNK3Ypk+l5tT8HG1xf3VDkBVlZ\n", + "rFpISTmXJ+S8kkPzWoCmLqvnmW0V3+8J75dLK19elnz6/HmdAIWgenp64v7zPfMc1sNGQhXOhNVZ\n", + "oH6OwBI8LefVKwmPuLm5pShyhkH8u0rpdT17YbPdcrXbkWU5N9evKIpa6n/XiLePnz6JBU4rXOb4\n", + "YvvF6sO1F6PAm6YhIgkz83THOApB9Pj0dLF4mtWOejgcLqVa54MzrK2G3yXmmqYlc7LCo8xlXSIo\n", + "xnFgHAdubmTyff/+PX/5Zz8jRiHy8jzj3NEdY2C32eKMY/+yX22PE1M/4OeZcZrZn07s93vJN13r\n", + "D7RWFzIwxsD33nzJZtNeDvTT+tm1bcvt7a0c9uNEkeckIl9//TWvX7+GmIjHE2VVULcbIk6cQHRA\n", + "Jg9BJV09KCWw0OWV+PjNB/Yvz0zLjO8n2m1LW1WMQ09d17y8vFDXzSV/IMZA3w9SgUIJaG5vb9bM\n", + "R3kQvLp7cwmdUEq2haIoePv27cXkMIwDc4h87/aGjx++4fF5j19mdu2W7//w9/iBgo8fP7IsC5vN\n", + "hjdv3lw2quPxxDgOa2NnxGWKq2shnmJKxJU/cM5dAmnOao55ni+xh+dfy/NixdQThXXsH17QCsq6\n", + "BqUvyUn/4T/8e1KSMPG62XB995ppUdRVvUICmrE/8vL8hLKJrNjwt7/8PkqLPLDveqyzvH4t70MM\n", + "CevMeg5IWZ84D2UzatsW6/K1PG8hKng5Pv/3H5pFUfCv/tW/oqpEgvL3//7f51//63+NUoo//MM/\n", + "5A//8A9/4/f/9Kc/5V/+y3/JT3/6Uz58+MA//If/kJ/97GcXnOS7rzc/ekvegDGOeUqM0wiqZEgL\n", + "0zwzLwmtLNM4ixxlWSSS30BKatWDWbS2DOPAab9nXDxLiujIhQwBVmY9XjCXb+1b4mm11uGsHFbb\n", + "7Xb1Zce13znhsgzvA09Pn/m93/t9irygH3oOhwNlVnBADq8YE2VZSBJLWBjGkc2mZbvdroeLoqqy\n", + "i9wJIpvNBq0Vx6P4bZumYZ5nPn/+TJ4X5FnB1dUVV1c7jsfjJWjEGFa/uGPsRn59+oaskPqIZQ4c\n", + "/AmXOeZpYrvdrO2AmnHomceJcVoL1Yzl7u7uEq2lV51qDIHD4UCzaTgeO8ZpYleVon2rK6zRssau\n", + "DPrGbSTCbmXxf6P50Gpenp5JUfCsQiv68URbNSyL5/l5L2RNW7N/OdBuRB4jSeAFz4cnUJof/ugH\n", + "fPPNRxLQHY90vYiuHx4+8+HD1+wPB0DjjMVmmbR+rnmikrLTMk0yifXDwDB2fPXVe0CtUWJmfU8M\n", + "Q9dTFDmbdovRBlxGXZfkRUVwBUnFy0SLUszDTFGumZiSvS7/PyW+/8Pv8x/+zf/Dp4dPfPn+e7KS\n", + "VzXvq3KtghBNYoiBzWZLdxpXaCNQ5Bk3t3cUecniPc8vj8QI87yg0KClkgQFxlg+fPhAWdacTife\n", + "vXtHXpR8/eEj33z8wNu3b8iLDIJe8dKM6+sbwiITq9GGxZ+j+ypOxx6FpW4l5tBHCZeeh7VqIsbf\n", + "cKqdpX9nmZ8Et0yrplqMH8fjkVPXX/Jhn08dh8OB3Xa7Sqa2lEWDMiBd6ye2t6/Z7bY8PT5xtd2x\n", + "BENQRqbL6Ng2t1inuX/8mru7W1K6FeXJy4GmbJnDxOl4RGnDZiNe/M2mvUBeZwWKGEQSN9ur//5D\n", + "E6QnmP+/vTONsfQq7/zv3de719a1uKvc7sXddrqbWJiJNCLBMv4QcDKDlAmMDBJBIyHlQyIURXwg\n", + "0XyIDYlQFCJFijSJBJmJYBSNFESACRqwcGRmIKaB2J0Eu6nGtXUtd7/vvpz5cN57bSdgjYPcnrTv\n", + "/5O7qlz3PVW3nnPO8/wXmO0erZb8hj+Ky/SXf/mXvPe978UwDDY3N7nnnnv45je/ydve9rZ/9rWL\n", + "W4tQCtJcIKwCPXLRCw1TMUizDFWzcXQDDUEax0SViqfUpxJISRGaTELyvJhRf1zXkxPP6sQx3bnz\n", + "PJ2djmSPUNpGaYpGHGfs7r9Io9nCUA10XcMw7KpQTXBdj8XFJRYXF+U1MoxI04h6q06Sg6opqJpM\n", + "YQZkVo6qIHQVNA3XsaTyyFBknEWW0Gw0MAz5S0vTHFDodDo4jgz08jyHNMkwNJkfs7e7S6/fl62D\n", + "sqRZ8zF0Dcdz0XSdIs3Jk5SQiKN+j3ASsLqyjOM4LC0tSR/GyYRIFGiGSrPVlAFbtoWmKRwfH7K2\n", + "vibDqLKCNEmhLKXSqlQwVZnWs7KwSFCpjWzdhKLErsxLdEXFNS1UTSWKYylzw0JRwbJ0+qMuYTLB\n", + "UBWKPGdpeZnWJEAzjjE0CJIx/fEQzVpHrVQdUmig0OsOqNV9gjTi5s2bmJrN4fEtgijk75+7zuHh\n", + "PmmWUhY5mqljWtJkNsvLyqZMYzRMWFz0yIocVQgc28Vzahz3jlE1DcPUSdKI0jChOnWXoiArMyxd\n", + "QzdN0iLG0CxIUhRNA8UAU0X3bMpogrAtNLWOIgqEokGZIKIJrfYCt05u4Xk2/d4J0WSCaeqoik6k\n", + "V3+8qo7wXRRF4PsuigppGmNpWjWE0cny2ox/W1SeqVJmbGG7tjwhRhFbd22ioFAIwd7uHqe37iaK\n", + "Yxp+YxZp8o//+A84jixUmia9D+qNBoICTVdZXOrMNvJOpyNFDoDnurPe6VQpNhoNXxFNkef5zBRm\n", + "yhmeDmNazSaWbeF5/ks867KkLIvq5qXTaNQpy5JGvY6uWHi6Q211TQ5KhYpheAwnI6I4JAhPKPKc\n", + "5559FkVR2Ni8G89xEWXBsD+k3mphWVL22e+NKMqEXq+H53kcHh4SRBMajQau69BudzBN45/Vq9dU\n", + "NMuy5C1veQs3btzgwx/+MJcuXeIv/uIv+MM//EM+85nP8MADD/DJT36SZrPJ/v7+Kwrk+vo6e3t7\n", + "P/obFwplWmCqKkqpkedQMxyMUpN5OQDVtS+O5S7l1XyKQiEIEuI4qBrOBaKUsjbPdWchTi+3zIdy\n", + "xtecksKnV2tDN9BUDdev0e33MVA5dWoVVZX8LTllVRkMhhwdHRKEkbyOmRpZJk/Bg8EQ3/VRFaSP\n", + "pBC4nosqZG9JKnxOZn0VebIcyZ04ilFUBcsyZ30fyRkNKXJBkkykebCi4tebmI6DgiApCkRO5QSl\n", + "oZYKlqYjNDi1uMzIkiRkqYgSM+9Cmb8iLcN0VUU3DZI4ZnNrc0Y7qdXrpGmGaTu0SsHaqmzV9AcD\n", + "ut2TKsTNJo5iGna98izMZ7u3HATJDawsBGVekFJgmToH+wcMqudKspQkTVjsdKh7HoZpsvPijnxt\n", + "w3wp4EqBLEsZjV2G/Yh+f0KR9tjZf5GbOy8SBmMMS3qT6qaL0JDZ1aWCaWsomo1pGNRrPmE0YTwe\n", + "oGoqnuszGA2J0gyBDJBrN5uYpjFjGARV4JiuG/iOx8lxj1auoikCVGlCoqgm6ThCVwuyCXgLDqgG\n", + "eTpCIyLJQu4+fZrhZECWFdTqTRm4Z+g4tidpcFUkbxznNOpt0jyVw47RkDwfYJ9InqTvS8ZBXhb4\n", + "joxDcVyXRr1eOfbYjMdjklSuJ8tLTp8+XWWlK2TpVEWncPXqW6Q8UpV2hMdHR+R5Vskk+7iuR6fT\n", + "Ic8z9vb2XsroqVo7qqrOONHyZ5bOhoLyNvRKcx0hBPV6g2nW1tRVo16rzXrUpmnNLA+n3OAoTEn6\n", + "J9i2hW7o5GXE8cGLmK5NnKQcTvZo1OtsbZ0hTiI838ZQocgEuiYQRS75vQg52dehXvfk4amKvuj1\n", + "BogSwnCf/f2dn6xoqqrKd77zHYbDIY888ghPPvkkH/7wh/mt3/otAD72sY/xkY98hD/5kz/5kf//\n", + "lOP4TzE8OMEoFTTboshV0kFIpsa0G4sYrklZOedkVRaP3LUEmipVPZNJIE+WTk32UyydaUjYNJ9G\n", + "atDFTCNrWZYMiE9ShsMRWZbRbNSp12vEJzFFWrCxtkKWptiOVUU6NOh2T8gyWbw93yVJUyZhRF6U\n", + "lFlGp9NB1wyCSYCCilcVvna9jqAkiMKZRdeU21YUBWEgaQ9mFXCVxBlBEc122yiJSfOcRqNBrVbD\n", + "sixGozH9fg9d19na2iKKItIkJs4KDFW66+i6hm2Z5IW085q2Kaamq9P/Nj0HTYVGwyeOYwYDOTxo\n", + "3tOSU99CzHTmQggajQaqptLtdqnX/Zn/sWlq2LaHqsqTmm3XsSs3KU1RsEyHuIjJ8pjlxTa94YgX\n", + "X3yRfv+Ek94RC50lXNOVvc4kYjKOcF2/YjokZGQIBUxdIwozjm7tQ5kwDkJEkeN5LqapowCqrmO6\n", + "khNIKR2vDFNm51BmFEXK0fGR5KaaNmUJSZ4xmYzwaz6OY6GMod8fMBgN6PZ60tg4maCbLkEYkWeH\n", + "Mi7athGKwDYddnYPGE4GGKbGVq7QXt1ClBl5FCCyGMs0+Jm3/QxRGGLZLkE0piykiKJm1Wg2m9Sa\n", + "dbpHR7iuQzYaUq+3WT91F25Dtj7GgwFJktDpLKBUzAVT18mKlF6vh2mas+GL63mYrs25s3cz6PUY\n", + "DeR8oFFvUqs1ZZ9fVXGciGAyQjc0VldXGQwGFEXB5uYWw+GwGuzU8Dwfy7bpdruVc5daiRKMqhiF\n", + "M8+H6aFF0+RAT3p0LjAcDmfSXmDm4yl9YOXpWc5Pplf6HNt2KQuI4ohBP8C2LKLxiHrDp9XpoKoq\n", + "7UaDtNoM4lSG6UVBUPVbR+RijPey/KHd3X06nZizZ89y7uw5xpMQXdfZ39+nLAu2tu7+yYrmFI1G\n", + "g5//+Z/nb//2b/nZn/3Z2cc/9KEP8e53vxuAtbU1dnZeqtK7u7usra39yO937W9uIBRVEmkXa9h1\n", + "jTITOK6Pm9tkSUoqBGYU4ft16cdYKhiG/KW4nqRpOI5DHMfEYUhncVG60wTR7A9+agRclvKXJF2A\n", + "5IDIceRkuNuTxhMbq6uziVqSxBRlzvGx3OEkoTqu9Oc5WZyBphKnMVm/wDJN8qwEpcSw61iqVQ2I\n", + "spmfp+yzyo2gLEDVYHVthTiSlIt63ZmpHjRNoxCG7HPVfExTFvzxZIzt2CwtLhEEAVE8kXZnjbLz\n", + "7sQAABS1SURBVBq6rkoFi23LgZMQuGHIYNgjSiJsx6LpN/B9D+nKLY2Iy6IAzcR0StIg4PvPP08Y\n", + "RTiOg2NLCWWjVZdOR0qJZRn0ej35eqY9k1aapkK9Jk+XSZRyeHjIxUvnKUWOnlk4VhNF1+h02tx7\n", + "Zou8FPT6PQajIZNxwGgSUYiCW91baF0Nrer76rbJcDRmMplI8reuYFpNNNuh1miiaCpZFuPXfFaW\n", + "V1CQPNM0TUiLrIoCKSkKkxLoj4YkYUhZyJz7JAmJwwiv0SAMYrI4xTQMSlRe3NklL0tcQwNVY39v\n", + "n87yAnla4Dg2QihMJmPiOEEoGpPxkCSKuU8rCcMJaZzS9F1M10EANc/BshxMFZIsI8sFmq6Q5zGj\n", + "XopjW9ju1LFqQJJGHP9A+lGORiMcx+HGD27gux71Wo3dg1s4tk1vMsJxfZr1Fo7lUQppuNvvnlDz\n", + "fY4ODyjCEsd1GQdjPNcDkaOoKfVGnfF4VFGBcpIoZtTvM5lMuP7ss+iGhuO61Gr1WR78dFLf7fbI\n", + "85x2u0Wz2azaeQJNk5zkvb09dnd3uX79OisrK6ysrCCEYDAYYFnWLMq3yEtM06Ld8un2jmQsRhCR\n", + "eQWqpaHbBn7TZzQaozkOHiqW4Ujp61jGbsdxTDAZg6LSPTzk+LjHoD/E8W2WlpZYXj7F5uYmF+49\n", + "x83tHX5w44eS9O85/MML2/zvb13D8zx5S3kVKOJVhJYnJyfouk6zKdUsjzzyCL/927/NpUuXWFlZ\n", + "AeD3f//3+da3vsWf//mfc/36dd73vvfxzW9+czYIeuGFF/7ZaVNRFK5eWiDVdDQ1RzEVUAWuarG5\n", + "djdtp0MqMur1Jq1ag1ajKRv0ponnWnIwk6YkaVpZ4kvS6vQUN3ULn8bHyqFEWcUeSFPT6UDF932C\n", + "IKDRaOC40lBYVTR0XZ15WiqKMitmYSgLpygzDMsgy3PCIKh2SkGaTknhrdkpuSikxjsMQ05OTrDM\n", + "qs9IIbOGFANDN0krLf2U/Nvt98mynHa7TSkERSn9ESVkw73daZGmsoFt6Ua1liZJlnHSPal06dK2\n", + "azQaInIZcFZvNKS5bCG1vOPxGKFKXX7veMBoOKbVanJ6c4NTp5akd2LF+5TXyITvf//7tNttZK67\n", + "h2XZGLo0k+73huztHXDu/BatVh2lmp6HYUiSxNTrTbIslSeCKsZY6CaObUu/yLHspcVRTElOWcL+\n", + "3i2iOGJpeRnTMMgpEaWkmUXjCXt7u7TbbU6dOgVIR/lS00mSSMbyxgV5npGkUUWDCTBUg16/S5RE\n", + "aKpBGIU4tsvq0jLNepMomtBaaEvKlF9nMOwhKPFcl3q9gedIAxbdMFjfWKXdWqIsBa4rSfR5lpLG\n", + "GVmZS1MZTWYCaZpOXoLjyGKUZtKYOE3SSmUj7fjyXA7EkiSlVqsxGAzY3d3Fc10Wmm3JsjDl4HEw\n", + "HmHbNqurp0jTlBs3trEdm7P3nGEykUyBhYUFoODw8JAkkX4LyyunCIOQZ555RrYiTJ1mo0UYBtx1\n", + "12nCMGU87KNoAsOQUcZxHFNWrTPTNKvY3+rmZBocHR1Tq9XJM8luGQzl9bfRaMiN15ZtIsexGfQl\n", + "XcwwTYosmzn5D4cTlheXeebb/4fzF+4lCkMG/T7Li4uMRgPKEilQETJosD8cyBtRrUGWFZimg2Xb\n", + "LHTaNBsNms0mL9y4wXg0YmNjA1XV6Pd7CKWQ6tdqeOl5Hm99x7//sRr0Vz1pHhwc8IEPfGBWYB57\n", + "7DEeeugh3v/+9/Od73wHRVHY2trij//4jwG4ePEiv/RLv8TFixfRdZ0/+qM/+rHX8zCrMskNDQdF\n", + "2u8LQZ6XaLrK+tK6lGRZNrbl4DkejuUgtIKkSm/UZnSSkigKCQJJT5k1yqveoDTx8BmPh7hujVpN\n", + "XjENw5jZq/m+z2A4pLO4wEmvS6PekNfw0bDK9kkBBde12dvbp9mq4egOjuNWul2ZeOd5Jr1ej/F4\n", + "TKfTQWZJyxPJzZ0D1ldPMRwGlWdnKonDQqm04/JnNXUUMg2DOJb5J8PRCEXVWFpqzXps04KMIsjS\n", + "DMuQOvo8l9ng7XZjRgWR1mAOJ8cn2KZJs9mUlne6zBV3a4LDw0NqtRqnVttYtmQcBMGEOG4xmYTS\n", + "sEQBRZH8vLvvPsPJybGcrGbZjN1QFPIk0em0WF5Z4Zlrf8dbLl+cTaeHwwHD4U021tfRmjWyqi9n\n", + "VEoX21LQDQ/f9xhPSjTVI45TTp9eRVF09nZ3cdpt/FodpRSEcYSSF9y1cReOY+H7Mj42iiKEqqPr\n", + "bcnJFZXbu6oShNJ0OUkzGa5m6Hiey3Ak7cXCQMol1/0NGWan6SRxRMdewLJs/MoVve54LCx2sG0P\n", + "TbeYBAMc10RXBE/9zdO8/d/+G0ChbtewdIPxZDLzZjUrPwRQsA3zJRvCiqeqajrxJGQymWCaJtvb\n", + "22iaxtbmJsF4Qppl9AZ9FpYW2TxzN8PhgJs3b3Jj+wf4nk+r1UJRBMfHJ6BIu8DReET3pMvKygqm\n", + "4XJ0eIJAY2lxgUuXLkkjj/GEIi9ZaXZ4/sY2FBlLCwusb5zG9XxGowFFXhDnOb7vMx6PuXbtGvff\n", + "fz9FUfDF//kN7rv3LCcnJ1y98tOMRgFRlFV/kyVZGpGnCadWVzk6PpJTa0WgqALP9+l1+5imxeLC\n", + "AqPREN+v0T08Yn93j/2jW7Q6i3i1OrW6PxNkLK+t01hYoOZLgUSeFdTrTdI4IYrkoebo6Ajf8xCl\n", + "nMrXfJ+lpSXCKKRW96WjkmnQHwxerSy++knz9YKiKJy9ryG5kqqOqkqChqtrXDh9gbtOn2G9s1pZ\n", + "vKlSgaLJAhmGMt7Td1yEKv0wNU2dWdpPdclBECCKEsd2qNfrDAYDdMvAcWwcx2UwGGCa0nFH9kKl\n", + "EsSy7VkzW0EOogxNq2z0pXFvmmdYtkmr1aIoyuqNJzi1eqq62mez06uCwKoiND7z3/+K//Dv3kme\n", + "QxgG2I6FIgS2ZaNqKqMgRFU1mYUiAEX+ca+srJAXBYYpd2d5QpUFtihkYmVcxZ6qKtXVKauu+Wol\n", + "p3yJMzeNDC6zHN+X/bIsTZERvDmmacnTqyJjUGu1Gp5XI8sjhCgwDAsFjShK2d7eZmlpgaLIK1MH\n", + "j6OjExQFao06a6vL/LfPfYFf/U//kaIsqujiHBmRLKe7eSl3evKMJE6lLlhAEAbouoJluoxGEzld\n", + "jXMKSoIgYG1tjSAI6HW7IBQsW/a7a7WaNF5OY0oU2XsUkJclAkGRFzJgTjdpt9ugarNJeZ6nFFmG\n", + "oRtQpZnGUQIls/eY79dwbJtms0m/35e8zhKai0v0eodEkzGdZptP/Zf/yn/+2EfBdtDSALUsSfMS\n", + "XVEQiiJjjwvpoqQgA/lUVWM4GFCUObppYJjSeUdVVVRFkrJty2Q0HKBouixyg151xS3Icpl1vrq6\n", + "ymQ0JkkixkGE63qsrp/iH/7+OUajgPZCh431DTRFI02iio6nMRwNiJIEIVSWV5bZ39shSzLCioJ1\n", + "18YmJSmWaZGlCXlWMAkCbt68OaMf/Y+/+l985Fc/RLfbw3EcVpaXGY7GaJpBv9fF81wGvZ60tdM1\n", + "XN9mOBxQZAWKqlCictztcXrzbmmVWEpHs4V2mx/u7mO7HgiFTqdFs9GWswJdpds9YjTsU+YyXtg0\n", + "DO7a3OL45BgA13E4PDzEsm2yNGV5eZlSCIIwpFZvoKgq29vbWJbBw49+4F920nw9IXR5ygSBKKTf\n", + "ZL21xOm1Le5ZOY1bd9Ffpq3WNJ1wPCGvNOhJkhAmEXEczwYl04IZhhF5Lh2MVEPn4OiQJElYtBdJ\n", + "05w0HVZX+YQwnFTZKXLCfOtgf6b5XVhYJIoiojgmz2A0GWNZFkvLy9LZfTJBVZXqelWQphlHRyc0\n", + "GvVZM9x2HZI4ks5BRUkUpViWJ/O8JxGqgDTJqDVquK6DYTtyQxCCsnwp3waUmaRS06X7TFnKKWYY\n", + "BNVUXE78pS7doiiimRVeWZazdsuU8J2Uyex6VeYFk8mYZqOGYVozr8Y0zbjnnnvQdYMolgYUSZIB\n", + "ZaUx1smyHNe1pcoozVjotCnyArcuixfIZFABGJaJKeTQZjgaUSLwPGl2a3g2nqdUfD/ZXlE1SJN8\n", + "1isbZTJlsLXQYTgYzKwAoWQwGOH7VV65qlIWAtd1CCaBbCvYNmtraxiGwXA4xLJMWu0Gw+GIosjJ\n", + "y5I0D1EKmEQBqi7dx1uNJqZh0e50pMFyxRCwHIvT9bswdINBv8+ge4v+UZejky6L7VUMw8F06jJb\n", + "qdBJ4zFJEtNqNiRNLo6q946K6zhkeY4QKq3FJcJwxGQyJsuLiucrebOKonDc7fPCC9/n/IVLdA+7\n", + "2JbFwkKHZrPF0VEfr15nd++HxEnEufMX0DUpI93d+yHrd22gIBkmt24dMB7LALJWq0FWZLKdkOSc\n", + "Pn0WXbOp1Rs4ls2g1yOMQ3p9eUCYjCf4ns808nppaZmDg4OqlRdzeHjEysoKQTDhu3/3DO3WAr7f\n", + "oNluomsavYHCwfERq6trGHYLX5PMl6WFRXrdAVmm88Mb+9z/Uz/FxvoyQTimUW9g2XWyskCIovLa\n", + "lMFrR0dHpHlOrdGh3zvBciy6xyf0B99j8+4tAJI058rVn+ao2yWOY+rtDnGSoJgmYRThui4bGxvs\n", + "7+++au16w4pmreGh60BZEIcFtaUVrm7dy/rSCl6rhaYU5EU2kz4C5GWOIhSiMIKyQLfM2VUmz2Vc\n", + "7LS/GUURvX6f6NYtWq3WzBRV6q5Vokh6JjqONdNfT6WAU8PTKIro9/tEcYLj13C8OkUm6UOyd2MS\n", + "BBMWOoukWYmqSgMM2duRqh4U0KtpoaEbNJsdRCmwXRttouPoJq12E0UTREmC6XoyKCrPMQ1JjZr6\n", + "F05lgZqqM+gPsG0bRdGwLCkzS9OEZrMJSFMNx5FXyKIyofU8f0byL4qSZq1ZDXFyTN2i0aiTFxmK\n", + "Ap3OBnmeMwkCjo6O8DyfUkjFlNyBS7yawXgsOYRT5+68SNBNhUv33UeYZtWUVVKbSmRftsxSTN3A\n", + "cR1pPlsZiliGPCHrukmSZKiqShyHM5ux8XjMYDTAr8sQrJ0jqeMPwpAiz9nc3JTvhYporWoa44nU\n", + "Hi8sLlKW0nW/5rvYy4vcOtzn5g+HaIpNmsbYjoPrtXANB9/3ObW+ShyGqBVHWNc0dENGnwghUBUV\n", + "BBwc3KIscwbDIZbn8lOra6imilAhCodYliLzrqwGTmpRqiqCosqNl3ScXAgs30WUgjAI0SyDmlan\n", + "yCQLZDDoV+FoDqIsOHfPGVRVkfaDFdUtjo+5ub2N5dksnVqlGAkmQcCgN2BjfR1RFCRFgaELXnzx\n", + "RZaXlzh79ixpKk2l8yKTPFdF5dTqusyo0oAyo+Zt0Ov18TwHMIh8GW2xvLqK47jkWcpdG5sMBgPW\n", + "19a4994Llb/tJp2DBZ599jlUxeTy1fPs7u1y7XvfxbJMTno9ScYfT1hbXyMYDUmTAFUTPPi2n2Zx\n", + "cYXDw0Nc1yEOU8qSqkefYlk2juuSxYJWq85oEMrsIieh1+9hVhtqWTIz25lMJrQ7izNnr2bLYDQc\n", + "UPN8OVQimhnu/Di8IdfzK1eu8N3vfvd2v+wcc8wxx/8T3v72t/Pkk0/+yM+9IUVzjjnmmONfK149\n", + "FX2OOeaYY45XYF4055hjjjleA2570fzyl7/MhQsXOHv2LJ/4xCdu98u/rvjgBz/I8vIy999//+xj\n", + "vV6Phx9+mHPnzvHOd76Twcs4YE888QRnz57lwoUL/PVf//Ub8cg/MXZ2dvi5n/s5Ll26xH333cen\n", + "PvUp4M5fdxzHPPjgg1y5coWLFy/y0Y9+FLjz1z1FURRcvXp1pgZ8s6wbAHEbkee5OHPmjNje3hZp\n", + "morLly+L69ev385HeF3x9a9/XXz7298W99133+xjv/EbvyE+8YlPCCGE+PjHPy5+8zd/UwghxHPP\n", + "PScuX74s0jQV29vb4syZM6IoijfkuX8SHBwciGvXrgkhhBiPx+LcuXPi+vXrd/y6hRAiCAIhhBBZ\n", + "lokHH3xQPPXUU2+KdQshxCc/+Unxvve9T7z73e8WQtz57/OX47YWzaefflo88sgjs38/8cQT4okn\n", + "nridj/C6Y3t7+xVF8/z58+LWrVtCCFlgzp8/L4QQ4vHHHxcf//jHZ1/3yCOPiG984xu392FfB/zC\n", + "L/yC+MpXvvKmWncQBOKBBx4Qzz777Jti3Ts7O+Khhx4SX/3qV8W73vUuIcSb631+W6/ne3t7bGxs\n", + "zP79qtZxdwgODw+l+zewvLzM4eEhAPv7+6yvr8++7k74Wdy8eZNr167x4IMPvinWXZYlV65cYXl5\n", + "edaieDOs+9d//df5vd/7vVeYi78Z1j3FbS2aP06H/mbBy+OAf9zn/7ViMpnwnve8hz/4gz+gVqu9\n", + "4nN36rqntom7u7t8/etf52tf+9orPn8nrvsLX/gCS0tLXL169cfKDO/Edb8ct7Vo/lPruJ2dnVfs\n", + "QncilpeXuXXrFiANUKZqg9dio/f/O7Is4z3veQ+PPfYYv/iLvwi8OdY9xdQ28Zlnnrnj1/3000/z\n", + "+c9/nq2tLd773vfy1a9+lccee+yOX/fLcVuL5gMPPMDzzz8/E/d/7nOf49FHH72dj3Db8eijj/Lp\n", + "T38agE9/+tOzovLoo4/y2c9+ljSVphfPP/88b33rW9/IR/0XQQjBr/zKr3Dx4kV+7dd+bfbxO33d\n", + "JycnswlxFEV85Stf4erVq3f8uh9//HF2dnbY3t7ms5/9LO94xzv4sz/7szt+3a/A7W6ifvGLXxTn\n", + "zp0TZ86cEY8//vjtfvnXFb/8y78sTp06JQzDEOvr6+JP//RPRbfbFQ899JA4e/asePjhh0W/3599\n", + "/e/8zu+IM2fOiPPnz4svf/nLb+CT/8vx1FNPCUVRxOXLl8WVK1fElStXxJe+9KU7ft3f+973xNWr\n", + "V8Xly5fF/fffL373d39XCCHu+HW/HE8++eRsev5mWvdcRjnHHHPM8RowVwTNMcccc7wGzIvmHHPM\n", + "McdrwLxozjHHHHO8BsyL5hxzzDHHa8C8aM4xxxxzvAbMi+Ycc8wxx2vAvGjOMcccc7wGzIvmHHPM\n", + "McdrwP8F7/c7xJLyUh8AAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "prediction shape: (1000,)\n", - "predicted class: 281\n" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEACAYAAAC+gnFaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text": [ - "" - ] - } - ], - "prompt_number": 5 - }, + "output_type": "display_data" + } + ], + "source": [ + "input_image = caffe.io.load_image(IMAGE_FILE)\n", + "plt.imshow(input_image)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Time to classify. The default is to actually do 10 predictions, cropping the center and corners of the image as well as their mirrored versions, and average over the predictions:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "\n", - "Now, why don't we see how long it takes to perform the classification end to end? This result is run from an Intel i5 CPU, so you may observe some performance differences." + "name": "stdout", + "output_type": "stream", + "text": [ + "prediction shape: (1000,)\n", + "predicted class: 281\n" ] }, { - "cell_type": "code", - "collapsed": false, - "input": [ - "%timeit net.predict([input_image])" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEACAYAAAC+gnFaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAG2ZJREFUeJzt3X9w02WCx/FPnOaOG1xRKmJJulNoCgnQ1q4pDMsyU1dK\n", + "B06ytDo7XRn0dnvawUF393bXvX92FrxZseM4t2Jv5rqcv3VL//DGuh7magczQBVyCgyO9UfLtWcI\n", + "1mWBrvxQS+Nzf9TGJIX0BykBnvdrJtN8v9/n+ebJY/L95Hm+3y86jDFGAABrXZXtBgAAsosgAADL\n", + "EQQAYDmCAAAsRxAAgOUIAgCw3KhBEAwG5fV6VVRUpIaGhhHbW1tbVVpaqrKyMt18883asWNHfFtB\n", + "QYFKSkpUVlamRYsWZbblAICMcKS7jyAWi2nevHlqb2+Xy+VSeXm5mpub5fP54mVOnz6tqVOnSpLe\n", + "ffddVVdXq7u7W5I0e/ZsvfPOO5o+ffokvw0AwESlHRGEw2F5PB4VFBTI6XSqtrZWra2tSWWGQ0CS\n", + "Tp06peuvvz5pO/erAcClLW0QRKNR5efnx5fdbrei0eiIci+//LJ8Pp9WrlypLVu2xNc7HA4tX75c\n", + "fr9fW7duzWCzAQCZkpNuo8PhGNNO1qxZozVr1mjXrl1at26dPvzwQ0lSR0eH8vLydPToUVVWVsrr\n", + "9WrZsmUX3moAQMakDQKXy6VIJBJfjkQicrvd5y2/bNkyDQ4O6tixY8rNzVVeXp4kacaMGaqurlY4\n", + "HB4RBB6PR4cOHbqQ9wAA1iksLIyfj71QaaeG/H6/urq61Nvbq4GBAbW0tCgQCCSVOXToUPw8wL59\n", + "+yRJubm5OnPmjE6ePClp6IRyW1ubiouLR7zGcH0eRr/97W+z3oZL5UFf0Bf0RfpHJn9Apx0R5OTk\n", + "qLGxUVVVVYrFYqqrq5PP51NTU5Mkqb6+Xi+99JKee+45OZ1OXX311dq2bZskqa+vTzU1NZKkwcFB\n", + "rV27VitWrMhYwwEAmZE2CCRp5cqVWrlyZdK6+vr6+PMHH3xQDz744Ih6c+bM0YEDBzLQRADAZOLO\n", + "4ktIRUVFtptwyaAvvkFffIO+mBxpbyi7KA1wOJTlJgDAZSeTx05GBABgOYIAACxHEACA5QgCALAc\n", + "QQAAliMIAMByBAEAWI4gAADLEQQAYDmCAAAsRxAAgOUIAgCwHEEAAJYjCADAcgQBAFiOIAAAyxEE\n", + "AGA5ggAALEcQAIDlCAIL7dwpTZmS7VYAuFQQBBb6n/+Rvvwy260AcKkYNQiCwaC8Xq+KiorU0NAw\n", + "Yntra6tKS0tVVlamm2++WTt27BhzXWSHw5HtFgC4lDiMMeZ8G2OxmObNm6f29na5XC6Vl5erublZ\n", + "Pp8vXub06dOaOnWqJOndd99VdXW1uru7x1RXkhwOh9I0AZPgX/9V+qd/kuh24PKVyWNn2hFBOByW\n", + "x+NRQUGBnE6namtr1dramlRmOAQk6dSpU7r++uvHXBfZwYgAQKK0QRCNRpWfnx9fdrvdikajI8q9\n", + "/PLL8vl8WrlypbZs2TKuurj4CAIAiXLSbXSM8YixZs0arVmzRrt27dK6dev0wQcfjKsRGzdujD+v\n", + "qKhQRUXFuOoDwJUuFAopFApNyr7TBoHL5VIkEokvRyIRud3u85ZftmyZBgcHdfz4cbnd7jHXTQwC\n", + "TD5GBMDlJ/VH8qZNmzK277RTQ36/X11dXert7dXAwIBaWloUCASSyhw6dCh+wmLfvn2SpNzc3DHV\n", + "RXYQBAASpR0R5OTkqLGxUVVVVYrFYqqrq5PP51NTU5Mkqb6+Xi+99JKee+45OZ1OXX311dq2bVva\n", + "usg+ggBAorSXj16UBnD56EXX2Cjdfz+XjwKXs4t2+SiuTIwIACQiCCxEEABIRBBYiCAAkIggsBBB\n", + "ACARQWAhggBAIoLAQgQBgEQEAQBYjiCwECMCAIkIAgsRBAASEQQWIggAJCIILEQQAEhEEACA5QgC\n", + "CzEiAJCIILAQQQAgEUFgIYIAQCKCAAAsRxBYiBEBgEQEgYUIAgCJCAILEQQAEhEEFiIIACQiCADA\n", + "cgSBhRgRAEhEEFiIIACQaNQgCAaD8nq9KioqUkNDw4jtL774okpLS1VSUqKlS5fq4MGD8W0FBQUq\n", + "KSlRWVmZFi1alNmWY8IIAgCJctJtjMVi2rBhg9rb2+VyuVReXq5AICCfzxcvM2fOHO3cuVPTpk1T\n", + "MBjUvffeqz179kiSHA6HQqGQpk+fPrnvAgAwYWlHBOFwWB6PRwUFBXI6naqtrVVra2tSmSVLlmja\n", + "tGmSpMWLF+vw4cNJ240xGW4yLtRVTAgCSJD2kBCNRpWfnx9fdrvdikaj5y3/5JNPatWqVfFlh8Oh\n", + "5cuXy+/3a+vWrRloLjKBqSEAidJODTnGccR444039NRTT6mjoyO+rqOjQ3l5eTp69KgqKyvl9Xq1\n", + "bNmyEXU3btwYf15RUaGKiooxvy4A2CAUCikUCk3KvtMGgcvlUiQSiS9HIhG53e4R5Q4ePKh77rlH\n", + "wWBQ1113XXx9Xl6eJGnGjBmqrq5WOBweNQgw+RgRAJef1B/JmzZtyti+004N+f1+dXV1qbe3VwMD\n", + "A2ppaVEgEEgq8/HHH6umpkYvvPCCPB5PfP2ZM2d08uRJSdLp06fV1tam4uLijDUcE0cQAEiUdkSQ\n", + "k5OjxsZGVVVVKRaLqa6uTj6fT01NTZKk+vp6PfTQQzpx4oTWr18vSXI6nQqHw+rr61NNTY0kaXBw\n", + "UGvXrtWKFSsm+e1gLAgCAIkcJsuX9TgcDq4susj+8z+l22+X6Hbg8pXJYycXElqIEQGARASBhQgC\n", + "AIkIAgsRBAASEQQWIggAJCIILMbJYgASQWCl4QAgCABIBIHVCAIAEkFgpeEA+Oqr7LYDwKWBILAY\n", + "IwIAEkFgNYIAgEQQWImTxQASEQQW4xwBAIkgsBIjAgCJCAKLEQQAJILASowIACQiCCzGOQIAEkFg\n", + "JUYEABIRBBYjCABIBIHVCAIAEkFgJf6tIQCJCAKLMSIAIBEEVuJkMYBEBIHFCAIA0hiCIBgMyuv1\n", + "qqioSA0NDSO2v/jiiyotLVVJSYmWLl2qgwcPjrkusoNzBAASpQ2CWCymDRs2KBgMqrOzU83NzXr/\n", + "/feTysyZM0c7d+7UwYMH9Zvf/Eb33nvvmOsiu/73f7PdAgCXgrRBEA6H5fF4VFBQIKfTqdraWrW2\n", + "tiaVWbJkiaZNmyZJWrx4sQ4fPjzmusiO4RHB974n7duX3bYAyL60QRCNRpWfnx9fdrvdikaj5y3/\n", + "5JNPatWqVROqi+z4/PNstwBAtuWk2+hwOMa8ozfeeENPPfWUOjo6xl1348aN8ecVFRWqqKgYc10A\n", + "sEEoFFIoFJqUfacNApfLpUgkEl+ORCJyu90jyh08eFD33HOPgsGgrrvuunHVlZKDAJOPq4WAy0/q\n", + "j+RNmzZlbN9pp4b8fr+6urrU29urgYEBtbS0KBAIJJX5+OOPVVNToxdeeEEej2dcdQEA2Zd2RJCT\n", + "k6PGxkZVVVUpFouprq5OPp9PTU1NkqT6+no99NBDOnHihNavXy9JcjqdCofD562L7GNEACCRw5js\n", + "HhYcDoey3ATr/PGP0tq1Q89375aWLs1uewCMXyaPndxZbCFyF0AiggAALEcQAIDlCAILMTUEIBFB\n", + "AACWIwgsxIgAQCKCAAAsRxBYiBEBgEQEAQBYjiCwECMCAIkIAgCwHEEAAJYjCCzE1BCARAQBAFiO\n", + "ILAQIwIAiQgCALAcQWAhRgQAEhEEAGA5ggAALEcQWIipIQCJCAIAsBxBYCFGBAASEQQAYLlRgyAY\n", + "DMrr9aqoqEgNDQ0jtn/wwQdasmSJpkyZosceeyxpW0FBgUpKSlRWVqZFixZlrtW4IIwIACTKSbcx\n", + "Fotpw4YNam9vl8vlUnl5uQKBgHw+X7xMbm6unnjiCb388ssj6jscDoVCIU2fPj3zLQcAZETaEUE4\n", + "HJbH41FBQYGcTqdqa2vV2tqaVGbGjBny+/1yOp3n3Ifh5+clh/8kABKlDYJoNKr8/Pz4stvtVjQa\n", + "HfPOHQ6Hli9fLr/fr61bt068lQCASZN2asjhcFzQzjs6OpSXl6ejR4+qsrJSXq9Xy5YtG1Fu48aN\n", + "8ecVFRWqqKi4oNcFgCtNKBRSKBSalH2nDQKXy6VIJBJfjkQicrvdY955Xl6epKHpo+rqaoXD4VGD\n", + "AJOPqSHg8pP6I3nTpk0Z23faqSG/36+uri719vZqYGBALS0tCgQC5yybei7gzJkzOnnypCTp9OnT\n", + "amtrU3FxcYaaDQDIlLQjgpycHDU2NqqqqkqxWEx1dXXy+XxqamqSJNXX16uvr0/l5eX67LPPdNVV\n", + "V+nxxx9XZ2en/vznP6umpkaSNDg4qLVr12rFihWT/44wKkYEABI5TJYv63E4HFxZdJH9+79L69cP\n", + "Pd+9W1q6NLvtATB+mTx2cmexhchdAIkIAgCwHEEAAJYjCCzE1BCARAQBAFiOILAQIwIAiQgCyxEK\n", + "AAgCCyUe/AkCAAQBAFiOILAQIwIAiQgCyxEEAAgCALAcQWAhpoYAJCIILEcQACAILMTBH0AigsBy\n", + "hAIAgsBCnCMAkIggAADLEQSWY0QAgCCwEFNDABIRBABgOYLAQowIACQiCCxHEAAYNQiCwaC8Xq+K\n", + "iorU0NAwYvsHH3ygJUuWaMqUKXrsscfGVRcX33/8h/SnP2W7FQAuJWmDIBaLacOGDQoGg+rs7FRz\n", + "c7Pef//9pDK5ubl64okn9Mtf/nLcdXHxvfuu9OGH3ywzIgCQNgjC4bA8Ho8KCgrkdDpVW1ur1tbW\n", + "pDIzZsyQ3++X0+kcd11cfMZIsVjyMgC7pQ2CaDSq/Pz8+LLb7VY0Gh3Tji+kLibPV18lBwEA5KTb\n", + "6HA4Jrzj8dTduHFj/HlFRYUqKiom/LpIjxEBcHkKhUIKhUKTsu+0QeByuRSJROLLkUhEbrd7TDse\n", + "T93EIMDkSg0CAJeH1B/JmzZtyti+004N+f1+dXV1qbe3VwMDA2ppaVEgEDhnWZPy03I8dXHxMCIA\n", + "kCrtiCAnJ0eNjY2qqqpSLBZTXV2dfD6fmpqaJEn19fXq6+tTeXm5PvvsM1111VV6/PHH1dnZqauv\n", + "vvqcdZFdqecICAIADpP6U/5iN8DhGDGawOS5917p6aelwcGh5T/9Sbrttuy2CcD4ZfLYyZ3FlmFq\n", + "CEAqgsAyxvBvDQFIRhBY5quvst0CAJcagsAyqSMARgQACALLEAQAUhEElmFqCEAqgsAyjAgApCII\n", + "LEMQAEhFEFiGAz+AVASBZVLPERAMAAgCyzA1BCAVQWAZDvwAUhEElmFqCEAqgsAyTA0BSEUQWIYD\n", + "P4BUBIFlGBEASEUQWIZzBABSEQSW4cAPIBVBYBmmhgCkIggsw9QQgFQEgWU48ANIRRBYhqkhAKkI\n", + "AssQBABSjRoEwWBQXq9XRUVFamhoOGeZBx54QEVFRSotLdX+/fvj6wsKClRSUqKysjItWrQoc63G\n", + "hPF/KAOQKifdxlgspg0bNqi9vV0ul0vl5eUKBALy+XzxMtu3b1d3d7e6urq0d+9erV+/Xnv27JEk\n", + "ORwOhUIhTZ8+fXLfBcaMEQGAVGlHBOFwWB6PRwUFBXI6naqtrVVra2tSmVdeeUV33323JGnx4sXq\n", + "7+/Xp59+Gt9uONJcUggCAKnSBkE0GlV+fn582e12KxqNjrmMw+HQ8uXL5ff7tXXr1ky2GxPE1BCA\n", + "VGmnhhwOx5h2cr5f/bt379asWbN09OhRVVZWyuv1atmyZSPKbdy4Mf68oqJCFRUVY3pdjB8jAuDy\n", + "FAqFFAqFJmXfaYPA5XIpEonElyORiNxud9oyhw8flsvlkiTNmjVLkjRjxgxVV1crHA6PGgSYXKkH\n", + "/rY26euZPQCXsNQfyZs2bcrYvtNODfn9fnV1dam3t1cDAwNqaWlRIBBIKhMIBPTcc89Jkvbs2aNr\n", + "r71WM2fO1JkzZ3Ty5ElJ0unTp9XW1qbi4uKMNRwTkxoEf/xjdtoB4NKRdkSQk5OjxsZGVVVVKRaL\n", + "qa6uTj6fT01NTZKk+vp6rVq1Stu3b5fH49HUqVP19NNPS5L6+vpUU1MjSRocHNTatWu1YsWKSX47\n", + "GA3nCACkcpgsX9bjcDi4sugiWrZM2r07eR3dD1x+Mnns5M5iy3DQB5CKILAMQQAgFUFgGc4RAEhF\n", + "EFiGEQGAVASBZQgCAKkIAsswNQQgFUFgGUYEAFIRBJYhCACkIggsQxAASEUQWIZzBABSEQSWYUQA\n", + "IBVBYBmCAEAqgsAyTA0BSEUQWIYRAYBUBIFlCAIAqQgCyxAEAFIRBJY51zkCzhsAdiMILHOuEUEs\n", + "dvHbAeDSQRBYJlNB8N57jCSAKwVBYJlMTQ0tXCi99NKFtwdA9hEElsnk1NBnn11YW4BLjTHSCy9k\n", + "uxUXH0FgmUwGweDghbUFuNScPCmtWyedPZvtllxcowZBMBiU1+tVUVGRGhoazlnmgQceUFFRkUpL\n", + "S7V///5x1cXFRRAA53fy5NBf20a7aYMgFotpw4YNCgaD6uzsVHNzs95///2kMtu3b1d3d7e6urr0\n", + "hz/8QevXrx9zXSQLhUIZ3V9rq+RwJK871/mA8QbBcPkvv5xYu8Yi031xOaMvvjHZffHXvyb/PR9j\n", + "rqx7ctIGQTgclsfjUUFBgZxOp2pra9Xa2ppU5pVXXtHdd98tSVq8eLH6+/vV19c3prpIlskPeU+P\n", + "9Prryeu2bJEikZFlxxsEp08P/e3rm1jbxiLTX/jjx6XL9Xh6JQbBREeTmewLY6SOjuR1wwEw2ojg\n", + "hhukhx7KWFOyLm0QRKNR5efnx5fdbrei0eiYyhw5cmTUuleSV1+Vjh0be/nJvnZ/zhzp3/5t6Pnw\n", + "L5ef/vSb7ffdN/G2DAfBo49K55vxGxiQ/uu/xrffiRrLL7N/+RfplluS1/33f0slJZPTpmHR6LnD\n", + "93z6+qTu7slrz2T661+lL74YvZwxktMpvf325Lcpnf/7P+l730s+6A8/P9+IYDjA/vKXkSFyoXbv\n", + "lqZPz+w+xyon3UZH6rzCeZgLHCOtXn1B1TPis8+GPqDTpk2s/quvSgUF0oIFo5c9e1Zqa5MqK4c+\n", + "WH/zN0NfjA8/lN55Z/R2dndLpaVD0z7Dj3RWrvzm4D3srrukZ56RzpyR/uEfpL/7u9HbPezMGcnj\n", + "kWbMkP75n6Vdu0a24fhx6c03paoqKefrT1nixyT1I5O6rbtb2rPn/HUSnx84MNSe668/f5sPHBj6\n", + "m/hZO3BAOnx4cj9/r7469HfVquT1if2V+Hy4/N///TfrPvoo+aA5lq/bWL+SDsfQZ2rq1KHP4ES+\n", + "yl98MTRNuHu3dN110tKl37Sho0NavHho38OGD6b/+I+S2/3NPhwOacqU9K+V+B3p75euuUa6aoKX\n", + "vPzlL0N/V68e2o8kffLJ0N8HHxz61Z/oxImh91NVNbTc0SHddtvor3PihPS3fzvUx+l0dw+VXbVq\n", + "6D0lTj+lPs84k8Zbb71lqqqq4ssPP/yweeSRR5LK1NfXm+bm5vjyvHnzTF9f35jqGmNMYWGhkcSD\n", + "Bw8ePMbxKCwsTHf4Hpe0IwK/36+uri719vZq1qxZamlpUXNzc1KZQCCgxsZG1dbWas+ePbr22ms1\n", + "c+ZM5ebmjlpXkrov13EwAFwh0gZBTk6OGhsbVVVVpVgsprq6Ovl8PjU1NUmS6uvrtWrVKm3fvl0e\n", + "j0dTp07V008/nbYuAODS4jDmSroICgAwXlm9s9imG84ikYhuueUWLViwQAsXLtSWLVskScePH1dl\n", + "ZaXmzp2rFStWqL+/P15n8+bNKioqktfrVVtbW7aaPmlisZjKysq0+uuztbb2RX9/v+644w75fD7N\n", + "nz9fe/futbYvNm/erAULFqi4uFh33nmnvvzyS2v64ic/+Ylmzpyp4uLi+LqJvPd33nlHxcXFKioq\n", + "0k8TLxVMJ2NnG8ZpcHDQFBYWmp6eHjMwMGBKS0tNZ2dntpoz6T755BOzf/9+Y4wxJ0+eNHPnzjWd\n", + "nZ3mV7/6lWloaDDGGPPII4+YX//618YYY9577z1TWlpqBgYGTE9PjyksLDSxWCxr7Z8Mjz32mLnz\n", + "zjvN6tWrjTHG2r646667zJNPPmmMMebs2bOmv7/fyr7o6ekxs2fPNl988YUxxpgf/vCH5plnnrGm\n", + "L3bu3Gn27dtnFi5cGF83nvf+1VdfGWOMKS8vN3v37jXGGLNy5Urz2muvjfraWQuCN998M+mqos2b\n", + "N5vNmzdnqzkX3Q9+8APz+uuvx6+yMmYoLObNm2eMGXmVVVVVlXnrrbey0tbJEIlEzK233mp27Nhh\n", + "brvtNmOMsbIv+vv7zezZs0est7Evjh07ZubOnWuOHz9uzp49a2677TbT1tZmVV/09PQkBcF43/uR\n", + "I0eM1+uNr29ubjb19fWjvm7WpobGcrPalaq3t1f79+/X4sWL9emnn2rmzJmSpJkzZ+rTTz+VJB05\n", + "ckTu4YusdeX1z89//nM9+uijuirhInAb+6Knp0czZszQj3/8Y33nO9/RPffco9OnT1vZF9OnT9cv\n", + "fvELffvb39asWbN07bXXqrKy0sq+GDbe95663uVyjalPshYEY71Z7Upz6tQp3X777Xr88cf1rW99\n", + "K2mbw+FI2y9XSp+9+uqruuGGG1RWVnbemxFt6YvBwUHt27dP9913n/bt26epU6fqkUceSSpjS18c\n", + "OnRIv//979Xb26sjR47o1KlTeiHl34S2pS/OZbT3fiGyFgQul0uRhHvvI5FIUpJdic6ePavbb79d\n", + "69at05o1ayQNpXzf1/9ozyeffKIbvr6dMbV/Dh8+LJfLdfEbPQnefPNNvfLKK5o9e7Z+9KMfaceO\n", + "HVq3bp2VfeF2u+V2u1VeXi5JuuOOO7Rv3z7deOON1vXF22+/re9+97vKzc1VTk6Oampq9NZbb1nZ\n", + "F8PG851wu91yuVw6fPhw0vqx9EnWgiDxZrWBgQG1tLQoEAhkqzmTzhijuro6zZ8/Xz/72c/i6wOB\n", + "gJ599llJ0rPPPhsPiEAgoG3btmlgYEA9PT3q6urSokWLstL2THv44YcViUTU09Ojbdu26fvf/76e\n", + "f/55K/vixhtvVH5+vj766CNJUnt7uxYsWKDVq1db1xder1d79uzR559/LmOM2tvbNX/+fCv7Yth4\n", + "vxM33nijrrnmGu3du1fGGD3//PPxOmll4gTHRG3fvt3MnTvXFBYWmocffjibTZl0u3btMg6Hw5SW\n", + "lpqbbrrJ3HTTTea1114zx44dM7feeqspKioylZWV5sSJE/E6v/vd70xhYaGZN2+eCQaDWWz95AmF\n", + "QvGrhmztiwMHDhi/329KSkpMdXW16e/vt7YvGhoazPz5883ChQvNXXfdZQYGBqzpi9raWpOXl2ec\n", + "Tqdxu93mqaeemtB7f/vtt83ChQtNYWGhuf/++8f02txQBgCW439VCQCWIwgAwHIEAQBYjiAAAMsR\n", + "BABgOYIAACxHEACA5QgCALDc/wN1ylfVql6MNwAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "1 loops, best of 3: 355 ms per loop\n" - ] - } - ], - "prompt_number": 6 - }, + "output_type": "display_data" + } + ], + "source": [ + "prediction = net.predict([input_image]) # predict takes any number of images, and formats them for the Caffe net automatically\n", + "print 'prediction shape:', prediction[0].shape\n", + "plt.plot(prediction[0])\n", + "print 'predicted class:', prediction[0].argmax()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see that the prediction is 1000-dimensional, and is pretty sparse.\n", + "\n", + "The predicted class 281 is \"Tabby cat.\" Our pretrained model uses the synset ID ordering of the classes, as listed in `../data/ilsvrc12/synset_words.txt` if you fetch the auxiliary imagenet data by `../data/ilsvrc12/get_ilsvrc_aux.sh`. If you look at the top indices that maximize the prediction score, they are cats, foxes, and other cute mammals. Not unreasonable predictions, right?\n", + "\n", + "Now let's classify by the center crop alone by turning off oversampling. Note that this makes a single input, although if you inspect the model definition prototxt you'll see the network has a batch size of 10. The python wrapper handles batching and padding for you!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "It may look a little slow, but note that time is spent on cropping, python interfacing, and running 10 images. For performance, if you really want to make prediction fast, you can optionally code in C++ and pipeline operations better. For experimenting and prototyping the current speed is fine.\n", - "\n", - "Let's time classifying a single image with input preprocessed:" + "name": "stdout", + "output_type": "stream", + "text": [ + "prediction shape: (1000,)\n", + "predicted class: 281\n" ] }, { - "cell_type": "code", - "collapsed": false, - "input": [ - "# Resize the image to the standard (256, 256) and oversample net input sized crops.\n", - "input_oversampled = caffe.io.oversample([caffe.io.resize_image(input_image, net.image_dims)], net.crop_dims)\n", - "# 'data' is the input blob name in the model definition, so we preprocess for that input.\n", - "caffe_input = np.asarray([net.transformer.preprocess('data', in_) for in_ in input_oversampled])\n", - "# forward() takes keyword args for the input blobs with preprocessed input arrays.\n", - "%timeit net.forward(data=caffe_input)" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEACAYAAAC+gnFaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAG6ZJREFUeJzt3X9sk+eBB/Dvy9l3vYUNSppCsDMZYoMNJGlWhxztRXJb\n", + "kghWvCStqrSI9raIWkxpt2ldK92p16S3AtGENGikXcpBV0ovRLpKBFWpL4uoB0sJVht66S3QOlyi\n", + "GtNQDsiRhLYm5rk/vJjXb+CNE+yY8Hw/kmW/7/s8r5/3cfx+/bw/QBFCCBARkbTmpLsBRESUXgwC\n", + "IiLJMQiIiCTHICAikhyDgIhIcgwCIiLJTRoEXq8XdrsdNpsNDQ0NE5a3traioKAAhYWFuP/++3H4\n", + "8OHYMovFgvz8fBQWFmL16tXJbTkRESWFoncfQSQSwfLly9HR0QGTyYSioiI0NzfD4XDEyoyOjiIj\n", + "IwMA8Omnn6KyshJ9fX0AgCVLluDjjz/GggULUrwZREQ0XbojAr/fD6vVCovFAqPRiOrqarS2tsaV\n", + "GQ8BABgZGcE999wTt5z3qxER3d50gyAUCiEnJyc2bTabEQqFJpQ7ePAgHA4H1q1bh127dsXmK4qC\n", + "tWvXwul0Yvfu3UlsNhERJYtBb6GiKAmtpKKiAhUVFTh69Cg2bdqEzz77DADQ2dmJ7OxsnD9/HqWl\n", + "pbDb7SgpKbn1VhMRUdLoBoHJZEIwGIxNB4NBmM3mm5YvKSnB2NgYLly4gMzMTGRnZwMAsrKyUFlZ\n", + "Cb/fPyEIrFYrTp8+fSvbQEQkndzc3Nj52Fule2jI6XQiEAhgYGAA4XAYLS0tcLvdcWVOnz4dOw/Q\n", + "3d0NAMjMzMSVK1cwPDwMIHpCub29HXl5eRPeY7w+HwKvvPJK2ttwuzzYF+wL9oX+I5k/oHVHBAaD\n", + "AY2NjSgvL0ckEkFNTQ0cDgeampoAAB6PB++++y727dsHo9GIuXPn4sCBAwCAwcFBVFVVAQDGxsaw\n", + "ceNGlJWVJa3hRESUHLpBAADr1q3DunXr4uZ5PJ7Y6xdffBEvvvjihHpLly7FJ598koQmEhFRKvHO\n", + "4tuIy+VKdxNuG+yL69gX17EvUkP3hrIZaYCiIM1NICKadZK57+SIgIhIcgwCIiLJMQiIiCTHICAi\n", + "khyDgIhIcgwCIiLJMQiIiCTHICAikhyDgIhIcgwCIiLJMQiIiCTHICAikhyDgIhIcgwCIiLJMQiI\n", + "iCTHICAikhyDgIhIcgwCIiLJMQiIiCTHICAikhyDgIhIcpMGgdfrhd1uh81mQ0NDw4Tlra2tKCgo\n", + "QGFhIe6//34cPnw44bqUHocPA4qS7lYQ0e1CEUKImy2MRCJYvnw5Ojo6YDKZUFRUhObmZjgcjliZ\n", + "0dFRZGRkAAA+/fRTVFZWoq+vL6G6AKAoCnSaQCmwYwfwwgsAu51o9krmvlN3ROD3+2G1WmGxWGA0\n", + "GlFdXY3W1ta4MuMhAAAjIyO45557Eq5L6cHRABGp6QZBKBRCTk5ObNpsNiMUCk0od/DgQTgcDqxb\n", + "tw67du2aUl2aeQwCIlIz6C1UEtxjVFRUoKKiAkePHsWmTZtw6tSpKTWirq4u9trlcsHlck2pPk0N\n", + "g4Bo9vH5fPD5fClZt24QmEwmBIPB2HQwGITZbL5p+ZKSEoyNjeHixYswm80J11UHAaUeg4Bo9tH+\n", + "SK6vr0/aunUPDTmdTgQCAQwMDCAcDqOlpQVutzuuzOnTp2MnLLq7uwEAmZmZCdWl9GAQEJGa7ojA\n", + "YDCgsbER5eXliEQiqKmpgcPhQFNTEwDA4/Hg3Xffxb59+2A0GjF37lwcOHBAty6lH4OAiNR0Lx+d\n", + "kQbw8tEZ19gIPPccLx8lms1m7PJRujNxREBEagwCCTEIiEiNQSAhBgERqTEIiIgkxyCQEEcERKTG\n", + "IJAQg4CI1BgEEmIQEJEag0BCDAIiUmMQSIhBQERqDAIJMQiISI1BICEGARGpMQgkxCAgIjUGARGR\n", + "5BgEEuKIgIjUGAQSYhAQkRqDQEIMAiJSYxBIiEFARGoMAgkxCIhIjUEgIQYBEakxCCTEICAiNQaB\n", + "hBgERKTGIJAQg4CI1BgEEmIQEJHapEHg9Xpht9ths9nQ0NAwYfk777yDgoIC5Ofn48EHH0RPT09s\n", + "mcViQX5+PgoLC7F69erktpyIiJLCoLcwEomgtrYWHR0dMJlMKCoqgtvthsPhiJVZunQpjhw5gnnz\n", + "5sHr9eLZZ59FV1cXAEBRFPh8PixYsCC1W0FTMofjQCJS0d0l+P1+WK1WWCwWGI1GVFdXo7W1Na7M\n", + "mjVrMG/ePABAcXExzpw5E7dcCJHkJtOt4qEhIlLTDYJQKIScnJzYtNlsRigUumn5PXv2YP369bFp\n", + "RVGwdu1aOJ1O7N69OwnNJSKiZNM9NKRM4afjBx98gL1796KzszM2r7OzE9nZ2Th//jxKS0tht9tR\n", + "UlIyoW5dXV3stcvlgsvlSvh9aeo4IiCafXw+H3w+X0rWrRsEJpMJwWAwNh0MBmE2myeU6+npwebN\n", + "m+H1enH33XfH5mdnZwMAsrKyUFlZCb/fP2kQUOoxCIhmH+2P5Pr6+qStW/fQkNPpRCAQwMDAAMLh\n", + "MFpaWuB2u+PKfPHFF6iqqsL+/fthtVpj869cuYLh4WEAwOjoKNrb25GXl5e0htP0MQiISE13RGAw\n", + "GNDY2Ijy8nJEIhHU1NTA4XCgqakJAODxePDqq6/i0qVL2LJlCwDAaDTC7/djcHAQVVVVAICxsTFs\n", + "3LgRZWVlKd4cSgSDgIjUFJHmy3oUReGVRTOstRWoqADY7USzVzL3nbyinIhIcgwCCfHQEBGpMQgk\n", + "NB4EPDRERACDQGoMAiICGARSGg8ABgERAQwCqV27lu4WENHtgEEgIY4IiEiNQSAxjgiICGAQSIkj\n", + "AiJSYxBIjEFARACDQErjAcBDQ0QEMAikxhEBEQEMAqkxCIgIYBBIiYeGiEiNQSAxjgiICGAQSImX\n", + "jxKRGoNAYjw0REQAg0BKHBEQkRqDQGIMAiICGARS4lVDRKTGIJAYRwREBDAIpMYgICKAQSAlHhoi\n", + "IrVJg8Dr9cJut8Nms6GhoWHC8nfeeQcFBQXIz8/Hgw8+iJ6enoTrUnpxREBEwCRBEIlEUFtbC6/X\n", + "i97eXjQ3N+PkyZNxZZYuXYojR46gp6cHL7/8Mp599tmE61J68PJRIlLTDQK/3w+r1QqLxQKj0Yjq\n", + "6mq0trbGlVmzZg3mzZsHACguLsaZM2cSrktEROmnGwShUAg5OTmxabPZjFAodNPye/bswfr166dV\n", + "l2YORwREpGbQW6goSsIr+uCDD7B37150dnZOuW5dXV3stcvlgsvlSrguTR+DgGj28Pl88Pl8KVm3\n", + "bhCYTCYEg8HYdDAYhNlsnlCup6cHmzdvhtfrxd133z2lukB8EFDqMQCIZh/tj+T6+vqkrVv30JDT\n", + "6UQgEMDAwADC4TBaWlrgdrvjynzxxReoqqrC/v37YbVap1SX0ouBQETAJCMCg8GAxsZGlJeXIxKJ\n", + "oKamBg6HA01NTQAAj8eDV199FZcuXcKWLVsAAEajEX6//6Z16fbBICAiAFCESO/uQFEUpLkJ0vn3\n", + "fwc2bgROnwaWLk13a4hoOpK57+SdxRJj/hIRwCCQEi8fJSI1BoHEGAREBDAIpMQAICI1BoHEGAhE\n", + "BDAIpMRzBESkxiAgIpIcg0BCHBEQkRqDQGIMAiICGARERNJjEEiIh4aISI1BIDEGAREBDAIpMQCI\n", + "SI1BIDEGAhEBDAIp8RwBEakxCIiIJMcgkBBHBESkxiCQGIOAiAAGARGR9BgEEuKhISJSYxBIjEFA\n", + "RACDQEocERCRGoOAiEhykwaB1+uF3W6HzWZDQ0PDhOWnTp3CmjVrcNddd2HHjh1xyywWC/Lz81FY\n", + "WIjVq1cnr9V0SzgiICI1g97CSCSC2tpadHR0wGQyoaioCG63Gw6HI1YmMzMTr7/+Og4ePDihvqIo\n", + "8Pl8WLBgQfJbTreMQUBEwCQjAr/fD6vVCovFAqPRiOrqarS2tsaVycrKgtPphNFovOE6BPc2tx1+\n", + "JESkphsEoVAIOTk5sWmz2YxQKJTwyhVFwdq1a+F0OrF79+7pt5JSgoFARMAkh4YURbmllXd2diI7\n", + "Oxvnz59HaWkp7HY7SkpKJpSrq6uLvXa5XHC5XLf0vpQYBgHR7OHz+eDz+VKybt0gMJlMCAaDselg\n", + "MAiz2ZzwyrOzswFEDx9VVlbC7/dPGgSUegwAotlH+yO5vr4+aevWPTTkdDoRCAQwMDCAcDiMlpYW\n", + "uN3uG5bVngu4cuUKhoeHAQCjo6Nob29HXl5ekppNycBAICJgkhGBwWBAY2MjysvLEYlEUFNTA4fD\n", + "gaamJgCAx+PB4OAgioqKcPnyZcyZMwc7d+5Eb28vvvrqK1RVVQEAxsbGsHHjRpSVlaV+i2hSvHyU\n", + "iNQUkebLehRF4ZVFM+xf/xXYsgU4dgz4u79Ld2uIaDqSue/kncUS4oiAiNQYBBJjEBARwCCQEgOA\n", + "iNQYBBJjIBARwCCQGoOAiAAGgZR4spiI1BgEEtu/H7h6Nd2tIKJ0YxBIaHwk8MYbgN+f3rYQUfox\n", + "CCQTiQDXrqW7FUR0O9H9JybozvPKK8ChQ+luBRHdTjgikMzwMHD5crpbQUS3EwaBZISIHh4iIhrH\n", + "IJCMEDxHQETxGASS4YiAiLQYBJLhiICItBgEkmEQEJEWg0AyPDRERFoMAslcu8YgIKJ4DALJcERA\n", + "RFoMAsnwHAERaTEIJMMRARFpMQgkwxEBEWkxCCTDEQERaU0aBF6vF3a7HTabDQ0NDROWnzp1CmvW\n", + "rMFdd92FHTt2TKkuzTz+r2REpKUbBJFIBLW1tfB6vejt7UVzczNOnjwZVyYzMxOvv/46XnjhhSnX\n", + "pZnHICAiLd0g8Pv9sFqtsFgsMBqNqK6uRmtra1yZrKwsOJ1OGI3GKdelmccgICIt3SAIhULIycmJ\n", + "TZvNZoRCoYRWfCt1KXUYBESkpfs/lCmKMu0VT6VuXV1d7LXL5YLL5Zr2+5I+BgHR7OTz+eDz+VKy\n", + "bt0gMJlMCAaDselgMAiz2ZzQiqdSVx0ElFraILiFrCeiGaT9kVxfX5+0deseGnI6nQgEAhgYGEA4\n", + "HEZLSwvcbvcNywrNHmYqdWnmcERARFq6IwKDwYDGxkaUl5cjEomgpqYGDocDTU1NAACPx4PBwUEU\n", + "FRXh8uXLmDNnDnbu3Ine3l7MnTv3hnUpvRgERKSlCO1P+ZlugKJMGE1Q6jz5JHDgwPXpzk7ggQfS\n", + "1x4imp5k7jt5Z7FkmLlEpMUgkAyDgIi0GASSYRAQkRaDQDLaf3mUwUBEDALJaHf8DAIiYhBIhkFA\n", + "RFoMAskwCIhIi0EgGQYBEWkxCCTDICAiLQaBZBgERKTFIJAMg4CItBgEkmEQEJEWg0Ay2h3/v/xL\n", + "etpBRLcPBoFktEHwxz+mpx1EdPtgEEiGh4KISItBIBkGARFpMQgkwyAgIi0GgWQYBESkxSCQDIOA\n", + "iLQYBJJhEBCRFoNAMtr/mIaIiEEgGY4IiEiLQSAZBgERaU0aBF6vF3a7HTabDQ0NDTcs8/zzz8Nm\n", + "s6GgoAAnTpyIzbdYLMjPz0dhYSFWr16dvFbTtDEIiEjLoLcwEomgtrYWHR0dMJlMKCoqgtvthsPh\n", + "iJVpa2tDX18fAoEAjh8/ji1btqCrqwsAoCgKfD4fFixYkNqtoIQxCIhIS3dE4Pf7YbVaYbFYYDQa\n", + "UV1djdbW1rgyhw4dwjPPPAMAKC4uxtDQEM6dOxdbLrjnua3w4yAiLd0gCIVCyMnJiU2bzWaEQqGE\n", + "yyiKgrVr18LpdGL37t3JbDdNE4OAiLR0Dw0pipLQSm72q/9Pf/oTFi9ejPPnz6O0tBR2ux0lJSUT\n", + "ytXV1cVeu1wuuFyuhN6Xpo5BQDQ7+Xw++Hy+lKxbNwhMJhOCwWBsOhgMwmw265Y5c+YMTCYTAGDx\n", + "4sUAgKysLFRWVsLv908aBJRaDAKi2Un7I7m+vj5p69Y9NOR0OhEIBDAwMIBwOIyWlha43e64Mm63\n", + "G/v27QMAdHV1Yf78+Vi4cCGuXLmC4eFhAMDo6Cja29uRl5eXtIbT9DAIiEhLd0RgMBjQ2NiI8vJy\n", + "RCIR1NTUwOFwoKmpCQDg8Xiwfv16tLW1wWq1IiMjA2+++SYAYHBwEFVVVQCAsbExbNy4EWVlZSne\n", + "HJoMg4CItBSR5st6FEXhlUUzqLgY8Pvj57H7iWafZO47eWexZLjTJyItBoFkGAREpMUgkAyDgIi0\n", + "GASSYRAQkRaDQDIMAiLSYhBIhkFARFoMAsnwfygjIi0GgWQ4IiAiLQaBZBgERKTFIJAMg4CItBgE\n", + "krlREDAciOTGIJAMg4CItBgEkrnRTp9XEhHJjUEgGQYBEWkxCCTDICAiLQaBZBgERKTFIJAMTxYT\n", + "kRaDQDIcERCRFoNAMgwCItJiEEiGQUCk7+rVdLdg5jEIJMMgILq5cBj467+W77wZg0AyDAKim7t8\n", + "Ofp85Up62zHTJg0Cr9cLu90Om82GhoaGG5Z5/vnnYbPZUFBQgBMnTkypLs2cU6eAM2cmzmcQEEUN\n", + "D8c/y0I3CCKRCGpra+H1etHb24vm5macPHkyrkxbWxv6+voQCATwxhtvYMuWLQnXpXg+ny9p6/r1\n", + "r4H/+I/4eQ4HEIlEX8+de33+dIbBXV2pPZaazL4AgK+/Bj77LKmrnDHJ7ovZLNV9kWgQPPUU0NKS\n", + "0qbMKN0g8Pv9sFqtsFgsMBqNqK6uRmtra1yZQ4cO4ZlnngEAFBcXY2hoCIODgwnVpXjJ/CN/+WXg\n", + "n/4JCARuvHzJkuuvpzMiWLMGeO216bUtEcn+wv/614DdntRVzpg7MQj274+G81Qlsy+++Sb6PVD/\n", + "EBo/NDT+fDPNzcCbbyatKWmnGwShUAg5OTmxabPZjFAolFCZs2fPTlr3TrJvH3D2bOLlL1yY/nsl\n", + "+gv+88+BZctuvOwf//H666kGwdhY9Lm+Hpg378Zlzp0D/v7vZ+ak29jY5O9z8eLEef39wO9+l5o2\n", + "jfvmm6nt8L79FhgZSV17Uqm7G/if/5m83LVrwKZNwH/+Z+rbpCcQAAYGgMHB6/MmGxGk8tzBf/0X\n", + "sHZt6tavx6C3UFGUhFYibvHbvmHDLVVPipGR6M7ku9+dXv333gNMJuC++yYvG4kAXi9QXh7dSXzn\n", + "O4DBED108fHH+nX/93+BTz4BHnoImDMHSOQjWr8eGB2Nn2e1Rg8PjYwA//APwN/+7eTrGRcOA2Yz\n", + "MH8+8N//Dfzwh9G2qH31FeD3A2VlwN/8zfUdtfpPRTtPvayvD/jwQ/0y468/+ADIzwdUvzsm6OmJ\n", + "Pm/YEA2Fu++O9vXgINDWlvi2A9EQ/6u/im6/ep6iROdnZESfAeCPf4wG1cMPR6fHP6+bfW5dXdHP\n", + "+NFHr89L5O/iZoSI/r1du3b9oZ0Oh6P9MTYW/Ry/853pvdd770Wfx9suBHD4MFBSEr0SZ9y330af\n", + "//mfgX/7t/h5d92l/x7qvvi//4t+X7V/e4n66qvo8xNPXP8sv/wy+vzSS8C998aXP38eOH48+r0F\n", + "gM7O+M/pZi5din4HMjL0ywUC0e374Q+vz1P/3d/oO5A0QsexY8dEeXl5bHrr1q1i+/btcWU8Ho9o\n", + "bm6OTS9fvlwMDg4mVFcIIXJzcwUAPvjggw8+pvDIzc3V231Pie6IwOl0IhAIYGBgAIsXL0ZLSwua\n", + "m5vjyrjdbjQ2NqK6uhpdXV2YP38+Fi5ciMzMzEnrAkBfX59eE4iIKMV0g8BgMKCxsRHl5eWIRCKo\n", + "qamBw+FAU1MTAMDj8WD9+vVoa2uD1WpFRkYG3vzLGZSb1SUiotuLIoRs99AREZFaWu8slumGs2Aw\n", + "iIceeggrV67EqlWrsGvXLgDAxYsXUVpaimXLlqGsrAxDQ0OxOtu2bYPNZoPdbkd7e3u6mp4ykUgE\n", + "hYWF2PCXqwVk7YuhoSE8/vjjcDgcWLFiBY4fPy5tX2zbtg0rV65EXl4ennrqKXz77bfS9MVPfvIT\n", + "LFy4EHl5ebF509n2jz/+GHl5ebDZbPjZz36W2Jsn7WzDFI2NjYnc3FzR398vwuGwKCgoEL29velq\n", + "Tsp9+eWX4sSJE0IIIYaHh8WyZctEb2+v+NWvfiUaGhqEEEJs375dvPTSS0IIIf785z+LgoICEQ6H\n", + "RX9/v8jNzRWRSCRt7U+FHTt2iKeeekps2LBBCCGk7Yunn35a7NmzRwghxNWrV8XQ0JCUfdHf3y+W\n", + "LFkivvnmGyGEEE888YT4/e9/L01fHDlyRHR3d4tVq1bF5k1l269duyaEEKKoqEgcP35cCCHEunXr\n", + "xPvvvz/pe6ctCD788MO4q4q2bdsmtm3blq7mzLgf/ehH4g9/+EPsKishomGxfPlyIcTEq6zKy8vF\n", + "sWPH0tLWVAgGg+KRRx4Rhw8fFo8++qgQQkjZF0NDQ2LJkiUT5svYFxcuXBDLli0TFy9eFFevXhWP\n", + "PvqoaG9vl6ov+vv744Jgqtt+9uxZYbfbY/Obm5uFx+OZ9H3TdmgokZvV7lQDAwM4ceIEiouLce7c\n", + "OSxcuBAAsHDhQpw7dw4AcPbsWZjN5lidO61/fvGLX+A3v/kN5qguApexL/r7+5GVlYUf//jH+MEP\n", + "foDNmzdjdHRUyr5YsGABfvnLX+L73/8+Fi9ejPnz56O0tFTKvhg31W3XzjeZTAn1SdqCINGb1e40\n", + "IyMjeOyxx7Bz5058V3P3mqIouv1yp/TZe++9h3vvvReFhYU3vRlRlr4YGxtDd3c3fvrTn6K7uxsZ\n", + "GRnYvn17XBlZ+uL06dP47W9/i4GBAZw9exYjIyPYv39/XBlZ+uJGJtv2W5G2IDCZTAgGg7HpYDAY\n", + "l2R3oqtXr+Kxxx7Dpk2bUFFRASCa8oN/ucf9yy+/xL1/uZ1R2z9nzpyByWSa+UanwIcffohDhw5h\n", + "yZIlePLJJ3H48GFs2rRJyr4wm80wm80oKioCADz++OPo7u7GokWLpOuLjz76CA888AAyMzNhMBhQ\n", + "VVWFY8eOSdkX46bynTCbzTCZTDij+ieGE+2TtAWB+ma1cDiMlpYWuN3udDUn5YQQqKmpwYoVK/Dz\n", + "n/88Nt/tduOtt94CALz11luxgHC73Thw4ADC4TD6+/sRCASwevXqtLQ92bZu3YpgMIj+/n4cOHAA\n", + "Dz/8MN5++20p+2LRokXIycnB559/DgDo6OjAypUrsWHDBun6wm63o6urC19//TWEEOjo6MCKFSuk\n", + "7ItxU/1OLFq0CN/73vdw/PhxCCHw9ttvx+roSsYJjulqa2sTy5YtE7m5uWLr1q3pbErKHT16VCiK\n", + "IgoKCsR9990n7rvvPvH++++LCxcuiEceeUTYbDZRWloqLl26FKvz2muvidzcXLF8+XLh9XrT2PrU\n", + "8fl8sauGZO2LTz75RDidTpGfny8qKyvF0NCQtH3R0NAgVqxYIVatWiWefvppEQ6HpemL6upqkZ2d\n", + "LYxGozCbzWLv3r3T2vaPPvpIrFq1SuTm5ornnnsuoffmDWVERJLjf1VJRCQ5BgERkeQYBEREkmMQ\n", + "EBFJjkFARCQ5BgERkeQYBEREkmMQEBFJ7v8B+P2XH1cBu2AAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "1 loops, best of 3: 210 ms per loop\n" - ] - } - ], - "prompt_number": 7 - }, + "output_type": "display_data" + } + ], + "source": [ + "prediction = net.predict([input_image], oversample=False)\n", + "print 'prediction shape:', prediction[0].shape\n", + "plt.plot(prediction[0])\n", + "print 'predicted class:', prediction[0].argmax()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "Now, why don't we see how long it takes to perform the classification end to end? This result is run from an Intel i5 CPU, so you may observe some performance differences." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "OK, so how about GPU? it is actually pretty easy:" + "name": "stdout", + "output_type": "stream", + "text": [ + "1 loops, best of 3: 355 ms per loop\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "caffe.set_mode_gpu()" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 8 - }, + } + ], + "source": [ + "%timeit net.predict([input_image])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It may look a little slow, but note that time is spent on cropping, python interfacing, and running 10 images. For performance, if you really want to make prediction fast, you can optionally code in C++ and pipeline operations better. For experimenting and prototyping the current speed is fine.\n", + "\n", + "Let's time classifying a single image with input preprocessed:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Voila! Now we are in GPU mode. Let's see if the code gives the same result:" + "name": "stdout", + "output_type": "stream", + "text": [ + "1 loops, best of 3: 210 ms per loop\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "prediction = net.predict([input_image])\n", - "print 'prediction shape:', prediction[0].shape\n", - "plt.plot(prediction[0])" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "prediction shape: (1000,)\n" - ] - }, - { - "metadata": {}, - "output_type": "pyout", - "prompt_number": 9, - "text": [ - "[]" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEACAYAAAC+gnFaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIAAAyxEEAGA5ggAALEcQAIDl/h+B3FfVQOwSzQAAAABJRU5ErkJggg==\n", - "text": [ - "" - ] - } - ], - "prompt_number": 9 - }, + } + ], + "source": [ + "# Resize the image to the standard (256, 256) and oversample net input sized crops.\n", + "input_oversampled = caffe.io.oversample([caffe.io.resize_image(input_image, net.image_dims)], net.crop_dims)\n", + "# 'data' is the input blob name in the model definition, so we preprocess for that input.\n", + "caffe_input = np.asarray([net.transformer.preprocess('data', in_) for in_ in input_oversampled])\n", + "# forward() takes keyword args for the input blobs with preprocessed input arrays.\n", + "%timeit net.forward(data=caffe_input)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OK, so how about GPU? it is actually pretty easy:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "caffe.set_mode_gpu()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Voila! Now we are in GPU mode. Let's see if the code gives the same result:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Good, everything is the same. And how about time consumption? The following benchmark is obtained on the same machine with a GTX 770 GPU:" + "name": "stdout", + "output_type": "stream", + "text": [ + "prediction shape: (1000,)\n" ] }, { - "cell_type": "code", - "collapsed": false, - "input": [ - "# Full pipeline timing.\n", - "%timeit net.predict([input_image])" - ], - "language": "python", + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 9, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "10 loops, best of 3: 174 ms per loop\n" - ] - } - ], - "prompt_number": 10 + "output_type": "execute_result" }, { - "cell_type": "code", - "collapsed": false, - "input": [ - "# Forward pass timing.\n", - "%timeit net.forward(data=caffe_input)" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEACAYAAAC+gnFaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAG2ZJREFUeJzt3X9w1OWBx/HPOtk7O1hRImLYTSeQDewCSUzdwFDKTFoJ\n", + "GTjYkuh0Uhn02pxmcNC219beP52CNxUzjnMV05lLOX9rQ/7wxlgP92IGd4Ao7CkwOMYfCZecy2Is\n", + "BVL5oYasz/0Rs+5uYPODDQs879fMTvb7/T7Pd5993P1+9nm+3y86jDFGAABrXZXtBgAAsosgAADL\n", + "EQQAYDmCAAAsRxAAgOUIAgCw3KhBEAwG5fV6VVRUpIaGhhHbW1tbVVpaqrKyMt1yyy3asWNHfFtB\n", + "QYFKSkpUVlamhQsXZrblAICMcKS7jyAWi2nu3Llqb2+Xy+VSeXm5mpub5fP54mVOnz6tKVOmSJLe\n", + "eecdVVdXq7u7W5I0a9Ysvf3225o2bdokvw0AwESlHRGEw2F5PB4VFBTI6XSqtrZWra2tSWWGQ0CS\n", + "Tp06pRtuuCFpO/erAcClLW0QRKNR5efnx5fdbrei0eiIci+99JJ8Pp9WrFihLVu2xNc7HA4tW7ZM\n", + "fr9fW7duzWCzAQCZkpNuo8PhGNNO1qxZozVr1mjXrl1at26dPvjgA0lSR0eH8vLydPToUVVWVsrr\n", + "9Wrp0qUX3moAQMakDQKXy6VIJBJfjkQicrvd5y2/dOlSDQ4O6tixY8rNzVVeXp4kafr06aqurlY4\n", + "HB4RBB6PR4cOHbqQ9wAA1iksLIyfj71QaaeG/H6/urq61Nvbq4GBAbW0tCgQCCSVOXToUPw8wL59\n", + "+yRJubm5OnPmjE6ePClp6IRyW1ubiouLR7zGcH0eRr/97W+z3oZL5UFf0Bf0RfpHJn9Apx0R5OTk\n", + "qLGxUVVVVYrFYqqrq5PP51NTU5Mkqb6+Xi+++KKeffZZOZ1OXXPNNdq2bZskqa+vTzU1NZKkwcFB\n", + "rV27VsuXL89YwwEAmZE2CCRpxYoVWrFiRdK6+vr6+PMHHnhADzzwwIh6s2fP1oEDBzLQRADAZOLO\n", + "4ktIRUVFtptwyaAvvkZffI2+mBxpbyi7KA1wOJTlJgDAZSeTx05GBABgOYIAACxHEACA5QgCALAc\n", + "QQAAliMIAMByBAEAWI4gAADLEQQAYDmCAAAsRxAAgOUIAgCwHEEAAJYjCADAcgQBAFiOIAAAyxEE\n", + "AGA5ggAALEcQAIDlCAIL7dwpfeMb2W4FgEsFQWCh//kf6fPPs90KAJeKUYMgGAzK6/WqqKhIDQ0N\n", + "I7a3traqtLRUZWVluuWWW7Rjx44x10V2OBzZbgGAS4nDGGPOtzEWi2nu3Llqb2+Xy+VSeXm5mpub\n", + "5fP54mVOnz6tKVOmSJLeeecdVVdXq7u7e0x1JcnhcChNEzAJ/u3fpH/+Z4luBy5fmTx2ph0RhMNh\n", + "eTweFRQUyOl0qra2Vq2trUllhkNAkk6dOqUbbrhhzHWRHYwIACRKGwTRaFT5+fnxZbfbrWg0OqLc\n", + "Sy+9JJ/PpxUrVmjLli3jqouLjyAAkCgn3UbHGI8Ya9as0Zo1a7Rr1y6tW7dO77///rgasXHjxvjz\n", + "iooKVVRUjKs+AFzpQqGQQqHQpOw7bRC4XC5FIpH4ciQSkdvtPm/5pUuXanBwUMePH5fb7R5z3cQg\n", + "wORjRABcflJ/JG/atClj+047NeT3+9XV1aXe3l4NDAyopaVFgUAgqcyhQ4fiJyz27dsnScrNzR1T\n", + "XWQHQQAgUdoRQU5OjhobG1VVVaVYLKa6ujr5fD41NTVJkurr6/Xiiy/q2WefldPp1DXXXKNt27al\n", + "rYvsIwgAJEp7+ehFaQCXj150jY3Sffdx+ShwObtol4/iysSIAEAigsBCBAGARASBhQgCAIkIAgsR\n", + "BAASEQQWIggAJCIILEQQAEhEEACA5QgCCzEiAJCIILAQQQAgEUFgIYIAQCKCwEIEAYBEBAEAWI4g\n", + "sBAjAgCJCAILEQQAEhEEFiIIACQiCADAcgSBhRgRAEhEEFiIIACQiCCwEEEAIBFBYCGCAEAiggAA\n", + "LEcQWIgRAYBEBIGFCAIAiUYNgmAwKK/Xq6KiIjU0NIzY/sILL6i0tFQlJSVasmSJDh48GN9WUFCg\n", + "kpISlZWVaeHChZltOSaMIACQKCfdxlgspg0bNqi9vV0ul0vl5eUKBALy+XzxMrNnz9bOnTs1depU\n", + "BYNB3XPPPdqzZ48kyeFwKBQKadq0aZP7LgAAE5Z2RBAOh+XxeFRQUCCn06na2lq1trYmlVm8eLGm\n", + "Tp0qSVq0aJEOHz6ctN0Yk+Em40JdxYQggARpDwnRaFT5+fnxZbfbrWg0et7yTzzxhFauXBlfdjgc\n", + "WrZsmfx+v7Zu3ZqB5iITmBoCkCjt1JBjHEeM119/XU8++aQ6Ojri6zo6OpSXl6ejR4+qsrJSXq9X\n", + "S5cuHVF348aN8ecVFRWqqKgY8+sCgA1CoZBCodCk7DttELhcLkUikfhyJBKR2+0eUe7gwYO6++67\n", + "FQwGdf3118fX5+XlSZKmT5+u6upqhcPhUYMAk48RAXD5Sf2RvGnTpoztO+3UkN/vV1dXl3p7ezUw\n", + "MKCWlhYFAoGkMh999JFqamr0/PPPy+PxxNefOXNGJ0+elCSdPn1abW1tKi4uzljDMXEEAYBEaUcE\n", + "OTk5amxsVFVVlWKxmOrq6uTz+dTU1CRJqq+v14MPPqgTJ05o/fr1kiSn06lwOKy+vj7V1NRIkgYH\n", + "B7V27VotX758kt8OxoIgAJDIYbJ8WY/D4eDKoovsP/9Tuu02iW4HLl+ZPHZyIaGFGBEASEQQWIgg\n", + "AJCIILAQQQAgEUFgIYIAQCKCwGKcLAYgEQRWGg4AggCARBBYjSAAIBEEVhoOgC+/zG47AFwaCAKL\n", + "MSIAIBEEViMIAEgEgZU4WQwgEUFgMc4RAJAIAisxIgCQiCCwGEEAQCIIrMSIAEAigsBinCMAIBEE\n", + "VmJEACARQWAxggCARBBYjSAAIBEEVuLfGgKQiCCwGCMCABJBYCVOFgNIRBBYjCAAII0hCILBoLxe\n", + "r4qKitTQ0DBi+wsvvKDS0lKVlJRoyZIlOnjw4JjrIjs4RwAgUdogiMVi2rBhg4LBoDo7O9Xc3Kz3\n", + "3nsvqczs2bO1c+dOHTx4UL/5zW90zz33jLkusut//zfbLQBwKUgbBOFwWB6PRwUFBXI6naqtrVVr\n", + "a2tSmcWLF2vq1KmSpEWLFunw4cNjrovsGB4RfPe70r592W0LgOxLGwTRaFT5+fnxZbfbrWg0et7y\n", + "TzzxhFauXDmhusiOzz7LdgsAZFtOuo0Oh2PMO3r99df15JNPqqOjY9x1N27cGH9eUVGhioqKMdcF\n", + "ABuEQiGFQqFJ2XfaIHC5XIpEIvHlSCQit9s9otzBgwd19913KxgM6vrrrx9XXSk5CDD5uFoIuPyk\n", + "/kjetGlTxvaddmrI7/erq6tLvb29GhgYUEtLiwKBQFKZjz76SDU1NXr++efl8XjGVRcAkH1pRwQ5\n", + "OTlqbGxUVVWVYrGY6urq5PP51NTUJEmqr6/Xgw8+qBMnTmj9+vWSJKfTqXA4fN66yD5GBAASOYzJ\n", + "7mHB4XAoy02wzp/+JK1dO/R8925pyZLstgfA+GXy2MmdxRYidwEkIggAwHIEAQBYjiCwEFNDABIR\n", + "BABgOYLAQowIACQiCADAcgSBhRgRAEhEEACA5QgCCzEiAJCIIAAAyxEEAGA5gsBCTA0BSEQQAIDl\n", + "CAILMSIAkIggAADLEQQWYkQAIBFBAACWIwgAwHIEgYWYGgKQiCAAAMsRBBZiRAAgEUEAAJYbNQiC\n", + "waC8Xq+KiorU0NAwYvv777+vxYsX6+qrr9ajjz6atK2goEAlJSUqKyvTwoULM9dqXBBGBAAS5aTb\n", + "GIvFtGHDBrW3t8vlcqm8vFyBQEA+ny9eJjc3V48//rheeumlEfUdDodCoZCmTZuW+ZYDADIi7Ygg\n", + "HA7L4/GooKBATqdTtbW1am1tTSozffp0+f1+OZ3Oc+7D8PPzksN/EgCJ0gZBNBpVfn5+fNntdisa\n", + "jY555w6HQ8uWLZPf79fWrVsn3koAwKRJOzXkcDguaOcdHR3Ky8vT0aNHVVlZKa/Xq6VLl44ot3Hj\n", + "xvjziooKVVRUXNDrAsCVJhQKKRQKTcq+0waBy+VSJBKJL0ciEbnd7jHvPC8vT9LQ9FF1dbXC4fCo\n", + "QYDJx9QQcPlJ/ZG8adOmjO077dSQ3+9XV1eXent7NTAwoJaWFgUCgXOWTT0XcObMGZ08eVKSdPr0\n", + "abW1tam4uDhDzQYAZEraEUFOTo4aGxtVVVWlWCymuro6+Xw+NTU1SZLq6+vV19en8vJyffrpp7rq\n", + "qqv02GOPqbOzU3/5y19UU1MjSRocHNTatWu1fPnyyX9HGBUjAgCJHCbLl/U4HA6uLLrI/v3fpfXr\n", + "h57v3i0tWZLd9gAYv0weO7mz2ELkLoBEBAEAWI4gAADLEQQWYmoIQCKCAAAsRxBYiBEBgEQEgeUI\n", + "BQAEgYUSD/4EAQCCAAAsRxBYiBEBgEQEgeUIAgAEAQBYjiCwEFNDABIRBJYjCAAQBBbi4A8gEUFg\n", + "OUIBAEFgIc4RAEhEEACA5QgCyzEiAEAQWIipIQCJCAIAsBxBYCFGBAASEQSWIwgAjBoEwWBQXq9X\n", + "RUVFamhoGLH9/fff1+LFi3X11Vfr0UcfHVddXHz/8R/Sn/+c7VYAuJSkDYJYLKYNGzYoGAyqs7NT\n", + "zc3Neu+995LK5Obm6vHHH9cvf/nLcdfFxffOO9IHH3y9zIgAQNogCIfD8ng8KigokNPpVG1trVpb\n", + "W5PKTJ8+XX6/X06nc9x1cfEZI8ViycsA7JY2CKLRqPLz8+PLbrdb0Wh0TDu+kLqYPF9+mRwEAJCT\n", + "bqPD4ZjwjsdTd+PGjfHnFRUVqqiomPDrIj1GBMDlKRQKKRQKTcq+0waBy+VSJBKJL0ciEbnd7jHt\n", + "eDx1E4MAkys1CABcHlJ/JG/atClj+047NeT3+9XV1aXe3l4NDAyopaVFgUDgnGVNyk/L8dTFxcOI\n", + "AECqtCOCnJwcNTY2qqqqSrFYTHV1dfL5fGpqapIk1dfXq6+vT+Xl5fr000911VVX6bHHHlNnZ6eu\n", + "ueaac9ZFdqWeIyAIADhM6k/5i90Ah2PEaAKT5557pKeekgYHh5b//Gdp1arstgnA+GXy2MmdxZZh\n", + "aghAKoLAMsbwbw0BSEYQWObLL7PdAgCXGoLAMqkjAEYEAAgCyxAEAFIRBJZhaghAKoLAMowIAKQi\n", + "CCxDEABIRRBYhgM/gFQEgWVSzxEQDAAIAsswNQQgFUFgGQ78AFIRBJZhaghAKoLAMkwNAUhFEFiG\n", + "Az+AVASBZRgRAEhFEFiGcwQAUhEEluHADyAVQWAZpoYApCIILMPUEIBUBIFlOPADSEUQWIapIQCp\n", + "CALLEAQAUo0aBMFgUF6vV0VFRWpoaDhnmfvvv19FRUUqLS3V/v374+sLCgpUUlKisrIyLVy4MHOt\n", + "xoTxfygDkCon3cZYLKYNGzaovb1dLpdL5eXlCgQC8vl88TLbt29Xd3e3urq6tHfvXq1fv1579uyR\n", + "JDkcDoVCIU2bNm1y3wXGjBEBgFRpRwThcFgej0cFBQVyOp2qra1Va2trUpmXX35Zd911lyRp0aJF\n", + "6u/v1yeffBLfbjjSXFIIAgCp0gZBNBpVfn5+fNntdisajY65jMPh0LJly+T3+7V169ZMthsTxNQQ\n", + "gFRpp4YcDseYdnK+X/27d+/WzJkzdfToUVVWVsrr9Wrp0qUjym3cuDH+vKKiQhUVFWN6XYwfIwLg\n", + "8hQKhRQKhSZl32mDwOVyKRKJxJcjkYjcbnfaMocPH5bL5ZIkzZw5U5I0ffp0VVdXKxwOjxoEmFyp\n", + "B/62NumrmT0Al7DUH8mbNm3K2L7TTg35/X51dXWpt7dXAwMDamlpUSAQSCoTCAT07LPPSpL27Nmj\n", + "6667TjNmzNCZM2d08uRJSdLp06fV1tam4uLijDUcE5MaBH/6U3baAeDSkXZEkJOTo8bGRlVVVSkW\n", + "i6murk4+n09NTU2SpPr6eq1cuVLbt2+Xx+PRlClT9NRTT0mS+vr6VFNTI0kaHBzU2rVrtXz58kl+\n", + "OxgN5wgApHKYLF/W43A4uLLoIlq6VNq9O3kd3Q9cfjJ57OTOYstw0AeQiiCwDEEAIBVBYBnOEQBI\n", + "RRBYhhEBgFQEgWUIAgCpCALLMDUEIBVBYBlGBABSEQSWIQgApCIILEMQAEhFEFiGcwQAUhEElmFE\n", + "ACAVQWAZggBAKoLAMkwNAUhFEFiGEQGAVASBZQgCAKkIAssQBABSEQSWOdc5As4bAHYjCCxzrhFB\n", + "LHbx2wHg0kEQWCZTQfDuu4wkgCsFQWCZTE0NLVggvfjihbcHQPYRBJbJ5NTQp59eWFuAS40x0vPP\n", + "Z7sVFx9BYJlMBsHg4IW1BbjUnDwprVsnnT2b7ZZcXKMGQTAYlNfrVVFRkRoaGs5Z5v7771dRUZFK\n", + "S0u1f//+cdXFxUUQAOd38uTQX9tGu2mDIBaLacOGDQoGg+rs7FRzc7Pee++9pDLbt29Xd3e3urq6\n", + "9Mc//lHr168fc10kC4VCGd1fa6vkcCSvO9f5gPEGwXD5L76YWLvGItN9cTmjL7422X3xt78l/z0f\n", + "Y66se3LSBkE4HJbH41FBQYGcTqdqa2vV2tqaVObll1/WXXfdJUlatGiR+vv71dfXN6a6SJbJD3lP\n", + "j/Taa8nrtmyRIpGRZccbBKdPD/3t65tY28Yi01/448ely/V4eiUGwURHk5nsC2Okjo7kdcMBMNqI\n", + "4MYbpQcfzFhTsi5tEESjUeXn58eX3W63otHomMocOXJk1LpXkldekY4dG3v5yb52f/Zs6Q9/GHo+\n", + "/Mvlpz/9evu99068LcNB8Mgj0vlm/AYGpP/6r/Htd6LG8svsX/9V+t73ktf9939LJSWT06Zh0ei5\n", + "w/d8+vqk7u7Ja89k+tvfpM8/H72cMZLTKb311uS3KZ3/+z/pu99NPugPPz/fiGA4wP7615EhcqF2\n", + "75amTcvsPscqJ91GR+q8wnmYCxwjrV59QdUz4tNPhz6gU6dOrP4rr0gFBdL8+aOXPXtWamuTKiuH\n", + "Plh/93dDX4wPPpDefnv0dnZ3S6WlQ9M+w490Vqz4+uA97M47paefls6ckf7xH6VvfGP0dg87c0by\n", + "eKTp06V/+Rdp166RbTh+XHrjDamqSsr56lOW+DFJ/cikbuvulvbsOX+dxOcHDgy154Ybzt/mAweG\n", + "/iZ+1g4ckA4fntzP3yuvDP1duTJ5fWJ/JT4fLv8P//D1ug8/TD5ojuXrNtavpMMx9JmaMmXoMziR\n", + "r/Lnnw9NE+7eLV1/vbRkyddt6OiQFi0a2vew4YPpP/2T5HZ/vQ+HQ7r66vSvlfgd6e+Xrr1WumqC\n", + "l7z89a9Df1evHtqPJH388dDfBx4Y+tWf6MSJofdTVTW03NEhrVo1+uucOCH9/d8P9XE63d1DZVeu\n", + "HHpPidNPqc8zzqTx5ptvmqqqqvjyQw89ZB5++OGkMvX19aa5uTm+PHfuXNPX1zemusYYU1hYaCTx\n", + "4MGDB49xPAoLC9Mdvscl7YjA7/erq6tLvb29mjlzplpaWtTc3JxUJhAIqLGxUbW1tdqzZ4+uu+46\n", + "zZgxQ7m5uaPWlaTuy3UcDABXiLRBkJOTo8bGRlVVVSkWi6murk4+n09NTU2SpPr6eq1cuVLbt2+X\n", + "x+PRlClT9NRTT6WtCwC4tDiMuZIuggIAjFdW7yy26YazSCSi733ve5o/f74WLFigLVu2SJKOHz+u\n", + "yspKzZkzR8uXL1d/f3+8zubNm1VUVCSv16u2trZsNX3SxGIxlZWVafVXZ2tt7Yv+/n7dfvvt8vl8\n", + "mjdvnvbu3WttX2zevFnz589XcXGx7rjjDn3xxRfW9MVPfvITzZgxQ8XFxfF1E3nvb7/9toqLi1VU\n", + "VKSfJl4qmE7GzjaM0+DgoCksLDQ9PT1mYGDAlJaWms7Ozmw1Z9J9/PHHZv/+/cYYY06ePGnmzJlj\n", + "Ojs7za9+9SvT0NBgjDHm4YcfNr/+9a+NMca8++67prS01AwMDJienh5TWFhoYrFY1to/GR599FFz\n", + "xx13mNWrVxtjjLV9ceedd5onnnjCGGPM2bNnTX9/v5V90dPTY2bNmmU+//xzY4wxP/zhD83TTz9t\n", + "TV/s3LnT7Nu3zyxYsCC+bjzv/csvvzTGGFNeXm727t1rjDFmxYoV5tVXXx31tbMWBG+88UbSVUWb\n", + "N282mzdvzlZzLrof/OAH5rXXXotfZWXMUFjMnTvXGDPyKquqqirz5ptvZqWtkyESiZhbb73V7Nix\n", + "w6xatcoYY6zsi/7+fjNr1qwR623si2PHjpk5c+aY48ePm7Nnz5pVq1aZtrY2q/qip6cnKQjG+96P\n", + "HDlivF5vfH1zc7Opr68f9XWzNjU0lpvVrlS9vb3av3+/Fi1apE8++UQzZsyQJM2YMUOffPKJJOnI\n", + "kSNyD19krSuvf37+85/rkUce0VUJF4Hb2Bc9PT2aPn26fvzjH+vb3/627r77bp0+fdrKvpg2bZp+\n", + "8Ytf6Fvf+pZmzpyp6667TpWVlVb2xbDxvvfU9S6Xa0x9krUgGOvNaleaU6dO6bbbbtNjjz2mb37z\n", + "m0nbHA5H2n65UvrslVde0Y033qiysrLz3oxoS18MDg5q3759uvfee7Vv3z5NmTJFDz/8cFIZW/ri\n", + "0KFD+v3vf6/e3l4dOXJEp06d0vMp/ya0LX1xLqO99wuRtSBwuVyKJNx7H4lEkpLsSnT27Fnddttt\n", + "WrdundasWSNpKOX7vvpHez7++GPd+NXtjKn9c/jwYblcrovf6Enwxhtv6OWXX9asWbP0ox/9SDt2\n", + "7NC6deus7Au32y23263y8nJJ0u233659+/bppptusq4v3nrrLX3nO99Rbm6ucnJyVFNTozfffNPK\n", + "vhg2nu+E2+2Wy+XS4cOHk9aPpU+yFgSJN6sNDAyopaVFgUAgW82ZdMYY1dXVad68efrZz34WXx8I\n", + "BPTMM89Ikp555pl4QAQCAW3btk0DAwPq6elRV1eXFi5cmJW2Z9pDDz2kSCSinp4ebdu2Td///vf1\n", + "3HPPWdkXN910k/Lz8/Xhhx9Kktrb2zV//nytXr3aur7wer3as2ePPvvsMxlj1N7ernnz5lnZF8PG\n", + "+5246aabdO2112rv3r0yxui5556L10krEyc4Jmr79u1mzpw5prCw0Dz00EPZbMqk27Vrl3E4HKa0\n", + "tNTcfPPN5uabbzavvvqqOXbsmLn11ltNUVGRqaysNCdOnIjX+d3vfmcKCwvN3LlzTTAYzGLrJ08o\n", + "FIpfNWRrXxw4cMD4/X5TUlJiqqurTX9/v7V90dDQYObNm2cWLFhg7rzzTjMwMGBNX9TW1pq8vDzj\n", + "dDqN2+02Tz755ITe+1tvvWUWLFhgCgsLzX333Tem1+aGMgCwHP+rSgCwHEEAAJYjCADAcgQBAFiO\n", + "IAAAyxEEAGA5ggAALEcQAIDl/h+B3FfVQOwSzQAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "10 loops, best of 3: 34.2 ms per loop\n" - ] - } - ], - "prompt_number": 11 - }, + "output_type": "display_data" + } + ], + "source": [ + "prediction = net.predict([input_image])\n", + "print 'prediction shape:', prediction[0].shape\n", + "plt.plot(prediction[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Good, everything is the same. And how about time consumption? The following benchmark is obtained on the same machine with a GTX 770 GPU:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Pretty fast right? Not as fast as you expected? Indeed, in this python demo you are seeing only 4 times speedup. But remember - the GPU code is actually very fast, and the data loading, transformation and interfacing actually start to take **more** time than the actual conv. net computation itself!\n", - "\n", - "To fully utilize the power of GPUs, you really want to:\n", - "\n", - "* Use larger batches, and minimize python call and data transfer overheads.\n", - "* Pipeline data load operations, like using a subprocess.\n", - "* Code in C++. A little inconvenient, but maybe worth it if your dataset is really, really large." + "name": "stdout", + "output_type": "stream", + "text": [ + "10 loops, best of 3: 174 ms per loop\n" ] - }, + } + ], + "source": [ + "# Full pipeline timing.\n", + "%timeit net.predict([input_image])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Parting Words\n", - "-------------\n", - "\n", - "So this is python! We hope the interface is easy enough for one to use. The python wrapper is interfaced with boost::python, and source code can be found at `python/caffe` with the main interface in `pycaffe.py` and the classification wrapper in `classifier.py`. If you have customizations to make, start there! Do let us know if you make improvements by sending a pull request!" + "name": "stdout", + "output_type": "stream", + "text": [ + "10 loops, best of 3: 34.2 ms per loop\n" ] } ], - "metadata": {} + "source": [ + "# Forward pass timing.\n", + "%timeit net.forward(data=caffe_input)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pretty fast right? Not as fast as you expected? Indeed, in this python demo you are seeing only 4 times speedup. But remember - the GPU code is actually very fast, and the data loading, transformation and interfacing actually start to take **more** time than the actual conv. net computation itself!\n", + "\n", + "To fully utilize the power of GPUs, you really want to:\n", + "\n", + "* Use larger batches, and minimize python call and data transfer overheads.\n", + "* Pipeline data load operations, like using a subprocess.\n", + "* Code in C++. A little inconvenient, but maybe worth it if your dataset is really, really large." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Parting Words\n", + "-------------\n", + "\n", + "So this is python! We hope the interface is easy enough for one to use. The python wrapper is interfaced with boost::python, and source code can be found at `python/caffe` with the main interface in `pycaffe.py` and the classification wrapper in `classifier.py`. If you have customizations to make, start there! Do let us know if you make improvements by sending a pull request!" + ] } - ] -} \ No newline at end of file + ], + "metadata": { + "description": "Use the pre-trained ImageNet model to classify images with the Python interface.", + "example_name": "ImageNet classification", + "include_in_docs": true, + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + }, + "priority": 1 + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/detection.ipynb b/examples/detection.ipynb index e343feefd20..e2a981a00d7 100644 --- a/examples/detection.ipynb +++ b/examples/detection.ipynb @@ -1,933 +1,8392 @@ { - "metadata": { - "description": "Run a pretrained model as a detector in Python.", - "example_name": "R-CNN detection", - "include_in_docs": true, - "priority": 3, - "signature": "sha256:5d53dc49c9b6b93c1a2714c99043a763029ec98aebfb44acfa8d9e61781c9499" - }, - "nbformat": 3, - "nbformat_minor": 0, - "worksheets": [ + "cells": [ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[R-CNN](https://github.com/rbgirshick/rcnn) is a state-of-the-art detector that classifies region proposals by a finetuned Caffe model. For the full details of the R-CNN system and model, refer to its project site and the paper:\n", - "\n", - "> *Rich feature hierarchies for accurate object detection and semantic segmentation*. Ross Girshick, Jeff Donahue, Trevor Darrell, Jitendra Malik. CVPR 2014. [Arxiv 2013](http://arxiv.org/abs/1311.2524).\n", - "\n", - "In this example, we do detection by a pure Caffe edition of the R-CNN model for ImageNet. The R-CNN detector outputs class scores for the 200 detection classes of ILSVRC13. Keep in mind that these are raw one vs. all SVM scores, so they are not probabilistically calibrated or exactly comparable across classes. Note that this off-the-shelf model is simply for convenience, and is not the full R-CNN model.\n", - "\n", - "Let's run detection on an image of a bicyclist riding a fish bike in the desert (from the ImageNet challenge\u2014no joke).\n", - "\n", - "First, we'll need region proposals and the Caffe R-CNN ImageNet model:\n", - "\n", - "- [Selective Search](http://koen.me/research/selectivesearch/) is the region proposer used by R-CNN. The [selective_search_ijcv_with_python](https://github.com/sergeyk/selective_search_ijcv_with_python) Python module takes care of extracting proposals through the selective search MATLAB implementation. To install it, download the module and name its directory `selective_search_ijcv_with_python`, run the demo in MATLAB to compile the necessary functions, then add it to your `PYTHONPATH` for importing. (If you have your own region proposals prepared, or would rather not bother with this step, [detect.py](https://github.com/BVLC/caffe/blob/master/python/detect.py) accepts a list of images and bounding boxes as CSV.)\n", - "\n", - "-Run `./scripts/download_model_binary.py models/bvlc_reference_rcnn_ilsvrc13` to get the Caffe R-CNN ImageNet model.\n", - "\n", - "With that done, we'll call the bundled `detect.py` to generate the region proposals and run the network. For an explanation of the arguments, do `./detect.py --help`." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "!mkdir -p _temp\n", - "!echo `pwd`/images/fish-bike.jpg > _temp/det_input.txt\n", - "!../python/detect.py --crop_mode=selective_search --pretrained_model=../models/bvlc_reference_rcnn_ilsvrc13/bvlc_reference_rcnn_ilsvrc13.caffemodel --model_def=../models/bvlc_reference_rcnn_ilsvrc13/deploy.prototxt --gpu --raw_scale=255 _temp/det_input.txt _temp/det_output.h5" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "WARNING: Logging before InitGoogleLogging() is written to STDERR\r\n", - "I0218 20:43:25.383932 2099749632 net.cpp:42] Initializing net from parameters: \r\n", - "name: \"R-CNN-ilsvrc13\"\r\n", - "input: \"data\"\r\n", - "input_dim: 10\r\n", - "input_dim: 3\r\n", - "input_dim: 227\r\n", - "input_dim: 227\r\n", - "state {\r\n", - " phase: TEST\r\n", - "}\r\n", - "layer {\r\n", - " name: \"conv1\"\r\n", - " type: \"Convolution\"\r\n", - " bottom: \"data\"\r\n", - " top: \"conv1\"\r\n", - " convolution_param {\r\n", - " num_output: 96\r\n", - " kernel_size: 11\r\n", - " stride: 4\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"relu1\"\r\n", - " type: \"ReLU\"\r\n", - " bottom: \"conv1\"\r\n", - " top: \"conv1\"\r\n", - "}\r\n", - "layer {\r\n", - " name: \"pool1\"\r\n", - " type: \"Pooling\"\r\n", - " bottom: \"conv1\"\r\n", - " top: \"pool1\"\r\n", - " pooling_param {\r\n", - " pool: MAX\r\n", - " kernel_size: 3\r\n", - " stride: 2\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"norm1\"\r\n", - " type: \"LRN\"\r\n", - " bottom: \"pool1\"\r\n", - " top: \"norm1\"\r\n", - " lrn_param {\r\n", - " local_size: 5\r\n", - " alpha: 0.0001\r\n", - " beta: 0.75\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"conv2\"\r\n", - " type: \"Convolution\"\r\n", - " bottom: \"norm1\"\r\n", - " top: \"conv2\"\r\n", - " convolution_param {\r\n", - " num_output: 256\r\n", - " pad: 2\r\n", - " kernel_size: 5\r\n", - " group: 2\r\n", - " }\r\n", - "}\r\n", - "layer {\r", - "\r\n", - " name: \"relu2\"\r\n", - " type: \"ReLU\"\r\n", - " bottom: \"conv2\"\r\n", - " top: \"conv2\"\r\n", - "}\r\n", - "layer {\r\n", - " name: \"pool2\"\r\n", - " type: \"Pooling\"\r\n", - " bottom: \"conv2\"\r\n", - " top: \"pool2\"\r\n", - " pooling_param {\r\n", - " pool: MAX\r\n", - " kernel_size: 3\r\n", - " stride: 2\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"norm2\"\r\n", - " type: \"LRN\"\r\n", - " bottom: \"pool2\"\r\n", - " top: \"norm2\"\r\n", - " lrn_param {\r\n", - " local_size: 5\r\n", - " alpha: 0.0001\r\n", - " beta: 0.75\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"conv3\"\r\n", - " type: \"Convolution\"\r\n", - " bottom: \"norm2\"\r\n", - " top: \"conv3\"\r\n", - " convolution_param {\r\n", - " num_output: 384\r\n", - " pad: 1\r\n", - " kernel_size: 3\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"relu3\"\r\n", - " type: \"ReLU\"\r\n", - " bottom: \"conv3\"\r\n", - " top: \"conv3\"\r\n", - "}\r\n", - "layer {\r\n", - " name: \"conv4\"\r\n", - " type: \"Convolution\"\r\n", - " bottom: \"conv3\"\r\n", - " top: \"conv4\"\r\n", - " convolution_param {\r\n", - " num_output: 384\r\n", - " pad: 1\r\n", - " kernel_size: 3\r\n", - " group: 2\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"relu4\"\r\n", - " type: \"ReLU\"\r\n", - " bottom: \"conv4\"\r\n", - " top: \"conv4\"\r\n", - "}\r\n", - "layer {\r\n", - " name: \"conv5\"\r\n", - " type: \"Convolution\"\r\n", - " bottom: \"conv4\"\r\n", - " top: \"conv5\"\r\n", - " convolution_param {\r\n", - " num_output: 256\r\n", - " pad: 1\r\n", - " kernel_size: 3\r\n", - " group: 2\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"relu5\"\r\n", - " type: \"ReLU\"\r\n", - " bottom: \"conv5\"\r\n", - " top: \"conv5\"\r\n", - "}\r\n", - "layer {\r\n", - " name: \"pool5\"\r\n", - " type: \"Pooling\"\r\n", - " bottom: \"conv5\"\r\n", - " top: \"pool5\"\r\n", - " pooling_param {\r\n", - " pool: MAX\r\n", - " kernel_size: 3\r\n", - " stride: 2\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"fc6\"\r\n", - " type: \"InnerProduct\"\r\n", - " bottom: \"pool5\"\r\n", - " top: \"fc6\"\r\n", - " inner_product_param {\r\n", - " num_output: 4096\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"relu6\"\r\n", - " type: \"ReLU\"\r\n", - " bottom: \"fc6\"\r\n", - " top: \"fc6\"\r\n", - "}\r\n", - "layer {\r\n", - " name: \"drop6\"\r\n", - " type: \"Dropout\"\r\n", - " bottom: \"fc6\"\r\n", - " top: \"fc6\"\r\n", - " dropout_param {\r\n", - " dropout_ratio: 0.5\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"fc7\"\r\n", - " type: \"InnerProduct\"\r\n", - " bottom: \"fc6\"\r\n", - " top: \"fc7\"\r\n", - " inner_product_param {\r\n", - " num_output: 4096\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"relu7\"\r\n", - " type: \"ReLU\"\r\n", - " bottom: \"fc7\"\r\n", - " top: \"fc7\"\r\n", - "}\r\n", - "layer {\r\n", - " name: \"drop7\"\r\n", - " type: \"Dropout\"\r\n", - " bottom: \"fc7\"\r\n", - " top: \"fc7\"\r\n", - " dropout_param {\r\n", - " dropout_ratio: 0.5\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"fc-rcnn\"\r\n", - " type: \"InnerProduct\"\r\n", - " bottom: \"fc7\"\r\n", - " top: \"fc-rcnn\"\r\n", - " inner_product_param {\r\n", - " num_output: 200\r\n", - " }\r\n", - "}\r\n", - "I0218 20:43:25.385720 2099749632 net.cpp:336] Input 0 -> data\r\n", - "I0218 20:43:25.385769 2099749632 layer_factory.hpp:74] Creating layer conv1\r\n", - "I0218 20:43:25.385783 2099749632 net.cpp:76] Creating Layer conv1\r\n", - "I0218 20:43:25.385790 2099749632 net.cpp:372] conv1 <- data\r\n", - "I0218 20:43:25.385802 2099749632 net.cpp:334] conv1 -> conv1\r\n", - "I0218 20:43:25.385815 2099749632 net.cpp:105] Setting up conv1\r\n", - "I0218 20:43:25.386574 2099749632 net.cpp:112] Top shape: 10 96 55 55 (2904000)\r\n", - "I0218 20:43:25.386610 2099749632 layer_factory.hpp:74] Creating layer relu1\r\n", - "I0218 20:43:25.386625 2099749632 net.cpp:76] Creating Layer relu1\r\n", - "I0218 20:43:25.386631 2099749632 net.cpp:372] relu1 <- conv1\r\n", - "I0218 20:43:25.386641 2099749632 net.cpp:323] relu1 -> conv1 (in-place)\r\n", - "I0218 20:43:25.386649 2099749632 net.cpp:105] Setting up relu1\r\n", - "I0218 20:43:25.386656 2099749632 net.cpp:112] Top shape: 10 96 55 55 (2904000)\r\n", - "I0218 20:43:25.386663 2099749632 layer_factory.hpp:74] Creating layer pool1\r\n", - "I0218 20:43:25.386675 2099749632 net.cpp:76] Creating Layer pool1\r\n", - "I0218 20:43:25.386682 2099749632 net.cpp:372] pool1 <- conv1\r\n", - "I0218 20:43:25.386690 2099749632 net.cpp:334] pool1 -> pool1\r\n", - "I0218 20:43:25.386699 2099749632 net.cpp:105] Setting up pool1\r\n", - "I0218 20:43:25.386716 2099749632 net.cpp:112] Top shape: 10 96 27 27 (699840)\r\n", - "I0218 20:43:25.386725 2099749632 layer_factory.hpp:74] Creating layer norm1\r\n", - "I0218 20:43:25.386736 2099749632 net.cpp:76] Creating Layer norm1\r\n", - "I0218 20:43:25.386744 2099749632 net.cpp:372] norm1 <- pool1\r\n", - "I0218 20:43:25.386803 2099749632 net.cpp:334] norm1 -> norm1\r\n", - "I0218 20:43:25.386819 2099749632 net.cpp:105] Setting up norm1\r\n", - "I0218 20:43:25.386832 2099749632 net.cpp:112] Top shape: 10 96 27 27 (699840)\r\n", - "I0218 20:43:25.386842 2099749632 layer_factory.hpp:74] Creating layer conv2\r\n", - "I0218 20:43:25.386852 2099749632 net.cpp:76] Creating Layer conv2\r\n", - "I0218 20:43:25.386865 2099749632 net.cpp:372] conv2 <- norm1\r\n", - "I0218 20:43:25.386878 2099749632 net.cpp:334] conv2 -> conv2\r\n", - "I0218 20:43:25.386899 2099749632 net.cpp:105] Setting up conv2\r\n", - "I0218 20:43:25.387024 2099749632 net.cpp:112] Top shape: 10 256 27 27 (1866240)\r\n", - "I0218 20:43:25.387042 2099749632 layer_factory.hpp:74] Creating layer relu2\r\n", - "I0218 20:43:25.387050 2099749632 net.cpp:76] Creating Layer relu2\r\n", - "I0218 20:43:25.387058 2099749632 net.cpp:372] relu2 <- conv2\r\n", - "I0218 20:43:25.387066 2099749632 net.cpp:323] relu2 -> conv2 (in-place)\r\n", - "I0218 20:43:25.387075 2099749632 net.cpp:105] Setting up relu2\r\n", - "I0218 20:43:25.387081 2099749632 net.cpp:112] Top shape: 10 256 27 27 (1866240)\r\n", - "I0218 20:43:25.387089 2099749632 layer_factory.hpp:74] Creating layer pool2\r\n", - "I0218 20:43:25.387097 2099749632 net.cpp:76] Creating Layer pool2\r\n", - "I0218 20:43:25.387104 2099749632 net.cpp:372] pool2 <- conv2\r\n", - "I0218 20:43:25.387112 2099749632 net.cpp:334] pool2 -> pool2\r\n", - "I0218 20:43:25.387121 2099749632 net.cpp:105] Setting up pool2\r\n", - "I0218 20:43:25.387130 2099749632 net.cpp:112] Top shape: 10 256 13 13 (432640)\r\n", - "I0218 20:43:25.387137 2099749632 layer_factory.hpp:74] Creating layer norm2\r\n", - "I0218 20:43:25.387145 2099749632 net.cpp:76] Creating Layer norm2\r\n", - "I0218 20:43:25.387152 2099749632 net.cpp:372] norm2 <- pool2\r\n", - "I0218 20:43:25.387161 2099749632 net.cpp:334] norm2 -> norm2\r\n", - "I0218 20:43:25.387168 2099749632 net.cpp:105] Setting up norm2\r\n", - "I0218 20:43:25.387176 2099749632 net.cpp:112] Top shape: 10 256 13 13 (432640)\r\n", - "I0218 20:43:25.387228 2099749632 layer_factory.hpp:74] Creating layer conv3\r\n", - "I0218 20:43:25.387249 2099749632 net.cpp:76] Creating Layer conv3\r\n", - "I0218 20:43:25.387258 2099749632 net.cpp:372] conv3 <- norm2\r\n", - "I0218 20:43:25.387266 2099749632 net.cpp:334] conv3 -> conv3\r\n", - "I0218 20:43:25.387276 2099749632 net.cpp:105] Setting up conv3\r\n", - "I0218 20:43:25.389375 2099749632 net.cpp:112] Top shape: 10 384 13 13 (648960)\r\n", - "I0218 20:43:25.389408 2099749632 layer_factory.hpp:74] Creating layer relu3\r\n", - "I0218 20:43:25.389421 2099749632 net.cpp:76] Creating Layer relu3\r\n", - "I0218 20:43:25.389430 2099749632 net.cpp:372] relu3 <- conv3\r\n", - "I0218 20:43:25.389438 2099749632 net.cpp:323] relu3 -> conv3 (in-place)\r\n", - "I0218 20:43:25.389447 2099749632 net.cpp:105] Setting up relu3\r\n", - "I0218 20:43:25.389456 2099749632 net.cpp:112] Top shape: 10 384 13 13 (648960)\r\n", - "I0218 20:43:25.389462 2099749632 layer_factory.hpp:74] Creating layer conv4\r\n", - "I0218 20:43:25.389472 2099749632 net.cpp:76] Creating Layer conv4\r\n", - "I0218 20:43:25.389478 2099749632 net.cpp:372] conv4 <- conv3\r\n", - "I0218 20:43:25.389487 2099749632 net.cpp:334] conv4 -> conv4\r\n", - "I0218 20:43:25.389497 2099749632 net.cpp:105] Setting up conv4\r\n", - "I0218 20:43:25.391810 2099749632 net.cpp:112] Top shape: 10 384 13 13 (648960)\r\n", - "I0218 20:43:25.391856 2099749632 layer_factory.hpp:74] Creating layer relu4\r\n", - "I0218 20:43:25.391871 2099749632 net.cpp:76] Creating Layer relu4\r\n", - "I0218 20:43:25.391880 2099749632 net.cpp:372] relu4 <- conv4\r\n", - "I0218 20:43:25.391888 2099749632 net.cpp:323] relu4 -> conv4 (in-place)\r\n", - "I0218 20:43:25.391898 2099749632 net.cpp:105] Setting up relu4\r\n", - "I0218 20:43:25.391906 2099749632 net.cpp:112] Top shape: 10 384 13 13 (648960)\r\n", - "I0218 20:43:25.391913 2099749632 layer_factory.hpp:74] Creating layer conv5\r\n", - "I0218 20:43:25.391923 2099749632 net.cpp:76] Creating Layer conv5\r\n", - "I0218 20:43:25.391929 2099749632 net.cpp:372] conv5 <- conv4\r\n", - "I0218 20:43:25.391937 2099749632 net.cpp:334] conv5 -> conv5\r\n", - "I0218 20:43:25.391947 2099749632 net.cpp:105] Setting up conv5\r\n", - "I0218 20:43:25.393072 2099749632 net.cpp:112] Top shape: 10 256 13 13 (432640)\r\n", - "I0218 20:43:25.393108 2099749632 layer_factory.hpp:74] Creating layer relu5\r\n", - "I0218 20:43:25.393122 2099749632 net.cpp:76] Creating Layer relu5\r\n", - "I0218 20:43:25.393129 2099749632 net.cpp:372] relu5 <- conv5\r\n", - "I0218 20:43:25.393138 2099749632 net.cpp:323] relu5 -> conv5 (in-place)\r\n", - "I0218 20:43:25.393148 2099749632 net.cpp:105] Setting up relu5\r\n", - "I0218 20:43:25.393157 2099749632 net.cpp:112] Top shape: 10 256 13 13 (432640)\r\n", - "I0218 20:43:25.393167 2099749632 layer_factory.hpp:74] Creating layer pool5\r\n", - "I0218 20:43:25.393175 2099749632 net.cpp:76] Creating Layer pool5\r\n", - "I0218 20:43:25.393182 2099749632 net.cpp:372] pool5 <- conv5\r\n", - "I0218 20:43:25.393190 2099749632 net.cpp:334] pool5 -> pool5\r\n", - "I0218 20:43:25.393199 2099749632 net.cpp:105] Setting up pool5\r\n", - "I0218 20:43:25.393209 2099749632 net.cpp:112] Top shape: 10 256 6 6 (92160)\r\n", - "I0218 20:43:25.393218 2099749632 layer_factory.hpp:74] Creating layer fc6\r\n", - "I0218 20:43:25.393226 2099749632 net.cpp:76] Creating Layer fc6\r\n", - "I0218 20:43:25.393232 2099749632 net.cpp:372] fc6 <- pool5\r\n", - "I0218 20:43:25.393240 2099749632 net.cpp:334] fc6 -> fc6\r\n", - "I0218 20:43:25.393249 2099749632 net.cpp:105] Setting up fc6\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0218 20:43:25.516396 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\r\n", - "I0218 20:43:25.516445 2099749632 layer_factory.hpp:74] Creating layer relu6\r\n", - "I0218 20:43:25.516463 2099749632 net.cpp:76] Creating Layer relu6\r\n", - "I0218 20:43:25.516470 2099749632 net.cpp:372] relu6 <- fc6\r\n", - "I0218 20:43:25.516480 2099749632 net.cpp:323] relu6 -> fc6 (in-place)\r\n", - "I0218 20:43:25.516490 2099749632 net.cpp:105] Setting up relu6\r\n", - "I0218 20:43:25.516497 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\r\n", - "I0218 20:43:25.516505 2099749632 layer_factory.hpp:74] Creating layer drop6\r\n", - "I0218 20:43:25.516515 2099749632 net.cpp:76] Creating Layer drop6\r\n", - "I0218 20:43:25.516521 2099749632 net.cpp:372] drop6 <- fc6\r\n", - "I0218 20:43:25.516530 2099749632 net.cpp:323] drop6 -> fc6 (in-place)\r\n", - "I0218 20:43:25.516538 2099749632 net.cpp:105] Setting up drop6\r\n", - "I0218 20:43:25.516557 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\r\n", - "I0218 20:43:25.516566 2099749632 layer_factory.hpp:74] Creating layer fc7\r\n", - "I0218 20:43:25.516576 2099749632 net.cpp:76] Creating Layer fc7\r\n", - "I0218 20:43:25.516582 2099749632 net.cpp:372] fc7 <- fc6\r\n", - "I0218 20:43:25.516589 2099749632 net.cpp:334] fc7 -> fc7\r\n", - "I0218 20:43:25.516599 2099749632 net.cpp:105] Setting up fc7\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0218 20:43:25.604786 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\r\n", - "I0218 20:43:25.604838 2099749632 layer_factory.hpp:74] Creating layer relu7\r\n", - "I0218 20:43:25.604852 2099749632 net.cpp:76] Creating Layer relu7\r\n", - "I0218 20:43:25.604859 2099749632 net.cpp:372] relu7 <- fc7\r\n", - "I0218 20:43:25.604868 2099749632 net.cpp:323] relu7 -> fc7 (in-place)\r\n", - "I0218 20:43:25.604878 2099749632 net.cpp:105] Setting up relu7\r\n", - "I0218 20:43:25.604885 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\r\n", - "I0218 20:43:25.604893 2099749632 layer_factory.hpp:74] Creating layer drop7\r\n", - "I0218 20:43:25.604902 2099749632 net.cpp:76] Creating Layer drop7\r\n", - "I0218 20:43:25.604908 2099749632 net.cpp:372] drop7 <- fc7\r\n", - "I0218 20:43:25.604917 2099749632 net.cpp:323] drop7 -> fc7 (in-place)\r\n", - "I0218 20:43:25.604924 2099749632 net.cpp:105] Setting up drop7\r\n", - "I0218 20:43:25.604933 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\r\n", - "I0218 20:43:25.604939 2099749632 layer_factory.hpp:74] Creating layer fc-rcnn\r\n", - "I0218 20:43:25.604948 2099749632 net.cpp:76] Creating Layer fc-rcnn\r\n", - "I0218 20:43:25.604954 2099749632 net.cpp:372] fc-rcnn <- fc7\r\n", - "I0218 20:43:25.604962 2099749632 net.cpp:334] fc-rcnn -> fc-rcnn\r\n", - "I0218 20:43:25.604971 2099749632 net.cpp:105] Setting up fc-rcnn\r\n", - "I0218 20:43:25.606878 2099749632 net.cpp:112] Top shape: 10 200 1 1 (2000)\r\n", - "I0218 20:43:25.606904 2099749632 net.cpp:165] fc-rcnn does not need backward computation.\r\n", - "I0218 20:43:25.606909 2099749632 net.cpp:165] drop7 does not need backward computation.\r\n", - "I0218 20:43:25.606916 2099749632 net.cpp:165] relu7 does not need backward computation.\r\n", - "I0218 20:43:25.606922 2099749632 net.cpp:165] fc7 does not need backward computation.\r\n", - "I0218 20:43:25.606928 2099749632 net.cpp:165] drop6 does not need backward computation.\r\n", - "I0218 20:43:25.606935 2099749632 net.cpp:165] relu6 does not need backward computation.\r\n", - "I0218 20:43:25.606940 2099749632 net.cpp:165] fc6 does not need backward computation.\r\n", - "I0218 20:43:25.606946 2099749632 net.cpp:165] pool5 does not need backward computation.\r\n", - "I0218 20:43:25.606952 2099749632 net.cpp:165] relu5 does not need backward computation.\r\n", - "I0218 20:43:25.606958 2099749632 net.cpp:165] conv5 does not need backward computation.\r\n", - "I0218 20:43:25.606964 2099749632 net.cpp:165] relu4 does not need backward computation.\r\n", - "I0218 20:43:25.606971 2099749632 net.cpp:165] conv4 does not need backward computation.\r\n", - "I0218 20:43:25.606976 2099749632 net.cpp:165] relu3 does not need backward computation.\r\n", - "I0218 20:43:25.606982 2099749632 net.cpp:165] conv3 does not need backward computation.\r\n", - "I0218 20:43:25.606988 2099749632 net.cpp:165] norm2 does not need backward computation.\r\n", - "I0218 20:43:25.606995 2099749632 net.cpp:165] pool2 does not need backward computation.\r\n", - "I0218 20:43:25.607002 2099749632 net.cpp:165] relu2 does not need backward computation.\r\n", - "I0218 20:43:25.607007 2099749632 net.cpp:165] conv2 does not need backward computation.\r\n", - "I0218 20:43:25.607013 2099749632 net.cpp:165] norm1 does not need backward computation.\r\n", - "I0218 20:43:25.607199 2099749632 net.cpp:165] pool1 does not need backward computation.\r\n", - "I0218 20:43:25.607213 2099749632 net.cpp:165] relu1 does not need backward computation.\r\n", - "I0218 20:43:25.607219 2099749632 net.cpp:165] conv1 does not need backward computation.\r\n", - "I0218 20:43:25.607225 2099749632 net.cpp:201] This network produces output fc-rcnn\r\n", - "I0218 20:43:25.607239 2099749632 net.cpp:446] Collecting Learning Rate and Weight Decay.\r\n", - "I0218 20:43:25.607255 2099749632 net.cpp:213] Network initialization done.\r\n", - "I0218 20:43:25.607262 2099749632 net.cpp:214] Memory required for data: 62425920\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "E0218 20:43:26.388214 2099749632 upgrade_proto.cpp:618] Attempting to upgrade input file specified using deprecated V1LayerParameter: ../models/bvlc_reference_rcnn_ilsvrc13/bvlc_reference_rcnn_ilsvrc13.caffemodel\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0218 20:43:27.089423 2099749632 upgrade_proto.cpp:626] Successfully upgraded file specified using deprecated V1LayerParameter\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "GPU mode\r\n", - "Loading input...\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "selective_search_rcnn({'/Users/shelhamer/h/desk/caffe/caffe-dev/examples/images/fish-bike.jpg'}, '/var/folders/bk/dtkn5qjd11bd17b2j36zplyw0000gp/T/tmpakaRLL.mat')\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "Processed 1570 windows in 102.895 s.\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "/Users/shelhamer/anaconda/lib/python2.7/site-packages/pandas/io/pytables.py:2453: PerformanceWarning: \r\n", - "your performance may suffer as PyTables will pickle object types that it cannot\r\n", - "map directly to c-types [inferred_type->mixed,key->block1_values] [items->['prediction']]\r\n", - "\r\n", - " warnings.warn(ws, PerformanceWarning)\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "Saved to _temp/det_output.h5 in 0.298 s.\r\n" - ] - } - ], - "prompt_number": 1 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This run was in GPU mode. For CPU mode detection, call `detect.py` without the `--gpu` argument.\n", - "\n", - "Running this outputs a DataFrame with the filenames, selected windows, and their detection scores to an HDF5 file.\n", - "(We only ran on one image, so the filenames will all be the same.)" - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "\n", - "df = pd.read_hdf('_temp/det_output.h5', 'df')\n", - "print(df.shape)\n", - "print(df.iloc[0])" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "(1570, 5)\n", - "prediction [-2.62247, -2.84579, -2.85122, -3.20838, -1.94...\n", - "ymin 79.846\n", - "xmin 9.62\n", - "ymax 246.31\n", - "xmax 339.624\n", - "Name: /Users/shelhamer/h/desk/caffe/caffe-dev/examples/images/fish-bike.jpg, dtype: object\n" - ] - } - ], - "prompt_number": 2 - }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[R-CNN](https://github.com/rbgirshick/rcnn) is a state-of-the-art detector that classifies region proposals by a finetuned Caffe model. For the full details of the R-CNN system and model, refer to its project site and the paper:\n", + "\n", + "> *Rich feature hierarchies for accurate object detection and semantic segmentation*. Ross Girshick, Jeff Donahue, Trevor Darrell, Jitendra Malik. CVPR 2014. [Arxiv 2013](http://arxiv.org/abs/1311.2524).\n", + "\n", + "In this example, we do detection by a pure Caffe edition of the R-CNN model for ImageNet. The R-CNN detector outputs class scores for the 200 detection classes of ILSVRC13. Keep in mind that these are raw one vs. all SVM scores, so they are not probabilistically calibrated or exactly comparable across classes. Note that this off-the-shelf model is simply for convenience, and is not the full R-CNN model.\n", + "\n", + "Let's run detection on an image of a bicyclist riding a fish bike in the desert (from the ImageNet challenge—no joke).\n", + "\n", + "First, we'll need region proposals and the Caffe R-CNN ImageNet model:\n", + "\n", + "- [Selective Search](http://koen.me/research/selectivesearch/) is the region proposer used by R-CNN. The [selective_search_ijcv_with_python](https://github.com/sergeyk/selective_search_ijcv_with_python) Python module takes care of extracting proposals through the selective search MATLAB implementation. To install it, download the module and name its directory `selective_search_ijcv_with_python`, run the demo in MATLAB to compile the necessary functions, then add it to your `PYTHONPATH` for importing. (If you have your own region proposals prepared, or would rather not bother with this step, [detect.py](https://github.com/BVLC/caffe/blob/master/python/detect.py) accepts a list of images and bounding boxes as CSV.)\n", + "\n", + "-Run `./scripts/download_model_binary.py models/bvlc_reference_rcnn_ilsvrc13` to get the Caffe R-CNN ImageNet model.\n", + "\n", + "With that done, we'll call the bundled `detect.py` to generate the region proposals and run the network. For an explanation of the arguments, do `./detect.py --help`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "1570 regions were proposed with the R-CNN configuration of selective search. The number of proposals will vary from image to image based on its contents and size -- selective search isn't scale invariant.\n", - "\n", - "In general, `detect.py` is most efficient when running on a lot of images: it first extracts window proposals for all of them, batches the windows for efficient GPU processing, and then outputs the results.\n", - "Simply list an image per line in the `images_file`, and it will process all of them.\n", + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: Logging before InitGoogleLogging() is written to STDERR\n", + "I0218 20:43:25.383932 2099749632 net.cpp:42] Initializing net from parameters: \n", + "name: \"R-CNN-ilsvrc13\"\n", + "input: \"data\"\n", + "input_dim: 10\n", + "input_dim: 3\n", + "input_dim: 227\n", + "input_dim: 227\n", + "state {\n", + " phase: TEST\n", + "}\n", + "layer {\n", + " name: \"conv1\"\n", + " type: \"Convolution\"\n", + " bottom: \"data\"\n", + " top: \"conv1\"\n", + " convolution_param {\n", + " num_output: 96\n", + " kernel_size: 11\n", + " stride: 4\n", + " }\n", + "}\n", + "layer {\n", + " name: \"relu1\"\n", + " type: \"ReLU\"\n", + " bottom: \"conv1\"\n", + " top: \"conv1\"\n", + "}\n", + "layer {\n", + " name: \"pool1\"\n", + " type: \"Pooling\"\n", + " bottom: \"conv1\"\n", + " top: \"pool1\"\n", + " pooling_param {\n", + " pool: MAX\n", + " kernel_size: 3\n", + " stride: 2\n", + " }\n", + "}\n", + "layer {\n", + " name: \"norm1\"\n", + " type: \"LRN\"\n", + " bottom: \"pool1\"\n", + " top: \"norm1\"\n", + " lrn_param {\n", + " local_size: 5\n", + " alpha: 0.0001\n", + " beta: 0.75\n", + " }\n", + "}\n", + "layer {\n", + " name: \"conv2\"\n", + " type: \"Convolution\"\n", + " bottom: \"norm1\"\n", + " top: \"conv2\"\n", + " convolution_param {\n", + " num_output: 256\n", + " pad: 2\n", + " kernel_size: 5\n", + " group: 2\n", + " }\n", + "}\n", + "layer {\n", + " name: \"relu2\"\n", + " type: \"ReLU\"\n", + " bottom: \"conv2\"\n", + " top: \"conv2\"\n", + "}\n", + "layer {\n", + " name: \"pool2\"\n", + " type: \"Pooling\"\n", + " bottom: \"conv2\"\n", + " top: \"pool2\"\n", + " pooling_param {\n", + " pool: MAX\n", + " kernel_size: 3\n", + " stride: 2\n", + " }\n", + "}\n", + "layer {\n", + " name: \"norm2\"\n", + " type: \"LRN\"\n", + " bottom: \"pool2\"\n", + " top: \"norm2\"\n", + " lrn_param {\n", + " local_size: 5\n", + " alpha: 0.0001\n", + " beta: 0.75\n", + " }\n", + "}\n", + "layer {\n", + " name: \"conv3\"\n", + " type: \"Convolution\"\n", + " bottom: \"norm2\"\n", + " top: \"conv3\"\n", + " convolution_param {\n", + " num_output: 384\n", + " pad: 1\n", + " kernel_size: 3\n", + " }\n", + "}\n", + "layer {\n", + " name: \"relu3\"\n", + " type: \"ReLU\"\n", + " bottom: \"conv3\"\n", + " top: \"conv3\"\n", + "}\n", + "layer {\n", + " name: \"conv4\"\n", + " type: \"Convolution\"\n", + " bottom: \"conv3\"\n", + " top: \"conv4\"\n", + " convolution_param {\n", + " num_output: 384\n", + " pad: 1\n", + " kernel_size: 3\n", + " group: 2\n", + " }\n", + "}\n", + "layer {\n", + " name: \"relu4\"\n", + " type: \"ReLU\"\n", + " bottom: \"conv4\"\n", + " top: \"conv4\"\n", + "}\n", + "layer {\n", + " name: \"conv5\"\n", + " type: \"Convolution\"\n", + " bottom: \"conv4\"\n", + " top: \"conv5\"\n", + " convolution_param {\n", + " num_output: 256\n", + " pad: 1\n", + " kernel_size: 3\n", + " group: 2\n", + " }\n", + "}\n", + "layer {\n", + " name: \"relu5\"\n", + " type: \"ReLU\"\n", + " bottom: \"conv5\"\n", + " top: \"conv5\"\n", + "}\n", + "layer {\n", + " name: \"pool5\"\n", + " type: \"Pooling\"\n", + " bottom: \"conv5\"\n", + " top: \"pool5\"\n", + " pooling_param {\n", + " pool: MAX\n", + " kernel_size: 3\n", + " stride: 2\n", + " }\n", + "}\n", + "layer {\n", + " name: \"fc6\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"pool5\"\n", + " top: \"fc6\"\n", + " inner_product_param {\n", + " num_output: 4096\n", + " }\n", + "}\n", + "layer {\n", + " name: \"relu6\"\n", + " type: \"ReLU\"\n", + " bottom: \"fc6\"\n", + " top: \"fc6\"\n", + "}\n", + "layer {\n", + " name: \"drop6\"\n", + " type: \"Dropout\"\n", + " bottom: \"fc6\"\n", + " top: \"fc6\"\n", + " dropout_param {\n", + " dropout_ratio: 0.5\n", + " }\n", + "}\n", + "layer {\n", + " name: \"fc7\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"fc6\"\n", + " top: \"fc7\"\n", + " inner_product_param {\n", + " num_output: 4096\n", + " }\n", + "}\n", + "layer {\n", + " name: \"relu7\"\n", + " type: \"ReLU\"\n", + " bottom: \"fc7\"\n", + " top: \"fc7\"\n", + "}\n", + "layer {\n", + " name: \"drop7\"\n", + " type: \"Dropout\"\n", + " bottom: \"fc7\"\n", + " top: \"fc7\"\n", + " dropout_param {\n", + " dropout_ratio: 0.5\n", + " }\n", + "}\n", + "layer {\n", + " name: \"fc-rcnn\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"fc7\"\n", + " top: \"fc-rcnn\"\n", + " inner_product_param {\n", + " num_output: 200\n", + " }\n", + "}\n", + "I0218 20:43:25.385720 2099749632 net.cpp:336] Input 0 -> data\n", + "I0218 20:43:25.385769 2099749632 layer_factory.hpp:74] Creating layer conv1\n", + "I0218 20:43:25.385783 2099749632 net.cpp:76] Creating Layer conv1\n", + "I0218 20:43:25.385790 2099749632 net.cpp:372] conv1 <- data\n", + "I0218 20:43:25.385802 2099749632 net.cpp:334] conv1 -> conv1\n", + "I0218 20:43:25.385815 2099749632 net.cpp:105] Setting up conv1\n", + "I0218 20:43:25.386574 2099749632 net.cpp:112] Top shape: 10 96 55 55 (2904000)\n", + "I0218 20:43:25.386610 2099749632 layer_factory.hpp:74] Creating layer relu1\n", + "I0218 20:43:25.386625 2099749632 net.cpp:76] Creating Layer relu1\n", + "I0218 20:43:25.386631 2099749632 net.cpp:372] relu1 <- conv1\n", + "I0218 20:43:25.386641 2099749632 net.cpp:323] relu1 -> conv1 (in-place)\n", + "I0218 20:43:25.386649 2099749632 net.cpp:105] Setting up relu1\n", + "I0218 20:43:25.386656 2099749632 net.cpp:112] Top shape: 10 96 55 55 (2904000)\n", + "I0218 20:43:25.386663 2099749632 layer_factory.hpp:74] Creating layer pool1\n", + "I0218 20:43:25.386675 2099749632 net.cpp:76] Creating Layer pool1\n", + "I0218 20:43:25.386682 2099749632 net.cpp:372] pool1 <- conv1\n", + "I0218 20:43:25.386690 2099749632 net.cpp:334] pool1 -> pool1\n", + "I0218 20:43:25.386699 2099749632 net.cpp:105] Setting up pool1\n", + "I0218 20:43:25.386716 2099749632 net.cpp:112] Top shape: 10 96 27 27 (699840)\n", + "I0218 20:43:25.386725 2099749632 layer_factory.hpp:74] Creating layer norm1\n", + "I0218 20:43:25.386736 2099749632 net.cpp:76] Creating Layer norm1\n", + "I0218 20:43:25.386744 2099749632 net.cpp:372] norm1 <- pool1\n", + "I0218 20:43:25.386803 2099749632 net.cpp:334] norm1 -> norm1\n", + "I0218 20:43:25.386819 2099749632 net.cpp:105] Setting up norm1\n", + "I0218 20:43:25.386832 2099749632 net.cpp:112] Top shape: 10 96 27 27 (699840)\n", + "I0218 20:43:25.386842 2099749632 layer_factory.hpp:74] Creating layer conv2\n", + "I0218 20:43:25.386852 2099749632 net.cpp:76] Creating Layer conv2\n", + "I0218 20:43:25.386865 2099749632 net.cpp:372] conv2 <- norm1\n", + "I0218 20:43:25.386878 2099749632 net.cpp:334] conv2 -> conv2\n", + "I0218 20:43:25.386899 2099749632 net.cpp:105] Setting up conv2\n", + "I0218 20:43:25.387024 2099749632 net.cpp:112] Top shape: 10 256 27 27 (1866240)\n", + "I0218 20:43:25.387042 2099749632 layer_factory.hpp:74] Creating layer relu2\n", + "I0218 20:43:25.387050 2099749632 net.cpp:76] Creating Layer relu2\n", + "I0218 20:43:25.387058 2099749632 net.cpp:372] relu2 <- conv2\n", + "I0218 20:43:25.387066 2099749632 net.cpp:323] relu2 -> conv2 (in-place)\n", + "I0218 20:43:25.387075 2099749632 net.cpp:105] Setting up relu2\n", + "I0218 20:43:25.387081 2099749632 net.cpp:112] Top shape: 10 256 27 27 (1866240)\n", + "I0218 20:43:25.387089 2099749632 layer_factory.hpp:74] Creating layer pool2\n", + "I0218 20:43:25.387097 2099749632 net.cpp:76] Creating Layer pool2\n", + "I0218 20:43:25.387104 2099749632 net.cpp:372] pool2 <- conv2\n", + "I0218 20:43:25.387112 2099749632 net.cpp:334] pool2 -> pool2\n", + "I0218 20:43:25.387121 2099749632 net.cpp:105] Setting up pool2\n", + "I0218 20:43:25.387130 2099749632 net.cpp:112] Top shape: 10 256 13 13 (432640)\n", + "I0218 20:43:25.387137 2099749632 layer_factory.hpp:74] Creating layer norm2\n", + "I0218 20:43:25.387145 2099749632 net.cpp:76] Creating Layer norm2\n", + "I0218 20:43:25.387152 2099749632 net.cpp:372] norm2 <- pool2\n", + "I0218 20:43:25.387161 2099749632 net.cpp:334] norm2 -> norm2\n", + "I0218 20:43:25.387168 2099749632 net.cpp:105] Setting up norm2\n", + "I0218 20:43:25.387176 2099749632 net.cpp:112] Top shape: 10 256 13 13 (432640)\n", + "I0218 20:43:25.387228 2099749632 layer_factory.hpp:74] Creating layer conv3\n", + "I0218 20:43:25.387249 2099749632 net.cpp:76] Creating Layer conv3\n", + "I0218 20:43:25.387258 2099749632 net.cpp:372] conv3 <- norm2\n", + "I0218 20:43:25.387266 2099749632 net.cpp:334] conv3 -> conv3\n", + "I0218 20:43:25.387276 2099749632 net.cpp:105] Setting up conv3\n", + "I0218 20:43:25.389375 2099749632 net.cpp:112] Top shape: 10 384 13 13 (648960)\n", + "I0218 20:43:25.389408 2099749632 layer_factory.hpp:74] Creating layer relu3\n", + "I0218 20:43:25.389421 2099749632 net.cpp:76] Creating Layer relu3\n", + "I0218 20:43:25.389430 2099749632 net.cpp:372] relu3 <- conv3\n", + "I0218 20:43:25.389438 2099749632 net.cpp:323] relu3 -> conv3 (in-place)\n", + "I0218 20:43:25.389447 2099749632 net.cpp:105] Setting up relu3\n", + "I0218 20:43:25.389456 2099749632 net.cpp:112] Top shape: 10 384 13 13 (648960)\n", + "I0218 20:43:25.389462 2099749632 layer_factory.hpp:74] Creating layer conv4\n", + "I0218 20:43:25.389472 2099749632 net.cpp:76] Creating Layer conv4\n", + "I0218 20:43:25.389478 2099749632 net.cpp:372] conv4 <- conv3\n", + "I0218 20:43:25.389487 2099749632 net.cpp:334] conv4 -> conv4\n", + "I0218 20:43:25.389497 2099749632 net.cpp:105] Setting up conv4\n", + "I0218 20:43:25.391810 2099749632 net.cpp:112] Top shape: 10 384 13 13 (648960)\n", + "I0218 20:43:25.391856 2099749632 layer_factory.hpp:74] Creating layer relu4\n", + "I0218 20:43:25.391871 2099749632 net.cpp:76] Creating Layer relu4\n", + "I0218 20:43:25.391880 2099749632 net.cpp:372] relu4 <- conv4\n", + "I0218 20:43:25.391888 2099749632 net.cpp:323] relu4 -> conv4 (in-place)\n", + "I0218 20:43:25.391898 2099749632 net.cpp:105] Setting up relu4\n", + "I0218 20:43:25.391906 2099749632 net.cpp:112] Top shape: 10 384 13 13 (648960)\n", + "I0218 20:43:25.391913 2099749632 layer_factory.hpp:74] Creating layer conv5\n", + "I0218 20:43:25.391923 2099749632 net.cpp:76] Creating Layer conv5\n", + "I0218 20:43:25.391929 2099749632 net.cpp:372] conv5 <- conv4\n", + "I0218 20:43:25.391937 2099749632 net.cpp:334] conv5 -> conv5\n", + "I0218 20:43:25.391947 2099749632 net.cpp:105] Setting up conv5\n", + "I0218 20:43:25.393072 2099749632 net.cpp:112] Top shape: 10 256 13 13 (432640)\n", + "I0218 20:43:25.393108 2099749632 layer_factory.hpp:74] Creating layer relu5\n", + "I0218 20:43:25.393122 2099749632 net.cpp:76] Creating Layer relu5\n", + "I0218 20:43:25.393129 2099749632 net.cpp:372] relu5 <- conv5\n", + "I0218 20:43:25.393138 2099749632 net.cpp:323] relu5 -> conv5 (in-place)\n", + "I0218 20:43:25.393148 2099749632 net.cpp:105] Setting up relu5\n", + "I0218 20:43:25.393157 2099749632 net.cpp:112] Top shape: 10 256 13 13 (432640)\n", + "I0218 20:43:25.393167 2099749632 layer_factory.hpp:74] Creating layer pool5\n", + "I0218 20:43:25.393175 2099749632 net.cpp:76] Creating Layer pool5\n", + "I0218 20:43:25.393182 2099749632 net.cpp:372] pool5 <- conv5\n", + "I0218 20:43:25.393190 2099749632 net.cpp:334] pool5 -> pool5\n", + "I0218 20:43:25.393199 2099749632 net.cpp:105] Setting up pool5\n", + "I0218 20:43:25.393209 2099749632 net.cpp:112] Top shape: 10 256 6 6 (92160)\n", + "I0218 20:43:25.393218 2099749632 layer_factory.hpp:74] Creating layer fc6\n", + "I0218 20:43:25.393226 2099749632 net.cpp:76] Creating Layer fc6\n", + "I0218 20:43:25.393232 2099749632 net.cpp:372] fc6 <- pool5\n", + "I0218 20:43:25.393240 2099749632 net.cpp:334] fc6 -> fc6\n", + "I0218 20:43:25.393249 2099749632 net.cpp:105] Setting up fc6\n", + "I0218 20:43:25.516396 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\n", + "I0218 20:43:25.516445 2099749632 layer_factory.hpp:74] Creating layer relu6\n", + "I0218 20:43:25.516463 2099749632 net.cpp:76] Creating Layer relu6\n", + "I0218 20:43:25.516470 2099749632 net.cpp:372] relu6 <- fc6\n", + "I0218 20:43:25.516480 2099749632 net.cpp:323] relu6 -> fc6 (in-place)\n", + "I0218 20:43:25.516490 2099749632 net.cpp:105] Setting up relu6\n", + "I0218 20:43:25.516497 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\n", + "I0218 20:43:25.516505 2099749632 layer_factory.hpp:74] Creating layer drop6\n", + "I0218 20:43:25.516515 2099749632 net.cpp:76] Creating Layer drop6\n", + "I0218 20:43:25.516521 2099749632 net.cpp:372] drop6 <- fc6\n", + "I0218 20:43:25.516530 2099749632 net.cpp:323] drop6 -> fc6 (in-place)\n", + "I0218 20:43:25.516538 2099749632 net.cpp:105] Setting up drop6\n", + "I0218 20:43:25.516557 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\n", + "I0218 20:43:25.516566 2099749632 layer_factory.hpp:74] Creating layer fc7\n", + "I0218 20:43:25.516576 2099749632 net.cpp:76] Creating Layer fc7\n", + "I0218 20:43:25.516582 2099749632 net.cpp:372] fc7 <- fc6\n", + "I0218 20:43:25.516589 2099749632 net.cpp:334] fc7 -> fc7\n", + "I0218 20:43:25.516599 2099749632 net.cpp:105] Setting up fc7\n", + "I0218 20:43:25.604786 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\n", + "I0218 20:43:25.604838 2099749632 layer_factory.hpp:74] Creating layer relu7\n", + "I0218 20:43:25.604852 2099749632 net.cpp:76] Creating Layer relu7\n", + "I0218 20:43:25.604859 2099749632 net.cpp:372] relu7 <- fc7\n", + "I0218 20:43:25.604868 2099749632 net.cpp:323] relu7 -> fc7 (in-place)\n", + "I0218 20:43:25.604878 2099749632 net.cpp:105] Setting up relu7\n", + "I0218 20:43:25.604885 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\n", + "I0218 20:43:25.604893 2099749632 layer_factory.hpp:74] Creating layer drop7\n", + "I0218 20:43:25.604902 2099749632 net.cpp:76] Creating Layer drop7\n", + "I0218 20:43:25.604908 2099749632 net.cpp:372] drop7 <- fc7\n", + "I0218 20:43:25.604917 2099749632 net.cpp:323] drop7 -> fc7 (in-place)\n", + "I0218 20:43:25.604924 2099749632 net.cpp:105] Setting up drop7\n", + "I0218 20:43:25.604933 2099749632 net.cpp:112] Top shape: 10 4096 1 1 (40960)\n", + "I0218 20:43:25.604939 2099749632 layer_factory.hpp:74] Creating layer fc-rcnn\n", + "I0218 20:43:25.604948 2099749632 net.cpp:76] Creating Layer fc-rcnn\n", + "I0218 20:43:25.604954 2099749632 net.cpp:372] fc-rcnn <- fc7\n", + "I0218 20:43:25.604962 2099749632 net.cpp:334] fc-rcnn -> fc-rcnn\n", + "I0218 20:43:25.604971 2099749632 net.cpp:105] Setting up fc-rcnn\n", + "I0218 20:43:25.606878 2099749632 net.cpp:112] Top shape: 10 200 1 1 (2000)\n", + "I0218 20:43:25.606904 2099749632 net.cpp:165] fc-rcnn does not need backward computation.\n", + "I0218 20:43:25.606909 2099749632 net.cpp:165] drop7 does not need backward computation.\n", + "I0218 20:43:25.606916 2099749632 net.cpp:165] relu7 does not need backward computation.\n", + "I0218 20:43:25.606922 2099749632 net.cpp:165] fc7 does not need backward computation.\n", + "I0218 20:43:25.606928 2099749632 net.cpp:165] drop6 does not need backward computation.\n", + "I0218 20:43:25.606935 2099749632 net.cpp:165] relu6 does not need backward computation.\n", + "I0218 20:43:25.606940 2099749632 net.cpp:165] fc6 does not need backward computation.\n", + "I0218 20:43:25.606946 2099749632 net.cpp:165] pool5 does not need backward computation.\n", + "I0218 20:43:25.606952 2099749632 net.cpp:165] relu5 does not need backward computation.\n", + "I0218 20:43:25.606958 2099749632 net.cpp:165] conv5 does not need backward computation.\n", + "I0218 20:43:25.606964 2099749632 net.cpp:165] relu4 does not need backward computation.\n", + "I0218 20:43:25.606971 2099749632 net.cpp:165] conv4 does not need backward computation.\n", + "I0218 20:43:25.606976 2099749632 net.cpp:165] relu3 does not need backward computation.\n", + "I0218 20:43:25.606982 2099749632 net.cpp:165] conv3 does not need backward computation.\n", + "I0218 20:43:25.606988 2099749632 net.cpp:165] norm2 does not need backward computation.\n", + "I0218 20:43:25.606995 2099749632 net.cpp:165] pool2 does not need backward computation.\n", + "I0218 20:43:25.607002 2099749632 net.cpp:165] relu2 does not need backward computation.\n", + "I0218 20:43:25.607007 2099749632 net.cpp:165] conv2 does not need backward computation.\n", + "I0218 20:43:25.607013 2099749632 net.cpp:165] norm1 does not need backward computation.\n", + "I0218 20:43:25.607199 2099749632 net.cpp:165] pool1 does not need backward computation.\n", + "I0218 20:43:25.607213 2099749632 net.cpp:165] relu1 does not need backward computation.\n", + "I0218 20:43:25.607219 2099749632 net.cpp:165] conv1 does not need backward computation.\n", + "I0218 20:43:25.607225 2099749632 net.cpp:201] This network produces output fc-rcnn\n", + "I0218 20:43:25.607239 2099749632 net.cpp:446] Collecting Learning Rate and Weight Decay.\n", + "I0218 20:43:25.607255 2099749632 net.cpp:213] Network initialization done.\n", + "I0218 20:43:25.607262 2099749632 net.cpp:214] Memory required for data: 62425920\n", + "E0218 20:43:26.388214 2099749632 upgrade_proto.cpp:618] Attempting to upgrade input file specified using deprecated V1LayerParameter: ../models/bvlc_reference_rcnn_ilsvrc13/bvlc_reference_rcnn_ilsvrc13.caffemodel\n", + "I0218 20:43:27.089423 2099749632 upgrade_proto.cpp:626] Successfully upgraded file specified using deprecated V1LayerParameter\n", + "GPU mode\n", + "Loading input...\n", + "selective_search_rcnn({'/Users/shelhamer/h/desk/caffe/caffe-dev/examples/images/fish-bike.jpg'}, '/var/folders/bk/dtkn5qjd11bd17b2j36zplyw0000gp/T/tmpakaRLL.mat')\n", + "Processed 1570 windows in 102.895 s.\n", + "/Users/shelhamer/anaconda/lib/python2.7/site-packages/pandas/io/pytables.py:2453: PerformanceWarning: \n", + "your performance may suffer as PyTables will pickle object types that it cannot\n", + "map directly to c-types [inferred_type->mixed,key->block1_values] [items->['prediction']]\n", "\n", - "Although this guide gives an example of R-CNN ImageNet detection, `detect.py` is clever enough to adapt to different Caffe models\u2019 input dimensions, batch size, and output categories. You can switch the model definition and pretrained model as desired. Refer to `python detect.py --help` for the parameters to describe your data set. There's no need for hardcoding.\n", - "\n", - "Anyway, let's now load the ILSVRC13 detection class names and make a DataFrame of the predictions. Note you'll need the auxiliary ilsvrc2012 data fetched by `data/ilsvrc12/get_ilsvrc12_aux.sh`." + " warnings.warn(ws, PerformanceWarning)\n", + "Saved to _temp/det_output.h5 in 0.298 s.\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "with open('../data/ilsvrc12/det_synset_words.txt') as f:\n", - " labels_df = pd.DataFrame([\n", - " {\n", - " 'synset_id': l.strip().split(' ')[0],\n", - " 'name': ' '.join(l.strip().split(' ')[1:]).split(',')[0]\n", - " }\n", - " for l in f.readlines()\n", - " ])\n", - "labels_df.sort('synset_id')\n", - "predictions_df = pd.DataFrame(np.vstack(df.prediction.values), columns=labels_df['name'])\n", - "print(predictions_df.iloc[0])" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "name\n", - "accordion -2.622471\n", - "airplane -2.845788\n", - "ant -2.851219\n", - "antelope -3.208377\n", - "apple -1.949950\n", - "armadillo -2.472935\n", - "artichoke -2.201684\n", - "axe -2.327404\n", - "baby bed -2.737925\n", - "backpack -2.176763\n", - "bagel -2.681061\n", - "balance beam -2.722538\n", - "banana -2.390628\n", - "band aid -1.598909\n", - "banjo -2.298197\n", - "...\n", - "trombone -2.582361\n", - "trumpet -2.352853\n", - "turtle -2.360859\n", - "tv or monitor -2.761043\n", - "unicycle -2.218467\n", - "vacuum -1.907717\n", - "violin -2.757079\n", - "volleyball -2.723689\n", - "waffle iron -2.418540\n", - "washer -2.408994\n", - "water bottle -2.174899\n", - "watercraft -2.837425\n", - "whale -3.120338\n", - "wine bottle -2.772960\n", - "zebra -2.742913\n", - "Name: 0, Length: 200, dtype: float32\n" - ] - } - ], - "prompt_number": 3 - }, + } + ], + "source": [ + "!mkdir -p _temp\n", + "!echo `pwd`/images/fish-bike.jpg > _temp/det_input.txt\n", + "!../python/detect.py --crop_mode=selective_search --pretrained_model=../models/bvlc_reference_rcnn_ilsvrc13/bvlc_reference_rcnn_ilsvrc13.caffemodel --model_def=../models/bvlc_reference_rcnn_ilsvrc13/deploy.prototxt --gpu --raw_scale=255 _temp/det_input.txt _temp/det_output.h5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This run was in GPU mode. For CPU mode detection, call `detect.py` without the `--gpu` argument.\n", + "\n", + "Running this outputs a DataFrame with the filenames, selected windows, and their detection scores to an HDF5 file.\n", + "(We only ran on one image, so the filenames will all be the same.)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's look at the activations." + "name": "stdout", + "output_type": "stream", + "text": [ + "(1570, 5)\n", + "prediction [-2.62247, -2.84579, -2.85122, -3.20838, -1.94...\n", + "ymin 79.846\n", + "xmin 9.62\n", + "ymax 246.31\n", + "xmax 339.624\n", + "Name: /Users/shelhamer/h/desk/caffe/caffe-dev/examples/images/fish-bike.jpg, dtype: object\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "plt.gray()\n", - "plt.matshow(predictions_df.values)\n", - "plt.xlabel('Classes')\n", - "plt.ylabel('Windows')" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "pyout", - "prompt_number": 4, - "text": [ - "" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "text": [ - "" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAALMAAAOoCAYAAACa7cU2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsvUmMZel1Jvbd9+6b75vnMV5MGZlZmSlmJYulEkWCpIQ2\ne+O2V+0GBBE25AXhCTQBEe2FbEAbw4AhayFIC9NA24s2BAluSAuBLUEDSIKqYjIzq3KKOd48z/fN\n0/Ui8juMYIsSkZESuwJ5gUJlRUW+8b//f843HcUwDLy93l7X4TL9vF/A2+vt9aaut4v57XVtrreL\n+e11ba63i/ntdW2ut4v57XVtrreL+e11ba5rsZgVRfmqoij7iqIcKYryrX+k58gpivKJoiiPFUX5\n6NXPAoqi/LmiKIeKovx7RVF8V3j8/0tRlLqiKE8v/OynPr6iKP/61fvdVxTln73B5/xfFEUpvXqf\njxVF+edv6jkVRUkrivJXiqI8VxTlmaIo//0bfZ+GYXyq/wFgBnAMIAvAAuAJgFv/CM9zBiDwEz/7\n3wD85qs/fwvA/3qFx/8CgPsAnv5Djw/g9qv3aXn1vo8BmN7Qc/7PAP7Hv+N3r/ycAGIAPvPqzxqA\nAwC33tT7vA478+cAHBuGkTMMYwHg/wXwL/6Rnkv5if/+TwH8m1d//jcA/rPXfWDDML4LoPszPv6/\nAPBvDcNYGIaRw/mX/Lk39JzAf/g+38hzGoZRMwzjyas/DwG8BJDEG3qf12ExJwEUL/x36dXP3vRl\nAPgLRVEeKoryX7/6WdQwjPqrP9cBRN/wc/60x0/g/H3yetPv+b9TFOVjRVG+feHIf6PPqShKFuen\nwod4Q+/zOizmfyo+/vOGYdwH8M8B/DeKonzh0os4Pxf/0V7Lz/D4b+q5fx/AJoDPAKgC+N/f9HMq\niqIB+GMA/4NhGPqlB7zC+7wOi7kMIH3hv9O4fDe/kcswjOqrfzcB/H84P+7qiqLEAEBRlDiAxht+\n2p/2+D/5nlOvfnblyzCMhvHqAvB/4sfH+ht5TkVRLDhfyP+PYRj/7tWP38j7vA6L+SGAXUVRsoqi\nWAH8SwB/8iafQFEUp6Io7ld/dgH4ZwCevnqer736ta8B+Hd/9yO89vXTHv9PAPwXiqJYFUXZBLAL\n4KM38YSvFhOv/xzn7/ONPKeiKAqAbwN4YRjG/3Hhf72Z9/mmu/6fxz84P/oPcN4g/Ot/hMffxHlX\n/QTAMz4HgACAvwBwCODfA/Bd4Tn+LYAKgDnOe4D/8u97fAD/06v3uw/gP3lDz/lfAfi/AXwC4ONX\niyr6pp4TwC8DWL/6HB+/+uerb+p9Kq/+wtvr7fWpvz41ZcY/BTHy9vp0X5+KnVlRFDPOy4hfxXkD\n8EMA/8owjJc/1xf29vqP6vq07Mz/lMTI2+tTen1aFvM/FTHy9voUX5+Wxfwffy309vq5X+rP+wX8\njNc/SIwoivJ2wV+TyzCMv0sb8g9en5bFLMQIznHRfwngX/3kL/36r/86gsEgJpMJRqMRNE3DcrlE\nJpOBruvQdR2TyQTVahWbm5tYr9eo1+vQNA07OzsYjUbodrtQFAWz2Qwmkwnz+Rxmsxmr1Qq3b99G\nPp+H3W7HbDbD3/zN3+BXfuVXsFqt4Pf7USqVYLFYsFqt4HQ6MZlMEAwGMRgM5OcAEI/Hoes6LBYL\n3G43yuUyFEWBruvY3t7GeDxGsViExWLB2dkZ7t69i1qthmazid3dXUynU6zXa7zzzjs4PDyE2+3G\nYDCQz2E6ncJqtSIcDmMymaDf72NzcxPL5RI+nw/Hx8eYTqfIZDLI5XJwuVxQFAXBYBBnZ2cIhUII\nhUL48z//c3zhC19AuVxGJBLBdDpFs9lEIpHAcrlEKpXCcrnEy5cvsbe3h3w+j42NDVgsFjx79gzh\ncBiapgEAGo1zUm8ymcDlcmGxWCAWi+Hs7AyJRAIWiwWTyQS/93u/99qL5FOxmA3DWCqK8t8C+A7O\nJZ/f/ruQjGg0Kov3ww8/RDQahWEYWK/XmM1mCAQCMJvNsFgsMJvNsFqtGI/HuHnzJvr9PqxWK6xW\nK7rdLrLZLCqVCvb29tBqtRCJRAAAe3t7mEwmMJvNePbsGex2O/x+P0ajEaxWK2KxGOx2O6rVKpLJ\nJFRVRSAQwHg8BgCMRiPEYjGMx2N0Oh3EYjEoigKz2YxwOCwL0zAMqKqKBw8eYDwew+PxoFarYWNj\nAwBQrVZhs9kQi8VgsVhgt9sxHo/h9XqRTCZRqVQwGo1gs9nks2k2m5jP50gkEmi321BVFaFQCG63\nG91uF5FIBKvVCuFwGKvVClarFT7fuc7I4XDAMAwEAgHM53M4HA4AwHK5RDKZxHK5xMbGBlRVhaqq\ncLvdcLlcMJlMMJvNsNvt2NzcRKvVgtlslsdaLBZwOp1wuVzo9/tXWiefisUMAIZh/BmAP/v7fqfX\n68HpdOLg4ADL5RIA8OGHH+Lzn/88qtUqarUaYrEYFosFUqkUjo6OoOs6Dg8PEQ6H0el0oCgKKpUK\nHA4HTk9PYbVasVwu4XQ6oes61us17HY7Go0GdF3HfD7H8+fP5Uv86KOP8ODBA7RaLVgsFqiqikaj\ngfV6LQsrl8vh+fPnePfdd1GtVrFarTCfzzGfz/HRRx/B5XJhOp1iPB5jPB6j1WrB7XZD13UcHBzA\nbrejVqvB6XTCZDJhOBzK7j8YDHBycoJAIIBu91zdWSwW4fF40Ov1sLm5ibOzMwQCAUwmE/R6Pezv\n7yMcDuPly5cYDocol8t49913USqVUCgUoKoqjo+PYbfb0ev15JTp9/tyk4xGI2xsbGA8HsNkMiGX\nyyEUCkHXdTSbTaxWKyyXS8xmM4xGI/h8PhwdHaHX6yEYDMLn8+HZs2dXWiOfCpz5Z7kURTF++7d/\nG4ZhoNvtYjQaIZ1Oo91uY2trC5VKBeFwGGdnZ5hOp3A4HLDb7TAMAxaLBdPpFH6/H8PhEGazGTab\nDfl8HtFoVH6fi3E6ncLtduPRo0e4c+cOOp0OQqEQhsMhfD4fFosFrFYrCoUC/H4/1uu1PE6n05Ej\nVdM0BAIBDAYDLBYLeDwetNttWK1W9Pt9KZNMJhM0TcMPfvADpFIpWCwWZDIZ9Ho9WK1WOJ1O7O/v\ny07o9XqxXq8xHo/l35ubm+h0OvB4PPjkk08Qj8cRiURQLpdhs9ng8XhgtVpRqVSgqirS6TSePXuG\nW7duYTabYTgcYj6fYzabwW63YzAYYGtrC4ZhwOl0olw+1/+EQiEAkMdar9eIRCLodruYTCawWq3w\ner0wmUxot9sIhUI4OTlBMBhEr9fDt7/97WtfM/9MV6lUQiAQOOfpX9W9rInr9TpyuRwikQj6/T68\nXi+Ojo4wGo2QTJ6jfL1eD6FQCC9evEA6nUav14PP50O1WsWtW7dgGAZarRZ8Pp/8P5PJhMlkglwu\nJ19gMpnE0dEREokEFosFRqMRZrMZxuMxptMpstksarUa4vG47FZOpxNnZ2cAAEVRsFgsMB6PsVwu\nMZ/PsVqtsLGxAZPJBIfDgSdPniCbzWI+n2M8HsPpdGK5XMJsNiOXy0FVVVitVqiqKrv+aDSCyWRC\nIpGAruvweDyw2+1oNpswDEMWWDgcxnK5hMPhwHw+x2KxQK/Xg6ZpGAwGUFUV0+kU/X4fLpcLx8fH\n0DQNi8UCuq5DURScnp4iHA7D6XSiUChgPp/D5XLBbrejXq/Ld1apVGCz2aCqKkqlq4kdr9ViBs53\nTTZAZrMZOzs7cLvd8Hg8ODk5gcPhkF00FArB4XDA7XbDbDYjEonAbDZDVVVYLBYoioJoNAqn0yk7\nkqIoGI/HWCwWOBeBQR6n2WwiHo/DbDZjd3cXzWYTZrMZbrcbJpNJSpn5fI5kMgmTyQSTyYTFYoHV\nagWXyyVlDGvWWq2G7e1tFAoFWK1WaRR9Ph+8Xi/6/T4Mw5Bd2WKxYDweIxAIYL1ew+v1wmw2o1Qq\nSX08nU7h8XjkebPZLMxmM3RdRzabxXq9hqqqSKVSACBlgaZpUBRFPlu73Q6r1QqPx4NQKIRqtYpQ\nKIT5fI6trS10u13MZjNYrVbY7Xb5ffYf8/kcxWJRmsadnR185zvfee3v/tOCM/9MF5smRVHQ7/dh\nNpuxXC5ht9vR7Xbh9Xphs9mwXC5htVrx1a9+Fd1uFw6HA2azGYPBAI1GA4PBAIqi4HOf+xyq1SpG\noxFarRZWq5U0VYPBAE6nE6qqYjKZSNPW7/dlNwuFQtLscFcfDodwOBzweDwAIGUNj/H1eo1er4fV\naoXVaiWPabFYMJvNYDab4fF4kEqlMB6PYbfbpQTyeDyYzWZYrVZwOBzSYOm6jnA4LI3vbDbDfD5H\nNBpFq9XCbDZDs9kUlMZsNmMymWCxWMhn2263MZvNMBgMYDKZpNZlGeNyuaSkYt3MTcTj8cBisQCA\nIES9Xg+pVAo2mw3D4RBOpxOtVutK3/+1WsysLa1Wq+yohmFgPp/DZrPB7XYDOD/GnU6ndOVEAzY2\nNhAOh2G322XRcDcOBoNwuVwIhUKw2WwIh8NYLBYwm81wOBxwuVxyUywWC2iaJjeX1WqVXZNNm2EY\nsrupqgqXywWn04lMJgOXy4VgMCiPrWkanE6noB28WQ3DwHK5hKqqMJvNePfdd2XnBM7rVpvNBk3T\n4Pf7oWkabDYbHA6H1KhutxsWiwWhUEhe33w+h8VigdfrBQAsFguEw2HM53NYrVZsbW3B7/dDVVXM\nZjN5TS6XC2azGYFAAG63G5qmyfs2mUxyeqxWK/h8PkwmE0GDptMpAoHAlb7/a1Vm+P1+NJtNRKNR\nPHr0CGazGb1eDzabDfV6XdCF2WyG9XqNv/zLv0Sz2ZRFeXx8jMFgICjCs2fPsLe3h8FgII0aS47Z\nbAabzYaTkxP4/X40Gg1MJhO43W7BnK1Wq9wo/X4fTqdTXt/x8TGcTicSiQSazabsvIFAAIqi4OXL\nl1BVFU6nE5VKBfP5HPF4HLPZDKFQCE+fPsWNGzcwHA4FzTg4OJCbtt1u4+TkBKFQCGdnZ9IrLJdL\naJqGYrGIRCKB0Wgk5cb29jb6/b6UT/l8HjabDWazGe12G+l0GoPBAB9++CHm8zny+TxcLhcmkwkK\nhQLW6zVWqxXi8TgePnyIjY0NubGazSYAyG7PGl5VVTSbTdksrnJdq515Op3CYrGgWCxCVVX0+32B\nzLjzzedz+fdyuUSv15MjdTabwe/3S40XCATQ7/exXq/R6XQQCASQy+Wk8ZlOp4jH42g0GrIDLhYL\ntNttAOclxGKxQKVSgaIo6HQ6cLlcsjNFo1GsViu43W44nU5p3nRdh6ZpSCQSUFUVJpMJNpsNTqcT\n0+kUpVJJmsThcAhN0zCfz6FpmpA0q9UKHo8HqqrC7/djPB7LydHr9aSpZIngcrnQ7XYxHo8xm83+\ngxPF7/fL52mz2WC326WvGAwGcDgc0HVdyCI2ydPpVH6X5RPret7kqqpitVphOBxe6fu/Vjvzer2W\n49Lv98NisQj05na75YvvdDpIJBJYr9d47733pHmJx+NYr9dIpVKYzWYoFovY2toCcF6Pj0YjbG9v\nS2OjaZqgGiQKLBYLut0u1us14vE4xuOx7KgOhwOTyQTr9VoayPV6LSXJYDBALBaDw+GQXXQ+n8Pv\n96Pb7Qoyw3LAbDYLqREKhTCZTORGYelhs9nQ7XYFGw6FQtLMBgIBYfF4IiiKAsMwpDEeDodCrhiG\ngXq9jnA4jHa7LU0r2UE2qHa7XW5Aj8cjJVKr1bpUang8HgyHQ6TTaSwWC8Tj8b/v6/0Hr2u1mE0m\nk+woxD+5aNxut1DUxItZP6qqKrUxG6pOp4Pt7W24XC4YhiEd/Hq9lkXCGhKANFeqqsLn8wmbdfFx\nAUhzyNqWmDRJFTaLLIlWq5XU1g6HA+v1GhaLRd6D1+uVJtLv98vuzTp2PB7LIluv1/B4PBgMBphM\nJlAURero4XAIr9eL0WgEv98PAPJY7D2IcvDzWK/X8lqXyyXcbjfcbjfsdvulv8Od2el0ygkzHA4F\nc+Z3papXW47XajGzk2ZpQJhuc3MTx8fHWC6XWCwWwuixM282m3jvvffw9OlTwTwbjYZguuFwGPF4\nHIVCAcC5vsDpdEq5wWOVdaPJZEIkEkEul8POzo7UxKVSCR6PB4FAAHa7HaVSCZqm4dmzZ4jFYvB6\nvahUKrDb7Wi323A4HGi320gmk7LYisWisHAejwf5fB5+vx/lchnhcBi6rqNYLAqGHY1Gkc/nEQ6H\noaoqOp0ODg4OEAgEUKlUMBwOMR6PsVqtBKPnjdput6HrOnq9HgDAbDajXC5jZ2cHiqLAYrFgvV4L\nIhIKhdDpdLBcLmEYhpAr7EN8Ph8Mw8CLFy8QiUTw5MkTAMDZ2RmSySSKxeJP/W5/luta1cxOpxPj\n8RixWEzqVKvVina7DcMwpKsn6D+bzfDw4UOEw2EUi0U4nU6MRiM5Svv9PsLhMGq1GlqtljR0qqpC\n13Wpm/1+P3Rdx3K5hMfjQSwWQ7vdRiQSga7r2Nvbw3q9RjqdhslkQjKZxHQ6xXA4hN/vh8/nkzJg\nd3dXdCOTyQSxWAyTyURecywWw+7uruy4fr8fs9kMFosFuq5jMBjg/fffF4hO13XRSRCmS6VS6HQ6\niEajGI/Hsjun02lYrVbMZjNZkJFIRAgZAPD5fGg0GqjVagDO+wKWEzxV/H4/er0eDMOQfoBwKLH7\n1WqFdDoNt9uNYDAopchVrmu1mGu1GtbrNUqlEsLhMBRFkcVG/JaKMzaELD/YlKTTafh8PmGsyOwN\nBgP0+33ZzQFIudHr9aSUaLVaODw8hNfrRb1ex3K5xJMnT2AymdDv9zGZTHB6eio0b7FYFChwNpvh\n0aNHMAxDVHXtdhsulwuDwQC6rmOxWODjjz+G2+3GfD4XjDYYDMJms8HlcuG73/2uqNXYWBUKBei6\njtlshnw+D6/XK83ZcrnEcDjEZDIRWI6NcbValROO+DNvDuLgFFlxMxgMBvD5fFLnt9ttmEwmjMdj\njEYjHB4eYjgcYr1e4/Hjx6Ihefr06U/9bn+W61otZqfTKX8mRTsej9FsNqEoijRmq9VKSpJsNovx\neCyNT7PZRKPREE2E3+8XUkNVVazXawCQsuHil93pdAAAHo8H0+kUiqLA5/MJ8rBer+F2u4UmXq1W\nUFUVvV5PbrZQKITFYgG32y2NIutWvg5FUdBoNDCdTjGZTDCdTlEoFGCz2bBYLEQItVwuMRqNBFdm\n4xcMBjGfz6HrupBFZrMZo9EIiqKgXq9Lv8FewWQyiUSWRBBJlOl0ilqtJiUStSV8zYZhCPyn6zqi\n0Sg8Hg8ajQbS6TTMZjO63a7cgK97Xaua2eFwwOl0QtM0qV0TiYRQupubm2g2m5hMJjAMAz6fDz/6\n0Y/wwQcfwGw2I5lMXmLLBoMB7Ha71MSBQABHR0eIRqMYDocIBoOiGdY0TZAFRVEwn8+xsbGB1WqF\nRCIhwiHgfLFzB/R4PFgul7DZbMKasWZnHcuTw2KxIB6PC1tHUoOUOUsVljOKoggjarfbkU6nhSRq\nNpsCnyWTScxmM3g8Hui6Lo1kPB4XEVQoFBJSio/BRtFmswniYjaboWkaXC4XbDYbfD4f/H4/isWi\nvCaSKNSZK4oCm82Gmzdv4k//9E9f+/u/dos5l8vBZDKhVqvh7t27KBaLWK/XGA6HGI1GsrPlcjkE\ng0FomoZSqQSv1wuHw4HVaoXHjx/j/v378Pl8cDqd6Ha7cDqdqNVq8Hq9mEwmoqngEdnr9VAoFHDj\nxg2B56bTqezmhLFI5ebzedE7T6dT2elY7qiqinK5jGQyiZOTE6xWK9y4cQOHh4fweDzSXBIrnkwm\ncnpwxyaeznKgXC7D4/FgNBqhUqkgEAhgOp0CgLCSy+US7XYbwWAQR0dH2NjYQLlchqqqqFQqiEQi\nsNlsWK/XmEwmcDgcmM1moq9erVZot9tot9twOp1oNBoYjUZYLpeIxWJSdrA273a7cLvdWK1Worx7\n3etalRnD4RCbm5vw+/0iGHe73QgEAhiNRqIeo5Ccu5LL5cKtW7dEdXbv3j0Mh0O0Wi2RcdINwSPU\n7XbLMUwMOZVKYTQaoVqtIhaLYTqdIhKJiAC9VCpJ+bGxsSEEA3c/KtiIDft8PpTLZezu7iKTycDj\n8cBkMsnuSRbN6/UKBOjxeFAul+FyuTCbzeDz+VAsFrFYLOD1euU5U6kUdF0X3cpsNpP6PJFIwOFw\nwO/3o91uy3/funULq9UKkUhEqHUKmogds3zLZDIAzqFJ1vadTgd2ux3T6RSapsmmQOLkqqTJtVrM\n7XZbFqvdbpcOm1RwIBCAx+MRwXssFsPjx4/lg9za2oKmaUJMRKNRuFwujMdjHB0dwePxoNPpwOFw\noFqtyvHudrsRj8eFdGADSf1BOBxGt9tFNBqVGpT4tMfjQTgcFtYxlUpBVVURIlFmSnbT5/NJrc33\nxrqaKA4RGyrzCO2FQiGkUikpbagr5o1FRISCqK2tLYHXbDab3MyUdhLNIbFDvD6ZTEofwBKE6Mx0\nOhWxF0mqUCgERVFEivu617VazGazGfP5XHxvg8EA9Xodi8UCtVoNz549E9IDAMbjMba3t2EYBiqV\nCl6+fInpdIoXL16IBpq1MzUEPGLJMNKZksvl0G63BV1ot9sYjUYYj8fQdR0Oh0OazNVqhWKxKN5C\nNoe6rqNWq8nPCHV1u120Wi2Uy2VRq5VKJZjNZgSDQdlhy+WynCAX3StUrD158gSnp6eo1+uXqP56\nvS6wGZtNq9WK58+fAzgnZpbLJdbrNebzOUqlEvb39wWLXywWODw8FJJmMpkgn89jsVig2Wzi5ORE\nUCAqGXu9Hk5PT9Hv99FqtaCqKqrV6pW+/2u1mCORCFwuF3w+H0ajkSjnVFWVJovsVyQSQbvdRqvV\nEqaK/55Op6JfIBxFFotoxnA4hK7rGA6H4vEjPOXxeKAoCvx+v/gDqZleLBaCUxN9GI/HcLvd8Pl8\nQhvPZjOB4rrdLoLBoODYbKAoGgoGg7Db7fD5fJcE/Y1GA51OB91uV9R5s9kMsVhMqGoSSe12Wyhp\nylR1/Tw6mWUP6+/5fC6NJckQi8UiiEWn04HNZpOTiPix1WqFw+EQ/yB9jzRRXNX1dK0Ws6ZpmE6n\naLfbl2hk0rar1Qper1dqaE3TcHZ2JsJzr9crOmIC/Wze6NhgM3PRga0oimh8TSaT1MCDwUBkmPy7\n3IFtNpuIepLJJObzOabTqezOFotFdnNN0zAej+XUASC7OmtOLloK/slwkvVrNBpCPfN1ES9nOTAe\nj2VRDodDaVrNZjMURRFsmLs9kYtOp4P1eo1+vy/mB/4+f5dMIfXgiUQCNpsNtVpNTAlkWF/3ulZo\nRr1el91tMBig2+1K7enxeBCNRtHtdkXEQ8yVWloSILdu3ZJaDoAIheiqJipBAU6n08Hm5qbsyGyw\neAOQRSS6QDobgCwGs9ksNTjNqIvFQrQhPAE0TUO1WkU2m4XdbkelUhG4zO/3X8J6b9y4IYL/RCIh\n2giTySS753w+RyaTkViEcrkszpjPfe5zggbFYjHpLUKhkLhVgPO6nvpoOtxpzYpEIvD5fJjNZlJi\nkZ0kscVa/Etf+pJQ3K9zXaudmdrcTqcDt9uNbDYrWgPWoRQWKYqCDz74AMlkUnYpTdOkIYvH4/jq\nV78q7JzdbsdisYDP5xPBDUVNbH646EwmE6LRqLwmAPI7VPI5nU4EAgE4HA7ZTe12O2KxmEhAicg4\nnU4pc4hFc/EHg0E4HA4kEgncv39fMGZN05DJZOD1euFyuUTUFAqF0G634ff7YTKZ4PF44PV65X0F\nAgFp7Ig1s8lkbZ9IJIRip1fQ7XYjkUgglUrBbDYjkUhgd3dXSCHGMPCz9Xg84lRxuVxwu91y6rzu\nda12ZtZoLpdLsNHZbCY6iKOjI/HXhUIh/PEf/zHW6zWq1So8Hg+Oj49FaE58l7tZpVKB1+uV0Bab\nzYZisYhWqyVlAMX7lEo2Gg3cu3cPz549g9PpvKTlpZ53tVrh+PgYiUQCxWIR4XBYMGHi41arFdPp\nVBRt/X4fs9kMiURC7GC1Wk0sXGwu9/f3BcqLRqMoFAoCI/I1dDodtFotKU2sVis6nQ5u376N4+Nj\nIW5arZb0EnyP/X5fmrxGowG73S4Sz3a7Lbgy3zOpbxJWjx49gqIo+OSTT7C9vX2lXRm4Zjtzu91G\nrVbDYrHAfD5Hv98XQqLT6WBra0vw0fl8ji9+8Yt49OgRIpEIXr58KU0cpZcX3dW0OdGhMRgMEA6H\nEQqF0Gq1xJ1BnJW7UavVgtPpFC3zfD4Xva/b7UY4HMbW1pZIJJllQQlpLBZDsVjEdDoVhIP2LcYK\nUHJZq9UwnU4RjUZFl00cnbEDg8EAo9EIjUZDJJ5kEllWud1uKQlcLhd6vR50XZfAmuVyiUKhIKcP\nyyOq69gf1Ot1iXS4GMjD+p4nTyQSkRPuKte1Wsy03qTTafkivF4vFosFgsEgAIhmVlVVPHv2DOl0\nGhaLBRsbG6KpCAQC8Pv92N/fRyKRgKIoyGazcpwTXaDTeWdnR7x6wWBQHM4+nw/L5RI3b94UBRoA\nWYilUklwXOpAdnd3EQqFLkUm0FOXzWbhdrslwosGXYryl8ulwI3L5VKc4IQSWTdHIhHBsi9mh2ia\nJhg4dd/UUbPuZbCL1+uVG8Ln88FqtYrLmyekz+cTcT4p+Gg0is3NTSmVWNZomobd3d0rff/XajGz\nZqVgxuFw4OTkRPBTpgQRnXA4HBIYU61WoSgKVquVeO6azSYGg4FkU1itVvGymUwmie1iidFsNtHr\n9dBut9HpdESo/9FHHwnNPBgMxPHN0BdCdoPBAJ1OB7quiyi/Wq2i1WqJvrjX6wnaQTgRAE5PT+V1\n7e/vYzabSRQWSwGSLLQvUWjEXZg0NJnQfD6PwWAgbGi9Xpe8DfoOWdpczOVot9soFApSVhACrVQq\nosY7OjrCfD6XaLLxeIxKpXKl7/9aJRp985vfFI1ur9cThosZEbTs12o1JJNJgag0TRNLFb9ILiiH\nwyGCI3rpgXcGAAAgAElEQVT8JpOJEBOkcG02m7BkrG8pKGK9DEB+3u12EQ6HRePAPAzu+Iz+oqKP\naAbdNIS8qMjTdV1uUGo82MgVCgVsbW1hPB4jGAxKk0yh0avPDy6XS3QZ4XAYw+FQtCcMhmk2m4jF\nYqLvZsadw+GQml5VVezv78Pv98Nms8FqtULXdXHAOJ1O1Ot1JJNJiQaj7ew3f/M33yYaAYCu69JY\nnZycSDLl3t4eLBYLjo+PEYlEUK/XxdVRqVRw7949SdqZzWY4PT3FvXv3cHh4iLt37+L58+e4ceOG\n7JT0FLLZ4S5DnDsUCmE0GgkzV6/X4ff7JamzWq1KXsfFpspms2E6nUpjyXqTATOVSgXRaBTBYBD1\nel1yKVhTU2HHBKaXL1/CbDbj6dOnl2IB6ERZLBaCP5P27nQ6gpfTCeP1evGjH/1IwhuZqKqqKj7z\nmc/g8PAQAETu6nK5hNUbDAaX3Oq8eb1eLwaDAcrlsqA3xL1f97pWO/PXvvY1JBIJ1Go1BAIBbG9v\n4+DgAPF4HNVqVaSh/JIePHiAP/qjP8KdO3dgsViQzWYl7GU2m+HevXv45JNPMBgMJLtiMBgIwwYA\niURCcjlqtZrseKlUCt1uV8oAitsXiwUCgYDoGEwmE6rVqsgj4/E4crmcMJfNZlN2cmZpsJkju0gC\n5f3338fDhw/RarWQTCYRDAbRarUEWQCAZDKJH/zgBwiFQlBVVVRrhmFI7U1vZDweR6fTQaFQgMlk\nElSFFrNYLCaUORlKn88HXdeF9ez1egLrsYcg6hMIBEQF6HA40Gg08Ad/8Advd2bgx9FcpFSdTieq\n1aqI0UulksBS6/UaP/rRj6DrunzZh4eHUlc7nU5873vfE7tQrVaTxxmPx7KAWq0WWq0Wtre3MRgM\nMJvNBB4DzmWpvV5PvsCL7ufBYCBIQr1eRyQSkXqXiaTdblfez0WTLBV79XodLpcLnU5HYDDWyuv1\nGt1uF+VyWUoS0vPtdhs2m008fvP5HF6vV3LvaMotl8tCqe/u7iKfz6NYLEoQjcPhwPPnz8UCRSnq\nixcv8MEHH6Db7Qpt3mg0xDNZLBZx69YtqdEZA3yV61ot5mg0KouDH2AmkxGigOk5JCBu376NFy9e\nIJvNSo1NyxDF4kyyVFVVogXS6TRqtRqsVqugDvxiWfuFQiHx11HySScKPXB0fvDE+MnaXFEU7O7u\n4uTkRBADZiiTfibyQnJntVoJ3svXzNDvi3Af47EODw8lDIYQnsfjgaZp6Ha7SCQSAktyx2bN/eUv\nf1nqcU3T5DGcTifef/99kafyJGK/QQOC3W6XBClmlFzlulZoRq/XEyuPx+MRmpbZxQxL6Xa7smPQ\nt+Z2u+Vo3tnZgd/vF3aOZYTD4YDVakWv1xP2i6whAxNXq5UIdoipmkwm1Ot1YQ3JVHIRs6EMBAK4\ndeuWiIbozmaJwKkA3W5XUBXutIZh4Ctf+YqUIQ6HQwwHjF7Y2NgQ9i4ajUozCkCaRWos+v0+QqEQ\nlsulnG6NRgOBQAC3b99GLBaTm5PiLjpZmF1y0aDK9CLqmQnZ8e8DkI3oda9rtTPv7u7KEdtsNiWN\nnYJ1TdPQbDYxHo+xtbUlwd1M62Rj+MMf/hDpdBqPHj3CrVu3UK/Xsbe3h1KphF6vh93dXXQ6HRmZ\ncHBwIOUD0ZOHDx+K1arX62E0GkniPj1z29vbIuJxOBwSaUvPIp0cz58/lxuLzN/BwQHu3LkDj8eD\nSqWC09NTiR2j8IdwHQmc09NTsXDVajXs7OwIDBkIBBAIBCQrOZ1O46OPPoLf74eiKOIkyeVyAjHy\nFKDemzkYmqah0WggEolITV+r1QR/7vV6YqAlW8v6+SrXtWoAf+3Xfg3pdBqNRgN+vx/b29t48eIF\nEomE0K0AUCgU4Ha78d577+EP//APcefOHQlOrNfrYiS9d+8eHj9+LLFTbrdbRErUKaTTaZGKNptN\n0T0kEgkRqNOISn0ETbLckS4iCqlUCqenpzJnhF495iYDEPVdMBiUHW+xWOBLX/oSvve976HVaiGV\nSiEQCIhiLpVKwWQyIRaL4fvf//6lHA2PxyOjMqjE83g8EhJO7TQRkQ8++ABPnjyRxKbZbCajIxhK\nQzy60+kIoUOokhJTWrPYADabTfz+7//+azeA12oxf/Ob34TP55NMDCbIUzfM2rdarYoplVRwqVSS\nfOblconJZILJZCLOFMMwEAwGJUaLBAsA2V2JqbIJ4mtheUEnB7v8YDAohA5F/rQoMeiFODMNscR2\nAUiyEL1/dDiPx2OEQqFLxAtLBqZ5djodSTBi2hFfC0uS4XAosCIXPKcEMH42GAyi0+lIWpSmaQiF\nQhKnQHktYx6o+S6Xy9jY2MDBwYE4TMxmM37rt37rLZoBQOhbpuik02l0Oh3s7Ozg2bNnElZCXLdY\nLOLo6Ai/9Eu/BJPJhNPTU0SjURwdHYm4BvixdWk0Gol/jSJ1NkpskE5OTiTettvtSuYF2T5FUUQZ\nRziu1+vB5XJhNBpJ6UNV2mAwEMlpq9WC1+uFruswDAM3btxAtVqV+n08HouGeDgcolKpIBgMolar\niQ6brKbT6bykIe71erh9+7bk2fV6PRweHkLTNJn9srW1hf39fWQyGdFhc7YLwxYnkwnK5bLk2zF6\nl2wlk5zS6TSOj49xdHSE4XCIeDyOR48eXen7v1YNIO3+Pp8PmUwGsVhMPkgygyQuWDoAuJSwmc/n\nZRKTxWLB/fv3MZlMZAZIPB6Hz+cT0oSLjbVrKBRCJpMR4TqllTS38r8pxp9Op+LrYwIQM+yY00aR\nEcuJcDgsoieiFmQwqXOgwo8sJwVUgUDg0pEfCASg67o0bWQwAUhjmk6nYbPZpA8hXV8ul6UGZonC\n7+FiBC/ZSiYlMfqB6AwjDiiXfd3rWu3M/X5f4lsDgQC8Xq+Ij0ajEe7du4f1eo1cLof1eo1f/MVf\nRKFQEBf3r/7qr6LdbmN3dxfr9Rq//Mu/jMPDQ/lS6FBhc7Zer7G7u4vZbAaXy4Xlcim75t27d8Vg\nu7m5iW63KwIeQncU+XQ6HVitVqRSKSQSCZnwxMgCegqZ2EnHNJPuuSi+8pWv4Lvf/a7Y/D//+c+j\n1Wqh0WiIN5DmWjpI+v0+7t69KygMhfmLxQJf+cpXxHsYi8Ukfvezn/0sjo+P5UZIp9NIJpOy+FVV\nFSc4R67REU9ZAbXcvLF4mj18+PC1v/9rVTP/xm/8hgSOx+NxoYopWD84OJAEIy58kgkM2bZYLJjP\n57hx4wa+//3v486dO4JyOBwO5PN5ZDIZ2VnD4TAODg7gdDrR6XSQSqVkxz47O5OJTGz2iAAUi0Xs\n7u6KCIgCKKrO6DKv1Wrw+XzybzKBdH9wgZVKJYxGI8nNY0QtpaFUEFosFmkgycjRysRSxDAMiQpg\n2hEx9NPTUwmX5MSAer0uDhQmI1HjQQyeJ+T29rYwgnSGc7zGw4cP8Sd/8idva2YAl/LTTk5OkMlk\nRKzPzDhivGSiSqWSgP5Ucem6jhcvXogQh40krVMU1U+nU9TrdSEp2L3Te0h7EbFqKueI5xKpuJia\nxEaMfyeRSIimghYqivy5ABlzexFRCAaDkqF8kWbmdKxgMChZdsxGJvLCcqPZbEpaKHCuU3a73RKT\nwPfD8qbdbiObzcLr9YqakDpoBk1e9ExSJ0Ip6duogQtXr9cTL1y9XhdXcaPRkGaOKjIOaCwWixgO\nh+j3+9B1HZ1OB6VSCcvlEq1WC5PJRMbzAucTSSuVClarlUR9DQYDFItFVKtVybB48eIF/H6/sGwU\nELXbbWENaZjN5XLyxQPn4xcePXqEZrOJ/f19iZZ9+fKlHNvdbhf5fB69Xk8gQebPMXCl2WzKv5ld\nx5mGpPHZHH700UeXXiNwLiut1WoYDodCz1erVZycnOCjjz6SiQP7+/uXUkEHgwH++q//Whg9Mn9U\nEzKXg+E0tJz98Ic/vNL3f612ZsZdUYTDwBWKYIh5sllSFEUEN5FIBBaLBdVqVVKMOBaiUqkglUpJ\nLAEhtXg8jlQqhfl8jtPTUxHqM2eNKT8Mn6FYh0gFa06Xy4VAICDHNIXzbKoikQh6vZ4YcGOxmEgn\niSUfHx/j/fffx2AwQK1WQyQSkcfj6eB0OhEKhVAuly9N3qL1iuaE0WgkzpfVaoVMJoNGoyGoTTab\nlXR+ZnhwABBw3gDev39f6PF4PI5arYZsNivZcqzh+dy6rl85Of9a7cyse7vdLjY2NjAajcSSw2gA\nfpBMHNrd3RWtcLFYhMPhwAcffCBw2XA4xP379y8lwnOK6Ww2k6ziVCoFTdOQz+dl+A4F8bFYTHZ6\n1qBUpLG+Zj7c2dkZlsulBJlfLDvu3buHVquFWq0mU6+Ojo4AnLtXLqYIcehQLBaTG5PBjjw9qF+h\n0L/f78Nmswkzubu7K3G+DGrkfEKOq+Bzc+oVoxaIXjAzj3U+iZ/pdIqzszO0Wi10Oh1EIhFx4rzu\nda0WM0MEedRdPMq501AcztqVc7OPj49FYD8cDkWrTHz34OBAJJccJkl9Ba1YFDKx1tY0TSBARVEk\nuJs5dcFgEFarFbu7u9JIUaNMPx5vSmK2xMoZysIoMTq3V6uVMIz0JRIn56nF/Ds2aD6fD9lsVnKs\nyUgSleCQn9VqJZ7CVqslOXIul0sE+2Q4OVtQVVWZ90fzLMu/3d1dsaIBEJ3I617XajFHo1HxyjFr\njSIb4LzepcTzopOYXT/F7aPRCMFg8JJL5aIwhynwwWBQ0ISLY8moT6AskjNHmLQJnBM8vNlo108k\nEpfm41HOyh2amDTjAbhDslyg04UiqYupRZx2xRuUN5TFYkG9XpeIrvV6LVOpSLCwDOBnVa/XJdeZ\naBDFWhy1xrFwlAZwhBwAubEp2KLV7arjhq/VYqbHjaMJSGK43W5EIhHJkgiHwzCZTPjGN74h9enF\n3ZM7zu3bt6GqKjY2NpDP50VzkEwmpYRgCihJCS4aTdOkkWJYDONgZ7MZ0um0mDkJZ5G9JEphMpmE\nOSNxQmPp/fv3xZ2xXq9x48YNRKNRCcC5mOi0ubkpRAwpd2Ljq9VK4nsJ9/GGDQaDcjLYbLZLUtn1\neo1sNivGBZZZvGlJhtAl73K5kEqlJCeaTCgD2JmncZXrWi1mBqMAkJ2XGC79f4xvtVgs+N3f/V2B\nkJj03m635QN++vQpPB4PCoWCDNCJx+Oi8wUg5ljuRjy2qVVg88UZH9xtdV1Ht9uV3Zy1K28KwzAQ\nCoXEo8jFdnh4iNlshkqlIrssiZdCoSCxsfQAMqSRr+0iEUNJZqPREP0IP5/1ei11fyQSwXq9Rj6f\nlxiGxWKBs7Mz0bgUCgUMh0OZgtvpdFCr1SRdaTAY4PDwUDLw1uu1jMAgucTv7nWva7WYCa15vV6Z\ntrpardDv99Hr9UThRYeyrut48uSJNCrValUWf7PZRLPZxGw2kwR6jnoYDAbo9XpYLpeo1+sAzskF\nSkSn06mI+pfLpUw25fxpjmTg8E2KcihCYrYFQ2lqtZrMHWQUVj6fF3qe8BthOr/fj1wuh7OzMwlS\nBCAWrVAohHw+j+l0KtoKDjSi2Ii1M8Nu2CMQmuTi43QpPn6tVsNyuZSkfAY8kjKnhIAacc7q5glz\nletaQXPdblfS4Cm8Zy1IZRe9emyCqEzjF7VcLsV8ydkhTNFknUn5JuEx4tLMkqOAnmqzP/uzP8PN\nmzelsWLcLlP4J5OJ1M2cbUIEoFQqSbJ8Pp/H7u6uRBWUy2WZoMoTwul04vj4WGxZxKQNw5BTh8J9\nyl1nsxnG4zEajQba7bYYU3O5HOLxuDB4RGAYS0AGks0x7VakwGnv4vAhOsGp075oAm40Gm8H9Fy8\n7Ha7hB/evHlTglISiYTMKSFExQ79wYMHmE6nuHPnDlRVRTwex+c//3nRC6uqir29Pezt7QGAfDHE\nbGlz4iTXyWSC0WiEW7duodVqST1rtVpl8DyDwWmMJYvGkoei/kAgAIvFIlG9X/jCF7BYLGCz2ZBM\nJhGNRuUGZRA5bf0mk0kEV3zf8Xhc3Dcsjbxer9TWZA8pZHrnnXdgGIY0nDS87u3t4b333pMmc2Nj\nA5qmSTOqqqrAmbxBORErlUqJu50eRTa2b0NgLlysvxKJBE5OTmTHYbCKy+WSBU+56Icffgiv1yu5\ncqenpzg7O4PX65XdsVwuo1arCRFis9nQaDQAQPDqSqUi6fbBYBCFQkG0FFy49NNxNPB8PkcoFBJI\najQaYWdnR2r/fr8vtDRwznD6/X5ks1lBFKivGI/H6Ha70HUd9+7dk3hceh8pSqJovt1ui/aZ5leq\nDBl8Q6wdOO8NOCelXC6jWCzKjcjPhG4ap9OJs7Mz0XirqiqnHxvG6XSKTCYjoiuGU17lulaLmePO\nDg4OsLe3JzYdMmfPnz+XcJf1ei3/jyHYtFwxmJBA/0UJI3FVAGK9Z/RUv9+XnYbjwjweDw4ODkRj\nbbVacXZ2Jk1krVZDPB4XAdDx8bFkTlD0RAd1rVZDrVYT10w+nxcUxul0yjFPkQ+H3qxWKxwdHaFc\nLsuUVe7qjNsi9HcxXIZzDKlb4XzCyWQiZYnFYpGsDeZSc1GrqoqXL1/KaVKtVqWUWa1WaDQaKBQK\n6Pf7Qt1f5bpWNTMpW5vNhrOzM3H9khb+hV/4BYlYJcZLS5PH40EqlQIAHB8fCxXLY5Y1bjQaFa0D\nm0IaTZkFx+aGOuV3331XBkl2u11sb2/j8PAQuVwOd+7cwcuXL5HNZmXeB61KzOoggcFRxXTChMNh\nafhY5wYCAaG7Cf01m03cunULjUYDDocDW1tbElAzmUxw8+ZNsWVRQ71YLJDJZGTMMo2zJFrcbjf8\nfr8I6ymBJc7MyNxMJiM3GrFlirRYc1NPAwB/9Vd/9drf/7VazPyCAAjiQG0EXdDUKjCSi116r9eD\nz+dDvV4XbJQNJZVkw+EQw+FQxjSwSSQZ0m63ZSYg0/UXiwUqlYpkdZByp0KPdXQ+n5dxCkRKKDxi\ngmir1RIyp9VqyQChVqslC4mjH6jKG41GKBaL2NzchMlkEhKl0+lcYuqoFmw0GjLtlWo2lhsUDjmd\nTgkPJyZP0wPnCc5mM9RqNcGsq9Wq3FgARB8D/Dg1dDweX+n7v1ZlhtfrhWEYQooAELaOXTU/dMJJ\njL/iImcsFus6Cvu5g9AadHHsA1N66ARhtgSz6OiqoG6CyAfrRJpSiX+T4CEdTe8c/YgApAShPprJ\nQbwBer2ePD4TUCnx5ONejOHt9/uXyin2Fsy5YF0MnDe5xNEpKeX4NFL7JF2YcsoShcmjfr9fSCc2\no2/p7AtXPp+HYRhyxIbDYclEowCJaAfhNuDH0tH5fI5kMimIw/b2tjRQ1WpVspNp8eGRzClPZPIo\npGfKZrVaRb1eFwz64OBA0BRS5P1+H3a7Haenp1Izq6oqxANd1s+fP8fBwYEsZir5eJOs12vs7+9L\nxCxxY07d0jQNtVpNfH4sWS6eIEQtyPA1m03k83kEg0H0+31sbGxIVDB9hKTMSbxwI6CICoCI+Dud\njkSSES8fDoc4Pj6+0vd/rcqMbDYr0FupVMJisZAoAArKWZtNp1Msl0upNznfw2KxoFwuY3t7G51O\nRwgPzgcMh8Oye3NqKScmud1u+X0KkkwmEx48eIBcLifYbzabxYsXLwBAdtubN28CgCzKg4MDaJqG\nO3fuoNlsSt4xg84phmKaEWFETdPwxS9+EScnJ3LDWiwWiT5YLpdIpVKXBksyTejGjRuo1WryfiqV\nCrLZLBqNhhA0LpdLCCHe9BsbG5LrQadMLpeTGz6RSFyaheLz+YTc4qajKApu376N73znO6/9/V+r\nxUzT6Gg0ws2bN2W4JDFYhh4Sp2Xjx1RNqti+/OUvXzK1MvqKRyqd2Ryyzi+R5lLGupJkGQwGUrcz\nRsDtdiOVSkmjBUAyLKxWK+7fvy8qQE5TpaieTpLVaoVUKiUjlEmH53I50SdPJhMZLq+qKmKxmCQW\nUU3H8oE0Nhc4zar0U7KeZ+NnGAa8Xu8llpGqxI2NDQlUZNnH98cJASR8SPaQCn/d61otZgBCXfPD\nyufzuHHjBp49ewafzyeeO2ZA5PN53L17FwBwdHQkKZxMQcpkMhiNRkilUmg2mzJplWMOMpmMDLBk\nTobX6xUfXjQaxenpqZAZlFFWq1WxQtXrdWEuB4OBjJKgXgM437HL5bLkJNfrdRH3cN4IAJlv4vF4\nRILZ7/elxqcvkjoNUtMUP7GM0jQNP/jBD3Dz5k2h6UOhEEqlkuiiOV6OJxFnZTscDpRKJdGxkLpn\nw8dm9y/+4i+QSqWENudp9brXtVrMgUBARPjEkblTkDHL5/PQNE0cIz6fTySWsVgMzWYTiURCnNjR\naFQICtLTi8UCkUhE/IYWiwVbW1vi8ubgRu7ioVBIbiSOLPP7/UKnMwaBijcOn+eQyovyUWK2Ozs7\nsiBjsRhevnwpJ8Lt27elAWM5Qe9iLBZDLpdDOp0WMoXZdgyUofz0/v37MJlMQjYtl0sJPGezerG8\nYcgM2VE2pZTjEl+m129zcxM2m02mxfKEet3rWjWAF8MJg8Gg1GSr1QrxeFx2QNbJDBnkbBIuPIac\n0BVBOxFNmOPxWBIvKbfkUKCLORdMMGKICwdk0p1MfBqANKZer1coeEJfxKuj0SgcDofMGnG73dLA\n+f1+gREZpEisG8ClkW7vvfeeCPndbre4wTVNExSDNwazLjRNw8bGBnw+H9555x3E43FprAlRMp/D\nbrcLle9yubC9vS2oEV//bDZDNpuVuYOBQEAkAa97XavFzN0DOC832u227GzEoLloGa/V6XRk5t1s\nNsNsNkMul5Nalzg05/Qx8YcKL5IEq9VKfk7pJ5NDya5R08Fxv/TDkV2j+P1iMpGiKKJEs9lsooku\nlUrC2AEQGahhGPL3uTPSB0mamTsrcI7NE1lgiUMTA3PnWPJwnBtDXwhB8vMDICZfMpcOh0PKHAbM\nDIdDzGYzOX14IrBUet3rWpUZDodDZjAXCgUEAgGpTUmdcmcFIEQE4SjivdVqFTdu3JB8t9FohFAo\nJNQrmbbj42PJVpvP53jx4oWMLeOIhWw2i48//hg3b97EaDSSDp8RBxxaTxMudRgWiwW5XE6cJnQ1\nEwmg/467f7ValezmRqMBn88nQ4esViseP34s4qOLcQesV5kNQudJOBzGixcvcOvWLamz1+s1KpUK\n7ty5AwAy4o2qOo4/I4O5s7ODDz/8UNAMEiiDwQA+nw8nJycolUrisKGc9nWva7UzD4dDxGIxgaIo\n0Kf+wul0iheQx6/H4xHBeSwWE3WXw+GQbAqyeszgIImQyWQkItbhcGBjYwN2ux2JREIym8fjMdLp\ntAyOZCNmt9vFrGqz2SRgnHnRrNdJPCiKIuTH9va2zMter9cSCAlAAiOpAGQCPnsIlgekqvk50Huo\nKMqlYHMK+4mY+Hw+wYqZthoIBLBYLC7NDySUmclkLvUlpOhJbxN14ed8letaLWZqhRl8clFj7HA4\nEA6HcffuXdnpvv71r+PFixfSXPEL59/d3t6WCazPnz+XLGLOiWbKPFVnHLfQ7/dlpAIDwxlGbjKZ\nEAgEkEgkhJpm+cPRYiyLdF0XmSjpcvrx3n33XcnQcLlciEQi2NnZkRqa7B6jCbi4xuMxVFUVCnw0\nGmFzc1OylcnIseS66CKnu4YL+otf/KIYIO7evQvDMGSHppyVtLzD4UAsFhMaezAYIJlMCmxK7+RV\nrmu3mDksnblubMbIVp2cnAiM9Du/8zvSsTscDmn0qG57+vSpTIn67Gc/i/V6Da/XK8J0UuZU1tG5\nzLwJDuBhPgZdK4qiIJ/PS6O2Wq1E6EQNM4MMiaIwXouumMePH0sJslgsUC6XxWHOHDdGDnBUMmN2\n6dEjRX94eCi0PN04F6WbDIqs1WoSx2u32/Hw4UOEw2EJnAQgWpXxeCz5cV6vF/P5HNVqVXZ9pqrS\ndMu5Kle5rtVipsKMNSE7eLJq/X5ffsaGZ7VaSQI+pZsAhOigOu3p06eCKFD1xWGYTqdThEntdhvD\n4RAAZNwC8V2GwLAhm81mWCwWwpaxGaVnzjAMcWdQ4wD8WFA1n89xcnIionqO/3358qUM4Wk0GjCb\nzQiHw7BardIQE5HhTTedTmVoD08aNop8LjZ1HBwfi8Uk3ovzCAHIeGbe5LRWsV6v1WoSKcxcDeqk\nr3Jdq8V8MZ3T6/XKFKaLugVCciaTSUYHZ7NZ6eAJ7VFZxgRQ1qs0krL+pD7jYs4Gm0WWOBe1yYw6\nYEnD2SuEyWaz2aVwFr/fL4IiLmafzyejzliLspxhOj5PJeBcGnt8fHxJa8zyhK+dsb4U2XMsBgNi\nFosFksmk4MK0hlE2qqqqSAYURREFIeE6mlXJ9nHYJwDs7OzITn6V61otZkJoJpMJ3/3ud8X/RmF7\nr9fD2dkZcrkcDMPAxx9/LJFcFOZTCMTjtlQqoVqtinlTURQR2p+enkodPRqN0Gw2pVkiccPxxWxu\nCHfVajVxKr98+VLeQygUEsr78PBQhj5SvEP9NTMwLBYLFosFjo6OJAjxyZMnUtPzPft8PokzsNvt\nYv7t9XrY399HvV5HLpeTkcI0InCQka7rODg4EPaQPj6iHMys43tyOp1y+i0WCxQKBei6jlarhXw+\nLyeRYRg4OjpCs9mUPLvXva5VpO03vvENAOeoxmKxQCqVwmg0QiAQkKHrmqbJh2i1WtHv9xGJROTI\nj8ViqFQqCAQCqNVqSCQSaLfbCIVCcLlcODk5kbhYHsG6rl9iz+je0HVdEoiAH4fQsAHlbl+r1aAo\nCrxeLwqFAnZ3d6EoClqtlkTvskzhjMLxeIzbt2+jUqkgmUyiWCxKvkWv1xOpJYfqkATh+7fZbPB6\nvYKIUIP86rNEIBDAeDyWnZgpTqxrecoBEKkrB3ayvGDqkdvtliE89EISdalWqxJa0+v1rjTT5Frt\nzMWIwIUAACAASURBVPzwmB3MLx+AfGDMauNR+vDhQ/T7fYTDYezs7GA6nUrGM0dGUNbInZb1KGWb\nTqcT0WhUnq9cLssOyFnWTBulmIfDNRmUyAZsY2MDg8EAlUoF3W5XalFOUiXURl1Fs9lEqVRCo9FA\nJpMR5u0nU/CZMLS1tSV2L6IZFBCREOFjhEIhSUelk5uqP5p5+dlQn00Eh8pCjm5jCcXanL0MCSwO\nPbrKda0WM+flLZdLsSExSYhlgt/vRzKZlKC+nZ0d+XtMsOe8kHg8LtJLkh1utxuZTEbqTSIjpVJJ\nglWYt8bSgNroiwlErG25Q1HYTgUelWqcnzKbzVCv1wWTdblcCIVCoi3e29sTXyEDYJgdnUwmJeiG\nC8nv9yMej0NRFESjUamhfT4fotGowHfUlXC8BCdUcb4KNSCksdmfMPOagemhUAiBQAAAZEIAMWcA\ngthc5bpWDCDLi9FohCdPniCVSiH3ag51pVKRBUlqmV8KVW8cTs6gFHb6xKnr9TpWqxVOT09hMplk\n5APrbe7ezNIg2cGGidOr6LrodDqIxWKCgrAWpdSUuzjw41xohh/+ZC5boVAQtIV5eazN2+02dnZ2\nUC6Xpf5l0OJyucSzZ89EZcfdlKpC4LwMInxIlKfT6eDo6Ag+nw+NRkPCKjkOIp/P4zOf+Yy42uv1\nupyGVPNRW16pVMTCdpXrWu3MTqcT8XgcgUBA7niyetytaGciAXDjxg2MRiPcv38fiqLA7XZjc3NT\nsGoGJJJ4YNYzmUZKNPln1tAckh4IBODz+SS3gySJw+GQNNJqtQqv1yu6aVqskskkFosFEokEotEo\n7t69KzQ2d0/CgNRHc+fmc1MvQgMqJ7/y7xK9GY/HsFgsYp5lWTKZTATF4HvkwCOyp7RjMcaLMxXp\nqzQMA4qiIJVK4ebNmwiHw6LRps0rFApdOdHoWjWAX//612V+HTHe4XAoi6zT6UiUQCQSkWiqvb09\n1Go1mXGiqqrY+y8SFVxsbOyIWTN+gKybqqoCyVFcREvRYDCQnTeTyUiSEgNROGbhohEAgGRyAJCd\n0zAMaQY5NJMQGLXDtExxRATHyZGJYyQYE/07nY5kWVA3wosZ1tvb26L7oD2MiUoM2Dk8PJSGk0QL\n4Tev14tWq4V4PI6PP/4Y8XhcXN/f+ta33s40Ac4bQCIFAKRBymQyUmb4/X7k83mZiVcqlcTQWiqV\nEA6H8cknn+DGjRsoFotSa2cyGSiKgv39faTTaQDnx+/t27dxenoq5AZhOWZZ+Hw+CQgkKbO1tYVW\nqyWlAC1QnU5HRDt0ceTzefj9fvR6PXGJ0LKfyWTk98vlMhwOhwiRaFz1+/1CdDBat1gsyk5JzyLt\nWERyVFXFyckJdnZ2pNZutVoCUzJsZz6fS7AkMX6WKCx5Op2OSGbZfHP8BU/K4XCIv/3bv73S93+t\nyox33nlHpJN0h4zHY/j9foGsCoUCer0ebDYb0uk0bt26JfFRzH4gW8WOu9Vqwel0Qtd1Cd02m83i\nFOEX7HA4sLe3h0wmI/44nnyRSETkqUyMZ0onSRiOEKMYirU6GTaeDBw5RnsTUzQzmYzQ0ER06Ptj\n1pvZbJbH4/Pruo7T01OEQiE0Gg0RVHHXZ7QBm1SKmkqlkliuqtUqhsOhmCMo2OJ74aINh8Oiw7bZ\nbIKQ8Ma+ynWtFvNoNILdbsft27eh67qwcMPhEOPxGNvb24hGo8hms/L7T58+leOWOmEmcZIgoAOE\nWDM1vIvFQgaqr1Yr9Ho9Yc04IZZ5yPP5HLFYDGazGVtbW0ilUqhWq3A4HJLyQ2EP6WxqJGazmexy\nzMpgXVutVkWmms/n5fgn0cL4r1AohHQ6DV3XZUfmPwyQ6XQ6yGazItzXdR3j8VgGVM7nc0SjUTQa\nDek7mPO8sbEhs17G47GMcrtYj5Oh5fPSNEGChWaI172uVZlBRVs+n0ckEkEwGJRwQIvFglarJeId\nBsL4/X4oiiINXzqdFpaNkBaF+0RKmBxKZzUdHABET3FRNRYIBGT4OaOumOcxm83EgkVVWzQalbgv\nwnM0oNIdTSE/cE5X7+3twePxiNE0Go3KDcJkUgASGH4xuszhcAhuTNNsPB7H9vY2FEUR7yFPvAcP\nHiCfzws+bLPZRDDFBZpOpyVEh2OMiV+rqioumKOjI5mJ8tZpcuHiLLrBYIBEIiGEAcNRqBpjorvd\nbsfe3p4sFsZ70d3N0b4cEQGcL9ZEIiGa4VQqJdpn6ik2Nzehqira7baEG3JSLMkFm80m7g9KUFVV\nlUDGdDqNjY0NjMdjaJom6UO1Wk2GaVJcRLZuPB5L4A2tVByswxKHo9CIaVOboaoqRqMRNE0T/Jnl\nxI0bNyTqS1VViXFwOBzi2GE+CWtzNqScB1Ov10WZyJtmPp8jm83C5XIhHA7LHO/Xva7Vzsxhj5qm\nSaPW6/XEDa2qKnK5nEBrxDt7vR7u3bsnCjRFUfDkyRMoioJisSiDdZj1fHp6eilln/kUvV5P/j99\ndX6/H/v7+/D5fMjlcgLV8Yter9c4ODiQm4KZ0C9fvpR6neo1UsqcPciprjabTY7y1Wol+dOcsnV2\ndoYHDx5IrV8qleByuUTUVCgUYDKZkE6nRS7rcrlQLpehqqroNfx+PwqFguiQL0Z8UYlHRSFRDWpX\nFEURBKZcLosYi/R4PB6/smruWkFz3/rWt8QFTbiL+RX0nGmahmaziXA4LEA9gX6OSqP4vN1uIxqN\notvtioictTHtV/T/EaMmKzgejy/Nhma9SHiK0BTDvinKobOExA71HhwqxKaJ8B0AoYh5IwMQRo+D\nKtPptLB1hmHI9FWOgCAuzc/m/2fvTWIjTdMzsScYjGDs+75zX5JVWdndVdXVDbUgoaUWIMD2QbB9\nMDAwfPPBgiEImjnqMjB8kQUddDIaAx0MDGBpZB1aLVVD6pbVKk11rZlkMrnFvm+MIIOMYGw+sJ6n\ngpZkA0nMtETUDzQ6i5kMBuP//u973+d9Fopt+/2+DBOtVqvkaGyKWdOz5LJYLHC5XHjx4gVWVlYU\nmtTtdtFsNnVCVatVxGIxHBwciLvt8/nw27/9219xMwAo8anb7SoMnuy3RTvWwWCg3D1292z25vM5\njEajUA2WKhSeLvoQkzBDtl2/30e32xW7jg9Et9tFvV4Xx5pQFxtDAKrHFw1VCGfRQ48sOJqJ03OZ\nOyJPB4bVk5dC+ii1jFSvUE3CYB3ymLvdrnBu/u6cYM7nc8TjcSlISB0tFAryZl5aWpJXHh1Tyf/m\n58TPjIkGvH8PuR5VmcH8PRqJs2FhhgdZYAyeoXjVYrFgPp+jUqnAbrfj+PhYjSJwN13joq/X6+L/\nslHkhOvq6koEnXK5rHQnBkESCru5uZHzktVqVWaJ2+1Gs9kUt5lWYTRx5OIhlEfiExvMRqOBJ0+e\n4OTkRLs/3z+xbFJj2fhS7sXFvyhwYIlGSI+BQp988sk9X7nFPER6WxPbbrVaeP/99+FyuTQQms/n\nsFqtqFQqMmpcWlr6ajEvXtT8+Xw+PH/+XJozjk37/b4ytdfW1mRgyDhhGhXm83nFJdAEnMd6KBRC\nuVyW2XYoFFLOx3Q6lT6QtNJUKiWnHrPZrOO01WrJ5Pvk5EQDCL/fL7NCngCMKO73+9jY2MDl5SXy\n+TxWV1e1E/d6PU3m6KBEeufFxQW++c1vqoyhRjKXyyko02AwCJEYDAYapWezWbkmVSoVGI1G+ekF\nAgGMRiMpdmiQw5OBGDRtvlKpFLLZrJxO+/0+vF6v3J9yudyD7v+jKjOq1ap25EQiIaql2WyW0plj\n3eFwiFgsJk0eFRtLS0vY3d2VDu/y8hLj8VhwV6FQ0FjZaDQqKm19fV0DjpubG43D6VZP7JY3mgwx\nxjqQgEPOBkWp1CNeX1/j3XfflQMpANXtVG3kcjk9SFdXV0ilUmK9MQAoEAig1Wqh1WpJSsWfSTst\np9OJTqej7JHz83OsrKyIXcif53A4pG+Mx+MajcdiMXQ6HfHAiYTQ0YibBi3PMpkMEokEvv71rz/o\n/j+qnZlukjQxJG7sdDrRbDYRCASwtLQkM+2vf/3r+L3f+z1873vfQ7/f140ol8uS0FNizykaSUP5\nfB7xeByJROIeMZ5DlWAwKDUGH6ZKpQIA4gHT0jYYDMpmgLU7c1BWV1fRbDZFZN/b25NaejabSVlN\n3jWZd6SbMkKZSQDME+dYvFqtIhKJSKS6uroqeiktgClrItxJJCIajaJSqWhgwkGIwWDAzs6OamHW\n/SzFrFarBjqJRAIGgwEul+vBCa2PajFzxEvcM5FI4ODgQAhHtVpFIpGQWvmv//qvcXFxoQV0e3ur\n3WM+n+OnP/0p1tfXtZsAdwuxUCiIRHR+fq5FzmleKpVS7shkMpFsi7vxaDQSsYcppcxFYYxEsVgU\nZmuxWPRQnZ2dod/va6o3GAyEP7Nc4I5Nf2oy05hJmM/nRS6irGtlZUU0VJKhWq0WvF6v8hHfeOMN\njEYjpNNpnJ6e4ujoCH6/X0Y6FxcX0lMeHx9rgbMBzGazWF1dRbVaVT/A/gbAgx2NHlWZ4Xa7EQgE\n7imfGQlGEj1r0EQigZubGzx79kxNT7fbRTweV5fPiRv9nUnhpIcdWWNckGTXkWhEwxia0jDPLxQK\nyRaBDkQczpAjQggNuPPQoxuR0+nE+vq6kBgS6jOZjDzq7HY77Ha7FjEpoNQ0kqq5vLyMZDKpBpY+\nHlarVTAdhaypVEqec8+fP4fdbleNHQ6HMRwOJd/qdDry0qPRIjNlaJDDptTj8Sj+Ymtr60H3/1Et\n5larJaiMHyitZ6m8praOuwCJ4TQ+zGaz99AQBlAyzIfjYZLyLy8vUSqVhBww+4OjZO5ANzc3aDQa\nSjbl2NhoNKq2pvi2XC7j/Pz8nkh2Mpng6OgIo9EI5XJZkn2qoOlHxwg1ohHX19figFBGRYiNjSQN\nZgaDgWLTFk84+tqRA12r1XQ63dzcKFGKjfJ0OkW321XaADeTfr8v1hwbZnqL3N7e4qc//emD7v+j\nKjOoPWMEwng8VvY0rVdpMUA+MY1ZKFUymUzI5/OiQTKhlAMCaveY/+f1etUI0nSQuyfVF5ubm+Jl\ncNTLJCzu2g6HQ1Fku7u7SKfTODs7Uz27tLSEJ0+eyDO63+8jGo1KEU03ImZ4MzWAUjCeFJRD8YRg\nzHEkEpG7Pl2NAoGAfEKAuxOCJwdfkyHwlHuxTn/y5Il6Ao76Kczl570IGXo8Huzv7+PHP/7xa9//\nR7Uzc9pGT2AAWFtbg8fjkT6PcBERD5YfVBVbLBY8ffpU3nHtdhvxeFxTMgo7eYTTrd7hcEhEy12d\n/A36qBEXpoKbRCP6UrCpy2azaDabKl+i0SgcDodISdPpFHt7e+Is076WCpJWqyW5FnV4tOWiiyjp\nq6PRSPKli4sLNceTyQTRaFTWvNPpFKurq8LAl5aWZDlG/2W/3w+XywWTySTlDADxOOh5R19nTkBD\noZAcjh5yParFTMcdyp3MZjNqtZoMSrrdriTxjUYDn3/+uaZ9i9a35D189NFHikVg3Tyfz/UAMAeQ\nWHa73ZYBOTkf3InYWLHM4f/oRkRVNHdS2oItLS3p4by4uJAq/Pj4WOWRy+XS1I6EKe5+zEAslUqa\nkLInWFSqMHyHsCLLBv6OzDShjIyjfzbOzWYTJycnmprm83n5i9Btlb8bdZS8Z/V6HdfX11+5gC5e\nHMlS2UAVBg2z6dc8n8+xvr6ORqOBjz/+WDesXq/fI/CQSUbrVyYnEbdttVqCxFiDz+dznJ2dKU11\neXlZN5mqEu5YbC65yMm9uL29lTEKPZhLpZJsb0ejEarVKgDcy22h1xxr0o8++gjZbFZlwnw+R61W\nk2av0+losPLixYt7UivgrqzodrsSLZDeenJycm+BM6+EZQNJ+q1WS/ZjRGpqtRqazabIXzS0oRPr\nQ65HtZiZn0FF9Xw+1wIlr4KKB8qQ1tbWMBgMxNug1eyibJ6dPxdRoVDQkUj4jP5qREuoEuGxCkD2\nWmSmkQtxe3t7L/GVpwPN0AEoQ7vb7crl/vLyEs1mU80nQ4goHiDxiTtot9vVJJFHPrPF6RNCxTkb\naUKXbK5Zo3Msv7KyIq4I7c4MBoM+Dy5QnobcTMhbuby8xNramsI4H3I9qgbQ7/dLjUweMXVxhI48\nHo9y8DweD3Z2dhRvRhGq1+tFMBhEOBzG6empMkuYyrq8vCz4y+12C9q7uLhANBrF5eUlMpmM7KYy\nX8QQEwlwOp3ySaZ6gw9SMpmU+/ze3h4ODw8Ri8XQarWwv7+vBNlAIACn04l6vS4FNAlKNpsNLpcL\nkUgEVqsVn332GWKx2L1m1eFwCFKjeJX1Kwc+a2tr4o6k02nZ/NJWN51Oi4uytraGXq+H1dVVQYGt\nVguxWAyJRAKtVgubm5sK2mw0GvjlX/5l/OAHP8B0OsXOzg6cTid+9rOfvfb9f1QU0N/8zd/UsXh8\nfCzSzfb2tthlhJii0aiErbSNslgs6Ha7ODk5wRtvvCH3916vB6fTKUUF4xs4GeQRzOOVmdCLlrcM\nvATumtLDw0OF5JDIw9oagOBE4tRkwIXDYRgMBlSrVQXIE4fmQ8UkVKYGXF1dYX19XTUwgzY3Nzfx\n6tUrAHcPAO26mHf42Wef4c033xTDr1AoyMe52WwikUjA4/Gg2+1qOEKrhOPjYyEs9KxmrszKyopE\nwjSlcTgcKBaL+NM//dOv1NnA3Q3xer2o1+vaBb7xjW8gFouJMONwOMT9/Y3f+A380R/9ETKZjPSD\ndAl1OBz4pV/6JTQaDaTTaVl/XV1dIZPJoFqtSnXSbrdhMBg0uiZhiOUKUQh6ylmtVuzv74tFR7UG\nc0TsdrvKH7fbjUqlIppmJBJBv9/Ht7/9bZVPe3t7aDQaKj04zGFgD2mYVHzf3NzIsZ7QGkk/HH0z\nu48PyHQ6xZMnT5DNZhEKhTAej7G/v696mFNPcrf39/cxmUzkgBoOh+9lKrrdbsnFVlZWpCd8yPWo\nFjO5zIwF3t3dxYsXLwDcBcdUq1WkUikFNf7kJz/BYDBAuVyWf1s8Hhd984MPPkA8Hsfx8TE2NzdF\nMG80GlJG0K6KTpfJZBLxeBxnZ2dihxGB4Eh7Mpng4OBARueVSgWxWEw1LP2Xy+WyXIdYw5+cnGB5\neRn5fF5EqVKphH6/j62tLdW1FxcXop7Sl5puRByGMJCSRzuFCLTK+uSTT7C+vq6fFw6H0Wq19Bof\nfPCB8kqIQbPefv78Ofb29hQiz82CfBDW+7RmuLq6wqeffvqg+/+oGkBygknYYe3IuAT6FlMpXC6X\nJRh9++234fP50O/3FZHAhi7zRQb1fD6X2xH1fLQIsNlseOedd7CysqLIXr/fj3Q6LX0crQSMRiMy\nmYxsb2liyAxv5gASv6bmkCN2NqSEE5lexXzCWq2GeDwuFUy/31cAJiVP8XhcwfTsNdLptAYpAFTy\n8DObTCYaxbNnYELVovnhZDLB22+/rTSAxRwZpnft7+/DZrPJWNLr9crf+XWvR7WYF6GinZ0dkdnJ\nXlsUktLIm01To9EQPTMYDMLlcmFjYwNerxflclnSIGZkL+r+GEhDp3qGXzLugTtWKBQCAJUBxF23\nt7dxc3Mjh3kA2NzchMlkkscdx9qMKeNr0PJg0Td6e3tbam9yJ7gzDgYDCW/JPQG+FAMzr5ClCNU6\nVKDQyZQIkN/vFxUAgEze2+22ZGNUyVCixaRX4C5dIBqNKhb5IdejWszU9Q2HQ3S7XQCQEw9H0Pl8\nHs1m8x5mTPiJ/hOExg4PD3UzFj3VOLXjpI96PUr4J5OJyoxFI0TyIsh+I4Zcr9dF9KGmrtFoiFvB\nQQ+taPv9vqBE4tSE9MijJixpNBoVIsQ0WYpKyQOhAIGnGndhui4tfpZseBkeNB6Ppf0zmUxy/a/V\nalrAnMz6/X4hOuRxUK1Dn5KHXI+qZp7NZojFYlhaWhIzK5lMIplMCsyPxWJSiAwGAxQKBZkaUmtH\nVyIqV2hGSF8KAHLuIRY9mUyws7Mjgj8HEIT5iFfzwfB6vYjFYsK+DQYDUqmUSEgXFxfY2NgAADV9\n5CEDwJtvvimVCL9G+RLH6E+fPhVRiKlR0WhUZQgDNjnVo3qbO/Y3vvENmEwmlUp+v19ezIt2B4QJ\nR6MRIpGIpF38nWw2GzqdjhTewWBQJRAN14PBIFZWVvCTn/zkte//o1rMHDRwFEuzlV6vJ+yWH2Sr\n1YLT6VSOc7ValekKhy6cBtIqi1atXPz0U6vVarJ2pUcG3Y2CwaBU3STgU19ITsbFxYVqzmKxiL29\nPUSjUTSbTXQ6HY2cS6WSsPCjoyMkEgkR9fk7U33On0FyUT6fh9vtRi6Xg9lsvmeHxYkhR/acmLKW\npyNppVJRnc/MbWoAyRFn6USzce7ALENoTMnXpUSLtIKHXI+qzOAO4fP5YLFYxFnmxUWczWYlvmSZ\nQMNvp9OJ4+NjSYAsFosolNw1CS/x6GZQZbvdlvFKuVxGJpPReBmA6k5OIGmE4nA4sLa2hkAggJ2d\nHblvcrLXbDblnETrWtapXDA2mw1ra2twu933vOn4bzY3N3F1dSVCUqVSuccZ4fCkWCzKe4/1Nf07\nGHVBshaNGInBEyun2ICDGrfbjdlsJhnXeDyWEIBTS+BfIDnfYDAkDQbDXxkMhgODwfDCYDD8T198\n3WcwGP7SYDAcGwyGvzAYDJ6F7/k3BoPhxGAwHBkMhl/9p16bdSMXCWMaOE6mm9HGxgbMZjPi8Tia\nzaZU1CsrKygUCjIJNxqN0sExooDUULLhms0mQqGQpnckLXE34nHKhFhi2H6/H4VCQcw1RjkQ8SiX\ny4qYoPKZBJ/JZCLiPyeH3A0HgwEymYyaPyqo6WfBppK+cBxDE6HIZDKSRxEPJkGJ7kqLKawcXZM1\nSPX7YlyF1WrV+yX2TIkaHzqLxSIPwNe9fh5lxhjA/zyfzz81GAwOAB8ZDIa/BPDfA/jL+Xz+vxoM\nht8B8K8B/GuDwbAH4L8BsAcgDuB9g8GwNZ/P/4Ez9e3tLYLBIFqtlhZbt9tFIpG4F25JP+VOpyNb\nK4L3Ho8Hp6enagRJdKcZIgBZurKB5Gv0+31cXV0hkUiorrTb7SgUCoLBhsOhFl0kEhEPmpO08/Nz\niU/J3+DAhikAsVhM7krMB6R1gslkQqlUkqSKooJSqYR2u60UAS484M6yy2w2o9FooFwuYzweCyMm\nGkS3fe7MfF+xWAzT6RS5XE7OT2woAQiqm06nsugisnJ6eipP6PF4rGDM173+s+/M8/m8Np/PP/3i\nz1cAXuJukf4XAP7dF//s3wH4r774838J4P+Yz+fj+XyeA3AK4J1/7LUX+QXlclnNVq/XU11IMSVN\nFXmM0juj2WwC+JIMdHNzI8YdvSqYFEXkhMoU7py3t7caFpDHSx+5+XwOp9Op98t/Wy6XNf2bTqf6\nb6YxcYGQj8EdkdRPADqBWNfyAer1enIkqtVqKqn4sNLei/YAJFXd3NyItGSxWGS2SBah2+0W25Bw\nIdESfjbAlwY67F/m87mwa46/6dH8kOvn2gAaDIYMgGcA/h5AeD6fk9BaBxD+4s8xAIsu1CXcLf5/\ncLGLn8/n2NzcxHA4RCqVklKZKVJer1e7IXcLhpmT9UaOMF8zEAjA4XDg7OxMcB71hhyEkKlntVrl\nHXd5eYlvfvObikQAoJExSe7hcFjDA7PZjNXVVSEHPp9PO1skEkEwGES329W4mp4diyVBMBgULk5H\nf1rzUoKVy+WQSCRUgvBUYh08m82wtbUlvjWpqUQdaEVLC2GauZB4tLGxAbvdLqNELnRuBGazGcFg\nEO12W7503/rWt/BXf/VXr72efm4N4Bclxv8J4Dfn8/nl4t/N70ZP/18MqH/079jscSchl8LhcMjQ\nhOR9h8MhMxhmBrbbbfj9foTDYXXwhJNYlgSDQeHJ5DuTgE+iPnP3GNLTbrflSkSXJZqfE9NmZBux\n6FqtphKCBB5yRAiPAVDOISeDoVAIhUJBJQRppDy1eMq4XC7t9AaDQYGgjICgfnE4HEoqRqEAHZWG\nwyFms5lI/Uzgury8VMDRzc0NKpWKsGbGdHD3rtVqmnbSiuF1r5/LYjYYDCbcLeQ/ms/n/+GLL9cN\nBkPki7+PAmh88fUygOTCtye++No/uD7++GP8+Mc/xt///d/j/PxcNSvrvFQqpVByGmm/fPlSdSZz\nTjhsKJfLkuRTjcGdvVarYT6f66FhA+V0OpHJZNDtdpFMJrVIybdgI0hZFXcvLm6n06lcwevra+22\n0+kU+Xwefr9frzebzTRtI/OOMq/FqGGiO1TceL1e6RrJX2b5wBRV2oqxZuaOTliNfBEOZejLwclh\ns9mUH14ymRRzLp/PC4NnQ3h4eIj3338fZ2dnD1pXPw80wwDgfwdwOJ/P/7eFv/q/APyrL/78rwD8\nh4Wv/7cGg8FsMBhWAWwC+I//2Gt/97vfxXe/+1289957WF9fh9ls1iJi88JO2mazyRibPAfu1vRi\n406zmHe9tbWlv6f1AO2uAGiqxbJhEYaLRqMAIJsANmyEqzj2Zh0diUQ0YGF+YK1WE8JC+wE6CwEQ\n8uL1esVUYxwFvfZ4wiya5ZAlxwUKQDAe/ZoXp30MBeLCpIKdOYRut1tYP/+O6AYHKhcXF0in03jj\njTfwne98B0+fPn3Q2vp51MzfBvDfAfjcYDB88sXX/g2A/wXAvzcYDP8DgByA/xoA5vP5ocFg+PcA\nDgFMAPyP83+ChE2CD8lCzL6LxWI4Pj7WzVp06WT07qIxCy24SL1kWVEqlaRqZijPs2fP5BTE8oaW\nVUajEcFgUDYATLciU44LL5vNIhaLoVgsyqX/9vYWR0dH2rEZJ7G0tAS73Y6joyNsbW3BaDSi3++j\n0WgIFiOB//LyUlyLdrstLnGv1xNJ6fb2Fp1OR/TXUqmkB+Gzzz7D6uoqyuUyms2mpojkbpBkJGAf\ntwAAIABJREFUXy6X0Wq1RA01Go3I5XLY2dnRiJoUVZ6CPp9PbMF+v4+VlRV89NFHD1pY/9kX83w+\n/7/xT58I3/0nvuffAvi3/3+vzc6aRnzdblflBN2GLBYL/H6/HOpZNnzxc9DpdODxeKTTMxgMSlIl\n2M9BwKKUyOFwCJpjfVqtVvHkyRMpM2j8wikep2wulwu5XE71Mz3xms2mLGd5qjCmjNNDmpFT3Gq3\n2xWISSOWZrMppTb9NJjbMh6P4XQ6sb29jfPzc/UX19fXSpCiqQ6RGVokMJNwOp2K9ERONi1sGTFM\nl9HFnZxCXkJ9RGNe93pUSpMvMuRgt9txcnIiHJdcB8JmDKW5uLhALpfDG2+8IViMOrV4PI6joyO8\n8cYb8mVjx06Xei5Gj8cjKI35KXTr4QImf6LVakkBs7y8jFQqhVKppHqUjLJ2u63kKdqF0dHIbDbj\n9PRU3iDX19f3FBvMRqGNVy6XwzvvvHNPZZ7NZrGzs4OjoyNJwTKZjFKnaMtFBIh+dhaLBePxGKPR\nCLFYTIgNfTQ4STw4OBAcaLPZcHZ2hlQqJToscxqbzabq7ouLC/z+7//+V2bjACT5pwMPdydip/1+\nX9Mr8mrJfONCDYVCwllJPL+9vdUOmM/ncXFxcU+Kz0aRr8shS7FYxM3NjRYrORg87imGpZXA5eUl\nTk9PFVlMKI/KZUZEMMlpNpvptQAIxisUCvKKBiAfOT4UXJw8SQjd1Wo1ABDfYjqdypKApCsGeZJF\nyH/Pet5qtUroenV1hYuLC+HHZN1xQ6G9AAn95G+87vWoFrPT6YTT6YTb7QYADS0WrQO4s3HETM4F\nORaTyQT9fl8LmiJQk8mE29tbPH36VFl2dDsKBALaOROJBCwWi2J6rVYrdnd3MZ1OJUsKhUK4ublB\nsViUupkB7NTVUXVNSyxi4LSoJRLAnZtj7mAwiF/7tV9Tbgo1f4twGxtg4O4B4AApnU4jEAiIuE/H\nVPKSKcliY8vmjs0o4xy4oMPhMJaWlhSLlk6n5S1HPz3SUxfzBV/3elSsOTLM+EFarVa8ePECb7/9\ntuq509NT3N7eIhQKCRajYplw1+3trVwtg8HgPTfNSqWi0oUBkJTtLy0toVQqCYWgK+bh4aF+PgDk\ncjkd6yyLzs7ONP3jjSUXmqPpVqslGI0m3zzaiV3P53P8+Z//uXR9jL148eLFvTSoRYst7qyLHnZv\nvvkmCoUCCoWCnPTtdjtyuZyQELIQ6SGXyWTkMc1BD6eshOqonVxeXsbBwYEyWtrt9r88aO4/5cVd\nmbvd5eWlrJ84cuYY1e12i1REz2LyoGnFCtx14fSlowplNptJ0c1deXl5GePxGLPZTCgIEQ42eTRs\nXPTR6Ha7oqNykdJmy2Kx6Huur6+VOEvaJ49yOp1SGNtsNjXm9ng8aLVaWF1dVRA8ADWCTKdiL8Df\nbdFnhEw4CgQikYiwZdolENlYWlrS5HUx74VOo6Tccgp4fX2NZrMpIfFDrke1mBknzKxqZpBw5yTX\nFgDy+TysViuq1apyOrgQer2ejm3CdoVCAcPhEMfHx3C5XFJqAFB9SmUIxavdbleK7H6/r52Xk0Bq\n5yKRiFQZtBXgzsdGtV6vo1AoKHCI3G1yT25ubnB+fi67A9bUDMM8PT2VmQtrfnIkWOIQ3+bwg2aI\nJFkxqKfX66kWprspkRUOkF69egWTyYRGo6EThaofg8GghpXcED5YD7ke1WJ2OBziBOfzeeGu1AXS\n9GQ0Ggle4k4VDofh8Xi0eMnl4BFLUSZdf0iSYRAjF+vy8jLS6TS8Xi/W1tbkl8yGyWKxiGnGq1qt\nqn5krC8XOuvpRCIBv9+PQCCgkEp6dxDm293dBQDEYjFRTVnDklttNps1+OFAhYobUmG50LhTj8dj\nxGIxTCaTe/0IbcrYQ7BkMxgMgjvj8biExDRD56kyHA7lnE/W4kOuR1UzM7z94uICm5ubiuH1+/2o\nVCqYTqdIpVJoNpuw2+1477338Ad/8Af42te+pskWiTlWqxXvvPMOXr58qeQmkmbi8TgajQYSiYQU\nGJwiUgnOCDHgDk1Ip9Pq3OfzOdLptP4tGyaqyvkQsflivQncuSP1+32Zs7hcLnFN2PRdX1+LTGUy\nmfQg0laWkWxUquzv7wv3ZV633++XPS/9OYLBIM7OzmSzsLu7i7OzM7mL0v3f5XJpgDIajeRnQoUL\nJ4hMAbPZbAiFQjg6OnrQ/X9Ui/no6Eg7R7lcxurqKlqtFoxGo3BncpgHgwFOTk6Qy+VQLpfV/Fmt\nVuTzeUQiERwdHaHZbKJer8s7jTed9TBrWDYy7Mi5OzmdTlSrVdWGtCe4vr6Wsz+TSVl78uexdiec\nyAUN3E07vV6vXqPT6eDs7ExpVUQx+v0+2u226m9yt/v9vtQkLKHoukQHVRKhaJyeTqfFua5UKjrp\nGo2GBL38jIvFItbX1++VVxzukILL5pnQX+6rtKkvL2aE0FOYQweaYpfLZfEFvF4v3n//fezv7+P2\n9lYeauTlWq1WHB4eaqoWiURgNBqRSqXQarU0FTMYDHC73VJTkHfALp/iTvJ22RBdXl7q/3u9ntyF\n5vM5otGodtbRaIRgMCgoiwoWckIoOuj3+0IZer2eFmG/39e42mKxqPSgb7PT6ZSZ+WAwuOdtPRwO\nBc8xQZZU03Q6rfE98CWSxJKMfBKbzSYHVd4jytGKxaI+AzIDH3I9qsVMLHaxM+aImLUa67PF3OdF\nX2fipotWUoxNYBLpdDqVdQEtBBZTT7lAyAF2u91yx2RmCJELvk9GCy+OsTn0WST+cFReq9VU1y7K\nmkjr5DSQfQObWQAKAaIFAut5ci46nY5EBPzdKO8iYYmRGre3tzAYDEry4i7carWUo0jvjX6/j2q1\nKq9sDrRcLpfEwA+5HtVi5k5jNBrlzENne+KdrHsZWcAPlz4Qi65DjEQYjUbadbl7D4dDRKNRrK6u\nisLJGjcYDAIAXC6X3PLZ0NEAkQ+IyWTC6uqqyoVFqigHDMRrWTIBEDne5/NpQZCFRyd9vj4d+Umm\nL5VKGqhwcETIEcC9FAEmEbDfMBgM8Pl8Ut6QGMXGjzs7SxZyqAkjUg5mNpsRCoXUN9BQ5yHXo6qZ\nuZi4IGgcSEvaXC4nWT4XSTKZRDgcFkIxn88VDE/bK07alpeXxfaiTwSRDx6vS0tLKg04vaMqhLnY\nXNDkKtCrgm5FVH4Ph0NhuhcXF+IQB4NB1ZnkYBPHpcqFtlxkxgF32dSJRAKZL+LNVlZW1Jh1u12k\n02nVwmx6J5OJmkFyukejkax70+m0jCdZKrHBY0m0u7srYQSnhBQMn56eIpFIwOVyYX9/H++///5r\n3/9HtZhJPTQajRpgEB1oNptCMcg5IPYM3CEhxKdbrZaQER6n3DkWw3rICiNaQNnT1dWVOvv19XVp\n9shj5uJvt9vaDdlw3d7eagfjrk5sl2YqwWBQNrvAndHMq1ev4PV6hZ3zQbq8vMTV1ZVQg3K5jHK5\njGQyqabs1atXKj2m0ykODg6wv7+Pg4MDRb7lcjmpz6mPJFpRqVRkcMOypdFo3HNIpQSt3+/rpGs2\nm2IQjkajB3kzA4+szCAHgEcaR7A0c6Fae7Hmo2cwFRgANDRgKI7b7dbomimwtJOiSpuDDE4OqQFc\nbABJdg+Hw/eO9dPTUxGU6H/MI5tQFk8IIghsasmRJueCVmMUCzCn8OnTp1KbJBIJDUfYfBkMBnQ6\nHR37w+EQ6+vrGu9HIhHRadnAcbHS29lgMIhzzQkpKZ/kX9DHg5g2zdWpmH/Q/X/Qd/8zu+r1um7S\neDxWZgenfixBaB3LnYSqCY6Db29v5dLT6XQ0bQMgGIvKDzLlaLXFUoKZ2awnCYsNBgMtbKIBDocD\nNzc393zyKIWiUeHNzQ0SiYRIRyylxuOxHtBOp6Nyh+Y2HHU3Go17sRDMxmYJwnCixei0brcreI/N\nLQDh6dQCknXIXXY+n6NSqYgeQASp0+nIuuHq6upeP8LS7CHXo1rMq6urMuErFAqIx+PodrsSnp6c\nnIjbTGJQuVxWXghDZkjcp2SoWq1KPcJdn6VFMpmEz+cTZk0G3vLyMtrtNpaXl5HL5RAIBDTZy+fz\n+PTTT5XNTZ3g9vY2AEj1QeyXRo/n5+caQ7Np5dSNPnuE5hi9TMrqzc0NyuUyrq6u0Ov1NKjhKdPt\ndoWjMw44l8uJy1KpVGA0GlGpVOByudDr9VAsFjV65/dQGADcOTidn58rANTj8SCZTOrnEvPm+2UC\n1etej2oxc7TKLp+7InkGZKPRZoAUS4582ZFPp1PdGIpJyW5j5C7DdBhFRhcfwmFUaJAHzCOYOYAu\nlwsABJ1R8LmIQrBJ5ciaDwqzwC8uLuSBQV4Fa1e+X5ZKixEThCT50LEJpfKaDkcUtVJDSaSHqhmW\nNnx9qkz4fii4pS/JYpQcSyzu8g6H46uAnsWLDDgGQVqtVni9XuVDUzbFiIXt7W1ZaNEgcTqdYnd3\nV8E+sVgMfr9fUz86hXLxcpchIkFaJRGBTqejE4N1Msn2HFkTuguFQuh0OkJh+CCwObTZbIjH42i3\n21hfX1dYJ5GJ2WymMX4qlZL9F1UxVKYTRuR4+dmzZ/eYbRzFv/nmm8Lb+VBsbGyI+01UwufzSYNI\njgZPJQYBjUYjJJNJXF9f69Qh1s3f8Tvf+c6DRtqPamfmolg0BqSQlFlzk8kE1WoVKysrEn6SqM/6\nstlsit98dXWFFy9eKEqBtSEneDabDYFAALPZTP4XhNeur6+RTCaRz+dVO3I8TfOWbreLUqkk/JhH\nOC14Wc+zVGJoJadqtVoNw+EQZ2dnsFgs8j4mw67Vasmckbss86zp8FSr1dBqtdRLcLyezWalsnn5\n8iUqlQqKxSLMZrNOJEKItFmgTpInEetwIjzz+VxlBZtdNqIP5TM/qp2ZsiiDwYBf/MVfxGg0QiKR\n0FHMJCUqKRgQ4/F4YDAYUKlUFJHgcrlUUqTTaXX8s9kMfr9fWjpOzajmsFqtOi5p5RWNRqXHI0uN\nzvoAsLGxoVEyd3oAGs1Tlu/3+3F5eSnTF7LOqFlcWlpSnDAALRxKtbjgWq0W4vG40BFCZ3t7e3j5\n8qUQG5PJhPF4rFhgmkuyWSVD8Pb2VsoVDof40DNjnBkqLGkcDge63S663S52d3c1KPrRj3702vf/\nUe3MrBcHgwFevnyJyWSCfD6P0WikepTYKLm+bI6o1DCZTKjVauLXEmpjmORgMEC1WhWiYDabtdNx\nvMtBhdPpFE+CyhMeszy2iRZwRM66nlg00RQGUXLH5+KgiTdtAhqNhnZrq9WKZDKpo547JbWMRFnI\nISE+zSB51sr8GSxLuBszEpkedQzbASBn/0gkcs+/j2Lfy8tLOBwORCIRTRNp4fu616NazDabTQuN\nOzQ7fTYtRqNRxoKRSAQABK+xCbJaraovibtypyYXgTwL7kR09+TpQJtaypMACDYbDAZot9sIh8Py\nsSDLjkcw1TKsX/l+2GQFg0HVrnQ74g7KB6RSqcjVkzAka1VafxHLrtVqaLfbSo4yGo3iT3BX5qCE\nggLCdW63W78r+RbkuBDy5AbCySVxbXKqCZE+5HpUi7larSLzRYrT4kKmTxp3NcafdbtdvHr1SkGY\n9E7j8GE0GiGXy2EwGKBer0sQC9xZBtBFs9frIR6PazzN5i4SiWgMzN2JCEgwGMT5+bkWJjFyRk1k\ns1mNmTkip/v+5eUlarUaKpWKVB5msxnFYhHNZlO7XjKZVK3Oh5hDDQAav3PHBCCjnMlkgu3tbcxm\nM2kBOdanxQKbw3q9Dq/XKzIVJ6GUgBEGZQjSbDZDLpeT+p2G7g+9HtViDgQC6qhp1kc4ik0Vechr\na2s4Pz/H1772tXvsr8lkgs8//1xYKamSvEksWRa5GYFAAPV6HblcDul0WlAf4S+6edJTw+FwoFKp\naAE8f/4cgUBAzD4OYDju5u54fX0tOihra5KHbm5uhDPTW/rs7Exyf4fDoV2f5CGy4BahOYpLDQYD\ncrmc/KYZFrpYlrEUInYPQPU0m2meCuTD8AFKp9PI5/OiDwD/Ap3z/1Ne9FJm3QxADphsqjqdDvL5\nvIy4Of6lbKfX62lnYQ1Zr9eVyX11dSXjQk7ygC9D3klIInuMN5blB2/YxcWF0I9FY3HW6eQqc2cn\nT5rSp1qtdi8QnsR2q9Uq6iaRgm63K5ISHy6WL6PRSGNq+twxQo2+ILlcThEWy8vLqNVqwuCJSjBo\nh9Af/7w4kaTqnbwWOjU5nU71Ig+5HtViJmC/qAJmDUlkgkaFBoMBmUxGpHpOo+jHTIk/m0Lu8GyK\n6LHhdDrVHFEzR0yaU0KbzaadnMMWppX6/X6EQiFxkFkaud1ukZJo+E1UgtnfixhyPB4XnXPRrXMx\nwJIPCG0S+HsyB8VqtQpa5GJfWVlBJBKBx+NR3AUxavIt+ACSB86SZXHQwywYNpGcUDIGmU6lD7ke\n1WKmspkCVlIeOW1j00YvYxoaTqdTPH36VDtHMpnUrpnP57GxsaE6k8aE5C9w0rWysoJ4PI5Op4O/\n/du/FTmJRB36UbB8oRSfEQtsCvP5vOREvLk+n08PBJOjiCgwB4WMuPF4LOSGxCXuzFyg9EOmap0O\nRDR6pH6PYoWLiwuN+DnoIJHeZDLds9alSxENxPl14uTkr3Dgwt7joQsZeGSLmbASox4YLk43eKo0\nqMW7vLzzOLfZbDg/P4fL5YLP5xNhfz6fIxgMyjKLRy89Meiwz5RShuPs7+9jNBopa4819NbWlhhm\n9OPg0IayKE4lSdjhkUyhbiQSQSaTEb+CqaYUsTJl1mQySenCXXE4HGpX93g8mnKSwcYdk4udu2oo\nFBJGzPqcDDtCkfTvo1BgUYzA7OzFv+dgyeVyweVyqcd5yPWoFjM9KiwWCzY2NhRxwBg1t9uNVCol\n9tnm5qZG4IlEAsAdPvorv/Ir8Pv92NnZQbfblQs8oTzuRExSpWNmIpEQwkHuBx8k4A6r5m5MI3KX\ny4VIJCIvC9bOJN7XajVEo1HM53O88847yOVyKJVKsv5iGP3a2ppKEWoBiWZQwUJLACI1LpdLll92\nu10cZ54w/Mw4rWSDabPZFNlM1Uk6ndbn4nK51PyxtHO5XMLLGbUcj8fRarUQDoeRyWTw1ltvPej+\nP6rFnE6nAUBUSx6pwN1Cr9fr0r2xI6cFVzabRbFYRCgUwocffohGo4FsNotEIiEuM0WiDI+nWTeP\n4mKxqB2zXC4r42QxCIgK5efPn2t3Go1GCIfDuLm5EbRGP7pgMIijoyO0222USqV7tgX8d9fX1ygU\nChIN0LTl5ORETk7T6RSlUkljeJZHNGphmXN5eYlisQiv14uPP/5YueOkbXLo0m63pWp3Op04OjpS\n6A/jhulD3ev1lAvOCaTH4xGpv9lsot1uI5vNPuj+PypL29/93d+V7dT19bWiFDKZDPL5PCaTCQKB\ngBxA7Xa7FjN1buQ3OJ1ODUwcDgeq1aqaMrphcuJF/jN5yYTlWLMuktSJUDC+12KxoNls6vuvrq7g\ncrng8Xhwfn6uOpdoCSeHALC7u6sRPYMvfT4fisWiIorZqLI8WCTIc3hEezK+7tXVFUKhkAzEq9Wq\n6ulF5IM7O8lG1WpVJjaMkgAg03OPx4NoNCrx6mQy0YLmfz/E0vZRcTMod7+9vdWxR8kSieLZbFZm\nKMCdlxwzoEm8r1arcLlcOD09RTQahcPhkGUtE1YdDgdarRYcDoekWOQEA5CZSiwWQzabFSRHXzoA\nGnszNoxDjX6/j1KpJDEo9YSLkWP9fh8vX76Ex+NRucOpIQW7FCYQ/uJAiIQs/v7Ly8vIZrMKJKLt\nFxtYckPoo8e+hIlbJCKtrq7KQ4PZJtPpVBpGk8mEo6MjTQHZILJpbbfbD7r/j2oxc7TK5CKHw4FU\nKiX/s5ubG0SjUUl/kskkPv30UxiNRglPWU7YbDZ84xvfQK/XkxyKI9xAIIBGo4FwOIxIJCJ8lLte\no9FAJpMRu45UTbpt0lOCdrQ+nw9Wq/Wec3w8HhfXl5Iqejqz/DAYDIIAidDw/dNf2mw2o9PpCKFg\no0dif6lU0o7LwREhtkwmoxqbdNVer4dUKoVsNov33nsP+XweJpMJOzs7Kh+oyqGo1Wg0IhqNij89\n/yLIMxgM4vj4WPfpK6+5hYv2ADTpo6UtfedOTk7QarVweHgIAPjhD3+IUqkkUhGbuXK5jMlkgr/7\nu7/DYDDAhx9+qAHIaDSSJRUX70cffYTb21s0m02VI8xVaTabcvHhBPLw8BA/+tGPZDrI3YxWs9Pp\nFCcnJ6jVauJg012oXq9jOp0qUctgMKBYLKJSqUiaxJ03l8uhVqvp3zIznM0gd8disags61KphEKh\ngMFggE6noxPi+fPnyGazyOVyqFaruL29xU9+8hMl4h4fH4tfMZvNcHp6KqaiyWTC+fk5Pv30U3FL\nSMI6PT1FuVzG8fHxg4lGj6pm/q3f+i34/X5Uq1UlONVqNaTTaU2zBoMBKpWKSOY8iuPxOA4PDxXs\nSAn/8vIyksmkGklK+GnISNir0+kgFouh2WxqBA7c2R8Ui0XBhoPBAPF4HIVCAdvb27i8vES5XIbJ\nZMLW1haazaZU4NPpFOHwXbbnYpYKoUVmllCAy1E5f+eXL1+K60FEAYC+32azyfOtVCphd3cX1WpV\naaxHR0dyZgKg9AE2tPxcV1ZW0Gg0sLm5iUKhoF6DJxjlWFar9Z4SZdHckZHNf/iHf/hVzQxAzDf6\nlq2trSnmloMJCjHPz88RCoXwZ3/2Z/jVX73LliedczQaaVGZTCZ17AT2uUszDy+fz8uHjUMW1pPE\nbkmyp46O2HYkElEA5tnZmWpdlkyFQkF1cbValYkiSyUiHL1eT6NkckKCwSAGgwGurq5E6uGEE4AG\nL9zhT09PtasPh0M10KSA7uzs6OuDwQD9fh8OhwMnJydwOp149eqVyplXr17pdTgm5/Tx5uYG/X4f\nT58+RS6X04T1q5p54VoMs+EukkqlFN3LuAOSyff29nB8fKwaFoD4DCTxl8tlDR/IxWWcmtlsVoNI\nhlgikcB4PL5ndsKMPnpnhEIh8Z/JQEskEiI00V6MMb0Oh0PvmYzAaDQqewNmsTBygegIcEe+mkwm\n8Hg8SnPl7ur1ehWvTHSHo3aiIA6HQykDrOlJed3b25PMazHLcDwe48033xS5iT+XsKjP58PGxoYG\nO8T4H1ozP6rFDEDTs9lsBofDgdwX0b80iInH4+j3+5jNZvjZz36GbDaLjY0NMdDy+bwWzuHhoeTv\n3F1MJpPCeqbTKc7Pz2E0GsW96PV6iEQimhAC0Gic3hKVSgWXl5dSf5MC6XQ61UCdnJwICiS+zZ/Z\n6XSkR2T4TTablVSJC3fR9bTRaAiiI5easioqSBjOyQXOJrHdbovlN5lMkEql0Gg0cHx8LN0im91n\nz55hPp/j5cuXiMViorVeXl6iWq0ilUqJOx0KhdDv9/Hxxx8jk8koIOh1r0e1mI1GI2KxmNhdixke\noVBIx7DX60U0GkWpVMLq6qqIRgys5Gu53W6B/JQj8Uin0npR7UFbLZKRKEeinIqOlxyVr66uiqcQ\niUQ0bjYYDNjd3RV5x2azKZ9veXkZq6urKicIjdFtiBNPwnckQFEpHo/Hpf+jqaPf70en00EkEkGt\nVpMsi7tzMpkUhOZwOMRNoR9dOp3W4qRCJRaL4fr6Gi6XC6urq8hmswiHw3A6nQiFQqLUXl5eSgWz\nvb2NH/zgB699/x8VmrG0tKQMkKOjI3Q6HRl8UzTKHYSRaAw05/96vR5evXqlWo+qZ5JyuIB4rNJU\nhhNFst4YbEPftcXwn3g8DqPRiGKxCI/Hg3w+L4I8hxilUgn9fh+5XA7n5+eo1+tSbVgsFiEq5JdQ\nrTEej9FoNDR1Ix86Go3CbDbj+PhYBCrgDs6s1+uaCpICS4HAbDYTmalQKOD29lbTRzLgms2mkgRI\nbT04OBDllcT+eDwuTPzk5ASz2Qyrq6sAvgysf9D9f9jy+ed1UYt3fX2N1dVV1WCcolGhTbmTx+NR\nPh6VETTwBqDdhznZvJE0bgFwT1VNpKPRaGhX5i5I6RbJ73a7HTabTYmnXEC8oYuOQaRu0g+j2Wwi\nEAiIUM9aepHuSrsrlky5XE7c4m63K4mVzWaTGyizXMj9ps0tveZWV1dRr9c13FmklfLzo0MqR/4c\ncdPgnPwT9gGVSgVms1lj9Ydcj6rMoGKZww1yeVkLkgvB0S5wl/8BQIOLarWKUCgkByPulG63G+Fw\nWIuFlgY8/umSD0BGMhx0UNHByRmhKA41aPfFGpsjdRLx2Rim02lJoviQ8Pgn14L6Pu6Uw+EQwWBQ\npQ2TV8nko0CBfGpaHTCHBAAGgwG2trZQKBSwuroqMevt7S1cLpdOFH6mJC3RNIecZWLwVMOT1ETF\nSjKZfND9f1Q7Mx2KqtWqMu2IGhiNRh17nELRfRK44w80Gg3tmJ1OR2UJd18ORrjD0MlnOp1qoEHV\nCh3xeTGfkKUKCfFUx3DHZpQaU2VZOnBnB+5OoFwuh/l8LnOY2WwmxGBRpe7xeNDr9bR4WeeSOVcq\nlSRoAKBShoJU5mMzP2Vxs/D5fIIvuVFwbtHtdlGpVKRdbLVaMkYcDu8yzk0mE8rlskbrvBevez2q\nndnn86mxuby8RCwWUxd+e3uL09NT0TgZ5P7ZZ58hlUrJ7op149ramkJziAxQ+Q18iVBQBV6r1dBs\nNuH3+xGPx1GtVmEwGLCxsYFyuYx6vQ6LxSICEtl1rFX584PBoFhr3OnoqcG8QJqb1+t1IQX5fB6p\nVOqeOWSz2USxWBTfArg7varVKsLhsCRdlUpF8WmMQ1tdXcXx8bHUJq9evUIymZSggQ9xLBbDYDBA\nLpdDJpNBsViEzWZDqVTSUIhCYpY4fB8vX76UqY3L5cKLFy8edP8f1c5M61faW5FTPJlx/k4sAAAg\nAElEQVRMZA1LRyNaxL777rvqwP1+P+x2O8rlsoSZRAVIKieLjgR07lwsH1ZXV7WjZTIZABCbjGUD\nv4fQG4/i9fV1OJ1ORCIRWCwW9Ho91bGkj8bjceG9NJ6hkU0ymZQZJG3CFqd8FMtmMhmZsNMujG6i\nbBgBaLdedCtiWP1in8FpH+0S3G43LBaLdmtO/KjmpnYxFAohlUqpnOEO/brXo9qZecROJhPs7++j\nXq9jf39fzkB2u10UxMlkgm9+85v44z/+Y2kBSREF7hZaMpnEaDTCW2+9JfdLq9WKUCgkMhLrXNa2\n5+fnSKVSCIfD6Pf7sFgsiEQi9wwVKRZg7ondbke321XtyiY1nU5LxUHlChEWwnPM7CbLzWazYX19\nHSsrK/D5fIq0oBiWvhf0ox6Px4ItOYnj0GZ3dxfxeBylUkmLlEMVDox6vR78fr8aYp6Oq6urGAwG\n8Hq9uLq6gt/v18Mci8XUuN7e3iIWi8FisWB3dxeffvrp69//hy+hfz4Xa1kAohrSI+Pi4gK1Wg3n\n5+ci2z9//lyj5m63i2KxiE6nI8X28fExjEYjyuWynHqcTqfIPBw9k9JIC9p6vS6XHgAapxM+A4Dz\n83PRK2u1mnZ82hcwJYr/hg8qFzZJ/IPBQO+fTqCkldI3r91uo9frodFooFKpSIFDbjUht4uLC0Ft\nV1dXOD8/v/d7sE4nS/CTTz7ReyP3hb1CPp8Xz3qxhON7orKGvPBarfaVCczixcbH5/NpFEu6ISdX\n4XD4Hjc4FotpzErVBhGBxeAZo9EoV1GLxaJjn/9N+iQlQMwCoSZvUTlNLzuiJGx8zGYz0uk03G63\nShjyiGns6PP5VNvSkZTHNodCHJ5wlG6327G1tYV0Oo1IJIJwOIxisSjeCrOyV1dXlfcHQNPPdrut\nE2tRyLu5uSmeRyAQuNeIcgEHAgH4fD54vV6dkORsUDLGrBj+jNe9HlWZQSVFpVJBtVrF+vq6uumr\nqyuVF8SiaQ5Oji5z6er1OhKJhAy6yc2gJIhqEDZdHF1zYEFYrVAoIBaLyfuNmC/pkZwu0ouOo2cS\nibi7UmnSarWwt7eHQqEg4hEZeqVSCclkEgaDQaw40kfL5TJOT08xHo+l2eMDSGcnn8+HbDaL8XiM\nk5MTvPPOOygUCkJV6MvB0HamyTJEk8iR2+3GxcWFNg265g8GAxwcHKgBTqfTODs7k41CMpnERx99\n9KD7/6gooL/zO78jWI27FfOoc7kcRqORSEI2mw3Pnj3D97//fXzrW9+ShJ4RBk6nE0+ePMHZ2Zls\nCxjKHovFZBBD6IuUTw5X2CCSief3+3W0cuelrIjTReBLc0EA8rCgkY3VasX6+rpIU2T4UY3O0oEB\nl5PJBEajEe12W+lQXq9XZUkymcTJyQmi0ahG53x4KJuixzSHJ8fHx1hfX0elUsHbb7+NXC6H6XQK\nv9+PVqslVh7jMGhKTlIRbQfo3lQqlRTddnh4iO9///uvTQF9VGUG67fr62usra0piqHX6wmQNxgM\nytOgyoFMLgpSDQYDQqGQambuqCwvSqWSeLjn5+cSyC7Gkd3c3AjDvbq6kvdwv98XdjwajcTjpWMm\nLWIZZUFGHSmnvV4PpVIJtVpNUivi2s1mE+FwWDERHF0ToqOdLrH2bDYra1367HG8TSHu/1vtQryc\nTMTl5WWsrKzg6OhIxCI2s4sj6qOjIxk38pTiQ7+ysoJisfhgq4FHVWbQPPD6+hoHBwdIJBKo1+vw\n+/04OjpS5hwAGRNSElWr1TS1YxNERh2nh/V6Xd07A3y4QzLyl75u5GrwlCC1lNavrVZLLvfkRRMT\nZtRDq9VCqVRCuVzWwuDrcpLGZpQiVT4szWbzni8zldVEM/gadNfncc/TYjQa4fz8XNwJn88nvz6n\n03nPo5kBPp9//jn8fr+UJpubmygWi4LnqJIhYsJm3OPxwO/3Cwp83etRLWbuwHSo5wh6PB6rWeFC\no7qCC5XCS/pjsEEZjUbK3vN6vUilUjg9PYXH40EgEJDmkHo3m80mToTRaEStVpP5CUe+5F2Qgced\nnObo5C/QJNHhcKDdbuuUCIfDmtrRO45+db1eT+PrdDoNs9mMbDYrbPjdd9/F+fk5HA6H4ERqABnn\nQBuFRVuv8Xh8b+TNMisej8sb2u126zNhMPzGxgZ2dnbw6tUrtFotRCIRWK1WRbiRsOTxeOB2ux90\n/x9VmUFZDj/ITqcjfPj8/FzwWLfbVWhPNBoVrNbv9xEOh/Hy5UtcXV3J8w2AiOs8TjlqJtmHO3O1\nWsVgMEC320WtVlOHTvhuPp8rAIg7IZ30XS6XIDc2gJ1OB5999tk9tTYXD4lALIGoyuZono0Xifjj\n8RjPnz8Xjxm4I0iVy2VFU9TrdTXJlUoF8/kcVqtVA6RmsyknJvpnkGgEQJ95uVzWg/7RRx+hUqkg\nFoshEAig3++rIY9Go/Lrq1QqD7r/j2oxkxzU7Xbl5BMMBmVjRa83RpZReUxPYpLtCbsR5spkMuIf\nmM1muQjR7IU8Az4cnI4xLoKdv9PphMPh0E1mBh5trOjvRi0fvYxZBxM9yOfzikKmYTlH6wzTTKfT\netjMZrPqd/qDcOqXzWbh8/mk2I7FYkKFEomETGUYJEQdod/v1+fBh4OQIA0TSZGNRqMiJDUaDSV7\nTadTYdc0jXzI9agWM+mcW1tb8hEmVDUYDPC1r31NZic8pjnOpa8zACEEnIrRe9hoNCIcDivAnJa2\nGxsbsqXiA0RxgMfjgcVigdfrFXuPMqR2uy0XT9oDMMC+UCjIPZONFydzW1tbqn25q7KMqdfr2Nra\nEh2TnIy9vT2N6ykc4GsCd9PTvb09YeWj0UjRwqPR6F5uCYdKfB0AWFtbk5DVZDLB7XbL5ZQnCqmq\nPJW2trawsbEBh8MBv98vL5PXvR5VzcysO0p+6G7EHZvydtZ/l5eXwnkJ29XrddWJ+Xz+3uia+rlF\nIjvDZ2gMfnt7K484LqpKpaKalROvm5sbUSTp2dFut+WuRJ8PMvI42OCkjSbiLKs++eQTpFIpxTgQ\nLaAZziKDcDabyUuDuz+V7FdXV1haWoLf70cul0MkEtHPqNVqwqfJByHMuJj9N51OUSgU9HC3Wi3M\n53MUCgVxRsgt53ubzWZf+TMvXhaLBbPZDC9fvtQRbLFYEI1GEQgE8Omnn8p8hRpBSpr4tUQiIUIS\nj+xIJKKkJ9bS3GGYh8LhBWmSNCSfzWZ6IADIgZ4DBuoHTSYTksmk9IV0z+eDR9NFeiuHw2G43W4k\nEgk4HA5sbGzA5/Nhe3tbEz/W60tLSzg5OUGz2dTQIhgMqo5ftNFiHW6325HJZNRE+3w+rK2tKd6C\nfA6ecicnJ4I8Wf/ToJyGi+RvMz/84uICn332mfzrHlpmPKqdOZ/Pa6RqtVpRr9cRjUa1Mzx58gRO\np1Mezkxj6vf78pXgjeURzV2YsboANP4m0jAcDhVGwx2LxJ9IJHLPPJz6QafTqe8ht4G7FIWtfr8f\n2WwWwWAQpVIJ4XBYyozr62u43W5RXEnuZwPKARDJ9sCXQgTW+AaDQWNoojwcV/Mzodqb9l4sERbj\n2qhhZIlBfz9OX3lSVKtVqcuXl5cRDocxm30Zk0w/vte9HtVi5oKhkTjN/FZXV1Eul2G1WtFsNgVH\nsd70er149uwZXr58KdB/fX0dzWYTRqMR6XRagwm73a7jsNVqySiQdTUJTWzaOF5frJFpEcZyod1u\nw+PxiPM7mUzw/PlzJVMRGiMyUyqV1GgBEDrD5pYihdlshuPjYxQKBbz77rvS8jEDfD6f4/r6Wr4X\n6+vr8t8gykGEqNVqiStit9v1WdIbJBqNiqhF83JuEIydAO4mnMViUQOW0WiEg4MDxGIxfPjhhw+6\n/49qMdPhx+l0wm63I5FIaCjx7NkzURlJByX0tba2huPjY3g8Hjntt1otyZJYG4fDYZmUM8ODvGnG\n5hLLpvVVuVxWfAJ3P+aGcNcmh2QxsjgUCskB32azodVqyUt6c3PzXrNF9IYqkrfeegtms1nwGVEM\ns9mMt956S3U+g4y+973voVAoKFObdE+a6EynUzWyFosFyWQS9XodwN0JRqdQlmMrKys4Pj7G1dUV\nrFYrvv71r8sqzOVyYX9/X1PWDz/8EJFIBPF4HPF4HB988MFr3/9HVTMTfyUWSrokc+mInxLdILON\ntrB09vz4449hsVhk+FKr1WRN2+l0lPZkNpvh8/nUVNESl7EL3KHJS+DxzEVLxQankGwgr66uhF0T\n/242m+h2u0JsWFZwh2UjS79nNoDM8qM0q1wu47PPPtPnsrS0pGhi8jg4dKJVASeG3W4Xw+EQL1++\nFCTJuGKPx4NmsylXqZWVFe3quVxO9rpEV0hA4glWr9e/ihtevKh0Hg6H+OlPfwq73Y4XL17INHE2\nm8lYkd5yFotF2YHM6/v8889V85I1RptZIiVWqxX5fB5PnjyRIzxjxoiKuN1u2O12fPzxx3LppEPR\n4eGhRKZnZ2f34D6OsTnYIbb7ySef4N1330Wv18Ph4SGSySQCgQCurq6Qz+fx3nvvod1u4/nz59jZ\n2VFqVDabxfe+9z3xRcLhMIbDIV69eoV2uy38+sMPP4TNZsPR0RG++c1v4vj4GH6/XxEQzWZTihvC\niJVKRQgPDWaYTejxeNDtdoX9h8Nh6TP5vSaTCe12W/yOh1yPjjXHXRiAMqvJXOv1egiHw6jX64jF\nYuh0Ouh2u1hbWxOmyrxpu90uk0LmcpCny1356uoKkUgE2WxWGPXl5SVSqRQqlYqGI5eXl+I0t9tt\nJJNJFAoFlRkAdFPD4bAyRRazr+kJTXU5BaeskYvFouRiXFjT6VSfx2w2g8vlgtvtltiAJZPNZkOl\nUsHm5iZyuZySpchXMZlMKoNIE+BnnEql0Ov1JNalZKzRaAjxIMGIlrxUYwNQ6ef1evH8+XP8yZ/8\nyVfGicDdzhyLxcQ79vv9KJfLamwKhYIyqJ1Op/6bEqfFnJKNjQ188MEH2N3dRa1WQzAYlFrCZrNh\nMpno39IJkzVuu91WihRxWmLEw+EQ2WxWnGhqDEn7vLq6QrVahdfrFbRFd/2trS3VuicnJ1hfXxcz\nsFqtYmVlRczBRVOaXC6HUCgky1zW2FycZ2dnsNlsImkZDAY5EhEeLBQKcDqdaDQaiMfjwoZZEpH+\nyfKl0WggEAig2+3qtCH8yUHV8vKykCZmiz/kelQ1c6/XQ7Va1Q5BthnwJTeY2jcS2yklMplMMnhh\nzEMqlRKnl69D9hm9l0mnpLg0n89rgEA4ixa19EB2uVxIp9Oy+6L0n+NfIiCMIiMSQOivVqthZ2dH\njZbRaMTOzg6azaZqdk74AIizQdMZNqF0dGJjNxgMBElyUMNIC/5+JCgBQDgchsPhwPn5ueA1jslN\nJhOKxaL43X6/X4YwLH/o70Fs/qHXo1rMmUwGy8vLYmkxLZXTr1AodG9gQjSA7kCM/2Vo+enpKdLp\ntEjubrcbsVhM3Amfz6chwsXFhVTYdNGkGeHa2hqi0ShSqZTYbMzL8/l8aDabwrj5b6ngpmiU6upg\nMIhnz56hWCyK1G4ymVAqleDxeOR8enFxgXq9rodlZ2dHrLetrS1ZH3CXvr29xdramoj0tNpiAmsw\nGJQYlzIvNrWpVEq8DA5crq6uEAwGtfiZyBUKhcT6m81mSKVScv7f2dl50P1/VIuZux5NANlNc3HR\ngZNQ02w2QzqdxtXVlRACwlNMaO31emLOEa7jzez1esrr4M2hFo/5gMFgUAw2vpfb21sAd2QdSpvI\ncWCX73A4NIl0OBz38qmLxaLyQnw+n6inwWBQ9XQymdQiouMRJ5a0CyiVSoL2KD4lt5nQ32Qy0YNJ\nvJhTPH5m1EmyRr+8vFQf0ul05MtMiJCvSz/mZrOplICHXI+qZqY6+vr6Wjo0OnQOh0OUy2UEAgFc\nXl7i4uICpVIJlUoFv/7rvy4nokgkgoODAzidTk2sSqUS9vf3NbYNh8NakIT4eIN41FNKxZqTxzj5\nu6VSCTs7O2om7XY7jo+PMZlM0O/3pZ/jcGU0GiEajYq7TFI9AHE06FrPcoW+cHQXomyKg5FIJCL6\na7lcRjAYVJbi5eUlstks1tbWMB6PUSqVEAgEUKlUtPPzQaOq2+VyadN4+fIlNjY2ZFDJxRsKhYSe\nUDUfj8cxGAxQLBYfdP8f1c5sMBjQ6/Vk4UrWGtXBpF8GAgEsLy/j6dOnwl8jkYgC1kOhEDwej4YA\nNBm0Wq1wu90yM7FarQqcpzzK4/HAbrdjNpuh1WohnU6ryaNXBCPOrFarGjY2THRIojGKy+WScTmd\n96mAJhLldDpVBrGUYQorGXtUwBAloV5wNpshHo/D6/UKxWAtzxLG6/UqLJOjfZYQ/FxYjtzc3Kih\nI3YfjUYVskl6KaPbqGC32+2aaL7u9agW83A4hM/nQyQSwYsXL+D3+8VQIxm90+kgm83C4XDgb//2\nb7G2tgYAcrt3OBw4PT2V3o6xwDy+3W63EA3eVMrlOX202WyIRCLY3t7GZDLB6ekpvF4vrFarFtpw\nOJTHB6VDlEt5vV5xQubzOUajkbJW6BzEUbDNZtPQhGjMwcGBrAgYO7G9vS3s1263w+PxCE2hbwZl\nVQyQZ+PKWIlcLidrXMq7iOrwwSRzMZlM3nNN4jCHLEH63pF6S/+Sh1yPqsxgrBibLh7hVBszg4Mw\n2d7eHprNpiZv4/EYq6urygnxeDxIp9M4PT2F2WxGOBwWLRSAwieLxSJWVlbk/O7xeJDL5eByuVCv\n17G3tyeqJKEvNj0sV4LBoBht8/lcLj9EFubzuRq3tbU1KbS5k29tbcnMkE0rw+MdDsc9ORcX5tbW\nltTrVqsVTqdTeYBGoxFra2uw2+1CQ4xGIxqNhhbfcDiE3W5XbDDlTwaDAQcHB0IwWFM7nU6p1KlE\nAe5ONdrfPsTR6FEtZhoLspli/cpxM2VJDNqhHRXLgclkgnK5DKPRiH6/j+vra5RKJZGEuCA5mr25\nucHh4aFI+4PBQDAVYTnCTvTooPIjGAzKsJD1eqfTEXGn1WqJdUbMl7tZsVgUgy2fz99z6KdNAvCl\neQvxcA5K6ApKI3FmrbDxJB7OHmQwGEhWxQaOCp75fC7dIHFs4K70YePX6/WwvLys+LhAIKByh54j\n5Eg/5HpUi5m8ZC4ujl45fWOsLlld7XZbsqjl5WVRJefzuWrHcDiM4+Nj2cVubGyoiaMglPgp60cu\nJvKQb25u4PV65dVMvJjcCI6XGUvMEEi6jvJ9LSIrfDASiYTw4WKxiHQ6LVJTvV5XaeFwONDtdvUe\nqL0jOYryLKZi0SmJPnKktjLKmWGda2trqFar6Ha7YtPd3t5FCweDQfE3yAbMZDLKBuT/aJfwlT3X\nwkWXeQDiVVCbRnegVqulepMfMgWgxKVZ21UqFTV4qVRK8BWtuMiqo7pjOp2q0eQpQViQkBwjkamA\nWVlZwcXFhZKq2Pg1Gg15JbPxY71psVgkeuXO2e12kUqltAgrlYqOd6ZLcZhjNpsVXNlqtVCpVMSr\nzmazauD40FGvR5SFjSeRE5qJm81mkZEajYagO74WuRu03QUgMtViJvjrXo9qZx4Oh/D7/crZm81m\nUpKQxEO5FLFTt9stmiUX3dOnT3F9fY1oNCqDGHoa83gkErBYCwJQxl0ikZAcPxKJKCaN/IlEIqFk\nrMWGj9wGu90uojwZdpyYcSJHFp/P5xNBnsHqHITQxoBBlZSOra+vw263IxAIYGVlRRFrpKsyJMhs\nNktk0Ol0YDAYkEgkcH5+Dp/PJ2ydD3AoFILNZlOqFDkt9AbhVNJkMklIyzjob3/72/iLv/iL177/\nj2pnph8w2WqsNwOBgLi+wWBQ07Tvfve7ir7l4IHZJx6PB++99x5cLpesrkajkfwsyBXm5I7uRExR\n4q5LbjPhNS5QNo/8Ghs0EvSn06lQEQphR6ORIMdf+IVf0EPK9z8ajWSHy1g2ogWsT7lzU/PI8oLU\nTSIqhMrMZjPcbjcGg4GaN6Is6XRaO6vdblcUBnO7w+GwxuGE/Vh+uN1uwXNseB8anfaoFjOtrgDc\niy6jNcBiYzMej/HDH/5Q6mPgjsHFGIbhcCgCztnZmRomhjbS2KVSqcBgMMhbglwJmnDTrpVxBxTP\nsrnkAqKjEZNKWdOXSiW0Wi2RhohsfPzxxxKQcldnZggx5GaziUKhINIRHZco3eIOztqaaEo2m8Vg\nMEC1Wr2XPcihDkuYv/mbv1GZdnh4eM+mlkaLtOfNZrOo1+uy7B0Oh6Kf0t+vUCg86P4/qjJjcaxa\nLBaxvr6Ofr+P+XyOy8tLWVldXFwgmUxKeEpjQTp5LhoQ2mw2IRIrKyu4vr5W112r1bQgiEtTyDqd\nTnFzc4NUKiXLrNFopM6d7LdqtSq3UO7a8/lccQuVSgWJREKEe46HOV2kCqbZbCIWi6FYLIrBBkB0\nS3qAjMdjjZxJuiedkyjQaDRSaZLP56UFtNvtqNVqyjQhOsRSA4CSa9lQs+5nUla73YbBYIDb7db4\nmp/zQ2vmR7Uz86ilRS1ruVQqpbqN7C/mhzCXj3gtJ15utxter1cwUiaTwXg8Fi7r8/kQCoWQyWTg\ncDhkVUXPDPKQOarmgMRoNCpSze/3w+FwiEfB5ClyJbxeL/b29oQ9c5Et5hDu7+/D5/OpPNjd3UUq\nlUIoFJInHEOLCL3Rf49oCq3HMpmMnOydTqcUJJFIREQhBgtx2sqp5fX1tSKPaRlMmRhjLRKJhMoX\nsvjY/DFD/CHXo1rM1Lsx05nOmeQXb29vi3Nrt9tVBozHY1EtabMFQMJVugCxWSL/mLsdp2m0q41E\nIvfypFmnk6O8tbUFp9OJ09NTTRQp0VpbW5NwYDweo9PpiMQUDAaRTqclElhdXUWtVpMxY71eR6PR\nEBON1gkmkwnb29siVW1vb8ujeTKZaBzNTBLqCVdXV2VDtr29LaiTA5N4PK54CbqXMn6COzXxe5ZE\nTqcTwWBQ7qbpdFpw5Pr6+oPu/6MqMxiW2Ol0kPsihPHk5ESB5PRxq9frkgWZTCZUq1V15oPBAKen\npxpeMB7C4/HI7XNpaUmmKH6/H7VaTcy55eVlHZmU3S8mmN7e3qLVauHk5ASbm5uo1+toNptKwWId\nyQDN5eVlUTfPzs7kz0y9nNfrVT37zjvvKGGW7LhyuYxcLodEIoFyuYxkMol8Pi8Vzc3NDQ4ODuBy\nufDq1SvV/W+//bZMXwjtcfhBfJ0Wv5xSUuFCo51WqyVuM51VKQUjgZ/ezwCUGvu616PamVdWVkQn\njEQionICdw0hlSg8TjOZDK6vrxUi2Ww2kUqlEAwGhQhQNkS1SK/XQ6vVUkdPcg1wdzO4k5LfzBKB\nmsLhcKhygSR3WnsBUOwDJ2x8IJi4ShkX0RI2VA6HQ7Upd06askSjURQKBT2Y0+lUJt8A1JiyPPD7\n/YL9mIO9+HmFQiHFWDAAiI2cyWTCzc0NisWipqQkIbEs4USUjS0X91cTwIWLUBgNRRhDRq0d61iS\nw5lRQl4AVddMJ7VYLLJs5XSLdTBVxZTwW61WjclZkrARSiQS4hgTVVlfX5f7D3HrdDqNYrEopCEU\nCmkX5MJhCi3hLZJ7CInRBiCRSKBYLMJisSgbm/ki5GQT8aH1LQBZc5lMJuzt7amW5yKMx+MaY/Nh\n4ENEPjM9rWlOEwgEUC6XxSkJBoMqlUg28nq9ePr06YOsBh7VYv5/2HuX2MbXNL3voSiRkijeREq8\n6a6Squqc03X6nD59mzFmpoE4i0Hs2SWzCbzILpuBYwdxso8RZJO17VUwNgLYm8DxwHA8iCcz4x50\nt/vUudRNUkmibhTFOylRlERJzKLO72mqPXaAUpzxCP0HDk5dVBTF//f/vvd93ufCbplMJvXy5Uub\ncePkzsCDsW+xWNTZ2Zn929rttq0I4GccHx+rXq9raWnJkB0ZJyhF2D0JvwQCxGLr5z//uZaWlmzO\nPTU1ZV4GJUE0GtX29vYdqwJ2O/gOuBmx60Ki73Q6zsPGJB2oD9ekxcVFM+Cogxk9l8tlN7DhcFhH\nR0c2A4cui/80pUa32/XDDb21UChY8IsYAYiQrJRAIOBhDqgMvG3I+u97PajFfHp6qtnZWTsSgRSM\njo5qYWFBh4eHd8IooV0Sh4ad69ramh3vGUqgxJ6amtL29rZlVpFIxLXy1NSUkQs69VqtpvX1dXtJ\ngBMHAgHbeDEe7nQ6ppEiAmVogRsR9EwGEghxiVA4Pz83P+Pp06dOV8Xi4NNPP9Xe3p6J9ciYIFJh\nkTA5OakPP/zQKhWULaOjo3r06JG2trbMwVhaWrKPHV597Xbb2TEff/yxXr9+rXK5bG7zxcWFlpaW\n9NOf/tR86sXFRf3BH/zBe9//B1Uzs6OBOLRaLZVKJfV6PW1vb5sMhPdZq9XS1taWpf27u7uSpD/+\n4z82ToxzJ6UIfsaMYEl1Qmp/cHCgbrerVqulYDDoxpK0VY5fkATYdbD9Tk5OtLu7q/39fVvbbm1t\nWQECzZP8FUkOh6QJhSvCgIRxfSAQULFY1M7OjimvIyMjevv2rSYmJmzHcH19rWazaZIQEQ4YhG9s\nbLie5j0DSZ6cnGhvb0/VatWl15dffmnJFYJgfDgoRSKRiH7605/e6/4/qJ0ZoguezKAHNBhjY2Mq\nFosmteDX1mw2XTfSgBHsiC0WTp9MGKGCNhoNhcNhLSwsaGNjww0lk0ZUJ2dnZ+780SDirUHzOdwg\nofeDyDMcbgl6kkqlnF3SaDQ8XKEePj4+to6R5Few8qOjI0WjUSMmmJEzOOLBweEIo3CIXKhQSMqC\nYDQ9PS1Jd/jW2C6QQ55MJu+ExmP7y7993+tBLWaEmnhNAOgDb7VaLePMlA4ctYyV8UCDAgp1kRKA\naDByOeBKo6/jRsEoQ8SKjReDG9w+oZlK8k4/MTFhKwQeCMhR0WjU4tTR0VFzrJfUCdUAACAASURB\nVDm+ISNBlOdBokyg/MGPj0ZYeicqODk5MWeEMT28auig8Cn4zHkNXP/hmvR6PWUyGX8eJApAxwXB\noQnkc3jf60GVGZlMxvG6sMAoO05PT7WxsWGft+3tbXvFQVHsdDreeTiuqYtxkz85OTHcxPes1Wo6\nPz/3wmFBM8plzM6EkXp8mFyExRXyLnZZID2C2ilX0OXBa2bHZ3cbjg+emJiwPxyhm2DqU1NTHhJB\nfaV86Xa7XpA42yMXgzZLM1mv1++M3FutlsbHx1UqlcxFQUYFPl0qlWwOAzx6n+tB7cz1et1sucPD\nQy0tLdkDbjiJ6vT0VPPz8yoWizo4OND3v/99L/zb21sVi0VTLTEyQdpDycGNh9vcbretwN7f31cw\nGFQkElE4HFaxWFQymdTe3p5mZmZsaQtBCHcjOvxer2fFCLvi5OSk7buoU4djzjCbwcARESuSsGEl\ndiKRMDzHsKPf73vsLP2C03Fzc3MncxAnz06no7W1NS9SsHAkVVBZgQbHxsZMCWXTGB0d9YInw/s+\n14NazNAlu92u1tfX1ev1tLq6qoWFBcViMcvfi8WiRkZG9Lu/+7v6+3//73uXAycF3ltZWVGj0VA8\nHtfOzo4//MePH6vVapm/S5NXq9U0NTWlmZkZL3BJHu9+8skn6nQ6ury8NOQlyRYC+H4woKA8gIif\nz+e9ED/++GMnQEFawpeCdFTQGlxM4U4z0WOw9PjxY/Oiz8/PfSI8ffrUwUYMU4AA4U8zoMJ2C1UL\nWDRG64FAwPkmTC3D4bDevn2rlZUVU2V//OMfv/f9f1BlBjtMJBLR9va2ZmZmtLm5qePjY21sbGhk\nZESbm5va3t7W9fW1/uiP/sh14v7+vvNMGOtubW1pYmJCf/Znf6bFxUUT5iENkWLKtI/FPD09rTdv\n3tjhBzYYabGBQEBv3771BLHT6SibzXohkDFCwhRDj3A4rJOTE83OzupP//RPzQhEywcXmjG8JPtu\nEEwEe29vb88ck6+++sp8aZyggsGgk2CxNsAjhIknuDH2vbjs93o9/Zt/82/8cxAkNDY2pkgkomKx\nqGq1qlKpZBLT+fm56/D3vR7UzsyMH+y4Vqvp6dOnPloZbYML09gtLS1Jkk0Ih9Oger2elpeXjTkj\n0BwfH1c2m3XE7/HxsSdxjUZDS0tLNjan3AGayuVyLn0WFhYsI6JBwsSFeAZ28Ovra62urno6yEgZ\niA2JF6YqWO9SbszOzhpJYac9OjryuDqdTjsQk1obGBBSFdNBBAYEbi4uLjoACKN3ml+abxIAEomE\nut2uCoWCSqWSJ7c0ou97Paid+fLyUrVaTb1ezxEPBwcHCgQC5lNQryG5J2CnVqvp7OzMIemYk2M6\nzo4WCAQ8vABL5e/QFmLq3el0dHp6qp2dHd3c3PgoZiFTEoCJYzvAQ4BRODl7wIiVSsViXB4Cfn5I\n7yzm8/NzJzsxqcPc/OjoyLnZ7Nq3t7ceTXe7XXOSydqmB6FnQGxQrVa9WDFlhOvBCcLDzESWr8P2\nlhi3970e1GLmOB0bG1OhUHDcWDgc9i7U7/cdYQABPhQKKZvNWjaFXIkunEBKbk6z2fRNn5iYUK1W\nUzqdNmwGJRJn+5GREbXbbd9UXDCR5+PEyeIHoyU7cHp62hYBiFuRd0E4wkgRUS8TymGBLAaN7XZb\njx49crJrtVqV9IuHYXt7W5FIRNFo1Lg0wyLp3aS12+2qVCo5fg0SlqQ7uYTwm8fGxhwNEY1GPW1F\nnVKr1e7Fy5AeWJnBTYYsgzUAi3RsbMx8AnDoSqVi5x+OyMXFRScxFQoFx6VhWwD3F0cgTGFSqZTx\nZSA3BAL4rREkiS6QhRAMBi0m5TRAtwgEB0e43+/ryZMnTkENBAIObOd98vNKsj0tZUAymfT4nWQo\nBkszMzOS5GaRsufjjz/W/v6+x+98lsOEouEyBN3ksL0XpdPExISazabm5uYcAB+NRrW+vq5/9a/+\n1Xvf/we1mEEXkPIwWfre976n3d1d1et1TU9Pe9pUqVTUbDYt/4fv+/nnn2txcdFEI3aQi4sL7e3t\nWdKPi2a9Xr9TMszMzJjsP1zSMG6/vr7W8fGxj140gzxYyPtp7Jg2AsuNjo5qf39fhULBOO/19bVq\ntZpj1hi0oBiJxWKOHx4m+PR6PUej8XMmEgm1221tb29bRf6zn/1MhUJBr1+/1vr6uiPdsDoACWq3\n2xoMBoYhyTSR5CaUevzNmzfG5QOBgF68eHGv+/+gygwWAGJQjm+GA1hHzc7O6vr6WpFIRAsLC3Zt\nLxQK7txnZ2eVzWaNXLBDIt1nPA2XGChqWIEMmsHolmlYOp02rjwxMaHz83ONjIxofn7e2DTMNKZp\npFCxg09NTfn4xok+n8/bkovmja9H1c176XQ6biCB7Six2FEvLi7cLDNc4nUgOoFQENLJ2D0ej7sE\ngjgFuQnoELMeyFmccO97PajFHIvFDMZzYzEVp6mizMBkEANAXIgYGaMmgXyPSSGdeCQSUTabVSQS\nsUQrkUj4e8RiMXOEUZ9QfpRKJU/POp2OxsfHbUYIY40RPJL9SCTicTwsNth/TPsoldAuwskm6/rm\n5sZ85EePHtnEhihkRAmUOysrKx7F83nwUKPC5qFiwBONRu1Vx4m1srJiO4PBYKC1tTXzzDc2NnR4\neOh7dp/rQS1mkAlk/DRdgUDAmR/hcNilCB8eDR3TuKOjIzdvyITQ4fX7fR/3dPG4EQ0GAw8ukNUz\nVcRSdmRkxOmr8CDg/WJ9xTHPkby9vW0VNiNjMg+RfGHCSOlCUgB6x0QiYV/ndrutvb09x7PRBGMs\ng1UWE7tisWgkZXgoA/w5HLUBMsTPO6xCWVtbM6OPIRQ7OIOm+1wPajEz8YrFYspkMlpYWLhjUIIO\n7c2bN7bVyufzdg1KpVL+Wiy0YJrhw4aBCsSdR48eqd/vO8R9YWHBLj7hcNjEGsLooZb2+33Nzc0Z\nG5+dnVU+n1cgEDC3hFOARQEDDQOVq6srra6uGiLj/QN7dbtdGxjyUGE1m8lkTCiCGjs5Oem4YiaE\nYOG4f+JeSvPJZwWKg4f1wsKCJicnFY/HXa9XKhUlk0kVCgU/aExVgQrvcz2oBpAOm9BKjj0IPNVq\nVWtra3acbDab+slPfqLf+Z3fMU9CeqfoKBQKNhGkMaLJYmrIrokBzBdffKGlpSUnn0ajUYsCUIfc\n3t56isaUjigGjFjIGWFHYzFeXl4qFos5aw9zSExeGo2GLQnIrIZkRVN8cHCgq6srVSoVvybE/M8/\n/1zRaFSdTkdXV1fa2NjQt771LWPGkJBoImHUYSIDsnJzc6ONjQ19/PHH2tvbs5cIzqWMwMHLCc7c\n2dm51/1/UDtzo9FQNBq9M7qV5GYvkUh4d6NUYGdm52NnhjQz7C8My02SNYB8DcoRGhv8ncFaY7GY\n+dNM2XCyB7KC0QfkBQUU939y/7CmhZ7KbinJQ5B+v+9/gy8Fp8DCwoK1i9Tr2NQOy6emp6fthB+P\nxzU7O2tYE0wb9TXO+5D5sXigtuczYyfu9/sKBoNulDOZzL35zH9hizkQCAQDgcDzQCDwf3zz++lA\nIPAvA4HAZiAQ+D8DgUBi6Gv/+0AgsBUIBN4EAoH/9N/zmncYbfF43PUdgxIUwagmIMeTeVcqlUz6\nQRERiURcdnCzmOpJ73BfdGwwykAFgsGgTwoeDEkWrZKvgjEMjDe0eRjbMGFE+c0pwvFOUzoYDFzz\nN5tNcx5ohuFugPgwyGF6R34J743mF4f9QCDgEwsCP+6e/X7fJ9jMzIw97piK8lkxNCIgk2EQm8/7\nXn+RZcbvSXolKfrN7/+OpH85GAz+50Ag8N998/u/EwgEPpD0X0j6QFJB0h8GAoH1wWBw+8svyNz/\n+vraw465uTmHwrBbocP7zne+o+PjY+8oIA7r6+taXFxUt9t1HY68H7n/4uKiDg8PjTywUIH2hkk/\nS0tLhukgxvOay8vLikQibigZ/ExMTOjJkyeuddvttubm5jyYoBeA5TczM+Pp4K//+q+r2Wzqhz/8\noUqlkl8fEtTLly8dAVev1xWNRr2DMkwhygFmnCStrKzo4OBAyWTSKVmkFcDNgMfS6XRMUWVAhDXY\n4uKiarWalSiJREKJREKFQuFeC+ovZDEHAoE5Sb8t6X+U9N9888d/XdJvfvPr/1XSH+ndgv4dSf/b\nYDDoSyoGAoG3kr4n6c+dfbLrFotFFQoFhyh2u12dnJwoGAzq5OREIyMj2tvbsz0U3IJ4PK7NzU1b\n37bbbTvaB4NBJ5XC38AbgjocUhApqwsLC3rx4sUd1yCQgnw+r2q1qsPDQz8c6XTaNer+/v4dU/Ji\nsXgnYSqVSrkhbTQabnh3dnY0Pj6uL774wgQkxu4w/TDJYcAxNTWl5eVlnZycqFwu69NPP7WY4ZfD\n3gnlhFGHri+fz2tra8sELgZT8Xhcx8fHxqNPTk4ccccJEwqF7h0E/xdVZvwvkv5bScO7a2YwGJx8\n8+sTSWho8pIOh77uUO926H/rormCIMQCQNqEjJ5mJJlMWscGPIcHBnUftgKMeamb4SWTz41ekPoY\nST6RC9TLwGCUB3hGh8Nhzc/PW6pF3jSsNIYb2OaiDcTPjQaNh4VaF4sAJoe4k3L0Q0/FVJFhysTE\nhPkVwHAY12CzMDxm5/OSZOydzPGbmxv3F3zmw+HxvD9KsPe9/n/fmQOBwH8mqTIYDJ4HAoHf+vO+\nZjAYDAKBwL+P3Prn/h3TulAo5FDFbDbr+DGoiIg78W1molar1dRut50dQjjNRx99pHa77boZwn4o\nFNLr1699XLKrXl1d6dGjRyarszAxER8ZGdGHH35oOKzZbDoEiIkbZcnY2Jg++eQTnZ2dqdVq2bgc\ntQrfA7YaDkZkpoAbgxqA+GCyPjIyopWVFQt/yefGM5nmGI7zN/fHglbKomQyaZsHuBnDAZl4ZpdK\nJQ9zMB4fHR01Ln6f6y+izPg1SX89EAj8tqRxSbFAIPD7kk4CgUB2MBiUA4FAThJxnUeS5of+/dw3\nf/ZvXV988YWB91gspu9973v2NJ6ennYgZavV8gcLPtxsNl2rknrKqHhjY0Orq6t3AiOldwoR6Z2v\nM9M0VNns6MiuSH7FQLBcLltPB6aLMyn+yZI8esepnxwQJoGzs7M6PDz0wARNIEproLP19XXjzMBl\nNKiSnA3Ybrc1MzNjRiAC2WFbA+r9i4sLraysmFZL5gpWva1Wy9NWgjNxPo1EIup2u/qDP/gDR3L8\npcsBHAwG/8NgMJgfDAbLkn5X0v81GAz+S0n/VNLf+ObL/oak//2bX/9TSb8bCARCgUBgWdKapD/X\nYOG3f/u39ezZM62trZn/S+cOBRJMFix32KkHqVG1WrXUX/oF6Z+Qeeo8vCzm5uYcPD/MVMOU5uTk\nxIMNJndAdvCEGSODIEjvTGGKxaIHGSyKer1uiwCUK6Ojo2bqVSoV+1ygpuZUOTo6Urvd1tHRkbF4\n+gqyTVDc7O7uuvkc9rkmLxHzRR5wBjAnJycW3TYaDdVqNVUqFY/JDw4O/P0eP36sH/zgB/r44481\nPz+v+1z/MQxNKBn+J0n/OBAI/FeSipL+c0kaDAavAoHAP9Y75ONa0n89+Hfoa6rVqlUW+BOvr69r\nZGREc3Nzkt5lBQ7nYuN8xL+5vr7WX/2rf9WOoWNjY/ZmhvM8jO3ifwz+G41GzZhDALq6umpeBOlT\n6ALHxsb06aef2pyGvG3qZWpqmlaiIPBQ5vtLMo0T9IQMFkbHy8vL+uijj3R8fKyTkxOl02lJ704x\n9IY0iRMTE/r000/NJ1lfX7dsbG5uzqUTPzfmktls1jwNKANra2va2dkx7rywsKDT01N9+OGH+vGP\nf2x+yO3trf7JP/kn772Q/kIX82Aw+L8l/d/f/Loh6T/5d3zd35X0d//fXo+SIpVKaWtry9RKIDLI\nRLgUgQEXCgVzjs/Oziyy5NhvNBpaXFyU9Av4j3oPDJejFr9jBiF4One73TvJVVjUfvDBB9ra2jLB\nKRaL6fj42Po8nP45NWCtYSADrRO/O7gn6A15n9lsVmdnZ9rY2PDUEAU2jeX8/LyazaaHJeDAQIZo\n9X72s595HI/iJpVK6fr6Fymr19fXymQyVspXq9U7tbn07sRbWVnx2P9XXnNDF5ZXjUZD9Xpd+Xze\nWDCSptHRUdVqNevwcOqBWIQh4dnZ2R19Xz6ft6kL/Irj42MtLS1pc3PTjvLUsQxOarWak6pAF2q1\nmtNih3dCxtE0i2C5mBFC3SQ0XpKnhLVaTdls1sMNdtRhr+RWq6V8Pq+XL19ay9hsNq173N3dNQNw\nfX3dD1Gj0TCKAc7OEIi+4ejoyIgN4e8IEnA9Oj4+dv0fCoW0ubnpxK2pqSltbGzc6/4/qHE2kBML\nSZLhKqxhWbT8Gd369fW1KpWKVlZWrELGlhbeLkEyTMskeVgCfsrNabVa3v1IfaJxBIeFpim9a6ym\np6ft5wxScHt7q16v598zBgbOg81HhsnU1JTDMMGgqcrgh9DwAqsx+kf6xGcjyc3p2NiY3aJIASAM\nE/UNjS9mjZKcnXJxceFGmM8LBToOUQxZ3vd6UIsZzBJVMHXwcKQXU8CJiQnl83kNBgP/HgJRNBq1\nkSHwHpgsujiCexqNhon25AF2u10tLCzo+vraTR6eyjh2krEC6kBziCxpamrKRCJI/MQwMJ3L5XL+\n3njcoSaHmE89/fbt2ztuTaurq8adZ2ZmjCfjTQ0vnOgKyoNQKKRkMqlMJmMrLiBMuBXBYNC+H/yM\neO71+33lcjkbmu/v7zvy+S8dzvwf8uLoe/TokXZ3dz2sgHr50UcfmVvMQqUehA/BDkJWB4lK6Ao5\nOiEFnZ+fu65Op9MuN4ikQEzL8Q36US6XVS6X9eTJEw9xoGaWSiV7JrNDYudF7iDuP2DCjLiDwaAN\nx1moR0dH+vVf/3Uf91NTUyqXy8pkMpqamrLi5PHjxyoWi16U6PPGxsYsdkBdTX4gD2omk/HPEIlE\n7jR1o6Oj2tnZUS6X84l2c3Oj9fV1P6jcp/tcD2oxswt2Oh1PskgXhUZJTZpKpXR6emqvDEz8aGJ6\nvZ4bP5ohdHVYFJAKdXZ2pkaj4bixQCCgcrmsZ8+e6eTkRLVaTZFIxFRPLK/y+byPeHKpr6+v7xzB\nktw4ogVkqHN+fu7d9urqyijKF198ofHxccdgEGjJRA5KKyaKfI9ms2mDxtvbW9XrdROOMK6B6Xd9\nfW0EhFMLnFuSU3Jvbm782SJawIcPshMptn9Zx9n/QS68JGCDochgVNrpdDw1g63GgKFcLlu9LMmE\nfbK3wWKr1ao9iMFx4WRcXl7q8PDQQ5nNzU03jJQRPBjSu4cPfw4eEtyLGJkz8pXkCWWv11Ov1zN+\njckLdgW4+Pf7fZXLZYfPl8tltdtt48g0j5CwSqWSm8VQKKS9vT0vUpAd2If0J9TmBHIyqaSGHx0d\ntWd1sVg0w25qakrFYtF9y8HBwb1Zcw9qMdOoIF1iAgY1sVqtqlarmUNRLBZtHJPNZh1Kw9exACET\nAV9h3s2xyGtK8s5FibG0tKRKpeKdb9jjmUZwf39fp6en1tSR7AT7jLoXQ0eEAZwO4XBYjUbDtS9E\nI+DCSqVi6y+4JSxMml0e8MFgYI/rdDpt9GR8fFyvX7/2yTHc6LKbk60tyZg0D4Yk5fN5G8+g4Lm+\nvtbW1pYGg8G9yfmB+/p7/cdyBQKBwd/6W3/LcBcmK1NTU8rn89re3nb6KhDT4uKi/sW/+Bf64IMP\nfETiLs+ABMEpMn4GAbgFpVIpCzUlefFls1mjEOyCPBzU54y4u92u6aGSjLB0u1078w8rsHu9nmZn\nZ+0YynhZeuctx/eA4IMOUJKj5c7Pz/X48WM9f/5cCwsLarVanohOTU0plUrZOw94LxwOa29vT/Pz\n86rVavrOd76jg4MDD094DUkO3+E9sMlQFvV6PaVSKQcSZbNZ7ezs6B/8g3+gwWDwXmLAB1UzU0dS\n25JGen197d0NJXM4HNZPfvIT+09QJ6Ktu7q60uvXr5XL5e4ouDmquTHDOxVGiAw1ZmZm7gTWUK+v\nrKzo1atXd6LLRkdHdXp6qkQiYUZeOBxWv993qYFdLH7LS0tL3pXJa0mn0y4ppHcTT5pTHOwh+PNz\nVCoVnZ2d2dsDkhWLmAVIniFmjGQs4oREmREKhRzYSVJXqVRylgvfhxMUaJTm8H2vB1VmQCXEIYc8\narwpKAtoxgqFgp4+feoINNzt8Y9IpVKmQ+bzeSuncR2CaA/PIh6P2+qViSHHLoR8giYhBA3j3DDq\nJicnbTMG8R/jRpAPfDTw1cDeAAuEfD5vAn4wGLSIlnE7Uz5IT7FYzLAfsij+L71DTWKxmOkAnFjk\ns7DwcW0aHx93VPJw5AbMQGi2qFw4Ue5zPajFDIzEWBpDPsB4dkDwT5ovFhq1JX83Pj5uGAt4D24x\nN4yRMfU2JQNNFjgsN4whAaXJYDCwSJTXxMWfMTwPGLsfv+50OpYcgZkzGCHm7fz83GUN5pAgMPF4\nXOl0WrOzs4YcIWdJMrxHrU0ZMuzzTOkEdIiA+OrqStvb2+Zew0ch/4+HiXr6+vr63r4ZD6rMqFar\nFna+ePFCq6urVkZUKhUNBgMzyrLZrBUgIBmJREJv3rzRl19+qd/8zd+0kpkdB/IP9loHBweu0VFS\nz8/P+wiHRvry5Uutrq7aVw6HfBYBHhNMLvGq6PV6zg8JBAKeUMJ6IxTz7OxML1++1NOnT1WtVrWx\nsaFcLqdGo+Fx9He/+12XLZRF5XJZlUrFKhC+dmpqynazKGSCwaDZe+zoqVTK6BCsw7GxMafFUtqh\ncUQ4gCHlMFJzeXmpP/3TP73X/X9QOzOE71qtpt/4jd9wk5HJZLS8vKz5+XktLCw4n2R9fd2LZ3V1\n1Q3Pr/3ar1kvFwgE9OzZMw8k4FeMjIyYGx2LxZRIJFyyUDJwcxcWFix2xfyQsS4awm63q5WVFe++\n+H+k02nbdi0sLLiBXV1dNRV1fHzcKbCRSERra2t69uyZDWeSyeQdESmZ36izP/vsM4VCIS0vL3t6\nGA6HVSgUbPV1c3NjSy6U2ZwSlEoEuSMmpsYfGxuzmePk5KS51PjTIXxdX1+/1/1/UIuZumtqakrP\nnz93t9/r9eygj4UAuSH7+/v2v7i+fpd/t7+/72O63+/rxYsXHrdCUuc4Zxfudrva3d3V9va2nYko\nGYrFot3lsYPllMDPrd1u6/PPPzc/gl3/8PDQ/s3lcvnOe5qamtLbt289TKlUKup0Oh748GAwkgbx\nAKEAa9/c3FQoFHJ8G+VSs9n0/8GxW62W6vW6tra2XM8jRfviiy9MGsIUcbicwqPj4ODAvBA41ldX\nV7bWfd/rQS1mTMAZSRP+gjKZm/fixQt33YxhqXXJMSGeASXH+vq6RkdHHXbDhA1HI0xMpqenzbTD\nTT+RSNg8EHSiWCx6XBwMBrW+vq5CoaDx8XH/HnbZy5cvzXir1WpaWVmR9G5w8eTJEx/ZcB6IsIBH\n0mq1lMvl7vQM+/v79rogSmJ8fNzxFcOefPQRpGphKonYAUwZvgkPOicM7qlTU1NaXFw0TwbWIpHN\n1Orvez0onPn3fu/3lM1m1Wg0bKGFDIhmj6kXyuGXL1/qu9/9rrnAML6y2ayCwaDi8bj29/eVSCTs\niTEzM+MdKxKJ2OGn0WioXC7rO9/5jqEtmkn8inu9niE7xursrMVi0bKpfD6vZrPpwcT4+LjlTJIs\nph02RJekR48eeQeHttlqtbS2tqZqterQTGBIbHNBLeCVrK2tObx9b2/PAl1Jd0QJ8Xj8TlOMAQ99\nCerwUqlkHSbKHjz2EB+fnJzoH/7Df/grnFl6B8Rj6DI6OmquMkOBi4sLVSoVXV1d2dwF8jkZJoyW\nk8mkyuWyHj16pFwu5zF0r9fzWJZUUtTfoVBIhULBhPTb21sT2OEqsDihmGLa0u12vdBisZgjgbHH\npRTK5XIaGRmxOaQkP0xjY2Pa2dlxTBzvczgDEZ4GFFJOj06n41qW6d75+bk2NjYMqd3e3nqgRK1M\ngxoMBm0GyWeJxxw6wvHxcSd9QZ2FAgvP+z7XgyozUDTTXAD9QBCnXkYrB6Go3++rUqlYaAm8l0gk\ndHZ2ZiiPY5obgHEMSg+GKOx81MKQlKiVaaAIk0SkCm8auBDkBEU4wxygr2g0ekeyhI+HJDsNhcNh\nN4gYGzKs4LMCB0Z9g/8GJQCnDiVHNps1FCfJ8B3qF7IRsRgGlSEujQcBExu41ffNNHlQOzPdM/oz\n4n+BwOD+QpznmIdUxDABKie+w+xawWDQDDgWifSOzsjCQ6UNtkr+nSR7QqPQJpJ3eCBycXHhiSRk\nf45m/i02XKFQSGdnZz6+Dw4OzGADRmSxMHnDu4PanNIJS1sIWaAWCAFo4ubm5kzQh4fNa/E9rq+v\n9ejRIx0eHnpkz3QTigAnZ7lctgUDzfX7Xg9qMRNZxqBi2ELgW9/6lssISXbvubi4cLYJcNWTJ0/s\n0wa0hPE41FH0hkzxMFak7MArAtMWDF8Izzk/P1cmk7FQFp41R7gkE+zBmUElMIohPIf0J4Y/cJQh\n1SM0CIfDWl5e9tCEU2Ztbc1iU+y6mEZSK/OQ7+/v69mzZ2bJkeN3dXWlVCrl4QruqIFAwA0zlNtM\nJqNGo6FkMmlZWzweVyaT0e///u+/9/1/UIt5fHxcf/RHf+SdgiYtl8upVCr561KplDY3N8304liE\n51sqlfThhx8at0W5EolEjAJcXFz4RqCZ29/f19XVlZ48eeJBCjU5Rzz1KiGQjLKpF0Elfvazn+n2\n9tbE/16v52ObcT2j6WGrWTLDYdxRokC7HB0d1fPnzzU6OqqFhQX1ej0dHh5qamrKTenBwYEk6U/+\n5E/0gx/8QMViUbFYTMVi0RRRSqm1tTVtbm6az8Ewh6DON2/e+H0Pm8GjEaOx9AAAIABJREFUECcl\nizyY+1wPajGHw2F9+umnkqT9/X3lcjlH+FIijI6+C1b/9NNPdXh4qF6v52EENTfqEbK4i8WiPvnk\nE11fXzuJ6vLy0vG/sNAI5gmFQjYCDAaDajQavmEMEEqlkkWylAT4shGTDHRFRjVlEWFCt7e3WlhY\nMI2T3BFG52NjY55IPn782Gbei4uLtpLF40LSHfQnnU7r6dOnVsYgJ2OqSMOXz+fVbrdNbY1Go8rl\ncsbBnzx5Ikku7dj15+bmLHIgGeu+QfAPqgEsl8sG4NvtttW/OOZj/8RiSqfTbrhIe4J0BCmJ8oDm\nBSQENQj/BpvXk5MTNRoNHR8fq9lsGhqTZG40rkl7e3u2O4DpRrjN0dGRzs7OdHx8rFKpZOwbo3Ho\np5VKxRERjKlRcnPasDPi7onNAZ8NMil8+n7Zfw81CGN/eBUoyodFBDjg02CD7fd6PeVyOUeo8VAg\nUSsUCsbP3/d6UDtzLBazgcrjx49teTU1NaVcLqfj42P/GVTJ2dlZzc/P6/j42LDXs2fPVK1WNTMz\no8nJSa2srDhhtVAoaHd31xmAwzawNzc3mp+f19XVlU1nzs7O9OGHH9ooER706Oio/fDm5+e9+MB7\nP/vsM52enro5ZKDA4lxcXDRaAc6MgSHSLcSxjN/Hx8f15MkTZ5VEo1ElEgmHvWNsODU1pWQyqU8/\n/VSnp6e2q/3ggw8s9wIbnpiY0OPHj90rMHqXZFbh48eP9ebNG4dwghrlcjk3iVdXV1pYWLjX/X9Q\nixlrq0QioVKp5KiFfD5vFly5XHbkGTsHtlpnZ2e6ubnRj3/8Y33rW99y140XBrs3MiiI5+zK4+Pj\ntrKlbgd7ZVedmJiwXS7/BqfQsbExk3tgvKFsBpID193Z2VE8HjeHGNNEyPws0FAopHQ67UnjxsaG\njcvJ1YarcXJyckf6BK4NQjJcKyOjokxidD5sc0sZ9ZOf/MQCBfLIm82mNxNgxb29vXvd/wdVZpD4\nSdmAATecY+KFi8Wij2QaL8a54MQ48EMNZSEP482tVsuvD46K5cDZ2Zl97pBnUZOXy2XX76VSyW7+\nTNRg6gFpoUZhAXGEg1+zOHEm2tvbs6PR8fGxnj9/rmaz6TobSwPwZkl3yqJarWYjckSzfGa8Bgy8\nwWBgmdmwRS/4+sHBgYW7ePbh88dDge8civP3vR7UYgZu6na7XqTIh4CvWHwTExN2pZTe5W1gVM6R\nSeeOjSzjbuRNNzc3hvWwo8IwkdEv+Sa8FgMG6lQaJ/Bd/p5pIwR2VM9o9fh9t9s1J4PviVsoPwdN\nMAMe6Z2YltMFQe74+Lj51ihv0OqBNTMlROaFVW4wGLQotVarmaeBcJWfgYeU04cTcnZ2VvelVjyo\nxcwVDAa1vLzsIxuMNBqNan5+XolEQhcXF/rBD35g0L5arToMZ3l5WZOTk1pdXbUyYnd31/q5+fl5\nm5vgEQdRplgsuhwAviPgkqHBsJ0AsQg3NzdWVMMVpoaFBD8sB4MkBD85Eono8PDQY/GrqytlMhml\n02nrBkdHRz00IZwoGAzahJEHj1JmeXnZpCDYfcMBltTt+DWTghuPx+12RLYgp2QikdDs7KzLQWIz\nxsfHf0XOH76AeJD/4OmAqzvZeq1WyzxjuvxGo+ExLYgGGR4498AMw1YA8hGCzX6/rw8++ECRSMSO\nP9PT08Z4G42GE5Y4MZB6Db5JumL8zi5IWUFyKxNN3gMcYXY3CEQ8PCxEBkgoxzudjndwYtqYgiIN\ny+VyTg0AMcHIhmEIERMTExOeeGK3xZifBAISAcbGxiz1QvnCoOde9///o3X0H8XFBwdJBnlRs9n0\nMckY++bmRm/evDFSQOglu1YikdBPf/pThUIhdbtdR5/RjK2srFgIcHNz45p4bm5OoVBIW1tbxnFR\nWDB5gwAFU4/3x8PCIAZ+Nb9Gzzc5OWmHfwSleOUhcZJkGwBI/MFg0DZbfC6UEWDYjMnJScHyi4XN\nw5tOp/Xll18afYFIBOF+b2/P3Be8q1HehEIhxx8TYTEyMqLl5eV73f8HtZhpKIC/kEQRkUsULoR8\nhghgwSw4GrJhuRA7LyNxFhnecoPBQMVi0c0Nejtiz1BR09TRLKLxY1QOoR2CDzZdkPrxjCuVSob4\n8NAALtzc3HR9jvMpNTLvqdFoSJIV7NI7E539/X1HOfT7fRspDlspDGsMKX8wlESHyImGPGs4l4XJ\nZKVS8ci+0+loa2vrXvf/QZUZ7DRM1MCG4/G4Op2OPzRQBTRs2AOcnZ157I1C5erqSktLS2o2m961\nEYOen59rd3fXgllkVLjgD0f1Yn5CREI8HjdPpNfr6e3bt0omk05xrdfrxmmZstVqNaXTadXrdYXD\nYXU6HfvrIdXCaCabzRodwN0JXLjT6ejRo0cKh8M2aeH0mJubU71e19LSkmOHpXcLHY8QCEtIyaDX\nYhozOTnpQKPhQVE4HNbBwYEfPKaUvBaU1ve9HhQ5/2//7b9tE0BgNpwrhxUoxA4fHBzo6OhIH3/8\nsQF91MZ4NeOPHA6HLTfiuIYlBs46Pz9vUxOk+pCKbm5u3CTmcjmVy2XzKOBo4JzPgwOpabjuTyQS\nHsljoojhOIT4arWqqakps/p2d3f1rW99y6cA/GfKGfyq4TpDA221WndqaWrtRqOhVCqlsbExG7lQ\nKpBwi9KdySBIzXATGolEVC6XXcIUi0X9o3/0j35Fzpd+kZQKCb9QKOj169f66KOPdHR05A+YkoIj\n+vDw0IaLpVLJE7z9/X1ze6EukmmXz+e1s7PjmjUQCOjVq1caHR3V/Py8tre3TX9kFI3ItVKpWKOH\nO1KlUjGnmZwTckRCoZDK5bINWCQZV6aUgNfADkzONrsmKpiVlRV9/fXXzvUmIqL4TcYgDSS2Yclk\nUq9fv9bl5aVPqNHRUX311VdaWlry5sH7hCW4u7vrhpoyazhVFjEDJdvs7KxLn/e9HtRipsumEWFh\n0T0DO0myjAlGHKPfhYUFvXnzxrBSOBx2OUANyKKEbgkMxTQPuf6wGgMOMv8el1Iu5PnDptx4SoC4\n5HI5fy+I/DwAkrzQh/8MNTe/ppfgfcPbgPuNcBc2HwaInEiSHF3MAmV83u12NTMzY9gvmUyagssO\nDe+70+l4uMQD/Jc2O/s/xMXkid2KxYeJCqaEQG+4V4bD4TvHH+76sVjMyIj0iywU0AteH8MW5Eaj\no6Mm+1BqYHGFcADlBgMTMFeIOPF43AMVoC3MbQiFpCSoVqu2t6L0IOUV4lK73VYkErEPxu3trfkg\ngUBAR0dHDrVkiMLPy4ibngFv5larZS43AxbEsbwOny0lCra7YMq9Xs96wPvuzA9qMe/t7dnkcHNz\nU5VKxSUFknZgqJGREdXrdauxSRUdGRlRIBDwv+t0OkqlUoaSJBlSqlar7uLh5lYqFW1tbdmNk1oX\nByJqaRCPq6sr7e7uqt1uW+18fX2tvb09HR4eOvEKXBgDGqBHPI1BZo6Pj/XixQtVKhVP5N6+favx\n8XEz3GC3EbFMs4k2sdfreZrKZwcfZXt725O7eDyuvb09NZtN1Wq1O2XeMCWAzwlC0eHhoX9ebL2C\nwaBr/Pe9HlSZMTwho7lCH5dKpRzzQPc+MTGhly9f6pNPPvGCxrQ7k8no6OjIaU/hcFiJREJbW1u+\nKdPT0x48gPXCJgPRYKiA38Xo6KinYcBSkjxgAPdNpVKq1+s2rMGAEKXK3t6ek6WwTYjH41a+MJYm\nLTUcDvsYj8fjOjk5sSkkk8TR0VEnP0nya8K4I59bkss50m4RCtDoSvLnv7y8rE6n44EKYuDZ2VkP\nfXiv97ke1M48Pj5un+VIJGLTQxx5jo6ObG5IVBqxwEj+b25uXFfncjlP0jhyce1BG4gtF8c2Rze1\n5vz8vKFCxtnUrTDjSqWSDcYh6qAdZPLG8CYYDNriQJK97vg54UxQ06LwiEQiOjs7UyQSUSAQ0PT0\ntJl2PCDSu9qdBxSXfQhJ8XjccCF1NbtwvV53WYVYFU8Oml1KsNvbWy0vL/uERIh73xiIB7WYLy4u\nLF0iVbRcLqvb7drWFVVErVZTLBYzk+7k5MTG3NVqVVdXV84ShCtMSCVCTsbYku6w6SYnJx1ttrW1\nZfhN0h2MGF0hN71eryuZTEqS3Y8Ir4fM1O12bWiDEBTK5eeff24PakmexjGoAUuvVCqmWxKPMezz\nDFR4enqqUCikZrMpSQ7WxAcDQhG5MMCQt7e32tracp2NrS5ErvPzc7169coPCyP7QqFwr/v/oHDm\nv/k3/6b9LSYnJ+11vLS0pGq1atEmVEQojESCkVaFofjr16/16aefegoGXgonAaMVjARZtMj2W62W\nZmdnFYvFvAuyWIgwi0QiHm0z6ctms1aiSPJkjaYVPkUmk/EQY39/326k4ONMMG9ubuw7jUcIA5xK\npeLSAtRmdHTUwZhg5kBoEJYuLi5MKOKziEajHgZtbm4qlUrZZqDdbmt2dtYNOCUIFINEIqFyuay/\n9/f+3nvjzA9qZ6ZZIw4XDsBwOurNzY3H04yHaYBAAMhEIX+DoHWon5hu85rDQZVIpBDSBoNB77KI\nXBlWkHjFAwVPuF6v69WrVz4xkGNhDTA7O6tKpWJZE5gzxPmzszPvqrw/rGYpFchqGRsb83u/vb3V\n4eGhkRGaulqtZvydMT4kfCIyIBIhNID/wqQUpyRQCx4APq+rq6tf8ZmHLxTZuOdDjEGRgcyJ3Qby\n0OjoqL3dIpGIXYkIkCfeiykXHNzhXZlG6fr62goN0ILhmpUSCBgREj2LnFOFDBXYf5Cc+v2+9vf3\nNTs761OEKSW2VzSsCFWLxaJOTk78M1C+9Pt98zCGLQYkGXmBT4JBzPX1tWKxmBYWFty0MjBhx2+1\nWnY0pQGm9JmYmLDpSzgc1tu3b9XpdMwVv8/1oNCMTCZjUj2NHBMxEkZRUXS7XaVSKYenN5tNLS8v\nq9Vqmby/t7enxcVFRydMTk56tA2vIZvN3jFVgRXGAgZDjsfjPimgg05MTNx5ULCNpYxgVxsZGXFp\n0+v1lEwmPXCZn5932QRj8MmTJ0Y0UJ/DEUkmk3r79q0fZBCUpaWlO7pBFtbs7KyazaYJVUCf7LoM\nXvCPnp2ddXgRmwrWuVAF1tfXfVp+9tlnOjo68s91n+tB7czDlq/Yxe7u7jqS6+XLl+YrDwYDY8Ow\nw6rVqiYnJ/X8+XPvcBzJkH8YVvT7fUNyHM+lUkntdtsunxMTE34vBwcH2t/fN+cXQtPV1ZVH2dgc\n4Ex0fHysRqOho6MjW9sy+Hj16pXZcjSvTD1PTk7sqk85sbu76+YWyRK8FeRNaCgrlYqCwaDevn2r\ns7MzZ6CAwQ+jQyhfGKcT6fb1118rEokYb2YMTloW+styuWxt4K9yAH/pIjt7GCojOJI/I4SSpgdI\nCIQBaQ8JSXTqGGzf3t7ao46bgyLl6OjIY2vk9LD0JicnPR0LBAKuw/H0GPa/oJwJBAKuMylVGGqA\nBtB8RiKROxM5xviSjF/jDEpwEfVxIpHw2Bk8m4cRghA2BmDplENMERnHU/dL8oAF/D8cDruZJYy+\n2+3ag+Q+14NazMSJQUHEBhZ39unpae9sKDaIGh4fH9fs7KxrQnBbeA0sOoz/CN6h+clms5qamtL8\n/LxisZjy+bxHyywscFmINpCUksmkuRt8fTQaVaFQsO0WC3xsbEzhcFjz8/Oul9kt8aKmHia+AsXJ\nzMyMm8KZmRkvUFANkgfAiYfH15QwsAQxv2FQg9Ib7jThQNFo1PcGrnQ2m7XmL5FIKBgMql6v6/Ly\n8l73/0Et5tPTU01OTt4xGMRwm6gCjmJUH+zA0i/Sqqh/WRRYyFILD4P9vB5BOZJct0tyXUrdiJE3\nO7kkZ1oz7GCSxi5HLcsDQSmBAyiNGpNHYEkmcwgU2OkZkPD+JHlHl+TPhZ9XkhOvKGcY4HDKwEXh\n52YXxraLyGIEwfwawS4ozX2uB9UA9no9k4kqlYpD0IkvYLGR2wwufHx8rEQi4SMPrLrZbLo0YKer\n1WqWWqGiGCYjATVdX197zAwP5Pr62to4BjeRSETVatXmiVggMBW8uLjQ0tKS5V63t7fmg/T7fW1v\nb3uHhf9MbY1O8PT0VIVCQRcX72IxGNUDPYJdk9gaCoX8ELNoQXIw0ME7D3gNTSO52PQEIDCcmBin\nQ7DCHAdnpvtcD2oxLy8vGzNGcZxMJq1CPjw81OPHj5VKpdTv9zU3N6dXr15pfn7ecBFyJYSfhULB\nZts8LGNjY44qGxsbs3QIgSrdPHUxnAjqRY7ieDzu6Ao0dHjWjY+P6/DwUOl02lTSwWCgQqFgk5dE\nIqGlpSXn+EnSwsKCNjc3lc/n7VIkyelXDMkogchDZKJJ/mA0GtXs7Kyte1lok5OTVphjMcBGAIQI\n1RZsGzuvTCbjUT5+GwiJf0U0+qXr4ODApUWxWLTioVKpaHt7W4uLi25MksmkSqWSTk5OdHx87NIh\nFAqpVCrd8U0jtw6SfCKR0Pb2tjqdjhKJhBs3Fj2aw2w2q2Qyqc8//1zZbFYHBwd30qVglDWbTU1P\nT1shgh4OTjUG6ATb4LbPrthoNDwlRHaFSoSQeDDg4bhfGkkGOIVC4Y5K5+XLl1ag9Pt9RSIR7ezs\naG5uTo1GQ6urq66nKUGgcw7bKVSrVYVCIW1sbCiRSHikT5gSGPe//tf/+l73/0Et5mg0asd7TALZ\nfZDhU16Ew2FFIhF7UCB5v7r6ReZ2qVTS3NycO/FoNKpHjx4Zw6aRHBsbU6PRMCowNTWlZrNpf2Ka\nQqZ0CFmHE5dwM6Khy+fzrpsZceP5wQ47MzPj0+Lt27cmWUny4uOBZleUZK+L4QwSGs12u22fan5m\n6V0/Uq1WvbiB59LptLrdrrLZrPsSppAkyaKuSaVSxt6Pjo4c0cY9+uSTT/TFF1+89/1/UA1gv9/X\nzMyMlcXkgQwntwJnsQgjkYgbJoSXLGgoiuwkHJGQe7gJ0WjUQw4W88rKitlmOAdJMkmIGpQpXyAQ\n0MzMjGKxmBlmDC5WVlaMqkBmIu0qlUopmUwqHo9rdnbWdl1YEpyfn5vrfHt7a3Ny6KcMlnhIoMwS\nJg/n4vb2Vul02uw5lC70EjyYpBA8fvzYmYeUQMOREisrK5qenvZgh//f53pQizkYDKpYLKpUKhnR\nOD4+NuQDrjucEzIctINjD5gsJBweBIB+OBksymKxeMfSCkrk4eGhPZ7xVy6Xy7a8BceGhbe3t6dS\nqeTG7fr6Wrlczuw/lDFo7oLBoBs8QnaGs/6gXvb7fR0cHBiRqVQqNrVhTI16He83vj/fo1aruYGr\n1+tqNBoO70FMgA0X0cvYDjBBxRZ4bm7O77vVajmo577Q3IMqM9LptJlaFxfvUptyuZzH18SmgTBk\nMhmVSqU71rTIq4aTVcfHx12KMHWjhOl2uyoUCo5JA6dOJpP2W0NIy0JbWFhwqYO5YiKRcCNZq9WU\nSCQsDqBUGQ7xkeSaE/gNm16a0lQqpYuLC83NzalQKNitlAdkuCxghx7edVFk39zcaGVlRZ1OR/Pz\n85JkhiENHgYygUDA42/qYh7m4XqdfgC52PDw6n2vB7UzQ9phuifJNShDABowPmiySKBBMsxgp8ag\npVQqmYIJXgu2C8wE8RybW2AvKJPgymQSgt1KMlEfNhlKFSaScDTAxYEGsYOdnJzU/v6+J5X8/DSM\ncJLB1xl0BINB02IhYPEz8JnwEEgyR5mwTH4GRueXl5f2qoNiixSMB3PYRBGN5rAS5n2vB7WYkd5L\nUqlUUr1eNxmcupfGplKp3HEMRV3MqJdjEItZoDMUI1dXV1pcXDQzj10WMjujbB6gYRUy+X/Fb7JC\nms2md2Wmfdvb22o0GpY04X9MzQuMeHx87IWJoSELCV7F6empVlZW/q0dm4eKRc1uC5TGAuckOjw8\nNP7c7/c1Ozvrmh9DRAZOu7u7pnpS+8/PzztCgxOC0yYQCCiXy93r/j+oxQwVkqgzpk2gAF988YVV\nJNTHWMjCRYabwDQMiI0F2Ww2Xe/y9fv7+3fGxzhlBoNBUzkvLy8t12fwMqzJA6GAqD83N+fdn4YT\n2T7Iy9jYmNbX1z1KluRAePLBcd7/+uuvbZEF/DY6Oqpqteoe4c2bN6a3UiqNjIwol8tpYmJCT58+\nteSMh5zT6M2bN45shlkIJRZBL1NIsPiXL19qa2tLvV7PlmX3uR5UzVwqlUzfpB5EECpJ3/72t5VM\nJp1wFI1GzX9eWVmx+SHcCthmHPk4XTLsuLi4UDabdX0IFfL8/FxLS0va39/3eykUCg5oJ0Ma/jFl\nDST9er2uo6MjPX36VF999ZUNBcHJQQzYAaemprS0tGTTcYhOWM7WajXNzc2Z34GKPZlMKpfL2csC\ngxxcP7HYYlIJ+sFGgLi13W7rt37rt1yCDAYDPX782J55w9mI2Dc0m039xm/8hv75P//nSqfTymQy\n2tnZudf9f1CLGQfNy8tL7e7uan193aNWVAy9Xs8y+WKxKElOlBoMBspkMnrz5o1dkRYWFiy5oo5k\nLHx5ealms+malPqXAQniWcoYasWxsTE9f/5cT58+VTAY1P7+vnOxEQUkk0ltb29renpaGxsbGhkZ\n8S6KgTcE/evra2vv4GdgUXBycmKIbGtrS4lEQuFw2AT+WCym3d3dO7yM29tbLS4u6mc/+5lWVlZM\nqJdk1IMyKZlMKhAI6MWLF4YtB4OBSqWSVlZWjOKAr8MrCYfD+slPfqKZmRlbKvAe3vd6UGVGo9Ew\nL4BdUJK9j+Ets4NVq1XX0wTq4IhJWurR0ZHd4rGgpU5sNpt3Xocmbmdnx4lWKDHgLWPyQh429SMl\ny97eno968kmgRkJ4Pz4+9micqIZyuWx6KqbjrVZL/X5fxW/yqiE6MZpGmAo0iRcdJjb4MdNUYzXG\nQwcVFHX1sEUtmwpTyuEkLHB0PhMU5m/evLnX/X9Qi3m4SwfQH5YtkXCEreqPfvQjHR0dKRKJ6O3b\nt5LeWVtls1lFo1Gtr6+bOwFycXR0ZC84OnCQA2AscGK8JiDdo+6QdGf4sry8rFQqZU820BEgLnas\n4Zhi8OlUKuWSgtiFRCLh4c34+LgFvcNMPPw7Tk9PlU6ndXNzo7W1NROFfnkEjv9GJBK54/rZ7/eV\nTqdVKBScIAs/Ay44TR42tpLMHuQU4IS7z/WgFjO0Q2pKfs0ABVgunU5rYWHBNrL8ORBRuVxWr9dT\np9PR9PS0R9O4u+fzeeXz+TuUS+pv6sTb21tTGkOhkGZnZ73j8YCgXAYxQIRKWGUkEjHjjxIoEonY\n4wNvEPgOTOuowcF1IS/hyREKhRSLxXR5eXnHN2Rvb88NLGSphYUFE51I5Uqn0woGgyqVSpqamlKv\n19Pe3p7a7bYDRCuVihc2ppPBYFDz8/Oan5/3OB8l+zAJ6n2vB7WYQSdubm5MbpFkiAmFdL1etzUU\nUb0wwJDic8RWq1Xb20LgOTo6Mk5aKpW82OLxuMWww87zt7e3llPhA4d8C686EABQEOpYBigc05eX\nlzo6OlKr1VKz2bScCuTg4ODAxCGwbyaGkvx/4o7fvn1rzJgUWUb62MyC/tDgMoBiweOfQfnBlJVJ\nI7xq+pCTkxMr3KmnR0ZG9OGHH97r/j+oxYw6hFKBiyYpHo87Xo1SAguqYWokBoUYfQ9LmbLZrCOH\n4/G4d2lQDMoWdmsGG+l02qgBJCdMt+GJ3N7eupRYWVnR6Oiocrmcxa9TU1OamJhQNptVLpdz+A7l\ny9TUlObm5pROpz3lxB9j2AIrFAo5LXV9fV3RaNS0WHR7DJbW1tb8QOLkORzaQ+kGR5zPPxKJ+GRC\nZhaNRpXNZrWwsKBcLmdRLCY4NOTvez0oNAMjwlarpePjY3344Yfa3t62pB0ojV3t8vJSGxsbZrHB\n9nr16pUSiYRevXqlxcVFHR4e6rPPPrNJYC6XszsPwtNIJKK9vT1Fo1Ftb2+b6TY+Pq6DgwNPxpia\nbW5u6oMPPlC1WlWxWLR6Gbejw8NDLx6mfNVqVYlEwkMVSoLz83Pt7+/b3LvZbCqZTOr4+NiZgtI7\n4QDE/1gspnQ6rd3dXbMCZ2dnLQpIp9N69eqVwuGwPTOmpqb085//XB999JEdkmjc+Gw7nY6mpqa0\nt7enTCajL7/80nU3zeBwhszOzo77mFevXt3r/j+oxQwPF4J5KBTS6uqq4vG4VlZWHGqDrzF1KHjr\n7u6uBoOBlpaWlEwm9fjxYy0sLHgYwq6CNVY6nVar1VIul3PjRkQE0cU3NzeOLSYkaHJyUh999JEG\ng4GHEpQwpFHlcjmXMzSGKysrFtKyMyPnxzqMmhUKLMY46AehrUJ/xUBcknd4pqOYiUvvUJ7b21s9\nefLEuj+GH4VCQZ1OR6FQyM3msCYS7nQoFFI0GvUDSv+xtrZmUevGxsZ73/8HVWZgmI0iA9wZZGJy\nctIZf7lcTs+ePdPp6an/TS6XcyYdiopOp6NcLmfhar1e947b6/X05MkT8z+y2azm5ua0sLDgehAD\nlGEjQ7gT/DqVSrk5oxbHIxp6JzxsBLnPnj1TMPguzphgnqWlJTeF7JpLS0tuvhKJhCYmJhzhQBmS\nzWYViUQ0PT2tQCDg7zkzM6NoNGojR0ozAjLhdo+Pj2t+ft4G7vQctVpNIyMj5jED5RUKBU1MTGhu\nbs5wYSqVcsDo+14PajHTZAUCARWLRVM9z87O9Pz5cxv6Yc79xRdfeHeDnthoNDQ2NqZyuazNzU1d\nXl7q5ORE09PTZr0dHx9bxEouyvARyv85HfCWgITPa1OfHx4emhkH6R/vOHZrYuGQXf385z83rl6t\nVvXy5Ut/b4KJcHhqNpuq1+uOOAZmBFEpFosql8u29cJa4OzsTLu7u44SrlarOj4+tpH45uamEaBS\nqaROp+NkXMx0sHmgyTw9PdXx8bFubm5Uq9XU6/X01VdfGWu+z/Vmi5xbAAAgAElEQVSgFjPuPufn\n5/qzP/szjY6O6uDgwDXbq1evbDyCbxyyIfDVRCKhr7/+Wqenp1ZWswhgjjWbTVMaOWa73a62tras\nzGDYIL0zAoetBkWTRXp5eelQH0QEqEe2trYcwdZqtcxXrlQqJgKdn5/r6upK6XTa9gmvX79WtVrV\n/v6+ud2zs7O6urqy1g8PO4ZI5+fnOjk5sWXY5eWltre3LQPb29sztMgIHNV1rVaz+oSHF2gQY5mj\noyMtLCwYbx7OP4lGo2q1Wvrqq6/udf8fVM2Mp0S329Vf+2t/TTc3N1pdXVUymbTwM51OK5vNuqwA\nm4Vi2e/39cknnyiXy5lY/1f+yl+R9M7+i/Ew/sZAcLFYTI8ePXLJwjDl7OxMn332mdrttknpg8FA\nT5488ZELNRQIL5FI3DHehnXGQGQwGCiVSpmFNkzFpJxKp9OeFHa7XZ2cnFjCRN4gCMfq6qrVHsvL\nyzau+e53v6vJyUlls1nnhwN3UpsD4/HgxmIxW56xIaTTaT+olHqS7A6VyWQUjUb1wx/+8FeyKS6i\nG2i0kCZVq1XVajWb/cEfGB0dVT6ft1VrLBZzHASKCZw48dGIx+M2Gm+32zZMCYVCHnsnEgl7uzF+\nHuYJgy9j78VuhhcGBi0saKyvksmkjo6OfByfnp7aVkt6xzvhCEcihqPTo0ePrG1sNBoeyRNkn06n\ntbi4aNYh6hTUO8COGNnABMT1iIcJByOMXqLRqEZGRlxyQGcl/HN5eVmRSMQeG/e5HtTOzA41MjKi\ng4MD+1kMa9ngAsTjcSeHRiIRzc3NmR4J3ZIanIFLIBAwDMdNGfaH6PV6HlpAA81kMqpWqx7jhkIh\n0zsxUcRNCLX08fGxJDk6DSiQIxlYEP8O6Z3NLjxl+A/QW4H2GGAkk0lVq1X1+33zVygjGLTADqxU\nKrYWuL29dckFFZQdGcadJH8O4XDYbkVwvYf1hpRK8GBAVd73elA7M4MPjPkwKSF+YGtry+6dmKnU\najW7WfKhV6tVx5uhhqBm5TUpBejGa7WaoT+kVTwMmLZIshigXC67QWNixn94KEMc6na7Oj091cbG\nhrHlVqulcrls1hqqDlhphPocHh5qb29Pt7e3Ojg4UKfT0dHRkUub6+tr1+ULCwuuo29vb23OyKST\nGh35GA/y7e2tzXBarZabOd47dAL43GDbp6enOjk58evcN6H1Qe3MkUjE5BYmaOl0WpFIxFkky8vL\nCoVCymQympmZ0T/7Z//MdrFAXN1uV/F4XPPz86ZPXl5e2hL38ePHDrZZWFhwlARY8/z8vKeINzc3\n9rgbHx+30yg70/T0tB49euTuH4LU4uKiY4lpULPZrNXTa2trNm6EaA9feGVlRaFQSIVCQWNjYy49\nstmswuGwCoXCHQiNYQdQH43tt7/9baXTaY+hCT2anp5WrVbT4uKid/JMJmMLsqurK+/8YMsgOXz/\ndrutxcVFvXz5Uo8fP5ake8dAPKidGf0eFyaFsNfW1tZULBZ1eXmper2ufr+vx48fO42KHWTY4xnC\nUCqV8g7/5ZdfWr1cLBatokAYgLcdWC0NHO8Ft3m8JqhhIfUMBgP7w11fX6tQKNh7mjp6a2tL5XLZ\nqAoPE0rnfD7vEwIbLHZ73O0xbxl+uCYnJ83rIBGA6R6CX8br8DcmJiZUr9edb0Itnclk/KDBz0D1\nDkc6l8vp+vra2dz3uR7UYoYQE41GTU4ni6Ner2tra8seD0jucTN6/fq11SdgsGSDfP3115bNM4lj\nocDvoFEkx3pkZMTaPpo+rArIy2PnpmY/Pj72Qs/n8/bG2N/fN5WUU6PT6SiTyVj9AhIivSsdSqWS\n2XTDVE6YhJRfk5OTOjo68klCs8tCRYMIFxufEMwVpV/0KsCgDITQVHY6HXU6HaMbpFIRiwG0R7nx\nvteDKjMgq+DbQJcNUiHJtSq7GRo9iEQ0gWj6qP/wRBv2bwP2YpLGwqRposnDt7jVat2hbCLkRCUO\nFRIvj3a7rWw2aztdGjHizIZ9pQn8wdeDxpDdEM4yu2a9Xrf9AaYvuC7xmWElgAfd0dGRxQXs5nwO\nqVTK2SUkVfF3nJYgIQyFyMvGz46I5Pe9HtTOjL8DKmwGHbgKUdtSa+I/zA4JjIYkfnT03bM+DPfF\nYjFDa8M7D7HAQE4ou6VfxDPE43Ef4SAVktwETk5OeudCns+uNzo6qkqlYuJQIBBwQxUOhy3jAn0B\nmqTxg8BEaQGycHFxYUISuylWDZw05+fnajabLr1wSqVR5AEafjCHjRVRyKPG4TNBcAukivPS+14P\najEPW8HSsLVaLY2NjdlDeHiHDoVCRjbYibChQqFC6lS1WvXRyhSPwJ2zszObvtze3nqU3O/3TSBi\nhI6ae3JyUqVSydxg5E/sbJubmybZB4NBR0O0Wi37Y8AVYRd+8+aNjo+Pjaogeo3FYo5sYFemUW40\nGuZkQHyiyUSXiHoaM/ZoNKpGo+ExOzg9kCeWZqAwlDfHx8dGT4YTsEBJMpnMve7/g1rMOBChZxtW\nOtze3lr9wI2U5OmWJDPeyPTAulZ6J+GnURkMBvYjnpqaMg68v7+vqakplxXVatU1eD6f9xEOJyOX\ny9kSgBAfJFM/+tGPvHujSwQdGB8fVzweN7EpHo8bffn2t79tHw+ywyORiHkbOBm1222dnp5accKw\nBGf8WCzmhjCXyymXy7khjUQiWlhY0OjoqG0dGDRR2tHwYRXM0ArHqPX1de3v79vPBAHCfa4HVTNf\nXFxoZmbGtS81LDZTn3zyic7PzzU2Nqa5uTmdnJwok8mYq0sjx/E/7J8xMjJiKRZH+KNHjzykgPnF\nTcRY8fb21mYneEpwOhCxEAwGlU6nTXIC2sKMkRAg2HZzc3OWKeFGNDIy4qRTalS8Nfr9vubn510m\nZDIZoweEaQJXnpyc2OIM32gQD+A58lpWV1c9jSR2jQYQZuHc3JwhS5z+8bRbXl5WPp/XxcWFy777\nXA9qZ+b4J5MOIWYsFjMzLh6P+6aOjIxYWZHJZFSr1TQ1NaXvf//7bhDZvSYnJ3VxceFSA8ssdnB4\nIZIc0l6r1WwEg6M9pcvs7KxqtZoajYZVypCGbm5unI+NF0ggELCDEIR2bHfhITMsgrjPxVSSBxw+\nBCcLDR9oDVNGeMoIejnhOJmIP+ZzB/HhgaLeZ3hECUbWYbfb1Zs3b4xr/yo6behClsRiBUKi7qS+\nQ7dHg3Vzc6ODgwMfc3/4h3/o6Vs6nb7jr4FWTpL1gpQUBwcHSiQSxrORUwEXwiG+vr5WuVxWLpez\nUeHc3JwpoMFgUAsLC3Ye2tzcVL1eN3S1urqqvb09n0SMg+Fw83PTA8zPzyuZTKrX63l48/r1ay88\nIosnJia0s7OjUqlk1Qk2teDltVrNBKphxAJbA1TjX3/9tYlc+PrBz8b+oNfraX5+3o1qtVq91/1/\nUIu53+8rk8nYlHA4nFGScU7MSIhE44hjEPLhhx+a9AJsB1yHmSHHMK6fMzMzSqVSOjw8dK2MTInd\niJIlEAhYAApKgkcH418WMuoQUBR2RkmGzXgAGBKxAPlMQAwoc66urjQ3N2cWW7/fNy8EVcpwqBEN\nGooWampMbVC2876ur6+VTCZtMHl+fm6yfr/f1+TkpObm5swN4QFH3vW+14OqmcfGxrS9va1ut6v1\n9XW1222LO/lw0+m0+RMTExPK5/NKp9M6OjrS6uqqaY1Pnz7VH/7hH7q+pWm8urrS0tKSDVlSqZQb\nRtJJ0+m0yuWy4yQWFxdNsfxlb4zBYGA0g51/cXFR8Xhc7XZbpVJJS0tLarVapo/u7++rUCi43oQA\nBewVCATuGH3jj4zdQSwWs3i11+vp29/+ti1siTzr9/taXV3VYDBwJgxGjuQR0hwTsoMpJWaR+EPj\nAYi6O5lMqt1ua35+3v7Ok5OTtvt63+tBLWacgjqdjv74j/9YH374oY1UmKKxQ62srOiLL76wb0M+\nn/ei3Nzc9OBhY2PDdTblwsbGhlKplN68eePdV5KxamRS1KTPnz/3AiADGyPFm5sbvXnzRoVC4U4Q\n/YsXL5xR0u/3nfsRi8XU6XRcH8M9xpUJke7c3JztDEqlkr7//e/r5OTEtbokl1kvXrywcQxj+Xg8\nrpcvX2p2dlbtdlt7e3v2jF5dXfVUMJFI3AkDBREJBAJKpVKqVqu2FeO0qlarmpmZ0cbGhnf9Z8+e\n6fnz5/e6/w9qMRcKBX9wy8vLVjUAh+FjAaUTdfT09LQHJ9Sr+XxeZ2dnWlxc9DGIrSuICYaJMOlQ\nZGOezQQQOf38/LxVzVAiB4OB1tbWPGRh6LC+vm63ULBnFCEYM/LAcOJQk1L6HB0dKRQKaW1tzQYu\nfAYMhvr9vpaWliTJiAjvIZVK2QckkUjo5OTEQlVKFghXPOwY1GD7tb+/r6WlJX8/kA5Mxo+Pjx1G\n+qMf/ehX5Hyuw8NDCzorlcodUxKgNaiRHIO/vMNJcnqT9E5XuLOz446dhcCxj29dv983T4JjFWND\neBPb29tqNpvmOMBt6HQ6LitCoZDq9br29/ctYRo2UgECxL8ZK9jz83NVq1W7McGVDgQCOjk5sWSJ\nKDbw55ubGyMdGExSu7bbbR0dHalYLOrg4MCIR6PRMC2AQM3h3MHb21v//4MPPrD0CtnY5eWl3r59\n69INMcHu7u697v+DWsyMR5m84QgEtMQOwoeeSCRUrVZtvI3hNzAeOCuqk1/2Nr65uTHri6HMsPsm\ni5YGk4UNG43mEzYauYHAhpisVKtV78qQ5nG5Z8qHhQJ1PQuEKGJOCppESaZk0pgyCkeMS0wyWS1o\n+ygrMDPHngBMGvRIksM8edgZxlByZDIZw5oHBwf3uv8PajGvrq6qXq+7XKDGhQ3X6XSMQ0vvatzF\nxUWl02nHeJHElMvlPEzI5/NOfo3H4zZNYYfLZDJ2KSoUCmo2mx6CAH0tLS356zBNhMMAzkt8wuzs\nrDKZjOMp4GywqHZ3d82RxkgRhyUsDdj5QXDgU1AOTExMWGXNZ4VHH+VONBpVIpFQLBa7Y8GwuLio\nTCZj9t34+LjLBsxlJNmHjocTQcDk5KS51LiXBgIBlzvvez2omnl3d9fH3fn5ufb29ky3pAbc39/3\nbtPtdo0NE2HQbret2aNmBXVgB4rFYrYy2NvbM/m/Vqvp9evXvpnpdNrQ14sXL2xSA77MtI2pZKvV\nUiqVsgni5eWlR+E0c1iQHR4euieg9gyHwx5Tw1tGvEpNzVTy+PhY6XTaGSmUQiAu4NK8FwI9JyYm\nrH2Eu4EFA+GeTFKhsqIXpDSbnJz0hJNBCZzw+1wPamcGhqNhWVpa8s41Njamer1ujgFH/szMjNLp\ntK25njx54ro7m81qeXnZdlWIUlm8iURC3/3ud40m3N7e6tGjR3ry5ImpoSwERr/sZrVaTY8ePdLk\n5KRSqZSWl5f15MkTTU5Oanp6Wqurq8rn81Z1EP1weXmpubk5188EZgIrzs3NuWxZXFzU5OSkgzuH\nU5442ldXV72rT09Pm3jEzwv3BKW79Isdt1qt2jASE5tkMmlbBfoLSplsNqu1tTVb7cIrhxY7PBN4\nn+tB7czNZtO7BbKeaDRqwxG692AwqEAgYG4E4D66t2HqJey6ra0t831xGu10Otrb25Mk7+KlUskN\nEWP1P/mTP7FUiRMhFoupWq2a2IRjJvzjvb09zczMqF6vK51OG47LZrPa2dnxoKVcLnsUD/H/5ubG\nSm44y5VKxZg0LkTdbte6O8j6MzMzprfigAoCwpj77du3Ojs707Nnz3R9fe3Phh0eI8jhGOZ4PG4y\nFqPysbExtdttnZ2dmXx1n+tBLWb4s+Pj43r27JnGx8ftS7G4uGhTP3Yl6suZmRl39clk0se99C48\n5/Xr15qdndX09LRGR0ddGnAShMNhZTIZ7e3t2RKLB6bdbnswgx6P4QEnxMLCgs1gcMn/4Q9/qO3t\nbT+c2GQxoSuVSkqn0/Z6ZtKILo8dk5+B8HXEslhvTU5OOrASg3ASAjKZjAqFgsOJarWaUqmUc1cu\nLi40Ozvr9yy98xbBfw+vEkk+qRYXF525CPID7fRXCa1DF2Pdbrerr7/+WsFg0C6UlUpFh4eHOjw8\n1Pb2tq6urlQul81VZiJ3cHBg0k+xWNTp6amurq684EBI8BVmZz05OTGBiCkd/GluEgw1/C2w/Nre\n3la/39fTp0+Nxe7s7NihHnJQsVhUvV5Xs9m0OppBTSAQ0OLiog4ODryA6vW6Tk9PtbW15UGGJDsN\nYbfVaDSc2wJXhZobH+dhx9F2u+3FSUIANNZGo2HUhO/faDTUbrfvOJyCclxdXRntuG/a1INazBi+\ndDodffbZZ7q6urLJCP/P5/MqFAoaHR3VysqKj2IooaFQSOvr60omk5qZmfHflctlp5hisBKLxVQu\nl410wMmlDDk+PtbU1JSNZiS5Ycpmsx7EzMzM3IkNptEjjAcxKcR3VN2SPCYeDAY6PT1VJpNx44m/\nRTabtf4RVQzSL3jR0WhU6XTaeeH8HdBkrVYzOR81tiSLGOCRsODBkDn52PUlGTFBG0lZ8ivW3NB1\ndnbmm4F3MtBQvV5XJpNRt9u1l1qn01GhUPAuglfa/8Pem8W4mqb3ff+vdq7FnawiWfvZ+3TPTPcs\nPZIVQbDsXDibA8QOksALYASyIyMXUSLpOjGsIIiQQFGgwIHgC8NyvMSJBRuxJDua0YxmJtPdc06f\npU7tVdyXIllkVbFIFvnlos7vaZY8stqn0NKoMB/QmDlbcfne732f5//8F4YfDA3gZ9Tr9Wv+Fycn\nJ3aDLi4ujCUG8uHz+XRycmJ/j+iDUChkWK7X6zWVSzKZVLfbNZ4EF2NxtHIsDLB03juEJthxDI3g\nI1OToh6BXcdnA3kBEep0OqbS5kFFZAveLslw9PHJJgOZ8SYYk5jRaKRGo2GRbGR0jyvr3+S6VYuZ\nZocvfLwOnJ6eVqFQUK/XUzKZtJ0DqIuufzgcqlwum98FmXh4x4HFMjjhxjO6ZljA+JZhBna2sNtg\nm0EjdRzHms+TkxOTYU1PTxtnpNvtmqMQMBZ4LU3VeA4KC4oHFJI+iAbMwG63q1gsZsoR2IAgEjAR\nWbRgz0xFWYy9Xk/BYNCQIWIiYAbyHYIwIezlYYco9abXrVrM3KS5uTnt7OxYfVYulw11IHdvbm5O\nh4eHevXqlVqtlo1Sy+WyKpWKOp2OXr58qVKppP39fSP8MMqWPnFOAtuFuTYYDNRsNs2lf2try3Zr\noK9ut2t1da1WM+U2D+Dh4aEajYbV0/ClIbWPuxSRa/Ls2TPt7OzYz2MgAQoiyVz6qXtxYqrX6yoU\nCte85qrVqgqFgl69eqXBYKCjoyOdn59re3tbH3zwgT1U5XLZhK0Q7fnewc9xNCoUCup2u2o2mybB\ngvOChdmbXrcKzYAVNjs7a74T4LH4zY0f7cQmjBu/rK2tWWNHLcmYHKUFU7l0Oq1oNKp6vW6umODQ\nTNimp6ctkmw0GlmtSmorUB96ORrRQCBgp8rc3Jza7bYeP34sScavjkQitosi58JR6PLyUvfv3zf+\nMPV3KBQyVfX8/LxWV1cNIvT5fKrX68pms5Kkx48fG1TH6FqSiRNwkEIQwNic/G3yFwlCmp2dVTab\nNR0iOze5KD+MGx674CVAcqFLhqhPpw3uymJhyIARIHnQMNTgYbCAqtWqDTDq9bp6vZ6psTHfxlIA\n+T9+ERDlu92uyuWyuc1jik7IPELRcd5xrVaT3+83425qbcxbwIFHo5F5YfAZxk3EsQgjnYqdejAY\nWN0K0X44HBr5CKuu+fl5223JIWRDQFVCI4wxD7Ck3++3iWy/3zfvulAodGNo7lYt5mg0qkgkokKh\nYOLSYDBoqAO79cXFhSWyOo5jdV6/31c6nbbMkng8bhgtJB5MEweDgebm5rS4uGgkdOpwGqZSqaR7\n9+7ZZAs9IdwI8vTG6aSSzLd5MBgY3XR9fd0kSeOpTjSO8D1odpmEjjv+czrxsyHEwxqkIUQIzPSO\nXPHZ2Vk7RR4/fmykpHg8rkqlorW1NaMPJBIJC4zHcyOTyVgjiusSiVSoT25y3aqaeTgcWpAMPhXj\nTu6O46hWqxkP4ejoSKenp2q323rw4IFc19Xu7q6VFb1ez3YTr9dreG6hULAaGuspWGWDwUB7e3u2\n29PQwf2l2UkkEub8Q/oVu9Q4rRQJPyHrkoxKiqAUfwpqZOwQ8K9AroT5DdNAtJDlctkoo3jZwbsm\nExxDGOwWwPMhNL399tv2OXH+pxGn9EKWdnR0ZL6AYPS8xk2uW7WYoXpClSS4Em9iVMnoz7LZrJUe\n3/72t826ikRWnDeRYlH/xeNx88AA2oJcdHZ2ZrIq13XNfAV30GAwqOFwqEKhYF7PxPQiIAU9YMJG\n3ggS/3A4bAgMTReav06no5WVFWPxjdfpeEoD68H8Y7oJlEZp1mg0bFQ+MzOjXC5nKMrx8bEkmSh2\nb2/P/iwYDNqmgvcefUa5XLYyJRaL6ezszPqDu3fv3uj+/5EsZsdxQo7j/APHcV46jvPCcZwvO44T\ncRznNxzH2XIc5587jhMa+/s/5zjOtuM4m47j/Knf7+dOT08rEolci0qAAE8dV6lULKidkJzz83Pz\nnjg7OzM+QrPZNOcecFdJ5itMJAR5KaSOttttOY6jeDxuDc/ExITtiDSmOPrAj8hkMnJd19yLqO0Z\nO1Mzw2mgnMFii52Qh+/Vq1fW2DJAcV1XqVRKk5OTNvk8OjpSu902FyIU1bgucbpxwd3gIfF6vTbh\nG41Garfb9v+Hw6Hy+byazaZarZbm5uZ0fn5uU85MJmMWDs+fP7/Ruvqj2pn/J0n/1HXdB5LelrQp\n6Wcl/Ybruncl/dbrX8txnIeS/pykh5L+bUm/7DjO933fiEYxGp+dnbXpGR04+DBTKhzoKTNojODc\nwqzDgwPeQyAQUCKRMGNE+MVgtfPz8xYdxrROktXmNEaSzK4AxQf4Nzki4zHANHyu6xqxn2YTDNjv\n9ysQCBjagUKk3+9b2tXc3JzV79Fo1LJO+FmUCvy54zhmAIN4F4QHtTbNsuM418LqU6nUNTNGPpPH\n4zEagN/vv7Gl7R96A+g4zrykP+G67l+QJNd1LyWdOI7z70r6t17/tb8t6f/V1YL+9yT9Xdd1B5IO\nHMfZkfQlSd/6vT8b1hYkcelKkoRe7uzsTKFQyGAhqJ+INuF2EAgJNZGpHLIpNIXo++AZcCLQFBKA\nOe4bDbTn8/mMAplMJm0Xm5iYsOEKY21qZfjQjH89Ho+Gw6H5QO/u7hqJfnZ21oYuLEpgPhpBHEZn\nZmasVobMBNKDD914rHAikdDR0ZGFEUlXo+9+v28qGNxYx08EPid8ZxpX8GZEE296/VGgGauSao7j\n/KqkdyR9IOm/lJR0XZcOoCIJF71FXV+4eUnf12IdIsu4USCwFDgpjRZ0THI6KDP44hkTh8NhVSoV\nvffee9rd3bVGyXVdO2oZomATAC7Lw0GpI8ketlwup4cPHxoSEg6HbXdlR8c6Fs+K09NTexBprFzX\nValUUq/X0+Liou3CTNbGbWcZ6AAjnp6e6vj42BTVGxsbOj4+VqPR0Be+8AWre0FoXr16ZQ0msROS\nrHbH5R/oMJPJWMPL0ARrAdydaFbpL25y/VGUGVOSviDpl13X/YKkM70uKbjcq2/J/df8jO/7Z1//\n+tf19OlT/c7v/I7K5bKx3eAFAC2NRiNFIhGr4Uajke7evWs1M+mq0lWA5dramh3zS0tLxkNgN0Wa\nv7S0ZE6kHPGUHkz/eGiWl5etdsb9k+YVhTOYLUJc6JfoB7GKzWQytthhrLE7k3GCpAo3VPjMTB3x\nuwiFQlZ2YCZD08hnmZ2dVSaTMd4HJ1W73TYc/f79+8aPdhzHyPgMdVKplPFfXrx4oWfPnv2xNBvP\nS8q7rvv/vf71P5D0c5LKjuOkXNctO46zIInZZkFSduzfZ17/3r9yvf/++woGg9rf39fjx4+Vz+dN\nlf1n/syf0Xe/+12l02kLbL97966Oj4+VSCSMHonuLR6Pa3Jy0tyPGE9DwifUZ3zI4vP5jFyPsoUA\nn36/ry996UsWSIn75vT0tBKJhIbDob785S9rNBppb2/POA/pdForKyv6xje+YUYrHo/HzBghwUME\ngqyUSCRUqVS0vr5u43z42DRulDmZTEa5XM4WNLXvvXv37Ncw/BAQSJ9MAgmUf/fdd61hHBcwzM/P\nq1Ao6K233lKhUDDbsoWFBSUSCX3hC1/QcDhUrVbTr/7qr77xwvpD35ld1y1LyjmOAw7zJyU9l/RP\nJP2F17/3FyT949f///+W9Ocdx5lxHGdV0h1J3/n9fr7f79edO3d0eHhoFrGdTkff+ta3bOdFqey6\nrnGDd3Z2jOlGbIQkiy7GT2J6elrJZNI87KhRUX7s7u4aW02SjbQDgYCOjo4sCapWq5kbfiAQUCqV\n0pMnT8xCYHFxUdFoVGdnZ/rggw/k8/ns10RGcMyDHCCQxbETE5ZkMmkuoOz40pWYYX5+XgcHBza2\nH1fk5PN5q9Nx65d0zXCcaWUwGDRUZnZ2Vs1m81oWOK5L0F0nJydVLpetzKKxvcn1R4Vm/LSkv+M4\nzhNdoRn/naS/KeknHcfZkvQTr38t13VfSPo/JL2Q9M8k/VWXu/h7LqRI2FrhDo+vMPBQo9FQo9HQ\n2dmZNYGUG6gqkFOBeLA4YYjRCKJ3k65KksXFRfl8Pu3s7NhkkYeAcoMhCOYxDEhw9gyHwxbtwMBn\n3INuvAzC9w6E5fT0VI1GwxYMI2YWMEkB29vb14ZLlBUw/4gD5iSC+TaeMYhwgLoetQt4P98ffQLf\nseu62traMniS/oWH5U2vP5Jxtuu6TyR98fv80Z/8ff7+35D0N/6gn7u/v28+EjRBzWZTmUzG/Ihp\ndlgkH374od59913DodvttprNpu1IhUJBHo9H+/v7isViRpf9F/kAACAASURBVNLhz4DUQAoobfCP\nwOYKwg4wHrgxLp6MoPGdK5fLikajZiWLOsXv95sGEDtckJpqtWqvg3Ib1hp4NGT6YDCok5MTVSoV\nTUxM2E6PpAs9Yb/fV6FQULvd1v379+0hazQaeuutt8zRkxocJAYNIUIG/pzPBhGJh9l13Ruz5pzf\nZ5P7Y3c5juP+1E/9lHEvBoOBZWQTlwDXgBqQnZyJGlwHkpok2S5KXvbOzo5FKwCdkaFHA4ZxeaFQ\nUCqVMgMURtIYhKPLI9RSkqEgpMBCHOp0Okb+l64SWe/fv69CoWA539FoVK1WyzIF3dchl61Wy0wd\nJyYmzKAGywRilsHoCdyp1+smppWuBk/j/Gswe4j9Z2dnZopDucL0r9lsWrTb5OSkTk5OlEgklMvl\nlEgkND09rU6no1/6pV+S67rOm6yBW0U0kqREImHxB6SNxmIxM/wG/mK3LhaLZpoCL5luv1QqGeGf\n3ZFFxoAD0j0LgeOUUTDaOSxxwcCfPXumjY0N40+ABkSjUZs8MoZnEQK10RxiNH58fKxKpWLlDGN3\n8vcKhYLV2T6fT5KszJmamtLBwYHFSBCjkUgklM/nDc0YLyvGVTLjkCH6SPyaeah5IDmZKLXw/CCk\nfnt7+0b3/lZxM46Pjw0tQLlALciuMC56JZnK4/GoWq1aKA1JpixGlBydTsdEpBCCQD2QNkHex64L\notH4EU+cAqNvuAnjJKBSqWTUU6it5XJZZ2dnajab8nq91zSJlBeSjOLJg5tMJnV0dGTfB4McShEM\naeLxuJ1OExMTisViZuCCUyrNM+XD5OSkTUr5njAWx2EVSsC4IABeBu6lYPM3uW7VzgxhptFomJAU\n90t2HaynIpGIyuWyQqGQ6edCoZA6nY6Wl5dVr9fN1w3CfDAY1Oc+9znt7++bnhAbXerTSCRi3T0L\nm3EwgxYsajn6x03ACe3JZrNqNpsKhULGkSAUiBEzyIvjOEbFJA9wfn7eCEi7u7s2+XzvvfdULBZV\nKBTshIrFYsaRwO2JYB7q52QyqcnJSS0vL2t5ednMJNPptObm5nRwcKCJiQkzsnnx4oUl0r7//vva\n3NzUxcWFotGoTQD5jJCn/vSf/tP6xje+8cb3/1YtZjr2QCCgjz/+WFNTU8rlcgoEAmbvSr7H0tKS\nGZY0m00jj09MTOg3f/M3zawchteDBw+uWbiSUbK0tKRqtWrSpuXlZUMF7t+/b5ZeOArhWt9sNk1j\nt7u7a4pxKKb9ft+wYaiseH34/X7t7+9rYWHB5P3tdtuGK1BJMX+UPrFheP78uS4uLoyuiaMnwtJO\np2N9xatXr8yGd3xHHw6H2t3dNbencUFAsViUx+NRr9fT0tKSarWavvGNb9g0E5YdBpPYdw2HQ/3O\n7/zOje7/rSozUP0eHx8btivJ1MKFQsEcjvCE2NzcNLEl4lAWO+JOasTxcJ5kMqmlpSVFIhHL4kin\n09dU1B9++KGRa9iRp6enTbNHPR4Ohw2VYPH1ej1ls1lNTEyY6z9OoShX8NigfAGOoy5nYpjL5Yy3\nzMO7vLyslZUVyy6kcWU3x8ARwQInHPxrn89nJ1ClUrFyCG4LiA+e0aBDEI8WFxeVSqUsExFx8E2u\nW7WYwSnZMRk+zMzMKJvNmko6FosZqwyXHjgFo9FIb731lo6Pj7W0tKRut6vHjx+bKhomWKlUUrlc\n1t7enrHCkNofHx9b8wX1E8dRFtv9+/dtTAwPQ5Jl6VFrM21stVrGqCuVSkYGgi8cDoctg5rm98mT\nJ+p2uzbw8fl85vMB6nF6emqEIyaIYMOgNYT9oErHYyObzaper2txcdE4HECGoBz5fN7gv5WVFTWb\nTRUKBWMKYugoychOb3z/b7Z8frCuWq1mjRhlxuHhoYbDoV69emXHOAOUXq9nNxKzbho3+L0XFxcW\n84tFFWUJNlOSTJpPAwdrDE+7mZkZPXv2zJAR1CqSzD8Ck/DLy6tQ+bOzM5uSgRNTElCPQ6Fk0AG2\nizkM6a0Er1MeNZtNy8YulUr2GXFwmpiYMDU2vwc6hCIbdAXsGUI/f7fX6ykSiZjC5OXLl+YuhdKF\nB50T9SbXraqZE4mETdXu3LmjYDCotbU1U4lwzDFChhoZCoVMgXJ+fq6lpSVrwkqlkpUE4/IpWG6x\nWEx7e3vmNgRvAlx1enraGqnFxUVLJKVkuLy8tAAcGsB8Pq8vf/nLJiWCggmCwQ7LLglBieEEdgU4\ngsIBSafTpslDezhOJ11cXLQsRDzwOIlIfcUzgzIDvvjS0pI1eHzXBHIS8wBCgjMSpye/f9Ohya3a\nmfGIqFar8vl8FlDOl39yciJJNr69vLzU9773PSPqP336VNVq1QYse3t7SiQSNnKVZAQaRrR7e3u2\nwPF1brfbKpfLyufzxvnlJJCu4hVAF6CtssjPzs5MQU2ADdxp/DxyuZypzDFZYZzMe52enlaxWDQM\nOp/P25gfqT/OozwsvF/G9+PKamwATk5OrOQBm8cnhNIBXd9wODSYFJErOkhOsl6vd213v8l1qyaA\nv/iLv2i1LTRDMN1SqXStpvN6vfJ4PKrVagqFQkZER1SZzWa1ublprvTUxXTePp9Pu7u7unfvng4O\nDuTz+YwzHIlETHAK3r24uGgZJSAUeEXTXPLzedAQxKL65oHE1406HU42JwElByLWer1u3nDpdNrk\nSclkUtVq1RYsxKTZ2Vlr+miiiUKGXI8Ui1IGtYjX67UcGU6bbDZrPGl4IgxbyB+cn5/X4eGhfu3X\nfu2HE0Dpyq2HQcLBwYE8Ho8KhYKZDm5vb5tNAFG+jK57vZ458DD5oubb3983b2acORmXE8eGVdW4\n9wMu9ASh49V2cnKiZrNpGDbZJRcXF0Zc4lhmbE5tSUmCkBXBK3g3fwavo9fraX9/3xrPaDRqC5fp\npCQzYwGaQ51OE8tirdfrCoVC5uCJvS9WBJwOPODwPhBFYCrOqPv58+dm27W8vHyj+3+rFnO/37dF\ngocx2je0euxseNJhtCLJaljsqbhJ8I1ZeDhuwl5DvoRChRvPlAwMFl4FuzxqcASio9FIhULBdIgs\nNuxomdjhSgQXA/MWIDZgOvJMHj58aJrBvb09SdLR0ZGSyaRhzYgVQGSIwcDsJhwOX3Mpvbi4sJwY\nEJmzszNr/i4vL80sHWV5LBazJvvly5cGb3LyYKH2ptetqpm73a6WlpasAfF4PEaux3gE21tEm0QZ\njJsFokaGCFQsFo2CCU4NnAYDT5Lxdlm4kNfhNkgyPwseFOkTWinowGg0Mv4FMN3l5VUcMlg0Pso8\nkFBbYaDVajXT1T179syGNkicCCOirsW9E485ooY7nY45GgEbjqu4R6ORNjc3jSJAGq4kO8WA3mq1\nmj34Ho/HOCzAksjP3vS6VYt5ZWXFDLPBMon8PTs7M34wg4FxC9bLy0tTi9DggOHiFgRrbNz9R5I1\nYJiwcJNoinK5nHw+nz0Q9XpdjUbDbizN38LCgtFHJyYm7H3AQIMjQWwCTDX4zAsLC5Jku3U+nzeI\nsFKp6OTkxEhU2CEA62G2yAKfnZ1VpVLR3NycEomEDg4O1Ov1VKvVtLa2ZiP6fr+vZDKpWq1mFrc0\ngZyE9Xpd9XrdNhYyB/EWwc/jpov5VpUZmLycn5/r/fffl8/n0/Lyssnoo9Go2WuRQ51MJs0wcGLi\nKmotHo9fE43SkYNaxGIxnZ6e2uKZmZkxmTwcDpJfB4OBRQmHw2FVq1WlUin7M4wVYZzNzMyoXq9b\niik163jshMfj0e7uriQpHo+bcWOpVDJbW04WdnvyrQnXYeKHfxyjcHjGo9FIqVTKyjCGJpRf1Pce\nj8caUSwdMJ5h9w2Hw4ZpI92KRCLK5XKmeD8/PzdF/Ztet2pnHo1GNgDAL5k8O6Z93Gik+Pl8Xr1e\nT48ePTILXOT5uLljGUBJAb0RrgZH7sTEhGWGIAtikXD802SxUCcnJ806llSsSCSii4sLe4jINcEq\ni9AeiE6YLbK4MAKv1+sW0QBNs9VqmZdevV7X9PS02QNgqcWonBRb2Hvsqixk6uSJiQmbrKLmgbFH\nrgpNKREax8fH8nq9kq4eSDw8bnLdqsWMDJ/AcrR4tVrNYgw4wmliEomEer2eqtWqstmsDTRQWjSb\nTUtiotyg5Bh3mQcSG+cUh8NhHRwcSJLtmI7jaGlpySZ9UC6DwaDtzKAm0WhUXq9Xx8fHdsowzEHF\njQwKrLpWq9lInVg213X16NEjs571+/2mIG+32+YoSo0MVElDSYZ4s9m0CGVG54FAwBiHPATs9ozf\nGdBQRiBNA6KjYU6nv6+DxKe+btViZlekloVvixQIEji46mAwsHoWbzl8MGZnZ21iiNIEPgYjaUmG\nOw+HQ8OWaf5OT0+NWklYDaw49IaYLuLKiTggk8nYGHlyclKNRsPMwJF1EYaJajoajZpqhh2RyIvd\n3V1VKhW5rqt+v29TOJyfRqOR1e64djabTRvagGM3m03LWSRuzuv1KpfLqdFomHhgcnLSUgcwJefk\nOTk5UTqdNtNHHJtQtLzpdasWM1a2pCnBSwBK63a7Ojg4MKioUCjozp07VpaMRyDQWGFmiFkJTDbS\nS/GhGPcvrtVq1hzB+2C6x8KDSYdqGRy42+3K4/HYuBoGIAMJkAw0jDSd4MU44NdqNTu2MW2k/h4X\nFzAyH4+owMiRUgqWHv+fEoLGGWIVzSuE//Pzc/n9fh0cHJgiB14Jqh5Jpg6v1+s3uv+3ajHjZClJ\nX/3qV008GggE9JWvfEXhcFgbGxsGHf3Ij/yIDRJc11UoFJLP59OdO3cUDof1+c9/XtFo1PKyA4GA\nTQzZ1djVfT6fKbDxgcbhh1Li4cOHdnpgyILPHQMK9HDoBBOJhEGNmBOS9uT3+5XJZDQxMaG1tTVz\nEM1kMlaCLCws2M4eCASMhzE/P28DlHv37ikSiVhGNtL/bDZrTL9kMqlQKKSFhQXzqctkMrq8vNT6\n+rpZLpBUgFCA4RJjc5K2JicntbS0JL/fbxvEvXv3bnT/b9Vi5smemprSkydP1O/39e1vf1u1Wk1f\n//rX1Wq1VCwWjZH25MkT20k3Nze1vb2tqakpvXjxQu12Wx988IEmJyf17Nkzo4OenZ3ZlJEF3mq1\n1G63lcvlVCgULHuPYxqFyc7OjkqlkrHO0MK1220Tqx4cHFjdC3b79OlTC6jf2dnRwsKCNjc3NRp9\nki4FJNloNFStVg0poDZmKMJg4/Dw0DSG+XzeTrMnT55Y2bO/v29KFrL8Njc3rcd4+fKlBRrhI42r\n0ZMnTyRdIT3U8jSEyL9evXplSM3x8bE2NzdvdP9v1WJm9Iv6gpwOEqAkGUke7wuv16u5uTlFIhEl\nk0mrCRlo0Cyii0ulUmo2m2Y9xYLAfmpjY8N2psXFRRugTE1NWXkBGZ9pYrlctp9DID01OM0V3GV2\nMYSlkPOpV/lcLN5+v28KFyy7ms2mTe0YM1cqFftMJycnchzHRAQ8SEwNIWwxhmfow9AIF1Lw9vn5\neftM+Nf1ej1Fo1GdnJxYHARkrje9btVipg6s1+vmfQxFEZ4AQxByAKkDHzx4YM0b6gjw54cPH5rR\nX6/Xs1gFjBlRHqPJOzo6MolWPB43SA8rWjgVmCpi/wWjjPo5lUqZsyaN0+TkpHZ2doybDeFHkpmw\ndLvdaza+eH10u11LmYWWOe5QCjKDTnJ9fd3iLsrlslKplIbDoSlIQDLG7RMQD4AzozpHpYJ/HfU4\naV2Li4tGanrT61YNTVgYUCsdx9H8/Lw1K3BtUTQsLi6aQThaQZosHOXn5uZMv5ZIJLS7u2s7PU0Z\nqmdqZmpRFiA7FaPuyclJ86qD7ww/hIEGqabjkB8BnKhKxnfLy8tL87igJ4AZyOtA5GHRj9vzIlJg\nkWIOiXHO8vKywXfU/XiLzM3NmXqFwQeuUdJVPuN4LiGYfyqVMgHxcDjU2traje7/rdqZganm5+dt\n6kT2M0GPHN00c/l83gYY9XpdpVLJ0I5ut2v13Dh0BfmdLp8d/fT0VOVy2WrdcDis8/Nz40wwZOl2\nuzbuHvdwAxtnOrm3t6dyuWziV5Qf8DtOT08Vi8WMQffy5Ut7T9LVWBu73mazqVwuZycJtlrS1QNU\nKBTsBKnVauYeSkNNn8FpVq/Xbdw9GAz08uVLM1qv1WrGQDw5OTGolO+gVCoZlo76u9Pp6MWLFze6\n/7dqZ85ms+ZLAfk8nU4rkUiYCDUYDNpU66/9tb+mX/iFXzAPOISo3MAvfvGL2tra0uPHj+3mjEYj\nZTIZFYtFOY5jtTCUURYE0BSu+Xja9ft9G6qM80NALiAynZ+fa3Fx0SZ3jKeJKtvY2DDVNAOOt99+\n20j6ExMTSiaT8nq9RtuEuca4GuNy3itjfxzx4WDgQx0Oh/Xq1Svz0FtZWTG+OEbiTAIzmcy17EBU\nOL1ez/4MLv14JMa//Jf/8o3v/63amTudjnkTY+iCGkOSTbTY/f7+3//7Njwpl8uSZBo7n8+n3/3d\n35XX67UdKBQKGdG/3+9fcxsCTsOHA981COnjOzjMNK/Xa7RR+A2UQ1BK5+fnNT8/bxBju922EwNO\nMUqZw8NDG/hQMvHaMzMz9vP4+5xkNIfspOSN06gNh0OFw2HlcjkbsmDZG4/HJclOn0AgYM75NJJw\npw8PD42aSpoV43mcp25y3arFPA7sAxXRyRN7Vq/XrYGjAWLc2u12jVPMTcaSgOOcmwtxqd/vq1ar\nmYkLAxMW5sLCggVMnpycaDgcql6vG4MPqAxuhPRJklO/37dFzWcgP3B/f/8a+y+fzxuSAfrR7/ft\n825ubqrdbluYJycDn7tUKhlVMxgM2tQOR3xckngQEfdyYVhTq9VssQI3sslg5+DxeMxU5uzszKao\nP6SAjl00Y5KME0w9eXFxYTAUhHFJhhOfnp6qUChoaWnJCDxwPbjJeKhxU1GzwAkuFovXvJipsyXZ\nRBBOsqRr1lbBYNDkU5Cazs7O1Gq19PHHH1vpVCwWzROZiLNxx/tEIqHDw0Pt7+8bguH3+3X//n1D\nVC4vL/XRRx+p3W6r1+vp6OjI0mnBnycnJ40mKl31I6FQyEoJTjnG9B6Pxx526eqEw8qr0+mY7ApD\nyd3dXeXzeWvKmbLe5LpVi5nYBUa+uFHCM6hWqwbY+3w+22GweI1EInr69Kny+bxlfbDjjsvnwV5b\nrZaOj4+vmZgztmbBhkIh5fN5i3qQPgms58httVoqlUomuSIsEzEqENjLly/l9/tNUABBH5717Oys\nCXK9Xq92dnZUrVb13e9+1xQhcI6Xl5dt5N/v9413Eo1GrwXCY7dQq9V0cHBg9E94JtgAg5lLnyTR\nAjcC5w0GA21ubqpWqymTyWg0GllOYy6X++HQZPyCF3BxcWG0SZ/PZ2lMsVjMjmF4FkBnCESTyaTV\nvjjpE3wDsR1FMbIgj8djP4Njc25uzvw1IpGIxZaBQnDMY6VLPQ2WjEYuHo/bBA/yEA5NlAjU3Ax3\nUqmUvSev16vV1VVDMkiUBesmBoLoMoZIlCx+v9+EqalUyqRc0WjUeCQ4IQWDwWtiWnD9ubk5eTwe\nG3kjgqXnIBXrj1102md5MV5mLAztEhgJVhaowscffyzpagyOLxrURXamg4MDQxMg9/AfWC8TMcj7\nR0dH8ng8xtRjV6TGjcViarVaJrlnJ4MoNQ4posZgMjk3N6disaiTkxOtrKxYElSr1bJhDdg5dXmh\nUND7779vOzluoUCVCAnGTxhKA04YnJl4LzTJUGl9Pp+2traUSqUM60bjiAL8448/Nm43jEHqZBTc\nN7lu1WLGzIXdmKw/dhGv12uKB6/Xq3fffVetVkupVEonJycKBAK6c+eOJFlIYywWU7FY1MrKis7O\nzozMRKkCRk19S22JEIAwdHLyGo2GWQZMTk4auYldeDgcKpfLaW1tTaVSyVCF+fl5ayYfPXqk7e1t\nLSws2EMDbkys2+TkpNLptLrdrpkyhkIhzc/Pa3Z21rw77t27Z4oQdsZQKGSKG1QyfHfsrNTMkJaY\n4qVSKfV6Pb148UIbGxsqlUomCGaIRdgRuzcKoLW1NT179uyN7/+tKjMcx9GLFy/UarX08uVL2xUx\nKkGDRuYGam74wXjIcQwnk0nDQMeDa3q9nvENKpWKKUCYLDJhG/euYDrJkUpJNDExYdyMUqmki4sL\n3b17V7lcznyXJVlmH9xov9+vi4sLvXz50thpqEowIOz1emYFlkgkJMlcQvHzODg4sHID1yKGLHjv\nlUoltVotbW5uWoMKDRU3JcbzEPTpHegPoAigAD84ODAfQPd1NPT6+vqN7v+t2pld19Xq6qqmpqZ0\nfHxsVlegBtgDXF5e6u7duzatw2qLUoCatFQqSZK58WAqjhPnaDRSOp22KR91KLo4ak90ewwriGAI\nBoM2WPD5fObNkcvlzCim2WxaMiociNnZWcPF79+/b6JXEBwI77xfGjDw93HUJxKJWD43vBHeDxku\nGNjgkMruih0Y5Qw7NjESjuMoHA4bp5nvdzgcKhaLWdlFljbf95tet2pnlmQDEnY+HInI3uPIh7zO\neJcRMpgvjQ6TL+RUDCN4ABgUINSEtwFKMhgMrHOnVod8VK1WrUypVqvmu4aamsULhMZrM1WDozEY\nDJTNZo07cffuXUMtpCsOSTAYvGYrO276uLS0dK1koJSiacOEkcaU75WHA/4HwlfkVzSmNMxwpply\nBgIBQ5GIobjJdasWM7TJV69emZ4MXu/k5KRxG2ZmZmwUzPgZNhwLDiYbqgoom0+fPrVhCqE4z58/\nV6VSUb1eV7FYNA7C8+fPDXaC/zw7O6tCoWDSKLzlKHm2t7c1Nzen9fV1I9VTo+/v7+vly5cql8ua\nmpoyeytJ9nPm5uaMu91sNs0v+uDgwIYcNKTn5+cWK0GzWqvVlMvlzIc6n8/bAsYWAfgTHBoFD8Mg\nfPZ6vZ65e3Y6He3v7xunut1ua3d312YAw+Hwh9Dc+NXtdrW4uKhEIqG9vT1jiyHTka4w3EKhYImm\n0BNpDEOhkCWxBgIBW4RwoHGgpw7ErsDr9SqZTJqk/+zszCISOPK73a6q1ap5w3HUExlMXdnpdFQo\nFIzrAYa8tLRksRCQ93E9hTxEHBsstXFjGxY+WDGG5PwaTH1+fv6aoxHoTTAYtAaTB7bdbst1XYPw\nCMoMhUJGzIItB0zJ+56bm7s2PcVM502vW7WYOdaxiR0MBkokEmaKCHAP9ZEjsdVq2YLD1gv3+NPT\nU6NEQtRBSMoIFlNuKKCtVkvxeNzIPSwGeMncYMoaBKODwUDdbteSnGgiPR6PsetYoJjQEEEsfeIg\nNBgMzHeO3EOSnhjeUBYh6yJmORKJ2HhZkrkiQaxnikmuN1Zo5JJzRSIRbWxs2MgaByWGK3BoGNn/\n0Dfj+1zj9E2spCCzMLSAOM6xSNMEdIZyYnyQwcJjLMuE8fLyUrlczky7yfTAplWS1Y2MiTGcwTJs\nNBqZ6mN8gcPHQKVN6TAcDpXP582yq9lsqlwu2zAG0hAXbMBxYny73bamEcSn0+moXC5f46x0Oh2z\nQHBd1/gu8EwY8ZNmBcEKXgg/C/iN/BWStXq9nsnOwL/f9LpVaAZfGPBbIpEwwlEwGLTdDb4uQlRJ\ntsij0ahyuZyxylKplNlhoaR2XVfhcNgmhjDfRqORiWA//PBDra6uWlOEhVWv11MymbT4CJh1i4uL\nisfjxogjAQBXJRYjNgHEp8F847RJJpP68MMPDb9m941EIjo9PTU7he3tbT169MgQD6BJDMj9fr/i\n8bipdIDpeNA4JYigazQaJmglb/wrX/mKMfYKhYJWVlbs5Op2u4pEIgqHw4buHB0d3ej+36qdGYyz\n2Wwqm81a182oFLfMaDRqZiePHj1SMBhUr9ezXSIcDisejxtRhiMfiT5cYEk2FQT2A79NJpPa2tqS\nJIMD4Q67rmtoADDf0dGR8vm8qajhSFMS8NonJyfmm0wphAMof8apcnx8bEc5C4UyLJVK2WdCKQ4N\ns9PpmIiBrGwml5IMkUEkwGmGb1yz2bSyDt+54XCoQqEg6eqkQB8Zj8fNBgFriDe9btVippZLpVLa\n39+Xx+Mxz7iDg4NrBoHsQjR4iUTCdl9UFoFAQPv7+1YPUlZAhzw8PNSLFy8sUD6dTl9TWaRSKSUS\nCXMSJccEUSsEJEoX13WVyWSUy+UsPJOpYjAY1OPHjxUKhUwlTi4IgxssdlnkeOKxq09PTxtezpSw\n0WiYqSQMQGwUUGnzOoVC4ZrrEpndKNa73a7ZGYCZz8/PW94h7vzjfiIHBwfa3t6+Zoj+ptetWsx0\n5gxKMMkOBoMWUwaJHg7E3t6ewuGwarWaDQSAoRzH0dramnmnnZ+f281qtVpaWlpSLBaT3+9XpVLR\n1taW6QWhW/IeQDgCgYCazaYqlYoWFhYUiURMI7i0tKTd3V1NT09bQtTS0pKazaYk6cmTJxoOh0ql\nUvL7/TYup5nNZrMKBALGGcZ9qdFo6PT0VLVaTUdHR9fQHFAOgjF5SKhpx8fcaAuhfhILhws+BCJC\njjgdYBvOzc3ZePz8/NweOgY5PzSBGbtQLAcCAe3s7Ei6UkDAZa7X6zo+PtarV690fn6u7e1ta0qo\n7RqNhmq1mhHZyScZt7yFoYbxIGNyCDcgAtS4eKnx0OAiBAGqWCxKkgVB4q5Uq9UstAaONcJRvCqm\np6cNBwbNgPMMjoxam9ra6/UaRMhkkQcYxbn0yQCqXq+r1Wppd3fXsHkebumKeovyBRwfZILyi3qd\nsoUafDzGeX9//2b3/0b/+gfsajQaVoNiLgjZxuPxWOhkNBo13wZwXJ/PZ0qOhw8fWpPjuq6Wl5eN\ndPT8+XMjzkB9pDZNp9OmQaR2xm6WJotdaH193bwr0um07d7Hx8c2Wt7Y2DDCEg0rECEq6Uqlovn5\neSWTyWvuSaRo8X1MTExoYWHBYDxJRrx3HEfpdNoek5NwsQAAIABJREFUjFgspm63a9/PaDSykM9U\nKmWm4eOMOtAXhjQzMzMW7zw1NWUiCMdxjB9CU57JZCRJ9+7d07e+9a03vv+3ameu1WoKh8PGe2Ch\nwpUAtoO8TiY2scKhUEihUMiUw9Ink7V0Om0WAOxO7CrjtSi7EKUGIe8Q4ceHL/CeaZxAKrrdrpUI\n+/v79jnW19fN9wJcGPNx3IT4M/IHiS/DCgEvjYmJCQtsh6sBnIlvB7g4nngYO4KcwPlGzQKvgwEJ\n9gcXFxcmskXjOD58wo0VUtWbXrdqMQcCAZ2cnFjeBrUtO0UymbT85/Pzc9OopdNpQwPK5bIODw/t\nJpJGWqvV7FiVZDcHTLper9sNgt4I9Adsh9l3p9O5Zh5OgwnmCy7caDR09+5d833+6KOPjMTjuq4O\nDg5s+NHr9Yzn4bqu4vG4/Tz4HdVq1ep/MgVZ4FBXCQjiIYBQNK6bPD8/V7fbVT6f12AwMHSILEDK\nBzLGyTCMRCJWUvR6PZ2dnVn9X6vVLAXrTa9btZhhniEZAj5jiEJKK/L9Uqmkzc1NG8uy63W7Xfu3\ns7OzJlfCHTQajdpQIZ1OW629u7trpwD0U3ZMpnsQ6eEu4PPGIsI6l9p2OLwKXS8UCgYBomaB7smk\nkkaNupnFmMvlrun2oMSCfBwcHKjdbqvRaFgdj1RKkjkaMUJnjM9IW/qE6M9ixuCcqWGr1TKy1LgL\nP/EUUGBvct2qmhnrWIB/eBPseqlUym4+Zt0/8RM/YclIuBnduXPHXCuLxaLVwpQO1WpV6+vryufz\nOjo6MkgtmUyq0WgYR2RcnoRKA5kS07JIJKLd3V27yfgrs7MfHBzo7t276nQ6+tKXvqQnT57YeDge\nj5siZXJy0nBcxs8LCwuGb8NUwzcDD+lWq2WOSvQJ4M7Ly8v2oFM/VyoVQ1sgaNVqNTv1kKKBtGCn\nAKTIWB+ivyTD3H/yJ39S3/ve9974/t+qnRluBrXqYDCwY5XjFII9HIdyuWwumhB/yA4cjUZaWFiw\nUetwOFQ2mzVN38LCglZXV826Fgx5dXXVcFMWNzo+UJHDw0O72djF0gAuLi7ae00mk6pUKqpUKtrc\n3LT6nbqdYzqRSJjWEV8L2ILUt4hyYdsx3ZucnNTi4qJBbKQJ8MCjm2RDmJ2d1UcffWTTwPn5eesn\n4LKAJTNyH41GCofDtrlAf2X0HgwGb4xm3KrFLMkaM75MmiPgJ0k2qm6320ZkR3EC/5lJFna0cHnR\n9zUaDdul4CJwk/L5vCYmJuyhQG2CL0e5XDbEgdIGsxZU3yAWNIZYEhAVPM65HjcER/FNSQJrDjUK\n3tBwLLBAoPw5Pz+3E47GTZINb8rlsvnFoVpnCgqRiMYaMQJqdt6767qmJOd7q9fr14hKb3LdqsWc\nTCbN7Jtuen193VhoyHSQLiWTSWN8ra6u2tBl3EQcw+7Z2VnNz8/bVC2dTmt1dfWaIWAoFDJuBibi\nuAWFw2H7/bt37xqCEAwGjTAfDAa1urqqxcVFmzbGYjFDKGZnZ7W+vm47siQbAnGSzM7OKplMWvg8\nzR3NJ+UMsOD5+blxQhYWFoxmymteXl7K6/Ua0pDJZDQcDg3dgQGYTqetROE1+PPV1VWl0+lrukoy\nWqSrzWVxcVFvvfXWje7/rVrMp6enOj8/1+HhoWKxmO2mSNyZMEFvhKnGDskOCqtubW3NFCk7OzvG\na56fn7eoBdhpYKdM2MLhsF68eHEt62Q8nw9iE+GTuVzO5E8c1Vjo4jcN8R8/DBJlkfOz88KFoFnk\n/Y67FGHZO86F5iRC5YLcrNvtqt1uGxWVhKxxORenCbj24uKiJiYmdHJyot3dXcOdoXvOzMwYZAgv\nJp/P3+j+36oG0HEc4+S+ePFCjx49MvdKQstZuDi4Z7NZGxZEIhH1ej2jjXY6HcViMVWrVS0vL5uS\nGB4xu56ka3wISWY8TlQvjRjhPpVKxUbflUpF8XjcGHwHr3OnKY8QnP5eNTS9AYstmUzKcRytrq5K\nkkmpdnZ29PnPf94miODBWGYRTs84OhAIWK3Nd0WTSZ0L24/3IslIVOgn5+bmNDU1pYWFBZVKJTuF\nMFHknuEIxbj8Ta9btTMTxLO3t2e1XrfbtfovEAhYbh1TwZOTE52dndn/ohVEnYKjPcJLjAX9fr8d\n17iKMtJGLgTnGRgNO1vG5RB7qLvhGAMfTkxMWJnBuB2/DeKK6Q0kqVgsGmLApA91SS6Xs0wUxtQs\naIYvkqy8oWxh9MzDhzKbeDaMKOGlsPvTn0DMAkFCoY6/HdAemYM3uW7VYuamozSBQH5yciKv16tS\nqaRkMmk5Ht1uV8lk0iAiBgNwcy8uLhSLxa6pK2DEnZ+fG29iMLgKU6c5wrzl4ODA0BVGv8T3gofD\ndDs+Pla5XLagenDtnZ0dI7SfnJwYOoK6BQsD6mKI+6VSSUdHRwoEAjbJm56eNvgOohCLj50WwhE2\nCIPBwCDEZDJ5TdU9HnlG6m2n01G1WlW1WrV/2263zYeOBhhBwsrKilZXV63Rvsl1q8oM/CSwWyUr\nr9vtan9/37znUD0fHh6qXq/rwYMH5ubD1BD3TCiWCwsLqtVqlnPHYpienjbnH8dx9J3vfEdvv/22\n5ufnTdlBQA1wITX04eGh+W+gTcRNHuU1DkKoVBiklMtli1K4vLy0Ic3du3fNeIb6l6gI0Amcn/r9\nvpGoUGGT15JKpdRoNEzSRU1NTV4qlcyoEScoyjigNkk2Rk8kEiaURRne7/f16tUrxeNxi0G+yXWr\ndma/36/19XUjsGSzWYOvYHqdnZ1ZAwYpRpJZ1RJVRtjMuK8bdaUka76wGUCgmc1m5fV6TUENkoJ2\nEM82PDfw0wCB4Ne8R+pmhjrg0tSjuGjG43G99dZb5kfHqTE7O6vJyUkj8M/MzBhfghoYWA1cGucj\n8r6hqSaTSc3OzioUCpkahc+zsLCgZDJpDw59CvYIxWLR4tbweJZkzXkikbBS502vW7WYJRleOt61\nx2Ixc72nSSSrJBqNanJyUuvr62ZMAv5KDU4q0nhCEtAYQevo4dDEUeb4/X7zhpZkYgHqdWpHhKe4\nEFFGoAph6IOnBlAZKVGUHjSwSMfwgwabHhee4v3M4GLcmwOCfqfTMTIWLkfY77IgUXdLsoaY7D8Q\nDaab+IcA3xHuCUR6k+tWLeb5+Xm9evXK5DgMHSDDhEIhJRIJU25/9atfleu6SqVSqlQqptAOhUKK\nx+NKJpNaW1vT5eWllQy7u7tGZVxaWjIEBGI7nfrFxYUNCwiDRzdHHjXTM+pjwoQkmT9cMpm0h4tJ\nJQ8jDvnU6ZjDrKysmKAWfBkBLIuJGp7QeIYv0idBR3A3Jicnlc1mFY/HTdGOMyjTRdhyDHfIaykW\ni1byABnCp5Zk6BNayZtct2oxS5906Oj9GCRAfEH9zM0olUp2nI/voHy57DQ0Rn6/35od/g3HJkQi\nVODIhjglxp3hKUvAiDFhxL+t3+9f88bgs7GYeGgoncgQpKHEHoydniBOdI4wCXnQ8PdAHQKRioFO\nsVg0PSETPH4+tTiuRxCfeEB5GMH+aaylTzD/cTeoN71uVQPY6/W0sbEhx3FsqMCxCiQ0GAyMnba3\nt2ewFLsgQ5JwOKy9vT2jPw4GA62urqpcLhuMxO/t7e0pFovZDWLRQXnEUouGNJlMmpMQixlS/8rK\niilY4GTDU8YSDLMXIo2npqb0/PlzjUYjO31w/8QCIR6Pa35+3miyDJRGo5ERgYAfiRxmkoqAdXd3\nV+l02pQ5RBsjICYyIhqN6t69e8Z79ng8Oj09ValUMo5Kr9fT4uKiqeeBTm9y3aqdeTxSjIhc3Nzx\nO/N4PAaN0X1T89ZqNeuq9/f37bhmR0KxzOiZ+hU9XbPZ1NOnT23Awa7FzinJjmheh4bKdV0dHR2p\n2Wzaboq6GQ72+IgYfzYml8vLy8ZJZqLGCYUXHBO3eDxurqVwqsGtcXYiQiMejxvllN+LxWLG2Ybg\n32g07LOdnZ2pUqnYqXJ6eqpms2mqd8oSeN3g/j/cmccudhlqwng8bg0M1gMYm/T7/WtSqk6nY9ZR\n77//vh31k5OT1vDQKFEzY0RI4+Tz+bS0tGSqZrBdJmqQ1TmWV1dXr5USGCrC9SVokqkj74dFzTSR\nqRrcEhhsDD7QGPr9flOQc2LAM0FZAurg8/m0sLCgSqVi8W8MbYApEUCQsDWOEIEtI9TlhKP5HI1G\nunPnjnl8cL9uct2qnRkmHGlMTK0uLi6u8X4hi2P4R8TX+fm5SqWScWoxDUQ1AT6KCyjNFDvk8fGx\n7VRg0HT046y2TCajqakpPXv2TB6PR8Vi0cSpsVhM9XpdW1tb5n3MMEWSmc+wmCDQn52dmc1tKpUy\nlfo4BjwajQzrpUHDdQiBqyQTClDuIHQlXPPVq1eGRzMVnJ2dNUgOD2dqfcS5SM56vZ6mp6dNZ0jT\n+8Ohydh1cnKiSCSifD5vhjDo/cZDKWlgtra2FI1G1Wq1TMSJETk7yatXr5RKpVQul82nji8dp6TD\nw0P1+/1r4TbRaFSlUkkLCwva29uz3R97g/PzcxOHEizEovX7/eZJgeJb+gQ7rtfrNvAAEmNUPRqN\n9I1vfEOJRMIguWq1aq+P4TcPRL/f19OnTxUMBlUul62kITGAU2QwGMjr9erk5MRq+UajYUKCcSMc\npqUkTUFz3d7etrqcDQfr29FopO9+97s3uv+3ajEDHVWrVX35y182emM0GtWDBw/0W7/1W9Z0ZDIZ\ny62DmkkE2dzcnJLJpClMwKTZpVzXtQkWJtxAXNlsVv1+X4uLizo4ODBJlMfj0aNHj1QsFo0Aj08y\ntex7772nQCCgFy9eGCpx//59C9jMZDIKBAJqNBp6+PCh4drVatVKkuXlZbXbbWUyGbVaLb311lt6\n+vSpWYoxoACtmJ6eVjqdNjcj1DR+v1/vvvuuITaIAegVJCmRSKhSqWhjY0Pb29taWVmxvzs5OWkZ\nJfPz86rX63rnnXes6fb7/YpEIubpEQqF9M477+i3f/u33/j+36oyg0WGYz4k9LOzM33ta1/T7Oys\n7UbtdtsciZrNpvL5/DUTxZOTEz158sSy8SgzSJzCSPvu3btGvBkMBjo/P1coFNLm5qYtjkAgYOhJ\nu9223ZqckKmpKW1sbKharerjjz+2B2xxcVGVSkXPnz/XysqKYcEbGxs6ODgwLJsd2ePxKJfLKRQK\nqd1ua2VlxUg+IC2gI5Is0erly5cm6K1WqxYKVCqVrKwaFwFg7HJ0dKTZ2VnlcjklEgnLHSfMB0SG\nYQ/oED4fOzs7FhDUaDR+KGgdv4bDoblwVqtVNZtNE7biGwcTrNVqmUyeAPOpqSmVy2Vtb28bK0yS\nkXywERhPFKWenpiY0NHRkRmOV6tV4+2yoOBFoL+jXi8Wi9rc3DSPDORLjUZDpVJJ5+fnJnWCNce0\njKy+jz76SJVKRfl83ohGW1tbNpIH48aajHE7JRYi13G1Ry6XU6VS0fb2tolqKdcgUVFKYAscDAZ1\ncXGhw8NDU8OQMUiPQbwzzqLhcFjT09NaWlq60f2/VWUGU6vt7W1z0KGjd11Xm5ubBkvxRcKYg7wP\nmoAxNgYnkHZYyBydExMTZtAC0f7i4sLc6i8vL80bjoHH2dmZGo2GHjx4IOmKP8FwolQqGYRYLBZt\nCIFZIpHJoVBIkmwYEg6HbTgCLDYYDLS3t6dAIGCMPmpcmH7wIWhYSZVlYY371DH8yWazymQyOj8/\nN2dTuNJwLVjoL168sNE28CVOqPl8XsVi0RxQfxidNna5rqvFxUWz0fJ6vVpaWjLTvsePHxslFE85\nbFrhaDQaDUUiETODAcqLRqPKZDLm1Xx+fq7l5WUL2ZGk1dVV4x1g0u3xeOw9YU3r8/ns9TBXgeRD\n4A11tSSrz+FjU/JQpzNqRwmDRzMSr3w+r0ePHqnRaCidTmtnZ8dc/c/Pz22kjx8eE9GNjQ2bGsL/\nCIVC5iOXTCYNhx43YZ+ZmdH9+/d1fn6uhw8fGlaPNx0CAcI0JV2btr7pdasWM4YjuPOcnp5qd3fX\nAhRxPCInBKgOWqLP5zNRp8/nM6wUFQlWWPV6XbFYTHt7e9f8JxhlZzIZbW1taXFxUbVa7Vr5gPcG\ndevCwoLRRCWZoSMuptLV7pjP522BEsa+vr5upH8GLLDsGKVTwyJghUiFema83GL8j9UWAyG4yel0\n2qBH1NW4H6G+wWw8l8tpcXHRdmJ25nFSEqcEYgBEA2963aqamYEBypLxXZLaDG4FRzIG5EiE4Cww\njUK2D6WRXYppI68xTrPkhrMLESYPnwP/NpTg0lXHDwRHUBC7NX4bYMzT09NmDcC4GBIRsiUWsNfr\nNVoowltG65KMoTfu98wuSTgoZRaZLQxqgC+xtB0MBlaiQayampqyMTx2YVgN+3w+k6zx729y3arF\nHI/HjZEG7bBardrCbjabOjg4MNJ5sVhUJpOxkTYO+Nvb26a6ZtfhhkLCIR4CV85er2dNFXKmdrtt\nXhLAeoxxJdnRDHoAAw4eBkHqPECVSsXgPKwOUJf4fD69/fbbSiaTyuVyCgaDyuVyqlarevr0qY23\nMVAkywUUA0cnRAOocUhT9Xq9JnCQZPxjsklwZmIYhVodOwLYfjTNDHZozpGk3eS6VWXGxMSEwU0r\nKyuKRqN6++23TZ6D5RXZfUtLSzo+PjZpVCKRsFIBvJkdlx0JP2HHccwbGUI9tTYNITwRZPZ4MwcC\nAStfJNlxzUPT6XTMGGY8FwWh6rjjJiPp6elpFYtFw2slaXl52XZ4HDk9Ho9KpZI8Ho9CoZAJDPr9\nvrLZrCEvvV5PqVTKyFIYvUhXPBdsAxYWFhSPx014gKIb43DeIwsd2RrUUUSx0WjUxttvfP/f+F/+\nAF4Q0sF5O52Ovve97xk/oVqtql6vW2xupVKxnDpJJj/66KOPbLQ9HA61s7Nj4e0sZBYinGLqWBQg\nuHsSwTBO6YSFxy6G0Tm4Mw7/lUrF4seoYfn3QG2gDHt7e1pYWNDZ2Zm+973vqd1uq1gsql6vG76L\nKxOG4L1eT6enpyoUCjo5OTECfrFY1OXlpQqFgvL5vH0OfOGgDcByY3JIuUWQD73BOCGrXq8b2gRe\nPzMzYxYNN7lu3WImYzqRSJiCGu0cR/3MzIy5djJpc11X5XLZ9Gho+uA1o9rArYd6OBqNand3V5J0\n584dDQaDa8LTi4sLpVIpMxAHzuLYnZqa0vz8vMLhsM7OziyBCYNC6n0QBwwXKXvOzs5sdx0OhwqH\nw8pms3ZyzM3NmZ3A8fGxDZZGo5EikYipPcbRDyKTSQUYjUba29szwQN8bVCcmZkZw6jZnXE9IrEA\nO9xUKqXV1VXNzs5aiTU5OaloNGrigje+//8mf9lxnElJPtd12zd61c/oopnr9Xp68OCBqtWq7t+/\nbzslLjqxWEyXl5eanZ21YMdyuaxwOKyZmRm9/fbbSqfThkhAQoejkclkVKvVzAfi3r17NiHDMJAY\nBb/fr9XVVSsLgK/wiFhYWDCr2bm5OZ2cnGh9fd3QFDjAPHShUEgnJyeKRqPKZrPq9Xr2v51Ox+p/\nRt3AdJREBGhyOgSDQSUSCUMTHjx4YIt9bW3NHv4/+2f/rIW4wyQEIqR8I/QSuzJQEHSQ8/Pz9jDg\nWgrRaG5uTnfu3NHXvva1N77/f+Cj4DjO33UcJ+g4jk/Sx5JeOo7zX7/xK36GFwgBEnh8g6n1RqOR\nqZilT+KJIeBQd1J6IKfCzZOdo1arGaTHRG58V4FiCl+a477dbtvuzBEPEsDi8/v9FolAljZTQ/Dk\nhYUFKxcYyrA7MrAA2SgWi/a61WpVPp/PLAWoc3O5nPkw8744vcDZ9/b2VKlUJMkYfvl8Xl6v1+wK\nmHoCc2IGSSMNH3p6etpw62KxqE6n86/4X7/J9Wn29Yevd+J/X9I/k7Qi6T+70at+RheKEfi01MJg\nn/jHccQWi0Xt7e1Jkg0PsBxgIUBrhAbJkARuNFwHOnsoleTqAcUx5Rt3l2cBIkbF7gt4DGol4gDY\nbozF0fV1Oh21220zLWQaiFSp1WpZA0qTjGP+eMoUAyV4JuygXOOGMyhuKEMYlvD5eMjYib1er0Uo\nYyDp9/vt9UBJbnJ9msU85TjOtK4W8z9xXXcgyb3xK38GF+UEEncYc6hLJF07chcWFvTOO++YoBTB\n6Y//+I9rNBpZ/QzKgS0rZCPootls1hY2+XhQUDkFwK2B1hh5s7jAXAOBgNbW1q69d6xqGV0Ph0Pd\nuXPH/D7AwiHL83qhUMgUNYhPMXxkUfr9fq2trRksCcrh9XqNc8J3kc1mFQqF9KUvfcnyUeB2SLKY\nNOwP4HlsbGxYc0gpRynDgg+FQjc2Tvw0NfOvSDqQ9FTS1xzHWZF0M0DwM7pwITo/P9fu7q6CwaC+\n9a1v6Ud/9Ee1s7NjyVGNRkNf/epXdXBwYP4XENJrtZp+/dd/XV/5yldscre9va0f/dEfVbvd1v7+\nvkFZhUJBmUzGDAr39/f13nvvaWZmRrlcTplMRtlsVt/85jd1//59mxYi6sTIGyQgHA7r4uLCnOsR\nB1BrDwYDPXjwQJeXl/rggw+sbsachViyr3/963r8+LFFyOHk1Ol0tLu7aycLusO9vT0jy4NaLCws\n6Gtf+5ru378vj8ej58+fG2nq8vLSaKfn5+fa29uzkwtvup2dHX3uc59TPp/Xhx9+aDK0arWqRqOh\n5eVllctlzc/Pm4XBd77znRvdfweN3Kf+B1cF6NTrHfoH5nIcx/2Zn/kZG3KwG5dKJWUyGZXLZdVq\nNcViMcukgxA/btDCIiMBCWdOJEfVatXQEca0kHQocwimxMibB2Z6elqVSsWQEgQBHPdg4EwLOQGk\nq2M9Go1a/Y9hYjKZVKlU0vT0tOr1ujKZjHq9niEY+N01Gg2FQiE9ePBAh4eH18oMJpypVEpHR0eG\nL+fzeVOQFAoFK6lWV1dt3P7WW2/ZRoHxOY6ed+7cMSLSYDCw8ofvrNVqqVQqaXFx0T7Hr/zKr8h1\nXedN1sAfuDM7jrMr6VuSvi7p667rPpf0A7WQucYd8V+9emV2rPV63XYvgs3ZUWGP+Xw+80A+ODiw\niSGEdLBe5PfYaY3Xw5QP7XbbRr0gHgTBY1VFmCZ0yng8rmKxaDUu0iZifsFjoazm83nFYjGLESaI\nh6FHvV43K4JWq6WNjY1rhurU4zShWAgMBgOVSiX5fD6DODGkGadvLiwsmAxL+iRQlFE3r4tTKqaU\nELtAiHBXgl56k+vT1MyPJP1vkqKS/gfHcXYdx/nHN3rVz+hijIq4k8YEISocAXYHJFWYgY9GI8vZ\n4z+OzfEAHbSAKysrymQyJqWiHq/X6wZZkfREcynJCPxwIaLR6LXBiHT1YFLnX1xcyOv1WkYgTRm2\nX9iDjUYjLS4umuZvPMxnOBxeS62lSWPnnZ2dVSKRsHQtvjeaVTwwELvyWYDnAoGATTah2PKQU6/j\nN02/QFnI93/T69Ms5ktd7cRDSSNJNUmVG7/yZ3BhLzAcDnV0dGRJpohJga2oXaPRqD766CODnsbh\nMgYY0WhUuVzOEIGzszNr8hCwglocHBxY/Ytx9vHxsdnXMinETRRjlXK5bLwLGr1ut2sWr6TGMv0D\nm6V8IOmp0+kYf6JWq5kRJA78LCgmjIy5MYDBEBI0A5Eru/yzZ890fHys4XCoFy9eWHxEv9+3GIfh\ncGjeHBD+KbNQgY9GI21vbxs2jdsopd2bXp+mAWzrCl/+HyX9Ldd1bxZw/BleGK/0ej198YtfVDqd\nNrPDRCKhcrmsVCplqMP5+bneeustxeNx4w0EAgEzCccHIhaLGQ6cyWRULBYVCATMwQdoKx6PG2cB\nHgX5eKAY1Lqzs7NaW1vTxcWF1tbWNBgMbHTNZBHXUZw4KWP6/b7eeecdY7/hjg93RJLtntTY4Mjv\nvPOOcrmcPVxM6nhwcB0KBoP64he/aMw7ThnU5YyyOVUQKqyvr5sPx9nZmXw+n+7evau9vT3t7e2Z\nsQxmOB9++KGSyaQZM97k+jSL+T+W9Cck/VVJf8VxnG9K+prrur95o1f+DC52AVhaHo9H29vbevjw\noQ4PD804EecfLGPxlaD5+fa3v6379++bEvni4sJYbNSweE8sLS3p8PDQUAqiziqVih2fqL7JBOSI\nHzdEJ9i9XC7b0AfYamtry6y0Tk9Plclk9OTJEz18+NBGy/Pz82YVViqVDFk4OTkxK7BaraYPP/zQ\n6npOiidPnpiqptVqKRqN6uLiQltbW8pkMrZj+3w+1Wo183JmkYPIzM3NWaJsvV7X+vq6Tk5O9J3v\nfMdOQp/PZ8kAT58+NTKV3+/XN7/5zRvd/z+wzHBd9/9yXfe/kvSfS/qnkv6ipF+/0at+hheiUtTH\n1MnjvGK4vpOTkzo6OtLKyorhqhiTo22DTI4ok4YxHo8rlUoZooEyHK5yIBCwwcm4uxBORpB3OKaZ\nusE9Hsdfl5aWzNwGhh0DDZyO9vf3bVERKeHxeBSNRlUsFrW1tWU7+Gg00t27dw01YfHCN4GHDKtu\ncnJSzWZT5XLZegmGIoyyQXJwB6WcgArK73U6HS0sLMjn85lglzKQz/6m16cZZ//D14jG/yzJq6vp\n382r9c/g4sgl9heerHQ1HSRllAUZDAaVSqVUrVaNcQeRCPYd0zJ4zBi8zMzM2ESLnGomXTDHfD6f\nTQ/hNAyHQ6sTEZdyJCMuwNqAEwYUArZaoVCwYUa9XjfOBGQfTF3QREYiES0uLlrje3Z2ZoFAYM7I\ntcbVNxi57Ozs6Pz83EoLOB7AcODYPJCSzLXUcRzjsbCYSQmo1Wq20OFS3+T6NA3g35R013XdP+W6\n7n/ruu5vu657M4vzz+jCOBvZOugExB8QhnF8GPyWKx6Pq1armamh1+u1rEBonFjLer1eSZ/kcdD0\nkd1H6hTlCfo6iOh4zGH7Ct+5Xq8rlUrZLogNeCw8AAAgAElEQVS5TaFQsIeLnzU1NWVc4ZWVFUMr\nBoOB9vf3Va/XDa5rNBqqVqu2YDm9xmN/m82mUVkrlYq63e61NNZ2u61wOGyeIixqWICIdxEUtFot\nRSIRHRwcWMwbRoyQp0Ch/jC4GU8k/Revd+h/6DjOT78eb//AXbj/xGIxrays2JGJ6iQYDJpDKI0S\nquDJyUlDHfr9vqmf2aV8Pp8SiYQNBxhPM+iQdC2x9OTkRPF43LDUcZsuJPlo/DY2NqwEikQi8vl8\nBl2xW+EC5LquEomE8aXBx1FTp9Npe9+xWEzxeFzLy8tmWEieYbFYNH4IavN0Om1xE6hdKJUQBnM6\n0AeMfw/EOMzMzFzLZuH98LNQ80hXQoNIJKJoNGo9xJten2Yx/6+SviDpf5H0y5Leff17P3AX7kPk\n0bXbbQP6ic+VrjpwZEhYZ1Fro4JGesWuAZkebjFMNgYFXq9X6XRax8fHlgHCkYq6mlNhdnZWzWbT\nrAsQw+7t7dnRz3iYnZNAGwYelC88hOScYJlFP3B6eqqdnR3LYGG3h7M8PoxBqAuNFvErpQTWuuPJ\nt/Qgkoznzfssl8vGL5+cnLR8FcdxdPfuXbNQQKp1Uw3gp0Ezvui67ttjv/4tx3Ge3uhVP6OrUqlo\naWnJGirAe3a6cDgsx3GUTqfl9XoNVqLOJKB9fHDgOI4x5SAiDYdDa5jgCxOnOx7T1uv1bHQNzg3f\neH193RAM1BycBrwnhKEQjIimIIAH5GZ6elp+v99chOr1ugKBgLLZrNndQpLHUZ/xOoMTSQb1jYt1\nedCAPXFA9Xg8RtACu6fkoQEOhUIKBAKWq0hdf3FxYRtENps12PMPIzrt0nGcDX7hOM66rgYpP3AX\nZQCIAmJTal+YYi9fvjQzFnbRO3fuWLAPI1oSq5rNpvkeM1XMZrOW/wFhKBAIKJlM2kMC/4HxNgrx\ndrutSqVi1gZEl0FgBzWZnZ01jw+EuugNB4OB4cHEU6TTadPvMQGdmZnRs2fPbKfl4VpZWZF09eCM\n/yyEuKhXsBNj55ZkJwzNLLwP6nl415RomUzGQj1pSAOBgNbX1+0hpQe4yfVpduafkfQvHMchcn5F\n0l+60at+Rheq54uLC3OPJ7Ac21oUI+wU7Lj4nVFzM3LN5/NaX1/X1taWwuGwxYvRCBKbAA/5448/\nNlck5PjIryDHY57SbDYNvcDUhZvKTk4TxaQRe15JFqg5MTFhYlRscSmTpqamtL6+btO8cVsu6RMn\nI4Sl+HtwCgQCAfOci8ViVgZRe/PvhsOhjfvhdvNaW1tblnTL7g0ve2dnRxsbG4rH4/awvOn1aXDm\n35J0V9Jfl/TTukI2/sWNXvUzuiYnJ6+hApj/4Q/XaDR0eXlpTQ7qj8vLSxu99vt9G4hgmHh4eGg8\nCZQS2OWizmaXx9YL8vp4/BmiAUSkXPh2jCtY4AqzKAnrxC631WrZwwvUxt+p1+v2HyNu+MNgv6Aa\n/X7fKAAEc5IQUKlUjIBUq9VUKBSuiXJLpZKdeM1m00oHIMVAIHAtPZamm/4EvB5K6f7+vm5y/b47\ns+M4/6GuSPiOrpPxN14/tf/oRq/8GVyMbi8vL/X2229rMBhoaWlJ6XTamg4sVfv9vvlM4I8GC45S\nAcL+j/3Yj1lgfDqdVr1eVzabtag1auHxvDvc5hOJhGHR8/PzCoVC8vl8SqVSFmsMlLW2tmYnCF55\naBaZHHLEJ5NJcwKC7ENdOzMzo0wmo+fPn19LsyI/vFqtanFx0Wr+xcVFtdttK03gayCMDQQCWllZ\nsbgLSfY6w+HQ6JvLy8tmfr6+vm7aRYYuWOAyGWX8jqrmvffe07Nnz974/v/rduZ/5/V/f1nS/y7p\nP3n93996/Xs/cBcWtgxP4Bng3bazs2OcW3ZNwPpWq2WTMxYNu+7e3p5BZVNTU3aT+/2+0TPZlWh6\ngsGgDWcQjmLYQtcOGoHhIMYzoVDIOMWXl5fK5/Mm8R9n5925c8e8PUAqGHS0220tLy/bEGM8FBPb\nLgzE9/b2bGGP8619Pp+9Byx8A4GAPB6PRTLDzgsEAsrlcpqenlYmkzGjSGifEPs9Ho9xQSYmJpTP\n5027+G/Krf+91++7M7uu+xclyXGc39CVDrD0+tcLkv72jV71M7oqlYqSyaSVECAHBM5IMoYZpoGN\nRkPJZFJTU1MWAww3gsECJQPBkAxUUGBLMltclB08WIhsqSNBRHAqwv4ABAYIDkhQuoISG42GxRrD\nUvP5fMbNQLoPOQrMnCnhxsaGBcjTsJHPAmIBUT+fz5utLn8nGo2arx0Kc3ysa7WaFhYWrLkDosNg\ncRzqk2RUgVQqZRAm9fdNrk/TPmYljbOmK5JuZqT7GV3pdNo4tHAvaM4wXEHrRo3YbDZtosZuDjYK\nLopLT7fb1dHRkR318HQhL6FgwQgR/gVKC8hAKEDOz8+ttse8cGJiwh5EYKyjoyPzNwZflmTlC2Y1\n+NAhTn358qU1i1A7cWaCv8L7Pzs7U6lUMtHtzMyMeULPz89re3vbhiRwj4EnM5mMhYLCN0H4wJS1\n3W7r7OzMMPbl5WUTQdB//GHEDf+mpP/HcZy/6DjOX9IV2eg3bvSqn9G1tbWlUqlkit+TkxO1Wi3b\nmVkMNHzJZNImhChRMPIGXmMkXSwWDYIjehi1Bg2jx+PR0dGR7V5wfyHTHBwcSJLBhghG2ZHZDaem\npsz1B1jP7/erUCiYRhAsmiYN3gcpAJJs4uf3+20xEXLfbDYlSYeHh2q329rb29PKyoo1qgx3Wq2W\njo+PTUlDY0mJAg+EOpgGkvg2fPFg1x0eHqrT6dgw5vj42B4O3tObXn+gBvC15u8/kPRjumoEv+a6\n7v95oxd1nJ+T9J/qiuz/sa6gPp+kvydpWVcC2v/Idd3W2N//y7oSCPx113X/+ff5me5P/dRPaXFx\nUdKVjGhpaUnFYtG8NAqFgk3QyDM5Pj7W5z73OYPNyOWDJUZHjmvl7OysDg8PLUN73HCRJoudmweF\ncTYTQyiV9+/fN3YctExSVsdRF4hHNEosHCaDKEn4XNT7eGdsb28bHPn5z3/eRKXhcNhKs1qtplQq\npVKpZMGY7My8TjAYVKVSUTabVbFYNEUP/iHkpXi9Xm1vb9s0dWVlRYeHh6pUKuaSBEvu29/+tjKZ\njJUnP//zP//ZaQDdq9X+j17/d+Prtbr7r0h64Lpuz3Gcvyfpz+tKnvUbruv+947j/DeSflbSzzqO\n81DSn5P0UFJa0m86jnPXdd3R7/3ZKC9Go5F1/+VyWaurq5Z5DUqB3xrEpMvLS+VyOUUiEf3u/8/e\nm8RGmqZ3fv+PjGBEkIx9j+C+JXOrrF4wXdOC1GrBGvukMWADvowxNnTTwePlYBuQL9bFbWAGXgAL\nsC0bmsPIkAFjoIPGGEEQ0FZ3Cb1VZlYWkzuDZARj3xgRDC5Bhg/M31PBbnWjkVRrWkR9QKOyM8lY\n3+99n+f//JePP9bS0pLVcqiwHccxmyp2H+rbwWCgZrOpRqOhubk5G5H7fD4dHBxYfYi5zNjYmB3N\nuF/m83kbN4fDYR0fH1vO9M3NjRYWFuwxX716pUePHlnjR24htSo3yPBd9C/ko52dHXPhZ1S+ublp\nZU2j0dDR0ZE++ugjvXz5Ul/+8pe1tbVlnyelA3rG6elp5XI5czwdHx9XqVTS4eGh0um0Go2GhRJh\nw9VqtXR6emqNbTgc1tnZmba3t++1tn4eCui/5zjOjuM4p47jdN797z72XKe6lWFNOo7j0i2t9ETS\nb+nzxvIPdevTIUn/UNIfDYfDq+FwmJO0K+nv/XUP7HK5jPZIbDDcDGLIOGqpH6mXwYcZYsBpLpfL\nSiQSVh9PTEwYMZ1mklDLVCplahV4FRMTE0aCZyxMnAM7MDVwKBSy0qNQKFhkGfRNOn7KF6xoQTiw\n2GKCyEjZ5XIZ6WpsbEyRSOTOsIgbiM8PEev5+blOTk4sBQB7LSRQpGxNTEwok8nccUh1uVxGBZie\nnjbSEoY1jOHpI3Bqvc/189TM/72k3xoOh4HhcOh/97/A+z7hcDhsSPqnko50u4hbw+HwzyQlh8Mh\n2sKyJDQ0GUn5kYfI63aH/olrNOcDDgURDNAWs9ms4akgGEBdmAjSFLlcLqVSKUkyGumTJ09MHvWl\nL31Jbrfb5D4TExNaXFw0LgW85S996Us2QUOuhA4wHA6b7xq+yVBDgel4rPPzc83NzRm5nXKC/Oxo\nNKqlpSX9+q//ur1u3lsymTS23agIIBQKaWFhQZFIRPPz88pms0qn05Zqtbi4qLGxMeMuM63Euovm\nlR6AhCmMeCBiBYNBra2tWVTx9PS0VlZWbCIai8XMVuF9r59nnF0aDodv7/UsI9c7bsd/qtuxeFvS\n/+04zj8a/ZnhcDh0HOdnFfN/7b/lcjlTSxQKBfN7WF9fty9iZ2fHdqdarabd3V3F43Gr/1qtlmGt\nb968MQ4HOxKPe3x8bMcukzTsvJDdY9n68ccfy+VyWWOaSqXMhRT8eGtryxTR7LY4ikYiEeNGcDoc\nHx/bgiyXyyb/L5fL+t73vqdkMqnNzU3Nzc1ZPTwYDAwVKRQKev78ufnModxmihmNRvXZZ5/ZuH58\nfNy0j3x209PT8vv9JqAFyoTfjRNSt9vVycmJ5ufnbWqaz+dt6MK4Hqu0971+nsX8g3d17b+UBOF0\neI8J4FclfXc4HNYlyXGc/0fS35dUchwnNRwOS++w7Mq7ny/oFh7kmnn3dz9xofxgQvb06VNjZlUq\nFW1sbGhubk67u7uamZmRx+OxwUM8Hre86lKppLW1NZuKERLZaDTk8Xg0HA5NfjQ7O6vvf//7Jvkn\nShgvuIWFBXMdlW5LoVwup7OzM62urhrSMjs7a+UDsv1RAWu/31cikbBdkpNkcXFR+/v7qlQq1mgW\ni0V5vV6trKyY9g8vurW1Nb169UorKytyu93mMkRcA7+bTCZNCbO0tKS3b99aRgkuS61WS9lsVvv7\n+xbtgHQsFApZNjgDmePjY62urlqkxfj4uF6/fm0sPKaH73v9PIs5KKkv6R/82N+/72LelPTfOI7j\nk3Qu6d+S9D1JPUn/WNK33v0Xb44/kfQvHMf5Z7otL1bf/fxPXN/85jdVqVRssibdTr4gvTNOfv78\nucbGxjQ3N6fx8XEtLS0ZZIdwtFgsanZ2VuFwWLVazSRBREokk0ldXFyo1+uZZEi6zc6bn5+3o31p\naUlbW1tG7mGxj3oSb25umrr7+PjYXgNum9fX10qn0+p0OjZZzGaz8vl8lgkeDoeVTqdVq9UUDAbt\n5kHVQZkC9ZObEY860rdG6304KOPj44pEIub8hA6RCR/E+kQiYQQsBLn9ft/MbpaWlgz5YKDzG7/x\nG4Z6FItF7e7uvuey+vnQjP/ovR/9r3+8V47j/HNJP9AtNPcj3ZrM+CX9seM4v6130Ny7n99wHOeP\nJW3olnr6O8OfgifCkzg/P9dnn32mpaUli0YoFApGsCkWi1pdXVWtVjPZDyoJLGWR+kMgf/TokarV\nqrHJ6vW6Go2GFhYWbHgBCgC2HAqFtLe3Z1wIkJFoNGrxZYRnJhIJ84vrdruqVCpG1ul0OkbKAZMG\nGpuamtLV1ZWZpXMiEOaDQIGPDGbg69evtbCwYDZZnU5Hy8vLpo2kOYQNSAkCBAjllWFNr9ez0mHU\nGHE4HFqjTAxFoVCwcpBGEGLTfa6fijM7jvNfDofDbzmO8z//Nf88HA6H/8m9nvlv+AJnBiP2er2W\nM724uGiTMHgYNFe7u7taXV01dtz4+LiZeUPHJGsalKHf71tWNf4a7HLdbtf4C+Pj40okEvrkk09M\nZzgYDBQIBNRqtcx48OTkxAY1IC9MJnl+wi7x+MCTAt0j+LXf71etVtPS0pLevHljzyXdNnvo8SKR\niN24PCZEIfwvXr58aQ79KFJIaJU+l2gRdcHOO+qPnc/n5ff7zY6XIdH8/Lyazab6/f6dsfy3vvWt\nXwjOPOE4zt/TrfvnqDjrx1l0vzTXqJXs7u6unjx5YpyHUQiKpNLPPvvMfM7wt7i8vFSpVDLvB4g0\nWFQh82+1Wmo0GsZ9htBEehOlB8c1Uy/Ce0YFnEBz4L+gKUi/kGmxWDFDhKtNc8hxTm1PY1YqlfT8\n+XNb9ChlENd++umnhgCBR/PYKEd4L5wWkPIjkYhlfR8cHFicBWJiXg8TRDgsjUbD6LDlclkLCwt6\n9erVvb7/nwXNhST9D7qF5n5b0rqkhqQ/GQ6Hv5REo0wmYx/awcGBJicnDXW4ublRsVg0eiVj3lar\npcnJSe3u7hrMVqlUDIdmQEHADf5wNGBgw71eT3t7e5qYmNDCwoLtlBzPfr/fund+FhSEkyCdTtuw\nBUoqo3HqWBYVvGS4DdTNOPOz642KTIlo43E4lSEpMarHibRSqdhkkzKt1+tpeXnZNo5R1iEsRZpO\nr9drPUw+n1coFDL/Ed4PAgBU6fe5fhZr7r+QJMdxPLpFIP6+bsfO/6vjOK3hcPj4Xs/8C7iYTEnS\n8+fPTaqDKSByonQ6LbfbrbW1Ndt9+QI9Ho+Wl5cVDofNRIVRMCJNiEeYwFCzosQIBAKanJw0S61k\nMqmbm9tMasJpGCLAFgMhyb0LWE8kEtbI4teBWhtFNqcJCbHhcNgcO5H8w1uGjI8OL5lMGj6MBRe5\nK4RkRiIRM3ZJJpNGKGLSyEmDGh2qK6mrCGD5/V6vp3A4rEgkYoQpPluv12ul0fteP8/QxCcpoFtU\nI6jbQcdfvfcz/gKvWq2meDyuubk5Cz5H4FkqlWyQcnR0pMFgoJ2dnTuY7tXVlXK5nOr1utrttkWt\nsdt7vV4tLCzYIj4+PjbqJCJO+M21Wk2rq6uWk3Jzc6NEImEyI8bUOCZVq1XDji8vL7WxsaFOp6NW\nq2U85e3tbeN91Go1GxPDad7Y2DAiEXYB3W5XzWZTa2trCgaDljEofX7zAzeCSlD2sPtyopXLZQUC\nAe3s7Ghzc9MQknK5bAxBmsV2u23BO5CgGOHzmmn8rq6urOm9z/VTF7PjOP+b4zjfkfR/6XZX/q6k\nf384HH5lOBz+UmoA2WVoKtxut03cqDX7/b55JqMSBttF8AlzjMYHeKzf7yuXy+nw8FC1Ws1G4YTG\nA0cR9jg6OIDX6/P5VC6XzSIWJTclAg0kMi2GJBMTE0qn08ZTZmDB1HM4HNp4fNSTg7H24eGhMfLY\nRUebZEnG/Gu320ZpdRzHxvzU1NlsVrOzs8YhwSxytE5OJBKKRCImmIWGC8JBw7e9vW0MPV7z+14/\na2eek+TRLZe58O5/rXs92y/4wuSFLBCQAZqw5eVlI9l7vV5lMhn7kihJ4GjgjE+WXigUUjqd1uzs\nrLLZrJaWlhSNRrWysmK7NlwEMNt4PG4LJpPJmEUV6auEBkm3w5R4PG64ONFk3CTRaNRG0tFo1B6X\nGxBVOgKC09NThUIhPXr0SIlEQrOzs5qfn5fL5dLc3Jwx/iRpbm5OLpdLyWRSw+FQS0tLCgaDhstP\nT0+bMfmoAQ7vB6V1PB43/JhyLxAI2Ag8lUopm80qmUyaEfvz58/tPT169Ohe3/9PXczD4fDf1i2h\n55/qFr34z3U7DfzXjuP8t/d61l/QRb1YLBZNY0bjBYeZY5whCObheBS7XC5ls1mbCgK9wa6jbqX5\nAT0hMpcsPhZ0rVYzr2VixChtwMXj8bg1Z+yYNFCRSOQOBHZ2dqZKpWJcYgYbyWTSbmZ8j+fn5++M\n4tvttlZWVrS3t6dYLGbeHmNjY0qlUmbs2Gw2dXZ2ZkptjBLx3lhcXDRCFwY3YOGxWEzJZFIfffSR\nNaDT09Om/mF0DbUWES285/tcP7NmHg6HN8Ph8FPdRqb9K0nfkbQi6Z/c61l/QRfmgzgYjTptgr/i\ngxwKhVSpVOTxeIxUhMHf0dGR7XZut9sk85i54HHBVIzamYw+mjUYbJDPCcUh4oEjHstcsGp2O+kW\nthsOh4Y7M1kEm2Z3Zrrn8/lMNABEdnx8bKbn2IXBCgRaq9VqdxIAaArZ4aGT3tzcKJfLqdvtqlar\n3Qm+9/l8qlQqFi40ekJKsiEP1rahUMgyGPHiu8/1s4Ym/0TS13VbLw90WzN/591/3wyHw+t7PfPf\n8OU4zvB3f/d3Jck6bgg6a2trKhaLajQaSiQShhsDSZEehUlLpVKxjh5KJvIpbABYlNiBwaOQZISl\n0dfAVA0tHPwR8kngXFSrVYXDYfOP5nkbjYbVmYhgM5mMOfoXCgW1Wi09evRI+/v7pphGroWiA4Ep\n3GPgNho1vEWy2axOTk6sJAD3pi8YDoeWYMXJNhgMzBQnn8+bwypZM+Pj44rH42a2zgQWJKjZbOoP\n/uAP3nto8rN25gVJfyzpo+FwuDQcDv/RcDj8/eFw+OqXbSFzEUbJUILdh66eQQVfHmppHI9goQE9\nTU9PGw+ahYpjEMoIVCxwFQjj8Xq9VkdTEuB3h4UXsiK0e2dnZ5bJR1Ks4zjmnwH1E1kTY2iIQpeX\nl8rn80omk8rn88pms3bz0oQ+evTIfC8g5yOoxZXT7/fbScWgZHd3VxcXF2anywib3bxYLFrDCNmI\nRhAJGjpHCP6SLIUqEAjcO9fkZ+HM/9m9HvnfwIV9QDAY1Pb2tpaXlw3yoXYEevL7/frOd76jQCBw\nR/rU6/XMOqtQKCibzaparRp6UK/XbUzLrsNjIkCdmppSu922mIfd3V1zHALFoKtn6oiAFJcl0AG4\nFX6/X2/evNHMzIzGxsaMbhqJRCxjm9ff6XQsiYrBDM1as9lUPB43Fh2vidH5qO7QcRydnJwYtk0Z\nQKj8ixcv7AaAmM+Usdlsmjzq5uZWFFQuly1KAl7G6Ibx8ccf3+v7v5+51y/ZValUzHkSGIvFygJi\n8oTJYqvVsgyRVqtlzu9+v98GLEiVLi8vNT8/b7s5gerj4+NGREdAyyABf7jz83OrVfv9voXY0PAR\nnM4OGYvF7OZgcSwuLtouGo/Hjdgvfe5NDQLCe4WHUq1WzdUU3BvzSEjxbrdbU1NT5pkMwZ7auV6v\nG087EAioWCwaJEgsHQ01Wkr8RdrttiFDICOodkCR4vH4vb7/B7WYGWrwBeKNAUoRDAZtiII0KhKJ\n2OiZ0gAiO7Xf6uqqHcmkOEky0jrWAktLS1pdXZXP51O327XYNaIggKvw0UilUjbKlaSPPvpI0q16\nu1qt2kJPJBIKh8P2vjAoxB2IiRuUUrgVwI08FnpFOBJAl1A7MU+PRqN287NrEiUMi47YtouLC+Mx\nYx+AYSRIkM/ns4g2DGUkqVqtmicgNNP7XD8Pn/nvzOVy3b4dMGTQiNEMQBQShNaQucHuGI1G7e+g\nQJIDPYowsIMD9ENOpxkCQ/Z6vXZEA235/X6Vy2VrwIgtY9diRI5gdHp62hpWxs7Y0DIahzQfCoXs\nJsBay+12G6cEngpeHzwHI3IQEPB27L+on8lKoS/gfbbbbaVSKRu4MKhCUIu2Ei1lMBg0qBI73l/k\n0OTv3NVqte7IkDAXqVQqyufzev36tQaDgWX9vXz5Un/1V39lmXws/N3dXZXLZaudX79+bRAY0iE4\nE9TR5+fn2tnZ0e7urprNpvb399XpdFStVnVzc2P4d7fbNfMZIK1YLKZwOKyNjQ1ThdBYVioVFQoF\n5fN59Xo9bW5uyu12a39/X2NjY6rX6+p0OiZurVQqOjk50Q9/+EPbpev1uk09p6amrPzAQvbt27cK\nBALK5XI6OjpSv9+3XgP0BK4F8GK73TbokRiLra0tG1BtbGwol8uZVAxCErs4sF6hULBk2vvwMqT3\nyM7+Zb0cxxn+3u/9nunbqJkxALy4uNDW1pbxIzAM/NM//VN97Wtf09jYmH3YLFhJtnNWKhXDRePx\nuHEWRt192E2heUI6qlQqluTabrdtWMJJ4nK5LMYNhAXkhb9DdQJ/YjRagjLl7OxMkUhEx8fHCoVC\nBschUCB+AkRh9GdHA3jOz8/tZMtkMuYw6vV6LeD+7OzMpGTU5PBPCOKhyQUxgYQEzRWjnEAgIL/f\nr2q1qt///d//xflm/F26cPicmpqyTD8avOPjY7OMAq/99NNPDVe9vLw0NcTBwYGWl5dVr9eVTqf1\n8uVLra6u2uLr9/t3jAxZxEQa4GcB3MZjs/BGx8+QdVwulw4ODowEFIlEdHJyYtq4wWBgiygUCunl\ny5d6/vy5TecKhYI5arKT4pMnyX4OxAOe8c3Njfb3902Eix9dMBi08Et8LqiDCXDHnBGuCqXKYDDQ\nycmJKX1Aas7OzpRIJCy5C2FCJpNRr9f7W8nO/jtz8aHlcjnzktvf37fdFd+K0S5fktrttkFz+NDB\nFQbG83g8llHSarWMgYaTPVM3BiPNZlO5XO4n/Juhh4IKjPows6DAxbGDRYlBWHq9XrcEKI5xXI4g\n5CNIiEQidgMx2CmXy9ZEMjUcdS6itLi8vNTx8bH5fmAkjsv+xMSECR7A5cHkGdlDfuK9jGL9pNNS\nhtEgv+/1oBaz4ziKxWIKhULmx0beCMaBlUrFuMv7+/t2BLKIgdP4kjD0ZjyO9wUjc9hl5+fn5i3B\nokokEgoEAkbqqdVq5l7E+FeSwWQoVjA8x/YA7JqAd8J4jo6OzLgF1Qp4LyXI4eGhmayw4xLJzO/i\n1olub2JiwmzM0Eey8CVZ2hQwIacbeDNeGpJsuMLv0l/wM+DoY2NjFr/xvteDKjMwDqTDR9WMixAJ\nrNRymUxGW1tbFgnGbkd3z+5IPU396Ti3gY1kdZDD3W63tbi4aKoLhgjxeNz8NKampoxJhqv+KCqC\nGpqGk8V7cXGhx48f224Ils5NR61+c3Njiauzs7MaHx83OzAMcaampqzOdpzbwCJUNKA8+HtA6A8E\nAsbTgJSF3wg8bkb9lHFYCMCak2RICfwYoobdbrc++OAD7e3tvff3/6B25m63q2w2a6QgiPEQhCDn\nYCkAdHdxcaHDw0OVSiV5PB7jXjDoIISKR+8AACAASURBVP4MTjM83WKxqHg8bgw4MlDOzs4MNaEe\nR+jZ6/VMj8jOzpGPgBZyETsXdq8MVsCD4WrTTMLfoBmVZFixJGvKGMOP2uzS3NbrdWPS8Z7ITpme\nnjb/PTBqSVbSMaaH4wFhqdVqmYsq5Z7P5zOZFOStL8qMkQtesqQ76gnqzmg0qomJCcsBXF1dNS+1\n6elpJRIJC8K5vLy04QnHsvS5TRfcA74gvjh83Xg8yheOXXbhmZkZW3A42UsyMg87NeR8Hj8QuHVG\nA5uG1zExMXGHtA8HWZJhu6N4s8/n09jYmDmcIh4AW8YmbGpqyvgko6QseoFRiy5eN+bnLGzouPBH\noOYyykZPyXt73+tBlRnsvnTy6OP6/b4qlYq5AlFXAkuRyoQqm7iw4+Njm/q9ePHCMF2CfcbGbvOv\nEWtisj18F8jT7/dtkII97tXVlUqlkgk54UozDmbYwOugKS2VSgaP4VYPN5vHHz1p4GzAtwYfxg+D\nG7dareri4sJKoWq1ar54GKbDMoSmCd/i6upKy8vLVtdTruEtIt3WyAgm8NVg5wa3Z7O5b0Lrg1rM\nREAMh0ODjZjizc/P3wl1hCcBofzi4kKJREKtVktPnjzRcDjU8+fPLf200+loZmbGcFrG4D6fT5lM\nxrzqUGfQSN3c3NjfoY1Doziac+LxePT8+XPb5bG+GhWN8hiEAXFK4Gz6+PFjIz2hOEEGxY4JxxiF\nus/nMwOaZDJpzR67p+M4lvVCZMTc3JyOjo4kyf4dLw2QDqaY4PBsJLiR4tfBOB2F+32uB7WYGdHi\nkwZyQB2J4oEsu/HxcbVaLQvcoaMvlUpaWFhQLpfT6uqqNZJwEuAeU1unUimzJpiZmdFwODToDW4G\namnCeMBrnzx5YqNoSpRKpaLT01MrCdjlILd7PB6zvUKLSKaI1+tVNpu18HlQkrm5OdtV8QJBTT4q\nG+t2u0ZWwo4WYpXH49HJyYn5P6P8pnTjJmKHHk3sOj091ezsrDXf8XhcyWTSft/v92t+fv5e3/+D\nWswsRkoKGkCO7r29PQWDQcvpYLxMXBkLhzHwcDg0SijNFpIi+BEYkDMqrlarymQydtOcnp5qYmLC\njv/BYKDPPvtMlUpFL168MCwarR/BPYPBQIPBQLFYTNItfZJBEGSfXC5n/nS9Xs/QmL29vTuBOvv7\n+3ajP3nyREdHRzaAAY6E3DQaJwwBSLplJIKJQwjK5XL68MMPJX1uYIOdLS5KoCsTExPa2tqydNZY\nLKZGo6Ef/ehHZjqJJvF9rwe1mMmbGyX7QGMsFArK5XJaW1uzWtfn8ykYDCoQCMjtduvw8NByTWKx\nmMFVHMfUjrFYzLjGsMEwPMGxBzk9rv3AVaMDE5qh09PTO0lVNzc3NohggY1mmHASQBoiVIgb8vLy\n0gKHer2evfbz83PVajUdHh5auYJHteM4ymQyhuJcXl5qf3/fBKiSzBgdewVJhrbwWJIsT4aYCXBw\npomoY3BspZHd2dm51/f/oBbz6ELhw4Mi6TiO1tfXNTExYTarkmzyhZ0tHhhMrEb/zAKg6WJqiIEL\n0iEMAqlnKW9gkIEQAI9NTk6aJhGnUeiczWbTuvxIJGI3KgMNYDEwW3IIkTWBwlAmcAOfn98G33c6\nHWMFYkHG0CUcDttJRjkGrXX0M85kMtYUYn2AS+nq6qrt5rVazWBNpqyYmTuOY+jO+14PCppjJAxm\nC20T/zSO+1ETbI5YSQbr8Wev12uKbBo2GhvHcayxAi1gB0LVwgBhcnLSOviJiQmLUJBkkBvDklFH\n/H6/L5/PZ+JPSUZlpaRiwEJwvKQ7aAPvgd0VTw/qfbfbbYoPsHnKLRJUr6+vze0UygCpBIPBQGdn\nZwqHwzalhGtCE4qtAhg/426c9omJ/oICOnLxoVEvI2eHW4FEiWOQJgb/NTjJTLX6/b5WV1fV7Xa1\ntrZmeCtDjmAwaJgqTdT6+rpCoZBRLuGF0LihsoCGylhcuvWSxu0IKiX/hQ8ChXJ098TrGZ9l6mq8\n3y4vL3V+fm7Oo5Qo4+Pj6nQ6hgFLMiiRhQ1ezedIT4G1wKjF7+j3wJCJngEP5ng8rlgsplgsJo/H\nY70HZdl9rgdVZhCySGoS7kIEk6OrQ2R6eHgot9ttYZI0RPgbT01NGTZ6eHgoj8cjt9utdrttnA+g\nMwwLRxXKjuMolUppY2PDBjBYX7Fj9/t97e/vm4s+ITg0sZJs4kYNS5lDg4krPZFmmIaXy2U7ibAE\nAEtvNBp2etTrdbMc4LGhBuCST+4hqATTQ6Z2GDFiGt5uty3YCPsBamZQF+ijpVLJLM/ucz2onZnj\nrdvtan193dha0WhUCwsLWltb09TUlHFsV1ZWbBeenJy0RmZ9fd3M/YbDoRYWFu5k/VE3D9+F6ExP\nT0uSVldXTcWCNo4Gje4eeA1oLxgMWuO1uLhoFrWQbyDuEy4Pg25packwXpyULi4uFAqFLKhnlFdB\nhDDsPU4hJqHkJuKkBI4NtDccDu35KRm4YTGZfPz4sZVnDH5GTyW86+hbeJxnz55ZuXSf60EtZmxb\nSQrt9XpGnSwWi1bLxmIxa85w1el0Ospms3K73crlckbpjEQiKhQKCgaDVs+Gw2EbWNBUeTwe7e3t\naTAYGNsO931JBj/RvSN+pY7HVjcSiZgWkVKlUCjo7OxMyWTSKJvdbtc8KFCMsJMz3ZyYmDAUZGFh\nwU4bHJTghuBexO8ydBpl5Pl8Phv983553Zwo1WrVZFr4hoCfS7JaHU75zMyMRWlwo9znelCLmZ14\nYmLCdlF4COwMqJYh01A/0jxJMvokO/2ojzG7lCQbFHQ6HcuF9ng8hlxAeJJkzDuaQOwNwLTJ2qOz\n73Q6xoHgtTLoobbE3oCamBD4ycnJn9AW0nhR89P8IXTldWBiKMmEstxUNHCjo3HKJur40cdFLCDJ\neM3Ak5FIxE440KXRBvx9rge3mOEpIObsdru2m7FzMkTY29tTsVg0g29yQlhQ4LpbW1uqVCpGm8TO\nCpkSzvMXFxfa2NhQr9dTMBjU/v6+8Q1ubm7MZ+OHP/yh9vb2TAFDHU6DiqqZBZhOp9Vut1Wr1ezG\n2d7eVqlUMjiS0oQ0V5z/qcn39vbM6pa6F7SlXq+r2Wyq2Wyq3W5bc8wJMPqZ5XI5M4bhxGq1Whbd\nTOkBR4OMlF6vp9evXxu9FkOYfD5vrLovlCYjF5AcujVGswwCiEvz+/2qVCqan5+3nZOj7uTkRJLs\nKAyFQpqfn7cR7+TkpMLhsMUHV6tVffWrXzVGWjabNRwXM29OA4hFX/7yl7WysqL9/X3FYjETozLo\noValmSQMh5RWslIg/jMGpx7nuKb+jsVievbsmYLBoGX+1Wo1K8PIOqHeBokAC7+8vDQbBIhavFew\ncXjao0gLCAbDpKdPnxpkSlj96uqqstmshVze53pQixk65vn5uVZWVkx2HwwGjcnGYmeKl81mjVoJ\nuM+XlclkLIaBoxlWHM0iI2/YeUdHRzaIoKzBeBvMNpfLSfrck25+fv5OFAL1tiSLbYPbQZ0LS216\netr8KDqdji1UGj+sAMi/pgQA4qNmvrq6MqlTrVbT5eWl5SBizI4hDQOTcrlsJU2xWLTyg/g0HEUv\nLi7UaDS0sbFhv+t2u1UsFnV8fGwG5PeJTZMe4GLGUw1d39nZmQ0ykD7h6IMIs91uG04KZkwuCpM/\n6mRI5/i1wfa6vr62yAhSpxg8RKNRgwAvLy8tTjiVShl1NJlMmkceYerssKAm0EUh42O7xXOAIODQ\niWzMcRzNzMyYATsEI2pavDKgeIKewDCEFMTrJU6DP8OhTqVStvPjZJRIJMy9FFxeko3iM5mMpqen\nTVRxn+tB4cyjnT87BJIiRtaYi4M3Hx4e6mtf+5qNpxuNhlnbTk9P2wgW8Wqv1zN8lEiJy8tLW9wM\nQ1BUwIIDFRl10a/VajZJ5FTh6G+1Wkb5pHnqdDpKpVLKvUt4RaolyULuYQeGw2EdHR0ZOoHODw9k\nEAfqXKIY0C/+uPAUSzE0kZRwbBx4bSwsLBgnBCf9er1uLk7oBkdZeCzw0cHL+1wPamdmgfX7fa2v\nr0uSZmdnFQqF9PWvf12SzM2eXTMej5vhSiAQUCaT0crKilKplO0aMzMzRirHg5laOxAIKJFIyOfz\nKZVKaeFdvPDMzIwRhqTbHf0b3/iG3G63KpWKotGoaejgE5N2Co1VktE7UXaDyszNzVmdy8IYHx9X\nOp22Zu7i4kLpdNokXLxfEAhMGJeWlgwSxC73+vpaa2trxmUmPQAkgtLI5/NZeHwqlTLR79zcnGWm\nQH4CR4/H41pYWLDT6NGjR0qn03rx4sW9vv8HtzPzgf/whz/U+vq6pYHu7+/L6/Xq5cuXdixSu21t\nbWl2dlb9fl/ValXlcllnZ2em2Mjn82YtQDbKzc2NmSJWq1Vr1CRZHUkuCZKjly9fyuu9zaWu1WoG\ng21vb1vpASJzfX1tte/ExITl8sEjoWaHHER9i3M/Xs+E+Kyvr9tujlh3a2tL19fX2tjYUDgctloa\nX2Zi1KTbEm5nZ8dKHaadJAFQw3NCADuO7sRMK+lDGNEfHh7aFPM+14PamScmJsxHYjRjA47B9fW1\nvvKVrxgpfH5+XuPj40YaJ8LA4/FodnbWUAKgrkAgYH501H/JZNJ4Bmjm0um0GZug/IhEIuYQj7AU\nzggZItSak5OTmpyc1MzMjNXk1NhYGJDWCl/j+vparVZLw+FQ6XRaLpdLjx8/ViqVstAhPECwJYhE\nIhYdgelko9FQJpMxPJpGGXN0dm9gykgkcsciAU/mdrutTCYjt/s2bB6uC/U/Kbf1el2xWMymhfe5\nHtRiLhaLCgaDlqgECsHuBgcZVhlN0iirzOPxaHFxUbVazRhi4KYME2B8TU1NmaHK4uKigf7NZtNy\nrAm9hCtC5EMmk1G9Xr9DPGKo0ul0LEf6+PjYQntWV1dN7Qxr7ujoyPBu9H48XqvVsgEOEqbR4RFD\nC4S3xWLRSjBQC/BuSiIa2+XlZUuhvbq6MqkYUN74+Liq1apisZg5QI0aW2JojiF8IpG4NzT3oMqM\nyclJlctl09qNjY0pl8tZKUBDM7pwILfs7u6aOvnVq1daWVlRsVjU8vKySqWS+SXD8iJUJhqN6tNP\nPzVRAHTJo6MjhUIhnZycGIaMyLbVamlvb08vXrywqAakRiTGkkft9/v19u1bw4xBTY6Pj0313Ol0\nTEWOuSGYdqVSMVrnzs6OksmkyuWy4dkMRObn55VKpbS1taWFhQXF43G9fftWCwsLZmOAZQPEoXq9\nrmQyKcdxtLOzo1gspkKhIJ/Pp/39fQWDQZXLZZ2enmowGBgFYGdnR91u12Ik4I3f1zjxQS1mZPAc\niRzvCF0rlYqpMoga7nQ6ev78uSRZvRkIBDQ1NaW5uTlLq6KRo95MJBK269FkMUJHps8NANYLujE9\nPW07OSoXsksoazCKATWAx4FAdHZ21soeMOP9/X1r6sj0Rp6EgGByctJeL2SqDz74wLjRH3zwgQKB\ngJVf4XBYY2NjKhaLmp2d1dbWllKplJ0YwIcLCwv2eV9cXGh2dtbsCKABBINBk4KlUikbArHzczq+\n7/WgFjN5eYeHh5adjWr4+PjYSgyGKtjCApnxb7VaTclkUvv7++amDw8Da67Ly0vt7e0pk8lYXcyk\nEQjw4OBA6+vryuVydpOhUQRCY1iwsLBgDWQoFFI+n7cBCc+NexHNV6FQsBJqY2NDMzMz6na7ZjuG\n9VWj0dCXv/xli46DjwLlc2dnR5FIxIwmgdgYXXs8HhUKBbNJCAaDJnqAT7K/v6/p6WlLEuB9ACPi\n3ES6bCaTsfzwbrerSCSiH/zgB/f6/h/UYgaam5mZsQUGFprJZEwtgWD0y1/+sl6/fm3kHVh3kUhE\n0WhU3W5Xjx8/VrFYNFEmtaTL5dKHH35oeDB16rNnz8yc8Pnz5xY7DN2x3W7r0aNH+uSTT9TpdLSw\nsGAu+vCfS6WSNZfEEgeDQc3NzUmSaRjj8bgNKdLptKTbcTN2tvCJA4GAnU7hcFiO46hQKBg/4qOP\nPlKtVtPc3Jz9zNjYmJ4/f65oNGpq9W63q+XlZY2NjVndi8F5Nps10tL09LRev36t09NTpVIpeTwe\nVatVzc7Omivr2NiYvvKVryiXyykajSoQCOib3/zmvey5HtRibjab5qQZiUQsEwQOA00QrpksTOxd\ncf7kS6Ih4oiE7I+F7fX1tcUEwwYjv9txHIubqFQqNg6nFpZkMFUikTAi/OHh4R1bLJThw+FQm5ub\nmpycNM0eNgYMRsbGxnR0dGT2AfV63f69VquZAAHjF4/Hc8fP+uTkxBz9WegMoPDV2N7eNhvbDz74\nwOimiAYCgYBqtZqJYsfGxlQqleR2u/XmzRvrB5gAsovj3nqf60GhGdSxYMHUc8ic4vG4TcKoMykb\nRvVvoA7EfoGQQLmUZIw6vrR2u23KDhzlp6amLC0Vq4JAIGCcCbBqrAJgyDHSptYm8AYzb+BGFg+w\nnN/v183NjdLptEKhkAkI0PiBzqRSKcXj8Tuvnx1+fn7elOJoJHFJLRaLZoKDtZbH49HCwoKhI2DL\nqVTK+hMoq7FYzAxtMJ+knoZMdZ/rQe3M7JjwehmiQHb3eDymJJZkaEM4HLa6lB2DsgMGHNkmEIjG\nxsYUj8fVbrdN88YR3e/3jf/baDQMBwYH5+fPz8/t+J6dnbXAHV4XvAuQk+fPn9tuBmaMoz6vZXFx\n0WRjlFuw30AfwOITiYQhOPV6XalUSicnJ5qbm7MbJxqNmvkknnlwPiDaEwY6Gl386tUrey8ej8eM\n2+lbSJo9PDzU5OSkqW3ucz2oxQw+CpcBjjK1LhjpqL0qUFu9XjdmG8cxLDZMs7PZrN6+fWt2ruz+\n7Xbb1NtQIplyoVzBdAVPDRQm3FjFYtEEoC6Xy9QoQG2BQEA7OzuamZkxQhC499nZmQ4PD03lgdpm\ne3vbFjRhlHCqeU9kWUO6Z7IYiUTMWQlZGEJWIMazszNls1kbxVNq4Y2RSqXM4RM2IAKGQqFgr33U\nOPI+14MqM9gtXC6XTZjAcKl9B4OBYcA0K6AMxBhQXwYCAYO2EomEBoOBKaChfqKkmJqaUq1WUygU\nUjAYvKO6wPNZkh2pOC1RCkxOTt6B+6ampgw1Ga3bObZRnZCt53K5tLa2Zp4ULEosFjh5qMUxAOfU\nQK3daDR0dXVlhHqGG0CHozZn3Eyw61DPwM4bHeTAq6YU4qTCSRR05T7Xg1rMLNZqtWq45+rqqi1m\n0I2FhQUzPwyFQobdMnnLZDJyuVxKJpMqFApyHEdbW1s2DaQp4kYAV56ZmbF6MxKJGG9ieXnZBgdM\nJzEq56aD64x5ICKCTCaj2dnZO/zjSqVihizwt5eWloyHMjMzo9XVVc3NzVmJ9PLlS6tLz87O7qAS\nhE9KMpuEy8tLZTIZSZ/7L1MXo58EN2cKyM2LhzPPTVwdpVcymdT6+rqazab5WYON3+d6UIsZKiFx\nD9A5KRvYEUAiWq3WHbI7bvrk3NXrdfn9fj179sx2NqAoToBRC1t2a45iYo45guFtwGMgealWq6lW\nqxlhiJuDCSVu9+Vy2ST/7HSdTkezs7M2SgdRYdLISHp2dtZI+nAo4F+w+KrVqilo0C/Cm3j27JmZ\nPmK2E4lELG6DlCmErgyJCEWikf1xLSRuTZCq7vX932/5/HJdo0EwUDZHrVZHhatEJow2HRB9sH9F\nncxNggIF05jRP/O7cHj5+R9/Dfw7/ybJNIc0dxB3EATwJUPzZHfkd0AQ4F2MEuAhyXMjjr5P/j9o\nA6+P5+S04L+S7PcoPUb/DjSDkoXXT8NKL4N7E802C/sLQeuPXbjHM75lUoW06PLyUqVSycg/+DdP\nTk7aQoeIDxKwsbFhjK7p6WnV63Wdnp4aMgGOSugOJQpHNuPwRqNh2C/TOXb2dDqtRqNhdSZ0yF6v\nZ65B4XBYiURC6XRa+XzepnEnJyemrAFrJ0dbkp1O5+fnWl1dtRE9C5b4BzynR+VZRDVsb2/r/Pzc\n8PBut2vPBTQJrk9zS47MqF4SBfhov0LP8oWgdeTCbV6S3e2VSsWGFUBWqCiwnAL5wHEHl3pyOvBx\no8Yd9S0eRSWQ8uMmxM0D0YiGjp0OY0een9EuC8JxHEMVUFCjFJE+j7pAsU3ji4YPXna/37+zi4NS\n8H7wrqCJBd2ABIQG8eLiwmxyyT7hhgQZAh0iwwSko9/v35GBAdHRSPI673M9KGgODoAks4nlKB2V\nzxOPBuEGqigWtfjGMdVCQT0+Pm41IjvM8fGx7erBYNC8niEyUZfy2vBiZiFKssEFEWlgwiAYQItM\nDCkbgP+kzw0V0fKR5oROkUFQtVq1gQe1MeUTXAyU6UwzJRnxiRtidXVVjUZD7XbbnJJARjCU5LWB\nunBBmmIkj1HjFw3gyIUvBHc6pBf4tCgxrq6u1Ol05PV69emnn1p6ab1ety+o2WzaLnR+fq5CoWBi\nUvwkzs/Prbms1WrWUPZ6PRWLRaXTaQUCAR0fH9ti4ngNhUKmAeTxkXydnp7q4ODAPPIajYZRNSXZ\nKYDdFQQefg6eNAMNIi64kSk5Wq2WjdpJnCVtC8bd6empqtWqms2mQYBnZ2d6/fq1wZtsAggALi4u\ntLu7awgH6I8kyzZsNBo2aqfZhPD/vteD2pmz2axp6Hq9npFrgOOgPQ6HQy0tLalUKimTyRg0Fg6H\nzWFneXlZR0dHlve8trZmvskMQ9ADspiJN/B4PIrFYkZ5pNYdtc+CHgnnwefzWY2bz+f11a9+1YZA\n8JQHg4GpPcrlsoLBoKLRqBqNhsmmWBiMsweDgRl++/1+zczMqFAoaGFhwT6zarWqxcVFYw5yw0Jh\npZ7HNRXuhtfrtXF9JBKxps/r9epXfuVX7kwq8bq7uLiwcTr8FWis902belA7M5l75XL5Tozazc2N\nIpGI5f9xHPZ6PduBOdZxkAdSk27H5FBBOX4JvIS4g3bv8PDQ3IWazaa5/tC5M4kkWF6SJS3lcjmb\n7HFME+COQz8Z1IFAwOrVZrOpyclJk2lhVA7agPVBu922Mgp0Ay4HTEJODj4nbjjIRtTRGKGDU1er\nVSNwBQIBe5/wR+hfpqenFYvFjDOyv79vU1DiJd73elCLeTSo0efz3TEFHFVzwC2QbhXKkowmeXl5\nqXw+b+aKkF9w+4FEE4/HjSzPFxQKhZTJZGxaNjZ2m+4EFAXKgisSEzj88fCGBsLCgKXb7Rp5CUiP\nunxyclLBYNAGKCxyn89n+SG4juJFTW4JJHxODzzlaABpbkmWBba8vLy0x2C3ZRI5GgcRCATk9/st\ngo3nkmSlycrKiiFA9BDvez2oxQykBJUSLwzcP9kBgMVohCTZTsNUjHEx42HUxKiPqfVAJyC6083D\nxKNZIyKYETZu/ldXVyoWi7bwCcZpNBrGJaFZBNbzer12CvHagCJZ/NLnXhrwMXBWmpqasgxB6m7+\nx46OExNj+W63a5pBSpDJyUl7TLBnRAj0CAxoUKHg6I8ImAHPaMza+14PajFzXJZKJYXDYeNFUGKg\nHIlGoyqXy+YVIckWG4gDkzhJevr0qU3k6vW6OfMTlomCgzJl1JCFGpQjHjQAhTK1InU+po/4bsCz\nAOkYHx83UhISLKwTut2uTezAgh3H0fLyst3cJycnVtKMYuXj4+MqFAoGnzF0gkgfDocttoFaGZSF\nkTVID5sKnynqG3gYIEcHBwfqdruG2LDZvO/1oBbz6empURHn5+ctK+/m5kbr6+tKp9MmwMReACk+\nwTYYpWQyGWUyGVu47ObsnuDCkP+xteIGWV1dtXqx2Wwa644FwFAF/sb5+W1g/IsXL+RyuVQuly31\nam1tzeito8R8himSrLbFFUmSqU0ajYa9N9AKRvI0n9LtZgBJCOEBC0+S4d6UF1gfzM3NmaodNIcR\nO1QBhLg0pZOTk1pfX9eXvvQly0tkcvm+14NazGDGoVDIKIbgt1tbWyboHAwGZj6+vb2ts7Mz1et1\njY+PWy3YarW0u7srj8djOyFNnCQbJMRiMQUCAQv8AZ7b39+3aRrO8fl83oxj8vm8Ybp42R0fH2t3\nd1exWMycji4vL1Wr1eymw1GT4HYGI8i2PvnkE2OpZbNZq7VDoZCR/5niBQIBOz1omIEC+/2+kayI\njDs4OFCpVNLFxYWazabFNRNyiRIem1vpdpBFWfPJJ59IklmTlUolHRwc2HPeN274QS1majqmbTDl\nMB/BoQc2FzXdaJIqi4QYMOpNJnWQhuDl0gxRC/b7fYOtIpGI5ZFQhxJfzCLimGYggmwfM+7Dw0NT\nhFxcXMjr9SqVSunly5fGnR7lkYTDYWPGIc7FK4/QTQhMqMnPz8+Vy+Ws1mewg6+e4zgmYgCrJtyH\nKeeoSypTv5mZGY2Pj5sXHacItgOY29AAYyf83t//38Qi+mW5IBphtI2BH7yAcDhs2C3NIYhHuVw2\nmKtararf7+v4+Nh4DtwAeNVNT09bCYIdLoqOwWCgWq1mkBicYgIy5+bm5PV67TXxWrEWw9sC7jKs\nPG4iyot0Om0GhfAbINkD7bndbsORWUzU16P84VEkBSswSFbn5+daXFy00E8kY7FYzD5L4iVojK+u\nrowJB8pBzgxcDuwYcD9NpVL3+v4f1GJGutRoNIxEnsvl5DiOer2ednd3tbe3Z8Yo5XJZ09PTRiyS\nZCVJt9s1N856vW5ec7u7uzo9PTWXecj2yPBh0JEXGAqFdHR0ZBitJO3v71uwPFNAdIo0ZS6XSycn\nJyY+bTab2trauiNIPTk5MaFtp9NRMpnU2NiYNjY21Gw2ValUlM/ntb+/bylUo3UplNNcLqdWq6Wd\nnR2dnZ1pc3NTLpdLe3t76na7CgQCVqbhkAqPhKQCHh+8GqPGUqmks7Mzy5U5Pz+3tIKTkxM1m02V\ny2W1Wi19/PHH9/v+7/Xbv2QXcF8LeQAAIABJREFUzR4exFNTU3ry5InBXuCoCFfn5+eVz+eNczA9\nPa10Oq0PP/zQwnpIWUKgOkqFRKDJhXG51+s1yb8k81pjV2OiJ8nQA4xeuGlIfRplAI6G+Yw68Uej\nUcNyb25u9NWvflXX19daXl42MStIChiy2+02kS22WslkUsViUclk0pxIUaYggZqfn7ebVJKJASBP\nob6em5uz7wEyFwgMwgXeM83pFxPAkQtegySzvYIDQFME3gpsBAsNxfMoF4HmCcwZCy60bAxHgJyA\n9dhlqR8pd3DKpKECwup0OuYkii8cXAlwXZzzwZmpvXlfqL3RPUoySOz4+PgOTEjkMX0A/BIWOT7J\n9AB8jrxOOBU0bM1m02i23Bh4QeMfTSMMG5GQIsbvo+Yx73s9uMXMhImAx2QyaWNeosPI6wsEAsat\noFFkx6KxQptXr9fNy5m6mYGKJKs3WYz8PKqM0Vo0Ho/blC+VSikYDCoUCplHxuTkpCTZ5A5eBLxg\n+ByRSMQYauSLkNDKa5qamtLy8rIZOJIuQI0/NjZm1gS4guKjHAwG7fPD0gCzGj4bzA8ZWUuyxhYU\nA/iSqerU1JQx5xDvZrNZM7l53+tBLWZUx/v7+6a88Hq9isVimp2dValU0sTEhDUwsNLAP6mdZ2Zm\nDC8ebXS63a4Rfvb3981BH2hrdnbWuL7pdNrsv/g7POVyuZzS6bRisZjq9bqZIlLvM7yhFs5kMpZw\n1ev1VC6XjfIJ2wxsmGaWSRzj50qloouLC5Nf3dzcaHZ2Vufn5za5I5OERnU08/rs7EwzMzNWzzPY\nwdsjGAyaQQ5jfiai1NJ8hmdnZ7YxoGqnhLrP9aAWM11zMBhUqVTS9PS0Xr16Zb5rHHG7u7sKhULG\ndwa+ikQiarVa5rrZaDQUj8f18ccf25cFiWh+fl6JRMI6d1AQiDflctnQA2C+fD4vt9utsbExffbZ\nZ1a/MlZm54L4z5QR0xXKgGw2q83NTQtgZwIXj8dtwog3R6PR0M7OjkVcwB1eXFw0828yXvDBy+Vy\nRpTis2m1WkZzRV+I7UIul7PSBlgSPw98peGXc0KA0OCctLGxce8YiAfVAKK4JqMPHLPdbuv4+NjU\nEORIj4ZEVqtV4zg7jmMSHoLSfT6fuYTe3Nyo1Wqp3W7bGNrtdiufz1tJ0Wq1LJEUyf5wODTDl4uL\nCxOcwm2AfHN2dqaJiQnlcjlNTU2pWCzaogc7x1IWOA6OtfS5nQGLw+VyGT7caDTk9XpVLBZNUtZu\nt80FCvEpGX4zMzM6OTkxuzM+E0n2mvELgQ2HvAqVN8aRYPDQQSXZTUb61H2uB7WY4UZMTU1pbW1N\n4+PjWltbk9vtNnYbx6fjOGbXBSoACQeHIzgPXq9X9XrdWGoQ/pmq4TyEIjsSiWhlZcWOek4MSoPh\ncKgnT57o8vJSU1NTSiaTxilJp9N3aJrgxG63W7Ozs5JkKAG/F4/HVa1W7QTAwDudTqvT6WhlZcVs\nsYAvYe7BJqRWT6VSJmAIhUJKJpOWkQK7DmEtpCq42dItooQFGB56P95XgIwQ2sP7wPzxfa8HVWbA\nxBpt+JjYkTON/gzvuFErW6ijfOEnJydGGR098uHtYisFod/tduvp06fm6sPQAv4DAxTq3kQiYTIj\nXIS4MUYVKTMzM/Z71Wr1Tvg8ODnKE0Si0WjUYDsITOQLor2TZIjI1dWVMpmMGo2GWZr5/X5dX18r\nEAhoOBwaZIcaHGN0Biaw7paWlswZNRAIWMQF8iwCffDgA68m+/B9rwe1M2NWwk7QbDbtAzw4ODC+\nAIudYxOaKEMSSUaIabfbNgABqgqHw6rX68ZSQ28HjEXnD3yH7g7ZPiNkmHTU4aOyo/Pzc2O9jToj\n+f1+M1ocjXSQZCPhyclJ7e3t3RHugpD0ej0b6XMjnZ6eWjAPtXI6nbYoCoZDg8HADBYh5jebTauj\nJyYmTBB7eHio5eVlG7nzGY5KwyYnJy2ldm5uzvg073s9qJ0ZlhpxAwg7O52ODTcQoiI8pdMGMoL6\neHPzeWA8jkgTExNaXFy0o5FmDpK79LmqBYdLSSZClW6nbhCe2JE47jFIgUAPaoC3HHYCOGfCgWCB\nwKkulUq2o5Limkql7nhiSDJzcAQCSLT4Wfge9BqBQMC8m8fHx41uOhwO5ff7zeuOTQJKZ71et5MM\n/BmO9MzMjPx+v66urkwA+77Xg1rMdN6jvGPqQ9h0kH9SqZQFzCCNL5VKmpmZsVICo5fR1KidnR3F\n43GLJKMOZeiAnwWG4Dc3N5aOyuID14aXcHl5aUrxZrNpX770eYD81NSUlQykTZHKivtoMBjU1NSU\n0UHxQeZxGJhEIhHDyFdWVgxVgNPMIsR/b1TOVKlU7Abxer3WUDOQYXA0iuuDtkiybEWwdkS32Dzc\n53pQizkYDBoODLeXZsbr9arVatk07vT0VEdHRwYfLS4u2gdaLBZNxsOiwpQc8/CJiQklEgmdnJxY\nXY7zJfUiuzn0RqZ3k5OTqlarlojV6/WswQQ7hhzFOPr6+lqFQsGwaHK6GVAwycRDA1X4xcWF0UbZ\nYVF048vM54UxJDg04UKSjBA1NTWlSqVi+DHOSqhLKIcuLi6MZsuGwusD36d5ZDD0haXtyMViubq6\n0vz8vCYmJrS+vi63263l5WXza/Z4PHd4GjDMUHJ8/etft90OhQS7h3R7AsA1JlDn/Pxcy8vLVluv\nra2ZOTmcDRY03m6JRMIifmlc4TKDV7OzgWOn02l7HXA2er2eQWpAdyAvqFlOT0/l8/m0urqqo6Mj\nE/USydZsNjU7O6ujoyNls1mFQiE9efJEwWDQnisSiaharRqKAxeDphnVi9vt1tLSkg1jPvjgAx0c\nHFgoKI06rvsul0vxeFzf+MY37pVr8qAWM7ZPNFfhcFjNZlPT09MmmaLBwguZqSDddrlc1tXVlebm\n5sy9EoIQnGS4uOVy2WAm3DCBr3K5nFKplLrdrkqlktFGLy8vzRosn8+bsJUdENplLpczce7Y2Jjy\n+bwWFhZUKpXMxDwQCOjk5MRMHrkhvV6vIRy4I0UiEZVKJVWrVR0dHZkDKgy8ZDKpXC6nwWCg3d1d\nPX36VMVi0XB6ScbjwBxyenra2Hng6dAEsOydmJjQ9773PaOdSrelCo002syzszN99tln9/r+H9Ri\nTiQSVvPBUkP1DOwD3IW0Ci8I4tRcLpdOT0+1uLiodruthYUFY6r1+31dXl7agCGZTCocDt+xlmI3\nX1hYULFYVDgcViqVshExvsl4sGGeAqEIBUg0GjUJ0unpqUUtXF7eBkY+ffrURuWkn9JYYpNAA4ry\ngxKBaOXRmwXl93A4NO8RanpcjdA8RqNRm/ThsM8p8eMsQozWm82mMQkZqLA7O45j9NW//Mu/fO/v\n/0HVzNVqVSsrK0omk7ag0dhBkez3+8rlcvJ6vTo+PtbExIQZIQJrYbtVLpdVKBR0cHBg0BOlAx7F\n1Isc2TDbIN5D4u/3+6Ya4XE46m9ubrSysmKex+Sc1Go1VatVQz3Ia5mZmdH29rY1WWNjt8lUNF/U\n2tgdQEzi1EBlg9kLcWlTU1MqlUoWR8GElIkn3nJAe3wOkuwzODk5MYSEBhMYFIQIrBoGHqqdL5Qm\nIxeulT9uV8vkCZiNThwHfEkWbEngDOyyTqej+fl5MzYhVAeH+Gq1alNFhhHHx8dmbTU2NmZQIIGX\nTP7Q1EH6R34EZMjNR1BlNpvVxcWF3r59a6GR+XzecHIiJigBYMUVCgXDh4HwwMIvLi5MZAvCglxs\nNAweigC8ZZAeDHLA1JlcEqrJaYZRZLfbNVVMKBTS/v6+Kbm/8JobuTDuZoExFmYKxSSPhYd9bDab\nVaFQMJbY0dGR7YLz8/N3DABxr6fpwUS72WzaUCWdThtNkhuGcTkj6VarpcXFRaM9RqNRJRIJq3XJ\nkV5eXjZYa39/X36/X0tLS2o2m6ZZBBFZWlqS2+1WJpOxGGU4IixcGkTG79Jtc8fQ5/LyUsViUbFY\nzFAdRvqpVEqNRsMmevw+pw8bxeXlpQ4ODsxQEfiQTQXPasoxMPovBK0jF2Z/LMirqyu9fv1a7XZb\ntVpN7XZbhUJBH3/8sRqNhg4ODmxadXx8bOSizz77zESep6enevXqlUUYYLd1dnZ2J2H07OxMOzs7\nkm5Pgu9///vGt2AAcnV1pe3tbZ2entoUjxICJQgeGtiG5XI5vX37Vjs7O5YNPj09re3tbVvQQHtI\nsKrVqnkhU/rQoELT/O53v2ufGdwLl8ulzz77zDSG/B2+HYeHhwYLUo5cXV2Z9VexWDTI7eTkxEqo\nVqtljSoN39HRkXk6X19fq9ls3ivQUnpgixk+hN/vt2OWXQq5/nA4VDablcfj0ezsrFkMQGg/OjpS\nOBzW+fm5jVifPHmivb09tVoto0MyhKhUKlbPfulLX5IkFQoF89CYnp42jSBc4UgkomfPnqnRaFhN\n++bNG8OKMTinMVxcXJTf7zfp/5s3b4xjsbOzI7/fr2g0qmazadzqdDpt4TrsypQC0EjhekxOTlpJ\n8PjxY8v6wxeDMiOVSlkkca/XUzwetyaU5pWdn/BQGry5ubk7TkfAcfQgTFLvcz2oxYyvBBHAPp/P\nlL9LS0sWKLO8vGyYssfjMayUSR2cW8xKIColEomfSKaanJw0mAuVy9OnTw3vPjs7UyqVskYHQ/BR\nBXU4HNbs7KyJQFdWVvTo0SMjH7lcLgUCAc3Pz5tuDwd8vDHwwmC4g8qFcojnCwaDZh8wNTWlpaUl\nS30ilJ6JIPyL6elpBYNB5fP5O8oUYtUo3UBkoBL4/X5TpCC7wqgRbL5UKsnv98vn833Bmhu9SDIa\nNVnJ5/OWLgo68e1vf9tU2C6XS9VqVQcHB8rn80Y2b7VaOjw8lM/n08HBgR3T1M2tVst2tVKppEql\noq2tLcvHps6mQYKeOsqjYCGAlGBsyASuXq/b85ycnBiWHAgE9IMf/MAQCfjKcI6Pjo60u7urfr9v\nHGHyChnMYBqDXzJKm/39fZVKJfN1JpKZ045dmoiM09NTxWIxHRwc2OdM8w1LEZ40wmBU2sB1NK7f\n//737/X9P6jFTI1brVYVjUaVz+eNrgmZBXUwC+Ht27d27HLkezwes2O9urrSzMyMDg4OVCwWTegq\nfW62CDw1NTWlTz/9VIeHh7q4uFAulzNXfrBoFCyBQMCmYjc3N8rlcsrlcjo6OlK1Wr0zaIHWyciZ\nm67T6diNJ0lv3761G6fT6ajT6eji4kKbm5uqVCqWaY21LBAheDEY+sTEhOkpOUVevXolSaZHhFDv\ncrm0u7trDa7P5zNVCaNykJnT01MrrSBnwZRjMHOf60ENTR4/fmxqjUKhYEc1/OXV1VV5vV4bCkxP\nT+vZs2fGGkun00bhjMViRuDnJqArJ1RmbW1NvV5PmUzGFCcffPCBTbqSyaQhDq1WS8vLyyoWi1pa\nWtLr16/NCJ2yaGFhwRbS5uammZYD1yWTSYsVxn6rUqlY6CVO9r/2a79mo2LMDj/88EML6gF9gP22\ntLSkTqej5eVlY9oNBgPNzMwYwvLixQsVCgXNzc2ZFArL3dXVVfOwo3Q7Pj42y6+nT5+qWq3acIpp\n57Nnz0w4IUnf/OY39ebNm/f+/h/Uznxzc2OLh8anWq3K7/eb1VS5XDZuAtpASUZu53fOz88Nt4bF\nViwWdXx8rEKhoJubG+3u7trud35+buQheBEoPzY3Nw1/vrm50f7+vi4vL5VMJtVqtcxhnuFNrVZT\nMBjUzc2Njo6ODFLM5XKGV5+enqpQKCgajRpa4Pf75TiONjc3jTVYKBQMuYHNB1LCZ7C3t6fT01O9\nfftWzWZTm5ubmpycVLFYNFuFUqlkCxsODBBfo9GwxCtOIHoPRuBMD4vFovFEjo6OJEmlUkm1Wk3f\n/va37/X9P6idGcVEv9+35gycl24fD2MmZGCmQFyzs7OanZ01kxPk/B6PR+l0WoVCwcbTsVhMMzMz\nZiSDOXksFlMul1MikVC1WtXS0pJ96YPBQOl02iaUcDFisZjpEqmlyfPGrZ5pWiwWM70jzSlmLnNz\ncwYxYhkQjUY1Oztr+dnRaFS7u7uam5tTMpk0u4Dp6Wnl83nNzs7K6/VqfX3dfEGWlpZsAVOWAOHN\nz8+r0WhYYzwcDlWpVLS+vm6mNo7jyO/3KxAIWI1Mg45d7tjYmJUz73M9qJ0ZWAquAWqGUaMRamIW\nKcB+OByW1+s1iy2mh5VKRfF4XIeHh+r1elpYWLhTl25ubt5p4mq1mnZ2dmzYkc1mLd0KtOHi4kKB\nQED1el29Xs92e2ptScbhuLi4UDabtckaihB4FESUnZ6eyu1227+53W6zLaBmZeSO4xAJqthpcVpw\nU9EE0izSkEoylALMmSkfhKy1tTV7L0RmAM3d3NxYwgDWXf1+/4tx9ujFlGlyclLb29vyeDzWFKK+\nANGglsbdvlKpmLKY8gG3+L29PSUSCZ2fn6tcLtuX1uv1TDSKIhrLglH3TTjVqKpvbm7ucKYxZYzF\nYlY/klhFedRut3VwcGCcajgcmJJzE5I6heMQpt69Xs8Yb8QpwwVhetnpdNRoNMyilgYaKic4OJKu\ns7MzS7Nlp+ZxuNlG3aBwCcW0Ef60JJ2cnKhSqdzr+39QixkpEl8cDpTQEofDoRKJhO2O8XjcvNU4\nPvFcwwJgenraQH1qV/jGICSw35Dej8qQwKkRmDIClmTavsnJSUszHR8ft+QoiEBYDIDCILLFX1n6\n3GwctTf5h5OTk5qfn7emdTTInlKKMT4nEnCfJEttZefv9XqmXIfYBE8D2RlCYqaeOB2NKmL4bmq1\nmo3L7xvQ86BqZmC4wWCgDz74QNJtAI/L5bJFzFCA4UM0Gr0TmgO1c25uzhoVFhYEJWRVdPHHx8dy\nu9168eKFscvYcbrdrubn541sj9KCBqnf72t9fd0W6XA41MzMjE5PTzU7O2uk95OTkztyJALlWSzo\n76Bk8viStLGxoYmJCQWDQWUyGR0eHiqRSMjv9xu9c3x8XIlEQgcHBwqHw3K5XHrx4oUkGSkJKwYY\nc8Cc6Ckpg9g8UOPwOpB8wWZE5Q2py+Px6C/+4i/e+/t/UIuZ6RwoAFyGUTX1zc2NHZcYrqCXa7fb\nRg2F54v+T5Idx9SSRDfA1Ds+Pr5z7I96O8O4g4W3v79vo/RqtWokHpz6GS6Ew+E7Tkkc5d/5znf0\n+PFjs+2tVqtKJBKSbssAEgAwICdFitIF05ZarWboiSTjdIRCIf3whz9UJpMxfJu+YNSknShliFpX\nV1cql8sqFos2FqfcoT/BWQlDSIxgNjc37/X9P6gy4/r6Wvl83tx6+OJZSOjrVlZWDO1gp8QEBTSB\nIQJaPlx/qAfBUKFTYrJCuCU3CZTPUddPThB2O3b7vb09s8qFXzwYDMxckOFMt9tVJpORx+Mx+uX5\n+bnZC1CmsNtDC8UOjIYNZiD5KLD8IPUjKGAhUw8Tq4zR+dbWlinSuemwHBhtaGu1mrlCUbbw+cHK\nu8/1oBZzMBjU0tKSfD6f6fskWWkBTvvmzRu5XC5tb2+bnOfq6kqVSsUceZD9Q9ZnTM3OTPOYyWSM\nD3J+fq5UKiW/32/oCPAbbDUGL1BFaQLdbreePHliE0NeFzug4zjK5/OGzDDRQyw6NzdnYTfcMBMT\nE/aaqYu9Xq9mZ2etlGi327bAaCoLhYJFGEtSKpVSOBw2mRNJsdy0wWBQ5XJZ8XjcbH8XFxeN7skN\nm8lk7DsJh8Nqt9vKZrNG6L8PLCc9sDLj7OxMsVhMS0tL2tjYkMfjUTabNSzz0aNH8ng8BrcNBgMd\nHByY3B7WltfrtUUtyerS8fFxzc3NGZ8Zgerq6qp5PlMPhsNha/4kmVbQ5XJpYmJC6XTaHDUJkCRy\n+PDwUF6v16RbDFdoEhG5UufjWMTrJYSSm7pWq8nr9RqRCMcmdkPHccy+tt/vWxIXTkqQkyBt4ZvH\ne2y32xbySXPIzs/PwPGAtcfzlkolyxR88eKFNjY23vv7f1A7s8vlMhUzihBJpm4eLTXAcVlk7Ewk\nn2IcMyppwgT8/PzcRrmEl8diMRvM4I1RKpUswxuCPibiPOfExIQNccCMYawB/TFZZNwO1ZPoCRor\npmuZTMbKIZfLpaWlJXMukmSliyRLXWUcj3H6+Pi49Rtkn1DOwKaDcgtXA1PGfr9vblIQpnD+9Pv9\nBllCaIJNSNP8vteDWsykgfp8PpviUTdDCSV1aVRS5PP5VC6XdXFxYWbhg8HARrHslOzQNzc3Ojg4\nMPd3bK5gjnG800TijUz9PnrzXFxcaHl52aZw9XpdpVLJeNMQcQaDgQqFwh0nJkSnHOUslmazKb/f\nr4uLCxUKBV1eXt5JkJVkcjE4x5CsEPQiFIAqe3Z2ZiUPXiBXV1dmAIOdGa8D7gfvncELjSjREHC9\ny+WyiRve9/qFLWbHcf4Px3HKjuN8OvJ3Ecdx/sxxnG3Hcf614zihkX/7rx3H2XEcZ9NxnH8w8vdf\ncRzn03f/9j/+rOdMJBIWcoMCotvt3unAsZylAWMHi0QiFuIIjssuTvzZqLn30tKSDT/g8DKqxaEI\nohKDA0nWmJGP53K57gxo4JZQj3u9XiP8uFwuPXv2zLDcUaOW6+trw8cZdYNf4+9BzAQ3KRNJSiaU\nKQTJw7CDsz2aQoXbfzQatbwXyjS425CVZmZmjKjFoudmSafTNuj6ZW4A/09J/86P/d1/JenPhsPh\nmqQ/f/f/5TjOE0n/gaQn737nf3FA/aXfl/Tbw+FwVdKq4zg//ph2wcvAV4JFjHIYSGpvb09XV1c6\nPz/Xo0ePVKlUrNtGuDoYDEzmM6oiJpEUtcX8/LyZMlYqFdvNGE1Xq1VTVJA/QqgjUqnz83OD1RzH\nsUVHatbr169tKvejH/3Idv7RsHeGF4PBQL1ez9yOGB7F43EbnDDVxHKX9K1oNKqtrS1DZEabUxQl\nfC04J0HColSChE9J02w2VSwWTUYViUTU7Xa1ubmpTqdjXnm4mt7n+oUt5uFw+P9Jav7YX/+WpD98\n9+c/lPTvvvvzP5T0R8Ph8Go4HOYk7Ur6muM4aUn+4XD4vXc/989HfucnLjR+kMHBM9l1KC2I7yVk\nkp0CtTBEelAIBgXYuNL1X11d2dEbCAQsdpcpIDcJRzzdvSSDzAjhOTo6Mg0ftFDCHqlhR4Mqg8Gg\nrq+vVavVDHo7OjpSvV63RpHnoLZH5FssFjU+Pm78C25U5E1YI9TrdU1OTmpnZ0fX19eWzgrGDk4O\ndk3utyQjHAFPIh8DimPIgxSMEuk+1982mpEcDofld38uS0q++3NG0l+N/FxeUlbS1bs/cxXe/f1P\nveD/MqHiiAOKgg6ayWQ0Njam/f19410gCWKMzaiY+nI07J2Fge/z2dmZmZr4fD4lEglDDtgNuQGw\nOQCmSiQSloLKLriwsKB6va6rqyuTGfF7oxxo9HvY2wKpUTKQ5YKu0ev1an5+3hyf4EP3+33L2c5m\nszYGHx8fN61kIpEw+RWnCRM/FienDTa2fO6Y5BB+hESMTEF6kftc/8agueFwOHQcZ/g3+ZhwgMvl\nsvL5vGVoY1RI/cdu+8knnxhJhklXpVLRzs6ONVkzMzPGuYD4D0qCOpoc7W63a6bbYNHLy8t6+/at\npqenrYSA1skE7ujoSKlUyqA0jF+wGKDO3tra0uPHjw2XxYeDgM61tTVThayvrxuZp1QqaXl52WRe\n1Kh4YuCev7u7K7fbrZ2dHaXTadVqNRukXF5eWoNGTMSoOSJMQEItGf/n83lNTk6q2WxqZWXFXlM0\nGlWj0bAJZiqVsmzt973+thdz2XGc1HA4LL0rIaBJFSTNjvzcjG535MK7P4/+/U91pP7zP/9zO47h\n/i4sLBhBB89hFtTi4qLliaRSKRUKBblcLlNZBwIBOY6jpaUla9Aw+2ZHZpoH3CbJoLtOp6OzszM9\nevTIGh/4C8QrYAMbCAQMWaAk+cpXvmJm3M1mUx9++KFZbMF/6PV6knRnyPPBBx/I7XbbTsv7xnUT\njLjb7dqAp1AomJTq8ePH8nq9+s3f/E3zf6MJhBiEskSSlTRQa/GI5jl9Pp9pM1dWVu6MsA8ODlQo\nFHR6emon4Ptef9uL+U8k/WNJ33r333858vf/wnGcf6bbMmJV0vfe7d6njuN8TdL3JP2Hkv6nn/bg\nT58+NWI4I9P9/X396q/+qqEbyeRtZYPl7eHhodLptPb29swK9u3btzawyGazOjg4MOLR4eGhJYxe\nXV2Z0oM6s1qtam5uToeHhzo9PbVQ9lHD7k6no0qlYsc5BouO4xh0ODU1pd3dXYMPWbSSzCkUzjY7\nIST+4+NjRSIRbWxsaG5uTs1mU4VCwRphJEyM88vlsvGNT09PVSwW9fTpU21sbFisXKvVUiaTMZ84\n8GVu6kajoUgkYv0HFmg852Aw0OHhoQKBgPUy/X5fCwsLZgN8n4GJ9IuF5v5I0nclPXIc59hxnP9Y\n0n8n6Tcdx9mW9Bvv/r+Gw+GGpD+WtCHpX0n6neHnt+nvSPrfJe1I2h0Oh//vT3tOpEDBYNDsqPB+\nkGR16tjYmK6urvTkyRNtb29blANcBkbOp6enRjQiv2M4HJoOT5I1Z8Fg0LzlKEcw9Qa6op5Fmg+S\n4fF4lEqlzA63VqvpzZs35ssxmgWSSCQMv8atHjsBFgh8Z0br8XhcPp/PNIWUNzSXTPbi8bjloOBW\nStIsDTTwJE6pEP5h6t3c3CgYDN5R8IC0YK07GAyUSPz/7L1ZaKx9nt/3LS0llWpXrSqptEvnvDrL\n291Dz9uDjQcTE8LcJJCLkItAcO587YDN3BtMIJAJODdxArnwQMDBZGCmJ8MwNtP99uJ+l7NKOtpK\nqr1U+y6VVJULvZ/f+6g9Y4cjjz0R7wNNn1fnaKv6P//n9/+ucfl8PmWzWa2trcnr9VqG88def2U7\n82Qy+a//kr/6O3/Jv/8XpEKkAAAgAElEQVRHkv7RX/DxLyS9+P/yPUmjZM7FBYzDAW0ytOvr16/1\n8uVLFQoFJZNJG1EoaUc2eXV1ZTjtxsaGldlId1BaJBJRtVq1TAjiB549e6aLiwujsEOhkImgSqWS\npZOCgZNl7KwWW15eNikqCxK4jYMlqUW0PPG7E9sFdY1eGbqZ2d/tdlsONQcyyJB4PK5Wq6VoNKp6\nva5UKmWZG7VaTdFo1HyB6L3Bop1tt51OR/F4XKVSSV6v955YqlqtKhKJPHgxPyoGEAKEkzOSROJX\n0QtwWKvX64rH41pcXDQXNrsIcBLB4lNTU6YppimVXR9bPtASckzczPRjE77S6/Vs12s0GrazStLh\n4aGV9bAIsOXz+chZ0UWzuKCKGaHI7CDls1wua2pq6l5MADUXPCFGo5HBkuzwvDabm5tGHuE5lGQz\nP85ybn7+HmY1m83a+xSLxdTv9+/1dCNs+tjrUS1mZJ9ER7G4sL+DFXMSJ+VzPB6blvnq6kqLi4u2\nONxut9msIEui0ajcbrcd4GD80A47/W2YS/kZwK4hINjBOp2OksmkVT7wu5C5TKoR7B6VEcTDjsdj\n9ft9sx5dXV3ZWBUMBo2sYffkBkfoRKUyvw8kBg4dbuzZ2VlziDtvimw2q4uLCytIgtZHvcjrOjMz\no42NDVMiwiAS6viQ61EtZpqclpeXLREehRi7BztWKpUy7S//hgUD89dsNg2V4AZIJBL29WZnZ21h\nMWYgsCGhCC0DTmqaq3BZIORnxk6n04YdkwwE3Xx5eSmPx2Oh6HSukC6EfYuRJhAIKJFIqFAoaHl5\n2TTctEZxWHOKjqD/WeBUBPO9xuOx5V8vL99B/pNvqpKXl5ftKQEbiSOb6AcO5oS+o88gifQh16OS\ngHY6HZvTstmsUqmUVY5BB0Nr1+t1K01fX183NVun07G4rsFgYLsROcawWlNTU8pms2ZmZS4HLsvl\nctrd3dXc3Jzevn2rjY0NY/D29vZUKpVsFkXPUavVrEJhMBiYTqTf75sPj2oLZmQoduSsHEBdLpfK\n5fI9qvv29lYnJyf3VHtgzwTE4MbB2BuJRLS/v286DmqM2+22Xrx4YX3aMH2RSESDwUD7+/va2dmR\nJMvSwPZFnjQoDKVJb968+Xe8w//261HtzHjiwEKhndl5ms2mzWgLCwtGHzN7NptN0/zOzs5axNT0\n9LQ5mUulksUMcLDDxu/1erW/v29aDoLE0Waww/NGYhsKh8Omcut0OhbEyMGOA1w8HrfdlO/HyMDv\nj5WfAG9cLshD+XeYX/1+v+r1+j2yAzaOzwXFYeHFYrF7+mxn5jImhMXFRaO+y+WyWc1wkCN4Ojk5\nMZ/jQw2tj2ox82il7pcmJk7+FMPzJlCHS8gh1cFUg83NzdnXQJ8BHc6bwmGITOInT54omUyaXmNp\nacnmZsgFDjrOxiXknEg6KcHB5ErOMbMuYwjqN8LT0TswErBrLy4uajweG0qC+o8FOz8/b/gvFLfL\n5TKordfrmQAJTyMtXOTRjcdju7HRiqOwu7q6Mve5JNNQJ5NJlctlk9A+5HpUixk70eXlpZaXl+3F\nQgpJbFQsFlM+n9fLly8tr5mTuNvtVjQaVTAYVCQSUSwWUygUMmf2eDxWOp02RwU7GMlEjUbD0jOZ\nn2OxmNrttkVx1Wq1e9AVB0aiuQh+JPPOSYwUCgWzICGjBIUIhUKKx+PmqKGbOxKJKJvNaji86wfP\nZDLWeY27xe12m7OEHZKDH4vWaTLw+XzG8i0sLBgCBG6NiAkNCF5DJ2LBpsOZYm1t7UHv/6NazM7O\nEsQ29XrddlL8geSnMR82Gg0TyvOG4apmZ0NQTiALmmAwWrfbbcgBc6Pf79fp6alCoZCWlpaMOUyn\n0wYjTk1Nyev1GiMnyYwEkuxpIn3rxQsEAjbjczAlJkGS5TUT+8UNi1E2mUya4o2DGU8qxhiETcSW\nrays2BMNdAVyidZbcH1nsSWtsox4S0tLikajtgF4vV7bwR8qA31UB0BO9lNTU1pZWdHCwoKePn1q\nZEmpVJLP57PK20AgcE955na7dX5+rlgsZuMKFiUOX0tLS6YDBtpaWFiQy+Uy79z09LQ2Njbk8/kM\ntZC+zUhutVpaWVkx5zb5d9PT03bydyIm2LUWFhaMjVxZWbF5tt1uW8p/IBDQ7u6u9buUy2UtLi7q\n5OTEdBg0yeKUWV5etqaAbrer1dVVUxAyD1cqFfNSUkzE68c5xO12m0IunU4rGo3q8vLSkCSXy6Xp\n6WmtrKwYjAgj6na7re/lY69HtTMDtQUCAdMlv3v37l6xZKPRULPZtEXxh3/4h5YOKt3Be+VyWd1u\nV7/85S/NOMphi0c+Viko4Uajof39fdXrdWUyGZ2cnBjsdX5+brgz4wKkDa5xOlempqZUKpV0dnam\ny8tLffjwQaenp5ZzjH+v1WopEAioXC5rOBzqxz/+sVUQn52d6csvv9TBwYEikYhpTKLRqBEndL5c\nXl7aCEQEAcgGehVm2mq1ahQ/6AQuF3Z4DoAHBweW5j8cDg09arfbyuVy+vLLL01wBUZ+fn7+oPf/\nUS3m0WhkgS/Mz8x7kBzEUHH4onrA7/db1ACGVqq8oHbb7bbNhGRnEMvKLI7fDf0GGg4UdWCr4MeQ\nC/jpSqWS4df9fl/xeNyqkZ2MGrJT6e4g+fTpU0sInZqaUiqVktfrVaFQMHsVMBomWwgTEB/w36ur\nKxPz86Qg+UiSZV7ARIIiMZ6hNaHcB+0yBmHatIbDoQ4ODuwGwcn+sdejWsxOCSb+OmIBgMSwQaFR\nlmQkAxemTN40Sab8KhQKJhuFlga7hibnjebmcYqKCBwEJ2Z2BE3wer2mXgsGg9ab1+l0LHgRJlOS\nsZcgF6QulUole/xj2r2+vrYcPHyHtHNhdOXsACwIFd5oNIxAcjbJgkrgwOE1B8sHvcBWRWuX9O1N\ngaAfrcjHXo9qZg4EApaMeX5+roWFBS0vLxv2urW1ZUZR5Jvs4pzWYbxY3OCn6HK///3vq9Vq6erq\nynKSWaxIIsPhsImDJJlSj7LI5eVlg/4ikYjOzs4sYyKRSBjpwgzNgk+n05YNcnh4aMlC4XBYxWJR\nU1NTRlm7XC4tLi5qaWnJ8u5wXaMbATdGw4IUFVES1RhIUr1er9bX1yXJFHsIjDY3Nw1LxmhATh89\nLYiYiFzg6YGQf25uTn/8x3/80e//o9qZOYWfn59reXnZMF1knThD0DjMz89rd3fXRhOCu5PJpJ4/\nf24RWW6327QQ1WpV6+vrikQiJtwH6QBpQG9wfn5u6USkzeP0xrkNxY2ajViDvb09pdNpM4HOz8/b\nfHtwcGC1wdQo4I6GQCH0nHRNdl4IJBKXkK5Go1F74kh3Yn+oe9qv5ufnrSgUhR3RDDwF0GvzNch0\n5r0BwuTwvLu7q0gkYibkh1yPamfu9/sGf/3Zn/2Zfvu3f1vtdlvxeFzn5+eWRN9qtfTixQv9+Z//\nua6vr/Xpp59a6MnU1JS++uorcx9nMhnVajWrAh6Px/r6668VCoV0cXFhMyewFegH83csFtNPfvIT\na1Uir65YLBpEd35+rq2tLZ2eniocDqtcLqtWq5nYnhDETqejSCQij8ejDx8+2LzKPJ9MJs3kinGV\nCgaqz1ZXV1WtVuXxeKzMMpvNKhKJWMoS54U/+7M/06effqpisaijoyOzoa2vr1tGNTY0FjPoDTsu\nVPft7a3VGhPpdXR0pGw2q1qtpp2dnQclgEqS66FWlb8ul8vlmvz9v//3TdV2fn6u1dVVtVotJZNJ\nQzM4fIHBvn79Wmtra3K5XLq5udFwOFShUNDu7q76/b4SiYQymYxpbweDgeG7xNeGw2GbaZkjMco6\nO7tpPV1fX1cul9PNzY22trZ0dnZmhgGqG77++muzMaH7WFm5c5Dxc6RSKYMbh8OhhTs6c6pJ0/+t\n3/otZbNZ+Xw+3dzcmEEVCSp+RZJIA4GAstmsksmkoRJTU1NqNpsGza2srBiRA75MItLh4aHS6bS9\nXq1WS6urq6bDoDSTpyXk0D/+x/9Yk8nE9e94u//C61HtzLOzs5YFt76+boczxPDMd5VKxSJkR6OR\nfa7X67VETEgVpIuBQMDqFNBVBINBLS4uKpvNajKZaGlpyUwAoVDIEACYQHKggbH29vZsjAD/xTj7\n4sULe3yTzYYKjR7C0WikeDxuWmDwaqrZQEGIFvN4PAZPRiIRhcNhi/tiNmcHZWeFJr+5uVEoFLKx\njbgAAtxxpNB6hY4EDJv4sUgkYn0wEEsQXN/R2Y6LmKd6va7PP/9czWZTBwcH6na7CoVCKhQKuri4\nUC6Xs/yJ4XBou8dkMlGn09Hr168l3YnsZ2dn9e7dOw0GA3U6Hfsc9AlkctRqNfu6qOCOjo5ULBZV\nKpUsoAY1WrlcVqPRUKFQsJ8LC9LU1JQ9gtGF5HI5w3vBnGEwa7WaxYVNJhNlMhnLqM7lcnr79q3K\n5bIqlYqRGs62LX43GNPXr19biQ7Y9vv37/Xq1Svl83n1+321Wi2LRqCThTl4OBxaLcX5+bkmk4kl\ni5I2RdA7X+/g4ODBUQOPajGjCeZxL8l2lcvLSwtPxG+WzWbNXsQLCRkAPlwul5VKpVQul02jjEmz\nUqmoVCoZlEcuBnit3+/X9va2uT0QNNGuhCyz2WxadRr5GxAryCddLpdptIvFos3Q/FzhcNic18Bu\nLMhwOKzl5WXTGHPYKhaLJkuFQJmenjaCCP/heDy2aF/ERODtlUrFKPVKpWJpRjyB2HERLhEeU6lU\n9OHDB7ndbrOtfRc27rg47YM+ODv9qOriEJfP5/XixQvTA1erVbNAJRIJo6ihpHnsMi+D14Kf4ggZ\nDoeGjni9Xh0cHFgpJW4Xcu5KpZJlSqOAA9cmeV66Q2kqlYo91kn/B+rqdru6vb3V+fm5hsOh0um0\nzeOBQEDxeNx6TJCvMl/DKKJXhkiCgPJ4PMrn8xZGw+9GxBkVGYjygfXK5bKp/Pg7dN/D4VAXFxem\nPFxcXDQi5yHXo1rMTmiqVCopFAoZrIVFCS9dOp3W+/fvzVgJrjw1NXWvBhgSggoDqHD8hOgTENf7\nfD4bDSaTiba2tiTJNBYQBEB2zWZTp6en9/DhyTe9hQjZnbMxRT/OMBvQjbW1Nfl8PjuwES9wcXFh\nNyKYLh4+n89nNDM3E0WaUP8IgMiRCwQCevLkiRmAuaHRUDMrh8Nh02Vw0BuPx5qdndXOzo7G47HZ\nwzAKPOR6VAdA0nqur6/NFoX6ixcWN/VwONQPf/hD0yjgvNjb21Oj0TB6OpVK6fXr15qdnbWU/LW1\nNRPYI2Mk4urq6korKyv62c9+ptnZWTWbTe3u7lpGBdEFaDRYnPgRqSlzLuZCoSCv16snT56oWCzq\n5cuXajQa8vl8Zun//ve/bzfd+vq6xuOxIpGIwWROM4Db7VY2m1U8Htf19bUd2nw+n4rFora3t+3Q\nGY1GNR6PLf7LaaeCAEkmk6pUKjaeTE9P6/3794rFYra5cPMmEgkVi0VjBxlHQqGQPvvsMzuvfMz1\nqBazJKNikT4ym/r9fvP7BQIBjcdjXV5eqlwum2653++rUChocXFRiUTCymrQYnAzUDrDaR9FGN6+\nUqlkRZRcWJkkGfFAtNfMzIzq9bolGUkyZGEymejJkyf2+WRJo97jxiBNU/q2dhnbP27x6+trxWIx\nXVxcaHt725wpaENubm6s9ow5GSgTAb7H47ECIV7X4+NjS/eMRCKSpJ2dHYssIOGfoiGeDrxWOFSI\nI/vY61GNGbz5w+HQgr8vLi4saahcLlu2GwcZEAAklqANKMZQdI1GI2UyGXtTsejzKC+Xy8pkMrYT\nIgZyu906PDy8F17O45tDZLFYtJIgrqurK4vJrdVqarVaevfunSUIcXgjI7pUKlmf3tHRkYbDoYrF\noiqVimXKESGLZczZBFCtVlWpVAwRGo1G2t/fV7/f12QyMaIlk8nY7E4z7XA4VC6XM2jQ7XZbqA6t\nq3QiQtW3222L7AUZIYrgY69HtZgZKQjxQ/rofJzhLiZsEJaKbAhJRl37fD61Wi2l02mdn58rFAqZ\nZhnxuZPVIh3T6UFEA4yqDAwX0Q76iJubG1vULpfLVHX4/wikaTQaxgzOzMxYZdni4qLdmOx+zhAW\nxP/8G8Yjvg4pns5EJwypoD8conHJkBNNulKr1TIZKN/X7XZbEA4xB+g6+v2+RYylUikTJX3s9agW\nsySDpxDpYyJttVomyEfiuLm5qVqtpkgkoouLC9XrdS0tLdlBDCgqn8+b0+L4+Phekj4J+YiJgAVz\nuZxub29tAbCLIfZhIQWDQa2srCgYDJoNCxcISUE4y0FiEomEjTmrq6u245O77PQ+IpJCCI8LhYQh\nZlrGCppVgTOB8cjpcx72CI10GhDIzEPBiHqx3W7b0w/MnXiGdDptf/eg9/5hS+ev10VANy4Nstuk\nbwU2ZC87A1KwRd3c3JgEUvq27BxblBOeA5FgXGCnhyrv9/vmO0TAQxYbdixJhm4gPqKNiR1s8k09\nGYJ50opI4GQ+5qnDzkuBJt19LGx02GiNITlAJqjOADajgJ5YW0lGGg0GA9Myc6BD3glGjRWLkYjD\nJN5Ep2vnodejWszQrU6xezQaNREQSaCc4IvFokFy6XRay8vL1pgkyYJW0um0CYicNWaMAM4QFiSP\nn3zyiVmPYN1wOuPCRvREjQQ/L6U/dHOvra3ZzxYKhYxdQ2Mh3S0wnh4gDjzOiaPFRY48k12W5Kfb\n21sz92JjqlQqtoNfXl4a6gGD1+v1NDc3ZzYwXo9nz54Zbh0IBJRMJrWysmJPDEa5UChkZ5LvGEDH\nhYAeGA6HNgk9lOLAiqHHALMlWBvEg+gpAgR5pIJXI/CJx+P30u35e8IG0XE4Y6t4DJO+ubS0ZIlE\nPDX6/b7pS25vb7W7u2s3AkQO8Be1Djc3N9rc3JR0d3Mjt4S1xPOIThstM9pqtBnslmhSGF+YddFO\n+3w+Kw/iey0sLNjC5KzCE45dGU0KP+fs7Ox3HkDnRUUDEBQHJYTx8/PzJoJh/CCbmEZTZxMUj2eI\nAQ5yIBlY/hH4A085682urq7uLWBoa5RpuFzozmOXZ5dbXFy0XZRMC+xbUO+SLNUTxzc3IsmhLFLo\nZEYmfm/CGQmYYSTg5iVEETYTSxiLnacdryuSAMRd09PTps9wRvJeX1/byPbQ61EtZubRfD6vg4MD\no7MlGfSEUKjVapl9ajQaaWdnR4VCweSXtEVVq1WtrKwYUwcdzGO3UqlYLx7ifacWIxqN6ujoyJzS\nPNolWeBhqVTS7e2t8vm8zcbValW5XE65XM7kpefn57q9vTVIC1oaa5jP55PP59PPf/5zDQYDgxgz\nmYy9Liw6NNrD4fAeC8mMPTU1pS+++EK9Xk8ul0sfPnz4N3bp0WhkFDo+PgqJJJkbm3o3n8+ny8tL\nvX//3oy+pJPOzMx8p81wXuh8vV6vBRA6YS1sSQiOtra2DPnI5/M2z25ubioej5sQCLYMkgOpKLYk\nyBi+byQSsURNoD1ob/pMyO5wu92WHE/gSrPZ1OLiolZWVoyCnpmZ0c7OjlHbkozsmUwmJk91u93a\n29vT/Py8nj59qrW1NdNmuN1ug+dAdgiBIeSm0+lodXVVHo9Hz549kyQjcoD8CFJ0uVxaW1szjUci\nkbCwRij5m5sb04pcXV0plUrp2bNntttLspYuzMUfez0qBpAZEScD1iTeMMYGFs9kMlEwGLTFglIs\nmUyacJwUTTpCUIzNzc0ZS0dqEtpfzJ5EZwWDQXk8HhsJ/H7/PXYRyI2QdJqsKLxk9OFxDYXNYdF5\nc5Gl4URiIpGIWai40SaTiVmfeFIwg4NvExU2Ho+1u7tr9XI8CUCO6Cjn4Onz+SztH7EUyVC4ZRB0\nkY46NTVlN+nHXo9qMZ+enmplZUWlUkn1el3r6+s6Ojoyiw6QGtgxkNLy8rIJ1IPBoN69eye3261y\nuSyXy6Xj42NbXCwOOkv6/b5lTlBq+fTpU8OjFxcXdX5+bofSZrOp1dVVi9kKh8M6OTmxwxflNc5k\ne2fWXSgU0urqqt68eWM+RkwEr1+/1tLSknK5nNH5CHyIC9vf31ehUJDL5dLTp09tLODQVy6XbdH+\n7Gc/0/b2tpEhc3NzNgc3m02tr69rfn5eFxcXarVaWltbUy6Xs0q6733vexZXhkDf4/Ho66+/tswP\nTLrz8/M6OTl50Pv/qMaMXq9n9n7gMHbHcDhslCoah/X1ddP3BoNBSXdz7Pb2tubm5qxv78mTJ3YC\nv7i4MF0xGDDIBLamXC5n3x/cmIVMulI0GrU0Ig6CsITM6pAXy8vLdjMRjMgh1rlzoxXh90DhNhqN\nVKlUDPPmUHZ9fW1JqLjGnWmkqVTKdnFCJoHiqDMmviASiSgUClkvDKmq6Lv9fr8KhYJ1gS8sLGhh\nYcFKgJjdH3I9qp2ZIBRsSVtbW8acgVBAJiwvL5uplPmRGbndbiudTqter+vTTz/Vmzdv9Df/5t9U\nuVzWkydP7nV68OiE2v3hD3+o0WhkWRS3t7eG+YZCITsIFYvFe8WWTgq90WhoaWnJXB6cBfb29owl\ne/v2rdbW1iwUkd8FjHg8Hmtzc9McKRsbGyqVSnry5ImOj48l3SVxxmIx3dzcGLSIRxA3OQuUcMXl\n5WVDc7gp0Vqj1Esmk8YoEmSD+AqSik0DpzxM6Ndff/3R7/+j2pnZAbEVwVRx0CDHAQYskUjo+PjY\nSAOv12u4KwU6pGuy46HZRfnW7XaNHcOlTZVYqVSyghuwWeJqSdiE5CEfOZfL6fLy0vBxyh/5upgN\nWFD8D+gOxwhh6FDXnU7HXhcOb5NvKn5hFsvlsv1+UO6QHpVKRb1eT+1221LyGYdCoZAtbq/Xq8Fg\nYMgN6Adjymg0Uq/Xs4Bzvhe/w0OuR7Uzoy9GSE9wCTsBxIIkOygSqcUjnV2Ckksn7RwMBs3oCoWN\nLmHyTVEk2gaSPwlZ8Xg8FkFF9BYGVeSdCwsLCoVCZl/iBlheXjaNCaQHOyXhNaSKDodDbW5u2u4K\nVc54hUkBWJBIXvoI8fJB9XPjrqys6ObmxtoIyKqm5IfDIgKptbU1ixljLEE5KN1xAlS4Qd87VYMf\ncz2qnZkDDzZ2UoZgppBIoglAl4w2wxn44vP5jFFDx8ApHrgPFwW4bDgctsMOXxuiBBIEgT4qNRYo\ncQLsnIRzk13M4m42m3ZYhRzBMV0oFCxYfXZ21jTDkEKQN/gMCZ8hgQjVGuwgDmxmdUnGbkK5O9GY\nVqtluy94uCQrRWIEhCEkUsypfXnI9ah25lKpZMQJwSrFYlHStznHzWbTWC3kinjxstmsms2mGV0R\n7IB6SDJzKWQJ8+dkMtHh4aHm5+cNy4aBdCIjVE68fv1aKysrCoVCJlDCtexyuQx9QYyPLR9Hy8XF\nhba2tmyBd7tdo9eBIFEKYq/qdDoqlUqaTCba39/X3t6eJTkBCbZaLUUiEZVKJWUyGe3s7Ojo6Eh+\nv1+ZTMYOfuVy2dpfUQIuLCwYovPFF19oe3vbDuPkbCDGv7y81NbWlikTodwfcj2qnRklGW+MpHtV\nCeCpnKTJunAKi3CNMELwZ07u7Dw0jxIcgy0IRALMG0EQpThQ0+DG7FqId9jJw+Gw6bD5H+ozHNTs\ndKR/8rN7PB5b+E7amEMpzg/pWxaS38vr9WpqaspaucjAQ4ONOo/dGz30eDy2EQvBEr8DYxznDj53\nOBzagROz60OuR7WY6c8AfPd4PGb4RNiyvLxsyjkamXBA8IKDelDYA3sWDAaNoIhEIrq6ujKRETT1\n2tqa5UMgZiLRCNIFoRCJmhx+UKpRPcaCxVyLrgSDKT0ljE348ljwkkywhFAKwoVRiI/B2Emyosxo\nNGpKQ4wKku4llwI9Enzj/Lm5ORYWFuzwzSbDCMNsvrCwcC8296Pe/wd99l+zi0Vzenpq1Q6c3Eul\nkk5OThQIBNRut5VIJPThwwfDYKm9hb5GHba/vy9JFkhOa+ri4qIlFaHJZdTA2nRycqKNjQ1DAgaD\ngTwej37605+q1WopkUgon88bhvv+/XuD8FqtlslRWRy1Ws2cHvV63XbU6elpFYtFra6uWrA3vzNC\n+JOTE52fn2t9fV2VSsVc5IPBQF9//bXVVAyHQx0dHek3f/M39eWXX+rly5dyu9362c9+plgspsPD\nQ33yySeWdxGNRtVsNlUsFi1Mkq6T29vbe+9DvV63UWRxcVH7+/sW+bW6uqo/+qM/etD7/6gWMzkW\nc3NzltRJ78je3p6y2axmZ2etMGdjY8MWAY9hHCjb29uan59XNBrVxcWFMVXT03ddd91u14LA0RlX\nKhVFo1Ftb2/rw4cP5gghf4KILUic4XBo+opms2lRAdQ5RKNRuVwuVatVs0Whsjs4ONDTp08lydLr\nudGi0ajRzji8cZcnk0kr6wQ92N3dtVELLHwymejFixdKp9N2cw8GA21sbNx7nZG5RqNRLS4uanFx\n0ZLzmdc3NzfNYQ6hws/z4cMHbW5uyu/36+nTp9Yw+zHXoxoznJW6xEBRW4a6bGlpSVdXVzZXYo+C\ngdve3rbETh6ZpHuORiPlcjkT2UPP4t7mEMOBjqxjBDTg3l6v1/oFXS6XHVJJx3cGnIN2cADk9wTq\narVaJn4i2IURyePxaGlpyRANMPi5uTkzA6BRhoyBpURNOBgMFI/HTYDFz8bXaTQakmRNU6A/qAE9\nHo9h6B6PxxCU2dlZe/Iw538XAuO4ksmkOp2OLU5JCgaDNp/V63UL8f51GxQWoEKhoEajYaQEc3Ei\nkbCDGgudmZs3p9VqaWNjwxYJi4Y8DUQ5/X7f6sQ4ONLahLyUv3fKRZndCU+hpzsSidjuTWd4IpGw\nuVyS9aLwqGcRHR0dmRqw0+nY3yHc50DIbgyeDp2O6o/FT6cgemq0GVDokFgUXr579842nYdqmh/V\nYkaTiyKsVqup12xYVkYAACAASURBVOuZAyWVSpnegORJ0ADKLGHdRqORAoGA8vm8zYfoIKanpw3S\ngp7l0X1wcKBCoWD2fq/Xq3a7bYclbE3OqKpqtWqWfdCQt2/f6uTkRP1+31RozWbTvvbt7a3Ozs7s\n5kNznclkdHZ2pqurK/uZe72eAoGAjSLOUG/yojH24pa+vr5WvV5Xs9nU5eWlhTQ2m037ODgx+mgi\nDIi4xYBQr9c1NTVlxUdnZ2fy+/2q1Wra29uzhd7r9R70/j+qxRyJRMzr1uv1FA6H740Ik8nEpJde\nr9cOSiyYdDqt0WikfD5vRAP1aZPJxMgLREfkRWCShd1bXV01manH4zHUAVlkIpEw2z2PbZzReAPX\n19cNDoQdpEMPxzQECf0swHH4HtGdkIJPHC74LkGOku4Vb3I5dSPBYNDievkY8F6/379XEITgCeIF\nXTb5fOhOyHcmG/s7d/avXegcwGZ5FPKmUyID3IRIPpfLqdlsWuUwJToslMXFRbNHkRuHIRONBmgI\n8yKsHTuTy+VSt9tVpVKx3fH6+toanehkGQwGFpfLU8EZmgJFj37YWd4pyUghDK8o7VDxcXMiYMKK\nxc02Pz9vhBGzNjQ3LmvK4J0pTlD009PTBk0SVoMS0OfzWU4f3eQEW34XAuO4UGkBVWFkhVb+9cjZ\nTqdjiZfMhjQJIHuUdE+/AA1MWCJEBzsvQn9JJgji/6GFIXDQS7AIUffFYjH7t0RsQVRIshwK6N9A\nIGD493g8VrVaNXERMVosevoIabtCjO/3+41BlGSNVBgIGEFY7EQMMAODK6Nbcbvd5vohgDKVStmG\nws4NsUKR6EOuRwXNweoR5zoajbSysmI5coj1yWWjq5kFFYvF1Gg09P3vf992tqWlJcttQ5fA4r+6\nurIkz42NDSMhXC6Xdnd31Wq1NJlMLDiRmZOdHbENoTOURBJUs7GxYXJVr9ers7MzY85+53d+x0Ja\nqFCGUfv000/twIikdX193RCDr776ytw0uVzOrE8ItHgdv//975swiXR+pLJut1tLS0s2c6fTaV1d\nXdlrShOAz+ezm7/ZbCoYDGpra8u0G6lUSplMxsRJD7ke1WLO5/OG2WYyGWOtOp2Ocrmc3r9/bwTE\nzs6OfvrTn8rr9SoejyuZTOri4kIul0tv3rzR3t6eTk5ODF3AOo8pkyR+DpI0sgJZ8Qh/8uSJ3r17\nZ7sec+RwONRkMrHyG7THwFtISEejkWKxmI6OjiyEvNVq6Re/+IXJN2dmZkxc3+v19OWXX1qGxmQy\nUalUUjgctmB0dt1CoaBut6vz83NFo1FztKNf/vLLL7W6uqr5+XkdHx8rFAqpWCyaTpxEIhoDPB6P\noSPchLVaTefn5za393o9q3RutVqGdsTjcf30pz990Pv/qBYz2giPx6O/8Tf+huGdMzMzSqVSGo/H\ndjianp7W1taWvv76awtsAVYC1vL7/Xr+/LnNysBqpPwsLy9bKDcaZsgAxEvoHBANDYdDE75DZrx8\n+dJy77B2MTIg1OHfwwAS6gg5QkyXz+ezKFraWZeWllStVu1rgJ1juaI/BYMtGgvMAxxiKXAnGoCR\nC1yakWF6etoO2rOzsxbrJd2NSMQn4MPkiURm9sdej2pmBnxnHgYJYA4Mh8Nm0aFYkYZSxhAkoxQ6\nttttnZ+f266YSqXMmHp7e6tUKmXjBHMn8s2ZmW/rg53lP8zlLFQWtRP3JhoLrTBMJmMKDCEppUB9\nzoKg1dVVc5AwG7OwGE+mp6eN/EGHwqi0ublpZlPOBsz+RAtweIW+9vl8ikajxnAC0dFzgkLOSTJB\n+nw3ZvzaRTG60xns8XgsGLHVapkrJBgMmriF/jyYuXq9bppliAqCTyBDrq6urCA9kUhYNx41wexS\nzMcQJ3weyjoe16RzcjMMBgMNBgOdnZ1pNBpZHzXlQFDcdBFCeDAKobIbjUZWk8wsi5GXxUR0F0gH\nmRj0HV5fX9uNCjnS7XZ1eXlp5xRnSEyj0dDu7q4ajYalGqGQA9WZmZlRsVi0ZCOETB97PaqdeTQa\nmWoOnfHNzV2fNEHWdJjMzMwol8vpiy++sDeCMhzyk+m/ZqckFJF4L2fJeavVMqSAvGGv1yu/36/T\n01OzEgGtQaIgwCGwkOaqk5MTu/lYBJlMxna5wWBgITHoLyAlXr16ZawaPxMZcoVCwQ5ks7OzRtiQ\nA40Yf35+XsVi0XyIRIxNJhOdnZ2pVCrZDXxxcWGvjySzYJF01G63TWNdq9XMHT4ejy2lv1qtmtn1\nY69HtTNj1e/1evrRj36kmZkZy2L70Y9+pLOzs3syzh/96Ef60z/9U3k8HsXjcWWzWYVCIQUCAa2t\nrSmRSKjVatnogcUJIT1yTPTM4/FYyWTSHunValXxeNws+fF43HZ0Zs3r62utr6+b5SkUCqler2tr\na0snJyfa3t42gX4oFDLKNxgMKhQKWY1yMBjU1dWV9SAGg0HVajWrLD49PdXTp0+NrZPuyI6trS1L\nx19fX9fl5aXtkM+fP7cxBMx9fn5en332mbrdrnZ3d602Ar8jTz2nmTgej6vb7Zp9isMiysNwOGwQ\n4k9+8pOPfv8f1c5M2iUBgSRvMkN6vV6z+gMvpdNpIz+YHUEIMLPiY4O1Y94Lh8OqVCqW57awsGCL\nCr0Hj31ERDgyFhcXLYC71+up3+9rY2PDIgMYSWDOeEzzSGdWRdsxHA4t0IZ6BixJ/B6NRsPCEBln\nnDM5ZAavjd/vNwzaGYzIYsSjyPdMJpOmbcZeJn2bphqLxUxpB9kCdOfMqfvY61EtZsiRlZUVvXv3\nznQZ3W5X796902QysSDver1u+XPtdlvlclmJREJut1v5fF6VSsUeyc1m03Irbm5uLGMDsB+XBrju\nzc2NKpWKnj17Zsowboipqbuy+VKppHa7bYs/kUjo6OjIAhnr9brh469fv7aid1AY6e7mrdfrxryh\nc/Z6vcrn83agmp+ftzEDsRNfH0c57B/5eGTAodWW7jKXcZTwmkmyjI1yuWzumHq9bo6ZTqdjyAjE\nFMQSWXrLy8sPprMf1ZjRbDaVTqdtpyOKCikjj1NKfLDkSzKxEaQBsBJzK0wcNCxO72AwqHa7LemO\nNUOYjpCGmwE/ICIlYr6QrTJ+FAoFs13RNxIKhYwuR1dcLBYth47gQunbInZgvampKVUqFSudn56e\ntlo5bj4SlQqFgon7nz17ZhLWy8tLi9T69R3U7XbbOEVGHjsuh2bEWPv7+xani8oPRWEwGDS57sde\nj2pnBvQHW56fnzeM+Nez0YDC8Ag6U/cR4CCfnJqaMjqXnTMcDmtubs7EO9Vq1WZRgllg8lqtlh36\niBUAcYFhA6d10urO3Qu/IQE0zn4SFheoC1Q3PdzgwMg4ybpDa0H6EvkXjDDc4IifeB3xBwKzES1G\ntvVoNNLFxYWNSOhbnDsvqBFxw+122yxVH3s9qsXMQgCdIKKVncBZnshj0O12W+wAMk52UkpoWFxo\nk1HBgXQMh0ODvNAozMzMWOAih0SanogL4CnBjMvNgyjK2b9XLpcVDAZVrVat74SnB7UX0rc5zexy\nzOgQNpIMV5dkowtnBQgTbhYWLhlzmUzmnu4YgRLIDuIoRFPAhtwUzvDEUqlkoxBw50OuR7WY2+22\nQqGQpVJ6vV6lUil5PB6LaYXo8Pv9pvElsIXdjMoCdijCDBcWFrS+vm4G1HQ6rW63ayQBuDHySHZv\ndkWn8zsWi9nX4Y3HKU1GHOlHsVjMdCN0GHJQhBHkwDc/P28/Pzs31n7+/Wg00tOnTy1ViadDr9fT\n0tKShsOhGXyxQfE6kPbJRsFNQrQYPzepnhAiBCViLA4EAhZAyUj00OtRLWbcCzgm2ClRqi0tLZlG\neDwe22OdBTAajYzxgn4lbw4Grl6vm1SR2RwGjhw24CYYMElmfJVkI87S0pLN5fV6/V6dWD6fN2fL\n0tKS4ec8km9ubnR6emrzvCRDHiQZmgPqQAoROmznrA55QnQZMQj0+aFDTiaTFppDTwkwILENVBfz\nc4BcuN1uOww6O7WDwaDJbgme/NjrUS1mQvyur691cXFhWg1gsc8//9x0EdQU8PelUsnqyKhWI5P5\n7du3hgMjq8QdEQ6HbU7lZI4HkUgtmDEqJ5zVaUB4kBgwh8lk0hZdoVDQYDBQqVQyzbTf71c6ndZk\nMrGRI5VKWaVZJpO5F15DQCHnBW7YmZkZXVxcWK0x7QIul8vaqNBP032Ip5Fsul6vp+npaQvYQZvR\narVUqVSMhGI+ZnYHJUE19x0D6Liw78Modbtd5fN5NRoNawotl8vW0XdwcKDRaGTRq/SQsMjpeEaz\nixAJzJbQQnQUiHhwtGCrR2ONDJLx4fLy0hKSyLkjdoukIDQmGFcR+ZdKJZVKJatem52d1fn5uXq9\nnlVS8LnOInjYPKIR+H2B55zdJ8y75NhhFSsWi1b1wJmj2+3aE0OSYdwkK9FG2+/31el0LCqBA3u7\n3dbp6emD3v9HBc0hYPd6vfre976nubk5vXz5UjMzMxbp6qws6HQ6Ojk5Mes7J/FEImGWfFLoe72e\nWfMhGxYWFpRKpXR5eSmv13uvumxnZ8cWwd7enh0McYHjj6MaQZJFw4ICOKllnCuElsfjcUUiEZu3\nwbdnZmb0/PlzDYdDPXnyxHZ+SdZ4hZaEgEefz2dtU7RM+Xw+vXjxwlAXyCfIGTq3k8mkCoWCUqmU\npfYHg0F7QnGQBFenKZaD69dff22E1ubmpr788suPfv8f1c4M6uD1elWtVu3FlO7mW2fVGVoCXlSn\nJQr9AzMirmlEPbz5UMPkInPK55EZCARMT+wMAcdVTZImhzJm/larpVqtpvn5eQtY4VDFXE/VBeIh\nmEksYhAog8HA1IDY/AlugZ6GTLm+vjYWcTQaqVqtKhAI3NvNGRMWFxcViUTUaDTMoMBODI6O6QGr\nFWcCnDntdluxWMwCK79zZzuuubk5ffjwwaC1TCZjrBSjwuzsrG5vb1UoFJROp+X3+1WpVMyRzbzM\nokXKSb4G1PHU1JQCgYBqtZrFFDgzI5wkDbs7uyxubkypqNIwdYKY4HJ25kUzOkBiZDIZY+awL4GH\nw1SilYber9frarfbBkcyqoC7wwRyYC2VSmo0GjZ2kcXc6XSsCoNFSR4fOmVkuKFQSBsbG/Zz8jPx\n/UKh0HcHQOdVrVa1tramy8tL+Xw+bW9vm9glEAioVCrdOyw542+RJPr9fkWjUQWDQWUyGdPgYnWq\nVqsm6SQDGoyVnmwOQYSfoKS7urpSs9m0PhUSQHF8I8h/+/atHQ57vZ61vjpd4UdHR9Yjws1B7C5K\nPpfrrlC+2Wxqf3/fVHTdbtdGFJfLZQgDiaLYnaDV2YEJvuEgDOYcCoWsQo1DHXMyQeK5XE4fPnww\nIdji4qLdGPV63Wb7h1yPamZG6JJKpewASDBgPp+3kEHeuFAopJ2dHROVj0Yj272vr6+VSqWMlUJc\ng+vbyfKRIgTRQdo8VDS1vIw08XhcuVzOHu+wiqPRSD6fT8vLy0Ydh0Ihe9zDsN3e3mp7e9tiEKh8\nQxvsdruVy+WUTqetuoLwGoRG+CA5OyB6oj2An2t1ddXo7HA4bAxiIpEw1wx6aL/fr2AwaOMT1DUx\nZKjj0MzQiOXxeKyi+J//83/+0e//o9qZcWBzAEGAg9A+mUza6Ztynf39fUMxJpOJFfBcX1/bgREZ\nKOmfvNGEuEiy3ZkF2u1274nvcZigHqNtdW5u7l4gDfoN4C7sUbhMWIztdtvQievra2uMku4OqLFY\nzNCBarWqZDJph1/6U/BHIoDC7Y0znYRSMPSTkxPd3t6q1WqpXC4bgTMzM2MbCSMX/06SvSYLCwuq\n1Wr2++LIRmP+HTTnuBDOg+9ie7q+vraoKnZBDnBPnz615HuwY2odnDJHJ9RFDgR4bb1e19XVlSVr\nIhGlv4OcOxYmnSXxePxekidaCXZ44DNQFFRsMG6YU5lTIYRwi0AAgV9LssMXMzI9JSjdiKvFGuUc\nd1h4HKR5kjHmIOpyPqGAE4fD4b1K4mq1aiNJr9fT9fW1qfA++v1/2PL563UNh0PLWuZg02g0LBG+\nUCgok8lYKEsul1OhUDAvHnhrsVi0GZhoKjQYZFJw+GIxSHeqvXa7rVarZSJ+BP6o0YbDoSUsUcng\nVPaBXbMoGZcGg4HN+9yU9IFgU2KmPj4+thq5crmss7Mzi9RijmYnHA6H9rrAmBJJxgFPkiWoViqV\ne2eGbrdrbng2DnoJQS/q9boajYYqlYqurq5UKpW0vr6uXC6nUqlkAq2HmFmlR7aYwS/ZedBidLtd\ne0Gvrq50dHRkhkzcKYSysNtymmcHlGT/XpKpzfC89ft95fN5LS4u3mPYmFNRhXHjsKgvLy9tETnN\nAVwsDNqiRqORPR0k2ciESo2oAAgOoDwOb8yseP9AQHjNiGXAWOCMmG21Wga1URXHmMNZAzMArxOv\nHSo5RP50d0Nr06L1kOtRLWZYMvSx9GXMzMwYFhsKhbS1tWWdHEgZ2YVAD5hlWZSk83AgDIVC5jJG\nEQaS4gxIBGFwLlB2WA5v4N7sxNyIhM0w96fTaZvtna1N/PvDw0ONRiOtrq5ajjTin2KxaGMLvkG/\n32/IBloKn8+n9W/KPm9vb7W0tKSLiwsbD6hThjTh4IwGhQYAdnwSlgh2dLlcRnd7PB4jg7xer6LR\n6IPe/0eFZsBixWIxvXv3TrOzs9rc3JTP57M3mF1xe3tbxWLR2DRs99VqVdfX1/YxDk3smDRHXV9f\na3l5WePxXec1LmTiacmzwANHAIyzZoIQ8m63a8U30l2YDYuLg2cymdTV1ZVWVlYMr0aVR+AiwY8c\nNmHvarWaYrGY2ZkIKV9YWFA6ndbl5aXdVLlczhqk4vG45ubmtLu7azcNIZM4wbGeSTIqPxAIWJ3F\nzc2NVldXVavVbOHjZWQnR2m4s7Ojzz///KPf/0e1M+ORo0fPiQAgeOFNxkFSKBQM3AfzJaiQAxCw\nHE5vbgpEPJze6aeem5tTqVSyXR4MlnBBxgoWPLs/cy15xuC25+fnhs6gDQYblmRhhbBonAP4Nzwh\nyuWyHUoJRgRZ6PV6qtVqJk7yer06OTmxUYA0JHQfmBiYnUGAiAZuNBrWNksjAQdVwhLJZCY64Tuc\n2XGVy2WFw2HLV6vX63b4a7Va8ng8Jj6XZD64VqulcDhsaAJZa+12W2dnZ5YIxOO01WoZ9Ypw/ubm\nxpzVR0dHJsGkVswJ44GtMoMzr5MPHQqFzKsIZutM5eQQRh4yEtBcLmd2KKxUCPdBJTg3YAwgCkCS\nRQDTgYi+m5gGkvx5LWEO+Zk5dIOPowakJgMokKeTkzWFoXzI9ah25ng8br44Kgjy+bxRxbVazRg4\nqOFOp6Nut2u47vX1taEUaHWPj4/tjWMm59CCDmI8HlupeSKRsMcxlipYSC5O8CQmtdttRSIRa0Jt\nNBrKZrMWWlOr1VSpVEwQxS6Nmfbi4kKLi4uqVqu6uLiwRdPr9VQuly1SDMaOuAQ0FaAz3W5XJycn\ndrOiyWYnBfa8vLy0cabVaimTydgTS5KJn/g9z8/Pza/Izdbv923Momb5Idej2plJfy+VSjYjr6ys\nWL6cJDvI3Nzc6LPPPtMXX3yhH/zgB0asBAIBffbZZ0qlUrarUSkGIkDGm9/vN6yU+ZJdkAXe7Xbv\nFdRD1rBTBgIB7ezsWCcJBk+CDMFx+/2+Xrx4YcL3TqdjcWC0rJ6dnSmVSulv/a2/ZXpnHCYXFxem\n5QZ18fv9ur29VTqdVrvd1tLSkmq1mhKJhDwej2klIDyQBEDwVCoV7ezsWIkRO+zi4qLevXtn4vte\nr6e1tTXNzMzYzO/xeHR2dmb4NV3cJycnH/3+P6qdeW5uzmztsVjMnBXAbPl8Xs1m0x6bmUzGegE5\n2DUaDZsdS6WSKdd45BPgQmqPJJtnKefhUINNn8c9eDIkAl8XvTK2J0m2izF7M+vzcUYFbrhms2m9\nK2ixEQixg1PGzhOJ1+X9+/f2hOp0OioWi4YXS3dPD84ZPLHY+amLgNZuNptG6sBoAk2SntRut3V8\nfKxoNGq/N6/TQ65HtTMji+z3+3aCR3WGO8PtdlvlApoN9BvIGSWZH45Cmn6/byU/XHjnCHRhN2bn\nBdelDIj5GCUeQh9nrjTxB9DClNlj/8LTBxtXqVQMbuSpU6/Xzeofj8c1NTWltbU1EwjBPM7Ozqrd\nblu7Kwwo9PLs7KztukCbkuyJwNwrydKMQqGQpDtnC2MRmhSv12tPSOS0QJy3t7f2BPzY61Et5nA4\nLJfLpcXFRW1sbNjBCvoV8+nl5aXZgXCOhMNhJZNJ5fN5G09OT0+tyw4xPRcQE2MA/w7smZ2cXZyg\nbg483W5X6+vr95RwpHpiu2LnRc23uLho+g8Sg4DmJBl2HIvFbGFyCKPnMBaL2cF3fn5eT58+tdHF\n5XIpmUyaFpuK44WFBRuDCDkMBALqdDpaW1uzBiuIFlKOMLSSeETjLdAfehmIFDaSj70e1WJuNpty\nu926vb1VJpO5lxUHAZLNZi17ghgC2Dh27Q8fPphz2ykeGg6HarVa5kjBjEoKPJoM3lBwZr43OxU7\nOTDeYDCwXZL8Z0YLHNZoj8mvKJfLVtADCQMaAbFCbwvMIT+v3+9XqVS6h9IQSUB/S7/fN80xwZBo\ntIPBoIrFohlYUe/Nzc2ZlDaTyZgzHjtVOBw2zTidhdwAzPIPuR7VzMwjFScxqe/RaNREQCwO5sdk\nMqn5+XlzO4BCgIxgwSephxefGohAIGDfL5lMam1tzbLbgL8QMSEVrVar9rGbmxtrkp2fnzfxfyAQ\nUCgUskMbkQI8/nF8JBIJxWIxExmhpGO0wW3CjE9/H/0sXHNzcxbTAK0ej8eNHOFjvA5EgPH9uPH5\nupubm/fy+5CL+nw+RSIR+/md5wvGmI+9HtVi5sXhDgfIBw3IZrPGqGGopN4BOpv6MzLYgsGgNjc3\nVavVbFxwluUQQTUej1WpVIzggFQBt2Xhh0Ih0zOMx2Nzq9CV3Wq1lEwm/41drFwu3xOx8xRwEjcz\nMzOKRCKmTUZQ5fF4bBbP5XLWXotHEXUdrhnID+j96elpra2tWZE9MzWifV43btZ+v2/wJgZW1H24\nuSFgODgvLi6aM+Zjr0e1mAuFgkXS/uIXv7BTfrVaVblc1mQy0dXVlT58+KDl5WW9evVKX375pVU4\ncBJ/9eqVGo2GcrmcMpmMXr16pVqtplqtZmgA1n92YP5cqVR0c3Ojk5MTC4chEPHw8NCQlFwuZ8RM\nPp+3SgS3261KpaJXr14pn88btkv9mXTHdB4dHSmXy5kOpFwua2pqSqenp8b2oUU+OztTOBy2Gxg2\nk50wn8/r9PTUkvcRMaGEazQa+uKLL1StVrW/v2+51cQiDIdDy2gmpgyJLBsMgqpms6nT01PL9cP1\n3W639a/+1b960Pv/qBYzpYy4HkjZQSS/sbFhyZ29Xk8/+MEPTLWFLoLYgPF4rKdPn9oBEUMrJlC/\n32/sFoQKJ3b6Q3BiE8HFqBAOh/X06VMjDZgXp6en7ZCJdYlHujNQhlSgaDRqWuR4PG6LxO12m/uE\nwzAYOp9PfVuv11MymTRBEhG+19fXdkhk502n04Ybc+iTZBUa0l3O3vLy8j31IsmnHJhBl54+fSqv\n1yuPx6PxeKznz58/6P1/VIsZK73L5bIXVJKhDTRHsWOxA6Gsi8ViFrNFUeX8/F2v3+bmpgmPmP/c\nbrei0aiRCk7jJrAVHkMWOoL2arVqijvMnGg8pqamtLu7azl1SErJvvN4PIbrJpNJ0wwnk0mzIlF1\njO4jkUhoYWHBbmTmbhakMwgdMwKNt1D9l5eXCgQCFuMr3TnRWfTkSIP+IJN1YuFer1exWMzS+jmE\nS/qOznZeULvMlbBUKL5ub291fn6uy8tLzc7OWu0BWgMsTufn55Jk4ppsNmvBhM5AFEJaqO7F/QxF\nDNWN25tkTxJ+FhYWdHl5aXMnYiEe97g3bm5uDOEg563ZbNpj/vb2Vvl83tqeyuXyvdbZw8NDm8n7\n/b7Fg/Fz5/N5q2Zot9tWIXd5eWndKDc3Nzo4OLBxC/koC5cRjXMC2R/Ak6BFJDIBo5JgipHgIdej\nWswEHQK+k/5DUPj09LQleEKgQE3Pzs4qGAzargcEhYE0FouZe8Lj8RhGTQbG/Py8Op2OotGoEomE\nLSyQE3Y35lUc106BvzOQBY2JJBt7vF6vif/BvRkdnKo5SYbEOLMoqK3AbYIlCxiS34nF67wh+TsM\nuYxNXq/XUolAefg40CS0OcgP4xWSAEijh5ImLnac/79fLpdr8g/+wT+wEz96hX6/r2QyaSd1VGXY\nltAkYOwk8Scej+vNmzd6/vy5ut2uCYUKhYKi0ajNnGCr4MnORy07GOwaVqTZ2Vm1Wi3FYjE72F1d\nXSkcDqvdbisej8vv9yufz6vT6ZhQH38gdqx4PG7fA0SEYHJuQq/XazJYzLyQLYwO7KQcCsmjLhaL\nCofD1jRVLBZtgZIgOh6PbfZGk03RJcExHo9HlUrFCn1YvAicON/0+3393u/9niaTyUelwTwq0gQG\n6+rqSq9fvzafmd/vN6lkq9VSv9/X2tqafvKTnygYDJpA6OrqSpVKxaxCV1dXqtVqqlarhsFCOuDz\nYwaV7mbvYrFo3YBPnz5Vq9XS0dGR0um06alXV1ctpAWYDkwYGvj8/Nx0zRwgm82mNjc3rXAHOhg1\nILkcw+FQqVTKRqzRaKTNzU2beYHhkJ1yqEXGyY3FXD8YDEwlR+dhtVrVD3/4QwUCAWv2Iq8OcokG\nWSSh5XLZ5KXOThUQnn/9r//1g97/RzVmEEqCKL7b7arRaNjjFlF4u922w5NTYkkxPOwd1DIh4ZLs\nUYtP0Kn9IEmJ9MzXr19rMBgoHA7bbglujKgGOI6F1Gw279HYwIbEBVSrVYsEYKcFHgO3vr29NaYT\nRAWRENVwVkvA8QAAIABJREFUfN7S0pKxg1QQgwlLsqyQer1uMtp4PG42KA7JjC0gH+zyvB/ENvh8\nPkmymF3iBYBUH3I9qsW8uLhoijd2JVgz52wK5MWjdnZ2VpFIxA5ACMWdSADhiSTvc8Ch5BKkgxAW\nDpV4AUFFsGeRXYEB9OTkxCJp+XuE78zfQIiI8Jn5CbEhzFH6VvjDeIWjptPp3KuDy2azpnzjTMHN\nTAQu/Yr8t9ONDvvH/wjJIXqLZCMkAI1Gw8J4JKlYLJorJpFIPOj9f3RjBrQoHSS8aIRe0ylCdFS7\n3Zbb7bYT/vT0tIrForxer8rl8j1GDFwXXJTqXoRM7Ix8P1LzeVSjaU4mk5bGD9THrE5PHjtXPB63\nWZ+EoFAoZPnLzOqNRsM6XUBqJFm9Mon3NMGizWDUAbuuVCqm5yA1n5w8Wgb4MwffwWBg2XdcvLaE\nkoO8AP1dXl4aHIlW+qES0Ee1M7tcLgtD3NvbMxVaMBg02IeUIGJlUWwBhd3e3trBJZVKGbLBDMkb\ny7jAYYbPY1asVquWME+OMp1/tVrNZmXmSfDm0WhkPSHM5sCNhULBPIDMpxzsKNEJBoOm6GPMIqQR\nbyQRWyAexAIQZ+sUHY1GI8OI6RPHTTIejw35yGQy9vry88bjccP0cfOgvkun0+b5cx6YH3I9qp0Z\n8Yvf79f79++VTCZNWBOLxUweWi6X5XK5lEgk7NDlTBFiMSBVBD8lbHA4HGp9fV2NRsMqJyh5h1Rg\nXJhMJpa/jNAGtVi73baDGZFeyWRS29vbevv2remsWQigAR6PR8+ePbODHAuTcJcXL15YqOL09LSy\n2aw2Nzd1fn5+zx0j3R3aqFXj9eAGpwWWtHxQG24AFIqj0cjkrPgVk8mkjRs8jci7W1paUqPR0N7e\nniqVijGYoVBIf/qnf/rR7/+j2pl5wyWZ4ByigYxloKVYLKZ8Pm87H24TSdrc3NTMzIyOj49NYMSh\niMchCywej9/r3O71eqpUKqZrzmQylrhPvluhUNDl5aXi8bguLy8tnosZvVqtKhaLmY55a2vrXqYE\nCAVRsJhUB4OBVS/g8CB/7uzszOIDOGxhlmWBIgIiUgsJLVplapTj8bglIlEGRFWFU9F3dHQkSVpa\nWtJgMNDXX39trCCQXzabNeIIVOhjr0e1M09PT1vZTb1e1/Pnz43xOj8/1+npqc1lBIAfHx9rb29P\n0p3gBjPp1tbWPSoW6AwvHfkapVLJZlQgvPn5eXvs/uAHP1A2mzW3NTAgVDZ6ZIIGqVxbXFy0iC2n\n3SoQCBgbiJ7C4/Ho4OBAq6urRmUTJYa7hEX91VdfqVgsKpFI2NhzcXFhkB1pR6urq/rlL39pGRvn\n5+eanp7WxcWF+v2+hYk3m02dn5+bxezk5ERzc3M6Pj7W7u6uBoOBjo6OrLSICggiGDhwl0olvXr1\n6kHv/6NazF6vV/1+33ZLQkl4rK6trZnJlF3rk08+MYOr2+3W9va2fv7znxuIv7q6ajt6NBo1JouG\n15WVFeVyOYPLnCbT1dVVEx1FIhFVKhXNzMxYKAzjAV0shULBXC6wlzRGoYHAcJrJZGy3Ho/HWl9f\nN5auWCxqbm7OPIG9Xs9Cb+bn57WxsWG2MuA9dt1yuayVlRXD7GEMd3Z2DO2IRqMWNjkYDJRIJGx0\nQgcOk0r4JK8NEQtUFK+vr9sTb3t7W7/61a8++v1/VGPG5eWlZcelUik76WMBIlEIdAHRvtfrVTwe\nt11RkiW+j0YjraysaDAY2GmdR2Kn09Hh4aEJlXw+nyEf6XTaDkHj8dgOgWRXcFAjZ+Lg4MDgsMlk\nonq9bnh1KpWyQktaVN1ut4UpDodDC11ETLWysmJS1V6vp/39fatj6Pf75nahv5sdGVsVoqZut2sB\ni+z2zogwmlyvrq60vr5u+mTcOWg3aMjNZDKm94DVhIl1+is/5npUixlrOzJDFiQHtWazaYvc6/Va\nVgMaXFg5aG1EPGdnZ4pGo9YJgjl1bm5O6+vr5pQej8dGoDjZPEkGwbVaLYP4gAQjkYi2trZMmgmR\nQr9etVpVu922sG8OVaT8o4mQZHoOerbx4q2srNzDgKmyIEgRTQhPEuZXcuiA0IA8MfjC5C0uLhq2\nDj4OdU6KaqvV0vLyspljnS6VeDz+4Pf/US1mBOiSjJzgQIhGAsex2+1WPB7XJ598oqWlJQsMHI/H\nJtl8+fKlHRihXCElgsGg6TAk2cLk4AWVy8GPz5mdnbXFj6aB/7+5uVEsFjNIMBAIKBwOW0Ycrmyn\nOEqSkSOMWRwMCasBmgNyg11kFneOQNwMzPZ8HnAjgiiUe05tBi4cDpTs2iAt0p0cN5lM2muGis7l\ncln18Mdef2WL2eVy/W8ul6vscrneOD72P7hcrn2Xy/XK5XL9Xy6XK+j4u3/ocrmOXC7Xgcvl+k8d\nH/8Nl8v15pu/+5/+bd8TlVe9Xrf+jIuLC1Oq8diFkMC6wy4ObV0oFNRqtXR8fGzlOuPxWMPh0GA0\nsF7eQElGF8N6FQoFix+4vb01ZwXfi1YmaGEKKsF7OfyxGDn9QwPTBzgcDo12R0PtxIwxDpCNDK0P\nY9jv920sYccmQJzMOyIJIH+mp+/6vmFF6WzhfQBhwYBLyLskk+fip+z3+/9eogb+Knfm/13Sf/Zr\nH/t/JD2bTCafSvog6R9Kksvl2pP0X0na++Zz/onrW+3i/yLpv5tMJjuSdlwu169/TbvYMaamprS/\nv2/BfZPJRI1GQ6enp7q4uNDh4aEJdw4ODuzNx692eHioTqdjweJnZ2fyer1qNBoKhULW5soC4xH7\n6tUr25FwTPOzYIxFSE9kVqPR0MXFhT3COcA1m01dXFzo+PhYNzc35iAnu6NcLiufz5sBFX10t9tV\noVBQqVRSJpPR+fm5eR+pJgaCa7fbKhQKyuVy+tWvfqV6va5ut6vj42PL0CO4/e3btyqXy8pms/bU\nY3YGmoQwkWTjGK8hpBWkETcXeXdnZ2f6F//iXzxowf2VoRmTyeTPXS7X+q997E8c//kLSf/lN3/+\nzyX9/mQyGUnKuFyuY0mfuVyuc0n+yWTyy2/+3f8h6b+Q9OO/6HuSk+F2u/W3//bf1u3trT755BPN\nzMxY0TuObMYKbO6IiiTp5cuXSqfTBkdtbW3J7XZrfX1d2WxWKysrVgQECTM1NaUXL16YK3p2dlbr\n6+tyuVz63ve+Z07qbDardDptemVK0t1uty4vL+X3+xWPx00HDGGztrZmdRDr6+sqFApKJpOmiSYs\nMhKJmN4ZTUetVjNtNiTMYDCwSAG+z87Ojt68eaO9vT35fD49efLE6HRMrLu7u5aGtLy8bPkZ0PdA\ngCSyrq6u2rgBMrO1taVSqWQpqM4O84ODg49ec/8xobm/K+n3v/lzStLPHX+Xk7QsafTNn7ny33z8\nL7xKpZLi8biq1aqy2ayWl5dt10BRRwALLxyULimVKMygYqvVqrmbCVlBylgulw16IkR7NBpZeAyH\nQEYdSRYUiPMEkiOVShl7SS6Fs5EJRIGiHKfAiTkVbUomkzE9BEKnWCxmjhc0Iq1Wy0rn+VmI/4WG\n50xQq9UsTgsChQMfB1IUipgPoLqLxaKp96DrV1dXLYwccdhDYDnpP9IB0OVy/a6k68lk8s/+fX5d\nZmMyKmDv8PeBBIB4rK2tWRMqM7XT/+dyubS6umrWH1hEqnrpsuOkz1wsyYJVoJ8hO9xut9UzoMxz\nu92q1WpaWVkxFABIb2lpycRBPNr9fr85OjhcohumgdUZASbdVRlz6MTU68y1SCaTFk0g3ek0wKoZ\ngYrFou2yzN5g9JgIQqGQotGostmsHRIp+OEACyoTiUQMPRmNRtrY2HjQ+/8ffGd2uVz/raTfkfSf\nOD6cl5R2/PeK7nbk/Dd/dn78L429+dWvfmVU72/8xm/cK14HnyWgpVqtyufzaWNjwwJi0D4sLy9r\nb29PP/3pT03WiZLs5uZGa2tryuVy1lZ1eHho1iLGi263q4ODAz179kyxWMyYRKA3dA8o2UhGcrJ8\nCNpjsdg92aXb7TYTKZgxBzev12s4Ljg6yAiQJLsz4iYSTImgJXv55cuXqtfrWlpaMhQim81am20w\nGDTtNYJ7SZbFQUg7cQwgMn6/X6PRSB6PR7u7u3rz5o1mZmZUKpUetLb+gy7mbw5v/72k355MJs42\nlv9b0j9zuVz/o+7GiB1Jv5xMJhOXy9V2uVyfSfqlpP9G0u/9ZV//t37rt6w+rVQqWTE7kkcyjQuF\nggUJQqWS7xAMBq3sxuVyqVgs2mGNKKpisWh0Nrsr6jBQhYuLCy0vL1uaJo9rbFGlUslkk91u10LS\nmX3b7baJcDjE0sXNzgdWWyqVrJuEeje+LwHmCwsLdhAEDkNgDxsYiURMK720tKS3b98qlUopm83a\nTt3r9Ux8RSQYSI8ku+Elmd2Lf9vpdLS8vKzT01MTds3MzFjp5uzs7INm5r9KaO73JX0u6YnL5cq6\nXK6/K+l/luST9Ccul+srl8v1TyRpMpm8l/R/Snov6Y8k/b3Jt+bEvyfpf5V0JOl4Mpn8hYc/SRbR\nyu6Gg2IwGGg0Ghn9y04pyYoaoamRTALoo0nmoAhVzWjCIubR7XLdNU8lEgl7jDvz6njsY/ik4RWB\nOk4M0uWBtnCNkNEhydhDyBooZp4+y8vLJoOdn583+prdEuaQ187j8RgjCgHFrAuawgJFF47UFEaT\nQzgYu/Stkdbj8RgsB1bOkwmDwYPW3GMytP7u7/6uUdIEaM/Ozlrw+Oeff67NzU1ls1nF43Elk0n9\nwR/8gT777DObBYmJhREDCy0UCiZ+j8fjljdM2QzwGXM5Yw3wFG+oM2fO7Xbbjl0qlTSZTMwQSnYb\nbBq/C7oTXNpQ0pKMweTgScJTqVS6V1fMmBGNRnV+fq5QKGQ4MomkHJ4jkYjy+byNDPl8XqlUSt1u\nV8vLy2q32ybCkmTudzYEbgTC1RnH8P+dnZ1ZeVChUNA//af/9KMNrY+KAaSiIJlM6sc//rFSqZQO\nDg50cXGhP/mTP1G/39ebN2/05s0bjcdj/f7v/75Ze7DznJ6e6l/+y3+parWqn//852q1Wnr37p1V\nO+CHk2SHsVAoZITK2tqaIQHhcFiBQMAe04jrA4GADg8P1e/3VSqVdHBwYKMAMbK1Ws28f+RwkMo5\nNTWlX/ziF5Yf1+v19OWXXxrN/MUXX1hgeKlUUi6XMwqdw5b0bTffmzdvVK/XVSgUVKvVlM/n5XK5\ndHx8rC+++MIIHjDvarVqss2bmxtdXFwYG0igOOVBbAbFYlHSnU3q8PBQs7Ozhq93u11lMhl99dVX\nD3r/H9ViJgCl3+/ryZMnqtfrFsZHd3QoFNLu7q6ur6/15MkTo1LxqE1PT1vJeiKRMDwYaxNs1fT0\ntEkaLy4u5PP5lE6nLY+OVM5CoWBZ0fQJokXG0r++vm7QVrfb1Wg0sogxRobp6Wmtr6/r8vJSXq9X\nqVRKt7e31gOysrKig4MD3dzc6OXLl7YLLyws6MWLFzZz4wFEVVir1Sz9aX193Zg9SYYrEweAXgVF\nH/G3CI56vZ7djLwfyGiXl5etgWp9fd0MrrCyZII85HpUi5kTNwA8eQ9OJwnQG91zSEFRlzGSSN86\nk3FUIIqJRCKG1YJRS7L6taurK21tbanT6SgQCFiSfiAQMNE+nXjT09NGYaOqYwQBZnS57nrAsUnR\nXUgMGJQ0Og6n3xBcHdMAX5sx6vnz5yYLZTcFLw8Ggxb2ArkB9Mesz8+NrgP1IU8t4monk4lCoZBS\nqZS5W9goPB6PgsHggxfzo9Izx2IxE6RfXl4qFospk8koHA4rm80qFArp+PhY/X5fS0tLNsNho5Jk\nGRE8sj0ej66vrxUMBlWpVNRsNhWLxTQej42Fe//+/b3uEyrXvF6vaXj5u6mpKZVKJRWLRQukubq6\nUiKR0NnZmZW2I5EcDof3lHfFYlErKyva39/X8+fPTaiPl7BQKJgznfkdzTF6Ehq3pqfvmlLb7bZp\nkU9PT+3gR+D4YDBQtVq1kWlhYcH8egiIIJdOT08N2qtUKmaOKJVK2tzcVLvdVqlUuhesjtPnu3gu\nx4VMkkwLshw4WNFfMjs7q3Q6rePjY3uss0uTtUzyJocw8h1wMFOV0G63bUTx+XxaXFy02K5gMGiP\ndnZ3AgnxDaKrAAGBoCGDAocG0bh+v99y6cjUIHOaoBrIDvTb/A5zc3OGcqTTadMo82QoFosKBoNG\nvpCvwe5/dXVltWtQ5mg9oPE5CLOjEwFMljQ9jKA76KVvb2+/W8zOy1lsg4yTiFpiVSXZYxBLEIgE\nlDMWfhan9K3kE3cy8zM1ZxRAokNGXgnNzfzqtDEBR8EsAmexWLFg8W+RdbK4xuOxQYXOMcVJjDBq\nOGFLYDUYRIJvwHrRqGBqIJODjDk0JYw9kmyBsykgRWWkgIUFeYGlhfzhd3nQ+/+gz/5rdlGzi4YX\nJRn4JzkOzJEQDGQIl8tlDYdDbW5umgwSWWOpVLKdfm5uTsFg0AISmc1RzzUaDWP0isWiOS7y+bwx\nYdL9EBVy31hwpH/ys7EIcKrAoKFrmJmZ0eHhoQaDgXw+n0qlkmKxmBXgwM6RPQdjSLkn4whxvaje\npqamVCwWbd5GU4K2udPpGAGERoUAm1wuZ/S8dOcE4hBZq9V0fX2tXC5ndDkHx4+9HtViTiQS1uhE\nChHJQ3SXOE/XqLXw9EUiEWMGEb4TYsIuWavVTL/ATIuoCMEPTVIul8t2ymAwqLW1Nbu5YO/Ynckz\nZidmROEg6/V6tbq6KpfLpXA4bHUPOE3G47EVVUp3RgUcNjjHMbtCX8PgQaKggeYQOhgMjKxBGgAd\nvbKyYj/Xy5cvbf4lnsHn85keptVqmeMbNR8JUqQ31Wo1PXny5EHv/6NazOPxWJlMxmYyv99vmXMQ\nFdLd3Eu/39bWlonv0TVgNE0kEqpUKuae9nq9SiaTNkM70/HRcHi9Xi0tLVmGBiHk7HbOvAlQFhYA\nkkhgNeeiDgaDpv0YjUbm1pBkeRVouREO8XOQWkrcb6fTMRJjMBjY7rmzs6PRaGQMIAdkn89nLhny\nQQhSREXIARhWlKfNwsKC2bcQOZHMjxab1x5U6GOvR7WYnTnCHOzQ3rKLcfLv9XrK5/NWeSvJhDg0\nkubzeXk8HiuShD3DuUFkLoufpiocFhyOOASCmCQSCUMhwuGwhZTDCCL3JFmeGbrT6SgSicjr9erw\n8NBw65ubG6PMJRn+DNTm9/uVSqXMGUIeBv4/YmxZ8HNzc/b3mFoZ3ahCY25HVxKPxy1wB10L5wC/\n369EIqGVlRWNRiNVq1VzuyNaImnqIdejWswcYG5ubizIkN2ERYFM1OW6q4pAi4B+gbqGUChkownz\nKYsKurpYLBpFjQkVySmRXcy/GE6vrq50dnZmRAGsIgc5xpRoNKqNjQ01Gg37POZ+dkQSmtCMsBMy\nOqyurtpOjisGBhOTKq8XcQC4P/AK4qTpdrva3t62UBhcMtxA0PugGsFg0MYKKopLpZLcbrcWFxeV\nSCQMD+dmeSia8ahwZtRl7KrQqOFw2BqQMGmGw2G9efNG5XLZ6Oj/l703iW00T9P8HmoXJVIiRZEi\nqV2KiIzIyD2nq9CDBvpiw30a32wffDB8m4MvBgzY1wF8NGD40BfDA8xlAJ8MH+zxwJgFVWigcmq6\nKisyMiO0UiLFfZcoiRIp+qD8PfmpptszCLnHM0J9QCIztVL8/t///77P+yzlclkvXrxQoVDQ/Py8\nTk5OHDXMzgrvGC0hQwAGE+xmhOUsLi56pMvDABYtyRyMRCJhoevs7KzK5bLFotiGzc/P6+zsTLu7\nu1ZqYK8AFHl5ealCoWD1Nr8rk8k41mFiYkKNRsPkn3q9rkQi4TiKpaUljY+Pq1wu2zdjYmLCu/3K\nyoqHIggaaJTByA8PD7W7u2sz9nq97j6iVCoZvgueZD8p5T7selI7M40MkibpfrcG06UejMfjtodl\n58Gyip2SHbbX6xnCgojebDat8UN1Qpe+vLysy8tLvXz58gGRqN/vO0AHGKxer5sQX6vVPCkEFSB+\njF0YZQc7ZxA5wMZAuh9tLyws2DGoVqs5UJ4jHfQA6ma73bbd2NnZmRGS29tbW3ZR14O40ADe3Nx4\nsBNkGA4GA1UqFcN2xWLR7xvlBfkpiCQecz2pnZlGDFvaeDxuU5WJiQmPUIkbY6GAXqTTaRUKBcXj\ncX388cfqdDo2+wuFQrZwDYfDnohtbGzo+PhYU1NT2t7e9i6Lxk6SHX6INeN3ElIDAQj+CJNCGkwY\nasik+FzQqDyfzztWAjTi66+/tnp8fX3dMRHHx8cPPKdJoZqcnFSlUlE2e69MI+EWjd/FxYX5FLe3\nt2YC3t7e6tmzZw80mBsbGy7XwPVBRxAToCGkgQXC+9DrSe3M/X5fb968US6Xc5PX7/d1cXHhiIdG\no2GC0OLiov3fIPpIUrPZ1NnZmW2oMPWmFKnVat6hjo+PH5DqoVZiOoNrz3A4VL1e9y7H8czYmQkY\nsn/gtEql4mP67u5Op6enJtNTxxOoORgMrMKen59XtVr1xI3EKRpLbA6AIAn9xCByZmZGBwcH5kpT\nnkCBheRPuRU0LG+1WpZN1Wo1XVxcPNjt7+7u1Gq1VC6X9fbtW01NTRm/f8z1pBbz3NycXr9+rUQi\nYbiLXS9ot4XnGjcUqwEYbXhZYDoOUYadjWwTJmw4HOEOCiuNySDQHoMLnPsh1jN2Bm/e39+33wV1\nftAOdn5+3gaGQesxSa7fiUoD1UmlUh7t7+7u2jar0WhYOQIGDwrDBA9iP68fe7JoNOqUKyBNsGp6\nF0hS4OIseiZ/6+vr9gZ5jMpEemKLmXqQWAU67aC8iAVOh12pVFzXQoqBa8DYlv+HrwBmDaoB7txu\nt01wl6T9/X0LaFutljHmfD5vsnuv17M5DMqPWq1mBGVubs67NJ4bwYcLTHc0GrkUQVgbjUZ1c3Oj\nUqnkr6O+pTGliQyHw6pUKnb1pLaHrFQoFDw1pTcgonlpacmuR91u105KnI5TU1NqtVoWFDB04sHr\n9/s21HnM9aQW883NjW8wzRq4MCSZVqvlWF285wiKZDqH29HExITOzs5cFw6HQ5sMgrt2u10nNyUS\nCZPp8edArIofMsOScDis6elpe1cgdyLRFRchfOBw2URYy2KT5IcLx/3z83OfCBMTE36Y4WmQdwLm\nCyZM47aysmJJFrszTS6LsdlsuicgcAivaWLp4vG4rRXga2ACA2RIk51IJLypfOj1pBYzDdH09LSn\nSevr616gcHCDurOlpSWHVUqyiR/TKaT4DEqwBQiaDaITjEajzjeBiMP3Az3hSA+7DxsBYEQmjfwu\nToDZ2VnH/7I7go+jwGZnY0weiUQcQsQED74Jjvd8nAd5ZmbGcjGGRJiIg8VzCsD5CIfD9rjGdiCb\nzer29tbQJR554PoIgWmOsWt4zPWkFjNvEFAcWjRG10ydGN9ubW2Z9A6sRRY2qAE3IxQKuUHZ3Nw0\nV4PuHa7wYDBwHYjzJfwJfjdcYW4uDD+8jSGyB0MimTRWq1VtbGzYqZTaG27J7OyszSLj8biWlpa0\ntrZmuRVOQwyN4Elks1nrB6GgJpNJw5ZgzzxkTAPRkF5fX3tH39jYUKVSMcGL6Sjj/mg0+iDtFhNI\nNpQPvZ7UYkaKD/US2wHpnrhPt87ErNvtGvynDCHQkThidhoSXJH+M66+vb11WhLHOLxqTgQaPZQa\n+EPwc/k6dsi7uzu7DDGGZ0GDzoBrY0pIOQP8lUgkzL3ANy8Uuo+BCIfDymazDxybODnILJTkJCoo\npPw39ma1Ws2KbiaUkKPw+RsOh1bAwANnSsgABTbhp59++qj7/6QWM+NoGsGpqSmPpKlzEWeCxXJE\ngwPPzs56QbBQZ2ZmrEiW5N2TkgDfDRyEGPeygGOxmPPzcPUJRolJ8uKnbtze3nZZgNIllUppZ2dH\n8XhcpVLJDRz8aV4XjkyYrkDqAUYLwnih0L1/dafTsUwqiGxQjlG2DIdD+1qjSgfSlOQhDKw5BAF8\nLhwOGxEiK5yN5ne/+92j7v+TGpqcnZ05944dFz5DvV73mz47O6tisejmjbw74hAODw/daNVqNZ2d\nnblMOTo60ubmpmU/uI12Oh17Qmxtbbn+vLq6UqFQsKEhlriMsefn59Vuty1+xeNufn5e+XzeHhnU\nruFw2P52YNfn5+f+WzY2NswZAfcmsbXX62l5eVmFwr1934sXLxx/NhqNVCwWlcvl/PP/xb/4F/r8\n888djDk2NqbT01Pt7u76fUVsAFsuk8moUChob29Pr1+/VqlUcvNMuVGpVLS0tKRWq2Uvjkql4lLv\nQ68ntTPjesmUj1xn4hlCoZDtYBlns2hZJM1m07sLAthoNOpuGx5H0FMDDgURYpgWSlImk7FLJ8aL\nlBZoCXHdX1tbs5woeGPZwWAA0rg1Gg1TUIfDoT7//HPn/DGIACLD5w5jG7B3yD4sWMb+GCJeX1/b\nCRSUItjIAUNOTEwom82aLCX9xPfG9iyZTLoUopYmGFSSIzg+9HpSi7nT6fhI46hl12U0vLq6alus\n0Whk53r0bvF4XOl02kcsOX/tdtsU0VQqZbgMsxQaH/R03FBIPEF4LJVK2RkIBAQHJh4ylM5LS0sP\nHJfgFt/d3Wl1ddUWV5ubmw67R8mSzWb17Nkzu/FDj6Vpm5+fN6V0a2vLpdba2ppDNWG9ZTKZBxKq\ny8tLy82C0i5kXcCZ2WzWxjfD4dC+IlgvzM3NGS7c2dl51P1/UouZHRi1RDCmYWtry8SfmZkZd/xI\nnhKJhBse0qFAK1is8AyQZ2WzWTO+2A0B/5m4wcfAgzkozwKvhTIqyTpDjv5YLKb19XWrmEOhkCFF\nZGGQn6hzg0qQer2uarWqfD7vk4VkJ0orHvylpSULA2j0+B4oovBGyGuhLuZv4H2EHw2zEKTk9vZW\na2vLh+SrAAAgAElEQVRr2t3dVSaT0Q8//ODhye7u7qPu/5NazGSKBGEggmnwDgYdGAwG2tnZ0ccf\nf2yL1cFgYBLScDjUzs6Out2uO3OaIzDkYLkQj8cde4ZcaHp62l27JEN4c3NzFnkiXAUGhLWHooMH\nhN+DopkgeNAEgtqx2mURLi4umodM00qtzYOP1o9TDVydciv4wMJIDD688KGDDeFwODTXGk4Isi5U\nKby3CwsLJjc95npSixmnH4jfkIdALUAGTk9PNTc3Z34DA5WlpSWPp+PxuI6Pj7WysqLBYOBsPoJ+\nuOGkU0FYmp+ft+snNxeoimMVWIvas91um6jPTkdZgRQJVXg0GtXq6qrd8AeDgS158XLGwBtjxm63\nq88++8zZfCxy+gRI80CN5+fnfj8ZQgXLk2azaT0lpwR+0uDTjPWBAektqKnHxsaUTCaVTqcVjUbV\n6XTszvSh15NCM0qlkgWcLFqST0EvMLvGq+L4+Fizs7M2DCSjo1AoOHgGtQjoAKoIJml4Gg8GA52c\nnGhtbc3jcgxOqLdhx01OTnqELN2rv+nyR6ORlpaWVCwWLYliSNHr9VQul/0AQIrq9/v63e9+p62t\nLRP5QXWmp6dVLBY1Go10cnKidrttZcr+/r752/A+QFfq9bpisZgd9GOxmE1j2u22TRJ5nzF2rFar\npsIWi0VrGclIYZFjPXx+fq5YLGbBwodeT2ox4/7OwmFUHYvFHoD6LFDQg0wmY10bKAU8DJrFmZkZ\nY629Xk9bW1vq9XqOGEM0S1g8N3dra0t7e3tOj1pdXdX4+LhyuZzr9nq9rlQq5ZtPOUPdT6YJ5VNw\nZA8mXCgU9POf/9wLEsUHHOFwOKxer+fBENPDjY0Ntdtt/33s9uDk09PT2t3dVb1e98fA7kFEMK/Z\n2NhQt9t9IGplMokT093dnXq9nnnbQdEEviYfej2pMuP09FTpdFrS/U7HgAQmGvo6sM3r62vHpJ2d\nnXmHBY9GCRJUaLdaLT80hULBi5mSAlPzfD5vrwy8L3DWJJ6C6SDkHRh5MPCGw6FrS2xxiU0gFIhB\nxuLioo6Ojsw7QXUdFLnCyhsOh/bBmJmZMf2VRAEefuipvI/kw7DjM1y6uLiwsTmUUTBxYpn5evoG\n8lfgOY9GI/3www+Puv9PajGn02n1+30tLCzYXYjun1qQpk2S3r17Z1ZXNpu1ZAiNGtkjNHGor/f2\n9ozjFgoFN569Xk8bGxsWnM7NzSmRSKhUKrm2DdoPIDQ9Pj424yyRSGhlZcXlBB5w4+PjOj4+tuv+\n5OSkI4klmWvd7/eVy+UUDod1enqq6+trFQoFL3rcQKempoy5o/CuVCqKxWIqlUpuCIHVIN3T9EGY\nwlCSMbskswShgzJtpZZnNH51daVYLGYPvz9wMwIXuXszMzNmbSHIzGQyxm0hDT179sxfDwMuHA5r\nY2ND29vbD7JQsJeamZlROp3W9PS01tfXlc1mjUlnMhlzP2DT9Xo9ZbNZw4QsgKAjP4gLC50HaPPH\ncPdkMukSCNNHyENYyoJhLywsaG1tTSsrK/roo4+cFgBHYnl5WcPh0G5MPGDz8/N69uyZyVh40lHO\n8NqICoZRxwh8c3PTgfAQmIDwQJbgxsBKfPHiha6vr202/vz580fd/ydVM6O4gLcQDocdp5bP51Wt\nVhWJRFQoFOxnfHd3p1qt5mDzqakpvX//3i75HJ+vXr2yFRUmJldXV9rZ2XEzWC6X9dVXX2l6elr5\nfN5JTUQVQ0LCzX5nZ0f1et1DHRpKOMSorJF/oStsNBr6/vvvtbm5qdFo5L+B+ndvb88EfUlefCS7\n0rRFIhG1223j5ijMT09Ptb29rd/+9rfa2NhwNIYkB7f3+32HBd3d3enk5MQTTbjVmEySG7O7u+vd\nHn4Mwt5QKKR//I//8aPu/5PamZEtzczMWG9HPToajbS8vGzjFaAiSgKaHVAD/Jw7nY42NzedVBqN\nRm3R1Wg0HAXBtAy3e0oTBgo0YxzPxK5RI1NXAsuBRyNiTSQS5j0z6AFqk2SjchQfnASw/hjBd7td\nux7hkYHkCpiNciXoOw0zDu4xzbB0P/YHzYEHTiP5+yruTqdjr2qgPBrotbW1v/rG/hteT2oxB7to\nRshEliWTSU1N3aeswlqDN8HORQJTPB73EYn5+Pz8vLLZrAaDgady29vbthaAXE5TRhNZrVa1srLi\n8oYHS5K5xOl02ho7poPLy8t+6BhybG9vG8aCB8zu+9FHH/nhxYMDpt3Lly9NLaWhq1arSqfTfm3x\neFzJZFK1Wk2bm5uOpWAKGo/HjRdfXl56ETI+X1hY8AMWj8d1eHhoZiDsPTz/cEzi9a+ururVq1f/\n7gbB//9xMTomiJwJG7IgYsoYZBBAI8lDDmLLJNnJEky4VqvZ9RPaJDznoHdavV7X8vKyCUGlUknN\nZtO7M0MHShtomdhxBX2i2VHhMxD4EzSGQQVCvY1VV7PZVKlUUqlUcuMFrRQcGv53sVh0UsDl5aX1\nhpQf4MWEADGYYsTOGJ8h1OaPUc6w8qamplymtVotS8wYZbfbbeVyuUfd/ye1mOFhBB3jkeGjWIbg\nAlR1eHiocrls2Twj3qArEh+jocPBHsYYxztWrclk0uNvOnyidrGsKhQKJuYwSKE55GuJFD45ObGT\nPhg52SmUCkCDGJoHd01YacGwScoT7G3n5uZ8KmBjxpDo5ubGVg1YFRweHvq9ZuCCypzQHiRVCFYp\n+XgNTBoJpX+so9GTagAjkYh1gKurq5qYmNCzZ888+4doxDEMkWZzc9OqbI6/TCajq6srRaNRp7lK\n8i4Inj05OWkuBAlTlBuhUMhk+WCGH6JVcv/W1tbMT4YmyTBhNBppZWXFWYAc41h9URf3ej0brc/P\nz3vKiXvRaDSykz3EJz4H7RQi1cXFha3FEomEms2ma2yQDvwvglnilGCUbZg9kn0oyf3FcDjU1taW\nDg8PHyQJPOZ6UjtztVp14/b+/Xu7AdGoIU/K5XLOKGF4wi5B1h0jYngLiFhZjMPhULlczmUCudJj\nY2MPcF1cRWkmGWFjLzs2NqZisWiaKfg4CnNKEEl22Gw0GkYrKF1o0sbHx1WtVlWpVCy1gvfMqB6T\ncr63Wq36yGfUjfUBwxskVahlKG/QJoLDM/bPZDI6Pz9XJBJ5YJxer9dtOFOtVj3iH41Gj+ZmPKnF\nDHdhfHzc0WnAdRxtCwsL2tzcNJZbLpeNCSMyZayKFQBkdepRdj3MEGnKGCuPj4/b6w50hHp3ZmZG\n1WrVmSWMwLFIgGO9urrq5isUCjloE750UIiLqePe3p4kmbMNfgsJKEhRBW2hfl9dXbXEiQeb0Tml\nD2UDfiO4m4LEnJ+fm7ctyWqXu7s7ZbNZtdttP5jBhAOmin/YmQMX2rulpSUfjeyCxIMR7jg2NmZ9\nHrgpolRYcBgTUnem02nt7u46KxD93YsXL8xBfvnypebn57W/v++dEqI9nOSvv/5ak5OT5iODc29t\nbWl7e1uJROKBQz9eFvF4XMvLy+Zmw97DVD2TybhkYOHi67a2tub3Bg8+BiTZbNaKksXFRW1sbJjR\nB/F+e3tb5XLZ9Xg0GlUmk3G5tru7q+3tbRtTQuQClbm4uNCXX35pduLd3Z02Nzf17NkzpdNpv4+P\nuZ5Uzdzr9ZwrIt0LKNltiQdDwIldFFZTBGKORqMHnz89PfXnYrGYv2ZxcdGaQ1hx8/PzqlQqfhDY\nbWiWKBkoXSYmJixobbfburi4MMuvVqtpYWHBQlP82iKRiBqNhtrtthEV/JPZ+fj7g1azNLmULzSf\nJycn7jUqlYqbvYWFBUfI9Xo91Wo1vXjxQnt7ey4lsDZgQCTJeDS5isCQg8FAR0dH5qCA7zPyTiQS\nOjs7e9T9f1I7M1O5Vqv1IP4LkjsEI5wtQS+YjKEeCdoUhMNhdTodO3bCYYZhtr297RgDcu+Wl5fV\naDS86Bit4ztxeXmpYrH4oKlMJBIP5FmZTMYNFrUtzDcsFWjQeO00c5gd4kcBDIhLKqXR0tKStra2\nNBqNHONGGQPrjxE5DxT4fDwed63LAzYxMeFgedThwI+UfIy1EeyiqAkmu37o9aQWcyqVslJEuseJ\nOdLga0QiEW1tbdlDglo3Go1qeXnZiwnzE9w2adhQkfD9+/v7Nlth+CHJQxuMBBnYwMGIRCLe+ajp\nLy8vtbKyYhMZ6V4QC3UV9IG/dTAYmKBDnRoKhfTxxx/btBHYEF4Fi35paUm9Xs9cDxCgbDZrqiee\nckB5jPJbrZYNcUBriIBg0IIqZmpqSolEwmUOpc/ExIRevXplstHU1NQfAnqCF2SY6+trnZycaGNj\nw1RHQuDz+bx+9atfKRKJ6OjoSJVKxXgto+ZOp2OjwF6vZ7Th7OxM5+fnTpY6PT01uaZcLuvXv/61\ng2mYKK6srJgAj+F3tVpVtVpVPB5XoVBQLpczsWd8fNxZKs1m0+mv5+fnRlNarZaD2MlL4b+Hw6H+\n6T/9p6pUKtrb2zOzjqEPKVKUE4gYcrmc3r9/r9PTU719+9bUTeLPsCCA10JjCEJSq9VsME49TgLs\n5eWl9vf3HYtRr9c1MTGho6MjIxynp6f6i7/4i0fd/ydVMxeLRfMFvvzyyweGhdhjzc/Pe1dbWVmx\nHD5oIYWOD+ehtbU1T9uAm2ZmZtyA7e/va2xsTNvb23YvIv633W5rZ2fHHsbsWkB0kUjEYlD8L4C9\nUqnUA487mjqOfIJwsBKjXEBpzTEP6gCygys/tfbt7a3S6bRV1xCYMpmMWYdM9IDfUL7THDP+pi/g\nayASJRIJRz8gbg2iHisrKzo4OHjU/X9SOzPlBESbSCTiGF5CYaampkzlZNHAv6A8WVpaeuDlhuIZ\nNyJ2SqAkyodQKKSVlRX7zyHgpEYMBviAmMD1JXoNmI6dnQUZDJIPuoiCyEh6ENWAbq/X62lubs4c\nZUlW11ByQOOkrOB9BPHhtSCWHQ6Hjp+YnJy0IBdEhJBKavhMJuO/A0ejnZ0diwPwruPv+NDrSS1m\nSDTlctnHWqvVUr1eV7FYdFb20dGRZmZm9Ktf/UqFQsHDFrr9vb09R6vhMs8xn8/n3WAeHBzo5uZG\n79690/n5uWZnZ60kGQ6HPhkYGcNQq1QqajabDsPE/CSYKnt2dmaeB/yParVqZl65XFaxWHR4EFZd\nlEXsjJeXl3r37p1Za3hroJwBJTk5OVG/3/dwaHx83AkCEPf5mzGt4QSCjzEYDFStVu0dx7j/9PRU\nzWbTrymIS5PFMjEx8Wiz8SdVZgSPUnbf7e1traysqNvt6quvvrKKWpI+/fRTL+zJyUkjFp988oki\nkYjdPqPRqJLJpPM+4DXE43ElEglDVevr60okEjY6XFtb09XVlTKZjKGofr+vdDrtgEdcRwlgh4b6\n+vVrB72DB7PLMuAhFhnEgsEIxoaM7nO5nE1gcBJdXl52CZZOpxWJRDze5zThxMGylkEQu3gymXQ5\nsra2ZjlUOp22NGxzc1OZTMaw38LCgkW8/D6SYl+/fv2oUuNJLWZqMCAmYgfg1WKzGgyvZEq1vb3t\nFKlOp2PSC/U0imUWRzweVy6XswL77u5OBwcHdtpfXFzU6emptra2vAPhPoSw9OjoyGIA6I/T09Ma\nDAYmr3e7Xa2srNh5dGZmxkpr4hPwocAeiwgHQiURtQbjkfleHiDc+iFojY2NPeBct9ttNZtNdTod\n7e7uWk9IFB0lAzXy1dWVlpeX9e7dOydLra2t6eLiwppJyP2tVstw4GOuJ1VmEHrDmyX9xAqDlEOz\nxK50dnZmzWCQdhkc69ZqNVWrVfstY/iC3xrYKbsqWSEMAlBy8JAFgxxnZmbs5IMrEaR+xLCNRkMX\nFxembEajUev2GO5I0tu3b13OkCRF+VOr1Yxi4CWN6xLvDzzvq6srZ4zQH1Dbh0IhlctlHRwcWE1C\nEA/2uYgjoJyiuTw8PLTDPi5R1O1BhuGHXk9qMScSCbXbbZ2enrqUgHIZCoWUz+ddThwdHWlpaUnb\n29uSZBok7K1YLObBxPb2tpsvXC2DxzGG4gxSWKRHR0eSfrIGS6fTjheGU8xiQOmC+pvmFcYZIezE\nTKysrBg3Jt96c3NT29vb9prDBxkpGeLTWq1mhqAkDz7gevOeMWzBsYlmOhaLKZ1Oa25uTs1m08gI\nDzhBnDx8QHiM9Cm7wMmx9eJefOj1pMqMs7MzcwPAmXHOhDDP7rGysqLT01MVCgV9/fXXkuRy4eTk\nxJL4XC7n8gV6aa1WU6fTsUyo3+8rn8/bAoCEK8jux8fHisfj+vbbb7W8vOzMEhqrVqtlSJEmjXRU\nJmSLi4uqVqsmDWFSw2Jh52ZBwgbENXRlZcVjZowXh8OhST6dTse0VhYhDDrCgebn51UsFrWwsGBD\nSU5AoDbscEFE0P/Nzs7aSSqYPx4Mvnzz5s2j7v+T2pnHx8d1enrqIw+yPMT2arXqBrFQKBjmoq7m\nOJ2ZmTFDDgta1Crtdlurq6tu8ra2tlwfcpNAMAiumZycdNIrdFMol9S4FxcX9jumJOKhuL6+Vq1W\ns1Po2NiYc0+IfWPhEA1HeYE4NhjGUywWTb8Ewkwmk5JkDSWDD3jNvG5OHdAIal8oACRhUeLUajVv\nKCQSUKdzoQ5/rN/ck9qZGYlOTk7qd7/7na1S5+bmtL6+rkgk4vru5z//ufL5vEWhDFBqtZpubm60\nurpqYnkul9Pu7q6dfoKZH9PT0/roo4+Uy+U81oVSSk4HCafdbtfiWQwPkVuBvEj3vGzG1gxd6vW6\nLi4utL6+7uYTt6Bms6mjoyO9fPnSihpKrvn5eR0dHemLL77Q7Oysstms5f6YshDAA8OOkHqosuDG\nlAu8X5FIxDrF9fV149iUPzwEm5ubhgevrq6USqUUj8c1PT2t4+Nj1+1/CLUMXEFXeWAkorzYeTEQ\npwEjE6/T6ajVaimdTiuRSKharbrDDh6N1WrV6aLgsKhTmKC1Wi1r9JgEgiiAQUO8v7m50dLSkmKx\nmL755ht1u10f2dTDhUJB3W5XyWRS19fX5hJfX1/7n6mpKeegoA6pVCo+bcrlshqNhnMPcfAPRprl\n83lJ8kQSJIPvw7iG4Qc4NtYJ4NN48dFI5vN5+9zxM66vr3V0dKSTkxPNzs7q/Pzcjv4fej2pxYwq\nAvM/TAexucJzAl/km5sbpdNpFYtFnZ2d6eLiwg5D7BLX19denDc3N955GQtDRu90Ol5k8XjciaU4\nAbGjsbvDU2C0e3l5qU8//dTsuJubG0cNo/5GNxiU+NNoBR30MYgk6+T169fmKjM2r1QqZrMFx+Qw\n14AFUchQ58/M3CfbFgoFlxbY3SL0BZXAyByTcgQHeHUMBgM9f/5ct7e3xuwfc4Xgm/77foVCodHf\n+3t/z4w2Im07nY7W1taUz+f17Nkz7e/vmzOAjo2FwGCE7n5/f1/Pnz9XsVhUKpVyd399fa2lpSXt\n7e0pk8moVqtpbm5Oktx88QBFo1H1ej2tra2p3W4bY+52u1ayIErF544HcnFx0SIDHgoeJBznpfvG\nNJ/PO2SSr+E0KBQKevnypVNS37x5Y0SC3ZgouEKhYGd/mk8eVrByONIYKBJRFwqFzHEmiUCSc1ku\nLi7sWY3nM2FDWPv++Z//uUaj0QcpW59UzdxsNs2txbEnn89renpa5XJZp6enku538C+++MI3EtRh\nb29P09PT+uGHH/TixYsHsp5Op2PEACNBvOAoYXASRawq3S+0q6srj4tZHCcnJ3r9+rVarZbev39v\nZyTstorFohlrlAIMMgaDgYUBDFmur++zCnmdSLVQdON0j4Ch1+tZmIAYAIrm1dWVPvvsM/3617/W\n+vq6RQzo9DKZjMuQubk5S7c4+fgcihaGTvA6EDBcX197N7++vvb9+NDrSZUZcBgikYjS6bQDJhmW\nhMNhJZNJbW9vm2iPJ7Ikk4pYMNjfBqX5mIBLcgQvquebmxuLNyEXUTfzM/CFQ/U9OTmpzR/Tq/A9\nbjQaSqfTtjdgh2M3Xlxc9AiYWAYWONIvyO6w5xgUofpmV0fahWoaCi0nCLUxQxOQlrGxMfX7fSvR\n+X++hixEBL+UF0S2QWBimvnY5k96Yot5eXlZ+Xxe7969Mxnm+PjYZPOjoyPjwxBmgnAZuCfwWC6X\ns76Nm48UCKYZllNAVjQzl5eXJiIxgJFkcxZGx6hLUKvQvBL7hhcG3hLValVHR0e2zuK1MuhgVH17\ne+uJH8T6q6srR5RxkuAN0u/3PXbnocHABaI/ZRaELjjXjPppbPv9vur1um192X3RD0qyAp4Thbr6\nMdeTWsyMctlRsZDCYyKdTmt2dtalABRFJmEoQzgaaXoODw8Npy0uLmp2dtYEc2pN6kUWNNRImGiU\nC5JMh2Q3oyaWZOI7BH1w2dnZWTtrMm0EP2dEfnt7q7OzM8ORq6urHu3zgFCjg8ODtExPT2t1ddUo\nyu3trc1gjo+PdX197Y0BJ6NqtfrAJ4PhDQFIqE6YGuIlQvAosi6cmP5gaRu40MdFo1GTcsCRMekb\nHx/3LhWM+oIWiUwK6AtJE8ckrpt4wM3Pz/vmEizJlBAcFrYcuxcoADufJJcUUCQpB5A9MbEjUKde\nrysSiTgDhTg3/KbhZzAkgliEzIlgeUm25EUniFFMLBZTs9nU4uKihsOhzXLYtZPJpAc4PPyE/QQ1\ngEwiKWPYaCA0kQmIGOJDryfVAJLn0W63tbm5acIOY1aOYdw0gbFSqZTNADn+KU0YGsA2k6RcLqcv\nv/xS1WpVx8fH2tnZsUUWRKGPPvpIY2NjWl5e1tnZmR2ScBhl4Y2NjdnqgJ8PbEcj+fnnn9sghUZx\nZWXFY2AeMMJ/GEyweOFbkAfOsEWSxQxB8xa4Hufn50qlUqZ8TkxM2MUTlUkkElGxWHwQkzExMaHV\n1VXnAFJaMY1EUACDjjLvDxPAwIWTEDxgIsMYZNDYdDqdB5BaoVAwwwu6JdwNRrtwKc7Pz7W5uam9\nvT0NBgNtbGzo5OTEnfnNzY0ymYx50nAQ2GF7vZ5WVlZUKpUciEksWi6Xe2BRi9r5m2++sSrmzZs3\nSqVSqtVqev78uebn550shY0AJw9Z4UE8nbLj6OhIr1+/liQTs2ZmZvT+/Xul02lPJ7vdrhYWFnR8\nfGxIMRwOq9FomGrK68Q4cXJy0hI2Itqq1aoNFxuNhvsGSGDRaFTff//9o+7/k1rMU1NTRie63a47\ncnZCTEtACJ49e6Zvv/3WhirD4dAUxuFwqO3tbftiAItR30GW5/fRtUO+oWbGDYlBCUR8yFBbW1se\nuLCTz8zM6M2bN8a7Z2ZmDIlBAqL+r1QqbhwpXZ49e2ZIjtAfVCjEMyB76na7NoFJpVLWFDIpZeEu\nLS2p0Wg4I3E0Gnn8zRSQJhT5FSUPjLqtrS1zQlqtlnZ2dtRoNJwUOzY2pn/+z//5B9//J7WYufGT\nk5N6/vy5ecVMvoDFrq6utLq6qkKhoK2tLZN2YIhFIhGtra3pu+++89FI84SDPC6ia2trtnulpLm+\nvtb29rYdQ4kdg8iPwBSlBiHzg8HggahUuocbQS54GKampmw2uLu7q3a7rUqlYh8N6lM8N3AXQjgK\n9LewsGDrXRQvWAHMzs7q+fPnTpcCjej1eq7vz8/PbReAWhvWYq/Xsx4RtIXdHWSEAQpNI/YKH3o9\nqQYQpUK327UTESR1tIEXFxdmrUn3xHtgPCIO7u7uTKXkZ05NTVkPCG+Dpo+RM00X/ASOeeA3YCjk\n9aAQ3W7XaABNHxM/eCWMw+GAnJ6emrWGsoUHNjhCl2QFdrVatbkLdFcULJxkWOiGQiFzoEulks7O\nzlzbA1/ynqFDvL29NU4O1gxjj3KLJAGijnlN/X7/DzmAwQszcGRHGFtDjcT+lYgESC9YSSWTyQck\noEgk4nFyrVYzKoArKDv9wsKCer2eSqWSmyJUL8iyKHWC0BlxCjc3N/ZbZsrY7/dNOKIWZ3Gw2+E3\njXs+i7NSqbg8IAxIup9GFotFc1fAskFY+NuBznK5nJUmLFyYhLFYzH7VIBQrKyvGlGu1mpvMarWq\nq6srMwiZdBYKBZ86DKcecz2pxby0tOSbvbm56eYH4g55fMPh0CoMOn8GFBcXF673grsY1gFBZUcQ\n62WBTUxM6OOPP9Zvf/tbB6KDX/N9QVgNNhzHNgsJGwOGHvxdwGJ4Xuzs7CiXy3mEvPljzAW7J6cB\n431MY7BBWF5ediZfIpFQq9XS8vKyHZhub2/NQwFjxyNvMBhobW1NjUbDmwjI0OzsrJLJpOttoDpS\nu1KplJlysVhMqVRK1Wr1Uff/SS3m4XDoHemXv/yl/uRP/kSHh4cKh8PK5XIPvOX+5E/+RL/4xS9c\nRuB42e/39c033+iP//iPdXh4qJ2dHVsGYF8gyZ7GOzs7zsFuNpv67LPPdHh46PF1IpHQ999//2Aw\nMjc3px9++MHZHgRWMnLv9/s6ODgwXAh/+pe//KV+9rOfaTgc6vT0VJlMxlq7/f19ff7556rX63rz\n5o3TsW5ubnR4eKg/+7M/e3BSXVxc6ODgwEoXoLLBYKDDw0P96Z/+qfb39810m5ub08HBgT0/MDsk\ngFO6JyuVSiWNRiO/zyTmFgoF7e7uOuuFxhGeytjY2KPRjCdVMxPIAy2TuhW8mRIDGRTQkCTzJthd\n2YEl+SiGnwAJnZ/NRROEUaMknwT8TkodMGkGFpOTk8Zc+TpOkuDXUEPDOaYsYBIpyb0CvQCMPl4j\nP3NiYsJupMCIvGa+hr+D30lCV3A0Lckfp2zi74UiwP3gNQZptLxG2Hgfej2pnZlmhPq02+1qc3NT\n4+PjnlIFPTA+++wzlUolT7iIffjZz35mvJrygZEwqa4rKysPFN/cJMSm1L4cvUB6PCSYFRLZAFxW\nq9UsosUtlAki5QbWYhzVi4uLuru7U7FY1PLysnZ3dz3pY6HiBUcDDBei2WwqmUzaHw8TSaIqss3d\nTJUAACAASURBVNmsSqWS+Rk0fsjEbm9vTW4iuWt+fl7Hx8c+GaC6AnsCWcLC297e1mAw0N/+23/7\nUSE9T2pnJguEGpB/BxlZKEbgXaRSKVtLsYMxOcNsheYE9hej716v57Ev2Gu5XFa1WvXPZLeCWokr\nEbRSdkGwbXR+lUrFVElG4UiugMqwsg1i471ezyIDcGdJdvPk9Go0GpqZmfF0j4xCILWJiQlnhgPv\nURbNzs6aHCXJzlFwL0BSkE7ROGIHjM0wHHLQmsfuzE9qMW9ubhpPRYoEngnLjboYvJTFhdWs9NMR\nD3KBfzK0ToYJ3KhWq2ULg7W1NSUSCS0sLGh1ddWNJCPnyclJLxKyQNDYseviXIRmES4IWDjZehD4\nGctT266srDjCeDgcuinjdfF9nCpM4SAwscPShGKIKMk+diA4sVjMFr2QpsgEDH5tNpt1GQW+DsZ8\nfn5uEexjrie1mKnJwJQxLCEXsNFoqNvtql6vm6eLNAhYCp0fOjU0cCipcfeRZAUzwZaFQsE8CEa7\nDEsWFhYeHOM0SZDVQQYYXiCuZYGDBTM6hgeBMhsyvCQ7CpE9eHx87L+LiRyLB14E9FB2VngpPEwE\n6pTLZW8I8EDAmOfn511KsXOXSiVj1jDsrq6uzImm1gZ3fsz1pBYzYk92tvPzczcwmKywQ3EzkExB\nrL++vlY4HDbyMDU1pY2NDbO7cI9nYsfN5zhmOCHJgwjwaZh8DDtoVnHEr9VqqlQqD8zDsRoAamu1\nWuZLBOvwYG4frDXstGZnZ83jhio6HA5NLuLvB6mhyQTaQ2XOyRU0d8HVFBECECjDKHgtmL4QLIp2\nEa8P+ofHXE9qMff7fTvlg0xQq7Go0Zo1Gg3vxKAGtVpN6XRazWbTbLrBYKBCoWDGHQoKjmL4B7Dx\nSH1FdXxxcWGhKGYrdPhQUsGpg2GPwREv6mkMYDKZjAqFgur1uutd6aeUWWrZbDarRCJhES0fv76+\ndiIrGPfi4qJWVlYsb+JnsWvCJuRhgfYKagKygnaQoRGlCg8w2kumnLyvsAkfcz0pNAP+ctBG6tmz\nZ/ZdBthPp9PKZrPK5/NuwMbGxrS2tqZQKKTd3V0HvlODQn/c2try+BWUAoroZ599pkajodnZWW1t\nbSmdTuvu7s4nBMR4rAComVdXVx+4gDKEwAMPn4vhcKjl5WVzGwifZ+FR6ycSCfth0BRChGfs/erV\nK/OdIeHzHiCFSiQSDsREFfPy5UsPWCQZA0eIgA7yiy++8APICYb+kJOHzST4UD/melKLuVwuu4Q4\nPDz0tC1IXWSRwg9GkNrr9cwVYBwcNC2EI10oFBSPx3Vzc+PpFVev11Ov13OqEg3Nt99+6yHGYDCw\nTW6pVNLc3JyKxaLK5bJ39YmJCf32t791LR6NRnV0dKTRaKTt7W0dHx8bScEuC1uxZDKpcrmsV69e\nOWpibm7OYlF203q9rmg0augPRIQSAXd+0Bni28rlsr3rfv7znzuCAswedQlWYiRrYSr+7t07m5jP\nzc25ESeh9jHXkyozCHthaEHjxxHJoiTMnJ0AnjKex5CIer2e7VhXVlY0NjZmXJjdPJPJaGxszHBa\nuVz2Tg35aHt72zIpeBc0oSQwsSPCcFtZWfGQplQqaWpqynTRra0t/6yVlRWP1RHYJhIJG0PCc8bJ\niAVLkhVjf5pS+BIMXhKJhHHzer2uTqejZDKpVCqlTqdj4exoNDJ1lLII56Lr6/uMmdvb2wcmlCi5\nJdnc/DHXk1rMZIXgI4E6mhqOWvHs7Ez9fl/7+/tuhlKplDKZjPb393V2dqbb21s3UCxEUI2DgwM3\nZe12+4Fa+auvvvLuNDMzo6WlJRttw3oLh8OuiwuFgs7OzrxL7+zs2NaqXC6bfipJ33zzjeLxuPL5\nvNrttur1usuYt2/fGjl5+/atwuGwms2mSqWS3r9/7wWP2eL8/Lw6nY6KxaLTAEBE9vf3FQqFVKvV\nPMKfmppyhjgCVkoZGjvek4uLC2WzWe/aWOGCboCy8HO73a5KpZK1mB96PakyAwz16upKf/qnf6rL\ny0ulUikvKEmWD93c3Oirr77Sd9995yYJZ3e0bIlEQrOzs5ZgUZdKsgCgXq8rnU4bZoIRJslG4QsL\nC57e4bu8trbmRSvJqEe1WtVgMFAkEnH4ejKZVLfb1SeffOJmFZtcBAG7u7sevrx+/VrxeFynp6da\nWFjQ+vq61Si8P3jLDQYD7e7uuh4PyrcWFxe9uw+HQ+3s7Oj9+/cWEcAbCdoWsNPCf0aqBa58c3Nj\nXSaDHAZUq6urev/+/Qff/ye1M8NTGBsb8zCk1+uZX1utVi2NHx8f18HBgfm7qEbgJNCUgJHOzc15\n8bGrTU9Pa2trS6enpw982ihJWGzwgKFsLi8vW0YEP4MygCENKhAMYeAVE5/G7giaIN0/zEFTFngg\n2AXQIMNeGwwGLnn4GfQTePSBNqBU4YFh8IT9Ge8Xihegu2DZQSmCvUO1WjV3nGi5x1xPamdmV2FR\nTExMKJVKWbIkyXKf8/NzbW9v6+joSJubm27M2u22lpeXlUwmdX5+/iDgcXx8XDs7O47MhWQONbLT\n6XgxAkOBw/K9OCQlk0mdnJyY8wCbLBqNGgpcXl42cgIKA4WS188ImITYsbExh7pDxWSHB+kpl8uK\nxWI2mlxaWvL7FovF3DMQRElID4oUhklzc3NKp9MPLMWSyaTla/Pz8yqXy0omk/4bgkQjmmAQjp2d\nHb19+/aD7/+TWszr6+s2AEdbhs1Wp9PR+vq6fSwghf/RH/2Rrq6uTAGlyYN4c3t7q9XVVUmykHQ4\nvA+rpIljBIxfRigU0tbWlkfM7OD1el0zMzNuisbGxmwaAy+E45dkKnZy6JLscs+fPzcLMBwOq9Vq\nedgDG44mstPpKJvNeleH2Tc9PW2no2g0ajx+eXnZej5orBMTE47MYJCCDnJjY8NoBM33p59+qna7\nbUiQkCRIX4y2d3Z2nFSF2fmHXk9qMe/t7SmZTKrT6ditvVwua3NzU41Gw8gGYs18Pq9KpaJPPvnE\nYTmpVErv3r3zsGRhYUEnJydWRoCYHB0dqdvtamdnR4PBwEc1ZCHKEYYIKLgJaz87O9P6+ro935aX\nl7W/v2873aWlJUuKqIuj0aix4W+//VaffPLJgwFFtVrV+vq6qtWqyy3ITPQEcCkgy0tytASO+NI9\nflwsFk0uqlQqSqfTZtCVy2Xb8VIGQXY6Pz9XPp/Xy5cvjR5VKhXFYjF/PaaNCHwJOHrM9aRqZlwz\nyZqmucI1kxuG5Oju7s64KbwJsGEaMr6HsWu1WrVkX9KDOAigMnjAMO6Y/mF0CFQInCdJlUrFtTW1\nKGE5xBnX63VPJ4HmsAfj9+C0dHNzo/fv3xsWAyZklAwBCoUNY26wa9AP0BqGGzwYDD3gfmNRG5zC\nnp2deROhNKNODoYfQStluPWh15PamWma0Oxx5PZ6PQ2HQ+3u7jrlCPohShI4wYzC5+bm9Pr1a+c/\nX1xc2LwEXBXQH6sCBJ3JZNK8ZGRTkmwdRm0+GAy0ubmpw8NDB8PH43F9+umnOj4+VjgcVjwet1VX\nIpHwgltaWtLk5KS94lA9Y1ozGo30/Plz/+6XL18qn89rcXFRxWLR2SaSzGhjyMGUkJNqf3/fFr9L\nS0vmVmNxMDU1ZdMbFnkwi5HIYpo8xK7r6+uKRqOejj7WPPFJLebhcKj19XUnhMZiMb17907xeNxB\n8MBBn3/+ub755hu1221LmrDqajabFoaura050AfXeUkPXO/L5bIZdWSaMEZmbD47O6tGo6FoNOq8\nwRcvXiifz6vb7brGrdVq5ikQBAQH+d27d1pdXXWAD0c7zRm77cHBgd2Q4F3ncjljvoQPYca4v7+v\nZDJpQcFwOFQymTSunEqllMvllEwmdXZ2po2NDXuJUMc3Gg2trKzY1Aby/c3NjfL5vG5ubjQ/P6/p\n6WlPZbH5Jcrtn/yTf/Ko+/+kFjPHKME7kHx48pnMSfdkm/X1dcViMSUSCVvh4i5E5ggKFUmehN3d\n3YdTorwIBspTkrDjIOiEIRcKhZRKpWwpgEgWfzt2V1AXdnyaTsonfgdiA9h1k5OTymazrtV5Hfw9\nNJ2E0jNan5yc1NLSklO5+v2+zSXxGWm1WrbbmpmZ0cLCgmZnZ209FswfRxaFjTBja5rCm5sbbWxs\nmE4bDof1R3/0Rzo8PPzg+/+kauZareak08vLS/v/BhNGGWsDodEUnp6e2t8Ygg6RwOz0yP1XVlY0\nGAx0dHTkBXVxcaFer6ff/va3pmqCdYO9SnJWNmJV8FhQB6A7WH/dbtcTOlKyWDBTU1OmgoLYML4u\nFos+RYrFovr9vhtKFh4+yWj2iMCAg4z7KKJYkqoYAOFzwZh7enra9l9MTmdmZpTP55XP53VxcaFo\nNKpQKKSFhQVVq1U77lNjP+Z6UjszMBcYLWhCkCLJsTwcDk0ikqRkMunSgXowOLkKh8PGrgnkgfZI\n3Qw0NjMzY9srhgxwhokpY0wNkw05Fq8VeuT5+bkymYx95HhNpJsCpwGJ0bjBk2DoAZF/cnLSLDaY\nbDRfg8HA9FYmpf1+385H1PBwnzn1hsOhVldXXT8H45zJ+qaJRM7W6XS0sLDgARHUg8dcT2oxMxgB\nDYjFYl6AwGJB82sUx2NjYybm09W3221dXFzo5uZGzWZTsVjMC5LMFBQi0WjUE75qtWouRblctkki\nNx4zGcxQ5ubm1Gg03N0TY0FAJnkn8D2CtrfJZNIjcEI1seeCSwFngqhjmra7u/ugeqC/k5MTxWIx\nuxoBH2KE02w27auBMhxord/v6/vvv9fU1JTW19e9y9K/cHW7XSUSCZVKJT179kyFQkHtdlupVEr5\nfP4PfObg9fz5cwejVyoV46EQfK6vr92QwZ8guHJ6evpBohJJTezITMYQb0K4X1hYMOWx3+9rfX1d\n6+vrqtVqNjjM5/Pa2Ngw+T8ajTosh92KAQfjZ7wp2O05iuFNAAHi7zYxMaEXL14YZqP04HUzzgYJ\nodxgZM2ODucavjTcC3oN8gopDzBgZ2QeNG9kEETjmE6nbfWAuQwIBp7Rj7meVM2MnRVOlNVq1VTQ\nwWDgRoQdm/IAJAADbG5yOBxWtVq1+6YkT7mkn0y6gbrW1tb8OuAqsCCx/EKhjA4vaKrSbrdtOdBq\ntRSNRt04IrcC3wYBYHSfSCT8eRpgHJLA3SmxGCkDRQK1zc/P23ZWkn3sGFNHIhEtLS2ZDYfcS5JP\nMzBuHPgZvQffA6IieC/RbiJV+9DrSS1mRsvdblej0cixvxBhisWiGx2mdTRftVpN7XbbuwtYNf5w\nHK1k8rEAMW+ZmJiwIJRygkYJmI4bDe+Z+AhuJrtas9n0IoTlhoxLkn833Ohut+uROo0lYZ1B7zw4\n29fX1zo7O3N9z0IcDAaG0VjEDHigZ/J1NKwMi1CeX11dSZJOTk40GAx8QrHokYxx8b1BA5wPvZ7U\nYpbk+T+NEvxhTE/Gx8edecIYlYkYuw6UUPBnxsiE09AE4vMMNMZwAPJR0IKK6VnQ6BB8eHp62kw4\nFC9EFv++m1FwUWAQDnSHxAqbL6DAlZUVn0ixWMw0Vb53YWFBkUjEAl+IVXA8Li4uTCHl75+ZmXEu\nIaUWJRpe2JLMt1heXjYhifuApzUPDxDoh15PajEXi0XNz88beyVC9+bmxpOnZrNp2iJvbqVSUalU\n8lDk+PjYGSBATCizsQqg5gRzJX8Pdhg72Gg0cug7dE2kUexwSP6xCJuYmPDroVShgQUGC0JaDC6w\nPiBQiMaNRq1YLJqKKcmMPLgduNmjHOdEoAw5Pz/XcDjUycmJnaCwNMD1v1arOTKZRns4HNoscjgc\n6vj42KN3VC0IeR9zPanFjDMn/scYm0DBhOQDFAXEFg6HTbfkDaV+u7q6MtRGWZLP523kDYbMjgTv\nAH8LGhyw6JmZGXt5SLJ3NBM/iDdgyVjISvJgg9MEvgi8kmQyKeknewIWN+UColFcSXmdQGIMlvh6\nyrVgk3Z5ealsNutmmdMPR1U2EZAWGsugmSLpBfPz89ZNBgdaH3o9qcUsydEJOPVQJyYSCaXTaR+9\nUA5xrWSHJS4X/dvW1pZub2+VyWSUSqV0cXGhubk5R6XR2EBCD4fDymazxlgZaScSCSMDGxsbhgQR\niobDYXOMKYHC4bBrUmpxQnOC2XxBiJHIBSaE8Iuz2aydh3hQ+H5UNb9vQbaxsWGUAe9lJpCEDSFC\nSKVSnrQuLy87JwYkCauuRCKhZ8+eeTq7vLyslZUV29o+5npSixn3HjI2UE/f3t7aY2J8fNw1ZDab\n1fLyshEQdjSgLmRAGJKz4FFnQN8E3stkMkZOtra2bGnFbiTpASzFKJcj/vT0VBMTE/r88899CjD4\nYAeUpP39fdfM6BJTqZRPllQqpcXFRWWzWde3pKzSjAUHR1htSTKPBdMadHsw+KR76RnuSqFQSPV6\n3XwMGsyNjQ3L2DDWubu7c9nGrs19QbD7mOtJLealpSVls1k3TigxIpGIFhcXzasg6ou6k8EB2C9N\nGPUoUBc3a2lpyXHAmUzGlmA4zc/Oziqfz5s1hg5OknFkEq2CEcc///nPNTk5acYcjSl1LmR8Ysmw\nBqMMWVhYUDKZ9AgfP+p4PO5dnXwV7LeWl5d9zE9OTjodKngyrK+ve3LJTowFLc0u6nAabewW4Lb0\n+33F43ETmiDzI1RgY3jM9aQWc7fbdboUuxqRaYg4qQelexyVN5Vjs91uG5/lZ5RKJcNgklwXApsB\nlcGBZurINA20AfQAUhK7PrkfQQ87anfySBDLSnIDx+++uLiwmXq1WtXk5KR99HgAwXSpS9nx2aVr\ntZqzDPl9TBDZpdl1ee3YLYBvUxJxusEODLoYcVphJMnAptfrPVoD+De2mEOh0P8SCoUqoVDozV/x\nuf86FArdhUKheOBj/20oFNoPhULvQqHQfxj4+FehUOjNj5/7H//ffieNBQsnqDSGID81NeW6kURW\nFji1M14Y2BOk02nnSkejUU+qgNXgKkxN3ccEdzod17IsRsxXQAuCukScjTj2oXKyq7F7swMD11EG\nxeNxbW5u2oqM5FOI8wxwpJ9EB0BjaP+oa5laXlxceKwd5CPDwAvKr9AZBi27WKiRSESlUslGkvxM\nEgIQGoTD4UfHDf9NjrP/vqT/SdI/CH4wFAqtSfoPJJ0EPvZK0n8i6ZWkrKT/OxQKPRvdb0F/Lum/\nHI1G34RCof8jFAr9R6PR6B/9Vb8QDV7QOBu7gBcvXphr0G63NT8/7x3tiy++cPN2c3OjnZ0d28xi\nqEh0cDQa1cHBgRYXF02+j8ViVoQgV0qn03bDBOcGQgvWjMBzHNl8H00cjWOz2fTpcnd3p9XVVS8+\nPs4i2tjYMMwXiURUKBSsR3z9+rUKhYK/ptPpaHt72+VIcHG+fPnSr4WSi40ATJpMlGKxaC0h9ryE\nAH355ZfK5XJqt9uampqyv93V1ZWOjo58316/fq1/9I/+ylv7b3T9je3Mo9HoF5L+qiLof5D03/ze\nx/6OpH84Go1uR6NRTtKBpJ+FQqG0pMhoNPrmx6/7B5L+47/udw6HQ+VyOZXLZR0cHOj29lb5fN5y\nfeLKRqORDbHJ7RsOfwoxf/funRNIcUgKh8O6urrSr3/9a83NzbmB4ohmaJHP5508hV3YaDSyLlGS\nDR3JF2GhBm1mwWibzaZ++OEH7e3tSZJlU7gJNZtNXV9fu5GamJhQuVx2XX5+fu6H5eLiQnt7eyqV\nSmq32y4rIPpXq1Uv/MFgoLdv36rX67lMgYRPU8dJVCqVTGTqdrvK5XI6OjryRPDw8FC5XM4Pf7lc\nVrFYfGAGA0X2Mde/1Zo5FAr9HUmF0Wj0u9/7VEZSIfD/Bd3v0L//8bMfP/5XXqVSyVAU0n+ok8H6\nsV6v26EIsWWxWFShUHB9e3d3p0KhYCyXEoZjl10F2AwtHnUrg5ler+cByu3trT0tpJ8yUIDUKpWK\narWaarXaA6ok43cmZAsLC5ZyYUqOLxwPQi6XcyQGHA5OLBY3fG2wbgYesAslGV7E3xrfZTYENIFM\nDXkogfiQnQXH1QyCIIVNTU2p1WrpF7/4xSNW179F1lwoFApL+u90X2L4w/9f/o6TkxOLTS8vL/XF\nF1+oUCiYS8uxSk2LLAqy/cTEhLrdriqVij766CPr8mB3YQZIGiqWBORBr6yseIwNUhAOh3V0dKSP\nPvpInU5H8XjcNE2aQ47jzc1NIyPFYtFmhisrKxqNRmo0GlpfX9f5+bmNGdfW1kxs2tnZUSgU0ps3\nb/TJJ59YUFupVCzpB16Ea8KOfXt7q1Qq5QFJcLpH/U4EBTs6WSZMIlnkNzc3evnypUsiEgAYXF1e\nXmp9fd2nF8Oif5+i03YkbUr69kfW2aqkfxkKhX6m+x13LfC1q7rfkc9+/O/gx/9aOcLXX39tn4Zv\nv/1W4+Pj2tzcNOiP2HVhYUGj0cj+EEwAQQugh8IUC7LNCNOZmZnRzs6O5UeM0VF3gDlHo1GHBEEm\n4jWEQiH7VoB+BJEPxubgzOzONH00uWNjY5ZupdNpPXv2zBZk8/Pzpp22223TTLGoHQ6Hzs7e2tqy\nzx7+e5jO0G8w8YxGo5aNIb8C0UBBQ5wwDlIEGRFngfnM5uamUqmUvvvuOxUKhb/u9v5rr39rZcZo\nNHozGo1So9FoazQabel+sX45Go0qkv53Sf9pKBSaCoVCW5KeSfpmNBqVJXVDodDPQvdPwH8u6X/7\n635HIpHw7gB+2el0zIPApw36Ibatl5eXOjs7cwIqgwPiDZDvDwYDW2S1220Vi0VDf6g2KEew+uL4\nZhcEJSFzj9o3yJlgigksRhlDLSvJO+twOLRhIT8b2RcRx/A0JJmOiWK90+mYlonMC3Sm0+lYiAAa\nwuvp9/sPXicJs+zE9XrdBH4ecMS1/D1AkFAEHkvO/5uE5v6hpL+Q9DwUCuVDodB/8Xtf4hC50Wj0\nvaT/VdL3kv5PSX93xJ2V/q6k/1nSvqSDvw7JkO4x2U6n452TOg0ICUNsOn3cheAzLy0tudve2Ngw\nt5jakjICRhgGhrVaTaFQSBsbG/apGxsbs4sogZVEU2CVNTMz49gyVCRg2RCSFhcXXVvPzc2pXC5r\nbm7Oo29chxDIIse6u7vT+vq6lpaW3Ggy5MG6YHZ29oHUHx9o6urd3V2Fw2E/9L1ez0JZYMdIJGLW\nHFPB6elpTyQZ0HB/KJtAj1jo6+vr/+4u5tFo9J+NRqPMaDSaHo1Ga6PR6O//3ue3R6NRM/D///1o\nNNodjUYfjUaj/yvw8X85Go0++fFz/9W/7vcy7aPJw3kSHBkFNvROgtoZC2OUiFKFBuXH12LnzGQy\naS85vOqOj4+NrYJhg5JIMpdhd3fXgTnwptEerq+vP/A5hq03HA7NL1lcXFStVrMChOkadWkoFLKB\nzcTEhJaWlhSPx21YmM1mjXRQMoDJ47OHjRnDmo2NDQttqY8XFhYc0TY3N2cjSJh1GDvyur744gsN\nh0Mz6vACWVpa0mAw8CbxodeTmgDyJrdaLZcJDCbYAQaDgXcy6I2gFyggJFmEyWIJQlIc6be3t9by\nBZtKTgI0g4ykg1M4/psmKcjvZYeldoXAj8o6GKADbs1ro6ZlN2QYA92TcgPcGJ0jPslM/ySZ8A91\nNfha+NuCHs1AlVBW8cVjMcO3ZvJKYw4777H+zE9qMXOcjo2N+fhuNBpOOEIPSCpTv993DUzQI6yw\n4JuM++X4+LhyuZwXnST7SnCT2u22xbI0R9L9QwT1k0kdR3E8HtfCwoLq9bpyuZxlR5i1MPLGShcF\nCjg5zD3pHva6uLgwFxrFNX8zP4NTAlgPn5FgjY8/CC5IsVjsgXedJItz4ZJwovD6UWnjZc3JAVkJ\n24fZ2Vnt7+8/6v4/qcWcyWTMzKJ5i8fjDyiIxO72+31lMhm9fv3a+O/d3Z13jYuLC/ODOeqpoQm1\nOT4+tniUr8O1Z35+3gaG4LxAfCwIGHf8O2jIkkgk1O12NT097XEwnAiYcMHpHLs8fQL+FbxueMu8\nLzc3N5ZZYUnGg8fPZwyPsSInBuUDzk8TExNOv0KmBQQJVwPVSpCeWq1Wjah0Oh39rb/1tx51/5/U\nYuaG05RgHwUtkl2g3+8rnU7r7OxMP/zwgxYXF7WxsWFBKsy0YrEoSR6UAGthBfD5558/cM7ENWh6\nelqxWMyeciSSMkkjICcSiTxwQULaREQbY/CPP/7YjRUnhSQvYEhOEH2Wl5e1ublp/d7l5aVhR7jT\n6+vrFjMwEmcxNxoNQ3NY+galWJJsxEhqAGbsExMTWl1dfZALiJKdEmdtbU2RSES7u7vK/ZiVPRwO\nHZr0odeTWszAR7FYzGB/uVx2PRzESTlqgZ5qtZp5y5QcwHHwEBhtB1XE1Mq9Xs8Zf9PT0yqXy1pe\nXnYksfRTTt/a2pptBqLRqHq9npsvxty4Il1cXOjs7MxDDOIXUKcw1SR2AQITTv7Sva80dNRGo6Fw\nOKy9vT07cI5GI6MVg8HAtge5XM5DFTjPcKrj8bgymYwuLi5sezA/P6/Ly0sdHByo2WxaFAH5C1Zi\nPp/X4eGhms2mNjc3fe/+EDccuIgmQwvIsSbJujyGKsHjcmpqylRKmicI44D8aAJptKA+gmuDjsCu\nI+gdmy2mcbe3t9bFUXuS9NTr9fwzQS84/hk8oCeUfqKihkIhe1lQswLFSfKE7vr62jpImHsMbyDS\n83dfXFxYdSPJfs68PuKcb29vlcvlXLfPzs56YHN1daV2u23eeCQSsdE4pybY+fT0tCmwH3o9qcUM\nZkpOhiRjunTqcHQleRFDsqnX61pZWZH0kysSNW2QC42TPQ0nnXmj0VCj0bAKm8WP7o4mCQ4Ei4HT\ngAuqJeULfOrp6Wn/TgYaSJ8kWQQQ9KeAnw0XmeYMbgT4ND7NBLNPTEzYh4/yAoEC5Q9kEreghAAA\nIABJREFULGx3a7WaWq2WERR8+G5ublSv180lAeunrEAE/FgK6JNazDDE6NSpn4Gv2A3Y2YC4Zmdn\nLcM/Ojqy4gH+AzsS0QiwzEKhkA4PD90sgeeCwUajUU/U+H24FwFpQTEFSYDYgyEMNScoDOiJdF/i\nNBoNM/KIQkNYCx8FoSnDkKB9Ag95oVDQcDi0gpoNod/vm4V3fHxstTmnHqcLfA9OuKDHH9knV1dX\nnqbSdNJk0qQ+5npSixkQ//z83JAboTngnBi7EB3GwgU6glR+fn6um5sbzc3NaWxszA0lgP/t7e0D\ngj1DCth31L6SvNuBcZdKpQeUR/BeFNoMNihFwHERml5dXRktQCyAcxL+09FoVOVyWcfHx+r3+/rL\nv/xLj/er1aoXDrg6FmP4d1CWoBKhxwjaijWbTT80wZE3KhXQo7OzM3sxByHLqan7xFbpJ5X6Y64n\n5TUHwB+LxfTJJ594ogRBiLqNbp1uHMdPjuhkMqn19XW/4cB1oVBImUzG4TadTsfYK538xMSE4vG4\nms2mlSCUPxMTE6rX60ZFUGfg0dzpdJROp122vHr1SrVazcd70PKqVqvp/Pxc8Xhc3W7X30eK02g0\n0u7urvr9vi0G5ubmbNuF2//S0pIf0o8//lj5fN4j8mw26/cV4v329rZhTkoMxMFkaiNCQNhL6Dul\n0c7OjqT7pu+jjz5yTMcfEloDFyR3doPz83NzjqmJGW7QnOFOz3EKTgrXmQEFJPVyuexjkp2LocDN\nzX2edrVaVa1WU7PZNG8Yf2Qw3LGxMd/kYrFoDLfZbDpXhJjh8/NzG7Tc3NzYNTRI6JFkCwX8lYHx\nyuWySfHn5+cKhUJqtVoezgwGA2cTgpLwuuEsU7IwUEL53u12Va1WXcvjxl+pVMyN5t80pXhAd7td\n9wtAf4+5ntTOLMlURKiTMLnQz8HcSqVStpdi+ACXF0Em/hXdbtecDKAqRAB08NR+y8vLvsmUM+zw\n7K64jtLwLC4uWgfIMT89Pf2vGH6DvBD5S1MIGhCsXYOIzMLCgtLptBdv0GWfZhXpEtg0tltkvQC7\nSXLZw5gavxEs0ZjyXV5e2q2f4B7orezinHIwDR9zPamdGf5vkGyDKJR4BVCJZDJp7BOpP/4ZENX7\n/b6urq6867A7UU5gasLnw+Gwp41ra2vu9iORiGMjIKGDScNpAE3AJJ2RL40kZRAPBoQeCPU8PHd3\nd4rFYuY3j42NaX9/35yRdDrtfEQsZ+GkUB8zjsdlaGlpySUAHhjxeNwRF3jgIaSNRCJaW1vT1taW\n7YHBvjHByWazTn2V7h+QpaWlR93/J7UzczOoD0ejkbOr2+22fvaznznTr9PpaGtry94Ul5eXrkW/\n/vpr0xdnZ2etVoa2yQ4HF3l1ddW+xix0yP/hcNjB6OCuQF29Xs+eFhcXF3bIh42XyWTMfFtbW1O9\nXnez9+rVKzdTZAciFEilUvZmvru706tXr7SxsaFms2lJP+pt+gl21uApgX7x5uZG6+vrGo1G9smL\nRCIOtXz9+rWxa3JOVldX3SDOzc0pk8n490syNPfixQs7pv7B0ShwEWnAMCEajVq3dnl5qV/+8peW\n4oN90uX3+329f/9ey8vL2tvbc0cPfIW7/g8//KBqtaqzszPzb6+vr7W3t6fj42PX6Pl83mPe29tb\n7e/v6+DgwDBhLpfzQ1WpVMysazabDuQ8OjpSLpdTsVg0aw/E4PT01IOfcrmspaUlnzblclmlUkmt\nVsv00lKppNPTU+caMu3r9/uq1WoqFouqVqvqdrt2Vnrz5o3x+larZWoruDY9ytHRkVl43W5XBwcH\n2t/f1+TkpBqNhsrlsqeYcLpPTk40HA51dHQk6R4B+f777x91/5/UYkblMTExocPDQzdy2GmNj487\nLGZ+fl6Hh4fWpcEpeP/+vfb39x3zAH4r3fMRgrVyqVTS5eWlMpmM5ufnHYcWtLm9vr7W4eGhfSGQ\nVtH4VSoVVSoVN3grKyuOhmAkL8kBQxzrBwcHloENBgPt7e3Zsek3v/mNbm5uLKz97rvvNDc3p/n5\neZcsoAeUBxgYohaH/1EsFt2gvnnzxkLWVqv1wCyRoQiLnRMS3J9mGvX85uamfx8ql8dOAJ9UmcFo\nNRQK2SeDWpcwHDDOWq2mr776yrsLZUk6nXbIJf5ywFfLy8te+GC5Nzc3Ojo6cn349u1b7e7uamFh\nQaenp5LuaaIcryyGeDyuubk5LS8vG4Ml1HJ3d9cNFI3d9fW1tre39Zvf/EaJRMKEoUKh4DIAoelX\nX33l180kE3YfCM/Y2Jg+//xzZ7BAjDo4ONDq6qp5JJRe+I0Ew4Du7u5c4jDeD7p7ZrNZlxoE+8Ae\nJKkLDw9IXt99990H3/8ntZjJ/6CZYuoUDoe1sbGhQqFg5CGVSqlQKDgxlSFGMKe6VCopEono7OzM\nkh+I6mDYmKdw5MNWY2dGAcJghHKBAE3MY3AaxUAlGo0aj8UPRLrvCwjWGRsb0+Lioo/y6+trY9Px\neNwT0ampKQdrfvrppy5LwuGwhb6j0Ujr6+s6PT1VLBZzc5lMJhWPx5XL5fTRRx85T5vSand31+6i\n5XJZ29vbToglZm56elpnZ2caDAZ2RGWsju4SPsljridVZqA9w22IYQgeGpLs8IlcSJJ3WiAuRsfQ\nHZEzgVgg4iyVSra2YmwNpTMWi/k0QEJPp7+wsGDVMscsGrzr62v/3HA4rFar5RMGSZgkm6dLcvYJ\nxzmTUGrsTCaj7e1tIy3IuYDk2u22RqORKpWKR/AwChnpMwACsotGo3rx4oWFuQyJgBZbrZYymYzL\nD0or6K/D4VClUskml5jWPOZ6Uos5aO4HvISUh1pa0gNVc7lc9hEMqM/EC8wVAjwqEbjGmMLQYJL2\nymgaw/Fnz55ZnR0cZiBUlWT2XTCMp9lseurGiB3/ZeRWwJGrq6u28gJ1YfHncjkrZ/idGItXKhVt\nb2+bHTcxMWEfDlAZPgecSMPM3wNTjs+RwgV1AG5J0JOj3+9rdXXV/I3x8XEtLy8/6v4/qTKDnQrj\nFbrzdrttayx229nZWSudsZ2CjVapVBSLxXR5ealisahQKKSDgwMlk0mPrsGKeSiAxfL5vNbW1lQu\nl7Wzs6Pb21v95V/+pdbX151oSqQbkzbCe1i80EfZzcCAc7mcd7d8Pu8hBRNOVCl4S0PXROEdiUT8\nfSy0m5sbnZ6eampqyhg8Q45CofCvOO8jYG21Wvrss8/cZPPzMU88PT19kAkIxZX3Gi860J5er6ff\n/OY3j7r/T2oxI33H6QcjlXA4rGfPnunw8NDHtyQHr4NPS9Lq6qqlUalUSpFIxEORUCjkoMZYLOZd\nnA6eUgMnUerBdDqt8fFx79rEDWMWTrQDQxeGPpLM+ajX695Nx8fH9fz5c0/TUGpjLnN1deUdG+0h\nC+jLL7/U0dGRSw2w9Ha77QcYRGV7e9tYdKlU+ldKokqlomQyaUrs+Pi435egH93W1pZ9n4M49nA4\n1K9+9StFo1GtrKzoj//4j/XrX//6g+//k1rMQQ9mYK1qteruGbPA6+trJZNJ1et1vXv3Tjs7OzZc\nmZycVD6f1+7urgqFgpEE1NXlctnG5eVyWdls1iJSiOhzc3NqtVpKJBJaXFz0CYAmMJPJeNIGYWl6\netqsPZzrwaPhQY9GI2cdnp6e6vnz567ty+Wy+dfQVUEhUHpfXl7qzZs3mp6e1tHRkdLptDkolBWt\nVssSrLdv32pnZ8dC2/X1dYcYNRoNpVIp9Xo9nZ6eusSQ7pviw8NDbW1t6erqSr/73e88Xq9Wq+4J\nKO/gV/+zf/bPHnX/n9Rinp+fd94Io2kMuQmtnJqaMnIxNzdnHzdqZBACPDYWFhYkyRESTPWIZSBK\nDCckGkIQE6AxOBLgzDRjkpwGC6zFrnx1deWJGgSfRCKhdrttvJjaPJvNuoHr9XpGVSDvT0xMeAwt\nyYJWSeadcGKhvIY7Mj09rZ2dHUNulB6UQQx/+P6FhQVzMhjRIwKg9s9msy6lOG2SyaQpoR9yPakG\nEGJ7Pp/XDz/8YDSA3fjo6Ejdblfn5+c+dsmWhnMQDoe1v79vbvFwONTp6amSyaQGg4EtXxlQkCPS\n7/f17t0714ClUkmFQsGICnActeK7d+8eKMFpMlutlvL5vNl7V1dXOjs784ADGyuGKJQ533//vWKx\nmOr1uhl6eIccHR3ZKheL2cFgYE+Ld+/eqdfreQpIJjj85lAopL29Pb17987MOklWqmAWQ2nBCYG7\n53A4VLFYdANKGdLr9bS/v69Go6FKpfKohSw9sZ0Z3kM2m3V2NGNW6t0go47dEYIM0h0IQdSG1JWz\ns7NKJpNaXFxUq9XyTomsCoiOtKWFhQX1+31Fo1Hd3d0ZW56fn1c8Hlc6nbaUa2ZmxgaGqVTKeDkN\nK8gJLDXgPx5AnIiur69VqVTsvjQajbSxseEdnVSrYFTD+vq6a/pKpWKUhPp3enra9TOC2KBJ4sLC\ngtUrQYNJBk2gHeSZoFSfmprSZ5995teytrb2KCfQJ7UzS3LXTR2I85B0j/NyhEOAD4fDPlbD4bDJ\n8Hw9aantdluzs7NKpVIeYaM0AX/GUV76yXuCUwD1NRxofDWA6djR+FmowyX5a8F9JZl032g0vJDO\nz8/NpZB+0kQC0yGZAk5EmT36MW8bxuCzZ890fn5ulQ3OoPzO7v/T3pnERpqmef3/hR22Y3Hs4Vht\nRzjttKszO6u6ekEjulsaMXBEQgKEaAEHhIAbHJFAnODACSE0h9EIBiEhREsDamkaxIFlUEs9rVqy\nypWb006v4XCsjnDYYUd4+TjYv6c+dx8G2V3drcCvVKoqp9MOO97vfZ/n//yXoyMbKDG69/p2oHOk\njOr1egbvccC0Wi27Sfne6C/vukZqMzOJYtzq9/sVjUbl9/sVj8dv8X1hfCGfJ+KBGpjoYaQ+lAvI\nh/j4YDAwpIPBArERl5eXFicBcZ4sDwxjKG8Y5EgyBUc4HLbQ+nK5bKebd3hCuhbWAjxENFgQe6h1\nGVA8fvzY8hIRGriua7RPHkpJpqPE8851XUNrMpmMGScyxYtGoxZLhykjcCPmjbOzswYtggLBl77r\nGqnNzKQPWT5XfCAQMOgKuibypv39fSMPSdfQHBuBNwkyDzwDJnd+v98cfSCXU+cmk0lzAGV4QpnA\nEEeS1Zk0n/CxyVxhLO4NtPcmvxJrwSDC64gkXTdzjuOYVAweCqoVyq3JyUn1+31rIDlx+b2GQiEj\n18/MzJhZDcoVoDdJxoGBocjCcpjUWU5u3p+Hk9mzmFBh3H11dZ0jTebHYDAwR3pkSouLi6rX61pf\nX1elUtHExISdQizGvcBPs7OzRtfM5/P2+Y7jmBfd1taW1a/o/TASZHrGxxlseC14oZ3CNJOuy429\nvT2b3LH5h8OhMpmMcaRPTk7UaDSshMJw3CsEYBjEz4sbE/wVoEBvXLIkU6gcHBzYz8MDw+tlmAQN\n9+DgwN4PvECazaba7baJihk+3WeN1GZG/o/RNtYASNoZdzOJwk+CUwiKqDckh1MZMSlEJca8dPJ4\nv0HSAVbDzguvCMbYruvq4ODATlo8JGiiyFzB+Pvo6EiHh4fGhKMPkK5Pd3L8uBn8fr8Fv0M4QnaF\noz+bGoMcfo5Wq2VIS7/ft5iGg4MDTU5Oan9/3+pkPOy8v0NJVqK1Wi2jgWJnC4LEQAqUhQnpXddI\noRlo9SYnJw1KKxQKpiaBRDQ2NqZgMKh6va5isaipqSnNzc1ZkA55JYxll5aWzFQlHA4b0TyXy1nD\n0+l0NDc3J+kaH3706JFxIHDtgYqKeoXJGajB9va2OWp2u13Nzs6q0+lodnbW3OYDgYDq9bqi0aiJ\nB6ifJVmtj1TMdV31ej0za6RUoRnmZKQvwMcZhQgJA1hp0czSLPJgwuMm229+ft7onicnJ6aK5/ef\nTCbNswM67H0FrSN1MnMK88Zj2CLJ0AJOqpOTE2WzWTMWJwaC6FyiwmZmZixfWpI5+khSvV5XKBSy\nk6vZbGpnZ8cyQM7Pz00SJH1phTAYDLSxsaGjoyO79mkaKQ0YFzuOc8sOtt1uG4VSkk0F8VLma7qu\na01rPp832iYnKhseh9NwOGz+zeDePKhEx+EgCm+D7wMnhduHg0L6MmEWl1O88ra2tqysou5+ELR6\nFkoKTEuY+LHJaVBwFdra2tL4+Lg1evCLm82mGSwyUCE3EKcflNMHBwe36tX5+Xm5rmunLS7+sO/O\nz8+tGeV1bW5umtVWMpnU1NSUhasjEMD8Bf4EdrQgNNAsyUvBfuvs7Ezr6+vy+XxmSQA9lTpWktX3\nTBt58Hi9WDMcHh4a3EcIKEw5hkhgyJJM9U5ZRFNbKpWMVgB8GY/H7/X+j1SZIck80Z4+faqpqSml\n02nLI2GAwvi0UCjo4ODARtnpdFrValXLy8t6/PixVldXzRqALI5arabHjx8bXzeVSpmHBGGXUEiB\n6iAvAX9NTEyYO+bU1JQeP35sjSs15+Liol3pp6enGgwGhgbgLMq4HT8P7GwLhYIcx7EhinRthFMq\nlRQMBlWpVMx7GluxVCplmxY0AsN2xLWNRsOMZbBWyGQyarfbymazury8vKXMASb1+/3m+BSLxVQu\nl3VycqJisWhxGRg33meN1GZGekSy6cTEhN68eaN4PH5L+MmVyBUNNLa6uqqVlRV98skn5nnBm7Cw\nsKBms6mNjQ1ls1nF43Ht7Ozc8l6rVCrmN/fpp5+qUChYWE6/3zee8MTEhN69e6dMJmPm6MViUUdH\nR9re3rbp3/Hx8S1y+/j4uDqdjh49eqTDw0N7CDFqYWixvr5uDZ8kazCRg52dnemTTz7Rs2fP7KYh\nU2R7e9sw4Ldv32ppacksgGOxmL744gs9e/bMyjYa14ODA5ueHh0d6ac//am+973vmdXu9va2lpaW\nFAwGremkLKK0evBn9iyutlwuZyQZZEvHx8eWDY0KJRKJWPYzENbBwYFtfm9cL/ZZ+FGgisB6lvEv\nsWuhUEgzMzNKpVJqtVo2MGEczfQMFQcRZhDUveVMMpm01wSpB6ycKR9NGX4aMzMz5iY0GAzsRgqF\nQgoEApqfnzcVCYT9wWCgx48fm+s+ZRGuQ8RhUDdjxHh5eWnTRfgnS0tLkmSYerFYNK+74XCo+fl5\n44D7/X5Tkd9njdRmppMGA0UdghoC7wvePO+Ym82dTCbtRCZEHkpnOBxWo9EwX2NYbl58G0IQAxk2\nAI0p7pcMDyAKwa7z+XwqlUrmTYE+EYYZymnMzxHNcpKfnX0Zf0wZhI0s2C+1NvyNqakp5XI5TUxM\nqF6vW7oAzkjE0IE5s9E5UamtgT8ZefNQg6gwtsaCADsvRujf+c537vX+j1yZQa16fn5uFliXl9cp\npODDPp9PyWRSlUrFUA8k84hJo9Go+Vd0u10z3p6bm7MGB6IQDRhWVl46qVcxIsnQCUbtuI6GQiEj\nGDUaDdVqNWsGwa5xqfeyzkBkGOrAcUin0+Ze32w27ecvl8tqtVrGycY9lKkllFGI9vBNUJejdsdY\nZ2VlxWRUwI7AcJLMbRVWHYQmGs1arWZG7vcVtI7UZgZvbTQadhJ2Oh3l83nt7e2Zsrjb7ZrXnCS9\ne/fOLKjy+bw2NjZseME0C38NfukMKQi15OFhzLu7u6tQKKRUKmWmKq1Wy0qSra0tM6nBCZTanTiH\nvb09K51wPQLZaDQallaFoSEMvkqlYpDX+fm58a753bTbbbXbbUWjURv/0+RielgsFrW1taUnT56Y\nsSSmjdPT0+anjEkkJzRIEHAe6bfHx8dKp9PmsYFaPZfLqVqt6vT0VD/+8Y/v9f6P1GYmugAZFFJ6\nNhXX4szMjPr9vhYXF7W6uqrl5WXVajXlcjn5/X4tLS3Z38f6FQNzGq1+v28n8ZMnT9RqtdRsNs2o\nEbI+I2tOJIhNSPxh6JGvB+MsnU7fsiHodrtWZzIYmZ6etqHMycmJ1tfXlc/nVSgU5PP5bJqXSCTM\nvZTXgko9m82aAPbq6soCLa+urpTP5zUzM2NNMkIGbhPsc6EHUNpg6sLwB4td6ZpzjlgC/jZ9y9zc\nnN68eXPn93+kambpyyBGmjemX81m0zjI/BnWr41GwyTv1WrVuvt6va6LiwuTVFHHAiexiarVqqRr\nTSHxZDxQ0CUxXYTny0AHkjwnJIy9k5MTS5elQQUSY8zNyeitf8lNoX5mQ+VyOeNE87oxPidTkBhm\nWIE8WODPRFdgWyvJmkWyUfDgANILhUJmuwuejBgYNTw1OEaOd10jtZk5dbrdrr773e+aG2Uul9MP\nfvADxWIxlUolzczMaHFxUd/+9rdVLBaVTqf16NEjMwtcWFhQsVjU06dPNT09rSdPnhgPASkS+Rx0\n5JKMdD81NaX5+Xm1Wi0FAgETASwsLBiCkM1mlc1mLd1Jkj744AMtLi5KkoX6kFWIN0a5XFa329Wz\nZ880Pj6umZkZM/CemJiw9Cb0d7Ozswaj4WtRKBTMYWhhYUHLy8vy+/3K5XJmyh4KhfT06VNlMhnL\nBE+n04pEIiqXy1peXtaHH36oi4sLLSws6OzsOnY5HA7r4uJCmUzGmtKlpSWdn59rdnZWkUjEoL/F\nxUV97Wtf0/T0tPL5/INxonfhZBQMBvWjH/1IR0dHpoT+4Q9/qFqtpv39fZMhvXnzRhsbGzo9PVWt\nVjNzwJcvX2pnZ0fValVjY2P6+OOPzWzw3bt3dr32+31zBhoOh1pfX7dQm+fPn0uS0TMDgYCeP39u\nJJ4XL17cIjfF43Gtrq5qa2vLTFKomz/66CNjrWFntb6+buwzWIG9Xk+VSkX9fl8vX75UIBCwJjca\njZqtbb/fN3bc0dGR1tbW1Gw2Va1WtXWTEHtxcaHnz59rb2/PmHiDwUDb29vGMlxdXdXZ2Zlev35t\nrks00C9evDA7r3q9boJanI5c19XLly/t99Bqte4tmxqpzYyrDnIjsGKQCq5qYDRKiIuLC9PdQTL3\nbpTz83NVKhWjMKJIoTHi8xkOgE1LshEwZQMUT055xsX4Z6Acka6HHXjTMdYGPeFnREQLJOit6ykf\nCM2RZIw+0ATIRECMUDqBNkEi4Jmcnp4aZIcyhq8LzwRKZ7lcNjQIliK1MjAedgx4Yd9njdRmjkQi\nFhRD5AKnDMy1SqVi4T3o9Gq1mlKplOLxuF6+fGn8g16vZ/J/L6F9bW3NnDObzaZht/gwe2EyHg5o\nj5B/CAA6PDw0F1Bqcuk6Lm1/f98SXicnJ7W1tWW6PVxKyQV/9eqVksmkxbcR1lmtVs0oETMX6uKT\nkxNtbGxod3fX+N5+v99IRFBEId5vb29rOByaqQuEJep3fkZKMQhSbHh+d0Q7IwsjMcvLIb/LGik0\nA6nP5eWlnj17pnA4bN16NptVu9022RR/dnl5aXgudd/R0ZEKhYJ2d3eVzWZ1fHxsymcmd8lkUpFI\nRLlcTj/5yU+Uy+VsWgd7bG9vT5OTkyqVSnYLQGKfnp62CGRG581m08SvcB7Gx8fNHgGJlOM4hiWj\nK1xZWTFRbCQSscxwLBIQ8ebzeQugxLne5/NZ4urW1paVRZysExMT2tnZMcNwHEERrLIJaXrz+bzZ\nN2DxQPO6vLysYDCoZrNpSbqJRMKoqPfxaB6pzQx1k+katk8MDhqNxq0ygT8n9Ql5EYoUkA4wYuwA\nKC2wxGKke3Z2pu3tbXPLhCRUr9eNJITxSTgcNlFou9022RIO9I1Gw2AwTji6/snJSQu0JxjI5/Pp\n3bt35h2yt7dndrSgGJKMpsogCWsw/gzO9eXlpTY2NrSwsGA+z1ADSJslk5ByCCemSqViGHmv11Oj\n0bAHC6NxuNno/1qtlsF3d10jtZnhOUiygcJ7771nXT+CV2/edb1etw7+8PDQPIX9fr+ePXtmm4RJ\n2WAwsGlaJBJRp9OxzD7UGoPBQKVSydJK+b5+v1+1Ws2+DtYDnNBc3f1+XwsLC9rc3JQks5dFHOrz\n+VQul20a6fP5zC9udnZWtVrN+MuE9FDy4H46OTlpATnAdCARR0dHhjF7hxqcwGgmIQvBdb66utLK\nyop2d3dvZbPw0GHXAF4OTOo1bbzPGqnNjAH25eWlnj9/ru9///t6/vy5VlZWjMPw7t07u+5evnyp\nYDCozc1NTUxMaGZmxtCEYrFohoftdluZTMZO+/X1devOHz9+rO3tbVNykIf35s0bxWIxJRIJra2t\nyXVdQySGw6FqtZpKpZLa7bYZfOMsOhgM9PHHHxu3AfLQ6uqq3n//fYsuQwaFO//jx4+1u7urt2/f\namVlRVtbW5qamrplI0Y93el01Gq1rLlEZULjNzk5qY2NDSM7XV1dqVarGef75ORES0tLRmuFj7K5\nuWk6wEgkYhwNLzfEK5aNxWImaHj79u293v+R2sw+n89y+eLxuMmksKXiTYIY9PTpUyMQgXSUSiVD\nNpaXl1UoFPT5558rFovZaT4/P69ut2skdhKfOGXi8bgODg5MFpVIJGxYgkuQJAvxOT8/v5V7PTY2\nplwuZx50DF0ePXqk8fFxpdNpHR4e2mtqtVoqFAp2bZdKJQ2HQ/ue4Me9Xk+xWMxEtvl8XmNjY6b2\nzmQyevXqlfL5vAVXUmZgWQsSA1dbkj0IsVjMkrwqlYohHJlMxiRqZ2dnRvWMx+MWLBoIBPTkyZN7\n1cwjhWaAXEgygan35ICeCJOOcEu0dJQKdOetVsuuf6aJ0BjPzs6MTMP1OxwOb2XtDYdD4/iiViEu\ngaB0LGAJtOT/OcnxcPNa3cIRxugGWAvRKA8EPz+oCyNnb9Qxr5tJKfU4jSoNKp4YOHuSQoUaR/oy\n0J0bBUYcE0xvpDD2wZIMBcH7465rpDYzOjw2JJgyTdNgMNDi4qLxHiSZ/Ws0GrUOHGFqOBw2RTZ2\nA+jtcDDCoTMcDmthYcEoqKSasnGRWUky4g96PdTgkINQpcCdILfbi7rAicb5iDLULiPnAAAbvUlE\nQVSITYz7Etxtr2YQYQIU1mw2azkmk5OTFl2M0p26GjUNpCfyDZFUwYpD2we1ttlsSpI9CAgNODAm\nJyeVSCRULpfv9f6P1Gbm2gOrJQiSXBOSlCCbY91KPccbAd0RPwmaJeilJycnRkJC5Xx+fm6xZPCH\nIbRD8YScj2sSrykWi91yY2q32/ZnSPZ7vZ4kWUnC6Y27PfwMhiZY24IaYA5DApTXmgtivDdkh+8P\n6T4Wi1mTx0PDTRiNRo0HzuGBRQLjfgZSCAho1r3uU/dFM0ZqM7PpMAakJpWkWq1m5Bmc6PFqoGa+\nuroy1bDruup0OqrValY+EFMsyZw28VzGdBFLAmxrQ6GQ3rx5Y+6jCAIwGifWbWdnRycnJ0qlUuZs\n71WihEIhc19CuYJFAIrvbrdrkGMgELA/R7iLRwf2sefn5yYgYITOx6Xr7D++Jmy/4XBoMCeYd7PZ\nNGdU4ERJRiRiotnv97W9vW1TRDSLDLD29vbu9f6P1GbGXhYd3WAwUKVSsQaFDA5q2Hw+r1wuZyfx\n8fGxEY4uLi5ULBatufNycyVZAiq2AEzOkP6gCfx5ISo6PgwaOU0JvUHpwVXPmFm6tg7rdrsKhUJG\nhAfL9fv9FsJDxLLXmKZWq5kaG/k/1lx4KYODcwuMj49bvBun8GAw0MLCghYXF43rUSgUTJzgDQHl\ngcKEMZFIqFQqyXVdO0wo9zBhv88aqc3MYAOTleHwOh/v4uLCNH6cmJyMOzs7doKEw2FDNxCiQldk\nEkdUA1o2x3EsR4Tw+KurK6XTafsauCJheXV6empKDzjEY2NjFlOBkoXNwegZPZ4kG9hALe10Onr5\n8qW5B3lLG/K2k8mkMpmMfZzohsFgYEMNbxPH5+I9glk4zaTP57M4ZeImBoOB4vG4/f75vfn9flUq\nFbVaLUUiETswdnZ2TEjhdWm6yxopaG5+ft42FL9EGqpsNmtdM6Sjcrl8yzWT0xtJPIw33kTqQklm\ngohLPMMU13W1uLiotbU1I50jYmVogqkiSUyYwFDb7u7uWoYgNTOGjtPT07ZRksmkZaiwsXBRokkj\nAi2VSpm7J6bf5J9MT0+bC9RwOLQxdCgUMm0ktr7YF5yfnyuXy9nn4qyP3hL1OFFt+/v7yufzNkSB\nxJTJZDQYDJTJZO5NNBqpzVytVs2EZW9vT9lsVmtrawoGg5ZljaNmNpvVu3fv1O12Dd8NhUKKxWJq\nNBrK5XJaX1/X4uKiJSYxco5GowbVYdiC1RSEG9d1tbm5aWHulDZnZ2cKBAJqNpvGa+h0OkokEkYS\n8jox8WCyaS8uLuzvUPJgEEMNurW1ZRg7LkWJRMLIROgMiV8DWqxWq8a5GA6H2t3dNUdSEri2t7eV\ny+XU6XSsvMFugXq51Wppb2/PAjU3NzfNSQqvEhptDp1ut6v9/f17vf8jVWZ4nfCZMiEJQrRJM0JZ\nwcmDAjmRSNgJBUZMzQxWipSK65uUJ9QqXmgNj2TGyYTRgCyQ/ee6rimp2QTEkYFDUx7x+YyHXdf9\nBdgOU3HorpLMaN1rWg5C4/V6QyIGOoF/NHpELGips6nf+Tt4YvMzghJxkvM74+vyujCmuesaqZOZ\nrn58fFwHBwcWmtjtdk3Oj21XsVjU2tqaQqGQtre3LYH1k08+sYB48keurq7UbrclXf/CqQ1brZbB\nYHxdfDW81+fPfvYzG0sTwg4Bajgc6vXr1/ZGIxY9PT21FFaYe5999pmePn2qt2/fGtKB0WKlUtHK\nyorVzh988IH29vZuGceAI0NFrdfr2t/fN5oq9fnr16+N24LDvSR99NFHBqsB8WGfy4bEIhdfD7jN\nRDB/+umn9jPB8d7Y2FAqldKLFy/u9/7fb/v8Zi3Gp9SYnHLSlxJ5rKDIdR4fH1c8Hr8VOYbrOyRy\nMvq8RHWc7BG1gnxgKg6xZnt7274/DDGvb0YsFrP86ePj41vaunQ6bUhIv9/Xe++9ZyR9It3Q3kHT\n7Pf7evbsmS4uLlQqlawZgy8cCoUM2ZiZmbFbAwMbyEoYvRDgeXV1pVwup0KhYA8b0cYIZTFZhIVI\ng9nv9y0vBQ8+7BaOjo5ULBYVjUbvjWaM1MmMBhBCzenpqbLZrIX1lMtl49WSUw2TbHZ21poWyEpw\nH/DMoEGho2dChsccdTdwGE0S17yXu4EUX5IqlYoWFhaUSqXsFKO+x5mUm4N6vVAomLUCrDj8Orze\n0MRAcFLi5o8ns1eYGw6HLQg0FAppfn5e5+fnhttDV00mk5qenlYymTS1O+UECV9YLgD7MXghbSAe\nj2tra8u+P5HE91kjdTJ7hx107G/evLGmaWNjQ41Gw3i7yJQkmZz+5OREL1++NLYXCg82K40ZWjYe\nDnzhMIEhtcnn86lardoQR7r2ZUOKj0EhnBLGzRMTE2YW3ul0tL+/ry+++MKmcKenpwZFoiBJp9M2\n5SSAc3d3V1tbW6rX65Y0y7QP4hRhnycnJzo8PNRnn31mnnWXl5c2DKJcQ2GCsrvRaNgAqNfrme4P\nXjh+Gqenp6YhBOFptVoWQQyz8a5rpDbz7u6uWXNNTU1pb2/PVM1ch5lMRqVSySiLfr//FgkmFArp\n61//ujUofAxL206nY40kmR5YvGKIuLu7q/HxcW1tbVk96NXuMczAooCNxGvnxAeqk2RstP39feM+\nYEwDTXN1dVWnp6eampoyLjVQHthxp9PR7u6uGUsyLcTyS5LZ3UK+wgAmFotZ3jcIije/G9szmm9Q\nHXyXd3d3DTt/9+6dBf5kMhlrEO+zRmozT05OWgbgxcWF+U8wwma4gDKZUwUFBGtzc9PqXsdxTD4F\n5xlqJ2oLRtjHx8dKpVKan5/X3t6exavhKQf3+OjoyGpGBjY4CtGwSTJyUqfTUb/ftzwRPJrxiGPz\nYa1FnY9mkVsKrziGIXwNHmxJJjDFOxozdbw0sA/gRvOaJQJPRqNR01Eiz8JFlIMF0QDun8Q832eN\n1GZOJBJ2pVOnTU9PG0OMRmRmZsbcO4HUvKcSv2w2F9kbp6enarfb2tzctFgzJnCcRpxMiURCnU7H\nrGXJuwbWQ5PHZoCB1+/37b8xCPf7/cZXDgaD6nQ6xuHodDrmqVwqleznApkAO2+32zaA6ff7t6xk\nvXYAPp/Pmk4ePhygqMPRHoJHx2IxJZNJSTJCviRj6qExpLQBPqW/YbDjjbO4yxqpzcyAIRwO2xgX\n3R61n+M4Vm9SInDFQpDhKmU6SLfuOI5yuZx1+6SxIsPKZrO3BKSZTMbyAQeDgfL5vGG3NE+u65pI\n9vj42Nh4Xo8579WOe1Cn01E4HDa5UzKZNAsujMbxf87lcsbmY6N7rbp8Pp/i8bjm5+cNt0Z0K10z\n9bDdKhaLFnLE7xmlNTgx1rmgI6AtcFHoJeCC8HoeMk08C14ALLdGo2FTMghAMOey2ax8Pp9evHhh\nglTAfJoW1NG8AePj46pUKmYpRd0bjUZNQXF4eGh17enpqfk6U3/2+33z0SBlSZKN3iHpey3DqHXB\neznJ4W1L11wNEBwSoqrVqiYnJ01LCFNNkim0A4GA3R6VSuVWrBxQ3tnZmVZXV9VsNrW5uWkPH1NA\nIDjKE0QP9AcIcuE8g8ow/MHD5L5WAyO1mVEvQLKfmZm5ZQyIDxuNGK6a8Bxw3A8Gg1YvgzF7TU9g\nnUEckr7MU4FTAQ7MZI0oByZy3BySzOeDWhxCFLh3IpGwkTz4ND5wvMZ0Om3cEdKd8L1AXMBmYQLI\nBmJjBQIBJZPJW2lU2OhSSsTjcXMqoozhNXW7XbVaLbs1+H6RSMSaR3oARu2SjPvMzXjXNVKbGWrk\nxMSE2u22XePeuIHx8XGT8WNyPTU1pZ2dHWugQBEI60EpAQbLZqvX68rn83bieYN5/H6/NVyHh4cm\nFkWNAY86GAyq3W5rYWHByDdQLREWHB8fGxGKmrXX66lcLpuD089n8Q2HQ2PujY9fxyvTdPl8PkuW\nhXdBqXR4eGjOqWgmq9WqlWxEEtMcImpAkoV3M5pCSUZuAmkh1u3s7EzJZPKXUmJII7aZab6oKYGM\nIJZzNVOngmIg7iTsBigJBYg3S3pyctKw1lwuZ+NaThmGE964MngQqVTKBgcISfn+zWZTiURC2WzW\nXhvTQiiiPAC4bNJo0cAlk0m7acbHx42miWl6PB63PgB5P/AYpVYoFLoVwsmgx+fzGXmez+f05uf2\n2gnDT0E6xY0F9Hh6eqrFxUU7oTudjr2mu66RmgBiBA4H4ejoyPzTgLfgEMO5QKMWi8UMyqIM4R9M\nvNlQfr9f3W7XOnJgPST/uVzOqKachLwGMGmQClALTLglWQlwcHBgXwtFCRwKdHxYWwHFgdxwolM6\nVKtVo6BeXl6aPwY178TEhGHtyL3q9bqy2awODw/tNKaWpv7nlK3X64bQ0PCScksWIpK1i4sLU4jT\neJMicJ81UiczDC58Gri6vKLTYrFozYrrulpbW1M4HLag9UwmY1ROBiGA/8PhUO12W5FIxK7iSCRi\nJxQTNpz1qUOpXwkI6vV6t7BkvhecjVarpbOzMzOXweET7Jdam5E4J3W73TYbBdJkgR0Jcef7oAzh\n9mEUjRoHZhx8i4ODA8OwvTcesikQGgwZUaLTUyAcTqVShq+DxMASRPFz1zVSJzNUT0k20s1kMgY3\n4UCUzWbtysMzmSndxcWFqbNTqZROT09tgkaDh5EKjSLwXyaTsSFELpezpnBjY8NOK+iWXrErJ/fP\nGycyXUulUpKuSwL4EkzSTk5OTOeIWxGlCbZfnOQQ6UlWhe1HBgwELWy24vG4PSiZTEaJRMLi1+C9\n8L1o/BKJhLnpT09Pm0mjJONKn52daX5+3hAdvt+DP7NnMahoNBomfQL+KRQKJtkBjQDEhyMcjUbt\nZCEtKhaL6fDwUJlMRicnJyoUCobrBgIBLS8vG7sslUqpUCgol8uZW2etVlM6nb7F4CPYHX0fDwlB\nPoFAwDIEQRIkmX6Oh5P8bvjOPJjU6ODSJLXSiDLiDofDZkJDsA/ly+Xlpf0cOPJTViBvOjg4MANz\nqK1g1jxAPJzYCsdiMX344YdWVx8cHBhz775Eo5E6mff29kyA+vbtWz169MjGzo1Gw3jJEIi++OIL\nw1tRcqD7Q5SJvs9b4wH0E/gTDofVarXME5nmh1N4bW1N0WjU/JiDwaBt7HA4rJ2dHc3NzZmyGs6F\nJPPFcF1Xu7u7yuVylhLV7XaNegmZh1IIWA3yz9zcnEFnvV5Pp6endhJSNzcaDRtxX15eam1tTeVy\n2YZK3FwXFxcmzvV6kwwGA/l8Pm1vb9vno67hhG40Gtrf37dJIU6kkgwPv+saqZMZQjmNBJvL5/MZ\n/xbCDSbegPmc0LjEw4WALcdVDD4tyYSq4LaoqIfDoSlNoDziUMqpCRHn8PBQh4eHJlAFWsRUkBvk\n/PzcsG82I03ocHidPsupeXh4eOtn7/V6NkJHKgWc1uv1zMkemy4eYJTaICOgHNBMr66udHV1ZQ8J\nAymclLzfy2v4jnMSDSMYOA/wXddIbWbHcZRIJKzpYsIVDAZtfDw1NWVKj1KppE6nY00UGSSwuILB\noIrFomGpZJgUCgVLHgXb5mrGLBE/DLJCaL6wqOVEu7q60uzsrJ1y0jW7DL4whCDMVqhFQURAbgij\nJx+EcgRBbb1el/Rl+CUj50gkYha7bE4Og2g0qng8rlgsZicrzSoPPqUDpCdc+KmHq9WqfW1SbLkR\ngDnxLXkI6PEsygjGsJOTk3a1UxcChXEaQaL3cmzR6yFLIvWUMoPrFuTg6OjIRs9gsVy9cIWpxTmx\nsa+dmZmx6xaUhSubk5TXSv3PwAEyPafxwcGBTQ2BGPkeuJYy4MG2FzU2p2Sv11M+nzeEBrSC7w9d\nliFUNBrV8fGxTk5OzMwdtTmCAQ4M/o03Hli2pFvY913XSG1m6tVUKmUYM/UfUzBCKrGe5d+lUsli\n0Rhbo9zgTffmccRiMdO7cZ1DPz08PDR2Hrgv0zfgME5NxtFs8kAgYLcL3nPIn6TrJheus+M4BnP5\n/X5T1XAzeTdTKpUyZhuvzcv0Y2oHXRPkBYbb7OyshV/yoDLwuLq60uPHjw3K8/l8WllZscYQf49Q\nKKROp2OhRuVy2dAWGtD7rJHazN43AukPJzJlAB5zIBS8MbVaTZ1OR3Nzc7cyo3GRR4HMlAyneDa4\n67p6/fq1EomE5ubmtLm5acQayhGgNDYvHGGu89nZWWOYMYaenJzU7u6u1cH7+/vG/qOuRZ0tyVKx\n4BtfXV1pfn7e7GO9rxUMmZtmampK1WpVwWDQsPFYLKZ8Pm8REyA3HBKo2JvNplFdJyYm9PnnnxsD\nkN95LBYzVGhra8tKEMx1aIrvukZqM4NIQG2k1mTiRaOWSCRsLAwiEYlElE6nTfrU7/eNdE+NTSnS\nbDYNl93d3b1FMAI9oRnFS5mOneAaXh8km0qlYr522OZSjszPzyscDqteryuTyajT6WhsbMywdG8T\nx2QzEomo0Wjo+PhYe3t72traso3sOI6KxaIikYgNl8ixLpfLOjs7s8FTr9czJIXXCh2Vm4T6n2mn\nJMOgu92u4vG48Um2buLVSqWSPXjD4VDVavWBnO9d2KRCjaSbZiM3Gg1TRLCRJVlqExuOpoYxNSNw\njAPxK4YQj66QUwoyO9wMmjVq4lgsZjUvGHc8HjfvC5yJQE9IcoX/izUApQS+bY7jmAIcxUcoFFI8\nHjdPDn5HQHsYuOAxwgPrbUi9jkgMQrxZKgyAuHlAM3BsOj4+VrvdtqHO1NSU9vf3jTuCKujBnsuz\naLTwNhsMBvZmc9Wn02krD5iSzc3N2Ym2sLCg/f1984PDLEaS0T7p7lkkTI2NjalSqRj5hgYRrSG1\nO280D5xXQoTEiXGvd9OtrKyYqQwDHx6aJ0+eGOQIEw1NHnAlpyq5gFNTU5qbm/sFC1tsFkibhUI6\nOzurFy9eWNOMDpCyi6koTSDxyfBZsACDlgpNAHRmYWFBn3322Z3f/5HazJC8SVpl80iyN51aV7pO\np9re3lY+n7eYhFevXplbveu6Rn88Pj42eO7ly5daWlqy0Et86VzXNVd9pnbBYFB/8id/osXFxVu8\nh+npaZu2kTIVi8Xsagd263a7mp2dtUy/Uqmkd+/eSbqewNEEVqtV4zPDQX7z5o01gMCKYOR8X5z4\nvfKnVqulYrGo/f19BYNBy+dutVo6Pz/X7u6uORbx+zg5OTG+B+qS8fFxsyFD2c7D/vMj73a7/YAz\nexeDDt5AQi45AagLa7WaudZjE7u2tqZ+v690Oq2LiwslEgnzjCByDUlSuVy2EuTJkycWX7y5ualk\nMmlBP5iFg5RQPoyNjWlnZ8dujEAgoJWVFcPDwVtbrZampqb0+eef26Bhc3PTcqkLhYJ561H3A0fi\ntTc2dp15zX8zCofBh9k6/tIbGxs2Wo7H4woGg/ZvXE+JWoaJSAmTTCYNVgRnhlaL8z7cj1qtZiUK\n2DSawbuukdrMmLGA7wITodr2+/12ivK5lCbf+ta3tLy8bE0ZmCcEdLgGJL1Go1EbqBA2ubS0pFgs\npn6/b1AWWDHIBMJONgcyJzwwwI6xuiWgExvY+fl5Q1m46r3GijRpi4uLphd89eqV3QrAX9/85jeN\ngA/X23Ec5fN5NRoNOzVRrbTbbdNFcioDX9ZqNeNpx+NxRaNRlUolI0rBRGQSG4lE9N577+np06dW\nzrXbbSNU3XWNVJmBI7ska4b4BVUqFePjktFB/YgrpiQ7fY6Pj83vLRKJ2Cg8kUgY/fHNmzdGNg+H\nw6pUKjb9kmQNHU0WnA1Yc9SO3kAbrAEYPEgymVSr1VK5XFa32zWRgVeEQCk0Nzdn2sBWq2XNrNci\ngJMVMxt+fzRpl5eXajQaWl5eNldRYtWYbEoyOLPValldziLSgmkpURk0mAx5oNxCB7jrGqmTGegN\nwSpDAUnGoiOMJhAIKJ/Pm0SK63F+ft7G2fPz85qbm9PV1ZXJliDpF4tFyzABrUgkEqb4QPDKm4tr\nkVedUSgUlEgk7GuAyUqyiGSGJ9K1/KpSqSgQCGh2dlbSdVN6eXmplZWVW4oRtH3pdFrvv/++GZDD\nVtvb21O5XFYoFLLvA+UzEAgoHA5rY2NDPp9Pc3NzdprGYjFls1mThPEQYr8VDoftAeXURZkdiUTs\nZoH2SVZMKpXSBx98cK/3f6Q2M8gDLvk/H3PAyYfoE6yWLh5SEFg1VlkA+0BTjH2B/hCB8mAwNYMD\n7XX5YSQM6iLJ8FlIQahbQArQyAHz8TAwiKB5ZQLoDajEK5mfm+9BJh8PO8iIV2RLLe793QGfwQLk\nAWV4wykbCASUSqXs1oHY5PP5jEgF/Ie8amNj417v/0htZr/fbx5nXKHIplCgMDjwJiOB5+K9zJXN\nNMsrMG2320axlK7JMvV6Xb1ezzKmJVlNy/gbDjP5f9T2MMoGg4GmpqZ0enpqUCC2BJKs5oT15/P5\nzNWfYBzGxlgAICBlosnmZQNx4vf7fbNEoImGigrxiIcJEQEwICUVcCKjfxAawn/Q+PE6+J0QxSbJ\nfu67Lue+cVW/KctxnNH4QR6WXNd17vL3RmYzP6yHNVJlxsP6/3s9bOaHNTLrYTM/rJFZD5v5V7Ac\nx8k6jvMfHcdZdxznI8dx/shxnCXHcVZ/3a9tlNZITQB/E5dzjeH9Z0n/1nXdv3bzsa9Lup9JxMP6\nhfVwMn/167clDV3X/T0+4LruqiRLPXccp+Q4zh87jvPxzT+/dfPx3M3HP3UcZ9VxnD/rOI7PcZw/\nuPn/zx3H+Qc3n/vIcZz/enPy/7HjOMs3H/8rN5/73HGc//2r/dF/tevhZP7q11NJH/8pn1OT9Odd\n1x04jrMk6T9I+rakvy7pv7mu+89vTviQpG9Iyruu+3VJchwncvM1fk/S33Vdd91xnD8j6Xcl/TlJ\n/0TSX3Bdt+r53JFcD5v5q1//L0D+hKR/7TjO+5IuJS3dfPxnkv6N4zh+Sf/Fdd3PHMfZkLTgOM6/\nkvRHkv674zhhSb8l6YdMJm++piT9RNK/cxznP0n6w1/KT/Qbuh7KjK9+vZD0zT/lc/6hpKrrus8k\nfUvSpCS5rvt/JH1PUkXSHziO8zdc1+1Iel/S/5L09yT9viRHUsd13W94/nly8zX+vqR/LGlW0seO\n4yR+2T/gb8p62Mxf8XJd939ImnQc5+/wMcdxnul6c7Eikg5u/vtvShq7+bw5SQ3XdX9f15v2Q8dx\nkpLGXNf9Q12XEN9wXbcnadNxnL988/ecm+8hx3Eeua77M9d1/6mkhqTiV/jj/lrXw2b+1ay/JOl3\nbqC5LyT9M0lVfVmC/K6kv+U4znNJy5II9/htSc8dx/lE0l+V9C8lFST9T8dxPpX07yX9o5vP/YGk\nv33zNb6Q9BdvPv4vbhrFVUk/cV3386/yB/11rgduxsMamfVwMj+skVkPm/lhjcx62MwPa2TWw2Z+\nWCOzHjbzwxqZ9bCZH9bIrIfN/LBGZj1s5oc1Muv/AuHZAPr9VeA9AAAAAElFTkSuQmCC\n", - "text": [ - "" - ] - } - ], - "prompt_number": 4 - }, + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "df = pd.read_hdf('_temp/det_output.h5', 'df')\n", + "print(df.shape)\n", + "print(df.iloc[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1570 regions were proposed with the R-CNN configuration of selective search. The number of proposals will vary from image to image based on its contents and size -- selective search isn't scale invariant.\n", + "\n", + "In general, `detect.py` is most efficient when running on a lot of images: it first extracts window proposals for all of them, batches the windows for efficient GPU processing, and then outputs the results.\n", + "Simply list an image per line in the `images_file`, and it will process all of them.\n", + "\n", + "Although this guide gives an example of R-CNN ImageNet detection, `detect.py` is clever enough to adapt to different Caffe models’ input dimensions, batch size, and output categories. You can switch the model definition and pretrained model as desired. Refer to `python detect.py --help` for the parameters to describe your data set. There's no need for hardcoding.\n", + "\n", + "Anyway, let's now load the ILSVRC13 detection class names and make a DataFrame of the predictions. Note you'll need the auxiliary ilsvrc2012 data fetched by `data/ilsvrc12/get_ilsvrc12_aux.sh`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now let's take max across all windows and plot the top classes." + "name": "stdout", + "output_type": "stream", + "text": [ + "name\n", + "accordion -2.622471\n", + "airplane -2.845788\n", + "ant -2.851219\n", + "antelope -3.208377\n", + "apple -1.949950\n", + "armadillo -2.472935\n", + "artichoke -2.201684\n", + "axe -2.327404\n", + "baby bed -2.737925\n", + "backpack -2.176763\n", + "bagel -2.681061\n", + "balance beam -2.722538\n", + "banana -2.390628\n", + "band aid -1.598909\n", + "banjo -2.298197\n", + "...\n", + "trombone -2.582361\n", + "trumpet -2.352853\n", + "turtle -2.360859\n", + "tv or monitor -2.761043\n", + "unicycle -2.218467\n", + "vacuum -1.907717\n", + "violin -2.757079\n", + "volleyball -2.723689\n", + "waffle iron -2.418540\n", + "washer -2.408994\n", + "water bottle -2.174899\n", + "watercraft -2.837425\n", + "whale -3.120338\n", + "wine bottle -2.772960\n", + "zebra -2.742913\n", + "Name: 0, Length: 200, dtype: float32\n" ] - }, + } + ], + "source": [ + "with open('../data/ilsvrc12/det_synset_words.txt') as f:\n", + " labels_df = pd.DataFrame([\n", + " {\n", + " 'synset_id': l.strip().split(' ')[0],\n", + " 'name': ' '.join(l.strip().split(' ')[1:]).split(',')[0]\n", + " }\n", + " for l in f.readlines()\n", + " ])\n", + "labels_df.sort('synset_id')\n", + "predictions_df = pd.DataFrame(np.vstack(df.prediction.values), columns=labels_df['name'])\n", + "print(predictions_df.iloc[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's look at the activations." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "max_s = predictions_df.max(0)\n", - "max_s.sort(ascending=False)\n", - "print(max_s[:10])" - ], - "language": "python", + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "name\n", - "person 1.835771\n", - "bicycle 0.866110\n", - "unicycle 0.057080\n", - "motorcycle -0.006122\n", - "banjo -0.028209\n", - "turtle -0.189831\n", - "electric fan -0.206788\n", - "cart -0.214235\n", - "lizard -0.393519\n", - "helmet -0.477942\n", - "dtype: float32\n" - ] - } - ], - "prompt_number": 5 + "output_type": "execute_result" }, { - "cell_type": "markdown", + "data": { + "text/plain": [ + "" + ] + }, "metadata": {}, - "source": [ - "The top detections are in fact a person and bicycle.\n", - "Picking good localizations is a work in progress; we pick the top-scoring person and bicycle detections." - ] + "output_type": "display_data" }, { - "cell_type": "code", - "collapsed": false, - "input": [ - "# Find, print, and display the top detections: person and bicycle.\n", - "i = predictions_df['person'].argmax()\n", - "j = predictions_df['bicycle'].argmax()\n", - "\n", - "# Show top predictions for top detection.\n", - "f = pd.Series(df['prediction'].iloc[i], index=labels_df['name'])\n", - "print('Top detection:')\n", - "print(f.order(ascending=False)[:5])\n", - "print('')\n", - "\n", - "# Show top predictions for second-best detection.\n", - "f = pd.Series(df['prediction'].iloc[j], index=labels_df['name'])\n", - "print('Second-best detection:')\n", - "print(f.order(ascending=False)[:5])\n", - "\n", - "# Show top detection in red, second-best top detection in blue.\n", - "im = plt.imread('images/fish-bike.jpg')\n", - "plt.imshow(im)\n", - "currentAxis = plt.gca()\n", - "\n", - "det = df.iloc[i]\n", - "coords = (det['xmin'], det['ymin']), det['xmax'] - det['xmin'], det['ymax'] - det['ymin']\n", - "currentAxis.add_patch(plt.Rectangle(*coords, fill=False, edgecolor='r', linewidth=5))\n", - "\n", - "det = df.iloc[j]\n", - "coords = (det['xmin'], det['ymin']), det['xmax'] - det['xmin'], det['ymax'] - det['ymin']\n", - "currentAxis.add_patch(plt.Rectangle(*coords, fill=False, edgecolor='b', linewidth=5))" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAALMAAAOoCAYAAACa7cU2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvUmMZel1Jvbd9+6b75vnMV5MGZlZmSlmJYulEkWCpIQ2\n", + "e+O2V+0GBBE25AXhCTQBEe2FbEAbw4AhayFIC9NA24s2BAluSAuBLUEDSIKqYjIzq3KKOd48z/fN\n", + "0/Ui8juMYIsSkZESuwJ5gUJlRUW+8b//f843HcUwDLy93l7X4TL9vF/A2+vt9aaut4v57XVtrreL\n", + "+e11ba63i/ntdW2ut4v57XVtrreL+e11ba5rsZgVRfmqoij7iqIcKYryrX+k58gpivKJoiiPFUX5\n", + "6NXPAoqi/LmiKIeKovx7RVF8V3j8/0tRlLqiKE8v/OynPr6iKP/61fvdVxTln73B5/xfFEUpvXqf\n", + "jxVF+edv6jkVRUkrivJXiqI8VxTlmaIo//0bfZ+GYXyq/wFgBnAMIAvAAuAJgFv/CM9zBiDwEz/7\n", + "3wD85qs/fwvA/3qFx/8CgPsAnv5Djw/g9qv3aXn1vo8BmN7Qc/7PAP7Hv+N3r/ycAGIAPvPqzxqA\n", + "AwC33tT7vA478+cAHBuGkTMMYwHg/wXwL/6Rnkv5if/+TwH8m1d//jcA/rPXfWDDML4LoPszPv6/\n", + "APBvDcNYGIaRw/mX/Lk39JzAf/g+38hzGoZRMwzjyas/DwG8BJDEG3qf12ExJwEUL/x36dXP3vRl\n", + "APgLRVEeKoryX7/6WdQwjPqrP9cBRN/wc/60x0/g/H3yetPv+b9TFOVjRVG+feHIf6PPqShKFuen\n", + "wod4Q+/zOizmfyo+/vOGYdwH8M8B/DeKonzh0os4Pxf/0V7Lz/D4b+q5fx/AJoDPAKgC+N/f9HMq\n", + "iqIB+GMA/4NhGPqlB7zC+7wOi7kMIH3hv9O4fDe/kcswjOqrfzcB/H84P+7qiqLEAEBRlDiAxht+\n", + "2p/2+D/5nlOvfnblyzCMhvHqAvB/4sfH+ht5TkVRLDhfyP+PYRj/7tWP38j7vA6L+SGAXUVRsoqi\n", + "WAH8SwB/8iafQFEUp6Io7ld/dgH4ZwCevnqer736ta8B+Hd/9yO89vXTHv9PAPwXiqJYFUXZBLAL\n", + "4KM38YSvFhOv/xzn7/ONPKeiKAqAbwN4YRjG/3Hhf72Z9/mmu/6fxz84P/oPcN4g/Ot/hMffxHlX\n", + "/QTAMz4HgACAvwBwCODfA/Bd4Tn+LYAKgDnOe4D/8u97fAD/06v3uw/gP3lDz/lfAfi/AXwC4ONX\n", + "iyr6pp4TwC8DWL/6HB+/+uerb+p9Kq/+wtvr7fWpvz41ZcY/BTHy9vp0X5+KnVlRFDPOy4hfxXkD\n", + "8EMA/8owjJc/1xf29vqP6vq07Mz/lMTI2+tTen1aFvM/FTHy9voUX5+Wxfwffy309vq5X+rP+wX8\n", + "jNc/SIwoivJ2wV+TyzCMv0sb8g9en5bFLMQIznHRfwngX/3kL/36r/86gsEgJpMJRqMRNE3DcrlE\n", + "JpOBruvQdR2TyQTVahWbm5tYr9eo1+vQNA07OzsYjUbodrtQFAWz2Qwmkwnz+Rxmsxmr1Qq3b99G\n", + "Pp+H3W7HbDbD3/zN3+BXfuVXsFqt4Pf7USqVYLFYsFqt4HQ6MZlMEAwGMRgM5OcAEI/Hoes6LBYL\n", + "3G43yuUyFEWBruvY3t7GeDxGsViExWLB2dkZ7t69i1qthmazid3dXUynU6zXa7zzzjs4PDyE2+3G\n", + "YDCQz2E6ncJqtSIcDmMymaDf72NzcxPL5RI+nw/Hx8eYTqfIZDLI5XJwuVxQFAXBYBBnZ2cIhUII\n", + "hUL48z//c3zhC19AuVxGJBLBdDpFs9lEIpHAcrlEKpXCcrnEy5cvsbe3h3w+j42NDVgsFjx79gzh\n", + "cBiapgEAGo1zUm8ymcDlcmGxWCAWi+Hs7AyJRAIWiwWTyQS/93u/99qL5FOxmA3DWCqK8t8C+A7O\n", + "JZ/f/ruQjGg0Kov3ww8/RDQahWEYWK/XmM1mCAQCMJvNsFgsMJvNsFqtGI/HuHnzJvr9PqxWK6xW\n", + "K7rdLrLZLCqVCvb29tBqtRCJRAAAe3t7mEwmMJvNePbsGex2O/x+P0ajEaxWK2KxGOx2O6rVKpLJ\n", + "JFRVRSAQwHg8BgCMRiPEYjGMx2N0Oh3EYjEoigKz2YxwOCwL0zAMqKqKBw8eYDwew+PxoFarYWNj\n", + "AwBQrVZhs9kQi8VgsVhgt9sxHo/h9XqRTCZRqVQwGo1gs9nks2k2m5jP50gkEmi321BVFaFQCG63\n", + "G91uF5FIBKvVCuFwGKvVClarFT7fuc7I4XDAMAwEAgHM53M4HA4AwHK5RDKZxHK5xMbGBlRVhaqq\n", + "cLvdcLlcMJlMMJvNsNvt2NzcRKvVgtlslsdaLBZwOp1wuVzo9/tXWiefisUMAIZh/BmAP/v7fqfX\n", + "68HpdOLg4ADL5RIA8OGHH+Lzn/88qtUqarUaYrEYFosFUqkUjo6OoOs6Dg8PEQ6H0el0oCgKKpUK\n", + "HA4HTk9PYbVasVwu4XQ6oes61us17HY7Go0GdF3HfD7H8+fP5Uv86KOP8ODBA7RaLVgsFqiqikaj\n", + "gfV6LQsrl8vh+fPnePfdd1GtVrFarTCfzzGfz/HRRx/B5XJhOp1iPB5jPB6j1WrB7XZD13UcHBzA\n", + "brejVqvB6XTCZDJhOBzK7j8YDHBycoJAIIBu91zdWSwW4fF40Ov1sLm5ibOzMwQCAUwmE/R6Pezv\n", + "7yMcDuPly5cYDocol8t49913USqVUCgUoKoqjo+PYbfb0ev15JTp9/tyk4xGI2xsbGA8HsNkMiGX\n", + "yyEUCkHXdTSbTaxWKyyXS8xmM4xGI/h8PhwdHaHX6yEYDMLn8+HZs2dXWiOfCpz5Z7kURTF++7d/\n", + "G4ZhoNvtYjQaIZ1Oo91uY2trC5VKBeFwGGdnZ5hOp3A4HLDb7TAMAxaLBdPpFH6/H8PhEGazGTab\n", + "Dfl8HtFoVH6fi3E6ncLtduPRo0e4c+cOOp0OQqEQhsMhfD4fFosFrFYrCoUC/H4/1uu1PE6n05Ej\n", + "VdM0BAIBDAYDLBYLeDwetNttWK1W9Pt9KZNMJhM0TcMPfvADpFIpWCwWZDIZ9Ho9WK1WOJ1O7O/v\n", + "y07o9XqxXq8xHo/l35ubm+h0OvB4PPjkk08Qj8cRiURQLpdhs9ng8XhgtVpRqVSgqirS6TSePXuG\n", + "W7duYTabYTgcYj6fYzabwW63YzAYYGtrC4ZhwOl0olw+1/+EQiEAkMdar9eIRCLodruYTCawWq3w\n", + "er0wmUxot9sIhUI4OTlBMBhEr9fDt7/97WtfM/9MV6lUQiAQOOfpX9W9rInr9TpyuRwikQj6/T68\n", + "Xi+Ojo4wGo2QTJ6jfL1eD6FQCC9evEA6nUav14PP50O1WsWtW7dgGAZarRZ8Pp/8P5PJhMlkglwu\n", + "J19gMpnE0dEREokEFosFRqMRZrMZxuMxptMpstksarUa4vG47FZOpxNnZ2cAAEVRsFgsMB6PsVwu\n", + "MZ/PsVqtsLGxAZPJBIfDgSdPniCbzWI+n2M8HsPpdGK5XMJsNiOXy0FVVVitVqiqKrv+aDSCyWRC\n", + "IpGAruvweDyw2+1oNpswDEMWWDgcxnK5hMPhwHw+x2KxQK/Xg6ZpGAwGUFUV0+kU/X4fLpcLx8fH\n", + "0DQNi8UCuq5DURScnp4iHA7D6XSiUChgPp/D5XLBbrejXq/Ld1apVGCz2aCqKkqlq4kdr9ViBs53\n", + "TTZAZrMZOzs7cLvd8Hg8ODk5gcPhkF00FArB4XDA7XbDbDYjEonAbDZDVVVYLBYoioJoNAqn0yk7\n", + "kqIoGI/HWCwWOBeBQR6n2WwiHo/DbDZjd3cXzWYTZrMZbrcbJpNJSpn5fI5kMgmTyQSTyYTFYoHV\n", + "agWXyyVlDGvWWq2G7e1tFAoFWK1WaRR9Ph+8Xi/6/T4Mw5Bd2WKxYDweIxAIYL1ew+v1wmw2o1Qq\n", + "SX08nU7h8XjkebPZLMxmM3RdRzabxXq9hqqqSKVSACBlgaZpUBRFPlu73Q6r1QqPx4NQKIRqtYpQ\n", + "KIT5fI6trS10u13MZjNYrVbY7Xb5ffYf8/kcxWJRmsadnR185zvfee3v/tOCM/9MF5smRVHQ7/dh\n", + "NpuxXC5ht9vR7Xbh9Xphs9mwXC5htVrx1a9+Fd1uFw6HA2azGYPBAI1GA4PBAIqi4HOf+xyq1SpG\n", + "oxFarRZWq5U0VYPBAE6nE6qqYjKZSNPW7/dlNwuFQtLscFcfDodwOBzweDwAIGUNj/H1eo1er4fV\n", + "aoXVaiWPabFYMJvNYDab4fF4kEqlMB6PYbfbpQTyeDyYzWZYrVZwOBzSYOm6jnA4LI3vbDbDfD5H\n", + "NBpFq9XCbDZDs9kUlMZsNmMymWCxWMhn2263MZvNMBgMYDKZpNZlGeNyuaSkYt3MTcTj8cBisQCA\n", + "IES9Xg+pVAo2mw3D4RBOpxOtVutK3/+1WsysLa1Wq+yohmFgPp/DZrPB7XYDOD/GnU6ndOVEAzY2\n", + "NhAOh2G322XRcDcOBoNwuVwIhUKw2WwIh8NYLBYwm81wOBxwuVxyUywWC2iaJjeX1WqVXZNNm2EY\n", + "srupqgqXywWn04lMJgOXy4VgMCiPrWkanE6noB28WQ3DwHK5hKqqMJvNePfdd2XnBM7rVpvNBk3T\n", + "4Pf7oWkabDYbHA6H1KhutxsWiwWhUEhe33w+h8VigdfrBQAsFguEw2HM53NYrVZsbW3B7/dDVVXM\n", + "ZjN5TS6XC2azGYFAAG63G5qmyfs2mUxyeqxWK/h8PkwmE0GDptMpAoHAlb7/a1Vm+P1+NJtNRKNR\n", + "PHr0CGazGb1eDzabDfV6XdCF2WyG9XqNv/zLv0Sz2ZRFeXx8jMFgICjCs2fPsLe3h8FgII0aS47Z\n", + "bAabzYaTkxP4/X40Gg1MJhO43W7BnK1Wq9wo/X4fTqdTXt/x8TGcTicSiQSazabsvIFAAIqi4OXL\n", + "l1BVFU6nE5VKBfP5HPF4HLPZDKFQCE+fPsWNGzcwHA4FzTg4OJCbtt1u4+TkBKFQCGdnZ9IrLJdL\n", + "aJqGYrGIRCKB0Wgk5cb29jb6/b6UT/l8HjabDWazGe12G+l0GoPBAB9++CHm8zny+TxcLhcmkwkK\n", + "hQLW6zVWqxXi8TgePnyIjY0NubGazSYAyG7PGl5VVTSbTdksrnJdq515Op3CYrGgWCxCVVX0+32B\n", + "zLjzzedz+fdyuUSv15MjdTabwe/3S40XCATQ7/exXq/R6XQQCASQy+Wk8ZlOp4jH42g0GrIDLhYL\n", + "tNttAOclxGKxQKVSgaIo6HQ6cLlcsjNFo1GsViu43W44nU5p3nRdh6ZpSCQSUFUVJpMJNpsNTqcT\n", + "0+kUpVJJmsThcAhN0zCfz6FpmpA0q9UKHo8HqqrC7/djPB7LydHr9aSpZIngcrnQ7XYxHo8xm83+\n", + "gxPF7/fL52mz2WC326WvGAwGcDgc0HVdyCI2ydPpVH6X5RPret7kqqpitVphOBxe6fu/Vjvzer2W\n", + "49Lv98NisQj05na75YvvdDpIJBJYr9d47733pHmJx+NYr9dIpVKYzWYoFovY2toCcF6Pj0YjbG9v\n", + "S2OjaZqgGiQKLBYLut0u1us14vE4xuOx7KgOhwOTyQTr9VoayPV6LSXJYDBALBaDw+GQXXQ+n8Pv\n", + "96Pb7Qoyw3LAbDYLqREKhTCZTORGYelhs9nQ7XYFGw6FQtLMBgIBYfF4IiiKAsMwpDEeDodCrhiG\n", + "gXq9jnA4jHa7LU0r2UE2qHa7XW5Aj8cjJVKr1bpUang8HgyHQ6TTaSwWC8Tj8b/v6/0Hr2u1mE0m\n", + "k+woxD+5aNxut1DUxItZP6qqKrUxG6pOp4Pt7W24XC4YhiEd/Hq9lkXCGhKANFeqqsLn8wmbdfFx\n", + "AUhzyNqWmDRJFTaLLIlWq5XU1g6HA+v1GhaLRd6D1+uVJtLv98vuzTp2PB7LIluv1/B4PBgMBphM\n", + "JlAURero4XAIr9eL0WgEv98PAPJY7D2IcvDzWK/X8lqXyyXcbjfcbjfsdvulv8Od2el0ygkzHA4F\n", + "c+Z3papXW47XajGzk2ZpQJhuc3MTx8fHWC6XWCwWwuixM282m3jvvffw9OlTwTwbjYZguuFwGPF4\n", + "HIVCAcC5vsDpdEq5wWOVdaPJZEIkEkEul8POzo7UxKVSCR6PB4FAAHa7HaVSCZqm4dmzZ4jFYvB6\n", + "vahUKrDb7Wi323A4HGi320gmk7LYisWisHAejwf5fB5+vx/lchnhcBi6rqNYLAqGHY1Gkc/nEQ6H\n", + "oaoqOp0ODg4OEAgEUKlUMBwOMR6PsVqtBKPnjdput6HrOnq9HgDAbDajXC5jZ2cHiqLAYrFgvV4L\n", + "IhIKhdDpdLBcLmEYhpAr7EN8Ph8Mw8CLFy8QiUTw5MkTAMDZ2RmSySSKxeJP/W5/luta1cxOpxPj\n", + "8RixWEzqVKvVina7DcMwpKsn6D+bzfDw4UOEw2EUi0U4nU6MRiM5Svv9PsLhMGq1GlqtljR0qqpC\n", + "13Wpm/1+P3Rdx3K5hMfjQSwWQ7vdRiQSga7r2Nvbw3q9RjqdhslkQjKZxHQ6xXA4hN/vh8/nkzJg\n", + "d3dXdCOTyQSxWAyTyURecywWw+7uruy4fr8fs9kMFosFuq5jMBjg/fffF4hO13XRSRCmS6VS6HQ6\n", + "iEajGI/Hsjun02lYrVbMZjNZkJFIRAgZAPD5fGg0GqjVagDO+wKWEzxV/H4/er0eDMOQfoBwKLH7\n", + "1WqFdDoNt9uNYDAopchVrmu1mGu1GtbrNUqlEsLhMBRFkcVG/JaKMzaELD/YlKTTafh8PmGsyOwN\n", + "BgP0+33ZzQFIudHr9aSUaLVaODw8hNfrRb1ex3K5xJMnT2AymdDv9zGZTHB6eio0b7FYFChwNpvh\n", + "0aNHMAxDVHXtdhsulwuDwQC6rmOxWODjjz+G2+3GfD4XjDYYDMJms8HlcuG73/2uqNXYWBUKBei6\n", + "jtlshnw+D6/XK83ZcrnEcDjEZDIRWI6NcbValROO+DNvDuLgFFlxMxgMBvD5fFLnt9ttmEwmjMdj\n", + "jEYjHB4eYjgcYr1e4/Hjx6Ihefr06U/9bn+W61otZqfTKX8mRTsej9FsNqEoijRmq9VKSpJsNovx\n", + "eCyNT7PZRKPREE2E3+8XUkNVVazXawCQsuHil93pdAAAHo8H0+kUiqLA5/MJ8rBer+F2u4UmXq1W\n", + "UFUVvV5PbrZQKITFYgG32y2NIutWvg5FUdBoNDCdTjGZTDCdTlEoFGCz2bBYLEQItVwuMRqNBFdm\n", + "4xcMBjGfz6HrupBFZrMZo9EIiqKgXq9Lv8FewWQyiUSWRBBJlOl0ilqtJiUStSV8zYZhCPyn6zqi\n", + "0Sg8Hg8ajQbS6TTMZjO63a7cgK97Xaua2eFwwOl0QtM0qV0TiYRQupubm2g2m5hMJjAMAz6fDz/6\n", + "0Y/wwQcfwGw2I5lMXmLLBoMB7Ha71MSBQABHR0eIRqMYDocIBoOiGdY0TZAFRVEwn8+xsbGB1WqF\n", + "RCIhwiHgfLFzB/R4PFgul7DZbMKasWZnHcuTw2KxIB6PC1tHUoOUOUsVljOKoggjarfbkU6nhSRq\n", + "NpsCnyWTScxmM3g8Hui6Lo1kPB4XEVQoFBJSio/BRtFmswniYjaboWkaXC4XbDYbfD4f/H4/isWi\n", + "vCaSKNSZK4oCm82Gmzdv4k//9E9f+/u/dos5l8vBZDKhVqvh7t27KBaLWK/XGA6HGI1GsrPlcjkE\n", + "g0FomoZSqQSv1wuHw4HVaoXHjx/j/v378Pl8cDqd6Ha7cDqdqNVq8Hq9mEwmoqngEdnr9VAoFHDj\n", + "xg2B56bTqezmhLFI5ebzedE7T6dT2elY7qiqinK5jGQyiZOTE6xWK9y4cQOHh4fweDzSXBIrnkwm\n", + "cnpwxyaeznKgXC7D4/FgNBqhUqkgEAhgOp0CgLCSy+US7XYbwWAQR0dH2NjYQLlchqqqqFQqiEQi\n", + "sNlsWK/XmEwmcDgcmM1moq9erVZot9tot9twOp1oNBoYjUZYLpeIxWJSdrA273a7cLvdWK1Worx7\n", + "3etalRnD4RCbm5vw+/0iGHe73QgEAhiNRqIeo5Ccu5LL5cKtW7dEdXbv3j0Mh0O0Wi2RcdINwSPU\n", + "7XbLMUwMOZVKYTQaoVqtIhaLYTqdIhKJiAC9VCpJ+bGxsSEEA3c/KtiIDft8PpTLZezu7iKTycDj\n", + "8cBkMsnuSRbN6/UKBOjxeFAul+FyuTCbzeDz+VAsFrFYLOD1euU5U6kUdF0X3cpsNpP6PJFIwOFw\n", + "wO/3o91uy3/funULq9UKkUhEqHUKmogds3zLZDIAzqFJ1vadTgd2ux3T6RSapsmmQOLkqqTJtVrM\n", + "7XZbFqvdbpcOm1RwIBCAx+MRwXssFsPjx4/lg9za2oKmaUJMRKNRuFwujMdjHB0dwePxoNPpwOFw\n", + "oFqtyvHudrsRj8eFdGADSf1BOBxGt9tFNBqVGpT4tMfjQTgcFtYxlUpBVVURIlFmSnbT5/NJrc33\n", + "xrqaKA4RGyrzCO2FQiGkUikpbagr5o1FRISCqK2tLYHXbDab3MyUdhLNIbFDvD6ZTEofwBKE6Mx0\n", + "OhWxF0mqUCgERVFEivu617VazGazGfP5XHxvg8EA9Xodi8UCtVoNz549E9IDAMbjMba3t2EYBiqV\n", + "Cl6+fInpdIoXL16IBpq1MzUEPGLJMNKZksvl0G63BV1ot9sYjUYYj8fQdR0Oh0OazNVqhWKxKN5C\n", + "Noe6rqNWq8nPCHV1u120Wi2Uy2VRq5VKJZjNZgSDQdlhy+WynCAX3StUrD158gSnp6eo1+uXqP56\n", + "vS6wGZtNq9WK58+fAzgnZpbLJdbrNebzOUqlEvb39wWLXywWODw8FJJmMpkgn89jsVig2Wzi5ORE\n", + "UCAqGXu9Hk5PT9Hv99FqtaCqKqrV6pW+/2u1mCORCFwuF3w+H0ajkSjnVFWVJovsVyQSQbvdRqvV\n", + "EqaK/55Op6JfIBxFFotoxnA4hK7rGA6H4vEjPOXxeKAoCvx+v/gDqZleLBaCUxN9GI/HcLvd8Pl8\n", + "QhvPZjOB4rrdLoLBoODYbKAoGgoGg7Db7fD5fJcE/Y1GA51OB91uV9R5s9kMsVhMqGoSSe12Wyhp\n", + "ylR1/Tw6mWUP6+/5fC6NJckQi8UiiEWn04HNZpOTiPix1WqFw+EQ/yB9jzRRXNX1dK0Ws6ZpmE6n\n", + "aLfbl2hk0rar1Qper1dqaE3TcHZ2JsJzr9crOmIC/Wze6NhgM3PRga0oimh8TSaT1MCDwUBkmPy7\n", + "3IFtNpuIepLJJObzOabTqezOFotFdnNN0zAej+XUASC7OmtOLloK/slwkvVrNBpCPfN1ES9nOTAe\n", + "j2VRDodDaVrNZjMURRFsmLs9kYtOp4P1eo1+vy/mB/4+f5dMIfXgiUQCNpsNtVpNTAlkWF/3ulZo\n", + "Rr1el91tMBig2+1K7enxeBCNRtHtdkXEQ8yVWloSILdu3ZJaDoAIheiqJipBAU6n08Hm5qbsyGyw\n", + "eAOQRSS6QDobgCwGs9ksNTjNqIvFQrQhPAE0TUO1WkU2m4XdbkelUhG4zO/3X8J6b9y4IYL/RCIh\n", + "2giTySS753w+RyaTkViEcrkszpjPfe5zggbFYjHpLUKhkLhVgPO6nvpoOtxpzYpEIvD5fJjNZlJi\n", + "kZ0kscVa/Etf+pJQ3K9zXaudmdrcTqcDt9uNbDYrWgPWoRQWKYqCDz74AMlkUnYpTdOkIYvH4/jq\n", + "V78q7JzdbsdisYDP5xPBDUVNbH646EwmE6LRqLwmAPI7VPI5nU4EAgE4HA7ZTe12O2KxmEhAicg4\n", + "nU4pc4hFc/EHg0E4HA4kEgncv39fMGZN05DJZOD1euFyuUTUFAqF0G634ff7YTKZ4PF44PV65X0F\n", + "AgFp7Ig1s8lkbZ9IJIRip1fQ7XYjkUgglUrBbDYjkUhgd3dXSCHGMPCz9Xg84lRxuVxwu91y6rzu\n", + "da12ZtZoLpdLsNHZbCY6iKOjI/HXhUIh/PEf/zHW6zWq1So8Hg+Oj49FaE58l7tZpVKB1+uV0Bab\n", + "zYZisYhWqyVlAMX7lEo2Gg3cu3cPz549g9PpvKTlpZ53tVrh+PgYiUQCxWIR4XBYMGHi41arFdPp\n", + "VBRt/X4fs9kMiURC7GC1Wk0sXGwu9/f3BcqLRqMoFAoCI/I1dDodtFotKU2sVis6nQ5u376N4+Nj\n", + "IW5arZb0EnyP/X5fmrxGowG73S4Sz3a7Lbgy3zOpbxJWjx49gqIo+OSTT7C9vX2lXRm4Zjtzu91G\n", + "rVbDYrHAfD5Hv98XQqLT6WBra0vw0fl8ji9+8Yt49OgRIpEIXr58KU0cpZcX3dW0OdGhMRgMEA6H\n", + "EQqF0Gq1xJ1BnJW7UavVgtPpFC3zfD4Xva/b7UY4HMbW1pZIJJllQQlpLBZDsVjEdDoVhIP2LcYK\n", + "UHJZq9UwnU4RjUZFl00cnbEDg8EAo9EIjUZDJJ5kEllWud1uKQlcLhd6vR50XZfAmuVyiUKhIKcP\n", + "yyOq69gf1Ot1iXS4GMjD+p4nTyQSkRPuKte1Wsy03qTTafkivF4vFosFgsEgAIhmVlVVPHv2DOl0\n", + "GhaLBRsbG6KpCAQC8Pv92N/fRyKRgKIoyGazcpwTXaDTeWdnR7x6wWBQHM4+nw/L5RI3b94UBRoA\n", + "WYilUklwXOpAdnd3EQqFLkUm0FOXzWbhdrslwosGXYryl8ulwI3L5VKc4IQSWTdHIhHBsi9mh2ia\n", + "Jhg4dd/UUbPuZbCL1+uVG8Ln88FqtYrLmyekz+cTcT4p+Gg0is3NTSmVWNZomobd3d0rff/XajGz\n", + "ZqVgxuFw4OTkRPBTpgQRnXA4HBIYU61WoSgKVquVeO6azSYGg4FkU1itVvGymUwmie1iidFsNtHr\n", + "9dBut9HpdESo/9FHHwnNPBgMxPHN0BdCdoPBAJ1OB7quiyi/Wq2i1WqJvrjX6wnaQTgRAE5PT+V1\n", + "7e/vYzabSRQWSwGSLLQvUWjEXZg0NJnQfD6PwWAgbGi9Xpe8DfoOWdpczOVot9soFApSVhACrVQq\n", + "osY7OjrCfD6XaLLxeIxKpXKl7/9aJRp985vfFI1ur9cThosZEbTs12o1JJNJgag0TRNLFb9ILiiH\n", + "wyGCI3rpgXcGAAAgAElEQVT8JpOJEBOkcG02m7BkrG8pKGK9DEB+3u12EQ6HRePAPAzu+Iz+oqKP\n", + "aAbdNIS8qMjTdV1uUGo82MgVCgVsbW1hPB4jGAxKk0yh0avPDy6XS3QZ4XAYw+FQtCcMhmk2m4jF\n", + "YqLvZsadw+GQml5VVezv78Pv98Nms8FqtULXdXHAOJ1O1Ot1JJNJiQaj7ew3f/M33yYaAYCu69JY\n", + "nZycSDLl3t4eLBYLjo+PEYlEUK/XxdVRqVRw7949SdqZzWY4PT3FvXv3cHh4iLt37+L58+e4ceOG\n", + "7JT0FLLZ4S5DnDsUCmE0GgkzV6/X4ff7JamzWq1KXsfFpspms2E6nUpjyXqTATOVSgXRaBTBYBD1\n", + "el1yKVhTU2HHBKaXL1/CbDbj6dOnl2IB6ERZLBaCP5P27nQ6gpfTCeP1evGjH/1IwhuZqKqqKj7z\n", + "mc/g8PAQAETu6nK5hNUbDAaX3Oq8eb1eLwaDAcrlsqA3xL1f97pWO/PXvvY1JBIJ1Go1BAIBbG9v\n", + "4+DgAPF4HNVqVaSh/JIePHiAP/qjP8KdO3dgsViQzWYl7GU2m+HevXv45JNPMBgMJLtiMBgIwwYA\n", + "iURCcjlqtZrseKlUCt1uV8oAitsXiwUCgYDoGEwmE6rVqsgj4/E4crmcMJfNZlN2cmZpsJkju0gC\n", + "5f3338fDhw/RarWQTCYRDAbRarUEWQCAZDKJH/zgBwiFQlBVVVRrhmFI7U1vZDweR6fTQaFQgMlk\n", + "ElSFFrNYLCaUORlKn88HXdeF9ez1egLrsYcg6hMIBEQF6HA40Gg08Ad/8Advd2bgx9FcpFSdTieq\n", + "1aqI0UulksBS6/UaP/rRj6DrunzZh4eHUlc7nU5873vfE7tQrVaTxxmPx7KAWq0WWq0Wtre3MRgM\n", + "MJvNBB4DzmWpvV5PvsCL7ufBYCBIQr1eRyQSkXqXiaTdblfez0WTLBV79XodLpcLnU5HYDDWyuv1\n", + "Gt1uF+VyWUoS0vPtdhs2m008fvP5HF6vV3LvaMotl8tCqe/u7iKfz6NYLEoQjcPhwPPnz8UCRSnq\n", + "ixcv8MEHH6Db7Qpt3mg0xDNZLBZx69YtqdEZA3yV61ot5mg0KouDH2AmkxGigOk5JCBu376NFy9e\n", + "IJvNSo1NyxDF4kyyVFVVogXS6TRqtRqsVqugDvxiWfuFQiHx11HySScKPXB0fvDE+MnaXFEU7O7u\n", + "4uTkRBADZiiTfibyQnJntVoJ3svXzNDvi3Af47EODw8lDIYQnsfjgaZp6Ha7SCQSAktyx2bN/eUv\n", + "f1nqcU3T5DGcTifef/99kafyJGK/QQOC3W6XBClmlFzlulZoRq/XEyuPx+MRmpbZxQxL6Xa7smPQ\n", + "t+Z2u+Vo3tnZgd/vF3aOZYTD4YDVakWv1xP2i6whAxNXq5UIdoipmkwm1Ot1YQ3JVHIRs6EMBAK4\n", + "deuWiIbozmaJwKkA3W5XUBXutIZh4Ctf+YqUIQ6HQwwHjF7Y2NgQ9i4ajUozCkCaRWos+v0+QqEQ\n", + "lsulnG6NRgOBQAC3b99GLBaTm5PiLjpZmF1y0aDK9CLqmQnZ8e8DkI3oda9rtTPv7u7KEdtsNiWN\n", + "nYJ1TdPQbDYxHo+xtbUlwd1M62Rj+MMf/hDpdBqPHj3CrVu3UK/Xsbe3h1KphF6vh93dXXQ6HRmZ\n", + "cHBwIOUD0ZOHDx+K1arX62E0GkniPj1z29vbIuJxOBwSaUvPIp0cz58/lxuLzN/BwQHu3LkDj8eD\n", + "SqWC09NTiR2j8IdwHQmc09NTsXDVajXs7OwIDBkIBBAIBCQrOZ1O46OPPoLf74eiKOIkyeVyAjHy\n", + "FKDemzkYmqah0WggEolITV+r1QR/7vV6YqAlW8v6+SrXtWoAf+3Xfg3pdBqNRgN+vx/b29t48eIF\n", + "EomE0K0AUCgU4Ha78d577+EP//APcefOHQlOrNfrYiS9d+8eHj9+LLFTbrdbRErUKaTTaZGKNptN\n", + "0T0kEgkRqNOISn0ETbLckS4iCqlUCqenpzJnhF495iYDEPVdMBiUHW+xWOBLX/oSvve976HVaiGV\n", + "SiEQCIhiLpVKwWQyIRaL4fvf//6lHA2PxyOjMqjE83g8EhJO7TQRkQ8++ABPnjyRxKbZbCajIxhK\n", + "Qzy60+kIoUOokhJTWrPYADabTfz+7//+azeA12oxf/Ob34TP55NMDCbIUzfM2rdarYoplVRwqVSS\n", + "fOblconJZILJZCLOFMMwEAwGJUaLBAsA2V2JqbIJ4mtheUEnB7v8YDAohA5F/rQoMeiFODMNscR2\n", + "AUiyEL1/dDiPx2OEQqFLxAtLBqZ5djodSTBi2hFfC0uS4XAosCIXPKcEMH42GAyi0+lIWpSmaQiF\n", + "QhKnQHktYx6o+S6Xy9jY2MDBwYE4TMxmM37rt37rLZoBQOhbpuik02l0Oh3s7Ozg2bNnElZCXLdY\n", + "LOLo6Ai/9Eu/BJPJhNPTU0SjURwdHYm4BvixdWk0Gol/jSJ1NkpskE5OTiTettvtSuYF2T5FUUQZ\n", + "Rziu1+vB5XJhNBpJ6UNV2mAwEMlpq9WC1+uFruswDAM3btxAtVqV+n08HouGeDgcolKpIBgMolar\n", + "iQ6brKbT6bykIe71erh9+7bk2fV6PRweHkLTNJn9srW1hf39fWQyGdFhc7YLwxYnkwnK5bLk2zF6\n", + "l2wlk5zS6TSOj49xdHSE4XCIeDyOR48eXen7v1YNIO3+Pp8PmUwGsVhMPkgygyQuWDoAuJSwmc/n\n", + "ZRKTxWLB/fv3MZlMZAZIPB6Hz+cT0oSLjbVrKBRCJpMR4TqllTS38r8pxp9Op+LrYwIQM+yY00aR\n", + "EcuJcDgsoieiFmQwqXOgwo8sJwVUgUDg0pEfCASg67o0bWQwAUhjmk6nYbPZpA8hXV8ul6UGZonC\n", + "7+FiBC/ZSiYlMfqB6AwjDiiXfd3rWu3M/X5f4lsDgQC8Xq+Ij0ajEe7du4f1eo1cLof1eo1f/MVf\n", + "RKFQEBf3r/7qr6LdbmN3dxfr9Rq//Mu/jMPDQ/lS6FBhc7Zer7G7u4vZbAaXy4Xlcim75t27d8Vg\n", + "u7m5iW63KwIeQncU+XQ6HVitVqRSKSQSCZnwxMgCegqZ2EnHNJPuuSi+8pWv4Lvf/a7Y/D//+c+j\n", + "1Wqh0WiIN5DmWjpI+v0+7t69KygMhfmLxQJf+cpXxHsYi8Ukfvezn/0sjo+P5UZIp9NIJpOy+FVV\n", + "FSc4R67REU9ZAbXcvLF4mj18+PC1v/9rVTP/xm/8hgSOx+NxoYopWD84OJAEIy58kgkM2bZYLJjP\n", + "57hx4wa+//3v486dO4JyOBwO5PN5ZDIZ2VnD4TAODg7gdDrR6XSQSqVkxz47O5OJTGz2iAAUi0Xs\n", + "7u6KCIgCKKrO6DKv1Wrw+XzybzKBdH9wgZVKJYxGI8nNY0QtpaFUEFosFmkgycjRysRSxDAMiQpg\n", + "2hEx9NPTUwmX5MSAer0uDhQmI1HjQQyeJ+T29rYwgnSGc7zGw4cP8Sd/8idva2YAl/LTTk5OkMlk\n", + "RKzPzDhivGSiSqWSgP5Ucem6jhcvXogQh40krVMU1U+nU9TrdSEp2L3Te0h7EbFqKueI5xKpuJia\n", + "xEaMfyeRSIimghYqivy5ABlzexFRCAaDkqF8kWbmdKxgMChZdsxGJvLCcqPZbEpaKHCuU3a73RKT\n", + "wPfD8qbdbiObzcLr9YqakDpoBk1e9ExSJ0Ip6duogQtXr9cTL1y9XhdXcaPRkGaOKjIOaCwWixgO\n", + "h+j3+9B1HZ1OB6VSCcvlEq1WC5PJRMbzAucTSSuVClarlUR9DQYDFItFVKtVybB48eIF/H6/sGwU\n", + "ELXbbWENaZjN5XLyxQPn4xcePXqEZrOJ/f19iZZ9+fKlHNvdbhf5fB69Xk8gQebPMXCl2WzKv5ld\n", + "x5mGpPHZHH700UeXXiNwLiut1WoYDodCz1erVZycnOCjjz6SiQP7+/uXUkEHgwH++q//Whg9Mn9U\n", + "EzKXg+E0tJz98Ic/vNL3f612ZsZdUYTDwBWKYIh5sllSFEUEN5FIBBaLBdVqVVKMOBaiUqkglUpJ\n", + "LAEhtXg8jlQqhfl8jtPTUxHqM2eNKT8Mn6FYh0gFa06Xy4VAICDHNIXzbKoikQh6vZ4YcGOxmEgn\n", + "iSUfHx/j/fffx2AwQK1WQyQSkcfj6eB0OhEKhVAuly9N3qL1iuaE0WgkzpfVaoVMJoNGoyGoTTab\n", + "lXR+ZnhwABBw3gDev39f6PF4PI5arYZsNivZcqzh+dy6rl85Of9a7cyse7vdLjY2NjAajcSSw2gA\n", + "fpBMHNrd3RWtcLFYhMPhwAcffCBw2XA4xP379y8lwnOK6Ww2k6ziVCoFTdOQz+dl+A4F8bFYTHZ6\n", + "1qBUpLG+Zj7c2dkZlsulBJlfLDvu3buHVquFWq0mU6+Ojo4AnLtXLqYIcehQLBaTG5PBjjw9qF+h\n", + "0L/f78Nmswkzubu7K3G+DGrkfEKOq+Bzc+oVoxaIXjAzj3U+iZ/pdIqzszO0Wi10Oh1EIhFx4rzu\n", + "da0WM0MEedRdPMq501AcztqVc7OPj49FYD8cDkWrTHz34OBAJJccJkl9Ba1YFDKx1tY0TSBARVEk\n", + "uJs5dcFgEFarFbu7u9JIUaNMPx5vSmK2xMoZysIoMTq3V6uVMIz0JRIn56nF/Ds2aD6fD9lsVnKs\n", + "yUgSleCQn9VqJZ7CVqslOXIul0sE+2Q4OVtQVVWZ90fzLMu/3d1dsaIBEJ3I617XajFHo1HxyjFr\n", + "jSIb4LzepcTzopOYXT/F7aPRCMFg8JJL5aIwhynwwWBQ0ISLY8moT6AskjNHmLQJnBM8vNlo108k\n", + "Epfm41HOyh2amDTjAbhDslyg04UiqYupRZx2xRuUN5TFYkG9XpeIrvV6LVOpSLCwDOBnVa/XJdeZ\n", + "aBDFWhy1xrFwlAZwhBwAubEp2KLV7arjhq/VYqbHjaMJSGK43W5EIhHJkgiHwzCZTPjGN74h9enF\n", + "3ZM7zu3bt6GqKjY2NpDP50VzkEwmpYRgCihJCS4aTdOkkWJYDONgZ7MZ0um0mDkJZ5G9JEphMpmE\n", + "OSNxQmPp/fv3xZ2xXq9x48YNRKNRCcC5mOi0ubkpRAwpd2Ljq9VK4nsJ9/GGDQaDcjLYbLZLUtn1\n", + "eo1sNivGBZZZvGlJhtAl73K5kEqlJCeaTCgD2JmncZXrWi1mBqMAkJ2XGC79f4xvtVgs+N3f/V2B\n", + "kJj03m635QN++vQpPB4PCoWCDNCJx+Oi8wUg5ljuRjy2qVVg88UZH9xtdV1Ht9uV3Zy1K28KwzAQ\n", + "CoXEo8jFdnh4iNlshkqlIrssiZdCoSCxsfQAMqSRr+0iEUNJZqPREP0IP5/1ei11fyQSwXq9Rj6f\n", + "lxiGxWKBs7Mz0bgUCgUMh0OZgtvpdFCr1SRdaTAY4PDwUDLw1uu1jMAgucTv7nWva7WYCa15vV6Z\n", + "trpardDv99Hr9UThRYeyrut48uSJNCrValUWf7PZRLPZxGw2kwR6jnoYDAbo9XpYLpeo1+sAzskF\n", + "SkSn06mI+pfLpUw25fxpjmTg8E2KcihCYrYFQ2lqtZrMHWQUVj6fF3qe8BthOr/fj1wuh7OzMwlS\n", + "BCAWrVAohHw+j+l0KtoKDjSi2Ii1M8Nu2CMQmuTi43QpPn6tVsNyuZSkfAY8kjKnhIAacc7q5glz\n", + "letaQXPdblfS4Cm8Zy1IZRe9emyCqEzjF7VcLsV8ydkhTNFknUn5JuEx4tLMkqOAnmqzP/uzP8PN\n", + "mzelsWLcLlP4J5OJ1M2cbUIEoFQqSbJ8Pp/H7u6uRBWUy2WZoMoTwul04vj4WGxZxKQNw5BTh8J9\n", + "yl1nsxnG4zEajQba7bYYU3O5HOLxuDB4RGAYS0AGks0x7VakwGnv4vAhOsGp075oAm40Gm8H9Fy8\n", + "7Ha7hB/evHlTglISiYTMKSFExQ79wYMHmE6nuHPnDlRVRTwex+c//3nRC6uqir29Pezt7QGAfDHE\n", + "bGlz4iTXyWSC0WiEW7duodVqST1rtVpl8DyDwWmMJYvGkoei/kAgAIvFIlG9X/jCF7BYLGCz2ZBM\n", + "JhGNRuUGZRA5bf0mk0kEV3zf8Xhc3Dcsjbxer9TWZA8pZHrnnXdgGIY0nDS87u3t4b333pMmc2Nj\n", + "A5qmSTOqqqrAmbxBORErlUqJu50eRTa2b0NgLlysvxKJBE5OTmTHYbCKy+WSBU+56Icffgiv1yu5\n", + "cqenpzg7O4PX65XdsVwuo1arCRFis9nQaDQAQPDqSqUi6fbBYBCFQkG0FFy49NNxNPB8PkcoFBJI\n", + "ajQaYWdnR2r/fr8vtDRwznD6/X5ks1lBFKivGI/H6Ha70HUd9+7dk3hceh8pSqJovt1ui/aZ5leq\n", + "DBl8Q6wdOO8NOCelXC6jWCzKjcjPhG4ap9OJs7Mz0XirqiqnHxvG6XSKTCYjoiuGU17lulaLmePO\n", + "Dg4OsLe3JzYdMmfPnz+XcJf1ei3/jyHYtFwxmJBA/0UJI3FVAGK9Z/RUv9+XnYbjwjweDw4ODkRj\n", + "bbVacXZ2Jk1krVZDPB4XAdDx8bFkTlD0RAd1rVZDrVYT10w+nxcUxul0yjFPkQ+H3qxWKxwdHaFc\n", + "LsuUVe7qjNsi9HcxXIZzDKlb4XzCyWQiZYnFYpGsDeZSc1GrqoqXL1/KaVKtVqWUWa1WaDQaKBQK\n", + "6Pf7Qt1f5bpWNTMpW5vNhrOzM3H9khb+hV/4BYlYJcZLS5PH40EqlQIAHB8fCxXLY5Y1bjQaFa0D\n", + "m0IaTZkFx+aGOuV3331XBkl2u11sb2/j8PAQuVwOd+7cwcuXL5HNZmXeB61KzOoggcFRxXTChMNh\n", + "afhY5wYCAaG7Cf01m03cunULjUYDDocDW1tbElAzmUxw8+ZNsWVRQ71YLJDJZGTMMo2zJFrcbjf8\n", + "fr8I6ymBJc7MyNxMJiM3GrFlirRYc1NPAwB/9Vd/9drf/7VazPyCAAjiQG0EXdDUKjCSi116r9eD\n", + "z+dDvV4XbJQNJZVkw+EQw+FQxjSwSSQZ0m63ZSYg0/UXiwUqlYpkdZByp0KPdXQ+n5dxCkRKKDxi\n", + "gmir1RIyp9VqyQChVqslC4mjH6jKG41GKBaL2NzchMlkEhKl0+lcYuqoFmw0GjLtlWo2lhsUDjmd\n", + "TgkPJyZP0wPnCc5mM9RqNcGsq9Wq3FgARB8D/Dg1dDweX+n7v1ZlhtfrhWEYQooAELaOXTU/dMJJ\n", + "jL/iImcsFus6Cvu5g9AadHHsA1N66ARhtgSz6OiqoG6CyAfrRJpSiX+T4CEdTe8c/YgApAShPprJ\n", + "QbwBer2ePD4TUCnx5ONejOHt9/uXyin2Fsy5YF0MnDe5xNEpKeX4NFL7JF2YcsoShcmjfr9fSCc2\n", + "o2/p7AtXPp+HYRhyxIbDYclEowCJaAfhNuDH0tH5fI5kMimIw/b2tjRQ1WpVspNp8eGRzClPZPIo\n", + "pGfKZrVaRb1eFwz64OBA0BRS5P1+H3a7Haenp1Izq6oqxANd1s+fP8fBwYEsZir5eJOs12vs7+9L\n", + "xCxxY07d0jQNtVpNfH4sWS6eIEQtyPA1m03k83kEg0H0+31sbGxIVDB9hKTMSbxwI6CICoCI+Dud\n", + "jkSSES8fDoc4Pj6+0vd/rcqMbDYr0FupVMJisZAoAArKWZtNp1Msl0upNznfw2KxoFwuY3t7G51O\n", + "RwgPzgcMh8Oye3NqKScmud1u+X0KkkwmEx48eIBcLifYbzabxYsXLwBAdtubN28CgCzKg4MDaJqG\n", + "O3fuoNlsSt4xg84phmKaEWFETdPwxS9+EScnJ3LDWiwWiT5YLpdIpVKXBksyTejGjRuo1WryfiqV\n", + "CrLZLBqNhhA0LpdLCCHe9BsbG5LrQadMLpeTGz6RSFyaheLz+YTc4qajKApu376N73znO6/9/V+r\n", + "xUzT6Gg0ws2bN2W4JDFYhh4Sp2Xjx1RNqti+/OUvXzK1MvqKRyqd2Ryyzi+R5lLGupJkGQwGUrcz\n", + "RsDtdiOVSkmjBUAyLKxWK+7fvy8qQE5TpaieTpLVaoVUKiUjlEmH53I50SdPJhMZLq+qKmKxmCQW\n", + "UU3H8oE0Nhc4zar0U7KeZ+NnGAa8Xu8llpGqxI2NDQlUZNnH98cJASR8SPaQCn/d61otZgBCXfPD\n", + "yufzuHHjBp49ewafzyeeO2ZA5PN53L17FwBwdHQkKZxMQcpkMhiNRkilUmg2mzJplWMOMpmMDLBk\n", + "TobX6xUfXjQaxenpqZAZlFFWq1WxQtXrdWEuB4OBjJKgXgM437HL5bLkJNfrdRH3cN4IAJlv4vF4\n", + "RILZ7/elxqcvkjoNUtMUP7GM0jQNP/jBD3Dz5k2h6UOhEEqlkuiiOV6OJxFnZTscDpRKJdGxkLpn\n", + "w8dm9y/+4i+QSqWENudp9brXtVrMgUBARPjEkblTkDHL5/PQNE0cIz6fTySWsVgMzWYTiURCnNjR\n", + "aFQICtLTi8UCkUhE/IYWiwVbW1vi8ubgRu7ioVBIbiSOLPP7/UKnMwaBijcOn+eQyovyUWK2Ozs7\n", + "siBjsRhevnwpJ8Lt27elAWM5Qe9iLBZDLpdDOp0WMoXZdgyUofz0/v37MJlMQjYtl0sJPGezerG8\n", + "YcgM2VE2pZTjEl+m129zcxM2m02mxfKEet3rWjWAF8MJg8Gg1GSr1QrxeFx2QNbJDBnkbBIuPIac\n", + "0BVBOxFNmOPxWBIvKbfkUKCLORdMMGKICwdk0p1MfBqANKZer1coeEJfxKuj0SgcDofMGnG73dLA\n", + "+f1+gREZpEisG8ClkW7vvfeeCPndbre4wTVNExSDNwazLjRNw8bGBnw+H9555x3E43FprAlRMp/D\n", + "brcLle9yubC9vS2oEV//bDZDNpuVuYOBQEAkAa97XavFzN0DOC832u227GzEoLloGa/V6XRk5t1s\n", + "NsNsNkMul5Nalzg05/Qx8YcKL5IEq9VKfk7pJ5NDya5R08Fxv/TDkV2j+P1iMpGiKKJEs9lsooku\n", + "lUrC2AEQGahhGPL3uTPSB0mamTsrcI7NE1lgiUMTA3PnWPJwnBtDXwhB8vMDICZfMpcOh0PKHAbM\n", + "DIdDzGYzOX14IrBUet3rWpUZDodDZjAXCgUEAgGpTUmdcmcFIEQE4SjivdVqFTdu3JB8t9FohFAo\n", + "JNQrmbbj42PJVpvP53jx4oWMLeOIhWw2i48//hg3b97EaDSSDp8RBxxaTxMudRgWiwW5XE6cJnQ1\n", + "Ewmg/467f7ValezmRqMBn88nQ4esViseP34s4qOLcQesV5kNQudJOBzGixcvcOvWLamz1+s1KpUK\n", + "7ty5AwAy4o2qOo4/I4O5s7ODDz/8UNAMEiiDwQA+nw8nJycolUrisKGc9nWva7UzD4dDxGIxgaIo\n", + "0Kf+wul0iheQx6/H4xHBeSwWE3WXw+GQbAqyeszgIImQyWQkItbhcGBjYwN2ux2JREIym8fjMdLp\n", + "tAyOZCNmt9vFrGqz2SRgnHnRrNdJPCiKIuTH9va2zMter9cSCAlAAiOpAGQCPnsIlgekqvk50Huo\n", + "KMqlYHMK+4mY+Hw+wYqZthoIBLBYLC7NDySUmclkLvUlpOhJbxN14ed8letaLWZqhRl8clFj7HA4\n", + "EA6HcffuXdnpvv71r+PFixfSXPEL59/d3t6WCazPnz+XLGLOiWbKPFVnHLfQ7/dlpAIDwxlGbjKZ\n", + "EAgEkEgkhJpm+cPRYiyLdF0XmSjpcvrx3n33XcnQcLlciEQi2NnZkRqa7B6jCbi4xuMxVFUVCnw0\n", + "GmFzc1OylcnIseS66CKnu4YL+otf/KIYIO7evQvDMGSHppyVtLzD4UAsFhMaezAYIJlMCmxK7+RV\n", + "rmu3mDksnblubMbIVp2cnAiM9Du/8zvSsTscDmn0qG57+vSpTIn67Gc/i/V6Da/XK8J0UuZU1tG5\n", + "zLwJDuBhPgZdK4qiIJ/PS6O2Wq1E6EQNM4MMiaIwXouumMePH0sJslgsUC6XxWHOHDdGDnBUMmN2\n", + "6dEjRX94eCi0PN04F6WbDIqs1WoSx2u32/Hw4UOEw2EJnAQgWpXxeCz5cV6vF/P5HNVqVXZ9pqrS\n", + "dMu5Kle5rtVipsKMNSE7eLJq/X5ffsaGZ7VaSQI+pZsAhOigOu3p06eCKFD1xWGYTqdThEntdhvD\n", + "4RAAZNwC8V2GwLAhm81mWCwWwpaxGaVnzjAMcWdQ4wD8WFA1n89xcnIionqO/3358qUM4Wk0GjCb\n", + "zQiHw7BardIQE5HhTTedTmVoD08aNop8LjZ1HBwfi8Uk3ovzCAHIeGbe5LRWsV6v1WoSKcxcDeqk\n", + "r3Jdq8V8MZ3T6/XKFKaLugVCciaTSUYHZ7NZ6eAJ7VFZxgRQ1qs0krL+pD7jYs4Gm0WWOBe1yYw6\n", + "YEnD2SuEyWaz2aVwFr/fL4IiLmafzyejzliLspxhOj5PJeBcGnt8fHxJa8zyhK+dsb4U2XMsBgNi\n", + "FosFksmk4MK0hlE2qqqqSAYURREFIeE6mlXJ9nHYJwDs7OzITn6V61otZkJoJpMJ3/3ud8X/RmF7\n", + "r9fD2dkZcrkcDMPAxx9/LJFcFOZTCMTjtlQqoVqtinlTURQR2p+enkodPRqN0Gw2pVkiccPxxWxu\n", + "CHfVajVxKr98+VLeQygUEsr78PBQhj5SvEP9NTMwLBYLFosFjo6OJAjxyZMnUtPzPft8PokzsNvt\n", + "Yv7t9XrY399HvV5HLpeTkcI0InCQka7rODg4EPaQPj6iHMys43tyOp1y+i0WCxQKBei6jlarhXw+\n", + "LyeRYRg4OjpCs9mUPLvXva5VpO03vvENAOeoxmKxQCqVwmg0QiAQkKHrmqbJh2i1WtHv9xGJROTI\n", + "j8ViqFQqCAQCqNVqSCQSaLfbCIVCcLlcODk5kbhYHsG6rl9iz+je0HVdEoiAH4fQsAHlbl+r1aAo\n", + "CrxeLwqFAnZ3d6EoClqtlkTvskzhjMLxeIzbt2+jUqkgmUyiWCxKvkWv1xOpJYfqkATh+7fZbPB6\n", + "vYKIUIP86rNEIBDAeDyWnZgpTqxrecoBEKkrB3ayvGDqkdvtliE89EISdalWqxJa0+v1rjTT5Frt\n", + "zMWIwIUAACAASURBVPzwmB3MLx+AfGDMauNR+vDhQ/T7fYTDYezs7GA6nUrGM0dGUNbInZb1KGWb\n", + "TqcT0WhUnq9cLssOyFnWTBulmIfDNRmUyAZsY2MDg8EAlUoF3W5XalFOUiXURl1Fs9lEqVRCo9FA\n", + "JpMR5u0nU/CZMLS1tSV2L6IZFBCREOFjhEIhSUelk5uqP5p5+dlQn00Eh8pCjm5jCcXanL0MCSwO\n", + "PbrKda0WM+flLZdLsSExSYhlgt/vRzKZlKC+nZ0d+XtMsOe8kHg8LtJLkh1utxuZTEbqTSIjpVJJ\n", + "glWYt8bSgNroiwlErG25Q1HYTgUelWqcnzKbzVCv1wWTdblcCIVCoi3e29sTXyEDYJgdnUwmJeiG\n", + "C8nv9yMej0NRFESjUamhfT4fotGowHfUlXC8BCdUcb4KNSCksdmfMPOagemhUAiBQAAAZEIAMWcA\n", + "gthc5bpWDCDLi9FohCdPniCVSiH3ag51pVKRBUlqmV8KVW8cTs6gFHb6xKnr9TpWqxVOT09hMplk\n", + "5APrbe7ezNIg2cGGidOr6LrodDqIxWKCgrAWpdSUuzjw41xohh/+ZC5boVAQtIV5eazN2+02dnZ2\n", + "UC6Xpf5l0OJyucSzZ89EZcfdlKpC4LwMInxIlKfT6eDo6Ag+nw+NRkPCKjkOIp/P4zOf+Yy42uv1\n", + "upyGVPNRW16pVMTCdpXrWu3MTqcT8XgcgUBA7niyetytaGciAXDjxg2MRiPcv38fiqLA7XZjc3NT\n", + "sGoGJJJ4YNYzmUZKNPln1tAckh4IBODz+SS3gySJw+GQNNJqtQqv1yu6aVqskskkFosFEokEotEo\n", + "7t69KzQ2d0/CgNRHc+fmc1MvQgMqJ7/y7xK9GY/HsFgsYp5lWTKZTATF4HvkwCOyp7RjMcaLMxXp\n", + "qzQMA4qiIJVK4ebNmwiHw6LRps0rFApdOdHoWjWAX//612V+HTHe4XAoi6zT6UiUQCQSkWiqvb09\n", + "1Go1mXGiqqrY+y8SFVxsbOyIWTN+gKybqqoCyVFcREvRYDCQnTeTyUiSEgNROGbhohEAgGRyAJCd\n", + "0zAMaQY5NJMQGLXDtExxRATHyZGJYyQYE/07nY5kWVA3wosZ1tvb26L7oD2MiUoM2Dk8PJSGk0QL\n", + "4Tev14tWq4V4PI6PP/4Y8XhcXN/f+ta33s40Ac4bQCIFAKRBymQyUmb4/X7k83mZiVcqlcTQWiqV\n", + "EA6H8cknn+DGjRsoFotSa2cyGSiKgv39faTTaQDnx+/t27dxenoq5AZhOWZZ+Hw+CQgkKbO1tYVW\n", + "qyWlAC1QnU5HRDt0ceTzefj9fvR6PXGJ0LKfyWTk98vlMhwOhwiRaFz1+/1CdDBat1gsyk5JzyLt\n", + "WERyVFXFyckJdnZ2pNZutVoCUzJsZz6fS7AkMX6WKCx5Op2OSGbZfHP8BU/K4XCIv/3bv73S93+t\n", + "yox33nlHpJN0h4zHY/j9foGsCoUCer0ebDYb0uk0bt26JfFRzH4gW8WOu9Vqwel0Qtd1Cd02m83i\n", + "FOEX7HA4sLe3h0wmI/44nnyRSETkqUyMZ0onSRiOEKMYirU6GTaeDBw5RnsTUzQzmYzQ0ER06Ptj\n", + "1pvZbJbH4/Pruo7T01OEQiE0Gg0RVHHXZ7QBm1SKmkqlkliuqtUqhsOhmCMo2OJ74aINh8Oiw7bZ\n", + "bIKQ8Ma+ynWtFvNoNILdbsft27eh67qwcMPhEOPxGNvb24hGo8hms/L7T58+leOWOmEmcZIgoAOE\n", + "WDM1vIvFQgaqr1Yr9Ho9Yc04IZZ5yPP5HLFYDGazGVtbW0ilUqhWq3A4HJLyQ2EP6WxqJGazmexy\n", + "zMpgXVutVkWmms/n5fgn0cL4r1AohHQ6DV3XZUfmPwyQ6XQ6yGazItzXdR3j8VgGVM7nc0SjUTQa\n", + "Dek7mPO8sbEhs17G47GMcrtYj5Oh5fPSNEGChWaI172uVZlBRVs+n0ckEkEwGJRwQIvFglarJeId\n", + "BsL4/X4oiiINXzqdFpaNkBaF+0RKmBxKZzUdHABET3FRNRYIBGT4OaOumOcxm83EgkVVWzQalbgv\n", + "wnM0oNIdTSE/cE5X7+3twePxiNE0Go3KDcJkUgASGH4xuszhcAhuTNNsPB7H9vY2FEUR7yFPvAcP\n", + "HiCfzws+bLPZRDDFBZpOpyVEh2OMiV+rqioumKOjI5mJ8tZpcuHiLLrBYIBEIiGEAcNRqBpjorvd\n", + "bsfe3p4sFsZ70d3N0b4cEQGcL9ZEIiGa4VQqJdpn6ik2Nzehqira7baEG3JSLMkFm80m7g9KUFVV\n", + "lUDGdDqNjY0NjMdjaJom6UO1Wk2GaVJcRLZuPB5L4A2tVByswxKHo9CIaVOboaoqRqMRNE0T/Jnl\n", + "xI0bNyTqS1VViXFwOBzi2GE+CWtzNqScB1Ov10WZyJtmPp8jm83C5XIhHA7LHO/Xva7Vzsxhj5qm\n", + "SaPW6/XEDa2qKnK5nEBrxDt7vR7u3bsnCjRFUfDkyRMoioJisSiDdZj1fHp6eilln/kUvV5P/j99\n", + "dX6/H/v7+/D5fMjlcgLV8Yter9c4ODiQm4KZ0C9fvpR6neo1UsqcPciprjabTY7y1Wol+dOcsnV2\n", + "doYHDx5IrV8qleByuUTUVCgUYDKZkE6nRS7rcrlQLpehqqroNfx+PwqFguiQL0Z8UYlHRSFRDWpX\n", + "FEURBKZcLosYi/R4PB6/smruWkFz3/rWt8QFTbiL+RX0nGmahmaziXA4LEA9gX6OSqP4vN1uIxqN\n", + "otvtioictTHtV/T/EaMmKzgejy/Nhma9SHiK0BTDvinKobOExA71HhwqxKaJ8B0AoYh5IwMQRo+D\n", + "KtPptLB1hmHI9FWOgCAuzc/m/2fvTWIjTdMzsScYjGDs+75zX5JVWdndVdXVDbUgoaUWIMD2QbB9\n", + "MDAwfPPBgiEImjnqMjB8kQUddDIaAx0MDGBpZB1aLVVD6pbVKk11rZlkMrnFvm+MIIOMYGw+sJ6n\n", + "gpZkA0nMtETUDzQ6i5kMBuP//u973+d9Fopt+/2+DBOtVqvkaGyKWdOz5LJYLHC5XHjx4gVWVlYU\n", + "mtTtdtFsNnVCVatVxGIxHBwciLvt8/nw27/9219xMwAo8anb7SoMnuy3RTvWwWCg3D1292z25vM5\n", + "jEajUA2WKhSeLvoQkzBDtl2/30e32xW7jg9Et9tFvV4Xx5pQFxtDAKrHFw1VCGfRQ48sOJqJ03OZ\n", + "OyJPB4bVk5dC+ii1jFSvUE3CYB3ymLvdrnBu/u6cYM7nc8TjcSlISB0tFAryZl5aWpJXHh1Tyf/m\n", + "58TPjIkGvH8PuR5VmcH8PRqJs2FhhgdZYAyeoXjVYrFgPp+jUqnAbrfj+PhYjSJwN13joq/X6+L/\n", + "slHkhOvq6koEnXK5rHQnBkESCru5uZHzktVqVWaJ2+1Gs9kUt5lWYTRx5OIhlEfiExvMRqOBJ0+e\n", + "4OTkRLs/3z+xbFJj2fhS7sXFvyhwYIlGSI+BQp988sk9X7nFPER6WxPbbrVaeP/99+FyuTQQms/n\n", + "sFqtqFQqMmpcWlr6ajEvXtT8+Xw+PH/+XJozjk37/b4ytdfW1mRgyDhhGhXm83nFJdAEnMd6KBRC\n", + "uVyW2XYoFFLOx3Q6lT6QtNJUKiWnHrPZrOO01WrJ5Pvk5EQDCL/fL7NCngCMKO73+9jY2MDl5SXy\n", + "+TxWV1e1E/d6PU3m6KBEeufFxQW++c1vqoyhRjKXyyko02AwCJEYDAYapWezWbkmVSoVGI1G+ekF\n", + "AgGMRiMpdmiQw5OBGDRtvlKpFLLZrJxO+/0+vF6v3J9yudyD7v+jKjOq1ap25EQiIaql2WyW0plj\n", + "3eFwiFgsJk0eFRtLS0vY3d2VDu/y8hLj8VhwV6FQ0FjZaDQqKm19fV0DjpubG43D6VZP7JY3mgwx\n", + "xjqQgEPOBkWp1CNeX1/j3XfflQMpANXtVG3kcjk9SFdXV0ilUmK9MQAoEAig1Wqh1WpJSsWfSTst\n", + "p9OJTqej7JHz83OsrKyIXcif53A4pG+Mx+MajcdiMXQ6HfHAiYTQ0YibBi3PMpkMEokEvv71rz/o\n", + "/j+qnZlukjQxJG7sdDrRbDYRCASwtLQkM+2vf/3r+L3f+z1873vfQ7/f140ol8uS0FNizykaSUP5\n", + "fB7xeByJROIeMZ5DlWAwKDUGH6ZKpQIA4gHT0jYYDMpmgLU7c1BWV1fRbDZFZN/b25NaejabSVlN\n", + "3jWZd6SbMkKZSQDME+dYvFqtIhKJSKS6uroqeiktgClrItxJJCIajaJSqWhgwkGIwWDAzs6OamHW\n", + "/SzFrFarBjqJRAIGgwEul+vBCa2PajFzxEvcM5FI4ODgQAhHtVpFIpGQWvmv//qvcXFxoQV0e3ur\n", + "3WM+n+OnP/0p1tfXtZsAdwuxUCiIRHR+fq5FzmleKpVS7shkMpFsi7vxaDQSsYcppcxFYYxEsVgU\n", + "ZmuxWPRQnZ2dod/va6o3GAyEP7Nc4I5Nf2oy05hJmM/nRS6irGtlZUU0VJKhWq0WvF6v8hHfeOMN\n", + "jEYjpNNpnJ6e4ujoCH6/X0Y6FxcX0lMeHx9rgbMBzGazWF1dRbVaVT/A/gbAgx2NHlWZ4Xa7EQgE\n", + "7imfGQlGEj1r0EQigZubGzx79kxNT7fbRTweV5fPiRv9nUnhpIcdWWNckGTXkWhEwxia0jDPLxQK\n", + "yRaBDkQczpAjQggNuPPQoxuR0+nE+vq6kBgS6jOZjDzq7HY77Ha7FjEpoNQ0kqq5vLyMZDKpBpY+\n", + "HlarVTAdhaypVEqec8+fP4fdbleNHQ6HMRwOJd/qdDry0qPRIjNlaJDDptTj8Sj+Ymtr60H3/1Et\n", + "5larJaiMHyitZ6m8praOuwCJ4TQ+zGaz99AQBlAyzIfjYZLyLy8vUSqVhBww+4OjZO5ANzc3aDQa\n", + "Sjbl2NhoNKq2pvi2XC7j/Pz8nkh2Mpng6OgIo9EI5XJZkn2qoOlHxwg1ohHX19figFBGRYiNjSQN\n", + "ZgaDgWLTFk84+tqRA12r1XQ63dzcKFGKjfJ0OkW321XaADeTfr8v1hwbZnqL3N7e4qc//emD7v+j\n", + "KjOoPWMEwng8VvY0rVdpMUA+MY1ZKFUymUzI5/OiQTKhlAMCaveY/+f1etUI0nSQuyfVF5ubm+Jl\n", + "cNTLJCzu2g6HQ1Fku7u7SKfTODs7Uz27tLSEJ0+eyDO63+8jGo1KEU03ImZ4MzWAUjCeFJRD8YRg\n", + "zHEkEpG7Pl2NAoGAfEKAuxOCJwdfkyHwlHuxTn/y5Il6Ao76Kczl570IGXo8Huzv7+PHP/7xa9//\n", + "R7Uzc9pGT2AAWFtbg8fjkT6PcBERD5YfVBVbLBY8ffpU3nHtdhvxeFxTMgo7eYTTrd7hcEhEy12d\n", + "/A36qBEXpoKbRCP6UrCpy2azaDabKl+i0SgcDodISdPpFHt7e+Is076WCpJWqyW5FnV4tOWiiyjp\n", + "q6PRSPKli4sLNceTyQTRaFTWvNPpFKurq8LAl5aWZDlG/2W/3w+XywWTySTlDADxOOh5R19nTkBD\n", + "oZAcjh5yParFTMcdyp3MZjNqtZoMSrrdriTxjUYDn3/+uaZ9i9a35D189NFHikVg3Tyfz/UAMAeQ\n", + "WHa73ZYBOTkf3InYWLHM4f/oRkRVNHdS2oItLS3p4by4uJAq/Pj4WOWRy+XS1I6EKe5+zEAslUqa\n", + "kLInWFSqMHyHsCLLBv6OzDShjIyjfzbOzWYTJycnmprm83n5i9Btlb8bdZS8Z/V6HdfX11+5gC5e\n", + "HMlS2UAVBg2z6dc8n8+xvr6ORqOBjz/+WDesXq/fI/CQSUbrVyYnEbdttVqCxFiDz+dznJ2dKU11\n", + "eXlZN5mqEu5YbC65yMm9uL29lTEKPZhLpZJsb0ejEarVKgDcy22h1xxr0o8++gjZbFZlwnw+R61W\n", + "k2av0+losPLixYt7UivgrqzodrsSLZDeenJycm+BM6+EZQNJ+q1WS/ZjRGpqtRqazabIXzS0oRPr\n", + "Q65HtZiZn0FF9Xw+1wIlr4KKB8qQ1tbWMBgMxNug1eyibJ6dPxdRoVDQkUj4jP5qREuoEuGxCkD2\n", + "WmSmkQtxe3t7L/GVpwPN0AEoQ7vb7crl/vLyEs1mU80nQ4goHiDxiTtot9vVJJFHPrPF6RNCxTkb\n", + "aUKXbK5Zo3Msv7KyIq4I7c4MBoM+Dy5QnobcTMhbuby8xNramsI4H3I9qgbQ7/dLjUweMXVxhI48\n", + "Ho9y8DweD3Z2dhRvRhGq1+tFMBhEOBzG6empMkuYyrq8vCz4y+12C9q7uLhANBrF5eUlMpmM7KYy\n", + "X8QQEwlwOp3ySaZ6gw9SMpmU+/ze3h4ODw8Ri8XQarWwv7+vBNlAIACn04l6vS4FNAlKNpsNLpcL\n", + "kUgEVqsVn332GWKx2L1m1eFwCFKjeJX1Kwc+a2tr4o6k02nZ/NJWN51Oi4uytraGXq+H1dVVQYGt\n", + "VguxWAyJRAKtVgubm5sK2mw0GvjlX/5l/OAHP8B0OsXOzg6cTid+9rOfvfb9f1QU0N/8zd/UsXh8\n", + "fCzSzfb2tthlhJii0aiErbSNslgs6Ha7ODk5wRtvvCH3916vB6fTKUUF4xs4GeQRzOOVmdCLlrcM\n", + "vATumtLDw0OF5JDIw9oagOBE4tRkwIXDYRgMBlSrVQXIE4fmQ8UkVKYGXF1dYX19XTUwgzY3Nzfx\n", + "6tUrAHcPAO26mHf42Wef4c033xTDr1AoyMe52WwikUjA4/Gg2+1qOEKrhOPjYyEs9KxmrszKyopE\n", + "wjSlcTgcKBaL+NM//dOv1NnA3Q3xer2o1+vaBb7xjW8gFouJMONwOMT9/Y3f+A380R/9ETKZjPSD\n", + "dAl1OBz4pV/6JTQaDaTTaVl/XV1dIZPJoFqtSnXSbrdhMBg0uiZhiOUKUQh6ylmtVuzv74tFR7UG\n", + "c0TsdrvKH7fbjUqlIppmJBJBv9/Ht7/9bZVPe3t7aDQaKj04zGFgD2mYVHzf3NzIsZ7QGkk/HH0z\n", + "u48PyHQ6xZMnT5DNZhEKhTAej7G/v696mFNPcrf39/cxmUzkgBoOh+9lKrrdbsnFVlZWpCd8yPWo\n", + "FjO5zIwF3t3dxYsXLwDcBcdUq1WkUikFNf7kJz/BYDBAuVyWf1s8Hhd984MPPkA8Hsfx8TE2NzdF\n", + "MG80GlJG0K6KTpfJZBLxeBxnZ2dihxGB4Eh7Mpng4OBARueVSgWxWEw1LP2Xy+WyXIdYw5+cnGB5\n", + "eRn5fF5EqVKphH6/j62tLdW1FxcXop7Sl5puRByGMJCSRzuFCLTK+uSTT7C+vq6fFw6H0Wq19Bof\n", + "fPCB8kqIQbPefv78Ofb29hQiz82CfBDW+7RmuLq6wqeffvqg+/+oGkBygknYYe3IuAT6FlMpXC6X\n", + "JRh9++234fP50O/3FZHAhi7zRQb1fD6X2xH1fLQIsNlseOedd7CysqLIXr/fj3Q6LX0crQSMRiMy\n", + "mYxsb2liyAxv5gASv6bmkCN2NqSEE5lexXzCWq2GeDwuFUy/31cAJiVP8XhcwfTsNdLptAYpAFTy\n", + "8DObTCYaxbNnYELVovnhZDLB22+/rTSAxRwZpnft7+/DZrPJWNLr9crf+XWvR7WYF6GinZ0dkdnJ\n", + "XlsUktLIm01To9EQPTMYDMLlcmFjYwNerxflclnSIGZkL+r+GEhDp3qGXzLugTtWKBQCAJUBxF23\n", + "t7dxc3Mjh3kA2NzchMlkkscdx9qMKeNr0PJg0Td6e3tbam9yJ7gzDgYDCW/JPQG+FAMzr5ClCNU6\n", + "VKDQyZQIkN/vFxUAgEze2+22ZGNUyVCixaRX4C5dIBqNKhb5IdejWszU9Q2HQ3S7XQCQEw9H0Pl8\n", + "Hs1m8x5mTPiJ/hOExg4PD3UzFj3VOLXjpI96PUr4J5OJyoxFI0TyIsh+I4Zcr9dF9KGmrtFoiFvB\n", + "QQ+taPv9vqBE4tSE9MijJixpNBoVIsQ0WYpKyQOhAIGnGndhui4tfpZseBkeNB6Ppf0zmUxy/a/V\n", + "alrAnMz6/X4hOuRxUK1Dn5KHXI+qZp7NZojFYlhaWhIzK5lMIplMCsyPxWJSiAwGAxQKBZkaUmtH\n", + "VyIqV2hGSF8KAHLuIRY9mUyws7Mjgj8HEIT5iFfzwfB6vYjFYsK+DQYDUqmUSEgXFxfY2NgAADV9\n", + "5CEDwJtvvimVCL9G+RLH6E+fPhVRiKlR0WhUZQgDNjnVo3qbO/Y3vvENmEwmlUp+v19ezIt2B4QJ\n", + "R6MRIpGIpF38nWw2GzqdjhTewWBQJRAN14PBIFZWVvCTn/zkte//o1rMHDRwFEuzlV6vJ+yWH2Sr\n", + "1YLT6VSOc7ValekKhy6cBtIqi1atXPz0U6vVarJ2pUcG3Y2CwaBU3STgU19ITsbFxYVqzmKxiL29\n", + "PUSjUTSbTXQ6HY2cS6WSsPCjoyMkEgkR9fk7U33On0FyUT6fh9vtRi6Xg9lsvmeHxYkhR/acmLKW\n", + "pyNppVJRnc/MbWoAyRFn6USzce7ALENoTMnXpUSLtIKHXI+qzOAO4fP5YLFYxFnmxUWczWYlvmSZ\n", + "QMNvp9OJ4+NjSYAsFosolNw1CS/x6GZQZbvdlvFKuVxGJpPReBmA6k5OIGmE4nA4sLa2hkAggJ2d\n", + "HblvcrLXbDblnETrWtapXDA2mw1ra2twu933vOn4bzY3N3F1dSVCUqVSuccZ4fCkWCzKe4/1Nf07\n", + "GHVBshaNGInBEyun2ICDGrfbjdlsJhnXeDyWEIBTS+BfIDnfYDAkDQbDXxkMhgODwfDCYDD8T198\n", + "3WcwGP7SYDAcGwyGvzAYDJ6F7/k3BoPhxGAwHBkMhl/9p16bdSMXCWMaOE6mm9HGxgbMZjPi8Tia\n", + "zaZU1CsrKygUCjIJNxqN0sExooDUULLhms0mQqGQpnckLXE34nHKhFhi2H6/H4VCQcw1RjkQ8SiX\n", + "y4qYoPKZBJ/JZCLiPyeH3A0HgwEymYyaPyqo6WfBppK+cBxDE6HIZDKSRxEPJkGJ7kqLKawcXZM1\n", + "SPX7YlyF1WrV+yX2TIkaHzqLxSIPwNe9fh5lxhjA/zyfzz81GAwOAB8ZDIa/BPDfA/jL+Xz+vxoM\n", + "ht8B8K8B/GuDwbAH4L8BsAcgDuB9g8GwNZ/P/4Ez9e3tLYLBIFqtlhZbt9tFIpG4F25JP+VOpyNb\n", + "K4L3Ho8Hp6enagRJdKcZIgBZurKB5Gv0+31cXV0hkUiorrTb7SgUCoLBhsOhFl0kEhEPmpO08/Nz\n", + "iU/J3+DAhikAsVhM7krMB6R1gslkQqlUkqSKooJSqYR2u60UAS484M6yy2w2o9FooFwuYzweCyMm\n", + "GkS3fe7MfF+xWAzT6RS5XE7OT2woAQiqm06nsugisnJ6eipP6PF4rGDM173+s+/M8/m8Np/PP/3i\n", + "z1cAXuJukf4XAP7dF//s3wH4r774838J4P+Yz+fj+XyeA3AK4J1/7LUX+QXlclnNVq/XU11IMSVN\n", + "FXmM0juj2WwC+JIMdHNzI8YdvSqYFEXkhMoU7py3t7caFpDHSx+5+XwOp9Op98t/Wy6XNf2bTqf6\n", + "b6YxcYGQj8EdkdRPADqBWNfyAer1enIkqtVqKqn4sNLei/YAJFXd3NyItGSxWGS2SBah2+0W25Bw\n", + "IdESfjbAlwY67F/m87mwa46/6dH8kOvn2gAaDIYMgGcA/h5AeD6fk9BaBxD+4s8xAIsu1CXcLf5/\n", + "cLGLn8/n2NzcxHA4RCqVklKZKVJer1e7IXcLhpmT9UaOMF8zEAjA4XDg7OxMcB71hhyEkKlntVrl\n", + "HXd5eYlvfvObikQAoJExSe7hcFjDA7PZjNXVVSEHPp9PO1skEkEwGES329W4mp4diyVBMBgULk5H\n", + "f1rzUoKVy+WQSCRUgvBUYh08m82wtbUlvjWpqUQdaEVLC2GauZB4tLGxAbvdLqNELnRuBGazGcFg\n", + "EO12W7503/rWt/BXf/VXr72efm4N4Bclxv8J4Dfn8/nl4t/N70ZP/18MqH/079jscSchl8LhcMjQ\n", + "hOR9h8MhMxhmBrbbbfj9foTDYXXwhJNYlgSDQeHJ5DuTgE+iPnP3GNLTbrflSkSXJZqfE9NmZBux\n", + "6FqtphKCBB5yRAiPAVDOISeDoVAIhUJBJQRppDy1eMq4XC7t9AaDQYGgjICgfnE4HEoqRqEAHZWG\n", + "wyFms5lI/Uzgury8VMDRzc0NKpWKsGbGdHD3rtVqmnbSiuF1r5/LYjYYDCbcLeQ/ms/n/+GLL9cN\n", + "BkPki7+PAmh88fUygOTCtye++No/uD7++GP8+Mc/xt///d/j/PxcNSvrvFQqpVByGmm/fPlSdSZz\n", + "TjhsKJfLkuRTjcGdvVarYT6f66FhA+V0OpHJZNDtdpFMJrVIybdgI0hZFXcvLm6n06lcwevra+22\n", + "0+kU+Xwefr9frzebzTRtI/OOMq/FqGGiO1TceL1e6RrJX2b5wBRV2oqxZuaOTliNfBEOZejLwclh\n", + "s9mUH14ymRRzLp/PC4NnQ3h4eIj3338fZ2dnD1pXPw80wwDgfwdwOJ/P/7eFv/q/APyrL/78rwD8\n", + "h4Wv/7cGg8FsMBhWAWwC+I//2Gt/97vfxXe/+1289957WF9fh9ls1iJi88JO2mazyRibPAfu1vRi\n", + "406zmHe9tbWlv6f1AO2uAGiqxbJhEYaLRqMAIJsANmyEqzj2Zh0diUQ0YGF+YK1WE8JC+wE6CwEQ\n", + "8uL1esVUYxwFvfZ4wiya5ZAlxwUKQDAe/ZoXp30MBeLCpIKdOYRut1tYP/+O6AYHKhcXF0in03jj\n", + "jTfwne98B0+fPn3Q2vp51MzfBvDfAfjcYDB88sXX/g2A/wXAvzcYDP8DgByA/xoA5vP5ocFg+PcA\n", + "DgFMAPyP83+ChE2CD8lCzL6LxWI4Pj7WzVp06WT07qIxCy24SL1kWVEqlaRqZijPs2fP5BTE8oaW\n", + "VUajEcFgUDYATLciU44LL5vNIhaLoVgsyqX/9vYWR0dH2rEZJ7G0tAS73Y6joyNsbW3BaDSi3++j\n", + "0WgIFiOB//LyUlyLdrstLnGv1xNJ6fb2Fp1OR/TXUqmkB+Gzzz7D6uoqyuUyms2mpojkbpBkJGAf\n", + "twAAIABJREFUXy6X0Wq1RA01Go3I5XLY2dnRiJoUVZ6CPp9PbMF+v4+VlRV89NFHD1pY/9kX83w+\n", + "/7/xT58I3/0nvuffAvi3/3+vzc6aRnzdblflBN2GLBYL/H6/HOpZNnzxc9DpdODxeKTTMxgMSlIl\n", + "2M9BwKKUyOFwCJpjfVqtVvHkyRMpM2j8wikep2wulwu5XE71Mz3xms2mLGd5qjCmjNNDmpFT3Gq3\n", + "2xWISSOWZrMppTb9NJjbMh6P4XQ6sb29jfPzc/UX19fXSpCiqQ6RGVokMJNwOp2K9ERONi1sGTFM\n", + "l9HFnZxCXkJ9RGNe93pUSpMvMuRgt9txcnIiHJdcB8JmDKW5uLhALpfDG2+8IViMOrV4PI6joyO8\n", + "8cYb8mVjx06Xei5Gj8cjKI35KXTr4QImf6LVakkBs7y8jFQqhVKppHqUjLJ2u63kKdqF0dHIbDbj\n", + "9PRU3iDX19f3FBvMRqGNVy6XwzvvvHNPZZ7NZrGzs4OjoyNJwTKZjFKnaMtFBIh+dhaLBePxGKPR\n", + "CLFYTIgNfTQ4STw4OBAcaLPZcHZ2hlQqJToscxqbzabq7ouLC/z+7//+V2bjACT5pwMPdydip/1+\n", + "X9Mr8mrJfONCDYVCwllJPL+9vdUOmM/ncXFxcU+Kz0aRr8shS7FYxM3NjRYrORg87imGpZXA5eUl\n", + "Tk9PFVlMKI/KZUZEMMlpNpvptQAIxisUCvKKBiAfOT4UXJw8SQjd1Wo1ABDfYjqdypKApCsGeZJF\n", + "yH/Pet5qtUroenV1hYuLC+HHZN1xQ6G9AAn95G+87vWoFrPT6YTT6YTb7QYADS0WrQO4s3HETM4F\n", + "ORaTyQT9fl8LmiJQk8mE29tbPH36VFl2dDsKBALaOROJBCwWi2J6rVYrdnd3MZ1OJUsKhUK4ublB\n", + "sViUupkB7NTVUXVNSyxi4LSoJRLAnZtj7mAwiF/7tV9Tbgo1f4twGxtg4O4B4AApnU4jEAiIuE/H\n", + "VPKSKcliY8vmjs0o4xy4oMPhMJaWlhSLlk6n5S1HPz3SUxfzBV/3elSsOTLM+EFarVa8ePECb7/9\n", + "tuq509NT3N7eIhQKCRajYplw1+3trVwtg8HgPTfNSqWi0oUBkJTtLy0toVQqCYWgK+bh4aF+PgDk\n", + "cjkd6yyLzs7ONP3jjSUXmqPpVqslGI0m3zzaiV3P53P8+Z//uXR9jL148eLFvTSoRYst7qyLHnZv\n", + "vvkmCoUCCoWCnPTtdjtyuZyQELIQ6SGXyWTkMc1BD6eshOqonVxeXsbBwYEyWtrt9r88aO4/5cVd\n", + "mbvd5eWlrJ84cuYY1e12i1REz2LyoGnFCtx14fSlowplNptJ0c1deXl5GePxGLPZTCgIEQ42eTRs\n", + "XPTR6Ha7oqNykdJmy2Kx6Huur6+VOEvaJ49yOp1SGNtsNjXm9ng8aLVaWF1dVRA8ADWCTKdiL8Df\n", + "bdFnhEw4CgQikYiwZdolENlYWlrS5HUx74VOo6Tccgp4fX2NZrMpIfFDrke1mBknzKxqZpBw5yTX\n", + "FgDy+TysViuq1apyOrgQer2ejm3CdoVCAcPhEMfHx3C5XFJqAFB9SmUIxavdbleK7H6/r52Xk0Bq\n", + "5yKRiFQZtBXgzsdGtV6vo1AoKHCI3G1yT25ubnB+fi67A9bUDMM8PT2VmQtrfnIkWOIQ3+bwg2aI\n", + "JFkxqKfX66kWprspkRUOkF69egWTyYRGo6EThaofg8GghpXcED5YD7ke1WJ2OBziBOfzeeGu1AXS\n", + "9GQ0Ggle4k4VDofh8Xi0eMnl4BFLUSZdf0iSYRAjF+vy8jLS6TS8Xi/W1tbkl8yGyWKxiGnGq1qt\n", + "qn5krC8XOuvpRCIBv9+PQCCgkEp6dxDm293dBQDEYjFRTVnDklttNps1+OFAhYobUmG50LhTj8dj\n", + "xGIxTCaTe/0IbcrYQ7BkMxgMgjvj8biExDRD56kyHA7lnE/W4kOuR1UzM7z94uICm5ubiuH1+/2o\n", + "VCqYTqdIpVJoNpuw2+1477338Ad/8Af42te+pskWiTlWqxXvvPMOXr58qeQmkmbi8TgajQYSiYQU\n", + "GJwiUgnOCDHgDk1Ip9Pq3OfzOdLptP4tGyaqyvkQsflivQncuSP1+32Zs7hcLnFN2PRdX1+LTGUy\n", + "mfQg0laWkWxUquzv7wv3ZV633++XPS/9OYLBIM7OzmSzsLu7i7OzM7mL0v3f5XJpgDIajeRnQoUL\n", + "J4hMAbPZbAiFQjg6OnrQ/X9Ui/no6Eg7R7lcxurqKlqtFoxGo3BncpgHgwFOTk6Qy+VQLpfV/Fmt\n", + "VuTzeUQiERwdHaHZbKJer8s7jTed9TBrWDYy7Mi5OzmdTlSrVdWGtCe4vr6Wsz+TSVl78uexdiec\n", + "yAUN3E07vV6vXqPT6eDs7ExpVUQx+v0+2u226m9yt/v9vtQkLKHoukQHVRKhaJyeTqfFua5UKjrp\n", + "Go2GBL38jIvFItbX1++VVxzukILL5pnQX+6rtKkvL2aE0FOYQweaYpfLZfEFvF4v3n//fezv7+P2\n", + "9lYeauTlWq1WHB4eaqoWiURgNBqRSqXQarU0FTMYDHC73VJTkHfALp/iTvJ22RBdXl7q/3u9ntyF\n", + "5vM5otGodtbRaIRgMCgoiwoWckIoOuj3+0IZer2eFmG/39e42mKxqPSgb7PT6ZSZ+WAwuOdtPRwO\n", + "Bc8xQZZU03Q6rfE98CWSxJKMfBKbzSYHVd4jytGKxaI+AzIDH3I9qsVMLHaxM+aImLUa67PF3OdF\n", + "X2fipotWUoxNYBLpdDqVdQEtBBZTT7lAyAF2u91yx2RmCJELvk9GCy+OsTn0WST+cFReq9VU1y7K\n", + "mkjr5DSQfQObWQAKAaIFAut5ci46nY5EBPzdKO8iYYmRGre3tzAYDEry4i7carWUo0jvjX6/j2q1\n", + "Kq9sDrRcLpfEwA+5HtVi5k5jNBrlzENne+KdrHsZWcAPlz4Qi65DjEQYjUbadbl7D4dDRKNRrK6u\n", + "isLJGjcYDAIAXC6X3PLZ0NEAkQ+IyWTC6uqqyoVFqigHDMRrWTIBEDne5/NpQZCFRyd9vj4d+Umm\n", + "L5VKGqhwcETIEcC9FAEmEbDfMBgM8Pl8Ut6QGMXGjzs7SxZyqAkjUg5mNpsRCoXUN9BQ5yHXo6qZ\n", + "uZi4IGgcSEvaXC4nWT4XSTKZRDgcFkIxn88VDE/bK07alpeXxfaiTwSRDx6vS0tLKg04vaMqhLnY\n", + "XNDkKtCrgm5FVH4Ph0NhuhcXF+IQB4NB1ZnkYBPHpcqFtlxkxgF32dSJRAKZL+LNVlZW1Jh1u12k\n", + "02nVwmx6J5OJmkFyukejkax70+m0jCdZKrHBY0m0u7srYQSnhBQMn56eIpFIwOVyYX9/H++///5r\n", + "3/9HtZhJPTQajRpgEB1oNptCMcg5IPYM3CEhxKdbrZaQER6n3DkWw3rICiNaQNnT1dWVOvv19XVp\n", + "9shj5uJvt9vaDdlw3d7eagfjrk5sl2YqwWBQNrvAndHMq1ev4PV6hZ3zQbq8vMTV1ZVQg3K5jHK5\n", + "jGQyqabs1atXKj2m0ykODg6wv7+Pg4MDRb7lcjmpz6mPJFpRqVRkcMOypdFo3HNIpQSt3+/rpGs2\n", + "m2IQjkajB3kzA4+szCAHgEcaR7A0c6Fae7Hmo2cwFRgANDRgKI7b7dbomimwtJOiSpuDDE4OqQFc\n", + "bABJdg+Hw/eO9dPTUxGU6H/MI5tQFk8IIghsasmRJueCVmMUCzCn8OnTp1KbJBIJDUfYfBkMBnQ6\n", + "HR37w+EQ6+vrGu9HIhHRadnAcbHS29lgMIhzzQkpKZ/kX9DHg5g2zdWpmH/Q/X/Qd/8zu+r1um7S\n", + "eDxWZgenfixBaB3LnYSqCY6Db29v5dLT6XQ0bQMgGIvKDzLlaLXFUoKZ2awnCYsNBgMtbKIBDocD\n", + "Nzc393zyKIWiUeHNzQ0SiYRIRyylxuOxHtBOp6Nyh+Y2HHU3Go17sRDMxmYJwnCixei0brcreI/N\n", + "LQDh6dQCknXIXXY+n6NSqYgeQASp0+nIuuHq6upeP8LS7CHXo1rMq6urMuErFAqIx+PodrsSnp6c\n", + "nIjbTGJQuVxWXghDZkjcp2SoWq1KPcJdn6VFMpmEz+cTZk0G3vLyMtrtNpaXl5HL5RAIBDTZy+fz\n", + "+PTTT5XNTZ3g9vY2AEj1QeyXRo/n5+caQ7Np5dSNPnuE5hi9TMrqzc0NyuUyrq6u0Ov1NKjhKdPt\n", + "doWjMw44l8uJy1KpVGA0GlGpVOByudDr9VAsFjV65/dQGADcOTidn58rANTj8SCZTOrnEvPm+2UC\n", + "1etej2oxc7TKLp+7InkGZKPRZoAUS4582ZFPp1PdGIpJyW5j5C7DdBhFRhcfwmFUaJAHzCOYOYAu\n", + "lwsABJ1R8LmIQrBJ5ciaDwqzwC8uLuSBQV4Fa1e+X5ZKixEThCT50LEJpfKaDkcUtVJDSaSHqhmW\n", + "Nnx9qkz4fii4pS/JYpQcSyzu8g6H46uAnsWLDDgGQVqtVni9XuVDUzbFiIXt7W1ZaNEgcTqdYnd3\n", + "V8E+sVgMfr9fUz86hXLxcpchIkFaJRGBTqejE4N1Msn2HFkTuguFQuh0OkJh+CCwObTZbIjH42i3\n", + "21hfX1dYJ5GJ2WymMX4qlZL9F1UxVKYTRuR4+dmzZ/eYbRzFv/nmm8Lb+VBsbGyI+01UwufzSYNI\n", + "jgZPJQYBjUYjJJNJXF9f69Qh1s3f8Tvf+c6DRtqPamfmolg0BqSQlFlzk8kE1WoVKysrEn6SqM/6\n", + "stlsit98dXWFFy9eKEqBtSEneDabDYFAALPZTP4XhNeur6+RTCaRz+dVO3I8TfOWbreLUqkk/JhH\n", + "OC14Wc+zVGJoJadqtVoNw+EQZ2dnsFgs8j4mw67Vasmckbss86zp8FSr1dBqtdRLcLyezWalsnn5\n", + "8iUqlQqKxSLMZrNOJEKItFmgTpInEetwIjzz+VxlBZtdNqIP5TM/qp2ZsiiDwYBf/MVfxGg0QiKR\n", + "0FHMJCUqKRgQ4/F4YDAYUKlUFJHgcrlUUqTTaXX8s9kMfr9fWjpOzajmsFqtOi5p5RWNRqXHI0uN\n", + "zvoAsLGxoVEyd3oAGs1Tlu/3+3F5eSnTF7LOqFlcWlpSnDAALRxKtbjgWq0W4vG40BFCZ3t7e3j5\n", + "8qUQG5PJhPF4rFhgmkuyWSVD8Pb2VsoVDof40DNjnBkqLGkcDge63S663S52d3c1KPrRj3702vf/\n", + "Ue3MrBcHgwFevnyJyWSCfD6P0WikepTYKLm+bI6o1DCZTKjVauLXEmpjmORgMEC1WhWiYDabtdNx\n", + "vMtBhdPpFE+CyhMeszy2iRZwRM66nlg00RQGUXLH5+KgiTdtAhqNhnZrq9WKZDKpo547JbWMRFnI\n", + "ISE+zSB51sr8GSxLuBszEpkedQzbASBn/0gkcs+/j2Lfy8tLOBwORCIRTRNp4fu616NazDabTQuN\n", + "OzQ7fTYtRqNRxoKRSAQABK+xCbJaraovibtypyYXgTwL7kR09+TpQJtaypMACDYbDAZot9sIh8Py\n", + "sSDLjkcw1TKsX/l+2GQFg0HVrnQ74g7KB6RSqcjVkzAka1VafxHLrtVqaLfbSo4yGo3iT3BX5qCE\n", + "ggLCdW63W78r+RbkuBDy5AbCySVxbXKqCZE+5HpUi7larSLzRYrT4kKmTxp3NcafdbtdvHr1SkGY\n", + "9E7j8GE0GiGXy2EwGKBer0sQC9xZBtBFs9frIR6PazzN5i4SiWgMzN2JCEgwGMT5+bkWJjFyRk1k\n", + "s1mNmTkip/v+5eUlarUaKpWKVB5msxnFYhHNZlO7XjKZVK3Oh5hDDQAav3PHBCCjnMlkgu3tbcxm\n", + "M2kBOdanxQKbw3q9Dq/XKzIVJ6GUgBEGZQjSbDZDLpeT+p2G7g+9HtViDgQC6qhp1kc4ik0Vechr\n", + "a2s4Pz/H1772tXvsr8lkgs8//1xYKamSvEksWRa5GYFAAPV6HblcDul0WlAf4S+6edJTw+FwoFKp\n", + "aAE8f/4cgUBAzD4OYDju5u54fX0tOihra5KHbm5uhDPTW/rs7Exyf4fDoV2f5CGy4BahOYpLDQYD\n", + "crmc/KYZFrpYlrEUInYPQPU0m2meCuTD8AFKp9PI5/OiDwD/Ap3z/1Ne9FJm3QxADphsqjqdDvL5\n", + "vIy4Of6lbKfX62lnYQ1Zr9eVyX11dSXjQk7ygC9D3klIInuMN5blB2/YxcWF0I9FY3HW6eQqc2cn\n", + "T5rSp1qtdi8QnsR2q9Uq6iaRgm63K5ISHy6WL6PRSGNq+twxQo2+ILlcThEWy8vLqNVqwuCJSjBo\n", + "h9Af/7w4kaTqnbwWOjU5nU71Ig+5HtViJmC/qAJmDUlkgkaFBoMBmUxGpHpOo+jHTIk/m0Lu8GyK\n", + "6LHhdDrVHFEzR0yaU0KbzaadnMMWppX6/X6EQiFxkFkaud1ukZJo+E1UgtnfixhyPB4XnXPRrXMx\n", + "wJIPCG0S+HsyB8VqtQpa5GJfWVlBJBKBx+NR3AUxavIt+ACSB86SZXHQwywYNpGcUDIGmU6lD7ke\n", + "1WKmspkCVlIeOW1j00YvYxoaTqdTPH36VDtHMpnUrpnP57GxsaE6k8aE5C9w0rWysoJ4PI5Op4O/\n", + "/du/FTmJRB36UbB8oRSfEQtsCvP5vOREvLk+n08PBJOjiCgwB4WMuPF4LOSGxCXuzFyg9EOmap0O\n", + "RDR6pH6PYoWLiwuN+DnoIJHeZDLds9alSxENxPl14uTkr3Dgwt7joQsZeGSLmbASox4YLk43eKo0\n", + "qMW7vLzzOLfZbDg/P4fL5YLP5xNhfz6fIxgMyjKLRy89Meiwz5RShuPs7+9jNBopa4819NbWlhhm\n", + "9OPg0IayKE4lSdjhkUyhbiQSQSaTEb+CqaYUsTJl1mQySenCXXE4HGpX93g8mnKSwcYdk4udu2oo\n", + "FBJGzPqcDDtCkfTvo1BgUYzA7OzFv+dgyeVyweVyqcd5yPWoFjM9KiwWCzY2NhRxwBg1t9uNVCol\n", + "9tnm5qZG4IlEAsAdPvorv/Ir8Pv92NnZQbfblQs8oTzuRExSpWNmIpEQwkHuBx8k4A6r5m5MI3KX\n", + "y4VIJCIvC9bOJN7XajVEo1HM53O88847yOVyKJVKsv5iGP3a2ppKEWoBiWZQwUJLACI1LpdLll92\n", + "u10cZ54w/Mw4rWSDabPZFNlM1Uk6ndbn4nK51PyxtHO5XMLLGbUcj8fRarUQDoeRyWTw1ltvPej+\n", + "P6rFnE6nAUBUSx6pwN1Cr9fr0r2xI6cFVzabRbFYRCgUwocffohGo4FsNotEIiEuM0WiDI+nWTeP\n", + "4mKxqB2zXC4r42QxCIgK5efPn2t3Go1GCIfDuLm5EbRGP7pgMIijoyO0222USqV7tgX8d9fX1ygU\n", + "ChIN0LTl5ORETk7T6RSlUkljeJZHNGphmXN5eYlisQiv14uPP/5YueOkbXLo0m63pWp3Op04OjpS\n", + "6A/jhulD3ev1lAvOCaTH4xGpv9lsot1uI5vNPuj+PypL29/93d+V7dT19bWiFDKZDPL5PCaTCQKB\n", + "gBxA7Xa7FjN1buQ3OJ1ODUwcDgeq1aqaMrphcuJF/jN5yYTlWLMuktSJUDC+12KxoNls6vuvrq7g\n", + "crng8Xhwfn6uOpdoCSeHALC7u6sRPYMvfT4fisWiIorZqLI8WCTIc3hEezK+7tXVFUKhkAzEq9Wq\n", + "6ulF5IM7O8lG1WpVJjaMkgAg03OPx4NoNCrx6mQy0YLmfz/E0vZRcTMod7+9vdWxR8kSieLZbFZm\n", + "KMCdlxwzoEm8r1arcLlcOD09RTQahcPhkGUtE1YdDgdarRYcDoekWOQEA5CZSiwWQzabFSRHXzoA\n", + "GnszNoxDjX6/j1KpJDEo9YSLkWP9fh8vX76Ex+NRucOpIQW7FCYQ/uJAiIQs/v7Ly8vIZrMKJKLt\n", + "FxtYckPoo8e+hIlbJCKtrq7KQ4PZJtPpVBpGk8mEo6MjTQHZILJpbbfbD7r/j2oxc7TK5CKHw4FU\n", + "KiX/s5ubG0SjUUl/kskkPv30UxiNRglPWU7YbDZ84xvfQK/XkxyKI9xAIIBGo4FwOIxIJCJ8lLte\n", + "o9FAJpMRu45UTbpt0lOCdrQ+nw9Wq/Wec3w8HhfXl5Iqejqz/DAYDIIAidDw/dNf2mw2o9PpCKFg\n", + "o0dif6lU0o7LwREhtkwmoxqbdNVer4dUKoVsNov33nsP+XweJpMJOzs7Kh+oyqGo1Wg0IhqNij89\n", + "/yLIMxgM4vj4WPfpK6+5hYv2ADTpo6UtfedOTk7QarVweHgIAPjhD3+IUqkkUhGbuXK5jMlkgr/7\n", + "u7/DYDDAhx9+qAHIaDSSJRUX70cffYTb21s0m02VI8xVaTabcvHhBPLw8BA/+tGPZDrI3YxWs9Pp\n", + "FCcnJ6jVauJg012oXq9jOp0qUctgMKBYLKJSqUiaxJ03l8uhVqvp3zIznM0gd8disags61KphEKh\n", + "gMFggE6noxPi+fPnyGazyOVyqFaruL29xU9+8hMl4h4fH4tfMZvNcHp6KqaiyWTC+fk5Pv30U3FL\n", + "SMI6PT1FuVzG8fHxg4lGj6pm/q3f+i34/X5Uq1UlONVqNaTTaU2zBoMBKpWKSOY8iuPxOA4PDxXs\n", + "SAn/8vIyksmkGklK+GnISNir0+kgFouh2WxqBA7c2R8Ui0XBhoPBAPF4HIVCAdvb27i8vES5XIbJ\n", + "ZMLW1haazaZU4NPpFOHwXbbnYpYKoUVmllCAy1E5f+eXL1+K60FEAYC+32azyfOtVCphd3cX1WpV\n", + "aaxHR0dyZgKg9AE2tPxcV1ZW0Gg0sLm5iUKhoF6DJxjlWFar9Z4SZdHckZHNf/iHf/hVzQxAzDf6\n", + "lq2trSnmloMJCjHPz88RCoXwZ3/2Z/jVX73LliedczQaaVGZTCZ17AT2uUszDy+fz8uHjUMW1pPE\n", + "bkmyp46O2HYkElEA5tnZmWpdlkyFQkF1cbValYkiSyUiHL1eT6NkckKCwSAGgwGurq5E6uGEE4AG\n", + "L9zhT09PtasPh0M10KSA7uzs6OuDwQD9fh8OhwMnJydwOp149eqVyplXr17pdTgm5/Tx5uYG/X4f\n", + "T58+RS6X04T1q5p54VoMs+EukkqlFN3LuAOSyff29nB8fKwaFoD4DCTxl8tlDR/IxWWcmtlsVoNI\n", + "hlgikcB4PL5ndsKMPnpnhEIh8Z/JQEskEiI00V6MMb0Oh0PvmYzAaDQqewNmsTBygegIcEe+mkwm\n", + "8Hg8SnPl7ur1ehWvTHSHo3aiIA6HQykDrOlJed3b25PMazHLcDwe48033xS5iT+XsKjP58PGxoYG\n", + "O8T4H1ozP6rFDEDTs9lsBofDgdwX0b80iInH4+j3+5jNZvjZz36GbDaLjY0NMdDy+bwWzuHhoeTv\n", + "3F1MJpPCeqbTKc7Pz2E0GsW96PV6iEQimhAC0Gic3hKVSgWXl5dSf5MC6XQ61UCdnJwICiS+zZ/Z\n", + "6XSkR2T4TTablVSJC3fR9bTRaAiiI5easioqSBjOyQXOJrHdbovlN5lMkEql0Gg0cHx8LN0im91n\n", + "z55hPp/j5cuXiMViorVeXl6iWq0ilUqJOx0KhdDv9/Hxxx8jk8koIOh1r0e1mI1GI2KxmNhdixke\n", + "oVBIx7DX60U0GkWpVMLq6qqIRgys5Gu53W6B/JQj8Uin0npR7UFbLZKRKEeinIqOlxyVr66uiqcQ\n", + "iUQ0bjYYDNjd3RV5x2azKZ9veXkZq6urKicIjdFtiBNPwnckQFEpHo/Hpf+jqaPf70en00EkEkGt\n", + "VpMsi7tzMpkUhOZwOMRNoR9dOp3W4qRCJRaL4fr6Gi6XC6urq8hmswiHw3A6nQiFQqLUXl5eSgWz\n", + "vb2NH/zgB699/x8VmrG0tKQMkKOjI3Q6HRl8UzTKHYSRaAw05/96vR5evXqlWo+qZ5JyuIB4rNJU\n", + "hhNFst4YbEPftcXwn3g8DqPRiGKxCI/Hg3w+L4I8hxilUgn9fh+5XA7n5+eo1+tSbVgsFiEq5JdQ\n", + "rTEej9FoNDR1Ix86Go3CbDbj+PhYBCrgDs6s1+uaCpICS4HAbDYTmalQKOD29lbTRzLgms2mkgRI\n", + "bT04OBDllcT+eDwuTPzk5ASz2Qyrq6sAvgysf9D9f9jy+ed1UYt3fX2N1dVV1WCcolGhTbmTx+NR\n", + "Ph6VETTwBqDdhznZvJE0bgFwT1VNpKPRaGhX5i5I6RbJ73a7HTabTYmnXEC8oYuOQaRu0g+j2Wwi\n", + "EAiIUM9aepHuSrsrlky5XE7c4m63K4mVzWaTGyizXMj9ps0tveZWV1dRr9c13FmklfLzo0MqR/4c\n", + "cdPgnPwT9gGVSgVms1lj9Ydcj6rMoGKZww1yeVkLkgvB0S5wl/8BQIOLarWKUCgkByPulG63G+Fw\n", + "WIuFlgY8/umSD0BGMhx0UNHByRmhKA41aPfFGpsjdRLx2Rim02lJoviQ8Pgn14L6Pu6Uw+EQwWBQ\n", + "pQ2TV8nko0CBfGpaHTCHBAAGgwG2trZQKBSwuroqMevt7S1cLpdOFH6mJC3RNIecZWLwVMOT1ETF\n", + "SjKZfND9f1Q7Mx2KqtWqMu2IGhiNRh17nELRfRK44w80Gg3tmJ1OR2UJd18ORrjD0MlnOp1qoEHV\n", + "Ch3xeTGfkKUKCfFUx3DHZpQaU2VZOnBnB+5OoFwuh/l8LnOY2WwmxGBRpe7xeNDr9bR4WeeSOVcq\n", + "lSRoAKBShoJU5mMzP2Vxs/D5fIIvuVFwbtHtdlGpVKRdbLVaMkYcDu8yzk0mE8rlskbrvBevez2q\n", + "ndnn86mxuby8RCwWUxd+e3uL09NT0TgZ5P7ZZ58hlUrJ7op149ramkJziAxQ+Q18iVBQBV6r1dBs\n", + "NuH3+xGPx1GtVmEwGLCxsYFyuYx6vQ6LxSICEtl1rFX584PBoFhr3OnoqcG8QJqb1+t1IQX5fB6p\n", + "VOqeOWSz2USxWBTfArg7varVKsLhsCRdlUpF8WmMQ1tdXcXx8bHUJq9evUIymZSggQ9xLBbDYDBA\n", + "LpdDJpNBsViEzWZDqVTSUIhCYpY4fB8vX76UqY3L5cKLFy8edP8f1c5M61faW5FTPJlx/k4sAAAg\n", + "AElEQVRMZA1LRyNaxL777rvqwP1+P+x2O8rlsoSZRAVIKieLjgR07lwsH1ZXV7WjZTIZABCbjGUD\n", + "v4fQG4/i9fV1OJ1ORCIRWCwW9Ho91bGkj8bjceG9NJ6hkU0ymZQZJG3CFqd8FMtmMhmZsNMujG6i\n", + "bBgBaLdedCtiWP1in8FpH+0S3G43LBaLdmtO/KjmpnYxFAohlUqpnOEO/brXo9qZecROJhPs7++j\n", + "Xq9jf39fzkB2u10UxMlkgm9+85v44z/+Y2kBSREF7hZaMpnEaDTCW2+9JfdLq9WKUCgkMhLrXNa2\n", + "5+fnSKVSCIfD6Pf7sFgsiEQi9wwVKRZg7ondbke321XtyiY1nU5LxUHlChEWwnPM7CbLzWazYX19\n", + "HSsrK/D5fIq0oBiWvhf0ox6Px4ItOYnj0GZ3dxfxeBylUkmLlEMVDox6vR78fr8aYp6Oq6urGAwG\n", + "8Hq9uLq6gt/v18Mci8XUuN7e3iIWi8FisWB3dxeffvrp69//hy+hfz4Xa1kAohrSI+Pi4gK1Wg3n\n", + "5+ci2z9//lyj5m63i2KxiE6nI8X28fExjEYjyuWynHqcTqfIPBw9k9JIC9p6vS6XHgAapxM+A4Dz\n", + "83PRK2u1mnZ82hcwJYr/hg8qFzZJ/IPBQO+fTqCkldI3r91uo9frodFooFKpSIFDbjUht4uLC0Ft\n", + "V1dXOD8/v/d7sE4nS/CTTz7ReyP3hb1CPp8Xz3qxhON7orKGvPBarfaVCczixcbH5/NpFEu6ISdX\n", + "4XD4Hjc4FotpzErVBhGBxeAZo9EoV1GLxaJjn/9N+iQlQMwCoSZvUTlNLzuiJGx8zGYz0uk03G63\n", + "ShjyiGns6PP5VNvSkZTHNodCHJ5wlG6327G1tYV0Oo1IJIJwOIxisSjeCrOyV1dXlfcHQNPPdrut\n", + "E2tRyLu5uSmeRyAQuNeIcgEHAgH4fD54vV6dkORsUDLGrBj+jNe9HlWZQSVFpVJBtVrF+vq6uumr\n", + "qyuVF8SiaQ5Oji5z6er1OhKJhAy6yc2gJIhqEDZdHF1zYEFYrVAoIBaLyfuNmC/pkZwu0ouOo2cS\n", + "ibi7UmnSarWwt7eHQqEg4hEZeqVSCclkEgaDQaw40kfL5TJOT08xHo+l2eMDSGcnn8+HbDaL8XiM\n", + "k5MTvPPOOygUCkJV6MvB0HamyTJEk8iR2+3GxcWFNg265g8GAxwcHKgBTqfTODs7k41CMpnERx99\n", + "9KD7/6gooL/zO78jWI27FfOoc7kcRqORSEI2mw3Pnj3D97//fXzrW9+ShJ4RBk6nE0+ePMHZ2Zls\n", + "CxjKHovFZBBD6IuUTw5X2CCSief3+3W0cuelrIjTReBLc0EA8rCgkY3VasX6+rpIU2T4UY3O0oEB\n", + "l5PJBEajEe12W+lQXq9XZUkymcTJyQmi0ahG53x4KJuixzSHJ8fHx1hfX0elUsHbb7+NXC6H6XQK\n", + "v9+PVqslVh7jMGhKTlIRbQfo3lQqlRTddnh4iO9///uvTQF9VGUG67fr62usra0piqHX6wmQNxgM\n", + "ytOgyoFMLgpSDQYDQqGQambuqCwvSqWSeLjn5+cSyC7Gkd3c3AjDvbq6kvdwv98XdjwajcTjpWMm\n", + "LWIZZUFGHSmnvV4PpVIJtVpNUivi2s1mE+FwWDERHF0ToqOdLrH2bDYra1367HG8TSHu/1vtQryc\n", + "TMTl5WWsrKzg6OhIxCI2s4sj6qOjIxk38pTiQ7+ysoJisfhgq4FHVWbQPPD6+hoHBwdIJBKo1+vw\n", + "+/04OjpS5hwAGRNSElWr1TS1YxNERh2nh/V6Xd07A3y4QzLyl75u5GrwlCC1lNavrVZLLvfkRRMT\n", + "ZtRDq9VCqVRCuVzWwuDrcpLGZpQiVT4szWbzni8zldVEM/gadNfncc/TYjQa4fz8XNwJn88nvz6n\n", + "03nPo5kBPp9//jn8fr+UJpubmygWi4LnqJIhYsJm3OPxwO/3Cwp83etRLWbuwHSo5wh6PB6rWeFC\n", + "o7qCC5XCS/pjsEEZjUbK3vN6vUilUjg9PYXH40EgEJDmkHo3m80mToTRaEStVpP5CUe+5F2Qgced\n", + "nObo5C/QJNHhcKDdbuuUCIfDmtrRO45+db1eT+PrdDoNs9mMbDYrbPjdd9/F+fk5HA6H4ERqABnn\n", + "QBuFRVuv8Xh8b+TNMisej8sb2u126zNhMPzGxgZ2dnbw6tUrtFotRCIRWK1WRbiRsOTxeOB2ux90\n", + "/x9VmUFZDj/ITqcjfPj8/FzwWLfbVWhPNBoVrNbv9xEOh/Hy5UtcXV3J8w2AiOs8TjlqJtmHO3O1\n", + "WsVgMEC320WtVlOHTvhuPp8rAIg7IZ30XS6XIDc2gJ1OB5999tk9tTYXD4lALIGoyuZono0Xifjj\n", + "8RjPnz8Xjxm4I0iVy2VFU9TrdTXJlUoF8/kcVqtVA6RmsyknJvpnkGgEQJ95uVzWg/7RRx+hUqkg\n", + "FoshEAig3++rIY9Go/Lrq1QqD7r/j2oxkxzU7Xbl5BMMBmVjRa83RpZReUxPYpLtCbsR5spkMuIf\n", + "mM1muQjR7IU8Az4cnI4xLoKdv9PphMPh0E1mBh5trOjvRi0fvYxZBxM9yOfzikKmYTlH6wzTTKfT\n", + "etjMZrPqd/qDcOqXzWbh8/mk2I7FYkKFEomETGUYJEQdod/v1+fBh4OQIA0TSZGNRqMiJDUaDSV7\n", + "TadTYdc0jXzI9agWM+mcW1tb8hEmVDUYDPC1r31NZic8pjnOpa8zACEEnIrRe9hoNCIcDivAnJa2\n", + "GxsbsqXiA0RxgMfjgcVigdfrFXuPMqR2uy0XT9oDMMC+UCjIPZONFydzW1tbqn25q7KMqdfr2Nra\n", + "Eh2TnIy9vT2N6ykc4GsCd9PTvb09YeWj0UjRwqPR6F5uCYdKfB0AWFtbk5DVZDLB7XbL5ZQnCqmq\n", + "PJW2trawsbEBh8MBv98vL5PXvR5VzcysO0p+6G7EHZvydtZ/l5eXwnkJ29XrddWJ+Xz+3uia+rlF\n", + "IjvDZ2gMfnt7K484LqpKpaKalROvm5sbUSTp2dFut+WuRJ8PMvI42OCkjSbiLKs++eQTpFIpxTgQ\n", + "LaAZziKDcDabyUuDuz+V7FdXV1haWoLf70cul0MkEtHPqNVqwqfJByHMuJj9N51OUSgU9HC3Wi3M\n", + "53MUCgVxRsgt53ubzWZf+TMvXhaLBbPZDC9fvtQRbLFYEI1GEQgE8Omnn8p8hRpBSpr4tUQiIUIS\n", + "j+xIJKKkJ9bS3GGYh8LhBWmSNCSfzWZ6IADIgZ4DBuoHTSYTksmk9IV0z+eDR9NFeiuHw2G43W4k\n", + "Egk4HA5sbGzA5/Nhe3tbEz/W60tLSzg5OUGz2dTQIhgMqo5ftNFiHW6325HJZNRE+3w+rK2tKd6C\n", + "fA6ecicnJ4I8Wf/ToJyGi+RvMz/84uICn332mfzrHlpmPKqdOZ/Pa6RqtVpRr9cRjUa1Mzx58gRO\n", + "p1Mezkxj6vf78pXgjeURzV2YsboANP4m0jAcDhVGwx2LxJ9IJHLPPJz6QafTqe8ht4G7FIWtfr8f\n", + "2WwWwWAQpVIJ4XBYyozr62u43W5RXEnuZwPKARDJ9sCXQgTW+AaDQWNoojwcV/Mzodqb9l4sERbj\n", + "2qhhZIlBfz9OX3lSVKtVqcuXl5cRDocxm30Zk0w/vte9HtVi5oKhkTjN/FZXV1Eul2G1WtFsNgVH\n", + "sd70er149uwZXr58KdB/fX0dzWYTRqMR6XRagwm73a7jsNVqySiQdTUJTWzaOF5frJFpEcZyod1u\n", + "w+PxiPM7mUzw/PlzJVMRGiMyUyqV1GgBEDrD5pYihdlshuPjYxQKBbz77rvS8jEDfD6f4/r6Wr4X\n", + "6+vr8t8gykGEqNVqiStit9v1WdIbJBqNiqhF83JuEIydAO4mnMViUQOW0WiEg4MDxGIxfPjhhw+6\n", + "/49qMdPhx+l0wm63I5FIaCjx7NkzURlJByX0tba2huPjY3g8Hjntt1otyZJYG4fDYZmUM8ODvGnG\n", + "5hLLpvVVuVxWfAJ3P+aGcNcmh2QxsjgUCskB32azodVqyUt6c3PzXrNF9IYqkrfeegtms1nwGVEM\n", + "s9mMt956S3U+g4y+973voVAoKFObdE+a6EynUzWyFosFyWQS9XodwN0JRqdQlmMrKys4Pj7G1dUV\n", + "rFYrvv71r8sqzOVyYX9/X1PWDz/8EJFIBPF4HPF4HB988MFr3/9HVTMTfyUWSrokc+mInxLdILON\n", + "trB09vz4449hsVhk+FKr1WRN2+l0lPZkNpvh8/nUVNESl7EL3KHJS+DxzEVLxQankGwgr66uhF0T\n", + "/242m+h2u0JsWFZwh2UjS79nNoDM8qM0q1wu47PPPtPnsrS0pGhi8jg4dKJVASeG3W4Xw+EQL1++\n", + "FCTJuGKPx4NmsylXqZWVFe3quVxO9rpEV0hA4glWr9e/ihtevKh0Hg6H+OlPfwq73Y4XL17INHE2\n", + "m8lYkd5yFotF2YHM6/v8889V85I1RptZIiVWqxX5fB5PnjyRIzxjxoiKuN1u2O12fPzxx3LppEPR\n", + "4eGhRKZnZ2f34D6OsTnYIbb7ySef4N1330Wv18Ph4SGSySQCgQCurq6Qz+fx3nvvod1u4/nz59jZ\n", + "2VFqVDabxfe+9z3xRcLhMIbDIV69eoV2uy38+sMPP4TNZsPR0RG++c1v4vj4GH6/XxEQzWZTihvC\n", + "iJVKRQgPDWaYTejxeNDtdoX9h8Nh6TP5vSaTCe12W/yOh1yPjjXHXRiAMqvJXOv1egiHw6jX64jF\n", + "Yuh0Ouh2u1hbWxOmyrxpu90uk0LmcpCny1356uoKkUgE2WxWGPXl5SVSqRQqlYqGI5eXl+I0t9tt\n", + "JJNJFAoFlRkAdFPD4bAyRRazr+kJTXU5BaeskYvFouRiXFjT6VSfx2w2g8vlgtvtltiAJZPNZkOl\n", + "UsHm5iZyuZySpchXMZlMKoNIE+BnnEql0Ov1JNalZKzRaAjxIMGIlrxUYwNQ6ef1evH8+XP8yZ/8\n", + "yVfGicDdzhyLxcQ79vv9KJfLamwKhYIyqJ1Op/6bEqfFnJKNjQ188MEH2N3dRa1WQzAYlFrCZrNh\n", + "Mpno39IJkzVuu91WihRxWmLEw+EQ2WxWnGhqDEn7vLq6QrVahdfrFbRFd/2trS3VuicnJ1hfXxcz\n", + "sFqtYmVlRczBRVOaXC6HUCgky1zW2FycZ2dnsNlsImkZDAY5EhEeLBQKcDqdaDQaiMfjwoZZEpH+\n", + "yfKl0WggEAig2+3qtCH8yUHV8vKykCZmiz/kelQ1c6/XQ7Va1Q5BthnwJTeY2jcS2yklMplMMnhh\n", + "zEMqlRKnl69D9hm9l0mnpLg0n89rgEA4ixa19EB2uVxIp9Oy+6L0n+NfIiCMIiMSQOivVqthZ2dH\n", + "jZbRaMTOzg6azaZqdk74AIizQdMZNqF0dGJjNxgMBElyUMNIC/5+JCgBQDgchsPhwPn5ueA1jslN\n", + "JhOKxaL43X6/X4YwLH/o70Fs/qHXo1rMmUwGy8vLYmkxLZXTr1AodG9gQjSA7kCM/2Vo+enpKdLp\n", + "tEjubrcbsVhM3Amfz6chwsXFhVTYdNGkGeHa2hqi0ShSqZTYbMzL8/l8aDabwrj5b6ngpmiU6upg\n", + "MIhnz56hWCyK1G4ymVAqleDxeOR8enFxgXq9rodlZ2dHrLetrS1ZH3CXvr29xdramoj0tNpiAmsw\n", + "GJQYlzIvNrWpVEq8DA5crq6uEAwGtfiZyBUKhcT6m81mSKVScv7f2dl50P1/VIuZux5NANlNc3HR\n", + "gZNQ02w2QzqdxtXVlRACwlNMaO31emLOEa7jzez1esrr4M2hFo/5gMFgUAw2vpfb21sAd2QdSpvI\n", + "cWCX73A4NIl0OBz38qmLxaLyQnw+n6inwWBQ9XQymdQiouMRJ5a0CyiVSoL2KD4lt5nQ32Qy0YNJ\n", + "vJhTPH5m1EmyRr+8vFQf0ul05MtMiJCvSz/mZrOplICHXI+qZqY6+vr6Wjo0OnQOh0OUy2UEAgFc\n", + "Xl7i4uICpVIJlUoFv/7rvy4nokgkgoODAzidTk2sSqUS9vf3NbYNh8NakIT4eIN41FNKxZqTxzj5\n", + "u6VSCTs7O2om7XY7jo+PMZlM0O/3pZ/jcGU0GiEajYq7TFI9AHE06FrPcoW+cHQXomyKg5FIJCL6\n", + "a7lcRjAYVJbi5eUlstks1tbWMB6PUSqVEAgEUKlUtPPzQaOq2+VyadN4+fIlNjY2ZFDJxRsKhYSe\n", + "UDUfj8cxGAxQLBYfdP8f1c5sMBjQ6/Vk4UrWGtXBpF8GAgEsLy/j6dOnwl8jkYgC1kOhEDwej4YA\n", + "NBm0Wq1wu90yM7FarQqcpzzK4/HAbrdjNpuh1WohnU6ryaNXBCPOrFarGjY2THRIojGKy+WScTmd\n", + "96mAJhLldDpVBrGUYQorGXtUwBAloV5wNpshHo/D6/UKxWAtzxLG6/UqLJOjfZYQ/FxYjtzc3Kih\n", + "I3YfjUYVskl6KaPbqGC32+2aaL7u9agW83A4hM/nQyQSwYsXL+D3+8VQIxm90+kgm83C4XDgb//2\n", + "b7G2tgYAcrt3OBw4PT2V3o6xwDy+3W63EA3eVMrlOX202WyIRCLY3t7GZDLB6ekpvF4vrFarFtpw\n", + "OJTHB6VDlEt5vV5xQubzOUajkbJW6BzEUbDNZtPQhGjMwcGBrAgYO7G9vS3s1263w+PxCE2hbwZl\n", + "VQyQZ+PKWIlcLidrXMq7iOrwwSRzMZlM3nNN4jCHLEH63pF6S/+Sh1yPqsxgrBibLh7hVBszg4Mw\n", + "2d7eHprNpiZv4/EYq6urygnxeDxIp9M4PT2F2WxGOBwWLRSAwieLxSJWVlbk/O7xeJDL5eByuVCv\n", + "17G3tyeqJKEvNj0sV4LBoBht8/lcLj9EFubzuRq3tbU1KbS5k29tbcnMkE0rw+MdDsc9ORcX5tbW\n", + "ltTrVqsVTqdTeYBGoxFra2uw2+1CQ4xGIxqNhhbfcDiE3W5XbDDlTwaDAQcHB0IwWFM7nU6p1KlE\n", + "Ae5ONdrfPsTR6FEtZhoLspli/cpxM2VJDNqhHRXLgclkgnK5DKPRiH6/j+vra5RKJZGEuCA5mr25\n", + "ucHh4aFI+4PBQDAVYTnCTvTooPIjGAzKsJD1eqfTEXGn1WqJdUbMl7tZsVgUgy2fz99z6KdNAvCl\n", + "eQvxcA5K6ApKI3FmrbDxJB7OHmQwGEhWxQaOCp75fC7dIHFs4K70YePX6/WwvLys+LhAIKByh54j\n", + "5Eg/5HpUi5m8ZC4ujl45fWOsLlld7XZbsqjl5WVRJefzuWrHcDiM4+Nj2cVubGyoiaMglPgp60cu\n", + "JvKQb25u4PV65dVMvJjcCI6XGUvMEEi6jvJ9LSIrfDASiYTw4WKxiHQ6LVJTvV5XaeFwONDtdvUe\n", + "qL0jOYryLKZi0SmJPnKktjLKmWGda2trqFar6Ha7YtPd3t5FCweDQfE3yAbMZDLKBuT/aJfwlT3X\n", + "wkWXeQDiVVCbRnegVqulepMfMgWgxKVZ21UqFTV4qVRK8BWtuMiqo7pjOp2q0eQpQViQkBwjkamA\n", + "WVlZwcXFhZKq2Pg1Gg15JbPxY71psVgkeuXO2e12kUqltAgrlYqOd6ZLcZhjNpsVXNlqtVCpVMSr\n", + "zmazauD40FGvR5SFjSeRE5qJm81mkZEajYagO74WuRu03QUgMtViJvjrXo9qZx4Oh/D7/crZm81m\n", + "UpKQxEO5FLFTt9stmiUX3dOnT3F9fY1oNCqDGHoa83gkErBYCwJQxl0ikZAcPxKJKCaN/IlEIqFk\n", + "rMWGj9wGu90uojwZdpyYcSJHFp/P5xNBnsHqHITQxoBBlZSOra+vw263IxAIYGVlRRFrpKsyJMhs\n", + "Nktk0Ol0YDAYkEgkcH5+Dp/PJ2ydD3AoFILNZlOqFDkt9AbhVNJkMklIyzjob3/72/iLv/iL177/\n", + "j2pnph8w2WqsNwOBgLi+wWBQ07Tvfve7ir7l4IHZJx6PB++99x5cLpesrkajkfwsyBXm5I7uRExR\n", + "4q5LbjPhNS5QNo/8Ghs0EvSn06lQEQphR6ORIMdf+IVf0EPK9z8ajWSHy1g2ogWsT7lzU/PI8oLU\n", + "TSIqhMrMZjPcbjcGg4GaN6Is6XRaO6vdblcUBnO7w+GwxuGE/Vh+uN1uwXNseB8anfaoFjOtrgDc\n", + "iy6jNcBiYzMej/HDH/5Q6mPgjsHFGIbhcCgCztnZmRomhjbS2KVSqcBgMMhbglwJmnDTrpVxBxTP\n", + "srnkAqKjEZNKWdOXSiW0Wi2RhohsfPzxxxKQcldnZggx5GaziUKhINIRHZco3eIOztqaaEo2m8Vg\n", + "MEC1Wr2XPcihDkuYv/mbv1GZdnh4eM+mlkaLtOfNZrOo1+uy7B0Oh6Kf0t+vUCg86P4/qjJjcaxa\n", + "LBaxvr6Ofr+P+XyOy8tLWVldXFwgmUxKeEpjQTp5LhoQ2mw2IRIrKyu4vr5W112r1bQgiEtTyDqd\n", + "TnFzc4NUKiXLrNFopM6d7LdqtSq3UO7a8/lccQuVSgWJREKEe46HOV2kCqbZbCIWi6FYLIrBBkB0\n", + "S3qAjMdjjZxJuiedkyjQaDRSaZLP56UFtNvtqNVqyjQhOsRSA4CSa9lQs+5nUla73YbBYIDb7db4\n", + "mp/zQ2vmR7Uz86ilRS1ruVQqpbqN7C/mhzCXj3gtJ15utxter1cwUiaTwXg8Fi7r8/kQCoWQyWTg\n", + "cDhkVUXPDPKQOarmgMRoNCpSze/3w+FwiEfB5ClyJbxeL/b29oQ9c5Et5hDu7+/D5/OpPNjd3UUq\n", + "lUIoFJInHEOLCL3Rf49oCq3HMpmMnOydTqcUJJFIREQhBgtx2sqp5fX1tSKPaRlMmRhjLRKJhMoX\n", + "svjY/DFD/CHXo1rM1Lsx05nOmeQXb29vi3Nrt9tVBozHY1EtabMFQMJVugCxWSL/mLsdp2m0q41E\n", + "IvfypFmnk6O8tbUFp9OJ09NTTRQp0VpbW5NwYDweo9PpiMQUDAaRTqclElhdXUWtVpMxY71eR6PR\n", + "EBON1gkmkwnb29siVW1vb8ujeTKZaBzNTBLqCVdXV2VDtr29LaiTA5N4PK54CbqXMn6COzXxe5ZE\n", + "TqcTwWBQ7qbpdFpw5Pr6+oPu/6MqMxiW2Ol0kPsihPHk5ESB5PRxq9frkgWZTCZUq1V15oPBAKen\n", + "pxpeMB7C4/HI7XNpaUmmKH6/H7VaTcy55eVlHZmU3S8mmN7e3qLVauHk5ASbm5uo1+toNptKwWId\n", + "yQDN5eVlUTfPzs7kz0y9nNfrVT37zjvvKGGW7LhyuYxcLodEIoFyuYxkMol8Pi8Vzc3NDQ4ODuBy\n", + "ufDq1SvV/W+//bZMXwjtcfhBfJ0Wv5xSUuFCo51WqyVuM51VKQUjgZ/ezwCUGvu616PamVdWVkQn\n", + "jEQionICdw0hlSg8TjOZDK6vrxUi2Ww2kUqlEAwGhQhQNkS1SK/XQ6vVUkdPcg1wdzO4k5LfzBKB\n", + "msLhcKhygSR3WnsBUOwDJ2x8IJi4ShkX0RI2VA6HQ7Upd06askSjURQKBT2Y0+lUJt8A1JiyPPD7\n", + "/YL9mIO9+HmFQiHFWDAAiI2cyWTCzc0NisWipqQkIbEs4USUjS0X91cTwIWLUBgNRRhDRq0d61iS\n", + "w5lRQl4AVddMJ7VYLLJs5XSLdTBVxZTwW61WjclZkrARSiQS4hgTVVlfX5f7D3HrdDqNYrEopCEU\n", + "CmkX5MJhCi3hLZJ7CInRBiCRSKBYLMJisSgbm/ki5GQT8aH1LQBZc5lMJuzt7amW5yKMx+MaY/Nh\n", + "4ENEPjM9rWlOEwgEUC6XxSkJBoMqlUg28nq9ePr06YOsBh7VYv5/2HuX2MbXNL3voSiRkijeREq8\n", + "6a6Squqc03X6nD59mzFmpoE4i0Hs2SWzCbzILpuBYwdxso8RZJO17VUwNgLYm8DxwHA8iCcz4x50\n", + "t/vUudRNUkmibhTFOylRlERJzKLO72mqPXaAUpzxCP0HDk5dVBTF//f/vvd93ufCbplMJvXy5Uub\n", + "cePkzsCDsW+xWNTZ2Zn929rttq0I4GccHx+rXq9raWnJkB0ZJyhF2D0JvwQCxGLr5z//uZaWlmzO\n", + "PTU1ZV4GJUE0GtX29vYdqwJ2O/gOuBmx60Ki73Q6zsPGJB2oD9ekxcVFM+Cogxk9l8tlN7DhcFhH\n", + "R0c2A4cui/80pUa32/XDDb21UChY8IsYAYiQrJRAIOBhDqgMvG3I+u97PajFfHp6qtnZWTsSgRSM\n", + "jo5qYWFBh4eHd8IooV0Sh4ad69ramh3vGUqgxJ6amtL29rZlVpFIxLXy1NSUkQs69VqtpvX1dXtJ\n", + "gBMHAgHbeDEe7nQ6ppEiAmVogRsR9EwGEghxiVA4Pz83P+Pp06dOV8Xi4NNPP9Xe3p6J9ciYIFJh\n", + "kTA5OakPP/zQKhWULaOjo3r06JG2trbMwVhaWrKPHV597Xbb2TEff/yxXr9+rXK5bG7zxcWFlpaW\n", + "9NOf/tR86sXFRf3BH/zBe9//B1Uzs6OBOLRaLZVKJfV6PW1vb5sMhPdZq9XS1taWpf27u7uSpD/+\n", + "4z82ToxzJ6UIfsaMYEl1Qmp/cHCgbrerVqulYDDoxpK0VY5fkATYdbD9Tk5OtLu7q/39fVvbbm1t\n", + "WQECzZP8FUkOh6QJhSvCgIRxfSAQULFY1M7OjimvIyMjevv2rSYmJmzHcH19rWazaZIQEQ4YhG9s\n", + "bLie5j0DSZ6cnGhvb0/VatWl15dffmnJFYJgfDgoRSKRiH7605/e6/4/qJ0ZoguezKAHNBhjY2Mq\n", + "FosmteDX1mw2XTfSgBHsiC0WTp9MGKGCNhoNhcNhLSwsaGNjww0lk0ZUJ2dnZ+780SDirUHzOdwg\n", + "ofeDyDMcbgl6kkqlnF3SaDQ8XKEePj4+to6R5Few8qOjI0WjUSMmmJEzOOLBweEIo3CIXKhQSMqC\n", + "YDQ9PS1Jd/jW2C6QQ55MJu+ExmP7y7993+tBLWaEmnhNAOgDb7VaLePMlA4ctYyV8UCDAgp1kRKA\n", + "aDByOeBKo6/jRsEoQ8SKjReDG9w+oZlK8k4/MTFhKwQeCMhR0WjU4tTR0VFzrJfUCdUAACAASURB\n", + "VDm+ISNBlOdBokyg/MGPj0ZYeicqODk5MWeEMT28auig8Cn4zHkNXP/hmvR6PWUyGX8eJApAxwXB\n", + "oQnkc3jf60GVGZlMxvG6sMAoO05PT7WxsWGft+3tbXvFQVHsdDreeTiuqYtxkz85OTHcxPes1Wo6\n", + "Pz/3wmFBM8plzM6EkXp8mFyExRXyLnZZID2C2ilX0OXBa2bHZ3cbjg+emJiwPxyhm2DqU1NTHhJB\n", + "faV86Xa7XpA42yMXgzZLM1mv1++M3FutlsbHx1UqlcxFQUYFPl0qlWwOAzx6n+tB7cz1et1sucPD\n", + "Qy0tLdkDbjiJ6vT0VPPz8yoWizo4OND3v/99L/zb21sVi0VTLTEyQdpDycGNh9vcbretwN7f31cw\n", + "GFQkElE4HFaxWFQymdTe3p5mZmZsaQtBCHcjOvxer2fFCLvi5OSk7buoU4djzjCbwcARESuSsGEl\n", + "diKRMDzHsKPf73vsLP2C03Fzc3MncxAnz06no7W1NS9SsHAkVVBZgQbHxsZMCWXTGB0d9YInw/s+\n", + "14NazNAlu92u1tfX1ev1tLq6qoWFBcViMcvfi8WiRkZG9Lu/+7v6+3//73uXAycF3ltZWVGj0VA8\n", + "HtfOzo4//MePH6vVapm/S5NXq9U0NTWlmZkZL3BJHu9+8skn6nQ6ury8NOQlyRYC+H4woKA8gIif\n", + "z+e9ED/++GMnQEFawpeCdFTQGlxM4U4z0WOw9PjxY/Oiz8/PfSI8ffrUwUYMU4AA4U8zoMJ2C1UL\n", + "WDRG64FAwPkmTC3D4bDevn2rlZUVU2V//OMfv/f9f1BlBjtMJBLR9va2ZmZmtLm5qePjY21sbGhk\n", + "ZESbm5va3t7W9fW1/uiP/sh14v7+vvNMGOtubW1pYmJCf/Znf6bFxUUT5iENkWLKtI/FPD09rTdv\n", + "3tjhBzYYabGBQEBv3771BLHT6SibzXohkDFCwhRDj3A4rJOTE83OzupP//RPzQhEywcXmjG8JPtu\n", + "EEwEe29vb88ck6+++sp8aZyggsGgk2CxNsAjhIknuDH2vbjs93o9/Zt/82/8cxAkNDY2pkgkomKx\n", + "qGq1qlKpZBLT+fm56/D3vR7UzsyMH+y4Vqvp6dOnPloZbYML09gtLS1Jkk0Ih9Oger2elpeXjTkj\n", + "0BwfH1c2m3XE7/HxsSdxjUZDS0tLNjan3AGayuVyLn0WFhYsI6JBwsSFeAZ28Ovra62urno6yEgZ\n", + "iA2JF6YqWO9SbszOzhpJYac9OjryuDqdTjsQk1obGBBSFdNBBAYEbi4uLjoACKN3ml+abxIAEomE\n", + "ut2uCoWCSqWSJ7c0ou97Paid+fLyUrVaTb1ezxEPBwcHCgQC5lNQryG5J2CnVqvp7OzMIemYk2M6\n", + "zo4WCAQ8vABL5e/QFmLq3el0dHp6qp2dHd3c3PgoZiFTEoCJYzvAQ4BRODl7wIiVSsViXB4Cfn5I\n", + "7yzm8/NzJzsxqcPc/OjoyLnZ7Nq3t7ceTXe7XXOSydqmB6FnQGxQrVa9WDFlhOvBCcLDzESWr8P2\n", + "lhi3970e1GLmOB0bG1OhUHDcWDgc9i7U7/cdYQABPhQKKZvNWjaFXIkunEBKbk6z2fRNn5iYUK1W\n", + "UzqdNmwGJRJn+5GREbXbbd9UXDCR5+PEyeIHoyU7cHp62hYBiFuRd0E4wkgRUS8TymGBLAaN7XZb\n", + "jx49crJrtVqV9IuHYXt7W5FIRNFo1Lg0wyLp3aS12+2qVCo5fg0SlqQ7uYTwm8fGxhwNEY1GPW1F\n", + "nVKr1e7Fy5AeWJnBTYYsgzUAi3RsbMx8AnDoSqVi5x+OyMXFRScxFQoFx6VhWwD3F0cgTGFSqZTx\n", + "ZSA3BAL4rREkiS6QhRAMBi0m5TRAtwgEB0e43+/ryZMnTkENBAIObOd98vNKsj0tZUAymfT4nWQo\n", + "BkszMzOS5GaRsufjjz/W/v6+x+98lsOEouEyBN3ksL0XpdPExISazabm5uYcAB+NRrW+vq5/9a/+\n", + "1Xvf/we1mEEXkPIwWfre976n3d1d1et1TU9Pe9pUqVTUbDYt/4fv+/nnn2txcdFEI3aQi4sL7e3t\n", + "WdKPi2a9Xr9TMszMzJjsP1zSMG6/vr7W8fGxj140gzxYyPtp7Jg2AsuNjo5qf39fhULBOO/19bVq\n", + "tZpj1hi0oBiJxWKOHx4m+PR6PUej8XMmEgm1221tb29bRf6zn/1MhUJBr1+/1vr6uiPdsDoACWq3\n", + "2xoMBoYhyTSR5CaUevzNmzfG5QOBgF68eHGv+/+gygwWAGJQjm+GA1hHzc7O6vr6WpFIRAsLC3Zt\n", + "LxQK7txnZ2eVzWaNXLBDIt1nPA2XGChqWIEMmsHolmlYOp02rjwxMaHz83ONjIxofn7e2DTMNKZp\n", + "pFCxg09NTfn4xok+n8/bkovmja9H1c176XQ6biCB7Six2FEvLi7cLDNc4nUgOoFQENLJ2D0ej7sE\n", + "gjgFuQnoELMeyFmccO97PajFHIvFDMZzYzEVp6mizMBkEANAXIgYGaMmgXyPSSGdeCQSUTabVSQS\n", + "sUQrkUj4e8RiMXOEUZ9QfpRKJU/POp2OxsfHbUYIY40RPJL9SCTicTwsNth/TPsoldAuwskm6/rm\n", + "5sZ85EePHtnEhihkRAmUOysrKx7F83nwUKPC5qFiwBONRu1Vx4m1srJiO4PBYKC1tTXzzDc2NnR4\n", + "eOh7dp/rQS1mkAlk/DRdgUDAmR/hcNilCB8eDR3TuKOjIzdvyITQ4fX7fR/3dPG4EQ0GAw8ukNUz\n", + "VcRSdmRkxOmr8CDg/WJ9xTHPkby9vW0VNiNjMg+RfGHCSOlCUgB6x0QiYV/ndrutvb09x7PRBGMs\n", + "g1UWE7tisWgkZXgoA/w5HLUBMsTPO6xCWVtbM6OPIRQ7OIOm+1wPajEz8YrFYspkMlpYWLhjUIIO\n", + "7c2bN7bVyufzdg1KpVL+Wiy0YJrhw4aBCsSdR48eqd/vO8R9YWHBLj7hcNjEGsLooZb2+33Nzc0Z\n", + "G5+dnVU+n1cgEDC3hFOARQEDDQOVq6srra6uGiLj/QN7dbtdGxjyUGE1m8lkTCiCGjs5Oem4YiaE\n", + "YOG4f+JeSvPJZwWKg4f1wsKCJicnFY/HXa9XKhUlk0kVCgU/aExVgQrvcz2oBpAOm9BKjj0IPNVq\n", + "VWtra3acbDab+slPfqLf+Z3fMU9CeqfoKBQKNhGkMaLJYmrIrokBzBdffKGlpSUnn0ajUYsCUIfc\n", + "3t56isaUjigGjFjIGWFHYzFeXl4qFos5aw9zSExeGo2GLQnIrIZkRVN8cHCgq6srVSoVvybE/M8/\n", + "/1zRaFSdTkdXV1fa2NjQt771LWPGkJBoImHUYSIDsnJzc6ONjQ19/PHH2tvbs5cIzqWMwMHLCc7c\n", + "2dm51/1/UDtzo9FQNBq9M7qV5GYvkUh4d6NUYGdm52NnhjQz7C8My02SNYB8DcoRGhv8ncFaY7GY\n", + "+dNM2XCyB7KC0QfkBQUU939y/7CmhZ7KbinJQ5B+v+9/gy8Fp8DCwoK1i9Tr2NQOy6emp6fthB+P\n", + "xzU7O2tYE0wb9TXO+5D5sXigtuczYyfu9/sKBoNulDOZzL35zH9hizkQCAQDgcDzQCDwf3zz++lA\n", + "IPAvA4HAZiAQ+D8DgUBi6Gv/+0AgsBUIBN4EAoH/9N/zmncYbfF43PUdgxIUwagmIMeTeVcqlUz6\n", + "QRERiURcdnCzmOpJ73BfdGwwykAFgsGgTwoeDEkWrZKvgjEMjDe0eRjbMGFE+c0pwvFOUzoYDFzz\n", + "N5tNcx5ohuFugPgwyGF6R34J743mF4f9QCDgEwsCP+6e/X7fJ9jMzIw97piK8lkxNCIgk2EQm8/7\n", + "Xn+RZcbvSXolKfrN7/+OpH85GAz+50Ag8N998/u/EwgEPpD0X0j6QFJB0h8GAoH1wWBw+8svyNz/\n", + "+vraw465uTmHwrBbocP7zne+o+PjY+8oIA7r6+taXFxUt9t1HY68H7n/4uKiDg8PjTywUIH2hkk/\n", + "S0tLhukgxvOay8vLikQibigZ/ExMTOjJkyeuddvttubm5jyYoBeA5TczM+Pp4K//+q+r2Wzqhz/8\n", + "oUqlkl8fEtTLly8dAVev1xWNRr2DMkwhygFmnCStrKzo4OBAyWTSKVmkFcDNgMfS6XRMUWVAhDXY\n", + "4uKiarWalSiJREKJREKFQuFeC+ovZDEHAoE5Sb8t6X+U9N9888d/XdJvfvPr/1XSH+ndgv4dSf/b\n", + "YDDoSyoGAoG3kr4n6c+dfbLrFotFFQoFhyh2u12dnJwoGAzq5OREIyMj2tvbsz0U3IJ4PK7NzU1b\n", + "37bbbTvaB4NBJ5XC38AbgjocUhApqwsLC3rx4sUd1yCQgnw+r2q1qsPDQz8c6XTaNer+/v4dU/Ji\n", + "sXgnYSqVSrkhbTQabnh3dnY0Pj6uL774wgQkxu4w/TDJYcAxNTWl5eVlnZycqFwu69NPP7WY4ZfD\n", + "3gnlhFGHri+fz2tra8sELgZT8Xhcx8fHxqNPTk4ccccJEwqF7h0E/xdVZvwvkv5bScO7a2YwGJx8\n", + "8+sTSWho8pIOh77uUO926H/rormCIMQCQNqEjJ5mJJlMWscGPIcHBnUftgKMeamb4SWTz41ekPoY\n", + "ST6RC9TLwGCUB3hGh8Nhzc/PW6pF3jSsNIYb2OaiDcTPjQaNh4VaF4sAJoe4k3L0Q0/FVJFhysTE\n", + "hPkVwHAY12CzMDxm5/OSZOydzPGbmxv3F3zmw+HxvD9KsPe9/n/fmQOBwH8mqTIYDJ4HAoHf+vO+\n", + "ZjAYDAKBwL+P3Prn/h3TulAo5FDFbDbr+DGoiIg78W1molar1dRut50dQjjNRx99pHa77boZwn4o\n", + "FNLr1699XLKrXl1d6dGjRyarszAxER8ZGdGHH35oOKzZbDoEiIkbZcnY2Jg++eQTnZ2dqdVq2bgc\n", + "tQrfA7YaDkZkpoAbgxqA+GCyPjIyopWVFQt/yefGM5nmGI7zN/fHglbKomQyaZsHuBnDAZl4ZpdK\n", + "JQ9zMB4fHR01Ln6f6y+izPg1SX89EAj8tqRxSbFAIPD7kk4CgUB2MBiUA4FAThJxnUeS5of+/dw3\n", + "f/ZvXV988YWB91gspu9973v2NJ6ennYgZavV8gcLPtxsNl2rknrKqHhjY0Orq6t3AiOldwoR6Z2v\n", + "M9M0VNns6MiuSH7FQLBcLltPB6aLMyn+yZI8esepnxwQJoGzs7M6PDz0wARNIEproLP19XXjzMBl\n", + "NKiSnA3Ybrc1MzNjRiAC2WFbA+r9i4sLraysmFZL5gpWva1Wy9NWgjNxPo1EIup2u/qDP/gDR3L8\n", + "pcsBHAwG/8NgMJgfDAbLkn5X0v81GAz+S0n/VNLf+ObL/oak//2bX/9TSb8bCARCgUBgWdKapD/X\n", + "YOG3f/u39ezZM62trZn/S+cOBRJMFix32KkHqVG1WrXUX/oF6Z+Qeeo8vCzm5uYcPD/MVMOU5uTk\n", + "xIMNJndAdvCEGSODIEjvTGGKxaIHGSyKer1uiwCUK6Ojo2bqVSoV+1ygpuZUOTo6Urvd1tHRkbF4\n", + "+gqyTVDc7O7uuvkc9rkmLxHzRR5wBjAnJycW3TYaDdVqNVUqFY/JDw4O/P0eP36sH/zgB/r44481\n", + "Pz+v+1z/MQxNKBn+J0n/OBAI/FeSipL+c0kaDAavAoHAP9Y75ONa0n89+Hfoa6rVqlUW+BOvr69r\n", + "ZGREc3Nzkt5lBQ7nYuN8xL+5vr7WX/2rf9WOoWNjY/ZmhvM8jO3ifwz+G41GzZhDALq6umpeBOlT\n", + "6ALHxsb06aef2pyGvG3qZWpqmlaiIPBQ5vtLMo0T9IQMFkbHy8vL+uijj3R8fKyTkxOl02lJ704x\n", + "9IY0iRMTE/r000/NJ1lfX7dsbG5uzqUTPzfmktls1jwNKANra2va2dkx7rywsKDT01N9+OGH+vGP\n", + "f2x+yO3trf7JP/kn772Q/kIX82Aw+L8l/d/f/Loh6T/5d3zd35X0d//fXo+SIpVKaWtry9RKIDLI\n", + "RLgUgQEXCgVzjs/Oziyy5NhvNBpaXFyU9Av4j3oPDJejFr9jBiF4One73TvJVVjUfvDBB9ra2jLB\n", + "KRaL6fj42Po8nP45NWCtYSADrRO/O7gn6A15n9lsVmdnZ9rY2PDUEAU2jeX8/LyazaaHJeDAQIZo\n", + "9X72s595HI/iJpVK6fr6Fymr19fXymQyVspXq9U7tbn07sRbWVnx2P9XXnNDF5ZXjUZD9Xpd+Xze\n", + "WDCSptHRUdVqNevwcOqBWIQh4dnZ2R19Xz6ft6kL/Irj42MtLS1pc3PTjvLUsQxOarWak6pAF2q1\n", + "mtNih3dCxtE0i2C5mBFC3SQ0XpKnhLVaTdls1sMNdtRhr+RWq6V8Pq+XL19ay9hsNq173N3dNQNw\n", + "fX3dD1Gj0TCKAc7OEIi+4ejoyIgN4e8IEnA9Oj4+dv0fCoW0ubnpxK2pqSltbGzc6/4/qHE2kBML\n", + "SZLhKqxhWbT8Gd369fW1KpWKVlZWrELGlhbeLkEyTMskeVgCfsrNabVa3v1IfaJxBIeFpim9a6ym\n", + "p6ft5wxScHt7q16v598zBgbOg81HhsnU1JTDMMGgqcrgh9DwAqsx+kf6xGcjyc3p2NiY3aJIASAM\n", + "E/UNjS9mjZKcnXJxceFGmM8LBToOUQxZ3vd6UIsZzBJVMHXwcKQXU8CJiQnl83kNBgP/HgJRNBq1\n", + "kSHwHpgsujiCexqNhon25AF2u10tLCzo+vraTR6eyjh2krEC6kBziCxpamrKRCJI/MQwMJ3L5XL+\n", + "3njcoSaHmE89/fbt2ztuTaurq8adZ2ZmjCfjTQ0vnOgKyoNQKKRkMqlMJmMrLiBMuBXBYNC+H/yM\n", + "eO71+33lcjkbmu/v7zvy+S8dzvwf8uLoe/TokXZ3dz2sgHr50UcfmVvMQqUehA/BDkJWB4lK6Ao5\n", + "OiEFnZ+fu65Op9MuN4ikQEzL8Q36US6XVS6X9eTJEw9xoGaWSiV7JrNDYudF7iDuP2DCjLiDwaAN\n", + "x1moR0dH+vVf/3Uf91NTUyqXy8pkMpqamrLi5PHjxyoWi16U6PPGxsYsdkBdTX4gD2omk/HPEIlE\n", + "7jR1o6Oj2tnZUS6X84l2c3Oj9fV1P6jcp/tcD2oxswt2Oh1PskgXhUZJTZpKpXR6emqvDEz8aGJ6\n", + "vZ4bP5ohdHVYFJAKdXZ2pkaj4bixQCCgcrmsZ8+e6eTkRLVaTZFIxFRPLK/y+byPeHKpr6+v7xzB\n", + "ktw4ogVkqHN+fu7d9urqyijKF198ofHxccdgEGjJRA5KKyaKfI9ms2mDxtvbW9XrdROOMK6B6Xd9\n", + "fW0EhFMLnFuSU3Jvbm782SJawIcPshMptn9Zx9n/QS68JGCDochgVNrpdDw1g63GgKFcLlu9LMmE\n", + "fbK3wWKr1ao9iMFx4WRcXl7q8PDQQ5nNzU03jJQRPBjSu4cPfw4eEtyLGJkz8pXkCWWv11Ov1zN+\n", + "jckLdgW4+Pf7fZXLZYfPl8tltdtt48g0j5CwSqWSm8VQKKS9vT0vUpAd2If0J9TmBHIyqaSGHx0d\n", + "tWd1sVg0w25qakrFYtF9y8HBwb1Zcw9qMdOoIF1iAgY1sVqtqlarmUNRLBZtHJPNZh1Kw9exACET\n", + "AV9h3s2xyGtK8s5FibG0tKRKpeKdb9jjmUZwf39fp6en1tSR7AT7jLoXQ0eEAZwO4XBYjUbDtS9E\n", + "I+DCSqVi6y+4JSxMml0e8MFgYI/rdDpt9GR8fFyvX7/2yTHc6LKbk60tyZg0D4Yk5fN5G8+g4Lm+\n", + "vtbW1pYGg8G9yfmB+/p7/cdyBQKBwd/6W3/LcBcmK1NTU8rn89re3nb6KhDT4uKi/sW/+Bf64IMP\n", + "fETiLs+ABMEpMn4GAbgFpVIpCzUlefFls1mjEOyCPBzU54y4u92u6aGSjLB0u1078w8rsHu9nmZn\n", + "Z+0YynhZeuctx/eA4IMOUJKj5c7Pz/X48WM9f/5cCwsLarVanohOTU0plUrZOw94LxwOa29vT/Pz\n", + "86rVavrOd76jg4MDD094DUkO3+E9sMlQFvV6PaVSKQcSZbNZ7ezs6B/8g3+gwWDwXmLAB1UzU0dS\n", + "25JGen197d0NJXM4HNZPfvIT+09QJ6Ktu7q60uvXr5XL5e4ouDmquTHDOxVGiAw1ZmZm7gTWUK+v\n", + "rKzo1atXd6LLRkdHdXp6qkQiYUZeOBxWv993qYFdLH7LS0tL3pXJa0mn0y4ppHcTT5pTHOwh+PNz\n", + "VCoVnZ2d2dsDkhWLmAVIniFmjGQs4oREmREKhRzYSVJXqVRylgvfhxMUaJTm8H2vB1VmQCXEIYc8\n", + "arwpKAtoxgqFgp4+feoINNzt8Y9IpVKmQ+bzeSuncR2CaA/PIh6P2+qViSHHLoR8giYhBA3j3DDq\n", + "JicnbTMG8R/jRpAPfDTw1cDeAAuEfD5vAn4wGLSIlnE7Uz5IT7FYzLAfsij+L71DTWKxmOkAnFjk\n", + "s7DwcW0aHx93VPJw5AbMQGi2qFw4Ue5zPajFDIzEWBpDPsB4dkDwT5ovFhq1JX83Pj5uGAt4D24x\n", + "N4yRMfU2JQNNFjgsN4whAaXJYDCwSJTXxMWfMTwPGLsfv+50OpYcgZkzGCHm7fz83GUN5pAgMPF4\n", + "XOl0WrOzs4YcIWdJMrxHrU0ZMuzzTOkEdIiA+OrqStvb2+Zew0ch/4+HiXr6+vr63r4ZD6rMqFar\n", + "Fna+ePFCq6urVkZUKhUNBgMzyrLZrBUgIBmJREJv3rzRl19+qd/8zd+0kpkdB/IP9loHBweu0VFS\n", + "z8/P+wiHRvry5Uutrq7aVw6HfBYBHhNMLvGq6PV6zg8JBAKeUMJ6IxTz7OxML1++1NOnT1WtVrWx\n", + "saFcLqdGo+Fx9He/+12XLZRF5XJZlUrFKhC+dmpqynazKGSCwaDZe+zoqVTK6BCsw7GxMafFUtqh\n", + "cUQ4gCHlMFJzeXmpP/3TP73X/X9QOzOE71qtpt/4jd9wk5HJZLS8vKz5+XktLCw4n2R9fd2LZ3V1\n", + "1Q3Pr/3ar1kvFwgE9OzZMw8k4FeMjIyYGx2LxZRIJFyyUDJwcxcWFix2xfyQsS4awm63q5WVFe++\n", + "+H+k02nbdi0sLLiBXV1dNRV1fHzcKbCRSERra2t69uyZDWeSyeQdESmZ36izP/vsM4VCIS0vL3t6\n", + "GA6HVSgUbPV1c3NjSy6U2ZwSlEoEuSMmpsYfGxuzmePk5KS51PjTIXxdX1+/1/1/UIuZumtqakrP\n", + "nz93t9/r9eygj4UAuSH7+/v2v7i+fpd/t7+/72O63+/rxYsXHrdCUuc4Zxfudrva3d3V9va2nYko\n", + "GYrFot3lsYPllMDPrd1u6/PPPzc/gl3/8PDQ/s3lcvnOe5qamtLbt289TKlUKup0Oh748GAwkgbx\n", + "AKEAa9/c3FQoFHJ8G+VSs9n0/8GxW62W6vW6tra2XM8jRfviiy9MGsIUcbicwqPj4ODAvBA41ldX\n", + "V7bWfd/rQS1mTMAZSRP+gjKZm/fixQt33YxhqXXJMSGeASXH+vq6RkdHHXbDhA1HI0xMpqenzbTD\n", + "TT+RSNg8EHSiWCx6XBwMBrW+vq5CoaDx8XH/HnbZy5cvzXir1WpaWVmR9G5w8eTJEx/ZcB6IsIBH\n", + "0mq1lMvl7vQM+/v79rogSmJ8fNzxFcOefPQRpGphKonYAUwZvgkPOicM7qlTU1NaXFw0TwbWIpHN\n", + "1Orvez0onPn3fu/3lM1m1Wg0bKGFDIhmj6kXyuGXL1/qu9/9rrnAML6y2ayCwaDi8bj29/eVSCTs\n", + "iTEzM+MdKxKJ2OGn0WioXC7rO9/5jqEtmkn8inu9niE7xursrMVi0bKpfD6vZrPpwcT4+LjlTJIs\n", + "ph02RJekR48eeQeHttlqtbS2tqZqterQTGBIbHNBLeCVrK2tObx9b2/PAl1Jd0QJ8Xj8TlOMAQ99\n", + "CerwUqlkHSbKHjz2EB+fnJzoH/7Df/grnFl6B8Rj6DI6OmquMkOBi4sLVSoVXV1d2dwF8jkZJoyW\n", + "k8mkyuWyHj16pFwu5zF0r9fzWJZUUtTfoVBIhULBhPTb21sT2OEqsDihmGLa0u12vdBisZgjgbHH\n", + "pRTK5XIaGRmxOaQkP0xjY2Pa2dlxTBzvczgDEZ4GFFJOj06n41qW6d75+bk2NjYMqd3e3nqgRK1M\n", + "gxoMBm0GyWeJxxw6wvHxcSd9QZ2FAgvP+z7XgyozUDTTXAD9QBCnXkYrB6Go3++rUqlYaAm8l0gk\n", + "dHZ2ZiiPY5obgHEMSg+GKOx81MKQlKiVaaAIk0SkCm8auBDkBEU4wxygr2g0ekeyhI+HJDsNhcNh\n", + "N4gYGzKs4LMCB0Z9g/8GJQCnDiVHNps1FCfJ8B3qF7IRsRgGlSEujQcBExu41ffNNHlQOzPdM/oz\n", + "4n+BwOD+QpznmIdUxDABKie+w+xawWDQDDgWifSOzsjCQ6UNtkr+nSR7QqPQJpJ3eCBycXHhiSRk\n", + "f45m/i02XKFQSGdnZz6+Dw4OzGADRmSxMHnDu4PanNIJS1sIWaAWCAFo4ubm5kzQh4fNa/E9rq+v\n", + "9ejRIx0eHnpkz3QTigAnZ7lctgUDzfX7Xg9qMRNZxqBi2ELgW9/6lssISXbvubi4cLYJcNWTJ0/s\n", + "0wa0hPE41FH0hkzxMFak7MArAtMWDF8Izzk/P1cmk7FQFp41R7gkE+zBmUElMIohPIf0J4Y/cJQh\n", + "1SM0CIfDWl5e9tCEU2Ztbc1iU+y6mEZSK/OQ7+/v69mzZ2bJkeN3dXWlVCrl4QruqIFAwA0zlNtM\n", + "JqNGo6FkMmlZWzweVyaT0e///u+/9/1/UIt5fHxcf/RHf+SdgiYtl8upVCr561KplDY3N8304liE\n", + "51sqlfThhx8at0W5EolEjAJcXFz4RqCZ29/f19XVlZ48eeJBCjU5Rzz1KiGQjLKpF0Elfvazn+n2\n", + "9tbE/16v52ObcT2j6WGrWTLDYdxRokC7HB0d1fPnzzU6OqqFhQX1ej0dHh5qamrKTenBwYEk6U/+\n", + "5E/0gx/8QMViUbFYTMVi0RRRSqm1tTVtbm6az8Ewh6DON2/e+H0Pm8GjEaOx9AAAIABJREFUECcl\n", + "izyY+1wPajGHw2F9+umnkqT9/X3lcjlH+FIijI6+C1b/9NNPdXh4qF6v52EENTfqEbK4i8WiPvnk\n", + "E11fXzuJ6vLy0vG/sNAI5gmFQjYCDAaDajQavmEMEEqlkkWylAT4shGTDHRFRjVlEWFCt7e3WlhY\n", + "MI2T3BFG52NjY55IPn782Gbei4uLtpLF40LSHfQnnU7r6dOnVsYgJ2OqSMOXz+fVbrdNbY1Go8rl\n", + "csbBnzx5Ikku7dj15+bmLHIgGeu+QfAPqgEsl8sG4NvtttW/OOZj/8RiSqfTbrhIe4J0BCmJ8oDm\n", + "BSQENQj/BpvXk5MTNRoNHR8fq9lsGhqTZG40rkl7e3u2O4DpRrjN0dGRzs7OdHx8rFKpZOwbo3Ho\n", + "p5VKxRERjKlRcnPasDPi7onNAZ8NMil8+n7Zfw81CGN/eBUoyodFBDjg02CD7fd6PeVyOUeo8VAg\n", + "USsUCsbP3/d6UDtzLBazgcrjx49teTU1NaVcLqfj42P/GVTJ2dlZzc/P6/j42LDXs2fPVK1WNTMz\n", + "o8nJSa2srDhhtVAoaHd31xmAwzawNzc3mp+f19XVlU1nzs7O9OGHH9ooER706Oio/fDm5+e9+MB7\n", + "P/vsM52enro5ZKDA4lxcXDRaAc6MgSHSLcSxjN/Hx8f15MkTZ5VEo1ElEgmHvWNsODU1pWQyqU8/\n", + "/VSnp6e2q/3ggw8s9wIbnpiY0OPHj90rMHqXZFbh48eP9ebNG4dwghrlcjk3iVdXV1pYWLjX/X9Q\n", + "ixlrq0QioVKp5KiFfD5vFly5XHbkGTsHtlpnZ2e6ubnRj3/8Y33rW99y140XBrs3MiiI5+zK4+Pj\n", + "trKlbgd7ZVedmJiwXS7/BqfQsbExk3tgvKFsBpID193Z2VE8HjeHGNNEyPws0FAopHQ67UnjxsaG\n", + "jcvJ1YarcXJyckf6BK4NQjJcKyOjokxidD5sc0sZ9ZOf/MQCBfLIm82mNxNgxb29vXvd/wdVZpD4\n", + "SdmAATecY+KFi8Wij2QaL8a54MQ48EMNZSEP482tVsuvD46K5cDZ2Zl97pBnUZOXy2XX76VSyW7+\n", + "TNRg6gFpoUZhAXGEg1+zOHEm2tvbs6PR8fGxnj9/rmaz6TobSwPwZkl3yqJarWYjckSzfGa8Bgy8\n", + "wWBgmdmwRS/4+sHBgYW7ePbh88dDge8civP3vR7UYgZu6na7XqTIh4CvWHwTExN2pZTe5W1gVM6R\n", + "SeeOjSzjbuRNNzc3hvWwo8IwkdEv+Sa8FgMG6lQaJ/Bd/p5pIwR2VM9o9fh9t9s1J4PviVsoPwdN\n", + "MAMe6Z2YltMFQe74+Lj51ihv0OqBNTMlROaFVW4wGLQotVarmaeBcJWfgYeU04cTcnZ2VvelVjyo\n", + "xcwVDAa1vLzsIxuMNBqNan5+XolEQhcXF/rBD35g0L5arToMZ3l5WZOTk1pdXbUyYnd31/q5+fl5\n", + "m5vgEQdRplgsuhwAviPgkqHBsJ0AsQg3NzdWVMMVpoaFBD8sB4MkBD85Eono8PDQY/GrqytlMhml\n", + "02nrBkdHRz00IZwoGAzahJEHj1JmeXnZpCDYfcMBltTt+DWTghuPx+12RLYgp2QikdDs7KzLQWIz\n", + "xsfHf0XOH76AeJD/4OmAqzvZeq1WyzxjuvxGo+ExLYgGGR4498AMw1YA8hGCzX6/rw8++ECRSMSO\n", + "P9PT08Z4G42GE5Y4MZB6Db5JumL8zi5IWUFyKxNN3gMcYXY3CEQ8PCxEBkgoxzudjndwYtqYgiIN\n", + "y+VyTg0AMcHIhmEIERMTExOeeGK3xZifBAISAcbGxiz1QvnCoOde9///o3X0H8XFBwdJBnlRs9n0\n", + "MckY++bmRm/evDFSQOglu1YikdBPf/pThUIhdbtdR5/RjK2srFgIcHNz45p4bm5OoVBIW1tbxnFR\n", + "WDB5gwAFU4/3x8PCIAZ+Nb9Gzzc5OWmHfwSleOUhcZJkGwBI/MFg0DZbfC6UEWDYjMnJScHyi4XN\n", + "w5tOp/Xll18afYFIBOF+b2/P3Be8q1HehEIhxx8TYTEyMqLl5eV73f8HtZhpKIC/kEQRkUsULoR8\n", + "hghgwSw4GrJhuRA7LyNxFhnecoPBQMVi0c0Nejtiz1BR09TRLKLxY1QOoR2CDzZdkPrxjCuVSob4\n", + "8NAALtzc3HR9jvMpNTLvqdFoSJIV7NI7E539/X1HOfT7fRspDlspDGsMKX8wlESHyImGPGs4l4XJ\n", + "ZKVS8ci+0+loa2vrXvf/QZUZ7DRM1MCG4/G4Op2OPzRQBTRs2AOcnZ157I1C5erqSktLS2o2m961\n", + "EYOen59rd3fXgllkVLjgD0f1Yn5CREI8HjdPpNfr6e3bt0omk05xrdfrxmmZstVqNaXTadXrdYXD\n", + "YXU6HfvrIdXCaCabzRodwN0JXLjT6ejRo0cKh8M2aeH0mJubU71e19LSkmOHpXcLHY8QCEtIyaDX\n", + "YhozOTnpQKPhQVE4HNbBwYEfPKaUvBaU1ve9HhQ5/2//7b9tE0BgNpwrhxUoxA4fHBzo6OhIH3/8\n", + "sQF91MZ4NeOPHA6HLTfiuIYlBs46Pz9vUxOk+pCKbm5u3CTmcjmVy2XzKOBo4JzPgwOpabjuTyQS\n", + "HsljoojhOIT4arWqqakps/p2d3f1rW99y6cA/GfKGfyq4TpDA221WndqaWrtRqOhVCqlsbExG7lQ\n", + "KpBwi9KdySBIzXATGolEVC6XXcIUi0X9o3/0j35Fzpd+kZQKCb9QKOj169f66KOPdHR05A+YkoIj\n", + "+vDw0IaLpVLJE7z9/X1ze6EukmmXz+e1s7PjmjUQCOjVq1caHR3V/Py8tre3TX9kFI3ItVKpWKOH\n", + "O1KlUjGnmZwTckRCoZDK5bINWCQZV6aUgNfADkzONrsmKpiVlRV9/fXXzvUmIqL4TcYgDSS2Yclk\n", + "Uq9fv9bl5aVPqNHRUX311VdaWlry5sH7hCW4u7vrhpoyazhVFjEDJdvs7KxLn/e9HtRipsumEWFh\n", + "0T0DO0myjAlGHKPfhYUFvXnzxrBSOBx2OUANyKKEbgkMxTQPuf6wGgMOMv8el1Iu5PnDptx4SoC4\n", + "5HI5fy+I/DwAkrzQh/8MNTe/ppfgfcPbgPuNcBc2HwaInEiSHF3MAmV83u12NTMzY9gvmUyagssO\n", + "De+70+l4uMQD/Jc2O/s/xMXkid2KxYeJCqaEQG+4V4bD4TvHH+76sVjMyIj0iywU0AteH8MW5Eaj\n", + "o6Mm+1BqYHGFcADlBgMTMFeIOPF43AMVoC3MbQiFpCSoVqu2t6L0IOUV4lK73VYkErEPxu3trfkg\n", + "gUBAR0dHDrVkiMLPy4ibngFv5larZS43AxbEsbwOny0lCra7YMq9Xs96wPvuzA9qMe/t7dnkcHNz\n", + "U5VKxSUFknZgqJGREdXrdauxSRUdGRlRIBDwv+t0OkqlUoaSJBlSqlar7uLh5lYqFW1tbdmNk1oX\n", + "ByJqaRCPq6sr7e7uqt1uW+18fX2tvb09HR4eOvEKXBgDGqBHPI1BZo6Pj/XixQtVKhVP5N6+favx\n", + "8XEz3GC3EbFMs4k2sdfreZrKZwcfZXt725O7eDyuvb09NZtN1Wq1O2XeMCWAzwlC0eHhoX9ebL2C\n", + "waBr/Pe9HlSZMTwho7lCH5dKpRzzQPc+MTGhly9f6pNPPvGCxrQ7k8no6OjIaU/hcFiJREJbW1u+\n", + "KdPT0x48gPXCJgPRYKiA38Xo6KinYcBSkjxgAPdNpVKq1+s2rMGAEKXK3t6ek6WwTYjH41a+MJYm\n", + "LTUcDvsYj8fjOjk5sSkkk8TR0VEnP0nya8K4I59bkss50m4RCtDoSvLnv7y8rE6n44EKYuDZ2VkP\n", + "fXiv97ke1M48Pj5un+VIJGLTQxx5jo6ObG5IVBqxwEj+b25uXFfncjlP0jhyce1BG4gtF8c2Rze1\n", + "5vz8vKFCxtnUrTDjSqWSDcYh6qAdZPLG8CYYDNriQJK97vg54UxQ06LwiEQiOjs7UyQSUSAQ0PT0\n", + "tJl2PCDSu9qdBxSXfQhJ8XjccCF1NbtwvV53WYVYFU8Oml1KsNvbWy0vL/uERIh73xiIB7WYLy4u\n", + "LF0iVbRcLqvb7drWFVVErVZTLBYzk+7k5MTG3NVqVVdXV84ShCtMSCVCTsbYku6w6SYnJx1ttrW1\n", + "ZfhN0h2MGF0hN71eryuZTEqS3Y8Ir4fM1O12bWiDEBTK5eeff24PakmexjGoAUuvVCqmWxKPMezz\n", + "DFR4enqqUCikZrMpSQ7WxAcDQhG5MMCQt7e32tracp2NrS5ErvPzc7169coPCyP7QqFwr/v/oHDm\n", + "v/k3/6b9LSYnJ+11vLS0pGq1atEmVEQojESCkVaFofjr16/16aefegoGXgonAaMVjARZtMj2W62W\n", + "ZmdnFYvFvAuyWIgwi0QiHm0z6ctms1aiSPJkjaYVPkUmk/EQY39/326k4ONMMG9ubuw7jUcIA5xK\n", + "peLSAtRmdHTUwZhg5kBoEJYuLi5MKOKziEajHgZtbm4qlUrZZqDdbmt2dtYNOCUIFINEIqFyuay/\n", + "9/f+3nvjzA9qZ6ZZIw4XDsBwOurNzY3H04yHaYBAAMhEIX+DoHWon5hu85rDQZVIpBDSBoNB77KI\n", + "XBlWkHjFAwVPuF6v69WrVz4xkGNhDTA7O6tKpWJZE5gzxPmzszPvqrw/rGYpFchqGRsb83u/vb3V\n", + "4eGhkRGaulqtZvydMT4kfCIyIBIhNID/wqQUpyRQCx4APq+rq6tf8ZmHLxTZuOdDjEGRgcyJ3Qby\n", + "0OjoqL3dIpGIXYkIkCfeiykXHNzhXZlG6fr62goN0ILhmpUSCBgREj2LnFOFDBXYf5Cc+v2+9vf3\n", + "NTs761OEKSW2VzSsCFWLxaJOTk78M1C+9Pt98zCGLQYkGXmBT4JBzPX1tWKxmBYWFty0MjBhx2+1\n", + "WnY0pQGm9JmYmLDpSzgc1tu3b9XpdMwVv8/1oNCMTCZjUj2NHBMxEkZRUXS7XaVSKYenN5tNLS8v\n", + "q9Vqmby/t7enxcVFRydMTk56tA2vIZvN3jFVgRXGAgZDjsfjPimgg05MTNx5ULCNpYxgVxsZGXFp\n", + "0+v1lEwmPXCZn5932QRj8MmTJ0Y0UJ/DEUkmk3r79q0fZBCUpaWlO7pBFtbs7KyazaYJVUCf7LoM\n", + "XvCPnp2ddXgRmwrWuVAF1tfXfVp+9tlnOjo68s91n+tB7czDlq/Yxe7u7jqS6+XLl+YrDwYDY8Ow\n", + "w6rVqiYnJ/X8+XPvcBzJkH8YVvT7fUNyHM+lUkntdtsunxMTE34vBwcH2t/fN+cXQtPV1ZVH2dgc\n", + "4Ex0fHysRqOho6MjW9sy+Hj16pXZcjSvTD1PTk7sqk85sbu76+YWyRK8FeRNaCgrlYqCwaDevn2r\n", + "s7MzZ6CAwQ+jQyhfGKcT6fb1118rEokYb2YMTloW+styuWxt4K9yAH/pIjt7GCojOJI/I4SSpgdI\n", + "CIQBaQ8JSXTqGGzf3t7ao46bgyLl6OjIY2vk9LD0JicnPR0LBAKuw/H0GPa/oJwJBAKuMylVGGqA\n", + "BtB8RiKROxM5xviSjF/jDEpwEfVxIpHw2Bk8m4cRghA2BmDplENMERnHU/dL8oAF/D8cDruZJYy+\n", + "2+3ag+Q+14NazMSJQUHEBhZ39unpae9sKDaIGh4fH9fs7KxrQnBbeA0sOoz/CN6h+clms5qamtL8\n", + "/LxisZjy+bxHyywscFmINpCUksmkuRt8fTQaVaFQsO0WC3xsbEzhcFjz8/Oul9kt8aKmHia+AsXJ\n", + "zMyMm8KZmRkvUFANkgfAiYfH15QwsAQxv2FQg9Ib7jThQNFo1PcGrnQ2m7XmL5FIKBgMql6v6/Ly\n", + "8l73/0Et5tPTU01OTt4xGMRwm6gCjmJUH+zA0i/Sqqh/WRRYyFILD4P9vB5BOZJct0tyXUrdiJE3\n", + "O7kkZ1oz7GCSxi5HLcsDQSmBAyiNGpNHYEkmcwgU2OkZkPD+JHlHl+TPhZ9XkhOvKGcY4HDKwEXh\n", + "52YXxraLyGIEwfwawS4ozX2uB9UA9no9k4kqlYpD0IkvYLGR2wwufHx8rEQi4SMPrLrZbLo0YKer\n", + "1WqWWqGiGCYjATVdX197zAwP5Pr62to4BjeRSETVatXmiVggMBW8uLjQ0tKS5V63t7fmg/T7fW1v\n", + "b3uHhf9MbY1O8PT0VIVCQRcX72IxGNUDPYJdk9gaCoX8ELNoQXIw0ME7D3gNTSO52PQEIDCcmBin\n", + "Q7DCHAdnpvtcD2oxLy8vGzNGcZxMJq1CPjw81OPHj5VKpdTv9zU3N6dXr15pfn7ecBFyJYSfhULB\n", + "Zts8LGNjY44qGxsbs3QIgSrdPHUxnAjqRY7ieDzu6Ao0dHjWjY+P6/DwUOl02lTSwWCgQqFgk5dE\n", + "IqGlpSXn+EnSwsKCNjc3lc/n7VIkyelXDMkogchDZKJJ/mA0GtXs7Kyte1lok5OTVphjMcBGAIQI\n", + "1RZsGzuvTCbjUT5+GwiJf0U0+qXr4ODApUWxWLTioVKpaHt7W4uLi25MksmkSqWSTk5OdHx87NIh\n", + "FAqpVCrd8U0jtw6SfCKR0Pb2tjqdjhKJhBs3Fj2aw2w2q2Qyqc8//1zZbFYHBwd30qVglDWbTU1P\n", + "T1shgh4OTjUG6ATb4LbPrthoNDwlRHaFSoSQeDDg4bhfGkkGOIVC4Y5K5+XLl1ag9Pt9RSIR7ezs\n", + "aG5uTo1GQ6urq66nKUGgcw7bKVSrVYVCIW1sbCiRSHikT5gSGPe//tf/+l73/0Et5mg0asd7TALZ\n", + "fZDhU16Ew2FFIhF7UCB5v7r6ReZ2qVTS3NycO/FoNKpHjx4Zw6aRHBsbU6PRMCowNTWlZrNpf2Ka\n", + "QqZ0CFmHE5dwM6Khy+fzrpsZceP5wQ47MzPj0+Lt27cmWUny4uOBZleUZK+L4QwSGs12u22fan5m\n", + "6V0/Uq1WvbiB59LptLrdrrLZrPsSppAkyaKuSaVSxt6Pjo4c0cY9+uSTT/TFF1+89/1/UA1gv9/X\n", + "zMyMlcXkgQwntwJnsQgjkYgbJoSXLGgoiuwkHJGQe7gJ0WjUQw4W88rKitlmOAdJMkmIGpQpXyAQ\n", + "0MzMjGKxmBlmDC5WVlaMqkBmIu0qlUopmUwqHo9rdnbWdl1YEpyfn5vrfHt7a3Ny6KcMlnhIoMwS\n", + "Jg/n4vb2Vul02uw5lC70EjyYpBA8fvzYmYeUQMOREisrK5qenvZgh//f53pQizkYDKpYLKpUKhnR\n", + "OD4+NuQDrjucEzIctINjD5gsJBweBIB+OBksymKxeMfSCkrk4eGhPZ7xVy6Xy7a8BceGhbe3t6dS\n", + "qeTG7fr6Wrlczuw/lDFo7oLBoBs8QnaGs/6gXvb7fR0cHBiRqVQqNrVhTI16He83vj/fo1aruYGr\n", + "1+tqNBoO70FMgA0X0cvYDjBBxRZ4bm7O77vVajmo577Q3IMqM9LptJlaFxfvUptyuZzH18SmgTBk\n", + "MhmVSqU71rTIq4aTVcfHx12KMHWjhOl2uyoUCo5JA6dOJpP2W0NIy0JbWFhwqYO5YiKRcCNZq9WU\n", + "SCQsDqBUGQ7xkeSaE/gNm16a0lQqpYuLC83NzalQKNitlAdkuCxghx7edVFk39zcaGVlRZ1OR/Pz\n", + "85JkhiENHgYygUDA42/qYh7m4XqdfgC52PDw6n2vB7UzQ9phuifJNShDABowPmiySKBBMsxgp8ag\n", + "pVQqmYIJXgu2C8wE8RybW2AvKJPgymQSgt1KMlEfNhlKFSaScDTAxYEGsYOdnJzU/v6+J5X8/DSM\n", + "cJLB1xl0BINB02IhYPEz8JnwEEgyR5mwTH4GRueXl5f2qoNiixSMB3PYRBGN5rAS5n2vB7WYkd5L\n", + "UqlUUr1eNxmcupfGplKp3HEMRV3MqJdjEItZoDMUI1dXV1pcXDQzj10WMjujbB6gYRUy+X/Fb7JC\n", + "ms2md2Wmfdvb22o0GpY04X9MzQuMeHx87IWJoSELCV7F6empVlZW/q0dm4eKRc1uC5TGAuckOjw8\n", + "NP7c7/c1Ozvrmh9DRAZOu7u7pnpS+8/PzztCgxOC0yYQCCiXy93r/j+oxQwVkqgzpk2gAF988YVV\n", + "JNTHWMjCRYabwDQMiI0F2Ww2Xe/y9fv7+3fGxzhlBoNBUzkvLy8t12fwMqzJA6GAqD83N+fdn4YT\n", + "2T7Iy9jYmNbX1z1KluRAePLBcd7/+uuvbZEF/DY6Oqpqteoe4c2bN6a3UiqNjIwol8tpYmJCT58+\n", + "teSMh5zT6M2bN45shlkIJRZBL1NIsPiXL19qa2tLvV7PlmX3uR5UzVwqlUzfpB5EECpJ3/72t5VM\n", + "Jp1wFI1GzX9eWVmx+SHcCthmHPk4XTLsuLi4UDabdX0IFfL8/FxLS0va39/3eykUCg5oJ0Ma/jFl\n", + "DST9er2uo6MjPX36VF999ZUNBcHJQQzYAaemprS0tGTTcYhOWM7WajXNzc2Z34GKPZlMKpfL2csC\n", + "gxxcP7HYYlIJ+sFGgLi13W7rt37rt1yCDAYDPX782J55w9mI2Dc0m039xm/8hv75P//nSqfTymQy\n", + "2tnZudf9f1CLGQfNy8tL7e7uan193aNWVAy9Xs8y+WKxKElOlBoMBspkMnrz5o1dkRYWFiy5oo5k\n", + "LHx5ealms+malPqXAQniWcoYasWxsTE9f/5cT58+VTAY1P7+vnOxEQUkk0ltb29renpaGxsbGhkZ\n", + "8S6KgTcE/evra2vv4GdgUXBycmKIbGtrS4lEQuFw2AT+WCym3d3dO7yM29tbLS4u6mc/+5lWVlZM\n", + "qJdk1IMyKZlMKhAI6MWLF4YtB4OBSqWSVlZWjOKAr8MrCYfD+slPfqKZmRlbKvAe3vd6UGVGo9Ew\n", + "L4BdUJK9j+Ets4NVq1XX0wTq4IhJWurR0ZHd4rGgpU5sNpt3Xocmbmdnx4lWKDHgLWPyQh429SMl\n", + "y97eno968kmgRkJ4Pz4+9micqIZyuWx6KqbjrVZL/X5fxW/yqiE6MZpGmAo0iRcdJjb4MdNUYzXG\n", + "QwcVFHX1sEUtmwpTyuEkLHB0PhMU5m/evLnX/X9Qi3m4SwfQH5YtkXCEreqPfvQjHR0dKRKJ6O3b\n", + "t5LeWVtls1lFo1Gtr6+bOwFycXR0ZC84OnCQA2AscGK8JiDdo+6QdGf4sry8rFQqZU820BEgLnas\n", + "4Zhi8OlUKuWSgtiFRCLh4c34+LgFvcNMPPw7Tk9PlU6ndXNzo7W1NROFfnkEjv9GJBK54/rZ7/eV\n", + "TqdVKBScIAs/Ay44TR42tpLMHuQU4IS7z/WgFjO0Q2pKfs0ABVgunU5rYWHBNrL8ORBRuVxWr9dT\n", + "p9PR9PS0R9O4u+fzeeXz+TuUS+pv6sTb21tTGkOhkGZnZ73j8YCgXAYxQIRKWGUkEjHjjxIoEonY\n", + "4wNvEPgOTOuowcF1IS/hyREKhRSLxXR5eXnHN2Rvb88NLGSphYUFE51I5Uqn0woGgyqVSpqamlKv\n", + "19Pe3p7a7bYDRCuVihc2ppPBYFDz8/Oan5/3OB8l+zAJ6n2vB7WYQSdubm5MbpFkiAmFdL1etzUU\n", + "Ub0wwJDic8RWq1Xb20LgOTo6Mk5aKpW82OLxuMWww87zt7e3llPhA4d8C686EABQEOpYBigc05eX\n", + "lzo6OlKr1VKz2bScCuTg4ODAxCGwbyaGkvx/4o7fvn1rzJgUWUb62MyC/tDgMoBiweOfQfnBlJVJ\n", + "I7xq+pCTkxMr3KmnR0ZG9OGHH97r/j+oxYw6hFKBiyYpHo87Xo1SAguqYWokBoUYfQ9LmbLZrCOH\n", + "4/G4d2lQDMoWdmsGG+l02qgBJCdMt+GJ3N7eupRYWVnR6Oiocrmcxa9TU1OamJhQNptVLpdz+A7l\n", + "y9TUlObm5pROpz3lxB9j2AIrFAo5LXV9fV3RaNS0WHR7DJbW1tb8QOLkORzaQ+kGR5zPPxKJ+GRC\n", + "ZhaNRpXNZrWwsKBcLmdRLCY4NOTvez0oNAMjwlarpePjY3344Yfa3t62pB0ojV3t8vJSGxsbZrHB\n", + "9nr16pUSiYRevXqlxcVFHR4e6rPPPrNJYC6XszsPwtNIJKK9vT1Fo1Ftb2+b6TY+Pq6DgwNPxpia\n", + "bW5u6oMPPlC1WlWxWLR6Gbejw8NDLx6mfNVqVYlEwkMVSoLz83Pt7+/b3LvZbCqZTOr4+NiZgtI7\n", + "4QDE/1gspnQ6rd3dXbMCZ2dnLQpIp9N69eqVwuGwPTOmpqb085//XB999JEdkmjc+Gw7nY6mpqa0\n", + "t7enTCajL7/80nU3zeBwhszOzo77mFevXt3r/j+oxQwPF4J5KBTS6uqq4vG4VlZWHGqDrzF1KHjr\n", + "7u6uBoOBlpaWlEwm9fjxYy0sLHgYwq6CNVY6nVar1VIul3PjRkQE0cU3NzeOLSYkaHJyUh999JEG\n", + "g4GHEpQwpFHlcjmXMzSGKysrFtKyMyPnxzqMmhUKLMY46AehrUJ/xUBcknd4pqOYiUvvUJ7b21s9\n", + "efLEuj+GH4VCQZ1OR6FQyM3msCYS7nQoFFI0GvUDSv+xtrZmUevGxsZ73/8HVWZgmI0iA9wZZGJy\n", + "ctIZf7lcTs+ePdPp6an/TS6XcyYdiopOp6NcLmfhar1e947b6/X05MkT8z+y2azm5ua0sLDgehAD\n", + "lGEjQ7gT/DqVSrk5oxbHIxp6JzxsBLnPnj1TMPguzphgnqWlJTeF7JpLS0tuvhKJhCYmJhzhQBmS\n", + "zWYViUQ0PT2tQCDg7zkzM6NoNGojR0ozAjLhdo+Pj2t+ft4G7vQctVpNIyMj5jED5RUKBU1MTGhu\n", + "bs5wYSqVcsDo+14PajHTZAUCARWLRVM9z87O9Pz5cxv6Yc79xRdfeHeDnthoNDQ2NqZyuazNzU1d\n", + "Xl7q5ORE09PTZr0dHx9bxEouyvARyv85HfCWgITPa1OfHx4emhkH6R/vOHZrYuGQXf385z83rl6t\n", + "VvXy5Ut/b4KJcHhqNpuq1+uOOAZmBFEpFosql8u29cJa4OzsTLu7u44SrlarOj4+tpH45uamEaBS\n", + "qaROp+NkXMx0sHmgyTw9PdXx8bFubm5Uq9XU6/X01VdfGWu+z/Vmi5xbAAAgAElEQVSgFjPuPufn\n", + "5/qzP/szjY6O6uDgwDXbq1evbDyCbxyyIfDVRCKhr7/+Wqenp1ZWswhgjjWbTVMaOWa73a62tras\n", + "zGDYIL0zAoetBkWTRXp5eelQH0QEqEe2trYcwdZqtcxXrlQqJgKdn5/r6upK6XTa9gmvX79WtVrV\n", + "/v6+ud2zs7O6urqy1g8PO4ZI5+fnOjk5sWXY5eWltre3LQPb29sztMgIHNV1rVaz+oSHF2gQY5mj\n", + "oyMtLCwYbx7OP4lGo2q1Wvrqq6/udf8fVM2Mp0S329Vf+2t/TTc3N1pdXVUymbTwM51OK5vNuqwA\n", + "m4Vi2e/39cknnyiXy5lY/1f+yl+R9M7+i/Ew/sZAcLFYTI8ePXLJwjDl7OxMn332mdrttknpg8FA\n", + "T5488ZELNRQIL5FI3DHehnXGQGQwGCiVSpmFNkzFpJxKp9OeFHa7XZ2cnFjCRN4gCMfq6qrVHsvL\n", + "yzau+e53v6vJyUlls1nnhwN3UpsD4/HgxmIxW56xIaTTaT+olHqS7A6VyWQUjUb1wx/+8FeyKS6i\n", + "G2i0kCZVq1XVajWb/cEfGB0dVT6ft1VrLBZzHASKCZw48dGIx+M2Gm+32zZMCYVCHnsnEgl7uzF+\n", + "HuYJgy9j78VuhhcGBi0saKyvksmkjo6OfByfnp7aVkt6xzvhCEcihqPTo0ePrG1sNBoeyRNkn06n\n", + "tbi4aNYh6hTUO8COGNnABMT1iIcJByOMXqLRqEZGRlxyQGcl/HN5eVmRSMQeG/e5HtTOzA41MjKi\n", + "g4MD+1kMa9ngAsTjcSeHRiIRzc3NmR4J3ZIanIFLIBAwDMdNGfaH6PV6HlpAA81kMqpWqx7jhkIh\n", + "0zsxUcRNCLX08fGxJDk6DSiQIxlYEP8O6Z3NLjxl+A/QW4H2GGAkk0lVq1X1+33zVygjGLTADqxU\n", + "KrYWuL29dckFFZQdGcadJH8O4XDYbkVwvYf1hpRK8GBAVd73elA7M4MPjPkwKSF+YGtry+6dmKnU\n", + "ajW7WfKhV6tVx5uhhqBm5TUpBejGa7WaoT+kVTwMmLZIshigXC67QWNixn94KEMc6na7Oj091cbG\n", + "hrHlVqulcrls1hqqDlhphPocHh5qb29Pt7e3Ojg4UKfT0dHRkUub6+tr1+ULCwuuo29vb23OyKST\n", + "Gh35GA/y7e2tzXBarZabOd47dAL43GDbp6enOjk58evcN6H1Qe3MkUjE5BYmaOl0WpFIxFkky8vL\n", + "CoVCymQympmZ0T/7Z//MdrFAXN1uV/F4XPPz86ZPXl5e2hL38ePHDrZZWFhwlARY8/z8vKeINzc3\n", + "9rgbHx+30yg70/T0tB49euTuH4LU4uKiY4lpULPZrNXTa2trNm6EaA9feGVlRaFQSIVCQWNjYy49\n", + "stmswuGwCoXCHQiNYQdQH43tt7/9baXTaY+hCT2anp5WrVbT4uKid/JMJmMLsqurK+/8YMsgOXz/\n", + "drutxcVFvXz5Uo8fP5ake8dAPKidGf0eFyaFsNfW1tZULBZ1eXmper2ufr+vx48fO42KHWTY4xnC\n", + "UCqV8g7/5ZdfWr1cLBatokAYgLcdWC0NHO8Ft3m8JqhhIfUMBgP7w11fX6tQKNh7mjp6a2tL5XLZ\n", + "qAoPE0rnfD7vEwIbLHZ73O0xbxl+uCYnJ83rIBGA6R6CX8br8DcmJiZUr9edb0Itnclk/KDBz0D1\n", + "Dkc6l8vp+vra2dz3uR7UYoYQE41GTU4ni6Ner2tra8seD0jucTN6/fq11SdgsGSDfP3115bNM4lj\n", + "ocDvoFEkx3pkZMTaPpo+rArIy2PnpmY/Pj72Qs/n8/bG2N/fN5WUU6PT6SiTyVj9AhIivSsdSqWS\n", + "2XTDVE6YhJRfk5OTOjo68klCs8tCRYMIFxufEMwVpV/0KsCgDITQVHY6HXU6HaMbpFIRiwG0R7nx\n", + "vteDKjMgq+DbQJcNUiHJtSq7GRo9iEQ0gWj6qP/wRBv2bwP2YpLGwqRposnDt7jVat2hbCLkRCUO\n", + "FRIvj3a7rWw2aztdGjHizIZ9pQn8wdeDxpDdEM4yu2a9Xrf9AaYvuC7xmWElgAfd0dGRxQXs5nwO\n", + "qVTK2SUkVfF3nJYgIQyFyMvGz46I5Pe9HtTOjL8DKmwGHbgKUdtSa+I/zA4JjIYkfnT03bM+DPfF\n", + "YjFDa8M7D7HAQE4ou6VfxDPE43Ef4SAVktwETk5OeudCns+uNzo6qkqlYuJQIBBwQxUOhy3jAn0B\n", + "mqTxg8BEaQGycHFxYUISuylWDZw05+fnajabLr1wSqVR5AEafjCHjRVRyKPG4TNBcAukivPS+14P\n", + "ajEPW8HSsLVaLY2NjdlDeHiHDoVCRjbYibChQqFC6lS1WvXRyhSPwJ2zszObvtze3nqU3O/3TSBi\n", + "hI6ae3JyUqVSydxg5E/sbJubmybZB4NBR0O0Wi37Y8AVYRd+8+aNjo+Pjaogeo3FYo5sYFemUW40\n", + "GuZkQHyiyUSXiHoaM/ZoNKpGo+ExOzg9kCeWZqAwlDfHx8dGT4YTsEBJMpnMve7/g1rMOBChZxtW\n", + "Otze3lr9wI2U5OmWJDPeyPTAulZ6J+GnURkMBvYjnpqaMg68v7+vqakplxXVatU1eD6f9xEOJyOX\n", + "y9kSgBAfJFM/+tGPvHujSwQdGB8fVzweN7EpHo8bffn2t79tHw+ywyORiHkbOBm1222dnp5accKw\n", + "BGf8WCzmhjCXyymXy7khjUQiWlhY0OjoqG0dGDRR2tHwYRXM0ArHqPX1de3v79vPBAHCfa4HVTNf\n", + "XFxoZmbGtS81LDZTn3zyic7PzzU2Nqa5uTmdnJwok8mYq0sjx/E/7J8xMjJiKRZH+KNHjzykgPnF\n", + "TcRY8fb21mYneEpwOhCxEAwGlU6nTXIC2sKMkRAg2HZzc3OWKeFGNDIy4qRTalS8Nfr9vubn510m\n", + "ZDIZoweEaQJXnpyc2OIM32gQD+A58lpWV1c9jSR2jQYQZuHc3JwhS5z+8bRbXl5WPp/XxcWFy777\n", + "XA9qZ+b4J5MOIWYsFjMzLh6P+6aOjIxYWZHJZFSr1TQ1NaXvf//7bhDZvSYnJ3VxceFSA8ssdnB4\n", + "IZIc0l6r1WwEg6M9pcvs7KxqtZoajYZVypCGbm5unI+NF0ggELCDEIR2bHfhITMsgrjPxVSSBxw+\n", + "BCcLDR9oDVNGeMoIejnhOJmIP+ZzB/HhgaLeZ3hECUbWYbfb1Zs3b4xr/yo6behClsRiBUKi7qS+\n", + "Q7dHg3Vzc6ODgwMfc3/4h3/o6Vs6nb7jr4FWTpL1gpQUBwcHSiQSxrORUwEXwiG+vr5WuVxWLpez\n", + "UeHc3JwpoMFgUAsLC3Ye2tzcVL1eN3S1urqqvb09n0SMg+Fw83PTA8zPzyuZTKrX63l48/r1ay88\n", + "IosnJia0s7OjUqlk1Qk2teDltVrNBKphxAJbA1TjX3/9tYlc+PrBz8b+oNfraX5+3o1qtVq91/1/\n", + "UIu53+8rk8nYlHA4nFGScU7MSIhE44hjEPLhhx+a9AJsB1yHmSHHMK6fMzMzSqVSOjw8dK2MTInd\n", + "iJIlEAhYAApKgkcH418WMuoQUBR2RkmGzXgAGBKxAPlMQAwoc66urjQ3N2cWW7/fNy8EVcpwqBEN\n", + "GooWampMbVC2876ur6+VTCZtMHl+fm6yfr/f1+TkpObm5swN4QFH3vW+14OqmcfGxrS9va1ut6v1\n", + "9XW1222LO/lw0+m0+RMTExPK5/NKp9M6OjrS6uqqaY1Pnz7VH/7hH7q+pWm8urrS0tKSDVlSqZQb\n", + "RtJJ0+m0yuWy4yQWFxdNsfxlb4zBYGA0g51/cXFR8Xhc7XZbpVJJS0tLarVapo/u7++rUCi43oQA\n", + "BewVCATuGH3jj4zdQSwWs3i11+vp29/+ti1siTzr9/taXV3VYDBwJgxGjuQR0hwTsoMpJWaR+EPj\n", + "AYi6O5lMqt1ua35+3v7Ok5OTtvt63+tBLWacgjqdjv74j/9YH374oY1UmKKxQ62srOiLL76wb0M+\n", + "n/ei3Nzc9OBhY2PDdTblwsbGhlKplN68eePdV5KxamRS1KTPnz/3AiADGyPFm5sbvXnzRoVC4U4Q\n", + "/YsXL5xR0u/3nfsRi8XU6XRcH8M9xpUJke7c3JztDEqlkr7//e/r5OTEtbokl1kvXrywcQxj+Xg8\n", + "rpcvX2p2dlbtdlt7e3v2jF5dXfVUMJFI3AkDBREJBAJKpVKqVqu2FeO0qlarmpmZ0cbGhnf9Z8+e\n", + "6fnz5/e6/w9qMRcKBX9wy8vLVjUAh+FjAaUTdfT09LQHJ9Sr+XxeZ2dnWlxc9DGIrSuICYaJMOlQ\n", + "ZGOezQQQOf38/LxVzVAiB4OB1tbWPGRh6LC+vm63ULBnFCEYM/LAcOJQk1L6HB0dKRQKaW1tzQYu\n", + "fAYMhvr9vpaWliTJiAjvIZVK2QckkUjo5OTEQlVKFghXPOwY1GD7tb+/r6WlJX8/kA5Mxo+Pjx1G\n", + "+qMf/ehX5Hyuw8NDCzorlcodUxKgNaiRHIO/vMNJcnqT9E5XuLOz446dhcCxj29dv983T4JjFWND\n", + "eBPb29tqNpvmOMBt6HQ6LitCoZDq9br29/ctYRo2UgECxL8ZK9jz83NVq1W7McGVDgQCOjk5sWSJ\n", + "KDbw55ubGyMdGExSu7bbbR0dHalYLOrg4MCIR6PRMC2AQM3h3MHb21v//4MPPrD0CtnY5eWl3r59\n", + "69INMcHu7u697v+DWsyMR5m84QgEtMQOwoeeSCRUrVZtvI3hNzAeOCuqk1/2Nr65uTHri6HMsPsm\n", + "i5YGk4UNG43mEzYauYHAhpisVKtV78qQ5nG5Z8qHhQJ1PQuEKGJOCppESaZk0pgyCkeMS0wyWS1o\n", + "+ygrMDPHngBMGvRIksM8edgZxlByZDIZw5oHBwf3uv8PajGvrq6qXq+7XKDGhQ3X6XSMQ0vvatzF\n", + "xUWl02nHeJHElMvlPEzI5/NOfo3H4zZNYYfLZDJ2KSoUCmo2mx6CAH0tLS356zBNhMMAzkt8wuzs\n", + "rDKZjOMp4GywqHZ3d82RxkgRhyUsDdj5QXDgU1AOTExMWGXNZ4VHH+VONBpVIpFQLBa7Y8GwuLio\n", + "TCZj9t34+LjLBsxlJNmHjocTQcDk5KS51LiXBgIBlzvvez2omnl3d9fH3fn5ufb29ky3pAbc39/3\n", + "btPtdo0NE2HQbret2aNmBXVgB4rFYrYy2NvbM/m/Vqvp9evXvpnpdNrQ14sXL2xSA77MtI2pZKvV\n", + "UiqVsgni5eWlR+E0c1iQHR4euieg9gyHwx5Tw1tGvEpNzVTy+PhY6XTaGSmUQiAu4NK8FwI9JyYm\n", + "rH2Eu4EFA+GeTFKhsqIXpDSbnJz0hJNBCZzw+1wPamcGhqNhWVpa8s41Njamer1ujgFH/szMjNLp\n", + "tK25njx54ro7m81qeXnZdlWIUlm8iURC3/3ud40m3N7e6tGjR3ry5ImpoSwERr/sZrVaTY8ePdLk\n", + "5KRSqZSWl5f15MkTTU5Oanp6Wqurq8rn81Z1EP1weXmpubk5188EZgIrzs3NuWxZXFzU5OSkgzuH\n", + "U5442ldXV72rT09Pm3jEzwv3BKW79Isdt1qt2jASE5tkMmlbBfoLSplsNqu1tTVb7cIrhxY7PBN4\n", + "n+tB7czNZtO7BbKeaDRqwxG692AwqEAgYG4E4D66t2HqJey6ra0t831xGu10Otrb25Mk7+KlUskN\n", + "EWP1P/mTP7FUiRMhFoupWq2a2IRjJvzjvb09zczMqF6vK51OG47LZrPa2dnxoKVcLnsUD/H/5ubG\n", + "Sm44y5VKxZg0LkTdbte6O8j6MzMzprfigAoCwpj77du3Ojs707Nnz3R9fe3Phh0eI8jhGOZ4PG4y\n", + "FqPysbExtdttnZ2dmXx1n+tBLWb4s+Pj43r27JnGx8ftS7G4uGhTP3Yl6suZmRl39clk0se99C48\n", + "5/Xr15qdndX09LRGR0ddGnAShMNhZTIZ7e3t2RKLB6bdbnswgx6P4QEnxMLCgs1gcMn/4Q9/qO3t\n", + "bT+c2GQxoSuVSkqn0/Z6ZtKILo8dk5+B8HXEslhvTU5OOrASg3ASAjKZjAqFgsOJarWaUqmUc1cu\n", + "Li40Ozvr9yy98xbBfw+vEkk+qRYXF525CPID7fRXCa1DF2Pdbrerr7/+WsFg0C6UlUpFh4eHOjw8\n", + "1Pb2tq6urlQul81VZiJ3cHBg0k+xWNTp6amurq684EBI8BVmZz05OTGBiCkd/GluEgw1/C2w/Nre\n", + "3la/39fTp0+Nxe7s7NihHnJQsVhUvV5Xs9m0OppBTSAQ0OLiog4ODryA6vW6Tk9PtbW15UGGJDsN\n", + "YbfVaDSc2wJXhZobH+dhx9F2u+3FSUIANNZGo2HUhO/faDTUbrfvOJyCclxdXRntuG/a1INazBi+\n", + "dDodffbZZ7q6urLJCP/P5/MqFAoaHR3VysqKj2IooaFQSOvr60omk5qZmfHflctlp5hisBKLxVQu\n", + "l410wMmlDDk+PtbU1JSNZiS5Ycpmsx7EzMzM3IkNptEjjAcxKcR3VN2SPCYeDAY6PT1VJpNx44m/\n", + "RTabtf4RVQzSL3jR0WhU6XTaeeH8HdBkrVYzOR81tiSLGOCRsODBkDn52PUlGTFBG0lZ8ivW3NB1\n", + "dnbmm4F3MtBQvV5XJpNRt9u1l1qn01GhUPAuglfa/8Pem8W4mqb3ff+vdq7FnawiWfvZ+3TPTPcs\n", + "PZIVQbDsXDibA8QOksALYASyIyMXUSLpOjGsIIiQQFGgwIHgC8NyvMSJBRuxJDua0YxmJtPdc06f\n", + "pU7tVdyXIllkVbFIFvnlos7vaZY8stqn0NKoMB/QmDlbcfne732f5//8F4YfDA3gZ9Tr9Wv+Fycn\n", + "J3aDLi4ujCUG8uHz+XRycmJ/j+iDUChkWK7X6zWVSzKZVLfbNZ4EF2NxtHIsDLB03juEJthxDI3g\n", + "I1OToh6BXcdnA3kBEep0OqbS5kFFZAveLslw9PHJJgOZ8SYYk5jRaKRGo2GRbGR0jyvr3+S6VYuZ\n", + "ZocvfLwOnJ6eVqFQUK/XUzKZtJ0DqIuufzgcqlwum98FmXh4x4HFMjjhxjO6ZljA+JZhBna2sNtg\n", + "m0EjdRzHms+TkxOTYU1PTxtnpNvtmqMQMBZ4LU3VeA4KC4oHFJI+iAbMwG63q1gsZsoR2IAgEjAR\n", + "WbRgz0xFWYy9Xk/BYNCQIWIiYAbyHYIwIezlYYco9abXrVrM3KS5uTnt7OxYfVYulw11IHdvbm5O\n", + "h4eHevXqlVqtlo1Sy+WyKpWKOp2OXr58qVKppP39fSP8MMqWPnFOAtuFuTYYDNRsNs2lf2try3Zr\n", + "oK9ut2t1da1WM+U2D+Dh4aEajYbV0/ClIbWPuxSRa/Ls2TPt7OzYz2MgAQoiyVz6qXtxYqrX6yoU\n", + "Cte85qrVqgqFgl69eqXBYKCjoyOdn59re3tbH3zwgT1U5XLZhK0Q7fnewc9xNCoUCup2u2o2mybB\n", + "gvOChdmbXrcKzYAVNjs7a74T4LH4zY0f7cQmjBu/rK2tWWNHLcmYHKUFU7l0Oq1oNKp6vW6umODQ\n", + "TNimp6ctkmw0GlmtSmorUB96ORrRQCBgp8rc3Jza7bYeP34sScavjkQitosi58JR6PLyUvfv3zf+\n", + "MPV3KBQyVfX8/LxWV1cNIvT5fKrX68pms5Kkx48fG1TH6FqSiRNwkEIQwNic/G3yFwlCmp2dVTab\n", + "NR0iOze5KD+MGx674CVAcqFLhqhPpw3uymJhyIARIHnQMNTgYbCAqtWqDTDq9bp6vZ6psTHfxlIA\n", + "+T9+ERDlu92uyuWyuc1jik7IPELRcd5xrVaT3+83425qbcxbwIFHo5F5YfAZxk3EsQgjnYqdejAY\n", + "WN0K0X44HBr5CKuu+fl5223JIWRDQFVCI4wxD7Ck3++3iWy/3zfvulAodGNo7lYt5mg0qkgkokKh\n", + "YOLSYDBoqAO79cXFhSWyOo5jdV6/31c6nbbMkng8bhgtJB5MEweDgebm5rS4uGgkdOpwGqZSqaR7\n", + "9+7ZZAs9IdwI8vTG6aSSzLd5MBgY3XR9fd0kSeOpTjSO8D1odpmEjjv+czrxsyHEwxqkIUQIzPSO\n", + "XPHZ2Vk7RR4/fmykpHg8rkqlorW1NaMPJBIJC4zHcyOTyVgjiusSiVSoT25y3aqaeTgcWpAMPhXj\n", + "Tu6O46hWqxkP4ejoSKenp2q323rw4IFc19Xu7q6VFb1ez3YTr9dreG6hULAaGuspWGWDwUB7e3u2\n", + "29PQwf2l2UkkEub8Q/oVu9Q4rRQJPyHrkoxKiqAUfwpqZOwQ8K9AroT5DdNAtJDlctkoo3jZwbsm\n", + "ExxDGOwWwPMhNL399tv2OXH+pxGn9EKWdnR0ZL6AYPS8xk2uW7WYoXpClSS4Em9iVMnoz7LZrJUe\n", + "3/72t826ikRWnDeRYlH/xeNx88AA2oJcdHZ2ZrIq13XNfAV30GAwqOFwqEKhYF7PxPQiIAU9YMJG\n", + "3ggS/3A4bAgMTReav06no5WVFWPxjdfpeEoD68H8Y7oJlEZp1mg0bFQ+MzOjXC5nKMrx8bEkmSh2\n", + "b2/P/iwYDNqmgvcefUa5XLYyJRaL6ezszPqDu3fv3uj+/5EsZsdxQo7j/APHcV46jvPCcZwvO44T\n", + "cRznNxzH2XIc5587jhMa+/s/5zjOtuM4m47j/Knf7+dOT08rEolci0qAAE8dV6lULKidkJzz83Pz\n", + "njg7OzM+QrPZNOcecFdJ5itMJAR5KaSOttttOY6jeDxuDc/ExITtiDSmOPrAj8hkMnJd19yLqO0Z\n", + "O1Mzw2mgnMFii52Qh+/Vq1fW2DJAcV1XqVRKk5OTNvk8OjpSu902FyIU1bgucbpxwd3gIfF6vTbh\n", + "G41Garfb9v+Hw6Hy+byazaZarZbm5uZ0fn5uU85MJmMWDs+fP7/Ruvqj2pn/J0n/1HXdB5LelrQp\n", + "6Wcl/Ybruncl/dbrX8txnIeS/pykh5L+bUm/7DjO933fiEYxGp+dnbXpGR04+DBTKhzoKTNojODc\n", + "wqzDgwPeQyAQUCKRMGNE+MVgtfPz8xYdxrROktXmNEaSzK4AxQf4Nzki4zHANHyu6xqxn2YTDNjv\n", + "9ysQCBjagUKk3+9b2tXc3JzV79Fo1LJO+FmUCvy54zhmAIN4F4QHtTbNsuM418LqU6nUNTNGPpPH\n", + "4zEagN/vv7Gl7R96A+g4zrykP+G67l+QJNd1LyWdOI7z70r6t17/tb8t6f/V1YL+9yT9Xdd1B5IO\n", + "HMfZkfQlSd/6vT8b1hYkcelKkoRe7uzsTKFQyGAhqJ+INuF2EAgJNZGpHLIpNIXo++AZcCLQFBKA\n", + "Oe4bDbTn8/mMAplMJm0Xm5iYsOEKY21qZfjQjH89Ho+Gw6H5QO/u7hqJfnZ21oYuLEpgPhpBHEZn\n", + "ZmasVobMBNKDD914rHAikdDR0ZGFEUlXo+9+v28qGNxYx08EPid8ZxpX8GZEE296/VGgGauSao7j\n", + "/KqkdyR9IOm/lJR0XZcOoCIJF71FXV+4eUnf12IdIsu4USCwFDgpjRZ0THI6KDP44hkTh8NhVSoV\n", + "vffee9rd3bVGyXVdO2oZomATAC7Lw0GpI8ketlwup4cPHxoSEg6HbXdlR8c6Fs+K09NTexBprFzX\n", + "ValUUq/X0+Liou3CTNbGbWcZ6AAjnp6e6vj42BTVGxsbOj4+VqPR0Be+8AWre0FoXr16ZQ0msROS\n", + "rHbH5R/oMJPJWMPL0ARrAdydaFbpL25y/VGUGVOSviDpl13X/YKkM70uKbjcq2/J/df8jO/7Z1//\n", + "+tf19OlT/c7v/I7K5bKx3eAFAC2NRiNFIhGr4Uajke7evWs1M+mq0lWA5dramh3zS0tLxkNgN0Wa\n", + "v7S0ZE6kHPGUHkz/eGiWl5etdsb9k+YVhTOYLUJc6JfoB7GKzWQytthhrLE7k3GCpAo3VPjMTB3x\n", + "uwiFQlZ2YCZD08hnmZ2dVSaTMd4HJ1W73TYc/f79+8aPdhzHyPgMdVKplPFfXrx4oWfPnv2xNBvP\n", + "S8q7rvv/vf71P5D0c5LKjuOkXNctO46zIInZZkFSduzfZ17/3r9yvf/++woGg9rf39fjx4+Vz+dN\n", + "lf1n/syf0Xe/+12l02kLbL97966Oj4+VSCSMHonuLR6Pa3Jy0tyPGE9DwifUZ3zI4vP5jFyPsoUA\n", + "n36/ry996UsWSIn75vT0tBKJhIbDob785S9rNBppb2/POA/pdForKyv6xje+YUYrHo/HzBghwUME\n", + "gqyUSCRUqVS0vr5u43z42DRulDmZTEa5XM4WNLXvvXv37Ncw/BAQSJ9MAgmUf/fdd61hHBcwzM/P\n", + "q1Ao6K233lKhUDDbsoWFBSUSCX3hC1/QcDhUrVbTr/7qr77xwvpD35ld1y1LyjmOAw7zJyU9l/RP\n", + "JP2F17/3FyT949f///+W9Ocdx5lxHGdV0h1J3/n9fr7f79edO3d0eHhoFrGdTkff+ta3bOdFqey6\n", + "rnGDd3Z2jOlGbIQkiy7GT2J6elrJZNI87KhRUX7s7u4aW02SjbQDgYCOjo4sCapWq5kbfiAQUCqV\n", + "0pMnT8xCYHFxUdFoVGdnZ/rggw/k8/ns10RGcMyDHCCQxbETE5ZkMmkuoOz40pWYYX5+XgcHBza2\n", + "H1fk5PN5q9Nx65d0zXCcaWUwGDRUZnZ2Vs1m81oWOK5L0F0nJydVLpetzKKxvcn1R4Vm/LSkv+M4\n", + "zhNdoRn/naS/KeknHcfZkvQTr38t13VfSPo/JL2Q9M8k/VWXu/h7LqRI2FrhDo+vMPBQo9FQo9HQ\n", + "2dmZNYGUG6gqkFOBeLA4YYjRCKJ3k65KksXFRfl8Pu3s7NhkkYeAcoMhCOYxDEhw9gyHwxbtwMBn\n", + "3INuvAzC9w6E5fT0VI1GwxYMI2YWMEkB29vb14ZLlBUw/4gD5iSC+TaeMYhwgLoetQt4P98ffQLf\n", + "seu62traMniS/oWH5U2vP5Jxtuu6TyR98fv80Z/8ff7+35D0N/6gn7u/v28+EjRBzWZTmUzG/Ihp\n", + "dlgkH374od59913DodvttprNpu1IhUJBHo9H+/v7isViRpf9F/kAACAASURBVNLhz4DUQAoobfCP\n", + "wOYKwg4wHrgxLp6MoPGdK5fLikajZiWLOsXv95sGEDtckJpqtWqvg3Ib1hp4NGT6YDCok5MTVSoV\n", + "TUxM2E6PpAs9Yb/fV6FQULvd1v379+0hazQaeuutt8zRkxocJAYNIUIG/pzPBhGJh9l13Ruz5pzf\n", + "Z5P7Y3c5juP+1E/9lHEvBoOBZWQTlwDXgBqQnZyJGlwHkpok2S5KXvbOzo5FKwCdkaFHA4ZxeaFQ\n", + "UCqVMgMURtIYhKPLI9RSkqEgpMBCHOp0Okb+l64SWe/fv69CoWA539FoVK1WyzIF3dchl61Wy0wd\n", + "JyYmzKAGywRilsHoCdyp1+smppWuBk/j/Gswe4j9Z2dnZopDucL0r9lsWrTb5OSkTk5OlEgklMvl\n", + "lEgkND09rU6no1/6pV+S67rOm6yBW0U0kqREImHxB6SNxmIxM/wG/mK3LhaLZpoCL5luv1QqGeGf\n", + "3ZFFxoAD0j0LgeOUUTDaOSxxwcCfPXumjY0N40+ABkSjUZs8MoZnEQK10RxiNH58fKxKpWLlDGN3\n", + "8vcKhYLV2T6fT5KszJmamtLBwYHFSBCjkUgklM/nDc0YLyvGVTLjkCH6SPyaeah5IDmZKLXw/CCk\n", + "fnt7+0b3/lZxM46Pjw0tQLlALciuMC56JZnK4/GoWq1aKA1JpixGlBydTsdEpBCCQD2QNkHex64L\n", + "otH4EU+cAqNvuAnjJKBSqWTUU6it5XJZZ2dnajab8nq91zSJlBeSjOLJg5tMJnV0dGTfB4McShEM\n", + "aeLxuJ1OExMTisViZuCCUyrNM+XD5OSkTUr5njAWx2EVSsC4IABeBu6lYPM3uW7VzgxhptFomJAU\n", + "90t2HaynIpGIyuWyQqGQ6edCoZA6nY6Wl5dVr9fN1w3CfDAY1Oc+9znt7++bnhAbXerTSCRi3T0L\n", + "m3EwgxYsajn6x03ACe3JZrNqNpsKhULGkSAUiBEzyIvjOEbFJA9wfn7eCEi7u7s2+XzvvfdULBZV\n", + "KBTshIrFYsaRwO2JYB7q52QyqcnJSS0vL2t5ednMJNPptObm5nRwcKCJiQkzsnnx4oUl0r7//vva\n", + "3NzUxcWFotGoTQD5jJCn/vSf/tP6xje+8cb3/1YtZjr2QCCgjz/+WFNTU8rlcgoEAmbvSr7H0tKS\n", + "GZY0m00jj09MTOg3f/M3zawchteDBw+uWbiSUbK0tKRqtWrSpuXlZUMF7t+/b5ZeOArhWt9sNk1j\n", + "t7u7a4pxKKb9ft+wYaiseH34/X7t7+9rYWHB5P3tdtuGK1BJMX+UPrFheP78uS4uLoyuiaMnwtJO\n", + "p2N9xatXr8yGd3xHHw6H2t3dNbencUFAsViUx+NRr9fT0tKSarWavvGNb9g0E5YdBpPYdw2HQ/3O\n", + "7/zOje7/rSozUP0eHx8btivJ1MKFQsEcjvCE2NzcNLEl4lAWO+JOasTxcJ5kMqmlpSVFIhHL4kin\n", + "09dU1B9++KGRa9iRp6enTbNHPR4Ohw2VYPH1ej1ls1lNTEyY6z9OoShX8NigfAGOoy5nYpjL5Yy3\n", + "zMO7vLyslZUVyy6kcWU3x8ARwQInHPxrn89nJ1ClUrFyCG4LiA+e0aBDEI8WFxeVSqUsExFx8E2u\n", + "W7WYwSnZMRk+zMzMKJvNmko6FosZqwyXHjgFo9FIb731lo6Pj7W0tKRut6vHjx+bKhomWKlUUrlc\n", + "1t7enrHCkNofHx9b8wX1E8dRFtv9+/dtTAwPQ5Jl6VFrM21stVrGqCuVSkYGgi8cDoctg5rm98mT\n", + "J+p2uzbw8fl85vMB6nF6emqEIyaIYMOgNYT9oErHYyObzaper2txcdE4HECGoBz5fN7gv5WVFTWb\n", + "TRUKBWMKYugoychOb3z/b7Z8frCuWq1mjRhlxuHhoYbDoV69emXHOAOUXq9nNxKzbho3+L0XFxcW\n", + "84tFFWUJNlOSTJpPAwdrDE+7mZkZPXv2zJAR1CqSzD8Ck/DLy6tQ+bOzM5uSgRNTElCPQ6Fk0AG2\n", + "izkM6a0Er1MeNZtNy8YulUr2GXFwmpiYMDU2vwc6hCIbdAXsGUI/f7fX6ykSiZjC5OXLl+YuhdKF\n", + "B50T9SbXraqZE4mETdXu3LmjYDCotbU1U4lwzDFChhoZCoVMgXJ+fq6lpSVrwkqlkpUE4/IpWG6x\n", + "WEx7e3vmNgRvAlx1enraGqnFxUVLJKVkuLy8tAAcGsB8Pq8vf/nLJiWCggmCwQ7LLglBieEEdgU4\n", + "gsIBSafTpslDezhOJ11cXLQsRDzwOIlIfcUzgzIDvvjS0pI1eHzXBHIS8wBCgjMSpye/f9Ohya3a\n", + "mfGIqFar8vl8FlDOl39yciJJNr69vLzU9773PSPqP336VNVq1QYse3t7SiQSNnKVZAQaRrR7e3u2\n", + "wPF1brfbKpfLyufzxvnlJJCu4hVAF6CtssjPzs5MQU2ADdxp/DxyuZypzDFZYZzMe52enlaxWDQM\n", + "Op/P25gfqT/OozwsvF/G9+PKamwATk5OrOQBm8cnhNIBXd9wODSYFJErOkhOsl6vd213v8l1qyaA\n", + "v/iLv2i1LTRDMN1SqXStpvN6vfJ4PKrVagqFQkZER1SZzWa1ublprvTUxXTePp9Pu7u7unfvng4O\n", + "DuTz+YwzHIlETHAK3r24uGgZJSAUeEXTXPLzedAQxKL65oHE1406HU42JwElByLWer1u3nDpdNrk\n", + "SclkUtVq1RYsxKTZ2Vlr+miiiUKGXI8Ui1IGtYjX67UcGU6bbDZrPGl4IgxbyB+cn5/X4eGhfu3X\n", + "fu2HE0Dpyq2HQcLBwYE8Ho8KhYKZDm5vb5tNAFG+jK57vZ458DD5oubb3983b2acORmXE8eGVdW4\n", + "9wMu9ASh49V2cnKiZrNpGDbZJRcXF0Zc4lhmbE5tSUmCkBXBK3g3fwavo9fraX9/3xrPaDRqC5fp\n", + "pCQzYwGaQ51OE8tirdfrCoVC5uCJvS9WBJwOPODwPhBFYCrOqPv58+dm27W8vHyj+3+rFnO/37dF\n", + "gocx2je0euxseNJhtCLJaljsqbhJ8I1ZeDhuwl5DvoRChRvPlAwMFl4FuzxqcASio9FIhULBdIgs\n", + "NuxomdjhSgQXA/MWIDZgOvJMHj58aJrBvb09SdLR0ZGSyaRhzYgVQGSIwcDsJhwOX3Mpvbi4sJwY\n", + "EJmzszNr/i4vL80sHWV5LBazJvvly5cGb3LyYKH2ptetqpm73a6WlpasAfF4PEaux3gE21tEm0QZ\n", + "jJsFokaGCFQsFo2CCU4NnAYDT5Lxdlm4kNfhNkgyPwseFOkTWinowGg0Mv4FMN3l5VUcMlg0Pso8\n", + "kFBbYaDVajXT1T179syGNkicCCOirsW9E485ooY7nY45GgEbjqu4R6ORNjc3jSJAGq4kO8WA3mq1\n", + "mj34Ho/HOCzAksjP3vS6VYt5ZWXFDLPBMon8PTs7M34wg4FxC9bLy0tTi9DggOHiFgRrbNz9R5I1\n", + "YJiwcJNoinK5nHw+nz0Q9XpdjUbDbizN38LCgtFHJyYm7H3AQIMjQWwCTDX4zAsLC5Jku3U+nzeI\n", + "sFKp6OTkxEhU2CEA62G2yAKfnZ1VpVLR3NycEomEDg4O1Ov1VKvVtLa2ZiP6fr+vZDKpWq1mFrc0\n", + "gZyE9Xpd9XrdNhYyB/EWwc/jpov5VpUZmLycn5/r/fffl8/n0/Lyssnoo9Go2WuRQ51MJs0wcGLi\n", + "KmotHo9fE43SkYNaxGIxnZ6e2uKZmZkxmTwcDpJfB4OBRQmHw2FVq1WlUin7M4wVYZzNzMyoXq9b\n", + "iik163jshMfj0e7uriQpHo+bcWOpVDJbW04WdnvyrQnXYeKHfxyjcHjGo9FIqVTKyjCGJpRf1Pce\n", + "j8caUSwdMJ5h9w2Hw4ZpI92KRCLK5XKmeD8/PzdF/Ztet2pnHo1GNgDAL5k8O6Z93Gik+Pl8Xr1e\n", + "T48ePTILXOT5uLljGUBJAb0RrgZH7sTEhGWGIAtikXD802SxUCcnJ806llSsSCSii4sLe4jINcEq\n", + "i9AeiE6YLbK4MAKv1+sW0QBNs9VqmZdevV7X9PS02QNgqcWonBRb2Hvsqixk6uSJiQmbrKLmgbFH\n", + "rgpNKREax8fH8nq9kq4eSDw8bnLdqsWMDJ/AcrR4tVrNYgw4wmliEomEer2eqtWqstmsDTRQWjSb\n", + "TUtiotyg5Bh3mQcSG+cUh8NhHRwcSJLtmI7jaGlpySZ9UC6DwaDtzKAm0WhUXq9Xx8fHdsowzEHF\n", + "jQwKrLpWq9lInVg213X16NEjs571+/2mIG+32+YoSo0MVElDSYZ4s9m0CGVG54FAwBiHPATs9ozf\n", + "GdBQRiBNA6KjYU6nv6+DxKe+btViZlekloVvixQIEji46mAwsHoWbzl8MGZnZ21iiNIEPgYjaUmG\n", + "Ow+HQ8OWaf5OT0+NWklYDaw49IaYLuLKiTggk8nYGHlyclKNRsPMwJF1EYaJajoajZpqhh2RyIvd\n", + "3V1VKhW5rqt+v29TOJyfRqOR1e64djabTRvagGM3m03LWSRuzuv1KpfLqdFomHhgcnLSUgcwJefk\n", + "OTk5UTqdNtNHHJtQtLzpdasWM1a2pCnBSwBK63a7Ojg4MKioUCjozp07VpaMRyDQWGFmiFkJTDbS\n", + "S/GhGPcvrtVq1hzB+2C6x8KDSYdqGRy42+3K4/HYuBoGIAMJkAw0jDSd4MU44NdqNTu2MW2k/h4X\n", + "FzAyH4+owMiRUgqWHv+fEoLGGWIVzSuE//Pzc/n9fh0cHJgiB14Jqh5Jpg6v1+s3uv+3ajHjZClJ\n", + "X/3qV008GggE9JWvfEXhcFgbGxsGHf3Ij/yIDRJc11UoFJLP59OdO3cUDof1+c9/XtFo1PKyA4GA\n", + "TQzZ1djVfT6fKbDxgcbhh1Li4cOHdnpgyILPHQMK9HDoBBOJhEGNmBOS9uT3+5XJZDQxMaG1tTVz\n", + "EM1kMlaCLCws2M4eCASMhzE/P28DlHv37ikSiVhGNtL/bDZrTL9kMqlQKKSFhQXzqctkMrq8vNT6\n", + "+rpZLpBUgFCA4RJjc5K2JicntbS0JL/fbxvEvXv3bnT/b9Vi5smemprSkydP1O/39e1vf1u1Wk1f\n", + "//rX1Wq1VCwWjZH25MkT20k3Nze1vb2tqakpvXjxQu12Wx988IEmJyf17Nkzo4OenZ3ZlJEF3mq1\n", + "1G63lcvlVCgULHuPYxqFyc7OjkqlkrHO0MK1220Tqx4cHFjdC3b79OlTC6jf2dnRwsKCNjc3NRp9\n", + "ki4FJNloNFStVg0poDZmKMJg4/Dw0DSG+XzeTrMnT55Y2bO/v29KFrL8Njc3rcd4+fKlBRrhI42r\n", + "0ZMnTyRdIT3U8jSEyL9evXplSM3x8bE2NzdvdP9v1WJm9Iv6gpwOEqAkGUke7wuv16u5uTlFIhEl\n", + "k0mrCRlo0Cyii0ulUmo2m2Y9xYLAfmpjY8N2psXFRRugTE1NWXkBGZ9pYrlctp9DID01OM0V3GV2\n", + "MYSlkPOpV/lcLN5+v28KFyy7ms2mTe0YM1cqFftMJycnchzHRAQ8SEwNIWwxhmfow9AIF1Lw9vn5\n", + "eftM+Nf1ej1Fo1GdnJxYHARkrje9btVipg6s1+vmfQxFEZ4AQxByAKkDHzx4YM0b6gjw54cPH5rR\n", + "X6/Xs1gFjBlRHqPJOzo6MolWPB43SA8rWjgVmCpi/wWjjPo5lUqZsyaN0+TkpHZ2doybDeFHkpmw\n", + "dLvdaza+eH10u11LmYWWOe5QCjKDTnJ9fd3iLsrlslKplIbDoSlIQDLG7RMQD4AzozpHpYJ/HfU4\n", + "aV2Li4tGanrT61YNTVgYUCsdx9H8/Lw1K3BtUTQsLi6aQThaQZosHOXn5uZMv5ZIJLS7u2s7PU0Z\n", + "qmdqZmpRFiA7FaPuyclJ86qD7ww/hIEGqabjkB8BnKhKxnfLy8tL87igJ4AZyOtA5GHRj9vzIlJg\n", + "kWIOiXHO8vKywXfU/XiLzM3NmXqFwQeuUdJVPuN4LiGYfyqVMgHxcDjU2traje7/rdqZganm5+dt\n", + "6kT2M0GPHN00c/l83gYY9XpdpVLJ0I5ut2v13Dh0BfmdLp8d/fT0VOVy2WrdcDis8/Nz40wwZOl2\n", + "uzbuHvdwAxtnOrm3t6dyuWziV5Qf8DtOT08Vi8WMQffy5Ut7T9LVWBu73mazqVwuZycJtlrS1QNU\n", + "KBTsBKnVauYeSkNNn8FpVq/Xbdw9GAz08uVLM1qv1WrGQDw5OTGolO+gVCoZlo76u9Pp6MWLFze6\n", + "/7dqZ85ms+ZLAfk8nU4rkUiYCDUYDNpU66/9tb+mX/iFXzAPOISo3MAvfvGL2tra0uPHj+3mjEYj\n", + "ZTIZFYtFOY5jtTCUURYE0BSu+Xja9ft9G6qM80NALiAynZ+fa3Fx0SZ3jKeJKtvY2DDVNAOOt99+\n", + "20j6ExMTSiaT8nq9RtuEuca4GuNy3itjfxzx4WDgQx0Oh/Xq1Svz0FtZWTG+OEbiTAIzmcy17EBU\n", + "OL1ez/4MLv14JMa//Jf/8o3v/63amTudjnkTY+iCGkOSTbTY/f7+3//7Njwpl8uSZBo7n8+n3/3d\n", + "35XX67UdKBQKGdG/3+9fcxsCTsOHA981COnjOzjMNK/Xa7RR+A2UQ1BK5+fnNT8/bxBju922EwNO\n", + "MUqZw8NDG/hQMvHaMzMz9vP4+5xkNIfspOSN06gNh0OFw2HlcjkbsmDZG4/HJclOn0AgYM75NJJw\n", + "pw8PD42aSpoV43mcp25y3arFPA7sAxXRyRN7Vq/XrYGjAWLc2u12jVPMTcaSgOOcmwtxqd/vq1ar\n", + "mYkLAxMW5sLCggVMnpycaDgcql6vG4MPqAxuhPRJklO/37dFzWcgP3B/f/8a+y+fzxuSAfrR7/ft\n", + "825ubqrdbluYJycDn7tUKhlVMxgM2tQOR3xckngQEfdyYVhTq9VssQI3sslg5+DxeMxU5uzszKao\n", + "P6SAjl00Y5KME0w9eXFxYTAUhHFJhhOfnp6qUChoaWnJCDxwPbjJeKhxU1GzwAkuFovXvJipsyXZ\n", + "RBBOsqRr1lbBYNDkU5Cazs7O1Gq19PHHH1vpVCwWzROZiLNxx/tEIqHDw0Pt7+8bguH3+3X//n1D\n", + "VC4vL/XRRx+p3W6r1+vp6OjI0mnBnycnJ40mKl31I6FQyEoJTjnG9B6Pxx526eqEw8qr0+mY7ApD\n", + "yd3dXeXzeWvKmbLe5LpVi5nYBUa+uFHCM6hWqwbY+3w+22GweI1EInr69Kny+bxlfbDjjsvnwV5b\n", + "rZaOj4+vmZgztmbBhkIh5fN5i3qQPgms58httVoqlUomuSIsEzEqENjLly/l9/tNUABBH5717Oys\n", + "CXK9Xq92dnZUrVb13e9+1xQhcI6Xl5dt5N/v9413Eo1GrwXCY7dQq9V0cHBg9E94JtgAg5lLnyTR\n", + "AjcC5w0GA21ubqpWqymTyWg0GllOYy6X++HQZPyCF3BxcWG0SZ/PZ2lMsVjMjmF4FkBnCESTyaTV\n", + "vjjpE3wDsR1FMbIgj8djP4Njc25uzvw1IpGIxZaBQnDMY6VLPQ2WjEYuHo/bBA/yEA5NlAjU3Ax3\n", + "UqmUvSev16vV1VVDMkiUBesmBoLoMoZIlCx+v9+EqalUyqRc0WjUeCQ4IQWDwWtiWnD9ubk5eTwe\n", + "G3kjgqXnIBXrj1102md5MV5mLAztEhgJVhaowscffyzpagyOLxrURXamg4MDQxMg9/AfWC8TMcj7\n", + "R0dH8ng8xtRjV6TGjcViarVaJrlnJ4MoNQ4posZgMjk3N6disaiTkxOtrKxYElSr1bJhDdg5dXmh\n", + "UND7779vOzluoUCVCAnGTxhKA04YnJl4LzTJUGl9Pp+2traUSqUM60bjiAL8448/Nm43jEHqZBTc\n", + "N7lu1WLGzIXdmKw/dhGv12uKB6/Xq3fffVetVkupVEonJycKBAK6c+eOJFlIYywWU7FY1MrKis7O\n", + "zozMRKkCRk19S22JEIAwdHLyGo2GWQZMTk4auYldeDgcKpfLaW1tTaVSyVCF+fl5ayYfPXqk7e1t\n", + "LSws2EMDbkys2+TkpNLptLrdrpkyhkIhzc/Pa3Z21rw77t27Z4oQdsZQKGSKG1QyfHfsrNTMkJaY\n", + "4qVSKfV6Pb148UIbGxsqlUomCGaIRdgRuzcKoLW1NT179uyN7/+tKjMcx9GLFy/UarX08uVL2xUx\n", + "KkGDRuYGam74wXjIcQwnk0nDQMeDa3q9nvENKpWKKUCYLDJhG/euYDrJkUpJNDExYdyMUqmki4sL\n", + "3b17V7lcznyXJVlmH9xov9+vi4sLvXz50thpqEowIOz1emYFlkgkJMlcQvHzODg4sHID1yKGLHjv\n", + "lUoltVotbW5uWoMKDRU3JcbzEPTpHegPoAigAD84ODAfQPd1NPT6+vqN7v+t2pld19Xq6qqmpqZ0\n", + "fHxsVlegBtgDXF5e6u7duzatw2qLUoCatFQqSZK58WAqjhPnaDRSOp22KR91KLo4ak90ewwriGAI\n", + "BoM2WPD5fObNkcvlzCim2WxaMiociNnZWcPF79+/b6JXEBwI77xfGjDw93HUJxKJWD43vBHeDxku\n", + "GNjgkMruih0Y5Qw7NjESjuMoHA4bp5nvdzgcKhaLWdlFljbf95tet2pnlmQDEnY+HInI3uPIh7zO\n", + "eJcRMpgvjQ6TL+RUDCN4ABgUINSEtwFKMhgMrHOnVod8VK1WrUypVqvmu4aamsULhMZrM1WDozEY\n", + "DJTNZo07cffuXUMtpCsOSTAYvGYrO276uLS0dK1koJSiacOEkcaU75WHA/4HwlfkVzSmNMxwpply\n", + "BgIBQ5GIobjJdasWM7TJV69emZ4MXu/k5KRxG2ZmZmwUzPgZNhwLDiYbqgoom0+fPrVhCqE4z58/\n", + "V6VSUb1eV7FYNA7C8+fPDXaC/zw7O6tCoWDSKLzlKHm2t7c1Nzen9fV1I9VTo+/v7+vly5cql8ua\n", + "mpoyeytJ9nPm5uaMu91sNs0v+uDgwIYcNKTn5+cWK0GzWqvVlMvlzIc6n8/bAsYWAfgTHBoFD8Mg\n", + "fPZ6vZ65e3Y6He3v7xunut1ua3d312YAw+Hwh9Dc+NXtdrW4uKhEIqG9vT1jiyHTka4w3EKhYImm\n", + "0BNpDEOhkCWxBgIBW4RwoHGgpw7ErsDr9SqZTJqk/+zszCISOPK73a6q1ap5w3HUExlMXdnpdFQo\n", + "FIzrAYa8tLRksRCQ93E9hTxEHBsstXFjGxY+WDGG5PwaTH1+fv6aoxHoTTAYtAaTB7bdbst1XYPw\n", + "CMoMhUJGzIItB0zJ+56bm7s2PcVM502vW7WYOdaxiR0MBkokEmaKCHAP9ZEjsdVq2YLD1gv3+NPT\n", + "U6NEQtRBSMoIFlNuKKCtVkvxeNzIPSwGeMncYMoaBKODwUDdbteSnGgiPR6PsetYoJjQEEEsfeIg\n", + "NBgMzHeO3EOSnhjeUBYh6yJmORKJ2HhZkrkiQaxnikmuN1Zo5JJzRSIRbWxs2MgaByWGK3BoGNn/\n", + "0Dfj+1zj9E2spCCzMLSAOM6xSNMEdIZyYnyQwcJjLMuE8fLyUrlczky7yfTAplWS1Y2MiTGcwTJs\n", + "NBqZ6mN8gcPHQKVN6TAcDpXP582yq9lsqlwu2zAG0hAXbMBxYny73bamEcSn0+moXC5f46x0Oh2z\n", + "QHBd1/gu8EwY8ZNmBcEKXgg/C/iN/BWStXq9nsnOwL/f9LpVaAZfGPBbIpEwwlEwGLTdDb4uQlRJ\n", + "tsij0ahyuZyxylKplNlhoaR2XVfhcNgmhjDfRqORiWA//PBDra6uWlOEhVWv11MymbT4CJh1i4uL\n", + "isfjxogjAQBXJRYjNgHEp8F847RJJpP68MMPDb9m941EIjo9PTU7he3tbT169MgQD6BJDMj9fr/i\n", + "8bipdIDpeNA4JYigazQaJmglb/wrX/mKMfYKhYJWVlbs5Op2u4pEIgqHw4buHB0d3ej+36qdGYyz\n", + "2Wwqm81a182oFLfMaDRqZiePHj1SMBhUr9ezXSIcDisejxtRhiMfiT5cYEk2FQT2A79NJpPa2tqS\n", + "JIMD4Q67rmtoADDf0dGR8vm8qajhSFMS8NonJyfmm0wphAMof8apcnx8bEc5C4UyLJVK2WdCKQ4N\n", + "s9PpmIiBrGwml5IMkUEkwGmGb1yz2bSyDt+54XCoQqEg6eqkQB8Zj8fNBgFriDe9btVippZLpVLa\n", + "39+Xx+Mxz7iDg4NrBoHsQjR4iUTCdl9UFoFAQPv7+1YPUlZAhzw8PNSLFy8sUD6dTl9TWaRSKSUS\n", + "CXMSJccEUSsEJEoX13WVyWSUy+UsPJOpYjAY1OPHjxUKhUwlTi4IgxssdlnkeOKxq09PTxtezpSw\n", + "0WiYqSQMQGwUUGnzOoVC4ZrrEpndKNa73a7ZGYCZz8/PW94h7vzjfiIHBwfa3t6+Zoj+ptetWsx0\n", + "5gxKMMkOBoMWUwaJHg7E3t6ewuGwarWaDQSAoRzH0dramnmnnZ+f281qtVpaWlpSLBaT3+9XpVLR\n", + "1taW6QWhW/IeQDgCgYCazaYqlYoWFhYUiURMI7i0tKTd3V1NT09bQtTS0pKazaYk6cmTJxoOh0ql\n", + "UvL7/TYup5nNZrMKBALGGcZ9qdFo6PT0VLVaTUdHR9fQHFAOgjF5SKhpx8fcaAuhfhILhws+BCJC\n", + "jjgdYBvOzc3ZePz8/NweOgY5PzSBGbtQLAcCAe3s7Ei6UkDAZa7X6zo+PtarV690fn6u7e1ta0qo\n", + "7RqNhmq1mhHZyScZt7yFoYbxIGNyCDcgAtS4eKnx0OAiBAGqWCxKkgVB4q5Uq9UstAaONcJRvCqm\n", + "p6cNBwbNgPMMjoxam9ra6/UaRMhkkQcYxbn0yQCqXq+r1Wppd3fXsHkebumKeovyBRwfZILyi3qd\n", + "soUafDzGeX9//2b3/0b/+gfsajQaVoNiLgjZxuPxWOhkNBo13wZwXJ/PZ0qOhw8fWpPjuq6Wl5eN\n", + "dPT8+XMjzkB9pDZNp9OmQaR2xm6WJotdaH193bwr0um07d7Hx8c2Wt7Y2DDCEg0rECEq6Uqlovn5\n", + "eSWTyWvuSaRo8X1MTExoYWHBYDxJRrx3HEfpdNoek5NwsQAAIABJREFUjFgspm63a9/PaDSykM9U\n", + "KmWm4eOMOtAXhjQzMzMW7zw1NWUiCMdxjB9CU57JZCRJ9+7d07e+9a03vv+3ameu1WoKh8PGe2Ch\n", + "wpUAtoO8TiY2scKhUEihUMiUw9Ink7V0Om0WAOxO7CrjtSi7EKUGIe8Q4ceHL/CeaZxAKrrdrpUI\n", + "+/v79jnW19fN9wJcGPNx3IT4M/IHiS/DCgEvjYmJCQtsh6sBnIlvB7g4nngYO4KcwPlGzQKvgwEJ\n", + "9gcXFxcmskXjOD58wo0VUtWbXrdqMQcCAZ2cnFjeBrUtO0UymbT85/Pzc9OopdNpQwPK5bIODw/t\n", + "JpJGWqvV7FiVZDcHTLper9sNgt4I9Adsh9l3p9O5Zh5OgwnmCy7caDR09+5d833+6KOPjMTjuq4O\n", + "Dg5s+NHr9Yzn4bqu4vG4/Tz4HdVq1ep/MgVZ4FBXCQjiIYBQNK6bPD8/V7fbVT6f12AwMHSILEDK\n", + "BzLGyTCMRCJWUvR6PZ2dnVn9X6vVLAXrTa9btZhhniEZAj5jiEJKK/L9Uqmkzc1NG8uy63W7Xfu3\n", + "s7OzJlfCHTQajdpQIZ1OW629u7trpwD0U3ZMpnsQ6eEu4PPGIsI6l9p2OLwKXS8UCgYBomaB7smk\n", + "kkaNupnFmMvlrun2oMSCfBwcHKjdbqvRaFgdj1RKkjkaMUJnjM9IW/qE6M9ixuCcqWGr1TKy1LgL\n", + "P/EUUGBvct2qmhnrWIB/eBPseqlUym4+Zt0/8RM/YclIuBnduXPHXCuLxaLVwpQO1WpV6+vryufz\n", + "Ojo6MkgtmUyq0WgYR2RcnoRKA5kS07JIJKLd3V27yfgrs7MfHBzo7t276nQ6+tKXvqQnT57YeDge\n", + "j5siZXJy0nBcxs8LCwuGb8NUwzcDD+lWq2WOSvQJ4M7Ly8v2oFM/VyoVQ1sgaNVqNTv1kKKBtGCn\n", + "AKTIWB+ivyTD3H/yJ39S3/ve9974/t+qnRluBrXqYDCwY5XjFII9HIdyuWwumhB/yA4cjUZaWFiw\n", + "UetwOFQ2mzVN38LCglZXV826Fgx5dXXVcFMWNzo+UJHDw0O72djF0gAuLi7ae00mk6pUKqpUKtrc\n", + "3LT6nbqdYzqRSJjWEV8L2ILUt4hyYdsx3ZucnNTi4qJBbKQJ8MCjm2RDmJ2d1UcffWTTwPn5eesn\n", + "4LKAJTNyH41GCofDtrlAf2X0HgwGb4xm3KrFLMkaM75MmiPgJ0k2qm6320ZkR3EC/5lJFna0cHnR\n", + "9zUaDdul4CJwk/L5vCYmJuyhQG2CL0e5XDbEgdIGsxZU3yAWNIZYEhAVPM65HjcER/FNSQJrDjUK\n", + "3tBwLLBAoPw5Pz+3E47GTZINb8rlsvnFoVpnCgqRiMYaMQJqdt6767qmJOd7q9fr14hKb3LdqsWc\n", + "TCbN7Jtuen193VhoyHSQLiWTSWN8ra6u2tBl3EQcw+7Z2VnNz8/bVC2dTmt1dfWaIWAoFDJuBibi\n", + "uAWFw2H7/bt37xqCEAwGjTAfDAa1urqqxcVFmzbGYjFDKGZnZ7W+vm47siQbAnGSzM7OKplMWvg8\n", + "zR3NJ+UMsOD5+blxQhYWFoxmymteXl7K6/Ua0pDJZDQcDg3dgQGYTqetROE1+PPV1VWl0+lrukoy\n", + "WqSrzWVxcVFvvfXWje7/rVrMp6enOj8/1+HhoWKxmO2mSNyZMEFvhKnGDskOCqtubW3NFCk7OzvG\n", + "a56fn7eoBdhpYKdM2MLhsF68eHEt62Q8nw9iE+GTuVzO5E8c1Vjo4jcN8R8/DBJlkfOz88KFoFnk\n", + "/Y67FGHZO86F5iRC5YLcrNvtqt1uGxWVhKxxORenCbj24uKiJiYmdHJyot3dXcOdoXvOzMwYZAgv\n", + "Jp/P3+j+36oG0HEc4+S+ePFCjx49MvdKQstZuDi4Z7NZGxZEIhH1ej2jjXY6HcViMVWrVS0vL5uS\n", + "GB4xu56ka3wISWY8TlQvjRjhPpVKxUbflUpF8XjcGHwHr3OnKY8QnP5eNTS9AYstmUzKcRytrq5K\n", + "kkmpdnZ29PnPf94miODBWGYRTs84OhAIWK3Nd0WTSZ0L24/3IslIVOgn5+bmNDU1pYWFBZVKJTuF\n", + "MFHknuEIxbj8Ta9btTMTxLO3t2e1XrfbtfovEAhYbh1TwZOTE52dndn/ohVEnYKjPcJLjAX9fr8d\n", + "17iKMtJGLgTnGRgNO1vG5RB7qLvhGAMfTkxMWJnBuB2/DeKK6Q0kqVgsGmLApA91SS6Xs0wUxtQs\n", + "aIYvkqy8oWxh9MzDhzKbeDaMKOGlsPvTn0DMAkFCoY6/HdAemYM3uW7VYuamozSBQH5yciKv16tS\n", + "qaRkMmk5Ht1uV8lk0iAiBgNwcy8uLhSLxa6pK2DEnZ+fG29iMLgKU6c5wrzl4ODA0BVGv8T3gofD\n", + "dDs+Pla5XLagenDtnZ0dI7SfnJwYOoK6BQsD6mKI+6VSSUdHRwoEAjbJm56eNvgOohCLj50WwhE2\n", + "CIPBwCDEZDJ5TdU9HnlG6m2n01G1WlW1WrV/2263zYeOBhhBwsrKilZXV63Rvsl1q8oM/CSwWyUr\n", + "r9vtan9/37znUD0fHh6qXq/rwYMH5ubD1BD3TCiWCwsLqtVqlnPHYpienjbnH8dx9J3vfEdvv/22\n", + "5ufnTdlBQA1wITX04eGh+W+gTcRNHuU1DkKoVBiklMtli1K4vLy0Ic3du3fNeIb6l6gI0Amcn/r9\n", + "vpGoUGGT15JKpdRoNEzSRU1NTV4qlcyoEScoyjigNkk2Rk8kEiaURRne7/f16tUrxeNxi0G+yXWr\n", + "dma/36/19XUjsGSzWYOvYHqdnZ1ZAwYpRpJZ1RJVRtjMuK8bdaUka76wGUCgmc1m5fV6TUENkoJ2\n", + "EM82PDfw0wCB4Ne8R+pmhjrg0tSjuGjG43G99dZb5kfHqTE7O6vJyUkj8M/MzBhfghoYWA1cGucj\n", + "8r6hqSaTSc3OzioUCpkahc+zsLCgZDJpDw59CvYIxWLR4tbweJZkzXkikbBS502vW7WYJRleOt61\n", + "x2Ixc72nSSSrJBqNanJyUuvr62ZMAv5KDU4q0nhCEtAYQevo4dDEUeb4/X7zhpZkYgHqdWpHhKe4\n", + "EFFGoAph6IOnBlAZKVGUHjSwSMfwgwabHhee4v3M4GLcmwOCfqfTMTIWLkfY77IgUXdLsoaY7D8Q\n", + "Daab+IcA3xHuCUR6k+tWLeb5+Xm9evXK5DgMHSDDhEIhJRIJU25/9atfleu6SqVSqlQqptAOhUKK\n", + "x+NKJpNaW1vT5eWllQy7u7tGZVxaWjIEBGI7nfrFxYUNCwiDRzdHHjXTM+pjwoQkmT9cMpm0h4tJ\n", + "JQ8jDvnU6ZjDrKysmKAWfBkBLIuJGp7QeIYv0idBR3A3Jicnlc1mFY/HTdGOMyjTRdhyDHfIaykW\n", + "i1byABnCp5Zk6BNayZtct2oxS5906Oj9GCRAfEH9zM0olUp2nI/voHy57DQ0Rn6/35od/g3HJkQi\n", + "VODIhjglxp3hKUvAiDFhxL+t3+9f88bgs7GYeGgoncgQpKHEHoydniBOdI4wCXnQ8PdAHQKRioFO\n", + "sVg0PSETPH4+tTiuRxCfeEB5GMH+aaylTzD/cTeoN71uVQPY6/W0sbEhx3FsqMCxCiQ0GAyMnba3\n", + "t2ewFLsgQ5JwOKy9vT2jPw4GA62urqpcLhuMxO/t7e0pFovZDWLRQXnEUouGNJlMmpMQixlS/8rK\n", + "iilY4GTDU8YSDLMXIo2npqb0/PlzjUYjO31w/8QCIR6Pa35+3miyDJRGo5ERgYAfiRxmkoqAdXd3\n", + "V+l02pQ5RBsjICYyIhqN6t69e8Z79ng8Oj09ValUMo5Kr9fT4uKiqeeBTm9y3aqdeTxSjIhc3Nzx\n", + "O/N4PAaN0X1T89ZqNeuq9/f37bhmR0KxzOiZ+hU9XbPZ1NOnT23Awa7FzinJjmheh4bKdV0dHR2p\n", + "2Wzaboq6GQ72+IgYfzYml8vLy8ZJZqLGCYUXHBO3eDxurqVwqsGtcXYiQiMejxvllN+LxWLG2Ybg\n", + "32g07LOdnZ2pUqnYqXJ6eqpms2mqd8oSeN3g/j/cmccudhlqwng8bg0M1gMYm/T7/WtSqk6nY9ZR\n", + "77//vh31k5OT1vDQKFEzY0RI4+Tz+bS0tGSqZrBdJmqQ1TmWV1dXr5USGCrC9SVokqkj74dFzTSR\n", + "qRrcEhhsDD7QGPr9flOQc2LAM0FZAurg8/m0sLCgSqVi8W8MbYApEUCQsDWOEIEtI9TlhKP5HI1G\n", + "unPnjnl8cL9uct2qnRkmHGlMTK0uLi6u8X4hi2P4R8TX+fm5SqWScWoxDUQ1AT6KCyjNFDvk8fGx\n", + "7VRg0HT046y2TCajqakpPXv2TB6PR8Vi0cSpsVhM9XpdW1tb5n3MMEWSmc+wmCDQn52dmc1tKpUy\n", + "lfo4BjwajQzrpUHDdQiBqyQTClDuIHQlXPPVq1eGRzMVnJ2dNUgOD2dqfcS5SM56vZ6mp6dNZ0jT\n", + "+8Ohydh1cnKiSCSifD5vhjDo/cZDKWlgtra2FI1G1Wq1TMSJETk7yatXr5RKpVQul82nji8dp6TD\n", + "w0P1+/1r4TbRaFSlUkkLCwva29uz3R97g/PzcxOHEizEovX7/eZJgeJb+gQ7rtfrNvAAEmNUPRqN\n", + "9I1vfEOJRMIguWq1aq+P4TcPRL/f19OnTxUMBlUul62kITGAU2QwGMjr9erk5MRq+UajYUKCcSMc\n", + "pqUkTUFz3d7etrqcDQfr29FopO9+97s3uv+3ajEDHVWrVX35y182emM0GtWDBw/0W7/1W9Z0ZDIZ\n", + "y62DmkkE2dzcnJLJpClMwKTZpVzXtQkWJtxAXNlsVv1+X4uLizo4ODBJlMfj0aNHj1QsFo0Aj08y\n", + "tex7772nQCCgFy9eGCpx//59C9jMZDIKBAJqNBp6+PCh4drVatVKkuXlZbXbbWUyGbVaLb311lt6\n", + "+vSpWYoxoACtmJ6eVjqdNjcj1DR+v1/vvvuuITaIAegVJCmRSKhSqWhjY0Pb29taWVmxvzs5OWkZ\n", + "JfPz86rX63rnnXes6fb7/YpEIubpEQqF9M477+i3f/u33/j+36oyg0WGYz4k9LOzM33ta1/T7Oys\n", + "7UbtdtsciZrNpvL5/DUTxZOTEz158sSy8SgzSJzCSPvu3btGvBkMBjo/P1coFNLm5qYtjkAgYOhJ\n", + "u9223ZqckKmpKW1sbKharerjjz+2B2xxcVGVSkXPnz/XysqKYcEbGxs6ODgwLJsd2ePxKJfLKRQK\n", + "qd1ua2VlxUg+IC2gI5Is0erly5cm6K1WqxYKVCqVrKwaFwFg7HJ0dKTZ2VnlcjklEgnLHSfMB0SG\n", + "YQ/oED4fOzs7FhDUaDR+KGgdv4bDoblwVqtVNZtNE7biGwcTrNVqmUyeAPOpqSmVy2Vtb28bK0yS\n", + "kXywERhPFKWenpiY0NHRkRmOV6tV4+2yoOBFoL+jXi8Wi9rc3DSPDORLjUZDpVJJ5+fnJnWCNce0\n", + "jKy+jz76SJVKRfl83ohGW1tbNpIH48aajHE7JRYi13G1Ry6XU6VS0fb2tolqKdcgUVFKYAscDAZ1\n", + "cXGhw8NDU8OQMUiPQbwzzqLhcFjT09NaWlq60f2/VWUGU6vt7W1z0KGjd11Xm5ubBkvxRcKYg7wP\n", + "moAxNgYnkHZYyBydExMTZtAC0f7i4sLc6i8vL80bjoHH2dmZGo2GHjx4IOmKP8FwolQqGYRYLBZt\n", + "CIFZIpHJoVBIkmwYEg6HbTgCLDYYDLS3t6dAIGCMPmpcmH7wIWhYSZVlYY371DH8yWazymQyOj8/\n", + "N2dTuNJwLVjoL168sNE28CVOqPl8XsVi0RxQfxidNna5rqvFxUWz0fJ6vVpaWjLTvsePHxslFE85\n", + "bFrhaDQaDUUiETODAcqLRqPKZDLm1Xx+fq7l5WUL2ZGk1dVV4x1g0u3xeOw9YU3r8/ns9TBXgeRD\n", + "4A11tSSrz+FjU/JQpzNqRwmDRzMSr3w+r0ePHqnRaCidTmtnZ8dc/c/Pz22kjx8eE9GNjQ2bGsL/\n", + "CIVC5iOXTCYNhx43YZ+ZmdH9+/d1fn6uhw8fGlaPNx0CAcI0JV2btr7pdasWM4YjuPOcnp5qd3fX\n", + "AhRxPCInBKgOWqLP5zNRp8/nM6wUFQlWWPV6XbFYTHt7e9f8JxhlZzIZbW1taXFxUbVa7Vr5gPcG\n", + "devCwoLRRCWZoSMuptLV7pjP522BEsa+vr5upH8GLLDsGKVTwyJghUiFema83GL8j9UWAyG4yel0\n", + "2qBH1NW4H6G+wWw8l8tpcXHRdmJ25nFSEqcEYgBEA2963aqamYEBypLxXZLaDG4FRzIG5EiE4Cww\n", + "jUK2D6WRXYppI68xTrPkhrMLESYPnwP/NpTg0lXHDwRHUBC7NX4bYMzT09NmDcC4GBIRsiUWsNfr\n", + "NVoowltG65KMoTfu98wuSTgoZRaZLQxqgC+xtB0MBlaiQayampqyMTx2YVgN+3w+k6zx729y3arF\n", + "HI/HjZEG7bBardrCbjabOjg4MNJ5sVhUJpOxkTYO+Nvb26a6ZtfhhkLCIR4CV85er2dNFXKmdrtt\n", + "XhLAeoxxJdnRDHoAAw4eBkHqPECVSsXgPKwOUJf4fD69/fbbSiaTyuVyCgaDyuVyqlarevr0qY23\n", + "MVAkywUUA0cnRAOocUhT9Xq9JnCQZPxjsklwZmIYhVodOwLYfjTNDHZozpGk3eS6VWXGxMSEwU0r\n", + "KyuKRqN6++23TZ6D5RXZfUtLSzo+PjZpVCKRsFIBvJkdlx0JP2HHccwbGUI9tTYNITwRZPZ4MwcC\n", + "AStfJNlxzUPT6XTMGGY8FwWh6rjjJiPp6elpFYtFw2slaXl52XZ4HDk9Ho9KpZI8Ho9CoZAJDPr9\n", + "vrLZrCEvvV5PqVTKyFIYvUhXPBdsAxYWFhSPx014gKIb43DeIwsd2RrUUUSx0WjUxttvfP/f+F/+\n", + "AF4Q0sF5O52Ovve97xk/oVqtql6vW2xupVKxnDpJJj/66KOPbLQ9HA61s7Nj4e0sZBYinGLqWBQg\n", + "uHsSwTBO6YSFxy6G0Tm4Mw7/lUrF4seoYfn3QG2gDHt7e1pYWNDZ2Zm+973vqd1uq1gsql6vG76L\n", + "KxOG4L1eT6enpyoUCjo5OTECfrFY1OXlpQqFgvL5vH0OfOGgDcByY3JIuUWQD73BOCGrXq8b2gRe\n", + "PzMzYxYNN7lu3WImYzqRSJiCGu0cR/3MzIy5djJpc11X5XLZ9Gho+uA1o9rArYd6OBqNand3V5J0\n", + "584dDQaDa8LTi4sLpVIpMxAHzuLYnZqa0vz8vMLhsM7OziyBCYNC6n0QBwwXKXvOzs5sdx0OhwqH\n", + "w8pms3ZyzM3NmZ3A8fGxDZZGo5EikYipPcbRDyKTSQUYjUba29szwQN8bVCcmZkZw6jZnXE9IrEA\n", + "O9xUKqXV1VXNzs5aiTU5OaloNGrigje+//8mf9lxnElJPtd12zd61c/oopnr9Xp68OCBqtWq7t+/\n", + "bzslLjqxWEyXl5eanZ21YMdyuaxwOKyZmRm9/fbbSqfThkhAQoejkclkVKvVzAfi3r17NiHDMJAY\n", + "Bb/fr9XVVSsLgK/wiFhYWDCr2bm5OZ2cnGh9fd3QFDjAPHShUEgnJyeKRqPKZrPq9Xr2v51Ox+p/\n", + "Rt3AdJREBGhyOgSDQSUSCUMTHjx4YIt9bW3NHv4/+2f/rIW4wyQEIqR8I/QSuzJQEHSQ8/Pz9jDg\n", + "WgrRaG5uTnfu3NHXvva1N77/f+Cj4DjO33UcJ+g4jk/Sx5JeOo7zX7/xK36GFwgBEnh8g6n1RqOR\n", + "qZilT+KJIeBQd1J6IKfCzZOdo1arGaTHRG58V4FiCl+a477dbtvuzBEPEsDi8/v9FolAljZTQ/Dk\n", + "hYUFKxcYyrA7MrAA2SgWi/a61WpVPp/PLAWoc3O5nPkw8744vcDZ9/b2VKlUJMkYfvl8Xl6v1+wK\n", + "mHoCc2IGSSMNH3p6etpw62KxqE6n86/4X7/J9Wn29Yevd+J/X9I/k7Qi6T+70at+RheKEfi01MJg\n", + "n/jHccQWi0Xt7e1Jkg0PsBxgIUBrhAbJkARuNFwHOnsoleTqAcUx5Rt3l2cBIkbF7gt4DGol4gDY\n", + "bozF0fV1Oh21220zLWQaiFSp1WpZA0qTjGP+eMoUAyV4JuygXOOGMyhuKEMYlvD5eMjYib1er0Uo\n", + "YyDp9/vt9UBJbnJ9msU85TjOtK4W8z9xXXcgyb3xK38GF+UEEncYc6hLJF07chcWFvTOO++YoBTB\n", + "6Y//+I9rNBpZ/QzKgS0rZCPootls1hY2+XhQUDkFwK2B1hh5s7jAXAOBgNbW1q69d6xqGV0Ph0Pd\n", + "uXPH/D7AwiHL83qhUMgUNYhPMXxkUfr9fq2trRksCcrh9XqNc8J3kc1mFQqF9KUvfcnyUeB2SLKY\n", + "NOwP4HlsbGxYc0gpRynDgg+FQjc2Tvw0NfOvSDqQ9FTS1xzHWZF0M0DwM7pwITo/P9fu7q6CwaC+\n", + "9a1v6Ud/9Ee1s7NjyVGNRkNf/epXdXBwYP4XENJrtZp+/dd/XV/5yldscre9va0f/dEfVbvd1v7+\n", + "vkFZhUJBmUzGDAr39/f13nvvaWZmRrlcTplMRtlsVt/85jd1//59mxYi6sTIGyQgHA7r4uLCnOsR\n", + "B1BrDwYDPXjwQJeXl/rggw+sbsachViyr3/963r8+LFFyOHk1Ol0tLu7aycLusO9vT0jy4NaLCws\n", + "6Gtf+5ru378vj8ej58+fG2nq8vLSaKfn5+fa29uzkwtvup2dHX3uc59TPp/Xhx9+aDK0arWqRqOh\n", + "5eVllctlzc/Pm4XBd77znRvdfweN3Kf+B1cF6NTrHfoH5nIcx/2Zn/kZG3KwG5dKJWUyGZXLZdVq\n", + "NcViMcukgxA/btDCIiMBCWdOJEfVatXQEca0kHQocwimxMibB2Z6elqVSsWQEgQBHPdg4EwLOQGk\n", + "q2M9Go1a/Y9hYjKZVKlU0vT0tOr1ujKZjHq9niEY+N01Gg2FQiE9ePBAh4eH18oMJpypVEpHR0eG\n", + "L+fzeVOQFAoFK6lWV1dt3P7WW2/ZRoHxOY6ed+7cMSLSYDCw8ofvrNVqqVQqaXFx0T7Hr/zKr8h1\n", + "XedN1sAfuDM7jrMr6VuSvi7p667rPpf0A7WQucYd8V+9emV2rPV63XYvgs3ZUWGP+Xw+80A+ODiw\n", + "iSGEdLBe5PfYaY3Xw5QP7XbbRr0gHgTBY1VFmCZ0yng8rmKxaDUu0iZifsFjoazm83nFYjGLESaI\n", + "h6FHvV43K4JWq6WNjY1rhurU4zShWAgMBgOVSiX5fD6DODGkGadvLiwsmAxL+iRQlFE3r4tTKqaU\n", + "ELtAiHBXgl56k+vT1MyPJP1vkqKS/gfHcXYdx/nHN3rVz+hijIq4k8YEISocAXYHJFWYgY9GI8vZ\n", + "4z+OzfEAHbSAKysrymQyJqWiHq/X6wZZkfREcynJCPxwIaLR6LXBiHT1YFLnX1xcyOv1WkYgTRm2\n", + "X9iDjUYjLS4umuZvPMxnOBxeS62lSWPnnZ2dVSKRsHQtvjeaVTwwELvyWYDnAoGATTah2PKQU6/j\n", + "N02/QFnI93/T69Ms5ktd7cRDSSNJNUmVG7/yZ3BhLzAcDnV0dGRJpohJga2oXaPRqD766CODnsbh\n", + "MgYY0WhUuVzOEIGzszNr8hCwglocHBxY/Ytx9vHxsdnXMinETRRjlXK5bLwLGr1ut2sWr6TGMv0D\n", + "m6V8IOmp0+kYf6JWq5kRJA78LCgmjIy5MYDBEBI0A5Eru/yzZ890fHys4XCoFy9eWHxEv9+3GIfh\n", + "cGjeHBD+KbNQgY9GI21vbxs2jdsopd2bXp+mAWzrCl/+HyX9Ldd1bxZw/BleGK/0ej198YtfVDqd\n", + "NrPDRCKhcrmsVCplqMP5+bneeustxeNx4w0EAgEzCccHIhaLGQ6cyWRULBYVCATMwQdoKx6PG2cB\n", + "HgX5eKAY1Lqzs7NaW1vTxcWF1tbWNBgMbHTNZBHXUZw4KWP6/b7eeecdY7/hjg93RJLtntTY4Mjv\n", + "vPOOcrmcPVxM6nhwcB0KBoP64he/aMw7ThnU5YyyOVUQKqyvr5sPx9nZmXw+n+7evau9vT3t7e2Z\n", + "sQxmOB9++KGSyaQZM97k+jSL+T+W9Cck/VVJf8VxnG9K+prrur95o1f+DC52AVhaHo9H29vbevjw\n", + "oQ4PD804EecfLGPxlaD5+fa3v6379++bEvni4sJYbNSweE8sLS3p8PDQUAqiziqVih2fqL7JBOSI\n", + "HzdEJ9i9XC7b0AfYamtry6y0Tk9Plclk9OTJEz18+NBGy/Pz82YVViqVDFk4OTkxK7BaraYPP/zQ\n", + "6npOiidPnpiqptVqKRqN6uLiQltbW8pkMrZj+3w+1Wo183JmkYPIzM3NWaJsvV7X+vq6Tk5O9J3v\n", + "fMdOQp/PZ8kAT58+NTKV3+/XN7/5zRvd/z+wzHBd9/9yXfe/kvSfS/qnkv6ipF+/0at+hheiUtTH\n", + "1MnjvGK4vpOTkzo6OtLKyorhqhiTo22DTI4ok4YxHo8rlUoZooEyHK5yIBCwwcm4uxBORpB3OKaZ\n", + "usE9Hsdfl5aWzNwGhh0DDZyO9vf3bVERKeHxeBSNRlUsFrW1tWU7+Gg00t27dw01YfHCN4GHDKtu\n", + "cnJSzWZT5XLZegmGIoyyQXJwB6WcgArK73U6HS0sLMjn85lglzKQz/6m16cZZ//D14jG/yzJq6vp\n", + "382r9c/g4sgl9heerHQ1HSRllAUZDAaVSqVUrVaNcQeRCPYd0zJ4zBi8zMzM2ESLnGomXTDHfD6f\n", + "TQ/hNAyHQ6sTEZdyJCMuwNqAEwYUArZaoVCwYUa9XjfOBGQfTF3QREYiES0uLlrje3Z2ZoFAYM7I\n", + "tcbVNxi57Ozs6Pz83EoLOB7AcODYPJCSzLXUcRzjsbCYSQmo1Wq20OFS3+T6NA3g35R013XdP+W6\n", + "7n/ruu5vu657M4vzz+jCOBvZOugExB8QhnF8GPyWKx6Pq1armamh1+u1rEBonFjLer1eSZ/kcdD0\n", + "kd1H6hTlCfo6iOh4zGH7Ct+5Xq8rlUrZLogNeCw8AAAgAElEQVS5TaFQsIeLnzU1NWVc4ZWVFUMr\n", + "BoOB9vf3Va/XDa5rNBqqVqu2YDm9xmN/m82mUVkrlYq63e61NNZ2u61wOGyeIixqWICIdxEUtFot\n", + "RSIRHRwcWMwbRoyQp0Ch/jC4GU8k/Revd+h/6DjOT78eb//AXbj/xGIxrays2JGJ6iQYDJpDKI0S\n", + "quDJyUlDHfr9vqmf2aV8Pp8SiYQNBxhPM+iQdC2x9OTkRPF43LDUcZsuJPlo/DY2NqwEikQi8vl8\n", + "Bl2xW+EC5LquEomE8aXBx1FTp9Npe9+xWEzxeFzLy8tmWEieYbFYNH4IavN0Om1xE6hdKJUQBnM6\n", + "0AeMfw/EOMzMzFzLZuH98LNQ80hXQoNIJKJoNGo9xJten2Yx/6+SviDpf5H0y5Leff17P3AX7kPk\n", + "0bXbbQP6ic+VrjpwZEhYZ1Fro4JGesWuAZkebjFMNgYFXq9X6XRax8fHlgHCkYq6mlNhdnZWzWbT\n", + "rAsQw+7t7dnRz3iYnZNAGwYelC88hOScYJlFP3B6eqqdnR3LYGG3h7M8PoxBqAuNFvErpQTWuuPJ\n", + "t/Qgkoznzfssl8vGL5+cnLR8FcdxdPfuXbNQQKp1Uw3gp0Ezvui67ttjv/4tx3Ge3uhVP6OrUqlo\n", + "aWnJGirAe3a6cDgsx3GUTqfl9XoNVqLOJKB9fHDgOI4x5SAiDYdDa5jgCxOnOx7T1uv1bHQNzg3f\n", + "eH193RAM1BycBrwnhKEQjIimIIAH5GZ6elp+v99chOr1ugKBgLLZrNndQpLHUZ/xOoMTSQb1jYt1\n", + "edCAPXFA9Xg8RtACu6fkoQEOhUIKBAKWq0hdf3FxYRtENps12PMPIzrt0nGcDX7hOM66rgYpP3AX\n", + "ZQCIAmJTal+YYi9fvjQzFnbRO3fuWLAPI1oSq5rNpvkeM1XMZrOW/wFhKBAIKJlM2kMC/4HxNgrx\n", + "drutSqVi1gZEl0FgBzWZnZ01jw+EuugNB4OB4cHEU6TTadPvMQGdmZnRs2fPbKfl4VpZWZF09eCM\n", + "/yyEuKhXsBNj55ZkJwzNLLwP6nl415RomUzGQj1pSAOBgNbX1+0hpQe4yfVpduafkfQvHMchcn5F\n", + "0l+60at+Rheq54uLC3OPJ7Ac21oUI+wU7Lj4nVFzM3LN5/NaX1/X1taWwuGwxYvRCBKbAA/5448/\n", + "Nlck5PjIryDHY57SbDYNvcDUhZvKTk4TxaQRe15JFqg5MTFhYlRscSmTpqamtL6+btO8cVsu6RMn\n", + "I4Sl+HtwCgQCAfOci8ViVgZRe/PvhsOhjfvhdvNaW1tblnTL7g0ve2dnRxsbG4rH4/awvOn1aXDm\n", + "35J0V9Jfl/TTukI2/sWNXvUzuiYnJ6+hApj/4Q/XaDR0eXlpTQ7qj8vLSxu99vt9G4hgmHh4eGg8\n", + "CZQS2OWizmaXx9YL8vp4/BmiAUSkXPh2jCtY4AqzKAnrxC631WrZwwvUxt+p1+v2HyNu+MNgv6Aa\n", + "/X7fKAAEc5IQUKlUjIBUq9VUKBSuiXJLpZKdeM1m00oHIMVAIHAtPZamm/4EvB5K6f7+vm5y/b47\n", + "s+M4/6GuSPiOrpPxN14/tf/oRq/8GVyMbi8vL/X2229rMBhoaWlJ6XTamg4sVfv9vvlM4I8GC45S\n", + "AcL+j/3Yj1lgfDqdVr1eVzabtag1auHxvDvc5hOJhGHR8/PzCoVC8vl8SqVSFmsMlLW2tmYnCF55\n", + "aBaZHHLEJ5NJcwKC7ENdOzMzo0wmo+fPn19LsyI/vFqtanFx0Wr+xcVFtdttK03gayCMDQQCWllZ\n", + "sbgLSfY6w+HQ6JvLy8tmfr6+vm7aRYYuWOAyGWX8jqrmvffe07Nnz974/v/rduZ/5/V/f1nS/y7p\n", + "P3n93996/Xs/cBcWtgxP4Bng3bazs2OcW3ZNwPpWq2WTMxYNu+7e3p5BZVNTU3aT+/2+0TPZlWh6\n", + "gsGgDWcQjmLYQtcOGoHhIMYzoVDIOMWXl5fK5/Mm8R9n5925c8e8PUAqGHS0220tLy/bEGM8FBPb\n", + "LgzE9/b2bGGP8619Pp+9Byx8A4GAPB6PRTLDzgsEAsrlcpqenlYmkzGjSGifEPs9Ho9xQSYmJpTP\n", + "5027+G/Krf+91++7M7uu+xclyXGc39CVDrD0+tcLkv72jV71M7oqlYqSyaSVECAHBM5IMoYZpoGN\n", + "RkPJZFJTU1MWAww3gsECJQPBkAxUUGBLMltclB08WIhsqSNBRHAqwv4ABAYIDkhQuoISG42GxRrD\n", + "UvP5fMbNQLoPOQrMnCnhxsaGBcjTsJHPAmIBUT+fz5utLn8nGo2arx0Kc3ysa7WaFhYWrLkDosNg\n", + "cRzqk2RUgVQqZRAm9fdNrk/TPmYljbOmK5JuZqT7GV3pdNo4tHAvaM4wXEHrRo3YbDZtosZuDjYK\n", + "LopLT7fb1dHRkR318HQhL6FgwQgR/gVKC8hAKEDOz8+ttse8cGJiwh5EYKyjoyPzNwZflmTlC2Y1\n", + "+NAhTn358qU1i1A7cWaCv8L7Pzs7U6lUMtHtzMyMeULPz89re3vbhiRwj4EnM5mMhYLCN0H4wJS1\n", + "3W7r7OzMMPbl5WUTQdB//GHEDf+mpP/HcZy/6DjOX9IV2eg3bvSqn9G1tbWlUqlkit+TkxO1Wi3b\n", + "mVkMNHzJZNImhChRMPIGXmMkXSwWDYIjehi1Bg2jx+PR0dGR7V5wfyHTHBwcSJLBhghG2ZHZDaem\n", + "psz1B1jP7/erUCiYRhAsmiYN3gcpAJJs4uf3+20xEXLfbDYlSYeHh2q329rb29PKyoo1qgx3Wq2W\n", + "jo+PTUlDY0mJAg+EOpgGkvg2fPFg1x0eHqrT6dgw5vj42B4O3tObXn+gBvC15u8/kPRjumoEv+a6\n", + "7v95oxd1nJ+T9J/qiuz/sa6gPp+kvydpWVcC2v/Idd3W2N//y7oSCPx113X/+ff5me5P/dRPaXFx\n", + "UdKVjGhpaUnFYtG8NAqFgk3QyDM5Pj7W5z73OYPNyOWDJUZHjmvl7OysDg8PLUN73HCRJoudmweF\n", + "cTYTQyiV9+/fN3YctExSVsdRF4hHNEosHCaDKEn4XNT7eGdsb28bHPn5z3/eRKXhcNhKs1qtplQq\n", + "pVKpZMGY7My8TjAYVKVSUTabVbFYNEUP/iHkpXi9Xm1vb9s0dWVlRYeHh6pUKuaSBEvu29/+tjKZ\n", + "jJUnP//zP//ZaQDdq9X+j17/d+Prtbr7r0h64Lpuz3Gcvyfpz+tKnvUbruv+947j/DeSflbSzzqO\n", + "81DSn5P0UFJa0m86jnPXdd3R7/3ZKC9Go5F1/+VyWaurq5Z5DUqB3xrEpMvLS+VyOUUiEf3u/8/e\n", + "m8RGmqZ3fv+PjGBEkIx9j+C+JXOrrF4wXdOC1GrBGvukMWADvowxNnTTwePlYBuQL9bFbWAGXgAL\n", + "sC0bmsPIkAFjoIPGGEEQ0FZ3Cb1VZlYWkzuDZARj3xgRDC5Bhg/M31PBbnWjkVRrWkR9QKOyM8lY\n", + "3+99n+f//JePP9bS0pLVcqiwHccxmyp2H+rbwWCgZrOpRqOhubk5G5H7fD4dHBxYfYi5zNjYmB3N\n", + "uF/m83kbN4fDYR0fH1vO9M3NjRYWFuwxX716pUePHlnjR24htSo3yPBd9C/ko52dHXPhZ1S+ublp\n", + "ZU2j0dDR0ZE++ugjvXz5Ul/+8pe1tbVlnyelA3rG6elp5XI5czwdHx9XqVTS4eGh0um0Go2GhRJh\n", + "w9VqtXR6emqNbTgc1tnZmba3t++1tn4eCui/5zjOjuM4p47jdN797z72XKe6lWFNOo7j0i2t9ETS\n", + "b+nzxvIPdevTIUn/UNIfDYfDq+FwmJO0K+nv/XUP7HK5jPZIbDDcDGLIOGqpH6mXwYcZYsBpLpfL\n", + "SiQSVh9PTEwYMZ1mklDLVCplahV4FRMTE0aCZyxMnAM7MDVwKBSy0qNQKFhkGfRNOn7KF6xoQTiw\n", + "2GKCyEjZ5XIZ6WpsbEyRSOTOsIgbiM8PEev5+blOTk4sBQB7LSRQpGxNTEwok8nccUh1uVxGBZie\n", + "njbSEoY1jOHpI3Bqvc/189TM/72k3xoOh4HhcOh/97/A+z7hcDhsSPqnko50u4hbw+HwzyQlh8Mh\n", + "2sKyJDQ0GUn5kYfI63aH/olrNOcDDgURDNAWs9ms4akgGEBdmAjSFLlcLqVSKUkyGumTJ09MHvWl\n", + "L31Jbrfb5D4TExNaXFw0LgW85S996Us2QUOuhA4wHA6b7xq+yVBDgel4rPPzc83NzRm5nXKC/Oxo\n", + "NKqlpSX9+q//ur1u3lsymTS23agIIBQKaWFhQZFIRPPz88pms0qn05Zqtbi4qLGxMeMuM63Euovm\n", + "lR6AhCmMeCBiBYNBra2tWVTx9PS0VlZWbCIai8XMVuF9r59nnF0aDodv7/UsI9c7bsd/qtuxeFvS\n", + "/+04zj8a/ZnhcDh0HOdnFfN/7b/lcjlTSxQKBfN7WF9fty9iZ2fHdqdarabd3V3F43Gr/1qtlmGt\n", + "b968MQ4HOxKPe3x8bMcukzTsvJDdY9n68ccfy+VyWWOaSqXMhRT8eGtryxTR7LY4ikYiEeNGcDoc\n", + "Hx/bgiyXyyb/L5fL+t73vqdkMqnNzU3Nzc1ZPTwYDAwVKRQKev78ufnModxmihmNRvXZZ5/ZuH58\n", + "fNy0j3x209PT8vv9JqAFyoTfjRNSt9vVycmJ5ufnbWqaz+dt6MK4Hqu0971+nsX8g3d17b+UBOF0\n", + "eI8J4FclfXc4HNYlyXGc/0fS35dUchwnNRwOS++w7Mq7ny/oFh7kmnn3dz9xofxgQvb06VNjZlUq\n", + "FW1sbGhubk67u7uamZmRx+OxwUM8Hre86lKppLW1NZuKERLZaDTk8Xg0HA5NfjQ7O6vvf//7Jvkn\n", + "ShgvuIWFBXMdlW5LoVwup7OzM62urhrSMjs7a+UDsv1RAWu/31cikbBdkpNkcXFR+/v7qlQq1mgW\n", + "i0V5vV6trKyY9g8vurW1Nb169UorKytyu93mMkRcA7+bTCZNCbO0tKS3b99aRgkuS61WS9lsVvv7\n", + "+xbtgHQsFApZNjgDmePjY62urlqkxfj4uF6/fm0sPKaH73v9PIs5KKkv6R/82N+/72LelPTfOI7j\n", + "k3Qu6d+S9D1JPUn/WNK33v0Xb44/kfQvHMf5Z7otL1bf/fxPXN/85jdVqVRssibdTr4gvTNOfv78\n", + "ucbGxjQ3N6fx8XEtLS0ZZIdwtFgsanZ2VuFwWLVazSRBREokk0ldXFyo1+uZZEi6zc6bn5+3o31p\n", + "aUlbW1tG7mGxj3oSb25umrr7+PjYXgNum9fX10qn0+p0OjZZzGaz8vl8lgkeDoeVTqdVq9UUDAbt\n", + "5kHVQZkC9ZObEY860rdG6304KOPj44pEIub8hA6RCR/E+kQiYQQsBLn9ft/MbpaWlgz5YKDzG7/x\n", + "G4Z6FItF7e7uvuey+vnQjP/ovR/9r3+8V47j/HNJP9AtNPcj3ZrM+CX9seM4v6130Ny7n99wHOeP\n", + "JW3olnr6O8OfgifCkzg/P9dnn32mpaUli0YoFApGsCkWi1pdXVWtVjPZDyoJLGWR+kMgf/TokarV\n", + "qrHJ6vW6Go2GFhYWbHgBCgC2HAqFtLe3Z1wIkJFoNGrxZYRnJhIJ84vrdruqVCpG1ul0OkbKAZMG\n", + "GpuamtLV1ZWZpXMiEOaDQIGPDGbg69evtbCwYDZZnU5Hy8vLpo2kOYQNSAkCBAjllWFNr9ez0mHU\n", + "GHE4HFqjTAxFoVCwcpBGEGLTfa6fijM7jvNfDofDbzmO8z//Nf88HA6H/8m9nvlv+AJnBiP2er2W\n", + "M724uGiTMHgYNFe7u7taXV01dtz4+LiZeUPHJGsalKHf71tWNf4a7HLdbtf4C+Pj40okEvrkk09M\n", + "ZzgYDBQIBNRqtcx48OTkxAY1IC9MJnl+wi7x+MCTAt0j+LXf71etVtPS0pLevHljzyXdNnvo8SKR\n", + "iN24PCZEIfwvXr58aQ79KFJIaJU+l2gRdcHOO+qPnc/n5ff7zY6XIdH8/Lyazab6/f6dsfy3vvWt\n", + "XwjOPOE4zt/TrfvnqDjrx1l0vzTXqJXs7u6unjx5YpyHUQiKpNLPPvvMfM7wt7i8vFSpVDLvB4g0\n", + "WFQh82+1Wmo0GsZ9htBEehOlB8c1Uy/Ce0YFnEBz4L+gKUi/kGmxWDFDhKtNc8hxTm1PY1YqlfT8\n", + "+XNb9ChlENd++umnhgCBR/PYKEd4L5wWkPIjkYhlfR8cHFicBWJiXg8TRDgsjUbD6LDlclkLCwt6\n", + "9erVvb7/nwXNhST9D7qF5n5b0rqkhqQ/GQ6Hv5REo0wmYx/awcGBJicnDXW4ublRsVg0eiVj3lar\n", + "pcnJSe3u7hrMVqlUDIdmQEHADf5wNGBgw71eT3t7e5qYmNDCwoLtlBzPfr/fund+FhSEkyCdTtuw\n", + "BUoqo3HqWBYVvGS4DdTNOPOz642KTIlo43E4lSEpMarHibRSqdhkkzKt1+tpeXnZNo5R1iEsRZpO\n", + "r9drPUw+n1coFDL/Ed4PAgBU6fe5fhZr7r+QJMdxPLpFIP6+bsfO/6vjOK3hcPj4Xs/8C7iYTEnS\n", + "8+fPTaqDKSByonQ6LbfbrbW1Ndt9+QI9Ho+Wl5cVDofNRIVRMCJNiEeYwFCzosQIBAKanJw0S61k\n", + "Mqmbm9tMasJpGCLAFgMhyb0LWE8kEtbI4teBWhtFNqcJCbHhcNgcO5H8w1uGjI8OL5lMGj6MBRe5\n", + "K4RkRiIRM3ZJJpNGKGLSyEmDGh2qK6mrCGD5/V6vp3A4rEgkYoQpPluv12ul0fteP8/QxCcpoFtU\n", + "I6jbQcdfvfcz/gKvWq2meDyuubk5Cz5H4FkqlWyQcnR0pMFgoJ2dnTuY7tXVlXK5nOr1utrttkWt\n", + "sdt7vV4tLCzYIj4+PjbqJCJO+M21Wk2rq6uWk3Jzc6NEImEyI8bUOCZVq1XDji8vL7WxsaFOp6NW\n", + "q2U85e3tbeN91Go1GxPDad7Y2DAiEXYB3W5XzWZTa2trCgaDljEofX7zAzeCSlD2sPtyopXLZQUC\n", + "Ae3s7Ghzc9MQknK5bAxBmsV2u23BO5CgGOHzmmn8rq6urOm9z/VTF7PjOP+b4zjfkfR/6XZX/q6k\n", + "f384HH5lOBz+UmoA2WVoKtxut03cqDX7/b55JqMSBttF8AlzjMYHeKzf7yuXy+nw8FC1Ws1G4YTG\n", + "A0cR9jg6OIDX6/P5VC6XzSIWJTclAg0kMi2GJBMTE0qn08ZTZmDB1HM4HNp4fNSTg7H24eGhMfLY\n", + "RUebZEnG/Gu320ZpdRzHxvzU1NlsVrOzs8YhwSxytE5OJBKKRCImmIWGC8JBw7e9vW0MPV7z+14/\n", + "a2eek+TRLZe58O5/rXs92y/4wuSFLBCQAZqw5eVlI9l7vV5lMhn7kihJ4GjgjE+WXigUUjqd1uzs\n", + "rLLZrJaWlhSNRrWysmK7NlwEMNt4PG4LJpPJmEUV6auEBkm3w5R4PG64ONFk3CTRaNRG0tFo1B6X\n", + "GxBVOgKC09NThUIhPXr0SIlEQrOzs5qfn5fL5dLc3Jwx/iRpbm5OLpdLyWRSw+FQS0tLCgaDhstP\n", + "T0+bMfmoAQ7vB6V1PB43/JhyLxAI2Ag8lUopm80qmUyaEfvz58/tPT169Ohe3/9PXczD4fDf1i2h\n", + "55/qFr34z3U7DfzXjuP8t/d61l/QRb1YLBZNY0bjBYeZY5whCObheBS7XC5ls1mbCgK9wa6jbqX5\n", + "AT0hMpcsPhZ0rVYzr2VixChtwMXj8bg1Z+yYNFCRSOQOBHZ2dqZKpWJcYgYbyWTSbmZ8j+fn5++M\n", + "4tvttlZWVrS3t6dYLGbeHmNjY0qlUmbs2Gw2dXZ2ZkptjBLx3lhcXDRCFwY3YOGxWEzJZFIfffSR\n", + "NaDT09Om/mF0DbUWES285/tcP7NmHg6HN8Ph8FPdRqb9K0nfkbQi6Z/c61l/QRfmgzgYjTptgr/i\n", + "gxwKhVSpVOTxeIxUhMHf0dGR7XZut9sk85i54HHBVIzamYw+mjUYbJDPCcUh4oEjHstcsGp2O+kW\n", + "thsOh4Y7M1kEm2Z3Zrrn8/lMNABEdnx8bKbn2IXBCgRaq9VqdxIAaArZ4aGT3tzcKJfLqdvtqlar\n", + "3Qm+9/l8qlQqFi40ekJKsiEP1rahUMgyGPHiu8/1s4Ym/0TS13VbLw90WzN/591/3wyHw+t7PfPf\n", + "8OU4zvB3f/d3Jck6bgg6a2trKhaLajQaSiQShhsDSZEehUlLpVKxjh5KJvIpbABYlNiBwaOQZISl\n", + "0dfAVA0tHPwR8kngXFSrVYXDYfOP5nkbjYbVmYhgM5mMOfoXCgW1Wi09evRI+/v7pphGroWiA4Ep\n", + "3GPgNho1vEWy2axOTk6sJAD3pi8YDoeWYMXJNhgMzBQnn8+bwypZM+Pj44rH42a2zgQWJKjZbOoP\n", + "/uAP3nto8rN25gVJfyzpo+FwuDQcDv/RcDj8/eFw+OqXbSFzEUbJUILdh66eQQVfHmppHI9goQE9\n", + "TU9PGw+ahYpjEMoIVCxwFQjj8Xq9VkdTEuB3h4UXsiK0e2dnZ5bJR1Ks4zjmnwH1E1kTY2iIQpeX\n", + "l8rn80omk8rn88pms3bz0oQ+evTIfC8g5yOoxZXT7/fbScWgZHd3VxcXF2anywib3bxYLFrDCNmI\n", + "RhAJGjpHCP6SLIUqEAjcO9fkZ+HM/9m9HvnfwIV9QDAY1Pb2tpaXlw3yoXYEevL7/frOd76jQCBw\n", + "R/rU6/XMOqtQKCibzaparRp6UK/XbUzLrsNjIkCdmppSu922mIfd3V1zHALFoKtn6oiAFJcl0AG4\n", + "FX6/X2/evNHMzIzGxsaMbhqJRCxjm9ff6XQsiYrBDM1as9lUPB43Fh2vidH5qO7QcRydnJwYtk0Z\n", + "QKj8ixcv7AaAmM+Usdlsmjzq5uZWFFQuly1KAl7G6Ibx8ccf3+v7v5+51y/ZValUzHkSGIvFygJi\n", + "8oTJYqvVsgyRVqtlzu9+v98GLEiVLi8vNT8/b7s5gerj4+NGREdAyyABf7jz83OrVfv9voXY0PAR\n", + "nM4OGYvF7OZgcSwuLtouGo/Hjdgvfe5NDQLCe4WHUq1WzdUU3BvzSEjxbrdbU1NT5pkMwZ7auV6v\n", + "G087EAioWCwaJEgsHQ01Wkr8RdrttiFDICOodkCR4vH4vb7/B7WYGWrwBeKNAUoRDAZtiII0KhKJ\n", + "2OiZ0gAiO7Xf6uqqHcmkOEky0jrWAktLS1pdXZXP51O327XYNaIggKvw0UilUjbKlaSPPvpI0q16\n", + "u1qt2kJPJBIKh8P2vjAoxB2IiRuUUrgVwI08FnpFOBJAl1A7MU+PRqN287NrEiUMi47YtouLC+Mx\n", + "Yx+AYSRIkM/ns4g2DGUkqVqtmicgNNP7XD8Pn/nvzOVy3b4dMGTQiNEMQBQShNaQucHuGI1G7e+g\n", + "QJIDPYowsIMD9ENOpxkCQ/Z6vXZEA235/X6Vy2VrwIgtY9diRI5gdHp62hpWxs7Y0DIahzQfCoXs\n", + "JsBay+12G6cEngpeHzwHI3IQEPB27L+on8lKoS/gfbbbbaVSKRu4MKhCUIu2Ei1lMBg0qBI73l/k\n", + "0OTv3NVqte7IkDAXqVQqyufzev36tQaDgWX9vXz5Un/1V39lmXws/N3dXZXLZaudX79+bRAY0iE4\n", + "E9TR5+fn2tnZ0e7urprNpvb399XpdFStVnVzc2P4d7fbNfMZIK1YLKZwOKyNjQ1ThdBYVioVFQoF\n", + "5fN59Xo9bW5uyu12a39/X2NjY6rX6+p0OiZurVQqOjk50Q9/+EPbpev1uk09p6amrPzAQvbt27cK\n", + "BALK5XI6OjpSv9+3XgP0BK4F8GK73TbokRiLra0tG1BtbGwol8uZVAxCErs4sF6hULBk2vvwMqT3\n", + "yM7+Zb0cxxn+3u/9nunbqJkxALy4uNDW1pbxIzAM/NM//VN97Wtf09jYmH3YLFhJtnNWKhXDRePx\n", + "uHEWRt192E2heUI6qlQqluTabrdtWMJJ4nK5LMYNhAXkhb9DdQJ/YjRagjLl7OxMkUhEx8fHCoVC\n", + "BschUCB+AkRh9GdHA3jOz8/tZMtkMuYw6vV6LeD+7OzMpGTU5PBPCOKhyQUxgYQEzRWjnEAgIL/f\n", + "r2q1qt///d//xflm/F26cPicmpqyTD8avOPjY7OMAq/99NNPDVe9vLw0NcTBwYGWl5dVr9eVTqf1\n", + "8uVLra6u2uLr9/t3jAxZxEQa4GcB3MZjs/BGx8+QdVwulw4ODowEFIlEdHJyYtq4wWBgiygUCunl\n", + "y5d6/vy5TecKhYI5arKT4pMnyX4OxAOe8c3Njfb3902Eix9dMBi08Et8LqiDCXDHnBGuCqXKYDDQ\n", + "ycmJKX1Aas7OzpRIJCy5C2FCJpNRr9f7W8nO/jtz8aHlcjnzktvf37fdFd+K0S5fktrttkFz+NDB\n", + "FQbG83g8llHSarWMgYaTPVM3BiPNZlO5XO4n/Juhh4IKjPows6DAxbGDRYlBWHq9XrcEKI5xXI4g\n", + "5CNIiEQidgMx2CmXy9ZEMjUcdS6itLi8vNTx8bH5fmAkjsv+xMSECR7A5cHkGdlDfuK9jGL9pNNS\n", + "htEgv+/1oBaz4ziKxWIKhULmx0beCMaBlUrFuMv7+/t2BLKIgdP4kjD0ZjyO9wUjc9hl5+fn5i3B\n", + "okokEgoEAkbqqdVq5l7E+FeSwWQoVjA8x/YA7JqAd8J4jo6OzLgF1Qp4LyXI4eGhmayw4xLJzO/i\n", + "1olub2JiwmzM0Eey8CVZ2hQwIacbeDNeGpJsuMLv0l/wM+DoY2NjFr/xvteDKjMwDqTDR9WMixAJ\n", + "rNRymUxGW1tbFgnGbkd3z+5IPU396Ti3gY1kdZDD3W63tbi4aKoLhgjxeNz8NKampoxJhqv+KCqC\n", + "GpqGk8V7cXGhx48f224Ils5NR61+c3Njiauzs7MaHx83OzAMcaampqzOdpzbwCJUNKA8+HtA6A8E\n", + "AsbTgJSF3wg8bkb9lHFYCMCak2RICfwYoobdbrc++OAD7e3tvff3/6B25m63q2w2a6QgiPEQhCDn\n", + "YCkAdHdxcaHDw0OVSiV5PB7jXjDoIISKR+8AACAASURBVP4MTjM83WKxqHg8bgw4MlDOzs4MNaEe\n", + "R+jZ6/VMj8jOzpGPgBZyETsXdq8MVsCD4WrTTMLfoBmVZFixJGvKGMOP2uzS3NbrdWPS8Z7ITpme\n", + "njb/PTBqSVbSMaaH4wFhqdVqmYsq5Z7P5zOZFOStL8qMkQtesqQ76gnqzmg0qomJCcsBXF1dNS+1\n", + "6elpJRIJC8K5vLy04QnHsvS5TRfcA74gvjh83Xg8yheOXXbhmZkZW3A42UsyMg87NeR8Hj8QuHVG\n", + "A5uG1zExMXGHtA8HWZJhu6N4s8/n09jYmDmcIh4AW8YmbGpqyvgko6QseoFRiy5eN+bnLGzouPBH\n", + "oOYyykZPyXt73+tBlRnsvnTy6OP6/b4qlYq5AlFXAkuRyoQqm7iw4+Njm/q9ePHCMF2CfcbGbvOv\n", + "EWtisj18F8jT7/dtkII97tXVlUqlkgk54UozDmbYwOugKS2VSgaP4VYPN5vHHz1p4GzAtwYfxg+D\n", + "G7dareri4sJKoWq1ar54GKbDMoSmCd/i6upKy8vLVtdTruEtIt3WyAgm8NVg5wa3Z7O5b0Lrg1rM\n", + "REAMh0ODjZjizc/P3wl1hCcBofzi4kKJREKtVktPnjzRcDjU8+fPLf200+loZmbGcFrG4D6fT5lM\n", + "xrzqUGfQSN3c3NjfoY1Doziac+LxePT8+XPb5bG+GhWN8hiEAXFK4Gz6+PFjIz2hOEEGxY4JxxiF\n", + "us/nMwOaZDJpzR67p+M4lvVCZMTc3JyOjo4kyf4dLw2QDqaY4PBsJLiR4tfBOB2F+32uB7WYGdHi\n", + "kwZyQB2J4oEsu/HxcbVaLQvcoaMvlUpaWFhQLpfT6uqqNZJwEuAeU1unUimzJpiZmdFwODToDW4G\n", + "amnCeMBrnzx5YqNoSpRKpaLT01MrCdjlILd7PB6zvUKLSKaI1+tVNpu18HlQkrm5OdtV8QJBTT4q\n", + "G+t2u0ZWwo4WYpXH49HJyYn5P6P8pnTjJmKHHk3sOj091ezsrDXf8XhcyWTSft/v92t+fv5e3/+D\n", + "WswsRkoKGkCO7r29PQWDQcvpYLxMXBkLhzHwcDg0SijNFpIi+BEYkDMqrlarymQydtOcnp5qYmLC\n", + "jv/BYKDPPvtMlUpFL168MCwarR/BPYPBQIPBQLFYTNItfZJBEGSfXC5n/nS9Xs/QmL29vTuBOvv7\n", + "+3ajP3nyREdHRzaAAY6E3DQaJwwBSLplJIKJQwjK5XL68MMPJX1uYIOdLS5KoCsTExPa2tqydNZY\n", + "LKZGo6Ef/ehHZjqJJvF9rwe1mMmbGyX7QGMsFArK5XJaW1uzWtfn8ykYDCoQCMjtduvw8NByTWKx\n", + "mMFVHMfUjrFYzLjGsMEwPMGxBzk9rv3AVaMDE5qh09PTO0lVNzc3NohggY1mmHASQBoiVIgb8vLy\n", + "0gKHer2evfbz83PVajUdHh5auYJHteM4ymQyhuJcXl5qf3/fBKiSzBgdewVJhrbwWJIsT4aYCXBw\n", + "pomoY3BspZHd2dm51/f/oBbz6ELhw4Mi6TiO1tfXNTExYTarkmzyhZ0tHhhMrEb/zAKg6WJqiIEL\n", + "0iEMAqlnKW9gkIEQAI9NTk6aJhGnUeiczWbTuvxIJGI3KgMNYDEwW3IIkTWBwlAmcAOfn98G33c6\n", + "HWMFYkHG0CUcDttJRjkGrXX0M85kMtYUYn2AS+nq6qrt5rVazWBNpqyYmTuOY+jO+14PCppjJAxm\n", + "C20T/zSO+1ETbI5YSQbr8Wev12uKbBo2GhvHcayxAi1gB0LVwgBhcnLSOviJiQmLUJBkkBvDklFH\n", + "/H6/L5/PZ+JPSUZlpaRiwEJwvKQ7aAPvgd0VTw/qfbfbbYoPsHnKLRJUr6+vze0UygCpBIPBQGdn\n", + "ZwqHwzalhGtCE4qtAhg/426c9omJ/oICOnLxoVEvI2eHW4FEiWOQJgb/NTjJTLX6/b5WV1fV7Xa1\n", + "trZmeCtDjmAwaJgqTdT6+rpCoZBRLuGF0LihsoCGylhcuvWSxu0IKiX/hQ8ChXJ098TrGZ9l6mq8\n", + "3y4vL3V+fm7Oo5Qo4+Pj6nQ6hgFLMiiRhQ1ezedIT4G1wKjF7+j3wJCJngEP5ng8rlgsplgsJo/H\n", + "Y70HZdl9rgdVZhCySGoS7kIEk6OrQ2R6eHgot9ttYZI0RPgbT01NGTZ6eHgoj8cjt9utdrttnA+g\n", + "MwwLRxXKjuMolUppY2PDBjBYX7Fj9/t97e/vm4s+ITg0sZJs4kYNS5lDg4krPZFmmIaXy2U7ibAE\n", + "AEtvNBp2etTrdbMc4LGhBuCST+4hqATTQ6Z2GDFiGt5uty3YCPsBamZQF+ijpVLJLM/ucz2onZnj\n", + "rdvtan193dha0WhUCwsLWltb09TUlHFsV1ZWbBeenJy0RmZ9fd3M/YbDoRYWFu5k/VE3D9+F6ExP\n", + "T0uSVldXTcWCNo4Gje4eeA1oLxgMWuO1uLhoFrWQbyDuEy4Pg25packwXpyULi4uFAqFLKhnlFdB\n", + "hDDsPU4hJqHkJuKkBI4NtDccDu35KRm4YTGZfPz4sZVnDH5GTyW86+hbeJxnz55ZuXSf60EtZmxb\n", + "SQrt9XpGnSwWi1bLxmIxa85w1el0Ospms3K73crlckbpjEQiKhQKCgaDVs+Gw2EbWNBUeTwe7e3t\n", + "aTAYGNsO931JBj/RvSN+pY7HVjcSiZgWkVKlUCjo7OxMyWTSKJvdbtc8KFCMsJMz3ZyYmDAUZGFh\n", + "wU4bHJTghuBexO8ydBpl5Pl8Phv983553Zwo1WrVZFr4hoCfS7JaHU75zMyMRWlwo9znelCLmZ14\n", + "YmLCdlF4COwMqJYh01A/0jxJMvokO/2ojzG7lCQbFHQ6HcuF9ng8hlxAeJJkzDuaQOwNwLTJ2qOz\n", + "73Q6xoHgtTLoobbE3oCamBD4ycnJn9AW0nhR89P8IXTldWBiKMmEstxUNHCjo3HKJur40cdFLCDJ\n", + "eM3Ak5FIxE440KXRBvx9rge3mOEpIObsdru2m7FzMkTY29tTsVg0g29yQlhQ4LpbW1uqVCpGm8TO\n", + "CpkSzvMXFxfa2NhQr9dTMBjU/v6+8Q1ubm7MZ+OHP/yh9vb2TAFDHU6DiqqZBZhOp9Vut1Wr1ezG\n", + "2d7eVqlUMjiS0oQ0V5z/qcn39vbM6pa6F7SlXq+r2Wyq2Wyq3W5bc8wJMPqZ5XI5M4bhxGq1Whbd\n", + "TOkBR4OMlF6vp9evXxu9FkOYfD5vrLovlCYjF5AcujVGswwCiEvz+/2qVCqan5+3nZOj7uTkRJLs\n", + "KAyFQpqfn7cR7+TkpMLhsMUHV6tVffWrXzVGWjabNRwXM29OA4hFX/7yl7WysqL9/X3FYjETozLo\n", + "oValmSQMh5RWslIg/jMGpx7nuKb+jsVievbsmYLBoGX+1Wo1K8PIOqHeBokAC7+8vDQbBIhavFew\n", + "cXjao0gLCAbDpKdPnxpkSlj96uqqstmshVze53pQixk65vn5uVZWVkx2HwwGjcnGYmeKl81mjVoJ\n", + "uM+XlclkLIaBoxlWHM0iI2/YeUdHRzaIoKzBeBvMNpfLSfrck25+fv5OFAL1tiSLbYPbQZ0LS216\n", + "etr8KDqdji1UGj+sAMi/pgQA4qNmvrq6MqlTrVbT5eWl5SBizI4hDQOTcrlsJU2xWLTyg/g0HEUv\n", + "Li7UaDS0sbFhv+t2u1UsFnV8fGwG5PeJTZMe4GLGUw1d39nZmQ0ykD7h6IMIs91uG04KZkwuCpM/\n", + "6mRI5/i1wfa6vr62yAhSpxg8RKNRgwAvLy8tTjiVShl1NJlMmkceYerssKAm0EUh42O7xXOAIODQ\n", + "iWzMcRzNzMyYATsEI2pavDKgeIKewDCEFMTrJU6DP8OhTqVStvPjZJRIJMy9FFxeko3iM5mMpqen\n", + "TVRxn+tB4cyjnT87BJIiRtaYi4M3Hx4e6mtf+5qNpxuNhlnbTk9P2wgW8Wqv1zN8lEiJy8tLW9wM\n", + "Q1BUwIIDFRl10a/VajZJ5FTh6G+1Wkb5pHnqdDpKpVLKvUt4RaolyULuYQeGw2EdHR0ZOoHODw9k\n", + "EAfqXKIY0C/+uPAUSzE0kZRwbBx4bSwsLBgnBCf9er1uLk7oBkdZeCzw0cHL+1wPamdmgfX7fa2v\n", + "r0uSZmdnFQqF9PWvf12SzM2eXTMej5vhSiAQUCaT0crKilKplO0aMzMzRirHg5laOxAIKJFIyOfz\n", + "KZVKaeFdvPDMzIwRhqTbHf0b3/iG3G63KpWKotGoaejgE5N2Co1VktE7UXaDyszNzVmdy8IYHx9X\n", + "Op22Zu7i4kLpdNokXLxfEAhMGJeWlgwSxC73+vpaa2trxmUmPQAkgtLI5/NZeHwqlTLR79zcnGWm\n", + "QH4CR4/H41pYWLDT6NGjR0qn03rx4sW9vv8HtzPzgf/whz/U+vq6pYHu7+/L6/Xq5cuXdixSu21t\n", + "bWl2dlb9fl/ValXlcllnZ2em2Mjn82YtQDbKzc2NmSJWq1Vr1CRZHUkuCZKjly9fyuu9zaWu1WoG\n", + "g21vb1vpASJzfX1tte/ExITl8sEjoWaHHER9i3M/Xs+E+Kyvr9tujlh3a2tL19fX2tjYUDgctloa\n", + "X2Zi1KTbEm5nZ8dKHaadJAFQw3NCADuO7sRMK+lDGNEfHh7aFPM+14PamScmJsxHYjRjA47B9fW1\n", + "vvKVrxgpfH5+XuPj40YaJ8LA4/FodnbWUAKgrkAgYH501H/JZNJ4Bmjm0um0GZug/IhEIuYQj7AU\n", + "zggZItSak5OTmpyc1MzMjNXk1NhYGJDWCl/j+vparVZLw+FQ6XRaLpdLjx8/ViqVstAhPECwJYhE\n", + "IhYdgelko9FQJpMxPJpGGXN0dm9gykgkcsciAU/mdrutTCYjt/s2bB6uC/U/Kbf1el2xWMymhfe5\n", + "HtRiLhaLCgaDlqgECsHuBgcZVhlN0iirzOPxaHFxUbVazRhi4KYME2B8TU1NmaHK4uKigf7NZtNy\n", + "rAm9hCtC5EMmk1G9Xr9DPGKo0ul0LEf6+PjYQntWV1dN7Qxr7ujoyPBu9H48XqvVsgEOEqbR4RFD\n", + "C4S3xWLRSjBQC/BuSiIa2+XlZUuhvbq6MqkYUN74+Liq1apisZg5QI0aW2JojiF8IpG4NzT3oMqM\n", + "yclJlctl09qNjY0pl8tZKUBDM7pwILfs7u6aOvnVq1daWVlRsVjU8vKySqWS+SXD8iJUJhqN6tNP\n", + "PzVRAHTJo6MjhUIhnZycGIaMyLbVamlvb08vXrywqAakRiTGkkft9/v19u1bw4xBTY6Pj0313Ol0\n", + "TEWOuSGYdqVSMVrnzs6OksmkyuWy4dkMRObn55VKpbS1taWFhQXF43G9fftWCwsLZmOAZQPEoXq9\n", + "rmQyKcdxtLOzo1gspkKhIJ/Pp/39fQWDQZXLZZ2enmowGBgFYGdnR91u12Ik4I3f1zjxQS1mZPAc\n", + "iRzvCF0rlYqpMoga7nQ6ev78uSRZvRkIBDQ1NaW5uTlLq6KRo95MJBK269FkMUJHps8NANYLujE9\n", + "PW07OSoXsksoazCKATWAx4FAdHZ21soeMOP9/X1r6sj0Rp6EgGByctJeL2SqDz74wLjRH3zwgQKB\n", + "gJVf4XBYY2NjKhaLmp2d1dbWllKplJ0YwIcLCwv2eV9cXGh2dtbsCKABBINBk4KlUikbArHzczq+\n", + "7/WgFjN5eYeHh5adjWr4+PjYSgyGKtjCApnxb7VaTclkUvv7++amDw8Da67Ly0vt7e0pk8lYXcyk\n", + "EQjw4OBA6+vryuVydpOhUQRCY1iwsLBgDWQoFFI+n7cBCc+NexHNV6FQsBJqY2NDMzMz6na7ZjuG\n", + "9VWj0dCXv/xli46DjwLlc2dnR5FIxIwmgdgYXXs8HhUKBbNJCAaDJnqAT7K/v6/p6WlLEuB9ACPi\n", + "3ES6bCaTsfzwbrerSCSiH/zgB/f6/h/UYgaam5mZsQUGFprJZEwtgWD0y1/+sl6/fm3kHVh3kUhE\n", + "0WhU3W5Xjx8/VrFYNFEmtaTL5dKHH35oeDB16rNnz8yc8Pnz5xY7DN2x3W7r0aNH+uSTT9TpdLSw\n", + "sGAu+vCfS6WSNZfEEgeDQc3NzUmSaRjj8bgNKdLptKTbcTN2tvCJA4GAnU7hcFiO46hQKBg/4qOP\n", + "PlKtVtPc3Jz9zNjYmJ4/f65oNGpq9W63q+XlZY2NjVndi8F5Nps10tL09LRev36t09NTpVIpeTwe\n", + "VatVzc7Omivr2NiYvvKVryiXyykajSoQCOib3/zmvey5HtRibjab5qQZiUQsEwQOA00QrpksTOxd\n", + "cf7kS6Ih4oiE7I+F7fX1tcUEwwYjv9txHIubqFQqNg6nFpZkMFUikTAi/OHh4R1bLJThw+FQm5ub\n", + "mpycNM0eNgYMRsbGxnR0dGT2AfV63f69VquZAAHjF4/Hc8fP+uTkxBz9WegMoPDV2N7eNhvbDz74\n", + "wOimiAYCgYBqtZqJYsfGxlQqleR2u/XmzRvrB5gAsovj3nqf60GhGdSxYMHUc8ic4vG4TcKoMykb\n", + "RvVvoA7EfoGQQLmUZIw6vrR2u23KDhzlp6amLC0Vq4JAIGCcCbBqrAJgyDHSptYm8AYzb+BGFg+w\n", + "nN/v183NjdLptEKhkAkI0PiBzqRSKcXj8Tuvnx1+fn7elOJoJHFJLRaLZoKDtZbH49HCwoKhI2DL\n", + "qVTK+hMoq7FYzAxtMJ+knoZMdZ/rQe3M7JjwehmiQHb3eDymJJZkaEM4HLa6lB2DsgMGHNkmEIjG\n", + "xsYUj8fVbrdN88YR3e/3jf/baDQMBwYH5+fPz8/t+J6dnbXAHV4XvAuQk+fPn9tuBmaMoz6vZXFx\n", + "0WRjlFuw30AfwOITiYQhOPV6XalUSicnJ5qbm7MbJxqNmvkknnlwPiDaEwY6Gl386tUrey8ej8eM\n", + "2+lbSJo9PDzU5OSkqW3ucz2oxQw+CpcBjjK1LhjpqL0qUFu9XjdmG8cxLDZMs7PZrN6+fWt2ruz+\n", + "7Xbb1NtQIplyoVzBdAVPDRQm3FjFYtEEoC6Xy9QoQG2BQEA7OzuamZkxQhC499nZmQ4PD03lgdpm\n", + "e3vbFjRhlHCqeU9kWUO6Z7IYiUTMWQlZGEJWIMazszNls1kbxVNq4Y2RSqXM4RM2IAKGQqFgr33U\n", + "OPI+14MqM9gtXC6XTZjAcKl9B4OBYcA0K6AMxBhQXwYCAYO2EomEBoOBKaChfqKkmJqaUq1WUygU\n", + "UjAYvKO6wPNZkh2pOC1RCkxOTt6B+6ampgw1Ga3bObZRnZCt53K5tLa2Zp4ULEosFjh5qMUxAOfU\n", + "QK3daDR0dXVlhHqGG0CHozZn3Eyw61DPwM4bHeTAq6YU4qTCSRR05T7Xg1rMLNZqtWq45+rqqi1m\n", + "0I2FhQUzPwyFQobdMnnLZDJyuVxKJpMqFApyHEdbW1s2DaQp4kYAV56ZmbF6MxKJGG9ieXnZBgdM\n", + "JzEq56aD64x5ICKCTCaj2dnZO/zjSqVihizwt5eWloyHMjMzo9XVVc3NzVmJ9PLlS6tLz87O7qAS\n", + "hE9KMpuEy8tLZTIZSZ/7L1MXo58EN2cKyM2LhzPPTVwdpVcymdT6+rqazab5WYON3+d6UIsZKiFx\n", + "D9A5KRvYEUAiWq3WHbI7bvrk3NXrdfn9fj179sx2NqAoToBRC1t2a45iYo45guFtwGMgealWq6lW\n", + "qxlhiJuDCSVu9+Vy2ST/7HSdTkezs7M2SgdRYdLISHp2dtZI+nAo4F+w+KrVqilo0C/Cm3j27JmZ\n", + "PmK2E4lELG6DlCmErgyJCEWikf1xLSRuTZCq7vX932/5/HJdo0EwUDZHrVZHhatEJow2HRB9sH9F\n", + "ncxNggIF05jRP/O7cHj5+R9/Dfw7/ybJNIc0dxB3EATwJUPzZHfkd0AQ4F2MEuAhyXMjjr5P/j9o\n", + "A6+P5+S04L+S7PcoPUb/DjSDkoXXT8NKL4N7E802C/sLQeuPXbjHM75lUoW06PLyUqVSycg/+DdP\n", + "Tk7aQoeIDxKwsbFhjK7p6WnV63Wdnp4aMgGOSugOJQpHNuPwRqNh2C/TOXb2dDqtRqNhdSZ0yF6v\n", + "Z65B4XBYiURC6XRa+XzepnEnJyemrAFrJ0dbkp1O5+fnWl1dtRE9C5b4BzynR+VZRDVsb2/r/Pzc\n", + "8PBut2vPBTQJrk9zS47MqF4SBfhov0LP8oWgdeTCbV6S3e2VSsWGFUBWqCiwnAL5wHEHl3pyOvBx\n", + "o8Yd9S0eRSWQ8uMmxM0D0YiGjp0OY0een9EuC8JxHEMVUFCjFJE+j7pAsU3ji4YPXna/37+zi4NS\n", + "8H7wrqCJBd2ABIQG8eLiwmxyyT7hhgQZAh0iwwSko9/v35GBAdHRSPI673M9KGgODoAks4nlKB2V\n", + "zxOPBuEGqigWtfjGMdVCQT0+Pm41IjvM8fGx7erBYNC8niEyUZfy2vBiZiFKssEFEWlgwiAYQItM\n", + "DCkbgP+kzw0V0fKR5oROkUFQtVq1gQe1MeUTXAyU6UwzJRnxiRtidXVVjUZD7XbbnJJARjCU5LWB\n", + "unBBmmIkj1HjFw3gyIUvBHc6pBf4tCgxrq6u1Ol05PV69emnn1p6ab1ety+o2WzaLnR+fq5CoWBi\n", + "Uvwkzs/Prbms1WrWUPZ6PRWLRaXTaQUCAR0fH9ti4ngNhUKmAeTxkXydnp7q4ODAPPIajYZRNSXZ\n", + "KYDdFQQefg6eNAMNIi64kSk5Wq2WjdpJnCVtC8bd6empqtWqms2mQYBnZ2d6/fq1wZtsAggALi4u\n", + "tLu7awgH6I8kyzZsNBo2aqfZhPD/vteD2pmz2axp6Hq9npFrgOOgPQ6HQy0tLalUKimTyRg0Fg6H\n", + "zWFneXlZR0dHlve8trZmvskMQ9ADspiJN/B4PIrFYkZ5pNYdtc+CHgnnwefzWY2bz+f11a9+1YZA\n", + "8JQHg4GpPcrlsoLBoKLRqBqNhsmmWBiMsweDgRl++/1+zczMqFAoaGFhwT6zarWqxcVFYw5yw0Jh\n", + "pZ7HNRXuhtfrtXF9JBKxps/r9epXfuVX7kwq8bq7uLiwcTr8FWis902belA7M5l75XL5Tozazc2N\n", + "IpGI5f9xHPZ6PduBOdZxkAdSk27H5FBBOX4JvIS4g3bv8PDQ3IWazaa5/tC5M4kkWF6SJS3lcjmb\n", + "7HFME+COQz8Z1IFAwOrVZrOpyclJk2lhVA7agPVBu922Mgp0Ay4HTEJODj4nbjjIRtTRGKGDU1er\n", + "VSNwBQIBe5/wR+hfpqenFYvFjDOyv79vU1DiJd73elCLeTSo0efz3TEFHFVzwC2QbhXKkowmeXl5\n", + "qXw+b+aKkF9w+4FEE4/HjSzPFxQKhZTJZGxaNjZ2m+4EFAXKgisSEzj88fCGBsLCgKXb7Rp5CUiP\n", + "unxyclLBYNAGKCxyn89n+SG4juJFTW4JJHxODzzlaABpbkmWBba8vLy0x2C3ZRI5GgcRCATk9/st\n", + "go3nkmSlycrKiiFA9BDvez2oxQykBJUSLwzcP9kBgMVohCTZTsNUjHEx42HUxKiPqfVAJyC6083D\n", + "xKNZIyKYETZu/ldXVyoWi7bwCcZpNBrGJaFZBNbzer12CvHagCJZ/NLnXhrwMXBWmpqasgxB6m7+\n", + "x46OExNj+W63a5pBSpDJyUl7TLBnRAj0CAxoUKHg6I8ImAHPaMza+14PajFzXJZKJYXDYeNFUGKg\n", + "HIlGoyqXy+YVIckWG4gDkzhJevr0qU3k6vW6OfMTlomCgzJl1JCFGpQjHjQAhTK1InU+po/4bsCz\n", + "AOkYHx83UhISLKwTut2uTezAgh3H0fLyst3cJycnVtKMYuXj4+MqFAoGnzF0gkgfDocttoFaGZSF\n", + "kTVID5sKnynqG3gYIEcHBwfqdruG2LDZvO/1oBbz6empURHn5+ctK+/m5kbr6+tKp9MmwMReACk+\n", + "wTYYpWQyGWUyGVu47ObsnuDCkP+xteIGWV1dtXqx2Wwa644FwFAF/sb5+W1g/IsXL+RyuVQuly31\n", + "am1tzeito8R8himSrLbFFUmSqU0ajYa9N9AKRvI0n9LtZgBJCOEBC0+S4d6UF1gfzM3NmaodNIcR\n", + "O1QBhLg0pZOTk1pfX9eXvvQly0tkcvm+14NazGDGoVDIKIbgt1tbWyboHAwGZj6+vb2ts7Mz1et1\n", + "jY+PWy3YarW0u7srj8djOyFNnCQbJMRiMQUCAQv8AZ7b39+3aRrO8fl83oxj8vm8Ybp42R0fH2t3\n", + "d1exWMycji4vL1Wr1eymw1GT4HYGI8i2PvnkE2OpZbNZq7VDoZCR/5niBQIBOz1omIEC+/2+kayI\n", + "jDs4OFCpVNLFxYWazabFNRNyiRIem1vpdpBFWfPJJ59IklmTlUolHRwc2HPeN274QS1majqmbTDl\n", + "MB/BoQc2FzXdaJIqi4QYMOpNJnWQhuDl0gxRC/b7fYOtIpGI5ZFQhxJfzCLimGYggmwfM+7Dw0NT\n", + "hFxcXMjr9SqVSunly5fGnR7lkYTDYWPGIc7FK4/QTQhMqMnPz8+Vy+Ws1mewg6+e4zgmYgCrJtyH\n", + "KeeoSypTv5mZGY2Pj5sXHacItgOY29AAYyf83t//38Qi+mW5IBphtI2BH7yAcDhs2C3NIYhHuVw2\n", + "mKtararf7+v4+Nh4DtwAeNVNT09bCYIdLoqOwWCgWq1mkBicYgIy5+bm5PV67TXxWrEWw9sC7jKs\n", + "PG4iyot0Om0GhfAbINkD7bndbsORWUzU16P84VEkBSswSFbn5+daXFy00E8kY7FYzD5L4iVojK+u\n", + "rowJB8pBzgxcDuwYcD9NpVL3+v4f1GJGutRoNIxEnsvl5DiOer2ednd3tbe3Z8Yo5XJZ09PTRiyS\n", + "ZCVJt9s1N856vW5ec7u7uzo9PTWXecj2yPBh0JEXGAqFdHR0ZBitJO3v71uwPFNAdIo0ZS6XSycn\n", + "JyY+bTab2trauiNIPTk5MaFtp9NRMpnU2NiYNjY21Gw2ValUlM/ntb+/bylUo3UplNNcLqdWq6Wd\n", + "nR2dnZ1pc3NTLpdLe3t76na7CgQCVqbhkAqPhKQCHh+8GqPGUqmks7Mzy5U5Pz+3tIKTkxM1m02V\n", + "y2W1Wi19/PHH9/v+7/Xbv2QXcF8LeQAAIABJREFUzR4exFNTU3ry5InBXuCoCFfn5+eVz+eNczA9\n", + "Pa10Oq0PP/zQwnpIWUKgOkqFRKDJhXG51+s1yb8k81pjV2OiJ8nQA4xeuGlIfRplAI6G+Yw68Uej\n", + "UcNyb25u9NWvflXX19daXl42MStIChiy2+02kS22WslkUsViUclk0pxIUaYggZqfn7ebVJKJASBP\n", + "ob6em5uz7wEyFwgMwgXeM83pFxPAkQtegySzvYIDQFME3gpsBAsNxfMoF4HmCcwZCy60bAxHgJyA\n", + "9dhlqR8pd3DKpKECwup0OuYkii8cXAlwXZzzwZmpvXlfqL3RPUoySOz4+PgOTEjkMX0A/BIWOT7J\n", + "9AB8jrxOOBU0bM1m02i23Bh4QeMfTSMMG5GQIsbvo+Yx73s9uMXMhImAx2QyaWNeosPI6wsEAsat\n", + "oFFkx6KxQptXr9fNy5m6mYGKJKs3WYz8PKqM0Vo0Ho/blC+VSikYDCoUCplHxuTkpCTZ5A5eBLxg\n", + "+ByRSMQYauSLkNDKa5qamtLy8rIZOJIuQI0/NjZm1gS4guKjHAwG7fPD0gCzGj4bzA8ZWUuyxhYU\n", + "A/iSqerU1JQx5xDvZrNZM7l53+tBLWZUx/v7+6a88Hq9isVimp2dValU0sTEhDUwsNLAP6mdZ2Zm\n", + "DC8ebXS63a4Rfvb3981BH2hrdnbWuL7pdNrsv/g7POVyuZzS6bRisZjq9bqZIlLvM7yhFs5kMpZw\n", + "1ev1VC6XjfIJ2wxsmGaWSRzj50qloouLC5Nf3dzcaHZ2Vufn5za5I5OERnU08/rs7EwzMzNWzzPY\n", + "wdsjGAyaQQ5jfiai1NJ8hmdnZ7YxoGqnhLrP9aAWM11zMBhUqVTS9PS0Xr16Zb5rHHG7u7sKhULG\n", + "dwa+ikQiarVa5rrZaDQUj8f18ccf25cFiWh+fl6JRMI6d1AQiDflctnQA2C+fD4vt9utsbExffbZ\n", + "Z1a/MlZm54L4z5QR0xXKgGw2q83NTQtgZwIXj8dtwog3R6PR0M7OjkVcwB1eXFw0828yXvDBy+Vy\n", + "RpTis2m1WkZzRV+I7UIul7PSBlgSPw98peGXc0KA0OCctLGxce8YiAfVAKK4JqMPHLPdbuv4+NjU\n", + "EORIj4ZEVqtV4zg7jmMSHoLSfT6fuYTe3Nyo1Wqp3W7bGNrtdiufz1tJ0Wq1LJEUyf5wODTDl4uL\n", + "CxOcwm2AfHN2dqaJiQnlcjlNTU2pWCzaogc7x1IWOA6OtfS5nQGLw+VyGT7caDTk9XpVLBZNUtZu\n", + "t80FCvEpGX4zMzM6OTkxuzM+E0n2mvELgQ2HvAqVN8aRYPDQQSXZTUb61H2uB7WY4UZMTU1pbW1N\n", + "4+PjWltbk9vtNnYbx6fjOGbXBSoACQeHIzgPXq9X9XrdWGoQ/pmq4TyEIjsSiWhlZcWOek4MSoPh\n", + "cKgnT57o8vJSU1NTSiaTxilJp9N3aJrgxG63W7Ozs5JkKAG/F4/HVa1W7QTAwDudTqvT6WhlZcVs\n", + "sYAvYe7BJqRWT6VSJmAIhUJKJpOWkQK7DmEtpCq42dItooQFGB56P95XgIwQ2sP7wPzxfa8HVWbA\n", + "xBpt+JjYkTON/gzvuFErW6ijfOEnJydGGR098uHtYisFod/tduvp06fm6sPQAv4DAxTq3kQiYTIj\n", + "XIS4MUYVKTMzM/Z71Wr1Tvg8ODnKE0Si0WjUYDsITOQLor2TZIjI1dWVMpmMGo2GWZr5/X5dX18r\n", + "EAhoOBwaZIcaHGN0Biaw7paWlswZNRAIWMQF8iwCffDgA68m+/B9rwe1M2NWwk7QbDbtAzw4ODC+\n", + "AIudYxOaKEMSSUaIabfbNgABqgqHw6rX68ZSQ28HjEXnD3yH7g7ZPiNkmHTU4aOyo/Pzc2O9jToj\n", + "+f1+M1ocjXSQZCPhyclJ7e3t3RHugpD0ej0b6XMjnZ6eWjAPtXI6nbYoCoZDg8HADBYh5jebTauj\n", + "JyYmTBB7eHio5eVlG7nzGY5KwyYnJy2ldm5uzvg073s9qJ0ZlhpxAwg7O52ODTcQoiI8pdMGMoL6\n", + "eHPzeWA8jkgTExNaXFy0o5FmDpK79LmqBYdLSSZClW6nbhCe2JE47jFIgUAPaoC3HHYCOGfCgWCB\n", + "wKkulUq2o5Limkql7nhiSDJzcAQCSLT4Wfge9BqBQMC8m8fHx41uOhwO5ff7zeuOTQJKZ71et5MM\n", + "/BmO9MzMjPx+v66urkwA+77Xg1rMdN6jvGPqQ9h0kH9SqZQFzCCNL5VKmpmZsVICo5fR1KidnR3F\n", + "43GLJKMOZeiAnwWG4Dc3N5aOyuID14aXcHl5aUrxZrNpX770eYD81NSUlQykTZHKivtoMBjU1NSU\n", + "0UHxQeZxGJhEIhHDyFdWVgxVgNPMIsR/b1TOVKlU7Abxer3WUDOQYXA0iuuDtkiybEWwdkS32Dzc\n", + "53pQizkYDBoODLeXZsbr9arVatk07vT0VEdHRwYfLS4u2gdaLBZNxsOiwpQc8/CJiQklEgmdnJxY\n", + "XY7zJfUiuzn0RqZ3k5OTqlarlojV6/WswQQ7hhzFOPr6+lqFQsGwaHK6GVAwycRDA1X4xcWF0UbZ\n", + "YVF048vM54UxJDg04UKSjBA1NTWlSqVi+DHOSqhLKIcuLi6MZsuGwusD36d5ZDD0haXtyMViubq6\n", + "0vz8vCYmJrS+vi63263l5WXza/Z4PHd4GjDMUHJ8/etft90OhQS7h3R7AsA1JlDn/Pxcy8vLVluv\n", + "ra2ZOTmcDRY03m6JRMIifmlc4TKDV7OzgWOn02l7HXA2er2eQWpAdyAvqFlOT0/l8/m0urqqo6Mj\n", + "E/USydZsNjU7O6ujoyNls1mFQiE9efJEwWDQnisSiaharRqKAxeDphnVi9vt1tLSkg1jPvjgAx0c\n", + "HFgoKI06rvsul0vxeFzf+MY37pVr8qAWM7ZPNFfhcFjNZlPT09MmmaLBwguZqSDddrlc1tXVlebm\n", + "5sy9EoIQnGS4uOVy2WAm3DCBr3K5nFKplLrdrkqlktFGLy8vzRosn8+bsJUdENplLpczce7Y2Jjy\n", + "+bwWFhZUKpXMxDwQCOjk5MRMHrkhvV6vIRy4I0UiEZVKJVWrVR0dHZkDKgy8ZDKpXC6nwWCg3d1d\n", + "PX36VMVi0XB6ScbjwBxyenra2Hng6dAEsOydmJjQ9773PaOdSrelCo002syzszN99tln9/r+H9Ri\n", + "TiQSVvPBUkP1DOwD3IW0Ci8I4tRcLpdOT0+1uLiodruthYUFY6r1+31dXl7agCGZTCocDt+xlmI3\n", + "X1hYULFYVDgcViqVshExvsl4sGGeAqEIBUg0GjUJ0unpqUUtXF7eBkY+ffrURuWkn9JYYpNAA4ry\n", + "gxKBaOXRmwXl93A4NO8RanpcjdA8RqNRm/ThsM8p8eMsQozWm82mMQkZqLA7O45j9NW//Mu/fO/v\n", + "/0HVzNVqVSsrK0omk7ag0dhBkez3+8rlcvJ6vTo+PtbExIQZIQJrYbtVLpdVKBR0cHBg0BOlAx7F\n", + "1Isc2TDbIN5D4u/3+6Ya4XE46m9ubrSysmKex+Sc1Go1VatVQz3Ia5mZmdH29rY1WWNjt8lUNF/U\n", + "2tgdQEzi1EBlg9kLcWlTU1MqlUoWR8GElIkn3nJAe3wOkuwzODk5MYSEBhMYFIQIrBoGHqqdL5Qm\n", + "IxeulT9uV8vkCZiNThwHfEkWbEngDOyyTqej+fl5MzYhVAeH+Gq1alNFhhHHx8dmbTU2NmZQIIGX\n", + "TP7Q1EH6R34EZMjNR1BlNpvVxcWF3r59a6GR+XzecHIiJigBYMUVCgXDh4HwwMIvLi5MZAvCglxs\n", + "NAweigC8ZZAeDHLA1JlcEqrJaYZRZLfbNVVMKBTS/v6+Kbm/8JobuTDuZoExFmYKxSSPhYd9bDab\n", + "VaFQMJbY0dGR7YLz8/N3DABxr6fpwUS72WzaUCWdThtNkhuGcTkj6VarpcXFRaM9RqNRJRIJq3XJ\n", + "kV5eXjZYa39/X36/X0tLS2o2m6ZZBBFZWlqS2+1WJpOxGGU4IixcGkTG79Jtc8fQ5/LyUsViUbFY\n", + "zFAdRvqpVEqNRsMmevw+pw8bxeXlpQ4ODsxQEfiQTQXPasoxMPovBK0jF2Z/LMirqyu9fv1a7XZb\n", + "tVpN7XZbhUJBH3/8sRqNhg4ODmxadXx8bOSizz77zESep6enevXqlUUYYLd1dnZ2J2H07OxMOzs7\n", + "km5Pgu9///vGt2AAcnV1pe3tbZ2entoUjxICJQgeGtiG5XI5vX37Vjs7O5YNPj09re3tbVvQQHtI\n", + "sKrVqnkhU/rQoELT/O53v2ufGdwLl8ulzz77zDSG/B2+HYeHhwYLUo5cXV2Z9VexWDTI7eTkxEqo\n", + "VqtljSoN39HRkXk6X19fq9ls3ivQUnpgixk+hN/vt2OWXQq5/nA4VDablcfj0ezsrFkMQGg/OjpS\n", + "OBzW+fm5jVifPHmivb09tVoto0MyhKhUKlbPfulLX5IkFQoF89CYnp42jSBc4UgkomfPnqnRaFhN\n", + "++bNG8OKMTinMVxcXJTf7zfp/5s3b4xjsbOzI7/fr2g0qmazadzqdDpt4TrsypQC0EjhekxOTlpJ\n", + "8PjxY8v6wxeDMiOVSlkkca/XUzwetyaU5pWdn/BQGry5ubk7TkfAcfQgTFLvcz2oxYyvBBHAPp/P\n", + "lL9LS0sWKLO8vGyYssfjMayUSR2cW8xKIColEomfSKaanJw0mAuVy9OnTw3vPjs7UyqVskYHQ/BR\n", + "BXU4HNbs7KyJQFdWVvTo0SMjH7lcLgUCAc3Pz5tuDwd8vDHwwmC4g8qFcojnCwaDZh8wNTWlpaUl\n", + "S30ilJ6JIPyL6elpBYNB5fP5O8oUYtUo3UBkoBL4/X5TpCC7wqgRbL5UKsnv98vn833Bmhu9SDIa\n", + "NVnJ5/OWLgo68e1vf9tU2C6XS9VqVQcHB8rn80Y2b7VaOjw8lM/n08HBgR3T1M2tVst2tVKppEql\n", + "oq2tLcvHps6mQYKeOsqjYCGAlGBsyASuXq/b85ycnBiWHAgE9IMf/MAQCfjKcI6Pjo60u7urfr9v\n", + "HGHyChnMYBqDXzJKm/39fZVKJfN1JpKZ045dmoiM09NTxWIxHRwc2OdM8w1LEZ40wmBU2sB1NK7f\n", + "//737/X9P6jFTI1brVYVjUaVz+eNrgmZBXUwC+Ht27d27HLkezwes2O9urrSzMyMDg4OVCwWTegq\n", + "fW62CDw1NTWlTz/9VIeHh7q4uFAulzNXfrBoFCyBQMCmYjc3N8rlcsrlcjo6OlK1Wr0zaIHWyciZ\n", + "m67T6diNJ0lv3761G6fT6ajT6eji4kKbm5uqVCqWaY21LBAheDEY+sTEhOkpOUVevXolSaZHhFDv\n", + "crm0u7trDa7P5zNVCaNykJnT01MrrSBnwZRjMHOf60ENTR4/fmxqjUKhYEc1/OXV1VV5vV4bCkxP\n", + "T+vZs2fGGkun00bhjMViRuDnJqArJ1RmbW1NvV5PmUzGFCcffPCBTbqSyaQhDq1WS8vLyyoWi1pa\n", + "WtLr16/NCJ2yaGFhwRbS5uammZYD1yWTSYsVxn6rUqlY6CVO9r/2a79mo2LMDj/88EML6gF9gP22\n", + "tLSkTqej5eVlY9oNBgPNzMwYwvLixQsVCgXNzc2ZFArL3dXVVfOwo3Q7Pj42y6+nT5+qWq3acIpp\n", + "57Nnz0w4IUnf/OY39ebNm/f+/h/Uznxzc2OLh8anWq3K7/eb1VS5XDZuAtpASUZu53fOz88Nt4bF\n", + "ViwWdXx8rEKhoJubG+3u7trud35+buQheBEoPzY3Nw1/vrm50f7+vi4vL5VMJtVqtcxhnuFNrVZT\n", + "MBjUzc2Njo6ODFLM5XKGV5+enqpQKCgajRpa4Pf75TiONjc3jTVYKBQMuYHNB1LCZ7C3t6fT01O9\n", + "fftWzWZTm5ubmpycVLFYNFuFUqlkCxsODBBfo9GwxCtOIHoPRuBMD4vFovFEjo6OJEmlUkm1Wk3f\n", + "/va37/X9P6idGcVEv9+35gycl24fD2MmZGCmQFyzs7OanZ01kxPk/B6PR+l0WoVCwcbTsVhMMzMz\n", + "ZiSDOXksFlMul1MikVC1WtXS0pJ96YPBQOl02iaUcDFisZjpEqmlyfPGrZ5pWiwWM70jzSlmLnNz\n", + "cwYxYhkQjUY1Oztr+dnRaFS7u7uam5tTMpk0u4Dp6Wnl83nNzs7K6/VqfX3dfEGWlpZsAVOWAOHN\n", + "z8+r0WhYYzwcDlWpVLS+vm6mNo7jyO/3KxAIWI1Mg45d7tjYmJUz73M9qJ0ZWAquAWqGUaMRamIW\n", + "KcB+OByW1+s1iy2mh5VKRfF4XIeHh+r1elpYWLhTl25ubt5p4mq1mnZ2dmzYkc1mLd0KtOHi4kKB\n", + "QED1el29Xs92e2ptScbhuLi4UDabtckaihB4FESUnZ6eyu1227+53W6zLaBmZeSO4xAJqthpcVpw\n", + "U9EE0izSkEoylALMmSkfhKy1tTV7L0RmAM3d3NxYwgDWXf1+/4tx9ujFlGlyclLb29vyeDzWFKK+\n", + "ANGglsbdvlKpmLKY8gG3+L29PSUSCZ2fn6tcLtuX1uv1TDSKIhrLglH3TTjVqKpvbm7ucKYxZYzF\n", + "YlY/klhFedRut3VwcGCcajgcmJJzE5I6heMQpt69Xs8Yb8QpwwVhetnpdNRoNMyilgYaKic4OJKu\n", + "s7MzS7Nlp+ZxuNlG3aBwCcW0Ef60JJ2cnKhSqdzr+39QixkpEl8cDpTQEofDoRKJhO2O8XjcvNU4\n", + "PvFcwwJgenraQH1qV/jGICSw35Dej8qQwKkRmDIClmTavsnJSUszHR8ft+QoiEBYDIDCILLFX1n6\n", + "3GwctTf5h5OTk5qfn7emdTTInlKKMT4nEnCfJEttZefv9XqmXIfYBE8D2RlCYqaeOB2NKmL4bmq1\n", + "mo3L7xvQ86BqZmC4wWCgDz74QNJtAI/L5bJFzFCA4UM0Gr0TmgO1c25uzhoVFhYEJWRVdPHHx8dy\n", + "u9168eKFscvYcbrdrubn541sj9KCBqnf72t9fd0W6XA41MzMjE5PTzU7O2uk95OTkztyJALlWSzo\n", + "76Bk8viStLGxoYmJCQWDQWUyGR0eHiqRSMjv9xu9c3x8XIlEQgcHBwqHw3K5XHrx4oUkGSkJKwYY\n", + "c8Cc6Ckpg9g8UOPwOpB8wWZE5Q2py+Px6C/+4i/e+/t/UIuZ6RwoAFyGUTX1zc2NHZcYrqCXa7fb\n", + "Rg2F54v+T5Idx9SSRDfA1Ds+Pr5z7I96O8O4g4W3v79vo/RqtWokHpz6GS6Ew+E7Tkkc5d/5znf0\n", + "+PFjs+2tVqtKJBKSbssAEgAwICdFitIF05ZarWboiSTjdIRCIf3whz9UJpMxfJu+YNSknShliFpX\n", + "V1cql8sqFos2FqfcoT/BWQlDSIxgNjc37/X9P6gy4/r6Wvl83tx6+OJZSOjrVlZWDO1gp8QEBTSB\n", + "IQJaPlx/qAfBUKFTYrJCuCU3CZTPUddPThB2O3b7vb09s8qFXzwYDMxckOFMt9tVJpORx+Mx+uX5\n", + "+bnZC1CmsNtDC8UOjIYNZiD5KLD8IPUjKGAhUw8Tq4zR+dbWlinSuemwHBhtaGu1mrlCUbbw+cHK\n", + "u8/1oBZzMBjU0tKSfD6f6fskWWkBTvvmzRu5XC5tb2+bnOfq6kqVSsUceZD9Q9ZnTM3OTPOYyWSM\n", + "D3J+fq5UKiW/32/oCPAbbDUGL1BFaQLdbreePHliE0NeFzug4zjK5/OGzDDRQyw6NzdnYTfcMBMT\n", + "E/aaqYu9Xq9mZ2etlGi327bAaCoLhYJFGEtSKpVSOBw2mRNJsdy0wWBQ5XJZ8XjcbH8XFxeN7skN\n", + "m8lk7DsJh8Nqt9vKZrNG6L8PLCc9sDLj7OxMsVhMS0tL2tjYkMfjUTabNSzz0aNH8ng8BrcNBgMd\n", + "HByY3B7WltfrtUUtyerS8fFxzc3NGZ8Zgerq6qp5PlMPhsNha/4kmVbQ5XJpYmJC6XTaHDUJkCRy\n", + "+PDwUF6v16RbDFdoEhG5UufjWMTrJYSSm7pWq8nr9RqRCMcmdkPHccy+tt/vWxIXTkqQkyBt4ZvH\n", + "e2y32xbySXPIzs/PwPGAtcfzlkolyxR88eKFNjY23vv7f1A7s8vlMhUzihBJpm4eLTXAcVlk7Ewk\n", + "n2IcMyppwgT8/PzcRrmEl8diMRvM4I1RKpUswxuCPibiPOfExIQNccCMYawB/TFZZNwO1ZPoCRor\n", + "pmuZTMbKIZfLpaWlJXMukmSliyRLXWUcj3H6+Pi49Rtkn1DOwKaDcgtXA1PGfr9vblIQpnD+9Pv9\n", + "BllCaIJNSNP8vteDWsykgfp8PpviUTdDCSV1aVRS5PP5VC6XdXFxYWbhg8HARrHslOzQNzc3Ojg4\n", + "MPd3bK5gjnG800TijUz9PnrzXFxcaHl52aZw9XpdpVLJeNMQcQaDgQqFwh0nJkSnHOUslmazKb/f\n", + "r4uLCxUKBV1eXt5JkJVkcjE4x5CsEPQiFIAqe3Z2ZiUPXiBXV1dmAIOdGa8D7gfvncELjSjREHC9\n", + "y+WyiRve9/qFLWbHcf4Px3HKjuN8OvJ3Ecdx/sxxnG3Hcf614zihkX/7rx3H2XEcZ9NxnH8w8vdf\n", + "cRzn03f/9j/+rOdMJBIWcoMCotvt3unAsZylAWMHi0QiFuIIjssuTvzZqLn30tKSDT/g8DKqxaEI\n", + "ohKDA0nWmJGP53K57gxo4JZQj3u9XiP8uFwuPXv2zLDcUaOW6+trw8cZdYNf4+9BzAQ3KRNJSiaU\n", + "KQTJw7CDsz2aQoXbfzQatbwXyjS425CVZmZmjKjFoudmSafTNuj6ZW4A/09J/86P/d1/JenPhsPh\n", + "mqQ/f/f/5TjOE0n/gaQn737nf3FA/aXfl/Tbw+FwVdKq4zg//ph2wcvAV4JFjHIYSGpvb09XV1c6\n", + "Pz/Xo0ePVKlUrNtGuDoYDEzmM6oiJpEUtcX8/LyZMlYqFdvNGE1Xq1VTVJA/QqgjUqnz83OD1RzH\n", + "sUVHatbr169tKvejH/3Idv7RsHeGF4PBQL1ez9yOGB7F43EbnDDVxHKX9K1oNKqtrS1DZEabUxQl\n", + "fC04J0HColSChE9J02w2VSwWTUYViUTU7Xa1ubmpTqdjXnm4mt7n+oUt5uFw+P9Jav7YX/+WpD98\n", + "9+c/lPTvvvvzP5T0R8Ph8Go4HOYk7Ur6muM4aUn+4XD4vXc/989HfucnLjR+kMHBM9l1KC2I7yVk\n", + "kp0CtTBEelAIBgXYuNL1X11d2dEbCAQsdpcpIDcJRzzdvSSDzAjhOTo6Mg0ftFDCHqlhR4Mqg8Gg\n", + "rq+vVavVDHo7OjpSvV63RpHnoLZH5FssFjU+Pm78C25U5E1YI9TrdU1OTmpnZ0fX19eWzgrGDk4O\n", + "dk3utyQjHAFPIh8DimPIgxSMEuk+1982mpEcDofld38uS0q++3NG0l+N/FxeUlbS1bs/cxXe/f1P\n", + "veD/MqHiiAOKgg6ayWQ0Njam/f19410gCWKMzaiY+nI07J2Fge/z2dmZmZr4fD4lEglDDtgNuQGw\n", + "OQCmSiQSloLKLriwsKB6va6rqyuTGfF7oxxo9HvY2wKpUTKQ5YKu0ev1an5+3hyf4EP3+33L2c5m\n", + "szYGHx8fN61kIpEw+RWnCRM/FienDTa2fO6Y5BB+hESMTEF6kftc/8agueFwOHQcZ/g3+ZhwgMvl\n", + "svL5vGVoY1RI/cdu+8knnxhJhklXpVLRzs6ONVkzMzPGuYD4D0qCOpoc7W63a6bbYNHLy8t6+/at\n", + "pqenrYSA1skE7ujoSKlUyqA0jF+wGKDO3tra0uPHjw2XxYeDgM61tTVThayvrxuZp1QqaXl52WRe\n", + "1Kh4YuCev7u7K7fbrZ2dHaXTadVqNRukXF5eWoNGTMSoOSJMQEItGf/n83lNTk6q2WxqZWXFXlM0\n", + "GlWj0bAJZiqVsmzt973+thdz2XGc1HA4LL0rIaBJFSTNjvzcjG535MK7P4/+/U91pP7zP/9zO47h\n", + "/i4sLBhBB89hFtTi4qLliaRSKRUKBblcLlNZBwIBOY6jpaUla9Aw+2ZHZpoH3CbJoLtOp6OzszM9\n", + "evTIGh/4C8QrYAMbCAQMWaAk+cpXvmJm3M1mUx9++KFZbMF/6PV6knRnyPPBBx/I7XbbTsv7xnUT\n", + "jLjb7dqAp1AomJTq8ePH8nq9+s3f/E3zf6MJhBiEskSSlTRQa/GI5jl9Pp9pM1dWVu6MsA8ODlQo\n", + "FHR6emon4Ptef9uL+U8k/WNJ33r333858vf/wnGcf6bbMmJV0vfe7d6njuN8TdL3JP2Hkv6nn/bg\n", + "T58+NWI4I9P9/X396q/+qqEbyeRtZYPl7eHhodLptPb29swK9u3btzawyGazOjg4MOLR4eGhJYxe\n", + "XV2Z0oM6s1qtam5uToeHhzo9PbVQ9lHD7k6no0qlYsc5BouO4xh0ODU1pd3dXYMPWbSSzCkUzjY7\n", + "IST+4+NjRSIRbWxsaG5uTs1mU4VCwRphJEyM88vlsvGNT09PVSwW9fTpU21sbFisXKvVUiaTMZ84\n", + "8GVu6kajoUgkYv0HFmg852Aw0OHhoQKBgPUy/X5fCwsLZgN8n4GJ9IuF5v5I0nclPXIc59hxnP9Y\n", + "0n8n6Tcdx9mW9Bvv/r+Gw+GGpD+WtCHpX0n6neHnt+nvSPrfJe1I2h0Oh//vT3tOpEDBYNDsqPB+\n", + "kGR16tjYmK6urvTkyRNtb29blANcBkbOp6enRjQiv2M4HJoOT5I1Z8Fg0LzlKEcw9Qa6op5Fmg+S\n", + "4fF4lEqlzA63VqvpzZs35ssxmgWSSCQMv8atHjsBFgh8Z0br8XhcPp/PNIWUNzSXTPbi8bjloOBW\n", + "StIsDTTwJE6pEP5h6t3c3CgYDN5R8IC0YK07GAyUSPz/7L1ZaKx9nt/3LS0llWpXrSqptEvnvDrL\n", + "291Dz9uDjQcTE8LcJJCLkItAcO587YDN3BtMIJAJODdxArnwQMDBZGCmJ8MwNtP99uJ+l7NKOtpK\n", + "qr1U+y6VVJULvZ/f+6g9Y4cjjz0R7wNNn1fnaKv6P//n9/+ucfl8PmWzWa2trcnr9VqG88def2U7\n", + "82Qy+a//kr/6O3/Jv/8XpEKkAAAgAElEQVRHkv7RX/DxLyS9+P/yPUmjZM7FBYzDAW0ytOvr16/1\n", + "8uVLFQoFJZNJG1EoaUc2eXV1ZTjtxsaGldlId1BaJBJRtVq1TAjiB549e6aLiwujsEOhkImgSqWS\n", + "pZOCgZNl7KwWW15eNikqCxK4jYMlqUW0PPG7E9sFdY1eGbqZ2d/tdlsONQcyyJB4PK5Wq6VoNKp6\n", + "va5UKmWZG7VaTdFo1HyB6L3Bop1tt51OR/F4XKVSSV6v955YqlqtKhKJPHgxPyoGEAKEkzOSROJX\n", + "0QtwWKvX64rH41pcXDQXNrsIcBLB4lNTU6YppimVXR9bPtASckzczPRjE77S6/Vs12s0GrazStLh\n", + "4aGV9bAIsOXz+chZ0UWzuKCKGaHI7CDls1wua2pq6l5MADUXPCFGo5HBkuzwvDabm5tGHuE5lGQz\n", + "P85ybn7+HmY1m83a+xSLxdTv9+/1dCNs+tjrUS1mZJ9ER7G4sL+DFXMSJ+VzPB6blvnq6kqLi4u2\n", + "ONxut9msIEui0ajcbrcd4GD80A47/W2YS/kZwK4hINjBOp2OksmkVT7wu5C5TKoR7B6VEcTDjsdj\n", + "9ft9sx5dXV3ZWBUMBo2sYffkBkfoRKUyvw8kBg4dbuzZ2VlziDtvimw2q4uLCytIgtZHvcjrOjMz\n", + "o42NDVMiwiAS6viQ61EtZpqclpeXLREehRi7BztWKpUy7S//hgUD89dsNg2V4AZIJBL29WZnZ21h\n", + "MWYgsCGhCC0DTmqaq3BZIORnxk6n04YdkwwE3Xx5eSmPx2Oh6HSukC6EfYuRJhAIKJFIqFAoaHl5\n", + "2TTctEZxWHOKjqD/WeBUBPO9xuOx5V8vL99B/pNvqpKXl5ftKQEbiSOb6AcO5oS+o88gifQh16OS\n", + "gHY6HZvTstmsUqmUVY5BB0Nr1+t1K01fX183NVun07G4rsFgYLsROcawWlNTU8pms2ZmZS4HLsvl\n", + "ctrd3dXc3Jzevn2rjY0NY/D29vZUKpVsFkXPUavVrEJhMBiYTqTf75sPj2oLZmQoduSsHEBdLpfK\n", + "5fI9qvv29lYnJyf3VHtgzwTE4MbB2BuJRLS/v286DmqM2+22Xrx4YX3aMH2RSESDwUD7+/va2dmR\n", + "JMvSwPZFnjQoDKVJb968+Xe8w//261HtzHjiwEKhndl5ms2mzWgLCwtGHzN7NptN0/zOzs5axNT0\n", + "9LQ5mUulksUMcLDDxu/1erW/v29aDoLE0Waww/NGYhsKh8Omcut0OhbEyMGOA1w8HrfdlO/HyMDv\n", + "j5WfAG9cLshD+XeYX/1+v+r1+j2yAzaOzwXFYeHFYrF7+mxn5jImhMXFRaO+y+WyWc1wkCN4Ojk5\n", + "MZ/jQw2tj2ox82il7pcmJk7+FMPzJlCHS8gh1cFUg83NzdnXQJ8BHc6bwmGITOInT54omUyaXmNp\n", + "acnmZsgFDjrOxiXknEg6KcHB5ErOMbMuYwjqN8LT0TswErBrLy4uajweG0qC+o8FOz8/b/gvFLfL\n", + "5TKordfrmQAJTyMtXOTRjcdju7HRiqOwu7q6Mve5JNNQJ5NJlctlk9A+5HpUixk70eXlpZaXl+3F\n", + "QgpJbFQsFlM+n9fLly8tr5mTuNvtVjQaVTAYVCQSUSwWUygUMmf2eDxWOp02RwU7GMlEjUbD0jOZ\n", + "n2OxmNrttkVx1Wq1e9AVB0aiuQh+JPPOSYwUCgWzICGjBIUIhUKKx+PmqKGbOxKJKJvNaji86wfP\n", + "ZDLWeY27xe12m7OEHZKDH4vWaTLw+XzG8i0sLBgCBG6NiAkNCF5DJ2LBpsOZYm1t7UHv/6NazM7O\n", + "EsQ29XrddlL8geSnMR82Gg0TyvOG4apmZ0NQTiALmmAwWrfbbcgBc6Pf79fp6alCoZCWlpaMOUyn\n", + "0wYjTk1Nyev1GiMnyYwEkuxpIn3rxQsEAjbjczAlJkGS5TUT+8UNi1E2mUya4o2DGU8qxhiETcSW\n", + "rays2BMNdAVyidZbcH1nsSWtsox4S0tLikajtgF4vV7bwR8qA31UB0BO9lNTU1pZWdHCwoKePn1q\n", + "ZEmpVJLP57PK20AgcE955na7dX5+rlgsZuMKFiUOX0tLS6YDBtpaWFiQy+Uy79z09LQ2Njbk8/kM\n", + "tZC+zUhutVpaWVkx5zb5d9PT03bydyIm2LUWFhaMjVxZWbF5tt1uW8p/IBDQ7u6u9buUy2UtLi7q\n", + "5OTEdBg0yeKUWV5etqaAbrer1dVVUxAyD1cqFfNSUkzE68c5xO12m0IunU4rGo3q8vLSkCSXy6Xp\n", + "6WmtrKwYjAgj6na7re/lY69HtTMDtQUCAdMlv3v37l6xZKPRULPZtEXxh3/4h5YOKt3Be+VyWd1u\n", + "V7/85S/NOMphi0c+Viko4Uajof39fdXrdWUyGZ2cnBjsdX5+brgz4wKkDa5xOlempqZUKpV0dnam\n", + "y8tLffjwQaenp5ZzjH+v1WopEAioXC5rOBzqxz/+sVUQn52d6csvv9TBwYEikYhpTKLRqBEndL5c\n", + "Xl7aCEQEAcgGehVm2mq1ahQ/6AQuF3Z4DoAHBweW5j8cDg09arfbyuVy+vLLL01wBUZ+fn7+oPf/\n", + "US3m0WhkgS/Mz8x7kBzEUHH4onrA7/db1ACGVqq8oHbb7bbNhGRnEMvKLI7fDf0GGg4UdWCr4MeQ\n", + "C/jpSqWS4df9fl/xeNyqkZ2MGrJT6e4g+fTpU0sInZqaUiqVktfrVaFQMHsVMBomWwgTEB/w36ur\n", + "KxPz86Qg+UiSZV7ARIIiMZ6hNaHcB+0yBmHatIbDoQ4ODuwGwcn+sdejWsxOCSb+OmIBgMSwQaFR\n", + "lmQkAxemTN40Sab8KhQKJhuFlga7hibnjebmcYqKCBwEJ2Z2BE3wer2mXgsGg9ab1+l0LHgRJlOS\n", + "sZcgF6QulUole/xj2r2+vrYcPHyHtHNhdOXsACwIFd5oNIxAcjbJgkrgwOE1B8sHvcBWRWuX9O1N\n", + "gaAfrcjHXo9qZg4EApaMeX5+roWFBS0vLxv2urW1ZUZR5Jvs4pzWYbxY3OCn6HK///3vq9Vq6erq\n", + "ynKSWaxIIsPhsImDJJlSj7LI5eVlg/4ikYjOzs4sYyKRSBjpwgzNgk+n05YNcnh4aMlC4XBYxWJR\n", + "U1NTRlm7XC4tLi5qaWnJ8u5wXaMbATdGw4IUFVES1RhIUr1er9bX1yXJFHsIjDY3Nw1LxmhATh89\n", + "LYiYiFzg6YGQf25uTn/8x3/80e//o9qZOYWfn59reXnZMF1knThD0DjMz89rd3fXRhOCu5PJpJ4/\n", + "f24RWW6327QQ1WpV6+vrikQiJtwH6QBpQG9wfn5u6USkzeP0xrkNxY2ajViDvb09pdNpM4HOz8/b\n", + "fHtwcGC1wdQo4I6GQCH0nHRNdl4IJBKXkK5Go1F74kh3Yn+oe9qv5ufnrSgUhR3RDDwF0GvzNch0\n", + "5r0BwuTwvLu7q0gkYibkh1yPamfu9/sGf/3Zn/2Zfvu3f1vtdlvxeFzn5+eWRN9qtfTixQv9+Z//\n", + "ua6vr/Xpp59a6MnU1JS++uorcx9nMhnVajWrAh6Px/r6668VCoV0cXFhMyewFegH83csFtNPfvIT\n", + "a1Uir65YLBpEd35+rq2tLZ2eniocDqtcLqtWq5nYnhDETqejSCQij8ejDx8+2LzKPJ9MJs3kinGV\n", + "Cgaqz1ZXV1WtVuXxeKzMMpvNKhKJWMoS54U/+7M/06effqpisaijoyOzoa2vr1tGNTY0FjPoDTsu\n", + "VPft7a3VGhPpdXR0pGw2q1qtpp2dnQclgEqS66FWlb8ul8vlmvz9v//3TdV2fn6u1dVVtVotJZNJ\n", + "QzM4fIHBvn79Wmtra3K5XLq5udFwOFShUNDu7q76/b4SiYQymYxpbweDgeG7xNeGw2GbaZkjMco6\n", + "O7tpPV1fX1cul9PNzY22trZ0dnZmhgGqG77++muzMaH7WFm5c5Dxc6RSKYMbh8OhhTs6c6pJ0/+t\n", + "3/otZbNZ+Xw+3dzcmEEVCSp+RZJIA4GAstmsksmkoRJTU1NqNpsGza2srBiRA75MItLh4aHS6bS9\n", + "Xq1WS6urq6bDoDSTpyXk0D/+x/9Yk8nE9e94u//C61HtzLOzs5YFt76+boczxPDMd5VKxSJkR6OR\n", + "fa7X67VETEgVpIuBQMDqFNBVBINBLS4uKpvNajKZaGlpyUwAoVDIEACYQHKggbH29vZsjAD/xTj7\n", + "4sULe3yTzYYKjR7C0WikeDxuWmDwaqrZQEGIFvN4PAZPRiIRhcNhi/tiNmcHZWeFJr+5uVEoFLKx\n", + "jbgAAtxxpNB6hY4EDJv4sUgkYn0wEEsQXN/R2Y6LmKd6va7PP/9czWZTBwcH6na7CoVCKhQKuri4\n", + "UC6Xs/yJ4XBou8dkMlGn09Hr168l3YnsZ2dn9e7dOw0GA3U6Hfsc9AlkctRqNfu6qOCOjo5ULBZV\n", + "KpUsoAY1WrlcVqPRUKFQsJ8LC9LU1JQ9gtGF5HI5w3vBnGEwa7WaxYVNJhNlMhnLqM7lcnr79q3K\n", + "5bIqlYqRGs62LX43GNPXr19biQ7Y9vv37/Xq1Svl83n1+321Wi2LRqCThTl4OBxaLcX5+bkmk4kl\n", + "i5I2RdA7X+/g4ODBUQOPajGjCeZxL8l2lcvLSwtPxG+WzWbNXsQLCRkAPlwul5VKpVQul02jjEmz\n", + "UqmoVCoZlEcuBnit3+/X9va2uT0QNNGuhCyz2WxadRr5GxAryCddLpdptIvFos3Q/FzhcNic18Bu\n", + "LMhwOKzl5WXTGHPYKhaLJkuFQJmenjaCCP/heDy2aF/ERODtlUrFKPVKpWJpRjyB2HERLhEeU6lU\n", + "9OHDB7ndbrOtfRc27rg47YM+ODv9qOriEJfP5/XixQvTA1erVbNAJRIJo6ihpHnsMi+D14Kf4ggZ\n", + "DoeGjni9Xh0cHFgpJW4Xcu5KpZJlSqOAA9cmeV66Q2kqlYo91kn/B+rqdru6vb3V+fm5hsOh0um0\n", + "zeOBQEDxeNx6TJCvMl/DKKJXhkiCgPJ4PMrn8xZGw+9GxBkVGYjygfXK5bKp/Pg7dN/D4VAXFxem\n", + "PFxcXDQi5yHXo1rMTmiqVCopFAoZrIVFCS9dOp3W+/fvzVgJrjw1NXWvBhgSggoDqHD8hOgTENf7\n", + "fD4bDSaTiba2tiTJNBYQBEB2zWZTp6en9/DhyTe9hQjZnbMxRT/OMBvQjbW1Nfl8PjuwES9wcXFh\n", + "NyKYLh4+n89nNDM3E0WaUP8IgMiRCwQCevLkiRmAuaHRUDMrh8Nh02Vw0BuPx5qdndXOzo7G47HZ\n", + "wzAKPOR6VAdA0nqur6/NFoX6ixcWN/VwONQPf/hD0yjgvNjb21Oj0TB6OpVK6fXr15qdnbWU/LW1\n", + "NRPYI2Mk4urq6korKyv62c9+ptnZWTWbTe3u7lpGBdEFaDRYnPgRqSlzLuZCoSCv16snT56oWCzq\n", + "5cuXajQa8vl8Zun//ve/bzfd+vq6xuOxIpGIwWROM4Db7VY2m1U8Htf19bUd2nw+n4rFora3t+3Q\n", + "GY1GNR6PLf7LaaeCAEkmk6pUKjaeTE9P6/3794rFYra5cPMmEgkVi0VjBxlHQqGQPvvsMzuvfMz1\n", + "qBazJKNikT4ym/r9fvP7BQIBjcdjXV5eqlwum2653++rUChocXFRiUTCymrQYnAzUDrDaR9FGN6+\n", + "UqlkRZRcWJkkGfFAtNfMzIzq9bolGUkyZGEymejJkyf2+WRJo97jxiBNU/q2dhnbP27x6+trxWIx\n", + "XVxcaHt725wpaENubm6s9ow5GSgTAb7H47ECIV7X4+NjS/eMRCKSpJ2dHYssIOGfoiGeDrxWOFSI\n", + "I/vY61GNGbz5w+HQgr8vLi4saahcLlu2GwcZEAAklqANKMZQdI1GI2UyGXtTsejzKC+Xy8pkMrYT\n", + "IgZyu906PDy8F17O45tDZLFYtJIgrqurK4vJrdVqarVaevfunSUIcXgjI7pUKlmf3tHRkYbDoYrF\n", + "oiqVimXKESGLZczZBFCtVlWpVAwRGo1G2t/fV7/f12QyMaIlk8nY7E4z7XA4VC6XM2jQ7XZbqA6t\n", + "q3QiQtW3222L7AUZIYrgY69HtZgZKQjxQ/rofJzhLiZsEJaKbAhJRl37fD61Wi2l02mdn58rFAqZ\n", + "ZhnxuZPVIh3T6UFEA4yqDAwX0Q76iJubG1vULpfLVHX4/wikaTQaxgzOzMxYZdni4qLdmOx+zhAW\n", + "xP/8G8Yjvg4pns5EJwypoD8conHJkBNNulKr1TIZKN/X7XZbEA4xB+g6+v2+RYylUikTJX3s9agW\n", + "sySDpxDpYyJttVomyEfiuLm5qVqtpkgkoouLC9XrdS0tLdlBDCgqn8+b0+L4+Phekj4J+YiJgAVz\n", + "uZxub29tAbCLIfZhIQWDQa2srCgYDJoNCxcISUE4y0FiEomEjTmrq6u245O77PQ+IpJCCI8LhYQh\n", + "ZlrGCppVgTOB8cjpcx72CI10GhDIzEPBiHqx3W7b0w/MnXiGdDptf/eg9/5hS+ev10VANy4Nstuk\n", + "bwU2ZC87A1KwRd3c3JgEUvq27BxblBOeA5FgXGCnhyrv9/vmO0TAQxYbdixJhm4gPqKNiR1s8k09\n", + "GYJ50opI4GQ+5qnDzkuBJt19LGx02GiNITlAJqjOADajgJ5YW0lGGg0GA9Myc6BD3glGjRWLkYjD\n", + "JN5Ep2vnodejWszQrU6xezQaNREQSaCc4IvFokFy6XRay8vL1pgkyYJW0um0CYicNWaMAM4QFiSP\n", + "n3zyiVmPYN1wOuPCRvREjQQ/L6U/dHOvra3ZzxYKhYxdQ2Mh3S0wnh4gDjzOiaPFRY48k12W5Kfb\n", + "21sz92JjqlQqtoNfXl4a6gGD1+v1NDc3ZzYwXo9nz54Zbh0IBJRMJrWysmJPDEa5UChkZ5LvGEDH\n", + "hYAeGA6HNgk9lOLAiqHHALMlWBvEg+gpAgR5pIJXI/CJx+P30u35e8IG0XE4Y6t4DJO+ubS0ZIlE\n", + "PDX6/b7pS25vb7W7u2s3AkQO8Be1Djc3N9rc3JR0d3Mjt4S1xPOIThstM9pqtBnslmhSGF+YddFO\n", + "+3w+Kw/iey0sLNjC5KzCE45dGU0KP+fs7Ox3HkDnRUUDEBQHJYTx8/PzJoJh/CCbmEZTZxMUj2eI\n", + "AQ5yIBlY/hH4A085682urq7uLWBoa5RpuFzozmOXZ5dbXFy0XZRMC+xbUO+SLNUTxzc3IsmhLFLo\n", + "ZEYmfm/CGQmYYSTg5iVEETYTSxiLnacdryuSAMRd09PTps9wRvJeX1/byPbQ61EtZubRfD6vg4MD\n", + "o7MlGfSEUKjVapl9ajQaaWdnR4VCweSXtEVVq1WtrKwYUwcdzGO3UqlYLx7ifacWIxqN6ujoyJzS\n", + "PNolWeBhqVTS7e2t8vm8zcbValW5XE65XM7kpefn57q9vTVIC1oaa5jP55PP59PPf/5zDQYDgxgz\n", + "mYy9Liw6NNrD4fAeC8mMPTU1pS+++EK9Xk8ul0sfPnz4N3bp0WhkFDo+PgqJJJkbm3o3n8+ny8tL\n", + "vX//3oy+pJPOzMx8p81wXuh8vV6vBRA6YS1sSQiOtra2DPnI5/M2z25ubioej5sQCLYMkgOpKLYk\n", + "yBi+byQSsURNoD1ob/pMyO5wu92WHE/gSrPZ1OLiolZWVoyCnpmZ0c7OjlHbkozsmUwmJk91u93a\n", + "29vT/Py8nj59qrW1NdNmuN1ug+dAdgiBIeSm0+lodXVVHo9Hz549kyQjcoD8CFJ0uVxaW1szjUci\n", + "kbCwRij5m5sb04pcXV0plUrp2bNntttLspYuzMUfez0qBpAZEScD1iTeMMYGFs9kMlEwGLTFglIs\n", + "mUyacJwUTTpCUIzNzc0ZS0dqEtpfzJ5EZwWDQXk8HhsJ/H7/PXYRyI2QdJqsKLxk9OFxDYXNYdF5\n", + "c5Gl4URiIpGIWai40SaTiVmfeFIwg4NvExU2Ho+1u7tr9XI8CUCO6Cjn4Onz+SztH7EUyVC4ZRB0\n", + "kY46NTVlN+nHXo9qMZ+enmplZUWlUkn1el3r6+s6Ojoyiw6QGtgxkNLy8rIJ1IPBoN69eye3261y\n", + "uSyXy6Xj42NbXCwOOkv6/b5lTlBq+fTpU8OjFxcXdX5+bofSZrOp1dVVi9kKh8M6OTmxwxflNc5k\n", + "e2fWXSgU0urqqt68eWM+RkwEr1+/1tLSknK5nNH5CHyIC9vf31ehUJDL5dLTp09tLODQVy6XbdH+\n", + "7Gc/0/b2tpEhc3NzNgc3m02tr69rfn5eFxcXarVaWltbUy6Xs0q6733vexZXhkDf4/Ho66+/tswP\n", + "TLrz8/M6OTl50Pv/qMaMXq9n9n7gMHbHcDhslCoah/X1ddP3BoNBSXdz7Pb2tubm5qxv78mTJ3YC\n", + "v7i4MF0xGDDIBLamXC5n3x/cmIVMulI0GrU0Ig6CsITM6pAXy8vLdjMRjMgh1rlzoxXh90DhNhqN\n", + "VKlUDPPmUHZ9fW1JqLjGnWmkqVTKdnFCJoHiqDMmviASiSgUClkvDKmq6Lv9fr8KhYJ1gS8sLGhh\n", + "YcFKgJjdH3I9qp2ZIBRsSVtbW8acgVBAJiwvL5uplPmRGbndbiudTqter+vTTz/Vmzdv9Df/5t9U\n", + "uVzWkydP7nV68OiE2v3hD3+o0WhkWRS3t7eG+YZCITsIFYvFe8WWTgq90WhoaWnJXB6cBfb29owl\n", + "e/v2rdbW1iwUkd8FjHg8Hmtzc9McKRsbGyqVSnry5ImOj48l3SVxxmIx3dzcGLSIRxA3OQuUcMXl\n", + "5WVDc7gp0Vqj1Esmk8YoEmSD+AqSik0DpzxM6Ndff/3R7/+j2pnZAbEVwVRx0CDHAQYskUjo+PjY\n", + "SAOv12u4KwU6pGuy46HZRfnW7XaNHcOlTZVYqVSyghuwWeJqSdiE5CEfOZfL6fLy0vBxyh/5upgN\n", + "WFD8D+gOxwhh6FDXnU7HXhcOb5NvKn5hFsvlsv1+UO6QHpVKRb1eT+1221LyGYdCoZAtbq/Xq8Fg\n", + "YMgN6Adjymg0Uq/Xs4Bzvhe/w0OuR7Uzoy9GSE9wCTsBxIIkOygSqcUjnV2Ckksn7RwMBs3oCoWN\n", + "LmHyTVEk2gaSPwlZ8Xg8FkFF9BYGVeSdCwsLCoVCZl/iBlheXjaNCaQHOyXhNaSKDodDbW5u2u4K\n", + "Vc54hUkBWJBIXvoI8fJB9XPjrqys6ObmxtoIyKqm5IfDIgKptbU1ixljLEE5KN1xAlS4Qd87VYMf\n", + "cz2qnZkDDzZ2UoZgppBIoglAl4w2wxn44vP5jFFDx8ApHrgPFwW4bDgctsMOXxuiBBIEgT4qNRYo\n", + "cQLsnIRzk13M4m42m3ZYhRzBMV0oFCxYfXZ21jTDkEKQN/gMCZ8hgQjVGuwgDmxmdUnGbkK5O9GY\n", + "Vqtluy94uCQrRWIEhCEkUsypfXnI9ah25lKpZMQJwSrFYlHStznHzWbTWC3kinjxstmsms2mGV0R\n", + "7IB6SDJzKWQJ8+dkMtHh4aHm5+cNy4aBdCIjVE68fv1aKysrCoVCJlDCtexyuQx9QYyPLR9Hy8XF\n", + "hba2tmyBd7tdo9eBIFEKYq/qdDoqlUqaTCba39/X3t6eJTkBCbZaLUUiEZVKJWUyGe3s7Ojo6Eh+\n", + "v1+ZTMYOfuVy2dpfUQIuLCwYovPFF19oe3vbDuPkbCDGv7y81NbWlikTodwfcj2qnRklGW+MpHtV\n", + "CeCpnKTJunAKi3CNMELwZ07u7Dw0jxIcgy0IRALMG0EQpThQ0+DG7FqId9jJw+Gw6bD5H+ozHNTs\n", + "dKR/8rN7PB5b+E7amEMpzg/pWxaS38vr9WpqaspaucjAQ4ONOo/dGz30eDy2EQvBEr8DYxznDj53\n", + "OBzagROz60OuR7WY6c8AfPd4PGb4RNiyvLxsyjkamXBA8IKDelDYA3sWDAaNoIhEIrq6ujKRETT1\n", + "2tqa5UMgZiLRCNIFoRCJmhx+UKpRPcaCxVyLrgSDKT0ljE348ljwkkywhFAKwoVRiI/B2Emyosxo\n", + "NGpKQ4wKku4llwI9Enzj/Lm5ORYWFuzwzSbDCMNsvrCwcC8296Pe/wd99l+zi0Vzenpq1Q6c3Eul\n", + "kk5OThQIBNRut5VIJPThwwfDYKm9hb5GHba/vy9JFkhOa+ri4qIlFaHJZdTA2nRycqKNjQ1DAgaD\n", + "gTwej37605+q1WopkUgon88bhvv+/XuD8FqtlslRWRy1Ws2cHvV63XbU6elpFYtFra6uWrA3vzNC\n", + "+JOTE52fn2t9fV2VSsVc5IPBQF9//bXVVAyHQx0dHek3f/M39eWXX+rly5dyu9362c9+plgspsPD\n", + "Q33yySeWdxGNRtVsNlUsFi1Mkq6T29vbe+9DvV63UWRxcVH7+/sW+bW6uqo/+qM/etD7/6gWMzkW\n", + "c3NzltRJ78je3p6y2axmZ2etMGdjY8MWAY9hHCjb29uan59XNBrVxcWFMVXT03ddd91u14LA0RlX\n", + "KhVFo1Ftb2/rw4cP5gghf4KILUic4XBo+opms2lRAdQ5RKNRuVwuVatVs0Whsjs4ONDTp08lydLr\n", + "udGi0ajRzji8cZcnk0kr6wQ92N3dtVELLHwymejFixdKp9N2cw8GA21sbNx7nZG5RqNRLS4uanFx\n", + "0ZLzmdc3NzfNYQ6hws/z4cMHbW5uyu/36+nTp9Yw+zHXoxoznJW6xEBRW4a6bGlpSVdXVzZXYo+C\n", + "gdve3rbETh6ZpHuORiPlcjkT2UPP4t7mEMOBjqxjBDTg3l6v1/oFXS6XHVJJx3cGnIN2cADk9wTq\n", + "arVaJn4i2IURyePxaGlpyRANMPi5uTkzA6BRhoyBpURNOBgMFI/HTYDFz8bXaTQakmRNU6A/qAE9\n", + "Ho9h6B6PxxCU2dlZe/Iw538XAuO4ksmkOp2OLU5JCgaDNp/V63UL8f51GxQWoEKhoEajYaQEc3Ei\n", + "kbCDGgudmZs3p9VqaWNjwxYJi4Y8DUQ5/X7f6sQ4ONLahLyUv3fKRZndCU+hpzsSidjuTWd4IpGw\n", + "uVyS9aLwqGcRHR0dmRqw0+nY3yHc50DIbgyeDp2O6o/FT6cgemq0GVDokFgUXr579842nYdqmh/V\n", + "YkaTiyKsVqup12xYVkYAACAASURBVOuZAyWVSpnegORJ0ADKLGHdRqORAoGA8vm8zYfoIKanpw3S\n", + "gp7l0X1wcKBCoWD2fq/Xq3a7bYclbE3OqKpqtWqWfdCQt2/f6uTkRP1+31RozWbTvvbt7a3Ozs7s\n", + "5kNznclkdHZ2pqurK/uZe72eAoGAjSLOUG/yojH24pa+vr5WvV5Xs9nU5eWlhTQ2m037ODgx+mgi\n", + "DIi4xYBQr9c1NTVlxUdnZ2fy+/2q1Wra29uzhd7r9R70/j+qxRyJRMzr1uv1FA6H740Ik8nEpJde\n", + "r9cOSiyYdDqt0WikfD5vRAP1aZPJxMgLREfkRWCShd1bXV01manH4zHUAVlkIpEw2z2PbZzReAPX\n", + "19cNDoQdpEMPxzQECf0swHH4HtGdkIJPHC74LkGOku4Vb3I5dSPBYNDievkY8F6/379XEITgCeIF\n", + "XTb5fOhOyHcmG/s7d/avXegcwGZ5FPKmUyID3IRIPpfLqdlsWuUwJToslMXFRbNHkRuHIRONBmgI\n", + "8yKsHTuTy+VSt9tVpVKx3fH6+toanehkGQwGFpfLU8EZmgJFj37YWd4pyUghDK8o7VDxcXMiYMKK\n", + "xc02Pz9vhBGzNjQ3LmvK4J0pTlD009PTBk0SVoMS0OfzWU4f3eQEW34XAuO4UGkBVWFkhVb+9cjZ\n", + "TqdjiZfMhjQJIHuUdE+/AA1MWCJEBzsvQn9JJgji/6GFIXDQS7AIUffFYjH7t0RsQVRIshwK6N9A\n", + "IGD493g8VrVaNXERMVosevoIabtCjO/3+41BlGSNVBgIGEFY7EQMMAODK6Nbcbvd5vohgDKVStmG\n", + "ws4NsUKR6EOuRwXNweoR5zoajbSysmI5coj1yWWjq5kFFYvF1Gg09P3vf992tqWlJcttQ5fA4r+6\n", + "urIkz42NDSMhXC6Xdnd31Wq1NJlMLDiRmZOdHbENoTOURBJUs7GxYXJVr9ers7MzY85+53d+x0Ja\n", + "qFCGUfv000/twIikdX193RCDr776ytw0uVzOrE8ItHgdv//975swiXR+pLJut1tLS0s2c6fTaV1d\n", + "XdlrShOAz+ezm7/ZbCoYDGpra8u0G6lUSplMxsRJD7ke1WLO5/OG2WYyGWOtOp2Ocrmc3r9/bwTE\n", + "zs6OfvrTn8rr9SoejyuZTOri4kIul0tv3rzR3t6eTk5ODF3AOo8pkyR+DpI0sgJZ8Qh/8uSJ3r17\n", + "Z7sec+RwONRkMrHyG7THwFtISEejkWKxmI6OjiyEvNVq6Re/+IXJN2dmZkxc3+v19OWXX1qGxmQy\n", + "UalUUjgctmB0dt1CoaBut6vz83NFo1FztKNf/vLLL7W6uqr5+XkdHx8rFAqpWCyaTpxEIhoDPB6P\n", + "oSPchLVaTefn5za393o9q3RutVqGdsTjcf30pz990Pv/qBYz2giPx6O/8Tf+huGdMzMzSqVSGo/H\n", + "djianp7W1taWvv76awtsAVYC1vL7/Xr+/LnNysBqpPwsLy9bKDcaZsgAxEvoHBANDYdDE75DZrx8\n", + "+dJy77B2MTIg1OHfwwAS6gg5QkyXz+ezKFraWZeWllStVu1rgJ1juaI/BYMtGgvMAxxiKXAnGoCR\n", + "C1yakWF6etoO2rOzsxbrJd2NSMQn4MPkiURm9sdej2pmBnxnHgYJYA4Mh8Nm0aFYkYZSxhAkoxQ6\n", + "ttttnZ+f266YSqXMmHp7e6tUKmXjBHMn8s2ZmW/rg53lP8zlLFQWtRP3JhoLrTBMJmMKDCEppUB9\n", + "zoKg1dVVc5AwG7OwGE+mp6eN/EGHwqi0ublpZlPOBsz+RAtweIW+9vl8ikajxnAC0dFzgkLOSTJB\n", + "+nw3ZvzaRTG60xns8XgsGLHVapkrJBgMmriF/jyYuXq9bppliAqCTyBDrq6urCA9kUhYNx41wexS\n", + "zMcQJ3weyjoe16RzcjMMBgMNBgOdnZ1pNBpZHzXlQFDcdBFCeDAKobIbjUZWk8wsi5GXxUR0F0gH\n", + "mRj0HV5fX9uNCjnS7XZ1eXlp5xRnSEyj0dDu7q4ajYalGqGQA9WZmZlRsVi0ZCOETB97PaqdeTQa\n", + "mWoOnfHNzV2fNEHWdJjMzMwol8vpiy++sDeCMhzyk+m/ZqckFJF4L2fJeavVMqSAvGGv1yu/36/T\n", + "01OzEgGtQaIgwCGwkOaqk5MTu/lYBJlMxna5wWBgITHoLyAlXr16ZawaPxMZcoVCwQ5ks7OzRtiQ\n", + "A40Yf35+XsVi0XyIRIxNJhOdnZ2pVCrZDXxxcWGvjySzYJF01G63TWNdq9XMHT4ejy2lv1qtmtn1\n", + "Y69HtTNj1e/1evrRj36kmZkZy2L70Y9+pLOzs3syzh/96Ef60z/9U3k8HsXjcWWzWYVCIQUCAa2t\n", + "rSmRSKjVatnogcUJIT1yTPTM4/FYyWTSHunValXxeNws+fF43HZ0Zs3r62utr6+b5SkUCqler2tr\n", + "a0snJyfa3t42gX4oFDLKNxgMKhQKWY1yMBjU1dWV9SAGg0HVajWrLD49PdXTp0+NrZPuyI6trS1L\n", + "x19fX9fl5aXtkM+fP7cxBMx9fn5en332mbrdrnZ3d602Ar8jTz2nmTgej6vb7Zp9isMiysNwOGwQ\n", + "4k9+8pOPfv8f1c5M2iUBgSRvMkN6vV6z+gMvpdNpIz+YHUEIMLPiY4O1Y94Lh8OqVCqW57awsGCL\n", + "Cr0Hj31ERDgyFhcXLYC71+up3+9rY2PDIgMYSWDOeEzzSGdWRdsxHA4t0IZ6BixJ/B6NRsPCEBln\n", + "nDM5ZAavjd/vNwzaGYzIYsSjyPdMJpOmbcZeJn2bphqLxUxpB9kCdOfMqfvY61EtZsiRlZUVvXv3\n", + "znQZ3W5X796902QysSDver1u+XPtdlvlclmJREJut1v5fF6VSsUeyc1m03Irbm5uLGMDsB+XBrju\n", + "zc2NKpWKnj17Zsowboipqbuy+VKppHa7bYs/kUjo6OjIAhnr9brh469fv7aid1AY6e7mrdfrxryh\n", + "c/Z6vcrn83agmp+ftzEDsRNfH0c57B/5eGTAodWW7jKXcZTwmkmyjI1yuWzumHq9bo6ZTqdjyAjE\n", + "FMQSWXrLy8sPprMf1ZjRbDaVTqdtpyOKCikjj1NKfLDkSzKxEaQBsBJzK0wcNCxO72AwqHa7LemO\n", + "NUOYjpCGmwE/ICIlYr6QrTJ+FAoFs13RNxIKhYwuR1dcLBYth47gQunbInZgvampKVUqFSudn56e\n", + "tlo5bj4SlQqFgon7nz17ZhLWy8tLi9T69R3U7XbbOEVGHjsuh2bEWPv7+xani8oPRWEwGDS57sde\n", + "j2pnBvQHW56fnzeM+Nez0YDC8Ag6U/cR4CCfnJqaMjqXnTMcDmtubs7EO9Vq1WZRgllg8lqtlh36\n", + "iBUAcYFhA6d10urO3Qu/IQE0zn4SFheoC1Q3PdzgwMg4ybpDa0H6EvkXjDDc4IifeB3xBwKzES1G\n", + "tvVoNNLFxYWNSOhbnDsvqBFxw+122yxVH3s9qsXMQgCdIKKVncBZnshj0O12W+wAMk52UkpoWFxo\n", + "k1HBgXQMh0ODvNAozMzMWOAih0SanogL4CnBjMvNgyjK2b9XLpcVDAZVrVat74SnB7UX0rc5zexy\n", + "zOgQNpIMV5dkowtnBQgTbhYWLhlzmUzmnu4YgRLIDuIoRFPAhtwUzvDEUqlkoxBw50OuR7WY2+22\n", + "QqGQpVJ6vV6lUil5PB6LaYXo8Pv9pvElsIXdjMoCdijCDBcWFrS+vm4G1HQ6rW63ayQBuDHySHZv\n", + "dkWn8zsWi9nX4Y3HKU1GHOlHsVjMdCN0GHJQhBHkwDc/P28/Pzs31n7+/Wg00tOnTy1ViadDr9fT\n", + "0tKShsOhGXyxQfE6kPbJRsFNQrQYPzepnhAiBCViLA4EAhZAyUj00OtRLWbcCzgm2ClRqi0tLZlG\n", + "eDwe22OdBTAajYzxgn4lbw4Grl6vm1SR2RwGjhw24CYYMElmfJVkI87S0pLN5fV6/V6dWD6fN2fL\n", + "0tKS4ec8km9ubnR6emrzvCRDHiQZmgPqQAoROmznrA55QnQZMQj0+aFDTiaTFppDTwkwILENVBfz\n", + "c4BcuN1uOww6O7WDwaDJbgme/NjrUS1mQvyur691cXFhWg1gsc8//9x0EdQU8PelUsnqyKhWI5P5\n", + "7du3hgMjq8QdEQ6HbU7lZI4HkUgtmDEqJ5zVaUB4kBgwh8lk0hZdoVDQYDBQqVQyzbTf71c6ndZk\n", + "MrGRI5VKWaVZJpO5F15DQCHnBW7YmZkZXVxcWK0x7QIul8vaqNBP032Ip5Fsul6vp+npaQvYQZvR\n", + "arVUqVSMhGI+ZnYHJUE19x0D6Liw78Modbtd5fN5NRoNawotl8vW0XdwcKDRaGTRq/SQsMjpeEaz\n", + "ixAJzJbQQnQUiHhwtGCrR2ONDJLx4fLy0hKSyLkjdoukIDQmGFcR+ZdKJZVKJatem52d1fn5uXq9\n", + "nlVS8LnOInjYPKIR+H2B55zdJ8y75NhhFSsWi1b1wJmj2+3aE0OSYdwkK9FG2+/31el0LCqBA3u7\n", + "3dbp6emD3v9HBc0hYPd6vfre976nubk5vXz5UjMzMxbp6qws6HQ6Ojk5Mes7J/FEImGWfFLoe72e\n", + "WfMhGxYWFpRKpXR5eSmv13uvumxnZ8cWwd7enh0McYHjj6MaQZJFw4ICOKllnCuElsfjcUUiEZu3\n", + "wbdnZmb0/PlzDYdDPXnyxHZ+SdZ4hZaEgEefz2dtU7RM+Xw+vXjxwlAXyCfIGTq3k8mkCoWCUqmU\n", + "pfYHg0F7QnGQBFenKZaD69dff22E1ubmpr788suPfv8f1c4M6uD1elWtVu3FlO7mW2fVGVoCXlSn\n", + "JQr9AzMirmlEPbz5UMPkInPK55EZCARMT+wMAcdVTZImhzJm/larpVqtpvn5eQtY4VDFXE/VBeIh\n", + "mEksYhAog8HA1IDY/AlugZ6GTLm+vjYWcTQaqVqtKhAI3NvNGRMWFxcViUTUaDTMoMBODI6O6QGr\n", + "FWcCnDntdluxWMwCK79zZzuuubk5ffjwwaC1TCZjrBSjwuzsrG5vb1UoFJROp+X3+1WpVMyRzbzM\n", + "okXKSb4G1PHU1JQCgYBqtZrFFDgzI5wkDbs7uyxubkypqNIwdYKY4HJ25kUzOkBiZDIZY+awL4GH\n", + "w1SilYber9frarfbBkcyqoC7wwRyYC2VSmo0GjZ2kcXc6XSsCoNFSR4fOmVkuKFQSBsbG/Zz8jPx\n", + "/UKh0HcHQOdVrVa1tramy8tL+Xw+bW9vm9glEAioVCrdOyw542+RJPr9fkWjUQWDQWUyGdPgYnWq\n", + "Vqsm6SQDGoyVnmwOQYSfoKS7urpSs9m0PhUSQHF8I8h/+/atHQ57vZ61vjpd4UdHR9Yjws1B7C5K\n", + "PpfrrlC+2Wxqf3/fVHTdbtdGFJfLZQgDiaLYnaDV2YEJvuEgDOYcCoWsQo1DHXMyQeK5XE4fPnww\n", + "Idji4qLdGPV63Wb7h1yPamZG6JJKpewASDBgPp+3kEHeuFAopJ2dHROVj0Yj272vr6+VSqWMlUJc\n", + "g+vbyfKRIgTRQdo8VDS1vIw08XhcuVzOHu+wiqPRSD6fT8vLy0Ydh0Ihe9zDsN3e3mp7e9tiEKh8\n", + "QxvsdruVy+WUTqetuoLwGoRG+CA5OyB6oj2An2t1ddXo7HA4bAxiIpEw1wx6aL/fr2AwaOMT1DUx\n", + "ZKjj0MzQiOXxeKyi+J//83/+0e//o9qZcWBzAEGAg9A+mUza6Ztynf39fUMxJpOJFfBcX1/bgREZ\n", + "KOmfvNGEuEiy3ZkF2u1274nvcZigHqNtdW5u7l4gDfoN4C7sUbhMWIztdtvQievra2uMku4OqLFY\n", + "zNCBarWqZDJph1/6U/BHIoDC7Y0znYRSMPSTkxPd3t6q1WqpXC4bgTMzM2MbCSMX/06SvSYLCwuq\n", + "1Wr2++LIRmP+HTTnuBDOg+9ie7q+vraoKnZBDnBPnz615HuwY2odnDJHJ9RFDgR4bb1e19XVlSVr\n", + "IhGlv4OcOxYmnSXxePxekidaCXZ44DNQFFRsMG6YU5lTIYRwi0AAgV9LssMXMzI9JSjdiKvFGuUc\n", + "d1h4HKR5kjHmIOpyPqGAE4fD4b1K4mq1aiNJr9fT9fW1qfA++v1/2PL563UNh0PLWuZg02g0LBG+\n", + "UCgok8lYKEsul1OhUDAvHnhrsVi0GZhoKjQYZFJw+GIxSHeqvXa7rVarZSJ+BP6o0YbDoSUsUcng\n", + "VPaBXbMoGZcGg4HN+9yU9IFgU2KmPj4+thq5crmss7Mzi9RijmYnHA6H9rrAmBJJxgFPkiWoViqV\n", + "e2eGbrdrbng2DnoJQS/q9boajYYqlYqurq5UKpW0vr6uXC6nUqlkAq2HmFmlR7aYwS/ZedBidLtd\n", + "e0Gvrq50dHRkhkzcKYSysNtymmcHlGT/XpKpzfC89ft95fN5LS4u3mPYmFNRhXHjsKgvLy9tETnN\n", + "AVwsDNqiRqORPR0k2ciESo2oAAgOoDwOb8yseP9AQHjNiGXAWOCMmG21Wga1URXHmMNZAzMArxOv\n", + "HSo5RP50d0Nr06L1kOtRLWZYMvSx9GXMzMwYFhsKhbS1tWWdHEgZ2YVAD5hlWZSk83AgDIVC5jJG\n", + "EQaS4gxIBGFwLlB2WA5v4N7sxNyIhM0w96fTaZvtna1N/PvDw0ONRiOtrq5ajjTin2KxaGMLvkG/\n", + "32/IBloKn8+n9W/KPm9vb7W0tKSLiwsbD6hThjTh4IwGhQYAdnwSlgh2dLlcRnd7PB4jg7xer6LR\n", + "6IPe/0eFZsBixWIxvXv3TrOzs9rc3JTP57M3mF1xe3tbxWLR2DRs99VqVdfX1/YxDk3smDRHXV9f\n", + "a3l5WePxXec1LmTiacmzwANHAIyzZoIQ8m63a8U30l2YDYuLg2cymdTV1ZVWVlYMr0aVR+AiwY8c\n", + "NmHvarWaYrGY2ZkIKV9YWFA6ndbl5aXdVLlczhqk4vG45ubmtLu7azcNIZM4wbGeSTIqPxAIWJ3F\n", + "zc2NVldXVavVbOHjZWQnR2m4s7Ojzz///KPf/0e1M+ORo0fPiQAgeOFNxkFSKBQM3AfzJaiQAxCw\n", + "HE5vbgpEPJze6aeem5tTqVSyXR4MlnBBxgoWPLs/cy15xuC25+fnhs6gDQYblmRhhbBonAP4Nzwh\n", + "yuWyHUoJRgRZ6PV6qtVqJk7yer06OTmxUYA0JHQfmBiYnUGAiAZuNBrWNksjAQdVwhLJZCY64Tuc\n", + "2XGVy2WFw2HLV6vX63b4a7Va8ng8Jj6XZD64VqulcDhsaAJZa+12W2dnZ5YIxOO01WoZ9Ypw/ubm\n", + "xpzVR0dHJsGkVswJ44GtMoMzr5MPHQqFzKsIZutM5eQQRh4yEtBcLmd2KKxUCPdBJTg3YAwgCkCS\n", + "RQDTgYi+m5gGkvx5LWEO+Zk5dIOPowakJgMokKeTkzWFoXzI9ah25ng8br44Kgjy+bxRxbVazRg4\n", + "qOFOp6Nut2u47vX1taEUaHWPj4/tjWMm59CCDmI8HlupeSKRsMcxlipYSC5O8CQmtdttRSIRa0Jt\n", + "NBrKZrMWWlOr1VSpVEwQxS6Nmfbi4kKLi4uqVqu6uLiwRdPr9VQuly1SDMaOuAQ0FaAz3W5XJycn\n", + "drOiyWYnBfa8vLy0cabVaimTydgTS5KJn/g9z8/Pza/Izdbv923Momb5Idej2plJfy+VSjYjr6ys\n", + "WL6cJDvI3Nzc6LPPPtMXX3yhH/zgB0asBAIBffbZZ0qlUrarUSkGIkDGm9/vN6yU+ZJdkAXe7Xbv\n", + "FdRD1rBTBgIB7ezsWCcJBk+CDMFx+/2+Xrx4YcL3TqdjcWC0rJ6dnSmVSulv/a2/ZXpnHCYXFxem\n", + "5QZ18fv9ur29VTqdVrvd1tLSkmq1mhKJhDwej2klIDyQBEDwVCoV7ezsWIkRO+zi4qLevXtn4vte\n", + "r6e1tTXNzMzYzO/xeHR2dmb4NV3cJycnH/3+P6qdeW5uzmztsVjMnBXAbPl8Xs1m0x6bmUzGegE5\n", + "2DUaDZsdS6WSKdd45BPgQmqPJJtnKefhUINNn8c9eDIkAl8XvTK2J0m2izF7M+vzcUYFbrhms2m9\n", + "K2ixEQixg1PGzhOJ1+X9+/f2hOp0OioWi4YXS3dPD84ZPLHY+amLgNZuNptG6sBoAk2SntRut3V8\n", + "fKxoNGq/N6/TQ65HtTMji+z3+3aCR3WGO8PtdlvlApoN9BvIGSWZH45Cmn6/byU/XHjnCHRhN2bn\n", + "BdelDIj5GCUeQh9nrjTxB9DClNlj/8LTBxtXqVQMbuSpU6/Xzeofj8c1NTWltbU1EwjBPM7Ozqrd\n", + "blu7Kwwo9PLs7KztukCbkuyJwNwrydKMQqGQpDtnC2MRmhSv12tPSOS0QJy3t7f2BPzY61Et5nA4\n", + "LJfLpcXFRW1sbNjBCvoV8+nl5aXZgXCOhMNhJZNJ5fN5G09OT0+tyw4xPRcQE2MA/w7smZ2cXZyg\n", + "bg483W5X6+vr95RwpHpiu2LnRc23uLho+g8Sg4DmJBl2HIvFbGFyCKPnMBaL2cF3fn5eT58+tdHF\n", + "5XIpmUyaFpuK44WFBRuDCDkMBALqdDpaW1uzBiuIFlKOMLSSeETjLdAfehmIFDaSj70e1WJuNpty\n", + "u926vb1VJpO5lxUHAZLNZi17ghgC2Dh27Q8fPphz2ykeGg6HarVa5kjBjEoKPJoM3lBwZr43OxU7\n", + "OTDeYDCwXZL8Z0YLHNZoj8mvKJfLVtADCQMaAbFCbwvMIT+v3+9XqVS6h9IQSUB/S7/fN80xwZBo\n", + "tIPBoIrFohlYUe/Nzc2ZlDaTyZgzHjtVOBw2zTidhdwAzPIPuR7VzMwjFScxqe/RaNREQCwO5sdk\n", + "Mqn5+XlzO4BCgIxgwSephxefGohAIGDfL5lMam1tzbLbgL8QMSEVrVar9rGbmxtrkp2fnzfxfyAQ\n", + "UCgUskMbkQI8/nF8JBIJxWIxExmhpGO0wW3CjE9/H/0sXHNzcxbTAK0ej8eNHOFjvA5EgPH9uPH5\n", + "upubm/fy+5CL+nw+RSIR+/md5wvGmI+9HtVi5sXhDgfIBw3IZrPGqGGopN4BOpv6MzLYgsGgNjc3\n", + "VavVbFxwluUQQTUej1WpVIzggFQBt2Xhh0Ih0zOMx2Nzq9CV3Wq1lEwm/41drFwu3xOx8xRwEjcz\n", + "MzOKRCKmTUZQ5fF4bBbP5XLWXotHEXUdrhnID+j96elpra2tWZE9MzWifV43btZ+v2/wJgZW1H24\n", + "uSFgODgvLi6aM+Zjr0e1mAuFgkXS/uIXv7BTfrVaVblc1mQy0dXVlT58+KDl5WW9evVKX375pVU4\n", + "cBJ/9eqVGo2GcrmcMpmMXr16pVqtplqtZmgA1n92YP5cqVR0c3Ojk5MTC4chEPHw8NCQlFwuZ8RM\n", + "Pp+3SgS3261KpaJXr14pn88btkv9mXTHdB4dHSmXy5kOpFwua2pqSqenp8b2oUU+OztTOBy2Gxg2\n", + "k50wn8/r9PTUkvcRMaGEazQa+uKLL1StVrW/v2+51cQiDIdDy2gmpgyJLBsMgqpms6nT01PL9cP1\n", + "3W639a/+1b960Pv/qBYzpYy4HkjZQSS/sbFhyZ29Xk8/+MEPTLWFLoLYgPF4rKdPn9oBEUMrJlC/\n", + "32/sFoQKJ3b6Q3BiE8HFqBAOh/X06VMjDZgXp6en7ZCJdYlHujNQhlSgaDRqWuR4PG6LxO12m/uE\n", + "wzAYOp9PfVuv11MymTRBEhG+19fXdkhk502n04Ybc+iTZBUa0l3O3vLy8j31IsmnHJhBl54+fSqv\n", + "1yuPx6PxeKznz58/6P1/VIsZK73L5bIXVJKhDTRHsWOxA6Gsi8ViFrNFUeX8/F2v3+bmpgmPmP/c\n", + "brei0aiRCk7jJrAVHkMWOoL2arVqijvMnGg8pqamtLu7azl1SErJvvN4PIbrJpNJ0wwnk0mzIlF1\n", + "jO4jkUhoYWHBbmTmbhakMwgdMwKNt1D9l5eXCgQCFuMr3TnRWfTkSIP+IJN1YuFer1exWMzS+jmE\n", + "S/qOznZeULvMlbBUKL5ub291fn6uy8tLzc7OWu0BWgMsTufn55Jk4ppsNmvBhM5AFEJaqO7F/QxF\n", + "DNWN25tkTxJ+FhYWdHl5aXMnYiEe97g3bm5uDOEg563ZbNpj/vb2Vvl83tqeyuXyvdbZw8NDm8n7\n", + "/b7Fg/Fz5/N5q2Zot9tWIXd5eWndKDc3Nzo4OLBxC/koC5cRjXMC2R/Ak6BFJDIBo5JgipHgIdej\n", + "WswEHQK+k/5DUPj09LQleEKgQE3Pzs4qGAzargcEhYE0FouZe8Lj8RhGTQbG/Py8Op2OotGoEomE\n", + "LSyQE3Y35lUc106BvzOQBY2JJBt7vF6vif/BvRkdnKo5SYbEOLMoqK3AbYIlCxiS34nF67wh+TsM\n", + "uYxNXq/XUolAefg40CS0OcgP4xWSAEijh5ImLnac/79fLpdr8g/+wT+wEz96hX6/r2QyaSd1VGXY\n", + "ltAkYOwk8Scej+vNmzd6/vy5ut2uCYUKhYKi0ajNnGCr4MnORy07GOwaVqTZ2Vm1Wi3FYjE72F1d\n", + "XSkcDqvdbisej8vv9yufz6vT6ZhQH38gdqx4PG7fA0SEYHJuQq/XazJYzLyQLYwO7KQcCsmjLhaL\n", + "CofD1jRVLBZtgZIgOh6PbfZGk03RJcExHo9HlUrFCn1YvAicON/0+3393u/9niaTyUelwTwq0gQG\n", + "6+rqSq9fvzafmd/vN6lkq9VSv9/X2tqafvKTnygYDJpA6OrqSpVKxaxCV1dXqtVqqlarhsFCOuDz\n", + "YwaV7mbvYrFo3YBPnz5Vq9XS0dGR0um06alXV1ctpAWYDkwYGvj8/Nx0zRwgm82mNjc3rXAHOhg1\n", + "ILkcw+FQqVTKRqzRaKTNzU2beYHhkJ1yqEXGyY3FXD8YDEwlR+dhtVrVD3/4QwUCAWv2Iq8OcokG\n", + "WSSh5XLZ5KXOThUQnn/9r//1g97/RzVmEEqCKL7b7arRaNjjFlF4u922w5NTYkkxPOwd1DIh4ZLs\n", + "UYtP0Kn9IEmJ9MzXr19rMBgoHA7bbglujKgGOI6F1Gw279HYwIbEBVSrVYsEYKcFHgO3vr29NaYT\n", + "RAWRENVwVkvA8QAAIABJREFUfN7S0pKxg1QQgwlLsqyQer1uMtp4PG42KA7JjC0gH+zyvB/ENvh8\n", + "PkmymF3iBYBUH3I9qsW8uLhoijd2JVgz52wK5MWjdnZ2VpFIxA5ACMWdSADhiSTvc8Ch5BKkgxAW\n", + "DpV4AUFFsGeRXYEB9OTkxCJp+XuE78zfQIiI8Jn5CbEhzFH6VvjDeIWjptPp3KuDy2azpnzjTMHN\n", + "TAQu/Yr8t9ONDvvH/wjJIXqLZCMkAI1Gw8J4JKlYLJorJpFIPOj9f3RjBrQoHSS8aIRe0ylCdFS7\n", + "3Zbb7bYT/vT0tIrForxer8rl8j1GDFwXXJTqXoRM7Ix8P1LzeVSjaU4mk5bGD9THrE5PHjtXPB63\n", + "WZ+EoFAoZPnLzOqNRsM6XUBqJFm9Mon3NMGizWDUAbuuVCqm5yA1n5w8Wgb4MwffwWBg2XdcvLaE\n", + "koO8AP1dXl4aHIlW+qES0Ee1M7tcLgtD3NvbMxVaMBg02IeUIGJlUWwBhd3e3trBJZVKGbLBDMkb\n", + "y7jAYYbPY1asVquWME+OMp1/tVrNZmXmSfDm0WhkPSHM5sCNhULBPIDMpxzsKNEJBoOm6GPMIqQR\n", + "byQRWyAexAIQZ+sUHY1GI8OI6RPHTTIejw35yGQy9vry88bjccP0cfOgvkun0+b5cx6YH3I9qp0Z\n", + "8Yvf79f79++VTCZNWBOLxUweWi6X5XK5lEgk7NDlTBFiMSBVBD8lbHA4HGp9fV2NRsMqJyh5h1Rg\n", + "XJhMJpa/jNAGtVi73baDGZFeyWRS29vbevv2remsWQigAR6PR8+ePbODHAuTcJcXL15YqOL09LSy\n", + "2aw2Nzd1fn5+zx0j3R3aqFXj9eAGpwWWtHxQG24AFIqj0cjkrPgVk8mkjRs8jci7W1paUqPR0N7e\n", + "niqVijGYoVBIf/qnf/rR7/+j2pl5wyWZ4ByigYxloKVYLKZ8Pm87H24TSdrc3NTMzIyOj49NYMSh\n", + "iMchCywej9/r3O71eqpUKqZrzmQylrhPvluhUNDl5aXi8bguLy8tnosZvVqtKhaLmY55a2vrXqYE\n", + "CAVRsJhUB4OBVS/g8CB/7uzszOIDOGxhlmWBIgIiUgsJLVplapTj8bglIlEGRFWFU9F3dHQkSVpa\n", + "WtJgMNDXX39trCCQXzabNeIIVOhjr0e1M09PT1vZTb1e1/Pnz43xOj8/1+npqc1lBIAfHx9rb29P\n", + "0p3gBjPp1tbWPSoW6AwvHfkapVLJZlQgvPn5eXvs/uAHP1A2mzW3NTAgVDZ6ZIIGqVxbXFy0iC2n\n", + "3SoQCBgbiJ7C4/Ho4OBAq6urRmUTJYa7hEX91VdfqVgsKpFI2NhzcXFhkB1pR6urq/rlL39pGRvn\n", + "5+eanp7WxcWF+v2+hYk3m02dn5+bxezk5ERzc3M6Pj7W7u6uBoOBjo6OrLSICggiGDhwl0olvXr1\n", + "6kHv/6NazF6vV/1+33ZLQkl4rK6trZnJlF3rk08+MYOr2+3W9va2fv7znxuIv7q6ajt6NBo1JouG\n", + "15WVFeVyOYPLnCbT1dVVEx1FIhFVKhXNzMxYKAzjAV0shULBXC6wlzRGoYHAcJrJZGy3Ho/HWl9f\n", + "N5auWCxqbm7OPIG9Xs9Cb+bn57WxsWG2MuA9dt1yuayVlRXD7GEMd3Z2DO2IRqMWNjkYDJRIJGx0\n", + "QgcOk0r4JK8NEQtUFK+vr9sTb3t7W7/61a8++v1/VGPG5eWlZcelUik76WMBIlEIdAHRvtfrVTwe\n", + "t11RkiW+j0YjraysaDAY2GmdR2Kn09Hh4aEJlXw+nyEf6XTaDkHj8dgOgWRXcFAjZ+Lg4MDgsMlk\n", + "onq9bnh1KpWyQktaVN1ut4UpDodDC11ETLWysmJS1V6vp/39fatj6Pf75nahv5sdGVsVoqZut2sB\n", + "i+z2zogwmlyvrq60vr5u+mTcOWg3aMjNZDKm94DVhIl1+is/5npUixlrOzJDFiQHtWazaYvc6/Va\n", + "VgMaXFg5aG1EPGdnZ4pGo9YJgjl1bm5O6+vr5pQej8dGoDjZPEkGwbVaLYP4gAQjkYi2trZMmgmR\n", + "Qr9etVpVu922sG8OVaT8o4mQZHoOerbx4q2srNzDgKmyIEgRTQhPEuZXcuiA0IA8MfjC5C0uLhq2\n", + "Dj4OdU6KaqvV0vLyspljnS6VeDz+4Pf/US1mBOiSjJzgQIhGAsex2+1WPB7XJ598oqWlJQsMHI/H\n", + "Jtl8+fKlHRihXCElgsGg6TAk2cLk4AWVy8GPz5mdnbXFj6aB/7+5uVEsFjNIMBAIKBwOW0Ycrmyn\n", + "OEqSkSOMWRwMCasBmgNyg11kFneOQNwMzPZ8HnAjgiiUe05tBi4cDpTs2iAt0p0cN5lM2muGis7l\n", + "cln18Mdef2WL2eVy/W8ul6vscrneOD72P7hcrn2Xy/XK5XL9Xy6XK+j4u3/ocrmOXC7Xgcvl+k8d\n", + "H/8Nl8v15pu/+5/+bd8TlVe9Xrf+jIuLC1Oq8diFkMC6wy4ObV0oFNRqtXR8fGzlOuPxWMPh0GA0\n", + "sF7eQElGF8N6FQoFix+4vb01ZwXfi1YmaGEKKsF7OfyxGDn9QwPTBzgcDo12R0PtxIwxDpCNDK0P\n", + "Y9jv920sYccmQJzMOyIJIH+mp+/6vmFF6WzhfQBhwYBLyLskk+fip+z3+/9eogb+Knfm/13Sf/Zr\n", + "H/t/JD2bTCafSvog6R9Kksvl2pP0X0na++Zz/onrW+3i/yLpv5tMJjuSdlwu169/TbvYMaamprS/\n", + "v2/BfZPJRI1GQ6enp7q4uNDh4aEJdw4ODuzNx692eHioTqdjweJnZ2fyer1qNBoKhULW5soC4xH7\n", + "6tUr25FwTPOzYIxFSE9kVqPR0MXFhT3COcA1m01dXFzo+PhYNzc35iAnu6NcLiufz5sBFX10t9tV\n", + "oVBQqVRSJpPR+fm5eR+pJgaCa7fbKhQKyuVy+tWvfqV6va5ut6vj42PL0CO4/e3btyqXy8pms/bU\n", + "Y3YGmoQwkWTjGK8hpBWkETcXeXdnZ2f6F//iXzxowf2VoRmTyeTPXS7X+q997E8c//kLSf/lN3/+\n", + "zyX9/mQyGUnKuFyuY0mfuVyuc0n+yWTyy2/+3f8h6b+Q9OO/6HuSk+F2u/W3//bf1u3trT755BPN\n", + "zMxY0TuObMYKbO6IiiTp5cuXSqfTBkdtbW3J7XZrfX1d2WxWKysrVgQECTM1NaUXL16YK3p2dlbr\n", + "6+tyuVz63ve+Z07qbDardDptemVK0t1uty4vL+X3+xWPx00HDGGztrZmdRDr6+sqFApKJpOmiSYs\n", + "MhKJmN4ZTUetVjNtNiTMYDCwSAG+z87Ojt68eaO9vT35fD49efLE6HRMrLu7u5aGtLy8bPkZ0PdA\n", + "gCSyrq6u2rgBMrO1taVSqWQpqM4O84ODg49ec/8xobm/K+n3v/lzStLPHX+Xk7QsafTNn7ny33z8\n", + "L7xKpZLi8biq1aqy2ayWl5dt10BRRwALLxyULimVKMygYqvVqrmbCVlBylgulw16IkR7NBpZeAyH\n", + "QEYdSRYUiPMEkiOVShl7SS6Fs5EJRIGiHKfAiTkVbUomkzE9BEKnWCxmjhc0Iq1Wy0rn+VmI/4WG\n", + "50xQq9UsTgsChQMfB1IUipgPoLqLxaKp96DrV1dXLYwccdhDYDnpP9IB0OVy/a6k68lk8s/+fX5d\n", + "ZmMyKmDv8PeBBIB4rK2tWRMqM7XT/+dyubS6umrWH1hEqnrpsuOkz1wsyYJVoJ8hO9xut9UzoMxz\n", + "u92q1WpaWVkxFABIb2lpycRBPNr9fr85OjhcohumgdUZASbdVRlz6MTU68y1SCaTFk0g3ek0wKoZ\n", + "gYrFou2yzN5g9JgIQqGQotGostmsHRIp+OEACyoTiUQMPRmNRtrY2HjQ+/8ffGd2uVz/raTfkfSf\n", + "OD6cl5R2/PeK7nbk/Dd/dn78L429+dWvfmVU72/8xm/cK14HnyWgpVqtyufzaWNjwwJi0D4sLy9r\n", + "b29PP/3pT03WiZLs5uZGa2tryuVy1lZ1eHho1iLGi263q4ODAz179kyxWMyYRKA3dA8o2UhGcrJ8\n", + "CNpjsdg92aXb7TYTKZgxBzev12s4Ljg6yAiQJLsz4iYSTImgJXv55cuXqtfrWlpaMhQim81am20w\n", + "GDTtNYJ7SZbFQUg7cQwgMn6/X6PRSB6PR7u7u3rz5o1mZmZUKpUetLb+gy7mbw5v/72k355MJs42\n", + "lv9b0j9zuVz/o+7GiB1Jv5xMJhOXy9V2uVyfSfqlpP9G0u/9ZV//t37rt6w+rVQqWTE7kkcyjQuF\n", + "ggUJQqWS7xAMBq3sxuVyqVgs2mGNKKpisWh0Nrsr6jBQhYuLCy0vL1uaJo9rbFGlUslkk91u10LS\n", + "mX3b7baJcDjE0sXNzgdWWyqVrJuEeje+LwHmCwsLdhAEDkNgDxsYiURMK720tKS3b98qlUopm83a\n", + "Tt3r9Ux8RSQYSI8ku+Elmd2Lf9vpdLS8vKzT01MTds3MzFjp5uzs7INm5r9KaO73JX0u6YnL5cq6\n", + "XK6/K+l/luST9Ccul+srl8v1TyRpMpm8l/R/Snov6Y8k/b3Jt+bEvyfpf5V0JOl4Mpn8hYc/SRbR\n", + "yu6Gg2IwGGg0Ghn9y04pyYoaoamRTALoo0nmoAhVzWjCIubR7XLdNU8lEgl7jDvz6njsY/ik4RWB\n", + "Ok4M0uWBtnCNkNEhydhDyBooZp4+y8vLJoOdn583+prdEuaQ187j8RgjCgHFrAuawgJFF47UFEaT\n", + "QzgYu/Stkdbj8RgsB1bOkwmDwYPW3GMytP7u7/6uUdIEaM/Ozlrw+Oeff67NzU1ls1nF43Elk0n9\n", + "wR/8gT777DObBYmJhREDCy0UCiZ+j8fjljdM2QzwGXM5Yw3wFG+oM2fO7Xbbjl0qlTSZTMwQSnYb\n", + "bBq/C7oTXNpQ0pKMweTgScJTqVS6V1fMmBGNRnV+fq5QKGQ4MomkHJ4jkYjy+byNDPl8XqlUSt1u\n", + "V8vLy2q32ybCkmTudzYEbgTC1RnH8P+dnZ1ZeVChUNA//af/9KMNrY+KAaSiIJlM6sc//rFSqZQO\n", + "Dg50cXGhP/mTP1G/39ebN2/05s0bjcdj/f7v/75Ze7DznJ6e6l/+y3+parWqn//852q1Wnr37p1V\n", + "O+CHk2SHsVAoZITK2tqaIQHhcFiBQMAe04jrA4GADg8P1e/3VSqVdHBwYKMAMbK1Ws28f+RwkMo5\n", + "NTWlX/ziF5Yf1+v19OWXXxrN/MUXX1hgeKlUUi6XMwqdw5b0bTffmzdvVK/XVSgUVKvVlM/n5XK5\n", + "dHx8rC+++MIIHjDvarVqss2bmxtdXFwYG0igOOVBbAbFYlHSnU3q8PBQs7Ozhq93u11lMhl99dVX\n", + "D3r/H9ViJgCl3+/ryZMnqtfrFsZHd3QoFNLu7q6ur6/15MkTo1LxqE1PT1vJeiKRMDwYaxNs1fT0\n", + "tEkaLy4u5PP5lE6nLY+OVM5CoWBZ0fQJokXG0r++vm7QVrfb1Wg0sogxRobp6Wmtr6/r8vJSXq9X\n", + "qVRKt7e31gOysrKig4MD3dzc6OXLl7YLLyws6MWLFzZz4wFEVVir1Sz9aX193Zg9SYYrEweAXgVF\n", + "H/G3CI56vZ7djLwfyGiXl5etgWp9fd0MrrCyZII85HpUi5kTNwA8eQ9OJwnQG91zSEFRlzGSSN86\n", + "k3FUIIqJRCKG1YJRS7L6taurK21tbanT6SgQCFiSfiAQMNE+nXjT09NGYaOqYwQBZnS57nrAsUnR\n", + "XUgMGJQ0Og6n3xBcHdMAX5sx6vnz5yYLZTcFLw8Ggxb2ArkB9Mesz8+NrgP1IU8t4monk4lCoZBS\n", + "qZS5W9goPB6PgsHggxfzo9Izx2IxE6RfXl4qFospk8koHA4rm80qFArp+PhY/X5fS0tLNsNho5Jk\n", + "GRE8sj0ej66vrxUMBlWpVNRsNhWLxTQej42Fe//+/b3uEyrXvF6vaXj5u6mpKZVKJRWLRQukubq6\n", + "UiKR0NnZmZW2I5EcDof3lHfFYlErKyva39/X8+fPTaiPl7BQKJgznfkdzTF6Ehq3pqfvmlLb7bZp\n", + "kU9PT+3gR+D4YDBQtVq1kWlhYcH8egiIIJdOT08N2qtUKmaOKJVK2tzcVLvdVqlUuhesjtPnu3gu\n", + "x4VMkkwLshw4WNFfMjs7q3Q6rePjY3uss0uTtUzyJocw8h1wMFOV0G63bUTx+XxaXFy02K5gMGiP\n", + "dnZ3AgnxDaKrAAGBoCGDAocG0bh+v99y6cjUIHOaoBrIDvTb/A5zc3OGcqTTadMo82QoFosKBoNG\n", + "vpCvwe5/dXVltWtQ5mg9oPE5CLOjEwFMljQ9jKA76KVvb2+/W8zOy1lsg4yTiFpiVSXZYxBLEIgE\n", + "lDMWfhan9K3kE3cy8zM1ZxRAokNGXgnNzfzqtDEBR8EsAmexWLFg8W+RdbK4xuOxQYXOMcVJjDBq\n", + "OGFLYDUYRIJvwHrRqGBqIJODjDk0JYw9kmyBsykgRWWkgIUFeYGlhfzhd3nQ+/+gz/5rdlGzi4YX\n", + "JRn4JzkOzJEQDGQIl8tlDYdDbW5umgwSWWOpVLKdfm5uTsFg0AISmc1RzzUaDWP0isWiOS7y+bwx\n", + "YdL9EBVy31hwpH/ys7EIcKrAoKFrmJmZ0eHhoQaDgXw+n0qlkmKxmBXgwM6RPQdjSLkn4whxvaje\n", + "pqamVCwWbd5GU4K2udPpGAGERoUAm1wuZ/S8dOcE4hBZq9V0fX2tXC5ndDkHx4+9HtViTiQS1uhE\n", + "ChHJQ3SXOE/XqLXw9EUiEWMGEb4TYsIuWavVTL/ATIuoCMEPTVIul8t2ymAwqLW1Nbu5YO/Ynckz\n", + "ZidmROEg6/V6tbq6KpfLpXA4bHUPOE3G47EVVUp3RgUcNjjHMbtCX8PgQaKggeYQOhgMjKxBGgAd\n", + "vbKyYj/Xy5cvbf4lnsHn85keptVqmeMbNR8JUqQ31Wo1PXny5EHv/6NazOPxWJlMxmYyv99vmXMQ\n", + "FdLd3Eu/39bWlonv0TVgNE0kEqpUKuae9nq9SiaTNkM70/HRcHi9Xi0tLVmGBiHk7HbOvAlQFhYA\n", + "kkhgNeeiDgaDpv0YjUbm1pBkeRVouREO8XOQWkrcb6fTMRJjMBjY7rmzs6PRaGQMIAdkn89nLhny\n", + "QQhSREXIARhWlKfNwsKC2bcQOZHMjxab1x5U6GOvR7WYnTnCHOzQ3rKLcfLv9XrK5/NWeSvJhDg0\n", + "kubzeXk8HiuShD3DuUFkLoufpiocFhyOOASCmCQSCUMhwuGwhZTDCCL3JFmeGbrT6SgSicjr9erw\n", + "8NBw65ubG6PMJRn+DNTm9/uVSqXMGUIeBv4/YmxZ8HNzc/b3mFoZ3ahCY25HVxKPxy1wB10L5wC/\n", + "369EIqGVlRWNRiNVq1VzuyNaImnqIdejWswcYG5ubizIkN2ERYFM1OW6q4pAi4B+gbqGUChkownz\n", + "KYsKurpYLBpFjQkVySmRXcy/GE6vrq50dnZmRAGsIgc5xpRoNKqNjQ01Gg37POZ+dkQSmtCMsBMy\n", + "OqyurtpOjisGBhOTKq8XcQC4P/AK4qTpdrva3t62UBhcMtxA0PugGsFg0MYKKopLpZLcbrcWFxeV\n", + "SCQMD+dmeSia8ahwZtRl7KrQqOFw2BqQMGmGw2G9efNG5XLZ6Oj/l703iW00T9P8HmoXJVIiRZEi\n", + "qV2KiIzIyD2nq9CDBvpiw30a32wffDB8m4MvBgzY1wF8NGD40BfDA8xlAJ8MH+zxwJgFVWigcmq6\n", + "KisyMiO0UiLFfZcoiRIp+qD8PfmpptszCLnHM0J9QCIztVL8/t///77P+yzlclkvXrxQoVDQ/Py8\n", + "Tk5OHDXMzgrvGC0hQwAGE+xmhOUsLi56pMvDABYtyRyMRCJhoevs7KzK5bLFotiGzc/P6+zsTLu7\n", + "u1ZqYK8AFHl5ealCoWD1Nr8rk8k41mFiYkKNRsPkn3q9rkQi4TiKpaUljY+Pq1wu2zdjYmLCu/3K\n", + "yoqHIggaaJTByA8PD7W7u2sz9nq97j6iVCoZvgueZD8p5T7selI7M40MkibpfrcG06UejMfjtodl\n", + "58Gyip2SHbbX6xnCgojebDat8UN1Qpe+vLysy8tLvXz58gGRqN/vO0AHGKxer5sQX6vVPCkEFSB+\n", + "jF0YZQc7ZxA5wMZAuh9tLyws2DGoVqs5UJ4jHfQA6ma73bbd2NnZmRGS29tbW3ZR14O40ADe3Nx4\n", + "sBNkGA4GA1UqFcN2xWLR7xvlBfkpiCQecz2pnZlGDFvaeDxuU5WJiQmPUIkbY6GAXqTTaRUKBcXj\n", + "cX388cfqdDo2+wuFQrZwDYfDnohtbGzo+PhYU1NT2t7e9i6Lxk6SHX6INeN3ElIDAQj+CJNCGkwY\n", + "asik+FzQqDyfzztWAjTi66+/tnp8fX3dMRHHx8cPPKdJoZqcnFSlUlE2e69MI+EWjd/FxYX5FLe3\n", + "t2YC3t7e6tmzZw80mBsbGy7XwPVBRxAToCGkgQXC+9DrSe3M/X5fb968US6Xc5PX7/d1cXHhiIdG\n", + "o2GC0OLiov3fIPpIUrPZ1NnZmW2oMPWmFKnVat6hjo+PH5DqoVZiOoNrz3A4VL1e9y7H8czYmQkY\n", + "sn/gtEql4mP67u5Op6enJtNTxxOoORgMrMKen59XtVr1xI3EKRpLbA6AIAn9xCByZmZGBwcH5kpT\n", + "nkCBheRPuRU0LG+1WpZN1Wo1XVxcPNjt7+7u1Gq1VC6X9fbtW01NTRm/f8z1pBbz3NycXr9+rUQi\n", + "YbiLXS9ot4XnGjcUqwEYbXhZYDoOUYadjWwTJmw4HOEOCiuNySDQHoMLnPsh1jN2Bm/e39+33wV1\n", + "ftAOdn5+3gaGQesxSa7fiUoD1UmlUh7t7+7u2jar0WhYOQIGDwrDBA9iP68fe7JoNOqUKyBNsGp6\n", + "F0hS4OIseiZ/6+vr9gZ5jMpEemKLmXqQWAU67aC8iAVOh12pVFzXQoqBa8DYlv+HrwBmDaoB7txu\n", + "t01wl6T9/X0LaFutljHmfD5vsnuv17M5DMqPWq1mBGVubs67NJ4bwYcLTHc0GrkUQVgbjUZ1c3Oj\n", + "Uqnkr6O+pTGliQyHw6pUKnb1pLaHrFQoFDw1pTcgonlpacmuR91u105KnI5TU1NqtVoWFDB04sHr\n", + "9/s21HnM9aQW883NjW8wzRq4MCSZVqvlWF285wiKZDqH29HExITOzs5cFw6HQ5sMgrt2u10nNyUS\n", + "CZPp8edArIofMsOScDis6elpe1cgdyLRFRchfOBw2URYy2KT5IcLx/3z83OfCBMTE36Y4WmQdwLm\n", + "CyZM47aysmJJFrszTS6LsdlsuicgcAivaWLp4vG4rRXga2ACA2RIk51IJLypfOj1pBYzDdH09LSn\n", + "Sevr616gcHCDurOlpSWHVUqyiR/TKaT4DEqwBQiaDaITjEajzjeBiMP3Az3hSA+7DxsBYEQmjfwu\n", + "ToDZ2VnH/7I7go+jwGZnY0weiUQcQsQED74Jjvd8nAd5ZmbGcjGGRJiIg8VzCsD5CIfD9rjGdiCb\n", + "zer29tbQJR554PoIgWmOsWt4zPWkFjNvEFAcWjRG10ydGN9ubW2Z9A6sRRY2qAE3IxQKuUHZ3Nw0\n", + "V4PuHa7wYDBwHYjzJfwJfjdcYW4uDD+8jSGyB0MimTRWq1VtbGzYqZTaG27J7OyszSLj8biWlpa0\n", + "trZmuRVOQwyN4Elks1nrB6GgJpNJw5ZgzzxkTAPRkF5fX3tH39jYUKVSMcGL6Sjj/mg0+iDtFhNI\n", + "NpQPvZ7UYkaKD/US2wHpnrhPt87ErNvtGvynDCHQkThidhoSXJH+M66+vb11WhLHOLxqTgQaPZQa\n", + "+EPwc/k6dsi7uzu7DDGGZ0GDzoBrY0pIOQP8lUgkzL3ANy8Uuo+BCIfDymazDxybODnILJTkJCoo\n", + "pPw39ma1Ws2KbiaUkKPw+RsOh1bAwANnSsgABTbhp59++qj7/6QWM+NoGsGpqSmPpKlzEWeCxXJE\n", + "gwPPzs56QbBQZ2ZmrEiW5N2TkgDfDRyEGPeygGOxmPPzcPUJRolJ8uKnbtze3nZZgNIllUppZ2dH\n", + "8XhcpVLJDRz8aV4XjkyYrkDqAUYLwnih0L1/dafTsUwqiGxQjlG2DIdD+1qjSgfSlOQhDKw5BAF8\n", + "LhwOGxEiK5yN5ne/+92j7v+TGpqcnZ05944dFz5DvV73mz47O6tisejmjbw74hAODw/daNVqNZ2d\n", + "nblMOTo60ubmpmU/uI12Oh17Qmxtbbn+vLq6UqFQsKEhlriMsefn59Vuty1+xeNufn5e+XzeHhnU\n", + "ruFw2P52YNfn5+f+WzY2NswZAfcmsbXX62l5eVmFwr1934sXLxx/NhqNVCwWlcvl/PP/xb/4F/r8\n", + "888djDk2NqbT01Pt7u76fUVsAFsuk8moUChob29Pr1+/VqlUcvNMuVGpVLS0tKRWq2Uvjkql4lLv\n", + "Q68ntTPjesmUj1xn4hlCoZDtYBlns2hZJM1m07sLAthoNOpuGx5H0FMDDgURYpgWSlImk7FLJ8aL\n", + "lBZoCXHdX1tbs5woeGPZwWAA0rg1Gg1TUIfDoT7//HPn/DGIACLD5w5jG7B3yD4sWMb+GCJeX1/b\n", + "CRSUItjIAUNOTEwom82aLCX9xPfG9iyZTLoUopYmGFSSIzg+9HpSi7nT6fhI46hl12U0vLq6alus\n", + "0Whk53r0bvF4XOl02kcsOX/tdtsU0VQqZbgMsxQaH/R03FBIPEF4LJVK2RkIBAQHJh4ylM5LS0sP\n", + "HJfgFt/d3Wl1ddUWV5ubmw67R8mSzWb17Nkzu/FDj6Vpm5+fN6V0a2vLpdba2ppDNWG9ZTKZBxKq\n", + "y8tLy82C0i5kXcCZ2WzWxjfD4dC+IlgvzM3NGS7c2dl51P1/UouZHRi1RDCmYWtry8SfmZkZd/xI\n", + "nhKJhBse0qFAK1is8AyQZ2WzWTO+2A0B/5m4wcfAgzkozwKvhTIqyTpDjv5YLKb19XWrmEOhkCFF\n", + "ZGGQn6hzg0qQer2uarWqfD7vk4VkJ0orHvylpSULA2j0+B4oovBGyGuhLuZv4H2EHw2zEKTk9vZW\n", + "a2vLh+SrAAAgAElEQVRr2t3dVSaT0Q8//ODhye7u7qPu/5NazGSKBGEggmnwDgYdGAwG2tnZ0ccf\n", + "f2yL1cFgYBLScDjUzs6Out2uO3OaIzDkYLkQj8cde4ZcaHp62l27JEN4c3NzFnkiXAUGhLWHooMH\n", + "hN+DopkgeNAEgtqx2mURLi4umodM00qtzYOP1o9TDVydciv4wMJIDD688KGDDeFwODTXGk4Isi5U\n", + "Kby3CwsLJjc95npSixmnH4jfkIdALUAGTk9PNTc3Z34DA5WlpSWPp+PxuI6Pj7WysqLBYOBsPoJ+\n", + "uOGkU0FYmp+ft+snNxeoimMVWIvas91um6jPTkdZgRQJVXg0GtXq6qrd8AeDgS158XLGwBtjxm63\n", + "q88++8zZfCxy+gRI80CN5+fnfj8ZQgXLk2azaT0lpwR+0uDTjPWBAektqKnHxsaUTCaVTqcVjUbV\n", + "6XTszvSh15NCM0qlkgWcLFqST0EvMLvGq+L4+Fizs7M2DCSjo1AoOHgGtQjoAKoIJml4Gg8GA52c\n", + "nGhtbc3jcgxOqLdhx01OTnqELN2rv+nyR6ORlpaWVCwWLYliSNHr9VQul/0AQIrq9/v63e9+p62t\n", + "LRP5QXWmp6dVLBY1Go10cnKidrttZcr+/r752/A+QFfq9bpisZgd9GOxmE1j2u22TRJ5nzF2rFar\n", + "psIWi0VrGclIYZFjPXx+fq5YLGbBwodeT2ox4/7OwmFUHYvFHoD6LFDQg0wmY10bKAU8DJrFmZkZ\n", + "Y629Xk9bW1vq9XqOGEM0S1g8N3dra0t7e3tOj1pdXdX4+LhyuZzr9nq9rlQq5ZtPOUPdT6YJ5VNw\n", + "ZA8mXCgU9POf/9wLEsUHHOFwOKxer+fBENPDjY0Ntdtt/33s9uDk09PT2t3dVb1e98fA7kFEMK/Z\n", + "2NhQt9t9IGplMokT093dnXq9nnnbQdEEviYfej2pMuP09FTpdFrS/U7HgAQmGvo6sM3r62vHpJ2d\n", + "nXmHBY9GCRJUaLdaLT80hULBi5mSAlPzfD5vrwy8L3DWJJ6C6SDkHRh5MPCGw6FrS2xxiU0gFIhB\n", + "xuLioo6Ojsw7QXUdFLnCyhsOh/bBmJmZMf2VRAEefuipvI/kw7DjM1y6uLiwsTmUUTBxYpn5evoG\n", + "8lfgOY9GI/3www+Puv9PajGn02n1+30tLCzYXYjun1qQpk2S3r17Z1ZXNpu1ZAiNGtkjNHGor/f2\n", + "9ozjFgoFN569Xk8bGxsWnM7NzSmRSKhUKrm2DdoPIDQ9Pj424yyRSGhlZcXlBB5w4+PjOj4+tuv+\n", + "5OSkI4klmWvd7/eVy+UUDod1enqq6+trFQoFL3rcQKempoy5o/CuVCqKxWIqlUpuCIHVIN3T9EGY\n", + "wlCSMbskswShgzJtpZZnNH51daVYLGYPvz9wMwIXuXszMzNmbSHIzGQyxm0hDT179sxfDwMuHA5r\n", + "Y2ND29vbD7JQsJeamZlROp3W9PS01tfXlc1mjUlnMhlzP2DT9Xo9ZbNZw4QsgKAjP4gLC50HaPPH\n", + "cPdkMukSCNNHyENYyoJhLywsaG1tTSsrK/roo4+cFgBHYnl5WcPh0G5MPGDz8/N69uyZyVh40lHO\n", + "8NqICoZRxwh8c3PTgfAQmIDwQJbgxsBKfPHiha6vr202/vz580fd/ydVM6O4gLcQDocdp5bP51Wt\n", + "VhWJRFQoFOxnfHd3p1qt5mDzqakpvX//3i75HJ+vXr2yFRUmJldXV9rZ2XEzWC6X9dVXX2l6elr5\n", + "fN5JTUQVQ0LCzX5nZ0f1et1DHRpKOMSorJF/oStsNBr6/vvvtbm5qdFo5L+B+ndvb88EfUlefCS7\n", + "0rRFIhG1223j5ijMT09Ptb29rd/+9rfa2NhwNIYkB7f3+32HBd3d3enk5MQTTbjVmEySG7O7u+vd\n", + "Hn4Mwt5QKKR//I//8aPu/5PamZEtzczMWG9HPToajbS8vGzjFaAiSgKaHVAD/Jw7nY42NzedVBqN\n", + "Rm3R1Wg0HAXBtAy3e0oTBgo0YxzPxK5RI1NXAsuBRyNiTSQS5j0z6AFqk2SjchQfnASw/hjBd7td\n", + "ux7hkYHkCpiNciXoOw0zDu4xzbB0P/YHzYEHTiP5+yruTqdjr2qgPBrotbW1v/rG/hteT2oxB7to\n", + "RshEliWTSU1N3aeswlqDN8HORQJTPB73EYn5+Pz8vLLZrAaDgady29vbthaAXE5TRhNZrVa1srLi\n", + "8oYHS5K5xOl02ho7poPLy8t+6BhybG9vG8aCB8zu+9FHH/nhxYMDpt3Lly9NLaWhq1arSqfTfm3x\n", + "eFzJZFK1Wk2bm5uOpWAKGo/HjRdfXl56ETI+X1hY8AMWj8d1eHhoZiDsPTz/cEzi9a+ururVq1f/\n", + "7gbB//9xMTomiJwJG7IgYsoYZBBAI8lDDmLLJNnJEky4VqvZ9RPaJDznoHdavV7X8vKyCUGlUknN\n", + "ZtO7M0MHShtomdhxBX2i2VHhMxD4EzSGQQVCvY1VV7PZVKlUUqlUcuMFrRQcGv53sVh0UsDl5aX1\n", + "hpQf4MWEADGYYsTOGJ8h1OaPUc6w8qamplymtVotS8wYZbfbbeVyuUfd/ye1mOFhBB3jkeGjWIbg\n", + "AlR1eHiocrls2Twj3qArEh+jocPBHsYYxztWrclk0uNvOnyidrGsKhQKJuYwSKE55GuJFD45ObGT\n", + "Phg52SmUCkCDGJoHd01YacGwScoT7G3n5uZ8KmBjxpDo5ubGVg1YFRweHvq9ZuCCypzQHiRVCFYp\n", + "+XgNTBoJpX+so9GTagAjkYh1gKurq5qYmNCzZ888+4doxDEMkWZzc9OqbI6/TCajq6srRaNRp7lK\n", + "8i4Inj05OWkuBAlTlBuhUMhk+WCGH6JVcv/W1tbMT4YmyTBhNBppZWXFWYAc41h9URf3ej0brc/P\n", + "z3vKiXvRaDSykz3EJz4H7RQi1cXFha3FEomEms2ma2yQDvwvglnilGCUbZg9kn0oyf3FcDjU1taW\n", + "Dg8PHyQJPOZ6UjtztVp14/b+/Xu7AdGoIU/K5XLOKGF4wi5B1h0jYngLiFhZjMPhULlczmUCudJj\n", + "Y2MPcF1cRWkmGWFjLzs2NqZisWiaKfg4CnNKEEl22Gw0GkYrKF1o0sbHx1WtVlWpVCy1gvfMqB6T\n", + "cr63Wq36yGfUjfUBwxskVahlKG/QJoLDM/bPZDI6Pz9XJBJ5YJxer9dtOFOtVj3iH41Gj+ZmPKnF\n", + "DHdhfHzc0WnAdRxtCwsL2tzcNJZbLpeNCSMyZayKFQBkdepRdj3MEGnKGCuPj4/b6w50hHp3ZmZG\n", + "1WrVmSWMwLFIgGO9urrq5isUCjloE750UIiLqePe3p4kmbMNfgsJKEhRBW2hfl9dXbXEiQeb0Tml\n", + "D2UDfiO4m4LEnJ+fm7ctyWqXu7s7ZbNZtdttP5jBhAOmin/YmQMX2rulpSUfjeyCxIMR7jg2NmZ9\n", + "HrgpolRYcBgTUnem02nt7u46KxD93YsXL8xBfvnypebn57W/v++dEqI9nOSvv/5ak5OT5iODc29t\n", + "bWl7e1uJROKBQz9eFvF4XMvLy+Zmw97DVD2TybhkYOHi67a2tub3Bg8+BiTZbNaKksXFRW1sbJjR\n", + "B/F+e3tb5XLZ9Xg0GlUmk3G5tru7q+3tbRtTQuQClbm4uNCXX35pduLd3Z02Nzf17NkzpdNpv4+P\n", + "uZ5Uzdzr9ZwrIt0LKNltiQdDwIldFFZTBGKORqMHnz89PfXnYrGYv2ZxcdGaQ1hx8/PzqlQqfhDY\n", + "bWiWKBkoXSYmJixobbfburi4MMuvVqtpYWHBQlP82iKRiBqNhtrtthEV/JPZ+fj7g1azNLmULzSf\n", + "Jycn7jUqlYqbvYWFBUfI9Xo91Wo1vXjxQnt7ey4lsDZgQCTJeDS5isCQg8FAR0dH5qCA7zPyTiQS\n", + "Ojs7e9T9f1I7M1O5Vqv1IP4LkjsEI5wtQS+YjKEeCdoUhMNhdTodO3bCYYZhtr297RgDcu+Wl5fV\n", + "aDS86Bit4ztxeXmpYrH4oKlMJBIP5FmZTMYNFrUtzDcsFWjQeO00c5gd4kcBDIhLKqXR0tKStra2\n", + "NBqNHONGGQPrjxE5DxT4fDwed63LAzYxMeFgedThwI+UfIy1EeyiqAkmu37o9aQWcyqVslJEuseJ\n", + "OdLga0QiEW1tbdlDglo3Go1qeXnZiwnzE9w2adhQkfD9+/v7Nlth+CHJQxuMBBnYwMGIRCLe+ajp\n", + "Ly8vtbKyYhMZ6V4QC3UV9IG/dTAYmKBDnRoKhfTxxx/btBHYEF4Fi35paUm9Xs9cDxCgbDZrqiee\n", + "ckB5jPJbrZYNcUBriIBg0IIqZmpqSolEwmUOpc/ExIRevXplstHU1NQfAnqCF2SY6+trnZycaGNj\n", + "w1RHQuDz+bx+9atfKRKJ6OjoSJVKxXgto+ZOp2OjwF6vZ7Th7OxM5+fnTpY6PT01uaZcLuvXv/61\n", + "g2mYKK6srJgAj+F3tVpVtVpVPB5XoVBQLpczsWd8fNxZKs1m0+mv5+fnRlNarZaD2MlL4b+Hw6H+\n", + "6T/9p6pUKtrb2zOzjqEPKVKUE4gYcrmc3r9/r9PTU719+9bUTeLPsCCA10JjCEJSq9VsME49TgLs\n", + "5eWl9vf3HYtRr9c1MTGho6MjIxynp6f6i7/4i0fd/ydVMxeLRfMFvvzyyweGhdhjzc/Pe1dbWVmx\n", + "HD5oIYWOD+ehtbU1T9uAm2ZmZtyA7e/va2xsTNvb23YvIv633W5rZ2fHHsbsWkB0kUjEYlD8L4C9\n", + "UqnUA487mjqOfIJwsBKjXEBpzTEP6gCygys/tfbt7a3S6bRV1xCYMpmMWYdM9IDfUL7THDP+pi/g\n", + "ayASJRIJRz8gbg2iHisrKzo4OHjU/X9SOzPlBESbSCTiGF5CYaampkzlZNHAv6A8WVpaeuDlhuIZ\n", + "NyJ2SqAkyodQKKSVlRX7zyHgpEYMBviAmMD1JXoNmI6dnQUZDJIPuoiCyEh6ENWAbq/X62lubs4c\n", + "ZUlW11ByQOOkrOB9BPHhtSCWHQ6Hjp+YnJy0IBdEhJBKavhMJuO/A0ejnZ0diwPwruPv+NDrSS1m\n", + "SDTlctnHWqvVUr1eV7FYdFb20dGRZmZm9Ktf/UqFQsHDFrr9vb09R6vhMs8xn8/n3WAeHBzo5uZG\n", + "79690/n5uWZnZ60kGQ6HPhkYGcNQq1QqajabDsPE/CSYKnt2dmaeB/yParVqZl65XFaxWHR4EFZd\n", + "lEXsjJeXl3r37p1Za3hroJwBJTk5OVG/3/dwaHx83AkCEPf5mzGt4QSCjzEYDFStVu0dx7j/9PRU\n", + "zWbTrymIS5PFMjEx8Wiz8SdVZgSPUnbf7e1traysqNvt6quvvrKKWpI+/fRTL+zJyUkjFp988oki\n", + "kYjdPqPRqJLJpPM+4DXE43ElEglDVevr60okEjY6XFtb09XVlTKZjKGofr+vdDrtgEdcRwlgh4b6\n", + "+vVrB72DB7PLMuAhFhnEgsEIxoaM7nO5nE1gcBJdXl52CZZOpxWJRDze5zThxMGylkEQu3gymXQ5\n", + "sra2ZjlUOp22NGxzc1OZTMaw38LCgkW8/D6SYl+/fv2oUuNJLWZqMCAmYgfg1WKzGgyvZEq1vb3t\n", + "FKlOp2PSC/U0imUWRzweVy6XswL77u5OBwcHdtpfXFzU6emptra2vAPhPoSw9OjoyGIA6I/T09Ma\n", + "DAYmr3e7Xa2srNh5dGZmxkpr4hPwocAeiwgHQiURtQbjkfleHiDc+iFojY2NPeBct9ttNZtNdTod\n", + "7e7uWk9IFB0lAzXy1dWVlpeX9e7dOydLra2t6eLiwppJyP2tVstw4GOuJ1VmEHrDmyX9xAqDlEOz\n", + "xK50dnZmzWCQdhkc69ZqNVWrVfstY/iC3xrYKbsqWSEMAlBy8JAFgxxnZmbs5IMrEaR+xLCNRkMX\n", + "FxembEajUev2GO5I0tu3b13OkCRF+VOr1Yxi4CWN6xLvDzzvq6srZ4zQH1Dbh0IhlctlHRwcWE1C\n", + "EA/2uYgjoJyiuTw8PLTDPi5R1O1BhuGHXk9qMScSCbXbbZ2enrqUgHIZCoWUz+ddThwdHWlpaUnb\n", + "29uSZBok7K1YLObBxPb2tpsvXC2DxzGG4gxSWKRHR0eSfrIGS6fTjheGU8xiQOmC+pvmFcYZIezE\n", + "TKysrBg3Jt96c3NT29vb9prDBxkpGeLTWq1mhqAkDz7gevOeMWzBsYlmOhaLKZ1Oa25uTs1m08gI\n", + "DzhBnDx8QHiM9Cm7wMmx9eJefOj1pMqMs7MzcwPAmXHOhDDP7rGysqLT01MVCgV9/fXXkuRy4eTk\n", + "xJL4XC7n8gV6aa1WU6fTsUyo3+8rn8/bAoCEK8jux8fHisfj+vbbb7W8vOzMEhqrVqtlSJEmjXRU\n", + "JmSLi4uqVqsmDWFSw2Jh52ZBwgbENXRlZcVjZowXh8OhST6dTse0VhYhDDrCgebn51UsFrWwsGBD\n", + "SU5AoDbscEFE0P/Nzs7aSSqYPx4Mvnzz5s2j7v+T2pnHx8d1enrqIw+yPMT2arXqBrFQKBjmoq7m\n", + "OJ2ZmTFDDgta1Crtdlurq6tu8ra2tlwfcpNAMAiumZycdNIrdFMol9S4FxcX9jumJOKhuL6+Vq1W\n", + "s1Po2NiYc0+IfWPhEA1HeYE4NhjGUywWTb8Ewkwmk5JkDSWDD3jNvG5OHdAIal8oACRhUeLUajVv\n", + "KCQSUKdzoQ5/rN/ck9qZGYlOTk7qd7/7na1S5+bmtL6+rkgk4vru5z//ufL5vEWhDFBqtZpubm60\n", + "urpqYnkul9Pu7q6dfoKZH9PT0/roo4+Uy+U81oVSSk4HCafdbtfiWQwPkVuBvEj3vGzG1gxd6vW6\n", + "Li4utL6+7uYTt6Bms6mjoyO9fPnSihpKrvn5eR0dHemLL77Q7Oysstms5f6YshDAA8OOkHqosuDG\n", + "lAu8X5FIxDrF9fV149iUPzwEm5ubhgevrq6USqUUj8c1PT2t4+Nj1+1/CLUMXEFXeWAkorzYeTEQ\n", + "pwEjE6/T6ajVaimdTiuRSKharbrDDh6N1WrV6aLgsKhTmKC1Wi1r9JgEgiiAQUO8v7m50dLSkmKx\n", + "mL755ht1u10f2dTDhUJB3W5XyWRS19fX5hJfX1/7n6mpKeegoA6pVCo+bcrlshqNhnMPcfAPRprl\n", + "83lJ8kQSJIPvw7iG4Qc4NtYJ4NN48dFI5vN5+9zxM66vr3V0dKSTkxPNzs7q/Pzcjv4fej2pxYwq\n", + "AvM/TAexucJzAl/km5sbpdNpFYtFnZ2d6eLiwg5D7BLX19denDc3N955GQtDRu90Ol5k8XjciaU4\n", + "AbGjsbvDU2C0e3l5qU8//dTsuJubG0cNo/5GNxiU+NNoBR30MYgk6+T169fmKjM2r1QqZrMFx+Qw\n", + "14AFUchQ58/M3CfbFgoFlxbY3SL0BZXAyByTcgQHeHUMBgM9f/5ct7e3xuwfc4Xgm/77foVCodHf\n", + "+3t/z4w2Im07nY7W1taUz+f17Nkz7e/vmzOAjo2FwGCE7n5/f1/Pnz9XsVhUKpVyd399fa2lpSXt\n", + "7e0pk8moVqtpbm5Oktx88QBFo1H1ej2tra2p3W4bY+52u1ayIErF544HcnFx0SIDHgoeJBznpfvG\n", + "NJ/PO2SSr+E0KBQKevnypVNS37x5Y0SC3ZgouEKhYGd/mk8eVrByONIYKBJRFwqFzHEmiUCSc1ku\n", + "Li7sWY3nM2FDWPv++Z//uUaj0QcpW59UzdxsNs2txbEnn89renpa5XJZp6enku538C+++MI3EtRh\n", + "b29P09PT+uGHH/TixYsHsp5Op2PEACNBvOAoYXASRawq3S+0q6srj4tZHCcnJ3r9+rVarZbev39v\n", + "ZyTstorFohlrlAIMMgaDgYUBDFmur++zCnmdSLVQdON0j4Ch1+tZmIAYAIrm1dWVPvvsM/3617/W\n", + "+vq6RQzo9DKZjMuQubk5S7c4+fgcihaGTvA6EDBcX197N7++vvb9+NDrSZUZcBgikYjS6bQDJhmW\n", + "hMNhJZNJbW9vm2iPJ7Ikk4pYMNjfBqX5mIBLcgQvquebmxuLNyEXUTfzM/CFQ/U9OTmpzR/Tq/A9\n", + "bjQaSqfTtjdgh2M3Xlxc9AiYWAYWONIvyO6w5xgUofpmV0fahWoaCi0nCLUxQxOQlrGxMfX7fSvR\n", + "+X++hixEBL+UF0S2QWBimvnY5k96Yot5eXlZ+Xxe7969Mxnm+PjYZPOjoyPjwxBmgnAZuCfwWC6X\n", + "s76Nm48UCKYZllNAVjQzl5eXJiIxgJFkcxZGx6hLUKvQvBL7hhcG3hLValVHR0e2zuK1MuhgVH17\n", + "e+uJH8T6q6srR5RxkuAN0u/3PXbnocHABaI/ZRaELjjXjPppbPv9vur1um192X3RD0qyAp4Thbr6\n", + "MdeTWsyMctlRsZDCYyKdTmt2dtalABRFJmEoQzgaaXoODw8Npy0uLmp2dtYEc2pN6kUWNNRImGiU\n", + "C5JMh2Q3oyaWZOI7BH1w2dnZWTtrMm0EP2dEfnt7q7OzM8ORq6urHu3zgFCjg8ODtExPT2t1ddUo\n", + "yu3trc1gjo+PdX197Y0BJ6NqtfrAJ4PhDQFIqE6YGuIlQvAosi6cmP5gaRu40MdFo1GTcsCRMekb\n", + "Hx/3LhWM+oIWiUwK6AtJE8ckrpt4wM3Pz/vmEizJlBAcFrYcuxcoADufJJcUUCQpB5A9MbEjUKde\n", + "rysSiTgDhTg3/KbhZzAkgliEzIlgeUm25EUniFFMLBZTs9nU4uKihsOhzXLYtZPJpAc4PPyE/QQ1\n", + "gEwiKWPYaCA0kQmIGOJDryfVAJLn0W63tbm5acIOY1aOYdw0gbFSqZTNADn+KU0YGsA2k6RcLqcv\n", + "v/xS1WpVx8fH2tnZsUUWRKGPPvpIY2NjWl5e1tnZmR2ScBhl4Y2NjdnqgJ8PbEcj+fnnn9sghUZx\n", + "ZWXFY2AeMMJ/GEyweOFbkAfOsEWSxQxB8xa4Hufn50qlUqZ8TkxM2MUTlUkkElGxWHwQkzExMaHV\n", + "1VXnAFJaMY1EUACDjjLvDxPAwIWTEDxgIsMYZNDYdDqdB5BaoVAwwwu6JdwNRrtwKc7Pz7W5uam9\n", + "vT0NBgNtbGzo5OTEnfnNzY0ymYx50nAQ2GF7vZ5WVlZUKpUciEksWi6Xe2BRi9r5m2++sSrmzZs3\n", + "SqVSqtVqev78uebn550shY0AJw9Z4UE8nbLj6OhIr1+/liQTs2ZmZvT+/Xul02lPJ7vdrhYWFnR8\n", + "fGxIMRwOq9FomGrK68Q4cXJy0hI2Itqq1aoNFxuNhvsGSGDRaFTff//9o+7/k1rMU1NTRie63a47\n", + "cnZCTEtACJ49e6Zvv/3WhirD4dAUxuFwqO3tbftiAItR30GW5/fRtUO+oWbGDYlBCUR8yFBbW1se\n", + "uLCTz8zM6M2bN8a7Z2ZmDIlBAqL+r1QqbhwpXZ49e2ZIjtAfVCjEMyB76na7NoFJpVLWFDIpZeEu\n", + "LS2p0Wg4I3E0Gnn8zRSQJhT5FSUPjLqtrS1zQlqtlnZ2dtRoNJwUOzY2pn/+z//5B9//J7WYufGT\n", + "k5N6/vy5ecVMvoDFrq6utLq6qkKhoK2tLZN2YIhFIhGtra3pu+++89FI84SDPC6ia2trtnulpLm+\n", + "vtb29rYdQ4kdg8iPwBSlBiHzg8HggahUuocbQS54GKampmw2uLu7q3a7rUqlYh8N6lM8N3AXQjgK\n", + "9LewsGDrXRQvWAHMzs7q+fPnTpcCjej1eq7vz8/PbReAWhvWYq/Xsx4RtIXdHWSEAQpNI/YKH3o9\n", + "qQYQpUK327UTESR1tIEXFxdmrUn3xHtgPCIO7u7uTKXkZ05NTVkPCG+Dpo+RM00X/ASOeeA3YCjk\n", + "9aAQ3W7XaABNHxM/eCWMw+GAnJ6emrWGsoUHNjhCl2QFdrVatbkLdFcULJxkWOiGQiFzoEulks7O\n", + "zlzbA1/ynqFDvL29NU4O1gxjj3KLJAGijnlN/X7/DzmAwQszcGRHGFtDjcT+lYgESC9YSSWTyQck\n", + "oEgk4nFyrVYzKoArKDv9wsKCer2eSqWSmyJUL8iyKHWC0BlxCjc3N/ZbZsrY7/dNOKIWZ3Gw2+E3\n", + "jXs+i7NSqbg8IAxIup9GFotFc1fAskFY+NuBznK5nJUmLFyYhLFYzH7VIBQrKyvGlGu1mpvMarWq\n", + "q6srMwiZdBYKBZ86DKcecz2pxby0tOSbvbm56eYH4g55fMPh0CoMOn8GFBcXF673grsY1gFBZUcQ\n", + "62WBTUxM6OOPP9Zvf/tbB6KDX/N9QVgNNhzHNgsJGwOGHvxdwGJ4Xuzs7CiXy3mEvPljzAW7J6cB\n", + "431MY7BBWF5ediZfIpFQq9XS8vKyHZhub2/NQwFjxyNvMBhobW1NjUbDmwjI0OzsrJLJpOttoDpS\n", + "u1KplJlysVhMqVRK1Wr1Uff/SS3m4XDoHemXv/yl/uRP/kSHh4cKh8PK5XIPvOX+5E/+RL/4xS9c\n", + "RuB42e/39c033+iP//iPdXh4qJ2dHVsGYF8gyZ7GOzs7zsFuNpv67LPPdHh46PF1IpHQ999//2Aw\n", + "Mjc3px9++MHZHgRWMnLv9/s6ODgwXAh/+pe//KV+9rOfaTgc6vT0VJlMxlq7/f19ff7556rX63rz\n", + "5o3TsW5ubnR4eKg/+7M/e3BSXVxc6ODgwEoXoLLBYKDDw0P96Z/+qfb39810m5ub08HBgT0/MDsk\n", + "gFO6JyuVSiWNRiO/zyTmFgoF7e7uOuuFxhGeytjY2KPRjCdVMxPIAy2TuhW8mRIDGRTQkCTzJthd\n", + "2YEl+SiGnwAJnZ/NRROEUaMknwT8TkodMGkGFpOTk8Zc+TpOkuDXUEPDOaYsYBIpyb0CvQCMPl4j\n", + "P3NiYsJupMCIvGa+hr+D30lCV3A0Lckfp2zi74UiwP3gNQZptLxG2Hgfej2pnZlmhPq02+1qc3NT\n", + "4+PjnlIFPTA+++wzlUolT7iIffjZz35mvJrygZEwqa4rKysPFN/cJMSm1L4cvUB6PCSYFRLZAFxW\n", + "q9UsosUtlAki5QbWYhzVi4uLuru7U7FY1PLysnZ3dz3pY6HiBUcDDBei2WwqmUzaHw8TSaIqss3d\n", + "TJUAACAASURBVNmsSqWS+Rk0fsjEbm9vTW4iuWt+fl7Hx8c+GaC6AnsCWcLC297e1mAw0N/+23/7\n", + "USE9T2pnJguEGpB/BxlZKEbgXaRSKVtLsYMxOcNsheYE9hej716v57Ev2Gu5XFa1WvXPZLeCWokr\n", + "EbRSdkGwbXR+lUrFVElG4UiugMqwsg1i471ezyIDcGdJdvPk9Go0GpqZmfF0j4xCILWJiQlnhgPv\n", + "URbNzs6aHCXJzlFwL0BSkE7ROGIHjM0wHHLQmsfuzE9qMW9ubhpPRYoEngnLjboYvJTFhdWs9NMR\n", + "D3KBfzK0ToYJ3KhWq2ULg7W1NSUSCS0sLGh1ddWNJCPnyclJLxKyQNDYseviXIRmES4IWDjZehD4\n", + "GctT266srDjCeDgcuinjdfF9nCpM4SAwscPShGKIKMk+diA4sVjMFr2QpsgEDH5tNpt1GQW+DsZ8\n", + "fn5uEexjrie1mKnJwJQxLCEXsNFoqNvtql6vm6eLNAhYCp0fOjU0cCipcfeRZAUzwZaFQsE8CEa7\n", + "DEsWFhYeHOM0SZDVQQYYXiCuZYGDBTM6hgeBMhsyvCQ7CpE9eHx87L+LiRyLB14E9FB2VngpPEwE\n", + "6pTLZW8I8EDAmOfn511KsXOXSiVj1jDsrq6uzImm1gZ3fsz1pBYzYk92tvPzczcwmKywQ3EzkExB\n", + "rL++vlY4HDbyMDU1pY2NDbO7cI9nYsfN5zhmOCHJgwjwaZh8DDtoVnHEr9VqqlQqD8zDsRoAamu1\n", + "WuZLBOvwYG4frDXstGZnZ83jhio6HA5NLuLvB6mhyQTaQ2XOyRU0d8HVFBECECjDKHgtmL4QLIp2\n", + "Ea8P+ofHXE9qMff7fTvlg0xQq7Go0Zo1Gg3vxKAGtVpN6XRazWbTbLrBYKBCoWDGHQoKjmL4B7Dx\n", + "SH1FdXxxcWGhKGYrdPhQUsGpg2GPwREv6mkMYDKZjAqFgur1uutd6aeUWWrZbDarRCJhES0fv76+\n", + "diIrGPfi4qJWVlYsb+JnsWvCJuRhgfYKagKygnaQoRGlCg8w2kumnLyvsAkfcz0pNAP+ctBG6tmz\n", + "Z/ZdBthPp9PKZrPK5/NuwMbGxrS2tqZQKKTd3V0HvlODQn/c2try+BWUAoroZ599pkajodnZWW1t\n", + "bSmdTuvu7s4nBMR4rAComVdXVx+4gDKEwAMPn4vhcKjl5WVzGwifZ+FR6ycSCfth0BRChGfs/erV\n", + "K/OdIeHzHiCFSiQSDsREFfPy5UsPWCQZA0eIgA7yiy++8APICYb+kJOHzST4UD/melKLuVwuu4Q4\n", + "PDz0tC1IXWSRwg9GkNrr9cwVYBwcNC2EI10oFBSPx3Vzc+PpFVev11Ov13OqEg3Nt99+6yHGYDCw\n", + "TW6pVNLc3JyKxaLK5bJ39YmJCf32t791LR6NRnV0dKTRaKTt7W0dHx8bScEuC1uxZDKpcrmsV69e\n", + "OWpibm7OYlF203q9rmg0augPRIQSAXd+0Bni28rlsr3rfv7znzuCAswedQlWYiRrYSr+7t07m5jP\n", + "zc25ESeh9jHXkyozCHthaEHjxxHJoiTMnJ0AnjKex5CIer2e7VhXVlY0NjZmXJjdPJPJaGxszHBa\n", + "uVz2Tg35aHt72zIpeBc0oSQwsSPCcFtZWfGQplQqaWpqynTRra0t/6yVlRWP1RHYJhIJG0PCc8bJ\n", + "iAVLkhVjf5pS+BIMXhKJhHHzer2uTqejZDKpVCqlTqdj4exoNDJ1lLII56Lr6/uMmdvb2wcmlCi5\n", + "Jdnc/DHXk1rMZIXgI4E6mhqOWvHs7Ez9fl/7+/tuhlKplDKZjPb393V2dqbb21s3UCxEUI2DgwM3\n", + "Ze12+4Fa+auvvvLuNDMzo6WlJRttw3oLh8OuiwuFgs7OzrxL7+zs2NaqXC6bfipJ33zzjeLxuPL5\n", + "vNrttur1usuYt2/fGjl5+/atwuGwms2mSqWS3r9/7wWP2eL8/Lw6nY6KxaLTAEBE9vf3FQqFVKvV\n", + "PMKfmppyhjgCVkoZGjvek4uLC2WzWe/aWOGCboCy8HO73a5KpZK1mB96PakyAwz16upKf/qnf6rL\n", + "y0ulUikvKEmWD93c3Oirr77Sd9995yYJZ3e0bIlEQrOzs5ZgUZdKsgCgXq8rnU4bZoIRJslG4QsL\n", + "C57e4bu8trbmRSvJqEe1WtVgMFAkEnH4ejKZVLfb1SeffOJmFZtcBAG7u7sevrx+/VrxeFynp6da\n", + "WFjQ+vq61Si8P3jLDQYD7e7uuh4PyrcWFxe9uw+HQ+3s7Oj9+/cWEcAbCdoWsNPCf0aqBa58c3Nj\n", + "XSaDHAZUq6urev/+/Qff/ye1M8NTGBsb8zCk1+uZX1utVi2NHx8f18HBgfm7qEbgJNCUgJHOzc15\n", + "8bGrTU9Pa2trS6enpw982ihJWGzwgKFsLi8vW0YEP4MygCENKhAMYeAVE5/G7giaIN0/zEFTFngg\n", + "2AXQIMNeGwwGLnn4GfQTePSBNqBU4YFh8IT9Ge8Xihegu2DZQSmCvUO1WjV3nGi5x1xPamdmV2FR\n", + "TExMKJVKWbIkyXKf8/NzbW9v6+joSJubm27M2u22lpeXlUwmdX5+/iDgcXx8XDs7O47MhWQONbLT\n", + "6XgxAkOBw/K9OCQlk0mdnJyY8wCbLBqNGgpcXl42cgIKA4WS188ImITYsbExh7pDxWSHB+kpl8uK\n", + "xWI2mlxaWvL7FovF3DMQRElID4oUhklzc3NKp9MPLMWSyaTla/Pz8yqXy0omk/4bgkQjmmAQjp2d\n", + "Hb19+/aD7/+TWszr6+s2AEdbhs1Wp9PR+vq6fSwghf/RH/2Rrq6uTAGlyYN4c3t7q9XVVUmykHQ4\n", + "vA+rpIljBIxfRigU0tbWlkfM7OD1el0zMzNuisbGxmwaAy+E45dkKnZy6JLscs+fPzcLMBwOq9Vq\n", + "edgDG44mstPpKJvNeleH2Tc9PW2no2g0ajx+eXnZej5orBMTE47MYJCCDnJjY8NoBM33p59+qna7\n", + "bUiQkCRIX4y2d3Z2nFSF2fmHXk9qMe/t7SmZTKrT6ditvVwua3NzU41Gw8gGYs18Pq9KpaJPPvnE\n", + "YTmpVErv3r3zsGRhYUEnJydWRoCYHB0dqdvtamdnR4PBwEc1ZCHKEYYIKLgJaz87O9P6+ro935aX\n", + "l7W/v2873aWlJUuKqIuj0aix4W+//VaffPLJgwFFtVrV+vq6qtWqyy3ITPQEcCkgy0tytASO+NI9\n", + "flwsFk0uqlQqSqfTZtCVy2Xb8VIGQXY6Pz9XPp/Xy5cvjR5VKhXFYjF/PaaNCHwJOHrM9aRqZlwz\n", + "yZqmucI1kxuG5Oju7s64KbwJsGEaMr6HsWu1WrVkX9KDOAigMnjAMO6Y/mF0CFQInCdJlUrFtTW1\n", + "KGE5xBnX63VPJ4HmsAfj9+C0dHNzo/fv3xsWAyZklAwBCoUNY26wa9AP0BqGGzwYDD3gfmNRG5zC\n", + "np2deROhNKNODoYfQStluPWh15PamWma0Oxx5PZ6PQ2HQ+3u7jrlCPohShI4wYzC5+bm9Pr1a+c/\n", + "X1xc2LwEXBXQH6sCBJ3JZNK8ZGRTkmwdRm0+GAy0ubmpw8NDB8PH43F9+umnOj4+VjgcVjwet1VX\n", + "IpHwgltaWtLk5KS94lA9Y1ozGo30/Plz/+6XL18qn89rcXFRxWLR2SaSzGhjyMGUkJNqf3/fFr9L\n", + "S0vmVmNxMDU1ZdMbFnkwi5HIYpo8xK7r6+uKRqOejj7WPPFJLebhcKj19XUnhMZiMb17907xeNxB\n", + "8MBBn3/+ub755hu1221LmrDqajabFoaura050AfXeUkPXO/L5bIZdWSaMEZmbD47O6tGo6FoNOq8\n", + "wRcvXiifz6vb7brGrdVq5ikQBAQH+d27d1pdXXWAD0c7zRm77cHBgd2Q4F3ncjljvoQPYca4v7+v\n", + "ZDJpQcFwOFQymTSunEqllMvllEwmdXZ2po2NDXuJUMc3Gg2trKzY1Aby/c3NjfL5vG5ubjQ/P6/p\n", + "6WlPZbH5Jcrtn/yTf/Ko+/+kFjPHKME7kHx48pnMSfdkm/X1dcViMSUSCVvh4i5E5ggKFUmehN3d\n", + "3YdTorwIBspTkrDjIOiEIRcKhZRKpWwpgEgWfzt2V1AXdnyaTsonfgdiA9h1k5OTymazrtV5Hfw9\n", + "NJ2E0jNan5yc1NLSklO5+v2+zSXxGWm1WrbbmpmZ0cLCgmZnZ209FswfRxaFjTBja5rCm5sbbWxs\n", + "mE4bDof1R3/0Rzo8PPzg+/+kauZareak08vLS/v/BhNGGWsDodEUnp6e2t8Ygg6RwOz0yP1XVlY0\n", + "GAx0dHTkBXVxcaFer6ff/va3pmqCdYO9SnJWNmJV8FhQB6A7WH/dbtcTOlKyWDBTU1OmgoLYML4u\n", + "Fos+RYrFovr9vhtKFh4+yWj2iMCAg4z7KKJYkqoYAOFzwZh7enra9l9MTmdmZpTP55XP53VxcaFo\n", + "NKpQKKSFhQVVq1U77lNjP+Z6UjszMBcYLWhCkCLJsTwcDk0ikqRkMunSgXowOLkKh8PGrgnkgfZI\n", + "3Qw0NjMzY9srhgxwhokpY0wNkw05Fq8VeuT5+bkymYx95HhNpJsCpwGJ0bjBk2DoAZF/cnLSLDaY\n", + "bDRfg8HA9FYmpf1+385H1PBwnzn1hsOhVldXXT8H45zJ+qaJRM7W6XS0sLDgARHUg8dcT2oxMxgB\n", + "DYjFYl6AwGJB82sUx2NjYybm09W3221dXFzo5uZGzWZTsVjMC5LMFBQi0WjUE75qtWouRblctkki\n", + "Nx4zGcxQ5ubm1Gg03N0TY0FAJnkn8D2CtrfJZNIjcEI1seeCSwFngqhjmra7u/ugeqC/k5MTxWIx\n", + "uxoBH2KE02w27auBMhxord/v6/vvv9fU1JTW19e9y9K/cHW7XSUSCZVKJT179kyFQkHtdlupVEr5\n", + "fP4PfObg9fz5cwejVyoV46EQfK6vr92QwZ8guHJ6evpBohJJTezITMYQb0K4X1hYMOWx3+9rfX1d\n", + "6+vrqtVqNjjM5/Pa2Ngw+T8ajTosh92KAQfjZ7wp2O05iuFNAAHi7zYxMaEXL14YZqP04HUzzgYJ\n", + "odxgZM2ODucavjTcC3oN8gopDzBgZ2QeNG9kEETjmE6nbfWAuQwIBp7Rj7meVM2MnRVOlNVq1VTQ\n", + "wWDgRoQdm/IAJAADbG5yOBxWtVq1+6YkT7mkn0y6gbrW1tb8OuAqsCCx/EKhjA4vaKrSbrdtOdBq\n", + "tRSNRt04IrcC3wYBYHSfSCT8eRpgHJLA3SmxGCkDRQK1zc/P23ZWkn3sGFNHIhEtLS2ZDYfcS5JP\n", + "MzBuHPgZvQffA6IieC/RbiJV+9DrSS1mRsvdblej0cixvxBhisWiGx2mdTRftVpN7XbbuwtYNf5w\n", + "HK1k8rEAMW+ZmJiwIJRygkYJmI4bDe+Z+AhuJrtas9n0IoTlhoxLkn833Ohut+uROo0lYZ1B7zw4\n", + "29fX1zo7O3N9z0IcDAaG0VjEDHigZ/J1NKwMi1CeX11dSZJOTk40GAx8QrHokYxx8b1BA5wPvZ7U\n", + "Ypbk+T+NEvxhTE/Gx8edecIYlYkYuw6UUPBnxsiE09AE4vMMNMZwAPJR0IKK6VnQ6BB8eHp62kw4\n", + "FC9EFv++m1FwUWAQDnSHxAqbL6DAlZUVn0ixWMw0Vb53YWFBkUjEAl+IVXA8Li4uTCHl75+ZmXEu\n", + "IaUWJRpe2JLMt1heXjYhifuApzUPDxDoh15PajEXi0XNz88beyVC9+bmxpOnZrNp2iJvbqVSUalU\n", + "8lDk+PjYGSBATCizsQqg5gRzJX8Pdhg72Gg0cug7dE2kUexwSP6xCJuYmPDroVShgQUGC0JaDC6w\n", + "PiBQiMaNRq1YLJqKKcmMPLgduNmjHOdEoAw5Pz/XcDjUycmJnaCwNMD1v1arOTKZRns4HNoscjgc\n", + "6vj42KN3VC0IeR9zPanFjDMn/scYm0DBhOQDFAXEFg6HTbfkDaV+u7q6MtRGWZLP523kDYbMjgTv\n", + "AH8LGhyw6JmZGXt5SLJ3NBM/iDdgyVjISvJgg9MEvgi8kmQyKeknewIWN+UColFcSXmdQGIMlvh6\n", + "yrVgk3Z5ealsNutmmdMPR1U2EZAWGsugmSLpBfPz89ZNBgdaH3o9qcUsydEJOPVQJyYSCaXTaR+9\n", + "UA5xrWSHJS4X/dvW1pZub2+VyWSUSqV0cXGhubk5R6XR2EBCD4fDymazxlgZaScSCSMDGxsbhgQR\n", + "iobDYXOMKYHC4bBrUmpxQnOC2XxBiJHIBSaE8Iuz2aydh3hQ+H5UNb9vQbaxsWGUAe9lJpCEDSFC\n", + "SKVSnrQuLy87JwYkCauuRCKhZ8+eeTq7vLyslZUV29o+5npSixn3HjI2UE/f3t7aY2J8fNw1ZDab\n", + "1fLyshEQdjSgLmRAGJKz4FFnQN8E3stkMkZOtra2bGnFbiTpASzFKJcj/vT0VBMTE/r88899CjD4\n", + "YAeUpP39fdfM6BJTqZRPllQqpcXFRWWzWde3pKzSjAUHR1htSTKPBdMadHsw+KR76RnuSqFQSPV6\n", + "3XwMGsyNjQ3L2DDWubu7c9nGrs19QbD7mOtJLealpSVls1k3TigxIpGIFhcXzasg6ou6k8EB2C9N\n", + "GPUoUBc3a2lpyXHAmUzGlmA4zc/Oziqfz5s1hg5OknFkEq2CEcc///nPNTk5acYcjSl1LmR8Ysmw\n", + "BqMMWVhYUDKZ9AgfP+p4PO5dnXwV7LeWl5d9zE9OTjodKngyrK+ve3LJTowFLc0u6nAabewW4Lb0\n", + "+33F43ETmiDzI1RgY3jM9aQWc7fbdboUuxqRaYg4qQelexyVN5Vjs91uG5/lZ5RKJcNgklwXApsB\n", + "lcGBZurINA20AfQAUhK7PrkfQQ87anfySBDLSnIDx+++uLiwmXq1WtXk5KR99HgAwXSpS9nx2aVr\n", + "tZqzDPl9TBDZpdl1ee3YLYBvUxJxusEODLoYcVphJMnAptfrPVoD+De2mEOh0P8SCoUqoVDozV/x\n", + "uf86FArdhUKheOBj/20oFNoPhULvQqHQfxj4+FehUOjNj5/7H//ffieNBQsnqDSGID81NeW6kURW\n", + "Fji1M14Y2BOk02nnSkejUU+qgNXgKkxN3ccEdzod17IsRsxXQAuCukScjTj2oXKyq7F7swMD11EG\n", + "xeNxbW5u2oqM5FOI8wxwpJ9EB0BjaP+oa5laXlxceKwd5CPDwAvKr9AZBi27WKiRSESlUslGkvxM\n", + "EgIQGoTD4UfHDf9NjrP/vqT/SdI/CH4wFAqtSfoPJJ0EPvZK0n8i6ZWkrKT/OxQKPRvdb0F/Lum/\n", + "HI1G34RCof8jFAr9R6PR6B/9Vb8QDV7QOBu7gBcvXphr0G63NT8/7x3tiy++cPN2c3OjnZ0d28xi\n", + "qEh0cDQa1cHBgRYXF02+j8ViVoQgV0qn03bDBOcGQgvWjMBzHNl8H00cjWOz2fTpcnd3p9XVVS8+\n", + "Ps4i2tjYMMwXiURUKBSsR3z9+rUKhYK/ptPpaHt72+VIcHG+fPnSr4WSi40ATJpMlGKxaC0h9ryE\n", + "AH355ZfK5XJqt9uampqyv93V1ZWOjo58316/fq1/9I/+ylv7b3T9je3Mo9HoF5L+qiLof5D03/ze\n", + "x/6OpH84Go1uR6NRTtKBpJ+FQqG0pMhoNPrmx6/7B5L+47/udw6HQ+VyOZXLZR0cHOj29lb5fN5y\n", + "feLKRqORDbHJ7RsOfwoxf/funRNIcUgKh8O6urrSr3/9a83NzbmB4ohmaJHP5508hV3YaDSyLlGS\n", + "DR3JF2GhBm1mwWibzaZ++OEH7e3tSZJlU7gJNZtNXV9fu5GamJhQuVx2XX5+fu6H5eLiQnt7eyqV\n", + "Smq32y4rIPpXq1Uv/MFgoLdv36rX67lMgYRPU8dJVCqVTGTqdrvK5XI6OjryRPDw8FC5XM4Pf7lc\n", + "VrFYfGAGA0X2Mde/1Zo5FAr9HUmF0Wj0u9/7VEZSIfD/Bd3v0L//8bMfP/5XXqVSyVAU0n+ok8H6\n", + "sV6v26EIsWWxWFShUHB9e3d3p0KhYCyXEoZjl10F2AwtHnUrg5ler+cByu3trT0tpJ8yUIDUKpWK\n", + "arWaarXaA6ok43cmZAsLC5ZyYUqOLxwPQi6XcyQGHA5OLBY3fG2wbgYesAslGV7E3xrfZTYENIFM\n", + "DXkogfiQnQXH1QyCIIVNTU2p1WrpF7/4xSNW179F1lwoFApL+u90X2L4w/9f/o6TkxOLTS8vL/XF\n", + "F1+oUCiYS8uxSk2LLAqy/cTEhLrdriqVij766CPr8mB3YQZIGiqWBORBr6yseIwNUhAOh3V0dKSP\n", + "PvpInU5H8XjcNE2aQ47jzc1NIyPFYtFmhisrKxqNRmo0GlpfX9f5+bmNGdfW1kxs2tnZUSgU0ps3\n", + "b/TJJ59YUFupVCzpB16Ea8KOfXt7q1Qq5QFJcLpH/U4EBTs6WSZMIlnkNzc3evnypUsiEgAYXF1e\n", + "Xmp9fd2nF8Oif5+i03YkbUr69kfW2aqkfxkKhX6m+x13LfC1q7rfkc9+/O/gx/9aOcLXX39tn4Zv\n", + "v/1W4+Pj2tzcNOiP2HVhYUGj0cj+EEwAQQugh8IUC7LNCNOZmZnRzs6O5UeM0VF3gDlHo1GHBEEm\n", + "4jWEQiH7VoB+BJEPxubgzOzONH00uWNjY5ZupdNpPXv2zBZk8/Pzpp22223TTLGoHQ6Hzs7e2tqy\n", + "zx7+e5jO0G8w8YxGo5aNIb8C0UBBQ5wwDlIEGRFngfnM5uamUqmUvvvuOxUKhb/u9v5rr39rZcZo\n", + "NHozGo1So9FoazQabel+sX45Go0qkv53Sf9pKBSaCoVCW5KeSfpmNBqVJXVDodDPQvdPwH8u6X/7\n", + "635HIpHw7gB+2el0zIPApw36Ibatl5eXOjs7cwIqgwPiDZDvDwYDW2S1220Vi0VDf6g2KEew+uL4\n", + "ZhcEJSFzj9o3yJlgigksRhlDLSvJO+twOLRhIT8b2RcRx/A0JJmOiWK90+mYlonMC3Sm0+lYiAAa\n", + "wuvp9/sPXicJs+zE9XrdBH4ecMS1/D1AkFAEHkvO/5uE5v6hpL+Q9DwUCuVDodB/8Xtf4hC50Wj0\n", + "vaT/VdL3kv5PSX93xJ2V/q6k/1nSvqSDvw7JkO4x2U6n452TOg0ICUNsOn3cheAzLy0tudve2Ngw\n", + "t5jakjICRhgGhrVaTaFQSBsbG/apGxsbs4sogZVEU2CVNTMz49gyVCRg2RCSFhcXXVvPzc2pXC5r\n", + "bm7Oo29chxDIIse6u7vT+vq6lpaW3Ggy5MG6YHZ29oHUHx9o6urd3V2Fw2E/9L1ez0JZYMdIJGLW\n", + "HFPB6elpTyQZ0HB/KJtAj1jo6+vr/+4u5tFo9J+NRqPMaDSaHo1Ga6PR6O//3ue3R6NRM/D///1o\n", + "NNodjUYfjUaj/yvw8X85Go0++fFz/9W/7vcy7aPJw3kSHBkFNvROgtoZC2OUiFKFBuXH12LnzGQy\n", + "aS85vOqOj4+NrYJhg5JIMpdhd3fXgTnwptEerq+vP/A5hq03HA7NL1lcXFStVrMChOkadWkoFLKB\n", + "zcTEhJaWlhSPx21YmM1mjXRQMoDJ47OHjRnDmo2NDQttqY8XFhYc0TY3N2cjSJh1GDvyur744gsN\n", + "h0Mz6vACWVpa0mAw8CbxodeTmgDyJrdaLZcJDCbYAQaDgXcy6I2gFyggJFmEyWIJQlIc6be3t9by\n", + "BZtKTgI0g4ykg1M4/psmKcjvZYeldoXAj8o6GKADbs1ro6ZlN2QYA92TcgPcGJ0jPslM/ySZ8A91\n", + "Nfha+NuCHs1AlVBW8cVjMcO3ZvJKYw4777H+zE9qMXOcjo2N+fhuNBpOOEIPSCpTv993DUzQI6yw\n", + "4JuM++X4+LhyuZwXnST7SnCT2u22xbI0R9L9QwT1k0kdR3E8HtfCwoLq9bpyuZxlR5i1MPLGShcF\n", + "Cjg5zD3pHva6uLgwFxrFNX8zP4NTAlgPn5FgjY8/CC5IsVjsgXedJItz4ZJwovD6UWnjZc3JAVkJ\n", + "24fZ2Vnt7+8/6v4/qcWcyWTMzKJ5i8fjDyiIxO72+31lMhm9fv3a+O/d3Z13jYuLC/ODOeqpoQm1\n", + "OT4+tniUr8O1Z35+3gaG4LxAfCwIGHf8O2jIkkgk1O12NT097XEwnAiYcMHpHLs8fQL+FbxueMu8\n", + "Lzc3N5ZZYUnGg8fPZwyPsSInBuUDzk8TExNOv0KmBQQJVwPVSpCeWq1Wjah0Oh39rb/1tx51/5/U\n", + "YuaG05RgHwUtkl2g3+8rnU7r7OxMP/zwgxYXF7WxsWFBKsy0YrEoSR6UAGthBfD5558/cM7ENWh6\n", + "elqxWMyeciSSMkkjICcSiTxwQULaREQbY/CPP/7YjRUnhSQvYEhOEH2Wl5e1ublp/d7l5aVhR7jT\n", + "6+vrFjMwEmcxNxoNQ3NY+galWJJsxEhqAGbsExMTWl1dfZALiJKdEmdtbU2RSES7u7vK/ZiVPRwO\n", + "HZr0odeTWszAR7FYzGB/uVx2PRzESTlqgZ5qtZp5y5QcwHHwEBhtB1XE1Mq9Xs8Zf9PT0yqXy1pe\n", + "XnYksfRTTt/a2pptBqLRqHq9npsvxty4Il1cXOjs7MxDDOIXUKcw1SR2AQITTv7Sva80dNRGo6Fw\n", + "OKy9vT07cI5GI6MVg8HAtge5XM5DFTjPcKrj8bgymYwuLi5sezA/P6/Ly0sdHByo2WxaFAH5C1Zi\n", + "Pp/X4eGhms2mNjc3fe/+EDccuIgmQwvIsSbJujyGKsHjcmpqylRKmicI44D8aAJptKA+gmuDjsCu\n", + "I+gdmy2mcbe3t9bFUXuS9NTr9fwzQS84/hk8oCeUfqKihkIhe1lQswLFSfKE7vr62jpImHsMbyDS\n", + "83dfXFxYdSPJfs68PuKcb29vlcvlXLfPzs56YHN1daV2u23eeCQSsdE4pybY+fT0tCmwH3o9qcUM\n", + "ZkpOhiRjunTqcHQleRFDsqnX61pZWZH0kysSNW2QC42TPQ0nnXmj0VCj0bAKm8WP7o4mCQ4Ei4HT\n", + "gAuqJeULfOrp6Wn/TgYaSJ8kWQQQ9KeAnw0XmeYMbgT4ND7NBLNPTEzYh4/yAoEC5Q9kEreghAAA\n", + "IABJREFULGx3a7WaWq2WERR8+G5ublSv180lAeunrEAE/FgK6JNazDDE6NSpn4Gv2A3Y2YC4Zmdn\n", + "LcM/Ojqy4gH+AzsS0QiwzEKhkA4PD90sgeeCwUajUU/U+H24FwFpQTEFSYDYgyEMNScoDOiJdF/i\n", + "NBoNM/KIQkNYCx8FoSnDkKB9Ag95oVDQcDi0gpoNod/vm4V3fHxstTmnHqcLfA9OuKDHH9knV1dX\n", + "nqbSdNJk0qQ+5npSixkQ//z83JAboTngnBi7EB3GwgU6glR+fn6um5sbzc3NaWxszA0lgP/t7e0D\n", + "gj1DCth31L6SvNuBcZdKpQeUR/BeFNoMNihFwHERml5dXRktQCyAcxL+09FoVOVyWcfHx+r3+/rL\n", + "v/xLj/er1aoXDrg6FmP4d1CWoBKhxwjaijWbTT80wZE3KhXQo7OzM3sxByHLqan7xFbpJ5X6Y64n\n", + "5TUHwB+LxfTJJ594ogRBiLqNbp1uHMdPjuhkMqn19XW/4cB1oVBImUzG4TadTsfYK538xMSE4vG4\n", + "ms2mlSCUPxMTE6rX60ZFUGfg0dzpdJROp122vHr1SrVazcd70PKqVqvp/Pxc8Xhc3W7X30eK02g0\n", + "0u7urvr9vi0G5ubmbNuF2//S0pIf0o8//lj5fN4j8mw26/cV4v329rZhTkoMxMFkaiNCQNhL6Dul\n", + "0c7OjqT7pu+jjz5yTMcfEloDFyR3doPz83NzjqmJGW7QnOFOz3EKTgrXmQEFJPVyuexjkp2LocDN\n", + "zX2edrVaVa1WU7PZNG8Yf2Qw3LGxMd/kYrFoDLfZbDpXhJjh8/NzG7Tc3NzYNTRI6JFkCwX8lYHx\n", + "yuWySfHn5+cKhUJqtVoezgwGA2cTgpLwuuEsU7IwUEL53u12Va1WXcvjxl+pVMyN5t80pXhAd7td\n", + "9wtAf4+5ntTOLMlURKiTMLnQz8HcSqVStpdi+ACXF0Em/hXdbtecDKAqRAB08NR+y8vLvsmUM+zw\n", + "7K64jtLwLC4uWgfIMT89Pf2vGH6DvBD5S1MIGhCsXYOIzMLCgtLptBdv0GWfZhXpEtg0tltkvQC7\n", + "SXLZw5gavxEs0ZjyXV5e2q2f4B7orezinHIwDR9zPamdGf5vkGyDKJR4BVCJZDJp7BOpP/4ZENX7\n", + "/b6urq6867A7UU5gasLnw+Gwp41ra2vu9iORiGMjIKGDScNpAE3AJJ2RL40kZRAPBoQeCPU8PHd3\n", + "d4rFYuY3j42NaX9/35yRdDrtfEQsZ+GkUB8zjsdlaGlpySUAHhjxeNwRF3jgIaSNRCJaW1vT1taW\n", + "7YHBvjHByWazTn2V7h+QpaWlR93/J7UzczOoD0ejkbOr2+22fvaznznTr9PpaGtry94Ul5eXrkW/\n", + "/vpr0xdnZ2etVoa2yQ4HF3l1ddW+xix0yP/hcNjB6OCuQF29Xs+eFhcXF3bIh42XyWTMfFtbW1O9\n", + "Xnez9+rVKzdTZAciFEilUvZmvru706tXr7SxsaFms2lJP+pt+gl21uApgX7x5uZG6+vrGo1G9smL\n", + "RCIOtXz9+rWxa3JOVldX3SDOzc0pk8n490syNPfixQs7pv7B0ShwEWnAMCEajVq3dnl5qV/+8peW\n", + "4oN90uX3+329f/9ey8vL2tvbc0cPfIW7/g8//KBqtaqzszPzb6+vr7W3t6fj42PX6Pl83mPe29tb\n", + "7e/v6+DgwDBhLpfzQ1WpVMysazabDuQ8OjpSLpdTsVg0aw/E4PT01IOfcrmspaUlnzblclmlUkmt\n", + "Vsv00lKppNPTU+caMu3r9/uq1WoqFouqVqvqdrt2Vnrz5o3x+larZWoruDY9ytHRkVl43W5XBwcH\n", + "2t/f1+TkpBqNhsrlsqeYcLpPTk40HA51dHQk6R4B+f777x91/5/UYkblMTExocPDQzdy2GmNj487\n", + "LGZ+fl6Hh4fWpcEpeP/+vfb39x3zAH4r3fMRgrVyqVTS5eWlMpmM5ufnHYcWtLm9vr7W4eGhfSGQ\n", + "VtH4VSoVVSoVN3grKyuOhmAkL8kBQxzrBwcHloENBgPt7e3Zsek3v/mNbm5uLKz97rvvNDc3p/n5\n", + "eZcsoAeUBxgYohaH/1EsFt2gvnnzxkLWVqv1wCyRoQiLnRMS3J9mGvX85uamfx8ql8dOAJ9UmcFo\n", + "NRQK2SeDWpcwHDDOWq2mr776yrsLZUk6nXbIJf5ywFfLy8te+GC5Nzc3Ojo6cn349u1b7e7uamFh\n", + "Qaenp5LuaaIcryyGeDyuubk5LS8vG4Ml1HJ3d9cNFI3d9fW1tre39Zvf/EaJRMKEoUKh4DIAoelX\n", + "X33l180kE3YfCM/Y2Jg+//xzZ7BAjDo4ONDq6qp5JJRe+I0Ew4Du7u5c4jDeD7p7ZrNZlxoE+8Ae\n", + "JKkLDw9IXt99990H3/8ntZjJ/6CZYuoUDoe1sbGhQqFg5CGVSqlQKDgxlSFGMKe6VCopEono7OzM\n", + "kh+I6mDYmKdw5MNWY2dGAcJghHKBAE3MY3AaxUAlGo0aj8UPRLrvCwjWGRsb0+Lioo/y6+trY9Px\n", + "eNwT0ampKQdrfvrppy5LwuGwhb6j0Ujr6+s6PT1VLBZzc5lMJhWPx5XL5fTRRx85T5vSand31+6i\n", + "5XJZ29vbToglZm56elpnZ2caDAZ2RGWsju4SPsljridVZqA9w22IYQgeGpLs8IlcSJJ3WiAuRsfQ\n", + "HZEzgVgg4iyVSra2YmwNpTMWi/k0QEJPp7+wsGDVMscsGrzr62v/3HA4rFar5RMGSZgkm6dLcvYJ\n", + "xzmTUGrsTCaj7e1tIy3IuYDk2u22RqORKpWKR/AwChnpMwACsotGo3rx4oWFuQyJgBZbrZYymYzL\n", + "D0or6K/D4VClUskml5jWPOZ6Uos5aO4HvISUh1pa0gNVc7lc9hEMqM/EC8wVAjwqEbjGmMLQYJL2\n", + "ymgaw/Fnz55ZnR0cZiBUlWT2XTCMp9lseurGiB3/ZeRWwJGrq6u28gJ1YfHncjkrZ/idGItXKhVt\n", + "b2+bHTcxMWEfDlAZPgecSMPM3wNTjs+RwgV1AG5J0JOj3+9rdXXV/I3x8XEtLy8/6v4/qTKDnQrj\n", + "Fbrzdrttayx229nZWSudsZ2CjVapVBSLxXR5ealisahQKKSDgwMlk0mPrsGKeSiAxfL5vNbW1lQu\n", + "l7Wzs6Pb21v95V/+pdbX151oSqQbkzbCe1i80EfZzcCAc7mcd7d8Pu8hBRNOVCl4S0PXROEdiUT8\n", + "fSy0m5sbnZ6eampqyhg8Q45CofCvOO8jYG21Wvrss8/cZPPzMU88PT19kAkIxZX3Gi860J5er6ff\n", + "/OY3j7r/T2oxI33H6QcjlXA4rGfPnunw8NDHtyQHr4NPS9Lq6qqlUalUSpFIxEORUCjkoMZYLOZd\n", + "nA6eUgMnUerBdDqt8fFx79rEDWMWTrQDQxeGPpLM+ajX695Nx8fH9fz5c0/TUGpjLnN1deUdG+0h\n", + "C+jLL7/U0dGRSw2w9Ha77QcYRGV7e9tYdKlU+ldKokqlomQyaUrs+Pi435egH93W1pZ9n4M49nA4\n", + "1K9+9StFo1GtrKzoj//4j/XrX//6g+//k1rMQQ9mYK1qteruGbPA6+trJZNJ1et1vXv3Tjs7OzZc\n", + "mZycVD6f1+7urgqFgpEE1NXlctnG5eVyWdls1iJSiOhzc3NqtVpKJBJaXFz0CYAmMJPJeNIGYWl6\n", + "etqsPZzrwaPhQY9GI2cdnp6e6vnz567ty+Wy+dfQVUEhUHpfXl7qzZs3mp6e1tHRkdLptDkolBWt\n", + "VssSrLdv32pnZ8dC2/X1dYcYNRoNpVIp9Xo9nZ6eusSQ7pviw8NDbW1t6erqSr/73e88Xq9Wq+4J\n", + "KO/gV/+zf/bPHnX/n9Rinp+fd94Io2kMuQmtnJqaMnIxNzdnHzdqZBACPDYWFhYkyRESTPWIZSBK\n", + "DCckGkIQE6AxOBLgzDRjkpwGC6zFrnx1deWJGgSfRCKhdrttvJjaPJvNuoHr9XpGVSDvT0xMeAwt\n", + "yYJWSeadcGKhvIY7Mj09rZ2dHUNulB6UQQx/+P6FhQVzMhjRIwKg9s9msy6lOG2SyaQpoR9yPakG\n", + "EGJ7Pp/XDz/8YDSA3fjo6Ejdblfn5+c+dsmWhnMQDoe1v79vbvFwONTp6amSyaQGg4EtXxlQkCPS\n", + "7/f17t0714ClUkmFQsGICnActeK7d+8eKMFpMlutlvL5vNl7V1dXOjs784ADGyuGKJQ533//vWKx\n", + "mOr1uhl6eIccHR3ZKheL2cFgYE+Ld+/eqdfreQpIJjj85lAopL29Pb17987MOklWqmAWQ2nBCYG7\n", + "53A4VLFYdANKGdLr9bS/v69Go6FKpfKohSw9sZ0Z3kM2m3V2NGNW6t0go47dEYIM0h0IQdSG1JWz\n", + "s7NKJpNaXFxUq9XyTomsCoiOtKWFhQX1+31Fo1Hd3d0ZW56fn1c8Hlc6nbaUa2ZmxgaGqVTKeDkN\n", + "K8gJLDXgPx5AnIiur69VqVTsvjQajbSxseEdnVSrYFTD+vq6a/pKpWKUhPp3enra9TOC2KBJ4sLC\n", + "gtUrQYNJBk2gHeSZoFSfmprSZ5995teytrb2KCfQJ7UzS3LXTR2I85B0j/NyhEOAD4fDPlbD4bDJ\n", + "8Hw9aantdluzs7NKpVIeYaM0AX/GUV76yXuCUwD1NRxofDWA6djR+FmowyX5a8F9JZl032g0vJDO\n", + "z8/NpZB+0kQC0yGZAk5EmT36MW8bxuCzZ890fn5ulQ3OoPzO7v/T3pnERpqmef3/hR22Y3Hs4Vht\n", + "RzjttKszO6u6ekEjulsaMXBEQgKEaAEHhIAbHJFAnODACSE0h9EIBiEhREsDamkaxIFlUEs9rVqy\n", + "ypWb006v4XCsjnDYYUd4+TjYv6c+dx8G2V3drcCvVKoqp9MOO97vfZ/n//yXoyMbKDG69/p2oHOk\n", + "jOr1egbvccC0Wi27Sfne6C/vukZqMzOJYtzq9/sVjUbl9/sVj8dv8X1hfCGfJ+KBGpjoYaQ+lAvI\n", + "h/j4YDAwpIPBArERl5eXFicBcZ4sDwxjKG8Y5EgyBUc4HLbQ+nK5bKebd3hCuhbWAjxENFgQe6h1\n", + "GVA8fvzY8hIRGriua7RPHkpJpqPE8851XUNrMpmMGScyxYtGoxZLhykjcCPmjbOzswYtggLBl77r\n", + "GqnNzKQPWT5XfCAQMOgKuibypv39fSMPSdfQHBuBNwkyDzwDJnd+v98cfSCXU+cmk0lzAGV4QpnA\n", + "EEeS1Zk0n/CxyVxhLO4NtPcmvxJrwSDC64gkXTdzjuOYVAweCqoVyq3JyUn1+31rIDlx+b2GQiEj\n", + "18/MzJhZDcoVoDdJxoGBocjCcpjUWU5u3p+Hk9mzmFBh3H11dZ0jTebHYDAwR3pkSouLi6rX61pf\n", + "X1elUtHExISdQizGvcBPs7OzRtfM5/P2+Y7jmBfd1taW1a/o/TASZHrGxxlseC14oZ3CNJOuy429\n", + "vT2b3LH5h8OhMpmMcaRPTk7UaDSshMJw3CsEYBjEz4sbE/wVoEBvXLIkU6gcHBzYz8MDw+tlmAQN\n", + "9+DgwN4PvECazaba7baJihk+3WeN1GZG/o/RNtYASNoZdzOJwk+CUwiKqDckh1MZMSlEJca8dPJ4\n", + "v0HSAVbDzguvCMbYruvq4ODATlo8JGiiyFzB+Pvo6EiHh4fGhKMPkK5Pd3L8uBn8fr8Fv0M4QnaF\n", + "oz+bGoMcfo5Wq2VIS7/ft5iGg4MDTU5Oan9/3+pkPOy8v0NJVqK1Wi2jgWJnC4LEQAqUhQnpXddI\n", + "oRlo9SYnJw1KKxQKpiaBRDQ2NqZgMKh6va5isaipqSnNzc1ZkA55JYxll5aWzFQlHA4b0TyXy1nD\n", + "0+l0NDc3J+kaH3706JFxIHDtgYqKeoXJGajB9va2OWp2u13Nzs6q0+lodnbW3OYDgYDq9bqi0aiJ\n", + "B6ifJVmtj1TMdV31ej0za6RUoRnmZKQvwMcZhQgJA1hp0czSLPJgwuMm229+ft7onicnJ6aK5/ef\n", + "TCbNswM67H0FrSN1MnMK88Zj2CLJ0AJOqpOTE2WzWTMWJwaC6FyiwmZmZixfWpI5+khSvV5XKBSy\n", + "k6vZbGpnZ8cyQM7Pz00SJH1phTAYDLSxsaGjoyO79mkaKQ0YFzuOc8sOtt1uG4VSkk0F8VLma7qu\n", + "a01rPp832iYnKhseh9NwOGz+zeDePKhEx+EgCm+D7wMnhduHg0L6MmEWl1O88ra2tqysou5+ELR6\n", + "FkoKTEuY+LHJaVBwFdra2tL4+Lg1evCLm82mGSwyUCE3EKcflNMHBwe36tX5+Xm5rmunLS7+sO/O\n", + "z8+tGeV1bW5umtVWMpnU1NSUhasjEMD8Bf4EdrQgNNAsyUvBfuvs7Ezr6+vy+XxmSQA9lTpWktX3\n", + "TBt58Hi9WDMcHh4a3EcIKEw5hkhgyJJM9U5ZRFNbKpWMVgB8GY/H7/X+j1SZIck80Z4+faqpqSml\n", + "02nLI2GAwvi0UCjo4ODARtnpdFrValXLy8t6/PixVldXzRqALI5arabHjx8bXzeVSpmHBGGXUEiB\n", + "6iAvAX9NTEyYO+bU1JQeP35sjSs15+Liol3pp6enGgwGhgbgLMq4HT8P7GwLhYIcx7EhinRthFMq\n", + "lRQMBlWpVMx7GluxVCplmxY0AsN2xLWNRsOMZbBWyGQyarfbymazury8vKXMASb1+/3m+BSLxVQu\n", + "l3VycqJisWhxGRg33meN1GZGekSy6cTEhN68eaN4PH5L+MmVyBUNNLa6uqqVlRV98skn5nnBm7Cw\n", + "sKBms6mNjQ1ls1nF43Ht7Ozc8l6rVCrmN/fpp5+qUChYWE6/3zee8MTEhN69e6dMJmPm6MViUUdH\n", + "R9re3rbp3/Hx8S1y+/j4uDqdjh49eqTDw0N7CDFqYWixvr5uDZ8kazCRg52dnemTTz7Rs2fP7KYh\n", + "U2R7e9sw4Ldv32ppacksgGOxmL744gs9e/bMyjYa14ODA5ueHh0d6ac//am+973vmdXu9va2lpaW\n", + "FAwGremkLKK0evBn9iyutlwuZyQZZEvHx8eWDY0KJRKJWPYzENbBwYFtfm9cL/ZZ+FGgisB6lvEv\n", + "sWuhUEgzMzNKpVJqtVo2MGEczfQMFQcRZhDUveVMMpm01wSpB6ycKR9NGX4aMzMz5iY0GAzsRgqF\n", + "QgoEApqfnzcVCYT9wWCgx48fm+s+ZRGuQ8RhUDdjxHh5eWnTRfgnS0tLkmSYerFYNK+74XCo+fl5\n", + "44D7/X5Tkd9njdRmppMGA0UdghoC7wvePO+Ym82dTCbtRCZEHkpnOBxWo9EwX2NYbl58G0IQAxk2\n", + "AI0p7pcMDyAKwa7z+XwqlUrmTYE+EYYZymnMzxHNcpKfnX0Zf0wZhI0s2C+1NvyNqakp5XI5TUxM\n", + "qF6vW7oAzkjE0IE5s9E5UamtgT8ZefNQg6gwtsaCADsvRujf+c537vX+j1yZQa16fn5uFliXl9cp\n", + "pODDPp9PyWRSlUrFUA8k84hJo9Go+Vd0u10z3p6bm7MGB6IQDRhWVl46qVcxIsnQCUbtuI6GQiEj\n", + "GDUaDdVqNWsGwa5xqfeyzkBkGOrAcUin0+Ze32w27ecvl8tqtVrGycY9lKkllFGI9vBNUJejdsdY\n", + "Z2VlxWRUwI7AcJLMbRVWHYQmGs1arWZG7vcVtI7UZgZvbTQadhJ2Oh3l83nt7e2Zsrjb7ZrXnCS9\n", + "e/fOLKjy+bw2NjZseME0C38NfukMKQi15OFhzLu7u6tQKKRUKmWmKq1Wy0qSra0tM6nBCZTanTiH\n", + "vb09K51wPQLZaDQallaFoSEMvkqlYpDX+fm58a753bTbbbXbbUWjURv/0+RielgsFrW1taUnT56Y\n", + "sSSmjdPT0+anjEkkJzRIEHAe6bfHx8dKp9PmsYFaPZfLqVqt6vT0VD/+8Y/v9f6P1GYmugAZFFJ6\n", + "NhXX4szMjPr9vhYXF7W6uqrl5WXVajXlcjn5/X4tLS3Z38f6FQNzGq1+v28n8ZMnT9RqtdRsNs2o\n", + "EbI+I2tOJIhNSPxh6JGvB+MsnU7fsiHodrtWZzIYmZ6etqHMycmJ1tfXlc/nVSgU5PP5bJqXSCTM\n", + "vZTXgko9m82aAPbq6soCLa+urpTP5zUzM2NNMkIGbhPsc6EHUNpg6sLwB4td6ZpzjlgC/jZ9y9zc\n", + "nN68eXPn93+kambpyyBGmjemX81m0zjI/BnWr41GwyTv1WrVuvt6va6LiwuTVFHHAiexiarVqqRr\n", + "TSHxZDxQ0CUxXYTny0AHkjwnJIy9k5MTS5elQQUSY8zNyeitf8lNoX5mQ+VyOeNE87oxPidTkBhm\n", + "WIE8WODPRFdgWyvJmkWyUfDgANILhUJmuwuejBgYNTw1OEaOd10jtZk5dbrdrr773e+aG2Uul9MP\n", + "fvADxWIxlUolzczMaHFxUd/+9rdVLBaVTqf16NEjMwtcWFhQsVjU06dPNT09rSdPnhgPASkS+Rx0\n", + "5JKMdD81NaX5+Xm1Wi0FAgETASwsLBiCkM1mlc1mLd1Jkj744AMtLi5KkoX6kFWIN0a5XFa329Wz\n", + "Z880Pj6umZkZM/CemJiw9Cb0d7Ozswaj4WtRKBTMYWhhYUHLy8vy+/3K5XJmyh4KhfT06VNlMhnL\n", + "BE+n04pEIiqXy1peXtaHH36oi4sLLSws6OzsOnY5HA7r4uJCmUzGmtKlpSWdn59rdnZWkUjEoL/F\n", + "xUV97Wtf0/T0tPL5/INxonfhZBQMBvWjH/1IR0dHpoT+4Q9/qFqtpv39fZMhvXnzRhsbGzo9PVWt\n", + "VjNzwJcvX2pnZ0fValVjY2P6+OOPzWzw3bt3dr32+31zBhoOh1pfX7dQm+fPn0uS0TMDgYCeP39u\n", + "JJ4XL17cIjfF43Gtrq5qa2vLTFKomz/66CNjrWFntb6+buwzWIG9Xk+VSkX9fl8vX75UIBCwJjca\n", + "jZqtbb/fN3bc0dGR1tbW1Gw2Va1WtXWTEHtxcaHnz59rb2/PmHiDwUDb29vGMlxdXdXZ2Zlev35t\n", + "rks00C9evDA7r3q9boJanI5c19XLly/t99Bqte4tmxqpzYyrDnIjsGKQCq5qYDRKiIuLC9PdQTL3\n", + "bpTz83NVKhWjMKJIoTHi8xkOgE1LshEwZQMUT055xsX4Z6Acka6HHXjTMdYGPeFnREQLJOit6ykf\n", + "CM2RZIw+0ATIRECMUDqBNkEi4Jmcnp4aZIcyhq8LzwRKZ7lcNjQIliK1MjAedgx4Yd9njdRmjkQi\n", + "FhRD5AKnDMy1SqVi4T3o9Gq1mlKplOLxuF6+fGn8g16vZ/J/L6F9bW3NnDObzaZht/gwe2EyHg5o\n", + "j5B/CAA6PDw0F1Bqcuk6Lm1/f98SXicnJ7W1tWW6PVxKyQV/9eqVksmkxbcR1lmtVs0oETMX6uKT\n", + "kxNtbGxod3fX+N5+v99IRFBEId5vb29rOByaqQuEJep3fkZKMQhSbHh+d0Q7IwsjMcvLIb/LGik0\n", + "A6nP5eWlnj17pnA4bN16NptVu9022RR/dnl5aXgudd/R0ZEKhYJ2d3eVzWZ1fHxsymcmd8lkUpFI\n", + "RLlcTj/5yU+Uy+VsWgd7bG9vT5OTkyqVSnYLQGKfnp62CGRG581m08SvcB7Gx8fNHgGJlOM4hiWj\n", + "K1xZWTFRbCQSscxwLBIQ8ebzeQugxLne5/NZ4urW1paVRZysExMT2tnZMcNwHEERrLIJaXrz+bzZ\n", + "N2DxQPO6vLysYDCoZrNpSbqJRMKoqPfxaB6pzQx1k+katk8MDhqNxq0ygT8n9Ql5EYoUkA4wYuwA\n", + "KC2wxGKke3Z2pu3tbXPLhCRUr9eNJITxSTgcNlFou9022RIO9I1Gw2AwTji6/snJSQu0JxjI5/Pp\n", + "3bt35h2yt7dndrSgGJKMpsogCWsw/gzO9eXlpTY2NrSwsGA+z1ADSJslk5ByCCemSqViGHmv11Oj\n", + "0bAHC6NxuNno/1qtlsF3d10jtZnhOUiygcJ7771nXT+CV2/edb1etw7+8PDQPIX9fr+ePXtmm4RJ\n", + "2WAwsGlaJBJRp9OxzD7UGoPBQKVSydJK+b5+v1+1Ws2+DtYDnNBc3f1+XwsLC9rc3JQks5dFHOrz\n", + "+VQul20a6fP5zC9udnZWtVrN+MuE9FDy4H46OTlpATnAdCARR0dHhjF7hxqcwGgmIQvBdb66utLK\n", + "yop2d3dvZbPw0GHXAF4OTOo1bbzPGqnNjAH25eWlnj9/ru9///t6/vy5VlZWjMPw7t07u+5evnyp\n", + "YDCozc1NTUxMaGZmxtCEYrFohoftdluZTMZO+/X1devOHz9+rO3tbVNykIf35s0bxWIxJRIJra2t\n", + "yXVdQySGw6FqtZpKpZLa7bYZfOMsOhgM9PHHHxu3AfLQ6uqq3n//fYsuQwaFO//jx4+1u7urt2/f\n", + "amVlRVtbW5qamrplI0Y93el01Gq1rLlEZULjNzk5qY2NDSM7XV1dqVarGef75ORES0tLRmuFj7K5\n", + "uWk6wEgkYhwNLzfEK5aNxWImaHj79u293v+R2sw+n89y+eLxuMmksKXiTYIY9PTpUyMQgXSUSiVD\n", + "NpaXl1UoFPT5558rFovZaT4/P69ut2skdhKfOGXi8bgODg5MFpVIJGxYgkuQJAvxOT8/v5V7PTY2\n", + "plwuZx50DF0ePXqk8fFxpdNpHR4e2mtqtVoqFAp2bZdKJQ2HQ/ue4Me9Xk+xWMxEtvl8XmNjY6b2\n", + "zmQyevXqlfL5vAVXUmZgWQsSA1dbkj0IsVjMkrwqlYohHJlMxiRqZ2dnRvWMx+MWLBoIBPTkyZN7\n", + "1cwjhWaAXEgygan35ICeCJOOcEu0dJQKdOetVsuuf6aJ0BjPzs6MTMP1OxwOb2XtDYdD4/iiViEu\n", + "gaB0LGAJtOT/OcnxcPNa3cIRxugGWAvRKA8EPz+oCyNnb9Qxr5tJKfU4jSoNKp4YOHuSQoUaR/oy\n", + "0J0bBUYcE0xvpDD2wZIMBcH7465rpDYzOjw2JJgyTdNgMNDi4qLxHiSZ/Ws0GrUOHGFqOBw2RTZ2\n", + "A+jtcDDCoTMcDmthYcEoqKSasnGRWUky4g96PdTgkINQpcCdILfbi7rAicb5iDLULiPnAAAbvUlE\n", + "QVSITYz7Etxtr2YQYQIU1mw2azkmk5OTFl2M0p26GjUNpCfyDZFUwYpD2we1ttlsSpI9CAgNODAm\n", + "JyeVSCRULpfv9f6P1Gbm2gOrJQiSXBOSlCCbY91KPccbAd0RPwmaJeilJycnRkJC5Xx+fm6xZPCH\n", + "IbRD8YScj2sSrykWi91yY2q32/ZnSPZ7vZ4kWUnC6Y27PfwMhiZY24IaYA5DApTXmgtivDdkh+8P\n", + "6T4Wi1mTx0PDTRiNRo0HzuGBRQLjfgZSCAho1r3uU/dFM0ZqM7PpMAakJpWkWq1m5Bmc6PFqoGa+\n", + "uroy1bDruup0OqrValY+EFMsyZw28VzGdBFLAmxrQ6GQ3rx5Y+6jCAIwGifWbWdnRycnJ0qlUuZs\n", + "71WihEIhc19CuYJFAIrvbrdrkGMgELA/R7iLRwf2sefn5yYgYITOx6Xr7D++Jmy/4XBoMCeYd7PZ\n", + "NGdU4ERJRiRiotnv97W9vW1TRDSLDLD29vbu9f6P1GbGXhYd3WAwUKVSsQaFDA5q2Hw+r1wuZyfx\n", + "8fGxEY4uLi5ULBatufNycyVZAiq2AEzOkP6gCfx5ISo6PgwaOU0JvUHpwVXPmFm6tg7rdrsKhUJG\n", + "hAfL9fv9FsJDxLLXmKZWq5kaG/k/1lx4KYODcwuMj49bvBun8GAw0MLCghYXF43rUSgUTJzgDQHl\n", + "gcKEMZFIqFQqyXVdO0wo9zBhv88aqc3MYAOTleHwOh/v4uLCNH6cmJyMOzs7doKEw2FDNxCiQldk\n", + "EkdUA1o2x3EsR4Tw+KurK6XTafsauCJheXV6empKDzjEY2NjFlOBkoXNwegZPZ4kG9hALe10Onr5\n", + "8qW5B3lLG/K2k8mkMpmMfZzohsFgYEMNbxPH5+I9glk4zaTP57M4ZeImBoOB4vG4/f75vfn9flUq\n", + "FbVaLUUiETswdnZ2TEjhdWm6yxopaG5+ft42FL9EGqpsNmtdM6Sjcrl8yzWT0xtJPIw33kTqQklm\n", + "gohLPMMU13W1uLiotbU1I50jYmVogqkiSUyYwFDb7u7uWoYgNTOGjtPT07ZRksmkZaiwsXBRokkj\n", + "Ai2VSpm7J6bf5J9MT0+bC9RwOLQxdCgUMm0ktr7YF5yfnyuXy9nn4qyP3hL1OFFt+/v7yufzNkSB\n", + "xJTJZDQYDJTJZO5NNBqpzVytVs2EZW9vT9lsVmtrawoGg5ZljaNmNpvVu3fv1O12Dd8NhUKKxWJq\n", + "NBrK5XJaX1/X4uKiJSYxco5GowbVYdiC1RSEG9d1tbm5aWHulDZnZ2cKBAJqNpvGa+h0OkokEkYS\n", + "8jox8WCyaS8uLuzvUPJgEEMNurW1ZRg7LkWJRMLIROgMiV8DWqxWq8a5GA6H2t3dNUdSEri2t7eV\n", + "y+XU6XSsvMFugXq51Wppb2/PAjU3NzfNSQqvEhptDp1ut6v9/f17vf8jVWZ4nfCZMiEJQrRJM0JZ\n", + "wcmDAjmRSNgJBUZMzQxWipSK65uUJ9QqXmgNj2TGyYTRgCyQ/ee6rimp2QTEkYFDUx7x+YyHXdf9\n", + "BdgOU3HorpLMaN1rWg5C4/V6QyIGOoF/NHpELGips6nf+Tt4YvMzghJxkvM74+vyujCmuesaqZOZ\n", + "rn58fFwHBwcWmtjtdk3Oj21XsVjU2tqaQqGQtre3LYH1k08+sYB48keurq7UbrclXf/CqQ1brZbB\n", + "YHxdfDW81+fPfvYzG0sTwg4Bajgc6vXr1/ZGIxY9PT21FFaYe5999pmePn2qt2/fGtKB0WKlUtHK\n", + "yorVzh988IH29vZuGceAI0NFrdfr2t/fN5oq9fnr16+N24LDvSR99NFHBqsB8WGfy4bEIhdfD7jN\n", + "RDB/+umn9jPB8d7Y2FAqldKLFy/u9/7fb/v8Zi3Gp9SYnHLSlxJ5rKDIdR4fH1c8Hr8VOYbrOyRy\n", + "Mvq8RHWc7BG1gnxgKg6xZnt7274/DDGvb0YsFrP86ePj41vaunQ6bUhIv9/Xe++9ZyR9It3Q3kHT\n", + "7Pf7evbsmS4uLlQqlawZgy8cCoUM2ZiZmbFbAwMbyEoYvRDgeXV1pVwup0KhYA8b0cYIZTFZhIVI\n", + "g9nv9y0vBQ8+7BaOjo5ULBYVjUbvjWaM1MmMBhBCzenpqbLZrIX1lMtl49WSUw2TbHZ21poWyEpw\n", + "H/DMoEGho2dChsccdTdwGE0S17yXu4EUX5IqlYoWFhaUSqXsFKO+x5mUm4N6vVAomLUCrDj8Orze\n", + "0MRAcFLi5o8ns1eYGw6HLQg0FAppfn5e5+fnhttDV00mk5qenlYymTS1O+UECV9YLgD7MXghbSAe\n", + "j2tra8u+P5HE91kjdTJ7hx107G/evLGmaWNjQ41Gw3i7yJQkmZz+5OREL1++NLYXCg82K40ZWjYe\n", + "DnzhMIEhtcnn86lardoQR7r2ZUOKj0EhnBLGzRMTE2YW3ul0tL+/ry+++MKmcKenpwZFoiBJp9M2\n", + "5SSAc3d3V1tbW6rX65Y0y7QP4hRhnycnJzo8PNRnn31mnnWXl5c2DKJcQ2GCsrvRaNgAqNfrme4P\n", + "Xjh+Gqenp6YhBOFptVoWQQyz8a5rpDbz7u6uWXNNTU1pb2/PVM1ch5lMRqVSySiLfr//FgkmFArp\n", + "61//ujUofAxL206nY40kmR5YvGKIuLu7q/HxcW1tbVk96NXuMczAooCNxGvnxAeqk2RstP39feM+\n", + "YEwDTXN1dVWnp6eampoyLjVQHthxp9PR7u6uGUsyLcTyS5LZ3UK+wgAmFotZ3jcIije/G9szmm9Q\n", + "HXyXd3d3DTt/9+6dBf5kMhlrEO+zRmozT05OWgbgxcWF+U8wwma4gDKZUwUFBGtzc9PqXsdxTD4F\n", + "5xlqJ2oLRtjHx8dKpVKan5/X3t6exavhKQf3+OjoyGpGBjY4CtGwSTJyUqfTUb/ftzwRPJrxiGPz\n", + "Ya1FnY9mkVsKrziGIXwNHmxJJjDFOxozdbw0sA/gRvOaJQJPRqNR01Eiz8JFlIMF0QDun8Q832eN\n", + "1GZOJBJ2pVOnTU9PG0OMRmRmZsbcO4HUvKcSv2w2F9kbp6enarfb2tzctFgzJnCcRpxMiURCnU7H\n", + "rGXJuwbWQ5PHZoCB1+/37b8xCPf7/cZXDgaD6nQ6xuHodDrmqVwqleznApkAO2+32zaA6ff7t6xk\n", + "vXYAPp/Pmk4ePhygqMPRHoJHx2IxJZNJSTJCviRj6qExpLQBPqW/YbDjjbO4yxqpzcyAIRwO2xgX\n", + "3R61n+M4Vm9SInDFQpDhKmU6SLfuOI5yuZx1+6SxIsPKZrO3BKSZTMbyAQeDgfL5vGG3NE+u65pI\n", + "9vj42Nh4Xo8579WOe1Cn01E4HDa5UzKZNAsujMbxf87lcsbmY6N7rbp8Pp/i8bjm5+cNt0Z0K10z\n", + "9bDdKhaLFnLE7xmlNTgx1rmgI6AtcFHoJeCC8HoeMk08C14ALLdGo2FTMghAMOey2ax8Pp9evHhh\n", + "glTAfJoW1NG8AePj46pUKmYpRd0bjUZNQXF4eGh17enpqfk6U3/2+33z0SBlSZKN3iHpey3DqHXB\n", + "eznJ4W1L11wNEBwSoqrVqiYnJ01LCFNNkim0A4GA3R6VSuVWrBxQ3tnZmVZXV9VsNrW5uWkPH1NA\n", + "IDjKE0QP9AcIcuE8g8ow/MHD5L5WAyO1mVEvQLKfmZm5ZQyIDxuNGK6a8Bxw3A8Gg1YvgzF7TU9g\n", + "nUEckr7MU4FTAQ7MZI0oByZy3BySzOeDWhxCFLh3IpGwkTz4ND5wvMZ0Om3cEdKd8L1AXMBmYQLI\n", + "BmJjBQIBJZPJW2lU2OhSSsTjcXMqoozhNXW7XbVaLbs1+H6RSMSaR3oARu2SjPvMzXjXNVKbGWrk\n", + "xMSE2u22XePeuIHx8XGT8WNyPTU1pZ2dHWugQBEI60EpAQbLZqvX68rn83bieYN5/H6/NVyHh4cm\n", + "FkWNAY86GAyq3W5rYWHByDdQLREWHB8fGxGKmrXX66lcLpuD089n8Q2HQ2PujY9fxyvTdPl8PkuW\n", + "hXdBqXR4eGjOqWgmq9WqlWxEEtMcImpAkoV3M5pCSUZuAmkh1u3s7EzJZPKXUmJII7aZab6oKYGM\n", + "IJZzNVOngmIg7iTsBigJBYg3S3pyctKw1lwuZ+NaThmGE964MngQqVTKBgcISfn+zWZTiURC2WzW\n", + "XhvTQiiiPAC4bNJo0cAlk0m7acbHx42miWl6PB63PgB5P/AYpVYoFLoVwsmgx+fzGXmez+f05uf2\n", + "2gnDT0E6xY0F9Hh6eqrFxUU7oTudjr2mu66RmgBiBA4H4ejoyPzTgLfgEMO5QKMWi8UMyqIM4R9M\n", + "vNlQfr9f3W7XOnJgPST/uVzOqKachLwGMGmQClALTLglWQlwcHBgXwtFCRwKdHxYWwHFgdxwolM6\n", + "VKtVo6BeXl6aPwY178TEhGHtyL3q9bqy2awODw/tNKaWpv7nlK3X64bQ0PCScksWIpK1i4sLU4jT\n", + "eJMicJ81UiczDC58Gri6vKLTYrFozYrrulpbW1M4HLag9UwmY1ROBiGA/8PhUO12W5FIxK7iSCRi\n", + "JxQTNpz1qUOpXwkI6vV6t7BkvhecjVarpbOzMzOXweET7Jdam5E4J3W73TYbBdJkgR0Jcef7oAzh\n", + "9mEUjRoHZhx8i4ODA8OwvTcesikQGgwZUaLTUyAcTqVShq+DxMASRPFz1zVSJzNUT0k20s1kMgY3\n", + "4UCUzWbtysMzmSndxcWFqbNTqZROT09tgkaDh5EKjSLwXyaTsSFELpezpnBjY8NOK+iWXrErJ/fP\n", + "GycyXUulUpKuSwL4EkzSTk5OTOeIWxGlCbZfnOQQ6UlWhe1HBgwELWy24vG4PSiZTEaJRMLi1+C9\n", + "8L1o/BKJhLnpT09Pm0mjJONKn52daX5+3hAdvt+DP7NnMahoNBomfQL+KRQKJtkBjQDEhyMcjUbt\n", + "ZCEtKhaL6fDwUJlMRicnJyoUCobrBgIBLS8vG7sslUqpUCgol8uZW2etVlM6nb7F4CPYHX0fDwlB\n", + "PoFAwDIEQRIkmX6Oh5P8bvjOPJjU6ODSJLXSiDLiDofDZkJDsA/ly+Xlpf0cOPJTViBvOjg4MANz\n", + "qK1g1jxAPJzYCsdiMX344YdWVx8cHBhz775Eo5E6mff29kyA+vbtWz169MjGzo1Gw3jJEIi++OIL\n", + "w1tRcqD7Q5SJvs9b4wH0E/gTDofVarXME5nmh1N4bW1N0WjU/JiDwaBt7HA4rJ2dHc3NzZmyGs6F\n", + "JPPFcF1Xu7u7yuVylhLV7XaNegmZh1IIWA3yz9zcnEFnvV5Pp6endhJSNzcaDRtxX15eam1tTeVy\n", + "2YZK3FwXFxcmzvV6kwwGA/l8Pm1vb9vno67hhG40Gtrf37dJIU6kkgwPv+saqZMZQjmNBJvL5/MZ\n", + "/xbCDSbegPmc0LjEw4WALcdVDD4tyYSq4LaoqIfDoSlNoDziUMqpCRHn8PBQh4eHJlAFWsRUkBvk\n", + "/PzcsG82I03ocHidPsupeXh4eOtn7/V6NkJHKgWc1uv1zMkemy4eYJTaICOgHNBMr66udHV1ZQ8J\n", + "AymclLzfy2v4jnMSDSMYOA/wXddIbWbHcZRIJKzpYsIVDAZtfDw1NWVKj1KppE6nY00UGSSwuILB\n", + "oIrFomGpZJgUCgVLHgXb5mrGLBE/DLJCaL6wqOVEu7q60uzsrJ1y0jW7DL4whCDMVqhFQURAbgij\n", + "Jx+EcgRBbb1el/Rl+CUj50gkYha7bE4Og2g0qng8rlgsZicrzSoPPqUDpCdc+KmHq9WqfW1SbLkR\n", + "gDnxLXkI6PEsygjGsJOTk3a1UxcChXEaQaL3cmzR6yFLIvWUMoPrFuTg6OjIRs9gsVy9cIWpxTmx\n", + "sa+dmZmx6xaUhSubk5TXSv3PwAEyPafxwcGBTQ2BGPkeuJYy4MG2FzU2p2Sv11M+nzeEBrSC7w9d\n", + "liFUNBrV8fGxTk5OzMwdtTmCAQ4M/o03Hli2pFvY913XSG1m6tVUKmUYM/UfUzBCKrGe5d+lUsli\n", + "0Rhbo9zgTffmccRiMdO7cZ1DPz08PDR2Hrgv0zfgME5NxtFs8kAgYLcL3nPIn6TrJheus+M4BnP5\n", + "/X5T1XAzeTdTKpUyZhuvzcv0Y2oHXRPkBYbb7OyshV/yoDLwuLq60uPHjw3K8/l8WllZscYQf49Q\n", + "KKROp2OhRuVy2dAWGtD7rJHazN43AukPJzJlAB5zIBS8MbVaTZ1OR3Nzc7cyo3GRR4HMlAyneDa4\n", + "67p6/fq1EomE5ubmtLm5acQayhGgNDYvHGGu89nZWWOYMYaenJzU7u6u1cH7+/vG/qOuRZ0tyVKx\n", + "4BtfXV1pfn7e7GO9rxUMmZtmampK1WpVwWDQsPFYLKZ8Pm8REyA3HBKo2JvNplFdJyYm9PnnnxsD\n", + "kN95LBYzVGhra8tKEMx1aIrvukZqM4NIQG2k1mTiRaOWSCRsLAwiEYlElE6nTfrU7/eNdE+NTSnS\n", + "bDYNl93d3b1FMAI9oRnFS5mOneAaXh8km0qlYr522OZSjszPzyscDqteryuTyajT6WhsbMywdG8T\n", + "x2QzEomo0Wjo+PhYe3t72traso3sOI6KxaIikYgNl8ixLpfLOjs7s8FTr9czJIXXCh2Vm4T6n2mn\n", + "JMOgu92u4vG48Um2buLVSqWSPXjD4VDVavWBnO9d2KRCjaSbZiM3Gg1TRLCRJVlqExuOpoYxNSNw\n", + "jAPxK4YQj66QUwoyO9wMmjVq4lgsZjUvGHc8HjfvC5yJQE9IcoX/izUApQS+bY7jmAIcxUcoFFI8\n", + "HjdPDn5HQHsYuOAxwgPrbUi9jkgMQrxZKgyAuHlAM3BsOj4+VrvdtqHO1NSU9vf3jTuCKujBnsuz\n", + "aLTwNhsMBvZmc9Wn02krD5iSzc3N2Ym2sLCg/f1984PDLEaS0T7p7lkkTI2NjalSqRj5hgYRrSG1\n", + "O280D5xXQoTEiXGvd9OtrKyYqQwDHx6aJ0+eGOQIEw1NHnAlpyq5gFNTU5qbm/sFC1tsFkibhUI6\n", + "OzurFy9eWNOMDpCyi6koTSDxyfBZsACDlgpNAHRmYWFBn3322Z3f/5HazJC8SVpl80iyN51aV7pO\n", + "p9re3lY+n7eYhFevXplbveu6Rn88Pj42eO7ly5daWlqy0Et86VzXNVd9pnbBYFB/8id/osXFxVu8\n", + "h+npaZu2kTIVi8Xsagd263a7mp2dtUy/Uqmkd+/eSbqewNEEVqtV4zPDQX7z5o01gMCKYOR8X5z4\n", + "vfKnVqulYrGo/f19BYNBy+dutVo6Pz/X7u6uORbx+zg5OTG+B+qS8fFxsyFD2c7D/vMj73a7/YAz\n", + "exeDDt5AQi45AagLa7WaudZjE7u2tqZ+v690Oq2LiwslEgnzjCByDUlSuVy2EuTJkycWX7y5ualk\n", + "MmlBP5iFg5RQPoyNjWlnZ8dujEAgoJWVFcPDwVtbrZampqb0+eef26Bhc3PTcqkLhYJ561H3A0fi\n", + "tTc2dp15zX8zCofBh9k6/tIbGxs2Wo7H4woGg/ZvXE+JWoaJSAmTTCYNVgRnhlaL8z7cj1qtZiUK\n", + "2DSawbuukdrMmLGA7wITodr2+/12ivK5lCbf+ta3tLy8bE0ZmCcEdLgGJL1Go1EbqBA2ubS0pFgs\n", + "pn6/b1AWWDHIBMJONgcyJzwwwI6xuiWgExvY+fl5Q1m46r3GijRpi4uLphd89eqV3QrAX9/85jeN\n", + "gA/X23Ec5fN5NRoNOzVRrbTbbdNFcioDX9ZqNeNpx+NxRaNRlUolI0rBRGQSG4lE9N577+np06dW\n", + "zrXbbSNU3XWNVJmBI7ska4b4BVUqFePjktFB/YgrpiQ7fY6Pj83vLRKJ2Cg8kUgY/fHNmzdGNg+H\n", + "w6pUKjb9kmQNHU0WnA1Yc9SO3kAbrAEYPEgymVSr1VK5XFa32zWRgVeEQCk0Nzdn2sBWq2XNrNci\n", + "gJMVMxt+fzRpl5eXajQaWl5eNldRYtWYbEoyOLPValldziLSgmkpURk0mAx5oNxCB7jrGqmTGegN\n", + "wSpDAUnGoiOMJhAIKJ/Pm0SK63F+ft7G2fPz85qbm9PV1ZXJliDpF4tFyzABrUgkEqb4QPDKm4tr\n", + "kVedUSgUlEgk7GuAyUqyiGSGJ9K1/KpSqSgQCGh2dlbSdVN6eXmplZWVW4oRtH3pdFrvv/++GZDD\n", + "Vtvb21O5XFYoFLLvA+UzEAgoHA5rY2NDPp9Pc3NzdprGYjFls1mThPEQYr8VDoftAeXURZkdiUTs\n", + "ZoH2SVZMKpXSBx98cK/3f6Q2M8gDLvk/H3PAyYfoE6yWLh5SEFg1VlkA+0BTjH2B/hCB8mAwNYMD\n", + "7XX5YSQM6iLJ8FlIQahbQArQyAHz8TAwiKB5ZQLoDajEK5mfm+9BJh8PO8iIV2RLLe793QGfwQLk\n", + "AWV4wykbCASUSqXs1oHY5PP5jEgF/Ie8amNj417v/0htZr/fbx5nXKHIplCgMDjwJiOB5+K9zJXN\n", + "NMsrMG2320axlK7JMvV6Xb1ezzKmJVlNy/gbDjP5f9T2MMoGg4GmpqZ0enpqUCC2BJKs5oT15/P5\n", + "zNWfYBzGxlgAICBlosnmZQNx4vf7fbNEoImGigrxiIcJEQEwICUVcCKjfxAawn/Q+PE6+J0QxSbJ\n", + "fu67Lue+cVW/KctxnNH4QR6WXNd17vL3RmYzP6yHNVJlxsP6/3s9bOaHNTLrYTM/rJFZD5v5V7Ac\n", + "x8k6jvMfHcdZdxznI8dx/shxnCXHcVZ/3a9tlNZITQB/E5dzjeH9Z0n/1nXdv3bzsa9Lup9JxMP6\n", + "hfVwMn/167clDV3X/T0+4LruqiRLPXccp+Q4zh87jvPxzT+/dfPx3M3HP3UcZ9VxnD/rOI7PcZw/\n", + "uPn/zx3H+Qc3n/vIcZz/enPy/7HjOMs3H/8rN5/73HGc//2r/dF/tevhZP7q11NJH/8pn1OT9Odd\n", + "1x04jrMk6T9I+rakvy7pv7mu+89vTviQpG9Iyruu+3VJchwncvM1fk/S33Vdd91xnD8j6Xcl/TlJ\n", + "/0TSX3Bdt+r53JFcD5v5q1//L0D+hKR/7TjO+5IuJS3dfPxnkv6N4zh+Sf/Fdd3PHMfZkLTgOM6/\n", + "kvRHkv674zhhSb8l6YdMJm++piT9RNK/cxznP0n6w1/KT/Qbuh7KjK9+vZD0zT/lc/6hpKrrus8k\n", + "fUvSpCS5rvt/JH1PUkXSHziO8zdc1+1Iel/S/5L09yT9viRHUsd13W94/nly8zX+vqR/LGlW0seO\n", + "4yR+2T/gb8p62Mxf8XJd939ImnQc5+/wMcdxnul6c7Eikg5u/vtvShq7+bw5SQ3XdX9f15v2Q8dx\n", + "kpLGXNf9Q12XEN9wXbcnadNxnL988/ecm+8hx3Eeua77M9d1/6mkhqTiV/jj/lrXw2b+1ay/JOl3\n", + "bqC5LyT9M0lVfVmC/K6kv+U4znNJy5II9/htSc8dx/lE0l+V9C8lFST9T8dxPpX07yX9o5vP/YGk\n", + "v33zNb6Q9BdvPv4vbhrFVUk/cV3386/yB/11rgduxsMamfVwMj+skVkPm/lhjcx62MwPa2TWw2Z+\n", + "WCOzHjbzwxqZ9bCZH9bIrIfN/LBGZj1s5oc1Muv/AuHZAPr9VeA9AAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "Top detection:\n", - "name\n", - "person 1.835771\n", - "swimming trunks -1.150371\n", - "rubber eraser -1.231106\n", - "turtle -1.266037\n", - "plastic bag -1.303265\n", - "dtype: float32\n", - "\n", - "Second-best detection:\n", - "name\n", - "bicycle 0.866110\n", - "unicycle -0.359139\n", - "scorpion -0.811621\n", - "lobster -0.982891\n", - "lamp -1.096808\n", - "dtype: float32\n" - ] - }, - { - "metadata": {}, - "output_type": "pyout", - "prompt_number": 6, - "text": [ - "" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAEACAYAAACqOy3+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsvdmPZVl23vfb0znnTjFHZGZlZmVWVdaQVd1FqmVSomjD\nEi3BEiVYFgzD0LMBCzBEw4IN+C8wYMCCAL/IT/SDn/xkA6Rk0pxsUjRpkt0NsqeasirnITLmO51p\nD37Y+9x7IyurSRhsJxuM1Z3Iyhs3zrDP3mt/61vfWkeEELiwC7uwC7uwHz+Tr/oCLuzCLuzCLuz/\nm1048Au7sAu7sB9Tu3DgF3ZhF3ZhP6Z24cAv7MIu7MJ+TO3CgV/YhV3Yhf2Y2oUDv7ALu7AL+zG1\nH4kDF0L8XSHEx0KIz4QQ/82P4hwXdmEXdmF/2U38eevAhRAK+AT428Bj4I+AfxxC+OjP9UQXdmEX\ndmF/ye1HgcB/GrgTQrgXQmiB/wX4hz+C81zYhV3Yhf2lth+FA78KPFz596P02YVd2IVd2IX9OdqP\nwoFf1OZf2IVd2IX9/2D6R3DMx8D1lX9fJ6LwhQkhLpz8hV3YhV3Yn9FCCOJln/8oHPg3gbeFEDeB\nJ8B/AvzjF7/0P/7z/w4kKGOYVxWPnz6lalqUUmRZRq/XAwJVXRICVGWNc548L5BSUZYlbduilCTL\nDFJJsqzHZDJhMBiQZRlVVaG0wjpH0zRoYzBaUzY1OIuUEqUUSikIgRACvbygrmuEDwghcM4hlMSH\nAAKcdWidASCEQAhBCCEeA8iUxDsbB1ebRTgipcR7jzEGIQXBe4QQIOJxfvO3fpu//XN/CyHAWoeU\nAiFk/A4gECihQAqsc/jgkVrT1DVGaaSU4AMyQBCSFgEEjJJorZFCEghY2+AJ+BAQUlAUPTJj0EKi\nlUEEiW1a2rYlpDGxwRKT3QEQ8V4IeMAYQ5ZlhAB4DyEg0tg4D8ZkgMBaS2tbEJJ0afGaEbjg00SM\n9xrSuP7rX/lX/PzP/wf4NL5CgPcBKQTee0IISBnHSEqJlHJxzQAhBHwaZ+89Ll3fi9/rnqX3LOYE\ngHceCAghz50HwAe7OEc3DzpbPbYQgtZavPfpmkHK5fV219ddkwua1gWUlCgt8M4hEITgQQR+/Vd/\nmX/wD/4Rzlo8HqHicdrWLY/j47z13i/OoyQEb7HWEgQE4nwQQi5GXhGfRyAQREixtERqhZSKqqrQ\nKkNqRUBircVZiyRer1Rq8eyFWI5Bd5/OOYIU3SCdG3spBIIXfJRwyzH1Hu/FYl0sxj0egF/65f+N\nf//v/YcgQrobn54/+PR38PGWXPDx8AFC8AQXFmPn04oVUiCVjHM63kV87unfSmnEyn0JIWhsG387\nCEK8grh+fCAE4riuzJHVv5dz0H/p83/53/4zvsr+3B14CMEKIf4p8H8ACvjFlylQtgZ9qrZGZZrh\nYIPd3W1aa5nMZhweHzGZnDKdTvF1m5x2dDBaACGQaYVWEh/iQ3bOMZ9Pcd4ymZyxsblJ0S+YTqc4\n59IC8TRtgwiB1rWooFBKIkWaqwHatsF7h5YSKQUBQeMafPBkWYHODEIE2tZijMFaj1KK1sbFIYsM\nkQbf2hYh08MQGiHB+SY6BgEEAWmj8N7hXBPntQg4LxaOQQiBRBG8AC8Wi034wKDo4b0j+IAQ0Tl4\nwCiFUSo6DecI0ifnE1Baxp8Fh/cttra0Pm4Swguc9WilEULig48bg5IordHaoHScNkEIlFYLh+Wt\nwzu3GEvvHZPJmBACWZaTGRPvNQDJiTnn8DYsFrn3HoQApYBACBZCWsDEBRSIjkLKtICDx1mPF9Ev\nxH0xOiLrk2MTEqWWm4d3Pjoplt9FgHUtTVsv5mnn0H33PBIQkmnjXv0jVj5bbLxCgFBIpZAKVn2U\n9wHnIeARPo2hUGnBW0JQeO9QUqClwBgNBNqmRAqB1goXLN5BZjQgcM6S5QXeS7wLacOQiOBASkxR\nRMfrPUIqnA908XAILu3RgiC6Tc4nh2fRWuO9xTUWhEBJickN0oO1Nm6OKl6ztXGDQ0CwadNSauHA\nF5tcemAibZCrjkt6t3g+cdLHDTl4SwdrSBuQEqBV+rYAj4Ag8CoAEoLAuc6hEsFRCHgvQK48O+/T\ntRCBmPcJSMXvaC2jM/Y2HRdkWndGKQIdcAhpicfNyRM3b+/jPTsh0x4WvxvnTLyu5AT4s7DRPwoE\nTgjhV4Bf+WHfqat5XPzWcjI+o+j3kEqxu73BtdcuUdctk8mEtbyPEIKqqTk9PeP09Ix5VaKFx3oH\nIaCSk/NIZrMKk2WMx6c45+j1ekgRyIyirmucc+R5QdbrR+fhHDaA0TohDUm/KDDGpE1hTi9PCDwI\nmqYB4k5praAoCvKsRwiB2WxGAExmsNZSNw1aK6y3mJRtkAJkQk1SaBZpCCHxCLy3rIC5hSk0Xq7s\n0iIiCB/cAm2p5GwCAt94vEwOz3mEAJObNEkjwgoh0PqW2gUkIIWKi1KbOH9EcpXKLJBcVddQ17Te\nLZBHnudorSMaNzmZNmitKasZ6+vraK1p25bZbMZsNsdai1ImRiM6RkBtU59HxbYlBIcUAR883gV+\n4b/8hT+fCfpjbM+A/+J//6VXeg3/4n/4xRSdWpyz4GOEJWyMlDrk2UU9QkTnLaWjbi1KyMV8kSqh\nWA9KRue1iGz9HFKk0M0/2S2XFC0sEavH2jbNn2VUE92gJBCjAohOWIr0My+QLCMo5/3i+l0AHdQy\nevIBH0RyvBF8pZPHtYBcuF2hRIIZpIi3u8+IwoOIhwhBIFNkGUJAipA+D+fXw1fYj8SB/1lM93Ia\na1lfH1GMBiitaBuLrRqaxtHUFVQ1k/mMPC9QWnPt8i6vX72EdZ7JdMqsLHHeUVUVVd1QNg2Xd7Zw\nPjq0LOtTJPRunWWYG5x3GG1QJku/V+GcjQPowAFN6ROVk9Pr5chMkuUZWZZHp9c4yrKibW0KpQKj\nwYjNzY2I3rWhbWpOz87IMkPd1IuJGkIMe633eNviXEAKyes3Xqf1Pu7YLFGKVgofAs47hAWl0wwO\noBBUto3ICI8yktour0kIFVGq0ggBTdOgjKZtWkLaSKy1GK2QSsewLwRa4SA4pNAE0oR1DoFa7jeB\nSF0l5Gxtm6KXSBPFjcKh1HyJrIKg6BUrC8KBjTSFDzYtujTpvefNmzdpmuocPfGX3f7mq74AQMno\n8JSMFKHzHqN0ijSTC4uPG6klUkZKynqfogjwwVPXFcCCnnLSoYVESBmdqs6Wjkyo+GcFtYcQ0vwM\nvPPu+ykKCckBR3BBECnS8RH9AkLKBcjtwJ8UiZp0ljZFbUopBCICjY6Gcy5FSkv6LEY+LkYz6d8y\nRQIxoI4UkweUjr/nkAu0DhCCXGx6HY1FOtYPs1fmwO8+eYgxhpPZGIB+3qPf64MPOOHJkCAVyqgY\nJfmW4BQBhZaCXq7Z2NiL4ZdQWGcjfxWgLEtms1l00GVJOS2pm4Z+r4cMgf6gh84yqvkMGRLP2RFk\nBEajIVJKZrN5QoAwm03ITBZRaBUdVV235HkPYzLmTJjPSwICY7IYpjpHVuRY51FEuqGuLVJpWucZ\n9EcMh+uE4Ni+dCnxiYLx+BSIznRWlQQfEmKJHJ11bdwk2pambcnynKapKWQvLhoJMgict5Tzkl5R\n4EPc+b216DzDOsfpeMysnLE2GrCxvo4UkrppUSncU8QQXCgVJ7+1BBc3N5FQSAz7wsIp13WNx2Nb\nS57rBbVDiNxlR2fpLC14Ik3V8c5KxU3H4bn9wXvIjn+WF04c/mI48IhEPRABh5cStIDkhCBGipo4\nX4WInLD0AhXAW7fIXyilovNzDu/Adw41oe2lvw7I4BM6j+hbIOKaF4Fbt95NGwiL/IpITrKLJhf5\nC+/xwa1QHNG5dseSMjpka1tynS/uqXPeEZDErWKZe2GxmXjv0qYkI33SUYDOEnzKl4kU1bPMpUGk\nomL+SCQ68i8oApfG0PrA6dExg16fZ0+fg/fsbu+ghSZYS24ysl5M3OV5Rt02aGEwKiLpumkSF6px\nwVMUOd47NtbX2FgbYVsLnRMSgiLPOTk5QQhBf7TB1voGdV1zfHJCXVUYkyGEIMszCCB8YDqZoguD\nlpFzdrbFNXWkU+ZzbF1T5AVmbZ35ZIwXku2dXYKX7O8/5emzxxR5zuUrV+gVfUIIjIYj1tZGnI5n\n3L1/D6UUg37ksgf9PqPRGk1T470jM4a6rhkMB5hM0+/1OXh+gA8OqSRa6JjA7fXiZFQK6x1VWaGU\npugXWOcTWgEhNePJjFlV0rQts1lF0zQ0rWPQLwjWoZRGSYkQKiEViVAabz1aRppHa423lrrxiRtN\njl0lTldB6yJ/HZ2vSIliFk65C0uVUmgdHbp3LgbHCWFZbxF+icwv7NWbtTY6pOAJBLxWyyTgIgeQ\nOPSUpAfouANtYlIdAt75yI8jIyWTcoZCCJQx5yiSjj4BFs64c/AS152AmC4UCOEjmkEsnTkCZWRK\nYAZEl7/pqBspSdkXrIsgjOSYSVy3EJKQonyR7k8qlegVv7j3LkHd3Y9WEjSLyEB0mLGb2gmpd5Go\nFyJtlF9tr8yB3/n0c/Jej6ZpGI2GaGWYTuZIeUaRF2xvbiKV5tHh04jahCArMtbX19IRBFpnSBHp\niPm8ZntjyHQ2WyStgvdoo1MWP0TOTQiKLKOta0aDAUWWYZuGwd4eW1tbACglGY/HKWwKTMsZ09mM\nqirJ85zRa1fRxiwSNQfPD5nN5wyKDKE0bTkjzzNu3Xx9wf3Ox2dMz06Yz0tOTMbW1hbWw/7jxwxH\nQzZH1wkSgmupbYvRmsZGNczW2oizyRl1LZicneBsVOM0TYsPgf2DI3wI2BAYra8z7PfIMo1Sirpp\n6BW9pKJRTOclx6cT9g8PUEazNlojhApCSBGQpy6rqMRJ0YQLFhV8jCoSxClETnAp6UjkAH1QOJ94\nqKRSiQnYGBL7NEEDHuscznmkkBidRYVISlB7F86ncMQy0XZhr94GvV6izSwueKyKfHAIAZwn+KiY\n6SKs1YcptMRbnxy7jPMhJbWVMEvKhCUP3CmOrGVBx6wifSEEjXMxlkt5IiEjUBBeEJIT7Rws51Qo\nAeETyAhRESWkQClD0dOEZpWu8bjEU3cRo/OOxrY45zB6kBKeccPxyclDjCw7QYO1FqlkJEpS5L/K\ndbu0iwkRE6M/zF6ZA1dIhr0hNot88sbmkCaMmdYNJ9M5z45P2Nvb43RWRbmglsiy4qysmM/nKKlx\n1rG+sYmzgbZtOT05xvmYuOz1eigZB81kBm8tZdkktNgSZnOkEFRVxXgyoZxOOTk8ZDgc0u/3kUbT\nNA1FUXBpd49ePkZKSVEU2LYlyzKKNJHX+gNm83mkTLKMyXhMWZYcHT1nOFxjb2M9OizvyHZ3qKsm\nKlQQ7O1sopTi9PAAIQW2qdnd3WFjY8jh4RRnG8bHE0yec3B0xO7OLoU2eOcxUnBwcExdNxhjaOuG\nmZxipEDkktYJyrKmamqcg42tLYTSFMMBGz7QtBbrPMMsY20wJFMG6xvyzJDpmPgZDUdM5/EZ4D1o\nhRJqkWdwbZuouigbtM4ilMB6T5ZlWGepk6rDGIOzAmddlG/KSH2Fao6UGiGXUrK4AFNomSRYL7N/\n8d//82UI2m0AISSEt0rJhhh0p7jcJwTp02KRSpEVvXPyRFg6kbZtF6oZ5xxKx/nh031mWbbgSVfl\njR34iNLBSA91XKpPCgedEOzv/M7v8K1v/VFSP3mapo5jaNskmYsJuH6/x/b2Nof7R8zGc9Y3RmSZ\nxnqL1pK832M4HJHlfYaDNabTOe+8c5srl66ijMFah4dF5CSkQBH5ZUlUMTXeEQL81//sn3xpzDsa\nzBiDCh4pAlLFhFznUaIzDyn536HclPeITyY5uiQ7XURYMVoL3oMUeCEj39wl+ZRIScMkySSOXZAd\n6g34kCga1dEbguAjgAgehPILLl2k6FyHqBQSnZQwIe6QEHc8bTpHcDgXqQ5tNJmMsuLWrsgKA4BE\n6xXaJslSo2LLAmIxNyJqX+HYfUhc/V9QBP7h+x9ydHLM2XTK+vomSMWVa9fZ3Nzk4OiQd999l63N\nLT6/d5/T0xOUkjRNlWiVYRqowLxu+cFHH3P50mV2N0bx4FVL3bj00CMi6Phr7+KCM0TZU57n5CZb\nIPWqLGOyL0nwpmdjgoiJmm5RGmMYjUaUZbngu/LMoFRBP89RwdHPDWfHh/RzTV5kDAYDtDYAHB0d\nY4whHw7J+gMGgz4ff/QDTk9P2d7d4uzkGN+U9Hs97t5/zPP9fbwU2BDItaEpK8qyRkrNdFZy/cYN\nRuubTGdzGmvp93rkhaCcl0CgrmusA9t6xpMpk1lJVddIYzBZhhaWclZiqwatIiudZ1mkcYo+rqmR\nQjEaDKiDo5dHXjA4TytlUpV0gWdE0m3bJL1w1N12FIuUEhc8MkR1gfOO1raMRsU5tKVYOtAOxL3M\nPEknvZBjppA7LWgVzqM1GSLvajIdw+OoPVs4yMhj+kjlyCWHmZssOrqiwDuP0Iper7eShAoLx7bq\n/LXWeNdirQfaBTXUXaf3ntms5ezsjO98509iwt1GgNA2c5p6htZRgiqlxLeeMK+AU2zr2NnZIcs1\n1jasrQ3IcsPJ2Rnee3r96AzqynLn00/QUnPlyhWUjKojERxKkGiEtF6EpKs/+KrcsXPd2iLSCmqp\nmJBBghBoIQmSKC1MSTkfwGu/3HCJ3PDqeIkIvUHJ+KejL7oEaYjP2Cu1QPhCgBQFS9mjO3e9wQuC\nAhHi30r7qKNPDpU0R6Ni1tPaWPegM4N0umNhFjpupQza6LQJB5yz8f5cVG8ptZTWQqRdOlpJpJ+v\n5guilNDSSQm7Db0b6x9mr8yB52uGa+uvMRiPuX37fWZljZCas8mETz+9w/HxGbu7V3htVHBj63WE\nkpRlGUOQEDg9GdO2nt6lEU8fPCUXOW+9dQ3nXJQLtu3CsTjnKMuSpo0EwLycIZVBSsW8dAunEXWe\nesHndUU+qlNVJL2ysC3j8oSqrGjaltwUaGMSdmjRIvKEm9uXMVqjhEF6RTWes762xs5oA3ygVwzY\n3NpBKcHh/Ud88N5t9nZ3+dbBH3B9uE05n5NNW/6nf/mL/Of/2X+KkwF7fBg3FRfY3d5lfPiMWimG\nTctWXvDg0RNGW2uY3FNPauqTMU4anMkpdq6yXowoJxWzgxN2Nrc4fnbAdKjRGz0aHNQtb127gZUZ\nR1j2fcVJecLlfp9NAkJntLMZfa1Y21gj7KxRe4u0UM8atNlkLuD7D5+wtTlgOByQ9TOkc9hgKfKC\nfq9AS4UXEldF/fhMSlS9j6DByhE63yMPlrp8DIVgrrKXzqOzcozOM1SWx+KaRLeYEGVcFYbgohxR\np8KMuPmQCjEkVduglaGVc+Y256CcMWmeo71jgx7X1nK2eoKq1JjBLmM3w9t+oltj0ZXSIGTAtk3k\n/YVGCo2UmqyfETXWUVWkRRSYTafTJEuF3/jNX+fk7BhhMryQ1LMKJbLoNFx0HlJFeaYIgWpc0gbL\ntJ6T5wbfVPSnBWvDPpmSzM9OOTs+wfR6HB6f8uYbb/Hk6X0uX96Nkj5hoqZfKRAktVMbkSWK3C2L\nyF40pR1Rn58KVNpOvx1ARSmq8zHqEnKZmFQibrR+Qb3FQi/n3KK4RkqJSnJeb9t0RkG3mwgRC5xk\nUBCWunEd2vS1KGrwgmWkk5LsHQoILkqPg1oWy3WFVK0jbRxRcCV0qpWwywSmQ56LsjoAEUSz4MOB\nJfUTQ4V4buJGpdItLcFFvLyoZlnWH4g/pdvJK3PgIQTKek7bNjjnePTwAddfv5miYM/dzz/nyuVL\nQCArctq2ZTgcRpQlwFrPb/7G/8X2zi5v3LzBX/vpv4Znshi04GKY3raRn2rbNhZvpIfqfJcACYvv\ndCiqU1TYVJxDXaG1QiuNbT3Wxp9rndHPDMbE0FglIb+1LUFCVZaIfh8tDCfjUwgBe5qKinzgtJpz\n/+ljtjY32XvtCvcfP2KwNsARuHP/Ljevv05lG/6rX/invPHmm3z6xWfcuXOXrc0Ntre2OTw+ovWe\nh08fUQyHTGcl9x/c5+xswNpAcXx8Sp71yfojHJ7gG8pywsnxISZTVE3FpUuX2NldR2WSh48ecvPm\nLc5OxvgskAvB7PkYdzxm1q/ZuzagtS1SQFO33H/wEDkoQGmE9eigcG7KSV3j24b21OMciKKHlnEO\n69CijUarVC3YOgwCqpqhyXCtY94KoiTB0reKsirp914+VdfyXkRBdYNUMe+hgkATkD7gjcTLSGOA\nS4hRxQQXAScceWEQQvL8aJ/D00CJwCpHY2sMniprGF3aZhgGHE2iJFSmCj4XHPiAt+BSdW8IAbyL\ncjbvcGXUBUsgWIeFRSFOlg34/d/8PR49esRwNEzzx+Fcu0i+x5A+RqBtE+L9SYnKNLnJMFLRW9sk\nuAYlVdRZS03b1jRlTT8veP50n3424ODwkM3NHYoiYz6fL5C29x6pQix2QhK8RuuX869aL59FzC+t\nRhUxYuqS0qsUQIysRKwziJ8QEEgVKYwFTRZlG+BWabMU6eCjPnHl/IsjifOfd8hehoATKYkOiXfv\nzras7IS4kaku8Zn4N8cKnUfnmBO9lqSJkkgbIsK5y15F2SGwGCPxgl9eOnKJUmLhl/40Ce2r04Fr\njfeBTz/5lHv37mFt5Py++c1v45yjKPr88Tf/iL/x03+Foig4OztjfWMt8Yoe71uePH3Iw4cP+Kmf\n+mmePnvE3XsfcevWLW7cuEFTVTEMbdtFSJO2vxiWiGUW23u3CIdsSkh4l7LsIeCaesFPNU2D0/Fh\nWGvRSkBo8FYggkIXGW0QIBSOgM4zRKY5PT5kPpvT6/Xo9/vkJmPeVBwcHXJ0doIAdq/scTQ549nx\nIVJIBqdHHE/HaCG59+ghJ+MzFILpbE7bWuazko2NTUyW88ff+Q7v3v4apiiYzGfUTcv7793GOc/O\n3hWOz8Zg59y98xEqK3j79m0ePnhEVc3wZYE9KVlvYD0Ydl6/yayx5KYg1C31aAsXLOW0xEvHfDKn\nn/XJih4y7+GVomlLCqHRGnLXsjnsoWqLth5pU9sCEZKcymFlmyagQCrNqMgplEMNBpzUBUFvEWYT\n2pmimlaMtkYvnUdhXpMZg8VFXXEImCwnF5rgPVa0CBELpK2z1M6TZSYhv0BVRxlmXbccHj0hqB28\nLahrj5EalUlcmCNUH6MKmsOKbG2IDAK0wLuQ5o8leIeWMWkWK4RjZWPwEucDtkMNsEB9VVXx/e99\nj15RUM1Lsizxyol+cN5hnSUr8nTHIlX6euqqZmdvl2o2Yzyfs7E2xLWO3cs77GrDoyfPcD7w4PFT\nfvbf/nd49/bX6Q+GqaBtqYs2iQ4QPiYKbWsRwrxktKNVVbVw/Eu6RSTkvESfy++sOCHnU4VoPLdS\nUX8NpLzFkjLJ9ZejLvclaV38by+WNMyCRksLXABGSISOGvPue6uJw+BlovnOO0yJwKWS/oUWPD2H\n7j6740mZLWscVq5jWQcRFlXaQi3bcKyaD+LctXXH+Cp7ZQ6863fycz/3N7HWMZvPqMqav/Lh15iX\nc0CgVAxvH915zJMnT3jvvfdo25Yv7tzhD//wj/j6++/y8cef8t47b3Hz5jWq5pjZfMK9+1/Qy3L2\n9vYwpkMRUZkSd9IsDhQd97kMbWRSnoTkvBECHVp8Sl5BzOV134mI3C4eWOUdbu5wDvJBjswUTjj6\n60PyYY979+5yJb+CKjRVWzPaXKeal4TgOZuNMVKh8oy93V3Qmv76CKUUa6M1nh8dMlpfp5cXjCdj\ntnZ3aVuLtxaVZ+xeuUTQirt3P2Nja4fPvvicwhgePXqIA9752tfZXOvx5rvv84ff/DaZ6UcHv7nO\n2f4Br1+6jBEaF2C0sUk7rVFeMOhvMK7HPD854ObNy5i1LZwNeG2YBoe1AaVzJALpPdujEf1BjlY5\ngoB3Fmdr2oRQREqQKSmRRiNE4NnsiFy1VB7GYRMz8PjWRUnpYJNsZ++l86joGVI1NJnWSCHo5QW5\n0gTrmFSTyDtqtQBu1jXMqxlCKqwLCC2oXcWsPMP5jJAZYgweUD3F6fiYzZ03ODoqKQY9pmVJL1NI\nIXBJ76+1QatY7YuIfTRU0q+HxKMLrSP69J6mboDYm2Y6HYMQ+GCRQaCANlha5whCkBUGKUlONzpe\nJwR53uPu3fu8/eZNgitQSjKbzchMwfbODltbe9y994BBf42333qXn/iJn0RJzXe/+12GQ4OUsYLS\nOrC2WaLxlCf6KvPWLtbOkraAtl3sTwuKIeZGujL1QNHp/ZNOOrILSz48/XI8zkv6N8Vq+aXji0g6\nJiy7dd6h447iCF1UHjzCxRYCoTsHUf8tCCgpojpm5RghxCS97IqXVGrJEJb69uDj2rd0uZeYMI1P\ncjke5xQ1K45/1YkLqRdOu5Pa/jB7dSoUrfHOMRwMcM7R7xXkeY5rXdR81zVKa1rvuHr1KltbWwyH\nQ3ywFNl7vPXWG2xsbPL+7ds4WzE+O2Jvb4/9/X3m8znDXp+qqhLVEW9TJnmhEF11YvdQVKJuOq00\nKKmXIn2XUE/y9D4lO2JSNGlZE8r3siuJj4tNSon1kYO31pLlMaHpgc2dbcZnZ9jhgE8//ZQiz2lD\nw6XXLuFay6wu2bm0x+NHjymrijfefAul4nTPewUB2NrdpWpbTudzPrv7BTt7e/RGI3YuX0UKxddv\nv8vZyQnPjw54/vQhxwcH7F25Qts0tE3AhcAXTx8hyzlrTYmqZoy213h+esz0ZMrl0SZaSz782jfg\nY8NaL5CLjLYRhKJHU5Zk2mBcoHAOX5WgQGeGoPIYxViB0xCCo2lqgoghaOMtobVxs8x7VN7hB2vc\neTalmR9SeEvRNgx7BcG9nAu0KpY+ewFIhZdgdSAIh8dhjFoUZbRtG1GW1pg8i/rzEBdlJjQ3b9yi\nths82p8QvMMUhrPJmM0Cpk3LR5/dIe+9jsiLhORCLJpKTU5ig7BODeFoXUMgoGREs0apWBQVYisw\npTS7uzuyo8crAAAgAElEQVT87M/+De7c+ZymqanGY6RMtQjexerAhPAjcPALNU0zmzEYDnm2/zwm\nMQc91tfWuHrtGscnpxyfnHH92ut8cucOt29/wKXLrzGdTNjY2EhghYWUrWtApZRC6ajeqqv6pWOO\n8AsJHimRuXDoyRkrmdQhzp9zXLOqjHUGWkeViXMgup4/sWpTahXX6ZcceFjozBErraHCl5N9AnBd\nP5YUeccNR5xrRNb9HV8kFvMnofsdEcGHkjIm3b1LDlzERHbnoGXsHSPFisLJ+3PovDukThuY8B7P\nebQdUmS1SPCG87TQy+yVOXCTZXGStw1CQJEbBLE3B0GiJQTfYvI8FpBohfOWTCmGwyGbm5vYpuWd\nd95iPp9jjAEzYmNjI950QitZltE0CV2ElRArLMMbt5Kw6egW75ca09isRi4Qh9KSTEmsDWgjFlxl\nCAGbuPdoAusdxitG/T6tc2ysr6O0SqhNR822ybh5/Tp5nnN8dETbxIZXbdPSNA11VZNlObfefIv9\n/X0+v/MZV69do6oqTK9AGM3mziaXr73GpctX6PV7TI6PQGX8m9/9fX7y6++zNlyjcrEAYzqesLW5\nyXTWIJRkZ2+X7z75Nq/dusHW61f43kefMJnXvPPubeoA+8+fMLFTnj19RHZlyLwVZPmI1nkOjo64\nfPU6g6Kg7xwYhcxi2OmauDF6ZXCuiWXKSExmQHYZ/yivPLOeor/O2GU4J6iDwDUO1wJCUD2fvnQe\nlW1FY1tkZpITl9TeRVlca8G5hLTiIlU6i3MlfoKSAtu2qTHTJpOZw7sWIWp8cOQmw8sBT56XzBqJ\n0y3GwNHJDIFEG0NmCqyrmc3nqXVDTGTppMwR3uOtX3DbSkUZpvWOum34xje+QVEUPHnyBL+5jfeO\n2jscscVAlG8kpBeg9Z7GOfIs59qVK4yGfba3t8BZxmenfPfjjxlPpmysb/L8+Ii333mPrCioa0uv\nP0jAIqJKRNRPF5nBdsUpUhBw6Ozlm2bHLRNCqhZ0aQ0sUXDk1bsiGFJiV4CRtM7GjptK4v1yI4ib\nAAgVnb9K7iny2/G/VOKoFwx2OqURL+jDE98c13pY5EGFYFEB2c2L+H+XPhNprkR/oUXsX0RSJvmQ\nIgff9eNc+gmVNlaR1DNpkFIydakLDyE68i7qX+reI82n5FKO+qfZK3PgPrjUWXQpl1FKoLWgaerF\ng2pSJlrpOGht2tXauiHgmM2nUVsbWly7bAsp09+dEiUWlCx3Nr6isu8cL5YG1yLAdZ3a6Gi32LNB\nLDupxXqv+F0pZayQ1FF+5kPAGEVIDaU8Ub412N1baKqFEAx7/QVPX1c1UkquXL5MAIbDEcO1ERtb\nG4xGIx48fIjWGus9W0IwnpyhMgNESuPk9Akm63H33kO2tre58cZb7F67yXc+/gyC5Cc+/DqZyTk8\n3ifvFxzNxjx4+IC+lDgP+48fUfmWYBsefv4Rm0XOd55+yiAb8td/5t/le3fu0grBwfN9Lt16h2ef\nfcbRs0dcunqJeTNng3W2t7co8oKsP6AsZ/Q2thitjZA6ltOfHJ8ynk7ZdZpiMOS3/+QT7JmAXGFw\nvHPtBlvbe3xy/+GXHxaQpZUZrCckRCdlTls7XOtQSPqDPhsbG6l5UpxXDx7cZz6bQwgURcH45Iz9\n45raarwrMXnDbHbGzqW3cGXg6X6FKXZiQljOKHp9pIwtBuZtTfAOoaBs5jRNg8nMIok+yDKCc5gs\nQ0pNWVXUbYNzniLvRRlqnscNWRk8JJle7EfTlZF7HykVlMYCo/U1JtMx4+kZeS+jV+Q83n8ae91I\nwWB9jf1nB/zD/+g/ZlbVqMmUzY21CDKI3LDEpcZKDimXKBVsSmh+2VxbEylORVggxhiNLOlHsUja\ndXy7FAKpRezroyQKEztCduqQAF4KCA48uCTci1LOqCLxbZ1o0LgWpRA479HCrHDKIRaPSZk206WC\nJXZmXKUz0loWJGoGFjw8JAosOnmRJLAiBJROrSW7XSdAcA5EbC+w4iaA2JJLSIlWkXprIOnS/VIr\nH0c1nj/RNP5PceKvzIEvvWH6V3A433XpWyYMpOh29vM9lyHE/thLhdG50GP1vjsqo+O3hBCL0tnu\n97r/XqALlg5cKXPuYZxz8mnCL4Ik78Cn1qcr31epiY8QYlFeHDn5yLMrGaVTXVRmrWI4GEY54uZm\nTPRIyc7uDm/zNt473nr7LcqyQiZK4Ps/+Ji816epGh7Xj7j9wfvMTk9iEbFWND6wvrnB9vYWs7Jm\nfHJEYTK28gJfNQzzjCwElHVsbG5QSUGjFW/ceIePfn/CdP85Nq+ZHY15cPdzjJQE23J6+JxHmeaj\n7/4xG4OCjz4+4tH+I/7WX/33GPo2th9VPWrb4kvPrCoZDodsbG/RH62RDwb01YjD41M+/87HNOtX\nMZsZWWjZGwx5/bUbfPtPPnvpLPrwrXfYP3jOtGmY1TW66HN4dEq/GKCF4Xg6Ybixw87eNSaTCUII\nXr/xOru7lzk7OeLOZ58xPjlGCcHl3R1msxZdDAh6TL/3Gn2zi/TblOUpShoyM8Cplmoe56bSkqAC\nrasxucYohWwiH25UhjES6QFU7HWTK+o2Fl4pHamwyWTCr/3GrwMwPZujsgznY2SaSYlsLet5j6as\nyIZD5iJg1kbs7z9lrdcnBM+9L75ga2czOjkBvUE/VkkGywdf+4DnByfUVnB8fEwIsd1rwDIajXDO\nUrctKjU0szaCKx/al465SAlWUtK2dU0M9zGpI6ZO8l2Pd6CXLQQJWiJcp71PG5Xoeot0Fbix6Mf6\nWOyS5xm2cRFBJ4faUTZeRKo8UkxLOXDnABaR88JRn/cjMq27iICXvb+7X1mAtOSPFpHQgldPLYFT\nncMi0lhZ+6vJSiFigZwSEhFiS+PYFjuC2NyoBaj1K4nQr7JX5sAXzlaQerAvG8Ikr50QbZcBJuLb\nlWxzLJvtnKlfhFmrm0M3eCF0qYpo4YWfdxZecOzxM784rxQihngsd9jV70vBgrvrGMF4RWFxrI46\ndGnnXY5JbMAjU99qH2Jv4rKtKYpiEWKFELu69XWP4WhIVVcEoXj33bc5ODhkd2uTQksypTl4WsTE\n3qBHf2ONwWjEz+zuIELcNJpZxeeffM6l9Q3eu3GTDInuj8iyHqflHNUzuLMT2ukZvVwxvHKF+qzk\n4NlTtl+7zs5wiBUSb2uuXb3MoFdweHbET735M7RGc9jOyYVmUjYEPIUUtE3DZOY4shVN06KMYavn\nqYPHisCsOmM95BSZ4M7H3+b4bErd8Zkv2FZ/xN67u8zblqPplO99cgfXgMgzil6fvlDorM9kVlE1\nkc8cn014/PAe77z5BpPNI9xsSr/I8AZCWTPqD9HFCCEM5WzG8fER9+59hrOaYjAi67XUTaygG40K\n1jf6zOanEBoybRgMhmysbzHoDzg7qynnNf3+IPaa7vq+CIHSmoePH/Frv/prkRppGoZrI1rbooIB\nZ1Ftw4bJuX3tdfIs47OH9xlPx9S+InhBdXyCyTTTU8nRwTOUVgwGQ5xreXD/PkXe4/jwKNY9eCjr\nhsY2sUVyazk5fR6LaUyO8gapNL1ejs7UVzoPncrOIVGOwiwSrBG2RDVXpA+69rDpfR9WLjTVXbVs\nlz+K3HZEntEh6kRpplZTISBCTBJ2rWONMXR97mMUkNrIChYqm5D+F3NfAtd22B6Esx38Xq7lFFVD\nlCt3/Hxc5ilxK0W6fhkbdPlYZbr03V0PpsAqsIy0UvyZ87HzoDYGmX4W2YJUUOVZjNFX2avjwFfU\nITFwSLxP+iSkhJBIbUY7iqJzpH4xMN3D7RoepaonVjjslFDpjhtP+3KNa4fWz6F9HwAXNwsRJ2/H\nX0GcOotdXJDCQnHOsasXduXu87CySHwIy4SY9zgcVRsVLvV0itIqopngkU4steapt3GR56yNhhwe\nHrK3t8Vbb77J8eExTdPG5lXOIozi+pVLkRJyDiU1vbU1RptDfuKD92nahvXNTU7OxlxFcHp0yJOH\nd8l6mp/88CcJWvHozj2asub61T2O65qty5d4eO8+WRZfkLGxs8XutdeYTZvoeAOcjmcIApnJCN6T\nW0ebXraR5znjecnx4SkuD9z+2puYfs7R5x/x5rWbnB49x9mXh5JP9vdZ29yAPOdPvv8D7j55Tq+/\nztyOmU73eXLwiDfffCNKN3VsSlZNJ+xtbdDWJbdu3sC4ig9uv8f/+sv/Mz29xU5vC5FJ7t97ytbm\ndU5tRT0/Rul15qeSRw+e4aRib28TYxycTTk720crT12V2NbzjQ//LX7+7/wdjCrYf3bM84NDqqpi\nWlZMZnMyk1HWNb/zu/83Z9MphFioU9bziOylQPiGvdGIr1+/gRvP2B72Gb79FvLhF9w7PWLYG+Fq\nR6E1vX6BdZadrW3uP3jI1vYuTdWSScPnn33CzbffxyEwmcZ7F7tYajBoEJAXBfPaUtclLjj8vD0X\njZ6zDhAl1NzJAFcrI0MI57TgnT7eB4mMgXPS40uqql42bRKpdwigRUDiadsW3a3/RI0YIxcJ3bCQ\nJXYVoURAmHqPrL6dSEuN8y1dZU3nI0LwSW+/ROsx+lbn1mv379gLXy0cuRAC4bqWyMuGVKzo0Vff\nyhTpqdT4KxV5idBVh35ZXvhV9uq6Ea5MDiGSg/XpEQm52Lk78iJmieXC8abbB2IGeDV7K6VErtz/\natjU8V/xWOeR9up3V5G7EultGR2Nk2ibEJbfwccIwAuZmueEc865u99uI5Hdq8XkUs6IjzxujBQE\nDsiKfOX6Qkym+Fh62zQWrVTqy6AAz9bWJsNBj9xIjo4P0NpQ6ALVy2i8i53YVCA4i1IBhGP3xlWu\nv3YJ0bQEDXMVWLu2i5tV7G2tcXl7xI03r1DZmksbu4jasbm2zvreLnu5QWQZO2tryNYzr0qOZxN6\nm2tc2srjZCUmZL1tEaHbdBTT6YSgDArNzLcM14d88MF7tJmkrk55bXvAds+wPthlQvXSefTk6IDj\npiSYDDHoQ55z0tTMZhNm0zkKwfODQ2bTCaPhkPlkyu76iL/+U9/gyvabHDx9zLf+8A842n/C7OwR\nP/PTX+f0tObJo8c8uveYja/vgZ0jqehlG7S1JtRAHuj1CvCWuqwY9DSvvbbN7vYWRwcnBFdx+Owx\ng/46W1vbrK2ts3flCk/3n/P9H/yAz764y6effsazZ89ikt2LBZrUStDLFNs761wdriHahus72+w/\n22fz2mVy4RnkCuEchdKs9fpkRazazKRiczRicnpCrzeknM/417/8r/gnv/A2rRO01ZyiyGirKVVb\nQ4i9g6xtIUlnm6biPIN73jrZbORtBTqPc9Rau6ipiJFsdFrWWYyJb3jCpQAbQXAO51uUFGQyj1Gp\ns8nBKbSWsa2FEOktVulVZYsXKZAURpast+xFY60lyKUj7d6wg4hFUfEVgKmfCrGMvqM0RUfn+Bix\n+0TnLDTdziY0nl6d6Fg4bZVecPJiVN/l4GAJ3rrEaIw2liAwfscvKZwVmvll9uoqMe0KCsVFgn/h\n5EDrDgXnEU2voOJVmmMpw1ki6iizOo94l+MZHXDXnvRFmc6ybWkXkpHeJ5mmdHLALnTtJ88je7n6\nAMXyc5Wa0XdNedxKBrt7RlIo8OnhdlSR+zJ10FFOWmdxJ3fLlq7ethR5HsdQ6AVakEAuBMEG6km5\nGCcpHaI9Y97p3ps41r5pY5N7JRns7TG6fBkIaKXZvf4mTV0vxgMBDBKH1wzYZCc2+krIp0NAq7Kz\nLqIKSQVgvUNKza3XZ8zrGu+gnFdMZ1N6esbbbvzSeXQ6ndL3HgFsZRnDq7vMyjnrt64gtUZUmiAF\nj588xkvBsZG8du0aAPPa8+DJETOb8/mDUxq7gVNDWjHm6LTBhpxnz59zcloBmwSZM7MTGgJCl1hf\nIssAdcPkbMJuu8PRwwmnp3NcKDm9Pqd3dZvJLPD5/Sf87MY7bO1twb1DwvCQO/v3cb1AW7X01RDV\nFjgjsKFkIBSvD3pczhWybjmZHpHtrtEOc4Z727jPjyj6fbQ3XN7c4LWNNQgtR+MTNl/b4rtf3OOs\nHBNkTnNwyLd/8Mf85F/9kIP9J8xnh+S5xnpwOqNRUE3OGPUKMgO1rWi1gJdT4JxwRiYNoo09vp2K\nKq+6buj3BrR1g3eBqipRSpH3eoQQ3xnptEc6iUajpEovFgl4Uac+4SCcBOtoElevtY5No3KDVAYb\nYpVi01iUVvRHA5pmjAoRDGQii31YlKPyc7wEFTR15dFk2NBELj14Ek+BlqnRFQKZErAqCIzOQCqc\nj+/NRaQKYtcifIr808bS9ERKdsbXtzkbKRXfRCQvlYxpshAorIgOXASkl8TujfGNPbFFQESJS0Xb\ny+2VOfDudVywdMiLHVOslMF2jnslTHsx+bj6ey9+p/veqr2sAupFO/c7YrkPrpbnnk+GnA83X3bO\nl5070j3nv7usYhMru/KXNaHLkPX8n3iM5QbZ9Xd5EQWsnu+FAy90tS41mF81rfWicVP31pLu8+56\nM2NwUn7pXN1xX9yAjffxNWvasBFSPwsfqJuWLM8Wb2950W7durXoT93RVq2zVFXFrJzTTj3XXr/O\n5vZtfAgcHB+ysbmJkor7D77g9OyYjc0Rg/4AFzTPDg6o5g3G5FFpIGKFsDEmvndRRFy2ZkbIWjIY\n9jg5LQHDvQePqcsZ/bxPb9Dj6OAJ2ztrfHLvAb/0q7+F2VznvQ8+5Pn+Kd/8/T9helQzP5iy1R/R\njkuKbFnEMez12BqtkQMSyfPDp5SnY66MhnhrWR+OmM0r+v2cXq7RCowwrPf7HM6mfO32u3z+eJ/D\nsxnV/JTf+zf/J0eHj7m0sx0dos6wTYUU8Rn3exmEQN3YWLEY/EK19aKpEFUV1jmUzvA+vh9WKUHT\nVgQ8Usc+/iHE8ZOpSMbZNhYOOYUUCilBOAiptYFIL2yRCJDxrU9CRiRuXRv70jsX32sp4ztby6rF\n2opMxBeZRGoyYEOLw0YgJQRFlpOpHGfb9NaexHUr0N18dLFFAsQo3/rlO3ch5uE6cLaa4AwhvifX\n+6UcMb6HVcd2Cy52I+zWdPdCdiliS9qOQRCie9l0pF/+wiYxu+KaTs7TOYPu310YtpAArlAQLzqz\n1cqllylKVh1i97MXz79Ayp3Q/ksIf2kvbhQ/7FrOtRVdpVHEea3ni5nr1e8t6ZwvX0f32WpWfLWR\n/OoxV0t7VzeUJVd5/ryrY/Pi9a32i3nZWHQdHV8csxc3m8WGk8LqRes3YpFU18GwyIe8zLZ3tuK7\nOLWhaVta20a5l4/ISrZR5VA1dey82IPxeMK8bVEI1tZ7BF8xn51x+eo2bes4HZ9xcnbM4eFzqmqG\nyTRGBhSevZ0Ntrc24iL3gXZmqWYN9XzOoJdjPfTXBxTDgv3Jc57+wTO+OJgyqU7oD/t881t/zG//\n1v+DYZ1bN79OqDyTo+esDXuUszO0MmRGs9kfUJiMUNe0rWMwWqMwGf28YGu4zng8RfUEl7ZHrA0K\nFAEtoJ9lrPmCk5MT3rp6hQ+/tsXaxg5ZnrO+tUmvN2AyneN9rDjWzoFvaUuLRaOzPliPlssCpBdN\nO49QsUjKuhYlBGU5RwiJMbEniLXtIjqLFabLDodCgnct3ll0ov4WdRk4nND4oAmuTYm+aEblNE21\nyBXZpo495rXGZJpgPU1TIYVGKUEbapyM7+0MriGTjtY3IHzqLgo69c33IUZxCBAq9ZpBUbuIortK\nWOfjS2Kk1CnZGfNwIQRMEAgZOxLGVhwB6Vx8eXLi6YWMbyVSRifk3vm6lHuT3WaxbNfxw+yVNrNa\nILiVxd39rLOXo0u/cIhf9fMQwuL1RKuOpHM0qxHAi074q5Dvi05xdWPoHODLHNWL537RWb547Jc5\n39XrWT3+i/0WVhOwf5YoY5mQeVGmef5azucsxLlS69VNZPW6VqvjVq9ldSNb/Lx7ozgSraKW3WSK\nXBpsa78ylFxfX4+hZ+vQRpHlJiajSDJOZVE69jQRUnJ5sMelS7sopbBNSzUvqcuSqqxAB4zKGAxG\nTKdzdna2WN8YMpmMmc3n7Gxv8Natt5lOS+4/fYhtPPVkzru3brExWuNb3/wWbdOii3Vufe0D8rUe\nTw+ecfXNTa6+cYvf/b3f5e69Q2Zzx+HRCRsbBeu71wlG8nz/AaPNAnc2Y2+4Td9k2KZFAZbA2++9\ny6Pnh5RlRTmZUQhF3i/YHOYYLMKBkTlG5zjjaV1Ae8fZs6f8o7//97jzxRdRpz6b0zaAUhA0wrdo\naynyjMYZghrg2hrl3Fe+DSYHqrrFK09W9Ajtsv1yXcdmX+mdw7ExlIgFbd7G3uGxWVZsL+CdjQ4u\nvSokvZsHgUWSeo8nBUhZzZaFRiHmvbSSaOWZzUu0NEgREW9dW7xwmDxGAv8vc+8dY1uS3/d9qk66\nsXN4r1+eeTM7aWdmd2Y2cZdLchMpkivLf8iQLFsCJMiGAmQZBiQYsAzLVrAJC0q2JVAQTEqyTZES\nSTGI3KWWK23eHc5OTi/NvNTdr+PN94Sq8h91zu26p8/tNxQlDOuh3733hMr1rd/vV7+glMKoBJUl\nhLUIjbb2F2kGGYBB5uIQIcQkZKAW1lI3CAKrwaIKM/scPyaHbZpQ+vncNyhpuQFyat06qMrXOhop\nrDFfmiWT8wL33MESVt7sg+Q8ve8UeFlUANOL3aWIy9R68awLYuU8XYBy77lg424ixfWy/maRl/vb\nfa+oSxUlDRAVPrSdv/eSJpouDki67Zi1uRR1rMqvDLhlrRt3YyjyKe67YF/uH3cTgWpuZla7Umty\naRVHlZqwqkYdBZit7h+VT3aJlxtNqXyRa0zuZlajhWXrdV4/YwwEHvPzbYKlRQaDATIKSJOUpaVV\nHrr8EOPxiMC3KpLD8RApPGpRk/3DLucvL9PtDRh2xoSizs13NnnsmY/QHyZ0hgO+9PWXiFo1tCdY\nXV9ke/sGvU5GGC4hhM/C3AL97j4CQT1ocuHcRe7t3OH08jKLjRbSwHA8QgQ+MgrYOewgo5BRkjDs\nj6iHEWEE840avjYEwkNqK7Ndqoc0Gi2GWcrTT36QbNhjrhbiRw26211u3N4hyTSXzq5x/uIpxoN9\nPD/k+u199kYJUinWWwLq9co+97SX+4IXDAcD5vLgFp7v4QcBqcpIktQGzXbOoqQorKEBT05ENMqk\nVrlAMPkTwnp1NUqTaWU3Agm+J8nSjEzFOeUsGSVj/FqIURqlY6uvH3mkSk08RHo55RsG0lp7A0Us\n1+JMxioQ5Fynto6ntBSWWzE28LnK8s/c4tqKjiyWWZVDmVun5mbzucqlkMV6sYeUfuAjPZEfdR3F\n1kyyFG0EWue6+veBiffRkGea7S4inRTAWDSoLAM6CbjKIFb126UoTwKWcj1dYHevuRSxC/KzgHXW\nRlUur+q3C45FqnL4XgBelcil3F9VXELVGUKZEi+3w90AyxzSrLKnvhf3zYSbRgpJMs6sPvAMfVhr\ntesjDCR55JrCylb6HlrZPgvDiDAKSdJ0ImNsNpqkcYwnJPPz82jfim2SYUyj0WDRzJNmQ4Y9Ta0+\nh1YQhnWajSZRI8EISUpASoMHn9Ps91J++h/9LIPBGJMakpuHoDVv8Dae7zEeZsy3enQPBzz3zHOY\npk+WjpHMcXBwD3/OMB8KaqFPphTDLEEpz4oI5JhUa4bjlJWVFcbxEE9mmCQFYZ1vaW0IfJ8wCJir\nh6hQ8NQHHqOXjlhemCdWPkr1WD91DhlEnNtYYXWtTtzzubO5zb3dAwamTSgkq5fOEi3OV/Z5vdZG\nhxla2MAfF1dW6fV6HHY7pFmKMdbthecHuaaINcjxAj/3xy4xntVKEcIQCg+RU+BKCIzwQUpUFk8i\nHSldmLIbvMCbWIlalUKfJLcDMUKTqRidaetAzAOjPetpUWUEfq4Z5XloxORQ0crqM2spYo78JmXG\nBiKeKATkBjuF/D1RKULnYsQ4m0SwB1BaToJ6CymPDHQUIGQO6po0zaw4x/etuMY78q8jZsz7Ir2v\nAF4ANdjKl0UdVfLXsiihuOZSgO79KtCYJYeFI6p0VnLfKT9bdl7jchZuRGs3ryoqeZYoo+q6u8Ed\nOxytEMVUlXM/oL9f3SYULUyNpzsW5XE5VoeJ+4gjlU2Mdf3KCcpUYZTLabUpMpgYTWmdIZQ3MZhI\n0xEFV2uMIR1n1kxb5CbZwlL+9UYdMEitCaMmSwvtnCLSebRwCSpGGTBBjau3tvjy17/H61ffYTjO\naNaa9Pr7eJkmFB7+uIHvSdpCM9rfo+37PP/NL7O8sor0PZZWl+mnmrmVswy2b+DphGbkUw8DlCcY\npskkRFdmFCbTRLWIUPhII4jCiMD41L06GMny3CKthQUWz6xyuNch9jTG8+in8Pa16/SykDhT3L3Z\noP3pZ2gGAa+//jZbuyNMXZAMR1yNFHOnTlX2uR/W2d28w5s3b6KBO60Wa2trrK6vYYRgd/+A69eu\nMjc3ZzfC+QXSJCFJNY1aSJLmaq/SQwqNVBqMYhzHiCBEiYyo3iBTY+IkzilRTRRad61RFBFEvj2o\nzFLCwEdmGUIYG2UqCKwriixD+D5GGdaWlphvtOju75MNB3ieIM61WKzfFEPgeda0PTvyZyS0ttal\nwvq3GWUjgtyWwYZ1s5F8pJR4UTDRlrPYpUBCpjS1oJb7ZLJy7nE8yOerQeXReIhzJS1hA4r/vj7E\nLAPXLGq0LC91Qdq9Xz6orKLSXfApDgfcDaE4NK1KJ8mHZ9Xfpdwn5vyOSKeIFlTV5irKtQpwy/Wt\n2rjKbS7fq+JyZo2HW5+ymMl9ZlaqclUABWDbbwaDcOSvJ+YnCg2bnP02JtcwsJ9FNCW3TFe90xhj\nQ74JQTK2Pj4KWagUYExGpzuiVqsRBBHI0Drxb59FK8Nvfem3+M53XmD/oENy0EPFCVsjq2s9Tsas\nXt4QZZoAACAASURBVLzAeuM8t955l3HaJWxH9OIOC2fm6Aw7nD37AJ3RmNbyGqPRGB0EGM+QYPCM\nsQezqcJDYMMh5P5LjI23KIwkTlLqzQZgf6+srFFvNzEK0lQz0GNSAWF7gWef+TAimmcYJ8w17eaY\nacMwTqxIw2gevHSeRx97gJfferu6032fO7c3Cf0aRhj6vREPP7zM4UGPN956k/3DLqdPn+bM6fMc\n7B3w+itvMRqOqEUh+/v3CGoNPvmZz3Dl2nX2drdpBQEXz21wam2NQTzm9s4Oc4uChXadTqdDo9Fk\nPBxRy0MpCiHYP7ReGz3PQwa+lWVjfawMhj2yTONHNYaDEfEopVVrcv70BhfOnuHfffc7gKFWsyqC\nCMGgP8LzfYxnDQgLjs/LtbyyLENpRRQEqDTJ1RvDIyOhICATVoNF5NS79KxWlhdacZ7xQOnMBiX3\nfEf8eyQG9sMg9wJpTwTS9PfpIeYs8Ub5kK58H0pGMbPYco6OBKoAZpa/41lU66y6lMFh+rBvcmfq\n+rR2xnT5BXVYBY7l32555U2rCoCDoBju44BYls2/F/FOUZ8qEQy4OvVMZHkup3SUl0FrMflePsw5\nKSmVW7GRq4QJJvJGIQBdsYEXbZ30hgABkQ0vAUbmsloFwqMeNBHCY5QohFAcHA741veusnnrLq9+\n53dQ+138UcqzZ87RbjcYm5iRzBj7iqAd0Vg8w4effJivffu3eHf7Gs35kMP+PWpejRs3rvPgmQeo\nGUk7atKLmmzde4eNtSWQHlmc4AcB2hh8X1pvhjJAeoYkSWxQDXseiRAQegHX373KqY2zyEadaHmB\nQAc2ilAQknYO6eztI6VkfeEcB7u7jEZ9VtdWyUwXjWZ/+xav0mN5udoH+6/9xq9TazRZXFplc3OT\ntVNrrK2t8a9/4zdI0gxPemzd3cYXITtb9/Cl5OzaBjpTBL5Hdzji+o13GY5HGGM3zqtvvs3lCxf5\n/ksvc3d3lwsPgU7qLC0tEccxtXqbUazY3d2lVqsThhFJlrK0sMhoPGYuatLvH6JUShQGgEIpgxQB\nd+/eZKk9z7e+9R021ldoNuvs7e2DkIzjlCCsobTGCNDKinK0p/GExJOKOE7xPSsa8YMAncu/LV/o\n59GeBNLjKFi1J0FoDIV64dGaDqOALE4mhn7W1ZNVM8wy6+WwUEH0ZoQSLNLvCcCFEO8AXUABqTHm\nI0KIJeDngAvAO8AfNsYcVrx77NNlxavY+PuBq3uwmX85BnLFZ3FqXqVaV87/mGk9s52tz8rHFblM\nH4hWA1T5oHMWVVwlwilfL5JS1cBYtTGeBOAnbWDuofJ0PafrWM7fw6dwzwky1wt2yp3hPXJSZ8NE\n9l3SPM83DzPZHCeiq1IdZCH79PJI5iZnaX2PJFXUWnP8lb/y1zl//kGGco7Xvv8iK1GDh5+6RDAc\nEx92ePLiRZRQXL17k/1Rlywbs9AydO/t8MnHn+Ar+3foHnSYb8+hE4FUkv3NbZ576kPcvHaNs2c2\n6PbvkSljnUsJDx1nyDAgkBJpfALPRjeS0sp8hSfAU8ggQOmEO7fuctDrYOp1fuALX2BpfRUlDcKT\nnNnYwGjNaDRiHI8JF5qk7Tq+73Pm9FniQYzxBETS6nZWpJXVRbrdPp3tbc4uLdNqNdjcvIMQBqVS\nBNaIZ9DrMR4OWV1aYb45T6dzyHg0ZH//AK/VJMPQqNeYi0IWwoCN9TV6h4csLcxz9/Yt/DNnWV5a\n4/y5DQajMYPhkKVlj9t37rKxcQZBQKY9PvjUszywsszuziZb27e4t3uPyPMJG3O89sZVdnYPaTwz\nx6XzZ9nf3QYpSNOUWr2BkBlxHBPWImq1Or1eF50ppAe1Ws1GJ8KqEY7HMXGc2wTkroKjIMAYiOOY\nKAitOWGu3FCc7YRRbaJyG8dx7kvJILzcH4wo/KaQ6757KGVIsxirbTM7/V4pcAP8kDFm37n2l4Ev\nG2P+NyHEX8p//+Wql6vEA/8+qcinbCRSLNSqzWJqIVMtW6+iul0AOwn0q9pT3mDcDauqTe5nOd9Z\n5c4Sa7j3yu10ZfnlzfCkVG5/AeBljZ2qepTrYKPUixzErRy8OGw0wvWvXE6uSGZ68zEGpCicnE1q\nnYux0uN9io1nqHWu52uVghkOR7TmFsi05E//13+Gr3/ju3zz536Fs6dOc35tEa2H6Br80Bc/ixqM\nifD4A5/5ArtbO9x59xbD2yOMjBgOhjz6zOf57pVXePHGNUyjRTeJCaKIX//OV/j4xz/Cwd4WG6fP\nMOrs4wsfP6qTmFHupljTrEXYUG3aBn3A4IWSYTwkiYfUvRpnzq3z2BNPc/PePo12EzxJpjNMkiB1\nRiQMzVaIaoWMjUGGEadOnSKUHpEQHPQ6HKqUVtCo7PGoHnC2sc5CY57xaIzxBP1Bj4uXLrC7t0+/\nP6Req1GrRcy12tap2vY9Op1DtJ+xvLKIEIZGvU42HBA1a8y1W6TjMZfOn2Wr22WxvkC32+ell17h\n7LnzjJOY1dV11k+d4eCwz/dfeoXx2Hri7PbHNJ76IM1mjdXlVa5cu0KcKuptw6uvvg5GcOPGO9T9\nS8TxmEcefhylDf3BgHqtQZykHB526PX6NBp12nNtayykUjyTa5MYw/Lycn7oqanX6mRZRppkJGlK\nrVYjiYd5IHTr1VEUFIC0XhujWt0G3PZ80lADHlpnk/Xn+z6pShHSxtjVWlgu8IT0H0KEUl5ZXwQ+\nnX//GeCrzADwMohCBWWeE6ki/+c8aFkXYa8abSY1OekwbxZVX6b8p4FgGtRdirWKUq5qZ1Ubq35X\nabCcRBGX8yieLR+wniTfr7peJZt3yyr3Q1Wdq0RAbn2mDjn1EXBbIbVHPrxYaJ2RJBijc9/KR/6s\nrRzSGl9Qsla1HuvcOlgKKI56mNTDzyICFeATooWmVgsYp4rX3nqDv/v3/gE7e11+7IlP8eADD1Jv\nN7i1vcnK6VMMV1boyH0+ePEy33z1ZYKDDi2lefhcg+bCHAeDASEBj/hN9DDja4NN1HwIo5hFHfLi\ny68jSXnu0UdJBiOa9QbJ4IBxMkBEIamBmueDslo+Yb1OIH0gINGKtUuX2O92+dQXfoyVU6c5J33w\nfJB5FKDcaZLRhYsD6x1Sa4OuaVSmkAja3gJBHB/5Qy6lTz77LJ7nU49sVKhUZwyHI5RWXDq7ysH+\ngbXSlB5pssR4NKbb7SIjjztbY86un2d5bZUrV68SBj4H3Q5BFPLClbfRjTob83MsLS/nvlU0wvNZ\na6ySKcPm9ibD4ch60ySAGG68cZ27bz3P0tIyly4/SKx9dvY7jDcPQCukMOwf3mOvM8fNd2/w3GMf\nZM747B0MORiNuXrrLsM0ZWF5lblmRquuWF1e5tT6BbxWh/W1DTZvbjHsxqSjlIW5eR5/9DHOnt1A\nGc3vvPAiL734EtIMrc9/37cHnQiMFiwvn2Z+YQ2VSXbudVhcXEFGinE8wvMEO/fu2jOTcR8z6CKN\nwg8kBJAmM/wZ5Ok/BAX+W0IIBfxDY8xPA+vGmO38/jawXvWi57AZxcKu0gCpotKrAAOsU5rKSlZQ\nzS5AVclyy3mXr1VR81X3ivJPirAxi/s4iZo+KRW7+UkbUbmc8veTOICpw0chJs6NZrW/SK7YqQz0\n1rfYbC5sVt29XNyBN123InZkAd6uZaybn33efvoysk6QPIlQGkWK0dbf853NLf7+3/k/GA81Tz3y\nJGfPn6PT7TBKR6gkoV6rcefOXc6dPcfGxYv44zHe3h70etzr76FGI8JGg5V6g0dPf5Afahpe+tIv\n0xnHmMzH9yMCLdBCMooTWu221U3PMlrtJkYKMiEYjUZ4QhD5AWmmiRo+0guI45gHP/AIn3/kUQZJ\nwiBLrQVkHhrQqvIdEUw2YIpXbS2bk0qzNvGlxcUjQsEYIi+k1WxM+vjcmQ3SNJ0ai/F4TBwnjAZW\n3zuMQpr1kMFwyGG3S6vdRGnF9tYWg8GAxaVF1tdXWV8/lfvKTmhEDeLxmMO9HRZaDYL5EE/4jMdj\nPNkgU5Kd7S79bsa77+5Yl7TUGA16bN/ZY6G9SLu1ws7WNttbW7z6yssMtUDUm3jSZ9QfsLq8wtz8\nPI88+iiL7TbBch+hPG4pxRtvvcVCY57OQYeV5WWCMKBWr9FotFhbP80oPaDX61Fvt1mYXyBNrTdR\nFQb00oQ7t7a5ePEhbty4xa3Nm3z4mQ8TD0esnL6IEJqWTgkCASZje/suc+0m3V61D6Ai/V4B/AeM\nMZtCiFXgy0KIN92bxhgjjhx2T6Wf+ac/P5kwTz/5OE8/9XilhZ7rj6EMku5hn6W4quVFZbAQQhyX\nl3Ncvuted8ssf5YBrVxXOFKrKwNY1SHg7ybNovhdrZf7bQKz/K24bSj3tQuAZVHQSd/LG0C5DVX9\nVzUmRSqceJXrWSWecjmTKi5Kj61JuicM0ldAhhaCeq3F3/wbP4WnAj73A58E7TEY9RgN+9y7vsXq\n8grXX36FMxcusv3OO/zCa2+wGIU8uL7Kgw9fYhSc5bDfRWWKpLlAs7XAf/bkH+Kdrdv81ne/zdDT\nDGSCSD2CwFod+r6PUIIoqmHIrOFL7hPE833bbgTjTFGvS8J6g/nFRYTnUavX7AFoZij0iL38gPdo\nc9O5KElN9QUc6UDPSqdc9UJh/Vprra2/klzTqVDlK+Z7FEVW7W4OEII4SZi7/ADCsyHIDFaP//Kl\nc2RphhFYs3hPWu0cbRjFY9L+kPOnV/A9n163y9LiPE8/+QlqtYioVuflV15n++4e48EIgWA4GtJu\nthn2Rmzf3eGhBx9g9fQ6/STm4eGQzAvojWJSBPd29tnZvMO9OzeJ+x12d3e4+Og8C3NL7G13iHzP\nujmYX+R73/su3/jG1zh3/jy1WoPr16+zcHqRuZV1uoMB927eYTgcceHCRcZG0e3tY+pQWwpY1Yv0\nzYCwVUeEHr/4r38dYwyf/sEf5KUXv4/QGdt37zA/P89oNJw5DvB7BHBjzGb+uSOE+EXgI8C2EOKU\nMWZLCHEauFf17p/8E39kJpVXJCGs5db9KLsi3c/stAqQpu9Xq7kV1OysPN4L6LqLpgCxQn+9qo6z\nQLCqTVXXymKbk9Ksfi0Da9k6swyIVeNX1P+kNpQ3yPK1orxZqcpKtni3sPiF4/5iynWLsnmETDBy\nhBYjUpOiTECWJPyPf+V/4Td/+cvUdZ1GELG1/w7bm3do+AHjw13a7UW88RghPR5//BGuvfUWA0/w\nwrvXSBuSRx95mA8+9gSvv/kG17a22Dhs8Mc/9mme/+3fYlyPSMOQ5UabO3fvsDlX46nLF+htD0nT\nxPqvNh7jLMMPIoQXWtEFhjSJ8UyTP/cX/xtGSUqcpUjfByPwPAG5cTp5kBC3b8tzzO0LdQLHOBgN\npw7kC8o7DEPq9foUgeTOGa01yXCM0ookTqzpfZrkB3yWY2jXAmrzLYLcgCdVGXFs9bWNgfF4jCXr\nBDozVgNJDdAqYfPuHd65/grjcZe15UZ+sBig9ZDTp+bpdTZptx5k52CfN6+8xWicsLC8RlSvce7c\nRbbu3ePSgw/Q7/fwPMnh+gKJvodJE+bqdYYMeP673+bDT32I3Z0dBsM+aZby2ONP0m63afktvvSr\nX+bHf+InmN+Yp9FoWI7Jk2z2NpmrhfzOt7/K448/xsUL69y9e50rb1/hYx/9MPV6EykD5heWCMOI\nS5efoNlsIaTk137xX8yc+//eAC6EaACeMaYnhGgCnwf+J+BfAX8c+F/zz1+qer9q53fyBnK5rfSO\nAUlFXez1+4giiu/uNfev/Ows8YGbbzkf9145lU3LXQrFzdvdMI61saJtVanK0vS9bDSz3nFBumw0\nVa7fSX1dfr74K9j18jvF5yx2vjCQmtWGrMKbotsWt14+AUJotCetIyzpo02NwFvgrTdep+63SfY7\n9Lt3Gahdmj7MN0LS4Zhk0GHzzrvIZouX33qNZqvFvf17tGoh436Prdeu885LV/ihH/1hzHgEdzo0\nOn3+2p/48/zpf/y3SPw6wyCi3rCimMXIo+1r5lttRuM+Xi0iHgwxniTLQ3rVGzVqzTrNxUUOej2i\nRhO0si5JsdaPkwhW1kh8qh+MMVNz0u2nKkveItVqtYl8GpgiTNI0nXB/5fGWUuIH1mtiq1UnTa18\nt/Bu6fpesT7vbX5JkGDjjyra9Rqj0YgwDBmPxzQbTXq9Pkl2wMJCwGd+5DmUMvR6ffqDAXt7e4xH\nQ8bjIUG4xMK8j/HhwoMXSZOM4TBmZ2ePr/zmr3HqzBk2b10nM4oHLz9ArVHn0pnLDPsxh1mfS+fP\nceH0OdI0YTDo0et3WF9bs0GIleL221e5uLbBWy++SppkLCwsEgQ++we7LC7PM7/Q4vFLF1mfa+Lp\nDhuXN3jq4fP0e0Pm5hdRGq682mNhoU2vu8edd67/RzXkWQd+MR8kH/hnxpgvCSGeB/65EOJPkqsR\nVr3saozMEl3ANIXkAkQZDIGJE6NyqtIwqTq4K5flLvRZk7kMZMXELXe8C3xlCrkM/JWcyIz+mTXA\n99OqKedfvl+1eVW9X2WQVR4v97yjqh8LIHHB+72KllwAP4kbKbeliqL3PIPxDUZoUiNITYD0Wnzr\nm69iTJ3Ir7NzcJ2st4sXZdQCH5kleCiSdMj50w8zFD5b71zn4x94iLlGg3OnTvGt//eXWX7gQX7n\nV77Ey89/h49+4lmeXNzghddf5dmPfZw/8Nwn+JXrrzJSMa35ObZuvctoHLOxsYpWQ/67v/yXWNs4\nw63NTW68c5MbV65a7ZZ4iFev89Szz7Kwsspht4P0fOtn3RTnSspapEpvEtzX7UtrHThbq6oqFeNV\n9gVUNecnetH5c+NczFKvWdU63/fJkmSyHnyZr2tp322325P3oyjK5fmK4aiPlAskaUq9EaJ0g85h\nD+EJkiSlWauBykgbDR44f44oCvF9nzDySY1Pe34eDGwEIR+4/CBaP0e338WvhcRJzEG3w3y7zvrS\nMmIp4BvvfourV95lZXmNBx54AMQpanXrYrjbOaTVbNCq+ZxaP838/CK9/oj5hSV2d/dY7a3iB/DS\nSy9w5eqbJFmMl6UMByOiKKLWaNLpDmi3F/CCkNv9Q7q9AT/wA58iiiL+7xPGQvxuZa7/IZIQwvyb\nf/1zlROm/NuXwbEFXQbJyYKUxyntgsU7CciqQNt9torSdPOsAq1yqro/i3Kv6pNZm8h7Ea+UOYhy\nfavAzBVLlDfYsrjifptbmav5923Hk8995ti9F7/z5fcknilT9pVtzjyUTIkaPqMsJagt8rWvv8Kt\ndw5Yba9x8/WXObj5JjLrMhfZKDZR6NOPR7RWV1k6d5762in8WhNhBBvLq9x48y2e8Oe49dZbPPHM\nk7zy7lvc2rnF4xcv86GNB/i3X/oKanmBX3vzZV7v7dKeW2T3zibn1xd54sFzPPLQRX7iJ3+cBI2W\nHkJ4hNIn9DziLCZFI6UgU1bf3cvPBIpoUWAFDrmuzbG+vt98/cinfvzYve99/dfv+365HPLyVW4l\nizFWECKEFe0YY1UinLmlyV1JI3LjLPLDUX3kqS+X6wcitC4TjA1CnmUZSZzYDR5jvQFifZ+nvkGl\nmTWhT1Wu621VWIejIQqNF/gMRgOiQBB4EQKfLLE+xOfmWlx68BIIwd7+Ia+++gb9wZjMH9EbDFmY\nW8b3Q4zxaNRb9AZ94nhEe65Js1UnHo+oJ9ZQaP/wgIND60NmMIp599Yt2vPz9Pp9G/ih1uBf/vy/\nxBQ7cim9r6b0Lis+c/c305PEZc2qHDuV1fUKKqD4XWb/q1jHY1WYATguZVFl7FN+fhaF6NbVLa8M\nwO4772XhlDcG13hplhFSOY+qjcot/36+Y8r5Vv12r1XV4aT2FkEkXLl2OZX9xRSO08opE2N8z6PT\nHSFljX/1S7+KJxfwtc87V6+SjQcsr8yzv73HcCCp1QKG45h6q8nKqTWu3XmXp8+fQwnY3tzGz2Bn\ne4ffObzG+soyr777NhsXz3L+8Qf57gvP89yPfJo/+tRf4O/81N/m3MIyvUiyM4g5vXEWnQ1ZXT/N\n53/0x/DCAKEVRtjo5bHKrNMoYTASKzIRxaG8ACTGFUcUAQLyafRezkZmbbRFH5ZFieVUqRqMwIZP\nzN8ReTjB/D+L39YiEmMQvnVSZjcfENp6+xPC+hw3uXMrgyEr4pIJCLQBrJOrwkEUudooYch8q2Y9\nBmqNyTQqsw6rtNHMqzZJlpCpjGbDhibMUo3n1VCZXTf1eo1OZx8NjEdjlpcWaLcVCR3ObpxCyoAs\nM8RxSrtdRxhF7AlUqmnVWjSiJk0RsbOzw/zyBuceeJRhPKLb6xMLq0PuN9vUGnUOO50Tx+l9NaUv\ng1cVK2fUyXLvKZAzx0UVLqXuyuqqNC+EEFM+Ulxqu+rZWSb973VCu4BYXhBVC6iqjJNEQVXAWbSr\n7ELXzV+I42qWbt+dJA6pSuV+q0onyfreKzifBPIFcAthY0+W8wcwniFLFauLp3jhe6/SpEY9avLa\n22/SPzykGRqiRsDS6hpbtw/wpDVxv3DxEvv9Pj6S3e17PPTYU9zbvEe92aA+N8fe3l2GnZi1U6cY\nZgln2mv8qT/zZ9k6PODezl1+/I/9EWS9xn/+F/8stBcJ6zX6vUNeevlV/tyf/a/oDTrWuk9K62ND\nG6QGpMil2sfBtGzV/F5A1+lILGFc3Z/e5GA459D08bzc8o7GyDoOK8LoTew7pKDQVSui3ACYvB6Y\n3O22lPmhtPUKqLH6/wAeaU7IG5RKiurZOeFZ9VVjLzDopta+RkqrneNJpC/wDUivTlNYD4qeZyMy\nWW8N1lNloU+fpAlKZ2idMT/XIEkyUNayMk0V9VaTkRzjGc3iyhKdbpcwrCMy6PdH6IUmYa3FYeeQ\ng94mRsA4HbO0sobneyhjCMKQM2fP8/OzR+r9A/CyRgZMg2+VQyd3IbueDIt3Qz+sBEd/wlYen8Bl\nUKzSQqkSHZSv3w+g3OQCYdl8vYrKdetb/n0/4HPTLNez5ToXh1Bue8oiq/fa1qpnT6LAq66dpEPv\nRhyvyqPgPNw8y5vPpI6eTyto85Xf/G3efOkKpB7Nxj41NcCvQ5qMUGkNKVr4yx6HoyGPXb5MtzdC\npRltWUP3Y9q1OqtLy4xVRm1+jl1S0tGQ3o0eWzdvsXf7HmvrZ3j4scf4yvbXObW8QDOs8yf+6H/B\nP/v1LzEYjohqdYyBr33jGzz+1GM2fiUGI5SN6KI0RguK2Km2/Uf+Z6b7y5B7i6kUoZWTNmYS6Lcq\nTSj6wkCq4uypPJ8n6zZ/L0dXW7s8uLAxZgLIQO6C1YZ2m8xyLfPNxSAxTHx560I92AL/JHsh7AFo\nLkASQuKluVM5bR1UWSoejNY2zicSlWRgQPuaIIhQyuD7AZ5vXf1GQYCUAcKA79VIUwXjhCAIiOOx\nDcgcWde1wvOp+fMoZRiPUhubNuky15DUgjbjOMYLAqS/RK8/oNVuIf2AXq9nQ9OdkN5XAIdpACnL\nVuGIAp8YH1RQjkU+Vb62q+TbJ4HRSaKM4tr9qM9ZQPJenz1JK6csPpolCplFvVfVY1aby3UrU3Un\ntcFNJ4FFkcqHmO67J4lQyi6Iy8nlJsrqhuWxN0LyzvVbfOPffosLq+dZXJjn2tUrDIZdllcW8X3B\naJRQCxuESw1WGmcYZwkizWj4EUmmyfojku6A27duI6OQYTym29lDDwY0wgbJ2DC6vc/WO5v8qb/6\nP/ADn/0st7e3ePu1N3nqiSf50jdf4CAeIMaKC5ce5LDTJQgixunIBtLGUqtSWgMkivmYu8xFgDLK\naacVs0gh8cRxo51Kd8ZgnXrdZ6wmZdxnLciCcjbWWVR+42jcPEdTxs1X6MKDtlUnBtA2HLg5kgih\nhEFQJ1Xa+iIxZop30DJ305A3KcqDfQgp0cJuBJnW1nsgEl8IRBAhEYx0jBTexJeJUhnapGSZDYhs\nMo0UYzAS32uQKQVBgPLACyOUsS6K2/PzqAwWpE+mDDLtHfVb7lRrNI5ZbS3ZOLC1gIVwgayCu3HT\n+xhSrZgILnDnrJs4Csor84HPjEalR5ErJixePoE8KVAimnSKEEfPGG0mhyASMSnHPlcGBlc0Uyzw\nItvC3NvNQzCdhWvVmVMaFO8b5xmbr1LT4ZSK56Q8qkcZcGadA5SBbxZQTWo6AfWjNhZ1seXa7/bT\nrpgqn1KF5d6xJKctXE/aRIwpg7SZzAGqc69s0/HkQx59vKDcLBtsD6QsqEsQkppo843f+HlOz61T\nqzegIdG6S5MBMpbIxhyH45QFQs5/4AOszje58vy3aQcSEw/JhmP6e7tcf/55GuOE5LDLUhTQU4KF\nepuGF9Benyftj0k6e/zDv/HX+S//+/+WZhQx3N5kezxk7fQyi9kid25f5Ymnn+BDz3wQpRUhnvWN\nkbfB9ms+XjnlagrgEkd9bAwYZTDCoES1KuYsTm9W3wpD7oTJjpOpttWrpMCnRjiv+4RYY3quT767\nZVPIxAuPkgaZf5pCpGLyM7bJIgeDdfWqjSHJw6CZ4lhX2EDN+TEnSuflCEGQR9vxAm9SnhBRvl60\nRVAhEEiSNJ3ULkkyyOX5UlqXv8bYjVEIQYB1aeDlIiE/9Jivz2EMNB38uN95xfsK4EodRbkpJqRN\nRws+mwqHZm9pk+98UiLy97SR6Fyv1JVzC2FlbBgLCKoIh+T7CCkmLOd0PYqKFGIKF5Bt/QqOoChv\nUvMZYFnlhe+ozOP9o5wI1naj0xQRr8vGEVXA7P65ZU2PQbFpFuKS6XtHG5fDGXGcW2Ki3zCdXFg/\nyRcM2HBU5aVabJAnpVkbWJH0BLNsmKoi8osXeEjpgZFkmSLwA/75P/05djZ3Obdxkf5wyNUbb7IQ\n+XhKYOIhola3ZuytJhfXTnPtjVfYv3MH7SlCnVhvj9qzDpqCkCzLiPwQLT16nR6Ndpso9HnqfaY5\nhwAAIABJREFUmacQnZSbh/t89Rd+iY9/5rPUDvt4kaAdBXTVmI3T6/zsP/kZ/uAX/x92d+8RBiHG\nWABHGLRFPzuuTFOcx8REJxBxVYZYE1HiLMq6RCi45brj4uZXxV0VFIMoni1xf5N33KKPSsv/t+33\nPWttekx0VGCBMRhpw6RNZm2RvzbH56SwVLp0xE5grVStnN09E7J+vgVHfv7DwJ+0oRDzuesl01iP\nk3lA5DRNjwVBeS/pfT3EdHfbskx7kibAwaQzpJSTgxStFEZpUNo6gKEYWktpSQRSHOVtpDnyG+0M\nWjk8miumKRs7uGqMLkAW16om9awBqaKmy5S0NUY5rrJ3kuy9vBnNEkPMImBn1cUTx9syq22uPPN+\n2ipSklOUVRv6/dNMMYsBKyfWWIcrBrQ9eIvjmDCsk8aK2zffZefOLssbZ+jEIwIN/iBlmPVZXKiT\npSnJYZePPf1JGmtnuf3qK2y9/RreoG8DJwcetTBCa+iNu6ytX2T/3oCl5Tnm1pft3E0y9u5ucXUQ\n86Hzj3CmPkcmAnZef4MlP+IX/79f4HBxgZu9Qx566DzPPvMhxvGIZrNOluViIOFhhPXzIoWcmLzP\nAsnytfJzs9wg3G+8TgoC4oqt3DxniTmLe+7nrFQlGizKLvIvcMK9X5bJV82XKo6huF6OBVuFHVWi\nXbe+03Yg1nK1uB/m0YbKdblfet8AvHywdARUYsrwQ0o5Ae+iY4uYi5POzGVo8cSdY4AU0oY9Mtbx\nvR/4Ez++Nrr0ccu/oi4u6LplwpHVmFKKWq02NegwQ6boDHYVoBbvF06hXHn/0X1dECxTaRaYFi5o\n7rej2z4+vmiqxC9CCDD62CSeOdHMtLl6Oc9yPU6Sdc9K92MxPV9iUTx/TtivRsNcu03nsMf62ml+\n9Vd+g3ZzgfMPPUymDd/45V+jGaeEvsdhr0uzVidMFUn3kGh5hV7vHmnaJ82GJEbTrjVRKiX0ApJB\nj8AYxr0e49GIqF5j9dwFxnc22drZxIwTvnn3gLA1x5n1Z3n2Cz+M7Mf8ws//PKQpKhlz9/ZNfuZn\nf5qde3cJQquVYPlxkQupXY7wONFRNeeqUtlS9b1QgO5arXIHUQWy7r3y/WJtFfkUxlknuTS+X/sK\ng58yWBebS3m+HXG65th8nXAkpTaUN60jMeh0+1w116KtSh1tni7x59brvbh0fh9FKMflupWR5rWZ\nnHpP/UmZE1f5BDLge0cn7VpnE5AOghDIwyLlEaONduXp1QY1Rb2Kz/JEKazYXM2ZKkCdtdsXO7er\n2gd2QqdpOtNKrjzximQlDo6UsLRYqia65VyrZNLHKXgAydHEvR/Yzpr0Ve8pleXPlO/87iiyY28L\n2xcT5ttYPxq+7zMcxMy3F3nx+ZfYv3fAU49/lDGG/YMDlleWkbv7aD0gjRUDNUKNFFfefov6aMDC\nSotxssC+6qK1YqQzWvUmWWIQqSLuDqjJgOFej1pznquvvsGz5y/x7Cc+hsbgjxRhvcnOYo3Xe7uk\n3R6f/kNf5Mr2Fq//5q9Sq2mSeEQQeiRpjMz9nxiTcxCFKFEfH9fy2Ln9dGw8K+b1/UA8CIJK7an3\nOi5VADdr/ZVTua6z6g7VHk+L8socieurqMhXSjml4VRFhEzP62njt+LZMrEohHCiYx3Ve1Z4xJPS\n+wrgLngVyQVEAE/61hzYFLElcx8PUtpDCCFQWAbZN4rCYMkTkjAMc5DOD0tFzkgLkQe6PSrTndhl\n0CtMft0Yli7L406CMshW7ebF90Js5N6btDunBmZN6nIdi02tzMbdj6oVAmYYeU2VVd7Q3HbNUuHL\nHEqnnF91PapA/uRJfD/ZehFzsJxPHKc0621Uanjhey+ysrjKuzvbzM3Pc/udm0ilWF5dRsU+XuKx\ns7eLkD71VkirWSMQ0GrU2YpThFH4Gjwvw3ghB70u7TShtrBMrT3HwoU1/Myws3OI2N7j4cceZiFo\nEo9TzFKbyx94hNFhl91vvsHu1hZpMuYv/Pm/xKB3iBd6SM+zJueKfN7mQJArU5fnSVn8VT5/OYl6\nPYlLKlKWZZP5qYrwYiWAm7UxuHV1530ZPN9rKpfnrt+T1l1503HFokUdq7DJnffl5wvjqTKeTHy9\n5JKD4nohDnbX0f18n5TT+yoDL6uAuR1XPFMEEzWmoJjzs2KlrF6sBOkHJFkGQqK1IgxD0jjFN4U2\nS35YmgN4UbbgOHtXrmPxV7beKzrfrW9VKh90VgGvu/sbYyYe9Kqoh/JCcb3Cufrb7kFwEY8PjruO\ntZzPbHewRTpaYEX+xWIrjimqFp2NpFNok1jNoOMb1jQLOb35ldU9y0mIk9nMsjdjYwwID09CmmY8\n/+0X2Nvd44lHn+Qg8unf2yfrdGgEPj01ZnFuHvqC9bMNhhKaq6fY3dtjPpCcWllhpz7P4PCAXpzg\nBQ38KGDl3DnOPvYBRHuBu4eH+CureMt7DPe67HQ6bH7z25xZWOW5xz9M3WshDxJWo3keO/Mg/+JX\nfonPf+4zPPvMs3T7e4AlFgwCX0iE8dBGgTBWG4RqMC7PNyGOu5QoOJ7ikn2/ANfZQBI4gaLdgzc4\nvsEfH49qcUfVO/ebk+VUpn6rABiOPIO675WtuI2xYqIgCKbyKNaBC9zFBuZi71H/W2Kh6Fsvj61Z\n1M/Nt6ov7tfu9w3Ai4E/abcrnhNKoI1CiNxQQYDWtrFvX7/B5YcfIag3GA8OqUc1PD9A4KGShEat\nThLHVv1KCLyCHVLKHmbClOy9XH75upsKGVvx6VIQ5Y4vJsKsCexSBWXquxhsV/e7mECuu1R3YpX7\ntdgMC8B3KYgy11A1HpPFr6epqOJeVbsKXeJyv7j9c7QxTPv0fq/JzbuqDp7wcidnFqyEsLrURkg8\nJN9//gVMqunsH9K+fIadvR1WGnUykzHSmt1eh8gIMt/nwac/yJlLF3n5699jtL/DYX9Ic3GFODX4\naMJmm4XlJWLfYzQe01z0GSUZg3FC5nsMjcZTBoXmdmeP5c3bPHPuHEtRi348ZG59jR/53Gd5+oc/\nSlaE6VIpSimiWsNySoY8YrpC5m5Vq4CrTH3avplm8afGaopYMJxECJY5TleW646zm7f7vTxPXc+k\n7jhWEUaz5oZbZplSLlP2VRbZVcRSOS/Xe2hV3abPrKo3tfsldy3NcnnhpvfdkGfWQBcpyyxwF0FE\npRRIz7Mx6xB853vf4//8R/+YT/3gp/ncj3wakyqUkZBpamGNOEltp8h8oolC19yfiDBc8KzyqFYG\nNBdo3XpXAVMV5e3+LjYId7JVnXgniXXM40mPQoOmAGWRG3BYYDrurKlqsbl1KFtolhfDBHgBP9eL\nLYN41eSU3rSxkZtXVf2q+nhW3kWqWozT93Pd3QljIsBYz3Zvv3aFYX/Axvo5DvcOuLZ1HQ4HLId1\n/NDD9xscxockytBeWqW9fIreMGXj/EVWPvo0m3fvcvrRh3n1+e8jk4xs2CPwfITSjHf3WF07QzTO\nqGWGOAzpBT6hFOjQkPiCt/fvMP/uVeT1ZZYeuYh4aJ3z3UdYXFxGSkOaQa3eIAgD+oOxrb7tEMAg\n5FHAhvL4ueN4RFkflzO7/X10z66zWf1+EuHlluvWpVwvl8ssj3XVWnHLrEpl8HUJhTJR42p/HOdI\npvGoTJwV7a2yaq4ihtwy3st8djezKjwqp/dVhFKWW5U7AIqDCEBYxXdj7ILMtCaoNwiiGk8+9TR+\nFPGPf+afcubMBj/6mc+xONdGpakDgnmHYK27PI4s/zzPm1CnVVR4sRO6O6nWeuJTo2qAyru7S/mW\nWbDi0y2vDODWiCbXXcYBQ6YXSnGtAMmiHoUjK7c+7qQs6n2/xVlWmZo1maGQ0U7LKas4FftbTOKa\nGvsSiEKTfLYc3+VAqpLRGopysByEQKOV4rd/+6ssLy6zv7vH0sIyg6s3CQ0cej71Rh3jBzTrTQZa\nsHbpAeKxDXXVqtdpGkXmS05duMC1q+9wcPs2gdYMuh2iKESPBrR9j9OLc9SDEFGv0Q0lDIf0R0M6\nvmGofL7z2wfgCR5uB8j5BsqHU6c3OOjsoIR1tKR0ShhG9hBHmNywXKK1QZvj4FW1jqrEV+5GWh77\nKi5yMq4Ol+bOicr+r6D0CyKlTCGXlQruZ61dzrf8OQv0Z20E5TLKYO6+V5aju/UtlzWLKKxKbuSu\nKg2fY8+fePc/YkpzcC3AZRYLbGV3gCioDkmcpSwsLNAdjWi12ozSQ5ZWVlleWeHG9ev8rb/7d/mJ\nz3+Bjz3zLL70MSoDY6mwKploGWBsueLYdXcgpJQTh/TuxCuzUe4mUQXw7nMuR1Ck8uIoNppiAdTr\ndaev8skrBZ4np54vNpwqqqDMDRSgXN60bIWOL7hZi8podWxBuZuH2zbfC9CWvHRzOAY05VTeKI/V\nwdrgTaz0tDH4wuflV17h7u07PHTxIbyWT7/TZVkJxmTgCXo7uxgkLC0TbJwhmJvDJIJsqFi6eJr9\nuzd45fsvMu/VObt+mtH2PTyd0esd0ppbJ2j4xGZMPxvRu9sjjgfs7tylvt9BR4JxHdq0aA0VyStX\n0A+cR15Y5+Mf+SgvvvgiZ8+dttHO6xG9YZ8giPKzWGtVKlEgfYQ8zgVWUb0mP6eoAsYyoFgOtbK7\n7VjlIFMGTfdalR64C0yFF8kyten+uW1xtcFmzYMqyr14x73vyrvdze53u4GV5335vMvt5/JmMCvd\nj9Mop/cNwIOgOJm1B5THnVPZT19oUm1QKkNkCuEL/DAk6fQJAo+l8+u8u7fNqheQGMOHH36Upx76\nAK++9hpXrl3lx77wBRYX5vClRChF4PsYpZBZan2Na33kB8ErJmauO1wCc1f+5Ype3FR4Myzeq6Im\nyvExywNWJV4qfhdlu9S/++eyi9Lz8LycChdySjRTgGOxqIs2lr0xloHeKJNbtjKJBJ+3Nm+fW9/j\nVH6Zsp9MdnX8sNJyE9bPx6z5XK5vud+ksEENijHwvYjRSPOVf/MtTp26QL/TZ6FeZ39/k2atznjY\nQZgUz8/ItKDT3eHspbMMuoeMuyPOn11HJCP23r5GNBzzwr/9Kj/+4z/B3mIbNRCkPozHGZ3xDiZ6\ni26SEnfHREGApyTGC6n7AWkywpgxMYK93W2GuwfIxQaNxgLbt+9y6tIZZCYhyQjqEZmAUIGvvdy3\nh9WsKix23Y3vOLgW433Uv2XZ7/H5djLrXgal8ly9HyHjEiFlsCoICTdPV3tjVn3gOIfopvI6Ka5V\nle+2cRaglwG8StbtEiDuBlZF5VfV5/etCEWprAQc09Rs8aeSlMS37Hjk+SDtYvcTEJ7HmUvn+fK/\n+ypRnFJv1DnsdlGex/qpU7QXF/jpf/KzfOLjH+dHP/dZhp0uARLf85BG4UvITOGnTeT+JGxZRitr\n5ensiF6uzlVQD4WeNlQfglQNZAEkBZiWT6JdWXVhzCOlRClNlmZTeYHlZIq+OvKNfbSwXY4jUylZ\nluWgZ/C8gto/6u+i7DJ7bCeSmJThyqyn1SkdUDbHdWhnTcgsy6bKF8LV6T/ZKrCoQ5XoIIg80lHC\n8vISnc6ANFFsbx+gVAAyotWIGOzfI+7tkxpJvVYDHTPQCf0kYX79NHWjuXPtCr3+kGYIO1t3STfv\nsb4wRz8Z89orL9Bq1dja26V/2EelB/hBQC1qsLA0z9Z4hBeGRM0WWQbNhRbzPmTJkGE/JqtL6s0m\nKqwT+jX8VCOlRygDUDEmgBTrhdDXHgaByjWyPKcP3M/yHLT9f1xsVy2OgJPEVkU6icU/TtUfiU5m\nPV/mNqu4u7LqbhUX4BI6Vam8GVRRx+6G4yoNuOWV83c5WbfNVWH9ykScWzcXF3/filBcirt8yAC2\nIVmWIZUkA3zPy2WZGqUVSguUkiwvLZHFCaM0pu0vsr4xT9RosKEUg3jMD//QZ3n9tVf5G7/zU/yn\nP/mTPHz5MsNBn5rnE+eROIQnSVVqT/h965FMeB44VIQLzkkeAsoVdRRqhkW7ygMchiFw/IS8SFWD\nOcVOIibybze5vq2P+nGS6wRQi8lQr9cdKqgQk0xTRVrbCONFOgJVJtaiBVhWhbYrt6Gcj9u24neV\nV0F38zgp//Im4m6m3W6fRqPGzZt3aNTbRLUmL3z/qzzxwafYvnkHkSXc3ryLjyAA0JBmikZzHtnQ\nnDl3if3+kGFnwPryMru3bnHz2hWaKiPTKX6jxp3bt1laXKTX64JWJKMxUkr6nUNW1lfw2jXkXI1G\ntkgvSzAC1tdXGB4cIJRP2uvz0je/w4dO/wQ6U+zcusPNF17l8hMPM9KCIDWIwEP71rOeZyQmV/0U\npfa6/VcGt+pD3uMbqh2baqB18zlpQy5zrSeJBoq6F4RBGQDdTcidP+67RSo2ieKzqrwqnyNVG6BL\ndBSgXxWsuZqDObrnipyqrD3dOlRZqJ+U3tdDTJiW8Zbl4cYYfAKCvE3CntjgiwBhDJ6UhEgW5+a5\nuXWXx1bOs384QPZGjJKERqtJ4EU898zHMEbzz//lL/Lxj36UT//gp0jSBBmFCGMAjZTWFaXWdoMA\nAdIeGiqVIcWRv5YCNAuDhuIgrdhtC3ByzY2TJJk6oHEp3pP6p5hAWukJMJcnWfmwsrjuTm7brmyK\nCpLSw/OmfaUX77iHg1OiIDUtv3frWAYSl3pxx7RKrOKC+6TNJ7DDRer3+5P6lsVKAFG9TrfbY2l5\njSw1fP3ffYvdnT3qG3NcvHSRrRvXac0tMe4eoOIhsc7QGHrdAXOrawRhAz8esdCSRNqweecWYZLg\nSUEgJfUoItHKmsxHIVoZZL1GFIXEo7EV12lNFo/xPUmSxDYAsTCgEkb7h5iR4k6asfVvIj7x8U/y\no5/9PH/tf/6r/NQ/+b84vNenKTy8DIYBJMIQKm1tIDBgjm+e5bGsuleeZ9Op2qrYfcelmE+KYuXO\neaj2SV9+3q1XFTiW61UAf/HdFdOU14FbB3duuRyJ++cSZOV+rVo37txz532ZY3UJnzIHcD+xiZve\ndwAvy5fKjZHSAy/f8SQ2Sr0RCGlItMLLJJ/86Me5/uJrdPo9rF9en7lGRKPWIDOag8N9kizmU5/8\nNC+8+Dx3tjf54k/+QWphiNAZgbBGEjoZE+TBHxA+wvNByNwJfUkWbMzkULCgvpVSE4tNl0L1fX8i\nq3UpkVksnHsCfWStiQ37pI+iC7mp+F1QyGX2FY78uBTPFODvsovFJCu4jHIdpZimlMuT3i03U9Mi\nlOLQ100TUVnJarPI634sZHGIW5Y/FotrnI6pN5qMhjHJWPGdbz/P+fOX0UoTJwmb9+5Rb7WIfEk9\nrbN/cMAw0Yhak9byKbb3+/QGQ85vbCCTMSIeExmF0IJhv0c/GSKjAKMNZ9dPMdCHZJjcDaKif3iI\nTBRZZqxaZaYxCrbu3uNzX/gM7165BkoybkREa8vc7uxx4aEP8vADD9GoNag1Gsg0I5CS1DNkwh5S\nB7nqqMdsgCtzefcTiUw/N/vZYq65FpjlNFMz6QQKvKhzFXiX53M5H3eeuBxHFWVdntNV3HDx54o/\n3LaWtXfca+XDy6r+cQmUqvv3o7yL9L7qgbtilDKrVHxmRqFyB72uu0jP95BoakgubJzlW1/9Gp87\ndZpOt0s9jOz7aUo6HtMMQhpRyFiPefrpp9na3uJv/u9/m//ki1/kuQ8/xbCzh6czWvWINIkt8PpF\nJA+7YATiWF3LwFU+WS9YL1fmVh6YYiDhaEEUeqrTlCj5uer0gJeNIKrqCHZyFZOxsKRzxRhunu4E\nLC9SrfQUBVNlNTppv5lebC77WWZBi03PDb7gUiwnsepuHscoqNBDpZrQq3HlnXdZmF9iZWkZreDm\n9esMhwOEFMw1W/gZzIc+jBLqC0t4zTn27m4y325jjOLGtStInRJFPnGSoZXi8KBLKgxhGLK6uESj\n2aQXp8TjGL8eMej2qC2ust3rsrRxirlTp/H7Yxqex6kzF7lw/kF8GfLa7Vt84EPPcGvzLkko+eBz\nzyCiBqNxTK3dJuv1ERp0CGMkNS0QBlQFzpap2N8tiNu+u/+z7jwpJ9das2pt36/8k8QHVdxalQbZ\nLO6j6rCxStXPJbSmuNB8nlaJgN3+mNV/xdx2KXiX8HDbcL/0PlLgHraurvhkWnZcgJOPzGPp5Q01\nhsQY/ChEZIbTy6uYmo8wCaiELDFIIAxCVk6t0+n3kKEkiJbojQesraxw+dGn+bVf/RUOD/b4zKc+\nQSgMo2HfWrlpG7Xayw82rbN3gUJPgUMURXlrHEDNlN1scsrbpQaOg3L1qfZ4PJ7I04Ep9qtMlfoV\ncvGCglJK5Sw2WNNra7lXuAbxZM4tGFWpYlhssNMTVOP5wdSpetkXxmQi6+Pm8AXQFg6RiucnboId\nHxtlJ0BVqegXpdRENXWqLtpgMkEg4caVG5xZO824P2BpaYleZx9pFKPhmFAYAk8RC0l9aYnLTzzF\nIMlYzDSB0XS6hyTJCJMkBKFPEISMsiTfGBNqQUCqFSgIowjf9+n2e+zvaZ77yMfobt/l9GOPYmoN\netfuoOOMl15+nQtnzrAyv8Tjlz/AamuZ1WfPcOPdG3zgE89x/c23CKOAzYN95j0fmYIRkPiKWmYj\n7Bj/+EGay2HdD0yqxB82mMhsaHCtqKFaa8rVxnLHqTzHqqjUYs5U1f1+FGtRRtUhYRXl7eZ5Ehfj\nrrmyqLJ4tpC9z6qbm1IndoH7eT+Os5zeNwCH476wy5NMCBsE1UNYdTABwggkgkxYK81QeCRaEbQa\n7Nzbot1qk8YxUa3BcDig0+kQ1Wu0ghadww79YR+kIPVq/Minf4i333qDv//3/wF/7I/8YU6treAJ\nGA36RLUa43hswcYPchn09A5bNXGFEFbNjmnqM03TKQ0T9z2X4nBFL7NOud2Du7KBjhtyrninyF9p\ndSxfw7SbSxdkq8bEXYjFvWKxVlErLqC69S76owzaLrVefJ+1MIApTaByP/i+T6oT6vU6Uvtcf/sa\nly4+xGg4pLe/izQJq0ttzDhk1OvTNzEJknPnLtFYXKK3t8/Djz1C3RO89M2voY0irEfESUo9lOjU\n4NcivMTQWpgjVhn97oBWEFGLIuZ9jyCKkEKysXGWGFBhxOHw/2fuzYMsy+76zs85d39rvpd7bV3V\n1VW9V1f1pl0CWwIZiUUwgwwOzLAMWCwTJsYT4LGDiImZMbZngnHMGAwzDkAgIxAIkAwSIEC7hJaW\n1Gt1d+1b7svb737P/HHz5jvv5suWYDzRnIiMzLzvvnvP8ju/8/19z+/8fgFZprh2+w7dXo/HHzmP\na0ria9c4duFBEstktb/LAyfuZntng9Dx8qw8SUYWJ8QC0iTLU4GVUp8V/VuWy7KC0/u2XITYC1lx\nSCnvd0wLDnWYxVQGLtOokWmWQ7kd5XJY/PEyki2/T1/kCipP/265HdMWnGlK97C664p6mlVy2N+H\nlVc9oUMxoIVZcaCzTQlZLlDKEJiZQCqxlwdP4GSS1DSYO3aEtbU1Fs4tEEYRW51dwiCiWquRotjc\n3iUIQ6q1GrWax64/Ymu3y733nMGUZ/mlX/m/+cmfeA+uZbK8vEC/s0uzOUMU+PkRcm1Ff6VOTrMM\nlR48SakrmWmKWleWBZIsm3BF/5RRffHcw0zHcZ3F1JjjhblbRhPl03Ll+hTtL9D0NOWgt1sf67LX\nSZlSKzaBi3ceFo9Gpwv0TdMwDPPJZ2RkoeJzH/84rWaLF55+lhPHj/HylYtYhsKouLSrDertFrcG\nOyzOLXHPfQ+wNRjRG/kszM/SW79NHAXML8wx2O0SRCmpH4BhMgp9KjMzzC4u0dnYwnIcvEqdmUYT\ny7LY7uyydvEK8/fdw9ZuH8+wcBwbI0lJSBgRcWNrhSPeCRbaVdrtGWaGXQhjNm/eoVKvsjPoYVVt\nlCExhMSREmlCmhyM4ldWOtOUwGE+85Myc7jy0GXhMESsy6j+vWnz6DD0O81q+JtYEsWzykp7Wv8U\nddLBVbGnNa1e+sKgy3z53sOuTbMCvt73p5VXVYFPowR04ZBSkigQKrf6i+zRmcoQpoklJMLP3eCO\n3X0Xz33gLzlx8iRRmlKdmaHleEjDxDBM0iSjtedXLA3B0fkqi+0WW1s7hEnCo4+9hj/40J/w2IXz\nVOt1LMclDAPiKMC1vDz3nsbJlhVaUQyZx2wpFEnZ/ahAltOQcnnXvDzgZaSr96XuTlhQOuNUaXto\nXZoTdc+yLE/CyqTgFkq5PFbl8StKEWe9fF2fLEUdy0i/aGN5AurIbhrdVJSyJ0shN/vcvJkiYos/\n+9M/5bGHnmRupsWws4uRxvjDHmZoM9rapO5VSV2PhaUjuF6V7eu3qdUrRIHPzWtXyeIQ07LxKjWi\nKCPwuygzRZgGi0eWCZKYzJA4rsPm7i5JnLC8vEymFP2VNU6dOU3omDQrMyQLswTb22Sk+PGIyzde\n4tmLX+PsyhW+c36OumGTCbhz6yrtSpXmbIMokwyJEAKsMCUoKIbs66O/shLT0ep0hZj7jB+mLMub\n0WV6RAixv99SdgGd5laqK87DrIOylVUu03jt4ntlUDjNw2aap0kZWU97xzT6pVx0i6Vcr3L9vt7i\nWy5fV4ELIX4NeAewoZR6eO9aG/hd4C7gOvC9SqnO3mf/HPhhIAX+O6XUn097bhFPu0Bakx4XYwUu\npYGVKhKRkbC3eZBBIpI8QWgKwpTcffYMf3LzN+j7Pl6ljrRdjEoF07S5c2uVYX+AFIKaV2Gm0aRZ\nsxGWweL997HTGzG/dJTFI8f5xKc/jldxuOeuY5CEuLYkTnLyUbcasizb9+0GXZGA2FMg+uAUnxeJ\nGsobQOWDB4XwF26L0+iEct+NBUSR/5mhx78Iw3BisqVpnifU9ewDKF+PvKZPTP09Oj94GNIp5wPU\nPXf0xarwkCmjL91KmVbK/LvuUimEIEpGrKysUK9UsQwT0/O4fOkGUiYYKsE2baIwZNTHoIa/AAAg\nAElEQVSLibCQ0uDOnRU812V+do6tO9fp7exAHBFmGa3WLF6lScc02Op1aM7MIIw8XnijUqNSa3Dz\n0jWGgyHVRgOExPEkqUgxHJuYhO3uFsONVQypyDIfK0kwMnj+U5/kypU7/PhP/FMW52ap33OWj/3h\nh3nHd307HTNhV4VUFBhBzECmGJaJmaqpikVfIMuW2Tdipgtx+GevtOldfm55PHV+vvjMcZypezzT\nnnuY6+1hXi/F9/X2l8Na6PeUrcRpHHrxvfK+lj4Oh/V1eSEq10N3Sf5GyjeCwH8d+L+A39Su/Rzw\nMaXUvxVC/Oze/z8nhHgAeDfwAHAU+AshxFk1JbiwrkzKm3V6ybKUbM8DxDVMTFNBRo4QgMzKE4ou\nOzVm7lpit9/Fsh2G/pCV1TUqVoVUGswszGMkKa6QdLq7bO/0EFISpxmG5VKp11GZ4g1veDOf/+sv\nkyQJD9x/BmUI1CiELCOVEO+dLjRMA5Wp/CScyLlkZQhQGXryb31gCiVdoFt9kKch3EL56RseZeGY\nJhBSFpMgP6xT3GM79l4CVxDSwLQEKJVHCylNKt3a0NGtjr50JSsYb+WWKRcdXelWhn5fGaVM4zSn\nlUyp/SzpYo+7lYYgTWOyTGHbFV54+gXiIKHWbPD0xS9ipRG2oag16hBFmBmM0oS64+RZ5VdWOXrq\nJPHQpreziSMltldHpBn+KESaFq0jR5DNOo35OXrBCMeqUHEqrK+uYbkmioSdzhZHjh0liiOev3OJ\n0aZJxfCItnepphKVJkhp4WCAyOinIVt+n/e+9ze478QJvvkd38q5Jy5gBQkVx8ZSFikZmQTTYBzl\nJU1RKRiGSaLAsE0ykUdjNwBjL+hVwqTFeBgKLETxsG4fn/IFEHvx5Mt3FYqxkIdcPgvQoy/e36iX\nUdlS14vcs3z3vqW1YTodM83CzZ8zeTJav0+/X5fp8TvGIA4tEfh4wVD7vw+zGPRr/0UQuFLq00KI\nk6XL3wG8Ze/v9wKfIFfi3wm8XykVA9eFEJeBJ4G/Lj9XR3r6YJZNDdvOzUkyRZYkqL2GG3sD6psp\nAkG7F/Pm734bFz/xJe49dZqeH9Ku1KhJj53QZ31nnaZp0ag2WFpu4zZOkES5chsMBqxvbDIYDEiF\nYn75GCs7fT75Wx/gx9/zY9TjDraAUOZH/i3XwUiBKIEkD5IUkxELsC0Dq+QZIqXcP/JecM57fTux\nsVkosyiKsCwr34SL4/3VHqbTGcUEGCMYPdPP+KCFflI0/944S4hOPejvKKMM/Z1lZV8W8GmeBPoi\nof8uZKE8gYrPDzPnM5XviWDIPPqkKYnimCSNcF0bVIWXn7vKvfc8yG63iz/os2AK2PNzN1NQwsSs\n2MzVqsT9DmY6Ih5scfHpG9y6co35+gwVt0aSJkRxTBpEhDWLxdOnOXrkBM8/9zw1zyEajhh0e6gs\nRlgGftij23OI+wGDLMGdncVtztJq1OjEXRIlMBOoKAszS0lUxsi2OP+ax3npS1+il/ksPHyG1Zfv\nYGRVGjMNNqNdTNuikiiyOEY4NiLJ4xPatotnuwyjgIwMVIpIU2SaooTYP1k8zfor5KP4f1IhTpY0\nPWiZlYu+WBf/T6MuvpGiL/S6PE6+S782XjzGf0+6AU6Ty6JfdM+m4jPdoplGUeXP0sHnwb29PJRB\nkdtWTCx6Xw+ZH1b+thz4olJqfe/vdWBx7+8jTCrr2+RI/EDRD27oZnmZDihOMBYdV3gXlIUhSRKe\neOQRvvAnf8FmZ4MkBkdUUNUKC615FqsunmnQXVsn6PdZ2djMBz1TzM7Ocdfxk0hDIgzJIBjiRwFb\nW1u87zfex/e9823MVD0kAkulECQIQ2K6Nqi8E22Vx8uO0mTqIOjmWXFNV3y6kircE/Xd/WkKsOiv\ngoIoK1Kdd1dKTbh2FZuUQoj95Mz6Bmv5YI3enqJME/6iTochqrJfefFb3+TU5aJsGRws+WRMkgTL\ntomigDRJqFaqpGnGH3/ooyzdfQ9mKgl3OhhKEagEVyjMJEUZBjgGx5eXmT1yjJevXqbVmoUsY3t1\nFcKQUHWxazVsaRGmKf0gRJmSertFLxhheB7zi/NcfvZZkiTBVAKRKpJRyO7aFu3UZsE0cdM8r2U2\nV2dzsI2TSdw0Q5g2tcTintocN3opz3/5Szz8xtdSa7TAdumY4EY+QZzCbIXR9jbHajOEoU+sFKEB\nhmsRqpTM72MpsZ+7NDUkgZG7wZocRI26d9Q0y2ha0ZVNMSf168VnutIuLEkpD1qSheyWn1FGxcUi\nP032dMQ9Vs5QoF69Pbp7r/6eslIvKJQyNVKW36/XT9PvyW1WvR66lfH15T4v/583MZVSSpRjtJZu\nmXZRb9xBZHgQeekcma5gdMVjphK35hKLhPn2PKZwGPoRg9UOhmWBhEatSsWusHT0OOvrm/T7A7rd\nHhtrm9iuQ61epVqrgWHz6EPn2ens8lt/8Pv82A/9IE4KFhLXtBhFISEKJQUGAlMJrDTDMU2UPRl+\nVhf4aXGQi/bpDv5RFO0LWkGl6K59OtVQKLsiZ6ceoa94r45eClSvK0m9HtrYTozDQQSi9lFEuU6T\nE2k8hoe5uOmKfRqiO0yQreLsgGIv1ZjAsj1GQcqtm7fZ2RpSmZ3h+MIRnrvycU4sH6E/3AK/hwpj\neiIiq1Q4Yjrs+gmxMFhYXGJj/Q6j3V2qhoEjMrqbG9SbLUzHwSGjdXQZu1bhxo3bVBpVDNvCcEzc\nSoW414W9BT1OYzYbJp6haPk+C7RpVRo0mzH+yiaWdFi4a5koiZhfPoZ65goPvektOG84x5W1bU4f\nrdNeXkRud7Btg4997pO85fHXcuX6Kovzs/hpQGJKlIgwpYFlgBmnGEqQCEUiFIHMqT5zrwv1DWM9\nFn6Z4jqsTFBnJUpm2ngViqlQqGWlpcts8V1dzsYpyzLtWZPK0TQPi899ULbLc0//Thno6O3T3//1\nXAeFYGI+7N0xUZ/D5PwbVd7wt1fg60KIJaXUmhBiGdjYu34HOK7dd2zv2oHy67/5O/uVPH/uQc4/\n8tC+4OgovLzhoG90FQpuX1GNfO45cw+Xr1/FPeGAMnHacxxfmEcmAlyTYegz6A3oDW7jBwG27dBq\nzOA4LtVqlW63Q6fTpdfvYloGse/z6Gtew/t+7wP8t9/3A0TDkDCLcWybSCoyoUiVwshSskwRhckE\n11heVXVlq7dL3/ATQuyj8GKzVBdaXag8z9v3AilQbPH84vv6u3VkXEyccjo33a1RV976+/XrUw/Q\nTFnAXsmS0JGOjuzK1Ey5CKEQoviuRAiHYJTQbM7x9Fc+xrGjZ9gOenz+83/NzJ6l0l6YI941CHo9\ngiTEa84hK00ur6/jORVWVjfYvHWLhmVTt0zSICDwRwRRiHIc5o/fxZmz9zIYjRBSUm3U2FpZJU4T\nao06wjRRYUToh6goQcwbWJZDnKXIRFG3bJZOnKSrXC5fv4awLM6/9nFsBTVMvvCZT3Ky6XL2/guQ\nGbRPneTirb+kuR1yrm/y8T/4KI9929tZEQpHWKASjCiPE97v96h5HhGCBIgzSSYFpjTIOOjNY9v2\nxJwbI9qvn5GnbEUdZvbr89YwxlH2dEur/GxddsvvnK58xwGsxrI25vPLi4wu0+WFRwc85ToV9ZqO\nwHW6ZpK6+ZuULz/1NF966mvf0L1/WwX+YeAHgX+z9/uPtOu/LYT4RXLq5AzwxWkP+NEf+kcTQlLm\ntoqGT8vcXF6BCyGw0owTx0/yxc9/hcfPPIofpvT8Ef4gxAwUvSwisSQNZeB6Jq7rkCQpQRQQxyG7\nnW0c22Z+tkW71SBNYoajAb0o4My9D/Brv/lb/OC7v59gMMQTApWmqL0MPwpFZghs08bRJkLRtvKB\nE90UnBbB0DAM4jjeD1+rT6ri2Tpa0umSopT7Ut8sKi8IRb2KZ5ZP0hX3Tdsl179fPLu8SaOP8zQl\nXp4Q5bYeVjKVQMErYmEaHvVala995Xmq1Va+ZxLG9Ld2cIXAVBEiU0ivRqps6p5LY+kYK6OYbhDi\neh47nS1G/SFVElAphsqQjk0/DohVRiMK6Gxu0R+OOHX0GCjFauBTnH2p1OukTkRKftp43m4ikpRR\nGLDud9i1UkBSP1Jj0LXZ6HeJvvAUqjvi6NE5TJWxefEKteoCfnfA4pFZbNsifuEqr/FabIgh/+H9\n7+f+h+/nmy9cYN5tYAyGmEmMVamSioxYZKTkeT8dJSGFOIsPKKY4jvdpSb3vX0np6GOpj7s+hoW1\ndRBFJ/veU8Vn5XMExd/FhnlZbstyUlBoBxeOjMKfvfyZ/r7yYlWACSnlBKjSQdG0RWQyDd1B7xXd\nAjksabQQgiefuMCTT1zYv/Yr/89vTr0XvjE3wveTb1jOCSFuAT8P/GvgA0KIH2HPjXCvIS8IIT4A\nvAAkwE+oQ5bxYkXW3eB0BK4jAdu295VYUcq+qEopXNvl3nvuZWV1g5Ef4NXaCNeFUUIYDFjf3sJo\nVsmUSdtycFyHdrOFYZj0e32Ggz5bQUAax1SqLvNzsxxZXGTOUtxeW+Gh84/x73/91/jpH/8xIj/A\nNW1klgIKYUnCNCZLIojGpmGh9MomYBmhlo/d63G+dUVWVmjFBCz6VFem+uZU4b6ne8Dok7Tsc6s/\np4ghnlNdYv95hV932XVvbGaOY4cXz9fpr2LcCmQmRHECcLJeRcKPaSX3N1YgJUJlCGFQcWr88Yc/\nwmMXnsRxTJLdXVqWiT/q45mCqOcjanV2DJdjx+/jvgfP84VnX+BUq0HY67CxukYNgWta2KZAOBY9\nPyBFMdNuUa3XePFrz2CYFkfa86ysruJ3urhCQByDZSBsG7dlIS0Pt+KysrGKU/G4tbXBa++5m/kj\ny1y8chlzqcXWZgcjAykhSALe9oY38ofPPMdxWxDtdBmtbnH+sXv5zPZnqM+7nDtxD8P5Rf78S1/k\n9uVrvOf7vw8bgWU5eBWPIPHJsgxLSGQqEVFKnKakMp0qh0UYgkLecmWrXkHJ6GFdJ/ljHQDoG/aF\nHBXIVKcMddnWg60VMqbz4zrdo8tPmub3x3E84aqahwWYzJQVx2OlrCvv8oa+74fYtr0vu6Y5yduP\n+2M83wrgU4TjLeS/+KzIlKXUpOtrUbfy/D3MfXb/3d8Iz/Jfuggh1F/96e8fQGU6daKvumXf4TIX\nXAxCGKWoWpU/+pOPEOyMuP/cBUJh4SmTmnCxGnW82SZJd0gYbZOkMWGYJzkwpIHnulRcFykFSRwR\n+EPSJEWaFtKxCEVKpGL8QZ+//8Y3IgYjZBwhhCKSKZHIsDAw1ME8l7rA6pbF9FgUcr+tOhrJsmxi\nw2cad6ej1+IenT4pK1odnZctIG289n8XCKp4tm4F6O3Lf4wDddXLJOpJJvpr/L5xwK37z7/5wDOe\n+8pfgswnRNVt0O/6fPFzT3PpxeuY0qE+W6d/9TpJvwcuEMTIzOSm78PSEc7c/SBJLOiKjPPH61x5\n4Xk2r11B9XdQwx411yQTGZGCyDC5++wDxAg2Nzao1euYhsXmxgauZeCaIo8HHodk0iRI4N5zj3Bk\neYHnL10kVgleonjwrnvIbMlOFvL88y/QSE28zCRWKUY65PGzD3FrtYPRXuTe+x8g7O6wdKzNiePL\nPPtnn2Gxucwt0+BSNeGlzVv0tjd59/d8F+2qh02GkWW550mi8tg+SiFMgzCLDyDrXElPykuBFJVS\nXHjttxzo8y995iP7NF0+7mP0fpg+Kd6bppMxQOBgJEHdStPlsgxeJuuczyM96mfuQjvpEpv/MFH/\n4n7dsi2K4zhEUbR/MKmQ9cJi0eVbV9blhapA3VIWwM6YUND6vNOtX8MwuPCat6GUmmoSvWonMceB\noA56MehmF0xyrkWDixVe90Zp1JqM0oRve+u38O9/6Ve5zwAXwcbqOqFbo3v7Js25OVzXpd40ME2D\nenMW13EJwpBer8fmTgcBVCsOrdY81WqFnc1dYvLQpNv9PvNzbf77n/s5fuUXf5He+jpZHCFsA8M0\nJnzAi7YU9Z/Gremc/rRNRz0++rRA9dOiERb3wuSO++HCLzQhO+jaN14E2J8QxfN0ZFOMS/G/YVgH\nzNPyZuVYiP9mUdj2i8yTXhuGxaA/Ig4zbly9QRrFWLbJYGuFzVtXEVFIba5BFmegbGqtNo0TdzEK\nA7bXdzh1/mGuvPhVVu/cpG6bGI0GoyTGVwlhmhGkGQtHF2m029xZWaNaqWBLydbGOt31DWLLpLbQ\nxjIl1VqNhbtOMcwkr3vLW1icbfPg44/Smm/z8Q/9Z9ZW1zh7/iF6/W2smkfaC5GGxFCwFvh88GMf\n4R8cf5TNr36R5MgC9XMn6cYBfcvg6KnTdJ+6wj2PPUJUi1leXuTO7ib/8n/9BX7hF/5nWk4Ff6fD\nQrVGmgX4gU+11SCIwgNJuHP5meZjPbn5Vy6O45AkCVEUkaY5TaEDMMMwcBxnH3XrHk06oCmKPj90\neqWY22Xwo5ex4ss38AvEnD/ToMhCVFgZud6wDuic8rPL1IxunRTPg0l51y1epdIJoAN5GknDkPuL\niJ7dqgCmkHveeZ43ce2w8iqmVEsnlI1SasIsKQShfExbn/xFKf72/SGWaTHXbGBXbUbBEIIB87NN\navUZGjMNurtdBipiOMr2Om8HJQRCSKqVCl61RdVzEUIxCkJ6gx3SICbJMgzH5PSRk8Qq5p3f8S7+\n3a/+Kv/we95Fxa2QxREyk5hSYpS4waJdhYAWXjfTlFWBFIr7i7jc+ue6wp6WxKD4TOfv9P4uI119\nE1Kvk5RyYgHIr2cTY1bcV3xP35zV/y4+LyZO2f/fsg7mUCxP1mlFShMhTYQStNttPvbRvySOIo4s\nLZJGKTevXMIwMxqeS9DvEqUZkfSoLyyyUKuxub3La197jqE/5PrKDUQSkgmBbVrYtRq7/Q6jVGF6\nFaxagxu3V1BJSrNdY9TvM+x3qbk2jlL01tdZWlrkrmPHmVlcwpiZpVZv8My1qxw/ukxnfRsbgySM\nWL12k+pMlbc88Rq+8MnPsrmzQ3eng20JZqpNZMVkN9jkzs1LnLq7hWtX6A58mK2xUROojRVk6LK7\nGWJ7Fv/kh36Mj3zkYxxdWuINj51nY+TjqAyn6hEnEVEcYlvOAeSrL8Z6f7/SIiqEwPM8TS4mPcqy\nLGM4HE7Ixli5HfQ20TfOi+vljWyd8phWyrKYy5+FvhAV96TpGJzon5UDrBXv1Rcb3VlAl9FpMlt8\nb8ylFz8ZaTp+f0FfFUxD4To9LRVbubzqCR1get65okOKI/c6naCvnPqgWq5J5kcMdne4/9z93F69\nxYW7H2B7p4sfh8gw5f4z99GXCaaoEkUJa2trbO3sYEiD4SA/QDPbapGmUc5zOxYmgjRJyKKYcOQT\nGwkpMHvsKP/2V36JX/j5n4fRCDX0J2LDlbnkwvSCcXIF3WQrBkzP5KPzhMUzdSWn84NlJF58r+AA\ndW8THVmXn1HUoYzu87Ga9DMvng2TE69sUpetCCi7TqYH2qa36TCFEsUJArBMh7XVDT776c9y5q6z\nbK6vMdeeQw36pET4saJhmfhSMsgSahWH2y++QOZaBP4MweoGKvZxDZPI97EcF+G4eMYsSexTbTSI\nlWDQ7dLwKvSGfcJwRH6IMsOWEgsTEcVs3rqNnyhee//D2IYJ0iDsB3z1s59nvtXgdW9+M3/0R3/A\n6173GsLdDkIKgiigogyMfkStUeXZzWs88e638pnPfZ67zpxi5vhpdlc6LD54hva3OrR6MU6k6Gxv\nIaVDvxty/uzDdMIhv/y+3+Yff//3Ii2JkcRYcUzVcYmzybCoOrWm93n+9ytsHGu0VjH+eugFKSWu\n6x6w7PL5PN4E12W/PM5la7CQhbL31nhhUBPhK8YIe5qHjJz6bJ0W0a2Cct3KDgBFHYIg0GiUMf8d\nhuHec3MaRQiBbTv786EYA90jLIqiibSGh5VXTYHrpkOB9HSFUzSq7FNcXvn0Do4Dn6rlEGUJd999\nF9evfYr5uTau65EIAxmmvPTSRULXwh+mWKaNV6nw8EMPIqRBlil2d7YJQp9erw9pipA1UimpVDxM\nKUEogjTAc6ssnzyGMCX/8b3v5d3f/h00bRuSlDhKUBIQYAhJtpdEGMNACSBTJFG+6gpjEnmUFy1d\nmcNkFvZpMYnLForen/mGcYF4C2GfvoGpRyjUr+dH1Ccnnj4Gel2LjZrD9jaK+/NxJO+j/Qzqegq5\nw2NdJFECUhJEIR/8wB9CarG106M/GGAg8Qc+tbkmKuiTphlRGlNvtXBtydbqNmazyvNf+RLhxgae\nY2LbAstzMTGJghBpOcwuzHHsrpOs376DMkYYbo3BaJOt23doOx71iofMUirSJQsTLGXQ3d7lpRcv\nYjSazC8ucf25F2h6FV689BJHHzjJd//g9/Gxj3yE2XYb2zLIgpCWtLA9D5WkDIhZ6W8T9Po897kv\nUnv7HEvH7mJna5dTFx5i9emLDNZ3qdoW/cCn6nl0d/ookfLYI4/xf/zSL/OP3v1fc3p+DtepEo98\nLMcmVQphiHzBzBRk2V44CAOk2LNGBfIVNzGLk4/Z3lhN38/RwcJ4rh8Mv3rY/+V4PFmW7Z9h0N+R\nK3YLKcU+nTNWvgcpmvze8bzTZbdQqoW8NRpNsiwlifON/CQdz78sy0AVG7mKarWay2SSkGVF4Lni\nVGtufRSx/i0rmqBHi/YVFndhDUwGqTtYXjUFriuGokzjaPX/dZOiPIhSSiyREskYTMl8rY6RpNxa\nuY1MDExhMzu3iHmsgnAc4mTIaDgkCHyuX30Ox3Fo1GeouiateoP52Tq9bp/haIifpPhZgGM7zNQa\nNCpVQCH6isfOXOCZ6Cs89eKLPPLoIzSSFNu0GKkYy83DhtpCIg2DUMIoiZFC4JLHjygrQ10B6yak\nLmRlt6oyn1f0iS4Y+fNy97XJPhQYhnmgv/X66OM0RswHIyceDEY1RjplDlMf93wCFl5GBdcuD7xv\nWrGxMNwaf/7JL3Ll5S1mvSa15jJ3djpsXb1KNhKEm0OUjNg1MoRQHK3XIPRxTMWMZbK1s0Ovu40t\nDNRsC6/RhGGGk1kMY4VRaWLMzOH1YyyryYiY0epN6qGgGgWYtZS5U0dRYUa01sPE5ejxk3T9AVG/\nQ9DZ4vadmwRRwNXb1/ihUz9KFIccPXmUnfUN2o0KnbrJIIxoRQZJkiIcm5cuXubU3HH6V1dY3V7H\nePwMwncIr25jziyRBhF2OMCpSFIX7CSjoUz8nZC3PfxGXnj6Mp8bPMX3fse7aFcqJNEQYUuiLAKR\nYYoMA4WBBCVIMUgw8lybWcwUkdgbE3PCpc4wph9cG99fKEu1T6Ho1nSZ+ivKtIQi5U38sWdWQppO\n7pONAcG4DgUC1wFi8V5dqe/XL03JVIY0JI7hYCt7PxdpuudpojJFkhYJwidPkhsGSJnuswymae/x\n8dEEdZSm6T7iLiwa3Qo5rLyqCR3KB07KK2HZ3CsrfR3BSymxpEuYpDhVl5mGw4ljR9jcXOOJ84+z\ndmedly89h+V5hCql3ZzBsR3mjyxTqVQY+T6WadLt9li5fYNMKaqVCrOtOpXGTI7yRj5RELGzuUV/\n0Kc128QdObz+NW/gP/zHX2ZmZoYHT9yF7/vUKhVGoxHSEMTSIA5DhBTY7JmBe6c1JRwQyDLnr5uF\nOhVS3oTR+0bvn0LRFpNHf64QkmzPP1jv3/Ix/kLYdDNzvDAc9B3Or4sDil5fVHS6pMydw8GY5NNK\nvdUgigWf/dhfYjpVfBXRnqljRTGGY5M6NtJUhCkkUUy9NcMoTBkGHU6dPEkYjNhau40rMxKlGA36\nRElCo9IC16TqOZw6eRcbGxtEgc+5Bx8gTmM6JJjLQ5Q/YKe3RdwPmKvNELZNkoqFmK3RXVtnBosv\nP/0sJ+45xac++yl+6Ed/GN8PkAa84Y1v5IO/+wHcSpX7HniASy9dIiRGWpLAD0AKjCOLVEwTWwga\nWKQVm9WNDnefuQ83CxkIwfXVFSxb4Mw08awKSRjRkhlGb4e7T53kf/wffpb3/JMf4e57jmNFETUp\nycIYUyowJYkQKAQqy3JUDqhXOFxdpjF1OmXMMx/cuITcstP3ZnQqozy/Jz041L4Vqd+nK1ydUtEP\nt5X56cK61PWI7hBRuM3qsqkzBDp42vfE2XOHLp5X9JFhGPt5W7Ms0zZ3Y4Q4yPcXNJBOK79SedXj\ngesNKJtSxWe6y08ZeeoTWwoLCInDmEQolpcWefbp5+h0t5mdbzC/3MZ0XMI0ZrTjE4URd25cp1qr\nYUiJZVuYQtJuVPA8D9M06Xa7bK35mLaNFAZVt0L72HEMQzAYDRkGfdZXNvjhf/zDfPpzn6FZqbDQ\nbBD6Ea1KjX4wwlcJ0pTYWZ6MNlUQCoUUYGSTwYXKYWgLZFsUnZcu/i/36X5/aAsDsJ9rszwOBVIu\n0zD6z9gFMf9eGTmVaZJ803SM1PQxLdMyeh2L9pY/O0yBZ1nG777vdzjSaJI5VVIhuHb5IjOGgfBq\nmFUHYQp6/oBqq0GtMUOnM8BE0huN2Lh9jaolIQkRpksah8Rxgh/E2I0GJ+86jWMaEAU8cuFhXGmw\ne2MNzzJpzM3S9JZxbtmkSUx3t4OyXO47/yDXu9vY0mD9hcvcdfcxXrr0Mm6lwhve+AaCJCSTYFg2\nb3/nO/n0X32CGMX80SPcuHYNI81wHZtGo4Fs1rj33D1ce+ky7bvuImjPMFIweuYZ3nDuIZ67fZsZ\nLHZ3+/QtycAaIeM8wFqz4jHo9vmf/sXP86E/+zDb6ZDH77kX264w6g6xqx5RlpEZilTmLocy3fOJ\nntrbedHPZOiLcdli0y2usRKdHvtdt+AKZVr4fOsyqMuYLkdhGO6/Uz/UVk7IoP8U8614tn6oqVDY\nY68RnbotFpLcYsy57ZQkyQ68J4qiHMhpXixSShzHnlgoLMva98wrz8NXKq+aAkS5HNgAACAASURB\nVNcHUV/ZyhO3EBY9mQFMxiUo7t3tdPBq1bxDDMl9957l4nPPstPdoj+06Pf7WLaL5bnMuHOcOHFi\n//nDYZ9er0enu4thGIRRRrXW5sziKaLUIAgiOjsdtjfW8f38oMTsXJv2bBNhGWysbvLG17yeT33p\n03zvd34nchQxGI4wbItIxdiOhR1nGBmkKiNOMxzLwtI8bXTB0hWxvriVB7Sc+09X6LpJqHuhHFb0\n9xZ0VdlX1jAOUiBFvfXIiUKI/QlRRubTFojiQJeuAIpDHK+EQrbWN7j+8mXOnXkYe2GB2JTc+OLX\nWGjUSC3F5vYGSSpwmy3uu/AEvWHAWvcyzWoNjNxbIh4OmKmYpI4BoSLLYKPfwXIkS1lAxR8x47nM\nzTbxMLj65S021m/jex7u/EJubUUhV+7cYenUab7ywvNYnkP39joPLC1ybXeXrzz9Vf7Vv/kFUgGG\nZZKoBMt1WDx6lNe++U18+Qtfwg9jjFYN5QdUDBfbMtno7XCqYqCiiOGNNbxWk6jiYfg+F59+hnDo\nYwUxs24Fs24RGIJsGLE0O8dApSxWHbrb23z3d7yL3/iD97Py8nW+861vZWlhiSQckiUxhiLP+yoU\nytiTr8PDa0/w0GXXujJFNk1p6h5Yk+BgHKunyIajW9hlNK7LlOu6+3OoULg62NPBYnGYpvhMr2+Z\nA5dykhHQPUXK7a3V6hM0og5Mi99F231/OGHp6m6/Ot0z7US0Xl7VrPRlhK1P4DGKkxMN1AWjbKJZ\nlpX702YZSZxgSsnc3BxRFHP0yHGWl48jpcnA90l9xe07K/k7hMCruJimRXt2dk+gFGEYsbK6Shxn\nWJZDvV6hXvMQKqce/GDE7vYOwgTTMthcXePuk6f5hf/tf+efvecnkJnCSmJMUxIHEVmSYUlJJiWG\nFGRJSpglE9TEtA0+vZ06J1woSF1I9P4tI5WprmJjmnC/6II2qfBVzs9qyGCaJTWeqJPJb6dx58UE\n0tGSboYXLo6Hlc9//FOoIKTX7yBUglVxyRIf0zUgjEgNSZTBTGuRUDms93osnboXU6VcefrLDP2Q\npldBECOFgSQ/ZOF6Dk6jxvbmBtvXb3H+wgXsNOW5rz3FXbNtkoUm4e4ug34fx3MYJgGt+07jtGbp\n3t6AIKbuuGRVm6ee+io/8dM/xekz9xDFUR4/J8vAEmQqpdFuE6WKWnuW+5fnWL9zG9EZIlJBHIV8\n/JOf4O2PvRkvyejdWuFS0GMmMKkZktc/+QQ3vvgMfhjRiXoEromjDO7cuk1sQmxKZAaDwYBve9Pb\n2B10+MBHP8r3vOvbabouZiiwVIZUGYnKSEQK5CGJD1s4dVRbjFcZfB02zvk+DBP0RnFPIXN66Igw\nDPcVarHIF3pCf58OHsoblLp1l1MTTMhuIZv6/Br7aMfIvbMGOU89Rvrjwzi5v3mx8ai/twCfZZfF\n/OTxGKToNKLOLryS7MPfAQVeVLDsbQJ5QwvXHH1QivuKVXbfdLIFUmSYjo0jBEjJ448+yUc++meY\ndhUpHOqVOo1GE2/ewzTzHd4kSfBHI8IoJI0TXM+hVqvhOA69Xo+036HX22Fraw1TmjQaTRqNJvPz\nbZaPLDLyB2ztbLO7u41yLX7gB/4b/vCjH+Vd7/g2LNOGIEAqmSditvN3OjKPoKfEGL3C2DLRXbX0\nfimiFOrIepr5WvRT8VmOHCZjqIw5O/a/pwteManGJT9dmd+rm8nF8WoDPZdima8shHQaNSJlfhoz\nb28xrhLLKlzUppuS11+4RM326A66eFnCypVN/H6fykxGXZgoy6FRb9JaOMLV2+tsd0c8+MBxOhur\npMLAdD3CUYjrOag05+0hR1PVmRZmBkuLy1QyuP7cc3gopO8TZBFexaM77LM7CIirNvede4gb124S\nhRHR0Me0JB/4iy/yT//5z/LgI4/kMbrJ+8q0DOIkIUxTbMejvbjAztY2p44ew7ZMbl68RLA7wjNN\nnIrFzu4WQdqj29nk9vY6cW2WdK7FVneH1sI8qrtLwwTDMRCpouq5KMtC2QahH1JzKgxHPkfnlzEr\nHv/Lv/s/+Zmfeg+ztgMIPMOC2McAhBSk2eHKo2zJ6a5wxU85rnwx3kmS7W825h4aBcgQe/7ZxRFy\nc0+hFYgbLOtgncYKc3KDs5BxPVpn2TuqPFfK9KwQgiSJUSrav9c0zX1Fm7c1P/GZK2j9eP2khaAH\npMvlPp367sk2iQOLZbm8qhRK0UllgdAn9jQuWF99LcvaVzJJmrvgqDQGBMowsW2bkR/Qai8Qh4qV\nOxus3t7Bqlg5520YWLaNYUhM08BxPTBMOv0hYjAiSRJsx6I9e4SKVwNg0B/gj0b0eh2KCEa2ZXL8\n+AlGYciw20cZFi9eu87502eoCANDCqQliA3I4gQrynIUZk7uehc70OWi95XeP9M2CXXEO2k6TvqH\n688sJl7Zk0R/tv5e/drYJBbo2cz17CvFd6Z5KuTvPxhHHdS+4tbNXr00qzM4XoXV/g7J9haj1TUi\nA26HIW1hs1vxuHDvg8SpIvIj2q0Wd27dYuX6JcwkojHTIhYpveGAVI1wDYswjlk+eQKv1mDl2nW+\n+ZseJ+j3uXjxRZrVCo5dpTXTYJBGbCQ+fhJxduFerjz3EsNRRK1eZ3s04uUbl/mpn/0ZHrrwCHGa\n5vlz8vVhr+G5XPQHQ/pDn6Wjx9lY3aJSq+E2GyT9gKrtkRqCi5de4k0PPU53a5v09hrD+Qy7YjII\nfY7PtTCrLjYxz9y8QioliQzJhCRVAiUgGIyo1aoE3QHRcMhP//hP8lef+CRvedPraHkeSoJUgrrl\nEMVx7vJ6CP+qnz7U5WzaqV997AsKQpefsnzr3ykCwI2twYMeW2WlrM+HsqdLId9jEDI9QYNeN8+r\nTnw2poPyuDvje+We/MsJEKbTMfq74jjn0Mt1LffJ3+lNzKIUlSxPbn1QdQWl/+i7w7blIDJAQ2vN\neo32bJvnL77A8aOnOH78GO3mHMPEp9vrsL29TdpLcRyHarWKQtBwHJIwIghGRFFMlgzZ7XSR0qBS\nqeA4DnbFpT4zg23b+L7PcDgi8CMcy2EQ+Jx/5Dy/8zv/idl3fz+n5uaxLYM4TcjzB4ElIBbkfrla\ne/Ud+vImUNEPxX069aLfU0bYOlooC0l+79j8LUc1LFMg5Wu69VAeM31Tuvx8fbzHpm02wWPqpbzB\nXZRBlDAz38Tod/C7PeZrdXwzYxBGdPsD3LkWuzs77HZ8Fo6coFavc/3aJSwVotKIFHBrTRLDZdDv\nsjkc0V5YwHQrbK9vMVNt0pppsTMc4WbQW1snsSzsLY+eAyMX2gvLXHr2IhYW/TDiwSce5eqdG/zk\nP/sZzj/5CGGc7qXbI49ameW/4zim2Zzh0ktXGPo+zTRja2sHuSs4e/Y+bgcZnTtrDEZDUPD0xWd4\n86OvY2dri5euXsadrXP95g3WjRXOnbmPU+0lNjbWWA+GxBKa1TrBKCCRAstxCJIIMzOZtapsXLrB\n27/pW3jfB3+bb3vHt+IsLeEBw94Ix7IQ5uGnHsunc8seRcV462NX/F9W/jrtUbYkx/I5edhGV8rl\n5wghJugWHaiUUbEuU7rFO/n+yQ318gJRvD9fZMZ8dnnelPvGNA2y7OA5ibKyP2wR3R+LV/z0/8cy\nrYJlgSmUlc5JFdcLZaCb+yqTqDSFNAORO9djWdz3wD388Uf/gieeeIz1m+tsrN9BmSaNZpPTp09R\nqVQIghDf9+n3B4xGI0ajIY7j0mg0cMwGAgiikDDM2Nnewvf9XJHbNtKQeK5LtVrDti0qQtLv9fn5\nn/uX/Ol//jDzb3kzFSUQhshP+gU+KWCY5j6CL/qk/Hd5AMuWSDkQftGHulvUeBEcH5CZRNIHlWN5\ngugLaZnzPCxegz7G5YVIr2/ejklvmnLWlMOQyMbIZzZT7KxsUktTUiKIFI5jE3qwNNtGxQF+Z5uh\nYbB2+UWGww41T2J4BoE/IhE20q7h1iWiMUPiufTCmDRW2FWHWyt32Lp5AxHF2AgGwYA0CMGu02y0\nWLt8nTnhMegMWDh5DGGZZAY8/uRjdPwu0nTz9grI0oxUFe5pJqORz82bN2k0mqSJYvn4Ce7cuEHY\nH2FVK+yEQ2wDRJqxtrnK5uoKDxw/wZ3eFs989SvMLC9x/JFzZKZEdgbMKou+YTAwDeIowkgVQkji\nJMrpwVodU5ioNGX9+m3e+ff+AU8/9TUqT1rMOBbzM3WGIx95yMGpw+SjPDfLXip6uIxpSklXjNOs\nvOJHD9hWBnL6nomeDKWoX3G9ECWdZinL2Vi2J+WwSByht62g+8oOBHr9y3tbaRrvuzMWKF23eA3D\nwLbtv7uxUMocuNoXagN9A61YFcsdMk3ZZyo3ZQwpkAJSMtI05PSZkyQfGRHEPZaONJFZi+4wJoxj\n1lbvYNk2ju1g2w4L87OYhslwNCIIArqdXYSwsCybaqVCtepRqTWRQuIHPt1Oh1F/gO8mpKmJsHxs\nUyL9hM/9xadotds8d/US5x9+EBmGCD/CEQbCEsQqIz+yOUYEOm9XXC+nkNMHtYxGpm5UUnikFJno\nJ8Np6ohZRxpFncp9L+U4TvI01FKUaXSP7iapb7CWg2LpQv9K3jP3P/k4l556Gk+YeLYBWUTc69Hr\nD7AW5zDJ6HW2qdsGZjQi3F4hGO5i1h2azSZutUIQQZqa2LUmS6eO0Vic5/aVq6T9gEqlzktXLrN7\n8xZzlok/GhC7ktqxBXaHfXqXb2DujkhlzFvf/q0cf/IClWOL/NVH/wTilMzM9zkked5KpMQUxb5P\nxnPPPIvjeNimg+u4DIIRp06e4tnPf4Hlk0ex203CnR3MNKVZq3Hx5ed55P6HWV6Y5dSx47ztbW8j\nrdpsPHeZFz//LMdPnKBRcemmPoa0saSJrxSuZYMpGfojTNNCCEnUHZIMfN7yyGv4wue+wH2P3Ieo\nunh1h2p4uAI/7ATwNDkswFcZbJURell2i+focYTKMYR0Ra7HEynu1/WEjmyLIGtF0R0Iygi7DBym\nWaN6nXUng2KxKW/OT9NfRR+WFf7fWQqlfALqsPCOZRJfiPyUXt7Igq/dix9iuEghMQwwUAiRkApF\n1XV54okLPPXlL3D25N0kQUyjeYSZeo3KQhXDMBmOhoxGAWvb23tK06LVanF0cQnbqzMcjugPBmxt\nbTMYDnBsm3qjzgMPPIRjO3Q6HXZ3dxj4ffpBQM2ycKTJ3WfP8v4P/x5ezePCqXuwRZon35WSLM3y\npBAlVOo4zphO0cxBmDydVjYvCxcnHankPqrjPi845UnO7eCmoo6GdKpD9xoyXoEnnTZZ9RNmOlco\npSSOwxJllMcGzy2rPa+NKcWr1wjCkKbpILKQGEAY1Gs1zNl5At+HNGN5fpFbV6+g/D4LTQ9FzOb6\nLdrzR7HsKo5wmF8+QuPoIt14xNFjR5k/fR+3Ll/mzu07MBzgWiaj0QinNkNfKZAGdpyx5Nb5ptd/\nExuJ4ubaKnfX6zSdBsPdAXEzxTT2zOpiwdprY78/YGdnh35vRHtmljAcUJ9v0bl5m4cfPs+nv/wZ\nzj5wDytRSNId0B32SXzF1u42TqXC33vr32d2bo6rO2usrq3SkCZyFNKebdHLBPEopmE3UFKRkGEY\nJngGCQLP9nAMC88wWHv5Gv/VO7+LD33qT4nqNsfm56mIrOycpE3C/Pi4SjPQ/LoLgFCAjlw2CvTM\nAbnTFVYuF+wnRwF1IIx0mV/WQU4ZuY+BR3ECVN/sH88ffdPVNM2DHiPZWOewH1cFsjSvY16FfI7p\ndSvaWsyFvF7s94OO3nWQtM8mlCyDw8qrehKz6Ggd9enuPLkiiibuLSKf6QOWd5xAiARE7sKaAioT\nSGGhfHjra7+J3/jN99J+Yo4kTemtZwz7Qzqmj+XkcSAMQ+JWKyRJiilNglFEv7OKaa9iWblJc/L4\nHErNopRiOOizvXZtvw6epWjXW8RxTBAnmFS4fnOVb3nLt3H71jWOzR9ltlFBmhlZlmDK/CBz0Z59\ntLAXG9vYS4WFUGQqQ6npOSWLMv4soziKYZr2Hkede5AYxkE6RFfaxU+Zf9evjzeDDnq+6HUrK3Dd\nPCzoH/2Z+Ribe88r0slZxFmMKaeLanjpNmdnFxEioTPs0PcNtmNBs30MkgZrw3Vcy+Pl67cx/R4L\nVUWW9NkJIkIMAlKMuEM06LM96MCXP8lg8yZZxWZoWEg8Zi2Xu5bn2A26MNPAqcxgjVo0Z+oYbspS\nZHHl+Re5pgS3r17izm/9PqfcI9hGHWF3SOIICwu1F+MlS3NF3tna5tbNO8wvHCFMJK5XZXWjx9zy\nCdJuh3uXTpKtdjl24gRXb11neGsbA4/P3brF9/+rf4FcWuLGxho3r1wjGUS02m2sKMXZHrJspmxk\nCbtGyPoopt2egWhEnMUYBgyiIZ5h4AeKRsPj+aef48zx+3jmqStEp1OMo22axvQ4HKGKEZnAVBKp\nIEqDiTk9dkMcK80CcBWAYgK1ColAIIRCMFbySTYGAYUVqu8R6bInpTNh0Y29UQr5LnJyTgIVHSDq\nHiv78ir35hTFO2Ec/4S9ebU/A4sZMDE/9bkxrsPkOQ19fhT116mow8qr6oVS5lOLDBx6AJcoivYH\nJkkmXeDGSr24Nhlj2jAMlBCYtkU8TKlUKly9epXmTJN7732UilslThI6vQ6dXockjUnThFqtSqvR\nwjJMer0+u51tut2cUjEMg1qtRqXi0pppUa1UUErh+z6DwYDdTic/VeV6zM40iZKY3W6HY8vH+PSn\nP8M//O53MUpiBCKPWW3JfQ4sTRMyle0FxcnRDUIiEUCGjomKNialI7zJXuAs0xxvipTN2zLHWEZF\nxeqvb66UUUXxfSiC9xxcfCf594OnLnWEUgTwKu4rDnKsrq5y9OhR1tfXp8pRd5gw2O6wsNDEEhLb\nEFw49xCWN8ONm+vUjlcIVzoMN28zP2uxNdolHirSyCIzJUGoqFYaNGuLGGca3PzSNl5ljsFoh9kl\nj83eFnFtmaudAbVWC9fJePHFL2CbS3g1iW2MGHlNor5kKzVZ3R7x7MWv8IYf+QH8yi6jCFxlkGYZ\nhhQYmnud67nUalV2dndZXq4jpaTlVagbJpESXH3pRRZqFWZlizMLR1mLJTcuXud7v/0HOFufpdsZ\n8MH/9DucXjjC6eXjRJ0ud3q7LPgZxxfn2Vy/g6h4nD17N5u37jDvVYlJyCyBaZlYpkSkGY7j4Scp\niWVw+tRJXrz4HEdmHiWZnkOAcOhjSAOkhSEkxp6izxFjbr3q3kzj8TZI9/zsDcabiGM9ANnePC90\nRJk/niZL+iE1nWrUi26pFvpj8t0HwYZSaj/rlE4N5bTQwdSFuqtr2QNsWinTpoV1WxQ91Mhh5VVT\n4OUj45B3RBiGhGG4/z9wQCnrRVdIxf8TG3tCoAIfr1bl3rP3cv3mDe6//37WV66RpCkKiet51Cou\nlm2Tphmj0YhOZxuBIo4jarUKi4sLSCno9/uEYUCSJKyurJAHr7exHZsgHOF6FRSCMAqId1KCIMCy\nbWzTxHMqfOLTn+LR8+cwTAtDmpApDFMiDYGFiVIZURTu0wfSMFAyD3ylo5lpPJkQRTLkws1JTPCG\nBfV0ODoYC++04P9lE6+8GBT3H8Zd68gcJieoEPnBiOK+AqEfOXKEMAxZWFicKkdxNMCtVdju91Gm\nxJlpcvK+e7iztsX5Jx/GT3a5ufoc7ZlF+uEOgyil4boY0sFqzlA7fZJ+t48XCTZuvUTX36XqeKRZ\nk2A75nRtmYXGMmm9yc1On6RvcNw+x5BVdjc7NNptNmybyEkYBUP667e5/+4jPPamx1A1GzOUmJmB\nIfeWXzVuv23ZdDpd2u0FPNchTWMMx2Q36tMPO5x+4hGufe2r9G71cVo1WGxw5vTrufv15+htrnP5\nxUu0I6h2A5JKl6EI2VVDOlfXWO7ucOzYEtdjn1s3L9OwPOLAJxaKOFZke0gyDAI810WaBkGWYFZc\nHjv3CL//wQ/xjrd/69Q+N1QGGYTpHgVAAQT2YviTIASYhpXTLWmeFg8hMI08nEOaZcRJHjDLkJrP\nuBB7flp5Zx3GtxcyWFbauryWNyR1nlt3jCj+h8lzFQXlV363Tm+8Ekgpgxi9lOdCMV908HMYPamX\nV02B60pW94GG8aqaJAmu606srmVFoZscxfXis/0V0zTYWt/g3Llz/N4Hf58nnniC9myFWqVOnGTs\n7vYIRkMMaWCZJvOzs7iuTZyEdLtddnZ69Pt9sixH8QsLCzTrDeIkJPAD1tbX/l/m3jzYsuwq7/zt\nvc98xzfmy5dTZVZWZo1Zk1QSoAmNqFFrACEZEWAEmO42gQnb0RFtYUfTJhocwWTobsRgBMbYEkhI\nQsJCI5pAElKVSqpJlVU5VE4v8413PvPZu/8497x33stXQNiOEOefd4fz7r1nn73XXutb3/oW48mo\nNHoSAt/DdX1sy2U0HJae+WjE/Ow8o3DA1dUNjhw9BDrFkpVKYHXDDLY9TXrIckLrbdhod8KnfoN3\nIKdyXC1L1jxybpro9bHay2SpPOK6Ma4mZ3WP6ptv3XvZbyFV59Q/pzqq52ma7UrWSilxXZfxeIyU\nijwL951H0oS4jSZoydpgg4W5BbYmW+Rmguul9Mc+Td+wZFmshB7W/GlUBn5eYM10mTlynKfii9iu\nw20HfILMpthKcRsW7/zhH+TCE49iWZJX/cBbOLu6yZULK1i9jFkfPvBnH6OXGfDnuXLlLFYx4VB3\njv/rF34R3WkxHGiarg3swE1yO98g8FyPRqPB3OwMRue4jo8WGtd2CC3FzPISq5e6iNGEqDeisziL\nO9/hwOGDnP/YX7N17hLXnz3P/a9+DZicvEhJZc442qIdOzjr4LQ8jp08Tm8yobAcCm1ASIQWeI5D\ny22g8xzHd/F1BrYkHI1401u+n9/53d/mDfuMuSMUWGoqggW22aGeVhtvGE12YbtSSoQUGJ0jhcKS\nEmEptBBTPHkHH96GXsyO9kk1p+rRYH2O7VfwUuWL9hbHwW6xq7pd2dt8pdxTdjshZa3DzeJxQtws\nhb33nOp4PhZP5bzuvb7nO77tWih1Q2zM7u4clmWRpTu96Oo7WjXQdaqcVLt3QikESgjiNGVmZobc\nGF70wod49OuPcmRpDsf28Nwmrtuk1Wjguj6TMCbPQgaDPtpkuK7NwaUDuK6P1gVxFNPb2mB97QaO\n4+D7HouLC/ieT5LGxFlOpguG62sUWYHvBviOR7PRIM5iojThG088ycyBRZwiJ8szlAQ1ZYlUTX31\n9tiAoUBSaovXvYM6hlb3LqpkS32cgZtw62qCVHSm6ti7YOpeRMX5rp9fh8PqR31x7GWZ7PWiqoRV\nudgByutxXRfLdhhPO7zsPbLxBKKEQhpmXIczp06z3t8qDYQU3Lh+DaXHDMwY1WjimCa2pTFRH993\n8bTLAa/LyfkW54aX8AqfgzML3Hpkia9+4eMIO8OfnePi+ioXN9Y585Lb6V8+x4FrXX755/4dX7v0\nLE9trrA1WKdjzfKPvu/NBI1ZEuGz1HSJ+jcwntq+n1UkxVROOI3LVn6tdhfPD9BpxmQ0ZrzRZ/bo\nQU7eeRef+eMP0nYcYvMcL7rlNj7yH9/Hi9tHUMMI37FYmWzhygbXV1foDdaJ0gHx6oQXzN3LDIa1\nSxdxlxZYH/dwbZ/AblCkBRKBMmVeKQ9jbE+RpynKGPq9Ma983f8E7/kvN425MIo006TKYEQpCSGE\ngDyj6jpjMKV2fFb2gbRtG0tYCG0w0mCQaCPQRpOlGUaUlL1tiM7cbJT3zrG93m59btej0/0M/n4F\nN3Uncccj3908vX5Ujma19ixrNx13r1Oz97295wkhththVL/r7zLi39ZCnjqeWseMKg9sh+kApYda\n/e8eFsV2gUQNa9Jltt9gCHy/rHyS8H1veQu/9du/zcte/IKSWTKMGI02aLfnkXg0g8aUlKHJdcpw\n1CfSKa6b4Ng2tmMxP18mMQeDPv1+D6FLMXfP8/AbPtK2CRyP0WCMzjOyIiOODcqzmZ2dJ+i0+OP3\nf4Cf+KEfRGXJ9qQXotQfllIgkOxAkPvzoevYWXWjdzRlbtYK34/KtR+EUn/+t2GC9d9S97Crc8ti\nhRIXreAcY3YL9lcejpRWjSssS3U5WWA7LoXWdDoz+84jK0qJx+toJWgvHaQIDbluEMwtMNQe/rUv\nkEQ5G6JBoRUUQ4yVEBYJXrvDpcEWW/2rHJ1t4YeSqNBsRBusP3GFmabLbUeOkfSgq7o8/Ncf492/\n+qu86r57eeXSnRBkWIHgxSfv5tMf/wBv+J/fxu0PPEjmQlZsYmcunlQkUiGmokjosrpUF6V4fxSF\nXL1yhcUDGZ7rkirYjIZECh6/epUiS/BO3sLGhavEF1cIHn6MF9x1L5lj0YtDxuR8c+UiQkK4vkFR\nJCQiZuy7XB9vcGL2BEWa8dhjj7ElwbF9fL+FpVza7Rl8N0Cbgk67yWTUoyhyMgSt2QWS55GUzbTB\nSIGybZASJXZyU2XOycGyFGmWbLcXLJkrBcqUazNNS40TxFQmQyiU0Mgpw0UXBZmpPOTKky7ndVmQ\nVq2LncYNO966QYidSLycm/W5vDuRX/9b542X37lTTbzjyJSJ2Dr0Uj7mpnVRt2d16KVeiV7//vqm\n8A/aA9994TuP68aheq9ecloPUfYaoOoQZscHlZTcnSLP8QIfy7F54P77+eojj7B88Agz3Xlm5wIw\nil6vx2g0oqBs/dTuNLBsm0bTn0IK5aJLp+FXu91iYXaWoBGgtabf77O+vs4kipBG0mm1mJstDY9l\nO4yiCZMkIQgauI7LU2ef4fTxYyih8AKPKBxjb4sIVcoZEgSIPRtcNUaO49SMY2XQ2TaM9QlUH/u9\n4wk751dhcPVa/X+q1/b+7/6ekd7l5ezge3rXIip/946XlGUZhjI3ACVfzhj0HQAAIABJREFUWj2v\nJkSO0wgYJhnDVPPIk88wyDULR3L6ozEL0SpHgw6uLkil5rq2eS4KiG2X5c4cgejj3jJLfvReVp74\nCxqO4NjxZRaXFhhu9Hnu/DUWLIf1r32eX3jn95P98Bv41f/7l1jvrHH+0bOIxQdZNBbKEbzmLa/l\n0kYf6YPJJmQ6ohCzFGaq80JpwI0BgSDwfMbjEb2tATdu3OCJxx/HWZxhPB4z22ghGz6ZMCyfuZvl\nuUMMLl9jtNJnc2aTD55/hCPHDrPQWGBMjrAFw7VVdBwh7YJRWvDZx/+GXBhOHTjGnUGbs70Nmm4T\nr+FDo8Gl9etcWVun2WySxQkN2+bEocNI5XLh/CW0tb8B8VszTJKYPC8oTFFWmlJgWzbCsikkGCQZ\nAqRFxc7IdYGHLKNJyyr56NMu7UYXpHFSFuJIWeaUonQqx1DmovJ8Jxlfcb4rjnlpL4qpw7Azzyvj\nXxrOHRphNdfqxrY+p6u1VBTZrnlefWY1f+vQZHXuftHmXoNcX8d7oaDn89r3O/5BtFSr46b15+X7\ndYW7ko+51+hUHmd1LyR7Qi0psS0LiSCJYk6fOsWffOCbPPjC7+T61eu4Tkqr0WVmps3igXniKCHJ\nEgpdMB5NiKOQRiPAsiziOCZNE/K8YDwaoqZYred5BIHP4VYTgyBLM8ajMePJGKkkJHHJLpGCSRLx\n0P0v4C8/8ylOnThJrgvCOEVKC8u2KPIcozWYUmgfBLrQ6FrJ+zbVap/S5NLL3es13CxVUI1/nT5V\nffbenEJ9I3g+w733PhbFDjS2H05e34wdyybN06nmSdnaK8sypGMhlWQ83h8DfwaLUZwznOQsNzUz\n2YB8eJW8eIpG3OOCbGOiLdqDNTaziK8Xszw+OUbbDWgVj3Lb7CrXNlKevujSbWSsrfVpbUg2V59D\nyAmzS7OIYJGvbwLXUsT4WX7qn7wK/+A51odn+MsvtXn0kU3+5b/+RS71VylsH11IBAFaCQqvgTYT\npJBQ3YtpaPXss88iDJw5cwYhFc1Gk2EypnX8Vg4vHmTu4EH8mQ4NN6CDwxc+8BE+82cfIeuHdObm\nePB1r2bmyEGQksSkPPvs0/zFn7wXr8jwA4eQjL9+/GFGV25w9623c9/cAv0kIRn0OH7bce570f0M\nhcEoB1MYrMzQUh5CWEwMZPp5pEz9sppzNOjjegG5zEr8PS4V+ZI0AqDVauAGwdS50EjbwhQavX3f\nC4q8KGmEUuJ4Fo7nlYa40Hiet91irK6hUs/d1D3m+jzbBa3WEoN1ymp9Du6d8zv4/e75XX5/Kci1\nbV+25/T+RW31pP5e6Yv6WoCbqYx/1/FtZaEAu7CnvZBA6Y2ltXBpx5Or47bV+bZdCqIrsZtfWaQZ\nrueiTemaz8/Oceb+B/jSl7/CC1/4EHmaEyUT1m9cpNls43ke3e4s7e7MNMwdkWYp4/GILMsIgoBO\nx6PdbE4xYc14POb8+WukucZ1XNqdDt1uF9d1y4rO4YD+cIsoilCWg+25vOIVr+Rd/+bn+He/8PM4\nUoDOiOMIW5W8WCVk2aMQgRYao3eaE1cTpRKyr9/wcoLlu/C/MhzcXYFWjXG9+06ddlhN7rqSWx3X\nrmOHe41yeYhd97c6vw6hVL8tiRMKiulCNSWfvyhI86yMKJ5nqn4ttMm1h+MHRMOIOx3N6TlDN76A\nY1b5yDNLPC0WOHP65SQyZrCxwrIlEeGAp85dILhdcmrBwYm+Ss/PuZCPmDhLHGrPMZskHF1e5MNP\nab7EYX75feu8WF3nV1/ikLSvMeOfxNcS11ris3/zDD/5T7+P6+eewc4LctVgkMVYrsY2GjPlsiul\nEKpsYfb1R7+OZVlceu455hcXWF9f5fCth/FbDrGJIM8xSUY/GbCZF7zoja/lysYKwzTj//i5f0Pq\n2Wz1+ywvHGSYhRw4cRRLGj713veSjEMSk2Eri7Mrz6F1zrETxzh96jRXNjb41pe/yKH+HXSOH8fu\ndIlzjZIeBQo0OMrabu6w9wi1IIw1nttBAJbj40gxlQQuW7LZtmJra4Ozz1xmOByyuLjIzGyHwPLI\nixwpDFJaOK6HkqXqX5pnGFNgCQvLEaRpTjDdAKqGv/UkY9UQYS+FtW6Mq/Oq52XbspudwL3Gfy/r\nre6tV6/fDGfu36S57uRUv7me86k7ZHu/7+/igYu/r6v+P/IQQpi//uxHd5XM1w1APXud5/H2gNVD\nm/pN28Fn/RLg2s5mlwNg2zZJliKVQiqFkJLCc3jP772HUydPcvDAAdxpkiWJ07KaDEEQNImznCDw\ncJwdrqsxBlOUfe2MKWGMChsWqLKjSxQRZym2YyOVwvM8XNelmHrMk0nI6laf7sIia9ev8cqXfRcm\nTzBJhBJiSiOchmuURlnXsvLVeO3t0FOO504hzG72x/4qbPWJWXkZe2Vq9074vXBO9Vm7eeJmW5ui\nvknsFxFIYyGsalPI0KLUYA+jhGajzWiS8oKHvuumuXTy9T9DGKVkkxArGTFnjTk1azg+kzFjx2zO\nnea5G5or4xa9FJyix1EnpaEUT69u0Z0LeMlcyEM8xyVsImaI6KLznIOupoFN2DjJheA4W1HEXcUq\nb/IHtB9cp9mdISwO8anzLb52o82L73uQFx3M6VrrRM2ANeFhbB/LpEhjkEiEEdPCFcnWVo+nv3WW\npaWD5HmpVqhlQiYyokmCiMGTPldHfbaKlCxLOdadY9YLUK6i0Ba+06AQ0Ow28QKLpiv51Pvfx+a5\nZ+g4LoNoQigNWIZO4HLHsVs5deQE0TAiysGbX6R79DjN5aMYt8FwkiAtC8exKOKMe86cvmnMP/+N\np1CFwc4NSii04yJVxa+ujJdGKoGYJuYFMBwOKPKYMIxYOrCA7zlcu3IJx7bwPQclQRc5ejqnfWtn\n099P26Q+5/erc6gb+8pWlLRae9e5e52V6rzyu3ZDteXnlAnour0q5/X+trS+Rvc6Mc/ngdfX2j0P\nfjfG7E/K/7YmMZ/Pe6uD/UkS3WREqlAEdlMOs6w0vJZSJT4mFSgLIQWtRpM4TUrjrQvSLOMlL38Z\nf/Hnf85b3/xmnCk8MjPbptnokOeaKEzY7F/nypXncByHIAhoNBp02m2Cho/nzRDHMf1+n62tLSzL\not3q4Lke7VYLo8qmD1u9Hpcvr5ZFSsqi02qxOL9AZ+4A66MRG1s9Vlauc2CuS+AHFFmKFOVC14Ap\nNLkptuEkqNOc9stmlwa/jmlXk7w6qs9RquzZtxPxlML4nufVcMAdSUzY2cT24+bvhJkGpfbQyGpe\nSZm1361BEY9jhIRGIyDJEyxLMTc3R55rlpcP7juPZrSgbTlEjsUwdRmYeR4fap7ohTQbis7lT2MB\nca9gYp1m6B4iG+e85MxxDroHefzpq4yfGdC+rcsLX3+azWdWefbRc+SdJSa3nuDq1nnmrvwxb16C\nWSfj+Kl76I0skq15FrxV7MYFTp9+CdmhV/PkV69zx50Jy8vX2Ag1y/e8jOtbIzwnIM9yTGFKGEVa\nWMpiYWGBA4tLRFGE47hobZB6gpQGZTkwzGngkTUD1j1D7iisSYIdxownI+JJzsWrq5y/cZUPffiD\n6CTEdQx33nqYRQ2NQoHlMfRyrqVbNOIR/adHjNY2WLLbzDbnmG8tEF5ZxbhdGkdmKRoObhBw6eI5\nbj10dN8xl46LyjQ6SYjiCOMKbMfBUDX1haARIIQgy2LStKDVatHuOGR5iN/MUa4LluLW03cSeB4r\n1y5x9fIlpNAsLCzQbAbkk/Guwr4KLqzPpcoWVPS7ugOYZdk2a6ruBE6mjKb97EplxKvcklI7kWaW\nZVOPf6exSX0jsazdjbvreH2dHlt57/tFrdWa+PsmMv9OD1wI8R7ge4E1Y8w909d+DvgJYH162ruM\nMX8xfe9fAT9GWc3+z4wxn9znM82XPveR7cVu2/a2GE1954H9NVOqwalXCVYDUheS30le3Mw/DrTD\nRGh+9wPvxW01uf3oCdrapeH5OK0GozTFUhYNy0U5FpZjb2NuvV5v23halkWj0UBKSZqm5Hm6/Rvq\nN833ffI8J01T4jguf7dRjCZjfM/hr/7qs7zjH72VViPAEoYiy3FdjyIrm1q4rgcl4WbHc5gaacsu\nfxvTMFbnORJNicqZKYUNbKv0PCQgdJnc1QbyQmJMTqlIUCCELjm7xpDnIKSNUg6m0MhshJAOxnIo\nLJtMCwqdYymDMimOSqFIUGiMdjBQVtAag7AdbMsl1xJQSOlgTFnAkzkFnm2xcvUqF8+d58bqBoNR\nQlxILl6+QqvV4Q9/5zdump9n3vgzDCbjkoqWG0SmsbSgE7QZbvVJ/Ii80KAcbNulyFNUEXKgJVlu\nGczgCsdmHWYaipW0B2HKA0dP0hqE6LUttG+z5gaErVn8RoNbZl2OdeFQZ4vWgTFNW2GNOwhvlpWh\nxGGelgePXF1l3buLUw+8GmVN8FKNUhmjICQWHgEB5AOEzHG1hdHQtxyktmlKB6M1uiiwpiXpFT1U\nUxbhKKWwRYAtJegR5889w+//7h9x6fwN5ma73HPmOIPhCrbj8uSTF0mlhwhcjnTbLNoWdhzSCTzu\nvvc+mgvLPHb+GlZnEdwWR47fwt33nSbNMm47dftNY/71b5wly1J832c0npDogsBvIoQgTVKEsKYl\n8Yq8yGg2S4ZWmmfouOx25fs+aZaR6wzXLTu9N9tNjCno9fpsbKzTbhYkSYw2Bc2mj5QChQGdYQFC\n56A1Skp0aiOkJM8zHM8hiiNc1y4rO800WqakzHrCpqjYQEKWj025uWpdoATIqZqpQe6yLVXStNIC\nrx9Vk4Y6JFP38Ku/e6VjK5u2V5GwOu66/+X/XR747wP/D/CH9d8K/Kox5lfrJwoh7gTeDtwJHAI+\nLYQ4ZUpxjj0Xu9uT3Js0qx5XJdbTz9+1o9WlJStjXeeUVzuZbe8Y3+pc17URAt7xtrfzy7/+73ng\n1F1YWiItVcrKjkekSVZ26VYSzyuLLhynbDbrui5RFDEYDJhMJnieR6fTYWFhHiHYfn0ymWxvNo1G\ng7m5OZrN5rTYISUIFlldW+EFL3iIj3z0Y7z9bW+lQNNutinyHKn0tNGEg8aQFzlFYaad0CSWskCA\nsncy8VJJlFAYUTJyFGXerMiLaSZBIpScKu5qhIwRWsN0UkphkWUFujBYysKSZWJVaw1+m1bDp7e5\njq8cVJ5iOQ4aSSYdUtUCzyVodkiiaZcek5GmCUkakRcZQmpyXTAZrLOxuUkYThiMXOJwwjcefpgw\nDEkzg+M1sLw2wl1kZRDvnUIAFLmNMH5Z9ScLomSA7UhaM4JTd5zGUR7rm1ucu3CFNAEpPAyKQViQ\nJSky67I+nLAw47Ka3sZ4WLAatXjtqQ4teYNhf5MsPchhXzArL3BCJ7R7Ln6yhPAKhm4IicFrFMSN\nlEBsoMIRhxp3snKjydVzj3Hy1J1oVzOOh7TwMGmMZh4rn8GyniOyMoriCI0YUBNyXSaxjS62i1mk\nnC5yo8HkGFOQmpjRJCbwJMdPnuLt7/hBfukXfoX1jTUuX7I5sNRhc3MT17JJDIyjmPbx44w2V+nY\nisySpJZg/ugyb/mO7+QXf+O3ePjxs9x++x186Wvz3HffA9y2z5gbk6GUIElC2i2fTGuWDx5kdXUN\nR7plUxRjqDruRNGEcByDAaUcbNsiyyMajQbrWyO0TtFGkxcxQgoaDY8gOMxc10UpSRiFPPvsWdI0\nYXFuBkvZFGlCnuR0Wi0G/QHtVkAcxeQ6RWqBkJBPq5AtYSOcqcaOFJii8n5rzJLta5NTAw6gEXIn\nSiyKgiiKAIHn+ds2qjLaaboD99bzVHVnrrJtddtVx96r3/P3xcD/TgNujPmiEOKWfd7ab0d4E/Be\nY0wGPCeEOAc8BHxl74lVaFSF7NXOVvveXZnj6rX6brjX6NcFb6pEZ91ThlrlX15QGINC8+qXvYyz\nZ7/FS1/8EjZurJHHGYcPHcJybIyUaG0Yj8eMx2M2NtaxbQfHcaZGvexgL0SZULx06RJQed0B8/PB\ndnInjmOuXLlKUZTetWU7ODYsLhxgY3Od2fkDPHPhEqdOnmAYxegsxZt2HBqHY4RdTUKJrer0qRLn\nr8IuJVWpFKfLZKDGYLTBsu1dOYLSx9AImZfMAAxSWAgUgd8gS0uOuqDAsQUoi562EFmG41nYJsG3\nNZOwz2ovZiO2OLsy4PzKgEGYE0XjHXyR6UQ1GiFL5TolyxDVUhZYTeIwRLRP0JqxieKU3CgSU/5v\n4Ub7zk8lPQLPJU5i0mRMs9UiT3vMH+6Q6xFWnKHjCRQxwlhoYZNkECEJHR8lbGZmjhHNdTnlD1mf\nFJy7dIn5NY+XLB7iqNtjZT1i9foWA79D1Otx3N4kb80i7Qi/Ca04AZ3gdjTYK6iZMcPJGVqH3sxX\nn/ogB+aewmodJmjcihqvM6tyhiLEkpIgb+HplNikuEVOKgoSNQ3HhQPaTJ2VDKaVfqrKi0hNoxOU\nMCOS2+++m+96+XfymU9+ikkUAwdIE0ma5kRZjN1qMxiNuOXgMsPVqzQdG6/b5svffJjHPvinfP3p\nc/SShCfPPcX1a02OHDm275gfPXYEpSSWkuRpihCSyXjE8uIsWZptc/pHoyGWsGn5Np7vlc1Psnw7\nsbixucLMzAzD0YDuTIcwjHBslzSNmJufYzgYlTRCYXH7qTPkRcblS89BkWIrheu0GUcav7FAmPZw\nPBtl/NJpm0JSxpTMNbsyirkGVcpNa1MSBRBT5pMxpacz9cQxlBHb1CDbtj2lE5efWY/8YXcHqjrs\nWEJJ2bbBrtZt5WVXDcTrUAvcLHa13/Hfg4H/tBDiR4CHgX9pjOkDy+w21lcpPfGbjgrPqrzTCseu\njnoYUU9qVka8So7VcdjKk68Pwu4k3k54YzkOMtc0lMND997Hex77Q85efIZbjx5HJBlFHCEkXN9a\nZ6Y7SxD4tNsttC47mY/HY8JwzHhcik8FQQCAUtaUuRIRx+n2tXS7XXzf58CBpe1rDccThOUwmYTM\nLyxhez6f+PSnaXW7HFxcpNNqEg76eI6FzhXUMtRpmqKNQU538HybemgopEJPKXyoqlCi9DKMKAsd\npqNcjpOWiCmsgVRoA1EWYVsSyxJokyEsg7RsHO0RRmMWuh2efPQRpBScOHkHbdfhg+//OJuRRWwa\ntGeXsfz1MiFsLCQWRkvyVGP0TgQmEWgNcRKj7BmM1kySjDAV2I6HcpyyAUbxPJS2PMZWHlFeYEkb\niebEidt47rlLSJnTMAHrWz0m6QSjXFAejU6DQhss20HZio04ZvPGJtK6waGDbY7ePsfKhWs8Z5rM\nzhhOLMc8Moj4Uv8IyWiWF830ObQe48Q5x5dmOKUCsmxImnVxmzbOIZsJDp9/4gbXEotm+A2KsMfj\nmze4/8zdWLlFK9BMTI+YDsrkoDYYmQAhHYTIKPICPZV0LXQpUGa0KesBEGgMcTLBdh0syyNJCnzH\n4p0/+aPMzLX5i49+ku9cPsn6xohGOyUeDknGIdlghGiXNMADi0toDcPhmG+dfZpmo4sddMhTze23\n38HSweV9h1wIw7Vrl2k1AlzH4fq1a6yvb3DnnXfhBw08z2U0GrO8vIgu9HSDMWRJhO06uE5AnCYs\nLNxKr9/n6OFlwiii3QxACALbI0sTGn6TySSi0WyQpSl5AYeWjxP4PkWWohBcW7nGKEwJWi45ZcMM\npMKybGRhtj1rOR0zRGmcSzpyuQa0KcvjpZQIozCm2GZ/obNtQ70Dn4htwa26gc3zbNvW1N+r11RU\na3cvAaOOOuwtzPvbjv9WA/5u4N9OH/888CvAjz/PufuC7KW2yFTUZ6q7UTfGdZyoTnfbq40Au/nM\ne3e3yvuuzhGibDA6yhMcJOkkxrJs3vzmN/Ebv/1bfP8b30y2NeLo0jJKuJw8dSuDrfK39nq97YTK\n7OzsNsVJ65JG2Ov1cByXRqNJt9ul2WwSxzFhGJIkCZubm9tY/8GDB3FsmzSJWZhf4OrKdZqzs7z2\n9W/gfe//U/7Jj72TKBzRcC3SLC27ueQaKUp2ilKgjJhK0k69gUrEygjcSoyqpJEDhiSMSrhFyWmI\nV3ogqmhMK39AKEluChCQSU2SRgihcZRNHsWgBStXr/OtsyH3PfCdfP2Jp/m1n383UQrHb72TNCmY\n6bpsXDmPP9vCUjZKOihhARK88nvSNCbOYyxLYdkKPS5xUy0EljQ0PLtsP2cMrpJId39p02hyg5mZ\nJdq+pNCKfj/i61/9BktL84wnY+yGIhcubtdHSEmWFygLFIKiiEmjAqUstDY8Pj5FcnmLl5/w6R4q\nGKQbrCBZLGKWm0OuF1t8ddDlg1cP0kwT1KbHbRdHfN9yzm0HDYI2MmzQ33yC7ozhi1/5I04+dBw3\nS7D0ExTFSX7pj8f84NveyHz6DMZO6dkaowzKWBRKYecGuwqSCo2yFHmWoyyrxFi1YUomwnVsLCWI\nw5xOa444GlCYjDf/wPcznhi81jzaauB34a7lg+SjmAMzHYrhmMMLSxRxTjiKuHThMq7wKbTi6JET\nvO3tP8SD9z3A1ZXr+475+fPnmemWMGIJRRruv//e8v5iiOII2y6hhySJpswrzdziAv3RmM3NNRYX\nF0mTiNnZGZI4odstm6QMRyM8x0UbjYOLNxcQx3GZ4BUWtm0ThqV2vHJcbjt9F1obvvH4X+K5ZRm6\nJSVpbkpY0BgkBkzpUUspkJYqheQoa0cUU9lZrRGypHgKU9kivSva39EacnYZ3fK13dDHXi2Uvd70\nXjtVN957HdDnO/6bDLgxZq16LIT4D8BHp0+vAUdqpx6evnbT8b73f2Tb+N1/393cd+auXYyHela2\nIvNXF7pfuFENWFWdVTU7rg9odSPiOEZ4JTamitLILR84wJve/CbOnj3LG17+apLhmCxL2Vq5iqcC\nXNtDGAPakOcZRZYThxG+7+O6Dp1Wm06rRZxkhJOQUZKUGKuUWFLSmZ1jcX6BwWBAFEVkSUqeJOR5\nTm9ri06nQ39aBXr7HXfx9DPPcOau20nyBMd30VmBq+wyuaXLFb69aUkJGmxlg5wWOWRpWUBENQkM\njcAny1N0UVAUpb44WmIbv2S4WAVCUZZTK42wLDZ7KeNxxMzsIoHXRqUJy4dv45tf+Ar/9TffR3vh\nEAfvfikSSTYZoxjQEBNaCxabyG1hLiF1WbmHRjk20pGITCA9hbQtutIHDOE4xBRFWdAjd4oeKl34\nvUcyWaNXTBDSxrF9mq6gc+gwr3vN6/jsZz/HpnGQMiNNYpQBW4IsQOcZ0ghs5WIyMCi2WgHn05DW\nlRu8+KSDGeQ8cVVw59xdHFZbvMJdwTRHfNm+nyezZRz7EMXgAuudMYdGIVL0CLMCu2XxzNnP0WnO\nojc7JFmbQ0c2OdPVPDE+zR9+8RLvfNMS7fQ8rumRZ5KmZVHoq0Sph3DnabY6JEmCMRoKMIgyb1FR\n1gBLaookw5MBaZRS5AYtBIWQ/ORP/zM++5mv0E9Sch2SZxMOuD5JOKTpltoyc0tL9IYhW1sTXvXK\n13Pfi16C35wBIblw4QpRnOw75u12h4W5BXzf4aknn+TQ8mGSJMcLAjKtKXVeDKNwgGs7oBRJlFHk\n4DoeMzMWeV42BQ7HYZngn0pdtBpNbMsmy3PIDbYSuK0GpuETxsk2RJrnOeMwZByGIOD4iXuQAsbj\nEf2tLXSR0m21KPIEdCnbrHWBFIY401hWiSYWucbostmFEGWTlR0YRSPUbknY0giLXQ5hZYuqSszK\n2axqVfaySerFPHsNtlKKrz38Db72yDf+x7BQAKYY+EdrLJSDxpjr08f/HHihMeYd0yTmf6HEvQ8B\nnwZOmj1fUrFQKhJ+XdZxL62wMt71waozTxzHwbIsNjY2WFhYYDKZbHvJURQhpcRxHIqi2MatLcvi\nmSsXmG/PMOe38QOfRMKYnL/8zGfxjeTYwUO0Ox3cTpvB1gRb2WURjlK4rrvd3HgymTAcDknTdNoY\nubXD+S4KJpMxcVx6361Ws2zNNoVciizl+o3rGCGJi4JcG/xWg9W1NS6cO8trX/3dHF4+QJ7G6CSl\n7TWI43g7sauUIsuyXeX0UGFx5fuTyWT7fGmp7SjFCMjyHNdyEZmNUQWTZIIKFP1wwtPnLqKFR6F9\nwglo7TIehbTsiH6ccWVtROfgMXACwjQnnQxQeUgx3CQdbTLXbiBmD6JR5LnBdgK0tkgLQZwbjLLJ\njGASJyjXxUuGmKkKne/6FBrSooTK0Bkmi/jwb/6Lm+bmT/3rX2Ort87m1ib9wYje1hglPU4cP8X1\n6+sMTUAUhlgSijxD6AJd5NMeiqWxUbYLBvpOiqVS/OgKD7Qj7j8wSx7bxFtDTrDJYX/IqtPiy85J\nwqigO3eKojfiYNHHs2N0N+WBky7zbPHlsxd5eK1Bp/FK/sXbZrh15hzCafBI/7v5r5sv4snNS/zT\nt97CYrTKjPTRJiQyCR//9MN87vNfodlscObMPdx5550cPXoMratilp3oKZ30WJifY2szAlyUC82O\nxxf+6q/58J99ku/93rfyx3/yXoyIGN64yJLvMtvu4CqLRqPJKMk4fvtd3P/il/LQS7+bi5dXSTPK\nsej3uOfM3Rw40L5pzK+trDMaDli9scLp06cQEoJGm/5whB8EaF3q41uWxWQ8ptNuY0lJHMW4DZ8g\nCDj37Dluu+0E66sbBEHJUsmyjDRNcWyboNEgTUIaDZ8kyYjjGCksXL/sLzqJ4tIzp6zIlJRsNtdx\naAYeV648x6VL5+m2AhpNB0xKUaQ4tiTLd1hvnuOSpSm6qKLbaXgz7XIvbbY3jHourdhT5FQ6ljvy\nt3WPunpeP7feCBx2YOIKDq1z0+976NXPy0L5+9AI3wu8HJgHVoH/E3gFcF95q7kI/C/GmNXp+e+i\npBHmwM8YYz6xz2eaL37mQ7t2r3p4Ud+N9r5e7VjVRdYHoM5Prt6gTUDoAAAgAElEQVS3bXvb665o\nQEVRkJiCtt9ATptE5BJyS7C6vsEnPvZxXv6SlzLT6TAJQxy7iS7YBd9U3n+9MWmdpF/xU13XRQix\nXZFZJTMALKXQRmO7LsqyCZOYJMsYjAZIKXjiicd5zatfWdKwhICk1IZI0/JvXuRYlk1e5Agpt7+r\nunbHKbvx2LZNmk6TKEpuN4YojCZPcyajCL/lE+cpmTA0urMIK+DDH/4koxEkoUWaKBzXx9hDkrzg\n0JHjrG8OaLTaJEmKMDmBAzodk0YjkmiEzkKSOKPZbJcestvAclpg+WQ4xKkkFwotFJkIydOELI5x\nbZs4TlGOT65LHZs8jfnEu3/6pvn50Pf8BFk+JElGuK7D6o01PLeJEBaWcklTWTZTmIa3JVQkQFjk\nGoxQSNslyzSBtkgcjWVFzGSb3L/oc6wLM05Ia3ID2b+BcVzCuSVuS4cMOcBlcZinRk2+tJIRNVJu\nbU+4PS845AzQ+QVmgiW+71X34s/lTJoRwjnFf/7yGT56/RTM9JlNvskx1ce3Fd2ZOxmsnef61ScR\nUjA3P19Ge7ogSRI6nQ7dTpfA9wh8n27TpdNscvz4Kf7ma49w+doVHn/yMTb7fdbW+pw5cz8rK9fQ\nJsWRMQ1HE08iZruzFBpaM/P82P/2U/jtWYLWHAaF7/lsrfdoegF5oTl9+uYU1rVrN7hxY5XlgwdQ\nStJstdjY6tPudNjqD2i2O+U6EIZoEuE5DmrqdDlTpyfwfbTOyLJy/fmey2QSsrS0wOqNDfr9TbI8\nJGgEzM0ulFRdIVDKJskypBQYIUmzDCkVSVwQRxFKSvIso90J0EXBoL/OYLhOmkzwA5s8T9B5WQXp\n2FZJuRWCIi83dbldpFOtkXwb1t2J5iu5it3OpFK76x3qtqzuwdcRhrqXXX3WXmf1byvk+TZWYv7Z\nTQa48iL3Et/rHO7qgivjBNBoNHj88ce59957ieN4u+xWa102VJjCKfX/j7MUKSRFVpYbW5aF5XkI\nz2G9t8V//qM/4sd+6EcYb/XJitLozc6UwlVQ3pCrV69uZ5VL77tBp1NO3rW1NQaDAWmakiQJrVZr\n2sknwFIWhS62f3+WZWXI5dl4ngdSsrq2xmA85tz583z/234ADxBxVG5KlkVaFDiug1SS0WRCp9sl\nmUIylu2QpkXp1aQp9rStmmU5SEtx9doK/VGZ4dcGFpaPAJIbmxts9sc89a1n2OyNGfQjlg4coUgg\n8JtoJD09QgpJK2jR8BqE4zG+45KmKYXJ0FKTpDFRHOL2rjKejFBKE4ZjpBKkeUZ3bpGZhSWcoEOm\nIUlz1lnENpBMRsx02pjCYHsNtHTIp574e//tD9w0l17xtp8liXoYEzGZDHCm1XutVptxGGHGQ4yQ\nWLbNKAwxUrFwYBnL9dnqD4mTjDjOKAwYW5eslTBBSYGtCg75GQ/MaW6fSXHEgDBMGQxy+vYsHa+D\nZbfpqyNc0Qe4EI145vK3aMeK1x6zuI1HuPuQg3v4Aa4evIvNuVN4meLUkfv4lfdfZKNzF3HyNNba\nV5ErV7ljvsl4fAlUQV4UtDptMIZRGJZdojodAMbDEWmS4FoCQUGSJWSFptHosLHZI45jPNfFsgR5\nlqGERa5D3EAwGY2Jo4R3vetnWVnb4FOf/zz/+7/6WVbXepw8cQqTaxxp8D2f6zfWufeeUzeN+cc/\n/kkOHVrm8KFlfM8lL2ASJRghcFyXrNCMxyW11rUUo8EA3/VoBD5pnuP7PmEYsrGxzpHDh6cMpYIP\nfuhP+cQnPkG306G31QOVcePGDYos58SJW3njG9/Ea17zGhrNJlprtvoDut0Z0jzHlmUzFqNLIxgn\nMVIabFsiZNnc/JGvf42DBxdxLQdTFERRSKfZYDjoY1tTaHVaJbvNx1Z7dfatKaVztz0qCRT72jqy\nLNtGGipm3F5JisoW1kvsq+/9B2nAv/KFP9+VuKwupCqbrbzoOs5dHXXa4PTztnfILMtKI0gZ+nie\nt23YqpL3JEkg12glKYzGsRx0kpVetGsxkZpPffpT+Fpy+/Ix/M4sytlpNFxpGbiuux0hVDchzzNc\n10MpOYUyyl6bZZFPzmQy2b4uIRWWbZetrTAUeXkOQpAB4yjl8soK/eGYV7/8pRya7WLZFlmWlypu\nxlBQdrORSqFFyb3tD4akiSZPM2ZmZ1lf3cD3GwghabRa9IdjpG3hej5hkrOykXLp8jW2+mPyAowW\n2JYiCYdEkx5FNmZxrk2URGSNBSxp03BbuMonTwxFrpGWjbAE/ckI27fLoolJjzQZs75+DSVSICPL\n4pLJKG06sweIU83s/AF08xAWmng4oOW5ZGlGkhlSY5EbRVoYPvjLP3rTXHrNj/4iRZogTIakwHUU\nnW6LOJ6QpDFWmhMlCUmW4fgeQbOFMYZJGIGQeI6DzksJ381iQNsIfCRhYdgYhcxIi07Y50BQkJsR\nSMNwa8jnx03uPhBw30KTXj/m+saE1f6IseMjGzZ3tQwnrAlzXZ/hwjG+vhKwnt+BFoZOc5VXvOp7\n+dI3Umj6LHcybjz8cbrJN9AotOwwHI1KYTNKZyWOIyylkAKUVKhpRfE4HBDGA06cuAXf7ZBGkKcZ\nppjQ8CUKRZFI/FaDftTn13/93/PENx/jzrvvJtUFTsPnd9/zHu44fQd333EXS3MLDEYjRtEE3w84\ndvhmJsqFixeY7bYREhSSPBPkusD2PHJT6vJPwlLTJ09yHKXQRblmMq3pdtsMBgNc1yPPUp566kme\nfPJJHNuiEQSAwXFtoiQiDiPW1ta4dvkKW1tbgGRmZoY3vOmNvPZ1ryObrkVdlJKxRguUpYiiMgoN\n4wjXczBCT9kzV8jCATrP8H0Xk2d4tsUkHJVqiqIs/y+F5EqYsW6fKuOqNbu85fK10sjXC3OAbVtW\nb0heQTh7S+rrSEJ1/j/IUvr9Or5UEEd1UTsDo286r/KwK2NYee5VCXhFlJ9MJtsCVJUBVUphG4VG\nl9KXAiwpsaUiMhqhJA++6CE+8Pv/iduXjuC5Hm6jsb259Pv9UqBqMMC27e0S+yAIMEYTxxGbm5vb\nkEtVrRkEPs1mY5qcKiskoyhBWQrXEqAVRZGT5gXDfg/HbXLrrbdx8fI1PvGpT/PWN3wPw+GQ2fm5\naekySNtiNJkQpymXLl+i1++xurrBaJggheR1r/0eFpaWKQpDu9WhNxiihY2yfZ4+/xwXLt9glM9T\nFBLXXYZUYwPoiE7HoRVoomhCll8lzyb0NiLmZw8wyQqasy2MEvhBg3EYE8cJrc4cURoyGA5x7BaL\nR48yc8tpAleQRhOMLmi3ZikKG4NPGGmSWKPtNVqeRyIysnCMbyvwPOJCERWCKN0/G58LiRYOFg6+\n53L48BKjcY/OTJswGuFqH0YjrDyn0AWFtum0WnhuQpGk5EmEyQuUMJwW9zHSa2TeEM9KefDYYbqe\nZLZ7N82ZU4yygKWlWRy5wZsmIU98+WP0oz7hwWMstTrclzd47omnGYdn8c2YqHkrjwWHySZjbpcu\n36E2WWmlrDRbfO3LDzNvBUw2XVJcVDfE848iJxLfatDsdHE9b8osMkRRiO95GF3q8AggMyB8h1uX\nTqCkwGQOndYsOk7xnJTALej4LcKh5oGHvoMHX/5CPOHyuU/+Fffd8wKUpWm3ZnjDa76H3/6t32Tj\n0mXe+sY3lUShVpMo3r94qtn0SNKYTrtFf6tHw2sTtFqEcYxjO0RJgmfbYCBouggDaRzh2TaubXH5\n8mUOHlwizwsef/ybnDv3LCdPHqfVbCCEoN0u2VvKtjGFZjgYcHHpAlcuXS3X3WjIb/6//x+PPfYY\nP/KP/zGLBxZR0pRNo4VFnhW4blngZrsOaaZxXMjygsUDx2hYCVevXWFz7QadZplXch0HPTW4uiiN\ntzYVj3x3qb1l2VSJzN3aLGqXOmi9crwOpdQLF+uaQ3UcfC+d8PmObyuEMn18E7Zc7XQVvlyn2lSP\ndwkhbRtwa9cF1z+zwqir5x4WGigk5NKQ64IsS3CUTVFo3EbAn37oQyAtXvLQyzCFZjzq4zoK24JO\nuwmUwvZRnBEnGZMwRucJvudiWTa24xJFMZ3uLHGSMRyNsSynpENaNrooE2oGU3qLjk02Fbo3xpBm\nMYHr4/k+11c3+eRnv8APv+MdDAcDXvCCB9FZQZrlZLkhTjI+9ZnP0Zmd5wUveBHN9jzv/t3fwg0s\nHrjvbl505m7WnrvC0vwS41SSN7p87tGn2JxEFHmC1jkCjetYZGmKJSRFZhBakiYGSzoM+1sU6UWy\nImNp+Qhe0CErHHTuUxRlYUcU91AqIcsm3HPyDrI8L3U+jKbXHyKVTa41aZoTxgmtdgvHcQhHZQVi\nqx3g2DDorWIrTRpHZLlGS49fe9f/etNcevs/fzde4JKkCUHgMg4nOK5NGIUYrSmiIb7v47sOJs/o\n93p4rkOaxLheUPKqpyqBcVTioRLDLUcO02m3MHk6nY8wHI4QUyfhlsO3sLJymbXVFZTKiJMRpshw\nXJeVlTWCoItUPp7XINIFjueVSTIDpsiRxpTjLBVa52RxqSq5sOihlGZzfYMi1TiOj5IOUnoUWESp\nxnYbGGkj9ZDAKbn+S8uHcfyAOE2RgGtLjE55yxu/l8C1cRzBcDBmq7fFRz/yUX70nT/KJAxZXJzH\ncVwcR/IHf/Cf6PcH3HX33XRmZ/A8h3vvuvOmMb9y6SLzs3MUeU6SpGgEzXaLMEqI4xQvaJCmKcqy\naloiGa2gwWDQJ/ADpBDcuL7CF7/4Be66+87SDlhWqdSILJtFpCUuXeVx+v0+Fy5cYHV1leFwyKOP\nPsrrX/96fvzHfxzHc7edvZ2oveTQ1mEOgDDN8DyHyWTC1sYqUTgqIwRpStgpLSG0UsN9RzwujGOC\noEExpRtukytkSZ+URu/yqut6RVX0vuON7whm1aswK0e7jo0/8OLX/sODUL76Vx/bNtawQwOsKxTW\nOdz1ctOdndDaFXpU5PrqqJekwm7lL5FqkBJhS7QUU4lmjTQlNIGS9Ecj/sMf/Efe/sYfwLUctM6I\nogkCzWDQx7ItXN+n2eygEdv0vjzPy2TNeILfaJZJDwRZrhmNxsRJKbKTxBmWdEBA0PCJ4ghtynDe\nVorxeEwcRXQ7Hc48cD/tuTk+/KEPkoQhDzxwP77rcebMGQyS9fVNeoMxt50+xfpGD8fv8ju/93uE\n6YQsmXDqyBECIXnZd70Uy+9waWvMY89dY5Jp4iSj026RJBH/P3tvFmPZdt73/dba83DGqlNTd3X3\nHXgnXlIcREqGIpEaKFlEHCGRYweBjUgZESASkhdFGZ7jIAiSQInzYCcvNig5tmwlQpwAphRIDEVS\nA6/E+fKOPVbXcOY9jysPa5/Tp5uTX8JLA3cBja46VX266py9v/Wt//cfyjIn8LxuMAlSGJS5ltUX\neYbIH4JsWCcRH/7wh0jSmjxXFGmL5/mUZUa/5zIYBLRl2anitHptuVoThD1WUQxCMhiOyIucVmnu\nLlJycXGG75mItqQuEoa9gOU6YrB3xH/5H/4b37dr9N31nde9u3cI/YB+r09elOSlphumWUnTKiYH\nE/KOPRbHEa7jYNsWdV1hSVNbBAj4rU99ipfe+xJOx/HfFHAhDAzzcTvbDaTQNA3n5+fMZjO+/vWv\nc3Fxwcsvv8yv/se/AoitB/3m3n8k2BFsZotVq3SgedNgmYI8T7i8uCBJVtDWeI5DEkdYtoVtaKMs\nx3V0qlfXWVfdCb9VO0rxpnqMUbepU0+Go+j1uBHdhp5YFOVjjwkheP8P/9QPHoSyu/tsfH53O+XN\n50VRPKZa2jAsNsUeHhHkbVtj309Odnez9TYbQ9MxNxR0RyetxjKlSVUVGIbB/sEBZdvQltpQxzRN\ner0elm1zdOMpyrJisVxxNV+zcSgzTY+mVdx/cAfHdYE5tqON6U3bwbQspLDJ6gbX30e1Bk3dkJaS\nWhnYtokUgiRN6A+uc3Bg8/xzz3K1nHPtqX2ee+H93Ltzhz/4w8+xNxrzxVe+wi//8i8xnc4J+30u\nzy+xHZ+mafnABz7AV77+VUR/wJ2zC9okxfeHnD79LPcvpqRRjNsb4btj7ZnhWhzsX2O5nCGEiWXb\nNE1N3qQoBa2pGAwOqZuEloqvfOkLPHXrKSbDISrU+Kxtj7cbq+lbCGmT5QWmZeH7JnWd0g9dpGmy\nXFzSonAchygpqJuG4SDUAb+mSWsKsiRhGAZcnN37fl6e767vsoS0MCyHvG54eK797Iqqoj8Ycng0\nZjpfYVoWRZ5pXYZl4roOWdYyny0YDYZ8/Rtf5QMf+ID2AS+1XF0BspVboRJKF7/+YEASx9vT+I0b\nNxh1QrpXX32Vy8tLfuVXfoVf+7Vf4/T0lKIocF1/8yQdq2Q3klHiWCaN1JoHzw24cfMmX/nylzvY\nosTxA20+V1UoIE0z3Yh0sIbrdMPIpgudAehM7HYh390m0jCMLR1RqcdnfZt6ZprWY/XrezXY71gB\n3z3q7Bq7mDsvwgbo310beh48LrffGKXDI1hld5q7W9Cl1HmTrXhEsjcAo9VyWN91SaoSy7SYHB4Q\nxStOnnqWZRSjlCQrYBotqBtFUbbEGdBC00BSpBpzCyZYtk2SpkynMfvjfeKioEmLDhoyyMuStpHa\nJyVJuH79Oo5jEfoevuvqgmiaDMZ7lNLi7tmMxSpnMD7ipJXUZUGaxvzO//F/8oH3/xCB52E7DnGS\nUamGW7duMV/HXM6uGIxNYjXlz778FVrbZbpaczA5JCkLWmVgixbHMCmznLLQobRVU5BliR4CqRaU\nJEtqVGvg+z0so+Dq/G2ylY9nh7z4/A/RKJMyb5CmqTm0baNVlW2LZxs4nk8cJ6Bann3qlCzPSbOU\n0ahHVTesVzGe6+E7JpVQFNEKQ7Uc7w2/b9fmu+u7r6vZgm+8+jrXT2+glKLf69OzbK6mM6arNUVR\n4HkuJyfHJElEPJuTei5pmnK4p61iLctmvVxgmNovfBOFppTaJmoZlg1SEMXRY37gWZFjWiYn168R\npwlvvfUWzarmlT//IsfHR9391ezUDvHY36rtao1hdvWjpakU73v/+4miNefn5ywWc1zPwzWB+lHU\nmezgkrLrlLV9hVY3t+KRSRV8exXlo9r1iDa4C6Ps2jb/86x3rIDD47mYu5/vUnZ2DZt2VU27RfrR\nsODx54PHu/HN522r1YCbj4UA2baIRuFYDmmaoUyT6WKOGwRcXl6SRQmO30M6IVfLmEoZpFmBtCwM\nBI7tsFquKSqDg8MT5osFgTAI+gec3nqB+WqJ0bZkWUYcx5ob7hp4PY/BYICUUockRxVL1yKLYixT\ncHpywu17b3JwdMJg/4h1UhKvV4xHQ6bROQqL2WzFnXv3uHHtGqvlgqOTU3qDkIvbdymKCtUapEVD\n0Uqeef4FLmZX7B8cce/BHXw/pCFjMhqxWsU4tknoWFStwnEdsiyh3+uxipYURYnrhpRpTpxWONLG\nUDXRYonyGrJ4gVIWQW+EECatUNA0WLZJFKc0VUktJK5lUrctZw/u4nkelmEwvTxDCTiYXKOtG+YX\nl5we7rHfDxgP+yzXy+/HJfnu+udYYX9IXjQUtbaFffhwyipac3zthHSVcnA4oVUt33ztNeq6oipL\n9kZDnn32aWYXM77xjW/QCwIiYwVsKHia2aHaFkMnIFOXuoELgoCq0iyxjS2zZVlEUcTBwQHL5ZKq\nzviTP/ljhsMBP/nxnySKI8JgI0LaNHpdEyf1CdwwTAxpAAaYgihe0+uPCHtDsiznm998ldbQIc2O\n45CnGdI0qcuyc1vUGLsQOsjCMK3HYF3YPfE329nWJmtzw4rbQEOaWfcoOEZnHDwu+HlyvWMF/BF3\nUm7tXnf530+mrcOjHWt37VrIWpahPRPkbnrG4/6624FGd+xRSmEI7eAnJdRVhet4pG1Nv9cjz0ui\nWtOKskYSXa0RdkBSVpQ1mErgOR5FK3DCIa7wiNMSx+1xNVsQhg2rKOtEDDZNC54f4nQ8XWEKZosp\ndV3j2A5hP2S5mKNokC1UTcEzz95CWj6LxQrbcrl5ax/XdbEsmyyNEaohTUsWixUvv/wy6zgmjpbc\nvX0b1bT0e0OG/THiuGY8CPA8m7LIeOrG9c4jWXL//l2G4ZiDccjtew9pakWcZxwMh9A2OIZJf69H\nVYHjjPCNIbYqqdMVRluQJRGW4eB6AbWqMEztJ2F5HlmW0/MDAtfDtG2SJEM2Nbeu32C9XpHnBZNx\nj7oVxOs5prQ4vXaMbxkMQwdBTfAdvFDeXd//9Y1vvo5l29x7eM5oOEIqQd20PHx4TqMa5t+cMxzq\nSEFahaAhz3K+8IU/xbM9XnzhOb72ta92qks9xDU3Xi/ShLoGNB2wqmu+8MdfIElSmqbh6aef5umn\nnyJJUzzfw/Vcbt66yXR+wXyx4Etf/jLvffllJvsT3c2Lx0/wis5iWRoo1c3WpLYoGPRH2rfeEHiB\nyYvvfR+zizus12vMRoCUGKZJUzeapGBI7TPeKixTku0gBrski43x3i7TrmkejxXcfH0DGW9CJTaq\n8u+03tFQ483Os6tygke49WYYsCnQpmluZeObx54M9d2l4ABbkc0jvmaHS3Xe1w3VTpcusF0HpIFv\n2VSGxcOHZxw/8wLS8aiUQBha/KIUjEYjlNA2sUXV0DYNliHx/RDTkAT+EWEnOljHOlczS2P6/QHR\nesloPNJUK9cnSVLaRnF+doltmzimgxSKyf4hTQ1RtOBytmI0HDAYjkjTFMPyOLm2x2x6wcXFlNVi\nyfve+z7yvCDKcgwBP/5jP8adew+ZzueEYUASzTm/OmdvNKIqc6RowarpuYrJyKVM5wQ2UNcEgU+S\npown+7imzWw2xR/26Y/2WU/nrNcNQ3+P2cV9UCYIi6ptaNqalpqmMomiCN/3SdK1VrOahlZGGibx\naoVt2xjSoFExlimRlpZ5H+7vUacxRZ4zm55h2xb/6B//Ll4vYDwcMpvNtI/MYklRVKRpimlY+H7A\nwcGRtvr1A/JiSZZlpGnMfLmgKIptAEcvHDAYDlkuVpRlRdFIFnN9dI5jzV6hE5lYhk2apBRpzng8\n5uhoiG3bBGGPMq9plOLOnTukWYoQgjJP8AMXKQWn10+5mk5ZLFfkZYOSkiDsIQ0by3Kp85qr6ZyT\n4xMQOYahGSpFnuOYWm9gmzoRyjAs6qrFcTyEDWWTsl4sMERDHkfkeQqqoVUwW6y59cyzfPONN7h2\n/RaqlSB02lJTNxwfHeJaFqYpuXvnDrdu3aRpWpI4RSmJH3iUZcFv/Mb/wL/+1/8ah4eHuH6AIQ2i\ntbbujeOUMi8JQp+L6SVFWXB6eg3TNLl//z77e/s8uH+f48NDnnnmPdy/e5+3b9/j5o3r3LlzmyyN\nME0NSyilDaXqusGybJarFZ/97GeZTqcIIZjP57zy56/wwgsv8Au/8AvUdc16vSbs9djb26MoCr7w\nhS/w4//SjxOGIa7ja//0rqaIJxywBZ01787DEp2CJaWB5/kcn5wS9iLu3r2LFApDgmk5SFpq1aIQ\n2I7moe9SBneJGJvEq01HrZXZ9s5Mr9EECMRj9OofaBrhn3z2/wLYUms2w8zHyfKPGCrweCzSBjrZ\nSNM3viC7lJzu/3pMDCTQftpN3WjKkgCEwBKGtmKtWtwgIKkqSin4r//7/46//BM/hW1a2LZHmtdM\nFysct0etBEHYRyHwPJ9GKUQriNdRd4roFIhSJ/J4ntfJ+02yPEMKk3WU4Do+cZrhe75+01pFWxfc\nvHHKZG/EajVn/+CAqmkoqwbX97n/8IKirIijCNFqqbljGVR5ynhvyNPPP8Nrr9+mPzikrCDJdVxZ\nXReMhj1m8xkGgn7okcXnxHHGapWwWKVcu/4Ufm/MfLnGdjwQJqsoZm9/zLqYE68S+s6Q0A5oipzD\n/QG22WLZLWm6xu952nSrNjXlSgjW6zX7+xPW6zVSGvoY27aURdkdiUtM28X1Qr1B1g2ha1EVGeNh\nSN00lE2DMEzyNOlOVi1BEFJV2lJAIGmbhrpqSJKEsqroBwF1U+O4zvZm1iremjTNEUjSNMM0LKQl\nqJua6eyKycGEu3fvMJlMWMznHBxoBd94vE+R5cTrGU2rA6yjNME0LUajUYe/ttiWSVnk2lxpuSAv\nciZHRwz39snzCmnYLJdrVAPTqzmjwYhRf4jpNgjZYhpym2Rf1y112Wo+ddmQxBlZVhCMfPy+Q1vX\nmIYA1dJUFU1dUVba7KltoShL7p895Md/4uPM5jM8x+XgYIIhDbIkwXUdhoMB6/WqOxUbWJYNKF55\n5RW+9rWv8tOf+Gn6/QFB2CPLckzLJopiemFIvzfgajrF8z1aGtbrFZ7n4Fi62To9ucZ8PqeudBjJ\n5eVDbp6esF7NsExo20eEhKZRKCUQ0uCP//RPuLy83J6ioyhCCEGWZXziE5/ghRde2J7W79+/w1tv\nvcmdO3dxHJe/9V/9Lfr9DYTSnb7ZnLi/VTL5napg09Fr1+s189mUssi1EZroRHu2RdvZyGrk51GM\n2pMsk03sm/7a40PKzfdWVfNYfZNS8tIHfuIHj4WyKba7DJEnf/ENB3Q33QK+9UXaFfds1i5kspn8\nAlvWiWg1boXQtMFaB49h2Fr9BoIv/tkXOdg7QEhBkecI4Oa1a1w/miCEZL5YkWQxWVGSlGtapfBs\nl1HPwbFt7VNS94iiNVEck8fx9oL0XJcgHHLz5AjTclmvE/KioCxrEIqsKvjm175MfO0Y17FIHIOr\n2RQlDPrDfaoyJ04ypGEipIGhFIYUhOMJb91+nVJlBMEI2VZk64SyqvF7ATWKhxcXhEFIUzWcnV3h\nW+B5fVxvQMslbVsymz1kONLFxvUcTLOHKVt6ZsXx6RGidXBND1P0KYuIqq2osoqqKilzk7ZpKatc\nm3y5DoYpWa0XnaTfxFBm59diYlsGozBAWg6W4+F4LkkcMYcO+akAACAASURBVLs6px/43H/4gCAI\nMWwfIcD3dQpLHEeoVndmvuchpUEYBLiOQ+CNkVKQJhVlEXN2dsl4b0TY6+kEIVVw/fSQMq+J45Q7\nt2/j+wZZnvPCc8/x+huv47kOWRqhVM2gF5DECRfnD+gFAddO9AC2qEpq1ZIVOet4RZokWJbOvNwb\njvG9kHWUomTD/QfnvPHWXRYr3fH7fsDeaI9Rb0idr6lsyXodIU2B5/u4jrMdco3HE5I4xZES3/fJ\nshzbs1jFC0CQC4ijhLIs8DyPo4MJrl8iJbz99ltcOz6iLlJCz0EIqIocy/fp9UMc2yFJMwzDYjwe\nsFotSdOYui557bVv0O+H9Hs9XMeiyFMEAtsw2B+NSNOMe3fv4gYei8WUXi/AMg0EUBQFe6MRt9++\nw+HhIdiC+WJBr9enKDXTq25LUA1S6eKtbWMtLi8uuus0IC8KsiTh5No17t67hzQMXn3tNd7z3HP6\nFN40uK7XpdjrmVVV15RV3Q0fv7VQPrkE357xITBoWhgO93EcF9XWXF5eUOSZZkq1DYbjUOYFhnjU\nMO7GPW6JEh3bTj/2SMDzaBYntmjBk83rd1rvaKjx5u8NDLIp1k8avzyya3xEPXRdd/vxJnB0gxdt\nXpTN2o04gu6IUzUgJY3QeHgXEanZLEWB5/f5/Gf/iA9+9EfYH48RtCSrNVW6oOcHqKbhdN+najwM\n1wNpUTY1WVpQFgV1nSAaCxMY9x2eun6AYZqU5a3tYGaxWnB5OSWNtR+H6wYcT8b6dRB99vaHVEVG\nnqe01ZrAllieT6M0FBOGfeqq48ELgWVKlqslnuczX0yJVjH7oxMsaSIdE0MoBoMeffoslyuiVcrx\n4Q0cQ9E0NY1quH4jpKprnr9+jdu375AVCaZtEMUp/TCgZ4LVZAyGIa6jMybbQEuQi7xlMj4gTUo8\nL2CaTOn1Ndzjui7SkCRJg1KNVsG2NVXH3V/NFL3hkCROSIucXt/n6OiANFlz8+ZN8qJmFeeUWYUr\nWkxpMOgPGPQGXDs+RrUtZZHpMI1kTZIkKKXY2ztkcjBicjwmSROE2XJ+8QBpSO49uEtVVNRlw/HJ\nCYPAw7R1CPZHP/JhkiymrCru373L4eGEhWUw7A2YTqcs1gmz+RylWkb7Q5zAx3ZMxgf72rohr7l3\ndo7OXTRRwiPoDeiNDQbjA6q64MH9+0ijpd93OD1+ijSOsfyxNhmrKqpGBzmYhsU6WlCWNXXVCdaA\ntqg4PjziwfkFnheyWMZ8/Kd+js9//vNgOPi+ji97/pn3cHZ+RhpH1LU2f1J1TRJHOK5LGPQoipJe\nr8c6iqibBtOSlGWDaRm8/4deRgitMPZcHyEkaRIhpYllmhwdHZLlCY7dYx2t9HstdUGu6xrLtIhX\nMXGSoKSg1+uDKjr8WTxmjdy2igbBxfkFVVWRdq6GtqMpuJuT9oMHDzC6IHKE9sjv9/us1zHz+ZIv\nfenLfPxjH0cgUErbQ4AeYH7bLDGlvgVgAf2zSGlSljWeF9I0FUfHJ9y5/RZRkuO6Gj4RpolqHg0c\nnyy8Gxrho4bT+hbYV6lHyszvteFs1jvKA9/sQHVdP0Yf3MWQHMd5LMj4SYaJbdtbfuVmEPpkGMRG\ncr/7YthKJ9S0QumOuws+MCyTsNfj1dfeZLlc0vMD6rpA1TWWAbOLh/jHR13oQJ9SNGT5ikZaIE0C\nzyBwfYxuWBFHMVoNVhCvV/ieR5ZkiEYHAD//nkPiJEWhi2RZLPEchzheUBQthlTM5ndYXK2w7QG9\nkXYK7AUBqzTFtn2SJMM0BHGS4XoBhtWwTmL6gyGqrcnSDC/oIYUWVkwXK27deoYwaDClSdtK8irR\n1CvDoqlK3nr7TSaHB/hhoDm+MsAQcDjoEUU5si7Iqpyg71IUKY5rUZX6SJlFFXlaYlkGeZHiBzpP\ntCwLXHeE9od5lMzt+z7tMsJyHWohMOMVaZqQJksG/R5REtO0BmF/QFEpSNaUVUnbVhRZThprHHWy\nv4chdF6NEA2mYbJYnuP6HoZlISSsoxXhwCWKE1xfcnrjBgaSsqxYr9cYpkFe5NiuiR94mKbB6ek1\nzs7u0+/1ODt7wM0bN8gKC8f1yYqUKItQqsEoBbZlU5U1B5MjLNMjzwrOLubMlxGO5+D6LoYlmBwe\nc3xyxN6wTzSbcXn1AEsaFG1Di8QwtZeOkmxTl0yn0T7aSvOXi7zk3r17WLbHCy++hGF73H1wzsHR\nNYqyRDUlIk2IFgsc2+by4iGDwZBwFGJbNo7jajOoqmY4HJJlGU3TUpY5lqVTkoLA5/DwANDFxLK1\nF894NCRax6i25erqgslkwipaYtkm0uiwXNl2boQuhmHQD3tEecbDhw954fmnKbINtxvKqgTVeYw0\nWui2sWvesLTyPN/OlI6Pj8mybEfIZ7BYrLZ15Ctf+Qo3b95if29CEPg7czaFNHaK4maqKbrB1u7j\naCFbqxSmZVLXTVdfLG7depp7928znV3hOBaGkJg7qstdKf0uc26TxqMx72/lehuG+VjxfpJG/eR6\nxwp4EAQAWz/rTYdcVdVjg8mmaR7DjjaBDZsjyUZyL6VE6ix0XeiVQpr2I2+BDp/aTKUbQ2ipbqto\npCQ39S5tVjVZmvB7f/Q5jm89hcorktYlTkosQ5FFJTDj+skhV/M5vWGfwPdASrKyJE0T2lawXq2p\nyprBQAsOBHCwt0/ZVBiWyXQ2RbSKq4dzzUixDPb6fbyJDwis66csF2uiKCFwDujfPEAaLctVxN7A\nZ7m+YGzZCFkhzZK6UTQSXM9m5B6wPx4wGAy094sjWSwv8ZSWOBfLOdk8xHY8ppczPfDxPNK0ZBll\neLZNr9enjUuGjg0SaplRFAVJ6XPt1lMIaZKmGVla0TY2q6RidrXAPrJxXYHnSZapR0WFVAbJOt1u\nwE3TkOcFaapzLpum4drRgDZrUQomk30O9/ewLEs7PlowvTrHtnXREY7E8x0cK6BtKswWyiLl7GFC\no1oEBkG/j+8HHN28QZ4XNEpwNZ1zeTXH9wWhP8ANbaLlkjyLGYQh+8d7WwvgLE1Zr1csZivqsuT5\n559nuVgQ+C5vvvk6IHE9j4PJhBvuGNu2WS6X2I7Dm2+/xeLqIcvVitVqRa8XcvMk7E6CkrqsSC4e\n0DQtVn3C4dEJlm0TJdorpiq14jdJdLEWQjDo96jyEkMIAj/AkJLCzHnz4UPG168zvfcGoVHTNgWq\nLemFDm2lKIocFUIjJO/78IdACFzXx7AcBAbCMAl8gzzLsCyHIo8xDZssK5jOFgSBh23qGMH98YS2\nqVgv5mTxGtfTuZOjYch8doFpmrimQ5mXWK5JpSqqqiAIfPJSu4RatuS5555lNp9RNGBgIKRBWVZY\ntkFd5zRtjTQrxnt9ZvMLrEzbyMbrJb1ej8DzuHH9OqppKItKB4V0TeD5+RWW4zPaPyItGs6nc4Ks\noBf2sG0Dx9w0gzvMtHbTMG6jjUFs9CE6pR6gy5VGmhbKMLl18zkCf8S9e/fAsmiFhmEtQ6LqGql0\n2Epba6FgXVYIpD4NiEe2IZv6rQkdzbYhhe/dgb9jQ8zP/j//+xYTesSBfLT77O5a8EjR9KR3wK4N\nbduyTcIQG8x8B07ZdOGGYeA0LdJ1WCQRgecjkWR1A47NH37mj3jlc3/MJ37mE5i+i2OGNFVNWaQk\n6zlFFnM4GbM/Gevsvl6PVimqtiEIevpNUlCVDUJpXLNuW0zL1Ck5hqBpGxzLoamabuMqiWM98Kyr\nGi8Mmc+0Y9vBwRFVVegDnTSoaz3MLMqG5TrCcX3SXBt2hWGP1WqJ51j6IjEkCoVhaGXlYrHCsGyE\nsHBsh6ZRSFMSJwlh2CdNss4/vCD0XCQ1nmPR1AV1VWF6DllWIITE80Ok0E6LtmlSpDH9wCOOV8Tx\ninB0ojsr6GiaOs9RwQ61Sm/KQuU0TbsVQuhOBIJAH9k3fuqr1QrTtVGqwbUtaBoGgwDVtJqCZRg6\nAKCsKKsSKRVu58SItLh77wHXr58iEFhWt+W3DUq1lN1Ns/FVNzsXvSLLsG0bKUT3HgnKqkYISZIk\n2+93XbfrUm2m8zmr1ZrRaITn6cdty9JB00o3E3medy6S4PlBBwHuWEagKWiWaVIWxdaWtK4qirwg\nTxI81+WZ597DxeUVluNovjSKpiqBhsBzUaplulhwcHKK43iUVY1h2kipnTlNw9S+Jnmufz70gPns\nwW3miwt+9Ec+RJkX+K6PlrnblGUBou2+19j+zHleaNio1X70nud1ls66mWpUw2qx4Nq1E6q6okhj\n8iKDtsa0JFmSAHDv3l3yumG5XDJfzCnzcltg3/ve9/Hiiy9SFIUetirBxcVD3r79Nq+88hdMDo/4\nt37plzk5uUYcx5yenlLmOt1o2O/jd3MAfY1tjKUepxpvGGvfbrz5pK4kSRLOzs5YRRcEvqf9jeqa\ntq6wLRPVbKCiroa1IKS2pd9g35tOfQMZ7z7+3g9+7DsOMd+xAv7Fz+uch7Ist0PI3Z9lNxShqqot\noX3TqT+Z5Aza2W93mLlLJdzlnQshCKTBosowBz1cTJxGkKP4f7/0Cn/7f/zb/Orf/Pfo+SH0PaJV\nRpGkHB0fYtAShh5Xl5eUecKNm9fJsozDw4nOv8xzjfW12mrz2rVTLMvGMEyKqiIvCxarJVEcY5sW\nnu2BgLAX4HleF9hQaxqTH/DqN1+jyEstTOiFnJ2dMR7vs7d/gGk7FEWFZTsslxFh2EOaGpe0TIOq\nKsnylChJyLKM5XKJ7/c4Pjkhy8pHrB1TYnUCJkOaGj9uWoRoaaoCU0JVZlRVwfs/+EFc1yXPK1ZR\nqgtu3WgXxSJjb9THNAx6PZ+8Nuj1esxmM2az2XaTzfNcC3gsnXLU7/dxHc3iCAKdzrJxc7x37x55\nVuK6Lp7n0ev1cDyHLEuZXl2QJjGmIbl+csJyudRqv+MjxuNx19XBbDpnvoqoqobRaLL1aBcd3BKG\nPmEvIOz1Wa/XRFFEHEdbXLQfBqi2JQwDZjNNaTs4OCAMQ8Iw1HTG5ZJvvvZN3U0pwdXVFcfHx1tr\n46LQ12bebQaO44BSlHXN8ckJy/VKX9elFr5s4EEpJYPBQFNWu6am6Taa9WJBtF7hhyGO5zOZTLAd\njySJKIqCqspJEz3YXK0jRvsHjPf3qeqWulHUTctgMKapa+7fu4/nelRFQdNC08Lrb3yd0cDn6aeu\nMx4OUUoxn62o64YwDHTClG0ym0d6M5Ky4y7bBEG4pfltYhGllLi+h0R13tvQD33SNCaJ1yha6qpE\nAGdnZ0Rp2jUTZbdRehweHjKZHGB2mZab+/+1N17ni3/2Ckle8Eu/9MsIafDMM8+wv7/P22+9xWg4\nYm9vqOGnumI4HJLnOYOBngeNRoNt7Xm8Vnz3Ar6Bbauq4ktf/VOklPR7AbQtvmOTJwmqrTuKZGfG\nJx4xYnah5J36uP0/DMP4riyUd9SNcNdu8duZVQGPDTGfPE7sYuX6iXVxl90L0I0tOsL+RqqvjyeV\nbPXwQ0mqtkEaBp/5w8/y2c98lp/6qZ+m1xtyfHRElqRYlq1pWUmCNCRlUWAYkixLMA3YHw9BtRwd\n7CNMQasUtmkTRwlNrXm1Qgid+I7C6YpRURRYpk0cReRFhmlpw3fX9WlbODt7iOcFWLbdyfIzhsMh\ndd1y5+7drgPMuHHrFkVedvQvE4WezNd1zXw+5+jokPl8RlnVBH7AU7eeZr5YUtediMCWFHmJIQ1t\nyF9W9MOQ2ewKzza5ujrn+PAApVqatsG2HIRhIqWJaTmYhjYqUm1FHMfYtkmWJlRKn0Qsy9zCZHle\ncP36DeI41hxxz+PO3bvcvHZ9i2kWXfKQ3nh1gHRd18Sxpg/Wqt120LZhsFot6PVCPM+lrmvNyy9L\nhJSYRg1ImlYxHO5RlDXCsBDoay3LE534U1eIDpJzHJ0gY5gGTV1TFTlZnhEEHqPBkLZtWS6n2p62\n0alPAolhmNsuOY4THNvRG3Kl7ROazpPec9wOb25QAoJeoH1zJLiWS9ZBS5ZlkaV558WR7iiTFVVd\nk6cRR5M96B6TpkWRl+RFQds22kK5KnEcm6vplNObN8kyXaBH433SrKCsGsqyhC4YWyioG0VZNXz+\n85/h5fc+x+HBHqaAfm+gN0XLJopWlGWBaZvYTrA9VSilts2Wvh4tPTRVirrRkXBVWWI7NkKAbRo0\ndcV8MUN1X0coZrMZaZpun8uyLPo9HRSuIxJ3TexqPvf5L3B5dcXk8Ihf/MW/ymi8pxs71WBZjq4B\nVY3jOIyHQxYLDceYpok0wHU8hNxQlcUW1vhOCMaTXidN05DWCRfnD1nNp5imQVMVBK5L21RIdkNp\nOu9y9cglcYMs6AyBR8VdCMHLH/r4Dx6N0HGc7qaMt7j2ruk5PBpSbi6KJ/11N7/8dmBgSVTT0ABC\nKU3UNwxs69GLIoTAsA1io0ZmFX3ToKLl7/7W3+etr73Of/Q3/x0cx2VeF5wvpth5g/B9PN8HAupW\nEac5Z/fuMZnsE/Z73L1/xs1rJ3z1K1/H7zl4gUfgBVimReAHDPp9jfU7LnlR6JQPAGxMw6Q/CDkJ\njyjLgqIoubi8II4TTk6usVpFmIaD57l4foBSigcPHjAc9Lm6utLQRpHiuy6WZbJex3heQFlVnJ/d\nZzAYELgOxy+8iJR6YHx1dY7vBShLIqTAC32SJCGJU4xWYphweXaHLEs5eOoGzz79wzRNqbnJUsdY\nLRdrLq9mZFmO5/rYrottWxwdTUjimMDfJ861Ne56vWY+n5IkCXmW83uf/mdUVcVqpRkLH/zgB6kO\n95GG4saNG9rmc7YkiiLSNGU+n3Lr1i0sSw+BAi/Ur1WSscwTjo8PkVKf4vr9HmmWUFU1VVVSJEui\nJMU0HaaXF4ChaaN1y95kn36vj2WZVFVJ1bQsl0uuLqYo1dAf9PA9D98PuHnzBnmRcf7wIft7e1y/\nfkxZlSyXK5pGcf/+faqqJvBD6u5a9R0bU0Aroa5yxqMRtGAYgnB/jGUbLFcrgtAnThKKsuDhYq09\n5j0f0et1xaTl+rUj6kZ1G1xBUZaU+ZqyynAtbW3sOgamaeP7DlmWaTtUqe+Bk5Nj0kif0lZRxGo5\nRxombd1QFSVRkhCGPfK8wDRtTEvTYEfDEXle4LsOq9W6K8YwmRyQpgmraEmSxNt5lOtoa4jVatWd\nArRRlecF2JaGvnzf5+LinJu3bhJHEafXTlgs50jLJk+TLizFIwiCraW0ZTnkmY4kzDKdcKW7V4GU\nBvP5gsPjYz760R+l7EJdbNvm1VdfZTQYcnLtGEsK3nrrNmVe8vTTN7m8nJLnOScnJ8xm804oJfF8\nd6dZ/M4N7oZ0sXVRlSanN24Shj1uv/UmlmmQ5gWoFtMQXfh402lBHOCRfcimEd2lR2+a2u+23rEO\n/DO/90+2roPbwroTCPqI2F5tf6GNDHWzdhkrUkqKDk82NPETKbQYQqCPImVHuDdMg9LVz1MVJZ/6\n1G8SrSP+lU/+FfIk0xmOQhAGPWhb8u6GUUISJRlBf4jtOETrFVkSoZoC6pLjwwluYGFaElOa1FVN\nnmU09ab7t3A8D9PS5k6WaWEZJnmpj/NN22wHsj/yYz/7/X1T3l3vrn8B19/7+7/JK198BWGZPPfc\nc7z88vswLR1evlqtuXnzxpap5Hsue+M9iqLqIDSYTPa4uLhif39/C8v6gccGE7ftR+ZTHWVl25Vv\n1Nsb645SbQIhKubzGfduv4Xr2drlTtV6GNrpNTaU5d3CvWHk7c71hPjuocbvWAeuj21sVYq79JtN\n0d7gUBtZvVJqi5lvTGDKjed018VvpfRNixKqy2GssaXO68vyDIEBaclZNOdv/y9/h/fefJaf/4mf\nJHRcvEGf2eUUr4KzsyvsvQHDQR/XdcgrnZazXCywXRfTkAwGQxxTEi0XvH37HqO9HkGo8d1hb8De\nfohQunPUhjzaPrOsa0xp6BgnKXBdB6SgqrSt6rvr3fXu+t7r/PySr37t6/y7/8G/r5OxwpCyrGhb\nsCyb27dvc3J0RF3XhGHIdHbF8dE19veHXF3NOT+/5Pj4kDTNybKM4+NDkjQlTZMOumtYrdaMx2OE\ngKKoOphDdUNVpamPbYswtFxfGDb7exPapuHq8lzz5Q2Lusy1VbWQmDshNvCom9+V0j+pZ/l26x2l\nEW4MW+ARprQpxrsT4d3B5OaXK7tBz6aYQxeN1g3xUJq20yqlU73LgiKJccOASrXM5jN+8zc/xYde\nfB8ffOllQtvXDIfS5WhygCe1mjCtS1bLJXlRIA2LwXDIaDQm37ACmpo337rNZLxH2BuRFQV5uWY0\nGnJxNSfwbPIsx5AS23W6DStg6HnUZYVpmMRx1NEpTQxp6hPEu+vd9e76nuvhxRW//p//FzRtw2Aw\nYD5fYFk2q1XE008/zfRqSpFr0VASa3hmvV7z4EHE9evXCMOAPC90wPGwz9X0CtM0GI26oe18znA4\nZLVaAdDrhTqYwtq1hVUa6toJOkaaHB9dwzJN3n7rTexegDQsAsuirErEDutll2m325XvKsu/0/ru\nLPH/H9eTplMbr4C6rnFdd2tctfneXRHPJlghDMNt162hk84JrOtgDcMAAf1Bn1opvF5IUZXceXCP\n//Z//p+4NjnkR59/H55pY/Z9wsGAoDWwy5aHyxmLKsM1LYKgx+TgEMe2eHD/Hg/v32G9mOKakmEv\n5MXnX8T1QzBsTMtHGi6XlwvOLy5plcTzA3qDgcb0bIuiKjXtaLUijRN8z8dzXUAfobIs+/6/Ie+u\nd9e/gOvn/vInSdIChCYPHB4ecXR0TBAE3L9/X0vx8xzLNEnTlPFoRBStCEKPt2+/jZCCs4cPaNpq\ny0oxDMl0ekVdl0hhEEWplri3sFysKcuGqmz1IFUp2gZUC7RAqzHspm4RSPb2DnjmmWdZRzFCSMpa\nh5DrP2LbjG6G30/ahvzAduAbiCRN060lrG3bmKZ2sNuA+xsZ/KZQb3jCG1fCDZRimibStDVFLM8x\nDAPXdjBNk9ligRv4mI6Naip+/zN/yE9/7OP8+Ic/SrFOqFDce/sutjBwkazjiPHN62BIVldziqrB\ndhx6/T7XT46pioI0TXn48Iy6hbpVuF7I5PAYpRryPCWO77FarIjjr3PzxilZEuukes/BthwGwyGD\ncEgWxxR5QVkV2LaFNOVW5PTuene9u777mq9WHB2dUBURdd1yfn5BFEW89NJLjMdD2lpx9iBnMh7T\nNDUX5xcUZcFheEhVVZyfP6Qoio4GnG1VpQcHB1xdXWKZHrZpkKW6ix8MBpRlQRTF20Lb64XdPE9o\nXYcwsC2TtgVawd54gmmavP7aq3i2RhcM+a0xkZsOfHf9wA4xP/cHv7v5GGA70NxIrJ8E8nf+7Xbn\n2sArG5+UjUWsUArLtHBsnTdZ1jV5XTFbL/mH/+QfszfZ52c+9JfI6wrDtQlNF0/azFYLpO9S1RWW\n0tP2yhKAQVPVqKrEsU2oKyzDxPMDqgamizU1BnlR4TgWgpaqKoijJQYNQugMzUHXhZuWRdgLKbOS\ndJ0wmexR1SVSCqpGc7P/yi/+0re8bn/8h/8UIbR5UxiGNG1LUZbcu3cfpRTvec97dB6nbdI2Ja7n\nk6YFrhtgWg6rSEuXTcfGtu2tMX5btQihsA1TR0Y1erLu+T5lVZJkGXfv3eXg8BBpW1imZi+4Hbun\naRocx6FVijQvdPQUCtU+fjw0TXu7WW844HVdc/bgnF5/jG07lGWB7wcdH76k3+9rD5BaS909z0Oo\nFsOyqeqG86spnq8dDIXQ4hfb0cNhANvTsxbb0MNsz/VIk4SqqiirSouH2lazFix3S1s1TYssyymr\nmrrz6MiyfDuMnkw0tbFRCikNirJCtTVSteTpGtmUGKpiMOjhhD5N2wWUCLPLVoSmbknzgjfefJu9\n/Qm9Xp9GCHr9HlIIzYmWYBkSRKuNqtxN42LQVApT6vdDCKirAim0W59h2VxOp0RxxvMv6nDpPC+1\niIUWUwqaStP22lZp10jDJE5SXNvkt//Bp/j5T/4coLQqV0kQFnkFcZqCCZ5vU9U1nulRV42+Xzra\nn+M4HYMEmk5kpQBpGniet72vy6La+psEYYg0NGc8TVMcQ3J8fML5+SWWY/OzP/1j33JP/NPf/zxZ\nltMPLAzDZDgckeU5bdNFliHohT7rxYLRaIhA4QU+0+mU09NTZrMrHekXRezv7xNFEYPBgKLIGI1G\nzGdrRqM9TFOS5+VOfdL5m67rbotu6NlbZo+wjI7rvW3Nmc0uefutN/BdB1M8boO9Wwd3bWSF+AHN\nxNzI4jed+GZtjhHQSUuVQEhJSxdEKh4VccuyUI1O7tATY4VRNkjXZlYk9FWDSiriwGAZGvyvf/dT\n/PDhM3zsw3+J0jUQnTnWOk1JzRwzdHBdG8fpkSQJ0+mUKiqwrIDxaI/ewX5XQGdajFMWOI7D0fEI\n13NYLOasFgmz2RrLsnnPUy8RpxlRFOP410iziLNphOvWOL0xg0mfycE+cRJjWzZlnnJ4sP8dY5X+\n/Et/Qdu2BEFAVuS8/vrrvPjiexmPx0wmE9q2ZW9vj/V6Rb83oqoqPNfBcU2SZM2w53Ln3j2eeeY9\nLJdLFIoWi2QdYRom67Lq5g/a43y+XPDpT3+amzee4vT0FNew8V3dQdRCkWURm+g7Q3TWnVVOlq21\nglAGnUCls8e0LKq6QilJAzS1TjF56b0/hO+2tI1ivV6zjjIuLy5RQnL7zpvcfOoG4/GQvcNr5GVG\nWWqBj21ZIEpGfavjCWs+sus4nF+csV6vmV2lRNGawNe0tMPJPpfnF+yP9xkHfQa9AWVZs1qtWMZx\nR32rCEMNm1mWxWw21xho0zI5OCAIAtq2YDDsUeQJUbREVrkOaO5OiYdHJ5iWq0VZTctw0KOqCoqi\noGy0rPyN117nS1/6Ep/85L+MYUikyDkY9UGlmKaFnL5BRAAAIABJREFUETxKbEmTHKffI81SFssV\npmmR5yUCSVlqDLfp0o/KsuBP//RP+Bt/49/khm1jGA1S1bih0YUrFCRFge14WswlDRzf05uv6xAM\nAi6WV3iDPmmacbFYIaWBwGA4GnM6PqEoClariCqvqcUa13UZj8dbEsJ8PqcqH6VmDfoBYagNt9Jo\nrXnyjqtteh2HJM+IoojFfEkYhgRBQBD6nF+dIwzB5eX5t70nVF1wcrhHmWc4jsPDB/e186FpMBwO\neeONN1Cq4eYzz1BVFd/4xjc4nEx48aWXSNOCppUoTEbjCXfv3WdyMEGaBrPzJes4YTgYM1/OWC4W\n3Lhxk34/4M6d+/T7fQaDHovVGgyDMAh5eHHBYDDQzUxZd54rCtM0qKqGyeSYtpXcuXMHz+0cCdsW\n29Quj1VZYtuO3vTaFim/d3n+rh24EOIU+HvAAZpD83eUUr8hhBgD/xtwE7gN/DWl1LL7N/8Z8G8D\nDfCrSql/9m2eV33uD353Sw3c7Dq7CTpbQ5iOy6069RLykb+3aRh6t1NgSEmZ5wjbRDRgGQa1lGQG\nTNdLfvsf/iNOj6/zw+/7AOV8TWnodI3hcIjdGfRo4UhN2qkDVdvi+T5ZWpBl+ZZcb9s2Yehrj42m\n3qZoADhOQNtAXbcURc0qSpDSwHZsqroE2RDHa6q6pOc7DPshAsWgF9ILA/IsRUrJx372r37L+/GZ\n3/sd7dPRiUDKsmSxWLC3t4+UWm5eVTWGlNRV2QkeGuI04c6dO2RZhuXYfOQjH8W0LGzLZrVa4Tlu\n56uuTe7bVnHv3n08z2Nvb0JVVhRFSZqleJ5JGIbkeb5Vsz1pHgZaeKFaE7r3uKhKLaJqWx2eUFQ0\nLejkFQuJLkaO42A7PgpBXpb4vs9sPqXp1GxIgRAOZaUVi5P9Paqi7LwwdDNgGiZt0+B5Lo7nURRa\nIJQmMUHg47seaZqiGp1tuF5G7O3tg2vs+FMIyrIijrXN7+mp5qcniX4/TaNTVxoK17UxDIE09GtX\nVw1xmiKkxXodYcsWgaLXCxFC0e/3uLy64OLhOR/5yEcpO4+MtlWYBmhWmqAVj0IBmlpfe4apFbrr\ndaRpqba7FacZpsFqteThwwcURcHLL78XUFsRkJRSc5ERqKazKxBaRUhHs63qFtsS/M5v/wN+4V/9\n16iqmuFwTJ4VSGmQZTmW7VFVNW2r6PV6FEW2jTzbnIo3bqGbbnLjJOp0YcOmadG2mtOulKJFIQ0D\n39OY9eZEvjG1UgJ+/mc+9i33xP/9+38EQtDznG1DmCR6WNnv91FKMZ1OGY1GTKdTrl+/Tp4k9Hra\ncuL09DpJkmoTLiHIcn3Kcl27I1Q4nYrW6uT8gvFY2+hK08AwLYqOgCBqhWHIrT2IYQg83936nTdN\njVItd+/eJV4/1DJ+oZWhnuPQ7sjoq7pGSvN7Sum/V4mvgP9EKfUXQogQ+KIQ4tPALwOfVkr9N0KI\n/xT4deDXhRAvAX8deAm4BvyeEOI5pdS3NbV9MoRht3BvCkHZ1JjowQCGvgA3fEmhFG3daiNBBbbn\nscoTBk6ASkuWqmQdmvzmb/0Wt9wxP/b+D+PtDak9n6pSxEnCm2++jW1bnJxcYzjsI6XAcTLyXHfX\ny0XEaKQVYGmakaYpeZ53A48Btu3gecFWNhytr5CGieNoB7zDwwlRnDKbzWhVg+2aeJ6PVZtkZc7q\n7gOuX7tGVlTcvvMqh5N9jO8wWn7ttde20IMQgouLC5bLJZ/85Cfp9Xqd4MHCsS2aRg9FvvKVVxkN\n9/jID38E1YkS6qamLBqSJMYyTZIkwvN8XfxNk9t3bvPsM+/pLkILKWE6u+wMqFp838eyLF0Eu3lE\nmqb0ej183yeKIt1VpTn/H3NvFmzZdd73/dae9z7zOXfsCY0GCIIASXAWKVKUSIqmqIROHMliUnKV\nqxK5ErkU5ykPyYMrT67yS8rlylviSqpSZSu2wyjWQDGS6ISkJJIiQUwkpkajp9t95zPueVh5+Nbe\n3SRAKsMDuasaQF9033vOPnut9X3/7z/MFwtzUFsMhyMsSzMe94ljuceD4YiqrrFVICrCLCfNCtKs\nwPVcFos5Fy9dpKwKFouFebgLzo5PmE2nuLaD8mDn0iXWqwVFIQERq/WK88UcZSkx6wo8dvZ2DdRQ\nYtkWylEEYchkNuXg4AC39qgb2SS3trZwcsgyTc/2qMoYz1X0ticoy6IsBKpaLeYkyUbaYtfBD0I8\nz2enN2KxWtHvDVicHWIpuH79OoeH96hrga7+zm/+pnRnfkDTyH1EN9RVCWi09YCloJSkV0W9iOVy\nYQQfHlmWkmYJ3//+9wF417veheu6XL58Gd+XTXQ49LAsRVNXD+hptkA4cbwhCCNcz8VybCLbZjjo\nSTc0X+B4PovFAsf2GAwiRqMJeVZyNp8TxwlJkjAe9+n3JbeyMDmWJycnRFHEcDg0vvg1VVWSJGL5\nW5QVoZH/13XNcrmkLAqO1zH9fp/hcEiSZKYKtTpCw49eaV5w6fIl8rUIh/b391mtVgwGA+7fvw/A\ne97zbu7ePcDzPI6Pj3nysce4desWtm2zXq65dGmfF1/8AVEUsbe/S78/4PsvfZ/dvV1sz2d9NicK\nQ3Z2tkCLQnp7d5eyqjg7P+fS5X3mixWqaugPBixWK6IwwPECTs/O2Nqa0WhNo0WdeuHSJV564QDf\ndQDNcNAnS+XQqR7KSdBavQUT/9Hr/xUGrpT6PeC/M79+UWt9pJTaA/5PrfWTpvputNb/2Pz5Pwb+\nG631N3/k++iv/emXOhZKK9Bp2094KOC4NpXxQ1iqZVlQN7iOI05iWr6eoVF1A7UmGA04zTb8wR9/\nmWKd8oVPfZYyzhhvbXO8WTD0RSnpuu5DasFzXNdjNBpSFAW27eD7Hmke43muwfXE10QpxXK5Mhif\nVOWe5xm/YUVRSFBA0ygsYyRVliVllVMUGVVT4zo26+WKOBaRwWQ0oBcFuI7Nv/vv/+Zb7v/f+49/\nnb29PVarFdeuXWVnZ4dbt25hWRYf+9hHWa1WsoGu1oSez3K5ZHt7u3MlbCuaKIpEEapMxWiYL2EY\nEgQhWVYY+CXqqpkkSdhsYu4e3Obpp58GFK7jMhgMumF0m7bT7w+kakQzHA2wbZvYJIs3NCwXK7TW\njMdTkiQBLKpKEwahVKGeT1U12I6Dsizm8zlFmRP1IlHwlg29XiQ/z7ZJ4gTdNDiO1y30fr8PQF7X\nNE3NYjGnrgq0rrCUhW1buI4jSUl+KMpDW9bCaiWfq3iKw3A4MEVD/UBYZrkGN3fAtMJ1XbNYLlks\n18wXS7S2Wa7W7EwHDPoRk+mYqipZLOY0Tc3e7g5R1KPIBTeu6wcVuNaygXciN8vt5hZFVbJYLLh3\nTzaoCxcuMJ3KDKEs806S3ev1WK/XBEEgqkylqarazJocmkZjWw4NmtVGEoyaRihxf/XNv+RDH/ow\nYRhiuz55Xhh82yLPSrGDiHridqgr2ZSLQgoXQw8uy4osy7tZS0sPljxYh6IoSbO8M6CzLAs/CKTr\nyTJCL6TSEq9WNzW/+rlfesua+P0/+Tp1U3N1b7fbO1oSRL/fl7CPSJ6VixcvYts26WbNdDpjOBrw\n2quvm8Fkwfb2Nnfv3mUwGIrPi+ty895dHn/8Guenc9Ca4XBoAjVSbEdM8xarJVEvIrBt4jjFDwLT\ndZRmhiN2Bq4ruZ+245Bu5hwd3idPE8oiQ+nGPJtGidkVtIr3fPBT//8xcKXUVeD9wLeAXa31kflf\nR8Cu+e8LwMOb9V2kEn/LVRlfCHm4HigqWxpN25ZTPfBB6aa2Shz9LGXRqAbLnFg+itBzKDyLY53z\nv//hH+ItMj798Y9TKNje28OppNJZx0sc5TIejyjLitFoyHQ6Fdz07JzpdCrmO0GIFzjE8YbDw0Oz\n0fWIoogo6jPoDymKnMViyfHRKbansGyLXtRnd2+b+XzFcrkmLzJcz6NpGsKwh2XBcrXGdgPCSGFZ\nmtPzBXfurpk+ZKzz8PWLv/hJTk9PmExGNE3D/fv3uXTpElVV8MorL7O9vY3rDtnb3SFLMmazGaPR\nSEzvoTMUakVUYoGuKcuCXi9is9nw1a9+lV/5lV/BdW2qqmQyHaKUTRgFoODpp5/m+PiYixcvkmUp\nGs1oOMJ1Xfb29tBaglnDMCQtC+7dO8T1bJNN6uE6DluzWbe5OLYZVleKPC9kAMWawWCIqxyUBaPR\ngDSV4dZysWA8GnN4/x4XL16kqmpCP+gw2aqqSLOM2IRIBP0RKNi/cImiyCnylKoq0Lphs9mQZjmz\nmUO2jlnNT7h69SrjyQRbWXiOI4cIUiB4A4GclGWRZCWnJ8e4rhzyriXDOdt2ODo8ZntHpO/jyYws\nWbB/8RJ5moj/dlFw8eIFqkK8Y6IowvcD0ljyLNuw3bJ6KNhb52RZxs7ODi+++CKXLl3ine98wnSB\nHnEc43kOdS10OLGlcHBdH9t28FyHqsoRiUQbINCgLGiqmuFAbCLadv/evfvGXbDA17LpHh4eY9s2\ng/7owSDb92lMhXxycsLx8SFbWzumM/OZzUwm7GrNcrFGWZrJZNKlrruO1X0WLeRnW4rJeESVF0S+\ndHQ/7tJ1wd7OLuv1muFwaJwP3W4Td12XXq+HUorDw0O2trYo65JNsibJEp545+PEccbR0RHzxYLt\nnV0ODg4YjUZUVcMjjzzC7dt32d/fx9INt27d4amnnpSiJsvxfJ/Z1pTj0zMaLyDq91mv1531xf2j\nQ2azLTZJQhgEeL7HJk7w7JDZbJc3b1zH9wLyRN5/VWbUddlt4Jb1k7ng/482cAOf/K/Af6G1Xj/M\nCtFaa/V2ll0P3eO3+2IURV2STovzta2D+ZmymT+Ul9dRbvQDX5OHja5GeKx1xcrSfPs7z3L/4B6/\n/sm/wTjsYfshZ+slvTCi5/oEOxGWZYlhTlVS1WJnOugP6fUuYNsuWZaxXq/AknZvMBgYW9OCs7Mz\n5ufnHNw9wLYdZrMtLl26TFGnhlNa8PIrL+M4HqPRGNfxqZuaIBiwWa/IixzP89na3qMqc9arJZXn\n4vkOh0dHb3fLODi4y9bWFkdHR3znO99hPB5z6dIF4zURcufOHfb29njt1dfoh33+vb/5N5nPF2jd\nPOQpIYrVLEtwXI8kyYiTNa+9/gpxnPLudz9NnmfmvtodzVMpGA57bDYbrl69wsnJGQBvvvkmo+GY\n0Uj8x8GiNd+fr9Z4nlgOxMkGpWAxn7NerXj22e/x27/996XlVhZhNCIIAgbDIZskpmkqDo/uS0Xo\nOAz6fUajERcvXmS5mNOLtjk6PCQvCtbrmO3tbcLQZzAYUVaVwThXHB2eotEopbvqVKmG+fmZGa5a\nvPDSqziOyyhyeOmlH1BmOR/60IeYTid4nkZZkKYplmWxWW+YjCdsTac4uzs0TU2RZoZWesjJySnv\nfe8zFGVDGEbYrktVbIGCqNfj5PiEOE44Pz/Hc1xGoxGbzYbVckk/Egc/lCxc33dFsWcpPFcO0OvX\nr3P58mVzeJXk5kBqmob1es1gMOD87JzpbEpViqZifj6nP4iwVEMbJtCumyQVx7/cbPpJkqIeovA6\njpiKrRdLLl26QFU1oC0TwFBg2xZFlaF1w+7ODlcfeYRNnFCWYk+7mAvsNRyNePTaIzR1yXq9Jksz\n8ey37A6Sk1Qt2xRRGRdmE0JXoQOHHxcsZqsazwbluUYpKcWKZ34/Gg1Zr1fG6dMlSWJ6/RA/DLn5\n5pucLxaMhiMee8djvPHGm+Rlyc7+HkVdEW9S+lbPJP2ssIEnn3wnR0cnFEXBZDbjfH4uthujIapq\nmM/n9HoiDspzOag3mwRQbOIEJy+kurcUnuvj+xF5FuMFATQVlm1jGTZdZeYGP+n6azdwpZSLbN7/\ns9b698yXj5RSe1rrQ6XUPnDc7jHA5Yf++iXztbdc/8P/+M87rPvDH3wfH/nw+7u8RN/3uxAH3/c7\nmiBdIIPGN4O3dujZKE1T1FQ9hz//1l/y0jf/io+89/0UnkVZV/hxzmTcpwxc1DqjKDIa3YCCwTAi\nzwqqqmATrzpIR2CTPkWZo3XNcrHGdT18L2B3e4c0zZhNFXGcUBY5CWB78nrEGMehrjV1VZgAVB+a\nmrIocCwbXWvu3r5DELhEkU+v57FeNfj+2+N9vV6P2tCjLly4wHg85oknnuwqjtPTU55//nlGwzGe\nH3Bw/5Ct2YzA98mL7KHqZEVVldy/f58kTZhtbXH58uWuI5LK2O04+O2B3WLleZ4zmYxQSqxO0zQD\nDYvFgjDsce/ePUmKCQYEYYDr2uzubrNcLrl86Sr9Xo+PfvQXABgNBwCcz5diOas1US9CKdV1R0Uh\n9gPr9Zo0TQl8r6N71U3DZDJhvY7J89zMLgIqE3Y9mcxQyiLLEnLb4d69u/i+h6U8BoMBuzu7PPbY\nO4nCkDLdAHB2eoJj29y8eYcoinj66aewcHBdm17YI89z5vMzHNclNB3kYCDvIwwj4/PtoGlYr1b4\nniWbS1WxvbvDuBihlCbwPOqmYtDv45qwB01rBwF1WdMYA6s0TY3Aq2F3dxvLku7Jc93OslY3UtD0\nez2UhqauWC2XzKYT4lhcIptGoruaRiCqNoNxMBATLt94eLeww9aW2CT3+hFZKvCA43q4nnFAVIrI\nFmOmqqpYrwVGC3wXFfgMBmLAVpUNeZrQ6BrHtnAiec2N1pSlFE+27ZDEawLfoxeFuDY0RYaui25+\n86OXS02RrAh7YwmOyNIHnu1FjuPYOI5FksQoJdGBtu9wvjxnsr0lzpKbBavXNuzu7nHr5i3cwCeI\nQvx+wHq9EujUhEyfnp6yvT0lTTPWmzWjwZDlekW8XrO3vdslgwlMmXFyckavJ4XPdDoRMkCS4Dse\nSmsm0y1efeW+CeDIgZpnn32e7z73ktkf3/Ztd9dP3MCVrNx/BvxAa/1PHvpf/wb4u8A/Nv/+vYe+\n/s+VUv8tAp28A/j2233vv/t3/vYPmbi0G3aSyGCkTaWwjGTV0q2yUv78ZrPB9/3OoMqyLI7qhMXx\nhu/926/xiY/8PPuXLuL2I+L5msX9E+IbGf72mMl0ytZkgNYNaZpxcnxM1IuYzWYAnedKmsXUhhM9\nHo+ZTmfUdcPZ2RlxnHTGM/v7F0wayCFlWZPmKZayiXo9+j0fz5MW/+DgHr7vE/gug34fP+jheJ6h\nn5Wcn52wXC0Z/RgIRdzlhHq1tbVFkiQ8++yzRFFPKqDdffK8ZG/vArqGl195jatXr+LYiiiKmE6n\nJMkGx3HxPJ8rV64ym00oq4ogDLvWWoIh+ty6dYu8SPG9UJ4HS5GmcceEWa1WXL9+g+vXr2NbDmdn\nZ1y9eo0PfvCDfOELX0A5EcfHR9iOYOAvvPDn/PzHPkpRVNR1ycnJCePxhJ2dHWY72ywW4kBYlgXn\n5+coZbG9vS32rrZLv9/n8P4xaS5MneroiMceewytNVtbW51DnWDYmpOTE7IilhScuqDIM6Ig5D3v\nfhoN1FXFfD5nE8fcTVNGkXRlW9t7+J7Ho1cfx7I08/k5/Sji/PwcP3C5cuUKRV2x3mxYL1fkWYbj\nOJyfn7O9vcNkMsByxdPC9z2yNCHLUvI8Zbmsqcucu3fv8Mlf+DhlWpAYPvzQQFEtrVY9lOXqejYn\nJyekaWrmMzb93qDDsWXgLEKQvb098tZStidmcb0ooq5KNIq6EeYUBivXWrNcLJlOZniuT2KgHMuy\nSNPEKJ5d4jgGrZmfn+L5D9z0rPpBF+w4xjq2Kn5kM0FYOlWN7fzwPMu2Q8pKIJWmUR2M43gWdVWj\nLHB+DJQQuC51kXMU3yNOxJ99vakIgpA8z1iuzrl69SonJyc0jSaON1zqXTIznSUoi4986MM898Lz\n9PohO3tbNHXNa6+/ynQ6Iwo8krX4q1979FHyPOfGGzfY27/AztYWx6cnDPo9PN/nxo3r7OzsEvUi\nbt++zWQ8pt8LWa/XbO9sc3p6xnA4xFLgBw55VjKeTMiLgpnbR3k2dZnxkQ+/nw998Bnh5iubf/Y/\n/Yu3fe/w19MIPwF8DXiBB1DIf4Vsyv8SuMJbaYT/NUIjrBDI5Stv8331N74qe37bIrT0mYej1Vox\nh21LyrVSSihihnJouQ5lXXWGV/Eo4l/90/+eC8MJT77/GRrXwrNsbMdhGPWw4oLNes3N5BxVVExG\nYzHK54HrYetC1oqKlFKUldCjkiTB82SQKdRHoUEpFMpSEqTgiaClZUOI3aRwt2UaLxmVtmVTVBLc\noK2GMAy4efsGSmkUDf/Zf/pfvuXz+Kf/5B+itWa9XktwilZkacrJyRlPPf00i/mcOElEnGISuW3L\nYjAY0u9FNE3NY9cepWlqVqslj1y5wunZWacAq6qyU7VmWcZoPOzYNkmS0It6+H5IHAstcTKZ0TSa\n2WyL+/cO8X2f01MZGo3HYxpts7UtPuJlWRi/iRGNVuhG2uc4TlmuV7iew2KxwHVdrl17lC55Js/R\nGtJYMH3fD4lzqbJa++HWegHj+e4HPkVeYFsWcYYRhmyIehFh6BuLVafDSLUZgpd50dHd8jzFUlLF\neq7NdDoh3qzFz7oscQIfBTi2jW05pGnKG9ev8/g73oFS4jGvbGN/rIUP7DqOHICew3q1wLYstiYT\naZfLCm1w77oxLKyH4EHHleqv1xPvcMuy0A1Yyuo24daOwnEsqroiDEMzJNYSgKAVlsmMzMuigynr\nupZEoyxDAZ7v8Wf/9s/49Kc/zWK5JIqEZSUME9sEDHsdi8yy7M5WtWlqiThrA5mNJUbdCLbtOR5l\nWeB6PkEYmBSm2kBbFpZtGQ60RZ6mHQ++aRo+8Qufesua+ItvfJ08z/DCiDAMKYqCzUagJBmeekRR\nyHK5Mh7pPVw/6NKv2r1mMpl0PiS6aQjCkNVqxe7ONqvlGtuyxC/f84iiiMVSuPG6TfZRCt8RGCjL\nMra3t431bUK/L92Z1kLddMxspalL0BWH92+znB/j+zZlniASToVCntH3ffSz/9+GmFrrb/Dj/VJ+\n+cf8nX8E/KOf9H2Bjj/c/mqpRP1+n+l0ahI7FL7rdfhtUzfYysJ25ZRPkwTlOkLRsRS/+7u/S5ln\nfOqXPkVGLYuiLDk8OeHQOWGgHfb6E565/BRlUXN8dMTrr71BWZbs7Oywu7uL68pJn+c5aSaJ2Mpw\nO7e3t8nznNVKhAu9XsRo1O+goMViwfxEKEyB7xMFoQQbbzbMz84oikJcCsdjer1+hzO/+vrL3Fwt\nmG1N8Dyb09Pjt71nh0eH9Ho9LNsijVPB4k/P6PeHvPbadYqioN8bUtcNaZrT6zkEYcC9w/uMhkP2\ndnf587/8Jm/cuM7v/PbfxzEWnBJN5XbRYO1ibIUhcbxha2sLgB98/wfcuXPAZz7zGVxXPN3v3z+i\n3++zt7fH448/QZKYAAssFotz8iKjNkzS7DjD86QrKaqazSam1+uz2ax4/PHHuXnzJi+++CLacIjf\n+973Mp1MqWu4fv0N3njjBpeuXSWKInb29gg86QbyLGF7e1uyLBcSbrtYbrD9CN+3ePTRd8hwyHRv\ndV2xmC8oy9oc2B6D4Zgg9GXRrlZYaJJ0w8nRIXcP1uzv7zMdj1BKsU4z1uu1VPlZxrA/YDqdEkUh\n682aRktlfHp6hucGpFlGLwwAje/1ZEhW5hRlQS+KaGqJywujAXWtaXRFwwPztryQJJ88z6Vbosbz\nQ+pSm/eg8X2fMAxZb8z7X4hiV3Jma/K0pKwqqqamQTJlB4M+tvGJn02nMpw06sGmqbAtxdnZKbPZ\njPF4xGq1ZjKWDrEB6qYi8ANT0Mgz0+ga13WEbVVVNLowWH1FlVcPnDmbhloLa8TzPEajEbPZTOAo\n28YJI84Xi64zg7du4HlZk5cN2ClKtWpuRV2XrFYieCoK0XWcnZ2xWhaAY2CjAa7tkKxXVLmwZwLf\nl+fe1kSBw+L8nDzPGfT7pqBrSOKYi/v7JFnKJo6ZbU2kEFIu08nYeOuv2d3dJUsTgYxM3kEQCDxc\nNWIfXabCST8+uiNiKQW252IrG9tygZ9RKX1bgZvf/xDL5OF4NVvJKSkRXwK51E1DXkr+YZJnKNfh\nu997lm9/8zt8+vOf4/LePmGhCZWNCjwqG0oLagvqrCBY5eROgGPwvqLIybKURgsvVuvGUAalWmlo\nxL/bFSpX69uyXq9pKe6d8Eh5aG0Z6t2mo0+JGqsEszm2uYPrzRqtGvzAw3Zt3rjxGv1Bn3/wO//w\nLfft61/7Ei+//IoR8CzJ0pymEWn3crmiF/UF39SaIAqkoisKojCg0Q1FLrmWyhJq3PZsC9BE4QM5\ncFuF+OZBruuayvgbbzYbxuMxH/7wz1GVFWmaMxyOpF3NCsMkCLqqZjwaSnWmhVudFQV1oymKkiQr\nZIAaJ6RZxmopm47I60sa04KXZU3gB4Rhn2vXrnHt2uPcvn+fNE0Yjoaslit8T4Q0tYl3a5qKN998\nk/FoxIUrVwTzthRZJlTJsixxXBfHcXFdr8v43MQS89VocSfyfU+k14GP0mKPsFot6UURXtjHsR1h\nYdQNumlYrVb0B32qusb1XRzXoawqHFvsGSwLyjw3Vgspru1Q5hlhEIocHkVeNDSNksxE+0GwSYsg\nxHEsdMS6QuGg6wcpLnmekucZQeiT5/JeNpsN+/t7ZEmBhYtp3MCS9ZamqSTUex5FmmIpidj7gy//\nG37jN36DPBean1gcWx3c2aY5BVGPusaQD4wNqiVDY4FHhe1SGqgzj3OUUeY6tovreSRZ2tE05X0I\nrKSDAZZlEYURVVnytz7/q29ZE7//R1/Bcz2qUii0QSBpR21gTPtMO47TeQwtTladfL7f75khv4R6\nCLGikBQsxyEpS6mFbYc8z9maTGUfMh1DlhdE/R4aTZlL9F9koLj1es3Ozi5Zlpvq26bXE7582Wiq\nKieJl9iq4uT4gH7k4RihotIKtMwZnvm5z/xzeg5nAAAgAElEQVTsSelbxVb90KS1xZRbXnIURaTk\nDMM+DtBkFY7nUaHRrgu+DN1ODo+48+ZdvvCZzzEdbeGUDa4fUDYNTVURL2M838MLfAZBn8byqauY\nqk7ZJGvCIGQyEwVY1JuwWW/ARG6FYSA8bsdluVpwenyC57qEUcRoMMR17a4q11oThi6O7aAcm15/\nynodM1+cdWq0yXiM64uScL1ZEoQOlu2SZSl37xzy6U9+qhuI/eg1Gs746M99grqueP75F7h58yZV\nVfH+97+XW7duk2WZCFI8B7uSzdL1XbBrjo+O5UF0PCxtc//olCSreOSRKzz2rieRxVeB1vSiHmmS\ncHhwyLPPPsvHf/7necdjT3Bw94DRsE/P9/GGQ+bzOWm85OjwLmHUJ4p6lE3Beik83k226VzWoihE\no2QDLWoWizXb27vkRUmAwrIDXMdhPwjxfI/ZdAvbkTSlo6Njrl+/znyd8Z3nX2Jrd5/+uIfjemzt\njEnTlLOzM7I84fT0hOVyQZalWL0h6RvXeeaZZ+j1IlxXuPhJklFVclAHQUi/3ycKA7a3dkiThNpw\n4xeLOUmcMGcNCpHzb1/EcR3ycoMduFRU1MgB5UUhWV6QxCmbTcxoOBZGT+RTVhX9qI/WDVHQw3VD\nAs/BsQqUktAQrRvC/gjH8ygyGbI3jRz68UZyI13XQVc+riXh0HW74FH0ez6OJYVPL+jRAElac/36\nXS5fuYIb+BRlQZkXWNrCcT2GfoBl2dRVTX8cYikLTQ3KZrFaEscbdrZ38PwA1di4rk/oaWpdkmcp\naZJS1gILVpXwyB1Hmc7aIgxCHNeRwy4ICCyZp8g8S37uMPLFJsPRlFWNa4V4dkijfIEUK3B+TCUq\nKfPSjSjLpSgbgp7MEnwDn9qWTZKnWK5AbRPHo65qpvvbrDdrST+yFL0g5O7dA/auPGJSkUJcu4dl\nKzP/2TCfnzMaDYmTGGVZ2JkUMVmWs7OzRZZl6FrjujZbW1PqWsKlt7a2yJIUmpq6LCjqlKos6Pc8\nbt08oBdEuJZQKptaqNGW9dcX1z/VCrwd2LwdlbBlTFROQ50V9L0Qq9aARaE0KgzIa8lJ/IuvfQPf\ncfjA0+/tKsd2EOkYsQbQGejkeQ5WZdgOluFJi6glCOTPOrbbyYM3m9hMg5sOc+28e00YQ0t/LAxe\nLgKGmsCQ+lscL8sy6romTVNGoz7L1dywN0KeeeaZDnd/3wff2i6+8NzXOiFOSwlcLBbcuHGD7e1t\nTk5OuH37NnVTgdWIeZCyODo8pijEQEkb06eqqvFcl9nWjPnihDzLeOzao53owrEcelGPvd1dirxk\nOBiaMGLxfFktFyhgMpkw3ZqJ4VTd4EcRti0HXPu+0bCJxUgrzwuzgYtJkG279AdDai2dWFEUrFZr\ng6PW5HnOeDxl0O/TaE2WZri9Prdv3SZJEk5Pz80MAi5c2GcyGREEPpZtUZY5yeK0CwxpqzDf92mD\nruU1Cce6ruTetJCK40hGqTbCmixLqKrSVFAZaZrg2gKtrVZrVoslO9s7bE1n2LZDkeVYtkVWF1R1\nTZ4VOI5PnmYdhdaxhCFjWTK8azDGUmiKPAcappMxYegxHgwIQp8iTwkCH40LloNlKapC7AREEOOQ\nFSVxklKU8qzduXfAYDhge3sH33XNM1AZzFZk8jZyj5QFYWjTaMHR43iDbizytMK2RALvejZBIGEk\nnrmf7TOudQP6QT6mQDiV+e+Kpm7MIN3DshyUaS9c1zOiOF9mII2wd2S4XvOZz372LWvij/7oywDY\nriUpXLaNZTvQ2rXywK5DKYeqrvGcpns2JcvUxmozUtMUhUC8k+kU1/LNYHgX27WM6dyDAWxRiklY\nWdVEvojK2j2ovRxjZet7gUDDgBvanJ+dMpuNuXdwl1EvQmmBDS31IOu30T+jiTw/GqXWvuEfdSVM\n45TI8+VBSzKCKMIKfKqmpqwrXn/1Ne7cusXnP/s5oRpZCteWyLImz4hTadGHw6EkoXsuXu6Rl6kJ\nRhW5uOcJXXExX7DZxAbjFsHOYDAQnNW0k+3wy7Zt4jhmMV+YpCDwggjP9xkOh12ittCr1kRRwHx+\nRq/XZzwe8s1v/SVnZyd88YtfFErcQ14ib3dJ56vklDc+woHv89i1a7I5RREX9vfZxBvyIuPw8FAy\n//YvdEZRWSaKuf5QZO/LxZyqLGjqmhs33qQsS55+6mkm0xmb9YbXrt+QAGAlLeF73v0UYPHYO96J\nY1s0Tc3JiWQL7u7t41g2y+VKsE8xO5EDD0Vi0uhPj++yv3cRUJRlzf2DuziBqCjl0JiR5ZmoBJuG\nN998k+OjisFwyGQ8psoyzk6O2N7eYXDlElkuPjWB6wjVVGtUU0tgru93ifZJIpYGrW9M23JHUWQ2\neUl4WsxXFGXcDRN9L6TXD7FtV+irdcnpSYmtety+dZtXXnkT17YYj0ccH3+fT37i41A3lE2GZzuE\nrkWlNFt728RxyqAXkmUlWDZ5VoDjU1UlVVFwcPdNgsAzMwmPrdkO8XpJozXLxYoLF/Zp6oq6EWZK\nGHnkeYrtSJh1rWV+U9caZdkcHt1DWQ5bs21cX0KP43ViKKM+lmUzmUxFRJIXRsXpkOWxWQc+4/EY\nhY2tfHQjHjFVXVDXsjFr6J5dz8CSSj1w2HPM4PThsAKFBF5XVU0DXYYpQJJsqKoa3w8leFwJZfLt\nLtsEJpe5wB5ZmgrRwPMpiwLXDykMvXQ0HkFZ09TiNqmbxvh8a3xPNt3hYCKK5nBAXWqyYo1SmuVq\nQZLGXLp4gaqRsPCmafB9US+XRUyaPBDKdU6fpmjrRUJxtG15P4eH90iTBM+ziYJAIFpL4Xkujm2Z\n2cdfH9jwU02lL8uyO7nhQcJzu3nbto2yFdpgWU0NludSATg2t+7c5o//8Ms88653EzkeFy9fksqm\nkqQb13UJwhDHtknSlKOjI4qiIAwCev1WTRlSlZWx+NSdzLfFsGSKD57nMRwOO550W1UMBgNTMQjt\narneUJYVi+WCqqq4dOmSeV819+7d67qBr371z7hy+RJf/I2/LbxrM+RoceAP/fzn3nLfXnrua9R1\nYxR0wtopikLcCZMUy36QkN2+jyRJuHnzpqlsVxSFiJAaY6HqODYNFUrZzOdzrly5wuH9E87P550/\nexhGRnRh4SjF+9//fu4d3OXs9ITxSMRN29vbjCdTWXSWJUyduqZuKhotD7GlLJbLFf3+EDT4nnDl\no16PtBQpflUJPc/3AizbZjgcMBwMaXRDmuS88cYbjCZ7ndWCUjaWshiORigFSRITxysRIDUVtrE5\n2DEugsvlkvF4TFVVXeXdmel7Ln7go5RNFA2QrgziTcJ8Picviw6eofHY29ul34+wLEW8WaF1hR84\nOBYEgct0OqEoM+q8oMgLslxa/aqBRlsox+PsfEGcJGzimO2dXcZDD9+1CPygY16NjN90VZXE6w11\nU+N7PptEBExFkRsYRYOW4dhqHXP79h36wxGD4YjRaGK6jZTKSObrqkIbpkgURWRxu7F7VHXO/fsH\nPP6OR42q0UU1NrYtQdy2oySFRmuUbXV88jzPheqYpx1brO10WqVlu9YdW5gsfuBT1Q/sU5taUrTQ\nbTp7Rd3UfPqzn3/LmviTr/yJdKOehef5Qo5wHDzfp24kF7fRigaNbhoswwqqyop+r9etodbiWAHx\nRqiynudR1ZkpqoQSOhiIU6nn+7ieRxwnZKmswbJIGI1GnZ7F81zOTk86Uy/bFpaN53pgaeLNBmiw\nlcZWCs+xyLMUx7E7iMmyrJ+YSv9T28D/6s+/3H2YD1oc1X3oYPxQ6pq8KAh7PfKyoLEVbhBx49ZN\nnvvus+xMtxhHfXa3dtiYh6a9YS01MAxDwlDsRNshR5mVhukCUtvKfRDPZ/E8aD2Ny9IICbTqhDSt\nD3CeF9RmwOq6rjADGhmGSjp6SdNI+zgY9Dk+Oea5577Hr/3ar7GztUUUhvJ6ylI24lSc895uA//B\nc1/vKvS2uhHObdX5M8gDLyKNFjLyfaEv5kVBnuXE8YaXXnoRraE/6KNVw9nZOf3BkPVqw2K5pihL\n/CBEa1NBWYrxeEKy2XB0dMTFvV2m4zGDfoTnuWzWGxLzPobDkfBkt2cdHTRNE1OJSeWlkEq91xsI\nW8jRBkZoiEJJaS9yGYzOZrPuUDqfz2lUgOt4nM/n+J6P78mQcDKZIOyJGj/wqMqCLE6oDNS2NZsx\nGA4oChGs1E0tdEbbRjcNWV3Q+n5bygZsPC9gtdyw2qwJQ8HLfd9HNZ5RwAYUZUaRJbiezSZekCYb\nfM82JmjCMCnyAj/ssV7FaGWxSXJWq5hbd+7y2DuewA8C+oMBuoqxVfNAVq4sbNtF64YiL8QHvpS0\neWUrwxUWOK0uxQwsyzJev36Di5cuEUZ9LNvG90N0I8+OpawfMrYqjdDMMxRd0DS65ODgNs+8793G\ngsHBswPqmm59QYM2A/6HO1OxuxA6nqb5oXXewprtWm8ajcbYDVu2eIzY0p3b6kG4OQo+9guffsua\n+NOv/B8G3pQCTALD5TO1LaHrad0yOdVDXYFLFInXj2d8WBQQJ4kQG/KcuqpBFT90CGnA9wM6f/tG\nKLvKsun3fIl6NPc1y5IOqgsClyRORIXp2CjH4eTkCNtS+K5DmYvXe12XYAQ8GjkgP/ixz/3sQSjL\n5fKHaGvqoQ+r/XfTNDjKFkN5W6GbGuU4LNYr8jznxRde4De/+B+xM5pS5kVn9iMeJgH9fh/P81gs\nFiyXS27cuCGihl6Pi/uXGQ7HeJ7HarXoLDdbf+I0jZnP551XS+u0l2VZJzZqGlFHDgbihZ3nOUcn\nR7ieT68X4rhi75kkGY5j88Ybb/Da66/wD37nPyeJYwLf5/T0tPOzKMvSYI7x296zVs7dHjctXt7S\nyyylcD0Py7bJsgLXdzuOvK1KPMfFAgLf5fO/8isCT9x8k9PzU2bTGUUpcFIcJ+xfuMSdg7v4vo+v\nFOvFmvuHR8II6fWYL5dYtnhRn54cd1DTcDhkd3cXz3V5+eWXmU6n7O7udOrSIi9oas1wOGb/iSdY\nrzcisCgSTk9PBUNtNI5lM9vf6w7KOI45ODgQ4Ydq6IUOjz/6PvJcMPMWzjo7OzEsEzFI2t/fx3VF\nBFRVFZvNBtCUVSk2Csau1LIsJlvCUZ/NZihlc3j/mLOzU/Ks7A508Z6pSGOp3E/PFuIlE4WAzd7u\nBYajPpvlEtAcHR0TDQY4XkStHPqTMacn54YW1/C+9z7N5ctXWK3X9KIeZWVjWdLtrFYrvCCgyMU6\nt98fcnBwr1svRZVTVjm6loLBtm2uPfooUa/PdDblytWrxl9GDsLCpLFXRWmqPKurLre2ZzRGeu95\nLlVV4LoeR0cnhqIYENcprhvIMDLwRQ0q/yDPM5Ik7tSydVkZOXgpxmGGCtx2da35m28qZSkUbKIo\nfLAn0MYuapr67QvN0OTMYsT2rQiqQUzlRIMgeoGiKISqGfjkWcxyIcKaptGsje1zLwxBF1hWjbZr\nA1XKM7LZxFy5csVU5wGr9RqwKE3QehLH5iBShskmh3AY+OimJgo98izBN17iN2/eYDYZYyuF5YnF\nReDL7K3RYmT1cFbC210/1SFmy3FtYZQWE3/YpVDV4AYBWVNR0VChOTg44Ev/6l/zNz79y+xtbROY\nqbLypIJo/bnbSj4IAlrflHaAKMP91oMcQCrZLMu6g6WlESqDOxfGn3pra6sTNrQHRmvAhW1TViXz\n+dwozwQve/3117j22KN87pd/mThujXa8zqymHWq19+EDH33rwOYHz37NYO0/HHjaCira16KwAMsY\nyrfvU8RKQegDLUwlYc8YUctiseF8PidJc+7cPWCxWorUeLlkuVoQRT18Yy86nYxQusF3HB65cpnh\nYEgUhuRlwdHRCevVmsp4j2RZSr/f6xbsxz/2CZIkFS54XuC5PpbrdNSvdtDbdhZtTmrbXaWFDAXr\nqsH3A4qipBf1zGcFjuuYBB9xBuz3+w8SYMxnKD7W8vqGw6Ek8bhSfadpRp5XJEnGdLoNyLBLo1GW\nCGc81wyxdavcFZpcYTxukiQhCkPiOEEFHus4ZjE/x3Mc0nTDxT3hlHueawJbTCK5I+2+OP/JM2tb\nLmmSinDHVH7L5ZKyysnLFM91sJTFarXk7p07jMZjnnnmfeRlgev6aBSu46Eb81qzHNd1yPPMrBWF\n49pQN93vPc8lTlYMRz3TwdXUZYNj+4h7ZCnrRkFjujTbthmPR1RViWPZHd9bWUq8VurKDCWFYFDX\nNb4XYJvN/WHoFDB0y5IgkMSfX/rsW2mE3/rzbwihoBQltza5snXTYLtuJ9F3XHkPlmVh2Vr84oPQ\n4NVt8Vfj+y5ogeJae1fLEnhms4lxPXEjbRlV7XBcYFQJRMnzjCAIiDdrijw1XYeF53sEvqRO7V+8\nxCsvv8xoOCDPUqLApzH3R+YJdIPYn8lEnnaTLEsxt2k5ku3m3bmwKYv5akE4GlIWBX4U8o2vf50P\nf+CDPHHtMRqjdrRdm02Sdk54LXziOE6XsiJOgCGTyQQbqdha7+ooEv+NFmJZrVb4ftCxPfb29lFK\ncf/+fV566fvkec6FCxe4fPkyWmvOzk7I84LFeonlyAO4vb3NC88/z7Pf/S6/9fd+i8cevcpmvcb3\nA1OxJMYvpZbAY9N+uq77tvesqEoaNL7JA1VKIJ0Gjet7aPPhu65NUzXCLLBt4liEK77hLOdF1g2d\nbNvGtV3iOGU8HuF6Po7tcfXRa3iexzf+4uso1VCUKVpXlLUijHzieMPuzhYXdvc4PLzPnbu3qSuN\n7djs7e3jBwHvfeYZvvvsX/HEk09y+eIldna2ODs9pyxLcYUrK2xlcX5+TqWt7rkYDgf0+16HSy6X\nSxaLBWma0uv1mG5POyimrjRK2RwfH3eqwyAQTP7C/h6PXrsmg+bFgrIU86f1esnpqXQNOzsi3tK6\nJtmsyIuCXtCnyFYM+n3KImVn5wL9ngg5Nol8r+P5qRF+iG/I1miM7wvckiQZtu2yWG5I05RkuSJO\nE2jEbnbUj7jyyCUcZaGamqYqqcsKypQ0r1AmRMC2bYqsMOtBnoF7B4e89NJLfOADH8CyLcIoIAoj\nozeQIAvPDEAloEHCOOqqRjdis9tu3q7rMplMKKtcrCmCoCsGtFZEkfi+BIHHdDpFaQtLibhEGCUC\n16R5IeZl8znn5+cURY7r2NiWje/7xo897Nbjw5CEZVnUTU1Rtpa6DyjFbSeepTm5OSB/9Kp0TVOW\n9IOgU0C3ebmVbnBdD1OhdQeDrksUMiy1bRvPF1WkheQLSPVfi+e7I/sUGra3t7Atp2N/1UVOWcsQ\nVylFkkhXnRno1HVdoigENK7rkGw2eI7D8dExvX6f4aCPbVl4jiRgtTkAQSDU5bpufnYr8K//2f8G\n0H2g8GCS3TJU5CQ17UXokxQZX/njr3Dj1df4W//OF9iezqjriuPTU8JBn77x7GjpS71er/PBbjfF\nltYkWX8DgkC8CirjxZDnRYdxt16+ICnT7WCs3+9hWUJHXK+Xnbw2zzPyuqLWwtt9/vnn2d/b59d/\n7T8ApamKUgYpRh6tmwdJRO2h1dqAvu/nPvOW+/bSs/9X1/K3XUZbWbYD2Ma0fIEn4p1Wzi+bFNR1\nafBkz+CfFVLrKCQBRHjpvV6PP/mzP+XLf/xHTGZjtnem3L9/nwaHyXiEhaQgDXqhcKbnC2azLSaT\nKWHU5+TkhNAP2N7aIopC5otz8jRjOBiwt7vHoD+kKk1Ki+vhBMJckE6i7N6XuFZWZtPJyfKcqN83\nc4OKPCuZzbZEvdiIIKOqSoLAZ7Ve0jRQFCV983c28UaqWS3V/HqzAS1r3PPh+PiU/f0LbG/v4jo+\nQdijadoJiRY5te/hBcLAEV+XmrrSxnSr5ODufcKoh6UsZrNtcmoxN7MUuinRdcVkNKDMMmgkn7L1\n+shpcMznaBmWiu/73L59m9deu86TT76Lra1t0iSVahYtSUR1jaXg9PSU4XDIZDoVdojWZh4ivvny\nWquuw2mfo6Zp6AWhuYcCcxwc3CTq++zuSscZ+hF1pShLoRc2jUjnHc/v1nCLceumpjJd4Q9vQoo8\nz6Sb82Xo6Lji+x4EvsGztelGLWpj5tXUmo//4lsx8D/4fdlHqGtU58fiiIAMJKOyedDpaxSOJSEw\nTd3geXLw1caSoxMgId5DCtesKXEkBQRnr2sMSmP+fo1liZd8kggtdDDom7lWQmAOss1GtBG2IxAf\nWmMrTW2e2dKYsJlpBZZt8/T7PvmzV4G3VxuC2g5BgG4q7DiOJMnbFufzOSfnZ3zzL/6Sz3/mszRF\nRRYnOK7LpcuXyXRF0NislivhpVoWdVnRCyW8oKlrqQg8jygIWW4WHNw7YLlcMpvO6PcHDAZ9kuSI\n8/Nzw/vNuHr1UYaDCePxlF6vz+npCUVREoY+URQSRQGL5Zy7B3ek+o18kizj+e99j//wi1/k4sVL\nrDcrAt/HQtHIdAIzpcA1/iiu45qW0u+YLz96PQwLtTBKO+xq4Ye6rg0+qfCcgKLIu0pdMHK3kz03\nWjyblVIox6HIa2azGefnC770pS/x+vVXufrIJTbxivnJMf3QZxFnnJ4d0VQNdVXwvmfeS5YlhFGI\n47mcnp/jJymXr1ymLioOj4/JDY1qMpVQ55dfeZU8y/n4xz4u841aU2mRe1u2xag/AA1ZnpGma9Is\nNd2JRRSFxm9DmBRVXfLGG28YfDVgNpsYqCagrxs81+98U55/7jne+c530u+JlL3l8rdyc61THr/2\nGFleoJTNdDIW/NNw2tMsJU0TsixGxaqbi7RFSJrkvPbaa2xtj+n3xU6hbhpC28N15cDuDftslith\nmrgS5tA0DWWtqYuKkrYjtfD8kCzLuHPrTe4fnfDJT37C5HWGpGmM4zqdSlmjJcSiqam1fDZxmnem\nU22V6Pkubi8kTVIcpwdo6lo2zLooO0dH23bEC99zOqZTFIQ0tUKpNnyloG4EXmyj0QTyCHBtB8ex\nOs1EC4/IPEjYG8ulZKcanmDHxHrY5M73fWzXI4p6b7smxpMxRVniKgyZwKKqayzbRjWa2gRCgEIr\nqexDL5IO39ZYFuhG7Eceik7Hdh3QMm+ybAcrcHBdx3wvcAxVsqwL6roiTlYsl3O0htFoZKjRJfFm\nzWw260gV6/WaxWIhiUmeR1XmVGVFU1ckSU0bqm07LqCNA+WPv35qG3jbqrUv+OEPrf1l2zZZI94K\nuxf2+Rf/8n/hIx/5CO9+11PovGR+ekpjQXxQ4PYjhniMx+MfoieKpHvUYW51VVPUBaPRiOl0YgyA\nStI05eT0BNu2eeSRR5hOxTJys4m5f/+QW7duo7Wm3+8xnU6MTLfh7OwU27G4fPkiq9WK7z7/HNiK\n3/qt/0QUjWmC5/umKvZQysJ1PCMeetBtPFyl/DgIpdINjZKYuaKuKI1rm+u6rJN2gGJRVCXKeEy0\nByHQwTPtz5MW1qbRDWWa4nsRJycnfOtbf8Xrr73GZDJmvVkQBR5VXeG4Nr2eDBVd22Zvd5eqrnE8\nl74foSybskq4svcoB/fuoWtFU5c89dRTWJbF6fExr92/wXQ8Zm93j1dffZUokirlwuVdPF+SX9br\nJSCdVBj5DIYRyrKoTTUXbzImkylNo0WIlbZtsy3inSTh9ddfN94c4h6ZZRkf+MAHOpiuqqqOctl6\n1DS1hReFYjSWl6zXS2zbI1/OO5OvremYMAzJq5qyqlgu1lR1RZYJ1XB/f5/ZbGo2ImFDqFLjeULp\nTJZz8izBUkM2G+GaW5aLZXko36XvhYR10Vk2+J7LSy++yFPvehdZFuN5AQcHd4zbXo5qNGEYYHse\ny/ncxJpJukzQi8TGtSw6TnKSbGQwZw4O12DDWZazM9syXRwEfkCSLlnH50TRlLOzM871OVpbeG5o\nOmXpRloPltZ8rmmEMQN0qupWcR0EPSzLxnUVrusxGDiiFjbPZ/u8Nk2D5bhmmLshSd5+I1uuVlgW\n2J6P1g1V3RibBIeirHCUZWyjrY5ajHFPbJq6Y8SIoMeideRU2CilaaoSS4nQp8hFiPSw8VutS5TS\nxMmGIPDNc1XTNJrpeILvBybgIWSxWFDkuUxULGVsDGwspQiiqHsOq6oylhc2gR/8xH30p1iBy5S2\nUdK/tq5+TVHhux51VZKWBUUYEXg+f/H1b5CtYmbXxizOl0yGYy5ffRxtWRR1RZJnVGlKo2y0BctN\nSpKck+clnnfWJe64tlQMJ2cLwVsHA6oGev0RYSTm+sp2OLh/iOO4jEcjhuMJcRJTFoKll7rg/PzM\neBvb5FXB8y+9aBLGf5X3vuc9ANRFiefYNHVtNm9F4AvbJIgC8iwjN+KFRgv3tdYNtvNjrDM9vxti\nWh7GFdG0h8ruHsYai6ZqcF3fLMj2ZH9oQGyLRwlo6rI2D3/Jt7/zHZ77/gtMtsVD2g080DWu1jRl\nTb1J2N3ZZm9v3yRwh0xmW/zJn34V2/Xwwx4vvvwKWmsG0ZDtrRm37hxQmir8nY8/ged73Lz5Jrdu\n3aLIc8Nfl8rl8uWLXLlyxbADpK3NsoyqFCjBsi2Go4HQrbC6NHbbEajEtm36fck2XK/XfO/b3+aR\nR66wY4zIPMuEA9uQJCmB66CrnDjdYNliKBXHMePRGMt2qYzDYd1UFFWDVSrKusQyEWfecIjWkCY+\n2SbF0hAvVgBYlsIPAgLXI4szhr0+qe3g2pZAKU2JasTDRNkORVERBQEKTZ4IJbaoS0bDHpOx/Bxl\n2ezv7kkwdBabTVhRlDWu54kDoutwenrK3t4O1DVZneMHPl4YkdkO/zdzbx5k2XXf933O3e/bX+/d\n07NjAAwwGCwSCZCgKEI0SYnRYomxaFouypFV5SQVJ7FViWOpUpWSaJWrZFGyLVmOo1RsWZYUaxct\n0lZICVxAgARB7Nvsa0/v3W+7793tnLgBUB8AACAASURBVPxxzrn9BhtdrnLRl4Wq4fR0v9fv3vu7\nv9/3911kKZGhrB5erieIWwH9/h5KKs1vHg+p1SKuXV/j+Ik76LSpsOCy1EyhJBkjy5JCJdWuyMKP\nnqdl7L7nUas3UCij0ch0x+wGKPS0XWYlEwM/+V6A7wdkRUm3pXUC9XqEEG99T3TbczrOLh3jOS5h\noLv4fDIhCLVLY6lKFBKhJAIBruasC08iKaCUlDJHCEd7FakSJbVjpnA0k8YRWoWZZRkIgSxLU+w1\nDBN6ggJdiKMoJvAC0qwgzxOiKKYscnr7O2RpyuqhZeo1rcrU1EcPqaAwcZCe5+G4wjz03jkT89uq\nxCyNSskoFvRSKKiTTVLAoV6r4cYBN2/c4DN/8ic89l0f4O5Td0GpuHnrFllaIFyXRrNBrdHQvGUE\naZYThCHdmdlK1trv97l85SpJMmR+fp6l5QWsrL7fH5BnBZ7nG8MbYXDVkvWNDWoNPb41203iOOa1\n11+lVosZjxOUgCefehLP8/i7P/VTRH5AadggnpGRuwbftF1fmqZ4pWZbWIMd+zXgbdWYmfFMtxJz\nJfUCz3phpCZfUL+eIApj8kIvmLRoSS9otfWqpMgywiDQVqOuw0uvvMbT33yamdk50jyjVBJPOJR5\niSsE/f6AY0ePsby8zJEjRzl16k6uXb9BuzvDj/6VH+XZF19kY2uLKIrp9Xr43YCd3T2ySULo+YRB\nwOUrV5hMtG/G0aNHOX78mKH5NXXE2XjM+vo6X//61+l2O9x9150URcHKyjKTyZjJeEImdc6i5wYE\nvo+UMBwO9EQhBKNkzMbmBoPBgHvPnNZ83yQhDAKGI50RmeUZrucQxwc2CEoUSAlxHBvK4YBkot0T\na7UafhBVGapFkVeUUlmWrN1c48iRVea6Mxq+Mx2n67jkeYFwHMbphO3tbYTQN22r2aAoJDUBVfq5\n41HkOWWp4bHROOHw4VXQtwj9/Z6mijqu9rxx9H1T5AXC0+k9Yagf9Lu7u8zMdnEnOowjGSZG/aiL\ngu9r9a7Gf11qcaS5+EAuS8Ig4MKFCzz8ru9kOBxSrzcMzKCo1eoGx47IjExem1zlDAZ9ze82O5g0\nzUxnXhJFATg6kSuMIjxXIFyPuVYLlGA80Vz8IHLZ3d2uOOd6ufnom+6JnZ0tfX78kDxLjTWtvh8E\nms7nux7CtYZzIFyFMBERSpY4jiJwdV5lkecolJ5004wwCphMEqQsK9KFffBZXD0MO9RrMcrX5An7\ngPI8H0fAZDJmd3sLz3VYPHyIRj1mYqYSOMj/PbDlvT1i8h3r6Dt+9T/zEUeR7gTNcihNDU/TZNhZ\n744L5y5w/9kHaNSbhFHEeDDk2LFj5HnBcDRikqak6aRiJGSpFjRsbGxUvhea/jfLeByjkJw7d67y\nxuh2u0RRTJbmFc0wSZJqg47Q3fHW1pYZjXXnoBkpL/G93/thzp49W+GR9oR4nsdoNKrG74ObX99A\n1kLAQj6WMfN2xzS90qaweJ5fLUIjwyIQmDgmWVTS5izLjEjCNR2rR+TUKKX2TCnSnCe/9hSdTqda\nwtSimGTYAynJy5zTd59mdnaOBx54gCiKGQ5HLMzNc+XadU6euoszd5/m+vXrZEnC6soyk8kEWUpW\nV1dpNxqMkxGDXsqhQyuVsvXmzTVwHOpxzOLiovHunvDggw/SbrUQQsMdFy5cZHZ2hkajQSw8XNdh\na2uXV8+fN0VRT1YYpsV4nHDmzH14kU8/0VBSmqQ06g0muabROY6DErpDK4sSqXIcR9MZ7fkLfB3N\nJaU0BcLSRl1arRrtVp2bN28Shjoerd/rVfQye46FgcnKMufYsWOMJwmjZESZKBR61+J5AWEYMzGv\nIRyBB5TSZEf6Lo7j0mzVCfxIS9BVDkjKstAWrsLF9Xzj/CdxhMelCxfodDvU4jq1WgPPdRmORhpb\nVSVFmeIIhzRLcISDMCZZrueCyllZXuDK1cucPHlCd/tegDIWA2UpyYsRpczN9efjumFViKZFdeYC\nZjzSC+Qsy+gneyj09BlHNYJQQzOu4xN4bhWwAgfakDceURRqHcHIRMONU+0+6ek6YF0OhdDnwvU8\n8kIn9SChLHIyWYCUGopX1stfw5CjROdx2lzZOI4rG43piUMIRztPep72iHcdgtBHlZL9/RFZlrGw\nMFdFxyl1oEC3DZuFjqah5P9iC7hmfhQ4dhnnR9r4JxkT1mJKJZEoJonkq088yUe/93s5tLTMcDAg\nn6RMJhonbHdazAchUklu3ryuucNxg6NHFyuq2cbGBltbG5piWAs5dOgQx44dZX9/n1u3bnH+/HmE\n0EupkydP4noCR+psvs3NTQ4fPoRwhNn0623+n/37/8Dq6iE+9bM/x87uFplZ4nRaLe3oZkQLQCUw\nsic9iqLbaHz2/0sp6XQ6b7u4sKIdO3pZAYrtCizP2Rpe2TR5eyFYxZ5WhkVmMTchDCN+4Rd/kbmF\necaTCa6rp4d+f59Os8n+zjYnjx2jFtVotTosLi5rYUhWgOtw/31n+cY3v8nd99zDxz/2Mf7vf/n/\nUAsDsmxCv9/n1q2Cy5MJvuPy4P0PkOc5e70+Fy9fYWZmhnoU4wiXF194keFoyNmzZ+l2Z3nlpRd5\n7bXXmJuf4b3vfa9hLaQMhj0ju8948MH7GY/HdFpt8ixnMByQG/x1MBgQRCE7e7vVgyuSBckkOfA/\nVwIXF4mkHscURcloNDLdkaReq1EziTS2IGmztTGDvva4DsOA0ajP/GyXnZ29amlsYYXM2NcKx2Fn\nf48w1BYPSaKX8LNzC2SZpnmmk4lRE1qjtIgiTcmnLEmRBVHggfBI84k5t05Fz5NKEMdNZJmzsrLM\nyy+/zDe/+Sz9/pC77rqLI0eOaCqt6xqzsE5l8SCM+KUsc5LBkDP33M2f/ulnOXHsqPYZaQW4vo+U\nAuGijZ1cu9QsGE/GVYMCVPstu4Bv1Rt6WSl14IP1C0rGCYNBT5vA5SWlLPGCoGps3q6QNWqhlqgL\njSF3ZrpkWcpoMCSOQ1zPxgJisOWCIHTNA7vQy1NHkJeSdDyhKHSAjCxLklGC4+l7ajLRexc7MVu2\nC2ilrOM4eEoyNHunVquF6wg9MZqdRBD4DIdDswyNKiol3F7EbQMIBySPtzu+fV4oj/8RDjoqqchz\nBC5eGJCVBaUjIPBwXJd/8ulfZX52jtOnTzPTahNHIb5z4HyWpikjE7zQ6WhDqMkkRZaS3AhBXNc1\nKrfMnIyxkV/brzuMjIqq3+9XjBhbHLXgQ3/Yr7/+Or7v89BDD3LmzBnTPblMUs1RLvO8KuC287AG\nN7aLCMOwojfaRdp01yal5N4H3/+mz+2V575cCX1st15BKGYBpJQWm9gUo2lxlA721c6PUimGyYgo\njnn2+Rd4+utP0+522NvbM+nYGZ7jsLO5wd2nTnHnHSd5+N0PM0xzbly7zrFjxygLXXTyvCAvNd+4\n3mqwsbnJa6+/zqUb1zT7x3Xp7ffpNFscWjlE4AeUpTR8dk1hS4ZDfM9jcXGRvMh59dVXiKOI1dVD\nzM3Osru7w/7+PlEc0mrPYu0OyqIgNF40nrlRPVd7SO/v7XFla53V1VU9/RQlYzNZ+aYoKAXyDfCV\nMinseiFYGEMl7btuoT7Pc8gz3XnmWc7a2hqNepN2u43vB9V5CYIAZZWFjnbWk7LE8RztYNjr02rp\nMGiFMLmvwghg9Dkr8kLTNs0kqZ0aJY7nGBqhdgjUKT1aWSlliSoLNjY3ePXVl7n3zH0cPXrciJoK\nc+04hrpZGIjAsYQQyjKl3tBJPD/zM/87P/upn2M0HBOGMaUEPf0LfM/HcYuKaeK6XlUwLSXQxhJK\nKZEThXCUoRfqh5SUFkpwzXnQfHEpXBxjl6uU4uFHP/Cme+Lxz38Gz/dR8mCB6vte5SMjZYkwKVuu\no3MtM3XQIJVFwWQyppQlvuGpC6E7cwBJSRhG2tDNQJNKYX5PTVH0DW3RjfwKpskz7X+jlCQOQ7rd\ntglO0ZTFaWbltC2Gvf+r91eWPPjwf2Iiz3/Ow3VdPMfBEw4qkwRhqEUqYUwuoDcZ8bVnnmZrY4sf\n+aEfplarkSVj9vb2GPUHzMzM0O12abdbBKFPqSSDQd9Qj2I6nU6FUe7t7dLva7724uI89XpMkSsm\n+z3Wb21Qq0cV9afdbjMajdjc3DTCkRpBoPMOP/vZz/IjP/IjPProe/VirSgMXppXwaWR8diwFDXN\nl5WVcMl2cLbo2geRHc1Ho9Hb+oHbFKNpWpYVLdj/7OuOkoTA+KEoKQn8gKzQyTul0rBJrV4ny3PO\nnT9PXK/RHwzM5zbGc122NzZ44L77EAruv+8Bdnd2kV7AnXef5rVXXuGhBx5gfX2dWq0GyuPm1k06\nnSbzMzMc/Usf5IULr/HsM9/k4sXLmobWaNAfjWjEChBEUc3ALKVmHPgeN9dvsbu7y8LCIkeOHGZ9\nfZ2nvv519nZ3ec97HmF1dZWba2t0Ovph02w0CEKPItfqOseB3e1d9s3Dt1GL2d/dIU1TDq2sIIuM\nerdNnmVQasy8KHUhDqMaNpZsMpngOA61WkSSjHEcj3SiVXX1RoM8LZiZ6SIl5J7D8vISQmgmQ5ZN\nSFOjjEWQS72obzRr1BsNLaQa69SadrvDYDik3Z1BlpAVKZ6r/Xs83yHPs4qWd2ttTecrzi9SrzfI\nigypNF/ccQwVF71zKcuc4WjApUsXefe7383KyooWBqWJYVlIXMdcjy6UgOtafxItBivzjDAKadQj\n9ra36czO4XshwvEpS8VgMGQ0GpKlB4ZgjuNoeqNwqonTD7RHvuM4+IEPQgu+SmwzEiFLzeqZjHXI\nh35fkRHaBPj+W5eqZlMbUvUHY1zPQUhFGGqlaJ7l2pNFKVCSUjhIAaUozINUR5c167WKlWKVkCgN\nVZbK+M4Ijanr2mXphMJg6Pr3HBubYGs8VpbagqPZqFcTuYZRvQqSsfe+Ldp2IilN4/N20JE9vm0d\n+Fe/+McIqaCUCKWxt3GW49djMiTDLOXX/sX/yXvOvIvl5WXiMMRzHeZnZqvuNk0nFc85CANcP6zE\nBVmWaRpaHN/WTY/HY3QQbFB9rZR5RXfKsowoCqufm+c5Vy9fpiwLPvzhD7OwsMBwOKzk2QdCmvL2\nLlhoSa+lg9n38EaMy1IG7ULEjp93n33zwub5p//8tgKuT672MK7UZ0WB62lIQJkuV0lFnmV4nmYp\nILRc2/FcnnjyKb7xzDM60Xs8xnEEeZoii4Juu8Xy4iL3n7kPWZQcPXKUvvGc6e3t4zlCR4OZ9+x4\nggsXL7C6uopUikSV2iB/aYlnnnkWFIyTCYdWVrQxWKE9srUHMuR5VvnA1+ox29vb7Gxvs7S4wNLS\nEqPRUAuE4ohjx46ytLRcObr1ej18z8VzHZaWltjb26fTaTGcTLSFrBCEQcj8nDbd91ydoen7hrIm\nBJmRxetzYiTZpRZw7e/vM5lM6O33GA4HFMYA6q677mJ2do79/R6HV4+glKDZbDFOElzXR7gOwnU1\nDbLMyfKMuKYl9rrDz+n3h+zu7dPvD5FFSafTNr4gEcloRBD4JMkIm+MZxTWahmdeb1gLAcdIygsT\nSCwYjQbs7Gzz0EMPUpjp0/5+02Zv0w9+Pb6bgmecHP/k332GpcVlTt112gimQDiaJ+37gdYXTGVX\nTlM0LeVOR60Zl0GUEZQVCJR5CB10tRZb9oVfdd8g+cBHfvhN98Tjf/b7pGlKJhXNZkMrTpXEM9OI\n/d30VFFQlgWeESpZuMgWc2n54wd1CsmBUM4R1lrDNf+Zz916q8uimpDzPCMMfRpT/PXpmjBt6FVx\nv123ahxsPXAch9P3f9d/eR04pgvE+NCUShE36qSGV/zqs88xPzvPu77jIZTU0U+3bt1i7cZNwiAw\nKeQNut3ZqvgWMq3I/0ppEvxgMGA00vaQMzOzzM7OU5Yl+3t9g0f5uJ5mo+ixEqxp/+c+9zkWFhb4\nvu/9CIdXVxkMBlXBtjl+9kI9KMjubU9PezFb6MLKh+3XLVY6/SDV6s83H1ZqP/2gsBFm9iFhT7pS\nCjcwnFI76uc5RVpqDFMoKB3+4vG/4MSJk+zu7hor2xGqKIjCgHarxSMPP8zS4hKTUcLzL7zAvQ8+\nhOM4tNstrl6+zNzcXMXi0IyJw4yShJMnT7LR79Pvv85jj93L7k6PT3/60ywsLJKmOcvLK+RZrgUf\njgeOwgGaUUyjWWewr31Yao06e/0+61ublGXJiRMn6HZajMZjPvvvP8fK8hK1WlzBJAq4unaTsijZ\n2tsxwinF7MyMzoscDDRsJhwKVTBJTHBuEBBOLZEcR7C2dpOXXnqZ4XBAZBzoTp8+zZ2nTjI/P0tu\nPFliI2WXqmQ4GBKGgY5Qcx2zFMuNak8QBgHpWGsAdDTeHrfWNlhYWGR2ZoZBf2jS6TU+7Qc6xxLH\nJUk1TLV3+XoFU8zPzhCGEQsLC7rL9jyisM5gsE8ca98eWwwC362aEoTA93SAcJ4dXJvC9yuqIAgm\nk4xTJ+/kytWr3Ou5ZKqkXquxv9ej1miCKhHK15L/8sDPvig1pBX6AZGvE3ekLPHqPnmWalqf0MAR\nQkM+2i3QMQ+XAhdQ0vJe3lpS7rkabpV5iuuUuJ4JJXdd49QIvtkRSOlQli5KaStc0AIehUC4Lq5z\nEGFn72vHEyiJdh4sdbdtd1plKfE8HSYCepqTBhpq1utm+i5wnIPkMd2kSYpiUn3mFhK1E3m1y5AH\nhIi3O75tBbyUBbLQeK1nsLNJlmn6zjDliS99me/54Ifo9/YojCXpyuKCMTXSktUrV65q/DiKqdVi\nHN8sNByHPC8rBoYOI85IkjE3bqyhJJXfr8a4JyB0Yd3e3mJjYwMpSz7+8R/lnnvuAVmSZxnzc7Mm\n307SajZJDKvDEQLPWFLmWVp98NOduGWhTHfgVlBi/256jHqrY3prbUcr+/S2HVSWZTiug+PprsN3\nD9gvYRjiKl0Uk3TC5/7Df6DT6bK7s0tZ5CjpaM6y4a0fO3qUxaUlBv0BoR9w/ORJNjfXWVhYABSH\njx7h/PnzHD58mFJpUYjEY7y3z2vnL7B46DCD/pBP/dw/4PkXX6TTnSXNcp59/gUajRZxVEcqgesI\n0iKvFrTj7V3yLCWIa3Tn5tje3mJ7dxdZFFy9eo2rVwt2d/fodDpkZcHpEye4fPky/UG/Wu62Wi1m\n5+bpdtsMBwOuXb1GmqYcWV0ljGM8z8HlIDgkzTJGw6E2IRqNuH79Ojs7OywvL3Hk8LtMEHW98oIf\nDYd6JPY8At+j225RKkUUzQIlUeybsGCT2q40Nl0U2iwqGQw4//o5Wu0Od999J6Nhwmg4QgjY2tqg\nLPUyVZqRPssy8sIYMwURea7pb5s7u+zu7iPLFzlx/Dgnjh/HdQV7u9ucO/cax48dpdVuEYU+rkMV\nYG09qx2zjKsYUVlGFOkCXa/XybKU+flFnnzyKTY2NlhePkQUBMzOdkDppHad26GxY3t96kJuMmzL\nAlUUFEXG5s118iIn9DzCKEDL5g39VTgUpfYpB6gFmg0kpTSahTcfjtCTXD2KCM2C3jFQln4HUBYl\nRalhE4S20z3o7EX1c7RLZVE9wC3GXRQF9XpoKJiGO++6uK4wNMmJKbT6Z9XrddPcWZGiwjo/uq5v\n7tv8NijUptnbGmAbvW91fNsKuCxKXDPSlwqSyZhmu02a5nzl8S/h4rK6tETdc83iMaUodWcqhKhu\nKBQUueaaamWeIssK0333kbI0kucGruvRqDfJ85I8T6vkjNzkU/Z6PebmZnj44Yc5fHi1YnEEroOS\nesPseR6qLBkYTF0okFIngkgpkWjjdjsaaXeytBqtrNzddq1we0G2I+1bHVauDFRK0+mFh/anjhGu\nAEfhCo/SeCvYaSHPc/r9AZMi49r160RxzKg/xPcDlCyZTMZ0Wk2U8YnY2dmhUW+glNCCDNfh4sWL\n3Hv6Hh3aurRIYRRtjqdNpY4cPcq169f51V/5Z6xvbgIOy0uH2N3bo9XuMD87z/rGJqfuOIVrOi7h\nOBRSanxe2+4xSSdsXbvGcNBnkqXMzc4R12pEAczMdukPBly+coX+cMQ41dt+rQwN6bSHvPDa6zRq\nPgsLCywvLVPkBbuDHju9PRbm5omMh0c2SYnjiPn5efb29qqH4qlTp8yCyiFJEiaTMe1WC6QkHY9R\nRYkf+Gxvb2tec6izL/f29+h0ukilF3a+Z+TdjrbfLcqSSxfOcfjwKt2ZWfb3+pRlThwFTFLN397d\n3UV4Ltdv3EBKRac7w+bWDgqIa03a7Q47W+sIVVYuj6+9fo6r165Ri2PuvedufuAHfwhZ5ly7fpO7\n7zxJbhgr1q9k2kfHWtQGQcAXvvAX1GpdwtDXDZEL6SRjPJqwsb6G42iKXr3WQEoFjovjOtU1af1i\ntIeJLppBqKGfWjOikDmesGZsOZ7bJk0zlFTEcQNZlgwHA5qtCPPc4+2Q3jiyOZ4Sx3hoG3NRMxFY\nGwHt0KlQqFIile6+i6kJ2H4GjuOA0hGLOqwiYjLRtafRaGhPpNJ6nGs4RUpJWUi63TaOq+EyKQ8g\nEn2vgpQZ3pRRlX1Ne9jzouPmnG/JQvm2FfBaXCMvJYVSSAVxo844Tdnd2eOVl1/mse9+DEfCzvYW\nQRjSbDaN3FkZwxhN14rCmHq9QbcbkJZaGDQea4bH0aPHCAKPW7fWuXHjBukkI44bpsPVT71z586x\nv7/Pmfvu4f3vfx8nTpwAVOVgGEY6H3JoQpbtU9MKcsCpiq4dgcqyeMvxCKhohMBti5/pTfTbc16j\nahQDpgQOB9a4vu/j+m4VeeUgKJVkf3+fer2pxz8l9ZShFFIpjWMiSXNtJl+La3zndz7ImXvOsL29\nw8VLFzm8epRSlsRxyNmzZ3j15VdYWTmE7/tcvHiRE3ecZDIeM7ewyJe+8gS/+Vu/Ras5S6PZ0osh\npfjAY38JqwLd2drm6aefZraroY1ap2Xee6BtNR2HmivIshSpFLks6A/6NFtNkmSAVIpH3vMejp84\nSRhF/NIv/zKO67G9u4vn++wP+oySBFTOxWvXadTruI5Lo1ZjptNlkhbMz8/TbDQogP1hws2b62YK\n2+bYsWNsb28z0+3qJaLvkoxGnD93TusDanVqRj7u+wG7+3ta7NKsm65sXE09OrRAsyxq9YitLU07\nPXxohSSZMDenMzSfeeYZQKsoz5w5Q3umy4+srKAcVwcxS4Xnh9xc28D1fFQxoRZ6DIdDbq3d4tKl\ni2xubRMGPtevXeW55+a5//77WFpc4Oq1axw9vAIcsKLszmU4HJIkCRsbG1y6dImPfOT7cZ0GeZEa\nPrPLytIyL7/8EotLp2nU6iYfNSaMIjAQXlGUZprUIRPatvjAu0cIEBICJwAhUdKaj5U0azUc4ZKO\nM1whWJybZ1KMqvvh7bpRawdgGyKLtReFhoCE4+IIUMrClRJVAI7+XlVqurK9r+w9ZDvvuF5HypLZ\n2ZkKjrWvaVkv+r52CX1fC7eyDKkKXN8FITU2X0ryvGQ8ThmXE8LwIFJSO0n6twXb2ObsW7kRftsK\n+GQ0ogCE54HnkSQj0qzghReeZ3ZmhpXlRYo8p1Zr4DiCoTH+j+PY5FV6ZuOr6A97OEKQloJmq4lf\narvHnZ1dTf8D4lpMGIWAYG9viysXL9JsNjh16hgPPvCA/j7fI5uMtVOY5+IailOaTypmiOV/WjaC\nVJr9oFVdumstS6fqlKcx+Wl+rL1Ypsn7053AWx2FKfjSLGeEo5VkruvhefpmHPQT3Q15LqqUCGOY\n1Wq1yc2CyQ18zp87Tz2IGCYj3bM4gnQyZqbTolmvc3hlleFwqEMa2m2GozFSKbY2t5kkE5ZXltnZ\n3WH18GHuuvdu1je3EI7Hv/w3v8O58xeI6x28uE13fonZmVnCKCBLU+JaDFJx9Mgx7rrzTjOCSwZp\nj73dHdY3NkmzlFa7RS2uEcYB22vXGAz2EUjas3W+/7EPs7i4iG8ZP7LkPd/5EE88+RRz7SbD0ZDR\n/p42vCpLxr0B/+RffZrrV6+SjEb8+Rf+nCdfeBElBLVGg6XlJWqNOh0vYOXQKuzucvnaNY4cPYrj\nuly7tUZRpMRByOLKovbKzlLW+lvkaYErBK1Gk4X5eTzHYTxK6N3aZtTXXuROPabV7SCUIs9ydjZ3\neNd3vItkpOXyw+EeZSnptlusb27ywcfeR3dmhmScQp6T5WN8YVhbjuDE6hI4DkJIHCRZ1ubo4UM8\n+t6HAcX6+jq9/T1u3Vrjq089xfqtWxw/fpQ77zjJ/fefZWlpkd3dbU1ndAVe4LF5dRPHdfi+j36f\ngQKHWuxCQZ5BFGsVa6fd0YEbfkBc0wlSjqeFVZ7nIqVZgmIKtrDBxMY+1qiu7UMNBK7naRk5JW6o\ncfpMZlVEIOrtEjGpdguFYX84BkKlFCB0xy0NtRKM2tHT0nqE7tcdBcLxdRgy4Lh6iV2WIEzA8P5+\nD6V0DGGaptUD0DJOwlArsEfJCNd19ERZ6GI8Hqem0RKGA041pVuoZHoCmG7g3g5Otce3rYDPzsyS\nFjml45CXCkRBuzPDc88+x4c/9CFQJqF8NKTb7RqurKbS6TQT3UnEBs+M4xhSyauvvkIQ+LpjDzQm\nNknHSKXhgSeeeIIwDPn4xz7G6uqh6mmXpWOUNEn047L6QJVSxsjGeJbIqdDlLH1Tzt8b6UF28Whx\n8OkN8/Qychrzejs3wrI4EP/YnxUG+mejtE94FIYgMIIcD0cqkPoi1kyIgmatzksvvkS33Sb0fITv\n0u/1aLVbDPp9Dr/rXcY3PMF1M+1v7ugg2IX5BQaDARcuXeDs2bOcv3SB1cNHyKXiZ37673PX3fcS\nNdrcdedphFej1WrRH+wTexGR6+MIBy/0QEBeKEqz5Y+jCG9hgSPHjvHSy6/QHwzY2NqiWYtY37zF\nX/3R/5rTd50iyyYs1ef0BJQkun+P9wAAIABJREFUBIGnHSG3t/EFyDwlS7QQJ/B9lOtx+eo1Nm+u\n0Qxj5lsdXnvpZXAcGp0W/eGQ/nDEVm+fr507j+O4tLtd7n/wIc5dvMja+i1muh0W5udpzXYRnsu1\nm9dxRjmNWp3IcVlYWqLX6zORKfuDPl/+8hPUmg16g76G4fZ7pOMxjUaTRx99H1EUMb8wz2Aw0OKy\nqKuvmSJjbq7NzvY6WZqwsnKY/d1dZucW9VI+TUmHY4IoRHguSTLC+rzb68nzPGZnu3S7bY6fOE6t\n9iEuXLjAFx//C77y1af4s8/rLNYf+7G/ius4FHnG008/TRRFvOeRR0DBaJToYAMOpkMpFd/93e8n\nGSfmvtOWExbnthzuMPRus4W4neMstNLTsrCm9kSOf1CibWlXpV5q2iL9lofQalbfBJ/b+6s0y0NV\nvbbBlYWGF5VSVZKiQIDSwd0C/ZpKoaccdcCr1wKuSdWIWefFdrtz237L1gPfO7j3LdXQ3vP2vRZF\nYXIB3Cp9apoS/K1w8G8bjfCpL/wBSZYS1WokaUbcaPK7v/d77O/t8z2PfZDID81CJTAp22W1CLTj\nkv37fl9HrHleWHmfKKXpX2u31hiNBiglOXr0KHefvpsTx4+TjccV9Uln/jmVsAYOCrXnaZP8sjhw\nTQSjrjQmUXZxZlNxLN48/WeLZVloxb7GtBPjgSeCw+n73/emz+2lbzwOHFjv2uXWNKtFy7D1Re9o\nTzVAUALSEUgB/eGI3/yN36BmEkmcUGPljpKcvvOUNp06dYfuIkrN0W+021q0oczF57rcuLlGWpSc\nv3iZP/6Tf0e92aUzM8/S8iphVAPXULWkxHEEge9rvw0EspQ6SsrR00IuMzS9rGCSTQyXesT+7jat\nRp2P/5WPMRr2aNTrjHd7+MYFbzAY4Idalv9L//gfs7G5UQmZBsMh6UTjvQ/e/wBHDq2CUnzjmWd0\nRqLjIny9PO/OzrK6OMurr7xOXhQ0mm2UgJWVFWZnZ80YXjLs7WsvnahFvVajkJLN3V0kilE2IclS\nunNz4DlEtRqD4ZC4LNm4ucbi4iJhGLGzvc2DDz6kl3tKC4dsOtCNWzcZjxLa7Rnm5hbw3QDfC7Sp\nluNo6aNQlEp/plakYmGR6evKFghbJPf29rh65TK93j43blzh2NEjzM50mZud444TJygM7c9zPRNH\npqrrKs8LhHDY29tjZmYGpXRD0Wq3qyAFq3uY1iXAgQWE/nkHTYuFCHTBfvPU6YoDVgjAw+//oTf9\nm6e/8hlzXx0oNQ9gSM2ymZ5oNa48Mf/O/nsLrxgxkbEKEI6D46iq3kyzQuxkPQ2pWkjqNjvsKWjH\nft807GN/nqZbFtXezBIPhBDvGGr8jh24EOIw8BuAph3Av1BK/RMhxP8B/CSwZf7pTyulPme+5+8D\nP4HWBvyPSqk/e6ufPZpMcAOfvJQooRdjzz33PB/+0IfxPJ3Con8Z7VPieT6TyYTd3X1GIw2n2Kg0\nvbyrMTRbfCkLLl++zI0bNzhy5DB//cd+jFpdjz6NRoM0TWm3tTLKFlhbEO0FYP+cpinSdL6BkfZa\n/xLH052w5ZcD1c+zJzRN0+pk2pNjBQ52uTl9gpVSVRf/FuejOuFWMGCl8faJrpTezkgUnhdUr5ul\nGY7vUTqCJ5960vh9KKI4okCSFgWh77G/v8+HPvhBBEoveNAMm+3dPa5eu0ozDrnzzrtBOBw7cQef\n+dPP8YXHv4zjN1g9fArHj5lbOMLNtTVm5pv0+j0WFxYZDQaEcZM0L5BFaRRpZmmTgxe2yfOU8aRP\nu9nl8tbrLMx1ufjqKxxdvp8v//nj3H/ffSwcWiBeWGY4GvLiSy9RypLHv/hFXOM7kxkbAYSgM9Nl\nZ2ufdqvFjRtrfPhDH8FV8MHv+RBxvcZnP/dZnnn2WdLxhGGvxxdefp73PvpdXLx4kdfOvU632yVJ\nM86dv0AY+LiOw/z8LFeuP8fRB84gxnvMz85Q1D0aUczJmRPcvHKN5e4cWzdvIYY5tTRnN+0xuzhH\ne6ZNkeXML8xxa+MmK8uHmIwn5sGrlbqLiwt85Ymv4jguy8vLRIEWjAiJnqCQJprMIfA8lHGjlEWJ\ng6jOt8a2R5Veod8f0Om0ie+6i6LMuevUCZ568gk6zSZHjxzR+5xS0mm32d7dJa4f8Jf1tewg5cHe\nxvM8EwqiO02llAnfOKASvtXxxq9ZLvZbHdOQwtt1otOduaXlVveSUU1OT8j63tb4+MFbsQ9Bk2fp\naGKCUiW+H97Gn7f3vxA6Um160rD4uRXv2TpgbTTs71BRFE3N0fm6siroWZZV/32r41tBKDnwd5RS\nzwkhGsAzQoj/D13MP62U+vQbPsx7gI8D9wCHgM8LIe5Ub3GGarUGwnPpDYd05+Z48qmvcfbsWRSK\ntVtrKKlo1RvVeJHnOcl4TFkU+H5Q4U+9fl8vNUcj0mREHEcEYcjdd57ixz7xcVqtlpbKliW1MEIV\nOb4jGA6HOI4WwdhFwjSNx8IkruviRjq1fBq+UEqRl0WVoDFtVGUFEdMnzXb4Qogq83GaA24vViml\nLkBvcdj3Nt2x2++b9osQjjZpUoU0/HNtdKUcgR94XL16FVdoxWEYRWR5SpZnHF09xLC3jxA6w1BK\nhTL4YqvV4uzZs4hSu61dv3mdJ576Ol/6ytdozyxxz5nTdOcWCII6e70xi4vHGGZ9ao0OgyQlipsM\nkpzA83A8H4SL8hSF0ruDbChxXB/PjcjzgsX5BbY3b5COR1Dm7G3t87u//f+yt7PLsTuOMBqNiOOY\nerPBoUOHWF5Z4Ttclz/5d58hScYoRy+wGs0mk0nKa5dfY21tjXd9x3cSeD5CwXsefoRLly4zmUyY\nabRwjxzhheef576zZ8mygt29PVxXj8ajwQhZlvR6fU7ffTfD3T5ZlvP6Cy8ji5KluQVuXr9Ou9Hg\njhMncB2hI9OU4MjJ47ieDr/tJ0PyrKDMNX20UW/iOm7V0a1vbXLHHSe4ce0GtVqN1ZVVilLSbneZ\npBPjER1QlCXpeIJAJyMJoaetwrChHEdQCyNcNI7aWFpkd2+PWq1Gkgz1fiGMuOvOOxFSGQVjxLA3\noNNsk5g80+mRPo4j6vVaBR2kqY5ia7U7hpaoF/iWJ31QJFX1n5QHux6lVMUHn45TqI6pe8MW4Tce\nB3DNgVBumopncyWn7xvfD6de4mAa1iJAOx1ouwJbfKc99ZvNZrUHs122fR/Tk8Ub8expDcc0lFqv\n16vvsQ+Haej1nY53LOBKqXVg3fx5KIR4FV2Y3+YT54eA31ZK5cAVIcQF4N3AU2/6l44gzTLtQhYE\nXLlyhTP33ac9HoSDchSJUUbap5jneRRlya31dS5dukRZlszNzbG6uso999zD6vIcYWi8iF0PpSS7\nuzsEgY/jaMBLSlVl/tmCbOk6tjDbDtl2G0h9ku2Ha3HvMitvK6q2IE+PTXYJYQv3dNGdxuYqXP0d\nyPt2VJse2+zJtj8nTVNKWSIcoQsD2u1NyhLh+VWknBdG2pkty3TobDLBDwLe+973Vuo6S+8rpaRU\n2n88zXPiRoMbtzb46lPPsLB8lMNHT1FvzeD6TdJCEdU7bO/1CJuefs0so8RDKfDDBkWWUyIosxzP\nc0C5eF6ALFPiuIYsBxT5BKEK/u7//D9QpindVgcXLfqJ2lFl4FXIkv39PuubG1y+epUkGZMXJaMk\nodvt4rgBSuR0OjP8xm/8Jo++532UecYLL7zAAw88wI/91U/w6muv8fQ3nsZFMNNu8cKzz3LPPffy\nWpox3NvTC2ypF17rN27x/d/7UYrhhM8/9QXe/fDD/Jvf+S3e/ZN/k1FvwIuvvsTnn/gyJ+44wZHj\nR0mzlOjiy6gsx3McZmZnKTJdFC5dvMwHPvABGvWY8XjCaJAAwpQ6Ra+/z8L8vOnoMqA0PjtauRqF\nmsY6Ho+rCbEsclqtFkVZWoiXLNOe641Ggyyb4LsOIgyYMSZWsiyJw4h0kuK7HulkghuYhd7Ugi1N\nU2o1LYaq13Vajy3AnucY9gkcFGzMfWcLubityCHk21AED4ydpov9Wx22QOpCp6eEigGG9sVRhuoL\ntqu3ego51f0r815tso/E88A34RW2+57WYli4yMJftqOe3mlN1xdbKyxN0Hbi0/DqdN15p8nDHv/R\nS0whxDHgQXQxfhT420KITwLfAH5KKbUPrHB7sb7BQcG/7UiSBDfwCQIfTzjs7uygSkmZ5xQypdFo\nkmc56STFZvcNBtrzeWZmhr/8Qz/A7OwsMzMzB1hfrkUKjqPpZ57v0mxov400K26DMRBuZbFqL34r\nR69y6UxhlYV++lubUWvLOl10LddzWlJsT4ot/PakTOP4tlufHj3f7mK1i5Lpp7odtWznAOB4LoEf\noEqFzAtjD+qB45CO9MTh+T7JZILveQyTIc1mg/3dXc69/jqB57O0uEAUhZX/g5LaHEx5PrkU/MEf\nfYaTd54hbnSJGl0KfMgVSng4UtCamSMvhxSFJIzqFKWk0WgbLru+8OJGg3wyQSFRqkAp3ZmOkx5X\nLp3jv/nxv0bkCXpZyu72FoPekLKQuDWfWq1OFNfodrvMzs6xuLzCI+99lJdfepW4UWdzc4ter0dc\nq+ulXC1mf2ePT/2Df8DxoyeII5+5uTl++7d/m0996lOURcHnPv9ZZFky2+5w4+oV3vfIwzz77LP0\nen3N9HFdDq+ssLF2iy9+7Sn29vaQLz7L9/3lH+T3/ugP+fFPfpJbN68z7g342z/+k9x35gwoxebO\nJlIpWo0mnU6XZKhDb1949lm+9tQ3OHHsBPPzC2xt7rE72OHW5hqqlNRi7TlvvTg810M46AR2xyXL\nJjhK+3orqUCV2mM8T3E9jyzN8DzNXhkNh9qmWenotX5vn7vuvIsiz4nr2lytFtc0pOM6SKPOLKHq\nDq05V+hrNWmj0QDzgBZCm0WhNCuLKfzcFtOqo0fhCN01K/M/fX8cLOmllFXz9k7LvIMdVGDuuQOh\nnDfVEHmeQ57rZaKwcLJwDSPG3juKNNXmdFaVaRWxRaFoNDoVGqCVncWUwhrStLjNgXT6Pp7u4Kfh\nFXtYCMUWc2t+Zwkbb3f8RxVwA5/8HvA/mU7814CfNV/+OeAXgb/5Nt/+ltWo1WoxyTOKPOOf/cqv\nko7HvPD8czQaOqk5iiIWFhZZWVk28lVdGBuNpr5wjBQ5y3RBUEoiixQc8IW+0BHadc9xXVx0BysN\nXiwcXQhtGn1R6IAFGwxsi2SWZdTjWtWB2MI9XTCnL1S9TDUBAeYBYDsJmw9ov9c+AOyT+Lbu5C2O\nadXlG8fCaQimkCWTNNWYqKNv4AL9ILHdQmm41qV5+ES1OrKUfPKTn2R7c4syz0jHE/JSsr27w9z8\nArV6A9eL+dmf+4d4QYNme46w0UG4IY4b4Xia8yyVInBdCimo1xqaSaAzJLAuidKEK2NUajJPiGOf\nZDhke3udn/iJH8d3JJ4rWFxawBMe4yQl8AKk6+huMQxwXY8SRZoWIFI63VnysmRuboFr126ws7uP\nlJJWo8kwSbh2/QYf/f4f5Nb1a/zCL/wjbt68wc///M/zXd/1XexubXHi+HGuXr3G/Nws1y5f5H2P\nPMzlK5e5eOEScRCihMRFct8DZ/nSl7/M1evXaDR0dN7+zg73nz7D9fOX+cVP/UPO3ncfn/j4j9Jc\nmCMvS2QJG+ubOMIhCkIefvi93Hv6LPV6natXr7L84ApZOeZf/9a/5sjqKs1mk52dbWZnZ1CqrOCc\nstTOeXEQ6jzFoqyMkuz1l0307iU3/75ei3E9h8LVCt1Go04UBiSjIb7rE3i+DgH2fIIwoJxaKk6z\nK9JM2wBs72zhuMLoGmJGoyFK+UyHA1tzqIqBInQhtfTf2/FjwRv3dNPLw7draqZhk4N/Y6TwxUHH\ne3CfanGR49j7QcOZjotJEvLMJCGqYm3j4qTUlh6TiaYV287cwhxZdsA6szsq+/7s7ymEqCiI04tN\noGKtTf/OrVbrLX/v6jN6x6/qH+4Dvw/8plLqjwCUUptTX/914DPm/94EDk99+6r5uzcd//hX/i/9\nAQQBDz10lr/xNz5pGBVela0HoAyjxHW9qjPGpGOEvl+NaLoQHkAJpVSMh0NGo4Q4jqoP03VdSgQ2\nC9CehHq9jnWis8wOS1NMhqM30X/KskS4TrVEtEZY7XbbjKoZg8GgwtWtP7cdiyxulmVZFYxrVaG2\n03/jUa/XK6c8+8S2T3x7EYVhiO8E5Ko0RmEgXJfAdemNhuyb5bDFXO1+IK7V8FxR4Xq+oxPrvcDh\nyJEjZHnBq6++xvOvXmY0Ljh2x2laMwtIEeCGdXq9Ac0wZjDYZ25uhltrN7nj1FF2d/aIwogyLwk8\n46EsS1zhocoUzxV4voMfeGxu3GR3+xYf+5EfYLYzS7+3TZaVuKFevkrhgOfrghVq//jxOMUxdp5C\nuHS7szz+xS+Za9PT7JfAw/dDmq0WFy9f4p//2q9y37330uy0edehFV5++WW9hItjFIq8mHDs2GGu\nXLnMyy9+k/sfeIBWs8alS1fY3tnh0qVzHDl0nNOLh3jl1Ve5/NLLfOz7/iv++A//gO/+7u/m7gfu\n49z5c3zx2a/zxEvf5H/7qf+Fe+8+rQvsKMH1fXzXIxklRJHOTDx8+LBmcTRmWbu5xsrSMufOnePo\n4SMkSULDuF0KoV0cFYJSltTqUbUIK6UevZPBkHq9jos7BUNo9XPoB+SFvr4DP2DiuvTMZOt5upAz\nTlDIapq095QfeNSiBqPRiPn5efb391lcXOLy5UscO3asSnsqy6IqhBa6sF2q7Y5tAdNNiUBKUT0k\nbDMjDH49vZh8i/p0m6r54LW0pF4IpyqmtpA6wr1t8nY9XUCtuVgchwcmdOKAzWOnbB0YMr6No20b\nKNs5Txfi6UJu64olPdgmzr7GuXPnWFvf4vVzl257z293vCONUOhHw78CdpRSf2fq75eVUrfMn/8O\n8C6l1F8zS8zfQuPeh4DPA3eoN7yIEEJ9+Qu/r4uZ0PhQEIaVFFnvHjSGK4vSFJoJnuualO0D8rvr\n6gsmyzL8wLqF6cQUu1S0F4stoHYs6/f71RPWPm0tp9YWc4AyL27DwCzMkuZZ5Sxmcfo0TYmiqCrC\ndhRMkqRSYE5j19N4mH1fSZLw0CMfetP5eOkbj7/pwpheeNivTdIUPG3VSymRSqEcl0JJzl++xJ9+\n7nPUoxiZa+HBeDJhaWGBTrPBT/7E32AySlBlQV6UKKETunVYbMgv//PfYn17l/vu/w5y6eFHDbJC\n4UcxaTqhFukgh26nw3DQBwQOOlA2NCpLz3WQMiVNE8LQAyTnX/4m29ub5NmEh+4/gyq1m1uZF0bN\n51Sq0dRwkQUCx9OZiyBwXI9XXn+NXk8vGDc2Nwkjn15vn9XVVfr7PQ6vrnDhwgV8z6Xb7rCytMg9\n95xGScWXv/oFGs0Gvb1d5udn+NpTT3Ly5ElmZma4445TuJ7HtRs3WVu7Rbc+T6etE9GVgCPHj+F6\nHs+/+BI7+7tcuXIVHF1k3Szn/e97H5/4xCdoNVv4fqB1BcZ7W9vBGngv9vnDP/pDdne2qMUx9Tjm\nwQceqAquDgMTlKVegI3HyW07G0u1tbS+MAwNbCHIsxLHs1Q6bdym909XGY1G3LhxE8/z+eD3fA+o\nqUWgOaztLujvG48TBoMhMyZ+sG6StCzUZ7vIN2K5b8S17fLQ1IbqPlDqILVKSsl7PvBmN8InH//D\n2xhk0z8fISgKWTVM9vORhSQv8koxDfDGHZSU+vdRiIqabAu4rT22ttjmDg6i9OxnYN/bNDxiodxp\nGLWCfcx0D/qBEgQB3/Gej6D+E90IHwX+OvCCEOJZ83c/DXxCCPEAGh65DPwt88G9IoT4t8ArQAH8\n928s3vYoioLJeMysMevvuB3GlhdbnVRFHEX0eiNqtRp5kTJKBrd5bKfpuOJbD5LxQXdsPgxrbCWl\npFB2zBI0a9qpDW7naNoFgu1o4zjGb3jV8s+OOfV6nbrTqLqfoihoNnVmpn1wwIG3SRiGt7kJTnN2\nLY49zQF9q8Ni9NN0pMFggO/79Pt9Hcbb6RDXa2SldkXDGP0jjMy++kxy0mQMCDAKs+FwyK//+q9z\naGmZWhTiuh7t7gxxo0a706WQgqe+/gw/9MN/BeX6CNcnKySduQWuXLnM4uIC6SShVou4uXaNdq1F\nvV4nScb4YUSSjAh9D+FphVscB2zcuskz33yayM3Y2thEFgWP7+6wub5WTWJRFCEc7deNIzi8MFdx\n4LOipNfvGyWfIIhjhoMRfmgnkxyUfhgPR0NeP3eeoshJRhn9fp8XX3qB3/2D36NZqxO1PD7wgfcj\naZLlGY88+h6uXblCo7XKN59/hlN33smRE4eptWJGvYJrGzeYmZtleXmZQaKThJ57/nnSSUpsTLEa\n9Qb1huDprz3JM09/jb/3v/49zp69n729Ps1m05xLSZqNDBSRcOLECV5+6UVWD60QeDr2ryxLBgO9\nA6g1GhpOCj2iKDCT3ATP80iSIaAzJ5XSqUKOA/39Pu1WF6kKev0eMzNder19tra2COOIJ7/2FL4X\n8gM/8ANIpfCc2x0zc9OsWBgxSbRKtyxLtre3OXr0KMPhkDiOK8Os6cOWAbt8PpCMH3S39to+gC/z\nCmJ8p0ZTSllNovbBoRfwmgtu7zH7OtrAyzXkhmljK6oIxG63q4uqc+Brbt+/hT9tivzOzg6zs7MU\nhWRvbw/HcTh0SIsEh8MhvV5PK3KnsPzpBuyNUKqFcqYXnG93fCsWylfQhq9vPD73Dt/z88DPv+Or\noo1mGo0Ge3t7LC8vV0k4drtb/ZKlHu2KXBdZm+YiS8lEpQR+gOf6lIXEd13CKKy6Zx2bZOxe0bxQ\n0E/1wUAnh3uuXmQIBI57wLG273EygUGmL7owDEBBmurEa6n0T3Q9D4FVxh08DPQT1kUZc3h7Mxxc\nNJpNEJplbpEf2L6+1TGZTPRC0nUrd7O4ViMzE0yr3QGTsei4AoGDH/ogHB0ZlU707ykchPBwg8gk\nwEy0zD3w+e/+279Ff7+HK9AULNdlmIyROPzOv/1djt9xitFkQrPdwvNrjJKc0SChWW+RpxmNuEaa\nJBxaWKEo7YNDf07NRg1XKFSZsb+3zcb6Da5cvUSRj7l2a137SruC7Z1dZucWtI1rXNMRY0oiHUEy\nHnPhwjn9kC9LHNfXUm7PpygLiiwlrgUIx2U8mTAa9YijmMuXLmp/dM9jPB5Ti0Ncz2NxaZFH3vuI\n6VJzhBQoKWi229y4fp16q4Pnx6wcOsyVazdo94c4jstwmHLXnXfx9ad16Mi7H3mEX/6lX+ZDH/kI\nl65cxnEE3W6Her1BKCSz3Q5CCP7pr/xTHn3f+/jwhz6kXRjTlDAI8F2HIpsghMvZ+x7gT/7oMySj\nCfVancFoRJnnNBrNisPseQ6+55LlKa7jGhhC0mg09XJ+klKv1RlPxowMHzyZjNBJRk329/ep1WJc\nx+WFF1/EEYLveewDOA6MJwlCGdWiUgSenj6dUtGM6yRj/WAajkYUZUle5Fy+cpnFxUWScUKtVq+Y\nNMpOywYJ8D0ff5pdwsHSUk1J8B3HJUJDYFpt+dZQgpICFExKy5lWVUesSr0bys3963oeSoIIfEqp\nvVtc10VISEZjFNBptWg2W5r15nvVbmwayrAPID2FjInj2ODiLQ4dWiHLMnq9fUBDmtrf3SPPtSNi\nalTdusezv/+By6ENg55mtL3d8e1zIzQfSKvVYjAYVMXbjoK2Iy3yA1qdbyxbLTcVgNqBGUxWpKTj\ngy7c8iwdY1bjOiaqykSGtVqtAxzOdRkNB9US074eSuL7rlkiORXEEoYhw+HQKNd00ofneaR2Iz+N\nHfoejuNVEI0dv8LAx5rJu46DMt1Inr81gd8L/Or3PpA4mzQjqarXDoMQpTSeXsoCKcwC0fOoxbF2\nWlMAHmlmgo6LEuW79AdDyjJHCcFoPCGMYiQCJRzWNjZodpaJ6g2U8EiGGVGtyXicMNOZYdjfQ0hF\n5AYEIqA3HtJo1Gk06gSuIB0PCH2Xv/jS46BytrbX2e/tMxj0qDVi/cDNcrI85db6munSYzZ3Nml1\nWmz3dkjGE2pFTiklcS0mGaf69zfL6tm5OZqNlrlGpO44e7t0Wi2GvZ6WQuc5wyylUAXxpAGuw9Ly\nMq0wIA5rvP7qOZa/8xB5BsdPniLNclw3ZHFRe8I7jqTZbvPquXOEcYwSgsuXL3P4yGG2NzbwhKBW\nrxOGOvHeRQdGBEFAs9Xi8ccf57lnn+Wxxx7jox/9qHY8RNDr9QjiiI2NLaIoptlsM5mkZHmu7RCU\nTrP3XK0W3N3dZTDsE8cxS0vLKKVIkjFRFBOGddY31mk2m0zSnDAsqNXC26bTNM0Ig4D/n7k3D7Lk\nus47f/fmnm+vtauqG9UFNBaCAAEuEMBVFEVJJLWZ9EgjKyxZ4/GMwxEKj0OjmbAdY88S9jjkcNgh\nOzx/zESMRdlhSbQ9Q1kOitplihYpkiKABtBAN9B7Vy+1vjX3zDt/3Lz5XkENaP5xQBnR0Y3Cq/fy\nZeY995zvfN93JPDjP/ZjDURgSYG0LCbDIVVWEHQcopGedpUXBa1OmzTJcF2fTrdPv5+TZhmHtQnY\nbBZR1kmKHvJro2RtrZzlJ7DuSunpPErpwQ56uINEVBUik+RCe6RU3B8Dt9D2DKmKsaQFggYONevK\n8k8OUikqM0lLx5Fr166xtLTCzgPbui+GoKwUs/EUyxJN72y+nudMs0VCw+3bu7iuW2fQVu38Oaph\noDlFWQhjRFfV1f6cMKEFUh5KGU7428fRd3Qq/SLAb7JTs9uZIBn49glOpaHtGHjEZNt6oEPeQBSL\nwR4WPYp1dtztdpvhtQaLNmWSwd2MNNZ4dpsybBEeMd/DYHemObEo4NEioezE9zXnXRR5E/ANx9xU\nIG8+bFv7kRTFHKIxjVXVkFCaAAAgAElEQVRtaFVn+VWJquaj2xCCQimkZeO5LkkUa0ZJPZ0ny7X9\nrq4EXCopuHXrFqur2vY1KxRnzu5wdHTM6dUH64BfYNkO0+mwpqUd0m752JbmMZdVSi8U2DKliCfc\nO9jjYP8eVy9fRFUFw+Gh9qSgYGm5h++52FLQCVs88fijfOB978VzHfK8YDgaEXbb9Pp9XN/HTnP8\nMCAIAuIkoawgbIWkWca/+IXP15n3DNt18RybsigYHh3zX/7Mz/Dxj36MJElod9vMoql20lOKX//N\n3+A//vavM6iWOLWxQZpl7Jx7SFNQk1SPPev3UEpSVoqb93Y5ODgg8H1+8Ad/kC996Ut893d/N7/9\nW7/VQA0a4tOVDYJG+XvmzBkO9vf58pe/zK/+6q/i+z5//nOf42Mf/RhpUdBptzm1vsrdu7cJQl/T\nTqVhLQhms5gsySiKin5/pYYtCixpY1se02mM61UEQQulBMvLq5oOlyXaiCuaIdAw5vHxMUjJdDrD\ncXQCYqpE1/exA0lWVQQ9ndl3vS5ZnpImMR7au8OxLYosoywKXr90iZWVFc0+QlAVJRWiWT+e7ehq\nWM4nAZWl7rWYONAIXgBbAKKq/dT/5KGqnLyq8ELt7a8n0WtDLSHmtD3jR2LbNgh1Qkz3zDPPatV0\nnOiquB7aoFXbcbMZLGbERtNhEiqlFGtrayeYXoseNYsxwuDoi3i3lLLpmxmYxkC2b3e8ozMxFxsW\ni14kJnjatk2apPXOLKiULi8ar2FVUJWAELieg1N/nUX+qHkY4KSwJk6Spnm4WB4tZvuLP1/0NVjE\nzAyebTYMk2Gbz59j2lnTXGo67VVZ06dU0xU31+V+h5kwr/9YTTfb7NhJEmNZdj1IQNO5VP29C6Xw\n/IBup6MnkQ+WGA4n9cMkyIqCVqvF5z//eT78oQ+xvrZKFMcsLS+jhIVtWQx6Xaoyx5IVWTqjVDb9\nTp+wbTMTEktktMNQc7Ul7N+9zbe++S0cWxBNJwyHxxR5SpLEOJ4NZYXlOkBOkWTM4pi/+GN/jccf\neZTR8RGua3P2gU2msxnD8YgyizgYHbG5tE4SJyilSOpRcffu3qM36DMejxFS4noeWZ7hubrJHQYB\nrVaLmzdv4roOo9ExXhiQZClBq8UXv/hFHFkyS2JObW0ym0VY0qIoKy5fvYaUFnGUsrS0RKfTYXnF\nxvO1h/i1Gzd4+umn2d3dpawD1dLyEnatsLRFRZrGxHFSz+B0OLW5jio10CCEJIpnlKqgKCqOjoeN\ndbHJmHXS4jCdznBdD0VOVUlsy8d1QoqyIM10E73b7WrVZt3Qj2YxQeAS18O/QTKNJhwfHRHFMbMo\nIs0ywlYLWRYN93g6nSKkZG1dw1mO4+BYkCQ6g53NZmRZiuc6dV8o4N69/Wa6k14TFkWZ17BnCY5T\n27cWqGqexOmFZdVBtw7WtVFVVWpq7H0PUWJbgslk1FwnDSfNVZ/aKCpsAuetu7u6VxQEhGGLu3fv\nal+bGnMvirmAsN0Om3iQZVkz/NywxkxgN2vR6EkM7XiR0WYoh4u9tkW9iTl/4wW+SEF8q+Ods5Ot\nOdfmpE1z0Jy8eY2UEt/R7A3zxbXS0mrMrESt/jKy+BOUofq9Fo3SdfCsiNKU8Xi8sNvqh3+R92oe\nRHOO5r2MCZbv+w2FME21gALmTRvzIHQ6PaIoOtGNl5ZFVRZNQ3Zxcs79DgMv6YdSnuCWG0qiUtrD\n2XPnRjlCCBxpMZ3N6PWXkBJmsylCaBqnJdpkqW6CJXHGmQceIE3ihsZVVVrR+sjDD3MwzbFVTjf0\nUDigIu7cvMmZrXWm0xF3bu1y5Y3LxLOItl/x/icf5Ad/8AeI44S//bf/FlWR0e14pHlK0Ao1YwaH\nlaU+/9VP/Q06rYA0ntJuB8ymE65evcL29jatdqhN+JXi2htX2dw8TZIkdHs9XN+j3W7zyqsXaIUh\nB0dHtFot+v0+8WyGYzvs3bnHgzs7dSarF0+aJEhLsnfvHs8+8wwvXXiBvKo4Go1oBSFHh0eEYYtz\n5x5BIOl1us1zW6ANzJ544gl2d3cJfZ9vf/vbbGxsMBwOmU6nDV+45Wm5dK/XO1HFObaD57kkScq/\n+bf/hldeeYW/+bf+Drbj8P3f/2n+zt/9n3j00UdPJBm27RDNYhzHY3m5g+v5JEnCbDbBdR16vR7T\n2aRpDuZZhu3YHI+GzOIpr7z2qq4884xer8t0qt0+kYLdO7dphSF+EJDEMZZtM00ipknMNNI+2EES\nEXgeSZbWrBOtHQ1bLQ4PDtg6vcnw+Jjd27sM+gMGgwFFoTehdrdNluvBDZVSVOh5uJZtaVFNTTOc\nj1HTQ1pKpRD3bcVBmk41Th/o4Q9VpSjKgrIo8f2grqbnjU2lFE888Z56YHmL2WzGztkdhkdHBJ5+\nD2M9YUgSs9msWfudTqdBAkyQXazEFxuS5p7N7519ImE1vHJdQevfMTHFUJj/tOOdG+hQ86JNZ9h8\nSQ0rzK1X9RDiqglyZtczXxjmEnLDyTbDihdtH01Wa3Y+t35tv98H5tl5XA9uMMFbd/ajE+pK85lm\nN12kAMmFDHquApv7JpjfMc2KxfMyPPC3E/IsQkL6vd3mehguu1KVVrst0KukgF6ng0Dw5JNPcvHi\nGxRVRWAF5Kl+7WQWQZmjFIStNkmSEEURx8MxrVab73jm/Xz+l36F0dE+k0lCGHQYTSf4vkM87LM0\n6DIdj/nuj72fF55/gb/4o5+l3W5T5AXD6TF/+Sd/nMtXrlKpCr/dYhZFKODSG6+j0pRf/MVfJE1m\nPPXkE5RFgRSCl156iXc9/riexBOE9Pp9fNtlb3+fRx55lL39fR7YfoDeoMOlS5c4PDzQ+GU0Iyty\nZFVot8vQIwx9jTPbDrbj4NkWt27f5jd/+7f0rMxWm6OjIwDcUx7rpzaoCsWP/MiPcvmNy5RFyfHx\nkNFoxMHwkJ2dHdbW1njxxRe5d/cujz/+OG+88YaeRN7paKvQ2azuSSieeuopiqLg5s2bHB0dIS1J\nWgfYc+cepr804Oj4iCAMEULysz/7s/zar/1aXW0qxuMJruPT6XQ5OjqmVBGBH+I4Nq7n1vDICMuS\nHB3tMx5PyLOMzc1Nut02y6tLbG9vNwFoPBrx0vkXtKz/yhWKomBvb49+v49jWQStkFmWcu/4ENtx\n6Ha75KokiiPafsDh/gG2bRGnOsB7nscsjsCSlEXO3uEBSZbWTX7wIo+8yll0DpTCqiGPWshTVw3a\n4nVKnlfo5fBWknJtYZsUZkSZjW0LqP2SQNQDObR7pef5RFnSeB+hVG31224ERnriUEpZFBRl3sQr\nmHsamQD9ZvMuI6RaFOyYGLHoK2NgqkVItaqqRrjzZojmrY53LICbzM40BEzmbb6cgSIW/QYMRNF0\nresgZgK0FLoRUhYZWBaibl46tsSS4AaaT55lmZ5gvpAtm+C4yBXPsoxpPfsQaD7L+HWbjcO27YY+\nuLi5mBsmhYAKvchqPxIppJ4jWcM4BrJZxMXefJRFgaqq2gPdbjrsGufWlDnT2S+KrMbzNJVKY38W\nwi546sknefmVVymqumqBpqP+4M4Ol69e48GdHW7dusWZM2dYXlnD8zyiaMbP/9zfA+mQZxXTWYzj\nOtg2XHr9VSxLcXR4hFDwP/z1v0qRp5SF0iPpiownHnsXvuvywY98lDhNsByX/+V/+19BQdBqc+/O\nbcIgYDJLePjhc5xaX+UzP/ADDEdTLr3+OteuXeP6jdtce+MSlm0zGAy4c28PBayvn+LoeEi702kM\njGazGWUS4bouS0tLXL58ueHjX7p0ia9//evkZYFjyt76uRsNx9y6eYvtM2fxPI+vfe3rfPr7PgUI\nNjc3efXVV/mVf/dLHB0d8a//1b9iZWWFH/6hH6Lb7dLr9Th//jz9bo9WENJtdxCVvm/nHnqExx57\nDNCb+6VLl7h9+zY3btxAofjAB56h0+5QFHqQ8drKKu2wxWQ0ZrC8hG8FHB0NkdKi1W7j+QGO62po\nqsooopgonnLr1k1GIy2yefjhh7Bth42tLWzXa9aSbdtw+jTvefLdXLhwgaIoaLfbnDlzBktaRHHE\n/sEB337pRa5eucZ3ffcn+N3f/V2iWcQH3vc+jipFr93BKiXCscC2eOXia+R5zvXr17l5c5eqqnjs\nscd45pln6PV6lHlKSYXr2jXH2SNOU22XW1TYtoOqlP55nNCyjYWFT57dH0IZT8YURUZneUXj61LW\nlaPE9XT/wLF1LEmznLyoELYO7KISUOnBzQYW1dbHZv6s9k3xPKeJERrfzppYpaFeQ7fMm7igBVd+\nEwcWVdiGn78YwE2/zWDlrVargUHf7njnhhrXwc7g3UATLBclweZLNQZSJzik851c74pzsY55jeFO\nm6Ds+35tAznPkk+wTqjpemruj7JoHGXmD5pAned585kGYzO4l3Fl0zetarJr872FAD/wTtzYt6MO\nhaEe6GyoTbZtY9k17icWHNMkCDEXB5VFgULiuB6VEpw7d46yLPD9kEpVOFJSoQVAcZJw+cpVULC+\nvk6lYDw6JooTup0246OU0TSiFXS5ffsuQegTxRPObJ3ixs2r9NoeVaGoioQ8Nz7qlmZvCJvNjU0m\noxHCsvA8n5WlJQ6PjomjiMHyKmVZcGv3Djdu3kRKSa/bxbZsXM8ny/WGeObMGVxP+3fs7JylKPVG\nGIQthqMhvX6PPC/I8pxuR9uiHty7xz/7Z/+0bpSnBEHAyko9GCJJWBoMWOksI4VkujRDVRWbm5tI\nIXj94kX27t6rvXMS0jhBuorReMQHn3uOra3TPP30UyRJwhOPvxv1F36c/b09bt64ieM4TCcjijxn\neXmlhrpyQLG+for1U6d49rnnNKSTpcyiCN/zoWZd7OzszLFXJN1uBylthJCkWUqaZ+R5ysHhPa5d\nv8J0PMKtjaje854nOLW+TpFXJGnK3sERrVao2SrTGd26UnjgzDZplpAkCXdu39G0N8eh0+3S6/bo\n9/Rm9Nijj3H5jTdY6g+YjseErRZlWeAELmcffJDB8jIo+KEf/iy+77O3t8eVK1dYWl4hiiI8IcGx\nyMuCrCgaQVKexdj2XPhSFDlXr15heniDslSkWVFn4T/xJ9ZE0GojUDhOAAhc10NK/WxpLFppnxjA\nrTcwpZT2PLc4CXeoOo4s+Kn4vncCIQBjr2udsMlYdCNcJF2YZqaprs1h3FCBhmdeFMWJXhjwp1rK\nvqMB3GTUJsCa8sHgS0YlabLvxQzZBDzHcQjDsFkYBuc2jYRGfg9N0NVlifnDiQtuyp8oihq57GJg\nXbSZNeoqg2GZKmKRzdIosFTeNE1N09PzXG1OtCCD1+q6+L7XTMNJWo242CtI05Q8S5rrqA3/cz1O\nzdK0JNf1GE0mhK0ux0dHvPfpp7lw8RJlXtJqaxx/Gs3Y299ne3ub0w9ss7LU1w9a3c1P04TpcEIQ\ntLn06gW2t89iezanT6/y8svn8T09sSdLc4qsoFQCUfvPjCZjHn3scZIkYXg8pNvvkcYxj5w7xze+\n8U181+X06S1++qd/mqOjA8qy5Mzp04xGI5RSTMYzBoMlwjDk6huvsryy0gzVQFh881vf4ktf+hLt\nth5957gOLRHScTR743/+O3+3KYM7nW7N5Z4yHo8bOfvB8QFKaf+JP/iDr9Lt9rAsqxlafPPmTYZH\nR3zgAx9gaaXP5/7859jb29P3OMtJZzGppWG4TqvNux9/vF74mkY4m83Y29tvfOyRetNPa1xcSkmR\nl2QUNT/aYXt7m+eff57eoE9VgRAwmYxwHD3k4er167x28QKj4SGrq0u0WiGinuDeabeJohhL2oR+\niBSOFuQ4Dp21NYQQ3L17l7t37/LgzjYPP3QOgN3bt5lEWnzy8ovnObW5gSpKZFlxZmOT2WRKnuXs\n17TBvMz54v/7q7zrXe9iZWWFy5evEEURh4eHnDun33MwGBCEIa7vEYYhvu/rBCjTvQApBFk6Z1Op\nouT88S0kMIpHCHn/UHX9xi5nz+5gWQ6e59UCJr1WpbBBVORVTlVpFpcOkmlT+ZuRadS8d6UUZT2o\npSgKVJI1AdWork0wXoREdBwpTwhyTKJmGtGLKs5ebz5hzNhj5HnO6upqk3SaOPl2xzsWwM0XWdxh\nDE/aKPC04GZUXxRjyk7DkzZZd1nqrvai5NVsEKZ5aWAXE9iNQsscZhc152ZKHtM4NUHeYF6m5Fls\nOC6qK81GY7BvSzqNNN8E/TTTtKXFLMDg//c75hz1k1NNpJQEoY0Ulm7kqFIzR6RuDBkVnxYhpQgp\n2Njc4OULrzbmXnme44ct9vf36Xa73Lx5kyJPNXbp2o1IKY4TWt1lHth5kFanw/7ePe7cvY1CsL6x\nxWg0xbV90kKRKg0dZElSQxsVb1x+nSefeJIKiOMp3/mxj1AUKTtndsiLjDSeooocW8KF8y/oJqXj\n4whIZ1Omx8csLQ3Y3d1lMBhobnu7zcsvv6w3YVuLftyaNaBUxWOPPdroDaqqYn//oPHCcV2X0Ug/\nY9tbZ5jNIqS0+PT3fqpZPB/8jmeB2nSobg6KquT44BBHWviuR5okDAYDsjTFtvRgW9Be3QiB5Tr0\neoPmHguhudaaq+xosZMQSGWmoEdMp1OWlpbZ2dnhypUrSCnpdnoMhyOSLMOyXF44/xJVVdTvpUjT\nDNfSSUaRK2xbMotTiiJC1glFluaNaMx1HM5ub3N8NOTOnbtMJxP80Ec4DhcuXOD7vvd7eenF81x8\n6RXCICApSpb62v/76vVrxHHMw+fO8f6n3stTTz/N8HjI2pIe3bf5nVtaFdsES0GcxsxmEfE40n0O\nObdatYTEtiwEgqN7d/Esj5zavVDeH1ZcWdvAb3Xod3s4jl7bZVWCsmrhjKobk3N6ojGi0tVwSVkW\nevqP0ApwIy4C0LbUOgE01fSi8dwiEpCmyYm5AG8e7mLUwydgLGiqfMNcmU6nTbx5q/GK5njHAvji\nZHaY86WVUg0zRE++9poLYXBf82WFEI21q8lcDT5seJ6GT2lcB01AdhyvyWAXb4YJumYXNJxOsyMu\nNhVMpvzmhqrZJAz2NS8NdcA3eLmUog7i+vPDMGw2hvsd5obPJf1uAy3pTWbeyNEMlwpVKRzbxnMt\n8qIkL7Uqcnt7G9u29MCGBU+HrKg4PDzkK1/5Cn/lv/7LHOzvceXyTR56cId2q8Us6YK0qZTij59/\nkW63w3g85MEHdxhNIu7eO+TBnYfZPzjGbkvaYYt0mnF6+zRXr19h8/QphKW0n4mQJFHCxz/6Yaqs\nJGwFfO0r/5Hv/Ph3MpmMWRr0KIuK2fiYlaVV8qLAkXpI7kMPPcj16ze4fvMGr1y4oFkMaGtVCyjq\nTbssM87ubDMcHqGU8axQjZeIgbosKYmnMba0GI3GrKyuoMqKLM8oiqwe3zajpKLValNmGa0wbPjN\nrus2Qz88x22eG9uyUQjiKK2fEa02DNutOpBb2I5NXuZ6UElV90scXw9YmI148skn2d45y8HBAVEU\ncfbBHQZLyxwcjvjaN79NK/CospKyBIFFu9snmk6ZzWJaoYPvtXDbDpUqGQ6H9RqxaidISzNPXI/z\n58+ztDRg4/QmaVWwtbFBGsdsndrgtQuv0ttqsdTu4UiL4+kx3/rWH+N7HmfWNwjDkN/58m/zkY98\nRNPvegMO7uzheT5xnOMHPqPhCD8McLBpBQFJElNVJd1uC6HQ3iToWZnL3T4Hd66Tp0nNdLl/Jnru\nkXdRlWaClp70ZFkGelVNAC/LokmgbHvuu6KTPAuh5hoNFoJ9lhdNk9Fk4fPgX51IvBabkcZozmTf\nizxyy7IYDocnEjXze+YzTAKqnVff+ngHlZggLd1oKAs9gCDPMz0r0dY3odvVNznLcgTzAQi2radG\nO46HbbsIIYmTBNsWGkapKpRpJoo6K6sUZVVhVQolpKaQmWkdUnsZC7loZjPPlPRGoB0RtX+CnsJt\nWfIEu0TWXF2DgQe+T1HqhyqrN5QMRZrUHHIpqGrcXptvFSRJfKKrvXjEsbbyXNyIjEGPebAMDxah\nO/wG/6uKEtt2sGypB3bbNmtrq1y9dh3L8yjKEoRkMFhib/+Qdz/2GL/8y1/gQ89+Bw8/dI4knjFT\nCisMydOCw8OjuiGnWF9fIQx97u0dsLF5mqJUrKysUVpanjwejdh+YJsXbt7k9OnT3Lxxg63TW3pD\ns3TP4/qNXc48cIbtB85y9eo1BoMBYRDW3tJw4+YNWq02vV6P2XTGbJawurpGmhdceuMK+/uHepq4\n0HapjiVwLAeVFDz+2OOMJxMCP0AKiVdjo/pZskjihLzSJXSWZ3Q6beI4IopjlpcHWgkJ9Ps9ytpP\nx3JckjhBWpbGVoHJZEKn3akZU3rjdlxt8xCEWsBSVdqjI4qiBh6sqA2NKqjyAlvaVKpiPB4xWOpz\nfDzE9TxWV9Z0z8J10batulFvqkfbthseuuO4LA2WEFhY0qq59w4rK8tYls1oNCQvchzL5o3XL7O5\ntcXTT78Xz/cZTUZ0Om1Gx0M8z+eZ7/gOwiDgjTfeYGNzE9dzGQwGrCwvc2p9nW6nS5blPHzuHBdf\ne43V1RVUVdEOWyRJghCS2XTCYNAjTmp2h9BmdYHnIaRAGud5BWVVMJ2OycqKJC+Qlo207s/GmE1n\nWNKh3fJJEh2gTaVsyAcwHzJu27YWGJmkjdqnPNcNf9uxMeZaQugpRJohU9WMuTlsMld3GorvfAiD\nwdoNO84EZOp7bZK1xeTxrdh1b3e8YwFcKYlQtd1llWn8yXJxfYe80Ioq29KZSFmWGicsM3zfIysK\nbMuhShL9FURFlik8T2dnjmV8hDWZ33ZcpG1jS6GlsqKWm1cK3/dQ1NCCJbCYX9SihmJsy2qoT3le\nAHOoRADKkki0/7EWHJX1mBHN887KGuN2bZ351L+rhNCNxbosk1IsGNPf79C4/aKXsj6nfCF4Sy0p\nrh9Opy6nK9BqUBRIbebz6U99kn/yT35el4BCIiyHKM6Qls8rF17n/e99ipWVNXzXxhbg2Ba7e3fx\nfZ9Ox0NaJbd373BqfZ08K0iimH6nT1UUONKmyktu3bzJ5vo6rmUReD6hrwUgRT7vsEshaXX7+GGH\npRWr5sYqZkpzYts9HyfQnN3LN26wsbYKCopC8fwLL+GHPUbTXVqttr7fUuP1WZrwuR/+DL4f6ClD\nNWynext2rSjNcRyrqbz80Guez57bacyPijynXMA8BRIpbaSQZKkO8I7jUSkQsi6/pUVZ6rF0hjIq\nbTO9fe47bwmBsGzNWvDmsFjYDnV274V1sJC4jn5uhYJW4GNJAdTZo2VhO7oJWGQZeZEQuB6OJZCB\nQyUEN2/d0HzuIKDX7aMUPPLoY/XzZzMea6GQhSDwfa2yHY8Jum0++env4+rVq6RZRpokPHD6NPv7\n+xxPR7z3ve9FSkl/dcB0OuX67g3chcClIQMHx3YJwoCWbGmGSDBvLAoJWZLS6Xa5cv06le1RSpeC\nCnl/Mz5818OSNkkyt7Itirm//pv1IFmW4TpaSWwCsGVZ5EVer4P52irLkuls1oyPM702A4fo50RD\nmlosNHchzfO8Cd4m6zb8fxOszTkusu/MDF3gbRlp5njHArhXU4mmk6h5oLXTjML3XWxblyN5pnfS\nIPRqFWNOUWoxT1EWoHKktOvsO8Nx7Dor16ORyrKgyDKKrJ5OYju4rkeZFZSqIsmzpuHgOzZZPXFd\nKS20KVHkpcKSAsvS5Z2qNNc6CEPN8FAlpdKlcV5UKGEhpM7+XU9DRWXdgYqzulEjLapqziYxXsqG\nOnm/481SXCHmlrRm09GbisZXizwnLXLsUtvzDwYDZlFEJRRpkXNqdY1Hzp1j72jEaDTBcWoZvxIk\nec6li5egzPnMp76HPM2YzfIGr1taWmL31i4ry4MaA1QsLfWxHYl0bSxLUCSammZZFlevXmVtbY08\nzzl79qyWmNdQUhRFeuh0FuP5DvsH+zxw5gHu3buH53sNDNTtdFlbW+PSa5dYWVvj2s2bHA6HXHjt\nIv3+gDDUjodxnCKEAlXx3HPPcXh4eAIKM58LnODlL8Jmi4rYRe491BQzJbGsuahrkY1g7lXzt9D2\nBm9mKhgqWdMwq0vsRXc+s9AXfaON3YTj+vVz0274/2UJ0rNotVtaJt8bkJFxNBrR7nY5ffp0895Z\nlmNb85F/WaaHflu2ICs0N3oymfDaa6/xwQ9/mN/+zd8kjmN2dnaIooh3v/vdfOhDH+Jb3/oWN2/e\nJAgCVldXkVJy5vRp8jyn3W43lDrdi5k1VWNRFNy+fRuYszLSehDJdDbDbYVUlaoz6bcKZBoirdTJ\nRmEDh5j7xVxHYV5nAnGe57Rq75o0TRtLaE3Jnd9LQz4wz46eLqUaQkFVVYxGo4bssPhMmGdPkxe8\n5n6b8zONT5gz4/40Iyt4RzNw1SgvF5uEWZaeKEGClh6JluU5CAhaIarOfHXTQdUPfEVQPyRxNAVB\nHax1AyWKYoqiwoxB8rwWCEmaFkhLIi2HWZzWxjo64EpA+wlb2tBJCWRVT68WWuGlEAjpIJReQNQZ\ncFlVFDX0o5sqmrrk2B4KpaezVxoy8TyfoqhwHLMI33rXXVR9mRJrUXFpAk9ZldiOU1cF+iEZj8d6\n0ryooYPZjM/+8J/jn/9f/3c9hCJHYGlXOCGZJjGHwyG/95U/YPvMac6de5CSgtl0yt3bd8izrAmG\ne3t7rK+foiwLbM/TJlpVxdraGmEYMplMKIqimW5ixFFhqLPM2WRGnqUIFKdOrXJ4tM+pjTXu3LmD\n7/sMBkuMRiOSNGZtY5Ov/dHXuXdwwHA80cZRvkecxGjuO5R5zvd/5lPcvn27+UyDUZpNcxGznM1m\nzaIx52mOxSzOQFcalkgajw5jCBYEgbYxVWgLiLJEiXmvxbyPUfIuCsF0hpYv3EuJ47jN7+oJN4og\n0MHFb7Wb12tlcjlNTB0AACAASURBVEan06IsSlpByGuvvsZzzz4HlsWp9VPkC453hiJnyXlAchyb\nssyRlt1seq+//joPPfQQB3t7fOITn2B3d5ft7W3297Vkfnd3l83NTU05rSqGw2Gjas6znMlkwmQy\n4dFHH236P3P+9HwgyebmJnEcNxv717/xRyhVkecZtqMl9vc7bNtGOBZpujgIYt7LMkQG04C0bVvb\nLQjxJ9gexlTPvH5xTZn+3KzOyM01M8+W8WNa7EmZ62wqY/OsmSzb/L9F/rdhsP3/HWr89izx/4yH\nbbuUpWIWJWR5iZBSu6i5Ab4X4roBAos81zQx7WXgkKYZSZJSlCVV3ZCzpMR17KZccxwHS+pJ8kmc\nMBqO9Jg2zyPwA5YGS41as9XWkmvf92mFQZ0dVc0CtywLp7bTVDUHu8j17MYkSUnTjCzLa/jDo9Vq\nE4YhYRgQhCFe4OP5+o9SiizXczjzQo80s+25hwoIzV/O7m8nm2VZ07E35RbM6YqLWbnreeRlobG+\n2khJURL4PmmSoMoKVVSEns+TTz7J/t4+oP2Qi7Ik7LQR0ua11y+zfzzEC9ukRYXveWxsbCCEYG1t\njaT2lJlMJmRZClTMZhOKImc4HDY0vOXlZW0+FceMx+OmC2/mnJZV0TA4UBW3bt0gSeImMIwnY1zP\npdUKmaYZB6Mxt27faeyItWukJI6meK5FK/B55gPva5rXxijNHIYRsFjRtFotgiBoaH6G4mUyZSFE\nY62Q5RmWbdFqhQSBTxD4hK1AM2nShCxPqaoSy9ZeM8aczbCsTIZmPq/dbjdZYBD4hGFQL2LjjV82\njI3pdFJbAxtFs1b6qlqxmNbahMlsRrvTpVJQLGTyVVU1tLXj4aE+T8tqAvbR0RHvfve7efnll3nq\nqad45JFH8Gt/c0OL/eM//mMef/zxJhj+4R/+4QnSgGNr6GBzc5NnnnmGCxcucP78ea5du9Y8szoO\n2M05dbvaP/727dv4QYBlzTNo8+/7rYksmw8VNkGziQN1lm02i6qq6Pf7dDqdxm/GBHtDfKiqiiiK\nGI+15bTZ8MMwPEEV9n2/MQQ7Pj5uvot5D+ODZCiT5vzerLBcrMrSND0xk/fPLITy73/9N5BS0Ov2\n6PW6TfllOzaqbkRaUmKVkrzIyHO9C/teGyEUeZE1zUXQZYyqrSRtDFOjBCHwAx+BOLFghTRUq7Qx\nw3cch77X0dafC+VUVRohgFN3qevGYFmBKjVNSenxb/FsSl4UWLYO/GVZNBN9PM8BpfBczeJAgRM4\neop8vdN3u96JQLN4LJrWm3LbZAYm8wC9yZRVCWj8v2mo1NlXp6XLWulIcqX41Pd+Hy8+/yJVVVKU\nOY5jNxx4v9Xi9cvXiOKUJx5/F88+8ySXXn6FtbU1tHDC5c6dO5w+vYUeX6Yhlv39fVZWVpqHcTKZ\nNLYE3W6X3d3dZhNVStFutzjYP6i9JmyeeOKJxhq11W4znc4YjcZMplO++s3zZHnGZBo1CtKiKkjH\nEbYUHOzv8d/99E+TphF5Xja2rr7vN6pdUwov6hEMvrm4+A2MYc6zoQDW2dRi2WsCxWI/Qkqpx9qJ\nudf8HD+dT3s3C99x7Br+mw84MDTYJEkaqAdgPB7z8Y9/nP/0n75aY6ylHvgQtlBoBk5eaKWp1hwE\nJyo3g+tOpuNaQOdyamOdKJrx/PPP89xzz7G6utqwwkwj8OLFi3zsYx9jOp2yvr6uB1e021RV1Qx5\noNKsqv39fY6Pj3nPe97DwcEBCE0xPDjQ2a7nuhQ1tOF5HoOlJQ6OjomSBM/XIxPfDkrQvQyHoshO\niOFMlmzu9SJVt4Ggam8hkwkbDrlhhJlAvHjvFxuP5j4HtVGaec1ihWX+ezFgL2b5piowm1+jsF7g\nmb/d8Y4F8NcuXaYo6tFDqqjFEBnSstja2uIDH3g/W5tb2NLFcXxarZDxeMx4kiCkQkqBIx1s29LE\n+0oibIVlu9pMvlRYro0tZJMV2HVWUOQ5Ao0V54WR4etgnsRFc6NsW/s0zxdfRpFrtoKmn2k2TFVV\nmnONHs6QZDozqDC7aMFsEjcNDQN55IX2eTAPlmmEyLcQLZgM0GSIJovU5zYPHkWZIy2pB1KkEVLo\nQN/pdCiLQpf3lYIKfMchEYKf/e9/hr//v/8DQj8kLwvdLEPhBQFpnPDa65fp9Ppcu3aJj374I7Q7\nfS1Lt2yyXNucmgkqVVVx+/Zt+v1lZrN4AeYxWUZOv79EWer7mOcloe8xHk84u7NDFMe4jk9RzoiT\nTPtwDAYcHI34vd//Awi6XL12g96gi+c6TKba30QISOKYv/BjP8ry8oC4ts01C6KqqobWaXBZMyHG\nlNvGE8csRpMBmXJ78Xen0ynT6fREVg0nMyrzelXpxei5NkpppoN5beVYqKrE9+YzU6WYe2Y4JrjX\nG3aTSSP5nk9+D7//+79fBzFNnZtMpoRhC8fxODocsvPgtm4Av/5604PodDqNSM1kvpdqK9g4hulo\nwuapDYbHxwR+QDzTU6f27t6j1+vhWPU5WTZ37tzh6aef5vLlyzz00EP6OtXzZpeWlohjbQi1vLKM\nAu7s3qbdbhOGLcq8xLEVbs8jzXL+6I++yYWLr5FkORUFonbWfKu+0GJ/wGTbSqkmCTKZ/qI1q6qK\nBkozQdhsogbSNdl1nCSEYdiYmB0dHdHv95tM3FR2eZ5zfHxcV9/hiY3BfIYJ6ELoST3mnAeDQRMb\nDPXYqDL/NBz8HQvgD557GDNZfn9/XwdNR3sW3NrdZW9/nyzLWF/WirHNzU067U7DrZWWRAqwXRff\n1/L2vExQKNqtdj2MARzbxvc8nFrxWSmF5TgUedxg31VZEc1S8jxDmukmRUmZ183VunqzhIWw5+rN\nNNVNUyooVIklrSbj9DxPD0QVEjtsNzeyLAqqssS2bALfxvGCRtnleZoe9lbqK4O/LtrlLvLMzc8c\n6Tb0RB1E9AY2ynONxUtLb0IIirJAeD6eLfmeT36CL3zh39JbGjQPe1VpnK/V7vDyhVc5vbHCN54/\nzwfdgE6nzXA8w/VCwMLzXMbjCVmW81jNbOj3+1y/fl3PpByPSZKEfr9PVVVcvHiR97znPQAcDYe0\nOh2SpCCKMxQO02mMF3QYjmdcvHiJb3372wDcu7VLu9OFSg8IcG2HJJ7hSMHDD+3w6COPUJWl5mkr\ntbAxzp3jtChprng1GZSxADXZt9mQFrMhkykZ+MMsZKMgXtQNmIzX/NuU42bBmvczY/XM50ZR1Nxn\nbcbkNEpdc2RZiu06tNstxuMJluWTZTrYZVlOu9/n8tUrjCdjTp1a59FHH20qAJOhDofHgODo6IiV\nlWWiaEq/32N1daUWDnUbeMNscltbW83z5jgOzz33HL/zO7/Dzs4Oly5dYmdnR9P46s0mDEOOjo4Y\nDof0Bn1anTZlUZIlaQMhZlmGJW12zj3Ey6+9SqvdJo6GJ6w17nf4vt9YNC/CiCZgL9q5msNw/402\nY7ER2VToC5CMMdgDmsx6cbSaSfY2NjaaoLwIgyx+rnkOWq3WCXvpLMsaqM4Y+Jnv8XbHOxbAn3n/\n+2svD6kpPPWOeHx8zM2bN9nbu0s0m7C7ewPX9RgOj0Do4a+Oo8suQE9Otyw9BNmV5FmG69W7Y64z\nErfmfiIgDEKWl5YoshllWdDr93j0kUdZX19HOj6BH2gKXt0gzfOcPMnrstqu+eKaN17kOWmmZdKW\nKZ2lA0pSVhVCSkoFZaohDcvS09P1iDMFZUWaz5pAUZYVSom3tJM1D4PJBIuiaCx1TelVlppTrwy0\nI40oQSJYNMzXfGmhIE8S0izjg88+Q5JE/PqXfws/bCEtm1JVBK2QOEqwbYd7h0MKbH7zd7/CY48+\nTL/XZXN9TfOds5TlpXUODvbodQfEabKgfJ0rzgxHd2VlpSkxv/CFf8dP/dRPcfnqdc7u7JDlBctr\nG3zxi19kMou0z8l4Rp4XBK02ZZGj6ilEUlSoomSwtsxP/sRPkMQRvquhKCVkY4+wWI6a0to0ikzw\nNRCKWdymGjPnba51FEXNxrnIdmiUtwtBwGT/juM0TV8tUguae7poombKcsPtN5myUemZcr8sS6bT\nKTs7Z7l69bp2UhRGyZmSZQXHx0M+85nPcHR0eOI63Lp1C9u26XY7TYNbCFhdXeXKlSssLy/T6WhO\nu/Gc/+Y3v8nOzk5TtQgh8HyP8XjM9vY2Uko+9KEP8fLLL9PrdBvcP45j+v1+MztWSonrOxRZznQ6\no9vtUlQl/UGPr33zG+RFQa/TZjo5bOCit1oTeZ5qRlg9YcdUUObamgC4yM8u8npY+YLM3WTIi9au\npgFq1qeBeRZhS6D53IYWK+c2s2ZzXjS6M8+H2WTM55jKIc/zxnr4z6yUPvQsfF/PlQwc7QncDhxO\nrfZ58vFHCENdMklLcnh4xAsvvMTdvQOGxxPSPNeOTZaFNH9bFllVIN2QtChBVehJ3wWlUrh15jIc\nRxyPZqR5hJSC8sZtvvat84gaP1eVwndd2q02YSvEqWctGp8F39dwThAGBPXN1L4LAsfR3iZl7fGN\nYSgIWZdh2ig/CAI818X3HGwhmh3XcR0sSxLHs/teM5PpLe7ki0Y78zJTNZm85pvXDAr0pO+iLCmL\nDFWWCAXScXEtSZVnfP+nP829e3s8f/4lLNvBcQOGQ+29kWc5wpLcvL3H2soSX/mDr7G1tUnnox/G\ntl063QF79+7h2D5Zqq/BjRs32NjYaLIM40dSliVLS0uNH/V0FushyVmJsBz27+zz8oUL3N3XCsrX\nLl3RsnovQFRG7RhR5jlCQq/b4a/+lf+GIs/rmYvaxU4tZMKLwiyYK1vNYnoz/mjgqkXc2vxOEHgN\nRGKCgG1LhDC0PDOsAYLApyznG64JGIv8fRO89YxEiWU52Pbc4dJ4dnie02ThnnTJi4qHHnyIa9du\naLhIaf/sotDnO5lFfOMb3+Ts9hn2J2OqSittt7e3m8adgeGklNy+fZszZ05TlvMJMp7ncXBwwEc/\n+lEuXrzIbDbjoYce0jh6on3dZ7MZQRBw8eJFVlZWODo4bH5/MBgwHA7pdDrsHx8QeAGB5+M5Lr1e\nn1u3dun2+9y6vcsLL76I32px7fpNlrouYRhqb5lO561jSRg2/iaLvQnbthu+/WIz0DQVTUA1393c\nb/Paqqb+moRj0SfJvMZk7MbTafGzzDOzCLcsVnKLTV+zpk3FEUVRc/5vd7xzPHALbKXLTtuxqPIc\noSoENmWRMUl0hoynaW2ntlbxQo8kvUIySvWE+ULj3BWQZilFJXBdvXjLomgWVJoXpGntEGjbegis\nJ/UQ3KrEDgLc+uaXRYGQFpO0YpxM6htdNIvVlFxCKqpcDzrWN04RhgFSimYzyDNtSO95rjaxr7Sn\nuYZ4bGRV0u+0WVoasLa2yubWpv65vH/H3WTbix1tmCu2DC9VVRW2VWfblkTUHfwsTxFYVGXZDGNG\nKVSZE6cZluNwVOZ89rM/TNhu81u/83t0ehaqEsRxQq/fJ1daOHJwPMaxBLdv3+U//Idfp9tusdTv\n4jsOH/3IhwGd8ezt7bG5udlwa43fTZZltNtthsMhRVHwwPaDpFnB9Zu3+PaLL6GE5M7duwxHI8oS\nBksrJJmmuKmqIMkSqrJAKEWe5fy1v/HX8T2PKJriuz55rr0o8lo5ZxYf0GRQZgEBDbvCZNuLsIdZ\nfIuCjMWgZ+7XIpd3kdJphueaRinQcI5Nw3ReLp9kHyyW+OYzTeAvKq1R2Nzc1H7mYYtZrDPvTqvN\nvb09VpaXeeH8S3iuQ7/fxbZtHnjggZpG5zCb6cDX7/c5PDyshWSq4WUbX+pWq8XFixfpdDrcvXu3\nYUEZvFcpbdB0fHzcGMyZCe+GvZIkCYP+gDRJmIwntFstiqLkzJkzJGnOV7/2NXq9HklRYjla7dxA\nEdX91ckmay7L+f0098lcv8WjqioKNRdLNT97U2BdhNpMUI+iqAnYJhExfZJFV9JF+MW8x2Jj27iU\nmntvBD+LzfFuVw/b+DObgZdZTJUJPbVaWbVDhFY25UWhHdNaLcb5jKqsGPS7bG5ssrV1msk04bWL\nr3N3b4+s0FCB41pks4w801PsldAX13M9PFvj4ZasM9CqolACx2/hS4mZMSkqCcIBJNKWCLSHsJQ2\nSAUSXNev5b4ltqN0ExTNTJkmOa6t5c1C6PPK84JZlDXlcJorJjMdiB1RcRtNW6xUqRuMAtbX14CP\n/IlrdjQc43s+ti2oyhxVy+od22mwXtuxkYAldRZWllVjGlSVFQi98UkpkbYWmWgamdSzNPMKG8ln\n/9wPkaYZX/3Dr9PtLaGQjCdTLCeg1+0ym01QSrK3f8DevYq1lWXGownxbKphkO1tds6dZjyNubd/\nRFVpI7GD/X1WV1cpioJZdMj+wTHD0ZTJLOKf/x//J7bj0O50+fbzzzNYWkJKm/6gz6SerJ6kKaJM\ntOVAVbLU7/D3/97PcXR4QBQntFpt4kjj7EmSUGblnA1SZ4SLAdLzvDk1s2GYCCxLS981RGfjOnrR\nlUWFbdkIadeZ8SK0JZvSffEzmkaU0toE8zuGM6yDiT63Ss2tkg0+LKWeWamUwqmZUJaUZJFujG+d\n3uLs2W1u3NzFdmw9GT7wqcqyCcb7h4c89OAO05luulZlyWQ6par7FEkck6UpD2zrhufW1iZZqp/b\nq1evsrm5yfb2NnEcMRj0EUKwurrK/v4e/aUl3SD2PCbjMd1ul36v11Qc0rLwfY9Wu0WaZQR+wDSb\nMJ1OCcKQvf09ZlHMrVu3iJIUNwgY9Po4MmU2ndLpdgmC8L5xxGDgjq21F0YGD8ZjX1dB5lrmxXze\nJNBs2I1+wkAqC/j3IrvE3FttETAXgJnfg/lGbu6dqeBMZWDYRHktDBJSNGwkE8CNtfafWQxcusb0\nxSGry9dZFBMEIaUQVJbFLM2wa1c937KgLFhqeSy3Ax47+53MZjPiNGE6jSnLkqhUDI+PGY4m7B8c\ncHhwRFpEOK6vxzQ5Lrkpd11BpTKKvPYzsES9sEDYQp+TZeOGPqosa4Mbo5JSCLt2JrQF0prv+FWR\nIyot10cJhHS1paUSKAQVWiikhEBJi9iwRygppc7Udkf3b9j8y1/5MtTiECk0991zHXr9Pp7vaSsA\nSyKp8GRJt9ul29XWqRunNlAo3BofNNztvf19Ov0W7TCgXYueJpMJk4N9PvWJ7+KRc4/wC//yl1BS\ni66scsokj/W1cUOssEOpYH8Uc/doiueHHOcRV/ZeoX/pOp7n8dIbew3UVJUllnijgVSyLCOKIibR\nRDdoiwh3MmPtzGksS+B7PqPREe0wJI6OyNKEwLGp8phnnnmGT37ykxweHmuIIi/ICz3+qjgeUhYF\nrdA/EUxNsDULzODcVVXVDBFVVyjaq8MWNkJJyqwCJZFKojJFZSlKpZlMhuutF65q/q0w1ZhNVepR\nX9IyakHt/SOEIs+zWsBREQYhRS3kqhQodKO92+s3lZbB4x3HoigzyjLlv/iRz/EPfu4f4ooA2wmI\ns4xuu8Pd/QMee/Rh3rh8lfe/9/34XojnuNzd36Xb6RAOlgG4O5qyvLxONMuxbZ/pWCtz9/b32Nrc\nJE0TUC62Zenxe5ZkOhkRBgFlXmBLTQkc9Ae6aXl8xPLyMo7jcG9vD0c52gs3LvFaPrnjkhYZcRaz\nurXG7/7yF4jiKUtLqwyPRwS2S1nkBJ5Pyw849+DOfddEmVfY0tHy+LJE2n6T8WrKrzEwq1BSYLs2\nsqhQUltKGEFPmmV6GIRS2jahKlF5hqhOPjuLWbJpUC/+bV5rmpJmfsAi1KmUAlViSeNfBHE0JUlT\nPC9oAr+51293vGMBXM+QzBqQv93unOiy610uwvMcHMdlNotwXJdWq0WW5fNhvkIbtVcVrLoupzfW\nUAp8L8BxPMbTKS++eJ6rV64xmkxAgR+EKCqKskJUtbVtpVWaruNCmRPY2sK2SDMsW2evQkocaZOU\nuX5oHQfHcmozotpYCiOvNhM+JLawUfWiLspSbw6Og7WYvWHhOLKR1d/3mlUVlgLLdhFUxGlGmuWM\nZhpush0b23GgKsgTnbFJS5LECb7nEkUxrufWXPAeUkqOjg8RsvZpkZKN9VUeeeQRNjY3aXe6PPHu\nx/ib/+PP8I9//p9SVSmlkNiORV6kHBwnDUPC9x2UskmyRDd2peTm7pHGBtV86rbJRsqi0KZGRUEU\nx7TabXzfZ325r2eM5gkoSS4yHGlxZ/c2/X4H27IZHu7zkz/5kzz77LNEUcRoeEQY+gSexp/LPEVS\nISzBeDxsIJNFPq5pDBZF1iiCldAKTtuyqVRJluY19imbCq4otHLXcVzK0tbNdAVVWVMzgVIY62NZ\nM5Nqy2RhfKJz5MJsTkNLTFM90EHKuYLPlO6L/YN5Gd9CqZI0y+n1unzw2ed4/oXzjMdjpLQYlWN8\n32P31h1c2+Jf/9Iv8VN/6S9x9dp1VleWcF3NEtEQh0UY+Fi2w3g0Znl5hVdffZWtrS3abc3njiNt\nmdtqd0mzHLvui0glcF2fLCvZ3t7h8PCQJNHDL+7evcfGxgZ37tzBXXVZWllmNBrhBQEqlURJzC/8\ni89zcHDMyuoyBwd7dDo9ijLDlrqiWVpaYmfn/gF87mciamX23GVSCNGYe5VlCZkgK3JaNUVWWnOL\nV2uhwSvrQG77LtS9C/PMLGoBGjhVzC1lLctqlKiGvTLvb9CobwPfPZGdO46DZdtUFc06eTN75n7H\nOxbANSfbWfDyQEu5hWxoRaaBlOe173bT8NN2oOYCuLVQw7UthNDeI1WpqKqMfsvlo8+9n+/6yHNU\npeLg8ICDoyPSrKgbPYqq0grE8Xjc/CkqDe9Y0tLUQgFCWKiqwBUK4WsRQEUBaFaKG3oaY66HtioB\nWIoKDblIaSFtG8vg6VWlp25jgrjSJbvr3P+auR5lXmiGi1IgLf0ZQqGwyZQgy7Q3i+PqUr5UiqAX\nEkcRlt9C2g6lUhyOJzqYCQeUIEo0H/fVi1e4uXubB7YfIE4ijkdjhG3T7/rc3dsnwWaWRvi+xvuz\nPKGs5ja2rmM11q6+32nk5kIIoniGqoO5QiEdi3YY0Bv0UUpfi+FwiO1Y2Jb2cpklkVYcBh6T4ZgP\nvO99/MCn/1uWl5ZJ4ykS2NpYYzKZIGqnwE7o14we1QhLzMIBmqBoRBSGrke96WZGfAEkWQwZOLZL\nnmT1+DmPND05rNaytR8M9b2uygoqnUVrd0g9fX5OK9NBOAiChulRVVX9vEl9zdCL2bFt2q2WzvBq\njLcsS1SpvaxbYcg0Svjgcx/k1VcvIYRNmqTgCWzbZTiZsdTvo4TD//PFf8/HP/ZRLFsPhFCqYhJF\nNWynmM3GeJ7D9Ws3WV/bwPcC7t07wHU8Do9HLK+usbKyRhxHNW+5RCkb23KxpEORV2RpwenNMwyH\nQzbWt8jijEF3mdHRmMTT3vBZntPqDHjl4hvMopxur89wNKZCIURFp9uhSDXUcPr0adL0/pNpTDUi\nJCg1H45uWRZZzZYxEAmA73lkNSVRqAW+fp43mD3UM3IXqInmZ4t4tgnoQLMJz2azhuNtzK/KN72P\n4zgNF928L2jKs+sFTT/EQDZvG0ff9v/+ZzwWaW8aH/UJgrDxVjbkecOVNDuULkl8RqNx3ZX3USj2\n9/dZ7rTrslTUWKOW4IZBgOtpXxCh2qwMWhSlzo4M7mX8DsyF8/2wYQ5MkhmT2ZQrV67y2sWLTKIZ\nWJJW2EYJQVVBWc/irISF43pNs6usMwIHuUBZqnGyIicvMpCm8aJvx1v5H1RCOx8WeakN+anVY1Ig\n1NxPQQibvFIIqb/bdJZgOz4tzydJEz1yzbVBgUCSFxWSimkcAZJZnPP8iy/RH/R48qn30Ov3Offw\nw9zavc1v/P5XOX/+PHY0Y3VpmbRurDVd+lp1aNsWulwQNR9e1PYJdb9BirqBkzCZTPB9j263i20J\noqneXFRVIqqKJI6YTSb843/0jxgMBqTRMar29BYojg4PNRXNGAQpkOhyOS1OTlN6M05pgnuv19M2\nu0KLOqgDaJ5nWJZNmtXe1R3tP1LkVbNJaD8S1TSzmlK7rn5tR1NPzSanMzLtsXN8fNwwJfR5zlWg\n5hyNXYHjOBRZRpSmWlhkadqs7nUoVpaX6fd6XLl2A9f1Scmx7YJer8doMqXX7nBv/4g3rt7gyccf\nw7ElZVmxtXUa39eDLVphyGQ8pV+Le7KiYDaN2Hr0NG9cucL/196Zxkp2XPf9V3XXXt4yb/bhUIsp\nyrJkSaQo0atiy7Ei2fESBPCOwEgQJN8cIIBjy0AQ5Ivj2EicIHEMBIkMRXGU1ZZpx9BqRZAdSNbC\nRbvEhBTFZYazvqW771K3Kh9OnXvvGw6Hjm1xRE8fkJh+/fp131tdderUOf/z/4cQ2Nzaoo2UqF3X\n0VRtXwQGRFnLQ5mVPPHYE5w6dUpQXOWU8xfPM93YBJPx8P95hPe970NMpiWbmxv4DmazCUluuHDh\nKU4eO8mJEyd58Ytf8qyR6IAEks20beV0riiiYoQ40XU+Rn1c29I/dphpmrJYLHqFL/E3Rd9DcC2a\nREEK4y5L/cwx5LcoCtqm6n3OmKvn0mURzd7e3ub48ePP2pWtZm7k4Y2Esx8GCiAHfieE8DZjzA7w\nX4AXA48CPxpCuBr/5m3A30JE/X4mhPC+67xv+N3//m8B21exlTNgf3+fyWTS37TubF3XRW5t4c5u\n2yhCkNg+wst8R5qlVFWN8CUPquzxcwGJiNJs0g+8ojGcE06WNImipyZuNPLHdEiLbes6Hvvq4zz2\n1cc5WK5YLpZUdUPTtjRtFx/LsSxNM0JQBrvQ5+RCQIqPnUw+4Rm2KO/Ff3z7bzzj+/jJv/N3yVOJ\nzoMPKKrZB4EK+iARmsfQOXEIeSqSZkEjB/mDnr1NhA0yQQI1NcY7uq6B0B1qT267jjwvcIlQ4u7v\n7bO7e1WigAYsOgAAIABJREFUxEwU0bMsI7UDi5/Jh3b0rpNGJ/ygN6gpAhC+ctA8Y+xm7BwWOHH0\nKN/31rfgnaPMC7AdwYuGYZZlmETSG2mkZD26c0SkxFILiYkLpsFgYueuF7k5RR7pHDESRQt6SZzs\ncPRd9QiCulphKOXrjGgbIp1wnCoxDSKMmLVbIsRUctpxTqGBtoev1XVDGr9b3Vg07aTBjhbU1Imk\nkU8+TTNskkUJu4xf+ZV/xv5yRVW1bG1vM5kI50eWptLV6Vrufu2redkdL6GplhzdOUKRp7iuZT6b\nce7cebY3RO3oShSAyIqUz37uc3zzq78Z5xxPPPEEx48fBwxlXnLp8mU2NzaidqfhyPY2YNjf3+9h\neMYYTJ7w2GNP8NT5p/ngBz/E0eMnmEwn7O9fZVJmHDkyY7HYZz6bcPrEWe65554YicI33/09z1gT\nn7//I7LR+fZQpO29nGv1dDWmoVDEmW74SqyWX5OrHiOmNPga4/R1g9UUivYB6HuPkTC6OWigY83Q\nNCY+SfL1bTt0VOvnv/YNbyaE6/Pp3jACDyFUxpg3hRCWxpgU+ENjzHcCPwS8P4Twy8aYnwN+Hvh5\nY8wrgR8DXgncBnzAGPPyIIQlh2wymfWDoTepkld6vM3zHILl0sWnyIucNEtJkpaNjTl1vcLahCRL\nhf0NMCHBJIasKCjsBFVeSVOp2vdbVRChVJvEhpbYtGMTQY80bROPQBOqSo/aGQFDdeBIspwzJ49x\n9sxpmrYlYPv8m4u58raR1tpz587x9IULXHj6gshL5bl0bwIJgIEuNFgjatzGypH5emYNVNWSrCcA\nErw3gI2LM0QVeh8MIUaXWZZhs1wad6xEpxoh+BBYNTVBanQy6RLhg07yGRhhZCwVdoe0zW9uHWFr\na1uQDq6jbYRkbOWWEB2lWw0wvJ4cLDYQXVsQSmMXqywAUeWezeeYEGialvvu+z3auiJLErokMibG\nMUmSJJJgCc3BZFriOheheylFUXL61EmKvODIzhHu+IY7KMuSK1dlvm1szGOEOKd1Nb6TQrHrhKPd\nAKGDLMtpqprOdQRqjBFRDx952m0qqTSJ+GJwYGCzlJyoa1vSJCePEfZqWdFUNSEPZKkUCFVJSDcX\ndRLaTaqRuixwR16IknvTNWAsKYaf+qmf5B3veCdN46TQv6rY2dmhiRzV21tbfOwTn+Spc0/xEz/+\nI9TVitA58jThq199nCNHjhCMxySBNLNMZ0KM5lwtm7rSPk8Ecuh9S1lmVPWCo8e2uXDhIouloChm\n8wkXLlzAB4F1FumULz38MA88+BDbR49RlCVXr15hNpswmWYcHCyYzUo2Nze5/eztUjg2aeT2eaZp\ncbxxdR8Fa9qCEKTWFOeYnM4CVWybl1NSIimdWoQmxnhvdbDz2UzSGs5B/D685qjjHA7e42MzkDbr\naN1Fm4w0AjfGYBh4dDQH7lxHGmXhNP/9Z0ahhBBUlC2PPucK4sC/Kz7/DuB/IU78h4F3hRBa4FFj\nzMPAvcBHr31fQyKQtnjk1qLftV1srvU9JCxNM/b29iSKijulJ1A3kb85WOxKothyMpEF4aQzTuhn\nZYGB6EYaa2WBWiL+OsJ2IqxnVVcR1kW/IAMZXdtIC3rMlfZQvAB5JpDCwqbMTh3jxWdO9Bws3nsu\nXrzII488wrlz51mp8K+Z98UR/fd6tr0xoVpJoS20ArX0iICA805URRIRGvCtpG6K1OK7FqPV7A7q\nyHme59KkNIlj7luJKBWZk9hMNrgkyEKy0LESB+cjpW8KttS0hDQvaTW+9nXvbEJMLyRm4I/oye07\nKc5mRR6Pk1l/OvBdR4tIqfkANhjaYPuIx1qDB9p+3AKrvQpl2GsuXSJJU86dv0DTtHg9xRnDkSNH\nOH1KmBUPDvaZ5hM2NzeZTuUEOJtN2NzaYDqdMJtMaVuPtblALlHcMeRpRucc1bIe9A07JaMyrFZS\n2ykLUUz3vsO1gi+eTmcYY4dOUNOvu36xa2pmHEWC4Pg752PhLsV1jqZuOLazzTd+453c/9BDwnpp\notqV90wmU3b398iznIcf+Qr//u3v4K1veTM7R7a5eOkis42tWGtpWK5WBOOpY+fiqVOnSBLLbDJj\nf3+X1WpBmmZ458myhLYV0rJjx45y/vx5tvMdsixle+eI4Pmbht/77d/iS1/6MkePHcdYy8HBLuDZ\n2tqgays25xsUZcqxnR1e+tI7+trFs+GhFwvBSudl3iOKNCL2IYjylh3mizrVcR9AX0uLUF8lchuf\nHPoNIdIg6CahJ7S2bWli4KnR87hwqR24fUevE00DNXXurRv6PMYNZM9mz+nAjTA5fQq4A/j1EMJn\njTEnQwjn40vOAyfj4zMcdtaPI5H4M0x3JSCqm5heDUMB7lrIjNeBSSxnz55FeIKlkLNYLXsMdBIH\nNslS9hcHdE4EBXDK52wEwhcCdSv41DQ6NmONSGpFUQhNq9g0xXSCUjeS4JUJYiI5k+/oOlkcUtjz\ncYdPSNKEpl5B15JQ4F3H9nzKva+7SyZK4yARx57lGdPJlCtXpLHlX/7qM8fsjhed5sqVK6wWS1Yr\nqXC3jTjJNM8oi5IueLxvSRPZmLS4kyQG57sYaQvTY2oEF24IgtrIE1Hyzg3WJtR1S/BQ5CK5Jrjg\nBJuJYw8+9Dlt+Y4SYWWMTjs1yZAuiffQR5DdkEoJIZApjwwy5sTOgCzNJTURhE8dDElexkgrOjIr\nfQRd5yXfbsEHS9dBVgjD3P6qocwKylKcN0G6cnd3H5YieS7SfCqEnKWppGmMZ2Njk8mkYHNzg+3t\nLW47c4bbXnSGyXRCFnO/nYcsLyU9Y6SDL2DASColTVI6F6idbmqePDfU9eHmIde2mFG+V7DMvpfP\n06akqqqwUU/T13JqoXO0bU2SWP7q97+F1WrJJz51PztHjwvkbyZScZPJhOVKmB53Fyv+22/9Dq98\nxcs5dfIE3/iyl9E0FcZarly5wvHjxyR48YHJZEqaZLRNC8EwnUhh1UShZ3BkWUFVNSyWNUd2UroA\nJsn55Kce4rHHHmN3/4Djx49Tt8KUOJ9PKcsC1wiufzrZ5MW3385rX/MaXAdFMenFgq9nRSmbWhpP\nNYc6Hhl4ZoiPnXMUkb9GA40kSWK9o2UymTCZTA515g61pUHGUKkR1DfNZjPmI5STIlDGNAjKdmiM\nwZrQQwV1vRRFQesGWTU9hd3I/iQRuAfuMsZsAe81xrzpmt8HY8yNSqXX/d2/+vW3A3L8ves1r+Su\n176qbxNeLpf9ZN2vhIb0ypUrbG5v9Q62bQVnubGx2Tc/tG3HfC6pmfl8hncdV6+oiKvIX+ED1liS\nJCdJkyg6G6PG4MmyIjqS2KThO0KnajiiqakiuDphgvdUdUW9XGBTkbRKbEGSZVJZzoq+Qy1LMqp2\nSQhQTApccFjr8Y3j6uqAjfkGTXN9Csnv/a7vILEJRZbjXEfrHMWk5JFHv8L/feRRLl+9wv7BPtVy\nRfAOEJ3LvChYLiq6VvJz5UQccttW5GlCYqSZyRiLsa3wNHYdk8xgk4wQPGkSmE1K6moBIm8h6ao0\nhVggdq2n7TqhyjVQ5tLaLwXJoTXbRAfqfSdKRQGC68jzRLq5YjcrKMQzgBfOGe89lRP0SJENGoME\nsEkuTTjWoLGNjSe7IpWcdd10/YkgsZGjOy05OFiQlTlJXkCAqnMkkRXywtUDkoMF5y7t4tyjJOln\n8K7CEDhz223cfdfdnDp5MnbAJuSZIJekEGrIkgRnXWR/sLFYHXrYoY6Jj2MhcUI81cRTSGqHHKtr\n5CQjqAsvJ0aCcN6XBc7VpAR+5Ef+Oj50fOqBhyjLCft7LbP5nLoOlOWMg+WSNEnY3Njgw3/4vzlz\n8jTGptx25jQGWFYti0WDMRJFlkXBaiU55Ukx42B3GVM7E7w3BJ8SvKWYlBw/foonnnqaxWLJe97/\nXggiY7izc4yLl55mtjljmmekWcDQkOUZmzNpALrzZS/HNZ5Vo927z06rqgFB5wc9Sk1B6YY45oDJ\nI30tMUrXKDmNr9cctiKUxtG0vr9wsGd9oOmcY3d3Nyp5DU1c3vs+hanSdEPNxVPEwnTfBZym2AQ+\n/okH+PgnH/wToVBuWMR8xouN+YfACvjbwHeHEM4ZY04DHwohvMIY8/NxQv5SfP17gH8UQvjYNe8T\n3vPu30RI6geKzs7LEVhpHYWhrIjV3Uza3uPN5rlEIdP5nP2DXUIIlIVUnPMYtRikmDQu+DnXxWhf\ndm5No8hxyFMUeX8Ul0ngadrYdhuE40LSNYGmrWUzsCP+5jTFhbirB6WpzMhjq2xi0z4CrNsV2NBD\n1nwQhsPEJtz7xh98xvh/5lMfJHQB34WolZgP+dckgcTQ+YBrG4xvyDNB6FR1y2OPP84TT56naVuq\numFxsCQY2Nna4czRY7SdFFq8BTB4A3v7e1ENqWF3f1c21koiRDmYGaHuNbYv5vm4qHwn95VnA1QU\nJMohNkf4mAZT9AqGnstDH/cwLf20AB32UGSUWElb+c5z7TqvXYdlYIJTFsbgvdAbxFxmmqS4TDca\n4eYxxuDqRjYpE3Ct6xEGqfHIcUbSTqJI34loSBEFGeJxez4tIQjVwtbWNvP5lNlsxomTJxAVnIFj\nXKPEcRefbnzjln7nnGi7lgUhyIbqu4F4KxhDVTc4D7/7e7/Pgw89JMcxLJvbOyRpJrA/58jSTOia\nr+6SGOFbOXnyKHd8wzfwile8QgiuHn6Y206dYrFYgBbY1AFF9NbTFyRd9eS5czzy6Fd49LGvihpU\nlvYCzsE1YDpmGyWtq5hOcpqm4tTxU5w9c5Z77n49+JTQeTob+kgY4M5Xfesz1sQXH/qI3MNExlhP\ngDpn9LGe+qy1kKcEH7A6H2HIaUfnnUdx8kbppu1h/nc9CY1JqopIAztO02itSdPD/SZhhhSZzk3x\ngfTBq2LZv+WNP/inK2IaY44BLoRw1RgzAd4M/GPgPuCngX8a/313/JP7gP9kjPnnSOrkTuCPr/fe\nEonEHGbMV9qkJEmG6vBkUpKl00gANHB+CIWnwnwOZGB8IE0MIlPWEjrJCyZJQhbTFHkuijyZTWhD\nQhs/R3ZsHzGtpt88+hb7JBUOjojmaJqGrnXkhfCFd52DzpPmGSYdlHy6LjCxA3/GtCgjxGnAHxvT\nxZw/lOWUjdlcFsl1zDU1TdVSZBllllDmObVzNK4lGE+WlYIvxZOYgGtWJEnKtMi448Uv4uV33klR\nTAgY2k5EbG0Af7CS00chAs/eeIKFqqmxqSErMmH/w5ClEx599FG+/OWHOXfuPFVds1hVBBKMEa4Z\nY8SxrxYrouJXPHKmZElCEkWEJbqJsmLSdkgwkFkL9nDHmxanEpuQR9X2mNEi0rXLQvGKuImRdlFi\nrYy/Dfq6gDUJSWpIioSmrvHBsKrVcYJrOrAS2fWsdcCqEjKq3Iv4QpalEY0ios/4QNvBwUGFj6im\n1bxgf2+X5WopdAnAxoZoVgphUmBzc4PJZCINVPM5J0+c4Mxtt7Fz5Ag7Ozvs7e2RJCmr1RLvRTfV\nB+k36FyH9w4fN+HlckmSplzd2yPNcn7qJ34U7z2fevBBDJYrVy4ym2+R5xPyvMT7wJXLu5KTNZAk\nGZ/73Bf5ymNP8Ad/8GGCDxw7usO33XsvJ06cYGM2Z7VY4B0sfMXjTzzBF7/4RR75ylfIilJSmrmU\nzKazCU3bcf7CZVGrN4HJdMpiscv2zoyua3jR7WdJk4SX33knbdtS7S85cfwET+9e7BWVNO9/rSl0\nr1L5NDMwbnadwG21qKgTpY0plgRFpUVfpLnziFIqy5J5vnFoDuprNUXSNE2fTlmtVr3z1tqY8sho\n2kUdP6E7pL0pcNY2wp9Nz+L5bPfd++jngBG+GilS2vj/O0MIvxJhhP8VeBHPhBH+AgIjdMDfCyG8\n9zrvG37/t3+jHzyIEawd+HjHFz7mTdZdUJENuruNcZ2aT9IdUB2yFjc0atMUyPXyTDoBdFcc58v6\nQtVoRx7nc68F/+sXb2KOHejTMJ0bBInHkKR7vuMtz7imBz76gT4CU129QHdIVFWKLHmEq7m+lpDn\nOU30plr1NsawWC7Iy3xIU+g4xuOhWugiYU85sK7pv3rvTSe0rJcvX6aqKpaNpHlc23JwcIDrOnav\nXuVgsej5nauqEmFoW8Zx0/SCx9i0XwSa3/Yh0NWxOcOKmIe+RvUp9bo67/G4/nvr/FB0SpKk1zCU\nG4TQDa+99vvVcde/z5Okl+AySRJx3kJqJvBD+npJaiTCk4ULrnNMJ1PquiKECFUNOq/Bd8LbLvPU\nYAMcO3qUM6dOc2xnh9lsJnn11Eoj1NYWR49sybXHk0vb1mR5BgZa1+JNykf+6GN8+A//iEW1Islz\nkqwgL6VjOcukBkAI4IX7XlMQNsoTXg9PHYInzeJJNxjapqOczMjyjKapwHQ0TcXm5oy2rdiaC6Sz\nLEt85zlz+jR3vuxl3H72rAQ6TTs6gQwCFiEEXvW6Q9lbAD79iQ/GOSvzsCwlSFLMvfehryP0RGKT\nvH88dH4j0QND+soY0/OV6Pc/rvnoOtcNvg2DdqpG3vpeY14Ta21f89HPUXphY0x//5q6ef23f/+f\nLgIPIXwaeN11nr8MfO+z/M0vAr94o/fVix6rnFgrudqhNVYmy+XLl9nY2Oid+LUDr1+uOmrducbk\n+sulAGmkCj/pd1GFLSrWVojwh4JHHyXbgXZUaSN1Q9DP0N14uVz2jUjq7PUaVG1Dd+v95VKEjuMR\ndFy0vZ4pXlUn48bGRt8Fqbk6KW5ZibTDoPeoY6XXphvUbDYjmIBvHT5+JyEEFgcHfc4uz3PyLO8n\nYTfaXNURr1YrbJqwsbnJ8ePHY0ST9/nIxUJa+zciVlhhccp69+gTT1FXFefPP83jTzzO7t4urm0i\nU5ucgIxNKJIEXwjfubUBEAIjQ0qWiFyXa53UGPKM1osQtqAGhJzKAM41FGlClhjyvGBvb1cKjla4\n3L1GUnG8k1Rk8HSeYWzfTSybg8dF3Upj0n5TTpKE4LTRI/KgBMOqqsnzkq5zUkL2gTTNSRJDyPKo\nBIXg5ruOvf0lTz75IGWeRWrfJvKqREWoxDKbTjl2dEcoCU4d5+Spk+zs7JBPcgwJb33r9/Hyb3oV\n//rXfo2mavDecPXKHrP5BvO50BQkxoozjgyWWZy/+/v7HDlyBPwgJaaanZ2v6TqtDQXapiJ4x2q1\npCgzygidzfMZu1cv9nTKx48d53V3383OkSPCpljKnN3e2qKuapLsucmc+jRavN6xIEddN31znDJN\n6tpWBkBtRtK+kh6CGH2UBka6zlXnUmmB7SgQbJ3rifi6VGpBWaTGSIyhiIRceZHTua4X94aB4nbc\nFKTXeiP7/8qB/3mZMSa8977/cMhZJ0lcPCPoFAxVeH2dLqCxkv2Y1a2HrY1er1H3+AjjYp5J30ML\nHRrV688hhNgOfZhm9FpKUv0bVa221rJYLPovWBuWdCOS475ElXoNGuV3Xce3fvcPPGPcHvjoB4Bh\nEzPGgPH9Y3XUwQecG04qep15jJ51UchmNqSwFKrmnIhkjNt5lSlNTwia+9QIQ78Pjxzrq6pikk8k\npRHvryjyWLSU3EdTN/142xGda55ntK2TfL6TnPtyueTqlas452lDx5XLV6RLzYg2adO2BCMbyWq1\nkg16b4+9g4rpZMJqVcUClusjqSIvek4day2rCL3UzU2/17HCuJ5ecKG/t1gcGf4uPrbGCMS0c1J3\nUfR6YNS4NWgiFoVwi7hOajBSX5H6QmolOrZW8P0+jrWJqUQ6ke6zsWCMhaZtMIllZ+cIs8kM4wNn\nzt7O8RMn+P33vofzT18gzXO5fGvJEmmmy/JYzI1zTdOQ+l0rJ4ykKiDgoqCyAT+kIdq2Is8Tlqt9\nvHdMJiVHt2Zsbm7y8jvv5JWvehUmyH22TUOeZRzsH/QINZsOsL+u63j169/8jDXx6U+8/xA8UAOK\nIkI2lRd9DM0NSDdk50X0HIRwzMTx1s07jwVKddxd1/XSa7re9Nq0cWh8yrdm4ECxo/Xku446Bmvj\nrlBtaNQNRP3Z3d/ylj9dBP61tOVySdd1vQhBFVMCGplpC6keRw4ODnoV6cVi0SufjLGaqiVnre13\n4TFESyNdoG9fHjt3zZWtVqu+xXk2m2HtwJfRV63T9NBmoV/omLBJu7Xquu6J8/M87++5i4gWnVy6\nGT0bDlxzbGOdvLwYRHT7jc+Ynnt6f184zbe2tqgamdzqkITIaEVZFn0UoZuhOnSdTFpY1o1VMKuD\ngGsVtQO9cxgM8/mcbtVQFnl/ymmdE9Yn3bQtZImlamuM6cgt1HXFal+k7bI8h64Db8ht4MSxbWbT\nWWzesriu6zlEtFt3/2AfFz9vUpY89eRFiqJguVriWkfd1IQAFy9eZH9/j6fPP83+/p445o0dDFKA\nJQTSJBFkSjKXnDtSBG/bFptIbYDYbSn9BLZ3wILHj/C6xJJmwwnSWkteFv0mMS5K2jwnp5ACfKyv\n+M7RdILCCa2Mn6g9BbwL1M6BD5KP74SStms70rwEA+cu7eLby8zLkiefvhRJkwzb2ztcvXp1SEHa\nQLVc4YGkLA81tUgRdoo1BmftQL1rDNbGlFeQFNKqWpIYaF1N03jSRBq7sgTuuftu7rrrLgmaYlC0\nWCyYllLkVMRYYizZRFODgaq6PsGbpKsGeDAwSkMEqqruGQE1yCgLWX+uc3FTFCRZQL5zvMe1LcEP\nHDVjLngNDseyacaY/vo1764nbXXMWZbJyckOKk0qsafjrKkXubevY1V6ZVYb72bdqFilDklJ1Ofz\nOWmasre318saaQ5Knc7Vq1ex1jKfzw85NF0kY5zohQsXeseWjHZHFRrQKNo5J3Jp0MOG+q4uhtyo\nDv5qtWI2m6EcGypArPe0Wq16jheFiPU/h4FP4Xr2bW96JjJlbWt7Idm/+fU/3/fT9TVOJGhgZ21C\nnof+1Dnk701P1Tqfz2OrvIAc1DTwU1+iQZnCB1UQWaNway1FlmOCnAhb1+Gatm+H995TLVe9OHIW\nWUG1nqYpWT3p3qg+N7ab5sA117RcLiNRVcTORlNHOZvN+qOItZb5bDa0FANNjG4Ta4XQKMKbuq4j\nTZJ+F9X29KZt2NvbF7hXzId77/svVHdA5xzL5VIihUzyjrPZLKIABpXzPM9oGsGIz2YzNjc2Ygoi\njeiXwGw6o6oEEVLkOcTqt4uq20mWkubSzRdMjAzWtra1PaepOEKSqNMeI5cGB6s1N4mYh4LkuBtT\nT+q6KYBobsoJS/R4pZGnIUkUciiIJ+c6vPM4Z0ZpFGkerOuKPBdIcpJI/ca1NdWq62lAmqaRGkQq\nsOcOHzeCr1NBh7HKtNBxpn0BoiiKPgKuIrPY+KiuRxdFUmTpoBC+t7cnzjgeU5xzHN3ZOYRUOXb0\nGCBHlOVy2Ufqe3t7PZHWODcakKaTxeKg16oD+t1bj1Dnzp1jPtsQXHAY8LxK7B5C6PHSmoPDSEt0\nkgjHBwxV8LWtbW03Nj3dggpqdCMAQ9Kf0lX/Uxy0II806pX3OFw81E0gy5JDiJA0TSiKnLquyfMM\nyPruTO0YlRM5vQNXkrI0FXZU6RdJSJJhAxHaj5ayHGoPLhZEb2Q3T5En7oxVVXH58mXSSKqvTlnp\nGrsIhdOEvxYUdLfUL8hay6VLl3p+ZS1AFkXRR9J6VBkXLZXe8ciRI33eXPPXA/xsgAfNZrNDOeiB\nkyOmcpynyIt+MmmOfVyYFYy5i9zHg8wX0LOfrW1ta3tuS9PsULOTrjXJUx9Ooeq6FbqBQcwYBlTb\nGOU29heaPlH0SgihF15RdFpqD3Ot9A2K0UmPU7gmDHh1rS/pRiD3JcV9Rak86/3/+Q/pn8x0YHei\nnl5d14JMaJrRUUfag4ui4MKFC4QgCtd69OnTLzH1sbOzQ1VV1HXNqVOnWC6XrFarPlWiOWzNO3Vd\n1xc+VZG66zopxnltz29JRsUR/Tv9vfIbtG3LdDpleTAQ2uiXM0afKD5dmP1EFUR3eC10Durya1vb\n2m5kuobVhyjwQPDaAg/Uda+BkwlQr0TTsm7aCBNMaKqmr5V519F2DWme9ClTLeqOi/kwIhfLIqgi\nClZXq6p/v851dG5oBFIfpoGoNC5O+tqZBoTPZTc1Ak+ShIODgz5lEBjQHYou8RG6s7293d+UKmVn\nIxiboi40BbK/vy/dj9EZA30hUYuNQJRoaw4NnDLl9YPLQISjiJfxJhNihX65XFJOJhDoo+i+Cyya\nRgtpmrKqKlxdM5/PefDTn+Oeu1/T1wbu/9gH+pxeXdeURYHhcAONyHvR5/hAK/EGwoBhJY6rqtOP\nj5oQyKylbupIKyCF27woqKpKFoP3Mjmdo0yyvhMty/OoNDT8nUYYNkmEewYlt6Ifj6pa9ZulKs+Y\noMRXArYzFj7+yYd43V2v7GsCPUontrR774V/IiJvNJpyneslslaLZX+s1fdQJIEuat1sXecJwZMX\nBdYY2lZk6rz3VCupYZRRLLhrZH6Uk5JqVfXdeABtN6T8rBUKXSlUpz3kMc9zadu3pk+5YaSW0jcy\nIRGaIURCpIoHH/o8b7jntYJDTiyNa7DGMinLiHtOpCPYGpL4/axib8Asn8hrTJSISxLKooiKUcKp\n0gXBvDvX9WNWFiVZRMqM4XGaZ/Y+RB7+ijQTCb9ghB9dT7pVVdHUNUnk1Ff2vTGpHUBRloQgY1mt\nBl4SPXn3zjKuTecsi8WKj3/yfr7lDXfTNE3fyaxc/CAILu178DGvrGtY/IeM3/hELJQEvo+4q6rq\nr0X9w7hRT1Ou+jrttxhDD4c1OpimS8at9eOi6Y3s5qnSx0i3rmuWy6XID42ctTGGg4MDyhEiQyE9\nxpg+qlZnpovRWnsIvqfFCuAQ9FAVf9R5K5JFO6108PRvdTGqCrY+p85QP7upa1nofXV8OEppLk5h\nSXkxwLTlAAAI6UlEQVSek3iZBH/88ft5wz139c0Fy+VSmmxCYDabsYyY8rEIQZqKGHLfeRidcmIT\n0jQ/jA0PwvsxLtyE6DydFzIoTUcpvKksS3Z3d+WU4qUtOViRt1ssFmwmCU1sttnc3DzUQOW9p4gC\nszYRyJhzTuhriwmhC9hg0Rq7D77nyfZRXegTn7yfe1//6kNH4Wq1IMsn1DGnqVGRnsS8gcSOAoJC\nFmkXcdWegAuyuJq6oekck7IU6tQItV1Vckw21nKwWLJcLvsT3aXLV9jY2KDIpBnD1Q6V97PxCF3m\npZBoIYuzrWrh4zGW1CSUce5KcBC7i51oa6ZZhvcOFyW31ImmNmValnzm81/me9/0xp72OFiBhaZJ\nwmQyjdd8QJrE1u44T+k8TZxDRSHcM8oyuVwu2N8/IC1KkjShnE5xXUueCNugJbC/txs3FYgsI/of\nxsqmbEygc8pZ469xkIVAM83gOLUdXdeaJ1DVVR84+G6A6I07ofU5heoZY3jo01/gL7/pjb3DBKJu\n6bD2VquVnPDT5NBmAESo75Ba0YANe7gHYuxPdB3qdTz55JOcOHGi9zNFUbC3t9cHC+pjdPPSDUDf\nd9wcqA7/udKpN82BG2NYLBYURcHW1lY/CYv5nCbmmdJE+Ep6HGaa9oxfV65cYXNzs4+GNQVT1bUo\nTEcstLWWVSWF0aKc9lSRAREHDiFIVOU9W1tH4kIzffRrTSdyaZ0IGaxWdXSCoc+RqTOdTqfYTPhY\nGlf3jjvPcxZLKYoWE8G4ewKta3uayTaS7adpyqVLF8jznIODochio/KQ0sdqfr+Jx0YDTEcaos51\nvUYkcKjFWCOGEOQaiiJHlWoC0ETcqqBsBItrMGRFSdt27B4sKMoJBzHyLCczFsuqH3PFjwea/p4A\nbHQ2s3RGMFKB1wWZkOG8p6qldTkI3yFJKimnPDaHFEgXpTpu3SDVEYwXhJ4IjDH41pHHOkpmE+rl\nSr6zosRg2JzNn9HcZYwhm5ZszAq6dkWZW4psBnh8sCSZdGcqdn/c/OObgZQ/mUSRDSOR/6qVrtTU\nZgNKIo+RX2pxbSApZW5qe3awEKylcY5lREClNsUEQ5oWET3VkWWW6XRO13XMY7EuhIAzjrSMp9u4\n/vYaoRIoN2aUG7M+xwswm86pqorFYsFysc98Pqd1VR9FpmnKweJAggwva3cMrQ0hCmrH/oDOeyZR\n61W/F00VysY3+IUy6rmGbMTSSBRMifJ1485sDd60Bqbv07aL/u8FX27x3lG3owBGg5zQUUzyQ1Fy\nMB6RZUx6HyRBWC38+77DE+giH9Hp06eBIRugVA263jRgHGcFxigY9QPjefRcgIabmkI51LUUj5zq\njPULriMuu2cnTIR0RtnDNPpVBz4ueGq060fdgPq8Oii9BqCPVsbdimmaktqBUF6du/6N5ql0Msi9\nJaRpFI7whyMAN9qQ9EvURaPHP5X0Uny6pG4KQpCUj/Kg6L3rlz3uRtXgQusD2hh1+fJldnZ2sFa6\nGzc3t3BuSCNo5KBHSL12vY4QzKHvTsmTNE2hJyr97HEE1XW+b6lPUtOnRMbt/poz1HvslYP8wEsy\nm036fKY6bL32wzAy34/HtS3ZWmsZY2214UKPy8YYTJQt0/vpP8umhzZDvfbx0Vr/pnZNhJAlfcHL\nWkvX+j5iVLyw1nB0zqtp2nBc8NZ5p+tJf9a5NV5X13Yj61zVQEWP8fp6bfba3NzsP1dPtuNioX6m\njvUYLaZObNzNqn0OepKU9STcMXoP+l663sZpQ4XujhVvuq7rkVz6fWvqUeegUlmM0Wvj9amp0TGP\nt5y23SHuI4jc4wyduSCw5y624+t4HfrdNVH7OO05dtjjNaPvcyO7aa30z/uHrm1ta1vbC9TCs7TS\n3xQHvra1rW1ta/uz2437NNe2trWtbW1ft7Z24Gtb29rW9gK1592BG2Peaoz5gjHmy8aYn3u+P/9m\nmTHm7caY88aYT4+e2zHGvN8Y8yVjzPuMMduj370tjtEXjDF/5eZc9dfWjDG3G2M+ZIz5rDHmM8aY\nn4nP37LjYowpjTEfM8Y8YIz5nDHmn8Tnb9kxUTPGJMaY+40xvxt/vuXH5FAzytf6fyABHgZeAmTA\nA8A3PZ/XcLP+B94I3A18evTcLwP/ID7+OeCX4uNXxrHJ4lg9DNibfQ9fgzE5BdwVH8+BLwLftB4X\npvHfFPgo8J23+pjEe/37wG8C98Wfb/kxeb4j8HuBh0MIj4YQWuA/Az/8PF/DTbEQwkeAK9c8/UOI\nZB3x378WH/8w8K4QQhtCeBSZgPc+H9f5fFoI4VwI4YH4+AD4PKKlequPixJgiLCkzJtbekyMMWeB\n7wf+HUrneYuPCTz/KZTbgK+Ofn48Pner2skQwvn4+DxwMj4+g4yN2l/4cTLGvAQ5oXyMW3xcjDHW\nGPMAcu8fCiF8llt8TIBfBX4WGCsc3Opj8rw78DVm8VksyNnvRuPzF3bsjDFz4H8gItj749/diuMS\nQvAhhLuAs8BfMsa86Zrf31JjYoz5AeDpEML9DNH3IbvVxkTt+XbgTwC3j36+ncM75a1m540xpwCM\nMaeBp+Pz147T2fjcXzgzxmSI835nCOHd8elbflwAQgi7wP8E7uHWHpNvB37IGPMI8C7ge4wx7+TW\nHhPg+XfgnwDuNMa8xBiTAz8G3Pc8X8PXk90H/HR8/NPAu0fP/7gxJjfGvBS4E/jjm3B9X1Mz0kv8\n74HPhRD+xehXt+y4GGOOKZrCGDMB3gzczy08JiGEXwgh3B5CeCnw48AfhBD+BrfwmPR2EyrJ34eg\nDR4G3nazq7jP432/C3gSaJA6wN8EdoAPAF8C3gdsj17/C3GMvgC85WZf/9doTL4TyWk+gDip+4G3\n3srjArwa+FQck4eAn43P37Jjcs34fBcDCuWWH5N1K/3a1ra2tb1Abd2Juba1rW1tL1BbO/C1rW1t\na3uB2tqBr21ta1vbC9TWDnxta1vb2l6gtnbga1vb2tb2ArW1A1/b2ta2theorR342ta2trW9QG3t\nwNe2trWt7QVq/w/Uvjt8hhUJzgAAAABJRU5ErkJggg==\n", - "text": [ - "" - ] - } - ], - "prompt_number": 6 - }, + "output_type": "display_data" + } + ], + "source": [ + "plt.gray()\n", + "plt.matshow(predictions_df.values)\n", + "plt.xlabel('Classes')\n", + "plt.ylabel('Windows')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's take max across all windows and plot the top classes." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "That's cool. Let's take all 'bicycle' detections and NMS them to get rid of overlapping windows." + "name": "stdout", + "output_type": "stream", + "text": [ + "name\n", + "person 1.835771\n", + "bicycle 0.866110\n", + "unicycle 0.057080\n", + "motorcycle -0.006122\n", + "banjo -0.028209\n", + "turtle -0.189831\n", + "electric fan -0.206788\n", + "cart -0.214235\n", + "lizard -0.393519\n", + "helmet -0.477942\n", + "dtype: float32\n" ] - }, + } + ], + "source": [ + "max_s = predictions_df.max(0)\n", + "max_s.sort(ascending=False)\n", + "print(max_s[:10])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The top detections are in fact a person and bicycle.\n", + "Picking good localizations is a work in progress; we pick the top-scoring person and bicycle detections." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "def nms_detections(dets, overlap=0.3):\n", - " \"\"\"\n", - " Non-maximum suppression: Greedily select high-scoring detections and\n", - " skip detections that are significantly covered by a previously\n", - " selected detection.\n", - "\n", - " This version is translated from Matlab code by Tomasz Malisiewicz,\n", - " who sped up Pedro Felzenszwalb's code.\n", - "\n", - " Parameters\n", - " ----------\n", - " dets: ndarray\n", - " each row is ['xmin', 'ymin', 'xmax', 'ymax', 'score']\n", - " overlap: float\n", - " minimum overlap ratio (0.3 default)\n", - "\n", - " Output\n", - " ------\n", - " dets: ndarray\n", - " remaining after suppression.\n", - " \"\"\"\n", - " x1 = dets[:, 0]\n", - " y1 = dets[:, 1]\n", - " x2 = dets[:, 2]\n", - " y2 = dets[:, 3]\n", - " ind = np.argsort(dets[:, 4])\n", - "\n", - " w = x2 - x1\n", - " h = y2 - y1\n", - " area = (w * h).astype(float)\n", - "\n", - " pick = []\n", - " while len(ind) > 0:\n", - " i = ind[-1]\n", - " pick.append(i)\n", - " ind = ind[:-1]\n", - "\n", - " xx1 = np.maximum(x1[i], x1[ind])\n", - " yy1 = np.maximum(y1[i], y1[ind])\n", - " xx2 = np.minimum(x2[i], x2[ind])\n", - " yy2 = np.minimum(y2[i], y2[ind])\n", - "\n", - " w = np.maximum(0., xx2 - xx1)\n", - " h = np.maximum(0., yy2 - yy1)\n", - "\n", - " wh = w * h\n", - " o = wh / (area[i] + area[ind] - wh)\n", - "\n", - " ind = ind[np.nonzero(o <= overlap)[0]]\n", + "name": "stdout", + "output_type": "stream", + "text": [ + "Top detection:\n", + "name\n", + "person 1.835771\n", + "swimming trunks -1.150371\n", + "rubber eraser -1.231106\n", + "turtle -1.266037\n", + "plastic bag -1.303265\n", + "dtype: float32\n", "\n", - " return dets[pick, :]" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 7 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "scores = predictions_df['bicycle']\n", - "windows = df[['xmin', 'ymin', 'xmax', 'ymax']].values\n", - "dets = np.hstack((windows, scores[:, np.newaxis]))\n", - "nms_dets = nms_detections(dets)" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 8 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Show top 3 NMS'd detections for 'bicycle' in the image and note the gap between the top scoring box (red) and the remaining boxes." + "Second-best detection:\n", + "name\n", + "bicycle 0.866110\n", + "unicycle -0.359139\n", + "scorpion -0.811621\n", + "lobster -0.982891\n", + "lamp -1.096808\n", + "dtype: float32\n" ] }, { - "cell_type": "code", - "collapsed": false, - "input": [ - "plt.imshow(im)\n", - "currentAxis = plt.gca()\n", - "colors = ['r', 'b', 'y']\n", - "for c, det in zip(colors, nms_dets[:3]):\n", - " currentAxis.add_patch(\n", - " plt.Rectangle((det[0], det[1]), det[2]-det[0], det[3]-det[1],\n", - " fill=False, edgecolor=c, linewidth=5)\n", - " )\n", - "print 'scores:', nms_dets[:3, 4]" - ], - "language": "python", + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "scores: [ 0.86610985 -0.70051557 -1.34796357]\n" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAEACAYAAACqOy3+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text": [ - "" - ] - } - ], - "prompt_number": 9 + "output_type": "execute_result" }, { - "cell_type": "markdown", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAXAAAAEACAYAAACqOy3+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvdmPZVl23vfb0znnTjFHZGZlZmVWVdaQVd1FqmVSomjD\n", + "Ei3BEiVYFgzD0LMBCzBEw4IN+C8wYMCCAL/IT/SDn/xkA6Rk0pxsUjRpkt0NsqeasirnITLmO51p\n", + "D37Y+9x7IyurSRhsJxuM1Z3Iyhs3zrDP3mt/61vfWkeEELiwC7uwC7uwHz+Tr/oCLuzCLuzCLuz/\n", + "m1048Au7sAu7sB9Tu3DgF3ZhF3ZhP6Z24cAv7MIu7MJ+TO3CgV/YhV3Yhf2Y2oUDv7ALu7AL+zG1\n", + "H4kDF0L8XSHEx0KIz4QQ/82P4hwXdmEXdmF/2U38eevAhRAK+AT428Bj4I+AfxxC+OjP9UQXdmEX\n", + "dmF/ye1HgcB/GrgTQrgXQmiB/wX4hz+C81zYhV3Yhf2lth+FA78KPFz596P02YVd2IVd2IX9OdqP\n", + "woFf1OZf2IVd2IX9/2D6R3DMx8D1lX9fJ6LwhQkhLpz8hV3YhV3Yn9FCCOJln/8oHPg3gbeFEDeB\n", + "J8B/AvzjF7/0P/7z/w4kKGOYVxWPnz6lalqUUmRZRq/XAwJVXRICVGWNc548L5BSUZYlbduilCTL\n", + "DFJJsqzHZDJhMBiQZRlVVaG0wjpH0zRoYzBaUzY1OIuUEqUUSikIgRACvbygrmuEDwghcM4hlMSH\n", + "AAKcdWidASCEQAhBCCEeA8iUxDsbB1ebRTgipcR7jzEGIQXBe4QQIOJxfvO3fpu//XN/CyHAWoeU\n", + "AiFk/A4gECihQAqsc/jgkVrT1DVGaaSU4AMyQBCSFgEEjJJorZFCEghY2+AJ+BAQUlAUPTJj0EKi\n", + "lUEEiW1a2rYlpDGxwRKT3QEQ8V4IeMAYQ5ZlhAB4DyEg0tg4D8ZkgMBaS2tbEJJ0afGaEbjg00SM\n", + "9xrSuP7rX/lX/PzP/wf4NL5CgPcBKQTee0IISBnHSEqJlHJxzQAhBHwaZ+89Ll3fi9/rnqX3LOYE\n", + "gHceCAghz50HwAe7OEc3DzpbPbYQgtZavPfpmkHK5fV219ddkwua1gWUlCgt8M4hEITgQQR+/Vd/\n", + "mX/wD/4Rzlo8HqHicdrWLY/j47z13i/OoyQEb7HWEgQE4nwQQi5GXhGfRyAQREixtERqhZSKqqrQ\n", + "KkNqRUBircVZiyRer1Rq8eyFWI5Bd5/OOYIU3SCdG3spBIIXfJRwyzH1Hu/FYl0sxj0egF/65f+N\n", + "f//v/YcgQrobn54/+PR38PGWXPDx8AFC8AQXFmPn04oVUiCVjHM63kV87unfSmnEyn0JIWhsG387\n", + "CEK8grh+fCAE4riuzJHVv5dz0H/p83/53/4zvsr+3B14CMEKIf4p8H8ACvjFlylQtgZ9qrZGZZrh\n", + "YIPd3W1aa5nMZhweHzGZnDKdTvF1m5x2dDBaACGQaYVWEh/iQ3bOMZ9Pcd4ymZyxsblJ0S+YTqc4\n", + "59IC8TRtgwiB1rWooFBKIkWaqwHatsF7h5YSKQUBQeMafPBkWYHODEIE2tZijMFaj1KK1sbFIYsM\n", + "kQbf2hYh08MQGiHB+SY6BgEEAWmj8N7hXBPntQg4LxaOQQiBRBG8AC8Wi034wKDo4b0j+IAQ0Tl4\n", + "wCiFUSo6DecI0ifnE1Baxp8Fh/cttra0Pm4Swguc9WilEULig48bg5IordHaoHScNkEIlFYLh+Wt\n", + "wzu3GEvvHZPJmBACWZaTGRPvNQDJiTnn8DYsFrn3HoQApYBACBZCWsDEBRSIjkLKtICDx1mPF9Ev\n", + "xH0xOiLrk2MTEqWWm4d3Pjoplt9FgHUtTVsv5mnn0H33PBIQkmnjXv0jVj5bbLxCgFBIpZAKVn2U\n", + "9wHnIeARPo2hUGnBW0JQeO9QUqClwBgNBNqmRAqB1goXLN5BZjQgcM6S5QXeS7wLacOQiOBASkxR\n", + "RMfrPUIqnA908XAILu3RgiC6Tc4nh2fRWuO9xTUWhEBJickN0oO1Nm6OKl6ztXGDQ0CwadNSauHA\n", + "F5tcemAibZCrjkt6t3g+cdLHDTl4SwdrSBuQEqBV+rYAj4Ag8CoAEoLAuc6hEsFRCHgvQK48O+/T\n", + "tRCBmPcJSMXvaC2jM/Y2HRdkWndGKQIdcAhpicfNyRM3b+/jPTsh0x4WvxvnTLyu5AT4s7DRPwoE\n", + "TgjhV4Bf+WHfqat5XPzWcjI+o+j3kEqxu73BtdcuUdctk8mEtbyPEIKqqTk9PeP09Ix5VaKFx3oH\n", + "IaCSk/NIZrMKk2WMx6c45+j1ekgRyIyirmucc+R5QdbrR+fhHDaA0TohDUm/KDDGpE1hTi9PCDwI\n", + "mqYB4k5praAoCvKsRwiB2WxGAExmsNZSNw1aK6y3mJRtkAJkQk1SaBZpCCHxCLy3rIC5hSk0Xq7s\n", + "0iIiCB/cAm2p5GwCAt94vEwOz3mEAJObNEkjwgoh0PqW2gUkIIWKi1KbOH9EcpXKLJBcVddQ17Te\n", + "LZBHnudorSMaNzmZNmitKasZ6+vraK1p25bZbMZsNsdai1ImRiM6RkBtU59HxbYlBIcUAR883gV+\n", + "4b/8hT+fCfpjbM+A/+J//6VXeg3/4n/4xRSdWpyz4GOEJWyMlDrk2UU9QkTnLaWjbi1KyMV8kSqh\n", + "WA9KRue1iGz9HFKk0M0/2S2XFC0sEavH2jbNn2VUE92gJBCjAohOWIr0My+QLCMo5/3i+l0AHdQy\n", + "evIBH0RyvBF8pZPHtYBcuF2hRIIZpIi3u8+IwoOIhwhBIFNkGUJAipA+D+fXw1fYj8SB/1lM93Ia\n", + "a1lfH1GMBiitaBuLrRqaxtHUFVQ1k/mMPC9QWnPt8i6vX72EdZ7JdMqsLHHeUVUVVd1QNg2Xd7Zw\n", + "Pjq0LOtTJPRunWWYG5x3GG1QJku/V+GcjQPowAFN6ROVk9Pr5chMkuUZWZZHp9c4yrKibW0KpQKj\n", + "wYjNzY2I3rWhbWpOz87IMkPd1IuJGkIMe633eNviXEAKyes3Xqf1Pu7YLFGKVgofAs47hAWl0wwO\n", + "oBBUto3ICI8yktour0kIFVGq0ggBTdOgjKZtWkLaSKy1GK2QSsewLwRa4SA4pNAE0oR1DoFa7jeB\n", + "SF0l5Gxtm6KXSBPFjcKh1HyJrIKg6BUrC8KBjTSFDzYtujTpvefNmzdpmuocPfGX3f7mq74AQMno\n", + "8JSMFKHzHqN0ijSTC4uPG6klUkZKynqfogjwwVPXFcCCnnLSoYVESBmdqs6Wjkyo+GcFtYcQ0vwM\n", + "vPPu+ykKCckBR3BBECnS8RH9AkLKBcjtwJ8UiZp0ljZFbUopBCICjY6Gcy5FSkv6LEY+LkYz6d8y\n", + "RQIxoI4UkweUjr/nkAu0DhCCXGx6HY1FOtYPs1fmwO8+eYgxhpPZGIB+3qPf64MPOOHJkCAVyqgY\n", + "JfmW4BQBhZaCXq7Z2NiL4ZdQWGcjfxWgLEtms1l00GVJOS2pm4Z+r4cMgf6gh84yqvkMGRLP2RFk\n", + "BEajIVJKZrN5QoAwm03ITBZRaBUdVV235HkPYzLmTJjPSwICY7IYpjpHVuRY51FEuqGuLVJpWucZ\n", + "9EcMh+uE4Ni+dCnxiYLx+BSIznRWlQQfEmKJHJ11bdwk2pambcnynKapKWQvLhoJMgict5Tzkl5R\n", + "4EPc+b216DzDOsfpeMysnLE2GrCxvo4UkrppUSncU8QQXCgVJ7+1BBc3N5FQSAz7wsIp13WNx2Nb\n", + "S57rBbVDiNxlR2fpLC14Ik3V8c5KxU3H4bn9wXvIjn+WF04c/mI48IhEPRABh5cStIDkhCBGipo4\n", + "X4WInLD0AhXAW7fIXyilovNzDu/Adw41oe2lvw7I4BM6j+hbIOKaF4Fbt95NGwiL/IpITrKLJhf5\n", + "C+/xwa1QHNG5dseSMjpka1tynS/uqXPeEZDErWKZe2GxmXjv0qYkI33SUYDOEnzKl4kU1bPMpUGk\n", + "omL+SCQ68i8oApfG0PrA6dExg16fZ0+fg/fsbu+ghSZYS24ysl5M3OV5Rt02aGEwKiLpumkSF6px\n", + "wVMUOd47NtbX2FgbYVsLnRMSgiLPOTk5QQhBf7TB1voGdV1zfHJCXVUYkyGEIMszCCB8YDqZoguD\n", + "lpFzdrbFNXWkU+ZzbF1T5AVmbZ35ZIwXku2dXYKX7O8/5emzxxR5zuUrV+gVfUIIjIYj1tZGnI5n\n", + "3L1/D6UUg37ksgf9PqPRGk1T470jM4a6rhkMB5hM0+/1OXh+gA8OqSRa6JjA7fXiZFQK6x1VWaGU\n", + "pugXWOcTWgEhNePJjFlV0rQts1lF0zQ0rWPQLwjWoZRGSYkQKiEViVAabz1aRppHa423lrrxiRtN\n", + "jl0lTldB6yJ/HZ2vSIliFk65C0uVUmgdHbp3LgbHCWFZbxF+icwv7NWbtTY6pOAJBLxWyyTgIgeQ\n", + "OPSUpAfouANtYlIdAt75yI8jIyWTcoZCCJQx5yiSjj4BFs64c/AS152AmC4UCOEjmkEsnTkCZWRK\n", + "YAZEl7/pqBspSdkXrIsgjOSYSVy3EJKQonyR7k8qlegVv7j3LkHd3Y9WEjSLyEB0mLGb2gmpd5Go\n", + "FyJtlF9tr8yB3/n0c/Jej6ZpGI2GaGWYTuZIeUaRF2xvbiKV5tHh04jahCArMtbX19IRBFpnSBHp\n", + "iPm8ZntjyHQ2WyStgvdoo1MWP0TOTQiKLKOta0aDAUWWYZuGwd4eW1tbACglGY/HKWwKTMsZ09mM\n", + "qirJ85zRa1fRxiwSNQfPD5nN5wyKDKE0bTkjzzNu3Xx9wf3Ox2dMz06Yz0tOTMbW1hbWw/7jxwxH\n", + "QzZH1wkSgmupbYvRmsZGNczW2oizyRl1LZicneBsVOM0TYsPgf2DI3wI2BAYra8z7PfIMo1Sirpp\n", + "6BW9pKJRTOclx6cT9g8PUEazNlojhApCSBGQpy6rqMRJ0YQLFhV8jCoSxClETnAp6UjkAH1QOJ94\n", + "qKRSiQnYGBL7NEEDHuscznmkkBidRYVISlB7F86ncMQy0XZhr94GvV6izSwueKyKfHAIAZwn+KiY\n", + "6SKs1YcptMRbnxy7jPMhJbWVMEvKhCUP3CmOrGVBx6wifSEEjXMxlkt5IiEjUBBeEJIT7Rws51Qo\n", + "AeETyAhRESWkQClD0dOEZpWu8bjEU3cRo/OOxrY45zB6kBKeccPxyclDjCw7QYO1FqlkJEpS5L/K\n", + "dbu0iwkRE6M/zF6ZA1dIhr0hNot88sbmkCaMmdYNJ9M5z45P2Nvb43RWRbmglsiy4qysmM/nKKlx\n", + "1rG+sYmzgbZtOT05xvmYuOz1eigZB81kBm8tZdkktNgSZnOkEFRVxXgyoZxOOTk8ZDgc0u/3kUbT\n", + "NA1FUXBpd49ePkZKSVEU2LYlyzKKNJHX+gNm83mkTLKMyXhMWZYcHT1nOFxjb2M9OizvyHZ3qKsm\n", + "KlQQ7O1sopTi9PAAIQW2qdnd3WFjY8jh4RRnG8bHE0yec3B0xO7OLoU2eOcxUnBwcExdNxhjaOuG\n", + "mZxipEDkktYJyrKmamqcg42tLYTSFMMBGz7QtBbrPMMsY20wJFMG6xvyzJDpmPgZDUdM5/EZ4D1o\n", + "hRJqkWdwbZuouigbtM4ilMB6T5ZlWGepk6rDGIOzAmddlG/KSH2Fao6UGiGXUrK4AFNomSRYL7N/\n", + "8d//82UI2m0AISSEt0rJhhh0p7jcJwTp02KRSpEVvXPyRFg6kbZtF6oZ5xxKx/nh031mWbbgSVfl\n", + "jR34iNLBSA91XKpPCgedEOzv/M7v8K1v/VFSP3mapo5jaNskmYsJuH6/x/b2Nof7R8zGc9Y3RmSZ\n", + "xnqL1pK832M4HJHlfYaDNabTOe+8c5srl66ijMFah4dF5CSkQBH5ZUlUMTXeEQL81//sn3xpzDsa\n", + "zBiDCh4pAlLFhFznUaIzDyn536HclPeITyY5uiQ7XURYMVoL3oMUeCEj39wl+ZRIScMkySSOXZAd\n", + "6g34kCga1dEbguAjgAgehPILLl2k6FyHqBQSnZQwIe6QEHc8bTpHcDgXqQ5tNJmMsuLWrsgKA4BE\n", + "6xXaJslSo2LLAmIxNyJqX+HYfUhc/V9QBP7h+x9ydHLM2XTK+vomSMWVa9fZ3Nzk4OiQd999l63N\n", + "LT6/d5/T0xOUkjRNlWiVYRqowLxu+cFHH3P50mV2N0bx4FVL3bj00CMi6Phr7+KCM0TZU57n5CZb\n", + "IPWqLGOyL0nwpmdjgoiJmm5RGmMYjUaUZbngu/LMoFRBP89RwdHPDWfHh/RzTV5kDAYDtDYAHB0d\n", + "Y4whHw7J+gMGgz4ff/QDTk9P2d7d4uzkGN+U9Hs97t5/zPP9fbwU2BDItaEpK8qyRkrNdFZy/cYN\n", + "RuubTGdzGmvp93rkhaCcl0CgrmusA9t6xpMpk1lJVddIYzBZhhaWclZiqwatIiudZ1mkcYo+rqmR\n", + "QjEaDKiDo5dHXjA4TytlUpV0gWdE0m3bJL1w1N12FIuUEhc8MkR1gfOO1raMRsU5tKVYOtAOxL3M\n", + "PEknvZBjppA7LWgVzqM1GSLvajIdw+OoPVs4yMhj+kjlyCWHmZssOrqiwDuP0Iper7eShAoLx7bq\n", + "/LXWeNdirQfaBTXUXaf3ntms5ezsjO98509iwt1GgNA2c5p6htZRgiqlxLeeMK+AU2zr2NnZIcs1\n", + "1jasrQ3IcsPJ2Rnee3r96AzqynLn00/QUnPlyhWUjKojERxKkGiEtF6EpKs/+KrcsXPd2iLSCmqp\n", + "mJBBghBoIQmSKC1MSTkfwGu/3HCJ3PDqeIkIvUHJ+KejL7oEaYjP2Cu1QPhCgBQFS9mjO3e9wQuC\n", + "AhHi30r7qKNPDpU0R6Ni1tPaWPegM4N0umNhFjpupQza6LQJB5yz8f5cVG8ptZTWQqRdOlpJpJ+v\n", + "5guilNDSSQm7Db0b6x9mr8yB52uGa+uvMRiPuX37fWZljZCas8mETz+9w/HxGbu7V3htVHBj63WE\n", + "kpRlGUOQEDg9GdO2nt6lEU8fPCUXOW+9dQ3nXJQLtu3CsTjnKMuSpo0EwLycIZVBSsW8dAunEXWe\n", + "esHndUU+qlNVJL2ysC3j8oSqrGjaltwUaGMSdmjRIvKEm9uXMVqjhEF6RTWes762xs5oA3ygVwzY\n", + "3NpBKcHh/Ud88N5t9nZ3+dbBH3B9uE05n5NNW/6nf/mL/Of/2X+KkwF7fBg3FRfY3d5lfPiMWimG\n", + "TctWXvDg0RNGW2uY3FNPauqTMU4anMkpdq6yXowoJxWzgxN2Nrc4fnbAdKjRGz0aHNQtb127gZUZ\n", + "R1j2fcVJecLlfp9NAkJntLMZfa1Y21gj7KxRe4u0UM8atNlkLuD7D5+wtTlgOByQ9TOkc9hgKfKC\n", + "fq9AS4UXEldF/fhMSlS9j6DByhE63yMPlrp8DIVgrrKXzqOzcozOM1SWx+KaRLeYEGVcFYbgohxR\n", + "p8KMuPmQCjEkVduglaGVc+Y256CcMWmeo71jgx7X1nK2eoKq1JjBLmM3w9t+oltj0ZXSIGTAtk3k\n", + "/YVGCo2UmqyfETXWUVWkRRSYTafTJEuF3/jNX+fk7BhhMryQ1LMKJbLoNFx0HlJFeaYIgWpc0gbL\n", + "tJ6T5wbfVPSnBWvDPpmSzM9OOTs+wfR6HB6f8uYbb/Hk6X0uX96Nkj5hoqZfKRAktVMbkSWK3C2L\n", + "yF40pR1Rn58KVNpOvx1ARSmq8zHqEnKZmFQibrR+Qb3FQi/n3KK4RkqJSnJeb9t0RkG3mwgRC5xk\n", + "UBCWunEd2vS1KGrwgmWkk5LsHQoILkqPg1oWy3WFVK0jbRxRcCV0qpWwywSmQ56LsjoAEUSz4MOB\n", + "JfUTQ4V4buJGpdItLcFFvLyoZlnWH4g/pdvJK3PgIQTKek7bNjjnePTwAddfv5miYM/dzz/nyuVL\n", + "QCArctq2ZTgcRpQlwFrPb/7G/8X2zi5v3LzBX/vpv4Znshi04GKY3raRn2rbNhZvpIfqfJcACYvv\n", + "dCiqU1TYVJxDXaG1QiuNbT3Wxp9rndHPDMbE0FglIb+1LUFCVZaIfh8tDCfjUwgBe5qKinzgtJpz\n", + "/+ljtjY32XvtCvcfP2KwNsARuHP/Ljevv05lG/6rX/invPHmm3z6xWfcuXOXrc0Ntre2OTw+ovWe\n", + "h08fUQyHTGcl9x/c5+xswNpAcXx8Sp71yfojHJ7gG8pywsnxISZTVE3FpUuX2NldR2WSh48ecvPm\n", + "Lc5OxvgskAvB7PkYdzxm1q/ZuzagtS1SQFO33H/wEDkoQGmE9eigcG7KSV3j24b21OMciKKHlnEO\n", + "69CijUarVC3YOgwCqpqhyXCtY94KoiTB0reKsirp914+VdfyXkRBdYNUMe+hgkATkD7gjcTLSGOA\n", + "S4hRxQQXAScceWEQQvL8aJ/D00CJwCpHY2sMniprGF3aZhgGHE2iJFSmCj4XHPiAt+BSdW8IAbyL\n", + "cjbvcGXUBUsgWIeFRSFOlg34/d/8PR49esRwNEzzx+Fcu0i+x5A+RqBtE+L9SYnKNLnJMFLRW9sk\n", + "uAYlVdRZS03b1jRlTT8veP50n3424ODwkM3NHYoiYz6fL5C29x6pQix2QhK8RuuX869aL59FzC+t\n", + "RhUxYuqS0qsUQIysRKwziJ8QEEgVKYwFTRZlG+BWabMU6eCjPnHl/IsjifOfd8hehoATKYkOiXfv\n", + "zras7IS4kaku8Zn4N8cKnUfnmBO9lqSJkkgbIsK5y15F2SGwGCPxgl9eOnKJUmLhl/40Ce2r04Fr\n", + "jfeBTz/5lHv37mFt5Py++c1v45yjKPr88Tf/iL/x03+Foig4OztjfWMt8Yoe71uePH3Iw4cP+Kmf\n", + "+mmePnvE3XsfcevWLW7cuEFTVTEMbdtFSJO2vxiWiGUW23u3CIdsSkh4l7LsIeCaesFPNU2D0/Fh\n", + "WGvRSkBo8FYggkIXGW0QIBSOgM4zRKY5PT5kPpvT6/Xo9/vkJmPeVBwcHXJ0doIAdq/scTQ549nx\n", + "IVJIBqdHHE/HaCG59+ghJ+MzFILpbE7bWuazko2NTUyW88ff+Q7v3v4apiiYzGfUTcv7793GOc/O\n", + "3hWOz8Zg59y98xEqK3j79m0ePnhEVc3wZYE9KVlvYD0Ydl6/yayx5KYg1C31aAsXLOW0xEvHfDKn\n", + "n/XJih4y7+GVomlLCqHRGnLXsjnsoWqLth5pU9sCEZKcymFlmyagQCrNqMgplEMNBpzUBUFvEWYT\n", + "2pmimlaMtkYvnUdhXpMZg8VFXXEImCwnF5rgPVa0CBELpK2z1M6TZSYhv0BVRxlmXbccHj0hqB28\n", + "Lahrj5EalUlcmCNUH6MKmsOKbG2IDAK0wLuQ5o8leIeWMWkWK4RjZWPwEucDtkMNsEB9VVXx/e99\n", + "j15RUM1Lsizxyol+cN5hnSUr8nTHIlX6euqqZmdvl2o2Yzyfs7E2xLWO3cs77GrDoyfPcD7w4PFT\n", + "fvbf/nd49/bX6Q+GqaBtqYs2iQ4QPiYKbWsRwrxktKNVVbVw/Eu6RSTkvESfy++sOCHnU4VoPLdS\n", + "UX8NpLzFkjLJ9ZejLvclaV38by+WNMyCRksLXABGSISOGvPue6uJw+BlovnOO0yJwKWS/oUWPD2H\n", + "7j6740mZLWscVq5jWQcRFlXaQi3bcKyaD+LctXXH+Cp7ZQ6863fycz/3N7HWMZvPqMqav/Lh15iX\n", + "c0CgVAxvH915zJMnT3jvvfdo25Yv7tzhD//wj/j6++/y8cef8t47b3Hz5jWq5pjZfMK9+1/Qy3L2\n", + "9vYwpkMRUZkSd9IsDhQd97kMbWRSnoTkvBECHVp8Sl5BzOV134mI3C4eWOUdbu5wDvJBjswUTjj6\n", + "60PyYY979+5yJb+CKjRVWzPaXKeal4TgOZuNMVKh8oy93V3Qmv76CKUUa6M1nh8dMlpfp5cXjCdj\n", + "tnZ3aVuLtxaVZ+xeuUTQirt3P2Nja4fPvvicwhgePXqIA9752tfZXOvx5rvv84ff/DaZ6UcHv7nO\n", + "2f4Br1+6jBEaF2C0sUk7rVFeMOhvMK7HPD854ObNy5i1LZwNeG2YBoe1AaVzJALpPdujEf1BjlY5\n", + "goB3Fmdr2oRQREqQKSmRRiNE4NnsiFy1VB7GYRMz8PjWRUnpYJNsZ++l86joGVI1NJnWSCHo5QW5\n", + "0gTrmFSTyDtqtQBu1jXMqxlCKqwLCC2oXcWsPMP5jJAZYgweUD3F6fiYzZ03ODoqKQY9pmVJL1NI\n", + "IXBJ76+1QatY7YuIfTRU0q+HxKMLrSP69J6mboDYm2Y6HYMQ+GCRQaCANlha5whCkBUGKUlONzpe\n", + "JwR53uPu3fu8/eZNgitQSjKbzchMwfbODltbe9y994BBf42333qXn/iJn0RJzXe/+12GQ4OUsYLS\n", + "OrC2WaLxlCf6KvPWLtbOkraAtl3sTwuKIeZGujL1QNHp/ZNOOrILSz48/XI8zkv6N8Vq+aXji0g6\n", + "Jiy7dd6h447iCF1UHjzCxRYCoTsHUf8tCCgpojpm5RghxCS97IqXVGrJEJb69uDj2rd0uZeYMI1P\n", + "cjke5xQ1K45/1YkLqRdOu5Pa/jB7dSoUrfHOMRwMcM7R7xXkeY5rXdR81zVKa1rvuHr1KltbWwyH\n", + "Q3ywFNl7vPXWG2xsbPL+7ds4WzE+O2Jvb4/9/X3m8znDXp+qqhLVEW9TJnmhEF11YvdQVKJuOq00\n", + "KKmXIn2XUE/y9D4lO2JSNGlZE8r3siuJj4tNSon1kYO31pLlMaHpgc2dbcZnZ9jhgE8//ZQiz2lD\n", + "w6XXLuFay6wu2bm0x+NHjymrijfefAul4nTPewUB2NrdpWpbTudzPrv7BTt7e/RGI3YuX0UKxddv\n", + "v8vZyQnPjw54/vQhxwcH7F25Qts0tE3AhcAXTx8hyzlrTYmqZoy213h+esz0ZMrl0SZaSz782jfg\n", + "Y8NaL5CLjLYRhKJHU5Zk2mBcoHAOX5WgQGeGoPIYxViB0xCCo2lqgoghaOMtobVxs8x7VN7hB2vc\n", + "eTalmR9SeEvRNgx7BcG9nAu0KpY+ewFIhZdgdSAIh8dhjFoUZbRtG1GW1pg8i/rzEBdlJjQ3b9yi\n", + "ths82p8QvMMUhrPJmM0Cpk3LR5/dIe+9jsiLhORCLJpKTU5ig7BODeFoXUMgoGREs0apWBQVYisw\n", + "pTS7uzuyo8crAAAgAElEQVT87M/+De7c+ZymqanGY6RMtQjexerAhPAjcPALNU0zmzEYDnm2/zwm\n", + "MQc91tfWuHrtGscnpxyfnHH92ut8cucOt29/wKXLrzGdTNjY2EhghYWUrWtApZRC6ajeqqv6pWOO\n", + "8AsJHimRuXDoyRkrmdQhzp9zXLOqjHUGWkeViXMgup4/sWpTahXX6ZcceFjozBErraHCl5N9AnBd\n", + "P5YUeccNR5xrRNb9HV8kFvMnofsdEcGHkjIm3b1LDlzERHbnoGXsHSPFisLJ+3PovDukThuY8B7P\n", + "ebQdUmS1SPCG87TQy+yVOXCTZXGStw1CQJEbBLE3B0GiJQTfYvI8FpBohfOWTCmGwyGbm5vYpuWd\n", + "d95iPp9jjAEzYmNjI950QitZltE0CV2ElRArLMMbt5Kw6egW75ca09isRi4Qh9KSTEmsDWgjFlxl\n", + "CAGbuPdoAusdxitG/T6tc2ysr6O0SqhNR822ybh5/Tp5nnN8dETbxIZXbdPSNA11VZNlObfefIv9\n", + "/X0+v/MZV69do6oqTK9AGM3mziaXr73GpctX6PV7TI6PQGX8m9/9fX7y6++zNlyjcrEAYzqesLW5\n", + "yXTWIJRkZ2+X7z75Nq/dusHW61f43kefMJnXvPPubeoA+8+fMLFTnj19RHZlyLwVZPmI1nkOjo64\n", + "fPU6g6Kg7xwYhcxi2OmauDF6ZXCuiWXKSExmQHYZ/yivPLOeor/O2GU4J6iDwDUO1wJCUD2fvnQe\n", + "lW1FY1tkZpITl9TeRVlca8G5hLTiIlU6i3MlfoKSAtu2qTHTJpOZw7sWIWp8cOQmw8sBT56XzBqJ\n", + "0y3GwNHJDIFEG0NmCqyrmc3nqXVDTGTppMwR3uOtX3DbSkUZpvWOum34xje+QVEUPHnyBL+5jfeO\n", + "2jscscVAlG8kpBeg9Z7GOfIs59qVK4yGfba3t8BZxmenfPfjjxlPpmysb/L8+Ii333mPrCioa0uv\n", + "P0jAIqJKRNRPF5nBdsUpUhBw6Ozlm2bHLRNCqhZ0aQ0sUXDk1bsiGFJiV4CRtM7GjptK4v1yI4ib\n", + "AAgVnb9K7iny2/G/VOKoFwx2OqURL+jDE98c13pY5EGFYFEB2c2L+H+XPhNprkR/oUXsX0RSJvmQ\n", + "Igff9eNc+gmVNlaR1DNpkFIydakLDyE68i7qX+reI82n5FKO+qfZK3PgPrjUWXQpl1FKoLWgaerF\n", + "g2pSJlrpOGht2tXauiHgmM2nUVsbWly7bAsp09+dEiUWlCx3Nr6isu8cL5YG1yLAdZ3a6Gi32LNB\n", + "LDupxXqv+F0pZayQ1FF+5kPAGEVIDaU8Ub412N1baKqFEAx7/QVPX1c1UkquXL5MAIbDEcO1ERtb\n", + "G4xGIx48fIjWGus9W0IwnpyhMgNESuPk9Akm63H33kO2tre58cZb7F67yXc+/gyC5Cc+/DqZyTk8\n", + "3ifvFxzNxjx4+IC+lDgP+48fUfmWYBsefv4Rm0XOd55+yiAb8td/5t/le3fu0grBwfN9Lt16h2ef\n", + "fcbRs0dcunqJeTNng3W2t7co8oKsP6AsZ/Q2thitjZA6ltOfHJ8ynk7ZdZpiMOS3/+QT7JmAXGFw\n", + "vHPtBlvbe3xy/+GXHxaQpZUZrCckRCdlTls7XOtQSPqDPhsbG6l5UpxXDx7cZz6bQwgURcH45Iz9\n", + "45raarwrMXnDbHbGzqW3cGXg6X6FKXZiQljOKHp9pIwtBuZtTfAOoaBs5jRNg8nMIok+yDKCc5gs\n", + "Q0pNWVXUbYNzniLvRRlqnscNWRk8JJle7EfTlZF7HykVlMYCo/U1JtMx4+kZeS+jV+Q83n8ae91I\n", + "wWB9jf1nB/zD/+g/ZlbVqMmUzY21CDKI3LDEpcZKDimXKBVsSmh+2VxbEylORVggxhiNLOlHsUja\n", + "dXy7FAKpRezroyQKEztCduqQAF4KCA48uCTci1LOqCLxbZ1o0LgWpRA479HCrHDKIRaPSZk206WC\n", + "JXZmXKUz0loWJGoGFjw8JAosOnmRJLAiBJROrSW7XSdAcA5EbC+w4iaA2JJLSIlWkXprIOnS/VIr\n", + "H0c1nj/RNP5PceKvzIEvvWH6V3A433XpWyYMpOh29vM9lyHE/thLhdG50GP1vjsqo+O3hBCL0tnu\n", + "97r/XqALlg5cKXPuYZxz8mnCL4Ik78Cn1qcr31epiY8QYlFeHDn5yLMrGaVTXVRmrWI4GEY54uZm\n", + "TPRIyc7uDm/zNt473nr7LcqyQiZK4Ps/+Ji816epGh7Xj7j9wfvMTk9iEbFWND6wvrnB9vYWs7Jm\n", + "fHJEYTK28gJfNQzzjCwElHVsbG5QSUGjFW/ceIePfn/CdP85Nq+ZHY15cPdzjJQE23J6+JxHmeaj\n", + "7/4xG4OCjz4+4tH+I/7WX/33GPo2th9VPWrb4kvPrCoZDodsbG/RH62RDwb01YjD41M+/87HNOtX\n", + "MZsZWWjZGwx5/bUbfPtPPnvpLPrwrXfYP3jOtGmY1TW66HN4dEq/GKCF4Xg6Ybixw87eNSaTCUII\n", + "Xr/xOru7lzk7OeLOZ58xPjlGCcHl3R1msxZdDAh6TL/3Gn2zi/TblOUpShoyM8Cplmoe56bSkqAC\n", + "rasxucYohWwiH25UhjES6QFU7HWTK+o2Fl4pHamwyWTCr/3GrwMwPZujsgznY2SaSYlsLet5j6as\n", + "yIZD5iJg1kbs7z9lrdcnBM+9L75ga2czOjkBvUE/VkkGywdf+4DnByfUVnB8fEwIsd1rwDIajXDO\n", + "UrctKjU0szaCKx/al465SAlWUtK2dU0M9zGpI6ZO8l2Pd6CXLQQJWiJcp71PG5Xoeot0Fbix6Mf6\n", + "WOyS5xm2cRFBJ4faUTZeRKo8UkxLOXDnABaR88JRn/cjMq27iICXvb+7X1mAtOSPFpHQgldPLYFT\n", + "ncMi0lhZ+6vJSiFigZwSEhFiS+PYFjuC2NyoBaj1K4nQr7JX5sAXzlaQerAvG8Ikr50QbZcBJuLb\n", + "lWxzLJvtnKlfhFmrm0M3eCF0qYpo4YWfdxZecOzxM784rxQihngsd9jV70vBgrvrGMF4RWFxrI46\n", + "dGnnXY5JbMAjU99qH2Jv4rKtKYpiEWKFELu69XWP4WhIVVcEoXj33bc5ODhkd2uTQksypTl4WsTE\n", + "3qBHf2ONwWjEz+zuIELcNJpZxeeffM6l9Q3eu3GTDInuj8iyHqflHNUzuLMT2ukZvVwxvHKF+qzk\n", + "4NlTtl+7zs5wiBUSb2uuXb3MoFdweHbET735M7RGc9jOyYVmUjYEPIUUtE3DZOY4shVN06KMYavn\n", + "qYPHisCsOmM95BSZ4M7H3+b4bErd8Zkv2FZ/xN67u8zblqPplO99cgfXgMgzil6fvlDorM9kVlE1\n", + "kc8cn014/PAe77z5BpPNI9xsSr/I8AZCWTPqD9HFCCEM5WzG8fER9+59hrOaYjAi67XUTaygG40K\n", + "1jf6zOanEBoybRgMhmysbzHoDzg7qynnNf3+IPaa7vq+CIHSmoePH/Frv/prkRppGoZrI1rbooIB\n", + "Z1Ftw4bJuX3tdfIs47OH9xlPx9S+InhBdXyCyTTTU8nRwTOUVgwGQ5xreXD/PkXe4/jwKNY9eCjr\n", + "hsY2sUVyazk5fR6LaUyO8gapNL1ejs7UVzoPncrOIVGOwiwSrBG2RDVXpA+69rDpfR9WLjTVXbVs\n", + "lz+K3HZEntEh6kRpplZTISBCTBJ2rWONMXR97mMUkNrIChYqm5D+F3NfAtd22B6Esx38Xq7lFFVD\n", + "lCt3/Hxc5ilxK0W6fhkbdPlYZbr03V0PpsAqsIy0UvyZ87HzoDYGmX4W2YJUUOVZjNFX2avjwFfU\n", + "ITFwSLxP+iSkhJBIbUY7iqJzpH4xMN3D7RoepaonVjjslFDpjhtP+3KNa4fWz6F9HwAXNwsRJ2/H\n", + "X0GcOotdXJDCQnHOsasXduXu87CySHwIy4SY9zgcVRsVLvV0itIqopngkU4steapt3GR56yNhhwe\n", + "HrK3t8Vbb77J8eExTdPG5lXOIozi+pVLkRJyDiU1vbU1RptDfuKD92nahvXNTU7OxlxFcHp0yJOH\n", + "d8l6mp/88CcJWvHozj2asub61T2O65qty5d4eO8+WRZfkLGxs8XutdeYTZvoeAOcjmcIApnJCN6T\n", + "W0ebXraR5znjecnx4SkuD9z+2puYfs7R5x/x5rWbnB49x9mXh5JP9vdZ29yAPOdPvv8D7j55Tq+/\n", + "ztyOmU73eXLwiDfffCNKN3VsSlZNJ+xtbdDWJbdu3sC4ig9uv8f/+sv/Mz29xU5vC5FJ7t97ytbm\n", + "dU5tRT0/Rul15qeSRw+e4aRib28TYxycTTk720crT12V2NbzjQ//LX7+7/wdjCrYf3bM84NDqqpi\n", + "WlZMZnMyk1HWNb/zu/83Z9MphFioU9bziOylQPiGvdGIr1+/gRvP2B72Gb79FvLhF9w7PWLYG+Fq\n", + "R6E1vX6BdZadrW3uP3jI1vYuTdWSScPnn33CzbffxyEwmcZ7F7tYajBoEJAXBfPaUtclLjj8vD0X\n", + "jZ6zDhAl1NzJAFcrI0MI57TgnT7eB4mMgXPS40uqql42bRKpdwigRUDiadsW3a3/RI0YIxcJ3bCQ\n", + "JXYVoURAmHqPrL6dSEuN8y1dZU3nI0LwSW+/ROsx+lbn1mv379gLXy0cuRAC4bqWyMuGVKzo0Vff\n", + "yhTpqdT4KxV5idBVh35ZXvhV9uq6Ea5MDiGSg/XpEQm52Lk78iJmieXC8abbB2IGeDV7K6VErtz/\n", + "atjU8V/xWOeR9up3V5G7EultGR2Nk2ibEJbfwccIwAuZmueEc865u99uI5Hdq8XkUs6IjzxujBQE\n", + "DsiKfOX6Qkym+Fh62zQWrVTqy6AAz9bWJsNBj9xIjo4P0NpQ6ALVy2i8i53YVCA4i1IBhGP3xlWu\n", + "v3YJ0bQEDXMVWLu2i5tV7G2tcXl7xI03r1DZmksbu4jasbm2zvreLnu5QWQZO2tryNYzr0qOZxN6\n", + "m2tc2srjZCUmZL1tEaHbdBTT6YSgDArNzLcM14d88MF7tJmkrk55bXvAds+wPthlQvXSefTk6IDj\n", + "piSYDDHoQ55z0tTMZhNm0zkKwfODQ2bTCaPhkPlkyu76iL/+U9/gyvabHDx9zLf+8A842n/C7OwR\n", + "P/PTX+f0tObJo8c8uveYja/vgZ0jqehlG7S1JtRAHuj1CvCWuqwY9DSvvbbN7vYWRwcnBFdx+Owx\n", + "g/46W1vbrK2ts3flCk/3n/P9H/yAz764y6effsazZ89ikt2LBZrUStDLFNs761wdriHahus72+w/\n", + "22fz2mVy4RnkCuEchdKs9fpkRazazKRiczRicnpCrzeknM/417/8r/gnv/A2rRO01ZyiyGirKVVb\n", + "Q4i9g6xtIUlnm6biPIN73jrZbORtBTqPc9Rau6ipiJFsdFrWWYyJb3jCpQAbQXAO51uUFGQyj1Gp\n", + "s8nBKbSWsa2FEOktVulVZYsXKZAURpast+xFY60lyKUj7d6wg4hFUfEVgKmfCrGMvqM0RUfn+Bix\n", + "+0TnLDTdziY0nl6d6Fg4bZVecPJiVN/l4GAJ3rrEaIw2liAwfscvKZwVmvll9uoqMe0KCsVFgn/h\n", + "5EDrDgXnEU2voOJVmmMpw1ki6iizOo94l+MZHXDXnvRFmc6ybWkXkpHeJ5mmdHLALnTtJ88je7n6\n", + "AMXyc5Wa0XdNedxKBrt7RlIo8OnhdlSR+zJ10FFOWmdxJ3fLlq7ethR5HsdQ6AVakEAuBMEG6km5\n", + "GCcpHaI9Y97p3ps41r5pY5N7JRns7TG6fBkIaKXZvf4mTV0vxgMBDBKH1wzYZCc2+krIp0NAq7Kz\n", + "LqIKSQVgvUNKza3XZ8zrGu+gnFdMZ1N6esbbbvzSeXQ6ndL3HgFsZRnDq7vMyjnrt64gtUZUmiAF\n", + "j588xkvBsZG8du0aAPPa8+DJETOb8/mDUxq7gVNDWjHm6LTBhpxnz59zcloBmwSZM7MTGgJCl1hf\n", + "IssAdcPkbMJuu8PRwwmnp3NcKDm9Pqd3dZvJLPD5/Sf87MY7bO1twb1DwvCQO/v3cb1AW7X01RDV\n", + "FjgjsKFkIBSvD3pczhWybjmZHpHtrtEOc4Z727jPjyj6fbQ3XN7c4LWNNQgtR+MTNl/b4rtf3OOs\n", + "HBNkTnNwyLd/8Mf85F/9kIP9J8xnh+S5xnpwOqNRUE3OGPUKMgO1rWi1gJdT4JxwRiYNoo09vp2K\n", + "Kq+6buj3BrR1g3eBqipRSpH3eoQQ3xnptEc6iUajpEovFgl4Uac+4SCcBOtoElevtY5No3KDVAYb\n", + "YpVi01iUVvRHA5pmjAoRDGQii31YlKPyc7wEFTR15dFk2NBELj14Ek+BlqnRFQKZErAqCIzOQCqc\n", + "j+/NRaQKYtcifIr808bS9ERKdsbXtzkbKRXfRCQvlYxpshAorIgOXASkl8TujfGNPbFFQESJS0Xb\n", + "y+2VOfDudVywdMiLHVOslMF2jnslTHsx+bj6ey9+p/veqr2sAupFO/c7YrkPrpbnnk+GnA83X3bO\n", + "l5070j3nv7usYhMru/KXNaHLkPX8n3iM5QbZ9Xd5EQWsnu+FAy90tS41mF81rfWicVP31pLu8+56\n", + "M2NwUn7pXN1xX9yAjffxNWvasBFSPwsfqJuWLM8Wb2950W7durXoT93RVq2zVFXFrJzTTj3XXr/O\n", + "5vZtfAgcHB+ysbmJkor7D77g9OyYjc0Rg/4AFzTPDg6o5g3G5FFpIGKFsDEmvndRRFy2ZkbIWjIY\n", + "9jg5LQHDvQePqcsZ/bxPb9Dj6OAJ2ztrfHLvAb/0q7+F2VznvQ8+5Pn+Kd/8/T9helQzP5iy1R/R\n", + "jkuKbFnEMez12BqtkQMSyfPDp5SnY66MhnhrWR+OmM0r+v2cXq7RCowwrPf7HM6mfO32u3z+eJ/D\n", + "sxnV/JTf+zf/J0eHj7m0sx0dos6wTYUU8Rn3exmEQN3YWLEY/EK19aKpEFUV1jmUzvA+vh9WKUHT\n", + "VgQ8Usc+/iHE8ZOpSMbZNhYOOYUUCilBOAiptYFIL2yRCJDxrU9CRiRuXRv70jsX32sp4ztby6rF\n", + "2opMxBeZRGoyYEOLw0YgJQRFlpOpHGfb9NaexHUr0N18dLFFAsQo3/rlO3ch5uE6cLaa4AwhvifX\n", + "+6UcMb6HVcd2Cy52I+zWdPdCdiliS9qOQRCie9l0pF/+wiYxu+KaTs7TOYPu310YtpAArlAQLzqz\n", + "1cqllylKVh1i97MXz79Ayp3Q/ksIf2kvbhQ/7FrOtRVdpVHEea3ni5nr1e8t6ZwvX0f32WpWfLWR\n", + "/OoxV0t7VzeUJVd5/ryrY/Pi9a32i3nZWHQdHV8csxc3m8WGk8LqRes3YpFU18GwyIe8zLZ3tuK7\n", + "OLWhaVta20a5l4/ISrZR5VA1dey82IPxeMK8bVEI1tZ7BF8xn51x+eo2bes4HZ9xcnbM4eFzqmqG\n", + "yTRGBhSevZ0Ntrc24iL3gXZmqWYN9XzOoJdjPfTXBxTDgv3Jc57+wTO+OJgyqU7oD/t881t/zG//\n", + "1v+DYZ1bN79OqDyTo+esDXuUszO0MmRGs9kfUJiMUNe0rWMwWqMwGf28YGu4zng8RfUEl7ZHrA0K\n", + "FAEtoJ9lrPmCk5MT3rp6hQ+/tsXaxg5ZnrO+tUmvN2AyneN9rDjWzoFvaUuLRaOzPliPlssCpBdN\n", + "O49QsUjKuhYlBGU5RwiJMbEniLXtIjqLFabLDodCgnct3ll0ov4WdRk4nND4oAmuTYm+aEblNE21\n", + "yBXZpo495rXGZJpgPU1TIYVGKUEbapyM7+0MriGTjtY3IHzqLgo69c33IUZxCBAq9ZpBUbuIortK\n", + "WOfjS2Kk1CnZGfNwIQRMEAgZOxLGVhwB6Vx8eXLi6YWMbyVSRifk3vm6lHuT3WaxbNfxw+yVNrNa\n", + "ILiVxd39rLOXo0u/cIhf9fMQwuL1RKuOpHM0qxHAi074q5Dvi05xdWPoHODLHNWL537RWb547Jc5\n", + "39XrWT3+i/0WVhOwf5YoY5mQeVGmef5azucsxLlS69VNZPW6VqvjVq9ldSNb/Lx7ozgSraKW3WSK\n", + "XBpsa78ylFxfX4+hZ+vQRpHlJiajSDJOZVE69jQRUnJ5sMelS7sopbBNSzUvqcuSqqxAB4zKGAxG\n", + "TKdzdna2WN8YMpmMmc3n7Gxv8Natt5lOS+4/fYhtPPVkzru3brExWuNb3/wWbdOii3Vufe0D8rUe\n", + "Tw+ecfXNTa6+cYvf/b3f5e69Q2Zzx+HRCRsbBeu71wlG8nz/AaPNAnc2Y2+4Td9k2KZFAZbA2++9\n", + "y6Pnh5RlRTmZUQhF3i/YHOYYLMKBkTlG5zjjaV1Ae8fZs6f8o7//97jzxRdRpz6b0zaAUhA0wrdo\n", + "aynyjMYZghrg2hrl3Fe+DSYHqrrFK09W9Ajtsv1yXcdmX+mdw7ExlIgFbd7G3uGxWVZsL+CdjQ4u\n", + "vSokvZsHgUWSeo8nBUhZzZaFRiHmvbSSaOWZzUu0NEgREW9dW7xwmDxGAv8vc+8dY1uS3/d9qk66\n", + "sXN4r1+eeTM7aWdmd2Y2cZdLchMpkivLf8iQLFsCJMiGAmQZBiQYsAzLVrAJC0q2JVAQTEqyTZES\n", + "STGI3KWWK23eHc5OTi/NvNTdr+PN94Sq8h91zu26p8/tNxQlDOuh3733hMr1rd/vV7+glMKoBJUl\n", + "hLUIjbb2F2kGGYBB5uIQIcQkZKAW1lI3CAKrwaIKM/scPyaHbZpQ+vncNyhpuQFyat06qMrXOhop\n", + "rDFfmiWT8wL33MESVt7sg+Q8ve8UeFlUANOL3aWIy9R68awLYuU8XYBy77lg424ixfWy/maRl/vb\n", + "fa+oSxUlDRAVPrSdv/eSJpouDki67Zi1uRR1rMqvDLhlrRt3YyjyKe67YF/uH3cTgWpuZla7Umty\n", + "aRVHlZqwqkYdBZit7h+VT3aJlxtNqXyRa0zuZlajhWXrdV4/YwwEHvPzbYKlRQaDATIKSJOUpaVV\n", + "Hrr8EOPxiMC3KpLD8RApPGpRk/3DLucvL9PtDRh2xoSizs13NnnsmY/QHyZ0hgO+9PWXiFo1tCdY\n", + "XV9ke/sGvU5GGC4hhM/C3AL97j4CQT1ocuHcRe7t3OH08jKLjRbSwHA8QgQ+MgrYOewgo5BRkjDs\n", + "j6iHEWEE840avjYEwkNqK7Ndqoc0Gi2GWcrTT36QbNhjrhbiRw26211u3N4hyTSXzq5x/uIpxoN9\n", + "PD/k+u199kYJUinWWwLq9co+97SX+4IXDAcD5vLgFp7v4QcBqcpIktQGzXbOoqQorKEBT05ENMqk\n", + "VrlAMPkTwnp1NUqTaWU3Agm+J8nSjEzFOeUsGSVj/FqIURqlY6uvH3mkSk08RHo55RsG0lp7A0Us\n", + "1+JMxioQ5Fynto6ntBSWWzE28LnK8s/c4tqKjiyWWZVDmVun5mbzucqlkMV6sYeUfuAjPZEfdR3F\n", + "1kyyFG0EWue6+veBiffRkGea7S4inRTAWDSoLAM6CbjKIFb126UoTwKWcj1dYHevuRSxC/KzgHXW\n", + "RlUur+q3C45FqnL4XgBelcil3F9VXELVGUKZEi+3w90AyxzSrLKnvhf3zYSbRgpJMs6sPvAMfVhr\n", + "tesjDCR55JrCylb6HlrZPgvDiDAKSdJ0ImNsNpqkcYwnJPPz82jfim2SYUyj0WDRzJNmQ4Y9Ta0+\n", + "h1YQhnWajSZRI8EISUpASoMHn9Ps91J++h/9LIPBGJMakpuHoDVv8Dae7zEeZsy3enQPBzz3zHOY\n", + "pk+WjpHMcXBwD3/OMB8KaqFPphTDLEEpz4oI5JhUa4bjlJWVFcbxEE9mmCQFYZ1vaW0IfJ8wCJir\n", + "h6hQ8NQHHqOXjlhemCdWPkr1WD91DhlEnNtYYXWtTtzzubO5zb3dAwamTSgkq5fOEi3OV/Z5vdZG\n", + "hxla2MAfF1dW6fV6HHY7pFmKMdbthecHuaaINcjxAj/3xy4xntVKEcIQCg+RU+BKCIzwQUpUFk8i\n", + "HSldmLIbvMCbWIlalUKfJLcDMUKTqRidaetAzAOjPetpUWUEfq4Z5XloxORQ0crqM2spYo78JmXG\n", + "BiKeKATkBjuF/D1RKULnYsQ4m0SwB1BaToJ6CymPDHQUIGQO6po0zaw4x/etuMY78q8jZsz7Ir2v\n", + "AF4ANdjKl0UdVfLXsiihuOZSgO79KtCYJYeFI6p0VnLfKT9bdl7jchZuRGs3ryoqeZYoo+q6u8Ed\n", + "OxytEMVUlXM/oL9f3SYULUyNpzsW5XE5VoeJ+4gjlU2Mdf3KCcpUYZTLabUpMpgYTWmdIZQ3MZhI\n", + "0xEFV2uMIR1n1kxb5CbZwlL+9UYdMEitCaMmSwvtnCLSebRwCSpGGTBBjau3tvjy17/H61ffYTjO\n", + "aNaa9Pr7eJkmFB7+uIHvSdpCM9rfo+37PP/NL7O8sor0PZZWl+mnmrmVswy2b+DphGbkUw8DlCcY\n", + "pskkRFdmFCbTRLWIUPhII4jCiMD41L06GMny3CKthQUWz6xyuNch9jTG8+in8Pa16/SykDhT3L3Z\n", + "oP3pZ2gGAa+//jZbuyNMXZAMR1yNFHOnTlX2uR/W2d28w5s3b6KBO60Wa2trrK6vYYRgd/+A69eu\n", + "Mjc3ZzfC+QXSJCFJNY1aSJLmaq/SQwqNVBqMYhzHiCBEiYyo3iBTY+IkzilRTRRad61RFBFEvj2o\n", + "zFLCwEdmGUIYG2UqCKwriixD+D5GGdaWlphvtOju75MNB3ieIM61WKzfFEPgeda0PTvyZyS0ttal\n", + "wvq3GWUjgtyWwYZ1s5F8pJR4UTDRlrPYpUBCpjS1oJb7ZLJy7nE8yOerQeXReIhzJS1hA4r/vj7E\n", + "LAPXLGq0LC91Qdq9Xz6orKLSXfApDgfcDaE4NK1KJ8mHZ9Xfpdwn5vyOSKeIFlTV5irKtQpwy/Wt\n", + "2rjKbS7fq+JyZo2HW5+ymMl9ZlaqclUABWDbbwaDcOSvJ+YnCg2bnP02JtcwsJ9FNCW3TFe90xhj\n", + "Q74JQTK2Pj4KWagUYExGpzuiVqsRBBHI0Drxb59FK8Nvfem3+M53XmD/oENy0EPFCVsjq2s9Tsas\n", + "Xt4QZZoAACAASURBVLzAeuM8t955l3HaJWxH9OIOC2fm6Aw7nD37AJ3RmNbyGqPRGB0EGM+QYPCM\n", + "sQezqcJDYMMh5P5LjI23KIwkTlLqzQZgf6+srFFvNzEK0lQz0GNSAWF7gWef+TAimmcYJ8w17eaY\n", + "acMwTqxIw2gevHSeRx97gJfferu6032fO7c3Cf0aRhj6vREPP7zM4UGPN956k/3DLqdPn+bM6fMc\n", + "7B3w+itvMRqOqEUh+/v3CGoNPvmZz3Dl2nX2drdpBQEXz21wam2NQTzm9s4Oc4uChXadTqdDo9Fk\n", + "PBxRy0MpCiHYP7ReGz3PQwa+lWVjfawMhj2yTONHNYaDEfEopVVrcv70BhfOnuHfffc7gKFWsyqC\n", + "CMGgP8LzfYxnDQgLjs/LtbyyLENpRRQEqDTJ1RvDIyOhICATVoNF5NS79KxWlhdacZ7xQOnMBiX3\n", + "fEf8eyQG9sMg9wJpTwTS9PfpIeYs8Ub5kK58H0pGMbPYco6OBKoAZpa/41lU66y6lMFh+rBvcmfq\n", + "+rR2xnT5BXVYBY7l32555U2rCoCDoBju44BYls2/F/FOUZ8qEQy4OvVMZHkup3SUl0FrMflePsw5\n", + "KSmVW7GRq4QJJvJGIQBdsYEXbZ30hgABkQ0vAUbmsloFwqMeNBHCY5QohFAcHA741veusnnrLq9+\n", + "53dQ+138UcqzZ87RbjcYm5iRzBj7iqAd0Vg8w4effJivffu3eHf7Gs35kMP+PWpejRs3rvPgmQeo\n", + "GUk7atKLmmzde4eNtSWQHlmc4AcB2hh8X1pvhjJAeoYkSWxQDXseiRAQegHX373KqY2zyEadaHmB\n", + "QAc2ilAQknYO6eztI6VkfeEcB7u7jEZ9VtdWyUwXjWZ/+xav0mN5udoH+6/9xq9TazRZXFplc3OT\n", + "tVNrrK2t8a9/4zdI0gxPemzd3cYXITtb9/Cl5OzaBjpTBL5Hdzji+o13GY5HGGM3zqtvvs3lCxf5\n", + "/ksvc3d3lwsPgU7qLC0tEccxtXqbUazY3d2lVqsThhFJlrK0sMhoPGYuatLvH6JUShQGgEIpgxQB\n", + "d+/eZKk9z7e+9R021ldoNuvs7e2DkIzjlCCsobTGCNDKinK0p/GExJOKOE7xPSsa8YMAncu/LV/o\n", + "59GeBNLjKFi1J0FoDIV64dGaDqOALE4mhn7W1ZNVM8wy6+WwUEH0ZoQSLNLvCcCFEO8AXUABqTHm\n", + "I0KIJeDngAvAO8AfNsYcVrx77NNlxavY+PuBq3uwmX85BnLFZ3FqXqVaV87/mGk9s52tz8rHFblM\n", + "H4hWA1T5oHMWVVwlwilfL5JS1cBYtTGeBOAnbWDuofJ0PafrWM7fw6dwzwky1wt2yp3hPXJSZ8NE\n", + "9l3SPM83DzPZHCeiq1IdZCH79PJI5iZnaX2PJFXUWnP8lb/y1zl//kGGco7Xvv8iK1GDh5+6RDAc\n", + "Ex92ePLiRZRQXL17k/1Rlywbs9AydO/t8MnHn+Ar+3foHnSYb8+hE4FUkv3NbZ576kPcvHaNs2c2\n", + "6PbvkSljnUsJDx1nyDAgkBJpfALPRjeS0sp8hSfAU8ggQOmEO7fuctDrYOp1fuALX2BpfRUlDcKT\n", + "nNnYwGjNaDRiHI8JF5qk7Tq+73Pm9FniQYzxBETS6nZWpJXVRbrdPp3tbc4uLdNqNdjcvIMQBqVS\n", + "BNaIZ9DrMR4OWV1aYb45T6dzyHg0ZH//AK/VJMPQqNeYi0IWwoCN9TV6h4csLcxz9/Yt/DNnWV5a\n", + "4/y5DQajMYPhkKVlj9t37rKxcQZBQKY9PvjUszywsszuziZb27e4t3uPyPMJG3O89sZVdnYPaTwz\n", + "x6XzZ9nf3QYpSNOUWr2BkBlxHBPWImq1Or1eF50ppAe1Ws1GJ8KqEY7HMXGc2wTkroKjIMAYiOOY\n", + "KAitOWGu3FCc7YRRbaJyG8dx7kvJILzcH4wo/KaQ6757KGVIsxirbTM7/V4pcAP8kDFm37n2l4Ev\n", + "G2P+NyHEX8p//+Wql6vEA/8+qcinbCRSLNSqzWJqIVMtW6+iul0AOwn0q9pT3mDcDauqTe5nOd9Z\n", + "5c4Sa7j3yu10ZfnlzfCkVG5/AeBljZ2qepTrYKPUixzErRy8OGw0wvWvXE6uSGZ68zEGpCicnE1q\n", + "nYux0uN9io1nqHWu52uVghkOR7TmFsi05E//13+Gr3/ju3zz536Fs6dOc35tEa2H6Br80Bc/ixqM\n", + "ifD4A5/5ArtbO9x59xbD2yOMjBgOhjz6zOf57pVXePHGNUyjRTeJCaKIX//OV/j4xz/Cwd4WG6fP\n", + "MOrs4wsfP6qTmFHupljTrEXYUG3aBn3A4IWSYTwkiYfUvRpnzq3z2BNPc/PePo12EzxJpjNMkiB1\n", + "RiQMzVaIaoWMjUGGEadOnSKUHpEQHPQ6HKqUVtCo7PGoHnC2sc5CY57xaIzxBP1Bj4uXLrC7t0+/\n", + "P6Req1GrRcy12tap2vY9Op1DtJ+xvLKIEIZGvU42HBA1a8y1W6TjMZfOn2Wr22WxvkC32+ell17h\n", + "7LnzjJOY1dV11k+d4eCwz/dfeoXx2Hri7PbHNJ76IM1mjdXlVa5cu0KcKuptw6uvvg5GcOPGO9T9\n", + "S8TxmEcefhylDf3BgHqtQZykHB526PX6NBp12nNtayykUjyTa5MYw/Lycn7oqanX6mRZRppkJGlK\n", + "rVYjiYd5IHTr1VEUFIC0XhujWt0G3PZ80lADHlpnk/Xn+z6pShHSxtjVWlgu8IT0H0KEUl5ZXwQ+\n", + "nX//GeCrzADwMohCBWWeE6ki/+c8aFkXYa8abSY1OekwbxZVX6b8p4FgGtRdirWKUq5qZ1Ubq35X\n", + "abCcRBGX8yieLR+wniTfr7peJZt3yyr3Q1Wdq0RAbn2mDjn1EXBbIbVHPrxYaJ2RJBijc9/KR/6s\n", + "rRzSGl9Qsla1HuvcOlgKKI56mNTDzyICFeATooWmVgsYp4rX3nqDv/v3/gE7e11+7IlP8eADD1Jv\n", + "N7i1vcnK6VMMV1boyH0+ePEy33z1ZYKDDi2lefhcg+bCHAeDASEBj/hN9DDja4NN1HwIo5hFHfLi\n", + "y68jSXnu0UdJBiOa9QbJ4IBxMkBEIamBmueDslo+Yb1OIH0gINGKtUuX2O92+dQXfoyVU6c5J33w\n", + "fJB5FKDcaZLRhYsD6x1Sa4OuaVSmkAja3gJBHB/5Qy6lTz77LJ7nU49sVKhUZwyHI5RWXDq7ysH+\n", + "gbXSlB5pssR4NKbb7SIjjztbY86un2d5bZUrV68SBj4H3Q5BFPLClbfRjTob83MsLS/nvlU0wvNZ\n", + "a6ySKcPm9ibD4ch60ySAGG68cZ27bz3P0tIyly4/SKx9dvY7jDcPQCukMOwf3mOvM8fNd2/w3GMf\n", + "ZM747B0MORiNuXrrLsM0ZWF5lblmRquuWF1e5tT6BbxWh/W1DTZvbjHsxqSjlIW5eR5/9DHOnt1A\n", + "Gc3vvPAiL734EtIMrc9/37cHnQiMFiwvn2Z+YQ2VSXbudVhcXEFGinE8wvMEO/fu2jOTcR8z6CKN\n", + "wg8kBJAmM/wZ5Ok/BAX+W0IIBfxDY8xPA+vGmO38/jawXvWi57AZxcKu0gCpotKrAAOsU5rKSlZQ\n", + "zS5AVclyy3mXr1VR81X3ivJPirAxi/s4iZo+KRW7+UkbUbmc8veTOICpw0chJs6NZrW/SK7YqQz0\n", + "1rfYbC5sVt29XNyBN123InZkAd6uZaybn33efvoysk6QPIlQGkWK0dbf853NLf7+3/k/GA81Tz3y\n", + "JGfPn6PT7TBKR6gkoV6rcefOXc6dPcfGxYv44zHe3h70etzr76FGI8JGg5V6g0dPf5Afahpe+tIv\n", + "0xnHmMzH9yMCLdBCMooTWu221U3PMlrtJkYKMiEYjUZ4QhD5AWmmiRo+0guI45gHP/AIn3/kUQZJ\n", + "wiBLrQVkHhrQqvIdEUw2YIpXbS2bk0qzNvGlxcUjQsEYIi+k1WxM+vjcmQ3SNJ0ai/F4TBwnjAZW\n", + "3zuMQpr1kMFwyGG3S6vdRGnF9tYWg8GAxaVF1tdXWV8/lfvKTmhEDeLxmMO9HRZaDYL5EE/4jMdj\n", + "PNkgU5Kd7S79bsa77+5Yl7TUGA16bN/ZY6G9SLu1ws7WNttbW7z6yssMtUDUm3jSZ9QfsLq8wtz8\n", + "PI88+iiL7TbBch+hPG4pxRtvvcVCY57OQYeV5WWCMKBWr9FotFhbP80oPaDX61Fvt1mYXyBNrTdR\n", + "FQb00oQ7t7a5ePEhbty4xa3Nm3z4mQ8TD0esnL6IEJqWTgkCASZje/suc+0m3V61D6Ai/V4B/AeM\n", + "MZtCiFXgy0KIN92bxhgjjhx2T6Wf+ac/P5kwTz/5OE8/9XilhZ7rj6EMku5hn6W4quVFZbAQQhyX\n", + "l3Ncvuted8ssf5YBrVxXOFKrKwNY1SHg7ybNovhdrZf7bQKz/K24bSj3tQuAZVHQSd/LG0C5DVX9\n", + "VzUmRSqceJXrWSWecjmTKi5Kj61JuicM0ldAhhaCeq3F3/wbP4WnAj73A58E7TEY9RgN+9y7vsXq\n", + "8grXX36FMxcusv3OO/zCa2+wGIU8uL7Kgw9fYhSc5bDfRWWKpLlAs7XAf/bkH+Kdrdv81ne/zdDT\n", + "DGSCSD2CwFod+r6PUIIoqmHIrOFL7hPE833bbgTjTFGvS8J6g/nFRYTnUavX7AFoZij0iL38gPdo\n", + "c9O5KElN9QUc6UDPSqdc9UJh/Vprra2/klzTqVDlK+Z7FEVW7W4OEII4SZi7/ADCsyHIDFaP//Kl\n", + "c2RphhFYs3hPWu0cbRjFY9L+kPOnV/A9n163y9LiPE8/+QlqtYioVuflV15n++4e48EIgWA4GtJu\n", + "thn2Rmzf3eGhBx9g9fQ6/STm4eGQzAvojWJSBPd29tnZvMO9OzeJ+x12d3e4+Og8C3NL7G13iHzP\n", + "ujmYX+R73/su3/jG1zh3/jy1WoPr16+zcHqRuZV1uoMB927eYTgcceHCRcZG0e3tY+pQWwpY1Yv0\n", + "zYCwVUeEHr/4r38dYwyf/sEf5KUXv4/QGdt37zA/P89oNJw5DvB7BHBjzGb+uSOE+EXgI8C2EOKU\n", + "MWZLCHEauFf17p/8E39kJpVXJCGs5db9KLsi3c/stAqQpu9Xq7kV1OysPN4L6LqLpgCxQn+9qo6z\n", + "QLCqTVXXymKbk9Ksfi0Da9k6swyIVeNX1P+kNpQ3yPK1orxZqcpKtni3sPiF4/5iynWLsnmETDBy\n", + "hBYjUpOiTECWJPyPf+V/4Td/+cvUdZ1GELG1/w7bm3do+AHjw13a7UW88RghPR5//BGuvfUWA0/w\n", + "wrvXSBuSRx95mA8+9gSvv/kG17a22Dhs8Mc/9mme/+3fYlyPSMOQ5UabO3fvsDlX46nLF+htD0nT\n", + "xPqvNh7jLMMPIoQXWtEFhjSJ8UyTP/cX/xtGSUqcpUjfByPwPAG5cTp5kBC3b8tzzO0LdQLHOBgN\n", + "pw7kC8o7DEPq9foUgeTOGa01yXCM0ookTqzpfZrkB3yWY2jXAmrzLYLcgCdVGXFs9bWNgfF4jCXr\n", + "BDozVgNJDdAqYfPuHd65/grjcZe15UZ+sBig9ZDTp+bpdTZptx5k52CfN6+8xWicsLC8RlSvce7c\n", + "Rbbu3ePSgw/Q7/fwPMnh+gKJvodJE+bqdYYMeP673+bDT32I3Z0dBsM+aZby2ONP0m63afktvvSr\n", + "X+bHf+InmN+Yp9FoWI7Jk2z2NpmrhfzOt7/K448/xsUL69y9e50rb1/hYx/9MPV6EykD5heWCMOI\n", + "S5efoNlsIaTk137xX8yc+//eAC6EaACeMaYnhGgCnwf+J+BfAX8c+F/zz1+qer9q53fyBnK5rfSO\n", + "AUlFXez1+4giiu/uNfev/Ows8YGbbzkf9145lU3LXQrFzdvdMI61saJtVanK0vS9bDSz3nFBumw0\n", + "Va7fSX1dfr74K9j18jvF5yx2vjCQmtWGrMKbotsWt14+AUJotCetIyzpo02NwFvgrTdep+63SfY7\n", + "9Lt3Gahdmj7MN0LS4Zhk0GHzzrvIZouX33qNZqvFvf17tGoh436Prdeu885LV/ihH/1hzHgEdzo0\n", + "On3+2p/48/zpf/y3SPw6wyCi3rCimMXIo+1r5lttRuM+Xi0iHgwxniTLQ3rVGzVqzTrNxUUOej2i\n", + "RhO0si5JsdaPkwhW1kh8qh+MMVNz0u2nKkveItVqtYl8GpgiTNI0nXB/5fGWUuIH1mtiq1UnTa18\n", + "t/Bu6fpesT7vbX5JkGDjjyra9Rqj0YgwDBmPxzQbTXq9Pkl2wMJCwGd+5DmUMvR6ffqDAXt7e4xH\n", + "Q8bjIUG4xMK8j/HhwoMXSZOM4TBmZ2ePr/zmr3HqzBk2b10nM4oHLz9ArVHn0pnLDPsxh1mfS+fP\n", + "ceH0OdI0YTDo0et3WF9bs0GIleL221e5uLbBWy++SppkLCwsEgQ++we7LC7PM7/Q4vFLF1mfa+Lp\n", + "DhuXN3jq4fP0e0Pm5hdRGq682mNhoU2vu8edd67/RzXkWQd+MR8kH/hnxpgvCSGeB/65EOJPkqsR\n", + "Vr3saozMEl3ANIXkAkQZDIGJE6NyqtIwqTq4K5flLvRZk7kMZMXELXe8C3xlCrkM/JWcyIz+mTXA\n", + "99OqKedfvl+1eVW9X2WQVR4v97yjqh8LIHHB+72KllwAP4kbKbeliqL3PIPxDUZoUiNITYD0Wnzr\n", + "m69iTJ3Ir7NzcJ2st4sXZdQCH5kleCiSdMj50w8zFD5b71zn4x94iLlGg3OnTvGt//eXWX7gQX7n\n", + "V77Ey89/h49+4lmeXNzghddf5dmPfZw/8Nwn+JXrrzJSMa35ObZuvctoHLOxsYpWQ/67v/yXWNs4\n", + "w63NTW68c5MbV65a7ZZ4iFev89Szz7Kwsspht4P0fOtn3RTnSspapEpvEtzX7UtrHThbq6oqFeNV\n", + "9gVUNecnetH5c+NczFKvWdU63/fJkmSyHnyZr2tp322325P3oyjK5fmK4aiPlAskaUq9EaJ0g85h\n", + "D+EJkiSlWauBykgbDR44f44oCvF9nzDySY1Pe34eDGwEIR+4/CBaP0e338WvhcRJzEG3w3y7zvrS\n", + "MmIp4BvvfourV95lZXmNBx54AMQpanXrYrjbOaTVbNCq+ZxaP838/CK9/oj5hSV2d/dY7a3iB/DS\n", + "Sy9w5eqbJFmMl6UMByOiKKLWaNLpDmi3F/CCkNv9Q7q9AT/wA58iiiL+7xPGQvxuZa7/IZIQwvyb\n", + "f/1zlROm/NuXwbEFXQbJyYKUxyntgsU7CciqQNt9torSdPOsAq1yqro/i3Kv6pNZm8h7Ea+UOYhy\n", + "favAzBVLlDfYsrjifptbmav5923Hk8995ti9F7/z5fcknilT9pVtzjyUTIkaPqMsJagt8rWvv8Kt\n", + "dw5Yba9x8/WXObj5JjLrMhfZKDZR6NOPR7RWV1k6d5762in8WhNhBBvLq9x48y2e8Oe49dZbPPHM\n", + "k7zy7lvc2rnF4xcv86GNB/i3X/oKanmBX3vzZV7v7dKeW2T3zibn1xd54sFzPPLQRX7iJ3+cBI2W\n", + "HkJ4hNIn9DziLCZFI6UgU1bf3cvPBIpoUWAFDrmuzbG+vt98/cinfvzYve99/dfv+365HPLyVW4l\n", + "izFWECKEFe0YY1UinLmlyV1JI3LjLPLDUX3kqS+X6wcitC4TjA1CnmUZSZzYDR5jvQFifZ+nvkGl\n", + "mTWhT1Wu621VWIejIQqNF/gMRgOiQBB4EQKfLLE+xOfmWlx68BIIwd7+Ia+++gb9wZjMH9EbDFmY\n", + "W8b3Q4zxaNRb9AZ94nhEe65Js1UnHo+oJ9ZQaP/wgIND60NmMIp599Yt2vPz9Pp9G/ih1uBf/vy/\n", + "xBQ7cim9r6b0Lis+c/c305PEZc2qHDuV1fUKKqD4XWb/q1jHY1WYATguZVFl7FN+fhaF6NbVLa8M\n", + "wO4772XhlDcG13hplhFSOY+qjcot/36+Y8r5Vv12r1XV4aT2FkEkXLl2OZX9xRSO08opE2N8z6PT\n", + "HSFljX/1S7+KJxfwtc87V6+SjQcsr8yzv73HcCCp1QKG45h6q8nKqTWu3XmXp8+fQwnY3tzGz2Bn\n", + "e4ffObzG+soyr777NhsXz3L+8Qf57gvP89yPfJo/+tRf4O/81N/m3MIyvUiyM4g5vXEWnQ1ZXT/N\n", + "53/0x/DCAKEVRtjo5bHKrNMoYTASKzIRxaG8ACTGFUcUAQLyafRezkZmbbRFH5ZFieVUqRqMwIZP\n", + "zN8ReTjB/D+L39YiEmMQvnVSZjcfENp6+xPC+hw3uXMrgyEr4pIJCLQBrJOrwkEUudooYch8q2Y9\n", + "BmqNyTQqsw6rtNHMqzZJlpCpjGbDhibMUo3n1VCZXTf1eo1OZx8NjEdjlpcWaLcVCR3ObpxCyoAs\n", + "M8RxSrtdRxhF7AlUqmnVWjSiJk0RsbOzw/zyBuceeJRhPKLb6xMLq0PuN9vUGnUOO50Tx+l9NaUv\n", + "g1cVK2fUyXLvKZAzx0UVLqXuyuqqNC+EEFM+Ulxqu+rZWSb973VCu4BYXhBVC6iqjJNEQVXAWbSr\n", + "7ELXzV+I42qWbt+dJA6pSuV+q0onyfreKzifBPIFcAthY0+W8wcwniFLFauLp3jhe6/SpEY9avLa\n", + "22/SPzykGRqiRsDS6hpbtw/wpDVxv3DxEvv9Pj6S3e17PPTYU9zbvEe92aA+N8fe3l2GnZi1U6cY\n", + "Zgln2mv8qT/zZ9k6PODezl1+/I/9EWS9xn/+F/8stBcJ6zX6vUNeevlV/tyf/a/oDTrWuk9K62ND\n", + "G6QGpMil2sfBtGzV/F5A1+lILGFc3Z/e5GA459D08bzc8o7GyDoOK8LoTew7pKDQVSui3ACYvB6Y\n", + "3O22lPmhtPUKqLH6/wAeaU7IG5RKiurZOeFZ9VVjLzDopta+RkqrneNJpC/wDUivTlNYD4qeZyMy\n", + "WW8N1lNloU+fpAlKZ2idMT/XIEkyUNayMk0V9VaTkRzjGc3iyhKdbpcwrCMy6PdH6IUmYa3FYeeQ\n", + "g94mRsA4HbO0sobneyhjCMKQM2fP8/OzR+r9A/CyRgZMg2+VQyd3IbueDIt3Qz+sBEd/wlYen8Bl\n", + "UKzSQqkSHZSv3w+g3OQCYdl8vYrKdetb/n0/4HPTLNez5ToXh1Bue8oiq/fa1qpnT6LAq66dpEPv\n", + "RhyvyqPgPNw8y5vPpI6eTyto85Xf/G3efOkKpB7Nxj41NcCvQ5qMUGkNKVr4yx6HoyGPXb5MtzdC\n", + "pRltWUP3Y9q1OqtLy4xVRm1+jl1S0tGQ3o0eWzdvsXf7HmvrZ3j4scf4yvbXObW8QDOs8yf+6H/B\n", + "P/v1LzEYjohqdYyBr33jGzz+1GM2fiUGI5SN6KI0RguK2Km2/Uf+Z6b7y5B7i6kUoZWTNmYS6Lcq\n", + "TSj6wkCq4uypPJ8n6zZ/L0dXW7s8uLAxZgLIQO6C1YZ2m8xyLfPNxSAxTHx560I92AL/JHsh7AFo\n", + "LkASQuKluVM5bR1UWSoejNY2zicSlWRgQPuaIIhQyuD7AZ5vXf1GQYCUAcKA79VIUwXjhCAIiOOx\n", + "DcgcWde1wvOp+fMoZRiPUhubNuky15DUgjbjOMYLAqS/RK8/oNVuIf2AXq9nQ9OdkN5XAIdpACnL\n", + "VuGIAp8YH1RQjkU+Vb62q+TbJ4HRSaKM4tr9qM9ZQPJenz1JK6csPpolCplFvVfVY1aby3UrU3Un\n", + "tcFNJ4FFkcqHmO67J4lQyi6Iy8nlJsrqhuWxN0LyzvVbfOPffosLq+dZXJjn2tUrDIZdllcW8X3B\n", + "aJRQCxuESw1WGmcYZwkizWj4EUmmyfojku6A27duI6OQYTym29lDDwY0wgbJ2DC6vc/WO5v8qb/6\n", + "P/ADn/0st7e3ePu1N3nqiSf50jdf4CAeIMaKC5ce5LDTJQgixunIBtLGUqtSWgMkivmYu8xFgDLK\n", + "aacVs0gh8cRxo51Kd8ZgnXrdZ6wmZdxnLciCcjbWWVR+42jcPEdTxs1X6MKDtlUnBtA2HLg5kgih\n", + "hEFQJ1Xa+iIxZop30DJ305A3KcqDfQgp0cJuBJnW1nsgEl8IRBAhEYx0jBTexJeJUhnapGSZDYhs\n", + "Mo0UYzAS32uQKQVBgPLACyOUsS6K2/PzqAwWpE+mDDLtHfVb7lRrNI5ZbS3ZOLC1gIVwgayCu3HT\n", + "+xhSrZgILnDnrJs4Csor84HPjEalR5ErJixePoE8KVAimnSKEEfPGG0mhyASMSnHPlcGBlc0Uyzw\n", + "ItvC3NvNQzCdhWvVmVMaFO8b5xmbr1LT4ZSK56Q8qkcZcGadA5SBbxZQTWo6AfWjNhZ1seXa7/bT\n", + "rpgqn1KF5d6xJKctXE/aRIwpg7SZzAGqc69s0/HkQx59vKDcLBtsD6QsqEsQkppo843f+HlOz61T\n", + "qzegIdG6S5MBMpbIxhyH45QFQs5/4AOszje58vy3aQcSEw/JhmP6e7tcf/55GuOE5LDLUhTQU4KF\n", + "epuGF9Benyftj0k6e/zDv/HX+S//+/+WZhQx3N5kezxk7fQyi9kid25f5Ymnn+BDz3wQpRUhnvWN\n", + "kbfB9ms+XjnlagrgEkd9bAwYZTDCoES1KuYsTm9W3wpD7oTJjpOpttWrpMCnRjiv+4RYY3quT767\n", + "ZVPIxAuPkgaZf5pCpGLyM7bJIgeDdfWqjSHJw6CZ4lhX2EDN+TEnSuflCEGQR9vxAm9SnhBRvl60\n", + "RVAhEEiSNJ3ULkkyyOX5UlqXv8bYjVEIQYB1aeDlIiE/9Jivz2EMNB38uN95xfsK4EodRbkpJqRN\n", + "Rws+mwqHZm9pk+98UiLy97SR6Fyv1JVzC2FlbBgLCKoIh+T7CCkmLOd0PYqKFGIKF5Bt/QqOoChv\n", + "UvMZYFnlhe+ozOP9o5wI1naj0xQRr8vGEVXA7P65ZU2PQbFpFuKS6XtHG5fDGXGcW2Ki3zCdXFg/\n", + "yRcM2HBU5aVabJAnpVkbWJH0BLNsmKoi8osXeEjpgZFkmSLwA/75P/05djZ3Obdxkf5wyNUbb7IQ\n", + "+XhKYOIhola3ZuytJhfXTnPtjVfYv3MH7SlCnVhvj9qzDpqCkCzLiPwQLT16nR6Ndpso9HnqfaY5\n", + "hwAAIABJREFUmacQnZSbh/t89Rd+iY9/5rPUDvt4kaAdBXTVmI3T6/zsP/kZ/uAX/x92d+8RBiHG\n", + "WABHGLRFPzuuTFOcx8REJxBxVYZYE1HiLMq6RCi45brj4uZXxV0VFIMoni1xf5N33KKPSsv/t+33\n", + "PWttekx0VGCBMRhpw6RNZm2RvzbH56SwVLp0xE5grVStnN09E7J+vgVHfv7DwJ+0oRDzuesl01iP\n", + "k3lA5DRNjwVBeS/pfT3EdHfbskx7kibAwaQzpJSTgxStFEZpUNo6gKEYWktpSQRSHOVtpDnyG+0M\n", + "Wjk8miumKRs7uGqMLkAW16om9awBqaKmy5S0NUY5rrJ3kuy9vBnNEkPMImBn1cUTx9syq22uPPN+\n", + "2ipSklOUVRv6/dNMMYsBKyfWWIcrBrQ9eIvjmDCsk8aK2zffZefOLssbZ+jEIwIN/iBlmPVZXKiT\n", + "pSnJYZePPf1JGmtnuf3qK2y9/RreoG8DJwcetTBCa+iNu6ytX2T/3oCl5Tnm1pft3E0y9u5ucXUQ\n", + "86Hzj3CmPkcmAnZef4MlP+IX/79f4HBxgZu9Qx566DzPPvMhxvGIZrNOluViIOFhhPXzIoWcmLzP\n", + "AsnytfJzs9wg3G+8TgoC4oqt3DxniTmLe+7nrFQlGizKLvIvcMK9X5bJV82XKo6huF6OBVuFHVWi\n", + "Xbe+03Yg1nK1uB/m0YbKdblfet8AvHywdARUYsrwQ0o5Ae+iY4uYi5POzGVo8cSdY4AU0oY9Mtbx\n", + "vR/4Ez++Nrr0ccu/oi4u6LplwpHVmFKKWq02NegwQ6boDHYVoBbvF06hXHn/0X1dECxTaRaYFi5o\n", + "7rej2z4+vmiqxC9CCDD62CSeOdHMtLl6Oc9yPU6Sdc9K92MxPV9iUTx/TtivRsNcu03nsMf62ml+\n", + "9Vd+g3ZzgfMPPUymDd/45V+jGaeEvsdhr0uzVidMFUn3kGh5hV7vHmnaJ82GJEbTrjVRKiX0ApJB\n", + "j8AYxr0e49GIqF5j9dwFxnc22drZxIwTvnn3gLA1x5n1Z3n2Cz+M7Mf8ws//PKQpKhlz9/ZNfuZn\n", + "f5qde3cJQquVYPlxkQupXY7wONFRNeeqUtlS9b1QgO5arXIHUQWy7r3y/WJtFfkUxlknuTS+X/sK\n", + "g58yWBebS3m+HXG65th8nXAkpTaUN60jMeh0+1w116KtSh1tni7x59brvbh0fh9FKMflupWR5rWZ\n", + "nHpP/UmZE1f5BDLge0cn7VpnE5AOghDIwyLlEaONduXp1QY1Rb2Kz/JEKazYXM2ZKkCdtdsXO7er\n", + "2gd2QqdpOtNKrjzximQlDo6UsLRYqia65VyrZNLHKXgAydHEvR/Yzpr0Ve8pleXPlO/87iiyY28L\n", + "2xcT5ttYPxq+7zMcxMy3F3nx+ZfYv3fAU49/lDGG/YMDlleWkbv7aD0gjRUDNUKNFFfefov6aMDC\n", + "SotxssC+6qK1YqQzWvUmWWIQqSLuDqjJgOFej1pznquvvsGz5y/x7Cc+hsbgjxRhvcnOYo3Xe7uk\n", + "3R6f/kNf5Mr2Fq//5q9Sq2mSeEQQeiRpjMz9nxiTcxCFKFEfH9fy2Ln9dGw8K+b1/UA8CIJK7an3\n", + "Oi5VADdr/ZVTua6z6g7VHk+L8socieurqMhXSjml4VRFhEzP62njt+LZMrEohHCiYx3Ve1Z4xJPS\n", + "+wrgLngVyQVEAE/61hzYFLElcx8PUtpDCCFQWAbZN4rCYMkTkjAMc5DOD0tFzkgLkQe6PSrTndhl\n", + "0CtMft0Yli7L406CMshW7ebF90Js5N6btDunBmZN6nIdi02tzMbdj6oVAmYYeU2VVd7Q3HbNUuHL\n", + "HEqnnF91PapA/uRJfD/ZehFzsJxPHKc0621Uanjhey+ysrjKuzvbzM3Pc/udm0ilWF5dRsU+XuKx\n", + "s7eLkD71VkirWSMQ0GrU2YpThFH4Gjwvw3ghB70u7TShtrBMrT3HwoU1/Myws3OI2N7j4cceZiFo\n", + "Eo9TzFKbyx94hNFhl91vvsHu1hZpMuYv/Pm/xKB3iBd6SM+zJueKfN7mQJArU5fnSVn8VT5/OYl6\n", + "PYlLKlKWZZP5qYrwYiWAm7UxuHV1530ZPN9rKpfnrt+T1l1503HFokUdq7DJnffl5wvjqTKeTHy9\n", + "5JKD4nohDnbX0f18n5TT+yoDL6uAuR1XPFMEEzWmoJjzs2KlrF6sBOkHJFkGQqK1IgxD0jjFN4U2\n", + "S35YmgN4UbbgOHtXrmPxV7beKzrfrW9VKh90VgGvu/sbYyYe9Kqoh/JCcb3Cufrb7kFwEY8PjruO\n", + "tZzPbHewRTpaYEX+xWIrjimqFp2NpFNok1jNoOMb1jQLOb35ldU9y0mIk9nMsjdjYwwID09CmmY8\n", + "/+0X2Nvd44lHn+Qg8unf2yfrdGgEPj01ZnFuHvqC9bMNhhKaq6fY3dtjPpCcWllhpz7P4PCAXpzg\n", + "BQ38KGDl3DnOPvYBRHuBu4eH+CureMt7DPe67HQ6bH7z25xZWOW5xz9M3WshDxJWo3keO/Mg/+JX\n", + "fonPf+4zPPvMs3T7e4AlFgwCX0iE8dBGgTBWG4RqMC7PNyGOu5QoOJ7ikn2/ANfZQBI4gaLdgzc4\n", + "vsEfH49qcUfVO/ebk+VUpn6rABiOPIO675WtuI2xYqIgCKbyKNaBC9zFBuZi71H/W2Kh6Fsvj61Z\n", + "1M/Nt6ov7tfu9w3Ai4E/abcrnhNKoI1CiNxQQYDWtrFvX7/B5YcfIag3GA8OqUc1PD9A4KGShEat\n", + "ThLHVv1KCLyCHVLKHmbClOy9XH75upsKGVvx6VIQ5Y4vJsKsCexSBWXquxhsV/e7mECuu1R3YpX7\n", + "tdgMC8B3KYgy11A1HpPFr6epqOJeVbsKXeJyv7j9c7QxTPv0fq/JzbuqDp7wcidnFqyEsLrURkg8\n", + "JN9//gVMqunsH9K+fIadvR1WGnUykzHSmt1eh8gIMt/nwac/yJlLF3n5699jtL/DYX9Ic3GFODX4\n", + "aMJmm4XlJWLfYzQe01z0GSUZg3FC5nsMjcZTBoXmdmeP5c3bPHPuHEtRi348ZG59jR/53Gd5+oc/\n", + "SlaE6VIpSimiWsNySoY8YrpC5m5Vq4CrTH3avplm8afGaopYMJxECJY5TleW646zm7f7vTxPXc+k\n", + "7jhWEUaz5oZbZplSLlP2VRbZVcRSOS/Xe2hV3abPrKo3tfsldy3NcnnhpvfdkGfWQBcpyyxwF0FE\n", + "pRRIz7Mx6xB853vf4//8R/+YT/3gp/ncj3wakyqUkZBpamGNOEltp8h8oolC19yfiDBc8KzyqFYG\n", + "NBdo3XpXAVMV5e3+LjYId7JVnXgniXXM40mPQoOmAGWRG3BYYDrurKlqsbl1KFtolhfDBHgBP9eL\n", + "LYN41eSU3rSxkZtXVf2q+nhW3kWqWozT93Pd3QljIsBYz3Zvv3aFYX/Axvo5DvcOuLZ1HQ4HLId1\n", + "/NDD9xscxockytBeWqW9fIreMGXj/EVWPvo0m3fvcvrRh3n1+e8jk4xs2CPwfITSjHf3WF07QzTO\n", + "qGWGOAzpBT6hFOjQkPiCt/fvMP/uVeT1ZZYeuYh4aJ3z3UdYXFxGSkOaQa3eIAgD+oOxrb7tEMAg\n", + "5FHAhvL4ueN4RFkflzO7/X10z66zWf1+EuHlluvWpVwvl8ssj3XVWnHLrEpl8HUJhTJR42p/HOdI\n", + "pvGoTJwV7a2yaq4ihtwy3st8djezKjwqp/dVhFKWW5U7AIqDCEBYxXdj7ILMtCaoNwiiGk8+9TR+\n", + "FPGPf+afcubMBj/6mc+xONdGpakDgnmHYK27PI4s/zzPm1CnVVR4sRO6O6nWeuJTo2qAyru7S/mW\n", + "WbDi0y2vDODWiCbXXcYBQ6YXSnGtAMmiHoUjK7c+7qQs6n2/xVlWmZo1maGQ0U7LKas4FftbTOKa\n", + "GvsSiEKTfLYc3+VAqpLRGopysByEQKOV4rd/+6ssLy6zv7vH0sIyg6s3CQ0cej71Rh3jBzTrTQZa\n", + "sHbpAeKxDXXVqtdpGkXmS05duMC1q+9wcPs2gdYMuh2iKESPBrR9j9OLc9SDEFGv0Q0lDIf0R0M6\n", + "vmGofL7z2wfgCR5uB8j5BsqHU6c3OOjsoIR1tKR0ShhG9hBHmNywXKK1QZvj4FW1jqrEV+5GWh77\n", + "Ki5yMq4Ol+bOicr+r6D0CyKlTCGXlQruZ61dzrf8OQv0Z20E5TLKYO6+V5aju/UtlzWLKKxKbuSu\n", + "Kg2fY8+fePc/YkpzcC3AZRYLbGV3gCioDkmcpSwsLNAdjWi12ozSQ5ZWVlleWeHG9ev8rb/7d/mJ\n", + "z3+Bjz3zLL70MSoDY6mwKploGWBsueLYdXcgpJQTh/TuxCuzUe4mUQXw7nMuR1Ck8uIoNppiAdTr\n", + "daev8skrBZ4np54vNpwqqqDMDRSgXN60bIWOL7hZi8podWxBuZuH2zbfC9CWvHRzOAY05VTeKI/V\n", + "wdrgTaz0tDH4wuflV17h7u07PHTxIbyWT7/TZVkJxmTgCXo7uxgkLC0TbJwhmJvDJIJsqFi6eJr9\n", + "uzd45fsvMu/VObt+mtH2PTyd0esd0ppbJ2j4xGZMPxvRu9sjjgfs7tylvt9BR4JxHdq0aA0VyStX\n", + "0A+cR15Y5+Mf+SgvvvgiZ8+dttHO6xG9YZ8giPKzWGtVKlEgfYQ8zgVWUb0mP6eoAsYyoFgOtbK7\n", + "7VjlIFMGTfdalR64C0yFF8kyten+uW1xtcFmzYMqyr14x73vyrvdze53u4GV5335vMvt5/JmMCvd\n", + "j9Mop/cNwIOgOJm1B5THnVPZT19oUm1QKkNkCuEL/DAk6fQJAo+l8+u8u7fNqheQGMOHH36Upx76\n", + "AK++9hpXrl3lx77wBRYX5vClRChF4PsYpZBZan2Na33kB8ErJmauO1wCc1f+5Ype3FR4Myzeq6Im\n", + "yvExywNWJV4qfhdlu9S/++eyi9Lz8LycChdySjRTgGOxqIs2lr0xloHeKJNbtjKJBJ+3Nm+fW9/j\n", + "VH6Zsp9MdnX8sNJyE9bPx6z5XK5vud+ksEENijHwvYjRSPOVf/MtTp26QL/TZ6FeZ39/k2atznjY\n", + "QZgUz8/ItKDT3eHspbMMuoeMuyPOn11HJCP23r5GNBzzwr/9Kj/+4z/B3mIbNRCkPozHGZ3xDiZ6\n", + "i26SEnfHREGApyTGC6n7AWkywpgxMYK93W2GuwfIxQaNxgLbt+9y6tIZZCYhyQjqEZmAUIGvvdy3\n", + "h9WsKix23Y3vOLgW433Uv2XZ7/H5djLrXgal8ly9HyHjEiFlsCoICTdPV3tjVn3gOIfopvI6Ka5V\n", + "le+2cRaglwG8StbtEiDuBlZF5VfV5/etCEWprAQc09Rs8aeSlMS37Hjk+SDtYvcTEJ7HmUvn+fK/\n", + "+ypRnFJv1DnsdlGex/qpU7QXF/jpf/KzfOLjH+dHP/dZhp0uARLf85BG4UvITOGnTeT+JGxZRitr\n", + "5ensiF6uzlVQD4WeNlQfglQNZAEkBZiWT6JdWXVhzCOlRClNlmZTeYHlZIq+OvKNfbSwXY4jUylZ\n", + "luWgZ/C8gto/6u+i7DJ7bCeSmJThyqyn1SkdUDbHdWhnTcgsy6bKF8LV6T/ZKrCoQ5XoIIg80lHC\n", + "8vISnc6ANFFsbx+gVAAyotWIGOzfI+7tkxpJvVYDHTPQCf0kYX79NHWjuXPtCr3+kGYIO1t3STfv\n", + "sb4wRz8Z89orL9Bq1dja26V/2EelB/hBQC1qsLA0z9Z4hBeGRM0WWQbNhRbzPmTJkGE/JqtL6s0m\n", + "KqwT+jX8VCOlRygDUDEmgBTrhdDXHgaByjWyPKcP3M/yHLT9f1xsVy2OgJPEVkU6icU/TtUfiU5m\n", + "PV/mNqu4u7LqbhUX4BI6Vam8GVRRx+6G4yoNuOWV83c5WbfNVWH9ykScWzcXF3/filBcirt8yAC2\n", + "IVmWIZUkA3zPy2WZGqUVSguUkiwvLZHFCaM0pu0vsr4xT9RosKEUg3jMD//QZ3n9tVf5G7/zU/yn\n", + "P/mTPHz5MsNBn5rnE+eROIQnSVVqT/h965FMeB44VIQLzkkeAsoVdRRqhkW7ygMchiFw/IS8SFWD\n", + "OcVOIibybze5vq2P+nGS6wRQi8lQr9cdKqgQk0xTRVrbCONFOgJVJtaiBVhWhbYrt6Gcj9u24neV\n", + "V0F38zgp//Im4m6m3W6fRqPGzZt3aNTbRLUmL3z/qzzxwafYvnkHkSXc3ryLjyAA0JBmikZzHtnQ\n", + "nDl3if3+kGFnwPryMru3bnHz2hWaKiPTKX6jxp3bt1laXKTX64JWJKMxUkr6nUNW1lfw2jXkXI1G\n", + "tkgvSzAC1tdXGB4cIJRP2uvz0je/w4dO/wQ6U+zcusPNF17l8hMPM9KCIDWIwEP71rOeZyQmV/0U\n", + "pfa6/VcGt+pD3uMbqh2baqB18zlpQy5zrSeJBoq6F4RBGQDdTcidP+67RSo2ieKzqrwqnyNVG6BL\n", + "dBSgXxWsuZqDObrnipyqrD3dOlRZqJ+U3tdDTJiW8Zbl4cYYfAKCvE3CntjgiwBhDJ6UhEgW5+a5\n", + "uXWXx1bOs384QPZGjJKERqtJ4EU898zHMEbzz//lL/Lxj36UT//gp0jSBBmFCGMAjZTWFaXWdoMA\n", + "AdIeGiqVIcWRv5YCNAuDhuIgrdhtC3ByzY2TJJk6oHEp3pP6p5hAWukJMJcnWfmwsrjuTm7brmyK\n", + "CpLSw/OmfaUX77iHg1OiIDUtv3frWAYSl3pxx7RKrOKC+6TNJ7DDRer3+5P6lsVKAFG9TrfbY2l5\n", + "jSw1fP3ffYvdnT3qG3NcvHSRrRvXac0tMe4eoOIhsc7QGHrdAXOrawRhAz8esdCSRNqweecWYZLg\n", + "SUEgJfUoItHKmsxHIVoZZL1GFIXEo7EV12lNFo/xPUmSxDYAsTCgEkb7h5iR4k6asfVvIj7x8U/y\n", + "o5/9PH/tf/6r/NQ/+b84vNenKTy8DIYBJMIQKm1tIDBgjm+e5bGsuleeZ9Op2qrYfcelmE+KYuXO\n", + "eaj2SV9+3q1XFTiW61UAf/HdFdOU14FbB3duuRyJ++cSZOV+rVo37txz532ZY3UJnzIHcD+xiZve\n", + "dwAvy5fKjZHSAy/f8SQ2Sr0RCGlItMLLJJ/86Me5/uJrdPo9rF9en7lGRKPWIDOag8N9kizmU5/8\n", + "NC+8+Dx3tjf54k/+QWphiNAZgbBGEjoZE+TBHxA+wvNByNwJfUkWbMzkULCgvpVSE4tNl0L1fX8i\n", + "q3UpkVksnHsCfWStiQ37pI+iC7mp+F1QyGX2FY78uBTPFODvsovFJCu4jHIdpZimlMuT3i03U9Mi\n", + "lOLQ100TUVnJarPI634sZHGIW5Y/FotrnI6pN5qMhjHJWPGdbz/P+fOX0UoTJwmb9+5Rb7WIfEk9\n", + "rbN/cMAw0Yhak9byKbb3+/QGQ85vbCCTMSIeExmF0IJhv0c/GSKjAKMNZ9dPMdCHZJjcDaKif3iI\n", + "TBRZZqxaZaYxCrbu3uNzX/gM7165BkoybkREa8vc7uxx4aEP8vADD9GoNag1Gsg0I5CS1DNkwh5S\n", + "B7nqqMdsgCtzefcTiUw/N/vZYq65FpjlNFMz6QQKvKhzFXiX53M5H3eeuBxHFWVdntNV3HDx54o/\n", + "3LaWtXfca+XDy6r+cQmUqvv3o7yL9L7qgbtilDKrVHxmRqFyB72uu0jP95BoakgubJzlW1/9Gp87\n", + "dZpOt0s9jOz7aUo6HtMMQhpRyFiPefrpp9na3uJv/u9/m//ki1/kuQ8/xbCzh6czWvWINIkt8PpF\n", + "JA+7YATiWF3LwFU+WS9YL1fmVh6YYiDhaEEUeqrTlCj5uer0gJeNIKrqCHZyFZOxsKRzxRhunu4E\n", + "LC9SrfQUBVNlNTppv5lebC77WWZBi03PDb7gUiwnsepuHscoqNBDpZrQq3HlnXdZmF9iZWkZreDm\n", + "9esMhwOEFMw1W/gZzIc+jBLqC0t4zTn27m4y325jjOLGtStInRJFPnGSoZXi8KBLKgxhGLK6uESj\n", + "2aQXp8TjGL8eMej2qC2ust3rsrRxirlTp/H7Yxqex6kzF7lw/kF8GfLa7Vt84EPPcGvzLkko+eBz\n", + "zyCiBqNxTK3dJuv1ERp0CGMkNS0QBlQFzpap2N8tiNu+u/+z7jwpJ9das2pt36/8k8QHVdxalQbZ\n", + "LO6j6rCxStXPJbSmuNB8nlaJgN3+mNV/xdx2KXiX8HDbcL/0PlLgHraurvhkWnZcgJOPzGPp5Q01\n", + "hsQY/ChEZIbTy6uYmo8wCaiELDFIIAxCVk6t0+n3kKEkiJbojQesraxw+dGn+bVf/RUOD/b4zKc+\n", + "QSgMo2HfWrlpG7Xayw82rbN3gUJPgUMURXlrHEDNlN1scsrbpQaOg3L1qfZ4PJ7I04Ep9qtMlfoV\n", + "cvGCglJK5Sw2WNNra7lXuAbxZM4tGFWpYlhssNMTVOP5wdSpetkXxmQi6+Pm8AXQFg6RiucnboId\n", + "HxtlJ0BVqegXpdRENXWqLtpgMkEg4caVG5xZO824P2BpaYleZx9pFKPhmFAYAk8RC0l9aYnLTzzF\n", + "IMlYzDSB0XS6hyTJCJMkBKFPEISMsiTfGBNqQUCqFSgIowjf9+n2e+zvaZ77yMfobt/l9GOPYmoN\n", + "etfuoOOMl15+nQtnzrAyv8Tjlz/AamuZ1WfPcOPdG3zgE89x/c23CKOAzYN95j0fmYIRkPiKWmYj\n", + "7Bj/+EGay2HdD0yqxB82mMhsaHCtqKFaa8rVxnLHqTzHqqjUYs5U1f1+FGtRRtUhYRXl7eZ5Ehfj\n", + "rrmyqLJ4tpC9z6qbm1IndoH7eT+Os5zeNwCH476wy5NMCBsE1UNYdTABwggkgkxYK81QeCRaEbQa\n", + "7Nzbot1qk8YxUa3BcDig0+kQ1Wu0ghadww79YR+kIPVq/Minf4i333qDv//3/wF/7I/8YU6treAJ\n", + "GA36RLUa43hswcYPchn09A5bNXGFEFbNjmnqM03TKQ0T9z2X4nBFL7NOud2Du7KBjhtyrninyF9p\n", + "dSxfw7SbSxdkq8bEXYjFvWKxVlErLqC69S76owzaLrVefJ+1MIApTaByP/i+T6oT6vU6Uvtcf/sa\n", + "ly4+xGg4pLe/izQJq0ttzDhk1OvTNzEJknPnLtFYXKK3t8/Djz1C3RO89M2voY0irEfESUo9lOjU\n", + "4NcivMTQWpgjVhn97oBWEFGLIuZ9jyCKkEKysXGWGFBhxOHw/2fuzYMsy+76zs85d39rvpd7bV3V\n", + "1VW9V1f1pl0CWwIZiUUwgwwOzLAMWCwTJsYT4LGDiImZMbZngnHMGAwzDkAgIxAIkAwSIEC7hJaW\n", + "1Gt1d+1b7svb737P/HHz5jvv5suWYDzRnIiMzLzvvnvP8ju/8/19z+/8fgFZprh2+w7dXo/HHzmP\n", + "a0ria9c4duFBEstktb/LAyfuZntng9Dx8qw8SUYWJ8QC0iTLU4GVUp8V/VuWy7KC0/u2XITYC1lx\n", + "SCnvd0wLDnWYxVQGLtOokWmWQ7kd5XJY/PEyki2/T1/kCipP/265HdMWnGlK97C664p6mlVy2N+H\n", + "lVc9oUMxoIVZcaCzTQlZLlDKEJiZQCqxlwdP4GSS1DSYO3aEtbU1Fs4tEEYRW51dwiCiWquRotjc\n", + "3iUIQ6q1GrWax64/Ymu3y733nMGUZ/mlX/m/+cmfeA+uZbK8vEC/s0uzOUMU+PkRcm1Ff6VOTrMM\n", + "lR48SakrmWmKWleWBZIsm3BF/5RRffHcw0zHcZ3F1JjjhblbRhPl03Ll+hTtL9D0NOWgt1sf67LX\n", + "SZlSKzaBi3ceFo9Gpwv0TdMwDPPJZ2RkoeJzH/84rWaLF55+lhPHj/HylYtYhsKouLSrDertFrcG\n", + "OyzOLXHPfQ+wNRjRG/kszM/SW79NHAXML8wx2O0SRCmpH4BhMgp9KjMzzC4u0dnYwnIcvEqdmUYT\n", + "y7LY7uyydvEK8/fdw9ZuH8+wcBwbI0lJSBgRcWNrhSPeCRbaVdrtGWaGXQhjNm/eoVKvsjPoYVVt\n", + "lCExhMSREmlCmhyM4ldWOtOUwGE+85Myc7jy0GXhMESsy6j+vWnz6DD0O81q+JtYEsWzykp7Wv8U\n", + "ddLBVbGnNa1e+sKgy3z53sOuTbMCvt73p5VXVYFPowR04ZBSkigQKrf6i+zRmcoQpoklJMLP3eCO\n", + "3X0Xz33gLzlx8iRRmlKdmaHleEjDxDBM0iSjtedXLA3B0fkqi+0WW1s7hEnCo4+9hj/40J/w2IXz\n", + "VOt1LMclDAPiKMC1vDz3nsbJlhVaUQyZx2wpFEnZ/ahAltOQcnnXvDzgZaSr96XuTlhQOuNUaXto\n", + "XZoTdc+yLE/CyqTgFkq5PFbl8StKEWe9fF2fLEUdy0i/aGN5AurIbhrdVJSyJ0shN/vcvJkiYos/\n", + "+9M/5bGHnmRupsWws4uRxvjDHmZoM9rapO5VSV2PhaUjuF6V7eu3qdUrRIHPzWtXyeIQ07LxKjWi\n", + "KCPwuygzRZgGi0eWCZKYzJA4rsPm7i5JnLC8vEymFP2VNU6dOU3omDQrMyQLswTb22Sk+PGIyzde\n", + "4tmLX+PsyhW+c36OumGTCbhz6yrtSpXmbIMokwyJEAKsMCUoKIbs66O/shLT0ep0hZj7jB+mLMub\n", + "0WV6RAixv99SdgGd5laqK87DrIOylVUu03jt4ntlUDjNw2aap0kZWU97xzT6pVx0i6Vcr3L9vt7i\n", + "Wy5fV4ELIX4NeAewoZR6eO9aG/hd4C7gOvC9SqnO3mf/HPhhIAX+O6XUn097bhFPu0Bakx4XYwUu\n", + "pYGVKhKRkbC3eZBBIpI8QWgKwpTcffYMf3LzN+j7Pl6ljrRdjEoF07S5c2uVYX+AFIKaV2Gm0aRZ\n", + "sxGWweL997HTGzG/dJTFI8f5xKc/jldxuOeuY5CEuLYkTnLyUbcasizb9+0GXZGA2FMg+uAUnxeJ\n", + "GsobQOWDB4XwF26L0+iEct+NBUSR/5mhx78Iw3BisqVpnifU9ewDKF+PvKZPTP09Oj94GNIp5wPU\n", + "PXf0xarwkCmjL91KmVbK/LvuUimEIEpGrKysUK9UsQwT0/O4fOkGUiYYKsE2baIwZNTHoIa/AAAg\n", + "AElEQVSLibCQ0uDOnRU812V+do6tO9fp7exAHBFmGa3WLF6lScc02Op1aM7MIIw8XnijUqNSa3Dz\n", + "0jWGgyHVRgOExPEkqUgxHJuYhO3uFsONVQypyDIfK0kwMnj+U5/kypU7/PhP/FMW52ap33OWj/3h\n", + "h3nHd307HTNhV4VUFBhBzECmGJaJmaqpikVfIMuW2Tdipgtx+GevtOldfm55PHV+vvjMcZypezzT\n", + "nnuY6+1hXi/F9/X2l8Na6PeUrcRpHHrxvfK+lj4Oh/V1eSEq10N3Sf5GyjeCwH8d+L+A39Su/Rzw\n", + "MaXUvxVC/Oze/z8nhHgAeDfwAHAU+AshxFk1JbiwrkzKm3V6ybKUbM8DxDVMTFNBRo4QgMzKE4ou\n", + "OzVm7lpit9/Fsh2G/pCV1TUqVoVUGswszGMkKa6QdLq7bO/0EFISpxmG5VKp11GZ4g1veDOf/+sv\n", + "kyQJD9x/BmUI1CiELCOVEO+dLjRMA5Wp/CScyLlkZQhQGXryb31gCiVdoFt9kKch3EL56RseZeGY\n", + "JhBSFpMgP6xT3GM79l4CVxDSwLQEKJVHCylNKt3a0NGtjr50JSsYb+WWKRcdXelWhn5fGaVM4zSn\n", + "lUyp/SzpYo+7lYYgTWOyTGHbFV54+gXiIKHWbPD0xS9ipRG2oag16hBFmBmM0oS64+RZ5VdWOXrq\n", + "JPHQpreziSMltldHpBn+KESaFq0jR5DNOo35OXrBCMeqUHEqrK+uYbkmioSdzhZHjh0liiOev3OJ\n", + "0aZJxfCItnepphKVJkhp4WCAyOinIVt+n/e+9ze478QJvvkd38q5Jy5gBQkVx8ZSFikZmQTTYBzl\n", + "JU1RKRiGSaLAsE0ykUdjNwBjL+hVwqTFeBgKLETxsG4fn/IFEHvx5Mt3FYqxkIdcPgvQoy/e36iX\n", + "UdlS14vcs3z3vqW1YTodM83CzZ8zeTJav0+/X5fp8TvGIA4tEfh4wVD7vw+zGPRr/0UQuFLq00KI\n", + "k6XL3wG8Ze/v9wKfIFfi3wm8XykVA9eFEJeBJ4G/Lj9XR3r6YJZNDdvOzUkyRZYkqL2GG3sD6psp\n", + "AkG7F/Pm734bFz/xJe49dZqeH9Ku1KhJj53QZ31nnaZp0ag2WFpu4zZOkES5chsMBqxvbDIYDEiF\n", + "Yn75GCs7fT75Wx/gx9/zY9TjDraAUOZH/i3XwUiBKIEkD5IUkxELsC0Dq+QZIqXcP/JecM57fTux\n", + "sVkosyiKsCwr34SL4/3VHqbTGcUEGCMYPdPP+KCFflI0/944S4hOPejvKKMM/Z1lZV8W8GmeBPoi\n", + "of8uZKE8gYrPDzPnM5XviWDIPPqkKYnimCSNcF0bVIWXn7vKvfc8yG63iz/os2AK2PNzN1NQwsSs\n", + "2MzVqsT9DmY6Ih5scfHpG9y6co35+gwVt0aSJkRxTBpEhDWLxdOnOXrkBM8/9zw1zyEajhh0e6gs\n", + "RlgGftij23OI+wGDLMGdncVtztJq1OjEXRIlMBOoKAszS0lUxsi2OP+ax3npS1+il/ksPHyG1Zfv\n", + "YGRVGjMNNqNdTNuikiiyOEY4NiLJ4xPatotnuwyjgIwMVIpIU2SaooTYP1k8zfor5KP4f1IhTpY0\n", + "PWiZlYu+WBf/T6MuvpGiL/S6PE6+S782XjzGf0+6AU6Ty6JfdM+m4jPdoplGUeXP0sHnwb29PJRB\n", + "kdtWTCx6Xw+ZH1b+thz4olJqfe/vdWBx7+8jTCrr2+RI/EDRD27oZnmZDihOMBYdV3gXlIUhSRKe\n", + "eOQRvvAnf8FmZ4MkBkdUUNUKC615FqsunmnQXVsn6PdZ2djMBz1TzM7Ocdfxk0hDIgzJIBjiRwFb\n", + "W1u87zfex/e9823MVD0kAkulECQIQ2K6Nqi8E22Vx8uO0mTqIOjmWXFNV3y6kircE/Xd/WkKsOiv\n", + "goIoK1Kdd1dKTbh2FZuUQoj95Mz6Bmv5YI3enqJME/6iTochqrJfefFb3+TU5aJsGRws+WRMkgTL\n", + "tomigDRJqFaqpGnGH3/ooyzdfQ9mKgl3OhhKEagEVyjMJEUZBjgGx5eXmT1yjJevXqbVmoUsY3t1\n", + "FcKQUHWxazVsaRGmKf0gRJmSertFLxhheB7zi/NcfvZZkiTBVAKRKpJRyO7aFu3UZsE0cdM8r2U2\n", + "V2dzsI2TSdw0Q5g2tcTintocN3opz3/5Szz8xtdSa7TAdumY4EY+QZzCbIXR9jbHajOEoU+sFKEB\n", + "hmsRqpTM72MpsZ+7NDUkgZG7wZocRI26d9Q0y2ha0ZVNMSf168VnutIuLEkpD1qSheyWn1FGxcUi\n", + "P032dMQ9Vs5QoF69Pbp7r/6eslIvKJQyNVKW36/XT9PvyW1WvR66lfH15T4v/583MZVSSpRjtJZu\n", + "mXZRb9xBZHgQeekcma5gdMVjphK35hKLhPn2PKZwGPoRg9UOhmWBhEatSsWusHT0OOvrm/T7A7rd\n", + "Hhtrm9iuQ61epVqrgWHz6EPn2ens8lt/8Pv82A/9IE4KFhLXtBhFISEKJQUGAlMJrDTDMU2UPRl+\n", + "Vhf4aXGQi/bpDv5RFO0LWkGl6K59OtVQKLsiZ6ceoa94r45eClSvK0m9HtrYTozDQQSi9lFEuU6T\n", + "E2k8hoe5uOmKfRqiO0yQreLsgGIv1ZjAsj1GQcqtm7fZ2RpSmZ3h+MIRnrvycU4sH6E/3AK/hwpj\n", + "eiIiq1Q4Yjrs+gmxMFhYXGJj/Q6j3V2qhoEjMrqbG9SbLUzHwSGjdXQZu1bhxo3bVBpVDNvCcEzc\n", + "SoW414W9BT1OYzYbJp6haPk+C7RpVRo0mzH+yiaWdFi4a5koiZhfPoZ65goPvektOG84x5W1bU4f\n", + "rdNeXkRud7Btg4997pO85fHXcuX6Kovzs/hpQGJKlIgwpYFlgBmnGEqQCEUiFIHMqT5zrwv1DWM9\n", + "Fn6Z4jqsTFBnJUpm2ngViqlQqGWlpcts8V1dzsYpyzLtWZPK0TQPi899ULbLc0//Thno6O3T3//1\n", + "XAeFYGI+7N0xUZ/D5PwbVd7wt1fg60KIJaXUmhBiGdjYu34HOK7dd2zv2oHy67/5O/uVPH/uQc4/\n", + "8tC+4OgovLzhoG90FQpuX1GNfO45cw+Xr1/FPeGAMnHacxxfmEcmAlyTYegz6A3oDW7jBwG27dBq\n", + "zOA4LtVqlW63Q6fTpdfvYloGse/z6Gtew/t+7wP8t9/3A0TDkDCLcWybSCoyoUiVwshSskwRhckE\n", + "11heVXVlq7dL3/ATQuyj8GKzVBdaXag8z9v3AilQbPH84vv6u3VkXEyccjo33a1RV976+/XrUw/Q\n", + "TFnAXsmS0JGOjuzK1Ey5CKEQoviuRAiHYJTQbM7x9Fc+xrGjZ9gOenz+83/NzJ6l0l6YI941CHo9\n", + "giTEa84hK00ur6/jORVWVjfYvHWLhmVTt0zSICDwRwRRiHIc5o/fxZmz9zIYjRBSUm3U2FpZJU4T\n", + "ao06wjRRYUToh6goQcwbWJZDnKXIRFG3bJZOnKSrXC5fv4awLM6/9nFsBTVMvvCZT3Ky6XL2/guQ\n", + "GbRPneTirb+kuR1yrm/y8T/4KI9929tZEQpHWKASjCiPE97v96h5HhGCBIgzSSYFpjTIOOjNY9v2\n", + "xJwbI9qvn5GnbEUdZvbr89YwxlH2dEur/GxddsvvnK58xwGsxrI25vPLi4wu0+WFRwc85ToV9ZqO\n", + "wHW6ZpK6+ZuULz/1NF966mvf0L1/WwX+YeAHgX+z9/uPtOu/LYT4RXLq5AzwxWkP+NEf+kcTQlLm\n", + "toqGT8vcXF6BCyGw0owTx0/yxc9/hcfPPIofpvT8Ef4gxAwUvSwisSQNZeB6Jq7rkCQpQRQQxyG7\n", + "nW0c22Z+tkW71SBNYoajAb0o4My9D/Brv/lb/OC7v59gMMQTApWmqL0MPwpFZghs08bRJkLRtvKB\n", + "E90UnBbB0DAM4jjeD1+rT6ri2Tpa0umSopT7Ut8sKi8IRb2KZ5ZP0hX3Tdsl179fPLu8SaOP8zQl\n", + "Xp4Q5bYeVjKVQMErYmEaHvVala995Xmq1Va+ZxLG9Ld2cIXAVBEiU0ivRqps6p5LY+kYK6OYbhDi\n", + "eh47nS1G/SFVElAphsqQjk0/DohVRiMK6Gxu0R+OOHX0GCjFauBTnH2p1OukTkRKftp43m4ikpRR\n", + "GLDud9i1UkBSP1Jj0LXZ6HeJvvAUqjvi6NE5TJWxefEKteoCfnfA4pFZbNsifuEqr/FabIgh/+H9\n", + "7+f+h+/nmy9cYN5tYAyGmEmMVamSioxYZKTkeT8dJSGFOIsPKKY4jvdpSb3vX0np6GOpj7s+hoW1\n", + "dRBFJ/veU8Vn5XMExd/FhnlZbstyUlBoBxeOjMKfvfyZ/r7yYlWACSnlBKjSQdG0RWQyDd1B7xXd\n", + "AjksabQQgiefuMCTT1zYv/Yr/89vTr0XvjE3wveTb1jOCSFuAT8P/GvgA0KIH2HPjXCvIS8IIT4A\n", + "vAAkwE+oQ5bxYkXW3eB0BK4jAdu295VYUcq+qEopXNvl3nvuZWV1g5Ef4NXaCNeFUUIYDFjf3sJo\n", + "VsmUSdtycFyHdrOFYZj0e32Ggz5bQUAax1SqLvNzsxxZXGTOUtxeW+Gh84/x73/91/jpH/8xIj/A\n", + "NW1klgIKYUnCNCZLIojGpmGh9MomYBmhlo/d63G+dUVWVmjFBCz6VFem+uZU4b6ne8Dok7Tsc6s/\n", + "p4ghnlNdYv95hV932XVvbGaOY4cXz9fpr2LcCmQmRHECcLJeRcKPaSX3N1YgJUJlCGFQcWr88Yc/\n", + "wmMXnsRxTJLdXVqWiT/q45mCqOcjanV2DJdjx+/jvgfP84VnX+BUq0HY67CxukYNgWta2KZAOBY9\n", + "PyBFMdNuUa3XePFrz2CYFkfa86ysruJ3urhCQByDZSBsG7dlIS0Pt+KysrGKU/G4tbXBa++5m/kj\n", + "y1y8chlzqcXWZgcjAykhSALe9oY38ofPPMdxWxDtdBmtbnH+sXv5zPZnqM+7nDtxD8P5Rf78S1/k\n", + "9uVrvOf7vw8bgWU5eBWPIPHJsgxLSGQqEVFKnKakMp0qh0UYgkLecmWrXkHJ6GFdJ/ljHQDoG/aF\n", + "HBXIVKcMddnWg60VMqbz4zrdo8tPmub3x3E84aqahwWYzJQVx2OlrCvv8oa+74fYtr0vu6Y5yduP\n", + "+2M83wrgU4TjLeS/+KzIlKXUpOtrUbfy/D3MfXb/3d8Iz/Jfuggh1F/96e8fQGU6daKvumXf4TIX\n", + "XAxCGKWoWpU/+pOPEOyMuP/cBUJh4SmTmnCxGnW82SZJd0gYbZOkMWGYJzkwpIHnulRcFykFSRwR\n", + "+EPSJEWaFtKxCEVKpGL8QZ+//8Y3IgYjZBwhhCKSKZHIsDAw1ME8l7rA6pbF9FgUcr+tOhrJsmxi\n", + "w2cad6ej1+IenT4pK1odnZctIG289n8XCKp4tm4F6O3Lf4wDddXLJOpJJvpr/L5xwK37z7/5wDOe\n", + "+8pfgswnRNVt0O/6fPFzT3PpxeuY0qE+W6d/9TpJvwcuEMTIzOSm78PSEc7c/SBJLOiKjPPH61x5\n", + "4Xk2r11B9XdQwx411yQTGZGCyDC5++wDxAg2Nzao1euYhsXmxgauZeCaIo8HHodk0iRI4N5zj3Bk\n", + "eYHnL10kVgleonjwrnvIbMlOFvL88y/QSE28zCRWKUY65PGzD3FrtYPRXuTe+x8g7O6wdKzNiePL\n", + "PPtnn2Gxucwt0+BSNeGlzVv0tjd59/d8F+2qh02GkWW550mi8tg+SiFMgzCLDyDrXElPykuBFJVS\n", + "XHjttxzo8y995iP7NF0+7mP0fpg+Kd6bppMxQOBgJEHdStPlsgxeJuuczyM96mfuQjvpEpv/MFH/\n", + "4n7dsi2K4zhEUbR/MKmQ9cJi0eVbV9blhapA3VIWwM6YUND6vNOtX8MwuPCat6GUmmoSvWonMceB\n", + "oA56MehmF0xyrkWDixVe90Zp1JqM0oRve+u38O9/6Ve5zwAXwcbqOqFbo3v7Js25OVzXpd40ME2D\n", + "enMW13EJwpBer8fmTgcBVCsOrdY81WqFnc1dYvLQpNv9PvNzbf77n/s5fuUXf5He+jpZHCFsA8M0\n", + "JnzAi7YU9Z/Gremc/rRNRz0++rRA9dOiERb3wuSO++HCLzQhO+jaN14E2J8QxfN0ZFOMS/G/YVgH\n", + "zNPyZuVYiP9mUdj2i8yTXhuGxaA/Ig4zbly9QRrFWLbJYGuFzVtXEVFIba5BFmegbGqtNo0TdzEK\n", + "A7bXdzh1/mGuvPhVVu/cpG6bGI0GoyTGVwlhmhGkGQtHF2m029xZWaNaqWBLydbGOt31DWLLpLbQ\n", + "xjIl1VqNhbtOMcwkr3vLW1icbfPg44/Smm/z8Q/9Z9ZW1zh7/iF6/W2smkfaC5GGxFCwFvh88GMf\n", + "4R8cf5TNr36R5MgC9XMn6cYBfcvg6KnTdJ+6wj2PPUJUi1leXuTO7ib/8n/9BX7hF/5nWk4Ff6fD\n", + "QrVGmgX4gU+11SCIwgNJuHP5meZjPbn5Vy6O45AkCVEUkaY5TaEDMMMwcBxnH3XrHk06oCmKPj90\n", + "eqWY22Xwo5ex4ss38AvEnD/ToMhCVFgZud6wDuic8rPL1IxunRTPg0l51y1epdIJoAN5GknDkPuL\n", + "iJ7dqgCmkHveeZ43ce2w8iqmVEsnlI1SasIsKQShfExbn/xFKf72/SGWaTHXbGBXbUbBEIIB87NN\n", + "avUZGjMNurtdBipiOMr2Om8HJQRCSKqVCl61RdVzEUIxCkJ6gx3SICbJMgzH5PSRk8Qq5p3f8S7+\n", + "3a/+Kv/we95Fxa2QxREyk5hSYpS4waJdhYAWXjfTlFWBFIr7i7jc+ue6wp6WxKD4TOfv9P4uI119\n", + "E1Kvk5RyYgHIr2cTY1bcV3xP35zV/y4+LyZO2f/fsg7mUCxP1mlFShMhTYQStNttPvbRvySOIo4s\n", + "LZJGKTevXMIwMxqeS9DvEqUZkfSoLyyyUKuxub3La197jqE/5PrKDUQSkgmBbVrYtRq7/Q6jVGF6\n", + "Faxagxu3V1BJSrNdY9TvM+x3qbk2jlL01tdZWlrkrmPHmVlcwpiZpVZv8My1qxw/ukxnfRsbgySM\n", + "WL12k+pMlbc88Rq+8MnPsrmzQ3eng20JZqpNZMVkN9jkzs1LnLq7hWtX6A58mK2xUROojRVk6LK7\n", + "GWJ7Fv/kh36Mj3zkYxxdWuINj51nY+TjqAyn6hEnEVEcYlvOAeSrL8Z6f7/SIiqEwPM8TS4mPcqy\n", + "LGM4HE7Ixli5HfQ20TfOi+vljWyd8phWyrKYy5+FvhAV96TpGJzon5UDrBXv1Rcb3VlAl9FpMlt8\n", + "b8ylFz8ZaTp+f0FfFUxD4To9LRVbubzqCR1get65okOKI/c6naCvnPqgWq5J5kcMdne4/9z93F69\n", + "xYW7H2B7p4sfh8gw5f4z99GXCaaoEkUJa2trbO3sYEiD4SA/QDPbapGmUc5zOxYmgjRJyKKYcOQT\n", + "GwkpMHvsKP/2V36JX/j5n4fRCDX0J2LDlbnkwvSCcXIF3WQrBkzP5KPzhMUzdSWn84NlJF58r+AA\n", + "dW8THVmXn1HUoYzu87Ga9DMvng2TE69sUpetCCi7TqYH2qa36TCFEsUJArBMh7XVDT776c9y5q6z\n", + "bK6vMdeeQw36pET4saJhmfhSMsgSahWH2y++QOZaBP4MweoGKvZxDZPI97EcF+G4eMYsSexTbTSI\n", + "lWDQ7dLwKvSGfcJwRH6IMsOWEgsTEcVs3rqNnyhee//D2IYJ0iDsB3z1s59nvtXgdW9+M3/0R3/A\n", + "6173GsLdDkIKgiigogyMfkStUeXZzWs88e638pnPfZ67zpxi5vhpdlc6LD54hva3OrR6MU6k6Gxv\n", + "IaVDvxty/uzDdMIhv/y+3+Yff//3Ii2JkcRYcUzVcYmzybCoOrWm93n+9ytsHGu0VjH+eugFKSWu\n", + "6x6w7PL5PN4E12W/PM5la7CQhbL31nhhUBPhK8YIe5qHjJz6bJ0W0a2Cct3KDgBFHYIg0GiUMf8d\n", + "huHec3MaRQiBbTv786EYA90jLIqiibSGh5VXTYHrpkOB9HSFUzSq7FNcXvn0Do4Dn6rlEGUJd999\n", + "F9evfYr5uTau65EIAxmmvPTSRULXwh+mWKaNV6nw8EMPIqRBlil2d7YJQp9erw9pipA1UimpVDxM\n", + "KUEogjTAc6ssnzyGMCX/8b3v5d3f/h00bRuSlDhKUBIQYAhJtpdEGMNACSBTJFG+6gpjEnmUFy1d\n", + "mcNkFvZpMYnLForen/mGcYF4C2GfvoGpRyjUr+dH1Ccnnj4Gel2LjZrD9jaK+/NxJO+j/Qzqegq5\n", + "w2NdJFECUhJEIR/8wB9CarG106M/GGAg8Qc+tbkmKuiTphlRGlNvtXBtydbqNmazyvNf+RLhxgae\n", + "Y2LbAstzMTGJghBpOcwuzHHsrpOs376DMkYYbo3BaJOt23doOx71iofMUirSJQsTLGXQ3d7lpRcv\n", + "YjSazC8ucf25F2h6FV689BJHHzjJd//g9/Gxj3yE2XYb2zLIgpCWtLA9D5WkDIhZ6W8T9Po897kv\n", + "Unv7HEvH7mJna5dTFx5i9emLDNZ3qdoW/cCn6nl0d/ookfLYI4/xf/zSL/OP3v1fc3p+DtepEo98\n", + "LMcmVQphiHzBzBRk2V44CAOk2LNGBfIVNzGLk4/Z3lhN38/RwcJ4rh8Mv3rY/+V4PFmW7Z9h0N+R\n", + "K3YLKcU+nTNWvgcpmvze8bzTZbdQqoW8NRpNsiwlifON/CQdz78sy0AVG7mKarWay2SSkGVF4Lni\n", + "VGtufRSx/i0rmqBHi/YVFndhDUwGqTtYXjUFriuGokzjaPX/dZOiPIhSSiyREskYTMl8rY6RpNxa\n", + "uY1MDExhMzu3iHmsgnAc4mTIaDgkCHyuX30Ox3Fo1GeouiateoP52Tq9bp/haIifpPhZgGM7zNQa\n", + "NCpVQCH6isfOXOCZ6Cs89eKLPPLoIzSSFNu0GKkYy83DhtpCIg2DUMIoiZFC4JLHjygrQ10B6yak\n", + "LmRlt6oyn1f0iS4Y+fNy97XJPhQYhnmgv/X66OM0RswHIyceDEY1RjplDlMf93wCFl5GBdcuD7xv\n", + "WrGxMNwaf/7JL3Ll5S1mvSa15jJ3djpsXb1KNhKEm0OUjNg1MoRQHK3XIPRxTMWMZbK1s0Ovu40t\n", + "DNRsC6/RhGGGk1kMY4VRaWLMzOH1YyyryYiY0epN6qGgGgWYtZS5U0dRYUa01sPE5ejxk3T9AVG/\n", + "Q9DZ4vadmwRRwNXb1/ihUz9KFIccPXmUnfUN2o0KnbrJIIxoRQZJkiIcm5cuXubU3HH6V1dY3V7H\n", + "ePwMwncIr25jziyRBhF2OMCpSFIX7CSjoUz8nZC3PfxGXnj6Mp8bPMX3fse7aFcqJNEQYUuiLAKR\n", + "YYoMA4WBBCVIMUgw8lybWcwUkdgbE3PCpc4wph9cG99fKEu1T6Ho1nSZ+ivKtIQi5U38sWdWQppO\n", + "7pONAcG4DgUC1wFi8V5dqe/XL03JVIY0JI7hYCt7PxdpuudpojJFkhYJwidPkhsGSJnuswymae/x\n", + "8dEEdZSm6T7iLiwa3Qo5rLyqCR3KB07KK2HZ3CsrfR3BSymxpEuYpDhVl5mGw4ljR9jcXOOJ84+z\n", + "dmedly89h+V5hCql3ZzBsR3mjyxTqVQY+T6WadLt9li5fYNMKaqVCrOtOpXGTI7yRj5RELGzuUV/\n", + "0Kc128QdObz+NW/gP/zHX2ZmZoYHT9yF7/vUKhVGoxHSEMTSIA5DhBTY7JmBe6c1JRwQyDLnr5uF\n", + "OhVS3oTR+0bvn0LRFpNHf64QkmzPP1jv3/Ix/kLYdDNzvDAc9B3Or4sDil5fVHS6pMydw8GY5NNK\n", + "vdUgigWf/dhfYjpVfBXRnqljRTGGY5M6NtJUhCkkUUy9NcMoTBkGHU6dPEkYjNhau40rMxKlGA36\n", + "RElCo9IC16TqOZw6eRcbGxtEgc+5Bx8gTmM6JJjLQ5Q/YKe3RdwPmKvNELZNkoqFmK3RXVtnBosv\n", + "P/0sJ+45xac++yl+6Ed/GN8PkAa84Y1v5IO/+wHcSpX7HniASy9dIiRGWpLAD0AKjCOLVEwTWwga\n", + "WKQVm9WNDnefuQ83CxkIwfXVFSxb4Mw08awKSRjRkhlGb4e7T53kf/wffpb3/JMf4e57jmNFETUp\n", + "ycIYUyowJYkQKAQqy3JUDqhXOFxdpjF1OmXMMx/cuITcstP3ZnQqozy/Jz041L4Vqd+nK1ydUtEP\n", + "t5X56cK61PWI7hBRuM3qsqkzBDp42vfE2XOHLp5X9JFhGPt5W7Ms0zZ3Y4Q4yPcXNJBOK79SedXj\n", + "gesNKJtSxWe6y08ZeeoTWwoLCInDmEQolpcWefbp5+h0t5mdbzC/3MZ0XMI0ZrTjE4URd25cp1qr\n", + "YUiJZVuYQtJuVPA8D9M06Xa7bK35mLaNFAZVt0L72HEMQzAYDRkGfdZXNvjhf/zDfPpzn6FZqbDQ\n", + "bBD6Ea1KjX4wwlcJ0pTYWZ6MNlUQCoUUYGSTwYXKYWgLZFsUnZcu/i/36X5/aAsDsJ9rszwOBVIu\n", + "0zD6z9gFMf9eGTmVaZJ803SM1PQxLdMyeh2L9pY/O0yBZ1nG777vdzjSaJI5VVIhuHb5IjOGgfBq\n", + "mFUHYQp6/oBqq0GtMUOnM8BE0huN2Lh9jaolIQkRpksah8Rxgh/E2I0GJ+86jWMaEAU8cuFhXGmw\n", + "e2MNzzJpzM3S9JZxbtmkSUx3t4OyXO47/yDXu9vY0mD9hcvcdfcxXrr0Mm6lwhve+AaCJCSTYFg2\n", + "b3/nO/n0X32CGMX80SPcuHYNI81wHZtGo4Fs1rj33D1ce+ky7bvuImjPMFIweuYZ3nDuIZ67fZsZ\n", + "LHZ3+/QtycAaIeM8wFqz4jHo9vmf/sXP86E/+zDb6ZDH77kX264w6g6xqx5RlpEZilTmLocy3fOJ\n", + "ntrbedHPZOiLcdli0y2usRKdHvtdt+AKZVr4fOsyqMuYLkdhGO6/Uz/UVk7IoP8U8614tn6oqVDY\n", + "Y68RnbotFpLcYsy57ZQkyQ68J4qiHMhpXixSShzHnlgoLMva98wrz8NXKq+aAkS5HNgAACAASURB\n", + "VNcHUV/ZyhO3EBY9mQFMxiUo7t3tdPBq1bxDDMl9957l4nPPstPdoj+06Pf7WLaL5bnMuHOcOHFi\n", + "//nDYZ9er0enu4thGIRRRrXW5sziKaLUIAgiOjsdtjfW8f38oMTsXJv2bBNhGWysbvLG17yeT33p\n", + "03zvd34nchQxGI4wbItIxdiOhR1nGBmkKiNOMxzLwtI8bXTB0hWxvriVB7Sc+09X6LpJqHuhHFb0\n", + "9xZ0VdlX1jAOUiBFvfXIiUKI/QlRRubTFojiQJeuAIpDHK+EQrbWN7j+8mXOnXkYe2GB2JTc+OLX\n", + "WGjUSC3F5vYGSSpwmy3uu/AEvWHAWvcyzWoNjNxbIh4OmKmYpI4BoSLLYKPfwXIkS1lAxR8x47nM\n", + "zTbxMLj65S021m/jex7u/EJubUUhV+7cYenUab7ywvNYnkP39joPLC1ybXeXrzz9Vf7Vv/kFUgGG\n", + "ZZKoBMt1WDx6lNe++U18+Qtfwg9jjFYN5QdUDBfbMtno7XCqYqCiiOGNNbxWk6jiYfg+F59+hnDo\n", + "YwUxs24Fs24RGIJsGLE0O8dApSxWHbrb23z3d7yL3/iD97Py8nW+861vZWlhiSQckiUxhiLP+yoU\n", + "ytiTr8PDa0/w0GXXujJFNk1p6h5Yk+BgHKunyIajW9hlNK7LlOu6+3OoULg62NPBYnGYpvhMr2+Z\n", + "A5dykhHQPUXK7a3V6hM0og5Mi99F231/OGHp6m6/Ot0z7US0Xl7VrPRlhK1P4DGKkxMN1AWjbKJZ\n", + "lpX702YZSZxgSsnc3BxRFHP0yHGWl48jpcnA90l9xe07K/k7hMCruJimRXt2dk+gFGEYsbK6Shxn\n", + "WJZDvV6hXvMQKqce/GDE7vYOwgTTMthcXePuk6f5hf/tf+efvecnkJnCSmJMUxIHEVmSYUlJJiWG\n", + "FGRJSpglE9TEtA0+vZ06J1woSF1I9P4tI5WprmJjmnC/6II2qfBVzs9qyGCaJTWeqJPJb6dx58UE\n", + "0tGSboYXLo6Hlc9//FOoIKTX7yBUglVxyRIf0zUgjEgNSZTBTGuRUDms93osnboXU6VcefrLDP2Q\n", + "pldBECOFgSQ/ZOF6Dk6jxvbmBtvXb3H+wgXsNOW5rz3FXbNtkoUm4e4ug34fx3MYJgGt+07jtGbp\n", + "3t6AIKbuuGRVm6ee+io/8dM/xekz9xDFUR4/J8vAEmQqpdFuE6WKWnuW+5fnWL9zG9EZIlJBHIV8\n", + "/JOf4O2PvRkvyejdWuFS0GMmMKkZktc/+QQ3vvgMfhjRiXoEromjDO7cuk1sQmxKZAaDwYBve9Pb\n", + "2B10+MBHP8r3vOvbabouZiiwVIZUGYnKSEQK5CGJD1s4dVRbjFcZfB02zvk+DBP0RnFPIXN66Igw\n", + "DPcVarHIF3pCf58OHsoblLp1l1MTTMhuIZv6/Br7aMfIvbMGOU89Rvrjwzi5v3mx8ai/twCfZZfF\n", + "/OTxGKToNKLOLryS7MPfAQVeVLDsbQJ5QwvXHH1QivuKVXbfdLIFUmSYjo0jBEjJ448+yUc++meY\n", + "dhUpHOqVOo1GE2/ewzTzHd4kSfBHI8IoJI0TXM+hVqvhOA69Xo+036HX22Fraw1TmjQaTRqNJvPz\n", + "bZaPLDLyB2ztbLO7u41yLX7gB/4b/vCjH+Vd7/g2LNOGIEAqmSditvN3OjKPoKfEGL3C2DLRXbX0\n", + "fimiFOrIepr5WvRT8VmOHCZjqIw5O/a/pwteManGJT9dmd+rm8nF8WoDPZdima8shHQaNSJlfhoz\n", + "b28xrhLLKlzUppuS11+4RM326A66eFnCypVN/H6fykxGXZgoy6FRb9JaOMLV2+tsd0c8+MBxOhur\n", + "pMLAdD3CUYjrOag05+0hR1PVmRZmBkuLy1QyuP7cc3gopO8TZBFexaM77LM7CIirNvede4gb124S\n", + "hRHR0Me0JB/4iy/yT//5z/LgI4/kMbrJ+8q0DOIkIUxTbMejvbjAztY2p44ew7ZMbl68RLA7wjNN\n", + "nIrFzu4WQdqj29nk9vY6cW2WdK7FVneH1sI8qrtLwwTDMRCpouq5KMtC2QahH1JzKgxHPkfnlzEr\n", + "Hv/Lv/s/+Zmfeg+ztgMIPMOC2McAhBSk2eHKo2zJ6a5wxU85rnwx3kmS7W825h4aBcgQe/7ZxRFy\n", + "c0+hFYgbLOtgncYKc3KDs5BxPVpn2TuqPFfK9KwQgiSJUSrav9c0zX1Fm7c1P/GZK2j9eP2khaAH\n", + "pMvlPp367sk2iQOLZbm8qhRK0UllgdAn9jQuWF99LcvaVzJJmrvgqDQGBMowsW2bkR/Qai8Qh4qV\n", + "Oxus3t7Bqlg5520YWLaNYUhM08BxPTBMOv0hYjAiSRJsx6I9e4SKVwNg0B/gj0b0eh2KCEa2ZXL8\n", + "+AlGYciw20cZFi9eu87502eoCANDCqQliA3I4gQrynIUZk7uehc70OWi95XeP9M2CXXEO2k6TvqH\n", + "688sJl7Zk0R/tv5e/drYJBbo2cz17CvFd6Z5KuTvPxhHHdS+4tbNXr00qzM4XoXV/g7J9haj1TUi\n", + "A26HIW1hs1vxuHDvg8SpIvIj2q0Wd27dYuX6JcwkojHTIhYpveGAVI1wDYswjlk+eQKv1mDl2nW+\n", + "+ZseJ+j3uXjxRZrVCo5dpTXTYJBGbCQ+fhJxduFerjz3EsNRRK1eZ3s04uUbl/mpn/0ZHrrwCHGa\n", + "5vlz8vVhr+G5XPQHQ/pDn6Wjx9lY3aJSq+E2GyT9gKrtkRqCi5de4k0PPU53a5v09hrD+Qy7YjII\n", + "fY7PtTCrLjYxz9y8QioliQzJhCRVAiUgGIyo1aoE3QHRcMhP//hP8lef+CRvedPraHkeSoJUgrrl\n", + "EMVx7vJ6CP+qnz7U5WzaqV997AsKQpefsnzr3ykCwI2twYMeW2WlrM+HsqdLId9jEDI9QYNeN8+r\n", + "Tnw2poPyuDvje+We/MsJEKbTMfq74jjn0Mt1LffJ3+lNzKIUlSxPbn1QdQWl/+i7w7blIDJAQ2vN\n", + "eo32bJvnL77A8aOnOH78GO3mHMPEp9vrsL29TdpLcRyHarWKQtBwHJIwIghGRFFMlgzZ7XSR0qBS\n", + "qeA4DnbFpT4zg23b+L7PcDgi8CMcy2EQ+Jx/5Dy/8zv/idl3fz+n5uaxLYM4TcjzB4ElIBbkfrla\n", + "e/Ud+vImUNEPxX069aLfU0bYOlooC0l+79j8LUc1LFMg5Wu69VAeM31Tuvx8fbzHpm02wWPqpbzB\n", + "XZRBlDAz38Tod/C7PeZrdXwzYxBGdPsD3LkWuzs77HZ8Fo6coFavc/3aJSwVotKIFHBrTRLDZdDv\n", + "sjkc0V5YwHQrbK9vMVNt0pppsTMc4WbQW1snsSzsLY+eAyMX2gvLXHr2IhYW/TDiwSce5eqdG/zk\n", + "P/sZzj/5CGGc7qXbI49ameW/4zim2Zzh0ktXGPo+zTRja2sHuSs4e/Y+bgcZnTtrDEZDUPD0xWd4\n", + "86OvY2dri5euXsadrXP95g3WjRXOnbmPU+0lNjbWWA+GxBKa1TrBKCCRAstxCJIIMzOZtapsXLrB\n", + "27/pW3jfB3+bb3vHt+IsLeEBw94Ix7IQ5uGnHsunc8seRcV462NX/F9W/jrtUbYkx/I5edhGV8rl\n", + "5wghJugWHaiUUbEuU7rFO/n+yQ318gJRvD9fZMZ8dnnelPvGNA2y7OA5ibKyP2wR3R+LV/z0/8cy\n", + "rYJlgSmUlc5JFdcLZaCb+yqTqDSFNAORO9djWdz3wD388Uf/gieeeIz1m+tsrN9BmSaNZpPTp09R\n", + "qVQIghDf9+n3B4xGI0ajIY7j0mg0cMwGAgiikDDM2Nnewvf9XJHbNtKQeK5LtVrDti0qQtLv9fn5\n", + "n/uX/Ol//jDzb3kzFSUQhshP+gU+KWCY5j6CL/qk/Hd5AMuWSDkQftGHulvUeBEcH5CZRNIHlWN5\n", + "gugLaZnzPCxegz7G5YVIr2/ejklvmnLWlMOQyMbIZzZT7KxsUktTUiKIFI5jE3qwNNtGxQF+Z5uh\n", + "YbB2+UWGww41T2J4BoE/IhE20q7h1iWiMUPiufTCmDRW2FWHWyt32Lp5AxHF2AgGwYA0CMGu02y0\n", + "WLt8nTnhMegMWDh5DGGZZAY8/uRjdPwu0nTz9grI0oxUFe5pJqORz82bN2k0mqSJYvn4Ce7cuEHY\n", + "H2FVK+yEQ2wDRJqxtrnK5uoKDxw/wZ3eFs989SvMLC9x/JFzZKZEdgbMKou+YTAwDeIowkgVQkji\n", + "JMrpwVodU5ioNGX9+m3e+ff+AU8/9TUqT1rMOBbzM3WGIx95yMGpw+SjPDfLXip6uIxpSklXjNOs\n", + "vOJHD9hWBnL6nomeDKWoX3G9ECWdZinL2Vi2J+WwSByht62g+8oOBHr9y3tbaRrvuzMWKF23eA3D\n", + "wLbtv7uxUMocuNoXagN9A61YFcsdMk3ZZyo3ZQwpkAJSMtI05PSZkyQfGRHEPZaONJFZi+4wJoxj\n", + "1lbvYNk2ju1g2w4L87OYhslwNCIIArqdXYSwsCybaqVCtepRqTWRQuIHPt1Oh1F/gO8mpKmJsHxs\n", + "UyL9hM/9xadotds8d/US5x9+EBmGCD/CEQbCEsQqIz+yOUYEOm9XXC+nkNMHtYxGpm5UUnikFJno\n", + "J8Np6ohZRxpFncp9L+U4TvI01FKUaXSP7iapb7CWg2LpQv9K3jP3P/k4l556Gk+YeLYBWUTc69Hr\n", + "D7AW5zDJ6HW2qdsGZjQi3F4hGO5i1h2azSZutUIQQZqa2LUmS6eO0Vic5/aVq6T9gEqlzktXLrN7\n", + "8xZzlok/GhC7ktqxBXaHfXqXb2DujkhlzFvf/q0cf/IClWOL/NVH/wTilMzM9zkked5KpMQUxb5P\n", + "xnPPPIvjeNimg+u4DIIRp06e4tnPf4Hlk0ex203CnR3MNKVZq3Hx5ed55P6HWV6Y5dSx47ztbW8j\n", + "rdpsPHeZFz//LMdPnKBRcemmPoa0saSJrxSuZYMpGfojTNNCCEnUHZIMfN7yyGv4wue+wH2P3Ieo\n", + "unh1h2p4uAI/7ATwNDkswFcZbJURell2i+focYTKMYR0Ra7HEynu1/WEjmyLIGtF0R0Iygi7DBym\n", + "WaN6nXUng2KxKW/OT9NfRR+WFf7fWQqlfALqsPCOZRJfiPyUXt7Igq/dix9iuEghMQwwUAiRkApF\n", + "1XV54okLPPXlL3D25N0kQUyjeYSZeo3KQhXDMBmOhoxGAWvb23tK06LVanF0cQnbqzMcjugPBmxt\n", + "bTMYDnBsm3qjzgMPPIRjO3Q6HXZ3dxj4ffpBQM2ycKTJ3WfP8v4P/x5ezePCqXuwRZon35WSLM3y\n", + "pBAlVOo4zphO0cxBmDydVjYvCxcnHankPqrjPi845UnO7eCmoo6GdKpD9xoyXoEnnTZZ9RNmOlco\n", + "pSSOwxJllMcGzy2rPa+NKcWr1wjCkKbpILKQGEAY1Gs1zNl5At+HNGN5fpFbV6+g/D4LTQ9FzOb6\n", + "LdrzR7HsKo5wmF8+QuPoIt14xNFjR5k/fR+3Ll/mzu07MBzgWiaj0QinNkNfKZAGdpyx5Nb5ptd/\n", + "ExuJ4ubaKnfX6zSdBsPdAXEzxTT2zOpiwdprY78/YGdnh35vRHtmljAcUJ9v0bl5m4cfPs+nv/wZ\n", + "zj5wDytRSNId0B32SXzF1u42TqXC33vr32d2bo6rO2usrq3SkCZyFNKebdHLBPEopmE3UFKRkGEY\n", + "JngGCQLP9nAMC88wWHv5Gv/VO7+LD33qT4nqNsfm56mIrOycpE3C/Pi4SjPQ/LoLgFCAjlw2CvTM\n", + "AbnTFVYuF+wnRwF1IIx0mV/WQU4ZuY+BR3ECVN/sH88ffdPVNM2DHiPZWOewH1cFsjSvY16FfI7p\n", + "dSvaWsyFvF7s94OO3nWQtM8mlCyDw8qrehKz6Ggd9enuPLkiiibuLSKf6QOWd5xAiARE7sKaAioT\n", + "SGGhfHjra7+J3/jN99J+Yo4kTemtZwz7Qzqmj+XkcSAMQ+JWKyRJiilNglFEv7OKaa9iWblJc/L4\n", + "HErNopRiOOizvXZtvw6epWjXW8RxTBAnmFS4fnOVb3nLt3H71jWOzR9ltlFBmhlZlmDK/CBz0Z59\n", + "tLAXG9vYS4WFUGQqQ6npOSWLMv4soziKYZr2Hkede5AYxkE6RFfaxU+Zf9evjzeDDnq+6HUrK3Dd\n", + "PCzoH/2Z+Ribe88r0slZxFmMKaeLanjpNmdnFxEioTPs0PcNtmNBs30MkgZrw3Vcy+Pl67cx/R4L\n", + "VUWW9NkJIkIMAlKMuEM06LM96MCXP8lg8yZZxWZoWEg8Zi2Xu5bn2A26MNPAqcxgjVo0Z+oYbspS\n", + "ZHHl+Re5pgS3r17izm/9PqfcI9hGHWF3SOIICwu1F+MlS3NF3tna5tbNO8wvHCFMJK5XZXWjx9zy\n", + "CdJuh3uXTpKtdjl24gRXb11neGsbA4/P3brF9/+rf4FcWuLGxho3r1wjGUS02m2sKMXZHrJspmxk\n", + "CbtGyPoopt2egWhEnMUYBgyiIZ5h4AeKRsPj+aef48zx+3jmqStEp1OMo22axvQ4HKGKEZnAVBKp\n", + "IEqDiTk9dkMcK80CcBWAYgK1ColAIIRCMFbySTYGAYUVqu8R6bInpTNh0Y29UQr5LnJyTgIVHSDq\n", + "Hiv78ir35hTFO2Ec/4S9ebU/A4sZMDE/9bkxrsPkOQ19fhT116mow8qr6oVS5lOLDBx6AJcoivYH\n", + "JkkmXeDGSr24Nhlj2jAMlBCYtkU8TKlUKly9epXmTJN7732UilslThI6vQ6dXockjUnThFqtSqvR\n", + "wjJMer0+u51tut2cUjEMg1qtRqXi0pppUa1UUErh+z6DwYDdTic/VeV6zM40iZKY3W6HY8vH+PSn\n", + "P8M//O53MUpiBCKPWW3JfQ4sTRMyle0FxcnRDUIiEUCGjomKNialI7zJXuAs0xxvipTN2zLHWEZF\n", + "xeqvb66UUUXxfSiC9xxcfCf594OnLnWEUgTwKu4rDnKsrq5y9OhR1tfXp8pRd5gw2O6wsNDEEhLb\n", + "EFw49xCWN8ONm+vUjlcIVzoMN28zP2uxNdolHirSyCIzJUGoqFYaNGuLGGca3PzSNl5ljsFoh9kl\n", + "j83eFnFtmaudAbVWC9fJePHFL2CbS3g1iW2MGHlNor5kKzVZ3R7x7MWv8IYf+QH8yi6jCFxlkGYZ\n", + "hhQYmnud67nUalV2dndZXq4jpaTlVagbJpESXH3pRRZqFWZlizMLR1mLJTcuXud7v/0HOFufpdsZ\n", + "8MH/9DucXjjC6eXjRJ0ud3q7LPgZxxfn2Vy/g6h4nD17N5u37jDvVYlJyCyBaZlYpkSkGY7j4Scp\n", + "iWVw+tRJXrz4HEdmHiWZnkOAcOhjSAOkhSEkxp6izxFjbr3q3kzj8TZI9/zsDcabiGM9ANnePC90\n", + "RJk/niZL+iE1nWrUi26pFvpj8t0HwYZSaj/rlE4N5bTQwdSFuqtr2QNsWinTpoV1WxQ91Mhh5VVT\n", + "4OUj45B3RBiGhGG4/z9wQCnrRVdIxf8TG3tCoAIfr1bl3rP3cv3mDe6//37WV66RpCkKiet51Cou\n", + "lm2Tphmj0YhOZxuBIo4jarUKi4sLSCno9/uEYUCSJKyurJAHr7exHZsgHOF6FRSCMAqId1KCIMCy\n", + "bWzTxHMqfOLTn+LR8+cwTAtDmpApDFMiDYGFiVIZURTu0wfSMFAyD3ylo5lpPJkQRTLkws1JTPCG\n", + "BfV0ODoYC++04P9lE6+8GBT3H8Zd68gcJieoEPnBiOK+AqEfOXKEMAxZWFicKkdxNMCtVdju91Gm\n", + "xJlpcvK+e7iztsX5Jx/GT3a5ufoc7ZlF+uEOgyil4boY0sFqzlA7fZJ+t48XCTZuvUTX36XqeKRZ\n", + "k2A75nRtmYXGMmm9yc1On6RvcNw+x5BVdjc7NNptNmybyEkYBUP667e5/+4jPPamx1A1GzOUmJmB\n", + "IfeWXzVuv23ZdDpd2u0FPNchTWMMx2Q36tMPO5x+4hGufe2r9G71cVo1WGxw5vTrufv15+htrnP5\n", + "xUu0I6h2A5JKl6EI2VVDOlfXWO7ucOzYEtdjn1s3L9OwPOLAJxaKOFZke0gyDAI810WaBkGWYFZc\n", + "Hjv3CL//wQ/xjrd/69Q+N1QGGYTpHgVAAQT2YviTIASYhpXTLWmeFg8hMI08nEOaZcRJHjDLkJrP\n", + "uBB7flp5Zx3GtxcyWFbauryWNyR1nlt3jCj+h8lzFQXlV363Tm+8Ekgpgxi9lOdCMV908HMYPamX\n", + "V02B60pW94GG8aqaJAmu606srmVFoZscxfXis/0V0zTYWt/g3Llz/N4Hf58nnniC9myFWqVOnGTs\n", + "7vYIRkMMaWCZJvOzs7iuTZyEdLtddnZ69Pt9sixH8QsLCzTrDeIkJPAD1tbX/l/m3jzYsuwq7/zt\n", + "vc98xzfmy5dTZVZWZo1Zk1QSoAmNqFFrACEZEWAEmO42gQnb0RFtYUfTJhocwWTobsRgBMbYEkhI\n", + "QsJCI5pAElKVSqpJlVU5VE4v8413PvPZu/8497x33stXQNiOEOefd4fz7r1nn73XXutb3/oW48mo\n", + "NHoSAt/DdX1sy2U0HJae+WjE/Ow8o3DA1dUNjhw9BDrFkpVKYHXDDLY9TXrIckLrbdhod8KnfoN3\n", + "IKdyXC1L1jxybpro9bHay2SpPOK6Ma4mZ3WP6ptv3XvZbyFV59Q/pzqq52ma7UrWSilxXZfxeIyU\n", + "ijwL951H0oS4jSZoydpgg4W5BbYmW+Rmguul9Mc+Td+wZFmshB7W/GlUBn5eYM10mTlynKfii9iu\n", + "w20HfILMpthKcRsW7/zhH+TCE49iWZJX/cBbOLu6yZULK1i9jFkfPvBnH6OXGfDnuXLlLFYx4VB3\n", + "jv/rF34R3WkxHGiarg3swE1yO98g8FyPRqPB3OwMRue4jo8WGtd2CC3FzPISq5e6iNGEqDeisziL\n", + "O9/hwOGDnP/YX7N17hLXnz3P/a9+DZicvEhJZc442qIdOzjr4LQ8jp08Tm8yobAcCm1ASIQWeI5D\n", + "y22g8xzHd/F1BrYkHI1401u+n9/53d/mDfuMuSMUWGoqggW22aGeVhtvGE12YbtSSoQUGJ0jhcKS\n", + "EmEptBBTPHkHH96GXsyO9kk1p+rRYH2O7VfwUuWL9hbHwW6xq7pd2dt8pdxTdjshZa3DzeJxQtws\n", + "hb33nOp4PhZP5bzuvb7nO77tWih1Q2zM7u4clmWRpTu96Oo7WjXQdaqcVLt3QikESgjiNGVmZobc\n", + "GF70wod49OuPcmRpDsf28Nwmrtuk1Wjguj6TMCbPQgaDPtpkuK7NwaUDuK6P1gVxFNPb2mB97QaO\n", + "4+D7HouLC/ieT5LGxFlOpguG62sUWYHvBviOR7PRIM5iojThG088ycyBRZwiJ8szlAQ1ZYlUTX31\n", + "9tiAoUBSaovXvYM6hlb3LqpkS32cgZtw62qCVHSm6ti7YOpeRMX5rp9fh8PqR31x7GWZ7PWiqoRV\n", + "udgByutxXRfLdhhPO7zsPbLxBKKEQhpmXIczp06z3t8qDYQU3Lh+DaXHDMwY1WjimCa2pTFRH993\n", + "8bTLAa/LyfkW54aX8AqfgzML3Hpkia9+4eMIO8OfnePi+ioXN9Y585Lb6V8+x4FrXX755/4dX7v0\n", + "LE9trrA1WKdjzfKPvu/NBI1ZEuGz1HSJ+jcwntq+n1UkxVROOI3LVn6tdhfPD9BpxmQ0ZrzRZ/bo\n", + "QU7eeRef+eMP0nYcYvMcL7rlNj7yH9/Hi9tHUMMI37FYmWzhygbXV1foDdaJ0gHx6oQXzN3LDIa1\n", + "SxdxlxZYH/dwbZ/AblCkBRKBMmVeKQ9jbE+RpynKGPq9Ma983f8E7/kvN425MIo006TKYEQpCSGE\n", + "gDyj6jpjMKV2fFb2gbRtG0tYCG0w0mCQaCPQRpOlGUaUlL1tiM7cbJT3zrG93m59btej0/0M/n4F\n", + "N3Uncccj3908vX5Ujma19ixrNx13r1Oz97295wkhththVL/r7zLi39ZCnjqeWseMKg9sh+kApYda\n", + "/e8eFsV2gUQNa9Jltt9gCHy/rHyS8H1veQu/9du/zcte/IKSWTKMGI02aLfnkXg0g8aUlKHJdcpw\n", + "1CfSKa6b4Ng2tmMxP18mMQeDPv1+D6FLMXfP8/AbPtK2CRyP0WCMzjOyIiOODcqzmZ2dJ+i0+OP3\n", + "f4Cf+KEfRGXJ9qQXotQfllIgkOxAkPvzoevYWXWjdzRlbtYK34/KtR+EUn/+t2GC9d9S97Crc8ti\n", + "hRIXreAcY3YL9lcejpRWjSssS3U5WWA7LoXWdDoz+84jK0qJx+toJWgvHaQIDbluEMwtMNQe/rUv\n", + "kEQ5G6JBoRUUQ4yVEBYJXrvDpcEWW/2rHJ1t4YeSqNBsRBusP3GFmabLbUeOkfSgq7o8/Ncf492/\n", + "+qu86r57eeXSnRBkWIHgxSfv5tMf/wBv+J/fxu0PPEjmQlZsYmcunlQkUiGmokjosrpUF6V4fxSF\n", + "XL1yhcUDGZ7rkirYjIZECh6/epUiS/BO3sLGhavEF1cIHn6MF9x1L5lj0YtDxuR8c+UiQkK4vkFR\n", + "JCQiZuy7XB9vcGL2BEWa8dhjj7ElwbF9fL+FpVza7Rl8N0Cbgk67yWTUoyhyMgSt2QWS55GUzbTB\n", + "SIGybZASJXZyU2XOycGyFGmWbLcXLJkrBcqUazNNS40TxFQmQyiU0Mgpw0UXBZmpPOTKky7ndVmQ\n", + "Vq2LncYNO966QYidSLycm/W5vDuRX/9b542X37lTTbzjyJSJ2Dr0Uj7mpnVRt2d16KVeiV7//vqm\n", + "8A/aA9994TuP68aheq9ecloPUfYaoOoQZscHlZTcnSLP8QIfy7F54P77+eojj7B88Agz3Xlm5wIw\n", + "il6vx2g0oqBs/dTuNLBsm0bTn0IK5aJLp+FXu91iYXaWoBGgtabf77O+vs4kipBG0mm1mJstDY9l\n", + "O4yiCZMkIQgauI7LU2ef4fTxYyih8AKPKBxjb4sIVcoZEgSIPRtcNUaO49SMY2XQ2TaM9QlUH/u9\n", + "4wk751dhcPVa/X+q1/b+7/6ekd7l5ezge3rXIip/946XlGUZhjI3ACVfzhj0HQAAIABJREFUWj2v\n", + "JkSO0wgYJhnDVPPIk88wyDULR3L6ozEL0SpHgw6uLkil5rq2eS4KiG2X5c4cgejj3jJLfvReVp74\n", + "CxqO4NjxZRaXFhhu9Hnu/DUWLIf1r32eX3jn95P98Bv41f/7l1jvrHH+0bOIxQdZNBbKEbzmLa/l\n", + "0kYf6YPJJmQ6ohCzFGaq80JpwI0BgSDwfMbjEb2tATdu3OCJxx/HWZxhPB4z22ghGz6ZMCyfuZvl\n", + "uUMMLl9jtNJnc2aTD55/hCPHDrPQWGBMjrAFw7VVdBwh7YJRWvDZx/+GXBhOHTjGnUGbs70Nmm4T\n", + "r+FDo8Gl9etcWVun2WySxQkN2+bEocNI5XLh/CW0tb8B8VszTJKYPC8oTFFWmlJgWzbCsikkGCQZ\n", + "AqRFxc7IdYGHLKNJyyr56NMu7UYXpHFSFuJIWeaUonQqx1DmovJ8Jxlfcb4rjnlpL4qpw7Azzyvj\n", + "XxrOHRphNdfqxrY+p6u1VBTZrnlefWY1f+vQZHXuftHmXoNcX8d7oaDn89r3O/5BtFSr46b15+X7\n", + "dYW7ko+51+hUHmd1LyR7Qi0psS0LiSCJYk6fOsWffOCbPPjC7+T61eu4Tkqr0WVmps3igXniKCHJ\n", + "EgpdMB5NiKOQRiPAsiziOCZNE/K8YDwaoqZYred5BIHP4VYTgyBLM8ajMePJGKkkJHHJLpGCSRLx\n", + "0P0v4C8/8ylOnThJrgvCOEVKC8u2KPIcozWYUmgfBLrQ6FrJ+zbVap/S5NLL3es13CxVUI1/nT5V\n", + "ffbenEJ9I3g+w733PhbFDjS2H05e34wdyybN06nmSdnaK8sypGMhlWQ83h8DfwaLUZwznOQsNzUz\n", + "2YB8eJW8eIpG3OOCbGOiLdqDNTaziK8Xszw+OUbbDWgVj3Lb7CrXNlKevujSbWSsrfVpbUg2V59D\n", + "yAmzS7OIYJGvbwLXUsT4WX7qn7wK/+A51odn+MsvtXn0kU3+5b/+RS71VylsH11IBAFaCQqvgTYT\n", + "pJBQ3YtpaPXss88iDJw5cwYhFc1Gk2EypnX8Vg4vHmTu4EH8mQ4NN6CDwxc+8BE+82cfIeuHdObm\n", + "ePB1r2bmyEGQksSkPPvs0/zFn7wXr8jwA4eQjL9+/GFGV25w9623c9/cAv0kIRn0OH7bce570f0M\n", + "hcEoB1MYrMzQUh5CWEwMZPp5pEz9sppzNOjjegG5zEr8PS4V+ZI0AqDVauAGwdS50EjbwhQavX3f\n", + "C4q8KGmEUuJ4Fo7nlYa40Hiet91irK6hUs/d1D3m+jzbBa3WEoN1ymp9Du6d8zv4/e75XX5/Kci1\n", + "bV+25/T+RW31pP5e6Yv6WoCbqYx/1/FtZaEAu7CnvZBA6Y2ltXBpx5Or47bV+bZdCqIrsZtfWaQZ\n", + "rueiTemaz8/Oceb+B/jSl7/CC1/4EHmaEyUT1m9cpNls43ke3e4s7e7MNMwdkWYp4/GILMsIgoBO\n", + "x6PdbE4xYc14POb8+WukucZ1XNqdDt1uF9d1y4rO4YD+cIsoilCWg+25vOIVr+Rd/+bn+He/8PM4\n", + "UoDOiOMIW5W8WCVk2aMQgRYao3eaE1cTpRKyr9/wcoLlu/C/MhzcXYFWjXG9+06ddlhN7rqSWx3X\n", + "rmOHe41yeYhd97c6vw6hVL8tiRMKiulCNSWfvyhI86yMKJ5nqn4ttMm1h+MHRMOIOx3N6TlDN76A\n", + "Y1b5yDNLPC0WOHP65SQyZrCxwrIlEeGAp85dILhdcmrBwYm+Ss/PuZCPmDhLHGrPMZskHF1e5MNP\n", + "ab7EYX75feu8WF3nV1/ikLSvMeOfxNcS11ris3/zDD/5T7+P6+eewc4LctVgkMVYrsY2GjPlsiul\n", + "EKpsYfb1R7+OZVlceu455hcXWF9f5fCth/FbDrGJIM8xSUY/GbCZF7zoja/lysYKwzTj//i5f0Pq\n", + "2Wz1+ywvHGSYhRw4cRRLGj713veSjEMSk2Eri7Mrz6F1zrETxzh96jRXNjb41pe/yKH+HXSOH8fu\n", + "dIlzjZIeBQo0OMrabu6w9wi1IIw1nttBAJbj40gxlQQuW7LZtmJra4Ozz1xmOByyuLjIzGyHwPLI\n", + "ixwpDFJaOK6HkqXqX5pnGFNgCQvLEaRpTjDdAKqGv/UkY9UQYS+FtW6Mq/Oq52XbspudwL3Gfy/r\n", + "re6tV6/fDGfu36S57uRUv7me86k7ZHu/7+/igYu/r6v+P/IQQpi//uxHd5XM1w1APXud5/H2gNVD\n", + "m/pN28Fn/RLg2s5mlwNg2zZJliKVQiqFkJLCc3jP772HUydPcvDAAdxpkiWJ07KaDEEQNImznCDw\n", + "cJwdrqsxBlOUfe2MKWGMChsWqLKjSxQRZym2YyOVwvM8XNelmHrMk0nI6laf7sIia9ev8cqXfRcm\n", + "TzBJhBJiSiOchmuURlnXsvLVeO3t0FOO504hzG72x/4qbPWJWXkZe2Vq9074vXBO9Vm7eeJmW5ui\n", + "vknsFxFIYyGsalPI0KLUYA+jhGajzWiS8oKHvuumuXTy9T9DGKVkkxArGTFnjTk1azg+kzFjx2zO\n", + "nea5G5or4xa9FJyix1EnpaEUT69u0Z0LeMlcyEM8xyVsImaI6KLznIOupoFN2DjJheA4W1HEXcUq\n", + "b/IHtB9cp9mdISwO8anzLb52o82L73uQFx3M6VrrRM2ANeFhbB/LpEhjkEiEEdPCFcnWVo+nv3WW\n", + "paWD5HmpVqhlQiYyokmCiMGTPldHfbaKlCxLOdadY9YLUK6i0Ba+06AQ0Ow28QKLpiv51Pvfx+a5\n", + "Z+g4LoNoQigNWIZO4HLHsVs5deQE0TAiysGbX6R79DjN5aMYt8FwkiAtC8exKOKMe86cvmnMP/+N\n", + "p1CFwc4NSii04yJVxa+ujJdGKoGYJuYFMBwOKPKYMIxYOrCA7zlcu3IJx7bwPQclQRc5ejqnfWtn\n", + "099P26Q+5/erc6gb+8pWlLRae9e5e52V6rzyu3ZDteXnlAnour0q5/X+trS+Rvc6Mc/ngdfX2j0P\n", + "fjfG7E/K/7YmMZ/Pe6uD/UkS3WREqlAEdlMOs6w0vJZSJT4mFSgLIQWtRpM4TUrjrQvSLOMlL38Z\n", + "f/Hnf85b3/xmnCk8MjPbptnokOeaKEzY7F/nypXncByHIAhoNBp02m2Cho/nzRDHMf1+n62tLSzL\n", + "ot3q4Lke7VYLo8qmD1u9Hpcvr5ZFSsqi02qxOL9AZ+4A66MRG1s9Vlauc2CuS+AHFFmKFOVC14Ap\n", + "NLkptuEkqNOc9stmlwa/jmlXk7w6qs9RquzZtxPxlML4nufVcMAdSUzY2cT24+bvhJkGpfbQyGpe\n", + "SZm1361BEY9jhIRGIyDJEyxLMTc3R55rlpcP7juPZrSgbTlEjsUwdRmYeR4fap7ohTQbis7lT2MB\n", + "ca9gYp1m6B4iG+e85MxxDroHefzpq4yfGdC+rcsLX3+azWdWefbRc+SdJSa3nuDq1nnmrvwxb16C\n", + "WSfj+Kl76I0skq15FrxV7MYFTp9+CdmhV/PkV69zx50Jy8vX2Ag1y/e8jOtbIzwnIM9yTGFKGEVa\n", + "WMpiYWGBA4tLRFGE47hobZB6gpQGZTkwzGngkTUD1j1D7iisSYIdxownI+JJzsWrq5y/cZUPffiD\n", + "6CTEdQx33nqYRQ2NQoHlMfRyrqVbNOIR/adHjNY2WLLbzDbnmG8tEF5ZxbhdGkdmKRoObhBw6eI5\n", + "bj10dN8xl46LyjQ6SYjiCOMKbMfBUDX1haARIIQgy2LStKDVatHuOGR5iN/MUa4LluLW03cSeB4r\n", + "1y5x9fIlpNAsLCzQbAbkk/Guwr4KLqzPpcoWVPS7ugOYZdk2a6ruBE6mjKb97EplxKvcklI7kWaW\n", + "ZVOPf6exSX0jsazdjbvreH2dHlt57/tFrdWa+PsmMv9OD1wI8R7ge4E1Y8w909d+DvgJYH162ruM\n", + "MX8xfe9fAT9GWc3+z4wxn9znM82XPveR7cVu2/a2GE1954H9NVOqwalXCVYDUheS30le3Mw/DrTD\n", + "RGh+9wPvxW01uf3oCdrapeH5OK0GozTFUhYNy0U5FpZjb2NuvV5v23halkWj0UBKSZqm5Hm6/Rvq\n", + "N833ffI8J01T4jguf7dRjCZjfM/hr/7qs7zjH72VViPAEoYiy3FdjyIrm1q4rgcl4WbHc5gaacsu\n", + "fxvTMFbnORJNicqZKYUNbKv0PCQgdJnc1QbyQmJMTqlIUCCELjm7xpDnIKSNUg6m0MhshJAOxnIo\n", + "LJtMCwqdYymDMimOSqFIUGiMdjBQVtAag7AdbMsl1xJQSOlgTFnAkzkFnm2xcvUqF8+d58bqBoNR\n", + "QlxILl6+QqvV4Q9/5zdump9n3vgzDCbjkoqWG0SmsbSgE7QZbvVJ/Ii80KAcbNulyFNUEXKgJVlu\n", + "GczgCsdmHWYaipW0B2HKA0dP0hqE6LUttG+z5gaErVn8RoNbZl2OdeFQZ4vWgTFNW2GNOwhvlpWh\n", + "xGGelgePXF1l3buLUw+8GmVN8FKNUhmjICQWHgEB5AOEzHG1hdHQtxyktmlKB6M1uiiwpiXpFT1U\n", + "UxbhKKWwRYAtJegR5889w+//7h9x6fwN5ma73HPmOIPhCrbj8uSTF0mlhwhcjnTbLNoWdhzSCTzu\n", + "vvc+mgvLPHb+GlZnEdwWR47fwt33nSbNMm47dftNY/71b5wly1J832c0npDogsBvIoQgTVKEsKYl\n", + "8Yq8yGg2S4ZWmmfouOx25fs+aZaR6wzXLTu9N9tNjCno9fpsbKzTbhYkSYw2Bc2mj5QChQGdYQFC\n", + "56A1Skp0aiOkJM8zHM8hiiNc1y4rO800WqakzHrCpqjYQEKWj025uWpdoATIqZqpQe6yLVXStNIC\n", + "rx9Vk4Y6JFP38Ku/e6VjK5u2V5GwOu66/+X/XR747wP/D/CH9d8K/Kox5lfrJwoh7gTeDtwJHAI+\n", + "LYQ4ZUpxjj0Xu9uT3Js0qx5XJdbTz9+1o9WlJStjXeeUVzuZbe8Y3+pc17URAt7xtrfzy7/+73ng\n", + "1F1YWiItVcrKjkekSVZ26VYSzyuLLhynbDbrui5RFDEYDJhMJnieR6fTYWFhHiHYfn0ymWxvNo1G\n", + "g7m5OZrN5rTYISUIFlldW+EFL3iIj3z0Y7z9bW+lQNNutinyHKn0tNGEg8aQFzlFYaad0CSWskCA\n", + "sncy8VJJlFAYUTJyFGXerMiLaSZBIpScKu5qhIwRWsN0UkphkWUFujBYysKSZWJVaw1+m1bDp7e5\n", + "jq8cVJ5iOQ4aSSYdUtUCzyVodkiiaZcek5GmCUkakRcZQmpyXTAZrLOxuUkYThiMXOJwwjcefpgw\n", + "DEkzg+M1sLw2wl1kZRDvnUIAFLmNMH5Z9ScLomSA7UhaM4JTd5zGUR7rm1ucu3CFNAEpPAyKQViQ\n", + "JSky67I+nLAw47Ka3sZ4WLAatXjtqQ4teYNhf5MsPchhXzArL3BCJ7R7Ln6yhPAKhm4IicFrFMSN\n", + "lEBsoMIRhxp3snKjydVzj3Hy1J1oVzOOh7TwMGmMZh4rn8GyniOyMoriCI0YUBNyXSaxjS62i1mk\n", + "nC5yo8HkGFOQmpjRJCbwJMdPnuLt7/hBfukXfoX1jTUuX7I5sNRhc3MT17JJDIyjmPbx44w2V+nY\n", + "isySpJZg/ugyb/mO7+QXf+O3ePjxs9x++x186Wvz3HffA9y2z5gbk6GUIElC2i2fTGuWDx5kdXUN\n", + "R7plUxRjqDruRNGEcByDAaUcbNsiyyMajQbrWyO0TtFGkxcxQgoaDY8gOMxc10UpSRiFPPvsWdI0\n", + "YXFuBkvZFGlCnuR0Wi0G/QHtVkAcxeQ6RWqBkJBPq5AtYSOcqcaOFJii8n5rzJLta5NTAw6gEXIn\n", + "SiyKgiiKAIHn+ds2qjLaaboD99bzVHVnrrJtddtVx96r3/P3xcD/TgNujPmiEOKWfd7ab0d4E/Be\n", + "Y0wGPCeEOAc8BHxl74lVaFSF7NXOVvveXZnj6rX6brjX6NcFb6pEZ91ThlrlX15QGINC8+qXvYyz\n", + "Z7/FS1/8EjZurJHHGYcPHcJybIyUaG0Yj8eMx2M2NtaxbQfHcaZGvexgL0SZULx06RJQed0B8/PB\n", + "dnInjmOuXLlKUZTetWU7ODYsLhxgY3Od2fkDPHPhEqdOnmAYxegsxZt2HBqHY4RdTUKJrer0qRLn\n", + "r8IuJVWpFKfLZKDGYLTBsu1dOYLSx9AImZfMAAxSWAgUgd8gS0uOuqDAsQUoi562EFmG41nYJsG3\n", + "NZOwz2ovZiO2OLsy4PzKgEGYE0XjHXyR6UQ1GiFL5TolyxDVUhZYTeIwRLRP0JqxieKU3CgSU/5v\n", + "4Ub7zk8lPQLPJU5i0mRMs9UiT3vMH+6Q6xFWnKHjCRQxwlhoYZNkECEJHR8lbGZmjhHNdTnlD1mf\n", + "FJy7dIn5NY+XLB7iqNtjZT1i9foWA79D1Otx3N4kb80i7Qi/Ca04AZ3gdjTYK6iZMcPJGVqH3sxX\n", + "n/ogB+aewmodJmjcihqvM6tyhiLEkpIgb+HplNikuEVOKgoSNQ3HhQPaTJ2VDKaVfqrKi0hNoxOU\n", + "MCOS2+++m+96+XfymU9+ikkUAwdIE0ma5kRZjN1qMxiNuOXgMsPVqzQdG6/b5svffJjHPvinfP3p\n", + "c/SShCfPPcX1a02OHDm275gfPXYEpSSWkuRpihCSyXjE8uIsWZptc/pHoyGWsGn5Np7vlc1Psnw7\n", + "sbixucLMzAzD0YDuTIcwjHBslzSNmJufYzgYlTRCYXH7qTPkRcblS89BkWIrheu0GUcav7FAmPZw\n", + "PBtl/NJpm0JSxpTMNbsyirkGVcpNa1MSBRBT5pMxpacz9cQxlBHb1CDbtj2lE5efWY/8YXcHqjrs\n", + "WEJJ2bbBrtZt5WVXDcTrUAvcLHa13/Hfg4H/tBDiR4CHgX9pjOkDy+w21lcpPfGbjgrPqrzTCseu\n", + "jnoYUU9qVka8So7VcdjKk68Pwu4k3k54YzkOMtc0lMND997Hex77Q85efIZbjx5HJBlFHCEkXN9a\n", + "Z6Y7SxD4tNsttC47mY/HY8JwzHhcik8FQQCAUtaUuRIRx+n2tXS7XXzf58CBpe1rDccThOUwmYTM\n", + "Lyxhez6f+PSnaXW7HFxcpNNqEg76eI6FzhXUMtRpmqKNQU538HybemgopEJPKXyoqlCi9DKMKAsd\n", + "pqNcjpOWiCmsgVRoA1EWYVsSyxJokyEsg7RsHO0RRmMWuh2efPQRpBScOHkHbdfhg+//OJuRRWwa\n", + "tGeXsfz1MiFsLCQWRkvyVGP0TgQmEWgNcRKj7BmM1kySjDAV2I6HcpyyAUbxPJS2PMZWHlFeYEkb\n", + "iebEidt47rlLSJnTMAHrWz0m6QSjXFAejU6DQhss20HZio04ZvPGJtK6waGDbY7ePsfKhWs8Z5rM\n", + "zhhOLMc8Moj4Uv8IyWiWF830ObQe48Q5x5dmOKUCsmxImnVxmzbOIZsJDp9/4gbXEotm+A2KsMfj\n", + "mze4/8zdWLlFK9BMTI+YDsrkoDYYmQAhHYTIKPICPZV0LXQpUGa0KesBEGgMcTLBdh0syyNJCnzH\n", + "4p0/+aPMzLX5i49+ku9cPsn6xohGOyUeDknGIdlghGiXNMADi0toDcPhmG+dfZpmo4sddMhTze23\n", + "38HSweV9h1wIw7Vrl2k1AlzH4fq1a6yvb3DnnXfhBw08z2U0GrO8vIgu9HSDMWRJhO06uE5AnCYs\n", + "LNxKr9/n6OFlwiii3QxACALbI0sTGn6TySSi0WyQpSl5AYeWjxP4PkWWohBcW7nGKEwJWi45ZcMM\n", + "pMKybGRhtj1rOR0zRGmcSzpyuQa0KcvjpZQIozCm2GZ/obNtQ70Dn4htwa26gc3zbNvW1N+r11RU\n", + "a3cvAaOOOuwtzPvbjv9WA/5u4N9OH/888CvAjz/PufuC7KW2yFTUZ6q7UTfGdZyoTnfbq40Au/nM\n", + "e3e3yvuuzhGibDA6yhMcJOkkxrJs3vzmN/Ebv/1bfP8b30y2NeLo0jJKuJw8dSuDrfK39nq97YTK\n", + "7OzsNsVJ65JG2Ov1cByXRqNJt9ul2WwSxzFhGJIkCZubm9tY/8GDB3FsmzSJWZhf4OrKdZqzs7z2\n", + "9W/gfe//U/7Jj72TKBzRcC3SLC27ueQaKUp2ilKgjJhK0k69gUrEygjcSoyqpJEDhiSMSrhFyWmI\n", + "V3ogqmhMK39AKEluChCQSU2SRgihcZRNHsWgBStXr/OtsyH3PfCdfP2Jp/m1n383UQrHb72TNCmY\n", + "6bpsXDmPP9vCUjZKOihhARK88nvSNCbOYyxLYdkKPS5xUy0EljQ0PLtsP2cMrpJId39p02hyg5mZ\n", + "Jdq+pNCKfj/i61/9BktL84wnY+yGIhcubtdHSEmWFygLFIKiiEmjAqUstDY8Pj5FcnmLl5/w6R4q\n", + "GKQbrCBZLGKWm0OuF1t8ddDlg1cP0kwT1KbHbRdHfN9yzm0HDYI2MmzQ33yC7ozhi1/5I04+dBw3\n", + "S7D0ExTFSX7pj8f84NveyHz6DMZO6dkaowzKWBRKYecGuwqSCo2yFHmWoyyrxFi1YUomwnVsLCWI\n", + "w5xOa444GlCYjDf/wPcznhi81jzaauB34a7lg+SjmAMzHYrhmMMLSxRxTjiKuHThMq7wKbTi6JET\n", + "vO3tP8SD9z3A1ZXr+475+fPnmemWMGIJRRruv//e8v5iiOII2y6hhySJpswrzdziAv3RmM3NNRYX\n", + "F0mTiNnZGZI4odstm6QMRyM8x0UbjYOLNxcQx3GZ4BUWtm0ThqV2vHJcbjt9F1obvvH4X+K5ZRm6\n", + "JSVpbkpY0BgkBkzpUUspkJYqheQoa0cUU9lZrRGypHgKU9kivSva39EacnYZ3fK13dDHXi2Uvd70\n", + "XjtVN957HdDnO/6bDLgxZq16LIT4D8BHp0+vAUdqpx6evnbT8b73f2Tb+N1/393cd+auXYyHela2\n", + "IvNXF7pfuFENWFWdVTU7rg9odSPiOEZ4JTamitLILR84wJve/CbOnj3LG17+apLhmCxL2Vq5iqcC\n", + "XNtDGAPakOcZRZYThxG+7+O6Dp1Wm06rRZxkhJOQUZKUGKuUWFLSmZ1jcX6BwWBAFEVkSUqeJOR5\n", + "Tm9ri06nQ39aBXr7HXfx9DPPcOau20nyBMd30VmBq+wyuaXLFb69aUkJGmxlg5wWOWRpWUBENQkM\n", + "jcAny1N0UVAUpb44WmIbv2S4WAVCUZZTK42wLDZ7KeNxxMzsIoHXRqUJy4dv45tf+Ar/9TffR3vh\n", + "EAfvfikSSTYZoxjQEBNaCxabyG1hLiF1WbmHRjk20pGITCA9hbQtutIHDOE4xBRFWdAjd4oeKl34\n", + "vUcyWaNXTBDSxrF9mq6gc+gwr3vN6/jsZz/HpnGQMiNNYpQBW4IsQOcZ0ghs5WIyMCi2WgHn05DW\n", + "lRu8+KSDGeQ8cVVw59xdHFZbvMJdwTRHfNm+nyezZRz7EMXgAuudMYdGIVL0CLMCu2XxzNnP0WnO\n", + "ojc7JFmbQ0c2OdPVPDE+zR9+8RLvfNMS7fQ8rumRZ5KmZVHoq0Sph3DnabY6JEmCMRoKMIgyb1FR\n", + "1gBLaookw5MBaZRS5AYtBIWQ/ORP/zM++5mv0E9Sch2SZxMOuD5JOKTpltoyc0tL9IYhW1sTXvXK\n", + "13Pfi16C35wBIblw4QpRnOw75u12h4W5BXzf4aknn+TQ8mGSJMcLAjKtKXVeDKNwgGs7oBRJlFHk\n", + "4DoeMzMWeV42BQ7HYZngn0pdtBpNbMsmy3PIDbYSuK0GpuETxsk2RJrnOeMwZByGIOD4iXuQAsbj\n", + "Ef2tLXSR0m21KPIEdCnbrHWBFIY401hWiSYWucbostmFEGWTlR0YRSPUbknY0giLXQ5hZYuqSszK\n", + "2axqVfaySerFPHsNtlKKrz38Db72yDf+x7BQAKYY+EdrLJSDxpjr08f/HHihMeYd0yTmf6HEvQ8B\n", + "nwZOmj1fUrFQKhJ+XdZxL62wMt71waozTxzHwbIsNjY2WFhYYDKZbHvJURQhpcRxHIqi2MatLcvi\n", + "mSsXmG/PMOe38QOfRMKYnL/8zGfxjeTYwUO0Ox3cTpvB1gRb2WURjlK4rrvd3HgymTAcDknTdNoY\n", + "ubXD+S4KJpMxcVx6361Ws2zNNoVciizl+o3rGCGJi4JcG/xWg9W1NS6cO8trX/3dHF4+QJ7G6CSl\n", + "7TWI43g7sauUIsuyXeX0UGFx5fuTyWT7fGmp7SjFCMjyHNdyEZmNUQWTZIIKFP1wwtPnLqKFR6F9\n", + "wglo7TIehbTsiH6ccWVtROfgMXACwjQnnQxQeUgx3CQdbTLXbiBmD6JR5LnBdgK0tkgLQZwbjLLJ\n", + "jGASJyjXxUuGmKkKne/6FBrSooTK0Bkmi/jwb/6Lm+bmT/3rX2Ort87m1ib9wYje1hglPU4cP8X1\n", + "6+sMTUAUhlgSijxD6AJd5NMeiqWxUbYLBvpOiqVS/OgKD7Qj7j8wSx7bxFtDTrDJYX/IqtPiy85J\n", + "wqigO3eKojfiYNHHs2N0N+WBky7zbPHlsxd5eK1Bp/FK/sXbZrh15hzCafBI/7v5r5sv4snNS/zT\n", + "t97CYrTKjPTRJiQyCR//9MN87vNfodlscObMPdx5550cPXoMratilp3oKZ30WJifY2szAlyUC82O\n", + "xxf+6q/58J99ku/93rfyx3/yXoyIGN64yJLvMtvu4CqLRqPJKMk4fvtd3P/il/LQS7+bi5dXSTPK\n", + "sej3uOfM3Rw40L5pzK+trDMaDli9scLp06cQEoJGm/5whB8EaF3q41uWxWQ8ptNuY0lJHMW4DZ8g\n", + "CDj37Dluu+0E66sbBEHJUsmyjDRNcWyboNEgTUIaDZ8kyYjjGCksXL/sLzqJ4tIzp6zIlJRsNtdx\n", + "aAYeV648x6VL5+m2AhpNB0xKUaQ4tiTLd1hvnuOSpSm6qKLbaXgz7XIvbbY3jHourdhT5FQ6ljvy\n", + "t3WPunpeP7feCBx2YOIKDq1z0+976NXPy0L5+9AI3wu8HJgHVoH/E3gFcF95q7kI/C/GmNXp+e+i\n", + "pBHmwM8YYz6xz2eaL37mQ7t2r3p4Ud+N9r5e7VjVRdYHoM5Prt6gTUDoAAAgAElEQVS3bXvb665o\n", + "QEVRkJiCtt9ATptE5BJyS7C6vsEnPvZxXv6SlzLT6TAJQxy7iS7YBd9U3n+9MWmdpF/xU13XRQix\n", + "XZFZJTMALKXQRmO7LsqyCZOYJMsYjAZIKXjiicd5zatfWdKwhICk1IZI0/JvXuRYlk1e5Agpt7+r\n", + "unbHKbvx2LZNmk6TKEpuN4YojCZPcyajCL/lE+cpmTA0urMIK+DDH/4koxEkoUWaKBzXx9hDkrzg\n", + "0JHjrG8OaLTaJEmKMDmBAzodk0YjkmiEzkKSOKPZbJcestvAclpg+WQ4xKkkFwotFJkIydOELI5x\n", + "bZs4TlGOT65LHZs8jfnEu3/6pvn50Pf8BFk+JElGuK7D6o01PLeJEBaWcklTWTZTmIa3JVQkQFjk\n", + "GoxQSNslyzSBtkgcjWVFzGSb3L/oc6wLM05Ia3ID2b+BcVzCuSVuS4cMOcBlcZinRk2+tJIRNVJu\n", + "bU+4PS845AzQ+QVmgiW+71X34s/lTJoRwjnFf/7yGT56/RTM9JlNvskx1ce3Fd2ZOxmsnef61ScR\n", + "UjA3P19Ge7ogSRI6nQ7dTpfA9wh8n27TpdNscvz4Kf7ma49w+doVHn/yMTb7fdbW+pw5cz8rK9fQ\n", + "JsWRMQ1HE08iZruzFBpaM/P82P/2U/jtWYLWHAaF7/lsrfdoegF5oTl9+uYU1rVrN7hxY5XlgwdQ\n", + "StJstdjY6tPudNjqD2i2O+U6EIZoEuE5DmrqdDlTpyfwfbTOyLJy/fmey2QSsrS0wOqNDfr9TbI8\n", + "JGgEzM0ulFRdIVDKJskypBQYIUmzDCkVSVwQRxFKSvIso90J0EXBoL/OYLhOmkzwA5s8T9B5WQXp\n", + "2FZJuRWCIi83dbldpFOtkXwb1t2J5iu5it3OpFK76x3qtqzuwdcRhrqXXX3WXmf1byvk+TZWYv7Z\n", + "TQa48iL3Et/rHO7qgivjBNBoNHj88ce59957ieN4u+xWa102VJjCKfX/j7MUKSRFVpYbW5aF5XkI\n", + "z2G9t8V//qM/4sd+6EcYb/XJitLozc6UwlVQ3pCrV69uZ5VL77tBp1NO3rW1NQaDAWmakiQJrVZr\n", + "2sknwFIWhS62f3+WZWXI5dl4ngdSsrq2xmA85tz583z/234ADxBxVG5KlkVaFDiug1SS0WRCp9sl\n", + "mUIylu2QpkXp1aQp9rStmmU5SEtx9doK/VGZ4dcGFpaPAJIbmxts9sc89a1n2OyNGfQjlg4coUgg\n", + "8JtoJD09QgpJK2jR8BqE4zG+45KmKYXJ0FKTpDFRHOL2rjKejFBKE4ZjpBKkeUZ3bpGZhSWcoEOm\n", + "IUlz1lnENpBMRsx02pjCYHsNtHTIp574e//tD9w0l17xtp8liXoYEzGZDHCm1XutVptxGGHGQ4yQ\n", + "WLbNKAwxUrFwYBnL9dnqD4mTjDjOKAwYW5eslTBBSYGtCg75GQ/MaW6fSXHEgDBMGQxy+vYsHa+D\n", + "ZbfpqyNc0Qe4EI145vK3aMeK1x6zuI1HuPuQg3v4Aa4evIvNuVN4meLUkfv4lfdfZKNzF3HyNNba\n", + "V5ErV7ljvsl4fAlUQV4UtDptMIZRGJZdojodAMbDEWmS4FoCQUGSJWSFptHosLHZI45jPNfFsgR5\n", + "lqGERa5D3EAwGY2Jo4R3vetnWVnb4FOf/zz/+7/6WVbXepw8cQqTaxxp8D2f6zfWufeeUzeN+cc/\n", + "/kkOHVrm8KFlfM8lL2ASJRghcFyXrNCMxyW11rUUo8EA3/VoBD5pnuP7PmEYsrGxzpHDh6cMpYIP\n", + "fuhP+cQnPkG306G31QOVcePGDYos58SJW3njG9/Ea17zGhrNJlprtvoDut0Z0jzHlmUzFqNLIxgn\n", + "MVIabFsiZNnc/JGvf42DBxdxLQdTFERRSKfZYDjoY1tTaHVaJbvNx1Z7dfatKaVztz0qCRT72jqy\n", + "LNtGGipm3F5JisoW1kvsq+/9B2nAv/KFP9+VuKwupCqbrbzoOs5dHXXa4PTztnfILMtKI0gZ+nie\n", + "t23YqpL3JEkg12glKYzGsRx0kpVetGsxkZpPffpT+Fpy+/Ix/M4sytlpNFxpGbiuux0hVDchzzNc\n", + "10MpOYUyyl6bZZFPzmQy2b4uIRWWbZetrTAUeXkOQpAB4yjl8soK/eGYV7/8pRya7WLZFlmWlypu\n", + "xlBQdrORSqFFyb3tD4akiSZPM2ZmZ1lf3cD3GwghabRa9IdjpG3hej5hkrOykXLp8jW2+mPyAowW\n", + "2JYiCYdEkx5FNmZxrk2URGSNBSxp03BbuMonTwxFrpGWjbAE/ckI27fLoolJjzQZs75+DSVSICPL\n", + "4pLJKG06sweIU83s/AF08xAWmng4oOW5ZGlGkhlSY5EbRVoYPvjLP3rTXHrNj/4iRZogTIakwHUU\n", + "nW6LOJ6QpDFWmhMlCUmW4fgeQbOFMYZJGIGQeI6DzksJ381iQNsIfCRhYdgYhcxIi07Y50BQkJsR\n", + "SMNwa8jnx03uPhBw30KTXj/m+saE1f6IseMjGzZ3tQwnrAlzXZ/hwjG+vhKwnt+BFoZOc5VXvOp7\n", + "+dI3Umj6LHcybjz8cbrJN9AotOwwHI1KYTNKZyWOIyylkAKUVKhpRfE4HBDGA06cuAXf7ZBGkKcZ\n", + "ppjQ8CUKRZFI/FaDftTn13/93/PENx/jzrvvJtUFTsPnd9/zHu44fQd333EXS3MLDEYjRtEE3w84\n", + "dvhmJsqFixeY7bYREhSSPBPkusD2PHJT6vJPwlLTJ09yHKXQRblmMq3pdtsMBgNc1yPPUp566kme\n", + "fPJJHNuiEQSAwXFtoiQiDiPW1ta4dvkKW1tbgGRmZoY3vOmNvPZ1ryObrkVdlJKxRguUpYiiMgoN\n", + "4wjXczBCT9kzV8jCATrP8H0Xk2d4tsUkHJVqiqIs/y+F5EqYsW6fKuOqNbu85fK10sjXC3OAbVtW\n", + "b0heQTh7S+rrSEJ1/j/IUvr9Or5UEEd1UTsDo286r/KwK2NYee5VCXhFlJ9MJtsCVJUBVUphG4VG\n", + "l9KXAiwpsaUiMhqhJA++6CE+8Pv/iduXjuC5Hm6jsb259Pv9UqBqMMC27e0S+yAIMEYTxxGbm5vb\n", + "kEtVrRkEPs1mY5qcKiskoyhBWQrXEqAVRZGT5gXDfg/HbXLrrbdx8fI1PvGpT/PWN3wPw+GQ2fm5\n", + "aekySNtiNJkQpymXLl+i1++xurrBaJggheR1r/0eFpaWKQpDu9WhNxiihY2yfZ4+/xwXLt9glM9T\n", + "FBLXXYZUYwPoiE7HoRVoomhCll8lzyb0NiLmZw8wyQqasy2MEvhBg3EYE8cJrc4cURoyGA5x7BaL\n", + "R48yc8tpAleQRhOMLmi3ZikKG4NPGGmSWKPtNVqeRyIysnCMbyvwPOJCERWCKN0/G58LiRYOFg6+\n", + "53L48BKjcY/OTJswGuFqH0YjrDyn0AWFtum0WnhuQpGk5EmEyQuUMJwW9zHSa2TeEM9KefDYYbqe\n", + "ZLZ7N82ZU4yygKWlWRy5wZsmIU98+WP0oz7hwWMstTrclzd47omnGYdn8c2YqHkrjwWHySZjbpcu\n", + "36E2WWmlrDRbfO3LDzNvBUw2XVJcVDfE848iJxLfatDsdHE9b8osMkRRiO95GF3q8AggMyB8h1uX\n", + "TqCkwGQOndYsOk7xnJTALej4LcKh5oGHvoMHX/5CPOHyuU/+Fffd8wKUpWm3ZnjDa76H3/6t32Tj\n", + "0mXe+sY3lUShVpMo3r94qtn0SNKYTrtFf6tHw2sTtFqEcYxjO0RJgmfbYCBouggDaRzh2TaubXH5\n", + "8mUOHlwizwsef/ybnDv3LCdPHqfVbCCEoN0u2VvKtjGFZjgYcHHpAlcuXS3X3WjIb/6//x+PPfYY\n", + "P/KP/zGLBxZR0pRNo4VFnhW4blngZrsOaaZxXMjygsUDx2hYCVevXWFz7QadZplXch0HPTW4uiiN\n", + "tzYVj3x3qb1l2VSJzN3aLGqXOmi9crwOpdQLF+uaQ3UcfC+d8PmObyuEMn18E7Zc7XQVvlyn2lSP\n", + "dwkhbRtwa9cF1z+zwqir5x4WGigk5NKQ64IsS3CUTVFo3EbAn37oQyAtXvLQyzCFZjzq4zoK24JO\n", + "uwmUwvZRnBEnGZMwRucJvudiWTa24xJFMZ3uLHGSMRyNsSynpENaNrooE2oGU3qLjk02Fbo3xpBm\n", + "MYHr4/k+11c3+eRnv8APv+MdDAcDXvCCB9FZQZrlZLkhTjI+9ZnP0Zmd5wUveBHN9jzv/t3fwg0s\n", + "Hrjvbl505m7WnrvC0vwS41SSN7p87tGn2JxEFHmC1jkCjetYZGmKJSRFZhBakiYGSzoM+1sU6UWy\n", + "ImNp+Qhe0CErHHTuUxRlYUcU91AqIcsm3HPyDrI8L3U+jKbXHyKVTa41aZoTxgmtdgvHcQhHZQVi\n", + "qx3g2DDorWIrTRpHZLlGS49fe9f/etNcevs/fzde4JKkCUHgMg4nOK5NGIUYrSmiIb7v47sOJs/o\n", + "93p4rkOaxLheUPKqpyqBcVTioRLDLUcO02m3MHk6nY8wHI4QUyfhlsO3sLJymbXVFZTKiJMRpshw\n", + "XJeVlTWCoItUPp7XINIFjueVSTIDpsiRxpTjLBVa52RxqSq5sOihlGZzfYMi1TiOj5IOUnoUWESp\n", + "xnYbGGkj9ZDAKbn+S8uHcfyAOE2RgGtLjE55yxu/l8C1cRzBcDBmq7fFRz/yUX70nT/KJAxZXJzH\n", + "cVwcR/IHf/Cf6PcH3HX33XRmZ/A8h3vvuvOmMb9y6SLzs3MUeU6SpGgEzXaLMEqI4xQvaJCmKcqy\n", + "aloiGa2gwWDQJ/ADpBDcuL7CF7/4Be66+87SDlhWqdSILJtFpCUuXeVx+v0+Fy5cYHV1leFwyKOP\n", + "PsrrX/96fvzHfxzHc7edvZ2oveTQ1mEOgDDN8DyHyWTC1sYqUTgqIwRpStgpLSG0UsN9RzwujGOC\n", + "oEExpRtukytkSZ+URu/yqut6RVX0vuON7whm1aswK0e7jo0/8OLX/sODUL76Vx/bNtawQwOsKxTW\n", + "Odz1ctOdndDaFXpU5PrqqJekwm7lL5FqkBJhS7QUU4lmjTQlNIGS9Ecj/sMf/Efe/sYfwLUctM6I\n", + "ogkCzWDQx7ItXN+n2eygEdv0vjzPy2TNeILfaJZJDwRZrhmNxsRJKbKTxBmWdEBA0PCJ4ghtynDe\n", + "VorxeEwcRXQ7Hc48cD/tuTk+/KEPkoQhDzxwP77rcebMGQyS9fVNeoMxt50+xfpGD8fv8ju/93uE\n", + "6YQsmXDqyBECIXnZd70Uy+9waWvMY89dY5Jp4iSj026RJBH/P3tvFmPZdt73/dba83DGqlNTd3X3\n", + "HXgnXlIcREqGIpEaKFlEHCGRYweBjUgZESASkhdFGZ7jIAiSQInzYCcvNig5tmwlQpwAphRIDEVS\n", + "A6/E+fKOPVbXcOY9jysPa5/Tp5uTX8JLA3cBja46VX266py9v/Wt//cfyjIn8LxuMAlSGJS5ltUX\n", + "eYbIH4JsWCcRH/7wh0jSmjxXFGmL5/mUZUa/5zIYBLRl2anitHptuVoThD1WUQxCMhiOyIucVmnu\n", + "LlJycXGG75mItqQuEoa9gOU6YrB3xH/5H/4b37dr9N31nde9u3cI/YB+r09elOSlphumWUnTKiYH\n", + "E/KOPRbHEa7jYNsWdV1hSVNbBAj4rU99ipfe+xJOx/HfFHAhDAzzcTvbDaTQNA3n5+fMZjO+/vWv\n", + "c3Fxwcsvv8yv/se/AoitB/3m3n8k2BFsZotVq3SgedNgmYI8T7i8uCBJVtDWeI5DEkdYtoVtaKMs\n", + "x3V0qlfXWVfdCb9VO0rxpnqMUbepU0+Go+j1uBHdhp5YFOVjjwkheP8P/9QPHoSyu/tsfH53O+XN\n", + "50VRPKZa2jAsNsUeHhHkbVtj309Odnez9TYbQ9MxNxR0RyetxjKlSVUVGIbB/sEBZdvQltpQxzRN\n", + "er0elm1zdOMpyrJisVxxNV+zcSgzTY+mVdx/cAfHdYE5tqON6U3bwbQspLDJ6gbX30e1Bk3dkJaS\n", + "WhnYtokUgiRN6A+uc3Bg8/xzz3K1nHPtqX2ee+H93Ltzhz/4w8+xNxrzxVe+wi//8i8xnc4J+30u\n", + "zy+xHZ+mafnABz7AV77+VUR/wJ2zC9okxfeHnD79LPcvpqRRjNsb4btj7ZnhWhzsX2O5nCGEiWXb\n", + "NE1N3qQoBa2pGAwOqZuEloqvfOkLPHXrKSbDISrU+Kxtj7cbq+lbCGmT5QWmZeH7JnWd0g9dpGmy\n", + "XFzSonAchygpqJuG4SDUAb+mSWsKsiRhGAZcnN37fl6e767vsoS0MCyHvG54eK797Iqqoj8Ycng0\n", + "ZjpfYVoWRZ5pXYZl4roOWdYyny0YDYZ8/Rtf5QMf+ID2AS+1XF0BspVboRJKF7/+YEASx9vT+I0b\n", + "Nxh1QrpXX32Vy8tLfuVXfoVf+7Vf4/T0lKIocF1/8yQdq2Q3klHiWCaN1JoHzw24cfMmX/nylzvY\n", + "osTxA20+V1UoIE0z3Yh0sIbrdMPIpgudAehM7HYh390m0jCMLR1RqcdnfZt6ZprWY/XrezXY71gB\n", + "3z3q7Bq7mDsvwgbo310beh48LrffGKXDI1hld5q7W9Cl1HmTrXhEsjcAo9VyWN91SaoSy7SYHB4Q\n", + "xStOnnqWZRSjlCQrYBotqBtFUbbEGdBC00BSpBpzCyZYtk2SpkynMfvjfeKioEmLDhoyyMuStpHa\n", + "JyVJuH79Oo5jEfoevuvqgmiaDMZ7lNLi7tmMxSpnMD7ipJXUZUGaxvzO//F/8oH3/xCB52E7DnGS\n", + "UamGW7duMV/HXM6uGIxNYjXlz778FVrbZbpaczA5JCkLWmVgixbHMCmznLLQobRVU5BliR4CqRaU\n", + "JEtqVGvg+z0so+Dq/G2ylY9nh7z4/A/RKJMyb5CmqTm0baNVlW2LZxs4nk8cJ6Bann3qlCzPSbOU\n", + "0ahHVTesVzGe6+E7JpVQFNEKQ7Uc7w2/b9fmu+u7r6vZgm+8+jrXT2+glKLf69OzbK6mM6arNUVR\n", + "4HkuJyfHJElEPJuTei5pmnK4p61iLctmvVxgmNovfBOFppTaJmoZlg1SEMXRY37gWZFjWiYn168R\n", + "pwlvvfUWzarmlT//IsfHR9391ezUDvHY36rtao1hdvWjpakU73v/+4miNefn5ywWc1zPwzWB+lHU\n", + "mezgkrLrlLV9hVY3t+KRSRV8exXlo9r1iDa4C6Ps2jb/86x3rIDD47mYu5/vUnZ2DZt2VU27RfrR\n", + "sODx54PHu/HN522r1YCbj4UA2baIRuFYDmmaoUyT6WKOGwRcXl6SRQmO30M6IVfLmEoZpFmBtCwM\n", + "BI7tsFquKSqDg8MT5osFgTAI+gec3nqB+WqJ0bZkWUYcx5ob7hp4PY/BYICUUockRxVL1yKLYixT\n", + "cHpywu17b3JwdMJg/4h1UhKvV4xHQ6bROQqL2WzFnXv3uHHtGqvlgqOTU3qDkIvbdymKCtUapEVD\n", + "0Uqeef4FLmZX7B8cce/BHXw/pCFjMhqxWsU4tknoWFStwnEdsiyh3+uxipYURYnrhpRpTpxWONLG\n", + "UDXRYonyGrJ4gVIWQW+EECatUNA0WLZJFKc0VUktJK5lUrctZw/u4nkelmEwvTxDCTiYXKOtG+YX\n", + "l5we7rHfDxgP+yzXy+/HJfnu+udYYX9IXjQUtbaFffhwyipac3zthHSVcnA4oVUt33ztNeq6oipL\n", + "9kZDnn32aWYXM77xjW/QCwIiYwVsKHia2aHaFkMnIFOXuoELgoCq0iyxjS2zZVlEUcTBwQHL5ZKq\n", + "zviTP/ljhsMBP/nxnySKI8JgI0LaNHpdEyf1CdwwTAxpAAaYgihe0+uPCHtDsiznm998ldbQIc2O\n", + "45CnGdI0qcuyc1vUGLsQOsjCMK3HYF3YPfE329nWJmtzw4rbQEOaWfcoOEZnHDwu+HlyvWMF/BF3\n", + "Um7tXnf530+mrcOjHWt37VrIWpahPRPkbnrG4/6624FGd+xRSmEI7eAnJdRVhet4pG1Nv9cjz0ui\n", + "WtOKskYSXa0RdkBSVpQ1mErgOR5FK3DCIa7wiNMSx+1xNVsQhg2rKOtEDDZNC54f4nQ8XWEKZosp\n", + "dV3j2A5hP2S5mKNokC1UTcEzz95CWj6LxQrbcrl5ax/XdbEsmyyNEaohTUsWixUvv/wy6zgmjpbc\n", + "vX0b1bT0e0OG/THiuGY8CPA8m7LIeOrG9c4jWXL//l2G4ZiDccjtew9pakWcZxwMh9A2OIZJf69H\n", + "VYHjjPCNIbYqqdMVRluQJRGW4eB6AbWqMEztJ2F5HlmW0/MDAtfDtG2SJEM2Nbeu32C9XpHnBZNx\n", + "j7oVxOs5prQ4vXaMbxkMQwdBTfAdvFDeXd//9Y1vvo5l29x7eM5oOEIqQd20PHx4TqMa5t+cMxzq\n", + "SEFahaAhz3K+8IU/xbM9XnzhOb72ta92qks9xDU3Xi/ShLoGNB2wqmu+8MdfIElSmqbh6aef5umn\n", + "nyJJUzzfw/Vcbt66yXR+wXyx4Etf/jLvffllJvsT3c2Lx0/wis5iWRoo1c3WpLYoGPRH2rfeEHiB\n", + "yYvvfR+zizus12vMRoCUGKZJUzeapGBI7TPeKixTku0gBrski43x3i7TrmkejxXcfH0DGW9CJTaq\n", + "8u+03tFQ483Os6tygke49WYYsCnQpmluZeObx54M9d2l4ABbkc0jvmaHS3Xe1w3VTpcusF0HpIFv\n", + "2VSGxcOHZxw/8wLS8aiUQBha/KIUjEYjlNA2sUXV0DYNliHx/RDTkAT+EWEnOljHOlczS2P6/QHR\n", + "esloPNJUK9cnSVLaRnF+doltmzimgxSKyf4hTQ1RtOBytmI0HDAYjkjTFMPyOLm2x2x6wcXFlNVi\n", + "yfve+z7yvCDKcgwBP/5jP8adew+ZzueEYUASzTm/OmdvNKIqc6RowarpuYrJyKVM5wQ2UNcEgU+S\n", + "pown+7imzWw2xR/26Y/2WU/nrNcNQ3+P2cV9UCYIi6ptaNqalpqmMomiCN/3SdK1VrOahlZGGibx\n", + "aoVt2xjSoFExlimRlpZ5H+7vUacxRZ4zm55h2xb/6B//Ll4vYDwcMpvNtI/MYklRVKRpimlY+H7A\n", + "wcGRtvr1A/JiSZZlpGnMfLmgKIptAEcvHDAYDlkuVpRlRdFIFnN9dI5jzV6hE5lYhk2apBRpzng8\n", + "5uhoiG3bBGGPMq9plOLOnTukWYoQgjJP8AMXKQWn10+5mk5ZLFfkZYOSkiDsIQ0by3Kp85qr6ZyT\n", + "4xMQOYahGSpFnuOYWm9gmzoRyjAs6qrFcTyEDWWTsl4sMERDHkfkeQqqoVUwW6y59cyzfPONN7h2\n", + "/RaqlSB02lJTNxwfHeJaFqYpuXvnDrdu3aRpWpI4RSmJH3iUZcFv/Mb/wL/+1/8ah4eHuH6AIQ2i\n", + "tbbujeOUMi8JQp+L6SVFWXB6eg3TNLl//z77e/s8uH+f48NDnnnmPdy/e5+3b9/j5o3r3LlzmyyN\n", + "ME0NSyilDaXqusGybJarFZ/97GeZTqcIIZjP57zy56/wwgsv8Au/8AvUdc16vSbs9djb26MoCr7w\n", + "hS/w4//SjxOGIa7ja//0rqaIJxywBZ01787DEp2CJaWB5/kcn5wS9iLu3r2LFApDgmk5SFpq1aIQ\n", + "2I7moe9SBneJGJvEq01HrZXZ9s5Mr9EECMRj9OofaBrhn3z2/wLYUms2w8zHyfKPGCrweCzSBjrZ\n", + "SNM3viC7lJzu/3pMDCTQftpN3WjKkgCEwBKGtmKtWtwgIKkqSin4r//7/46//BM/hW1a2LZHmtdM\n", + "Fysct0etBEHYRyHwPJ9GKUQriNdRd4roFIhSJ/J4ntfJ+02yPEMKk3WU4Do+cZrhe75+01pFWxfc\n", + "vHHKZG/EajVn/+CAqmkoqwbX97n/8IKirIijCNFqqbljGVR5ynhvyNPPP8Nrr9+mPzikrCDJdVxZ\n", + "XReMhj1m8xkGgn7okcXnxHHGapWwWKVcu/4Ufm/MfLnGdjwQJqsoZm9/zLqYE68S+s6Q0A5oipzD\n", + "/QG22WLZLWm6xu952nSrNjXlSgjW6zX7+xPW6zVSGvoY27aURdkdiUtM28X1Qr1B1g2ha1EVGeNh\n", + "SN00lE2DMEzyNOlOVi1BEFJV2lJAIGmbhrpqSJKEsqroBwF1U+O4zvZm1iremjTNEUjSNMM0LKQl\n", + "qJua6eyKycGEu3fvMJlMWMznHBxoBd94vE+R5cTrGU2rA6yjNME0LUajUYe/ttiWSVnk2lxpuSAv\n", + "ciZHRwz39snzCmnYLJdrVAPTqzmjwYhRf4jpNgjZYhpym2Rf1y112Wo+ddmQxBlZVhCMfPy+Q1vX\n", + "mIYA1dJUFU1dUVba7KltoShL7p895Md/4uPM5jM8x+XgYIIhDbIkwXUdhoMB6/WqOxUbWJYNKF55\n", + "5RW+9rWv8tOf+Gn6/QFB2CPLckzLJopiemFIvzfgajrF8z1aGtbrFZ7n4Fi62To9ucZ8PqeudBjJ\n", + "5eVDbp6esF7NsExo20eEhKZRKCUQ0uCP//RPuLy83J6ioyhCCEGWZXziE5/ghRde2J7W79+/w1tv\n", + "vcmdO3dxHJe/9V/9Lfr9DYTSnb7ZnLi/VTL5napg09Fr1+s189mUssi1EZroRHu2RdvZyGrk51GM\n", + "2pMsk03sm/7a40PKzfdWVfNYfZNS8tIHfuIHj4WyKba7DJEnf/ENB3Q33QK+9UXaFfds1i5kspn8\n", + "AlvWiWg1boXQtMFaB49h2Fr9BoIv/tkXOdg7QEhBkecI4Oa1a1w/miCEZL5YkWQxWVGSlGtapfBs\n", + "l1HPwbFt7VNS94iiNVEck8fx9oL0XJcgHHLz5AjTclmvE/KioCxrEIqsKvjm175MfO0Y17FIHIOr\n", + "2RQlDPrDfaoyJ04ypGEipIGhFIYUhOMJb91+nVJlBMEI2VZk64SyqvF7ATWKhxcXhEFIUzWcnV3h\n", + "W+B5fVxvQMslbVsymz1kONLFxvUcTLOHKVt6ZsXx6RGidXBND1P0KYuIqq2osoqqKilzk7ZpKatc\n", + "m3y5DoYpWa0XnaTfxFBm59diYlsGozBAWg6W4+F4LkkcMYcO+akAACAASURBVLs6px/43H/4gCAI\n", + "MWwfIcD3dQpLHEeoVndmvuchpUEYBLiOQ+CNkVKQJhVlEXN2dsl4b0TY6+kEIVVw/fSQMq+J45Q7\n", + "t2/j+wZZnvPCc8/x+huv47kOWRqhVM2gF5DECRfnD+gFAddO9AC2qEpq1ZIVOet4RZokWJbOvNwb\n", + "jvG9kHWUomTD/QfnvPHWXRYr3fH7fsDeaI9Rb0idr6lsyXodIU2B5/u4jrMdco3HE5I4xZES3/fJ\n", + "shzbs1jFC0CQC4ijhLIs8DyPo4MJrl8iJbz99ltcOz6iLlJCz0EIqIocy/fp9UMc2yFJMwzDYjwe\n", + "sFotSdOYui557bVv0O+H9Hs9XMeiyFMEAtsw2B+NSNOMe3fv4gYei8WUXi/AMg0EUBQFe6MRt9++\n", + "w+HhIdiC+WJBr9enKDXTq25LUA1S6eKtbWMtLi8uuus0IC8KsiTh5No17t67hzQMXn3tNd7z3HP6\n", + "FN40uK7XpdjrmVVV15RV3Q0fv7VQPrkE357xITBoWhgO93EcF9XWXF5eUOSZZkq1DYbjUOYFhnjU\n", + "MO7GPW6JEh3bTj/2SMDzaBYntmjBk83rd1rvaKjx5u8NDLIp1k8avzyya3xEPXRdd/vxJnB0gxdt\n", + "XpTN2o04gu6IUzUgJY3QeHgXEanZLEWB5/f5/Gf/iA9+9EfYH48RtCSrNVW6oOcHqKbhdN+najwM\n", + "1wNpUTY1WVpQFgV1nSAaCxMY9x2eun6AYZqU5a3tYGaxWnB5OSWNtR+H6wYcT8b6dRB99vaHVEVG\n", + "nqe01ZrAllieT6M0FBOGfeqq48ELgWVKlqslnuczX0yJVjH7oxMsaSIdE0MoBoMeffoslyuiVcrx\n", + "4Q0cQ9E0NY1quH4jpKprnr9+jdu375AVCaZtEMUp/TCgZ4LVZAyGIa6jMybbQEuQi7xlMj4gTUo8\n", + "L2CaTOn1Ndzjui7SkCRJg1KNVsG2NVXH3V/NFL3hkCROSIucXt/n6OiANFlz8+ZN8qJmFeeUWYUr\n", + "WkxpMOgPGPQGXDs+RrUtZZHpMI1kTZIkKKXY2ztkcjBicjwmSROE2XJ+8QBpSO49uEtVVNRlw/HJ\n", + "CYPAw7R1CPZHP/JhkiymrCru373L4eGEhWUw7A2YTqcs1gmz+RylWkb7Q5zAx3ZMxgf72rohr7l3\n", + "do7OXTRRwiPoDeiNDQbjA6q64MH9+0ijpd93OD1+ijSOsfyxNhmrKqpGBzmYhsU6WlCWNXXVCdaA\n", + "tqg4PjziwfkFnheyWMZ8/Kd+js9//vNgOPi+ji97/pn3cHZ+RhpH1LU2f1J1TRJHOK5LGPQoipJe\n", + "r8c6iqibBtOSlGWDaRm8/4deRgitMPZcHyEkaRIhpYllmhwdHZLlCY7dYx2t9HstdUGu6xrLtIhX\n", + "MXGSoKSg1+uDKjr8WTxmjdy2igbBxfkFVVWRdq6GtqMpuJuT9oMHDzC6IHKE9sjv9/us1zHz+ZIv\n", + "fenLfPxjH0cgUErbQ4AeYH7bLDGlvgVgAf2zSGlSljWeF9I0FUfHJ9y5/RZRkuO6Gj4RpolqHg0c\n", + "nyy8Gxrho4bT+hbYV6lHyszvteFs1jvKA9/sQHVdP0Yf3MWQHMd5LMj4SYaJbdtbfuVmEPpkGMRG\n", + "cr/7YthKJ9S0QumOuws+MCyTsNfj1dfeZLlc0vMD6rpA1TWWAbOLh/jHR13oQJ9SNGT5ikZaIE0C\n", + "zyBwfYxuWBFHMVoNVhCvV/ieR5ZkiEYHAD//nkPiJEWhi2RZLPEchzheUBQthlTM5ndYXK2w7QG9\n", + "kXYK7AUBqzTFtn2SJMM0BHGS4XoBhtWwTmL6gyGqrcnSDC/oIYUWVkwXK27deoYwaDClSdtK8irR\n", + "1CvDoqlK3nr7TSaHB/hhoDm+MsAQcDjoEUU5si7Iqpyg71IUKY5rUZX6SJlFFXlaYlkGeZHiBzpP\n", + "tCwLXHeE9od5lMzt+z7tMsJyHWohMOMVaZqQJksG/R5REtO0BmF/QFEpSNaUVUnbVhRZThprHHWy\n", + "v4chdF6NEA2mYbJYnuP6HoZlISSsoxXhwCWKE1xfcnrjBgaSsqxYr9cYpkFe5NiuiR94mKbB6ek1\n", + "zs7u0+/1ODt7wM0bN8gKC8f1yYqUKItQqsEoBbZlU5U1B5MjLNMjzwrOLubMlxGO5+D6LoYlmBwe\n", + "c3xyxN6wTzSbcXn1AEsaFG1Di8QwtZeOkmxTl0yn0T7aSvOXi7zk3r17WLbHCy++hGF73H1wzsHR\n", + "NYqyRDUlIk2IFgsc2+by4iGDwZBwFGJbNo7jajOoqmY4HJJlGU3TUpY5lqVTkoLA5/DwANDFxLK1\n", + "F894NCRax6i25erqgslkwipaYtkm0uiwXNl2boQuhmHQD3tEecbDhw954fmnKbINtxvKqgTVeYw0\n", + "Wui2sWvesLTyPN/OlI6Pj8mybEfIZ7BYrLZ15Ctf+Qo3b95if29CEPg7czaFNHaK4maqKbrB1u7j\n", + "aCFbqxSmZVLXTVdfLG7depp7928znV3hOBaGkJg7qstdKf0uc26TxqMx72/lehuG+VjxfpJG/eR6\n", + "xwp4EAQAWz/rTYdcVdVjg8mmaR7DjjaBDZsjyUZyL6VE6ix0XeiVQpr2I2+BDp/aTKUbQ2ipbqto\n", + "pCQ39S5tVjVZmvB7f/Q5jm89hcorktYlTkosQ5FFJTDj+skhV/M5vWGfwPdASrKyJE0T2lawXq2p\n", + "yprBQAsOBHCwt0/ZVBiWyXQ2RbSKq4dzzUixDPb6fbyJDwis66csF2uiKCFwDujfPEAaLctVxN7A\n", + "Z7m+YGzZCFkhzZK6UTQSXM9m5B6wPx4wGAy094sjWSwv8ZSWOBfLOdk8xHY8ppczPfDxPNK0ZBll\n", + "eLZNr9enjUuGjg0SaplRFAVJ6XPt1lMIaZKmGVla0TY2q6RidrXAPrJxXYHnSZapR0WFVAbJOt1u\n", + "wE3TkOcFaapzLpum4drRgDZrUQomk30O9/ewLEs7PlowvTrHtnXREY7E8x0cK6BtKswWyiLl7GFC\n", + "o1oEBkG/j+8HHN28QZ4XNEpwNZ1zeTXH9wWhP8ANbaLlkjyLGYQh+8d7WwvgLE1Zr1csZivqsuT5\n", + "559nuVgQ+C5vvvk6IHE9j4PJhBvuGNu2WS6X2I7Dm2+/xeLqIcvVitVqRa8XcvMk7E6CkrqsSC4e\n", + "0DQtVn3C4dEJlm0TJdorpiq14jdJdLEWQjDo96jyEkMIAj/AkJLCzHnz4UPG168zvfcGoVHTNgWq\n", + "LemFDm2lKIocFUIjJO/78IdACFzXx7AcBAbCMAl8gzzLsCyHIo8xDZssK5jOFgSBh23qGMH98YS2\n", + "qVgv5mTxGtfTuZOjYch8doFpmrimQ5mXWK5JpSqqqiAIfPJSu4RatuS5555lNp9RNGBgIKRBWVZY\n", + "tkFd5zRtjTQrxnt9ZvMLrEzbyMbrJb1ej8DzuHH9OqppKItKB4V0TeD5+RWW4zPaPyItGs6nc4Ks\n", + "oBf2sG0Dx9w0gzvMtHbTMG6jjUFs9CE6pR6gy5VGmhbKMLl18zkCf8S9e/fAsmiFhmEtQ6LqGql0\n", + "2Epba6FgXVYIpD4NiEe2IZv6rQkdzbYhhe/dgb9jQ8zP/j//+xYTesSBfLT77O5a8EjR9KR3wK4N\n", + "bduyTcIQG8x8B07ZdOGGYeA0LdJ1WCQRgecjkWR1A47NH37mj3jlc3/MJ37mE5i+i2OGNFVNWaQk\n", + "6zlFFnM4GbM/Gevsvl6PVimqtiEIevpNUlCVDUJpXLNuW0zL1Ck5hqBpGxzLoamabuMqiWM98Kyr\n", + "Gi8Mmc+0Y9vBwRFVVegDnTSoaz3MLMqG5TrCcX3SXBt2hWGP1WqJ51j6IjEkCoVhaGXlYrHCsGyE\n", + "sHBsh6ZRSFMSJwlh2CdNss4/vCD0XCQ1nmPR1AV1VWF6DllWIITE80Ok0E6LtmlSpDH9wCOOV8Tx\n", + "inB0ojsr6GiaOs9RwQ61Sm/KQuU0TbsVQuhOBIJAH9k3fuqr1QrTtVGqwbUtaBoGgwDVtJqCZRg6\n", + "AKCsKKsSKRVu58SItLh77wHXr58iEFhWt+W3DUq1lN1Ns/FVNzsXvSLLsG0bKUT3HgnKqkYISZIk\n", + "2+93XbfrUm2m8zmr1ZrRaITn6cdty9JB00o3E3medy6S4PlBBwHuWEagKWiWaVIWxdaWtK4qirwg\n", + "TxI81+WZ597DxeUVluNovjSKpiqBhsBzUaplulhwcHKK43iUVY1h2kipnTlNw9S+Jnmufz70gPns\n", + "wW3miwt+9Ec+RJkX+K6PlrnblGUBou2+19j+zHleaNio1X70nud1ls66mWpUw2qx4Nq1E6q6okhj\n", + "8iKDtsa0JFmSAHDv3l3yumG5XDJfzCnzcltg3/ve9/Hiiy9SFIUetirBxcVD3r79Nq+88hdMDo/4\n", + "t37plzk5uUYcx5yenlLmOt1o2O/jd3MAfY1tjKUepxpvGGvfbrz5pK4kSRLOzs5YRRcEvqf9jeqa\n", + "tq6wLRPVbKCiroa1IKS2pd9g35tOfQMZ7z7+3g9+7DsOMd+xAv7Fz+uch7Ist0PI3Z9lNxShqqot\n", + "oX3TqT+Z5Aza2W93mLlLJdzlnQshCKTBosowBz1cTJxGkKP4f7/0Cn/7f/zb/Orf/Pfo+SH0PaJV\n", + "RpGkHB0fYtAShh5Xl5eUecKNm9fJsozDw4nOv8xzjfW12mrz2rVTLMvGMEyKqiIvCxarJVEcY5sW\n", + "nu2BgLAX4HleF9hQaxqTH/DqN1+jyEstTOiFnJ2dMR7vs7d/gGk7FEWFZTsslxFh2EOaGpe0TIOq\n", + "KsnylChJyLKM5XKJ7/c4Pjkhy8pHrB1TYnUCJkOaGj9uWoRoaaoCU0JVZlRVwfs/+EFc1yXPK1ZR\n", + "qgtu3WgXxSJjb9THNAx6PZ+8Nuj1esxmM2az2XaTzfNcC3gsnXLU7/dxHc3iCAKdzrJxc7x37x55\n", + "VuK6Lp7n0ev1cDyHLEuZXl2QJjGmIbl+csJyudRqv+MjxuNx19XBbDpnvoqoqobRaLL1aBcd3BKG\n", + "PmEvIOz1Wa/XRFFEHEdbXLQfBqi2JQwDZjNNaTs4OCAMQ8Iw1HTG5ZJvvvZN3U0pwdXVFcfHx1tr\n", + "46LQ12bebQaO44BSlHXN8ckJy/VKX9elFr5s4EEpJYPBQFNWu6am6Taa9WJBtF7hhyGO5zOZTLAd\n", + "jySJKIqCqspJEz3YXK0jRvsHjPf3qeqWulHUTctgMKapa+7fu4/nelRFQdNC08Lrb3yd0cDn6aeu\n", + "Mx4OUUoxn62o64YwDHTClG0ym0d6M5Ky4y7bBEG4pfltYhGllLi+h0R13tvQD33SNCaJ1yha6qpE\n", + "AGdnZ0Rp2jUTZbdRehweHjKZHGB2mZab+/+1N17ni3/2Ckle8Eu/9MsIafDMM8+wv7/P22+9xWg4\n", + "Ym9vqOGnumI4HJLnOYOBngeNRoNt7Xm8Vnz3Ar6Bbauq4ktf/VOklPR7AbQtvmOTJwmqrTuKZGfG\n", + "Jx4xYnah5J36uP0/DMP4riyUd9SNcNdu8duZVQGPDTGfPE7sYuX6iXVxl90L0I0tOsL+RqqvjyeV\n", + "bPXwQ0mqtkEaBp/5w8/y2c98lp/6qZ+m1xtyfHRElqRYlq1pWUmCNCRlUWAYkixLMA3YHw9BtRwd\n", + "7CNMQasUtmkTRwlNrXm1Qgid+I7C6YpRURRYpk0cReRFhmlpw3fX9WlbODt7iOcFWLbdyfIzhsMh\n", + "dd1y5+7drgPMuHHrFkVedvQvE4WezNd1zXw+5+jokPl8RlnVBH7AU7eeZr5YUtediMCWFHmJIQ1t\n", + "yF9W9MOQ2ewKzza5ujrn+PAApVqatsG2HIRhIqWJaTmYhjYqUm1FHMfYtkmWJlRKn0Qsy9zCZHle\n", + "cP36DeI41hxxz+PO3bvcvHZ9i2kWXfKQ3nh1gHRd18Sxpg/Wqt120LZhsFot6PVCPM+lrmvNyy9L\n", + "hJSYRg1ImlYxHO5RlDXCsBDoay3LE534U1eIDpJzHJ0gY5gGTV1TFTlZnhEEHqPBkLZtWS6n2p62\n", + "0alPAolhmNsuOY4THNvRG3Kl7ROazpPec9wOb25QAoJeoH1zJLiWS9ZBS5ZlkaV558WR7iiTFVVd\n", + "k6cRR5M96B6TpkWRl+RFQds22kK5KnEcm6vplNObN8kyXaBH433SrKCsGsqyhC4YWyioG0VZNXz+\n", + "85/h5fc+x+HBHqaAfm+gN0XLJopWlGWBaZvYTrA9VSilts2Wvh4tPTRVirrRkXBVWWI7NkKAbRo0\n", + "dcV8MUN1X0coZrMZaZpun8uyLPo9HRSuIxJ3TexqPvf5L3B5dcXk8Ihf/MW/ymi8pxs71WBZjq4B\n", + "VY3jOIyHQxYLDceYpok0wHU8hNxQlcUW1vhOCMaTXidN05DWCRfnD1nNp5imQVMVBK5L21RIdkNp\n", + "Ou9y9cglcYMs6AyBR8VdCMHLH/r4Dx6N0HGc7qaMt7j2ruk5PBpSbi6KJ/11N7/8dmBgSVTT0ABC\n", + "KU3UNwxs69GLIoTAsA1io0ZmFX3ToKLl7/7W3+etr73Of/Q3/x0cx2VeF5wvpth5g/B9PN8HAupW\n", + "Eac5Z/fuMZnsE/Z73L1/xs1rJ3z1K1/H7zl4gUfgBVimReAHDPp9jfU7LnlR6JQPAGxMw6Q/CDkJ\n", + "jyjLgqIoubi8II4TTk6usVpFmIaD57l4foBSigcPHjAc9Lm6utLQRpHiuy6WZbJex3heQFlVnJ/d\n", + "ZzAYELgOxy+8iJR6YHx1dY7vBShLIqTAC32SJCGJU4xWYphweXaHLEs5eOoGzz79wzRNqbnJUsdY\n", + "LRdrLq9mZFmO5/rYrottWxwdTUjimMDfJ861Ne56vWY+n5IkCXmW83uf/mdUVcVqpRkLH/zgB6kO\n", + "95GG4saNG9rmc7YkiiLSNGU+n3Lr1i0sSw+BAi/Ur1WSscwTjo8PkVKf4vr9HmmWUFU1VVVSJEui\n", + "JMU0HaaXF4ChaaN1y95kn36vj2WZVFVJ1bQsl0uuLqYo1dAf9PA9D98PuHnzBnmRcf7wIft7e1y/\n", + "fkxZlSyXK5pGcf/+faqqJvBD6u5a9R0bU0Aroa5yxqMRtGAYgnB/jGUbLFcrgtAnThKKsuDhYq09\n", + "5j0f0et1xaTl+rUj6kZ1G1xBUZaU+ZqyynAtbW3sOgamaeP7DlmWaTtUqe+Bk5Nj0kif0lZRxGo5\n", + "Rxombd1QFSVRkhCGPfK8wDRtTEvTYEfDEXle4LsOq9W6K8YwmRyQpgmraEmSxNt5lOtoa4jVatWd\n", + "ArRRlecF2JaGvnzf5+LinJu3bhJHEafXTlgs50jLJk+TLizFIwiCraW0ZTnkmY4kzDKdcKW7V4GU\n", + "BvP5gsPjYz760R+l7EJdbNvm1VdfZTQYcnLtGEsK3nrrNmVe8vTTN7m8nJLnOScnJ8xm804oJfF8\n", + "d6dZ/M4N7oZ0sXVRlSanN24Shj1uv/UmlmmQ5gWoFtMQXfh402lBHOCRfcimEd2lR2+a2u+23rEO\n", + "/DO/90+2roPbwroTCPqI2F5tf6GNDHWzdhkrUkqKDk82NPETKbQYQqCPImVHuDdMg9LVz1MVJZ/6\n", + "1G8SrSP+lU/+FfIk0xmOQhAGPWhb8u6GUUISJRlBf4jtOETrFVkSoZoC6pLjwwluYGFaElOa1FVN\n", + "nmU09ab7t3A8D9PS5k6WaWEZJnmpj/NN22wHsj/yYz/7/X1T3l3vrn8B19/7+7/JK198BWGZPPfc\n", + "c7z88vswLR1evlqtuXnzxpap5Hsue+M9iqLqIDSYTPa4uLhif39/C8v6gccGE7ftR+ZTHWVl25Vv\n", + "1Nsb645SbQIhKubzGfduv4Xr2drlTtV6GNrpNTaU5d3CvWHk7c71hPjuocbvWAeuj21sVYq79JtN\n", + "0d7gUBtZvVJqi5lvTGDKjed018VvpfRNixKqy2GssaXO68vyDIEBaclZNOdv/y9/h/fefJaf/4mf\n", + "JHRcvEGf2eUUr4KzsyvsvQHDQR/XdcgrnZazXCywXRfTkAwGQxxTEi0XvH37HqO9HkGo8d1hb8De\n", + "fohQunPUhjzaPrOsa0xp6BgnKXBdB6SgqrSt6rvr3fXu+t7r/PySr37t6/y7/8G/r5OxwpCyrGhb\n", + "sCyb27dvc3J0RF3XhGHIdHbF8dE19veHXF3NOT+/5Pj4kDTNybKM4+NDkjQlTZMOumtYrdaMx2OE\n", + "gKKoOphDdUNVpamPbYswtFxfGDb7exPapuHq8lzz5Q2Lusy1VbWQmDshNvCom9+V0j+pZ/l26x2l\n", + "EW4MW+ARprQpxrsT4d3B5OaXK7tBz6aYQxeN1g3xUJq20yqlU73LgiKJccOASrXM5jN+8zc/xYde\n", + "fB8ffOllQtvXDIfS5WhygCe1mjCtS1bLJXlRIA2LwXDIaDQm37ACmpo337rNZLxH2BuRFQV5uWY0\n", + "GnJxNSfwbPIsx5AS23W6DStg6HnUZYVpmMRx1NEpTQxp6hPEu+vd9e76nuvhxRW//p//FzRtw2Aw\n", + "YD5fYFk2q1XE008/zfRqSpFr0VASa3hmvV7z4EHE9evXCMOAPC90wPGwz9X0CtM0GI26oe18znA4\n", + "ZLVaAdDrhTqYwtq1hVUa6toJOkaaHB9dwzJN3n7rTexegDQsAsuirErEDutll2m325XvKsu/0/ru\n", + "LPH/H9eTplMbr4C6rnFdd2tctfneXRHPJlghDMNt162hk84JrOtgDcMAAf1Bn1opvF5IUZXceXCP\n", + "//Z//p+4NjnkR59/H55pY/Z9wsGAoDWwy5aHyxmLKsM1LYKgx+TgEMe2eHD/Hg/v32G9mOKakmEv\n", + "5MXnX8T1QzBsTMtHGi6XlwvOLy5plcTzA3qDgcb0bIuiKjXtaLUijRN8z8dzXUAfobIs+/6/Ie+u\n", + "d9e/gOvn/vInSdIChCYPHB4ecXR0TBAE3L9/X0vx8xzLNEnTlPFoRBStCEKPt2+/jZCCs4cPaNpq\n", + "y0oxDMl0ekVdl0hhEEWplri3sFysKcuGqmz1IFUp2gZUC7RAqzHspm4RSPb2DnjmmWdZRzFCSMpa\n", + "h5DrP2LbjG6G30/ahvzAduAbiCRN060lrG3bmKZ2sNuA+xsZ/KZQb3jCG1fCDZRimibStDVFLM8x\n", + "DAPXdjBNk9ligRv4mI6Naip+/zN/yE9/7OP8+Ic/SrFOqFDce/sutjBwkazjiPHN62BIVldziqrB\n", + "dhx6/T7XT46pioI0TXn48Iy6hbpVuF7I5PAYpRryPCWO77FarIjjr3PzxilZEuukes/BthwGwyGD\n", + "cEgWxxR5QVkV2LaFNOVW5PTuene9u777mq9WHB2dUBURdd1yfn5BFEW89NJLjMdD2lpx9iBnMh7T\n", + "NDUX5xcUZcFheEhVVZyfP6Qoio4GnG1VpQcHB1xdXWKZHrZpkKW6ix8MBpRlQRTF20Lb64XdPE9o\n", + "XYcwsC2TtgVawd54gmmavP7aq3i2RhcM+a0xkZsOfHf9wA4xP/cHv7v5GGA70NxIrJ8E8nf+7Xbn\n", + "2sArG5+UjUWsUArLtHBsnTdZ1jV5XTFbL/mH/+QfszfZ52c+9JfI6wrDtQlNF0/azFYLpO9S1RWW\n", + "0tP2yhKAQVPVqKrEsU2oKyzDxPMDqgamizU1BnlR4TgWgpaqKoijJQYNQugMzUHXhZuWRdgLKbOS\n", + "dJ0wmexR1SVSCqpGc7P/yi/+0re8bn/8h/8UIbR5UxiGNG1LUZbcu3cfpRTvec97dB6nbdI2Ja7n\n", + "k6YFrhtgWg6rSEuXTcfGtu2tMX5btQihsA1TR0Y1erLu+T5lVZJkGXfv3eXg8BBpW1imZi+4Hbun\n", + "aRocx6FVijQvdPQUCtU+fjw0TXu7WW844HVdc/bgnF5/jG07lGWB7wcdH76k3+9rD5BaS909z0Oo\n", + "FsOyqeqG86spnq8dDIXQ4hfb0cNhANvTsxbb0MNsz/VIk4SqqiirSouH2lazFix3S1s1TYssyymr\n", + "mrrz6MiyfDuMnkw0tbFRCikNirJCtTVSteTpGtmUGKpiMOjhhD5N2wWUCLPLVoSmbknzgjfefJu9\n", + "/Qm9Xp9GCHr9HlIIzYmWYBkSRKuNqtxN42LQVApT6vdDCKirAim0W59h2VxOp0RxxvMv6nDpPC+1\n", + "iIUWUwqaStP22lZp10jDJE5SXNvkt//Bp/j5T/4coLQqV0kQFnkFcZqCCZ5vU9U1nulRV42+Xzra\n", + "n+M4HYMEmk5kpQBpGniet72vy6La+psEYYg0NGc8TVMcQ3J8fML5+SWWY/OzP/1j33JP/NPf/zxZ\n", + "ltMPLAzDZDgckeU5bdNFliHohT7rxYLRaIhA4QU+0+mU09NTZrMrHekXRezv7xNFEYPBgKLIGI1G\n", + "zGdrRqM9TFOS5+VOfdL5m67rbotu6NlbZo+wjI7rvW3Nmc0uefutN/BdB1M8boO9Wwd3bWSF+AHN\n", + "xNzI4jed+GZtjhHQSUuVQEhJSxdEKh4VccuyUI1O7tATY4VRNkjXZlYk9FWDSiriwGAZGvyvf/dT\n", + "/PDhM3zsw3+J0jUQnTnWOk1JzRwzdHBdG8fpkSQJ0+mUKiqwrIDxaI/ewX5XQGdajFMWOI7D0fEI\n", + "13NYLOasFgmz2RrLsnnPUy8RpxlRFOP410iziLNphOvWOL0xg0mfycE+cRJjWzZlnnJ4sP8dY5X+\n", + "/Et/Qdu2BEFAVuS8/vrrvPjiexmPx0wmE9q2ZW9vj/V6Rb83oqoqPNfBcU2SZM2w53Ln3j2eeeY9\n", + "LJdLFIoWi2QdYRom67Lq5g/a43y+XPDpT3+amzee4vT0FNew8V3dQdRCkWURm+g7Q3TWnVVOlq21\n", + "glAGnUCls8e0LKq6QilJAzS1TjF56b0/hO+2tI1ivV6zjjIuLy5RQnL7zpvcfOoG4/GQvcNr5GVG\n", + "WWqBj21ZIEpGfavjCWs+sus4nF+csV6vmV2lRNGawNe0tMPJPpfnF+yP9xkHfQa9AWVZs1qtWMZx\n", + "R32rCEMNm1mWxWw21xho0zI5OCAIAtq2YDDsUeQJUbREVrkOaO5OiYdHJ5iWq0VZTctw0KOqCoqi\n", + "oGy0rPyN117nS1/6Ep/85L+MYUikyDkY9UGlmKaFnL5BRAAAIABJREFUETxKbEmTHKffI81SFssV\n", + "pmmR5yUCSVlqDLfp0o/KsuBP//RP+Bt/49/khm1jGA1S1bih0YUrFCRFge14WswlDRzf05uv6xAM\n", + "Ai6WV3iDPmmacbFYIaWBwGA4GnM6PqEoClariCqvqcUa13UZj8dbEsJ8PqcqH6VmDfoBYagNt9Jo\n", + "rXnyjqtteh2HJM+IoojFfEkYhgRBQBD6nF+dIwzB5eX5t70nVF1wcrhHmWc4jsPDB/e186FpMBwO\n", + "eeONN1Cq4eYzz1BVFd/4xjc4nEx48aWXSNOCppUoTEbjCXfv3WdyMEGaBrPzJes4YTgYM1/OWC4W\n", + "3Lhxk34/4M6d+/T7fQaDHovVGgyDMAh5eHHBYDDQzUxZd54rCtM0qKqGyeSYtpXcuXMHz+0cCdsW\n", + "29Quj1VZYtuO3vTaFim/d3n+rh24EOIU+HvAAZpD83eUUr8hhBgD/xtwE7gN/DWl1LL7N/8Z8G8D\n", + "DfCrSql/9m2eV33uD353Sw3c7Dq7CTpbQ5iOy6069RLykb+3aRh6t1NgSEmZ5wjbRDRgGQa1lGQG\n", + "TNdLfvsf/iNOj6/zw+/7AOV8TWnodI3hcIjdGfRo4UhN2qkDVdvi+T5ZWpBl+ZZcb9s2Yehrj42m\n", + "3qZoADhOQNtAXbcURc0qSpDSwHZsqroE2RDHa6q6pOc7DPshAsWgF9ILA/IsRUrJx372r37L+/GZ\n", + "3/sd7dPRiUDKsmSxWLC3t4+UWm5eVTWGlNRV2QkeGuI04c6dO2RZhuXYfOQjH8W0LGzLZrVa4Tlu\n", + "56uuTe7bVnHv3n08z2Nvb0JVVhRFSZqleJ5JGIbkeb5Vsz1pHgZaeKFaE7r3uKhKLaJqWx2eUFQ0\n", + "LejkFQuJLkaO42A7PgpBXpb4vs9sPqXp1GxIgRAOZaUVi5P9Paqi7LwwdDNgGiZt0+B5Lo7nURRa\n", + "IJQmMUHg47seaZqiGp1tuF5G7O3tg2vs+FMIyrIijrXN7+mp5qcniX4/TaNTVxoK17UxDIE09GtX\n", + "Vw1xmiKkxXodYcsWgaLXCxFC0e/3uLy64OLhOR/5yEcpO4+MtlWYBmhWmqAVj0IBmlpfe4apFbrr\n", + "daRpqba7FacZpsFqteThwwcURcHLL78XUFsRkJRSc5ERqKazKxBaRUhHs63qFtsS/M5v/wN+4V/9\n", + "16iqmuFwTJ4VSGmQZTmW7VFVNW2r6PV6FEW2jTzbnIo3bqGbbnLjJOp0YcOmadG2mtOulKJFIQ0D\n", + "39OY9eZEvjG1UgJ+/mc+9i33xP/9+38EQtDznG1DmCR6WNnv91FKMZ1OGY1GTKdTrl+/Tp4k9Hra\n", + "cuL09DpJkmoTLiHIcn3Kcl27I1Q4nYrW6uT8gvFY2+hK08AwLYqOgCBqhWHIrT2IYQg83936nTdN\n", + "jVItd+/eJV4/1DJ+oZWhnuPQ7sjoq7pGSvN7Sum/V4mvgP9EKfUXQogQ+KIQ4tPALwOfVkr9N0KI\n", + "/xT4deDXhRAvAX8deAm4BvyeEOI5pdS3NbV9MoRht3BvCkHZ1JjowQCGvgA3fEmhFG3daiNBBbbn\n", + "scoTBk6ASkuWqmQdmvzmb/0Wt9wxP/b+D+PtDak9n6pSxEnCm2++jW1bnJxcYzjsI6XAcTLyXHfX\n", + "y0XEaKQVYGmakaYpeZ53A48Btu3gecFWNhytr5CGieNoB7zDwwlRnDKbzWhVg+2aeJ6PVZtkZc7q\n", + "7gOuX7tGVlTcvvMqh5N9jO8wWn7ttde20IMQgouLC5bLJZ/85Cfp9Xqd4MHCsS2aRg9FvvKVVxkN\n", + "9/jID38E1YkS6qamLBqSJMYyTZIkwvN8XfxNk9t3bvPsM+/pLkILKWE6u+wMqFp838eyLF0Eu3lE\n", + "mqb0ej183yeKIt1VpTn/H3NvFmzZdd73/dae9z7zOXfsCY0GCIIASXAWKVKUSIqmqIROHMliUnKV\n", + "qxK5ErkU5ykPyYMrT67yS8rlylviSqpSZSu2wyjWQDGS6ISkJJIiQUwkpkajp9t95zPueVh5+Nbe\n", + "3SRAKsMDuasaQF9033vOPnut9X3/7z/MFwtzUFsMhyMsSzMe94ljuceD4YiqrrFVICrCLCfNCtKs\n", + "wPVcFos5Fy9dpKwKFouFebgLzo5PmE2nuLaD8mDn0iXWqwVFIQERq/WK88UcZSkx6wo8dvZ2DdRQ\n", + "YtkWylEEYchkNuXg4AC39qgb2SS3trZwcsgyTc/2qMoYz1X0ticoy6IsBKpaLeYkyUbaYtfBD0I8\n", + "z2enN2KxWtHvDVicHWIpuH79OoeH96hrga7+zm/+pnRnfkDTyH1EN9RVCWi09YCloJSkV0W9iOVy\n", + "YQQfHlmWkmYJ3//+9wF417veheu6XL58Gd+XTXQ49LAsRVNXD+hptkA4cbwhCCNcz8VybCLbZjjo\n", + "STc0X+B4PovFAsf2GAwiRqMJeVZyNp8TxwlJkjAe9+n3JbeyMDmWJycnRFHEcDg0vvg1VVWSJGL5\n", + "W5QVoZH/13XNcrmkLAqO1zH9fp/hcEiSZKYKtTpCw49eaV5w6fIl8rUIh/b391mtVgwGA+7fvw/A\n", + "e97zbu7ePcDzPI6Pj3nysce4desWtm2zXq65dGmfF1/8AVEUsbe/S78/4PsvfZ/dvV1sz2d9NicK\n", + "Q3Z2tkCLQnp7d5eyqjg7P+fS5X3mixWqaugPBixWK6IwwPECTs/O2Nqa0WhNo0WdeuHSJV564QDf\n", + "dQDNcNAnS+XQqR7KSdBavQUT/9Hr/xUGrpT6PeC/M79+UWt9pJTaA/5PrfWTpvputNb/2Pz5Pwb+\n", + "G631N3/k++iv/emXOhZKK9Bp2094KOC4NpXxQ1iqZVlQN7iOI05iWr6eoVF1A7UmGA04zTb8wR9/\n", + "mWKd8oVPfZYyzhhvbXO8WTD0RSnpuu5DasFzXNdjNBpSFAW27eD7Hmke43muwfXE10QpxXK5Mhif\n", + "VOWe5xm/YUVRSFBA0ygsYyRVliVllVMUGVVT4zo26+WKOBaRwWQ0oBcFuI7Nv/vv/+Zb7v/f+49/\n", + "nb29PVarFdeuXWVnZ4dbt25hWRYf+9hHWa1WsoGu1oSez3K5ZHt7u3MlbCuaKIpEEapMxWiYL2EY\n", + "EgQhWVYY+CXqqpkkSdhsYu4e3Obpp58GFK7jMhgMumF0m7bT7w+kakQzHA2wbZvYJIs3NCwXK7TW\n", + "jMdTkiQBLKpKEwahVKGeT1U12I6Dsizm8zlFmRP1IlHwlg29XiQ/z7ZJ4gTdNDiO1y30fr8PQF7X\n", + "NE3NYjGnrgq0rrCUhW1buI4jSUl+KMpDW9bCaiWfq3iKw3A4MEVD/UBYZrkGN3fAtMJ1XbNYLlks\n", + "18wXS7S2Wa7W7EwHDPoRk+mYqipZLOY0Tc3e7g5R1KPIBTeu6wcVuNaygXciN8vt5hZFVbJYLLh3\n", + "TzaoCxcuMJ3KDKEs806S3ev1WK/XBEEgqkylqarazJocmkZjWw4NmtVGEoyaRihxf/XNv+RDH/ow\n", + "YRhiuz55Xhh82yLPSrGDiHridqgr2ZSLQgoXQw8uy4osy7tZS0sPljxYh6IoSbO8M6CzLAs/CKTr\n", + "yTJCL6TSEq9WNzW/+rlfesua+P0/+Tp1U3N1b7fbO1oSRL/fl7CPSJ6VixcvYts26WbNdDpjOBrw\n", + "2quvm8Fkwfb2Nnfv3mUwGIrPi+ty895dHn/8Guenc9Ca4XBoAjVSbEdM8xarJVEvIrBt4jjFDwLT\n", + "dZRmhiN2Bq4ruZ+245Bu5hwd3idPE8oiQ+nGPJtGidkVtIr3fPBT//8xcKXUVeD9wLeAXa31kflf\n", + "R8Cu+e8LwMOb9V2kEn/LVRlfCHm4HigqWxpN25ZTPfBB6aa2Shz9LGXRqAbLnFg+itBzKDyLY53z\n", + "v//hH+ItMj798Y9TKNje28OppNJZx0sc5TIejyjLitFoyHQ6Fdz07JzpdCrmO0GIFzjE8YbDw0Oz\n", + "0fWIoogo6jPoDymKnMViyfHRKbansGyLXtRnd2+b+XzFcrkmLzJcz6NpGsKwh2XBcrXGdgPCSGFZ\n", + "mtPzBXfurpk+ZKzz8PWLv/hJTk9PmExGNE3D/fv3uXTpElVV8MorL7O9vY3rDtnb3SFLMmazGaPR\n", + "SEzvoTMUakVUYoGuKcuCXi9is9nw1a9+lV/5lV/BdW2qqmQyHaKUTRgFoODpp5/m+PiYixcvkmUp\n", + "Gs1oOMJ1Xfb29tBaglnDMCQtC+7dO8T1bJNN6uE6DluzWbe5OLYZVleKPC9kAMWawWCIqxyUBaPR\n", + "gDSV4dZysWA8GnN4/x4XL16kqmpCP+gw2aqqSLOM2IRIBP0RKNi/cImiyCnylKoq0Lphs9mQZjmz\n", + "mUO2jlnNT7h69SrjyQRbWXiOI4cIUiB4A4GclGWRZCWnJ8e4rhzyriXDOdt2ODo8ZntHpO/jyYws\n", + "WbB/8RJ5moj/dlFw8eIFqkK8Y6IowvcD0ljyLNuw3bJ6KNhb52RZxs7ODi+++CKXLl3ine98wnSB\n", + "HnEc43kOdS10OLGlcHBdH9t28FyHqsoRiUQbINCgLGiqmuFAbCLadv/evfvGXbDA17LpHh4eY9s2\n", + "g/7owSDb92lMhXxycsLx8SFbWzumM/OZzUwm7GrNcrFGWZrJZNKlrruO1X0WLeRnW4rJeESVF0S+\n", + "dHQ/7tJ1wd7OLuv1muFwaJwP3W4Td12XXq+HUorDw0O2trYo65JNsibJEp545+PEccbR0RHzxYLt\n", + "nV0ODg4YjUZUVcMjjzzC7dt32d/fx9INt27d4amnnpSiJsvxfJ/Z1pTj0zMaLyDq91mv1531xf2j\n", + "Q2azLTZJQhgEeL7HJk7w7JDZbJc3b1zH9wLyRN5/VWbUddlt4Jb1k7ng/482cAOf/K/Af6G1Xj/M\n", + "CtFaa/V2ll0P3eO3+2IURV2STovzta2D+ZmymT+Ul9dRbvQDX5OHja5GeKx1xcrSfPs7z3L/4B6/\n", + "/sm/wTjsYfshZ+slvTCi5/oEOxGWZYlhTlVS1WJnOugP6fUuYNsuWZaxXq/AknZvMBgYW9OCs7Mz\n", + "5ufnHNw9wLYdZrMtLl26TFGnhlNa8PIrL+M4HqPRGNfxqZuaIBiwWa/IixzP89na3qMqc9arJZXn\n", + "4vkOh0dHb3fLODi4y9bWFkdHR3znO99hPB5z6dIF4zURcufOHfb29njt1dfoh33+vb/5N5nPF2jd\n", + "POQpIYrVLEtwXI8kyYiTNa+9/gpxnPLudz9NnmfmvtodzVMpGA57bDYbrl69wsnJGQBvvvkmo+GY\n", + "0Uj8x8GiNd+fr9Z4nlgOxMkGpWAxn7NerXj22e/x27/996XlVhZhNCIIAgbDIZskpmkqDo/uS0Xo\n", + "OAz6fUajERcvXmS5mNOLtjk6PCQvCtbrmO3tbcLQZzAYUVaVwThXHB2eotEopbvqVKmG+fmZGa5a\n", + "vPDSqziOyyhyeOmlH1BmOR/60IeYTid4nkZZkKYplmWxWW+YjCdsTac4uzs0TU2RZoZWesjJySnv\n", + "fe8zFGVDGEbYrktVbIGCqNfj5PiEOE44Pz/Hc1xGoxGbzYbVckk/Egc/lCxc33dFsWcpPFcO0OvX\n", + "r3P58mVzeJXk5kBqmob1es1gMOD87JzpbEpViqZifj6nP4iwVEMbJtCumyQVx7/cbPpJkqIeovA6\n", + "jpiKrRdLLl26QFU1oC0TwFBg2xZFlaF1w+7ODlcfeYRNnFCWYk+7mAvsNRyNePTaIzR1yXq9Jksz\n", + "8ey37A6Sk1Qt2xRRGRdmE0JXoQOHHxcsZqsazwbluUYpKcWKZ34/Gg1Zr1fG6dMlSWJ6/RA/DLn5\n", + "5pucLxaMhiMee8djvPHGm+Rlyc7+HkVdEW9S+lbPJP2ssIEnn3wnR0cnFEXBZDbjfH4uthujIapq\n", + "mM/n9HoiDspzOag3mwRQbOIEJy+kurcUnuvj+xF5FuMFATQVlm1jGTZdZeYGP+n6azdwpZSLbN7/\n", + "s9b698yXj5RSe1rrQ6XUPnDc7jHA5Yf++iXztbdc/8P/+M87rPvDH3wfH/nw+7u8RN/3uxAH3/c7\n", + "miBdIIPGN4O3dujZKE1T1FQ9hz//1l/y0jf/io+89/0UnkVZV/hxzmTcpwxc1DqjKDIa3YCCwTAi\n", + "zwqqqmATrzpIR2CTPkWZo3XNcrHGdT18L2B3e4c0zZhNFXGcUBY5CWB78nrEGMehrjV1VZgAVB+a\n", + "mrIocCwbXWvu3r5DELhEkU+v57FeNfj+2+N9vV6P2tCjLly4wHg85oknnuwqjtPTU55//nlGwzGe\n", + "H3Bw/5Ct2YzA98mL7KHqZEVVldy/f58kTZhtbXH58uWuI5LK2O04+O2B3WLleZ4zmYxQSqxO0zQD\n", + "DYvFgjDsce/ePUmKCQYEYYDr2uzubrNcLrl86Sr9Xo+PfvQXABgNBwCcz5diOas1US9CKdV1R0Uh\n", + "9gPr9Zo0TQl8r6N71U3DZDJhvY7J89zMLgIqE3Y9mcxQyiLLEnLb4d69u/i+h6U8BoMBuzu7PPbY\n", + "O4nCkDLdAHB2eoJj29y8eYcoinj66aewcHBdm17YI89z5vMzHNclNB3kYCDvIwwj4/PtoGlYr1b4\n", + "niWbS1WxvbvDuBihlCbwPOqmYtDv45qwB01rBwF1WdMYA6s0TY3Aq2F3dxvLku7Jc93OslY3UtD0\n", + "ez2UhqauWC2XzKYT4lhcIptGoruaRiCqNoNxMBATLt94eLeww9aW2CT3+hFZKvCA43q4nnFAVIrI\n", + "FmOmqqpYrwVGC3wXFfgMBmLAVpUNeZrQ6BrHtnAiec2N1pSlFE+27ZDEawLfoxeFuDY0RYaui25+\n", + "86OXS02RrAh7YwmOyNIHnu1FjuPYOI5FksQoJdGBtu9wvjxnsr0lzpKbBavXNuzu7nHr5i3cwCeI\n", + "Qvx+wHq9EujUhEyfnp6yvT0lTTPWmzWjwZDlekW8XrO3vdslgwlMmXFyckavJ4XPdDoRMkCS4Dse\n", + "Smsm0y1efeW+CeDIgZpnn32e7z73ktkf3/Ztd9dP3MCVrNx/BvxAa/1PHvpf/wb4u8A/Nv/+vYe+\n", + "/s+VUv8tAp28A/j2233vv/t3/vYPmbi0G3aSyGCkTaWwjGTV0q2yUv78ZrPB9/3OoMqyLI7qhMXx\n", + "hu/926/xiY/8PPuXLuL2I+L5msX9E+IbGf72mMl0ytZkgNYNaZpxcnxM1IuYzWYAnedKmsXUhhM9\n", + "Ho+ZTmfUdcPZ2RlxnHTGM/v7F0wayCFlWZPmKZayiXo9+j0fz5MW/+DgHr7vE/gug34fP+jheJ6h\n", + "n5Wcn52wXC0Z/RgIRdzlhHq1tbVFkiQ8++yzRFFPKqDdffK8ZG/vArqGl195jatXr+LYiiiKmE6n\n", + "JMkGx3HxPJ8rV64ym00oq4ogDLvWWoIh+ty6dYu8SPG9UJ4HS5GmcceEWa1WXL9+g+vXr2NbDmdn\n", + "Z1y9eo0PfvCDfOELX0A5EcfHR9iOYOAvvPDn/PzHPkpRVNR1ycnJCePxhJ2dHWY72ywW4kBYlgXn\n", + "5+coZbG9vS32rrZLv9/n8P4xaS5MneroiMceewytNVtbW51DnWDYmpOTE7IilhScuqDIM6Ig5D3v\n", + "fhoN1FXFfD5nE8fcTVNGkXRlW9t7+J7Ho1cfx7I08/k5/Sji/PwcP3C5cuUKRV2x3mxYL1fkWYbj\n", + "OJyfn7O9vcNkMsByxdPC9z2yNCHLUvI8Zbmsqcucu3fv8Mlf+DhlWpAYPvzQQFEtrVY9lOXqejYn\n", + "JyekaWrmMzb93qDDsWXgLEKQvb098tZStidmcb0ooq5KNIq6EeYUBivXWrNcLJlOZniuT2KgHMuy\n", + "SNPEKJ5d4jgGrZmfn+L5D9z0rPpBF+w4xjq2Kn5kM0FYOlWN7fzwPMu2Q8pKIJWmUR2M43gWdVWj\n", + "LHB+DJQQuC51kXMU3yNOxJ99vakIgpA8z1iuzrl69SonJyc0jSaON1zqXTIznSUoi4986MM898Lz\n", + "9PohO3tbNHXNa6+/ynQ6Iwo8krX4q1979FHyPOfGGzfY27/AztYWx6cnDPo9PN/nxo3r7OzsEvUi\n", + "bt++zWQ8pt8LWa/XbO9sc3p6xnA4xFLgBw55VjKeTMiLgpnbR3k2dZnxkQ+/nw998Bnh5iubf/Y/\n", + "/Yu3fe/w19MIPwF8DXiBB1DIf4Vsyv8SuMJbaYT/NUIjrBDI5Stv8331N74qe37bIrT0mYej1Vox\n", + "h21LyrVSSihihnJouQ5lXXWGV/Eo4l/90/+eC8MJT77/GRrXwrNsbMdhGPWw4oLNes3N5BxVVExG\n", + "YzHK54HrYetC1oqKlFKUldCjkiTB82SQKdRHoUEpFMpSEqTgiaClZUOI3aRwt2UaLxmVtmVTVBLc\n", + "oK2GMAy4efsGSmkUDf/Zf/pfvuXz+Kf/5B+itWa9XktwilZkacrJyRlPPf00i/mcOElEnGISuW3L\n", + "YjAY0u9FNE3NY9cepWlqVqslj1y5wunZWacAq6qyU7VmWcZoPOzYNkmS0It6+H5IHAstcTKZ0TSa\n", + "2WyL+/cO8X2f01MZGo3HYxpts7UtPuJlWRi/iRGNVuhG2uc4TlmuV7iew2KxwHVdrl17lC55Js/R\n", + "GtJYMH3fD4lzqbJa++HWegHj+e4HPkVeYFsWcYYRhmyIehFh6BuLVafDSLUZgpd50dHd8jzFUlLF\n", + "eq7NdDoh3qzFz7oscQIfBTi2jW05pGnKG9ev8/g73oFS4jGvbGN/rIUP7DqOHICew3q1wLYstiYT\n", + "aZfLCm1w77oxLKyH4EHHleqv1xPvcMuy0A1Yyuo24daOwnEsqroiDEMzJNYSgKAVlsmMzMuigynr\n", + "upZEoyxDAZ7v8Wf/9s/49Kc/zWK5JIqEZSUME9sEDHsdi8yy7M5WtWlqiThrA5mNJUbdCLbtOR5l\n", + "WeB6PkEYmBSm2kBbFpZtGQ60RZ6mHQ++aRo+8Qufesua+ItvfJ08z/DCiDAMKYqCzUagJBmeekRR\n", + "yHK5Mh7pPVw/6NKv2r1mMpl0PiS6aQjCkNVqxe7ONqvlGtuyxC/f84iiiMVSuPG6TfZRCt8RGCjL\n", + "Mra3t431bUK/L92Z1kLddMxspalL0BWH92+znB/j+zZlniASToVCntH3ffSz/9+GmFrrb/Dj/VJ+\n", + "+cf8nX8E/KOf9H2Bjj/c/mqpRP1+n+l0ahI7FL7rdfhtUzfYysJ25ZRPkwTlOkLRsRS/+7u/S5ln\n", + "fOqXPkVGLYuiLDk8OeHQOWGgHfb6E565/BRlUXN8dMTrr71BWZbs7Oywu7uL68pJn+c5aSaJ2Mpw\n", + "O7e3t8nznNVKhAu9XsRo1O+goMViwfxEKEyB7xMFoQQbbzbMz84oikJcCsdjer1+hzO/+vrL3Fwt\n", + "mG1N8Dyb09Pjt71nh0eH9Ho9LNsijVPB4k/P6PeHvPbadYqioN8bUtcNaZrT6zkEYcC9w/uMhkP2\n", + "dnf587/8Jm/cuM7v/PbfxzEWnBJN5XbRYO1ibIUhcbxha2sLgB98/wfcuXPAZz7zGVxXPN3v3z+i\n", + "3++zt7fH448/QZKYAAssFotz8iKjNkzS7DjD86QrKaqazSam1+uz2ax4/PHHuXnzJi+++CLacIjf\n", + "+973Mp1MqWu4fv0N3njjBpeuXSWKInb29gg86QbyLGF7e1uyLBcSbrtYbrD9CN+3ePTRd8hwyHRv\n", + "dV2xmC8oy9oc2B6D4Zgg9GXRrlZYaJJ0w8nRIXcP1uzv7zMdj1BKsU4z1uu1VPlZxrA/YDqdEkUh\n", + "682aRktlfHp6hucGpFlGLwwAje/1ZEhW5hRlQS+KaGqJywujAXWtaXRFwwPztryQJJ88z6Vbosbz\n", + "Q+pSm/eg8X2fMAxZb8z7X4hiV3Jma/K0pKwqqqamQTJlB4M+tvGJn02nMpw06sGmqbAtxdnZKbPZ\n", + "jPF4xGq1ZjKWDrEB6qYi8ANT0Mgz0+ga13WEbVVVNLowWH1FlVcPnDmbhloLa8TzPEajEbPZTOAo\n", + "28YJI84Xi64zg7du4HlZk5cN2ClKtWpuRV2XrFYieCoK0XWcnZ2xWhaAY2CjAa7tkKxXVLmwZwLf\n", + "l+fe1kSBw+L8nDzPGfT7pqBrSOKYi/v7JFnKJo6ZbU2kEFIu08nYeOuv2d3dJUsTgYxM3kEQCDxc\n", + "NWIfXabCST8+uiNiKQW252IrG9tygZ9RKX1bgZvf/xDL5OF4NVvJKSkRXwK51E1DXkr+YZJnKNfh\n", + "u997lm9/8zt8+vOf4/LePmGhCZWNCjwqG0oLagvqrCBY5eROgGPwvqLIybKURgsvVuvGUAalWmlo\n", + "xL/bFSpX69uyXq9pKe6d8Eh5aG0Z6t2mo0+JGqsEszm2uYPrzRqtGvzAw3Zt3rjxGv1Bn3/wO//w\n", + "Lfft61/7Ei+//IoR8CzJ0pymEWn3crmiF/UF39SaIAqkoisKojCg0Q1FLrmWyhJq3PZsC9BE4QM5\n", + "cFuF+OZBruuayvgbbzYbxuMxH/7wz1GVFWmaMxyOpF3NCsMkCLqqZjwaSnWmhVudFQV1oymKkiQr\n", + "ZIAaJ6RZxmopm47I60sa04KXZU3gB4Rhn2vXrnHt2uPcvn+fNE0Yjoaslit8T4Q0tYl3a5qKN998\n", + "k/FoxIUrVwTzthRZJlTJsixxXBfHcXFdr8v43MQS89VocSfyfU+k14GP0mKPsFot6UURXtjHsR1h\n", + "YdQNumlYrVb0B32qusb1XRzXoawqHFvsGSwLyjw3Vgspru1Q5hlhEIocHkVeNDSNksxE+0GwSYsg\n", + "xHEsdMS6QuGg6wcpLnmekucZQeiT5/JeNpsN+/t7ZEmBhYtp3MCS9ZamqSTUex5FmmIpidj7gy//\n", + "G37jN36DPBean1gcWx3c2aY5BVGPusaQD4wNqiVDY4FHhe1SGqgzj3OUUeY6tovreSRZ2tE05X0I\n", + "rKSDAZZlEYURVVnytz7/q29ZE7//R1/Bcz2qUii0QSBpR21gTPtMO47TeQwtTladfL7f75khv4R6\n", + "CLGikBQsxyEpS6mFbYc8z9maTGUfMh1DlhdE/R4aTZlL9F9koLj1es3Ozi5Zlpvq26bXE7582Wiq\n", + "KieJl9iq4uT4gH7k4RihotIKtMwZnvm5z/xzeg5nAAAgAElEQVTsSelbxVb90KS1xZRbXnIURaTk\n", + "DMM+DtBkFY7nUaHRrgu+DN1ODo+48+ZdvvCZzzEdbeGUDa4fUDYNTVURL2M838MLfAZBn8byqauY\n", + "qk7ZJGvCIGQyEwVY1JuwWW/ARG6FYSA8bsdluVpwenyC57qEUcRoMMR17a4q11oThi6O7aAcm15/\n", + "ynodM1+cdWq0yXiM64uScL1ZEoQOlu2SZSl37xzy6U9+qhuI/eg1Gs746M99grqueP75F7h58yZV\n", + "VfH+97+XW7duk2WZCFI8B7uSzdL1XbBrjo+O5UF0PCxtc//olCSreOSRKzz2rieRxVeB1vSiHmmS\n", + "cHhwyLPPPsvHf/7necdjT3Bw94DRsE/P9/GGQ+bzOWm85OjwLmHUJ4p6lE3Beik83k226VzWoihE\n", + "o2QDLWoWizXb27vkRUmAwrIDXMdhPwjxfI/ZdAvbkTSlo6Njrl+/znyd8Z3nX2Jrd5/+uIfjemzt\n", + "jEnTlLOzM7I84fT0hOVyQZalWL0h6RvXeeaZZ+j1IlxXuPhJklFVclAHQUi/3ycKA7a3dkiThNpw\n", + "4xeLOUmcMGcNCpHzb1/EcR3ycoMduFRU1MgB5UUhWV6QxCmbTcxoOBZGT+RTVhX9qI/WDVHQw3VD\n", + "As/BsQqUktAQrRvC/gjH8ygyGbI3jRz68UZyI13XQVc+riXh0HW74FH0ez6OJYVPL+jRAElac/36\n", + "XS5fuYIb+BRlQZkXWNrCcT2GfoBl2dRVTX8cYikLTQ3KZrFaEscbdrZ38PwA1di4rk/oaWpdkmcp\n", + "aZJS1gILVpXwyB1Hmc7aIgxCHNeRwy4ICCyZp8g8S37uMPLFJsPRlFWNa4V4dkijfIEUK3B+TCUq\n", + "KfPSjSjLpSgbgp7MEnwDn9qWTZKnWK5AbRPHo65qpvvbrDdrST+yFL0g5O7dA/auPGJSkUJcu4dl\n", + "KzP/2TCfnzMaDYmTGGVZ2JkUMVmWs7OzRZZl6FrjujZbW1PqWsKlt7a2yJIUmpq6LCjqlKos6Pc8\n", + "bt08oBdEuJZQKptaqNGW9dcX1z/VCrwd2LwdlbBlTFROQ50V9L0Qq9aARaE0KgzIa8lJ/IuvfQPf\n", + "cfjA0+/tKsd2EOkYsQbQGejkeQ5WZdgOluFJi6glCOTPOrbbyYM3m9hMg5sOc+28e00YQ0t/LAxe\n", + "LgKGmsCQ+lscL8sy6romTVNGoz7L1dywN0KeeeaZDnd/3wff2i6+8NzXOiFOSwlcLBbcuHGD7e1t\n", + "Tk5OuH37NnVTgdWIeZCyODo8pijEQEkb06eqqvFcl9nWjPnihDzLeOzao53owrEcelGPvd1dirxk\n", + "OBiaMGLxfFktFyhgMpkw3ZqJ4VTd4EcRti0HXPu+0bCJxUgrzwuzgYtJkG279AdDai2dWFEUrFZr\n", + "g6PW5HnOeDxl0O/TaE2WZri9Prdv3SZJEk5Pz80MAi5c2GcyGREEPpZtUZY5yeK0CwxpqzDf92mD\n", + "ruU1Cce6ruTetJCK40hGqTbCmixLqKrSVFAZaZrg2gKtrVZrVoslO9s7bE1n2LZDkeVYtkVWF1R1\n", + "TZ4VOI5PnmYdhdaxhCFjWTK8azDGUmiKPAcappMxYegxHgwIQp8iTwkCH40LloNlKapC7AREEOOQ\n", + "FSVxklKU8qzduXfAYDhge3sH33XNM1AZzFZk8jZyj5QFYWjTaMHR43iDbizytMK2RALvejZBIGEk\n", + "nrmf7TOudQP6QT6mQDiV+e+Kpm7MIN3DshyUaS9c1zOiOF9mII2wd2S4XvOZz372LWvij/7oywDY\n", + "riUpXLaNZTvQ2rXywK5DKYeqrvGcpns2JcvUxmozUtMUhUC8k+kU1/LNYHgX27WM6dyDAWxRiklY\n", + "WdVEvojK2j2ovRxjZet7gUDDgBvanJ+dMpuNuXdwl1EvQmmBDS31IOu30T+jiTw/GqXWvuEfdSVM\n", + "45TI8+VBSzKCKMIKfKqmpqwrXn/1Ne7cusXnP/s5oRpZCteWyLImz4hTadGHw6EkoXsuXu6Rl6kJ\n", + "RhW5uOcJXXExX7DZxAbjFsHOYDAQnNW0k+3wy7Zt4jhmMV+YpCDwggjP9xkOh12ittCr1kRRwHx+\n", + "Rq/XZzwe8s1v/SVnZyd88YtfFErcQ14ib3dJ56vklDc+woHv89i1a7I5RREX9vfZxBvyIuPw8FAy\n", + "//YvdEZRWSaKuf5QZO/LxZyqLGjqmhs33qQsS55+6mkm0xmb9YbXrt+QAGAlLeF73v0UYPHYO96J\n", + "Y1s0Tc3JiWQL7u7t41g2y+VKsE8xO5EDD0Vi0uhPj++yv3cRUJRlzf2DuziBqCjl0JiR5ZmoBJuG\n", + "N998k+OjisFwyGQ8psoyzk6O2N7eYXDlElkuPjWB6wjVVGtUU0tgru93ifZJIpYGrW9M23JHUWQ2\n", + "eUl4WsxXFGXcDRN9L6TXD7FtV+irdcnpSYmtety+dZtXXnkT17YYj0ccH3+fT37i41A3lE2GZzuE\n", + "rkWlNFt728RxyqAXkmUlWDZ5VoDjU1UlVVFwcPdNgsAzMwmPrdkO8XpJozXLxYoLF/Zp6oq6EWZK\n", + "GHnkeYrtSJh1rWV+U9caZdkcHt1DWQ5bs21cX0KP43ViKKM+lmUzmUxFRJIXRsXpkOWxWQc+4/EY\n", + "hY2tfHQjHjFVXVDXsjFr6J5dz8CSSj1w2HPM4PThsAKFBF5XVU0DXYYpQJJsqKoa3w8leFwJZfLt\n", + "LtsEJpe5wB5ZmgrRwPMpiwLXDykMvXQ0HkFZ09TiNqmbxvh8a3xPNt3hYCKK5nBAXWqyYo1SmuVq\n", + "QZLGXLp4gaqRsPCmafB9US+XRUyaPBDKdU6fpmjrRUJxtG15P4eH90iTBM+ziYJAIFpL4Xkujm2Z\n", + "2cdfH9jwU02lL8uyO7nhQcJzu3nbto2yFdpgWU0NludSATg2t+7c5o//8Ms88653EzkeFy9fksqm\n", + "kqQb13UJwhDHtknSlKOjI4qiIAwCev1WTRlSlZWx+NSdzLfFsGSKD57nMRwOO550W1UMBgNTMQjt\n", + "arneUJYVi+WCqqq4dOmSeV819+7d67qBr371z7hy+RJf/I2/LbxrM+RoceAP/fzn3nLfXnrua9R1\n", + "YxR0wtopikLcCZMUy36QkN2+jyRJuHnzpqlsVxSFiJAaY6HqODYNFUrZzOdzrly5wuH9E87P550/\n", + "exhGRnRh4SjF+9//fu4d3OXs9ITxSMRN29vbjCdTWXSWJUyduqZuKhotD7GlLJbLFf3+EDT4nnDl\n", + "o16PtBQpflUJPc/3AizbZjgcMBwMaXRDmuS88cYbjCZ7ndWCUjaWshiORigFSRITxysRIDUVtrE5\n", + "2DEugsvlkvF4TFVVXeXdmel7Ln7go5RNFA2QrgziTcJ8Picviw6eofHY29ul34+wLEW8WaF1hR84\n", + "OBYEgct0OqEoM+q8oMgLslxa/aqBRlsox+PsfEGcJGzimO2dXcZDD9+1CPygY16NjN90VZXE6w11\n", + "U+N7PptEBExFkRsYRYOW4dhqHXP79h36wxGD4YjRaGK6jZTKSObrqkIbpkgURWRxu7F7VHXO/fsH\n", + "PP6OR42q0UU1NrYtQdy2oySFRmuUbXV88jzPheqYpx1brO10WqVlu9YdW5gsfuBT1Q/sU5taUrTQ\n", + "bTp7Rd3UfPqzn3/LmviTr/yJdKOehef5Qo5wHDzfp24kF7fRigaNbhoswwqqyop+r9etodbiWAHx\n", + "RqiynudR1ZkpqoQSOhiIU6nn+7ieRxwnZKmswbJIGI1GnZ7F81zOTk86Uy/bFpaN53pgaeLNBmiw\n", + "lcZWCs+xyLMUx7E7iMmyrJ+YSv9T28D/6s+/3H2YD1oc1X3oYPxQ6pq8KAh7PfKyoLEVbhBx49ZN\n", + "nvvus+xMtxhHfXa3dtiYh6a9YS01MAxDwlDsRNshR5mVhukCUtvKfRDPZ/E8aD2Ny9IICbTqhDSt\n", + "D3CeF9RmwOq6rjADGhmGSjp6SdNI+zgY9Dk+Oea5577Hr/3ar7GztUUUhvJ6ylI24lSc895uA//B\n", + "c1/vKvS2uhHObdX5M8gDLyKNFjLyfaEv5kVBnuXE8YaXXnoRraE/6KNVw9nZOf3BkPVqw2K5pihL\n", + "/CBEa1NBWYrxeEKy2XB0dMTFvV2m4zGDfoTnuWzWGxLzPobDkfBkt2cdHTRNE1OJSeWlkEq91xsI\n", + "W8jRBkZoiEJJaS9yGYzOZrPuUDqfz2lUgOt4nM/n+J6P78mQcDKZIOyJGj/wqMqCLE6oDNS2NZsx\n", + "GA4oChGs1E0tdEbbRjcNWV3Q+n5bygZsPC9gtdyw2qwJQ8HLfd9HNZ5RwAYUZUaRJbiezSZekCYb\n", + "fM82JmjCMCnyAj/ssV7FaGWxSXJWq5hbd+7y2DuewA8C+oMBuoqxVfNAVq4sbNtF64YiL8QHvpS0\n", + "eWUrwxUWOK0uxQwsyzJev36Di5cuEUZ9LNvG90N0I8+OpawfMrYqjdDMMxRd0DS65ODgNs+8793G\n", + "gsHBswPqmm59QYM2A/6HO1OxuxA6nqb5oXXewprtWm8ajcbYDVu2eIzY0p3b6kG4OQo+9guffsua\n", + "+NOv/B8G3pQCTALD5TO1LaHrad0yOdVDXYFLFInXj2d8WBQQJ4kQG/KcuqpBFT90CGnA9wM6f/tG\n", + "KLvKsun3fIl6NPc1y5IOqgsClyRORIXp2CjH4eTkCNtS+K5DmYvXe12XYAQ8GjkgP/ixz/3sQSjL\n", + "5fKHaGvqoQ+r/XfTNDjKFkN5W6GbGuU4LNYr8jznxRde4De/+B+xM5pS5kVn9iMeJgH9fh/P81gs\n", + "FiyXS27cuCGihl6Pi/uXGQ7HeJ7HarXoLDdbf+I0jZnP551XS+u0l2VZJzZqGlFHDgbihZ3nOUcn\n", + "R7ieT68X4rhi75kkGY5j88Ybb/Da66/wD37nPyeJYwLf5/T0tPOzKMvSYI7x296zVs7dHjctXt7S\n", + "yyylcD0Py7bJsgLXdzuOvK1KPMfFAgLf5fO/8isCT9x8k9PzU2bTGUUpcFIcJ+xfuMSdg7v4vo+v\n", + "FOvFmvuHR8II6fWYL5dYtnhRn54cd1DTcDhkd3cXz3V5+eWXmU6n7O7udOrSIi9oas1wOGb/iSdY\n", + "rzcisCgSTk9PBUNtNI5lM9vf6w7KOI45ODgQ4Ydq6IUOjz/6PvJcMPMWzjo7OzEsEzFI2t/fx3VF\n", + "BFRVFZvNBtCUVSk2Csau1LIsJlvCUZ/NZihlc3j/mLOzU/Ks7A508Z6pSGOp3E/PFuIlE4WAzd7u\n", + "BYajPpvlEtAcHR0TDQY4XkStHPqTMacn54YW1/C+9z7N5ctXWK3X9KIeZWVjWdLtrFYrvCCgyMU6\n", + "t98fcnBwr1svRZVTVjm6loLBtm2uPfooUa/PdDblytWrxl9GDsLCpLFXRWmqPKurLre2ZzRGeu95\n", + "LlVV4LoeR0cnhqIYENcprhvIMDLwRQ0q/yDPM5Ik7tSydVkZOXgpxmGGCtx2da35m28qZSkUbKIo\n", + "fLAn0MYuapr67QvN0OTMYsT2rQiqQUzlRIMgeoGiKISqGfjkWcxyIcKaptGsje1zLwxBF1hWjbZr\n", + "A1XKM7LZxFy5csVU5wGr9RqwKE3QehLH5iBShskmh3AY+OimJgo98izBN17iN2/eYDYZYyuF5YnF\n", + "ReDL7K3RYmT1cFbC210/1SFmy3FtYZQWE3/YpVDV4AYBWVNR0VChOTg44Ev/6l/zNz79y+xtbROY\n", + "qbLypIJo/bnbSj4IAlrflHaAKMP91oMcQCrZLMu6g6WlESqDOxfGn3pra6sTNrQHRmvAhW1TViXz\n", + "+dwozwQve/3117j22KN87pd/mThujXa8zqymHWq19+EDH33rwOYHz37NYO0/HHjaCira16KwAMsY\n", + "yrfvU8RKQegDLUwlYc8YUctiseF8PidJc+7cPWCxWorUeLlkuVoQRT18Yy86nYxQusF3HB65cpnh\n", + "YEgUhuRlwdHRCevVmsp4j2RZSr/f6xbsxz/2CZIkFS54XuC5PpbrdNSvdtDbdhZtTmrbXaWFDAXr\n", + "qsH3A4qipBf1zGcFjuuYBB9xBuz3+w8SYMxnKD7W8vqGw6Ek8bhSfadpRp5XJEnGdLoNyLBLo1GW\n", + "CGc81wyxdavcFZpcYTxukiQhCkPiOEEFHus4ZjE/x3Mc0nTDxT3hlHueawJbTCK5I+2+OP/JM2tb\n", + "LmmSinDHVH7L5ZKyysnLFM91sJTFarXk7p07jMZjnnnmfeRlgev6aBSu46Eb81qzHNd1yPPMrBWF\n", + "49pQN93vPc8lTlYMRz3TwdXUZYNj+4h7ZCnrRkFjujTbthmPR1RViWPZHd9bWUq8VurKDCWFYFDX\n", + "Nb4XYJvN/WHoFDB0y5IgkMSfX/rsW2mE3/rzbwihoBQltza5snXTYLtuJ9F3XHkPlmVh2Vr84oPQ\n", + "4NVt8Vfj+y5ogeJae1fLEnhms4lxPXEjbRlV7XBcYFQJRMnzjCAIiDdrijw1XYeF53sEvqRO7V+8\n", + "xCsvv8xoOCDPUqLApzH3R+YJdIPYn8lEnnaTLEsxt2k5ku3m3bmwKYv5akE4GlIWBX4U8o2vf50P\n", + "f+CDPHHtMRqjdrRdm02Sdk54LXziOE6XsiJOgCGTyQQbqdha7+ooEv+NFmJZrVb4ftCxPfb29lFK\n", + "cf/+fV566fvkec6FCxe4fPkyWmvOzk7I84LFeonlyAO4vb3NC88/z7Pf/S6/9fd+i8cevcpmvcb3\n", + "A1OxJMYvpZbAY9N+uq77tvesqEoaNL7JA1VKIJ0Gjet7aPPhu65NUzXCLLBt4liEK77hLOdF1g2d\n", + "bNvGtV3iOGU8HuF6Po7tcfXRa3iexzf+4uso1VCUKVpXlLUijHzieMPuzhYXdvc4PLzPnbu3qSuN\n", + "7djs7e3jBwHvfeYZvvvsX/HEk09y+eIldna2ODs9pyxLcYUrK2xlcX5+TqWt7rkYDgf0+16HSy6X\n", + "SxaLBWma0uv1mG5POyimrjRK2RwfH3eqwyAQTP7C/h6PXrsmg+bFgrIU86f1esnpqXQNOzsi3tK6\n", + "JtmsyIuCXtCnyFYM+n3KImVn5wL9ngg5Nol8r+P5qRF+iG/I1miM7wvckiQZtu2yWG5I05RkuSJO\n", + "E2jEbnbUj7jyyCUcZaGamqYqqcsKypQ0r1AmRMC2bYqsMOtBnoF7B4e89NJLfOADH8CyLcIoIAoj\n", + "ozeQIAvPDEAloEHCOOqqRjdis9tu3q7rMplMKKtcrCmCoCsGtFZEkfi+BIHHdDpFaQtLibhEGCUC\n", + "16R5IeZl8znn5+cURY7r2NiWje/7xo897Nbjw5CEZVnUTU1Rtpa6DyjFbSeepTm5OSB/9Kp0TVOW\n", + "9IOgU0C3ebmVbnBdD1OhdQeDrksUMiy1bRvPF1WkheQLSPVfi+e7I/sUGra3t7Atp2N/1UVOWcsQ\n", + "VylFkkhXnRno1HVdoigENK7rkGw2eI7D8dExvX6f4aCPbVl4jiRgtTkAQSDU5bpufnYr8K//2f8G\n", + "0H2g8GCS3TJU5CQ17UXokxQZX/njr3Dj1df4W//OF9iezqjriuPTU8JBn77x7GjpS71er/PBbjfF\n", + "ltYkWX8DgkC8CirjxZDnRYdxt16+ICnT7WCs3+9hWUJHXK+Xnbw2zzPyuqLWwtt9/vnn2d/b59d/\n", + "7T8ApamKUgYpRh6tmwdJRO2h1dqAvu/nPvOW+/bSs/9X1/K3XUZbWbYD2Ma0fIEn4p1Wzi+bFNR1\n", + "afBkz+CfFVLrKCQBRHjpvV6PP/mzP+XLf/xHTGZjtnem3L9/nwaHyXiEhaQgDXqhcKbnC2azLSaT\n", + "KWHU5+TkhNAP2N7aIopC5otz8jRjOBiwt7vHoD+kKk1Ki+vhBMJckE6i7N6XuFZWZtPJyfKcqN83\n", + "c4OKPCuZzbZEvdiIIKOqSoLAZ7Ve0jRQFCV983c28UaqWS3V/HqzAS1r3PPh+PiU/f0LbG/v4jo+\n", + "QdijadoJiRY5te/hBcLAEV+XmrrSxnSr5ODufcKoh6UsZrNtcmoxN7MUuinRdcVkNKDMMmgkn7L1\n", + "+shpcMznaBmWiu/73L59m9deu86TT76Lra1t0iSVahYtSUR1jaXg9PSU4XDIZDoVdojWZh4ivvny\n", + "Wquuw2mfo6Zp6AWhuYcCcxwc3CTq++zuSscZ+hF1pShLoRc2jUjnHc/v1nCLceumpjJd4Q9vQoo8\n", + "z6Sb82Xo6Lji+x4EvsGztelGLWpj5tXUmo//4lsx8D/4fdlHqGtU58fiiIAMJKOyedDpaxSOJSEw\n", + "Td3geXLw1caSoxMgId5DCtesKXEkBQRnr2sMSmP+fo1liZd8kggtdDDom7lWQmAOss1GtBG2IxAf\n", + "WmMrTW2e2dKYsJlpBZZt8/T7PvmzV4G3VxuC2g5BgG4q7DiOJMnbFufzOSfnZ3zzL/6Sz3/mszRF\n", + "RRYnOK7LpcuXyXRF0NislivhpVoWdVnRCyW8oKlrqQg8jygIWW4WHNw7YLlcMpvO6PcHDAZ9kuSI\n", + "8/Nzw/vNuHr1UYaDCePxlF6vz+npCUVREoY+URQSRQGL5Zy7B3ek+o18kizj+e99j//wi1/k4sVL\n", + "rDcrAt/HQtHIdAIzpcA1/iiu45qW0u+YLz96PQwLtTBKO+xq4Ye6rg0+qfCcgKLIu0pdMHK3kz03\n", + "WjyblVIox6HIa2azGefnC770pS/x+vVXufrIJTbxivnJMf3QZxFnnJ4d0VQNdVXwvmfeS5YlhFGI\n", + "47mcnp/jJymXr1ymLioOj4/JDY1qMpVQ55dfeZU8y/n4xz4u841aU2mRe1u2xag/AA1ZnpGma9Is\n", + "Nd2JRRSFxm9DmBRVXfLGG28YfDVgNpsYqCagrxs81+98U55/7jne+c530u+JlL3l8rdyc61THr/2\n", + "GFleoJTNdDIW/NNw2tMsJU0TsixGxaqbi7RFSJrkvPbaa2xtj+n3xU6hbhpC28N15cDuDftslith\n", + "mrgS5tA0DWWtqYuKkrYjtfD8kCzLuHPrTe4fnfDJT37C5HWGpGmM4zqdSlmjJcSiqam1fDZxmnem\n", + "U22V6Pkubi8kTVIcpwdo6lo2zLooO0dH23bEC99zOqZTFIQ0tUKpNnyloG4EXmyj0QTyCHBtB8ex\n", + "Os1EC4/IPEjYG8ulZKcanmDHxHrY5M73fWzXI4p6b7smxpMxRVniKgyZwKKqayzbRjWa2gRCgEIr\n", + "qexDL5IO39ZYFuhG7Eceik7Hdh3QMm+ybAcrcHBdx3wvcAxVsqwL6roiTlYsl3O0htFoZKjRJfFm\n", + "zWw260gV6/WaxWIhiUmeR1XmVGVFU1ckSU0bqm07LqCNA+WPv35qG3jbqrUv+OEPrf1l2zZZI94K\n", + "uxf2+Rf/8n/hIx/5CO9+11PovGR+ekpjQXxQ4PYjhniMx+MfoieKpHvUYW51VVPUBaPRiOl0YgyA\n", + "StI05eT0BNu2eeSRR5hOxTJys4m5f/+QW7duo7Wm3+8xnU6MTLfh7OwU27G4fPkiq9WK7z7/HNiK\n", + "3/qt/0QUjWmC5/umKvZQysJ1PCMeetBtPFyl/DgIpdINjZKYuaKuKI1rm+u6rJN2gGJRVCXKeEy0\n", + "ByHQwTPtz5MW1qbRDWWa4nsRJycnfOtbf8Xrr73GZDJmvVkQBR5VXeG4Nr2eDBVd22Zvd5eqrnE8\n", + "l74foSybskq4svcoB/fuoWtFU5c89dRTWJbF6fExr92/wXQ8Zm93j1dffZUokirlwuVdPF+SX9br\n", + "JSCdVBj5DIYRyrKoTTUXbzImkylNo0WIlbZtsy3inSTh9ddfN94c4h6ZZRkf+MAHOpiuqqqOctl6\n", + "1DS1hReFYjSWl6zXS2zbI1/OO5OvremYMAzJq5qyqlgu1lR1RZYJ1XB/f5/ZbGo2ImFDqFLjeULp\n", + "TJZz8izBUkM2G+GaW5aLZXko36XvhYR10Vk2+J7LSy++yFPvehdZFuN5AQcHd4zbXo5qNGEYYHse\n", + "y/ncxJpJukzQi8TGtSw6TnKSbGQwZw4O12DDWZazM9syXRwEfkCSLlnH50TRlLOzM871OVpbeG5o\n", + "OmXpRloPltZ8rmmEMQN0qupWcR0EPSzLxnUVrusxGDiiFjbPZ/u8Nk2D5bhmmLshSd5+I1uuVlgW\n", + "2J6P1g1V3RibBIeirHCUZWyjrY5ajHFPbJq6Y8SIoMeideRU2CilaaoSS4nQp8hFiPSw8VutS5TS\n", + "xMmGIPDNc1XTNJrpeILvBybgIWSxWFDkuUxULGVsDGwspQiiqHsOq6oylhc2gR/8xH30p1iBy5S2\n", + "UdK/tq5+TVHhux51VZKWBUUYEXg+f/H1b5CtYmbXxizOl0yGYy5ffRxtWRR1RZJnVGlKo2y0BctN\n", + "SpKck+clnnfWJe64tlQMJ2cLwVsHA6oGev0RYSTm+sp2OLh/iOO4jEcjhuMJcRJTFoKll7rg/PzM\n", + "eBvb5FXB8y+9aBLGf5X3vuc9ANRFiefYNHVtNm9F4AvbJIgC8iwjN+KFRgv3tdYNtvNjrDM9vxti\n", + "Wh7GFdG0h8ruHsYai6ZqcF3fLMj2ZH9oQGyLRwlo6rI2D3/Jt7/zHZ77/gtMtsVD2g080DWu1jRl\n", + "Tb1J2N3ZZm9v3yRwh0xmW/zJn34V2/Xwwx4vvvwKWmsG0ZDtrRm37hxQmir8nY8/ged73Lz5Jrdu\n", + "3aLIc8Nfl8rl8uWLXLlyxbADpK3NsoyqFCjBsi2Go4HQrbC6NHbbEajEtm36fck2XK/XfO/b3+aR\n", + "R66wY4zIPMuEA9uQJCmB66CrnDjdYNliKBXHMePRGMt2qYzDYd1UFFWDVSrKusQyEWfecIjWkCY+\n", + "2SbF0hAvVgBYlsIPAgLXI4szhr0+qe3g2pZAKU2JasTDRNkORVERBQEKTZ4IJbaoS0bDHpOx/Bxl\n", + "2ezv7kkwdBabTVhRlDWu54kDoutwenrK3t4O1DVZneMHPl4YkdkO/zdzbx5k2XXf933O3e/bX+/d\n", + "07NjAAwwGCwSCZCgKEI0SYnRYomxaFouypFV5SQVJ7FViWOpUpWSaJWrZFGyLVmOo1RsWZYUaxct\n", + "0lZICVxAgARB7Nvsa0/v3W+7793tnLgBUB8AACAASURBVPxxzrn9BhtdrnLRl4Wq4fR0v9fv3vu7\n", + "v9/3911kKZGhrB5erieIWwH9/h5KKs1vHg+p1SKuXV/j+Ik76LSpsOCy1EyhJBkjy5JCJdWuyMKP\n", + "nqdl7L7nUas3UCij0ch0x+wGKPS0XWYlEwM/+V6A7wdkRUm3pXUC9XqEEG99T3TbczrOLh3jOS5h\n", + "oLv4fDIhCLVLY6lKFBKhJAIBruasC08iKaCUlDJHCEd7FakSJbVjpnA0k8YRWoWZZRkIgSxLU+w1\n", + "DBN6ggJdiKMoJvAC0qwgzxOiKKYscnr7O2RpyuqhZeo1rcrU1EcPqaAwcZCe5+G4wjz03jkT89uq\n", + "xCyNSskoFvRSKKiTTVLAoV6r4cYBN2/c4DN/8ic89l0f4O5Td0GpuHnrFllaIFyXRrNBrdHQvGUE\n", + "aZYThCHdmdlK1trv97l85SpJMmR+fp6l5QWsrL7fH5BnBZ7nG8MbYXDVkvWNDWoNPb41203iOOa1\n", + "11+lVosZjxOUgCefehLP8/i7P/VTRH5AadggnpGRuwbftF1fmqZ4pWZbWIMd+zXgbdWYmfFMtxJz\n", + "JfUCz3phpCZfUL+eIApj8kIvmLRoSS9otfWqpMgywiDQVqOuw0uvvMbT33yamdk50jyjVBJPOJR5\n", + "iSsE/f6AY0ePsby8zJEjRzl16k6uXb9BuzvDj/6VH+XZF19kY2uLKIrp9Xr43YCd3T2ySULo+YRB\n", + "wOUrV5hMtG/G0aNHOX78mKH5NXXE2XjM+vo6X//61+l2O9x9150URcHKyjKTyZjJeEImdc6i5wYE\n", + "vo+UMBwO9EQhBKNkzMbmBoPBgHvPnNZ83yQhDAKGI50RmeUZrucQxwc2CEoUSAlxHBvK4YBkot0T\n", + "a7UafhBVGapFkVeUUlmWrN1c48iRVea6Mxq+Mx2n67jkeYFwHMbphO3tbYTQN22r2aAoJDUBVfq5\n", + "41HkOWWp4bHROOHw4VXQtwj9/Z6mijqu9rxx9H1T5AXC0+k9Yagf9Lu7u8zMdnEnOowjGSZG/aiL\n", + "gu9r9a7Gf11qcaS5+EAuS8Ig4MKFCzz8ru9kOBxSrzcMzKCo1eoGx47IjExem1zlDAZ9ze82O5g0\n", + "zUxnXhJFATg6kSuMIjxXIFyPuVYLlGA80Vz8IHLZ3d2uOOd6ufnom+6JnZ0tfX78kDxLjTWtvh8E\n", + "ms7nux7CtYZzIFyFMBERSpY4jiJwdV5lkecolJ5004wwCphMEqQsK9KFffBZXD0MO9RrMcrX5An7\n", + "gPI8H0fAZDJmd3sLz3VYPHyIRj1mYqYSOMj/PbDlvT1i8h3r6Dt+9T/zEUeR7gTNcihNDU/TZNhZ\n", + "744L5y5w/9kHaNSbhFHEeDDk2LFj5HnBcDRikqak6aRiJGSpFjRsbGxUvhea/jfLeByjkJw7d67y\n", + "xuh2u0RRTJbmFc0wSZJqg47Q3fHW1pYZjXXnoBkpL/G93/thzp49W+GR9oR4nsdoNKrG74ObX99A\n", + "1kLAQj6WMfN2xzS90qaweJ5fLUIjwyIQmDgmWVTS5izLjEjCNR2rR+TUKKX2TCnSnCe/9hSdTqda\n", + "wtSimGTYAynJy5zTd59mdnaOBx54gCiKGQ5HLMzNc+XadU6euoszd5/m+vXrZEnC6soyk8kEWUpW\n", + "V1dpNxqMkxGDXsqhQyuVsvXmzTVwHOpxzOLiovHunvDggw/SbrUQQsMdFy5cZHZ2hkajQSw8XNdh\n", + "a2uXV8+fN0VRT1YYpsV4nHDmzH14kU8/0VBSmqQ06g0muabROY6DErpDK4sSqXIcR9MZ7fkLfB3N\n", + "JaU0BcLSRl1arRrtVp2bN28Shjoerd/rVfQye46FgcnKMufYsWOMJwmjZESZKBR61+J5AWEYMzGv\n", + "IRyBB5TSZEf6Lo7j0mzVCfxIS9BVDkjKstAWrsLF9Xzj/CdxhMelCxfodDvU4jq1WgPPdRmORhpb\n", + "VSVFmeIIhzRLcISDMCZZrueCyllZXuDK1cucPHlCd/tegDIWA2UpyYsRpczN9efjumFViKZFdeYC\n", + "ZjzSC+Qsy+gneyj09BlHNYJQQzOu4xN4bhWwAgfakDceURRqHcHIRMONU+0+6ek6YF0OhdDnwvU8\n", + "8kIn9SChLHIyWYCUGopX1stfw5CjROdx2lzZOI4rG43piUMIRztPep72iHcdgtBHlZL9/RFZlrGw\n", + "MFdFxyl1oEC3DZuFjqah5P9iC7hmfhQ4dhnnR9r4JxkT1mJKJZEoJonkq088yUe/93s5tLTMcDAg\n", + "n6RMJhonbHdazAchUklu3ryuucNxg6NHFyuq2cbGBltbG5piWAs5dOgQx44dZX9/n1u3bnH+/HmE\n", + "0EupkydP4noCR+psvs3NTQ4fPoRwhNn0623+n/37/8Dq6iE+9bM/x87uFplZ4nRaLe3oZkQLQCUw\n", + "sic9iqLbaHz2/0sp6XQ6b7u4sKIdO3pZAYrtCizP2Rpe2TR5eyFYxZ5WhkVmMTchDCN+4Rd/kbmF\n", + "ecaTCa6rp4d+f59Os8n+zjYnjx2jFtVotTosLi5rYUhWgOtw/31n+cY3v8nd99zDxz/2Mf7vf/n/\n", + "UAsDsmxCv9/n1q2Cy5MJvuPy4P0PkOc5e70+Fy9fYWZmhnoU4wiXF194keFoyNmzZ+l2Z3nlpRd5\n", + "7bXXmJuf4b3vfa9hLaQMhj0ju8948MH7GY/HdFpt8ixnMByQG/x1MBgQRCE7e7vVgyuSBckkOfA/\n", + "VwIXF4mkHscURcloNDLdkaReq1EziTS2IGmztTGDvva4DsOA0ajP/GyXnZ29amlsYYXM2NcKx2Fn\n", + "f48w1BYPSaKX8LNzC2SZpnmmk4lRE1qjtIgiTcmnLEmRBVHggfBI84k5t05Fz5NKEMdNZJmzsrLM\n", + "yy+/zDe/+Sz9/pC77rqLI0eOaCqt6xqzsE5l8SCM+KUsc5LBkDP33M2f/ulnOXHsqPYZaQW4vo+U\n", + "AuGijZ1cu9QsGE/GVYMCVPstu4Bv1Rt6WSl14IP1C0rGCYNBT5vA5SWlLPGCoGps3q6QNWqhlqgL\n", + "jSF3ZrpkWcpoMCSOQ1zPxgJisOWCIHTNA7vQy1NHkJeSdDyhKHSAjCxLklGC4+l7ajLRexc7MVu2\n", + "C2ilrOM4eEoyNHunVquF6wg9MZqdRBD4DIdDswyNKiol3F7EbQMIBySPtzu+fV4oj/8RDjoqqchz\n", + "BC5eGJCVBaUjIPBwXJd/8ulfZX52jtOnTzPTahNHIb5z4HyWpikjE7zQ6WhDqMkkRZaS3AhBXNc1\n", + "KrfMnIyxkV/brzuMjIqq3+9XjBhbHLXgQ3/Yr7/+Or7v89BDD3LmzBnTPblMUs1RLvO8KuC287AG\n", + "N7aLCMOwojfaRdp01yal5N4H3/+mz+2V575cCX1st15BKGYBpJQWm9gUo2lxlA721c6PUimGyYgo\n", + "jnn2+Rd4+utP0+522NvbM+nYGZ7jsLO5wd2nTnHnHSd5+N0PM0xzbly7zrFjxygLXXTyvCAvNd+4\n", + "3mqwsbnJa6+/zqUb1zT7x3Xp7ffpNFscWjlE4AeUpTR8dk1hS4ZDfM9jcXGRvMh59dVXiKOI1dVD\n", + "zM3Osru7w/7+PlEc0mrPYu0OyqIgNF40nrlRPVd7SO/v7XFla53V1VU9/RQlYzNZ+aYoKAXyDfCV\n", + "MinseiFYGEMl7btuoT7Pc8gz3XnmWc7a2hqNepN2u43vB9V5CYIAZZWFjnbWk7LE8RztYNjr02rp\n", + "MGiFMLmvwghg9Dkr8kLTNs0kqZ0aJY7nGBqhdgjUKT1aWSlliSoLNjY3ePXVl7n3zH0cPXrciJoK\n", + "c+04hrpZGIjAsYQQyjKl3tBJPD/zM/87P/upn2M0HBOGMaUEPf0LfM/HcYuKaeK6XlUwLSXQxhJK\n", + "KZEThXCUoRfqh5SUFkpwzXnQfHEpXBxjl6uU4uFHP/Cme+Lxz38Gz/dR8mCB6vte5SMjZYkwKVuu\n", + "o3MtM3XQIJVFwWQyppQlvuGpC6E7cwBJSRhG2tDNQJNKYX5PTVH0DW3RjfwKpskz7X+jlCQOQ7rd\n", + "tglO0ZTFaWbltC2Gvf+r91eWPPjwf2Iiz3/Ow3VdPMfBEw4qkwRhqEUqYUwuoDcZ8bVnnmZrY4sf\n", + "+aEfplarkSVj9vb2GPUHzMzM0O12abdbBKFPqSSDQd9Qj2I6nU6FUe7t7dLva7724uI89XpMkSsm\n", + "+z3Wb21Qq0cV9afdbjMajdjc3DTCkRpBoPMOP/vZz/IjP/IjPProe/VirSgMXppXwaWR8diwFDXN\n", + "l5WVcMl2cLbo2geRHc1Ho9Hb+oHbFKNpWpYVLdj/7OuOkoTA+KEoKQn8gKzQyTul0rBJrV4ny3PO\n", + "nT9PXK/RHwzM5zbGc122NzZ44L77EAruv+8Bdnd2kV7AnXef5rVXXuGhBx5gfX2dWq0GyuPm1k06\n", + "nSbzMzMc/Usf5IULr/HsM9/k4sXLmobWaNAfjWjEChBEUc3ALKVmHPgeN9dvsbu7y8LCIkeOHGZ9\n", + "fZ2nvv519nZ3ec97HmF1dZWba2t0Ovph02w0CEKPItfqOseB3e1d9s3Dt1GL2d/dIU1TDq2sIIuM\n", + "erdNnmVQasy8KHUhDqMaNpZsMpngOA61WkSSjHEcj3SiVXX1RoM8LZiZ6SIl5J7D8vISQmgmQ5ZN\n", + "SFOjjEWQS72obzRr1BsNLaQa69SadrvDYDik3Z1BlpAVKZ6r/Xs83yHPs4qWd2ttTecrzi9SrzfI\n", + "igypNF/ccQwVF71zKcuc4WjApUsXefe7383KyooWBqWJYVlIXMdcjy6UgOtafxItBivzjDAKadQj\n", + "9ra36czO4XshwvEpS8VgMGQ0GpKlB4ZgjuNoeqNwqonTD7RHvuM4+IEPQgu+SmwzEiFLzeqZjHXI\n", + "h35fkRHaBPj+W5eqZlMbUvUHY1zPQUhFGGqlaJ7l2pNFKVCSUjhIAaUozINUR5c167WKlWKVkCgN\n", + "VZbK+M4Ijanr2mXphMJg6Pr3HBubYGs8VpbagqPZqFcTuYZRvQqSsfe+Ldp2IilN4/N20JE9vm0d\n", + "+Fe/+McIqaCUCKWxt3GW49djMiTDLOXX/sX/yXvOvIvl5WXiMMRzHeZnZqvuNk0nFc85CANcP6zE\n", + "BVmWaRpaHN/WTY/HY3QQbFB9rZR5RXfKsowoCqufm+c5Vy9fpiwLPvzhD7OwsMBwOKzk2QdCmvL2\n", + "LlhoSa+lg9n38EaMy1IG7ULEjp93n33zwub5p//8tgKuT672MK7UZ0WB62lIQJkuV0lFnmV4nmYp\n", + "ILRc2/FcnnjyKb7xzDM60Xs8xnEEeZoii4Juu8Xy4iL3n7kPWZQcPXKUvvGc6e3t4zlCR4OZ9+x4\n", + "ggsXL7C6uopUikSV2iB/aYlnnnkWFIyTCYdWVrQxWKE9srUHMuR5VvnA1+ox29vb7Gxvs7S4wNLS\n", + "EqPRUAuE4ohjx46ytLRcObr1ej18z8VzHZaWltjb26fTaTGcTLSFrBCEQcj8nDbd91ydoen7hrIm\n", + "BJmRxetzYiTZpRZw7e/vM5lM6O33GA4HFMYA6q677mJ2do79/R6HV4+glKDZbDFOElzXR7gOwnU1\n", + "DbLMyfKMuKYl9rrDz+n3h+zu7dPvD5FFSafTNr4gEcloRBD4JMkIm+MZxTWahmdeb1gLAcdIygsT\n", + "SCwYjQbs7Gzz0EMPUpjp0/5+02Zv0w9+Pb6bgmecHP/k332GpcVlTt112gimQDiaJ+37gdYXTGVX\n", + "TlM0LeVOR60Zl0GUEZQVCJR5CB10tRZb9oVfdd8g+cBHfvhN98Tjf/b7pGlKJhXNZkMrTpXEM9OI\n", + "/d30VFFQlgWeESpZuMgWc2n54wd1CsmBUM4R1lrDNf+Zz916q8uimpDzPCMMfRpT/PXpmjBt6FVx\n", + "v123ahxsPXAch9P3f9d/eR04pgvE+NCUShE36qSGV/zqs88xPzvPu77jIZTU0U+3bt1i7cZNwiAw\n", + "KeQNut3ZqvgWMq3I/0ppEvxgMGA00vaQMzOzzM7OU5Yl+3t9g0f5uJ5mo+ixEqxp/+c+9zkWFhb4\n", + "vu/9CIdXVxkMBlXBtjl+9kI9KMjubU9PezFb6MLKh+3XLVY6/SDV6s83H1ZqP/2gsBFm9iFhT7pS\n", + "CjcwnFI76uc5RVpqDFMoKB3+4vG/4MSJk+zu7hor2xGqKIjCgHarxSMPP8zS4hKTUcLzL7zAvQ8+\n", + "hOM4tNstrl6+zNzcXMXi0IyJw4yShJMnT7LR79Pvv85jj93L7k6PT3/60ywsLJKmOcvLK+RZrgUf\n", + "jgeOwgGaUUyjWWewr31Yao06e/0+61ublGXJiRMn6HZajMZjPvvvP8fK8hK1WlzBJAq4unaTsijZ\n", + "2tsxwinF7MyMzoscDDRsJhwKVTBJTHBuEBBOLZEcR7C2dpOXXnqZ4XBAZBzoTp8+zZ2nTjI/P0tu\n", + "PFliI2WXqmQ4GBKGgY5Qcx2zFMuNak8QBgHpWGsAdDTeHrfWNlhYWGR2ZoZBf2jS6TU+7Qc6xxLH\n", + "JUk1TLV3+XoFU8zPzhCGEQsLC7rL9jyisM5gsE8ca98eWwwC362aEoTA93SAcJ4dXJvC9yuqIAgm\n", + "k4xTJ+/kytWr3Ou5ZKqkXquxv9ej1miCKhHK15L/8sDPvig1pBX6AZGvE3ekLPHqPnmWalqf0MAR\n", + "QkM+2i3QMQ+XAhdQ0vJe3lpS7rkabpV5iuuUuJ4JJXdd49QIvtkRSOlQli5KaStc0AIehUC4Lq5z\n", + "EGFn72vHEyiJdh4sdbdtd1plKfE8HSYCepqTBhpq1utm+i5wnIPkMd2kSYpiUn3mFhK1E3m1y5AH\n", + "hIi3O75tBbyUBbLQeK1nsLNJlmn6zjDliS99me/54Ifo9/YojCXpyuKCMTXSktUrV65q/DiKqdVi\n", + "HN8sNByHPC8rBoYOI85IkjE3bqyhJJXfr8a4JyB0Yd3e3mJjYwMpSz7+8R/lnnvuAVmSZxnzc7Mm\n", + "307SajZJDKvDEQLPWFLmWVp98NOduGWhTHfgVlBi/256jHqrY3prbUcr+/S2HVSWZTiug+PprsN3\n", + "D9gvYRjiKl0Uk3TC5/7Df6DT6bK7s0tZ5CjpaM6y4a0fO3qUxaUlBv0BoR9w/ORJNjfXWVhYABSH\n", + "jx7h/PnzHD58mFJpUYjEY7y3z2vnL7B46DCD/pBP/dw/4PkXX6TTnSXNcp59/gUajRZxVEcqgesI\n", + "0iKvFrTj7V3yLCWIa3Tn5tje3mJ7dxdZFFy9eo2rVwt2d/fodDpkZcHpEye4fPky/UG/Wu62Wi1m\n", + "5+bpdtsMBwOuXb1GmqYcWV0ljGM8z8HlIDgkzTJGw6E2IRqNuH79Ojs7OywvL3Hk8LtMEHW98oIf\n", + "DYd6JPY8At+j225RKkUUzQIlUeybsGCT2q40Nl0U2iwqGQw4//o5Wu0Od999J6Nhwmg4QgjY2tqg\n", + "LPUyVZqRPssy8sIYMwURea7pb5s7u+zu7iPLFzlx/Dgnjh/HdQV7u9ucO/cax48dpdVuEYU+rkMV\n", + "YG09qx2zjKsYUVlGFOkCXa/XybKU+flFnnzyKTY2NlhePkQUBMzOdkDppHad26GxY3t96kJuMmzL\n", + "AlUUFEXG5s118iIn9DzCKEDL5g39VTgUpfYpB6gFmg0kpTSahTcfjtCTXD2KCM2C3jFQln4HUBYl\n", + "RalhE4S20z3o7EX1c7RLZVE9wC3GXRQF9XpoKJiGO++6uK4wNMmJKbT6Z9XrddPcWZGiwjo/uq5v\n", + "7tv8NijUptnbGmAbvW91fNsKuCxKXDPSlwqSyZhmu02a5nzl8S/h4rK6tETdc83iMaUodWcqhKhu\n", + "KBQUueaaamWeIssK0333kbI0kucGruvRqDfJ85I8T6vkjNzkU/Z6PebmZnj44Yc5fHi1YnEEroOS\n", + "esPseR6qLBkYTF0okFIngkgpkWjjdjsaaXeytBqtrNzddq1we0G2I+1bHVauDFRK0+mFh/anjhGu\n", + "AEfhCo/SeCvYaSHPc/r9AZMi49r160RxzKg/xPcDlCyZTMZ0Wk2U8YnY2dmhUW+glNCCDNfh4sWL\n", + "3Hv6Hh3aurRIYRRtjqdNpY4cPcq169f51V/5Z6xvbgIOy0uH2N3bo9XuMD87z/rGJqfuOIVrOi7h\n", + "OBRSanxe2+4xSSdsXbvGcNBnkqXMzc4R12pEAczMdukPBly+coX+cMQ41dt+rQwN6bSHvPDa6zRq\n", + "PgsLCywvLVPkBbuDHju9PRbm5omMh0c2SYnjiPn5efb29qqH4qlTp8yCyiFJEiaTMe1WC6QkHY9R\n", + "RYkf+Gxvb2tec6izL/f29+h0ukilF3a+Z+TdjrbfLcqSSxfOcfjwKt2ZWfb3+pRlThwFTFLN397d\n", + "3UV4Ltdv3EBKRac7w+bWDgqIa03a7Q47W+sIVVYuj6+9fo6r165Ri2PuvedufuAHfwhZ5ly7fpO7\n", + "7zxJbhgr1q9k2kfHWtQGQcAXvvAX1GpdwtDXDZEL6SRjPJqwsb6G42iKXr3WQEoFjovjOtU1af1i\n", + "tIeJLppBqKGfWjOikDmesGZsOZ7bJk0zlFTEcQNZlgwHA5qtCPPc4+2Q3jiyOZ4Sx3hoG3NRMxFY\n", + "GwHt0KlQqFIile6+i6kJ2H4GjuOA0hGLOqwiYjLRtafRaGhPpNJ6nGs4RUpJWUi63TaOq+EyKQ8g\n", + "En2vgpQZ3pRRlX1Ne9jzouPmnG/JQvm2FfBaXCMvJYVSSAVxo844Tdnd2eOVl1/mse9+DEfCzvYW\n", + "QRjSbDaN3FkZwxhN14rCmHq9QbcbkJZaGDQea4bH0aPHCAKPW7fWuXHjBukkI44bpsPVT71z586x\n", + "v7/Pmfvu4f3vfx8nTpwAVOVgGEY6H3JoQpbtU9MKcsCpiq4dgcqyeMvxCKhohMBti5/pTfTbc16j\n", + "ahQDpgQOB9a4vu/j+m4VeeUgKJVkf3+fer2pxz8l9ZShFFIpjWMiSXNtJl+La3zndz7ImXvOsL29\n", + "w8VLFzm8epRSlsRxyNmzZ3j15VdYWTmE7/tcvHiRE3ecZDIeM7ewyJe+8gS/+Vu/Ras5S6PZ0osh\n", + "pfjAY38JqwLd2drm6aefZraroY1ap2Xee6BtNR2HmivIshSpFLks6A/6NFtNkmSAVIpH3vMejp84\n", + "SRhF/NIv/zKO67G9u4vn++wP+oySBFTOxWvXadTruI5Lo1ZjptNlkhbMz8/TbDQogP1hws2b62YK\n", + "2+bYsWNsb28z0+3qJaLvkoxGnD93TusDanVqRj7u+wG7+3ta7NKsm65sXE09OrRAsyxq9YitLU07\n", + "PXxohSSZMDenMzSfeeYZQKsoz5w5Q3umy4+srKAcVwcxS4Xnh9xc28D1fFQxoRZ6DIdDbq3d4tKl\n", + "i2xubRMGPtevXeW55+a5//77WFpc4Oq1axw9vAIcsKLszmU4HJIkCRsbG1y6dImPfOT7cZ0GeZEa\n", + "PrPLytIyL7/8EotLp2nU6iYfNSaMIjAQXlGUZprUIRPatvjAu0cIEBICJwAhUdKaj5U0azUc4ZKO\n", + "M1whWJybZ1KMqvvh7bpRawdgGyKLtReFhoCE4+IIUMrClRJVAI7+XlVqurK9r+w9ZDvvuF5HypLZ\n", + "2ZkKjrWvaVkv+r52CX1fC7eyDKkKXN8FITU2X0ryvGQ8ThmXE8LwIFJSO0n6twXb2ObsW7kRftsK\n", + "+GQ0ogCE54HnkSQj0qzghReeZ3ZmhpXlRYo8p1Zr4DiCoTH+j+PY5FV6ZuOr6A97OEKQloJmq4lf\n", + "arvHnZ1dTf8D4lpMGIWAYG9viysXL9JsNjh16hgPPvCA/j7fI5uMtVOY5+IailOaTypmiOV/WjaC\n", + "VJr9oFVdumstS6fqlKcx+Wl+rL1Ypsn7053AWx2FKfjSLGeEo5VkruvhefpmHPQT3Q15LqqUCGOY\n", + "1Wq1yc2CyQ18zp87Tz2IGCYj3bM4gnQyZqbTolmvc3hlleFwqEMa2m2GozFSKbY2t5kkE5ZXltnZ\n", + "3WH18GHuuvdu1je3EI7Hv/w3v8O58xeI6x28uE13fonZmVnCKCBLU+JaDFJx9Mgx7rrzTjOCSwZp\n", + "j73dHdY3NkmzlFa7RS2uEcYB22vXGAz2EUjas3W+/7EPs7i4iG8ZP7LkPd/5EE88+RRz7SbD0ZDR\n", + "/p42vCpLxr0B/+RffZrrV6+SjEb8+Rf+nCdfeBElBLVGg6XlJWqNOh0vYOXQKuzucvnaNY4cPYrj\n", + "uly7tUZRpMRByOLKovbKzlLW+lvkaYErBK1Gk4X5eTzHYTxK6N3aZtTXXuROPabV7SCUIs9ydjZ3\n", + "eNd3vItkpOXyw+EeZSnptlusb27ywcfeR3dmhmScQp6T5WN8YVhbjuDE6hI4DkJIHCRZ1ubo4UM8\n", + "+t6HAcX6+jq9/T1u3Vrjq089xfqtWxw/fpQ77zjJ/fefZWlpkd3dbU1ndAVe4LF5dRPHdfi+j36f\n", + "gQKHWuxCQZ5BFGsVa6fd0YEbfkBc0wlSjqeFVZ7nIqVZgmIKtrDBxMY+1qiu7UMNBK7naRk5JW6o\n", + "cfpMZlVEIOrtEjGpdguFYX84BkKlFCB0xy0NtRKM2tHT0nqE7tcdBcLxdRgy4Lh6iV2WIEzA8P5+\n", + "D6V0DGGaptUD0DJOwlArsEfJCNd19ERZ6GI8Hqem0RKGA041pVuoZHoCmG7g3g5Otce3rYDPzsyS\n", + "Fjml45CXCkRBuzPDc88+x4c/9CFQJqF8NKTb7RqurKbS6TQT3UnEBs+M4xhSyauvvkIQ+LpjDzQm\n", + "NknHSKXhgSeeeIIwDPn4xz7G6uqh6mmXpWOUNEn047L6QJVSxsjGeJbIqdDlLH1Tzt8b6UF28Whx\n", + "8OkN8/Qychrzejs3wrI4EP/YnxUG+mejtE94FIYgMIIcD0cqkPoi1kyIgmatzksvvkS33Sb0fITv\n", + "0u/1aLVbDPp9Dr/rXcY3PMF1M+1v7ugg2IX5BQaDARcuXeDs2bOcv3SB1cNHyKXiZ37673PX3fcS\n", + "NdrcdedphFej1WrRH+wTexGR6+MIBy/0QEBeKEqz5Y+jCG9hgSPHjvHSy6/QHwzY2NqiWYtY37zF\n", + "X/3R/5rTd50iyyYs1ef0BJQkun+P9wAAIABJREFUBIGnHSG3t/EFyDwlS7QQJ/B9lOtx+eo1Nm+u\n", + "0Qxj5lsdXnvpZXAcGp0W/eGQ/nDEVm+fr507j+O4tLtd7n/wIc5dvMja+i1muh0W5udpzXYRnsu1\n", + "m9dxRjmNWp3IcVlYWqLX6zORKfuDPl/+8hPUmg16g76G4fZ7pOMxjUaTRx99H1EUMb8wz2Aw0OKy\n", + "qKuvmSJjbq7NzvY6WZqwsnKY/d1dZucW9VI+TUmHY4IoRHguSTLC+rzb68nzPGZnu3S7bY6fOE6t\n", + "9iEuXLjAFx//C77y1af4s8/rLNYf+7G/ius4FHnG008/TRRFvOeRR0DBaJToYAMOpkMpFd/93e8n\n", + "GSfmvtOWExbnthzuMPRus4W4neMstNLTsrCm9kSOf1CibWlXpV5q2iL9lofQalbfBJ/b+6s0y0NV\n", + "vbbBlYWGF5VSVZKiQIDSwd0C/ZpKoaccdcCr1wKuSdWIWefFdrtz237L1gPfO7j3LdXQ3vP2vRZF\n", + "YXIB3Cp9apoS/K1w8G8bjfCpL/wBSZYS1WokaUbcaPK7v/d77O/t8z2PfZDID81CJTAp22W1CLTj\n", + "kv37fl9HrHleWHmfKKXpX2u31hiNBiglOXr0KHefvpsTx4+TjccV9Uln/jmVsAYOCrXnaZP8sjhw\n", + "TQSjrjQmUXZxZlNxLN48/WeLZVloxb7GtBPjgSeCw+n73/emz+2lbzwOHFjv2uXWNKtFy7D1Re9o\n", + "TzVAUALSEUgB/eGI3/yN36BmEkmcUGPljpKcvvOUNp06dYfuIkrN0W+021q0oczF57rcuLlGWpSc\n", + "v3iZP/6Tf0e92aUzM8/S8iphVAPXULWkxHEEge9rvw0EspQ6SsrR00IuMzS9rGCSTQyXesT+7jat\n", + "Rp2P/5WPMRr2aNTrjHd7+MYFbzAY4Idalv9L//gfs7G5UQmZBsMh6UTjvQ/e/wBHDq2CUnzjmWd0\n", + "RqLjIny9PO/OzrK6OMurr7xOXhQ0mm2UgJWVFWZnZ80YXjLs7WsvnahFvVajkJLN3V0kilE2IclS\n", + "unNz4DlEtRqD4ZC4LNm4ucbi4iJhGLGzvc2DDz6kl3tKC4dsOtCNWzcZjxLa7Rnm5hbw3QDfC7Sp\n", + "luNo6aNQlEp/plakYmGR6evKFghbJPf29rh65TK93j43blzh2NEjzM50mZud444TJygM7c9zPRNH\n", + "pqrrKs8LhHDY29tjZmYGpXRD0Wq3qyAFq3uY1iXAgQWE/nkHTYuFCHTBfvPU6YoDVgjAw+//oTf9\n", + "m6e/8hlzXx0oNQ9gSM2ymZ5oNa48Mf/O/nsLrxgxkbEKEI6D46iq3kyzQuxkPQ2pWkjqNjvsKWjH\n", + "ft807GN/nqZbFtXezBIPhBDvGGr8jh24EOIw8BuAph3Av1BK/RMhxP8B/CSwZf7pTyulPme+5+8D\n", + "P4HWBvyPSqk/e6ufPZpMcAOfvJQooRdjzz33PB/+0IfxPJ3Con8Z7VPieT6TyYTd3X1GIw2n2Kg0\n", + "vbyrMTRbfCkLLl++zI0bNzhy5DB//cd+jFpdjz6NRoM0TWm3tTLKFlhbEO0FYP+cpinSdL6BkfZa\n", + "/xLH052w5ZcD1c+zJzRN0+pk2pNjBQ52uTl9gpVSVRf/FuejOuFWMGCl8faJrpTezkgUnhdUr5ul\n", + "GY7vUTqCJ5960vh9KKI4okCSFgWh77G/v8+HPvhBBEoveNAMm+3dPa5eu0ozDrnzzrtBOBw7cQef\n", + "+dPP8YXHv4zjN1g9fArHj5lbOMLNtTVm5pv0+j0WFxYZDQaEcZM0L5BFaRRpZmmTgxe2yfOU8aRP\n", + "u9nl8tbrLMx1ufjqKxxdvp8v//nj3H/ffSwcWiBeWGY4GvLiSy9RypLHv/hFXOM7kxkbAYSgM9Nl\n", + "Z2ufdqvFjRtrfPhDH8FV8MHv+RBxvcZnP/dZnnn2WdLxhGGvxxdefp73PvpdXLx4kdfOvU632yVJ\n", + "M86dv0AY+LiOw/z8LFeuP8fRB84gxnvMz85Q1D0aUczJmRPcvHKN5e4cWzdvIYY5tTRnN+0xuzhH\n", + "e6ZNkeXML8xxa+MmK8uHmIwn5sGrlbqLiwt85Ymv4jguy8vLRIEWjAiJnqCQJprMIfA8lHGjlEWJ\n", + "g6jOt8a2R5Veod8f0Om0ie+6i6LMuevUCZ568gk6zSZHjxzR+5xS0mm32d7dJa4f8Jf1tewg5cHe\n", + "xvM8EwqiO02llAnfOKASvtXxxq9ZLvZbHdOQwtt1otOduaXlVveSUU1OT8j63tb4+MFbsQ9Bk2fp\n", + "aGKCUiW+H97Gn7f3vxA6Um160rD4uRXv2TpgbTTs71BRFE3N0fm6siroWZZV/32r41tBKDnwd5RS\n", + "zwkhGsAzQoj/D13MP62U+vQbPsx7gI8D9wCHgM8LIe5Ub3GGarUGwnPpDYd05+Z48qmvcfbsWRSK\n", + "tVtrKKlo1RvVeJHnOcl4TFkU+H5Q4U+9fl8vNUcj0mREHEcEYcjdd57ixz7xcVqtlpbKliW1MEIV\n", + "Ob4jGA6HOI4WwdhFwjSNx8IkruviRjq1fBq+UEqRl0WVoDFtVGUFEdMnzXb4Qogq83GaA24vViml\n", + "LkBvcdj3Nt2x2++b9osQjjZpUoU0/HNtdKUcgR94XL16FVdoxWEYRWR5SpZnHF09xLC3jxA6w1BK\n", + "hTL4YqvV4uzZs4hSu61dv3mdJ576Ol/6ytdozyxxz5nTdOcWCII6e70xi4vHGGZ9ao0OgyQlipsM\n", + "kpzA83A8H4SL8hSF0ruDbChxXB/PjcjzgsX5BbY3b5COR1Dm7G3t87u//f+yt7PLsTuOMBqNiOOY\n", + "erPBoUOHWF5Z4Ttclz/5d58hScYoRy+wGs0mk0nKa5dfY21tjXd9x3cSeD5CwXsefoRLly4zmUyY\n", + "abRwjxzhheef576zZ8mygt29PVxXj8ajwQhZlvR6fU7ffTfD3T5ZlvP6Cy8ji5KluQVuXr9Ou9Hg\n", + "jhMncB2hI9OU4MjJ47ieDr/tJ0PyrKDMNX20UW/iOm7V0a1vbXLHHSe4ce0GtVqN1ZVVilLSbneZ\n", + "pBPjER1QlCXpeIJAJyMJoaetwrChHEdQCyNcNI7aWFpkd2+PWq1Gkgz1fiGMuOvOOxFSGQVjxLA3\n", + "oNNsk5g80+mRPo4j6vVaBR2kqY5ia7U7hpaoF/iWJ31QJFX1n5QHux6lVMUHn45TqI6pe8MW4Tce\n", + "B3DNgVBumopncyWn7xvfD6de4mAa1iJAOx1ouwJbfKc99ZvNZrUHs122fR/Tk8Ub8expDcc0lFqv\n", + "16vvsQ+Haej1nY53LOBKqXVg3fx5KIR4FV2Y3+YT54eA31ZK5cAVIcQF4N3AU2/6l44gzTLtQhYE\n", + "XLlyhTP33ac9HoSDchSJUUbap5jneRRlya31dS5dukRZlszNzbG6uso999zD6vIcYWi8iF0PpSS7\n", + "uzsEgY/jaMBLSlVl/tmCbOk6tjDbDtl2G0h9ku2Ha3HvMitvK6q2IE+PTXYJYQv3dNGdxuYqXP0d\n", + "yPt2VJse2+zJtj8nTVNKWSIcoQsD2u1NyhLh+VWknBdG2pkty3TobDLBDwLe+973Vuo6S+8rpaRU\n", + "2n88zXPiRoMbtzb46lPPsLB8lMNHT1FvzeD6TdJCEdU7bO/1CJuefs0so8RDKfDDBkWWUyIosxzP\n", + "c0C5eF6ALFPiuIYsBxT5BKEK/u7//D9QpindVgcXLfqJ2lFl4FXIkv39PuubG1y+epUkGZMXJaMk\n", + "odvt4rgBSuR0OjP8xm/8Jo++532UecYLL7zAAw88wI/91U/w6muv8fQ3nsZFMNNu8cKzz3LPPffy\n", + "Wpox3NvTC2ypF17rN27x/d/7UYrhhM8/9QXe/fDD/Jvf+S3e/ZN/k1FvwIuvvsTnn/gyJ+44wZHj\n", + "R0mzlOjiy6gsx3McZmZnKTJdFC5dvMwHPvABGvWY8XjCaJAAwpQ6Ra+/z8L8vOnoMqA0PjtauRqF\n", + "msY6Ho+rCbEsclqtFkVZWoiXLNOe641Ggyyb4LsOIgyYMSZWsiyJw4h0kuK7HulkghuYhd7Ugi1N\n", + "U2o1LYaq13Vajy3AnucY9gkcFGzMfWcLubityCHk21AED4ydpov9Wx22QOpCp6eEigGG9sVRhuoL\n", + "tqu3ego51f0r815tso/E88A34RW2+57WYli4yMJftqOe3mlN1xdbKyxN0Hbi0/DqdN15p8nDHv/R\n", + "S0whxDHgQXQxfhT420KITwLfAH5KKbUPrHB7sb7BQcG/7UiSBDfwCQIfTzjs7uygSkmZ5xQypdFo\n", + "kmc56STFZvcNBtrzeWZmhr/8Qz/A7OwsMzMzB1hfrkUKjqPpZ57v0mxov400K26DMRBuZbFqL34r\n", + "R69y6UxhlYV++lubUWvLOl10LddzWlJsT4ot/PakTOP4tlufHj3f7mK1i5Lpp7odtWznAOB4LoEf\n", + "oEqFzAtjD+qB45CO9MTh+T7JZILveQyTIc1mg/3dXc69/jqB57O0uEAUhZX/g5LaHEx5PrkU/MEf\n", + "fYaTd54hbnSJGl0KfMgVSng4UtCamSMvhxSFJIzqFKWk0WgbLru+8OJGg3wyQSFRqkAp3ZmOkx5X\n", + "Lp3jv/nxv0bkCXpZyu72FoPekLKQuDWfWq1OFNfodrvMzs6xuLzCI+99lJdfepW4UWdzc4ter0dc\n", + "q+ulXC1mf2ePT/2Df8DxoyeII5+5uTl++7d/m0996lOURcHnPv9ZZFky2+5w4+oV3vfIwzz77LP0\n", + "en3N9HFdDq+ssLF2iy9+7Sn29vaQLz7L9/3lH+T3/ugP+fFPfpJbN68z7g342z/+k9x35gwoxebO\n", + "JlIpWo0mnU6XZKhDb1949lm+9tQ3OHHsBPPzC2xt7rE72OHW5hqqlNRi7TlvvTg810M46AR2xyXL\n", + "JjhK+3orqUCV2mM8T3E9jyzN8DzNXhkNh9qmWenotX5vn7vuvIsiz4nr2lytFtc0pOM6SKPOLKHq\n", + "Dq05V+hrNWmj0QDzgBZCm0WhNCuLKfzcFtOqo0fhCN01K/M/fX8cLOmllFXz9k7LvIMdVGDuuQOh\n", + "nDfVEHmeQ57rZaKwcLJwDSPG3juKNNXmdFaVaRWxRaFoNDoVGqCVncWUwhrStLjNgXT6Pp7u4Kfh\n", + "FXtYCMUWc2t+Zwkbb3f8RxVwA5/8HvA/mU7814CfNV/+OeAXgb/5Nt/+ltWo1WoxyTOKPOOf/cqv\n", + "ko7HvPD8czQaOqk5iiIWFhZZWVk28lVdGBuNpr5wjBQ5y3RBUEoiixQc8IW+0BHadc9xXVx0BysN\n", + "XiwcXQhtGn1R6IAFGwxsi2SWZdTjWtWB2MI9XTCnL1S9TDUBAeYBYDsJmw9ov9c+AOyT+Lbu5C2O\n", + "adXlG8fCaQimkCWTNNWYqKNv4AL9ILHdQmm41qV5+ES1OrKUfPKTn2R7c4syz0jHE/JSsr27w9z8\n", + "ArV6A9eL+dmf+4d4QYNme46w0UG4IY4b4Xia8yyVInBdCimo1xqaSaAzJLAuidKEK2NUajJPiGOf\n", + "ZDhke3udn/iJH8d3JJ4rWFxawBMe4yQl8AKk6+huMQxwXY8SRZoWIFI63VnysmRuboFr126ws7uP\n", + "lJJWo8kwSbh2/QYf/f4f5Nb1a/zCL/wjbt68wc///M/zXd/1XexubXHi+HGuXr3G/Nws1y5f5H2P\n", + "PMzlK5e5eOEScRCihMRFct8DZ/nSl7/M1evXaDR0dN7+zg73nz7D9fOX+cVP/UPO3ncfn/j4j9Jc\n", + "mCMvS2QJG+ubOMIhCkIefvi93Hv6LPV6natXr7L84ApZOeZf/9a/5sjqKs1mk52dbWZnZ1CqrOCc\n", + "stTOeXEQ6jzFoqyMkuz1l0307iU3/75ei3E9h8LVCt1Go04UBiSjIb7rE3i+DgH2fIIwoJxaKk6z\n", + "K9JM2wBs72zhuMLoGmJGoyFK+UyHA1tzqIqBInQhtfTf2/FjwRv3dNPLw7draqZhk4N/Y6TwxUHH\n", + "e3CfanGR49j7QcOZjotJEvLMJCGqYm3j4qTUlh6TiaYV287cwhxZdsA6szsq+/7s7ymEqCiI04tN\n", + "oGKtTf/OrVbrLX/v6jN6x6/qH+4Dvw/8plLqjwCUUptTX/914DPm/94EDk99+6r5uzcd//hX/i/9\n", + "AQQBDz10lr/xNz5pGBVela0HoAyjxHW9qjPGpGOEvl+NaLoQHkAJpVSMh0NGo4Q4jqoP03VdSgQ2\n", + "C9CehHq9jnWis8wOS1NMhqM30X/KskS4TrVEtEZY7XbbjKoZg8GgwtWtP7cdiyxulmVZFYxrVaG2\n", + "03/jUa/XK6c8+8S2T3x7EYVhiO8E5Ko0RmEgXJfAdemNhuyb5bDFXO1+IK7V8FxR4Xq+oxPrvcDh\n", + "yJEjZHnBq6++xvOvXmY0Ljh2x2laMwtIEeCGdXq9Ac0wZjDYZ25uhltrN7nj1FF2d/aIwogyLwk8\n", + "46EsS1zhocoUzxV4voMfeGxu3GR3+xYf+5EfYLYzS7+3TZaVuKFevkrhgOfrghVq//jxOMUxdp5C\n", + "uHS7szz+xS+Za9PT7JfAw/dDmq0WFy9f4p//2q9y37330uy0edehFV5++WW9hItjFIq8mHDs2GGu\n", + "XLnMyy9+k/sfeIBWs8alS1fY3tnh0qVzHDl0nNOLh3jl1Ve5/NLLfOz7/iv++A//gO/+7u/m7gfu\n", + "49z5c3zx2a/zxEvf5H/7qf+Fe+8+rQvsKMH1fXzXIxklRJHOTDx8+LBmcTRmWbu5xsrSMufOnePo\n", + "4SMkSULDuF0KoV0cFYJSltTqUbUIK6UevZPBkHq9jos7BUNo9XPoB+SFvr4DP2DiuvTMZOt5upAz\n", + "TlDIapq095QfeNSiBqPRiPn5efb391lcXOLy5UscO3asSnsqy6IqhBa6sF2q7Y5tAdNNiUBKUT0k\n", + "bDMjDH49vZh8i/p0m6r54LW0pF4IpyqmtpA6wr1t8nY9XUCtuVgchwcmdOKAzWOnbB0YMr6No20b\n", + "KNs5Txfi6UJu64olPdgmzr7GuXPnWFvf4vVzl257z293vCONUOhHw78CdpRSf2fq75eVUrfMn/8O\n", + "8C6l1F8zS8zfQuPeh4DPA3eoN7yIEEJ9+Qu/r4uZ0PhQEIaVFFnvHjSGK4vSFJoJnuualO0D8rvr\n", + "6gsmyzL8wLqF6cQUu1S0F4stoHYs6/f71RPWPm0tp9YWc4AyL27DwCzMkuZZ5Sxmcfo0TYmiqCrC\n", + "dhRMkqRSYE5j19N4mH1fSZLw0CMfetP5eOkbj7/pwpheeNivTdIUPG3VSymRSqEcl0JJzl++xJ9+\n", + "7nPUoxiZa+HBeDJhaWGBTrPBT/7E32AySlBlQV6UKKETunVYbMgv//PfYn17l/vu/w5y6eFHDbJC\n", + "4UcxaTqhFukgh26nw3DQBwQOOlA2NCpLz3WQMiVNE8LQAyTnX/4m29ub5NmEh+4/gyq1m1uZF0bN\n", + "51Sq0dRwkQUCx9OZiyBwXI9XXn+NXk8vGDc2Nwkjn15vn9XVVfr7PQ6vrnDhwgV8z6Xb7rCytMg9\n", + "95xGScWXv/oFGs0Gvb1d5udn+NpTT3Ly5ElmZma4445TuJ7HtRs3WVu7Rbc+T6etE9GVgCPHj+F6\n", + "Hs+/+BI7+7tcuXIVHF1k3Szn/e97H5/4xCdoNVv4fqB1BcZ7W9vBGngv9vnDP/pDdne2qMUx9Tjm\n", + "wQceqAquDgMTlKVegI3HyW07G0u1tbS+MAwNbCHIsxLHs1Q6bdym909XGY1G3LhxE8/z+eD3fA+o\n", + "qUWgOaztLujvG48TBoMhMyZ+sG6StCzUZ7vIN2K5b8S17fLQ1IbqPlDqILVKSsl7PvBmN8InH//D\n", + "2xhk0z8fISgKWTVM9vORhSQv8koxDfDGHZSU+vdRiIqabAu4rT22ttjmDg6i9OxnYN/bNDxiodxp\n", + "GLWCfcx0D/qBEgQB3/Gej6D+E90IHwX+OvCCEOJZ83c/DXxCCPEAGh65DPwt88G9IoT4t8ArQAH8\n", + "928s3vYoioLJeMysMevvuB3GlhdbnVRFHEX0eiNqtRp5kTJKBrd5bKfpuOJbD5LxQXdsPgxrbCWl\n", + "pFB2zBI0a9qpDW7naNoFgu1o4zjGb3jV8s+OOfV6nbrTqLqfoihoNnVmpn1wwIG3SRiGt7kJTnN2\n", + "LY49zQF9q8Ni9NN0pMFggO/79Pt9Hcbb6RDXa2SldkXDGP0jjMy++kxy0mQMCDAKs+FwyK//+q9z\n", + "aGmZWhTiuh7t7gxxo0a706WQgqe+/gw/9MN/BeX6CNcnKySduQWuXLnM4uIC6SShVou4uXaNdq1F\n", + "vV4nScb4YUSSjAh9D+FphVscB2zcuskz33yayM3Y2thEFgWP7+6wub5WTWJRFCEc7deNIzi8MFdx\n", + "4LOipNfvGyWfIIhjhoMRfmgnkxyUfhgPR0NeP3eeoshJRhn9fp8XX3qB3/2D36NZqxO1PD7wgfcj\n", + "aZLlGY88+h6uXblCo7XKN59/hlN33smRE4eptWJGvYJrGzeYmZtleXmZQaKThJ57/nnSSUpsTLEa\n", + "9Qb1huDprz3JM09/jb/3v/49zp69n729Ps1m05xLSZqNDBSRcOLECV5+6UVWD60QeDr2ryxLBgO9\n", + "A6g1GhpOCj2iKDCT3ATP80iSIaAzJ5XSqUKOA/39Pu1WF6kKev0eMzNder19tra2COOIJ7/2FL4X\n", + "8gM/8ANIpfCc2x0zc9OsWBgxSbRKtyxLtre3OXr0KMPhkDiOK8Os6cOWAbt8PpCMH3S39to+gC/z\n", + "CmJ8p0ZTSllNovbBoRfwmgtu7zH7OtrAyzXkhmljK6oIxG63q4uqc+Brbt+/hT9tivzOzg6zs7MU\n", + "hWRvbw/HcTh0SIsEh8MhvV5PK3KnsPzpBuyNUKqFcqYXnG93fCsWylfQhq9vPD73Dt/z88DPv+Or\n", + "oo1mGo0Ge3t7LC8vV0k4drtb/ZKlHu2KXBdZm+YiS8lEpQR+gOf6lIXEd13CKKy6Zx2bZOxe0bxQ\n", + "0E/1wUAnh3uuXmQIBI57wLG273EygUGmL7owDEBBmurEa6n0T3Q9D4FVxh08DPQT1kUZc3h7Mxxc\n", + "NJpNEJplbpEf2L6+1TGZTPRC0nUrd7O4ViMzE0yr3QGTsei4AoGDH/ogHB0ZlU707ykchPBwg8gk\n", + "wEy0zD3w+e/+279Ff7+HK9AULNdlmIyROPzOv/1djt9xitFkQrPdwvNrjJKc0SChWW+RpxmNuEaa\n", + "JBxaWKEo7YNDf07NRg1XKFSZsb+3zcb6Da5cvUSRj7l2a137SruC7Z1dZucWtI1rXNMRY0oiHUEy\n", + "HnPhwjn9kC9LHNfXUm7PpygLiiwlrgUIx2U8mTAa9YijmMuXLmp/dM9jPB5Ti0Ncz2NxaZFH3vuI\n", + "6VJzhBQoKWi229y4fp16q4Pnx6wcOsyVazdo94c4jstwmHLXnXfx9ad16Mi7H3mEX/6lX+ZDH/kI\n", + "l65cxnEE3W6Her1BKCSz3Q5CCP7pr/xTHn3f+/jwhz6kXRjTlDAI8F2HIpsghMvZ+x7gT/7oMySj\n", + "CfVancFoRJnnNBrNisPseQ6+55LlKa7jGhhC0mg09XJ+klKv1RlPxowMHzyZjNBJRk329/ep1WJc\n", + "x+WFF1/EEYLveewDOA6MJwlCGdWiUgSenj6dUtGM6yRj/WAajkYUZUle5Fy+cpnFxUWScUKtVq+Y\n", + "NMpOywYJ8D0ff5pdwsHSUk1J8B3HJUJDYFpt+dZQgpICFExKy5lWVUesSr0bys3963oeSoIIfEqp\n", + "vVtc10VISEZjFNBptWg2W5r15nvVbmwayrAPID2FjInj2ODiLQ4dWiHLMnq9fUBDmtrf3SPPtSNi\n", + "alTdusezv/+By6ENg55mtL3d8e1zIzQfSKvVYjAYVMXbjoK2Iy3yA1qdbyxbLTcVgNqBGUxWpKTj\n", + "gy7c8iwdY1bjOiaqykSGtVqtAxzOdRkNB9US074eSuL7rlkiORXEEoYhw+HQKNd00ofneaR2Iz+N\n", + "HfoejuNVEI0dv8LAx5rJu46DMt1Inr81gd8L/Or3PpA4mzQjqarXDoMQpTSeXsoCKcwC0fOoxbF2\n", + "WlMAHmlmgo6LEuW79AdDyjJHCcFoPCGMYiQCJRzWNjZodpaJ6g2U8EiGGVGtyXicMNOZYdjfQ0hF\n", + "5AYEIqA3HtJo1Gk06gSuIB0PCH2Xv/jS46BytrbX2e/tMxj0qDVi/cDNcrI85db6munSYzZ3Nml1\n", + "Wmz3dkjGE2pFTiklcS0mGaf69zfL6tm5OZqNlrlGpO44e7t0Wi2GvZ6WQuc5wyylUAXxpAGuw9Ly\n", + "Mq0wIA5rvP7qOZa/8xB5BsdPniLNclw3ZHFRe8I7jqTZbvPquXOEcYwSgsuXL3P4yGG2NzbwhKBW\n", + "rxOGOvHeRQdGBEFAs9Xi8ccf57lnn+Wxxx7jox/9qHY8RNDr9QjiiI2NLaIoptlsM5mkZHmu7RCU\n", + "TrP3XK0W3N3dZTDsE8cxS0vLKKVIkjFRFBOGddY31mk2m0zSnDAsqNXC26bTNM0Ig4D/n7k3D7Lk\n", + "us47f/fmnm+vtauqG9UFNBaCAAEuEMBVFEVJJLWZ9EgjKyxZ4/GMwxEKj0OjmbAdY88S9jjkcNgh\n", + "Ozx/zESMRdlhSbQ9Q1kOitplihYpkiKABtBAN9B7Vy+1vjX3zDt/3Lz5XkENaP5xQBnR0Y3Cq/fy\n", + "ZeY995zvfN93JPDjP/ZjDURgSYG0LCbDIVVWEHQcopGedpUXBa1OmzTJcF2fTrdPv5+TZhmHtQnY\n", + "bBZR1kmKHvJro2RtrZzlJ7DuSunpPErpwQ56uINEVBUik+RCe6RU3B8Dt9D2DKmKsaQFggYONevK\n", + "8k8OUikqM0lLx5Fr166xtLTCzgPbui+GoKwUs/EUyxJN72y+nudMs0VCw+3bu7iuW2fQVu38Oaph\n", + "oDlFWQhjRFfV1f6cMKEFUh5KGU7428fRd3Qq/SLAb7JTs9uZIBn49glOpaHtGHjEZNt6oEPeQBSL\n", + "wR4WPYp1dtztdpvhtQaLNmWSwd2MNNZ4dpsybBEeMd/DYHemObEo4NEioezE9zXnXRR5E/ANx9xU\n", + "IG8+bFv7kRTFHKIxjVXVkFCaAAAgAElEQVRtaFVn+VWJquaj2xCCQimkZeO5LkkUa0ZJPZ0ny7X9\n", + "rq4EXCopuHXrFqur2vY1KxRnzu5wdHTM6dUH64BfYNkO0+mwpqUd0m752JbmMZdVSi8U2DKliCfc\n", + "O9jjYP8eVy9fRFUFw+Gh9qSgYGm5h++52FLQCVs88fijfOB978VzHfK8YDgaEXbb9Pp9XN/HTnP8\n", + "MCAIAuIkoawgbIWkWca/+IXP15n3DNt18RybsigYHh3zX/7Mz/Dxj36MJElod9vMoql20lOKX//N\n", + "3+A//vavM6iWOLWxQZpl7Jx7SFNQk1SPPev3UEpSVoqb93Y5ODgg8H1+8Ad/kC996Ut893d/N7/9\n", + "W7/VQA0a4tOVDYJG+XvmzBkO9vf58pe/zK/+6q/i+z5//nOf42Mf/RhpUdBptzm1vsrdu7cJQl/T\n", + "TqVhLQhms5gsySiKin5/pYYtCixpY1se02mM61UEQQulBMvLq5oOlyXaiCuaIdAw5vHxMUjJdDrD\n", + "cXQCYqpE1/exA0lWVQQ9ndl3vS5ZnpImMR7au8OxLYosoywKXr90iZWVFc0+QlAVJRWiWT+e7ehq\n", + "WM4nAZWl7rWYONAIXgBbAKKq/dT/5KGqnLyq8ELt7a8n0WtDLSHmtD3jR2LbNgh1Qkz3zDPPatV0\n", + "nOiquB7aoFXbcbMZLGbERtNhEiqlFGtrayeYXoseNYsxwuDoi3i3lLLpmxmYxkC2b3e8ozMxFxsW\n", + "i14kJnjatk2apPXOLKiULi8ar2FVUJWAELieg1N/nUX+qHkY4KSwJk6Spnm4WB4tZvuLP1/0NVjE\n", + "zAyebTYMk2Gbz59j2lnTXGo67VVZ06dU0xU31+V+h5kwr/9YTTfb7NhJEmNZdj1IQNO5VP29C6Xw\n", + "/IBup6MnkQ+WGA4n9cMkyIqCVqvF5z//eT78oQ+xvrZKFMcsLS+jhIVtWQx6Xaoyx5IVWTqjVDb9\n", + "Tp+wbTMTEktktMNQc7Ul7N+9zbe++S0cWxBNJwyHxxR5SpLEOJ4NZYXlOkBOkWTM4pi/+GN/jccf\n", + "eZTR8RGua3P2gU2msxnD8YgyizgYHbG5tE4SJyilSOpRcffu3qM36DMejxFS4noeWZ7hubrJHQYB\n", + "rVaLmzdv4roOo9ExXhiQZClBq8UXv/hFHFkyS2JObW0ym0VY0qIoKy5fvYaUFnGUsrS0RKfTYXnF\n", + "xvO1h/i1Gzd4+umn2d3dpawD1dLyEnatsLRFRZrGxHFSz+B0OLW5jio10CCEJIpnlKqgKCqOjoeN\n", + "dbHJmHXS4jCdznBdD0VOVUlsy8d1QoqyIM10E73b7WrVZt3Qj2YxQeAS18O/QTKNJhwfHRHFMbMo\n", + "Is0ywlYLWRYN93g6nSKkZG1dw1mO4+BYkCQ6g53NZmRZiuc6dV8o4N69/Wa6k14TFkWZ17BnCY5T\n", + "27cWqGqexOmFZdVBtw7WtVFVVWpq7H0PUWJbgslk1FwnDSfNVZ/aKCpsAuetu7u6VxQEhGGLu3fv\n", + "al+bGnMvirmAsN0Om3iQZVkz/NywxkxgN2vR6EkM7XiR0WYoh4u9tkW9iTl/4wW+SEF8q+Ods5Ot\n", + "OdfmpE1z0Jy8eY2UEt/R7A3zxbXS0mrMrESt/jKy+BOUofq9Fo3SdfCsiNKU8Xi8sNvqh3+R92oe\n", + "RHOO5r2MCZbv+w2FME21gALmTRvzIHQ6PaIoOtGNl5ZFVRZNQ3Zxcs79DgMv6YdSnuCWG0qiUtrD\n", + "2XPnRjlCCBxpMZ3N6PWXkBJmsylCaBqnJdpkqW6CJXHGmQceIE3ihsZVVVrR+sjDD3MwzbFVTjf0\n", + "UDigIu7cvMmZrXWm0xF3bu1y5Y3LxLOItl/x/icf5Ad/8AeI44S//bf/FlWR0e14pHlK0Ao1YwaH\n", + "laU+/9VP/Q06rYA0ntJuB8ymE65evcL29jatdqhN+JXi2htX2dw8TZIkdHs9XN+j3W7zyqsXaIUh\n", + "B0dHtFot+v0+8WyGYzvs3bnHgzs7dSarF0+aJEhLsnfvHs8+8wwvXXiBvKo4Go1oBSFHh0eEYYtz\n", + "5x5BIOl1us1zW6ANzJ544gl2d3cJfZ9vf/vbbGxsMBwOmU6nDV+45Wm5dK/XO1HFObaD57kkScq/\n", + "+bf/hldeeYW/+bf+Drbj8P3f/2n+zt/9n3j00UdPJBm27RDNYhzHY3m5g+v5JEnCbDbBdR16vR7T\n", + "2aRpDuZZhu3YHI+GzOIpr7z2qq4884xer8t0qt0+kYLdO7dphSF+EJDEMZZtM00ipknMNNI+2EES\n", + "EXgeSZbWrBOtHQ1bLQ4PDtg6vcnw+Jjd27sM+gMGgwFFoTehdrdNluvBDZVSVOh5uJZtaVFNTTOc\n", + "j1HTQ1pKpRD3bcVBmk41Th/o4Q9VpSjKgrIo8f2grqbnjU2lFE888Z56YHmL2WzGztkdhkdHBJ5+\n", + "D2M9YUgSs9msWfudTqdBAkyQXazEFxuS5p7N7519ImE1vHJdQevfMTHFUJj/tOOdG+hQ86JNZ9h8\n", + "SQ0rzK1X9RDiqglyZtczXxjmEnLDyTbDihdtH01Wa3Y+t35tv98H5tl5XA9uMMFbd/ajE+pK85lm\n", + "N12kAMmFDHquApv7JpjfMc2KxfMyPPC3E/IsQkL6vd3mehguu1KVVrst0KukgF6ng0Dw5JNPcvHi\n", + "GxRVRWAF5Kl+7WQWQZmjFIStNkmSEEURx8MxrVab73jm/Xz+l36F0dE+k0lCGHQYTSf4vkM87LM0\n", + "6DIdj/nuj72fF55/gb/4o5+l3W5T5AXD6TF/+Sd/nMtXrlKpCr/dYhZFKODSG6+j0pRf/MVfJE1m\n", + "PPXkE5RFgRSCl156iXc9/riexBOE9Pp9fNtlb3+fRx55lL39fR7YfoDeoMOlS5c4PDzQ+GU0Iyty\n", + "ZFVot8vQIwx9jTPbDrbj4NkWt27f5jd/+7f0rMxWm6OjIwDcUx7rpzaoCsWP/MiPcvmNy5RFyfHx\n", + "kNFoxMHwkJ2dHdbW1njxxRe5d/cujz/+OG+88YaeRN7paKvQ2azuSSieeuopiqLg5s2bHB0dIS1J\n", + "WgfYc+cepr804Oj4iCAMEULysz/7s/zar/1aXW0qxuMJruPT6XQ5OjqmVBGBH+I4Nq7n1vDICMuS\n", + "HB3tMx5PyLOMzc1Nut02y6tLbG9vNwFoPBrx0vkXtKz/yhWKomBvb49+v49jWQStkFmWcu/4ENtx\n", + "6Ha75KokiiPafsDh/gG2bRGnOsB7nscsjsCSlEXO3uEBSZbWTX7wIo+8yll0DpTCqiGPWshTVw3a\n", + "4nVKnlfo5fBWknJtYZsUZkSZjW0LqP2SQNQDObR7pef5RFnSeB+hVG31224ERnriUEpZFBRl3sQr\n", + "mHsamQD9ZvMuI6RaFOyYGLHoK2NgqkVItaqqRrjzZojmrY53LICbzM40BEzmbb6cgSIW/QYMRNF0\n", + "resgZgK0FLoRUhYZWBaibl46tsSS4AaaT55lmZ5gvpAtm+C4yBXPsoxpPfsQaD7L+HWbjcO27YY+\n", + "uLi5mBsmhYAKvchqPxIppJ4jWcM4BrJZxMXefJRFgaqq2gPdbjrsGufWlDnT2S+KrMbzNJVKY38W\n", + "wi546sknefmVVymqumqBpqP+4M4Ol69e48GdHW7dusWZM2dYXlnD8zyiaMbP/9zfA+mQZxXTWYzj\n", + "Otg2XHr9VSxLcXR4hFDwP/z1v0qRp5SF0iPpiownHnsXvuvywY98lDhNsByX/+V/+19BQdBqc+/O\n", + "bcIgYDJLePjhc5xaX+UzP/ADDEdTLr3+OteuXeP6jdtce+MSlm0zGAy4c28PBayvn+LoeEi702kM\n", + "jGazGWUS4bouS0tLXL58ueHjX7p0ia9//evkZYFjyt76uRsNx9y6eYvtM2fxPI+vfe3rfPr7PgUI\n", + "Njc3efXVV/mVf/dLHB0d8a//1b9iZWWFH/6hH6Lb7dLr9Th//jz9bo9WENJtdxCVvm/nHnqExx57\n", + "DNCb+6VLl7h9+zY3btxAofjAB56h0+5QFHqQ8drKKu2wxWQ0ZrC8hG8FHB0NkdKi1W7j+QGO62po\n", + "qsooopgonnLr1k1GIy2yefjhh7Bth42tLWzXa9aSbdtw+jTvefLdXLhwgaIoaLfbnDlzBktaRHHE\n", + "/sEB337pRa5eucZ3ffcn+N3f/V2iWcQH3vc+jipFr93BKiXCscC2eOXia+R5zvXr17l5c5eqqnjs\n", + "scd45pln6PV6lHlKSYXr2jXH2SNOU22XW1TYtoOqlP55nNCyjYWFT57dH0IZT8YURUZneUXj61LW\n", + "laPE9XT/wLF1LEmznLyoELYO7KISUOnBzQYW1dbHZv6s9k3xPKeJERrfzppYpaFeQ7fMm7igBVd+\n", + "EwcWVdiGn78YwE2/zWDlrVargUHf7njnhhrXwc7g3UATLBclweZLNQZSJzik851c74pzsY55jeFO\n", + "m6Ds+35tAznPkk+wTqjpemruj7JoHGXmD5pAned585kGYzO4l3Fl0zetarJr872FAD/wTtzYt6MO\n", + "haEe6GyoTbZtY9k17icWHNMkCDEXB5VFgULiuB6VEpw7d46yLPD9kEpVOFJSoQVAcZJw+cpVULC+\n", + "vk6lYDw6JooTup0246OU0TSiFXS5ffsuQegTxRPObJ3ixs2r9NoeVaGoioQ8Nz7qlmZvCJvNjU0m\n", + "oxHCsvA8n5WlJQ6PjomjiMHyKmVZcGv3Djdu3kRKSa/bxbZsXM8ny/WGeObMGVxP+3fs7JylKPVG\n", + "GIQthqMhvX6PPC/I8pxuR9uiHty7xz/7Z/+0bpSnBEHAyko9GCJJWBoMWOksI4VkujRDVRWbm5tI\n", + "IXj94kX27t6rvXMS0jhBuorReMQHn3uOra3TPP30UyRJwhOPvxv1F36c/b09bt64ieM4TCcjijxn\n", + "eXmlhrpyQLG+for1U6d49rnnNKSTpcyiCN/zoWZd7OzszLFXJN1uBylthJCkWUqaZ+R5ysHhPa5d\n", + "v8J0PMKtjaje854nOLW+TpFXJGnK3sERrVao2SrTGd26UnjgzDZplpAkCXdu39G0N8eh0+3S6/bo\n", + "9/Rm9Nijj3H5jTdY6g+YjseErRZlWeAELmcffJDB8jIo+KEf/iy+77O3t8eVK1dYWl4hiiI8IcGx\n", + "yMuCrCgaQVKexdj2XPhSFDlXr15heniDslSkWVFn4T/xJ9ZE0GojUDhOAAhc10NK/WxpLFppnxjA\n", + "rTcwpZT2PLc4CXeoOo4s+Kn4vncCIQBjr2udsMlYdCNcJF2YZqaprs1h3FCBhmdeFMWJXhjwp1rK\n", + "vqMB3GTUJsCa8sHgS0YlabLvxQzZBDzHcQjDsFkYBuc2jYRGfg9N0NVlifnDiQtuyp8oihq57GJg\n", + "XbSZNeoqg2GZKmKRzdIosFTeNE1N09PzXG1OtCCD1+q6+L7XTMNJWo242CtI05Q8S5rrqA3/cz1O\n", + "zdK0JNf1GE0mhK0ux0dHvPfpp7lw8RJlXtJqaxx/Gs3Y299ne3ub0w9ss7LU1w9a3c1P04TpcEIQ\n", + "tLn06gW2t89iezanT6/y8svn8T09sSdLc4qsoFQCUfvPjCZjHn3scZIkYXg8pNvvkcYxj5w7xze+\n", + "8U181+X06S1++qd/mqOjA8qy5Mzp04xGI5RSTMYzBoMlwjDk6huvsryy0gzVQFh881vf4ktf+hLt\n", + "th5957gOLRHScTR743/+O3+3KYM7nW7N5Z4yHo8bOfvB8QFKaf+JP/iDr9Lt9rAsqxlafPPmTYZH\n", + "R3zgAx9gaaXP5/7859jb29P3OMtJZzGppWG4TqvNux9/vF74mkY4m83Y29tvfOyRetNPa1xcSkmR\n", + "l2QUNT/aYXt7m+eff57eoE9VgRAwmYxwHD3k4er167x28QKj4SGrq0u0WiGinuDeabeJohhL2oR+\n", + "iBSOFuQ4Dp21NYQQ3L17l7t37/LgzjYPP3QOgN3bt5lEWnzy8ovnObW5gSpKZFlxZmOT2WRKnuXs\n", + "17TBvMz54v/7q7zrXe9iZWWFy5evEEURh4eHnDun33MwGBCEIa7vEYYhvu/rBCjTvQApBFk6Z1Op\n", + "ouT88S0kMIpHCHn/UHX9xi5nz+5gWQ6e59UCJr1WpbBBVORVTlVpFpcOkmlT+ZuRadS8d6UUZT2o\n", + "pSgKVJI1AdWork0wXoREdBwpTwhyTKJmGtGLKs5ebz5hzNhj5HnO6upqk3SaOPl2xzsWwM0XWdxh\n", + "DE/aKPC04GZUXxRjyk7DkzZZd1nqrvai5NVsEKZ5aWAXE9iNQsscZhc152ZKHtM4NUHeYF6m5Fls\n", + "OC6qK81GY7BvSzqNNN8E/TTTtKXFLMDg//c75hz1k1NNpJQEoY0Ulm7kqFIzR6RuDBkVnxYhpQgp\n", + "2Njc4OULrzbmXnme44ct9vf36Xa73Lx5kyJPNXbp2o1IKY4TWt1lHth5kFanw/7ePe7cvY1CsL6x\n", + "xWg0xbV90kKRKg0dZElSQxsVb1x+nSefeJIKiOMp3/mxj1AUKTtndsiLjDSeooocW8KF8y/oJqXj\n", + "4whIZ1Omx8csLQ3Y3d1lMBhobnu7zcsvv6w3YVuLftyaNaBUxWOPPdroDaqqYn//oPHCcV2X0Ug/\n", + "Y9tbZ5jNIqS0+PT3fqpZPB/8jmeB2nSobg6KquT44BBHWviuR5okDAYDsjTFtvRgW9Be3QiB5Tr0\n", + "eoPmHguhudaaq+xosZMQSGWmoEdMp1OWlpbZ2dnhypUrSCnpdnoMhyOSLMOyXF44/xJVVdTvpUjT\n", + "DNfSSUaRK2xbMotTiiJC1glFluaNaMx1HM5ub3N8NOTOnbtMJxP80Ec4DhcuXOD7vvd7eenF81x8\n", + "6RXCICApSpb62v/76vVrxHHMw+fO8f6n3stTTz/N8HjI2pIe3bf5nVtaFdsES0GcxsxmEfE40n0O\n", + "ObdatYTEtiwEgqN7d/Esj5zavVDeH1ZcWdvAb3Xod3s4jl7bZVWCsmrhjKobk3N6ojGi0tVwSVkW\n", + "evqP0ApwIy4C0LbUOgE01fSi8dwiEpCmyYm5AG8e7mLUwydgLGiqfMNcmU6nTbx5q/GK5njHAvji\n", + "ZHaY86WVUg0zRE++9poLYXBf82WFEI21q8lcDT5seJ6GT2lcB01AdhyvyWAXb4YJumYXNJxOsyMu\n", + "NhVMpvzmhqrZJAz2NS8NdcA3eLmUog7i+vPDMGw2hvsd5obPJf1uAy3pTWbeyNEMlwpVKRzbxnMt\n", + "8qIkL7Uqcnt7G9u29MCGBU+HrKg4PDzkK1/5Cn/lv/7LHOzvceXyTR56cId2q8Us6YK0qZTij59/\n", + "kW63w3g85MEHdxhNIu7eO+TBnYfZPzjGbkvaYYt0mnF6+zRXr19h8/QphKW0n4mQJFHCxz/6Yaqs\n", + "JGwFfO0r/5Hv/Ph3MpmMWRr0KIuK2fiYlaVV8qLAkXpI7kMPPcj16ze4fvMGr1y4oFkMaGtVCyjq\n", + "TbssM87ubDMcHqGU8axQjZeIgbosKYmnMba0GI3GrKyuoMqKLM8oiqwe3zajpKLValNmGa0wbPjN\n", + "rus2Qz88x22eG9uyUQjiKK2fEa02DNutOpBb2I5NXuZ6UElV90scXw9YmI148skn2d45y8HBAVEU\n", + "cfbBHQZLyxwcjvjaN79NK/CospKyBIFFu9snmk6ZzWJaoYPvtXDbDpUqGQ6H9RqxaidISzNPXI/z\n", + "58+ztDRg4/QmaVWwtbFBGsdsndrgtQuv0ttqsdTu4UiL4+kx3/rWH+N7HmfWNwjDkN/58m/zkY98\n", + "RNPvegMO7uzheT5xnOMHPqPhCD8McLBpBQFJElNVJd1uC6HQ3iToWZnL3T4Hd66Tp0nNdLl/Jnru\n", + "kXdRlWaClp70ZFkGelVNAC/LokmgbHvuu6KTPAuh5hoNFoJ9lhdNk9Fk4fPgX51IvBabkcZozmTf\n", + "izxyy7IYDocnEjXze+YzTAKqnVff+ngHlZggLd1oKAs9gCDPMz0r0dY3odvVNznLcgTzAQi2radG\n", + "O46HbbsIIYmTBNsWGkapKpRpJoo6K6sUZVVhVQolpKaQmWkdUnsZC7loZjPPlPRGoB0RtX+CnsJt\n", + "WfIEu0TWXF2DgQe+T1HqhyqrN5QMRZrUHHIpqGrcXptvFSRJfKKrvXjEsbbyXNyIjEGPebAMDxah\n", + "O/wG/6uKEtt2sGypB3bbNmtrq1y9dh3L8yjKEoRkMFhib/+Qdz/2GL/8y1/gQ89+Bw8/dI4knjFT\n", + "CisMydOCw8OjuiGnWF9fIQx97u0dsLF5mqJUrKysUVpanjwejdh+YJsXbt7k9OnT3Lxxg63TW3pD\n", + "s3TP4/qNXc48cIbtB85y9eo1BoMBYRDW3tJw4+YNWq02vV6P2XTGbJawurpGmhdceuMK+/uHepq4\n", + "0HapjiVwLAeVFDz+2OOMJxMCP0AKiVdjo/pZskjihLzSJXSWZ3Q6beI4IopjlpcHWgkJ9Ps9ytpP\n", + "x3JckjhBWpbGVoHJZEKn3akZU3rjdlxt8xCEWsBSVdqjI4qiBh6sqA2NKqjyAlvaVKpiPB4xWOpz\n", + "fDzE9TxWV9Z0z8J10batulFvqkfbthseuuO4LA2WEFhY0qq59w4rK8tYls1oNCQvchzL5o3XL7O5\n", + "tcXTT78Xz/cZTUZ0Om1Gx0M8z+eZ7/gOwiDgjTfeYGNzE9dzGQwGrCwvc2p9nW6nS5blPHzuHBdf\n", + "e43V1RVUVdEOWyRJghCS2XTCYNAjTmp2h9BmdYHnIaRAGud5BWVVMJ2OycqKJC+Qlo207s/GmE1n\n", + "WNKh3fJJEh2gTaVsyAcwHzJu27YWGJmkjdqnPNcNf9uxMeZaQugpRJohU9WMuTlsMld3GorvfAiD\n", + "wdoNO84EZOp7bZK1xeTxrdh1b3e8YwFcKYlQtd1llWn8yXJxfYe80Ioq29KZSFmWGicsM3zfIysK\n", + "bMuhShL9FURFlik8T2dnjmV8hDWZ33ZcpG1jS6GlsqKWm1cK3/dQ1NCCJbCYX9SihmJsy2qoT3le\n", + "AHOoRADKkki0/7EWHJX1mBHN887KGuN2bZ351L+rhNCNxbosk1IsGNPf79C4/aKXsj6nfCF4Sy0p\n", + "rh9Opy6nK9BqUBRIbebz6U99kn/yT35el4BCIiyHKM6Qls8rF17n/e99ipWVNXzXxhbg2Ba7e3fx\n", + "fZ9Ox0NaJbd373BqfZ08K0iimH6nT1UUONKmyktu3bzJ5vo6rmUReD6hrwUgRT7vsEshaXX7+GGH\n", + "pRWr5sYqZkpzYts9HyfQnN3LN26wsbYKCopC8fwLL+GHPUbTXVqttr7fUuP1WZrwuR/+DL4f6ClD\n", + "NWynext2rSjNcRyrqbz80Guez57bacyPijynXMA8BRIpbaSQZKkO8I7jUSkQsi6/pUVZ6rF0hjIq\n", + "bTO9fe47bwmBsGzNWvDmsFjYDnV274V1sJC4jn5uhYJW4GNJAdTZo2VhO7oJWGQZeZEQuB6OJZCB\n", + "QyUEN2/d0HzuIKDX7aMUPPLoY/XzZzMea6GQhSDwfa2yHY8Jum0++env4+rVq6RZRpokPHD6NPv7\n", + "+xxPR7z3ve9FSkl/dcB0OuX67g3chcClIQMHx3YJwoCWbGmGSDBvLAoJWZLS6Xa5cv06le1RSpeC\n", + "Cnl/Mz5818OSNkkyt7Itirm//pv1IFmW4TpaSWwCsGVZ5EVer4P52irLkuls1oyPM702A4fo50RD\n", + "mlosNHchzfO8Cd4m6zb8fxOszTkusu/MDF3gbRlp5njHArhXU4mmk6h5oLXTjML3XWxblyN5pnfS\n", + "IPRqFWNOUWoxT1EWoHKktOvsO8Nx7Dor16ORyrKgyDKKrJ5OYju4rkeZFZSqIsmzpuHgOzZZPXFd\n", + "KS20KVHkpcKSAsvS5Z2qNNc6CEPN8FAlpdKlcV5UKGEhpM7+XU9DRWXdgYqzulEjLapqziYxXsqG\n", + "Onm/481SXCHmlrRm09GbisZXizwnLXLsUtvzDwYDZlFEJRRpkXNqdY1Hzp1j72jEaDTBcWoZvxIk\n", + "ec6li5egzPnMp76HPM2YzfIGr1taWmL31i4ry4MaA1QsLfWxHYl0bSxLUCSammZZFlevXmVtbY08\n", + "zzl79qyWmNdQUhRFeuh0FuP5DvsH+zxw5gHu3buH53sNDNTtdFlbW+PSa5dYWVvj2s2bHA6HXHjt\n", + "Iv3+gDDUjodxnCKEAlXx3HPPcXh4eAIKM58LnODlL8Jmi4rYRe491BQzJbGsuahrkY1g7lXzt9D2\n", + "Bm9mKhgqWdMwq0vsRXc+s9AXfaON3YTj+vVz0274/2UJ0rNotVtaJt8bkJFxNBrR7nY5ffp0895Z\n", + "lmNb85F/WaaHflu2ICs0N3oymfDaa6/xwQ9/mN/+zd8kjmN2dnaIooh3v/vdfOhDH+Jb3/oWN2/e\n", + "JAgCVldXkVJy5vRp8jyn3W43lDrdi5k1VWNRFNy+fRuYszLSehDJdDbDbYVUlaoz6bcKZBoirdTJ\n", + "RmEDh5j7xVxHYV5nAnGe57Rq75o0TRtLaE3Jnd9LQz4wz46eLqUaQkFVVYxGo4bssPhMmGdPkxe8\n", + "5n6b8zONT5gz4/40Iyt4RzNw1SgvF5uEWZaeKEGClh6JluU5CAhaIarOfHXTQdUPfEVQPyRxNAVB\n", + "Hax1AyWKYoqiwoxB8rwWCEmaFkhLIi2HWZzWxjo64EpA+wlb2tBJCWRVT68WWuGlEAjpIJReQNQZ\n", + "cFlVFDX0o5sqmrrk2B4KpaezVxoy8TyfoqhwHLMI33rXXVR9mRJrUXFpAk9ZldiOU1cF+iEZj8d6\n", + "0ryooYPZjM/+8J/jn/9f/3c9hCJHYGlXOCGZJjGHwyG/95U/YPvMac6de5CSgtl0yt3bd8izrAmG\n", + "e3t7rK+foiwLbM/TJlpVxdraGmEYMplMKIqimW5ixFFhqLPM2WRGnqUIFKdOrXJ4tM+pjTXu3LmD\n", + "7/sMBkuMRiOSNGZtY5Ov/dHXuXdwwHA80cZRvkecxGjuO5R5zvd/5lPcvn27+UyDUZpNcxGznM1m\n", + "zaIx52mOxSzOQFcalkgajw5jCBYEgbYxVWgLiLJEiXmvxbyPUfIuCsF0hpYv3EuJ47jN7+oJN4og\n", + "0MHFb7Wb12tlcjlNTB0AACAASURBVEan06IsSlpByGuvvsZzzz4HlsWp9VPkC453hiJnyXlAchyb\n", + "ssyRlt1seq+//joPPfQQB3t7fOITn2B3d5ft7W3297Vkfnd3l83NTU05rSqGw2Gjas6znMlkwmQy\n", + "4dFHH236P3P+9HwgyebmJnEcNxv717/xRyhVkecZtqMl9vc7bNtGOBZpujgIYt7LMkQG04C0bVvb\n", + "LQjxJ9gexlTPvH5xTZn+3KzOyM01M8+W8WNa7EmZ62wqY/OsmSzb/L9F/rdhsP3/HWr89izx/4yH\n", + "bbuUpWIWJWR5iZBSu6i5Ab4X4roBAos81zQx7WXgkKYZSZJSlCVV3ZCzpMR17KZccxwHS+pJ8kmc\n", + "MBqO9Jg2zyPwA5YGS41as9XWkmvf92mFQZ0dVc0CtywLp7bTVDUHu8j17MYkSUnTjCzLa/jDo9Vq\n", + "E4YhYRgQhCFe4OP5+o9SiizXczjzQo80s+25hwoIzV/O7m8nm2VZ07E35RbM6YqLWbnreeRlobG+\n", + "2khJURL4PmmSoMoKVVSEns+TTz7J/t4+oP2Qi7Ik7LQR0ua11y+zfzzEC9ukRYXveWxsbCCEYG1t\n", + "jaT2lJlMJmRZClTMZhOKImc4HDY0vOXlZW0+FceMx+OmC2/mnJZV0TA4UBW3bt0gSeImMIwnY1zP\n", + "pdUKmaYZB6Mxt27faeyItWukJI6meK5FK/B55gPva5rXxijNHIYRsFjRtFotgiBoaH6G4mUyZSFE\n", + "Y62Q5RmWbdFqhQSBTxD4hK1AM2nShCxPqaoSy9ZeM8aczbCsTIZmPq/dbjdZYBD4hGFQL2LjjV82\n", + "jI3pdFJbAxtFs1b6qlqxmNbahMlsRrvTpVJQLGTyVVU1tLXj4aE+T8tqAvbR0RHvfve7efnll3nq\n", + "qad45JFH8Gt/c0OL/eM//mMef/zxJhj+4R/+4QnSgGNr6GBzc5NnnnmGCxcucP78ea5du9Y8szoO\n", + "2M05dbvaP/727dv4QYBlzTNo8+/7rYksmw8VNkGziQN1lm02i6qq6Pf7dDqdxm/GBHtDfKiqiiiK\n", + "GI+15bTZ8MMwPEEV9n2/MQQ7Pj5uvot5D+ODZCiT5vzerLBcrMrSND0xk/fPLITy73/9N5BS0Ov2\n", + "6PW6TfllOzaqbkRaUmKVkrzIyHO9C/teGyEUeZE1zUXQZYyqrSRtDFOjBCHwAx+BOLFghTRUq7Qx\n", + "w3cch77X0dafC+VUVRohgFN3qevGYFmBKjVNSenxb/FsSl4UWLYO/GVZNBN9PM8BpfBczeJAgRM4\n", + "eop8vdN3u96JQLN4LJrWm3LbZAYm8wC9yZRVCWj8v2mo1NlXp6XLWulIcqX41Pd+Hy8+/yJVVVKU\n", + "OY5jNxx4v9Xi9cvXiOKUJx5/F88+8ySXXn6FtbU1tHDC5c6dO5w+vYUeX6Yhlv39fVZWVpqHcTKZ\n", + "NLYE3W6X3d3dZhNVStFutzjYP6i9JmyeeOKJxhq11W4znc4YjcZMplO++s3zZHnGZBo1CtKiKkjH\n", + "EbYUHOzv8d/99E+TphF5Xja2rr7vN6pdUwov6hEMvrm4+A2MYc6zoQDW2dRi2WsCxWI/Qkqpx9qJ\n", + "udf8HD+dT3s3C99x7Br+mw84MDTYJEkaqAdgPB7z8Y9/nP/0n75aY6ylHvgQtlBoBk5eaKWp1hwE\n", + "Jyo3g+tOpuNaQOdyamOdKJrx/PPP89xzz7G6utqwwkwj8OLFi3zsYx9jOp2yvr6uB1e021RV1Qx5\n", + "oNKsqv39fY6Pj3nPe97DwcEBCE0xPDjQ2a7nuhQ1tOF5HoOlJQ6OjomSBM/XIxPfDkrQvQyHoshO\n", + "iOFMlmzu9SJVt4Ggam8hkwkbDrlhhJlAvHjvFxuP5j4HtVGaec1ihWX+ezFgL2b5piowm1+jsF7g\n", + "mb/d8Y4F8NcuXaYo6tFDqqjFEBnSstja2uIDH3g/W5tb2NLFcXxarZDxeMx4kiCkQkqBIx1s29LE\n", + "+0oibIVlu9pMvlRYro0tZJMV2HVWUOQ5Ao0V54WR4etgnsRFc6NsW/s0zxdfRpFrtoKmn2k2TFVV\n", + "mnONHs6QZDozqDC7aMFsEjcNDQN55IX2eTAPlmmEyLcQLZgM0GSIJovU5zYPHkWZIy2pB1KkEVLo\n", + "QN/pdCiLQpf3lYIKfMchEYKf/e9/hr//v/8DQj8kLwvdLEPhBQFpnPDa65fp9Ppcu3aJj374I7Q7\n", + "fS1Lt2yyXNucmgkqVVVx+/Zt+v1lZrN4AeYxWUZOv79EWer7mOcloe8xHk84u7NDFMe4jk9RzoiT\n", + "TPtwDAYcHI34vd//Awi6XL12g96gi+c6TKba30QISOKYv/BjP8ry8oC4ts01C6KqqobWaXBZMyHG\n", + "lNvGE8csRpMBmXJ78Xen0ynT6fREVg0nMyrzelXpxei5NkpppoN5beVYqKrE9+YzU6WYe2Y4JrjX\n", + "G3aTSSP5nk9+D7//+79fBzFNnZtMpoRhC8fxODocsvPgtm4Av/5604PodDqNSM1kvpdqK9g4hulo\n", + "wuapDYbHxwR+QDzTU6f27t6j1+vhWPU5WTZ37tzh6aef5vLlyzz00EP6OtXzZpeWlohjbQi1vLKM\n", + "Au7s3qbdbhOGLcq8xLEVbs8jzXL+6I++yYWLr5FkORUFonbWfKu+0GJ/wGTbSqkmCTKZ/qI1q6qK\n", + "BkozQdhsogbSNdl1nCSEYdiYmB0dHdHv95tM3FR2eZ5zfHxcV9/hiY3BfIYJ6ELoST3mnAeDQRMb\n", + "DPXYqDL/NBz8HQvgD557GDNZfn9/XwdNR3sW3NrdZW9/nyzLWF/WirHNzU067U7DrZWWRAqwXRff\n", + "1/L2vExQKNqtdj2MARzbxvc8nFrxWSmF5TgUedxg31VZEc1S8jxDmukmRUmZ183VunqzhIWw5+rN\n", + "NNVNUyooVIklrSbj9DxPD0QVEjtsNzeyLAqqssS2bALfxvGCRtnleZoe9lbqK4O/LtrlLvLMzc8c\n", + "6Tb0RB1E9AY2ynONxUtLb0IIirJAeD6eLfmeT36CL3zh39JbGjQPe1VpnK/V7vDyhVc5vbHCN54/\n", + "zwfdgE6nzXA8w/VCwMLzXMbjCVmW81jNbOj3+1y/fl3PpByPSZKEfr9PVVVcvHiR97znPQAcDYe0\n", + "Oh2SpCCKMxQO02mMF3QYjmdcvHiJb3372wDcu7VLu9OFSg8IcG2HJJ7hSMHDD+3w6COPUJWl5mkr\n", + "tbAxzp3jtChprng1GZSxADXZt9mQFrMhkykZ+MMsZKMgXtQNmIzX/NuU42bBmvczY/XM50ZR1Nxn\n", + "bcbkNEpdc2RZiu06tNstxuMJluWTZTrYZVlOu9/n8tUrjCdjTp1a59FHH20qAJOhDofHgODo6IiV\n", + "lWWiaEq/32N1daUWDnUbeMNscltbW83z5jgOzz33HL/zO7/Dzs4Oly5dYmdnR9P46s0mDEOOjo4Y\n", + "Dof0Bn1anTZlUZIlaQMhZlmGJW12zj3Ey6+9SqvdJo6GJ6w17nf4vt9YNC/CiCZgL9q5msNw/402\n", + "Y7ER2VToC5CMMdgDmsx6cbSaSfY2NjaaoLwIgyx+rnkOWq3WCXvpLMsaqM4Y+Jnv8XbHOxbAn3n/\n", + "+2svD6kpPPWOeHx8zM2bN9nbu0s0m7C7ewPX9RgOj0Do4a+Oo8suQE9Otyw9BNmV5FmG69W7Y64z\n", + "ErfmfiIgDEKWl5YoshllWdDr93j0kUdZX19HOj6BH2gKXt0gzfOcPMnrstqu+eKaN17kOWmmZdKW\n", + "KZ2lA0pSVhVCSkoFZaohDcvS09P1iDMFZUWaz5pAUZYVSom3tJM1D4PJBIuiaCx1TelVlppTrwy0\n", + "I40oQSJYNMzXfGmhIE8S0izjg88+Q5JE/PqXfws/bCEtm1JVBK2QOEqwbYd7h0MKbH7zd7/CY48+\n", + "TL/XZXN9TfOds5TlpXUODvbodQfEabKgfJ0rzgxHd2VlpSkxv/CFf8dP/dRPcfnqdc7u7JDlBctr\n", + "G3zxi19kMou0z8l4Rp4XBK02ZZGj6ilEUlSoomSwtsxP/sRPkMQRvquhKCVkY4+wWI6a0to0ikzw\n", + "NRCKWdymGjPnba51FEXNxrnIdmiUtwtBwGT/juM0TV8tUguae7poombKcsPtN5myUemZcr8sS6bT\n", + "KTs7Z7l69bp2UhRGyZmSZQXHx0M+85nPcHR0eOI63Lp1C9u26XY7TYNbCFhdXeXKlSssLy/T6WhO\n", + "u/Gc/+Y3v8nOzk5TtQgh8HyP8XjM9vY2Uko+9KEP8fLLL9PrdBvcP45j+v1+MztWSonrOxRZznQ6\n", + "o9vtUlQl/UGPr33zG+RFQa/TZjo5bOCit1oTeZ5qRlg9YcdUUObamgC4yM8u8npY+YLM3WTIi9au\n", + "pgFq1qeBeRZhS6D53IYWK+c2s2ZzXjS6M8+H2WTM55jKIc/zxnr4z6yUPvQsfF/PlQwc7QncDhxO\n", + "rfZ58vFHCENdMklLcnh4xAsvvMTdvQOGxxPSPNeOTZaFNH9bFllVIN2QtChBVehJ3wWlUrh15jIc\n", + "RxyPZqR5hJSC8sZtvvat84gaP1eVwndd2q02YSvEqWctGp8F39dwThAGBPXN1L4LAsfR3iZl7fGN\n", + "YSgIWZdh2ig/CAI818X3HGwhmh3XcR0sSxLHs/teM5PpLe7ki0Y78zJTNZm85pvXDAr0pO+iLCmL\n", + "DFWWCAXScXEtSZVnfP+nP829e3s8f/4lLNvBcQOGQ+29kWc5wpLcvL3H2soSX/mDr7G1tUnnox/G\n", + "tl063QF79+7h2D5Zqq/BjRs32NjYaLIM40dSliVLS0uNH/V0FushyVmJsBz27+zz8oUL3N3XCsrX\n", + "Ll3RsnovQFRG7RhR5jlCQq/b4a/+lf+GIs/rmYvaxU4tZMKLwiyYK1vNYnoz/mjgqkXc2vxOEHgN\n", + "RGKCgG1LhDC0PDOsAYLApyznG64JGIv8fRO89YxEiWU52Pbc4dJ4dnie02ThnnTJi4qHHnyIa9du\n", + "aLhIaf/sotDnO5lFfOMb3+Ts9hn2J2OqSittt7e3m8adgeGklNy+fZszZ05TlvMJMp7ncXBwwEc/\n", + "+lEuXrzIbDbjoYce0jh6on3dZ7MZQRBw8eJFVlZWODo4bH5/MBgwHA7pdDrsHx8QeAGB5+M5Lr1e\n", + "n1u3dun2+9y6vcsLL76I32px7fpNlrouYRhqb5lO561jSRg2/iaLvQnbthu+/WIz0DQVTUA1393c\n", + "b/Paqqb+moRj0SfJvMZk7MbTafGzzDOzCLcsVnKLTV+zpk3FEUVRc/5vd7xzPHALbKXLTtuxqPIc\n", + "oSoENmWRMUl0hoynaW2ntlbxQo8kvUIySvWE+ULj3BWQZilFJXBdvXjLomgWVJoXpGntEGjbegis\n", + "J/UQ3KrEDgLc+uaXRYGQFpO0YpxM6htdNIvVlFxCKqpcDzrWN04RhgFSimYzyDNtSO95rjaxr7Sn\n", + "uYZ4bGRV0u+0WVoasLa2yubWpv65vH/H3WTbix1tmCu2DC9VVRW2VWfblkTUHfwsTxFYVGXZDGNG\n", + "KVSZE6cZluNwVOZ89rM/TNhu81u/83t0ehaqEsRxQq/fJ1daOHJwPMaxBLdv3+U//Idfp9tusdTv\n", + "4jsOH/3IhwGd8ezt7bG5udlwa43fTZZltNtthsMhRVHwwPaDpFnB9Zu3+PaLL6GE5M7duwxHI8oS\n", + "BksrJJmmuKmqIMkSqrJAKEWe5fy1v/HX8T2PKJriuz55rr0o8lo5ZxYf0GRQZgEBDbvCZNuLsIdZ\n", + "fIuCjMWgZ+7XIpd3kdJphueaRinQcI5Nw3ReLp9kHyyW+OYzTeAvKq1R2Nzc1H7mYYtZrDPvTqvN\n", + "vb09VpaXeeH8S3iuQ7/fxbZtHnjggZpG5zCb6cDX7/c5PDyshWSq4WUbX+pWq8XFixfpdDrcvXu3\n", + "YUEZvFcpbdB0fHzcGMyZCe+GvZIkCYP+gDRJmIwntFstiqLkzJkzJGnOV7/2NXq9HklRYjla7dxA\n", + "EdX91ckmay7L+f0098lcv8WjqioKNRdLNT97U2BdhNpMUI+iqAnYJhExfZJFV9JF+MW8x2Jj27iU\n", + "mntvBD+LzfFuVw/b+DObgZdZTJUJPbVaWbVDhFY25UWhHdNaLcb5jKqsGPS7bG5ssrV1msk04bWL\n", + "r3N3b4+s0FCB41pks4w801PsldAX13M9PFvj4ZasM9CqolACx2/hS4mZMSkqCcIBJNKWCLSHsJQ2\n", + "SAUSXNev5b4ltqN0ExTNTJkmOa6t5c1C6PPK84JZlDXlcJorJjMdiB1RcRtNW6xUqRuMAtbX14CP\n", + "/IlrdjQc43s+ti2oyhxVy+od22mwXtuxkYAldRZWllVjGlSVFQi98UkpkbYWmWgamdSzNPMKG8ln\n", + "/9wPkaYZX/3Dr9PtLaGQjCdTLCeg1+0ym01QSrK3f8DevYq1lWXGownxbKphkO1tds6dZjyNubd/\n", + "RFVpI7GD/X1WV1cpioJZdMj+wTHD0ZTJLOKf/x//J7bj0O50+fbzzzNYWkJKm/6gz6SerJ6kKaJM\n", + "tOVAVbLU7/D3/97PcXR4QBQntFpt4kjj7EmSUGblnA1SZ4SLAdLzvDk1s2GYCCxLS981RGfjOnrR\n", + "lUWFbdkIadeZ8SK0JZvSffEzmkaU0toE8zuGM6yDiT63Ss2tkg0+LKWeWamUwqmZUJaUZJFujG+d\n", + "3uLs2W1u3NzFdmw9GT7wqcqyCcb7h4c89OAO05luulZlyWQ6par7FEkck6UpD2zrhufW1iZZqp/b\n", + "q1evsrm5yfb2NnEcMRj0EUKwurrK/v4e/aUl3SD2PCbjMd1ul36v11Qc0rLwfY9Wu0WaZQR+wDSb\n", + "MJ1OCcKQvf09ZlHMrVu3iJIUNwgY9Po4MmU2ndLpdgmC8L5xxGDgjq21F0YGD8ZjX1dB5lrmxXze\n", + "JNBs2I1+wkAqC/j3IrvE3FttETAXgJnfg/lGbu6dqeBMZWDYRHktDBJSNGwkE8CNtfafWQxcusb0\n", + "xSGry9dZFBMEIaUQVJbFLM2wa1c937KgLFhqeSy3Ax47+53MZjPiNGE6jSnLkqhUDI+PGY4m7B8c\n", + "cHhwRFpEOK6vxzQ5Lrkpd11BpTKKvPYzsES9sEDYQp+TZeOGPqosa4Mbo5JSCLt2JrQF0prv+FWR\n", + "Iyot10cJhHS1paUSKAQVWiikhEBJi9iwRygppc7Udkf3b9j8y1/5MtTiECk0991zHXr9Pp7vaSsA\n", + "SyKp8GRJt9ul29XWqRunNlAo3BofNNztvf19Ov0W7TCgXYueJpMJk4N9PvWJ7+KRc4/wC//yl1BS\n", + "i66scsokj/W1cUOssEOpYH8Uc/doiueHHOcRV/ZeoX/pOp7n8dIbew3UVJUllnijgVSyLCOKIibR\n", + "RDdoiwh3MmPtzGksS+B7PqPREe0wJI6OyNKEwLGp8phnnnmGT37ykxweHmuIIi/ICz3+qjgeUhYF\n", + "rdA/EUxNsDULzODcVVXVDBFVVyjaq8MWNkJJyqwCJZFKojJFZSlKpZlMhuutF65q/q0w1ZhNVepR\n", + "X9IyakHt/SOEIs+zWsBREQYhRS3kqhQodKO92+s3lZbB4x3HoigzyjLlv/iRz/EPfu4f4ooA2wmI\n", + "s4xuu8Pd/QMee/Rh3rh8lfe/9/34XojnuNzd36Xb6RAOlgG4O5qyvLxONMuxbZ/pWCtz9/b32Nrc\n", + "JE0TUC62Zenxe5ZkOhkRBgFlXmBLTQkc9Ae6aXl8xPLyMo7jcG9vD0c52gs3LvFaPrnjkhYZcRaz\n", + "urXG7/7yF4jiKUtLqwyPRwS2S1nkBJ5Pyw849+DOfddEmVfY0tHy+LJE2n6T8WrKrzEwq1BSYLs2\n", + "sqhQUltKGEFPmmV6GIRS2jahKlF5hqhOPjuLWbJpUC/+bV5rmpJmfsAi1KmUAlViSeNfBHE0JUlT\n", + "PC9oAr+51293vGMBXM+QzBqQv93unOiy610uwvMcHMdlNotwXJdWq0WW5fNhvkIbtVcVrLoupzfW\n", + "UAp8L8BxPMbTKS++eJ6rV64xmkxAgR+EKCqKskJUtbVtpVWaruNCmRPY2sK2SDMsW2evQkocaZOU\n", + "uX5oHQfHcmozotpYCiOvNhM+JLawUfWiLspSbw6Og7WYvWHhOLKR1d/3mlUVlgLLdhFUxGlGmuWM\n", + "Zhpush0b23GgKsgTnbFJS5LECb7nEkUxrufWXPAeUkqOjg8RsvZpkZKN9VUeeeQRNjY3aXe6PPHu\n", + "x/ib/+PP8I9//p9SVSmlkNiORV6kHBwnDUPC9x2UskmyRDd2peTm7pHGBtV86rbJRsqi0KZGRUEU\n", + "x7TabXzfZ325r2eM5gkoSS4yHGlxZ/c2/X4H27IZHu7zkz/5kzz77LNEUcRoeEQY+gSexp/LPEVS\n", + "ISzBeDxsIJNFPq5pDBZF1iiCldAKTtuyqVRJluY19imbCq4otHLXcVzK0tbNdAVVWVMzgVIY62NZ\n", + "M5Nqy2RhfKJz5MJsTkNLTFM90EHKuYLPlO6L/YN5Gd9CqZI0y+n1unzw2ed4/oXzjMdjpLQYlWN8\n", + "32P31h1c2+Jf/9Iv8VN/6S9x9dp1VleWcF3NEtEQh0UY+Fi2w3g0Znl5hVdffZWtrS3abc3njiNt\n", + "mdtqd0mzHLvui0glcF2fLCvZ3t7h8PCQJNHDL+7evcfGxgZ37tzBXXVZWllmNBrhBQEqlURJzC/8\n", + "i89zcHDMyuoyBwd7dDo9ijLDlrqiWVpaYmfn/gF87mciamX23GVSCNGYe5VlCZkgK3JaNUVWWnOL\n", + "V2uhwSvrQG77LtS9C/PMLGoBGjhVzC1lLctqlKiGvTLvb9CobwPfPZGdO46DZdtUFc06eTN75n7H\n", + "OxbANSfbWfDyQEu5hWxoRaaBlOe173bT8NN2oOYCuLVQw7UthNDeI1WpqKqMfsvlo8+9n+/6yHNU\n", + "peLg8ICDoyPSrKgbPYqq0grE8Xjc/CkqDe9Y0tLUQgFCWKiqwBUK4WsRQEUBaFaKG3oaY66HtioB\n", + "WIoKDblIaSFtG8vg6VWlp25jgrjSJbvr3P+auR5lXmiGi1IgLf0ZQqGwyZQgy7Q3i+PqUr5UiqAX\n", + "EkcRlt9C2g6lUhyOJzqYCQeUIEo0H/fVi1e4uXubB7YfIE4ijkdjhG3T7/rc3dsnwWaWRvi+xvuz\n", + "PKGs5ja2rmM11q6+32nk5kIIoniGqoO5QiEdi3YY0Bv0UUpfi+FwiO1Y2Jb2cpklkVYcBh6T4ZgP\n", + "vO99/MCn/1uWl5ZJ4ykS2NpYYzKZIGqnwE7o14we1QhLzMIBmqBoRBSGrke96WZGfAEkWQwZOLZL\n", + "nmT1+DmPND05rNaytR8M9b2uygoqnUVrd0g9fX5OK9NBOAiChulRVVX9vEl9zdCL2bFt2q2WzvBq\n", + "jLcsS1SpvaxbYcg0Svjgcx/k1VcvIYRNmqTgCWzbZTiZsdTvo4TD//PFf8/HP/ZRLFsPhFCqYhJF\n", + "NWynmM3GeJ7D9Ws3WV/bwPcC7t07wHU8Do9HLK+usbKyRhxHNW+5RCkb23KxpEORV2RpwenNMwyH\n", + "QzbWt8jijEF3mdHRmMTT3vBZntPqDHjl4hvMopxur89wNKZCIURFp9uhSDXUcPr0adL0/pNpTDUi\n", + "JCg1H45uWRZZzZYxEAmA73lkNSVRqAW+fp43mD3UM3IXqInmZ4t4tgnoQLMJz2azhuNtzK/KN72P\n", + "4zgNF928L2jKs+sFTT/EQDZvG0ff9v/+ZzwWaW8aH/UJgrDxVjbkecOVNDuULkl8RqNx3ZX3USj2\n", + "9/dZ7rTrslTUWKOW4IZBgOtpXxCh2qwMWhSlzo4M7mX8DsyF8/2wYQ5MkhmT2ZQrV67y2sWLTKIZ\n", + "WJJW2EYJQVVBWc/irISF43pNs6usMwIHuUBZqnGyIicvMpCm8aJvx1v5H1RCOx8WeakN+anVY1Ig\n", + "1NxPQQibvFIIqb/bdJZgOz4tzydJEz1yzbVBgUCSFxWSimkcAZJZnPP8iy/RH/R48qn30Ov3Offw\n", + "w9zavc1v/P5XOX/+PHY0Y3VpmbRurDVd+lp1aNsWulwQNR9e1PYJdb9BirqBkzCZTPB9j263i20J\n", + "oqneXFRVIqqKJI6YTSb843/0jxgMBqTRMar29BYojg4PNRXNGAQpkOhyOS1OTlN6M05pgnuv19M2\n", + "u0KLOqgDaJ5nWJZNmtXe1R3tP1LkVbNJaD8S1TSzmlK7rn5tR1NPzSanMzLtsXN8fNwwJfR5zlWg\n", + "5hyNXYHjOBRZRpSmWlhkadqs7nUoVpaX6fd6XLl2A9f1Scmx7YJer8doMqXX7nBv/4g3rt7gyccf\n", + "w7ElZVmxtXUa39eDLVphyGQ8pV+Le7KiYDaN2Hr0NG9cucL/196Zxkp2XPf9V3XXXt4yb/bhUIsp\n", + "yrJkSaQo0atiy7Ei2fESBPCOwEgQJN8cIIBjy0AQ5Ivj2EicIHEMBIkMRXGU1ZZpx9BqRZAdSNbC\n", + "RbvEhBTFZYazvqW771K3Kh9OnXvvGw6Hjm1xRE8fkJh+/fp131tdderUOf/z/4cQ2Nzaoo2UqF3X\n", + "0VRtXwQGRFnLQ5mVPPHYE5w6dUpQXOWU8xfPM93YBJPx8P95hPe970NMpiWbmxv4DmazCUluuHDh\n", + "KU4eO8mJEyd58Ytf8qyR6IAEks20beV0riiiYoQ40XU+Rn1c29I/dphpmrJYLHqFL/E3Rd9DcC2a\n", + "REEK4y5L/cwx5LcoCtqm6n3OmKvn0mURzd7e3ub48ePP2pWtZm7k4Y2Esx8GCiAHfieE8DZjzA7w\n", + "X4AXA48CPxpCuBr/5m3A30JE/X4mhPC+67xv+N3//m8B21exlTNgf3+fyWTS37TubF3XRW5t4c5u\n", + "2yhCkNg+wst8R5qlVFWN8CUPquzxcwGJiNJs0g+8ojGcE06WNImipyZuNPLHdEiLbes6Hvvq4zz2\n", + "1cc5WK5YLpZUdUPTtjRtFx/LsSxNM0JQBrvQ5+RCQIqPnUw+4Rm2KO/Ff3z7bzzj+/jJv/N3yVOJ\n", + "zoMPKKrZB4EK+iARmsfQOXEIeSqSZkEjB/mDnr1NhA0yQQI1NcY7uq6B0B1qT267jjwvcIlQ4u7v\n", + "7bO7e1WigAYsOgAAIABJREFUxEwU0bMsI7UDi5/Jh3b0rpNGJ/ygN6gpAhC+ctA8Y+xm7BwWOHH0\n", + "KN/31rfgnaPMC7AdwYuGYZZlmETSG2mkZD26c0SkxFILiYkLpsFgYueuF7k5RR7pHDESRQt6SZzs\n", + "cPRd9QiCulphKOXrjGgbIp1wnCoxDSKMmLVbIsRUctpxTqGBtoev1XVDGr9b3Vg07aTBjhbU1Imk\n", + "kU8+TTNskkUJu4xf+ZV/xv5yRVW1bG1vM5kI50eWptLV6Vrufu2redkdL6GplhzdOUKRp7iuZT6b\n", + "ce7cebY3RO3oShSAyIqUz37uc3zzq78Z5xxPPPEEx48fBwxlXnLp8mU2NzaidqfhyPY2YNjf3+9h\n", + "eMYYTJ7w2GNP8NT5p/ngBz/E0eMnmEwn7O9fZVJmHDkyY7HYZz6bcPrEWe65554YicI33/09z1gT\n", + "n7//I7LR+fZQpO29nGv1dDWmoVDEmW74SqyWX5OrHiOmNPga4/R1g9UUivYB6HuPkTC6OWigY83Q\n", + "NCY+SfL1bTt0VOvnv/YNbyaE6/Pp3jACDyFUxpg3hRCWxpgU+ENjzHcCPwS8P4Twy8aYnwN+Hvh5\n", + "Y8wrgR8DXgncBnzAGPPyIIQlh2wymfWDoTepkld6vM3zHILl0sWnyIucNEtJkpaNjTl1vcLahCRL\n", + "hf0NMCHBJIasKCjsBFVeSVOp2vdbVRChVJvEhpbYtGMTQY80bROPQBOqSo/aGQFDdeBIspwzJ49x\n", + "9sxpmrYlYPv8m4u58raR1tpz587x9IULXHj6gshL5bl0bwIJgIEuNFgjatzGypH5emYNVNWSrCcA\n", + "Erw3gI2LM0QVeh8MIUaXWZZhs1wad6xEpxoh+BBYNTVBanQy6RLhg07yGRhhZCwVdoe0zW9uHWFr\n", + "a1uQDq6jbYRkbOWWEB2lWw0wvJ4cLDYQXVsQSmMXqywAUeWezeeYEGialvvu+z3auiJLErokMibG\n", + "MUmSJJJgCc3BZFriOheheylFUXL61EmKvODIzhHu+IY7KMuSK1dlvm1szGOEOKd1Nb6TQrHrhKPd\n", + "AKGDLMtpqprOdQRqjBFRDx952m0qqTSJ+GJwYGCzlJyoa1vSJCePEfZqWdFUNSEPZKkUCFVJSDcX\n", + "dRLaTaqRuixwR16IknvTNWAsKYaf+qmf5B3veCdN46TQv6rY2dmhiRzV21tbfOwTn+Spc0/xEz/+\n", + "I9TVitA58jThq199nCNHjhCMxySBNLNMZ0KM5lwtm7rSPk8Ecuh9S1lmVPWCo8e2uXDhIouloChm\n", + "8wkXLlzAB4F1FumULz38MA88+BDbR49RlCVXr15hNpswmWYcHCyYzUo2Nze5/eztUjg2aeT2eaZp\n", + "cbxxdR8Fa9qCEKTWFOeYnM4CVWybl1NSIimdWoQmxnhvdbDz2UzSGs5B/D685qjjHA7e42MzkDbr\n", + "aN1Fm4w0AjfGYBh4dDQH7lxHGmXhNP/9Z0ahhBBUlC2PPucK4sC/Kz7/DuB/IU78h4F3hRBa4FFj\n", + "zMPAvcBHr31fQyKQtnjk1qLftV1srvU9JCxNM/b29iSKijulJ1A3kb85WOxKothyMpEF4aQzTuhn\n", + "ZYGB6EYaa2WBWiL+OsJ2IqxnVVcR1kW/IAMZXdtIC3rMlfZQvAB5JpDCwqbMTh3jxWdO9Bws3nsu\n", + "XrzII488wrlz51mp8K+Z98UR/fd6tr0xoVpJoS20ArX0iICA805URRIRGvCtpG6K1OK7FqPV7A7q\n", + "yHme59KkNIlj7luJKBWZk9hMNrgkyEKy0LESB+cjpW8KttS0hDQvaTW+9nXvbEJMLyRm4I/oye07\n", + "Kc5mRR6Pk1l/OvBdR4tIqfkANhjaYPuIx1qDB9p+3AKrvQpl2GsuXSJJU86dv0DTtHg9xRnDkSNH\n", + "OH1KmBUPDvaZ5hM2NzeZTuUEOJtN2NzaYDqdMJtMaVuPtblALlHcMeRpRucc1bIe9A07JaMyrFZS\n", + "2ykLUUz3vsO1gi+eTmcYY4dOUNOvu36xa2pmHEWC4Pg752PhLsV1jqZuOLazzTd+453c/9BDwnpp\n", + "otqV90wmU3b398iznIcf+Qr//u3v4K1veTM7R7a5eOkis42tWGtpWK5WBOOpY+fiqVOnSBLLbDJj\n", + "f3+X1WpBmmZ458myhLYV0rJjx45y/vx5tvMdsixle+eI4Pmbht/77d/iS1/6MkePHcdYy8HBLuDZ\n", + "2tqgays25xsUZcqxnR1e+tI7+trFs+GhFwvBSudl3iOKNCL2IYjylh3mizrVcR9AX0uLUF8lchuf\n", + "HPoNIdIg6CahJ7S2bWli4KnR87hwqR24fUevE00DNXXurRv6PMYNZM9mz+nAjTA5fQq4A/j1EMJn\n", + "jTEnQwjn40vOAyfj4zMcdtaPI5H4M0x3JSCqm5heDUMB7lrIjNeBSSxnz55FeIKlkLNYLXsMdBIH\n", + "NslS9hcHdE4EBXDK52wEwhcCdSv41DQ6NmONSGpFUQhNq9g0xXSCUjeS4JUJYiI5k+/oOlkcUtjz\n", + "cYdPSNKEpl5B15JQ4F3H9nzKva+7SyZK4yARx57lGdPJlCtXpLHlX/7qM8fsjhed5sqVK6wWS1Yr\n", + "qXC3jTjJNM8oi5IueLxvSRPZmLS4kyQG57sYaQvTY2oEF24IgtrIE1Hyzg3WJtR1S/BQ5CK5Jrjg\n", + "BJuJYw8+9Dlt+Y4SYWWMTjs1yZAuiffQR5DdkEoJIZApjwwy5sTOgCzNJTURhE8dDElexkgrOjIr\n", + "fQRd5yXfbsEHS9dBVgjD3P6qocwKylKcN0G6cnd3H5YieS7SfCqEnKWppGmMZ2Njk8mkYHNzg+3t\n", + "LW47c4bbXnSGyXRCFnO/nYcsLyU9Y6SDL2DASColTVI6F6idbmqePDfU9eHmIde2mFG+V7DMvpfP\n", + "06akqqqwUU/T13JqoXO0bU2SWP7q97+F1WrJJz51PztHjwvkbyZScZPJhOVKmB53Fyv+22/9Dq98\n", + "xcs5dfIE3/iyl9E0FcZarly5wvHjxyR48YHJZEqaZLRNC8EwnUhh1UShZ3BkWUFVNSyWNUd2UroA\n", + "Jsn55Kce4rHHHmN3/4Djx49Tt8KUOJ9PKcsC1wiufzrZ5MW3385rX/MaXAdFMenFgq9nRSmbWhpP\n", + "NYc6Hhl4ZoiPnXMUkb9GA40kSWK9o2UymTCZTA515g61pUHGUKkR1DfNZjPmI5STIlDGNAjKdmiM\n", + "wZrQQwV1vRRFQesGWTU9hd3I/iQRuAfuMsZsAe81xrzpmt8HY8yNSqXX/d2/+vW3A3L8ves1r+Su\n", + "176qbxNeLpf9ZN2vhIb0ypUrbG5v9Q62bQVnubGx2Tc/tG3HfC6pmfl8hncdV6+oiKvIX+ED1liS\n", + "JCdJkyg6G6PG4MmyIjqS2KThO0KnajiiqakiuDphgvdUdUW9XGBTkbRKbEGSZVJZzoq+Qy1LMqp2\n", + "SQhQTApccFjr8Y3j6uqAjfkGTXN9Csnv/a7vILEJRZbjXEfrHMWk5JFHv8L/feRRLl+9wv7BPtVy\n", + "RfAOEJ3LvChYLiq6VvJz5UQccttW5GlCYqSZyRiLsa3wNHYdk8xgk4wQPGkSmE1K6moBIm8h6ao0\n", + "hVggdq2n7TqhyjVQ5tLaLwXJoTXbRAfqfSdKRQGC68jzRLq5YjcrKMQzgBfOGe89lRP0SJENGoME\n", + "sEkuTTjWoLGNjSe7IpWcdd10/YkgsZGjOy05OFiQlTlJXkCAqnMkkRXywtUDkoMF5y7t4tyjJOln\n", + "8K7CEDhz223cfdfdnDp5MnbAJuSZIJekEGrIkgRnXWR/sLFYHXrYoY6Jj2MhcUI81cRTSGqHHKtr\n", + "5CQjqAsvJ0aCcN6XBc7VpAR+5Ef+Oj50fOqBhyjLCft7LbP5nLoOlOWMg+WSNEnY3Njgw3/4vzlz\n", + "8jTGptx25jQGWFYti0WDMRJFlkXBaiU55Ukx42B3GVM7E7w3BJ8SvKWYlBw/foonnnqaxWLJe97/\n", + "XggiY7izc4yLl55mtjljmmekWcDQkOUZmzNpALrzZS/HNZ5Vo927z06rqgFB5wc9Sk1B6YY45oDJ\n", + "I30tMUrXKDmNr9cctiKUxtG0vr9wsGd9oOmcY3d3Nyp5DU1c3vs+hanSdEPNxVPEwnTfBZym2AQ+\n", + "/okH+PgnH/wToVBuWMR8xouN+YfACvjbwHeHEM4ZY04DHwohvMIY8/NxQv5SfP17gH8UQvjYNe8T\n", + "3vPu30RI6geKzs7LEVhpHYWhrIjV3Uza3uPN5rlEIdP5nP2DXUIIlIVUnPMYtRikmDQu+DnXxWhf\n", + "dm5No8hxyFMUeX8Ul0ngadrYdhuE40LSNYGmrWUzsCP+5jTFhbirB6WpzMhjq2xi0z4CrNsV2NBD\n", + "1nwQhsPEJtz7xh98xvh/5lMfJHQB34WolZgP+dckgcTQ+YBrG4xvyDNB6FR1y2OPP84TT56naVuq\n", + "umFxsCQY2Nna4czRY7SdFFq8BTB4A3v7e1ENqWF3f1c21koiRDmYGaHuNbYv5vm4qHwn95VnA1QU\n", + "JMohNkf4mAZT9AqGnstDH/cwLf20AB32UGSUWElb+c5z7TqvXYdlYIJTFsbgvdAbxFxmmqS4TDca\n", + "4eYxxuDqRjYpE3Ct6xEGqfHIcUbSTqJI34loSBEFGeJxez4tIQjVwtbWNvP5lNlsxomTJxAVnIFj\n", + "XKPEcRefbnzjln7nnGi7lgUhyIbqu4F4KxhDVTc4D7/7e7/Pgw89JMcxLJvbOyRpJrA/58jSTOia\n", + "r+6SGOFbOXnyKHd8wzfwile8QgiuHn6Y206dYrFYgBbY1AFF9NbTFyRd9eS5czzy6Fd49LGvihpU\n", + "lvYCzsE1YDpmGyWtq5hOcpqm4tTxU5w9c5Z77n49+JTQeTob+kgY4M5Xfesz1sQXH/qI3MNExlhP\n", + "gDpn9LGe+qy1kKcEH7A6H2HIaUfnnUdx8kbppu1h/nc9CY1JqopIAztO02itSdPD/SZhhhSZzk3x\n", + "gfTBq2LZv+WNP/inK2IaY44BLoRw1RgzAd4M/GPgPuCngX8a/313/JP7gP9kjPnnSOrkTuCPr/fe\n", + "EonEHGbMV9qkJEmG6vBkUpKl00gANHB+CIWnwnwOZGB8IE0MIlPWEjrJCyZJQhbTFHkuijyZTWhD\n", + "Qhs/R3ZsHzGtpt88+hb7JBUOjojmaJqGrnXkhfCFd52DzpPmGSYdlHy6LjCxA3/GtCgjxGnAHxvT\n", + "xZw/lOWUjdlcFsl1zDU1TdVSZBllllDmObVzNK4lGE+WlYIvxZOYgGtWJEnKtMi448Uv4uV33klR\n", + "TAgY2k5EbG0Af7CS00chAs/eeIKFqqmxqSErMmH/w5ClEx599FG+/OWHOXfuPFVds1hVBBKMEa4Z\n", + "Y8SxrxYrouJXPHKmZElCEkWEJbqJsmLSdkgwkFkL9nDHmxanEpuQR9X2mNEi0rXLQvGKuImRdlFi\n", + "rYy/Dfq6gDUJSWpIioSmrvHBsKrVcYJrOrAS2fWsdcCqEjKq3Iv4QpalEY0ios/4QNvBwUGFj6im\n", + "1bxgf2+X5WopdAnAxoZoVgphUmBzc4PJZCINVPM5J0+c4Mxtt7Fz5Ag7Ozvs7e2RJCmr1RLvRTfV\n", + "B+k36FyH9w4fN+HlckmSplzd2yPNcn7qJ34U7z2fevBBDJYrVy4ym2+R5xPyvMT7wJXLu5KTNZAk\n", + "GZ/73Bf5ymNP8Ad/8GGCDxw7usO33XsvJ06cYGM2Z7VY4B0sfMXjTzzBF7/4RR75ylfIilJSmrmU\n", + "zKazCU3bcf7CZVGrN4HJdMpiscv2zoyua3jR7WdJk4SX33knbdtS7S85cfwET+9e7BWVNO9/rSl0\n", + "r1L5NDMwbnadwG21qKgTpY0plgRFpUVfpLnziFIqy5J5vnFoDuprNUXSNE2fTlmtVr3z1tqY8sho\n", + "2kUdP6E7pL0pcNY2wp9Nz+L5bPfd++jngBG+GilS2vj/O0MIvxJhhP8VeBHPhBH+AgIjdMDfCyG8\n", + "9zrvG37/t3+jHzyIEawd+HjHFz7mTdZdUJENuruNcZ2aT9IdUB2yFjc0atMUyPXyTDoBdFcc58v6\n", + "QtVoRx7nc68F/+sXb2KOHejTMJ0bBInHkKR7vuMtz7imBz76gT4CU129QHdIVFWKLHmEq7m+lpDn\n", + "OU30plr1NsawWC7Iy3xIU+g4xuOhWugiYU85sK7pv3rvTSe0rJcvX6aqKpaNpHlc23JwcIDrOnav\n", + "XuVgsej5nauqEmFoW8Zx0/SCx9i0XwSa3/Yh0NWxOcOKmIe+RvUp9bo67/G4/nvr/FB0SpKk1zCU\n", + "G4TQDa+99vvVcde/z5Okl+AySRJx3kJqJvBD+npJaiTCk4ULrnNMJ1PquiKECFUNOq/Bd8LbLvPU\n", + "YAMcO3qUM6dOc2xnh9lsJnn11Eoj1NYWR49sybXHk0vb1mR5BgZa1+JNykf+6GN8+A//iEW1Islz\n", + "kqwgL6VjOcukBkAI4IX7XlMQNsoTXg9PHYInzeJJNxjapqOczMjyjKapwHQ0TcXm5oy2rdiaC6Sz\n", + "LEt85zlz+jR3vuxl3H72rAQ6TTs6gQwCFiEEXvW6Q9lbAD79iQ/GOSvzsCwlSFLMvfehryP0RGKT\n", + "vH88dH4j0QND+soY0/OV6Pc/rvnoOtcNvg2DdqpG3vpeY14Ta21f89HPUXphY0x//5q6ef23f/+f\n", + "LgIPIXwaeN11nr8MfO+z/M0vAr94o/fVix6rnFgrudqhNVYmy+XLl9nY2Oid+LUDr1+uOmrducbk\n", + "+sulAGmkCj/pd1GFLSrWVojwh4JHHyXbgXZUaSN1Q9DP0N14uVz2jUjq7PUaVG1Dd+v95VKEjuMR\n", + "dFy0vZ4pXlUn48bGRt8Fqbk6KW5ZibTDoPeoY6XXphvUbDYjmIBvHT5+JyEEFgcHfc4uz3PyLO8n\n", + "YTfaXNURr1YrbJqwsbnJ8ePHY0ST9/nIxUJa+zciVlhhccp69+gTT1FXFefPP83jTzzO7t4urm0i\n", + "U5ucgIxNKJIEXwjfubUBEAIjQ0qWiFyXa53UGPKM1osQtqAGhJzKAM41FGlClhjyvGBvb1cKjla4\n", + "3L1GUnG8k1Rk8HSeYWzfTSybg8dF3Upj0n5TTpKE4LTRI/KgBMOqqsnzkq5zUkL2gTTNSRJDyPKo\n", + "BIXg5ruOvf0lTz75IGWeRWrfJvKqREWoxDKbTjl2dEcoCU4d5+Spk+zs7JBPcgwJb33r9/Hyb3oV\n", + "//rXfo2mavDecPXKHrP5BvO50BQkxoozjgyWWZy/+/v7HDlyBPwgJaaanZ2v6TqtDQXapiJ4x2q1\n", + "pCgzygidzfMZu1cv9nTKx48d53V3383OkSPCpljKnN3e2qKuapLsucmc+jRavN6xIEddN31znDJN\n", + "6tpWBkBtRtK+kh6CGH2UBka6zlXnUmmB7SgQbJ3rifi6VGpBWaTGSIyhiIRceZHTua4X94aB4nbc\n", + "FKTXeiP7/8qB/3mZMSa8977/cMhZJ0lcPCPoFAxVeH2dLqCxkv2Y1a2HrY1er1H3+AjjYp5J30ML\n", + "HRrV688hhNgOfZhm9FpKUv0bVa221rJYLPovWBuWdCOS475ElXoNGuV3Xce3fvcPPGPcHvjoB4Bh\n", + "EzPGgPH9Y3XUwQecG04qep15jJ51UchmNqSwFKrmnIhkjNt5lSlNTwia+9QIQ78Pjxzrq6pikk8k\n", + "pRHvryjyWLSU3EdTN/142xGda55ntK2TfL6TnPtyueTqlas452lDx5XLV6RLzYg2adO2BCMbyWq1\n", + "kg16b4+9g4rpZMJqVcUClusjqSIvek4day2rCL3UzU2/17HCuJ5ecKG/t1gcGf4uPrbGCMS0c1J3\n", + "UfR6YNS4NWgiFoVwi7hOajBSX5H6QmolOrZW8P0+jrWJqUQ6ke6zsWCMhaZtMIllZ+cIs8kM4wNn\n", + "zt7O8RMn+P33vofzT18gzXO5fGvJEmmmy/JYzI1zTdOQ+l0rJ4ykKiDgoqCyAT+kIdq2Is8Tlqt9\n", + "vHdMJiVHt2Zsbm7y8jvv5JWvehUmyH22TUOeZRzsH/QINZsOsL+u63j169/8jDXx6U+8/xA8UAOK\n", + "IkI2lRd9DM0NSDdk50X0HIRwzMTx1s07jwVKddxd1/XSa7re9Nq0cWh8yrdm4ECxo/Xku446Bmvj\n", + "rlBtaNQNRP3Z3d/ylj9dBP61tOVySdd1vQhBFVMCGplpC6keRw4ODnoV6cVi0SufjLGaqiVnre13\n", + "4TFESyNdoG9fHjt3zZWtVqu+xXk2m2HtwJfRV63T9NBmoV/omLBJu7Xquu6J8/M87++5i4gWnVy6\n", + "GT0bDlxzbGOdvLwYRHT7jc+Ynnt6f184zbe2tqgamdzqkITIaEVZFn0UoZuhOnSdTFpY1o1VMKuD\n", + "gGsVtQO9cxgM8/mcbtVQFnl/ymmdE9Yn3bQtZImlamuM6cgt1HXFal+k7bI8h64Db8ht4MSxbWbT\n", + "WWzesriu6zlEtFt3/2AfFz9vUpY89eRFiqJguVriWkfd1IQAFy9eZH9/j6fPP83+/p445o0dDFKA\n", + "JQTSJBFkSjKXnDtSBG/bFptIbYDYbSn9BLZ3wILHj/C6xJJmwwnSWkteFv0mMS5K2jwnp5ACfKyv\n", + "+M7RdILCCa2Mn6g9BbwL1M6BD5KP74SStms70rwEA+cu7eLby8zLkiefvhRJkwzb2ztcvXp1SEHa\n", + "QLVc4YGkLA81tUgRdoo1BmftQL1rDNbGlFeQFNKqWpIYaF1N03jSRBq7sgTuuftu7rrrLgmaYlC0\n", + "WCyYllLkVMRYYizZRFODgaq6PsGbpKsGeDAwSkMEqqruGQE1yCgLWX+uc3FTFCRZQL5zvMe1LcEP\n", + "HDVjLngNDseyacaY/vo1764nbXXMWZbJyckOKk0qsafjrKkXubevY1V6ZVYb72bdqFilDklJ1Ofz\n", + "OWmasre318saaQ5Knc7Vq1ex1jKfzw85NF0kY5zohQsXeseWjHZHFRrQKNo5J3Jp0MOG+q4uhtyo\n", + "Dv5qtWI2m6EcGypArPe0Wq16jheFiPU/h4FP4Xr2bW96JjJlbWt7Idm/+fU/3/fT9TVOJGhgZ21C\n", + "nof+1Dnk701P1Tqfz2OrvIAc1DTwU1+iQZnCB1UQWaNway1FlmOCnAhb1+Gatm+H995TLVe9OHIW\n", + "WUG1nqYpWT3p3qg+N7ab5sA117RcLiNRVcTORlNHOZvN+qOItZb5bDa0FANNjG4Ta4XQKMKbuq4j\n", + "TZJ+F9X29KZt2NvbF7hXzId77/svVHdA5xzL5VIihUzyjrPZLKIABpXzPM9oGsGIz2YzNjc2Ygoi\n", + "jeiXwGw6o6oEEVLkOcTqt4uq20mWkubSzRdMjAzWtra1PaepOEKSqNMeI5cGB6s1N4mYh4LkuBtT\n", + "T+q6KYBobsoJS/R4pZGnIUkUciiIJ+c6vPM4Z0ZpFGkerOuKPBdIcpJI/ca1NdWq62lAmqaRGkQq\n", + "sOcOHzeCr1NBh7HKtNBxpn0BoiiKPgKuIrPY+KiuRxdFUmTpoBC+t7cnzjgeU5xzHN3ZOYRUOXb0\n", + "GCBHlOVy2Ufqe3t7PZHWODcakKaTxeKg16oD+t1bj1Dnzp1jPtsQXHAY8LxK7B5C6PHSmoPDSEt0\n", + "kgjHBwxV8LWtbW03Nj3dggpqdCMAQ9Kf0lX/Uxy0II806pX3OFw81E0gy5JDiJA0TSiKnLquyfMM\n", + "yPruTO0YlRM5vQNXkrI0FXZU6RdJSJJhAxHaj5ayHGoPLhZEb2Q3T5En7oxVVXH58mXSSKqvTlnp\n", + "GrsIhdOEvxYUdLfUL8hay6VLl3p+ZS1AFkXRR9J6VBkXLZXe8ciRI33eXPPXA/xsgAfNZrNDOeiB\n", + "kyOmcpynyIt+MmmOfVyYFYy5i9zHg8wX0LOfrW1ta3tuS9PsULOTrjXJUx9Ooeq6FbqBQcwYBlTb\n", + "GOU29heaPlH0SgihF15RdFpqD3Ot9A2K0UmPU7gmDHh1rS/pRiD3JcV9Rak86/3/+Q/pn8x0YHei\n", + "nl5d14JMaJrRUUfag4ui4MKFC4QgCtd69OnTLzH1sbOzQ1VV1HXNqVOnWC6XrFarPlWiOWzNO3Vd\n", + "1xc+VZG66zopxnltz29JRsUR/Tv9vfIbtG3LdDpleTAQ2uiXM0afKD5dmP1EFUR3eC10Durya1vb\n", + "2m5kuobVhyjwQPDaAg/Uda+BkwlQr0TTsm7aCBNMaKqmr5V519F2DWme9ClTLeqOi/kwIhfLIqgi\n", + "ClZXq6p/v851dG5oBFIfpoGoNC5O+tqZBoTPZTc1Ak+ShIODgz5lEBjQHYou8RG6s7293d+UKmVn\n", + "Ixiboi40BbK/vy/dj9EZA30hUYuNQJRoaw4NnDLl9YPLQISjiJfxJhNihX65XFJOJhDoo+i+Cyya\n", + "RgtpmrKqKlxdM5/PefDTn+Oeu1/T1wbu/9gH+pxeXdeURYHhcAONyHvR5/hAK/EGwoBhJY6rqtOP\n", + "j5oQyKylbupIKyCF27woqKpKFoP3Mjmdo0yyvhMty/OoNDT8nUYYNkmEewYlt6Ifj6pa9ZulKs+Y\n", + "oMRXArYzFj7+yYd43V2v7GsCPUontrR774V/IiJvNJpyneslslaLZX+s1fdQJIEuat1sXecJwZMX\n", + "BdYY2lZk6rz3VCupYZRRLLhrZH6Uk5JqVfXdeABtN6T8rBUKXSlUpz3kMc9zadu3pk+5YaSW0jcy\n", + "IRGaIURCpIoHH/o8b7jntYJDTiyNa7DGMinLiHtOpCPYGpL4/axib8Asn8hrTJSISxLKooiKUcKp\n", + "0gXBvDvX9WNWFiVZRMqM4XGaZ/Y+RB7+ijQTCb9ghB9dT7pVVdHUNUnk1Ff2vTGpHUBRloQgY1mt\n", + "Bl4SPXn3zjKuTecsi8WKj3/yfr7lDXfTNE3fyaxc/CAILu178DGvrGtY/IeM3/hELJQEvo+4q6rq\n", + "r0X9w7hRT1Ou+jrttxhDD4c1OpimS8at9eOi6Y3s5qnSx0i3rmuWy6XID42ctTGGg4MDyhEiQyE9\n", + "xpg+qlZnpovRWnsIvqfFCuAQ9FAVf9R5K5JFO6108PRvdTGqCrY+p85QP7upa1nofXV8OEppLk5h\n", + "SXkxwLTlAAAI6UlEQVSek3iZBH/88ft5wz139c0Fy+VSmmxCYDabsYyY8rEIQZqKGHLfeRidcmIT\n", + "0jQ/jA0PwvsxLtyE6DydFzIoTUcpvKksS3Z3d+WU4qUtOViRt1ssFmwmCU1sttnc3DzUQOW9p4gC\n", + "szYRyJhzTuhriwmhC9hg0Rq7D77nyfZRXegTn7yfe1//6kNH4Wq1IMsn1DGnqVGRnsS8gcSOAoJC\n", + "FmkXcdWegAuyuJq6oekck7IU6tQItV1Vckw21nKwWLJcLvsT3aXLV9jY2KDIpBnD1Q6V97PxCF3m\n", + "pZBoIYuzrWrh4zGW1CSUce5KcBC7i51oa6ZZhvcOFyW31ImmNmValnzm81/me9/0xp72OFiBhaZJ\n", + "wmQyjdd8QJrE1u44T+k8TZxDRSHcM8oyuVwu2N8/IC1KkjShnE5xXUueCNugJbC/txs3FYgsI/of\n", + "xsqmbEygc8pZ469xkIVAM83gOLUdXdeaJ1DVVR84+G6A6I07ofU5heoZY3jo01/gL7/pjb3DBKJu\n", + "6bD2VquVnPDT5NBmAESo75Ba0YANe7gHYuxPdB3qdTz55JOcOHGi9zNFUbC3t9cHC+pjdPPSDUDf\n", + "d9wcqA7/udKpN82BG2NYLBYURcHW1lY/CYv5nCbmmdJE+Ep6HGaa9oxfV65cYXNzs4+GNQVT1bUo\n", + "TEcstLWWVSWF0aKc9lSRAREHDiFIVOU9W1tH4kIzffRrTSdyaZ0IGaxWdXSCoc+RqTOdTqfYTPhY\n", + "Glf3jjvPcxZLKYoWE8G4ewKta3uayTaS7adpyqVLF8jznIODochio/KQ0sdqfr+Jx0YDTEcaos51\n", + "vUYkcKjFWCOGEOQaiiJHlWoC0ETcqqBsBItrMGRFSdt27B4sKMoJBzHyLCczFsuqH3PFjwea/p4A\n", + "bHQ2s3RGMFKB1wWZkOG8p6qldTkI3yFJKimnPDaHFEgXpTpu3SDVEYwXhJ4IjDH41pHHOkpmE+rl\n", + "Sr6zosRg2JzNn9HcZYwhm5ZszAq6dkWZW4psBnh8sCSZdGcqdn/c/OObgZQ/mUSRDSOR/6qVrtTU\n", + "ZgNKIo+RX2pxbSApZW5qe3awEKylcY5lREClNsUEQ5oWET3VkWWW6XRO13XMY7EuhIAzjrSMp9u4\n", + "/vYaoRIoN2aUG7M+xwswm86pqorFYsFysc98Pqd1VR9FpmnKweJAggwva3cMrQ0hCmrH/oDOeyZR\n", + "61W/F00VysY3+IUy6rmGbMTSSBRMifJ1485sDd60Bqbv07aL/u8FX27x3lG3owBGg5zQUUzyQ1Fy\n", + "MB6RZUx6HyRBWC38+77DE+giH9Hp06eBIRugVA263jRgHGcFxigY9QPjefRcgIabmkI51LUUj5zq\n", + "jPULriMuu2cnTIR0RtnDNPpVBz4ueGq060fdgPq8Oii9BqCPVsbdimmaktqBUF6du/6N5ql0Msi9\n", + "JaRpFI7whyMAN9qQ9EvURaPHP5X0Uny6pG4KQpCUj/Kg6L3rlz3uRtXgQusD2hh1+fJldnZ2sFa6\n", + "Gzc3t3BuSCNo5KBHSL12vY4QzKHvTsmTNE2hJyr97HEE1XW+b6lPUtOnRMbt/poz1HvslYP8wEsy\n", + "m036fKY6bL32wzAy34/HtS3ZWmsZY2214UKPy8YYTJQt0/vpP8umhzZDvfbx0Vr/pnZNhJAlfcHL\n", + "WkvX+j5iVLyw1nB0zqtp2nBc8NZ5p+tJf9a5NV5X13Yj61zVQEWP8fp6bfba3NzsP1dPtuNioX6m\n", + "jvUYLaZObNzNqn0OepKU9STcMXoP+l663sZpQ4XujhVvuq7rkVz6fWvqUeegUlmM0Wvj9amp0TGP\n", + "t5y23SHuI4jc4wyduSCw5y624+t4HfrdNVH7OO05dtjjNaPvcyO7aa30z/uHrm1ta1vbC9TCs7TS\n", + "3xQHvra1rW1ta/uz2437NNe2trWtbW1ft7Z24Gtb29rW9gK1592BG2Peaoz5gjHmy8aYn3u+P/9m\n", + "mTHm7caY88aYT4+e2zHGvN8Y8yVjzPuMMduj370tjtEXjDF/5eZc9dfWjDG3G2M+ZIz5rDHmM8aY\n", + "n4nP37LjYowpjTEfM8Y8YIz5nDHmn8Tnb9kxUTPGJMaY+40xvxt/vuXH5FAzytf6fyABHgZeAmTA\n", + "A8A3PZ/XcLP+B94I3A18evTcLwP/ID7+OeCX4uNXxrHJ4lg9DNibfQ9fgzE5BdwVH8+BLwLftB4X\n", + "pvHfFPgo8J23+pjEe/37wG8C98Wfb/kxeb4j8HuBh0MIj4YQWuA/Az/8PF/DTbEQwkeAK9c8/UOI\n", + "ZB3x378WH/8w8K4QQhtCeBSZgPc+H9f5fFoI4VwI4YH4+AD4PKKlequPixJgiLCkzJtbekyMMWeB\n", + "7wf+HUrneYuPCTz/KZTbgK+Ofn48Pner2skQwvn4+DxwMj4+g4yN2l/4cTLGvAQ5oXyMW3xcjDHW\n", + "GPMAcu8fCiF8llt8TIBfBX4WGCsc3Opj8rw78DVm8VksyNnvRuPzF3bsjDFz4H8gItj749/diuMS\n", + "QvAhhLuAs8BfMsa86Zrf31JjYoz5AeDpEML9DNH3IbvVxkTt+XbgTwC3j36+ncM75a1m540xpwCM\n", + "MaeBp+Pz147T2fjcXzgzxmSI835nCOHd8elbflwAQgi7wP8E7uHWHpNvB37IGPMI8C7ge4wx7+TW\n", + "HhPg+XfgnwDuNMa8xBiTAz8G3Pc8X8PXk90H/HR8/NPAu0fP/7gxJjfGvBS4E/jjm3B9X1Mz0kv8\n", + "74HPhRD+xehXt+y4GGOOKZrCGDMB3gzczy08JiGEXwgh3B5CeCnw48AfhBD+BrfwmPR2EyrJ34eg\n", + "DR4G3nazq7jP432/C3gSaJA6wN8EdoAPAF8C3gdsj17/C3GMvgC85WZf/9doTL4TyWk+gDip+4G3\n", + "3srjArwa+FQck4eAn43P37Jjcs34fBcDCuWWH5N1K/3a1ra2tb1Abd2Juba1rW1tL1BbO/C1rW1t\n", + "a3uB2tqBr21ta1vbC9TWDnxta1vb2l6gtnbga1vb2tb2ArW1A1/b2ta2theorR342ta2trW9QG3t\n", + "wNe2trWt7QVq/w/Uvjt8hhUJzgAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "source": [ - "This was an easy instance for bicycle as it was in the class's training set. However, the person result is a true detection since this was not in the set for that class.\n", - "\n", - "You should try out detection on an image of your own next!" - ] - }, + "output_type": "display_data" + } + ], + "source": [ + "# Find, print, and display the top detections: person and bicycle.\n", + "i = predictions_df['person'].argmax()\n", + "j = predictions_df['bicycle'].argmax()\n", + "\n", + "# Show top predictions for top detection.\n", + "f = pd.Series(df['prediction'].iloc[i], index=labels_df['name'])\n", + "print('Top detection:')\n", + "print(f.order(ascending=False)[:5])\n", + "print('')\n", + "\n", + "# Show top predictions for second-best detection.\n", + "f = pd.Series(df['prediction'].iloc[j], index=labels_df['name'])\n", + "print('Second-best detection:')\n", + "print(f.order(ascending=False)[:5])\n", + "\n", + "# Show top detection in red, second-best top detection in blue.\n", + "im = plt.imread('images/fish-bike.jpg')\n", + "plt.imshow(im)\n", + "currentAxis = plt.gca()\n", + "\n", + "det = df.iloc[i]\n", + "coords = (det['xmin'], det['ymin']), det['xmax'] - det['xmin'], det['ymax'] - det['ymin']\n", + "currentAxis.add_patch(plt.Rectangle(*coords, fill=False, edgecolor='r', linewidth=5))\n", + "\n", + "det = df.iloc[j]\n", + "coords = (det['xmin'], det['ymin']), det['xmax'] - det['xmin'], det['ymax'] - det['ymin']\n", + "currentAxis.add_patch(plt.Rectangle(*coords, fill=False, edgecolor='b', linewidth=5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's cool. Let's take all 'bicycle' detections and NMS them to get rid of overlapping windows." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def nms_detections(dets, overlap=0.3):\n", + " \"\"\"\n", + " Non-maximum suppression: Greedily select high-scoring detections and\n", + " skip detections that are significantly covered by a previously\n", + " selected detection.\n", + "\n", + " This version is translated from Matlab code by Tomasz Malisiewicz,\n", + " who sped up Pedro Felzenszwalb's code.\n", + "\n", + " Parameters\n", + " ----------\n", + " dets: ndarray\n", + " each row is ['xmin', 'ymin', 'xmax', 'ymax', 'score']\n", + " overlap: float\n", + " minimum overlap ratio (0.3 default)\n", + "\n", + " Output\n", + " ------\n", + " dets: ndarray\n", + " remaining after suppression.\n", + " \"\"\"\n", + " x1 = dets[:, 0]\n", + " y1 = dets[:, 1]\n", + " x2 = dets[:, 2]\n", + " y2 = dets[:, 3]\n", + " ind = np.argsort(dets[:, 4])\n", + "\n", + " w = x2 - x1\n", + " h = y2 - y1\n", + " area = (w * h).astype(float)\n", + "\n", + " pick = []\n", + " while len(ind) > 0:\n", + " i = ind[-1]\n", + " pick.append(i)\n", + " ind = ind[:-1]\n", + "\n", + " xx1 = np.maximum(x1[i], x1[ind])\n", + " yy1 = np.maximum(y1[i], y1[ind])\n", + " xx2 = np.minimum(x2[i], x2[ind])\n", + " yy2 = np.minimum(y2[i], y2[ind])\n", + "\n", + " w = np.maximum(0., xx2 - xx1)\n", + " h = np.maximum(0., yy2 - yy1)\n", + "\n", + " wh = w * h\n", + " o = wh / (area[i] + area[ind] - wh)\n", + "\n", + " ind = ind[np.nonzero(o <= overlap)[0]]\n", + "\n", + " return dets[pick, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "scores = predictions_df['bicycle']\n", + "windows = df[['xmin', 'ymin', 'xmax', 'ymax']].values\n", + "dets = np.hstack((windows, scores[:, np.newaxis]))\n", + "nms_dets = nms_detections(dets)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Show top 3 NMS'd detections for 'bicycle' in the image and note the gap between the top scoring box (red) and the remaining boxes." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "(Remove the temp directory to clean up, and we're done.)" + "name": "stdout", + "output_type": "stream", + "text": [ + "scores: [ 0.86610985 -0.70051557 -1.34796357]\n" ] }, { - "cell_type": "code", - "collapsed": false, - "input": [ - "!rm -rf _temp" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAXAAAAEACAYAAACqOy3+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvUmMZll23/e7wxu+KeaInKuys+aq7ibdraZE0oIgU4Qt\n", + "mrAsGISgrTfaWAa88tYbwzagnQEbhGUv5I1XNiBKIE3SNCi2SDfZbLC72TVmVWVV5RQZ8ze+9+7k\n", + "xb3vfV9ERTYJg8Vim3G6oyLjG95w371n+J9z/leEELiSK7mSK7mSnzyRX/YFXMmVXMmVXMn/N7lS\n", + "4FdyJVdyJT+hcqXAr+RKruRKfkLlSoFfyZVcyZX8hMqVAr+SK7mSK/kJlSsFfiVXciVX8hMqX4gC\n", + "F0L8B0KId4UQHwgh/ssv4hxXciVXciV/3UX8RdeBCyEU8B7w94BHwB8B/ziE8M5f6Imu5Equ5Er+\n", + "mssX4YH/DHA/hPAghGCA/w34B1/Aea7kSq7kSv5ayxehwG8Bn638/TC9diVXciVXciV/gfJFKPCr\n", + "3vwruZIruZK/BNFfwDEfAXdW/r5D9MI7EUJcKfkruZIruZI/p4QQxGWvfxEK/LvAK0KIu8Bj4B8B\n", + "//jih/7Hf/bfggSVZcyrikdPnlA1BqUUeZ7T6/WAQFUvCAGqRY1znqIokVKxWCwwxqCUJM8zpJLk\n", + "eY/JZMJgMCDPc6qqQmmFdY6madBZRqY1i6YGZ5FSopRCKQUhEEKgV5TUdY3wASEEzjmEkvgQQICz\n", + "Dq1zAIQQCCEIIcRjALmSeGfj4OqsC0eklHjvybIMIQXBe4QQIOJx/q/f+V3+3r/3dxECrHVIKRBC\n", + "xs8AAoESCqTAOocPHqk1TV2TKY2UEnxABghCYhBAIFMSrTVSSAIBaxs8AR8CQgrKskeeZWgh0SpD\n", + "BIltDMYYQhoTGywx2R0AEe+FgAeyLCPPc0IAvIcQEGlsnIcsywGBtRZjDQhJurR4zQhc8GkixnsN\n", + "aVz/9a//K37pl/4jfBpfIcD7gBQC7z0hBKSMYySlRErZXTNACAGfxtl7j0vXd/Fz7bP0nm5OAHjn\n", + "gYAQ8tx5AHyw3TnaedDK6rGFEBhr8d6nawYpl9fbXl97TS5ojAsoKVFa4J1DIAjBgwj81m/8Gr/8\n", + "y/8QZy0ej1DxOMa45XF8nLfe++48SkLwFmstQUAgzgchZDfyivg8AoEgQoqlJVIrpFRUVYVWOVIr\n", + "AhJrLc5aJPF6pVLdsxdiOQbtfTrnCFK0g3Ru7KUQCC7oKOGWY+o93otuXXTjHg/Av/y1/4N//+//\n", + "xyBCuhufnj/49Dv4eEsu+Hj4ACF4ggvd2Pm0YoUUSCXjnI53EZ97+lspjVi5LyEEjTXx20EQ4hXE\n", + "9eMDIRDHdWWOrP5ezkH/udf/h//6v+B58heuwEMIVgjxnwH/J6CA//myCpStQZ/K1KhcMxxssLu7\n", + "jbGWyWzG4fERk8kp0+kUX5uktKOC0QIIgVwrtJL4EB+yc475fIrzlsnkjI3NTcp+yXQ6xTmXFoin\n", + "MQ0iBIwzqKBQSiJFmqsBjGnw3qGlREpBQNC4Bh88eV6i8wwhAsZYsizDWo9SCmPj4pBljkiDb61B\n", + "yPQwhEZIcL6JikEAQUAyFN47nGvivBYB50WnGIQQSBTBC/CiW2zCBwZlD+8dwQeEiMrBA5lSZEpF\n", + "peEcQfqkfAJKy/hecHhvsLXF+GgkhBc469FKI4TEBx8Ng5IordE6Q+k4bYIQKK06heWtwzvXjaX3\n", + "jslkTAiBPC/IsyzeawCSEnPO4W3oFrn3HoQApYBACBZCWsDEBRSIikLKtICDx1mPF1EvRLsYFZH1\n", + "SbEJiVJL4+Gdj0qK5WcRYJ2hMXU3T1uF7tvnkRwhmQz36o9Yea0zvEKAUEilkApWdZT3Aech4BE+\n", + "jaFQacFbQlB471BSoKUgyzQQMM0CKQRaK1yweAd5pgGBc5a8KPFe4l1IBkMiggMpycoyKl7vEVLh\n", + "fKCNh0NwyUYLgmiNnE8Kz6K1xnuLaywIgZKSrMiQHqy10TiqeM3WRgOHgGCT0VKqU+CdkUsPTCQD\n", + "uaq4pHfd84mTPhrk4C2tW0MyQEqAVunTAjwCgsCrAEgIAudahUp0jkLAewFy5dl5n66F6Ih5nxyp\n", + "+BmtZVTG3qbjgkzrLlOKQOs4hLTEo3HyROPtfbxnJ2SyYfGzcc7E60pKgD8PGv1FeOCEEH4d+PUf\n", + "95m6msfFby0n4zPKfg+pFLvbG9y+eY26NkwmE9aKPkIIqqbm9PSM09Mz5tUCLTzWOwgBlZScRzKb\n", + "VWR5znh8inOOXq+HFIE8U9R1jXOOoijJe/2oPJzDBsi0Tp6GpF+WZFmWjMKcXpE88CBomgaIltJa\n", + "QVmWFHmPEAKz2YwAZHmGtZa6adBaYb0lS9kGKUAmr0kKTZeGEBKPwHvLijPXiULj5YqVFtGD8MF1\n", + "3pZKyiYg8I3Hy6TwnEcIyIosTdLoYYUQMN5Qu4AEpFBxUeoszh+RVKXKOk+uqmuoa4x3nedRFAVa\n", + "6+iNZwW5ztBas6hmrK+vo7XGGMNsNmM2m2OtRaksRiM6RkCmqc97xdYQgkOKgA8e70Ln0QQfjWY0\n", + "aq7zxtuf6K3HceoN+934hBCiBxoCWuu4ELuFI/AOtNadNxY/E2ia5nNe9mQyic8lRXDtOaOSW3r9\n", + "Ukpqmxb0ikGGGKEJ6c/dtxAy6qTgECKQaYUUILzl4OAZjx8/5Pf/7b/h5s0bbO/uMFpboygKpBTU\n", + "dcOgP6CqaqRQ0Zh72dkMqVT0HIVGeAdSUGhN8B68wFsXo4A2WknKsFVKxphuHsTo1OKcBR8jLGHj\n", + "2LfPqY16hIjKW0pHbSxKyG6+SJW8WA9KRuXVRbZ+DilSaM8r2+WSooWlx+qx1qRxXEY1UQ1KAjEq\n", + "gKiEpUjveYFk+Uyc9931uwA6qGX05AM+iKR4o/OVTh7XArJTu0KJ5GaQIt72PqMXHkQ8RAgCmSLL\n", + "EAJShPR6OL8eniNfiAL/84juFTTWsr4+ohwNUFphGoutGprG0dQVVDWT+YyiKFFac/v6Li/cuoZ1\n", + "nsl0ymyxwHlHVVVUdcOiabi+s4VLizrP+5TJe7fOMiwynHdkOkNlefpehXM2DqADBzQLn6Ccgl6v\n", + "QOaSvMjJ8yJO5MaxWFQYY1MoFRgNRmxubkTvXWeYpub07Iw8z6ibupuoIcSw13qPtwbnAlJIXnjx\n", + "BYz30WK3UEIIaKXwIeC8Q1hQOs3gAApBZU1UGnhUJqnt8ppEWsRCaYSApmlQmcY0hpAMibU2Kgml\n", + "Y9gXAkY4CA4pNIE0YZ1DoJb2JhChq+Q5W2tS9BJhoqhoHUrNl55VEJS9cmVBOLARpvDBpkWXJr33\n", + "3Lt7l6apusXVTmatMiDgnIEQw13VQRu+g3uECEynkw5q0Vqj1NKzPB/GClxc5tHjt4Ha1kuITEZY\n", + "pYVQ1tbXY6De3kua103T4LxHrih7v6JsQjqHEAJjms95ncZbkDJ6mSHQ1AtMXdHUCyaTMWvDHtPp\n", + "EQ8+OuPhw5KiLPEhMBwOCSGws7PH3rVrZFmJVjnON2hVRO9TKKxx+AAhQXLGtlBJQEqNALQKqBbq\n", + "IHRoh7XReWkNnpIRInTekymdIs2kwuLjRmqJTGNnvU9RRHxOdV11YyqEwEmHFhIhZVSqOl8qMqHi\n", + "z4rXHkJI8zPw6mtvpiikNfTRuSCIFOn46P0CQsrOyW2dPykSNOksJkVtSikEIjoaLQznXIqUlvBZ\n", + "jHxcjGbS33LF+IkQISYPKB2/55CdYYxzUHZGr4WxSMf6sXr0x777BcrHjz8jyzJOZmMA+kWPfq8P\n", + "PuCEJ0eCVKhMRY/EG4JTBBRaCnqFZmNjL4ZfQmGdjfhVgMViwWw2iwp6sWAxXVA3Df1eDxkC/UEP\n", + "nedU8xkyJJyzBcgIjEZDpJTMZvPkAcJsNiHP8uiFVlFR1bWhKHpkWc6cCfP5goAgy/IYpjpHXhZY\n", + "51FEuKGuLVJpjPMM+iOGw3VCcGxfu5bwRMF4fApEZTqrFgQfkscSMTrrTDQSxtAYQ14UNE1NKXtx\n", + "0UiQQeC8ZTFf0EuLPADeWnSRY53jdDxmtpixNhqwsb6OFJK6MagU7qm0eIVScfJbS3DRuInkhcTF\n", + "HDpFVtc1Ho81lqLQHbRDiNhlC2fpXHeKMyA63FmpaHQcnjfeeh3Z4s8roTd2iYH7EAguEFrPMPjo\n", + "UQoRz63ortE5E8fVe5zzKCUTvh2NlLcuYcLRoyJdl1IyGtt2ASdFoJJHq2SEZgQCpSVLnzeOj0R1\n", + "SswYkxa76xTCYDBgsVgwHA4pZcaTJ4959923mU2n1PWcItM09YL5dIrzBqUcY9OwqAz3XnoVpSTP\n", + "9p/gvOPDj97nhTt3uXnrDoPBiPX1LYxZ0BiPDkVcIwm6wvrOAIeQoq3WuImlJ6wS/CRbWMXHqAii\n", + "w+GlBC0gKSGICl4T56sQEROWXqDSOLdGVSkVx8M5vAPfKtTkbS/1dUAGn64pGkSBiPcjAi+//Foy\n", + "IHT5FZGUZBtNdvkL7/HBrUAcUbm2x5IyKmRrDYUuuntqlXc0utFULHMvdMbEe5eMkozwSQsBOkvw\n", + "KV8mUlTPMpcGEYqK+SOR4Mi/oh64zDKMD5weHTPo9Xn65Bl4z+72DlpogrUUWU7ei4m7osipTYMW\n", + "GZmKnnTdNAkL1bjgKcsC7x0b62tsrI2wxtJ6EEIIyqLg5OQEIQT90QZb6xvUdc3xyQl1VZFlOUII\n", + "8iKPnp0PTCdTdJmhZcScnTW4po5wynyOrWvKoiRbW2c+GeOFZHtnl+Al+/tPePL0EWVRcP3GDXpl\n", + "nxACo+GItbURp+MZH3/yAKUUg37Esgf9PqPRGk1T470jzzLqumYwHJDlmn6vz8GzA3xwSCXRQscE\n", + "bq8XJ6NSWO+oFhVKacp+iXUpTAeE1IwnM2bVgsYYZrOKpmlojGPQLwnWdUpJCJU8FYlQGm89WkaY\n", + "R2uNt5a68R1soJRCqITpKjDOdh4ynXKgU8ptWKqU6uAK71z0V5OHZb1F+NYzjwrRtUZBRG+K5NcG\n", + "mcJ9SIuWmLniXM4MAeRZVKrOOUwTDbJUOayE6xAXe1VVKaLLY7JNy3TPy+uAgHUO4SM23X43Lm6L\n", + "Cy7i8AlvJbTjmxG8oVdmzGZj/uT73+Wd937EYjan3y+xTUMIjjzTaCVRCqo6OhbT8Zgf/eD7jNbW\n", + "yMsc5yI8dHDwFOctvXLIK6/mFEWfvNBYH6jrGp1lCQMPOBtxb5ESm7TzJNmgqNxdxNQTHNLCWD7E\n", + "iMJrtUwCdjmApOyTtx4fAhAEOotJdQh45yM+joyQTMoZCiFQWXYOImnhE1hGQq2ClziWTz/FOcJH\n", + "bwaxVOYIVCZTAjMg0vX6FrqRkpR9wTrbGfLWOHRJ1GSA22hEKpXgFd/dezte7f1oJUHTRQbCr8zV\n", + "dDOqS5YLvBDJUD5fvjQFfv/9Dyl6PZqmYTQaolXGdDJHyjPKomR7cxOpNA8Pn0SvTQjyMmd9fS0d\n", + "QaB1jhQRjpjPa7Y3hkxnsy5pFbxHZzpl8UPE3ISgzHNMXTMaDCjzHNs0DPb22NraAkApyXg8TmFT\n", + "YLqYMZ3NqKoFRVEwunkLnWVdoubg2SGz+ZxBmSOUxixmFEXOy3df6LDf+fiM6dkJ8/mCkyxna2sL\n", + "62H/0SOGoyGboztRATlDbQ2Z1jQ2VsNsrY04m5xR14LJ2QnOxmqcpjH4ENg/OMKHgA2B0fo6w36P\n", + "PNcopaibhl7ZS1U0iul8wfHphP3DA1SmWRutEUIFIaQIyFMvqliJk6IJFywq+BhVJBenFAXBpaRj\n", + "8lh9UDifcChilUpMwEav1KcJGvBY53DOI4Uk03nEXFOC2rtwPoUjYqJNpaqcLkHWHr/DZJeQRrfA\n", + "V7L6sWKh+09U1FqS6xKtNVUTvezgo+fjUrKPELDGopToEkztAo0RQ5a8aUubkG6vyRjbXYsNKZkn\n", + "RIR9lKSua/K8QGvF2ekx999/l2o2ITjP+HQR4T3nyDIdYUVgbW3IjevXyYsa21iaukJryc72JmfT\n", + "MXW9YLGYMRmPqeuaO3fusr29h1YF5BqlJcZEOC9qpdbWWUjedUgVObGCJRrY9j4kJNjM4oLHqogH\n", + "hxDAtRFQi9+Kc/k4oSXe+qTYZZwPKamtRLaETFjiwMv8BV0ks+rpCyFonIuxXMoTCRkdBeEFISnR\n", + "VsFyrgolIHxyMkKsiIrPJqPsaUKzCtd4XMKp24jReUdjY1SV6UFKeEaD45OSjzpFdQUN1lqkkhEo\n", + "SZH/KozmkhUTIiZGf5z8hXOh/Hkk1oH/5Z/3Sq7kSv7/J//dP/vn2LBMBvuQIBrVwhuC4KMDETwI\n", + "5TssXaToXMtYKYSgKyVsK2iWSnl5fJdwcq2X0ZqxK2WF6RBt1BDzHynf4z2CWDXUetvRa/dLOMkv\n", + "S2T/m//qPyf8JdaBX8mVXMmV/KVJpgVSlF1y2gV37v3gBUGBCPG30j7W0ac6f4i14bFi1mPaSqU8\n", + "QzrdojC0ddxKZehMd4rWORuhJBert5RaltYCKccSOkMQ+07kitcd8N7SVkTpBEkBCcJ5vlwp8Cu5\n", + "kiv5iRalFDqYiNakogYv6Lxhn5LsLdYcXCw9DmrZLNc2UhkHqCVUJHTqlbDLBKZDdknY2EwkUmlu\n", + "0+HhwBL6iSB9PDfRk1eCzquHlGiHlOBe9h+IP4Pt5EqBX8mVXMlPtIiUs1it0xcsu2ZlCDghugSt\n", + "ajtx20+KpTeslUolqW1lSMARG7fa47cdtW1FDoBEYBP271bQ4VUvOwS6nJG4oJdX+wCUih67Mebc\n", + "PV0mVwr8Sq7kSn6iRYmAF21VSlhWrsQXEEAmJELLVLXEOYgDIKQqG6XOK0yJwKWW/q4WPP4FsFIl\n", + "E5AyX6FMWF7Hsg8idF3aQi1pOFYlJlqX19Ye43nypSvw//V/+e+x1jGbz6gWNXVVM1/MaWtw33zr\n", + "DQ4PD3j8+DGvv/46xhg+un+fP/zDP+K1V1/l3Xff51d+5R9x9+5d3n7/BwD0+316ecHe3t45CyZT\n", + "XWZs5xapXEp0SfLYCSVSV1RKdAiBDgafkgsQ6RHaz1jju+4+7z2Vd0zmc5xz1E3NcDhCCJjPFzjn\n", + "ePDgY27cuMFwMGQ8noCSVPMFIXhGgwGZVDz4+AF7u7vkWvPBB++jlGJttMbbP/oR6+vr9IqS8WTM\n", + "xvoGxliEVJycnvGzP/+3eXZwyMcff8CN7RGzyZgyyyJOB7z61a/x4cPH3HvtTf7wu98jz/o457l3\n", + "5xZnDx/zwrXrbN+8gRv2yAYjzLRGVg1FphjXYz47eMTdu9fJnMLZgNcZ0xA7WaUN9BFI7/GZZJEa\n", + "SAQB7yzO1rFxR8RGliCiJySz2LJvjKdQhsrDOGySDW7ip2N0dUjwNddu3aQUksXTJzDqU+QZtm7w\n", + "zuEFuOBwxOfXL3oUShOs41k16XDFWIsbS98aYxBSYV2gLPss6or7H/8Q53cJ+TbGV2TCc22Uk7uH\n", + "/PIvfpOjI8PJuMe08fRyhRSCpomlZlrHZo+6rkFEHg2V6teDEF2ZWqYz8J6mbgA4m0741V/9VRAC\n", + "6yz9PEMBxlqMc5GuINOJdiAqh5anpyh6HJ+c8sq9uwRnyZSkms944/U32N7ZwbrAxw8+xVjH3/y5\n", + "v82/862fQUnND3/4Q4bDIRDrjpVWWNt2m0aagTzvAUul1ZZ9tq+1a2cJW8Q11uqj1Trvtmon+ECp\n", + "lg1RQsiuEaj9Tvs7BMjk59XTP/mn/+nnXhPBR96S+FfnHbcQR+g6dT3CRQqB9hwQk5aC2LwUUj1/\n", + "52EHE2v5ZaqJV4mSISzr24OPa98CISVNfQix8Y3leJyrqFm551UlLqTuxnl1zJ8nX7oCHw4GOOfo\n", + "90qKosAZF2u+6xqlNcY7bt26xdbWFsPhEB8sZf46L730FTY2NnnzjTdwtmJ8dsTe3h77+/vM53OG\n", + "vX5Xv6sTd4dM5YVCtN2J7UNRqYKtrZUGJfWySN+JaDmTpvcp2SFl5JvwzkeehxDwsm2JX5azWe9Y\n", + "LBZYa8mLnMFggAc2d7YZn51hhwPef/99yqLAhIZrN6/hjGVWL9i5tsejh49YVBVfufdSbD4Bil5J\n", + "ALZ2d6mM4XQ+54OPP2Jnb4/eaMTO9VtIofjaG69xdnLCs6MDnj35jOODA/Zu3MA0DaYJuBD46MlD\n", + "5GLOWrNAVTNG22s8Oz1mejLl+mgTrSVf/+o34N2MtV6gEDmmEYSyR7NYkOuMzAVK5/DVAhToPCOo\n", + "IpakWYHTEIKjaWqCiCFo4y3B2Ggsix6Vd/jBGvefTmnmh5TeUpqGYa8kOMlGoXFrJU01RVaBTGly\n", + "HVu3vQCkwkuwOhCEw+PIMtU1ZRhjopelNVmRJ+w0LspcaO6++DK13eDh/oTgHVmZcTYZs1nCtDG8\n", + "88F9it4LiKLs6s+lbEvb0qKVbQ2ww7iGQEDJDIj8NEKpVD/tUUqzu7vDz//8z3H//oc0TU01HiNl\n", + "6kXwLnYHepe6hUkVDLFeuZnNGAyHPN1/hrUNa4Me62tr3Lp9m+OTU45Pzrhz+wXeu3+fN954i2vX\n", + "bzKdTNjY2EjOCl0pW0tApZRC6VjyVld158j0er3ULZvWT1v6lioFO4WePFMlYyIuOH9Occ2qRewz\n", + "0BpkbFZBtBQDsWtTahXX6ecKL55TuSY/n+wTgGvLTaN3lgyOOEdE1v6OG4nFqpTQfkdE50NJiQwy\n", + "dRZHiMM7v1TQMnLHyMRj0q79i8RUgQjRAAjv8Zz3tuPvZe34stPz+fKlK/DYTgxlkSGI3BwEiZYQ\n", + "vCErithAohXOW3KlGA6HbG5uYhvDq6++xHw+J8syyEZsbGzEm07eSp7nSy6LsBJihaU34dyS9a/N\n", + "IMdmvrbNdtnui4jt7LmSWBvQWbTWXeOJc12NKAisd2ReMer3Mc6xsb6O0ip5bTrWbGc5d+/coSgK\n", + "jo+OYmOJ85jG0DQNdRVrhV++9xL7+/t8eP8Dbt2+TVVVZL0SkWk2dza5fvsm167foNfvMTk+ApXz\n", + "e9/+A376a2+yNlyjcpbgPdPxhK3NTaazBqEkO3u7/PDx97j58otsvXCDP33nPSbzmldfe4M6wP6z\n", + "x0zslKdPHpLfGDI3grwYYZzn4OiI67fuMChL+s5BppB5DDtdEw2jVxnONbFNGUmWZyDbjH8syTqz\n", + "nrK/ztjlOCeog8A1DmcAIaieTTFbPYZZwVqpWMznBO9ZGENjDTLPkhKX1N6hUARjwbnkacVFqnQe\n", + "50p8BSUF1phEzLTJZObwziBEjQ+OIsvxcsDjZwtmjcRpQ5bB0ckMgURnGXlWYl3NbD5P1A0xkaUT\n", + "IZfwHm891jqci4ybzjusd9Sm4Rvf+AZlWfL48WP85jbeO2ofIwofYm02Pnl6AYz3NM5R5AW3b9xg\n", + "NOyzvb0FzjI+O+WH777LeDJlY32TZ8dHvPLq6+RlSV1bev1BciyiV4mI9dNlnmHb5hQpCDh0Hkmg\n", + "rLGEYJGSlblNqtl3BFxaA0svWIhIZtZ6xKQ1QiYxzkbGTSWJZfZRa7YNRCLxyqikniK+Hf91qWjI\n", + "xIX68LDsCSA5X0l/dx2Q7byI/3fpNZHmStQXWkT+IoKP0V5IkUNXFrjUEyoZVqFS2Uq6+rbzt60L\n", + "DyEq8tVa92RjsM6i5LLT+M+SL12Bt9wXzjmUEmgtaJo6egJS0tjY/qx0HDSTrJqpGwKO2Xwau5aC\n", + "wZklLaRMvyNxUuoUY6UdW15u2c7hYmlwLQJcy9TGsikhnadlUhOJA4HULi6VJNc5QkbvLMsUIRFK\n", + "eUCEwGB3r2urFkIw7PUhxMaYuqqRUnLj+nUCMByOGK6N2NjaYDQa8elnn6G1xnrPlhCMJ2eoPPKE\n", + "KF1wcvqYLO/x8YPP2Nre5sWvvMTu7bv84N0PIEh+6utfI88KDo/3KfolR7Mxn372KX0pcR72Hz2k\n", + "8oZgGz778B02y4IfPHmfQT7kb/3s3+FP73+MEYKDZ/tce/lVnn7wAUdPH3Lt1jXmzZwN1tne3qIs\n", + "SvL+gMViRm9ji9HaCKljO/3J8Snj6ZRdpykHQ373++9hzwQUigzHq7dfZGt7j/c++YzpmWX31iZZ\n", + "fciibnjy+Al3bt+KjRbWE5JHJ2WBqR3OOBSS/qDPxsZGIk+K8+rTTz9hPptDCJRlyfjkjP3jmtpq\n", + "vFuQFQ2z2Rk7117CLQJP9iuycoe8P8LJGWWvj5SRYmBuIjwkFCyaOU3TkOVZJOkyhkGeE5wjy3Ok\n", + "1Cyqito0OOcpix5SSoqiiAZZZbFa2Ec+Dyk0bRu59xFSQWksMFpfYzIdM56eUfRyemXBo/0nketG\n", + "Cgbra+w/PeAf/Ce/wqyqUZMpmxtr0ckgYsMSl4iVHFIuvVSwHVRA4vqIOT0RuzcTxBk6jzFGI0v4\n", + "UXRJu6i8IrwltYg11EqiyCIj5Ar84qWA4MCDS4V7su1IfI4zOpnP0CJbwZRDbB5LjKJStd2QLd3C\n", + "KpyR1rIgNexA13kJCQKLSl5IGRt9QkDpRC3ZWp0AwTkQkV7gXCMakZJLSIlWCXqDVJfuE1Feiv5J\n", + "kFMae/9nKPEvXYG3EoLD+ZalbwV7E61lP88GByHyY7fzDVgNPVbvu2tpTviWWMEk2++1/24z18vj\n", + "BJTKzj2Mc0o+TfguSPIOfKI+Xfm8SiQ+QoiuvThi8hFnVzIyIbZRmbWK4WCItTZGGy7Sge7s7vAK\n", + "r+C946VXXmKxqJAJEvjR2+9S9Po0VcOj+iFvvPUms9OT2ESsFY0PrG9usL29xWxRMz45osxytooS\n", + "XzUMi5w8BJR1bGxuUElBoxVfefFV3vmDCdP9Z9iiZnY05tOPPySTkmANp4fPeJhr3vnhn7AxKHnn\n", + "3SMe7j/k737zFxh6E+lHVY/aGvzCM6si78fG9hb90RrFYEBfjTg8PuXDH7xLs36LbDMnD4a9wZAX\n", + "br7I977/AVNVs7nR46XNDdSs4q2/+XOUZcH+wTOmTcOsrtFln8OjU/rlAC0yjqcThhs77OzdZjKZ\n", + "IITghRdfYHf3OmcnR9z/4APGJ8coIbi+u8NsZtDlgKDH9Hs36We7SL/NYnGKkhl5NsApQzWPc1Np\n", + "SVAB42ojtV96AAAgAElEQVSyQpMphWwytFJkKifLJNIDqMh1Uyhq05BlGUpHKGwymfCbv/1bAEzP\n", + "5qg8klAJAbmUSGNZL3o0i4p8OGQuAtnaiP39J6z1+oTgefDRR2ztbMZGFAG9QT92SQbLW199i2cH\n", + "J9RWcHx8TAiR7jVgGY1GOGepjUElQjNrHUKCDwZBwnzTvPTOJbbEONe1FBEqCgFBlhgxdeI48ZHh\n", + "cUkhSNAS4RKMIJKhEi23SNuBG7tBrbdApNGwjUM8R4EHQYKY/BJ2CG0NdoqcO0V9Xo/ItO6iB7zk\n", + "/m6/0jlpSR91kZBfNg45T8eQ2UUaK2t/NVkZcf/ILyMS50ykxY5ObJFFAi1oecz/imPgQZA42JeE\n", + "MElrJ4+2zQAT/duVbHNsm22VqV8Js1pXeQlthNCmKtJ5L7zfXc8FxR5f8915pRAxxGNpYVc/LwUd\n", + "dtcigvGKQnesFjp0yfLSHScS8MjEW+1D5CZemJqyLLsQK4TI6tbXPYajIVVdEYTitdde4eDgkN2t\n", + "TUotyZXm4EmJFILeoEd/Y43BaMTP7u4gQjQazaziw/c+5Nr6Bq+/eJccie6PyPMep4s5qpfhzk4w\n", + "0zN6hWJ44wb12YKDp0/YvnmHneEQKyTe1ty+dZ1Br+Tw7Ihv3ftZTKY5NHMKoZksGgKeUgpM0zCZ\n", + "OY5sRdMYVJax1fPUwWNFYFadsR4Kylxw/93vcXw2jSyLvZxnsyly0GO96DE7OuXmKy+z99ouc2M4\n", + "mk750/fu4xoQRU7Z69MXCp33mcwqqibimeOzCY8+e8Cr977CZPMIN5vSL3N8BmFRM+oP0eUIITIW\n", + "sxnHx0c8ePABzmrKwYi8Z6ib2EE3GpWsb/SZzU8hNOQ6YzAYsrG+xaA/4OysZjGv6fcHkWu65X0R\n", + "AqU1nz16yG/+xm9GaKRpGK6NMNagQgbOokzDRlbwxu0XKPKcDz77hPF0TO0rghdUxydkuWZ6Kjk6\n", + "eIrSisFgiHOGTz/5hLLocXx4hFSRt3tRNzS2iRTJxnJy+ozgPTIrUD5DKk2vV6Bz1XnPtjGARAmB\n", + "8ZEOlrACOYqsS7CSug2tNUT4oCXFSvt9WNnVVMt2Ta02viQcOSpEnSDNRDX1HG80rVJiFNBSK9Cx\n", + "D4b0v5j7EjjT+vYgnG3d7+VaTlE1gLVLAq24zFPiVop0/TISdCUKhqXubjmYAquOZYSV4nstZa/O\n", + "MmR6L6IFgSAkwtON0fPkS1fgWZ4RA4eWbpMuoSikRCSa0RaiaBWp7wamfbhLwqOW96LDsFNCpT0u\n", + "AOJyjoHWWz/n7fsARH7maJpFh19BnDqdFReksFCcU+zqglVuXw8rFtaHsEyIeY/DUZlY4VJPpyit\n", + "ojcTPNJF8qZqsUiKH8qiYG005PDwkL29LV66d4/jw2OaxkTyKmcRmeLOjWsREnIOJTW9tTVGm0N+\n", + "6q03aUzD+uYmJ2djbiE4PTrk8Wcfk/c0P/31nyZoxcP7D2gWNXdu7XFc12xdv8ZnDz4hzyNz38bO\n", + "Fru3bzKbNtQ2ElqdjmcIAnmWE7ynsA6TNtsoioLxfMHx4SmuCLzx1Xtk/YKjD9/h3u27nB49w9nA\n", + "7TsvsrWracaPOTg6QgCD/X3WNjegKPj+j97m48fP6PXXmdsx0+k+jw8ecu/eV+j3+xQ6kpJV0wl7\n", + "WxuYesHLd18kcxVvvfE6//uv/Qt6eoud3hYil3zy4Albm3c4tRX1/Bil15mfSh5++hQnFXt7m2SZ\n", + "g7MpZ2f7aOWpqwXWeL7x9b/BL/3iL5Kpkv2nxzw7OKSqKqaLislsTp7lLOqaf/Ptf8vZdAohIFXG\n", + "op5Hz14KhG/YG4342p0XceMZ28M+w1deQn72EQ9Ojxj2RrjaUWpNr19inWVna5tPPv2Mre1dmsqQ\n", + "y4wPP3iPu6+8iUOQ5RrvXWSx1JChQUBRlsxrS10vcMHh56ZrQ7dNZL8s87KdwCuOSMz7LOd1olEN\n", + "oSMoC6El9Yq82DIGznEHHyGpqnpJ2iQSdwigRUDiMcagxSU79iQRrk0EthzaRIcwcY+s7k6kpcb5\n", + "aJDaNRidOJ/YTJfeeoy+1bn12v4dISXVKXIhBMK1lMhLQipW6tFXd2VSSnbXK0Lc10CEtjv08+WF\n", + "z5MvXYHH8pykYH3yuoXsLHcLXsQssewUb8tBBzEDvJq9lVIiV+5/NWxq8a94rPOe9upnVz13JRLp\n", + "fwvjJNgmhOVnSMxkXshEnhPOKef2IbaGRLZbi8mVkiwfcdwYKQgckJfFyvWFmEzxsfW2aSxaqUSi\n", + "pADP1tYmw0GPIpMcHR/EhadLVC+n8S4ysalAcBalAgjH7ou3uHPzGqIxBA1zFVi7vYubVextrXF9\n", + "e8SL925Q2ZprG7uI2rG5ts763i57RYbIc3bW1pDGM68WHM8m9DbXuLZVxMlKTMh6axChNToqcnWr\n", + "DIVm5g3D9SFvvfU6JpfU1Sk3twds9zLWB7tMqDh68oyiGLJ/dsz+2TGjXp/HRwccNwtCliMGfSgK\n", + "Tpqa2WzCbDpHIXh2cMhsOmE0HDKfTNldH/G3vvUNbmzf4+DJI/74D7/D0f5jZmcP+dmf+RqnpzWP\n", + "Hz7i4YNHbHxtD+wcSUUv38DUmlADRaDXK8Fb6kXFoKe5eXOb3e0tjg5OCK7i8OkjBv11tra2WVtb\n", + "Z+/GDZ7sP+NHb7/NBx99zPvvf8DTp09jkt1H3um485Sglyu2d9a5NVxDmIY7O9vsP91n8/Z1CuEZ\n", + "FArhHKXSrPX65GVOIJBLxeZoxOT0hF5vyGI+41//2r/in/zTVzBOYKo5ZZljqimVqSHETU+sNZAq\n", + "TpqmotVibdIy+LgtISlobOuaAwJdxDlqrU0VM23XYiK9cpYslYviUoCNIDgX6XGlIJdFjEqdTQpO\n", + "obWMHPZCpF2sLlfgzaIh7+UdzGGtJcilIm132EFE+tm4BWDAOZ8iYd9BmqKFc3yM2H2Cc7oSStdW\n", + "4qStEx2d0lZpg5OLUX2bg4Ol89YmRmO0sXQC42f8EsJ5HvCf5EtX4LiYARZSdliZEKB16wUX0Zte\n", + "8YpXYY5lGc7So45lVuc93uV4RgXcJk8vlulIuaIs2zKxVK8a0sUJIvwRJ8d5z16uPkCxfF0lMvqQ\n", + "WNvcSga7fUZSKPDp4bZQkVsy73V3kDwMrfNoyd2S0tVbQ1kUcQyF7rwFCRRCxI0KJotunKR0CHPG\n", + "vK17b+JY+8ZEknslGeztMbp+HQhopdm9c4+mrrvxiK5wwvCaAZvsUPZ6MWvftjO3WfUUYnUtyKkK\n", + "wHqHlJqXX5gxr2u8g8W8Yjqb0tMzXnFjtq/toFSD6fVY395mMZ9zOp3S9x4BbOU5w1u7zBZz1l++\n", + "gdQaUWmCFDx6/AgvBceZ5Obt2wDMa8+nj4+Y2YIPPz2lsRs4NcSIMUenDTYUPH32jJPTCtgkyIKZ\n", + "ndAQEHqB9QvkIkDdMDmbsGt2OPpswunpHBcWnN6Z07u1zWQW+PCTx/z8xqts7W3Bg0PC8JD7+5/g\n", + "egFTGfpqiDIlLhPYsGAgFC8MelwvFLI2nEyPyHfXMMOC4d427sMjyn4f7TOub25wc2MNguFofMLm\n", + "zS1++NEDzhZjgixoDg753tt/wk9/8+sc7D9mPjukKDTWg9M5jYJqcsaoV5JnUNsKowUY6PmcPCuY\n", + "NwsqM6Ec9mjqhlxmCBM5vp2KVV513dDvDTB1g3eBqlqglKLo9Qgh7hnptEc6iUajpEobiwS8qBNP\n", + "OAgnwTqahNVrrdGZJi+yS1VIf3NA04xRIToDucgJElCOys/xElTQ1JVHk2NDE5OTwZNwCrRMRFcI\n", + "ZErAqiDIdA5S4XzcNxeR9ht1BuFT5J9yYE1PpGRn3L7N2Qip+CZ68lJFvmMfAqUVUYGLgPSSyN4Y\n", + "d+whCEJMlJ2v+rlEvnQFvkqS3llMsdIG2yrulTDtYvJx9XsXP9N+blUuWsjL5Nx3xNIOrrbnnk+G\n", + "nMeqLjvnZeeOcM/5z7YVKavjcFlN6DJkPf8Tj7EM+9ptwi56Aavnu3Dgrq7WJYL5VdFadxsztLuW\n", + "tK+315tnGU7Kz52rPe5FA5x5H7dZ0xkbIfFZ+EDdGPIi73ZvMaahGpbcunEjeluNiR5XrPtECIFx\n", + "lqqqmC3mmKnn9gt32Nx+Ax8CB8eHbGxuoqTik08/4vTsmI3NEYP+ABc0Tw8OqOYNWVbESgPhaZo6\n", + "Jh1FDOsFnrVshKwlg2GPk9MFkPHg00fUixn9ok9v0OPo4DHbO2u89+BT/uVv/A7Z5jqvv/V1nu2f\n", + "8t0/+D7To5r5wZSt/ggzXlDmyyaOYa/H1miNApBInh0+YXE65sZoiLeW9eGI2byi3y/oFRqtIBMZ\n", + "6/0+h7MpX33jNT58tM/h2Yxqfsrv/97/zdHhI67tbEeFqHNsUyFFfMb9Xg4hUDc2diwGj0TEbdRE\n", + "LIncGJZUpkKFWFVhnUPpHO/j/rBKCRpTEfBIHXn8Q4jjJ1OTjLMG68A6lbZ9A+EgiNRinjZskQiQ\n", + "cdcnIaMnbtOGHBdlUc2wtiIXcSOTCE0GbDA4bHSkhKDMC3JV4KxJu/YkrFuBbueji5scQ4zyrV/u\n", + "uQsxD9c6Z6sJzhDiPrneL8sR4z6sOpJrudhE1q7pdkN2KSIlbYsgCNFuNh3hl7/yScy226hVBm15\n", + "T6vYuxLAFQjiojJb7Vy6rKJkVSG277XNPatNBrAMGT/v4S/loqH4cdey5Kp252EUcb7W82LmevVz\n", + "Szjn89fRvraaFV8lkl895mon3apBWWKV58+7OjYXr6/F81pu7otj0TTNOe/hotH9nMFJYXVH/UZs\n", + "kop825KyGFJVFXmuWRvGxKw1cVf0LMvIdUZjDMaaWO7lo2clTaxyqJqaLM/RPRiPJ8yNQSFYW+8R\n", + "fMV8dsb1W9sY4zgdn3Fydszh4TOqakaWazIZUHj2djbY3tqIi9wHzMxSzRrq+ZxBr8B66K8PKIcl\n", + "+5NnPPnOUz46mDKpTugP+3z3j/+E3/2d/4eMdV6++zVC5ZkcPWNt2GMxO0OrjDzTbPYHlFlOqGuM\n", + "cQxGa5RZTr8o2RquMx5PUT3Bte0Ra4MSRUAL6Oc5a77k5OSEl27d4Otf3WJtY4e8KFjf2qTXGzCZ\n", + "zvE+dhxr58AbzMJi0ei8D9ajZWxAsiHukuOcw0wqMq1jN6OKTVLWGZQQLBZzhJBkWeQEsdZ00ZkP\n", + "FhnatRmDS+8M3ll0gv66vgwcTmh80ARnui5NgEwVXCbO1mS5JlhP01RIoVFKYEKNk3HfzuAacukw\n", + "vgER9+qUEnTizfchRnEIEEqgpUShqFP5pJSRp9v5uEmMlDolO2MeLoRAFgRCRkZC72J5oHQubp6c\n", + "cHoh465EKtPJc291Xcq9dU1JETVY5b6/TL50Bd56h3BeMbZyuXfpO4X4vPdDCN32RKuKpFU07Ya8\n", + "q+dYPedlnu9FpbhqGFoFeJmiunjui8ry4rEvU76r17N6/It8C6sJ2D9PlLFMyFws0zx/LasRhhCC\n", + "PM/PXd/F8Wif0cXPrB7r3Ni0O4ojuz0vs1xRyCxtpqBQg9je7VOzg+iVcTu14HHGoTNFXmQdn3Os\n", + "3rMorVF55MG4Ptjj2rVdlFLYxlDNF9SLBdWiAh3IVM5gMGI6nbOzs8X6xpDJZMxsPmdne4OXXn6F\n", + "6XTBJ08+wzaeejLntZdfZmO0xh9/948xjUGX67z81bco1no8OXjKrXub3PrKy3z797/Nxw8Omc0d\n", + "h0cnbGyUrO/eIWSSZ/ufMtoscWcz9obb9LMc2xgUYAm88vprPHx2yGJRsZjMKIWi6JdsDgsyLMJB\n", + "JgsyXeAyj3EB7R1nT5/wD//Dv8/9jz6KdeqzOaYBlIKgEd6graUschqXEdQAZ2qUc/jgWTQGEwKF\n", + "UhRK4hZxi7eqNnjlycsewURj3W6pJ5VMVH5po2IRG9q89bFsFpn4ueOzFCHg01YhaW8eBBYJaTOX\n", + "iGEvqtml8zhTntl8gZYZUkSPt64tXjiyIkYCzjmCa3C2IS8LPD72XxgLFiAgExwihOi2DPQidupm\n", + "WRYrWFzbZp/0R5ds8+RSp7kfcGlbQ5K3Hgmq0lrHI0XaDco2Xb5gWdfWOlbqc5H9RfnSFfhFqADO\n", + "L/ZVj7j1/JYcC5/3LC8ec1VBrb63qmxWkwyr20aterjtsVb/Xv1eey2XedIARVF037/Mm36edJUu\n", + "K0py9T6eZ1zaa7zseBcV7sWqm1XD0B6nfX9V2V8cn1UjApdHM8+7LxNbLmPhaNrhO4RAcOc3mPXO\n", + "ETR4J85RI2gtUalpyqVuQk9A5bGd34sY1vt0fSEEyBTr6yOyrU1msxmyyDCNYWtrl1defoWqWpDp\n", + "WCI5r+ZIoSiLAcenY154eZvxZMb8rCIXPT598IQ3v/kzTOcNZ/MZv/nt71MMS7wS7F7bZH//YyZn\n", + "ljzfQgjNxtoG0/ExAkEvG/Dinbs8O3jEje1tNvtDZIB5tUBkGllkHJyeIYucRdMwny7o5QV5Aev9\n", + "Eu0DmVBIHzHbrV5Ovz9kbg0//fWvYecT1socXfQZ74/5+OEBjfV85fYeL9y9TjU7Rumcjx4ec7Ro\n", + "kM5xbSig1yPrj5Ba44zBTaf0pEZ5RXAeIwXz2Yw1rWPEpRU6yzDO0jQmbpq9kouSou2GBtRy71AX\n", + "TCwuEHQ/QkRW1+A81rtoCJ6jyxbzKbrMCc7jfB3r9QuFcZGCIO4qFD3fPJOx2xto93JtczKxgCBF\n", + "nT4ST3kpYrQS4sbnzqbfqeM6QkdRjcaSQ5m6U1PbfNrpR8h2vcQkpc40UomU6lrurdlYgw9xV6fI\n", + "sXT5PbfypStwoPOIV3HV9oYuYkA/TnFdVGKX/b3qUf44xbIqq7DEquK5CIGsKvnnKdbnGaqL57vs\n", + "71Xl2MplhO+twrsMcrk4XpdFCZflEC564hfvY9UAXoyQnnfuc/9u3w9dNI0UkqaysR447VjSnoMQ\n", + "IokWoJRGBGhsot9MSkNqhXdxzPK8IC9yGmM6jHHQH2DqGiUk6+vreB1hm2Ze0+/32QzrGDtnPvGU\n", + "vTW8gzzvMegPKPoNQUgMGYY+L33Lczwx/E///F8wm1UEE2g+PQXveYf3UVpRzS3rwwnj0xnf+ua3\n", + "CAONNRWSNU5OnqHXAuu5oMw11jnmtsE5FblbZIXxnnll2NnZoarnKGkJjQGRQYJEMq3Js4y1Xo7L\n", + "BT/12ptMzILtjXVqp3FuwrXrd5BZwZ2bO+zu9agnmkdP9nl2eMIsjMiFZPcrtyk213l4csLR6Zgb\n", + "W5tsjbaYHTyjV/bxucWLQJHn3N3ZZTKZcDo+w1hDCJH2QukMQqwsgUjKhfeEIAkqVqUIEciFQiQP\n", + "3AlBEDpuvGxr8jxWlzgfW9kvk7IsaVIfSBAe62q89fhA3KPVK4SPe1xmOlVGKYVHdEnFiNXb2CkS\n", + "lrxJNsSNiLuCgNSwI6TEB0/jDMInGLG23Q72AM7LblNvIeWyQccBQial7tO2ey0aAVIt+XWW9ASX\n", + "y5euwFsvTWv9OajjMvz1IpTQvrbqAa6+f5nSeB4OC0uv9Hmy+p2Ln71IXrMaWawma1ePdZmX/Dwo\n", + "47LXVw3c55Kjl0Axl53nz1L0f9a1dR4ty+fT4urt8S8+l89dQ0cfsSzZJHjy1CcQUfFo3L1cblnV\n", + "XY0P3V9t05T3FuFU1zBhzII2qg0hYCob27RFXLBORM+/1+8BAek9eTFga2OUPCKfdguX4GpcgJCV\n", + "3P/sKb/17T/i7fsPmFeWQTlgMj1GWU8uFLrqo5VkJDyL4yNGWvPd3/8ttnd2kVqxtbvN1HjWdm4z\n", + "2/8Y5RsGhaaXZzglmJsm3a/EBkewnqIsyIVGBkGRF2RB01M9CJLttU2GGxts3trl9OiMWnmCUkwN\n", + "vP/hR0xsTm0djz/tM/o732SQZbz99vs8PVwQeoJmvuB+4Vi7fp0z2zCeznnt3it866tv8Ue/93so\n", + "KTl88oh3P/0UDzwaDtnb22P32h5BCA6PT/jow/usra1FQ7i+gWkaGuPplzmNSWWvUiGFRzoPwVHV\n", + "NSLLccJS9PpYV1E3dfJEPcUKbLcqSmuktQgRkFlGlmWRisJahNYEF9jb2mK9P2R8fIydz1BKUDeR\n", + "iTHypgQylRgr7ZLPSHgfu0tF5LdZ2AVZ6mVwLu4r2u4fqoqsq5ZrN4NGgnWeMisTJ1PEuat6luZr\n", + "wKXdeKhTkZaIG17/RCQxW3meN3oRL11V0qvvX0xUXualryqfNjmwahDapOll8uPw4edd/6rn3rXz\n", + "r0A6sd34817F8zzXyxTuxeu9zHBdvOeL710W5Tzveaxez0WYafUzz5PLqAqgVdjxX4GAWNmNuzte\n", + "937M/kPka47XlMLvEFKFQfytsuzzEZY4H9W44PFC0FQ1pDKy6IFBCJaz8YKyLMmyAmQeSfxHt/Eu\n", + "8Nu/+dt85zvf4/jkjOZkgqsbni5irXXVVOzefZFr/Rf47MEnVGZMPiqY1Gds3FrjbH7G7dv3OFtU\n", + "DLf3WCwqfJYRVKAhoEKkvTXGoRAEVDJkjhBkLLUNkrox9Ab9OBpBsrOzR280IDgwxjPzFUZAPtrg\n", + "b3zzG4hinXndsDaIxtH6wLxuIqQRPC995QXeePMeP3jvfR4dHLAwNd+ZVYyfPGZzMAClePTwCbku\n", + "CSIwnSx49dVtTk8mvPPeuxyfjrlx4wa3brzAydEJb//wPRbzBWWRc3z8jKzs8+/+wi/wwYcfcXS4\n", + "zzDLuHvnJtf39pjVFQ8PDljbFGyMepydndHvD6jmC8re8NI5ZYOOWDaRY2U2n2CtRxcl89mCemEY\n", + "lgNeuHGTF2/f+n+Ze+9gy5L7vu/TfdI9N7wcZt7k3dnZiN0FdhcZBIlMAQQl/UGVZNliWSrSIiVL\n", + "crmKtKtMy7IlymJZJVGUTZkumiAlywwimECRAAmABJGXi81p0k56YV6++cT2H336vr7nnftmIJJe\n", + "9tbsve/cc/p0+PW3f79f/wJ/+I2vA4paTZsIIgS97gDHdVGOdiB0Cs7XKegrTVOyPCPwPLIkLswb\n", + "/QMnIc8jFdqCRRTcu3S0VZbja3WeciDLU52U3HEt9e+BGtj1PaKCDjXT8ef8ENOUsk51krgPJaeY\n", + "SWI5B0cCVQDjT9jNJ3Gtk9pSBofxw77RL2PXx60zxt9vuMMqcCz/bb+vvGlVAbDnmek+DLBl3fzd\n", + "qHdMe6pUMGDb1DPS5dmS0kFdijwXo+/lw5xRHcI6LzH29IU6Rdv+a+coo28UAsgrNnDT19FoCBAQ\n", + "4CKQoGShq81AOIReAyEcBnGGEBm7ez2++s1LrN1Y5cWv/zHZTht3kPDkiVO0WnWGKmIgU4ZuhtcK\n", + "qM+e4G2PXuBLX/s9rm1cpjHts9e9Tc2pcfXqFe49cQ81JWkFDTpBg/Xbb7CyNAfSIY1iXM8jVwrX\n", + "lTqaofSQjiKOY/xaiNTnkQgBvuNx5doljq2cRNZDgvkZvNzTCX49n2R/j/3tHaSULM+cYndri8Gg\n", + "y+LSIqlqk5Ozs3GDF+kwP79Eoxmyt7vP3MwUge/x2d//HCrPqdUbzM4tsra2xtKxJZaWlviPv/M7\n", + "xEmKIx3WVzdwhc/m+m1cKTm5tEKeZniuQ7s/4MrVa/SHA5TSG+elV1/n/JmzfOu551nd2uLMfZDH\n", + "IXNzc0RRRC1sMYiqVSiDJGcqaNDt7pFlCYHvARlZppDCY3X1OnOtab761a+zsrxAoxGyvb0DQjKM\n", + "Ejy/RpbnKFHEegFyJ8cREkdmRFGC62jViOt55IX+W8uFbsFMCKTDCNCFI0Ho2PPavPBgTfuBjmVv\n", + "HP10qCdtZpimOsqhMUF0nGqcMuVPBOBCiDeANpABiVLq7UKIOeAXgTPAG8D3KaX2jqhj9GmL4lVi\n", + "/J3A1T7YLL4cAjnzaU7Nq0zryvUfcq1ncrD1SfXYKpfxA9FqbrV80DmJK65S4ZSvm5Jl1cBYtTEe\n", + "BeBHbWD2ofJ4O8fbWK7fwcWE5wRZ2AVb75UClHaocmURL0Kp0TPauMGoUMZ6XWwearQ5jjaBUhuk\n", + "0X06RSZzVYi0rkOcZNSaU/zYj/0TTp++l76c4qVvPctCUOfCY+fw+kOivX0ePXuWTGRcWr3OzqBN\n", + "mg6ZaSratzd578OP8PmdW7R395luTZHHAplJdtY2eOqxt3L98mVOnlih3b1NmikdXEo45FGK9D08\n", + "KZHKxXMkjtBOZkrkCEeAkyE9jyyPuXVjld3OPioMec9HP8rc8iKZVAhHcmJlRYfhHQwYRkP8mQZJ\n", + "K8R1XU4cP0nUi1COgEBCLnBzwdKJ46ycXCFKh4R1j3pYp93usr+xwcm5eZrNOmtrtxBCkWUJAu3E\n", + "0+t0GPb7LM4tMN2YZn9/j+Ggz87OLk6zQYqiHtaYCnxmfI+V5SU6e3vMzUyzevMG7omTzM8tcfrU\n", + "Cr3BkF6/X0mTb3nsSe5ZmGdrc431jRvc3rpN4Lj49SleeuUSm1t71J+Y4tzpk+xsbYDU9u21sI6Q\n", + "KVEU4dcCarWQTqdNnmZIR+vW0yTVUo+E4TAiigqfgCJUcOB5KAVRFBF4vnYnLIwbzNmOH9RGJrdR\n", + "FBWxlBTCKeLBCBM3hcL23SHLFEkaodSfrQ5cAd+plNqxrv0o8Dml1D8TQvxI8fePTqqgSr3x7RYz\n", + "WGUnEbNQq1QpYwuZat16FddtA9hRoF/Vn/IGY29YVX2yP8v1TnrvJLWG/Vu5n7Yuv7wZHlXK/TcA\n", + "XrbYqWpHuQ1SySKEQOHQIRgdNiphFOTmoFMwLmOZesc3H6VAChPkbNTqQo2VHB5TdD7DPC/sfLVR\n", + "MP3+gObUDGku+YH/6of4oy9/g6/84m9y8thxTi/Nkud98hp85yc/RNYbEuDwFz74UbbWN7l17Qb9\n", + "mwOUDOj3+jz4xEf4xsUXePbqZVS9STuO8IKA3/7653nXu97O7vY6K8dPMNjfwRUubhASq0ERpjin\n", + "UQvQ7su5TvqAwvEl/ahPHPUJnRonTi3z0COPc/32DvVWAxxJmqeoOEbmKYFQNJo+WdNnqBTSDzh2\n", + "7PZhAhkAACAASURBVBi+dAiEYLezz16W0PTqDNp9XOEy6HXY7ewyNd3EcRxO1peZqU8zHAxRjqDb\n", + "63D23Bm2tnfodvuEtRq1WsBUs6WDqm3cZn9/j9xNmV+YRQhFPQxJ+z2CRo2pVpNkOOTc6ZOst9vM\n", + "hjO0212ee+4FTp46zTCOWFxcrqSnr3/zW9QfewuNRo3F+UUuXr5IlGSELcWLL74MSnD16huE7jmi\n", + "aMgDFx4myxXdXo+wVieKE/b29ul0utTrIa2pFnmWaRt3VViTKMX8/Hxx6JkT1kLSNCWJU+Ik0Qep\n", + "UV+buxZRHYXhAKSO2hjUQoQCz3FJ/BxwyPN0tP5c1yXJdKYoWVi/KPVnn5W+jFSfBN5ffP8U8EWO\n", + "AHA4bGM89lkwqaL4z7pRiy5CX1W5GrXkqMO8SVx9mfMfB4JxULc51ipOuVwOq1YmSxZVFixHccTl\n", + "Osy95QPWo/T7VderdPP2u8rjUNXmKhWQ3Z6xQ878ALi1ktqhmF40tFLQAeQ2UUtQKi9iKx/Es9Z6\n", + "SO18YYDf/NMR6+w2aA4oCjqoxMFNA7zMw8UnFzm1mscwyXjptVf4yX/102xut/nuR97HvffcS9iq\n", + "c2NjjYXjx+gvLLAvd3jL2fN85cXn8Xb3aWY5F07VacxMsdvr4ePxgNsg76d8qbdGNu3DIGI293n2\n", + "+ZeRJDz14IPEvQGNsE7c22UY9xCBT6Kg5riQaSsfPwyLtGMecZ6xdO4cO+027/vod7Nw7DinpAuO\n", + "C7LIAlQETVK5CXGgo0PmuSKv5WRphkTQcmbwoghyCOemEAKaeY3F5RlOn1gu7PJdwkBnhUryVKcM\n", + "zDPOnVxkd2dXe2lKhySeYzgY0m63kYHDrfUhJ5dPM7+0yMVLl/A9l932Pl7g88zF18nrISvTU8zN\n", + "zxexVXKE47JUXyTNqtfA1VeusPra08zNzXPu/L1Eucvmzj7DtV3IM6RQ7OzdZnt/iuvXrvLUQ29h\n", + "Srls7/bZHQy5dGOVfpIwM7/IVCOlGWYszs9zbPkMTnOf5aUV1q6v029HJIOEmalpHn7wIU6eXCFT\n", + "OX/8zLM89+xzSNXXMf9dVx90IlC5YH7+ONMzS2SpZPP2PrOzC8ggYxgNcBzB5u1VfWYy7KJ6baTK\n", + "cD0JHiRxtfepKX8aHPjvCSEy4N8opX4GWFZKbRS/bwDV22ZRqmyw7WIDxVGAATooTWUjK7hmG6Cq\n", + "dLnlusvXqrj5qt/M+4/KsDFJ+jiKmz6qmN38qI2o/J7y96MkgLHDRyFGOUEn9d+Ucl5F8ymEKGKL\n", + "TZbC7D64spxrUIAz3jatHtO7vy2JlSUtfb+pN9BBkByJyHIyElSu4z3fWlvnp/7lv2bYz3nsgUc5\n", + "efoU++19BsmALI4JazVu3Vrl1MlTrJw9izsc4mxvQ6fD7e422WCAX6+zENZ58Phb+M6G4rnP/jr7\n", + "wwiVurhugJcLciEZRDHNVkvbpqcpzVYDJQWpEAwGAxwhCFyPJM0J6i7S8YiiiHvvf4CPPPAgvTim\n", + "lybaA1KafJrag9CMgU6Y4lR7yxaskk5Fl44sqJJEx9kxDnJK6YQDgePTbNRHY3zqxApJkozNxXA4\n", + "JIpiBj1t7+0HPo3Qp9fvs9du02w1yPKMjfV1er0es3OzLC8vsrx8rIiVHVMP6pW0UXMljqyTZpLN\n", + "jTbddsq1a5s6JC01Br0OG7e2mWnN0mousLm+wcb6Oi++8Dz9XCDCBo50GXR7LM4vMDU9zQMPPshs\n", + "q4U330VkDjeyjFdee42Z+jT7u/sszM/j+R61sEa93mRp+TiDZJdOp0PYahX5anU00cz36CQxt25s\n", + "cPbsfVy9eoMba9d52xNvI+oPWDh+FiFymnmC5wlQKRsbq0y1GrQ77YlrAv7kAP4epdSaEGIR+JwQ\n", + "4lX7R6WUEgcBu0vlHwLwc7/wEo8/+jCPP/ZwpYeetLjuMkjah32a46rWF5XBQghxWF/OYf2ufd1+\n", + "Z/mzDGjltsKBWV0ZwKoOAb+dMonjt61e7rQJTIq3YvehPNY2AJZVQUd9L28A5T5UjV/VnNj32ht/\n", + "WY1TNS6TpKh8qF3SHaGQbgak5EIQ1pr80x//CZzM48PveS/kDr1Bh0G/y+0r6yzOL3Dl+Rc4ceYs\n", + "G2+8wa+89Aqzgc+9y4vce+EcA+8ke902WZoRN2ZoNGf4K4/+Jd5Yv8nvfeNr9J2cnowRiYPnaa9D\n", + "13URmSAIaihS7fhSxARxXFcHL0MwTDPCUOKHdaZnZxGOQy2s6QPQVGHsiJ3igPdgc8sLVVI2NhZw\n", + "YANtxtjYNodheJh4hI5rnee5jldSWDoZUz5D70EQaLO7KUAIojhm6vw9CEenIFNoO/7z507pFG4C\n", + "7RbvSG2dkysGRTyccvnkd3+AWi0gqIU8/8LLbKxuM+wNEAj6gz6tRot+Z8DG6ib33XsPi8eX6cYR\n", + "F/p9UsejM4hIENze3GFz7Ra3b10n6u6ztbXJ2QenmZmaY3tjn8B1dJiD6Vm++c1v8OUvf4lTp09T\n", + "q9W5cuUKM8dnmVpYpt3rcfv6Lfr9AWfOnGWoMtqdHVQItTmPxXyWrurhN0OE7/Dp//jbKKV4/3d8\n", + "B889+y1EnrKxeovp6WkGg2q9vyl/IgBXSq0Vn5tCiE8Dbwc2hBDHlFLrQojjwO3qp/8hAH/z+3/1\n", + "EJdnihDac+tOnJ0pd3I7rQKk8d+rzdzK7v7lOu4GdO1FY0DM2K9XtXESCFb1qepaWW1zVJk0rmVg\n", + "LXtnlgGxav5M+4/qQ3mDLF8z77PbMQmEy/eamDdwOF5MuW1BOo2QMUoOyMWARCVkyiONY/7HH/tf\n", + "+N1f/xxhHlL3AtZ33mBj7RZ112O4t0WrNYszHCKkw8MPP8Dl116j5wieuXaZpC558IELvOWhR3j5\n", + "1Ve4vL7Oyl6dv/HO9/P0F36PYRiQ+D7z9Ra3Vm+xNlXjsfNn6Gz0SZJYx69WDsM0xfUChONr1QWK\n", + "JI5wVIO/8w/+PoM4IUoTpOuCEjiOPiuQSO3WWFIxlmnMHovMGitThsPh6ADPPpA3nLfv+4RhOMYg\n", + "2TST5zlxf0iWZ8RRrF3vk7g44NMSQ6vmUZtu4hUOPEmWEkXaXnsSCYmsR57FrK3e4o0rLzActlma\n", + "rxcHix553uf4sWk6+2u0mveyubvDqxdfYzCMmZlfIghrnDp1lvXbtzl37z10ux0cR7K3PEOc30Yl\n", + "MVNhSJ8eT3/ja7ztsbeytblJr98lSRMeevhRWq0WTbfJZ3/rc3z8E59gemWaer2uJSZHstZZY6rm\n", + "88df+yIPP/wQZ88ss7p6hYuvX+Sd73gbYdhASo/pmTl8P+Dc+UdoNJoIKfnMp//DxLXznwzgQog6\n", + "4CilOkKIBvAR4H8CfgP4G8D/Wnz+2lH12EGerLqBQm8rnUNAUtEWff0Oqgjz3b5m/yvfO0l9YNdb\n", + "rsf+rVzKruU2h2LXbW8Yh/pY0beqUuVpejcbzaRnbJAuO02V23fUWJfvN/+MSqv8jPk0dGJvGpP6\n", + "Zb8/rYimaPfFbpeLhxA5uSN1ICzpkqsanjPDa6+8TOi2iHf26bZX6WVbNFyYrvsk/SFxb5+1W9eQ\n", + "jSbPv/YSjWaT2zu3adZ8ht0O6y9d4Y3nLvKdH/su1HAAt/ap73f5x9//d/mBn/3nxG5I3wsI61oV\n", + "Mxs4tNyc6WaLwbCLUwuIen2UI0mLlF5hvUatEdKYnWW30yGoNyDPdEhStPfjKIMVBxY7piilxmjS\n", + "HqeyJ69SOo62WatGPw2MMSZJkoykv/J8SylxPR01sdkMSRKt3zXRLXNlg702LU2ShNiL0flHq89l\n", + "Al8Sp7vMzHh88ANPkWWKTqdLt9dje3ub4aDPcNjH8+eYmXZRLpy59yxJnNLvR2xubvP53/0Mx06c\n", + "YO3GFVKVce/5e6jVQ86dOE+/G7GXdjl3+hRnjp8iSWJ6vQ6d7j7LS0s6CXGWcfP1S5xdWuG1Z18k\n", + "iVNmZmbxPJed3S1m56eZnmny8LmzLE81cPJ9Vs6v8NiF03Q7faamZ8lyuPhih5mZFp32NrfeuPJn\n", + "6sizDHy6mCQX+HdKqc8KIZ4GfkkI8TcpzAiPqsT2UJwEUFXqiTIYAqMgRuVSZWFSdXBXfpe90CeB\n", + "XxnIDOGWB94GvjKHXAb+SklkwvhMmuA7WdWU6y//XrV5VT1f3nyr5suxzKqqxtEAiQ3IVaqlsgni\n", + "JPVVuW9Vm1GVdOI4CuUqlMhJlCBRHtJp8tWvvIhSIYEbsrl7hbSzhROk1DwXmcY4ZMRJn9PHL9AX\n", + "LutvXOFd99/HVL3OqWPH+Oq//3Xm77mXP/7Nz/L801/nHe9+kkdnV3jm5Rd58p3v4i889W5+88qL\n", + "DLKI5vQU6zeuMRhGrKwskmd9/tsf/RGWVk5wY22Nq29c5+rFS9q6JerjhCGPPfkkMwuL7LX3kY6L\n", + "4CBwks6EnmrLBuewpKu9AydbVZnxEkKMEoSPdOilWEBVND+yiy7uGxZqlrCmTetc1yWN49F6MOcb\n", + "QupnW63W6PkgqI5GuLQ8R5bX2d/rIBxBHCc0ajXIUpJ6nXtOnyIIfFzXxQ9cEuXSmp4GBSuez/3n\n", + "7yXPn6LdbePWfKI4Yre9z3QrZHluHjHn8eVrX+XSxWsszC9xzz33gDhGLdQhhtv7ezQbdZo1l2PL\n", + "x5menqXTHTA9M8fW1jaLnUVcD5577hkuXnqVOI1w0oR+b0AQBNTqDfbbPVqtGRzP52Z3j3anx3ve\n", + "8z6CIODnKntdzM23q3P90yhCFGmegS/87q+Ufxv725XeoQVdBsnRgpSHOW0j4h0FZFWgbd9bxWna\n", + "dd4JRMrvKNdVBqoqjnHSJnI36pWyBFFubxWY2WqJ8gZbVlfcaXMrSzX/qf0w91VZ2EwqZfA2bans\n", + "c+qQyYSg7jJIE7zaLF/6oxe48cYui60lrr/8PLvXX0WmbaYCncUm8F260YDm4iJzp04TLh3DrTUQ\n", + "SrAyv8jVV1/jEXeKG6+9xiNPPMoL117jxuYNHj57nreu3MMffPbzZPMzfObV53m5s0VrapatW2uc\n", + "Xp7lkXtP8cB9Z/nE93ycmJxcOgjh4EsX33GI0oiEHCkFaabt3Z0isYfJFgX6HKmwtTk0XneiV/ue\n", + "surqqOer5kWhdKZ5pUCpkRetNiMrIMGirZwilDSicM6Ct7/3Y4fe8/U/+gye8EdOXY7jkaYpcRRr\n", + "BhGlowGiY58nriJLUu1Cn2SFrbc2Ye0P+mTkOJ5Lb9Aj8ASeEyBwSWN9YD411eTcvedACLZ39njx\n", + "xVfo9oak7oBOr8/M1Dyu66OUQz1s0ul1iaIBrakGjWZINBwQxtpRaGdvl909HUOmN4i4duMGrelp\n", + "Ot2uTvxQq/Orv/yrKLMjl8qb7olpOK9Juz9qnEhs0awqsFPZXM9wAebvsvhfJToeasIEwLGBpMrZ\n", + "p3z/JO7Gbqv9vjIA28/czcIpg5ztvDTJCalcR9VGZb//TrFjyvVW/W1fq2qDzb3neY7njWdmsVUr\n", + "VaUcL8YETiuXVAxxHYf99gApa/zGr/0WjpzBzV3euHSJdNhjfmGanY1t+j1JrebRH0aEzQYLx5a4\n", + "fOsaj58+RSZgY20DN4XNjU3+eO8yywvzvHjtdVbOnuT0w/fyjWee5qkPvJ+/9tjf41/+xL/g1Mw8\n", + "nUCy2Ys4vnKSPO2zuHycj3zsu3F8D5FnKKGzl0dZqoNGCYWSaJWJMIfyAjgI/AVaMhVCGJ7prs5G\n", + "qjbaqg3cnqfynJSfEwh0+sTiGVGkEyz+p/Fbe0SiFMLVQcr05gNiwvwO4pjU5CUT4OUKkHieOwoQ\n", + "RWE2iu8z3azpiIF5jkpzslQHrMpVznTWIk5j0iylUdepCdMkx3FqZKleN2FYY39/hxwYDobMz83Q\n", + "amXE7HNy5RhSeqSpIooSWq0QoTIiR5AlOc1ak3rQoCECNjc3mZ5f4dQ9D9KPBrQ7XSKhbcjdRota\n", + "PWRvf//IeXrTARzGrTvKXKnKjtZ7j4GcOqyqsDl1W1dXZXlhxEQYTw4x6d5JLv13S9A2IJYXxFEL\n", + "yH7HUaqgKuA0/Sqbb9r1C3HYzNIeu6PUIVWlPG5V5Shdn71ZlqWIu+EGjQWQsbgobwCjDcpRpEnG\n", + "4uwxnvnmizSoEQYNXnr9Vbp7ezR8RVD3mFtcYv3mLo7ULu5nzp5jp9vFRbK1cZv7HnqM22u3CRt1\n", + "wqkptrdX6e9HLB07Rj+NOdFa4m/90A+zvrfL7c1VPv7X/yoyrPGf/YMfhtYsflij29njuedf5O/8\n", + "8A/S6e1r7z4pdYyNXCFzQIpCq30YTMtezXcDutZAohljfQhqXS6eHdWi682rGZwRJz2aWx04zKTR\n", + "G/l3SHEQnEwexLlRRTtQRdjtCRuP5/k4JAUjr8iy2DRP04SjzVeVvkCvnWj/Gim1dY4jka7AVSCd\n", + "kIbQERQdR2dkyjJQSkeqNPb0cRKT5Sl5njI9VSeOU8i0Z2WSZITNBgM5xFE5swtz7Lfb+H6ISKHb\n", + "HZDPNPBrTfb299jtrKEEDJMhcwtLOK5DphSe73Pi5Gl+efJMvfkAbttH2+BbFdDJ5rKMLs4UpRS+\n", + "61eCozsSKw8TcBkUq6xQqjiP8vU7AZRdbCAsu69Xcbl2e8t/3wn47DIp9Gy5zeYQyu6PvRF+O32t\n", + "uvcoDrzqWnnjLVuTVB2amWIkj3J/q1QEwnFpei0+/7tf4NXnLkLi0KjvUMt6uCEk8YAsqSFFE3fe\n", + "YW/Q56Hz52l3BmRJSkvWyLsRrVrI4tw8wyylNj3FFgnJoE/naof16zfYvnmbpeUTXHjoIT6/8Ucc\n", + "m5+h4Yd8/1/7z/l3v/1Zev0BQS1EKfjSl7/Mw489pPNXolAi0xldshyVC0zuVN3/g/gz43OvKKLF\n", + "VKrQyiVXapToFw5oMS3F1cc4SFWcPZXpebRuhdkU1GhHUEVyYaW0XfmoDil18gMERx3lOVI7zGjG\n", + "RAP/qHoh9AFooUASQuIkRVC5XAeoylXB/ee5zvOJJItTUJC7OZ4XkGUK1/VwXB3qN/A8pPQQClyn\n", + "RpJkMIzxPI8oGuqEzIEOXSscl5o7TZYphoNE56aN20zVJTWvxTCKcDwP6c7R6fZotppI16PT6ejU\n", + "dEeUNx3AbTvUsm4VDjjwqoOTcuyPqljbZTG8zJWXAeYoVYa5difucxKQ3O29R1nl2CobqAbwO4m/\n", + "R90/SbVk3lk1JncC8qPAwpTyIab9bFllc9RBcVXfzMZVNjcsz70Skjeu3ODLf/BVziyeZnZmmsuX\n", + "LtLrt5lfmMV1BYNBTM2v48/VWaifYJjGiCSl7gbEaU7aHRC3e9y8cRMZ+PSjIe39bfJej7pfJx4q\n", + "Bjd3WH9jjb/1j/4H3vOhD3FzY53XX3qVxx55lM9+5Rl2ox5imHHm3L3s7bfxvIBhMtCJtNHcqpTa\n", + "AQlDj0XIXARkKrP6qdUsUkgccdhppzKcMeigXhX3ltVpRp89qZh16bquBkTDRNhryrEsZex6RW4i\n", + "aGtz4gnv0PFXQpIs17FIlBq7N5dFmIaiS0GR7ENISS6Uzu+Z5zp6IBJXCIQXIBEM8ggpnFEskyxL\n", + "yVVCmuqEyCrNkWIISuI6ddIsA88jc8DxAzKlQxS3pqfJUpiRLmmmkEnnYNyKoFqDYcRic07nga15\n", + "zPgzpBXSjV3edACH8cBOQui5NUl5ZTHxqcrJkoPMFSMRryAgRwoyEYwGRYiDe1SuRocgchRTg+K+\n", + "MlnYqhmzwE21xt3brkMwXoXt1VlwGpjnlXWPrjfLxtMpmfukPGhHGXAmnQOUgW8SUI1aOgL1gz6a\n", + "tuj36u/6U3M1smIVGc+9Q0WOe7getYkoVd4w1IgGDpaubkt58z26uFBkH9f0YMRgfSClQUmCkNRE\n", + "iy//zi9zfGqZWliHuiTP2zToISOJrE+xN0yYwef0/fezON3g4tNfo+VJVNQn7Q/pbm9x5emnqQ9j\n", + "4r02c4FHJxPMhC3qjkdreZqkOyTe3+bf/Pg/4b/47/8bGkFAf2ONjWGfpePzzKaz3Lp5iUcef4S3\n", + "PvEWsjzDx9GxMYo+6HEt5qvgXJUBLnEwxkqh084JRSaqzfAmSXqj68o4R4kDPbowduW67qpSxYGP\n", + "zXDR9hGzxjitj77faYaFMzKTzJVWz0hLFaNJV4d6zZUiLtKgKXOsK8BRFJJERpYXK1cIvCLbjuNp\n", + "BkPH5wmK9ZJrBBUCgSROEozGPo5TKPT5UuqQv0rpjVEIgYcOaeC4LqBwfYfpcAqloGHhx53OK950\n", + "AB9XG5irBwt+XGzTP+Wq2PmkRBTP5UqSF3altrgthNaxoTQgZCYdkusipBiJnLbId0DQRk1hA7Ju\n", + "n5EIzPtGLZ8AllVR+A7eeXhcMiuDteZO85EdbNk5ogqY7X/2u8pjj2UrbFdj5uMAxIsNlcPSEiP7\n", + "hvFiw/pRsWBAp6MaX6oHG2T52iTn3qqN4cB0WKepMplfHM9BSgeUJE0zPNfjl/7tL7K5tsWplbN0\n", + "+30uXX2VmcDFyQQq6iNqoXZjbzY4u3Scy6+8wM6tW+ROhp/HOtpj7ugATZ5PmqYErk8uHTr7Heqt\n", + "FoHv8tgTjyH2E67v7fDFX/k13vXBD1Hb6+IEglbg0c6GrBxf5ud/4VN87yf/H7a2buN7PkqJIo6X\n", + "IlcH6g2tILFGqawmOoKJq3LEGqkSx9ZCUc8EVZ55rymTrLTG5qjgGIS5tyT9jZ6Z3HzzNlxHe5se\n", + "Uh0ZLFAKJXWatBHVmvpzdZgmhebSpaV2Au2lqvXs9pmQjvMtOIjz73vuqA/GlNJeL2mOjjhZJERO\n", + "kuRQEpS7KX8uANx0unK3GQEHo8GQUhY7lxbJVJZDlusAMJglrzktiUCKg7qVVAdxo61JK6dHs0X2\n", + "srODLcLbAGmuVRH1pAmp4qbLnLR2RjlssneU7r28GVWpRPT1ymZNbIsjDvdlUt9sfeadrFWkpABn\n", + "eyOtvrfqdZP6pxWfEi096dCd5PrgLYoifD8kiTJuXr/G5q0t5ldOsB8N8HJwewn9tMvsTEiaJMR7\n", + "bd75+HupL53k5osvsP76Szi9rk6c7DnU/IA8h86wzdLyWXZu95ibn2JqeV7TbpyyvbrOpV7EW08/\n", + "wIlwilR4bL78CnNuwKf/319hb3aG65097rvvNE8+8VaG0YBGIyRNCzWQcFBCx3mRQo5c3ieBZPla\n", + "+b5JYRCq5kuV5rM8/vb6qUpoPUnNaX6zP7+dYoeMMN9tyzN7Q7DXxaQ1Y0sM5no5F2wVdlSpdu0+\n", + "jvuBaM9V87vv+4eeuxsQf9MB3Oi0D4BKjDl+SClH4G0G1uRcHA1moUOLRuEcPaSQOu2R0oHvXc8d\n", + "uQHr7NKHPf9gHAjK74QDr7Esy6jVamOTDhN0itZkVwGqed4EhbL1/Qe/54ZhGSuTwNRwqXfa0fUY\n", + "H140VeoXIQSo/BARTyQ0Ne6uXq6z3I6JIFxx790Wx5VoFC/mReivKoepVov9vQ7LS8f5rd/8HVqN\n", + "GU7fd4E0V3z51z9DI0rwXYe9TptGLcRPMuL2HsH8Ap3ObZKkS5L2iVVOq9YgyxJ8xyPudfCUYtjp\n", + "MBwMCMIai6fOMLy1xvrmGmoY85XVXfzmFCeWn+TJj34XshvxK7/8y5AkZPGQ1ZvX+dTP/wybt1fx\n", + "fG2VoOVxUSipbYnwMNNRRXNVpeypWqYXW11lH26b56rCQZTpoVx/+XfzDlOPce67m5DG9nPla1VO\n", + "gmZzKdPbgaSrDtHrSCIp9eGwerN6rdlmrqavWabGNh6bITT/7qb/bzqAm1JWSYwIJ1cjO9axf1IW\n", + "zFVBQApc5+CkPc/TEUh7ng+Ig8hqgMptfXq1Q41pl/ksLwTjxWZbzlQB6qTd3uzctmkfaIJOkmSi\n", + "l1yZ8EzRGgdDSOrQYqlayFpyrdJJH+bgASQHhHsnIJ1E9FXPZVla3FP+ZfLmcjdFb2TmH6B0clnX\n", + "den3IqZbszz79HPs3N7lsYffwRDFzu4u8wvzyK0d8rxHEmX0sgHZIOPi668RDnrMLDQZxjPsZG3y\n", + "PGOQpzTDBmmsEElG1O5Rkx797Q61xjSXXnyFJ0+f48l3v5MchTvI8MMGm7M1Xu5skbQ7vP8vfZKL\n", + "G+u8/Lu/Ra2WE0cDPN8hTiJkEf9EqUKCMKrE/PC8lufOHrND81lB11WbvhBiLMRDlfXU3c5RFcBN\n", + "Wn/fbrGfsxlBu+4q9Y4dq8j0y1g82b4j5XEcp+tx5zdzb5lZFEJY2bEO2j0pPeJR5U0H8DKh2YAI\n", + "4EhXuwMrk1uyiPEgpT6EEIIMLSC7KsM4LDlCjmI3SKkD4ShRCNJCFIluD95pE3aZcI3Lr53D0hZ5\n", + "bCIog2zVbm6+G7WR/duo35aDkz1WVd/tTa0sxt2JqxUCJjh5jb2rvKHZ/ZpkwpdanE65vup2VIF8\n", + "1b1HR520ix4HC8CLEkUJjbBFliie+eazLMwucm1zg6npaW6+cR2ZZcwvzpNFLk7ssLm9hZAuYdOn\n", + "2ajhCWjWQ9ajBKEy3BwcJ0U5PrudNq0kpjYzT601xcyZJdxUsbm5h9jY5sJDF5jxGkTDBDXX4vz9\n", + "DzDYa7P1lVfYWl8niYf8vb/7I/Q6ezi+g3Qc7XKeUdBtAQSFMXWZTsrqr/L5y1Hc+STJy9CyzR2b\n", + "v20p2qaTO20sNt2XwfPbKTbI2uv3qHVX3nRstahpY1U8F5vuy/cb56kynoxivRSaA3Pdju9j1tGd\n", + "Yp+Uy5sO4GVAMAMHxSFmkUxUKcMxF2fFWabtYiVI1yNOUxCSPM/wfZ8kSnCVsWYpgh8VAG64XcHk\n", + "E3jzfvOv7L1nBt9ub1UpH3RWAa+9+yulRhH0qriH8kKxo8LZIq59EGzy8ZXH2zznOJPDwZpysMBM\n", + "/WaxGZ101aLTmXSMNYm2DDq8YY2LkOObX5XFifbmuztHovKBp1IKhIMjIUlSnv7aM2xvbfPIg4+y\n", + "G7h0b++Q7u9T91w62ZDZqWnoCpZP1ulLaCweY2t7m2lPcmxhgc1wmt7eLp0oxvHquIHHwqlTH4X4\n", + "VAAAIABJREFUnHzofkRrhtW9PdyFRZz5bfrbbTb391n7ytc4MbPIUw+/jdBpIndjFoNpHjpxL//h\n", + "N3+Nj3z4gzz5xJO0u9uAZhYUAldIhHJ0QguhtDkh1WBcpjchDoeUMBKPuaSfN+B6+NDdpk1z3T54\n", + "g8Pr+fB8HKaTSc/ciSbLpcz9VgEwHEQGtZ8re3ErpVWaJpSuKWYd2MBtNjAbew/GXzMLZmydIrem\n", + "aZ9db9VY3KnfbzqAw2Gu21yDg7jIucoQonBUEJDnurOvX7nK+QsP4IV1hr09wqCG43oIHLI4pl4L\n", + "iaNIm18JgWPEoSzTh5kwpnsvv7983S6GGzGfNgdRHnhDCJMI2OYKyty3mWzb9tsQkB0u1SasMhdh\n", + "NkM7kt8BaB7mtsrzMVr8+TgXZX6r6pexJS6Piz0+BxvDeEzvqnI0qFePrSOcIsiZBishtC21EhIH\n", + "ybeefgaV5Ozv7NE6f4LN7U0W6iGpShnkOVudfQIlSF2Xex9/CyfOneX5P/omg51N9rp9GrMLRInC\n", + "JcdvtJiZnyNyHQbDIY1Zl0Gc0hvGpK5DX+U4mSIj5+b+NvNrN3ni1CnmgibdqM/U8hIf+PCHePy7\n", + "3kFq0nRlCVmWEdTqWlJSFBnTM6SOElIJXGXuU4/NuIhfHtuDMVQjMLJpqTyPNvNg00SVFFs1h6Zu\n", + "2xfEnsc7mdCN5thxKttX7qsN4FXMYhUN2XXZ0UOr2jZ+ZlW9qd2p2GtpUsgLu7zpAD5pok1JUw3c\n", + "JomolALpODpnHYKvf/Ob/O//18/yvu94Px/+wPtRSUamJKQ5Nb9GFCd6UGRBaMKYorljkdXMoFc5\n", + "h5QBzQZau91VwFTFedt/mw3CJraqE+841oF5HOlgLGgMKIvCgUMD0+FgTVWLzW5D2UOzvBhGwAu4\n", + "zgEHdpT0AiCdcWcju66q9lWNsV234RjL95QXo13yvLDdHQkmApSObPf6Sxfpd3usLJ9ib3uXy+tX\n", + "YK/HvB/i+g6uW2cv2iPOFK25RVrzx+j0E1ZOn2XhHY+ztrrK8Qcv8OLT30LGKWm/g+e4iCxnuLXN\n", + "4tIJgmFKLVVEvk/Hc/GlIPcVsSt4fecW09cuIa/MM/fAWcR9y5xuP8Ds7DxSKpIUamEdz/fo9nQy\n", + "A6E7DiiEPEjYUJ4/ex4POOvDemZ7LA9+0+usPL72c1Xrwn5/GTTL7bKlzPJcV62Vo7jRKvC1N50y\n", + "U2NbfxyWSMbxqMycmf5WeTVXMUP2OyZhgV3Kjo1/7gHccKY2yMDBZOvdFRDa8F0pvSDTPMcL63hB\n", + "jUcfexw3CPjZT/1bTpxY4WMf/DCzUy2yJLEmtxgQtHeXw4Hnn+M4I+60igu33bXhYGBNTI2qCSrv\n", + "7jbnWxbBzKf9vjKAayeawnYZCwwZXyjmmgFJ0w4TyMpuj02Upt13Wpxlk6lJxAxGRzt+IFzmiA7+\n", + "FqO8pko/BMJYkhdjIIwK5O4PuFSeg3kPWoIQ5ORZxhe+8EXmZ+fZ2dpmbmae3qXr+Ar2HJewHqJc\n", + "j0bYoJcLls7dQzTUqa6aYUhDZaSu5NiZM1y+9Aa7N2/i5Tm99j5B4JMPerRch+OzU4SejwhrtH0J\n", + "/T7dQZ99V9HPXL7+hV1wBBdaHnK6TubCseMr7O5vkgkdaCnLE3w/0Ic4QhWO5ZI8V+TqsPRRtY6q\n", + "1Ff2Rlqe+zKw2nUZkLElwkmgVMXpGyalDMxlo4K7PccZ7+f45lXefEybKiXGCsag3G4bl8q0XAW2\n", + "RzGFVcXO3FVl4XPo/iN//f+hJEkydlpcLlp3R7FotQ13lCbMzMzQHgxoNlsMkj3mFhaZX1jg6pUr\n", + "/POf/Ek+8ZGP8s4nnsSVLipLQWkurEonWgYY/V5x6Lo9EVLKUUB6m/DKYpS9SVQBvH2fLRGYUl4c\n", + "ZqMxC8BOczUiXilwnPHA+2bDqeIKytKAAeXypqUbdHjBTeKOVJ4dWlD25mH3zXU8cs1e2jWMAc2o\n", + "DlktalfRj9I+eCMvvVwpXOHy/AsvsHrzFvedvQ+n6dLdbzOfCYak4Ag6m1soJMzN462cwJuaQsWC\n", + "tJ8xd/Y4O6tXeeFbzzLthJxcPs5g4zZOntLp7NGcWsaru0RqSDcd0FntEEU9tjZXCXf2yQPBMIQW\n", + "TZr9jPiFi+T3nEaeWeZdb38Hzz77LCdPHdfZzsOATr+L5wXFWaz2KpVkIF2EPCwFVnG9qjinqALG\n", + "MqBoCXV8HMv1lzdxQyM2yI/mwKI1Q1Ou6x6SuAydmn9Vc1xVjHVMFedunrV/t/Xd9mZXtYFVlUkb\n", + "XPm8yx7nqo2wqkzadCb2/a7u+jMseXFAeTg4lf50RU6SK7IsRaQZwhW4vk+838XzHOZOL3Nte4NF\n", + "xyNWirddeJDH7rufF196iYuXL/HdH/0oszNTuFIisgzPdVFZhkwTHWs8zw/iIDhuMXiF7XAJzG39\n", + "l616sYuJZmieq+ImyvkxyxNW5bVp/jbvtrl/+58tLkrHwXEKLlzIMdWMAUezqE0fy9EYy0CvMlV4\n", + "tjLKBF/0tuif3d7DXH6Zsx8Re1at11boOB+i0AKoPAc13i67veVxk0LTmJkD1wkYDHI+//tf5dix\n", + "M3T3u8yEITs7azRqIcP+PkIlOG5Kmgv225ucPHeSXnuPYXvA6ZPLiHjA9uuXCfpDnvmDL/Lxj3+C\n", + "7dkWWU+QuDAcpuwPN1HBa7TjhKg9JPA8nEyiHJ/Q9UjiAUoNiRBsb23Q39pFztap12fYuLnKsXMn\n", + "kKmEOMULA1IBfgZu7hSxPbRllfHYtTe+w+Bq5vtgfMu638P0dng+yrGH7PvLtHonRsZmQspgZRgJ\n", + "u85JUp75zZZeJwFgeZ2Ux8p+v93HSYBeBvAqXbfNgNgbWBWXX9WeP/cqFKNrS9Nxbtb8y+KE2NXi\n", + "eOC4IPVid2MQjsOJc6f53B9+kSBKCOshe+02meOwfOwYrdkZfuYXfp53v+tdfOzDH6K/38ZD4joO\n", + "UmW4ElJl4rSJIp6EfpfKM+3lae2ITmHOZbgHY6cNk/Vw9nebAy2LocAY52E2CLOxZVlOmqRjdYGW\n", + "YMxYmXbZC9uWONIsIU3TAqQVjmO4/YPxNu8ui8eakMToHbbOetyc0gJlddiGdhJBpmk69n4hbJv+\n", + "A24sVzlSjUtKpg1VqgMvcEgGMfPzc+zv90jijI2NXbLMAxnQrAf0dm4TdXZIlCSs1SCP6OUx3Thm\n", + "evk4ocq5dfkinW6fhg+b66ska7dZnpmiGw956YVnaDZrrG9v0d3rkiW7uJ5HLagzMzfN+nCA4/sE\n", + "jSZpCo2ZJtMupHGffjciDSVho0Hmh/huDTfJkdLBlx5kEcqDBB2F0M0dFIKssMgyslq532Ua1ON/\n", + "WG1XxWXqKg5z8nY8eXutVpXDXP2B6mTS/WVp8yjpzi5VAfGOapttymeesdtpX7P7XN4Yy/XbNGn3\n", + "uSqtX5mJK/fFPPvnXoVih3oti2BpmiIzSQq4jlPoMnOyPCPLBVkmmZ+bI41iBklEy51leWWaoF5n\n", + "JcvoRUO+6zs/xMsvvciP//FP8Je/53u4cP48/V6XmuMSFZk4hCNJskSf8Ls6IplwHLC4CBuc4yIF\n", + "lK3qMGaGBnDLE+z7PnD4hNyUqskcEycRI/23XezY1gfjOKp1BKiGGMIwtLggoyYZ54ryXGcYN+UA\n", + "VBl5ixqwrEptV+5DuR67b+ZveyxtEdR+l/1bFYCb6/Zm2m53qddrXL9+i3rYIqg1eOZbX+SRtzzG\n", + "xvVbiDTm5toqLgIPIIckzag3ppH1nBOnzrHT7dPf77E8P8/WjRtcv3yRRpaS5gluvcatmzeZm52l\n", + "02lDnhEPhkgp6e7vsbC8gNOqIadq1NNZOmmMErC8vEB/dxeRuSSdLs995eu89fgnyNOMzRu3uP7M\n", + "i5x/5AKDXOAlCuE55K6OrOcoiSpMP0Wpv+WxsT+rD3kPb6h6bg67optSPguqKmWp9SjVgKnfMAZl\n", + "ACzPebnYa8BsEuaz6n1VMUeqNkCb6TCgX5WsuVqCOfjNvM+WLMr/zL3lM7g7bV5vOoCXD9PK+RNd\n", + "PLyiT0Kf2OAKD6EUjpT4SGanprm+vspDC6fZ2eshOwMGcUy92cBzAp564p0olfNLv/pp3vWOd/D+\n", + "73gfcRIjAx+hFJAjpQ5Fmed6gwABUh8aZlmKFAfxWgzBmByBtm2srXO23Y3jOB47oLE53qpiE0We\n", + "5+RZPgLmMpGVDyvNdXvh6X6lY1yQlA6OMx4r3TxjmyeOqYKycf293cbyYre5F3tOq9QqNriP+lzi\n", + "esy1KIoOEb7ruofUSgBBGNJud5ibXyJNFH/0h19la3ObcGWKs+fOsn71Cs2pOYbtXbKoT5Sn5Cg6\n", + "7R5Ti0t4fh03GjDTlAS5Yu3WDfw4xpECT0rCICDOM+0yH/jkmUKGNYLAJxoMtbouz0mjIa4jieNI\n", + "JyAWCrKYwc4eapBxK0lZ//2Ad7/rvXzsQx/hH//P/4if+IX/g73bXRrCwUmh70EsFH6Wax8IFKjD\n", + "m2d5Lqt+K9NZifoqrZXsgzWbYz4qi5VN8zBZFVJFE/bnUUBmgN98t9U05XVgt8GmLVsisf/ZDFkV\n", + "01C+ZtPemORYklhtxqcsAdxJbWKXNx3Ay/qlcmekdMApdjyJzlKvBEIq4jzDSSXvfce7uPLsS+x3\n", + "O+i4vC5T9YB6rU6qcnb3dojTiPe99/088+zT3NpY45Pf873UfB+Rp3hCO0nk8RCvkAgQLsJxQcgi\n", + "CH1JF6zU6FDQcN9Zlo08Nm0O1XXdkW7Z5kQmiXD2Qjnw1kSnfcoPsgvZxfxtOOSy+AoHcVzMPQb8\n", + "bXHREJmRMsptlGKcUy4Tvf3eNBtXoZhDX7uMVGUlr01Tl8012gfFZc6prH80i2uYDAnrDQb9iHiY\n", + "8fWvPc3p0+fJs5wojlm7fZuw2SRwJWESsrO7Sz/OEbUGzfljbOx06fT6nF5ZQcZDRDQkUBkiF/S7\n", + "HbpxHxl4qFxxcvkYvXyPVAe+BjK6e3vIOCNNlTarTHNUBuurt/nwRz/ItYuXIZMM6wHB0jw397c5\n", + "c99buHDPfdRrdWr1OjJJ8aQkcRSp0IfUXmE66nCYhsbVJnd3eGYXfd9hicfzvDGuumx/bZeJlklH\n", + "cODmPVXgfVTby3Ri00QVZ10lzZXHz/yz1R92X8vWO/a18uFl1fjYDErV73fivE150wG8yvjd/kxV\n", + "RlYE6LXDRTqugySnhuTMykm++sUv8eFjx9lvtwl9nb1aJQnJcEjD86kHPsN8yOOPP876xjr/9H/7\n", + "F/zFT36Sp972GP39bZw8pRkGJHGkQcI1mTz0ghGIQ5NWBq7yyboRvWydW3libJ2iWRDGTnWcE6U4\n", + "Vx2f8LITRFUbQROXIUZ7IdqHKnabTH3lRZpn+RgHU+U1Ouq/Gl+ctvhZFkHNpmcnX7A5FvtsoGph\n", + "TBJPHd8hS3J8p8bFN64xMz3Hwtw8eQbXr1yh3+8hpGCq0cRNYdp3YRATzszhNKbYXl1jutVCqYyr\n", + "ly8i84QgcInilDzL2NttkwiF7/sszs5RbzToRAnRMMINA3rtDrXZRTY6beZWjjF17Dhud0jdcTh2\n", + "4ixnTt+LK31eunmD+9/6BDfWVol9yVueegIR1BkMI2qtFmmni8gh92GIpJYLhIKsAtfKXOy3C+J6\n", + "7A7fWwZlm07KxdDYQX1Hq0HK778b9YFdqizIJkkfVYeNVaZ+NqM1JoUWdFo+JyozFZPG2tC2zcHb\n", + "jIfdhzuVNx3As8xWn4zrjg04ucgil17RUaWIlcINfESqOD6/iKq5CBVDFpPGCgn4ns/CsWX2ux2k\n", + "L/GCOTrDHksLC5x/8HE+81u/yd7uNh9837vxhWLQ72ovt1xnrXaKg00d7F2QkY+BQxAERS8sQE0z\n", + "vdkUnLfNDRwG5epT7eFwONKnw+FYDza34VboxQ0HlWVZIWKDdr3WnnsmNIgjC2lBZZUmhoYjHyfQ\n", + "HMf1xsTociyMESHnhz0nDdB6njc2JqMwwVaMjUkRI6u48izLSCy7/1FbcoVKBZ6EqxevcmLpOMNu\n", + "j7m5OTr7O0iVMegP8YXCczIiIQnn5jj/yGP04pTZNMdTOfvtPeJ4gIpjPN/F83wGaVxsjDE1zyPJ\n", + "M8jADwJc16Xd7bCznfPU299Je2OV4w89iKrV6Vy+RR6lPPf8y5w5cYKF6TkePn8/i815Fp88wdVr\n", + "V7n/3U9x5dXX8AOPtd0dph0XmYASELsZtVRn2FHu4YM0W8K6E5hUqT90MpFxl/lyKasKyvfa1lj2\n", + "PJVprGozNjRzp7aX22PuNcyUTXt2PVWMYlUb7N/KNFfFeBrd+6S22SWxchfYn3c6tCyXNx3AzUBU\n", + "6YOF0ElQHYQ2BxMglEAiSIX20vSFQ5xneM06m7fXaTVbJFFEUKvT7/fY398nCGs0vSb7e/t0+12Q\n", + "gsSp8YH3fyevv/YKP/VTP81f/6vfx7GlBRwBg16XoFZjGA012LheoYMe32GrCFcIoc3sGOc+kyQZ\n", + "4yLt52yOw1a9TDrlNvcY8KzimO1nTP1Znh2qVzEe5tIG2ao5sRei+c0s1ipuxQZUu91mPMqgbXPr\n", + "5nvZG87+e4zjL42D67okeUwYhsjc5crrlzl39j4G/T6dnS2kilmca6GGPoNOl66KiJGcOnWO+uwc\n", + "ne0dLjz0AKEjeO4rXyJXGX4YEMUJoS/JE4VbC3BiRXNmiihL6bZ7NL2AWhAw7Tp4QYAUkpWVk0RA\n", + "5gfs9YfkueLqzVvst9s8+djj1FxJcvUqJ9/6MKnnstbZ5aHT97C9c5soCHVWnjQnT1ISAVma61Rg\n", + "jNOIGd8yXZYBzh7bchGiCFnBYYCxQdWmlTIATtLjlhmXsmqjCuTvVIwKblJfj3qfvcnZ9djctl2q\n", + "Npwq0J0E5DZQV0klk75PKm86gJvFaB+OmCKEAFdCXpgbOgI3F0glyIqYFkEuyVyHhZMrrK+vs/To\n", + "ElEcs7W3SzSMaTSbZCg2t3cZRhGNZpNmM2R30Gdrd5/7z9+HKy/wr3/6/+SHf+hvU/Ncjh9forO3\n", + "y/T0DPFwoF3IrR39qEHO8hyVHfaktEGmCqhtsDScZFmEM+NT5upNvZNEx4M2i8qY40bcLYNk2Vuu\n", + "3B7Tf8NNV4GD3W/TDpuDMXWYzcgWS219vj1O5qC4TCv2oWkURXrxOTl5pPjKF77A7PQsLz/3AqdP\n", + "neT1y6/gOQqnXmOuMUVrbpYb3R2WF45x/oGH2Or2afcHLC3O0964SRIPWVxaoLu7zzDOyAZDcFz6\n", + "0YD6zAzzy8fYu72FFwSE9RYzU9N4nsf23i7rr1xm8YHzbO12CB2PIPBx0oyUlD4x17ZWWQlPszTX\n", + "YG5uhpnePkQJm9dvUW812Om28Ro+ypE4QhJIiXQhSw9H8SuDThUI2LQ2CSQO0tkdFJu+7M+qOmwa\n", + "tdtStY4mcb93w3mb+ybFKyqvh0njY9pkM1fmTKuqXfbGYNN8+d5J16qkgDs9X1XedAA3emNTbKCQ\n", + "UpIqEEpL/SZ7dK5yhOviCYkYaDO4k/ec4cVf+n1Onz1LnGU0ZmaYDUKk4+I4LlmaM1vYFUtHcGKx\n", + "wfLcLFtbO0RpytueeAe/+uuf4Ym3Pk6j1cILakTRkCQeUvNCFAfWHmWzR3vyHKljthggKZsfGc6y\n", + "ilMun5qXJ7zM6ZoihBgzpTIqnYNUaQW3LsdNNvM810lYGSdcA8p2/VXSkSkmznr5ur1YTBvLnL7p\n", + "Y3kB2pydabPpv9kwqsDL0M1IN+9miMTjd3/nd3jikbezMDNLb28XJ0sY9Nq4kU9/a5NW2CCrhSwd\n", + "W6EWNth+4ybNVp14OOD61SvkSYTr+YT1JnGcMxzso9wM4TosrxxnmCbkjiSoBWzu7pImKcePHydX\n", + "is7qOufuu5cocJmuz5AuzTPc3iYnY5D0uXTtNV545VkurF7mexcXaDk+uYBbN64wV28wPT9FnEt6\n", + "xAgBXpQxNCqG/M7cXxnEbG61GiS1zXgV81FVf1k9IoQYnbfYqhC7DnOf7VNgz+PdtXO8DVVtq+LA\n", + "y4yi3QebnsqcddU7qtQv5WJbo5TbVW7fnTbfcrkjgAshfhb4OHBbKfWW4toc8IvAGeAN4PuUUnvF\n", + "b/8d8F8CGfBfK6U+e6d3GCcOOz62GUApHbxMkYqclOLwIIdUpDpBaAbCldxz4T4+c/3n6AwGhPUW\n", + "0q/h1Ou4rs+tG2v0Ol2kEDTDOjNT00w3fYTnsPzgA+y0+yweO8Hyyim++KUvENYDzp85CWlEzZck\n", + "qVY+2qqAPM9Htt1gHxyBKADEnhzzu0nUUD4AKjseGOI3ZotldQIccKm2+aUuCv01x45/EUXR2GLL\n", + "Mp0ntBb6h7h8O/KavTDt9xjCLUsGdvvL+QBtyx17szIWMlWius19Gw58Eidom1QKIYjTPqurq7Tq\n", + "DTzHxQ1DLl28hpQpjkrxXZ84iui3E2I8pHS4dWuVsFZjcX6BrVtv0N7ZgSQmynNmZ+cJ69PsuQ5b\n", + "7T2mZ2YQjo4XPlVvUm9Ocf3iVXrdHo2pKRCSIJRkIsMJfBJStve36N1ew5GKPB/gpSlODi/94R9w\n", + "+fItfvCH/j7LC/O0zl/gc5/+DT7+F7+HPTdlV0XUFTjDhK7McDwXN1OVwGJvkGXJ7G7EdCHGmalx\n", + "Gq8GnTJDYn+a32z9vPktCILKM56jDkntYsfpr+5LdRyTcvtsZsGsqSodunmufK5lz8OksZ60GZrP\n", + "crjeO5W74cD/b+BfAT9vXftR4HNKqX8mhPiR4u8fFUI8BPwV4CHgBPB7QogLygQXnlDKh3V2yfOM\n", + "vLAAqTkurqsgR3MIQO7phKLHgyYzZ46x29nH8wN6gx6ra+vUvTqZdJhZWsRJM2pCsre/y/ZOGyEl\n", + "SZbjeDXqrRYqV7znPd/BV7/2NGma8tCD96EcgepHkOdkEpLCu9BxHVSutCec0Lpk5QhQOXbyb3ti\n", + "DAAZ7tae5CoO14CffeBRJo4qgpDSLALtrGPu8QO/SOAKQjq4ngCldLSQ0qKypQ2bE7NNAW2QFRwc\n", + "5ZZVLvbCt6UM+74yl1Kl0xy9a6SfLa4pkEI7GulolYIsS8hzhe/Xefm5l0mGKc3pKZ575Rt4WYzv\n", + "KJpTLYhj3Bz6WUorCHRW+dU1Tpw7S9Lzae9sEkiJH7YQWc6gHyFdj9mVFeR0i6nFBdrDPoFXpx7U\n", + "2Vhbx6u5KFJ29rZYOXmCOIl56dZF+psudSck3t6lkUlUliKlR4ADIqeTRWwNOnzqUz/HA6dP810f\n", + "/yiPPvVWvGFKPfDxlEdGTi7BdTiI8pJlqAwcxyVV4PguudDR2B3AKYJepYxLjJO4QEOK+pIaqVOU\n", + "KvwjzDwITfw6njylokZ16TnW9GmYHnvzLlsl2cVu66QDPu2N7FgUKKw+VKtjqiRcGFf52GpJ+x77\n", + "vnGu/YCJw0oEfrBhqNHnJInBvvanwoErpb4khDhbuvxJ4P3F908BX0SD+PcC/14plQBvCCEuAW8H\n", + "vjapfpubKotsUGS+EUCuyNMUVXTcKSZ04GYIBHPthO/4yx/mlS9+k/vP3Ut7EDFXb9KUITvRgI2d\n", + "DaZdj6nGFMeOz1GbOk0aa3Drdrts3N6k2+2SCcXi8ZOs7nT4g1/4JX7wb/8ArWQPX/x/1L15kG3J\n", + "Xd/5yTz7Xeve2t/W7/Xr13u/3qVGEhIGCWQQYMEYGRyYATzYYDtiHOMZ22MHYcfMIHvGwTgmvMDY\n", + "4TEYGxASBgzd2AIktNIttaTeu9Vv32qvuvvZT84fp7Ju3lP1WgwxE81kRMWte8655+TJ/OUvv7/v\n", + "75e/hFiWS/4d38PKgSSDrEySlFKQCnAdC6cSGSKlPFjyrjnn/badcWxqZZYkCY7jlE64ND2Y7eFo\n", + "OsMMsyvvZe70M11oYa4ULX833SXEpB7MZ1RRhvnMqrKvCvhRkQTmJGF+atRfHUD6vFmnrMgRolwP\n", + "AKVPBEuW2SdtSZKmZHmC77uganz95Uvcc9cD7PX7hKMhS7aA/Th3OwclbOyay0KjTjrsYecT0tE2\n", + "r71wlesXL7PYnKPmN8jyjCRNyaOEuOGwfPYsx4+d4pWXX6EReCTjCaP+AFWkCMcijAf0Bx7pMGJU\n", + "ZPjz8/jteTqtBr20T6YEdgY15WAXOZkqmLgOj7zzCd740pcYFCFLD51j7es3sYo6rbkWW8ketutQ\n", + "yxRFmiI8F5GV+Qld1ydwfcZJREEBKkfkOTLPUUIcrCw+yvrT8qG/mwpROzR1CoajrKRqMSdr/f0o\n", + "6uKPU74RTVHKpnl+OnlM/58NAzxKLnW7mJFN+pxp0RxFUZX3MieYKZKfjqGC6d62YmbS+0bI/Hbl\n", + "T8qBLyulNvb/3wCW9/8/xqyyvkGJxG9bqmZ5lQ7QKxh1w+nogqowZFnGkw8/zLO/83ts9TbJUvBE\n", + "DVWvsdRZZLnuE9gW/fUNouGQW5tbZacXivn5Be44eRppSYQlGUVjwiRie3ubX/q3v8QPfugDzNUD\n", + "JAJH5RBlCEti+y6oshFdVebLTvLsyE4wzTN9rBrTrN9Zhyea3v2jFKBuL01BVBWpybsrpWZCu7ST\n", + "UghxsDmz6WCtLqwx38fsO33cVO5aeR9VqnHl+tN0curnHhXXXRQFSFnCw/0BKkTJuTquS5JE5FlG\n", + "vVYnzwt++zefYeXOu7BzSbzbw1KKSGX4QmFnOcqywLM4ubrK/LETfP3SBTqdeSgKdtbWII6JVR+3\n", + "0cCVDnGeM4xilC1pdjsMoglWELC4vMiFl14iyzJsJRC5IpvE7K1v081dlmwbPy/3tSwWmmyNdvAK\n", + "iZ8XCNulkTnc1Vjg6iDnlS9/iYfe8xSNVgdcn54NfhISpTnM15js7HCiMUcch6RKEVtg+Q6xyinC\n", + "IY4SB3uX5pYksij3AeUwajSjo46yjEx5Owo46DFZPV8FJtqSLLtuVqZNP9hR8vZWaFXLsom4p8q5\n", + "lI/qe5jhveZ9q0pdUyhVaqQqv7er1+3G7P5ZtOya11d9Uf9fKfCDopRSopqjtXLJN/gjOE/XAAAg\n", + "AElEQVT9EcjwcKYwkyMzFYypeOxc4jd8UpGx2F3EFh7jMGG01sNyHJDQatSpuTVWjp9kY2OL4XBE\n", + "vz9gc30L1/doNOvUGw2wXB578BF2e3v8u1//OD/xoz+Cl4ODxLcdJklMjEJJgYXAVgInL/BsG+XO\n", + "pp81Z9ej8iDr9zMD/JMkORA0TaWYoX0m1aCVneYCzYyC+rl6wlBKHaB6U0ma9TD7xuyHwwhEHaCI\n", + "ap1mB9K0D28X4mYq9qMQ3Wybif3FVWUdhBBIxf5WYwLHDZhEOdev3WB3e0xtfo6TS8d4+eKnOLV6\n", + "jOF4G8IBKk4ZiISiVuOY7bEXZqTCYml5hc2Nm0z29qhbFp4o6G9t0mx3sD0Pj4LO8VXcRo2rV29Q\n", + "a9WxXAfLs/FrNdJBH/Yn9DRP2WrZBJaiE4Ys0aVTa9Fup4S3tnCkx9IdqyRZwuLqCdSLF3nwm9+H\n", + "9+7zXFzf4ezxJt3VZeROD9e1+OQX/pD3PfEUF6+ssbw4T5hHZLZEiQRbWjgW2GmOpQSZUGRCEcmS\n", + "6rP3m9x0GJu58KsUl+47E5FWKZjq96rszN5j2l/mOVNmD/f1dNK/HSgoo0Vul5/7sGxXx575myrQ\n", + "Md/PnJS+UeigEMyMh/0rZurzjeT8j2Ot/EkV+IYQYkUptS6EWAU294/fBE4a153YP3ZE+QcA/Jtf\n", + "eI1Hzj/AIw8/eCA4JgqvOhxMR5dWcAeKahJy17m7uHDlEv4pD5SN113g5NIiMhPg24zjkNFgxGB0\n", + "gzCKcF2PTmsOz/Op1+v0+z16vT6DYR/bsUjDkMfe+U5+6dc+xn/zgz9MMo6JixTPdUmkohCKXCms\n", + "IqcoFEmczXCN1VnVVLbme5kOPyHEAQrXzlIz9MsUqiAIDqJANIrV99e/N59tDgI9cEykWw1rNJW3\n", + "+Xzz+JELaI6YwN7KkjCRjonsTLRzoAiKkjNG6GgJ/VuJEB7RJKPdXuCFr3ySE8fPsRMN+OIX/4i5\n", + "fUulu7RAumcRDQZEWUzQXkDW2lzY2CDwatxa22Tr+nVajkvTscmjiCicECUxyvNYPHkH5+6+h9Fk\n", + "gpCSeqvB9q010jyj0WoibBsVJ8RhjEoyxKKF43ikRY7MFE3HZeXUafrK58KVywjH4ZGnnsBV0MDm\n", + "2c/9IafbPnff9ygUFt0zp3nt+u/T3ok5P7T51K8/w+Pf+UFuCYUnHFAZVlLmCR8OBzSCgARBBqSF\n", + "pJACW1oUHF485rruzJjT/XYUEtf9Vu2/233qYo5by5pm2TMtLfNa0yo76ni1lBPLNIHVVNamfH51\n", + "kjFlujrxmIDndrJ6NAI36ZpZ6ub/Sfny8y/wpee/9se69k+qwH8L+BHgH+9//oZx/D8IIX6Wkjo5\n", + "Bzx39C3+AQA/8eO/DRy9W4uenc1z1ZhpUyk6ecGpk6d57otf4YlzjxHGOYNwQjiKsSPFoEjIHElL\n", + "WfiBje97ZFlOlESkacxebwfPdVmc79DttMizlPFkxCCJOHfP/fybX/x3/MhHfohoNCYQApXnqP0d\n", + "fhSKwhK4totnDAT9bmbqWTO8UNfdjJ6AEnWkaXqQvrY6qKqUg0mX6FJtS9NZVJ0QdL2qIXtm0VSN\n", + "ee/q7/W9q2avaQ4fpcSrA6L6rjP3VfuObHIKkYHmFXGwrYBmo87XvvIK9Xqn9JnEKcPtXXwhsFWC\n", + "KBQyaJArl2bg01o5wa1JSj+K8YOA3d42k+GYOhmoHEsVSM9lmEakqqCVRPS2thmOJ5w5fgKUYi0K\n", + "2aeKqTWb5F5CjkVRwKLbRmQ5kzhiI+yx5+SApHmswajvsjnskzz7PKo/4fjxBWxVsPXaRRr1JcL+\n", + "iOVj87iuQ/rqJd4ZdNgUY/7lL/8y9z10H3/m0UdZ9FtYozF2luLU6uSiIBUFOeW+n56SkENapIcU\n", + "k95QRcdnmxPzUeUoa+0oyrAa5jlF0dlB9JQ+V11HoP/XDvO3cnJq+TPvN61rYThgZ8+ZzzNBgn6e\n", + "ljUTVJmg6CgEr1Nj799lpn7lJ2gL5HZxHUII3vHko7zjyUcPjv3cv/rFI6+FP14Y4S9TOiwXhBDX\n", + "gZ8G/hHwMSHEj7MfRrj/Iq8KIT4GvApkwE+pb2AHRFE0M/vrDjSRgOu6B0pMl2piJKUUvutzz133\n", + "cGttk0kYETS6CN+HSUYcjdjY2cZq1ymUTdfx8HyPbruDZdkMB0PGoyHbUUSeptTqPosL8xxbXmbB\n", + "UdxYv8WDjzzOP/u//g1/46/8BEkY4dsussgBhXAkcZ5SZAkkU9NQKz2tQKvvpzutuuzezPNtKjLz\n", + "d7odTCelqUxN55QO3zMjYMxBWo25Ne+jc4iXVJc4uJ+O666G7k3NzGnucH1/k/7S/aaRmRDaYTZb\n", + "L73hBxQkSYrMHZQoQJQKXAgFUiJUgRAWNa/Bb//W0zz+6DvwPJtsb4+OYxNOhgS2IBmEiEaTXcvn\n", + "xMl7ufeBR3j2pVc502kRD3psrq3TQODbDq4tEJ7DIIzIUcx1O9SbDV7/2otYtsOx7iK31tYIe318\n", + "ISBNwbEQrovfcZBOgF/zubW5hlcLuL69yVN33cnisVVeu3gBe6XD9lYPa5/aj7KID7z7PfzHF1/m\n", + "pCtIdvtM1rZ55PF7+NzO52gu+pw/dRfjxWX+y5ee48aFy/zkD/0gLgLH8QhqAVEWUhQFjpDIXCKS\n", + "nDTPyWV+pBzqNARa3kplO40cmcqCBh1mvnhVuWYKAEyHvZYjjUxNytCUbTPZmpaxo/hxs5T7xZbX\n", + "p2k6E6papgWY3SkrTadK2VTeVYd+GMa4rnsgu7Y9y9tPx8t0vGngo9tKy78+p3fKUmo29FXXrTp+\n", + "bxd5c/DsPw7P8v92EUIvzYHff+bjMwrA5Lu0oqrGDle5YN0JcZKjGnV+43eeJtqdcN/5R4mFQ6Bs\n", + "GsLHaTUJ5ttk/TFxskOWp8RxucmBJS0C36fm+0gpyNKEKByTZznSdpCeQyxyEpUSjoZ823vegxhN\n", + "kGmCEIpE5iSiwMHCUrMUA8wKrGlZHJ2LQs6sUNVopCiKGYfPUdydiV71NSZ9UlW0JjqvWkBGfx18\n", + "agSl721aAeb7lX/WobqaZRb1ZIcmFVMOzLBGMgukQokcRQ6yHBB1v8WwH/LcF17gzdevYEuP5nyT\n", + "4aUrZMMB+ECUIguba2EIK8c4d+cDZKmgLwoeOdnk4quvsHX5Imq4ixoPaPg2hShIFCSWzZ1330+K\n", + "YGtzk0aziW05bG1u4jsWvi3KfOBpTCFtogzuOf8wx1aXeOXN10hVRpApHrjjLgpXslvEvPLKq7Ry\n", + "m6CwSVWOlY954u4Hub7Ww+ouc8999xP3d1k50eXUyVVe+s+fY7m9ynXb4s16xhtb1xnsbPGR7/9z\n", + "dOsBLgVWUZSRJ5kqc/sohbAt4iI9pARLJT0rLxopmvKn0bqJqPVYlXKK3m+nT/Rz83w2B4iWd/M6\n", + "00oz5VIpxWNPfeDQvZ/73DOI/SyZZtbPMoR2NiS2/Jutv77etGx18TyPJEkOFiZpWdcWiynfprKu\n", + "TlQadUupgZ01o6DNcWdav5Zl8eg7P4BS6sjZ621fiWlGQOhiCgnMcq76hfUMb0ajtBptJnnGd77/\n", + "2/ln//znudcCH8Hm2gax36B/4xrthQV836fZtrBti2Z7Ht/zieKYwWDA1m4PAdRrHp3OIvV6jd2t\n", + "PVLK1KQ7wyGLC13+u7/zd/i5n/1ZBhsbFGmCcC0s25qJAdfvout/FLdmcvpHOR3N/OhHJao/Khuh\n", + "vhZmPe5HtbHZrkcp/tm8IxwMCH0/E9noftHfLcuZuafu02p/lvf7xlnYDvrfEiAFqlTfCAGW5TAa\n", + "TkjjgquXrpInKY5rM9q+xdb1S4gkprHQokgLUC6NTpfWqTuYxBE7G7uceeQhLr7+VdZuXqPp2lit\n", + "FpMsJVQZcV4Q5QVLx5dpdbvcvLVOvVbDlZLtzQ36G5ukjk1jqYtjS+qNBkt3nGFcSL7pfe9jeb7L\n", + "A088Rmexy6d+8z+xvrbO3Y88yGC4g9MIyAcx0pJYCtajkE988mn+7MnH2Prqc2THlmieP00/jRg6\n", + "FsfPnKX//EXuevxhkkbK6uoyN/e2+Pv/y0f56Ef/JzpejXC3x1K9QV5EhFFIvdMiSuJDm3CX8nM4\n", + "xrpU6rMUgRCCubk50jQlTUvQUyLfkqYwAZhlWXied4C6TeenCWjMfjWVp5nuwaRNb4dGSxkvHfga\n", + "MZf3tNC7EGkro9QbziGdY04auk4mNWNaJ/p+VXk3LV6l8hmgA+A4NpYlDyYRc3crDUyhtCiCIJg5\n", + "drvytitwmEYtmGaJFoTqMm1z8Oui/w/DMY7tsNBu4dZdJtEYohGL820azTlacy36e31GKmE8KfYb\n", + "bxclBEJI6rUaQb1DPfARQjGJYgajXfIoJSsKLM/m7LHTpCrlQ9/zYf7pz/88f+H7P0zNr1GkCbKQ\n", + "2FJiVbhB/V5aQHXUzVHK6gBl7l+v83Kb502FfdQmBvqcyd9pxF8dSMCME9Ksk5RyZgIoj0/vV+W1\n", + "tcCZE3DVStADp7oS03EO76F4lMkshEDJMoRQCVnuniRthBJ0u10++czvkyYJx1aWyZOcaxffxLIL\n", + "WoFPNOyT5AWJDGguLbPUaLC1s8dTT51nHI65cusqIosphMC1HdxGg71hj0musIMaTqPF1Ru3UFlO\n", + "u9tgMhwyHvZp+C6eUgw2NlhZWeaOEyeZW17Bmpun0Wzx4uVLnDy+Sm9jBxeLLE5Yu3yN+lyd9z35\n", + "Tp79w8+ztbtLf7eH6wjm6m1kzWYv2uLmtTc5c2cH363RH4Uw32CzIVCbt5Cxz95WjBs4/NUf/Qme\n", + "fvqTHF9Z4d2PP8LmJMRTBV49IM0SkjTGdbxDyNecjM32NidyXUaj0YGiDoLAkIupfGiZG4/HM7Ix\n", + "VW6Ho01Mx7k+XnVkV+t3SCYqsljKn0N1IirrMAUn5rlqgjX9XHPiMIMFTBk9Smb176Zcuv4ryPPp\n", + "8zV9pZkGHTp91FZs1fKnQoGbSYhMxKpUmWfZRKSmgoNZheb4NkWYMNrb5b7z93Fj7TqP3nk/O7t9\n", + "wjRGxjn3nbuXocywRZ0kyVhfX2d7dxdLWoxH5QKa+U6HPE9KnttzsBHkWUaRpMSTkNTKyIH5E8f5\n", + "X3/un/PRn/5pmExQ43AmN5xZNy2AWpnrpeOmyaY7zNzJx+QJ9T1NJWfyg1Ukrn+nOUAz2sRE1tV7\n", + "6DpU0X3ZV7Nx5vreMDvwqiZ11YqAauhkfujdzHfSFBHsT/gClJKwH07o2B7ra5t8/rOf59wdd7O1\n", + "sc5CdwE1GpKTEKaKlmMTSsmoyGjUPG68/iqF7xCFc0Rrm6g0xLdskjDE8XyE5xNY82RpSL3VIlWC\n", + "Ub9PK6gxGA+J4wnlIsoCV0ocbESSsnX9BmGmeOq+h3AtG6RFPIz46ue/yGKnxTe99738xm/8Ot/0\n", + "Te8k3ushpCBKImrKwhomNFp1Xtq6zJMfeT+f+8IXuePcGeZOnmXvVo/lB87R/Q6PziDFSxS9nW2k\n", + "9Bj2Yx65+yF68Zh/8Uv/gb/0Qz+AdCRWluKkKXXPJy1m06Ka1JrZ5uX/s+ixmurApLV0+KrpbPZ9\n", + "/5BlV47nqRPclP1ZkDCrlKuycJT+yHM1k75iirCPipCRR97bpEVMq6Bat2oAgG5T7c8r22bKf+sd\n", + "pEonp/breQfjQfeBGRGWJMnMtoa3K2+7AteCYC7O0Q1aRWr6+up3/X8ahdQdj6TIuPPOO7hy+TMs\n", + "LnTx/YBMWMg45403XiP2HcJxjmO7BLUaDz34AEJaFIVib3eHKA4ZDIaQ5wjZIJeSWi3AlhKEIsoj\n", + "Ar/O6ukTCFvyr3/hF/jId38PbdeFLCdNMpQEBFhCUuyvYMOyUAIoFFlSzrrCmkUe1UnLVOYwNdlM\n", + "/ryqKKvIwFTK2qnjOFrYj3ZgmhkKzePlEvXZgWf2gVlX7ai5nW9DX1/2I2UbHeygbm4hZyIfhWc5\n", + "JBQoIE8ykJIoifnEx/4j5A7buwOGoxEWknAU0lhoo6IheV6Q5CnNTgfflWyv7WC367zylS8Rb24S\n", + "eDauK3ACHxubJIqRjsf80gIn7jjNxo2bKGuC5TcYTbbYvnGTrhfQrAXIIqcmfYo4w1EW/Z093nj9\n", + "NaxWm8XlFa68/CrtoMbrb77B8ftP830/8oN88umnme92cR2LIorpSAc3CFBZzoiUW8MdosGQl7/w\n", + "HI0PLrBy4g52t/c48+iDrL3wGqONPequwzAKqQcB/d0hSuQ8/vDj/O///F/wFz/y5zm7uIDv1Ukn\n", + "IY7nkiuFsEQ5YRYKimI/HYRV0lL7/Sz3nZhmMjYhyom2VGxaySuUOtqfY4KFKQg7nH71dt+r+Xhu\n", + "F4kSRRGW5SClOKBzpsr3MEVTXjsdd6bsaqWq37vValMUOVlaOvKzfDr+iqIApR25inq9DrAfV68T\n", + "z+lVraX1oXP9O04yQ4/q99MWt7YGZpPUHS5vuwI3Z9WjOFrzu2lSmOe1knBETiJTsCWLjSZWlnP9\n", + "1g1kZmELl/mFZewTNYTnkWZjJuMxURRy5dLLeJ5HqzlH3bfpNFsszjcZ9IeMJ2PCLCcsIjzXY67R\n", + "olWrAwoxVDx+7lFeTL7C86+/zsOPPUwry3Fth4lKcfwybagrJNKyiCVMshQpBD5l/oiqMjQVsGlC\n", + "mkJWDQes8nm6TUzBKO9Xhq/NtqHAsuxD7W3Wx+ynKWI+nDnxcDKqKdIxnTnVfi9RnI4y0ly7PPQ8\n", + "jVZqmYuyc3JVYGUSy2/wX/7wOS5+fZv5oE2jvcrN3R7bly5RTATx1hglE/asAiEUx5sNiEM8WzHn\n", + "2Gzv7jLo7+AKCzXfIWi1YVzgFQ7jVGHV2lhzCwTDFMdpMyFlsnaNZiyoJxF2I2fhzHFUXJCsD7Dx\n", + "OX7yNP1wRDLsEfW2uXHzGlEScenGZX70zF8mSWOOnz7O7sYm3VaNXtNmFCd0EossyxGeyxuvXeDM\n", + "wkmGl26xtrOB9cQ5ROgRX9rBnlshjxLceIRXk+Q+uFlBS9mEuzEfeOg9vPrCBb4wep4f+J4P063V\n", + "yJIxwpUkRQKiwBYFFgoLCUqQY5FhlXttFilKgXYOKlVO6nrRjxlSZ1lHL1zTZaos1QGFYlrTVepP\n", + "l6M3FDlcSgs+I89n/WRTQDCtg0bgJkDUzzWV+kH98pxCFUhL4lkernIP9iLN9yNNVKHIcr1B+OxK\n", + "cssCKfMDlsG23X0+PpmhjvI8P0Dc2qIxrZDblbddgZthRtWZsGruzSqHWWeflBJH+sRZjlf3mWt5\n", + "nDpxjK2tdZ585AnWb27w9TdfxgkCYpXTbc/huR6Lx1ap1WpMwhDHtun3B9y6cZVCKeq1GvOdJrXW\n", + "XInyJiFJlLC7tc1wNKQz38afeLzrne/mX/7rf8Hc3BwPnLqDMAxp1GpMJhOkJUilRRrHCClw2V+c\n", + "tL9aUzK7QqwqVKaC1ArdXHChSxVNmO2jFa0ePOZ9S1SVHmrf6jJ+LWymmTmdGA6buOVxcUjRm5OK\n", + "SZdUuXM4nJNc93Oc53jCIhcKt9MiSQWf/+TvY3t1QpXQnWviJCmW55J7LtJWxDlkSUqzM8ckzhlH\n", + "Pc6cPk0cTdhev4EvCzKlmIyGJFlGq9YB36YeeJw5fQebm5skUcj5B+4nzVN6ZNirY1Q4YnewTTqM\n", + "WGjMEXdtspqDmG/QX99gDocvv/ASp+46w2c+/xl+9C//GGEYIS1493vewyd+9WP4tTr33n8/b77x\n", + "JjEp0pFEYQRSYB1bpmbbuELQwiGvuaxt9rjz3L34RcxICK6s3cJxBd5cm8CpkcUJHVlgDXa588xp\n", + "/sf//m/zk3/1x7nzrpM4SUJDSoo4xZYKbEkmBAqBKooSlQPKWIhiKhl9zJQ9k06Z8syHHZdQTgKm\n", + "b8akMqrjezaC42ifiNYhpsMTpimOq2NAX1+14s2ACB02a8qmyRCY4OkgEmc/K6ipy/R9gyA4OD51\n", + "7qYIcZjv1zSQSSu/VXnbFbj5AlVTSp8zQ36qyNOcoaRwgJg0TsmEYnVlmZdeeJlef4f5xRaLq11s\n", + "zyfOUya7IUmccPPqFeqNBpaUOK6DLSTdVo0gCLBtm36/z/Z6iO26SGFR92t0T5zEsgSjyZhxNGTj\n", + "1iY/9pd+jM9+4XO0azWW2i3iMKFTazCMJoQqQ9oStyg3o80VxEIhBVjFbHKhahpajWx1MXlp/V2X\n", + "qhKthijpvTbNYiLlKg1j/k1DEMvfVZFTlSYpnab2bc3qan2r71s9Z56PnIJ6ViCLgsIp+NVf+hWO\n", + "tdoUXp1cCC5feI05y0IEDey6h7AFg3BEvdOi0Zqj1xthIxlMJmzeuEzdkZDFCNsnT2PSNCOMUtxW\n", + "i9N3nMWzLUgiHn70IXxpsXd1ncCxaS3M0w5W8a675FlKf6+HcnzufeQBrvR3cKXFxqsXuOPOE7zx\n", + "5tfxazXe/Z53E2UxhQTLcfnghz7EZ//g06QoFo8f4+rly1h5ge+5tFotZLvBPefv4vIbF+jecQdR\n", + "d46JgsmLL/Lu8w/y8o0bzOGwtzdk6EhGzgSZlgnW2rWAUX/IP/x7P81v/uffYicf88Rd9+C6NSb9\n", + "MW49ICkKCkuRyzLkUO5vcVhVG2bKhirark7S+rhpcU2V6NG5300LTitTc+OOo6xMU6biOD54prmo\n", + "rbohg/mnx5u+t7moSSvsadSISd3q6JTSYiy57ZwsKw49J0mSEsgZUSxSSjzPnZkoHMc5WH1dHYdv\n", + "Vd52BQ6zNEB14OoFPOZmBjCbl0Bfu9frETTqZYNYknvvuZvXXn6J3f42w7HDcDjEcX2cwGfOX+DU\n", + "qVMH9x+PhwwGA3r9PSzLIk4K6o0u55bPkOQWUZTQ2+2xs7lBGJYLJeYXunTn2wjHYnNti/e88118\n", + "5kuf5Qe+93uRk4TReILlOiQqxfUc3LTAKiBXBWle4DkOjhFpYwqWqYjNya3aodW9/0yFbpqEZhTK\n", + "7Yr5XE1XVWNlLeswBaLrbWZOFEIcDIgqMj9qgtB5zU0FYG7cYBblCMgKonHIZDTmytcvcP7cQ7hL\n", + "S6S25OpzX2Op1SB3FFs7m2S5wG93uPfRJxmMI9b7F2jXG2CV0RLpeMRczSb3LIgVRQGbwx6OJ1kp\n", + "ImrhhLnAZ2G+TYDFpS9vs7lxgzAI8BeXSmsribl48yYrZ87ylVdfwQk8+jc2uH9lmct7e3zlha/y\n", + "M//4o+QCLMcmUxmO77F8/DhPvfeb+fKzXyKMU6xOAxVG1Cwf17HZHOxypmahkoTx1XWCTpukFmCF\n", + "Ia+98CLxOMSJUub9GnbTIbIExThhZX6BkcpZrnv0d3b4vu/5MP/213+ZW1+/wve+//2sLK2QxWOK\n", + "LMVSlPu+CoWy9uUrn/aXLjpawpxQq6F1VYrsKKVpRmDNgoNprh69G45ped0ujFCIMiGbHkNa4Zpg\n", + "z+TB9WIafc6sb5UDl3KWETAjRarv22g0Dzl6df31p373MBzPTIhm2K9J9xy1Itosb7sC14PcXJwD\n", + "GChOzrygKRhVE81xnDKetijI0gxbShYWFkiSlOPHTrK6ehIpbUZhSB4qbty8VT5DCIKaj207dOfn\n", + "9wVKEccJt9bWSNMCx/FoNms0GwFCldRDGE3Y29lF2GA7Fltr69x5+iwf/d/+CX/rJ38KWSicLMW2\n", + "JWmUUGQFjpQUUmJJQZHlxEU2Q00c5eAz39PkhHXbmUKii2nGmQJVVbwGTXhQTEGbVfiq5GcNZGAq\n", + "5Kq5qrl1c7BX0ZoeQCZaMs1wHeJotkdm5cSqoNVq8vu/8Z9QUcxg2EOoDKfmU2Qhtm9BnJBbkqSA\n", + "uc4ysfLYGAxYOXMPtsq5+MKXGYcx7aCGIEUKC0m5yMIPPLxWg52tTXauXOeRRx/FzXNe/trz3DHf\n", + "JVtqE+/tMRoO8QKPcRbRufcsXmee/o1NiFKank9Rd3n++a/yU3/jr3P23F0kaVLmzykKcASFyml1\n", + "uyS5otGd577VBTZu3kD0xohckCYxn/rDT/PBx99LkBUMrt/izWjAXGTTsCTveseTXH3uRcI4oZcM\n", + "iHwbT1ncvH6D1IbUlsiiDAH8zm/+AHujHh975hm+/8PfTdv3sWOBowqkKshUQSbKnN9Szm5moJHx\n", + "YZlgRglX6c1qP5d+GGboDX2Nvr+ZOiKO4wOF+lbKzAQPVQelab2V1MR0fJl0jTm+pjHaZa5xse9I\n", + "T5Ip0p8uxinjzbXj0XyuBp/VkMVy5bGYoX+qY/mtaCNd3nYFritYjTaBfXN5PzTH7BR9nZ5lD0wn\n", + "VyBFge25eEKAlDzx2Dt4+pn/jO3WkcKjWWvSarUJFgNsu+TfsywjnEyIk5g8zfADj0ajged5DAYD\n", + "8mGPwWCX7e11bGnTarVptdosLnZZPbbMJByxvbvD3t4Oynf44R/+r/mPzzzDh7/rO3FsF6IIqWS5\n", + "EbNbPtOTZQY9JaboFWY3t9DcotkuOkuhiayPMl91O+lzJXKYzaEy5eymfWEKnh5URm+hnVpCmGZy\n", + "id7kfiSPLmZ+Cn3fo1a/QYl0iv3JrMxhUe4m5Dg6RE3tLx5JAQcrCBj2Iq68+iYNN6A/6hMUGbcu\n", + "bhEOh9TmCprCRjkerWabztIxLt3YYKc/4YH7T9LbXCMXFrYfEE9i/MBD5SVvDyWaqs91sAtYWV6l\n", + "VsCVl18mQCHDkKhICGoB/fGQvVFEWne59/yDXL18jSROSMYhtiP52O89x3/7d/82Dzz8cJmjm7Kt\n", + "bMcizTLiPMf1ArrLS+xu73Dm+Alcx+baa28S7U0IbBuv5rC7t02UD+j3trixs0HamCdf6LDd36Wz\n", + "tIjq79GywfIsRK6oBz7KcVCuRRzGNLwa40nI8cVV7FrA//xP/w/+5l//SeZdDxAElgNpiAUIKciL\n", + "2bFoprqoKnEzFE7/VfPK6/7OsuLA2VhGaGiQIfbjs/UScnv/mZr/Bse53QKvcum/OS60jJvUTzU6\n", + "qjpWqvSsEIIsS1EqObjWtm1MGqkoyhWfpYI2l9fPWp1mQrpS7vMjn63rbj7vrVNIecYAACAASURB\n", + "VMrbrsCryBsOc5768yjnnuM4B0omy8sQHJWngEBZNq7rMgkjOt0l0lhx6+Ymazd2cWpOyXlbFo7r\n", + "YlkS27bw/AAsm95wjBhNyLIM13Pozh+jFjQAGA1HhJMJg0EPncHIdWxOnjzFJI4Z94coy+H1y1d4\n", + "5Ow5asLCkgLpCFILijTDSYoShdmzXm/tga4WLVBVE/YoJ6GJeGdNx9n4cPOeeuBVI0nMe5vPNY9N\n", + "TWKBTv4Ps7uv6N8cFalQPv9wHnWM3WDK/vFKB5RUhFnOaDCiXZ/DC2qsDXfJdraZrK2TWHAjjukK\n", + "l71awKP3PECaK5IwodvpcPP6dW5deRM7S2jNdUhFzmA8IlcTfMshTlNWT58iaLS4dfkKf+ZbniAa\n", + "Dnnttddp12t4bp3OXItRnrCZhYRZwt1L93Dx5TcYTxIazSY7kwlfv3qBv/63/yYPPvowaZ6X++eU\n", + "88P+i5dyMRyNGY5DVo6fZHNtm1qjgd9ukQ0j6m5Abglee/MNvvnBJ+hv75DfWGe8WODWbEZxyMmF\n", + "DnbdxyXlxWsXyaUkkzGFkORKoAREowmNRp2oPyIZj/kbf+Wv8Qef/kPe983fRCcIUBKkEjQdjyRN\n", + "y5BXg+IwrTtT8ZhydtSqX7PvNQVhyk9Vvs3f6ARwU+R/NAdeWq+zVuAUXEyt0Gkk0+wK7yotadYt\n", + "COoz56Z0ULE/cehr5b78yxkQZtIx5rPStOTQq3WttsmfeicmTDu7OrjNTjUVlPlneoddx0MUgIEC\n", + "280G3fkur7z2KiePn+HkyRN02wuMs5D+oMfOzg75IMfzPOr1OgpBy/PI4oQompAkKUU2Zq/XR0qL\n", + "Wq2G53m4NZ/m3Byu6xKGIePxhChM8ByPURTyyMOP8Cu/8u+Z/8gPcWZhEdexSPOMcv8gcASkgjIu\n", + "13hf00NfdQLpdtDXmdSLeU0VYZtooSok5bVT87ea1bBKgVSPmdZDtc9MzrJ6f7O/p6ZtMcNjmsWk\n", + "dexcYDcafOqrn2aUZMwttrGGPcL+gMVGk9AuGMUJ/eEIf6HD3u4ue72QpWOnaDSbXLn8Jo6KUXlC\n", + "DviNNpnlMxr22RpP6C4tYfs1dja2mau36cx12B1P8AsYrG+QOQ7udsDAg4kP3aVV3nzpNRwchnHC\n", + "A08+xqWbV/lrf+tv8sg7HiZO8/3t9iizVhblZ5qmtNtzvPnGRcZhSDsv2N7eRe4J7r77Xm5EBb2b\n", + "64wmY1Dwwmsv8t7Hvond7W3euHQBf77JlWtX2bBucf7cvZzprrC5uc5GNCaV0K43iSYRmRQ4nkeU\n", + "JdiFzbxTZ/PNq3zwW76dX/rEf+A7v+s78FZWCIDxYILnOAh7FgzoPqmGg1apsyqy1X13QH8ZS8/1\n", + "pwkqjpbPb5whUd9HiGl+8SpQqaJiUz5Ni3f2+bMO9eoEod+jlM0pn10dN9W2sW2Loji8TqKq7KuT\n", + "S7W87Qr8KM7X/K5fsLprh1YGprmvConKc8jLXNGgwHG49/67+O1nfo8nn3ycjWsbbG7cRNk2rXab\n", + "s2fPUKvViKKYMAwZDkdMJhMmkzGe59NqtfDsFgKIkpg4Ltjd2SYMw1KRuy7SkgS+T73ewHUdakIy\n", + "HAz56b/z9/nd//RbLL7vvdSUQFiiXOkXheSAZdsHCB4Ox7ZXj+nvpiVSTYSv29AMi5pOgtMFMrNI\n", + "+rBzqBp7a06kVc7zdvkaTCGsTkRmfcv3mI2mqe6aYnKJvnAJ90Z87YVXIIL5QrF7a4tGnpOTQKLw\n", + "PJc4gJX5LiqNCHs7jC2L9QuvMx73aAQSK7CIwgmZcJFuA78pEa05ssBnEKfkqcKte1y/dZPta1cR\n", + "SYqLYBSNyKMY3CbtVof1C1dYEAGj3oil0ycQjk1hwRPveJxe2Efafvm+Aoq8IFc6PM1mMgm5du0a\n", + "rVabPFOsnjzFzatXiYcTnHqN3XiMa4HIC9a31thau8X9J09xc7DNi1/9CnOrK5x8+DyFLZG9EfPK\n", + "YWhZjGyLNEmwcoUQkjRLSnqw0cQWNirP2bhygw9965/lhee/Ru0dDnOew+Jck/EkRFZ8Tlqmqoqs\n", + "Ornr/qxGqZjpMo5SSqZiPMrK+0bKTK8U1T4TczMUXT99XKsck2Yx62E+27Jm5VBvHGG+m6b7qgEE\n", + "Zv2rei7P04NwRo3STYvXsixc1/3/Ry4UmA52M2RQN5A565svaRYhBIUqTRlLCqSAnII8jzl77jTZ\n", + "0xOidMDKsTay6NAfp8RpyvraTRzXxXM9XNdjaXEe27IZTyZEUUS/t4cQDo7jUq/VqNcDao02UkjC\n", + "KKTf6zEZjgj9jDy3EU6Ia0tkmPGF3/sMnW6Xly+9ySMPPYCMY0SY4AkL4QhSVVAu2ZwiApO308er\n", + "W8iZnWqaiKZiNdsVdESK3ol+Np2miZjNAarrVG17HRN8O9Siy1F0jxkmaZrm1aRYptCb9JJlWXjC\n", + "59lPf4Fmvc2J8+d48/kXCIRN4FpQJKSDAYPhCGd5AZuCQW+HpmthJxPinVtE4z3spke73cav14gS\n", + "yHMbt9Fm5cwJWsuL3Lh4iXwYUas1eePiBfauXWfBsQknI1Jf0jixxN54yODCVey9CblMef8Hv4OT\n", + "73iU2oll/uCZ34E0p7BLP4ek3LcSKbGF9vsUvPziS3hegGt7+J7PKJpw5vQZXvris6yePo7bbRPv\n", + "7mLnOe1Gg9e+/goP3/cQq0vznDlxkg984APkdZfNly/w+hdf4uSpU7RqPv08xJIujrQJlcJ3XLAl\n", + "43CCbTsIIUn6Y7JRyPsefifPfuFZ7n34XkTdJ2h61OOjd3k35aU6wR8lhxp8VcFWFaFXZVffx8wj\n", + "dBS1qJ9t5hPR15t6wkS2OsmaLmYAQRVhH4qAOsIaNetsBhloH1DVOX+U/jLb1pT9P/UUilYAt0vv\n", + "WCXxhShX6ZUvqfna/fwhlo8UEssCC4UQGblQ1H2fJ598lOe//Cx3n76TLEpptY8x12xQW6pjWTbj\n", + "yZjJJGJ9Z2dfaTp0Oh2OL6/gBk3G4wnD0Yjt7R1G4xGe69JsNbn//gfxXI9er8fe3i6jcMgwimg4\n", + "Dp60ufPuu/nl3/o1gkbAo2fuwhV5ufmulBR5UW4KUUGlnudN6RTDHITZ1WlV81KHOCk1TS1bxqiW\n", + "99bOQJhFCJqUrVIjVWHS/+u+MhffVMtRg9VcYWZyhVJK0jSumOZlbvDSstqP2thPhh/FMdevXGWh\n", + "0yVoNojimLbtIYqYFEBYNBsN7PlFojCEvGB1cZnrly6iwiFL7QBFytbGdbqLx3HcOp7wWFw9Ruv4\n", + "Mv10wvETx1k8ey/XL1zg5o2bMB7hOzaTyQSvMcdQKZAWblqw4jf5lnd9C5uZ4tr6Gnc2m7S9FuO9\n", + "EWk7x7b2zWo9Ye2/43A4Ynd3l+FgQndunjge0Vzs0Lt2g4ceeoTPfvlz3H3/XdxKYrL+iP54SBYq\n", + "tvd28Go1vvX938b8wgKXdtdZW1+jJW3kJKY732FQCNJJSsttoaQio8CybAgsMgSBG+BZDoFlsf71\n", + "y/xXH/pz/OZnfpek6XJicZGaKDcqEdPqIvZztat934TKCzDiujVA0KCjlA2Nnjkkd6bCKuWCg81R\n", + "QB1KI/1WYYRV5D4FHnoFqOnsn44f0+lq2/bhiJFiqnM4yKsCRa7Qq4ahHGMm963fVY8Frbt0O5jo\n", + "3QRJB2xCxTK4XXnb84F//lO/PdOZVbSnw47Mc/p7Fb1p54QuSimUKJ04cZbyb3/xF/jWb/8AWZ4z\n", + "2CidDpYtcbwyD4Rlyf3g+hxH2jiWS5qk2C44TmnS1Ov1A0U3Hg1R+52llVng+6RpSpSWW6uFaUKz\n", + "3eLG9cs8+djDzLdqyCxBFBnsL2TW73OAFvZzY6MKBAqEolCg1GFO/Ch+T+9+LaXEdV0jFO9wzGtV\n", + "aVf5xOpx8zfmc49C/UfF9WskremfKaJP9yen6YRdFMVB/SVTzvLSXp/nP/cl/FQSbY0I+32EyOiN\n", + "ewzCiJ1BSHv+BJ7fYjLewHd80tEIe7xFx0koipjdKGGARWd5BYuCZDQkdxehv8Vo6xpFzWVsOUgC\n", + "5h2fO1YX2Iv64Dq0al1stUptLsNK1jiWODiTBpeV4EbL5ubaJme8Dv/D3/1J9ro9VGrhKKdU4MbE\n", + "e+PGGp//wnMsLh3DdRv4QZ1+NGGhM4fq99h54w2KeIzVcrl0/Qrh9R06RUBar/FDP/P3mF9ZIe6P\n", + "uHzxMtGVdc4qn0ZSIOcCNuyczSIl8utsxCnd7hwkE9IiLZd3FzmBZSEzheN6ZNJBtBq8eOkip8+e\n", + "4tzxLm3LwQljrDwrdz9yJZktKYSFyAV2IZFAoqZJl0xazVSaGnBpJ/cMahX7iYNQCKbjPCtm5VtK\n", + "yV33P3lIn3z95WcP5OUohPxWlI05KVRpy/LzMMWr1OxGFlPZn13IU/2dWb6R3jUV/GNPfTvqT2s+\n", + "cJgOdL0Dh5nAJUmSg8bOstkQuCntoI/N5pi2LAslBLbrkI5zarUaly5doj3X5p57HqPm10mzjN6g\n", + "R2/QI8tT8jyj0ajTaXVwLJvBYMheb4d+f7KfNMei0WhQq/l05jrUazWUUoRhyGg0Yq/XK1dV+QHz\n", + "c22SLGWv3+PE6gk++9nP8Re+78NMshSBKHNWO/KAA8vzjEIV+0lxSnSDkEgEUOxv3lYW/Y5ZZQlv\n", + "tp84y7anTpGqeVvlGKuoSM/+pnOliir070En7ykqfTLLfVcVuXkvpaYJvPR1eiHH2toax48fZ2Nj\n", + "g263i8oL3PYprMZ1rDCnP+4x2umxtNTGERLXEjx6/kGcYI6r1zZonKwR3+ox3rrB4rzD9mSPdKzI\n", + "E4fClkSxol5r0W4sY51rce1LOwS1BUaTXeZXArYG26SNVS71RjQ6HXyv4PXXn8W1VwgaEteaMAna\n", + "JEPJdm6ztjPhpde+wrt//IcJa3tMEvCVRV4UWFJgGeF1fuDTaNTZ3dtjdbWJlJJOUKNp2SRKcOmN\n", + "11lq1JiXHc4tHWc9lVx97Qo/8N0/zN3Nefq9EZ/497/C2aVjnF09SdLrc3Owx1JYcHJ5ka2Nm4ha\n", + "wN1338nW9ZssBnVSMgpHYDs2ji0ReYHnBYRZTuZYnD1zmtdfe5ljc4+RKcGc5+Lu72KXxjFZLFBC\n", + "YkkLpIMlJGXaVk1TlNarGc007W+LfD/O3jIm5KmCh2J/nAMztMtbFXMRWHU9hC7mRGAqbtPKPIoe\n", + "0rtOmdRQSQsd3rrQDKGtRoAdVaq0qbZuddFW7luVt12BV5e6xnFMHMcH34FDStks1dlO0wcH34VA\n", + "RSFBo849d9/DlWtXue+++9i4dZksz1FI/CCgUfNxXJc8L5hMJvR6OwgUaZrQaNRYXl5CSsFwOCSO\n", + "I7IsY+3WrZKT9VxczyWKJ/hBDYUgTiLS3ZwoinBcF9e2Cbwan/7sZ3jskfNYtoMlbSgUli2RlsDB\n", + "RqmCJIkP6ANpWShZJr6qIuCjonfK5bg6zKlUhFOfwuH0AyY6MIX3qOT/VROvOhno66vctdk3Zn1n\n", + "eVHJNHGSjsHNOHbsGHEcs7S0TDiZYNk21mgDO9wlkDXSZITfqLEzHKJsiTfX5vS9d3FzfZtH3vEQ\n", + "YbbHtbWX6c4tM4x3GSU5Ld/Hkh5Oe47G2dMM+0OCRLB5/Q364R51LyAv2kQ7KWcbqyy1Vsmbba71\n", + "hmRDi5PuecassbfVo9Xtsum6JF7GJBoz3LjBfXce4/FvfhzVcLFjiV1YWHJ/+lXT93cdl16vT7e7\n", + "ROB7pRXi2ewlQ4Zxj7NPPszlr32VwfUhXqcByy3OnX0Xd77rPIOtDS68/ibdBOr9iKzWZyxi9tSY\n", + "3qV1Vvu7nDixwpU05Pq1C7ScgDQKSYUiTRVFCXiJo4jA95G2RVRk2DWfx88/zMc/8Zt81we/A9d3\n", + "GaUJNcfCth3sfVRIAXG+TwGggcB+Dn8yhADbckBAkZfb4iEEtlWmc8iLgjQrE2ZZ0ogZF2I/Tqts\n", + "rKOioarFVNrmNVWHpMlzzy7Wmd1+0LQUqxElVXrjrUBKFcSYpToW9HuY4OePw4687QrcnD3NztKh\n", + "QL7vz8yuVUWhv1dNJjP2U9oW2xubnD9/nl/7xMd58skn6c7XaNSapFnB3t6AaDLGkhaObbM4P4/v\n", + "u6RZTL/fZ3d3wHA4pChKFL+0tES72SLNYqIwYn1jndF4WCo9CbXAx/MCHNtjOBiUyHw4ZKG7wHDS\n", + "58bGNidPHYciwZY6S6DuMIXj7Ds9ZCnQhdICMuvwMTtYH9eTl21LA5HPzva66LaqRrJoRGwqY9M0\n", + "1t+PokqOGkj6GvM+uujvSZLOOGullHiex2g0QkqLLJ3sp+F0ufzlT2MNBmzsRUg1was3oJBs9rdZ\n", + "nF9kd7xLpsZ4fkJvFNAIFCu2za2Jj71wD1YKQZZjd+bonDzDq9FlHM/l3HJALXXIdxO8us2P/vAP\n", + "cunlr2Lbkm/78x/mjY0drl+6hb2X0g3g47/5NHupgmCB69ffwM7HHJ+b5x/+zEcp2k0G/YKG5wDT\n", + "UDR54G8Q+J5PvV5nvttBFRmeG1CIAs9xmdgWnWMrbFydQwzHhHtD2ktdvIU2yydWufj059m9cJW1\n", + "Ny/y6Ps/ACojyxMSmTEKd2lFLu4WuE2fO+46w954TG675IUCIRGFwHddml6dIstwA4+gSMGRTIZD\n", + "vvfD38//+a9+np/8qZ+gXvOJsgy3KHALgS0ssK39JFjgqGnoqZ54J+F4htuVUiKkQBUZUljYUiJs\n", + "i0KIfT55yg9r35bY3wu1arlVi+awq0X7i6qL42A22ZWpV6qbr5RzyiwIKWmgw8njhDicCrt6jVln\n", + "U0lr/aXB61u9r1nedgWuZ0A9+M0Ui7ZtkybTvejMGU03tBkqJ63ZmVAKgSUEUZLQ6XTIlOKdT76D\n", + "r37lq5xcmcd1fHyvgec1aNbreF7AeBKRpRP6/R6FSvE8h9WVZTwvoChyojBib3ebrc11XNclCHyW\n", + "lhYJ/IA4iYjSjLTIGWxtkqc5gVcjcH0a9TpRGhEmMV97+RU6y0u4eUaapVgSrP0oEb2pb4GepECR\n", + "Iylzi5voQLcTTCe0opjdDsu0WI5KEgXT7Gy6VDlrE0XomG/zejO3hVnMwVGNMjEVvqbPppQOQPk+\n", + "nudhOy6j8ZhGe44/+qNnuXRpB0/YXLpwjZYfQBiTS0XHczl/9z1s9XZLBSEF62s3sYoRfTXCqjdw\n", + "VQPHLlBhjyDw8AuPZX+OuxaaXBhcxc8DVjuLnD25wnOf+V2EkxJ057m8tcHl7S3Ov+deetcusHxz\n", + "jn/yD/4RX7r6Jq/u3GK3v0Xb7vIXvu/PUat3iUXASsMj7K2jfOugP7UlxX464SQqt/JrtubwgxpF\n", + "kjIejhht9+ieWuWu+x/g93/112m5LpG6wjtPn+O3fuFXeKp1EmsQErg2t8a7eLLO2sYt9vpbhEmf\n", + "aGPME/MP00GxefUy3soiW6M9PCeg5tTJkxyJwFKlLyibRDi+RZYkWErR2xvxrd/xnfzupz7Nd/3Z\n", + "76BV85BhjEQhioIkLUis0sdU7KdXIEvRu84oVJk7Pi33gXQcB1vYiEKhpEIhKZSgUAVpkqJEGbJ3\n", + "QNEpjghgODoO3JRVfY1pnZpOeF2OWnBjgsQpIp/dPL36THPdgm3POlmroOZ272LSl3ojDF2vb6TE\n", + "33YFbipiU1GbkSnlO0w92RqJHnTYwQIJg2sqSve5QlELgnLlk4Tv+/CH+bmf/3ne+9QTZWTJIGQ4\n", + "3KbVWkDi06jV94MyCrIiYTDsERYJnhfjOg6Oa7OwMI9Sin6/R6+3hyjKZO6+7xPUA6TjUHN9hv0R\n", + "RZaS5ilRpLB8h253gVq7ya/+2sf5y3/xB7HS+EDohSjzD0spEEimbovZeGhdTO5Md/R0ZevhXOFH\n", + "hXIdRaGY39+KEzTrYiJsfW25WKHkRTWdo9Rswn6NcKSc7vhi27LMLidzHNcjLwra7Q5f+MIf8fTv\n", + "PMOjZ99Fb3Mdv3Cxw4RotEVhCVorq+QTRVbUqc0vMih8gpufIQ4ztkWdvLAgH6DsmEke47faXO3v\n", + "stu7waluk2AiCfOC7XCbrZev02l4nDt5B/EezFlzfPnzT/Mvf/Zn+bZHHuZbV+6HWopdEzx114P8\n", + "3u9+nA999w9w72OPk3qQ5js4qYcvLWJpIfaTIlGUERxFXibvD8MJN65fZ2k5xfc8Egt2wgGhBS/d\n", + "uEGexvh3nWb70g2iy7eofflFnnjgYVLXZi+aMCLjhVuXERImW9vkeUwsIkaBx9pomzu7d5InKS++\n", + "+CK7ElwnIAia2JZHq9Uh8GoUKqfdajAe7pHnGSmCZneRWCiCxhzPfPL3+MiHvps4j5GqfAclBZbj\n", + "gJRYYuqbKn1OLrZtkaTxwfaCiBJZW6ocm0lS5jhhf4d7KSwsUSAF++2TkyqNkDWSPjoKRW9ePEXr\n", + "6v+m7j2DLEmv88znM2mvLdtV1W66p6fHN3pmgAEIYOAIgqSAAEYERO2SIQXBXXFjpSDXKDZiRa1C\n", + "DDGWYoRErqgfIhQUQS5FCqADQEI08I6CH7gxGNNm2lV32WvTZ37f/sh7q27V9JAMShHk5p+qupWV\n", + "tzJv5vud8573vAch9jPx+t6cvZcPFvJnv87qxuv33O8m3g9katXJLPVSf89LnotZPJulXmatCWbf\n", + "f3ZR+P9FBH74IsyCw/R3sy2nsynKYQCabvsaF+qU1VqqssQPA7Tr8PBDD/HVJ55gbfU4c91F5hdC\n", + "sIper8doNKKiHv3U7jTQjkOjGUwohfqhyyfpV7vdYml+nrARYoyh3++ztbVFlCRIK+m0WizMzwGg\n", + "HZdREhFlGWHYwHM9nnnuee4+dRIlFH7ok8RjnD0ToalzhgQB4tACN71GruvOgOMU0NkDxtkbaLod\n", + "7nqbvYlm+efpa7N/M33t8N/ePoI/aPy/z++ZAw9R/X/vR0lFUWCpawNQ66WV1vzq+3+NTrtL1xNk\n", + "IsdVJZgKtxEyzAqGueGJp59nUBqWjpf0R2OWkg1OhB08U5FLw03j8GISkjoea50FQtHHu2Oe8sQr\n", + "WH/qT2i4gpOn1lheWWK43efFizdY0i5bX/scP/fed1P8vXfwi//3v2Krs8nFbz6HWH6EZatRruD7\n", + "/vbbuLLdRwZgi4jCJFRinspOfF6YgJ8FgSD0A8bjEb3dAbdu3eKpJ5/EXZ5jPB4z32ghGwGFsKyd\n", + "e4C1haMMrt5gtN5nZ26HD118guMnj7HUWGJMiXAEw80NTJognYpRXvGZJ79CKSxnj5zkvrDNc71t\n", + "ml4TvxFAo8GVrZtc29yi2WxSpBkNx+H00WNI5XHp4hWMtigUzaDD5cvXWW13aIYNXCWJspSyrKhs\n", + "VXeaUuFoB6EdKgkWSYEAqZmqM0pT4VMrV5TWtR59MqXdmoo8zWrFlJR1TSnJJ3YMdS2qLG8fgbuu\n", + "M8GLahIw7N/nU/CvgXNfRji91w432MxGzbWwoDhwn0+POb1/Z6nJ6b63yzZvV6u7Hdd92E76L9r+\n", + "2gF89gQOn1AN5rMOd7Ue8zDoTCPO6WchOXgBhJQ4WiMRZEnK3WfP8ju/920eedVruXn9Jp6b02p0\n", + "mZtrs3xkkTTJyIqMylSMRxFpEtNohGitSdOUPM8oy4rxaIiacLW+7xOGAcdaTSyCIi8Yj8aMozFS\n", + "ScjSWl0iBVGW8OhDr+TTn/oEZ0+foTQVcZojpUY7mqosa3mirY32QWAqg5lped+TWt2mNbmOcg9H\n", + "DS+1KpgulrOGP9NjH64pzC4ELwfchz/Hqtqnxm7Hk88uxq52yMt8EmXVo72KokC6Gqkk43HMm970\n", + "Fp78zpP0yx7raY+B7zCMBaO0ZBiVrDUNc8WAcnidsnqGRtrjkmxjk13ag012ioRvVPM8GZ2k7YW0\n", + "qm9y1/wGN7Zznr3s0W0UbG72aW1LdjZeRMiI+ZV5RLjMN3aAGzli/AL/6B98L8HqBbaG5/j0F9t8\n", + "84kd/vH/9S+50t+gcgJMJRGEGCWo/AbGRrVUbvpZTFKrF154AWHh3LlzCKloNpoMszGtU3dybHmV\n", + "hdVVgrkODS+kg8vnf+8P+dQf/CFFP6azsMAj3/9W5o6vgpRkNueFF57lT37nA/hVQRC6xBT8lye/\n", + "zujaLR648x7OLyzRzzKyQY9Td53i/KsfYigsVrnYyqILS0v5CKGJLBSmpLL1pJhm6BNIB1NkoDVa\n", + "aEaDPp4fUsqi5t/T2pEvyxMAWq0GXhhOgguDdDS2Mpi9z72iKiukkDVo+xrX92sgrgy+7++NGPvz\n", + "RotNDe9m77MD1OpMYXCWsp29Bw/f8/v8/cH7u75/a0OuPXzZu6dv39Q2W9Q/bH0x+yzAQd/1v8z2\n", + "1w7g0wjysJxmenJFkSMmYnnYj+Rmedvp/o5TG6IrcdA7uMoLPN/D2Do0X5xf4NxDD/PFL32ZV73q\n", + "Ucq8JMkitm5dptls4/s+3e487e7cJM0dkRc54/GIoigIw5BOx6fdbE44YcN4PObixRvkpcFzPdqd\n", + "Dt1uF8/z6o7O4YD+cJckSVDaxfE93vSmt/DT/+xn+Pmf+1lcKcAUpGmCoyQCUXPeoq7KG2GwZr8b\n", + "cXqjTI3sZz/w+gYrD/B/dTp4sANteo1np+/Myg6nN/esk9ssrz3LHR4G5XoTB7jF6f6zFMr0f8vS\n", + "jIpq8qBaEBP7zrKoMwo0r3nta7l4+QpP9Aue3crZHqWUMqA0Pm4QkgwT7nMNdy9YuuklXLvBHz6/\n", + "wrNiiXN3v5FMpgy211nTEhEPeObCJcJ7JGeXXNzkq/SCkkvliMhd4Wh7gfks48TaMh95xvBFjvGv\n", + "P7jFa9RNfvH1Lln7BnPBGQIj8fQKn/nK8/zEP/whbl54HqesKFWDQZGiPYNjDdYU6InDnlD1CLNv\n", + "fPMbaK258uKLLC4vsbW1wbE7jxG0XFKbQFlis4J+NmCnrHj1O9/Gte11hnnB//kz/4zcd9jt91lb\n", + "WmVYxBw5fQItLZ/4wAfIxjGZLXCU5rn1FzGm5OTpk9x99m6ubW/z3S99HoODBAAAIABJREFUgaP9\n", + "e+mcOoXT6ZKWBiV9KhQYcJWuhztYiRYGbTVxlqO0S2kscWrwvQ4C0G6AK8XEErgeyeY4it3dbZ57\n", + "/irD4ZDl5WXm5juE2qesSqSwSKlxPR8la9e/vCywtkILjXYFeV4SThaA6cDf221Ztt8ENgXew9La\n", + "6c/12LKXBoGHwf+w6m02Wp++/lI68/ZDmmeDnOkQh9maz2xAdvj9/iIJ5V97I89XvvCnLwGA2ep1\n", + "WaYH9MizIH+YN3ecoCa49qrZ9QVwHIesyJFKIZVCSEnlu7z/V9/P2TNnWD1yBG9SZMnSvO4mQxCG\n", + "TdKiJAx9XHdf62qtxVb1XDtraxpjyg0LVD3RJUlIixzHdZBK4fs+nudRTSLmKIrZ2O3TXVpm8+YN\n", + "3vKG12HLDJslKCEmMsJJukYNymamKj+9Xocn9NQ3BJOM5PC8zdu7sM3emNMo47BN7eEb/jCdMz3W\n", + "QZ243Wsiml0kbpcRSKsRerooFBhRe7DHSUaz0WYU5TQaLX71V9/Ph5+Map4UgeOGxElOEcXobMSC\n", + "HnN23nJqrmDOSdlZuJsXbxmujVv0cnCrHifcnIZSPLuxS3ch5PULMY/yIldwSJgjoYspS1Y9QwOH\n", + "uHGGS+EpdpOE+6sN3hUMaD+yRbM7R1wd5RMXW3ztVpvXnH+EV6+WdPUWSTNkU/hYJ0DbHGktEomw\n", + "oo44kezu9nj2u8+xsrJKWdZuhUZmFKIgiTJECr4MuD7qs1vlFEXOye4C836I8hSV0QRug0pAs9vE\n", + "DzVNT/KJ3/0gOxeep+N6DJKIWFrQlk7oce/JOzl7/DTJMCEpwV9cpnviFM21E1ivwTDKkFrjupoq\n", + "LZAGHNclw1I5iijLajCtLE5pUUJhXA+ppvrqKXgZpBKISWFeAMPhgKpMieOElSNLBL7LjWtXcB1N\n", + "4LsoCaYqMZN7OtD7i/6UWrjv/GMvwZNnvvWFA0Hf9F6cVZRMsaKW1ToH9j0crEz3qwOMg1RtfZy6\n", + "AD2LV/V9fXssnX1GDwcxLxeBzz5rDz7yZuzf1Eaew/alsyANkGXJS0BkmorAQclhUdTAq5Wqq95S\n", + "gdIIKWg1mqR5VoO3qciLgte/8Q38yX/+z7zn8cdxJ/TI3HybZqNDWRqSOGOnf5Nr117EdV3CMKTR\n", + "aNBptwkbAb4/R5qm9Pt9dnd30VrTbnXwPZ92q4VV9dCH3V6Pq1c36iYlpem0WiwvLtFZOMLWaMT2\n", + "bo/19ZscWegSBiFVkSNF/aAbwFaG0lZ7dBLMypxuV82uAX+W055GzNNtehyl6pl9+xlPbYzv+/4M\n", + "D7hviTn7md1Om7+fZlqUOiQjm4lKptKv2UgjHacICY1GSFZmaK1YWFigLA1ra6vEccbp06dxvnkB\n", + "TEGrEUJV0dYuiasZ5h4Du8iTQ8NTvZhmQ9G5+kk0kPYqIn03Q+8oxbjk9edOseqt8uSz1xk/P6B9\n", + "V5dX/eDd7Dy/wQvfvEDZWSG68zTXdy+ycO23eXwF5t2CU2cfpDfSZLuLLPkbOI1L3H336ymOvpWn\n", + "v3qTe+/LWFu7wXZsWHvwDdzcHeG7IWVRYitb0yhSo5VmaWmJI8srJEmC63oYY5EmQkqL0i4MSxr4\n", + "FM2QLd9SugodZThxyjgakUYll69vcPHWdT78kQ9hshjPtdx35zGWDTQqBdpn6JfcyHdppCP6z44Y\n", + "bW6z4rSZby6w2FoivraB9bo0js9TNVy8MOTK5QvcefQE494QX3ukacIgGSM8F+l6qMJgsowkTbCe\n", + "wHFdLFNbDAgbIUIIiiIlzytarRbtjktRxgTNEuV5oBV33n0foe+zfuMK169eQQrD0tISzWZIGY0P\n", + "NPa93EAH13X35HezAWBRFHuqqdkgMIqiQ8/LS6PgKTOg1H6mWRTFpGltf7DJbMCi9UGnxtmmw1l5\n", + "7DR6v13WOn0m/rKFzL8wAhdCvB94O7BprX1w8trPAP8jsDXZ7aettX8y+d0/AX6ceijTT1lrP36b\n", + "Y+6FyV/87EdxHGfPjGZ25YH9NHt6sWaLYrNdgtMLMmskv1+8eKn+ODQukTD8yu99AK/V5J4Tp2kb\n", + "j4Yf4LYajPIcrTQN7aFcjXadPe1or9fbA0+tNY1GAykleZ5Tlvne/zD7oQVBMBlIkJOmaf1/W8Uo\n", + "GhP4Ln/2Z5/hR/6799BqhGhhqYoSz/Opinqohef5UAtu9iOHCUjrybRwJmmsKUskhpqVsxMJGzi6\n", + "jjwkIExd3DUWykpibYlSgKgQwtSaXWspSxDSQSkXWxlkMUJIF6tdKu1QGEFlSrSyKJvjqhyqDIXB\n", + "GhcLdQettQjHxdEepZGAQkqX2h5AUbgVvqNZv36dyxcucmtjm8EoI60kl69eo9XqIGTdDfjkDUVp\n", + "KhzfBSkZRONailZaRGHQRtAJ2wx3+2RBQlkZUC6O41GVOaqKOdKSrLUsdnCNk/Mucw3Fet6DOOfh\n", + "E2doDWLM5i4mcNj0QuLWPEGjwR3zHie7cLSzS+vImKaj0OMOwp9nfShxWaTlwxPXN9jy7+fsw29F\n", + "6Qg/NyhVMApjUuETEkI5QMgSz2isgb52kcahKd265b6q0FIxNR8DW3+eE8WFI0IcKcGMuHjheX7t\n", + "V36TKxdvsTDf5cFzpxgM13Fcj6efvkwufUTocbzbZtnROGlMJ/R54BXnaS6t8Z2LN9CdZfBaHD91\n", + "Bw+cv5u8KBgMI+aXVhj0hxRVRSNskqUZRZETBAGjcURmKsKgiRCCPMsRQiOoOy/LqqDZrBVaeVlg\n", + "0nraVRAE5EVBaQo8r5703mw3sbai1+uzvb1Fu1mRZSnGVjSbAVIKHrn/e16CUc9++1OY3EFISVkW\n", + "uL5LkiZ4nlN3dtpJtkwtmfWFQzVVAwlZf2/rxdWYCiVATtxMLfIAtkyNuaZe4LPbdEjDLCUzG+FP\n", + "vx62jp1i2mFHwul2/0NvfNkI/C8D4I8BY+A3ZgD8nwMja+0vHtr3PuA/Aa8CjgKfBM7aevrn7H57\n", + "AP5nn/6Dl+iQZ0n+aYv15O8OAONsmi9l3VY+W8Wd7uM4++A73bfjtciEZSwM//qX/g3vfsfj+EYS\n", + "aJ8CS288Is+Kekq3kvh+3XQxpUs8zyNJEgaDAUVR4Ps+nU6HbreDEDAYDIiiiCiK9habRqPBwsLC\n", + "BBhL4iRHKc3G5jpCWJ797lP83R9+D4KKdtisi5mVIc9ywkYDg6Wsypprm1w/rXQN7LMcnaj17xPF\n", + "V30tBVRlhQAUk0jBUutwbQZm36BeCkFR1IUkrTRa1x2qlTFIz6HVCOjtbBH4LlWRo10Xg6QQCqs8\n", + "cDzCZoc0qaf0VLYgzzOyPKGsCoQ0lKYiGg3Y3tkhjiMGI480jvjW179OHMfkhcX1G2i/jVCaNEkZ\n", + "j/qMR33wTlIag/Z8rJBEaYoxJdiKZDQgdCVHlxZYXVnGVT5bO7tcuHSN3EiMkGALAlURqhxZ9PHK\n", + "iKW5Bht5i/Gw4vRSi7edNbTG32TQHzGSqxw5dox5fYvT7Yy28GiHKzgn+lReBlkTf6HFRp4zLwKa\n", + "8Ygb0X187db9dO4MOXP2PoQyxOkWrbbHuEgRHEOXHlq/SKYLquI4bgWoCCuY+KZU6EMZTmUNlS1r\n", + "jgyHLEkJfYmrFE9/+7v8q5/7Baqi5MydRzmy0mFnZ4ftrQFDq4iwvOa+eyl2NuhoQSvwuP8Vr+Ds\n", + "Kx6hc/QO/uW/fR9ff/I57rnnXo6uLnL+/MO89vWPkWQFrusTxQlRFNUqL1tneb7vUxjD2upRNjY2\n", + "MZWth6JYy3TiTpJEtRmZBaVcHKfuOA7DBlu722glMdbgerUqZZr9LXQ9lJLEScwLLzxHnmd8/5t+\n", + "4CUY9cQXP0a71SZNUsoqx/W9Pd5bKYVFUE2jXSnQlaEyFmsFRkyFAlPsMRMABzAIuZ8lTqNwEPh+\n", + "sIdRU1zK83269+AEoINj0oCXYNfhTHo2Mz33yrf81SkUa+0XhBB33OZXtzvgu4APWGsL4EUhxAXg\n", + "UeDLL3f8acffdGWbed8DlePpa7Or4WGlxPS1Kce0x0uL/cafvYtdVlTWojC89Q1v4Lnnvstjr3k9\n", + "27c2KdOCY0ePol0HKyXGWMbjMePxmO3tLRzHxXXdCajXE+yFqAuKV65cAaZRd8jiYrhX3EnTlGvX\n", + "rlNVdXStHRfXgeWlI2zvbDG/eITnL13h7JnTDJMUU+T4k4lD43iMmHRoCilxlN5LxaY8//SmUFLV\n", + "TnGmLgYaLNZYtOMcqBHUMYZByLJWBmCRQiNQhEGDIq816oIK1xGgND2jEUWB62scmxE4hijus9FL\n", + "2U41z60PuLg+YBCXJMl4n19kEoFYg5C1c52SdYqqlQbdJI1jRPs0rTmHJM0prSKz9d9WXoIrQnRV\n", + "d2e6XoDreJRGEfoeaZaSZ2OarRZl3mPxWIfSjNBpgUkjqFKE1RjhkBWQIIndACUc5uZOkix0ORsM\n", + "2YoqLly5wuKmz+uXj3LC67G+lbBxc5dB0CHp9Tjl7FC25pFOQtCEVpqByfA6Bpx11NyYYXSO1tHH\n", + "+eozH+LIwjPo1jHCxp2o8RbzqmQoYrSUhGUL3+SkNserSnJRkalJOi5cMHYSnBQw6fRT07qINDQ6\n", + "YU0zIrnngQd43Rtfy6c+/gmiJAWOkGeSPC9JihSn1WYwGnHH6hrDjes0XQe/2+ZL3/463/nQ7/ON\n", + "Zy/QyzKevvAMN280OX78JMPhkGa7ixCC1dUjlMWk/V1JtJKUeY4Qkmg8Ym15niIv9jT9o9EQLRxa\n", + "gYMf+PXwk6LcKyxu76wzNzfHcDSgO9chjhNcxyPPExYWFxgORrWMUGjuOXuO8mWaaoLGEnHew/Ud\n", + "lA3qoG1CSVlbK9ecqUqlNKBqu2lja6EAEzMta20d6UwicSx1xjYBZMdxJnhVH3M2859i2RSPZmnH\n", + "mkoq9gB7+txOQXs6QHyWaoGDQ8lfbvuv4cB/Ugjx94GvA//YWtsH1jgI1tepI/GX3abR6eGhpbNp\n", + "xGxRcwri0+LYLA87LVbMXoTD0fv0GNp1kaWhoVwefcV53v+d3+C5y89z54lTiKygShOEhJu7W8x1\n", + "5wnDgHa7hTH1JPPxeEwcjxmPa/OpMAwBUEpPlCsJaZrvnUu32yUIAo4cWdk713gcIbRLFMUsLq3g\n", + "+AEf++QnaXW7rC4v02k1iQd9fFdjSgUzFeo8zzHWIiepWbknPbRUUmEmEj7UtFGi1t9aUTc6TK5y\n", + "fZ2MRExoDaTCWEiKBEdLtBYYWyC0RWoH1/jEyZilboenv/kEUgpOn7mXtufyod/9U3YSTWobtOfX\n", + "0MFWXRC2GonGGkmZG6zZz7IkAmMgzVKUM4c1higriHOB4/oo160HYFQlVZHgKJcwSBmOt6mqHC+Y\n", + "w1E+SVmhpYPEcPr0Xbz44hWkLGnYkK3dHlEe1dmB8ml0GlTGoh0X5Si205SdWztIfYujq21O3LPA\n", + "+qUbvGibzM9ZTq+lPDFI+GL/ONlonlfP9Tm6leKmJadW5jirQopiSF508ZoO7lGHCJfPPXWLG5mm\n", + "GX+LKu7x5M4tHjr3ALrUtEJDZHukdFC2BLXNyIYI6SJEQVVWmImla2VqgzJrbN0PgMBgSbMIx3PR\n", + "2ifLKgJX896f+DHmFtr8yUc/zmvXzrC1PaLRzkmHQ7JxTDEYIdr1UIcjyysYA8PhmO8+9yzNRhcn\n", + "7FDmhnvuuZeV1TVazTZSKXZ2drly9Srdbocjy8vcuHGVViPEc11u3rjB1tY29913P0HYwPc9RqMx\n", + "a2vLmMpMFhhLkSU4novnhqR5xtLSnfT6fU4cWyNOEtrNEIQgdHyKPKMRNImihEazQZHnlC/jrjqK\n", + "DWHLo6QemIGsfVtkZZnCn5xcM4SdNP7U0mOo6ZO6C1oirMLaak/9hSn2gHqfPhF7hluzAFuWxR7W\n", + "zP5utqdi+uweFmDMsg6HG/P+vO2vCuC/DPyLyfc/C/wC8D+8zL5/LkfT6/X2ovBZMJ7liaYneDvP\n", + "cDioZz68uk2j7+k+QtQDRkdlhoskj1K0dnj88Xfxb//9+3j3Ox+n2B1xYmUNJTzOnL2Twe4IYwy9\n", + "Xm+voDI/P78ncTKmlhHW5+LRaDTpdrs0m03SNCWOY7IsY2dnZ4/rX11dxXUc8ixlaXGJ6+s3ac7P\n", + "87YffAcf/N3f5x/8+HtJ4hENT5MXeU2HlAYpanWKUqCsQEu1x9OZqYmVFXhTM6paRg5Ysjih9m+W\n", + "kxSvjkBU1Zh0/oBQktJWIKCQhixPEMLgKocyScEI1q/f5LvPxZx/+LV846ln+X9+9pdJcjh1533k\n", + "WcVc12P72kWC+RZaOSjpooQGJPj1++R5SlqmaK3QjsKMa97UCIGWlobv1OPnrMVTEuk5COERFxGe\n", + "Wxdqs3xEEmXMza3QDiSVUfT7Cd/46rdYWVlkHI1xGopSeHjdACElRVmhNCgEVZWSJxVKaYyxPDk+\n", + "S3Z1lzeeDugerRjk26wjWa5S1ppDbla7fHXQ5UPXV2nmGWrH567LI35oreSuVYugjYwb9Heeojtn\n", + "+cKXf5Mzj57CKzK0eYqqOsO/+u0x//0Pv5PF/Hmsk9NzDFZZlNVUSuGUFmeaJFUGpRVlUaK0rjlW\n", + "Y5m6Jnuug1aCNC7ptBZIkwGVLXj877ybcWTxW4sY3SDowv1rq5SjlCNzHarhmGNLK1RpSTxKuHLp\n", + "Kp4IqIzixPHT/PDf/VEeOf8w19dvsr6+SavTRQjN8vIRsJaLFy8y123jeR6eVw/LfuihV9SfL5Yk\n", + "TSY0iSXLkonyyrCwvER/NGZnZ5Pl5WXyLGF+fo4szeh26yEpw9EI3/VqSgUPfyEkTdO6wCtuD1f3\n", + "PnCebz35aXyvbkPXUpKXdcs/1iKxYOuIWkqB1Ko2kqPuHVHU3Z/WGISsJZ7CTrHIHMj2972G3AOg\n", + "W7+2r0WfUi5TDAJeEk0fxqlZ8D4cgL7c9lcCcGvt5vR7IcR/AD46+fEGcHxm12OT126z/QwAv/XB\n", + "J3no/AOcP3f/AcXDbFV2KuafvN9t043pBXMcB6313rDj2Qs6/SDSNEX4Ci0cVFWD3NqRI7zr8Xfx\n", + "3HPP8Y43vpVsOKYocnbXr+OrEM/xEdaCsZRlQVWUpHFCEAR4nkun1abTapFmBXEUM8oyiqxeabWU\n", + "dOYXWF5cYjAYkCQJRZZTTiRZvd1dOp0O/UkX6D333s+zzz/PufvvISsz3MDDFBWeciZ+0vUTvrdo\n", + "SQkGHOWAnBhUFXndQMT0JrA0woCizDFVRVUZrJVgJI4NaoWLrhCKup1aGYTW7PRyxuOEufllQr+N\n", + "yjPWjt3Ftz//Zf7o332Q9tJRVh94DImkiMYoBjRERGtJs4PcM+YS0tSdexiU6yBdiSgE0ldIR9OV\n", + "AWCJxzG2quqGHrnf9FCWOUqUNEOHca4IHEWZJcRRn14VIaSD6wQ0PUHn6DG+//u+n8985rPsWBcp\n", + "C/IsRVlwJMgKTFkgrcBRHrYAi2K3FXIxj2ldu8VrzrjYQclT1wX3LdzPMbXLm7x1bHPEl5yHeLpY\n", + "w3WOUg0usdUZc3QUI0WPuKhwWprnn/ssneY8ZqdDVrQ5enyHc13DU+O7+Y0vXOG971qhnV/Esz3K\n", + "QtLUmspcJ8l9hLdIs9UhyzKsNVBRO2WruuHF2pq11dJQZQW+DMmTnKq0GCGohOQnfvKn+Mynvkw/\n", + "yylNTFlEHPECsnhI06u9ZRZWVugNY3Z3I773LT/I+Ve/nqA5B0Jy6dI1kjSj0WqSpnUBUDuQJQnt\n", + "doelhSWCwOWZp5/m6NoxsqzED0MKY6h9XiyjeIDnuKAUWVJQleC5PnNzmrKsay7xOK4L/BOri1aj\n", + "iaMdirKE0uIogddqYBsBcbpv9DS7bfd2OXX6QaSA8XhEf3cXU+V0Wy2qMgNT2zYbUyGFJS0MWtds\n", + "YlXWHu316LR6yMo+jWIQ6qAlbA3C4kBAOMWiaSfmNNic1vYOq0lmm3kOA7ZSiq99/Vt87Ylv/bdR\n", + "oUxA8w7gozNFzFVr7c3J9/8b8Cpr7Y/MFDEfZb+IecYeepPZIuZnP/77B2wdpxdgst8eeB8m/Keg\n", + "7LouWmu2t7dZWloiiqK9KDlJEqSshxpUVbXHW2utef7aJRbbcywEbYIwIJMwpuTTn/oMgZWcXD1K\n", + "u9PB67QZ7EY4yqmbcJTC87y94cZRFDEcDsnzfDIYubWv+a4qomhMmtbRd6vVrEezTSiXqsi5eesm\n", + "VkjSqqI0lqDVYGNzk0sXnuNtb30zx9aOUOYpJstp+w3SNN0r7CqlKIriQDs9TLm4+vdRFO3tL7Xa\n", + "y1KsgKIs8bSHKBysqoiyCBUq+nHEsxcuY4RPZQLiCIzxGI9iWk5CPy24tjmis3oS3JA4L8mjAaqM\n", + "qYY75KMdFtoNxPwqBkVZWhw3xBhNXgnS0mKVQ2EFUZqhPA8/G2InLnSBF1AZyKuaKsMU2CKBIkJU\n", + "ObaERjOgM9dGiILd3hY7uzv0ByN6u2OU9Dl96iw3b24xtCFJHKMlVGWBMBWmKiczFGuwUY4HFvpu\n", + "jlY5QXKNh9sJDx2Zp0wd0t0hp9nhWDBkw23xJfcMcVLRXThL1RuxWvXxnRTTzXn4jMciu3zpuct8\n", + "fbNBp/EW/vcfnuPOuQsIt8ET/TfzRzuv5umdK/zD99zBcrLBnAwwNiaxGX/6ya/z2c99mWazwblz\n", + "D3Lfffdx4sRJjJk2s+xnT3nUY2lxgd2dBPBQHjQ7Pp//s//CR/7g47z97e/ht3/nA1iRMLx1mZXA\n", + "Y77dwVOaRqPJKCs4dc/9PPSax3j0sTdz+eoGeUF9Lfo9Hjz3ABubO7TbbcoqY2dnlxMnVjCVZTQc\n", + "sHFrnbvvPouQEDba9IcjgjDEmNofX2tNNB7TabfRUpImKV4jIAxDLrxwgbvuOs3WxjZhWKtUiqIg\n", + "z3NcxyFsNMizmEYjIMuKuttSaLpzB6fEA1y6dgtJbZjluS7N0OfatRe5cuUi3VZIo+mCzamqHNeR\n", + "FOW+6s13PYo8x1TT7HaS3kym3EuHPcpztpY224k5xSoh9u1vZyPq6c+z+84OAod9mnhKh85q088/\n", + "+tb/KhXKB4A3AovABvDPgTcB5+uPmsvA/2St3Zjs/9PUMsIS+F+stR+7zTEPyAgPk/Wzq9Hh16cr\n", + "1vQkZy/ArD55+nvHcfai7qkMqKoqMlvRDhrIyZCIUkKpBRtb23zsj/+UN77+MeY6HaI4xnWamOrg\n", + "UNdp9D87mHRWpD/VqnuehxBiryNzWswA0EphrMHxPJR2iLOUrCgYjAZIKXjqqSf5vre+pZZh1ZwB\n", + "ruvWN7nrUlYlWjuUVYmQcu+9puc+nWbjOA55PimiKLk3GKKyhjIviUYJQSsgLXMKYWl05xE65CMf\n", + "+TijEWSxJs8UrhdgnSFZWXH0+Cm2dgY0Wm2yLEfYktAFk4/JkxFZMsIUMVla0Gy26wjZa6DdFuiA\n", + "Apc0l5RCYYSiEDFlnlGkKZ7jkKY5yg0oTe1jU+YpVRZRlSk69YiTEVUVYUxEUQ7JshGe57JxaxPf\n", + "ayKERiuPPJf1MIVJeltTRQKErie+CIV0PIrCEBpN5hq0TpgrdnhoOeBkF+bcmFZ0C9m/hXU94oUV\n", + "7sqHDDnCVXGMZ0ZNvrhekDRy7mxH3FNWHHUHmPISc+EKP/S9ryBYKImaCcI9y2996RwfvXkW5vrM\n", + "Z9/mpOoTOIru3H0MNi9y8/rTCClYWFyssz1TkWVZrXLqdAkDnzAI6DY9Os0mp06d5Stfe4KrN67x\n", + "5NPfYaffZ3Ozz7lzD7G+fgNjc1yZ0nANaZQw352nMtCaW+TH/+d/RNCeJ2wtYFEEfsDuVo+mH1JW\n", + "Btfz6k5HLel2mvT7fRqBw61bG6ytHkEpSbPVYnu3T7vTYbc/oNnu1M+BsCRRgu+6qEnQ5U6CnjAI\n", + "MKagKOrnL/A9oihmZWWJjVvb9Ps7FGVM2AhZmF+qpbpC4AfBSzBqEKVkaUWaJCgpKYuCdifEVBWD\n", + "/haD4RZ5FhGEDmWZYcq6C9J1dC25FYJqomCTe00602dkRs2yl81P7SoOBpNKvVRRcpgKmeLULA08\n", + "G7AejuyF+PMbef7aOzG/8KmPAPsXYxYAp2A8q+GenvAUnAAajQZPPvkkr3jFK0jTdK/t1hhTD1SY\n", + "0Cmzf58WOVJIqqJuN9Zao30f4bts9Xb5rd/8TX78R/8+490+RVWD3vxcbVwF9Qdy/fr1vapyHX03\n", + "6HTqm3dzc5PBYECe52RZRqvVmkzyCdFKU5lq7/8vinqcmOM7+L4PUrKxuclgPObCxYu8+4f/Dj4g\n", + "0qRelLQmrypcz0UqySiK6HS7ZBNKRjsueV7VUU2e4+j6WmntIrXi+o11+qO6wm8sLK0dByS3drbZ\n", + "6Y955rvPs9MbM+gnrBw5TpVBGDQxSHpmhBSSVtii4TeIx2MC1yPPcypbYKQhy1OSNMbrXWccjVDK\n", + "EMdjpBLkZUF3YZm5pRXcsENhIMtLtljGsZBFI+Y6bWxlcfwGRrqUk0g8z1OKPKfol2ALhM2J4x2y\n", + "pIe1CVE0wJ1077VabcZxgh0PsUKiHYdRHGOlYunIGtoL2O0PSbOCNC2oLFjH1KqVOENJgaMqjgYF\n", + "Dy8Y7pnLccWAOM4ZDEr6zjwdv4N22vTVca6ZI1xKRjx/9bu0U8XbTmru4gkeOOriHXuY66v3s7Nw\n", + "Fr9QnD1+nl/43ctsd+4nzZ5Fb34VuX6dexebjMdXQFWUVUWr0wZrGcVxPSWq0wFgPByRZxmeFggq\n", + "siKjqAyNRoftnR5pmuJ7HloLyqJACU1pYrxQEI3GpEnGT//0P2V9c5tPfO5z/B//5J+ysdnjzOmz\n", + "2NLgSkvgB9y8tUWr1WJze4tut0MzbJEkQy6+8DxHj65x7Ogage9RVhAlGVYIXM+jqAzjcVRnolox\n", + "GgwIPJ9GGJCXJUEQEMcx29tbHD92bKJQqvjQh3+fj33sY3Q7HXq7PVAFt27doipKTp++k3e+8138\n", + "0Lvf8xI8GacZjqylrtbUIJhmKVJaHEciZD3c/IlvfI3V1WU87WLKMNFkAAAgAElEQVSriiSJ6TQb\n", + "DAd9HD2hViddsnt6bHXYZ18jpWIK8FM8qQUUt8U6iqLYo3CnyrjDlhRTgJ9tsZ++799oAP/KF/74\n", + "wIlM22anUfQszz3dZmWDk+PtrZBTTTbUqY/v+3vANtVwZ1kGpcEoSWUNrnYxWVFH0Z4mkoZPfPIT\n", + "BEZyz9pJgs48yt0fNDz1MvA8by9DmH4IZVngeT5KyQmVUc/arJt8SqIo2h9iIRXacerRVliqst4H\n", + "ISiAcZJzdX2d/nDMW9/4GEfnu2hHUxRl7eJmLRX1NBupFEbU2tv+YEieGcq8YG5+nq2NbYKggRCS\n", + "RqtFfzhGOhrPD4izkvXtnCtXb7DbH1NWYI3A0YosHpJEPapizPJCmyRLKBpLaOnQ8Fp4KqDMLFVp\n", + "kNpBaEE/GuEETt00EfXIszFbWzdQIgcKiiKtlYzSoTN/hDQ3zC8ewTSPojGkwwEt36PIC7LCkltN\n", + "aRV5ZSnKiTRLGOLxGGktypZUeYawBZIKz1V0ui3SNCLLU3RekmQZWVHgBj5hs4W1lihOQEh818WU\n", + "tYXvTjWgbQUBkriybI9i5qSmE/c5ElaUdgTSMtwd8rlxkweOhJxfatLrp9zcjtjojxi7AbLhcH/L\n", + "clpHLHQDhksn+cZ6yFZ5L0ZYOs0N3vS9b+eL38qhGbDWKbj19T+lm30Lg8LIDsPRqDY2ow5W0jRB\n", + "K4UUoKRCTTqKx/GAOB1w+vQdBF6HPIEyL7BVRCOQKBRVJglaDfpJn1/6pX/DU9/+Dvc98AC5qXAb\n", + "Ab/y/vdz79338sC997OysMRgNGKURARBSJpm+EFQN6gpXQ+fxjLfbSNk3VNQFmLSWOVT2tqXP4pr\n", + "T58yK3GVwlT1M1MYQ7fbZjAY4Hk+ZZHzzDNP8/TTT+M6mkYYAhbXc0iyhDRO2Nzc5MbVa+zu7vKf\n", + "fuf3XoIn1cT8CkTtF6QVSVJnoXGa4PkuVtQNRDduXKOIB5iyIAg8bFngO5ooHtVuiqJu/6+N5Gqa\n", + "cRafpuBqDAei5fq1GuRnG3OAPSybHUg+pXAOt9TPMgnT/f9Gt9JPT2DKL81WfPcvzEFPj6mcZ9ao\n", + "Zhq5T5sApgNzoyjaM6CaAqhSCscqDKa2vhSgpcSRisQahJI88upH+b1f+4/cs3Ic3/PxGo29xaXf\n", + "79cGVYMBjuPstdiHYYi1hjRN2NnZ2aNcpt2aYRjQbDYmxam6QzJJMpRWeFqAUVRVSV5WDPs9XK/J\n", + "nXfexeWrN/jYJz7Je97xAwyHQ+YXFyatyyAdzSiKSPOcK1ev0Ov32NjYZjTMkELy/W/7AZZW1qgq\n", + "S7vVoTcYYoSDcgKevfgil67eYlQuUlUSz1uD3OAAmIROx6UVGpIkoiivUxYRve2ExfkjREVFc76F\n", + "VYIgbDCOU9I0o9VZIMljBsMhrtNi+cQJ5u64m9AT5EmENRXt1jxV5WAJiBNDlhqMs0nL98lEQRGP\n", + "CRwFvk9aKZJKkOSGFCiFJVExxi0RRlIWEiNcNC6B73Hs2AqjcY/OXJs4GeGZAEYjdFlSmYrKOHRa\n", + "LXwvo8pyyizBlhVKWO4W5xmZTQp/iK9zHjl5jK4vme8+QHPuLKMiZGVlHldu864o5qkv/TH9pE+8\n", + "epKVVofzZYMXn3qWcfwcgR2TNO/kO+EximjMPdLje9QO662c9WaLr33p6yzqkGjHI8dDdWP84AQy\n", + "kgS6QbPTxfP9ibLIkiQxge9jTe3DI4DCgghc7lw5jZICW7h0WvOYNMd3c0KvohO0iIeGhx/9Hh55\n", + "46vwhcdnP/5nnH/wlShtaLfmeMf3/QD//n3/ju0rV3nPO99VC4VaTZI0xXEEaTbG93zWVlf4nd/9\n", + "IN/3ljeR5Smddov+bo+G3yZstYjTFNdxSbIM33HAQtj0EBbyNMF3HDxHc/XqVVZXVyjLiief/DYX\n", + "LrzAmTOnaDUbCCFot2v1lnIcbGUYDgZcXrnEtSvXXwZFLEpaLBYrNGVR4Xl1g5vjueSFwfWgKCuW\n", + "j5ykoTOu37jGzuYtOs26ruS5LmYCuKaqwdvYqY78YKu91g7TQuYsSIM64A562AwLOBB9w0sbeqYA\n", + "f1hO+HLbX3sE/sXPfvQl3PJ0pZvyy7NSm+n3B4yQ9gBcHzjh2WNOOerpzz4aA1QSSmkpTUVRZLjK\n", + "oaoMXiPk9z/8YZCa1z/6BmxlGI/6eK7C0dBpN4Ha2D5JC9KsIIpTTJkR+B5aOziuR5KkdLrzpFnB\n", + "cDRGa7eWQ2oHU9UFNYuto0XXoZgY3VtryYuU0Avwg4CbGzt8/DOf5+/9yI8wHAx45SsfwRQVeVFS\n", + "lJY0K/jEpz5LZ36RV77y1TTbi/zyr7wPL9Q8fP4BXn3uATZfvMbK4grjXFI2unz2m8+wEyVUZYYx\n", + "JQKD52qKPEcLSVVYhJHkmUVLl2F/lyq/TFEVrKwdxw87FJWLKQOqqm7sSNIeSmUURcSDZ+6lKMva\n", + "58Maev0hUjmUxpDnJXGa0Wq3cF2XeBRRmpJWO8R1YNDbwFGGPE0oSoORPrujDLRPkUgsdZHacx38\n", + "0CPLM8LQYxxHuJ5DnMRYY6iSIUEQEHgutizo93r4nkuepXh+WOuqJy6BaVLzoRLLHceP0Wm3sGU+\n", + "uR9hOBwhJkHCHcfuYH39Kpsb6yhVkGYjbFXgeh7r65uEYRepAny/QWIqXN+vi2QWbFUira2vs1QY\n", + "U1Kktavk0rKPUoadrW2q3OC6AUq6SOlToUlyg+M1sNJBmiGhW2v9V9aO4QYhaZ4jAc+RWJPzt9/5\n", + "dkLPwXUFw8GY3d4uH/3Dj/Jj7/0xojhmeXkR1/VwXcmv//p/pN8fcP8DD9CZn8P3XVxHo7UgiSI+\n", + "/alP8tjrXsfy8gqL8wtUZUmW5RgEzXaLOMlI0xw/bJDneT2/VO0blLXCBoNBnzAIkUJw6+Y6X/jC\n", + "57n/gfvqLFrr2qkRWQ+LyGteelrH6ff7PPbGl5pZJVGC63t7wd5+1l5raGdpDoA4L/B9lyiK2N3e\n", + "IIlHdYYgbU075TWFVnu475vHxWlKGDaoJnLDPXGFrOWT0poDUfWsX9E0e9+PxvcNs6YYBjANtGe5\n", + "8b/RU+lnHcNmB/ACE95W74Hv7Co1jWynJ+m67kSatH+esy33cLASnOU5SIlwaoc4LRXa85FWIGU9\n", + "EeTNb34z/+HX/19e+eAjeNolDPw6Gs0NN2/eQjsaLwhoNjtYFL4fgq0jfSU9ev2IoNGkP0zqdl3p\n", + "0RuMSbPaZCdLC7R0QUDYCEjSMcbW6byjFONxQprs0u10OPfwQ7zqdW/hIx/+EFkc4/khgedz7tw5\n", + "LJKtrR0ee+wx7rr7LFvbPbSj8DyfOIn4zGc/z42LlwmF5A2v66CDDjc2blHkCQpDUUGnPUeWJeR5\n", + "SiNokWU5ygEpFIY6RXVCD1d2CGTFrVs3eeSRVaK4JE1jstjgOyHSStqtOTqdYxR5WlNOso5kTJUT\n", + "BB7pKEZKydG1ZdKsboNvtoKa+99YJww0wtYPZrfVoD8cMTfXpayGWOmQV4bKlBw9ucL6+jqiMrQD\n", + "lyyPWJ5r1alnldVaXd+vvV8QdOYXcKWHAEZ2hJYaO3EIbDfnCf20thJutxkP+wz6BZ12i2Ji2dvp\n", + "tImimLIouHrjGr7ncuz4ccLQwZiMfn+H3d0+i0srRHGOdh3CVhNf+URRjNKKubk54tGQuW6H/u4O\n", + "VVXiuhoqQ6MRYmyM60oqoxn2h7SabbR2WFxaoTcYkxUW5YcgJCaDhisZjiPa7Sa9/gDHrZUYZZlx\n", + "9s5TfPe7zxCN+rSaTdrtLi+88DyD0ZBLly/TbDa5di1jeXmBsqx4/PHH6fX6XLh4ka9+9Wt4nsvK\n", + "kdpYatDr8ZnPfo63/613gJCkWU671UaonDTPiOOEOMmpjKXrezDx0hmNR/ieh+t6RGlCEDQwpsIK\n", + "+OQnP8l999+3D4RmfwalNbUqZBb0OpMawOHtfe97Hz/1v/4k1u4XAetnf0IvSgC5N/JMaEVZVQSe\n", + "xx0nT5KmEZsbG0TRgCovCLyAaDzCcR2U0mRZhud7+Oz/P1MxgrEzneLV/lzXWY57Wus6uMCYvb6W\n", + "KVaBIMvyvfOaxcKX2/7aI/Avf/6PDphS7Y/V0nsyudnK7nQlnYI97NMwruvv7TNb2Z2drTeN4qus\n", + "Vm5YWasx6vZ3gSMdkjxDeS4q8PkXP//z/Ojfery2m9UalMRxXbxGkzwv6PUHDAdDpg5lWgdUxnL9\n", + "xjqe7wMC16uN6bXroR0HKRRxmuC7LaxRtam9lpSTh1kKQRJHtBoNfM/l7rNn2Orvcu+D9/GVr3yZ\n", + "a1eucPXFSyzMzaOU4r3v/TGeeeZZmu02ruvjeiFGBTzxrW/y5DNPISSMd7cxUcyrzj/C8dNneHFj\n", + "m+v9MV5rDqka7Ozs4PkO83ML9Ps7E4WNS1WVDIejCQCXdJSlrCLieJs8G3LqjlO0W11sqZDCw3WD\n", + "vYVVqwohBUmaobXDKIqojEUpF6k1/f4Ag534ymSUVUUYBvWAXw0mT8iTiCDw2djpU6Fw/Qari0fY\n", + "2d4hL3Iqa1hdWSXLUlzXYbvXY3NzkxMnjjMYDBGEBL7P9tYmR9dWuHjhAljDqVOnGQ1HddQn6yJ0\n", + "UkbkacLaygqtVoOG7+E5Lus3btBptVm/eZO5+QWKSaF4OBqQxCNcV2MmWUydNYJBIZWm1epS0SCO\n", + "M7SWuE49asxWJVLVbptQYcq6duO6GmnB0ZIwCBgNhpRV3SugtMPSygoGQZxn+EIw12wwGo85euwY\n", + "cRxhTEmWZcx12zTCAMfRLC8vAJJ+f8SVFy9hjGFjc5PHXv86kiRhcXGB0Pe4cuUKR48eZbfXJ2w0\n", + "6PV6XLx0gUYj5MVLl1hZWeb8+fMcXTtGu9VCac3NG7cAyIqCdqfL4tI827sDtOOQpQmOo/C8afCT\n", + "0N/pM9f5/9h70x9Ls/u+73POs293q7q1dnX37JzhkBIpkbEkS6JEKbIJJ0YiL4Agv3AiJ28CwwEc\n", + "2foH4iAIEiBI8sKKAEGGZEtRbMgQ4oW0BUqkKFGmJC6jGc7We3Utd3/29eTFufdWdXNIOQkiSsAc\n", + "YDCFW13VfZ/7PL/zO9/fdxnw+htfQyitqVBryqvc+NyvbSIMpRlVvX6fNEkQQvDR7/7oN9STn/l7\n", + "P8MyXvDTP/3TnJycUJYlrut/U/ihExIptN6hbRtMKVG0fPUrX6HrKizDwLZNDc+ujcS6rsNawyya\n", + "YbYWz7Xr0Jlr9eVqqCmfYMQZhrGlIyr15KxvU8+uW91u1nd87JN/ejvw63j1pthuivmmeF9fG3re\n", + "5mev+wk8ncB+fZp7vaBLqfMmO3FFsjcAo9NyWN91SesKy7QY7+8RJ0uOnnmeRZyglCQvYRLPaVpF\n", + "WXUkOdBB20JaZhpzC8ZYtk2aZUwmCbujXZKypM3K9UNuUFQVXSu1T0qacuPGDRzHIvQ9fNdFCrBN\n", + "k/5oh0pa3D+dMl8W9EcHHHWSpirJsoR/9mu/znd++DsIPA/bcUjSnFq13L59m9kq4WJ6SX9kkqgJ\n", + "/+4rX6WzXSbLFXvjfdKqpFMGtuhwDJMqL6hKHUpbtyV5nuohkOpASfK0QXUGvh9hGSWXZ3fIlz6e\n", + "HfLyS99Bq0yqokWapubQdq1WVXYdnm3geD5JkoLqeP6ZE/KiIMszhsOIumlZLRM818N3TGqhKOMl\n", + "huo43BkwXcXUZczsLCFNEm7evMVyucIVOeP9Ab7ncbw3QHzgOZbLBX3HIC911NXN4yFVsWJ/rAOs\n", + "pSg5PhyyWCywbAvLgiDq0TQeStXQNcxnMaZh0It8DEOwvzemaVqaquRyesH+/h5SdgS+T1VWVLXm\n", + "6G+G10ma0TQlZQmGMDHX8V69Xo80S7AsA9uz19JuHSHXlC1tp6iKilUyI17MybKEXj+iakuarsS0\n", + "LaokwQ8j0iIDWk4f3cGxTFzHZtTzCDyT4TAizTLeefdddnf3uXPvHmWli0UQRrz2+uucPnrEyx/4\n", + "AB/96EfwfJ/JZAJIptMFaZpx+9az+L7LnTv32Ds45vxyhu0EvP7GW9w4uYlSil7UI7JsLidTJssV\n", + "ZVnieS5HR4ekaUwynZF5LlmWsb+jO3rLslkt5him9gvfRKEppbaJWoZlgxTESbytC++1HM+lXTb8\n", + "/h98icPDg/Xz1V6rHeKJ/6tuXWuMze/saGvFhz78YeJ4xdnZGfP5DNfzcE2guYo6k2u4pFp3ytq+\n", + "QqubO8G2lsF7qyivahdPNK3XoeD/J+vbXsA3x43N13BdrvqkYdN1VdP1In01LLiuPNTr6d1sszsa\n", + "trX9WgiQXYdoFY7lkGU5yjSZzGe4QcDFxQV5nOL4EdIJuVwk1Mogy0ukZWEgcGyH5WJFWRvs7R8x\n", + "m88JhEHQ2+Pk9geYLRcYXUee5yTrbsJxDbzIo9/vI6XUIclxzcK1yOMEyxScHB1x98E77B0c0d89\n", + "YJVWJKslo+GASXyGwmI6XXLvwQNuHh+zXMw5ODoh6oec371PWdaoziArW8pO8txLH+B8esnu3gEP\n", + "Ht3D90NacsbDIctlgmObhI5F3Skc1yHPU3pRxDJeUJYVrhtSZQVJVuNIG0M1xPMFymvJkzlKWQTR\n", + "ECFMOqGgbbFskzjJaOuKRkhcy6TpOk4f3cfzPCzDYHJxihKwNz6ma1pm5xec7O+w2wsYDXosVgt6\n", + "PZ+oP6BI5tjWTYSQfOeHXiKKerz22h/RiJZ33noH23YYDkfc2Nuhv9PfekovVzPm0zmPH58CgtB3\n", + "8b2IJIkp8iUQ0e/16IUhaRLjOCZFmvLowT0O9g6p64YkScizkvHxDlWZMhoO6NoW1wwZjW5SVtof\n", + "fjKfcPPkBo9OH2IZUlvuCohXGa7nUNUVRaGNvVzX1UZJjo1jClaLJY8fnyHoONrf49atGwyHfSbT\n", + "CU3b0I8i4tWS0PdxHZt+GBC4FkK1FHnCO2+/w4c+/CHuvvs2YX/I8c0TwESaNqYSWCjiOGY2W/I9\n", + "3/u93L55izt37mwHeUII2gZ8P0SphrfeepdPf/ozvPDii9R1w8uvfIiibCkbbQv7+PGEZbzi8PiI\n", + "bJmxtz+mUx1ff/NNmqamrip2hgOef/5ZpudTXn/9daIgIDaWwKZb1cwO1XUYOgGZptINXBAE1HX9\n", + "TYvbaDSibnK++MXfZTDo80Of+CHiJCYMepunfl2orxwJ27bBMEwMaQAGmII4WRH1hoTRgDwv+PrX\n", + "36AzdEiz4zgUWY40TZqqWrstaoxdCB1kYZjWE7AuXDvxr/HuDaTbtvWWFbfxgtLIw1VwjM44eG8D\n", + "r+3v/3ZDKL/7W//X9mixoc1s3ux7YUDXqTzXfU/00NPWMnOuKDlbPudTPHIl9SBMtR2GUJjrsNW2\n", + "UUjbJusaZOTzs7/wj9gzHSLPx3RC4qJF2AFp1VE1YFoOnuNhGALVtQjhUdcae5sv5oRhuP132o69\n", + "NiYCZ83TFabYctcd2yEMfBbzGaprsCQcH+5zcuMYafnMVyVvvvkmURTiui6L2SV5liBUSy/w2d8d\n", + "8eqrr7BKEopW8MUvfYVVVumBl5AI1TDqB3ieTVXmtEqtPZIlDx+eEYYj9vZvcPfBY6pGUbYdQRSA\n", + "gfZXdj3qGlRT4BsKW1U02RKjK8nTmFc/+CquF9AobRS1ETvkeYFYhzWbtk2a5jRtQ683YLVaUhQl\n", + "hqtoOkFR1JjSYhhG+JbBIHQQNGRZguN5ZFVJka2QQuPJs9mcOE7o9wYURUUU6YI9ny9wXZesmuM4\n", + "NnmeMuj38YOAuqlQSlAUJUmc4rs+WZ4TF9rASAiBbZtYprk+IiuyJCdLc4ajEbbpIIyKNE1o2g5T\n", + "6oF1UZRbuKBqCvI8pWlqDOGQpgV+GGBYFlXTooSxpruV2LajO/iq1oITz2FnOMS1Ldpa/85uc7qU\n", + "gniVYNqWFmI1Ff3Qo8hiLAGOY+Cv3TGlZXP/0RnRYMj5+Yy8rNkZjvB8lygMcWybuizwPIfRYHgV\n", + "X6gEdQ2WZZKkMf/qX/1LWtXykz/5k9x/8JAgjLBsmzhOGA6GSCXWsJKpMzTrisGgz2DQg04haCny\n", + "gtlshmd7vPyBF3jtta+RpStsSw9xN4VPyCuetWEatG3HG2+8TppmtG3LT/83f/cb6smv/fN/zpd+\n", + "/4tcXl7y4osv8hM/8ROMd8f6/hNPnuAVsMkkVevNQ2xYbwjtCy51Z1yWJdPze6xWKzzHpa4LrcEo\n", + "Cs1aM6T2Ge803zyvr6LbrpMsNsZ7Tyo5nzS+2qyquhIObWrX/yc72f+/1wYbelp2en0YcN0SdiMb\n", + "37z2dKjvdQoOsBXZXPE118PNtfd1S32tSxfYrgPSwLdsasPi8eNTDp/7ANLxqJVAGFr8ohQMh0OU\n", + "0DaxZd3StS2WIfH9ENOQBP4BYRjSdR2rROdq5llCr9cnXi0YjoaaauX6pGlG1yrOTi+wbRPHdJBC\n", + "Md7dp20gjudcTJcMB336gyFZlmFYHkfHO0wn55yfT1jOF3zogx+iKErivMAQ8P3f933ce/CYyWxG\n", + "GAak8YyzyzN2hkPqqkCKDqyGyFWMhy5VNiOwgaYhCHzSLGM03sU1babTCf6gR2+4y2oyY7VqGfg7\n", + "TM8fgjJBWNRdS9s1dDS0tUkcx/i+T5qttJrVNLQy0jBJlkts28aQBq1KsEyJtLTMe393hyZLKIuC\n", + "6eRUJ4+rDj8KuHH4AtPplKqq1g+H5Oz8DNPQIom9vQOOj48I/ICijHTijTSYTmacPnq8DeCIwj63\n", + "Tm6xmC/xHIE0JfOZPjqvFjM8z4O1yMS2bZpaMrs4YzQacXAwYH+nTxBGVEVDqxT37t0jS5cU2Yqq\n", + "SPEDF8cQnNzY43IyYb5YkMQtSkqCMEJ0Nv3QoykaFssVR4dHIDwMQ1FXKfO4wDEtaB1sUydCGYaF\n", + "ZwY4joewoWozVvM5nudRJDFJsmKqJnQKpvMVt597ntdee43jG7exbY+mralrg8vLCYcH+/iej2lK\n", + "XnvtNW7fvkXbdqRJhlISP/CoqoqvfvUr/NW//tc4PT0ljCKkNIhX2ro3STKqoiIIfc4nF5RVycnJ\n", + "MaZp8vDhQ3Z3dnn08CGH+/s899wLPLz/kDt3H3Dr5g3u3btLnsXr4eK6seq0Z45l2SyWSz73uc8x\n", + "mUwQQjCbzd6zhoRRxM7ODmVZ8ju/8zt8/5//fsIwxHX89Xxr3Qk/5YAtWFvzXntZolOwpDTwPJ/D\n", + "oxPCKOb+/ftIoTCkbtokHY3qUAhsx6Jruycog5uCLYTYJl5tOmqtzLa3r+nAjnX9WRv7PW1V+83W\n", + "t70D/8Jnf33bKT/dUW+K8HWIZbMzbaCTzTR4M/C8TslZ/11PiIEE2k+7bVpNWRKAEFjC0FasdYcb\n", + "BKR1TSUF/93/9D/yF37gh7FNC9v2yIqGyXyJ40Y0ShCEPRQCz/NplUJ0gmQVr49KawWi1Ik8nuet\n", + "5f0meZEjhckqTnEdnyTL8T1ff2idomtKbt08YbwzZLmcsbu3R922VHWL6/s8fHxOWdUkcYzotNTc\n", + "sQzqImO0M+DZl57jzbfu0uvvU9WQFjqurGlKhoOI6WyKgaAXeuTJGUmSs1ymzJcZxzeewY9GzBYr\n", + "bMcDYbKME3Z2R6zKGckypecMCO2AtizY3+1jmx2W3ZFlK/zI06ZbjakpV0KwWq3Y3R2zWq2Q0tDH\n", + "2E6HVWhhVIVpu7heqDfIpiV0LeoyZzQIadqWqm11uEOWrruTjiAIqWttKSCQdG1LU7ekaUpV1/SC\n", + "gKZtcFxn+zBrFW9DlhUIJFmWYxoW0hI0bcNkesl4b8z9+/cYj8fMZzP29rSCbzTapcwLktWUttMB\n", + "1nGWYpoWw+Fwjb922JZJVRbaXGkxpygLxgcHDHZ2KYoaadgsFitUC5PLGcP+kGFvgOm2CNlhGnKb\n", + "ZN80HU3VaT511ZImOXleEgx9/J5D1zSYhgDV0dY1bVNT1Q1JltF1mnH18PQx3/8Dn2A6m+I5Lnt7\n", + "YwxpkKcprusw6PdZrZZrOMPAsmxA8fu///u89trX+OSPfpJeT29YeV5gWroDj8KQXtTncjLB8z06\n", + "WlarJZ6nB8BCCE6OjpnNZjR1Q9sqLi4ec+vkiNVyimVC110REtpWBy0IafC7v/dFLi4utp1oHMf8\n", + "ws///DfUk9/47Gd5+PAe7777Dvfu3cdxXP7Bf/sP6PU2EMqm49bF1XiqK998771Wu6bXrlYrZtMJ\n", + "VVloIzSxFu3ZFt3aRlYjP1csmKcZcZvYN/29J50Mr5h37RP1TUrJK9/5A396O/CnQxyuv/ENB/R6\n", + "Cjt840W6Lu7ZrOuQyWbyC/qD6lpty6mZO1rR2OjgMQxbq99A8KV/9yX2dvYQUlAWBQK4dXzMjYMx\n", + "Qkhm8yVpnpCXFWm1olMKz3YZRg6ObWufkiYijlfESUKRJNsb0nNdgnDAraMDTMtltUopypKqakAo\n", + "8rrk6699heT4ENexSB2Dy+kEJQx6g13qqiBJc6ShWRSGUhhSEI7GvHv3LSqVEwRDZFeTr1KqusGP\n", + "AhoUj8/PCYOQtm45Pb3Et8Dzerhen44Luq5iOn3MYKiLjes5mGaEKTsis+bw5ADRObimhyl6VGVM\n", + "3dXUeU1dV1SFhh6qutAmX66DYUqWq/mWGmooc+3XYmJbBsMwQFoOluPheC5pEjO9PKMX+Dx8/Igg\n", + "CDFsHyHA9yOWiyVJEqM63Zn5noeUBmEQ4DoOgTdCSkGW1lRlwunpBaOdIWEU6QQhVXLjZJ+qaEiS\n", + "jHt37+L7BnlR8IEXX+Stt9/Ccx3yLEaphn4UkCYp52ePiIKA4yM9gC3rikZ15GXBKlmSpSmWpTMv\n", + "dwYjfC9kFWco2fLw0Rlvv3uf+XJJVdX4fsDOcIdhNKApVtS2ZLWKkabA831cx9kOuUajMWmS4UiJ\n", + "7/vkeYHtWSyTOSAoBCRxSlWVeJ7Hwd4Y16+QEu7ceZfjwwOaMiP0HISAuiywfJ+oF+LYDmmWYxgW\n", + "o1Gf5XJBliU0TcWbb75OrxfSiyJcx6IsMgQC2zDYHQ7JspK8cLYAACAASURBVJwH9+/jBh7z+YQo\n", + "CrBMA4FOi98ZDrl75x77+/tgC2bzOVHUo6xKDZ12FagWqXTx1raxFhfn5+v7NKAoS/I05ej4vaMF\n", + "mrbFdb11ir2eWdVNQ1VvErq+sVA+vQS8Z7crMGg7GAx2cRwX1TVcXJxTFjmOaerNx3GoihJDXDWM\n", + "15l1W6KEYVyztr4S8FzN4sQWLXi6ef1m69tewK/DIJti/bTxy5Vd4xXx3XXd7debqKONC+HmomzW\n", + "e0UciboFKWmFzpZcR0RqNktZ4vk9vvC5z/ORj/8H7I5GCDrS5Yo6mxP5AaptOdn1qVsPw/VAWlRt\n", + "Q56VVGVJ06SI1sIERj2HZ27sYZgmVXV7O5iZL+dcXEzIEu3H4boBh+ORvg6ix87ugLrMKYqMrl4R\n", + "2BLL82mVhmLCsEdTr/F+IbBMyWK5wPN8ZvMJ8TJhd3iEJU2kY2IIRb8f0aPHYrEkXmYc7t/EMZSm\n", + "VKmWGzdD6qbhpRvH3L17j7xMMW2DOMnohQGRCVab0x+EuI7OmOwCLUEui47xaI8srfC8gEk6Iepp\n", + "uMd1XaQhSdMWpVqtgu0a6rUx/nKqiAYD0iQlKwuins/BwR5ZuuLWrVsUZcMyKajyGld0mNKg3+vT\n", + "j/ocHx6iuo6qzHWYRroiTVOUUuzs7DPeGzI+HJFmKcLsODt/hDQkDx7dpy5rmqrl8OiIfuBh2joE\n", + "++Mf+y7SPKGqax7ev8/+/pi5ZTCI+kwmE+arlOlshlIdw90BTuBjOyajvV1t3VA0PDg9Q+cumijh\n", + "EUR9opFBf7RH3ZQ8evgQaXT0eg4nh8+QJQmWP9LYdl1TtzrIwTQsVvGcqmpo6rVgDejKmsP9Ax6d\n", + "neN5IfNFwid++Mf4whe+AIaD7+v4speee4HTs1OyJKZpaqQ0UE2jB7WuSxho3n8URazimKZtMS1J\n", + "VbWYlsGHv+NVhNAKY8/1EUKSpTFS6jnBwcE+eZHi2BGreKk/a6kLctM0WKZFskxI0hQlBVHUA1Wu\n", + "8WfxhDVy1ylaBOdn59R1TbZ2NbQdTcH9JkUEITS7Z7VKmM0WfPnLX+ETP/gJBAKltD0E6BnCe2aJ\n", + "KfUNAAvof4uUJlXV4HkhbVtzcHjEvbvvEqcFrqvhE2GaqGuJQU8X3g1UfNVwXsVIXhX5K2XmH7fh\n", + "bNa3vYBv6H/X6YPXMSTHcbad9XVJPegP3bbt7RD0eg7eprBvdrPrXTiArfTQshNKd9zr4APDMgmj\n", + "iDfefIfFYkHkBzRNiWoaLAOm54/xDw/WoQM9KtGSF0taaYE0CTyDwPUx1rYASZyg1WAlyWqJ73nk\n", + "aY5odQDwSy/sk6QZCl0kq3KB5zgkyZyy7DCkYjq7x/xyiW33iYbaKTAKApZZhm37pGmOaQiSNMf1\n", + "AgyrZZUm9PoDVNeQZzleECGFIkliJvMlt28/Rxi0mNKk6yRFnWrqlWHR1hXv3nmH8f4efhhojq8M\n", + "MATs9yPiuEA2JXldEPRcyjLDcS3qSh8p87imyCosy6AoM/xA54lWVYnrDtH+MFfJ3L7v0y1iLNeh\n", + "EQIzWZJlKVm6oN+LiNOEtjMIe33KWkG6oqoruq6mzAuyROOo490dDKHzaoRoMQ2T+eIM1/cwLAsh\n", + "YRUvCfsucZLi+pKTmzcxkFRVzWq1wjANirLAdk38wMM0DU5Ojjk9fUgvijg9fcStmzfJSwvH9cnL\n", + "jDiPUarFqAS2ZVNXDXvjAyzTo8hLTs9nzBYxjufg+i6GJRjvH3J4dMDOoEc8nXJx+QhLGpRdS4fE\n", + "MLWXjpJsU5dMp9ViNaU5zGVR8eDBAyzb4wMvv4Jhe9x/dMbewTFlVaHaCpGlxPM5jm1zcf6Yfn9A\n", + "OAyxLRvHcRkMhlR1w2AwIM9z2rajqgosS6ckBYHP/v4eoIuJZWsvntFwQLxKUF3H5eU54/GYZbzA\n", + "sk2kscZyZbd2I3QxDINeGBEXOY8fP+YDLz1LmSfrZx2qugK19hhptdBtY9e8YWkVRfGeNWQD+8zn\n", + "y20d+epXv8qtW7fZ3RkTBP61OZtCGteKogKEYhv0ef111kI2pTAtk6Zp1/XF4vbtZ3nw8C6T6SWO\n", + "Y2EIiXlNdXldSn+dObdJ47lOtniy2TSfKN5P06ifXt/2Ar7x6950yHVdPzGYbNv2CexoE9iwOZJs\n", + "JPdSSqTOQteFXimkaV95C6zxqc1UujWElup2ilZKClPv0mbdkGcpn/n8b3N4+xlUUZN2LklaYRmK\n", + "PK6AKTeO9rmczYjWggmkJK+qtZhCsFquqKuGfl8n9whgb2eXqq0xLJPJdILoFJePZ5qRYhns9Hp4\n", + "Yx8QWDdOWMxXxHFK4OzRu7WHNDoWy5idvs9idc7IshGyRpoVTatoJbiezdDdY3fUp9/va+8XRzJf\n", + "XOApLXEuFzPyWYjteEwupnrg43lkWcUizvFsmyjq0SUVA8cGCY3MKcuStPI5vv0MQppkWU6e1XSt\n", + "zTKtmV7OsQ9sXFfgeZJF5lFTI5VBusq2G3DbthSFVu+B7jqOD/p0eYdSMB7vsr+7g2VZ2vHRgsnl\n", + "Gbati45wJJ7v4FgBXVtjdlCVGaePU1rVITAIej18P+Dg1k2KoqRVgsvJjIvLGb4vCP0+bmgTLxYU\n", + "eUI/DNk93NlaAOdZxmq1ZD5d0lQVL730Eov5nMB3eeedtwCJ63nsjcfcdEfYts1iscB2HN658y7z\n", + "y8cslkuWyyVRFHLrKFyfBCVNVZOeP6JtO6zmiP2DI83qSLVXTF3V5HlKmupiLYTQitCiwhCCwA8w\n", + "pKQ0C955/JjRjRtMHrxNaDR0bYnqKqLQoasVZVmgQmiF5EPf9VEQAtf1MSwHgYEwTALfoMhzLMuh\n", + "LBJMwybPSybTOUHgYZs6RnB3NKZra1bzGXmywvV07uRwEDKbnmOaJq7pUBUVlmtSq5q6LgkCn6LS\n", + "TCvLlrz44vNMZ1PKFgwMhDSoqhrLNmiagrZrkGbNaKfHdHaOlQsMwyJZLd6zhmRxtrWDPTu7xHJ8\n", + "hrsHZGXL2WRGkJdEYYRtGzjmphm8xkzrNg3jpljqgq71ITqlHkCuEVppWijD5PatFwn8IQ8ePADL\n", + "ohMahrUMiWoapNJhK13TAoqmqhFIfRoQVxTqTf3WzLt225DCn4EOfAONbLDRTUG+fozYMFKUUtsC\n", + "f90MZtNtdx3bJAxzQ0EUV/4pTXflM+60HTIImKcxgefgIsmbFnybz//m51mcnvOjP/KjmL6LY4a6\n", + "gywzRFexWCU4js3ueMRqlRJEkk4p6q7VqfRIRsMBddUilMY1m66jLAudkmOI9ZDHoQ020tyKy8tL\n", + "rcyqG7wwZDbVjm17ewfUdYmiJYwGNE1Lv9ejrFoWqxjH9WmamijwCQOP5XKB51gsFwvkOnz2YG8P\n", + "y7aZz5f0nr2NECaOKdnb3UWakiRN6fV6mOvrV1UloeciaPB8l7YROsLLc7g4P0MIieeH2JakUgI3\n", + "8DHFPp7nkSRLptMLwuERSrU0TYshjTU2qo//lmnSi0KE0JuyUAVtq09K0+l83YlAEOg/89xzL2wN\n", + "xAxMqrJGKqDt6PdDfNfXvtWGQVnWpEnGfL5ASoW7dmK0TAspBLs7OwgEliXxdnZQ3QClNEcfoKoq\n", + "XTT7A6IwpMxz8jxfv7eEwaBPVTcIIXnw4P7Wh911XbIs5WBvj8lshgCeuX0bz9NRX7Zl6aBppZuJ\n", + "oiiQhsF8PsXzAw0BGuDYJr1egERT0CzTpCrLrRVpHK8oi5IiTdnd3eHmzRucX1xiOc72OSoyrfAM\n", + "g5DA95nM5zi2heN4VHUDXYeQBnmWanvjptFzHqlT2k3LxpAmhmkhDBPbdmmaFiEM9vb2qaoSRLf1\n", + "9AjDcN0ll0gp9WZm24RhSJIkWJaGc1rV8s47b3N8fIRpmZRZQlHmerC9YZchsUwbD4ObN06YzWdk\n", + "WXytwD65NENlTtM0nJ4+Yrx/wNHREYZhsFwu6fV6LOZzlOoY9Hr46zmAvseue6fodR0BeK/x5nXR\n", + "4cHBAVEUcXp6yjJOCHxv7W8kKOt6S1UWUqCTilraFoTUcW4b7HsD815HDf5MdOAbaONp46pNR74Z\n", + "ZG4I7Ztue/Nz16e1eV5eqZmumVddpylKKddmNAazeIHZjwATqxW0luS3/uBL/NzP/xx/+2/8LawW\n", + "EILpbEKZZhwc7uO7+4ThbS4vLrj/4DE3b91guUrY3x9TFAWr5UJjfZ222jw+PuHoaE97KtQ1RVUy\n", + "Xy6IkwTbtPBsDwSEUcDu7mgd2NAgpcHzzz3PG19/k4uLx1qYEIWcnp4yGu2ys7tHr+/juC6W7bBY\n", + "xIRhhDRNjg8PsEyDuq7Ii4w4TVnlSxaLBb4fcXh0RJ5XpHGur58p8R2HZDnFkCbL2RzVduSrjrYu\n", + "MSXUVU5dl3z4Ix9hEI0oipplrK1xVdOStA1VmSPpYZomJycnFI3B3niH6XTKdDrdbrJFUWgBj6VT\n", + "jnq9Hq5jMRyOCAKdzrJxc3zw4AFFXuG6Lp7nsTMa43gOeZ4xuTwnSxMml5IbR0csF4lW+x0ecHK8\n", + "t+7qYDqZMVsuqeuWGweHVOuMUrGGW8LQJ4wCRmuWTBzHJEm8xUV7YUCWpmsnSX3N9vb2CMOQMAx1\n", + "LN5iwdff/LruppTg8vKSw8NDRNdQpAllWerCmufrk4QDSpEXDYdHRyxWS0qpu/N6nUJl2/oE2e/3\n", + "2dkZbpuadt2dreZz4tWSy8szPN9nPB5jOx5pGlOWJXVdkKV6sNk1LWWWEfg+Shk0bUNVVfT7I9qm\n", + "4eHFBZ7rUZclbQdtB5ezBcP+kKKoGQ1GKKWYTZc0zYowDHTClG0yncVPpF/p1Cl9XVarlX7fhf6+\n", + "63vs7u6wXC4RAnphiJSQJisdOoJGMw3DpCsrdkYjojAkTVMc5xvDHACk0J4r9+7ex/UDfvzH/4qm\n", + "5XYdN2/e5M677zIcDNnZGdA0NfN5xmAwIMti+n09DxoOn/RZufIy+db1q21bfN/n1q1bfPlrF2RF\n", + "RS8KoOvwHZsiTVFGs6ZIrvFvccWIgStxIVxpV647sn6r9W2nEX7xc/8C4Ikd5zrj5PoQ8+k38+RO\n", + "CQhd9OVGvKNfRKlue2QyTX08qWWnu3MlqbsWaRj85mc/x+d+83P88A9/kigacHhwQJ5mWJataVlp\n", + "ijQkVVliGJI8TzEN2B0NQHUc7O0iTC0GsE2bJE5pG82rFULoxHcUzroYlWWJZdokcUxR5piWNnx3\n", + "XZ+ug9PTx3hegGXba1l+zmAwoGk67t2/jxCSNM25efs2ZVGt6V8mCkGzVnLNZjMODvaZzaZUdUPg\n", + "Bzxz+1lm8wXNOuZb2JKyqDCkoQ35q5peGDKdXuLZJpeXZxzu76FUR9u12JaDMEykNDEtB9OwtKdF\n", + "V5MkCbZtkmcptdLpJpZlbmGyoii5ceMmSZJojrjnce/+fW4d3yDPc5RSlOvkIb3xaqVd0zQkiaYP\n", + "NqrbdtC2YbBczomiEM9zaZpG8/KrCiElptEAUpssDXYoqwZhWAj0vZYXqU78aWrE+tTmODpBxjAN\n", + "2qahLgvyIicIPIb9AV3XsVhMtD1tq1OfBBLDMLfm/UmS4tiO3pBr3T23a096z3HXeLM2dQqiQPvm\n", + "SHAtl3wNLVmWRZ4VKCDLsmvKZEXdNBRZzMF4B9avSdOiLCqKsqTrdGFp6grHsbmcTDi5dYs81wV6\n", + "ONoly0uquqWqKlgHYwsFTauo6pYvfOE3efWDL7K/t4MpoBf19aZo2cTxkqoqMW0T2wm2p4rNKRlY\n", + "34+WHpoqRdPqSLi6qrAdGyHANg3apmY2n6LW30coptMpWZY90bj1ogE/9VN/6xvqyS//8q/w21/4\n", + "HS4uLxnvH/DjP/5XGI52dBFULZbl6BpQNziOw2gwYD5fEEWRPt0b4DoeQm6oymILa3yz+nm94G6g\n", + "3qxJOT97zHI2wTQN2rokcF26tkZyPZRm7V2urlwSN0iCtmG4go+FELz60U/86aUR6uOVxrWvqzHh\n", + "aki5uSme9tfdvPntwMCSqLalBYRSmqhvGNjW1UURQmDYBonRIPOanmlQ0/Gz//gf8e5rb/Ff/Y3/\n", + "HMdxmTUlZ/MJdtEifB/P94GAplMkWcHpgweMx7uEvYj7D0+5dXzE1776R/iRgxd4BF6AZVoEfkC/\n", + "19PZlY5LUZY65QMAG9Mw6fVDjsIDqqqkLCvOL85JkpSjo2OWyxjTcPA8F88PUErx6NEjBv0el5eX\n", + "tE1JU2b4rotlmaxWCZ4XUNU1Z6cP6ff7BK7D4QdeRkrN+Lm8PMP3ApQlEVLghT5pmpImGUYnMUy4\n", + "OL1HnmfsPXOT55/9btq20txkKanqmsV8xcXllDwv8Fwf23WxbYuDgzFpkhD4uySFtsZdrVbMZhPS\n", + "NKXICz7z6X9NXdcsl5qx8JGPfIR6fxdpKG7evKltPqcL4jgmyzJmswm3b9/GsvQQKPBCfa3SnEWR\n", + "cni4j5T6SNvrRWR5Sl031HVFmS6I0wzTdJhcnAOGpo02HTvjXXpRD8syqeuKuu1YLBZcnk9QqqXX\n", + "j/A9D98PuHXrJkWZc/b4Mbs7O9y4cUhVVywWS9pW8fDhQ+q6IfBDmvW96js2poBOQlMXjIZD6MAw\n", + "BOHuCMs2WCyXBKFPkqaUVcnj+Up7zHs+IorWxaTjxvEBTavWG1xJWVVUxYqqznEtbW3sOgamaeP7\n", + "Dnme03UNUupn4OjokCzWp7RlHLNczJCGSde01GVFnKaEYURRaBdH09I02OFgSFGU+K7DcrlaF2MY\n", + "j/fIspRlvCBNk+08ynW0NcRyuVyfAioMw8DzAmzLRim9sZyfn3Hr9i2SOObk+Ij5Yoa0bIosXYel\n", + "eARBsD2ZW5ZDkb/3EFNKg9lszv7hIR//+J+jqjfGYDZvvPEGw/6Ao+NDLCl49927VEXFs8/e4uJi\n", + "QlEUHB0dMZ3O1kIpiee715rFb97gXvcyMQwDIU1Obt4iDCPuvvsOlmnoIGbVYRpiHT7errUgzvrf\n", + "/mT2wXV69Kap/Vbr296Bf+7f/tpVYb0WCHpFbL9yI9wEPmzWdcaKlJKyXk+JNfETKbQYQh/JDKo1\n", + "4d4wDSpX/566rPjFX/wl4lXMf/yp/4gizXWGoxCEQQRdR7F+YJSQxGlO0BtgOw7xakmexqi2hKbi\n", + "cH+MG1iYlsSUJk3dUOQ5bbPp/i0cz8O0tLmTZVpYhklR6eN827VbiOjj3/djf4KfyPvr/fVnY4n3\n", + "KKh/5+/8XYRl8uKLL/Lqqx/CtHR4+XK54tatm1umku+57Ix2KMt6DaHBeLzD+fklu7u7W1jWDzw2\n", + "/im2fWU+taasbLvyjXpbSv1CpTaBEDWz2ZQHd9/F9WztcqcaPQxd6zU2lOXrhXtDqd7Uu00H/q1C\n", + "jb/tHXjXdXhr74ZNV70p2hsc6voQczNg2pjAVFVF27bbLn4rpW87lFDrHMYGW+q8vrzIERiQVZzG\n", + "M/7X//0f8sFbz/MXf+CHCB0Xr99jejHBq+H09BJ7p8+g38N1HYpap+Us5nNs18U0JP3+AMeUxIs5\n", + "d+4+YLgTEYQa3x1EfXZ2Q4QSW9l32+rk7appMKWhY5ykwF17KNe1tlV9f72/3l//futrr/0RP/Vf\n", + "/hc6GSvUNs9dB5Zlc/fuXY4ODmiahjAMmUwvOTw4Znd3wOXljLOzCw4P98mygjzPOTzcJ80ysixd\n", + "Q3cty+WK0WiEEFCW9RrmUOuhqroaRhprLx3DZndnTNe2XF6cab68YdFUBXVdasrhUz5Pm477upT+\n", + "aT3Le61vewf+h1/8N8AVpnQ9Ygj0LnddZbl5cxsJ/fXOXRkmhpBYpqklyFUNSnNMpSEp6xo31DDE\n", + "dDrl53/pF3nm+ef4yCuvEto+SZJgei5R1MeTWk2YNRXxckVRlkjDoj8YYNkeRVlqvLNtePTwAePR\n", + "DnVV0qgSITqGwwF0EHg2RV5gSIntOmtZfYDjeTRVjWmYJEmMYRrb3b5tW773h/7yn+hn8v56f/1Z\n", + "WO/VgX/mNz5P27X0+32SNMWybIqi5Nlnn2VyOSHwHLI0Ydjva3695RLHMTduHG8hkDRN6Q96pGmK\n", + "aRpEUQQIVqvleuCp5xJRFG7tMDY49rYj5xrGLfQrk8k5d959h34U0DYVptT1yLj2Pq4X8utd+WZ9\n", + "q0zMb81R+RNY14cBm/Bh13W3xlWbP3NdxGOa5jblfdN1a+hk7QS27mANwwABvX6PRim8KKSsK+49\n", + "esD/8L/9LxyP9/lzL30Iz7Qxez5hv0/QGdhVx+PFlHmd45oWQRAx3tvHsS0ePXzA44f3WM0nuKZk\n", + "EIW8/NLLuH4Iho1p+UjD5eJiztn5BZ2SeH5A1O9rTM+2KOtK046WS7Ikxfd06ADoI9SGzvb+en+9\n", + "v/74lWYlCE0e2N8/4ODgkCAIePjwoZbiF9pFMMsyRsMhcbwkCD3u3L2DkILTx49ou5qiKOj3exiG\n", + "ZDK5pGkqpDCI40xL3DtYzFdUVUtddbStFv90LagO6IBOY9hto+mQOzt7PPfc86ziBCEkVaOdSvV/\n", + "uuvenM43as2nA2y+1fq2QyhZlm0j02zbxjS1g90G3N/wIzeFemOYvnEl3EAppqn9jquqoiwKDMPA\n", + "tR1M02Q6n2uesmOj2pp/85uf5ZM/+Am+/7s+TrlKqVE8uHMfWxi4SFZJzOjWDTAky8sZZd1iOw5R\n", + "r8eNo0PqsiTLMh4/PqXpNL/c9ULG+4co1VIUGUnygOV8SZL8EbdunpCniU6q9xxsy6E/GNAPB+RJ\n", + "QlmUVHWJbVtIU8vs31/vr/fXv9+KBiPqMqZpOs7OzonjmFdeeYXRaEDXKE4fFYxHI9q24fzsnLIq\n", + "2Q/3qeuas7PHlGW5pgHnW1Xp3t4el5cXWKaHbRrkmZb+9/t9qqokjpNtod105aYpaOsWKQxsy6Tr\n", + "gE6wMxpjmiZvvfkGnq1tJwx55bK6Ydlt6NHX15/6IeYXPvvrAOsLcBXg8DSQf+1ntzvXBl7ZcL83\n", + "FrFCKSxTZwMioGoaiqZmulrwK//0/2RnvMuPfPR7KJoaw7UJTRdP2kyXc6TvUjc1ltLT9toSgEFb\n", + "N6i6wrFNaGosw8TzA+oWJvMVDQZFWeM4FoKOui5J4gUGLUJ0OiFm3YWblkUYhVR5RbZKGY93qJsK\n", + "KQV1qx0V/9KP/81vuG5f/Oyvr0ULM8IwpO06yqriwYOHKKV44YUXaBody9a1Fa7nk2UlrhtgWg7L\n", + "WEuXTcdeZ4jqCLCu7hBCYRsmqutQrT5Wer5PVVekec79B/fZ299H2pb2yW5a3DW7p21bHMehU4qs\n", + "KLFsWyeEd08GS5umvd2sNxzwpmk4fXRG1BtpX+yqxPeDNR++otfraQ+QRkvdPc9DqA7DsqmblrPL\n", + "CZ6vHQyFkMi1vadl6N7E9nRyim3oYbbnemRpSl3XVHWtxUNdp1kLlrulrZqmRZ4XVHVDs/boyPNi\n", + "O4wejzW1sVUKKQ3KqkZ1DVJ12q+8rTBUTb8f4YQ+bbcOKBFaiq4UtE1HVpS8/c4ddnbHRFGPVgii\n", + "XoQUgqauEBIsQ4LotFGVu2lcDNpaaS/ytWFTU5c6ji/PMSybi8mEOMl56WUdLl0UlRax0GFKQVtr\n", + "2l7XKa2NMEySNMO1TX71n/wif/FTPwYorcpVEoRFUUOSZWCC59vUTYNnejR1q5+XNe3PcZxtvFzb\n", + "am9tBUjTwPO87XNdlfXWSTQIQ6RhUlUVWZbhGJLDwyPOzi6wHJsf/eSff08I5Vd//TfoBTq/cjAY\n", + "khcFXbuOLEMQhT6r+ZzhcIBA4QU6eejk5ITp9BLHcYjjmN3dXeI4pt/vU5a59pufrhgOdzBNSVFU\n", + "1+qToG31fbMpuqFnb5k9wjLWXO9ta850esGdd9/Gdx1M8aQN9nWjvus2skKIP91+4K7rPuFvsjlG\n", + "wFpaqgRCSjoUzZo3uynilmWhWp3coSfGCqNqka7NtEzpqRaV1iSBwSI0+Lmf/UW+e/85fvC7vofK\n", + "NRBrc6xVlpGZBWbo4Lo2jhORpimTyYQ6LrGsgNFwh2hvd11Ap1qMU5U4jsPB4RDXc5jPZyznKdPp\n", + "CsuyeeGZV0iynDhOcPxjsjzmdBLjug1ONKI/7jHe2yVJE2zLpioy9vd2v2nyyB98+Q/puo4gCMjL\n", + "grfeeouXX/4go9GI8XhM13Xs7OywWi3pRUPqusZzHRzXJE1XDCKXew8e8NxzL7BYLLShPRbpKsY0\n", + "TFaVNgQTa4/z2WLOpz/9aW7dfIaTkxNcw8Z3dQfRCEWex9t5hCHW1p11QZ6vtIJQBixWS6RcC64s\n", + "i7qpUUrSAm2jU0xe+eB34LsdXatYrVas4pyL8wuUkNy99w63nrnJaDRgZ/+YosqpKi3wsS0LRMWw\n", + "Z615wpqP7DoOZ+enrFYrppcZcbwi8DUtbX+8y8XZObujXUZBj37Up6oalssliyRZU99qwlDDZpZl\n", + "MZ3OWC6X0HaM9/YIgoCuK+kPIsoiJY4XyLpYBzTrU+L+wRGm5WpRVtsx6EfUdUlZllStlpW//eZb\n", + "fPnLX+ZTn/pLGIZEioK9YQ9UhmlaGMFVYkuWFji9iCzPmC+WmKZFUVQIJFVVkuf6JGvZJlVV8nu/\n", + "90V+8id/gpu2jWG0SNXghsY6XKEkLUtsx9MWzNLA8T29+boOQT/gfHGJ1++RZTnn86VWSmIwGI44\n", + "GR1RliXLZUxdNDRiheu6jEajLQlhNptRV1epWf1eQBhqw60sXmmevONqm15HBx7Hccx8tiAMtfI5\n", + "CH3OLs8QhuDi4uyb1pCj/R2qIsdxHB4/eqidD02DwWDA22+/jVItt557jrquef3119kfj3n5lVfI\n", + "spK2kyhMhqMx9x88ZLw3RpoG07MFqyRl0B8xW0xZzOfcvHmLXi/g3r2H9Ho9+v2I+XIFhkEYhDw+\n", + "P6ff7+tmpmrWnisK0zSo65bx+JCuk9y7dw/PXTsSdh22qV0e66rCth296XUdUv7x5flbduBCiBPg\n", + "F4A9dMv8D5VS/7MQYgT8MnALuAv8NaXUYv0zPwP8hqeQ+AAAIABJREFUZ0AL/G2l1L9+j9+77cB/\n", + "7/P/crvrXE/Q2RrCrLncaq1eQl75e5uGoXc7BYaUVEWBsE1EC5Zh0EhJbsBkteBXf+X/4OTwBt/9\n", + "oe+kmq2oDIlhmgwGA+y1QY8WjjRka3Wg6jo83yfPSvK82JLrtUTY1x4brQ6R3UA+jhPQtdA0HWXZ\n", + "sIxTpDSwHZu6qUC2JMmKuqmIfIdBL0Sg6EchURhQ5Dqx/Qf+w7/6DZ/Hb33mn64DgLUIpKoq5vM5\n", + "Ozu7SClxHEe/Dylpai2GaduWJEu5d+8eeZ5jOTYf+9jHMS0L27JZLpfrtJEapdapJJ3iwYOHWvm4\n", + "M6auasqyIsszPM8kDEOKomAwGFCs4arr5mGghReqM2FN/yzrSououo6qqinLmrYDnbxiIdHFyHEc\n", + "bMdHISiqCt/3mc4mtN06a1AKhHCoaq1YHO/uUJfV2gtDM5dMw6RrWzzPxfE8ylILhLI0IQh8fNcj\n", + "yzJUq7MNV4uYnZ1dcI1r/hSCqqpJEm3ze3Ki+elpqj9P09B2qaahcF0bwxBIQ1+7pm5JsgwhLVar\n", + "GFt2CBRRFCKEoteLuLg85/zxGR/72Mep1h4ZXacwDdCsNEEnrkIB2kbfe4Zp4PkBq1Wsaam2uxWn\n", + "GabBcrng8eNHlGXJq69+EFBbEZCUUnOREahWaSm50P5DrGm2ddNhW4J/9qv/hL/8n/yn1HXDYDCi\n", + "yEukNMjzAsv2qOuGrlNEUURZ5tvIs82peOMWuukmN06ijusDYJoWXac57UopOhTSMPA9jVlvTuQb\n", + "Uysl4C/8yCfeswP/F//2t4k8Z0vBTVPNJe/1eiilmEwmDIdDJpMJN27coEhToihiuVxwcnKDNM20\n", + "CZcQ5IU+ZbmuvWa3OWsVrUVVaAbcaKRtdKVpYJgWZV1j2yaiURiGZs1pbrjA892t33nbNijVcf/+\n", + "fZLVYy3jF9A2NZ7jbAOTu66jbhqk1IjEBz/yg/+vO/Aa+K+VUn8ohAiBLwkhPg38TeDTSqn/Xgjx\n", + "94C/D/x9IcQrwF8HXgGOgc8IIV5USn1TU9vrIQzXC/emEFRtg4keDGDoG3DDlxRK0TWdNhJUYHse\n", + "yyKl7wSorGKhKlahyS/943/MbXfE9334u/B2BjSeT10rkjTlnXfuYNsWR0fHDAY9pBQ4Tr6Ox3JY\n", + "zGOGwwFhGJJlOVmWURTFeuDRx7YdPC/Yyobj1SXSMHEc7YC3vz8mTjKm0ymdarFdE8/zsRqTvCpY\n", + "3n/EjeNj8rLm7r032B/vYnyT0fKbb765hR6EEJyfn7NYLPjUpz5FFEVrwYOFY1u0rR6KfPWrbzAc\n", + "7PCx7/4Yan3zN21DVbakaYJlmqRpjOf5uvibJnfv3f2/2XuzWMuy877vt9aehzPfserW0N1kjySb\n", + "pEhqoEyZlCiREuQMssUEEhIkVgLYyADEyEOeoofAiPMQBEGeDDhIEMCWFUZhNJGaaMlSRIpDk81u\n", + "suehhlt15zPuea+18rD2OVVkVzft5IEEog1Ud9W999xzzj57r/V9/+8/8K5H3t1dhB5Swtn5SWdA\n", + "pYnjGM/z7CLYzSPyPKfX6xHHMcvl0lZVecl0NutgB0m/P0BKw3CYkmX2HPf6A1qlcERoVYRlRVHW\n", + "FGWN53vMZlMuH1ymaWtms1l3cdecn5wyGY/xHBfhw87BAcvFjLq2ARGL5YKL2RQhhTXrCn129nY7\n", + "qKFBOhLhCsIoYjQZc3h4iKd8lLaL5NbWFm4FZWlIHJ+2yfA9QbI9QkhJU1uoatGFDsdhgOu5BGGE\n", + "7wfsJANmiwVp0mN2foQU8Oqrr3J0dAelLHT1q7/yK7Y7C0K0tucRo1FtAxhMxy+2i7j1yYiTmPl8\n", + "1gk+fMqyoChzvv3tbwPwxBNP4HkeV65cIQjsItrv+0gp0Kq9R09zLISTZSvCKMbzPaTrEDsO/V5i\n", + "u6HpDNcPmM1muI5PrxczGIyoyobz6ZQsy8nznOEwJU1tbmXd5Vienp4Sx7H113E9GwbdNuS5tfyt\n", + "m5YosvJ/pRTz+ZymrjlZZqRpSr/fJ8/LrgqVG0LDg47J9jbV0gqH9vf3WSwW9Ho97t69C8B73/se\n", + "bt8+xPd9Tk5OePyRR7hx4waO47CcLzk42Oe5575DHMfs7e+Spj2+/fy32d3bxfEDludT4ihiZ2cL\n", + "jFVIb+/u0rQt5xcXHFzZZzpbIFpN2usxWyyIoxDXDzk7P2dra4I2Bm2s6OjSwQHPf+uQwHMBQ7+X\n", + "UhZ202m79dAa9om3YOLfe/xrYeBCiM8B/1P356eMMcdCiD3gT40xj3fVtzbG/KPu578A/Lox5svf\n", + "83s2Ffi/+IPPbgQ66/YT7gs4Vl1lfB+WKqUEpfFc1zqJGfv1EoNQGpQhHPQ4K1f87hc+T70s+MWP\n", + "f5ImKxlubXOymtEPrFLS87z71IIXeJ7PYNCnrmscx7V5ilWG73sdrufjdGnW8/miw/jUJo3c+g0L\n", + "6toGBWgtkI6L5/vW06WtqOuSVis812E5X5BlVmQwGvRI4hDPdfiFf/NX33L+/+P/8JfY29tjsVjw\n", + "8MPX2dnZ4caNG0gp+fEf/zEWi4VdQBdLIj9gPp+zvb29cSVcVzRxHFtFqOgqxo75EkURYRhRlnUH\n", + "v8SbaibPc1arjNuHN3nqqacAged69Ho9tNbkeb5J20nTnq0aMfQHPRzHIeuSxTWa+WyBMYbhcEye\n", + "54CkbQ1RGNkq1A9oW43juggpmU6n1E1FnMQEQUDbaJIkts/nOORZjtEa1/U3N3qapgBUSqG1Yjab\n", + "otoaY1qkkDiOpZtGUUQURFZ56NhrcrGwn6v1FId+v9cVDeqesEx6HW7uQtcKK6WYzefM5kumsznG\n", + "OMwXS3bGPXppzGhsvThmsylaK/Z2d4jjhLqyuLFS9ypwY+wCvqHKSm8zt6jbhtlsxp07doG6dOkS\n", + "47GdITRNtZFkJ0nCcrnsYMoWKQxtq7pZk4vWBke6aAyLlU0w0trgOIKvfvlLfOhDHyaKIhwvoKrq\n", + "Dt+WVGVj7SDixLodGuurUte1LVwcZ5N6VJbVZtZi4TnR5cG61HVDUVYbAzopJUEY2q6nLIn8iNbY\n", + "eDWlFZ/+uY8/sAL/3B/8Kdf3djdrx5oEkaapDfuI7bVy+fJlHMehWC0Zjyf0Bz1efumVbjBZs729\n", + "ze3bt+n1+tbnxfN4885t3vWuh7k4m4Ix9Pv9LlCjsEZfUjJbzImTmNBxyLKCIAy7rqPpZjjWzsDz\n", + "XIxROK5LsZpyfHSXqshp6hJhdHdtdkrMTUEr3pFG+K+MgQshrgMfAP4K2DXGHHffOgZ2u79fAu5f\n", + "rG9jK/G3PeI4/i5F5ZpGswk0bu/5oGymtsI6+kkh0UIjux0rQBD5LrUvOTEV/9fv/R7+rOQTH/0o\n", + "tYDtvT3c1lY6y2yOKzyGwwFN0zIY9BmPxxY3Pb9gPB5b850wwg9dsmzF0dFRt9AlxHFMHKf00j51\n", + "XTGbzTk5PsPxBdKRJHHK7t420+mC+XxJVZd4vt8JlxKkhPliieOFRLFASsPZxYxbt5eMv8dYZ338\n", + "1E99jLOzU0ajAVpr7t69y8HBAW1b8+KLL7C9vY3n9dnb3aHMSyaTCYPBYOOjvPYitt4Xawt0Q9PU\n", + "JInlwX/xi1/kU5/6FJ7n0LYNo3EfIRyiOAQBTz31FCcnJ1y+fJmyLDAYBn0bJLy3t4cxgqqyqTBF\n", + "U3PnzhGe73TZpD6e67I1mWwWF9fphtWtoKpqO4BiSa/XxxMuQsJg0KMo7HBrPpsxHAw5unuHy5cv\n", + "07aKKAg3mGzbthRlSdaFSITpAATsXzqgrivqqqBta4zRNmG+rJhMXMplxmJ6yvXr1xmORjhC4ruu\n", + "3UTobI97FnISUpKXDWenJ3ie3eQ9aYdzjuNyfHTC9o6Vvg9HE8p8xv7lA6oit/7bdc3ly5doa+sd\n", + "E8cxQRBSZLndDIzuOo17EASmoixLdnZ2eO655zg4OOCxxx7tukCfLMvwfRelmk1ItuO4eF6A47j4\n", + "nkvbVliJxDpAQFtXvFbR71mbiHW7f+fO3c5dsCYwdtE9OjrBcRx66eDeIDsI0F2FfHp6ysnJEVtb\n", + "O11nFjCZdJmwiyXz2RIhDaPRaJO67rly81msIT9HCkbDAW1VEwe2o3unY2/bDh/7/b6lDHreZhH3\n", + "PI8kSRBCcHR0xNbWFo1qWOVL8jLn0cfeRZaVHB8fM53N2N7Z5fDwkMFgQNtqrl27xs2bt9nf30ca\n", + "zY0bt3jyycdtUVNW+EHAZGvMydk52g+J05Tlcrmxvrh7fMRkssUqz4nCED/wWWU5vhMxmezyxuuv\n", + "EvghVb7qcldLlGo2C7iUzju+93+lBbyDT/4P4D83xizvZ4UYY4xYB7w9+HjHEv/+xOZ169A9p13M\n", + "78vL21BuzD1fk/uNrgb4LE3LQhq+8rVnuHt4h7/9sZ9lGCU4QcT5ck4SxSReQLgTI6W0hjltQ6us\n", + "nWkv7ZMkl3Acj7IsWS4XIG271+v1CIKAsqw5Pz9nenHB4e1DHMdlMtni4OAKtSo6TmnNCy++gOv6\n", + "DAZDPDdAaUUY9lgtF1S1TSPf2t6jbSqWizmt7+EHLkfHxw88V4eHt9na2uL4+Jivfe1rDIdDDg4u\n", + "dV4TEbdu3WJvb4+XX3qZNEr5N/7W32I6nWGMvs9Twuvc4XJczyfPS7J8ycuvvEiWFbznPU9Z21sp\n", + "kdLZ0DyFgH4/YbVacf36VU5PzwF44403GPSHDAbWfxwka/P96WKJ71vLgSxfIQTMplOWiwXPPPMN\n", + "/t7f+/u25RaSKB4QhiG9fp9VnqF1y9HxXVsRui69NGUwGHD58mXmsylJvM3x0RFVXbNcZmxvbxNF\n", + "Ab3egKZtO4xzwfHRGQaDEGZTnQqhmV6cd8NVybeefwnX9RjELs8//x2asuJDH/oQ4/EI3zcIycZt\n", + "b9UlsW+Nx7i7O2itqIuyo5UecXp6xvve9zR1o4miGMfzaOstEBAnCacnp2RZzsXFBb7rWfHJasVi\n", + "PieNrYMfwt64QdDZIkuB79kN9NVXX+XKlSvd5tVQdRuStZld0uv1uDi/YDwZ0zZWUzG9mJL2YqTQ\n", + "rMME1vdNXuR4nkfVLfp5XmxS2i0915qKLWdzDg4u0bYajOwCGGocR1K3JcZodnd2uH7tGqssp2ms\n", + "Pe1samGv/mDAQw9fQ6uG5XJJWZTWs186G0jOpmo5XRFVcmkyIvIEJnR5p2Ax3wHhe51S0hYrfvfv\n", + "waDPcmnZS77vkecZSRoRRBFvvvEGF7MZg/6AR979CK+99gZV07Czv0etWrJVQSqTLulngQM8/vhj\n", + "HB+fUtc1o8mEi+mFtd0Y9BGtZjqdkiQJZWl9jS5fvsRqlQOCVZbjVrWt7qXA9wKCIKYqM/wwBN0i\n", + "HQfZsenabm7wTsf3XcCFEB528f7fjDGf6758LITYM8YcCSH2gZP1GgNcue/hB93XHnD8OgD/8//6\n", + "Eh/+kffzkQ9/YONlHATBJsQhCIJ7FrGbQAZD0A3e1kNPLQy6VrSJy//9V1/i+S9/lY+87wPUvqRR\n", + "LUFWMRqmNKGHWJbUdYnuFFO9fkxV1rRtzSpbbCAdC5uk1E2FMYr5bInn+QR+yO72DkVRMhkLsiyn\n", + "qStywPHt67HGOC5KGVRbdwGoAWhFU9e40sEow+2btwhDjzgOSBKf5UITBA/G+5IkQXX0qEuXLjEc\n", + "Dnn00cc3FcfZ2RnPPvssg/6Qn/75f8yq/ccQ2Ep7jaRl7b1/VLW9AvoT+2d9GOwEWnVXiOiukhYI\n", + "+/br4z37tfX/gbfcZMPud8a9t76Xj30C4E8J7qO8190v8K3PD9vhWx+3WoHj2tc4Gtuv7e199894\n", + "LpQFBD4c7L3lVwBw7dK9v7/3iQf/zP1H3ANf/AlJlFBVFdPpOa7nEXUsKqvcgyiKO59vF4NmuVgQ\n", + "+NaWtGpbtnd3GNYDhDCEvo/SLb00xevCHgxrOwhQjUJ3BlZF50kOmt3dbaS03ZPvWSgHbCCJlJI0\n", + "SRAGtGpZzOdMxiOyzLpEam2ju7S2ENU6g7HXsyZcge8TRdEGdtjasjbJSRpTFhYecD0fz+8cEIUg\n", + "duwH1rYty6WF0cLAQ4QBvZ5VPreNpipytFG4jsSN7WvWxtA0tnhyHJc8WxIGPkkc4Tmg6xKj6s38\n", + "5kFHnS+IkqENjigLVqsVUgrrlug6uK4kzzOEsNGBTuByMb9gtL1lnSVXMxYvr9jd3ePGmzfwwoAw\n", + "jgjSkOVyYaHTLmT67OyM7e0xRVGyXC0Z9PrMlwuy5ZK97d1NMpiFKUtOT89JElv4jMcjSwbIcwLX\n", + "RxjDaLzFSy/e7QI4KkDxzDPP8vVvPt91Se98Xb7jAi5sqf1PgO8YY/6H+77128C/D/yj7v+fu+/r\n", + "/1QI8d9joZN3A1958G//dQD+g3/vcwghNgt2ntvByDqVQnr2JUqzVlbaynu1WhEEwcagSkrJscqZ\n", + "naz4xr/4l/zkR36C/YPLeGlMNl0yu3tK9npJsD1kNB6zNephTfxLTk9OiJOYycSuOGvPlaLMUB0n\n", + "ejgcMh5PUEpzfn5OluUb45n9/UtdGsgRTaMoqgIpHOIkIU0CfN+2+IeHdwiCgDDw6KUpQZjg+n5H\n", + "P2u4OD9lvpgzeBsIxbrLWerV1tYWeZ7zzDPPEMeJrYB296mqhr29Sw98/F8f/9+OxXxFEHpcvXqV\n", + "WrUsVyuW8wVVWeK6LhcXF2xv7zAa9ZCe9bQIAp+yyCnLgqoqmM8Vqqm4ffsWH/sbH6UpavKOD9/v\n", + "oKg1rVbcl+Xq+Q6np6cURdHNZxzSpLfBse3A2QpB9vb2qNaWsolNr0riGNU2GARKW+YUHVZujGE+\n", + "mzMeTfC9gLyDcqzHft4pnj2yLANjmF6c4Qf33PSkutcFu25nHdvW333yBJal0yoc97vnWY4T0bQW\n", + "UtFabGAc15eoViEkuO8AJai64ji7Q5Zbf/blqiUMI6qqZL644Pr165yenqK1IctWHCQH3UxnDkLy\n", + "kQ99mG9+61mSNGJnbwutFC+/8hLj8YQ49MmX1l/94YceoqoqXn/tdfb2L7GztcXJ2Sm9NMEPAl5/\n", + "/VV2dnaJk5ibN28yGg5Jk4jlcsn2zjZnZ+f0+32kgCB0qcqG4WhEVddMvBThO6im5CMf/gAf+pGn\n", + "LTdfOPyT/+Wfve17/34V+EeBXwW+JYT4Rve1/wr4b4HfFEL8XToaIYAx5jtCiN8EvoMt2P6++T5T\n", + "0vXFuvY4uT9abS3m2GRiKoXsEkCklChsnqWUEuE6iEmPP/4fP8uHHnqM6wcHaE/iNy3RsEf/0h4y\n", + "q1ktl7x5dsTJnduMBkNGoxHDgQ0SzlYZaxcy13WJO5Otphte3blziO8HG5HCmgZ1fn6CkIIgcPH8\n", + "mDRJN2yIvF6xVAuSJOHqwWWL0eYFqm6Y5WfWnlNqoihksZwSdUKLBx5CkOXWR1t3wQFhGHF8fMqT\n", + "Tz3FbDrF8yNuHd7lAx/+Pp/sXx//2ofr2e7vzTffwA0DKwyKAtIkoSgKstWK/f19qqqkKTKEY2c5\n", + "nu/g+QnD4YCiyDaJO9PplK3RCBHHtE2L6ehjSncsrO46t+203GDgQWjtTvOi2EQErm8zSwdVtKol\n", + "iqJuSGxwpQtGIF0Hzw3QZg1bOmitiMKY2XSKAPzAp9/vMxkPmc3nlKVD2y5RqiHLloShDRheC3DW\n", + "1DfVDYzbVqHWgcydJYbSClM1+K5P01R4fkAYel0KU40UgsB3kY7sONCSVVHY4WccfZdW5HuPum1J\n", + "4pgw8MmzFUa3OBJ8zyWJYzskxCDQ7GxvkS2W6KYlDiOklDz7zW8wHo04PzlGChvycf3qZctmSQcY\n", + "1RKFPvPZFN/3Obi8z2w+I8+WCAFNVVLXFTtbWzRVyfF8xsH+Pk3TsJjNSdMe+XJF5PvopkW6LlVl\n", + "z5U2LQ8//BDz6QlB4KB0C8bO+jzH35A53vaafKdvGmP+grf3S/mZt3nMPwT+4Ts+633HGuteU4nS\n", + "NGU8HlN2fMzA8zf4rVYaR0gcz+7yRZ4jPNdSdKTgN37jN2iqko//zY9TouxN0TQcnZ5y5J7SMy57\n", + "6YinrzxJUytOjo955eXXaJqGnZ0ddnd38Ty7WVRVRVHaRGzRcTu3t7epqorFwgoXkiRmMEg3tMfZ\n", + "bMb01FKYwiAgDiMbbLxaMT0/p65r61I4HJIk6QZnfumVF3hzMWOyNcL3Hc7OTh54ro6Oj0iSBOlI\n", + "iqywWPzZOWna5+WXX6Wua9Kkj1LvhBj+9fH/9gjjkPFwgBCCZVGyXC45PT2lLEv6aY/xeEwcRyxX\n", + "S7SxlfHZ2Tm+F1KUJUkUAobAT+yQrKmom5okjtFKIaRDFPdQyqBNi+ZeYVPVNsmnqirCKMKg8IMI\n", + "1RiaRiGEIQgCoihiubLhvrOZVezaGEJFVTQ0bUurFRqbKdvrpTidT/xkPLbDyU49qHWLIwXn52dM\n", + "JhOGwwGLxZLR0HaIGlC6JQzCTsthMVttFJ7nWrZV26JN3WH1LW3V3nPm1BplLGvE9/0ueWhi4SjH\n", + "wY1iLmYzZjPrDf/Rt/lcqkaDUyDEWs0tUKphsbCCp7q2uo7z83MWc4sbWtioh+e45MsFbWXZM2EQ\n", + "WP63Y4hDl9nFBVVV0UvTjlihybOMy/v75GXBKsuYbI04Oz9HCo/xaNh56y/Z3d2lLHILGXV5B2Fo\n", + "4eFWW/voprCc9JPjW1YsJcDxPRzh4EiPzhXrbY8fuBJzvcO4rttZNt6DU4wxm+obbXDW6ReNomqq\n", + "jkKWITyXr3/5GY6+9RKf+PTPcdysiGpDJBxEGHIluUQjQUlYlDXh7SMqNyRNhmw/uU9dV5RlwXKZ\n", + "kWUrjNFdlW2TqDXa+nd73oYu6Lou5+fnrCnu60U89H3qssEoyPPVhj41Gg0tDUtr6rKgLkuU1ixX\n", + "S4Qw7O9u43gOr73+MmkvfeC5+vSnP8ULL7zYWegaMIL9/cu4rsd8vmA4GFt88wdgj/D/h6MsM158\n", + "+Q5JHONHKX7Ht9ZKY7RmsVigtbUV8AIP13NJ0gjXsfYMUkJTVZ3VQoHnulRVgRQ2I1QgNqHYQoJw\n", + "7lXXYRgShiFZlhFFAa26R7ddUyfzPKeqSsIooOyKj7OzM/b39yjzmjRN6Ro3kJbVVRQFvucTRQnL\n", + "xQopbMReXdcMh0OiKGJ3d2djcTwY9CmKbJPmFMb35jJO13EIaYfGrhsjhGW7RLGFXKqsQnTKXNfx\n", + "8HyfvCw2NE2wNM68KDBhDykl4509+qP7hjTfcwjHJ88X2O457Fg2mji2EWxVVTKdtvS6+2p2anHt\n", + "07tHpGmCMJrVbEbT1F0+b21TsFyXvGkQCBZdQMXWyK5RJyc2F7asai4uLjAYmspG/8WxJUh85zvP\n", + "s7Oza7/frWVJYvnyjTa0bUWezXFES6sajBEbnYuFoayFwzsdP/AFHNhMWteY8pqXHMcxBRX9KMUF\n", + "dNni+j4tBuN5EFjj9tOjY269cZtf/OmfYzzYwm00XhDSaI1uW7J5hh/4+GFAL0zRMkC1Ga0qWOVL\n", + "ojBiNLEKsDgZsVquoIvciqLQ8rhdj/lixtnJKb7nEcUxg14fz3M2VbkxhijycB0X4Tok6ZjlMmM6\n", + "O9+o0UbDIV5glYTL1ZwwcpGOR1kW3L51xCc+9vFuIPZfv+U8DfoTfuxHfxKlWp599lu8+eabtG3L\n", + "Bz7wPm7cuElZllaQ4j/4Y/3sZ38V1/WR0qGpawaDIdeuXeW973sC62vcgjEkcUKR5xwdHvHMM8/w\n", + "0Z/4CYIg5PD2IYN+yv7+Hn4QMJ1ObQ7ockkUp8RxQqM1y6Xl8cZxvHFZi+MIgyCKIppacTFbsr29\n", + "y8npKU3TUjcGz3UtbTPwmYy3rMWu53N8fMKrr75qlXXA1u4+nm+VpFI4FEXB+fk5ZZVzdnbKfD6j\n", + "LAuuP3QNzzQ8/fTTJElMUZS2rV0sOlM0TRhGpGlqvaSTIUWeo7Shad9a77XGY7J92YbxNiuc0KOl\n", + "RWHFP34cUVY1eVawWmUM+kPL6IkDmrYljVO7sIQJnhcR+i6urBHChoYYo4nSAa7vU5d2yK613fSz\n", + "1YpstbBc4jbAk5YRrTplskCQJgGutDd8EiZoIC8Ur756mytXr+KFAXVT01Q10khcz6cfhEjpoFpF\n", + "OoyQQmJQIBxmizlZtmJnewc/CBHawfMCIt+gTENVFhR5QaMsLNi2lkfuuuuQXkkURriei+tYdWYo\n", + "7aJq51n2eftxYG0yXEPTKjwZ4TsRWgQIYRAtuO9QiYquGxHSo240YWJnCYF0cFwXRzrkVYH0rMvp\n", + "yPVRrWK8v81ytbTpR1KQhBG3bx+yd/Val4oU4TkJ0hEIKSiKFdPpBYNBnyzPEFLilBX9/oCyrNjZ\n", + "2aIsS4wyeJ7D1tYYpWpAsbW1ZYOmtUI1NbUqaJuaNPG58eYhSRjjSUup1MpSo6X8/oXYD4WZ1YOo\n", + "hGs+Z+tqVFmT+hFSGUBSC4OIQiplcxL/8l/+BYHr8sGn3kfQtUDrQaTbiTXgXoJ9VVUgW+Iktrto\n", + "WUInIQ9D+7Ou423kwatV1k2DLUYfhuFmo1mHMazpj3Vrn9sKGBRhR+pfm+CUZYlSiqIoGAxS5osp\n", + "s9mMKIp4+umnN/z3p3/kE285b8998882Qpw1JXA2m/H666+zvb3N6ekpN2/eROmWH/2x/+4tj//s\n", + "Z3/VyuWFpG0Vvucx2ZownZ1SlSWPPPzQRnThSpckTtjb3aWuGvq9fhdGbD1fFvMZAhiNRoy3JtZw\n", + "SmmCOMZx7Aa36aAMrDJrpFVVNU2tmM2sSZDjeKS9PspYOK2uaxaLZYejKqqqYji0wbbaGMqixEtS\n", + "bt64SZ7nnJ1dWBN9CZcu7TMaDQjDAOlImqYin51tAkNc1yVJEoIg2ARdryPKyrJEtfbcCCFIer/4\n", + "lvNXlp+nbZuugiopihzPsdDaYrFkMZuzs73D1niC47jUZYV0JKWqaZWiKmtcN6Aqyq7Sa3ClpCxz\n", + "q5TsoA2lrfS+ripAMx4NiSKfYa9HGAXUVUEGVtwGAAAgAElEQVQYBhg8kC5SCtra2glYQYxLWTdk\n", + "eUHd2Gvt1p1Dev0e29s7BJ7XXQMtTdN0SfIODvYcCQlR5KCNxdGzbIXRkqpocaSd/Xi+QxjaMBK/\n", + "O5/ra9wYDeZePqaFcNru7y1aaVzX60KbXUQ3oPQ8vxPFBVbUpy17x1bUik988mcfKOT5/d//PI4n\n", + "bQqX4yAdF9Z2rd17shoSl1YpfFdvrk2bZeog1xmpRYHABm+PxmM8GXSD4V0cT3amc/cGsHVjTcKa\n", + "VhEHVlS2XoPWh9tZ2QZ+aKFhwIscLs7PmEyG3Dm8zSCJEcby/qW4l/WrzQ95Is/9GDi81ZWwyApi\n", + "P7AXWl4SxjEyDGi1olEtr7z0Mrdu3ODTn/w5SzWSAs+xkWW6KsmKnKIs6ff7Ngnd9/Arn6opLAyB\n", + "lYv7vqUrzqYzVqusw7itYKfX61EUBVVV3WMFdEOcLMuYTWddUhD4YYwfBPT7fTzP2wwzl8slcRwy\n", + "nZ6TJCnDYZ8v/9WXOD8/5TOf+QyDweC7vEQeeK4AKYTd5Tsf4TAIeOThh+3iFMdc2t9nla0e+PjR\n", + "YEBZWsVc2rey9/lsStvUaKV4/fU3aJqGp558itF4wmq54uVXX7cBwEKyXC5573ueBCSPvPsxXEei\n", + "teL01GYL7u7t40qH+dxWuLrD4sMwRCLIuzT6s5Pb7O9dBgRNo7h7eBs3tNCU3TQmlFVpVYJa88Yb\n", + "b3By3NLr9xkNh7RlyfnpMdvbO/SuHlBW1qcm9FxLNTUGoZUNzA2CTaJ9nltLg7VvTBzHm5bXLvI2\n", + "4Wk2XTzw/DmOZ+mrquHstMERCTdv3OTFF9/AcyTD4YCTk2/zsZ/8KChNo0t8xyXyJK0wbO1tk2UF\n", + "vSSiLBuQDlVZgxvQtg1tXXN4+w3C0O9yIX22JjtkyznaGOazBZcu7aNVi9KWmRLFPlVV4Lg2zFoZ\n", + "O79RyiCkw9HxHYR02Zps4wU29Dhb5vi+bzc66TAaja2IpKo7FadLWWXdfRAwHA4RODgiwGjrEdOq\n", + "GqXswmy4F8TidzREIe457Lmue8/+Yl2oYQOvLUTJJsMULPTYtsqm0AsbYfaghXt9SCFpKgt7lEWB\n", + "7wd4fkBT13hBRF1VlGXFYDiARqGVdZs0Wnc+34bAt4tuvzeyiuaoh2oMZW0hzvliRl5kHFy+RKtt\n", + "WLjWmiCw6uWmzijye0K5jdNnV7QlsaU4Oo59P0dHdyjyHN93iMPQQrRS4PseriO72cf3D2z4gVfg\n", + "f/4nn9vg3Gs/lPXi7TgOwhGYTiKrFUjfszRm1+HGrZt84fc+z9NPvIfY9bl85cBWNq1NuvE8jzCK\n", + "cB2HvCg4Pj6mrmuiMCRJ12rKiLZpO4tPs5H5Sik3oboAvm8n82Fo0zzWVUWv1+sqBssYmC9XNE3L\n", + "bD6jbVsODg6696W4c+fOphv44hf/hKtXDvjML/8dq0jshhyu61IUBT/yE596y3n79jf/DKV0p6CT\n", + "GzP4JEko8gLp3JeQXX36LY9/4fn/hrq2IiTdWai6roOmRQiH6XTK1atXObp7ysXFdIP1R1HciS4k\n", + "rhB84AMf4M7hbc7PThkOrLhpe3ub4Whsbzop8TwfrRRKt2hjL2IpJPP5gjTtg4HAt1z5OEkomnwD\n", + "bSxXKwI/RDoO/X6Pfq+PNpoir3jttdcYjPY2sxMhHKSQ9AcDhIA8z8iyhRUg6RansznY6VwE53Ob\n", + "sNK27aby3pjp+x5BGCCEg+O8NZP05q1/uoFn0D57e7ukaYyUgmy1wJiWIHRxJYShx3g8om5KVFVT\n", + "VzVlZVv9VoM2EuH6nF/MyPKcVZaxvbPLsO8TeJIwCK1SVggGnd902zZkyxVKKwI/YJVbAVNdVx2M\n", + "YuciSisWy4ybN2+R9gf0+gMGg1HXbRS0nWRetS2mY4rEcUyZrRd2n1ZV3L17yLve/VCnavQQ2sFx\n", + "bBC344oucNkgHLnhk1dVZamOVbExqFt3Omul5fpedx0rEgrCgFbds0/VyqC0ArNOZ29RWvHxT/78\n", + "AxfyP/zCH+L5Et8PrLma6+IHAUrbXFxtBBqD0RrpOGAEbdOSJsnmHlpbHAsgW2XWVM33aVXZFVWW\n", + "EtrrWadSPwjwfJ8syykLew82dc5gMNjoWXzf4/zsdGPq5TgS6Ugbsi4N2WoFaBxhcITAdyVVWeC6\n", + "zgZiklL+cKfS359leb9cfpNO3yrquiVKEipqGhReGPP6jTd59hvf5On3vJdhnLK7tcOqu2iUUhSd\n", + "LajFsSOiKOLKtauEYUhRFDRlQ5GXlEWFrW3thTGdzrGOcX2CILDS28YKCeq6piiKTSKQXQRq8twy\n", + "ZjzPI4l7HQ3KIS+yjn9q28deL+Xk9IRvfvMb/NIv/ZKlHXXRcHme24X4HdJ4JKJTyXWJHdLBd1za\n", + "umHY71MU1nVPPviz5sMf+hBVWZFlK55//jmMgbSXYoTm/PyCy5cPmE0XlFWN6/t4YYQx0GiDkIL+\n", + "YEi+WvH7f/hHXN7btRa7aYzve5yennPj5m2apqHfH1ie7PaEtqODOoDrSLYndtAqcJjPpyRJj/Ns\n", + "hXENniNwhMPo0j6rLKOuao4Pb9NOJhvP8X4aotoS6fpcTKcEfkDgh9xZzhiNRoAmCnyGg5S2qSmz\n", + "nFa13Lx1k63JhF6/x3wx77zi7U0ZxRFGa0pV07QNRbFkPHrr+RNCcHBwhSAIENrvFLAhdVPiuy6e\n", + "77DKZhT5Cq1bgiAgTWO049k4vknCcpHhCMkqr1icn3Pz1m0eefej7O7vk/Z6mDbDERrHtV2pFIKs\n", + "sNL/uqpJ+yNUY9PmJ3FCozRy7enTWDOwsix57fU3uHxwQBSndtES1s4zCGKiUH6XsVXT1lSVNW+z\n", + "g80SbZqN+jSKIqR08Z0Qpehk8Iq21ZhuwF+W5aYzjeOYNEmstzx6s2hb/5N6U5Fb5oqh3hjaORRF\n", + "bl0SjV3UpBQ48j412QMOAbR1TVNVuJ5H0+XkOtIF17XwpwBhBKy7wsDH9y23PeqiDgWQ5Tmj8ZC6\n", + "qmjqCkSz2YSqsqAsC4IgpCpLVKvB2OvaMsASa/CmNU1dM73IN5BokoTkWU4Sp3iug3BdVss5jhT4\n", + "nmeH256D53tgjC3UMO/YkcMPwQJuyft601rBd5ubu8KxhvKOwGiFcF1mywVVVfHct77Fr3zm32Vn\n", + "MKap6o3Zj/UwCUnTFN/3mc1mzOdzXn/9dStqSBIu71+h3x/i+z6LxWxjubn2Jy6KjOl0uvErXzvt\n", + "lWW5ERtpbdWRvZ71wq6qiuPTYzw/IEkiXM/ae+Z5ies6vPbaa7z8yov8Z//Jf0qeZYRBwNnZ2cbP\n", + "ommaDnPMHniu1jfUertZXxxrepkUAs/3kY7D/AH7QC9OkEAYeHz6U5+y8MSbb3B2ccZkPKFuLJyU\n", + "ZTn7lw64dXibIAgIhGA5W3L36JgwCImShOl8jnSsF/XZ6ckGaur3++zu7uJ7Hi+88ALj8Zjd3Z2N\n", + "urSuarQy9PtD9h99lOVyZQUWdc7Z2ZnFULXBlQ6T/b2NYX6WZRweHlrhh9Akkcu7Hno/VWUx8zWc\n", + "dX5+aisgzxok7e/v43keaWpl6qvVCjA0bWNtFDq7Uiklo60B2ggmkwn5Az6CNE0775mWIrOV+9m5\n", + "ZS8kcQQ47O1eoj9IWc3ngOH4+IS418P1Y5RwSUdDzk4vOn8Pzfvf9xRXrlxlsVySxAlN6yCl7XYW\n", + "iwV+GFJX1jo3TfscHt7Z3C91W9G0FUZZV0HHcXj4oYeIk5TxZMzV69c7f5ma1WpF3aWxt3XTVXly\n", + "U11ubU/QnfTe9z3atsbzfI6PTzuKYkimCjwv7BgxgVWD2v9QVSV5nrFcLq3dcdN2/PXGGod1VOB1\n", + "V7dmcwVdpWwMuK5DHEf3Cjm6gHJt0OrtF7I0iVjrgNd8cY01lTNGb6yi67q2VM0woCoz5jMrrNHa\n", + "sOxsn5MoAlMjpcI4qoMq7TWyWmVcvXq1q85DFsslIGm6oPU8y7qNSHRMNttxRGGA0Yo48qnKnKDz\n", + "En/zzdeZjIZ2o/JtIRsGdvamOyOrd+K/ww8BhPJnf/RbmwHI2t9kzX113c7bOwwpdUuLpsVweHjI\n", + "b/3vn+VnP/Ez7G1tE3ZTZeHbSn7tz71us8NO+LCW5BdFgR3urz3IAawrX1mWtsISAs9zNxtLWZbU\n", + "nT/11taWdYWrm82GsTbgwnFo2obpdNopzyxe9sorL/PwIw/xcz/zM2TZ2mjH35jVrIda6/PwgR/7\n", + "2bectxee+bMOa78X5AxsBBXr1yKQXBQ//ZbHD4I/IIwCYA1TKaq6AsdCRrPZiovplLyouHX7kNli\n", + "bqXG8znzxYw4Tgg6e9HxaIAwmsB1uXb1Cv1enziKqJqa4+NTloslbec9UpYFaZpsbtiP/vhPkucF\n", + "vh9SVzW+FyA9K+tefwZrs6M4jjc5qZvuqrZDQdVqgiCkrhuSOOk+K3A9t0vwsc6AaZreS4DpPkPr\n", + "Y21fX7/ft9WuZ1N3iqIkTX/5Lecvyz6P6Gh7vtcNsc1auWsVwXXncZPnOXEUkWU5IvRZZhmz6QW+\n", + "61IUKy7v7TMeDvB9rwts6RLJXdvuW+c/e8060qPIC4y+l2w0n89p2oqqKfA9Fykki8Wc27duMRgO\n", + "efrp91M1NZ4XYBB4ro/R3WstKzzPparK7l4RuJ4DSm/+7fseWb6gP0gIAmsHqxqN6wRY98jG3jcC\n", + "tGEztxoOB7RtgyudDd9bSGG9VlTbDSVNR4VVBH6I0y3u90OnQEe3bAhDm/jzU5/8hQdCKF/90l/S\n", + "Nh31uMuVVVrjeN5Gou969j1IKZGOsX7xYdTh1eviTxEEHhgLxa3tXS1V0y7gnm/dSNeMqvVw3MKo\n", + "NhClqkpL+Vwtqaui6zokfuATBjZ1av/yAS++8AKDfo+qLIjDAN2dHztPYDOI/aFO5PF9n+VyueFI\n", + "rhfvjQubkEwXM6JBn6auCeKIv/jzP+fDH/wRHn34EXRXwTuewyovNk54a/jEdd1Nyop1AowYjUY4\n", + "2Ipt7V0dxzHWyN1CLIvFgiAIN2yPvb19hBDcvXuX55//NlVVcenSJa5cuYIxhvPzU6qqZracI117\n", + "AW5vb/OtZ5/lma9/nV/7j36NRx66zmq5tC1YVXaWAVYGnSTJxm7T87wHnqu6bdAYgi4PVAirStUY\n", + "vMDHdB++5znwgArccRy00lR1uRk6OY6D53hkWcFwOMDzA1zH5/pDD+P7Pn/xl3+OEJq6KTCmpVGC\n", + "KA7IshW7O1tc2t3j6Ogut27fRLUGx3XY29snCEPe9/TTfP2Zr/Lo449z5fIBOztbnJ9d0DRNB021\n", + "OEJycXFBa9aBGAH9fo809Te45Hw+ZzabURQFSZIw3h4jhB2CqdYghMPJyclGdRiGFpO/tL/HQw8/\n", + "bAfNsxlNY82flss5Z2e2a9jZseItYxT5akFV1yThg3n4168esMrt7zqZnnXCD+sbsjUYEgQhi/mK\n", + "PC9xHI/ZfEVRFOTzBVmRg7Z2s4M05uq1A1whEVqh2wbVtNAUFFWL6EIEHMehLuvufrCv4c7hEc8/\n", + "/zwf/OAHkY4kikPiKO70BjbIwu8GoDagwYZxqFZhtO0i1ou31SeMaNrKWlOE4aYYMEYQx9b3JQx9\n", + "q9EwEimsuMQySixcU1S1NS+bTrm4uKCuKzzXwZFOByOlhJ3qcT1fWuPiUkqUVtTN2lL3HqV43YmX\n", + "RUXVbZAPOsqmIg1DdLcxrPNyW6PxPJ+uQttsDEY1COyw1HEc/MBFqwaJzRew1b+ynu+uLeYwsL29\n", + "hSPdDftL1RWNskNcISyHPwwCyiLrjLm8jotu8DyXfLXCd11Ojk9I0pR+L8WREt+1CVjrHIAwtNRl\n", + "pfQPfwX+pT/73U2lfH+ihyWytyjdtRdRQF6X/MEX/oDXX3qZf+sXfpHt8QSlWk7Ozoh6KalvB4Rr\n", + "+lKSJBsf7PWiuKY12ay/HmFovQrazouhqupNosjayxdsyvR6MJamCVJaOuJyOcf3feI4thWNalHG\n", + "8nafffZZ9vf2+du/9G+DMLR1Ywcpa7L+fUlE601rbQP69I++Vej67Wf+dNPyr7uMdWW5HsDqruVb\n", + "lG+t4MfJn6BU0+HJfod/tthaR2ATQCwvPUkS/uhP/pjPf+H3GU2GbO+MuXv3LhqX0XCAxKYg9ZKI\n", + "tm2ZTWdMJluMRmOiOOX09JQoCNne2iKOI6azC6qipN/rsbe7Ry/t0zZdSovn44aWuWA7iWbzvuI4\n", + "7gIQ7EZcVhVxmto5RtNSlQ2TyZZVL2rdia8awjBgsZyjNdR1Q9o9ZpWtbDVrbDW/XK3A2HvcD+Dk\n", + "5Iz9/Us8+sR/+ZbzVxW/g9OlK/mhZeDUdWvTZlpbhdd1w+Htu0RxghSSyWSbCmXNzaTA6AajWkaD\n", + "Hk1Zgrb5lGuvjwqN232OsmOpBEHAzZs3efnlV3n88SfY2tqmyIsO1jY2iUgppICzszP6/T6j8diy\n", + "Q4x1c1TK+ubb19puOpz1daS1Jgmj7hxamOPw8E3iNGB313acURCjWkHTWHqh1lYO7nYMLmCDcRut\n", + "aLuu8LsXIUFVlbabC+zQ0fWs73sYBh1d13TdqER1Zl5aGX7ip376gRX47/7O/wlKITZ+LC5SOmiw\n", + "GZX6nk2HQeBKGwKjlcb37canVNe9Cvt8Aus9JPC6e8o6kgK4XYZAh9J0j1dI2YmQcksL7fXSbq6V\n", + "E3Yb2Wq1su/NtRAfxuAIg+qu2fVMzL5LiXQcnnr/x354K/B1COpmaAmbqbDrujZJ3pFcTKecXpzz\n", + "5b/8Ep/+6U+i65Yyy3E9j4MrVyhNS6gdFvOF5aVKiWpaksiGF2ilbEXg+8RhxHw14/DOIfP5nMl4\n", + "Qpr26PVS8vx4o5wqy5Lr1x+i3xsxHI5JkpSzs1PquiGKAuI4Io5DZvMptw9v2eo3DsjLkme/8Q3+\n", + "nc98hsuXD1iuFoRBgERYlaRNOwUDnut1vshe11IGG+bL9x73w0JrGGU92V/DD0opu3iVb32849oh\n", + "yVr2rI31bBZCIFyXulJMJhMuLmb81m/9Fq+8+hLXrx2wyhZMT09Io4BZVnJ2foxuNaqtef/T76Ms\n", + "c6I4wvU9zi4uCPKCK1evoOqWo5MTqo5GNRrbUOcXXnyJqqz46I9/1M43lKE1Vu4tHckg7YGBsiop\n", + "iiVFWXTdiSSOo85vwzIpWtXw2muvdfhqyGQy6qCakNRofC9gtVrRti3PfvObPPbYY6SJlbKvufxr\n", + "ubkxBe96+BHKqn7ryQNcR1AUOWWZITKxmYusq8oir3j55ZfZ2h6SptZOQWlN5Ph4nt2wk37Kar6w\n", + "TBPPhjlorWmUQdUtDU3XkUr8IKIsS27deIO7x6d87GM/2eV1RhRFhut11Ww38ErT1ApFjP1ssqLa\n", + "mE6tq0Q/8PCSiCIvcN0EMChlF0xVNx0zp8JxOlGV726YTnEYoZVAiHX4So3SFl5cR6NZyCPEc1xc\n", + "V240E2t4xM6DLHtjPrfZqR1PcMPEWhck6/AHx/OJ4+SBnwlAnCZ4woYnCyFplUI6DkIbVBcIAQIj\n", + "bGUf+V0GgWOQEowGre8XrQsczwVj503ScZGhi+e53e8Ct6NKNqpGqZYsXzCfTzEGBoNBR41uyFZL\n", + "JpMJ6+zY5XLJbDaziUm+T9tUtE2LVi15rjY+T47rAeYdSQ3wQ7CAb3Db+z609R/HcSi19VbYvbTP\n", + "P/vNf85HPvIR3vPEk5iqYXp2hpaQHdZ4aUwfn+FwuMGS1+3gsEvcsNWHolY1g8GA8XiElJKqshP3\n", + "07NTHMfh2rVrjMfWMnK1yrh794gbN25ijCFNE8bjUZf+oTk/P8NxJVeuWPObrz/7TXAEv/Zrf9cq\n", + "GoscPwio64bQ9xFC4rl+Jx66123cX6W8HYTSGo0WNmauVi1N59rmeR7LfD1AkRuHxu89qqq65yvT\n", + "QVRSOmijaYqCwI85PT3lr/7qq7zy8suMRkOWqxlx6NOqFtdzSBI7VPQch73dXVqlcH2PNIgR0qFp\n", + "c67uPcThnTsYJdCq4cknn0RKydnJCS/ffZ3xcMje7h4vvfQScWyrlEtXdvEDm/yyXM4B20lFcUCv\n", + "HyOkRHXVXLYqGY3GaG2sEKtYt82OFe/kOa+88krnzWHdI8uy5IMf/OAGprNKTEu5XHvUaCXx4wjn\n", + "bZzvHAFbYysvr1pF07bMZ0ta1VKWOdPplP39fSaTcbcQWWGJaAy+b8Uc+XxKVeZI0We1yizVTXpI\n", + "6SMCj9SPiJR9P1prAt/j+eee48knnqAsM3w/5PDwVue2VyG0IYpCHN9nPp12sWY2XSZMYmvj2tQb\n", + "TnKer+xgrts4vA4bLsuKnclW18VBGITkxZxldkEcjzk/P+fCXGCMxPeirlO23cjag2VtPqe1Zcys\n", + "7+91hqstLhKkdPA8gef59HouXmCv9/Xwcs1Kk67XDXNX5PnbL2RVVeD4AcZoWqVxO2Zb3bS4Qna2\n", + "0XJDLaZzT9RabRgxVtAjWYddCByEMOi2QQor9KkrK0SylrF2jVGmQQhDlq8Iw6C7rqwEfjwcEQRh\n", + "F/AQMZvNqKsKBzvotDYGDlIIwjjeXIdt29poNekQBg/wVL7v+IEv4GESQqeOFAh03RJ4PqptKJqa\n", + "OooJ/YC//PO/oFxkTB4eMruYM+oPuXL9XRgpqVVLXpW0RYEWDkbCfFWQ5xdUVYPvn28SdzzHVgyn\n", + "5zOLt/Z6tBqSdEAUW3N94bgc3j3CdT2GgwH94Ygsz2hqi6U3pubi4rzzNnao2ppnn3+uSxj/ed73\n", + "3vcCoOoG33XQSnWLtyAMLNskjC0VqerEC9pY7qsylkL2wHPlB5shpvStcm3THgpnczGqt6H/r61D\n", + "bfCvgzYKsN4y9uJv+MrXvsY3v/0tRtvWQ9oLfTAKzxh0o1CrnN2dbfb29rsE7ojRZIs/+uMv4ng+\n", + "QZTw3AsvYoyhF/fZ3ppw49YhTVeFP/auR/EDnzfffIMbN25QV1XHX7eVy5Url7l69WrHDrCbe1mW\n", + "tI2FEqQj6Q96KGXjvdZp7I5roRLHcUhTm224XC75xle+wrVrV9npjMh82YUDO5DnBaHnYtqKrFgh\n", + "HWsolWUZ/QfcN3VbIxtBoxpkF3Hm9/sYA0UeUK4KpIFsZoVAUgqCMCT0fMqspJ+kFI6L50gLpegG\n", + "oe0CJByXum6JwxCBocotJbZWDYN+wmhon0dIh/3dPRsMXWbdIiyoG4Xn+9YB0bMeKHt7O6AUpaoI\n", + "wgA/iikdF600OtCbzctxBVHfZ7GYYrSx/OZiRRyH3Lx1h4cefhfDARssWCnLFMrzAq0Urck3s6I1\n", + "/Oi6VsbuuS5xkmIwnUajpm4aPMfHYLttVSvKDn7yXB/P86lbxahvdQJJEiLE29vJ9pMxqipwpUPg\n", + "2yq+KUv8wF7vyigMGmE0AgGO5awLV6NpQWmUbhBCgtb257WwcY3SMmmksCrMuq5BCLRSG88V3/cI\n", + "XEGLXYjDMMJ3faq6pWlywjBCtQ3z2Tl1VXFweZ8ktqpMYwyu56INtF0cpOu6G9dVpd45E/MHvoCX\n", + "Zdlle9mKO/QT6rICJEkc40Q+h7dv8zu//dt8/G/8TR5/92OgDId371JXLcJxSHspcZoShNZvo6ob\n", + "/CBgNJ5sZK2LxYI33rxBnq/Y3t5mb3+Htax+sVjS1C2ua7FfEB2uqjg6PiZObfvWG/SIoogXX3qB\n", + "OI4oihwj4Etf/hKu6/Jf/IN/QOj5qK6rcDsZ+bqiW1d9VVXhKsu2sM9373twzxr0e4+6M/laS8yN\n", + "tgO8tRdG1eULvl0FueaZu65VLLZ1TeD71mrUkTz/nRf56jNfZTzZompqlNG4QqIahSMEi8WS69eu\n", + "s7+/z9Wr13j3ux/l5q3bDEZjfvnv/DLfeO45jk9PCcOI+XyON/I5v5hSlzmB6xH4Pm+8+SZlaX0z\n", + "rl27xkMPXe9ofj0bcVYUHB0d8ZWvfIXRaMjjjz1K27ZcurRPWRaURUmtbc6i6/j4nofWsFotbUch\n", + "BFlecHxyzHK55Kn3PEEcx2R5TuD7rDKbEVk3NY4riaJ7NghGtGgNURTxIBAlisJNhmrbNhtKqVaK\n", + "O4d3uHr1gK3R2MJ3XcXpSIemaRFSUlQlZ2dnCGFv2n4vpW01seBe+rl0aZsGpSw8lhU5/w9zbx6k\n", + "yX3e931+fXe/95w7szN74sbuAuAFEOAFUjzEkKJIKiIpKpQtq+I4FeeQK3EsV6pUFqVSlSJKtiU7\n", + "lVCmJMuUYikyKVmEDlIEDwggQRD3sYu9d2d2zvc++v7lj1//et4FZ5dOpVxUo1BY7O47M2+/3U8/\n", + "z/f5HqurK6BuEfrdnqKKGia2Y2Ea6r5Jk1RZKhsKdohjZbI0M9vCDGE0GjAejgv1oyoKdmG3qvBf\n", + "k8D3lKQfSPIM13E4e/Ys97/xDQyHQyqVagEzSIKgUuDYHnEhk4+iiDRNGAz6qOCIvNwrqc48w/Mc\n", + "MFSUout5WKZAmBZz9TpIwSSMyXOJ45m02zulCCbLMu6/QQ0ZjoYEtksSK/sKIdT9IFB0Ptu0EKY2\n", + "nANhSkQRESHzDMOQOKbKq0yTBIlUk24U43oOYTgmz9VORttr6ElDRQU2qQQ+0lbkCf2AsiwbQ0AY\n", + "TmjvbGOZBourB6lWfMJiKoE9Qz/DMIv3en3E5M2OH3gBrwUVZW1pmERRwdMsMuykVFDx2TNnuefU\n", + "vVQrNVzPYzIYcuTIEZIkZTgaEUYRURSWjIQ4UoKGzc3N0vdC0f9mmUx8JDlnzpwpvTFarRae5xNH\n", + "SUkzHI/H5QYdobrj7e3tYjRWnYNipLzA+973Hk6dOlXikdMOi6PRqIimsqZufnUDaQsBDfloxsyN\n", + "jml6pU5hsSy7XIR6BYtA3MD4ZzKZlN/TtCw8IyDLcySQRgmPf+sJms1muYQJPJ/xsAd5TpIl3HnH\n", + "nczOznHvvffieT7D4YiFuXkuXr7C8Vtv58Qdd3LlyhXi8ZiV5SXCMCTPclZWVmhUq0zGIwa9iIMH\n", + "l0tl69raOhgGFd9ncXGROFbCqPvuu1sA0v4AACAASURBVI9GvY4QCu44e/Ycs7MzVKtVfKGc77a3\n", + "27z86qtFUVSTFQXTYjIZc+LESSzPpj8eKHrpOKJaqRImikZnGAZSqA4tSzNymWAYis4Y7/MxqAKh\n", + "aaMm9XpAo15hbW0N11XxaP1er6SX6c9YFDBZliUcOXKESThmNB6RjSUStWuxLAfX9QmL7yEMgQVk\n", + "eZEdaZsYhkmtXsGxPSVBlwmQk2WpsnAVJqZlk6Tq9w1hcf7sWZqtJoFfIQiqWKbJcDRS2KrMSLMI\n", + "QxhE8RhDGIjCJMu0TJAJy0sLXLx0gePHj6lu33KQhV95luUk6YgsT4rrz8Y03bIQ7XmE5/oCZjJS\n", + "C+Q4jumPO0jU9Ol7AY6roBnTsHEsswxYgT1tyA3uDEajIhpuEuG6Doal6oB2ORRCfRamZZGkKqmH\n", + "HLI0Ic5TyHMFxRdMljRNEBJGY5XHqXNlfd8vbTSmJw4hDJJCSW0VRl6OayOznG53RBzHLCzMldFx\n", + "Upp7rJiiYdPQ0TSU/Le+gHc7HbWMsz1l/DOe4AY+mczJkYTjnL957HHe/773cfDAEsPBgCSMCEOF\n", + "EzaadeYdl1zmrK1dUdxhv8rhw4sl1Wxzc5Pt7U1FMQxcDh48yJEjh+l2u1y7do1XX30VIdRS6vjx\n", + "45iWwMhVNt/W1harqwcRhig2/Wqb/5d//hesrBzk0//sF9htbxMXS5xmva4c3QrRAlAKjPSH7nne\n", + "dTQ+/f95ntNsNm+4uNCiHT16aQGK7go0z1kvhl97aMxT25NKKZmEIa7r8Su/+qvMLcwzCUNMU00P\n", + "/X6XZq1Gd3eH40eOEHgB9XqTxcUlJQyJUzAN7jl5iu9897vccdddfOyjH+W3fvtzBK5DHIf0+32u\n", + "XUu5EIbYhsl999xLkiR0en3OXbjIzMwMFc/HECbPP/c8w9GQU6dO0WrN8tILz/PKK68wNz/Dgw8+\n", + "WLAWIgbDXiG7j7nvvnuYTCY06w2SOGEwHJAU+OtgMMDxXHY77fLB5eUp43BceI24CCkwMcnJqfg+\n", + "aZopIdU+d0atVi2tU8NwwqCvPK5d12E06jM/22J3t1PSOzWsECcJlq0SzHe7HVxXWTyMx2oJPzu3\n", + "QBwr5WYUhorlkGujNI80ikjCqLxeyFM8R6kToyQsBF1GSc/LpcD3a+RZwvLyEi+++CLf/e7T9PtD\n", + "br/9dg4dOqSotKZZmIU1S4sHUYhfsixhPBhy4q47+LM/+xLHjhxWPiN1B9O2yXOBMFHGTqZeaqZM\n", + "wknZoADlfksv4OuVqlpW5irwQfsFjSdjBoOeMoFLMrI8w3KcsrG5WSFrNQIMoTDk5kyLOI4YDYb4\n", + "votZyNJFscBMkxTHNYsHdqqWp4YgyXKiSUiaxgXdNmM8GmNY6p4KQ7V30ROzZruAgWkqrN6SOcOB\n", + "ahbq9TqmIdTEWOwkHMdmOBwWy1CvpFLC9UV8OsThRveyPn7gBbxZbyjAHmVviZGSZBk4FoZp8m9+\n", + "4zc5fuQYhjCJJhG+51Lx/D13v/GI3fYOlmVx4MAiWaYWMv1+l6QQgrRm6qysLJUYVhhO2N3ZJUlT\n", + "Dh5c4dChQ4wKFVWneKAYhoFlG8wvzNLr90p60enTp7Ftmw9/+Ec5ceKEMqnyK4SR4iinSVIWcJ3+\n", + "HkVRiV2D4jpreqNepCm5snHd33vtoW8C3/fLbj0rvD70AshxHIRhsLH7va/3vL0c0dF4zHA8wvN9\n", + "vv3E41i2jUR16Y6jYsB812P96lXuuPVWjh45wv1vup9hlPDiCy9z5MgRXFulEw0HQ44fO8qw16NS\n", + "r/LRD/0Ir5w+zU5nh8B3ESbESUxQq9PpdXFsB9OyWFlZQQhFYdtttwmCCkePHiOOE7785S/jex6v\n", + "f8MbmJud5dr6Bt1uF893qTdmsW2T2dlFOu02ruOyu7uDZZpYpsCr+QR+gGsbnD7zMisrK2r6STMm\n", + "4zFB4GEXRUFKyNMEpGQ0Soubav/zPx6NQIjCs8ZUZkiOTRInzM40OX36lSLYWS1US6VsQQuk0Bnk\n", + "eYZhGWRS0tneoV5XeP5wNC5yX0UhgFG+2jmUMYNBEBDHym/EsIxCbr3nRy9ziWWapEmMzFLW166y\n", + "duUS73z47Rw+fLQQNaWFiMkoqJtpAREoGp3qRHMaCy3StMblS+cxTKXYjKKQLAc1/Qtsy8Yw05Jp\n", + "Uq3UyoKpKYE6ljDPc/JQqWAVvTAljlX0m2kIZpr1opApvnguTIzCLvdmdOc43jN3G40UldR2TBWY\n", + "EMYqjUcor21TGIThnsw2S1PCcEKWZ9iFSEsIyMip1SvkZDRbDWXoZuiOWcEdKs1InXMJas/gOEgJ\n", + "SRzTLQLF69UKrVaDKIqKWMa05PXD3nSh3+M0oeH/d6jxf+7DtixknKuLHInr+iQCeuGIbz31JNub\n", + "23zkQx9WF+54QqfTYdQfMDMzQ6vVotGo47g2mcwZDPoF9cin2WyWGGWn06bfV3ztxcV5KhWfNJGE\n", + "3R4b1zYJKl5J/Wk0GoxGI7a2tgrhSIDjqLzDL33pS3zkIx/hoYceVIu1VPFh0zQpg0u9Ij5KU9QU\n", + "XzYv1Z26g9OdiX4Q6dF8NBqVAbmvPcIwLB8u+nW6eOt/9ffd7xiPVeeZSQWbBJUKcZJw5tVX8SsB\n", + "/cGgOG8TLNNkZ3OTe0+eREi45+S9tHfb5JbDbXfcySsvvcTr7r2XjY0NgiAAabG2vUazWWN+ZobD\n", + "P/Qunjv7Ck8/9V3OnbugaGjVKv3RiKqvzCk8LyhglkwxDmyLtY1rtNttFhYWOXRolY2NDZ749rfp\n", + "tNu8+c0PsLKywtr6Os1mk06nQ61axXEt0kSp6wwD2jttusVkUg18uu1doiji4PIyeRpTaTVI4hgy\n", + "hZmnmYIAXC8oWEkR+/U9UahUdZVqlSRKmZlpkeeQWAZLSwcQQjEZ4jgkigplLIIkV0Tzai2gUq0q\n", + "IdVEpdY0Gk0GwyGN1gx5BnEaYZnFQ9o2SJK4pOVdW19X+Yrzi1QqVeI0JpeKL24YBRUXtXPJsoTh\n", + "aMD58+d405vexPLyshIGReOCZZFjGsX1aKqgatPU/iRKDJYlMa7nUq14dHZ2aM7OYVsuwrDJMslg\n", + "MGQ0GhJHe4ZgqvFRylA9cdqO8shX2Z42CCX4yjALNotHnilWTzgJGY3Gxc/lFUIbB9u+calyHYv+\n", + "YIJpGYhc4rpKKZrECUbBbkPmZMIgF5AJ5QWvCqWgVglKVopWQiIVVJlJ5TujmCoaFtN0QlFg6Op9\n", + "TgqbYG08lmXKgqNWrZQTuYJRrRKS0fe+Ltp6IlGLdvP7QEd/Cwr4ZDxBSIMojpjECXbFJyYnThKe\n", + "eOJbPPz2tzPo90kjdWEfXlktseAoCul2R0WX41CrNUpxwfb2pqKh+T4LC3Ml1LC1tYUKgnWoVqtK\n", + "Rp0ney5qcYznuTiOhevWSZKE82fPkmUp/9s//TkWFhYYDofUC3l2XES/pWmGX/gYl91QQVfTF7Ye\n", + "jcIwLAuvHuX1QkQv1PY7NDVSCy9c1wVE2TVrCOXGLBZfpbwIJdc2LJPvPP0svf6ASiXAEIrnnEQR\n", + "eZpy+NAqnudxz4mTXLt2jcOHDtOP9sbJK1euqGiw4oFx9OhhTp8+zcrKCt1OxNzMHHfeeTcPP/wu\n", + "nnrqaZAwGYc0Wi3lmpdmgKECbwWlEVOt1sCwbZ55/gV2d3Y4sLjAfa8/xm6nyytnXsX3PY4IOHBg\n", + "idFwSK/fV0tTy8QyDQ4cOECn02VhfoZhGLK7u4ttmvQ6Xebn5pgMR1jF2G/bFo5pYRQLbQ177Ode\n", + "evXqZXrdHsPhgDRVOOntt9/O7Owc3W6P1ZVDZKnyTp+YY0zTRpgGwjQVDTJLiCLFmR+NxoU9Q8Jo\n", + "NOLK1TX6/SF5mtFsNgpfEI/xaITj2IzHIyWyMgz64wm1gmdeqVaKrrmwZ03SIpBYvZ9Dhw5x9OhR\n", + "0jRWnap+f6jOVTcStm1eZwuBzMtp7eSpk1y8eIFbXY8sGyjOtKF40rbt4BaFaboZ0ZNlmqaMhiNV\n", + "2AqmlerKE7IsRSCLh5AqjGbpIupiC3tPtZneeDfU3tkiziW1WhUpM0bjCZZ2Z0RgmIrPnWXKM92y\n", + "HSzbKeEiDRnlBX/cKKBKVbQ1rHQ9xVlxzgVmEeI8Ho9J8vS6ohsELr5rkyQxiu4ulJNhcb701Dzd\n", + "lIWF5fL079/s+IEXcGmglglS4lcrRAWv+OWnn2F+dp43vv51yFxFP127do31q2u4jsPc3By1WpVW\n", + "a7bkmqZ5VJL/pVQk+MFgwGik7CFnZmaZnZ0nyzK6nX6BR9mYlrrY1VhJadr/yCOPsLCwwA+/772s\n", + "rqwwGAxKrFnn+OkLVX+wtm1e9/TUF7O+GbR8WP+5xkqnR0QNvbz20B+6/uC1eEUXdP11b/ShJ0lC\n", + "GmUKwxQSMoOvPvpVjh07TrvdLqxsR8g0xXMdGvU6D9x/PwcWDxCOxjz73HPcfd/rMAyDRqPOpQsX\n", + "mJubKx86ijGxymg85vjx42z2+/T7p3n44btp7/b4zGc+w8LCIlGUsLS0TBInSvBhWGBIDKDm+VRr\n", + "FQZd5cMSVCt0+n02trfIsoxjx47RatYZTSZ86c8fYXnpAEHglzCJBC6tr5GlGdud3UI4JZmdmVF5\n", + "kYOBUkUKg1SmhGMlEjIdB3dqibTfce7sq9x5553cdutx5udnSQpPFr+QsucyYzgY4rqOilAzjWIp\n", + "lhSqPYHrOEQTpQGI45hOp8O19U0WFhaZnZlh0B8W6fQKn7YdlWOJYTKOlCy+c+FKCVPMz87guh4L\n", + "Cwuqy7YsPLfCYNDF95Vvjy4Gjm2WTAqEwLZUgHAS712bonh4qVxVQRjG3Hr8Ni5eusTdlkksMypB\n", + "QLfTI6jWQGYIaSvJ/5SffZopiq1rO3i2StzJ8wyrYpPEkaL1CTCQICR5noEUJaSWJCkmIHPNe7mx\n", + "pNx1LPIkwjQyTKsIJTfNItUd7GJHkOcGWWYipbLCBSXgkQiEaWIaexF2+r42LIHMwbKcQmRjljut\n", + "LMuxLBUmAmqaywtoqFapFIU4xTCsPVaSaZKmOWkaludcq8+nXVh1k/q3voCnBSfZNC3COFb0nWHE\n", + "Y1//Bu9817vp9zqlJeny4kKBISrJ6sWLlxR+7PkEgY9hu8pz1zBIkqw0l1dhxDHj8YSrV9eROaXf\n", + "r6I/hSBUYd3Z2WZzc5M8z/jYx36cu+66C/KMJI6Zn5slDFX0Vb1WY1ywOgwhsGzVLSRxVJ54/dTW\n", + "Pt9aTDFt2qU79Gkxz42EPNNba/2U18otDZ3EcYxh7v+hu66LKVVRHEchj/zFX9BstmjvtsnSBJkb\n", + "irNc8NaPHD7M4oEDDPoDXNvh6PHjbG1tsLCwAEhWDx/i1VdfZXV1lUyqBWmOxaTT5ZVXz7J4cJVB\n", + "f8inf+EXefb552m2ZonihKeffY5qtY7vVcilwDQEUZqUC9rJTpskjnD8gNbcHDs72+y02+RpyqVL\n", + "l7l0KaXd7tBsNomzlDuPHePChQv0B/1yuVuv15mdm6fVajAcDLh86bLqSFdWcH0fyzIw2QsOieKY\n", + "0XC4lzvZ+N7z92M/9tHSC340HKpOyrJwbItWo04mJZ43C2R4vl2EBSeFWEphyGmqzKLGgwGvnj5D\n", + "vdHkjjtuYzQcMxqOEAK2tzfJMrVMzYuRPo5jkrQwZnI8kkTR37Z227TbXfLseY4dPcqxo0cxTUGn\n", + "vcOZM69w9Mhh6o06nmtjGntiLu1ZbRTLuJIRFcd4nirQlUqFOI6Yn1/k8cefYHNzk6Wlg3iOw+xs\n", + "E6Sh4JocwEJP+3sNiUD7ecs0JU1jttY2SNIE17JwPQclmy/or8IgzZRPOUDgKBVpnueFZmH/I0sz\n", + "Kp6HWyzojQLKKlxkydKMNFOwiZr29ha+Wn9pCOXxmRQNl2EIzEKGn6YplYpbUDAL7rxpYpqioEmG\n", + "RaFVX6tSqRTNXVbK87Xzo2naxX2bXAeFqmSksKwButH7fscPvICbtkUmYRxOqDUaRFHCNx/9OiYm\n", + "KwcOULHMYvEYkWaqMxVCFMnuFSjGxiiKC2WeJI7TovtWIbNK8lzFNC2qlRpJkpEkUZmckRT5lL1e\n", + "j7m5Ge6//35WV1VHNx6PcUwDmasNs2VZyCxjUGDqQkKeq0DTPM/JUcbtmkKl3Mmi0mVQy92noZLp\n", + "gqxH2v0OPeLDHpwyvfBQ/tQ+whSwjx2qngT6/QFhGnP5yhU832fUH2LbDjLPCMMJzXoNWfhE7O7u\n", + "Uq1UkVIoQYZpcO7cOe6+8y4GgwELBxZJC0WbYSlTqUOHD3P5yhV+8zf+FRtbW4DB0oGDtDsd6o0m\n", + "87PzbGxucestt2IWHZcwDNI8V/i8st0jjEK2L19mOOgTxhFzs3P4QYDnwMxsi/5gwIWLF+kPR0wi\n", + "te1XylCXZmPIc6+cphrYLCwssHRgiTRJaQ967PY6LMzN4xUeHnEY4fse8/PzdDqdGy6Odnd3aNTr\n", + "kOdEkwkyzbAdm52dHcVrdlX2ZafbodlskUuJMCS2Vci7DWW/m2YZ58+eYXV1hdbMLN1OnyxL8D2n\n", + "DMltt9sIy+TK1avkuaTZmmFrexcJ+EGNRqPJ7vYGQmaly+Mrp89w6fJlAt/n7rvu4IM/8iHyLOHy\n", + "lTXuuO04ScFY0X4l0z462qLWcRy+8pWvEgQtXNdWDZEJURgzGYVsbqxjGIqiVwmq5LkEw8QoAo21\n", + "DkGLaPJMFU3HNfD8gKDmkeYJVglFJFhmgyiKkbnE96vkWcZwMKBW9yiee9xkh0klCJDkGLLoplGv\n", + "yQtXP2UjoHz0JRKZ5eRSdd/p1ASsz4GCkFTEogqr8AhDVXuq1aryRMq0x7leZuZkaU6r1cAwFVyW\n", + "56KsA+pehTyPsaaMqvT31If+XFTcnPG3n4WSSUkuwa9WmEQR7d0OL734Ig+//WGMHHZ3tnFcl1qt\n", + "VsidZWEYo+hanutTqVRptRyiTBnLTyaK4XH48BEcx+LatQ2uXr1KFMb4frXocNVT78yZM3S7XU6c\n", + "vIu3ve0tHDt2DLVtV6pL11P5kMMiZFk/NbUgB4yy6OoRKMvSfccjoKQRAtctfqY30Tcq4JpuOB0/\n", + "N/1rbahv2vtj4GmaqvFP5mrKkJJcSmVrS06UKDZG4Ae84Q33ceKuE+zs7HLu/DlWVw6T5Rm+73Lq\n", + "1AlefvEllpcPYts2586d49gtxwknE+YWFvn6Nx/j9z7/eeq1Waq1uloMSck7Hv6hUgW6u73Dk08+\n", + "yWxLQRtBs1787I6y1TQMAlMoloKUJHlKf9CnVq8xHg/IpeSBN7+Zo8eO43oev/brv45hWuy021i2\n", + "TXfQZzQeg0w4d/kK1UoF0zCpBgEzzRZhlDI/P0+tWiUFusMxa2sbxRS2w90z+1yracKrZ84ofUBQ\n", + "ISjk47bt0O52lNilVim6sknpUZMXLAXDMAkqHtvbina6enCZ8Thkbk5laD711FOAUlGeOHGCxkyL\n", + "jywvIw2T8TgkzSWW7bK2volp2cg0JHAthsMh19avcf78Oba2d3AdmyuXL/HMM/Pcc89JDiwucOny\n", + "ZQ6vLgOUbCc1ziuP9PF4zObmJufPn+e97/0AplElSaOCz2yyfGCJF198gcUDd1INKiVW63oeFBCe\n", + "SlEvEqOEqrymuefdIwSIHBzDAZEjc20+llELgoJpFmMKweLcPGE6Ku+Hm3Wjmo8NlFh7mioISBgm\n", + "hgApNVyZI1PAUPeMzBRdWd9X+h7SnbdfqZDnGbOzMyUcq+m4WsyjfgYT17aVcCuOyWWq7kORF/TT\n", + "nCTJmEwiJlmI61rle1NOktcH2+jm7Pu5Ef7AC3iepmBZjMcjojjlueeeZXZmhuWlRdIkIQiqGIZg\n", + "WBj/+75f5FVaxcZX0h/21BIqE9TqNexM2T3u7rYV/Q/wAx/XU0u/Tmebi+fOUatVufXWI9x3773q\n", + "dbZFHE6U6ZNlYhZBs1ESlswQzf/UbIRcKvaDUnWprjXL9mhP05j8NDtEXyzT5P3pTmC/Iy0Kvpo0\n", + "FPYm80yN1Za6GQf98Q0hlLzgwpqOzatnXqXieAzHI9WzGIIonDDTrFOrVFhdXmE4HKqQhkaD4WhC\n", + "LiXbWzuE45Cl5SV227usrK5y+913sLG1jTAsfvvf/QFnXj2LX2li+Q1a8weYnZnF9RziKMIPfMgl\n", + "hw8d4fbbbitG8JxB1KPT3mVjc4sojqg36ooK6DvsrF9mMOgiyGnMVvjAw+9hcXERWzN+8ow3v+F1\n", + "PPb4E8w1agxHQ0bdjjK8yjImvQH/4nc+w5VLlxiPRvz1V/6ax597HikEQbXKgaUDBNUKTcth+eAK\n", + "tNv7nr+dTpvF5UXllR1HrPe3SaIUUwjq1RoL8/NYhsFkNKZ3bYdRX3mRGxWfequJkJIkTtjd2uWN\n", + "r38j45GSyw+HHbIsp9Wos7G1xbsefgutmRnGkwiShDiZYAsTyzCwDMGxlQNgGAiRY5ATxw0Orx7k\n", + "oQfvByQbGxv0uh2uXVvnb554go1r1zh69DC33XKce+45xYEDi7TbO4rOaAosx2Lr0haGafDD7//h\n", + "AgocKrELKUkMnq9UrM1GU1EVbQc/qBR0RiWssiyTPDcoel5VsIUOJi7sYwvVtX6ogcC0LCUjJ8N0\n", + "FU4f53EZEYi8WSImhdy9CAQuIFQyAUJ13HletPEUakdLSesRql83JAjDVmHIgGEqy9wso1gQC7rd\n", + "HlKqGEJNC95b2iYqvCFNGY1HmKahJspUFePJJCoaLVFwwCmndA2VTE8A0w3cjeBUffzAC3i1WiXJ\n", + "JIiURnOGZ55+hve8+90gi4Ty0ZBWq0W9rkDJMAyLNBOmONHqv0Q5L7/8Eo5jq47dUZhYGE3IpYIH\n", + "HnvsMVzX5WMf/SgrKwfLp10cTZB5kUQ/ycoTKqUsjGwKz5J8KnQ5jr4n5++19CC9eNQ4uF446iXm\n", + "dPHWXcaN3AizdE/8o7+W66ivjVQ+4Z7rgoDuPl9CMSFSakGFF55/gVajgWvZCNuk3+tRb9QZ9Pus\n", + "vvGNhW/4GNOMlb+5oYJgF+YXGAwGnD1/llOnTvHq+bOsrB4iySX/9Of+CbffcTdetcHtt92JsALq\n", + "9Tr9QRff8vBMG0MYWK4FApJUkqHGeN/zsBYWOHTkCC+8+BL9wYDN7W1qgcfG1jU+/uM/xp2330oc\n", + "hxyozKkJaDzGcSzlCLmzgy0gTyLisWI9OLaNNC0uXLrM1to6Nddnvt7klRdeBMOg2qzTHw7pD0ds\n", + "97p868yrGIZJo9Xi7nu+9/zVZ1sIy+Ty2hWMUUI1qOAZJgsHDtDr9QnziO6gzze+8RhBrUpv0Fcw\n", + "XLdHNJlQrdZ46KG34Hke8wvzDAYDJS7zVH5bnsbMzTXY3dkgjsYsL6/SbbeZnVtUS/koIhpOcDwX\n", + "YZmMxyOyLC3Vxrq5mJ1t0Wo1OHrsKEHwbs6ePcvXHv0q3/ybJ/jLL6ss1k9+8uOYhkGaxDz55JN4\n", + "nsebH3gAJIxGYxVswN50mOeSt7/9bYwn4+K+U5YTGuc2DLPYP1jX2UJcz3EWSumpGR1TeyLD3ivR\n", + "urTLTC019QL4RockVyHGRQZAnudkxfJQlt+7wJWFAKPA6ItoK4EAqYK7BaJk9JiWXbxWLVmVgCss\n", + "GzHtvNhoNK/bb+l6YFt7976mGup7Xv+saZqWHH+dPjVNCf5bv8SMo5hxFONXa3z+85+n2WpSrdXL\n", + "k9CcnSGMIka7k3IR6BfeJFEUMZyoMNwoirAsl5lWo1jGKA74+rV1RqMBUuYcPnyYT33qv+LY0aPE\n", + "k0lJfdIuYNOKr9LO1lIm+VmaXQd1OI5Dmmcljui6bpmKo9kp07/WWNY05jhNL5wu4PV6fd9zNf3B\n", + "AqXz3PQyRMmwb9CBF9/v6tpagbUp8YPhWpiGQRxFpThpNBoq/44sxHFdqo2GEm3InErV5+TJk1y5\n", + "ukaawV995Wt88U/+IwuLq0jhcsstx7GcAEyLcRhhmi7jMMaxbRzfQ6CUb3leJM5YJkmcAxaDXsTi\n", + "wkFazZAoGtFt7/D6e17H607dx2jYo1lt0mnvYhcueO12m8FoyAc+8AF+7Z//c3a2dxDFZNMfDIjC\n", + "mNbMDJ/73Oc4dHAFCkhLCpiMJji2zcbaOq3ZWd7wwJt4+aXTjG6ghD1/6TLDXld56VTqVIKANM85\n", + "c/Y8OZJRHDKOI1730ANgGXhBwGA4xM8yNtfWWVxcxHUddna2Cp8PTbdTwppqLaA77BCGY1zXYzgc\n", + "4PseSTQhzWXBVXeVtUMa43sOAru8JuI4IksihMyxi040HA85uLTIJ3/iE3Q6HS5dvECv1+Wzn/2/\n", + "OHL4ELMzLZaXlrnl2DGiUHvMWGVToa93VVhUzNvMzAxhNGE0GlJvNMilvE4XMU23g+sLqO48r7sX\n", + "ZF5mVU4fprieFXKjIy9EPLCXKaDuY8F+MISOZ9Nfcg9eUR26MneTRRctS3hmOiRGCKGmq+Le22OY\n", + "pCUxQdcQzTbTtUJDMDpaTp9fzf+2C0KEfi83O25awIUQq8DvAop2AP+nlPJfCCF+HvgZYLv4qz8n\n", + "pXykeM0/AX4apQ3476WUf3mz75FkOVKoxdgzzzzLe979HixLpbCoN6N8SizLJgxD2u0uo5GCU3RU\n", + "mlreBQyLLX6ep1y4cIGrV69y6NAqP/nJTxJU1OhTrVaJoohGQymjdIHVJ0x9oHtP0SiKyIvO1ymk\n", + "vdq/xLBUJ5wkSSl/119PX0RRFJUfpP5wtMBBLzeB67637uL3+TzK4q0FA1oary8uKYvtzD5Hnudk\n", + "huDxJx4vOOQSz/dIyYnSFNe26Ha7vPtdyjg/zTJlgG/b7LQ7XLp8iZrvctttd4AwOHLsFv70zx7h\n", + "K49+A8OusrJ6K4btM7dwiLX1dWbmVYDw4sIio8EA168RJSl5mhUm+MXSJgHLbZAkEZOwT6PW4sL2\n", + "aRbmWpx7+SUOL93DN/76Ue45eZKFgwv4C0sMR0Oef+EFsjzj0a99DbPwnYmTRAmLhKA502J3u0uj\n", + "Xufq1XXe8+73Ykp41zvfjV8Jr9fh8wAAIABJREFU+NIjX+Kpp58mmoQMez2+8uKzPPjQWzl37ty+\n", + "5++ZZ55nfn6Wi1ee4fC9JxCTDvOzM6QVi6rnc3zmGGsXL7PUmmN77RpimBBECe2ox+ziHI2ZBmmc\n", + "ML8wx7XNNZaXDhJOtI5AKXAXFxf45mN/g2GYLC0t4TlKMCLyYoIiL6LJDBzLQhZulHmaYSDK60xh\n", + "26MyTq7fH9BsNvBvv500S7j91mM88fhjNGs1Dh86pPY5WU6z0WCn3cav7Plv7xXevb2NZVlFKIjq\n", + "NKWURfjGzYvOa/9Mc7FvdL2+tmm50X2h/zu9I5IoP6XpCVnd2wof3/tRNM5e5FkaipggZYZtK2Mw\n", + "zZ/X978QKlJtetLQ+LnmcU9rQabpvSVFsag5Kl83L6fqOI7Lf7/f8f068AT4n6SUzwghqsBTQoi/\n", + "QhXzz0gpP/OaE3kX8DHgLuAg8GUhxG3yRp8QEEYxrbk5Hn/iW5w6dQqJZP3aOjKX1CvVcrxIkoTx\n", + "ZEKWpti2U3acvX5fLTVHI6LxCN/3cFyXO267lU9+4mPU63Ullc0yAtdDpgm2IRgOhxiGwWQyKRcJ\n", + "0zQe3Y2bponpKdn0NHwhpSTJ0jJBY9qoSgsipj+06Se3znyc5oDrizXPc1WA9jle27nocVGPzmWW\n", + "oGHsy0JRqjiLS5cuYQqlOHQ9jziJiJOYwysHGfa6CKEyDPNcIoXCF+v1OqdOnUJkym3tytoVHnvi\n", + "23z9m9+iMXOAu07cSWtuAcep0OlNWFw8wjDuE1SbDMYRnl9jME5wLAvDskGYSEuSSrU7iIc5hmlj\n", + "mR5JkrI4v8DO1lWiyQiyhM52lz/8/f+bzm6bI7co6wPf96nUqhw8eJCl5WVeb5r8yX/8U8bjCdJQ\n", + "C6xqrUYYRrxy4RXW19d54+vfgGPZCAlvvv8Bzp+/QBiGzFTrmIcO8dyzz3Ly1Kl9z//mxja9Xp87\n", + "77iDYbtPHCecfu5F8jTjwNwCa1eu0KhWueXYMUxDqMg0KTh0/CimpcJv++MhSZySJapLq1ZqmIZZ\n", + "TnEb21vccssxrl6+ShAErCyvkGY5jUaLMAoLj2iHNMuIJiEClYwkhMBEkBZsKMMQBK6HWXzu1QOL\n", + "tDsdgiBgPB6q/YLrcftttyFyWSgYPYa9Ac1ag3GRZzo90vu+R6USlNBBFKkotnqjWdAS1QJf86T3\n", + "iqQs/83zvV2PlLLkg0/HKZTH1L1xM0m5mm6N8n6YpuLpXMnp+8a23alvsSdfVyJATelVXvK6+Oou\n", + "XAjlmaT3YHpK17DR9HT9Wjx7WsMxDaVWKpXyNfrhMA293uy4aQGXUm4AG8Wvh0KIl1GF+QZnnA8B\n", + "vy+lTICLQoizwJuAJ270PXwvwHEcLl68yImTJ8myXHmJGJJxoYzUTzHLskizjGsbG5w/f54sy5ib\n", + "m2NlZYW77rqLlaU5XLfwIjYtpMxpt3dxHBvDUIBXnssy808XZE3X0YVZd8i62yBXH7I+uRr3zuLs\n", + "uqKqC/L0RlwvIXThni6606NliavfhLyv2S/TTBj9YeuvE0VRoXbb5zB0lmGC5XrKmS2OVejsOMR2\n", + "HB588EHFSikuNGEosUcmlf94lCT41SpXr23yN088xcLSYVYP30qlPoNp14hSiVdpstPp4dYshGWT\n", + "xDEZFlKC7VZJ44QMQRYnWJYB0sSyHPIswvcD8mxAmoQImfKz/+N/RxZFtOpNTJTox2t4pYFXmmd0\n", + "u302tja5cOkS4/GEJM0Yjce0Wi0M00GKhGZzht/93d/joTe/hSyJee6557j33nv55Mc/wcuvvMKT\n", + "33kSE8FMo85zTz/NDz28z/lHsHH1Gh943/tJhyFffuIrvOn++/l3f/B53vQzf49Rb8DzL7/Alx/7\n", + "BsduOcaho4eJ4gjv3IvIOMEyDGZmZ0ljVRTOn7vAO97xDqoVn8kkZDQYQ6EflEh6/S4L8/NFRxcD\n", + "WeGzk2MI8FxFY51MJuWEmKUJ9XqdNMs0xEscK8/1arVKHIfYpoFwHWYKE6s8y/BdjyiMsE2LKAwx\n", + "nWKhN7Vgi6KIIFBiqEpFpfXoAmxZRsE+gb2CTXHf6UIurityiPwGFME9Y6fpYn+jY6/QqSmhZIAB\n", + "VuE1n+d7hVp7i2sVpv6e6mfVyT45lgV2EV6hu+9pLYaGi3Q49jTsMX2f6vqia4WmCepOfBpena47\n", + "32/ygP8PGLgQ4ghwH6oYPwT8QyHEp4DvAP9IStkFlrm+WF9lr+Dve9iOjSUM2ru7yCwnSxLSPKJa\n", + "rZHESYnLqfxJ5fk8MzPDj37og8zOzjIzM1MuA2QSFfiRop9Ztkmtqvw2oji9DsZAKOx7+uLX8tky\n", + "l64orHmqCqJbxFNpW9bpoqsxsGlJsf5QprEv/SHpIq+79enR80YXq16UTD/V9ag1rSA0biClNwyD\n", + "aKQmDsu2GYchtmUxHA+p1ap0223OnD6NY9kcWFzA89zS/0HmuRI5WDZJLvjjL/wpx287gV9t4VVb\n", + "pNiQSKSwMHJBfWaOJBuSpjmuVyHNcqrVRsFlVxeeX62ShCGSHClTpFSd6WTc4+L5M/zdn/oJPEvQ\n", + "iyPaO9sMekOyNMcMbIKggucHtFotZmfnWFxa5oEHH+LFF17Gr1bY2tqm1+vhBxW1lAt8ursdPv2L\n", + "v8jRw8fwPZu5uTl+//d/n09/+tNkacojX/4SeZYx22juf/4NWF1eZnP9Gl/71hN0Oh3y55/mh3/0\n", + "R/ijL/wHfupTn+La2hUmvQH/8Kd+hpMnToCUbO1ukUtJvVqj2WwxHqrQ2+eefppvPfEdjh05xvz8\n", + "AttbHdqDXa5trSOznMBXnvPai8MyLYSBSmA3TCWFl8rXW+YSZKY8xpMI07KIoxjLUuyV0XCobJql\n", + "il7r97rcftvtpEmCX1HmaoEfKEjHNMgLdWYGZXdoGMrsybWVmrRarULxgBZCmUUhFSuLohGaLqZl\n", + "R4/EEMq0Shb/qPtjD7/WuLYuhDcrZIqu6RT33J5QzppqiCzLIEnUMlFoszJhFowYfe8osy7L2lNl\n", + "akVsmkqq1WaJBihlZzqlsIYoSq9zIJ2+j6c7+Gl4RR8aQtHFXJvaacLGjY7/pAJewCd/BPwPRSf+\n", + "r4F/VvzxLwC/Cvy9G7z8pih8msT8q9/4TaLJhOeefYZqVSU1e57HwsIiy8tLhXxVFcZqtaYunEKK\n", + "HMeqIEiZk6cRGGALdaEjVAalYZqYFKnsBV4sDFUIdRp9mqqABe1LootkHMdU/KDsQHThni6Y0xeq\n", + "WqYWAQHFA0B3EjofUL9WPwD0k/i67mSfY1p1+dqxcBqCSW/QgesgCPVQSfe66yzDCyrkWc6nPvUp\n", + "dra2yZKYaBKSZDk77V3m5hcIKlVMy+ef/cIvYzlVao053GoTYboYpodhKc5zLiWOaZLmgkpQVUwC\n", + "lSGhzhWQF+HKFCq1PBnj+zbj4ZCdnQ1++qd/CtvIsUzB4oEFLGExGUc4lkNuGqpbdB1M0yJDEkUp\n", + "iIhma5Yky5ibW+Dy5avstrvkeU69WmM4HnP5ylXe/4Ef4dqVy/zKr/zvrK1d5Zd+6Zd461vfSnt7\n", + "m2NHj3Lp0uV9z1/gWEiRY5Jz8t5TfP0b3+DSlctUqyo6r7u7yz13nuDKqxf41U//MqdOnuQTH/tx\n", + "agtzJFlGnsHmxhaGMPAcl/vvf5C77zxFpVLh0qVLLN23TJxN+Lef/7ccWlmhVquxu7vD7OwMUmaY\n", + "pl02C7Zh4DuuylNMs9JfQ19/cah2L0nx9yuBj2kZpIUvSLVawXMdxqMhtmnjWLYKAbZsHNchm5Ku\n", + "T7MroljZAOzsbmOYotA1+IxGQ6S0mQ4H1uZQJQNFqEKq6b/X48eC17pA6vvoZvYG+vXX/51CCp/u\n", + "dbx796kSFxmFkVcUKTjTMCmShKxikhBlsdZxcXmuLD2UX0+t7Mw1zBHHe6wzvaPS97v+OYUQJQVR\n", + "/1zTi2I9Tev3cyNCQ3mObvqn6ovbwP8D/J6U8gsAUsqtqT//LPCnxf+uAatTL18pfm+f4+cB+K1/\n", + "8wqve90p/s7f+VTBqLDKbD0AWZDvTdMqO2OKdAzXtssRTRXCPSghyyWT4ZDRaIzve+XJNE2TDFFm\n", + "AeoPoVKpoJ3oNLND0xTHw9H30H+yLEOYRrlE1EZYjUajGFVjBoNBiasHQVB+uBoP15tnHYyrVaG6\n", + "03/tUalUitDZsHxiT2+xQU0JtuFA/3tfH8cx3WI5rDFXvR/wgwDLFCWuZxsqsd5yDA4dOkScpLz8\n", + "8is8+/IFRpOUI7fcSX1mgVw4mG6FXm9AzfUZDLrMzc1wbX2NW249THu3g+d6ZEmGYxUeynmGKSxk\n", + "FmGZAss2sB2Lrc012jvX+OhHPshsc5Z+b4c4zjBdi8wQ5MIAy1YFy1X+8ZNJhGGpFHIhTFqtWR79\n", + "2teLa9PCMASOY2HbLrV6nXMXzvN//Ovf5OTdd1NrNnjjwWVefPFFtYTzfSSSJN1/iew4Jju7u5w/\n", + "f4ZDB49y5+JBXnr5ZS688CIf/eH/gi/+hz/m7W9/O3fce5Izr57ha09/m8de+C7/6z/6n7n7jjtV\n", + "gR2NMW0b27QYj8Z4nspMXF1dVSyO6izra+ssH1jizJkzHF49xHg8plq4XQqhXBwlgizPCCpeuQjL\n", + "cjV6jwdDKpUKJuYUDAF5muHaDkmqrm/HdghNk14x2VqWKuRMxoqaV0yT+p6yHYvAqzIajZifn6fb\n", + "7bK4eIALF85z5MiRMu0py9KyEGroQnepujvWBUw1JYI8F+VDQjczosCvpxeT+x2vNYArd0TCQAij\n", + "LKa6kBrCvG7yNi1VQBWrSwWW64KtZfdaQa2ayCqTgsWmD91A6c55uhBPF3JdVzTpQTdx+nucOXOG\n", + "9Y1tTp85vy+D5nve+83+UKhHw28BL0kpf33q95eklNeK//0w8Hzx6z8BPi+E+AwKOrkV+Pb+X/3n\n", + "Afiv/+4XFZ6ZxASekiKnSYRpCkzDJBfgugoGqRQLSoVXaW8BdcHEcYztaLMngyColktFfbHoAqrH\n", + "ssmkX44sGovSHinTxVy/dppvmySJih0rZPGVSgXXdcsLwy3Uo3oUHI1GpQJTM000JKJHRd2Vj0b7\n", + "bCBBOe4Vqi394WoKpOd55UUT3iDVR00X6sEDSmqcJAkCNYFUfUWLskwTScHtFUpogTA4efIkX3ns\n", + "eSy/zuz8EkkmsD2XKEqoNVtEUcjsbJMoGnP8+GEGvb6yC85yHNvGtW3y4ubO84goirFciyxNeOXF\n", + "77Kzs0USh3ztq19FZjGua5MlaaHmM0rVaFRwkQUCw1KZi8p1zmJ7p83KyiHiOGFzawvXs+n1uszM\n", + "zWJZFidPnODs2bM8//JLtBpNZmdcPvThH0Xmkmvbl8nIaM3sD6Hc+/oTXL66xvr6NdbWr3Lw4BLz\n", + "C3NIAUEt4GMf+3Geff4FwkgtgFUwQ8Yv/+Knedtb3sInPvEJ6rW6eg/hGCEgTUM8zy6wWMX8eetb\n", + "3057d5vZWcV394vwjVqlopgVKDc80zLpDfrKqMpTNFbLtmgEfmkTIUyjgC0ESZxhWFqJqYzbGs0m\n", + "Fy9eYjQacfXqGpZl8653vhPk1CKwOPTXBG3b4LG2dpWZ2Tk6nU4ZGD19feqCrRsg/TWnp9c83yvQ\n", + "e/e18mrX99vNIJRp1th1X1/kpGleNkx6z5WnGcJQ13+chJDsFVLVPBmEYaTeT9Hs6YfKdGOnz4V+\n", + "f6a5V+inO3BdI3St0WyTaXqiPk+33norx48f560PPUBSeEB99nOfv+F7/34d+EPATwLPCSGeLn7v\n", + "54BPCCHuRcEjF4C/X5y4l4QQ/x54CUiB/1bebPZBeQm027s0zSaTghcrodgIq4u31xsRBAFJGjEa\n", + "D67z2I6iScm3Howne91xwczQxlZ5npNKPWYJaoFyagOuG2X0AkF/OL7vY1etcvmnx5xKpULFqJbd\n", + "T5qm1GoqM1M/OGDP28R13evcBPWEoYvw9IPiRuorjdFP05EGgwG2bdPv9xmNRipdpbI/i0U5L+pz\n", + "khCNJ4CAQmE2HA757Gc/y8EDSwSei2laNFoz+NWARrNFmgue+PZTfOjD/yXStBGmTZzmNOcWuHjx\n", + "AouLC0ShCkxYW79MI6hTqVQYjyfYrsd4PMK1LYSlFG6+77B5bY2nvvsknhmzvblFnqY82t5la2O9\n", + "nMQ8z0MYyq8bQ7C6oPJK4zgmTjN6/X6h5BM4vs9wMMJ29WSSgFQP4+FoyOkzr5KmCeNRTL/f5/kX\n", + "nuMP//iPqAUVvLrFO97xNnL292PvDjocOrZKUPcZ9VIub15lZm6WpaUlBmOVJPTMs88ShRF+YYpV\n", + "rVSpVAVPfutxnnryW/zj/+Ufc+rUPXQ6fWq1WvFZ5kTxqIAixhw7dowXX3ielYPLOEVzkGUZg4Ha\n", + "AQTVqoKTXAvPc4pJLsSyLMbjIaAyJ6XMUGIc6Hf7NOotcpnS6/eYmWnR63XZ3t7G9T0e/9YT2JbL\n", + "Bz/4QXIpsYzrHTOTRCVgaRhxPFYq3SzL2NnZ4fDhwwyHQ3zfLw2zpg9dBvTyeU8yvlf09LW9B18m\n", + "JcR4szKS53k5ieoHh1rAC9RiMy8fPlmWFQZeZkFumDa2ooxAbLVaqqgae77m+ufXjZZunnZ3d5md\n", + "nSVNczqdDoZhcPCgEgkOh0N6vV7JGdf37jRT5bVQqoZyphecNzq+Hwvlm7BvxPkjN3nNLwG/dNPv\n", + "OnV0Oh2Wlpbo9/vlm9DxTnmek2dqtEsTVWQd2yHLcvIsJ5QRju1gmTZZmmObJq7nlt2zik0q7F5R\n", + "vFBQT/XBQGEMlqkWGaLwDYa9gp5nGWEIgzgpFyVIiCKVeJ1L9RVNy0KglXF7DwP1hDWR8npC/95F\n", + "o9gErmPjOLZK8zFubGAThqHKKzTN0t3MDwLiRIU41xtN4MY88igK1fsUBkJYmI5XJMCESubu2PyD\n", + "/+bv0+/2MAWKgmWaDMcTcgz+4N//IUdvuZVRGFJr1LHsgNE4YTQYU6vUSaKYqh8QjcccXFgmzQwQ\n", + "BratzlOtGmAKicxiup0dNjeucvHSedJkwuVrGxhCYJuCnd02s3MLDIcDPD9QnazMyQ3BeDLh7Nkz\n", + "6iGfZRimraTclk2apaRxhB84CMNkEoaMRj18z+fC+XPILMe1LCaTCYHvYloWiwcWeeDBB4ouNUHk\n", + "orQwfe1x8fJVGv0hhmEyHEbcftvtfPtJFTrypgce4Nd/7dd593vfy/mLFzAMQavVpFKp4oqc2VYT\n", + "IQT/8jf+JQ+95S28593vVi6MUaT8tE2DNA4RwuTUyXv5ky/8KeNRSCWoMBiNyJKEarVWcpgty8C2\n", + "TOIkwjTMAobIqVZrajkfRlSCCpNwwqjgg4/DEUJI6vUa3W6XIPAxDZPnnn8eQwje+fA7MAyYhGOE\n", + "LFSLUuJYCkoxMknNrzCeqAfTcDQizTKSNOHCxQssLi4ynowJgkrJpJF6Wi6QANuy1VSm2SXsLS3l\n", + "lATfMEw8FASGkDe1k5WZIMw0Z1qW3b7M1G4oKe5f07KQOQjHJsuVd4tpmogcxqMJEmjW69RqdcV6\n", + "s61yNzYNZegHkOM4TCYTfN8vcPE6Bw8uE8cxvV4XUFOv8ne3SBLliBgVqm7V48lyCtHYuA6Dnma0\n", + "3ej4gSsx6/U6g8GgLN6aRqM70jTZo9VphZLmpgIQ7JnBxGlENNnrwjXP0ijMasyCRicchzSJVZiD\n", + "xuFMk9FwUC4x9fdD5ti2WSyRjBJGcV2X4XBYKNdU0odlWUR6Iz+NHdoWhmGVEI2mRbqOjU4GMQ0D\n", + "WXQjSbI/gd8qICLY6+zzvEgzymX5vV1nfwwdFM6LFAUz0iKKi6DjNEPaJv3BkCxLkEIwmoS4nk+O\n", + "QAqD9c1Nas0lvEoVKSzGwxgvqDGZjJlpzjDsdxC5xDMdHOHQmwypVitUqxUcUxBNBri2yVe//ijI\n", + "hO2dDbq9LoNBj6DqqwdunBAnEdc21osu3Wdrd4t6s85Ob5fxJCRIE7I8xw98xpNIvf9iWT07N0et\n", + "Wi+ukVx1nL02zXqdYa+nFINJwjCOSGWKH1bBNDiwtETddfDdgNMvn9n37C0uKk94w8ipNRq8fOYM\n", + "ru8jheDChQusHlplZ3MTSwiCAlKzLAuTvAwJqNXrPProozzz9NM8/PDDvP/978e2LAwEvV4Px/fY\n", + "3NzG83xqtQZhGBEnCRTLYctWobkyl0qFOuzj+z4HDiwhpWQ8nuB5Pq5bYWNzg1qtRhgluG5KELjX\n", + "TadRFOM6DgbwEx//eInxmobAME0G3S55nOLXbMY9lXaVpCmVWpUojHEcj1q9SbOZEMUxuzs7HDly\n", + "RCXqFE2KCvm1kEZhrRwn12HduZRlKEIu8yLcwUDkOSI2SITySMm5MQZuC5dITjANEwTl8lHfV6a3\n", + "RxwQQpDmaQmBCCG4ePEiMzNzHD10WO3FEGS5ZNQfYpqi3J3t3c97TLNpQsP6+hqO4xQdtFk4f/YK\n", + "CHePoiyENqLLi2l/jzChBFIuKmQiQ+zfS+zVhJv/8X/+Q+NEujvVTztdJH3Puo5TqWk7Gh7R3bYK\n", + "dEhKiGK62MP1uJsQgnq9zmg0KmGLac72jaSxegybhkf0e9DYul5OTAt4lEgovm6hoX/uNE3Kgq85\n", + "5noCee1hWcqPJE33IBq9WFWGVkWXfwMWim3buI5DOJ4oRkmRzhMnyn5XTQIOuSG4evUq8/PK9jVO\n", + "JatHjtJud1iZP1YU/BTTshkOuwUtbZdqxcMyFY85yyMagcAyItLJgM2dLXa2N7lw7jQyT+l2d5Un\n", + "BSkzsw0818EyBLWgwom7bucNr7tP5U0mKd1ej6BepdFs4ngeVpTgBT6+7zMJVUZjUAmI4pjP/fbv\n", + "FJ33CMtxcG2LLE3ptjt87Gd/lne89W2EYUi1XmU0HionPSl55C//gq99+RFa+QwHlpaAZ7/n/A36\n", + "I6Q0yHLJlc01dnZ28D2PD37wg3zpS1/iXe96F1/+q78qoQYF8anJBkGp/F1dXWVne5s///M/54tf\n", + "/CKe5/HRj3yEt731bURpSq1a5cDiPBsb6/iB2m1YhmYtCEajCXEYk6Y5zeZcAVukmIaFZboMhxMc\n", + "N8f3K0gpmJ2dV3S4OFRGXOMRArX47nQ6YBgMhyNsWzUgekp0PA/LN4jzHL+hOvu6WydOIqJwgovy\n", + "7rAtkzRWaTevnjnD3NycYh8hyNOMvJC0x3GsvHcAaeyFHWdZhpyCT0rMHLAEIPLCT33/I0knuIHy\n", + "9ldJ9MpQS4g9hor2I7EsC4S8Tkz3xjfer1TTk1BNxUVog1JtT8qHwXRHrDUduqGSUrKwsHAd02t6\n", + "ZzZdI/TSUhd/XSc0eUHDNBqyvdnxAy/g04uB6ZBfTdeLwqh4MgtyqcaL0mtYpuQZIASOa2MXb2ea\n", + "Pzqthpou0pMi1uy1tL3pbn/69zUdUP+d6YeBxsL0hzBN5N/DtOPSgrLctOdZQZ+S5fJTf+D7HePx\n", + "eOoCN8tttn5ih+EE07Qwjf1fnyQJ9VpNJZG3Zuh2B8XFJIjTlEqlwu/8zu/w0IMPsrgwz3gyYWZ2\n", + "FilMLNOk1aiTZwmmkRNHIzJp0aw1CaoWI2FgiphqECiutgHbG+t858nvYFuC8XBAt9shTSLCcILt\n", + "WpDlmI4NJKRhzGgy4Sc//g+467bb6XXaOI7FkUPLDEcjuv0eWTxmp9dmeWaRcKLiwcI4xrIcNjc2\n", + "abSa9Pt9hGHguC5xEuM6askd+D6VSoUrV67gODa9Xgc38AnjCL9S4Qtf+H/Ze/MYy7L7vu9zzt3v\n", + "22vtrq6empruWTicIYfLkEOKFClZtCRKliwldrzEtuI4MBwIipEoiGXYjhN4gWwEhmPYAWxEiWTD\n", + "suhNjg3boERJpmWRIinOTM/aPT29r7W+/e7n5I9zz32vht0jIwo8guEDNLqnpl69V/fe8zu/5bv8\n", + "PJ6smKUJp85sPfD63buzx8rKCp1Oh9U1lyA0GuLXbtzgueee4/bt21R1oFpZXcGtGZauUGRZQpKk\n", + "tQenx6mtTXRlGg1CSObJjEqXlKXi6HjYSBfbjNkkLR7T6QzfD9AUKCVxnRDfiymrkiw3fIlut2tY\n", + "m/VAfz5LiCKfJE2wTurT+YTjoyPmScJsPifLc+JWC1mVDfZ4OjV6OBubpp3leR6eA2lqMtjZbEae\n", + "ZwS+V8+FIu7f32/cncyecCirom57VuB5tXxriVaLXrDZWE4ddOtgLUyLRVUPh8YCuA5MJqPmOpl2\n", + "0oL1aYSi4iZw3rp328yKoog4bnHv3j2ja1P33MtyQSBst+MmHlgwgk0gl81Y7F60fBILO15GtFnI\n", + "4fKsbRm8YD+/BVEsQxAf+ru/6//9D7As7MYOB+2Hh8UpF3oGvWF/ccO0dBpXdlGzvywt/gRkqP5Z\n", + "y0LpJngq5lnGeDxeOm3Nw7+Me7UPov2M9mdZEawwDBsIYZYZAgUshjb2Qeh0eszn8xPTdOk4qKps\n", + "BrK2EngYjNC2l8xDKU9gyy0kUesMq8H8zjWfzej1V5ASI1YlNJ7v44g2eWaGYGmSc/aRR8jSpIFx\n", + "KWUYrU88/jgH0wJXF3TjAI0Hes7dmzc5e2aT6XTE3Vu3uXL5bZLZnHao+Mizj/G7ftf3kyQpf/pP\n", + "/wSqzOl2ArIiI2rFNWLGY22lz3/1I3+STisiS6a02xGz6YSrV6+ws7NDqx0bEX6tuXb5Kltb26Rp\n", + "SrfXww8D2u02r73xOq045uDoiFarRb/fJ5nN8FyPvbv3eWx3t85kzebJ0hTpSPbu3+fjzz/PK6+/\n", + "RKEUR6PRA6/fk0+8r+EKlBik0TPPPMPt27eJw5BvfvObnD59muFwyHQ6bfDCrcDQpXu93okqznM9\n", + "gsAnTTP+4T/6h7z22mv8qZ/4s7iex/d93/fyZ//cn+HJJ588kWS4rsd8luB5AaurHfwgJE1TZrMJ\n", + "vu/R6/WYzibNcLDIc1zP5Xg0ZJZMee3NN0zlWeT0el2mU6P2iRTcvnuHVhwTRhFpkuC4LtN0zjRN\n", + "mM6NDnaUzomCgDQ3KA0ouh8PAAAgAElEQVQhDHc0brU4PDjgzPYWw+Njbt+5zaA/YDAYUJbmEGp3\n", + "2+SFMW5QWqNQCG3EzBBOzcrUSzZqxqSl0hrxwFGcWUk6xo+M+YNSmrIqqcqKMIzqanox2NRa88wz\n", + "H6gNy1vMZjN2H91leHREFJifIYThoViQxGw2a/Z+p9NpOgE2yC5X4ssDSXvPFvfOPZGwWly5qaDN\n", + "a2xMsUiX32y95wHctivsL2naCgvp1SRJmosfBEFz6tlfGBYUcovJjqLoRPvEtl3sv5UysDatNf2+\n", + "gYzZ7DypjRts8DaT/fkJdqV9T3ua2t6a67rIpQx6wQJb6CbY19hhxfLnsjjwdyPyLLeEzM/2m+th\n", + "sexaK8YPmGP2Oh0EgmeffZaLFy9TKkXkRBSZ+VmT2RyqAq0hbrVJU6PoeDwc02q1+djzH+Gnf/bn\n", + "GB3tM5mkxFGH0XRCGHokwz4rgy7T8Zjf8e0f4aUXX+K//L0/RLvdpixKhtNj/ugf/gO8feUqSivC\n", + "dovZfI4GLl1+C51l/MzP/AxZOuODzz5DVZZIIXjllVd439NPGyeeKKbX7xO6Pnv7+zzxxJPs7e/z\n", + "yM4j9AYdLl26xOHhgelfzmfkZYFUpVG7jAPiODR9ZtfD9TwC1+HWnTt88Rd/wXhlttocPUQLHOB9\n", + "73s/x8dDRqMRB8NDdnd32djY4OWXX+b+vXs8/fTTXL582TiRdzpGKnQ2I/BNVfbBD36Qsiy5efMm\n", + "R0dHSEeS1QH2/PnH6a8MODo+IopjhJD8+I//OP/8n//zutrUjMcTfC+k0+lydHRMpedEYYznufiB\n", + "X7dHRjiO5Ohon/F4QpHnbG1t0e22WV1fYWdnpwlA49GIVy68ZGj9V65QliV7e3v0+308xyFqxczy\n", + "jPvHh7ieR7fbpdAV82ROO4w43D/AdR2SzAT4IAiYJXNwJFVZsHd4QJpn9ZAfgnlAoQoslR0MJtu0\n", + "PGoiT101GInXKUWhMNvh4QE8CFzS0lqUubiugFovCUQNsTXqlUEQMs/TRvsIrWup33ZDMDKOQxlV\n", + "WVJWBlBg9YmWOwWWVLWMkLFEqmXCjo0Ry7oytk213FJVSjXEnXe2aB623vMAbgcCNvO2v5xtRSzr\n", + "DdgWRTO1roOYDdBSmEFIVebgOIh6eOm5EkeCHwW1E3huHMyXsmUbHJex4nmeM629D4Hmvaxetz04\n", + "XNdt4IPLh4u9YVIIUJhN5posWgppfCTrNo5t2Sz3xd65qrJEK1VroLvNhF1Ko5lclkUz2X/QSpMU\n", + "4ZZ88NlnefW1NyhVXbVAM1F/bHeXt69e47HdXW7dusXZs2dZXdsgCALm8xl//Sf/AkiPIldMZ4mR\n", + "QnDh0ltv4Diao8MjhIb/8cf+OGWRUZXaWNKVOc889T5C3+cTn/o0SZbieD5//n/9X0BD1Gpz/+4d\n", + "4ihiMkt5/PHznNpc5/Pf//0MR1MuvfUW165d4/qNO1y7fAnHdRkMBty9v4cGNjdPcXQ8pN3pNAJG\n", + "s9mMKp3j+z4rKyu8/fbbzOeGPHPp0iW++tWvUlQlni176+duNHwACwr42Mc+ztbWFm+88QY/949/\n", + "lqOjI/7+3/t7rK2t8YM/8AN0u116vR4XLlyg3+3RimK67Q5Cmft2/twTPPXUU4A53C9dusSdO3e4\n", + "ceMGGs1HP/o8nXaHsjRGxhtr67TjFpPRmMHqCqETcXQ0REqHVrtNEEZ4vm9aUyqnnCfMkym3bt1k\n", + "NDIkm8cfP4frepw+cwbXD5q95LoubG/zgWffz+uvv254AO02Z8+exZEO82TO/sEB33zlZa5eucZ3\n", + "/I7v5Jd+6ZeYz+Z89MMf5khpeu0OTiURngOuw2sX36QoCq5fv87Nm7dRSvHUU0/x/PPP0+v1qIqM\n", + "CoXvuzXGOSDJMjzXpywVruuhlTZfT1JarpWwCCnyh7dQ7t6/R2d1zfTXpawrR4kfmPmB55pYkuUF\n", + "RakQrgnsQglQxrjZtkW1MrBLE/yNbkoQeE2MMP3tvIlVptVr4ZZFExcM4Sps4sAyC7ssjYb7cgC3\n", + "8zbbK2+1Wo3Mxrut9zyA21MKaILlMiXY/lKNgNQJDOniJDen4oKsY7/HYqdtUA7DsJaBXGTJJ1An\n", + "1HA9vdBHWRaOsv6DNlAXRdG8p+2x2b6XVWUzN0012bU9uYWAMApO3Nh3gw7FsTF0ttAm13Vx3Lrv\n", + "J5YU0yQcP8DQIQwDlBacP3+eqioJwxilFZ6UKAwBKElT3r5yFTRsbm6iNIxHx8yTlG6nzfgoYzSd\n", + "04q63LlzjygOmScTzp45xY2bV+m1A1SpUWVKUVgddcegN4TL1uktJqMRwnEIgpC1lRUOj45J5nMG\n", + "q+tUVcmt23e5cfMmUkp63S6u4+IHIXlhDsSzZ8/iB0a/Y3f3UcrKHIRR3GI4GtLr9yiKkrwo6HaM\n", + "LOrB/fv8jb/xv9eD8owoilhbq40h0pSVwYC1zipSSKYrM+Ar33L9/s7f+dskSUqWpEhfMxqP+MQL\n", + "L3DmzDbPPfdB0jTlmaffj/79f4D9vT1u3riJ53lMJyPKomB1da1udRWAZnPzFJunTvHxF14wLZ08\n", + "YzafEwYh1KiL3d3dRe8VSbfbQUoXISRZnpEVOUWRcXB4n2vXrzAdj/BrIaoPfOAZTm1uUhaKNMvY\n", + "Ozii1YoNWmU6o1tXCo+c3SHLU9I05e6duwb25nl0ul163R79njmMnnryKd6+fJmV/oDpeEzcalFV\n", + "JV7k8+hjjzFYXQUNP/CDP0QYhuzt7XHlyhVWVteYz+cEQoLnUFQleVk2hKQiT3BdrwlmZVlw9eoV\n", + "poc3qCpNlpcoBd/9kBjS7Q3wvAgQ+H6AlObZMr1obXRiAL8+wLTWuI4LDifbHbqOI0t6KmEYnOgQ\n", + "gJXXdU7IZCyrES6DLuww01bXdlk1VKDBmZdleWIWBvymkrLveQBfbt7b8sH2l6wOgc2+lzNkG/A8\n", + "zyOO42Zj2D63HSQ09Htogq4pS+wfTlxw+3nm83lDl10OrMsys5ZdZXtYtopYRrM0DCxdNENTO/QM\n", + "At+IEy3R4B3HaZAs71ymnWTYiMuzgizLKPK0uY6IB2fg89mUuNXl+OiIDz33HK9fvERVVLTapo8/\n", + "nc/Y299nZ2eH7Ud2WFvpmwetnuZnWcp0OCGK2lx643V2dh7FDVy2t9d59dULhIFx7MmzgjIvqbRA\n", + "1Pozo8mYJ596mjRNGR4P6fZ7ZEnCE+fP87WvfZ3Q99nePsOP/uiP1mYHFWe3txmNRoawNJ4xGKwQ\n", + "xzFXL7/B6tpaY6qBcPj6N77Bv/yX/5J225BwPN+jJWI6nmnR/c9/9s81ZXCn062x3FPG43FDZz84\n", + "PkBroz8xnPy9b7l+9+/fZ3h0xEc/+lFW1vr88H/2w+zt7Zl7nBdks4TMMW24TqvN+59+ut74BkY4\n", + "m83Y29tvdOyR5tDP6r64lJKyqMgpa3y0x87ODi+++CK9QR+lQAgzsPM8n1Jprl6/zpsXX2c0PGR9\n", + "fYVWK0bUDu6ddpv5PMGRLnEYI4VnCDmeR2djAyEE9+7d4969ezy2u8Pj584DcPvOHSZzQz559eUL\n", + "nNo6jS4rZKU4e3qL2WRKkRfs17DBoir4+X/6z3jf+97H2toab799hfl8zuHhIefPm585GAyI4hg/\n", + "DIjjmDAMTQKUm1mAFII8W6CpdFlx4fgWEhglI4R8l1AlAxzHMKUNgcnsVSlcEIpCFShlUFwmSGZN\n", + "5W8t06hx71prqpoZWpYlOs2bgOr7/gnJi+WWiIkj1QlCjk3U7CDaJnhaa3q9hcOYlccoioL19fUm\n", + "6YQFJ+Vh6z0P4MsnzDKV3Wbmk8moviiWakuDk7ZZd1WZqXYQBM0Fsz0mO7y0bRcb2C1Dyy57ipr3\n", + "kE3JYwenNsjbnpcteZYHjsvsSnvQ2N63I73aBJkm6Ge5gS0tZwG2//+gtcCoL8R7bNYSxS5SGPqx\n", + "0hU8iMujTbAXUnB66zSvvv5GI+5VFAVh3GJ/f59ut8vNmzcpi8z0Ln23ISklSUqru8oju4/R6nTY\n", + "37vP3Xt30Ag2T59hNJriuyFZqcm0aR3kaVq3NhSX336LZ595FgUkyZTPfPunKMuM3bO7FGVOlkzR\n", + "ZYEr4fULL5khpRfiCchmU6bHx6ysDLh9+zaDwQDHdYnbbV599VVzCLuG9OPXqAGtFU899WTDN1BK\n", + "sb9/0Gjh+L7PaGSesZ0zZ5nN5kjpMHzA5fvzf+7PgKWmq4rjg0M86RD6AVmaMhgMyLMM1zHGtmC0\n", + "uhECx/fo9QbNPRbCYK0NVtkzZCchkNq6oM+ZTqesrKyyu7vLlStXkFLS7fQYDkekeY7j+Lx04RWU\n", + "KuufpcmyHN8xSUZZaFxXMksyynKOrBOKPCsa0pjveTy6s8Px0ZC7d+8xnUwI4xDhebz++ut89+/8\n", + "nbzy8gUuvvIacRSRlhUrfaP/ffX6NZIk4fHz5/nIBz/EB597juHxkI0VY9239ZkzhhXbBEtBkiXM\n", + "ZnOS8dzMOeRCatURRsZBIDi6f4/ACSio1Qvlw9EYYatDv9vD88zerlQF2qmJM7oeTC7giVaIylTD\n", + "FVVVGvcfYRjgllwE4NTuREBTTS8Lzy13ArIsPeEL8E5zF8sePtHGgqbKt8iV6XTaxJuH2Sva9Z4H\n", + "8HfipbXWDTLEOF8HzYWwfV/7ywohGmlXm7na/rDFeVo8pVUdtAHZ84LmvZdvhg269hS0mE57Ii4P\n", + "FWym/M6Bqj0kbO9rURqagG/75VKKOoib94/juDkYHrSWtRNM9eE3rSVzyCwGOQ9aYRBQVIYVubOz\n", + "g+sarROrFyOEIC8Vh4eHfPnLX+aP/dd/lIP9Pa68fZNzj+3SbrWYpV2QLkprfuPFl+l2O4zHQx57\n", + "bJfRZM69+4c8tvs4+wfHuG1JO26RTXO2d7a5ev0KW9unEI42eiZCks5TPvvpb0PlFXEr4itf/jd8\n", + "5rOfYTIZG3u8UjEbH7O2sk5RlnjSmOSeO/cY16/f4PrNG7z2+usGxYCRVnWAsj60qyrn0d0dhsMj\n", + "tLZ6HMaVxWZEvu/jSEkyTXClw2j04B74eDyiQtFqtanynFYcN/hm3/cb04/A85vnxnVcNIJkntXP\n", + "iGEbxu1WHcgdXM+lqApjVKLqeYkXGoOF2Yhnn32Wnd1HOTg4YD6f8+hjuwxWVjk4HPGVr3+TVhSg\n", + "8oqqAoFDu9tnPp0ymyW0Yo8waOG3PZSuGA6H9R5xaiVIxyBP/IALFy6wsjLg9PYWmSo5c/o0WZJw\n", + "5tRp3nz9DXpnWqy0e3jS4Xh6zDe+8RuEQcDZzdPEccyX/vUv8qlPfcrA73oDDu7uEQQhSVIQRiGj\n", + "4YgwjvBwaUURaZqgVEW320JoqCqj2SKkZLXb5+DudYosrZEuD89Eu93VOlM1Tk+OY1uvugng1rbO\n", + "7KOFOqBJ8hyEXnA0WAr2eVE2Q0abhS+CvzqReC0PI63QnM2+l3HkjuMwHA5PJGr2dfY9bAJqlFcf\n", + "vt7zAO4HIVVZIaSgKHJUpXBccxO6XXOT89wILtkg6brGNdrzAlzXRwhJkqa4rjBtFKXQdpgo6qxM\n", + "aSqlcJRGC2kgZNatQxotYyEX+sHLmVK1pIho9BOMC7fjyBPoElljdW0PPApDyso8VHl9oORosrTG\n", + "kEuB0tYDz7iZpGlyYqq9vJLESHkuH0RWoMc+WBYH+6Dluh6OK41ht+uysbHO1WvXcYKAsqpASAaD\n", + "Ffb2D3n/U0/xD/7BF/jkxz/G4+fOkyYzZlrjxDFFVnJ4eFQP5DSbm2vEccj9vQNOb21TVpq1tQ0q\n", + "x9CTx6MRO4/s8NLNm2xvb3Pzxg3ObJ8xB5pjZh7Xb9zm7CNn2XnkUa5evcZgMCCO4lpbGm7cvEGr\n", + "1abX6zGbzpjNUtbXN8iKkkuXr7C/f2jcxIWRS/Ucged46LTk6aeeZjyZEIURUkiCujdqrolDmqQU\n", + "ypTQeZHT6bSZPiAF7/d7VLWejuP5pEmKdBzTWwUmkwmddqdGTJmD2/ONzEMUGwKLUkajYz6fN+1B\n", + "hcnutAJVlLjSRWnFeDxisNLn+HiIHwSsr22YmYXvY2RbzaDeVo+u6zY4dM/zWRmsIHBwpFNj7z3W\n", + "1lZxHJfRaEhRFniOy+W33mbrzBmee+5DBGHIaDKi02kzOh4SBCHPf+xjxFHE5cuXOb21hR/4DAYD\n", + "1lZXObW5SbfTJc8LHj9/notvvsn6+hpaKdpxizRNEUIym04YDHokaY3uEEasLgoChBRIqzyvoVIl\n", + "0+mYvFKkRYl0XKTzcDRGnhW0WyFpagK0rZQt+AAWJuOu6xqCkU3aqHXKCyMx63ou1plHCONCZBAy\n", + "qtZSWbRNFuxOC/FdmDDYXrtFx9mATH2vbbK2nDw+DF33bus9D+Cu46NVbvpPjo8fehSlYVS5jslE\n", + "jA5xTlnlhGFAXpa4jodKU/MrCEWea4LAZGeeY3WEDZjf9Xyk6+JKYaiywtDNtdKEYYCmbi04AofF\n", + "RS3rVozrOA30qShKYNEqEYB2JLJ2rjaEo6q2GTE477yqe9y+azKf+rVaCDw/aMoyKcWSMP2Dlunb\n", + "L2spm89ULAVvaSjFD1hZmqPQII2Yz/d+z3fx1/7aXzcloJAIx2Oe5Egn5LXX3+IjH/oga2sbhL6L\n", + "K8BzHW7v3SMMQzqdAOlU3Ll9l1ObmxR5STpP6Hf6qLLEky6qqLh18yZbm5v4jkMUhMShIYCUxWLC\n", + "LoWk1e0Txh1W1pwaG6uZaYOJbfdCvMhgdt++cYPTG+ugoSw1L770CmHcYzS9TavVNvdbmn59nqX8\n", + "8A9+njCMjMtQ3X80sw23ZpQWeJ7TVF5h/DAZAsjSxZxBIJHSRQpJnpnhlOcFKA2ivv6OdKgqY0tn\n", + "IaPSte7tC915RwiE4xrUQrBoi8Xt2GT3QVwHC4nvmedWaGhFYU3aqrNHx8H1zBCwzHOKMiXyAzxH\n", + "ICMPJQQ3b90weO4ootftozU88eRT9fPnMh4bopCDIApDw7Idj4m6bb7re7+bq1evkuU5WZryyPY2\n", + "+/v7HE9HfOhDH0JKSX99wHQ65frtG/hLgcu0DDw81yeKI1qyZRAi0WKwKCTkaUan2+XK9esoN6CS\n", + "PiUKqR8ewEPfJ00XUrZludDXfycfJM9zfM8wiW0AdhyHoizqfbDYW1VVMa1VRI0bUdxUq7Y3bVQk\n", + "RU0WCk+wKW3wtlm3xf/bYL2scGgTReuhC7wrIs2u9zyATyfj5oE2SjOaMPRxXVOOFLk5SaM4qFmM\n", + "BWVlyDxlVYIukNKts+8cz3PrrNxYI1VVSZnnlHntTuJ6+H5AlZdUWpHWkrBKKULPJS8KpGN6ydJx\n", + "qNAUlcaRAscx5Z1WBmsdxbGB9umKSpvSuCgVWjgIabJ/PzAkpKqeQCV5PaiRDkot0CRWS9lCJx+0\n", + "3knFFeKk1KV9YK2LzjvXYDBgNp+jhCYrC06tb/DE+fPsHY0YjSZ4Xk3j14K0KLh08RJUBZ//ns9R\n", + "ZDmzWdH061ZWVrh96zZrq4O6B6hZWenjehLpuziOoEwNNM1xHK5evcrGxgZFUfDoo48ainndSprP\n", + "58Z0Ok8IQo/9g30eOfsI9+/fJwhNwPJcl26ny8bGBpfevMTaxgbXbt7kcDjk9Tcv0u8PiGOjeJgk\n", + "GUJo0IoXXniBw8PDE60w+75As6Fs6WrbZg9admM7jgNa4jgLUtcyGsHeq+ZvYeQN3olUsFCyZmBW\n", + "l9jL6nx2oy/rRlu5Cc8P6+em3eD/qwpk4NBqtwxNvjcgJ+doNKLd7bK9vd387DwvcJ2F5V+eG9Nv\n", + "xxXkpcFGTyYT3nzzTT7xbd/GL37xiyRJwu7uLvP5nPe///188pOf5Bvf+AY3b94kiiLW19eRUnJ2\n", + "e5uiKGi32w2kzigqzpqqsSxL7ty5Y+JAjcrIsgyJYDqb4bdilNJ1Jv3wQFYUBUqfHBQ27RB7v1jw\n", + "KOz32UBcFEUjB51lGVmWNRBA6yQENOAD++wYdyndAAqUUoxGowbssPxM2GfPylLb+20/nx18wgIZ\n", + "95sJWcFvgwDebrdPDAnzPDtRgkQtowWeFwUIiFoxus58zdBB1w+8IqofkmQ+BUEdrM0AZT5PKEuF\n", + "tUEKghYISZaVSEciHY9ZktXCOibgSsDoCTtG0EkLpKrdq4VheGkEQnoIbTYQdQZcKUVZt37MUMVA\n", + "lzw3QKONO7syLZMgCClLhefZTfjwh3WZ9WVLLPs1+2A+DPw/Ho+N07yoWwezGT/0g7+bv/l3fqo2\n", + "oSgQGC1whGSaJhwOh/zyl/8tO2e3OX/+MSpKZtMp9+7cpcjzJhju7e2xuXmKqipxg4BKmQxnY2OD\n", + "OI6ZTCaUZdm4m1hyVBybLHM2mVHkGQLNqVPrHB7tc+r0Bnfv3iUMQwaDFUajEWmWsHF6i6/8+le5\n", + "f3DAcDwxwlFhQJImGC0LqIqC7/v893Dnzp3mPW2P0h6ayz3L2WzWbJp305+wrSvTlkgbjQ4rCBZF\n", + "kZEx1RgJiKpCi8Wsxd5Dy+RdJoKZDG3hj+g4Es/zm9cahxtNFJngErbazfcbZnJOp9OiKitaUcyb\n", + "b7zJCx9/ARyHU5unKJYU7yxEzpGLgOR5LlVVIB23OfTeeustzp07x8HeHt/5nd/J7du32dnZYX/f\n", + "UOZv377N1taWgZwqxXA4bFjNRV4wmUyYTCY8+eSTzfxngZ9eGJJsbW2RJElzsH/1a7+O1oqiyHE9\n", + "Q7F/2ArCgCxbNoJYzLIskMEOIF3XNXILSxBjoD5cJs3nWj6ILcxPa93o+ttrZp8tq8e0PJOy19lW\n", + "xvZZs1m2/X/L+G+LYPv3NTV+d5T4f4A1m6fkRYWQ0qio+RFhEOP7EQKHojAwMaNl4JFlOWmaUVYV\n", + "qh7IOVLie25TrnmehyONk3yapIyGI2PTFgREYcTKYKVha7bahnIdhiGtOKqzI9VscMdx8Go5TV1j\n", + "sMvCeDemqTElyPOibn8EtFpt4jgmjiOiOCaIQoLQ/NFakxfGh7MojaWZ6y40VEAY/HL+YDnZPM+b\n", + "ib0tt2ABV1zOyh+0NBVRGJKlKbpS6FIRByHPPvss+3v75n7UEqFxp42QLm++9Tb7x0OCuE1WKsIg\n", + "4PTp0wgh2NjYIK01ZSaTCXmeAYrZbEJZFgyHQxzH4eDggNXVVSM+lSSMx+NmCm99TitVNggOtOLW\n", + "rRukadIEhvFkjB/4tFox0yznYDTm1p27jRyxUY2UJPMpge/QikKe/+iHm+G1FUqzyyICliuaVqtF\n", + "FEWN8cY7lxCikVbIixzHdWi1YqIoJIpC4lZkkDRZSl5kKFXhuEZrxoqzWZSVzdDs+7Xb7SYLjKKQ\n", + "OI7qTWy18asGsTGdTmppYGqnJ8P01TVjMau5CZPZjHani9JQLmXySqkGtnY8PDSf03GagH10dMT7\n", + "3/9+Xn31VT74wQ/yxBNPENb65hYW+xu/8Rs8/fTTTTD8tV/7tROgAc81rYOtrS2ef/55Xn/9dS5c\n", + "uMC1a9eaZxYWGkOWhdhqtbhz5w5hFGElIUy2/PBQZcwpFqqB9t8W/WJ/bwsu6Pf7dDqdRm/GBnsL\n", + "fFBKMZ/PGY/NMNse+HEcn4AKh2HYCIIdHx83v4v9GVYHyUIm7ed7J8NyuSrLsuyEJ+9v+xbKS6+8\n", + "Rq/Xbcov13PR9SDSkRKnkhRlTlGYUzgM2gihKcq8GS6CKWN0LSXpYpEaFQhBGIUIxIkNK6SFWmWN\n", + "GL7nefSDjpH+XCqnVGWJAF49pa5x5ZUCXRmYkjb2b8lsSlGWOK4J/FVlgr0pnTzQmsA3KA40eJFx\n", + "bbEnfbcbPFTPe1m03pbbNjOwmQfw0FM7q7OvTsuUtdKTFFrzPb/zu3n5xZdRqqKsCjzPbTDwYavF\n", + "W29fY55kPPP0+/j4889y6dXX2NjYwBAnfO7evcv29hmMfZlpsezv77O2ttY8jJPJpJEl6Ha73L59\n", + "uzlEtda02y0O9g9qrQmXZ555ppFGbbXbTKczRqMxk+mUX/36BfIiZzKdNwzSUpVk4zmuFBzs7/Hf\n", + "/eiPkmVziqJqZF3DMGxYu7YUtoe+LWvtBnvYaiCAdTa1XPbaQLE8j5BSImp9DaB5T6DZoPYwq+qB\n", + "t2n/LQwOLAw2TdOm1QOmovrsZz/Lv/t3v1r3WCtj+BC30BgETlEapqnhHEQnKjfb151MxzWBzufU\n", + "6U3m8xkvvvgiL7zwAuvr6w0qzA4CL168yLd/+7cznU7Z3Nw0xhXtNkqpxuQBZVBV+/v7HB8f84EP\n", + "fICDgwMQBmJ4cGCy3cD3KevWRhAEDFZWODg6Zp6mBKGxTPzNWgnm3uUnyHA2S7b3ehmq27Sgam0h\n", + "mwlbDLlFhNlAbJ9R+3wsB1zbkrNuRBaNYiss+9/LAXs5y7dVgT38Gob1Es783dZ7HsC/+vUXUbqs\n", + "yRA50nE4c+YMH/3oRzizdQZX+nheSKsVMx6PGU9ShNRIKfCkh+s6BnivJMLVOK5vxOQrjeO7uEI2\n", + "WYFbZwVlUSAwveKitDR8E8zTpGxulOsanebF5sspC4NWMPAzg4ZRSuHWg6vA90hzky0r7ClaMpsk\n", + "zUDDBoiiNDoP9sGygxD5ENKCzQAtEcRmkeazLYKH1W9451pZXaEqS1PeKw0KQs8jFYIf/x/+e/7i\n", + "X/rLxGFMUZVmWIYmiCKyJOXNt96m0+tz7dolPv1tn6Ld6RtauuOSF0bm1DqoKKW4c+cO/f4qs1my\n", + "1OaxWUZBv79CVZn7WBQVcRgwHk94dHeXeZLgeyFlNSNJc6PDMRhwcDTil3/l30LU5eq1G/QGXQLf\n", + "YzI1+iZCQJok/P7f93tZXR2Q1LK5dkMopRpYp+3LWocYW24vK1a+c9nNZV87nU6ZTqcnsmo4mVHZ\n", + "79fKbMbAd9HaIB3s9yrPQauKMFh4pkqx0MzwbHCvD+wmk0byue/6HL/yK7+C43gNdG4ymRLHLTwv\n", + "4OhwyO5jO2YA/NZbzQyi0+k0JDWb+V6qpWCTBKajCVunTjM8PiYKI5KZcZ3au3efXq+H59SfyXG5\n", + "e/cuzz33HG+//aMHrRYAACAASURBVDbnzp0zvfvab3ZlZYUkMYJQq2uraODu7Tu0223iuEVVVHiu\n", + "xu8FZHnBr//613n94pukeYGiREjRtN4etkQNh7TZttYLUxOb6S9Ls2pVNq00G4TtIer7RpbWZtdJ\n", + "mhLHcSNidnR0RL/fbzJxW9kVRcHx8XFdfccnDgb7Ho3NnTBOPfYzDwaDJjZY6LFlZf5mh9d7HsDP\n", + "nDWT7LIscTyjWXDr9m329vfJ85zNVcMY29raotPuNNha6UikANf3CUNDby+qFI2m3WrXZgzguS5h\n", + "EOAFZtqttMbxPMoiaXrfqlLMZxlFkSOtu0lZURX1cLVOyBzhINwFezPLzNAUBaWucKTTZJxBEBhD\n", + "VCFx43ZzI6uyRFUVruMShS5eEDXMriAw8LCHsa9s/3VZLncZZ26/5kn/ga8fjcemFy8dcwghKKsS\n", + "EYQEruRz3/WdfOEL/4jeyqB52JUyfb5Wu8Orr7/B9uk1vvbiBT7hR3Q6bYbjGX4QAw5B4DMeT8jz\n", + "gqdqZEO/3+f69etsb28zHo9J05R+v49SiosXL/KBD3wAgKPhkFanQ5qWzJMcjcd0mhBEHYbjGRcv\n", + "XuIb3/wmAPdv3abd6YIyBgG+65EmMzwpePzcLk8+8QSqqgxOW+ulg3GhHGdISQvGq82grATog9ay\n", + "kNhy+8NuZMsgXuYN2IzX/tuW43bD2p9nbfVsC2A+nzf32fqdWqauXXme4foe7XaL8XiC44TkuQl2\n", + "eV7Q7vd5++oVxpMxp05t8uSTTzYVgM1Qh8NjQHB0dMTa2irz+ZR+v8f6+lpNHOo27Q17yJ05c6Z5\n", + "3jzP44UXXuBLX/oSu7u7XLp0id3dXQPjqw+bOI45OjpiOBzSG/RpddpUZUWeZk0LMc9zHOmye/4c\n", + "r775Bq12m2Q+PCGt8bBlD+HlNqIN2MtyrnZZ7L/lZiwPIpsKfaklYwX2gCazXrZWs8ne6dOnm6C8\n", + "3AZZfl/7HLRarRPy0nmeN0NtK+Bnf493W+95AP/O7/isgfDUJ+Lx8TE3b95kb+8e89mE27dv4PsB\n", + "w+ERCAcpXUMjroNcUZYG5icFji8p8hw/qE/HwmQkfo39REAcxayurFDmM6qqpNfv8eQTT7K5uYn0\n", + "QqIwghrbqVTNUkyLuu/l1nhxgxsvi4IsNzRpx5bO0gMtqZRCSEmlocpKKlXhOMY9HSEpKg2VIitm\n", + "TfukqhRai4fKydqHwaITyrJsJHVtdlhVVe0F+K2rgcAJq/hmWj9FmpLlOZ/4+POk6Zx/9a9/gTBu\n", + "IR2XSiuiVkwyT3Fdj/uHQ0pcvvhLX+apJx+n3+uytblh8M55xurKJgcHe/S6A5IsXWK+LhhnFqO7\n", + "trbWlJhf+MI/5kd+5Ed4++p1Ht3dJS9KVjdO8/M///NMZnOjczKeURQlUatNVRbo2oVICoUuKwYb\n", + "q/zhP/SHSJM5oW9aUVrIE3INy9dieVBkg++7tVAsUsC2guzBuYx2aJi3S0HAZv+e5zVDX0NSi5p7\n", + "uiyiZstyi+23mbJl6dlyv6oqptMpu7uPcvXqdaOkKCyTMyPPS46Ph3z+85/n6OjwxHW4desWruvS\n", + "7Rp5VNPLhvX1da5cucLq6mpjym0157/+9a+zu7vbBEwhBEEYMB6P2dnZQUrJJz/5SV599VV6nW7T\n", + "90+ShH6/33jHSinxQ48yL5hOZ3S7XUpV0R/0+MrXv0ZRlvQ6baaTw6Zd9LA9Ye5L1Tjs2ArKXlsb\n", + "AJfx2WVhDoNlmrvNkJelXe0A1O5P2+ZZblsCzfsukxLtH3s4Lwvd2efDHjL2fWzlUBRFIz38255K\n", + "H/kOkWc0gduRx6n1Ps8+/QRxbEom6UgOD4946aVXuLd3wPB4QlYURrHJcZD2b8chVyXSj8nKCrRC\n", + "SoMLrbTGrzOX4XjO8WhGVsyRUlDduMNXvnEBUffPtdKEvk+71SZuxXi116LVWQhD086J4oiovplG\n", + "d0HgeUbbpKo1vrEIBSHrMswI5UdRROD7hIGHK0Rz4nq+h+NIkuTBrvQ201s+yZeFdhZlpuZo+q2v\n", + "NxrihqVYlTm6qhAapOfjOxJV5Hzf934v9+/v8eKFV3BcD8+PGA6N9kaRFwhHcvPOHhtrK3z5336F\n", + "M2e26Hz623Bdn053wN79+3huSJ6Za3Djxg1Onz7dZBlWj6SqKlZWVho96uksMSbJeYVwPPbv7vPq\n", + "669zb98wKN+8dMXQ6oMIoSzbcU5VFAgJvW6HP/7H/hvKoqg9F42KnV7KhJeJWbBgttrNtNx/fNiy\n", + "r4mioGmR2CDguhIhLCzPmjVAFIVU1eLAtQFjGb9vg7fxSJQ4jofrLhQurWZHEHhNFh5In6JUnHvs\n", + "HNeu3TDtIm30s8vS/I6T2Zyvfe3rPLpzlv3JGKUM03ZnZ6cZ3NmKQ0rJnTt3OHt2m6paOMgEQcDB\n", + "wQGf/vSnuXjxIrPZjHPnzpk+emp03WezGVEUcfHiRdbW1jg6OGxePxgMGA6HdDod9o8PiIKIKAgJ\n", + "PJ9er8+tW7fp9vvcunObl15+mbDV4tr1m6x0feI4NtoynQcbTQP192SNqcryPMLi7ZeHgXaoaAOq\n", + "/d1te9J+r6qhvzbhWNZJst9jM/bAVvhL72Wfs+V2y3Jfe3noa/e0rTjm83nz+d9tvecBXBQZrueg\n", + "igKhFQKXqsyZpCZDJjCwtlNn1gnigDS7QjrKjMN8afrcCsjyjFIJfN9s3qosmw2VFSVZVisEuq4x\n", + "gQ2kMcFVFW4U4dc3vypLhHSYZIpxOqlvdNlsVltyCalRhTE6NjdOE8cRUormMChyI0gfBL4RsVdG\n", + "09y0eFykquh32qysDNjYWGfrzJb5+kMyQJttL0+0YcHYsrhU/ZDJdV5kCBxUVTVmzGiNrgqSLMfx\n", + "PI6qgh/6oR8kbrf5hS/9Mp2eg1aCJEnp9fsU2hBHDo7HeI7gzp17/It/8a/otlus9LuEnsenP/Vt\n", + "gMl49vb22NraarC1Vu8mz3Pa7TbD4ZCyLHlk5zGyvOT6zVt88+VX0EJy9949hqMRVQWDlTXS3EDc\n", + "tCpJ8xRVlQitKfKCP/Enf4wwCJjPp4R+SFEYLYqiZs7ZzQc0GZTdQECDrrAl8IOW/X+2NAdOZODL\n", + "WN5lSKc1z7WDUqDBHFtEw6JcPok+WC7x7XvawF8qw1HY2toyeuZxi1liMu9Oq839vT3WVld56cIr\n", + "BL5Hv9/FdV0eeeSRGkbnMZuZwNfv9zk8PKyJZLrBZVtd6larxcWLF+l0Oty7d69BQdl+r9ZGoOn4\n", + "+LgRmLMO7xa9kqYpg/6ALE2ZjCe0Wy3KsuLs2bOkWcGvfuUr9Ho90rLC8QzbuWlFqIdbqk0mE4we\n", + "0mIQaO/hOwf6SilKvSBLNV97R2BdbrXZoD6fz5uAbRMRO4hcViVdbr/Yn7E82LYqpfbeW8LP8nC8\n", + "2zVmG7/tM/CqSJHaqRUiDLOpKEujmNZqMS5mqEox6HfZOr3FmTPbTKYpb158i3t7e+SlQYF4vkM+\n", + "yyly42Kvhbm4gR8QuKYf7sg6A1WKUgu8sEUoJdZjUigJwgMk0pUIjIawlC5IDRJ8P6zpvhWup80Q\n", + "FINMmaYFvmvozUKYz1UUJbN53pTDWaGZzEwg9oTiDga2qHRlBowCNjc3+EsPuFZHwzFhEOK6AlUV\n", + "6JpW77le0+t1PRcJTB6QRJZFBcIcfFJKpGtIJgZGJqlUhS4ULpIf+t0/QJbl/OqvfZVubwWNZDyZ\n", + "4ngRvW6X2WyC1pK9/QP27is21lYZjyYks6lpg+zssHt+m/E04f7+EUoZIbGD/X3W19cpy5LZ/JD9\n", + "g2OGoymT2Zy/+bf+Nq7n0e50+eaLLzJYWUFKl/6gz6R2Vk+zDFGlRnJAVaz0O/zFv/CTHB0eME9S\n", + "Wq02ydz02dM0pcqrBRqkzgiXA2QQBAtoZoMweXALypEOValwHRch7UBzubUlm9J9+T2aQZQ23AT7\n", + "GosZNsHEfDalF1LJtj8spfGs1Frj1UgoR0ryuRmMn9k+w6OP7nDj5m1czzXO8FGIqqomGO8fHnLu\n", + "sV2mMzN0VVXFZDpF1XOKNEnIs4xHdszA88yZLfLMPLdXr15la2uLnZ0dkmTOYNBHCMH6+jr7+3v0\n", + "V1bMgDgImIzHdLtd+r1eU3FIxyEMA1rtFlmeE4UR03zCdDolimP29veYzRNu3brFPM3wo4hBr48n\n", + "M2bTKZ1ulyiKHxpDzB4w3AtLgwersW+qIHsti3LhNwmLQ9ketk1LZan/vYwusfc2rVm5y9ol9gCw\n", + "B7m9d7ZVYysDiyYqamKQkKJBI9kAbqW1f9v3wN3QI6/L19k8IYpiKiFQjsMsy3GFgysdQseBqmSl\n", + "FbDajnjq0c8wm81IspTpNDGMvkozPD5mOJqwf3DA4cERWTnH80Nj0+T5FLbc9QVK55RFrWfgiHpj\n", + "gXCF+UyOix+H6KqqBW4sS0oj3FqZ0BVIZ3Hiq7JAKEPXRwuE9I2kpRZoBApDFNJCoKVDYtEjVFTS\n", + "ZGq3Rw8e2Pzdn/vXUJNDpDDY98D36PX7BGFgpAAciUTxsRe+9fWT7PtOfuFBs7oKKGA6h+/4jPnz\n", + "W1mPnIOkToKyFIIOJ9yCVk6Zvz/3PSdf933f/+//Hq9d/MLiP2pDnTsPN9b5/74qidQSnWuUo6m0\n", + "QTJZrLfZuLr5t8ZWYy6qMlZf0rFsQaP9I4SmKPIa+aKIo5iyJnIpDRozaO/2+k2lZecInudQVjlV\n", + "lfGf/54f5i//5F/BFxGuF5HkOd12h3v7Bzz15ONcfvsqH/nQRwiDmMDzubd/m26nQzxYBeDeaMrq\n", + "6ibzWYHrhkzHhpm7t7/Hma0tsiwF7eM6jrHfcyTTyYg4iqiKElcaSOCgPzBDy+MjVldX8TyP+3t7\n", + "eNozWrhJRdAKKTyfrMxJ8oT1Mxv80j/4AvNkysrKOsPjEZHrU5UFURDSCiPOP7b70NviSs/Q46sK\n", + "6YZNxmsgv1bATKGlwPVdZKnQ0khKWEJPlufGDEJryqKok5kcoRYH8XIWbVsl9qC2f9vvtUNJ6x+w\n", + "3OrUWoOucKTVL4JkPiXNMoIgagK/vdfvtt7zAD4cDutyunNiym5OuTlB4OF5PrPZHM/3abVa5Hmx\n", + "MPMVRqhdKVj3fbZPb6A1hEGE5wWMp1NefvkCV69cYzSZgIYwitEoykohVG1SrAxL0/d8qAoi10jY\n", + "llmO40pUZYaSnnRJq8I8tJ6H53i1GFEtLIWlV1uHD4krXHS9qcuqMoeD5+EsZ284eJ5saPUPWrlS\n", + "OBoc10egSLKcLC8YzUy7yfVcXM8DVT4wgP+n9VtbjmdQC7JmSFaVa4bpGlRVQzOBSljpY1kjk+qT\n", + "Ulid6AK55M1pYYlZZgwdpFww+Gzpvjw/WJTxLbSuyPKCXq/LJz7+Ai++dIHxeIyUDqNqTBgG3L51\n", + "F991+Ps/+7P8yB/5I1y9dp31tRV836BETIvDIY5CHNdjPBqzurrGG2+8wZkzZ2i3DZ47mRvJ3Fa7\n", + "S5YXuPVcRGqB74fkecXOzi6Hh4ekaU6SpNy7d5/Tp09z9+5d/HWflbVVRqMRQRShM8k8Tfi//6+f\n", + "5uDgmLX1VQ4O9uh0epRVjitNRbOyssLu7sMDuIH9ipqZvVCZFEI04l5VVUEuyMuCVg2Rlc5C4tVZ\n", + "GvDKOpC7oQ/17AIWrTfbbmnaqWIhKes4TsNEteiVxXxj4QEchf6J7NzzPBzXRSmagP9O9MyD1nse\n", + "wAeDQX1iYqjcQjawIgt1Kopad7sZ+Bk5UHsB/Jqo4bsOQhgWnao0SuX0Wz6ffuEjfMenXkBVmoPD\n", + "Aw6Ojsjysh70aJQyDMTxeNz8KZUwusDSMdBCAUI4aFXiC40IDQlAUQIGleLHgekx16atWgCORmFa\n", + "LlI6SNfFsf10pYzrNjaIa4Oq8R+CQ/YDqqI0CBetQTrmPYRG45JrQZ4bbZb/tP7/X7N0UtvPBWTZ\n", + "SbNaxzV6MGDutaoUKJNFS2lMNkTNSTDLBOEoihqkh1Kqft4kShuWcRAEeK5Lu9UyGV7d462qCl0Z\n", + "LetWHDOdp3zihU/wxhuXEMIlSzMIBK7rM5zMWOn30cLjn/z8/8Nnv/3TOK4xhNBaMZnP2dzcADSz\n", + "2Zgg8Lh+7SabG6cJg4j79w/wvYDD4xGr6xusrW2QJPMat1yhtYvr+DjSoywUeVayvXWW4XDI6c0z\n", + "5EnOoLvK6GhMGhht+LwoaHUGvHbxMrN5QbfXZzgao9AIoeh0O5SZaTVsb2+TZQ93pjEtD9B6YY7u\n", + "OA55jZZZnmuEQUBeQxLFMl6/KJqePdQeuUvQRPu15X62Dej2M1i2qsV4W/Gr6h0/x/O8Botufy4Y\n", + "yLMfRM08xLZs3m295wHclha+HxJFcaOtbMHzFitpTyhTkoSMRuN6Kh+i0ezv77Paaddlqah7jYaC\n", + "G0cRfuChVIXQbdYGLcrKZEe272X1DuyFC8O4QQ5M0hmT2ZQrV67y5sWLTOYzcCStuI0WAqWgqr04\n", + "lXDw/KAZdlV1RuAhlyBLdZ+sLCjKHKQdvJjb8TAmpRJG+bAsKiPIT80ekwKhF3oKQrznt/U/ylVW\n", + "Od2O0R8pC1XDPnWtR6KbYVZTatfVr+sZ6KkZbLl1RmY0do6PjxukhBnALSjgtpdq5Qo8z6PMc+ZZ\n", + "ZnQ8HAObLUtjarK2ukq/1+PKtRv4fkhGgeuW9Ho9RpMpvXaH+/tHXL56g2effgrPlVSV4syZbcLQ\n", + "GFu04pjJeEq/JvfkZclsOufMk9tcvnIFrTXdXo+ilkStqoo8LZohMGCctRSEXsjtG7c5deqUQXGF\n", + "MfcP7hN3uiA8Lr99lS9+8ZeJ4pBut4OqoNWKcHzB/v5dNtc22djYZGfn0XfNRE1v2RymRWGqcysd\n", + "GywhTuw+X0Z9vJPSvxwwXddlNps1Dl8m3gQNh+CdaBILUlhmWdr3XIb8BkFAkadNzFnW6jk8MqbZ\n", + "/X6f9fX1h7Kym8/4bv9TmHT23wAB4AP/TGv9E0KIFeDngB3gGvB7tdbD+jU/AfxRTDf1x7TWX3zX\n", + "T8ACXuO6btPIXyY/WMdoS7lVKmnKHdcx2cr6+jqeqmi1YtI0w+j2qlozO7O/j3lHKfC9qC5haw9K\n", + "XZImGUJKpHBIk0k9/HDptUJ67YjTm2t87nd8hqKsuHHzFjdu3mI6T5jP5qRZTl4U5EVFmuWkmSnL\n", + "fNfDWC2BZ8y3UY4RxvLiNqoyD19VlVCZIQzqwRm0Qhtj5BrVYkdtSiuk8Ex/XGvUQ9QI/9P6rS3f\n", + "s0bSGUKGpirDlrkaoQwTWAjqNohRxMzKOY6QONJDKVP5mcN2gTMuywrX9agq1aAPLMXfZumz2ayB\n", + "9ZVlCWox7AxDj0oL/ts/8Sf4q3/1f2MyT0jTlDAMSRKDJJmlKZ7r841vvkRVVZw/9yh5OgcGRotf\n", + "KxxHkmYJ/c6ASlWMxyPW19eYzsYYCoNgOp1wcGCG0db13Q98XNepvTsFrZpebltANgD2V1a4cvU6\n", + "d+/v8aUv/TKr6xtEccRkMiSKQvr9FrPZhLW1FTY2Nvnwhz9cE5re5b74PlVVnECHKGXqWts+WVYM\n", + "7HQ6J0g8VljNfwfk0LZpsyxjPp9/C05/mUFt/9j3s2xuWDjVLzN2pWg3pDHL0KRu36yvr6O1Zm9v\n", + "77cGI9Rap0KI79Baz4VJ635VCPEp4AeAX9Ba/xUhxP8E/CngTwkhngb+C+Bp4Azwi0KIJ7QRLHng\n", + "skG1LMvG8sriLH3fBy05PLhrHhDPxXEKOp02WZYgpYPjuQ1xRWgH4Qi8ICCQEdZ5xXXN1L55BrQx\n", + "SpVOTWipSTvSMeiRvMjrhyEiTc1ncV0PjSCdljiez9bmGttbp8mLAo1s+m9l3SsvckOtvXfvHnv7\n", + "++zv7Rt7Kd837E3AARBQ6RwpjBu3kKZkftCSAtJ0jtcIABkrOQDpugb/LAUg+al/8mPour/neV4j\n", + "mC8khoFZZwhKa5LciEhpVeIIA0N0ENY8hrJUTTZYsKgiBNogHcqKIjciY1WZAUZvvKyvicXYSilx\n", + "agLROwdCbs1iNcw548odhwFCazzpIIAiS/Ech8qpFRPra+I4Ti2CZWQOojikrMoauucSBCGnT20S\n", + "+AGDlQHnHjtnqPDjSb2h23WG2KYoM1R9kJaVESkTQJ6neI5PnmZUZYUmQwhj6qFqnXbpmlaayfhq\n", + "6z0B3dBs1rIocB0fv86wk3lKnmZoX+O5ZkBYLlWDNpGxWZyFs9myvyhK/MA4uedVDkLiIviDf/AP\n", + "8NM//XfJ89IM+pOUlZUV8lqjut/r8evf+A3u3rvL7/99v4csTdBVie863Lx5i8FggBYK4WhcTxK3\n", + "AoqqpCwzozliZZ8jAzlUqiAMPdJsxupan/39A2Zzg6JotSP29/dR2sA6Azfm0uXLvPTyBfqrawRh\n", + "yHB4TKsVEcUe0+mMViuk2+1ydvssaIkUrlH0fMiK45i8zE5AfauqVgD1PJz6GTPDQ01aB1RTJTmm\n", + "pZMZo4llvLcNsO1Wy7Q1yhLq+6Fsj7p+hrVSqJoMZMk6dpBqSUY2AxdCIFjo6NgeeFlWuLUtnO1/\n", + "/5ZRKFpra8rm1zHnGBPALT7hp4FfwQTxHwR+VmtdANeEEJeBjwFfffjPp9kIyxhOu7nLQjWQMNf1\n", + "GI/HRv+kbr0oNFluprVCS2QiUaoijCKzIUrDjDPys2aDgfGNFFKaDSqp8dc1bKeG9SRZWsO6aDak\n", + "xqMqckNBr6FFDRRPg+8ZSGEgXVqn1tjZ2mg0WJRSHBwccPXqVe7du09ijX9FuxmO2L8ftPqdiDQx\n", + "Uqm6MFBLhTEQKFVpXEUcYzSgCpMZBK5EVQXCTrMryGrNc983JKWovuaqAIFokDmO9MwB52izkSRU\n", + "JHWAq/N8F2Ro4VOGvGSzmExlTbDRdXvBEQv9iEbcvjLDWS/w63LSq1tbBnFTYKzUlAapBYWWTcYj\n", + "pUABRXPdNMk4xSrs5YeHOK7Lvfv75HmBqjeLFILBYMDpU0ZZcTqdEPsR3W6XOI5wHIdWK6Lb6xDH\n", + "Ea0opigUUvoGconFHYPvelRlSTrPFv6GlRWjEiSJme2EgXFMV6qiLAy+OI5bCCEXTFDR7Ltms9vW\n", + "zLKYGRgcf1WqOgt0KauSPMtZW+nz5JOP8+KFC0b1UtRuV0oRRTGjyRjf87l89Tr/50/9NN/z3Z9j\n", + "ZdDn4PCAVqdXz1py5kmCFoqsrmBPnTqF40haUYvJZESSzHBdD1UqPM+hKIxo2draKvfv36fvr+B5\n", + "Lv2VgcHz5zn/4p/+Ey5deovVtXWElEynI0DR63WoipRuu0MQuqytrLC7e64Z+r0bHvro6BA/9Fk2\n", + "THAcY6ad1Th2+7zYoLrMA2hmaTXU1wq52a81768XAnL2kLCdgqIoyOvE08IUlweXloFrEURVaTwN\n", + "7LLBvSgXPA/bc3+39ZsGcGGUnL4JnAP+D631a0KITa31/fpb7gOb9b+3OBmsb2Ey8Ycuz/XrMlQ0\n", + "bhgW4G4HmfXnQDiS7e1tgxUvzCBnlswbDLRTX1jHc5nMplSlMRSgtK4cwkD4tCYrDD7VrQObkMJY\n", + "atWmEJbkIl0XUZlUVBhZOfOAiFqcSVVUldkcYRghpapPeAfHdcizBKoChwBVVvTbMR/78HPmQclL\n", + "cExg93yPOIo5PjbEFv7a3/qWa3XukdMcHx+TzOYkiZlwF7kJkq7vEQYhlVYoVeA65mCywx3HEZTq\n", + "/23vXGMly667/tt7n1fdqnu7+/a7Z8ZxkulhPMZ2t8cPktjETpzYMdhBiEAQQhaCzyAhhRBLCPgC\n", + "ASQeEiEoQBRhwDwEOA5YdhzZseIgP+dpjz3xiOmZzIy7e2a6+z6q6jz35sPa65xze3p6TBL3nfat\n", + "pW7dulV1q07tOmft9fiv/78jeAhWmB4T48F4EY3FYzInSt6ZwVpHVTUED3kmkmuCC3bYVBx78KFP\n", + "F+U7csLKGJ12YlwfafflHo0gO98/FmKU3TSCbbdJgob/aZJJWSkInzoYXFbESCs6MitzBF3nhX/G\n", + "gg+WroM0F4a5nWVNkeYUhThvgkzlbm09IU3yTKT5VAg5TRIZiDKe9fUNJpOcjY11Dh8+xB1nznDH\n", + "a84wWZuQxtpv5yHNCmkwG5ngCxgwUkpJXELXBqpWNzVPlhmqqtnjXNqmwYzqvYJl1lJggw4llWWJ\n", + "jXqavpKsha6laSqcs/yp97+X5XLBVx54kM2jxwXyN52xXIqU22IpTI9b8yX/7X/8Ovfdew+nTp7g\n", + "j919N3VdYqzl6tWrHD9+TIIXH5hM1khcSlM3EAxrEymRmCj0DC1pmlOWNfNFxZHNhC6AcRlffeAR\n", + "nn76abZ2djl+/DhVI0yJs9kaRZHT1oLrX5ts8H133cWb3vhG2g7yfNKLBb+crU0nEmmPHF/btn2m\n", + "pwNQGhzlkb9GAw3nYobXNEwmEyaTyZ7J3KG3NMgYKjWC+qbpdMrMDqyDikAZ0yAo26ExBmtCDxXU\n", + "6yXPc5p2kFXTLOxm9p1E4B44Z4w5BHzKGPPu6x4PxpibtUpf5rG/B8Cv/OqjnHvjfZx70+v7MeHF\n", + "YtGfrDul0JBevXqVjcOHegfbNIKzXF/f6IcfmqZjNhNSotlsim87rl1VEVeRv8IHrLE4l+ESF0Vn\n", + "Y9QYPGmaR0cShzR8R+hUDUc0NVUEV0+Y4D1lVVIt5thEJK2czXFpKp3lNO8n1FKXUjYLQoB8ktOG\n", + "Fms9vm65ttxlfbZOXd+4hv2eH/0RnHXkaUbbdjRtSz4pePLCU/zfJy9w5dpVdnZ3KBdLgm8B0bnM\n", + "8pzFvKRrZBq1mIhDbpqSLHE4I8NMxliMbYSnseuYpAbrUkLwJC4wnRRU5RxE3kLKVUkCsUHcNp6m\n", + "64Qq10CRyWi/MUZEOEY1RGFE7ESpKEBoO7LMyTRXnGYFhXgG8MI5472nbIWCM08HjUECWJdhrRH1\n", + "pLhmNmZ2eVIQAlR112cEzkaO7qRgd3dOWmS4LIcAZdfiIivk89d2cbtzLr64RdtewCVfw7clhsCZ\n", + "O+7g/LnzxgMkvQAAGwdJREFUnDp5kuA9iXNkqSCXCAGDIXWO1raR/UFFp0MPO9Q18XEtJE6IWU3M\n", + "QhI71FjbWjIZQV14yRgJwnlf5LRtRULgZ37mz+JDxwMPPUJRTNjZbpjOZlRVoCim7C4WJM6xsb7O\n", + "5z7/fzhz8jTGJtxx5jQGWJQN83mNMRJFFnnOcikEW5N8yu7WIpZ2JnhvCD4heEs+KTh+/BTPfvsy\n", + "8/mCT376UxBExnBz8xgvvHiZ6caUtSwlSQOGmjRL2ZjKANDZu++hrT3LWqd3b06r2nVd3DiHCcge\n", + "8hcdsTrgLNLXEqP0fhI3Pl/Jr6RsmuyJpvX1hYM97QPNtm3Z2tqKSl7DEJf3vi9hqjSdbjDgyWNj\n", + "up8CThKsgy9/5SG+/NWHvyMUinmlJ+x5sjF/B1gCfw14VwjhojHmNPDZEMK9xpi/HU/IX4zP/yTw\n", + "d0MIX7zudYL69U9+7D/0O1znJQVWWkdhKMtjdzeVsff4YbNMopC12Yyd3S1CCBS5dJyzGLUYpJk0\n", + "bvi1bRejfUlHtYwi6ZAnz7M+FZeTwFM3cew2DNSVJgTqppLNwI74m5OENsRdPShNZUoWR2WdTfoI\n", + "sGqWYKMmHkjKV9U463jrOz/4kvX/+gO/RegCvgtRKzEb6q/OgTN0PtA2NcbXZKkgdMqq4elnnuHZ\n", + "5y5RNw1lVTPfXRAMbB7a5MzRYzSdNJG9BTB4A9s721ENqWZrZ0s21lIiREnMjFD3GqmwW2vxxGGn\n", + "Tj5XFkntNRVsmgbicISPZbAkSYRi3dBzeejtAScf3y1Ah90TGTkrZSvfea6/zqu2wzIwwSkLY/Be\n", + "6A1iLTNxCW2qG41w8xhjaKtaNikTaJu2RxgkxiPpjJSdRJG+E9GQPAoyxHR7tlZAEKqFQ4cOM5ut\n", + "MZ1OOXHyRFTBGTjGx1N/erHrxqe/6zEEI2RSIfjYj2iHaN4Yyqqm9fAb/+sTPPzII5KOYdk4vIlL\n", + "UoH9tS1pkgpd87UtnBG+lZMnj/KDP/AD3HvvvUJw9cQT3HHqFPP5HKJT6x1QRG9dfl7KVc9dvMiT\n", + "F57iwtO/jw/g0qQXcA5tDaZjul7QtCVrk4y6Ljl1/BR3nrmT+8+/BXxC6DydDX0kDHD3638onnHX\n", + "XxefJZ3IGmsGqOeM3tasz1oLWULwAavnIww17ei8syhOXivdtN3L/66Z0JikKo80sOMyjfaatDzc\n", + "bxJmKJHpuSk+kD54VSz729/5AUK4sSjoK6FQjgFtCOGaMWYC/ATw94GPAx8C/lH8+bH4Jx8H/pMx\n", + "5p8ipZOzwJdu9h5pmvX1SusKnBu6w5NJQZqsRQKggfNDKDwV5rMrC+MDiTOITFlD6KQu6JwjjWWK\n", + "LBNFntQ6muBo4vvIju0jptX0m0c/Yu8S4eAIoW8Mdk1LlgtfuCJIkizFJIOST9cFJnYQNF3Liwhx\n", + "Eqcl9b0u1vyhKNZYn87kIrmBtXVFXTbkaUqROooso2pb6rYhGE+aFoIvxeNMoK2XOJewlqf84Pe9\n", + "hnvOniXPJwQMTScitjaA311K9pGLwLM3nmChrCtsYkjzVNj/MKTJhAsXLvCtbz3BxYuXKKuK+bIk\n", + "4DBGuGaMkctsOV8SFb9iypmQOoeLIsIS3URZMRk7JBhIrQW7d+JNm1POOrKo2h4rWkS6drlQvHxH\n", + "IcRIOy+wVtbfBn1ewBqHSwwud9RVhQ+GZaWOE9q6Axvo4kXbRf6YZSlkVJkX8YU0Fe4dg4g+4wNN\n", + "B7u7Jb6VPstylrOzvcViuRC6BGB9XTQrhTApsLGxzmQy4fSZM8xmM06eOMGZO+5g88gRNjc32d7e\n", + "xrmE5XKB96Kb6oPMG3Rth/ctPm7Ci8UClyRc294mSTP+0l/883jveeDhhzFYrl59gensEFk2IcsK\n", + "vA9cvbIlNVkDzqU89tjjPPX0s3zmM58j+MCxo5v80NvexokTJ1ifzljO5/gW5r7kmWef5fHHH+fJ\n", + "p54izQspaWbSMlubTqibjkvPXxG1ehOYrK0xn29xeHNK19W85q47SZzjnrNnaZqGcmfBieMnuLz1\n", + "Qq+oNCajut7yPKdU+TQz0Pl2ncBttamoJ0qjKBEUlRazaa2dezm3iqJglq3vOQf1uVoiqeu6L6cs\n", + "l8veeWtvTHlktOyijp/Q7dHelIGiJsKfTc/iebPPDa8QgRtj3oA0KW38/5EQwj+JMML/CryGl8II\n", + "P4zACFvgb4QQPnWD1x0i8F//90CMYO3Axzs+8DFvsu6CimzQ3W2M69R6ku6A6pC1uaFRm5ZAblRn\n", + "GvMidH4QGlXugzG2VI9NndL14H/94k2ssQN9GaZrB0FifT/nHG/+kfe95Jge/sKn+whMdfUCeyFS\n", + "0mTJYDTUoNj6OnpT7XobY5gv5mRFNpQpdB1jeqgWukjYUwysa/pTP3vdCS3rlStXKMuSRS1lnrZp\n", + "2N3dpe06tq5dY3c+7/mdy7IUYWhbxHXT8oLH2KS/CLS+7UOgq+JwhhUxD32O6lPqcXXe42n7763z\n", + "Q9PJOddrGMoHhNANz73++9V117/PnOsluIxzEectpGYheEKg75ckRiI8uXCh7VrWJmtUVUkIUSgi\n", + "6HkNvmsipbGUg2yAY0ePcubUaY5tbjKdTqWunlhmaxMOHTrE0SOH5Nhj5tI0FWmWgoGmbfAm4Xd+\n", + "94t87vO/y7xc4rIMl+ZkhUwsp6n0AAgBvHDfawnCRnnCG+GpQ/Akacx0g6GpO4rJlDRLqesSTEdd\n", + "l2xsTGmakkOznCb2tnznOXP6NGfvvpu77rxTAp26GWUgg4BFCIH73vxjLxuBg5yHAptc9ph775UT\n", + "ZZiozCdZf3uY/EaiB4bylTGm5yvR73/c89HrXDf4JmivzfaRt77WmNfEWtv3fPR9lF5YIKVtj0AJ\n", + "IfCWH37/HywCDyE8Crz5BvdfAd7zMn/zD+CGXEw3NN1prLU9DnPsxK9cucL6+nrvxK9feP1y1VHr\n", + "643J9RcLAdJIF37S76IKW1TwvRDhDw2PPkq2A+2o0kbqhqDvobuxYl7X1tZ6Z6/HoGobulvvLBYi\n", + "dBxT0HHT9kameFU9GdfX1+n8MLHVNE1sblmJtMOg96hrpcemG9R0OiWYgG9afNz5QwjMd3f7ml2W\n", + "ZWRp1p+E3WhzVUe8XC6xiWN9Y4Pjx4/HiCbr65GKYV5fX+8n3lTVxlrLhWe/TVWWXLp0mWeefYat\n", + "7S3apo5MbZIBGevIncPnhhA6rA2AQP4MCakTua62aaXHkKU0XoSwBTUg/PEGaNuaPHGkzpBlOdvb\n", + "W9JwtMLl7jWSiuvtEpHB0/MMYyO6KOouek8bdSuNSfpN2TlHaHXQI/KgBMOyrMiygq5rpYXsA0mS\n", + "4ZwhpFlUggK8J3Qd2zsLnnvuYYosjdS+deRViYpQzjJdW+PY0U2KouDkqeOcPHWSzc1NskmGwfG+\n", + "9/0U97zu9fzLX/ol6rLGe8O1q9tMZ+vMZuskLsEZK844alCm8fzd2dnhyJEj4AcpMdXs7HxF12lv\n", + "KNDUJcG3LJcL8iKliNDZLJuyde2Fnk75+LHjvPn8eTaPHBE2xULO2cOHDlGVFS59ZTInvVZVM1Oh\n", + "fxIl1/1wnDJN6vOVAVCHkZqmHYbvRmUSDYz0OledS6UFtqNAsGnbnoivS6QXlEZqDGcMeSTkyvKM\n", + "ru16cW8YKG7HQ0F6rDez/68a+B+VjSPwT/zPX+sjHjOq+ekH0N1TLwa9gMZK9mNWtx62Nnq+Rt3j\n", + "FKaNdSZ9DW10aFSvv4cQ4jj0gBTQ4xpDkfRvVLXaWst8Pu+/YKXd1I1I0n2JKvUYNMrvuo63v+sD\n", + "L1m3h7/waWDYxIwxYHx/Wx118IG2HTIVPc4sRs96UchmpmyEroeqta2IZIzHeXXASjMErX1qhKHf\n", + "h0fS+rIsmWQTKWnEz5fnWWxaSu2jrup+ve2IzjXLUpqmlXp+KzX3xWLBtavXaFtPEzquXrkqU2pG\n", + "tEnrpiEY2UiWy6Vs0NvbbO+WrE0mLJdlbGC1fSSVZ3k/rGGtZRmhl7q56fc6VhjX7IU29J8tNkeG\n", + "v4u3rYlsj10rfRdFrwdi3XvImmRCT7hF2k56MNJfkf5CYiU6ttYQYqPYEzCxlEgn0n02NoyxUDc1\n", + "xlk2N48wnUwxPnDmzrs4fuIEn/jUJ7l0+XmSLJPDt5bUiQBvmsVmLvTXT+oGOl4XI0ydBwi0UVDZ\n", + "9MNFsm4lWeZYLHfwvmUyKTh6aMrGxgb3nD3Lfa9/PSbI52zqmixN2d3Z7XHTNhlgf13X8cff8pM3\n", + "jMAfe/Az/fM0oMgjZFN50cfQ3IBMQ3ZeRM9BCMdMXG/dvLPYoFTHrRS6PYZ81KfQwaFxlm/NwIFi\n", + "R9eT7zqqGKyNp0KVklY3EPVn59/+3j9YBH4rTD9gGUsCGpnpCKmmI7u7u72K9Hw+75VPxlhN1ZJT\n", + "LpXxhJTCctR56fjy2LlrrWy5XPYjztPpFGuTXt6q71onyZ7NQr9QHbXtuq6f1qqqqifOz7KsF17o\n", + "IqJFTy7djF4OB641trFOXpYPIrr9xmdMP623syOc5ocOHaKs5eRWhyRERkuKIu+jCN0M1aHryaSN\n", + "Zd1YBbM6CLiWUTvQty0GI9Ozy5oiz/osp2lbmTKNm6uzkDpL2VQY05FZqKqS5Y5I26VZBl0H3pDZ\n", + "wIljh5muTePwlqWNI80C4RTenJ3dHdr4fpOi4NvPvUCe5yyWC9qmpaorQoAXXniBnZ1tLl+6zM7O\n", + "tjjm9U0M0oAlBBLnBJniZlJzR5rgTdNgnfQGiNOWMk9gewcsePwIr3OWJB0ySGstWZH3m8S4KWmz\n", + "jIxcGvCxv+K7lroTFE5oZP1E7Sng20DVtuCD1OM7oaTtmo4kK8DAxRe38M0VZkXBc5dfjKRJhsOH\n", + "N7l27dpQgrSBcrHEA64o9gy1SBN2DWsMrbUD9a4xWBtLXkFKSMtygTPQtBV17UmcDHalDu4/f55z\n", + "585J0BSDovl8zlohTU5FjDljSSdaGgyU5Y0J3sSHSMmqb172ZYhAWVY9I6AGGUUu11/btXFTFCRZ\n", + "QL5zvKdtGoIfOGp0PkX7c0MJabj+9fi17q6ZtjrmNE0lc7KDSpNK7A0Tue2e6PuVauD77sBVoNdq\n", + "6ur9aHc3PYn6bDYjSRK2t7d7WSOtQanTuXbtGtZaZrPZHoemF8kYJ/r888/3js2NdkcVGtAoum1b\n", + "kUuDHjbUT3Ux1EZ18ZfLJdPpFGU508+nn2m5XPYcLwoR638PA5/CjexPvPulyJSVrey2sl/+L3/k\n", + "Lyllv+F3DeysdWRZ6LPOoX5veqrW2WwWx98F5KCmgZ/6kjFroLWDILJG4dZa8jTDBMkIm7ajrZte\n", + "wMR7TxnpDfI8J82zPf00Lclqpnuz/tzY9t2Bb29vR6KqiJ2Npo5yOp32qYi1ltl0OowUA3WMbp21\n", + "oq0X4U1d18XxcNlFdTy9bmq2t3cE7hXr4d77/gvVHbBtWxaLhUQKqdQdp9NpRAEMKudZllLXghGf\n", + "TqdsrK/HEkQS0S+B6dqUshRESJ5lELvfbVTddmlCksk0XzAxMljZylb2HZlk2+q0x8ilwcEqskMi\n", + "5qEhOZ7G1Exdgy6ApqlihiV6vDLIU+OcQg4F8dS2Hb71tK0ZlVFkeLCqSrJMIMnOSf+mbSrK5aBf\n", + "W9e19CASgT13+LgRvMoFHfroOCIrlAhdI+AyMouNU3VNXRRJkSaDQvj29rY445imtG3L0c3NPUiV\n", + "Y0eP9e+tJDXee7a3t5lMJj1CQWujARk6mc93e606oN+9NYW6ePEis+m64ILDgOdVEpsQQo+X1hoc\n", + "RkainROODxi64Ctb2cpe2aTkqIIa3QjA4PosXfU/xUEL8kijXsmQ9zYPdRNIU7cHEZIkjjzPqKqK\n", + "LEuBtJ/O1IlRycjpHXiSCJorSYQdVeZFHM4NG4jQfjQUxdB7aGND9Ga27w68bVuuXLlCkqY9ZaaW\n", + "GowxdBEKpwV/bSjobqlfkLWWF198sWdu0wZknud9JK2pyrhpqfSOR44c6evmWr8e4GcDPGg6ne6p\n", + "QQ+cHLGU03ryLO9PJq2xjxuzyj7mGaCHWpJRvciVrWxl35kNFL17BaIVoaN+Qq9boRsYxIzlNfZq\n", + "aOp1rf5CyyeKXgkh9MIrik5L7F6ulX5AMTrpcQnXhAGvrv0l3QiAvrmvKJWXs3134JtRT6+qKkEm\n", + "1PUo1ZHx4DzPef755wkh9AIQXdexWCx6Z962LZubm5RlSVVVnDp1isViwXK57EslWsPWulPXdX3j\n", + "UxWpu66TZpz3fe3MjZoj+nf6uPIbNE3D2toai92B0Ea/nDH6RPHpXdf1qiC6w2ujc1CXX9nKVvZK\n", + "piXVqqp64IHgtQUeqNe9Bk4mQLUUTcuqbiJM0FGXdd8r821H09UkmetLptrUHTfzYUQulkZQRaSg\n", + "LZdl/3pd29G1wyCQ+jANREMIPeGVbhr9jMJNbN8d+O7ubl8yCAzoDkWX+AjdOXz4cP+hVCk7HcHY\n", + "FHWhJZCdnR2ZfozOGOgbidpsBKJEW71n4ZQpr19cBiIcRbyMN5kQO/SLxYJiMoFAH0X3U2DRFCaZ\n", + "JAnLsqStKmazGQ8/+hj3n39jj0N96Iuf7mt6VVVR5DmGvQM0Iu9FX+MD7cQbCAOGlbiuxu1VT1cV\n", + "9NRaqjpyocfGbZbnlGUpF4P3cnK2LYVL+0m0NMui0tDwdxphWOeEewYlt6Jfj7Jc9pulKs+YoMRX\n", + "ArYzFr781Ud487n7+p5Aj9KJI+3ee+GfiMgbjabaru0lspbzRZ/W6msokkAvat1s284TgifLc6wx\n", + "NI3I1HnvKZfSwyiiWHBXy/lRTArKZdlP4wE03VDys1YodKVRnfSQxyzLZGzfmr7khpFeSj/IhERo\n", + "hhAJkUoefuQbvPX+NwkO2VnqtsYay6QoIu7ZyUSwNbj4/SzjbMA0m8hzjNBCOOco8jwqRgmnShcE\n", + "8y785LJmRV6QRqTMGB6ndWbvA0kq1BZJaimXpcwW+KHBX5YldVXhkGtF2fcUMqiWFwUhyFqWy4GX\n", + "RDNv3vRSHzKfL/nyVx/k7W89T13X/SRzkqT9ebdcLvu5Bx/rynoNi/+Q9RtnxEJJ4PuIuyzL/ljU\n", + "P4wH9bTkqs/TeYsx9HC4RgfTcsl4tH7cNL2Z7bsDd07Iq9bW1mhHztoYw+7uLsUIkaGQHmNMH1Wr\n", + "M9OL0Vq7B76nzQpgD/RQFX/GhO+6aLqYY0ymXoxFUexxzuoM9b3rqpILPTZCxqmU1uIUlpRlGc7L\n", + "SfClLz/IW+8/1w8XLBYLGbIJgel0yiJiyrUL3k8GMuDm1Sk760iSbC82PAjvx7hxE6LzbL2QQWk5\n", + "SuFNRVGwtbUlWYqXseRgRd5uPp+z4Rx1HLbZ2NjYM0DlvSePArPWCWSsbVuhr80nhC5gg0V77D74\n", + "nifbR3Whr3z1Qd72ljfsSYXL5Zw0m1DFmqZGRZqJeQPOjgKCXC7SLuKqPYE2yMVVVzV11zIpCqFO\n", + "jVDbZVlFtXDL7nzBYrHoM7oXr1xlfX2dPJVhjLZqUXk/G1PoIiuERAu5OJuyEj4eY0mMo4jnrgQH\n", + "cbq4FW3NJI2iD1FyS51oYhPWioKvfeNbvOfd7+xpj4MVWGjiHJPJWjzmXRIXR7vjeUrnqeM5lOfC\n", + "PaMsk4vFnJ2dXZK8wCWOYm2NtmvInLANWgI721txU4HIMqL/MFY2ZWMCXaucNf46B5kLNNMMjlPH\n", + "0fVa8wTKquwDB98NEL2bjZWvr6/zyKPf5Mff/c7eYQJRt3S49pbLpWT4ietBEmoC9R1KKxqwYffO\n", + "QIz9iV6HChl87rnnOHHiRO9n8jxne3u7DxbUx+jmpRuAvu54OFAd/iuVU/fdgX/gz/3V/T6EV4l9\n", + "nn/9b9613wfxKrPf5l/9yo/v90G8yuy3+Re//I79PohXlVWVOGbtgUEcg2/mvfMXfLnF+5aqGQUw\n", + "GuSEjnyS7YmSg/GILKPrgy4Jwirh3/cdnkAX+YhOnz4NDNUApWrQCF0DxnFVYIyC0WG/8RDZKwEa\n", + "9t2Br2xlK1vZH8aU6kAd7XgqU7NkpbIYo9f0b7UkqtF7OwJO1HW7h/sIJEtyDJO5ILDnLo7jj6ef\n", + "+8eui9rHZc+xw9bj1Y3llSbl93GUfmUrW9nKVvad2MuN0u+LA1/Zyla2spX94e3mc5orW9nKVray\n", + "V62tHPjKVrayld2mdssduDHmfcaYbxpjvmWM+flb/f77ZcaYXzXGXDLGPDq6b9MY82ljzO8ZY37T\n", + "GHN49NgvxDX6pjHmJ/fnqL+7Zoy5yxjzWWPM140xXzPG/PV4/4FdF2NMYYz5ojHmIWPMY8aYfxjv\n", + "P7BromaMccaYB40xvxF/P/BrsmcY5bv9H3DAE8BrgRR4CHjdrTyG/foPvBM4Dzw6uu8fA38r3v55\n", + "4Bfj7fvi2qRxrZ4A7H5/hu/CmpwCzsXbM+Bx4HWrdWEt/kyALwDvOOhrEj/r3wT+I/Dx+PuBX5Nb\n", + "HYG/DXgihHAhhNAA/xn46Vt8DPtiIYTfAa5ed/cHEck64s8/E2//NPDREEITQriAnIBvuxXHeSst\n", + "hHAxhPBQvL0LfAPRUj3o66IEGCIsKefNgV4TY8ydwPuBf4vSeR7wNYFbX0K5A/j90e/PxPsOqp0M\n", + "IVyKty8BJ+PtM8jaqH3Pr5Mx5rVIhvJFDvi6GGOsMeYh5LN/NoTwdQ74mgD/DPg5YDyOedDX5JY7\n", + "8BVm8WUsSO53s/X5nl07Y8wM+O+ICPbO+LGDuC4hBB9COAfcCfxJY8y7r3v8QK2JMeZPA5dDCA8y\n", + "RN977KCtidqtduDPAneNfr+LvTvlQbNLxphTAMaY08DleP/163RnvO97zowxKeK8PxJC+Fi8+8Cv\n", + "C0AIYQv438D9HOw1+WHgg8aYJ4GPAj9mjPkIB3tNgFvvwL8CnDXGvNYYkwF/Afj4LT6GV5N9HPhQ\n", + "vP0h4GOj+3/WGJMZY74fOAt8aR+O77tqRmaJ/x3wWAjhn48eOrDrYow5pmgKY8wE+AngQQ7wmoQQ\n", + "PhxCuCuE8P3AzwKfCSH8ZQ7wmvS2D53kn0LQBk8Av7DfXdxb+Lk/CjwH1Egf4K8Am8BvAb8H/CZw\n", + "ePT8D8c1+ibw3v0+/u/SmrwDqWk+hDipB4H3HeR1Ad4APBDX5BHg5+L9B3ZNrlufH2VAoRz4NVmN\n", + "0q9sZStb2W1qq0nMla1sZSu7TW3lwFe2spWt7Da1lQNf2cpWtrLb1FYOfGUrW9nKblNbOfCVrWxl\n", + "K7tNbeXAV7ayla3sNrWVA1/Zyla2stvUVg58ZStb2cpuU/t/6S2bnP6vZqYAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [], - "prompt_number": 10 + "output_type": "display_data" } ], - "metadata": {} + "source": [ + "plt.imshow(im)\n", + "currentAxis = plt.gca()\n", + "colors = ['r', 'b', 'y']\n", + "for c, det in zip(colors, nms_dets[:3]):\n", + " currentAxis.add_patch(\n", + " plt.Rectangle((det[0], det[1]), det[2]-det[0], det[3]-det[1],\n", + " fill=False, edgecolor=c, linewidth=5)\n", + " )\n", + "print 'scores:', nms_dets[:3, 4]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This was an easy instance for bicycle as it was in the class's training set. However, the person result is a true detection since this was not in the set for that class.\n", + "\n", + "You should try out detection on an image of your own next!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(Remove the temp directory to clean up, and we're done.)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "!rm -rf _temp" + ] } - ] -} \ No newline at end of file + ], + "metadata": { + "description": "Run a pretrained model as a detector in Python.", + "example_name": "R-CNN detection", + "include_in_docs": true, + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + }, + "priority": 3 + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/filter_visualization.ipynb b/examples/filter_visualization.ipynb index 7125907f35e..6d629c5b635 100644 --- a/examples/filter_visualization.ipynb +++ b/examples/filter_visualization.ipynb @@ -1,620 +1,13214 @@ { - "metadata": { - "description": "Extracting features and visualizing trained filters with an example image, viewed layer-by-layer.", - "example_name": "Filter visualization", - "include_in_docs": true, - "priority": 2, - "signature": "sha256:64c88129e2eeaa956e4c8a26467ff6119f24ea3d7ef15f8217326249973bea8f" - }, - "nbformat": 3, - "nbformat_minor": 0, - "worksheets": [ + "cells": [ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we visualize filters and outputs using the network architecture proposed by Krizhevsky et al. for ImageNet and implemented in `caffe`.\n", - "\n", - "(This page follows DeCAF visualizations originally by Yangqing Jia.)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, import required modules, set plotting parameters, and run `./scripts/download_model_binary.py models/bvlc_reference_caffenet` to get the pretrained CaffeNet model if it hasn't already been fetched." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "\n", - "# Make sure that caffe is on the python path:\n", - "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", - "import sys\n", - "sys.path.insert(0, caffe_root + 'python')\n", - "\n", - "import caffe\n", - "\n", - "plt.rcParams['figure.figsize'] = (10, 10)\n", - "plt.rcParams['image.interpolation'] = 'nearest'\n", - "plt.rcParams['image.cmap'] = 'gray'\n", - "\n", - "import os\n", - "if not os.path.isfile(caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'):\n", - " print(\"Downloading pre-trained CaffeNet model...\")\n", - " !../scripts/download_model_binary.py ../models/bvlc_reference_caffenet" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 1 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Set Caffe to CPU mode, load the net in the test phase for inference, and configure input preprocessing." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "caffe.set_mode_cpu()\n", - "net = caffe.Net(caffe_root + 'models/bvlc_reference_caffenet/deploy.prototxt',\n", - " caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel',\n", - " caffe.TEST)\n", - "\n", - "# input preprocessing: 'data' is the name of the input blob == net.inputs[0]\n", - "transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})\n", - "transformer.set_transpose('data', (2,0,1))\n", - "transformer.set_mean('data', np.load(caffe_root + 'python/caffe/imagenet/ilsvrc_2012_mean.npy').mean(1).mean(1)) # mean pixel\n", - "transformer.set_raw_scale('data', 255) # the reference model operates on images in [0,255] range instead of [0,1]\n", - "transformer.set_channel_swap('data', (2,1,0)) # the reference model has channels in BGR order instead of RGB" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 2 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Classify the image by reshaping the net for the single input then doing the forward pass." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "net.blobs['data'].reshape(1,3,227,227)\n", - "net.blobs['data'].data[...] = transformer.preprocess('data', caffe.io.load_image(caffe_root + 'examples/images/cat.jpg'))\n", - "out = net.forward()\n", - "print(\"Predicted class is #{}.\".format(out['prob'].argmax()))" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "Predicted class is #281.\n" - ] - } - ], - "prompt_number": 3 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The layer features and their shapes (1 is the batch size, corresponding to the single input image in this example)." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "[(k, v.data.shape) for k, v in net.blobs.items()]" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "pyout", - "prompt_number": 4, - "text": [ - "[('data', (1, 3, 227, 227)),\n", - " ('conv1', (1, 96, 55, 55)),\n", - " ('pool1', (1, 96, 27, 27)),\n", - " ('norm1', (1, 96, 27, 27)),\n", - " ('conv2', (1, 256, 27, 27)),\n", - " ('pool2', (1, 256, 13, 13)),\n", - " ('norm2', (1, 256, 13, 13)),\n", - " ('conv3', (1, 384, 13, 13)),\n", - " ('conv4', (1, 384, 13, 13)),\n", - " ('conv5', (1, 256, 13, 13)),\n", - " ('pool5', (1, 256, 6, 6)),\n", - " ('fc6', (1, 4096)),\n", - " ('fc7', (1, 4096)),\n", - " ('fc8', (1, 1000)),\n", - " ('prob', (1, 1000))]" - ] - } - ], - "prompt_number": 4 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The parameters and their shapes. The parameters are `net.params['name'][0]` while biases are `net.params['name'][1]`." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "[(k, v[0].data.shape) for k, v in net.params.items()]" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "pyout", - "prompt_number": 5, - "text": [ - "[('conv1', (96, 3, 11, 11)),\n", - " ('conv2', (256, 48, 5, 5)),\n", - " ('conv3', (384, 256, 3, 3)),\n", - " ('conv4', (384, 192, 3, 3)),\n", - " ('conv5', (256, 192, 3, 3)),\n", - " ('fc6', (4096, 9216)),\n", - " ('fc7', (4096, 4096)),\n", - " ('fc8', (1000, 4096))]" - ] - } - ], - "prompt_number": 5 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Helper functions for visualization" - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "# take an array of shape (n, height, width) or (n, height, width, channels)\n", - "# and visualize each (height, width) thing in a grid of size approx. sqrt(n) by sqrt(n)\n", - "def vis_square(data, padsize=1, padval=0):\n", - " data -= data.min()\n", - " data /= data.max()\n", - " \n", - " # force the number of filters to be square\n", - " n = int(np.ceil(np.sqrt(data.shape[0])))\n", - " padding = ((0, n ** 2 - data.shape[0]), (0, padsize), (0, padsize)) + ((0, 0),) * (data.ndim - 3)\n", - " data = np.pad(data, padding, mode='constant', constant_values=(padval, padval))\n", - " \n", - " # tile the filters into an image\n", - " data = data.reshape((n, n) + data.shape[1:]).transpose((0, 2, 1, 3) + tuple(range(4, data.ndim + 1)))\n", - " data = data.reshape((n * data.shape[1], n * data.shape[3]) + data.shape[4:])\n", - " \n", - " plt.imshow(data)" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 6 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The input image" - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "plt.imshow(transformer.deprocess('data', net.blobs['data'].data[0]))" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n", - "text": [ - "" - ] - } - ], - "prompt_number": 7 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first layer filters, `conv1`" - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "# the parameters are a list of [weights, biases]\n", - "filters = net.params['conv1'][0].data\n", - "vis_square(filters.transpose(0, 2, 3, 1))" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJNCAYAAAARaCA+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", - "text": [ - "" - ] - } - ], - "prompt_number": 8 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first layer output, `conv1` (rectified responses of the filters above, first 36 only)" - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "feat = net.blobs['conv1'].data[0, :36]\n", - "vis_square(feat, padval=1)" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngICAgICAgC0ibKQCAgICAgICAraI/wdvk9M+hXkCqAAAAABJRU5ErkJggg==\n", - "text": [ - "" - ] - } - ], - "prompt_number": 9 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The second layer filters, `conv2`\n", - "\n", - "There are 256 filters, each of which has dimension 5 x 5 x 48. We show only the first 48 filters, with each channel shown separately, so that each filter is a row." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "filters = net.params['conv2'][0].data\n", - "vis_square(filters[:48].reshape(48**2, 5, 5))" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ni8T/A2aklexSCttuAAAAAElFTkSuQmCC\n", - "text": [ - "" - ] - } - ], - "prompt_number": 10 - }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize filters and outputs using the network architecture proposed by Krizhevsky et al. for ImageNet and implemented in `caffe`.\n", + "\n", + "(This page follows DeCAF visualizations originally by Yangqing Jia.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, import required modules, set plotting parameters, and run `./scripts/download_model_binary.py models/bvlc_reference_caffenet` to get the pretrained CaffeNet model if it hasn't already been fetched." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Make sure that caffe is on the python path:\n", + "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", + "import sys\n", + "sys.path.insert(0, caffe_root + 'python')\n", + "\n", + "import caffe\n", + "\n", + "plt.rcParams['figure.figsize'] = (10, 10)\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "import os\n", + "if not os.path.isfile(caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'):\n", + " print(\"Downloading pre-trained CaffeNet model...\")\n", + " !../scripts/download_model_binary.py ../models/bvlc_reference_caffenet" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set Caffe to CPU mode, load the net in the test phase for inference, and configure input preprocessing." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "caffe.set_mode_cpu()\n", + "net = caffe.Net(caffe_root + 'models/bvlc_reference_caffenet/deploy.prototxt',\n", + " caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel',\n", + " caffe.TEST)\n", + "\n", + "# input preprocessing: 'data' is the name of the input blob == net.inputs[0]\n", + "transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})\n", + "transformer.set_transpose('data', (2,0,1))\n", + "transformer.set_mean('data', np.load(caffe_root + 'python/caffe/imagenet/ilsvrc_2012_mean.npy').mean(1).mean(1)) # mean pixel\n", + "transformer.set_raw_scale('data', 255) # the reference model operates on images in [0,255] range instead of [0,1]\n", + "transformer.set_channel_swap('data', (2,1,0)) # the reference model has channels in BGR order instead of RGB" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Classify the image by reshaping the net for the single input then doing the forward pass." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The second layer output, `conv2` (rectified, only the first 36 of 256 channels)" + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is #281.\n" ] - }, + } + ], + "source": [ + "net.blobs['data'].reshape(1,3,227,227)\n", + "net.blobs['data'].data[...] = transformer.preprocess('data', caffe.io.load_image(caffe_root + 'examples/images/cat.jpg'))\n", + "out = net.forward()\n", + "print(\"Predicted class is #{}.\".format(out['prob'].argmax()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The layer features and their shapes (1 is the batch size, corresponding to the single input image in this example)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "feat = net.blobs['conv2'].data[0, :36]\n", - "vis_square(feat, padval=1)" - ], - "language": "python", + "data": { + "text/plain": [ + "[('data', (1, 3, 227, 227)),\n", + " ('conv1', (1, 96, 55, 55)),\n", + " ('pool1', (1, 96, 27, 27)),\n", + " ('norm1', (1, 96, 27, 27)),\n", + " ('conv2', (1, 256, 27, 27)),\n", + " ('pool2', (1, 256, 13, 13)),\n", + " ('norm2', (1, 256, 13, 13)),\n", + " ('conv3', (1, 384, 13, 13)),\n", + " ('conv4', (1, 384, 13, 13)),\n", + " ('conv5', (1, 256, 13, 13)),\n", + " ('pool5', (1, 256, 6, 6)),\n", + " ('fc6', (1, 4096)),\n", + " ('fc7', (1, 4096)),\n", + " ('fc8', (1, 1000)),\n", + " ('prob', (1, 1000))]" + ] + }, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJNCAYAAAARaCA+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text": [ - "" - ] - } - ], - "prompt_number": 11 - }, + "output_type": "execute_result" + } + ], + "source": [ + "[(k, v.data.shape) for k, v in net.blobs.items()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters and their shapes. The parameters are `net.params['name'][0]` while biases are `net.params['name'][1]`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", + "data": { + "text/plain": [ + "[('conv1', (96, 3, 11, 11)),\n", + " ('conv2', (256, 48, 5, 5)),\n", + " ('conv3', (384, 256, 3, 3)),\n", + " ('conv4', (384, 192, 3, 3)),\n", + " ('conv5', (256, 192, 3, 3)),\n", + " ('fc6', (4096, 9216)),\n", + " ('fc7', (4096, 4096)),\n", + " ('fc8', (1000, 4096))]" + ] + }, + "execution_count": 5, "metadata": {}, - "source": [ - "The third layer output, `conv3` (rectified, all 384 channels)" - ] - }, + "output_type": "execute_result" + } + ], + "source": [ + "[(k, v[0].data.shape) for k, v in net.params.items()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Helper functions for visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# take an array of shape (n, height, width) or (n, height, width, channels)\n", + "# and visualize each (height, width) thing in a grid of size approx. sqrt(n) by sqrt(n)\n", + "def vis_square(data, padsize=1, padval=0):\n", + " data -= data.min()\n", + " data /= data.max()\n", + " \n", + " # force the number of filters to be square\n", + " n = int(np.ceil(np.sqrt(data.shape[0])))\n", + " padding = ((0, n ** 2 - data.shape[0]), (0, padsize), (0, padsize)) + ((0, 0),) * (data.ndim - 3)\n", + " data = np.pad(data, padding, mode='constant', constant_values=(padval, padval))\n", + " \n", + " # tile the filters into an image\n", + " data = data.reshape((n, n) + data.shape[1:]).transpose((0, 2, 1, 3) + tuple(range(4, data.ndim + 1)))\n", + " data = data.reshape((n * data.shape[1], n * data.shape[3]) + data.shape[4:])\n", + " \n", + " plt.imshow(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The input image" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "feat = net.blobs['conv3'].data[0]\n", - "vis_square(feat, padval=0.5)" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvUmwbll6HfSd9m9u997Ll01lZmWqVFUulShs2S4ZN2CB\n", + "JGMKg4PAxiGHAxg4gjEOIhgyYeSJTQQaMWNAVIgJaECgMG7AgZsQ7gLbQq1VqlRVKjPfy9fce//m\n", + "tAz2Wvtb+51f5fAly9fA/gbvv2//5z9nn92ds9e3vvUV8zzPli1btmzZsmXLlu2f2cr7rkC2bNmy\n", + "ZcuWLdv/Wy2/SGXLli1btmzZst3R8otUtmzZsmXLli3bHS2/SGXLli1btmzZst3R8otUtmzZsmXL\n", + "li3bHS2/SGXLli1btmzZst3Rvi8vUj/3cz9nP/RDP2Rf/vKX7c//+T///bhEtmzZsmXLli3bvVvx\n", + "WetIjeNoX/nKV+wv/+W/bO+884796I/+qH3zm9+0r371q5/lZbJly5YtW7Zs2e7dPnNE6ud//uft\n", + "S1/6kv3AD/yANU1jP/VTP2U/+7M/+1lfJlu2bNmyZcuW7d7tM3+R+s53vmOf//zn4//fffdd+853\n", + "vvNZXyZbtmzZsmXLlu3erf6sT1gUxT/1mPbiwvqbm8/60tmyZcuWLVu2bJ+5nT3e2s0ntye/+8xf\n", + "pN555x374IMP4v8/+OADe/fdd5Nj+psba84vrL04N7PwYrW5ujIzs0koW0WJl7JTLK7KX9iKqgq/\n", + "rf3AqZxwDgHd6gLH2+K8c2HL42Gl+bXGYQjHjaP/djiGMjlfxeNsMvlxOB8uUUsFhvinnHeW38L4\n", + "olpOsxy3bCB/ofVzxPbEdafJv5umcN1h8LLjgWW938KIdpWbnYz36m1XlaGR67qx3cd7276xiXVq\n", + "Vz7sVqsmHI/+XK1W8bumCcet1q2UhePbulmUVdJ3Qx/qtNvtYtnL64OZmV3f+mQ4Hgd8HnF9r1tR\n", + "4R6rWGRzEe5/ljIrQzvJkLSmDedpZIZxbE3TIPVEPTq09dz5aXHCufAxUc7hXicvshljYZ68UkUR\n", + "LlyV8lvUr2287VjngkuBD0Qbh/Bld/T6dv2IMhm7uIdpmqx/drTm4crYPeu1N0C9Cudrtl5WluE8\n", + "BT55TTOzecRxcl8z5mIhYzcO//nEJk42dnFGyLxiO3JsjoPMP8yTqtJOxHfSriPH/SydwuuOMjc7\n", + "jJ3Jz8d5t5I2aTdhvG/OQiNuL338b8/XZvZKu6I/dT5zLtTnGzku/Ob8wsvaszWq6XXf7cL8uL0N\n", + "c+fZR8/id598/Dx8fve57b+9s817WysPGKelt/XE9Wnweg4Y47M6QnhZGXcz1phq5rjz7yqs9XVT\n", + "SVn4LCtZ66pwjVK6rvRF3o9Dh3ajrpMtfotzePPb6jxcrNn49Vdn4e/tmc8rX0f8WhOuoWvsgHm0\n", + "v/aym5dhLZoO4be3z/fxu/nIeaLjP5RJ88exO0vbTRXnmh/HdbeUH5+9dmZmZpdvXsWy57/2ib3/\n", + "9ffj2tH3/kzgGJ5lrL/EuvvkVz+NZTXXGKkn5z/rFu4jVHCeCjkundvbjf9/sw7HV3JMVYb6VbWs\n", + "NTXbxNcztmPXe3uOUzjf9ZOj3TwNz4xq1dp3/9En9tvZZ/4i9fWvf91+5Vd+xb71rW/Z22+/bT/z\n", + "Mz9j3/zmNxfHrS4v7fzttz7ry2fLli1btmzZsv0/sovHG7t4HDYdzcXZP98Xqbqu7ad/+qftj/7R\n", + "P2rjONqf/bN/NkfsZcuWLVu2bNn+P2mf+YuUmdk3vvEN+8Y3vvE9j1ldXiSuMMLtiZeK8LgWAvYr\n", + "BB8kfKngX3RtCYxJ94GfNsFCl9d65fxm7rIqBUYfcB519034TSneOda5oGuhEDjZlrAr22c+6cbQ\n", + "egIKlTLWWRFR93IUr3y620kh1BrQ9iSw94wKTiYuqBPdNMFVMI6VVZsKLkHA4YW6L8OP2pawuEPG\n", + "Ba5VdnI8YNfS1I2FsaPuxmlOPrVO2p595zBvuFe/VhE9AdpO0RcWrUTbpfTA8J9J2xjjZBRXFWHx\n", + "ccTYEPdkQf/hvLyvxI2F7+dZ27Vc1LOFO6huZNwBPu8PaIfefwDvdPw0M+uOcEF69xuHR1mWVm0a\n", + "K4rSyuLEeI4D2st4H/Gqs7rWC709/I1+nXXp6nF+LykxJ6Zk7bCFzQXdp/hd7ddnv+okKjBM50qO\n", + "o2ujEBck6yk+WHoqC51PcIcce2/kHu6b421o5Jc3h/jdo8ehLueXfv3NJvx2vXUf1AYuve3Ds1i2\n", + "PduamdlqLe7zdbihTtzNZQuqBO772Hlnn/U7HH9uq6q29etr63fhfvYvvZ7z4cQ8aUKdB3GjFLG/\n", + "pY2LdH1qapkv8RilgIS/a+k7ltF1ZGZWYt4pj5dLgdI3uD5M6JtK+xWHVeKzb+A+KtW3jzVO6Q4l\n", + "x5q69uDu7bVNOO4xdkqZRGNB96D0FykD2tgV55XcP9tE6knXXi3u/noVzte0Xvba+69Zs2qsxpho\n", + "Gh9Dw7ikhbSHMGaalY/Jucf1a70+6ibPwrJcugC53E9YJ3uZV/QKtuLGKyK1R8cVn3F+2uj6lWvF\n", + "Z4e0Uylr5im7N2Xz1eXlfV062z9nq7ffl/f1bP8CWrXJff3/F1u/vr7vKmT752QP331431X4F9ru\n", + "bdWby9L0NXAelm/fkbxWKfqA72T3XeB1Vd8ZeeZR33T53ohdeBJhSJQo2f3yh0LiBDuyFmL7CmTU\n", + "budoSiRoK3LAHQF+OunOnIVy+KiQXazUq5UzK4ox+SqxYvlGzt1yJe06jtzByb1idNST7yq4wy4E\n", + "OYroh7yXFxElU1Z2sKFXVj7e/jucTyGMI8n5eg/oa0FOeraFoAQT+njodadJ8rTvsJ08TwRDdlUR\n", + "kfAqkeRayE53xMirZQfH/tEdEXe4AojFdq8i+CTnwIGFTNM5DppTKK305xzQgVXtD7tmg11i4/05\n", + "gjze4BpdJ2gd+qkTRHDsiuRe5FbToX6inWoMqCrFjsNvB+7CZf7PRKSk7BSsVBImEgL8yPVEyeZF\n", + "8mkmO9KSbSfrCom4gojMVfheqhkRjFK7jlxzIeVPLQnYMndxuekgKNUeyOW+x//lWkCuus43ohcP\n", + "Qh+vLhwl2KBse3Hhx10FdKp0rrk1dRgLtZDsud71YxhD+50Q4bfhxxdyD/t1qCcDR8zMXj4FciVr\n", + "4gzieTlq8ADnn1++IrI0cwzJdyURFJlEBF8VQcAJZYmzMiJLlZQxUEMQwRFE5Qpto+T0+EiSc5TL\n", + "Mcl1sizlXnFcKWgWg5KGUZ8dOJ5dIqRrPhPLZLWnh0PqecIjw3bV5x6RuGLl9bx4EEjmjx74GNts\n", + "Q9/OxXJd4z20EkRxBIrabKUCXGsEEuLUnpOoAJSdCqLCb9VLxNW8lLW7RJvNOp+BWBX6nMBvKgne\n", + "YCBXIfNe/z5lOddetmzZsmXLli3bHS2/SGXLli1btmzZst3R7s+1Z0VKhCZkp1IsOEAJwywrTr0C\n", + "qiuM5Oli6UaIdUjI2YBd9ZjoR1QtHmpcOBRL+PYKulhmZj20pY63TsCM2h/FksRIHZeEX0d4Um5r\n", + "JIlc4NFIkE5clfgQBHwq+NslFH2SiEcSZ+OwNyHrXqB94rMKY8f+kcqXEbJVsifcIvjBqCRKQLBH\n", + "cY/QzTWIa7EiiXyQ9sR5R9UMOuHSLAq4D0/oWLUrtJdo1hhcuqMQ5tmPyVCrTkDLhS2OYzsVdG1p\n", + "Z7OfNGCBjZgEIJSvHmYtdKw2F1IGvZtiVld1KOt5felDjuGuE/cUbkddbHS3VEL25RgvqyUkPsp8\n", + "dlI470/cmNBdS7Z7JKfr8KOOll7kFRK5mRNUG9EgI/GV3hMljFeRFKt9wt+pewjjr9FxOi2OmzFP\n", + "C3Xtom1PcOztCAJyNXp9D7eYf8XLWDbV4bjL0dcfCpjVZ+KyAIm4Fl02Xixxnx+4duJ4cfustiCg\n", + "y/yvIy3Byy7rQGzfPXU3+u0nYS0sVBeMpGx1waLdyTKodE1iYImM4QZjTInVJzjETjyX38alU11V\n", + "dHdxDosbe2BghxCrG/h01WUd21MGYKRUyLW4xjWyxnTUOaLbMVlDUHZCHy0xrufqMWO7yoQiLaXd\n", + "bmNZu0LIf+vjZL1Z477C/0dZf7ronvdrVRhr662vp1NHd+fStZY8dqktpVp5RfqH0iNI2ThIUMSI\n", + "e23kXvkYrxOqCPX2vP2bFvejbuETz0y1jEhly5YtW7Zs2bLd0e4NkaqryiZFH4j0CNk5hpomauN8\n", + "S1cC6pT+wMwiiTXZur5CXksgBO50FK2grILsIEhOE2ZpDPUu/I14jV1cWzjZd3cIrNEphtzreQnX\n", + "SBgs1Za1zgzNVZTiRFqeKRJ19Ti86cera7gwkQ4lsYNELSTOmbczOGN1Gr5HqG+ym8KOqBDUoSKh\n", + "OpjudEqcd5At/OEQdrWKHK4Mys5CbObubxY5A+4qzs59515DgXjEcWvZhbUb3I+o7nJ8Kl9+Qv0m\n", + "3VXxb9nJUDW7kLETxZjR75Ps9MuRv/X2IsI2JuHiAZ1TZeeLK6hjPzh6PWtcf/TdJ1G6EcjccfA+\n", + "PB5YJyWA45rJrhoEYA2rPpGVgH2io5Vfx5DvZA6Tga+h4YTwFH3l/CsWxyXSJSCbakj2QFX+k1Ir\n", + "XGuWc3LSDASM1pa1qwA6pYhozbGt6u1Es06sRTXGYrGXrfHIcHnv13He4l4kAOJE8MqAazVKtsX5\n", + "Rtn+E+GbcPyg998CVVgvESkBmqytuav3tu6x3h+e+LpfUc5E1nier+J4nSQ0v/HVK5bh70rlZBiA\n", + "oerYcTgt+zghu7MuDBiQtqnR2Z08u/oOaLqiGpGUfUJFPxmTmDsiCdACzek7egT8O2YU0Pl3Kspo\n", + "TvDpYGxjJc8ze0QrcgYroKgalNIAuaKERauINI7vdv78W6Hf1xKA0Jcn5nOsu97EEmGOMiYYk5Pc\n", + "X4Vn9jR6neKSpe3EsSbwr3sJpAxVVs9FkrbihGVEKlu2bNmyZcuW7Y6WX6SyZcuWLVu2bNnuaPdH\n", + "Np+nlMB1wo1FCDQFKQs9PDkuOf/EBKFetiSMKTm0Qr3mxbcrgf2I+lZCNm5JdhS15QnJZ1WBdwXF\n", + "4AHYoSZIZRLWMREZWhKQxSkgf1EfR/1N/E7g/omQOTVGlkRI1eypQbqr116nc2gl9QKjdrsAc2si\n", + "S7pWJtGMcRVhMWp6MYhAvqLGU3IPgFgrSYZKt3DVKj4PWDzRB1nuGy7Ls/QaCsVzDInLrIc+U6Xd\n", + "FJnSkgwTrp1C2olq2Er2nqlHxrHT62iHxkyhrhD8ITpmJVWJWyHAX4UDm3NxQeP+xQNt1xU1yADP\n", + "q4x59A5JnXgPUkbCrNVLyFybnE2RxITEa5zQjOH8r9ztEF3bqhlT+C9eqXoy56uGLhtlqnI9Wa4r\n", + "nAvqbiyje8wbcY76NOJaYPJpcdlE/Tj1GJTUwBMXMFw5FRPU6iIGwu7ZmbcJExlXrQRbDMs5WR3C\n", + "93vJSsB23N+6WNVxF4jsh10Y60PnSb5nCy7FVrpkOEEBGPF9X3mwzeYKrv1OAhp2SPgtA6WkS49B\n", + "LJq0my4mZSIb6Q5L13Li4mI/JnpDqK/8li5NBko0jdSNQTGiTt+jY7dCAYh6d7rGx4AqCd7oGXgk\n", + "7n6041BQi1DPyzZZBtEk2T6wJpXD8tlVSnLlAsr26j6kizLJSgA3c03F8CRjA55nos/KgIZGyeZI\n", + "gp0kI47P3RNZGdSlzLkz8l6V2oNzJXpfJNYvNSiVKUStRM1LHoMs6oRtbt/LMiKVLVu2bNmyZct2\n", + "R7s3RKqylJzL3HSqOuox/LYoS6iZ8fvljlRJZPF0kViq5wWJVBXTierorpK7LyEWxk2v5nrjxj7J\n", + "k8bd9Jz838wJjrVsiSMRNoHkGP55gpwnv42brySvFHNIFYtrebi6F7Xr8B9Vfd1eIqxa3tapIn17\n", + "7WhGB1XyQULnRxCpx6MoZRep/MFJ4qSgZAOVnSvfaTOcXQnoNXaTutOoqqVMAwmFRAYUQbw9hp34\n", + "DvnFzCzm65qT3FCQEJi9TjGsvC4WZSYolf/N3FCy++SYUHVkyD6cyU6PUMdrrzmJfmyemplZu/Xf\n", + "rrHrf2l+P6+v3jczs+++fMKT+fVP5DCMl5R2LSqGdQtKFkPSJf/kRFKwjkkcT9Vnma4T6qK7yjEq\n", + "YSuxfEkUZz/WKl0RiaU+TmuQYrn+KCDs59OdPuopav8ckxo8Q3QukWkBiqjEYua4K9cK3ZEoj3tV\n", + "VJeI7JkQhiFxoDz9AYjJ8SA5MUHK3d06Uf0ItenDjaNOx+OL8NkFlKqf/fiIagj6ssY6YYLSUCFf\n", + "kduaUhyap5GZIgSlIhJJEnGSxYJ9qMT+7/FXisjHi0bj2pL4Khj4ERF8R3AakKfLjbd/HZErzWyA\n", + "ekg7cXiMIp3A3JVHWSePx1TtPA0YWpKeT8mqWMzruVT7TsYpAnX0xxUDgARhrGuu+0svCeXja80K\n", + "ARL7euPrFFX5x8HXSX+OLfNUJsZn1+kHRPhI1imiyRqVFSNlYhHzCUoXW0uSvSChJ6+7uFq2bNmy\n", + "ZcuWLVu2f2bLL1LZsmXLli1btmx3tHtz7RVVkbg4COeOAqGd1phASQJ3xpPoFfDv93AVqitspo6U\n", + "nBhYsAKhdIcpZOtHCAGcWixCihxHurtIRNeaheObWhKEtoG9t9s7YZPkRb061b4TtVdA30qKLOAi\n", + "imKyAnHTBabodL0KFVyfO4twew7IVtx9JHlvzv1aNzfQjLl2t0AHaLevhJS9Z9ZWkij9+hP9o6f6\n", + "Wmw6oSNEN5+253rTLs9HBfyS5HjRjIF7RtVx49fixYtSUMlIAVRdqGuJY0xJsXQBAU4Xwjzdsjok\n", + "Nxso8QrZuIG2zuOHV7FsRYL2hZ9vBfx69/EHfo0DScZwWSVkcxKwl27sSly7dbXU4jmlBVPTba/k\n", + "bWq1MIuBuux4vGY7OOXHmLwHaAyoULI5v01cAMUra4K6B6MUvyZt7nCYaDHRPam0BJ6nVt8W3Niy\n", + "UDWrE66SgVphdO2J3h5+u7qSROI13cJ+3h5BC3vR9jkeoBUmrr2bm+Dm3V+/8GsgAKFC8MJQ+jkG\n", + "C+OlWIqjR5K4mZOnax0Alxgn0v8N5v386YlMAVQCL9Ttc2KtjV0oQRye+dbrzgTliVYgMyr4hB6N\n", + "cxJBLKXf7ArzbnUhLnNkEShLv4cBfXb6Wktl9V4Sg1NLLmphqRJ3qST7WPrqrcZxrUEcdOkNe3F3\n", + "giJQSfRAHTtN2pjPEdyrks2ps1WemFeq4t7CjXYQCXQnzcsaOzDwyc/XxXkHl+Wo5HTcv061ht/L\n", + "mhCDBvxaVRXqpBktfE3283XzqXZ3y4hUtmzZsmXLli3bHe3eEKmxNCs0Nnrmbk0svuEK2fgE+sAd\n", + "5iToC3OGlYlSN99cl+S0kuGS+hpKsrm8QQ94E+9FnTuiU0kI55JQzuvGt/lJSZRAi/zqcYd7cekk\n", + "YpJHD3vJK4S8f0V5grCX7NwZ/h2u241C2MZXrexMKuSa22xE6gFK4FvJ4RVlEiRMuG4Dinatufb2\n", + "+I3kKRzG46tFfi2E0I5dAkmYmVkv7dqiHcdJiLWxPSVMliHBte7wSN4PFZgUplsCKDbjWsr17yCJ\n", + "MJojh2XcsvuBDVCqUhXYycZlXi9VDMdxrSAdq4uwg9rIPRA5rAUl/V1f+t1mZvbp4bux7KOXz83M\n", + "7PX1o1j2BOjE0JGIqjtoIFJK2KfUhEwTDjvu7sKNULpCdppEiTWiAf1UFikKYGZRkmRSxWrOyT7Z\n", + "fvOiizLdpcd+nEQSA+0YLyH93x+B3AzL60+S/3ECIlhKrr1yImFXyjieVkIAXp1S4AYBfSYRXtCa\n", + "er28VkHpFJ9Eh0Mgjw+CZvWHcJ79C5E6uL4xM7Ou97lTrXD9GuerhRzcABlQbwIA67X52lEA1Vqt\n", + "/fokzU8S/l/vcJ699DvaNqKJieo6ScdL+ZM5yatJRFrQH1SlF0kC/naSfIZUhV9vME5lrhGtWNeO\n", + "Um0gDTCVIlMCJLw/ysKG58hK0PwJZP9K81/iuRSHuAYRDB3uT05LD4Oir1zX5LiSJH6Zft3AAChd\n", + "gLc4n6ydBIenEwR4o9q4F/aQ/1CUnpJA8yRjgsi1PLttZFkSFRDOwbVe+nCGxEPCK0fARp2gxAxA\n", + "Em9KRB0VYceYkMZrcq69bNmyZcuWLVu274/lF6ls2bJly5YtW7Y72r259myeXskhTBKpEtzgCtOE\n", + "gadIoXQLJGTfxenkp/PiOxIgR4H26xNaHIT2O4H9ontA6jkBMlV4coywJIiI6saJuKSSXcNnK8Te\n", + "1VWAXZls0szsJRRjeyUKR60sgWdjEla6UZQIPyefZmYFINBKGOgkDNLFZ2a2vQiQvgigWwWl3KkX\n", + "DSC4wIbe69RCP4cepUYEPaipVLWS+JKaPdInw8BErqI2TTdape5G6L2ojhH7p1rqlBA+VtfKAGi7\n", + "H3WsoS6NNAAUoJOgBKoXJ3g7VcGpT6Rqul1SbzNXr56Fxfvu4zfMzOxy433y0bMPzczsx374345l\n", + "v/ndv29mZr/R/lYse/5bvx6qtD/iWqL7MqUETzN345WVli3JmTG5rwYACPH21eMqqqLLnCC0Xoor\n", + "bjK6DOQcr5xLS1VHiIEnehSJrQxYGDqZLxi7lew3o96dXgmXGNW1jzFeynyi50f7rowaXBp4A1cF\n", + "XWziMo0k+rUcT1H8Qcb/AcRmIZvvXkKD7aWTzXsEskyDu6Xp2ltDM65QCgKDIrSMel+NJzKv4O5T\n", + "FX1qcI2jamBhnbyV+czkviOCaJTageu2qWgS6qEEaOj9DfpbrH8yx0acZ9Dk0tA+imudrH8kOSsR\n", + "mut5tRISc8PAHvU3gZbQuRutZNJg0aWax9BoHdYdPUdM7i1rSAyUGtUtj3GdiBDSjaUBHeFTMwVw\n", + "vdOy4wB3MNbnQZ41A4j6o7jbh56ahfpMwkcSUcR7UL255fOZen+cp6Wu4VG0axk8posSA2Rq8W0y\n", + "yKg4EbxQyHO3yjpS2bJly5YtW7Zs3x+7v1x7VqbqxPi7lN3vXJOcqHm1ljvNSFQvFf0In4MSC3E+\n", + "SgKowjLf+tPwe4bLaqgzQojlTZvES1VxnqlKq2G1JIVzpy2v3EUkJ+sOYklYbYiqtNtYVkFt93bn\n", + "u8rDMexqetklxA3GiZBTCgUfRGrhfLoMv5N6NkCi6rW8reP669rrtIXyct9/4nWiKrnsZrZnD8Od\n", + "gog5JKHBJIL6Dppjoj94Rx1JmpfdZws0q+j9tw27QlCvGjtC7oiU83gEwrXbuxL4HmXd6O1UMKw9\n", + "yfVkKFNV8mCV7Ig4tjhyNF/YDE0KBamITm6E173FjvmL5+/FskeP3jIzsx9+44di2e/90tfNzOwf\n", + "/8O/G8v+4d/6C2Zm9jvf/7KZmf2fv/Rh/I4KCp3soIsWu1q910ieF1I061yoAvuSUE416Bq7/0nz\n", + "a5HYLWM4EouTfHlLqYW4i09231hjTiAX7PhC1gvmjkvydRItEkRg7FhRVSDH9yJnEb/uhZTcMPDF\n", + "r8EhE/N6Sh60AqhnUes4CWWdBGUcj2F8HnY+/q9fhn7cP/Xx3KI9GyXFVww8CGW1oN/M/FBLG67q\n", + "sE5sVz7/DVIIOwnA4PA4CAG72qDt5KcdCNi2w3rdL1GVUQnLMTecNiLWH41TAZo0JvlUR62amZk1\n", + "MXcnVMzluULkQtF/yqSYjB12XiJJw+eJorSUXxEF/hKIZYOxMe69D4nIpDlhEWyigRrM3apBKehH\n", + "JVtTpaWXQAUGIR1677sZausTsgLUkjKCiPQkQVnziTnp+Sw1UCw93swJ5bPOU/SdS6jIeRmAIGsn\n", + "vS1p9pBws+3KAwWYoaNWaXNec9KclBmRypYtW7Zs2bJl+75YfpHKli1btmzZsmW7o90f2bwfTCmb\n", + "UYdU0Fl6DFSxVlWWaRPxSU3QeEKdlFoVFfVsxI0UXYUJsZI6Jno1wM2DQ32EqivVRwIsOCo8atSH\n", + "gRbJRlwBNYjFhbidmPhVbmIuCEV6112UIEUKKZtuPiYPNjM7wM3Y96yP3D8TdQo3cL8LBz545Odl\n", + "k9Tibqjr4L7ZCLRfQg34jdf9fGwKTULLOhdF+O1RYH8Syw/uiYg6P0PnhSNuaBANpAruiV7kUXbw\n", + "964E769JyoyQvffrfoDGjmrxxESiAs9HHRslMaJ/pO+IvKureI5QNeB8hefLJRTOWIj1VgjI6P/1\n", + "6kEs+wNf/FfDdzvpUJBYf9fv+WOx6D8Gyfdv/O2/ZmZmH18+j989uV4qmw/lEffsp2U99f6jGy9x\n", + "QYBYLWNntQWhmc0wKZwPIrBKzJwg+1JvaFZea3TLicuAARUy7uNI4HVrpQcs3YMkwqobg/N57pdU\n", + "gbETFxRcNfVK1zCsSXW5KIs0B9UYQl+r7k1U0RZtpwGu75uXvv4cn2JN2KveHlxL4qqne51yV3qv\n", + "Bcb1du3adg/Ogy7ZZusukxIu4FXjrt3n0zMzM9tXQizGGidT12qsDwMzAYjbkW2sLmBOp8K0nUI9\n", + "VSuviG7BRBgulIlXbg9ttc1ZuB9hUUQ3n2phkdCtpHT2v+rCTewznf9GV5lfo8fSARmxSEkJN8FM\n", + "DFqnIvnOzGyGq7BV1x76WGkZTEKsmQo8KEMfnuFjZLCPciDw5TCKAj4DVZKoDFJwJACAa2uxXE+V\n", + "llMjomKMLlUlkS+DUuj6nYTE3kKVfS0q5qvVkoDP5+5RngV9cr9Ly4hUtmzZsmXLli3bHe3eEKmy\n", + "KBIiWNx1a1inf7v4a1bCWvxuuSPUEE6+6cY8PUpijztcDVfFDrpYvpmnoZbhfEpA5G5Wd9jTQDkF\n", + "EKFVagEhzqXsVolEKTm5AslPiXgF3vQbCZM/K0IoctP4LqHGtq8HSnU4usJxvH3ZQtzehB3s7a3v\n", + "tM4uww5vM/rukwhLLWq/3Dmfn3n+t8ePDfW88eu+ErrcbgT9AWF+nK9jGQm1qmLMndAkoeskRXZy\n", + "P3vc5ErCrxmVUAARmI/eJyTF9xqai/oqIhhlJARV4A4qkV8ASqK5xghicqerCtdxRyjE6glj8sGZ\n", + "q5PvkYcLafg3AAAgAElEQVTqzc1bsezwcUDsPvjwN2LZi0+Cynm78R3Zj/8Hf87MzL72tX/NzMz+\n", + "q7/4n/m10IedBBs8eRmCB3QHFqeuzJ2pXN5rAeV7KtabuZwDibKaG5IbV82r5deU3feJbAen8u/F\n", + "3HW6TkTtBN7D0uYT/0uvn36aCbCdbsnxsSQKq0XUI2Z7UPiPHzKGiCZL2x2O4e+DyB9QDb6QMHnm\n", + "/5xk7ZiIBOL41hQtCH13uX0Yy167ChN7cyaINPp6s7qIZQPOu7t+6vezQvBGK2tnRGljxEL8jn/V\n", + "CQEc8gNC2K6AdK4EpetvQ6cUnYbO81PGBNaH3W2o2/pKZB0o9SHzmgElOiYYxJCSqCHTIkgLEZlE\n", + "uQa/oUqGLGsROVLHDIeYDn/mlaukX5mBomol2AMoTZIUsaAUjo+dDnIeLTwmpc4rIPxdtyTFJzI1\n", + "47JN2KNJUE5JlMyP6oDsRk+ASq0AfVSUsMGzaLWR5xQWlLb1svUaCK/OMdRPHxPDoMrvS8uIVLZs\n", + "2bJly5Yt2x3t/nLtDUPyZsqQzCnhPjDUWnPIxRj+WFbE4/38zLWU6JEVFJPD27Ls4LhznkWkkq75\n", + "4kTm5znhY0F8TZCjKRI7VDoB54Pvtdv5vdZFeJtfrTTUeLmrjvWVv3lZFUnjEYpmtahAxdx4Epp+\n", + "QH2HTkI+sSN99sx5Fuvz8JuLS9n9na15F3517Fw3wgO7ugzolKJu+/0ed4hdmGwDIqfkoKHBx+T4\n", + "cN9ABAVNYq6nUuUv0J6d5A5bAwkk+jMk3Afcj4aGU9SuXob/aqq5uDtVfhO1N2VMkK4Vh5huK5kv\n", + "cNRdXejjC5GauECysytz9O8f/cP/w8zMjjtH/zao4L57Gcv+yn/7X5qZ2e//4/+JmZn9qT/95+J3\n", + "f/Gn/wszM5sE/Xp2+5Q3LfeK+5J5ynxlOnIpJrkRRMxDkbnj1PmyxIdOoT/kuSinIx4n5xj5vea/\n", + "BF+riqK+goPjHlWQl6SqROgzZp+XsRPBRN3pgt+jYr4ME9e8o9x0c/3T5GgRktIcZvhU8V8MrEk4\n", + "Wiwrp3bx20Rflin2sBSUwv26fC3w8M43PiY264BOXV04R488uKr0sdZhbdmd+/x7fgicvMYpV9bv\n", + "IRNz+O2lLsiBMnMk8uxCELEzcl8cTTo8AB/pmZ9vfx3WExWTpLBmiWGqyExBpFkRGcCPnZwjjiNF\n", + "idCfg+bzJJqqiBgQGXKfas2ht6VcyylUR6U+IGuxFuQM634hyLmDfuqJCR+Dhv/HMYBnSKXPZKK0\n", + "trA01yyRUxXfJOzsv6HXZRQ0MYKUzImanJdf6vEQOhX0aQVuVCNc4k27tleN7wUquq3z7ZRlRCpb\n", + "tmzZsmXLlu2Oll+ksmXLli1btmzZ7mj3RzafUhxwpgK1uscYfVwqZAoYU+WeoSw9JkR1qsgq3E/8\n", + "MHxWAmcS2i+V2M3vy6V7JuGk414GkzxxOGAsFYIMzT2gHqW44o77UHbTepfU+DvJ4TQAqhQ30hjh\n", + "fm1Tku3FBcAcSsaQfw3XD79tJNfagFDX461D8bfPQz8dHsq1Xgvn6Y7issBpGlGR3V7AVVKLCwJ+\n", + "BLpFylKUsGNOQA/Jp/tG8991dI+ofwLQrvb/Ciju5kzcAg0IqGxCIZFOAwnQfnwF2FdzWFVos7rx\n", + "dppjmPoS2lZlZfdL41Ni/Rm8sF5d+jmG0BaThHV/9XO/28zMXnzoquT982vUSYiVbfCf9ELU7+H6\n", + "+YW/9E0zM/v6n/nP43c//mMhT99f+rt/PZY1m9CISQ5Bqn2XEiaPtpvE396C0Nqu5Lc1QvdRp7ZV\n", + "lwE+E1cIXXFSRJdZMimxTqi7mcfpNIErcRlULW7J6VSpSA1gDBfCjmWwSTMIsZnK4zLEJ7qyK3XV\n", + "Yd5TpkXdSDPDz/0czAAwdnIc3NzzUZZ45vo0JwVzQRs87sTqhuN+KauwgqzJ5tJJ5A8fvxbKVuIm\n", + "QTeOMk+PXXABnm/c3Xy4QDuJAnoBd/81Mgqs9tJgsSpCLIbMf3Xh9WzPQ11aDfXvQtnmTO4Hyu/X\n", + "15L/Dv4u5v3U/KukW2j+xX0f6ltpYEVFt5y3P6VrGgk2GLkWS1lZc+3GuUTCoIqZEIQWUjGwRcYa\n", + "/qyERkGJjUmpCnRViluekgGjaFIwu4UHgHh7UYnchBbB4JFExZwuO1Hgn0Fpocs0nPuEu5vSKaQU\n", + "jEqBwXguRaYHruWtSB1suU7P/tsG66MGL01Ys9c6do9Z/iBbtmzZsmXLlu37YvcnyDl3CWM0vswL\n", + "0sQ37PlEnptEkI0Ij37P7PMiksnrUUyylPMWcziuFiJeBCcEVaCYZBKSTOBK0QyQkftedzokpeIY\n", + "2VUOfKm+cYLfbbF8q7c2HFgpEY/EZ80Jxu2M5qliDqOB0gyC1hFpUUkKCOdprr09iKC3t76r3SPE\n", + "+qJ2YicJe8Xku9Szdfh71B0Zdr1HZK6vRNSuOnSoR5LsDL/T/sf5L/z6JdChVnZkW+xEW0H4ihYo\n", + "0UAEQ8Ti0D7aT0SsVBKjrBlWK9dnAIJyx6P4nxCgGYDAHZciKBh3w+y79cdtIPlOL70N3/odYaf/\n", + "7V//pVjGnHwrQRh3h1szMzs793pugVI9ffGxmZl99Lf+p/jdn/wT/6mZmX347X8Uyz7sXphZmpst\n", + "zjW52ZF5tWRQrrahLpXusCl7gMPmUonVEF8VcuqpHF4W829KEeumxxkFOXXegyhLwrag34TE5xMk\n", + "9kSQNAqyShmQg0kDQAYQhWVOzhQJlUFWVmmdikQmJrSPIiJDnLsa1s/caH55VjohwKOlRgmooWTL\n", + "hJD3SdbktgmE7oszR0mvrsL42258rndY0PS8m80ex5152QGIxCwE4DfCuevhUzMzuz66+C6DEQS4\n", + "tHVEn/wcLfJ/UgbAzOwS434QkeJ6C5mGC//tAbIHXMNUQHZAEEs1O9I7Y3wmdOSJx0teQaBTlSAi\n", + "nuPTfz0gGImipoUICPMchVytYl5RGZQUn0zy6kWBWX3GMZ+gyung8wTMQimSIlnDGewjiDy8GaUG\n", + "agDZqyX/5AgpDiXbHzFndN7F2B0WyfUNa7cGjxGJX4mH5+x8i09fE2OOX1l3KFKqGhNN9b0xp4xI\n", + "ZcuWLVu2bNmy3dHyi1S2bNmyZcuWLdsd7d5ce9MwJLoXEZiXfF2RPC6wmqsoCxQefyvHxTKH+wjP\n", + "lcBd61a0Q0hiF9InuaPlCcK66ogQ5qwSLxrP55DxQMIe/n+Qc0x7KHHf+vVvQAoVL55tN+H6a8lr\n", + "VVUBUi2F2BgJgArZR5cePhN9IvpW5L7QFQr77vfBzXT90uH2Z88CefRs6zpGVLaehQBZocorIQD2\n", + "Y4DlO7g0E8Vy/K3u0W6Ca1OUeLfnoUXPNssAhO25t0m7RTt500VF3yKq3i+V5RNpJ0DAlSqWw42m\n", + "RHnwVK1Scano2hNtnwJ5AuHGq2u9GHI+jZKvEf3z7hs/EstuPgrutlbzH+ImVR2YbqFCGoC5Ax9d\n", + "BHXq3/rg1+N3F+//ipmZ/eRP/plY9rd/JmhLDZW7cdg+N+IyovaPukBr+GPUtReHFvWMpLHpZh4H\n", + "9a0y2EBoAWiTMsk2QL+YlOE3q7XXPeYOiy4IDSyBK0yV6GNevyXdQB2JFd2NmjsQXvtqKBdlbSvu\n", + "PurdUUdMrlDAjaJaPPQ9FxI8wmCbqtE1AWc6kWNUyc70RlY93bMSbIFJTBdfqHsY99utl1E9nC57\n", + "M7M1cnHWquMT+0I04ODufPR6GJPT8Vn87vrDoEul6yrXqWajgTrINbeVOYnAl/bCx38N1+L+1utJ\n", + "vSWyQtTtxKmT6A3ia6UscM2ckjUWQQmabaOia0ncbaBUcExWQphn7FBRqruV2lJST65Jsv7GHHpJ\n", + "nBe1ncS1howSSp9hG9NVqC57uvY0r2TUR1PNKLpAewlKiZkiZO1CAFB/QiuLCvTqdozK8lJG1+b5\n", + "hbuR6XpeyfirG+Z69d9SN6yUNmnqpNEWlhGpbNmyZcuWLVu2O9r9kc2n2bOrmzkRUvOa8S094Uby\n", + "3U+VZckA1V0qd8RyCewiSMRN9ILxFtwIOZG7ikpRmoKKvarAvAyenpHCWyUWBgvbma4gmU52MEA4\n", + "+r3szBDCXEho7oQQ5+7gZZRJKAWlYU4mlYRgPC2zn2v+IBKgC6lvCVilELI9SX4vbm79Wk+emJnZ\n", + "Gw9f90tNlB8QdVzc7yw5sYiicQd9PDqJve8D0pVkdcf1NUz+7MEZruk7nc1ZqHuzkXyGG7SxIjwY\n", + "XMydN6g6NbPPq7IwkRbZEZOoWMoutag2OE7yWoGMrwEQYxXq0pfYrSqJEu11PjuCssFuaiX5sqKc\n", + "hmhiNFH2wM9H4uU8LAMwiPoWtZ/j27/4t83M7Ef+0J+OZV/5Kz9oZma/3Em+NCAIjchf9FXo9yR4\n", + "g4iZyhnEXTJJ5zL+iZzoGD6RV68oTyxjzBcmZNc1dqRvvP6a1Cn89snH4X5ublyJO5JdE6RruSMm\n", + "YqO7b27hSwnoiFIcSiwn6ia733pKCbCzZlYgYp9skEn2FwQBO+jVVtA05B8bZZweIG2iU7xHeDqR\n", + "kLOtE8vrljnMFJEkWiA14nhKSPFYYytHhDYNAlB0LaTKPUjhFw/8+HIfZBf6nRDQB8o6+L1umGtO\n", + "gk1aoPiVPBRa5GIral8TqlVYgwastbMgLaylyjpUkHNp1SNQEJFRrILEflljmL3h3NuzwW9WR+Zw\n", + "ldD8qDQg6A9up0zUxvmHIux8xmpPAeE9Lp+7nVwj5ufD3C1Uagjzvz+IhAdU0QsNKItBFksF+F6n\n", + "OPux1nvE8yRmB9DMIrwTb+vNWUAiN1tpVyCSKvHDeZJkWSESvF+i3r+dZUQqW7Zs2bJly5btjpZf\n", + "pLJly5YtW7Zs2e5o96dsPk8JYh+RukrcI9Ri0eTCdA8luheA50RZldoaSgov59RVIAiz1YBYG3GP\n", + "lYD9alsSzVKifHCHKPxHaLcQuDW6OaJKrEOMJIw34jLc70LZUWDXESTXQbRFZriFVMeKhF4lG5I0\n", + "T9Kpkp7p0ZuVnAz4OnUt0LXoLrgXLwLZ+eNPn8Sy119/Mxw+iYoyPEorgVuZaHkEoVzP2/cn9ESg\n", + "sXN+JVpI6xb3J2TTNRKUigtsrqnsLmTb2GZFcn4z1RgRiBfjadAghqi7IomMZ7b/copVQhQl3ExX\n", + "3Sjtxetv5b7WSDT9cONZXncfBRXzTULAhWtFFIipHqzjlC6aDppda3EtNkiq/UJ0pP74N/5DMzP7\n", + "r3/2L8SyPeZRIcltOe7WogvW1kz4upxPkQctqsd9Rz0lcaPzD9Vsoo6TFqL9G9GRubwKbqHtmY+/\n", + "cxCkL7ZhPD156mP4kyeB5Nzr+oOqJ96RKHKj2mZLbZ84x9zbbdOKxGZfjMYKQSbxh348p/Ms+kRs\n", + "H3VZMRjl/NLnydiHsTPs/bfXTXCR3b7wcReTO6NKmllhuw1udA3AIYl60CwKTPwqSdAP0IMqxLW7\n", + "hvZTrwEIeCy1D9F3ByHCvwAtoXcp9qlDIlvxD3HetStNkA26hayT1C0jOdvMrNmFOu12wd03ShAH\n", + "KRDJGEbHKmHck2WrGwuf0nYNg1c04Tfav0QfnlVLKoQOQLrD1d3FdbUXRe4ezwzVsYtuMVmTqAel\n", + "fUzP8wS9L3XZTT3XcHFZM1OI0C16PEeKJKCJbmGhr7BOyTKR6lfpM5nPs3OZ11toRam2GAMQCulr\n", + "agAmpHg0j9ICeqVDnLCMSGXLli1btmzZst3R7k/+YCoiwdhMUo0pSlLE1+VYFlW2e3/TjMK7SU4k\n", + "vMHWunVNPqxqRAkVO6JWVZeBYBSy0+NOs9Iw6Rjq7JcaUfdqEsVcoG0NEKyyEtVbbP8mkV8gEnIQ\n", + "Eh93cMqv3QHF6XZLEuFKdlMkEg8T0S9/Mx+AhDTmO2NyoutEbZqv64IcgPj+wdOPYtkbrwUphKPm\n", + "v4tkaNlhWtixdn2He5WdJkiWGn7coC82Euq8wk6zETSTxMtayNPdHHbEMpxieqhIxBSkMZJ9hRwc\n", + "OZyygxoxjWRDFsNldUyQvF4K6sU8WXXD/Foy/hAOsRFy/lkRdl0PV4/9+kUgSs8aVoyw71nIpi3Q\n", + "oec7DxSYoV7NMf7suYear9/4ATMze/JP/kEs+4M/8R+Zmdl/93P/TSz7LaCJhXnfEQlar2RHGLnb\n", + "gjBFMm4aCGFmNvVUFpdGnJch3BGJUpAA93q2dUTm/DKgKUqUXmOXerYhEdnPsUPo/vMn3iacVwn1\n", + "FDviWeVXIjqlaAZKVFn8iOAVUcmYsGOO+dKk/6codaBke+QplN33qg79fynI5aYJc3IQ5P76kzAW\n", + "vl06Ejcg/HsDkncrO/2rCxDPZRIRHVf0qcfft7c+1nb4u++9rIw5KeV8QIw4d6+uPK/f8Rr33Xm+\n", + "vhGI1LjzOTkMRDA0JxtQQgkzYlDOthLvQM3Ai/B52DtadzgElGqSNixPKOsTTlH0i8hJW3t7VhMD\n", + "FXyMt7w+A5skOSPR9KoQdwrarhWpC0qG7I9Oon/xHAR9cRIcse6u1z5P+DBOMgpgbWHbTeoRmRkc\n", + "IM9frI+tyKQwiKCQABQG6GgGCKr2Tyrdw+c5JWmktS9R9+2Zt9PFFfLqSZpGeidU7b3ChNfAN5Ld\n", + "Z0Gkpinp3YVlRCpbtmzZsmXLlu2Oll+ksmXLli1btmzZ7mj3RzYvRvUORThNFVsJ6auycISUVR0W\n", + "TLhJtWWodlqI+wynrqkcLGgdvytFnpzus0TZmvowJwizSmKjCyqBR6NrMdzDkJAIQWLuRDMJUPSj\n", + "S9dxoT6QQuEXOPHuxl0rz18E6HsvcHcN/SrCzkqfi+R40UchYVkl28uGquiacTl8HA+u7XKLpKWt\n", + "tAn1oCbpE8ood1BM73qF55H4UvyYNVx6640oFuPrplFtJ/SxqNdbx+SymsgT7c7Er0IEpmZUKe5e\n", + "KlpPg5f1JNmKsvrQUwFYCOhw6ZXqgiwJN8MVKZB9ib44u3TF6C+MXwnXvBYlZo51ceMalbcFkn5x\n", + "G8bEw0dvxbLrZ8EtuMKYaFcOxb+8DUljX3/dx9/LXwtuvn/zR/6NWPYzf++vmpnZrbpgC7pbvUqR\n", + "ky3HMWikB1G4E1LnjLHWKhGWhHYlu45LUnpRhvY5u3C1/YtNcAGsZUxSP2xFPSGZVw+eB7fYTe1u\n", + "pO5AsqsknsV41nESCdtKNqZmmspoTUsdGy44BdT5NWk31x91LTUoayt3z1xcBa2sBxfed5v6Asf7\n", + "GOvOQt03Z/7bpy+Cm291Hs579eCRXwvHqWYaMyb0e3cj3dyGv188u45lz56H8XQcfJ3YrkIbK3ug\n", + "wZjouF6Ie/oM834vrqj+ABL1tfusGsyPYu26YOdVGAtTKcRmzN1W1g6u9xXmUCUq9mXH7BCqMcQf\n", + "+j1El55SBeDGq1VvkNk2JNtAi7/j+qPrVRyfSbSDmaXkaGr2rVZ+3kePwm9vb/05YbulpuAMgvis\n", + "Lnio8R+wQM7i2uuh/adrYoVnzdh4/zdwPa5auVcmV9a1i97bhADOSA1onGnSauhCnZ+7C/gCf282\n", + "vnby+aABIP5o8RMeQaXRhNtV/b0xp4xIZcuWLVu2bNmy3dHuj2w+z68wRrFbV0kEoiOjvv2Ht88i\n", + "IYcF0zfNOaIfiWRq+MBPFemKMglSAVeZVnXY5b3E3aQyi6P8gb6lh/PEl2954yf/WN9sV9h9tY3v\n", + "vohINUKirqFY3D/s5bcBafjkw09j2RFEyWIkwU5IfyDla74kkvMm5YuXJPtJPbHDKEUeed+FneDm\n", + "7EEsm0uE5ErodgfUiTuiQRApT5e2lJDQcGXmTFS1aQYlKMLQAXXS++Y4GUF6rqSvGVassgpEUyYh\n", + "0fdg5U9CSq8h8aBtQtK+EiULogNok6L2XTXb9Sgqzm98AarcvyC7b6AquiMlUVKHP/NKSZS6TZQY\n", + "wdxRuZALkDc/eeJj6OwsXP8n/+C/F8v+h5//X8J3QorlPErkN+LoXgZqkIivORSdgC1lxh20oKTs\n", + "H7nXISKNfrMMhW9FEqFZAyVAG7ZXPq8evR52tU+fu4r7MITdfCodAvRRdq3FSKK82pIUT2QjIaBj\n", + "XRqx7qmswRylUySHIYMSBKUlQfvh1SMpexiOH/3+b14G4nfhQKRtLqDyj/l6ceE7fa6xoywKHdCJ\n", + "Y6fE5hc4vxP1jwgkuT06wse4+s3Gc6Ix/pyzaZJ1/Yi51iVi9+H+e5FJePkUgSWSAaFdBTRlJbo3\n", + "7RrPE1nYawy8pkEexpWSuMPfhzl5UIV6KCJEBXxB+Kl2r1gSf6M5KWO2BdQzyaFXEelWIjY/l0rc\n", + "84msHOcXjtIMGJO7naNUzIahBHg+2gZkheiOEmyDoBBVCFgDnW0UfaYkj8q5IP/ixbmPUwZ59abS\n", + "GWHMnEp2ssYzcSNBJMznyv418ywGda3rOdBUyQnJYKx+8DVWAylOWUaksmXLli1btmzZ7mj5RSpb\n", + "tmzZsmXLlu2Odm+uvaJItRnqeUm6nF75NHNIc1IvWnGCgAdXwShEQXiRrG6oEyGK4YAxhdfpLsMi\n", + "AWNxfSFlR2Vr1WUak+PNXHmcRFV1RdIVUlUKRdMV4a69NcqUWN1AIX2Qe6UEspI4P/3ouZmZ7W6W\n", + "CSUrQMbC63TXmiRUpVC2apZs4cZanXnZvnuO84k+SUX1bncLUCGciTxnTdAZ3R1KtgVhXNXGUWd1\n", + "o7BPelHKPgKenUTHaYKbc5iK5HdmZnXR4BjVAoK7L/EYI8mnwN1V4W4OL0Oggqidsy5ThNN1DEHj\n", + "SFw7N09D2z0UYmc3kYAppHy68aStmSz59vpFLDu7eIQ64VwHJ4deXwf3bC3n/e53f9XMzH74i1+N\n", + "Zb/3C18zM7O/+ct/N5YxQKAUt6wHDai7G+M+TiJxxWGeHjUAIgabCBEWY6iUNmGyWJKezTwxbi1w\n", + "/xrK4hVc5aosz3H95udcs2uag1ba0Os4XdxWdFkNou1l0Eya1LWLuvcSZFKDeF83J/a5MWmzuOXp\n", + "ChI31gr3+OCBJ2g+fxjcZ61oxdXQnipEx6pck+we/n8pWlwt1slGkjGPIBs//9RdoNe3Yexcv3ge\n", + "y3Yo24uOFDMZ9EJebmu6u7FeiHt8ohK1zr+JGTD8/m+fH3F/omL/EO7WQX+LZ4H0HfWmuF5pMmAu\n", + "SZpkecC6ksREof8rHRN4uOiyT1d1pesZxsTAhN5KWeBYlwagmzeJV+DxcnneRyGBAufnDLIQt+gt\n", + "XGtCs1gE5eizBo3SStL0Kkm+Hqwuwzhate7G3a6D23gtQS6kNOgaX1w8RDVAo9BgM4wPJdavkO2i\n", + "WauKOaqr2SswP1Wzikr9SdmQXXvZsmXLli1btmzfF7s3RMrmVEDA0SfNtQdUJSGW9/jUvEYkBUtZ\n", + "JNtJWc8cUnjj1Ldq7FLGRt70SfaUVjqRQsn4PjqO/aJMdwncfbBGjZDeRqiy6y6UpMezMycHrtvw\n", + "5r7e+C6xxqv2oDstvM1rmDRDWK0Iu0Sq9JqZFQ2J0MscRtMkMBXPl0hHhN+cbb2eBqL6ofcdfosd\n", + "HpWTzcw6IEYkOUt1I9mWqudmrkDfy81G4rmQ2K3ocC3ZVWDXOw+yw7QU4dB4gSrusGRMjsxX6P1E\n", + "8nLX+fX7bpmvqgEpWHPtDSBXz0A4NDR9vw/3eGXeru+89raZme3qD6VOS8V4ju1ElR/3dhBS8Ar3\n", + "RvkJJWd2OE7R1zV2tfvv/los+1N/5KfMzOzv/V8/73W6QE422f0S4dA8ldz0FeibQrINEParpciR\n", + "Q9nB4xxTEhQCZee9E/VfQv7hzUcuiUACagy20MAKIAgrUdG/ehx20DtRuyZgrWsXkfBK8g9yrA3C\n", + "lCYpuUrWuHR/q7vvGv2ZgOQl87/J2oE2Xj9wlOASiFRCIq4wtgSm6UAyPwcysB38vh6BWH/zwtuV\n", + "63QtKF2PEPvDtcsP7JFr7yDyB0TxRxkT5+sQoMKsEP3RidD9RKTd+2SAVPck6B+DR148c/Tr8jr0\n", + "e9X6elLsR5zDxz3BfsqVqKxIzGFZJgu7foTv+ewSqI/yHKPm+ozsaenjIn12KTIUc+NJf3EMJzI9\n", + "VK45gZxrYYm1fSvPE5LNi8Lb/YD1YQbqO8u4toE5TAWRR04+E0SoxbPrfOvzb70KY1LRdFa+kbLN\n", + "9pwVNjOzfpIMGEhe2Whe2zXXWpFkKSkdovkHoYovTPk4juRhVFffG3PKiFS2bNmyZcuWLdsdLb9I\n", + "ZcuWLVu2bNmy3dHuz7VnsyVJhulSEsZe9IqoPoZRxXhZ9Ukg6Ei30wS1PYmdcCcJFjsQgR30+vQ7\n", + "+HF0S6h7whMeym9PaCDRLUj3WSO6M7zDWRWLmUhZiOWXD0AYbdzdU8O1NYxJRUPdBILtjgGyPPYB\n", + "Wq9WQhiNCYLdXFney0jKH4XY2dbQAjlzyJZ5OZUoSe0lhaqPUCWOLrhZ65smNDZzzRiFgo8HkOcL\n", + "d7fMcO0lfEm4Cga9yZi0F8lT1T1M12avriiSopWAjnsWtxxvQ4MnOhC/C9VAgpuxaHldTWga/n7n\n", + "rS/6ve7CfZXiWpigxFsL2TJyt205xh488H4q4dLdQ4PncO2ukMePAsFzJ0mOOXe+/Uu/FMt++F/6\n", + "M2Zmdqb+XihWz6W7ceiXGJUoSzcH1cHFtR3J4dJfY3HCt+4pA5Ym4+njZ0Gx+/133vDrwy84g+w9\n", + "CTm/aOF2W/k51tBYarbS1zPV/r1fh5m6aOJugmv9uFcNJtAMRO3eXakIAElUtJdJm6n6PIoLlsTb\n", + "WrSl1tDZGUW+nz+5rXzuvIO+e3gMv/3B7cP43Qbz6SDurh7z9FclufoTBF58uvPghZmBQr26FvHZ\n", + "i7u5Ceeju+UoZHPqknWaNBwL1KABCLjF+dbr9PyjEGSxvfTggT2yQbSayTwGA9HFJvpwNV3BQvbH\n", + "WlhKPzHxbjlrsAVcSzL+e/Rd17urqoB+0YSAFXU3U+28kXndIDH4Zi1BBBXrrq59BmoJLYKfrZ9v\n", + "M5JSnTkAACAASURBVJLsL2sXXNkj6REaRIH1cRRqRc+MDYMERUEXqxLRsgIuQKWU0B3ailZipF7E\n", + "5MXisqsZgCXZBpaSbdGllwQq4D+j9B2fhVOStPjU4uKWEals2bJly5YtW7Y72v0hUsWYKDxzV5eE\n", + "BoPYOKs6KsN/zd+Io0zBiS2pEjWHHmgGfloNfvsVdoaam41SCKpYO+JNW15g49/p/WBHICTCcmZe\n", + "JYTLy06HpEvd/TB3Vy27hTVCkc/OXG2YkgkaQs236t3adzpb5MnaHhh+6t/N3Mwo+lfwzVxVX7kj\n", + "kN1PCRVvGU4b5MJqhLw/zWGHNcjuk6TsnvmNREJgOIAIqCrS6OJBdv9R5b7QENVQduwUJcA1pT9L\n", + "UESp6F4KsZ7k3fGo/QpEUpFOm5Lvwm95nKjXlyRAKnK0wnHYrU2OND58EJCBj587qvNFICGjkOgb\n", + "KN/rTrepmWtS5hPQzlshYK9Amq/X4borIUy/vA5ogqaZYrs3Z96GL3/p75uZ2R/71//dWPZXfzkQ\n", + "z/uVEOsH7qYldx53f1TsFnJ8jfpKbIDHEyix9kT+Ocok1IKcHEFa/uDpb8Wyt8qQi44In0qdlPjt\n", + "5lLQpxrh0ooIYP7NSiKeqIDv9dxjV9+pJAfG+/7oyA2Fx4ngKKrL8V+eWBOnBLkPNogiM3+hyOkV\n", + "ENaHg6M0b2Mx2AJ96Z/5fK2AelwNUikg0mPp6tT/ePeLZmb2WORPnu4hEyDzZIAXYTg46nnDeTKF\n", + "ayVSEx3Qd0E/jmhkDbaJQSF7b+tPvxtU1i9fl7XzjFIHEngD5NpaojoqYQFiv+Zro/yA5oajTIGg\n", + "aRbztFbL386KpoTr9pQakGcYA1r20iblIdRld/BznCFAYtVIXkU2kDxjGhDAlYDdtgxUEgX4OvTj\n", + "YUbwgHg/iMSOvY+JDvc977xdd7tw/bOt5H+tgCZp3llC0IoCMbgHk6EXVH+FYCtF7pgp4SjjhF6k\n", + "WdsT8++wU2J9mKdDIsWzlHNQy4hUtmzZsmXLli3bHe1+OVInEKni1LudOjXjb1Q5c8mvslekBkIR\n", + "ffTYwUoYLHkIvYQmM3SykLfRAjvSMvGpl0nN9H5SKgfeuuP5ysXxmhuOh9XCZSJfql1LvjCEKdeC\n", + "pu0gdKe8mRo+5BbHJ9nCx6XvmRuCQSCBCmHCq/VWfkulM8m1NjInoslxDDGXfsffPflbB++THn74\n", + "QX36DeskHAVKPUhjc3M4yRAvHc7y43CTA1CC6SC7JbS1cjrIkUjyWpXc6UidcK1a+G2UaSiE39Wu\n", + "gNy1AX1alc4fmLvQxg83Lqo4dmHn3o9+3hlCm6Z5/WJOShHJK8NOfBA+xg5h6utzhLV3wtXA+Y57\n", + "31U+fi3U5ebonJrzDz8wM7Of+NE/Esv+t1/930PdSh8TE7kvo/92oHApaU6K0nJOyk6T/dUp+sS5\n", + "I2N3tQGqIYgod98vdiJIug/3vY4512S3jn7aiKgjB/QgA7vFoCxL4YOgr0eBSa7GgH4dZIzd3IT+\n", + "XHc+xw7I53c05qQTpAtr3CRlRPEUuZjAZRn2Pp9e3gQ04WzwNeGdp+HeNk80r1lALD+CXITu4Il6\n", + "TSL18u4775qZ2XtvfM7LngYe3vObJ7GMAsQ6nwqieTKfDhifBa7RCadsOCD/pKwhRCJGRWnoERBE\n", + "kJ6Na0F4rzAmVBCUAqA1ARzlXk1cw1QnA9dU9PkE55ffuzCtP2NKkR0pgL6UWAsPsibW5FzJWGd7\n", + "jTInDXykWnhTTQP0WybUNCznTgWOUiXo9ArjmWjyQeU/IhLlx/fwGM23jki+eHqDc7kgZ43nSS1I\n", + "cFWyTuJh4TpWLp+/fHbPMicpdTP28jzHWFOOWHeETMpO8r/Ci3E4yv0o2faEZUQqW7Zs2bJly5bt\n", + "jpZfpLJly5YtW7Zs2e5o9+jaS4nhDi0KORkQnJITT4V1j4nrLz2f5pOL6un4YxB4tgcE2FbiMhmY\n", + "h8evxRxXmuuPecKSWuC44lQZxcHVPYFfq6oxXVWafy8Sv1XZlu4mIUqTZFtLSCiPoyqwKmxHIrQq\n", + "YUPNteuFCIk6na3P/bcFCdsiCQDkdxRS5gQXYX8QWJ5h57gdzVcXZSpklBKy1fuPYa+Jsj2uKdA+\n", + "c+ZpO7HfSSgXXn3sOx1rdAEo2ZSqxEn+J5G9iIcVzKslLgCMt3UTXAy1uvZw/OW5SF18inBphbYB\n", + "1aurtgDxvpUIYrrqVBW/rKmeH+D2Q+eNzbyWoyrw4/5bce3ewD34tozTd87fMjOz75qTqF+C7K0B\n", + "FdFVhP5KcmMiAGDspb/2J9ziqGcrN8sMAcLrj0rVkyjQU/mcEiaNkNOprK55LdlOvdISTsiE1HCf\n", + "t5JDjG77c7nHGnVuDn6P6z64O17u6LLQscZgG/VZcbB7/x+RG0xJucWnoT3ffCZE+Y8/NjOzT0Xt\n", + "vhi4doY61bImdl2Y2JUQpr/zQXDtvt/6mPjqa18xM7NffPYbUifSN/y3McdmmjzPzMxKRPsUtayT\n", + "/KloYnDeKWE7Bh4oVQFNcXvtY/Lhm6Gte1G2LnBuz2KhcxljSOkeJJGfkE4pZPGqW1IrNNcjXcoy\n", + "xzA+mk0YQytxo93CFdxJf63hvtPAJib5myR35cUFggKOogqPOaaEfj6LlL3CtYPPk/XKx8SBwRM6\n", + "AdDsvVAFdtfhuGv5bR1pET52BpDcV52s8Zvw2waZD+ZSgihi+4uKPDNljKfcc17PGAAiLnC63kd1\n", + "9x6zay9btmzZsmXLlu37YveISL2yC6HJDiLuIJPQQ2TG1ojU8hTZG+TphNAePgeQc2sRlRwh+jhJ\n", + "Yi/mxJJoYSfFqkrgiYzslGJIyNZEMYhIpTHci3sgKTwphXCh5jUaEa6ryJzviPytmm3CtEF1Izst\n", + "5rCS+4r59wS5OoLErtm6SU7UVINEpwa5xyN2Lt2tlCE8uT+SHCjEWuwSR810X5HEuxwT6baAec2U\n", + "qFsurhHF11B3iQK2ETsTRZC4w9HdJ8X8FISK4nsKXcbBo6HrFF3d4NOJmES9jkIOPd6AKCtzgn9q\n", + "WD3rN6r8AcoUTKO0B8Uvq9p3y/0BaI2AHzuIuWpisQ65Ew+/4bICP/YjP25mZt/8W/99LCPYc5Sd\n", + "3jAy2AA7yIPOP3xKCLvnSZR1gicWMU9GS9e6wkH0spJl78WLgE5ssFvdbGRNgPzKWel9wlyElWhC\n", + "MK9akusS7a7BHlwnBiGKX1yFAID1me+mb24DKXw2Cuj68Ydxl5zLTBAEJQxzXD33Sfk25tiFjKcO\n", + "/b+ufD6XqHOH62q+thZSLLOI5PK4Dz/4Tix7+KVAPN93TuyeOSZnnaiR0e1FmITlaolIMfGils2o\n", + "oMqaRH1TQdgr5mSVMuZMXAvqSHQ8gkmzojUMtVdfA+aVzJOakhxyGMeCIsJrBJtY8jhJ+/P8gaM1\n", + "Z/tw/IsXz2LZLZBefU5ugHqp6DSR81pyR9aQRzjeihQO83RK4EXM3Ye2KzX3XAnpILlZroWV5s4E\n", + "wngrIq183qgg6QbCsSsJslqfo2wTjm8kril21ImgNJUOiXn1RiWbd8l3ZmYDnjuDkPyH/TK4QC0j\n", + "UtmyZcuWLVu2bHe0/CKVLVu2bNmyZct2R7tX156aK5Yvy1LYk7mmlmRPO6HsqwrEJMxVJLgqmawm\n", + "PK8+Q8KYqliN86qyNsne4oKrSio1C3md2kbF0sVD95QWkWNfColwhlbNKH60Hi4oJZYOYE33o8CT\n", + "hnxJVCfX3IAVyeaCBZMcLW6MqgKMK9BuSbL36GXDEfC8+IBubgJBcncjrirod+xu4UaSPiHJW3Vc\n", + "BpDDa/FPzQxKUGI7XZtCFGWuwVIgaLr0yDVNyLm8ZkKiJOnRi+jaVNEa6sxU4lvq4FIpa1G2Zv5B\n", + "9Mm2cRfLBpB1Ke4uCmn1ogRNd6cq5a/RZpWQXeeWJFrRLNqFdn/ySdD7efTA1am7mbkBfaydnW9w\n", + "X46tP34cctf95recWPzVn/jD4fi//jOxbA/35U7GJDVb7EgleglEgLtPxLmjK3KWccVceKOS/WOw\n", + "wTJQ5KD0Aajsj1Bdrgt3uzBQZWhEbw5abZW0IV1LqoRMDaym9rFODTKd422LeSftaUUI5GDXPRf3\n", + "3AR3g/Z1g/yMm8pdkBW0fd5/6fV8HW3WTUKsxvpUyhzr0Y4bEKF1rVvB3d/JnGDO0KeHm1j2mkHH\n", + "SOgD1S1cK5q7bqS7z29/hgtoh6CASubrSGrDJEE0XLsSnzV1pKSeZ8ynKcdhHZ3UcwMXMTXo0vyb\n", + "/EvGGhMryHEjggE2jY8nutGq1ZKArmsH11aqfqtmWIt7WJ37PdxAlbsTHamWzyRdk3GeM1m8WNZu\n", + "ZU14CZqFqIIXHqoV7rmS+2cGDnWj1tWibIY7VnNCPn/+Ap9Pve5wPV5eXcaySwvuzQ1oLKvR27AH\n", + "RUdz8/GZLZJ9nkVDXeVw7failTdRv1DI7v1R3YZLy4hUtmzZsmXLli3bHe1+lc2Lk6WLvxPcJiqA\n", + "L9Gc2U68NSahw0RimHJ8SfqdBJEasNMqZJdcE52RV1CGcNeC5hTzqZ0WVYlxioScToKfVn4Z1szM\n", + "8J2SsvGpufb2+0Do28sucQ/F4oHZxVWxnERdJbFSiVe5nthh7g5OIr28eoD7kvDrA97wJay1R5bw\n", + "vbz9U9Gct9gnYbjMuSTEajTQIDsitqgiZ6yKbMhcRV2uQTmDaeAOdtmulaJv1bKsH4hmeD2pyl43\n", + "SpQG+iTExm4fdpO3beins9WVV5i7eVFxZ1i3kthJ2NaM9DdHtLEQ5RuoCCtR/OphQKAuLsJ1R9ma\n", + "zwj5rSTX4+4Q6rs/ODmUisqfe+f1WFY8+8jMzH7fl/9ALPsff+Gvh3tOdoQIHkGuxWk4cV+a629a\n", + "zv9xPIG+QepC0RTmM5wSpXCgD+ivTtDCFQi7k6gjU66jkKAUIsKdoKkkwDeq3UHUQfO0Yeeuat+c\n", + "gjXUqR8KSji9QHDGrY+hLcZMI2Hl//IY5t0XGvktLrHfOZp5tglkd80KUAP1pDSHIuKMACAh2Mxs\n", + "jzFcytqxacL1SwkKmbjeakBHTPYgc4wID0W89QdR9kHmxAmAf0LhLEz5mkiQSFwwaEiReP4d1z95\n", + "AnUnFM25TpXC7OY6qesE5UkUuZpLSncIwsYbLzmupb7MtiHq4BV+O02OfnHc96LOzaCIUp57W+Ru\n", + "3UuuuakK81mVwldou/4sjLt59iCKYVrOUz4nGw1owveaJ5X11Hy2E/q4G/w5cTi8mjtTJFQ4AFaS\n", + "2aFlBgq/PK+VeKIocSTj/4j5fBRJBJVHOGUZkcqWLVu2bNmyZbuj5RepbNmyZcuWLVu2O9q9ufbm\n", + "YkwI4/xTYc8I+wk8RwVuTaTJ70+59krRwogK6RXPK7AzrjUKPEtXTDEJszjWX4jl8wm3EN146heb\n", + "ScojdLs4bZKMkXUa5F6PUIotRLKZZHtNbnnogmvv2DuMT62OA9wyrRAhqQqctCDbVbnOJd1jkngW\n", + "hGnV2mCyWCUWMtHpoDpCaOOo56SKwayGajEVdNlIPasTLgPWXTRDiMrP4qpZuPSm5RhSMTC6D1sd\n", + "J0xkqkJa+HoUzR6Op0qg9QFsyN11cJXuK9dYadahTqvxodcX96P6NHSzKor+1lshufDzp5/GMrpe\n", + "6q2P5z367LXX3+BB8bs2Jq31ezjsgsZRv/d6rlbBtTsIKf7Zh0FT6A/+/n8nlv2NX/g7Zmb2ya2P\n", + "namj+wKuosldxhW00sZECZ7+HpWsR2OIH30cmIRbldrhFtb+R59RF6me/FpnW7hPxLU60BUt56DO\n", + "0050vMY5uCWmc2nPTWj3eiXE8jiQZe3AnyRZV5Uff7YJbjwlTF9Be+y96UEs+9rD3xHOKsOZyW0v\n", + "ztx93IFQuznzTAWsUhnXWnGPRW07HxOrNqwja3NXzEUdXIatiPANzJ4gASB01ZKcHOqc0hymRG+P\n", + "gkaagWF8pUZmM3Xx1GUHN/tmK0moqWKuek8cb1xDlJtO95CsSQ2DklQJ3MrFcfxtL0nTKwQvtJUk\n", + "l4fafUzyLAsw9d5WK6dMVJj44yzzCuO5FWJ77FfxUlGrbl14m9zuwzOjXKkuIdrusl6ct2pYTwmA\n", + "aDh21QWP42Weko5SmYo1BlP19mGA+xLJ2FXvj+Np0mAzBoqICJ63vwRvTMsy/jkIwXw46ANnaRmR\n", + "ypYtW7Zs2bJlu6PdGyJVFkXcyZtJvjpVkS2XSMN8KjcTj5ddGnefyWEUFmdovEr2RkBCypDjq698\n", + "rzNNVLHWUHu8VWtIPt7ONUyfJPeoNq07kyjOKm/VICLuj04E5AZvFhldhjofDoISMddWJ7sUSCIw\n", + "vHiUMPQxqumKwjHbS/NVxXBl/+2zFyF0frv1XRI3J4WQh/mbwyDXBTpFxXBFsMhxVWX1+OqfCCGD\n", + "gD3qDop/qCo5PiWs9VXBjERFnyTWJK8W7l+2RBV2taUo8RYlUSpV8R5Rt+UOm5IEHyuJeh9Qpcu3\n", + "3vXjISGhKCWV17ved3CffhqUj3/g/S/Est/49V82M7OV7JLX5wHt+uTjgCBdvfZG/O6td98zM7Pr\n", + "ly9jGdHUQ6L2Hs739NrRzy88DHVfXXuww9fe/xEzM/sHv/k/x7ILKDvvQfLeiAwAQ7N1/FFQWqcp\n", + "FaCLhG0MSQRBiQYgsZ2Mv2rguCNc+SJ+9+j1gPAUK0FLMMZGDRgASnV97XPtyfOQw+7Rax7CvUbu\n", + "tO2FI8HnZ2HOrIQozoFKAqxKstQYlI/XjlI+RBDBT7zzNT8F8lkOkuushWRAX/r51hvMWYFdaqBD\n", + "RCtmDVjAeJ0FuRvBDl8V3ndEvTetI112eG5maY7PuJ5Lpgb2I+d1sttnNQU5LeNjTNbEaYlcVisQ\n", + "6xv5bVTsFuSSiRIw1pXqzmcHCfnhHmxhcUyqRwJ574ZJ1uk+nKcTjQ+iODW8DqXkS43yH7L+l3ye\n", + "yLpS1WGMjUI2p5dEG7TA+bSaXMe1TscprC1Fwet7f23Qnyqnw8APdSY0GNeDqMJHB5QCPhinhQR+\n", + "+HsB5BokswblN9SbE3PtSv69kc8/8RxEsnkvz24i0JO2+/d+VcqIVLZs2bJly5Yt2x0tv0hly5Yt\n", + "W7Zs2bLd0e7NtTfNU5LQNyYXVtVh+IfGxGVX8g+32b9dlElRVCXnd0kySsC46h7CLwrVrIAboxBo\n", + "u8Tfs+j48BqTJNes432gTNjBUWJGE3TO1NNwKLg6kOwokDUItZ248eiqUBmbFiTGrgGJ96hKzAH2\n", + "HIUISpfWrLonaLNZXFb7482i7lT2nUSDhtDqIAlPe/wdSdk6JgCnKrHQ9bZExwltkfTdSFV00SeZ\n", + "lxB41CWL0Q4mNi3KWBfVACMunSQtxn1PQtTuOibNlF/ib5IuFYrfbIKrZP0578Qdie3isqTezyAB\n", + "ANRA+eSTj2PZg0cgoD9399W8D313dRVcRepu/+Db3w73pdEGcAcXQo69vglunNc+9ziWfQyl9M/B\n", + "nWJm9ju/8jvNzOzy5/9aLKvrANHvDqFOqjtTQ4toPLjLsowuU3U3L8dOVKzXDAQzXQDiMojJmlN3\n", + "kpkTsRXip1cgyYBAzTJxGT/5KNx/L3W/OA/38/K5993Vg+D6u7x0FyB9RR3cUqUETGwRIHImrqUf\n", + "vwrE8vPRXev7PvRrIYOyRrLcRl2g6EfVUWpjNgYQcSU4JLaTuEJakOeLvbt2X74Ibjwl5W+RGLkr\n", + "/H64PEzibiQBPbrHEh03lIk+GzW9KtGH4jImzWQ1ElIXctxmDRdYsk6AZE/KgKlBz6hWVyzOr2zz\n", + "mcra3q4N/ta1c+xCm+xnccFCqX8NpfpanisxiEbacIJrbZSgKAZFlK2SzUmsFmoD1k4lZdPPV2sS\n", + "8DXcwnDx6WOqQVvo2uGJn+XZgTEza6ACXG+T6I2VxsTgWqcp+W0hz5WyXGYWmfj800WZbmnTABQ8\n", + "Y0WD8Yi2299IBop9OgpetYxIZcuWLVu2bNmy3dHuj2xelqmKNhABVbGlYmoKPgFBkB25v4kKIlGQ\n", + "qKjq4SAF1yTdLY9PyN54Wy+VbI2dhor9kqCsb+Sen29JQCcBTnfGDOfVcF3eq6pN9wN3zrJLByI1\n", + "6a4i5vry8222UGrGOfZCeiTANQoRN6I5SZ1wD7W0CXaQtztHOqhOOwkpn8RGJTHGOrPpBOkjciSn\n", + "iOjDfAKl0tsfqBR9AvVM+ORNZKXbqz8g6FQmOfxiwkQ/Drs1k101v01yHbLvZIc/gSBedFTR9/M+\n", + "Ain5XELId9hi6/gnmjcp2RRq5MylZ2a2qgMiVbce/v7gUVC+7hAU8PLJR/G7tg275fUJREDV4dll\n", + "+52T0i/W4beFoKlffO9LZmb2o5//Siz7O9/6FTNzknkvQQzMF9bLrrIHiqrBHuxrzY11BMm8bZwA\n", + "vd5SsdrPN46hfQgwTDL+jt0tzq8SFkt27Lgcatagfw4vHKWZoJgsigx23KH/Zy9sgcodMMivpF8f\n", + "YA7/vofvxbLPtQH1uxbFcsqj1ImcCs4v+R85ZhpNHglEhm2sit0c2ZqSswPxvlEEA2P8/NwRyQ2D\n", + "YQSRZt7LufT1LK7BVCGQdaqsiaDJutou1/MJkgjbcyf222pY3E8kKKs3oeRzB4R9UTWJchoagEJS\n", + "vjwnVhh3KpNCr8csQUb7YwgK6eV8lOnZcJ7KGF5hLs6NrwlUxx+ERH2AjIgG7/SUE1CZHq5JglL1\n", + "BlK2rGcl1skSx6v8AZXoNVPGCDQ1eZ6UDKyRfuJCXiyf04r6rc+wPjLYRN0UrFu5fCZpUA7fJyT+\n", + "yeAkSBDWGFCl2SPSlCMLy4hUtmzZsmXLli3bHS2/SGXLli1btmzZst3R7jVpsaqDJ74aGLWlNKEg\n", + "Ud9RlYABBabgG+FWdd+lKrbzieMLTYaJa6iKdiQlL+WGIsHNzOVLlBTbwN1CWHTdKnQZysSLElVs\n", + "lTA6gpQ3CIm5VlIerIQuSivXIDpJt4ySSKeOejpCGJ/jTSzOP0v7k9CnxOp+poq5KpUvAwri35EI\n", + "KBAr+0LItjOynCaaQcxMrPxfuBtKUzcGYeRX1aPMyoZ6NuLGQieqsrfBHTtq4lkGJcgY7iuOHQ2U\n", + "wPeD90l/xG8RADBJluXtKsD3e1ERPyJBcKFzIkrmnBBNq/xaL26C6+fNt96JZc9eBnfs+UXQTPoc\n", + "FNHNzA641rp1N8KTTz8xM7NNK76dOVzj+TOv5/mbgSi7v3V30wqaRn/46z8Wy375k98ws8hhT5O8\n", + "FqFNVpMQoeHavD2IFkxPDTBJOAw3QiP1vICrtFm7u2EPV2EJd5eSoyPpe/JrzdGNL3pfuO4oZH9S\n", + "lNWNMO74vf/2cKR+lrtFWyQE7pE89nJ299Qf+sEfMjOzt0t397zcBzeOuvbpvlN9pMi8ljFRRl0o\n", + "UeqmUjbmXV2pezBcQ519dAvOk4+TFq63tnYCfF1y3RMSL9xBnSYtxkRmT4x6NczFUeZJXLLE3Vdu\n", + "cP0rGTvQAyslUOKIa6m2VXTVwcU2yvpDBfBa2pUBNbWsSet1aJNmLSr2XH/F3T1CsXslbqz5GMpu\n", + "r4MrrhEV8wI+1Vrcs1GrSta1ulnqONXon0EZIFjjqtHbZIV1bGxE28uoM0gtPA1AAjldE/8ate38\n", + "vAws0mcCm3YlUVExaEAzn2Adb3Bfldz/gPlZSFAItdA02wGpJbNqG+IZKKLs1rN+4m5s1Jd9wjIi\n", + "lS1btmzZsmXLdke7v1x7ryBQfCHUt3rukpaB5vbK2yp3VSeuo8hVkRLblJzG7UKSaq1Idyavntnr\n", + "SaK6oDQgL+r5KA/AHUQjaBEVjlsJV6VSuYZaT6fuEWVKzmM4cym7SaI47Ro7Pgk5PUCaQBVm+TKf\n", + "hHpHDr30E9XJRQGebZ20XNxoiCr3K2/604n/FbL7n7lzFbZ/DGs3LcM9aIPN6a7KzKwCkbsoKYPg\n", + "h0fFYCW2MlxXQ20Zpl5IDifev+xqItoi42kEebMH+rPf+251hfvSnFMxh1ci7b1U9mUI+UbQh3Ub\n", + "UKKbWw+1fu/9HwzXB3nz9saREZ6PyJSZ2cVlIA/vbzywYIVd4iy72t0+XOPqysnGu5eBWPveD3w5\n", + "lv0rrwfS9P/6LMg0VKpEjNxh7fosll0jn+RRdpUD5lUrYe1nTUAOmo2fb3MOEu/G67m5CPU7YuAf\n", + "hbBtVOLvXZ196rnTVUSKCO9SfkSV9QvMz5V5nXZo25tPhah/Hs73vA8SCn/y6/9W/O7tMiiFDzIm\n", + "qCxfJ5LVuLzMQJLsVytHuIhwttImA9adqiSqqqHmWFf8SpFQfZDcZETVPjo4SlkBnSmVbAxCs6ap\n", + "tCH8hvIrisgbFNBVfoSEYg1AWJ2HNl5fOSLEcP5So1cop1DKPWJNOh6Rf1HQJ+bJbKROa9xXU3sb\n", + "RpROCPg9UPJKNBlqSJzoGlsAzadi/lHlP4rwnCiSrCD4lLW0xnNEAyWiFINIjDBmpJV6RoK4BoOh\n", + "fYj0KHLeU4lf1r9hXAZgMcsAvQqhLNSvV6V2rCeKAlHigGtoXetCTSV+HZV4duvyj6bQtisxF6cT\n", + "OflGkZhYXwiyeMIyIpUtW7Zs2bJly3ZHyy9S2bJly5YtW7Zsd7T7I5vPdjLx8JRoS1EJdWkK7Y6E\n", + "EW3520p1VOwVuFEzNc50uymJ8YQ+1anKxGvKb+E2U2VX6n0UTQpTmjmhcyXuvg0g49tbdy10gGq1\n", + "HoSK1bVXLPl6NuD6NcmkjeOe1ICZZoU4cQ+CrJOgfqqf1C9I92V5gpQ9ywnJD45KtYnuDVwmfvl4\n", + "PwoZF1HbS+BunkMjBWIfS1HUjCHsLxo3TFqqyTDRZoUq9gIzrleSIPeEBtaAeqpmDCtKAmQhxNqq\n", + "p56KuwwOx2tW3M87LIn1TsoVZXW4nirpu2fPgrttDyX0afbWvr2lu8nHyfvvvW9mZt/59NNY9uhh\n", + "0LupxS39HC7C7bUTZSu4Ox6998VY9vgy6Fh9GfVU1XtqkJ0LxP/rw9Nwr2u//10RXB/Xo2gR6dpt\n", + "hQAAIABJREFUFeE8733OkzA/uf3AzMx+UHSsnu/CfTxHQl11hc2Ya+Ps5+26cI/l6HONrt1B2jWS\n", + "l08kzd6cuWtt9yy4QFfi7i1fBLfpT3zld5mZ2e99/f34naF/xs77adXCZZZo1vH6Mp6qpT4OXVCJ\n", + "+47tjXGqLiPq/qgbhW02ymJz/igEL6zP3SXy2jqMhWdHCUAoGTyTLFThg/6+SpXoWUc/nGvXLFJY\n", + "a5S1rZ+3AQG9bHVNxtohARV07VR0MQmJmaTo89aT5q5buva8X8eZgVI+ngu42TvVlsM81aAoPqf6\n", + "Lnwed97X6xU08ySwiarstarTo07qgj5Qo60SsnVBbT1xy03UO1RtJdIi8DtZVyfMk0Mnbjz4DOW0\n", + "MSikO7gLvAV5P2HPFNR79D5hnaMGWKJsvsxiMWI97SRTBNtzEFrA/haZNUZdz3Et1c9bqXt5aRmR\n", + "ypYtW7Zs2bJlu6PdI9m8MKUikyisb5VEeF4lppulBOQKx40JXIQdQapdEM7H/8s5BOqQOi5VjHmO\n", + "Qnd/JLadkETQF+26oSovQzhlC0XyouwCmGNpe+ZkW4MS8kHe6iOyJ9dn+KvuHFrUZoCK9NAI0taQ\n", + "bC73j7+HUXc/86uHeaS9NBNDnVWpPraJoFQknjOfn7YXJRw01J+7r7HXHQQ+VW2cStEJixU7rcZ3\n", + "kwXIrkQia1F4jl0isyRGTsuujrta5bWX3JFOOp6haF8sd/MkYDa1H//aY+SuE1Rjswm7+uvnz/yu\n", + "QFTVXI8zJAPq1hGhi8sHKPP777GbfPj4Ee7V23BzHYjNT37rN2PZL//iL5mZ2ftfcGXtf/Jrv2hm\n", + "Zo8fPYxl5LUeRBZ6Yj1F7fjz737ezMw+3QXUtdo6Of3hg4B0vXjm97pbh/H/WuX38BJyBp+aq7jf\n", + "lNhpFj5P3kI+wVbm+DuvB7mH7uOAAg299/8R46nrT+y+ZQK0NYMi/F4roHMCHNjcMShBxhjCyFtB\n", + "jh4BMf4Tv+cPh3u4ccL2DqHzrawd7MNa1K4b5L+rhVhOhKGUhYph9LPM8YJkZKKkys2m6rQSloEi\n", + "1kKiPvQBaXvz8edj2ZMpIFGdoFldzCjhF9khZ+jMxkvysDEPns4h3IvwgRtIh8jUiSjyrLlTqbY9\n", + "q5xGuO4WJ1xJqP0Z2ngtBHT2hcbNMFBK1wSiSKOi/gPzbwqawjbGwlNIEMd0wBrWyrOTnhWVOqDs\n", + "R+uNQtmbqfT5d8rfE5F9Rc6JpmMuDKKhQGV7GyTbwAGBMjtB346UHxBvwgron8iUcBhLUo7kOWL2\n", + "2wSASRmnuHouemTUOOwlryPq0glKNWM+J88Ckew4ZRmRypYtW7Zs2bJlu6PlF6ls2bJly5YtW7Y7\n", + "2v259l75P0G50k5AdidN3XJ0C3pRVEVXHRf+SVeQEqZt6UZ0VFDVqcni1gSJ1DtRbQu4G0VZNSrA\n", + "gkRXJM2/dAYSvqyEgNwAUh5Ed4OE+qpYkrgVAvW6g1gtx0eSvRDs5pJuN6+lN4kqxpOw6MeR0Fdo\n", + "PQGtV5VA9ewUks4FH6cbsdF2pdqwQMskvs8Jjs8P0bYitC8ugBJ1qSKJXE4BiLmsl/dQaKACublK\n", + "FOc9qLL5TKKy/5RK8myHragY1/Ajlv8UVd2iYrs6FH12Ec6zPXsQy8gFPexcR2qN5MJsw9uXHtiw\n", + "ArR9Ju42uso1A8ARejcvRINqu25xvM+nwxDccqMkN37v8ZtmZnb95MNwXvHPvH1xGeq0ddd21Nk6\n", + "9+tfw1Xy+Y27Z16CxNubE5vPHwZX6buvubL79TGQ1x+cBbff3D/3+8dYO5i7x26GUHfNrHAA8XuS\n", + "cfoQunDPd6L3hLajnpCZ2cNtaP/3H3o//ft/6MfNzGy4Di69QZJ8d3SVigs2utREHXqOBFyZa1R7\n", + "lzlObaExCaih3l4s8Gvh+E6CAug+acVlvt6GNptvJOEuCODrSdw9hxZ18t82Fcjb0CUaB6/vQM06\n", + "ccUw0XQtWkgF6jmXup4yeEYDing+zUyMD9y2Jn6vPWuu1wku66JYtrUG+zCRuyqb99RWEgoG69nh\n", + "OXErum9VFcbVRnIxj1zDJAMA18LNxtuf6/9ek7tD+0ua2NcRWU9Jm+DQSBgztqRxMLn8oMR60Bdm\n", + "ScI+ct3bitp+TJbtF2ngXmUbKz0kBgfI+ke6w6DP3yiups8JagVqAAaeu+K+blbfI8rMMiKVLVu2\n", + "bNmyZct2Z7tH+YM5QaUY8pmG8PIIRZ/wsVQuSMM1qYpenSoDwVCuX0QEa3GpVB045oTT8P/l9U/V\n", + "iaGWwwPu6vX6p86BN/NKkaMOn35cU4bdXEpiZgX8GjPezslnThSGI0wnlSr5nSir86U+QYmm9Acm\n", + "bZ10VJF+mqNpUSZBd0FVj3rrtYjgKNJGCQOVsXWMk0byfiGseOZiKyFdMMtOv8QuZC50pzsnn+FA\n", + "trXKX2CXZKIYTeXnUfJ0oU+2yLX42sO3vL6I5x4l119L8nDxNJaRJ6wh4XEjJsReEnCvzh1hur0O\n", + "CNSL50EGoBf0Y49zXGwdJXvxMlz317/1a7Hsy1/9YTMzu37+JJZtoCh+OPhuuq4CoZ0Kx2ZmF2+8\n", + "bWZmb34rkNjr1tGnNW6sERL1V98Oxz+7dmL529vw/Xjl5/0U97FZe1sfIW1xMTr68agK7d2tqMTu\n", + "uQafHcP9tBePYtmHCJNWVG8HqO985eeNa8zR++4AAvobK2//L7zzOTMz+8mv/Z5Y9iZkAkYgF7dH\n", + "2S3HAAzZkWP8r6SdWgQUqNRBeQKl4s69OCEBzewEk+zqmTtSz8HsETrVG4zTRqQe1ljHup0oqyPI\n", + "pRcF7tIhXnzKnDyxrlLRvJK5XrWUWvE6UWKhTLJSEImSMhK/QdgvJBOCRfRbECRIbYySazAmWy1l\n", + "7QSKp4h8h2CIUcjuRCwPL6F6v3cEd98HhPOy8MCO7TmuK6jKCtdQhHuzxVo3iOeiK3ANR2LLgsFQ\n", + "jmaN+4Ds0vsyqWJ5LNN1EtIRa2kTjhPpJ/K5awl8IupZVvp8GnCNZf5bHpVw4xkUJST+oV9KIgyQ\n", + "hOmOvu4xFqcVAvz6LMsfZMuWLVu2bNmyfV/s/hApSxGZGe90Y/L9ki/FnYDuCGIuJkWTmNbslbDJ\n", + "tAIn0K9EEQFl8ro5xbjKJUqlFZhiiZcdDxBYA8+jvxBfMXYJvYRaMxS9EV8teU2tZisnmDPpLpHH\n", + "i+8Z3d2xdnL/lJA4yg52ZA4laZRJuUHxvJQuUL81SU/qN6cvW/P/8STc1S7rdJBzGEP8hSPl6JvG\n", + "yyKrufAmDDucUtAk7lirdZH838zBnEnzOrI5Vf4gHi/hvxR4E94K80Vp7rot0J633ghIyHnliAzb\n", + "pix8B9+02MFKqDH5Tf3Rd7XX/zd7b9Zr25JWicXsV7Pb059z783bZE+TFK1dD1UWNoksl43JF3hA\n", + "VkquQvwBC+QnLJUsJb/B4gGVGwlZFsaU7KKwhCywiwskCZVk3uxvf/rdrn52fogx4htzr5WZ1k6h\n", + "g0vxvey1Y801Z0TMiJgzxje+8a39DnMlofP3XvLoy1mjYfq+QWNwWh68bPyhd99+xznn3LNT2a0C\n", + "EcmlrTfveJ7TuUgyEB1R+Y3pvpdTKAZohj/PIbhavYQcdxuKT1pf3z/0kgh3D41TtMIOvhCC2xwh\n", + "9NnI+q7POP5s3lHEdv3Un+Oks/566abnaK0LO+/pw8f47lYoq5H/72Bku/816lwKSvkcu97X96xO\n", + "P/n6J5xzzn3ivvX7Zu2lGC7BjRkJIri6QP1UfBHf54UhCOQ+ZYrmcs4ompy0W0Wcp2GtkzW0bchR\n", + "UX5pgjbbrp7yJ9Ppnp239+hnKfekWKxxfcknybxq4H41veYw9H/7WslHRH+U4Ih2yb3mOtFIXrUg\n", + "LCzPE6bdW4GjNUqtX5uCc0fQLyAxXWf1ZP+vN1a2bvz9nNeGpna1R3pqyVNI+YUl6plmdv0FZCXS\n", + "Sq6PNSOVe0IUVzlK7M9MRaIpRKz8OvaxLvVYGCmN0AnPj56OtQhy0mOQytypkLsu0+dO+FoQSSKn\n", + "g3E65JLu4v7VgnRzSGyk/ylmrWgWx0IhgpvkSKnnIi++96tSRKSiRYsWLVq0aNGuafFFKlq0aNGi\n", + "RYsW7Zr24lx7SXIFO9w2fjsgNpKArW65HZ+6XaRkKpt324q9u8jZJpOg1QYpXdW2mZNKiL0D5uWV\n", + "up+fe2i3FDiRhMlacMeDKUjkctqc/4gLxAUVbalTIIhq3/E7yhqoG81/LsU9sGEOQ3Wj4iTqnitJ\n", + "ct1BYtXcfayLqv02qEtBuQj1xKaEh62I3TNQVoa7oW0GWLT/rRIWIWPQS1nCHINwBZQC4dKNqRAv\n", + "3a2ZuGzobtWwZtf7e5c4qzy7ZzI29939O57IfOeGd+2NE3OFlFAvFq55CCvWQUF4fj1bbB3Xi7T2\n", + "+akniu8fHYSyMYjndNltGjueY3G10XBt71pQcvI777ztnHOuGpsL6gjyC3uiyn+G6+cKo8MFQhL9\n", + "UkjHrWOovbl97t2+jfpqrkES+0U6A+6oy6X9dlwVW79NEYqdHnoF7nc7U3E/Gvt78Y1Hj0LZP/7k\n", + "jzjnnHv0+Gkou3/X12l/z9yND9HWUu7/rdb33afumCr8j8O116xMpmG5Ye5EuLZnJkkRsiJIbjhm\n", + "SOh2EctlTSjg0tGAnq6ju0NI0R3n/Y410V11+5lrr5G1q4BkRV9rUAwVwG2OhXx2pbpbIRMC93Uh\n", + "NAaqguu6XpSUFVFcAGucUhUoNSKk6MAQEEI93UcLuJuK1NxYCa5fDsYQ1rWNKGbDjbtsLChhtYH8\n", + "h7hK+9D/GqjCddJfa72yMUyv/HhsbvQRAipKCTbo4GbbrKxORbWtSj8a+Xuy0PynHSUhVOJhGFCg\n", + "z8Qg56GZHXiPlaoBGkGa2oEkluciMUEPvboqSZ/RXLg0ynW04rJt6PrdQUBXukeGDBnqAS/GvgLC\n", + "03eZ5v3bYRGRihYtWrRo0aJFu6a9wFx7/VWoZ8dB/s8gXxl2PzuAo6EgJkPipYxvrOmOt1qWNAMi\n", + "LK8vxxGJ0EuR/yy7NO6ONSSTZ5zPGtTDdiv85cGhvfnyLXwy0rxe3NVZG0g8bnVXGRA5e9NvuJ3p\n", + "mQdqAP/gKwlDxS4ll91Kj3YVgtwwg7xmH++wm9kISsMQX800H3YsRJ8EVciByJSyW6Mgn1Y9IQFW\n", + "wK8gvyDEyiBdIJIYJCBTJkPJ5n3WbB+PXWqaa1uxg2yF2I9tle40HcbfzSMLXb5/0xO1p1DY2y8O\n", + "w3d7IIAXC2vsDIjRwbGhSpfn56i7IA1AAgbEXtyfVCC+9973CMwdCGM+bR6H7z72CY+WfOX5v7X2\n", + "oyrLpSEo+zO/O/7pf/wfhrJvf/kv/HmPra3PnnvSerO0unctdukgu+4d2Dbw8ROP+qgkA1uoopaT\n", + "sUfVliJcyPHfLA3NGY896lfL4NlHSHgOAviouxu+O8J9SuZ2rRxSC3uCfh6g7vuCyE0xZyaZha5v\n", + "0I4ffvCJUFY6X7/FxlAHCgvWIBZPD21MrM582VgI65QOqCpFFXz9CiFbJ2h3XookxBJzUtCkFgRl\n", + "yq5osAkh4052/0Rni9zkH9ZALoup5HqDIGuqwTNEeCV33D7QrM75cyzlftVYpxT9D3NRYAVKQihK\n", + "QUmSRhQpW3oYpP0jrLGUPVhuRMKj8+1pJdikTzGGVcwZv90oUZ6yEgLdNAhK6FU4kmLKDCgRRLoB\n", + "gnVyZuN6/8DPp5EEO5Cw3qxs7BLFUyFoemKKXF8FgLBv7Ldcd4lmqlpGEB+VUxAJzMRzUiQM9hBE\n", + "EvdfESne2oEnBs+7xHSCtq41fIXAmtwrcghETKVrMD438tzL8H2mQqxZRKSiRYsWLVq0aNH+Tiy+\n", + "SEWLFi1atGjRol3TXqiOlHq9djj27AjB7Mg/a/TX27JI4YwDF1BwtzFhkEDB1GLKtn12gxxCOxjo\n", + "1D5SHSVCpkP9dn7pj7u8FJcFCNCFKLyWhFt7yWtVwt2juYYASzbiRut7wJIDZXeSSHcoAaNM0EwH\n", + "Idigq+Gcwf3U33HOuRGIonkvhEGows5ru8Zq5T83TupJuJl9mG7D84kQu7OC2lbSTx1dm1JPuNS6\n", + "HUR5dfemWTsoUxV3jpcBjk29s3b7vqapaNag3UriLUBYPD4yAvbhgXdLTUFAPxiLy27h3Wft0qbp\n", + "0bF3T52fG9m0hZurkfxnKQiTWssKas/52FwwH7tzx7cVfXhxdh6++9svf9nX8Ya55+olFMBvWD3v\n", + "ow1/++W/tHrC9fvBB++GsgO4qOZad7h7qLZeSw61xQLkeQ0KwViYzc1ltlr58bQWdeIVCLqJ9MBi\n", + "jTKZEwtoei3Rrr09uzcVPt+/dSeU8Z589KWXQ1mNsn3Ja7a35/unkhxy5xf+uONDUzZPoGztEiHZ\n", + "Y+KNQR5eXFhbR3BjXkpOxNEedYRExwx9oR6JFK43HSck73aiS8a1g7o8m1r0kXB8Wao+k//tdM/G\n", + "RApl+2ZmvyVFIJM1brLn+6wXtfnV2vfTBArwiawrLU7Xisuqq6ltZW2oqaItrr0+BM9IXwd3k+iX\n", + "0c2Deb+Rc8yhFVWK36mH3lQv7eL9VGI5ifJKn6AGorIdQu5WkOJ7+ZLPv9Xc9M7OofN2IBkLlvPV\n", + "1rVCTkDpzxru8LVo24XsHfqIpfvMpYP/nZPABjt8kDM1HMe1Ptluv9JtgvdOgyL4fKCe1SDXH8aV\n", + "BiWg/wtxwboS7l7Ru6I+lAbPUHk+TbbH+HeziEhFixYtWrRo0aJd0/7eKJsnOz4F1dkd2NUw/12y\n", + "4zhKm2+H/4e3akWViD7tCOvt5G2ZSIgqcKc78u+FMN10+808iOnKbmE+87uayVhkBTKiH0r2xGch\n", + "jDJMVTOyJyDWKdmyBtk85DpSpCWhhIMVhTBZISfnOxCpEMLubEceyIOy+2cm7n6jTEWQLa3i4auw\n", + "M9Ss6o5EQDlF5f/RjPA9dnNrudYuBfoQVsupoGOCJPId+Q9blVDANlFRMpIyU9HqJxlzPLGdzt7U\n", + "fx5N/I580xmxtR/5Hf7qwsqOJ15R++JCxgkI5fVTy793cfoU9RUVc9Tv6LYhLE8eesToI294AvSd\n", + "O6bYfX7qkaNbt61sAaV05aYm2OFrmHaBnHX13EjpizmI1bKd7DF2jw48WrW4NKRljnx20z0jW1PO\n", + "QHNonZ/5dqti9Qjk/Y0QZi8hI7B/aKTcp8+RTw+h2dPKxvAK9T0WYn+BsbYWcvizS48Y5bJOVDjP\n", + "89pU4UmiLoVYvZgDpXBmHYi9NdpTCYLYoL/KSuQPuMYoYZbrpITkM8uAqjQvF8jdKUEpHDNEKTSI\n", + "paeEQq1BIVgTZE1e4xKaQ65He5gHzznnSpynHVt7xrXvu3rjx44qcedAjgT8cyFbnqDfAc1WVIXN\n", + "UGVv5vrUp1FA7nEuQV8IZtQ6hoGSJyIXEHLHSVYGkpcVYaLaR9/ruuf/NpQw0WAblKWCdD1/6ufp\n", + "eGRo6vHx0PvgnHMbZD7oa0GTsLat1yKxEDIfKAHb1539qehfQJOkLEMAhnoEOGL6HQi/ol+UKZCq\n", + "hxyTfCYMEKwdkgxGNpexy/ZIPXl/SnmeGnImwRsDXZ5ti4hUtGjRokWLFi3aNS2+SEWLFi1atGjR\n", + "ol3T/t6QzQnVqSsqQHuiREtYMFFto5ZkQztft0tb4qprp9t2zwy8XZQ4UtiVpLeBC4paRHKtkPhR\n", + "WkkJquBOElcgiJ3rpUGRi4Kwv5LY14NrOudcQiVageDZxr5TtxT79oomhzRWIVMK0KqyMCFWPa7M\n", + "Pc5eCtk6gwuwlGvsjfz1Z6pATc2ahP+LEnnHcwkBXfFeXqugZpJq4cAF16naNftn+xzkWhZCOk1z\n", + "QOuqxQV9JiXMJgXuSSt6Q8xuPEg4jTEpSu3F1P9TghyuY22x8q6tO5UpZnPcP7h3P5SdnXvX0vmp\n", + "kZLXK0/Uvjw1Uupo6t1dzx8/tHrCpbVAMtxFZq61Q5CHG3HZjY+gWG5NcCfnT/zxE3NB5RgnrSgC\n", + "r6lAX5urkqOIhNlTIbtTx2YyNRLt2Tnql9q93gN5e3ZudX+OvtjfN3cHieyXl9YeksxvQzE9ENyd\n", + "cxdwS2oyYvZXI4vNFNkAWlGFp35VK6rwr338k865ofu8JZF7R+RNDvfgWjSz9iZHOER1d0DY1UTq\n", + "1FsqrO4JXDYrcUEFVXKlADB4Ae1RzSauz726drmOSuLbp2uMJ1Fs52kaUa+nBpBMU5eDFFxN/PmW\n", + "F5qgnOdSaoPvw1QeZ+Z5l/UE66N6aYLOnLqloHzdY7yq7lXPZMiijk0FermouTR1nU64Jml7EAAl\n", + "lbqagaJTdXCssY1oq7WdH7PPHj8LZTnWLLqJnbM52StVApetNbkv3Naqd0W3WBp0twbOaJx/m4A/\n", + "WGsTulHtPoVHvPYJHsJFoVkhhsE9jcw1urbVBUtNR31chLGjKupBs0qpOld/8d2C4cwiIhUtWrRo\n", + "0aJFi3ZNe2GIVNq7gXSpqZPKrqrfJoeRO6ZE7R0CA4ZE7VJAJcFwIKuA3fKA9LZ9Bf6m35FLr9W3\n", + "9HT7HTbsGHFifasnOrW4tDftccUdoYTQUp29s10qX5cbIVZn6XZOKu56crzp69s6+z1VqQH0UyM7\n", + "WJoq4Y6Qw6zKjAEaQCwlylPtV8mbrDPzBbYi9RCI2kpspKyEIoLop1x2bqhe0uh9IAFfQn03ULtF\n", + "u0OOJie7VSGMOoTTalgzm6p9x7aqsjwBu8YJKRs727QCqtlJyC0Aprs3jeydjPz5VpJXLyjgS/j5\n", + "08cf+rJ9Q7NmIGofHpicAcfp+cmJ/+62fTdfelQhEXXmT3zc55p7+tbXQ9negUd9Zo9MFX0FiG88\n", + "MuwqA2JXy27ykCjZmSfM1oJWZEACnp/bTvv2TY8crQXVYji3opXFCOiYTEkSkDX/3wKoE0P99foX\n", + "qFN108Z6NfFj/OyxkciZbWAp8gtp7u/nK6+aTMIe8g+endpviSZpiD1HVobohEllSF+N+aLE9hRE\n", + "2USCQoisEkFzzkjLaWt9t0GdlQC8BtpBZCob2bwmcDBYV0gAlxyST4GInpzYvWMuuI3cO6JEmuOR\n", + "ZybqPRHF+BWQ4MtLQ7qIurcaxBJcAoKm5dvPGK5Tuk50wBcKqmmLij3R5F7uF4nXKidDNfhMCcsN\n", + "8//Jswtra9or+sJAFbRLCdPwKmSJHu+vO59Zn5wiUESRFuYw3PWQU4Rr3VCpXfMvNoNrab5KEroH\n", + "GUDYsUr2xxjLdmQWaTRQiI9JmYsV0SzKdch47ZkHUFBa+6weGRD1xcNBlQZdp0OlB/l8I9k8WrRo\n", + "0aJFixbt78R+IETqtddecwcHBy7LMlcUhXvzzTfdycmJ++Vf/mX3zjvvuNdee8397u/+rjs6Ovr+\n", + "J4sWLVq0aNGiRfv/mf1AL1JJkrg//uM/djdu3AhlX/jCF9xnP/tZ9+u//uvut37rt9wXvvAF94Uv\n", + "fGHrt/1V11cydHs5Z8kwlVjNTwNSOPWe+m13WycwJhFFEtfSQR0AD6o6NznpqUCx1LjYQXpOVYEX\n", + "biklyQW3YBCSEoId4Om1JEhdT6DxIm3ISgqZSDJK6Lj0jeit0LWlLkgSuqE3pS0IVZKy4KmSc5DQ\n", + "l4trj2Q/VYwuSNAUzZgW7saxkOJbEGA3EGjR+8U61Z0dTyKqtouJT3tNUFnhOHEZuNrXOVNV3jUS\n", + "lKYkggqMXrMTRQsF1+8k8SUTVAuy7NrEw+OjkSSNBRm1bo0U3ackwIIw2xhkX7b+t31u15+de/he\n", + "E/SuV749q5W5+/qWWkBCgAcpeu/Q5uv5wpO79+Biu3Fo7pkJtZjWdt5v/tVfOeec++TPfCaUPf7L\n", + "L+ECmuTT34u7Lz0IZR98w7sD1d3UYs4soGatyXA5P6lc7pxzKxBhb4m7c45kyJpcd4SEz8cTcwu9\n", + "9+EHzjnnjm7axm4fausPHz9yzg1d1i368EiU3Z888e7LtdSpPITukejzZNBvyoSAvEKi50GMB8e4\n", + "jNMSbskVEgoXonFD/bZUMsRmIPSra5m9qAt8ARdhK/Wkm0m6PfRBXVNHStpFjR2NrAFVYFKaC/Dk\n", + "3PfTydOTULaH8TRQIIebfa0u/Y4K3AzsEWI/3IfN1Pp1fenvf6JJizO622ysJS0T6Vp7Cuq9abZy\n", + "BkVgLcpKde1vaxZy3euEAtHQs6W6hKSPiKswUB8GXkkmkKc6tyQZZgCUBmAxUYesncuV709qp/mq\n", + "+9+MhIJBUnzb2DrBAKBadAnNLbe91tPNXEoEAt2j6sakBqCOJ2a2UNcuyf2awJ7uZhLQeyXxh5M5\n", + "sy7fun7QoBy8J+DZqfeTz8JhpJr7XvYDu/ausul///d/333+8593zjn3+c9/3v3e7/3eD3qJaNGi\n", + "RYsWLVq0v5f2AyNSP/dzP+eyLHO/9mu/5n71V3/VPX782N29e9c559zdu3fd48ePd/62u/IKl4Zc\n", + "OlbWBClyIX3hTTgRtdfw1r+DKL6D8211GISmguyrOxOeUIiIzCHUdxpCTIRLtnVEvZRseOWlU3da\n", + "3K0oie7i3L+FN6J2zpD8emR1KrETzHNN2MSti95itDHdJpY33CVoHYMkgoT/8nhpvwuXks6m2rnk\n", + "XOJuaiV5sgqgJDWUdYXf6JoN+jrblsQoBBFiWSfIUSAUJrpzIUolO3e2g+NFdn9tvWP8YQeZV5ob\n", + "iv0pu+qcBGgrm2In2EigwKz2O8aDzBPF23M7/o07r/pjFiYJ8OyRJ+8qIrtAXq2NoJRkfrai7E0F\n", + "/GfPn4ay1z76Ef8B7T45M3X01HlZAZWf6IEgnD80CYVFx5277CCxI374zvuhbANC7UTu3Rq73snU\n", + "t//h+++E76jAnZZGWCeYqSjlBrvqRAiwGVAVnf7TqUenTk4s19/h1KNzqxp9LB17/4FH0+aC/hHN\n", + "mYliO+s5EgVyTqPFhd27aoLcbXKbFnOP9lWl/XYDdCDdgdITfdf1hxkLUkmsR+XrRsLTq78IAAAg\n", + "AElEQVTfSYbO5Frc4V9I/kPOgRHkFza1omUlK2JtxVib7Bn6962//bZzzrnT53bebuTPk1c2xxpK\n", + "kuSigN4z7B95NRXB7hgab22dQDF+JR3LwJoklc7G+pz1itwDkZb2BGVrLAqNSrIQpVJUEdVLy+37\n", + "pKH+fVh/7bdFBoRNUGfXEPX3desGSuBEyQXpQWVKCUpgG1ci9VFWCFSprayqruSfdSbjoZIEJHnT\n", + "E6Cp9DjXMkV/KMnT6UBhvwpyiPvUKnKH39Sdob4ck5T60UCtID8kCJbJ/qhHKhn8HZhKh6Ssp75j\n", + "7AppM/uBXqT+9E//1N2/f989ffrUffazn3Wf+tSnBt8nSTLUKooWLVq0aNGiRft3yH6gF6n7970o\n", + "4O3bt93nPvc59+abb7q7d++6R48euXv37rmHDx+6O3fu7PztTMOHp6MgFhgtWrRo0aJFi/Yi7eT9\n", + "M3f6PhHl7y1/cO0XqcVi4dq2dfv7+24+n7s//MM/dL/5m7/pfuEXfsH9zu/8jvuN3/gN9zu/8zvu\n", + "F3/xF3f+/uDu4YAcGuA51ZHagWYl3baOhNtGwF1Q9h5g0Dh8B3QXEhkPEuTyr7jn6MZQDayE+iBy\n", + "eRLb1d8Y6kk2m8CTgTFohy8vPASbt6IEW/KnQuyDm0PyCAfiX5IYtJ3B9VG3hJjt+k3ofztHv4uc\n", + "11J3RGD08XZ7CItn4j4kabISsvGmGKonC//etUyyqaOUysKStJQk7oECfE8oWgjQVOVttjVg2Ebx\n", + "GIV7p4q5OaDwXvqOUtWZ3ACSgRNxIxAOzzNJWgpC7zL1Lr7bvRHBKyZjXoq2FC47Fx2pxaXXe1Je\n", + "Pd3ItcLzcJFMJ9Z5l9Bounn/JeeccwdTu/7TJ16LqpCxPgLx+esgnTvn3E/+o3/knHPuK1/8olUA\n", + "fXx+am7Ej7zqlb3V3UJV6PkCCY3X5jKbpvs4xtpQlL4vOiEWE+UvhSi+RMLhaWYJjw/2/fk24haY\n", + "Lfz1mOT42dMn4btb97xmlY7/i9kF2mDXv4Sbr5Ib8NIr3i07n5lrjy6by3MrIwF83Yi2GcjjCdqT\n", + "ijo8gxK0/Qz8UG2zntkTRIOu5vdL6U8m0pYswA10hGpQGtSNk1KrSob/AQjgyZEp0L/11lvOOeee\n", + "rm3DvBz781aStLsvURdxbZVwETMTgQZMtFj/k26H20UzW1CXSNzdxYjaTnZchbGV71LRZuJzp0Rs\n", + "6gg6Maz/ooXEZafTe4KPeaLBFnRf7tAgRABOnouOV5DnljUJLt2qMDCCGljpoE/aKydxbg2ahZKy\n", + "GwRZKPUlXBadp4RxUj96fU5yzsrzlFpRw6wgrJPVk+5zDWgKQUD4o1lBjG4iWmQM7HLbzyTVFgtJ\n", + "kJNt+sjNlyfu5ssTfJ+6b79pNIWrdu0XqcePH7vPfe5zvgFN437lV37F/fzP/7z7qZ/6KfdLv/RL\n", + "7rd/+7eD/EG0aNGiRYsWLdq/i3btF6nXX3/dfelLX9oqv3HjhvujP/qj7/v7pB++VQYEKdkqGhb2\n", + "DH+XHQlJxPqWSvRHL8p/uu3jGeuvCqYddgbdANYDmjVAn5iwR45iXjW9POtOxVpVx6WsghL28Na/\n", + "Xohicse3f1WW9d+Pnez0AilT377rQT1bIex36ItOw5p3aSJQCVdUnGsQi8eV7ZyI8KVK9qNisITJ\n", + "8zNz82W6W0H/NGuRX6Cyu6rYgryskhph95NqG4kcyl0Jt4Aqwttqtor+ERwsldgYNsSSa5B/ldCP\n", + "j3qLm9qjGRuQ7u9MLIfeAqjKgSiWn4x8OPlyboTR2SWJ0tb/AUQRmJQ7zIszQwnu3P+oc865S5DM\n", + "kyMjdldQtCbi5U+H0HghAL/5J/+Xc865GzdvhrIC/bhY22+zIFOhuQuBfkAJPZeAhctLT/I+lLB6\n", + "hkafnFgbctwnRRqnQJg0d16FXIDzpaE/N4BSrZBPcP/ApBFWUDsvRX5gA/J2IejjpvHjP89MOmIO\n", + "lGojoe6LDZTiBU1YQ86hEzmDBHOc6M9SVKd7qo1LTkiHPGlrkamYQr09S+1+9g6yJzLFA9ldiPpV\n", + "NUYbFmiXjesCc1ylNkYjZkqwE19c+PY/F/mDixEQ6am1tdwDcltZn0z2IOdQUv7G6suAicQJYR4p\n", + "Ay5WopiebCNHjMVRJD7HmlFKWVgngBxtZKyTuz9U5waJXdbklCryqqLtSJjekQEh3UZJiCppEtcQ\n", + "WCVrGD8lqpiOZ0cj4y/LSMrWa6EFMnc4xtXrE65REOkXEj3zmg6Qph3eDD53BCXnc0eDzMwTot4p\n", + "oJTBm+LEtsUHQj8NcuiBFC/reZazPYpmWU3CcSp8vsOisnm0aNGiRYsWLdo1Lb5IRYsWLVq0aNGi\n", + "XdNeWNLi3l1xe1GLSAq7K64w5yRpYTc4EB+UbEzytLrA6O5xO76De6jfdvskAvsGCFKwyFAkeGOy\n", + "o+7BpUdi90D3iteXMlZDiKVJjeS6Q9+i/04gU3oetD0km+8i24f2pAqnUrNGXGtUHRYYl1BtuyOR\n", + "5yBBKD5mAlVTFZwJOjXYgB3AhLLOOZfyHkrdKdTbCYk5gZttUCe6gLRP0Da6vXq9h/ic51ZG3mcu\n", + "LtOQeFhI5KYKr+3xbW3ELViD2Fkt/XG375uKdn3iic1dpYRZf2MLIexzXA1JuRhjmd5jVsnKlksq\n", + "Bvv/H77/XvjuNlI7qRtjNvfuqVLcsxu4546Ore6P3vdE9XJsBNgG92wFwrZzzo0KKnVTn00DO/zf\n", + "6dRcm5s1XSHWrzX0vnpVB3dUG5dgi2ZbA+4Ubk6qeU+mRpgmYXspumct2rBZmctysufdaMuluZYy\n", + "kMhLITGvQmJ2W3brpXeRZSPrpxL3bAlttWpsdapbjlebk/XCXzeTcdpAeb1dmlswh1u0lCTEE+hC\n", + "taJivYSbk8nKR9InLdxcuRDgC+p9TawNb73ribmX4pbMkLUhn1v7pxvMsamQfXHv9m/QLSnzD23I\n", + "Jdokm8AFN7E+ObnA3ClEbw/EbtbXOecy6PL1sp6WCIohob8QcnKgfgzWX0YxqRsL7WnELUc3lkzJ\n", + "nOuUjGe6GeuSmkma0BnrqugDpkHbUAOwGOyitcSzYxDk5D+vVpKgGPdY3WdpuF5y5a+wB3bk/VVS\n", + "OrW9+kFQEs4/WPYZ5CPrPk6T7UiGbGusVJhrvGYAgJtV5Q4Lat+l28+dRAMFvreMVESkokWLFi1a\n", + "tGjRrmsvDJHaSl2DN8hmQE721klMPN+gUw0hDclx9PTbyqZER6ic2u0gpyuCFBAxeat2VxRenTNV\n", + "9kxQMr7fa04ivmmHdiXb13LfJ4dQgxxeaaeKuTyJvv3jOyEMEkVJgSYIqBDyOul52V+6+6WsQC9I\n", + "R7fd/eG6ej9JBlcCNncJWTr86yuD3bduB2rsPiVclbIGGtfcUyJdSZm8/4omBkkMIGOiuk0wIS8F\n", + "wcJGuJDdvymbW99V/L7Ylr+oBSWra+SuwuEjQbrG+35HfnFiauMViL+jysZ/gXxyy43l1WqpjqzB\n", + "A1QHlhvfoJ86BAwUkhvu2YmXLnj1Ix8JZW9/5+s4zvpkMfPE4re+9rVQ9uC+VwU/PtyX4zyKowrs\n", + "RGyY12whgRVU+1ZUbQ6l8EyUrZvaIzJTCeHneZ/OTc6ghOzDuBJS+MLX6ejA11NxhjUI8POZEds3\n", + "GyBIIsFPdf5e+N/7+1524dlTU4A/OPbSEsuZSTyk3XZOzhrk9Zt3fIaIrrN2zXrf1l4Iy4FQryTm\n", + "HjIRjaFkM0hMFDOr6AK3sRK18fMzf9wISvCVoGVnZ14u48H9u3YpXlfU/on05RKAwhUiFYS9B++/\n", + "LYXQXUPZut5WbKd0Sq6PLqA/05Epqy+Aqs1bG2sL5C48PJYbhQpkiaiCZ5zPQD91YaPEgbQhiI3v\n", + "CJRS5DTHPc4k2CLDnGwFiW2RyYFIUy1EcKKpu7w0A2I36zmoE705qhTP4/U4rEnSoILBDXzWbTfV\n", + "NZpXDwjzgABvvptQFq4xcEXx+O0gMy6duv4yeGgYgOYtE+SOkj3zpa2Th8gtqvk/DYkTb8b3ERaP\n", + "iFS0aNGiRYsWLdo17cUhUi4ZvEHvlCtIySnafjNUNIlv/QNRM1g38McOUaqB35Ooyo4Xz10SCsku\n", + "nYZWOTLbaA65VjxqmBk72a5vAKmUewQ/t+xSkP7sSv6/fKtBvF62I6+h7Qj6reOVt0Q/uwoCMp/X\n", + "oE5AEdNuu5+UI0XEJMcOphBOyajyO9H1QrKq47oCSLlA7xikScTObcARgo9cNqTkSwUBQ5kRxRh1\n", + "qmQHWVCmQRApiAnmkmsuoFgiNJgGZMvGyWbjPy9ajxycPDf0aa/0SIDmcJshd5aOqwL9NNm34y5O\n", + "/HGrtYT63/Kcp0Z26S04LAzDzzVfJHZkjx5+EEpu3b7nnHPu9MSQnsN9IBeSw20MbtSTRybI+dJL\n", + "Htl6fip9AnRsg7GTCX+FAnsnp49CGTl1N26/FMqC+KjwfD74kHW2ftpAsoMcIOeszzJwflZL428V\n", + "GAzrhZV1yDtXjQ3V4rozklxzS9TlUHhjz555NEdlQsb7/jwbQSmmE49E1msIUm50Xvt6EgVzzrnq\n", + "GDkRhbfTQui1T1XM0bd7LMgNkeOlyETkue+TUenrputvjbmuiOgSl3369rdCWQMh4FGpSA+Ea2VK\n", + "NoAYChEdZm67BThnRaljHfOvs3tNNFkFHDOGy4skBJei5dx+uwdESJfzjogQUI9U5holFHoh2iSU\n", + "9RA4k+K8qfQd0aeRyJQQiEo65W1d4fIp0kKgXbwPvD+K3DJfnqI6DcukoiHvp0g8sJ4DNNvRYwCk\n", + "SelguGzdXz3a8vA551wBNWnN00rOnUpnUCZlmAuXMjnJVruCJJGcg12mMj2XZ5eDujnnXD2G/EWp\n", + "yqWBkGVFA7XtbYuIVLRo0aJFixYt2jUtvkhFixYtWrRo0aJd016c/EHfD8Kq2xAaLGH1gOxzgewI\n", + "4zcDTjJI4SpnsON8ZoQCpT5u2y1ozq5tWQV1rRCK7dy2r3Cn+/BKLifnnEvoslLCeA+ypbrWGKa/\n", + "I4S0k/fiDUN9xS3Fb9nvba8uFg83d+IeCGhmru3ndeUdHCq+6u7soajbirIuyZPJwKUJtxTcDbkq\n", + "hoNYPytERR34cbMWqLUGiVqI2kCnByG8dBs1GhIfUHacTwizKYjiuYRQp+yLXnMY+r9lYXUnVJwq\n", + "1xbuU1U7JqF2BVfFfGHk4Bv73hV3/txcS4EIO+CQs/9VideX7Uv+s03rr5EKTE0XzbymOra5AjMQ\n", + "z1s574cfeLL3Ky+9bBUA2ftQVMG//fVvOOece/DSK6HsyRNPvD6+8WooWy68K7OCrMNeb+fYMIRf\n", + "ZB1WcEWUM5MfqEjKFQL4Bmrfk4m5sajYvNqIAnji3WgzSDK0IqFQ4B4+f2bu1oJh/4kphudQAl9t\n", + "rF8LqIifXxpR/QDBAypTkUCVe28q7jb8pRvl5g3LF1hjzZhdWBvml548m3bbrr2us/vZtZA1sKLQ\n", + "T73M06MbtwffNZd2rcQqF8roCvr9P/yDUDa65dtaicvOIZAjE5kQBq1oTkqucRvM/yYzcjDUCtwo\n", + "s/6nyrvOP9ZpkCkC8295IcR2uMU7IRbnYQ2AXIPMf0oHdJn6sdAuCeLowd7OhewcaAzS1hpzsRjk\n", + "bkXgFc6byrpKV2EmZWRUtM12TkJ9/lDqpJdgFzLpBxIvxTbNhFQG83ppsFMgq4QyBlLlqsAP9fCR\n", + "lDWklMgznu5efT7z2U73ncrf9OgnpfZkIWOGHTdCMIrKHpXImsDx4pxzLdbiLFUOSHTtRYsWLVq0\n", + "aNGi/Z3YiyObp8lO+YFdNpAJoKiZao+FN8xtAvouong4x47vdtZDSfFb17TwSz0h8/gNBNG4EeBF\n", + "lIhOQU5FyUIE64BFPayIkxxjuv0gT1EQHgIhKUis6VjDgHeE0LJB8jbOUOBBNwX5CfttkGlQ6ITt\n", + "kb5jbjWoALjRyMipK4Tkl6WhNPXMn7cVciYr02teK+wwNK8WUUrdfbBreZQSVoMUguw+ExJRZUyW\n", + "I3+SciLEWoRzJ7LT61JfpjudZuXPN4aY4VLIkWenHv2RU7iLM4+c5JmiX35XtR4Z1FA1vkzF58oR\n", + "+loIuMvZqa8nx5+G/GLs6JCYIhT+5NRQmpfveAL6c5FpeOP1j/k2C/rF7PAh56NzLgehnkjvoRCh\n", + "33/fI1j7En6/mTM3n6EK+7c8YtNIWDODMlSQ9fzC1+/WvXuhLAWh/Xy2RJsF1Vkh2EFyuB3f9/kE\n", + "CyGMUx5gs7R+ZUh6JcdR9kDFFJeNr3Ou+QQpU4H7vqztvFyyUwkKGGMeLwXNZPsHedUgK9AI6kjU\n", + "aTQS1AvIRo0ABKJbzjk33vdt7QS523/ZI1jffPftUEbFglyI8uTTJ4PljETtXeHvFFC275YNxF9H\n", + "KmvDoBgrq0BsziT/pUOd1ys7bg5ke1/Q7BoBGBXQx0QiWxh2vxJyNlGnQhdv1DmXuZ6hTgpuYDkZ\n", + "PAvt2caFbfCwwx+RVUg5r23tYDBQqygl7oUKdxIdzwSJT9JtfIWBRBSuHSBCDF6SuZYG9F3uCfpz\n", + "8IRhOwaDgh4THRNDknky6GqUqZg0BZ7lvo6O/RjPcn1PYPCUnS+Hd0YcNu77YU4RkYoWLVq0aNGi\n", + "RbumxRepaNGiRYsWLVq0a9oL1JG64nbb6VLzf5TmRSgwVwVyFxhw9lNqIOlx7ZAwNjzv/7d6EkYc\n", + "eNFauoyU7E73odZz+NsBsdttKxwT9u52uPb0uEAG3qHjoe7DIGgLf08jUGyR0mUgVwo6VlZGN1M2\n", + "yEnH84kWCXRUBmRz/ESJjeE7uqrkvKOJ17EZV+ayWBfePdLVio+jrwXGJaSbi29L3TxWeaoY87fS\n", + "ruBjULI/PutYC0kE5bzlUHfFXwqkSM2dBVJk0cAFIYRl5rBbrsy1s0L+Nc2/SLdYJq7NkmrL4qpL\n", + "MUAODo2oS7J7CzVtnQctCNNKBCbsXYkS8CkI1S+9/FooW0AxfCJ6S5PJAdpl97OBi7aF6vDekeXV\n", + "27vhlcBL8c6QWNyKFpbbQTZnTjzVQFrC9bZamquqh1t2BlflWLSgNrjXqm3Wdf5zI+6WAkrpmZLi\n", + "cZ96VaWGr2AjufvG+76984WpnTvnP+eVr281umXXAilf71OHca2unZ7uucbK6NpSd98cWk1lZf2e\n", + "YfDQe6ok6smeHzuJEIYLqMI7dXfCpZ6JBhS12gZ5Snlq5WqQPoA26rLd4beX6/NQVvZQpZd7UpWc\n", + "/7Imr0lAt+NmM7qstnWhkg3bIMFOmGOF3ACuhdkgKGnQFP85Ya47KzPSuAQZdcP1uVXXXjixPLpD\n", + "AJToQzHYZ5B/j+uPjb8Urrpu4Mdie3UtpLYT8v8N3H/Jlb/mDlUKQpJt57/lbwb9RDeeuMBD3lc3\n", + "fIb7WtK1p+cljUA0wAIBfRBltvXb0MVKn/neXPOISEWLFi1atGjRol3XXhgilaTJUPU7vPEKSkMe\n", + "miICPF52BPx+EK4JJKDbiUIMrzmwgZoqDxzEYTrnrqQGYkjsIE8edsQaEuooXcDjZLeE0M1UNx/Y\n", + "QQwUy5PtsNaUpOBWd3/+L0nfvs4g1mEXkkkOOar3KmGPO8FU3tZJItT+Z16lXpALdkVdq2Iu+852\n", + "swlUfgM5X3NTgRRYlDZMi2Jb/oKRsyorQJJ5OthpUBVeiKLsO0cldN2t8L7qxa6w050qutvun7ne\n", + "ZEPmktSjHa3IL8wXfmc9Kz0ioDvtdOaP69dKACeJ1NS5c8gtTwSRmxyCFCwK0BuobddCHuYUIMFZ\n", + "d2vjyqtyV6UhWATYMiGRtggK+PADU0A/gtr2RuSOb1bICbiyOq02Hn0Z4RYvFtauV172+fouZ1Z2\n", + "vnzfn2Nh/TTKvGL6xcb6lUjbuDKiusMO9+DYJBbe+c47+IFHZsb79l2G0PhENCymB/4+7Qty9sFD\n", + "r1heZDauSqI6a6s7d/NlZf25XiEoQaX6cVPyMSRBJDiC6uy9zKtnj6AyL+OUIe6KyKWQ7Ggkr1sK\n", + "+YUk216niFyPRJ2d46QTpPUS5PXDe4acHc6BXAlKvd4Q9ZT5lHGdFAI00YSQ106UsPF3mYokA9YT\n", + "iaB3TKe4v7bCGc6nCCvrVItMQ0G0F+T8ShC5DHMsKVRqAoiQLAokoKsXJMjNKLrRbq/nfWg2kEaR\n", + "NQgPHpXJaSgXIGsnif3yiK9bBgDJ9SHT0CjZuqN3QhG2ISKkzzoG7ySJJuxDddVLwEAdechxnVbE\n", + "h48xlY7gM9PeBTRQa0egFHPyytxJdzw7TYpo250TpE6czInvYhGRihYtWrRo0aJFu6bFF6lo0aJF\n", + "ixYtWrRr2osjmydJcF05J245JaIFDE5de9tMMDtKiN27lM2vvjbuOIe68Xa5EXf81GxwXLJVpyQQ\n", + "yndpNm1fq293uBEB3yc7fpuqAjzVYcW3RFJ8Tbi5ViI8tai0LkyeKf3UM/GoEAHpbhokEvYwby2Y\n", + "cVDFTQQyvXKPdyWD1uSZo4l3s7Qrc081TFDs1BJ3tZBjJ5OB0BJH5uGNQOYkqioBu6UrRoiYxZVz\n", + "OXMpqsskJNduxLUCd9DDi8fOOeceHN4N3x2k3j3SOIP2R3DLMrGs/wx9Kklu3ELFWt3CdBGsRG9p\n", + "DVdRBYVzJfbS3dn2RoRm3ccjc21N4Q47PbVExqPRFHUz1xoT+WrCW86Z5QVca1Nzo9HFUVXWruND\n", + "72a6PHsWymYg4w8Tmfq6L5eSoHjq67yWsbO+8Od56Y1POOecOzi6Eb7LMGBv3b1tdcKadfLcXIv7\n", + "SNpcr0xtfQXyuLqsqsq7O1cbI9tzDUhk4h0f30XdEUQgOmp56vvzQgjzUxDWFzO7T4FSIG7kNca2\n", + "JpLlepvKOkE3xhQk8nJi93CCezc5tn762gfv+vP31tdUuW/WVidqqnXCtq6DT0czKqBPgoySyviD\n", + "sC/XGmOeFKqFhN/ujWxMNPh+LfOUwROtXKPFGsuMGcIEcFnKIBJV1sbfQTJgzDtpawc3WqqBQs13\n", + "X2M3Ld1u4kaje0oI41x3Wlm7EquUnZdZMVQrjkmId6yTiYogJnTpkQphnRKIKvJ85Xn12RWU59W1\n", + "F5IFy5q4ortPokyumKrYM6Cp1X6iinyhrzik1lgJ+y6RbPVcuweJ6b9XNJqLiFS0aNGiRYsWLdq1\n", + "7YUhUl3fD4jA9ja9A/0ZqC0z546ejF8q+mO/vvpp11HJ9uFGxB0QlnGAvmpTFVrz31FtdSBBvk0U\n", + "tEttE+aDiq3mdSLpbxCSjzd4JcThrT/dQQAnOTqrhYgIsmsiO7MM6sm5vP2z/1VWIiFKJu/lDL/V\n", + "3WdT8xpGNg4K9DxO0CeS51VCIAeJO1cpWm7OdKdXk2xuh4WcgK3eJ+xSOkpNyOE470aIvbzHqtie\n", + "IDdVLcTqNWQMRqqAz/PKvWsR/83cXRvZaS4WHmmZSvz/auV34szb5pxzI6iBtxLqXuP6qjTRLlCW\n", + "G+pDhJOAxP6BKVxTWf1gz9CnMfJVUf3ZOecuZ/7z7duGpu3veUQiLQ1N4vCoZxK6jn68xP1XYu14\n", + "5Nu9PDVUowQ6VZaKapHsauN5tvCo2ygzNOXBy17R/N13vhXKplPfj3fu+LqTYO6cc+vnJ8455w4P\n", + "jGzNKVzI9WdnXjpBkT7Ws5rafZqde1X6THbkmw0DKkx24Ry58yhxMdmze3KBHIP7h4YIrUnel2WC\n", + "aMblXFTRgTArAZjrycWl1f3B0T2cjgiuoAVo/6Wsf2++/WVf78YQOWYqmEj7exB/N6J23jFAQNCP\n", + "HAEPHYnISuIG6lMr+oMgj1LIwSXm1XQiKvJAOpZzDSjydWkGyzSQM9SpGZDIgcgI+uN2kZjR/7r+\n", + "ZXiO6fJP5L5vFc7xdV5hPg9yrXKZ1McEg61UsZx1Gkgy8NmhDzle146rsQb1op5PaQfLCiHrL6Ur\n", + "BNUkKb0Q9JkZILJcyeaUqbA1KYdMQt/IHL+KBEqfMLCkyO34aqRJTlkn/hWkiZ4rkfNgnTQoSZHt\n", + "XRYRqWjRokWLFi1atGtafJGKFi1atGjRokW7pr1YZfNdhGnVVgqZd7cVw1X2wRIUK2GPJDLRsUiG\n", + "EKi+RXZBd2KbYNb3Ss7bVnENv021nrvcd9/dWN+BjFGyrQ+SFYCim8GBg3M4Z64qdYFS5ZukSOGh\n", + "Bvdpniuxk3CuXB/wrfY/21rvSOTZyoHUwFGvXAVXCu97LZUyd6/qWDFppti2tIjL4KIUL2JIQllv\n", + "FJbvBz/NCzvzmr49GRNsT9+rPpavU7Mnrr0l3ZJSd5D7OyH5Z64YXD8ZyKOD9CqQ+TE0fRTap96M\n", + "kl2ZyHizMdcOoWodJyVdWdTMau1ad27fd845VwvETd2hQ3EtHh5619+Txw9DWQ33zQ/9+E+EsgsQ\n", + "ylezi1C2QELgA5CTO3E7UUX6SHSfzp97raqm3lYiLsUtF3inokpOhfLLS3Mt3nrjU84558bQbErF\n", + "jb2BK0zd8z00dhZLIXa3fpDtHZoLsMb8vDyztvY4biODcn/iiezdYET7zzdv3UT77Pp7e95l2LR2\n", + "jtMzn3j67n1zrZ489+5G1dGhRtp8ZmNiD7pYo8raPb/wdZ4c+3t8IO2aYH58/dzI/u+tfJBBL96U\n", + "Setdqkx87JxzGd086kfLSdUQzSAG5fB/oSdkPfTZ7AwhoCKtJBk2urMUsvn0ACr2ostm3SOuQuhC\n", + "FQXXJrsaKQuFjJMMg03F2YN+mtSdQT4qGVajLuIpdx014sL6b9eiAnurNBY+a+Q5Rc0qXWupY6YE\n", + "7EDoH1BgGKgkrlK42an7pGsN1cs1i8QEyeclTsQVlT+vjrUESZ21nuMJNSAl4fOVJORaX94nTRDO\n", + "Z6ZKALLOOid4H9NBwmNvGmQwkoCLXRYRqWjRokWLFi1atGvai0Ok2k5TmIU3405eTbfJ4foGvYNO\n", + "Ltt0koj1TdfOlAz+c87eSNNBDCfeflWBnaRI2SUMQ/av1FNRIpLHA9Klar7bCCxA7ycAACAASURB\n", + "VBJDSDVauee2R8iZ3OBpuiRKIWS6I0X/BJBOVXdDu6T/SUQWlMbCtaVOgUUthVRAlyHWksS40u0X\n", + "yOtoqxKmSaxuBur0vL6S7aldIGRzoo6d7Ag3HBOy++B9SrYVlkNsgJJjQ2OFMIwcXquFjJMKoc4y\n", + "TjL2v6go97gHVeERkaN9U4ceg4Ccyn0yqQkJP2buPhlrVFTu5bcFdo7cLfr2DPMJqlwFB8qRENCJ\n", + "TuVCgF+DjH/r7oNQ9vTxh8455549NUmEmzc9wnX2dBu57QOqbOfNQ75GQcQwnj/5qR8JZfO1R1hU\n", + "sb0qvfzCbVHbLlDnVEjJhwjjz0GKL2WsX2QYr43Vl6hWc2nXKie+fyrp18XpBc5nZQn7TFXBzz1B\n", + "OxHUc7LnZQdOLzzSNBpb/29AHs86G0NHQI7G+3ItdHsva+JsBkJ5I9Ihjf9NvRGZgNZ/X+75HX5x\n", + "IHn4Ej8/FyePQ9kScg6alYAoTipIU83FWNpKIvsgKIfn6IiMaP9jTZQxUWDel4KcF4hAaYTYTC6y\n", + "kp0zoDONBADUIKpnVEKX6+fMdZrqnPSmLQhL+yDXqS9sBBFvkdBwU+uzAGsRUG/NIkCVe1Vnbzn/\n", + "pZ6OdddnYkpJIMHzuJ7LcRzHmpWhgEwBgTiVsCHSqUFJRM6SXLI9lNvPEz5uFTna6c1hnlb8QI8p\n", + "QBTXRze9T4neV+bEzRWRZ53lPjF3qWbZSL73q1JEpKJFixYtWrRo0a5p8UUqWrRo0aJFixbtmvbC\n", + "XHu9S4auiG1kN8B3uxRGOyG2EUcdqLPiNwoZd3hvpGZRn+xwWe3wI2aq+ktIURI07iIKW5lAsMGN\n", + "gmv1+h6L80lRBqg2zQc+M1RtWzG8E3IcYdS8EB0TJtrsqZ0ksPt62xUFhDu4yXwbtsn+JIqKpzJA\n", + "+4o2Zzh3o2rLULumAntdGzl1ufEuhlQalgLGV7I1PQZKSqWbr1FiK0je7QAWxm+Da0kVi3liKaOb\n", + "UcZkDd7xqtpOxpmJv7UApF2koo+CKZigbmVipMYSmVcLSXxLnaVMyZZIkNsIiZbaO6qFsisAY2/i\n", + "3ULUu0mEiEqtplYIw/cevOKcG6qNc04qKbzBAHn722+HMiYfrkRbZgNXLr29B8fT8F3LZKwSANH2\n", + "vn6zlZG9STbWJOgV3GiXQmzPQZ69f/8Va/+RrzNdPEshkc+W3u1WZdauy9mZb+uRudv61PfFam46\n", + "SpOpLwvuNGd6a5uV9edoCnejuEqYNYBuRPXZB/22RNTuoZW0XJgC+vzCt2M+F2VxuNbHE3HtQlOt\n", + "Wcn54CJcnHtS/kRce+XY1/PJ238RygJ5uZfHSQq3qCZSZhJ0WWSpFTWkNMB90zPYQlx7nIs71m49\n", + "b0igK+ukufE1CTLVtu36TDxQw32vc43J3VtxxXHtGq7nvJi4sdHFqi3FpSgdUBUYAEO6iRLxqe0l\n", + "7rGMzwRZu7lAKu0ELttB9gqse+XI5uQYGRIkV7yjzFIJjadCEznjsyrmZ0ExXe/JDtwGibQ12IDr\n", + "uQYeqTv8qtWYH1onjiGlhXCc9JrwOfBR9DmNeyzPnUEQ1g6LiFS0aNGiRYsWLdo17cUhUn3iBpRl\n", + "vi3KMUSCBsRm/E0l1jQQVuXtm/nUWqdvpFfI5gNUZZsySAK6vkinQQFbdgQJd1UaQrktyRC+77av\n", + "RYRJCat9wrxugiqRlC1v1eST14LwkVBZlEKYK5inCSrajeofQLFXk62l2zkBgwKv7LRC6Kgid9gl\n", + "ZBJCOxp7tGUj92mx8LukFnIBrdSpAYlZyYEk22v+qX5DJVwlUfprNBq8wJx8iRLgcZ4SocEqfwG4\n", + "ar3W9nMHK+TcFUKYDXxwCVFSGX8NiI1tZjudo30fWv7SyP+9d3QzfNcBiVJiOT9PD0wJm7uuXHaE\n", + "m5b9r0RdkIfLbZmAgP4qWod8eeN9U9HegMRaltbXC6AZq7URyx/cf8kfV5lMwle+9pZzzrnDA1FW\n", + "x98U4yQv7LuGyvYy13NIHBzsWZ2ePfLE9pXkn6sQrn3r2CQBNo3vz0MJ52fwQOhDGa9F6ZEo3emP\n", + "c98nZWrHzTCfqpHdkycPfZ00JHsJUryOiSyd4vp2j2v258rDAGUpUhto/3hqyF299khU3Vr7Ly+8\n", + "KruiWSuoveeVEfBz7LpbUdTPMuRJZFh7Ze1KkddP898t0K+qSs953ApMTRKvBhRx7VT1cgZ8MFND\n", + "UiuqgVyTzvo1w7o6eCZQnmQQ0LQdlEK1DVH9sDp1zDUpCBrO0UgZwLdBoFLa+/u0lmwHDKzpWi2j\n", + "N2U7YGmMeToIGCLQ1Olzip+sbIR5pKgO54R6glLkHxyNrT8n5bacAUF0qvIP2sqgKEW/GhLLDenq\n", + "gI43Ih2TZxXOKwEIISeprHtXnkWDZxLq1EmwAdXRu97az/vZSbqHhrkO5bj+yvH+8w6XmVhEpKJF\n", + "ixYtWrRo0a5p8UUqWrRo0aJFixbtmvbikha3/SDxa78TiiXpUMjGIAcq0BYSBGuC2ADFaYJOamZQ\n", + "i2LbjadupIyquzsS6bYCzzYCC9r5diSyBLRNwFBdi1RlZqJW51xIVtxokl1yLaVddbMNDydoRymu\n", + "PXotOsDyq5W48aAYrJAxyY5a1oAcPNACgQtAFWPpMqqKbdfSuDQYebPxCszLmSfFtjsSBCei+0LC\n", + "rroi2P1KAA16U4OtAl3F2wRYdtN4LBAz+ivJtpOBruZ2fWpl1TNxAcBlogT8ch/XrOwaq8S3++jw\n", + "NX8uIaKuVt4V0yxNiXs89idZCzl4Hyrj54vTUNbyBohbKhDEZdzxntXUkapVx8u7ig5HRoA/OvYk\n", + "64szu9azJ96NdXZqatdfx318+fUfCmUf/dhHnXPO/R9/+Aeh7Md+9DO+Sgm0YMZ2rTWDDYQwWoEU\n", + "uxTC9s1j7w599OF7oWyyNxm22Tm3rr0LjGRa5+x+buBGrSR5agISeSeBJSO4KtVlfRvX+vDdb4ey\n", + "PZDNz05PQlmDgJJDSUJc19TlEpI/hsdq4evUiRtrhHVClc3HCBjYXIi2ElwqF3J9/jYRHa3ZpSfP\n", + "371r7r4EY+LOPSYvligWfFeJPtbs0vfrem11WtAtrZkKmKBXz8dFUKJHGri7WsyFTOa6Y7JoGcOk\n", + "OwwT+eIwjT/Z4UYM+e41Cbyx4n19ZP3NSQsZJEegivYuCoQdF7JyyG9DpgiZ9ylcVCXWSw0AYsNa\n", + "eSZy3afWk3PO5Sm1kOyndC1mIyF2s9m5PgvQ70Jyp1ZXklY4v5y259+BjLo/lXRUFhIPi6uSwVOd\n", + "ukURZCWL92ozVLvX9Z/P87XQPUrMp9RtPxOa1gIwsppkd9EgKxg8pZqK7ntaRKSiRYsWLVq0aNGu\n", + "aS8MkUqSK8reIfzcrHfbSEtvewg7V/is4d80CYlMSEoHYS3TXYD/O1JEAuTdVvLatTuuT56c5usJ\n", + "REnNycfQffxANxoQVnZ52UoZ83rZcS12c6mG1Vf+GuvB3cTbv4bkZ0OEKc2NCBh2i72U4f7kA2J5\n", + "P/jrnPTrICTfn6eSsFESGpVrWXeevLpEzrVapejRdalIOHSoJ9VsnXNuE9AfhVpCrPNWkZbxHoym\n", + "vvPGBxpC69s12jPC9OVzkPidXZ/oVLuyuhNh6EXEvZ35+uVCwHywx9x5vo+Xos7NcVXKfSKhXAnz\n", + "z596VK8YkCi35SwCUVdyXTH/YcKQe2dIQ7309+RSZtM73/qWc865k+eGdHz44SN/3NJyuOXY6n7r\n", + "PSOg//S//w+dc8597GM/Gsref+Tr/tIDjyptZK6X2NWPBK0hYXt/avfk9InP8Xd8w5CeENcha8zN\n", + "G56gTqTNOSP+jg48EraY206fyMh6ZVEEJQj4N25aUADJ3geSj+vRc9/u0UjG/9TXL0sNYaIiyWJh\n", + "fZcC7aWK9SCH52Z7rq2cv/7F6Vkoy4AEH960fhqPPHl+pmjeLd8nG9nNHwBhKyd+3K1nhj6Wt3wQ\n", + "wfu45845t7i8QBtEpmPt+3gjfU0pmlzWSYf1ocvsOAaFUM6kFbV9Bo9U6iVgrj1BMNh3mbgEcsDO\n", + "qYT6U+IlHz54/B9K7ajaP54nGmzEjAXqpXA94X9bADoqpmtAS8eAIiHgBzCLgU0KawEtUvkfSiKo\n", + "sjtQx2Fggz9xPtasBL5+a1moEkpirA31KXM/tkc5UFqF1ZjXT6UekA0g1XQXVJGX7BUZ77EgrOuN\n", + "76flytpzBhkP9onmcHRBJkKfU0DfJACna6mUb/1ZYi2uZEyUIf+jBnltBwOoRUQqWrRo0aJFixbt\n", + "mvbicu25ZMAf4kv3ANXB23eSKfp05QfOhe2nyh/09OnuEEkL4a3iv2XocjVWlAy7D0FE1kt+lh0J\n", + "/dyCEuU5Q11lR8Do27CrsbfwETgVxVh2ASPwNwZ8IIbwC+bWISN6LtwDCj0O3qqxcwrZvW1Xx5xY\n", + "A94YWyooQcj+7SSsFEemmZWNx+hPQY4mU7+rUXGzEruUNXb1z0/tHMu536UqqkYxvUL2AOUeuE9L\n", + "FQ7lzl3FXP1fFVil6tz4JkLN94V7glx3bW3n2ABVSgc5BBEmLTvXPUCMeSloEnaixxNDTvZzjxKU\n", + "4Nwsa+NDZeBBjYSPwrovRGixQ+r4RtEv1IXjyjkRbhWRRMptcJyuVjLWoZK5kNxgF9glvvvYUJqv\n", + "v+2FKBdLg04J4j5YWp/M//jfOOec+9mf/Q9C2Xfeft8559y9B75dz58bqvIqEKSLpZUdgw+kpIUU\n", + "6MtmY2Pn8ABipsIboUjv3rHxgfb3/XEd5vrJuaEvNeZCLetKBX7VRub6euPvxfmzp6FsegBRQ5FJ\n", + "2JAjI2OS4yPfGCJTVNi5t9uIGPk4uvteYu6UA/QLvLkTXWT9tbrWREonBx5ZU93a0dSPe3JOko2K\n", + "D9eoo42rDZDI5cwGYAskqt5IrjUioTInAuosc7KHFEQC9L0XAdsa47TVNQmIaSq8tbDuq5hpuo3m\n", + "8LOiFH2oCua6IEghhF67td1GP+ogZ6EyPbh3bgdHSNdz5tNjnrhB5P0unhXOJWMiJw+z1WccUGfr\n", + "piBmmQmaRgQsl3vSBumYbaHRBvIwtfBbG3CacuHoUhB0PBY0tfdrR99YPWcbf+7zczvf2WzYn/pM\n", + "yoHwltL/SyBWs5Wtp5xPKolQYf0nCuucc9UIkgzC7x08M3ZYRKSiRYsWLVq0aNGuafFFKlq0aNGi\n", + "RYsW7Zr2YnPtXSlx7oqCaDL4812tC24c/Sl1AoTsFnyJIN0pOQ8Ez7EovPIUbWvvmy2g5W6jZG8o\n", + "Vg/yL1GSQcm+/i/dHhotWk6Y80hcVqhKLqS7eltpwWUIzxcvmkHmSlSFBC/JdCtBKzv0U66hqYBv\n", + "B+rs+E2mBHCS0gd5AtGf4loawS1SCbY8haum7uAK6I1EuO7h0qj0PsGNl0pIPFDfSvqOObS6gSz9\n", + "UMXaOeeqqT9ufOy/OzgUIjCmx+pSJBxK3mNxmcJ7sXewH8rG1RjHGwG5g6L5sxNzH/VwgbQg2+c3\n", + "ze10q0KONyHWruDGUXJyizIN3jg89L9dKSkTLuJqo6RcuGVxT/Lc7tey8XX/4Im5gr6K3HmlkL0/\n", + "8iOfds45d3lpdXr/0bvOOecenls/PXnmSeF9/v+Esk//8Md9GeZfNbK8bhtMwNXK3EMQAnep9H+O\n", + "QTkV6QTOrVxC/TO4lFTZnNIlPfLE5YWd4/LCuxRHItdRQAqiHhBm/fUPxWXYIT9mosRyuBYWc3PV\n", + "bUDKnojEBKMiOoz/XnJ+bRp/L1QJegTl8URdYAhaOJAxefLMj4WJzEkS6m/cMqV4ho4HcrK0v4ar\n", + "5N0PTOphPffnqBdCGIerptM1kefRWHJQDzJ9FCVQgGcbxRXHwJJOgojCdE53uOzk+pxGGqjSY+1M\n", + "i+11Inj0BhI2OL/0P581bS1uxNZff6OyBgw2Ut0b9EUmi2fOBKB8/skDkHln1bXHnHCqYt6PKKEg\n", + "P8ZY7+R5VjBThqyJzFmotBh+buHmH+SGxPlU7b3F/NBcpwkmpRLQmXazblXiiEEWQtUJbjmsV9L/\n", + "G7gUlYLBc0xyW08u4SJfSwaEtkSgkEgiVEtf91TuSTbQkdi2iEhFixYtWrRo0aJd014c2bzv3YA6\n", + "zlf9Qbbo3g4NZYECHcr44qohmSFfjqIpV3YYqSJSlX8LzSUzPXcwrZBzlzUFxJSUvUP8k+RBuQZ3\n", + "MT1JsYKWZAVIf4WQLnN/XCaSDMxJVyqJMSfZe7vvOkHkSIYkiXA0ltvPN34hFge1NnkbT0tuybZz\n", + "2DW1oR8NdklKLK+C6KjtvnMgIbc6hNqvL8N3M/fYX1N2nySWak487laKsYqP+rZtJE8exQTbVrKU\n", + "g/g4OfC/VfmLBDvMXHZ1+Rg7ONlVEqSa7BthcTL20MlIRErTwn9fJ4bcHB95dOQYueNakTXYgDCe\n", + "pbaDaoA0bKSvmZPRya5yA/LyYmn9WQPNmKbW/wy7Jul5b//l8N2tex4t+sZ7XwllBUL4byGXnnPO\n", + "3QAp/KOf+Aeh7F/89//COefcLP0wlC0vfT/+zVtvh7I3Pu5FOhMgM5/+hAl4Pn3+gW+/rAmUFell\n", + "B8t51Qlh9eZdX89c0M8gHCsocbnn0ZlmjXmfW792yVCY0jnnFhhPeq/XGCeHL3/UyigZIDvnFsTr\n", + "9VJQQgohym6eqPDhoUf9lgtDsLg+KIKTI2BjKvILFFp99wMTSS3HlHOx9k/3ffsnE1v3OCaIqvYi\n", + "4Hj+3Lfr5NzG1Xx2jjZrYI1v93RqiMAR2qNikhSkVeCYMiYt11MJzW9I2Be0JAgHyzOBihm6Tqxr\n", + "ilTacQ1J5pp/j+tpkFCxurmQ92/bTzLQo8Tc7QX9CcNYBF53Ecq5njrKlei6zurq+o9r1BIAVDdE\n", + "pFTiB6LLqu/ZbQuMtnjglnLdFCLOWcM5tI3INfL85bq/XFun1GvmfxWyN0RHlSifoh1K7242RIz8\n", + "vOtVEgnPGkUVMyLR0q6bR36dmk5sTJ5d+vE8kD3BOiKqM64sIiIVLVq0aNGiRYv2d2LxRSpatGjR\n", + "okWLFu2a9sJce2nWuqYW6DDdzoOWBM0I+10SNKNE94NK5YOEOIAgBTIkZMzzleJGKyoQDAfK4syD\n", + "JK69BUnM2yrWreCjLaBnJanx2xyYYdKqOivgTNFCISlR8+9tUM9uo9BqjzZIR6GthahCZ+B6puin\n", + "SvmtgHHXF+pu9W2k1pP/TLK3tbWBq3K5lBxGGUjkewaZloBbNa9YVYIoDLj1+NgUo8/W0PgRtW/m\n", + "pMpKhYJ9f473xN02gd7SSkiJDTRwRhJQwOPH3n2gavddTdeqkXNLQNW1YMYjagGJPsseXCbjyq7V\n", + "w1VwLq6aVevdfA0VkNNtzSglxzd094muyQrq5Jlg9heX3t3SdtZ3NfSA1ksju4/h2joc+/t1//VP\n", + "hu8uEw+Fn0v+vYNb/v68/Z33Q1k58e7Jlz9yP5R9831PNt/Mjaj+o5/2rq/vvPVWKHv40Cukf+be\n", + "K84555Zrqy/Vy9eSa5BabfXaxtUaed0Oj0yfi+6+MZTInXNBvjpXtxyV3OGyLid2vz71Qz/inHNu\n", + "fm46VrOZd2nNz6xd470S35mK+/G+7xMlBRcTf9xIlO0XPJ/MnQ3GO5cuXUNSupun1q7JnieUj8bW\n", + "rhKk+dffsOM+eM/rXCXibjo69N+3osBNraoSC8To4Ch899Zf/rlzzrlnTx+Hsgp92HZC2AVFYiLk\n", + "/RHUsSuZfxc1+s5JAAbWTrIn0k7WH6xT6vZhXjkV+2a+wLywG5BS20iDcuBaHZCJA6UE46Xfds/p\n", + "s6YhBUJz7ZGon6rPkq5KqWia6B//mfQFuic1D2FLWoiegmR3ef40DHbQYCdmgNDsEb4zWn10wlWm\n", + "NAMGZSzRAZUQscvM39dpImvd2s/ZVW/aclR+bxpz7W2wxnaJlVGOT/XWqIE4n/v1MpMMDBPonk0r\n", + "G+uk3lSVurt9X9we2W8fHN9xzjn36MTG8xkCKjLpuzSJrr1o0aJFixYtWrS/E3thiNTe3shdXqg6\n", + "trdkQDanhMBA2nXrOIbnp5p/qSdytZ22OcHuQ164yUN2WWnXYoh/LyxCKuCqYnUgCg52Fdv1TK/q\n", + "OQjpkzuiXEhtCdAp3S0x/H6tGcnRP3UhIazh+oLS4HxFHrZ61gTUqRXCdocQ3kLJ1jl3UEqiB3Ii\n", + "ytIXp353euNAQk2h5J5JiD03aVTYLiuDdaiOvhKyNcmjuSB3JfpkJDmkChBk84mVrZZAmEq7PkNy\n", + "meMwl/5qsPtVcmwLkn1X2A6eea1UMXi6B/kDGZMNfrsn7Q9kWPRxoeO/Z84ruxbRik7UpgtcWHd6\n", + "K+Q9KzJF/zyy0LSaO86jPkdAhNKphcGffjjDNe1at2955PDhE0Ok/uyv/q1zzrn/5Q/+VSibXfhd\n", + "nSpbn0Ee4aWPfDyUPTlFSPLc71zHgqrUaPdMELy7xx71SuWelKlHZJQQOoF6fF0bSpKjrUlhyFUO\n", + "bKPufb/evWuo2le++BfOOefee+edULZc+HYtLuW82Oke3bAd8Ruf8mjW7VsmiUACeC8IQ9lhjNeS\n", + "UBP5Ljl3M5HQaDacQxIuHyAWGztrBBvo+vPyq7f9teaSE6+B2vTI+j2sCkQ9WxtXHz729/0TL71m\n", + "ZTN/vq+dG9I4qXBPBP4pMRfGgnBvnG/bqrEAjBLQeQdlc0WaUsyJdkBsRr9KUFBohUb/Ax0q5IRU\n", + "u88yfRTieYJnR9Jvz8l++5EkgVDyLFKgix6WTtb9dPsR3AEeSlOSs+34HM+Mjahzsy4bCcCoG/bT\n", + "dg6/QZ2vyBo459wSMhaNoHkHB358ME9oIg0Ln6RfKwT0TKXuK9yzVurOB0/vhICPfk8HhH4GNJFt\n", + "Lyglxngp/T8BYptLZoEK4yodZCVBYMdLRkD/4NSP8dOFBGp8nzeliEhFixYtWrRo0aJd0+KLVLRo\n", + "0aJFixYt2jXthbn2RuNyoAUyB9ys5PAkJTlcFFMD7Kdka8KDohmVbP+WkC1JfIUkVKTLLs0keWRO\n", + "96DqPfmyWojyJdx8qm3DBKpDfRTWggRHYXsTxlYl2uDa1GSUTPIrSrAJNahExwXQcppbn9AFNap8\n", + "3VT3g7obnTPYP+3Gg++ccy4HFJpJX1PvpWmsnrMTTyK+JUrd1DSaiCo2BUxIIg6JTZ1zI7hims6I\n", + "vUF3pJMggpwq6kZ2JNm1FFI+3Vyp9DuVoktA0Jm4MRK4T9a9uRYzuB4LIXZn+K2SzSnBohpIlH7v\n", + "RMcopwJy6102q9RcHBuqswsBO7gW9Ly4FZ0oYNOlvRK3YANi58v3jdB//95HnHPO3XvNk8y73Prw\n", + "/NQTxo9umLtvCZL1SgjoLYidJ8+MsMlp/E/+s18IZb/2Tz/vnHPut/75b4WyJ2fv+eOpsC4uuwzz\n", + "OpEAENeAxDy1zl6c+3YtRFk7hz7YnpDHkwkTk5sLLm3oMvD99d63vh6++/Lffs2fK7Ux/OEzf/xy\n", + "afU8QDDIRrIdnJ3838455/7Bz/xoKHv11U/4a/XbCa81yIYJpDlyxxNTJ18VfnwUos/GT5u1zd0c\n", + "86gQNzbHSX5o82+N8aFrDBPUTo+8u6NfmGbUzSNfl6IQwvjck9iP9oyUTkXzfE91+eBaE3dPiVaW\n", + "Mp/GHVx7dNnIGtbCBdq2QjcPbk65Vgj8EWoHM2D0uk7CtTd4nvB4UED0EcL1asDOBt1AHqcc/4kk\n", + "ks+obN5tP5OUPs+gqCzfTvxLBXBFQNZYO1qhsdRBWk6eXXRjynOCGl2ZdhOCqxailD6dog5wnw9V\n", + "tNiv1taqoDq5qOKv52ifuCV5z6Sepvxu5yMBnpqBibhii6DLZWtSDzL6wYES0KEZJ8E7THSsGmR3\n", + "QEAvxbW52FgwxC6LiFS0aNGiRYsWLdo17YUhUkWZu33ZVSUg4i4Wgghg565IU0BpBmcjciO7um6b\n", + "bEiZAL7h843fOVNiHaAKqJNKLYwgiSAv3y7LSQoVsjN2Xaq2TrRtsdjgux3nyO2WJBZrG8oqsN5W\n", + "glwlPSUJRM4BO4JcdnMdkJWOZHuVf8Bb/VSGRBnIeduk+ESkHrirVcLiCpvYcwkTn839bna6J6gX\n", + "4n65wVNyPK8xLo0IWzToYyFpFiBAjlVWYezLNoWQGNe4J0Ie5a6XpGMn8gdERKVbXYJ8hdVEyrBz\n", + "KTJFn4A0DJTNcZwQhY+BjqUghy5a21WN8bnrtQ2+bDKxnRZJ5o0oe2vKStrdB/fQBisrRiSREgXQ\n", + "tm5HUcyQh+ryYiEH+jZqUALH/bvvm7L562+86pxz7uj27VB29tSjXkQ9B8gAlJgHAQBcCySHF+s+\n", + "klx7+1Ax7lZGCp+OPGLSjwyR6TFQK6DK3/zGe+G795/5a1x0T0PZ4U2P5o1v2jkuZh4leXpuffIA\n", + "6Ne3v2qk/GrkJRH294RQj3aUI1Wb93+JVm1koaBifiO5/pbIBrC3p/IP2OnrzWZQiqCUlB+pGxtj\n", + "h1DbryCr8ESQxq+87VG6tz98N5SR0Hs4seufQdm9LHVNygZ/nXOuIiLVGpq0BrJNInSq62TiUYVE\n", + "6puNIPUiGgI5kNWRxARtOCedhORjbhWD/H/D54k+fzivBNQI6KA+k6ieXurzJKUqv4xnIHdK3ibH\n", + "v2DOP5Gm6HGOWucE9QIE6SbC1Qpy1rIjhetNFHugdp5wjbfOW2HJnpTb44rZBnTutiFfoeRVbSC1\n", + "kRhy7BBIlKosPEwDdaZjf43ZDIFFKmGBc/Safw/DY9PaPD0ce4S1EdUhyvhkEhQx6f3YaSXvp3pq\n", + "dllEpKJFixYtWrRo0a5p8UUqWrRo0aJFixbtmvYCXXtZIPo551xOpereoPjVCoTtQYJiJP5V3wU9\n", + "YJ26hbb1jqjRtA8157wyyJTnVYFbQuEKT5fgztVr1aKABpC4Ks1VpRgkIGPAviL747KMiRKLq4eH\n", + "BJj+tzyvHUbXmyqxjkGyLUTviDBuCxw3z4wIWFYtjldyIuor5Ni8oMtS+KXqfgAAIABJREFUyMZ0\n", + "QdVyTwDLr+YG416cez2gycTIqxWUv2ucoxbXFt2tWS9JjvHunyZCIoT7rMi2XaCdkE2pCt3pOAmQ\n", + "Pv6KbysQUQVGp+c1lftEsnuu+HhwqSqxlXC3jBO4DSpg1aNaCLMbuKI18S1w/9VKiNVwFVbi2izy\n", + "Ka5lZculd2ns3zDImqRtErA1sILaMRdftfu1jyS0lbigZ+hD5d9yPn3n638byv7Vv/zX/oO4qmbL\n", + "Neqxh+trX0Ofad9cRoFkL329WnuX2u2DO6Gs6beDTYJ+mfhb+rk/7vH73n334TNzz80xP26+aq5I\n", + "V/t++uuvvhmKXr7j3X2vfebToeybf+21te6/ZHV6+tS7uQvVVoILfrOyxYBuhhzuuaFmm//bido3\n", + "lap1nchH25o5LiiWW98xKGY0NXfj3j5I5nDZfulLXwzffXD+yB9TGIm9QhaDRBbPBjSCRvwodIf1\n", + "nbWfnu9S1iJmKuCym8paw7mjbqQs2e4nZlHQQBm61GtZO87g2u3F3UmyfYbxN5AixPqQiY4RMwro\n", + "2sm6V5I0mG1VvT3X8llgrsoc504dXZGyhqGNhegYktLQtLr+8hqitg76RtvpQ44ZQIS+kfP6EpSD\n", + "ZN2Lla9TVSkFghdQbS//txa6AXXEUnGZpaWfE/rsqPFg1OTS1chfZMrsALL+jJCMuxxtR3ZdzEWB\n", + "H3ps40J4GZwfsnTTzd80NiY32XY2DLWISEWLFi1atGjRol3TXhgiVVWZK2VXM3Ek7Nmr4dmZ3y2s\n", + "V7bTMhK55oTbzslnpHQhikP5ejyFwq4Qdl1CYvlGyvhXVJRH3EGKdADDejWvU8jrp+H3vr18+1+L\n", + "YvcYuebyXNTesdPsB7tqIDKqzotw1VyJnejaTFSEKRmQp5RwsPqSnN3LTr/lLkHVcfH1gNgM4ud6\n", + "LWhCBeSwFkmES787ne8b6sidwxphzSo1kADiKGScpIGwqeGyVNvV3EjYkaZW994t0BxBbkBkJ5jY\n", + "yW6RStS5MEuz0rehEpmAFAhCVwtKQEanENCDtIcoW5O9moBgO85sp8kdbiayEqsASdg5VgvOE6v7\n", + "CGM7Hdlx+whFZw5J55w7efLcOefcSx8DiXVl9b13wyMtz589D2WvfOYzzjnnXn/9QSh7+uZXfX0n\n", + "toNdQ7LhlddfCWV//ua/cc45961vfyuUZW6IMBXCIl2BsNwJgsBu17yCRK4UETsGqtLIUMv2QXZd\n", + "CVEZZNh33vFIy1981er2xme8dMF/+fl/Fsr+1//tz5xzzn34J/86lH39K99wzjn3HwtK+emf+DHn\n", + "nHNfeesboewXPuERK6reO+fcau7z86kqPdG+DORhIm7OOTcZM9uBBDGgUzpBUxkmXkiuxxqoRyJh\n", + "5WNkFJhKTrISY2e59nV6dG4BAwxKOb5xHMrOZ/64VgJbiDDOGyPq15AWqQVNS1K/3o4EEaFS/IhS\n", + "N5IyoG4QHJAaqjFmDk/pf/Ku94TEX2BNSkXZ/rj2n5+eWj7FOZT0N61fk1Rqh8hZKYhQ4nxZVamH\n", + "BXk9hVhNz0UueVpTEJs7CZ5IAuruz5EK2z4FmjLIPzvxdakl2IdOhFSzQgAdawX17yEJkMsaO0af\n", + "pU6CF7juQ35hLnNofwIEayzo1y45H0qcCHLJcdyK54ZSOGkpCBeeI5TuqSp5/jIrRa4aDsjJKXI2\n", + "7z/9jnPOudfufiqUVVhvN40FICR4ZpSyFpWiRr/LIiIVLVq0aNGiRYt2TYsvUtGiRYsWLVq0aNe0\n", + "F+faG5euKpQISMjUykgyPzsXLaJLwNPJ934HJGm1qERbCHBgnm+2rpUGZXMV4IEbSV17IGrmhR4H\n", + "CFYgyySjKroSxQlLwmUj7iGi0oPzdr5+6u7qgnq6KOEGxXaDIkdw1aWZkT2DYi5ce50cn6XQZ1Fi\n", + "I96zlQCcgMRYN6r3hfNpJk+QKBMl4G+oY2N9skpWOJ9vY+22NaaCJo5zLkP9NgKFk0SYyZjogxaN\n", + "uECYoHgQUeD7c4R7UYt7JKgnC4kyBcZdSiJZKsbXci0S2nMRr6eicCtCLjmUfzP8thd4ftNSn8XK\n", + "qBnTCTm1xnHTQ1OWbtk/g2AHf435TDRRJr69X/rzP3HOOfeRN34yfDUd+7b+zA8bFP7ec0/efOVl\n", + "c+3NLv18enxixM67H33DOefcT/2EKXs/fuRddU+fmLvnxz/xKioMOL9VwrCv+1oI00xQmwg5uOQ9\n", + "GZl7IrgMRIG7ZhJucQGsFr4f3/3QJyi9D/Vx55x79PAD55xz/9V//c9D2cNHvo2nT42AzyTAf/M3\n", + "XwllFZKmHkuC5jqDu7GR4A1+p1pFmAst+mQk69QISZ3PL8wVVRbUDLI+4fBIVuJugpu/79UthXVP\n", + "E37f8ImbG2hw3TgyZfdHp94FOpbk5hnc6CtRws4htNatbAJkCHxJUht/TKCuOkplDZpHzwAYIR1j\n", + "LRjJmkDy/lhcexUIyJWogmdjPz6ykbmKRxhHlSTLPgWl5PzCu7Q1EGDEa4lifAl3WyUu87LyN6AR\n", + "33KCtU2GuGuRIUCT63YgjTNZcjdQYseYkMTnGbM4yNOc2mN5anUP8l16/YYZJeTZhWCAtJcE8ghK\n", + "YQ+vJIiAyZLXK3HtjpkgWugeHJMy//gIKlSXCuttKe7eCn1ycMTAAhkvdPerCxRjspfO3kAz7Pnl\n", + "w1B2/8Y9VEozNfjPqdRzPNZ1dNsiIhUtWrRo0aJFi3ZNe2GI1HhUhR2nc84V2FUqSkUkqOkMkWE4\n", + "5UpyXQVJBEVEKF0gob7lCATMkuRseTOG/IBG8PPNXVW8ExAFcyFxc/efZPpG7K/b1LKbCEgIdgvy\n", + "Vj2eMNRe2lWQgG+7jxnIg9kgJyEJ+Lr7BCIjIaQd3s75oj/SkE6EveelvnkzXtlKNtiJKDmWXOxu\n", + "sNUC+iUhwVMqlAuatMF9JHe8kXxxE8hU1KoOj9DgToICSArXPI0ZiZpS+YJK9kIeT0D2ZA47Rb/C\n", + "ztDJbh2fR6Up5pJEWibWnx3Qt0zI5oEfLERx7khJilS0oMe462sZ/8yN5swmUNFWRJSyEiTuOmfk\n", + "5UzIxivkP6R6/hkQB+ecmyAk/mf/oaFK/93//HvOOefu3LWw/k9++qPOOec+1n8klL3ysv/85Int\n", + "XL/2lid7ps7a82Of+SHnnHMtiL3z2Uza6uum8iMkTKuKfIbggclEFMsxyGX6uREI1b0Er7zzzbed\n", + "c879n3/qifAf/4mfDt89Qx7AP//iX9u1sPes50YA/x/+p//ROefcP/un/0Uo+9FL38b82Or+DhTC\n", + "7+xbP50/97vj5ZmhdC1ykZVAGvYOjdjdYO043Df08fzcIydKQCcZWdcpjoUis/FMFGt8YORtB0Xz\n", + "dOPv3UgkNF6+4+/7QlDlZ6jT3sRQnScgyBe1ho2TPO22ynIJsmDaiBHqPi5lrauA9Euof5oB1RH0\n", + "m4iUonl97utXbCQnJ9a7slbU04+TqvLrz2omEQuYi6NKnl0lx594OIDENI0ESqB+i0uRqVhiHRXU\n", + "m0EjBXO9thocgLUmVc8N5nUmkhSVv0+rxpT6M+fnVpvZHGsRcDQSNLfH+qwZBcZ4ju5Vfo6tOuvD\n", + "kws/dhO5sSkDmVKr+6jkM0GlFuC5UPkB5s5dyvWRz3LE9wNBy3hdVVFPg2SOPDt4zwTNn818Tthq\n", + "ZO3p4XVJpf1F+b1flSIiFS1atGjRokWLdk2LL1LRokWLFi1atGjXtBfn2isyNxKNDyowC4rpxoDb\n", + "Dg4Nsl+C0Nhp4scN5b6FAI2/rbiK6O6ia29saKYjebsXsnEKYl8iuj/U9MgrOy+VYntxmbRwQaoA\n", + "+6b2ULkR61ULh8RSg4ypPF6rwit+M0+N7MpkjcUAxmeFRYGXekslXUYGexYZ1YQFCgfsv1Z14qCP\n", + "JDcKMKsS1RMkC55Iew4OvS6JKnVnINcvqQUm+lAZyPZdoklGoS0jbtSeZPx+W7FWBHBd2TJQQJSd\n", + "6aKAa7NT1d+Erj3tJ7igRTGZiHEvxO42oe6J7lWomCx9h1M3GNcXomM1QvvztZDDG45JO+9y4d0o\n", + "o7HB07z/vQQlbODnWooq+gSVnx5799HDt98K360xdl59wxS7f/k/+Y+cc8792Rf/KpRdAgrPxLX+\n", + "zb/xiub1xtwYP/NDnlj+Y5/5+VCWgdh6fuoh9vVtUT2GSzcrdbxAxXltbdjf8+6TWpS9O7je9pC8\n", + "2P8IpNgL68+zOYjyl97d8WlxDzUgz6rGUUPXnkzsjyIZ83/6T/7zUNYiy+taCNjLuR+T031b92aP\n", + "fftXS3O3cHu7XPtxv5Q+vHET7nlRoKe7txPNNKqiX16aBtgB3IHVaN8uRQqA5uyFm3m98EE+pbhC\n", + "MrR7s7IAoDuTu845585b0UxquMbaItsgsETZEzmCXDQoh24k+ifHlbqxcH5RFk8zJq3V7MZIhiyL\n", + "fFb6cTKa2DxZIbijqO0ed+lieH1ZVzn/OtEnIh2lFGJ7ApdVJu52Bu8UclyPR/BG1uIatIAlaA/7\n", + "h+LaxDNuNJI+AR1gH/fBOeeYF33dmY5bUvgAhVVrbuQ5iNV9b+2ZInuBE/26CjQcskFKWSf3pn48\n", + "P1udhrKsBjldgqc6ZM9QtXe6numedU7I9ZpRA31HScNE7n/fUzNS7hN0n0g6d865tmFieqGl9NAK\n", + "SyUqCGt316u21I4s8GIRkYoWLVq0aNGiRbumvbhce0UWcoQ5Z6HuTgheJRRwK5EwYJhmsme7/9mF\n", + "f3NsZKNPsh/fVnlN55wrSyIDoo6Kuixnu0jMmv8OYdqCKnQ9w48l11RNhEMUwLFjYt1KCWFNqXpb\n", + "2m6JIa6KiByAgL1aGSI1n4GArrsfvHyrJEJ4m8dxbSvoF8PwBVUhmrPc2LUodZBJWGsKNfZCiP0Z\n", + "AmWPbhpRdg/IgeaaYvWYk6sX9I2E+k6YiOxOJZaToD7IyQVoU9EMShf0Tu4xOopgiuZ1TIDSZSqJ\n", + "0TOEXtTRM+Z/1OAJf58qIaV2/Qz1lR0pVeZJNhUS9QTTMxVUL8VvF3NDMKhi7lrrJyIMvY4/7PRm\n", + "Ih2wXEFRHujj/Qe2gz0Acvrud74Zyu7c87IH/95nPhbKGPY8E1JuAaLunoyJpvY7/UsharsMCuyY\n", + "1+uFjbUx+m6zFrV55tAb5J9E/kdVkcc6slqIKjiCHS7O7BqXcxKg/Y60FRX/4xsewdF5lQAJ39sz\n", + "5Oz3/uX/7pxzbn5h92T/GEiL1DPkv9yzeh7f9lIDq5khR0HaALeuFaTv2VOP3N27J8r62J2r2nW9\n", + "8fc1KXTugMQrmNAYMh46TkjGTYCS7R8bgnVW+3ruCyJyWvv6zvSe4F7sCXK7aEZolubT9Pc/l6wQ\n", + "45a/AbF6oCKO9Vdz7WGeqkegBnk8FRLxCErVvaAPRc35ZOhDA+SCsg4bgRuY17BvVLEcf2VN5JLV\n", + "iYo5x0KWbHs9FGGkdErbUB1cZF3gESil/6cjH8KfOkPkGdDR1nYcJSmK/mYoqzdeWX9dm5zG3p5H\n", + "tjol4MPD0GfsG0EpIesybhVp89ffyJq8x3GaSQQIELZM7n+BgZ/Ks4Bk/ND/EoDmEDCk85TRS2uR\n", + "kyEZvZc5zlyXTWdrFz1hq/Ugeaj7XhYRqWjRokWLFi1atGvaC0OkksRQGOdMTEs5RWXObOX2vjdi\n", + "GKLsCPb2/RvkfL6dp27wUstwfiAMvRID0u08QMzhN0SksCMQP/cGQp+t5JVrgYi0wuWqUSd+V400\n", + "YZJvVyEKjgV877287x5AGG2ztvDnzcbvJopSfM/gQeXCJWrg503BfdHM6CWECztBBMnDGcmubrn2\n", + "u1SVNRhBfG0ufXL3luemEIVyzrhJ6QD1wX1qCrRBdtq4vqJEzKHUSbhwQ+6Zitoxg7u0h2hnL4OM\n", + "yB03jhpCSymErtL7un1ejrFOULIcu16V8+iwY06EX3G58DvhCr8te0WwCCFaEyinoPzCCfLKaQxx\n", + "QuFKZ7uvDnUvhHPiguyC/24jaOFNcCVy4dmdPfPClf3Y7muHcPUHwm9qEuY/s/t5fuJ3fRMRM5wD\n", + "WVsAkelviNQHhEP3hdPCHI5LQdVGqMtauDwddv8Hx1bPNZCes0tFqZBVHsjZam470/sv+Z374dQQ\n", + "mefgcmm4/hf+2//GOefcT/7kj4eyozte2DMTRPgWZAUOblsOs9HK7/7bhSECHXhtcwhCav8zr2Qt\n", + "vEXuhxXhzwoip8J5DIQ84TKiu9NMeUB+bU2R/zIRjti48v15uj4PZRug49OJ8dGICAv24DZAxPKx\n", + "yBQUlA6w9azLPf9qufT3Ipd1LYGXQkV9Q2S6rAk5kWbpuxxSCKWIb66RM64XflcfZCe7wR/nDFWq\n", + "VVQ3g/xIrki7b2sr3KcWqFOq3B/MWeWNpi3FlJHDUNaLCYRee2cctXLkUc1OtD7Ide2E85qmvp7r\n", + "zrhMo5KcO82T6e/tZGxCrG0DHh74erk+k+Ex6oW3tAIi6jTXaUpEVFxHWHhVkHUMGY31cnvdbyDN\n", + "kLpCvkIb5HCC/llv10ocpWP+X/bepNmyLK0S+05/m9e4+/M2wqPLnoAERFKQqIqCMpHITAMKmcxS\n", + "lpiJNNCYCQPAcsiE5A+gEZLlRBjITKIxTSisJLCyGiCySAoIKjsiMiK893D319zm9Brstc63bj6v\n", + "TLMnS7lUtr+JPz/33tPsvc8+Z6+1vvVpnVygf97E1vZgR9TNZ9CRfD4iIhUjRowYMWLEiHHBiC9S\n", + "MWLEiBEjRowYF4wXRu31QzfVfDMzSwD3DQLFMYVVHXtLQPF9p3gr0lQH/15ds66aUDAQWRaguxJ1\n", + "EQdUr+LgjsdQZ/OUNeR8G0WMm/68KFCpyhEpox1qo7Wd0BOEIkXEnKJ2VCHdVMBtumlcxE0ouhtc\n", + "RFtVTJOXWnusq5SBWlAbAoijW6kNRaG+ut4OEBGqs3mxDPs9vOKQ/bVrgRbZqXWFfswE7iX1SfuL\n", + "onTYPeFva0lDBaU2iDt5BxG30iisWZdVtfwWbSIUANnlaYssLVJQoVrXkbYLpaREk4LLRdieA+bO\n", + "BYI20Cy12Ofvod0JVWejWPzCRT3VY1FYL6nerGdYSQ2xAWNXIXOjY7akhDeoNTcgXfj01GH/5X6w\n", + "HdFU45cOw2+Lhe9jfnAtHF9qoh1eD6L19an33Sncu4fRx9jpSXD7LkDFdI2P180m/PZo/+VpG+9h\n", + "FUc3DRILZD5ZrVe4Bm+TDu2+EVH4tWvh3H/q06HG4F/Dfd3M7PJRqBf4A5/0+nt/+VdfNjOzWtzR\n", + "f/gHgz3E7dt+npcuhf2uIQ43M3vjR384XOueU3sNangtD/08F+tAkSZIvxYNt3UYa6cnTu3sgdot\n", + "pP5jkjKtXMYfxnMrNEWCe2YQV/L2SRAgd5tAgV5a+lyz2gQK8sbgtM8MteYaoZZPcV+vxNZgDzRv\n", + "tvBrXRbh3Ku506fFIlzHsyyMl2bwMcTakckotd4wj6YiWO6m4zot3OP+y4QCnS/D/npJ55/kDXDM\n", + "zySFvtmSivJgbUSTMUmbglRq3fUUVku1AQrpS6EviyLcWyXupzT1vmaVjUFqkjZDuIfmpTvms+5p\n", + "IeeeQAw/iCt4hwoIiXyvht3KKOn/BpnDiIoStGgwMysw/+yJ/UqCMdaI/RBF9KOppAT1D6VB04QV\n", + "DaTuKvo970nFSmUR0KeJjDVmVhXS1l41Q1978DxPVRZEqty/10l1iedFRKRixIgRI0aMGDEuGC8M\n", + "kRqtmWpKmZmNNIFrBEHI+Ubu2woIu7WC+oA0UTW4TLA6SgX9YOr+JHDbQWRoainnOJl6KayE76uw\n", + "DSscTdek8FOFzQnejmkSqiLCAULEXVFb2J/WATKsHA4PPYV1PgtCzW3jq9+0eIpj+jmVEHbT6iDP\n", + "pDYZEDRdwTR4C09SR86ona52rB7CNe7f8hXxEgLgvPLrIYqiK8J6FY4xYLWWqyVEwnaVVUW3wfd9\n", + "tdTg+NXgxx+Qkp+Vfu4tUma1P7myyiZxtsckitwRsfIvqaGYsK6eyffOIwJpGtq7FCR0BnH9sgpC\n", + "3VISFhZAoupjR3C2eVit9bL6ZfKCCoY5tOuNo5TbbUAYUlFR7i/D8fs6nPxy6WjJ8VlYCb908/a0\n", + "rSDqIEuwA3RZL0L9Zw/vmJnZ2bGLqBtaG+ysHEP/XDkKCMezJ4+nj67COkOruh8/CftTS4Aeppdb\n", + "WTXy3lrL8dtNOOnm1Ntz/zAgR//VT/+ImZlt1n78p/fD/r7v+93qYTFnarSjWq++8oaZmb10yw0R\n", + "v/n2XTMz++FX3U5i/6XQ/71YEkx14swjAz46R+3A47PzwvKNJAXsAS2Yzb3viOwrSpsTkRE7AQqE\n", + "d+wEYMRZYAwvxYzwShHOaTETmxogTY9OH0zblhi7gybv4LrKpSclzKswd5WVJBTgPGfzcKy7d/9x\n", + "+qw3mM/K91ewaUilrtsIdmIUlsKQyLEVk1RarMwXPncQfWBOhFrIrDEnjGJWOeQwddyxOkCyjyJS\n", + "QPPVdoe2D7kg95MVxMjaqGoITQRZkZ7QJr0gVzmQ7l7sB3og92pcXSHxpEgdkZzhOaogzCTKBhKY\n", + "jMr00JBZkD4yO3746VmYDmLJgGdRKQ/eFAlXY+/37pgRiUf9XTV/ppm2sBQpnvU75XcTovRitQBz\n", + "0HZ7PsmqEiamlKSN50VEpGLEiBEjRowYMS4Y8UUqRowYMWLEiBHjgvHCqL08z6xuHB7PQOPsiJ1p\n", + "oyOUGRHAXnwsCN8mAq2W8AzZcfuGz0cyUUwidmcNPdk2dNiHUAuk3tKd+nv4V52VKZTPhcaYKBWK\n", + "2QTin67fsdCRLs5yrAww+kz8hugEu1x4d1LP3I1C91VhYw4YNzOn9hoIgAsRjPYr0Ei9QNE5ayid\n", + "d/bdUwf6YovzlXMaKFT3PjmFf84c3i6JiLMLQOpNr144gLTV44MCRPEnoSi9qVVYG467Fadssnwp\n", + "+jWR8VLAg6UvxcUXkHHfizs6+jMtdJySKhZfKog9z7a+v00f7oES1O4oNsr1Kcap4tO4KeaVw855\n", + "CVH4uKPYNDOzVj2DsgCZJ71TRWtQqx2up1xJf4EyT1QcisHeCz3y9F6gsRqhsUvcC8tD9weq0CYn\n", + "K6GqcEO/f/9euC5pr7M1KCv12ClY7cCpmGfHgcYuhTKm2LaXvn7760FIvlNrbnjMH5iZ2X/zM5+e\n", + "PvvyW980M7N3HjmNfP16oAKzxMXWiYVzeXDX3clfhaD/ox/y7119JbTF+qnThz3O/fjMfZkSyBFK\n", + "0ONShsyGhoJl76fTs1P8zvt/Caoq2fGFC/9eFm+v4iDQp+rAPtRhLthCsN+sfU7eQ78m2v7rcIKZ\n", + "eIuNSMrQagOkjCR3wWbzsJ9F6bQk/ftKeNCt952e/uCDO/hLJQOYO3fq1VHsrAJ0ehDJPI25c+iU\n", + "7sO4T0DFiY8gqcBcePwGMgd1bCe1Z+ribfTxE7kFnmMLmbspaB9w/J2EJZz7IGL7DXyf2kZd7OFL\n", + "p3KXNPSj+l0xuWqQ8TR2EKCL2zolLRUSC3o5KVaK0GQP0sKjzP9FSm8z9YACtSzPDlaFGEQWkVi4\n", + "T+qGNKrUWp3qiurzF+2kxXtJLYqzPP+sZD6dqpHIcy9SezFixIgRI0aMGN+jeIGIVG5bSWtvscLo\n", + "encd7iCAVrfpgkK8YUftbWZmlSBCOUXTIh4vKorXKQQWZII6dEGfuHJITERnFVPYpdI1UKcd9Csh\n", + "IiUXDQdWvv1qaaAEbrdaVZwiw7r2FeGVxUv4nrfTbEFnXRcMNkCszmRFzrYr8yBsViEmVx9166tl\n", + "nnvXKKoGpEVWED1Wc4UIBrMKwsdEXITrsLJsBc1p4J68txdQlUJdnDOetzRiTbsEEcdyxSg2BUlO\n", + "+wlZzmHV3YlQM0XVc9awm5Wy8sDKWGvtMZ1W9O9WoKEUEaA9Q7tT1TysIrvR++5kuG9mXn9uP3HB\n", + "8tUCgn1BC7ZYda8730fesCbkc+p1yaoqQ+28XlDPlkLtbTi3S5dECI9xupYaerc/9nEzM3v4+OG0\n", + "jXtb7DnC2aKv14I+rU4D+rZt1EWayBltTfyzG9fC2JnNfL9bIHJyWVZh3ClK2EMp+/ih3ONAdrut\n", + "o7R9E/q7Wl43M7NrR57EUW/DSv/jrzmC87f/EFCqB8987rp6OXyuqMKHXwtWCJ/40e/zE30c5ozN\n", + "Q69deAw0b7vx/mwxT+zBvX4pdUXbOlxXLfd1g1qYmcx/bFd1lqezdyJWByP6eNw4IpbmrDIQPmtk\n", + "/iFinEpSzKIKCN+p3idJ6Pe5JIBsMY9vekeY8vw1M5OKFebO7jPYeaQ3fVxvgL5tGxci86etVJEY\n", + "cH8QwTAz65KACCajjzFO9+0OcgF0GuxI3fr8TxftWemC+Qwo/lYSAOr2GOcmaHZO9EufJ2AT9nxb\n", + "24Zr3ACdHqSGZtvDbV7YBIOIfcgE6e3JyPhvC8yTqUlN1JT/qig+NOg883HSAdmvYLFBuxQzswZ1\n", + "+hJhM2ZgGHqpdZmkZA4ETeLf4vY+TkiYMDFkUZB4Nsqxxj6M8VTsPwa4w/OZb+ZO/W3rY6IsYO0h\n", + "SVZD/xx7pPE7vypFRCpGjBgxYsSIEeOCEV+kYsSIESNGjBgxLhgvjNozSyxNFB6Em6oaTxiL/Ao9\n", + "AU5lEGFpAZFvXqoJFIpBFirsg98QINZMBIsJBGalOOEmCaBCoYfoWZFLMcge9BDFxGZmBu+lVFxk\n", + "05z+FBBsC4tEkfOgRWYncbbvd10Hr5ayvOY/hthxPvfrr0BjjKkXEh1IYxHGzM6L3QWdnkSvqVzX\n", + "AFhcBZN07E3EWZhGW10nxU1BW/adQ6b0ORmTAxxLi3yGf4vcYWwmAwwC+9JbzBLxIMMaYRTBZAf6\n", + "rhWvJgr1aWyc7Xgx0QtFfMxAe+RCC7d9oDETEZaSjhatq1MKkhSRQXm7AI1RiWMv6btG+n9kH4qw\n", + "nEzlptFEhXDgs7XTKCz0PJOixXtwyl8ehDZ+8swTQBILfXfp0J0wbBE9AAAgAElEQVSt//bv/tbM\n", + "zN74kHsrHT8N37t+w+mOzTqcX71ybxsWI101DvdvN/DsAQU1l3u4BH3SZU57ZKA5pVltQF83a++n\n", + "09NwToVQRjkKE2cC0++Ro0V/5lIg+fb3B1ruwVf/Ydr2T34oUFGpeLAlqGxweNm37cED6uSBO6V/\n", + "8P47Zma2fuR+SyO89PKZ3Lv4bd9SMiDXilMvRNqwbVjw3cfJfHKZFgoOYvDiSOYOHGuE67yZWY65\n", + "oABVnI3nKUP1fVogaeZgLf0EkfOpCMDn6ONCPADX2zDeLu35OXFqL2ZwzO79s4+98UNmZnb/obfr\n", + "ww/CPvJS6CkU5h2FAu/W8EBaigO8MQFJqCVIOWr8NhMqbESbdI0Iq8d9XLPek0xK8XYdjZ510qFo\n", + "23ImlTIWpFZRMUNo3H6LOaxUF3XMiZ06gYdtWSfUHuQYnbSJTYkk+jyFzKRVqQaouo7POi0aDcpU\n", + "E7CYADX3uWNISHeKZ1RC/0RJ3sHYVk/FFufM+VQpyyTBWJS5M8O2QiqV1HBlH8THrm5YcFsexi36\n", + "UedYncifExGRihEjRowYMWLEuGC8MEQqSfwN3cyshTi3V4EZ39zV7RtIRya1kSqsNHNJU6WLail2\n", + "BkxZZRpm0msaZGiKXhy7s4yrLn37B5qVyLFSugj7eeZwTB1EAJ1jNUNhZVmcP7dx8FX1FvYQuQi2\n", + "19uQYl0duCiWCFO6o17fFbabmdVYufLtv8h9VdmNrFclacUdU5jFRRqIgDq2EyUaxTGXyJpaUowU\n", + "RUqdqIxtkBDpOv/m7/1gVmFV1YtguyjpACwrx8n+wffTA6VsRdBM1K3AZ7ryKLA0zipP66agORG3\n", + "fdYOHMzRlz4JvxlFKFoCfUg0dZvH7Siil+8D1crE1qFHTa5a6sW1ELErIrGByJMopJnXq+pl5ZgT\n", + "zcGqV+sKlrArOD52VJHj6u1vfXXa9JEPfcLMzJ48vjdtu3o5rFKXIso9gUP3vtSa2zShzUak6R9e\n", + "d7uA+QHQVHUCB6qXa2IH5oQd5A792AiaPaOzt1z/6VkQnr/6SkjiaLfeh8uXgmP59dden7adPQvC\n", + "2pXUJLyyCEL1euMi9odPQxLB5sy31R+ERI5U+rPF6r9vfNt6FYT8TB3fX7pdA6fstvXv78EmgEL0\n", + "8Hdo68WBo2SzReiLTKoiMGsil/u5Rdt1QDgVfeYqPRdEbB/3Z1+piBiCXhHs1hhrhfTd8SbMZ83o\n", + "qNMiw3livO779GfWhu/dOtKkkHAvnNbf9E1pOH5Te/t3HcadIGJ5iQQUQZj8cYPrEqQ3H4HMKFox\n", + "Mv3fnwl7s9DGaj/S9B/g+yJsRySSzs/6ezZV9vA+7JAcMkhiBV3OC0HzKexuW6lKUSPZQJDzHvdM\n", + "WUr1DPRTojYBSDJgnUatV1oBrcp25trQJ8kgiRLG2oWSFETWSRCpoWFNQE2KUaZq120+n/yH9P7n\n", + "ecqxwIAlcv91OO629udJCfd+k3MfJZHheRERqRgxYsSIESNGjAtGfJGKESNGjBgxYsS4YLxYsbnQ\n", + "GMkEJ/q2nCK684yVDamKjeE2OwoFADhafZzos5JkFCerwBDi5Od4bHRCNxL3HQelAOlUroUUAWOK\n", + "j0gJCHwGylKpPVpsD7LfyStKHZtB46237ve0qG6ZmVndOmRbzbFvccqmyI7UViK0Z2vBM6UX2qko\n", + "KMoUsSmaYoeW7Sjic8quHcO17omLdAKn2nornjGrM+wDgu3UfZQy9GcqlOmsDHRPrYJJenapK/vz\n", + "xIGTyFiuB7BwOrHIQk8Azh1HpYAxTkUwSjHuIP40Np4vTE23ZUGWbQEK8HAZritrxNsLh83FWbw/\n", + "A8QtlCkpnfVavYXC341UHt0/DMdYC1XXrgJVNbn9Cu1SbwI90kkx0MNLgbK7+fLLvm0/UDGleGZd\n", + "QsFhekeZmXWg9hqBydMy0AKsRJAmTqN2EH1eExH3GnRnLjc2i8GWQlk1KCrMAqhmZgn6vdm6B9HB\n", + "MvwmA8Wx3XrbDO8F+rI7cXrooIS3lyR23L/zdTPbLaR7/CyM56tHTmOmly/j+9+atrGAdSWu4MtZ\n", + "+M0Gcw2LcpuZrbfhWjfiwUdB+Z7Q+KuzcP3LfT9+sgDdLJRJBgH2jlM/bwZ6domLfYJz0iKzpF0q\n", + "oYLmuNfaxM9pi3shLcVHCe1+evzetG04CEWy96swrgqlnTCdtL2PqyU8wLJK6NHu/XCsrbdTD6+u\n", + "XPyGuoEFb6VSBuj4LGWBaim8zXwRSeJxvznfVOC6E/H7641t7ec0ThSZiPeR8NDhvh57b68OxcV3\n", + "ki0oUdkRYCMpJhX5BqUaMnfQxy9PfZ4e+dwVCUaCe3GqwNH4GezNMf/KvMrhNAziGI9na995342Y\n", + "JyuhRZlIpN5erB7A5KFS2j/FM3anFjorReyI6Oe45vMu9pvakwKyOaVCPk7GPorNY8SIESNGjBgx\n", + "vifxwhCpYei1XJqnlcuqhiLiRoRmFJmqJQIFzepAnQPFEV3b5Pw81WaS1FDWXxpEdEmd4CDNxPR8\n", + "rRc0EGKQV+JJJy/u4aytR7QslZRbo7OsXANXjq2gGgmWZCsRtpZ5WGkmYslANGXoVVgIYSURJEnr\n", + "Z00oRXL4Bt/LPuZwMe7EbZtv7lqvqkStMRUvV8UM+5UVFlAcrjD7wVcrvC5F6VIgEYXWhsKqZhRh\n", + "tX8myCEQqzLZ8Z3gmeD74jCMa9TEgjQ/j2pNoswdE3XYOvS7IkkzXxmauXg0x/UvRxEWDxRR9+e+\n", + "v9163w1YuW5FbNwh7byV++TpaUBJZjNpfyQ+jB2tMfyemAPBOhVhezEPKEEvbv9rIG3FwhGhu0hJ\n", + "v7TvYvMbt+Gon7sr+ntf+0czM8uAXD19+O702RKI6ckHr03bLl+9Gb5f+GqxABI0SFJGVwTkbD+X\n", + "xAbcf2cr9aQIx9isAxK1vPXK9NFQhzHx9NgRpE1GBFXGOuakTtr/6tXQFvfvOtLSAh1US4YCiEEq\n", + "CRXbbjfxYlao/QesTiSte6qJKI79FCwvl4505ai/N669Pweck9p+NN0G+wjbNnIPD7QrEWH/Ekiz\n", + "iqgXQHjyVOckICKCSNJipl456nOWBmuDzfwSzsP7Oh2ZlOHjrwJilZXeTsOWyLUjjB1QymTj9xhd\n", + "1HNhR1i7s+O8ImL7DfZXyDxNO41RrG4SJO0MCpxjbqHlgpkj+yroT7BtAWuKrvX+IjnR7zhtcx9S\n", + "p5TVFnaE3fxXbIcaWEKY3OOYnwdJxhoxJjP0V9pJmwBp3tv39ud46pVhIUq049ROhN3vyQEo7ZCI\n", + "AL2noH6BK9Zai0wUkmcnfitOO9b1YGIEkUtS2l/4sbZNSBSZlYLSCdr4vIiIVIwYMWLEiBEjxgUj\n", + "vkjFiBEjRowYMWJcMF4gtdftiM1zQNtKTyXwJarEn2Toz0OhI6DSQkSMacrvqY8E4E6jsPu8iFiF\n", + "xdN7psKjU3FjOT4Ei5mIx9MtBHjqHk7PFvjiKJyeZBAni+8KvUCGzqFtgyg86b2dTuE7c5C5AG8L\n", + "gWqv3k70VqIvSipFGSdYVOBRIKBVIUYuaLNKXsFrUK8KgRMCHkQwmIECSDNxCgct00Morc72PV1v\n", + "e6XikDAgFNQk6Bdod4KR1f6D7vVKLX4btJ4J3dqjDRNxdicCraL0aXiojwp9TAb1kQHcL9QGWdMR\n", + "9KEWnuYYNqG2s4yeNQLPgyqsROxcwlttVFq6ZJKDb3uCIrAsGt2LP9HpNvTJ5eueAJDjGLfFW+mV\n", + "1wL1tt74ee6j4e/fdW+pGy8Fgfri0L+32Av0zVf/5itmZvbhmz6GZyg4+ujuP07b7nwtfE+9qPau\n", + "B3FyufDflgeBUsyFxq1A8136kJ87O4BzjXrcdCz8m/n9Vw9hHyyybGZ25VrwvlJh/d27QeysdPey\n", + "YhFmp9sa3GSZjF0O7Rb36fGpC2Gn8e9bJuorE8qETvmJzD89fcm2MiecIaFAKwBgbNcoZJ2JsDy1\n", + "827r7YZj0sf6gvOp3BQHoDEX4guYIsnmTKgV0nxP54FiEb3y5Jmn80QGul0L6RZIMugkAaZvMHdu\n", + "xAEc97sUO5ikBA2Sd5RG6jH/bkXEvqhAaYlUxDCfW6q0POZkuf6pCLQUnGYiRQ4KTr0Au4YJMFLF\n", + "Ay7eVelzB4XdiSSqsLixJkrRR8lGv54Mz6dR+Sy0rYvT/SMWNa+Ebub1pArVYB8qC2GSVS9UcUMK\n", + "ThK1Jtpy4ie9/ytQuo1Qy5xju176vyeNJ8ku9JssZE4eURhbflsVWiT6fEREKkaMGDFixIgR44Lx\n", + "4uwP0nESeJuZ5ajDpBACnboTsSno8SY6DP4GXQNF6sRtmrXw0kRF6ahT1J133TauDETEN6Fe6o46\n", + "MDVUxYF0bBX0hdYCgiZltotSJamK3uiYLuLogm6yfk4d0mnHHQF6WAmrULqH8LGtReyMtutTpjX7\n", + "GzetGHQFSdRD61AlKZEeOafJEkIdqCne98OXJfpHrAMo8isWSEPtVtNnFWwqRhHRUoCf57LSmlAd\n", + "WUHh71TGU4dVjabJFtOYIdQoQnAuhWWlOaL/M7EJ6CFYHGScMCV6lAbou/PJAxS59+P55IgK4ukh\n", + "FQRhDruAWlKT0Sd14xdGt+Nerr/ZhrFzJjYJOUTbZ2dBiD5IskdJ8W7mosvv/8FQf+7wkjuQP3wS\n", + "EIT5ngibIQb+/k/9iF8QEJFWUN8Pvx7O/e77of7cl//a69pd3Qvfe/2NS35OQNOSmaBEQBhONu9P\n", + "2/bSV83MbLGQ9GcIrwtJHi8WEAATYhEX9dmN4HZ+dOBI18Ov/52ZmY2Z1zA8PQlWJFpC7TL2u1qJ\n", + "TQUTQKTvmLTSy49n89Du1f6u67yZC+bVdXq7CgLoRtAXgglzESCn23DOiViSZJuwrTlxp/YcNxSd\n", + "1TvT+4815PxacyARR7nPCR+sQzLMQmFaVhYQRLhKwpic9Y6mtGkYi0+fvYPviyVLGZDIvpFxDaRn\n", + "MJ2n6dguySOb0O+JIOI1kocSQdPohk3bh+1K7AqASCqqsWno4u7HYqKO2t9UQDE7tf/gPKHJM7QC\n", + "Ql8XM0nYGTHu9f7H84dVH8JO0E+dVmAA+i8u4gmO24lNQ1uH6xhHn4uJUiasdSlif85ZJ2eeRLKY\n", + "h/NsB99HD6RplOceJ+Nhxzkcg7fXZzHaZJqn/Z6oiTRKAsw4VdYQOxv06zAIIllgnpTnVD69bwgT\n", + "Jm3xvIiIVIwYMWLEiBEjxgUjvkjFiBEjRowYMWJcMF4YtZdbYqrOnSgt5TZISyjdxa8JPGsQBWrB\n", + "2R6fl5lD2xndZnHZjcCZWXoedp3cxkUwTS8U9ZGaqD9RgJYZqS2huxIKgEmZqZswqDWBjEkB9gqF\n", + "9uehzRQC5G3jXizleIhjCY2Dc2KzqhcOCxir7xUpPWERLDWKPdUfK/y2qb39N5vQ/ipA7FCQOZVi\n", + "kPQ0akB71SjKbGaWNMGxOBVRfA9hdSIu8pP30U5iAV3xBbOFt5ImIBQF+wKFWsUxvcH3xTJlKpaZ\n", + "KBYMwWK/I6w/Lwqe5PwqigRt11mgWDaNFOME3aoFRTtQn7l4EW2ptdfzRKHlpQibj66E9jy87FRV\n", + "h74gmi1ac7t0PXghbUWcmwOyH2X8z+HKfef+g2lbARrv3fvud3Z0FOjAW7c/PG3bOwzn9I1vBb+l\n", + "5thplOZJ8G9arX1bdSmIyB88cqj9/XtB0P6JH/jktO36frjGS5f9/rt6FM7z+ImfUwNq5crRR8KG\n", + "0ovnjnm4h9JDp8KuXAvHvfeNL0/b7jwMlEYh/XoAv6vFFf9tC7f5WlzJC7Td/ODytI02+2UV2nCm\n", + "TAioEE2ioIt1v/U2GUCjdTPvJ5LhfS3O0qD+19LHpKDnOZNzZA7DnKQFsqmAGGQ+L3hPCo+egtrp\n", + "hapOMY8VsqanyH8zhPGUD077HR8/wzaRMWDOLir1BQz3zCg0zgjqs6uFpoFjdy7qaYqx6ffWdDL+\n", + "jf5YalAIat+ExoJ4OytcgsCEgrI/71VH3zczp+UreIGNIqzOc3pWaYF2JMyIt9Uk3k6VMgvH0L7L\n", + "2Z8yxlo4j1MIb2bWYRJ0d3If6zmSWKzzcU35QidzIqsM5Jlfv6GSQdO63xe9DFO9RshwWAFlJ7EH\n", + "xxIFiPX4z6Dfo6O/FhTBOMnkGTsZ+0uSwaAC+edERKRixIgRI0aMGDEuGC8MkcrSdMfZm2XiUrUE\n", + "4MtnorWJwr+5ICcVVz+JiiLD6odoiZlZib+7Bt/PfKXBlZOKk+kKrm/wfCMfxJ2ajuVa621yoJWV\n", + "i9ew+jbhnPlbdbbTI0Tkzm8aRQDqNfQE4UKbqdsrBdA8pczSb//IZAFhLY6RycpgAEpXygouRfpt\n", + "Ju252dLOQNoJIscy9RVmWQaEYTkPyMTj1l2kt1ilaPo5haAm6bJsMxXgMlGh11UaTkWtA+iGPyas\n", + "jSeO4fhpIzBNMcCmQ+oU0oF6B6QCcpinutKke7xYPMD6uLaAxGltwpo1ERMfw8ujgBLNj277PpA0\n", + "sF47msa/T9Yn07a3775jZmYHJ476LYHc7B0GRCQVC4UnjyGilmSP8gpsBdRqBB2QykqT+ytlfwn6\n", + "5P1HjggVWDH/05/+qXDMe15DchwD+qDO9hvYitx8/aPTtjd/4s1wfFl9l/uhz45uudt6voTFw5m6\n", + "IqP+VhXQpwzjMJwwxnXiwvLqZkCa0vv+vTkQs0ru/w/uB+F7Iw70y324eG/FsRkIqKJUrEW4twzf\n", + "ny889bp/jtUIV9+1JI8cXgnIWi+CXSI3w+DnVCLJZzEXixP8hnOSupg7wuTHpxDZ1P6EtUsFkcpo\n", + "nSD1Hxe4P/b0t0A7B6AQ69ZFzF0bxti21ZqstHpQpJkO2H5PDEzyUEQOk6Hc9hNjMSXRiLKe898o\n", + "1z+D7UCaevsPTAASRoB0Si4WP3VHOxdhOFgTEq7jWsOTVTRyQbo4ee8IqykK1zKxRjuL87Y/CrDV\n", + "LZISRr93J5uInqyGsATbcNzF3L9P9DWVenUZrjsvlDlAklXu8962DvP+kEg/EW5PWO1BLFSAvncC\n", + "yXcNGAnpuxHoZyKvPUyaSsQmJeEzVmC6Qdir50VEpGLEiBEjRowYMS4YL04jlWc7poo9kQs1pExo\n", + "6uVv6z1S0pXTpnHZViCBDKvoXDRSEzqFFW4y+iqMJlxq0sl6aZm8raZIsRRPQ8vyGr8V5KIk6uRB\n", + "bQ4RrEQsBMbJfFIQnIxIj5j1EaUT6IiV27sdlCxcdyPuBzTgpCGc1lKqe3LKatIZ/i4T19kYjPC0\n", + "rh21acops83qzlfzLVZOpaAurKdXZmHVvZi5+eMHz2DmKOfkthaygpgsDFRMQo2S1i4Ewibmd2xP\n", + "atR60ch1WMGqboh1BzPRKFGvliaK0gB9EqO7MeXY9Z8SHJhBe9QI0vjSrWBgOeulDhu0LMdPHVV6\n", + "fO+OmZmtT10jl8Ee4upNb8+r18J4f/qBo1QPH4bf3nk/1LgrFn5PVFjpXbvqVgdPTnmN3tbsu1sw\n", + "3DTze3Z5xa0LLu0HdOjRB66laoGw9NDq/Of/4qenz/7V//zVcB6CqkwyGFnBF0BVNu3dadurV8K5\n", + "UCtmZlYeBRTp2tzNPHsgp/n8MnYr93pxvg7c6eNw7vcf+jXYJmhjnj72unr7y3Ddsz0f6zksGxb7\n", + "YqbKtPLExx1Ruho18QbRo1SzcH5dLZYAGFD717yvDy4FpJE1L80c6Wklnb8G6qH3E5HtBqaTozhi\n", + "5gktac5rStpWtE9MVxdLEGpeFoI+GawNlqJRWWFeSjGHFjLXtAnnTkHTjVYjYknSs/6aH4rnl+rc\n", + "hcOqvpbaoMGA6nfn8YZUkPaeBsszmadxXYnc/zQ2zuRYGyBSvTiCVhh3tPhRVM9oxCnPSc7raknD\n", + "61EdbIo5IVGBHfWqidgpENka/TypQ00L2iD4/ZegfbZitTODRlIdGYgmqUn19LwRLXGeAU1MHIkb\n", + "0Rccm2or0fIa5D2Bz9NU0D+SA0JITPVnR3nuDz37Qt47FJV9TkREKkaMGDFixIgR44IRX6RixIgR\n", + "I0aMGDEuGC+Q2qvMTAWDSDXfSSGHEEzT/wkPihMwU+KFAbMS9Yno5mrm0O+0XxNqDxxYkqhdAA/p\n", + "xypz7FfgwXJGEblQdXk450bddgmLg/DrBLLv8L1UhMVDF/7O5RoyCPAGSYnt+/Niw7Mzp9Smc0pI\n", + "N+FfoQLJgCmNNWmME61NleJ7Qi0UtHqQ/aUUtoqLOSi1InNqhemndPguRXQ49qCvRERKLk5rHfL6\n", + "UxF2jwNF5JqmTfpU0olL1B8DLNwKZdEjXXqn/iL+1HpZPD21riCn0InYlWbsbeON/Ortj5uZ2X4Z\n", + "qKh+6+LM+98KItv9uUDWOEQmlOXyUqCs8spFydeuBmrpm994e9rWNIHGu3//zrTtU//kn5uZ2esf\n", + "/SEzM0ulrteDh4Gq2khdsduvBeuCt7/x1rRtexporuEdH/97EEhfuuZp/RR0XrvmFgMTHYQ+vPry\n", + "K9NnP/Av/kszM3vrX/8f/v0siN3Lfd9HNg+/vS00Ju0hnj0VweoqtHsi92S+DOOtIu1R+ZxAQXFW\n", + "iOgWXhNj721yH+L5mzdenbY9e4rUfWm7Cu7dJ2d+Tnug+7alpsSHYxwehmu9fOj3SwtR+lz66dlx\n", + "EOirKH15GETx7Z6myYdrXBz4eGpPwrk0vafu895uQfvlMtdONTQTsVroSZkL3TbyXvd7Z44J+kxc\n", + "uTtQZImoomdj6JMO82mdixIc1gU7tySooL7XexJJIeZ9R/F8L1UxOI8oLUl6n5UadpJYElKGMlGC\n", + "2pstnEaiyH82lwQoWJeotOEQNdw2x/7bbgs7B1hjdDJfNTh3SgfMzDq6l0v9vZa18WSOL/C4z6Wu\n", + "XMbajSIAH4Y5rkG2gcovMtKDMq+jMxqRpbANO32eYHyMUj0gZbUDTfJBAk6vlCaqXJQp7Rf8WG2K\n", + "sSiVPUYI5VUwP5276m1wXZ3WP0x27S9wAvadIiJSMWLEiBEjRowYF4wXhkglaTq9IZqZJVhNqFki\n", + "RYSZWiIkFBv7myaNNVXDyDfdUapff7uZ2SirIKIZgwjsKIorVNgKAXhRnvckWCzEwKzFW/Wg4nmK\n", + "vZFeK6gO34hzEbglSCdXsT2rmu+IoiEo1FXVtMLU+nMpUTeY1YkUfjyvL7QtBK2tGpfmRPXki1h1\n", + "qpcpjU3bVt/qw7bVxlPcKWgmSqTooxtRiogTK61RkCPaU2iaMFcaQ6+i8PMmdQlXWkhhrhtBkJCo\n", + "0EpqejpBkSKY5PdlVcP6ZFrX6epRqN22uOmoy9nTgByePQvozzL1tPpLlwPqUsmYIErQCvxaYYFb\n", + "Lnyl+813glB7K+aDFI3/xD//Gf/e2/9oZmb/5i/+OOxr7uLsNz4WUKqjK24h8JWv/E04zz2//974\n", + "yMfCsWT5yVpoWv8sRfvfF+NOooQNLAR6cT+d74f2Osv8nG7fDm13cMNF7MvLTCLxlTvR3mbj98Rm\n", + "BZRW5pNFS0QijMlrYuGQzMPcUcwdJVxevmVmZh998wenbTnQoUFqKB7cRF9Iqj9tLw5KRcKZ0KA1\n", + "LoHEQAi/3Z43Di5KHxOH+wH1m+95m4y4T3Mxvx2PH5mZ2dmZ729k/TOZpzLcd3tlaH8V22/bMJ60\n", + "rhsRK507aeLZ6PXDsLcQOH/Oe0ascM4Mdeqwu05S3SckQtCnHPdzIipi2r5ko1qnwHRY5ol0Ml3W\n", + "NkFNNiR5qBUj66mmYhK9gXi/lBqCy4Pn1HqFQFprks6A8NlcLBGYcMLz7RzB7IfQF32vDzueuAim\n", + "IdRWUKXrgEj1wgRheKjYOkto8SIJBehPInJqNcHP5oXYdOBe2IjRa4Jkr52xTuNi2d/Qw/Zhx34A\n", + "6DDGSSYZO9ttaJ9SE4CIRAojwee/1s6l+Wey85jif3zcjTvPlvMREakYMWLEiBEjRowLRnyRihEj\n", + "RowYMWLEuGC8OGovSSwVj6eUQrjM4TR6zKjvRAGXa/UxScYA/W9ElEfmI09V2EYX0/Cv+oOMrEOn\n", + "Hj8D6EHxWBmN0LqIGAGLp4V6cYRtxSguxj3dYfk7P1jTkNp0KJo0h2qt8+fUcGsn/Fb2N5CWc1ie\n", + "tFQx0XLqmYV/W4GHCXsKFDvDdeeFOHaTxhEMnH5cWhOKliYrceDeX0I8OtWrE8oqpbO0t0kHylIZ\n", + "Q7r9aqOkGak12ciaVALLJzxPsjJyvhkotVJMhFO4tydCrRWgW9QJdwuq6M2P/uS07ew4iOfv3XMB\n", + "+N48CIqrkskRfm41and1G6nXhc9TOSfSvQ/vuoj8+q3XzMzs6LLTfe+/G9y2//c/+V+mbUvUQnzz\n", + "Rz4dzueyi8P/6st/bWZm+/ve/nkZaL7P/Bc/PW3rmvP13xpQLzf2va7fk6dPzcxsu5b6Z/S7qSEE\n", + "F7qbY3h+KIL1MtAH33zb6cFb69B5t645BbhaBa+s5Z7TLZfo47T0c2rT8HlZsg6nDGLQEq2YTudH\n", + "Qfh9YC9N217CfNI8c8f2GlkbnbiN56AZ1iunW589CdfRrJ2+WS44FrAvcafPQR8VMq/tof7g8kBo\n", + "LIp3N05JtOinmQjbWePtVOg+3qisJ1poHcAR9KHQ3UPLKgpSbYF0vAiQ91E7cNv5OdEOS2ucLkEV\n", + "rikY38pzAofYtE/9nPowJuYzmadZxWH0bftVGLubWrzlYORWCH3cwtuISSGNULak/Vgj1Mysb0BZ\n", + "roRGgnh7Nne6i8yTyh1aeHRlqe9vBqq4biAjyZyyXQ1hjA3Srm59ptUWpoJxU0yC/kQf+3RvF0kL\n", + "qzaIUJyi9FmxxPfFMR8eWGptVSJ5Yyvj5OQ0UMuzTiol0G9R6i+O047ExwryliJf4F8f63wn2Ml1\n", + "mt4ZfD6lZ6HYohlfAdTbjzVTE9WqaEM+JyIiFSNGjBgxYsSIccF4YYhUN2aWy1se3zi1Ns5kOyDi\n", + "MAIMOwJwpHNmta+q6KLQZf76OYkBE66gRQgIUeYoCBLrJDzea8gAACAASURBVKnVAlN800SFfeFz\n", + "OpGbmfV5eBPXBqbuckJLxHW8b8MbfC8oXYsfK/rDRYfWRmKK7079J7jjprL66Iawihsn51p1c6X9\n", + "hNSmo4u3pDATTRvEaqDenK9hNLlYSEpuzppsIop/chzcqPdQ62uQlNscabKFrNao/1MRNdOkU6n1\n", + "N1ULF1F8P61+/XoqrLon2w3pV6bBFtKve/uoyVb4qrppA+pX5L76vXbjI2Zm9o/f+nf+W9Sdm4l7\n", + "dgG7h6kM2OhV0K2DiDN3cTITNLgyNDP74INgk/D6G15/7snTsPr7+tvf9OtpQpvdQr04M7MfABL1\n", + "lX8XznPz938zfbY8DGL3JHFU6yd+/MfMzOzRI69/9uhJGFdXLznSk6LN7t27N20jwnl25n1XTHX6\n", + "Qj9oCnsHIfbxI3dx7157PfxOUqifnYQ2o12Fmdk+UtEfPfHjHwBZ2b/kY/L6DaA5qMNXS2r+fC+0\n", + "u6JkdEIelo40XMI99lDu5xwC2JNjR6noEC63k12+HNCGZ3KMBKtpIvHrMz+nrAz70DGUoe1KQUnY\n", + "dom4eJf76EdZkrfPwpw5avo/Ei6Y2GGCIBFhSWY+/oYSte7EVmBCcxT1RuJFIyJeXvYOcwBUvAJi\n", + "X8hEeQyx+2br7dpYQPXUOmUgIyD3ZJLCvV6eHW1/hvPQOp18jkCw3frxOccNowqxgSBt/RpWqOdY\n", + "yvHzwxa/1fqbFK+LdQ4SpHIyIQKXLIqANG8Tv/+GISCWpZbbgAC8KqVdKRjXZ0dC5sC3TVUetHYf\n", + "K1pAxJ6q2Dzh+co8nRD99+SZdR/uxfXGEVZaHKS5tDF2XWYy75Vgooyskorjw5jMdmChYWf/Yb+w\n", + "6ZA2MYx7fcZNlT92qqzYd4yISMWIESNGjBgxYlwwvuuL1C//8i/bjRs37JOf/OS07cmTJ/aZz3zG\n", + "Pvaxj9nP/uzP2rNnrsP5rd/6LfvoRz9qn/jEJ+xP//RPvzdnHSNGjBgxYsSI8f+B+K7U3i/90i/Z\n", + "r/zKr9gv/uIvTtu++MUv2mc+8xn7tV/7Nfvt3/5t++IXv2hf/OIX7a233rLf//3ft7feesvu3Llj\n", + "P/MzP2Nf+9rXdryhGElS7LqYTz4iAkUm9H3SQr6g4MQDqijCtio/mLadbcLLXZI6LE7vFXo1DbKP\n", + "AZSWGtZS9KaO3XSv7nageIiN1cUcdFReqAJ791hq8URxZtvIdaFJOqE7ChG++nXBHbYRwSB2MxNR\n", + "3qYPkCphTPWM8nNRISa+IJhpB3Gmms4Sxu3EM4biYR1iJfxz1G14CzqOXjBl5sLWxSxAtk2t/QS4\n", + "u/d+bdBmWSWu9ClpSTW3yr/tCs3qpt45N6U7WfCyEtffDJQhKUEzs+UiOFong4+/t9/+OzMzmwvd\n", + "Mg4QNAu1wqLGCTxYcqEdsuy8ALuHOHS18cXLyygW/N7770/b+JvLB15weLMNx/jEh9yB+//6t38R\n", + "jot2InVpZjbgXP7lz/3X07b/9X/7fTMz+/Ef/4lp22uvvmFmZo/ue9Hgli7O4gqegb5Rp+wVhNcN\n", + "qKiTp05t1qegnYRuPjkJXlBHUlx5YJ9JUkiPeWS570Ldsy2SJ9aSlPI4HK8DjVouZLxOygIfEzkE\n", + "zcNainujssHRq+4P9vReaItLncsN6jNQGpKUMJuRFvMxtt0EuqluSc+JiBn9qkzDogzjLqm87/JL\n", + "8EASH58UIvJGqDqKgeuNn2cBD6oG1R4G8XabfNHUgw+O+umOODjso5z5/EP/pFqKkHN0NOrfhnl/\n", + "NlQ4bxeWJ7j/txu/r8qMRdv9vuIzQf2GEtB3UlvXsnSJc/fjJ7jGFPeEjlfOxepxlOB66q1fP3OR\n", + "VqdCrWJ46rzbgDZMtbjwCKoKvaxeiPP8EMcXCQpczgdRh9N7cVaJ3KRBMehUn52oVNHqMxrzaS4y\n", + "j46+VOH+WxTer6T2Mtk2ggtra6FRt4H6T6VPBvhiJb0+90k3iqAeHlRJcv5dguep/c9n+w4lh+dU\n", + "Lb5sNWjGQcZuDgH8jnpexuzz4rsiUj/5kz9plyWTx8zsj//4j+3zn/+8mZl9/vOftz/8wz80M7M/\n", + "+qM/ss997nNWFIW9/vrr9pGPfMT+8i//8rsdIkaMGDFixIgR4/+XcSGx+YMHD+zGjVDX6saNG/bg\n", + "QRD73b171z796U9P37t9+7bduXPnufvom84GqWvH+jsq4uNCXAVj8yKsRBtBmoj+zOb+XrjCCndd\n", + "u7CNaE45CXUF6YCwfAd9wraNeWoyBdN9K2/1SL/sRSjMNN1SRWyoWZfAbVdrU6U50sAFfWg7IGhi\n", + "YZDQsV2F8khXHTqBuPB5UfibdDEJv1lr0K+hwRv5uANTQVgv18C/RhFndqxhJTa663W7831ckZmZ\n", + "lYpQ4hq327DCKqQPE6y6ChGRtkiTTbXW4lT/TFbEuI5c66qhvbtBxfNYpXGFLc7aPEYhrstFGRCU\n", + "mdS1o2XFw5OvTdtmVVh8qHh624RxlIijfw/xbJmEMbmc+QqOY7EZXVg7r143M7ODQ1/9vfet4E4+\n", + "NFLrbhlWrgJw2Qz99I2vvzNtO0AdNwqVT04crfiXP//fmpnZ//g//Q/Ttv/uF/97MzP7yl+5KP3x\n", + "k4C+HV31Bdcbb4TzfPTAx26PFd5X/4O3U1lSqBraeiUyAabpv/qJj0/bzk7D/dyLTcFrcDsfpFDk\n", + "k21YOV+75ijN9ZeCyH5vz/uO99MApFFFxwMFszKuhjUSVfQ+rUOb9Svvp/2jILLdu+Rt8u7fBTuJ\n", + "9pkL4E+Q3LKUGn9ckTdApJai4T28HNDH2x/6Pt+IdPn2zOef/gTVHgTp2rB6hCAy3Tacu9bprGGF\n", + "MK9Ym0znOlRbqAQ5pf2HJuCgzWqxf6Arf6WoLywOhlLQdDwWtsb7WhNgwvkKIGY955CNz9NtG+6P\n", + "qvS+npAWqV1KR/NBmIBJ7cyEFUFmeGAVZxvQrL4XAX6L+2/m89Qp+qQofZy2eI4MgpJUEO9XeUBT\n", + "U5nDWlpTiCXMhvO+JNvQTiEt1P4Fc51QIUQYtZ7oZOcj/T6y7ijGU9N6wsj+XkhKWYqFBCmOs97H\n", + "5ABU6XSrynbcY9KgKR+ekijWobZlWaJdpdYgE9W0/m3XbXc+MzNrgL5qQlWN+3gUhI/JCOlOQcfv\n", + "jDn9PxabJ0myo6B/3ucxYsSIESNGjBj/KcaFEKkbN27Y/fv37ebNm3bv3j27fj2svl5++WV77733\n", + "pu+9//779vLLLz93H1/+87emAjcvvXZkr3701ed+L0aMGDFixIgR4//NuPONE7vzTTJaw3f87oVe\n", + "pH7u537OvvSlL9mv//qv25e+9CX7+Z//+Wn7L/zCL9iv/uqv2p07d+zrX/+6/diP/dhz9/HDP/Wx\n", + "qbComdkKsGwlNtIUO46JQ5YVFNiluPOmoNsWAmPWs0AHHW+d2muHcIwMUGgvjUMKRosMUxSeyfHp\n", + "gZHMRewKx2B1R03ofSUwKs8zhS9ULp5JM9BIjVALLWDxQkR0pKcSFQySqhIPqo4QtAj6yfMkINw6\n", + "LQZszwuK7aXIJa4hz0WA3rEY8/m2Uwic27SQ5rajeJv/dyi4KgK0PYgXDm1ZZmJB36Dw8aZzuJlC\n", + "+UGdqtklcj0jXYwp+pTzbWF7u1g4PZCl4e/Z3Mff09NAVRXimbICZaCUCUXRG6E7MtCdOUSvdevw\n", + "+BwU8Kx0emgGsfO9e75gWcAdPRMOaIR7soptT0CbVUtxwJ4FuH3VBNj7k5/6p9Nn/+df/GszM/vU\n", + "j/5n07Y/+ZOgh3zzE29O2y4dBbH5t955d9p25/0gtt5unSo8Pgn3zkYomEt7wSGclQIKobsLiI6L\n", + "uVO7BUTmrXjGvft+aIsbN9zHag538NONFPcemYAibsegvpeLMNbKudM+HNeF0AOsgHC28uvq4KKu\n", + "g/3kzjvh+HL9tz8RCh2fPbwxbXv03t+amdnTJ04LVihuW4Di6VRsDsp6I35XB9dDG6aSbNI9C22s\n", + "lEm3hlO+3DubTaBAm617QFUYMxTg5jKHsTC6+j5Ns4eMdYrNUy2Gi787kQ9sMD+3Jr5sOB7zVXop\n", + "Wpzhfk5FgkFPo9XGv7eYgype+fyfTVUxxFsP4vW6kUK2BYugo0C7+i6VTNTx9jfcp4V4e434bSWu\n", + "5AmOb+K31bXBI63r/DwTFm1mMWxxAqd8YSd/i30s9BM9yLK8Ovc9LTg/sj2FF8vwnOgHn0/pVUa5\n", + "S5op3YokptLnP8oSMqVsce65PJI2qJqRyzhh4kkuSR59HeRDszmTzbytO5xTLwlIXUcaV3jx8bwA\n", + "nT5bwyCifJzfrQ8d2a0PBTf8xEb7qz91Sv7b47u+SH3uc5+zP//zP7fHjx/bK6+8Yr/5m79pv/Eb\n", + "v2Gf/exn7Xd/93ft9ddftz/4gz8wM7M333zTPvvZz9qbb75peZ7b7/zO70RqL0aMGDFixIjxn2x8\n", + "1xep3/u933vu9j/7sz977vYvfOEL9oUvfOG7Hri1s516aTnektte3anDv5vWBagFijPN5x+atjGt\n", + "WooO2bIK+zs5cwfYnsgJ0mV3XJT5mWxjhmsjKcys8dd1KkrFKqH15uQp7WRfEhGhwE5WcHlBEbms\n", + "jIDwqE1Ej7fqXN3G8b1S3K47rDB72d8kBuUCRkWHI0SnKpuDOLiTmoT8bVlJWjH3Ky/NdCXvajkG\n", + "oCgV9DNlOIFT+mie6pzCpmJRiYtzElYOlfhAzHqI/c1RwnE4xvUI6pYxdVyc8qc6gmwUv9S+C224\n", + "rv3712+9bmZmJ8fvTNtYC6sWFW+KFdOQ+qquYRtrokIfVkzbhKJzH+tnSEm/8arT3g/uBNRnX+rF\n", + "GepePX7oqMb1oyAAPVbx9hy1pmT1RSHvzZcCqrQSwfLZOqyWj3pH5N54/cPhWI/dbfzhw7Ba/MEf\n", + "/CE/z4f3zcxsvfLVN1f2N2+6JUOKFfHhIWpoHTn6dvosjIW5WBJcOriE8/T+PzsL6Mu9e36v334N\n", + "bVb7WJtB+Ku1HmeXQ/uPI+1P/F5bQ0R+9cgRpBpp4Fev+DXc34Y2e/db35q27VdhTF6d+YD6yr/5\n", + "V2Zm9urH3JPv8OatcHxBeJJN2B9d7Pev+Er/4Ch8//DQ+78H6tJK/bNiHkS5J8+8TZZImtisfUzm\n", + "rD8qTICLbNEmouwmwqrp/znQDE1N5zyqGt0ZENO28TY5QDp/0TsiVaAvWqAUH4gTdgWR9VxgDVpd\n", + "dJKU1ACx0zkuMQqQxWqC9g+CEg/4Xl5RCO3XkDxnnKRAcGaSAFNBjL8R5HSOOTsXt/OBKNFOpYSA\n", + "Eo64/qJwRLYBq9IrIkcnctk2zXFap3V6Psr3UlrSyDam+gvDMaJteyS05HMRcQMJbUqfu/OUiQp+\n", + "/Om5J+eUoX86qZM7WUKYMxFMJHt2HJLXZpU/68aEz3MZpz3uTyUkcPxeq5fgeT7siO3DsbTKRiaV\n", + "PJ4X0dk8RowYMWLEiBHjghFfpGLEiBEjRowYMS4YL6xo8dC3O/bYpNZSoWcyCJpTEWA3LaiCxKFQ\n", + "FqtUYTML/eapC2vbNkDERRGgWxVR851SrDMmYV8isB6Fba0U+aQYcxzEtCcnVaVUIWBEUFwUn5u5\n", + "i/lOdgCd0AUf7UYK8QSKB7TbboVGQnvmIvZj8WdCnOo7Vab7uD4t5ExnXxGMgvsaGhWA4jy08aZ3\n", + "dBE2wsdKRZn076rpxSN9nSSBPipzFwzOQel1o0Lr7CfxlkLBU9ErWsYz1ZqVON7kldMrFYljHvr5\n", + "3r3/lpmZ5YW3dTrs4VrEC4hFOOUEWo7xHWgbwt4kjOuTZ378H/r4PzMzs4d33LF8MQvUV711KqKG\n", + "t9GNa9embSwWPLn0mlkJYflyT3y5WLQTYu+78KQyM/vUp4In3N/8zb/340PsfXDgLu7MzH37nbf9\n", + "e/Nw3x0euth2C6+cVCD4fRbSxbhuRJx95Ur4bCEFgms4dS/nR9O2w8vhe/fv3p+2naKQ8dU9pwDo\n", + "3r4vPlJzJA3wHlLaZwZvrdVaEiDglP70gYj9kfhyIAko7XEYu48bv55b1wMd9/T9r/r1H4Z2vHTN\n", + "6btsBC2Bwr/Xrzm1uH8Z37vsfZ3UpKz8nujgGZ48eTRte/QACQBSgYCeQoXMMfR7yipWgJg+mrzv\n", + "slwlA6RsfB8s1puJiLiHRCETyoj5Qa0mxYDameHxdFB4fw2Yu85q/36NEyxURA4KNuv0EYd5r9d5\n", + "gv6B4u2E36ZFOA91NicFrLKMSQyfersysWdQIzc4gPeD0318ZumzK2FFDRRU3ooXWDMG2k+rXSR4\n", + "1iiN2cH3qZDJLmPx81GpWtKyPp/3PQXlMlFBDjDm9FvT+T/s7+mJ08iXDsKcMEiiVocqDoP6N07X\n", + "JufeQlCuFU3Ir9KXqhd6GnPXOPqznk7siTyTcwjvR3lOtZBvDDIndfAls973Z+Lb9byIiFSMGDFi\n", + "xIgRI8YF44UhUlliO6t1uolqfRuulmZSw4crjXYQcWJOREBcvFumekqaPtCHdnJAFvQFb6ma6kx7\n", + "hFFEZw1WTnnqIlouuhKpVzSlieaCZlFsjZffHQEb3HN7WcENPZ19tdYV9i9ic0Zd66qCCJ+4CKM9\n", + "uejOU3H9xY6TUt7MIXbNdxAcpPWr2BGjaGjl+LA1SE3e5Ec6qrvYeRKNA01ScWaOFfmpidj0MsSR\n", + "4tieUPjZejvRqXeQ1VyO61HrCI6PDueu9RKrMSAdSeuIGFPn00LE9gPHjjjmos127RfQJokmJRQ4\n", + "9bD6/Pir/2z67OvfhGN4dXva1tVB0Nlt/Twv7wWU4vFDXxFeuRyQk630CeuPbTc+dq8cBWRnA7To\n", + "1k0/1nvvBmHnqyJ2p4j4vffe8eNfRg2tnWQDVAAQ644GSMdS6n8x/X4OpOtIylGtUYdvNnP0iQiG\n", + "JizsXwqC5UxWmhscK5fxPFucT1Ony/kWCN8g99BsTqsFcT2GTcRSUKIPvvUPZmZ26/br07bjgjX5\n", + "HM1q4Gy/d9PRpLOTkAyQS0LFZYjLe1RxUKuRDMdVS4RiEdosGUWwjL8XV1+atuUQ/p8++Pq0rcKc\n", + "kM/E7R3C8xHzXyYoHcdQuoNgAU3W/kctSq1KMYnWFTlpMZ+YxxJz8IjvHUoK+xMwEkRQzcxSuGyn\n", + "ktbf16y/5/dahvu/EZTQUCkhl/uZDADRSXV2J/oySpsMGd3WHSXhPJ5ljv4Sdc93rANYE9TbhOUp\n", + "6zOIzgVp7CHyJ+JkZpZAqJ+pTQdT/WU+SzHvDjuidFxr5m3cjugTrX+HVwXOobW4k88KJmB5uz49\n", + "DohtXog7esI5Vl3EcUxFLjFOsl4RMbj9d7TVSb/9o12HAM77khQxIKEgE1d0qtH7QZ8d/MPHWPJd\n", + "MKeISMWIESNGjBgxYlww4otUjBgxYsSIESPGBeOFUXuj9RPVYaYOpA77UZyb504PNSguWYtQegRF\n", + "Rt8h3Y/CfYQ7JzGdFKMdKYBT3w1wWqP4s9A9tRHfk6nwZK2VNOEZUvXyW1CFdN0WyJbCc3WiHht+\n", + "LlAwzLeGRAV7OMZwHjJOxQOqgvdTAfF217kQtwdVmifi2ZQHqDoRf6Q+obOsVD6FUDARwWAC2nYQ\n", + "upMOwKO6HbOAKKDyqnA4dQunYh2k63U4z+W+uK2DisikaG+zxfGl74gjqyg9zViEFo7Raz/fl49C\n", + "kdvjUxd7L1EsWLSmUkBX6Eb0bSKi+AxtsgO3Y0eXlh8xM7N37//V9FmVBcqqa079YICbZ5lTMRRo\n", + "X7nkwm6ywUojFmjbS1JI9+wsUCXPjgNleOO603jHk1eWU4EsYH2kfk+n4fyqyu/TGhSt3pMU9HZC\n", + "wZYlqM06jLUs9Wugs/9m615YVy4FGrEWL6QUXjDXr3uB4iS/youeth3sH+JfFdvD2RyCdoX4SUvO\n", + "9sUJHoLZMnO6cX4UjjV84GL3K6+EQsrP3hVhMeaxPPExfnQ9iM0rofZS9G0GumnvtQ/7OZ2Bnpj7\n", + "9w3zWbd1GrU6QFucSnFlUJsLoUrpsl0LLUNKq6A/VKqSBfwr1GIFmk3FyaSMRmVR8J9BJBWc71qh\n", + "gEmtkQo8Ec8mzn/zmfc1XbnVl3DA/L9RHzEUvFX5yLbG2BUD7CnJiZcjoucpoUZpzATtL+7kOe7T\n", + "uvN7h7WvEynM3sE9PE39+nu0cg4X9a04u9dbUOaJVweoKs5nOv+G/hzFi4k9pkkBk3+a0Gie8CNz\n", + "11QVg/O/H2u1WmObyCjw7CgG9RuEtMRk7OL4LHwfvgdJiVDaTNCygpSd76LZ8jxF2pNx/he/s4Ly\n", + "GTkWT0N+686Cfk8MkdqLESNGjBgxYsT43sQLQ6TabmWpoB8UKqqwnOn6naxqMnwvS3wJwbfFRBAZ\n", + "vp2OO/X0+GYP0bG4yQ7jeRFlMuL8VBSOFX7dampm2E+99uvJlxBvN7Ii4Js+bQ1kuTbmVKDLm3HK\n", + "lY6sfiiiFgF4D9SjF5sC6ymU9GOkcLEtDQ7X8h6dIDV2spcwF5b28ma+AKrVSFsPSKEvVLAI4XUj\n", + "6b9ziGcXpffxPtLPtxCMqjiR7S9OE1bD9Xm+9BVphZXLUtC8NUWhrdRQIrLWiU1BhuvFyuiqiJ0f\n", + "PQ7i7cVS+pV2GoL0jGlY1erqJ4OgNOml1hVTx1NBRCCKPbwekJhu4+jLAijtKCvoHk7oc7EwePYk\n", + "/KaRlXsDpGVvz20Knj4N32sbb+O9/XBtBcbuyYmny1+/HpCWWuq6bSGYXYljOVeaw6go6fnxTDFs\n", + "NZPkjS1QR9RG6yQNfQ6ksRNxcIaVZtv7/XflCkTZmSOsJcTrxdzHWoHxUcx8G8HJbBZ+m0tyQFnx\n", + "fpIaarivhrU7u1+GoPuxOKZv8fflV79v2nZ6/51wTKl/VlVInihl5Y5pucK/w6m3fw5n90EQpPUK\n", + "qIqgD+uvBZf1cs/Hc5nh/lv49XDspFoTFIp+VlHQOmxMjihKreGGc5P7j6hWvXHkcAAD0DaC0kzo\n", + "i8wdSBQ4bUIbLgqxxMFYUEuWyT5d5tOiCP2zWfux6oZp8orco9amFABlgkiPOayQOamf6gqKiHog\n", + "Iqf2A5gTZEyskWK/7fy3Rc62FoQJ1jYt2rORGoIjkLtR0L8BzxVaqJi5ZRCF42ZmYxL+LmVOJkvS\n", + "y/OsAduQl/LsGkP/JECOhlZsYvhTffziGOmgzzMcS2x/+gzXo84R+Fym2IkJKvDg00M1qHWrSVn5\n", + "DOeeCNIH5qgX66Qe19q3kpSF547OZ53Ue31eREQqRowYMWLEiBHjgvHiNFJjO6FAZr6o6IRnTcH5\n", + "DrL6nNIeBabK8GNNNZ/SdEfVTYGjTfjGqahSWFX0vXL1hm3K/WJVpfXvsErIJCW/qfljNf2k+xrR\n", + "IuG0+aatKBVW9U3tb9AVVpONrCBYL6hXUzusCBWky8Zdfrss1cAMxxX6mteTCPyVsfq5rOBaLCdU\n", + "j0VpSiNF0qmNEBmKlSX1IECmal9VGdKJNdWWPHwjKekF0DwaTpqZ5TXM72T1N/YBxeml30voUFj/\n", + "al37yjADWpCmmgYLVENNAqkXEzSzgiGnDGdLx4AOzCuv07aAncOju3fxmXfAugNa0PnxmRreaa0z\n", + "rI7X0nZc1aXiXXHtMKTV37vrNglPnobffPzjHzczs3ffc6NJ1k5biiHmCfRQWkSNmgtd6VPzMhMz\n", + "VZp0MuXdzGyGPjs7C3199UjqpQFBPlg6+nYG9EV1DtSZsb6ZmdmCppty/XMcP5X1I03/qmnsSGo4\n", + "kM5RkD7aBGiqfwPd3tVXXctUA32y0lGyvRuhPmi79jFGs9FiJvXUcG/nsE4ZVoIqzMI1ZgvXki0x\n", + "r23vea2/GaC2d//+307bbtyAbuup10RjKnwplhQ1UJ9KGAM/t9DuiSAiNC4dBSdYo06kjgmCOHmi\n", + "+sZw3BNpE+pgZrBO2Yim7hDnuRJ96TOgr7mgRDynVmp9bhsix4IIAX3rGp13w78p7jW9h0fUaVO7\n", + "BA6ZVlANWiZ0YhzaQeu0ES3bFdR6LARh6w0oHu0MRJDZ0NR5EC0rER5FyWA1M+zUlQv77aXWJvtf\n", + "50nWnRNvXCsyTORsjNHbtUHtxMXc73UinFq7dsJt9AHQE2FS3SzPXeZp6AsnA1PZR4NnV1OL1QHs\n", + "IbJCkKaM7a59jblLnnE1agcWMnclOwYd5yMiUjFixIgRI0aMGBeM+CIVI0aMGDFixIhxwXhh1F5e\n", + "lZZIGjz/kjJQVhWEB9XtHO9+Wn8PYjyFAilarWYuVNx0M+wPu9AydIBFc7VEgOgvUXQSMZdUb8sC\n", + "jN21Qu0BWh1VxAa6LaeYTpx4mRrei2NrS8hS9ruF7cOobsd4H9b6TwPEcZ20Uw/ItgRkrHWI6Oit\n", + "NdwKiMxTcVHvafsg0DodgwcRNqZoO3WWJwRN2NnMrIVlxHLvEP8XypICQ7nWBvD4vBXKANReJvBr\n", + "RWftXujjEXTP6HYCPWD+w4NAu9179GD6rIR4PsvERZmUjtITSdjvpvf053kZaLROBlky9ZNDxntL\n", + "OJCfBRG91qFbgiqZpbembTeuBXro/rueap9MNfz8nBbzQCnRmsDMab7r1zz9/e79QOU9eRLonitw\n", + "KTczO1sFuoU0jZkLtm3HaiREJxTYlNbe+LZywXYUsSmohcUy3Kdncr68UdWJvAO1pKnRrBhQCi2a\n", + "oS1y+S0pvUTSv0np8nx7saswWmfkwo8nmE8qcZZes3alfy2fBwfyVqji+eWbuB4fJ13DWl9CVc/D\n", + "eOJRsxtOBdvx4/D91MXuBkq9FBF5swq/vnLZf3uMsa21xkh3qnyCLtv8dxR9QF5SguDbGtbdVBoP\n", + "92KZ+zihQ3oromzakxwufRtpYaakD+Li/XQdtqmtAB3tW2nDElKB5dLn/6YNVPm28fFMmn8QO5sc\n", + "yRAjqCKlLHnqrVZR6DH/qf0CE4qG87KUTJ4x2y2dzSXxilIRzLuFJCdwjGmyD60JNAGA+ygraVc8\n", + "XHsZqLQHaoQq47bMlAJkpQxa+Ci1Hr7X1L5tsQjtDKZ7rAAAIABJREFUX+be/nWHfpRnHB8teo/3\n", + "6G+V5Uzynek8xf4IbdHJM6FhFQmhNosS1Q5k/un4TlCLeH+kBEju++8COUVEKkaMGDFixIgR44Lx\n", + "whCpotyzRETcTKdUcXSHVUIhJo01TPpWG1+5zpBiq4IwpozraiqFwWEPEfM4+lvwgO93orZOsEoo\n", + "xvNCM32Dpog6ySStsuc+RJRMIfuE0uhqhSZ0fgyaVY6Dr2o3QN+WV2T1zVT/nVpjWM0NKiINq7hZ\n", + "EYSt5Q76hpWmWD1QgFnMRLAIdDApxKRuWh3INmwqRezHdNJMDAnbBisNoBmlCIbXrALenRf2b7ay\n", + "gsJKdzLcM7OKKKEYMiZT34qdAdLOV01Y4c91VUckMBdTQxjMZVrXCUajmUCX+RhWYpXYedDgLzNf\n", + "pa2ehjGzh/T7QcSxS1Qcb8/8fGlcabL6Zt5Bmfv3iCxeveKIxH3YObx0+5Vp29GVUPftCQTIr7zi\n", + "hpw5bA92kCaiFLpapflrqqgGVrU6xljPUlDiHvczzRwbSfYoMIi2W72vgNLNJYUbw76RVfIciGQq\n", + "ZpI02NWalLyPmw3EqaUYEyJNOhf0rR+wqhajVzZ7IvU/2wWMNgX92qwC6ljuuVDcVqHNtpImn0LQ\n", + "zvu/q91CoLwWrBbab3xl2jYCza2fuXXFuA59nYqtwqJirVGZJzHhjIrSYd4bOcYFaZrqxYnYuKqQ\n", + "xCHMAZHDRNEX/DaT9PfJJFLm7gLXPQPCPpc5cQ9WCBsxqVwPZCR8W455dzkTS4JZ2FGz8fv0ePXE\n", + "zMzK0g+yPQvnvrcfziNRsfdIM2c/J46xRuYkIvKW+DllNHgWRIYoSi/MAREwJj6psJz18lpJ4skw\n", + "/+r8z0QRcaSYEorUzJlzsaK0Xk9R69SGZwctBhL5bJySuPxYFGpXgoixhp4K0NM0jPtM0Ke247zj\n", + "+yOLQgshNdCk8H0UNJm2BnmqKCm+rmbKQB07rZPL85QxNl94MsjzIiJSMWLEiBEjRowYF4z4IhUj\n", + "RowYMWLEiHHBeGHUXjbmVogTcQ5BbyPC5gFwotYL6yCsU7+h9Rp+O1pDaNrJebdvg9i5UhgfVEkm\n", + "xzd4Z+Spn+cklFYo/DkeVBPbpXo1wr2k4vTcJqGwwJ4U/QkU7rikCmbP138qQZWoKHLA3y0ou7nU\n", + "fKogaFx24mcDvxOlVsmUtoNjy23HWksqFIcAV+DWzTZQFJ3ApB2cuknfFCIYJsSdqLNyF9ribKMO\n", + "7OH8KqHx9ueBslpl4vY7CfUVbqYvTLF7gaYUpHQiPk/k1ily+p3519KUdJ8Ly/cXENSvve0m+hpC\n", + "+ERoxPUKdKf4Y43wx5pXPiZJmY5CozQ9a1hpokYYH6szp4roizZDsTH156IXjDpR07FcxyT3UQg8\n", + "z+8VpYhCp2aUtptoPni3CGeyBO3WyhjKMa5ToTGLGcXZfqyzs0CHX77swnpSekqBdG3YNlGL4kVT\n", + "zeH2L+7cCcZELhT0AOFzLvNUlrKunNyTM7hY74idUT1g42Pi7E7wFLv84ZBYMJ76vNJuAwWb3HLP\n", + "quzu34d9iLB7W4U2Wb37H6ZtS9Ri3Mq9Q5F9IT5SHekbzE+Z3P8LtIkuwevmfF3TaZaSpIzZDE71\n", + "Mk+yzdQ9v2YfYE6ciYyihKP7sFXH8tDXudDyGcZHL4k6C1CQtXCFz1ApoV4LLY0kp2YL0bkYSfWg\n", + "9lmj08xdt/XZwWSIQeZ4Jp4UmSbAwDOpU18qeMWxooRMP3xmnQrd3eK3g1Qs4L2+41ifkMZVb6/z\n", + "spUMkpdc5lNW4ehwrV0v9wTG+sHhzWnbJH0RHq2Cp9pOUhaeCZn4aFEh0YpX4haTq8t31Fkd1KJe\n", + "F641k4QuHqPfSAIYZRZCt7JPdhzwu/PtpBERqRgxYsSIESNGjAvGi0OkLLc8ddFpgZW7ruq2cLTW\n", + "OjcU+Q5Sf+zkNAgGZeFkeUa3XQ+KGJnqv18p0hKOUQ+emjxYePvecQBvnpPqjDf3NpWVBt6IB0nJ\n", + "zNDcXLntuKXybVprE2Fdl6liEPW09G2ZgE0ib+QFVi5Skss6vOETpFIxXzFnuqxv61tW/HaUgmie\n", + "ptDyMnpBc+g822kNKxz3+MTryRUYAx1QnU7q+s1Qf6sVe/QM6EMjK8img02FODHP8L20FAH+KVES\n", + "R4lO67DCJ8BRqsMw0IJc0EcKS1tx1i8hKM91pTmJscVtvQgrsjqT+k/sTyRbdN3x9Nl8CNdwrfSV\n", + "3rNnx/i+rEiZui7jj+jUZu0rxxTjiAiCmQj1WX9OhmQ3paHLShffH3fuLDr1i/0EEBu1KeCxElm/\n", + "TZ9jGaqoYgmUNJcbm47VxY79CNAHTdTA+RGZMvOU7ExQLyKhFNHv1NeC2Fxr/XF8tCIOzjDutU0G\n", + "jI9Erqc7DX3XbryPq6Pb4Xr2HGHkyOruw4G+knTxxyEpYhSbihY3liZlDEi82GhNzJMw1q8dXZu2\n", + "PTsL813TKhIJOwUgoakgnQSdWzlWAuRoXgkiB/uBaiZJOeggTdRoBVmafou+YOLBVqDes23oz9O1\n", + "zyG09WjlGvKpTqLck0B/dd6lULuVfi8wTxOFUGE1q3G0Mq8TCFSrlwGIfSL3P5FzrRQxwDphdeLX\n", + "SMuGqVKHtNf0TFDmBp2SdGJ1QJeWQZMiwLpIUlCJZARFfXtWqtipnVnvHKuXZJcKSGtZeltXqJNZ\n", + "b/17A54FKrYf8bxX5KjA/dwKOr4Bwp5P96laB+H65DlZct6X94QEfTer/N6pUTVikDnBLVA0ySYi\n", + "UjFixIgRI0aMGN+TiC9SMWLEiBEjRowYF4wXRu31bWq5UDH0oEkTgewBz55txcUX4j1Sd2ZmJ2vA\n", + "3SJiOzoIztJF6j5OFWDMBNSG+mQQ4jSBhzs4dWe5iDMBY9crdSAPx22Fgqwy0n1aNBIOtFNBSYEz\n", + "QR/lImyknjcTGiHFbwuBHd2J1oPnaeJ2vQXMupgH2LkZXPSaDwFOViqmoKBWUE2izKl4QSXJGf4V\n", + "sR+dzdVbCefSCFUy5vCbgbfTOAjFwILCcqyKBVKFAk7g7KwC6Ao0WiEu6tvkjpmZdVpcNKV4HA7D\n", + "pQvhh2mdIYJNiMj73sfEWGywL/9tAa+uIvVxSv8aLVDa4RgZ6NOic7p7SrIQiH2xwLhqZEwAMtdi\n", + "qCyqqs7qpK3WQnfdvBEcuJ88DfS4+q5RnK33SZqRRhEBNO4ZpcxmoHlaoSDLit4y3ia8NHo85SJO\n", + "NxaGFbExOVhh8SZKWa81x99DJpQFtikpyeK7K7i3z+dOsbUQXWey3txCeN9Lge4SRZiHTP1xIN4X\n", + "sX9zRh8foe9Pw9xVSBuT3S4ugdqW8TJQxH7yxI+/DFTF42/83bTt4ErwsWquuyv+KQopL/d9Tuww\n", + "B2nfTfQ15slCfZ8y+HgV3ocZaByxW5oSMFK5d0gHjVrIFvNept5iG46Z8L2N+IPNIHa/NN6Ytj2A\n", + "B5yO6yoPlQp2KCAUEu/FKZ3C70Qd7TEoU9CCnQiNmfgySmUH3jKDFJwvce+mcvyUNNvgz7hmC2dx\n", + "lYCkdJanFETPDc8QEZHX9AIb9JwgrFZ6aqI5xe8Lz7hExi730/filI97fKLnxDORc/Fo3q5pGsZk\n", + "WQktifbRpKy0ZJKJyEIwdrYyJhv4Io4dinaraRXbWu6hDM9dmTqtKEOyRZV5Agr1AOp3x3mikQoY\n", + "Rf6dX5UiIhUjRowYMWLEiHHBeGGI1Ko9tUWprt9YrZYqWA7/lqWsVoD+JIkL25aLsPo43Tz0/TFN\n", + "ttD064BszIE6dJ0jMtmk2JbVB419E38z5Zt7JqvkmqJseatmim+iAuBpxQIxnVgTlBBl6spwTnGy\n", + "pAazFmAmSBMbahRR5rQfrX+F1XmDdO25+cqIIkp17J1qAYqLcQKEKROkhehYkYv9Aw47irNtCjdo\n", + "dZYd6NpMJEJWhiOE/fO5j5MRLr+XDw6mbW3LWnN+PSUckPsdYWNYpWxExJjNQttSsDurfL9T08mC\n", + "kBeW5ipYRv23rLFvjyRVB3CsiFUUPIS+oBN0abpaRVr1vJXvU+wpYnsgfOpA3uHkc02owPAoZRsd\n", + "zelOvpVai0Q6VcS7B3sKdbE+2A/3k9bka3A9lQj7KTLPJU1/as8JBREEE6JTTeHeIHVfBcAUym/k\n", + "+FOStKApa7iHLxaSPNLzLFDXUuwyWKezlrZePQtI0N5Vvy62u6baFwXF/j53ZLgXUnFR3qDG4ezl\n", + "N/w8n34zbNsDMrHvjv10IE9rRwS6dRCvLwRpOn0ats3F4mWA7cjpsTilQww/DOcREVpC2HN0ttr/\n", + "PeaxQtgECoAVfWYfsw6mmVmF35yJ6DxNd5GLUub6WQmk5UTqj8KeQq0GTlahXTP5bY25ZpT7NCvC\n", + "39VcH4W0LkByiiDiA9p/TAVVS9b4lcyTsDDQGnrjEMbMIK74U+q+/Ha9QgIEfppLe3FOEkcYq8Ds\n", + "KPo0WcIImJvi814Qvs0WSKwggg3mqU4sFjpMHkPH+9rbmlUGEmmTBHOt1tqknUHb6ZgAE6FicybA\n", + "VGLdg76gPYs+/2kj1Iv9TtsA6ZK5roDbvQKii0W47jbV+xkI++jnWRTK95yPiEjFiBEjRowYMWJc\n", + "MOKLVIwYMWLEiBEjxgXjhVF7dXNim8L9HEqI/nJxWm0BHys8msNbRp1I92co2il+QzVErqlQa00d\n", + "4MG9PYiCO6Xd4E+lkDWhPRH7EWXNSqHR8FsW4DVz+DTLRO02EkYHFScQI6FI9asg7K50H/2jWmXR\n", + "RNDt504PEt9Gqq7DdfW9OixTsKc/gD+NtDXFuIM4y++VQbw3dO7BNfYBCk06pRYhnhS6MaW3yyQA\n", + "Fd8TnG8q/b+EsFZFwSykqs72CYSVgxZSBty9PRMfn5xuw6DMpPBsASde9YzZgmbdMZtn84/eJhsI\n", + "FfOlQ+Y54OhRVLkZPIJqeja1Pib3svDbrdBDY0YvNHHdxVhnQWczp4DVuZh/VgJ3n56FfR/gnjg9\n", + "9WOVEBGrOJuC8V0fobDjwwOnoB49CgV0r0jRZNKRzyskTCG8UpbujuzHp+hUPWsaOmvLYOf5rdfq\n", + "Sg5/JPE7YtFYemYNpvcSPLMksWHAseozF3vvoUBxs/JjDbjHCqGAezr1q1N1G8bM43vvT9sOQQF2\n", + "cH22tVNm2cgKDL7fs+K8sNkwj+WDJkrAsVrkE6R0OynQOmLfpEoyof0o7Femgz53Y6fUDkTRQuMm\n", + "GasdaKWAcAx1L2f7JKCiZnOnXfJtGJ/Jzr0OzzyRapzgeyzQHj6HYNmERoRoOpVqB3S2JgWejir2\n", + "x7G0XemFJHRzkcALqvdtLb3iai0GjHEnfnsd5lZWCpC6y9P8nEvReBbV7tVFH0kZuYjiSe2tOqHv\n", + "09BO28bnjhr0+notzzgWQeYh5J6g8D6VZ90a/nzrtRZohohbHl7VAmNHa8BjzpZb3BIWZsazqBfP\n", + "LBa8HkRszwQB+s6Fawh/J5kktPWcE8TFHaL5mVbUyCO1FyNGjBgxYsSI8T2JF4ZIdV1vm0ZqflGU\n", + "KunKBpFf2zrSUeQQjLUiFIcY+srSV78nm3vhe7JK6+E2u23DW/go7qxMXVUR+TCGVcUob/B9AqRJ\n", + "xGlJGlYQlaQE11usPkY5BtxZJ6RNBHMlUBddaY1wVs5kVddh5aA1wXoIATMR5TJdtZXlfJEHhIW1\n", + "oVoRh6aonVTpdfG8k/OokoqIM6y6l6Lia2usnBa+rdlSqO5tTAQuHZmaPH1kPVZ9vdQGu3olrDD3\n", + "Kl9pLqvwo9Otux1TlVmlLh5PUTNxb+bIyQkQhgrX0Inrd1EALRscwWlrCCal/UekEFcLSatNQhuv\n", + "156SzVpjpqm+WInOS9pfiOgRK8JxKSvynmJXSQ2m268gVwn6cZAVqQFpWIr9wBptO3AM5YpgYBUq\n", + "ju1ERxcLRwRXK1z/gZwnUBKiWuEYcGCW1SdRJyJCqaBlRKu0NhxX5PO5iPJxTywXjv4RnWqkPxdY\n", + "nXYigG0gqCVKN4rVCFfme5LC3cFRPZf76gwC/T2xbmjr0BeKZvRIPGiOn07bMqaEP/i6H/dVCM9X\n", + "4bqXufdrewlJFPcFET4M+30k17XEmFmt/HuHh2HuPJXafT1dUuS+p0M0ETwV7NOdXhGJBEk8ZSWo\n", + "Cm0vBCWYarftWC1AUC/zNBGuGY5/78QR5Ltn983MbN2KszlrPIqtQIt6hm0vlSo4x6t1DBHDVJBr\n", + "bJsXYe7QGqKsYZnsYBBzfE/E0UC1ErmfM6DzvVRvoFB6EOsc1t2bNOFSc45WE6UI0HvOdbknG/CR\n", + "odUmDPdxKUzMGU6l7X1MMrdkFCuWFvYsCRihnfyDNoz/vvJnctewUoPaCkCwLue0xf25ECZmRL1R\n", + "dQQpZ2HbYiSr4J+xL7SGIWHsTKqnEGFdaAIO2r/ZyHMac7e6rkz2SP+RiIhUjBgxYsSIESPGBSO+\n", + "SMWIESNGjBgxYlwwXhi1N1hrTeu+Tx1osaETeBK+QO3gGFs3UOyrAmwUPBUKbAH6pm2dlhsg8j0+\n", + "fYT9+/mwyOVMhNsZYMxB6TnAg3nu8CSFr+qtwmK96sCclnSHxTFNBJb4fjbTa6VjtHdTC5pRrY2S\n", + "lII9gZaxv1QLCYM2Je2irtN08U3FY2UqULvjRQV/IikGWgD2VBolAVS9VbE3hIKJilcBwY6A1kcR\n", + "9ve4nkH8eWYFi1wKPQAMeKbQfhfokLmIDasx0IG9eJbM6U+CsajXShE3PWHMzDagkcZeKTN+T5x9\n", + "QdWenbkr/9gGOiwrRGyZh/NLRwr7va8P9gK1kIk/FgtI972KbcNv5+KPlMJbZhSqeAE/rs3a6R5S\n", + "eqRxtPAw26KaORRO9/BeONh9+EitVo63z+FAnYlgkwVHk+eIzZMdrgDXgO9tNz5ODw4Pzp0ni7yq\n", + "2JyU4k4xXhZNTvW3oU1ILVbiYJxDgKqO0cs9FM1upNoBzqXrXKpAurE+dVqKdMPy4LJ/70mYi1K5\n", + "o9vTx+F78H1qn97xYz3FnPSSO3uvHwa66+Da9Wnbyb33wvHlPHtQS1txwGc7dVrdHF2bTn0ngmHc\n", + "47OZSAZA/a23Wsgb3kJayJvyhUopGFL74mOFZBCOk6Ol0/NPcI89fOY0Ug1fvEYSBeZ5GBPr3sfk\n", + "iGtMRBRdFji+zLHFNCZJd/v59pCR9FKMOMO8OtQy19KfbNCBjXl6VAqQiT9aSByfdfRH8v3OMIfK\n", + "9DclnmSF0Kh0+zadJzFPy30yUAAv88mI6hrqt8QbdOrORBMLwhy2qX38t5vw/c1aqD08kxLxQOQc\n", + "k4p8ZLGEBCURCnokfQ/frd7n9dUKBaKVMgbdmnbeT3z+qKSHw06rDQwoJN+JAzuF//+xiIhUjBgx\n", + "YsSIESPGBeOFIVJjb9YkYlcwBAShbH31USLVWwVj63VYrS1m6nYd3o5TedOd5UCzxKm5A7JRA6Vq\n", + "RGA4h7KsEqQlx/FlQTqlGOsKgiLLYetfLGdIv2/1XTW8pSeTwFpEhBSljrrUYLq0n1OanV8lD1CM\n", + "DoMK2+lE+5z095Lon7gew7Fd38JTiP76RJE2OstLSjgEhVXhIu7TBunhkurPFYOiD0xTX+FfFfun\n", + "SCEu5/6DDUSkVeX9P4lic//tM7g3l7KtsLDSycWmILfQFus2jJdE+qSlFYK6I0PQq+7kxQz2F2In\n", + "wbqCWn+wgQBzX92+JzQV56boD5CYURx2DavqptNVLZ3t/WsJEIFCbQKQ4j6IJQhF2yUskBVVZCzm\n", + "IjrtaOuh4xTjX1bOiwVSjaWz6Sje1LoiBEqzpOtwf+77Tz9wqwG6bi+XLnafhOLqzg00ZZ6LiBrJ\n", + "GFUhqc5AaYiqqTs8r7AQVG0Fd/Rc0+WT3e+HHaNNWh9r3UlAPbO5I1IHQIROxL38DOLqZYX6l42u\n", + "zIPIOt1IZQXU3ZuL23QNNe7RZT/W4wcPcY2CHMH5XBEZjicibYOIqHmETqw26izMp3npfTJinhpU\n", + "MYx233E/mJJnfIwnGAMzJirs+TPhQ7AwyeWZkPUBsatrZzhaoFNpL87WBW0avE8K3Nt5rk7l+AdM\n", + "hN5Xk/BeEFkmMaWFJAARRR28XYlEKcNB93a1MyHrwbk+kc84PvNCS1CwAoV/L59qUgr6hOQdrVM7\n", + "DqzJeR7hH+TcqxmZmPB/tfVgAkhTu7B/vUKlgFquf2D1DGFieF213Kd7YRwllVpHrHGJYb+a2MA6\n", + "heqinkyoohwf3dPLe8eASho6x/I1Qp3SGxkzz4uISMWIESNGjBgxYlww4otUjBgxYsSIESPGBeOF\n", + "UXuJZTaKd8YW0O4sdYiNLqqF+JiwkOm6cRixhBg3EQqKfhuLygW4NaiNFD4+iUB3dABW2JEOq6la\n", + "KxMKHJSygcdG5tBukbBAr7go96RqQO2J7xNpN6Unree5OKw4wtOol+K+/VRQUn5Kx2IpkFmRooAr\n", + "7LxyKH6As/hGxKmkncZUbNTx57wQd9iB1KKfewk6aHMmMGoOF2HxZSLcSvaiFCEoxdujiK0fPwkO\n", + "0HuLm35KoOA6cSWn2/kqc7FvhzZpxRfM0I//N3vvEmtJllUJbvub3d/7+i88IjPyE5BkFerOboSQ\n", + "WqjVElMYIiUDJFJMGDBJZjmCESNGSEhMmSBGiBESUqtAqknT1VWpaioaIjIjIzI8wsPd3/f+7G9W\n", + "g7O27XXrOZnSk7K9u3T2xJ/bvdc+5xw7ZmfttddSQ+tDgqX7h81oVYvmUAtHCZOUxlQCKG3TFPTY\n", + "kuEntI9iqP2GpARfA7KexfZ9VS8OWXUX6VAm9gvuo5FSNhHUgXPSYNIUmJoBzxeWMtHxyUrUw+Q2\n", + "QClwHJ/HrjoQzEjbSdNhNaX2EuQKEqR9MrpflQjNOka6v4RSwJra49SitvViQcUrk6aTfU+J9JqC\n", + "zFK+/6H7w0RsiPt0JRFRc5d62u9I265XzTQbJ5vetfHuk/9o+zt9gmslvaHQpeVq1QwiF4EaKaX5\n", + "pRUxLJfu+G25pW3uum/Wpg/06Etfddtemop6hzmQU8B63RMRmK5BW/CgrzEW2Nh1mke5eIScJ6Zt\n", + "SDOONHZbjFO9h0ZKj2cYQzmN62Wu+nDW1y9uXfsMpE+k6fOM1a5BFO8ptdM2h0U+CVERVLNpGDi1\n", + "jZQZjasR919Pc+JkVkyPE6UlsNtBCNK4UiE6mpSKwo3XfW3aYurekVK6vcV4TkjbUHD8gO6nFM+A\n", + "kdTzK+g7ZpQ+nGE/M6SPIyrY6XDftQc0EtBCqHhG+zggbbs8O3bXFdszoQZFJsuPp21K+djuXPo2\n", + "ICJ6mmmf2KUGKLZhGS1VVmdajGpWcVGOIC184MpBKf/XhUekfPjw4cOHDx8+7hlvDJGKwlACsbdg\n", + "feFjD68kdiuDhN6009S9uZYleWhFUConmYQCBO2Q3nRzrHZVCbWllWakpfnMOUTZKxNr69q9Cce0\n", + "+lKfvDBiYjX8egpbJXUd/Mxu3XVVIaE/AmSCylAFiEDI5ECsiGoCiZLkLtlYm7GnVUKPFdYARCog\n", + "hdcEiEzZG2EzUEQuZpQEqxUicbetvtXTigjEakbd2gHXyysy9I+iakxENWK79dMOK7GqttW3kh0r\n", + "IgS2vSPlvrr+Yto2mznl+5KV8uFrlnSKSNIKDsGrRV24j6RYvVyAsCk2JkegjxH5OoHXa8igGPG0\n", + "ApqmflAipApOgzLB+K9KJkyqii8VD6gANZFNrS+onH1qYy0D589A2KWlnn6uKIiIyMuXL7HNCNOK\n", + "iLCyeTLJbtg9noHkrqhSTONqxIBerUzFXqU7EiKMq59WGPB9qmOGCbhADui3SazuCSDik9dfhNV/\n", + "3xjSpArH1ZZQotp9HlIByu2lc1ZYECn+eOUkC/aVjeeXQJa++uUn07YtENO4cWP4+qXJH+Snro25\n", + "1HuNY52cGrF8qN18Mp+RKwNQ7IwQyUDbiVbk2hatSr3QsdQ9gRFJlTpgr1MBwh2zh57OpyQxkUDu\n", + "JSPyfodzakHUvyEZ650it3RPqGTFERVF7IAq7ajYSPuf5Qy08GCkQp22cihe06BtCMFR+YMosOvq\n", + "kTGo+XmC39Q0UasrAjXn9GxpOTsChfxx0MISUuLHjV3SfrNUn12EtPQ6J1BRhKrIU5FREZ7hGmg+\n", + "xT2T0DwRQ5U/RsYgpcKGFukEsmuc0OGW0DSVP2mpoGmlpHBqk149awlNi4CONa2T9eDiAEWx24aJ\n", + "5W6/uy0jV+7fvGAPQfX4ZDkHSPzQmGTJiteFR6R8+PDhw4cPHz7uGf5FyocPHz58+PDh457x5sjm\n", + "QSBRTPpEg4PHK1KiTQcH1bZE2FZcNKKURYnfFERULgEzj/SuqGS/GCmukKA7JZiROPUE8Y2U2osA\n", + "cbYE9wv21xC2mReAsVnFFXDwybFLi1zfkjovSN4xE9ZBMlZY1e3X/VvVlNqBxkZAebGxV30YMo3F\n", + "tgB6SuNIaSSk76LI0ihV6/RpUtY4wd81aXEsQLbdkY5WC6JezebKKC6gbN+UZg0n+NzaWgnFCfXr\n", + "iBTsvjTT0ix1x2dtr6p2n++bV9O2cnTX0w02xobRpaBUW4VV5O0ciViMVEBHhHHdlrAqeOuOEVBR\n", + "QBSotg2RZ3uY0Oqm0NpLSaYRpVbXG3cNnMbS1FYv1LBoTxKxlkyVuonYqzpSe6gSsz6WajvFlApR\n", + "E+brayMx6z40Tef+zg7+FTHtoTRlHSuQWKEZNY6cnqvwHUvZFLgBON0evMbIWNOIA0Hy2ma3tzZ2\n", + "zs8eYn+qWM3fR7ozuUvEZmK7IKVyCzVxd93u35fPfmTHeviOO1+6xx8/PcM5GXn45Nhte/bSpezO\n", + "iLBfwoQ4IBLvHGnW9ZXpbdUgqOfElC5BPD8g6ud6/9nlaEpjhAJ+zBa1oxLwbZxstm5M5AW5CKQ4\n", + "ZyJ7x6nqCFEKRukGlFLVVKJuOlvYnBShYOW2tPbaY/67JBX5GppuQUqEYWhGzYnErPT5jBwlZsu3\n", + "RURku3Fp15tLm6eD1J1UNiMHCtAx9lQ8pRqZU8w3AAAgAElEQVREXChRqY4UEdUHEKBZvi1G+nhA\n", + "yjCitOu+Uj0l0rbDvBf2TC1x112StlMSq7YbqX1j/jkgyuvYDjgtrhpg0L0iGomm6plao84KARfg\n", + "BFq8cPd6TopTO08dM5SC7KH3l0b4XmjXpdSHOCFzeUyo3YGOI7TdRnt2KVE9pnTzRG9gHS3SSHtd\n", + "eETKhw8fPnz48OHjnvHGEKkwEBEiZ6coF+16W2lUlXsLTCMqyda3WZYpwAKv5hUB9hcHTNRWtVP1\n", + "K6LVZ4c37pBQjTXIlgtbriWQX2jprXYiyNNrqap9R6TOOq0I4Pk2L8wb6+LmhYiINK1df5Kc4zyN\n", + "xBwnC3xm57lD6Tot/mQQVQAmsjne/pOVI6yywm6Hky9iW9VvtlDWDchXDKjHdrRzktitdMeRFLBR\n", + "Ht61tHJPtb2JxJgcqp2Pg/VhjGKEkRCcyTuPVl/Sq4owXStWaU1vq9R279o2ooaKFBFD32S0glS1\n", + "W9b6DuCrFxFKGIqWGtv3aizxR0IOe9xuQ2Sk1AErt3BCuvho7nsloXrzpVtNxzkRhrH6ZQL6Zu/6\n", + "Z744m7bFKA9PMxvPV2v3PfXhYvmB1cohHZcXVmqvK2xGiXTbcmErfUVEBuq7ob9bkq2/6YDqaHm3\n", + "iJHNmTCeAPXiFaSiSUxsVyQ4YsLopApN7Y9dX128wj6IbF/Dw5GQlv3WjaE8IfkTkIIzIrFevXDj\n", + "bkGI0Pb6c3eNRw+mbTtIJsyp1HxduTGQqYTKia3Wwyt3r+33Nk+kmfs8ohW5YCww0qWIXU3IdYbf\n", + "5BkXj7h2Us85Rp9U9ZzlGtT4jVHSUdF0KrbQEvMgoj7WUnSSLpmU4oEqxoSqLtAXRyRrsbx1f89z\n", + "QykutUyekYYEitmk7D+Dj988IaX8BIUUR18TEZHyoSFSnz7/gTvdwNpV0dGRxtUGDhwhuWfo/H9A\n", + "bB5VRtsuUj370pVrp65nxwq9GFI7byB1Q8+zAG4LPJ+MqlRPkjiDzreEvkTq5BDR81Sfmb37rCGo\n", + "u2vcfmtSFtf7L2aoUzM8BGc1KBrqcnaqcEUTHaFpLe6JMdBnKKnDixaAMdvdnSfVtUivGZnGxl+D\n", + "648Lku5QT0hytIhCQ0VfFx6R8uHDhw8fPnz4uGe8MUQqjTJpCX0Y4H7OXmcN8txlR+Jj+uJIaJYK\n", + "otX09q1V/7y/EG/dmiPvSBogwht+R75Wmj+vtpTnXbi31SKjUmMANklsq3StZu0oz7uE2GEcuLfv\n", + "LLIV/NHSrVKfv/whHR+cIir1DYGYpYl13XYHNI18hQKU52eRrTQbIBx16VZLaWCrsER5OAG3CdA3\n", + "SuBPXBJaJW12bvWdENJSQopgGAkRQFlrlNP1YLkZiVsFzmaUi271molnhcYeSaRUxruCkOrFt6Ec\n", + "eQiuVUACo5ovHyFXMYyc53dtkWZ2/Ao+jXlOrvYonY6IU6ACbh2hZDHGbE1cugDIXgBn9JzK/4uV\n", + "QxqWkckKVBWEM6msXsuP29au6+TY/TYkr7kI3IvNllCK3I1JRelY1mC3A+rIihxYmR4f3+WZxITm\n", + "CeQ0Qlr96zGyjFACdFn0mjXdCsjpixef3/mMESkFWPj69VwikprQv89ODaVTccIc3oBNZW2jGhLl\n", + "1lBN5Qu+eGXntHrgkOXtNYlkAv1h6QydbpvW7pOTB+6+v3j+fNpWoE57KRgLM1tBZxBOXK9tH1/g\n", + "t+ckf7A6cuN/x4gIUMyEuHQhPNP2ld1PymFTj70DWQ2d2AgRVtCbeU7q9Skpj3/tMy4l198wmgw/\n", + "NRWaJW/ACtIRPF4y9Uml8aecp5ogiR733X5naPpq5VD/+czGxOmxE/vV7MPtxjh1irS8uP5o2tbg\n", + "+dQPhlqEmJ9CEp9UZc+Rrj8KCvyWUCKgs12l6B8JUic6rokPKCoNQJJAOifQ82+P/cbEuTQVS/K4\n", + "zN0xUkJTA8xjLea4gJDmBtmXkF4nVBCTpR56UZ/Suzzg263dO7lCkCNzqN22DL6r48jcN4UwaUxC\n", + "aDWluUYzRyxm3UK6pCfU+yh292RBKBkjdq8Lj0j58OHDhw8fPnzcM/yLlA8fPnz48OHDxz3jjaX2\n", + "YslkICXoQYlwRDpskfaoGkoPQMW7Y7Ix8MOAYHz17utIbXeROPg2h+dSyD58IOduiexeg9CWkSTA\n", + "gFRdSmTfZKEwMqnDQvm8JQJeD+L1AkrNOamuj737+/zkS9O2m53zxOKScE1pJXStMeD5kN6LFYJO\n", + "YioTVxgVat8n6VfsWuF/llHKaj6DrEFJvkpQXQ5i29Z3Dh5tOC2KNM5AfkUqtzAMXGKuCuhKbKdU\n", + "DGDscbR2HQMoUI+U2ovmd67/9Pg9ERFZI40pItL2Sopn+XoUFMTuuhoqTc6RHuRxGoRKNqeSeKQP\n", + "xwPCJsqPKY03wmstovLzGaQbMqTMciI4Qi1gKm8WEZmv3LU25FfXt5oCJkkGEK8HSvfK5Alo17iA\n", + "ArmmEziNq3urSIn7K+86BW5OmWm6oSL/ueMTl/pjFXM9bE5eZ4qoq0wCK9triolhfC024dSejqeG\n", + "zn1M7ioWz5RQTe2k+1G/uIEUu9vK9ftIUieb0hFgB952CTcAUpaePObIAUHviZr8LOs9VNGpAKKY\n", + "u3Rrc+PGa0ptWEFtu5jZ/BM3mm639i9RWJKxAjxK2DmNl6AUviWlbGU89DrH0v1qas8k9YG0ND9N\n", + "tPy/p3Sr3ncByZlohx8UqWPbpDYvd9M4fF0zHU90X2vRSk/nPqJsZE2p7bNGixy4yMKllI+RWp/N\n", + "jbKhabzNzu7hWmU9yH90uXDp3h3NPwnSnAkVT+k9npH/6KCedKPOK3YNKYoDMklpmzvuLGG/vC2u\n", + "3/q6f40DgvZimrF3Jjz5yPe2h0xDp/IXNIUOOJecikg6jImMpE7UlWKgcdrhOdXTfB7hORURzWIq\n", + "WkGbHD5DVNaAnjWgsTDXPVT3DLpPQ5VRCW1M7Cp3P2cJ+XQmXv7Ahw8fPnz48OHjZxJvDJGaRbnE\n", + "9GZ+0zlCX0ueRzHeiIfGyiBTCCiObIqnQSWhAtE74vpOpHQlVs/nVoZc4lxuyddJaycPBOlalF8T\n", + "cpAVQERoNdvpdZAkw9W1E8xbQPYgiOwtN9A3YxJaUxG0ngiDEYhyUWL7jbBiy+ntP5kcyS0UiYjw\n", + "9r++MYKrIggJCSgez93KbE6rv6ud+w2Lug0TKZ4QKfRTxNbpo5bfWh83DfoiVxE+IvbjPX8k/7sE\n", + "bVyVNiaW6MeQynrnOPf25BenbT969b+7/REBfmhUJA7XQEib6lDyCnIogb5VRkCOA4hq0jJNScYd\n", + "jz+M2Y7G7rZy434Q9YsyBHWe3e3/FgjX+sYQkWMQi3t2K8e/jEju4Tv2+MnjaVuj9f9AGmpCdVRo\n", + "8cG53Se2IqTrwtGePH5r2qIl2z05rSsQlGdElFdft0Yd38kFHqgbSy0EIEoPdAI9vB5VQFREpMVv\n", + "GbnqcD/zb1X8MQaCcX1rpNcGBNiM5pUGROWBCLNhhAIQLuxQTzgSDlUw52hlcgbVHtIJjLChLfIz\n", + "d0+WNzYnBWhP9bcUEYkw1gJhlBAILx2/AaE4pPFUoABmR96VAWCSFqh+TeintueM2lqlEKKUUHqg\n", + "f4xSJ6GSmEkSQT3ZmCiNcZIAfWGhxRrjb0sTe1IscUxCDTAX7GieSJEBiEkm4/LSkcYfn7xjv4XY\n", + "6emxa5uHKyv2aFp4eO5+PG1DnYp05LWnSEga2zkp2T0h9DEBAp+QSGtbYyzgOdWQIHCK8v+wpyIS\n", + "yA+wTFADf9KGxIdVCiikAqgIY5YRqQQipjwXjxBbHnG/9uQJG4YooiICfICxlpAnYYB2v+leTNuG\n", + "0SFBGaFZAbICTceEdswTexTlzEgSBW3ImYYSRUER3RMj5qmmo/E/w30ycpu4Y233z6Ztx6u7Hqwc\n", + "HpHy4cOHDx8+fPi4Z/gXKR8+fPjw4cOHj3vGm/Pak0HYrmqYUgak8TDCVyggZdcW/k+kj6ME1JBI\n", + "jCE0e0YizCm3PAUEvToyyFa9uV7dkmI6YOymt3TLLHMwctvYO2iKtBTrTkyQMqVWekDlz199JiIi\n", + "D84MHtV0R0gQb9cgPUQEfEH6jLWQikJ1VEhtGmTniODmGgQ8TTvttgZ7L47cdYVETk6gjp7NrK0b\n", + "pGzK3rRVAoWqAztWlAJSJR0n5fj1RKxsABmHUBGfHWgMKTmaNYNc+/REQN9Ujjx/unx32pZBe+Vk\n", + "ZWmsy+3X8O+/2DEACzcg2xakRK8k55RSi1nkyOFtzyq+7vORxm6YqIeZ9XFVq0+VpQWXkeo4YQzN\n", + "TQuoKTXdZfvYbOBrlltfv4Iq99GRaUBVE1HaYOzTh44oXpPaeqJpaaS4VGlbxIjFKaVsIuQ769r6\n", + "eg7tr47aRFNAEaURlCBKXO9J+0uJ4kl6N2XPautKQO+JgK3nvlnbeM4zqEgT2blBqoKJ+kqAV6rA\n", + "gojwL166duqF7j+kAAdKWc9w/5WUblkduTYpS0tZjTjnem/9r6mVhPznJo8/jKc5EctvNo6A3pRG\n", + "zj1euXlnu7V7IkeKviXNnBW0x5rWxsRuC7cDmk/VR1C1eDh0THQdj3+3LeNrENdPOSnVq4ccz4kj\n", + "UpQjF2+AqtDiPJoDxWy3D1b724C8X9O1NiA0d9R3W8x387md5xqp+hfXNiccn57i++5+Ol7aPfn4\n", + "ofPhe3FrtIjLly4F1A82/gZQOhLS0Qqhts0Or6rLFrPbQo5UlfqZkgFsvXdjd5ER3aBHupv8F3PQ\n", + "Dbj/m06pEuTUgbEbcU0EUltC/dniPHvoA3bUJykKO1I6pwDjhD0hUxRecKHOrn2OYzJRHNqCpHel\n", + "6Wh9JoyjtdcwpXnvkujrhp5J6oZCen/qxRmRs4B6AIeUFl1vP5SfFB6R8uHDhw8fPnz4uGe8MURK\n", + "gu6grFl9uJjX3cNDbSDCtvrpBPSmHQbqHM8HANktJVZs4N4wUzg550SwC4EM5DNDlSqsHEfymuvF\n", + "rWDa1lb/TQ0VVfLriUBsDIiArKv5V7cOQWnJL2gO76g0sLf6GPvYVbb66Xt4o9ES4vgYK6aW/d+A\n", + "yFGjKNlVHe5bggT3G0eEf3T+9rRNSbkFkThTECHbhkpd8VbP6IuuqntSJR+wIhuIqDiqTxzQipRX\n", + "IToY2MMLSsF1Z6u0Ye9IwQ9OvkrXCpSOVkmn858TEZFdZYTiEoUM6qvHMKn6inEBQBA45C4Qch/X\n", + "z1nZHNc9oxX5ogApfE99ApL5PHX77cnDKsbaNaLrV/8zlil4/MRJZlxeGUqocgLLY1tNl1pqT/IL\n", + "7R5yFiBUj8LjxX2PEZEAq9nNhlzlsdJcrkwmRBGLgKUWFm4cban8fD53v1FE7oAIrsUWVJyQJEqO\n", + "tv4vQFTl21+PcXJkCuwT6kXk5dtbN+4DoBoxee2tzl3bba+ohB3K8yxhUAJpPDp9ZMcCEhaR2r+W\n", + "pHP9wYBVb0/+h4vCnfPVhbuG2cquoVB1cpr/KkgdRIQ0aIHCjFDyauuuP0wJftCxSwTcLNX51LVo\n", + "vLLxr4rlxczuKz0ndacQERmx+qfulwEoAiPMOo8Vc0Iup/vO/RORr2GHz1YkHbPY4VqTL6ZtRzi/\n", + "drBrVcIye9cpEvTxM0McjqB2vliCnE2EfZVnWS2sAGMGsvtN+ZntN8Hzp6c5Ge3as3QPbvf2AGGF\n", + "ejfaKaEipmYHsndC81+D9iS3i8VEcqdCoQAZnoNiGxQ2kHehToE9SQH1isTq/UnzZBZoAZChr4vC\n", + "3TsBeZJqh54sjNhf4Px2pfWdts9AY1ybIAGqqSRxEfMT5AIMlQzSdwi3EYicWPvr+Mzo/tPMSszt\n", + "3lER2mvCI1I+fPjw4cOHDx/3DP8i5cOHDx8+fPjwcc94Y6m9chhlJC2mBCmOODA4rwMsHhG02oG8\n", + "zGkp1SVKSO9I/2QtjO3ewXNKWOsp7VUgtbJcWCpk3Tlj0oSg6E3tUgErIkXf3rpjHAdmfJkgfVKP\n", + "RDZFakuRxav1x9Nn4ehI0R0ZHweT7hPB00Clj4/sWHECE2ZKGfU1COWxHb9SVWCYonbU1qpsvN8T\n", + "YTd1+z1Qm4bCa0OpNdX9CAJL96lBZUgwahRD24eup2uR7kO6sSEScwKz1pFVlHEyTFiuO3fOm4rI\n", + "8/kjnO9dUviD1TenbZ++/L47j8HB3gz7Bw1Uv4nYr4ajfW/9lEZI45JpZhBpqpL0XqDsnrBSfu3a\n", + "LoHJ73JpaZwRar7kxS0B0lgrguKVWMuaTTFUefel9VMG7Z/dxmBqTRtd37i0IOupPHnidKFYxfx2\n", + "7dLdKWmW6ed7IqrnhTvPjDSDcqRZX61f3Pmewv5Mdl+tXPp8TSTyAqnSjlIh+0ELUDhl5K6jJl0u\n", + "lYOqm6tpm6pi75Cqu3hlad9EBxlRC4bWXevi2O6/eu9+W5HenWgBAqU21KCaVcm3a9wnpV3PBlpF\n", + "p2cufbQvqWAEOlZnVFiwR2qvrImCgDGzWpGOFtKtfD9rNr6j+3QHl4cOk42mDkVEchChSRxdBOMu\n", + "p0KJAYT2NOa0uJ4c3096ImQWDo0uNQoY6Z5Ug25OGc8X7n6aH1m6Lbr6kdsHmyGj8CYoqKABxOeR\n", + "6Osffvx/i4jI8akrzohprjnKXYHSMrR7OENqr6ZnzQrPtpAcMFpNn1IBhrpdTLwLERkHnfdBhI6o\n", + "iCR3fXGztTT+InftPuPcNlKrq4x0nDr3944MisN0Jv9tzBJ3jT0RyjV91lfqUG3jup3oCHavaccu\n", + "l5bG09Qz63gtg7dxjTZP7qEsvquYvD+dibsW6n8tjuhaIqD3+hkXKiFVndK7A/q9ozGplILugObw\n", + "kzEnj0j58OHDhw8fPnzcM94cIlWPk5eZiEgOsnfL/nsT6YxQAixrWH6gV68dkglQddaAVaGBOux7\n", + "tyJNa3obx0vyrCAV7RKrFVrV6qpmRyXsuorf1/aWXkDRdWBpa6xYVM1XCMHoIOtAfG1p8VrNKtIn\n", + "yy+LiMj5mZX1CwiV695WjmXr3uZ7Xn1iNT/27rNlzm/wbijc7olYCwSBVwZKOkxo9T+2d1XUdZHC\n", + "iyT1eBqorHpSyEUbNi2RiEGEDWjPw7Q0IZSudX1S1kaOrBr3d0KrnzBU8qbt72T1VEREXt7+s9tH\n", + "aW04E4e+sUyHUoUTUvEd0XYRrVJVRT4h8nKkJbvsCRZoUQBI9LUdvwKhOh1pTKoUAxHbX3zhihHO\n", + "zs6nbeod1pInVQ1iOSMiKjeiqMPbT9+dPpvPIfVAEhot2nqxMOkQVXRnrytFP1htnJXfLbCa1HJ1\n", + "kitQ1fOM1PZvrl35f0iQpMo5nJ4aSlQBnenJu1ERu4HkTEqQ0lW9n2zIjORPG3UM8/jX1tnvDaaZ\n", + "6zlTCbkyZss9qddDOkLlKkSstFtLtweSGgiBXOwIElJUL6V+VSmIhr63fOQQxu1LQwT7qSiHFeDd\n", + "332Jwh66fv2L5S96VUInEvVs4cZOzP6T0+RG9+TkpzhtkiED6gCUrqO2iXHvxtT/IcZOQPdVXMAv\n", + "riSiODwJD+Q/ADel5Im43ji05xMQ0E+XD6fP6hoyGXO7J7/26BdEROTVjSlhl7VDVR4uDGHWuWO7\n", + "sevZN+450tcsHZLrhYnI4X2VAeHqqDS/xH2yeg1hP6PCihVkbOLa+kkRKeLzy4j7NBIbTz2ed61K\n", + "Z/R2rBok/iCg5xmKcfr4pR1/7uYnldUREUng7nGc09yJ8dG1P7RjgDSuz/+6uivN0VHBhLY1FzvY\n", + "+bHXqsrp2HhK8ewOCKVleYrXhUekfPjw4cOHDx8+7hn+RcqHDx8+fPjw4eOe8cZSe5tqlIyIbiof\n", + "FJIWSojTW5ev7IdKjiR1XlXbbSrbZtkzu8QGaY5PLxwRscgMsm0aVf022C+F2umeNHs6pAX2W1IM\n", + "BmH3Zm2ppSRx6riqcSUiUu6dVoZ5oJJ2h2h6yK6/xjVGZPz4lS85LSQ2fk1AUN/vTQulRDpA1bRF\n", + "ZOrtGLB00LHCtZoG23WVtYNnq8ZgTW3NgNJzIaDSmPSWItWqsqNLrCrWgR03BXl1ABGSMiYTATwc\n", + "7fp7USVgMpFUdWQyTV5DK+rh/F07T1WMJsmQo5lLkdZIre4rIyJvAWfnBelY4Yqy2NJIg6ZxezKy\n", + "Dh2MncZEVMZv+5bHpPs3zVyqrFpbKkbTkikbfyJV9eLF57YtVKK2pQxeIn2zWFoK7vzc6U1VPafP\n", + "XD8+euSItScnRhhWQvlmc0Pb0oPPRESqCvcO5aAzKItHIbediw0pcD96rARh1zcdmQFXMFlOqYhk\n", + "vXbXGBMBXlN/rLatE8BI+xs1zUkw/nbt+jtT/TgyTR9jd+9ywYAKmtdkxqvsgYR06W6uPxURkZNT\n", + "02WL0BfVNRkjoy9WZIxb1Wr47P6dLexev712Y7IhysLJzM0119fcTyiAoHZav3TzaEIqzprtaKmi\n", + "QdPnquOTUtpPNb24ACSB0fSMNPhUsZ3TuRHGzEBt3ENZPaJ5NwxtvIscpt2ublx/lQM5UIB6MSdi\n", + "92ru2mRVXk/bXm1cu/Mc37aq7WVtrGTjjz/9zyIi8vbjd6fPZuc/786XcmEPzhyh+uuP/6dp2w9f\n", + "/Ce3r9BSe6coEJrndp9ejC4duA1t3tmBXjErdPzRvYY0akC6R+XWXX9LRREzzI98n8SgdhArQEKk\n", + "hUOhZxx2c0BLQZFXiOKJitLTAc4vLawN68Zd4/7GrquHAnuSWRqvKNy4n5OjRAyaR1vZPDGMjr4Q\n", + "YNwx3UDNoFs2Ep/Sc3axWhRzYCQeKnmeKTgonqJxOAQH/I474REpHz58+PDhw4ePe8YbQ6TaapCu\n", + "IIIXyqQHZkePqqZKqw9dLZFibafKrqSsO5VukrK2IlI3N+7tdndmq5VggrCIsIdX847Yxi3I0R35\n", + "yinJeUmeYMqZLmiVNMvcKul279CELCLVVyBn3WCr3xylq1wSH+EN+vjIkIMZSnJvN0ZUfvYF/J9o\n", + "pSEdCJhAi0I63+kSY2uvEoTtiIjV7eguLGqtTRItFz0oCgByRL5KM3h9hVQlO6FuuK6YVnoqJzAS\n", + "YXoI1cOJEIlU1b6p1B2Lo31NpfNzdx3bC0I98efJ3KE1EfmlVSp/QX2SgHTYEHKlXodxYH2Sg3ie\n", + "kPzCvnW/6cVQpzR2q/iqv0vOVkXjhMqfOwysJLR7R8nA6i8nItJhxXbESAdWeIywavufnzpkKDwo\n", + "K0ZpPh0rS9QVwI6lxOOAiN2pklyZ7QkUZaR73IoH4NdF6FMDlETRFRErYY5Y6gDXX5H/nBaZ9K8h\n", + "jG63dp8ssIpWwm5IRQx9wzX+Liqgn2lEiJSO+55W/1Bgv70y5HBx7O7/6EA6AirWhJKZjAPuDUIV\n", + "CiAIFclaKPG2IBX9Aavq7c6uYQHEqGX5ARB0e0KkmknuAK4DRITOIfsSE4l+UokYuXgG45RW/00F\n", + "pX4u9Ud7DqyADq83RYYiQgSL3N0Lr0htvsJ45nGVQs7maG73zm2yxXnY9SSp2zejmTrGBsDF//KD\n", + "/2v67ASK5nNyoFC1+7ceWql/F0I6Ym/tGkH25PzcikIyOCV8/uKfrAG08AS+diMVJUUoAEp4aGau\n", + "Da8bQyTnGH+MtPS418OY7gk4RXAZiCKRARH6g8llwX3GRTTHS9cmcUoq+g1kGqh46dWVeyblOaF0\n", + "yAj0RIDXIo9ZZnPXrnRz54DSDpa16PAsGtjrM1UVcxprotIZhFxN2haEUqJoQe9hkZ/+ouQRKR8+\n", + "fPjw4cOHj3uGf5Hy4cOHDx8+fPi4Z7y51F4zCgnmSr5ysDQrYavGg3RMNsYpE9lc4fuA4L4GJNqO\n", + "4GZN4+ygt/Tq9uPps0XhYDzWk6igxcRq12pGKqQArcS6R6cGQQ8gFFd0/BxQpRKhI4LHswRmuKQZ\n", + "pKK0aWyptRhptiQyGLUGoTyi7pyrWelgMH6HFEwIUjibJqcwvGRyaAsyetcZZK7mvjnJ/apSfDta\n", + "h8bJGY5lcGuA9/YFKSCH0IjpQBgMqU00PRsS2XSOAoWUFHuVT9/Upu2lHEPW7NEea0mxt5i7tsix\n", + "3/jY4PnrmxH7NXg6XYKwSNzEfelSBjkRQMcR50kpKD3qEBrZOIjVcNO1Q0nGm33o+npHKt713sH3\n", + "nJ55C9pPdWX9OYMuS0NpvOcv3HWcnpsCtJrPqkFnP3DKyl1PSlpcmna6uaE0AsjQ7CwQ63giAqiS\n", + "vCMyV9Xzi6APxPvokdJVMimf757U2dNjlypIYk7LuevYbGxMqEYc1RpMxPejpdtvVVP7I7XXk7aV\n", + "pttbIpsn6NmBdGwWSCPvNra/zY0rAHjwwAjotzcYOzMbUAVU6ysUr7BmkwYXBagbgBZuiIgUSAFx\n", + "avf21rXFjrTSctxvIY1TTaWO2NZ2dq0V0ucFpXZC9N1I16+p14GdAvAT1Q4SEYnn7jxHvqEC1QDC\n", + "9dDxC+hundK2zSs3roeKdAThRhFTUc4CBtnVQArwaozMOkEomlBS/rNn/zx99OGR0517793/YdqW\n", + "Zm4ny7mlgh6OrnhjX9j802E+TYg8vkBfryorXumRvsLUIDURq1VvjN0h1Nyd1bnXNe4PmpMizCMR\n", + "zZ0l5q6Q0s1aeNNRGwfaPpjrj1ZPps9WC6dtOJKOVALKwi2lltXw+uUrM3d+dOzSnDG5h0z0DnI+\n", + "yTK4d+DZ3ZGJ8Ch3nx06hpiWMGIb63JNBRWJfU8LJSLCmbyOlA8fPnz48OHDx88o3hgiVdUb2VD5\n", + "/wKkQFai7vGWOptZueTVjXurD8nrR8veO1ZOhncZqxiPIK8XM/eme7M1hd8gdETQILLvN4N7+29b\n", + "eqvGSzcTsJWodrs1AvIZVhojl1UCWUshV8ClmQUI47PCVpoVPLcqQhU2G4eSrRZ2nutbt3ItWeoA\n", + "5zSnFUkLKQZVM+6p+5XYycTGDUi5dU1v/zjljtC/AI3SECm/C905ZVRW3IG0GhXWx1GMslpd1ZJc\n", + "hRYeBLQtkQT7tfZPsMLaVhf0W9dnIWyA4DUAACAASURBVPkJyohVamwr8iCATEWonn/kl7Vyq8TN\n", + "jspwUWygCKKISInS4I6UnZU9O3Y2TuPR/YZsGqUBmjlg5dRHto+ydee5yljZ3J1vnrMSNRBZlhpA\n", + "YcHVhY3JUPuWVmlKGtf7juUKelwP+1XeXDo0bbWy62+Azpwck68gCNJM4tX7M6MVcT99rgrTtgpV\n", + "KZSRiKAxPm8IJVLkin87oh9bundGoCgdrfADlDWron1B57YGZN4TqqJK/AFLUuQotiDC9mavJe5U\n", + "ko623m6tAGJ1Cj9LKq/ugWLH8OtkErVWhfB1qfwD36cqmbKjdlL0o1gYcnL50vVnV5OfHWQnFH1j\n", + "vZAid78Nae7SAqB4RsUzOP5Iq3+Vs2FivU4oIyGxqsqtKAh7vk0EaCpAyTB24x0p0KM989TG6fmp\n", + "u65tSIUSQHEDGuM15owYJPKAniv/zwf/KCIiKTlgfPnRe+4aqLBmDkRYkUERkWvcOw2h5KJK7SQF\n", + "pM2tcyMjqCEUxQN6rmhyJCBU56p2468n9GvZu/6J+Jmk8znNcXpvtXTvBor2dm5/M8hLiIisjt2z\n", + "q2tYMRxo3sWn06YCnoA5OWrcbF0xRkoK7AmKNnrKZiQgfg9Af/vG7mEtSpmR/II+W3u6d3qM04DR\n", + "pUClc9jrEE4pPJ8H3At3wyNSPnz48OHDhw8f9wz/IuXDhw8fPnz48HHPeGOpvaHupQ+JxA2T0QWZ\n", + "PCqMF61I92bvYLmyNMha1cNrIqD10ILIKI2kkGUEyJbVeXs1vgyJbAtYPjrQ0VFtE4Ii8fe2tNTS\n", + "yYkzCCURX1EcVQ1vk5h0LwAdJqSmGhYutXR9a2aYLwYHlZaNwY5Br5o9Bq0GIJIPdIwI5L0AqaA4\n", + "pPQkSIRRRGTfmZL4aVuvaUFKmQBmD4iwp30RElE+gPZX3LOOicK4UKwdKe2Cdho6e9/vQJgMWG0c\n", + "fR2S3s6udGaZBSkLDyBDRgTVB0jbJinMQEceV64v5vNH9n0dV5lB20Hktm32RmxOYMgdlQQjx3q+\n", + "1p450tYd0qic4lksXbo7qKkoYebOKaFrbWEum1Fq5cXnn+NYpHdWun2fcqYIRO7N2p370YldVw2y\n", + "dVmSyWrp0lJ5bsdiQrOGkszZIHYGojAXheg9qFpQnE7QiCk9oSmtGaU721I1i+7qg4WUqlSibkKp\n", + "Ki0GqHCNPaURlQA/UMpGjVHjhG5sKO9nuaVn6tLth8n+vd7/OadPkUYisq+myibiPaXCyr07/q4m\n", + "c/dA9b6sTzQdy3QHNetmsv9kCM3m1kiH3ML4eLkkFwXMD3lO6WYocM+WVsTQD65P2HB90gqkPtEC\n", + "GJYbi5C+6ysdO9ZfGzwnrqjY4AtoSm33ZFoeoN1TKgBAoUJE+kjbtWuLek/9joILLViIYupXENr/\n", + "5YP/ZNcVuPv0ydlbtg+krzpy25iDjP78pZGtQ6ToczJBTis3J/Ql2obSUxmwj4YpC3qtZMYe4nu7\n", + "xsaJpv4zmn8TTcFS+rRBSq0kXb5E9cMwTudLS5lqsclua8dq1DWD+n+OIoacuA0VTLWb1vozhsp5\n", + "wu4VB0pXIk3NzzXQE2IbpxnaoqF0ez39bVSdiRZBQmaTkTwVVHhlcx8+fPjw4cOHj59RvDFEKs9i\n", + "ycjDqdyjhPehIRiRqmy39qa7XLq3yZpJrPCCYzkBJRnniSE8RQH0A2WdKa3MdNXHq9pYV07EM4si\n", + "RWnojRjICYlSy6tb5+eXkSp1CsJcBGPBOGayN0qO6c1bPb4qWi1c3zq/vs/l42nbMnfIFas4K7H4\n", + "gBQKUv4Isl3ICBaQgZ7UYSP8tiBic6uyE7T6VfXYsraS+BjkwX6wVeKANq4qWmFpyTZIpx2RY8NR\n", + "CYYWFVY6OY0J7bKRVt/rnVuljgmTkqGeTu1eQb1dUPIajLSq76Dmm1jHzkHUDQNCJOE7uCOfvJtr\n", + "109Vber5i8U59mttnGmpr/J6aeGlZO+M0IoYK63rG0M/iwKlxuS1pighl64/eQyvPS5/ByKWQB3+\n", + "6sp8LVVF+/raCOtaiv/ooa2+5wu3j4HgB/WzGgjpUGSXAIGpxHoOtKCsuDgEZHciseZAUAZakZYg\n", + "hTOJewn5AZZuuLhw13Y8IzRLfdpArK531jZawh/TSl8hFvYVVDeAlhSzC6A0C3I20NX3SA2QYo5h\n", + "lGQ6N9yL7OF3dApl70tbaat6+cnKrmu7d9dxfGRoYQnUk1fXA+5xPrqiVDmU0vfUrglQUlZbT3CN\n", + "vA8tReexPnGcCZFSiYORJC7UvUB9IHuSkNFd5ETiztVXcGdzTQOUsidPUCU053STjZN0gCG3ww5K\n", + "2RPZnd023LldXFih0vvR/yEiIlnyv9o5Ne5Y7GuoWRJGH3c7+HnmdozTIyctsI70eWXnpl6vWWzf\n", + "7zCHsEzG9NhjsjXQp4j8X/V5w3Nngrl429r+whTkfYxrJcKLiAShosrTJtkpwktyKnHkxiK7XcSx\n", + "ZiIMzdeiDX4+6xAYe32uMbEcfq0VIdKYuzJSxe9adwweT02piDAXr7l2Yj9LdtJ4XXhEyocPHz58\n", + "+PDh457xxhCpxSyQikouE+Sh96TSeXrm3n6zwFCdonCrr5xWf6UKRhKXIIKPHYv0aYl3jXzsSEKH\n", + "U16WkIYUfmk1oR+6cIxolaoePxEJRwbw4hoDFqmET5xyANiZHpyjYWD0ByX0JP65rdzqsO1sv1tw\n", + "c/KZvekfzx7hGOQcDk9AkxpgrAc+fCELaGK1SgsyQ6e4hNQdI46I84ZrS1MqXQdvi0VHdbWnKF1E\n", + "iJCWZA/Ur1pq3weG/liZNokpwhNwV5GonLjjFjGvZlwbbHcOrRhb+0w5B+FIIqE4REEcIend56dH\n", + "D6dNzy9+7I5PJekl+BKruR0Di1SZo3Q3TW21GKKcuSXPtzW4TB1JcuTgnjSENM2AurStjcmjlSs/\n", + "vt3ayn21gvgjyvWrve1XqYFcwq5IS0C8QeWNLJaG3H3xhUPkVrRNOYpahi9ipe7KjWK3+puNO88Z\n", + "lZrv4adXFIZIbPeujTviI6lgZE+r6kXq2vjm1lC3DMjZFm0cE/dEhTi1DF7EUKq2s3ZSLlOYkiAo\n", + "kLaE+DWLY3f8qrT2VwSYGRgJEItRfepY1BXyC2cPbKzdAEXsCE2egcOkIpwiIkfw2utGu0+6SrlM\n", + "jCaCrwlEIDkmr0/8y+hThK0No8TgerJ3o4puhsSvihSd6G2eEvDQ1Ap0uyPuTavZBOK5gbfFD7ME\n", + "k1bHWqYpBBkJidcfhYRcSaxjB3MHoTrKXwtpTv7hxx+KiEheGPr3zXf/R3e+JNxaA01iTzjBuKfb\n", + "eWr3HDxLFjCuA4i0kviowjUd+0QCCabbaRKVZES+h/xDT2Re1dXMaDy3QJYyiKmygKmKWhL1UEa0\n", + "MUv8rDdO/iElfqmOOn6eKtdXeXbuElViRn31bP7NIB3RESKHR6eE7N0a6G/p3Bs3FhvaX6jfY4mV\n", + "u9TNg/CIlA8fPnz48OHDxz3Dv0j58OHDhw8fPnzcM95Yai9L5lKTiniA1NbVpWGcx4DC44BVX+GX\n", + "RTIFi5WDdrc3BgFrGi9JmFjnPs8A8TcE+yuxtetT+r77eyDCXIWS1DwzyDCGengUEYwNaDUnxLpu\n", + "XApClZ1rSg9sSvfFglRfk8FtY0mEFrIH+8p+W4BZWGR2nkq2ffTgW9O2D37oSnY/v3ZE+FQMztTU\n", + "CqdscpQOszqvpgc4FaCq3PFAxPrOpRRCylloNenAfn4NCJVKqCfF+gZSBA2pLqvUQLkmrzeQbGdE\n", + "Ck8AXzdUFDCC+N63rJ6N/W3dWNT0p4hInoGIHVoqbti6/WXUJ6qAm1Ja+ASl4B+9/PG0ra6h4kxw\n", + "92oGRf8Aqb0jSmNdQ52dPLSUjF/kVn6ssHwxt3NK0WfHubXJDikl9iT88Q9Btj52BQunZ+fTZzc3\n", + "jijPqd0MxOKSSNmrhUtpDAOl25FmnM+JvI8+TohEqqTldpImoXsIwH9CRSk3N+7c0xXJhOC+C3pK\n", + "C8Knjguogxj9RGXVk1Iy5AQ47aMpu+BguXlX2bwDHSEimYa8cOmwgQirSigvqCqlh6J3SHmRRgn4\n", + "yG1tb21MLiEPM1tauicAsXt3ZR6OIUi8SzqWzhkR+WQWaNucnBpur12/NyBgq2+giMjRyo2PmiVE\n", + "MP5iGmst6BYRFftMBR2syp3j88jGc4e+iGuQyFtSAkdK7ZIU+yvMD1wok4Bk3JLETovzHEniRQR9\n", + "x5IUa9AHOhChqWBD1UQCKmwKcE7//MF/nrapOs4JKYBrai0h/CJDmr9pmJQPSkXjjpGKtY0g9TwE\n", + "TAFBKoq8U1ucO9dTKWuEKR1abCBEpu7Uu47Td7i3e1BKusHu/27UogC7rnnq5rWzhc0nL26dJEvZ\n", + "EKUHxVsJyQlp4VN74FSCIi/IBKV0v/TwxxxIwqBF+q6ImbCuqvi0W3yvJjkhvT0GIvQPBzSYu+ER\n", + "KR8+fPjw4cOHj3vGG0Ok4mCQZWZvobutE1A8y43YeH0NsunCVhBF5lZiaUZlrQPQp6W9parDN5uK\n", + "hyCN9p1KGBiq06D89oCcpiTj0VZVe6y0SyIRr4CI5IRSqO9XHJEnF1bOSpwbCC25wtv6OZWmClaL\n", + "Ifv8YFkRDCTgh9XEcm4l6auZc+SeJYYS/duf+1UREbn5PyEh0VtZcwdyeEWsxx5SB7OCiXiuQWdz\n", + "WyVVQBMyaux94xCjIuNadxDwexJEA4rQYWXeEelUyfgD+ZUFQKkY1Wogp5CQSGiEFUtAJFItxW9a\n", + "8trDUkIJ1Q35FTYVroFc7ROQXLve0M/jpRuzBZX15iBlnhSE8Ny6VXQcW7sXqZb9u2MsF4aWZIW7\n", + "ntu1SShkIMpviDB+duLQrxndTypOGNNq+urSkZIZ4VmtIGYLEvdua+NaQ6UJRAyxZMKqrtb2jFLB\n", + "i68iQU719WNPQC280PZfr61t9BhM2FUhyMNSb9fuuzWR7QEFr2+t7c6BcF9SkUuKFfESIoEbEnrU\n", + "85wREbZWRJqKDbrOndMQkNclhn1C7VSDDH9A1AXqExNyk8Xunq2wci+oOEFFUvtLIpYDdTp+8GTa\n", + "ppIFIS2/I4yPrrZ2ur5xY5zJ2wv03Q4SClVJJP65O18Wvx0VTSCUJkpUVuFuX7Mkhp7eGFFRispp\n", + "wBNzFRv6NtzifGkM73vMyVQ81GFM9iQ/0KnA8pzv5wT7s3l/NnN/X1059LNtrL+0oGEYiB0eaPGO\n", + "tdPHP/qBO/7TL0/bjiEdIeQrp9mWJaF+uz2QYPX/bAktQ/FQRwhK16JfW9tWY04OC9umno3NeJfE\n", + "zR6jHSQRYoKzYqDiTaMCmjaGmg5CtxlJF6EpGCU/BbI/EolcRaGZlK4VXR0VY6mwrspqsDffFkK7\n", + "PRVRhJgfYvJVVNkFnk8GeBeOLaNP2AeJWbNkwuvCI1I+fPjw4cOHDx/3DP8i5cOHDx8+fPjwcc94\n", + "Y6m9bVvLjHzYVMW0bY0I20IddiACeJw42Hc+IwVwQJqcWtkqzBvYtnnhUiC76hX+NXiyRWqJUxa6\n", + "O86saXquJYGSEjBikrGHFnQvCO1XAugALRJWca6QZlu25us2wuMuIGJhnAAeJf+zFkTFQKydFgX2\n", + "Q3DnCFj47QdfERGRj1788/SZ+h9VFXuIIWVB2lYKhSZErB3Rxgz3zibypm1LJl8vO0QgDtq+uQU8\n", + "23N6BGkfIqeGMT4fDIpV36UiIQI2COAxMaVVq6olmLYHRK7Zu57SA5OycmdjMgChP6ZmyqAiv5pZ\n", + "CmaGlFEuXIAw3LnGsnH9/vTx27gWG2zqIRWnlp69uXTpwfMT0xFSSeGLy5d2XSCehjR2ZtBeKma2\n", + "vx00mJTsuaE0oqYWWPep7rUowa5LCeKcljs+RjqGEHstaGD/O9U+MuievPGQbuT0mBLVaxqnFZS9\n", + "KWMmI8ixc0rBXVw4NfiTUyMA3750PpbXOzgr0PeVsMwpk2n/BwR8105ty9o60BsixaUZNLh2O2un\n", + "DEUxFXmH5idQm26R2icibo05I6NUXIn05WxlKTAVEGItnGNoT21emo5WeOrO/dknH03bqplriwKp\n", + "WPYL3G2gWVfYmCiWaE8qFFDy/EAaTEpeHkkXTpAqjeg8xxQFRRgbTCJXp4rH1Idb3E9XG9JsQpfN\n", + "UvvtBlNh31n7r+CPOI6kVTWHptnGXc/1jRHbB/RJRNSKASm9fGlpJHW+eHllvno5FOq5KCnGOE2J\n", + "7D9gnrzBuJaAH9NwwKDU4ggP03EgYr8S1um3AQprqCZjcg1grbg+eF0a61AXinUMr67dNT48+5Jd\n", + "A+afjIqyjlD4VVPxgHoCBuTooefC5HHFfNSpI6AKkADP1YTcAQLMyQM9//RWDLl4C9pnCT3k00yL\n", + "TIiUTx6srwuPSPnw4cOHDx8+fNwz3hgiFabBgefWCcqFbwlpUZFnXv0pUbwgNEsXQiO7OkOpNC6M\n", + "vJ4DzVG13Q25hZd4Mw2IbK6KuQtSVt7l7k283xsi1WNVsSPF4g4SC2PDZHP3bxThrZpU1wNc5M3W\n", + "Vj8rlAan5BdU4K1+T4hQi7L6ly/M/+nn33Urgq6z1WyE0m4lTMa0hI+BKuUzLhgHEZHkAtTjrCvp\n", + "TR/Xw25EHcpvw8Te6lv0XUQK5PMliMyhK6HffGEruB6ok6rEi4g0aPYoZhIlSOlETuy1TJ1K8hPI\n", + "TgwpkdfRPjVWLoy0hCjrDciHq6xUAdu+dw3F3iMqUw5Q2JDQ/hKspg+8zka3v83G9d2jxTemz5Tj\n", + "nOaGCCiakpOsR4/z29F4Vk+snIjiKrvA5c8xbp4WDcv9FYJYXpP8xBxK6HzvqnTIkhzhtRigmLHX\n", + "XIXfEnlXFc1B+mWkczdgLqDvK5rLRSQxvO6akjzJBnWQt++lIKpvLm/oex3O3aF0Y0vSHCrJwL5y\n", + "UHseCVbtgQhwSfzkNUgr4hboTJyw/IKLOaEZKvHw9IlDKb94+Xz67GTl5rPthtE/d+77yrY1IIg3\n", + "JJOiqvBHR4bmaNn9EamXa5vs8NuE2loLCw5QJSUHU6FKEsGTkuvvVTKClu89yujHHUG8kD8IQV4O\n", + "F6YYnmKO3xL6qUjHV8+tsOMTFGPcio2/GYjnazrPEHIuyyXJ3qB4Z4c5/uqaJFlKeL1Fd5Xgj+Z2\n", + "nmaPaN9TV4LTYysKSFGMNBLqluJBkadKLKcCKIwxShJIiPGXUOZGJQRybn887lNCOMfCXWPNINSg\n", + "mRN2hYCfLe5P7muFnV9efzJtmaGIZqBinwIP9Dinm1LtbFMbFCXmMX1OulCJAzxrIp5XQRints4w\n", + "1x5YWAKd60ebJ4IE8z7tL0owJ9EzRrzXng8fPnz48OHDx88m/IuUDx8+fPjw4cPHPeONpfb6YZAg\n", + "JYVpkC5PKRVRg+TLSrzj4FJmQ0dQKFJfNcHoynEsEtIlAmStsHNHRMgBkG0QGWQcpQ72zYnD9+jc\n", + "bXt1ZVB0r6rgncF/NVIElIGZ4FFNrTA6HkN3qKwNMk1DEIEpFaY6Rim1XQ2tnvXWfvvRJ05l9+HZ\n", + "V+0a9XJDEFZzItBBqyRLKWUBku2hYixMfikFq3DvSKrQmtoQMvyN8b2ctMJikM3zU7dtt7dz+vEX\n", + "H+H7BkWrBk1AKroR5NOblhVzdRwRKR6QNXENRWKVKoaKMkmxL9HxGcHOOQjYZUepCEDrN7dG9k5z\n", + "158djdNhUA0eguAB6V/duNTeIrdigzkGT0D6UDUUu/u9EeA1ZkQif+edd0VE5LPPntlvQWx/QKTQ\n", + "IyhlP3/m0keTAbSIdCDxsjq9pnZmM9KA27lzykgBX41+mahsJFIbY5pKVX0ylhFXrZiGDFong2Ai\n", + "cffQhUmJlL69dum7oTdSrBLg9z0p5eO4msab53YNGm3LRFN3fmyaPCKpTVlcaeGawGlMS0fc1VZi\n", + "c1/d99WVS/MvqIhhC0X/k1NLY6n2VUHaSgOcHwJWFsexmOx+dubSfE1F+mGq7aZtTP3VIT3PSRcl\n", + "tAdkRjzNcZRaDyJNgZIrhCqvl6xt5Nqux1wYkGZQhGPElJ6SEXqDVOxzHkDHbG1zYonU/yw1Un4q\n", + "7p7JFjZ3h9AN1EKMkwekLYZ0V0puB+dnjsSf0/UL2j8msnUN7cGLS0vVPjhy93tA43mALlMAVfb+\n", + "gLIC43caV5PRNz0nA8yTIc3JmirLaEyMmqIkU15Vnq9p7oqCQ01D1gILAndOOyqe6lpoplF6LAGV\n", + "JSVl+RhzHDsAxBj/O5rjmvbm4LrZ5DiCaBWbdgueNey2MKUniVqRxuooYm2SJA3Ol8e9/MTwiJQP\n", + "Hz58+PDhw8c9440hUp0EEsX0Zoy31eXKCKvlpCJOpalYYSbklxXDf6ij18IKq+kZlclHWDKqN1ld\n", + "2UozTO6qqSphNirsdXSJVZ8hHiK7HeQMdlSS36qKNhEwR5RVgsw2ULl0CFIkE8DzDOgblaPmIOrF\n", + "e+u6AghPeWsrpw8+ctIGa1JxHsStGMJQyeG0CkiB9MR3icA9aThsUC67oDVpCzXsJCMVZSXsDdZP\n", + "YepWkRkpFWexWxGPuMYnj74yfXa1ceXqbUuohhIhiW0cZ6q2TX0dqXQErf5BSkzYkyrW8lusIKmE\n", + "eybqYXgXkSoKW8GqoHEb2oqsvHGr/pqKF9QnKxjvkpLr3v32YmcFAzJ3K91stNVvGLo2bDvylcTq\n", + "/Mnjp9O250Ciqr0Rqx8/fCwiIiP5VH38I+e7+ODcqeK/vLTjf+29XxARketrWxmeA4mak9r2FTze\n", + "CMySCP3DfpZaks2rWfXEVCI8K9ZnhftMfRBFbPWdMtKiis2ENJ0cOaTjk09s9T/HCnO1MuTu8tKh\n", + "GSGO22U2XrU4gREZJbsyIqP/y+i3bePmqTBgNN39m9IYU1+9kuYpRWCbTv0/6b5CX2/3dl9nkC7Z\n", + "r21M6D3eU1sr6sXtdHXhUNTTE0O4Pn/h2qzI1FeTETmUyzOqiEuMEhsTiioFNHdpUQITewegeUFm\n", + "RG31XY1x7j0V8Uju+i49O5s2NZB/2FFRiEp3zKitb3DZcUAyJSnQJFJAj5eu7dQbtSG5kixwbRwN\n", + "Jv/w4NzNvymlHxQ5GkbOnLj9XlyY1ITgvufiEUWRukElTMh/FSz2jjQMFOE98HrVuT3kLA1cIcgB\n", + "QhHeIaPvqZJ7x9Ixbt8R5i5GkHpIARUkIdDjOc3FO6oQn2YsyQDyPj28w8iN8Twhj0V9LmpGgtCn\n", + "xRx+qSUr22/xL8lv4NmRkkySktxzyjrEKLiJSTqDmuy14REpHz58+PDhw4ePe4Z/kfLhw4cPHz58\n", + "+LhnvLHUnvSh1EQEKwCtdgQjp4DKn18ZiTeAgMZsQWagQCVbUh9tkUbp6Rgj3hv3IDGOdPmKVJNg\n", + "+QTtzgdijCvsmJKKLdKBGZGya8CDFSm2DjinCTIltrmSrhdErI5B4ksTIrYG7gSPSbNkB7PUqLXf\n", + "rrcO7n7WGdk4gdHzYuWgzXlORHxRg2JKO8FQU02BRUR2UGDejaxZAriZjJwThZtjO/cOZPzN1tSz\n", + "i1NHtmxbNYi2Dnh05NJNn778dNqWgZTPAiEJdISKgq5HCcLUd5FqkFAKsEK6U5Du6tnkVTmcwqko\n", + "1+7xaPvNkUZqdhfTtnpw19ixYjUuMSOy7YgCCT3Wq8uPp8+OoB4dCaWxcY0JHV+1xS4u7fhKFF+s\n", + "LAXy8TOXxjs9NbK5ppKDEHpKM0utX2N/GRGwM2ggffHcUmZffvddERG5urI0YgaCfEzEUtWRIlFo\n", + "ERQNaEovT20MqxL6nFLGDdK8yxmZ/CLdsbmxFNCIioJTUvu+XbvrOT6y+3S1cv3Z93cVnkXV8Snd\n", + "HmHc1eSKkOdI84xMI8D5UUGJ/nZPelfaTmpGLCKyWKiAnmp8kfEzqAU9pbsbjPViaWOihfZQQAa1\n", + "EegTHaVAdtCWamiePDl1bbbbIj3JaXTo4yWUMlOWPad7AhQAjZ1dl6pi91RsoUa/UW7zzqgafVDA\n", + "jniehsZQSppdK/TxFaWR1xs3Fi+pXTUtGlMBSop5nPjHkiUuVbecuflsNbPnT/akwKmRkXeu+6fi\n", + "KUwZNQk0KUUhTS0FtoFuYBnfbRMt2IiJHtBPhUq2jw4PLcq2SoeUKhdlhRgLPVEF1NKB96eOGilR\n", + "MKJE7w+Q2CllnMLFImiIgN67MVPSMyFFMUrfGFUgxr0b05hQJfswIw3AFgUd0CIribKgOnoj6b01\n", + "FWgURO3Q/mEjY03pj0QpGEBL6YkCEghPWnfDI1I+fPjw4cOHDx/3jDeGSMVhIe2eSNwPHImQlVC1\n", + "FLqubVu1BkpEK2f1ogpoRajeOXsqiVcCXlnBVy/isnoQ+0jBtK0O1VRFRIJpBW9vqAXeqnNqzhwo\n", + "FS20plVfC9Xh6mC15FY6p0BhRKyEWgJb/aZYsZ8ckzcQ2uyEFNi7Z1AAJmXjGuR2LSHlzp8fu9+m\n", + "RLrssMJISB46AyK4L61dYyBXpHUuqaIoO1sRL7Fy3O7snIpUVydQwj0gx+J3JImhvmcpMZvDGF5r\n", + "dEGxKgCTT5+qMbcdlc6PqlQMwjJBkhVQqoT8Ghdo/yI2RDCCdEIRGmFXUc+BiNJanh+x/56qp2NJ\n", + "nJBcR1m5VVeUGbE1xmq2r21MruF/VhABPEafXYMILmJK8ayUXwUoyYYP3bvvENn/1hHmQ0JkFJ3g\n", + "cu148lWbNk1k9M3GUCKVM2DQJ0anNUB/DqQu9uqDSIggVp1NY/2k4yQgRLqG7EIQ2jZdkbZESk6A\n", + "sAS4hpjIsZMig52uzOZu3lHJERGRGvIMaUoorZaJE0qjyE1MatMVxsl8bmP88tKhmW89dgrYF0Qs\n", + "X3fuuEfU1zV8AseA5k60cUQyKWv0J/sP1nt3/JbmyS3mWJVhCInErIr5rBitfo4j3YD68UgOFIoO\n", + "RIRwjSrxQaTsUQtegOYw+qZIa0sE/FDc9R/RPLHDPBHdWl83KgUwEClaYRzanxL0ZyDA53S/SIr9\n", + "hdZek/yL8PNEBzl54mF88hjvR5lqxwAAIABJREFU4Cdb13aeOu9H8BVl+RW9d1iRQ+dplvvX8cyF\n", + "Qj2eSSWN3RxFW+FB9QT6iRAeBSCzApkj2q86PzQHjg0owKrZV9TNMTN2W9i4dp+TdIuS5wMiyseQ\n", + "m1A0KSP09frazXEJne8IFFt9aEXoeT9wNsPtt2mtUEOATvGzIAkpK/Wa8IiUDx8+fPjw4cPHPcO/\n", + "SPnw4cOHDx8+fNwz3lhqL0lEjkgLKgI8W6RkfAqy5SI1wmwXf+x+HxiMriTOkJTKC5Bc45SVmvE5\n", + "INOGoFAgwUJelJKCRdiVlEaKkGbhV1DAmPHIWhhI2ZAxsaYbVW6qZu0MkFNTuv6z43dFROR6/cNp\n", + "29A7qLigNF6OdFA0EIkQJ/jhJx9MW7a1S7OonkdDRMh5r8q1RKydDG05teNOPididwtTW9YnUp2T\n", + "ltJiqlrOOiafvfxYRESOFg9xTgTxAyrOidjaTyrqto8M6RnKQMiANF5OattV664/ILXfrlUFYvf/\n", + "OCciOrRgQlIxj0GALQKDfScCMLE9c4ydLY2JGOlgJs8qkVnNbdPU0nibrSO55rmlDIvMQeAhDcCq\n", + "2+D7RuJUlL3tDbJ+64lL29W1fW8H0uZbT50C/qsLI6wfqbYQEVFV5fvJEzNeffnyJc7dUhZqkMvk\n", + "bU0VsCq4GiIrJ5TJoUoE7ohsrVo5I6XMVIsqpNRSCQPfjtIYi+URPrN0S4zzm8NcuSODZtWUS1mx\n", + "GuMqowKQGiTetiFdOpxnRPdThfRNnDCxV90OiBSLuUv1uQ7TaFDWJ2LvbO7OvS6NApBhflDCuIhp\n", + "+lxevLLrxz3bUapUk/QVtNVS6q8K5OHV+dv2ddyTIc11/R6adUSsHucgoJMGkrbT2LPeG+ZOGKiH\n", + "nfVrA02zDTlA3EArryHdoyJ3bZKSQfQO2l6c7t+DZrBYkDEx5sUEadHF6uH0WQdz5T6zdtV7bOyI\n", + "bC+qd0epfcwtccxq29BFCsiEHKnFqlEtKrHvY/5lcnSj2of0TIyVosHEfjzkxoxSgEjLthUXZemY\n", + "JE1DUGlUF6zgFHzrjlFXlsbX1KPSaEREUsyTHemYJbHSLewald6RZ0Z2H6HbOIJa0tX2XJnP3N+s\n", + "mdbu3DgJ+ZmEYqecxqm+AjB9p93BmJw00LqA74+74REpHz58+PDhw4ePe8YbQ6TmeSAr8hBL4JfD\n", + "b7o3W7ctIw8tRWxCWumqAndHr7X6VpsRSqWryAZqqjWtwgZ9WyfSY4DVZzAQqtW6t9+MyM77BiW5\n", + "VEKcYKXVEwVbzyQGeTAlxewCq9SQasMTqFgX+em07Xr7oYiIRJ2109HCIXZja+d0DlmBF6RU3Sdu\n", + "5aREwYFK6KsdVoFExCzQPyzOrQrUjVBZP/qMyeaCFXbfW99ttg796ENbzY0D1OuxWoyFFauhRE5F\n", + "AYG++1NZ/USKpFWFqjGz15ISiYPA9jcDKVHbZDG3VdhmDW88QpWG7RfuvA04kgSq+M3AysruX/aE\n", + "S0BaZfKqKvvWgjah1aoSNpvRVnpd6MZwQihFD4RtILXfPZCI83NbTav8xyvy+nr80Kmh34CwuVgY\n", + "+qvE8oQUu2dAbq6vr6ZtF1cOxfo3/+bfTtuuLt2K8GhpCGuP6+lJKbrFPauuAyMVOwTRXUkCRUxj\n", + "gmkUm+AVtBK/h5pWxCgnr0liJcbqtIQkQULHV9SLj6+SDAnPSUB/GJHSwpeAFbMjRYJtRT4rHJpa\n", + "VYSwZoc+hTEdq1b/OUL/eqA+A5lIblDkMT9A/9z9N5vZ4L25ccT2orDf1pAYUOA4JPR3QBFHR2zn\n", + "dOXkAug2kQDzGRcljLhnB0KJApi8DSQnoaj3iKKQgyKGB64Yp7+1IoprEIprQhACoDNRRvNEr0iL\n", + "7W/yiZxbH5e1O5cWKt4xef1pwQTPKzUKAFq6/xQ5YZ9Svf9shhVJ8Axg71QtUBghScLnq+hsQAhe\n", + "jGPU9PyLdMxQn4yYobkAQmU31FdVRGSPv0OxsXMMLrgWzPD1t0B62tY6qsZzl2UVFFqNSepB4DZQ\n", + "0niKRjxPSKbgZOFcGVbLB+4cdzYnbiEhsSttTlrA47CLbL8VnjHsqKLX3VMB0h5SCxJZhicJfjLm\n", + "5BEpHz58+PDhw4ePe4Z/kfLhw4cPHz58+LhnvLHU3mqZS0Ygp2rrxBHB+PibBGMn00bVieEod2Ru\n", + "C8BflXjd/pSU52DJjJS9a6QFgpGJoFBxpfMMkXpqW9uWQltlfUmK3ZMsNpH9kCpUWHQYGXZ0qZCu\n", + "M3Kiop1MzlPCap4xORPJjcGg2DnUkR+cGSm4vQQpE8abLZk2N0pKpPRIAN2pjAiLKdqwZPJdp7pc\n", + "Npx6VawmaD8EoXIk9fAWqb2qgvExQcER4NQ4sPSQGp7GAadbUWxAuiOaR+16Mo1O7iowZ0gVz2Yw\n", + "dCXNmgGpgJbUySsQS2+2RsrukY7tqZ+C16SqCuinhAGPJ7dvVSKOQtoH4P7La1NWzk8cxh5QylS1\n", + "zTi1sFy49A2bcPcb18YnJw+mbbdrR8puAXEfHbFqkp673ZPPP3dpwS99ycjGIa71xQtLGT565FKG\n", + "tzekdp7qvWNHUIK+Gi8L6wkh3coFEAHunZrukw6K6culpayuLt1xV0em99VMjgYWqtmjysoNpecK\n", + "pM+YMhCEarxq4y+BCWtAxNYG9+l2a3pDswKm3ZSWK0HK5xTYFmmLAoryrC1WgPj+6qWNiRppyYzS\n", + "WKqfU9N4UrPmyxeW7l9gnGwoVZKlOk6VCE1FMbEqq1v7T8TqlbW13CJVR3PcgLaN53b9WqAy0H0X\n", + "Ne4eC1D5U+2sOKIv3XGT0O7hIxhpM19+g/n58YNH07b9Z+4aS0oj9pgf1qTVNcApYuxdH3ekDt41\n", + "IOdXVNiANGpIRSw2xbCRLxS7A0qVz/U+tVGp5us6/gN6TEfY30j6SBnuIU4PdpgLB9IW0/ERk97T\n", + "iLzpjjQNIXMoy9zup0oLNFQzLLTGVnPllsSoVBU8I2L7AqTwkO5AvbaIfptCM2qeW999+a2fFxGR\n", + "NcZVRhSIaIlCpZY1u6DsTs+pGUQdY65KUvcCunekc3831Mb9gZrc3fCIlA8fPnz48OHDxz3jjSFS\n", + "xTyWiMrq1Wtru7bVh77Vk2Dp9PdAb7Wqsn11YwREfcHsxVbEp7qI1BUuvQVHKE1nNdUBvm9Vwyq2\n", + "bjXBSqdpBqQlsVLz7d79TVx3ibGy3OMteBhtZXaLVdeTh/ZWvSsd6tH0jFKh/JYIiLcoe88DQ986\n", + "rDCWCyLstW5Fui/VG8/OV1fQrPq7TNz3Y1qRBliRxqQEO8CvbhhJWR3SDhGxovMU5ayBrXS6BCgZ\n", + "CPshUdaVsBsSgtUNW5ymoW8DSKENldqOk08Skc1X7riqxOx+DDQL17XMSf7hyG3bxdb+u41r15CI\n", + "iHusXLqRjo9+GglNUC8o9i5LAiWqgxzPhGWMMVbn3ZVuPKeRSSKoTEhC6KuWR0eHtfM4d1q59tgf\n", + "ZCLy3Mb1buf6+IxUtI+P3Oe7va3qj44d2Zh99RIgsQGjSTj+Qak9bvJsruXN5A2mw47kJ9K5KjFT\n", + "H4LY3JF0hkoxNCSd0EJlmZErnQOGyWvPxpqivxGtRnOQ7XsqP+8w7jLy39QS/0hYEsK12Wpp30sS\n", + "TEpEaI8xPtWbUPtBxBCk+cL65OKVQ5gWvfWdqkOXe0OaVFF6sSKy+bXr/4L8FNW0LdTJllbwiua2\n", + "jNwCVQsrzhK4vztqzxio60jZhE4RgQXdzxsUeaDf8xMrgNhcu+u53RixuMR9F8fUrziXJKbCAmQp\n", + "opTcHga3v+2ekHNI18QR+rqiEvq9O8+KXDmqvSKtNq5HFJ7w+I+AehYkcaJSC3FC0imFO2e1RKxJ\n", + "riMC6s9FEeoxGxw8J4EmcoZH56eBfBpr96MtOVDMZ++IiMjx4p1p24PTYxzLPWuu1h9Nn1WQU+no\n", + "2aH+e+yKEUPqIKL5V9uHAE7JVy5LMKd2Ws7dfBf2rr++uLD5Z712Y7glX0dVhRdCE0XHHz0TVCak\n", + "p0KFmXoRVlQowUaGrwmPSPnw4cOHDx8+fNwz3pzXXhweeJg1W/fmvN6QWBx4CENnb7Vz8JEG4oio\n", + "ON16Z2+NKXKo+9oQqSB3b6kRVvrsqj2VOjOCgTL5mtAX6PzJcmb52wGCkbO5+QXdgsPRs69T5b5X\n", + "QrhN5RVERHqUs768+GTatsjh1xbb27d6TdWM5o3u87r/fNrWNsg90zJlrs7t4CXsKFdet24fHSEC\n", + "A0RSg9BWvw2uK3qN/2BNTt/D6FYVMfEBVDgzJtXTEShWrR5qrfHMFJxqB3KQ1xJq4j6FEHZlUbW9\n", + "CgIGzHlxq8nVsXE5SiAWKv7Z0wpOVReKwa5hOXP5eALzpITvXcMwIVbkPYmJ7tHGq9SQAy0ZVt5Y\n", + "L8Q9geN6QH5l13vXx3lhqzUt649YkmKm6JsdPwFvbntlq3lFTs4eufJi9Y1zxwWngvlA6KeqtFXt\n", + "fOna9elbxsf77LNPRUTk5MyQs/UNkFNC6ZT/1GFJmhKqs9u5m60gQcwBq/6MYGpFApvGOiVBX+92\n", + "dq0hSq33FaM0rp1yIDID+fCp/1mW3+U0MaqoTvfdSP5/oZakk+jt7Bj7JR4cdpOT/EDbjDg3d9yb\n", + "Gzvfy1dOfuPs7PG07RTCqZu1zXXKkVOxVhGRBjygq621k857jGak4KulkDoIhFEFnTsJfdM5s7T9\n", + "dkD/kpPjaZsiVwEhrOnKoU3Djd33gcqDqDcjrfdXj9x1bT+1uabaut9uOpsnB6BJw2Dfy3I8J2p7\n", + "xvSj+7za3c1OxMhOjI09a7bwhrtak4dfC04TzeeKCIchPWKBHC1m5FMZ6XPH5rMOqMsISZSIZACG\n", + "Wn39aKyNmBNZV2HAPE18xBrzYxsxmuX6oihM/PLtx++JiMj50ZenbSt42x0tXH+Gyf8yffbjZ/8k\n", + "IiI/eP4fpm25Xg/xBlUSoqfBVjcqBE3yE8gwvXVu3NgSCPhXn35dREQCylJcXv3YXQuJ74YQTI0T\n", + "4lzqWKc5scXzTOcGEZEYz2LmHAr7WL4mPCLlw4cPHz58+PBxz/ipL1Lf+c535NGjR/KLv/iL07Y/\n", + "/MM/lLffflu+9a1vybe+9S3527/92+mzP/7jP5b33ntPvvGNb8jf/d3f/WzO2ocPHz58+PDh4/8D\n", + "8VNTe7/zO78jv//7vy+//du/PW0LgkC++93vyne/+92D777//vvyV3/1V/L+++/LZ599Jr/2a78m\n", + "H3zwwQRzczRde6AYXOPvPcG+mkbQ1JGIyAwE6H6wdMc8VzkBI5vXKO1v2P/olYNbFwvAzuQDFUze\n", + "WHSSgPjazoiQO6jeSmCQeQFPqIR0GlYrB72rmreIyACoOO7hw7azz1IQ8DZEolRFYy5hjyNNNxIU\n", + "mbq2224MHleyd55YykAVZaPYwbMH9LlaCfi2dRB3PS31Uw9YtCcYW9McTGxuUVbbU7pLy04TVraF\n", + "anyC0vDbziDrPnSpgoFSwDnSgz2RCHuQJ9nDbPI6E0uBtbXb1u2pPZFGaPYu7RRkdnxNbaSZpWxD\n", + "nO+YEgEXKbU6tL5TlXUmz2uBREkyBT1yhKrAG2fUKyCCS2iw/x6l201iqZ0Y5MjFwqBwTTM3JcsE\n", + "uOPvqCT/7MylKpX0yeTgkyO4CHC/oiSbvR41tff555ZaXoDQ3ZV27jOkCLeUWjo/c6r9O/il5UR6\n", + "1nLugIjde6T74hmpDiPd21O+tVi6lNFu5DSy4HpoPCvxHQrnXOo+R2n6bkv3OtKMTDbXlHJH2xYg\n", + "dkeUglTyOCuVT2XalJbW6y6RiuNqbT279a2NtZWSc+fW/7fo45iI8nqt6isoIrKGJEZCB+lAJFdv\n", + "tJhSsSrrEbCzgCp/UxorzkHLoHzTmLk+Y/mTEYRyLn8PVB8jvlucMSK1++iRyW+UaLuyskKlqwqF\n", + "Oq1tGwI3Fvc7SguiZH6/5wIIkPILlRrhMYQ0Ms8/+DOgeUofea/z/9xT8YBAbifOSvqeyk6orAC7\n", + "I7i/t0Tt0IIFLpSqUIwRkpxIBPmZiFS8NY0ZEn1gQIUUe2I+eOCI50uMnRuSZJnDeePB8q1pW1s+\n", + "c+fEUjdIQYYHMj0uLZ3SfXINl4WQHC0iPFvVPaCIbR85zv2aUrsj5tMgtNzmqHSL9jVpWZZuEJVE\n", + "kDu//dfipyJSv/qrvyonJyd3tvNLkMbf/M3fyLe//W1JkkTeffdd+frXvy7/+I//+NMO4cOHDx8+\n", + "fPjw8f/LuDfZ/E//9E/lL/7iL+SXfumX5E/+5E/k+PhYPv/8c/mVX/mV6Ttvv/22fPbZZ6/9fT82\n", + "IgG/Qbt/B3oL7QMV8LI3yBXKIEsqTTyaY+UU/8B+i5UQcadlv4XXT+LeXAMi8en7cEwviPMExEYW\n", + "qYT44nZtq5rjpVu5zJaGXGgpbkirlFfwaUuxwotpFZABrQj5hOEc3rfWTVmmb+JUwquIFa1cSnVH\n", + "H8klG4TWNHLnduANhVfqjnzIQpTr9j0TsEHKJeRoelt/zcs1b1LvsIgRSpUfAKE9TowIvq/cym1O\n", + "S4MRxO8sszapcC7DgYcaCJhEtlSn+5HE9GotfwfSNnC5LKQbophL8kFYpEKFCKhCOjJKoT8g6Qac\n", + "p6I6bptDWEIQywdefcJrKyD5hRDnVNZEmEaZ8IwI6JPDPZHn9xDfXFLpvJbkB0AJj1a0aFKUhOQH\n", + "IrRhFNt51rUSxQ1pzOHPd3tpKPEcKBZLHHSTJ6L7d0YEzxqyAhHBxA1Qp4H6XwVzWRAxCFRMl9FH\n", + "1z4NFY/kmfvteuOQixmtwnW8hrRa1gVkzygx7mce17e3INaTnIQKaw4HpdTuN3sqP49iN04U/TqQ\n", + "kBj03OwaVImC0Ty9jusrQ6lzILa7yo6l5P6W6s8VAVKiNJ+tCqgKy3ooeZfnSfh0joT+hRgfTF7v\n", + "kTkYaIxNXGQgaD2hCiHafUMFA5FmFhpr/7p18/Nub4hUCq/VVAy5e3Xp5slrEnMu0CYZ4KT0AG7A\n", + "2A2tvSbZDyrrV08+RmTUO7MlhKvCGA9J4kaJ573KhfRMdEa/U1FGi/lnSYj8PHb3eJSyxJD6vxLZ\n", + "utEsBXnNVU5O4/LG5okM93MaOjFf9ah05wfkjISLBRkTSohM7ZQWVqgVYr4fyKe0wBzwyfP3p21P\n", + "nziBX0WO5nO7r85O3D5utnZdmjkR8lXVsduTdEcPIdSqvzvHhiSJMIl5/ytxL7L57/3e78mPfvQj\n", + "+f73vy9PnjyRP/iDP/hXv8uTgA8fPnz48OHDx39PcS9E6uFDc5T/3d/9Xfn1X/91ERF5+vSpfPrp\n", + "p9Nnz549k6dPn752H//h330qgbgy1KdfOZOT87PXfs+HDx8+fPjw4eP/zXj14528+jHsisK72RaO\n", + "e71IPX/+XJ48cZoxf/3Xfz1V9P3Gb/yG/NZv/ZZ897vflc8++0w+/PBD+eVf/uXX7uN//t+eSkck\n", + "buncqRyfWGqnBdwfjpQygAZPQ6kltXhLyOtthC5EMNhvA6SgUqhiB6SOHEdIOzVE+gQ8vSJPviRy\n", + "qY9Na15r12v3QniyJMgS53K2spfOTefIwzsowSakxZIDWk1J9buHPlYxt/NMEpAII/ttDZh/IM0O\n", + "9bgjCyepALemUO/OqP2HACkeUidXv6RxNOAyULJfamnM7R7EQtbWUZIr5fa2e5da2lNa6mjuiO+B\n", + "wteDHSsLHQRfZKZF08FDa6S+y0LVUTEIfF+6lEY7rKdtEqpWEF0PyJglGqojEn2duN/OCoN1c6T0\n", + "9gRjtyAZL2emmbRcuXF6RZpNHTStmtp+qz596jV24HQHjZmYUkYJ0ozDQWoJ6RlKY+1uHRm0IRVp\n", + "1TuiDIzkGbwGWdlarwtptKOF9fUGukxJRvpgSKM2tZE9b0DoTA8KTVzb5VTkoenODON6t7VU1B6E\n", + "6cdnlm7U1OpA16rX2FKbBKUbYwERuwOkmYKDaQ/pFozrgcj+qiLN6TlNafRkGKgpTdWdEhHJQTa/\n", + "urR5YgkvuvhAWwdFBlyAgXPSO2c2IwqCqv1TyrhWRXFSdtYufnBiaaz1Dimj1vqkRAqsIK2wbCL2\n", + "unQHe5KmaM+AtIBUsT8aOWWrPqn22wHXyOn+MHV9xt51WjwzIlXG3nAV7pMtKbbfbHGPUbFPhblz\n", + "X1ubLDHv55HNJ7uNS2OVtbXJPHdtluDZEZHuXQIfvJiuoUPaJyT/zyiFd6YQKV/7jlKAI7zgOnru\n", + "dOj5QRNGKX2GJk5jG+tPlm5cPSTF/hy+cjXlZTfQfrsmVfYWPpI7und1nq5La2MBKXtz63QOAzqn\n", + "568+FBGRm9pAlBmuK6JiAx2TQ2/HUo28kTTwAmg/PXv+T9O2y+tvuOteQUeLiggiPHd6ola0oAMl\n", + "4d13jJ7SeF2rqvik1QUtubfeXclb72Luiyp5/98bTeG/jZ/6IvXtb39b/uEf/kEuLi7knXfekT/6\n", + "oz+Sv//7v5fvf//7EgSBfOUrX5E///M/FxGRb37zm/Kbv/mb8s1vflPiOJY/+7M/86k9Hz58+PDh\n", + "w8d/t/FTX6T+8i//8s6273znO//q97/3ve/J9773vZ964Lq5mkppRURikONyXulCFbsjFeUEq7+U\n", + "3rR3a+c6n82pJB/s9aEh/zOsBHoopSdEmAuwmghiJtZCLmFmaccCsgtxSeqsg1v97ypDH06XXxIR\n", + "kRk5aD86/qqIiHz0/D/i+LaCTRKgL1TWOQB9YAkBAdIW0+pL7dnahoiNkB9QJXQRkYW6g3c5ro+u\n", + "FY7X4QFh3e0joRVhjCETEEo4zx06uSsNTRgCKMaKreYVMCi3tiKJBKs+JYJTuXoUqlu3XWuGAoBd\n", + "ZWRbJa9GhPCt4Ml2S5DcGlIUY0Hlv7gOJSK2hDRMbTfaCmYAobOuCblEHxeprXTnQOySM9t2e+NW\n", + "v9veVnqKhGy3QL/mtIJFHzPpMcH4jFIq4R0hobAn9Amr37wwwmgJhEdRKBGRFVaziqqN5E331hOH\n", + "pn7x3GQNFLBbPiACOPqi3Bn6tzwCskyKwMpTHgm5qLbuOo6PHep0cWFl1SorcntLqteYMypSYJ+O\n", + "SchZj+tXVFnEZAUYYekbdakHEb5ncrDrm57Wglr+PraE/u1cf2opuYhIiPF8cvpg2vbq0l0bK7sv\n", + "UE7OXl7RhKxjpU0o7YS60HkWMx0nJBMA6GJPauMZULKAkLseF1fvyTsTh8iAxJU7m+tmMzd2IvI6\n", + "DbVgg1ByRe4Gup8F/odCThWKxCY0TrVCZMzCg/+LiMSp+trZNVzBp7TPbK6ZYc5uCX1Tr79ZRp6U\n", + "ICWPdD0qRRHgX74ElaJPGOlEQU/EkhBKVCf0KYfaekyP3RbEcnZFqOHK0OH5ENXWr8vISQ28TZmb\n", + "r527TIj6YLofuf5/tbb7WSUbeip22eq9u7V7t0db9NTuR83Hbh8btD+hSl/c/IvbR2Pz2oD7LiX0\n", + "OcS1BoEhzKuFe3bs6RkfwAGiyO0e/+jT/+L2i0dx09iztgGqxl6jWiDF42QEOlYk9oyNJp9Ce551\n", + "6LMg5AKIn0wn98rmPnz48OHDhw8f9wz/IuXDhw8fPnz48HHPeGOmxWEwk7oxImCag0RKxp8d4M7Z\n", + "zCD7o4VLN+Qzg+w+AiktmxsUFyfut13JpFT3bw+183Ek0itSgVlKmkVIC80oPVCEC/zW9puJg1tv\n", + "N0YsfXr+CyIiEtD3zpdP8T2XilxvX0yfRSCPRgnD2O64FSkmK+eMjRdFoLbckeEt0l0HRo4rpFRw\n", + "TllEaR+FagNrwxCs5Lq1fsqgQRQQAT3BfuYFqSODsBiFREAFyXsgtrMq0KeZatxYimF1pDo6dKXQ\n", + "AtqKQbsRdKa4KGGZO+ibYdyb9cfu+JFdTwmyc43BURFhWMneIWnBqAL6SCTKBinQs4WZfKrIdkxC\n", + "Ku88cmagr15+NG2r9i5tFWFN01XWXhuoFx+fcmoXKZPcoPVycPvII4PMZ0iVlDv73sOHDkYfqO8u\n", + "ofN0/tClB06ObR81SPEXV8+mbe/93C+5/RI5dQ9T3dNHp9O2FFA4jz+Fx6vSfnukKUCMyYjo9nOY\n", + "BX/0wX+Ztj04cfc/p8L0FmNlcZXAynMiACMd8/KF3XdH0H6bZHRovz3SAjVda4b0IFMQdiBxL+bk\n", + "GgsyNve/qsj/V/bea8eSZMsS267FURGRuqpu3Wo53TPE9ADkL/BLCRD8AxIghgIzGBIEBzNkN7v7\n", + "9lUlM7MyQx7hWvDB1va9TkfOfQjgIl9sv2Skn3NcmJuZu6299lof35u2nmYM1mtL1ajO1D1Ux7dr\n", + "owfo2ndNaczvvvtWRERev7bCFrVomHo7foN7PdPcscH1D1SU0LQgGyPNvVrZ95fUO1EGVKwvJL7F\n", + "lCBlmdgjZkKBBrESJEQ6fmL18E6NZHEMSsUlOP6bl1YNfl27MXlPBPCxd9f/4spS69K71H5LFIwC\n", + "9/FIKe0jlOxHFMLUDaV4QK0IKbVXiNIiuCgE18pq56o3R9/LEzdm+onS0kipta17npRkfP4K+lQv\n", + "qBELnEpAafQOumQtORvcQ0eOr6eFyvpEBTAp+mwq1sebDs4PIG931F5atBWRsv2xR7qbtL1WmUtz\n", + "pyTM1YA0npK5cFC7v9e53fe3734vIiJx644/xDYmk9i13WptyuoJtOJubt/ZNqTMUy4ACNQV5bHL\n", + "SUtjggtZPhUekfLhw4cPHz58+HhifD5Ean4h02AljFoGPRBhbQaztaBy1Tcv/1xERJrBlMWfX7jV\n", + "dN9Z+WUMFKkiZWdYty2rn54UThe/KDbYwSq1b+17+dq9ueak4hwF7i15jozEe4Rn3jo3smmg8gOB\n", + "e9POiBwXLsRG8sYCcsZcc5UimFkmAGXFR+HVP5RlSZW5A4lPycY5EdsTrJKUuCcikgAKioVQpcGt\n", + "kvLE3v61xDkvqEwcv73v7T5NoypVE9l30tUMZC3onhyO7hrWCa0qU3cuShwWEenQZ7alISKKNma5\n", + "3ZMX2TciInJ7MEQgGN1fztrEAAAgAElEQVQqLceq6kikxxAwxZwwiVjL5W1FpHIGH2+MlP3swrXP\n", + "xcY88ULISTx7ZsULB6CTSgRviOw+q9fjyvpwAaQpzoiwC3/KiFR8k9D1iWxn2xqsTvkeqyZcAfkD\n", + "9ot8+86d22ta/U/wNVSSuIjIJbzeTkRYVn78SAhPr6RsKl4YOi1TRltTaXJbu209+W+qT9tE6ui6\n", + "WjycbO7YAOGZCeEaQOwfqI0rnPOs5fqkop5pYQu5LShaxOekKstMbO9BqJ/J10vR5DdvrD0Ph/3Z\n", + "NYiY80GEsd5SCX8AImxNHoYbIFa3Hw0RzyBnwAU1R5UYIaVsLWRg5Gy3dvOpIngR9Yl40ZohWGlS\n", + "xwAbE7Jy816YWJsEmm0gr8cZ7R2kbGwGQj+I8sFEStQoHprJbeEvvnHo/99+9/tlWxQommjH2uIY\n", + "Mc3xem9jvsdon5sH154jSW2kuXoy2n2NM/Qnkt9R38EptDHRod9F5GhRoI8lgx3/CsjKgOKFMjIi\n", + "eI7+1xCCdAOJlXRvz4RbZGLeU1u/rxwiV5GKe4w5ebe2frIu3X6yNaGEkBMYkJ1oqIhL5/WRJCRU\n", + "Kb1qeey6fVzuDOlSe0BqkuXZEVGfVMT+/b1Dx8uVIbhbnHsc2Fwf4/sR+59izo4IfYoxT7aUCVNS\n", + "/jDbSaVBISLmnPLPwyNSPnz48OHDhw8fTwz/IuXDhw8fPnz48PHE+GypvXkqhDh0sofJZ0aKqT0I\n", + "4K8JCrzYubRIRSTKMncpnYi0HpJZYVGDJ/M1oPrYpYoeaoNMF7IZEeYGpCAqJtYhVRUR2bBqkEaL\n", + "LVV3qvG9wCDIUWFOCLWohpKIyAwTzCHgPB5I8UzOBszP6bEQ6Yt1atDmCeTxkMwoRxhDjoAxjzVB\n", + "t7jWiUikQajGk3at3YyUApt2wngyJR2Zi+cufdHdmi7Qdf0B50RKyVCqDwCxhoG14S00hZ5v3yzb\n", + "Bqg3q1GvO2d3rQ1pi+Tpa+zPYNwI6rWXW0u33b111xHN7n5dsEEtUrUFGSmrzlhDhRKq1PzjT5Za\n", + "Vrg7o7YroIoeBVQAMOu/Dtrva0pFoz8PRNgMke5mdewYx5gIRm+QUhqZRIp0cFkaZK1964gUQECp\n", + "rRwmw0Lk9P29Sw/81b/662Xb3/7d/ysiIr/4wtr1VLn99ZTaG9B3n5NSuWpQaYrv+QX1YYyh9cq2\n", + "zUjZsNBvUbq+c0dsY9WRyXNKt6F9itL6WN+4c8o1LUf7HTGuWNl80RYi3aEBxwooZRhjcpsojdbB\n", + "LDimuePyCvNZRWmxWc/N9TVVCXfn5NozJ9Na1dbi/bYnpIrJ2iIE8Xsgg+BQiecRE8rhsoB0b17a\n", + "WEvQFhG1oaAvBkTsV+2tgHgJIX7LrgRTg6IU0iwKdq5/zIW77+M7G1cVvv/21goGZui4sbZYD62q\n", + "kdpuwFw40hyXo0AgJrXvDtpCqovXkO5S2mDuTmhM4nIiepwGKEqKuCgI96LuyXB8jfacrZ9GMJVP\n", + "U2jLEWF9Rgrw/t76y8/3SFmT2v0RafE9pSAbnbMpLb6GptraupNcbFVIjMyVZ01pq/GvfX8eoME4\n", + "My0FJG4yIx4n1yfr9n7ZludoHyoUUAJ4R4UqY+vapJ7dbwcSd7tcvcS5WbqxRRp/7G3HCea/iagN\n", + "+nFLrhgzCiAicvkIqc0+FR6R8uHDhw8fPnz4eGJ8NkSq7ToJCJERcW/aXWevui0Qk/CsXNS9LQ9i\n", + "b/BDr2+/tjf1M8oY9hr1N+6zVy++Wj7SsncqYJYJS42RSIQdVj09SQ10eD3PA1ZHdf8+HIxQH2Jl\n", + "kSeXOG97Wz/1IALPhnSEQGmEVnCzYAU/kTprCE9AIuDl4j6/b42AOgRACQb3PVosLyT2KKMuAeQq\n", + "ZZkIEEu7/pZ+67atLozsvV67v3+Z2jnd7qEsfiYVDbIpliRpbGXAYewQqbu9tWEwuZXwurT7H4Ox\n", + "WNdG9h6xcirX5NOGldMqNYQrf+6u9/33Tm0+m+z60wISCqRsP0Qoqz1+tGNhtTKRAvG7D9+6/RFy\n", + "eIVS7JTU8wNFqUAKTmhtM0M6Yqyp/B3+iGPHqvjunDq6T+OIsn5CrnIoP9PCUXoUErx56dCkn6/t\n", + "ujpoOPD4e/3qF+763hvS+Po1yMmh9f+fbxyhn5XVL7ZbnJt1vAwohh6DVfwVdboiSYZTA8I6ISiq\n", + "xv/iuXldtkCaBiKvpyiGmE62rQBRWz3HCkKwlFjNsgp57lapCZGtVf4iprLuEWhSR3IaKZBYbv8K\n", + "UhApFa8c9+p15sZrQu0aJerNaPOkKrWPI5VwQ4F/pOMnKNCYiGytqFtESJyei0pXFDkplgMJi5PH\n", + "8+8ZqqDeZVSSH0CSQAqau6BePldGihZIdgQbN4eEz+y+1r91/fPmZN//ESTz+8bu69t7hyYVa2u7\n", + "aev2dyAHhh4Id5yQAjaQoxGFJ4xqz7MqZtvFqppHktK1giA/TVSAA0++ILVMSAXv0DKxOabGDkug\n", + "wwMVTOjdfKDn5AOQ3pGyKRGyA0FIfRdzURdQKT92neekrA9HjZnmrgHSFUdIfTStHauBZEtMUhf9\n", + "qJ6QjJy6bdc3JqcSXro5pqQ+HuizlVwpFnI/5HnG3trw+v69O1/K3PTjEd8zsn+BZ1s4PM7EPJBM\n", + "kfq5PluZd2qUevkDHz58+PDhw4ePP0r4FykfPnz48OHDh48nxmdL7U3jcEaOzEHUrhsiHUKBmpV4\n", + "W2ghtQTjHqFU2zZk7gqV7YTMCIvcpQgmpG+6iRSLVw6qnintkEKdN6CEHzh0UtUGLR+QbuhH0zu6\n", + "QJorHClVBGhftUvmwjSmjoCbRzKDjEGUH4TU3kE2jUc7fqlmnKVBkVsoex9/Nhi7Rirxvn2H/dvx\n", + "Z2ilbLaUHoKyc0OaLZ2So4mwOoHE2E9kfDpAn4g0wHYbRx493JG5MSDwEIq5q9JSgW3n/r69v1m2\n", + "aaqqG+1YYaLpULv/d/vv3ffonJ5d/Jm7LiK2bkqofb/8GxER+d2v/x87FnLFBaUiRpDRI0qZnaB9\n", + "RbuVALD47a2d+xi6FOUgRrZMkHpW8eZxMji9H1QfyvY7DJpatX6ixrBshqqFDGlqaTGF24Wg7WF0\n", + "bffdj9/j/6TYD6h+RcraIUi297d2DV984XRvJlLA1/TEdkfaXviXx72m70qk3dRsWUSkV72bmAyi\n", + "U00F2jZNS7OOmbYdk9JV0T0j8ngOAnIYqXYM6eNM6oCwbJLu6Pp6mhCPAIdgvaUBmnGsGK5mxEVB\n", + "qVroTQXUnzKk0gaYQDeNpVtTmHYLaVZJBsoAXVePOZP1kTS1EhNRXdWbQyqyiJEWXPzLiWytulMT\n", + "pZZCtLs6F4iIxKLFK7RWx3w7U/GGmjsHG9OlG26+FRGRqLrF/u18n//FvxYRkb97/+2yLUJb/PTd\n", + "r5dt91Di3lPxxgyiektzV4U04jix3hdoBhj282RtGCJ9zmmkBGnmkFJwAegW42DbQk1zRjR28byp\n", + "SKuqQQpUPbCjwK7/AEK1zWoiLc4pIoNkHTNTb/1UWS5BZMfSdG9Heouq49RTocoJmn7HB9dOTOzX\n", + "tFuasxk0FOsjKmzoMHeFNk/s9zCtJlrKOODZTe4RgmMoe6GnlN0DHEIG0mILkdJcpcz3ASmf3EOU\n", + "STDRvLf0/5i04jbExv9EeETKhw8fPnz48OHjifH55A/GQSbydctAgOzpJXQC8VqVRkVE9lilHUnZ\n", + "t6qUjGw/rkEA7UMu9YUqdu4+o8p0aeCnlRBhb5xRriyGSOhifhhpVVM7RGom9Cvv3SqtIPkBVWpV\n", + "AiyvAlOU2o9UVh+CCJyT19UBx23o+FHg3rCT7C+WbavUkRef08rxdz84JGjCyjAjv6IQb+Etqbgr\n", + "/3Ukvzz12uoZORjd9bOyd5k6RErREhFTry5yfn93K41a5SKoDVfwWBxnO8/9yV1DbQsi0Wr+nhCR\n", + "AavoDx+JqI6y4he7v1y2jegz5cXXIiLy7EtbmVw/OML0VUyrOhQUBLTSntBpW1K7TgExDb3tb+yA\n", + "upCifatyGoXbx5pQjcMB/SRhxXiH8MytoXoD7v802fXH4o4x0kqrq9z+Nlz+D9J6vHJtnZIStpaO\n", + "M2FcizIyQkROWmp/srZO0NfXhGbFGAsdE+Uhf6GVy0NPRHCU39ekmK3ntKZ6bUWkei5TX1Ss7Xp6\n", + "ELQLRq4gbZLhGlmJfUYRAUudqIfeac9jB2OBizLQF1gpfkb/r2juKkG2n1i9W6UzVuhDpLqcJo89\n", + "/LTUmwnwKmEQhjb/qExDQr/NcE8mKgAZ0bez0rV/ltv8JyghnykjIEC9EpKumDE/BYX5/w2VQ9ai\n", + "ztCEOVY/TUJuLl0RULDHfHL33g6FYoA//+LPlm3/+3/+v0VEZN/YmOgwx2ZEgH57/w7XSkRp9Kcw\n", + "sT4e6LxbuHaKCSWegKrwvVbf1ZgkEQr1ST0RiRlz5pywxAykM2Y791Eg54Dvh1TE1IcodiLu8wjU\n", + "qafnpIK4rOwfA7HKc1KlT4A+EaZSAbEbOrvG5uT+roBMNZQ5UomdkNDXbOXOmQHJEfdkpPZvUZRx\n", + "oue0AE0f6ccZiOKNPoCpAKCBdAhLkqSA8WN61kxApEYqCmnbx0h0nmC8pSZTwSjep8IjUj58+PDh\n", + "w4cPH08M/yLlw4cPHz58+PDxxPhsqb3j8U52GyMit4qok4ryCGhzICPb/dGRd4+U2xmR0kliUgqP\n", + "lFBuUP0BBOUychBjQJ81QO6m2VIRynEPQoO2lbDHOjYzUoZzwgS8I7aR3gggeDXNDAjiXJUX2L9B\n", + "luHgrnUUTllEOE+DbBXGDmL6HkxLn11+s2z74d0/unMD6XwmcnYA+Lpnsj+IpSHBowE0syY28gQ8\n", + "39QG2b+9/j2+R5pJUAyOSTOkRponTR4rS0cg27Oy9X6PdC+p006TGlRSGkeNqYkB/uO7fxARkSK3\n", + "fpeuHMl1hgZPSppRJfoLG8pqejaaCW7vVFvMjt9WOHfSJZo7pJtIvb8LXap6Auk4JNQdPs6yWhlh\n", + "O4diMqdxjuO37pwmNoh2JPNuolQZSMZ1S2RXQOXlFikbIlavobr84aNpRv3iK6cjdVMZAXp34dIi\n", + "3/7++2Xbm5cuPZOepZuQsqJUUYe21YKSgKYkVfGe6b5O2EfbWd/NFKqf7V5rX+A0lpJRIyLWqkac\n", + "EsVZR24WvV+2j67XMWHfU9VjNhdfJHBIl2xE6oM1m2qYyyZcUYB5SZ0VdkzYRz9NiIA9LIbndgKa\n", + "Up+osKA6uf6cZtYnooXKQG2CfqwpsIlUt5WIPZO2WIT0YcBq14vOG5HYS9cnxwejAESrHPuzNMok\n", + "bluIgpnmg/W/ce/mxImOf3HhxnNGzhKDXg9RC/Q302j9b4cCnZxU2UP0jwLp9pTSs32dYrf2/TRz\n", + "329pTOj8P5CO1gHq6Ww4LymcKnIapyhuyULVOKP0PFTRq8oaWw2EZ0rjlriGrGAdJ3eMnKgF4+jm\n", + "Lk4Bq/I7TXtGaVnmXSKn46EYUVHIhHn3PAXtjv9ATiEdUnYzOXrEeI51NBmNSKVqKnSmcTVpYQOd\n", + "sM4ZFZnQqxzjRM+9Cj8JM7vHSep+k+X2PJ8Cn9rz4cOHDx8+fPj4o8RnQ6TGYZKqthLqOHBv4XNA\n", + "PmAjFHZHezO8e3Arkobe0pUgHuRUOo9yyYFWaVHg3v5PuiKnEvJgwmppthWEAkZMLA/h4ccE4MtL\n", + "t2J8IMXc5NJdDwFXMoE0Ch68RLRaKgu3qhpbQj9yfV0mEi9WDiO9VSsp/ngytfGLtUMEEiLWXT1z\n", + "56lKsCERTJWczWXA6uc30GolAuqnnnciIgkQqRMRZq/vILFAC+2y1NUJ+3q5f1NVXZ7o+oHcXT0z\n", + "lGiNVcKP775btk1YQYesxIv+MdNqWuBF9d37v102BRBNLqNX+Iqt9NZQAt+uDRHQkvgoImLt4Fb6\n", + "Efl63T+4FeluS6XuQF0Y9ZtAZA4SEDypXbXxQlKb1/ZkBXBtzYhWTYvEA62IR7RtTwUIShq/v3Nj\n", + "8eLCxtDNtetPX//SHAD+8Vd/LyIif/VXVtjw/bcOfVR5CxGREoT2lojlDQjKq5WtiK1kHytN9rrT\n", + "En5ChGRZEVPfBcLKKLFy7FU5XMRQqpBxpwzl7CCvKkldRGTAMjxkpBvzSrkxBf4JBPx3P5on3Osv\n", + "XX/qiCgfgTTcEXIbAJ3ke6zXY9dNpfYYQ4zIKpowMSKFv48nU4CeMSZu7m2eKko3dsuMJBGANseY\n", + "Y3ie6tBfk53Nf6IeelQ8o+M4GmiOBRI9l4YI90d3LunW9heiACVQJepXJo3w/lfO17FJrU2uH1zf\n", + "jQn9TEPXxwJCOhSBTzPrp3kKBwCS2ElAGi+AUjDaEKnXYEDq8MgIvNjaeT4cnXr36UDEerTj2FHf\n", + "1RL7mQt6cP2iLgZ2Bl2tPoDsrKFIq53nhNsZkbNHisxCTGNMJVNYEmZB4Ak5C4FEJsiICLlihJAC\n", + "SdhrcdTzJRI5np17chaY1pr2sXYq0cYjKZurTMSM7BD7+sWYd0eS6ZlAYm9Jgb5DW/T0nNLihZR8\n", + "BTNIJwUxIVIMN38iPCLlw4cPHz58+PDxxPhsiFQQRFKf7C00RU6XqkolhO9aQKWOLRCbkd4qd2tX\n", + "YjsQH+cA8bVptLz1JFjt6wpuIEJKq6t/e4PNt4oq8UrL/Rv1toIrQqxqEvteVbnjry5spaU5/E45\n", + "CPTGncTue1o2LyJyB8+tkPYrqXubJyqLBLie+9O7Zduz/kv3PRaTi3XVj9Jk8mGaBwioDcQzaJH7\n", + "5pW+ngaJv2WKJpaUD6/B+aFVggoSMuqlnKAgBs+LbMVXa7ffmPgjz69cW+/31q4n+D/JSPcTPIuZ\n", + "+kQO3lhCCNv769+IiMjFGvwB5j6g3V9cvl62VZWWHzObBtfAPAOs4G5IfLRcuc/TgkqiUR49wn8v\n", + "IPQjAvx0as3pXt3SA+r/ipwkGSE3WFWPhPCNQKLY4zGD/IDyXHpCkJRz01Cp+zPwUX74zvhQKXgQ\n", + "LGrX1iorYPdJUZKe0JSyhNcb+kbb2spPeRllwfIjitgRRwM6JhFtUy5PQMKJysNj8csJ16aciogQ\n", + "KeVShOS1GUG4c2IyGVb4H28JEX7mkL2ZOEoPKNPOid8TqMcg6wZCAkTvTcuinjingBBpBYwYTXt4\n", + "cCi2+uWJiAwQWIyYiIf2qY/GUVIBzgDcr5DGelm6c+lJpiLrgDpFdp9C8HDGyhCxEEhHQNIV6abE\n", + "IWmeUJQGbZeR0GMAlczD0cbVEZIxx8qeJy0gk4w0bjqgidFsXMII7T/QNXbg3yj3jO1HlcMbECKm\n", + "aMVMc11zAveIEDGZdN4llAacHxWEFREZIbd5gvxA29t91UTMQFIHijDP/DhDe27oXoeYRxmRVcHY\n", + "jp5FoyKxZxxaiGTiWZysbK5pwFEOAuJDou06EkTtcKy6JjQJQyEj3qhyGWeWmNFxjONz5mClvCkS\n", + "6W0gdULgu1Rosziz42/XuMfEZc6BUg8k3NrXniPlw4cPHz58+PDxRwn/IuXDhw8fPnz48PHE+Gyp\n", + "vTwNpe05ZQeCJZVGj4Dn1MtHROTh4IjSAaV7lGScEwEwXDmo7lRZuiuCOqnClDF9v4HHXRoaOXhE\n", + "miEtufzZQeYpqR1PWtZO8GwK5t9IpPgY0GOkZE4iR/YotQ9DLpd1sHia2rYE6QtO2URIQQ2pwe23\n", + "e0d8TUIiSosqIOP9mdp1BHQ6U3pMFZOjs0QiIF6CR9uTlu5TqTOkC4QUY9VHbSTIVCKQ3AHF832t\n", + "Qbwus1/a90HKfPHSSNG7zpFHP/xsxQta/k0IuKQJ/Pzo3ql3408//5OIiLwk/8PNxhUgZFRY0KN5\n", + "OkpPDiiXjWhdkgAqDwnG3+9d6mcd2v5GpIVGQPER4fMJCMAR9Ynj4NTW+4pSW2h3EnGWJD7oh8u2\n", + "edB+TLIfIEOr/11zRvZ3x//40dLjGbD4oTfMPEbqd0vE+gaSJTGl78PwcTpUFbjNh86+YwroBPHj\n", + "9FKWldC+Q5UNEGyWhNINWrxQkU+YKo8HscpvkF8c0kKcxdO5pjpaeqiGXxtLkmjZf0xp8RZODSmV\n", + "pI+z+vnZ90oUiGgqlDLGS8okoPPU1GtHyvr6W1WiFxEpUTzR0/XHSAdnkfXJCGrwKvUhAY9/HJNS\n", + "hinS8SEpy09ILYYF3Tv0tbAjSkHuUvUhSbeMGJMhxkR3S9IIkRKWiRw9uXlyXVr/O+2dZMJEKcge\n", + "8hikfiEjPh8p3aUOBTHmxHJF/Rbjc7WyY+VIn7GKfiBwxSD6RI5x2pylzLBbSm0O4q53cSeY7L4G\n", + "GAssoaEpUHag6GCKymnhWKVz6Jx6jFMu3tKamZEoACmI7ylSoQGlu1WJn2xql3HK0g3qhdtR+l5V\n", + "zoPZ9tfj855kEqRXUjikCWiuK2O9fitsGHDvHo52rBZzcra2H4exKuBT8UBb4xooVdgwbeRxeETK\n", + "hw8fPnz48OHjifH5EKk8k45WS7rqYgFFXc1f3xiJc0TJfkYrHRU/Y6HHDpIJGfkKRQnenIGSRLTU\n", + "Uzdv9mFanNFjdoTHeY62Skoyh2LwW6u+zZ7JFMRKVAWCQ6p+NYigTOI8wP28pDd9XRFNXNaLF+cg\n", + "ses5QIohJZSsH/GmPQMtoHpZJdTO7LWmlakkvjkpxDMz/AEHb1r9B7qsCZi8C+SMVtPH+gHHcr9N\n", + "ya9qOLm/08BQygwiiWVq5/ls44oN4ti+99MHh9xU7eMS1ozQjBIo1eHuWxERuWnN12sNRKqjlXYH\n", + "KYyht/u/3kIsridiM8p6UyKl5/Czi8lPcMDqa+6x0jvzkHPnuVlbqf3p4BDWE60Wo86tjqOIvAZB\n", + "bN1GJP8wK3Jq90mJ/x0UaU+DIS0XFy+xX7snJyBM642tyJV4HcUsUuj+romovoHv3ulkK8erZ04Q\n", + "sYLHIwsjxpBmYAmTECjuSFITYaRCi48J4BH1cV1FB8KIaKQ7wX9JmBHb2FdsRh/uCFU5Vq7NCkKa\n", + "TkCsCioAUN+zmgj9+jkjDEqULRY/Q5qncIkTo2Q4zx9/MPmFF89d3y1X1nfG1p3TsxeGuqrAIQuX\n", + "5jhuIIp+2bHUkyynPiQonhlHku64c/1kCkxqIMxQzn+ysRNnVziGHSSATI0iYfeH6+Wzn1G8EZb2\n", + "/QpIVyuGfg4Qoh1akokAUbkdrf8VOUQv6Z70g/tto/8SYTkBqvRAHnobzDsDCV2GqfucxR8DnYtp\n", + "Pm8gZ1BGTNQGwg2k5QzpDh+P4RSFKqRmsxRbNIy+ArIeZy5UgP8lCVyrIKr64IksdoqSALnmAqwI\n", + "RH1G/xVp5vPUQo2YvStVOJaQ8B6du+/se7q/BOhXsaY2Cdy5s3B1ixoHqmuRCITyIKUsERD2mao9\n", + "FDDre5KdGBhtfhwekfLhw4cPHz58+Hhi+BcpHz58+PDhw4ePJ8ZnS+2FyUqSkrQZQFgMSDtCANWr\n", + "craIaVXc3JtfU9U7uDcPSW06UlIepQp0m7INSXdC4N11Dy8/EZG4cZBtT6qzOeDRmPQ5Tgdomkx0\n", + "niC0Vx2TIjW1hhQfQdEFYO+6I9Vj3B1O98WL3gVrFiE9RNy8oUB7zgZjK7SbQzF5JNhbee8hkV4H\n", + "tN0cUBoJqT9OrQRIxwY9pxsBmU5E1BxVMZa6XeO2nfbuXHpKhUzQc/nVb3+9bHsNFfmvv/xy2bbb\n", + "OuJ5ubU0Ros2CzlVCeJjnBmxVvvbGkrcx5OlJ1qk8Y4nI7GfGhQFRNYma6Qj5zVp4SCNMJ3s+Nvd\n", + "M5wHparQtgH0q0ZKD8aTu56hsTbZZG9ERKQiFfv6hFQA9edpAwXqwK4nREorJ08y7QNa0MHpsRHX\n", + "PxPErWMoYRX5URXTrT+tL925s/9bi/Q1k7c1paaE2pnWdj1SqiHpLikHoDsju7v2iVkzCOMujVnZ\n", + "HunjnMjeIKAqsTpkcr4WYND4jxctNNK7AgVgtbLU8v7gcgs9+bolaLuqsnuyKPq3lEYBGThTFXGq\n", + "IqhrFGCUVJSzKFHbfPrxnUttv/7iF/a9lbpH2A1YlW7OjFPbX4TjLmrWrKxfurGWFpSyQ3qcVey1\n", + "QGW+Nb2n4BlSxUTUVv9FCa1PTurZ1rrfbjfmbHD/7W9FROS2tfm/RIHSQ21zdxS5ea8mHbFQ0E8o\n", + "3R3ieRKz/yL0BTWl3DbMrYAWHGl2haCUtNQnYnyP9bA1GxYMRB9BSp09KVPMz4GKLFH314IdHhOa\n", + "KotICykDzSNhzTKkxzjdFaqHHZHteyWq0/MkVdcEFBFFpLulRRwNpQI1Vct+rjrtT1RQo9cxkt6a\n", + "UjA6UnS3FDSe4QmlApGCJVMQaXTuopRxXgRn5+F2jHQvzV3jpEUmTED/w69KHpHy4cOHDx8+fPh4\n", + "Ynw+r70wljCxVYiWa2eBrVZaEPq2VNY6gtEW0qkf4ac1ElE5RYl5lNhvOzDQQiiX8lt9ECk53BAc\n", + "XYkM5AO0XbtznkbaL1YVPZX1a5nqROX/EdRRFcwaRnvlb3O30mQ1VT29iTyPejAKA0KOFKWbyVet\n", + "haJsTKQ8LZ1eY0XYiq2MZ7RdTyTyNlAPI/IrxOo4IljhEmrXbUUl4Vg5U/WrrED8T4hsfgGyqZa3\n", + "hmKo0py7Y53ufr9s+3DrSvEvdkaYffPK3euLwlYQ1SunRl43do3FWhWjDeHpW6x00MdyZoKiOOBw\n", + "NPRnwL1Yr58v25rakWETIjHmIDFH1HfXQBEmRg4712ZB4lCSjhCpuYI0ApXVD0AuSypXP47O16sm\n", + "FWF1Yu/YQwoeXuNsiIyWP+u4KkvykMP354GIpViJh6H1kxQr/IlQyrv7W3zPflsACUxJqVrBlAFI\n", + "WEDWBuqvNdFqVd3kzyQJsG1kTzogmxNti0Il2xKapcTqQN3lHyubp6RiXdUobKFlbQP0a0Vk8wor\n", + "3KwklAxQQE99chk7rc0xGQjNClzmRJhPgFycSFaigYr88+fWJ++vXdFES15/2dodK2HkUuVUSOJE\n", + "SfMhVvPrnUmNpK/tydQAACAASURBVJDkYLXxFkTlnPzyBpxTNNt8Np4cYhS/Mu/GCQ4UVHezFA2p\n", + "mjUTlrPctcXx1vxHc6B6l8Ur2y+KgSY6fle7Bo35OYH5rGfvRs2KNOrXSbIOS1dklNQdv6V5skN/\n", + "nqhdFW2dBpsnAvWTJbXvBMU1A+Q8BiKHj5O7nxEjUngWRrmdp6pzJzEjckBzCJHXqoVcyCcPz8CG\n", + "JCZOB6jCb9xvJzp+mCiCY4jkufeGixUKH6aDPSf0+Uj1PDLhGTcOdgwdEzOI9R2hxOoNuD+RrIsi\n", + "zbldv47FPKPiEWTCSNjdiOWEMEr3hzEnj0j58OHDhw8fPnw8MfyLlA8fPnz48OHDxxPjs6X25ulc\n", + "CXYWBxmGBLEqeZSNJzXNdfNAcCsUU+eYUgCR6l2QuW3l4N4QxFYS0V7IqQGdk5o2shnihL97goxV\n", + "02mmc29A3u1JxbXXNM5ihkr6PLjEiGDHAXhnQmmUETmNmDWb1HCWoOXbvTtWR9t2SEvOo0L2lGI5\n", + "OWh3lRmxU9N4TW8w+rFy8PzFzlJAei4hqaJ3SO3NrGYNGDkhHSdNt4Szg7OTxNITA1ILL7cGGd8i\n", + "jTv31CaDEkZt227jzq8sSBcI6rUhmWAHKe4FbkVaEhFSSa+k2aWeyhfFF8u2n2AuHVP/C3FPZkpj\n", + "aoogIvLwSnWT0McPpE90/+BI7qvO2isDYXigttZ0HBt5qxwbdZ3FBHfsWFvnnNDaNpYyOhzc/q5e\n", + "vLHvo/AjjEgzCQr8L67s3t3eO6Pl7e5i2aak9HXGyt74rFeDXDLIBmTP6uA92ieh1FqE33AKeg50\n", + "jLHhOIiyCWtFKckcRSRENq8ql57i9EwLtWU2jY2hn1XVTAvAfELEbiXvs2lsD5I5mysPSLcO+Cws\n", + "qTgAGkjsDqDabqxEvbty4zigOSlL1bSWpdKRUh3tt+0Rad4V5gsikY9K9rc9SFy49Hx1MH2osnAp\n", + "7bPUqqa0WLEa7TPdmwm2JI7IHpaunxxAnBcxE/Smtn7ajW585In1tc3KEdvb0ZwtEuQPJ0rZzCCl\n", + "x2Jke/1rQkq7I9XxEBQQJqwH6DMdteEA4nVIdAtNI7JSvZLdZ0pjCRwIwKGWIKD0KOYQ4pXLBL3F\n", + "PLO+G4OMHdLBQqQgs4zMpfEx63LNSCU2J3LZuHN/b1daHEKm9RifqskkYq4krBiu7X+xYWqBu4/z\n", + "YGNHx8nQcdvpXOz+YWL/EZny+yOrw7trXZMqfZypfiRL22N/VAA0gjYTsn7dxGnLx+ERKR8+fPjw\n", + "4cOHjyfG55M/kMlgADGV75lKeBXhGYmw3bTuzbWjcmFVew2prFL955goqIiFEjWL7LH3V0RlsAuh\n", + "jxCJAcuEiVYaIVYnMUktCFRciScoAd6SB6g9t6S6XcMHMCUi4oLmkIhwqIgUrciVRF4WtnK92H7t\n", + "jknXk2P1vd05ZGKmdeXumUM1Xr7+F8u2FATo9x+s1Pi33/0DDmqrygHeWDMpoCvaF7EqMxCDiRjo\n", + "KXzsFAgoCRHqgLqoIraIyGl255lQCX+syud0/3VVFZLa7YjuHhLCGWB1XALBahuWB1YjLFInXgij\n", + "9jXB6qw9cqmta7sgJ6+pRBFRW6UpP77InBL1SKXxR6y6r29JbRynEqWGtCrxO6XrUo/DeSZlbS1a\n", + "YBVpHWMgdLetrQy1GIPJsYoYXd+a2vTLlw6R+Omdrf5joHkBrdxVUTkk5FABGz0llh/QMnDuV81J\n", + "feUIJYA/JiPcCk4lpLbe4TpyQkSV5BrhROaJESQUm5DUgmqSUJMQEk3+kyCU10QKnzFOSvITbZWU\n", + "TWXiEQjCRyCd25X1dfXVC0aSVcG2M5kCtKPKK4hYdw4JildwNhjtggagaSedazI7vn6voLkmROFD\n", + "QFIbWngQUvHC2ACxqqx4I7r4BjsxlOL+979x54GJ71DZPHl94xDxI+QlRETaEPIndK/DyLVxltF8\n", + "nmiWgBBxXD8BgpICbV1h7phpTCr6H525A0DqIGDkFP6Pn1AbDwilV8SYUepxsZSAD2lkfUOfO1Fm\n", + "E9AKLg8Zoe8BSNkBuX1o8QQjVzkQ5ohkQjqorR/JuzXC/lo8d/n6E5xvRONUnRUykslQYn3GaDJ+\n", + "c6I2VvI4S+cowjyhGKqmMVkDpe7ouVKs4N1JnrCrVLMfNCcDCR+poEazPgnfp0+Q5zk8IuXDhw8f\n", + "Pnz48PHE8C9SPnz48OHDhw8fT4zPltpzsCUThmHyODGM7mDHI2mhdJBbZRLppnSphZjJdosCt+0v\n", + "UoNCpBhaUh1XxdSECHOBkshJtGaAOnlGBrkZ9I5SglFHwJiqsCtiirETYOeECG69qkPPlsYZlABP\n", + "ub1B1ZZDS8ut1+74f/nmXy3b/ua/+q9FROQK5qUiIrf3Lh1TdY7EnJHJcTu6FMSrC4NiFdI/neyc\n", + "NLV1OJACO8jrPZFIC6SUAmq7CnBsz9pauLYQMG7VGLF9UCXeyY6fIn0SRpyy0r5AaQwcIidS/jWM\n", + "ZFvSm9L0ZZaCnE5pjG5y7VT3pM4M9Xw2iFaV+0yM7DqecN0jaXtFJ3yPNWOU5OzatVzbua3QnANB\n", + "1qfK9ac8tL6TI803U3omw1iYJ14ruW0R/VZJ1mOviuVU2AE4u6fjV41rw5nSndfI8nW9wfOrrdP0\n", + "qUgp/gJ6RJyWV+J/j77RksbSopnEqRWkTxqSXU5QMJDQtaoCf0CpQs3G1zXNCYuRsRqvksIx2vNM\n", + "Rw1w/9n3MCb3DzbWNX1zPNo4yZN/lscUkRpzWzASeRwaWKop9+NPdq2pXs+ZZh1UrBMmFsujWNLd\n", + "5MqgKtIhzXs6JhZSPmt2IaXTUJtkIArnl1ao0sFoOCEj97BEOpry4jMI2mP6ctm2funa7H/7t/+L\n", + "iIi83f+8fLbvoI81WJ9odJ5gg/LQ3eOOUqBJ5vYbkJFyMEPZnYzpo1Gv27VD09FcM5//K0IpYBJD\n", + "6pEyYheHaFCiOqWv8RzjIged7xtoYbGLRKL6UKS3lqO/zJTG1UItNvzWYo+QnEKunjuHiKudKeBv\n", + "S3fvouDv7betI/yn+C1fV415n2ks+uyaUnLPAB2Di32UbD+R47KaBYc8nwfnHbpvqbALx4rJyD4D\n", + "sbykAiBN33ecl1f9LCoKCUDRiYmon6/IIeET4REpHz58+PDhw4ePJ8bnUzafx4V8LCIygWQ+0TZV\n", + "Oc5zIxsneHPviUS+cMLpTbdp3OokJWVTJV4WeIPvBiMs1pArYBJdDMJ6QGTzBO+ecUCrWnhjrQoj\n", + "VkYgYE7TezpP+P8ATQlopZ9g1dEP/KbvVlAdlTWHKM5lwnYOkunFytCnHc7lcmUoyVJ+j/Lmh72R\n", + "PjssJ45EjhXISjzck2I5SsJPFZG4gbSFdE6rXD2U7Ny7EMQ+8mnqQMqMRqygGiMxCxYBHZWedljB\n", + "Mym6OjoUKyMSr6ptb1ZXy7aPx2/d9RzNO+9q7ZCTVeHabia/xA6k2JGU7bUWYqL7n69AouQS5kUc\n", + "2dCEDovoKaRChQxfxKqeCaO7S/QTsf5fgYAstF/t9yEhojKrTxwrK2NFelYUAaV8IBLsAxbg+xOh\n", + "H7cfXV948dJUpA971z6brbWdErB5TCpRNYxsf4MSO6Ewzh56K4xX3scAD8WcSrh1vyOtNFdaoEAO\n", + "AHpOTEDX5lH0qSW0TPfHbaiSCCNJISuqVFXkgAAF6LYlNA2/SQkuGoDwZSy7gnvbYH9TYde6ee2k\n", + "KOqOFPvhl9dT2yVF8ngbEL5zhA0o/ZlSN/oT0LqEnAC0eKDrqFwdSCQXhaSYswNCieYAiBQhIqI+\n", + "ogn5iW7cmP3ym29EROQ//I//YflsSN38sG8Nud6f3LaU/AJ1nHY0d19AaiQlArqiWKEYEh3FKIAB\n", + "OZu9XhckklDFAQfTZ46ISIN+FFNBk/reTVRYkOn4pz6hWZSmV29KQp/x/ZAyIilkbeLEClAm/Gai\n", + "+5RE6pfH/p+uP82T3eOicM+M51evl23XN9c4l8cFYAqYBROjam5/p6M9O0rMkw0z+9VJ4gziQ9Yh\n", + "IZkaVeAfdJza8dWfNKYiCkVnGWnVNEVASJMivBF5/PbaFoywzYxiPQ6PSPnw4cOHDx8+fDwx/IuU\n", + "Dx8+fPjw4cPHE+Ozpfaq01HigFVP3TvdQErgJbR4mhOltiKFW4nsC6iyJ/J4A+h7pjRGnqvaqYNC\n", + "9wdKu4BEHhCENw9K4rTzVr2XkJTNQxAbVyuDtuMIRO3a0of7ysHRqSgRltWZ8QerrYO82BKJW5Vq\n", + "GRzdw1Dy3QfT8Xnz2pEHA9LR+HjnNFgq7K+q7Vrfvf9WRER+Li0VOUI9/Lsfbb8Pe5cWK9cGIyc4\n", + "+TixlJXexQOlNqolHUZ6N4CAY6SPClbxxfdaThnO7rj1g7XrQ+6uKyJi4xWIrbudEWCTnx1hcmLN\n", + "HEC6mhYcifQ4fYIwrmmufmCyM4xP6XuRFi9QGjNAakENekVEjrjHIb6/IjPODP21WFERA8YMK1F3\n", + "ULtOCbIecYye1koD+ukUUAoOBQ8D0j1MWJ9xF3sy1I2Qbh9aItZ2rk1qMl7N1zBDJfJ6A7XnY23p\n", + "2/XWpaXWSAvd3VvKJkZKicnpHY67Xhlh+HB0pNyIUoAT0mg8Jygpm7MISjZXIq7qNImIBEjfBJR2\n", + "6VTlO+DUHkjBZNp6goF0SfpAM7R1WkoBqo7OTMbUqgul6uVpbJSBDnpfAbWrKpWzOrqahnNaVPvx\n", + "SAasqhAfp1SAgbZVE+aJ0mMhzrMgHbMZhObm+sOyLVPtK0ptDWi7pLB5ctaigNlSUCqupDUR60tL\n", + "z3/79rciInLqrE9U6FenyrYdD+76v/ryl8u2EqnvuDQF9v24x/EttSeTS/MHIOUn1DaiKvrUiZRY\n", + "zmlpm7s5jYi2ppTVDP5CkNk9mUCQb2uYdpPen1JGVitKY2I887ECUR1D0vtDIVPd2Hl++OgM4Z9f\n", + "mFNDDzP7YaBUNdL2VYfUXmd9IgXJu68i2oYUMI3dBq4J01lRCFJw3E8xZ7ECvKbXe6Tx2obnZE0F\n", + "Usp6ETKkOQFjNsupoAxzXEBjYsY7QM/PgrMn7uPwiJQPHz58+PDhw8cT47MhUsMwLN5DIiLKCWMe\n", + "2ojVZBiRrx7etIealFDxm7o1YlsLUhqTLZVQqDIJeWor8+bkVikDrWDjFIqtROKdsaqraEU+As0K\n", + "uawcKxdeffSzroTc9ydS4p4GSCIQgqYVn7oKERGJQVTP+E0bq9p/+KffLNt+eudKhjMqpy9Wbj+b\n", + "zQ4HIF+3g1tNzne0qjq5hlXfPhGRRAn4tCJbFTg/QmREfcUGO36IlQMfdyHSg6i527I6L1bas92n\n", + "qgP6Q75md3cfRUQkL+1YL0DAXJe2+r3auJXm9clQtwHehhMIvhOt4LRyeKRSd+2eXChRA3Vjr79R\n", + "VYyJsKiIUUoGeEqKrdF2U81wif5LREf1BhTqk+jjHZWER1pWTb5SVX/EeVq/y0DiVLXfiRAxRRo6\n", + "KqEugFbs90bYjzGOTtRPtpduf8fOVv8xOvQDyWlsgFzUKk1B5OQV7mFLJF5VW+97W+nq9TCJWtGk\n", + "kRA2/TzPyScQ56Ll5+ceeo8lEVQLgCVBdL+sWK2yD9vnhohqqbuQd90A9EHdBkREptp9noM8PRPr\n", + "VYtMUiLMHw/3OE8qilFfNzYUxfVEVErOVHyN5gTUOQfpnEvzQYQeaLWuZOuSSNHq5ykRkbhx70ZS\n", + "wJbEjc+Q5umpcm378wc3h7FcxekEVLOyY7VAH0cqQMpjt9/nK0Nacjw7xtHQ7AiSJHFk93Nq4J25\n", + "yEBQSgL9qiNETMngHRWAaP/k5q+AmLGKuCJ8EyEi6p3YQ8W/P3M2VESQpDYwdgM6mErGjCSnM+Hv\n", + "nqRDfvqg3pE0dwCJa3v7rbonxHDKSMibT7NEbGGnvq9M4lZ0KiafzhnP6ZAQ2RT+fDHNkzP2o6h2\n", + "2/JYx790AlofEZMp4Qz9k5Dupz7PRyoAaoDS07QjBRUyfSo8IuXDhw8fPnz48PHE8C9SPnz48OHD\n", + "hw8fT4zPltrbxGuJI4PTVGyaUyGaMukrg4LVmJcVm6sOMCYp5jZI/U2UgktAilNgkZVYQ+yvIxJd\n", + "DwiaDULnUYntpBgLEuntrSlgX164pp1GUgAP1PBY85iU4gE8280G+yoRm00WIyWHZmS8if21RJT9\n", + "zfffish5aiMH2fmv/+VfiojI1Xa3fJYkjtB6bAn2ht5Kllhbq9xNQmTbdtBUhJ3TlLrPI8rV5r2q\n", + "stu2aFFZxvVTenSbuTs1kGZTAl2wsbJrrQFB16QtNYwupbJKjZR8sXbbPjx8v2xrGpfGqGqXHsxS\n", + "gqyRlhzoXmv6NhFL46xzp7tSrk2zq1e4v7I+sYJSdEAEdEWom9qlwDTFLCISLKnvx4UVTMQcVTOK\n", + "lfJRDNGQtlWC+7RhuSmkERRaD2kMLeRZUlGeYjeuItKxOTw4va3N1kjBAa7/wLpk6DITpQqPB3e9\n", + "SugeKD1cQxX8gQoLNjCXHkgzStP3IaXWLC1Hejc4Lqf7NW2nn3WU2leC67mK+fRom5LYe0rZqd5d\n", + "FHFfd38PYr9N0SdiItuOSD0oAZyN1wV/s8mqat8dSAG8wvdWGxvjo/ZnSu3kpRtja0qLjzCc7lt3\n", + "j9OQTJ4xZ3MBSKbFFlyA02p/IhKxFqiw4TqKIgJKy7770ZmkvzuhiISdJRpoMVFqJ0WqjGkhX712\n", + "it1lSsRm0Caalo3pNS9kbTKHUO+HQFJGc22PuZbvvyqajz2lxWclRVMKEM+YgXTxItUqK1g/EX2x\n", + "dr+dEk5Pw/B+JLeJCer4lDJtoYqeRkysRn/u7Lf3R/fbdWKaUWsQ2Vdr0yWsKuj9RdBxI707CVuc\n", + "p23qe9WRMgpACCrL2fNMX0GI0pIt2nb0fMSLQd2CRG+Hkhwp6PWKdKRwy3pKtyqjoaFxqqfStGwa\n", + "rQR46qcsKvWJ8IiUDx8+fPjw4cPHE+OzIVJ5HApxXhf13JlWqweQLhN637vcvBARkWll3ky/+/H/\n", + "ExGRurLVvK5OGyq///DB/X2xRan7RG/wjXvHbWkFu5SEZ0SOhPJz31BpJMiQD5m9fScg1I0Dkejg\n", + "KxSD4FzXtjLoQc6OZioNHtSbyPYxK4k7MERAwaG8MGLnixdOsfb6o5WaHw5A7vCWHoxUwqxKwKRY\n", + "ngMR2hIBXNA+GZdrY1XXE/oV4PwSKuuNFaWi61E0ZYTaNavZ9pOWZltHSXD9I9NkQUqvekM/9kCn\n", + "XobWnrvSoRkpoUlt5xCjBp5gSWil5qoivMrf2OUD9dkWdk75yq36o8yOdagdSvNAKFmAFS5Ld5xA\n", + "8uywcn14sD6kiEhS2n16fenOj1EdLBZlJLVrLeQoaDUt6M81k7cXhW6gJYy0KImVvNnaGis88ibb\n", + "LcULtk78+N5JTewuni/b7g9O2iAhEmkFHz291qIwIur9/R3Oya5VSb4tqf0rYpCw/5eW/5N0gRLV\n", + "93ubJxTsU3I6q5OrEnhI+1Cl5oiLPRRFI0SkBNJzLifhvpdmXGSi441L4oFmh4rW2H47KHpnmfUJ\n", + "9b/jwpYOc0tX27VmkCdJIr6fINvTGl+dJLTdc1L2DkDAHk6kbI75ZEeyBno9MxPLNRJC0/G94cGQ\n", + "2woFB3cf3bn/9Pbt8lmKMdb1dF24/7udjV0tgJnF5rOf79wxToNJbJQAkdOIJGaAus5DenaOIiKT\n", + "3ndCVZTjHJKKfgz0iT3iVA0/JOhs6nGPU0KkQvU/RMFIwkgrENTQ+mmrHnohZ19QlECFSgE8BEfK\n", + "sAgKGmKakwYU9JQru+/rHWQaIGFQrEjqBQT0riZUFdI5WkQlIlJBpofPU31KZyrUwe5kIO/IHues\n", + "j46IfPWKElIzJPXTYUzSlCQAsySkZ0ff6/0kOREgsmlqP2Zf2k+FR6R8+PDhw4cPHz6eGJ8Nkerb\n", + "7sxdWQ17ePWnpbabtSEtwaxu7YaShKGKKdpqfoW8/TzZ22+N3OhRhThpValu0knGZY7unKZPlFXr\n", + "W6uIrTBayr1W9QPOk/yCOl2luNVCTmXFY6hCZ+Thh2PQoaSDmFoW27FSlHMzcrUq3XXkvzBX75sb\n", + "x6G4A0p1QSWdK6BPp8i2zbMKhxJHB6gapZ5lAL8jIb8wLZOduf4X7+1RxB6L7vMGXIkTrZZa9Uai\n", + "pb6200CrhXwRxGTxN3COaKUzY+nIwqkPg2uLECu9mMrKt2uHtIzEx4s37honEtXc7lz/DIg3NM6O\n", + "13NgrzfluhCXJIL/4hS4+9lPVNYfKs/EkMsM/SlK7Dw7IEwHEq4N4L+YEcKzLt31hJ21iXpWKpqT\n", + "EarQtFj1EySitycl/sARUghvvvqTZdse8gBVReXX4OYkG0MO7oASbMHXY2HKmxu334JWxooYbS+I\n", + "j4YxU5Y2TzzAk3C9No6ctn8/POZBdYuoaP3os/hTSBeNNfU1436aqncgienOvUNxXjw3lE55jRPt\n", + "L4bY5Tp3+6gOhqAEs3rjMUtEvT7tWvWMJ0Ldw0hX2tZ3lOvHEgdKtdPziGhOjIH0ZIRcKq9spHuX\n", + "wc/0LO2gWYeIvQ7d3x8/Gr/rh/fubwUia0Ka5wDisySqqDy0i0vjgynqsCfO4fVHSLzwUw9jNiio\n", + "nVJ3vGBh0z72a+T2nwYt9adnAnbH/m8D2j+i/pRi7opp7tRdq/9lyGgRELaeEFkVMBXyydTnKKNp\n", + "GYjIY2vjqVXuD3HEihVQbxJJzSF3EOAeVq3drxzPjJEaViV5ktzm+hWeE+qN576IsUP9X2VChjNu\n", + "oJqcun9jeoYEmAsnep9QeZ6e/XyxbSaUMFPeKj+n1buXeFFx/IcxJ49I+fDhw4cPHz58PDH8i5QP\n", + "Hz58+PDhw8cT47Ol9prTKAGnTBL1t7HvqE/U/nC7bNuuvxIRkZFSdur7VVL5/bp0vy2onP32iPJP\n", + "YHcpSQ2sNgpjG8S32q5xLIOxexB6TwcjR6qOQjdZanFQPz2WMwCkrV5axOFdfP26htSJY0DmBBlr\n", + "+oB9nRQqPksPIN2XE1H71UuQpgcH2fYEsRaJu/6XF5ba+fnOeewNHaVAAXeucit1T0COTBNLi2Ql\n", + "UpABpVZwafveUhXqE5avoFgt7HWmyvKk7A6S4Vg9JiIOJAD88d71mYhSa1qJvXlBatMggCr/dQqt\n", + "r4WA9qOYfLgWry2D1nv0j76x67q+dtB3Uxk8niG1OFMfS1L12oM0wY6KCKBovE6JiImUJntohQGU\n", + "9VlZuFbFcttYIAUeEVG+R+olRFqaM7GqFM2pLS3Fngj2XqOvVY2l8QqQoU+VSRcsHoOUAhpRvLCk\n", + "Sun4t/eu/P3PLv/Uzhf9PqOxHhXuutjXS9NyLZX6a7qjonuipPETpBY4xaAq68NZGku3PSYbc8pm\n", + "VAI6zVPTwnxlORGQbWdOQbh/tfx7TTIlfatl6KzO7I5RUGpT1aEHLttGemSgMn1NwWwvbJxuL9zY\n", + "TlG8ogrfIjbvRCQ1YarPNE8piZhShqJpdqZKIFUTruzc//1/+o8iIvJx/zsREUmIiN1AiuRI9/Cr\n", + "L1z7cHqs69x+b65tPEcoEJooBd9hyEZi6cM00D6m3oSUnoXLAtM9QrR/xs4Gk0pd0LXGmCcpTVRi\n", + "7GSUvms6TWNhrNOgyNCeM6XxGvTFbcYPFNAiAn7Eu+OXK0utrzUr2Fl7ToFrszSlwifQPBaaAz27\n", + "P/yMuVasn6jUAU01MmIuHqjv9Op1Sv0kXNqWcB51+YAUT0xzok5xA3uowqFhjjg9F539KyKSp0rf\n", + "sfm8xtwZj5aC5mfLp8IjUj58+PDhw4cPH0+Mz4ZI1X2/kH9FRNIab6u0IlUiJhM2V4XzSWtopTmi\n", + "xPysXBGrzzmzS0waIEJ4cU1IrGwHsnW5tbfqFG/uM60gjnCaD0Z7g65rh0QFAYm0gWysZEoRkR5C\n", + "b4p6RcwvxNs0cV2ljYA0kFhZilVqTmTjAud+IGLveHKrpDWt9NR/KwGaNFEZbodVDZMT4wkE9IaQ\n", + "JoifxbmtaqbBIQftYIhchpVuFPIqFagfCWy2nfttivuUhIzIuTZmEu88uX1MRLasISHQ0yrpulGR\n", + "Oiq1BQE4pFLWcuXQqSRjPzXst8L1ULm0YKU1jLaCO8D3q6Uy/Uqd3un+Lx5nEfVTOJZfBO7cHvYk\n", + "PojS6CEiQUSsDHMq/81SJXbatR7h9XYgSYQNdl2QJEWK64mAJvSEjJTw1esJ6Qm0iGDklR5W370d\n", + "q8jcb0dGbkDkZ5HCLY5RY6xnRCw38cvHoppCSNtybvS3yqiwTIR6vR0ORkDeKckd18++ig3OqSwM\n", + "EVWBW/b6U+f6MzQLv71csa+au/6Ofjugn6Y0TnU/+r2WxvUFSPYqFikikoGUzl6PERDmnPqaegJy\n", + "kY/upywN9bp87pDrfOsEGVl8tcf5TnT8BPMPTb8y4dESkHTHgk7R9dd3rtjjcLJtF5fuuP/0Iwp2\n", + "qFx+xJgYz64fY4z6hPansba+U8AzlbvO8ejmkYr9VEN3jXHi5vAossKGDkhHED7u/z3V2qteKnU/\n", + "mfAcmWP6Lb4XD/ZbJaqHQEkSknBJRhWVJaFjyFVIReMUSE87MpoKOZ/SUOIkdf0uIpRGxawDwlki\n", + "3LsigPxFbxkJgSTF7QcjoKeY12K6T4pSMSKnCYOI2jMCmlZmNHcC9WvE9fWeGnYGwtpS5ijK3d8F\n", + "zZMpxFljEsRVJKqx6VzaE9C3jseOlz/w4cOHDx8+fPj4o4R/kfLhw4cPHz58+HhifD5l87yUbjDI\n", + "+gHwNaHjC1Q9kAHfu3eOgMgEcFXPDSndJhM8+ehdMUlUKRhpJ1KMTVTbifDpOXJwIqvDTpnb70jp\n", + "oQHkwLq16zkcHFaY5USADfA3dD8mIkJruoch6x7aNgVBnCNgyTAhaB0KzJutpdvev/vRnRuRkneA\n", + "6pVsVxPpNEgdZBu0pBmENA+nO1RFmUmMqtXRdOSrhuuJc2u7BKnEkNJ9yaLfhHtCnmMhtJVSgsKV\n", + "WJmTErFqRlj1vAAAIABJREFUyxwotdZC+fh9S9pipVPF320sVRGlqkDtricl1eXVhfOf+uG73y7b\n", + "0tTB3k1rqcUDNJM6SpWqr9cmMmJ7iX03g6XAglQ1kNz3h570mUDADinr2EOrZe4pZQqvsfWOUnZr\n", + "96NTZ0UR94OD9IPB+kmMdFeAdA8rdodIfY9U2KByLmVmKbihc8fa7CwF0UNHLaeUgaZU2IFA01jr\n", + "nUstnfaWRtXhyX6RquM0sWL4rBp0RDZWUjQRwFXviNN9qim1+PXRBKQpxZb8OqtPHL8ftA9zrv6x\n", + "ZtO8pBFsnMQYC0yeV3L73Y3TPVrRZw28y7ifztB2Czi1B+Ix699o1pZTkEWpvmrWJwLsO0K/2u8t\n", + "FdRhPjkjB2OOjUmzTNB35pRU0dU7sKX5BM34d//0j8s2TZtu1i599P72Rzs+vBtfvaRiF7Vrs6PL\n", + "CWMyTYiAjzmpJa06Td+0B3J0KGJ85u5XnFFxAtLoASn7DygKmokq0uEe9uR/GYAoPXGxAVJGHVFV\n", + "1GtPPefC2J4hZeLuVx+wFpibYxMS96v2quxv80SMwquQxxPmzo68+9YoHmjXNsftUIwVo09ckrbj\n", + "BqnHHfX/m2vXT8uVzbU5vDhD0upTtgP7hKqP6t3RzmmAA4LEULZvaQ6BK0a2IloKuicjRWOn6X6i\n", + "CrTuGw2zN054FpJWJesGfio8IuXDhw8fPnz48PHE+GyI1LPLS/l4oDdDlJMP7MwM1ClgZWV1zqYX\n", + "xBCr6YYUix/wVsvu621z7vQ+kIP4gLfp26O9/WcoP08TdnoHKZpkFeYj3oQHKyHuUZ7PjuAxCKAT\n", + "1KyJ17uUlSYG4Cx25hMpdmdYLWYJqbOCqF3GtqpsLt0b+z25b1cfnGfV1c4hUxmtlu8rh1zMo+33\n", + "+TOH4OiqVURkB6/DF8+/WLZ1b93K4e21rbSvP7j9HEsrP35euuNOubXJGKuvl7vWjBqlAOrVUftX\n", + "6mpOjNEEq7M8sRXZAJJlH1jb7UEeZ++2Ev3t+YW7rlX5yq61cKTbL//13yzb/v73/05ERB4Ov1q2\n", + "NRWUdYlsGgIJiGnlmqIkfJrtPGtFndCh1+SNpyTmmkq9Z3H7aEgnRFGUuLB2yoB2TlQSrUrlHZWz\n", + "xyFWX1gaxlTE0AI5YZRKh1PLBQhARNsTe126excySRPLxLKg/QH1XcFNvqL+qs71MemEnIBI9ESi\n", + "Bf93QWZFrE2U9O22Qb2dUBKVTDC5BOsvigjPtILVvwNCxEMg5hPdk7JUWQO+fKgoc1X3QqgnAiy2\n", + "hfhi21BpPqQ4avKaC8SNey0EEREJgcRxm6iMRUeSDKoUndB9j4Ec1UBJBqr91sKabGvq7Ev/IFeK\n", + "SQtF6Pq1hH4mZu++dmhXSwT0n26+xY7Rr0lZXbMJlzsjxyt5fv9gsEJTq0wDFS8AsWsHcgDAOJ0G\n", + "QpNalUSBN2Fq56vNmVLBRqN2bXRfY/SJjp4xsWipPymQq00jSYLoL3JAbfOZryOKfQrbR4xjzDSv\n", + "TbXbcSd2rUoUr48ktdC7e1xX1v8eQveb119cLttmOC5cothhnRNagwGYhXafXl25uXO1fbFsS1BI\n", + "EhLEXkMy5f7WUM8jigsuM1KqR/98e+f6/ZxaY6/WWmxBKHGHAgAqYpBB/XypUGwPpXTKBKwxx+ZU\n", + "ZDF8yjOSwiNSPnz48OHDhw8fTwz/IuXDhw8fPnz48PHE+GypvSxaSZhSiqOGeWHIZG8HMc6Ej4e5\n", + "kmMtBRKoBgzBwyeQgUOh1Aag+hA6TouCrIjcAO4OCOLNQTbNCoNH1dx1IGK7GiMztBqqufJEsKxq\n", + "oCgRjvRcEkDMRcHpThyrI3g4cdfQk7ZRqirjdE6vX3wpIiLVyVIwJ+g8vX37g4iI7HYG3TaDg0zz\n", + "1EiEV6NL3339xTfLtgKaIZcbg/Zvi4/uWmdKmUAd9sPB2q5LXZpvc0FaXRt33XWtxsPLRxKBZD8Z\n", + "iiydEuAp3VLCXDWhex2ifWbSoFH1/LalVAmud3/vtuWJtfXXLxws/frqm2XbF2/+hYiI/M//7r9b\n", + "th0O/9ldQ0WkbKR+m9TOcxWp2jgR9ZEXGJHi2pLuzxaGu5wy6CrXnl1t8HiKlMWGFIs1o9cTAbmG\n", + "MXfP6XOkYBJNKTZETkVKIaB+ejy4/rTdkNo7xknVPk73sQZajsKDkcbzBsT/Elo8OaXMJ6SCBtqv\n", + "mrweDqyF4/oTm4ZrSomJ6iUMmSfSpRpAPM5x/e9uLRUdYCcdGxmLGmkT3QBpxoII+KJFIUTsHpEq\n", + "25JW1hHk+oqU+rcbd569FgBwB1BiNxPbcYzxLN2Nj+iXmmdMWKkexG+ei2akvtSEVvXnRERm1Uxr\n", + "rK3XO+gs0X5lBY4C6SNpV2ipKOU//dPfiojID+9/vWy7OzqagWnb2X5ffQVaQk4aeCgUeP/B7l3d\n", + "uf7HYt+CoiFWG9cmi8hIuUPqMUYhSExppDR2fSGh58+imE0UFE3zJ0QtKSAuldN9srSxHSMAeX1p\n", + "T1KxH6HFlFB2NgKlhZgiUiJVnrBBPOaChu7d6eA+r0+UbgeVIogtzX4JOopErm2Gzjgom9jd/1fP\n", + "jO4xD2j/Nc31hbvGnHTZLmb399WlFeX8/MFpi33//Xu7bjxjnz+DGTiNvwTzykTPyeboxtXxgdJ9\n", + "SPNrYZGISH9yn18RpUI1Dc+V8skk+hPhESkfPnz48OHDh48nxmdDpGSOJY2oXBqITBDYm98EpfA5\n", + "tBXMgFV1mhOJUkttGyI74q2zJWXbCArRXat+YbYy2B9Q1nu0t9B84/ZBVlciWIg3Dfv6YJWa8Bss\n", + "PLEIkdJFn5LcQ/KQ0srtvOQSaqz+iESnKr/p2q61bt0bfBFv6LcgNhKhHDxdGbFKvLm+WT5T2YWK\n", + "EJFv3rjfhpOtIL589Y07D0I6SijrRlRqXYBQ/O47W80fQVj8BS2d3qQOTVOOe9VZyWsIxeZ1aOhX\n", + "ilVff7Ky/hFk5KKw/lRhlR4S2TIR9XoiUnrvEBEldP704/fLZy+e/1JERL7++s+XbZvIdYb/5t/8\n", + "t8u2unXn8rsffr9s64CIHicqIUYZdZrYeUZAWw4VVJxJnXyH/pSQ6nKPAghVWBcRmVHCG1Cpt5Lt\n", + "OyrASNH/Yypdn4Ec1VjxxezhiA57eLB7sgPZNCdvsAFIcBnxStv9vSHkakJBRUwSFyXQjrFxiGgR\n", + "dvR99299NMXkAsTjoTYCsBZ0DCQdkuK62H8vw6qzJ/K0qoersjkjOHUNsv2ZrAGOOfK8ghUsoTrR\n", + "rNvsnNTX7vrjWzsneGH2jDqjaCTCvJawKSdwh5mlNjB2xo7U1rHqD4kArrIHq4z6CVDas7ZTJEyL\n", + "PQi5z8h/bTmWImIhkah1QqO+NsB3MSAC+AnI6oe7D3aFWP3P6MNvXtoEnEJOJqBim7sPbr8391Qu\n", + "37kxsyVJmAiFHyPhBzMQoyQiVwoUvgyN6+t9ZmM4VoSHnlN6j6MzRNC1xeXWkI4JhO6IGPh6jQH9\n", + "VntbCAI6y+QEQN0jKkCa0Yfzgsc1xjpd6wMQc352yd61E3vXdijQ2RE6HMXunnV4dlQzIf2x2/Zx\n", + "svbPM9fup4OhWlEFqQ96dqsDQpbZM+bli1+IiEhZGEr1/dvvRETkw63rJ9uC0HfIKdzdULELUhv9\n", + "3vqkyhilgd0TAZ98Qw4oBdwWYpI4Gkmy4VPhESkfPnz48OHDh48nhn+R8uHDhw8fPnz4eGJ8ttRe\n", + "05ykY2YxUnEJsQMnVaCdDVoPAMEyZJlB7TUJDbJWRdlpJrgbh4s0fUCGsiqj3JDGiZLT2aBzVmNc\n", + "ItEu+ijUnEGiujSkI4QUXYpUQUumiLMqqpPu0QxYPs0MYlSDzDm0lFnduhRdEphmR9+46y8Ixl/D\n", + "mLQbHCmz3ts+phGGskTi+3jzTkREnm1NWykCLDqQjo8qVe+2pPcCrY79DaVRHkBipaKACOm+DPfu\n", + "piVi5a07v+ILa+sSqZ2Hg5HtW5BS58bOKU/ctaqhq4hInoOoXF0v25R3rLozqn4tIvK3//B/ueNT\n", + "yuwXX30jIudmpC+e/am71tpSpR9/dmmhjr44AA5PSCU3S5CORRqpJz2hA5R9O0pBm2ev9YkQ6ZOO\n", + "9Y6WdAwlq6D3Ms52jBZqyAN+m/GF1VCY3hiMroTqkPqJGm4T/3VRNE5jSm0s6TNS4EaaY4SOXE6G\n", + "1iNSgO1AqVicXkNiTEEEsjmde31Os3bnXkFZm7TKOh3juAZ2TOiXtB/NSar7dOZGCyNZ+m0BUnzf\n", + "Wbqhwz0eKbXYIKVyubM0hqpyrzeuDzeUHlFSOPfTCWNxpjRyh5RxSGnJHGm5iQynN+AtsHCzNk+n\n", + "RrE1aXFhTsoy2++IH0dErA8wt49kWhyhz16//7hsi6HKXoaWvosGRzLebEDOJheDGCTvE431I/rp\n", + "QEUcapbNKVBVFJ+pb8RqpM5uC0jzqN4QpzbDhWbBDYZCJVLWH5CqiyllqIbc9DWJ8T1W29ZsrGb7\n", + "qFstrhAtpQIvMNbokSTpYiRO4xT/jrX15x79frWm679w/WS9oZTyfE6LCclIuYJ+1DxREQX0m+72\n", + "RsGYMcYvr4yC8uqVO+nLS3LAQLp/ldv3vv7C0SueXTm3iXkkZX88u55TrceXWxT2fGXbCijvR2I3\n", + "QNP9GanSazHGRH1iGAf5H/77fyv/pfCIlA8fPnz48OHDxxPjsyFSp+pBevKyOQHVCCNbmaiH3bFq\n", + "6Jfu71VJJNaFtE1oBlaTCb0rDlj9Ktk2JKRJlFg32xt8DaJqS6ufOnVv1QmrPSsBMLdX4qZWQjut\n", + "sEEUXUMVl1XEFbmaeyLxgsTKMhEq3dBTCbcibLcP5kkVTyidJ0+8onTnFx8eH79GGSiT3X/48ScR\n", + "EXnx/Otl282DQ124JP724AiAGZV/pyBIPrsylOqhVWKnfS/EymqD1UpC9+RY6arO9lHmrvy5TQwl\n", + "qUC2Hycq6wZKwHIOSsYfqXa4hspuV7k2ZCHunz84kvP/+n/+T8u2P/ulQ5/WJXmIoQDgDSQnREQO\n", + "B3cvkpFJrCAK08pxjetpVu6ziBBJhQYYfRqBxJQl9Wv0nY6/p6gHkaIDeBbGLDeN5W6MtgupYKBc\n", + "u1VnSOCLqoLv7w3VW0PCgNWpc/h1sSdc0z7g+FRkAXRAzzwghe0RZdqblW37+aM77o7KlUf1KyP5\n", + "kQoq60w2viflaw2VTBhRYt4SIq1r+IEI+Ipgsdp7gHEdUpl6qD6ddD0zytrvb41YrertO/K66zHv\n", + "RdiWlbb6H4HOJYQ0qU8giZjL6egI2Ow1mKqzApGIG8ytu0uTQokKqKfDL5THuqIFCZHYI4znmY1S\n", + "IRkQEXLWAqX49U/fLdu+fed8LNvR+tOzF+66Q5DDw4lQ7ZM733uSpFjQHyIxRyhUykgBPMF1zCRx\n", + "M0GmIi2oUCdUtXegigOhv1AWZ//VbA3CNhUbBYPrn2FAzw6g6CN5NxbwsEvOED7IGeAec79KcJ5F\n", + "YfNaCSmINT1/EiDdDT0n9nuHdPbP2afUnXua0TyBrBBZPEoMhDVA9iUm9GmVumd2nlO7Yv79+iV7\n", + "x+KYJNQQYsyGo83xF1CtX5HNR9uo7A+eq1TEpahiS5IwAqkJVvYvkJ3ISH4h1qKkkDElzEkMBfKc\n", + "+YnwiJQPHz58+PDhw8cTw79I+fDhw4cPHz58PDE+W2qvHTuZhYw6ZwcjP9yToS1gv56UWAfo4syk\n", + "u6KaLgERUDWjMRIsrzCmkg5DIl2mqtnBWlBKcqeUQQMtjiC181T4kN9KVQGcZalTpCCjwv17QanI\n", + "g+KepLp6Dy2qrifIGAgjI5GqwDx2RnZO1UgzMAh4UQpGWiJJieDXqRI8a4e4f3/3wz8u2zZIaYVk\n", + "/HqqbrE/S4vEoYPnS843rHCedI0HaKvs8NmW8kiHHkTE9Ztl24tXTj13IAJufXLX3dRG7J1AKCzz\n", + "i2WbavWkpLcVRO43AeD7jooDchhzPpCO0f/xH3/nzuOMMOnSIjGZXG4voUHzYCkLTQGGpE8yIS2x\n", + "Ld11dYOp+UbQzCopY9Kg6bj/H5AWnYioHWUgdhO03yGlVpN6+aipDaQCRiLnqqNARJphqo/FkPnd\n", + "nSOU7iiNliHNsN9bOi2DBk9A55mCyB9D44rH8Lp039/Xpk8TQauqqUzZvMc01lEKfsAE0PaWWjse\n", + "Xf8sckoZ9CC551Axp1SUEs/DiOcVJdvathiaRs8u7Ppz1S/jtBRSdhdELB9ad059a2MnhaL/iLku\n", + "JA0bNR6OiILQglges/EttLVOD9ZOMdo2jS2NV5aYE4mAr3pUeqyaNLtipH4jSs9PILmHifV/5ULP\n", + "Rzv+x/eub3/300/Ltu/eOu21MLV7HKdagODOo6qtrY9wIIgotZshtRNQYUlSunN/+cwKcNbQKiJe\n", + "t+SFO+fNpY1nLYqYkZ6aqLDgcuu+p9p5IiIZ5pOM7pMqn1eVpSAf9m4uqKk/p7gO7pMVTMq12Cmj\n", + "9Liqgq/Xdvw8VX04KnZSRXV6/nQoGmhbeu6O7t5FRJ8oQDwvSuIgYD8DqCchjdOlAIHPU2keXJMh\n", + "quNFautKX6DUWYa5oCBz9TUuTSk7XJSj4yO/sDbMoXsV8BuO6q0R3UGvg1P1OhQCKiiIkj+MOXlE\n", + "yocPHz58+PDh44nx2RCpSSZJSB1ZVzpta0S4hwf3d1fbqi7QN2wqIVYCJi00RLA64zfSCZer5ZIB\n", + "lbUmWpNKaIF6YnGpd4i36YiUXRO8EQ+0+pzBKF4RiVFLhkso0KaE/qTwhos6lgtw13XkctXOrVYi\n", + "8nCaA0UV7K26qRxKM4WkFA+0Qd++1xsmTOM1nN7WcxA1Z0IQfvPjr7CNVrAD5BcyWs2D2KnkTBFb\n", + "YTAS2ffufh7VXiq1VcAlVjXPrwyRen3pkJubwry5IKwrBa0LAOZJOtqqSrvWamvXPQ9uxZjBY6+q\n", + "aAkF9GO7spXWXe3u048//HbZFsauJPdia15Tl6X7zV1FKsq47raxkuD0EqW2o1thZqUhaGHoVq4z\n", + "EdYTIB0j9bUtZB3qxla/DciZIyOX6P+no11ji/6cF+58L4jYrB5vTJhuQPINSEJBuciXl6ZA/+OP\n", + "3+Iz66cXWPUPhJIlQIljyCTkBam4A3WLuYgDl70/GkpSA7FuKuvrUD+RKOUxgQ5AJNK6Q5sB4Zno\n", + "uhSJYK/PT8UFiNpahi4iMnWu7e7vDZEpIAWQkbJ9dUCZNqGOMVbCqvCdr20OiTBndhU5AASKFtj1\n", + "hxgL/Wgo7V4cmlMUdp7qWVkSAff+6Bq5g6xBTIrlWqgTsdIz0ISACoBmkIGbB0NYfwIixb/9BdwD\n", + "WrF2UiBApWZOkzlbbF5iDiNEVO/PTFUcKyhmX+wMJdRnR0kOCOuN+96arl9RUZXJiAmtyIFqsdp9\n", + "hvG3JgJ4DBSXnQWur10/2RNKt0KfyQh90d6myFSS2rWqU0DIhSW4TzMjKOj3EWMlOJVTa31C5REy\n", + "QhNL7aeklB7ASWHAc5eV0HWccK2BSggouioiEsChgewXF4kRlgSZ1DuQMkYxCPdZuX10rcEiyfEY\n", + "uZ1pH+qX19I8qWAjz3GJ7ocV6P/wFOARKR8+fPjw4cOHj6eGf5Hy4cOHDx8+fPh4Yny+1N4wyYpU\n", + "bwdRIq59px9AGCOT0wGE0vFMM+axCbFC9Ky3kqqmCGD8nnRv1LS2IHh6u3InMxMUPTdID4wGbfbQ\n", + "nhkD0rECZF5sXtrxAd/mgMcbSmNmgJOz2NIez6BPcrg1yF5E04ikWAsdqZ5VbJHTGWeDcRUqLwFP\n", + "5yvWvYHJqTDZ2p3vn/7JXy/bVEfkd28ttdYgy5CTsnCk7c9kexAqZyLWKme2gpFzvrHvX2xVM8VS\n", + "awMU2/uKdE86hbZt2+WVI/Syts2udND6QG2iBPEI9zOkdGeD/VWNEdtzEFrH3qDwm48utZlHrM7r\n", + "rqMg0+gBxPostvRRB22lWVRPxlJ7XQ8SMaWbE0Ds82h9ooQS825txNqba3eNH452rRv0nYkI/QmU\n", + "6hXaj2gA6sjpx8d6KgmNie3GpUrub41Yrlo4q5WNpwBjLCe18xRpESV0JyReE0HjK6D08Auk0Xoa\n", + "/wcUGXQ9KbYjt8tpkQEE1cPhdtkWqrlxj7HI+Yl/luLhj7UQQUSkQNHG8USE6VhTdjQnYEwweT/S\n", + "og2aT9RcOFTdO05jgKuQ59auDcjL00B9onT3s++ZggBzYRp/qpUzdDYXlejjAXIwdPdlQlo2pH4d\n", + "IC02kQNFiN4zUVosBAH4amt9PAm+ERGRrqf0Hcb9Cmnu+mjn1mjhEVELDujjrGWv5G1Oy6kGWJpa\n", + "++fQu0rovquRdJzov9Yn9Vuc7k1BLE85PYfPQ6KAXO7cdW1Y7R3PgozI8z0KHlaYf7m/KAF+pPlf\n", + "DY8TIpsnqpVIRRE9KBplaKniLm5wfOunqscVky7gspsGf1ABVIK+EHJ+emkf0pZC8czQcgGGu59M\n", + "lFc1fm5j/VzbibXNdLzw0B0XvSlrp2kp0CD6Rnh+biI2TmOSoI95558Ij0j58OHDhw8fPnw8MT4f\n", + "ItUPMtGqMgUReyZUJVLVX3qDr2e3Sm9YsRmox0iy1NP8uKxRdHUID53NpamoZ3gLzkgxWktI+ZzG\n", + "DjIJxJgbgQipb5mIyIzS3aMQAVVLy1XCgeG3Qd+CjQi3Qt37+IGYbthFQqufJIJPXkteWw3OnT3B\n", + "0BSdmg6GtjLIcij2Jnas7YVbEf7Lv/g3yzZVYt7T6vvbO0ee7FtS5wVBNSeZhI2uogkluL5xvlsq\n", + "zcCq36WgDY8m63ACsf7th3fLtv7gvheQirESCtdXdo+1nHpkj0eQJlOsqp5dkecZFIg/3tP3gRIF\n", + "hOYN2MepMuRqs4ayd2r3f9AiBxp1TePaLo5BgB3t+FfbPxERkZvDr5Zt0QyyK6101UOKFePvQ7fC\n", + "TwMqCcfnFxd2Tu0JRGGgvmdEcKzIzrzZ1q49545QUqwcb+/snmxA4r26sFL7unV9Jjlb6bo2SRIl\n", + "nZNfmsov0OpTUdLN2hCZI/r9w8HGTg/0gcvPUyAMPRWZqBegInEsNaD805l90LAyzYkAr+T12xsj\n", + "Vqs/YUx9vYGyd89zFzrDHNLKGcv/CfeYybEF9sfjP8K964lsPuCeXV5ZAYAW8rCf6Rpee+xTp+Xx\n", + "qrCRxey5hnFKKFkI/8upY6QZaBa5DWxRsl9TQc0EGYFnl1fLthcvHIp/sXPb9jeGIGpfGwl/OoKU\n", + "zXNdAISBi5e0L4xEAD/cuz55T9IxK5yn3sOyPCtjEhFDYUSsiEDHoYjIvcp+BNx3ocBN7gU63lg9\n", + "P9YsyiL3b8ftgbpWlSF4Uagq3uTsMD6WblACfJqSe8EEJJoKvwKMk4RkP3rsL0RfUxkSEUPuztAv\n", + "zLEt3WvRAimCb7Jl7qJJUZUbmOGt8gsYOympveu1jmd+hf+sDYUI6zR0F99Fuk863ZDCg0yebO7D\n", + "hw8fPnz48PHHCf8i5cOHDx8+fPjw8cT4fKm9rpeRVKRnQIYTKSuvgcF1BE+uoNXBcHewpPEMfysA\n", + "2WcpE6qhQQLTToYH9agtGUoO0BRqSe14VlVoOvdRCeKk7RSAovnQmyp2C+i7UoIhQ+ZIGQmRndvx\n", + "HudrKbPqCFV2IluukI5gZd19AM0MVpGd9HpUM8cOr2m+mExrL65cau/LV79cts1IH1xtLWXw29Ep\n", + "nyucLyIyq+EmFQqMgNt7gtbr2v09LIbGBgUXF+7vmztTQt43zvD0vrM00jw7+L4YTR9GAJknn9BW\n", + "Ckmldh7cPXnxzPWrTWZEzDBy+31/Y+e0gsTuOiR1bJhlDhORrSfcY0oB5Gq+21k7qeHw6eR+W+SU\n", + "ioXG0nbzlV0DvscjN5g1jWvH0tQzK2bHgNGL3H6ciRY5oABBLBWoqYB1ScbDSOkyr/TjjUuLrFbW\n", + "/praCyg9EOBYMfV7TeUpKfiM643fplSwMCH1zPo0JdJsZWmprQp6VzxPqFbMOD5OGRTQz0o4Zafn\n", + "QQNFTy+n9NgEojRnIjSNVJAuVoa5iwnws2paEc1hxr1TEnHbWRonAbUgiq2tNQWR0bmX0IpiHa83\n", + "L5ze2WpnabQAOncB17PohWC88PyjekdclDBpuoeKPSYIecWfImDTnLQCaT8nbSulUhyRHuuJiK8k\n", + "+i0pgatWFKcblXhdN5baOxxcGl31mUREWnzO27QTKlGZ9QE1jcYkdiW2pzTW0/hcd0nEUl+cWtSm\n", + "7okqogUC2l7T/PizmIqolL7CxVPBFJ19JmJ6SwXltpRQPZ0VVCCNRs/dRaNMVb9pAoj0ukKa10B3\n", + "4AKwONAxTmk0/JbbTmMcWW/Q7U/T8nytSqzn/erYCZnao9qGn2gTLigJP/G90JPNffjw4cOHDx8+\n", + "/jjx2RCppp4kX7GvHsiupDqc4o2wY3nmxdeHyorlsQJtshDm7KczJBampayXVjBYYTW1bXu4cauU\n", + "e1JRVqSrIPQpUvJeRmrfeIOvJ/vtae/KdNUvaUVEZF1gTETYi1CGmq+oXLQGYZmUbaNllUhv2rqa\n", + "FG4AqCJjxTdxXTN84AJaaT67dCvYNSEN93u3gptolVaqAjqtNHstNaXDx/Dpq6hNmgw+XYNrk6E3\n", + "9OO4d/u73xrSc2xcGw4jeYiBdzyQKnWewjuOtnWT+00w2TEOkB9IQnduGV3/EIHYmBGqougIr8iA\n", + "5szEbByAvnVEgEzweU8IR9+qJ51rk+c7WhkOiqBa+8dY9c8DoZmtO6eOrjULHcn75frVsm0LZKkk\n", + "NG2CenEOUrqWcru/3c3bP3xcthUYUPcHa/+r589xLXZKumJuOjsnRSezjI4Pomgn6uFHq1XRMmjb\n", + "h/6dnKlNK2HVpB7U54ClU9pWVZTtnmyAeumY3KyoNFyJsoQ0qaPARIUlKmOyIv81vf6YJyAQZZnQ\n", + "HwNFjogAnChiBiJ6QIUF1cFdY0oFA9GyIrdDKRJQkExCDESs2FoBxvwpYq3eSKAprBif4V7PvNAH\n", + "qjtKlSLqAAAgAElEQVRTFcXYuHPeUz8ZR1WKt9+WpWtvLvG/v3djcilXP2v/x2v/AOOqKMnrcueu\n", + "cUv+j6rePnIBDk7m4cHmGPUWVESCMx16Loxgffzosg4sYaCoxkRjfUSfYeRMJTmYqK1+sto3mHSt\n", + "13AGkASPj6XoDCM9hcopfOJYA3nXqQQJt7Qq5Suhm6+hgdfiHBGqunC4yYED/7aEEi4oHZHSA3mM\n", + "/igqF8R6T+jsgFwFdF2d9uGePDE/IQmhf7JPoN67YX6czfkvhUekfPjw4cOHDx8+nhifDZHqZDzL\n", + "/Qa6CqO3QF2kTGIrMs2b0sJ12cZcKhVsY1+naRHpQrkkcSVaCPINZPnUPeB7NZUGwwsuXpNIGvYT\n", + "EMKjPlXzQCWh6n49ogw3I6FFrP6pqlW2L9wbdEmlqfMapfa0+NYVdkrih2nu+E19bb5u2sYqCMrt\n", + "3zbK6bFjvbr6Uv5/9t6s15bsrBL9YkWsvtvt2ft0mSczT7ZON2kKU6qLRFkiLV3pykKyZF2QkCX4\n", + "AwgJjPzkN9sPCOGryxtClniBJ+AFZHElQEKUTZVNYZw2dqYz8/TN7lffxn2YY8Q3Vq7tdLGr8MHU\n", + "/F7OPrHWimbGnDNijjG+8ZmZpdJNjvphf8Opa79aSPV//Pig2JblME4TM03qYeqymt5KAnKSz7Ba\n", + "WPjKZJaE1Rd1VGZmk1FIhU6lJt+CKI2s3ItagCv+iuEGjcUmYj4N7X7rQUBdFqKHoyVHRVa6WaGN\n", + "EU0HbvwKHz9nDq/bGSRLaJQETe1shr83q1jhDqX+5Dj03frSEZw60pVnZbUpoG7O+1p3i+NJNYIw\n", + "UxSYsDcY49xw3VLxfQSnVXE/sDPoVir1dY1Mkqn2IezntCf9BFoS1QhRazEFqqPoZzFOJTWcVgQK\n", + "9FTRrxqSfp4VprdaOy+MuzwXbSZ1gzi+6ia5+k4E6XWgVVbkWGFv7jjSk8L+o9dzpIOWFWVBn4gS\n", + "VMp+j4miVrDOXZrWhgz7mMoKvpZReyJaJqAjFbmfFeiQFoI+0HQxL61rZIjSq4CKZ76sab+Cpmbg\n", + "3yM6WxhomutQKmK6ShsJNU6cAjlk38gE/R9D86YIEpGYutTLI9JUFePUOQ1LpYYa0dFOR+oZYhxT\n", + "X6UI2hKo4mjkqEq/P8A+HP1i3TdFk4jOlGX883uKeKTpqploSY0h0dd1DFHLOF+x1Qj/ls7RIy3k\n", + "e0Ogb4r6EdlJZD7h+RHBmco8SYR1kYqZM9iWspqZUkMlliwpjpFIO7F/qiVEjj5WJ0rnp1s8/4tr\n", + "kfNVk1LaFCn6xnuyYgiKi1Qz24navZwTEZGKESNGjBgxYsS4YMQXqRgxYsSIESNGjAvGE6P26puL\n", + "FYEja8NVxcWcoseFOMGewh24Ji6urKc3GjtkN4DYetYXwRjr+QEqzioO3VGAVxMocgYIfjwWB3Zw\n", + "imkq9fdwfovlqjzPzAoX8xCo04aPBlIbiwK7qoguK7AiaLfEHRfXPa4IZI6f1GsOT48nYePRgTv2\n", + "lkoU4DI1Wa5hAcGqiPhKAFB74th9926wIjg+c/sBA/S8EAH6CLW7pkLV0gF3q+p0F2HmEe51PpE6\n", + "cKDRFrmnsLPG2zJxGpP3VQWgw3ngPjOhanI426eSTr9RDtQirQEaFYfnm6AKykIPLIsUb3HHhqCz\n", + "nCllRQGwiB0BaWcl398AafrLCt2ZfR+VBSw8Ft4nWKZusFT7D4htJSW8gXGUiXieda1GE7GEMPxN\n", + "+xExcc5xnqIXL1K3E6UxaT+ingj4fCx1tTa77nLOIKVDeH4p6eK0q5jPnUZhu5YE3E9LrGunNinh\n", + "fo5GTgHRdkMdoAuxLRIwToQyoqA1EyqGniGNmt/Xdjv0xbMzHyctuGOLrtWyfD3VeoZ7Us+EWmKt\n", + "sTnrBXp/yUCFLaT/zWEPsCFCeR5hNJZab6jJWCqr2B9jXEThE1DpGfZSkWs1Uu9NHye06Vge3Cs2\n", + "3X8QKN1TocDodr2Q65+gLypVw6QVUloz4ZZJqc1lXk0wZ+ZCWT14EM5lxWoCx1W6bzjgWPBrpGv4\n", + "GYT9Sg+RiqyKhQDpxl7P9Rb9PsTe0nd4H9WSoLD/0GOAbqTbvwq7OV9m6ToVVcqVbkYFBvMg3bVK\n", + "WbHag1jSgNKsyXzi42SOc/IgpUbLAzOzei383e16XcUW5qRU2rrfD/IBdWqn5ESrB9TQPkxO0Tac\n", + "YO7QcZUWiQJCy2O/A6nKQamCCtA5n6vFw/tLzSMiFSNGjBgxYsSIceF4YohUeWNpiQp7IU6el2VV\n", + "BaPL7qa/GR4cYYUjKdENvDnmYtzGRaym6ZdY9RuIVLPlqwUaoqWiYq3WwrZW4iuYEk39lop0QdhW\n", + "9eZs4s++lBriMRIcY7oitofoVVKjz2A1kC79zXxWwWqhIWJ31JCrSVp7HcaFo4GvCCtMT8Xbfa5p\n", + "2KzXVPJjPToJqFNJzP8ePwyI1FhSWIv1SSp2FkA6DnpeJ2sbYsyK7C/D6ms4CCviNPHjb0CIma1U\n", + "P4f5ZuorHaZVV6u+SqbYsVFx9IviTbUzSIFsNZthf01JF+fKeTqTNgRyUxNhM5GOmbR1uxaOn4hQ\n", + "toFzSuX41PaPp7DrEPPDMVbfJb1+oj9iyJfPWQfL9zsZBaRjVpKVe0LjTjXTg6AVu9O2LqwbZGWW\n", + "VUL7NHS1ChNbFdv2escr5xuOT4RRxN5YYVP/OxW0jKjTSr1IohVqlofVpDSJzSAezwRhnU9pdOnf\n", + "S3AMJqVUa5IGTYGt3EOa3o6GgnTBkqMsFeQTzE/5TOr/cV27lHuH05sJ6sZ+YhXWH/R5imbCuo8S\n", + "hd0iQN9q7+L7fj3zIWod7rqZLk+5oYaYU6KjRCZ8TCQCzhXb0iCyn5W9TY774bfv3L/t+8Xlt9o+\n", + "x1fGmItW0vlx34u6eoI+AmEuCdJcR91FdSkYjcM1TAciyifCIW03gwdMIpgCBeDtPOz3PPPJmqD/\n", + "NfQZis7NzJZLoonrps8zNXhmToim2lMoXyQneb+idUAqVhNEsxTB4XnSmDacE+wnVpTlfO44wzEB\n", + "KqymlymOUdS/lME2wlgbjRyRWxC5lUSdxRxjR0xyHz9+ZGZmxyeO5nIMbmz4HF8YazMBZUXEH/5V\n", + "k16iyFVhXSbTcNyZXGtaMEwyntCRtE6m/n1eREQqRowYMWLEiBHjghFfpGLEiBEjRowYMS4YT4za\n", + "S0olM/WdqAa6ZyYGUQt4C9W6Dk/v7wXI9NEdqY2E37TEKXyEWnczpQUAN2aAjksLP1YHwuJUvXAA\n", + "Hy/Fi4Z16rT+XgkeLGJsXtBIzY5DhlOodsejsI+awLMT1nUSeeAIddiyxI/Voi+TnCch7Zl4MNFb\n", + "51J317eB2uRpZhURtqMNr+7790uAdg8e3fJzGsHtuO+QaYL6eNtt/y205tbKGrINsGxDfHTyAJFf\n", + "bcFjqeKQOaHduiQALHBOZRWR56SAzL9n9CCSpATWyTKFaXEvQFmpYJztmYjvCeuZVUUcegRXcopp\n", + "zcwOh4HSbLb8+lnrrSQ18TIK1QuMX2g01uuaie8Jz1poWcLS6i1Ed+ZcfGRqhUBWaiLSKyldnwoo\n", + "lK/V3R9pMQn0xVSOv9EN92wm1uZHh4HaazSdAiwEnWKLPRr1cSyKWdfr8JXk/pNtVBE/e7SKstkm\n", + "i/nI3hvqos3fkBbZEHpyjDqF6hhNz5zx2GmMUT/QElf3rhbbTkBVNMRvifrwqmyrkDIRWQLrnqW4\n", + "dzMR4M9nEOJKUg5FwUsRZS8hwM0kAaZcCzR3onXNCid7mQuSNs4TNI7Mq/SFyyXZI8d6vNz0fpLg\n", + "nLTW3hz9M9X6m2haHc/VagO/xf0XGqmBvqD3P0HtTKUHKZ9QfyLWZNR5IlmwdqFcP9qni+QI9RDi\n", + "IVScPJnQsd+vtXKOsHwCT62BCKtnI3qbiaAedRrpWaceU4XY2i+hSCzZ2PT2b3fCuY8GfqwJ/PNy\n", + "oaA5Z6gA/ezsDNu83/F6mu3Wyu/MfJyoZ1i5Ej7v9V3YPR2vf4/JJurjRRpNqTq2wRz9ekWwz3tt\n", + "HgnaU9suRwfpdH2Ml+htJRIECvVN+mSW+hx0XkREKkaMGDFixIgR44LxxBCpYb9UOAebmVWRmr8Q\n", + "Iewcq9SWuJNf3Q8oxcljF2cOsThst/239QbEZnqFU6T9s+KzIAiVJlIeBSVLiFzIm/kMb8T6Bl+n\n", + "/YC8E9fwBlsqSZ0wfJ7D9XoykrzyxL9VRMrabHIJQMeaDX+D72CludH29PKtVlidvHz92WJbscIv\n", + "sYaZH2sJQWWrJRXk4d4+EQf40rXwebcqKwgI25tVX7mW4MmgtevSLHyv03ERIc+lqMOW+bs9V5Dl\n", + "iqxq56z+Le2KtFtN4Z0BkRyKJUZRETz3TkFB+YL1ouReF+64IgAvIxVc03XHRAJlWUIRt6If+Tni\n", + "ad4DikL1MwqqVWzKum4arQbE+1prrVg6+7YJUQ+t/1X8QRdvsWvAKnQu/aSEBJDpxBEZpj8fHLgl\n", + "RhPi5ZKgD9yNVhTg6rfZDP0kP6c2l9aQZPso+kLrkJI0QPWcavJELFQ42mp38X0iQ4LW5etC1PE4\n", + "3PeJiOLpYq73ibX7tE5gC6v5RIpcFjYqIsAnAsMEkJmk+pfQX8eSws3vVURsXCBSspLmeeZ1QZMz\n", + "XH/N0eSsKAoQ/khkXBv2sVIPjeJkqRhAke/lS17rsT+gi7bMO+iLivAwKYK2Hquu0rgueXSVYA9S\n", + "aUmyDZMhpK/TTmAkNin8OFmsoz5EvTQBg3PCVOafpa07lrfbSKyRfjjAcVUUzmsbiSs36xMOTwKq\n", + "q2gZ3dtbgvRmQG5KMneyOZttRw4pop8tvD35DK5KUkIbyQCJZGWk70FOx9L/mSAyUUQqC9eTyX0d\n", + "rZgmhCjc6/UaURO0WpVxj/tO1/NE2ByK95UlYu/sdrf8Gmh7pNYtOCetdjEDc6TI3WIea+3FiBEj\n", + "RowYMWL8q0R8kYoRI0aMGDFixLhgPDFqb3C6tJlU+a0sA2SeCxXWy4Ngs335SrGtVQ+w3LUbTmPd\n", + "eit8b750eLIBN/C5wIkNCCUrQOz0M0J75ZpAhhQbzwTuB1Wk2yja1gKReQGtr4t9ZzPA8gInV1Dc\n", + "eDR2ainbgBN3U+BpQLuXO88U2/a2r5uZ2XbXPZMa8DmpimCvDrqFxV2V2itRbKc9ApvG4k68UQ73\n", + "6XJLnY3xdXF7Z9vVxcejgvZvVKW4aIn/hJ0sRFjLHdfFs4lnrLTwaBjOb6zUDmjZXGDsJeiT5Vwh\n", + "a1AwLF47FeoM7dOQYqgL0MMKY7O4pkL2bfinqN8R6WAtmkk6gF5Y/b5TZuPZepHNFAJcdTGnsF69\n", + "ZQrvGxHqVsoU2/r1V3ht2FQS36UFfc9ScUKGeDuRcXp6FvqEehH1IXLd3vRxSlf6wdBdtDkm6ugT\n", + "U6HbKbZXd3p6wSiPSeG9UmuktirqbI3xWSqr30zok2NQq+OJCHFxv1QwPitEtn78TSR06H1aoN81\n", + "1ZeqRPd4pfFAn4pX2Qz7oShdqU1SajW5Ll63OnAnLG4rY3KJBBVRL9gCySOZiNdLHG/0dMuVRsUm\n", + "oT1moKweP/AC1dOiuLK3SQlU0ULoTor9m0LLkYOlEHnacxopxxx/duYVGxag2a5fu15s45yhiQJT\n", + "C9eqxdr552y+fk6c907P3B+LY10LBJdxjy9f9edUDQXkNSml8HGSPtG0QPdOxu6tRxotKWQP3tdY\n", + "8LkqBeprcNFfyLWeHYdnotJ97EdLccXnDa025dnZhgeeFjwuEh/WpS0diPKzktPN/KU8/gpPLXV7\n", + "534mQl/PZiwWLfektIr5LEbS/yB3GYm3oY4FBun+vtDi42HoE7mM5yxjEXjfppKf8yIiUjFixIgR\n", + "I0aMGBeMJ4ZIVaxudXHiHsPZmim3ZmZNOFUPTkXEuB3exK/v+Up3jlVkb+hvpEsssaeycmhDvNbB\n", + "2/dCkkiPT8KqKhWUKIWIepL78etwB6+3fKU3x0prIDYJiyKtXuoF4fiNrW2cm7+FD/th1dXsSP27\n", + "8hLbfB/Xtm+Ef7duFNt2t4NTcVlSjbmIzWX1wTf9pIHvrTj2Fr/066LVgKwGyvWw+qmLiHI64UrP\n", + "r79WpiuzuL1jlahpqrQbWLopQ/EZ64DpyojCT7WuSLE6a9RVxBnOqSIiyiVU+zNp9wFSXZnOqyJm\n", + "ojMqROS5ZCs1tGDTIce3RK8S+4N4dV1y6VtHgv71RwHVaTZ9tdrG3yqALlbTK0JxoK/S/4hIaXsW\n", + "1hF0kVZUByt4RUQyFPvLp9qGYezOU0V6wn1qNtbtBKpSPYCICRHGiqSQ87q0rxGlWEq6MjuUXhdr\n", + "92mVrApQr1bL08TP4EadJKHddQydQOy7IenSzDsopb7fHuwPtsSJeTgIfWZTkJYBhPVbUn9sTJGx\n", + "oPMl1DgkwqVi5zmQXr3/7ON1QU4plC43vO+U2kF4W6r78Zn2vchF0A6UhH1iBWkHWrSSag70l4kD\n", + "ZmaHp+Hv0sKv6z6qIihK3kR9wMUKIgSXf8whdUE6KUDvSmIN7UFSSWwpECNBn+ZAWNUpfjIh+uHf\n", + "I7KcVzH/y/jvn4PINDqhvdTtn3Ute8fHxbYCaZTr5xyj00WrFdqEDvCKrvA8M/0BTr1/6u1P5FQt\n", + "GXjd6nSSACVrqMUIE3DE4oSJMku2tTwnakC969vOiBDhX60rCKRH5inON4qSn50GxKh35ug852zW\n", + "7qsJqlfDXKzMAdtV6zoOca+n0teWsC7KFLmH7URd2u5HRUSkYsSIESNGjBgxLhjxRSpGjBgxYsSI\n", + "EeOC8cSovWpaWYHs58MAt7XE+KkCqHyRixBzFt79GgKPXr2+b2Zmb9+9V2yj34rNxCkczqo72wEC\n", + "bJjQUyhoupCCijTPbXTEiRt+U7l4Ec2XKKRZcQFgqx62dQRa78JbpFYPkO1crmtML4yxQ8asKDoX\n", + "avHKZvCFagndQKueeSoFmgHZl8SzZoFj9IbwsxIvlBRwZk2ugS1XFyEqi7xOJ94mhKxrJaFgAAuX\n", + "hMiiK7mi0oR7HQIWJ+iM1J6+79P4Rag9iGgrQi3xqCu0YCN8Ppm4Z8sQAkUWzazXhHaoUgjq7U/K\n", + "ainXRSh8KTDyDDSiesAQ0lYBOotf87Ou3NdmB27rMk7ojj4Y+DXQW0qLwW5uBBpHacES2nZFFE0B\n", + "bOEEvC7EVdqDcP9YvHjoc1QVWswdw0UUPw+/UW8d9skFKCstEEwbG/VwIVVMkaiZiHOln7C47XLh\n", + "Y6wGaq+SiUsx7+ci/HYgTtB0J1faYasDIa5QhizgykLNZmZt0OeZyAdGpOqERpijWLGL6M3GIzg1\n", + "g26pCrU/IRUo/DDpEXWbbqBodrUpxYiRgKKu9OU2fJ6mLsDN4ZWV1EjxiYg9Xx9/Gejj3Ssutm7A\n", + "If7RXa+KwFM+PHSh+P37QaCuCSUVJO8UVJTMF5xD06r2tfD9o5NH/kUcjH5OGlpwlxSd+mL14cbN\n", + "fq8JC1c6l81stWg9JRLqAXcEL6hRz/tTVojItSoFqhJM/N4tikQJehF6v+Y5Tc/xk5vJ/XfPNvHb\n", + "wxjvnfq9ppQhWxGA0+1c6WbMXUXbeQfcgbREVBE2F/G4HwvPhFSlGvB7VPoW45gUp5kXRubc0Wj4\n", + "c6rB6hCp+k4xe0bmExacFgqQ/ThJdDzzWShedDIHnhcRkYoRI0aMGDFixLhgPDFEKitllkpK4RLi\n", + "sEomwtoGU6L9TXMAe4C5LCrrUIDud12AeHAQap0tRZRMiGk4DG+ftYa/cW5DPL6o+AqGK5dSWRAZ\n", + "1KbSlOy0xLpS/lZNEbU6LNPtl2/TWktojtT8haR/n/bCivjw9HGxjW/JJXGdZdprMvW36gX2p2Jv\n", + "rvqXWC3oO3YthzVCJs7mWM02G1IvDyJKPX5i4XOtCVbiSl9W84NR+K2u8EpErs5xOJ4CrUhEiMtQ\n", + "F2dWnpqKAJoC0bNez94bKsolYtOBw3VaFWd1oInVzPfLtO6+OJsTnJhrqjeQtrk4pbsAXhAm/M3r\n", + "SSRdeQ4rhuVSEwbgLDxWZ22IPcVtvtkI16M2CfNCKLteO6wQuwsiM8ZYywXVKUTBJXEiBtJRq62j\n", + "r/Olt12O5IGhoFktrERZp1DroFEoOxQXZVq2q2B3PAifl6X+ZBMO/Wcjv9ZWK4y7nlQUGB2H1PYM\n", + "aKYiGGUgArqqX0KUrWhuA5YpKkCuwVE6F+SqWg37U7Hrgqn+cz/PSoK2w3G1XlwF97Mk45qIXCqr\n", + "72LVn8nquxYQ/jQXS4hluBeJoFSzMwrFMdYb7g7NunolFfsD6bt84wX/HsTBU6lJeDg6MLNVO5XJ\n", + "PKAjtZJP6DPMXWcnPVyXz/8l9Lvx0UGxjUiwInK0FXlKKjsMUCdSlfJl7K9Zd4RjOAjHnQAl6nQ8\n", + "OYHjRJMyiNLOJP2eFQ2qMtcRaVGLE6I0ihITdeY8PR6tJ9vMpL+MYN1RLkufADpTFqyEKJqK5/lb\n", + "fU4keLY1ZN7n30TdFOknwqN17TgW1OpjXgjLxU6jQLq07mu4/r1dd8Wn7QsTENSJvbCVkGfSlNco\n", + "95r2IxUR1vOdIJV5lwi0WsFY8v6YU0SkYsSIESNGjBgxLhjxRSpGjBgxYsSIEeOC8cSovclksALZ\n", + "VgDtLWdSZHMJL4ipuFj3UFzVHO6vQViZCYxdhwfVZHhUbGuUA/XQygJk2Grs+GcpoHgpmkwPnky8\n", + "eBJ4lag7Lh2bV4XFcFafz9e2kVpqthxOLuBp8aKaQ7A8WhGgh3+UxiLMvCq2RcHT2brobwbxup4b\n", + "i3bOqwKxT8LBRkrj4RqUnuPfc6EHuG+Fe0npKLVFUTApPT0nNrGWiyyoRaFWSVnOF+vUnsLI3HdN\n", + "rjHP6V9EwbK4vfPIqnadL1d+Z+YC9FzIUtIM9L3Rz1dE6YDvCWcrPTEB7K7i/Ol8/d6V4RivMDZp\n", + "JPWg4bGUbiVEz+Ouairhti70KJuiJC7qbRShLslvSRkk5m1dySjs9O+RPiFUP5M+VKlwTDgVWKYT\n", + "vVAGmTGxQQqO4xjqtk5/oKMDd6o+OArC5xHE68/fvOnfRxv2e+7Pk1lo/62uUCEsmqz1xjG3JSI2\n", + "J6Wg1AoLqW5IVQIWTWVjj8YD+f56MeYaJBAlGVcNUNa50D0GijYRv6UEIvfTBz5PDgZBUtDsh/Zq\n", + "OsNipVaYM7WbFLdT6Q9IBK7ffLnYdO/eHTMza0lVhBZcuVUCwXs3RFKAzmFMrJBuUrS/Ujb8niYP\n", + "sDC0Fv6eY3xwrJk5LTcBVTcWyu7wMFCKOoeRFtOx02yQ7lqv1KDJG+Mx5Q4yJzVAs2Pez2W+YKKK\n", + "UmYUx6tnE/tfRea6ZpPPSe8TnW6gLdXHa2nvTQDyqDeYbOHB7y1FlsH2SWUb5ywt+M55X59dc0gP\n", + "SqZzd2iLFJ0jl2ug75g+azI8Y5OSXgN9rKT/I8lq1faP85Ru/J8Qm9++fds+/vGP2wc+8AF79dVX\n", + "7ctf/rKZmR0dHdnrr79uL7zwgn3iE58oslvMzL7whS/Y888/by+99JJ99atffd+Dx4gRI0aMGDFi\n", + "/CTH+yJS5XLZfud3fsc+8pGPWL/ft5/6qZ+y119/3f7gD/7AXn/9dfvN3/xN+9KXvmRf/OIX7Ytf\n", + "/KK98cYb9kd/9Ef2xhtv2N27d+3nf/7n7Xvf+96KgJgxX05tMPCVRlKB2+7S3xaHPa4g/HtLvK3e\n", + "v+dvtZcuXTIzs0bVxa7Nanhznlb9zf363lNmZra1GVJY63UX5zaw0tWXcCJI1aojR8zJnojYlO+q\n", + "FVn95QahqLzVUjNc1JCa+kr7vPTzGuoKXspc7DmHAJSu32YuYtYgEjEXoSzF0ERddFWT4LibIrZd\n", + "UvQoIuoK0pTVHZhLMTlU4ZSeSE2uJhzIS7L6oMh4NF1f/fH7uYpoM7oei4sx0S/Jv+UKp7qyIgv7\n", + "W8pK56wX0InlnCnHvtIcAonROlCLwu3Zr5UiylRWRERMUkUEINBN5B5P0J8pjlREii7WimrxElfq\n", + "YKE5a1LDkCtcTbXmyl3bmO2jqc7v/b629RQWIirsZvsrSlQr023bEaElUv3VMZlu+HU4FWutxeUU\n", + "SI+sBlm7UpNIygWqKaJk/FmueF/jPJRLe05nRBjD/x8+9HpxbdhJzFbsInBOYvXBe6hIZ6UW+tpk\n", + "KHYqCVFarT9HOxU/zyruY4q0/sLfxFwAq+gHUV2T6ypTIL3pqHuSh/3OHz/w7zXCvDuce5+4fxBs\n", + "BK5thxqCtb4gYg0gZzKlE2ldQalyVmVwpG1/O8y7qaB07Pd0kzbzsVUBMrSQPZ9BqN1tios1a8ip\n", + "1Usxn3pfqwO5nWv1CjaZtDHHDudiRf/nqDXZFFuJFuaVhw/dfoGC8sHIrQaabTAiYvVAl30dJ0dH\n", + "j/FvQL90DtvYCN9PtE+gX+vcxTGuKD2njLIgMlUg8Tp2WPdzJtddCLCTdbTmvdUR9FxSSewhclUX\n", + "6wLO08oELDDu87VUGLeJmIldBJ8nOtcRfV6KrcES+8t0npim2P86Sl+WZ1yu3g7nxPsiUvv7+/aR\n", + "j3zEzAIE+/LLL9vdu3ftz/7sz+wzn/mMmZl95jOfsT/5kz8xM7M//dM/tV/8xV+0crlsN27csJs3\n", + "b9rXv/719z2BGDFixIgRI0aMn9T4Hxabv/POO/bNb37TfuZnfsYePnxoe3uBON/b2ytWcffu3bNr\n", + "164Vv7l27ZrdvXv3f/Epx4gRI0aMGDFi/NuI/yGxeb/ft0996lP2u7/7uwXczUiS5D2iLFv7/Nzt\n", + "eXUVuqN7rjBGk1GAFkciTpuAAlIfl6PHgZ5pXXcYu9kM0F616tt2t4Pz7kYzUGXqO0FqLdHCr6Q0\n", + "khVlo5mt1Idd+8zMhY8qImRbJOf8uGBFZB9tQMFKrdALRAWY9EpSZ1seaz5SHw/QV/TkUBoLjsla\n", + "oLcNIaLSU2lGHytxZ6agcsUdFte40DbOcZ5SBBQiT4pC9brSctjHSISgpOcmIhileDIV348+6I+T\n", + "MsQAACAASURBVIj5XIWa9IBRagUwMv5dCBUwwfcm4gVV0Gha5BPQst7VMs5FacykoJaEqgLNRVZG\n", + "XbTpgF0RiHmerxc35n5bkrzAPrNCAfJvTZTA9ygKXag49JwkhqzgviVRAbvLEu9PHcD3uVALp6dB\n", + "S7mzcanYNpufrJznaOjC7s1mqFiwEGqDNGIqlVcT9LGK+LhVsnD/l3PXb1IioO3PQrOzlB5bfl3s\n", + "izr+SB9VtZAsKAUF/xPc/4n4/TSqbH8Zk9NwnqWaU+ol0KZMDqipYzM94zQBAWN2Z8dptMKxOvE2\n", + "sSz8vax40eKz4yAyH/ddZmAzFnw/h87g+CitC5FXyD2cYEnuUwnicR2nCa51IjIHitYzzE/tpvTr\n", + "c9y+OZ9oIWsmCqmwvKBvpPFaoEDpT2Tm3k+L9vpcy8SeTO4Jxc5XLl8uth0eovDtSJKn0BYdLUKO\n", + "OT4pCQWFdj+DK/r82JMj6Hu32fHnMAX76nvEcx6M/NnJotK1itBt6NvqlcXxsTwnUWc0Hq99xueO\n", + "PtfoO7Xiys7rk25CCYrSaPR003Gav4+zePGsEwnGeUlWpC9zeZ4v0f/OK0w/ScTbLXv/V6Uf+SI1\n", + "m83sU5/6lP3yL/+y/cIv/IKZBRTqwYMHtr+/b/fv3y80SlevXrXbt28Xv71z545dvXr13P3eeuuR\n", + "GbJsupt1a+2vW/nHiBEjRowYMWL8uOO/fP3r9rWv/72ZrWYfnhfv+yKV57n96q/+qr3yyiv2a7/2\n", + "a8X2T37yk/aVr3zFPvvZz9pXvvKV4gXrk5/8pP3SL/2S/fqv/7rdvXvXvv/979vHPvaxc/f9wQ8/\n", + "W9RjMzOrYzW5XBFHByRCxYkl/J2LAD2FOy2tEcy81lh3w4XaG206n+MNdiaOzVjVrtTQStfT2r1e\n", + "0HpdtyzzbeVy6T2fukCbddo05ZTfT2QFV9g6qMEq0s7HJV/BUYw4FOTmvJRYAgsUxaqFQw/iyDv3\n", + "vV7hEKu5dstXUFxp6Crdr09QAiIcIkBm2reKnfmbOsSB6nrNmlxqYcA4Pva6Zh3U9VI04eQkfK5o\n", + "Cmtyjcd+jClTjPF/HTDniQ6JSGi9NIrIVYBehbA1XXHEBUohiFwV972BVXey4TshIpEJIjgAEqVi\n", + "U6Ywa72yHIsUXf1xVal1tZh2Pi7TMVlF50xKUCdifE8QhBQu462695My2mcxU5S0uLJiW60S+hMF\n", + "wFNd/c8hcJVrYB9a0fAX/ViQNgpwZUyOgLrO5RjlMs4T844igvy+zglbcMCfnZMUoe1/ehZQBHX7\n", + "X6DdtU5hG6JlrbVGFJcASy73iy7SOq6qEGqPJ44+NJtPh2td+JywBHJQ7ToiSNuPo0NHPW7dedvM\n", + "zDba4dzSqo7rogCjny9v7NTbZIlqEyVJHtq+EhbV9++9U2yjy/nRsTuVs5LClavXzcysK2gJ5y5F\n", + "pM94PwVNzpHEMpNKERuw6WgIwtUo0uR9nBJtYaq/VkJgu+vcTaRfv0ekSSsQEB3b23PkiqLsodg0\n", + "zDCMduHs/eCBi9jv3nuI6/I+XMFcozUkKziXuSLshXhc6gqC7VnIGGfVAJ3jiSxxfl61Pwj9oyb9\n", + "n/dppSYhfqSbyDCtzLu0DpJzHw34PAvfq4sTPbviamWL9bqurFRSEfSxQRsfQYk5jfz0a6/ZT7/2\n", + "mpmFxLPf+X/+X/th8b4vUn/7t39rf/iHf2gf+tCH7DXs8Atf+IL91m/9ln3605+23//937cbN27Y\n", + "H//xH5uZ2SuvvGKf/vSn7ZVXXrEsy+z3fu/33pf2ixEjRowYMWLE+EmO932R+tmf/dkVLlTjL//y\n", + "L8/d/rnPfc4+97nP/cgDN5qZjXpSwwzoUzIWQ0S8fWpaKzVHWUNq3ZUDX1yWy6lCD9CSKuFMxadx\n", + "pBpIcgWtr7BcdZQEfeAb9iJ3VIFIVGkFOQr7Sc/hVplKqRXH03NMPZkKrlqFZZHW69uIEtVEjzVK\n", + "hzg3rYkW2oIolSI9TaBOC0H6zk7DKlX5aSICJYFfsjJ1U5Jqj2Okso0I2EhW8+TIeS6qKRpC50TD\n", + "QT2+6qa46itJ/Tem/aaybTSg6eS6RogrUjWwLCwpxBCPtcbUTJZ6KNWNsGbiXEwiC+O6FZsGpvMv\n", + "sC8//ibQj4m0Vx/nonWwaOaYrPTdsL+emEmyPzdlRU4dFLvCiqkd2ma4Yn4Z2q4h1iHVCmxCZAU7\n", + "nqGGl/STKvrfSvp5FvZ3cnyCfYmtAFarWn+wZOtaNmoqFlITkG1REd3ISS+MCSJNZmZnqNPHVHdF\n", + "GhboQ7qPK7uhL9YbrjPKgL70Tt3Ukjqbupj5jqBX0VRqruYVpa1t4jc4l6mgGsQttrZcD0Xj3t29\n", + "K8W2BAbDqay+ORb6Dz0BKLcwJjY3vU8MoM05A6o9FZ1NCt1QooggELvFXI1GoXNJvE9s7AY7he6m\n", + "10TlOG03vT8RJXlw/344vrRNHUhHd8Pbn213KEarRDjUkJP72VCdL5CIuSCRy8JMOHymfbJALs8x\n", + "aFSUsA2UXGu4sU9q/b1WC88uGTv1BvtYE/tyRO4RErvuoG3MzEZAffcuuXPqFmwntjZ3i22cJxTN\n", + "5xyn8zktWFQHxucSbQUUQaJuLZE2YVuo0Slry2o9ywnaeiJ9vJh3BLnt9UJf7EAbpjZBrB2qJsVE\n", + "rtROBl3denOfE8cjMGEreixq4/y3qnU+L2KJmBgxYsSIESNGjAtGfJGKESNGjBgxYsS4YDyxWnvL\n", + "LLFBLjV3loAR5wIP9gLEVm2IsDwFtSdu43QRrgmNVwWkOs/FgXxa2EKHfcnVZ3R4FWqJlE4itda0\n", + "xhijBrGfZgTTlVodkEmbkFpKpV4caZ+ppGEWomh1py5SPSWtHx+vpHzi3CtlEZsn4TwJz6qwt4zj\n", + "lxv6fdg1yLWSRlNR8iZg9rE64XK/ogom9afCSqasVpGGrsLqJgSTI0mhJwSr1Bb3t1w4FEsaU9Nv\n", + "3b13ndrjvwrP++/EpgN/LqT93dHav0cxrLYTqVx14GUCQp/XINRaHwJLpX3SKmjZkkPNtKJQsT2h\n", + "b21r2lMofcm0X94HJimEcwvf29xyC5EKxPHthvfrrU44l96R1+RrQgC/nDhkXy6FY03EuoGQPimm\n", + "kkn9SbTTQi0xcAuHst8qzkWrEqQl1jXzbZQPTBbaTqgxCRp9sWLXEb7XEMf4Wg00ttI9oBaaFb+v\n", + "p8chUaJ71em2CSo5sG+aeb+brYiXwznU6hBHV/x+LSFPWIgAvtUALT/zbWUIype5OkuHvytNv8bD\n", + "O0HkTddtM7PN7fDb036gyrQPZcOwrdyW2nAYT2nZr2sBmjPdFAF0GfXnZI7to44gkw7MvD4cabTh\n", + "2Cm7wRB1PYVuZ9/lvTEzyyDiP+u5/QWH/1ykInMkm0xk7mCnyTA/H2ttSojtO22n24p7eE79U6WK\n", + "KeLWkmqHh6Gdul3fXwu0YHczJErt7Ttld2kv3JuDAxegs+5nVygzUsblslJS4dyrQlORWlX3dM77\n", + "Kgvhs4qJDWKiX1gDTEXYz4SOWk1tYsK/CxF209Fc78lyykQBfxby3I8hAVD7k+J3KzIkuq37limk\n", + "AlrrcjgMc5bKNwaQlGSSUKYJCudFRKRixIgRI0aMGDEuGE8MkRqPhjaeqjgRot+K1KZCPa1c3iCb\n", + "qCafNFVEiUr3Itgj6qN16GiSyYrrWi+OKe4rtfEgNtSUaCIcVXnT1rRXRiEszUTEiDdmHkPRkgIJ\n", + "kTd9Vvo+34xMUkMhylNEiqnzan9A88E6VmuptOuUhnxyfKIqC3lbZzvpORFNUXEgkT1FmHi9Kp6m\n", + "sJApxCpipLC4LoJZms9VzjHQGwzE1A/RXlmlhbY4PXWxYbPYHyuIi2ARK63zxOF9qT82m6+LUile\n", + "pzVDOAZWblNZ/aDtap2wmh+J6PIEBpYTSY3Ppuh/Tb+vQ/Q17ZMUVmpa/clpQEmyy/69IWrBcR9T\n", + "SWGvAkHY3nBxMKvaNzTVGYjs5es3/XsQD58cuij28a3vmpnZrOfHaLcC2jXG8Ss1H0uDMUwypV7Z\n", + "Bs8lXzffq0pSQgqkYWHeJwiENAVhagHZpFB1Iegni0d2W/591ikrSf/n/DMTYW27G/oVzXLNzGaY\n", + "T9TOZVkKK11FBFLU/cTC3PKpj/WtArmQ2nCwjlFBLG1kSqnfp/Ek3P/yUhBWjDHWsDMze/GFF83M\n", + "7PadN8PvBGmp4horbRkTOc5F5preURA0b7S87ySFSbG3J4X3xz0XQG9sBSSuizp0iiAcow8/eOT9\n", + "ahc1AVNhDjg/bYqw3REWv3dMma+1vO2YKJIB9VCrhTGQ0EzYhK3tHezLx9qkMK4sNhXovPYxPp/0\n", + "twPW+MSx1EKAfX17wxEsPlfKkhSVY3yMxyK2xzFWEjXOSYYqEnBkW0aDYTzPxmoIXBgtK0uSYh9S\n", + "/5E2Meo0QHZGUPrJlDYtPp9WcMtOTwI6ORj4nOC1Fn3HfD5URNjP54SiWadIqNLkJdYsrVYVOfZz\n", + "OS8iIhUjRowYMWLEiHHBiC9SMWLEiBEjRowYF4wnRu3NTueWTwQ8rMOfR5yI0xpqPo0d2h0AFu2Y\n", + "CAtZw0nU3hQlqysyxc7uQSHCdnpGiWcMP1W6rw76pF53cSRFhCpUplePQqeEVt8rOtff1kSI6m7L\n", + "4iNFt2n5LcWWJXUxZ02yc9zGeTVKsdF1V72A6PorTIB7UMnx+XGrKQ7AoLvU24lRF6E4hdpFHSa5\n", + "1hKE8hW5rqyoF6ciTgohN2Vb2G+j4SJBirYz8XYhVUl6Vr3ASKkt5b6Sbmw2/RqOATePBR6meFJ9\n", + "nJzS9b7bhz8KHaa1/iG9uGrSrsuiT6hjPN3O/dxJBygt0jsLlEGv6eJd0ut9CIu1v7Dvam1C9n/1\n", + "YBvCe2wq/jRV0DeX9p/236KNB0J3Dc7Cb6aPH4T/Tx2yZ8JEvvSbMuJcIP2PrMBcKDD2olxuaIp5\n", + "YkMSVVjjjP1uKk7kS1Q+6LT9Xrdw30cDv9ekzDPxjKJgvJL5tiVqEVaqTvdmtUBj1UTMSr+d0jwc\n", + "Q32UZqDRmrWWbMPVytyRsK6YzH8Z+t107H5X2ztByHx49KDY1kNf4Jx4R8p+bcBte8UJmjSjdMDZ\n", + "GM7SI+9/OeiRujjgk/reFVE6Re6cY2pVb/+jw++FzxKd/8K4n4nYvgoaTZNSfPyLVx89/caaAILE\n", + "I7Th9rZ7VtF3Tft/QTNJY3MeVxH5yckR9uF9rA0fKaVlSV/dv/du2CDzXxc+Spd2fFy14It1cHBY\n", + "bDtCDcUVd3Jw20ptcS7S6ymV1hNuang+F3Tjihcahd3+OwrKxwOnMed4/rWk1iC95bTWHR8BKktZ\n", + "LsN+WqDZJ5JsMplQMC/vDniOD099Pnn0OAj09XnagVSg0/F7zGe37k+rFpwXEZGKESNGjBgxYsS4\n", + "YDwxRKpcq1pr6W+cREQWUpm5DFfcRER0KYSVmYgzqWdWcVwJv80EpaLYmajTefXidC8UICey+iHS\n", + "oSK2KVb1ilzxe3qMwsW6QKTEVuEcETuFzwtBzigsVwE0d6P137ISanLlmhIaYgyh9OBU0tUh1NXU\n", + "+A7dzhWRQmPnK/XXUFdPa21hRZImgrBgRVSRNOUSjsdDzAX9mcJZNlOkBSunhaYk08VaxIF0p+31\n", + "HH0hcqerVHfAhTh5sZ7CXBHB/ISIiNxrCqVV7M5rpJjbzOwAAtxc0r+5G/aTLRF2c0WulhxczauL\n", + "7wR173SluQQiosJSpumfnTlydIpUbNYhLOlqlQJ86X+sIVeVBIud9g7OU9oJh+0duot2DQLdtqTa\n", + "b2wGRIJC8cP7j4vPDg/uhN9JUsicbSKrVToQ5wtBX5es9Sh2BphvenNfpbaBLPNel+RYrOfVEKuH\n", + "8Rw2FWJ/kaLf63jevbJvZmatujuQ2zli56efecbMzMo1RcnCv8uzdWd/zntLSeuvAC3IS97/KYZX\n", + "B+6EY1ZQYrp4NwW5nS7DPRtD9DuGm7aZWb4IfUgdy1nXcSLoa2c7IDGLzPspe3Ga+Bi7Bjf2nojd\n", + "R1MmeYTfXtpztOD5Z583M7M33/7nYtsQyQiX968X25iMoBYvBKI1rZ71TMuCHHJuJ4I1Lfs+mk3W\n", + "9VS7hNCu2q9p59KX6+oP1oXNHdR/1XFK5//2RjjWios35rBbd31cfeTDHw7n1vJ7eHwcjjsc+LWy\n", + "rp/axGQboa0rYpPAuZCVLczMev2AcM1QeaTb8WttN3Ce5sL2Hp4tDx440slnR3/o46/6HkYi7Bv7\n", + "k2fXYkF7ElgjqLAdv+6f+fnyb60cyqlA24lIsM5xUzx3q6kivPa+ERGpGDFixIgRI0aMC0Z8kYoR\n", + "I0aMGDFixLhgPDFqb3N3pyi2aWbW7we4s3/m8ODRNPxdTlVYCspIRKSEPlNx8abIuCzbWECSzq7l\n", + "yjrtpgI3UlFK95BuUcEaaRal9gijqtiXIkZSe4LYWhVeNCpsLoTn4rFBl+flOZRdvuLAC2f3scO4\n", + "FJInZTpWS+FVwP3Dobf/EJTF9rbTE2xXpZYeHwR35FpZfZTCOe9duuwnyPtU1W4XzpP+KOot5gp0\n", + "b3/C7Sp2J82pDuS8Dk0KaJDGkXYawQ+FcHut5n2CLrrqRM7vqds4XXyVxh0DAl+heymeF1FyCXTX\n", + "ZLpejJmiR/WY4WXrtdIBX6klipyn4gF0ehyoFy0QOgRVsAnKYiptwwKhza4XeW2gT27uuNt5FRRY\n", + "R+g+ik3zhcPoRweBjhj0XOy82Q6f78JNe++S0zOPjq6ZmVn/sVBLTDKQ/t+DG/ti5vdkgX61VLd5\n", + "tHFFncVB5ZHSngvE3wBVrPeQc0hdvJBaaKeGJAU8/cxL4TxkmJJGroksobMR3KtbIjYnHbWoh3tS\n", + "ke/TFX3eFQoY/aOkHDivQ6QSrGxgo4Ni2wMkCFSl309AUVNEvb/jztqep6OO/XAAh++UmVkN8+im\n", + "jn/8dks8kPoQ+0uOUeFUzzlUxfaXr4RzmQg9d/9hEBEfHDiN1O363MZoQuSstBzdyHuSPLCzE+4J\n", + "pR3q7UYncPUs4qOoUhNvN1BrR0dOo/fh1VcXGpdSjpVi7WV4qlW9nRiPHoVrXSx8nn7zzdDubSnG\n", + "zJ6wkOQJw/MuEwd++saNpy5L4G+GY992egaalxUbzIshT5YYV5n3Uwq1d3Z2ZRs8A0XYzr5dEUkJ\n", + "5R2avEXZwnKBZ3hVMSAk8ci82kFb6POcvlAr/lh8JkoCEvtpplVB9GF9TkREKkaMGDFixIgR44Lx\n", + "xBApyzK7tOurqhZSl+/dvlNs6z1GrTFZfbQaeOuVN3gKTxV9aGJ1qKgT35Ip7NY6SBSg6xssEQb5\n", + "WvF5RVIjqRg+z4Fc36oprCMitZJWDkHpbKpO6PidIB0ZVmmJoBTFOcvdpCh6JA6wza2w0mL9o0Rc\n", + "pJl+qg7LA4g4K2fe1qznptdFwfLe888V21i7T529j7H6LZ+zSmgkWKVJHSouDRK5sPeievq3tv4Q\n", + "yI6uHGeo4zgeq9v9qgOuurPTdVzRvx6E5bpCSeHiO9Q0dSKH8r3pBMiRCKC5iGJfG664s6PWnPST\n", + "bhfiTLW/wD2Zz13su6xRbO/bTiF8PT6RNPFmOIFhFs59Q4SYG1jVp9L/ulthzDZbvlpu8x6rTcQS\n", + "Lu5l7eNAM0cuwB2jf/azcE9q7avFZ60WUrMnl4ptlQprTUpSgIVVel9S7SdAHaYTaf8Z7SzWBdBs\n", + "TxWVtoD+qDi1WgtfaNUdkWtCeLu/7+e5iZX44aGnpE/OsRhJkSCSiO0KQJoCOVULjwToX2VLaqNB\n", + "FD6bOvqRsa6jSVLMHGJcQQ42MSe8+b3vFtuOT8J+WLEguyx2AUSM547S5Eu448vYWQL92dT1P0S8\n", + "zaYjB/fuhvHOOohmXju1QKTEnb+7Gfrk0yKYn2CsHZ840kbbFU0UKqONNZX96CBc60zG+MFB+Htv\n", + "L6Bfijb0++F8dV4Z4LpVWM4xeyKC7eU8tEVD7B9OUJNRk2xYIYEVA7QSA+epicxhX/va18zM7OWX\n", + "Xi62TZg8M1+3MljmMv9hvtc6tby0etURrk4b8zTsPzKp/8h6gUndW6pSCfdwc9P3yxqDq3ZCvFZv\n", + "E8Ke45H3pxGed5z/O2IrwWuYyZxApCmV/sfn5CrShRq3WhMR7a8VCFZ8lM6JiEjFiBEjRowYMWJc\n", + "MOKLVIwYMWLEiBEjxgXjiVF7k5nZfO5wWbMeYEQVQM/zACMPBDKmO28qnkldCC/b4k7agkC2fA5V\n", + "V3jGqOoMkQvESwfslhTepGA0EQ6ALMuKKzd9oYQqe68ofSrC6sUi0Gw1gZ2Hw0AFTFQcCfhytlCH\n", + "DIi4VSiP62jK/gg3L2YQogvEWYYAf0OEoCNAqwrZ948CjaLOspVyDecmyloWfE5829ZOEK1rwckJ\n", + "6K5OK9BDiTh/9OB3VG04PUgn3JkWCAWNN1+BZ0FfCrTbhyh5MnYIOO2y4CXpsXWxv3q8lAG3K9K7\n", + "xG/6IkqtgTZdSJuc4D4OBbKmy3sL9JEWHu3B70uhcF6DUoZ9tKcKVgcQrB6K23gfBUx7R05B0FOL\n", + "0HpdHLO73dDuWrAzx9qrJEWzS/QME8qKwt5sKL5MGQppL73fz/qBjjk7CP1q2BN4HnR3ljrFsEzC\n", + "+ZYqQg9DKJ+d+XXNl4FGWAjcT5HxwYnTLZdeCRQdBet1cZiegoqbzpwC72wGKqxUlmKsLEYr9+T0\n", + "JNAxSuMysWAgRXBnGIMDoYUpfKd4PSmLn00ZnlEydecQvmfiBZTQPV/6aaWBAtGn7lR+7074ezzz\n", + "Lz5+DC8vGMgNJAGCXmnVw0fFtpOj0NYjmafmZ2Hb7X/+VrFtE6L8gXhgcciWU5dlcB4lZX0q/kCb\n", + "8KfqdPz7N24EL67Fm0KZgwKrrCQUce72vsMi6EOZi5ncQd+jpy5fKz47PAptc3ri44pzx2Dg/Y+U\n", + "3nDg93UTfefg0EXxJ29BFrHnx7j53E1cd6D9Dg/dW419TSUrpODf+sFbfq2gNjuSADGfsE3EKw70\n", + "1VIehs12aGNNiuCzs1sUDfe2boNu1nmK858+42ZNfubzCT3A8pKPU47Bjjx3a/RUxHyaibSG1F5V\n", + "nnWkdlW+w4LTep4J+lpNxO7nsXjLc94VNCIiFSNGjBgxYsSIccF4YohUmlVtsZR0SbwFdptbxbbF\n", + "FKuvpQs2KxbedLe3XezJ1OnNDUekWBNMURqKF4lSTEXETtsBdQImItEUJ+zZfF1sTfH2WGoCunjc\n", + "37S50iFapTXnFuekfLJi2FQsFCZI10/yta/ZSNJV6xAP6ps267h1kRqq1gx58ZbuO97ZCm1cveqr\n", + "mlOIl999951iW4YVxL2HvtJ64dlQCyoRm4ounHpLYmfxzruhntQZVni6WhiNQ1tXGt4mYyBY04m3\n", + "a69HhGt9KbFqSRHaRJFDChopRC7J+brFgIgopT8V32Naraz0auXQZiqKZl03vcfsJ6zrV84U1Vlf\n", + "6dHqQZHTElbYar9A5PLszIWqFPsP+lKnCqv+0t37Zmb28ksf8AvDCl77VRko7bEgXRTWX7lypdg2\n", + "X8BWou9p2hudgEgmsko8HoeV+z0IVi9f83RpriobDbH/wDnlqSNnRCTLqdYk5HhylITt2BIH6lMi\n", + "B0BdFRHsYmXeajkiyrkjERd3Jpso+sz7NJur2L6GY4h4m1Yok3MEwEDV88yvy0qcw3QNTKsD2cb6\n", + "hCsTRdh2Ksjd3du3zMzswUO3pOifIP0elgjHksL/7jsYr1IxgONP0T+K2I8fuwP3tB+u69Ghi8K7\n", + "nfC9ckXQ1GGYl3Yuh/lHEewTWJJovbwa0Ilr1x3VYV27dsvvdR3tqnMS79lTW1vy23CMR0Dmdjbd\n", + "/oXzjtqK0Dxd0afpBLVOpVIAUfSxINxElqtSY5PPqe2t8FxTwfgQiRrDoc/dbSB92v+qlfBsSSWt\n", + "n+M0l/mE3TMVhGsTqJPWc2Xy0hGSJ+pidcJ7/eCB32vOGSoYN8xTXbFTYZ/NTRJ6UIuzIwL0jAhj\n", + "E7YmgvSzhp+OtVYj/HalTiqum6i+mVfo2BDxeq0e2l/7XelHWJtHRCpGjBgxYsSIEeOCEV+kYsSI\n", + "ESNGjBgxLhhPzkeqNFspqJvPAgRXFcfgnc3wdykVZ99FgPj2xG13uwt/JHHMzgGHajHCFNA/gc1E\n", + "9drnBIXHKg4mPFoRUSrFi7UVaDXAg+f6eFDgJuI4+tgonEhHdTUxT3A9ZYGMKSxXCtAAs1/e3y82\n", + "0TPpDL4kG5su5psDblYq6Pq1p8J5yrXuXQrtviE0KqmCW3ddxEr4OJPzJGT7SJyqWfA3By2WlfxY\n", + "ORR+t4RGLLxdxEfmvOSBskDlxTZc/2jkdBOpNcLpR8dOcTQAX69QqywaLcLiOqD1dkPoJgjaj49E\n", + "WIvzbAndQOp5uVyH3d97fWYCzwvsTgpQXeHpcnzjxtPFtu3tME4eP3RqZQYXY3qwnfacRh+N4CMl\n", + "95AC4Ik4JvO61AG/8NGS7y3m8Hariy8T2uzNdwIt8PSL/7H4rNImZSGUXUbPMKfFpyMULU783Eso\n", + "Vq4UKMdpRWikCUTe9AzbEEfsFDSaUqbddmjDriRlsE2OD53uothe2eYaqGWtwEC6YWPTj0t6dzKE\n", + "Y35bxObGfi2TwnkFigtKb32tPJWx8a3v/JOZmZ3JvEPxdGMWxuJ86ZTVcBbaqfnQx+nlS2GO6W46\n", + "LdtqISlA3LZv3wvzw/fedlH0f/hgC5fg17gBUTZ9x2pCI927F3wGdQzv7wf39A2hjBIkuYykaHgP\n", + "NK7ODR/96EfNbNWBnmNrjPv61ltvF5814aPUbPj9z9Iw7jT/ZwCa70xc/Onp1umcN/79BDgH8zym\n", + "UqB3iTlRXcwZlU2/rlYt0NFt6acJEjSGUjQ4g9i8XvPxRI9EpRunNXFIt1XJzBB9ZywSAM71mtC0\n", + "sxOoylbHz2kDflPf+u//1feNLqvzbrUUxkSD93gmXlB4dmhiQYZxNTnHM2oloasX+tFMyxsv6QAA\n", + "IABJREFUiltTyK8z8VgSic6LiEjFiBEjRowYMWJcMJ4YInX7zm3b3RJ32MJh1d+CKZirNfxNs2Xh\n", + "TbvTdAFoHW+QihJQHFcWAfAUyBLfTMslf6teonaUomSsp7Zc+vEpIlWxHS0RUnmD95pokqYNUTpr\n", + "4ukbb4GqyDXMUItQkYYcLsYKv/AXW931VW2lvG6/QOsIRcvmSGHXlQ5rDc2k1t0AtRC1/lUlDefy\n", + "zDWvk9bHm3635StH3p9Rfyi/DW1WB+qwXHGHx8q4KUgPRLlLSaHPUGNMbQq4OlJRKms9lSV1nq2Y\n", + "Ia241ZK6ckBpTuYutq01wz40rXcMm4qZ2CqwPbX+WqmEVbrcuwnuZwmoR//UhcAUNnMVbGY2RD09\n", + "TRToQfhbEZsCwpht+S1XaVrrjPtZ0HW6Jv0FK+FU6lqxy6SCCFKoPxFLCo4tFe+zjVNJ50+BTr38\n", + "wY+F3zUcJa2gTzRkBUu0ZCTi7AWXsHJfF0jdnwkixjqGOnZZR43zTpr6vZnNx9i2nrCh9Q/5i7ls\n", + "MyRWVHK/ftqP5CIAp8i9K9YttBZZApFOBMGqNOls79vyhJYUfu+KzxSlwplefcorELz20f/DzMz+\n", + "6Z/+3k8d6BgR8flcxhrapy2p6Zf2gxu99mvOZ2WZz4liv/TCK74/urYn2u7h+t99NyBXisi34ai/\n", + "u+Mu8rwDWg6NyKKKjZtIu683fIwT9f7Od75dbNuFK/0GkhJmNXHRxxw6Ehd9JiVdvep1BYmOKHJe\n", + "Ql695hMxQWNHalcyKYLWJCv1QomgC0p6BvRH57q09MMTUDJ57LMmXa22brtz+6EzDFPUsdzdDW3T\n", + "kHNivx/2fF4/eBzQ4Wdv3iy2XdoObEK6kqgxX7v+Xp+CekeBpikabYhKAPLwbEMcrs//WWGX4DBh\n", + "usSYEauPDPPTgwf3/Lfo72qxUy1Lwsc5ERGpGDFixIgRI0aMC0Z8kYoRI0aMGDFixLhgPDFq7+GD\n", + "Y5sNHOPM6hCTSfHENiiduoi4d7sBApyLP8xisQ63s5Bxte6/paCYdINC9oRTtXgl+bmWCPEKXyBR\n", + "J5YgXlWqjih3tSy0yDz8TapsMXHYccCCl+qYDQGiCuEoTq2KAJxUxf5lh5YpFDyWIsBnRwFupbfK\n", + "UgR7HThrd0WATmj54UMXh1MAeSL7JaRfqymNFa718SN35WUD5dJ2pEUJ46o7+Xt+Zmbu+6PO8qQq\n", + "le4ipJuJLxPpBi34aQ060INGkgKx9BvRflIqxKFyo3LcT6EW6e2iHlDT6RjXqN5G+Azn1BBvsSxd\n", + "p8dYBFRpNJ6nHouUEYXoZk7BKSxPOpBO2FN10Ue/U3raXbz9Pm1uBbpF7xPvo/piLXMmavjx661A\n", + "wexeDaL4ilx/rTh3pcfD9Y+mLuz281QaI5zNyYkLa+eg1o4loYD9iFSMJluQUqlLv+Y9UWplhnF0\n", + "Ir9t74TraghlUiG1KRIAFlInjWfmVAm9yDK5LvJcee59bQFRdCLFiI33TChAekrRYd3M7D/89H8K\n", + "HyU+dh7BZb5eDfdV6SHONdvbLiznGFNalGLjXETUGc5p/5InCnEAKAVDCorFk6cyT/J+aQIQkxzq\n", + "Qkt7oohLEO7eD15p14S+P+uHfrRzyX2kmPjB+SKXsc6kBBVbs/8dibdahja+JnIHJj5osgmlFDru\n", + "OceyrfX7vBc6/5Ke03mC428p/YT3oiHUNqlfnXfpo8Q5zMzs0ePQju/eeiech9CIW6BsHz1yt3sm\n", + "Mm3viAcXKzvcd78pPjsakmS2rIb2PHzo++Nz7+BReBZpZRPOe/pMoLcjqVAz97RqyJzIe3d6LAWv\n", + "i+Q2789ZeT1pTCMiUjFixIgRI0aMGBeMJ2d/sCyv1CarzMLKse8LM3uEFeS1q+5Yu18N4jytP5RQ\n", + "2CjC6pT1qmrrq2+uzHRVz7f5zaa/hbP+1nlu5yNBP+ZTrohFAI5zn878TX+IOlUTIBNLWQXwl6ms\n", + "FgvBuCAiFQgmtwQ5SkrrzsoU0Y5kRdaByLgMFGgpd/8SbAXu3BUnYgh6z0599c+3/005Puvz3b59\n", + "p9i2BDozFfSlipXQWFCPHPduXqz+fAVLh+femaMKRFM0/b8LV9rRSJyFcW8nWtcMx61UvY1ZT/AU\n", + "lhBEXMz8fmm6bLPcxO+873Llqu1P5+9U0ByeS0lWsw+B2LE92y3vr/1+OCcVrCYQTJbUsR3Xs2KT\n", + "gc+JDJi5PYem8hbnglX3VETcvH5F9SjeFfChQL80Tf0hVv9tSRRYLmEJIohkrRmuu9II55QJgnOG\n", + "/babvt6bjlBrUly0uZoey3iewvm4P5TUfaCeS0EOOe6Xy3DcqoijT0/XXbQL1E/anzU5NQGB6Etf\n", + "nN2r1XVnfYqih9LHWQut3GVxMrUEAYKY+3WlsEJYzGVb2VfdxW9pgC7bvvVP3zCz1fbstoNQnn18\n", + "c8PnRCIMilIRHVf0owaEV8czkbaFIOwp2l/rqZ6iFh8ZBEX/aDtDKwEzswHnaTnW8VFAHSuZ38/d\n", + "3TDHHZ86mtMfhvGhbULkqLhfAkZwnOo9ZJ9Q9JdjRpFr2q9UBJFst/kbSUDBs4UI/1LGy3AW2klZ\n", + "Cvb/uWwjOq5VOZjW3x9oAhBrjPoxRvi8KkhsFwkfR8ehj/XE2X6Ie7GQOfn+/VDlQqt9vPpKqJow\n", + "Gvmc1EfyUqvjyWNFO2n9O4yxh4/Cfh888CoaRJ9UsN7B/k7l2bW9FfrudOrPXd6fjU2vytA4JwFi\n", + "kUREKkaMGDFixIgR418lnhgiVV+4kZ2ZoyTTXFMYw78lOc1FAk7zVPhorFh2t/xNvzC9EykLVw58\n", + "W1denqvOstZa02U3zwlv/Zr+PyrqdPl5EulQM0UiYFwRK89OPnwiiMAEteZ0pVVuZGu/JTpzKiut\n", + "Qksk11PhKgkrHEXwuArqC4LBGmbKvfdQ4VyPb3hbn2n1d9o5yKt6H8Ztuppd4r4vptBvCCJEBCuT\n", + "2nBcTRAtMTPbQa1Fq0mqfYGieAfowMxN0Zzjk7Ca4gq3WhGNGNAUrc00wgprIEjDECu4nV3XjYzR\n", + "drr65OpMHR4q0ND10J+1NhUXibksidkmzbpy/2LEinCkRRAB1p+TbfybKNVG16+fyGF7pYYhtIRS\n", + "p5L3WDWKrCN5cODag1brKXxf0BwgsNQNVQQR+u73vmdmZh945eViG+tpKZrLepY9WWmPiUTm63o8\n", + "1ZLxXNifWaPNzOzGjWfCZ6LH4Jzw6LHrN3ag0dmUem2sBaa6rcEgtLEaF165FtD2uYyn8VkYuw0g\n", + "QYloxCi+XAjSmpQwn2S+qn+/OJJzT0uh7dR2hufOe6jXeuVqWLmrTQgRnH7f+wTvUyoTwAD9tN/3\n", + "ubsN9CtV02Wizuh3ir5w7qycY7g7FFSLz5bGtiOiN5951szMvvPPbxTbCh2k6GtoMDybhvPcV1Nj\n", + "mKrqnPgIuh1Nyec1JIpI45zKMk9S/6TPCSIi1OMqgloDSqY1BIlIKfpCPVJP5imiyQOZY7rdDvbh\n", + "50QEXpmIDGjO3nbQ4VYzR47v3wvo82LpDdDGPJIKIvj228HYdLbw+bxWDtdx977bD1Bfpfd4AANW\n", + "PjtefPElPzfM9aqHsqImpm85rz9xTpyXRPOMMa56zXrN2/u8iIhUjBgxYsSIESPGBSO+SMWIESNG\n", + "jBgxYlwwnhi1162XbCEi1noXQuSBiHhRV0pr2C1BQY0kSz4rBwhyd9OhdQrQ6FhuZjaZLLGNNYzE\n", + "VgAQ7EjogUUh4nPYky7jmmpPkanSWIR+Nf2b6cGEIjc7TqNUAUtORJxHWHYi4mAKlvsi9iMEz1pi\n", + "Zi7AzkS8ToiYQsEzcdHmNoWsSfsMVZyMz+dSWIrCv+lEaCRAxZnYP7DNlG5ygSbciQV2JSq7KXXI\n", + "hqDMOm2nMUhLKS3KOokHj52qGaEm27ZQMC045Jfgtqv2B0VqrEDcXHuUhO6h7cRA+g77rMLTrM+m\n", + "7u0zUJWs+fbo0KkwUlBKhZKe0jR9pvPqvWPb9YSWJN2odC9/w/ugomNej15DHWLwiVDb7JNaG4sO\n", + "yI/uuXXGnE7dU60JF860Xl+nTNqtDs7DqQj2nbHQOKTMRzJ2aPuh1BLpez0GKT0mClSkrh/PSVPD\n", + "T0DBDgY+dth2TaFbSKOoJUgfv1mhpXA9o77fz50t9PcSv+fHz0HzJcoPwz19KfX3Svx4XZ1g47H3\n", + "U8oSTkQWsIG5o4k20cSS8yxBKD1QSxbOrZqAQep/c+MZ2Ra+Nxj6OXXa3dVtVXGsR//UMbEH6k2T\n", + "UiheT0Uq8Ajz1KNDr8nIPvH0FRcb37z5vJmZ3bl7B9fnbb2FuWNlTIBmVxH3Kawb1GqCjvHaT4qE\n", + "J7mfpJs5/tSJf4wxpjKKMZJsMrnWdM6/da5Bn5Rn0qO7oU1aLZn38MzUufDddwItxzlW3dY7W6F/\n", + "LMzbhC72LamrmaahnxxKrVUOreeec7d7UtU6F5XPwr6vXAlU+Oqzm3IDeXYktOSRdwfcR3Vx3wRl\n", + "OZbkISbcDCY+x+QyBs+LiEjFiBEjRowYMWJcMJ4YIrVxZcvSlh8+q9BUUeuAhbfAmYi+KYCVl89C\n", + "WKgiWqIfcxHF8i2VNgiZVrBmGry8mY6AuqSyrOMKVlcpRB905UpDTH375d/8XklXddhdKoL1Fuqk\n", + "VaVe4BLCTl1pVSBAPDxwS4inbwRhpYriT/qsPh5W+lxx6fU3Jf2eSr2h2ApsbnZx/VKnD+LURsPf\n", + "y3nYWs1XKdvbYTWnyBFXuBSvqmD+4cOwWmrUXdi6BzO/FZQMKI22fxnpslrpncaF9+77iogCRQql\n", + "tYYWgYttSavNgESNBX3pEx2S1T/7iRrSLQvhs4id2wnOPXToVBC8HmpX9aVaewdoQVvEvtRua6o9\n", + "j9+RtOJh0XdXfBLMzMeOCrGZVq6oTg0p1LOxIgjhXBSRI+pTFasJpjrXGj/cJPfoyNEC1i67c8ct\n", + "OWhPoaaaFMXelf5Mw0K9VKIYmdSuS4gwohGbDUcLmNgwXzGLDPf98mUXILMmpmjoCyRG244o3v6+\n", + "G+eWIHKu1TVNPbRJTjQjX19p68FoJ6Dor3cxRa7CP/t7Xqfur/8c9dRkjt27dGnlnKoyh9E4UlPt\n", + "KaheLDStHHYmalMCZKtR9zZmooYmKswwn1BkX5G5rgf0syrGzXfRPyaCUlwFwtQUO5t33w61+555\n", + "+kaxjdYhmXk/pQD56afC90qJ2l+Ef6cTn/9SIIfzqaOKlXJop+0dR/PyhIyECNCHrOco24Cs8rmi\n", + "VivpOYawtDDRpBM1zGXQEqcvtU7JLOQjnXcCctqVuaPTpcFsE9eyXi+yKVYn7Cdqa1FipxTjWFrn\n", + "ZKkY11ZDew+PXIC+jfqHfSQCqEkr6+muMgJAzv3ypY6snjsNVtetFjZr/i6itjDnRUSkYsSIESNG\n", + "jBgxLhjxRSpGjBgxYsSIEeOC8eTE5k9trgihxxDCLVKH7Cp07JZ6URQRZ+JjUQF8rmLXaUEZ+DEL\n", + "8ShEr8dH7mcyoehX9kFIW91hiZmzNpeZC4BNxJ6E9lUASB+LQqi49JNjDaNd8SKaTWYr523mPjsq\n", + "jtvbCzSDOuu+84MgDhyoiHUv0Ew9uPlq2yxzUEzi7ZXhGpOyekahTmEmdCcuUSkQCiQ7XW871kJS\n", + "nWxRJwvfLws90QLNmCVOz40Axb7z7rvFNtJXZYHMK+0AMzea4i0CaL001DqNoT89BKWUyrntXgr3\n", + "Yl/oOYo8BwOn2+i70mp7+5Oy8b5hNoA/0FVx6ifdOB6H73XkHuYLeGuJF1IN/Un7xAiUUUNrwmXr\n", + "nkkJ6BalOwvxMNZUqbiokz05lDpUw3Fv5bzD9VwN16c+TqOw34FQgDM4X2+YJw+U6K2F0+z1hMbA\n", + "uTw+cbpvOQxj4qH4Ux0dh8/f/v73i22sHqAUB2uMqdiWNBITRkYjpx3o7KyUFamqhvjK3DoO9Fha\n", + "8f6XjknZ+X1i11IH8DnOr9mV5IlpaLNOim1Cey3ZQWWcJDi95cwF8KVKoNFXROkQzM4HnjxBuq1S\n", + "8zahR98MVJD2lzHusdJTdUgQyiIs72AszJdOt02RIdQUGrPe4JzsNAq9v5b4njrLk5ZLZf49QRUB\n", + "dTHnJPOuVFvYQfUGddvegdhYveLefvOdcG7oLyr2pus25y0zs9GYPnKexHIGCqrZ9GslfaSiaF7b\n", + "SLydSHNyjJ8cu9yByRbaJqTWNImnoADFH4yJT7u7LlWgH5XSt0VSkHhbkRZMbL2yBY+fLP2eNFBP\n", + "syY+WsMBPPjm3icfHQYPqqNDp/FIgX/3je8W255+9jkzM9vZpDzE72GlcIz3a6Cw/NFjl7s8xpyx\n", + "teXn/t++8f+Zmdn+vtPdXQjl9XtpIvUuz4mISMWIESNGjBgxYlwwnhgilZWqNhv7SqtCIdpC0A+s\n", + "yOuJiFOx6liI2JtCWa2rxrpCiiYN8EY8BCKj4jy+zDclDZSpk5pqe17MsDpXASSBgMVcRYnh2iio\n", + "bosQkivD+1JDaBtv33p8Cg8p0jPzum4P5bcUo1abfk50e+b5zqWGUwoHZrVfYJp+mjuqMcNKQJ3l\n", + "uZpZSXXGqmoqYv/hOQ7wXDnxMxWi81rVVoErsZ1LLvblvV5Iumwf9zYt+4qMwt+0KjUR4Wj7FNJq\n", + "D8V+gBYDiYgTmSasiCQX/V1BFZjIMJU0ZdokaFovBZoZUsfr0id2d+k67v36MWpM6ja6IysiVKQz\n", + "C5rF9Gt19M+BiNBhej7z/jrDZwI+2m0Ie0/FAZ9CeUV/tpDCrskWt47DqvPyZRdbM3Wf44VosZnb\n", + "BQx7vt8zpK7fu+9Iww9uBfTVzkGfVZR9XrUDCpkbcFhuijvyYBDu/+mZCMHRn45PvP8T2lULgbRI\n", + "tV6vHjAeOup2ClR8Syw5Ds6Qup+i/qOgmkmKfi2C3eFx+F5WkaSALdz/TK1jQtuNZo5+vPz8i2Zm\n", + "9i1x+74MhJv3ROe1NEWijozhOj4numTmiOBY+iRFzoPhet/V8cQps8G2E1S1DISlLOOaY+hM6u8R\n", + "Wb8kruT1evjNSNq/QIcEuXvttY+amdffbLUdfTwEqqFO5EQsj469T1w5xxKF825DnklEkSpiHUGx\n", + "d4Hwy/VPpiqfDsE5VPfLbctc587QxmrJQysUdYXnPRlLkhGTMIhEKkqZsq7p2McuKwRUJFFqught\n", + "cSYIN5HF077PJxuo6/fqq68W2+qYz7LCVkiSLeasjehtyHbX5+/WNtzWBSUjm6N2CjMI2b//vbeK\n", + "bVqf9byIiFSMGDFixIgRI8YFI75IxYgRI0aMGDFiXDCeGLV3+PDAUvHiILQ5X4o47SgIAJOOC7Cr\n", + "3QDxLYUCojhPhdKEz5cLh2wpbh8CWlYRYUbIWkSchTu5FtldsvCh+J7MKA50aJHQqgoLHz0KIk8K\n", + "VtviuzHsBSiyWhbPljo9jnwfdJZWyPIEUKm6jdOV9vDUYWxCxQu0F8WXZmZnKN6rECYLmdYFxl1a\n", + "OG5dYORFUaDY247nTBrVzN1wVYDP+0NYWIWgZdASw4nD422IWN0TxCmD4dgFo4RsVexNF2fTIrQ4\n", + "5wU8a/b3vU3GhRO7tyvpRhVxn3evK6CR2uLLxd+yKKqZWb1GV3ruTwoKL0jB+n7pGHz3noszDZ4u\n", + "WgyYl90QX6SchTyr4otjQTRLuq8jlPEUnkntlvfr3UtBqPr22+8U20hpvf2OQ+GP64EqXE5V7Byu\n", + "rXfm9zMHtUd/pnmidHOC73sfPjsKHmBzuScZoPp6x6+V970sYtsahfwyJ7DLFkWuZb8UhT985EV7\n", + "KbbVQsKTorisJFtgzCwP/XoodlW6k7S0VmCgb9tiGWhc9ZujL1dJqhi8/W4Qu6v78rXrYYxfeur5\n", + "YtuUlNbcx1gDY/Jnfvpjco2hUQZIGJhOvP/VILLX4taMVLyoZpiftjZd2PzMM6HvLoVbPT4IdOOK\n", + "oDujL184ro6he5AvKLVIaUMm83Qdv6ETtpnZrR/8ANcgPkbdQKnW9l3SQTqc/lHzhYjTkXhyLDRe\n", + "F1TUaLw+17LChJ7z4wNPnuCQzWSe4vOGc8JQ6EEXVq8XbZ4JZb8FMby6zVMOoM+zcVGVwJ9nJ7Nw\n", + "bUrpcm6bTMI1KrXJ/lKWpKSCKhz790jz6v1soX26z9wothWVH4Ru7WNM9EG36rOeEoBtwYXoc6b3\n", + "5P79cB+fueHHeup6+LsqfeLunSAb0ISCcvn9X5UiIhUjRowYMWLEiHHBeGKI1PGtB5aKY2wFSEwi\n", + "abiDGVxsZ/5GvjEPSISKeEdABOay0mTdOV2ll5GeTCGu1gsiwqN19ehoPZMV2XwB9Eve/ot9iHib\n", + "KFlP3KYp5KZ48bSnTtDhPPfERZuCOU1r7UF4qysyCv/G8vadYRU7FUF9BUhMDxYCiTih5znruvmq\n", + "ogpUQVODed16fK6cZjMV74d7kZuvSPYvB2RREYk6nM95reo2TwFqMhB3ZIiip4L+DEfht1rDiufX\n", + "H7gAlQLkhazIGljhV4ASTKfS1ljpqLA+waq7IStoIoupIF1sk5WVGxIlMnF7f/fWrXCeaOOdHV0F\n", + "hXNTd+ReL3zvyhUX0VIgr3YiHB/lmYiCcc6KHI6G4Tz7sHO4fHVXPuPv/Phj9Ov9nZ8qtrHF7j+8\n", + "X2xj+vepoEkUhT547N+roJ+yssFcVqH34UC/J07cTaxgF+Ks34SwfSGoTgr7h6euP1VsY3KLrmaH\n", + "EEXP8O987veQp3Jy6i7q40H4niJSfViMqP0IEZmFODCnuD93E79+WowMpdbcvdtB0L+JdHq2m5kL\n", + "ZYdif0JH76Uk4NAmpNnwPnF8EhDxjiLnEAMrmsR+lJXCXDtKfVzzCNOpi5PLuIdVQT9LSbgnw7GP\n", + "P1Ze0DExAtKgSR512E504N7/5ru3/FpZB05qbV6+FFzMT6X+KMq62UySMoi2Hx76/WziGNlME2BC\n", + "36GbQmnh4/UAaJLO/8dIgEjkWfNP//iP4VrEfoV1F7e3fY7nfVeE++Gj0E5Mjrl0ycfk5gbHot9r\n", + "Vragm7+Z2Zvff3Ptezdv3sS5iyUFUPeyiP1LOBdlc4hAHh4FdFafCQleI7K6tCFQ77okb/TBLNQ1\n", + "UQAu9yNxW+fYnonFAWsSPrgXxs7Dh95f6LI+kiSGZ58JlT2uP+2I5D3UFbx/xytblGthPDUloYDP\n", + "iWtXvf6i9tnzIiJSMWLEiBEjRowYF4z4IhUjRowYMWLEiHHBSPJ8xfr2x3PQJLEPf+RZW4iwnCRj\n", + "STV0EP1d33N4/konwG252DpsbwSodGfTaRF6atQb6lSMIpDDHy4Y1iKvxPZ74nHB5lIaj0I0peAU\n", + "PmUQxia1oscn7VIR0RudnVXoRi8adSWniFoLHs9RSHUpQuUy4FbSPipYLwHan4i3F6klFSeSUlMv\n", + "KBb5vH/fKYtLu8FHpVIVqrBwmxcPJtARhMVXCnriWKcnTg9swm12og7sGQW43p4ULO7suD8PPa3S\n", + "xBuPflf0UToVyJq+ZJpEcADBsBaDpgPwjtCyvMcqou3R20T6yRk8gI6PAy1x/bpD0c8/H+DpgdA+\n", + "dFSvCDxO2PvO7dvFNorx63Wnm9yrR8S+h4EOOAA98fLLN4vPsveIXs3MeqDs1EeGPlsKxXM8JZk6\n", + "K4dtJ8d+P1kYl079Wgz1wYPQ1kNxfaY/z1SLsmKeUFH0/XuBHutIUsIekiv6PaElSIuDHh6NvP+T\n", + "AqQnkplTGnr4x4eB7tDxT88gJhOYmV2B91lJBPWFs3jV+8kSbuCzQmzt10Bn50Qo8DZE9kpjpmh3\n", + "9cUqxvhQKkDgGIlJEWKMHYrcS0IZd1G8dq5UB76vnkmUCMyFlmS/U1qe/kS3bjl9x6LaO6CxZnIs\n", + "0m7HZ07j0fdIx9q7oAN1PPGZcHTk1N4lFEE/PHK65+wk9PEW+g4L5pqZfeO/fQOXrP5s4TzV2+3Z\n", + "Z4IT98FjF5Yvlpi7hUZttSBUlzHOOZ7Xo+OvEJnLY5vJCSuVQsb0TPSx00QCUlYWYzjse2tTfMwO\n", + "1vszfbs4rvtS2eGpa8+Ymdnf/9e/K7a9+NLLZmb21ptvFtsuoxi2Pk/5DFrKmKB/lxamb3Aew2XX\n", + "pLJAG7TcnlCgfCZ897vf8fPE+FhK240w7nXe4dytzu5JKbH/61P/t/2w16WISMWIESNGjBgxYlww\n", + "npjYfDpd2FxejA0iyoa8ffPlT9Efikj3rrg7MmuMaVor6zmVJdV7yrpeeNOuSx0kvun29W0Zx60I\n", + "IkQnWK31Q2G5proOIFRWhOvRIxfIma2uNLiqOhV33gbetGfL9ZpH6uLNum6JvFVTeL5Y+gq71gwr\n", + "p041rCrHE1+tMHW2VvN3azp774sTNVO3V9x5kSa+lPMk+lStKSIRVgnTqdQaQ4p/BvFuKpBkks/w\n", + "HbXJCJ8fnfiK9Nq16/hMHHuRbLBY+PXToF1FoWx3IoipFNvb3Az3TtEfImYHUustRUq8tgmRi0wQ\n", + "mVIa7omm5O7ubeKcQjv0ei5sp/2COjHzPKtiU0FxrortiRjN5+oUD2GreVCgSkFr40fYWhAdffjA\n", + "7ReevvF0+F4mDtzo23W5J0RO220fp/Um/6Zjt6dc7+8tcb6+0nzwMAhG90QIakA1T5c+di4BRajV\n", + "vf1p3aAJKAmQ1a3NMHaXS/+M31Oh6Rhp4pOpWl2Ea9zY8LF+chrufy5z19lZaGut/8ikBUUpaZPB\n", + "sdYSm5QNON9fvebXX62Gzydyr0tEmASR5ip9Kfeki3POVxJlME/i/4nC36w1Kog0z1dT8inG1tV/\n", + "H3ObupJ//81QH/GKzDFztPEiZ3KC20987GM/bWZmtUNvw1tAYnWeoKCbc5iZJ9T0h46mHLwRhN0q\n", + "1N+7FM7lCKL0plQbePHFF8zM0Sozsze+E67h6rUbxbZ/gNi8If3vBbjIqyXEo8ehP48FJScC+eZb\n", + "Ac3RMclarIqq0brgQx/6SLHt7HQdYeWtOJO58+mnA0pDFMrMrQ7UYqS7Gc7p4BEAE3lRAAANxklE\n", + "QVTqGkof6uG+0nLHzOwBKiB8/5//udhG24dNEdvTDV/n/aeeDdeodj4V9N0JUOemJDYUtRal/3Fe\n", + "u3LZxwmR/S2pE8gxrnVSOT9LQY8oNo8RI0aMGDFixPjXivgiFSNGjBgxYsSIccF4YmLzFz9603Kh\n", + "nUjtlZR3gEPNzf0bxZYXXgiFDJ/edREh3YvrAqMS5tOijYRA6fujUDjpPoWxWQRRPUNYUFIFy4QK\n", + "T04dRm5BAKpC8SEomhQiTvWOIVWjLuYUe6pjNoW9CjVSvFqSc6IAuSTFHVkYlZTRndtOzzz73LM4\n", + "llwr6KmG+G2lOFZVBOiEYFUAXhQaLgktC1pAnZ1HBY2QYP8iTsd9PREn8D2IQxVoLYpwJr618CWa\n", + "+fEb8A8byP5IFbO/6PXTRV6FlRRgqo8WnYeV7mVx7eQcYftMnKVr6GMFnC4Uyyb6VbvtlPFiSUGr\n", + "UFBJuP4HDxyepyu6UoCP4NBdrzssfnwcKIIuRPzPPXO9+IyO4Uo70QFdnZg5aFUUTKYkF1829u2q\n", + "3H9S6TUI+kcD9WyDm/JI+hXajg7vZi5yPj11yqIGbx2l8dqg2fNcqeVwoqTn5nKt/Gsmrs/VcjjP\n", + "bSkyzLlLmHqb4dxzHbtIHlFqmXNCIjwC+30HjtnqT0V+RvsVk1IqQhk+uhfE1jvbTot24eKddf3c\n", + "S5PQ/uoZlOM+JizuKufLpACdppl4oj4+dMDOhAJihsx8ZT4Lx1BaZgRZBAt5n5y5PxLH30KKa08h\n", + "WL523ftuH5SeioiPjsK2my88W2z79rf+u5mZye7spZdexMHwj1BMLbhyn4i33MlpON+nnr5RbLtz\n", + "OxTSziXnaIykhRtPPePXk4e+VVlxGw/bDpEA8uD+A/l+OKlLl9xbjdSvejvxcy0CT5qzJm7/D5Ag\n", + "pM+OOioZnMl4ytE/SIX3paDxjafCdScydy/wbFW3+SESmVIRxV8FRZ9L/+PUcvv2O3L8cA8oo9Ex\n", + "0erA70zE/qxAsOJ3lfCYV4ttx7hG9ZTkmfwATvhmZjduPGU/9/P/ZxSbx4gRI0aMGDFi/K+OJyY2\n", + "XyRzyyQ1nqnrKnocDsPr/O6OCxGfvRSQqEbX30iZkqnpmnxzV6EuV8IU3WqqexOCvo4Ixpn+OJa3\n", + "bwrQ61Iv6BDCNk01pZB9InXiKoUD+RDn6ysdLtK0NlwPK7GavC3T+VpFlGOs+s8k/bgJd1a9HiIr\n", + "dMzdFNHjHKu6E1mFUDCub+FliGMH4qzMVfJUaifWkPZ9cOSi7DJRR1nh0pIiA4JQrzhawbaYik1D\n", + "4Xor/YRp6lonsUDsBCYYoX1a4mI7ACJCVIPO0Waedq/oH9FJbX+uJrWtT4/CvdNkgzkQmVz6KYXs\n", + "7FdDSc2nE7HWvJrOwvWMxaaC+Jwip7xsXemz/paAtLaBc25jVbdQx37ODoneL1hYyNGLVV1jvV5Z\n", + "RYTS1MyOZZVMewB2iWrV91wxCEwHjkjswOX88JG78lOw3ZJVKu9dTdqumB9kUck+ztV/re7fp1BV\n", + "5xXWJqP41sysdxbu2UzQz+kC40OgjiUQ+DTzFfnOVhiDusImcsx5TZGBzc2AxGkSwxEcw49FlE3r\n", + "iGtXnyu21bsBnVoIEj9fAmHou3i5hbmrmJ+kvXhOWpuMaf81uYYSUuwHA5kTafEilgxEERdLh26+\n", + "9+Z3zczs6Wdu4ny9Dbe2wvUrSnt0HMbwZOpI7xnqBN6QumpPPxv2dxtokZnZiy+HNP2ZzF0Hj0N7\n", + "9jEn1CRh5vgstBcRNzOzUoLEmqpf/waseJS56MEB/6zn/ZkWFwtFwtFOtGQ5PvLvN4GqH4k7O6tY\n", + "aN/9/psh7X97y5Er2gSonc39h8H2YVcQrk4N9e8q3sc3gQAPe+F+Hn3nu8VnJ8ehLV5++cVi23AU\n", + "7km14vd6VqBKilxiPEmizD2gZK2Oo87s4xmeDw8e+vi/DuuQctn7JFmPS5LEcHQUUMSyWJLsIlHn\n", + "8MhtKjgWte6qot3nxRNDpIa90Y/+Uox/F/HmW2//6C/F+HcR//itbz/pU4jxY4q/+y9fe9KnEOPH\n", + "FN/45jef9Cn8m44n9iI16o1/9Jdi/LuIN38QX6T+d4l//NYbT/oUYvyY4u++Fl+k/neJb/7DPzzp\n", + "U/g3HU+M2qtUMmt1HGIrWYD9hn2HOF98LkCFN/ZdHNYAFVFK/HuEllWUXRTNFVieYmCKKasCMZMW\n", + "mYnYm34S6phLleWt2+7ES+ErxelmLkrPxFtnOhti27rAkiJniunMzDJ8roJ1Xuvjx06ZteAAXBMR\n", + "8RDQtqpCCXfSz2dry6m9BdqLxSnDOU1x3uJ2jgKeJRFbVyAerIsHFanCre1tqzfqtrW9bVU4mnc3\n", + "HAIfA9ou49xW6NFK6B/qt0XPGnVbztA+uQh2e4CglcarFM7q4tlC6o3uzHJ8UizqIkxaajVRINx3\n", + "9aJpXA7nrv0pbYfz3Cg73cc+e3U79HF1R6dXlVKGBn+gkhT8XkLRWms4LbmESZu2HV3kz8Sr6iMf\n", + "eS1cD/xZyis8DoqXimCX51sWYSmh8Fq9buVy2RqNetFk5ayy9tuaTDtz3MfxOLSniuMJpw/G3tbd\n", + "HM72Iuwn9dYTuvXKlUDL6b2mz5BSdRPQN6Q2ajKGR6AHtWjy8XEYpyqETVBmIZPEjloj3GP1p9mH\n", + "952eE/8urxQhD/sjpbwprtO8nY8fOY03RnH3kdDtr7z0Svi+uFhPpigMXhKncIydDRHPU1xNylwT\n", + "S2aYp5eWW45/qxC5a2JHCbRsw9a9+kixmJmdwaG8KZ5+T8ONPIM7ejL2/sf58bF48r17693wu+ed\n", + "xqzgPt5/4ELt/UuUj/j1k3rsS3H5BvrzM3AnH419DI+n9PHzOfHSTnCsV8Hyxkag9ubi1Vcuh23q\n", + "SzhDkXR6IZmZ7SKhpgqx/c6WJwxwTnjuORfMU4LSEgd8jvt7d7zaxH/8T8ED6+79u8W2xyeku7zf\n", + "d9rheTZTmn+5NJvPi2LVly/7Ob366qs4N6fH+MzUOZlF3acD3y9d41NJFKJ/38mRJwW1OmHcPwbF\n", + "15ExwQSdnV0fp6Qvc5n/9vbDnNCQ576/H0iyBebJtniF6Xx/XkSxeYwYMWLEiBEjxgXjidgf/Of/\n", + "/J/tr//6r3/ch40RI0aMGDFixPgXx8/93M/ZX/3VX5372RN5kYoRI0aMGDFixPj3EJHaixEjRowY\n", + "MWLEuGDEF6kYMWLEiBEjRowLxhN5kfqLv/gLe+mll+z555+3L33pS0/iFGL8K8WNGzfsQx/6kL32\n", + "2mv2sY99zMxCpfLXX3/dXnjhBfvEJz5RVOaO8ZMVv/Irv2J7e3v2wQ9+sNj2fvf2C1/4gj3//PP2\n", + "0ksv2Ve/+tUnccoxLhjn3evPf/7zdu3aNXvttdfstddesz//8z8vPov3+ic3bt++bR//+MftAx/4\n", + "gL366qv25S9/2czi2P4XRf5jjvl8nj/33HP522+/nU+n0/zDH/5w/sYbb/y4TyPGv1LcuHEjPzw8\n", + "XNn2G7/xG/mXvvSlPM/z/Itf/GL+2c9+9kmcWoz/yfibv/mb/Bvf+Eb+6quvFtt+2L399re/nX/4\n", + "wx/Op9Np/vbbb+fPPfdcvlgsnsh5x/iXx3n3+vOf/3z+27/922vfjff6Jzvu37+ff/Ob38zzPM97\n", + "vV7+wgsv5G+88UYc2/+C+LEjUl//+tft5s3/v707dkkmDuMA/r3htta8Du8FQSsq7G4Qmpqq9TJc\n", + "bBAHW9qC/obaI5qiwK2msiGjVVpcdBdSsEsdoqUabHga3t57qzcL76WTk+9nU0/5wdcHHzh/vyeG\n", + "SCQCVVWRTqdRKBT8Xgb9IPmwf+Hs7AzZbBYAkM1mcXp6Oohl0X+an593Byn/0SvbQqGA1dVVqKqK\n", + "SCSCWCyGcrns+5rJm8+yBv6tbYBZB93Y2BgsywIAjIyMYGpqCo7jsLb74Hsj5TgOfr2Z0m0YBhzH\n", + "+eIdFCSKomBxcRGJRAL7+/sAgE6nA037fcicpmnovM53ouDrle3t7S0Mw3CvY50Ph93dXZimiVwu\n", + "597qYdbDo9FooFKpYG5ujrXdB98bqbcnLdPwubq6QqVSQbFYxN7eHkql0rvXFUXhd2BIfZctcw+2\n", + "9fV11Ot1VKtV6LqOzc3Nntcy6+B5eHhAKpXCzs7Ou1O9Adb2d3xvpMLhMJrNpvu42Wy+624p2PTX\n", + "adujo6NYWVlBuVyGpmlov45qaLVaCL2ZNE7B1ivbj3V+c3ODcDj86WdQMIRCIfcHdW1tzb2dw6yD\n", + "7/n5GalUCplMBslkEgBrux++N1KJRAK1Wg2NRgPdbhfHx8ewbdvvZdAPeHp6cmcMPj4+4vLyEvF4\n", + "HLZtI5/PAwDy+bxbqBR8vbK1bRtHR0fodruo1+uo1WruLk4Kplbr79y2k5MTd0cfsw42EUEul8P0\n", + "9DQ2Njbc51nbfRjEP9zPz89lYmJCotGobG9vD2IJ9AOur6/FNE0xTVNmZmbcbO/u7mRhYUHGx8dl\n", + "aWlJ7u/vB7xS8iKdTouu66KqqhiGIYeHh19mu7W1JdFoVCYnJ+Xi4mKAK6d+fcz64OBAMpmMxONx\n", + "mZ2dleXlZWm32+71zDq4SqWSKIoipmmKZVliWZYUi0XWdh84IoaIiIjII55sTkREROQRGykiIiIi\n", + "j9hIEREREXnERoqIiIjIIzZSRERERB6xkSIiIiLyiI0UERERkUdspIiIiIg8egFnCUKNTa56BwAA\n", + "AABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nVOIHKWOMMcaYSv4PwNFhvU7XHUcAAAAASUVORK5CYII=\n", - "text": [ - "" - ] - } - ], - "prompt_number": 12 - }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(transformer.deprocess('data', net.blobs['data'].data[0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first layer filters, `conv1`" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJNCAYAAAARaCA+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXmQZVd95/m77737ttyXysyqytpUpdIuVkFjNrEIjKch\n", + "mMF2e6Lb45ihZ9x7G7dBEkJGgJBEY+PGbUfHTAf2KOwxmIhxNNhWu23RIDAGyVjCgCRUWmpfsir3\n", + "fPu79775Q27s8/t+K/L1RXbi8fcTURF1fnHufeee7Z1893u+JxoMBgMTQgghhBD/XRR2ugBCCCGE\n", + "EH8b0SJKCCGEECIHWkQJIYQQQuRAiyghhBBCiBxoESWEEEIIkQMtooQQQgghcvCCL6L+4A/+wK6+\n", + "+mq78sor7WMf+9gLfXshhBBCiB8IohfSJypNU7vqqqvswQcftL1799pNN91kn/70p+2aa655oT5C\n", + "CCGEEOIHghf0l6hHHnnEjhw5YgcPHrQ4ju0nfuIn7HOf+9wL+RFCCCGEED8QlF7Im509e9b27dv3\n", + "vfTi4qI9/PDDQZ59+/fbmdOnX8iPFUIIIYT4a+NyL+1e0EVUFEXb5jlz+rS997b3m5nZV7/yZXv1\n", + "a19n1XJ4XVzE+xQL+ADFYhjr9vuQp9tNINZph7FuykqKP9JVS2F1/eInfhHy3HbnB/FWruitZgey\n", + "NBqbEEuzsJylEtZLpVwOy1itQJ5i4S+f5at//FV79WtebaU4vC4yvPc9d98NsX/+z342SPeTHuRp\n", + "tdoQ830jLmH9Fkj/qZbjIF2pYJeN4xhiBX8r0jXv+bcfh9gHP3JXkM4yMnBIbJCGsbT/l53qK3/8\n", + "ZXvta15naYp9MUnCWNbHe/f7eF1UCOuPjb1//x/+HcRuv/X2IF2KyRQAlWdWqYT9ZXJqBPJMTI5D\n", + "rNvvBumz55Yhz4kT5yG2tdkI0rHr52Zmn77/U0H6Qx/8wPf+/8UvPWRvuPn1lpK28lVVrmD/qVQx\n", + "Vq2EY6tYwjxpgp/n27jb7UKeThtjH7zrw0H6bqIxLUZFiJXcmCmR+TSOsT59vUQRmXPJu4te+/k5\n", + "4IEH/rP9yI+8zXpdnBMGGfbhn3tf2Bc/Rsbj1uYWxJaXVoJ0o9GEPFOzUxibCvtnrUbmyjLWZ9IL\n", + "n6fdxPktSzOIffTe+4L0e9/7XshTrtYw5tqmVMQyFf6iTR/8oz+yN99yixVIW7UaLYg1m2FsQMpd\n", + "LJA+5TrHPZ/Atnr/7bdDrBi5DlPEcja28PuwPjoapOcWJyHPdx59Gj8vDevuptddB3n+5OsPQ2zv\n", + "3n1B+sMfuAvyXI4XdBG1d+9eO/1XfmU6ffq0LS4uQr6vfuXLZmZ26tRJ23fypB298uALWQwhhBBC\n", + "iL92XtBF1Mtf/nJ7+umn7cSJE7Znzx777d/+bfv0pz8N+V792tc9/5+vfNn2HzjwQhZBCCGEEOJv\n", + "hBd0EVUqlexXfuVX7K1vfaulaWrvfve76c687C/edCwuHrAsNeu4X/OyGH8zHhnBn87HJ+pBulbH\n", + "PBn5Gdn/pLm8jD8Zd8lrFcNfPoG0hz9lb66H99/YwFd3RdISk9PhK5Ndu/An6lqt7iJYd4PBX8au\n", + "u+E6m5mdsV4vfPWZJlhPjG4Svvss+J9rzaxcwZ/Jy+61UZ28LmHVG7ufssvx5X/a/qsMBuHdCoXh\n", + "9lD411sZqRf2Cixzr/OSv/Le4/CRw1auxtbr4hOm7lVykuIraf9a18zMBv6Zh3u+tuv7Efnp3r8q\n", + "NDNrF8NBSt742RR5nTc3E/4MH5ex7tpt/Dm/2w1fmbBXxJ5C4S9/yr/i0BErFMpWIq9/y64M/lWl\n", + "Ga8X/1puda0BeTbWMdZzrzRT3+hmVmDvmx0ZeR2cDrC/ZFkYy8ir86SPrw99GYpMVkHe5/X/Yi45\n", + "dPCA9Xtd65M5MOlhOT3sFX+3hX2j3wvroUIkDKMj+Jqs5mKDDMdjl/RFP1f2yOt19jrP4+ckM7M0\n", + "w77Q7/dcHuyLxcHzsX0HDlgvSSwukXFMYgOnLclImSLD61KvSWGwV7298PlGKlXIMz2L7ffNrz0V\n", + "pBcXXwl5bn7ryyF233vCV/wvevHVkOdlN10LsUe/9l2IDcsLuogyM3vb295mb3vb24bKu2+/foX6\n", + "m+bw4cM7XYS/cxw8eHCni/B3jkOHDu10Ef7OceSI5pa/aQ5dccVOF+HvPHIsF0IIIYTIgRZRQggh\n", + "hBA5eMFf5w1D31kR9HuX3x7+37hI3jlPz4QajD2LqBnaNT8GsbGJUGs0Oj4KeVbXiE6qtf17/eYW\n", + "XtduhVtwxyfwHfCevbMQ239wIUhPTk1jmZw/w+YabvfdWMfYIAnrM0uGEHwZan9iojlh6qbIv4sn\n", + "egSmD4Dt2UQ8FhGdRjQIYwW2N5tQrYbv7Jm+o1zCMvit9BnR8DDdWc+NhW6PaDK6pN8VwjIMmBUD\n", + "oeB0EkkP69xrf8xQF8LG6Mw0bkOe3TURpHfXsQ+3iA6l1Qy1RRd6q5DHs7GFdT4A7ZhZw7VNt0N0\n", + "jES3uLq8Ft6ngeVmlgrj46FucXoa55uxcbSM8MREi9cnWiM/1oyMNWZpkjofnIj8jc2sZjIybj19\n", + "ogMDiA9PYwvnro6ziBifwjm+Pua1omaxsy+gxSYaz34z7B9U/zTE8GN2AiCKNLOBsxMoFIgG09UV\n", + "+/gSmSt9H2oRixoik7J0iOcrEgueyC0xzp66BHle9cYbIbayFH6P/sav/ifI85kvfwJiX3zrN4L0\n", + "Jz/ym5Dn1x74MMQee/RJiA2LfokSQgghhMiBFlFCCCGEEDnQIkoIIYQQIgdaRAkhhBBC5GBHhOVV\n", + "Z7SYZaFQsNNGseTGKp4DdPLkxSD9zDE0WDt4aB5i+w6GIu76GFbD2AgKE8sRGtR5mLhu74G5IH34\n", + "yr2Q59BhPB5nbDQUTF5aQtH6uRPnwjwXVyBPcwvrbjAIxcP+HMLL0U+80R0TWZPzmJyg2QsjzcyM\n", + "nP/kY8yssUjMIXtJ2IdK5DpGrR62e5mcyxcTYXniDPh63kH2MmROWNrrkfP1mCDVGXCmQ5j9mZlV\n", + "3Dlx/vPNzHrE4HB5eSNIX7yAZ+Cxc9wm3Xll+w/ieDx0YA/E/LlfXSau99e0yVlhRPy95cZDq4Xj\n", + "utfBWOSeb3pqAvKMT6FofGHPjLuObHYZxfkGIIrfAjNLdCE/Zs3MMuKWmrm/qZnwOk2J8Nq1DRn+\n", + "1h3CbLPTQpFzl5zD57sZO/twdBSF+gO34cWbWpqZpURBDeJ98nxFchahh9mpMiPdKA1zsqmy6OYg\n", + "tgmA+MVa1ZkzJ6SxEnIG7WCIjQFd8r09sxD29XViUPu1L38TYv/zP35nkP7i7+J5d7/4wV+D2D3/\n", + "178M0jf+1o9Bnv/ymT+B2I03XAWxYdEvUUIIIYQQOdAiSgghhBAiB1pECSGEEELkQIsoIYQQQogc\n", + "7IiwfHyy7tKhGLNNhJ5Fdvr76VAYeOLkEuQ5cwadjvee2BWkD12xC/JMTuNp0/UKUeo59u1bgNhe\n", + "5zy+n+SJMlzPfvfPTwfpRx/Bk6ZPnzgbBsiyeHQcRavjY+HzFUvDCcu9AXREBKqlItZT2TnlMqF3\n", + "IcJYyQkoC0wtSfx6/Yn0XhR8OfyJ8APiEh0RpSe6fGO9FEi9DJxDMhORMhdlf/+MylaRqtswQQy9\n", + "rd3F8Zc6Yem5c+g83GyiY/jIaLjZY3ISRdVT7uQBM7N9+3cH6bUNFKR6xkbwJIBqGQW/s7PhyQYj\n", + "I7ghpV5DsfLYaDhmxiZwXE1OoaC5PhLGmFi6tYl158kSIvglwnJ/qoANUBScDbBPZS5fShTUJTL+\n", + "vKP+gPTFfh8F1B62eYA5nZcrYTuMEFF+tY59oeeE5P0m3rvdIptwnMI+IvMUG9ueiLi9MxU+1jte\n", + "F/l5mHx81iebDlw5S2TjDDuxIBnmRIQM2335QjhP3PjyI5Dngd95CGKPfv2xIP3eu38a8rz3H38I\n", + "Yv/wn/1wkP7XH/qHkOcP/p+vQ+zHrrgZYsOiX6KEEEIIIXKgRZQQQgghRA60iBJCCCGEyMGOaKIS\n", + "p7moOU3C5N7QnM7MbNccnhA/vzvM5803zczOnkJTwIvOODBN8N3xwm5ipDeO79nhugXUV5WLoS7j\n", + "iW+dgjyPP/YsxJ74VhhbX8WT5cenQ73F4r5ZyDM9gzqUSjUsU5Jub4ZnZlYohuvuAtHrDIr4bjyu\n", + "hF2tQrQqzGzTnzpeIMaazP0ucvmYISej6oz7+sQzc5CiZsBLw2KiNfBlMjMruvoslVDckBCtiK+H\n", + "ghdJXIbYtTs56B2M/MzMer2wjldWNiDPqVMXIPanD38nSM/M4ji+/kWHITZWC/v13MwU5PHUatin\n", + "6nWsz7rTy8yQ8TE6iu034bSbI2OopSqQv0u3GuF8d+k86smWLqB208MMVVnfKBa8WSMx6SygHihx\n", + "WqqI9KmsgPfquPk8MqzzPjGR9XTbqAvLiGaoOhJqoiaJeWmlgn0hc9qmlGjMeh3URHnhYJHoJIeB\n", + "jdGUaI1Sp01LEmyrQtHVC9FksXKmWagLY2WK2JwOEWRiAtvhzInzQfrc6XOQ5/Vv/SGIPfyVULf0\n", + "jv9pN+R59ZteB7HPfurBIP2qN78I8nzjAH63Ly9tr7m8HPolSgghhBAiB1pECSGEEELkQIsoIYQQ\n", + "QogcaBElhBBCCJGDHRGW99qhWrffC8Vu7MRoJo4+enVoWjm3G0Wri/tQ6H3+bCg2b26gephoza3Z\n", + "3F58vbqCArWlb58M0t99EoXlx59GwV05Dte4h47iaff7nZHn6DiKXZlgGwSb/eHMNivO6M4L1M3M\n", + "EnJie8mJXeMSrt+ZkNULtLl+mtyr5AXbQ/694OqFCe6LxBGz5ITe3lzU7DLidif6Zc/nxedmKPQs\n", + "ETE/wxsHsnuPT6BhpP/ARhMFuOtruPHh1MmwX3/7sWOQp1rDDRtjzpC3VCAbERyjo0ToTZ5v1Jly\n", + "VqqsfrGNV9zznT6Lm1aWzq9D7OLSWpBuNrDuSkOYwWbEBDElMYO+TsTLxIjRC9fTDOfhAemg/W5Y\n", + "BlLl1u/jvTztNs7DRTJux5ygf3SM9FfyzK1mODd3Gk3IkxJT0ILbGMQMf9kGGywRGaNsbnbff30y\n", + "nxaK4bxYImbJbI6FjTN9NNZlfT8l4nZPi9xrwRlLnztFvueKOP6vvD7cbHLq1HHIs3sRN1Gtng83\n", + "vLTXsY33HcCNa1uN7c1uL4d+iRJCCCGEyIEWUUIIIYQQOdAiSgghhBAiB1pECSGEEELkYEeE5bFz\n", + "RPanmm8sozizT07XnnTux6PjKDDct4jupKMjoTBw+eIW5EmI0DpiR947zpxagtjFC6GwFE5ZN7Oj\n", + "1x6A2P4D80F6bgFPuy+4FvQnqpvx09H98nlYF96aE5KXiTN3MapCDK4rk5PQifC64Cy12UnoTOiZ\n", + "OHFmXMZyMryIMyOCWOYA7U8+7xM35DRD0Spo1Ekd0Gd2QlYmymf03Y6JuITXVUlfmJwO3br37EVR\n", + "58qlNYitXQqFnmfO4fiYfhbdyBd2u9gQwut6HYXlERHc+9ZbXUdRaauJIudGI4ytr+Emks0NFLL6\n", + "TRwjo3XI48cHg80bbDuIFwF7p24zswHZHNF3ouqUbPBh4ui++zxium/d/vabclrEsbw+gm06Ohpu\n", + "MmLzRpOIxleXw/65uYHzfrWKc1epFM4dbLMCqU7MQ1prQBzL4e5kvkndhpcsY/M3EcC7+bREjiyI\n", + "SBuzsns65Hum5L5r5/fOQZ71i7ghpRuFfWr2mnnIM7cXy/6tR8LTAFaXsE9NTOP429wc7sQOhn6J\n", + "EkIIIYTIgRZRQgghhBA50CJKCCGEECIHO6KJ8u+UK5XQbIsZyG1u4jvudifUUk1MjUKeOjlpfaQS\n", + "fn4yhnqERgvfkSbp9roTZog3Mho+39Q0ardmZlEXMjYevp9PEjQz29gItWLspPeImcN5HcGQy+k4\n", + "dvcaoG6CGTiWnFDC6+LMuK4ndXoA9nzkYHnL/HXkNHhG151Ib+yUdXKvJA3b3WukzMwyci+oF6Ix\n", + "Y3izPa91uBwgwSLXMY1JzZVzYQE1Uc0jqD84Vw37fkba79KlVfy8Wjgma3XUqniOP4dGfutk3th0\n", + "Y4bpmFpubjFDrRHTxlUqOJfM7ArHdpXUQbO5vdlfm2hOBqQvekNVqm0iEpfEa6nI8xnRhSZOq8Xq\n", + "ZUD0OZ7MsJxjY2iyXB8J+4LX+Znx74uWM4hlKp9ijO1XcHMV05MNZVVM5reMXenqLyH6ymLJzxNM\n", + "x0QLEaRiuI9ZuYx10Cls3z+rZE7vNsP5tFzGfjAxh7rlC2dWgvTpZ3BsH776CMTm94f3Ov70Bcgz\n", + "txdNuTsV1DcOi36JEkIIIYTIgRZRQgghhBA50CJKCCGEECIHWkQJIYQQQuRgR4Tl3r8wcsaBJSLO\n", + "ZAdgJ06gubmJ4jd2+nTViXcrpBYGZfzAdpucmO6IKyicK9dCIXmdnFpfruLnNVru1PEuil29VrlI\n", + "xH3MjNKLnIezajQrOXPGiIhBM1LnaT8s+4CYIDKjSW9GlxFRJ/Nh9ALmxAvGL0O/5wTi5FT3iEg2\n", + "vUlnQswF2XVeWF6uYB7WppF7aLZ5gNHvhs8TkfosFYgBpxskY2Mo9F5cRCM9r2DeWEODw14XjS1b\n", + "TmhdHsIslZlfdplpbhTea3pmGvLMUOPXMB0TU1Jm6lpxdVcg9cvawdPp4bgqkJHrNzWwjRB+zjUz\n", + "6/V9PiJWJtf5okfM5JE5cDqqxHB0pIYbg7xbaruJRszMbNPr+StVvDcTWg9jpDnM/FkkmziyDOcl\n", + "PzezDSne4NQbpZpxAXyx4Od9LDkzUPbzFIX0M//M7DvMyEakXbvDMbl8AU16z51Asfmeg7vcdRuQ\n", + "Z2MV56Bh5pfLoV+ihBBCCCFyoEWUEEIIIUQOtIgSQgghhMiBFlFCCCGEEDnYEWF5mnqx8PZu0gWy\n", + "3vNOsszZtdlA0WpW9SfZYzXUiLNqkbhzewZwRrxZxQlQmRC63cZyps55mLtLhzfzJ8abcfdsv35m\n", + "LtWMSiUU4BWJg3EUM2FyeF05Jp9H1JklJwLOSKaI9J++y8Zc8BnebZm5L7OCRk4szFx/M9J9okLY\n", + "Z0vEMZkYMkMZmPiU4QWpRCdMHaBr1TBjuYQXzsyMQ6znBP0x2VCAgmazbi+8jgn1PQcO7oZYXEHB\n", + "qBcPV2pY50UipPVDhImJu0w46wS+Pb+zxsz6xI3c0+6S0wGISL3jNsD0UyY6xut832B/Y0fsNAI3\n", + "L2Vsz0hxe2FyHOOGm7FxdLOOS2F79cjpEhEru+vsbMMGcxWH3TtDbIBhMLf+LGGbVML2Yt8pmatk\n", + "VndlIpL333Vs/LPvELY5yTMgfdGi8PmKZDNGh5wOUHb7ViZ34eaPfge/M9eXw9MPxifxFJN+B/sL\n", + "G5PDol+ihBBCCCFyoEWUEEIIIUQOtIgSQgghhMhBNGCOXH+dH8jeOQshhBBC/IByuaWSfokSQggh\n", + "hMiBFlFCCCGEEDnQIkoIIYQQIgdaRAkhhBBC5GBHzDbfe9etLhIKttjJ5BSn82K6rwJzE3O3p4Ix\n", + "Eis4o7l7P3gv5Lnt9tshFpfDD6zXRiDP8adOQ2xuX3gidX28CnkunL0U5qkyczpirNcPjcpKxAH0\n", + "7ns/CrHbfu7fBOkucZBMiXFg5gzjiOeiVYjBqa87ZoxaJEZzqTMTTAfYDz7yIXy+O3/+/UF6QPpi\n", + "o9HGcjqTTHYifZah6aE32xsQQz5mCug3aCTkuvvuuwdiH77rg0F6ixjPdUj7dXrO+JWY79XIM5fj\n", + "MB9pYqsRkz7n0UdnhNs//KEg/d7bfxbyFItYpkIxNCGMi+wEd2aoGNZxkhKDPtIOA2d2WSKGlcUC\n", + "XnfX3eH88v7b74A8UYRl7yXh2B4dxzrYXMHT7Su1sFyHjxyEPE89cQFi586EBoeL+2YhT30C566f\n", + "/8CdQfruD/085MmYyaPrL8xIt0sMY1MfI98NpQLO+xHMjWSMEiPkj9x1V5D+wK13Qp61VWyH2fnQ\n", + "IHL3gV2Q59nj54J0q4V9cWpqDGK9btg3ChnWrzeHNkPD5o/ei3PL+277AMRs4Ps+juQ0RbPNipvz\n", + "4hj7TykmhthReN36ZhPybJL5u1YLv0M+/nH8br8c+iVKCCGEECIHWkQJIYQQQuRAiyghhBBCiBxo\n", + "ESWEEEIIkYMdEZZHoOx2SSLqZk7nPsLN0Ilo3J24PayHuheWMhJyYvpEPRT4NTdRSMdOf981Nx6k\n", + "1zYakKfXCss0NYliu0G/C7HI10u0/bOZmRW9SL6Iou7qJArnq/VQ3Fofq2GeCopkMycIbzexfjtd\n", + "EnMng7fJSe+Mdju8bnwMTwGfn69DbG1lK0hvkbYaGcXrypVwCCZ9csI4EXqXy2F9VojIkuGzjdZx\n", + "CmAC/4ITY/Z62F8arRbEatWwf6RkkA5i/Fuu6sStw/y1FxGBelxiG0vC5ysW8XlTIhC3gYuRsc42\n", + "pPj5LGP7WIgQGiDPlw7Y6fPhvdgmgK0mttXEbChgro1gf126sIafloYPNDs/BXmanS2Iefp9rM9S\n", + "hQifXd8vjaLo2JfJzCzth3XVJ22csTZ1AvSI7YoZ4tyPao1sNulj/7xwdj1I7zu8G/JMzobz0sXv\n", + "nIU8Y6T96vVw3m2sYz8okjFaYOMIwL6YuY1HfdL5C0TMH7t5o1LBNu738PNarVA432x2IM/A71ox\n", + "s0ol/1JIv0QJIYQQQuRAiyghhBBCiBxoESWEEEIIkYMd0UT5F8j4Cpbon4YQLjHPTHad1yiARosX\n", + "wQbDlIHopur1UCN05ukzkKdIDDEnnenayefOkw8Mm7BWw3fHaw3UI4B/YzRcVxgbD/VdcZVpFlDb\n", + "VCyEMTSwM1vfQF3Yxnqo59pYQ6O0HtF8eXPPlAlRCLHTW6wsXYI8YxNoYjczE8YaTSxnmxjiWSVs\n", + "9xJ5N58RwUXPmaUOCqi3YGSuHipl/Lxqhfxt5bQ3zRjLlLWx/VqtsG06Bbx3kmEZvMlpdQjNF5Ms\n", + "ZmTQgrSIlIndjKid2Afi57n7s/nmMgfEh9exPOTzvDYsTVBTlxKj0LmF6fDWfSznmRMrENu7by5I\n", + "T82gjnDl2YsQ8zQbqF8p97Gc/U44tmojzIgR56CC033GxODUm8qamSWDsP5KGfYX+h3iqIzgGK0T\n", + "ndQzT4XzfLuB4+rgofkgferkMuS5tLwOscW9YRvXyOf3e9hfCgNmSBuSZsRk2WnMmJFnrYr62Imx\n", + "cRfB+u200Eiz3QzrqkXmpArRgcbkO2tY9EuUEEIIIUQOtIgSQgghhMiBFlFCCCGEEDnQIkoIIYQQ\n", + "Igc7Iyz3WkinGWPGmpk3ujOzwhBq8wG5jt0fL8TQMOJBerK0OyV+6QKKlY/ciIZq9XpolnbuNAoF\n", + "5+dDUWdMToinBnLl0MxsONm1WZI44WUHn7e9yQwxQ4Hf1iaKwdfWUAC/teXEpkRdW69jGcYnQrHi\n", + "CBF1MrwZ3WgdRY8Xz6O4dmsjFDlOzKD4PCZF6DpT0GIBRbL1OsY6nbCd+z0UUDISZ2gYE2PNGjE9\n", + "LRXCzREFYqwZkemkkYXt1+5h32CGkVHkN59sL/yMSN9nBpx++Bcicl0RnyV145+NqwExecTNJkzo\n", + "vb0ZrBfbmxndOVN2Ze91iWCbbB6Yng1Fx6e+i/PN0ulViN30qhuCdH0cDXg7Xdxo4WFmm2xmajnD\n", + "3XYL+/7oKI5bb6hYLGHfr5KNFl1XrgER8w+o6WlIVsbvov2H5yH28Je+FaSPEyPNI9e9PEgv7puB\n", + "PE89sQSxDTefTpB6KhIx/zA7HzKygcEb2bKNT2NkY0DFTZbrW9h/VtfQ0LjVDL9XemReHJ0kn0fm\n", + "vGHRL1FCCCGEEDnQIkoIIYQQIgdaRAkhhBBC5ECLKCGEEEKIHOyQY3kohgTNGhEPM1Gljw2YPJo4\n", + "FnthOdfMESfgIfToTDjX2gzFbetbKNg8cPQlENtcD8V0Gysorjt6VegOnA5Q3Dcgp2tHzkU5TYd4\n", + "ODOLBuHztZsolmRCz42NsOxr5PTwfh+vi8thuSYm8WTy6Vl0SPZOwMUhNgWYmV04H4r+p6fxRPpr\n", + "brgSYpurG0F6bR0FuCnpU20n0G400IV31y4UjZadEJI55TO8g2+JOPVWithfqs5RvziG7VAsEHG7\n", + "E9xmRoTlCZa952ODIYTzRETONqTE7kR6alg+wGDRnTbfJ1WeJFjOQRpmJGb9lg0hTKYnMpA+lWXh\n", + "vbp9nBPGJ3HMlEvhmDnx9DlWCojsPxxubumnKGRvEwd/D+vB/YS49ffCnH4MmZltbuLnedF4nQia\n", + "q1UUxReLzgGeCsu3H38bW7hx5soXvwhiU7OhW/effvFxyPPaN98YpPfumYA8p0+hi3ni6rPXxX5X\n", + "KGAHZeMIriMbNGq1cH6pVYm7PByfYdZz5dwgwvJLy2ukFGFb1Ufw3mNETF8oDLu1CtEvUUIIIYQQ\n", + "OdAiSgghhBAiB1pECSGEEELkYEc0UahJylwarxlutbe9sR7LxvJQndQQoqix+gjEzp4KdTZxBe9z\n", + "8Iq9EHvkoWeCdLeDepKZ+fBdeLOJRp7kFb4V3Hv+HjEJZFy8FL7Xb7dR/7C5hRqFTivUZRSK+HmT\n", + "M0TvNBPW5+g45qnXUNfT7Yaf1yOnszN2zYX6oz9/7AnIc+y7JyH2qle8OEgfOTwNefoDot1ohPV5\n", + "+hS239mz5yE2N7crSFeqw5mJdl09tFqolykRY8txd/p6nZh0FonWx3vPVsrYDlstNF7NXKdlOhRP\n", + "qUjqgOqWwjIUSV+khopJOP4iojUsED1n6ua3lHTFNBuif5J7Mxlo3+njiFTFJidRQ9NwJrlnT6Op\n", + "7PQCagR37Q6NZS9dwv7K/H49SYqNVSoRLax7nm5CzH3b2KfWXTtUN7G/MM1OzWmnKsRQeRhN26Ul\n", + "rM/yKDbOD73lZUH6P97zWcjznUdOBOkXv+Eg5Bkfw3GcpmHZEzJACmTMVMkze5hxb6Xi6q6CdV4k\n", + "Gqymm79XVjYgT6OJ3z2TE+H3w8QEav+YJop+SQ6JfokSQgghhMiBFlFCCCGEEDnQIkoIIYQQIgda\n", + "RAkhhBAHr2CGAAAgAElEQVRC5GCHzDa9iMulqX6bmW3mxd9ryDsNYTjGnPQuXQzFwvsOzUGeWg0F\n", + "08e+dTpITxKR3K75UHh97s+ehjxFwzJFkTvRfBjlp5mtr2+6G2HdlYhZ4675UGDIDDJnSGx8IhSt\n", + "ZqSYHSJubzvxMBP8MubmQkH4j/6jH4Y8v/PbfwSx//vX/1OQvvbqqyDP0WsWIXbF0fAU98X9C5Dn\n", + "6SePQ+zcmVCkykxBGR1XL9kW1h317RyEYsyxMRyPcRFjdWdsGVXJ4CZ/yvX7iUtv334DoqDOyMMU\n", + "3Hj3QnMzs4yInDNXJqbYLsYo5vUi+YyYi/aJ6SFAjIMtIuJ2J3IuEFHwKJlvLp0NzQtbxODw4BU4\n", + "dxWdoHhtBU0lC4PthcnjU+MQKxaxjv3GpKSPddBu4CaObjcUm7MexUyd+24nQKlEnoU7NodlIps4\n", + "nnkWN6m87ObrgvQf/r97IM8jXwkNOK952X7IMzmKbby8Fo738ghuMOhsYPtlpB08JSIQj1yfjUj9\n", + "NskmgGVnLL2yisaaxKPTpp1R6dgImqeWyRhtt7Y3g70c+iVKCCGEECIHWkQJIYQQQuRAiyghhBBC\n", + "iBxoESWEEEIIkYOdcSwHHbkTmxGNXkaPMN/eQXxAbuY/j51QzY3Ot/+8fg9PcW90QpHjdX/vOsiz\n", + "sYbXnTl+IUjfeNNRLJMTcW+to0BuenYXxPpe3DqEZt7MbHraOYhPovvryDi6/k6OhQK/CnEZZ463\n", + "fefSvr65CXkaDXzmxD1feQhhpJnZFx94OEj//R99LeS5+5P/CmIPfO5LQfoLv/co5Hnov16E2Le+\n", + "EYo/r3/pYchz8KoDEKuPhO1w4Sw70RzxIuB+F5X6W6Q+s8Q7iON19TqbTsJ6LxF38EoB28Y76nsx\n", + "MYWMYyZnLrp7eaG5mVlGHMQLfppiUxLbAOOHGhGtD3NgwIB8YIHUS8GVoVwm7UKuWzoXblYoV7H2\n", + "FvahE3+7HfaXjQ0co1XiVO2JSZ4SE5a7WBmnGyuX8V6pE4iz7xS2EcHPJRHZQBGl2/fPehnnymPf\n", + "wU0jN1wfbkr5e7e8CPJ89fcfC9LPPHEO8kzOT0JseflUkC6Qib9E+ks/xe8nT5F9cbsv+24P5411\n", + "srnl0upqkO718fMnJvF0kJHRsDPURshGD/LM7S6K/odFv0QJIYQQQuQg1yLq9OnT9oY3vMGuu+46\n", + "u/766+2Xf/mXzcxsdXXVbrnlFjt69Ki95S1vsfX19Re0sEIIIYQQPyjkWkTFcWy/9Eu/ZI8//rh9\n", + "/etft1/91V+1J5980u677z675ZZb7NixY/amN73J7rvvvhe6vEIIIYQQPxDk0kQtLCzYwsLzpoCj\n", + "o6N2zTXX2NmzZ+3zn/+8PfTQQ2Zm9lM/9VN2880304VU5N5Few85pitgqz3/Spvqn8irangVzkzs\n", + "6Ptdks3R6qCepOrey+6an4E8zzx+CmL+ZPcrrtkLeVYuhVqYXgffOVfq+C5+c7MRpMvF7TULZmbj\n", + "ThNVrWHLVGJiWNcN32m3iEFmkxjkrS+H5ey08N14qcz0VeHzJEP+uTA3H5oJfvyOX4M8tzzyKoj9\n", + "2E+/JUjf8GLUrz3+GBrrPfFnzwXpP33kCchz5swFiF11/cEgPTGFRqWMWi3UpiVF7C9pHzUDTafr\n", + "62fYDuMJmvvVKqGupkCMCr3WyMwscqa1RDaFEF1flqDWwUuSvCGgmVmB6KsGbjwmRP+YEL2Tn3CY\n", + "psaS7SeXQgHnJKaT8o9TjXFsNzaxXjY2mkF6Zg8auPrxb2a2sRZqoLpkjMYVnIM81KyRTs1O00p0\n", + "TF43ZWZWjsOvO1Z37F6xiw1Inox1YsfUOI7Rs+cvQezZZ0KT5UPXo9nms0+Ec8mZM8uQ58oJvG60\n", + "GrZD0kGjy2IR59NkiC+/ATGaTtzE20+G02D6fOPj2O9mptGcdWIinINi0g9abeyf7c72mq/L8X1r\n", + "ok6cOGGPPfaYvfKVr7SlpSWbn3/egXl+ft6Wlpa+39sLIYQQQvxA8n0tohqNhr3rXe+yT37ykzY2\n", + "Fh7PEUXRcDtqhBBCCCH+FpLb4qDf79u73vUu+8mf/El75zvfaWbP//p04cIFW1hYsPPnz9vcHJ6z\n", + "ZGb2lS/98ff+v//gftt/CM/9EUIIIYT4QSbXImowGNi73/1uu/baa+1nfuZnvhd/xzveYffff7/d\n", + "euutdv/9939vceV57c2vCe+XpxBCCCGEEDtIrkXUV7/6VfvN3/xNu/HGG+0lL3mJmZnde++9dttt\n", + "t9mP//iP26c+9Sk7ePCgffazn6XXw0s+d8o5ewtITey2ST8fZNd5RToRZ7JbDXFSNxNMz+4KTc8K\n", + "AxTunT72HMTmdocnbE/OoHD3xLOh7qxGTmf35ntmZt5LsDCcrtzMma61NtGUsLmBl3nDunYHha3s\n", + "NPbI9Y1SjM9Xr6Pb3iByBnlElMt49VtDY7sDV6CY/zP/8Xch9tjDT7r73Ah59pJ7/dCbbgjSW6to\n", + "tvnUEyhIP/702SA9txtFwAxvpFckwss0xrrquY0BzByy2UVxZpqF969VsO/7jSZmKOwuDLZXHhSY\n", + "MJm1u7s3ExMzkbovZlTE6bMYESNNC/t1gQhwIyLmB9izECF7FIV1NSB1xzZoRKUw38QoinkHxGR1\n", + "cz3c/FEgXyvU8NORUZdlDJUKYTD27s1mlpB7DVy7U2F5is8HXxcZ+YIifc9TJwbDFSL6P30iNOVd\n", + "WMCxvefIQpDubqFAfGsTBdtlJxrveNNlM8sGZB4eQvjDhpEfDkxYnvSZca8zzaxi3Y2P4maFcjFs\n", + "h3YL66XVImbCpF8PS65F1Gte8xo+8ZjZgw8+mLswQgghhBB/W5BjuRBCCCFEDrSIEkIIIYTIwY4c\n", + "QOxN1fy76gJx1iuSd87+hSJ9x00+H/Nt/z77L67cNkdKTPpmZkNN1PqlBuS5tIJCogNXhmZp/V4T\n", + "8jTdgbz1EdQHdTuo0/LL52gIszgzs8iJYaKUtQvWU+q0TcUCvuOuj6A+oOIOJU3JQZ8R0aH4thpQ\n", + "Q1XkCw8+FKSvv/FqyPNzd/+vEHvymyeC9NJp9EhbvnAMYnE1HILTs2ggt+8g7nLd2gzNL9tEj8Tw\n", + "Y496Q5JDgovOJDPLME8/RS2FOa0Bka9YHBNtkeuPTDcFH0V0dnRke01USvR5rGJcmdhBwn4uMzNL\n", + "+uH9CwV83mQIyR77i5f1/JIrZ9rHm7fbqAGJ3Lxbq+F4pM/XDWP+882G+2vd15MZb7/ECXQi0qmY\n", + "2sTnKrBysu8ZMEsl9x7mAHci9q1WsY67zVDH022jrqc+Ec7zGWnjJtEDxUV3MHuM83CX6JaoQawj\n", + "Jdq71H1f9InudUC+70dcvdQrmGdyFL/r/CHI3S7WAWUY0ddl0C9RQgghhBA50CJKCCGEECIHWkQJ\n", + "IYQQQuRAiyghhBBCiBxEg2EcJF/ID9R5ekIIIYT4W8Tllkr6JUoIIYQQIgdaRAkhhBBC5ECLKCGE\n", + "EEKIHGgRJYQQQgiRgx1xLL/1fbcGaX9CfH28DteMkhPFU3fyeYe4NvcS4oLrXZt7eF02QNfWcjV0\n", + "SL3n7nsgzwfuuANi3U54/5mZUchzYRldzL376oGD85Dn0T9/JkgfOrgH8sQltNg9dWo5SC/Mo1P2\n", + "XXd9GGK33ha2HTv1nJhZW8Wdrl0fwTauEPfepBfen7Vns8naL0yzjn7fL3wMYrfffnuQ3lzHE7/n\n", + "d09DbGYhbNOnnjoBeToNrKvFPaEbOTvYOzG8zjv/RsTb+b57sH/edtudQXpATmxn5vV+Q0iBOPyy\n", + "voAbSch1VLC5vQX0vR+7N0j/m/fcSnIR93x3cn1KnNZ7PeKs7O/DPo08S6kUuTTWQbWCPfQTn/iF\n", + "IP2v/+W/wg8kgw3ahpSpQOaEQjksQ22kBnn8HGhmFhXDz+v2sB+UyhWI/fx73xuk3//+2yFPRk8a\n", + "SF0efL5yFT+vUgndub1Du5nZ0rmLEFtdDk+T2L1nAfJMT+H8+f73h98Fv/QLOB47XayrrUbost1s\n", + "4/zWaIbzEjuxoFpFN/Kp8fB7dGYav1fLFWLJ7pzHf+59d0KWD9z5QYhVamF/KZWxTOx0gF7Pu7bj\n", + "qRvNFp7gkbmxnCQ4SitlckKC68Of/MS/gzyXQ79ECSGEEELkQIsoIYQQQogcaBElhBBCCJGDHdFE\n", + "lWvh++r9h/YG6V4b32OeeOYUxLYaW0G6OoLvwWt1fIefWfie3b+3NTObGJ+CWKOF72U9EdEa9Nx7\n", + "2TJ5J+t1GmZmBacnmZhAjUJzI9RS1etYB1Tz5fRkTKfBKLq2y/qoWeiTE+KXL6yFZepcgjyTk2MQ\n", + "W9gzE6SnprFdJiZQE9HphO/LW43hTvMeHws1Akkb2+XPvvwExN7yjlcG6Vff/FLI8we/+8cQO/Hc\n", + "uSC9f/9eyFMkp9THtVBbsNXYvm8+T3ivArk388MduGPqmWnuUD665POKpOt5LcyACe0c/T72c/Z3\n", + "Ys9pdpiOiX1a7MZthYx1puXyWr84xjKViuxe7s5EO2JEQ1cohKWPiMiNtXs5Dp+vVEL9SqGIc9fA\n", + "1xbRyzHdGWYifYN0qkEU1lW/hzrJVg+1jPFkeN2uhQnIs7i4C2KPf/vpIH38uTOQp9GYhZgnJX24\n", + "SNrdSXatXMY81X7Yp6iGL8W6gz5E6rdAyjTM0M6IXjVLwnt53Z2ZWbWC/azqxky/gnrZmOir2u2w\n", + "3ZM+lqlcwjIUmBB0SPRLlBBCCCFEDrSIEkIIIYTIgRZRQgghhBA50CJKCCGEECIHOyIst0G4dnv0\n", + "698J0ufPXoBLZhfQ4PDK6w4F6fExNLEsErO2yIkjuz0UHZ87eR5ifSJ89AwyImR1RmgjYyj+bjZQ\n", + "FFurhqK8sSkUXl+4sB6k63UU4G118fn6XSdE3P7Rni9TJRThj4yjKL9IjAMn5sKynzuJpnbPPHsa\n", + "YsecaeXsLArL9+9Hg9Hx6dDMs0o2DzDa/VCYePTGQ5Dn6SdQWPr53/yvQfpn7v5fIM9r3vgyiD30\n", + "h98I0qvrm5CHiWunZ0IBPNtQwMB7EUFzhGJlLyRPmRnmgFznVbLk3l60bmYW+b/vhtB9lkrY95kA\n", + "3pv7MUF8HGMfrjjzwgqpcy/qfr5c4b2oHJ2YAnp6REDtDXmfD4afUCKfSLTfUA9FIsCtlLGOU9d+\n", + "KZlzsyE2BpSIgLrfI/3FzcMZmZe7bZzzttbCTTgdkueGF18Jsde98aYgPTb5JOR54lvPQMzDtMsx\n", + "MRiO3Xzd62MddPvh5oitLTSeLJEdG7VKWIiIDKwyMUYdJLhZCCDP55+Z7Z+IS9t/R5fJxqcB23Tg\n", + "Nol0ye9ExGPVCkNurGLolyghhBBCiBxoESWEEEIIkQMtooQQQgghcqBFlBBCCCFEDnZEWH5paSlI\n", + "T+4KBeE/9OYfhmvm5mcgtrK0GqTPn1qBPKtL6xA7fyZ0y95soJh3bt8cxPYcwNO7PSWiHvROyhOT\n", + "KIBvbqLjdL0WiofHx9CxfGsrvK5SQ1Hg6sYaxPwJ5lFxOMfW3nr4eeURFEbWiAPt4tXzQfqGV14F\n", + "eZbOLkPsiUdDwebZZ3DTwXe+cwxis3OhAH1mFt2JGetroQv+0etRCfnGd74KYv/u9l8P0l/4na9D\n", + "nrf8g1dD7MChsE+1tlDs2muhqHP1UiiSnduDgntG0Qm9swzvzRyuvWCTuXwXiJAVBOnkOoorQsSU\n", + "0P6SmAhUidq14sS1zK24WsM+XHYbJkplMmaYk7tLJ30UkVOBOFyHbeVd1HkRmCs9aSs/J5BnyUj7\n", + "ec04bSqyecBTIALjkQo5ccLVX4EohVNSx0vn3ffFGZxvNpYbEHvl624M0jfddD3kYS70n/mtMM3G\n", + "B3Ujd+7c3S7Wnd8gkpK+keI+BHDr921uZlYhTuBGxhZ+HtkcUQ5jGRGoD/zmEzMruQ0abHSw75k0\n", + "CfsLG/+MiGwIGRb9EiWEEEIIkQMtooQQQgghcqBFlBBCCCFEDnZEE3XNdQeC9MxcqHdavbAB13zu\n", + "D78JsUtO75SSU6uTAWpMDl61GKRfTTQuk5NobHn6mbMQ82TkHWyahu+BqyN1yNNs4Avseech6TUZ\n", + "ZmYdp5cpM40EeaOMdTXcu+OGM4MsbeLnrZ1HDdaa06Htu3ov5Dl0BGOHrwxj552uwczsuW+fgNjK\n", + "xbAPbbbxVHdGsxH2l2efOgl5fvidN0PsRa+/Nkg/+ABqoq5/BerAJkZDfVyBtFVhfARiF8+GfX99\n", + "A832GAMnYEkyos/JqYliYhivoQETTeNjxuD+22sWyhVmrIex0mg4tutEl1IkGpc4DvP1iL4jSYYw\n", + "Ic2IxoU5AMJtmAkqeWYfI9omVi9xHGpxwCjVzDJSBt/GKTEOzdLtzUQ7XZwDR0dQ9zK1K9Q3sp7R\n", + "buK8nyTh/Z/41nOQ52tf+TbELi2Fc94tf/8myHPNVUdIKTxYd6zZS87otUj0qgN3L2ZmmhEdmq9j\n", + "No59Pzfj49aTJth+Sd99P7RwHo5I2Quu7EVifkvNRKsuH6kDPndhaFj0S5QQQgghRA60iBJCCCGE\n", + "yIEWUUIIIYQQOdAiSgghhBAiBzsiLL94LhT9PvLl8FTsJSJMHiNC78WjoUB84dA05Ln+5Xgq957d\n", + "ocHh49/4LuT50uceglin2YMYQJalqTM0LBChYK+P945LzhiRiOS86RoTzRWZmHcQCj3ZSfYML4Rs\n", + "d9EktE/MIc+fuBikjxEx+MIV8xA7dE0oLN97EPNc+6IrIHbpUii8Xl7CzQqMyYnQtPLRP8YT2735\n", + "npnZP/ynPxKk7/wn/x7yPPYwmoIeviHsw/026/tosjo5E4rN223irEdIvAiYiDoHTBwNp7ET0THR\n", + "a/r+yAwcC/Q0dmcmSATwnjFi/MqMQ0uu7DEZjxn5PF/OmJz8nqVE/F0Ip9msSETAEBkONm69aDwm\n", + "5olxjLGSm2/oBgNSBv/MzFCx39u+fzLt+YULuJGk1w5F44sH0QT5iiOLELvmhnCemN+7C/J8+Qu4\n", + "gembj4bfDwlxsbz5LS+HmIcZlTJFcxSF+ZgZrDeRpMJy0qkS11Z9sgkgIQ1RGmJjR6+LYn4/tOKU\n", + "GHkyYbn/PPLdl5FNFX5BU4rYWCNz3vehLNcvUUIIIYQQOdAiSgghhBAiB1pECSGEEELkQIsoIYQQ\n", + "Qogc7Iiw/JIT+c7tDcXCr3jzy+Ca+UUUjdfHQpFaTBx2n/n2aYj9nx/4jSB98tg5yHPDy45C7LpX\n", + "XA0xDxPlVsoVl4coKAcoViw5J+VOFwWblWp4anWbOMIyN2QvSGVuyIzZhckg7U8FNzNLOnivei0U\n", + "R69cRAH18cfOQOzUk2HbzC3OQJ7dB1EgWndi7Ani+s2Y2x3e/+nHj0Oez3/6CxD76Z/9iSD9RuJq\n", + "/MzjJyC2eGQuSGcptlWngYLNuOTEypXhTiH3ouosI0Jv4gQ88MJOosNkbtYoGmf9jAmYvbiWXObw\n", + "wmgz7ugdWTj+0pQ5+hNhuRP4luIq5MmIYNuLqr1rvBkX8wKkiZko34v3i6Q9SyVysoGrq4hWOts9\n", + "ELYp9BUzS5PtN+WUyrgxwFp43fHjS0H6/LlLkOfo1ZsQe8Vrrg/S/+M/eAPkOXAYT034wu8/HKRP\n", + "PIcnV3ztK9+CmCclmw4GbGOAa68yc9QvhReSbk6dwL2I22/geD7GbpbPcd47+FdizJP2MZY59/Nq\n", + "DcdaXCH9xfV95pTPxzbW8bDolyghhBBCiBxoESWEEEIIkQMtooQQQgghcrAjmqgj1x4I0qPOOLDb\n", + "QV3P49/4DsTOHV8O0s9+GzU1p589D7GrXxyeuP2zH/1pyLNrcRbvdRz1VR4mLSo5nUS3S8zMSsT8\n", + "rhg2T7PRgjyj4+G74m4H3y8XSDOX3EndRMZA6biMZWJwODqJz7JrT6il2t/bA3k2lrcgdvHCSpBu\n", + "bKBG4vRTSxAbdZqo8elRyMPo9sI6ftHLr4E8X/vyNyD2p18J++er3/gSyLN0Fo0DV5dD7UZETCz7\n", + "REtRcLGY6F4YVX8aekpMM6n4xuUjxoHEE5DInZgGA++FUp/tn8/rKMzQ6PL5OznDUXbSe4rl7Hj9\n", + "CNFy9IhusePMIZkxYjTEAKTGmqS/eC0Ty8NuBoampD6Z+MZrTFKi+RxOsYe5pqbHIVavhRrT0ydx\n", + "jv/yF/8MYsefPRmkb37zKyDPNdftwzK4ueRrD+F30XPPoq7W4/VBZmb9PqkrVw1Fol8rOwNVr5Ey\n", + "M4vImPH3Yvqgfg/n2GJ5+/FHHgVMpHtEN9XpoOazWgmfr97FMjED7igK+3pKTKyZEC2SJkoIIYQQ\n", + "4m8WLaKEEEIIIXKgRZQQQgghRA60iBJCCCGEyMGOCMvXN0Mx7cnjp4J0Yx0F1L0mCtKKpVDw99JX\n", + "vxjy/JP3/yOIHb5hf5B+6vFjkOeL/+XLEGtuYLk8WYblrJTDam43UOzGDNX8CfTNTRTcj0/WgzQT\n", + "rUfkRPqiO0meaB4pTSeSbbU6+Hnk5OySEz7XiXna5EINYiNTofldu4F1sEkE916L3VxtQB5Gq9kM\n", + "0rtmcYPB4SsPQOxrXwrFpq+5BYXlh6/aDbFOO6y/sSk0Be10tu8vaYqCZsaIM6gbEBPEHrmXb1Hm\n", + "x2fGzC4jH8B7M1E1iM23P2WdmQSmpGMXnYg0GhAxPylSpx2O7U4PBbGtFsa8iaU/2d7MjPiEAkUm\n", + "ECd401FvEmrGTR4zN2iiPvYDNk30nXg3IYJ0sncASMl1xRgLOjUdCorro3XIc/I4is2PPRVuDLq4\n", + "9EeQ56ZXXQexw0fD74urr0XxuZE5D7KQ2IAKu8N6YBsRKlUnvB7B+bTbxvbz4zEhanAmdh+mf8bE\n", + "LDXpbT9m2h2yGaMTfmf2EjK/RVgoL7jPyNxCv+rorpjh0C9RQgghhBA50CJKCCGEECIHWkQJIYQQ\n", + "QuRAiyghhBBCiBzsiLC82wjFtCMjoVBwftc8XDMxiY7T9elQhFsZxcc5t4Qu47//0VBQuL60AXl2\n", + "70UR8J696LLtGRCBWuyE5ZuNJuShjtruXq0tFHF7kWWXuL9WCihMjJ0wcQhd5PPXOeEeu6xIBMY9\n", + "Jyhc20Ix+FYbRc4VJ0iv1NANfbyMYuw0ca7UxEWZ4kTGa2trkGX/Fdg3TjrH4me/i+7545NYzpWe\n", + "O20+IwJHUskDfxr7kH8PVZ34s9PB65IUP9BrWzOSh/WFge97RCQ7IJ0vcjJcKj53dPuk3Ewg3g3H\n", + "UZ+oyHvEjdw7TidMgE/c5at+rBF3+WF0rSXiXF2MyUkHsf+8IQT/hJRUXkKez48tL1A3G05YXiyQ\n", + "vkgExc1WuLmkWsMNKVdctR9iI2OhAH15CU8Q+PafH4fYRff9cOAgjv+ZGXRW9/gxa2aWkHmp54Td\n", + "5DKL3QkXY2P4/VGIyCYH1xd65PPbZB4epNvPLyNjOL91ndN41MG+2G6SjWRufok6bHMUbjKq18Lr\n", + "CiXm2o5lYBtQhkW/RAkhhBBC5ECLKCGEEEKIHGgRJYQQQgiRgx3RRPl3p94zKxnge/CzFy9ArH82\n", + "1DY0iYnloIcvlBd2hdqma6+9GgsZ4TvSRhPfwQLEPK1UDE8dbxNtU51ofRJX9gZ5vmo1bMKkh3VX\n", + "iisQ8wqWlL14J/jT5jOmmyB1V4rDcrJTs4nMxjquPvtEXMHUHWAwWBzunXfs3pd7LZeZmWWoaZtb\n", + "3OWuQ01N1MFY2bVfPx3OiNVrKQpDGjHG7l4lohkoG+mLvt6JgeuAqKJ8O2dDXgcimmj7v/cuLqO2\n", + "kchzrO0MYpnOhxkcFl2fGh1Fg8OI6C18HVcrOO0OY/WXkrpjVeeLXmJ1x9w2XYjpmApEt1Rw+iqm\n", + "bRoMIYqKiQspaz+vLWps4XisjaJO6sDBcN6fmBiDPKtrWxjbDOeA9MQS5Nk9O4EFdVCzTTbvurpK\n", + "e9junW44lzBtFevX3sC5T+7dbuP3U5HMCZ6RcazP2Gmi4iq2C/suaDndW5sYv/Y3UUvVcbrIEjFr\n", + "rVaYjjD/Uki/RAkhhBBC5ECLKCGEEEKIHGgRJYQQQgiRAy2ihBBCCCFyEA2GUfy9kB84hMmbEEII\n", + "IcQPCpdbKumXKCGEEEKIHGgRJYQQQgiRAy2ihBBCCCFyoEWUEEIIIUQOdsSx/J+/52eCdMW5hc5O\n", + "o/vr9AzGppxDKjP03VhHB9pWK3SgXV1Bp+NWC11bvbDsl375FyHPv/gX/xpi8wszQXpqEk/8brfQ\n", + "qfq5584G6fV1LOced++ZGTzNe4a46S5dWg/SK+v4vJ/8xL+F2G3vuy1IM/flYhFj5Wo5SNfIdeUY\n", + "nWsHbpmfEkf4hMRSdxJ6p41u4Xf8/Icgdvtt4fOVSsypFzdHRC4WEddmxiDafl9HMkDn4YF3jid5\n", + "Pnb3PRD7P/73fx7em5xe3m4zZ/7w+SbZGJ2dhNj4RHg6QZk4Ayc97PtpEjoUJ31svw/ceVeYvv02\n", + "yFMs4ecVimHblMlpAXQDjOtm3v3ZjDv4ewvxbp+4tpM+/KGP3B2k7/uF+yDPxmoDYufPLAfpSox9\n", + "cXFxFmJF1xfrI2XIs9ZAB/+2N5MmfT8iotyP3f2RIH3r++6APIUS1nFcDtur28G5K+ljn6rXwucZ\n", + "HalDnk4X22HDuZjHpL9UqngqxIfvCueX226/HfJU61jHfoyMjuC941roll8ibu+dDo7jdtePK3QC\n", + "7/WwD/s+e+9dH4E8d95+K8RSOIaCOd5jzJehR07i6HawjVvN0MWcicGrpK3K9bAv/Mp/+AXIczn0\n", + "S5QQQgghRA60iBJCCCGEyIEWUUIIIYQQOdgRTVTF6Uwmx0PdxNx8qPMxM5sYHYFY6vQcyxdXIc/S\n", + "EsaWnR6o0SSnVhO9w/gklsHTaqNmoNMLYzHRAxFJBLzz7RDdVLkcvt8tkVPkjehuWp2wTO0Oak4Y\n", + "XacZ6BNNTZZhOaMofD9fq6KuIC5j2cuVUDNQLmPdxTHqCoqxO807G66r91xbsXfqXv/0POHfI0xT\n", + "w5XGl+gAACAASURBVNRPJafZYRqQiJz07rU3WYaaAcbGZqihabZQN9HrYV8YqYenrxdJPxsdwxPa\n", + "R2ph/yyT61oJfh7VFm3DFhnHbFylTjxZLBIt3oC0n9N3pESHlpH+EjutH+s9rD7h3kT0WSX6HN/R\n", + "ekRPxgrhtWKsBTpdvFcvCT+wXEPNyWCY/kn6fqWC92o0Qt1Ls4Fa0SmiA53bFerAmJ7s0tlLEBvE\n", + "YbnGZ1HTmpAx42k4vY6Z2amTFyC2vBQ+z9oKlrO1Gc6xlRjraXoONYoTU6H2pz6Gc+f4BNEMkfna\n", + "MyhinszCdi+QSZBpC32/rpDPr9WxnP66PmkXMmwt6eH39rDolyghhBBCiBxoESWEEEIIkQMtooQQ\n", + "QgghcqBFlBBCCCFEDnZEWD4+ERpCzjgjzZkpItwjgsaVi2tB+szJJchz+hQK9zadMLFSQXHdNBEm\n", + "MoNBT6+LomqvZGPGoVslFMVubYXlZMahcSlcB9eIeVuVCPC8+NSL9C9HxwnSmdFlkxjygSCViKX7\n", + "CROfhqLDag2fjwqaR3xse1NLM7PElYGJyJkQueREuUy4y8XmYbmiwhD3NrOsH7bXgMqVkY1GM0g3\n", + "XdrMrFrH+qy6Oh4hdV5jJnZOVF0hz5IQk9V+3wn1mULcQwSqWxsoyt104vok2d6s1QybtBSzzREY\n", + "GxkN66pGzBOr5F5YACLAJXNX0fWhDjGjTFMc73VnPjk6WoU8F1exvyROcF9hZrRMUezwhrxmZm0i\n", + "xt7a3AzSk1PYFw8f3Y/3Wg3r4bnvnoE8fSKAP3j13iBdq2O9bJBNDZ6rrzkCsdk5/K6bmAljRTJm\n", + "Wo2wDy9fWIM8K8v4fdFx5SRDhpr7DrMvgLWw36xgZMMG5Hk+6u6N15WIqfOI26DRJ5sqmLB8q4H9\n", + "bFj0S5QQQgghRA60iBJCCCGEyIEWUUIIIYQQOdAiSgghhBAiBzsiLJ+eDIXl486NPOmgiu38GXSS\n", + "PfbdE0H6uefOQZ7lNXSzrTvR8cg4nuY9OTM6VMyTEcG0FyIzwWaXPHPTiQAbW+guHbsTv4vE0btE\n", + "Yt4lNh1GuGtmo85dvttBEXlGRKveyLlDHNJ7Xbyu3Qrvv7mJAs6NDRQFjo6FdRyXhuvqiRMUsxPG\n", + "mUA8i8LrmOixQATpkRNVFsl1RSK89s70yWA4x3IvZK+AAN9semYKYrvmwlMExsbQvZ/VcakQPl9K\n", + "hJ5UxJ1tn8dz9XWHINYlG1L8aQTMKb9YwGdhjuGeuEQE4q4P+ZPmzcwS5iruP58oYqsVnEuK7nky\n", + "1IJbu4XjaHw87AtV4hJdJALxnqvjkREUiBeG2PiQpNiHV9fwxIm6mz+vvv4KyFMh7fe1rz8RpE+d\n", + "wO+L6191DcT2HtoTpBsbWKH9IebPp/78GYgdIz9jxNWwrnbvw/G474qFMH1kGvIsHsaTPzbXw763\n", + "fHET8mysYv9sk81CHubW7xkMyCYOdiJDGvapAZmH2Rj1luiFmFQw+bxCcbiNOQz9EiWEEEIIkYPv\n", + "axGVpqm95CUvsbe//e1mZra6umq33HKLHT161N7ylrfY+vr6NncQQgghhPjbyfe1iPrkJz9p1157\n", + "7fdeb9x33312yy232LFjx+xNb3qT3XfffS9IIYUQQgghftDIrYk6c+aMPfDAA3bHHXfYJz7xCTMz\n", + "+/znP28PPfSQmZn91E/9lN188810IVVxuoGkF74LP0eMw777+LMQO/ZMaJa2soK/fBUr+F5/bHIs\n", + "SO/Zvwvy7N4/B7GJCTRG8/R7aLaZuve7JfKelpmJNRqhBqrdRh3DwOlzmF7Ha0DMzCKnjfFaoMsx\n", + "604GZ6eX93qobeh0wnppt/Ede7NBDEc3wjro9/He7F18yemPWL0wvHloKUW9TC/DNk6isFy1KmpV\n", + "IvLevexMFmNiOMhOsveatm4y3CnkC7vDk+zLFdREjRHN3pgzjKyQPtzroJZi0Cu6PFh3XWIG6bWF\n", + "3e72z1chhpWjxBhxbNKZShLjUCbvaDhDvnYLn6VPzHY7rq8zA0lmpOnx88jz4PN5TSIz1mRzidc2\n", + "MVPJQgnbvdMOx2iaYn0WSziOPCvLOO9HpJ95DdTsNOqBvvT5r0Hska9+K0gffslhyPOy196ABXNN\n", + "89yxU5ClQUxdPUx3c/7MCsROP3c+SJ85hXrgtY3QSNNrJM3MZmfx+2r/4VBLtXf/LOSZJEbTIzVi\n", + "2Ozw3ylmZqnXEXqxo1H/TS8jtAHRA6YZxgpRWAYiMbVCRHSnRDc8LLl/iXrPe95jH//4x63wV4Sj\n", + "S0tLNj8/b2Zm8/PztrSEDuJCCCGEEP9/INci6vd+7/dsbm7OXvKSl9jgMor8KIqG/utfCCGEEOJv\n", + "G7l+w/qTP/kT+/znP28PPPCAdTod29zctJ/8yZ+0+fl5u3Dhgi0sLNj58+dtbg5fiZmZ/e7vPvC9\n", + "/x89eqXdcP21+UovhBBCCLFD5Pol6p577rHTp0/b8ePH7TOf+Yy98Y1vtN/4jd+wd7zjHXb//feb\n", + "mdn9999v73znO+n1b3/7j3zv31VXXZm/9EIIIYQQO8QLYrb5317b3XbbbfbjP/7j9qlPfcoOHjxo\n", + "n/3sZ2l+73W1vh6K8s6evgDXnDqD+qotJ9CsjKKgcXYBDceuui4UFB4+shfyTEyiAWefCKY9EXm7\n", + "6U9VZwK8ARHJDdzp6Mz4seRE+uz1Knvj6o0f2ecz6iOh2DQiIuRKZXujwiYR13aJAWfDic1bTRTu\n", + "tohxIHz+kGaivm/2EmxzVldF9+q6QNq4wI5Md41TraKAs1pDY0svLC9n2ws/zcyOHg0NKUdqOGaS\n", + "hBlihuLoEnlVzwwxG+1wbA8SrJcuEWP7XL1k+/757FMo+DUihK7UQvG+N5k0M4sMPy9xAu0+2VSR\n", + "dLG/+HmjS/JEhe3/nh0Qk8BSzIx0vYEr21iCn+c3bdRrOLZZzD9flmI549r2XzXMD/fI4YMQW1wI\n", + "NwI9+fBTkOehP/xTiE0shKaVb/2xN0CeK69Fw9av/MHDQfqM29BkZja/CzcneW54Of5g8MM/+jqI\n", + "7dkbir2rdfwuajdCw8+L59A089IF3Gi1cjEUsjebaBzaJps4BkMYzTKjYI//vnr+OhTF++8s9r1W\n", + "IH04G+J7rEDKyTZRDMv3vYh6/etfb69//evNzGx6etoefPDB7/eWQgghhBA/8MixXAghhBAiB1pE\n", + "CSGEEELkQIsoIYQQQogcvCDC8v9ems1QCLy2EoriLl5C59oWOY19ZCwU3M3Mo3Pt4asPQOzI0YNB\n", + "emIcRWVd4qi9vrz9WYBMIFp04s8+EcmmRPhcKociPOZ46wXTXEBNXMy9wy1TxBPiUnivSgUdtiem\n", + "RyE2Ph6Ko+MYxYRJQk74dmJe7+JuZtZiTudboXC9uTWco3fmnHF7RDxsRLyYOqE305B7Mb+ZWdkJ\n", + "ySPSfjFrd/f3T4G4dTPm50JxbYU4HXeIg3i7GZaLOY9vbuBmgZXVcMx4cbYZ3/jgHZhLQzzfysoW\n", + "xLrE4d63KRNes7FWLodl8n3azGxkBGNxOZxfiLbWOkRc72Gi2WKRbDYhMc+A2ET7jR3e+dyMbxrx\n", + "04vfRPJ8lu3nl6mJMYyN4Vxy/IlQ2P2H/xndyftkrL39XaGI+1VveBHk+e6jxyD2x05YXi3hnDe3\n", + "ewpini8+8AjE2qTd/f6h8Wmsl8nJsE+Nkr5Yq2DMt3u3g23V75PNScPsyyHfIQO3QYPaSpJNKv4U\n", + "CnYqhb+3mVlmfjMW2VRB5uZ4iDFzOfRLlBBCCCFEDrSIEkIIIYTIgRZRQgghhBA52BFNlDfXXHan\n", + "d7eJDsXrn8zMJmfCU6oXD+6BPIsHFiA2Nha+T2428ATutZUNiK1eWoWYp1xBwUPZ6TnaTXKCOtGY\n", + "jDhjy3aTGCq6d8XksGtq0ld0op1SYftT1s3MLp5fDu9DtE2bW6hN2bVrwqVRQzBK2tjrycbG0Bix\n", + "1US90+hWmK/THs5ss+AEK1mP6bQw5rUGvT62Z4HpwFJnVEh0L0znljo9QGkIozszs7rTsBHpjxUq\n", + "2M+yXvg8G2vYxpeWcXysrod6xwH5uy0mhpF1ZzBYrm+viUr7RKtG2m/Daae2iM6usYX6Lq9zqxET\n", + "xBFi+DvmNJeTE6hVGeYUeaZRYjGvNxzGyNPMLEu21x+CYMfMYqcV6xPTVVZOzygx8ly5hCaSj3/z\n", + "mSDdJlrK1/zwKyD22rfeFKRXL6HG9fc//QWILZ2+GKTf/D+8BvLE9e3nz6PXHIZYcwvreOl8+H24\n", + "fBLr4PRT4TzMNHxVMmbGpsK+NzmFfbFex/FfLOTrn56U6fpSpvUN86XkOywj/Tp2jq0DUqaUmAkz\n", + "neuw6JcoIYQQQogcaBElhBBCCJEDLaKEEEIIIXKgRZQQQgghRA52RFjecUaWXjLGjMOYkebUVCgs\n", + "n5xCY7ZqiZjKtULR6MYqisjXiOiwRQThHiaSjZy719YmnpzdIuaeXkzf6WC9eHOxhJyg3iOGgx4m\n", + "TGRcOB+KLLvEBLVPhJ7+FG4mwJ2ZnYDYhDPgq5PTtpmJ5cC5w8XEII9RrYV13E6x7rIEY4mLsVPH\n", + "S33sG6m7rt/H+ux2iFGoM4eLhjSLS1xf8P3HjAvnvRFjq4VjodXGWMd9XlzGdmBGod6ENCZid0+N\n", + "CGLHJnBOmJ4K+xkTQndIv06cSL3VwnbpE9HqYBC2TbdHxLXEoBJvhGOUmcFGbjywzR8lImT31/XI\n", + "OC6QDSixMwX2hrV/cSWJhaTEhHhteQViPTdmrnnZVZDnptehkWbm6uqPfudLkOe7j6HZ5stf/dIg\n", + "vfvQPORZWl6GmKc6hnWw+xBufHrlG64M0pUqznlxHPZ1No631nFzhN8c1STfO12yySkl48HDNjBE\n", + "mc/DTDMRb7ZbJv2HzRuJm7sGbFyRcRSVZLYphBBCCPE3ihZRQgghhBA50CJKCCGEECIHWkQJIYQQ\n", + "QuRgR4TlmXMfrdVCkVy9QIR0xAm8Vg9FquUY14R9IrxsboUO5RcvoNMyE41mQ6w5yxUUznpt29oq\n", + "OqRT1+3RsB6SBE/z7g/hMlytYjN7R9ghTY2t5ESq/vPNzJI2ChMbjVB0fGkJxfzPPn0GYnEc1ufk\n", + "JIrrp8gp52POFXpsFN2lGSXneFsignTmzNvzMaKW9P3eDIXeHSLOjqioMiwnc/RlbG6Ebt2s2Qek\n", + "8Jtb4WaINhG7E72mVevhBgImLGdjpuo2EBRL2ztCT0+PQ6xSxw0MExNhXxgnG1lKZZxvvPN/SjYB\n", + "NMjmk46bg/xYMDNrEedqgGhke0Tw60+pr5A6LxKBeGThhaxMXbKhoOJE6kWy0SNlncPRJvOGFwqb\n", + "mY26DUT7r9wPeWLSX/70v/5ZkP7mn3wb8lz3oqshdu1LjwTpzQa69bPvC8/SeRTJHz9xFmL9Tljv\n", + "CXHTTty8OyAbirz43MysPhL2hSoRrRdL+H1RHsKxnM1BaRr2zyLZc5CS0xZKTujt+7SZWdobor+Q\n", + "DT6RP3rAzAZyLBdCCCGE+JtFiyghhBBCiBxoESWEEEIIkYMd0USVnHbJ6ySKxPixGGNspBbqFmJy\n", + "wnirQQzHVkI9ToPkMfIOOCbaDU+NaCmKTmuQdNCssddmZmbhdf50djM0a4yIiV4hwusqzqjM6xou\n", + "x7jTGo2OYbt4E1QzM/+6nJl0tprYDm1nBpcSA8C1ddQodLvhdf32EJoTMys7DVZWRU1NRgzcwICT\n", + "vcQnuhCvLSqXUVvhdVpmZgX3rn9A+j7DG+l5k1AzMyIZAMNPIjWw+gjWVcXVQ7mMOo1SCceMN+5L\n", + "hzghvlzGOkj62KcuLof95RLxSYyILmzg5qUqeZYC0eKUnOaDXGZFogOFPKRPJT1sv4EzuyxViCaS\n", + "6FdAF0L0jnVicFhzRqhdMkaTIdovYUJCoq9a2D0XpEdHsO6efeJZEnsuSC/u3wt5bnzpNRBrbIbf\n", + "F8vLa5AnrqGuzlOv4fiojqIZbOTmiSKZvz0llifCduj7eWOA83BG9EFeD8goFLFveHFoZMRolsxv\n", + "A/fd1yemx2zG82MkInorOjcTjeCw6JcoIYQQQogcaBElhBBCCJEDLaKEEEIIIXKgRZQQQgghRA6i\n", + "ATtu/q/zA5moSwghhBDiB5TLLZX0S5QQQgghRA60iBJCCCGEyIEWUUIIIYQQOdAiSgghhBAiBzvi\n", + "WH7HHR8I0t6dmHnbbq03IJZ2QxfTvXumIc/EBLrZbmyGJ9JvkhO4iyXiTu408ffcfTdkufOuu/Ay\n", + "J0jb3NiAPAMiuN+1ayZIV2r4LEsXwpPB280m5Bkfq0PMn97d7qCj9333fgxi7/m5nw3SzE27HGM5\n", + "C4XYpfF52ZaDknOOj4kzb5E4gZecA22tjm7BP/2efwKx973vfUG6sYX1yZ754ME9QXqM1Pn62ibE\n", + "NrfCvre8gnnaxN19YjSs47FRtMG++557IPbu/+2fBulmE9t9cxOf2TvMFwr491ccY73U6q6cpF7q\n", + "dSx7zcUqxHX7no+Gz/fhO2+HPBnpVQXnYpwQZ25mnu377MDQEToqYr1kfXeqADNMJo7JH/zwR8P0\n", + "nXdBHuY4H8G92Kn1xHXfzVOs7qISPl+3H/bhra11yNMiJwb81q/fH6RvvRXbr1zGMnjz6siw7grE\n", + "vX51eTVIH7lyEfKcefYixCJ3wsbEDM4lW1vYh/7tfeH3w/tuvwPyFCPsaOjqTdrBzXkpuU9G2soq\n", + "YaxExl65Rk4QGIT95YP/9P2Q544P3gqxgrtugrRnkQi2250w31aC3ykpGUelKKy7QYTtkpLvC+/g\n", + "/wsfuxdvfhn0S5QQQgghRA60iBJCCCGEyIEWUUIIIYQQOdgRTVSWhS+1i8VQfxSTk9DjMha1sR6e\n", + "0H5pGfUk9RF851t1sfUmnvTe76JOqlwmOilHlqLWYGMlPPV7dBJP/N69ex7L0A/f3T75zacgT6sd\n", + "asWue/GVkGeE6IEuXgj1AexUd4Y/IZ6JR9IMdRpJGmpq6MnkRCySRV4AgdelpOx9V0x2ejgjroRt\n", + "3FvFPkXkJFZwfbZMNDxML+PrLyE3Zyeo12phHx4dxTZmECkT4DWKZmZetsD6C+tCSRrWe7+P+q5+\n", + "gp9XycL6y7Ltp6o+0TZFBbwudaKaJMWCF8kcNHCn22cwFswGKetn4f2LEavfYcYfKSfRFvoxSp+v\n", + "SOZY1z8zptchfTgdhPcqxZinOkCdjadENDxMu1Vw9Zem2KfG61MQe27tbJCuEO1PIcZ66fXC+ozJ\n", + "8w0yLAPcm2mbmPjO94+M9DO8EYFc5/RAdF4k83e/12Ef4K7DtvJ6pwL53SYh43+jE8baZN4vFdl4\n", + "8DGiiSTzW4Fop4ZFv0QJIYQQQuRAiyghhBBCiBxoESWEEEIIkQMtooQQQgghcrAjwnKvm/OaMW/Q\n", + "Z4YGa2Zml9LQtHJjDU0CW3MTEJudHw3S4x0UBa6v472GWXI2GmgKOjkTft7CIpq8XTy7BrEn/vxY\n", + "kC6VUfz22lteHqTrNRTSP/HoMxDruGee2YX1xPD612KRiDOJyDFx4shkwATU+HyZEwaXytg3mODW\n", + "i7G7wwgjzSxyYtp+HzveoITlrNVCQfrIKJpKbm5i3zAn1O20cUNDp9ODWFwJjVirxDSP4Q0jC0Um\n", + "vMTrfL0wYTITFBMNNbk3EUe7tDeCZKQkD53g3Mexz2c6XfDoGwwnhPbZiuzz2EYLR0rGBxMd+w0a\n", + "zNyTuol6ETDb6MFEzk5MXyljX4zj7YXlGSlTgWziGDjj3mYX585DM/shtnJpK0hXa9g7YmIGuXIp\n", + "HJNX1GchT5Li5iQP68ER+1LxGUkW2L9A+n6RfmGFz5eR7740ISJ5tpvGUQJRt1nVzTdV8n2x0sY6\n", + "bzix+YB8qVSYHzZshiDjES8j1w2PfokSQgghhMiBFlFCCCGEEDnQIkoIIYQQIgdaRAkhhBBC5GBn\n", + "hOXe2tiJ1gpFFC9O7RqD2PkzobJs6dQlyDM2MQqxKSf0npxAEXBzi4iAk+3Fdd4N3cxsanZXkH7u\n", + "ydOQ5+TxsxDbtTgZpF/6iqP4eU6Y/O0/exryNDZRHD27MB2kE+K0zvDu8sUCOfGbiPRK/tTxAXHF\n", + "JbsHvJg2JsLEEvlbIHJCxIS4SzPSvhOkd5kTMQ6bgmsHnzYzy0g5e/2w3tfXsd8xYbkXWjNRN8M7\n", + "cY8QQfqAOWMXvdMxCj3LROkZl8P2qlax/WLiEl0qhnXsBfEc4qJOBLHgyE5F60RU7ccIU2wTVX7m\n", + "+jUxELcBdbN3H0f6MBObFwpFlyafR+7lN38UDduFib+923qJjFH2eZCHOeUTkXO9GvazixdxzEzM\n", + "4PdFY81t2iBC6PFJdP7/zqPng/TY5FWQJ0kuQMzDujDveWE/Y3XnT3wYkB0cbMRETpGeEpf/FKcb\n", + "i4Zw9C5HONaq7vthkGE515p473W3D4js07EC2XXgxwgb2myoZbBrZHj0S5QQQgghRA60iBJCCCGE\n", + "yIEWUUIIIYQQOdgRTVQvCTUCJaehScip3GPT4xCb2x9qjU4+ew7ynD5+EWJ7F0M90NQ0vgevEX1H\n", + "gxiTeeojqME6dTx8X762ugF5Dl+7ALEDh8Pni8k74NNPhzqwbgNfAldqaFDZbIXmcKXy9mZ4ZmZF\n", + "p7fgPn4k6g0ASZ4SM+Tz8jnycSkz6XO3Z+aewzAgWrEBPZE+/ECvBbpczJeTmW0mRItXqYT3KpW2\n", + "N2s0M6s6U1BvEmpmViM6qX43HCODIU9H9w8Yk3IWiHEnyI2GkCwwzVBUwHuD5ovqPbBPeR0Y1VuQ\n", + "Z/EGnJnXhBrX0MHnM+dSokMZuFGSEhFWgZh7+vsznSTxFwWzUq/Jer4MeB2WCRs5zXDOrbh5otnA\n", + "PONT2K/7bmhtbuJ1i4dmIHbp7CNBul4bgTyD0vZmjdTAlWrawkpmZrB+jmU6RjbHRk4DVSCf7/Wk\n", + "z5dhe01UlWjMyqWwrTp9XHIsNVCE5a2RZyvEbJNop735bDqs1mlIzSxDv0QJIYQQQuRAiyghhBBC\n", + "iBxoESWEEEIIkQMtooQQQgghcrBDZpvh2i3thYK0NEHTxUoZxYqHjuwJ0qefPQ95Tjx1BmIXzq8H\n", + "6alpFINXKiiu7Q1xkvXWRhti7XYok9t3CE8B3zWL4u8RJ0ROGlgH546HIvUzZ1fwPnN47yNHw7qb\n", + "2TUFeRheqOuN9i4X8zBDvigjBodgnkbM4Yhkc+DKmQzRds/f35WdiKWZgNqLo0skDxNV+1Pcez0U\n", + "WTJhqTe2LBHDSsbISOhax0wsC8QsNXXliogwmZul+nszE1IifGYi9W2ghoPsPt5UklzHyunboc82\n", + "K5C28k/HpK7s8zAP1jnTo3thuR9DZrx+I3eztI/C6wIx4PR9vVAc0lUS8rA+hXVccHNHt4XlLKGu\n", + "3Kqj4Zx+9sQq5HnRS2+AWMsZLyddIuIeor8yQ8cic+B0oZRtRPC/f7B+x8TSfk8FKROfv7d/vjrp\n", + "jKnbhHNhC69bbeHnTU2HS5PRGuaJyTzV92VnVUAE8GxTw7DolyghhBBCiBxoESWEEEIIkQMtooQQ\n", + "QgghcqBFlBBCCCFEDnZEWO71bu12KMaOq+S0+7b3MDUbmw3F0Fdcsx/ynD6xBLFTJ0MH8cV9/x97\n", + "7x5s2VXf+f3W2nufc+65t59SP/QACzBtIYE12IZ4SCjMMC3PeMYeykMpg11lFZ6Kk8IeG5sBCYEw\n", + "IECNMUQxtiszHuLSjCsGqpLBpGqKOEplGKeCwY4cYwJYGCShV7cere6+r3P2a+WPdlFZ39+3OZtt\n", + "7Cvw91PVVdpLa7/WXnuffc/5rO/yondR+WMol6vl3eXSi+XHr8hnFL/ssJ+Sen3uy5rNXMr7/f/5\n", + "j12dP/q//zxbfulJL0aefPVLXdnhQ7lM/+n/9KeuDgOVvJ5IiJGl52JiOZ3SnEiO0Fc68/IyC9Pt\n", + "UfodIraaWQKJc1L5W4QlMhus15LZ0ZcLL43XyzxGOaGJbWZGUrAxOb5j6xEmkHTOZHdMQ7+4g7zd\n", + "CyLS4kwEZmZ1k18HNmv8ovZicMK+MODPPdanejKgAGXasvDXuCBlTcqPM5L47p6kg2NCOV47M5+G\n", + "zmA1epI4jTBpncnfKCIz13aIfsv6cEmkeHdM7CZlgn+R14udr7O7veXKjj87/7x4+MGnXZ21uR+E\n", + "M9vI+8L2pr+PK3KPIoGcH0v+R7GbXT+3JSKRsxTzAi4qG9RBH5UDHi+BvE5sLvL9ndn0z4g49ed3\n", + "KP/ItFnh1+trX4bNwAblUN+eyPtD0TdRQgghhBAj0EuUEEIIIcQI9BIlhBBCCDGCPXGiKgjOPH8u\n", + "94jOP+09hgPn9rmy+f58Nu2jVx5wdY5/11FXdv5M/lv4E09e8Ps74L2QOCBEcv/cN+mRw/mxp9a/\n", + "u37l80+6ss/+wRey5fu/5sNE/9nP/YNs+af+xT90dR5/9LQr++i/+d+gjm8Dzuo2wLC/i4VwzuQ3\n", + "aDajOboi9Ddu4kn537iHhakV4IpMJv56zma+b6Bi0rXe82nAf2Lrra97JyOW/hjQZaI+CQF9p7WZ\n", + "D5VdX19zZQVsn4V0NsSFWSxzf2Sx49uATbTegls0zFkYFirpgvWYJEGC/AK4KWxme+YIoifFglhj\n", + "JB4awB4/GNZ6cWP5YkHajt0N3YBA2kDapQUXjrlUJUsFdZATJP5Y0+f31sb6uqtz9snzruyyK3IP\n", + "9PRfnHN1tje9e3v5lfuhzo4/zCHhsKxPkVNGl4mod64vDPXX0MHqWNAt2SEL4EWa3q93bpHfIy1p\n", + "p/0b/j7aN4O+2JMgX/K86SAMdnCEJnN0h646ek0hhBBCiL/F6CVKCCGEEGIEeokSQgghhBiBXqKE\n", + "EEIIIUawJ2L5bJ6LgPP1XObb2fJBaWcf9TNur0Mw2qFjl7k6J6692pV9fjeXW88RUXBtvt+VFeVq\n", + "+fPI4UOu7OyZ7Wz5kYe90Hj6tC/bfzw/hrf+0j9ydV75j2/Ilj/7qT9xdf6HD/4vrqypcwHvHsR5\n", + "dgAAIABJREFUFX//Ja7O//TvXZETZ6nvS0RdDJobOms2zo5ekOC5hojleAwoBQ/dH5udnQUVtiA5\n", + "NiQIjomQKHpOiLQeK1+2hIDK2dQL4ozpBMTyNS+yr8+9WD6tQGQnYZQ1OeeigPDZngjpLQnEhPPr\n", + "BoitbedDEGPh2w692brxgwAiOaYE4mxL6vREZS3LSbY8KXybswBOt21i4MforwNW6xIJKiTHziRj\n", + "fwzk3gYpl93ZccC4gNT5Y6rIM3cJwctzIpZvnt12ZfsP5tt6fOLv7adO+8+CwxCWvLXrt10OCNtk\n", + "wZrBiMwPzxw24IYN7HD7Y+HFKKST71FYP0urT8/qRJ4JsL+y8ueyMff7m4W8XViAa6ICPJSxoFI2\n", + "kmW4gu73OXpNIYQQQoi/xeglSgghhBBiBHqJEkIIIYQYgV6ihBBCCCFGsCdieQsC49pGLrLWC58a\n", + "e+GcF/6eOpPL2DOStHzZ4Q1XduhIXlZ3XrzcXnjZdD5b3VyPn/FJuU89laeBl2Sm8O996fNc2TUn\n", + "rsyWLz/iz+/f/vonsuX//d9/xtWZz7wk/4//6cuy5WI6LPF6WPYxSxXHAiJZMvkbylgidNf5sgLE\n", + "S5wZ/VKgwMhmZ8cUdTOzrc1cNo1EwF3sePG5b3KBclL6/ZUTL9c2y3y9neDvGUYP59cTmbegidp5\n", + "32diuQUiiIMQjonwF7ft94fJ9EPGISzqXVfWBX8fuzpEso5x4sp6lOJ7f62qau7KJkUu/Vdk2yWL\n", + "pQaYBNwR6RjTl9PAQRzYyOye6dhIkoT3DEvYXz0oh81GwIR7fF6X635QxfaWf6aX0Pc2Nvx6Zx/3\n", + "0viBA/nzs63JAIYh14+cHxuI4J+NLLLcbX3l/i9uGqR1OlCApZiv3nbN+icsz6dEIo/+WgXoe0yu\n", + "NyPPZmjjnq5HPnuobD4MfRMlhBBCCDECvUQJIYQQQoxAL1FCCCGEECPYEycKf2ovJ/lv0/MN7xXs\n", + "kEDMc0/krtH+fX69tQ3vRF1xPA/EPH/Bzyy/bPzvtDGy31dhvdavd/TqI/kxzf1v8R1Z7/QjZ7Ll\n", + "z/2xDxx97KG87Hu/70WuznXf+xx/nE0eaPrAVx5zdRguiI14TCxIE30nlhXXslnkYX8x+N/Bi4Jd\n", + "l/QNFy8JOB8sjHJt5q/f+iT3XKhLlcj5wezk04m/JcvKlzXL3MtoSbswOnCwcNmMh2YaNHFJmpzO\n", + "Gp/QUSC+BVkTQ/N6PADCDjnuQHzHHq5DQ+71MnqHpyrz6z6b+JDHggSjTmC99em4sE3mqtGw27D6\n", + "njESXtphkC7ZOPOk8KhYfy3K1R81HfHzYkk8IvQIiW7V1SScEdzJ+bpf8fzTPuh5PstdVHbP9MT1\n", + "Q5rWtx1/Tqzu6xjcyVYh3cXwQUgfi+QaM3cK2SWOUgOeZAx+O1VBTFt0mWhYMjl6WI8Gv1JHcOgH\n", + "BNne6DWFEEIIIf4Wo5coIYQQQogR6CVKCCGEEGIEeokSQgghhBhBSENTCL9VOxwa/CaEEEII8Qzg\n", + "Uq9K+iZKCCGEEGIEo1+izp07Z695zWvsBS94gV133XX2mc98xs6ePWsnT560EydO2I033mjnzp1b\n", + "vSEhhBBCiG9DRr9E/cIv/IL9yI/8iH3xi1+0z33uc3bttdfaqVOn7OTJk3bffffZq171Kjt16tS3\n", + "8liFEEIIIZ4xjHKizp8/by9+8Yvtq1/9alZ+7bXX2qc+9Sk7duyYnT592n7oh37IvvSlL+U7lBMl\n", + "hBBCiG8jLvWqNCqx/P7777cjR47Y6173OvvTP/1T+/7v/36766677MyZM3bs2DEzMzt27JidOXOG\n", + "rv+2t9yaLVeQVN2ThN269ynRNUSysuTqKvkZt0tIXw0kmbc1n2a72+cJxR94/22uzpve8RZXhm0f\n", + "yPmxQFg8rEBSjRNUSiSJOJLo2s4gpZn0j7ve+R5Xdttb3pqv1pF08tIn+mLgLGuDuvXrVVW+/Yak\n", + "Uretb7yDhw5kyzvnL7g6p37l/a7so2/88Xx/M98wX5r4BPgvVt+dLT/VH3V1ji2fdmUvaP8iW15P\n", + "/jjPFwdd2QLuh4PB/3T+tvfe5cpuu/WXs+UykBnpSRx53eVlDZn1PJFr6v9o8n0R+7CZWYFZwyTi\n", + "/n3vuSNbPvW6d5P9uyJ/j7D7kc1OAM8XTD6/uCmSKj4gJZq13dt//fZs+U1v98+b2JO09z7fVmhY\n", + "HfJMgHs5kATqjhx9mkA7lCQlvvJt9avvfG+2/Nbbf9nVSck/h7sW0+x9HZYOjs/BRFLwE0nULgs8\n", + "9sbVCdGf8/vfnffHd97yRlenJ/2azmyApPyjO/X+WrHPMCzrov9cbZN/LahTnrL/m+//WVfnp3/V\n", + "Xz+DJPeO/PbVknsGLrF1pC8aSTrHD9KCvPiU7LpD0vn/+LN3uDqXYtTPeW3b2r333muvf/3r7d57\n", + "77X19XX3010IQd86CSGEEOI7llEvUVdffbVdffXV9pKXvMTMzF7zmtfYvffea8ePH7fTp0+bmdlj\n", + "jz1mR4/6v8bNzD71B3/w9X8PPPjgyEMXQgghhNg7Rv2cd/z4cXvWs55l9913n504ccLuueceu/76\n", + "6+3666+3u+++22655Ra7++677dWvfjVd/xUvf3lewCaeFUIIIYR4BjPqJcrM7EMf+pD95E/+pNV1\n", + "bc973vPst3/7t63rOrvpppvswx/+sF1zzTX2sY99jK6LOkVf5IdR9/6wdoP/7XZRTLLlGP1v1Wuu\n", + "xGyj38mWJ4HMHk48jTqubi4mn4WIM26T33LJL5/4c3mf/PkVVf5bMc7EbmbWB/97fUK3YfUk3ZQQ\n", + "iXtAZibv2/wYevNtnsi2AngMVeF/549EKEswI3zXDTvBBH1hp/A96MHyClf21fK52XKz9P31RPOY\n", + "K7umfSjfP/GRHu6vdmVPlYez5SrsujqMBmSDydRfq0g6A2oLrDmJJuW+6qZqJvvZf0R/jOQACnZQ\n", + "QEdcSqL6WQcORiJORkf6NTYenUOePRMAcnsYU7esyysWrX9uVaS7FC3cW8SNackO8W/gbsoc09Xn\n", + "1/b+3u7JhejgcdZhgXkP1cwswLHT/sqeQVAvsSuI0ichkH7G+n4AX5U93wLcIG2cuDo9a8+AnxfE\n", + "OQv+uqe0+vw2Ou9Xtj06Uf550/T++lVwz7TsXuvYtcrLAul35BFrRtzCoYx+ibrhhhvsj/7oj1z5\n", + "PffcM/pghBBCCCG+XVBiuRBCCCHECPQSJYQQQggxAr1ECSGEEEKMYLQT9VcCJLwGxMQmeNltGWau\n", + "bMvmsF1vjC2JHIkuX+y3XJ2CyOYVEbQdRAKMIOrRgDWaCgiSHAnkQ9u0I/vvmbzo0y/9tgmhQMuS\n", + "BZf59ToIMysqIogTeXBtLRe0z2/5a9UTixTD56oBgwLMzDZjHtJ5xg64OmfDZX7FJm/P5yxOuyo/\n", + "sPM5V/aSNi97aHaVq/NHEy+3b8a8rBsgtpqZRfi7qSDhrJMJCRwEYTrVvg4Vg+ERg93HjAxyuHig\n", + "3zSBBEiS0zN0ZDtyP7YYIGlmzaxfWacjz6AC7q1AEgcDkb+RRExodn4RBg8US7+/2Q6RzXdyOTl0\n", + "JMCxJANu1vPjqslxsmeQ2zZpl0RCMwN0jkj6PtsdSses3xUkmBiDGOkgoAEfpZEEciZyoAUERBfs\n", + "gQrP/YYMxmKN0EHn78iArbYnkvqA61d5r9ywOVv2EUYaFIdQ9aROTyT1APcfE8sTEdLpAI2B6Jso\n", + "IYQQQogR6CVKCCGEEGIEeokSQgghhBjBnjhRCX4aRmegMv/jKisrYPLEmrhULXGp6naZLfckHHJi\n", + "C38MvS9DmLfU4e/65AdYNrkw/vjOJhJu0d0i59KQMLoC358HOlHJ/T5PfBKyPzy9UBEXgPkI0HZn\n", + "Hz/v6hw+ut+VVdO8L9Q7w370frrcyJafjIddnY44A1fWT2TLL13+mavzssW9ruy7Qj5J91ea57o6\n", + "O8XclWG7B+LwMVrwhnrir0yIm1Y4F8bvb5tMdNujp0T8IxaS6cMnV4c1Uq2QhCdicF839X1jd8Of\n", + "32KePzfamQ+/ZQGcBQT5FbV/7DJvCWFhm0Y8MJyUuCIiSkWcqPULeb2yJq7KxJdtQWBj7ybsNesG\n", + "fdIM8JHMLMKFTiT5FQOOzXwPos1Jt4VHudpf5bDnsL82BUxAjJ6PmVmfYD3mhbL7KuXPrt6I/0Qm\n", + "LkanlVE1JNgS2671bdAQ9y5V8JwiYbRxYHipW496hOOlKH0TJYQQQggxAr1ECSGEEEKMQC9RQggh\n", + "hBAj0EuUEEIIIcQI9kQsj6D0VTAN+EHbduscKi+4slnaly1vwbKZWU3EuQ4COJfmA8cKMrN0HCQP\n", + "EpkPwz1ZHbLtEiVxklSIvl9LtkODPLFsYFijCyojaX/JvKRXzXLBv+28fDohgZhb53ey5Z1tP/38\n", + "C5/1PFdW1/n264UP6WTsFnlfWEYvdZetP/Yr26ez5efVD7g6+8KmK3ukOJ4tf9n8uTwdfbhniPm2\n", + "JgPF8t0FyMPk76j1qS+bFPn9UEW/v0iuO4rPLDSP3Q9Yj0rVQEvuD3zWmJl107xsscbEci+N7+7P\n", + "y9o13xf7CbmPYVPFlh/sMiXPqWH4/fUJpVx/PUsSbFnC2J0JGSjArkMNAnrb+m3XLAwSYMeZku9n\n", + "eAiRDsphKasQXrzyiC6xKfY4HdA/A7s/2LMSQjlT79ugRyGdHFMXfJvjZ19L5XPWp/z2kYo9gkDY\n", + "Lsk9WrDwSxhQVHjX3UgXdmG3gXRYMvbDAjmGoeibKCGEEEKIEeglSgghhBBiBHqJEkIIIYQYgV6i\n", + "hBBCCCFGsCdieQ/vblXKBc3L7Cm3zmWtL9sBCfiBdLWr80j0ZUvLxc7dtO4PknhmxQB5t2Cvpc7K\n", + "I7Oxs+RvtMaJEdejmMgE9ZLJg3nZEHHwIiik+xWnE28BRkgQrreWrs5kw3fHp5/KBxQcPnrA1bn6\n", + "mitc2af/j/8nW079YI00h0jkbODD8S5PLN+IXmR/cHbUlX2+vC5bvrd8oatzofLtchVsf70dJs63\n", + "bS4w7zb+/HZrf03XZ3nZ+tTXaUmKuYHo6fq0EUnW/P1AB0cgJCmbXfYaumc988e0IGnki/V8xoJm\n", + "w89gkEqSSl3nD4VZIlI36WcIe0YwcR7t756lthMBHssiuVYYlH0RPHZyTEMeMPQSs+RxkI7J+fVk\n", + "4EqEh3PHjolJx3gIbPCOX83vn2akk+sOU3qEAQcVWNo7KcPP3kQtefL5NOTrFnIqOGiEhK/blJxf\n", + "BRU7fztaSwYUYDi/+3w0PjNGGP4B6NA3UUIIIYQQI9BLlBBCCCHECPQSJYQQQggxgj1xonZC7mWs\n", + "xfwHz0nyvsxV6WFXVjbgW5TEqUmHXNkyrWXLdfJBd0X0bsPM/HE52MTSUNiR39QL8qNzD75RR2aa\n", + "xm2R7DQ6AzYGYg7+SRhn5Sbhaewn/OUyT/JDP+FS6+FxPv/673J1zj9BQiwfeDJbPnGtX48CM4qX\n", + "xA/Y1+24sv1d7m5txjVX58tTfwz/Z/kD2fKD0de5rHjclR3tz+TH1PvgR0YLF3Br198zU+Jgzaq8\n", + "XdZn3keomH8AZYl4fakbMIP6ACcqJbId4vCgktQV/l5vJ17waKv8OdVNvKiRMFnTzCKEHnYLv7+e\n", + "+Fwevx7zXgLMbt9Xfr2F754W4To0JHSVOmZr+BwmLhUJZ0UCeQYyZydGDBNlzhAL7oR6JMiTukXQ\n", + "r2hPHBDETJ020q/R+RqyHt099XPzcw6R3DMj9aDYkSBN3BbpQAW5fiWEXXekDTryGd2C/4vLZj6Q\n", + "08wsxZHOrOmbKCGEEEKIUeglSgghhBBiBHqJEkIIIYQYgV6ihBBCCCFGsCdi+bnp5dnyTpOHXU7N\n", + "i8JH0mOu7DKQeVk4XEHEvQj2NcqvZpeYkT6QxC/cHw2Hw2A0ZlCzYwCBkoq7eC7DJMveHdOw92nf\n", + "nP58ezbrOITfVZUP5Gxqv976Rt431mdTV+fL/++Drqwq8+1PN8g04ISF5dtPJBhxH+mf85AHcD49\n", + "9QMavlg915U9WOVhsD0xRI+EM67sWH82Ww7esaSgpLpo/flt7Xobez7JB1+w+6MnciZmsbJeVrBQ\n", + "QLhHUbZlsGvFZqR3ZSSskRT5LE82jTxpA1wv0GNafQFp4CEL4MVQYH/LWE2uX1fkHwdF7/sBc/cT\n", + "iOT9jAjw5WqxnA24YR2mTzgohonXfj3ceiz8x18i0jFuiw6mGeAl00E/7HHtPpaJHD0gNDOQgQhF\n", + "AYMjUu3q+P2bFSRU2a3HPjKhrOr8dmZLf5zTOl+RdHMLJPy6hgFLy6k/l52J79c1GUwzFH0TJYQQ\n", + "QggxAr1ECSGEEEKMQC9RQgghhBAj0EuUEEIIIcQI9kQs34bE8vPlRrYcib3IZjk/GvJU6qfCYVen\n", + "D14oLts8ebyqSGJq8OnkBUt3dTtcLSZSQ5SkNmM1JqQGcOQSSydnM8QPmpabrAZmectmSycCJYrk\n", + "zCFlM6+vz3MrdvuCFyHPPnnelV1+9GC+P2YKEzpo0EnvpcdD6YIr24h5ivlTcd3VqfFimdn+kB/7\n", + "IXvS1Xle+poru6zJ67XdhqvDmE8hlbolYjKJ+V7AmIpJ6fsPmVTd9WvsP2aX6LNg4Q4ILDcWgs/u\n", + "WDzM0PkDLxu/w8kSkseJLJ0av8eqy9eLC7+/yYBHC6b3m5lZQeRvSAfHmQ/MzOqSPEtmsB3y3IhU\n", + "YHb2sKvTDfikieyRxARxfMYyY5v1Mzjlng7wIbNJQF+PRq77gMTyzvzMGIEMKCgGDKpAsZwOjmAD\n", + "kdp8f6X5wVI9O7+4+gIWZGAHppEXRCwnIf9OLF8jg45K0nYt3A47rT/u2M1c2Q5JWx+KvokSQggh\n", + "hBiBXqKEEEIIIUaglyghhBBCiBHsiRM1KfIZ5xcx/43y8faIW4f9JPt0m4d2st+OifJh82qRLQfz\n", + "ns209E5UYElzbofEI8Cfr8nv9YGIRE2d/+Y7JDg0EbGgJ79Dd/B7eUWFBE/Xo+Pi6wSyreRm7yYO\n", + "GNlfBHfrwoUdX4fIMPsO505SS1w1RofGDPO7eha6mrdxS/yHisw6fqzPgzS/Kz3k6jy7ecSVrXf5\n", + "th7p9pNj8syrvK8v15iLt9q9WZLZ2EvqoUBgLPFXWNArDTRcCTkXes/ky2Xt74/pggQOxtzPa1h+\n", + "JOmLBYRylsSJqpYDzpfdouyZBPdfX5A65MEYqryev2ep8umeu4H4Od2Q60mfr8T1KTBokpwLlejS\n", + "yjoYRnsReObRQOPVTlRPP27JRcV7hGw7goCYyDOehm2CA9UnJjKywOjVYanssYFuIwsX7QNpF3DM\n", + "YufPZUL6cAmpnB1JAK3Jc7gd4HxdCn0TJYQQQggxAr1ECSGEEEKMQC9RQgghhBAj0EuUEEIIIcQI\n", + "9kQsX7c8YDCB4LcovJS72fmpyFPMZdoJEekmJEwswMzVBREvexZsOSTwjzqHubzHQiVj6S8Fhmuy\n", + "TLkEIjSbyZ6F7bltkSBIhs/oZHImEfxBuJ+Q822IPIjt0iz9IIDJ3PeN6Voe7rm1s+XqMNqU972W\n", + "zGR/IezzK8Ipn0te9GZBc4chuHPDFq5O1665stNtHiz7qF3pj4kwm+b3w5zI2C3ze/G6k2TNklz3\n", + "uoe+TvonE9kDhm2m1WJrT8V2UtbmZWXtnze2Q2T3Ni8rJuTxSWaWx2dC7Py2y3r1o7gf0E5mZuiD\n", + "hyH3v7Fnia+DA1kurocH5ddj18ZtmwyuSYVvlwTPU+pGM897QB9iA3xQXGd9qh8wcIX4zC7c18ys\n", + "A8G+IMI9PudxAI4Zd91dERkEwAZ60M6Am2JiOXZGcrHY4C+4Rd1AKDOzjsr8EO5Jnt8VCdItSfjs\n", + "UPRNlBBCCCHECPQSJYQQQggxAr1ECSGEEEKMQC9RQgghhBAjCGnI9NPfyh0OsbOFEEIIIZ4hXOpV\n", + "Sd9ECSGEEEKMQC9RQgghhBAj0EuUEEIIIcQI9iRs8+d+5dZseQL5iWXt3+2qXe9Sre3mh7+25YO1\n", + "ptv+FCdLKOj9/urKFdlykv8m+saPvsXVefPtt/kVgYKEtZUkVK7rcSZrkma2A8GhLCeNXOUOQuVI\n", + "E9id732fK3vbG96Zb5v8ThxJt+r7vCyQ4LnQkWA9CE+LbDZx+lM1nBBJgnvXv7rVld3+9rysICF2\n", + "kZxzwmtFAvLYtiooakloX0dCAhs4v5YkHL7nPb/iym59x5uzZQyCNeNhe33fQh0GC17FWdxZiK0/\n", + "hgTheokE673vXaey5X/2wV92ddZJsOXabr489/mtNsNnhJmV3epzaUnw4wKeG/XEt9Oi9Mf5r992\n", + "e7b8plvf7ursBB80u2v5w2s3+bDWJpEHHFyrKUkOLpNvmAnckyW5uVl/+c335n3xTXfeQg6JrYnX\n", + "wd8fidx/+HBkWY0lCWdcXsjPZ385d3Xi0h/nO97/jmz5jlvf6Opg8LOZWQXtWXU7vk4Pz336EPR9\n", + "qot5WR99P+iCL4tl3p5veM9vuTo/9zO/TY4hP66W3euBXCsIrY2F71NFQdquXMLyrqsTSeppFfJt\n", + "3fHeU67OpdA3UUIIIYQQI9BLlBBCCCHECPQSJYQQQggxAr1ECSGEEEKMYE/EcpyNvK1wxnYvyVU4\n", + "rbOZhQXOdu3rzBpXZGu7KBgS0RNnnzaznsx4jRTEg0RZmDmPfU+2DSJkRd55dxcgIe6fuTo1Ez2r\n", + "/NL37KAIAWVTNlN48vuLRX6cfeHlxb71giiKyYHtsCONDn0oMCGd0IFh35G+wSaNj06YXD3zuplZ\n", + "hHoVGRkQOnLsODBg2OmZwfnQy06M2xjz80OR3swssD4c8fqRv9uITA+rWT8gpHfK7n8ygGFW5/Xm\n", + "O37/811/LtMuL8NBD2Zmu0QaD9B2rAm6uPoCrkcv0kZ2raCtOtI5OvI8TXBgrG+wJ2CPgwBI3x8C\n", + "DqQxMyqW4/OlJ8+bggzUQSE9dWSASOOPfQ3k66r3217sLsj+cto4cWVkvIsVKf/Q6sw/K1EkDz15\n", + "xkff0RJ8rnXkipKxGGZkAIqvQz5s8fqRe5R93scib5hAPsPK4PdXxVwsL4K/Z5iQXpJ6Q9E3UUII\n", + "IYQQI9BLlBBCCCHECPQSJYQQQggxAr1ECSGEEEKMYE/EcgzLTZBO2hLRrCHeJQrpPdqoZhaJrFg1\n", + "UEYkcpbnWw1pLSbAgkzHhL+eZPqur+WS+PKxC353y1y4i0RMZr6mwTGgwH0pAqYDkzbvybt5KvP1\n", + "qNBI5MWI9Yj4GYnoGerVgxUY2M3c/s0skbbqQG5P7NYifbiEc46Vr1SRNi7ASB129czw76bA+isR\n", + "vVNYPRhj0KZIHRShzUga+IDLVxEjtlz6FTGN/MCO3/++LS+tzmoQmsm9dt4HiFsHA1Jqcv9PBjxb\n", + "psHLy33w/aXGPmVeaGYp8Tiogj2HA0ndL1BIZ/e/K/GwOrxfw+wA5P6oSt+gDXyIJDJgo4r+AsaQ\n", + "t1+9TYRmNuUD7p+koZekPfHjKZI62Fb0OdX548R7jd/H5P5vV1/BnvQpHEiSSDslMmALn0tsAEUo\n", + "/PmVJSS5l/6eKaJfb0K2NRR9EyWEEEIIMQK9RAkhhBBCjEAvUUIIIYQQI9ibsE0I0nJhbcSRaEhg\n", + "3GKa15vNiB+w5t8Ta8jVKskM3ESzsVCsDpFjoZXoJKFfYmZWESmihHyxC09tuTqTNfgNv2ShaMTw\n", + "gkNgwXMM59CQtLhEfl9Os3z7HblWLTl03HxckPf+Hb9igbPbN8OsIe9qkb7BJDNwC7qWzKDe+utQ\n", + "N3m9SALrphO/v97yzlGwmdAJPUhKkQSAskC8iEGFLGyT/E2GJR2bsJ0k1GI/Y/tDSuLLVeS6r0FI\n", + "78bm0tW5/IIvW4cHx4I4UemAD7tdNnn/XJI2wEBexoy4HKxVGss9kJl5z2dB/JyAfYG4oixIEx9n\n", + "zKkZ8vc6zXhkQawQXso80IY8z+pl3n77J75dysa3y85mvt6s83VmYfVH6TJ4N4191uFlSMRNS5Yf\n", + "EwujZE889Jb6gX7uIKhnB6GgdNPMico/HyLp+1Xp79Gy3IFl4kQxl4q031D0TZQQQgghxAj0EiWE\n", + "EEIIMQK9RAkhhBBCjEAvUUIIIYQQI9gjsTwXyVoM0iq8dNwzcQ+kw20SnhbZbOUp39Zs179LtiQA\n", + "rGYJnCuOycysAOEuEfl8QsLh+idykbzf8ZLc5PjBfNtzv5126aW5CLIiEzgZHUiHPZGQU0nabr6b\n", + "r3fYn0uabfoyMPybzTVXpzi7zx8oSNyhHdbV0bNkYa2RiNA1JOTVJPjx/DYJg8QwuuTl0wPsQOEY\n", + "wsBZyPG6B3J+iVxTHDARyaODC7A5zCtNJEjP/Xk3ICyV5JTajDwTZhC6uFH7+2N9a9eVre3mZXHm\n", + "xeTtNf+QKEB4j2TQAfG1/XaSv8ZrpEExzLfu/LnsRjKKwwUhsmBN354lSMAFu57kmYfQ4EdW0T27\n", + "/P7aJRmgAc/Y+cQPAtg85/tCs5WXHZ77a4yDgBh19Pc2C6gsoR0qUgdt/sSCZjEY2chYgcIfU8sG\n", + "iJDPQ7dtNvgD9scHJpDPJxDJy4JI5IXv11WVf66U0dcJ5PPJyICeoeibKCGEEEKIEeglSgghhBBi\n", + "BHqJEkIIIYQYgV6ihBBCCCFGsCdiOc7a7J04ltDsJbk0g5meSUptaIlsDuIec46Z0NiR2cL9ikRS\n", + "h5jm+czL0WtEHtx8GsRysvvqsv3Z8pZ5Qa4jMdGY8ouze1+Krssbix1TVxDRcy2/DuWBJ12d2cHT\n", + "rqxvQCy3Y37bO749ezi/nqW2E3A29Ipc88gkWRC9G/LnCc7Obmb2FEirPUkQZ0rnbJrXm9Ckeka+\n", + "XsEEY9L7UwdluGxmgfR9NKaJO8ydcZBUMTGdUZE6JXkmlPBIKBr/jChakgCNZUQQD0RkDyjlk2Yq\n", + "WCEwJXJvn/wAjRISw0kIt7VOIjfbhgvRk4TtSGTlCp7NkcwuwZ6LbtukDibsm5HeSfp9re9GAAAg\n", + "AElEQVRPRQZ/zMr8fJZbZNaELb+/Nbh+R8nggW0/JsbR4SwKZmZkFgx8VnXJ98U+5nVSQdLCO983\n", + "MNmczZ7Bvlthz3kEP9cv7m/1gIJY+PMryxqWvSA+mfgyl1heeSHdyMAHNhZiKPomSgghhBBiBHqJ\n", + "EkIIIYQYgV6ihBBCCCFGsDdOFP4ODL+b9ux3WvLbcYLfd2vy4/g2ma0cnagZcXgK4jsQDcTBMisr\n", + "CHlbI7OH12f9j+qLrfz33dkRH7sYNvJtNed3XJ1Ijqks85PpBoThmXlvIZGNp0iCGCN4E8UFf0zF\n", + "Wb8eeBldedDVIXmqRDwZ9vcC9oSOCDtMjSuhHdYr76YdnJMQS3BTOtKe5Fd9K8EZwoC+S5Iw+JVJ\n", + "Sr4owHEyV4WFbeLWexK2V1Tk2sCKPTXDYP/kmFiv7sD/a4hPtpyQ0FoQ3eqpX29REp8E7n+ivVka\n", + "4o703h1hTTcrchcGA1bNzBJxRScQcLhMPoyyI/2lhIvFwjZZyCLCshqJXYUfF1YRn2xSeW9pcSE/\n", + "v3lY98ew4z2bA7CpIxs+3PeJ01uuDOlo2KY/aQw0Lsnnk3NTiQ84oWGp+dOEqbBUjx0SlkpCsrEv\n", + "JBbWWvoQ2aLKP8cmU/+5Nplsu7IZ1AvRP4cTOcGOOIJD0TdRQgghhBAj0EuUEEIIIcQI9BIlhBBC\n", + "CDECvUQJIYQQQoxgT8RyFLQDiHMtm+mZyOapyustmRxGzMQCAvhQejYzq2oiRw4wywMR/IoCJMCF\n", + "F+mW57xoHWf5etXhDVcHg0qbhdeQJywQE86PSbmMAqxOJgoWHQmHA1E/LHxAZtrx0njXgQi962XX\n", + "gkzAjTLtkNA3My/OssnLG9JWGHBYERn0wMyXVRB2yQZVzCq/vwgC+hDx2owMfGBieUsEcViR9fMh\n", + "MGm1Z2mbUDbEm09EMGahp0tozwtTMhBi3ffPapJfq2bNi8Lb637QyAKCUWtyTO2AtD8miJfB339T\n", + "uCcLUidg4qiZTeG5uBv8fbzsSGgtPnfZ82ZAf0mkDg4CMjOLcK8FYurXCxJMCmm3BRu/tPQC8/Un\n", + "npctd1t+QMGZJ9jwj5yGfNwGUtbj5wV5CDHBH2ECdQUDS/A5YubDYc3MIukLbr3o60Tse6ROWflQ\n", + "0OkExHIikU9KX1ZB2Cb7bO+Sb/P4V3gV0jdRQgghhBAjGP0Sdeedd9r1119vL3rRi+wnfuInbLlc\n", + "2tmzZ+3kyZN24sQJu/HGG+3cuXPfymMVQgghhHjGMOol6oEHHrDf+q3fsnvvvdf+7M/+zLqus498\n", + "5CN26tQpO3nypN133332qle9yk6dOvWtPl4hhBBCiGcEo16i9u/fb1VV2c7OjrVtazs7O3bllVfa\n", + "Jz7xCbv55pvNzOzmm2+2j3/849/SgxVCCCGEeKYwyqY6fPiwvfGNb7RnP/vZtra2Zj/8wz9sJ0+e\n", + "tDNnztixY8fMzOzYsWN25swZuj5qeSjABSLEscDUACnmbUmEXyLlNlOUh4m0zoQ7Nh061iF+aAES\n", + "YLNLZl4viXS4v4JlL7suQFLvFkQAJAIsHmgshnWFBKnJTHYNDRETt3PhtiuPuDo7u/78Isj8YdOn\n", + "tselP78Cj6EbJpZjHHlgieVU6gSRncy8PiX9M4S8T7Xu7jAriViKci0TRBkFiOvYNy9FB3HSLOk8\n", + "sNnRXbXVErmZF9eHzCLfEDG5It16CaL35oav1BDruOryPlyTOos5ScqG501N+gFLTUdIyLhNS3Id\n", + "oI1nRgZ6kGPv4W9qNqiCiewdzFDAhOZmQCJ0JCdYFOz8YFs4usbMmi0/eGejAul/28vgzzrkB+9c\n", + "vp4PePkP/+l+V6eOPv0cSeQ7CyaI9yh/k3smxXyATU2eN2yqCrzVCjIwKJD14oDvWyKRxgtIDI+F\n", + "b/NpRdLIq3wGj9nE1ylL/zkai/wYEmm7lpR1w8blUEZ9E/WVr3zF7rrrLnvggQfs0Ucfta2tLfud\n", + "3/mdrE4Igb4MCSGEEEJ8JzDqm6g//uM/tpe97GV22WWXmZnZj//4j9unP/1pO378uJ0+fdqOHz9u\n", + "jz32mB09epSuf+/vffrr/33F91xtx1941ZjDEEIIIYTYM0a9RF177bV2xx132O7urs1mM7vnnnvs\n", + "pS99qa2vr9vdd99tt9xyi91999326le/mq7/ff/k72bLQyanFEIIIYR4JjHqJeqGG26wn/qpn7If\n", + "+IEfsBijfd/3fZ/9zM/8jG1ubtpNN91kH/7wh+2aa66xj33sY3R99EwChKCRzDwaxIYhb+y3YzaP\n", + "O+Q3WkN+dzeiERXELUDYT5ihh9+dO/87dJx4J6ItIIiReAy72/lvxcwhiMwrADemH+jGGGyrIMGT\n", + "ofXHGbbz3/D7jsxoXnrfKUFTla13TuI2CU/DcM+Bp4deT2Ihr3RG87wea07mUuEM9In8OB+YLoM3\n", + "CQusJBQJvRfiHzJHKWEdv23WLAlCR1loLrtv0cEaku1J1Bh6by9KuMYz4tQQR6mAY2rJ/ViT58YC\n", + "2qAj63Vx9Qkuzff9gjxL8GIxL4SVlfB8mxA/r6UGSH7sLfGfygHmSMBrbmZl9MewaHLPhuVAzsl6\n", + "6zFvv9T5lN7DG4dc2Z/fl0f13H96y9W56oWX+4MAeuItJXbd4dBZUGkK+TMvkL4RjKQQw0c+y4+O\n", + "5EYu4+pXhaLwHloJZUWx6+pUpS+blPl6MfhtByLt4XOpIw/PloRtdoncuAMZHdP55je/2d785jdn\n", + "ZYcPH7Z77rln9MEIIYQQQny7oMRyIYQQQogR6CVKCCGEEGIEeokSQgghhBjB+KmL/woEJ7OC7MoE\n", + "VRbACdthaiYTNosy3183IWGGxMlLzFwFmByZQCxnIXYNsenbSX55CmLzdm3eWEXlRbpQ+LIewyiH\n", + "ho2B2E2lRyJHxw5mJvc5aRaYAI/iOkr6ZhYbIn/D/qjpTeihIVo0282MuPTWgcxbkL9PqEANAx9o\n", + "e5L9YcZiN1AsbyCMNRIJuCVhqSibJ9LP2Q0YIeSUSfIFWbGAgRYdE6iBJZGJY8VGqeTH3pMbsib3\n", + "PwYOpuDbqS18WQ33ZOMdYD64Bbfd+uNcsoEsUK0kz8BAQhZRrWWBqokEqmJ4YU3E3SEDV0oy6KBZ\n", + "+gsxgU40IUHFWMfMLO3m58xCgc+e8wLzQw/lwY/Ty3wg59ErfZnbPzk/I8I23losCDLCR3csZq5O\n", + "y54JsPGChKeW5LWgZSnSuF7pr1UJ4ZqTwj/4ZySAs7L8OkzIADH2eejeLVjIa09ee4ak+V4CfRMl\n", + "hBBCCDECvUQJIYQQQoxAL1FCCCGEECPQS5QQQgghxAhCYvHEf5071KTEQgghhPg24lKvSvomSggh\n", + "hBBiBHqJEkIIIYQYgV6ihBBCCCFGsCdhm7/3z38iW64wvZAEey1Ln1C3OZlmyxeqqauzQ9ZbQvgd\n", + "mx29Dr5p6pDXu+vd73B1bn7fL7oyzH1jIX2JJRXCFNusTnAb95shOWVWQAjZhISN/au3nXJlb/3A\n", + "h/LdNT48rV/u+B02eaBau/Azd/ckSDPgjPSdnwkd65j53Me29evd9aF/48pOnfpgvj8SVMhyJkvo\n", + "UwW5s8qKhErG/JxL0jcCmf29x/ZsfJ2f/8V3urJffMMbsuUFCTPser+tqszPb33uw/021ueubH2+\n", + "li3PZr5O2/jrvljmZXXr2+X2t78lW77tX/68q0PvBwg9pLdM5/fXgxMRmCPBQoEh7JYFTwbyvPnV\n", + "D7w/W/6N229zdRqSxNgnCBOmjxYyu32Rr3eBBJw+emHblT345Nls+fyuv7dnM4zyNPvsR/5dtvxf\n", + "vedOV6cg4aUBAnAjOcGCtEsFqbVT0u8mLNwT7oeKhV+2fltv/NB/my3/0h0fcHVYIGYPYaV9XPN1\n", + "4HMN+6aZWYgk1RWenyUJ24ws0Bg2/9/d/t+4Orfe5vtnNcmfE9tbPliz3n3SlV37PSey5Qfv9/1u\n", + "0VxwZZcdzvtZ15IwYZZBCk+B9935Hl/pEuibKCGEEEKIEeglSgghhBBiBHqJEkIIIYQYgV6ihBBC\n", + "CCFGsCdi+QTEtTWQ3RKbtp7Iw9t9Ls6xicIbMkv2Muby2dKIZEnWa4n8icTCb6sHeTiQOpGJ5VAU\n", + "k3/n7bESaYSCzBAfwJ8skz8mBsrfbe1nPY84UMD823pB2qAkZSiNh5K995P9wSnXA0Net3fz8+nI\n", + "3xmBtGeJs6MT2bWi1yZfLxoR55MXPXuQYjsiljMubOcDARYLf/3a1su1KI2vzZgk7++PqsrvtWnl\n", + "60QiOXd9fgxs0AHCgnwTu+4gljOznPWzCKJ1JNsOcfU9GkmfSnhMhLbxB9oRgRqfn2xwBBv4gO1S\n", + "kfXmMy85b8w3suUmeKF5vuYH/TjQXjYzdnHwbiePRfY0tR4H6pDPmTKtFstL8vEUSZk7psWWKytI\n", + "f7GYtxU7zmgwsIP1/d6fS4A+HAJ5bnRkPdqiOT0ZkNK2+fOlIo139NnHXdlTj+eDkx596DFX5++8\n", + "xK/XwQCUp7b9uZRkZEAsx4eA65soIYQQQogR6CVKCCGEEGIEeokSQgghhBiBXqKEEEIIIUawJ2I5\n", + "Jv0WII0GIgoviT2YQDpkEvmi8Em5WyEX92qyXiLCH5OM3XrMiYdt9US8Jt68FXDOdBJpjM9mkixZ\n", + "sYTEciaDMxJKxyTVOJBI7wTbL4nZymbJTpDWTeVhkraODRFpLrVnewGDHMhgglD6MvDDrSDHVLJr\n", + "DDItcXktkk7VNVA27PLZDojkW9skXZ71lwkkJBPRNJZeEMek6unUS8cscR6FaRRGGYn0u0ANalhv\n", + "ZY2L4Pmxe5auFyGxnLUdS5cGWD9HWdrMrIN7rScH2jPpGKuRfjcjAvzlG/uy5f3r+10dTPRndGTb\n", + "TBpP8LEVBg5EijCAiQ0MqMiNNIO2KlnkdbtaTJ6Qm7slx4CnzGYswOdiH9lgJTIoJuT3f0H6QST7\n", + "G3KT1I1PI3/uVVdny1/43JdcnfnsgCvb2c53ePU1B12d2dyf831fOJctr+3zfdEKP5iGCv4D0TdR\n", + "QgghhBAj0EuUEEIIIcQI9BIlhBBCCDGCPXGiavj9Fn8rZoF1DfEtljCT9U7pvYLN0jtRO0UeVNaS\n", + "/SXiLTCXAYnEWwjwwz4LzQzsfbZDr4fUwZBHsu1IZqSfQD026zkjgQOVSAhiR8IaI3g2HfMY6A7z\n", + "ei1xsJhH1CUMBR0WRrm7RJ/EH2ciwZaxyftnJLPPlxXxpKDLFkQ+KFmoI4SjMg+NEWD7LPSUdfMK\n", + "QjKZ48K8AvRVenL9mCPofJwBYZtsJvuClOH+2POG+TLO2SPbZs6e3x/zn1b/PRuIu2kkiDVAeDAN\n", + "BaXhs3nZlAUOMzlmmj9jE/HQIvEI3baHBKNeLMyXEvEridtUOE+KuDGkf07gfp8QP69n8hbSkv2R\n", + "oFkUHFmdHp7XReU/59g9E/vcW4rkmLg/utppu/yYD7988CuPZ8tbF552da7/4f/Mlf2vn/iTbPnI\n", + "lf6e2d7216Ht874w3yDvEiy0doBzeSn0TZQQQgghxAj0EiWEEEIIMQK9RAkhhBBCjEAvUUIIIYQQ\n", + "I9gTsRyFcAzbS2Q2763KzwJ+YZIL4hdAGDcz2y78rOO7EMBJ8uqMpYvFATOtV4nMSF/n22K7Y/Kw\n", + "4bZYkCYc/JRthzjVJYjI1RAx0vyM4igqm5lFYno7mZ7I7ixMFCVZI6I3mz3cBdYNGBRgZlY3q4MK\n", + "WxZQB0maJPvOYuPbuALZPJLp4CfsLoX2KwdGRs7m+f1QTLyQymTzfbBeNTAsdVnnbdWRoMLFwl+/\n", + "ps6l2OXSC7AeFtbKghhX9wV2LijFswENRiRg3F3HQkHpxvCYyAAYcn7Y1+m2mWyO9whZbZ30jRIO\n", + "K5E6LLzY1yGFTKqGY0+JifNssBAOViADEcgghwmUVaTOkGErNNCYtHER837Wkc+UHgMx612/P/Ls\n", + "CiCbM4mchZf2AwZ2JPJ8e/D+L2fL//S//C9cna/++eOu7C/+/MFs+e/9w3/g6nzmD+93ZbO1/HlW\n", + "Vf64t7d8GQ6c+WbQN1FCCCGEECPQS5QQQgghxAj0EiWEEEIIMQK9RAkhhBBCjGBPxPJdkLha8OY6\n", + "IiGiRG5mdqGaZ8s7sGzmJXIzs2UBM9IT8bKwgcnKQGzZtOOrxXKWNI5eYE9k7BKTx8nWi57IoLCp\n", + "cpiXbAlniGdtwsRZlBXJ/tj5IZG1Hl0NBfhh9JBc2wU2g7rfWgdqKU2gJ/0MA5ID2XZion7I7yEm\n", + "5TMO7N/It0MkYCZZTqGsKvz59eS6b23lCcl952d6Xy68qI/J9NjvGCyxnEmyOBtBYrPdMyEd+z45\n", + "htSR6w5tl0hieaDJ1QgTy1nPztuhJzI/3R1si4negVz3EiTuntzc7YB7m10/FpTdYjuwZwkbZOCa\n", + "is3uQGYMgL5YDuiLDDbjBWlOlzQeycCZCY45IuI3m8UAB0wEOmPB0IT7nEceetSV/d2XX58tnz/n\n", + "B4j8/n/4rCv7sde8LFve2fHPja98+RFX9sobb8iWnzjtjyn2bDDN+O+T9E2UEEIIIcQI9BIlhBBC\n", + "CDECvUQJIYQQQoxgT5yoRZn/DlvDYdQkqfACCdvEAM4dEgDYYBKcmTXgXPVUK/CFZbH6d+EJCRxD\n", + "l4LtMJIsswKOISTvUkTYFrugJfE78ChZMBujAJ/MovdZWDO5jEwWdEeuuwsTJDoCC0ENzkMb5jGg\n", + "C1OQvzNK4hG4QEPaBmxW9XxbVD1gjhnUiyzdk7D/YO5EzWc+jHZC0j2x/ZqFdxt2ibewtZmHAO7u\n", + "+jr1kvUh6NcD7j3mZAUSzup7P/GmyLXCwMGe3Mfl1PsW5WxfvveJb3P0tBgd8YrY2aGPR4NDqdCV\n", + "HwPRg6whbdzCs4M+Twd80gTiwtKnEhwD7fvk4DHwl2Q6W0H2iAGc1YDgSQbrw6yfRcNQV1+naPMy\n", + "9nyjbYdtRSq1LNQ1+M8e5MjRg66s3s3P+fN/cp+r87JX3ODKDhzKHeh7Pum9qRte/N2uLBZ5u5x9\n", + "asfVufrZh1zZ9u62KxuKvokSQgghhBiBXqKEEEIIIUaglyghhBBCiBHoJUoIIYQQYgR7JJbnkloL\n", + "yW9MLN8iYZs7EFq3JGJ5ywIOXVabr4MzhZtxcRWZekfWJtDMsfbbmXREUoUyDNa8eFD5Ip1Ynp4f\n", + "SLLlsDhKFKgjkUEDs1bhlCO5LnTmdZjBvGvYtsl1caL8sPPr21yYZs5qQQRRlHlZm7PjRO+ZieWR\n", + "BXDCtpyAfwnma/l9tG/dS87zub/XMAh1y7yIicGaZmab27lY/vTZC67Ogsjmkyq/t/et+4El7hhJ\n", + "N2CDDlzSJO0/A8JSo5fIq43LXNm+y67MlouZDwWua98Gfv/sb15/7J0LVBwmbLv7j7Yd64t5GXt2\n", + "BpaaidshvnYgR1piWOqA+8rMLPa4TKRuduywYsCEXOMhua5O6wdjsCuBInlh/kMl9ljGhxi4vaX8\n", + "s6iP/jOzCL6s68gHG65HnosPPHA6Wz5x/XPJUfr2/PT/9fls+bnf8xxX57KjG67s85/7UrZ85VVX\n", + "uDodaU8eWjsMfRMlhBBCCDECvUQJIYQQQoxAL1FCCCGEECPQS5QQQgghxAj2RCzfKXJxtQGBcUlm\n", + "Od+KXiyti1zs7Ngs5wPeEwNL605+5uwBE1nbhMiRM0jPnRFHb6Pz4uWkydebsHPBQG+WMkykwwYk\n", + "2XqgV4epyYOcbmNtxwROcn6wg7IiXZZJpDgjPTtQRgfyJ3WOSaoxypgktpm6yigBs8Mk54cyZiJy\n", + "JqOC9pvOiBw98fdfW8P9QE6GDbzYhWTzzW2fILxc+BtiNsn3N5sOEJNRGDezRIXm1c8Edi44yGEy\n", + "3+fqzA8edWWHjj9r5XoXNs+tPKaOicLsOkCHYbI0e5gFTOJndejgDxw1QtKtByTqozBuxgXx1ENf\n", + "JANupmRwS9XnfbEkYjnOWGBm1kN/aYmM3Q0Q58swUGhGadxJ5GYRHwpEdmfXD/sGE/fZR8GACQNs\n", + "d3vhyq64Mh9okcjn6oNffdSVXf3sfDDGdO6fU1/98oOu7PLL8/2Vle8bF877Z1BZrk5kvxT6JkoI\n", + "IYQQYgR6iRJCCCGEGIFeooQQQgghRrAnTtSyzHe7hN+Tl4X//bMuiKcB61G3iQgleNLMI2KzebPf\n", + "j916DQlPQ7cJ0z7NbJ3MOj6Hn49L8nt9AW3AZllfkt+zF/DLd10PC2vEn9lpRtkAeYy1JPOWEroN\n", + "LFhvwLaGKlEYYsd8Ejb7OwaM0t/Y2Z8s0GcjOZuCrOj0sYEn2EM/q5fet2C3Udt033DZzKylaZd5\n", + "/4ykXWLhPQkM7hviIwbm3RBPKsDGetbviOMS4blF3R+yP2yDQEKBA1vPH4ArapMP6US3sGXKJw2D\n", + "hUXiP7HnCz6HmecTWVAwULJ7u/PPJeyfLPxySo6zavN6LLy4J9d9EfLPo5p+zqw+v8p8P09kW/g5\n", + "E0kdPErWvIkEGkdYsyd1eubeDfnsw/vjL7f2/+fpJzddjUOHD7qyySw/oUcefszVWd+3Tspy3/r8\n", + "035/VeX96kgCaYeib6KEEEIIIUaglyghhBBCiBHoJUoIIYQQYgR6iRJCCCGEGMGeiOULECSXMBt6\n", + "QyTLlpR1IMUlYp8yWbEHCZhJq0zwHTLT85T4d2sgaLL56Jk0XsF6BROaIWSRhaIxSb4A+ZS6koSy\n", + "zK9DRyR5Nh17D2UsRK/DED3zYnkgAwVSR4JRoT2bevUs5GZm1ueBcSzEMrUs2A5uJVInlCQM0rU7\n", + "C99jbYyhp74NGMvdPHCQXYem9G2FIavbOz5Yr176WeoncM77981dnR3SaWeTvD0ns9VheC1rJxbg\n", + "CtIxC5B0ErmZRRjcEomUWy93Xdn5s09myyUJHF0sfXsixZRI+aTvR5T5SZ/q2YAJOGcmpJekrTp4\n", + "LrbsOUkGBiGBXL+CyeY9CuLk+UbuvwSDKlpiYy9t9YAQ9qFZ0OEtsF7rrzsbi+EG2LDnIj5j2fOb\n", + "BbEGHOTgB3GxAVpDPh7ajnxmwglO5/7TryXnd+5C3lbr+3xAbTX1V2Lz/Fa2PKn8+ZWlP87l0M8H\n", + "gr6JEkIIIYQYgV6ihBBCCCFGoJcoIYQQQogR6CVKCCGEEGIEIQ2e3v5btMMh0cNCCCGEEM8QLvWq\n", + "pG+ihBBCCCFGoJcoIYQQQogR6CVKCCGEEGIEexK2efub35Yt13X+LteTsLZAEir3X5EHoxUTH9q1\n", + "s7vtyuo6r9e3JIyOhEgWEKj4K+845eq85Y7b/IFCyFtJAiPZDN8Rf4IlyWw4y3kkoaR1z8ryELLd\n", + "1jfwBz9wuyt7w2/8i2yZze7NZiZ3l5Rd454EAMI50/nTaQhqXtaR4Llf+/m7XNntt7wrX2/iAyTb\n", + "qS9LM6gTSYolBnKamUHfL5f+OCdLf/3KRX5+ofFt8I5f+2VX9u5TP58tY1CimbkgTzOfn5rItWLn\n", + "h1vCoFszsxh9wGGLfZ0kzd55+wey5Tf98hv8IdEQxLCyDvMfMLczRH9dAgn37KDtahIEWZNj+I07\n", + "3p8tv/2Wtw46zuD6ng8SjOR500HyalP4Z0I/O+jK2ph3/knr74/p9pOu7J3v+2C2/KY3v93VKUka\n", + "bIFhiSRolq0XMPCXZYK6h64vo+sVfn//8vb8+XLbW8hnAwkmjnBN+44cU8qvadg95+rMGh/8in22\n", + "m+53dVpS1pX5Nb7jzne5Or/0xjv9MWzlz4TZ+Zmvs+kDMSOcczP1fbje78uajWW23M7Is9rvzhq4\n", + "qB885fvipdA3UUIIIYQQI9BLlBBCCCHECPQSJYQQQggxAr1ECSGEEEKMYE/Ecpy0PYBI1+x6ka5v\n", + "fNl0M9/Q7ACRCYno6bxZItcyL3jIK2fvPUHrYXbrOHCWbJS2mSKbQIijjjWZrbw3EAzNS7KMHo+J\n", + "nIsXW70TH9j+mKzs1iPXkzQeeqVDM167KhcR6/nC1VnOl66sA6ERRXMzLmMXi/wW7Hf8imnL36YJ\n", + "ZryvEpl9noAzrXfkmPre7y+CmM8GFGA/N/PhuoEMfGD3DHbkSGZeR4pI7mN20+JNQvoP9nMzs7LI\n", + "jz2Rmw1nrTfzonBV+GMKZOCD2zbpxOTWdg8KFKrNzHojZbD9pvAGblPMyQ7zdpl0Xua1hb+P3LbZ\n", + "vU2eE4s6v7nLwvf9VKweqIOfOxdXJA9+fJbgB9jFFUkZrFf69kytl6NTCc9m2vfzg2JCfL9NpPwe\n", + "2qX3z7LUeSE9kXsLqUh7roEgvm/b97v953wbVDW8E6z7c7lQ+bKtCaxHnsMtuR/cqJFvAn0TJYQQ\n", + "QggxAr1ECSGEEEKMQC9RQgghhBAj0EuUEEIIIcQI9kQsDyCpFSBotksvjC2IkLa2kb8Drq37d8Ky\n", + "IJJszOW6zjuIlmiy8mp5MBLBEAVGJgFWgYiQTtom4i6uRsTdJSlLfS5j9mmYWJ5cEjiTiZkpDNeG\n", + "SuRELG3zskjXI22ObTdA3DUza8p8vXrNX5f6IEkxP7CTH9KcyLXEWY27uWzanmdiq7cjiya/fmU3\n", + "7FYOKGyTlHE+GAOT8YkcPUByZnI9Xc31fTbSI4f5t0z0xv6CfdrMrCRtgHdIi5KumUWyHh55ZPfx\n", + "gPML5LnRkfUKJ86SBHoyIKQOeV+s5z6dvJ9f7sribi4nh/asq1M2q8XynrTdkg2KgT7bEVE4EEF8\n", + "As8l1u9YHyqxIksZH/DZYOQzJRApvofPrFStuTo1PNNj5dPlE0blm9lkcT5fjyTXlyThnqXeIwXp\n", + "Z25QBXlWT0giewn3bcc+j9nAAHi3YANg2CAAdj8MRd9ECSGEEEKMQC9RQgghhBAj0EuUEEIIIcQI\n", + "9iZsE2Zkx1m5S6LntMSJWmzm74D7Dvp3wmpOyvA3ZxYOSX7jTiyIDQjsN1j4vbUg/hObdTxCWU98\n", + "khaCEfvof2PfbUhZm6+3PdCJcqoR/cmZbQuOvSPv741fr1jknkbB1iPBgQmuX+7RqhoAAB3KSURB\n", + "VBrY07Gp6sq7AN0+X9Ye3M6X1zZdncB8oMlGtjzpfSBfveMPvprm9TqfmcdxQbO+SiKuAbpFzCGg\n", + "igJ4Lqy/sP1h2CXzO5BJ5ftG0xAPxYVtEmeIRdvCeiw0k2X2tRgmTFyqYlDYJnH/yHGiB8JCQbvo\n", + "+9myyvtiPTvi91ftc2XFVh7OWJJgzaJZ3UFb0jc64nO2cD7s1q5YMClsvyDPDeb1lLAiC+6NAz4b\n", + "euZuUT8nfwh1LPR0ml+HsH7A74+5jRcgpLf1wZoshDT0q50oL+ia9RBMWs/8MW1uuCKr+vy6L9b8\n", + "Me3MfNlyCvca+ShibmEq5EQJIYQQQvyN8g1fon76p3/ajh07Zi960Yu+Xnb27Fk7efKknThxwm68\n", + "8UY7d+7c1//fnXfeac9//vPt2muvtd///d//6ztqIYQQQog95hu+RL3uda+zT37yk1nZqVOn7OTJ\n", + "k3bffffZq171Kjt16pSZmX3hC1+wj370o/aFL3zBPvnJT9rrX/9668mwRCGEEEKI7wS+4UvUy1/+\n", + "cjt06FBW9olPfMJuvvlmMzO7+eab7eMf/7iZmf3e7/2evfa1r7Wqquyaa66x7/7u77bPfvazf02H\n", + "LYQQQgixt3zTYvmZM2fs2LFjZmZ27NgxO3PmjJmZPfroo/aDP/iDX6939dVX2yOPPEK3EUH2Kie5\n", + "fDabehuMSZwYylnv+m++ZhMSwImzlbODJPLgkJnWWWgeip6RmYlMjoaDSD0RZ8GYXjY+dG2z9mFt\n", + "iy4PcEQB8FIkkMYjsUHZzPKhAxm09rJkseWPfbKV1ws12Tg59n6Sh10282HfiqYC6pFZwJvSB2nW\n", + "VS7T9pWXawP5m6Voc4m0JrPPE6/UoDmtp33K00M3oxI5EZF9YiS7QcgOQbhlwnbPjHR3vw/QN5O/\n", + "kyNZL0Bb0cNmpxfxPl4d5Gnmw3WZwtoPCPtjYjJrOrz/UvSP+WVJAhxnl+X7m/mwzViTEMudPMBx\n", + "snve1akGjHxgIa8dG0wDYZus/3QuGtUMW74kocBTIh3jlnDQgxkPUHV18OYzM0sk6RkDYoMfGGQg\n", + "lnezQ65KIoMHnP+++6SrU5BrxZ4TSFuRYOK1vF22D/p2WvrHvgX4FauZkG2v+7IGwpETWc/IQDIc\n", + "iPTN8FcSy0MI7oGE/18IIYQQ4juRb/qbqGPHjtnp06ft+PHj9thjj9nRo0fNzOyqq66yhx566Ov1\n", + "Hn74YbvqqqvoNu75j5/6+n8/95rvsmdf8bxv9jCEEEIIIfaUb/qbqB/7sR+zu+++28zM7r77bnv1\n", + "q1/99fKPfOQjVte13X///fblL3/ZXvrSl9Jt/P0fesXX/z33mmvGH70QQgghxB7xDb+Jeu1rX2uf\n", + "+tSn7Mknn7RnPetZ9q53vctuvfVWu+mmm+zDH/6wXXPNNfaxj33MzMyuu+46u+mmm+y6666zsizt\n", + "N3/zN/VznhBCCCG+Y/mGL1G/+7u/S8vvueceWn7bbbfZbbfdtnKnOCNzAdNkT9b8F2Qb+7xc14Lt\n", + "utglSeBr/hRjBXI0kTp7Inr7meU9JUnY7QxnDycpyuSFE9OIezqjed4uO62XCc8RibuBSz8ZKtZh\n", + "YjgTaZnLB1Hg1bY/ptnT3jCcP5WXFUvfD1jabLORt93WwQGJu2ZWgLxP3FOLxDoOXX7d05JIskwC\n", + "XubrFS1JNUfR1PxXyEPETzOzZpFL8T2LciciMm4/EJk/lOSPJjgsmvrPBmzgvTYgUZi57h2515xK\n", + "ztKt2Yz0KKSzHbJrDBee/W3ZdQP6J2tz2ix5n+pwJI+ZteW6K+uneep1IHL2dPG0K5ttPpEvL8+5\n", + "OuWA50tPxOsused+3l8imSEBU80vkpcVRGRnydxYjQ68oPuDbZO+H1iKOfSXfveCq9PCcz+Q0SeJ\n", + "zF7RwWCBtvUSORP8bUBieUcGwDQxX6+vyP24j8wYgs888pjqichuFbRnJIMxyOwgQwaNXQollgsh\n", + "hBBCjEAvUUIIIYQQI9BLlBBCCCHECL7piINvBR38Nhwh4HBCflud+Gw4CxDEhu6BmVmz9GXupMnP\n", + "9Wx2dFaG4LldXG8IxHeC39k7UqcFH2BJHJeWeFoYUDck7M/Mh2Yy1QG9IjOzAO5PueV/r18jTtSB\n", + "0/O8ziZpp6lv883L8+VlNewqFA34Ftvk74wLvj3LCjooma0cg0rNzIpl7qbEXZLuufDXtK8h+BFd\n", + "tUtQL3IHomfOUMkCI8EnIeG3ccDjhKkHGEb7l4X5eiu3zB2lgnlEA/52ZN4bHgQNCSX3P/pkg7JF\n", + "CSxQlfk5EW7KnjhRkTg0BXgocceHZs7OP+bK1iCwsex2XR2bkX4NlKxPER8wQRnRFq0mhW0B3mLv\n", + "nZpIPDC3P+ZEDsjyZa5RZJ0B/LhJ648zbEMYZecDgDsI5DTz/i/zpiz55zC9R5GS+EfQF2viRKHb\n", + "bEYCcYmciu8Nf7nHFctmgZTRe3kg+iZKCCGEEGIEeokSQgghhBiBXqKEEEIIIUaglyghhBBCiBHs\n", + "iVjeQtgmhpAxxatgYjCET/YkkK9rvJDmtsV2SGeyXy2fdURQQ3kQhfGL65HZ7VGcZ3qtK/IS4ozM\n", + "ZN2CiFxRSc+DQZqRzLIeWyJQNhAqWXuBc7Ljy+abedn+cyTEkvTiZgqBqoeGdfViN19vWhEh9oK/\n", + "xjUY0+Xa3NXpiHAf63z7020vdU52vPw5qSG8tGWz1ntQEI0sMJKURQjEZYmRfU8E0YiC6LCASuzY\n", + "LIgRKckzom9Xh22yY2IiratG71kmsuaUJJS0I0Kzq0MGJkRi6vvBAn69QNql6rez5SkJAF3bfsKV\n", + "Ve1OfpzRS+s9DrwgsDBKFkxcgGScSH/tybMSH80dabuG9DMcVMGCPCMJzXT7J4J/R1bD84udf35P\n", + "+q28DtlfzwRqCNKNrJ3Yx8yQMFEiluN16II/FxpsDYMMCtK+bFAMCuKRfqyxExw/u4q+iRJCCCGE\n", + "GIFeooQQQgghRqCXKCGEEEKIEeyJE9WDG9LC75FM0wgkADC18Psn2Vcizk7fYRlLACQ/Vg/62ZT9\n", + "xgx+Bwt0I1vC9RKZgDjA78lTnIDR+O/Qqcx/LC7JRI2MEn4bD8QBYXPFYjAqm6uW9cYEQZqhIs4Z\n", + "8bkwVI799s+YLsClKr2jxEJXC3CSOhIql5i/AhMVT8kEy2sL4o+5iYtdFcpknrtagfgrPPkR/EMS\n", + "zhqJ8+GCJsmWWdAdBhP2A5QvOoEt6Z89TmBL5z8eMtkv6+js/s/7Qs8COYd0TzYxdOu9Jbx8PXFq\n", + "rFu4oil0orXltqtTLTf9McADu6nI5MazQ/4YgIK0Z0m8lwqeeSwnkURIuqTXxn0OmFWkjdG9weey\n", + "mVk7IKyRTSCPwahmZgkDk4nYg65Y7PxEwqnecmUFOp7kuOmpDMiiZBP7uhncyYOfTXSNE4Azb4oF\n", + "PWML03mFaUguqTcQfRMlhBBCCDECvUQJIYQQQoxAL1FCCCGEECPQS5QQQgghxAj2RCyPKI1CSF8i\n", + "wl8ghlgJPlrH5GEmzjn/bdjs6KzMwUIIcZlsp2bSOArpLBAMiopIgtmIlFuC8FcMDNtEd5D4xRyQ\n", + "I1sSzLa77iXZCwfzg28L0gZk0MH2oXz7y7WBYaIgeidyi4TO76+CSdRbYj2Gwuuu2NdZCGm5YCGd\n", + "UIbLlyDAIRAXnI7sQEGcz4S+2m5nAz0wkNPMi6VssInbP7mPye5cPRa2iYHAF1eEwQo0OJQ8b6Aa\n", + "u4+7AWGNLHiS3YAYWskk+Yo8J2KzhGUvkQciOffTXFauJ14s7yY+fBYpSNuVRCjGy8weyxWRnPE6\n", + "dyhwm1lNAkYLuEnIx9OwbyPI+fVsVEMBgZisDojkBbv3iGzeF/m5MEmefh7SBwXAJHm35dWBvGbm\n", + "g60HDsbAQT/sM7sg9wyV4geib6KEEEIIIUaglyghhBBCiBHoJUoIIYQQYgR6iRJCCCGEGMEeJZbn\n", + "ywWKc9TpJGKZMzb9eh1ZL4AZGHCGejMrSOx2P0D+LEhieA9SfCIpykaE6Q4E5r4nMigIfxUmxJr5\n", + "1Fgzi6D8lXy6awfKn6n3bccSqFGA7XwQuLX7/TEsQYAtD5EsYiJHNuv5tnY2hhnwxRJuCdIsZe+P\n", + "oW1ys7wk8mKXvJyJgnZsfHtWnV/PBcy3w/4eKqDdWaIvkyxRCGcJ8EyODjBggg1EYLcDVuyHiJ8s\n", + "MZ2k9UcQWZlcyweRQN+nbefLeliP3R8sAd7vncm1ZMYAt0zWMy9Qxz4vi0Q+t4lPuO8g5TtVa35/\n", + "A0YGsMEK9HkG7ccGFLD0c+xobL2G3RAsGhur0JR/rOSLaDg49OOeDGSJeJVXjzm6uG334Uuep2QW\n", + "Azawy22bDfpxR0HnLPBrFfjc8NvGz7CLW8LBH35vqSXPkmKAOH8J9E2UEEIIIcQI9BIlhBBCCDEC\n", + "vUQJIYQQQowgJEzR++veIQ33EkIIIYR4ZnKpVyV9EyWEEEIIMQK9RAkhhBBCjEAvUUIIIYQQI9BL\n", + "lBBCCCHECPYkbPPUz/xkttwV+QzfSzIL+GJ+wJV183z2cBZGV5CwTcxOY7OjJzKbd4AQtDvf8U5X\n", + "593v/llXZpaH1hUl2Z9LTzQLEDQX2ezTEEJG1TcSVNZ1eaAamyn8tlv+e1d2yy23ZctF5deL5FyW\n", + "Td6eBzaOuzpf+erXXNn11x3Jljef8AGAW5sLVza/PL9WDUl0PHXHna7sttveli2zGb8jmVkex0vg\n", + "bOJmZiUNYszbryXBmhi6evHAYH/J99c77jzlym75lf86W8bgyYs7ZAcKs7+zcE8SJmoYTEq2TbqL\n", + "u0c7EvZ353vz6/fWW273h0T6fg9Bfj05gJ6F5kJZs0b6+Zrvn2mSn0ygYbT+mfCv//mv+3pCiGcU\n", + "+iZKCCGEEGIEeokSQgghhBiBXqKEEEIIIUaglyghhBBCiBHsiVhuO5v5cgXi5dSL5XEyc2U9zjad\n", + "yKzjnZeOrc+FUDZ7eOj8tno63XxO05IZsEHa7lsiJpPX2RKuTiQzr6OQ2vd+Q03yl7npYJbsftgs\n", + "1rHM22C+5q/Lw1/zgvhzr31Otnz2oU1XpyqXruz4scPZ8hf/8EuuztHn7HNls438fBZnSdsREhjN\n", + "Hc56bmY9EYNxFvdIBjS0RLzuU75eTSRr5pUH2H7JhxQ4cObzggjwfSTnjH9vEeGeFBkOdQhoxF9i\n", + "PfSsC7IeUrb+XIrGl7nLV/h7pp35NtgBCb9nsy8wtx7E9UieIx0R4IUQz3z0TZQQQgghxAj0EiWE\n", + "EEIIMQK9RAkhhBBCjGBPnKi03M2XqzxsMxH/yaqpK+rg8EPvhZJI/JUCPI1E/BUWljjkjbMnbhGG\n", + "TzJ1pCBbL/rc42EhnXiYiYVDEgejAE+r64c5GdU0D088+8TTrs6+wxu+bH4wW/7Mlz7t6rzyn1zn\n", + "yh5/aDtbPn3mnKvzgz/2PFd23xcfyJZTmrs6jCFmUSACW8L2i8R/6vztttvl7bls2TVmfRh2R0JP\n", + "GXg79MxtIsGPbgbzgiaHOgpw9FJHwllJAGdwt/JqJyoufPvON/3+pgsIqK18G2wf8Me0nMB6/iCt\n", + "JYfZgnNVsWDdYUqbEOIZhr6JEkIIIYQYgV6ihBBCCCFGoJcoIYQQQogR6CVKCCGEEGIEexO2OQNJ\n", + "fAZieeUDK3ui/MaAQX7EbE1kNnYQrWPBEvKIcOtrkW1Xrix0KLL79UjGohVweXqSuogieUrkvbgn\n", + "lxkE+NT542bsbO5ky5OZb7sjVx5xZZ+/9yvZ8mVX+kDVq6866sr+7cf+Y7b8ov/8ua5Oij5I8/TX\n", + "8jDP57zgsKvDSCBV02tOChOEJXatvw5btW+rczuwHhmYMF/zvWMNQkFLEpDJgeMi++vJPWNptSCe\n", + "kr9vE4TPVq3vZ6n22wrQnti+jHLX73/jrK936Hzedv2UBYf6e2ZrDvfaAd92LRmkgrB7nVr5Qohn\n", + "PPomSgghhBBiBHqJEkIIIYQYgV6ihBBCCCFGoJcoIYQQQogR7IlY3m3sy5fnuWTcBn9YLjHZzEIC\n", + "oTi1vk7vhU2XWE6EbfZ2STbl6xCxO3S5gBp6lnjtyxoQ3vvOi6yhWC2WdyQpu21BWh/4Pj2b5OtN\n", + "52uuzqMPPkWOM19+wYue7er8yWf/wpVV83wQwrV/5ypX5w8/5dPPjx87ni0XxbBI6BBAYCY+M1Yx\n", + "M+vg+jVE5t9a+rLz27lmPCm9drxOwtax3pyl2RNcP2N9kfSFhI8KNoCiJTMNgFieFn69uGSmfl4W\n", + "42qxPBJBfW3h19vYyp8TaeHbbnvu16vqvA2Kxj9vqoYMZIFk80hHJqxOZBdCPPPQN1FCCCGEECPQ\n", + "S5QQQgghxAj0EiWEEEIIMYK9caLWDmTL/RTCNpmH0vtAxYgVOxJjR0IzE4YJRhI42JNtxdXvnO6Y\n", + "zJwQRA7JutZfCtxWQ5wvgxnhqTnCdBkIWQxh2Pt0KPP1LpzbIbV8e1559cFs+fGHHnd1lsSXef4N\n", + "z8mWH37ga/6YuqkrO3JFHq555onT5Dg9Pbo4JOS1I34e9paatHlPLsQcgh73+QxSO7Dhr/usyPc4\n", + "rQaGNYLLxPwn3odgvda3uS1IH17mTlSs/Xrlrj/2COIZuT0ciclqgQWHgkdItsXaADdV1r7OZEmc\n", + "RLzXSDCqojaF+PZE30QJIYQQQoxAL1FCCCGEECPQS5QQQgghxAj0EiWEEEIIMYI9Ecv7KpdL+yJf\n", + "DkTqLjoiY4IMzYI1A5GAUfQONFHRy9GJK7dwUGxG+vwYWvMCdUvCGXuUVAPRT+GQiuAl5DKSEFJQ\n", + "WcOAMEMzs7bNzwVFbDOzQ4e9Hf30E0/mx1T5Njhy7Igre+ThR7Plo3OfPHno8oOu7Ny5zXx/cVhX\n", + "T3g+RFZmAwN6uBAFyU6cT/312z/L+/rG3NdZm/jrV0BfSGwgBCF1eZ9i4ayW/LWxPg/SZMGasZu4\n", + "srDMt1Us/P6mjd9fSnh+q8NS+4lvg8W6L4OsTatLv+0dnyFrBkI4uSzWLX1ZAX2IBdtGcgxCiGc+\n", + "+iZKCCGEEGIEeokSQgghhBiBXqKEEEIIIUaglyghhBBCiBHsiViOCeGo0rpEcTOLRCyNEVKUiXgd\n", + "AhM2QUgnad19IhL3APezI5JsH3Lhtu69ddx0TDYH4Z7573DOMfq2q6K3XcsyT4APLA2dkh9ENfXH\n", + "vdz1KeYo728c3O/qnDnzhCvbdyg3fCO5Vjubfn8bB3PxOQ1Imzcz6zq4yGS1QPoGitCRJGXPKt+B\n", + "ZiD9zwu/7Qnp1zjOYtkNGxgQcFBDN1Qshz7bEXO+8cdQwHHFJTnOmtzb0Nljsfr61Wu+nbb2+223\n", + "0/zaNJXf9oJsqwNxHe89M7OSDGTp4dZiz5uOPW+EEM949E2UEEIIIcQI9BIlhBBCCDECvUQJIYQQ\n", + "Qoxgb8I2McgSfRLiP/FATAjkYz4CCb+MBQRGkjnU+czuq72TvvOz1PdwPok4J6klLhX6Kz1xTty5\n", + "eLepJUGaCVyVshz2Pu0VM+/+sEzQqsq9sN3dha8z8Z5NNcuPa+vCrqsznftkRNDurN4ZFkZZQltF\n", + "4tSxXNIS9hdIDyrJtkroe6QJqAzXQUhmx0JlCRH7EPHzAvnbqgN3KjbkHu1IX0iwfRSEzGhArWF7\n", + "klBXd4xTv//dA35/C+j7dUH6RrXaiWIWU2Bhu7D5yNxNZW0K8W2JvokSQgghhBiBXqKEEEIIIUag\n", + "lyghhBBCiBHoJUoIIYQQYgR7IpajQ4k5cz0xNmP05qWb2Z3ImZFZwDDjfUIL2cyMirqr3zlZaKY7\n", + "QRZmiBK5mQUINGRhmwlSF2NBpHUi6mMjd+3QsMZvvGxmlkiYYNPl4Z7rlZfBm6UXfBe7+XqzmRf3\n", + "myUJVKzrbLksB3Z1kH4D0YeZbI5mMAsFDUTCx07bkOvQEam6xWvK+jkDD531DXLOPkTSn0tB7tEQ\n", + "8qDXNHFVrCfn5wY6kG07SNBsM2tcWQL5uy/8/d8z2bzEvsHCRclABCjqC79eTwaNCCGe+eibKCGE\n", + "EEKIEeglSgghhBBiBHqJEkIIIYQYgV6ihBBCCCFGsCdiOcqtOEF7oBKpFy8DmNY9qZOIpR4DCtu+\n", + "GRKTZAekJi9rLz4XICu3nd9f25NjgLTnRNsgP052jExy7uD9mZ0vI8H2WTJ31/mU6Mlafn5168Xd\n", + "Zesl4H378/bsGr9eS0Kwp1OQhwcmeqN/XjGxnJwzNnFBkuMjOQYU1xP5u6bH1G8zCyCSJxYTT8BB\n", + "BmzgBSZsX1wPBmOQ3fVMuK9g+6QvpoIMDEh5+7FQc4SJ+2y9BNJ4x27rgs1iAG3Xk/2xQTErls3M\n", + "uoH3nxDimYW+iRJCCCGEGIFeooQQQgghRqCXKCGEEEKIEYSUBsoi36odssRIIYQQQohnKJd6VdI3\n", + "UUIIIYQQI9BLlBBCCCHECPQSJYQQQggxAr1ECSGEEEKM4G/8JeoVr3jF3/QuhRBCCCFG8Y3eW/7G\n", + "R+cJIYQQQnwnoJ/zhBBCCCFGoJcoIYQQQogR7MlL1Cc/+Um79tpr7fnPf769733v24tD+I7noYce\n", + "sle+8pV2/fXX2wtf+EL7tV/7NTMzO3v2rJ08edJOnDhhN954o507d26Pj/Q7j67r7MUvfrH96I/+\n", + "qNn/1969vLSxhmEAfyx1JYK0aLSOgogmjpdq8QIuG4IgGq26UEFBxY0U2tK/oUmKC3XhShBEoXFb\n", + "Sg0agiB4gZIWxQQUSSAadaFmoUhj9T2LAzl4ij2Qk5lA8vx235dZPDwhkzcXZsDOtRaJRNDT04OK\n", + "igqoqoqtrS12rjG73Y7KykpUV1ejv78fP3/+ZOcJNjw8DIPBgOrq6tjenzq22+0oKyuDyWTC8vJy\n", + "MiKnJd2HqNvbW7x+/Roulws+nw+fPn2C3+/XO0bKy8zMxMTEBHZ3d7G5uYnp6Wn4/X44HA5YLBbs\n", + "7e3BbDbD4XAkO2rKmZqagqqqsavzs3NtvXnzBq2trfD7/dje3obJZGLnGgoGg5iZmYHX68XOzg5u\n", + "b2/hdDrZeYINDQ3B5XLd23uoY5/Ph8XFRfh8PrhcLoyNjeHu7i4ZsdOP6Gx9fV1aWlpia7vdLna7\n", + "Xe8Yaaejo0NWVlbEaDTKycmJiIgcHx+L0WhMcrLUEgqFxGw2i8fjkba2NhERdq6hSCQiJSUlv+2z\n", + "c+2cnZ1JeXm5nJ+fy83NjbS1tcny8jI710AgEJCqqqrY+qGObTabOByO2HEtLS2ysbGhb9g0pfs3\n", + "UUdHRygqKoqtFUXB0dGR3jHSSjAYxPfv39HU1ITT01MYDAYAgMFgwOnpaZLTpZZ3795hfHwcjx79\n", + "89Ji59oJBALIzc3F0NAQXrx4gdHRUVxdXbFzDT158gTv379HcXExnj17hpycHFgsFnaug4c6DofD\n", + "UBQldhzfV/Wj+xDFGxDr6/LyEt3d3ZiamkJ2dva9xzIyMvh8JNCXL1+Ql5eHurq6B29Wyc4T69ev\n", + "X/B6vRgbG4PX60VWVtZvPyOx88Q6ODjA5OQkgsEgwuEwLi8vsbCwcO8Ydq69/+qY/etD9yGqsLAQ\n", + "oVAotg6FQvcmaEqcm5sbdHd3Y2BgAJ2dnQD+/vRycnICADg+PkZeXl4yI6aU9fV1fP78GSUlJejr\n", + "64PH48HAwAA715CiKFAUBQ0NDQCAnp4eeL1e5Ofns3ONfPv2Dc3NzXj69CkeP36Mrq4ubGxssHMd\n", + "PHQu+ff76uHhIQoLC5OSMd3oPkTV19djf38fwWAQ0WgUi4uLsFqtesdIeSKCkZERqKqKt2/fxvat\n", + "Vivm5uYAAHNzc7Hhiv4/m82GUCiEQCAAp9OJly9fYn5+np1rKD8/H0VFRdjb2wMAuN1uVFZWor29\n", + "nZ1rxGQyYXNzE9fX1xARuN1uqKrKznXw0LnEarXC6XQiGo0iEAhgf38fjY2NyYyaPpLxR6yvX79K\n", + "eXm5lJaWis1mS0aElLe2tiYZGRny/Plzqa2tldraWllaWpKzszMxm81SVlYmFotFLi4ukh01Ja2u\n", + "rkp7e7uICDvX2I8fP6S+vl5qamrk1atXEolE2LnGPn78KKqqSlVVlQwODko0GmXnCdbb2ysFBQWS\n", + "mZkpiqLI7OzsHzv+8OGDlJaWitFoFJfLlcTk6YW3fSEiIiKKA69YTkRERBQHDlFEREREceAQRURE\n", + "RBQHDlFEREREceAQRURERBQHDlFEREREceAQRURERBQHDlFEREREcfgLd2vbS3y+X88AAAAASUVO\n", + "RK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "source": [ - "The fourth layer output, `conv4` (rectified, all 384 channels)" - ] - }, + "output_type": "display_data" + } + ], + "source": [ + "# the parameters are a list of [weights, biases]\n", + "filters = net.params['conv1'][0].data\n", + "vis_square(filters.transpose(0, 2, 3, 1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first layer output, `conv1` (rectified responses of the filters above, first 36 only)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "feat = net.blobs['conv4'].data[0]\n", - "vis_square(feat, padval=0.5)" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvWmMpFd1Pn5qr+6q6m1mumfp2ccz3m083mIb8BgMRkQY\n", + "J8FsIUAQIkokpEhByodIAUWKiBIJKUo+ZRMghLFQiBEIh0VgYztj43Uw9tgeL+NZerae3qura/19\n", + "qDynnvfeU29V95iM/3/d50vPVL31vnd/733OOc9JtFqtlgQEBAQEBAQEBKwayYtdgICAgICAgICA\n", + "/68ibKQCAgICAgICAtaIsJEKCAgICAgICFgjwkYqICAgICAgIGCNCBupgICAgICAgIA1ImykAgIC\n", + "AgICAgLWiN/KRurBBx+USy+9VC655BL5u7/7u9/GIwICAgICAgICLjoSb7WOVKPRkH379slPf/pT\n", + "2bJli9xwww3y7W9/Wy677LK38jEBAQEBAQEBARcdbzkj9cQTT8iePXtkx44dkslk5GMf+5g88MAD\n", + "b/VjAgICAgICAgIuOt7yjdSJEydk69at+v/JyUk5ceLEW/2YgICAgICAgICLjvRbfcNEIvGWXBMQ\n", + "EBAQEBAQ8HbAu9/9bvnFL35hfveWb6S2bNkix44d0/8fO3ZMJicnL+iepVJJlpaWRESk2Wzq5wMD\n", + "AyIikkqlRESkWq1KtVpd1b137dql5azVaiLS2eglEonI8wB8b7mXZTIZvcYqSzKZjNQjkUiY98lm\n", + "s5Hr6vW691sLqVRKGo2G/h/3jtu8JpNJ795xz8BzRCTyLGBwcFCfu7Ky0tf9eiGdjg7Ver3uXVMs\n", + "FmX9+vUiIvLmm29qOdGvXHaUj8uVSqWk2WxG+sOqZy6Xi/yW+xDParVakXGEzyzgfjyON2zYICKd\n", + "8Tk7OyszMzMiIrK8vCwi7bbFGOP2QFsNDw+LiMidd96p/QAzeyKRkHXr1unzREQWFha0jO5fvm+h\n", + "UJBSqSQiIsePH+9an5WVFa0T0Gq1ZMuWLZH6vvHGG949Nm3aJNu3bxcRkcOHD2sbuCgWi3q/w4cP\n", + "6z2t8YbvCoWCzM/Pi4jIyMiIiLTn7dmzZyPX33zzzVIsFkVEdAHldr7yyitFROT8+fMyNTWl9QMw\n", + "p7773e+KiMg//MM/yGOPPeaVf3FxMfJZJpPxxqyFgYEBHQv79+8XEZHLLrtMfvSjH4mIyPT0dNff\n", + "XnnllXL55ZeLiMizzz4rIiIvv/yyd91HPvIRXc/xly0MvL5gfKCNCoWCVCoVEbHXCYzPDRs2yJEj\n", + "R7zv0f9YU/kaXq+wVvJ6u3v3bhFp942IyPz8fKQMiURCUqmUlhX3Gxoa8sbZyMiIbNy4Ue8jInLy\n", + "5EmvvNwfQ0NDItKeq1ZfYk3A+Fu3bp3ZBsD69evl3LlzIhK/pieTSW+96fYOi3OPRptym+E+/xfp\n", + "edPptLnGu0gkEtp3KCvGi4j0nEe91mbgr//6r+UrX/lK9/L2LOkqcf3118srr7wib7zxhmzevFm+\n", + "853vyLe//e2u17svm8HBQW9hWVhY0MbCwra4uKiDFt/lcjkZHBwUEZFyuew9A2i1WjrpX3vtNRFp\n", + "T2o0JiYLvwz5t3GNjs7EQGTk83n9HM/IZDL6UuKFz92EJZNJfS4GijVI3MXCAl4oaLdkMqkv2n7B\n", + "z8GGljcYqF8choeHta+thRblTyaTOqmsOqE+iUTCeynzIoL6tlotc3FB3/ILwSoXb5b4bzf0+h7l\n", + "Qh3r9boeHPAiWl5eloWFBRER/dvtXhhP+Fuv1/VFj3qnUilvjFp1ZfDiam2g3v/+94uIyKlTp0RE\n", + "5LnnntO+2bRpk4i02yKfz4tI5yXHwNguFApaT2sDBUxMTOimk+tnAS8trBt873379nkbqYMHD8rn\n", + "P/95ERHZvHmziIh84xvf0O/xYjt9+rTZx9zWIiJ//Md/7G2kJiYmtN/R1/l8PvYFgM011i4R0bL/\n", + "6Z/+qbz44osi0llP8vm83huoVCq6RsYdPo8eParX9bIkuHN0aWlJxzbcPWq1mo6Pubk5EWlvpLAp\n", + "ff755yPPFulsisbGxnTMcNti04J3Q6vVkldffVVERA4cOCAiIo8//njknYD+cg9KKysrej+sYbOz\n", + "s1qP0dHRrvUfGRnRsYXf7t27V+eK9XwcjoaHh6VQKGi7uXDfid1gjf9kMukdMBKJhLdRSaVSeh2+\n", + "67UJKxaLMjQ0JIuLi14Zu5UlrswYO1y2uEN7q9XyPue5Y5EPvHmy5q21ufryl7/8f7uRSqfT8k//\n", + "9E/y/ve/XxqNhnzuc58LEXsBAQEBAQEB/7/EW76REhH5wAc+IB/4wAf6utY91S8uLurJAqfTmZkZ\n", + "3VFi15tMJj0z1PLysrIJvIt1Tx+5XE5PBzgFzM3N6UnE+i3Ap6K4+nQ7BeIzPn3g5MgMAk42KAub\n", + "qPqh/bshmUzqDt7a4WMHn06nvZ05n1xx3cjIiLYHn/T7wdzcnHnKdc14iURCy2qdINgkZqEfkyh/\n", + "H3ddOp3W71HOZrPZk80RabOtYExR1kqlouXj9sOJFkxDuVz2mKhCoaD3wxgaGxvTeQMGZmlpyWOQ\n", + "Go2GMgJcdsy9sbExEWmzLWAruR3xbzzrHe94h+zZs0dERA4dOqT3Q1thbCeTSZ3DPI7BdoG5ajab\n", + "sUEquN/k5GTfpgYwpxMTE/LCCy9EvuvGep0+fVpERK666ioRiZpY0B+9nv83f/M3IiLyta99TRmS\n", + "hx9+WETaTATYE2D37t3KrHK5wORZp3r04eDgoLpSPPXUUyLSHmNg7TCepqen1ZQHBsQy97z++uvK\n", + "DqzFTIL+h1nwpptu0vmK/j1y5Ih85jOfEZEoIwWgfQYHB7UN2GQIVgdzitePn//85yLSZsSYERKJ\n", + "sh4wD584cULHCQNr3DXXXKN1dU1xc3NzylihTCdPntQyu88XkQgDZPUrkMlkvPdJv2g2m9omzH7j\n", + "M24v9xnFYlHbFX+5f8FEDQwMeKyXZZ7rtQZbc4nXJ7YqdLu+1/Os3+C+3dx5eiEomwcEBAQEBAQE\n", + "rBG/FUbqQuHaWnft2qWnP5yo0um05+Ar4jsh8ykLO9tyuay7cJzGkslkxG9JJGpDxd/z5897vhbV\n", + "atW7bnZ2Vk85eAafLi07uOX7wuwRds1gs8rlcsTmLdI+taFcFtvTa7eN31jsDrMx+MvsHDM0+N5i\n", + "g+LYwlarZToZolx4Bvd5nI+H5fieSCT0fpZjfrey4i98wVZ7QoQzu1tmOLJi3MG5WqTTfmCeGI1G\n", + "w/PrmZ+f1/GB+iwsLHhOsPPz8zreeJzgezBSZ8+e1RM6Ttb1el1ZD/ivbNiwQc6cOSMiov5YuJbr\n", + "NDY2ptcB7DuIub+ysmL6hYD1QvmKxaLJYljAWB0aGtK6oF+vuuoqj9kQ6TgVY77Oz88ra9av38qT\n", + "Tz4pIm0/nTvuuENEOv5NFgtx5ZVXavkOHjyon2O8WU7Je/fuFRGR//zP/zTHJQILMDbeeOMNrS+e\n", + "tXXrVh0LLiPaC5lMxnM2txisxx9/XP8NdufEiRMaBIH+terIjM6OHTu0HuhDjPFGoyH33nuviIjc\n", + "f//9kXoz9uzZo88BOzYwMKDzkMc92goM1y233KLtzD5Qd955p4h0gjrYwuK2D8oq0n43gGXFOsXj\n", + "sBfz4voai0TXMWuNZJ9MwLUGWGM8mUzqGoj79muN6DeQgoFnZbNZjxXj94UV6OH+5TIzLjgY6oJ+\n", + "fYHoFTkAsFMlIj3m5ua0gePQarW8xqzX6160Rq9NBzuxY0OEQbdx40ZdpNlpG5MTL2O+Dp3JgwNI\n", + "JpP6YsFvl5aWPPMmmw/RjtYGjevXLZrM3WxasDY47LSMejSbTV2MrAFqPSPOzNhsNte8eWm1Wt7G\n", + "kjc0vIFDGbCAJpNJr28ajYZZBrRBHD1frVb1t7yY4EWGhTSVSulnExMTItJxzGVY5ahWq/objM9T\n", + "p07pmOWIFsCl6lEGkfYCiegpzL2ZmRnPDP7UU0/FRolh7Fjjc2BgQNsZL3CrHXm+Y24dPXpUzW+9\n", + "gBfxSy+95I23u+66S+vOmxfUGabAarXat6nLxfe+9z35wz/8QxFpRwSK2BuG//mf/9HnYmMxOzur\n", + "JkUgm83qugRH///6r/8yX2rYyLLGn7vmnTp1SsuFtv7JT35i1gVjAmg0Gno/jI3p6WnvIMJr1nPP\n", + "Paef4TCBtZ7XFdSH10qYCoeHh7353Wg0dAPl1p8xMzPjObkvLy/r/fbt2yci7XmJzTDAQQPXXXed\n", + "iIg8/fTT+hwcMF599VVvM5JMJrVfYV5dXFzUNr/22mtFpB1Nifp2W9cBy9TV6xDroluknBXR3c/G\n", + "iSM58bx+5wyiKlEukfYa4gZF8aEY4GCiXhskjDGs+Ty/+3HXAIJpLyAgICAgICBgjbiojBSzRf1S\n", + "a3wy7zdk39qdYhfby7EYu1OcZvlUhO+mpqb0ZAhWodls6m/w2alTpyLO3CLtHTrYB2Z0XLZhYmJC\n", + "WQXslOv1uoyPj4tIx2xoOYSLRE8q/TrquVoibF7EDp5PcFw3i27F/Ti01qW7c7mcnkSYyo9jotjx\n", + "2Q2fXV5ejugaifQ+FcWdtnK5nI4ZtMvQ0JCWLy5EnE2eDJw2ccpuNBqeOfj111+PLTOQSqW0DKjH\n", + "2bNnvTkwODhoOr/i9Myh7AhXB5uaSCRk27ZtWlaUvR/Jiw0bNnjaQsPDw2bAAOvRibTHD8rSzaxm\n", + "aQq5sE6a3U78Vki6K1fQLx599FG55557RETk7rvvFhExQ6rZ+Rzze8+ePR4jVa1WVQph586dItJm\n", + "UcCeWGW3NKAg7XDq1Cn9DRiiboCpEGg2m57ZhTWyMCbHx8dV4w2oVCp6XZz+V7Va1bUUfbhu3Tpl\n", + "sVzTmIjI7/7u74qIyA9+8AMdsxhD09PTXkQ5r+8vvfSSiLTHLMyQYNG2bt2q45MlV8AwwvRoadY1\n", + "m01lomCiPn/+vDK6WJ/e9773ySOPPCIi7XXA1WTrBUv6xXKqRvksyQFrzWLzH79LLA06d61llorX\n", + "Svd9wSa7OD2pXs7hXFbXDabRaHiO9GtFYKQCAgICAgICAtaIi+5sjh1oL+Esl1VwFbxxvcWyuDvg\n", + "Wq1mPtcV8ywWi7HsBYuDuqf7bDarz2Mnc9fJudVqeWwGi2/ibzc/EDju4iReKBRWrSZuqeHm83k9\n", + "lcApOZlMahvxKcFl2azdvaXgzPdh9sxty+HhYWUiUSa0PZfPYiitcdIvrPFkPSNOMJJhicflcjm9\n", + "p8Xo4FTcL9LptI4JjN1KpaLzp1+VdfTlwMCA9gc762McsDN8HCOFfhsZGfHkD1qtlo4ZFka0AB8v\n", + "+IGdOXPG9AvpV7EY+M1vfuMxPiIdBocZ09WK17rPEWmzDSJt5ieuj9GXroO+CzDE4+PjyipZ89/6\n", + "DMEBe/fuVd8s9NGOHTtM5XlcZwHzYWhoKOLTKtKe2+5n69at0zUQrNLCwoK2M+qzsLAQCRgSaY8n\n", + "937cR+wb5TKhpVJJ+wMM0szMjNxyyy0i0lGzP3v2rNfnzJZym2LeYL3m+Q6fq5dffjkSvOQC8+gH\n", + "P/iB+qKVy+VVsyY8B/r1GQIsYWdm1tz7MNMEWMKY7uf4DusDvsvn8x4jlc1mPemeXoKhcYFLzPDh\n", + "s0wmEytG2g1vm40Ub2xQAU6TgoHMGyrXkU3Ed6ZjVWwswjzROLrM0hlBhB6/yGGKw2cTExM6IeK0\n", + "nrjjeIF3B2qr1fJo3Eaj4dWX78EUZb/mUmuiAZbZp9VqxZrHrImOZ3Qzxbi6INVq1etDNueyGdQd\n", + "8IVCQc0YTE2vNaVBq9UyTUUYg5b+Uxz9bh0SxsfH9X6uRs5qAAdf1oeBKSOdTmu/oR/K5bI37vbu\n", + "3aumJNTt5Zdf1rGAct5xxx1aT5goepWZN+D4Lebj2bNnvYwAVgTrwsKCft/tRe6mz+i379988011\n", + "xMZLcmVlRc1G2LgnEom+ndstfOtb3xKRjrP5e9/7Xt3AQZG8UCjoC7RXRCLGJe4xOTmpmlH9RlJx\n", + "tBs2LYhE4wMLIy7QB+N8dnZW+wkbpHPnzummBfN6aWlJ+8kyxbCmHsYixudzzz2nztnQzWo0GjpO\n", + "2NTmbghHRka0r2Hie+ONN9T0d+mll4pIezMWF6GJjWMqldJ5ZgV1YMN82223qckuDul0Wsu3lvy0\n", + "1jsmzmTXz33wW+sa9AkHSmFd4N+gbTi1i/s+6RZI0295mZTAZ64pk7NYWKm2VoNg2gsICAgICAgI\n", + "WCMuOiPlgne/FoWOz6xQTVbtBprNpmlOc1kP3jEzM8D5r/Bc/JtVpV3zlrWzbTQaEaVyfBan5mo5\n", + "5GFHz8/oph8Sh7jTOjODrKtlMVFxDFgcM5DP5z2NJ5H4sFPLKZhViQHLoT6ubzjPFOcidJ/HpkIu\n", + "sxuqa8Fqn3q9rm0aZzJiJ3fuA5z0Oc8hmCg4Ih8/flz1gLg9oAUFZmBlZUWdX1GfyclJvY7VvaGn\n", + "AwfZXuZNlHlqakrZJuuE2evUCYYEbeWOqzgF/DgsLCyoPhQYnePHj2v/wyE7Tt6iH6B+X/va10RE\n", + "5Pbbb9fxiCTCN9xwgzLccYxUMplUduxXv/qViLQZLsyHOGzcuFGZF+D5559XGQWMCctcOzY2Fqsv\n", + "xWsRfo+kyk8++aTHDDH7YDnIx6lTN5tNLzMEM00oy/79+73nsnmO5QxgRgUTxq4FbNVwWarBwUEd\n", + "f1gHSqWSx65WKpWIPALgrk+JRCJWFb0b3FyqjUZD23CtjEs3oL84byf6vNFoeBadbu8QgIOYLJke\n", + "911jmfXZwZ/fs5Y58q1qj8BIBQQEBAQEBASsEW9LRoodDruhXq+bsgGW4JjLTjSbTS+f0vLycuxz\n", + "cWqqVCqmOCJOKlZeIN4J43tcz+GbbuZt/owdla0d/Vr9gNzncDnBcuB53ZiuOCaKv3P9jVZWVrxy\n", + "s58TQqzr9brZ5gjRZibKtY0zI8nt6kox5HK5iFK9C4yNarVqMkeoZ7+OyKj39PS0KRUBwPepUCiY\n", + "ztD4LY9ZtJub00yk0y6lUslzcp+fn1emAfODpQ7AYBw6dEjlGPo90bEQ6Vqd/5klhdK0i7X4koi0\n", + "/bTAdoHhGBgY0LbEHLDysFm48sor5ejRoyJirydwgn7jjTe0bXDvkZGRvtp1fHxc+wSCoddff72y\n", + "AOvXrxcRMcdNt/UC0gQYE6xSD6RSKa0bYAVm8P8xrq6//npP3JIBJm7Lli06bjlfo8sQt1ot7S+0\n", + "8xVXXOExao888kiEWRdpj12LMUcZ8H6xmGcLCwsLOl/ZkuGybE8++aT80R/9kYh02rdcLnt9Xq/X\n", + "1zRX4nKprgVuG7FEBOpUqVS856VSKU8ImN9dyEuYyWR0jLJfn+s3V6/XvXdlIpHw3k/8zuH1He8z\n", + "fGb1K8s4uNk04pBoXegbeA3otdjFpQOxYDkExym4WpFcQ0NDHo1tJR4eGBjQ3/YyQ2AiWuYrRq+I\n", + "RZH2IsJRWP3CHRS9cCHRC0ytulpLfG8sNpYTOavOM/A92oA3er02L3B4ZcfHfkyU/HKw+shSxWfT\n", + "0lpf6lbZ0+l0rHI4UCwW5YYbbhCRTluxYyucyaenp1e90PKYxMvBjYTqBU7ZYzlDu5GzqylXs9mM\n", + "jKPVlKvbs5F8HdFdlUrF1Gxz8bGPfUzNbW5S4l7I5/ORw6GInQFhx44dukHBi/ncuXParnAYf/bZ\n", + "Z71nFAoF7UOOCISTO+aUa/4Tia6fvL70E+Ry7bXXehvMer3uRd6l02n9jE13bjqY/fv3exuzUqmk\n", + "dePyY1PMaYiwFrG53l1/ukUcIwE1zNwi/ua1VCppWfm+qBv0v6w+6ub6sNo13XrfcWR4HLpdg00/\n", + "HyBxEOG2dBO8p1IpM/mx61aRSqW89YHdaoBqtWrOw7j3/1qA9bxbewTTXkBAQEBAQEDAGvG2M+2J\n", + "+Ka4XlpAbC5jxgK/da9rNBp6IsCud35+3jPtWaxFt1B3lBU79aWlJVOd3A2d5rpZZcUpj80DvNt2\n", + "mSvOPbQaHQzXJFatVs1EmC7dmkwmtZ0sCpaB7/nUiROGdeLj9kBbgoVqNBomE4VnoJyjo6OxjCDX\n", + "0S1z19OHw0S9VaceC/0yKxjPoMtFbAdwsC0sp9GveY7bA/Ngtck+manjMcRq/d3AJ0KeAxyK7yo4\n", + "W+1msTsiNgsGBg/z71e/+lVfJ3nOAWchjk3NZrPe2mGV9+TJkxr6/6lPfUpE2kreME3hOwtLS0um\n", + "mdI12aVSKW1Ld211YSlgu/354osvesncRTqmc6wN9Xpdnf7ZdOfKpVjyDMPDw2oyg6TF1NSU3gdO\n", + "/YcPH/asELlcLrIGApwkGXj00UdFpCNlcfDgQWWiUK6FhQXTZQRj45VXXunaVtVqNTJH1hrowBkp\n", + "Vqsn1Q3u2E4mk2ZOQViLXHV3kej7wjJHWu+2OBkKrmPcemmZGS2475I4BEYqICAgICAgIGCNeFsy\n", + "UgB26JaDH59OmZFyfXN4Z8qyAW4468DAgJ4YeMeKEz52whxG2Stnl3s6Pn36tHkyiDs9s2CoxYC4\n", + "DBE737n25H7Au/+4nbglvdDLZ8xVr200GuYJw22PZDLp+R5w+VD3wcFBPcnjWefPn/dOXzye4k5o\n", + "mUxGxwKzFVYYrRUosFZw+K4lOuuWUSQqPAe/GW5bViAXafvIgJHA6b3RaPRV/m7SI1YbcjizSJuB\n", + "QRl4PMc5yOIe3B9AKpUyc3+xAKHlBGuF2VuAwzN8WQ4dOtRXTsHnnntO146TJ0963+OkXqvVvHbr\n", + "dn/2lxNpMzWQq4BqNo/TXn5mmK9wTl9ZWfGYBpZs6dcnkYM7XF+VlZUVncOoz9mzZ5UtgmL96dOn\n", + "1SGf/adcAcXnn39e9u7dKyIdcdjjx49r22Ns85jFvGB/V5bTcJ3SFxcXdcxa7QehzT179qgA6JVX\n", + "XikibZYK92ZfXvyW12hLQRxoNpsRiYHVoh8Gylrzu81rl9XppqLvvhMsOR8R3584kUh4rGwvBinO\n", + "CsICpHyfOOFOVlTvhbf1RgqwktvygO/XCRvXsQnQ6hw2VSE6CM/ismCR6EbPWxsLd3NVr9f13lbC\n", + "YetFzxELcYkdV/NStzZNVkQLK+PiO+vl5ZpnBwYGvJdWt80aPsPCXa1WI86bIlGaHPW0XkCWo2iv\n", + "TQnXEWOKaXXLBNhPW1sOuVx/PJ8nLsrSbWxjrGKcLi8va1nQVuzgDefaoaEh3XDx4oaxjRc0b8wA\n", + "a8HauHFj7IaBTYHuhrob4BzMGm6oG7+IuG/iKH2eN/2aNlxl81Kp1NdG6uDBg3LFFVd0/Z41ilw1\n", + "cZGOSQqO4BzhinaZnp7WTSbKtG7dOt38wbQ7MjLimXk5StXVHXKBtkY5e22keExb7Yz5iOdx+TDn\n", + "OXqX5xY2NNA2e+2113QjyHCjOlOplM4HRCYODAzoeOcDGJ6Hw9vU1JS2gbX+WAmXsaHiICb8NpFI\n", + "eBGzuVwuEhUn0h4j/E5YS8aDfsCbCdcthF1FuF/dKFZOAMyIW+/Qb7Ozs2bd0Nfoo8XFxdh5a63R\n", + "vXTlXDImkUhEMqqI9KeoHkx7AQEBAQEBAQFrxNuGkbIcmnknbDmZ8olGxE4OXCgU9Lc44cSxUAw+\n", + "CfH3rDwrEg0lZUdFKxzYZS4SiYTuePl6Vy+DKfZ+nZu7sSSuEzlrLfVyrHPLxf9G+TnsFSzL0tKS\n", + "l0uO2wVUfC6X05BlPvni5IOToCVNsWHDBo89WVpaijBbqKPblsxS9GJK3Ho3Go0IY9kNuVxOrwMb\n", + "kE6nIw70KItristms2YoOpgSpqZhCsFvW62WPg9sBU7MjEwmo30ERsrKK5fP5z2z0cjIiMlIueZ5\n", + "K6+We2+UHSd4tOnCwoKZ5NV6nmUSxToxPz+vZXDD7l2gHdysAv0AzAfAOT5xv5mZGe+ehUJBn4vT\n", + "8auvvmqaUaCQjX5i0xzaatu2bR4jVSqVlOXtd7yvRc7DWms4F5+IyKZNm3Ru4rNt27bpeo3vEomE\n", + "fo96b9++3RzLeB7WlYGBgYiemki73i67try8rGOHTcZ4LsyICwsLHrPKcwJtC1YLvxGJZlHgHJOu\n", + "CXB5eVnZx0ql0reG2WrhsjL9AO3L4w2MJZzvp6amvITczHChTYvFovY1v0fdNaZYLHosEb/j4hTw\n", + "LetHNpv1+pDzq7Kjfy8ERiogICAgICAgYI142zBSAIdCW7Z2ZkKwg8d37C+BHebi4qKXMX5ubs47\n", + "EWQyGf03dtScf4nL5zIXLJyGzzj0k3fN7q7fytDNz7BU0fl6V1E9mUwqS4HTjAsrD53lZBh3Hdep\n", + "W+46kU578IkL2LRpk7ImEC3s5iDvOsFWKhVtL7Qzs1FgM4rFoqnObPVDHBvHDAcYJMu3gOGGag8N\n", + "DXnOsqVSSdsKJ7TBwUG9DnUbGhrSExr8KrZv364nXvy2Xq9rzjiLpbBC8nF9Mpn0fLIsBfFkMqlz\n", + "iaUHXHDoPK4rl8vmyZH9oESifnG4vh+RzjhmFewEC5u6ucC6Ac7mTz/9tH7GvkoWXEXzj370o/KN\n", + "b3zDu44FMUXajuMQAMX8Zj8iZiaRGw85+SzfQYtF6+Vkz0C7YV2JC0EXiTql89osYvv5zMzMqJM5\n", + "6vbmm2+qPx/GO7fBU089JSJthgh9yCw4+gTz/NJLL9WxzBIgGCfXXHONiLSDBNBuYLCY/ea+coNi\n", + "NmzY4LGyc3Nzni9vo9GIONWLRP0iu/WX5fAeh36tDLyOdROwRrkB957sA/uzn/1MRNrq9JbavRtI\n", + "UyqVvDke51u3FlgCybVazfR/WstzLvpGyopUsPRtXPpxYGBAXwpxjuPJZFIbC3+tSJ5isaiaMdhA\n", + "jY+Pe4tcMpmMmAhEujsBWpsOdsh24ZoMGey8zguV+1mr1dIFo1sajX7QyxmXkzS7g5FNGECtVvMm\n", + "5NTUlDqNIurIpYIBON/it+fOndN24mdhEcILxUrPYTkldotEc6M66vW6FxnYjRJ3TQRDQ0ORMSjS\n", + "3jS55p58Pq/1wIsjnU57Ts7FYlHrx5swfMZmMGjy4LparaaLN5TQT506pYshXuQMlLlcLuuLAOYG\n", + "OGUzRkZx6FrkAAAgAElEQVRGdA7wixL3gSmAzX18gEB74AVizdvt27dHFmuME1cPie8t0nlx9TKX\n", + "QDUb43R6elo3UK7yNoNfvqjvpz/9aXMjBSDJ9Mc//nH50pe+JCKdsc16SVjoR0ZG5JJLLhERkX//\n", + "93/Xz1zzdiaT0aTL/KLvJwovm82q7lOc0+369et142utbXHOxOVyWfvrs5/9rIiI/Md//Ic33tk8\n", + "ibHz8ssv69hGvdFXIp1x97Of/Uyuv/56EREzRQ02op/61Kfkm9/8poh0xsvIyIhu8HjDjfcFNlzW\n", + "+yebzeqc4nUdGyhsUufn573NVTqd1r7evXv3qhXy+01aYrmgcMBNPya/SqXibXxPnDhhJi12x511\n", + "0OVIaF4/sbZxlGW/9VxtEhccxuPSAgHBtBcQEBAQEBAQsEZcNEYKNK3lWI6TKGvQuMxVpVLRHaOV\n", + "ywhoNpsmtQpgtzszM6O73FtuuUVEoqY9VmPGSZ9ZIGvXjvuxRoZrjuRTAMw009PT3q69Wq161PrY\n", + "2JiWBdclEomeDrRxsJz+gUwm46n+sgI62tk64bZarQirI9IeA6xhJNI9LxROo+94xztEpH2yxkkB\n", + "7EI3R2aXObLYNmvssKaI1b+9Tmr4Hv2Wz+c9FpNP6mzOw+fo34mJCe/kffLkSe1jjLHh4WFlUXs5\n", + "Zt91110i0mGrzp07Z6qhYyxeddVVItI+0bvOtBbjwLnvwBLk83mdr7jv8ePHdTyBObEkJVhzibWl\n", + "mBG68cYbRUTk2LFjWgaA6+Y68zOgfI1EwCIiv/jFL0SkPbZhCo1Lqs7tgXFw+PDhWBbzc5/7nIiI\n", + "3Hrrrd53lrlh8+bNWgYwTfl83nvG3Nyc6hphvOzevVuZD/xllh+o1Wr6jDhn85mZGU0izqZHi/XC\n", + "mLDm4U9+8hMRaTOL6EMLYHk4mTfuu7S0pGWFttS1116r6uRgpHh9AyN+33336WeXXnqpiHTvN5dJ\n", + "OXfunLdGcx3xPK4bW1OwNrDeFObAsWPHZM+ePV3bg8EJeN0yAJYOI6PX2uYmtOe1jYE5x+8IsFQc\n", + "yIJ5DysK51zlAJK4OvUqZz/SCXxN3Pz2ft/3lQEBAQEBAQEBARFcNEZqdnY24kfAIow4veB0VCqV\n", + "9DpmHFwlcsvPhX+DXXEul/OYhmw2q45uYKLYL4nlF6y8S8iaDlu/lSGdVZ2tEzxOViIdxofZNJxy\n", + "sMs+f/68d+JrtVp66mRfIEvhlU+YcerqQLcwadwnLoyafdUAi/1gpWrUadOmTeqH8Mwzz+i1cfmZ\n", + "WOS0Hxt/IpEw25LLhev6FTq1gibcHHXlcll9bvCMYrGoYxFlWrdunZYLjBT7wHF4ueuUncvltK3x\n", + "3NHRUT2tw/didnbWCxEXEbnnnntEpHNSfvLJJyNq8i7AFE9MTGh92Z8RJ3kwCHySRT2svGrZbNYL\n", + "4FhYWIi0L3xn3NxtIlF/KMw/tFU2m9XvLSVjHkNg/Czn9ziH7D/7sz+L9QVEe1h9cN1110Uc3UXa\n", + "7QbfNJYHgZ8Y1qdjx47JTTfdJCKddcqSRKjVaqbwMdY0ME7WOsuq+HwPjFmwKUeOHNG2t8YO2MXl\n", + "5WUd+2gXi2Fnp3msL5VKRcfs9773PRERefbZZz1LRz6f1zkE9vG2226TRx55REQ6bNaOHTuUZeNx\n", + "4DIchUJBRVgff/xxrYer7p/NZj1hT2YDLWavWq16chrd0M96x3OG/V3de1h5+kR8qwPPBczBa665\n", + "RqUp0HfValWZKA5AYEZVpD12XCtUt3ysrtgnB0pxOTHeUDdmqS409+BFdTavVCrexF1ZWfFMcUyx\n", + "8XduhF4ymYyNDuHnWsD98EKrVquedP3S0pJOXnaGw2LDL2N3Q5BKpXTAQSdmeXnZo9N5M8kvcCwU\n", + "+M5y9Ma1ItHBYX3Gk2m1iXdZuytuELKeF/oRE61er2sbwbzEm1OAKXQeC9CSYSdM1CmuXbjenJjS\n", + "HReZTKav9DfdIhwBTh/jfp/P57UMGBvT09O68KBt5+bmYk21KOfc3FxfQQatVktTcABwFmXs3r1b\n", + "2wUOuSKdDQPGgRXNKtJ5eaAPl5aWtJ7WRgQv97m5Od3Q4G8ymfRMoqlUKvI8lJH7Eu2PlxcDbTAx\n", + "MaHOvtYGHy/DgYEBLwCFgXm0bt063SBy+fBicVMeiYj87d/+rYiIvPOd7/Tua23uVlZWNHoNa8Ls\n", + "7KyapHguuS+q5eVlbyNjHRDYBITxl0qlzGhN19zLdcMcvfnmm+XgwYMiEu1/V1+NI/QwLtmVAQ7w\n", + "vOlEfRYXF+XQoUNafpFoEA4/w00V9Mgjj8j+/ftFpBMZyOPOCoTitRAbZWyk+HncFldffbWIdPqI\n", + "DxPYQLEqukjvwIhu4M1Gt3Ek0n2N44AckWjdORsE5hna0op6F+n0Ccbi9u3bdU7x2mW5/bhreFxa\n", + "NRfWeuOaq63oct5gdkMw7QUEBAQEBAQErBGJ1mpjAt+Kh/5vaGOj0YjVunApUQbTy+ycZ+Wys4DT\n", + "Cytv45SFHbV7IhBpsyk4YbLiLpcBz7d2y26IaDdzpItcLqdtZTFq3fLixUkq9Arfx4nBPWm4sE4q\n", + "bnkSiYSXq4tDgxk40eK509PTesqAU+LCwoLJ0KAPURarbvl83vs+nU577JOVsDORSHgaT1wHfMbM\n", + "Kvo8nU5H5AdQVzzX1b7B80TabArazZJ7YFX5OMDss3fvXj35stQB5hwcrqempkzFcpiI0Fc4vTOs\n", + "wIFewPOTyeSqtI5E2mMNZhF2ZMU4wneW6Sybzcq2bdsiv2X2E2Hqo6OjptSDi6uvvlpeeeUVEbHX\n", + "r3vvvVdERO6//37vu9HRUXWax6necnzdtm2bmpIwFx5//HFl1jAW33jjDXWQx3gulUo6juH43K29\n", + "XQtBKpVSBpmTArMmn4jNwBaLRW1nduYHMI4nJyc9U1apVPLWXs4ZCHCePjYpgqmDNeCxxx6LOJQD\n", + "rlUjlUppAI8VwHHnnXeKSMdRXkS8RMouXLY1l8tp3ThvIlgUrqOb5UPkwkxTnJTazWXJQN9wrtq4\n", + "5w4MDChbx/XoJ3ddL3D7oczswtOvWnucYz6bNMGGddsuBUYqICAgICAgIGCNuGg+UmCjXMFD7P5E\n", + "Ortw62TbTVnbdaRmxoeZE8te6jJD8/Pz6giM6/nUxv5QLhPApwUuO04bOOHOzMyYzJD7mcVCsN8U\n", + "/85ywgZWs1u3mC+c1lhKwm03tsNzWVxnwVqtpv0En5uFhYWIb4UL9AOf0JnpsuzbrtMy++axU7qL\n", + "ZrPp5cFrtVqmAKzLSPK9+bmuZMPKyoq2s9Uf+O38/LyZ86mbCKBIp11mZ2fVPwjjbmVlxRNuTKVS\n", + "ct1110Xu4fpRiURD7ONChFfLRonY7I2Fbky2dWJEu2FcWSfLer2uTFO3cHGR9ny1+tq63pVnYUBI\n", + "0xL9nZiYkDvuuENEuvuZiLQZmtdff11EOvNn//79Wg+Mq9HRUWVCUZbTp09r0AzGRDdGyu1HVgTn\n", + "z9ycpxxMxN+599u4caOyo5DJePPNNz2BSnakx/XLy8uen9Pw8LD+G+2zY8cOHct/8Ad/ICLtIBZ3\n", + "fO/atUvLjHqUy+XYQBowUQcOHJCf//znIhL1K3IlY7hd8FmtVtM2ZcV89I01hlbDQmG+8rsDayX6\n", + "g9+J1vzC83iNZdV7sMlgsHm9Z0d7MMO4N7PHLNIKcICJm2uP5yCLiFpw86E2Gg1vLPK7azXM2UV1\n", + "Nu+mSuouVIlEQl/gVkSVpU7NukSW6QnAJKxUKvobNr91S/8g0lmgWbGaX4qWHpKbsFOk08GcrJJT\n", + "vqBubhoakeiGDM+1oiyArtSk85tUKqXlQp1Y3ygussmqe7FYNKMuUH5Q5oODg9qWWFCq1arWz6LW\n", + "40xAVp8zNQ3wy5XV5y1TmRsZ2Gg0zEnnUs5LS0uefpGlvdINcQsnmxuZgkc98Bw4tzabTa8/eLML\n", + "U5G1mc7lcrpoHj9+vO/yu+AUP9ZBBGOM5757AHIPWfie29mt5+TkpC72aKNCoaBtZLUzm5L6WWBZ\n", + "1dlyToeWkfXd66+/rmVAuio2GwGZTEbNhzBhXX755bqmPfzww/od2oDNmqgHTF0nT540646+5nlm\n", + "XeeuCZlMRscPxtPw8LBGLLKqN0yF3Fd4wWI9XlhYUDMkXsbnzp3z+uPkyZNqWsO4WlhY0Dny4x//\n", + "WK91NffYbMtK6G6gjLXmPPvss/pvBBVMTExo+2HuVSoVz7THaz7GISdh5whygJObc8RaXHox63Bj\n", + "HQys9wTmSiaT0XmGdblarXptkk6ntc15I+0mXx8dHfXmNb/LeZ3AZ+w87x5EmaBhssNd8y2Cxprb\n", + "1rvORTDtBQQEBAQEBASsEReVkbJ2mCKdXaGl8MrO5K68AIfTW+Yry4SGXTQny+VQV+RTglNlMpn0\n", + "QnUtzRM+YTPb4+6Ua7Wad+rn0ziewTtlvh9OBFaiUHYw57Z0zam4F/+GWSVOQOzS1JZDdqPR8EJG\n", + "uyWcRf1waisUCnotU77cNiLtU6p7guOk1RZNzWY83IfVkAGWMnCd9JlF5VMeym8loUZZWAF/Naq5\n", + "gEV7o77us0Si4x3XWQ7yABgCkY4T+cLCgsfK7ty5U69lR/U45jeuPhbrZVHsXLdu5mlXa23btm2e\n", + "UzMnngZyuZwyMyg/s5+4LxgMhnWyPXfuXNcE3CKiJiALKysrytqAeWFApbxSqWjboKzJZFLZGAQA\n", + "lMtlM3SefyNis0z5fF4d1cGyiPgm5bGxMWXXWPsM4xz9VSgUlP3hUHdXFoZ1szhDAOoLVmPPnj1m\n", + "rjs4ecNUOD8/r/XDenHgwAFtI4tpAmuYy+X0e84k4I7bmZkZue2220REVIvq9OnT2odswYBFgtd1\n", + "1/G91Wpp+S3m18qo0Y21dtcJ/h2/b+MYGXzHQWL4y0mV0Zf1et1b5/h9wZItcWx7XAANu0uw+4Wr\n", + "I9XtPcWO9rjONRv2w0AHRiogICAgICAgYI24aPIHLvpx4GSwn0uc3TqVSpnhopbzIIftitjCjfl8\n", + "Xne5uEepVDIZBtdhz9oVc6gul9n1kYpzgOVnuCcl1+8H14hEw3sBZqFWm9eoF1zGotsJaK2w2hef\n", + "819LNVck6ogpYo9FFtDsprSLZ+B03Y9ApgtXZX1wcFDvB6auVqvpvEGZGo2Gngzxl/1wUF9mjcA+\n", + "TU5O6ukZbfCb3/xGw9Dhx3L55Zerrwr7lICtwVx4q8ZNv2AGEWvC7/zO78hPf/pT71qUlRlfOIdD\n", + "2oEFSIFCoeD5ZPQax+ib0dFRz8G/G9773veKSGeMQcRSROSzn/2siLR9fcDGgHG6/fbbNSfir371\n", + "KxFpZ1sAgxMnSthqtTypAxGfKWFgPF122WX6PfsdWUrucZI37J9q/dayKkCYF6LIzCpgfrA0Bufw\n", + "A7OKPl1eXvbeRdy/cOovl8ux4xss3tTUlCd8Wi6XPSmYer2uc56FbdGWhUJB/frQbplMxsueYAVS\n", + "WIwp//atmKf83mFha/c9m81m9Xm8BuE3GMfMoqPt6/W6+T7kwDKRKCPlqp7zdYlEIjaIgJ3cwcJ1\n", + "2y5dNNMeNkKsIi4S1bLgDQg+YzMTgI0Ib66slCdoVDYLcmeyTopIVBsF11kvT95E8UvbihYEmBJ1\n", + "HR7ZNMYOd1YnuoOoUqmYqsNANps1o3Dc8nP0JNO4Li3L/dXLpNOPY5+FdDptOlBiMeLvOHkz6uMu\n", + "GKwcj3br5lhuRfy54PQy/L11P1cpv1qtev1q9R87S2JhbrVaXiqhoaEhU93dOhxg3OHlUK/X9YUL\n", + "0wM7huKzX//616bTvxuRGJddYC3otmGxohnR18ePHzcT5/IcF2m3FeYx2sOac0tLS7qhRRv0Gsfu\n", + "2tUPsInjAxBMergP9wE2hAsLC9r+iHBbWlqKTS/CdbReLGgjN4qOwWsg67thc8ObEzzPykzAaYPc\n", + "MZbJZPRFy0Ea+D2+s9xERDrmMUQrTk1NmQdgtz/5/7y5ihvfODyxFiFrKrmHtsXFRf2M3zFxQR/W\n", + "+8D6zHIw537G/LDWIgvWwXtlZcVbK633geWiwuudRYbwHHCTlvOab61xVrnj3lN8GF/NIT+Y9gIC\n", + "AgICAgIC1oiLxkjVarVIokbA2hU3m02PYUomkx4FW6vVzNOnC07cy1Sx64jXjamJUwTHPer1urkD\n", + "xumO8wTi1MGaRe69W62Wp/RuUZiDg4MmfW+1C05AKAfuib/uCcNKEMknJYt2tZyGuSxxbQlmgHWf\n", + "2OyG04tlKmBnZCs/k5tclvuI1dE5pFYkmlwU/VGtVs0To6X9gjbg8efWnZlagEN6cbKtVCp62sXz\n", + "+TTLY8PNI5lMJpWRQh9xYmyYA/lUhjFisVEoI9+v24mdy8D35e9E/DFhsSWlUsl0pMZ93nzzzYjZ\n", + "G+XCvWBK4jkDNmF0dNSrazKZVKanWzuI2BkL4nL0uYCDv5XYF+WzTtaLi4uahw7zY25uzmTtLFhu\n", + "EhgTcc7zJ06cME2Aro5UtVrV/rLYfbTRFVdcEQlkEGk7r8M0yqyg6+RcKBQ8S4JIZz7gHuPj49qH\n", + "lpnWzXQhEmW6LVxzzTUiIvLcc89p/THGwOiuW7dO+xftPTY2ps9lawTm0sDAgPdOY2dptGmlUvHG\n", + "RTKZ9HKt8lrZKxsC3hMol7WudZMyctcxy0K0vLzsBcNYefXYuZ7XYMsc7TrDN5tNz12G7426WWbO\n", + "fpjkwEgFBAQEBAQEBKwRF1X+gGUDWGiTnbwA1zen2Wx6zm18HxYltE4nADtXW6wIdqOWaiozMG49\n", + "LNFHLgMzHHEq0fwM7MLZvu7KR5TLZZOhYZ8gtG+ckq3FPnF9+NTkKniXSiXtGz7tuHIVIuIxPlxm\n", + "68QKMPPGob1u+1rMWr1e9+7N7ByXD23FJyFX/oJhnXYY7oknl8t5DCKzngCXGc+wfFVarZaORWbg\n", + "cGJlIUCclPm3qBvaoJtshQueZ3HsR6FQ0FO45XhtjZE4lnllZcX0ZQBLMTMzo+OWmSu0Lxzt2RcM\n", + "Yf74jjEwMBDLzAAs7QKsxqkXOSWZ9YKTNPrQWmPOnz+v7btr1y4RafsGocy47+LiopdBIJFIaLsx\n", + "CwMhSQjkdgOYKDjrwz9KJLr2oh8wflnZHDhx4oTeB/5dp06d8mRLWBwSqNVqsX4wmBfHjh2LCDLj\n", + "fhjHqC+3BcbgyMiImeGA6ywS9SFlILABa34ymdR6wBft1KlTOrZLpZLJUqOsvJ7hOouN4d9a/3Z9\n", + "B1utlrYN19PK8WlZF6x3KuYz+0fH5fhjuM/g9RhjotFoeBYWFiq2mPK44LM4h3Tgom6kRPxCcsQF\n", + "JnW9XtfPeDC5m4h0Oq0UMhaJXrQlbwgsp3DXzMcRet2i3dx6Wfe19I6wcExPT+vvUX52WrTu3Suq\n", + "D2i1WroBYK0nd7JbEyCTycSaY1BWK5kwJ1C20MvJkZP3irQXDtcU242Cdb/vZk5zwWPRipAE8vm8\n", + "XhdXD97EsvI2R6WItNvZGkeWqj/fW6S9YLhKvM1mU18YuG5gYMAzXXD/9BtdBtTrdc8Z3mrnTZs2\n", + "qVmVTV2u0jPrnXG/uubjbgsv5j9vSnnji5ckIrk4Qg/3thxf8/l8X8mU+92AMlDOSy65RPuYD1eY\n", + "/y+++KKItPvQfc65c+fUbMTO5rj3n/zJn4iIyA9/+ENvI9VqtWLNlbiv5ZIhImpSxGZiZGRExyy/\n", + "6PEMjspD8mWY82ZnZ3Uji7bYt2+fRvAhgm1iYsI7UPDYYf0qa5zjM1bexhzBBm5sbMxrl0aj0dea\n", + "u7KyohF8eIEvLS3pv9FHx44d0/kIzUKu7/T0tDrJW8/jNSEuNRMTAmwyAzhiEHDNy7VaTb/nd0jc\n", + "czkinjeHIr03T/wM1wS4vLxsltlFr2ew6wPq0c8GSn/f95UBAQEBAQEBAQERXHRGinPmiERPEzht\n", + "JRIJz9E6k8l4lH+9XtdTFlOnLh1cLpfNEM04xgQ76oWFhUi4KMrnKq+L+ExUIpHwqMl8Pq//xkmO\n", + "tarw3Pn5edPEgXvj9DYzMxNLp1q/FemcVHAyq9VqegK22BEgmUyaVKlrTms0GrFaYXGsHfe1lZuO\n", + "6xanu4V2Yfqe6w0mjZlOi951xwnX31V0Z7CqsxXqzOV06Xk2ebMJDfXkhJyuOXppaclT/M5kMur8\n", + "ijmzsLDQl/mJZQF4PGNugv1i6Qng+PHjnjp4Npv18k2Oj49rW2EdGBwc1PbtlaOQ6wH2iRkwsBgY\n", + "75dffrkqoPN64fbPzMyM5rV7q4E5vH79elPDyk3mjrIzyuWy1vPWW2/Vz9EP0ALbuXOn9jszOmh/\n", + "mH35Ozh4W+vA3r17PWf6bdu2yaFDh0SkrSIuElV0hwbZpk2blInCeN+6davH/FnrM5sjmdlFW6G+\n", + "Z8+ejWhUibTlP9wxxnUHC2Wxb91cQRAI8Pd///ciIvKlL31JGSYORMI6xZpWyKKBz1566aWIsjlM\n", + "rIDFTLP5Gs+rVCqRRL2Aq91UqVQikkO4Po5dZRbddauw5EN4TeD3C5fBrRu/Wy0mmt+lfA+uRyaT\n", + "Ma1TnGGE/64WgZEKCAgICAgICFgjLhojBbFLSzzQ2sW6dlX2HWDZAOxe8T07JXO4vMVcuP5GHDaK\n", + "nWoikfAc2pvNpse2cPgzsxoWm+EKcnLILDvUu2KTpVJJP8Pp0lJKF7EdqDnPEH7DedXcOmUyGU/1\n", + "22IwLCdYdr612CcWLXQlHZrNpp5e2AmSxeAA9AkLLbrh9olEwiuDm08OcOthqdgnEgltqzifPPYd\n", + "4/uCMcHJ18opx0C75PP5SB4/kbZkhOuztrS0FHFQxncoA9q2l58a2iyTyZgnXFdl3bpfpVLxfLgS\n", + "iYTWA/fL5XIe09ltbPP9oFTNavLWKRNM0yuvvCIiIr/3e7+njBTGhHUSbzab+r3Lkl8oMD7Pnj3b\n", + "lx8WmD8XWAvYwRw+RX/5l38pIiL33nuv3HLLLSIi8r3vfU9/i7XI8jfcuXOniLQdwd05MDU1pWPi\n", + "+uuvF5F2rjr49YCJuvbaa+XZZ58VkU6/jI+PK2uDMXPmzBntf5YUgC8VcumdOnXKE7ccHx9Xdgys\n", + "q0hnnMNHb2VlxZN7yOVyykThvbK8vOytF9Vq1RNmZXzlK18RkbYv2gc/+MFI3YrFojJNzDyCifrQ\n", + "hz4kIiLf//73VUSUmTcgnU577zHOtcqwHMHjfAFXq3Zeq9U8/zD2w+pVJswhFrS23gNxsCwjzGBh\n", + "neiV5xaI8/lycVE3UqwFhYWNNyDuBkOks0Fat26dDmB+ebnOd+Vy2dx8uSYRa5NjdZzlmJdKpTyF\n", + "6VqtppMPCwY7a3OZUT8sOm+88YZnushkMl5EFV9jvUAsZ/NMJuOZ1qwXweTkpPYJJ6uMS8FimQDZ\n", + "uRq/hUni/PnzXt9YiurdAgFcMJVsUb9WdB8DCxXaeW5uznuh8Bjijaa1gXLLbG3CSqWSZ1IUiUYR\n", + "4a+bvJfHIm+4rdQ/ACfidKP7uoEd43FfKyoT85Wvs9rZHdt8DytCiFX7rc2NZaJGdNrJkydjTRN4\n", + "9tNPPx35jUh3h3FE9V1IeiOOjkIfY5y+9tprsSYGV9HfBdoL5XznO98p3/nOdyLPeOCBB+QTn/iE\n", + "iLTNmiIiL7zwgm7CLHMKxqm1rvC4tvoDv3n22WdVoR2bCGguiUjElAWzHDvFwwS4bds2EZGIYjva\n", + "LJ/P69jmlybGJZu53TmysrLivXesg2G5XI5VNsczvvnNb8rVV18tIqJmztnZWR07CHaYm5vTdfj7\n", + "3/++iLQ3pEic3Gq1vGhRJg4YLiHAawyriWPs8zjCeszZKjBm0H4rKyseSVCtVr33HT/PMvdZ47fX\n", + "ZsmtG7sysEK6awbnLBA8b9GmlsnQdZGIQzDtBQQEBAQEBASsEReNkQLFD1qRHcWws2Qmyg3fZlMM\n", + "zGCsMA3afWVlJWLmE4meNK0wftZPck9flgMtJ1jE/XjHDzSbTTNfGj4Dvb1jxw7PsdCiThnsmG/p\n", + "+FhsEefLQ7uBrgaljO9F7FxlnJiSQ2JBnzO1jueBSSwUCp6UBOcZ5H6ICzW2lG/5GvcExGrnrBzM\n", + "ZRWxld9FosmPAcuchTHtspWMpaWl2FMY09Fx8gcAj208n8OVUfZisRg7nhiuCalarZpsjGtS7AVr\n", + "PgKW0/7CwoIZ7s3tB/aCHcJ5LXCBzw4dOmQ6kcPsiueeO3fOlPdw0S2BNoBxun79emUBwCb3cniN\n", + "S9LOjvvM5Nx1110iIvLggw+KSLvNn376aRHpyK688MILpio2M4Ioe1w+T55Hlq4bkiqDkbruuuu0\n", + "LLzugBmCySuRSKhpD789cOCAmg1x/ZtvvqnsPpI6s2M5wG4abB7Eddb4ZPN13LhFve+77z75whe+\n", + "ECnL9PS0p4G3vLwsN910k4iIPP744yISZeqKxaLnftBtHXDZorm5OZ0DmKMsH8NWFEvLEGAdO06c\n", + "LNJeE6xx684BdpexEi2zc7gLKyvHysqKzqW1SI7EsYpWhpNuCIxUQEBAQEBAQMAakWj1k+75rX5o\n", + "zEl4bGxMT2bY/U9OTkYyhIvYonClUkk/45MVhOJwIrDAJ0h24HOZBg5Nj9up8i6bTzb9+Pqk02kN\n", + "hYW/hoViseiFZ7vt4vobDQwMeA7j9XrdPOnDfo+TEF/HSvP9DCFmyfBbi7Xr9RuGVeZ+EfdbyzeP\n", + "y+SWxcqr1mq1tN+5P7gf8FvXPm/Z8K2TEwsFMkOIsrAvGgCmcGJiQn2V3HxjDJYqsAQNGfAxQlmm\n", + "pqbMa9Gv8IGpVCpeW6dSKY8JbTQanmMxB6ww04hyFwoFdTyO8yfJZDJm6DX6ECrhzz//vBdGfyHY\n", + "s2ePyh7Ah6bXyRrK1yxrAWSzWbn33ntFpOP0/cMf/lDXkwceeEBE2uwC2Gf4G8EJvBsgLFkqlZTt\n", + "wtpwxRVXqLO+BYzFlZUVnQ8f//jHRUTk29/+tubpw9rPsgtgBZmRQdnL5bLOJfx2cHDQW6eq1ao3\n", + "vonXbbkAACAASURBVHn9YfbYYu9dX05LpJNhvSNuvPFGEWn742Esct1Q5t27d4tIx8dNpM1cos3d\n", + "Nf1CYeURZUXwfpiZbpk8VlsG7jdXEoV9s5i5ci0O2WxW1zmsWUtLS7qesCwElx+/xTMwNrCmxr3r\n", + "LpppD53mDjgenKjIq6++6jkXLi8vq4M1GotpSTT0yMiIt4FiapI7zorkczuOZfnjJORbrZZJwXN0\n", + "Gl/Lz63X67qBwgS2EmcuLi56mlaVSkXvbdGj3SKMrAHipm3gDYMVsWKZZ9E23L5WGhBLR4xflu7G\n", + "h/sQyOVykee54P5yqeSBgQH9LTtmuqmJMpmM1tNyEufNXzf9Gf4NRw7xBsodW9YkXllZiWwEcL0V\n", + "UQdgPLGWVtyCzOaPuM2/SKf/2VHVAspnpbgBWq2Wzm+0wfT0tB6KcI9jx45F2gUbBiyS09PTXjlY\n", + "Awgv+C1btkRMKQA2Naz34/ZrN02hfoH+7/dFhLpbGmQcgYty1mo1ddKGM/fhw4e1Xdx5LtKZo5de\n", + "eqma0eB6cPPNN+umD3jhhRdk7969ItKJqGNtLjfZrEh7AyXSdmXgRMd4xsGDB0Ukuq5bh2I4r8Mx\n", + "m1N2sbnZinDD2GfzJUfF4jveQHF9ugG6WT/96U91s/TEE09EniViJ1VGO3OEo+t2INLeXOH3nAbN\n", + "rVM+n/fG1uLiopdGhTfwHPVswT3gsesJz0e3zdn1hNvQVVnn5NHdkpqL2H3YaDS0vTjrCW+MXFg6\n", + "UquJyg2mvYCAgICAgICANeKiMVLLy8uRZJWg4hYXF5U65902mCjsEqvVaiTUH99hR4ud8vnz5yPq\n", + "tiJRtsJyWu3l0GqFebomO9a8YYbFZQuYXsY9WJcIJ6FMJqPf8w6ZzWSoN/7NJwxmx9CG7ICM3T/v\n", + "wl1WhE9PYKKYpWKq1NW8YtrYMgv20hGzkla7obW9nJxRj1QqpaYfPimjDEwB4zesWWUxB64ybzfg\n", + "OpR9fn7eNOW4Gl6tVsszM7Nkh6WsD8ZsYGDAy1HFUgJxTNPy8nJPJkqk3VZWgMFqARaKgzAwb7kN\n", + "XN0hAIwbTEUPP/yw94xSqeSpunMovBWebWmA8ck6zgQbh4WFBWWW4jIIcN0sphlIJBL6PZiQyy67\n", + "TH70ox+JiM1iYQ1mFgB9bjmVDw0NaVkY6H+McTb1YR3bt2+fziWYrrhMcBI/ePCgF9Y+OjrqWRe2\n", + "bNniJQpmrTL0R7PZNGVw8BnPQZeJSKVSkYS4Ir3dCbjuMEnChMvzA/d7//vfL//93/8tIh3rA9e1\n", + "Xq978gdursRu6GWCZtkXl2Xn4AVev9GunOMTn7FOl5uTj+UUAA5osNwbALYGsSUBZe2X0cU9rrji\n", + "CmWwkdNwaWnJdA/qhcBIBQQEBAQEBASsERfV2dwSqLSc1ro5JeP0ihMN/w7f1et1PYHgZNPvrrhb\n", + "CLNr9+2WDR0niF5h63HhzJZjK042zWbTc3js5WzeL6y684k1Dt36y/JBc1mvXC4X6wwY5/+TTqdX\n", + "HYIPdHMkhA8NQsQPHTrktWmhUNATLUs2oO8w/jZu3Kj1YMaUyyAS9XPAmE0mkx5z1W9/bN68WccE\n", + "Z03vx1k6m81GfPe6YXx8XB2y4dx99OjRvnyHxsbGvPZbi9gly5X8+Z//uYiIfO1rX/Ou27Rpk7YH\n", + "swOWz6M1ZsH0oD3m5uaU2VjtaXZoaEgZczAX3Rg9rGlgEKzgmaGhIfnsZz8rIqLh9C+88IJ897vf\n", + "FRGJ+CK5rOfWrVsjvmDdsHv3bp1nOMnz+sLCwmAG8Vx2mnaFORnbt2/3mCaRTkADHN+feuopvQ/a\n", + "gy0VaDN2cmcm0WXcWKLGcnLHbzdt2mS2v+vze+mll3r+XyKd4AXkG8xkMqocj7F25MgR+eIXvygi\n", + "Iv/4j/+ov41b05PJZMS3S6Q9ni3xzdUCbVUoFHT9Ytkdt3yW72AqlYqscy5QdhYWjnsHJxIJ7Se2\n", + "xKC+6PNcLucJo/Yrl1AqlWR+fv7t6WwuEl2wrA0D0+V4oWGRSaVSOmGwAHIUG75Lp9O68cAETiQS\n", + "nvmu2WxG0ruIRDsa1/OGizvLovZdmp87AhM8kUjoyxRtkEwmtZ6cGgWDhynd1UaujYyM6L1Rj1wu\n", + "p4PKdYYW8RdckajKLTv54TP8hpXr3QmRz+e1jXqZRtzNdTKZ9Ewh9Xo99gWGZ4yMjGh7oS1444W6\n", + "DQ4OalvjurGxMR1jqA+bU3kT626uWbsFm2ZuE0515JqoLfS72UilUpF0MXiGG8XCDrm8gbPMQS5a\n", + "rZZHsffaRGFOLy4uXpBKuIU48+LU1JS+7HFdLpfT8rATPEzA/HLGixWbBNaqWy1qtVpkrRKxX0oi\n", + "nfaMM2G0Wi15xzveISIdx/t/+Zd/MaN/0ebYlPAmyl0zGW4EtUj08AQNvFQq5b2sOHqKN1Csri7S\n", + "3oRD1wtRio8++qjWA5snvg8OOzzP0Lb5fN402brpvsbGxryIRPxepNM3U1NT5tr7rne9S0Q6KXEO\n", + "Hz6s6wnq+OSTT3p9WKvV9ACC74aHh3UDtWnTJjVnc5nQh6wZ1+8GgTMQiLTbzX2PpNNpT0fMOqRa\n", + "7x82eQPc9nxIsQ7PeB/iO06qzoFIbrJsC+VyWYMXYLrtN9Kwn7kdTHsBAQEBAQEBAWvERWWk2BQD\n", + "5oVZG+xOE4mEnhyZuXD1fmq1mtJ82DVzmCfAu+e4BLp4NqPRaHhh461Wy2MOisWi7p45Nxrq6zrK\n", + "cxuI+CxQIpHwTu3sWMpO0xa7g93/7Oysp89j1Z1PcEyjovx86nGpWnYKZFbGpb0rlYpn1rQ0mdw6\n", + "4zq3PdatW6f34bqjLTEOZmdnvf6CeUWk49zMwD0sTabFxUXTOdetRy9mxzrpWadePINZSj41oU1x\n", + "v5mZGe+UmkqlvCSerVbL026xxqlFcTO72O+JOI416qUM3gu//vWvY793ldPr9bqeVBluGXl8grm4\n", + "9dZb5Wc/+9mayrm8vOzlVdy1a5eaClnbCeWLY/oajYYqh+P6Q4cO6dqCOcjJ3PGsqakp7xn9Sjtc\n", + "e+21qsgN/bmZmRkNEmKLA5IlP/bYYyLSZs7ARGEeplIpdUbH37vvvlt1sH784x+LSNQEyHIPYLHw\n", + "brDkZhice9WyjqCPcN9cLqcMEb9fwETBBFmr1XQ9YROfq5u2bt06T7n8yiuv1OtmZ2d1veEyYRyz\n", + "ic1lmlkWhoNX+P0q0raSoK/Z6dxSp3fBek5WzlALlqsNfxbneoDrs9ms7gPwt1arKXMZp7bebDb7\n", + "dr/phcBIBQQEBAQEBASsEReNkYLTITMgIlFfJSCfz+tpg53RsGtmQUPs6nHKGhwc1OvYl4flArqh\n", + "12ksbofO7AOey74qfA+cRGGzrlQqXrlqtZqyBPDlOHPmjLYVvms0Gl5oqkhU9RVlwH2Wlpb0FIa6\n", + "zM3NaXmszO5s37ZUva12Q3sxM+U62HdTWQesPHe43j3R4VloozhFemahcL9yueypwDO4j618hHGC\n", + "rRYwZrdv365MCMYu9wH6LZFI6LzgNsN9LJ819gN0/eFqtZrnrG/1AX+GOg4PD+tv3wrF5Z07d6rv\n", + "A9c9jqFjIGebpUCdzWY9po1zPMKX5ejRo+b4BNuAE7MVJLIauBIg27ZtU1aHGSnLn8/F2NiYsvK/\n", + "/OUvRSQqiYExwX5E7AeFUz3Yj2az2VduQThNi3TkFPbu3avinPDDmp+fVyYKOHPmjGzdujVSluXl\n", + "Zbn77rtFpKPG/sADD3jO60ePHlWRUTh/J5NJT+2c5VKsNQQol8s6ji1mH/5zyWRSxTktPzIwIhs2\n", + "bPCEStlPFWvs9PS055d2/PjxiNUF1zKstdcdH/1KcvA84TmF+zFjy/6hItE1jv1nraAul7my2OdE\n", + "IqHtzwE6rhh2Pp/X9QF9Xa/XY3NBcvt0C1ri8vWDi7aRwmBx9T4Ylno2U+0Y8NZChsblFwZrgLgv\n", + "iFQqFYm44utduOkHMplMbDQZ7seO2VjsTp8+rQtoLwod1+EFs379em0b60XPAwFtUK1WdRByW1qb\n", + "ELQhJtD+/ft1YWfzpmuKbbVaEb0vXG8NTEvB200e3Ww2dZywJhc+YwrYnQSc0gcbbk6C3MuEYekU\n", + "ue1SqVTMl1vcBsqarFg4zp8/bzoHu4q8CwsLOvZ5I4f2sBw3WafFUoFfbeJP1npyTagW+jUVLS8v\n", + "m6Y9y6RoJTjGM6zvNm/ebDqQor3wUu+WUopfFCLteYRxiXbuZ/PRDevWrfPMOPy8ONx8883qdI3o\n", + "vbNnz+rmD5vsl156SduS11ccDq655hoRieqIxW0Yz54967lacPshui+VSsnv//7vi4jI/fffr9/D\n", + "0R39NTY25qWsKZVK8sorr0Q+27dvn94ba+r8/Lw6vCPdyuLiYqS/ROwUW3Nzc9r2UFE/duxYJGhG\n", + "pL3hdDdQk5OTkaTLaBeMDbQ9HzQuueQSEWknKEa5sDE8fvy4BiVZSZLT6XTEFAbgM/xdWlrSzdxt\n", + "t90mIiIvvvhirDmaxxrWOWttYE1CbFBxXT6fj0QJi9gajrxesKaiq9eYzWb13+yWYm3W8BnavNVq\n", + "aXuwCRBj1MpmAlhriItg2gsICAgICAgIWCMumo4U9B+wq7dUZ4FkMinXXnutiLQTPopET7Yc+onP\n", + "rDw5OEnW63VPxZrzufGJYTUh5iIdhi2dTusJl9kb1zHb0gJKJpOewzDnMmK9KzyPQ3utfzPL4zoZ\n", + "M52NHf/g4KCert2w227Afev1uscmsInFyqsHcA44pnHBXHECW8CioS3AXHLq1CnPyZCTc/KJxGKO\n", + "4kyE6Dc2nTBQd0ubyTIP8jNduppPiHHyEYlEQs2BlgNnv3niMH9yuZwnFTI5OanlhvljLZIAVk5L\n", + "IJ/PR+YrrmNJB7Q5nILPnDnjsVgbN27U8luJZ+NC/xmo+549e7z8dv2qTlv48Ic/rG0JRfJ+cd99\n", + "98mHP/xhEemY5+r1uq6vcPSGinY3gJFKp9N6akfdmG1jTSNrroABeeSRR0QkGnLOSYvd9Z/NX3F6\n", + "UyISazqDSXFlZUUtHGC/kslkxIwPWPMbbBfKefToUV2TeP1GG8BpntdOPH92dlYZQjBYlrM5z9ty\n", + "uazPcSUAeqFbAI/rVD84OOjJQTBbBO2rubk504LRL1xtNtaTZGf4OHAWAqzrccnJuwH9yeZei3mF\n", + "Rl23cgVGKiAgICAgICBgjbhoPlK5XC5yasNJhMNysbtPp9PKRAFDQ0PqXMancDevHmcgt1RY2U8E\n", + "u1LOQO0inU57+ZY4hx4zYNbOG89jxsxiz9zT/MDAgD7XYslwYlpaWtJncLswU+LmM8rlcpEy4j6u\n", + "/002m9VysWyBe5osFoueXACf/K28euz47LJZrVbLUyVmuBnQRaIMDcrKJ2k3E/jKyor+m0+kbr4v\n", + "y1FZpMPW9GIwXbaNwYyU64fTaDRifRTigiey2aznJ8bh/mjbRqMRy+hxFgK0L06DpVJJ+2G1TFQ2\n", + "m43k2BOJ+h3xs1xmzfW944ANvh/XvVqtmkwUgHVpx44d6mtjAc/dtGmTp/BtnV57SXvAd2N2dlbv\n", + "t1p88IMfVOdsnlPoE8xpzgVq4bnnnhOR9riCzw6UoQ8fPuwxbtxWrNqN+wCpVErXJ7BUuVxOy/ee\n", + "97xHRCTivwNmjVmbu+66S0REHnzwQWWigImJCWWkwAhls1kdMwgmgMI12gPt4/oElUolfS7uUSgU\n", + "TDkTrF1WLlJmlMBEoW13794tDz30UORerVYrwqzF+d3BnyuRSOj6hP7lMceSLaiLK6EjYvs5ckAB\n", + "7sMZCdzcp3w/9jNyZXXY2sLAmob+mJ+f9wIGarWaMuCc/QLPYz9bvKdY+BbtizYaGRnR+4BB7Mdo\n", + "d9E2UljosHhgAS+Xy56Zol6vey+CmZkZpUfRkOl0WjdQUMXl5JEc2cbO14CVGNd92fCgtMwQVqQW\n", + "L2ju/cbGxrSeMClwJB/uU6vVdPDiZcJaG+ycjO+xuRKJvtxQbjcljkh00LjU78rKippM0OaJRMJ7\n", + "cS4uLup1XF93sqRSKXMT5Jq/WPMIE9eKRMK1ItENBSYQoon27dvnOa1aaX6SyaSOS1cZXCS6+Pbr\n", + "pG1toDiBMWAFIKBfeaPMUT8A2oAXEyuFEdoU881ycLfAbY96Ly0txUYH7du3T0TaYxKHHYy1oaEh\n", + "T8Npfn5e64bysR4W5v7ExISuISKd8WaZHtB3tVrNW2Ms5ejt27d7GynLQblcLmvboczj4+MRhXSR\n", + "3iYHvCiPHDnStzkd2L9/v4i0+xQbFMxBaDmJdA6YO3fu1Bcj2uCyyy7T9ZIDZNwUXJOTk54DLh8u\n", + "cN+bb75Z1aSBarXqRd598YtfVAVvbKC2bdum5cY9hoeH5dOf/rSIiHz9618XETv4w9og1mo1rRM7\n", + "1GOjx/MXfYjrRkdHPYd7V7EbwIEA44+T6lobL2yojh8/ru8sKMdzUJQ1N9lE7aqiu8D7BGXYvHmz\n", + "lgubPusQNTQ0pO8BbJ4rlYpXFyYJsD5w3+BZqVTKTA7ublY4NRVrTLrpb1jDj9dK60DbTwAIB2Bh\n", + "/sZFAALBtBcQEBAQEBAQsEZcNGfz8fFxmZ2djTWF4MQ8MDDg7Sb3798vTz31lPcb11Fwx44dykRY\n", + "J2awFeVy2czFZNGLrmO2WzeRNtOEU0mc9k2hUIg1M1wo8EzWssIO3govZ0d0Kx+cBeT0wqmoW4h7\n", + "nD6U5aiKU5SI39aspM3mFLes3RJK9wsraS3AjBTGBBKPvvLKKxekp4RTO8b91NSUOs7iZFir1Uyz\n", + "MJhIDh/m/FIiUYV7MJ1WDrVMJqPfo08LhYLWFyzq4uKijndmJ+DcjJD8YrGop3/8rdfrygJwzi2M\n", + "RXZi59+ItMcB6nTw4EGVLnDD0F3glI12K5VK3jx897vf7ZlbeDxhbBQKBY+V3bNnjypux8lBHDhw\n", + "QPvhwQcfjC1zHD72sY+JSNs09s///M8i0jlRz83NeW4NV1xxhZ6+0W9jY2NaN8x9zqjAquguyzIw\n", + "MKBtyrnPYHJiKQT0Na4/deqU51B+7bXXqvyBu76IdBzMZ2dnvVxrpVJJxzu+s9aBG2+8UV588UUR\n", + "6TD2zKKAITpy5IiOX7Rpr7yecYnoLxRxSYvXr1+v44kZnX7KMTo6qn3DmkxuDkjW+uuV/9Eysblg\n", + "+aC4hMYMzL3169dHtCVF2uOUdaZE2v2BMQi2N5VKaflw/fnz5z15I5HgbB4QEBAQEBAQ8FvDRWOk\n", + "3H9j59hoNHRXzPZK7PA5bx0Ap7B0Oq32VPhNWJncWUARO1Erl51V5m7N5YoRcl493mVbOb4AnO6X\n", + "l5fNE4TFPljg66zTC06C8Ll58803tc3ZV8B17E6lUno6RLsWi8WIwJ1Im0HoV83bfS6fEizByDiJ\n", + "AK47fstsB8bJ/Py8l3tqaGgo4ujsgscOgDKMjY3pCQ73wAmG0St/HMb4xMSEXHbZZSLScYg9ffq0\n", + "SoCAQZidnVV/IzADLBHAOSh5fuF+eB6+A3Mr0hkbhUJBP8d9R0dH9bcYD/Pz8+p3xuMTjASHiqMN\n", + "0fY85pj9Wu1pvtVqaZ45hLjPzc3FSqsAzESA1dq8ebPmjwM4GAbzI5fLeXNyaGhIv7fYHeDAgQPy\n", + "7ne/W0REvvzlL+vnvca5i8985jMi0mZ0nnzyych3vRzL3XKLdNalbr5/qBvLULAjs0jUnww+XE8/\n", + "/bS3Jn3iE5+Qb33rWyLSaftjx46pjxfGy4YNGzTvHmPbtm0iEvUFA9D3KysrujawdeOKK64QEZHf\n", + "/OY3Wi+XbRkfH/dYL5G2tUNE1I/OUtHn68CScoYLtOOGDRu0rTmgh8cO5iSeYbV5N+A6tkwAeGf2\n", + "u2Zb2LhxoyePkUgkvHHC6ztLz+A69HUymTQtP3HZIuLej7lcLrL+i7TnJdY+fldbbdmLkbqoSYuT\n", + "yaS+5DhyCA3CgwQDCoOSK4uBxRpJvIFCx1nOZqyuGrdZiktXwmlS+DpX06obHYxO5EgYTBr8dmpq\n", + "KuKgDuDFjPbo5ljMzrUYSPg7Ojqqv2dK2n3pN5tNT+2ZNx24ByeSxDOKxWJkoyXS7jcsHljAWYHY\n", + "VfIWsV8w3A9u3fnFF+cQPj8/r/1lbSpRj1arFYn+Qj3QXzwuMekx/oaHh7VN0YfFYtGLgEulUvoC\n", + "wKZp9+7datqD6W5mZkYXXZT97Nmz+gx2wsXCwxs+1zmUgfm2uLgYSRAq0p4rHFGLtrDGdjd1cL4f\n", + "J6B2nftduJGV7oYVcwgbzLm5OXUAZpO2e3/eZKF92dEchxyktsK9RaILt5WNASYiEfE2AidOnDA3\n", + "1/1uoKDcjUg0OJozum2iLLM1qz6jHHF6aQz3Jb24uKhtDzeMm2++WQ8HmF/YRInYzr7A3NyceRCN\n", + "0zRCn3NSXYZbN+vlPzc3p/Oby4exbZkv+d3lBiwkk0ntN5jTua7oy1deeUUPKuVy2YwWZqV13Btl\n", + "5PriOtSNN7msfYV1hzUQMZbjNlp8CGOdQLQhtynr0Ym011aUgcckxiXWx2w2G0mwjO/QLqwr6Tq5\n", + "r6ysqEkPawOrxfMGzu1rtEkcgmkvICAgICAgIGCNuCDT3o4dO2RoaEidu5544gk5f/68fPSjH5Wj\n", + "R4/Kjh075P7779cdnj70f3eVrOqNzwYHB/UEhV1ntVrV63hX7CZitcCK1Xz66GWqc8EaU66irUX5\n", + "WWacyclJ3YXj9FKtVns6cwNxitqAq1Xj0uiW6acboHGCuh87dswLU282m9onOKVyGD+zOy4tm81m\n", + "9bTBv7FOytZJP84RnNWp3RPG0NCQ59y4vLysz8DppFQq6b/BEPSi0IFWq6V1wzi+7LLLdMziM54D\n", + "OB298MILkdyDIu2+x7PBiPTKBYm+n5iY0BMfn5pRX7RjNzVu9BvnCoNTPZ7x61//uu8sAKsFxtXQ\n", + "0JCXc5GzGUxNTennzFyi3Gi/XC6n94xjM9jcB2zZskXvh7HIZh9WzwcOHDigz2LtIlwPhe/vfve7\n", + "ItIxS64G//qv/yoiIg899JB885vfXPXvXbBeD7e1C/Q/m7d7AY7i6Ldz5855a1E3zS13DeQ+ck1t\n", + "jOHhYW8ui3TYQtzj9OnTWnew5JxEHuZ1zgOIzw4fPqxO8+jnfD7vyZYsLy+befUsWGs+2nx8fDyS\n", + "bB0A4wI2S6RjulwLXI28er2urC3mQCaT8ea/9e7tN9emSIeJwlrd7/rCSuloq8HBQdNlA8/Ae212\n", + "dlaZf6w1qVRKjhw58ttzNk8kEvKLX/xCnnnmGXniiSdEROSrX/2q3HnnnfLyyy/Le97zHvnqV796\n", + "IY8ICAgICAgICHjb4oIYqZ07d8qTTz4ZEX689NJL5aGHHpKJiQk5deqU3H777Sq8pg/9X2GtbgJ+\n", + "cYyEdXrGabvRaHhK2alUytzJuo5piUTCC8G22AeLaep2eurHYdT6baFQUBYAJ9zDhw97rIx1YhaJ\n", + "+kOhPVyfJZGOL0gymdR79mK7YPvnbOjoExay61egMi5MmIUlUQ/05eDgYOSE5P6GT0BAvyehOFiC\n", + "jIODgzomMBYXFhZ0jMEZdnx8PDLeRNosFE6V6EsO/e/3FMY+K5wZXcTO4zU2NuY56VqOsgMDA57T\n", + "7/DwsDoFQ3zxtddeM8c7518UiTr1oy3YXwvjnn1aWFE9LizacvDvBjd32tLSkne6TyQSnmJ8MplU\n", + "poLHJMqPucdj5NZbbxWRtjyDOwZHR0flk5/8pIh0/NfYZygOo6Oj+pu/+Iu/EJG2zMRf/dVfiYjN\n", + "OGM+JJPJSLuuFWiDQqHQ95x3cdtttykjw2ySm6XCgpVztdt7BZIi8FPjscTyCyy7I9Jex8E6Infg\n", + "Y489pnOey2mJTQLMkruipOl0Wq9lp3Ks2yxUzQKVGItoA2sdLRaLOq/4t6gfz8d+10i8BzB/5ubm\n", + "IuLRLli82nU2F+m8O9AG3Ic8p10x6dHRUW/tGBoa0vUOn507dy6WWe2FXs7mF7SR2rVrlwwPD0sq\n", + "lZIvfOEL8vnPfz4yuVutlkn5srkCDWdpLLE+kOtEPDw87JnYrISsFuIahLF161YtOy+MHAkiEnWa\n", + "R1m6mYAwEJBGgZ1P+UUUF53AcPWXCoWCtlU6ndYyclu6UXHu9yLRBcByvu4FTHr8LRaLuliy7od1\n", + "zzgTZr9lsTSeOHoy7hm8iXEX52KxGDFNi7QXEVyH8p0+fVpNDVD1PnPmjOcYubS0pC88a9HldETu\n", + "Is0v8NW+DG+77Tb97euvvy4i7Y2cO8+uu+46pbqBoaEhLReS6i4sLJgHIE6WjXphbvSr79XLDM+b\n", + "nX43UjiU4CU4MzNjRmbh3piPlUolUhdcg4Wbx6VljsbL64YbbhCRtmI1NKCwFtx333191eFd73qX\n", + "PPzwwyLS2SR88IMfVD0qbJD5sMVtaWm3xcG6Hn2ydetWnd+cqsNa3612sQ4OGE+ckQJjFuMqn8/r\n", + "5gEv98nJSe/wzug30g3Ys2ePOirjWcPDw95GlfW1sBnitrfSFnFZ2L2FnwW4azO/P91r3OcAvd4r\n", + "rIOI8mHMsoq623b8XsE9+P3D6yw2fyhLrwTIvQgJfp5Iu11Yj06k3RaYrxyA0A+BgN//1qL2Hn30\n", + "Udm0aZOcPXtW7rzzTp3MQCKRuCBRwoCAgICAgICAtzMuaCOFk+qGDRvknnvukSeeeEJNehs3bpSp\n", + "qamIwxsDpj1strDT66VEjd1pMpk0nWPdkHkOmcSuk3VfsDvmXTHYhampKd29shaNZU5z6eRu2iM4\n", + "QeD0uX79ei0LTglbt271HE4thXarrfgUY5mF2Izifs5/2akcp2zOpwSUSiX9jENYwQ6irLOzsxGn\n", + "YRGJ5BNjUyv6GM+1HLIHBwc9E1E2m9UTHtph27Zt6mSIMlntNjQ0pOOEtV1cc1e3Uyw+5+9hEoMZ\n", + "aXp62lPuXVxc9E6V4+Pj2kZArVbT8XQhSu0wyeVyOVWRRptaOaU44THmz+zsrGeOFLGd/vEbp7zx\n", + "hgAAIABJREFU1MdKBC7SOcGjnwcGBvS5bNpx2ale+m8WBgcHdZxgfFpzFeXgv41GwwvLTiaTXlh+\n", + "sVjUtY/HEPoOdRsZGZHbb79dRER++ctf9lV+OKdv3bpVGSk2EeGkjzpyHyFI4LXXXtMxCPNRr+CT\n", + "uKCYs2fPxppOmFXghL4i7bmAtrRyn1pmHmZqMaYwbw8fPqzaXEh2v7CwoMwwJ4RGImY4h5dKJU+K\n", + "g60GkC0YHR3VesC8zWwkjyf0w4033igiIo8//riuDRwAgfoyw4YysOQItw+r6+M6913EZnKrb9B+\n", + "rDAO5txii9xyiETfK2CzZmZmTAbHtRxZrgfJZNJTaO8Gt27d2DZrvwBGmjM+gBFMpVJSqVSkXq9H\n", + "NN4srNnZvFwuRzKK//jHP5arrrpKPvShD2lCya9//evy4Q9/2Pw9FqZUKmXq2AQEBAQEBAQEXAwM\n", + "DAzI6OiolEqlnhupNTNSp0+flnvuuUdE2ieKT37yk/K+971Prr/+ern33nvl3/7t31T+wALn8hHp\n", + "7Iq7nbZxgmPBPteunk6nvVORdb+VlRXdvGEnzA7NlrOi5cTHPiHuqf3MmTNaPpxMjx8/7tnnz507\n", + "5/mWHDt2TE9oqK8V0mvZdbds2WKKILLjpBUGyqJsImJmn0+lUp7/2vLycqyjPfqmVCpFFGXdcnE/\n", + "4WSHU5YVWlsul72TEYvHAax2zKHp+C3s5hyuDrBvH/pt/fr1OmZQ5uHhYWVUuG5oZ7CLr776qtn2\n", + "AAc7uD4Zq4GV3wr9hTadmprSsYW27RaUgTZkts0VSxTp+ILheu5Tno84/WHO7Nq1S8sMf61Wq+Wp\n", + "xbv/tv7fL3AItEL2mT3B/TF26/W6d1Lm9QTjKZFIxPoegRW5+uqr5frrrxcRW1HfAoIEXN81kXa/\n", + "oK+5bq6AKoN9YFymntkDFl+17uH6sORyOc+Hj1ltrF8scoo6TU1NeeKQrVbLtBDg31xWzBvMy1Qq\n", + "FWGiAKw16Dfuc/Z7xXMhoLljxw4d55whAGsD+2hi3kAlf3x83Jw/eB7y+h05ckQ2b94sIu33o/UO\n", + "cMV3RToCoRhPrOCNsTE8PKztHyfmnM1mzTx4mLtgn0ZHR3UN5TUY7Y/2sxzamalnJ33MKTCmHNTD\n", + "vstxewf068DAgPYJynLu3Dllu3nOY0x0k4OxcNFSxGzcuNF8eVlRcblczlS7dhWXu1H8bmTYrl27\n", + "dMHGdyMjI6aWR5xWURwGBgYiCy3gKrhmMhnTqdB1cmYKG53ODr4u5Q1YKWLweyxaZ8+e9crA0TCY\n", + "zCdPnjTr6jrfp1KpVTsSA5lMRusJZ22YoHohk8lo++L5cdGh3YAFLZ1Oa1lYPb8ftFot3Vi45lwX\n", + "rlPtasvLGBoa8gIf+ICB+VOpVGKTZaMdb7rpJnnmmWci5erWBtdcc42IdMbJ3NycjjWUqdVqeYlO\n", + "U6lUrAYRO5PGBV+sJmrPxeDgoOcMzHMOqFarnplyenpaN4eYK0tLS1rPuHb+3Oc+J3fffbeIiHzk\n", + "Ix8Rkd6BA4gc27lzp6cZtXHjRi/VCLcL1hWen6hHq9XSvmXzOsYCNlz80kZb3XDDDbqeY5NQq9XM\n", + "9Dyuw3MqlTJfhu513aKjAT6kosyf+tSnRKStc4bUOdb7AqTAD3/4Q+1fTnXivlu6rSuuQ/7IyIi3\n", + "QbYc1a333o4dO3TzlE6nddOC9t2wYYOWwQo6wcFxaWlJ298KGMDYYPeGuE09vxus9yPm+rZt23Qj\n", + "g+ueeeYZLQtHkLruISMjI3rdagNprHHSTb8K9QWBwMr22JDOz8/LSy+9FJIWBwQEBAQEBAT8NnBR\n", + "kxazcxvAuk+8e3ZPEfl83tth1mo1b4fMzBefWKyTEr5HaPLp06c1ESvLC4BpwMlgenpaT1JWqCaf\n", + "rPqRNbCcoXslvAU4t5xIVAVXpL27dnf42WxWmTkwA8ViUU87qHsul9Py9xs6jH4rlUqmQ6F7Aq7V\n", + "amY90V/4m0ql9IQMlXA3wSw/R6RDM5fLZa0bnjsyMqJlBaXLfcCmUQCnttHRUR2LnJMPCXQxrp5/\n", + "/vm+282qg6vqXSwWIxpqIu124cTZIu25gjbFaTGTyWg9mcJGW91xxx0i0u57nIpRdtaMAXK5nJok\n", + "wOxaCbAzmcwF6Ra5yOVyeu9yubxmRoo12axTNpsewOpgPJ05c0ZP1xgfxWIx4pwvEp3zGMcHDhxQ\n", + "duKhhx5aVZknJye1rWH+SKfTej8+lWPssP5bPzpNGC8itvM3M95slkNZXDmA+fl5LxktJ+dlk2Ic\n", + "e4J1aGBgoKeTvEjboRm/QX35/YHybd68WZkf9Jul9caMFNYfZlU5wMR1X2CWymL7+V1nSTVYVgY2\n", + "3fezxvRi9wAex+zO4W4bRkZGtD/j3BFGRkbMZOVxwBgsFov6WzfHqEinLcvlsseoZbNZNYljvWPJ\n", + "CU5A7jrDb9iwQc6cORMYqYCAgICAgICA3wYuGiN1ER4bEBAQEBAQELBq/NYEOS8ELqXWy2zVz3VD\n", + "Q0NKK74V6UAuBIVCQZ39jh49KiL9KwiLdMya7HS+mt8DLg3MIqnclm77dlPIRXksVXSUr5vjrlu3\n", + "oaEhdcRl9XHWiHHLx/ezzLigfnHfbgmlXed81s2Kc5TfuHGjasSwwrDl5B9nZmL63lLuhhnCdZ5n\n", + "rFu3zjTjuCYRJBUXsR3Z40woXA+0N9cVZo1EIqFlWW1SUitzAZcBiV27JfNF312IaW816Dfh+WoT\n", + "o78V+L86pLprCJtYOQAmriycAsj9Let18XXsoIxnuOOTIyaxHljz0VpfuCyW6Yyf5aatqtVqXn15\n", + "7gG1Ws0zjXOgDNBsNiPrN8oFs5U11t+uJMVq50IqlfLS7Fh161bftc69bk7pve4TTHsBAQEBAQEB\n", + "AWvERWOkRKIOtNi1FwoFj1UQ6S/sfH5+3judsG7JaiUMupXZ1VKynObuuOMOdZKDQ+hqGCU3RNz6\n", + "LUsFcHhurxBxVwCVlcOBbs7tODWB2WCnSz61WcwWAEdMS0vFCizo5hjpli+fz3uSGtlsVn+LNmXd\n", + "L74ujoniE7j73LWwn3wPV9WZc4rBIbher3v9Oj09bQZNWIAi82/+H3tv8mtZclUP79u/e1+bfVOV\n", + "VemqAhurbAa2EBJCsmTBBAkx8k+MEAz5CxgiJnjMgBlIngEzkJCMkEH2wCCQBTbVuai+yaysyqzK\n", + "fPm623+DpxVv3X1WxIl738t6Zb5Yk8q675w40Z04EWvvvfbLL1f+Vsfi4DTmHdvNTk7Ha2trwVEY\n", + "bWMnYMUoq5yP6rl1p0E/lstAnVx5Hvs65DJePGeXzWm3CjxjYqYZl9w1sO5En8M0qeuYQeK1GvVj\n", + "xgnzjOebl/Hg9qo1xzPZdW1oNBoLCe9xnX/HW62WZJAwxmocuN1+DY6xS/zvnLl3GjYqN6DJ32N2\n", + "3HYVaLUqM1THCtUFhPg+VxYMVb9V9wjntpGCbD0+HvgYs9DmKgsQ7kUUy+Hh4ZlECXGHo85KkR2b\n", + "hLfffjtsoFZ5PtqRuvfq1avhZcemsy5ig01ngJrkMYrTT7ROpxPGDnXmqA3VDkT33Lt3T26afH2m\n", + "02nyJUDEoTL9PP3000FEj+GfMZvNkhtQToybApsIU+DnczSP2aKGC8b1ueeek4KC6mPtx206nYaN\n", + "FrS5WNzPR1GZ6QUQY8Rzg9P0sPih2eJGCptFPnSg7nWZDTgJt1oLlMhkLtQGKrWBy/0gbG9vh3fx\n", + "LKMUGWqjF6vfsh+IZT986uPl/526zoNNZ2xqU6Y9tM0fPs0WdfuUqYjrhb+pjU/K3QAkgNrwsRsB\n", + "/82bD/m62AZvVbN1rrkv5eoRA9o+GAykFlzK7Ja6Rl3HSZqVua/ufU21hdu7yuavmPYKCgoKCgoK\n", + "ClbEuTJSo9GoskscjUYVM9OVK1cqTs7z+TwwH9hBPn78OJz+YklIl4VP/cL/5t98yhmV7HEZ5Jxi\n", + "+/1+6KtV9ImU8zCbsFTb0f8qIaqidnl8cXr57//+70p5wObmZuVkM5/PA+uEdvKpjlNOeIYL9Yy1\n", + "nU2V6gSi0oGkACVf1BH1xzO9aYL7VrFd+K3T6UhNGWWOVCwg2LpvfOMbZqZTDjHgRM7zWDn9si6R\n", + "T8vBABN14cKFML6s5ZXSV+P2quuWzdUZO6F7EyEzoaylkzqpYp168OBB0K3BXGSz82kc0VPmyFar\n", + "9URNiP55ADNNfI2va4wF8s7rygGdf1Pl8TvqddO63a5k7/zcYXV3nu+e9ZzPT9LVcJ29yZHnlBov\n", + "/v9UUMxpgihyGZ+Y+SsFn+DZTDPEHJC0CtuJe4GUyZafV/csxWYpJrQOhZEqKCgoKCgoKFgR5yp/\n", + "kKuuysq7vDuEAi0cct95553KqZ7V01dxCs69J2cH/+KLL4Z/w39qNBplK7x6DIfDbOZN7dBxWuK6\n", + "8w6d822hDDACHNKLU59qBzMHYDlQZ+XcqE4Q6oTTarVCmxRLBGaIGRXuA58rSjEhrBKeqgufJnm+\n", + "+LbwiY8duFk53kwzU6l8bR6oI/qFc1Ui39gv//Iv2+uvv25m2gcRrJJiVrlP4HP1+uuvB0VgzAPl\n", + "Z7e1tRV8pzD2zEDzKRD38vgqFWnFqOY6QzNUP6RkLVQ5PJ85YbbZ4nxX7yGzlKl1Rz1fndqfJNTc\n", + "Vo75KUZF9V+d9IBiELzfDPcd+qPb7UqJF88+MOvFUPVXY+mv57JS34hYYAPff9ayBqn5WydHo9h2\n", + "3Is+50CvFGIsb6q9uX0Z+3uqfM+O5uDcNlKgzWGuYOovFT3Fjccij8X1qaeeCgOH8o6OjoL5KbVh\n", + "iUUseHNVzAk7B5PJJLQX2jiTySR8ONHujz/+OOulqctO/dxzz4V/L+tUCxMFYz6fh75WaUXqFnGf\n", + "AFY59qlkmRsbG5XfVeQdp9bBs5CuwkxHiamIL3YexZxAedxGOJYfHR2FslMmVt5IqcUJgQoq5cV4\n", + "PK6kXlDRlmZWCYZQ8xoRdr5NAA4vV69eTW7W+V3wqTDMqg70jx49CgcgzCHlRLq+vh7eOa4f/s36\n", + "aqnN6yrAWMc2NMqEhd+479EWzKfLly8vzEdAuQqkUKf/pkxEdR8e1a5lr2MTF65TprNU2SmoAx+3\n", + "TfUf5stkMgnjwBszv9FrtVrSod07ss9ms4rWWyxi0m+q2EGe12DvDM8RwqeJTGWoMUT91foUm5O4\n", + "H++KcvDP2UT5utTVPfXu5TqMp76Fy9SHUUx7BQUFBQUFBQUr4twYKSQY9sk02+12xbF3bW0t7P7Z\n", + "ufmpp54ys5PTNTNOKqSbodRmPdrtdrgOu90rV66E07VPbliHt99+eyFprNkxg4FTLH7L3RHzyR8M\n", + "F2QfzE4So9ZBPW9zc7OiyWR2soNnc0tKEoC1WJTWEf6ea5JQDtfAhQsXQp+ArYzpQ6VCsJna9U7p\n", + "zABhzh4eHiZNhAyvM8On7GXp6tg8QR3AHjKbhzr/9Kc/DeZPxWxibnPSWswtZszAVq2trUmzpx/X\n", + "vb09GQCAdxh13d/fD6wTl4E5hHqtr6+fSRYDxSrlgs19alwxHnfv3rVbt26Z2aJUh2dKcp/PzAbr\n", + "iaEclFtXXso0tcpJnVmWlNQAl+fHkM1ainHk+qW09nDvZDKpMEcxc6Mvp9E4UUrHWjKdTgMDyxIL\n", + "yglaOZbzuqja78s4DdMa60vPZrLLQy7QL1y/lFN4zJybY0ZTZvWYvIEKcljWfLgMCiNVUFBQUFBQ\n", + "ULAiztVHajqdhh0hTk+sRI3d7OXLl8N1OH1sb2+HXHZgRHZ3d8PpAOzUw4cPw+4UrM14PA73pBSh\n", + "J5NJhfl47733wkn+W9/6lpkd+1H90z/9U22bh8NhMnz+NI6icF6/c+dOYA7ghO+Rw2zEdureTyd2\n", + "rQ8DZmkCRkr9GdfzGDLr4U8xXD7KWV9fD6dIrieu5dOikm/Ab8oHgOeOUv1W8HVmZ3OwQMr3aTgc\n", + "Vk5Z4/E46QuAune73dAmfj+++tWvmpnZj370o2h92T8KTBT7TWE+NJvNhXfYTEuZzOfzCoM5mUxC\n", + "HzCzkmL3MKYbGxvZvhgpcP+h30ajUbbTqj8hq0CaK1euBCaKZRxy6h/L54g1kufiqsyaL3sZpJyx\n", + "zU7Wcvb1Uc7aKV8vbi/3vfevUxiPx9KnSTEc/lszn8/D+8Nrg/dzZPkDxcSpf6ecyT3TeZrMHIrx\n", + "83XMHXNmkDyTHLtOoU7aQX0TcuuogphyhUBXwblG7TGViIVxOBxWBh2bBNxndtxRd+7cMbOTCJ7x\n", + "eFyJNGOknM0bjUYwhdRFSMEUggioVTSccoFN22effVbpF6aSWdMEC6hyWjZLRyXA7MIvBkcTeXNm\n", + "u92W9VKmVWzw4Mi8ubkZPgBqA8JK2vjAKnPqV77yFTMze+211yo6Qzw2/AxfF7Oq/lKz2QwffeXs\n", + "yY7o6NNlP+qz2SyYqdDng8Gg8hE8PDyUZtCUY7FPHO3rh/mhNpBcP7+gKVMp1wlz6NNPP5UbKYwD\n", + "l4txgrl+Pp/XOu7j3rPYSDFylcjrNlleK+yTTz4Jm9dXXnmlco9K9wSoyESzapTVMhGM6sOSaxLJ\n", + "KS/2bOWA7k12/Fz+4PsNSG7dptNpJQij1WpVymEHb3YxUWOiHJ9VxJ8yQykHdH8vO00v01b/jLqD\n", + "cm40Hl+Pb2Xq8B/bRPl5znMW83gwGNSmvfL38DdHfePOsv88immvoKCgoKCgoGBFnCsjxWAnXOxY\n", + "/YmE72MmgbGsJhPCszc2NqJlxpCT144R29niZA7nxY2NjbDj5/BxmFO4r1R+I+zMlf5WnQMjfuOc\n", + "h3wa86GmfJr0z/fP8JpEzGxwud6xu9frSeqYmSiz45OOPwXFTiSexdjY2KiYLWezWdIcCbRaLTlX\n", + "czCbzQLblpL9GI1GFaVn9Szl5MzjByr+wYMH9tJLL5nZsanObFEqAkry+/v7lfbySZHrAgaMpRVU\n", + "/VBHOJOziR+M4/Xr1+2NN96IlpOafzlYVsE5FyzjgnpxX3omilkIHqdcNkE5EavrFHJM+rmMVIyN\n", + "8u3gseZ7lH6Uv46ZbhXqngKb55gRxVqjTI4Yj5iJVzFNKUZK/caK+R7e7Lesgj/3n3Juz/kmqPdj\n", + "Pj/JKoI+YkZNmWzRz+12WwYn+Xtz2Si0hf/Lz65j9HISGeegMFIFBQUFBQUFBSvi3Bgps/jpA8KE\n", + "YGWazWY4qcIvaplnpHaW7HvDoptmZteuXQuMT4otiAG+LyhvbW0t7LS5PJzMcXJdX18PO334Y21s\n", + "bARldDBh6sTOatwxNkbt1r2sQbvdln4B8EHyeaYYjUajwvi88MIL9uabby78xkwHxoH9EVJK32ZV\n", + "fyl1Or1y5YpkGjEOOJGovI9mJ2OjfLNYQXzZ0yIDcwzjr+rBzsuKKVSnKIzV2tpa6EPuc5zg4BPI\n", + "z+BnpZyWeT6g3jit1t3LZeA6jMvVq1eTUhfAqozSsvflMlhqrfFSK75cz/ixEj1fp5yDU4KcfJ2a\n", + "H/5e5Q8Te7+XZbNiDuX8X19n/1uMeUqF1qvrsDZBgsdskRHzbFGsXH8dM9Ncd+XPlXKQX4URqYPy\n", + "ZVqWaeTAMF8e+z4C3W63Ih+kmKbBYBCeg3WK81yehjVWbVSBCnX31OHcNlLKi95s0aEZDsEbGxuh\n", + "wcoZGuj3+3KToDZBMGdgkT46OgobOJjYut1u2MxxtBg+8Jzqwk+iXq8XJhva8Ru/8Rvhg/Gf//mf\n", + "ZnZsTkEd8AF6+PBhRUl3c3PTfumXfmnhGdyHqJNahJcBmyYUvGlPmRTG43FlMt67dy84EnPwADYF\n", + "eMH4o8OpBnyb1tfXw6aaaWtf7y996UtyI4V6Y7N7eHiYXMQZ3rE39kLmAnOCFYb9My5fvhx0vdgJ\n", + "P7XYI1CB+5vT/eAZvHn2v/F4pD7GZicmPd4YclJjXI++wtxWjvz37t2r/KawiobUKtkJVklJgfHE\n", + "WsXXsYM/+hWbdrVeqUMRO1/7v6X+HWtTnSJ0qiz1d/V8H4lmVp9Ghe9NpZRa5QOYE/GXW4Yyl6nE\n", + "w7E21pkoc0yYCssEC/hr1b3j8biiBacOOypqdzAYhPceB0f1La+LUlQBMrnm/rPcoIZnn3mJBQUF\n", + "BQUFBQX/P8G5mvbU6YRVZGFyGI/H4QTJWiBeb4pPtilzAO/swQINBoPARGGHPB6PwykRO2B+DnbU\n", + "BwcHlfpdvnw5lI3cYsxcYbfdbrcX9ErMtCnr8ePHFbPmwcFB5Z6UyriHYhZYqVadTnHKrsuHqEJ5\n", + "vbP55cuXK6ranOiSnQi9mUedRJV5jR3IlSaLcoyso37Vc1c90fIpEGxRr9erMH6s08RMTopZwdzl\n", + "tvH4+vyBk8kkzG3/LAaPEfq31WoFRheM1P7+vt28edPMTsaNc5SlGKm9vb0FxWjAj9sqp/Q6NmrZ\n", + "kHO+Bqzc7u5uhR29dOlS6Bs+SatnqLyF6rm4jnOM+rlT596g9LDqrssBZwZQzrzK2byOSfD5/Jap\n", + "z5OCqgvPT+/oze1QTB3gzbRPup2x8lW9vKtAbC3yzDoHgzET5SVWYnV59tlnzexk3WG3ipSZVLWD\n", + "53vKDJ6T57AwUgUFBQUFBQUFK+JcfaT4vwA77MEH6ejoKOwKWcQLLBF2sbnCmP1+v5LRfjQaSVst\n", + "To7wc+p0OsF/AyfrTqcT6owTItcHp8of//jHC+Khqv2A931aW1sL7cRufFUhwpTonmJZ+FQBFkPJ\n", + "TPDJwN/bbDYr8gJcBtiTGNCXqDvfi3HgUz5kI15++eWggA9GjJkCFb7LfeHnFDtQ8ylqVQdRddIc\n", + "DocVB+Xd3d3gr4e5qxy5manF+7O1tRX8xPhZOCWy8zo7zuK/3g+LT2g8j5m1BcAqs08DxppzpKlT\n", + "pWecFXv7JE7pMXYyBcwF+HeqcX3w4EHlNw4EwDrR6XTCv5XQJgPPYwZLKaCnkNuHKd/BGIunxinl\n", + "PJ7qbyVEGiunrl5nASWqqXx0PUs1nU4rjJS61/vAnQfzpurF6zvA/mFcZzVvU++6AtanVqsVsnW8\n", + "++674e+5/lA5/aesCzn+lOdq2lNA6hgGfyCZJsXihQ/MwcFBRb12bW0tDCw+LMtqTfG9DCzqvV4v\n", + "OC1zCg6f+uPw8DDL9Nbv98NGAHV//Pix3OitAhVZon4DeDFnKhe/Abx58vooKp0KjwOuOzw8lFFp\n", + "2MjiHt5E4t9scmL9rZQ+GC+GfsEzS+uqqEVu2ei9mIMvm2rMtOK/Ai9ImHcqmTDK5GfkRtkdHR1V\n", + "Eh6r6DNca3Zi3uaoTF6Y8W9lUkS/jEYj+fdVnXBzkPOumFU/BLHoOY+jo6OK2ZqVmdm0q8xaPsE7\n", + "gz9YytSeQl3E1FmYAJWpi5+rNha+/rFNb8oJn69fdXPCquiqfqnNZGxTmdLSytXLUlDmrdi4Yq1Q\n", + "/auuU1kWeNzUPMK/8d0ej8fhkM3PUw7lyCbC7VFuEMsetFLX5/R7Me0VFBQUFBQUFKyILxwjVQc+\n", + "lWMXy4lT/c4yxj6pnfKXv/xlMzN77rnnzMzs5z//ub311lu1dWLzD6sYAziN93o9e/31180s7RTe\n", + "bDYrelN1bAQYmIsXLwZNJuUkF2Of/Aml2WyGZ/KpA/WGeUYlMeZTAu7d2toKDAmX55kNsxNNKZji\n", + "ms2mDA0HO+HD6c1OElS/8847UpqC8+mZacdyZrhYmsCblOtkCBjqJKdy6AE4DW1vb1cc89V16vlq\n", + "jBhwkO71esFsyO+RelcUU5fL9KLvmXlEeYqB4f5Rp8PP0+ShAjTqFOa5/pyU2ey4z7F+sCZXiiHm\n", + "svFeqPVEsQBcXooxWyV4ImXu499yGKtWqyXr7O9Vjtt1ZfM1KcmTVBksa6Dq559jlmbRYvdxO3Pn\n", + "ueojXxf1zPm8Kh+j2mGmGVjPdvHagXeg1+sFBta71/i6e1Y+1n5v/VB9pfYGsW+h/y3LJFh7RUFB\n", + "QUFBQUFBgcQvHCOVwjKnqGeeecbMTkK1NzY2QmZ27HBjKuqcod5fF2NozI5ZlxwfqToGgQHfLLBe\n", + "g8Eg+ATV+ZHgXmYSwJjwvRzKi5MI7mXgGVtbW8HJmMPplV+VclDGiQWM1M7OTkU6wSwdKsvlepZQ\n", + "MSvqFMP/74UqzU4YCeXPE4OXHDCrqsWzwzizbTdu3DCzxZx4vi4q3xTXD473EPfkZzBYLA99iXru\n", + "7e1V5nGr1UoGeyjfMcWych4+PANzbXd3t1LOYDDIzjqQctytc+pNsTbMnuDvzGZiLPv9fuhLDt9G\n", + "2angEe4rZlHRR8sGO6jrYjIevmw+3ftr+N8xRipH6sDsZC3i8hQTuiojGfORWpb5UUgx3Sq4h/8d\n", + "87PM8dVZxo+qjnFDef495fqzzyLWSKwxd+7cWWCYAe/r2263pTBqzve8zh9O+YSl3pVV59Iv9EYK\n", + "iz0W0mU2UnAe5//+y7/8y8JvCpcuXbLf+Z3fMbMTavLf/u3fkkrM2GipNCOnBTZBdSZITHh2JoZZ\n", + "gDdSKTPT5uZmJUqI2+Q/EnwdR4QBOzs79uGHHy789vzzz1dMkv1+P2zMuJ54IbiuWHy5XF8evyy4\n", + "/ujoKPQR61f5DVSdaUIlOV4WaoPx6NEju337tpmdbKSU5hZDmYXVRgpzguvOCx/afuvWLTM7Tk3k\n", + "N/tbW1uVjZQyoTJSixZvWFl53bfz4OAgOK3WQY27Msmy+TXno68+5rwpYu01ZFRImWnNFvWo1PO4\n", + "XNTVLF/TTH3MY6YubwJU4M0VR+oqh3EVNaw+pLjOb6j4utwPpOqXVT6aKYdw/j1VF3Yc5+t8m5rN\n", + "ZnJDpnCaNvH93hzpgTHmeY45iO/d9va2/eqv/qqZWUgP9uDBg7DeQGPOzCoBQeq5Tz/9dPg2wzRe\n", + "Z55TZrw686ZHTgBRMe0VFBQUFBQUFKyIX2hGahkTmAdMeowUEwV87WtfC9f967/+a7gP7A6H8WMn\n", + "+ySYqGWhdtUqZFo5yXptIbMTNtDshO1SZkvWxvFQ2lFvvvlmcMgFrl27VmGu2HTHjBTjQgJJAAAg\n", + "AElEQVR+f+2118zsmGXxiTL5VMwnKtzLzArMSihjfX294hxsZhWFaYVWqyWZPs73Z3Z8KlJh/t45\n", + "kxNUKyiWCnXf3NwMbcI8YKkQJZmgxgvXX7hwoWJ+5dMe3tVLly6F69SpUyUqZrkEjBG3u87JfVnd\n", + "mtTfFJQJOBYcAv0bdhLH/dx29JcKTuDnKi2wZevMUMy1v6fu1M4aZEovya9Fy5ij/L1KhkAxDnX5\n", + "/FZBronIs08qAbW6jln3XEaqzkTN13lTYqNRTTavsExdfvSjH0X/rlxnvPyC2cm35tGjR5Vk83V5\n", + "C+tkDVJ9lHr3PAojVVBQUFBQUFCwIn6hGSkFzwzU7Sax2+31ehU/HLOTkx7suf/1X/8lmSvv9Gl2\n", + "diefswCzRWBA2H9F1ZWV280WWTycmGOnGPQDGARmDeD/wX46GIfhcBhOHRjLl19+uVJ+q9WqME1m\n", + "J8KdqB+frFn92fugtNvtCkPHEhAA/z+324tb4n6zRZ+HXL+qFJvEz/cnrzophjfeeMPMzG7cuFHp\n", + "P+VLxSyYciZP5aHqdrth3mE8rl+/XmGu2JcK4zUYDMKcYZZEMWU8bin/Gx4P1JsZE+VUvay/kRo3\n", + "rEHdbjdcx+sFfkP/7uzsBIdcvKu8jjH7hDrnMlG+3mYn7W232xWx1NiJXY0DM1H4ry9H+TSp9yIm\n", + "taH8ulKsAv5W9x1AnevGkqGc6lXASkoWgq/3zBpLLHDGjxRymRfVp9xHdePv2SweL/zGTuXM1Kp7\n", + "ECyFbzAziGx5SjG+XGe1DvA89+1V5SzDTP+f20gpJ0SPRqMRBg50eqfTCfdgMZnNZgsmLLO4+U+p\n", + "sObCbzpikX2pRLLLwCuL86Tl9B1qoUAd4Vy/sbGR/YHFb8rUiTrt7+9X6PvhcFiZ/F/60pfsZz/7\n", + "2UL95vO5jCYE+GPjn6Femn6/XzEf8/jyeCiq3n+sx+OxjFKE8zjSH3zyySfS3IF5oRYT/s1/5FTb\n", + "OKEwKHZ+Z7DZ4eg5bKrYyR3z5bPPPqssXpzWBptwHgO1YOHv/BFm+Lnmk6WmPhjcPrUQe8folJk7\n", + "9gxAfSzb7XZ459SHCo65P/3pT8NvfABRa4z6YHjNNZVQVn1cU/3o4eeUMrHxv1MmKjb3pe5dxgS4\n", + "LPj9zYlc5AwcShOOr1fO0DlK8948qNqv0lqpuvu5zdexDpOK/vVtU9ks+NDBfek3pdy/XBdPYrBD\n", + "voog5Hv9dzE2hkDdBmklh/2l7ygoKCgoKCgoKDCzXxBGanNzM5zGQBfGdpWeEWq320H1G6fdg4OD\n", + "wIoofSIGGI533nmn8jfslC9evFgbzhy7t9vtBnVvsGMfffSRzKuHHTc7Y3NouNnxKTTlMGxWNQPE\n", + "tDtUHq/UKRZgbR/W+PGnHT4po+2PHj1aaAuAUwfMGmCjfJ0UY6hC2JUpxFPO+/v7FSdeNgtxecpJ\n", + "WjGHKXMB5iSzowCbUNlECShHas436DEcDgMDBhwcHITwfDj3X758OTBS+G+3263ILgyHQ3mSQ13B\n", + "SN27dy/0Myeb9qddbhubxvy4KUmEHKTYXT69ezmQunBr/k1lC+C/++e9+uqrlbrgnmazWVnb1Om+\n", + "1+tVdLVYxiNl9uXfFPvF75G/n0P1uTxvAlLMBecCVH2UYqSYqeH3V5nTcsLf60y5bKLE3FFsGvdV\n", + "iklT84Cfwf2hnPSX1VpSba8LIuBkyzFwPbBmzud5SulswlT58oAYY5pSQOe5o2Q8Uu9ynXmTURip\n", + "goKCgoKCgoIV8QvBSK2trQUnYvgsPX78OPgPYKc6m80qO3R2ZFXOyXVQDugAnhVjo9SpF7v1a9eu\n", + "LdTR7IRB6vf7kkXwImi8s1aq2Hx65xOpOiXgtAOfoG63m3ScBUajkTztqhOrP/1Pp9PgzwE/nX6/\n", + "XzlR9/v9wMKx87N/7s7OTkXYzexknPiUHRPK8+UqR2WFHL+1ZrO5IJyI8rzo59raWiiPGTHFRAHK\n", + "QRr/VUzOcDgMDBgzV97ZeGdnJ8xvxVAC7NfHJzmMq1LR53FJ9R87wyqH8FWQG+atxgtIObeqecJs\n", + "pfK/UiypEj5UzrLeid3Xry4UHtcpBX9V51gZDOXQbJYWtUyxRfwbMz7KSdvXuc5pWjEXKczn84Xv\n", + "Dn7z7VA+XwqqLzwj5e9Xfarmp6pPbI1WfoLLMDNmi/PYz1X+rqjvFxALNsiti++P2FxMlbuMr9Qv\n", + "xEZqf38/dD42UlevXg2dj83O0dFRZUCW0ZpCpNILL7xgZscL30svvWRmeqNSB3z8sSmazWZhksHU\n", + "0Wg0wobLO4F7sOK2B8pQ0Qn+HjW5Fd3O5gyzRUfRVOTD4eFhZROpkpDy/Zj4vElAGp/33nsvbKQB\n", + "djwELl++XNmAxqJw1IfCO4dz/XyCZA+lNp3a+PCBwJfJH0P+GzaCaAdHsfmUMma24BDuP9KtViu8\n", + "N0jw/PDhw9B/KFdFFCqn/slkEvoIY8nJiAHe6KF+vV4v9JV6X3lR9Au9nwPKITZF+XOb1PVqDFOL\n", + "Lo+HN0nx2Dz77LNmdqwrpdqA304TWMJmSf9h4YAB7lOf0iM38pg/+uojrFCndq82IwD3rTIBLusw\n", + "XLeBSx280GftdruykWYnfP6bb1ssQnSVDcCyY+fbk4McjaVOpxP+jvV7OBwmI0y5r7x5ue5AEAss\n", + "ycEqDuaMYtorKCgoKCgoKFgR585IgbVhbSPsQLGbHY/HgaXBKXptbW2BhTFbpOKVrgV2uLPZTDIS\n", + "OA3jVP7+++9Xdty5bFSn00nSkHjW1tZWODnC9DgajYK5hTWc1LPRJjAc7XY7ae7odDqVtk+n00od\n", + "VZ4xdWpSodVmVT2v8Xgs1Zc5Ia0Hm/HQX+q0hTKUWY/VxLn/VDkwM9axmGgbm2qU+nvKLMRaO16d\n", + "ejweL5izAMxLlklIPYPNDJ6pYZmEVJ7Izz77TI4bv5seeFa73Q5/x/u7vr5e6V9lkldOrhcuXAhM\n", + "Lp/oeb7nyBPU6UNx2V4fTL3LPIYq7yOb4lFXKJz3+/2K3Alr7aAM7vtcswbXxbPLMSd7pX2mAh98\n", + "HWJh/r7OyplXmb9S7Itvq3JyV7ILqrwUo5NqG9/D75QyPfrrYybAlFkw1oYUU3ZW8FI2k8kkue4A\n", + "PMc4CCjVLi5HaTPmIsUGA0phPuZwX4fCSBUUFBQUFBQUrIhzZaTY8Qw71l6vV/G14NBv4OjoKCpc\n", + "6YFdpwrF550qTs1Q0j6N3XRzczOUlzpJHB4eBiYEzMpgMAgsAH5rNBrhJM8MhncObTab4R61C9/c\n", + "3JQO9Ow7YbYoMskicylGivvU+wVtbm5WxBR7vZ4U8wQwvhcuXAh9qdoEcdUPPvggWhZDnbLZGV45\n", + "3/IYqjorQU6Uh8ACZn7ALrFzPViHTqcjGSmMjQpEYMdtzAX0X8w/zrMofC/+tre3l2RFYiduPMu/\n", + "t4rt41Byrqf34Ynli+QTc45obd2JXflZpXx3lFoz+wSqPgdGo1F419H3PA5cp5SPpGof5y1TJ++U\n", + "wGKOPETd7zxeygdJvTNnAWZ8Un5TMUdwxbalwH6lPjglVpecstW9p4ViwOqgLCF1OSU9VG5JQNXl\n", + "NLkRua9iTFROucv4mp3bRqrRaFi32618lI6OjrL0Q04LjmgyO55guY6dqUkETaher5eMEkSbODUJ\n", + "Rxh4h9zJZBKeC9PSo0ePKnUejUbBTKaUvFVUh9oMqboqcym/ZCkH6sePH1cit3JV4FUQAUNpR6HO\n", + "3G/s7Kmcx9Ff/NJzOSjXv/QcgKDmRGpeqXaNx+PgnMltw7hjfFl1HKij2FHGZDKptGM4HFb6JZaW\n", + "RX1oVz14TKfTYKJmM6w3jcUWbd5IeW0fdoKuWxC9A22uCZAdt7lNHt1ut+J6MJ/Pk863dXpnvm0q\n", + "uEKZTtgRGKhzck/pSPFz6jYKKsJRmXtSZjLevPh2xp6pVMBP62TM5fGGum4DpDSccsyldYhtkHI0\n", + "o9S4xUy7qQ0UO4mjTBVNqlTUU6Y4vkd9iwB1L/eLujdVXg6Kaa+goKCgoKCgYEWcq2lvPB4naXQ+\n", + "8XHiUrN8uq/f71fMJHwSy6XLgbW1tcC8cJ4+nyT54cOHSSYCrMfGxkZQV+c64O/on/39/XBixo5/\n", + "bW0tMAzol5i5E+WwWQj9opLv8klEsU98IgR7wg7jXrF8b2+vcgpSJgx20kcZdSbcVNLkWFizYi4w\n", + "x9TpiR2uof4NZ3hlOuOyYUpVp8XxeJw0ozA7hv5FnzabzUrfjMdjqbIO1AVLoA7MzijmAvViqQ7P\n", + "DHS7XSn9oODngWKIh8NhUo4AdeO6xORKFJOT0rJRUI7bqZybnL8SYNYBdeJ7weKORqNQP5iy79+/\n", + "X6ljLFzet5frzO+bWo9zQt1jJt4cJoR/V1Ir+Bszj7xuez0nZbLL1XNahaFKsXMsdaCu5/op7aOU\n", + "+ZOd5ZVeUkozKhYw4O+N6aYBPDc4UwHgMwPw/anAkFgQk3onU4EqXK6vv3JVUb/loDBSBQUFBQUF\n", + "BQUr4twYKZxovYSBOvVwbi/cN5lMpP8Ass17pW4zvQNeNk8XMwCXLl0KdWefEjMtwshQuegY3k7b\n", + "brdDX0FputvtBvYh5RBolm4nn07Qv9y3zMaoEwYYOvjz8ImAM9B79oT9l1R2cGZqvO8BCx4qxkrZ\n", + "vFOMz3A4lI70qB8/wwumdjqd0F9gJMxOmCMwSTEHX6VejWco/6RcJ13l06LmgfJpwPiqkyGzAArM\n", + "sGxtbZnZSR/wu5w6/a+vr1cYtcPDwzDXuB+5Lt7XT70XfJLnOqsTt2cLe71eGGtVfz6N417UYT6f\n", + "h/FMMTTc55h3s9ksvIecSSFXkDHnlK18X1TOM4WYY3RK3DLGnuE+5dOC/kv5YeX61NY5JedCtUc5\n", + "ufN/U76oXK7yffPPrauXesYq96rxZX9CH6zDeTDxLphVrQGKMWMpiWVZwjqpA/V+pFhXL/+gcG4b\n", + "qa2tLTs4OMhK28KbISxi29vbYWHBgttqtSrq4LmRfbloNBpBcRuT4969e8lEwKtAqZv7QWbNLbR7\n", + "bW0t9IuiZRnKoRnlcL+hbeqj2u12ZRSZN88pMO3tTbf8Gye15M2GV1JmejnlLMv9gv4bDAaVucha\n", + "S8DOzk5F/VtFfqq2DwaDyrgqHRyzqmM5A2Vcu3Yt1Jk3u3gfsEkcj8cV8wdDffjYEVRFpKnnAhjT\n", + "0WgUzFAcAPGVr3zFzMxee+21Sl3wLHb05wUcawHaFkt5lIL66CsTm4om5ChBNqcoU6FK5ZQyQ/uF\n", + "nn9jMzibN9VHJqX7pDbyPNaqz3MOm/yhUhsgIPaBTgUW+TnJ/1Ybqph5S+EsnM0BjtrjoAL/Ic6t\n", + "s78utSkF2JSt2l7XXuXgX2eWNVsMGFBrOc/tVLAWr6k535BYG3xduTx+R1PBRMs8v5j2CgoKCgoK\n", + "CgpWxLkxUjHzQKPRCCaRFFulQt6n06lUtz4NsLuGSWFnZyfsaJGQdW9vL+xeFaOSUn9eW1sLO+BY\n", + "jr0cpMLGzXSoKZshcMJnc4p3qt7c3Axjwrt71JsdoxUUfepPBHzyxn+VGnuz2YzOH4bS8+Exwrgy\n", + "68nmF3a+N1scIzZ/KSdjr5l09epVe+edd8xskVXAPOH+Qx+mKOcLFy4EbSq0SUkxKMVldixWJnKl\n", + "3g4wja9OqSo8n/GlL33JzDQjxayGP9myeaCOaVZsiBojrr+X54iFkvt5xyaMuiAHXx4HqqRO6lxn\n", + "mMvrzBVAnTk1VT/VDs4WACgWjU33XIZ/R3me8N9ywtDrzLSxtqj/Py0Ue8NZCpjd9uydMgGaLTJv\n", + "OSbLmNxHjkRAXZv4t9i1ZovrCcutmMWlYPy7WSc9opB691Q7zKoscExSpA6FkSooKCgoKCgoWBHn\n", + "xkjt7u7a+vp6ELDEbn1vb68215lZPDwy10HN+xHF/CxwHeeyQ74vsDOxe1M7WbBu+/v7wSH31q1b\n", + "Zmb285//PFn3OoFBxSIwO6b8oHx/9fv9hVx3Zscndd+/k8kknCaYRUGfsA+N+g1tZ5FO376YYJvy\n", + "5/AnHnZeV06D/Azl7wOgng8fPqz4linmSoEZVp4zKOf69etmZvbRRx9VnNfVHLt//36FseI5ocQy\n", + "mWlCezngQTmlp0LsFZidUczRD37wAzMz+/rXv25mZj/72c8q13S73cr7MxqNwnrBDtcKdX4o6tTp\n", + "xz0W5u2fEXNoX5YBUQEIqUAJRur0zlkKuF+Uj5//mwpbV+2N+TmlWABmSdW77MtQPlx17IgqL4Uc\n", + "JisG5Wc3n1dlPFqtVjL4Q9WH+ygFJW6K37ledWXl+iUpBpGZ7hz5k1arVbE4nMbHuI7dU1IRKjDD\n", + "B4ukcG4bqdFoZKPRKHQgR4thI4WouPX19aC15NOkMHhjhkXx448/Dh2S+jhsbW1Vym61WhXdKu78\n", + "ug5OKRZz2hXoDN24ccPMzL75zW/aG2+8YWaLuk/4mKMuvGGCWaLZbIbfmUrml1lF3rEZzezYhImX\n", + "gE0ePpmq0sZhB2XVZvTL+vp6cELmRLxedZ77kRdS3w5l7ltbW1sw1Xhw2di0qHHjvvKO4DEK3Ues\n", + "PXjwoEJh80uPDRU7pacWvEePHlVMsryQsqlIfQS9bhZ/CNh8BKh3IPWhZNV+BvoX7/Tt27eDyRPg\n", + "SE02v+JdiZk8vXmM1d9V0mUeD5WIVUVNcmCH2XHfq8ONMiX68pSek1l1bBTqPjbKVIg6m+mIYR/t\n", + "qFTbfV3xDLSNMwnkbCbZbFW3AfZ1UTpNCjFT65NGTC3eb2h8hB6gHKPr4DePvC6mgk1iJsU6kyOQ\n", + "+h6ehYJ4jDwB6qIUVVR26pCYm+nErJj2CgoKCgoKCgpWxrkqm5udmHRYNwdMFDShjo6OKnpJsTxt\n", + "+B1sxqVLlypO3/v7+xXZAGZRWBWZmSPUM5VoF4gpKgMqcTCSJV+9etU2NzcXnvvZZ59VQuH5tM1O\n", + "0MqxXGky+fry8+7evVtxvuW/oy87nU6oA5+AcxKxcv+gDHYyTCnbqv5VJzZWz08pXJvpXHsA1x0O\n", + "3urEl2KuFObzeZjvYGhu3boV+pzr58djPp9XAhS4n8GI8VzjfmZneZTn+5yZP1azT52OMfaTyST8\n", + "G9jY2Ajvz4cffmhmxzIOvg+YaQBTzExdjIVQ5kAFr8IcO3krEwz6jdcB5bTq5zuPDQcY+IwLSrE+\n", + "BsU6+fWu0WiE68CSKckSBXUqVyzVbDarzKdGo6rWbVZlmhTzx/cqVoHLSEkncHln7Vyu4J/RarXC\n", + "O5AK/lBlMAu1St1zzYf8PPXt8Ca72Wy2YL739VNsMLtXKHZMmXa9XEFMW8oz8CrIISb34Zltrt8y\n", + "iZkLI1VQUFBQUFBQsCLOlZFiBzo+0eNUiv+anZzGVS4zZpqUo7q33c9ms1AedrZKamE4HIbTHU6f\n", + "+/v7SXVoXN/tdlcWBf3444+DX8i1a9dCW8EssL+L8iNSdnAwegcHB1LETTndw2/p3XffNbNjhgPs\n", + "CrMjGENm9/zpcG1trXJCV9nBue7qFMGsiEdMlZYFRT2Ug2/MmTb222w2k1IXcIhOyWCotrz//vvh\n", + "38w4geHCbyx1ofyS+GSlQvaV879qYw5LxeCx8n2p3oV79+4F9ozh5Q8ODg5CXb0YL+Dro4ISer1e\n", + "ZSxYSZ2vZ3babHFuKP+xlN+Skl04OjqqzMtYGf4d6HQ68lqlMI3fVP8rnxz1XA7pV2WknMgVW8Tt\n", + "UQKKgPK54mehnFR5dbIPddcqKNkFzwJx/dR1XJa6rs5xX9XJX8csP89txRamrADMKqmclvgGwvcu\n", + "97sXy42XWnMVM8V/8+3gfuFn+fWJZWGWYQHPbSM1GAzs4sWLYXHBJiFGo3kTRqPRCIup0kBicIoG\n", + "s+NFE52ZEyHI18XUWLHo42O3traWdDbHpOt2u0H9mTdIqB/6h5PbotxlFJ3xUefNEBAz1XhNLn4x\n", + "eDJiU8V96RcF3jTxBMWGkcdObTyUA7Wig9UCpZR2AU79gTmGMWQonSvuM7SDTSbeDNrv98MiA9Pt\n", + "48ePQ9uV0jxDzW82o5ktOhCjnIsXL1ZMyWoBipmjlS6ZT8Xi/43/9w7Nk8nEdnZ2zOykrzqdjtRQ\n", + "w1jz9RjDmzdvmlm1T9AfqUWcNzQ8DgDGjU0T3F8pyh9zR0XE8geD3x+OCMV1ftHnezGf2cTCdfem\n", + "Mx632GY5Bt4g5SQv9m1Tz/L1q0tDoxyueXPnf4tpEOVE8p3G/Kc+1rHAG7XB9L/xhpA3PkCz2Uyu\n", + "lTzXvJl0Op0uHY0LqHmvkpujjmaLpnRldlvWhKn0oXjzWmfmxb1qbJZVUjcrpr2CgoKCgoKCgpVx\n", + "boyUdxpN5d3Z3t5eMPPhPq+AzWDnSpXfLKX0C4ZrMBiEcnDyZZ0j3s2qRIwpp3Rc1+/3w6kYv925\n", + "cyewCakQTHbcZaA85QzrnX99fXgc0G9gW5TekJlVTGfT6bTizM8ndA5nR72UxAJDMSA59H3sROjB\n", + "c4hPap49uXbtmr333nsLz9ve3l5gEwCYRu/evWtmWsbBbNE0bbY4rnziVDm0/Nzu9/sVljXWnz5Z\n", + "MiuHp+5nZ2PV5xhzPn2m8tc1m82FoATci/mGfmS2L3ZyVWuBv5brr0z6yhlWJUYGmIlI6eYMBoMw\n", + "rri+2+0GXTpmC/yJmllj7w4Ra6ti21ImLmaf+PqUXhaXsSzDoxzG66DMVp7NyNWbWua5Hqq9dTIO\n", + "6rsBKHMkm6jm83nl/VTmz1z3gVarVWGuWKFfmcGUKVsB13GCb2bx6+ZtCjkO4Mr1IMY++XawidWP\n", + "WwqFkSooKCgoKCgoWBHn6mxel1sOJyDPRsWgQuebzWZgO8A07e/vy9MV/o7/NhqNCus1m80qPgPs\n", + "fIe/KXkDBvyibty4EXbt8ElSqs2tViuwIxAdffrpp0PfwO/p6tWr4YT75ptvJusAdLvdyg6fHZSV\n", + "Izif/HEK4jBf9jMxW2THwJiwbwwLBXo/Dvbd4ZNLjs/GfD4Pf1d59RheQFHlFOOTJq7nUyD3EXIV\n", + "gpFiWQiM1/r6eqgPO1B7/yrcz1A+Tfv7+wvipijPO5Rzv/C4qT71zsusjs/X+dNdzCco5Zeo5Ah4\n", + "7sAHCazghQsXwnxHu8wWA0uUcCvAYr2KjckRElSn6U6nU5mzSrV/NBplh1mnciMqMBOlnpHD2pid\n", + "yNBgTeO2ASocnZ31UznjlI9mzN9R3euZnpiUhcdp5QUUvDyDYqZUAARD+S+y9ANw4cKF0Gb1vUk9\n", + "IxZko5imXJV9z5gxO6sCH9QzUvNTBTTExi3lNA8o64Zycs/xmTq3jdTOzo50zO10OtJUhH9j0WfT\n", + "Hho+GAzCxw0bjL29vfBhwYf08ePHoXOwyWKnZEyAmFYVgOdynVn1OLVRxGboypUr9uqrr5rZyQeX\n", + "2466X79+PXww8NIgzQ634+joaEHHw+P+/fuVDcPR0VGoN5v41MYjlZhYJavkxdybGnhiozx28GWT\n", + "Av7N6WhSiy9HEKI/MHdiH3Jf3sWLF8NmBPciUbXZyRip1Dl4tod3tOSNlNLaAVhDCWDHbdY28s7y\n", + "R0dHydQQ6KuDg4NkGp1UpB6Xw2YrH8nDDvfAcDisqMBzFB2vE/4djY0lf9B8fVX0XKxN7Nhttphu\n", + "RV2HjwR/LFKbNbPqmKh5HHPmBVKbMWVOiSU8VvPYf6RZKR+IbaSU07yqn4rG8nWJjZHacCmoflZ1\n", + "zkHMLJja6KU2d8pEyc9QG0vlatFsNivPq1N/r9u8xNrm4TdIFy5cCO8nJy32c1VlpOA6xP7fA2sN\n", + "uw+k1rPYprHoSBUUFBQUFBQUfI44N0ZqY2PDer1eOIHi1NbpdCqaTEdHRwtJbc2Od6dgOPg07p2v\n", + "O51OYBU4nB8MDkLO8Ryz/Bw7OEW32+0KixJzOgVNjrbdvXs3MDRge9rtdmBAcCJ99913Q9tYTwi/\n", + "QSeKd8+sucWh9YrxUyHu6vTof4vlP0KbmP3y1K8yJcUSKadMToo5Q502NjZCXZSjPfpyNBotqH6b\n", + "Lc4XjA2zgPw8JeMA9orZCt9XPE/w/EuXLlXM2Upu4uDgILA1t2/fDs9nZhNA/2Hs2eE6dRrvdrvh\n", + "HmZxFdvKrI3Zcd/7EyG3F3N2b28vOwcdM1ZmVUYqZXLkcVAO1J71nEwmFVaa+43LS60ZdRpTyqSI\n", + "eYn+4rxgSu6D32WsS5x/MfVMJbGQOo2nHI1RL64n38OOwMoU5x2g+TrFLnICYGZvchgmxXrlIqbX\n", + "5FXAuc7KvJly9Oe/8/2Asgqw60lOG1BHM61YP5/Pw/vAeRi9Iza3E21nkzvDz6nZbCbzUuaODdZD\n", + "1s9TARmqPKVPqAKv6lAYqYKCgoKCgoKCFXFujNSDBw8WbOgcuorTPxgEKGt7eCfn1DUe2L3ihMtl\n", + "sMhhSkAP+cGazWZgxyBbEPPdgFL5s88+a2bHKtY4WWBnvbW1FU6T8E9gBkC1CSdX9rlhKEVm5XDI\n", + "pxwfGu4dewHvH8InG2Yk0JaUPxwrkTOU4CWH2fvfgIODg4W8Zh6eSeQyRqNRYE1YxBT3cLt9DjW+\n", + "h9k+tE35kAE4nfl6si+T2THLiPnG/aJOpJ6RYn8YxTyyfIgfD35H1akYfbGzsyPZMW4T4BkuZjCZ\n", + "OcM6EXO4Vn5EynHfn6jZj4Tr5fMb8jvDJ1vUVfmlsL+eElD049XtdsP7rE7qKIPbyu+Z9+tSId38\n", + "TMUCLStKqHxpOMReOfMqR+zUdYppUs7BuVIMuU7puVB+Ysw0KT8xVc+YunzKGlDH3qigCcDPF4+U\n", + "ry8/37OYsfr561jkmOd7SqqD/6bqV+fEH/tt2WCmcG3tFU8Io9HINjc3K8lDOaEwDywaBSftvb29\n", + "sGHIjWIBeEJiwWq32+FjjQ0Sm+xYhfnGjRsLz93d3a0szLFNBzZSTL+jHcpUxKbC1MuOwY5FJLIG\n", + "UUqzi/Hcc8+Zmdlbb71lZpqqnU6nYROJPuIUHBy9501n/DFHnZSWkdIC43u47z8SOMUAACAASURB\n", + "VNFONo2gfvxRZ7OS2bEjvDczj0ajUB5/UDn5qNliJApMt1wOm2dwj9LmAo6OjirO19xO4PLly2Ej\n", + "xe9AjuMmX8MbYP/x6vV6lc2eMtNye/0YxK7jzQTmBkcX4l354IMPKm2IHZD4I26mTR1qY8EbxtQi\n", + "zdS/MjMrcCSiMgv6DwuXxRt0/M5mMu/Mb1aNcuboOYb/uCozEuuw8XV1JjNcl3JeVubb1OZKbSbU\n", + "YTwXp9k8qU2T2WLCZv935UReVwc+7PhNV2xT7+sQM/fhMKS+typtVCpogr8rPHf8u97v90OZnNge\n", + "9/C74jf4ygTc6/WWTsFWZ07FM3wS7hSKaa+goKCgoKCgYEXUMlJ/9Ed/ZP/4j/9oV69etf/5n/8x\n", + "s2MTzf/7f//P3n33Xbt9+7b93d/9XQjD/vM//3P767/+a2u1WvYXf/EX9tu//duy3MuXL1u73baP\n", + "PvrIzE52191uN7AFOG3fuHHDnnnmGTM72RW/+uqrUtUbjIB3TmeoXeijR4/CPTgJX7p0Kex2wWps\n", + "b28HtuCdd94xs8WQ+DpAPwr3fvLJJ4Ht4PBNsACo/+bmZuUEoXKy8SmZTUSsRK2oVVUW9KyYbgWT\n", + "gjpMJpPKaZzNaSr/Ho8157Az02aVyWRSYR2Z3VEULMbo8PDQnnrqKTMze/nll8PffXn8XDZLsixD\n", + "DL1eLzyb+9HPMz5Bct/6Ofrpp58uMFtmmkn85JNPsh0jUwmKuY24zrNuOfAyEzGmGO+S0r7hezAO\n", + "KTOimWYxlCmb2U/fLk4ArQIuWIEf7E9KY4qZK5UrTumDpcLL1fWxpMV1Ughm2nE7Jt2RE4auTIXM\n", + "oiizIbMLfoxiZjxfh/l8Ls2WnuE6renOj03K7MR/X8bxHfAyIur5ZsfvGd41fLsU+8R9BLRarco8\n", + "ZvMcr4E+V6ma29zn/HyU4zNExNqMe9mhPdV/LIPDzJFKtO7/nTsnzkT+4A//8A/t+9///sJv3/3u\n", + "d+23fuu37PXXX7dvf/vb9t3vftfMzF555RX727/9W3vllVfs+9//vv3xH/9xdgRBQUFBQUFBQcEv\n", + "GmoZqd/8zd8M7AnwD//wD/bDH/7QzMz+4A/+wL71rW/Zd7/7Xfv7v/97+/3f/33rdDp2+/Zte+GF\n", + "F+w//uM/7Nd//dcr5Y5GI9vd3a3YVQeDQUXU7u7du+E0yv4aXrGchQf5lJ9ytGPgefDJuHPnTmAG\n", + "IIy5sbER6oJTgLLnKly9ejXUBaeB+Xwe2BOwN8oB+fDwMPjLKGdkhVj+OC/YWeeQr3bz7HOldvaQ\n", + "W2CVdu/PweyDCulGn45Go8oYst+U8glDH7bb7Qqb9MILL9gbb7xhZmm16Ha7XQk5Z7AflvL78Q7o\n", + "4/G44pvF5bJfFPzR4I939+7d0AdeHd3sWOXe7FjNXjFCqBfGRfX94eFhYBzZ586DfX34tIh74GPI\n", + "8hEMlTMQYDbl3r17ZnbCMo9GowVRXV9/LpPZpZSPFDNvKoeev5d9ppR6Opfh71USFoeHh5JV5ICM\n", + "WP1YxoGRygWo+oolFJZ1MlfgNUL5Pvl3Oebn5IMhFIsWE4xM+Vydpk2qv5VopmKkYg75/hnqfVB+\n", + "OqPRKLzHqg4ppffZbLYgOWR2vF759Y7FV5VkBs8hJYngg4SazaYsL+XnzOUqWQPFQgMsR6Gc/lPZ\n", + "GJbBSs7m9+7dC+ava9euhQXvzp07C5ump59+2j788ENZRqfTsbW1tbCwo/KPHz+uOODu7OyEdBus\n", + "CYPJheebVZ1Dr169Ghb9mK5FDLPZLJSHj1y/37e3337bzBZNEzkv6ZUrV+zf//3fzcyi/ZKDOsV1\n", + "BX5xlWaTv46db9HnzzzzTEjNAShNjn6/L9PcYFz5Q8+bJUCZWPzkZmdn/ohh04Rxu3Xrlv3kJz9Z\n", + "uPeNN94I9/OL6TcgrVarEhm4vr5e2QiqFBcM7iNsoFAu38cRpCgbCxH3Ad4ZHj9+B3CvivhS85QV\n", + "57Fx4mAI/+Fj53qUx9pS2GCqOcB9gE0lb4rUh5zfW//hiJmdUs7fMedrzCMVDcrX4Bk811KbFwVO\n", + "H6NMov7jwPOfN+be7OLrEGujUidXyX79v1PwH0h1KEq9J6gD15PB9yoHeV7jUmZNX99loDZ6nHWD\n", + "9aP8ddy3PjE2bzD4v2z2zY065ChRf52qA78reHextrBjvNLGUuZZ7nvvfqPM4CqVlNrQsEkRaxt/\n", + "Q3zgGpdXp6WmflvGLHxqZ/NYqKmvTEFBQUFBQUHB/zWsxEhdu3bNPvroI7t+/brdvXs3sEVPPfWU\n", + "vf/+++G6Dz74IDj6euzt7dlsNgt59HAqvnjxYtgh8+kEDt18evUOdIPBYCH/Ga5ZloligH1A6Pxk\n", + "Mklq46TwwQcfSKfuzwOK/mSTqN/wKrZqZ2cnMFIsz4BTBxwK+XSszK6cl9A7S5pVZQMYOIk8evRI\n", + "nhjApHhtLrMTk9ODBw8qprhms1kxV7GcgqKUGalcYiiDQ9i5XG8W4lORcsjmv/uk0Ep5mxkONgcC\n", + "aBtrkOFU1+12K3NBsT08r1hhWAH1T5mRYhQ7J5SuK0OVaaa1h5rNZphbPBc9S6lO2zzmKvCB56nX\n", + "8+K28G/eVYATi3OQBSvVA54tZLajTuk5l6VR7E6uE693LGfNrZS6N7MeXIYyv5/mAK/uVW3yfToe\n", + "j6V5SbE3uX3PfZrj9G9WNXHFnqH62q+5sTx4ytXCs6LMrCsotqjORQa/8/qk7kkFgqRkKBQzaGb2\n", + "p3/6p9F2mK3ISP3u7/6ufe973zMzs+9973v2e7/3e+H3v/mbv7HRaGRvv/22/e///q/92q/9mixj\n", + "fX09JBlWGkYFBQUFBQUFBeeNuo1U7Q7m93//9+2HP/yh3b9/327dumV/9md/Zn/yJ39i3/nOd+yv\n", + "/uqvgvyBmdlXv/pV+853vmNf/epXrd1u21/+5V9GTwZwRPX211arFSQCwCSx/wcj5QgKQF5hVXg/\n", + "rGXFPxlnZeZEnW7evFmRDWD7MDul885b7daVr4X3sbl9+7b97Gc/W/jt4sWL4WTODt54Huql/Bba\n", + "7XZlzGICa5gTSvKC2+FPacwAQqiw2WxWnsvOiBwC7H2ZuG5gg1IOxnUYj8eB9YDvE7NQas5w3VEf\n", + "78TO/1Y5tBgYy6tXr1YYqc3NzaTgHasiY76kcv2xbw4LtLLvo9lxu1OSF+iXulMvs0WpEyv7QwJc\n", + "h7rcc6gPM43e16/RaFTYApa1UI7R/F7607MKM1eIzclVna9j/jqKGVC+TLgX/aMcrlU9lW+R8tfx\n", + "f4+VG4PyJ0r5V+FZdd+Gs5Ji4PI4UMBs0c+tjqnB+oW/j8fjbNbLzym2OCi/V36ulzpotVoyswa3\n", + "M1aXWJ+roITU2sxiwquMT2N+VqO6zEO/oH5TfrFsNBqVD1S73Q5RRCk9J4ULFy5UIg3b7XYoBx9Q\n", + "Nr+wA6z/cKtNhUcq2oTNW8okgd/4hfMTnZ2MleMkq+z6xV6Zb3Z2dkJ/MM3MZjm+n59rduIsiedy\n", + "H9VFb/p0IGZV046qM3/M8dzJZBJMnZgfSjOKNznYiEyn0zAOUPK/f/++1ENS8Alv+Td2IgUwzpcu\n", + "XaocWra2tirmQF7A8X6Mx+NgVlXRengGpwVSzuvA5ubmwsbcTGtDsXmLP3hq8VXjrz7wdQlUc6OA\n", + "PWJRQrkfL4DXKb9mtdvtvJQW7XYlYppNbCkoJ+fBYFD5cMci3LyOFEc9MlS/qE2kipSLlbEqznoT\n", + "lHoG/79qk9p4p+Ykl8MHQ29mjpkPfRYDtdlQm+tOpxPWHV5DfF9y1gt+1/2GazabBZcSXsdUm3l9\n", + "MFvcJPI3KZVSiq9HBGps/IuyeUFBQUFBQUHBivg/5ZzUaDQqYe2NRqOSmDa2q1RqqOwobHZsTgNL\n", + "USdh4JXIP/vss2CuhHzExsZGRR/o2WefrdSl2+2Gnfcqzu7YybMukEriit06nxKY1cHfUee9vb3K\n", + "SUqZDJkdAYuhNIp2d3cruk+9Xq+SPyzG7oBNYAVdXy82EfHpBEwUn4o8dazmTozR8/fyKcs7sZvV\n", + "q/B7h/YY+6CYqpQDf0rF/OjoqKIszn3Azu6YY5gvSl+LT7c85zwjxTnoFLPB5hQ234EtVgEm6uSq\n", + "xpPzfSnTkNLQAXjdSelI8TxgrRuz4/H1c0GNNScFBiaTidQ088wVm1jrFNCV7pNHLJQ8ZapjpiGH\n", + "RavDk2SNPg/DjTIpAjH2U5nvUmZI7ueUUzqXkTIbq3uB6XQqg1v8tWqNUfUzq34z+N3n9QJzWpn+\n", + "UtIniuHKYZ4LI1VQUFBQUFBQsCLOzUeqTrAuBvidbG9vV4THptNp8KtQjESqvNg9eAb8P2azWXbZ\n", + "169fN7OTXXbufYw6fwwvRtbr9UKbBoOBvfbaawvtmE6n0t/I+4UwIwV0u91KaDXXgU9UHE7q6//c\n", + "c8+Zmdlbb70VfmPbd0ptXOVsAm7cuFFh6zikX0HZy9kvyjN5uWJ/7IAMPwFWDlb3qveB+8U/t9fr\n", + "LTiKpsqF/xf6lFWn8dx+vy9Pclx/tA1ADsz33nsvzHeMEeYeo91uVxyplYMp+xNxPVN5/JRTsHKC\n", + "Vj40sbntwSH4QK4EgwqtjrGKilXyYP/Es4DqlzqlZz+W/JvyuVH3fh6IBR2kruV5t4rT+pMC93ku\n", + "k+d9B5m1AWJ9pAItUA4zqzl+U2bVbw2/A6mgDl57lfN6XV/k+pj668FSpfYs52baW3VC4gOauylp\n", + "Npth44ABnEwmQfvq+eefNzOzH//4x/J+DA42aDk0JwATFhyGL126ZG+++WayrmbH5glMKJgoOGkx\n", + "Pjy7u7sVNebDw0OZYobVk/3i2+12F8wZ/Az+zSzPoZM3YWrRUs7I+EDu7++HuiKKjZ35+WXxzuF1\n", + "Mhrcf74vOWEvq2f7vppOp9mK4R6xj5LSMsF12MCtr6+HuuC64XAodat8nThKEX22sbER2gtT3HQ6\n", + "lRsUjA0nOfV6LmYn48CHE4/JZBLmLN/L6uoAxpP1x/xGyfdpKmIJUA7oSll/Pp9XHF4nk0klWTaD\n", + "x9LPMd5cc1CCOmxgnUHfs7MsK6rj32wuy9Hp8nX1/aL6jz9yft6x3pAqr25z6q9b9aCdQu47quqS\n", + "Y955Ek7uKbCrgO/7GHxksvobg6OZ1caSv4d+XVQBLewuwa4vdfpraKNPcXV4eJhMDePN5lw/3048\n", + "IydoovK82isKCgoKCgoKCgokvtDO5ss6D7ZarXCCw8m70+mEHSgnikXZYEdiWlUAl5sjd3Dx4sWF\n", + "ky3qkqLsORwc9cJvjx49qjy33++H3TjKa7fbC5oYHuvr6zL/kT9d871cf5wEYOpUfaEcmlutVqgX\n", + "sw43b940M80w4sTCz+DTAfpGhdjiWWzWY1MSM1Fmi6d3jPVkMqmcSljtPJdSVrnb1OmenW89xZ0y\n", + "T3L9+PTsqWyzE9ao0+kEUxwSOO/s7NjHH3+8UK7SkWK1czbpYF6BRe10OlKtXTEWOM1ibjCzwm1U\n", + "5k2ebyk2hNcT37/MbPF4plidFDtqVjVZNhqNBadWs8UTv7/WTJswuVyvYbS1tZVUlldO5HiX2UFf\n", + "saMxZ2QzvV74f3uklObPmtFRrGWd03yK1VSoq7NiNk7bzlT4Pj/Da5rFTGf+/VHrEwc5qOCalOM4\n", + "vwMcBKbqo95bfAuYOfTuLY1GY8GFwdeTofID+sCrHNN9YaQKCgoKCgoKClbEF4aRAqvQ6/XCDlD5\n", + "+gCNRiP4ObFtFqcx7Eh3d3cl+6MkBGB/xY50d3c3yBR8+ctfNjOzV199Nas9zWZTOtt6cTOFOnaM\n", + "nZix00YfIPzbTJ9mO51O5XSihA7NqpIJR0dH4bdlcwayDAXXBQ7vvOuHT5kaf/jfPH78uNJ2FV6+\n", + "trYWylH+N8rRGfPgk08+kT4tAOafZ3E8WH0+xXDxyc+L7rEwnprPfLLyJ0jO0wZw/j0g5k/EdUWd\n", + "wNqxer7365pOp1G/Cy5vMplkOU3zyRp9NhwOF/wfUixhysF7NptVpFNGo1FgmtCOo6MjOQ6ov2K9\n", + "+PSe6xzsMxYwM8QirZ59UOHmZlWRVu4DZoNRZxUIwGPp51OMVUhhWUFThVgwwVk4uS/LFsV8pHL8\n", + "9lbBYDAIfY6xjPn4qDVDzXcPlXVAlcXMqlpTWZYEdcW3ZDgcVmSGmJEGw9VoNML8VWOdUpZnx3wl\n", + "K4H3jefxMv7Q5xa11263bTAYVDSDzE46hF9wLB5w4DY7WbzQufv7+6eapHB4/frXv25mxxFJMH/8\n", + "8z//s5mZvfTSS+H6F198MdQJCxU6/9NPP7VXXnll5boAoN03NzfDBwobAlY2RgoV/ghPJpNwLb/k\n", + "3ok7pkrrk/hGVV2d46nSkWJdIF5w0W+YB48fPw6bpfv371fqzKYfvIjsBI2XBf22u7ubdOZmWjhF\n", + "TTNSlC8vYvg3bwxZRRhlpT5AeNZsNqvQ0LF7lzU5YlPU7/cr75TZyRhydB8OLIjA5END6vl1UWBs\n", + "7lGbVx+1xx9S/oioduZuYpTmWh1SSVL5N6xf+O3g4GBhjFFfr3bPTu5cfkrVGX/b3t4ObclRco6B\n", + "zZJeCypmojxL1AW9pJyCY3VTiWxz63JeEXyq7YBKmdRqtSruBas4xvM8SWmo8W9+reR5okz7GI/D\n", + "w8Pkd4Xh03jxe1G3GUrVj9dytDn6DUw+paCgoKCgoKCgIIovTK493n3i1Imd5vr6etglgrpWpomz\n", + "xo0bN8JJLkaZmx3XF9QlGJY7d+6cSYJj7NRHo1HoD/w2n88rJhG/a/enl+vXr4dEznxy9Tvzfr8v\n", + "ncaBVP4zrgOHtasccDiho5zZbFbpN9zn7/Uh83waY5NcKjyW66o0ilAO/qZCZxUzwGYopqtztIrY\n", + "7MKMnlIJRzmqjao9KdXrtbW1LBaG63fr1i0zM3v//ffltcrxNeXozfAhzEq1m5lTPikr5XA2FXhn\n", + "+bp8k8BkMlnIiRi7Xul01SGlGcd9pJy0+V7PIHIdWc4B18WCIPxviklgc2lK+XxZxNinlMO2+ltK\n", + "C0ppgqm2qfacByPlTXa9Xi+827msK78fnvVkORVmeTFPOHDEJ5weDofBDI53ixPQ1wUd+LWK52ed\n", + "Rp6qH4Bvx2QyqVhYcmUt8JzCSBUUFBQUFBQUPAGcGyN1XvblgoKCgoKCgoJl8IVUNvc07LJ0W7vd\n", + "rjjfcsQSaMbJZBJNQcHPZefglK6LmaYpQXGm0ptwObmOnUqWf5lNaIr2VvXy98WuO81GWKVlOQuo\n", + "iZ67aa9z+l4WbGZSqEsB4s3bKqqt3W6H61JRb7E0JLnw6vnKvLm+vh6c9GF+VXWKjUfKNMGmbPVe\n", + "qXc41Y75vJqY9LRIvRcwX3v9ttPi+vXroY8xJmpsFNbX18PcQdCJ6pOtra2kW0Pu+pJC7ntbF6jA\n", + "cyhljlwWp1kbVlmTYsEs/nunVNhjdVDX4XcO4ML7p4JNOOrNR/KyCZzXtGWd+FHOYDBIzruUGZy1\n", + "qs7q+1JX/2LaKygoKCgoKChYEV8YZ/O66/w9aieqQj9VeRziiFMZh06r0Oplk83y39WJIPdUvgoz\n", + "xc9bJl+Qf56vT+wk5euTywLdvn07nDo+/fTTrPp9EZAT+lvHSAHNZrPCTvFcQxADS1kwfK614XBY\n", + "qUu32w2aVx988EFWGxVY/0kxaXDsVHn4GP40i/DiGNjh38tHMFSf8/9z4MZZMFJKzVyBdZ88VmFe\n", + "IAUym83CnMAcarVaUdkOxvr6eni/lSYcytvc3AxMmlJ+r3P0VurUqesU6hK3+zqPx+OVmXOuS+q5\n", + "p2V5+Xlm9TICXK/cPmek9MGAtbW1cN0y0h8A5jnuVe9/LC+m7+N2u13RBxyPx9lK7h7NZlN+j1Pl\n", + "8fjXJS0ujFRBQUFBQUFBwYr4wiib827RszCxE6vfuSs2am1trZKPinehamee60uRYmBUZnguz6s7\n", + "M/hEykJhQJ293p+olgEratfl6vLPi/1/DB988EFgXOpOnbmnUnWfv2cZsVGP2Ik1Z36q32azWTi5\n", + "Qc5hNBqF35D/7Kmnngrzl096rHwda+9oNApM1Le//W0zM/vBD36QrKdqbx0rin+rsHoOsfblsb+j\n", + "kofw4o/LgMtJ5YzjcHCGV3BnVjBX3gRlKF8bFoKtg8+KwHVBm/r9fhYjNZ/Pk2KFHP4OLOsnlFoj\n", + "YmDfJjXuqXUA7el2u6H+nDUAf08J6qq5gTLN9DckR4gyhhiz6sFSAgpsbfGK5QcHBwt+xGaaUePy\n", + "wS43m83wHnOfq/4H46pUwlVd1W885rhXSbyw3ySuA0PcaDTCu6HmEPszq3FS610dzt20pz72p6Hd\n", + "U6rEnrLj35TejEKn06m8pKxRwlApInLQbDZDebyB4qS2dfcDPtVILurMC0CuGe+0kZq5OinLKhXX\n", + "baRytUxyTHucFJTrqT6u+DsWsXa7HeY26nJ4eCjNQmojw383O1YkR7Ji9Xf0d+wj79WEuX+wIex2\n", + "uyEFEHDlypWQkJuBD1VKZ0u9C/5jnWtO9QeabrcrddOuXLliZid9mXKAjQF9denSpZD+iR34/Tit\n", + "YjZCZoNGoxE236dZR9lknHJgf1LO5maLplg8y6/RdUFAQK7D+GnMjPyMXE2w3IPcKu4amGNbW1th\n", + "bvNmqS7gxSw+F9E+3rSpFGA5hxNex/i95rRxZscm6NxvCOYvJ2n2a5bZ4jc81saibF5QUFBQUFBQ\n", + "8ARx7qa9nHDWbrdb2TlynjneJaac5FKUXUw52DMcMWbCn+R597qswjn3Sa5SLecsVMmIl8VpmZzU\n", + "PeoZdacjr8wca5tnGlQS39x6zufz7D7M6Qees6xOjOfh1Kj6YDKZVMLn2SzEQRG4X+UMrOsD/B2n\n", + "wU6nI98pvENwYn/w4EHoK1aaB1OCYIKDgwMpB+ATUDcajQpDNJvNsh28c9rI7agzKXNd/LpT16do\n", + "G7+jrDDuwetdLmAi//jjj0Ofs3M7m1ZjaDablbbFrgerwMhZExQzNJ/PJSOpWGWVQQBzEH2mAlfU\n", + "ms8K9ylTHNcZOTwfPnxYMffxvak5wX9T7iFqvVrFSR/1+eyzz8I798wzz5jZMbvj14nDw8PKvIuZ\n", + "MH1AiWLH2Omf24H+8rlNcQ/qjncO/93a2lpIiJ6CMoP6tnW73coaOZ/PK245Od+NwkgVFBQUFBQU\n", + "FKyIc2ekUsAOMmajTZ0m1a4eu+NOp7OQ2y12HTu8qbKxc+XTky/XI8cJse6kwScDXJfKi7cKlD9C\n", + "rA655Xk2ie3vuSfw1HXqVDedTitMY90JQznJ1jnZ5/aHH/fDw8MFXwaUoXxx/L3K+dvspH0p59T3\n", + "33/fLl26ZGYW/JiYlUVI/M2bN0PZOA3yvIO/04ULF8Lf8dzRaFSRbNjf3w++Xvwu+Dp3Op2Kv+N8\n", + "Pg/zHCdsJQmxCgaDgWRflJSEd8TOZTofPHgQmCPcq97bXAa70WhUHIsPDw8Da8fICTxhxq+OkYIE\n", + "w2mQ8jE00/3g2zGbzQKzyeyseg89662EIxV6vV5gQPEs9mPluqV8M1NrBK+3SvYn6psj+kMB9eb6\n", + "g6XE+1Xnc8XvgP/exb4XXj5IMZJHR0eBGeL8qf663d3dcB3Whr29vUq/8bjim7O2tlZ55zh/Lffv\n", + "KpacL/RGKoXYxz3lpY+OrFuo6qLVfBSgQqfTqWhVDYfDiukp9jH2arKsfaUSip6lKjeQE7EYg1oA\n", + "vHnuNOUph2HWAuMIndQHr87JMHeDtKwjPZeL+mHzsr6+Lk0xqY1gzERktjhPOckodF+4DP+MO3fu\n", + "hLmIjddoNAobPVz38OHD0A5eDJWZ0psKm81muAcLPWvG8AcQz8MG6rR6Puij9fX14KQN9Pt9+WHM\n", + "CR5R9drb27Pnn3/ezE42r2rcYto2fo5x1BHfqzY/OZF8eE6sDkC73a481yzvHeD2Yh0Yj8eVOtcd\n", + "JvmAg01OXfQcR/D567g89fEHUgmtOZmv6j9+Xsp8x87karOpwJuJnG/BbDaTm3j1DF/X2HcvZ32d\n", + "zWbym4X5if8OBoOFZOX4r7+O3wH+L/6Oe/f29kLbsAk7ODgIdcbBoN/vB9Mw2plzCCmmvYKCgoKC\n", + "goKCFfELw0jlUpgA61KpHXpOOH2n05EaFinHaMUCpBxV+aTB9fS7/hgDp+QN/IlqFdSF6J6GoVGn\n", + "OqWenmKDuH4pU9wquQrZFHgWCtgKilkDRqNRUm5B/abahDnEYchKL4WR0ueB8/LVq1fDeIENYEf6\n", + "Oo0d9UwwXGCmdnd3K0rE7XY7qS1zGigWp9VqyVN7zjNj7IHX/YrNL5gAU3nwJpNJWG+4Tmru5EqU\n", + "5DBSUHpeBblrCLtu1JUD8NqrAotyctWp9/Hx48eVdX19fT2Y4u/evRuuBdvBavGKgfHPYOXt2HW+\n", + "zWxi98/ie/k7lnrnmS3iv+EeVkf3DvZ1ayWbjBXD41nqumASfn8w39m0y7p6ZsfzGe3gZ+E3jNej\n", + "R4/CGHpGLFmf2isKCgoKCgoKCgokvpCMFOe/AxT74EOIlVwB/4Yd9Xg8rjA5aqc+Ho/DPXBym81m\n", + "Fbao3W6Hv6tQcWWTV6wHi5ylwpRTDNFZsSjLsE/Lgk8TOKmwc3Uui6H+DSh/BPU3xiqSDqfFbDar\n", + "hOC2Wq1sVmFZvxTGnTt3zMzsxRdfNDOzl156KfyNmUJ/ov7444+lj4y/l+un/M6YwfIMAoem1zkF\n", + "r6LgD+BdPjw8DH5pzLZ5Vmw6nWb5oCgmtNFo2Icffmhmi4EFqfvr3mXv99ntdlf2l+Rca2Ddm81m\n", + "Zb1bRo0d4Hcr56Qfa0OqP3hN9/3a6XRCm8B2xPwKFWvo2zsajWQf+PU/VwiU678KlPo7MB6PpRUF\n", + "31n0lXpvFbM6nU6DPAqzQV7wejqdVt5rnp/sBwwGFnV4+PBhUiiU66mYOmCVb+EqeQa/kBup3JdU\n", + "6ZEAbN7yTnwxxVUAH7bRaBSegUX26Ogo/BsTcTAYBMViBaVbo/7mtTk8W6LZwAAAIABJREFUlDnA\n", + "f9BWfRmVMvdpy4iBtZRSDpR1UT258BvVmPlQOUb6D+mTMPWx6crsePxT5uM6s5Df+PCcwMaV1YTf\n", + "f/99MzO7du3awsYCz1Lvo5pn/nDS6/Vkegn/PvLHBovYpUuXKhGdKlIq1Q/LgAM81PuHv+W+X4PB\n", + "IDjOc7AJUGcuyFFQZ1V0fPw3NjaSZhHMscFgIJ/Bax+Xy2g2mxVNszqc5uO2bLStWh9Z0yilqXV0\n", + "dBQ+6gg+UOuF2UnAQ0p3LuZakFpvY+1NHV4A/t7VRUByIJNZWuGcwRs1RRKodwR9rYJnNjY2Kk7k\n", + "ue4XZnnfndygFO5jNZ9iKKa9goKCgoKCgoIV8YVkpICULgU7IzJrkGJUeOftT5iz2SzQlcrBlE95\n", + "fnedq2WTqzPSaDQWGDBcrxwUlclzFfbmLMxZuRIG3A52ykQZqzi3m9WbNZVJIddp/kma+zDf2Hzs\n", + "tcrMTuqNuZsbcMGmGMxjPqFhDHZ3dytOmpcvXw7sA96VOkdQ/H1rayuccnMlG4AHDx7Yzs7OQv1i\n", + "ARd1+jcpcF/myH3UheUDm5ubod8U85EqI1dHjseQfwMDlpI8UCZbdjZO5TxkKYHPA7nvXoolNauy\n", + "Mr1eb0GCAdeAiUpJFGxsbFQSGPM3SQUzsZk7tf6flmFFOfiezedz+U3zGop1lhq+z2dUWFtbqwS0\n", + "dLvdpHUJz42xr6lMGAy/ZrVarYrjPucq9d8cxqoWncJIFRQUFBQUFBSsiMb88/SsxUNXOEE+KUdg\n", + "nMAajUatarZ/fl2dcuuc8sNhvx5fHtvDY0g5DX7eUH4/KUFRdSJkm7xqm+8P5cwfE4XzyJVi8Pfg\n", + "Gav2uQqF3tjYqPilsEN2rBzURfW9+k2dpL0Plxo/9f6sra2FUyAEKBXbkho/My0potrJeRVz1wk+\n", + "zXrH2GazGXzK2AE5x4fzueees7feemvhN24n96Wf5zyuqm9wfbfbDeXcvHnTzE6U5s2OHXb5Pt9u\n", + "z7a2Wq0gP4FTe4w58fcuM9dPk/tyVX+YXCZRMcCqLs8//3z4O3wMc9mMVqtV6T81Ho1GIxlIU9fn\n", + "aAuLQ6eCmFL1NVsUCo2xw1w/rgO/W5yP1izfN6vT6SSDMJS1Cmg2m4Ghg7Vnd3dXzhPAW0RSc+gL\n", + "bdqrW2BzwJNImcGUzggGmhfMVMQUvwS8SKh7OCkrnuHrxZsmpS3C9fXPZTwpDaRVoSIlmQbGNV4r\n", + "yExvuFJKxkoPhxeCnKjNOtPiWWzu1cupNmEq2e9wOExuCNm0pxYr9RvK4cUT9VNq8Tx+fsNzdHRU\n", + "od1jm7ocPazYQrbsPOcsAf6/vlwsvvgA5Zq01HikIklRL3+duofNb1Cbxwbo9ddfD/2rnNy5bR6N\n", + "RiOYWVJz+rSHWfVsv7nKDQhhsLK1Xz85HQiPIfoIzz86Oqo4dfPGB337xhtvhE12av6pOZsbkbhM\n", + "P6v3h82+aDv+y1kg+Ln4PimTPG+A/GFiMBhU3g0eL1Uvrrs/APF3m1P6YA3EdUoTijXteOMFlwPc\n", + "02w2K++h0hbL2SAX015BQUFBQUFBwYr4QjNSqROcOrXP5/PKqa6ONuSTEP6tcpOlQmt5x6p2r7iu\n", + "1+sFpz9lIuT/T1GXSkFamb9ywmXPEnUMTY6jvTqNM4OkyuNxyDk9LOvEnlPOquXlmiuU/pJqr2KL\n", + "Njc3k6aaOkVoVRfPKo1Go4V5bnbMhLDjuZl2LJ3P55K58uA1IFa/3P7PZRNVvr8c1AWgKNOpYmK5\n", + "nt7MyKwCn8xRR7BUMXMO2gSogJbPCylzlWKpADbdK7kPBszMWN9Ho1EYh2vXrpnZokq5si5wX6qg\n", + "C2Z8lsFZ5UpVVhzWaeO/q75G+1ij0fcrMzno+4ODg/DeA5yMHHONsxNwwmPffu5nldwcf+f1jt/R\n", + "nO+Fmu+z2axielS5YT0KI1VQUFBQUFBQsCK+0IwUwAxNnd9Uzs6+3W6HXSY762KHzCdq70vDjqAc\n", + "Wunr12w2K+GgfILhE7g/idY5eKKenIVdMQmft4N5zKnVTPuMsVMo28iVOr0H90dqzFWI+Gl9PM46\n", + "8KHO/87suP/AcoBpUKzHdDoNzAXm297eXkVOg4ETunJeV5ISPEb+2WZW8Sviupgt+lrhPu+bpTCd\n", + "Tissitny83yZ0z/qCtauTvoBqBOs5FO0Z7mY8WPmyvv/8W+qXsqfi/1Ac/zEPg/kBnUoRkpZLWLt\n", + "YGd+/BffAWai/PxoNBph/HFvLGQ/Z61R34vTMlKKxVTfSuWQrSwrPHd8vzJrw32N9121HWvMbDar\n", + "zMtms1mRdOHAEa6Xn+e8DuE94jVLsU+8tvpnzOdVUdUcnNtGyr8UatC5E3KiRHhy8IKBDmbnOv/B\n", + "4PqkdF+Ojo4qE2UymVQGZDqdho+XpzJRB/6vagv3wWQyqURATCaTz1XPZRl4R0alKTKbzcICBZNn\n", + "rpaJ+pizeRbPXUYzytedzW5chlr0c5Jgxw4BqUUX7RgMBmERURsoLgPXqYSdCjB5qP6Ltc3ryMzn\n", + "8zCW2EQonTN+z5TJhg8nqi9zTWtnBe/wmgsVZcu6WsrEr6A+RtwvUOFG5Bgjlfg61wxuVg2QqdPc\n", + "WlZ5n8dfuS1wub7M7e3tYNasi0jFe6M2DqnI0Pl8Hn6HCXAwGNhHH30k24d7YuDvRV30W050sb9X\n", + "bUC8+bPdblfWz62trfB3fAObzWZ4/7GJPDg4SEYL17Xdg6OoeY3klGlcJ38voMyWHLHtfzvLg0Mx\n", + "7RUUFBQUFBQUrIhzY6S86YIZJ7WjBpilUrpKOD2hjMPDw6xd/Xw+t2eeeSbcY3asyeI1NObzeXCc\n", + "ZcVn71Q3m80qO+hOpxPKY10aRVf7XbPS6VHodDqhPHb+O2tzVK5jOaBOerPZrOIAGjv5e1ZkMBiE\n", + "PuSTRc4po05TJuWMrjR0uF4pzOdzeVL2813Vbzgc2lNPPWVmFhLfMnvHemOoC/cFJwM2WzTx4USv\n", + "wsbn83kYI5Sxt7dXCQdXDp5KEVqZshX4bym2b5mksKsA72tu9gKA8+Bhvbhy5Yq9+eabC9epNl26\n", + "dCloQDGUOjXMuJ9++mnlb2xmWiaUm8FmF5WgVsGvmWaL7hLKnAKk5oSqO9eF64m6grHjwIdYOWbH\n", + "7CzeB24jykbbtre3g2bXKvMvlaUiFzFTZ530Bt9vdlL/3d3diqtIo9EI/Yb/bmxshHmHOc6mOLge\n", + "bG1thfdGzWcGxgvveixzCcDWHqXCryxEKYCR5Hvx28WLF5P3mhVGqqCgoKCgoKBgZZyrj5TZIuNi\n", + "pjNLq5N1DMqOmlLNhmPswcGBvffee2ZmgZmK3YtQcs4SnqPSyiclgMPaeUftWbSY06KvH1+nxMpy\n", + "FX7rsIq/kRpP5LWK3WOm/aa2trakg62/N9ZeX5fc7ODsC6RkMlLCmMw0Msvi/fqYWeUTHxgJnPiO\n", + "jo4kW+N/4z5IhfJygAQD8x257/jUziyA93fr9/sVFiX39K4cX/m5fN3ly5ezylwFq74r3I+of13b\n", + "wTju7OwEJfgUmJVlxu80wo4KLBeQU6aaQ2ptYxbCB+YoqGdyQBCXj9/U+pKCWjPNTtr+zjvvmNmx\n", + "r5R/b9l/kqHWd7+GxBg+nxPW/035KqaeC7DPLdclxSoDe3t78nvtrSgfffRRxT+Z6wKmu91uhzUm\n", + "1y+Slf+9LxU7jPO6jH9zoBezrKgLgICCWGAB41xTxOTSmXWRejzZVDqQXHizx/Xr15MOhVeuXDGz\n", + "4/QX6jkYOJTLLykPmP+4NhqNyoaQ1Wn5Pv8yc3kq2nGZjVRdBE3sbzH4MVEaILljePXq1bBIphSy\n", + "Y9oz3jynovti7ctpu3JUV5u1tbW10AdqwVB9wJFtyvSY+hjh3l/5lV+xl156qXJv6v3i+vl3ZX19\n", + "veKAyjpHKPfKlSsLaUw8UhGJZicHH9TFBxPg7yln2DrUBQ7kbpo91MaS8c1vftPMzO7fvx8+2IA6\n", + "TFy4cCGYHbzJsA69Xm+ldCEevIHDPFFmfD4Y4APqN8WMTqezoDMEpBLLcySZ1yVTddra2kp+JOs2\n", + "SOp6v1blvlO8NvD8SyVOVg7UMaTmLMaj1WplbRrUOqbafunSpTBecEfgdZG1pVhZ3iw/g4ACK9Gr\n", + "fuENlw+GURv+Vqtlw+Ew+e0spr2CgoKCgoKCghXxhU5arPLesLoz/r7syWptba3ikMvl4fSiukYx\n", + "CE8//bTdu3dv4TeVLLfdbof659a57nSc6/S9iqZULuuUYoFUGUpNnmUSlPOgP4nGZBLUCc7XQZ1Y\n", + "FAuVe8KMmVOQB40dgVMUN6CYy9j4exMBa6OkTnXb29uB/fnggw8qf3/66afN7Jie91pfMdVxOFXD\n", + "sVSN0cbGRmg72qmYmu3t7UD3q/kCMFswn8+D+RH3MpYNJWecdbCGwvPPP29mZm+99VblOSpp9ebm\n", + "Zsg9xjpICp4BqWNjcpHLSKlciz4kn7G+vh7mBM83rAO4Rz2LGRNcv7a2FhhsOEpPp1P72te+ZmYn\n", + "DOj7778fXAaYxU+9U/yOrjpPclhwz5ooqQCWEgC4fzmXXp30Qk59U/n36oC5e/nyZbtz585Cea1W\n", + "KxkcAJwVs1oHMGmFkSooKCgoKCgoOGOcGyMF++6yfgYp8E6cVVuXPYFyCCbKxOmo1+tlO4/m+GnF\n", + "/MTU6TmVbzDmZHgaRsqX55+Tqn8dEwUsyxKwn1hKuVnVifNgKd8ioM5hM4eBY/VfdsL2obxcT7Ap\n", + "+/v7C1nL/TO8cjm3LeZXodqRIyL64osv2ssvv7xwr2JHuF4sHHnz5k0zs3DiNDs5FaO80WgkHfhV\n", + "OwFcP5lMFvwclCI4UPc+pkQZU38zqyqy93q9irih2ckpnPsv9Q5gjAaDQYVB2traCuPKDJzqNzyX\n", + "GcIU854LnvfLrtvsgwSfO2YmVUCI92lhR3W+z8vRTCaT8AyUu7+/H/6O37a3t8N4cZ+C2cK8Go/H\n", + "WRkY6qDEN5ktV3Mjd00/DYuqHLdzwb5FagxzswPk+jmn8ngyvP/kMv1Sx0id20YqVqk6Z2h2VMe/\n", + "V1k0FbDowxm2Ts0Yz9/c3AzUMBbcs6Ibub0pBzrAbxzPYiPFdWEqv64uHv5jtLOzU9EXYZNOrA5m\n", + "x1Q9m/nMtDYT17FOTVhtrlIRf758s0VlZqXJBKQ2Mb1er6Krwh9wdqpN6dH4yD8P9VHnSNScugJs\n", + "LsWCtb+/H/oDZsSHDx9WdIbYLJRyElc0Ps935eCfi8FgsBAh6bFs0mJWoldQ/Qysr6+HvkSfqw3c\n", + "xYsXwzPQl6PRKJiKWeHeJzzOjYRWByXeNHKAxrKRY/wMtRlR885vXnq9XlZggWoHmwB5fHMPd6zd\n", + "Fru+bg3hduduzJZd0xXB4OsYe15dQBje9X6/X4nGPDw8DGsQ1urxeLxAVJgtzm02++Z873xdc65X\n", + "h7A6FNNeQUFBQUFBQcETwrk6m7MTXyqMvw51Zg2PujBkgE17OL3n6pLEdIm8/gYrUfNzvRN07LTg\n", + "6WAuS8kfrIK6k2bK1FV3uvOKwXWnSyWTkGJelGm3jvXMPZGmWAplZooxeqnnMYvnTTadTkc67Prx\n", + "YCZHvR8vvviimdmCHALq1O125buSCkNnZWCMpxojDlHPcWiPlQOchpFaX1+v5Chk+YZUGLqCSgDN\n", + "eO6558zs2LHc4+LFi6Hs1Hqzvb0d2ERO5uwTLXO/8HilnJJTYPaJXSi8Q3ZdGDpD9a/6zbNUnMOz\n", + "7r31itUxHTZup9kxc54aB17LU5pWCqrOpwkgin072K0hVbaqjw8OYNmAXMCsalZd4zkbR651idcn\n", + "3yb+NgAxiwPWEzxX7SHwHS2MVEFBQUFBQUHBE8AXWv6A4ZkXdqQGYuHq2HXyThg7ZJxs5/N58pQN\n", + "dDqdsLvH84+Ojlb2D0CZZmn/Cw5rV9mr8SzeoU8mkwoDkuuXtoxwp68DP4fZxxyWjeuK6+vC49Up\n", + "qi4kOeWQXSdyV+drhb95Rornp8p5V+fThLJ5PvO4+3tZ+E7l3/NQLMr6+npgwlJCmniOf4Y/jSs/\n", + "p3a7Heqv/IoUa8BMnWKQ+N4U44s6M5uA+cS+G8v6VfR6PenMjb5EYAE74QP9fr8i4st1wfh3Op3A\n", + "SOF6VrtGP29sbEihQ7QJ7YmxAcpnx8+306zp7A+DcsfjsVwfctjidrsd+igl+pkLJTOg1hqzah8y\n", + "e1c3b1LrIrPPSjg4tw3MDPF3wtevbk1V9VP593J9ClE2+1Qty3oB6+vrMncrO8Hjb+hrXgeUP+IX\n", + "1tncLF/ZPHZdymFvWY0M9YyLFy+GScGJXRVdjefyIPmJzhS7eiEBjk5ZxrFctcknfsxF3dikNo78\n", + "u7qOX1KvQDyf66SbHsqZN6Ytpeq87OYqtgEF/N/5GWqDhL/1+/1KO+rS1dRFs/mFoNFoyKgogHXO\n", + "UhpAvIFLbbw5FYOn7LvdbvhNjRXqORqNKvNPRQtymiSOYuWE3f5jz5sNb/Lg9irzBh9OAPUext5N\n", + "tYH2aDabwRldpc5ARoWHDx9WzHhra2uVSL6tra3Qb9ynuCeV2FV9lFqtVugPzCeVropRF5nonb5V\n", + "PzP4XfWaRiroRK1l6l2pO+ykEDPn5q4rqbWm1WpVvgm8/iiXhxSazWboL+5zf8iJBRukxhqEBNcV\n", + "v/V6vTAX8Sye25wNxGuFKfKEVdF5LHMPxQpqHIqzeUFBQUFBQUHBE8IvrGmPVY7VrlPpm7Az5LL6\n", + "RWx+4xM8nrGq3EGK1VgGMYfHlGPisjojp6krs0U8lqnw/RSUiSimb1R30jPTeeHq7k2BGSk+2fry\n", + "+KTJZljPiii2VfVBnUk2ZT5kkxI71/rcaHXBBPy+KTOZuielm8bzISV1wWMIbZmDg4MKu1cXDl7n\n", + "gLzsXFBO9XVQbAjqde3aNTM7yV9mdtKmfr8frgNj2W63A3PE64FvJzsl47derxfuYfV8P66cLSLV\n", + "p0rDjRmOHKkNRmxN8vpQZvmSNChTmR5TY9/tditmN6UqruqhWOgYM83rhK9Pp9PJDtwBuL3of77X\n", + "9wdfp9TngRhzxfItsXuXgWIkcy0Ovk7z+YmeF8oYDoeFkSooKCgoKCgoeFL4wjBSKRuvOrXXla2E\n", + "EVN+LjEWYhXhSTPNrMQcNxVSJzN2fAViTtNeVqLOT2tVBiYHvi9ZVFWdXFJ9r2Qy6mz3dW1bdp6k\n", + "/q5C8ZfJC5WSC+D+U++Kn2NqbitFaF+O2fG4sM8TfsuZx8z8KGZq2aCDOjYoxgIqqPcLdcTfTiOq\n", + "q6QuzPLWkUajIYMHwESh3I8//rhyLwcHsIO58o1TLKBScFeBOQC30fso1YlgqkCU3PWW64464946\n", + "JiblYxgDf59y6resv6VZvXo+gPv7/X6lrdznPiiK/53bv8zGKdS1yTODn0dePM4qwPXza1bsu8Lf\n", + "E7PjcTk4OEiuP2356+cENvekFvXYR9ZPlPn8RM6eF8i6xRdQC0uOwzUvBKrcXIc3jnpSNK+n2GN1\n", + "8hslX5/URDrNBqrupfJOkuwoqsBmCPw7tcHkjz6/SD4yI9Z/ufMEUC8pwyuHs3N9nbkKCw5HkuIe\n", + "b2pjTKfTyiaM+wD/rTNp89+VM3LKTMGHGa/MzXpNqs+4XPVOqcha1lDyGzZuuwo24N9yzPxs1uLx\n", + "UibbnEjJGNhUZ3a8OUA5qY1Co9Go9FEsGk/pq6m65tR/Pp9X1vC69SV1kON/c58qp342Ofoy+Hk+\n", + "SpFRt3ahbbluKeq6OpcBX3//bfJtVzpY3LZc86jSIOMDeM66GDss8KYaz/Lfw9x3T6HRqGpRDofD\n", + "ShCJWm+VqV25B2VpTq5U+4KCgoKCgoKCgvM37XFIslk9rbkKcBIBYiHeKqzUO7k3GlUlctxvlm+G\n", + "AF0+Ho9rJQy4XF8nT+N6Z05/Go/VK1dZ2J+WYs7hKZOpYqQU+8RQwQYKqfKY7fBs5jLO5jnmT3Za\n", + "xNweDodLh+WyqcqfjFjTLGW6idHzygyeC6/JEnunkGMvlT9RYX19PakBpBix+Xy+cLo2i7cptSak\n", + "zJ87OzvhmamT6ipO6UCv16uwSsPhMPQlnq/6vNfr2Y0bN8zM7N69e5V6spnWt03Jh9QFFqhgFiVN\n", + "wHNRrbM5jHNdnzKzmyNdwGbwlIvBk4BfW1UwTqwuqs/V+s+WCc8cLcMCoV/Z9KjmSaye3Ca+VuXI\n", + "VCxlnWkc93IydNQv9T1uNpuVBOqx+VKczQsKCgoKCgoKnhDOnZHyYIEtVI0dxtWOVDmqs2+BbyKH\n", + "/rINN9cRXLUn557YrtjngFInXXbSzK0f+zzkyh+k/L5QX7N63zHV58pXRYFPr/46pWidUuRVzq1c\n", + "Hp9icxgzVQ77pXGdfZ8rhfZY3kfl55R6BxRDw4rLPh8V+1zUBVek/M5SecbMqv5c3W7XLl68aGZm\n", + "H330UeV6Rsr5VqlJMyNVx65hfUA7lVgq+zkBly5dsgcPHiTLXhVgUQaDQehLMHkqs4H/N+p869Yt\n", + "MzPb3d01M7NPP/003MtMzbK+W2qdVewIwGw1swq+7jwX6wSVV2FPc8CWEe9zxVI7dX3Gyuxm+Wt1\n", + "TOpAsXvcp778GKvo+382m1WClqbTaUVhfD6fL+WUf1osG5gRw/b2tpnZguxHKiMJM2IqEwIsFrHx\n", + "PLeNFJw2vfNr3cd1WedQRU3zc1ahdNlxzqw+EkG9DLmmHUbKbBWbgKmFLrWhWSZSElDtTNU1tlFT\n", + "G1r/gZzP57UpVQBfF160ltWtUVEdau4oh2ZWMedNAl56/I0XQugh4aPI2NraqvxetyDzfPdtV475\n", + "uUrJ6lm8scFzh8OhPfXUU2Z2srl6+PBhpQzVjsFgED5yMX2d2AfdTJuo+W9+nVAm0Tr1/NMAG8zZ\n", + "bBYCFNTYAEpJu9ls2s2bN83sZG6/88474e9QTI8l4U29D/wh8us1Z2NY5qAH5NxTpzHH6zsCPdCO\n", + "8XicdBtJ6Vzl1MtsMS2USk3Cm8UUIaDmF9+D+nW73aXnoloz63TVfP1V1oDTgAOpVjGtel3H3Mjg\n", + "WPACojqxPsGFppj2CgoKCgoKCgqeAL5wpj2zk9M6nxLUztfnaZtMJtlO0wCfspQjs6JEVXuWZZjU\n", + "aQztZidyNs2lTDoqQaoy7cV21SrnWMpBWZm6lKNgirVZxlFd/S1VdsrZlE/ydexYzniqk02MHQHr\n", + "8Omnn5rZolP15cuXzczs/v37lftiJkBoC8Gx2CyPVcg9eeeaXRT4vQATwmaxb3zjG2Zm9pOf/ETW\n", + "08+DyWQSmAb0hZ+vyrSHBMGK+cI71+l0wjjUJRFPsYRA7txhkx3MoKPRKOnIzmY6b3ZpNpt2/fp1\n", + "MzsxX7755pvh75xYVullpcypWGvG47E07aXeR/Rpq9VKvnspM3On05EMO8Y61+ynshmwq0dqni/L\n", + "3nDb1Xzid9XrtcXmH7OAKDulRK6sN51OpyIN0Gw2w/jnJlOvWxN8UIqS9lGoc4NRZSAYYzqdVt6L\n", + "tbU1qYOGeuG9ePz4ceVvCJAojFRBQUFBQUFBwRPAuTFS8MFhFsbseBeey4SsitzTYi7qnM1TJ7Vc\n", + "NisW6qqcTfm0qE5wuYxPrpJ2jpp4jFHzUE6psRxlqh2pEzVf7+9V7Yg5qvvxjDFSYEKWDf2/cOFC\n", + "OFGllM0ZOI3xiUq1g+H7KuYz4JnaVUL7MWc3Nzcr/jm3b98OTJWqPytX46TMTCz71HGQCaCUrP2p\n", + "vdfrSbkFNce80KpC3RrDfh2eiWDxVQWwEPP5XDrGwgcNjMbDhw8rzOza2lroQ56fqWAN1Y8pRirm\n", + "bH4aqYEcf6NutxvmNNo4mUxWZlZzHMH52WaL649n+1OBK2bHAQ1mx35sKVHTRuNEfJXZE4x1bvty\n", + "pCLqUJelog6+H3L94ZQf48bGhmSsc1TW1Vjj2/WFdDaHc6LvLFXZ7e3tsMDi+pijpaL+lAnQ062n\n", + "TS+yKmIbKdD8aGOsbin9jljUXo4jeCwKa1mkTK3cl2rDp5zNmY5OLVCMZR3K1WKYE71ntmhe8Kkr\n", + "hsOh7A9fv8uXLwfzHtrNiWdTGAwG4UPHWkSpyLvcBN5c97rDgdlxv/hNR8xZG+YyXKcW0e3tbbkp\n", + "5T5XJmplWvE6TTHTqZoL/rfY4ptaK9CXvV6vYp6JOUWjXzkyTPUTTHso7/DwMNSFy8ZGH/NFRcLy\n", + "OsvP9R9NNrupOcZAcAVMoyo6Mhe8aQJOExBwVodstY7lrq0qPRP/2x/uUv/Gc33/qj5qt9thU6VS\n", + "J6mk5fxM/1xuZ6p+uVp6des7rltfXw/fT+wb2AzPgWv+26GiYxuNRlAOKKa9goKCgoKCgoIzxhfG\n", + "2ZxPkl7qIHaS9MwGm10U26GYg9SJ2t/j/1534lxW8ZuZCbXjTzmJxxyLvVpuzLGzLkzULN5XqT6q\n", + "M1uq3T+Qa3oE6pgSdppUcwfIZWi4Tr6u3KfMYOA3nPyU6vR0Og0h7Hfu3Al/h6M6TlnMDHhdNN/u\n", + "VJjysu1VUMwAg5mpK1eumJnZJ598UrmO32/l5Ipy8Bu3l99/Pv2n2AmlR+Xbxc+Zz+dZDGe73U4y\n", + "pSyJgfJSzutmi0lUzeJq9nDsx/M/++wzaZYDI8Xq6aqeSrbEB5aw4jveZZ6fioHFWO/t7SXXHRUE\n", + "9P+x92UxtmbXWevMp8ZbVXe+PfimY7uhnbgbMHFEAgkKAfGAEykKUh7yQMILeULwZonIeSDxWxSi\n", + "ICEBUp5IJCTEA6IZMxEbkBNb2N3BduKhp9u37zzUfKoOD8W36zvr//bwn6rqaif7k1q3+vzDnve/\n", + "11rfWouhLA7KVOS1aJ1OM75SLMPBvIhpK32/sEWkNLI5zzEFrJWdnZ2gBQTu3buXJMHzvEd5WI+D\n", + "waBhOlPzhKklAFNPfHtK0NYsm4onifqY6UTl3D/Yz6tGqqKioqKioqLilPGB0Ui1hcqNNxwOk5L3\n", + "vPnkYr/lcBLNlX8H11WFF+CTdYwMmirD34dorv7ZVFtShGz1jpjka0iCAAAgAElEQVSt3dclRnxH\n", + "GbEAdny/mY6KrjRSOe1cieaG64z3rKysBG2SkgahIdjf3w98BEUEzWltPIcnpy0CYtySEndwlRuL\n", + "JVKus492rviOufIV4Xs6nTby0Zk1M9CrOWEWzxfIKA2TUUrIX15eDvNNEe25DCbGm2my+2AwCH2A\n", + "Pr93717goCHsxnQ6bcyTUo3keDwO9+JZxZHhNaCIyBxZW2l0AX5vaYgDr6k1a+4TMRJ5KdQ+oTTs\n", + "ao/ze/ny8nIYT6XxVJktTvId5bArmCeDwUBqRUvI6N1ut8FPVETwGFJ7bkrD1QbYc5UDBM9FdYbI\n", + "aaSyB6mf+Zmfsf/wH/6DXblyxb785S+bmdlnPvMZ+5f/8l8GFf0v/uIv2t/+23/bzMx+6Zd+yf71\n", + "v/7X1uv17J/9s39mf/Nv/s1moZ2Ojcdj6aHH6ko2D3mPC467URq3iMs/qyTJvAhKD2n+2mg0Coue\n", + "2wGVPRZUauMFUE4qdQbI/2bx2CUx5Ly62i4C5ekT+3j5Q0QsrUmJ+UtBHf5KPeCm02nYgFQU4dT8\n", + "jCXsTXmL4XAS2whKosD3er1sDBuzdh8gjrtjpg9cPG6eBG52HF/ryZMnof6KhM/kdrxTmb9UdPpu\n", + "9ziJ7zxCU1vzKMeOQl1SSZo5dRbmsUrd0e/3gwmYTWfoB+6rFJQXKMpdX18PnpfcZ6rf8AyvvbYm\n", + "ZCV0KFOl8mZMefGeFnjs5y1PCWj+gO4PX/1+P4wTytvd3W0kSx8OhzOOB4A6sKEMtGN3d7cxV5aW\n", + "lsJYnEa/qgMKx5Hjg5kSgP3+znsOO3KgzqUZMRgnNu39vb/39+zVV1+d+a3T6dg/+kf/yL74xS/a\n", + "F7/4xXCIev311+03f/M37fXXX7dXX33Vfu7nfu5UwwxUVFRUVFRUVHyQ0M/d8Ff/6l+dydUEqJPZ\n", + "v//3/95+6qd+ygaDgd28edM+/OEP2//+3//bvv/7v79x787OjowwnTvhqphG3jWe0el0Zk7XqDtO\n", + "p7koxikoKZRP917qZVUnS2roA1yLRZWFFMiSoSeKsiaE35PK2cUSXK6dXuo8ODiYiVpsNtuXJeEX\n", + "+FlGKhL9ZDIJbWfnBKX6R3lcP5+wM5Yf0Nch1k9q3kJqxnsV4VGZ+zY3Nxtj2Ov1giYK7VhYWAi/\n", + "sTYDSWvffPPN8FtqfrPkV2JmVuFDYvdjbaC/l5aWgvkA7zA7nr8Y09XV1dAvHOndRylfW1ubkbLR\n", + "Xz4COmM0GjXIsir3YAxKywaNYI4wDmAexOLmAWqt5PZItB0Yj8cy0bJ/N2tCeWwUITuW6zBWBv/b\n", + "VuOn9nXWRHlNM48PJyD2c5vzAyoyPDsLpLTjKmwNTKkqS4FKGH54eBg0iKrcyWTSKPvg4GAmqTV+\n", + "82bXmKbT5xsdj8dhP+GQF9jHsOY2NzcbOTR5LFWeTrW2+Lvo36Pm12g0khk8eC3xv9wOBvaabrcb\n", + "tLfox/39/bnOBHOTzX/1V3/VXn75ZfvZn/3Z0MHvvPOOPfvss+GeZ5991t5+++15i6ioqKioqKio\n", + "+EAjq5FS+Af/4B/Yz//8z5uZ2T/5J//E/vE//sf2r/7Vv5L3pghxfFrk07Y/ETJZVrnT5giyOIGy\n", + "7Rhl87Pe/poLFKdcPzlSu+I5AXjvZDIJWid27faRrRcWFkL9IGE8ePBAhnvwAfRQR9yXIoAq5Dhe\n", + "vv9VcENFQDdrZu7O2a2VZo3HIRWBmCVrJdV7CVlJSoycZA0NIngMh4eHjXIVKZrnJzAajUI78czT\n", + "p09n+EO4Bk0Uk7q9NMsSuiLLKpdz1qaWkNIVF3EwGEh+i+eWxDQ7ENqwZu7cuTOTjV5lqPdQ/Mrh\n", + "cCh5GphP3DY8Aw3C7u5uK76F2XFfKg4Kl6ecIVJgjhSI5bHI+pgfGEtug9LkYb4rblYMSkvgnQ1Q\n", + "by6DtRlKC8T8Q08iPjg4aHC81Dtie7vP3deG04W+4T3Wj93BwYHcg3GfiorO65/h90Cz5vfTZ7vA\n", + "PbiO9j59+nQm3yP+xd/o0/39/bA/MffWa4a4fal92dcfdfa/xdYYuMM8z7EGMMc4XBI7IGCN4LfB\n", + "YBDq2oZLNddB6sqVK+Hvv//3/779nb/zd8zM7JlnnpkxJ7z11lshXYGHn2Bcad+BPLEUkVFNJr4H\n", + "HcNqfAVvhlLxSGLAfSoCMt4bW7gYqNSA7e7uyo+hJ+FzeTnVJD+rPOW8OlaRdA8ODhoTjk2AAJMC\n", + "uf5437wfIrzHLB9bJJVupdTLKlaHFNBXPDf4N3+IgCMG15M/Xkghce/evWA6gMmLU2GkyMsxz1Vv\n", + "clAbGh8wgel02lg/bNpjsyWADfDBgwdJc5VStXP91dzJffx8klJOWqzKSMWEGwwGrecvoObQ4uJi\n", + "eDfqxAJQrq+82ZrbxQcQ7wXGB0wmkftxzfWt2jNZwMRHmGP8oC6oX8z8DjCVAYe+nOeVghdEl5aW\n", + "wpxQ5iNuo1oDvlzeW/3zZrN9qcxQLHB7EyvvWbxG/L6vxotNWPwb5goOVCsrK+GwgT2I5xjPxbZ7\n", + "aur7xKZ2rNXJZCIP8T7llFnTpMqONGo+8Z7lU8h0Oh37zGc+E62r2ZymvVu3boW//92/+3f2vd/7\n", + "vWZm9qlPfcp+4zd+w/b29uyb3/ymff3rX7fv+77v0wVTgLSKioqKioqKig8KcFju9XrZg1RWI/VT\n", + "P/VT9ju/8zt29+5de+655+wXfuEX7Ld/+7ftS1/6knU6Hfuu7/ou+xf/4l+YmdlLL71kf/fv/l17\n", + "6aWXrN/v2z//5/88elhKqe1SBDVIsaPRyG7fvm1ms67QXj16eHiYJI+pJLnKnJGCihnU6/WKXEM5\n", + "tw/ayyYgld8MYHI1u4iqurOU6CXMmCaHE36iTaw+5zYw9vb2ZBwpr5GLkclTKn0l7aYkIFbjsnbE\n", + "zwXWmClJNBczJqW5hDmKTdTKNA0p78mTJzIMAMYDxOErV67Ye++9N1PG4uJi6OdS1+SYZBZrz+Hh\n", + "YUMLyX3PGmL0P8zWLD3ibx4P1W52W/YRzWOxryBZq4jRSsumzEzKuYLbycme54WasysrKw1tknJ8\n", + "UFhZWWloMT1pGVAaEG+KYY1KqYlL7TsqyrsyH7LzkU/6rRIP837G893P/YWFhcYeyQRu1IvDPeSi\n", + "jvu1Esv/6vfbXCgY9d1jpxSg1+uFbxv6cjAYNJLz7uzszJiuUBfUgccBexDmHRPLmarC31z86/v3\n", + "JDGfzI7bz2b+XCYPsyNtGsrGGuC5w5ouH8ONNVfqmxpD9iD1b/7Nv2n89jM/8zPR+z/96U/bpz/9\n", + "6WzBFRUVFRUVFRXf6Ti3yOY+2jIH1fISZixAYYoMmLLh5jgNbfP5MEqiwHqkAi22hQ8L4TVbseEu\n", + "6ctSV21VjpK8S6OE55Cqu+KOcV1PMv1T71BaSubrQaNzeHjYmO+rq6th/njXYwa7A6sAsyqoYqrO\n", + "rPFRHKlUXymXbp5/wOLioiQgq6CpV69eNTMLmmeUY6aD8E4mk/A8+r7X6zXW4ng8nuHYAHBZBxTh\n", + "nceQNRIpLXpKI64cVW7cuBHGjMMWlIRnePnll8N+8vnPf97MjuYY9qVUKA6uK2sXUxoG/La6uhr2\n", + "6FgAXVxj0jLqooC6ol/6/X7jOxCL2p8KjJkaD3aUUftZaq+5cOFCkvPJHDfcl6pnrG1eS55D6T6r\n", + "SOn+ulk+eG1pGBEGj7GZ5korrKyshO/mPLxZgDXsivuWC8h5bgcpP7g+2ajZrBcGSOtoJCdz5fv9\n", + "wK6uroYBVV5CKjIvq2KVWhZIDdZgMGjEuWIPHfba8B+g6XTaiM20t7cXzB747enTp42yfb/6RReL\n", + "Su3bwiYT5fGn1N4M5fHgN7B5UjSkiKzqYB4zb7Yto+34M1mf+8e/Z3FxMcxL9mbz7+b7GEhGCvMH\n", + "E9XZI82bodpE4EY7cv2roDz0MI+91xCD5wZ7s6YIqtPpNMw7tFOZj1ZXV+UhKUVuVkAfsHlemQNK\n", + "o13jgLG2thYIvimHAYUf+qEfsnfffdfMzL761a+G3zkNiFk+3lWuzmqvBFJzjPcLdaBRXmA5KHMw\n", + "6oNre3t7MnmwEu6Ux6p/LxO1c+PqnaJGo1FjLXO/sJexN93xe9grluujkmDjOr6jm5ub4QCi+i3X\n", + "91hnLKh7IYa/5eh7ThifWl/s3csmSrwnJpT4uqOeyvSoYnMxFYQpJrmDVE1aXFFRUVFRUVExJ841\n", + "aXGMKOrvU+a+NmYhuHJCUiqNPlxKfDab30SU08qkJIRutxvI95Aqtra2JKmRpedSdacqu1SjATNJ\n", + "KVEwJwm11TCxtOvLjUkWiiDv7yuNkMzkdZbASs24eAYS9ebmZnhWxf25fv26mR151MKMo0i4LEmW\n", + "9EHsN0DFBFIxdGJaW7QnJaViju/t7YWxVLGRptPjWGUqyj7n4vKmF9basXSfMmHwGHkNQ5s1g/Iw\n", + "vt1uN5hyS/c4aCb/8l/+y/alL33JzI5j5HCfKg3hSaDMTG3NKrE9KfWelKYzl1+RNcXKmcTHeGLz\n", + "JjAYDMK4Yr1xrj04UsTapfaQFIGawx9womO0NdV//B1Qe3DKsYX3CcSsU9HaY9o974gxj1Y7B/8e\n", + "RTPgvQFzZ3t7W/Y51hKHxrh//37VSFVUVFRUVFRUnAXOVSOlflNkzhxJmPlVPpiWAsewKpW8czjJ\n", + "s5AIUPfxeNwI8Lm8vBz6ARLQkydPgsYHQRr39/dDXS5dumSvvfaamc32eUmwTMWH4rpyfsAUeZP7\n", + "pURS5YBobfuSw0GwpFFKfiy5T0m2Kq8f8/WYe+PHUBFtNzY2gjYBGh+zWVd4wC/fj3/84/Z//s//\n", + "MbP0nOR1pvgwXGe/VpRkpoixo9EozAnFqUv1ARPfFZCK6tGjRzMuzimydApra2uNqOndbldqNwDM\n", + "09XVVekMUILhcNjIWr+7u1scugK4efOmmR3tE1/5ylfmqss8YN4Pxjr1SVHaGOb/qbk4jwOP+k54\n", + "zUuMzK34nam9gZ0i1D6q1mEpSZu1Y3jGa0n576WlpYYjRbfbbbRT8QRXV1flfFe8P+YSoazUfo19\n", + "7PDwsFEGc8E4C4l/H3+3eR/FuGLu8DdE5fMEVlZWQjtgIbh165b8jn1gyeY+aikGOrZYfJRwjkAL\n", + "8EBj8g6HwzBwqQ85x6DiD6UyKWKhpdTjvV6vkfZkOByG0PV478OHD0/Fcy2GlIfHPLGRTkLiLk10\n", + "W3qALt2MUvVTBH+OKl5iclALTB1OVV2Gw2H4UPDGdu3aNTOzQBxmcFJQbCKoy/b2dpj7THL1GynX\n", + "GXVaX18PBzggRg5OmYiY4OmT+fL6hilrPB6H9zDx3h+KOSErp4JB/be3txsk2Nh88vfxWsd4TCYT\n", + "mSKG+4brMg8uXrw4k/JnXoBEfP/+/eTh77TBc0glc07tubj/xo0boQ8wT8bjceNwGnO4SKF0jHLp\n", + "QDgdkNl8Ht0Ar715PMTx7MrKSmgfhKyYEOhTJu3u7oY4XaiDX/seSIb+1ltvNfa7hYWFhoOH6nN2\n", + "/mKnGOXUhT0G19ocpE8blWxeUVFRUVFRUXFG+MCY9tiN08c+ysUv4vfiVIwylpeXw8kXJ2XWPgFt\n", + "Velcv5NIJzFAmwBJyGvfSuEln5xGhyW4lKo51eZY7CZ1n5JEVMLWeTVhKjZSTAPn28tkybahFVil\n", + "Xzo/FEGfE9AqYrcvfzgcNsxpbD5KSfTD4bAhVbLbsCJzprSM3Pe478KFC5KsyhpkLp+RM6tOp9OG\n", + "6ZnfyftKakzUOJwGlLniypUroQ2sEWgbqgPOBiosTOw5/27eP3lcvSPFcDiciUdlpnPKKWcipQm9\n", + "cuVKKO+tt94ys6Mx4MTUvlyMZa5/0B42l6tYSakQL1xn1lyVOI6w9SWX+1TVnSOqow6pHKmj0SjM\n", + "d/TpkydPQn9ByzMYDBoOG6urq2GP4Uj4WAds2VGR8rnNZvGxKaV4lNAHYsAaZrN/W3DGEcSXqhqp\n", + "ioqKioqKiopTxrlqpBYWFpKRYHHf1atXw0n67bffDs/iOgfcbMtXYJdIlcvI86ZyUhY/q7QZOVt8\n", + "DFevXg2SPNeJNW9mTc2V10j1er3icAueX6AkeR9J3ayd5KWkE0XYVM+pugC4xpGKASXZqHHt9/sN\n", + "gqeqM7+P+Thw22euR0mgzUuXLgVpUZWLflZR0bkOStOYCzYIadZr8fz7PIbDYYO/xHXFs4oQ3u/3\n", + "G/yHpaWlmSB+KXCdfaDd9xtKU8bu8b5ea2tr4Rms71xYGAbeDU7dG2+8MaMVRZ28VklFsR6Px40x\n", + "zGlTUxzMNvBzlrUtqTAd7Nrf9lOW0jDEoHLtsXOMz3PHcxf3dzrNvInKASoWEoH7HHNHhZ/At2Zh\n", + "YSHsQVyf0+D4AUrTyG2aRyMUK8es/ViPx2MZDgYaOJwvJpNJI5/n4eFhcLr5wJHNAWx8iFGxtbUV\n", + "DgOlKT9SJiheaDmUpBo5PDyUql9AlcWT3W84pWZLX47Z0SSAWhl1X1lZCYuGD02pjU4RctVmzkk5\n", + "ua9KIkLHCJYpNXrpQs85EaBe6qCXOshFF427rsrY29sL97F5jqN0o22IaM2qdrSdE7eyyRHlAuqw\n", + "we0t6UvlIGFWbsJGO7ApcWqXHFi4MjvaB3w7h8NhOHTyfOHN+qQf9BjYo9YLf7mYURjDJ0+eNPp/\n", + "aWkp9BsSUM9DFXjhhRfMzOzb3/52+C21j/HcYcJ92w8eO034w5f68KjEvjGobBcpwQEfRY6AnVrL\n", + "ly5dCnslHzBTh9iUB6Ha39X3J/ZBLt3vTuvw2hZ8eEV/zUNv8R5/vG5Lv4UQHPr9fsNRbX9/v5Ec\n", + "Xplx1YE2hko2r6ioqKioqKg4I5yrRiqWjJjNUGY6uWlptVdWVsK9MPGoXEcMZR6ImZfM8lHPU+8w\n", + "a2rU+v1+w92WXYvRjsFgMGMyUXXwWjOlGeI2sFrWS0YqH5TSKrHZjeut4oKwictsVhOhpAkFpZFU\n", + "8WiYROzNZJysEuWp+ami5nI/s8u+nwNKc8V9wuZZJcl7KcssPQdTccD29/flnFESd2rNKSma8/+x\n", + "GRL3YWw4h5bXFsbMW6l4PrGQEymo+cmEa9QbdYmZxlUfcewcM02gHw6HQRsP7Uipiz/PRWik3nvv\n", + "vYbWLvW8WV4D4nPFsamQCfxYw+grRQxWJqCc6R5zstvtzmhyY7hw4UIgSHNZSvvt94Ht7e3G3sH5\n", + "K7FGHz16JPeQEnDbVLgZFa6DwRr7ttpLlLe2thb2Nq43xpAdTDyxPKe1xLzi2IdMOfGaZt4reU6w\n", + "ttNMr58cMDYcZgZR57n/ct+aqpGqqKioqKioqDgjnJtGCtKUIqMCnE3a828WFxfDqRmS39bWlpTa\n", + "Y+X78hRwGmcp2kuMV69ebQQUPDw8lLZxzycaDodB+uccUL7+bXILAhcvXgwEViWpp/hBrGVht/u2\n", + "AS8BRUaOtQmcEUgxMUlAcZ5QFx5fFWjTk6oVuX5lZaVB3l9eXpbuzr5fWDuS4xH46zGSewqlXC+0\n", + "W2U5Zy0Ua0S99JzjHWL8RqORDHXgocIkqByJObTRSHmS7jzkdNaUeGl9OBwGDSi4T7F6XLlyxczK\n", + "Qxdw7kFoFcAZ2dnZCdoYNd84PIRfA7GwEKn1zVoD34esMfchNE4KDnOj3q000qXv9c4zKiI5z0nW\n", + "uqJcXktes8J1UnM8pynE+xYXFxvrZjKZSM0/yuGy8Qy0UJ1OJ7yvVPtTqtWEJm97e7txL9YR6mp2\n", + "tCdgHucipuMZ7MvzzDG8o9vthjZhrRwcHNjjx48/mGTzwWBgo9GoOJqv8pTC36mNdnl5uSj668WL\n", + "F+3evXtFdWm7wSvw5sQHRrP44gdpGRP/yZMnMnkrwxO3Yx/z1GbJnoYgzqY261KPuphptxRqEftI\n", + "+ZPJREbhTh0I+f24zoe71AGFo3Cr2F2+LP748+FPbbrY+NRmrlKwpMBRxzGHOE0KoFK19Pv9GVNI\n", + "DIuLi+E+9H3swOIPz7E6+zXHXo+lBymVkiIGjAPApmyef75do9Eo3JdKrLu4uGg3/396l9dffz1b\n", + "dzOzD3/4w2Z2ZArEQRVj2el0kpGlU7HIGMrkBLC5hz3MUuaRlEcvf0jniV6tzMcA1vloNEqaWBXU\n", + "OsdYfetb32pdz1LE4lP5eFQnJZuXpN7hQxgfNrwpjs2f/E2ax5nH3weqwObmphxjAPOg1+uFtvG3\n", + "H98BrMHHjx8Xx2espr2KioqKioqKijPCuYc/KNHGxMwp/n3T6XRulS6/B/+ya2Xbd7DpUUmmKSwt\n", + "LRVLTznCuw8R0SbnlJdelbZD/abiKrHmjV2TlYlVxWfxUkxpPC9Fruc8jZBO9vb2ZN+o+cRkau4H\n", + "/nd3dzf8jT5VBG/WsigtGWvTSl2NvfSfMxUyCV9phlLlon6Li4tJMx63DX/j38PDwxlir9mRlKwk\n", + "V6VdZBOVktK9xq/T6SRNeZyHD+VBalfxejjUBZObU1sr55l7/vnnzczs93//96P3M777u7/bzI7C\n", + "S2Bf5Da21ZRz3ZWjD5s48Jt3BOK1zPGQUtpYXvtKuzxv5gjWiGOtbm1tNcZcxXAbjUYNCoJyvOF2\n", + "MAnfmxlHo1FjfZuZNMmpvQvga2cV/qDX681YDmL1yqF03NrGsRoMBtJ0epI4WH7f3t/fD3MG7dje\n", + "3ratra2qkaqoqKioqKioOAucu0bKY21tLZxkwcNhqR3PMnchxXNgPodyt+TopSUn2+Fw2CC+l4Y6\n", + "GI/HM2RU1F1FQFenejwDG/rh4WGSq8T1KJVelJSgNAMpLWAs6J5yF/Z8gFg+pZLI3DGkwmkwvEZI\n", + "cb04Yj0HyPTvjPF1lOaCn4ndl4sqz23wz04mk2REfVw7ODgIGhhoIQ8ODhpzgkMGsDs41wv3eScS\n", + "nz+M3+vrxCRos9kxh+Zqd3d3JrK173MvYeM+vz4XFxdnQhyYzWqaTiP6s9nxuCLkwcWLF8NaSfFu\n", + "WFtw8eJFMzsisatclaXwUbg5rx6DI7PjPkDNY6XhSgX6jcFrrg4PD6Xjg8plh+vglT548KAxhuvr\n", + "68EVPlePFHeUeZEKau0prVxOk+Pbubi4GN7DGlPFoUy9L+U4xOOlrAscgBhOEGhHzMnChz8o5SlO\n", + "p1M5d9qGy2EHMowZny9U/+c4Uud2kOp0Ora4uBg6kzdi5VGjyIpMUjSbVSXniNtqEmHC49rq6mpY\n", + "iCDhIkUN3zcajcKHB2Ts4XAYTB3zRCr2RDtPAk4BG+2TJ09kqg8F9VFTfV5iiu10OmFsONGljwuz\n", + "s7OT3GRSZjw+rJV6k2FBMmEY9ecPNz5yMVMVRyoH/CY4nU5nvEnbQJkjDw8PZcoeper27WVvHJjx\n", + "eH4yMOZMyCxB7qPEY+oJ1zHwgc0snkgbaOO1x+Z7gL06zc4mGTmAeT8YDIodblJgMymQizemknT7\n", + "GEbcp7EPDN7l46tFzSAF/RvzIDxNDIfDxjpT+xDHE8tREEqgUo/xR53jNqlDItcZa4k9b725iuvF\n", + "z7KjgG9bacy4FD70oQ+F7xf2htu3b4c99+rVq2Z2lHAbZWNP2N7eDmeCeRyS/EHv4OCgiKbT6/XC\n", + "vskHtM3NzWraq6ioqKioqKg4C5ybRuociq2oqKioqKioaI2qkaqoqKioqKioOAP087ecDU7DdbMk\n", + "MOb7YWv35ZnFA1WWkFfniWIe64sU2bxtNOzJZCLb5XNxKaK62WwuOcAHhYvxg1Jgl3gfuTsXNkCF\n", + "N2BiuyKoK+4YB6vDtdN2Tz4JVJ6x09QKn3SdlYx1rs7z5Np7PzAPEdzj/d7HgNxelHNmUSFPSsJC\n", + "nJTc37bPY04fAIfEKHkvl+/DQrTNCuGRI/gDZ8X1ez8sSuxgptpRyotNjWtuTXG5ufae20HqNKAO\n", + "UH4h5iaRIoyXQk3e1IeqNLprbhNRUcLnibKuPAKVV4Qim/IBxCd+NGt6qgwGg3AAAVR8MNWXqi54\n", + "p9ksmRtxkHgslWeT8pQEmIRZ8mFGpH6z8sSlJ0Fu0/dQnpBtNsKSzf4kG2vMU0ZF1D4NvB8fAi6j\n", + "NB1VCrF4TP6jGvUqmvNgEduLSg+sqb1MRU/PxWsqTVHF3mQlYOFN7Xcqur8SHP37Op1Otk0oN5WK\n", + "ib3xUvWP1cG3qdvtNpIRl4LLOsnBV+1jPA9SczaVpJ37jfs39T3md/jvWclcr6a9ioqKioqKioo5\n", + "8YHWSKVOpJywkc0pJad/s6Z55vDw0P7KX/krZmb2uc99rqh+qRg/bGZQKth51LwpN2QFdu1mKCmC\n", + "k+16qNxOLOl5F3yVn63b7YZwAXDZffr0qYzx5FW5sf710uba2lqjDNSH25uL1svhN5REm1L9n6VG\n", + "SkmxJWrtmCYx9l6PEi1GKgZWrn6nNd9LcRJtXKk2i++JaZNK6sL3pZ45i/5PoeQZpZU7ODjImtNx\n", + "ny+r1Lz50ksvNfIWxsbN90HpXOOYVikMh8PGnqDMpSpshdfYlPY5P+N/5zXl689R3fma1+5wX+J+\n", + "pfXOjVduHvN7Yu1R66zT6TQScrPWM9WPpfd5nHtAztPgD7yfUIMUQ4nak+OvMNqq4GMbvVeZdjqd\n", + "1nFPUly0a9eu2bvvvjvzm9ooOCGuSpzKXCkfG4X7WdnLOcAbxoZ5WD7Nh9qUWP2tMqUzfJJUfgZ1\n", + "PQu+TslaaWO2Om1eRcoUlzsQnMY+cNp9zpngWZgo/aCdhkmv9CA1T5+exvtyHCkFH0eMny3dm1L1\n", + "U4eX3Ee9NBE96scmu5Okt1E0jdyzbftc7ce5+dl23q2srIR9kQNp+1hxav0o06OCSloee1+KD5Wb\n", + "22ofw++xtVRNexUVFRUVFRUVc+LcNVIliHmOgFiMU+pkMilOP6DwiU98wszMbt68aWZm//bf/tvk\n", + "/aWeA6zB8GrKTqeZQDXW3nkIo/4UHpPMcB0mKo6UnZL0FhYWgtShpDq0dzQazUQ5N4tLHygPkuvW\n", + "1paMcg0gmvzDhw8bSXeXlpZCW1iCVMmXS1MM+LQ2SlI6iZ7LRPIAACAASURBVHbktMnQ3F7UaTwe\n", + "ZyOLnwZKpFl1nfugVLov7fNY/6bSMqVIy2pNDQaDpLk89h5f/km0dzmnhNPSAvqyUmWotafWT66e\n", + "3FcpArqqK7/Dj1usz1LWBd6bfHTymIk3Na9i7VEmtrZQ5apE4Apsfk2txcuXL5uZ2Z07d+TYlWr/\n", + "SjXw3qOyVJteuufjO1o1UhUVFRUVFRUVZ4Bz10i15WRw7py2PA7lbovm56QiYG1traHhyBGkc1wp\n", + "aFSgRcnxAzgHUG74SqUXpQUClFYpFVuq0+k0pI5YPf19PA4sPSFnE+dkBFgL5cdVkSDVWPf7/Ybb\n", + "a0x6Rhkp7ef7zZFS15T0qWJglZaRu99r6uapc9v9wEvqJ9FIzct14VyQfH/q2ZO0nZ/18ctiIWFO\n", + "K+kyym+rHVGaHp6Lvu+5DOZ3lval4o768s2O1wjKVWM/nU4bGnHVz7kQBly3VC5SXrdqn22rkWrD\n", + "S8J+rMj+/vnYNeCjH/2off3rX2/c5/uc/05xYA8PDwO/NpefslST63NUpnhpKY3UuR+kTgKf2b0N\n", + "454PZHgW77t+/bqZHRGHY4lrY+BJ4jevq1evhuSNufgmqSBkauJzEl5exG1iYZjNfkzwYQQpnPvU\n", + "m9AYsQzvJUEhh8NhuI/Ni94rjp+9cuWKmR1lG1cfQ/8bJzzmcv2YqA8QmzJT953FQeokUAco1Vcl\n", + "H/iYKcuPeRti9mkQqM/iIFUCbjs7TaikwCmCsqpfqbnvueeeMzOzN998U7Zr3oNUjsw7j5kpZ/Yq\n", + "qTPK6/V68lDj9wtFNuZyeaxKzLlmltwfGSXrR93X7/dnDsjzHqTUu/n5XMytUhObjxMYS2hfYmIt\n", + "LZfv4/OAItezeRn/luz5SPBcTXsVFRUVFRUVFWeAD3QcKYBPgiw5qFNsqYINEiSkD7PjEzTMRzHz\n", + "B6ROnFxHo1FQNaakmMePH0vXeqVZ8ypiVmtzfCgljc3juq7iIHmpk6HamTIbsSYnZWI1s4a2SMWl\n", + "GgwGtrq6amZHmiizWZdkvs/XZ3FxcSYljS9fkSHVb+9H7CiFtm7t7NDAdVYSv3c/z8W8ASaTSaPc\n", + "eTRJbd3t51Gox55JvTtXfyCWHslstt9K0q6YHY/X/v5+0ky+vr5uZkcaKa99OE2zXqz8HLj//PzJ\n", + "aepSrviTyaSh4WIzM8cRUvVX5i2V5UG1OaWJUu1VWiHeM/17ThI2wyP1rcRersypyjRpdrwfov7b\n", + "29uNb8JoNLLv+Z7vMTOzP/zDP5wp0yxvSlflpr5TqbXHZnA243pt1sHBQbG5j1E1UhUVFRUVFRUV\n", + "c+IDyZHyUkeMc9PWhpq7D0Q2TybPYTgchpMypJRcHp8csXQe0q1Zs40l9vROpxlkVHGGzNIhDlBG\n", + "TJpMaXqA4XAYiO6KvIwxOjw8DO9JBUtUfKjFxcVQhgoOWqrx8YRRbs95Ji329W+TnLMUJc+UBsFj\n", + "nETbwRrOk2Aewr3imZxGImaea6lwFS+++KKZmX31q189tcS/JSjl6+TqdBqhGLi/fTL0WJ1UGJS2\n", + "oWfm+Q55UndMK6v6bR6OVArzODkwAdzXC2jTv6mQCKX9m2pHbi9S8Fq51Fr9QJr2fGVjJrbSSV26\n", + "OH3S4rW1tRBjA+a+3d3dGQ8zs6PNsyQ55nA4DG3JEXz9ZBiPxw1V7DxtVOh0Og3zlPog9Pt92c6U\n", + "xxBIsG+88UY4bHJWbxyWEPV8MpnMpJDxZWBj3NjYsDt37piZSY8+RVjHeLFHIo+5X8zqENbr9UI7\n", + "VNwVzJfzhJ8LHGuHVdicnNlMj7kyl84TJThlEmuz4XqUEtrboO372GwAsBeoQupDr8jcpTF3/N8l\n", + "mOcQM28ZqryYSakU3nORvYvVfYCaX7lkuW2hiO3sMcdQ5SkvxlJwqqu28RVVvbn+qu98xPoLFy6E\n", + "lF1ArH9TjgCp7zxf53f4MtSBr9fryetzzcHiOysqKioqKioqKmbwgTTtATjh7uzsSFIgkIuNU1IG\n", + "SzAw90wmk1MlErdx8y5BidR+EjWwl/RUosucKzk0TqwtQp8zgZaf85oSpb07PDy0ixcvmpnZvXv3\n", + "GuVztF7MDybr+jmT07LA9DmdTpOhHdDuvb29czEzqWf5b7SRtW3cP8qpw9chlrvrrLeSnOs0a8Da\n", + "4iQhAmKSbSrcB7vYpzQ0gHK4YJy2aa/0HW33l06nmevzJPuiKrff7zfWqKIqjEajMA7Y/5nknDKx\n", + "lSZQztU5NeaxMk7DtHeS9domCwTv9WazmlWOlK6sGilTZ2n5/C6/56v9IuWIUsMfVFRUVFRUVFSc\n", + "AT7QGqmTICdRKU1UKfyzLO2UutPPgxICpce80ktplN4Yv4U1Mx5w1UZwUjMdhVuRB5kPpZ5JBeRU\n", + "dvDSQHBK66nIl4o8+n4ixzfh39QaUEEBuU0x5CT0tiEbYvekrr/fGil2nT4NYjfPIT/fYlpA3Act\n", + "+oMHD07FCecsNVIl2ieltVH3dbvd8De4iwcHB41I88zrSbW72+1Kp5lUO3LvO03NFf9d6rTFnCHW\n", + "5Pho7SrkQCmXazweN4LSjkajwEFlbeo83zH/LN7XhrgPqMwg6n4f2Dq1/3xHHKROMhnxvNnxJGI1\n", + "OeoyGAzkYag0VlDOYyB2zexkauPcRD9NDw9OrZI6RMS8E7HZo5/39/eTh1JAmTVipg5/uHrllVfs\n", + "S1/6UrZtuY80mwpLFimbxE4Lbc18qXhdHNeLxy9Vhjq45g5rp9GOHNp6SrYxa8zrrcVrJbX+Ywc4\n", + "/7GJfbgvXbpkZhYyMMRSXZVGSC+5xjjN/cWXX3JQibW3NN1PaTsxx3BfzlmoFLk0Qqp/U6TqUsTW\n", + "QEn2iZMeDr15W2UBUW1nk+08nsapuuRQTXsVFRUVFRUVFWeED2T4A4/YaV2ZZ1KulQATPPkdKieS\n", + "0nooU10qcS+bg1KJZDnvn4Kq81kqFH1fxuKr+PrGEraiP6DuVW7KStLb3d1thDhQfeRjUpmVJ3GN\n", + "9SPGhkMdsNbJl32a0Yg9SsY6llPMY3t7W5owVNuAVOiLmDYrFQcnh5S2i/+/bZ/nVP9AqZnHP+Pr\n", + "mdPWeDPe0tJSIxRLrJ4q+bYyxZZI7ixxn6ZTzEmRImTHNE6cdcIsblFgBwr/Pl7Tao6ltFQp8BpN\n", + "rVWep7GcgvOORew5P0/Ufby/q8jsHBmenVvMZs15qZBByqqyv79vzzzzjJmZvf3222Y2a9r14S3M\n", + "yjMIKO29ui+GqpGqqKioqKioqJgT3xEcKYY6OfIJOBUckssvJVjiN2hEOMBYyg6POqqyzWzm9J4i\n", + "qreVAr1tuUQ7kaqfWdoezfVPaaFKNUNra2shOCekHdYMslbOt20wGDSCbl66dCnwR7htqTax9FQS\n", + "wVfhLMnmJ5kTQI5EnsuHmJL0T0tz0fY9bfq8lNyectVPrdecdoexsrJiZmZPnjwxM81BifFSmLtn\n", + "1o40r4jbqRAgas2cBkdKzc8c2VxdU/XL8fpOEjpn3lybbQLaKszT5/PsGan7S6woS0tLM2ElPNB/\n", + "e3t7Rd9jznCixvo0wn7EzgY5jtR3hGmv1+uFgeUPMhrFE7lEhc0EafZiwADwwQwfZh+h1UwPWGxC\n", + "mR19mL3nCC/w2AB65Ih2pYuAN48UYZz7yt/Hh1e8l8cDiYW5/1T56CPuUxxonjx5YhsbGzPv4QMr\n", + "e+14T5AYKVQdkPCbIvjmPrjvpzySM7v4w6syZU0mk8Z9qr2xD7M/2E6nU/nRagt+31maktTB0h/2\n", + "eU8oeYeZzaSKKfnQdbvdhnk7R2XgctfW1szs+CDF9U3FqorVP4WTEHsZvi6xfc+bSZnKwDHu8BvX\n", + "D04suC+2z5bur2p/9GuA35fao2MHUdUfOdNeifl7Om16W/M9vH+rda1QcvD05mmUob7bCtzXvkym\n", + "33jTqjLxKYFQ0YPUt0G9z6Oa9ioqKioqKioq5sQHTiNVSpY1m402bXak1YBZKKe1UZKmV5NfvHhR\n", + "nqp9xO/JZBJOsRwp15sZFxYWQv64UtOZQuq+EikTdcUJX5G0Y9FrfcyO0WgU3sMSBswVOU0UJEdo\n", + "nN58881wjSUwvAcS+MOHDxum3a2trRk1sH9H235WkpwC51CcR2ovNTOVEIBZcmUpOqXtTCWTZq0s\n", + "X1dj2VYjldOSpMwfKvJ6m/JS/ZYCS6xKe6s05oAikXO2gFQYithcTOV2bEvwj5nTTjOqd6wuam2m\n", + "ylDaImAwGMj4gH5/N9OUgxQlQ8Gbf83yWmPlOKTAGuTU9dxvvo+4rvj74OCgdQJjVX/08+rqqr37\n", + "7rszz6WsIDHg3UwjST2b60v+f9b44X3ealRiKqwaqYqKioqKioqKOXFuGinPSWB7eOr0zM97yRfa\n", + "KDNNoAQGg8EMf8Ts6EQKKffatWtmZo3TNN6HkyryyHU6naBpYkkI7wbXh/PNsXRSKt15LQCT70q1\n", + "Af1+v8EjUmEUer1eeDdLY54Hpd43HA4DcZaB9125csXMzN57771wDX3DJGjWcF29etXMtFZC2dq/\n", + "93u/18zM/vAP/zD8xu3wEp4KBMr9ywR0ry3I5UHLIaeJyt3DUJJmDJcvXzaz43nOaxLtXlxcnJHg\n", + "AcWRSOVNzGmfUu1Uv6U0PzGouZPKm5jjIPL/l0jyq6uroT9UVGdoZ7GX5NDtdu2NN95o/D5vKI5Y\n", + "P3qNSy54pEKOVO3fqTTiOaI/oOq3sbERtNo5TQjWxZ07d8Jvik+YAvbj3d3daGiDWP1j75uX0N/p\n", + "NKO6mzXzg8Yim6e0a0pbhP1ia2vLPvGJT5iZ2R/8wR+E5/CM6n/FfUXf7+3tJaOi5xxk1H1q3nkn\n", + "HGWx8Ti3g5Rf5Mrbzh+ozNKqRBV1WqmoVQTkTqdjjx8/NrPjQVIEVD5g8MENpiw2l6GOfIDCROBN\n", + "KfXB40HndBFmR33lD1C9Xm8mtL3HcDhsbAaHh4fJjYI/Nr4/eNNXMXQYIJTjANXv94Op7tatW+E+\n", + "HFD53RgTNo34cjhaNzz1UA63gw/X6gCKDxr/xmPEhGJfp7bIfYByH5HSj5cyxcETFQcpNpPhXz5E\n", + "qcMk19MnQeaycoemkxDK1cchl67GlxeLR9TW5JTCw4cPZxKxe2C+DwYDu379uplZOCipmGvT6VQK\n", + "TqlYYEAs+4AaG7/vqP2KzST8G5BzIvC/sZmplJANHBwcNMx49+/fn3Ei8kDaqocPH4bvAO8NKScW\n", + "NXdjfRSDEjr4GeW8wPudX7e+PNXnPpaVgvJcVc/s7e0FLzwkk79//7594QtfaLwP4H0i5T3Jwmwq\n", + "rQzqxAIwl8tKE9UG30YA8yCFatqrqKioqKioqJgT5xpHKhdziVEas0O5OKoTdQlYpcfqvo9//ONm\n", + "dizt3Lp1K2glUifr0WgU3pOKlKtUjvPCmxfNdB/6nHfqVM/qcaVi5XEt6Wv0ldmsudKbEG7evGn3\n", + "7t2buW9nZyeEVlDkUbRnf3+/0dcsyTFQf8y1mPRTYm5ThNJSU1aszNJ7vXYxFsJAmYC81mF1dTVI\n", + "6Ez0T+E04rkolJgZvJOBeibm0OIlVkX65r5kTU7bNvN689qT1dXVkEPvG9/4hpkdaXMxH3NllJj5\n", + "VXgT1d4csZz7paRPlRnvpGbBFKAF39zcLDa/Yo9J7RFKs8au+F577Ouqwu+kTLLsqq80V0CpI0Bu\n", + "Lak6+3K4/gzu89Sz2GevXr0a2o75zmeDVC7F8Xgc1k1KS6nKZ009kIqAn5qnVSNVUVFRUVFRUTEn\n", + "zj2yeSojN9/nT77MX2pLruRnWarACZlzwp1EuvaulaXRvc3SxHLuF1+G1yJheFP8ACb4p/qQicde\n", + "g2WmtYZqfJkDBa0StB5sB8ezq6urUguCPlLkReZrzRvp2UyTTP2SUbZ7xRkpLVeVUaqRimka1H1t\n", + "Ca9ty8ghpVXgNVrqks2hCZj/k4oS3jbyPteL2+75PDGSqyK3QrsLCV6V20azXhKtW3FGlPt7qcMA\n", + "a6RySM2ZmAYndh/v20BMq1CyvtlxpHTe8TtS/Zd6n+LjxrRLqD8Ht0TbVB1inNC24WBKNYMpjiE7\n", + "daWyIsSsGqngz/yO0j1NzcVYaJTUe8/tINXWtAGo9B0xoqgqN1ZmrvMxATudThg8/MamOCa8pbwT\n", + "uO7eZKIWFdevzQJQKmYPVR4j5SmRqxdv6my6NDvqP/VOPIN+Ye8ZgM2MvDmoWDEp8DikUhKo9gK8\n", + "UaUiW5d6HanrubQSsTYB6CMQzFWfxp4FeRTm1ZgnX1vMswf4OeYJyF4IYy8hLlcdIvxHVY1/znTS\n", + "9uM0HA5n4vigTiUf3xh8O3J1Th28YqR0oGR/iUF9NOfJ2pD7mAPYx0AsZwcX/y7/PlWWL1d5g5uV\n", + "CRvqoMzfyXn6nOvnHYFyh/Gcw4WCaiengeG6l+C0Ur6gXHXALBUmq2mvoqKioqKiouKMcO6mPfVb\n", + "ThKIYX193R48eGBmmsiu3qHyyEGqWF5eDqand955Jzwzj5SI53wZbI5gScRLEDGNkYo6zO320guf\n", + "qpUkmpNEUqpwfgeeYXNfSuXM7YDrNyRG1phxzj28D6bCx48fJ50SUhITx3vh+aH6KDWP2ClhHim9\n", + "LVRdPNl4fX09hOfguEP4DSalmBm0ZL6reRAzC+U0w6lrObJ52z7n8krMuKqOpaaEmCYshba0BbWP\n", + "xrQdqX0AyCVBVkTr0jqW3p+if/D+yTQHzjBhNhvaQ5XLVAXcx5r4XOgCs1mtNu9xOYtEKdQYto1E\n", + "jnbkTNQ5rQ07D+DflKb+5s2bZnak1UaMQey9Ku7gYDAIdU45TSjKS25e5fZvZQ3A71UjVVFRUVFR\n", + "UVFxyjg3jZSPJK1O1jm+k5KoSsjr80TmBRYWFsLzKvs32/1LpMgcPykFlhZjLs+ev5TjETBynCfA\n", + "a4GYQ5OTAr2L8Xg8DuWhLazJy+VqKuFIKU7TZDKRBG9AaR9SkvxJNFKxuZjiBynk3OC9toPHgyXO\n", + "lETKvJ5UJOpc21Io3QeYB9FWW9QGJaTl2H0Aj00J+VpxPHLg+1OardL+Vc8oPk+OJF6yztrk8/P5\n", + "P7mvoHXloMj4jXNz4jeVkYHrrDTeap2rfTbFx1GaP/+N9N8vzrLB5SoOVckaUJxARmp8e71eY188\n", + "ODhIzjfF10pZALjseTTXOQtM6v4cR+rcTXsg/sEkF0OJKpHfnVr8/JHj39RGBpUv3neS2EI5sBea\n", + "SsvA5Haz/KbNRFv22ivxVDCbNROi3NRGkpu8KY8L1GlpaSl48KnNDWUNBoNg0uPEyMqbEFAHi1zc\n", + "r1TcslQ/lpqZ5jELpX5TGzL/hv6ZTCYy/U3J3FAmKpVe4iTt8Ne5fDNtgma1PJD7OAA5gSZnmiyJ\n", + "ycX3sXNK6XpsaxLNjauiFKTMM8oMyl7FsfhHDNUe1aaYSVF9+EoPoh4cIw1Q0cKVUBT9oLrviloX\n", + "fOhQH3B1AObE43xgwd+lJsJSk2JqTvJ3Jffdy5llzeL7bKngWDK328wnda2SzSsqKioqKioqzgjn\n", + "rpHyGoGYVJRy28S1fr/fkD5LJVKUY5ZWnXPMoJw2AxoQaFRiZNNUeAF+nz+159TueD+Xx9Gfc2Yy\n", + "JWWXxoriOprlVbCqTqnyldp4PB6H31LSMRNUY8Rzs1nVespNnpHSjpTitM1fag2wBiZHNvYmu1gc\n", + "Nn43UBILits7j2aXtYA+Xhqvm5y2uiTido583bbOpSY7VReen/OYG9X1UocQ7zSj6A1tyOSnkcmB\n", + "657S6PlcmQye2yrkTa783Bj6OqWeje0DynSXcxLyexFrlRhosw/JwWXErEGA2k+UNaAt4f4k2ns1\n", + "j6fT6cw8B7zmD31VNVIVFRUVFRUVFWeAfv6WswEi+sL1WvGXcPpTgRtZMmQJA7wZvEORB/k6nzBL\n", + "7K9cD6XRQTt2d3cbUgy/H+8bjUaNtilegpKIYiRWJWlxOAL1LhUQT2lcvPQQ0/h5LZvKoTedThv3\n", + "sWSgykdZMc1GKpCpkuSAbrfb6BduK3OMPCE7p6XK8Ws8YryY1LNKg+B5LAyuZ4prxxwPjI3iAXFE\n", + "ZdZSlEiduTUI5CI9K+R4hCm353kkYH6H13DG1koJZ0yNP/epqqcKyMnvaMtVS6HTSYdYiD1jNssT\n", + "43lXwl/h64pLo9qrtCK4puZLThuVimyu+kUhNq/bhjdQ93J/5DhLKoh0qebIh1NhsOOQn7/dbjdo\n", + "rHgcUG5pMM+UZj1niUntQSVr4twOUgcHBzMdnpooPPHZtAPwhoGPnCLJASqSLh/W2FToVdfdbjcs\n", + "HD40+UFXpEWzphedIlzHNkg8wx8vv7mmYm7gGdUvivzoPwQIlc9gcyp7zPnxjE1e9HlJolWun/qo\n", + "qmdjhxIk1gTZNNXu2PtKNkhfbtuPV2qBxz64sftLyvDzKUeq5fngxyNnAuB3ldxX4tHr52dqH+D3\n", + "MJk39fEq3cxVZHv++LPgmCJzc3t82erwpxAjdacOa+pZFV2b/z+VSiYVFR1t8fD9r8zMMSJ4ifc2\n", + "m7dU/5WanNQa4L285D0qgrw3Pan5W+LkwG1LmftYyMb+eHh4GL5jXC+193mlhdqj1Zo6PDxsKBOU\n", + "QiD2HVUCnB/PmBBzGmZ6s2raq6ioqKioqKiYG+dKNocWwuxYm8Anx3kjiDNipi7vpqpyrc1bntlR\n", + "e1KqxpTrr7pv3mFS5ixvTut0dE6nlJZItU2R5rlPlYarRBOmsLy8bE+fPp1pG2saU/2mzIxcVyWl\n", + "srYN0ppSYXM/tiWbl5rxSlyK/XtLyNw5zVCKzMumdp4HfixPSixWITkAlpRZYm1LAE7tA7k8mKnc\n", + "jXxfbo6XOITM05dtY8cpTYnSKsW0ffPEvPLvyyVULw1NUAq1T6VyAab6dB63e0aKgqL6KGaS8+/p\n", + "9/vSRJwi6bOlJuXkwM/5Z/lv5USE8CxPnjyR3wYFpUVVNASPXBgK1Gl/f79GNq+oqKioqKioOCuc\n", + "G0dqNBrZ3t5eOOGBJP706dOi/FIcPZuD3OEkioz1t2/fDs+wlKdO0ilNFD/L0bBxTXGUIE2mgqop\n", + "rK2tBW1LyjWZpWO+xoE9PTqdTtAYsQbG38v2ctZMqYCXuJ4isff7fUnmVu9LhatIRSBW2iU1hwaD\n", + "QbjO2rOUdMX3+Xaw1pO1rAol2iQl+SjSPCOlUcm5yat3KKT4Ndwe7h8/ljHpslTzivvm0RqnpO1Y\n", + "2/x4tekjxRkDsCfs7u42NCBM0uf+823OhRwodajhNp5GGIKUJiRXrrqf9zg1/vPy8Pi3VEaEHM8u\n", + "FxVb1cU/oxwCfJ2V5gVzJ2YFMDviO3nteezbmtoX1Dcux+8s5YRi7sc4vP5Znife0Wtvb08S7r3V\n", + "JaaJSzlApRobxRtvvDH94R/+4elLL700/djHPjb9lV/5lel0Op3eu3dv+jf+xt+YfuQjH5n+6I/+\n", + "6PTBgwfhmV/8xV+cfvjDH56++OKL0//0n/6TfK+ZTTudztTMpqurq9PV1dWpmUX/Gw6H09FoNB2N\n", + "RtOFhYXpwsJC9N6NjY3pxsbGzG+9Xm/a6/WSZZjZtN/vT/v9fvj/VDn+v263O+12u6GswWAQfkvd\n", + "h/YNh8PpxYsXpxcvXoz2gf8NfZj6jfvczKbj8TjaXjObDgaD6WAwmOmvTqcjy/L/cZvUu31/5Mad\n", + "719aWpouLS3J+1Dn0jFfXFxs1KX03bH7fLnc523/K+nreZ8tHUtuT+rZ1ByPjWlJHebpA9XnpfU/\n", + "rT5PzTvuE+xnZib3ND/v/PxuM678u7pP1ZnvS72b9xc17v5ZtDk2RmpsUvNJ/cd7Zdv5rtpxkrmx\n", + "vLws+5nnnf8vN8Z+T+f/FhcXi97H+xh/k9T78Lfa0+f5z7/Hfw9P47+1tbXp2tqa/DbM8x/6O4bk\n", + "UWswGNgv//Iv22uvvWb/83/+T/u1X/s1+6M/+iP77Gc/az/6oz9qX/va1+xHfuRH7LOf/ayZmb3+\n", + "+uv2m7/5m/b666/bq6++aj/3cz93KhJORUVFRUVFRcUHEimNlMeP/diPTf/Lf/kv0xdffHH67rvv\n", + "TqfT6fTWrVvTF198MWijPvvZz4b7/9bf+lvTz3/+81IjFZMw/EkV9y0uLs6cjjudTuMUq07LSgLi\n", + "E7CSdiAtDofD6fLy8oxUwf/hxN9GWlL1g0aKf3/hhRemL7zwwsyJGnVtIxl46cX3V7/fn3Y6nVAO\n", + "a36uXbs2vXbtWrh/MBg0pByuN9oRk4a4PFzz46okUP8M6qLayxrB2D1cHv5jCQ1lKQkppjH07eA+\n", + "n0cqPs3/eNxUXVK/xeqdktpPQ3Jt01+oS04L2Fb7lFvXqo9ykrXab8bj8YymWNVPadZK29FGI9VW\n", + "w6i0I7E17OcEl9tWI5HqA+7LeeaYqkupVgzPpvaQ3FpBWdwOfg+Ab0+3201+p1jbqcpT3zF8A/v9\n", + "frAaseZKadTUXE/tBak9ejweJ60Qajzw/VlfX29cV+X0+3051uqscSKNFONb3/qWffGLX7RPfvKT\n", + "dvv2bbt69aqZmV29ejXwkN555x179tlnwzPPPvusvf3226VFVFRUVFRUVFR8R6GIbP706VP7iZ/4\n", + "CfuVX/mVQPYFmMSlELuGzNae9MZBJkHcXVpasnv37s3cNxUB4BQBlYmvitjM9Zz+fyIbPwNiHciI\n", + "0+m0QSBMkeJz4LJAHNzY2LBvfOMbM/cNh8NQbirwGL9Hkb+Hw2Gj/fwOkBIvXbpk7777buN5Xx4T\n", + "D1UIC+5z1JvDB4CUCbDDADCZTGYI+2ZxQjqTeGPwZfr70UaeT5iL9+7da4SF6HQ6kqTq34d7+d9Y\n", + "XjB/v7oWcy/3z8T66iSBJ5VLfGodptqhrufK5+dU/VN55mKu656kW0pL4Lqqd6f6xcwazh/qPi4D\n", + "f6f23dyzJfU3i2dCSCEWdBEAmRf9s7W11djL+dug1g9+U9+QnZ2dIueF2DVF6seegb5Q5eJ3s+O9\n", + "IZf1QM1P7C87OzvJEDQc7gXOSQrb29uNkAO9Xq/xdbyGBgAAIABJREFUG/cHjzmCFjN8qBgGOzup\n", + "TBipfQnv3d3dnZkLXE8ut9/vzzxjdtRXmGMoQ+X9m0wm4T2oc7/fT+7lMWQPUvv7+/YTP/ET9tM/\n", + "/dP24z/+42Z2pIV699137dq1a3br1i27cuWKmZk988wz9uabb4Zn33rrLXvmmWfkeweDgZxYKysr\n", + "wSMLHc6HqI2NDTMze/DgQfgN93W73XCIwLvZi40PED6cfafTkRsYns11ro92zhFt+ePpPxQcmRUT\n", + "4datW6FcvENFSuaJj/ZsbW0lNz7uA35fylPu0qVLZmZ29+7dpOegqhf3Pf5Gny8sLNijR4/Ce8xm\n", + "JzcQiwWmUPLx29raarRDRW3nAyG/12+WDCzqGPz455Lgpg5XsQMBf2RwzXsVKs8Wxjwx3Eo+WrHD\n", + "f9tDZK5M1J8Pm+pe5elZ6hGYa5PyvPP9qTxvDw4OGv2vUqZMpzr5tkKqL+fhsfp5zvOYy0plR+D1\n", + "5r3ccod/zGPez9ShOJciKFUG+mVxcTHsWWp9cxv9oYTbq1LJcF3wG3vgpfa9nFckyptOp41DU+kc\n", + "HwwGoV4Yk/X19YZiA/fyfQqpa1yvDnmuKoGB40T55OvT6bQRKX00GjXm1nR6nEEAv3G52Eun06l9\n", + "5jOfSdY7adqbTqf2sz/7s/bSSy/ZP/yH/zD8/qlPfcp+/dd/3czMfv3Xfz0csD71qU/Zb/zGb9je\n", + "3p5985vftK9//ev2fd/3ffLdo9Eo+9GpqKioqKioqHi/0aHAnrmDVJJs/nu/93vTTqczffnll6ev\n", + "vPLK9JVXXpn+x//4H6f37t2b/siP/IgMf/BP/+k/nX73d3/39MUXX5y++uqr8r0mSGNM8FLktStX\n", + "rkyvXLkiyXeerOnfj79z5HCQ33CfIsktLi6G8pj8ze/G+1MERSbheUKeIsjH/kuRNNlVluuC8nIk\n", + "U9WvnhjPBEdFsGQ3bz/mTIJMkWdV6IfYfyXurnxdkTTRP2ruqPFS5fl5Pu8YqnnMdTrt/it5n7qu\n", + "SKfzEOzbluv73LvMx4iuar6ftgt2ai6q/lJOJ3zPSUjQbUMIpOYd14X3dO/Ak1uH2PO5TaoPuC6K\n", + "3K/23tP8L0ea5/+w36UcGzyJPDbnuB94TgPLy8uN/sC+FesH3o/V/Lxw4cL0woUL2TmEfROEcDXW\n", + "ykEi9m2bd+3hnaPRKLtWUg5m3Bdqj8EcjyFp2vvBH/zBqNr3v/7X/yp///SnP22f/vSnU6+tqKio\n", + "qKioqPhTgXPNtcccFGXrZ2I7eFO5qOfKZuzt0WwzBiltb28vlF1i62XEeC6eIB3jUShyo7o3xZFi\n", + "gOC9v7/fIH3v7OxI/osiNXK0eQ/1Dh4bNQ5+jBWRldueGusY0TrlUKCeZf6aJwXz/GSeGPoF13Z3\n", + "dxtzhudYiscQmzv+mdycyM13Bf9sjq/FmIdDhTJL24H5gn95bqq5MZ1OZ+Z5qrxUubn6c3kxxPqS\n", + "ia5mOsJ97N2+z3Nty6FkP+EyVF/xNbWHM1cN1zwvxUzv/34sudxcvkvflhiHy9dTOX8oHmgpb5P3\n", + "mhyfTbVJrTM/HrH7GKm9HFBjrXi9OQcE/pbMu09gjpiluXRmx21nXjFzC08KkPpT6+3cDlKrq6v2\n", + "9OnTBiHz8uXLdvfuXTObnejKU8qTbnlygwDI74599AE/6OpjzQtSpUJQmwSXmfPIiSE2iL5fbty4\n", + "Ye+8807j3XxwxCJQH2nuA38oKa2Dmdnq6qqZHXt8sNdhKn0LI+V5FeszVRf/DB+QAE6jgHKHw2Fw\n", + "MuD3rq2tmZnZw4cPw/MXLlwws+MDP8+Jth9rBj9b8p7YARMCA4996sOX24BK7uP5ospS7VGJrxmp\n", + "98yTKJo9RFPJedVHK3XojB1A/JxW4xXzCCs5XPP7+ECdc1AogSJL817IDii4LyUMpZKcs9MEtx97\n", + "Etalam+bj6evn+pT3i9Sa5C/P6lDkxrzjY2NsFfG9kVFjE4J61BEsMc0Dhvdbre1N6bqX3iz7+zs\n", + "yH5XTj2evK4wHA6lsAFwu9XcBkr3XjVP19fXzexoT0daudh7atLiioqKioqKioo5ca6mvdXV1Uao\n", + "Awa0GuxWyupZ/8zS0lJ4N6sw/amUEx6revHJf15tAkuVpUk8Uwl5FVQySga77aLc9fX1mdARXF+z\n", + "4xO5SnTLcUtS8U2URH3hwoUQ6oAlUa+14XAVKr4JoKRElna4XiVSEUuJ7M6MMcF86pAnh+orIGba\n", + "S5nTUvfFNE2lSMUW47H38WGm02lRouXYb0BbbUEbsxVrR7xGKmeuTGlAfH081P056kFJ+JCTaKRU\n", + "XbrdblK6LwWX77XK3D8ot9PpNLQObcY1pdVRe2Vq/ikNoVlTu6j2Pda28R7i1y3vjwCbwXhuQJOD\n", + "slKWETzrk+2yOZW17bie0/hjT+D3KU09WyT4/hjUuKHtvV5P0nnmnZedTieYLdGXvMcpjbOax8CU\n", + "QnYwPQR7ctVIVVRUVFRUVFScMs5NI+Wl+Hk0PyDnKS0UtBqdTmcm4raZts2WSvw5iSqlqTGbldbM\n", + "jk7leB8TlVOkP2UTZo0D/+2fee6552aCppodaYhUADMvSU2nzWjy0+lU9qvnVyleEpfLZEilQVJS\n", + "kNeysLYoJTWtr68HaS2l/RuNRqFtmFus0WPJFpINB1ct4euoeXcSZ4MYudVLiTmybEqDFFsrag2X\n", + "cFAYpdpbBdbkASyht43CrNDtdpOSeWr98xrIOWaUagFL0MaJYJ4+x3NewzGZTIo4izyf1P2soU7x\n", + "YZQmpC0PsJRYHtMaAtA4KctHbP2Uam2ZBI+/FfcNdWCNj+ILA8vLy+FZjmaOvRn7rNIgzeP4wGtV\n", + "jSssF7jGjlI8njleZUn5ykLA45HTSJ2rac/suBNUJHJW0YHgCzx69KjRqOFw2DiUmB13iA8bz3+r\n", + "hcGbZsprQplxTkLqjCHlbceHML7fH3xUaoAYlJnCq0JjGzSi3b/33nvJ+qe8SdRET21QMbNl6X3+\n", + "YMbmSG6DH0f1gdzf30+mUWCUmMlyh6u2ZrCTmOliKImyHSNhnwbUQUqp9s2aQhU7Q+TI/N60a5b2\n", + "MOS9waek8F6HgPLgKj1wlXxYTktwZJOS309yxG2upz9AxQ76fo2yMJYyX+eg9hpAHUQXFhakZzDa\n", + "hL4dj8fhvpgDEu4v3Se8iWoe5MYfptO9vT3ZnyUepG0O8KUo2TOU8xQ/Mw9dopr2KioqKioqKirO\n", + "CEVJi88CMMMoqcnnJhoMBjOu5mY6lgVLMNCI3L9/P7xPaTGUFJNzXfUnW5aKvLt37D2QXFhCU32R\n", + "yo2WI5vH1N8pF12Y5A4ODqRE6FXJq6urQQ3MUrSqlyfx9Xq9oIliU2BK6lBaNJT74MGDhqSkJGCu\n", + "WyrHn8Lh4WFD4t/f37fLly+bmdmdO3fCvSWaFyXlKGeI0vAHOVI0a8nU+/ycaEOGT8XDUnXJadty\n", + "xO0UclpgH3YlRzbn93GMG8CXo2KVKVM8O7QwsEa8eaEEsbhrXIfcu9pqC5V2TplfeE/hZ/xew//P\n", + "+wprosyO1qCyYKTMh6nYTApqf2RtFGvJ/R4eM58rrWbbfYKfUXGXeN75+3gNKy0qUx7g9MW/qfmk\n", + "tFT+fr6eattwOJQ5cttadVIUBLUeJ5PJXFq0qpGqqKioqKioqJgT58aRQnDKEmkcz5hpIitwcHBg\n", + "Fy9eNLNj7RO/i6PsQtPD1z2nZTQaNSQKlYW9pL2+7ilwpmpVBiSg3d3dxunZc728rTim2Shxy/bB\n", + "Pv2zrKkr4SsoXgK79CrJmoNhqnHw5XI7XnjhBTM70hopkrmPwqzIsqyhYelUSWglHAYljXU6zWCz\n", + "pc8yV6Wt1qENfym1BpR78TwR0/2zJXwdL2Uroj1fZ9f1WCgPBoeISAUXzfEvUlw/BeWW38bZwCM3\n", + "x9oSn/l9irjLdblx44aZHfMn2e2etZCeJ6YcVvwzvtxUm0oJ0jkHAwa0KHgvBy9V/c1OKqWEdhXG\n", + "gYHfee8q5S/5PlpdXU1yvDBGOzs7kqTtMU/Ef/Usxnx9fT3s9bBuqP6NaXRzzmHAB5ZsjgWPiNCe\n", + "1MsYjUaNOFKDwUCq0wEedFZn8jvMjlXE7InA11VHqw2eI8bi/lRUdPbe815FiiyXIspyO7xq2S+6\n", + "paWl0BZ+nsProzw1NqlNnFPT+A1gZWWlcXhRZlKz9EdG1YnHPbXhfeITnzAzsy984QuNODR8AMl5\n", + "/vkNXm14fIhIbdzqt1gKhpKPm+rT0yKqp57NEUtPy+EiZypUH5ecB6LZUZ978vBJ+jJGXvZ7R+xj\n", + "6ddzKXE3Fg9N1fM0xkS110fb9vd78xgTt7nOqn6pOiuzW2qO59LGlEKZrdoKEGZlWRn478FgILNx\n", + "eKeJbrc7Q5Mx06l1GKkUPP1+P9QrFZ281+s1+uHg4ECOoeovNrf5aynEaDX+wL20tBTWVy7jQiWb\n", + "V1RUVFRUVFScEc49/IFCadLglPkIp/vRaBROqCCsd7vdcOJWJh48y6bHtiYWszKybCyGSqmElNMM\n", + "sPSCuqTyfSmpbmNjw8yOiPvcN/iXXXjxr9IqpRIK50yBkGJQPkdFZ9Mi6sB1Rl1QT46RArBmQM0/\n", + "lbcKYLMLwjk8efIkOc9z41uamy6loeF3qcTY6pmSeaeIu2bNNVIaoTt3jccjlX+RSbXqnUDMJOa1\n", + "T6wZxDtGo5F0CikNV+GxsbFh9+/fb/w+r0YK9zJiz51G+AluL68R1CNl2lehT1LhUJaXl8Pv2C8O\n", + "Dw/ld8JH/D5JPK7hcBieV/OZ12qJyZvDYAArKyuhbUqDydHVfUYHj1QdsC/2+/0wtzhvIe/rbbC8\n", + "vBzGve2zpXMb+wCewb9ohyK+K4uH6h/1bWoTR6pqpCoqKioqKioq5sS5a6RSHCAm7AHQLuzv74eT\n", + "OUIdMLGUA0EC165dMzOzd999t3EtxtdR9yluFksbqIsi7voI2Dmtm4Ii0LE2iwmynsQZsxmnAjWi\n", + "f2/fvm2XLl0yM7O7d++G+1TeK3Wfh4qortp5cHCQJJEDrBliCeOv//W/bmZmv/Vbv2VmZlevXrXb\n", + "t29Hn83VRV3z48l8nVzYgFKOyllFu55X+4n3mOUJzbzm8Xcuv1iJZpqlxFKCP4PL9e1TvD4VpJXb\n", + "lBpXJdHG3lca3V+hVJup0HY+cXtLnuE1z2MFCwFrotAHHN7g5s2bZmb2rW99K1r34XAY9olU3rfS\n", + "qPIxYv5JwnOU4EMf+pB9+9vfbvzO1odUcOCU40YbsHYfWF9fN7Nj7b7KRMB7NIdfyK1ntM3XNaZt\n", + "9yE91LNtAtCqsf7Aks2VeQnXfCesrq6GhVEatZbf7zfkfr8frvOiThG8FZk7RdyMDaaPH8J9gfvZ\n", + "W5AjZZcc9Lxniz/MKc8XRW7mwxgI3vfu3QsHGvTHo0eP5ELzfc79q9T36qOJxb+4uNj4oKlQ/v1+\n", + "Xx6GfByUWP+pjbHkYx6LGeTVy3y9dNmphMLzeMDh79JEoanDXxt40qrygFLkUDVPecx5PbKX52ke\n", + "pNS64LhpKVNrzGzpTe0cAT9FjPV1Ve+Olauu51KclCLlQcbR4nkfA1RUb2W+SQlbnAIotz+WzOOc\n", + "Ga+UoA9BcmdnJ7SZ6Q7KDK4O3qrtucNr6oCXMkMuLCw0PH5ZyIZA/fDhQ5lSDM+kMgRwWhvl1IUx\n", + "Ut/5nKdpKfiw5mNW8j7LwnE17VVUVFRUVFRUnBHO3bR31lhcXAwEMiUVtUXOBKSgJKEU8ZrBmjoV\n", + "lTinKUtJjDkNjCeMcyR1nNpHo1G4rrQ3XBfl3ot+gAQSi5uFMjgxKurN7/XarrW1teBkkNLoKA2I\n", + "Uk1Pp8dJmlW4DCBmZio17aXGhjVxSur0Gk6uM9oYi8njTXGlcdNipsJU0uKURmcwGCRzreHadDqd\n", + "IfirmD25uDZmR32VCruh8iYq6bhEa+SfLXWuOa0QEnhXqanDfyK8OdXsaFyUNsGPMc87brfPg1oa\n", + "eoTRVovH4EjzqXnC5HW1nz377LNmdrwf3717VzrKqLqrvYaBvRLzs9PpJPuN2465Dezu7oY2Yf2w\n", + "RYEdeZSjCt6nQunMY0b01I3RaDTjvIR/1btZy2o2GxqJ90BvwWBLUiocCb69VSNVUVFRUVFRUXEG\n", + "ODeNVKfTsUuXLs3kJjOL50Ty0sb6+nrQNOA0a2YNImPO7fEk4JOtD/oZIzJ6KYbrznmk0M4Uj0Gd\n", + "nmORzZV2hG3BzM8y09G6n3/+eXvjjTei9WF4jRvzJVLETeZLgNv0+PHjGe6E2awElIpOyxopRspd\n", + "XWn5lLu10iTgPg7PoMB2eh/cTpHwmUunNBeqzopHxJJcShOiuBQpDkosjIcqw8+rHB+K36Gke1zf\n", + "29uTvLQUZ4Trir8Vx0MRlFXg1hwPR9XFa7tOsiXHeFgn2ftSWtSS/cVMR5Wfh/isophjzbEmUQUY\n", + "Vih1aPBjpLQjinvLOeNYi4b9Ee1Q5XtNPMaQwxWoPeEk/VsKH/KGSeQ5zqAKIuo5pu/3sSTnOPCB\n", + "JZsDHN/IbNazjVNx+CSe/PFXGxrewQTk3KHKx1/hd7Yd4FinK2I2P5MqI5Uygz8C/JuPg8MHi1Kv\n", + "k9RBJXbw9W3p9XrhYPTgwYPwPLw/+DeA1b18qPLgQ5tSdasPFRPU0TYfNX04HDb6JmfG4UOi/+Dy\n", + "fdynpYec1PxQZaRiLpXO41ITUIy87OeOiorMBG42r6m6qphlqs+BXq8nYwnxdSC11tXc5o9YKm5R\n", + "KkUNv48TKadMYoA6cPM45BKBl3qBpg5h6iBVOheBnFmdvbj98wsLC2FuqQNtjpwcywih6sj1V/HE\n", + "mHCN8i5evBj2E9zPsQ1VCjM8G0uXljq8cqytnPemf159e08CZcbn+iu03feYpM8ONf6b3+l0GueE\n", + "Np6wlWxeUVFRUVFRUXFGOFfT3srKitQwKJS4dLIrLJPNVM6z0pxIXkpQpjiun3LtBJiozu+FtgVa\n", + "NyV5sdReKkVxfZDMWWnCYiiNRA6tg3d/jYEJxSl3V2BlZSW8G9IWE99ZioGLLscR8wRVjg+kXGHV\n", + "b0AsSrhfRjGyuUJp/jVFIo+9IwY2fXltJmscuU9LtFjz5ILLQfWLbzuXq/q8tDzWipSGMEhpzGKm\n", + "fa6X2SwZnq+pMfaIRUX34xkzu6Y0ZTHSsgf3hQppwxpfs3hSbU9e5gwMrOXhcTc76u+SkDixNZVy\n", + "MOD2pL4/THLGnswOKeoZH9NQhdpYWFgI72P6CM9T7G34TVkNcnP2tFBCAWAg/iCHiMgBfYBv4NOn\n", + "T+X+he8T7t/c3JTaLqXhxvs4DEbVSFVUVFRUVFRUnBH6+VvOBtPptFgbpbQFfDLM5Qfyv7NdVQXB\n", + "Y5url8ZYwuC8czHbv5nZ5cuXzcxmomlDonrmmWfs7bffnimDeSRo5+PHj2eIzLjPBxRjqZzrpCSV\n", + "nJaPc2ahnSqYZurdrCHwZMQbN24kIxSzZIPyVPksYfgo0YrnxME92TkAUg7mhAoBobggDE+KV+3h\n", + "Z1nKBpQmTIW/YC0K6qzCcyiJNMbXAnIchZSWQkl+KQ1XTLsYCyvBdWIttEJMgvR1VBoY9d4YqRbg\n", + "ZzB3lKu+Gn8mc5doDNiFPdUHw+FwRrMBpDRMjBTXj6E0tX4uqnnV7/elRgjzEtcUn21paSmpkYJW\n", + "fWFhIWjveI2mnuVvTkq7zI5BKT4pQzlXAIpPxN8ihppbav/07+v1eqHMXF39+2IhgEo0v6wd5X3Y\n", + "z2O+D9+SpaWlsL+r7w/v1XgPZ8JAn/M3xJ8r+H2+/SmcO9kc4Eja7JFhFt8k/EdOqZIVyYyBRbWy\n", + "stLK7OXhyY39fj+oLnFgzHnPKKItBp3Vn7yg8AxPLBVHCiYv7yWJ+/00UKRF3vRT6QdiJkxApY9B\n", + "nRcXFxubw9LSUnieD3dqPF966SUzM3v99dfDb95EyRsjH5phYgUZP5bCJuUwAMRMe7GI/lwXM30Y\n", + "ScXc4jFX3melKVj8Zt3pdGZMa6i7Mrv5D5+KYm6WjgXEY+X7iuekMjvnzKlc53ljDqmPSCwdDA7m\n", + "XEeUC6EoFg/JE/JjKI1BpaC8D0sPzX5P5TWV+qSwB5wS4NBn/A5O91JiVu/3+w2vPR4z0Bzu3bsX\n", + "fmMPZvSlipXHccp8Wqj19XXpNOPLYHMk5kG3221QKLy5D+sLv62trYX1EEvRZBYfDx+7CX3Pv7EA\n", + "Vwqek17wVYfSXDw8vuZ/6/f7YS/AwWxhYSGMScqRiueOGn9GNe1VVFRUVFRUVJwRzjXXXqfTaRAP\n", + "1akvFhtlXvBJP/c+zi9kNnt6ZkKoiricAqSLxcVFGedIoYTMx4Rcs1mCvVk8onVJriN2x2WzZswE\n", + "YqYlfnbz9poNljqh0ev3+0HSS5FDzY4SEpsdm1FZg6BCLUA7sr293Vo1zeTvErK50lwokinqbTYr\n", + "SSsNrdfM+PFHuUqrVBpbKJVHkqXa1FjyNa+RWlpaCvcxWdfvDdxXrBVUufYUqT7nDu4ldAVuU2qM\n", + "mETOfQCpH9d8DkkgFe6D4bUOrEVt64CgwkfE9jFPfL548aLU0KZCj/C88/NYaZ9WVlbCdaZXeA3h\n", + "xYsXZ7RNvi4qxxtbMNT3Z21tzcz03oF5rDTYPOasfeT9GOWjfqjTZDKZCRGCtnNdAdaUpcJ9cHvV\n", + "fpwC2rG7u9voo1wsOIVUCCJ2Eos5bqHOmIv4XvA8ZOJ4SW7JhYWFMCa89qpGqqKioqKioqLijHCu\n", + "HKnBYNA44bFUydoiLwGp0+54PG5omJg0zZocH0JgNBo1cqj1+/1iQvxJwBIIyvfEdyaMMo+FpQSz\n", + "ZrgHr5Eya0qJTG5WQfzYNq+CgirOg5fuWXJUQeHUNHzllVfMzOxLX/pS4xpLQKxl8ZI8E3dT4QI4\n", + "6Cvz3JiMjt9UxnBF8PTSPYdd4P5RWoBUv7A2RgU+BVLSYEq6MpudB34slSs5a4uU1hDvG4/HQapX\n", + "bVRaHn7fCy+8YGZm3/jGNxrXNzc3wztR3s7OTqOdsZAIpURhIKfN9tc5OrXiubGEnuLxAIrrleMn\n", + "xojMuM8/E5snnkivuGmlITFiZfi2ra2thXWdqx+AtfLgwQOpRUG9S8c853gDpHiAvV6vwa8ymw02\n", + "bXbURqy9yWTSyInX7XaTfLNYvVE/zEHPSeb7Ynyj0qwIvm1q3cUClGJs4Kz19OnT8A1sy9uKzZPS\n", + "cBA5jdS5HqRisT1S4M2uRBVvpiPGerOBmtAcFTnllafiPq2vrwcPA/7I4W82jfj6YxGa6YWYApP5\n", + "2HQK1fSjR49kv+U8rYBUTC6F1IedN31efCmzBk98f4hU0YZjdfJ1iSVTVeX6g4Iyp/DhqhTcB6mP\n", + "ei71i8fS0lKoK+YfH+qA4XAYPl4sfPj5wn2lxkqZPDn+Wsr8DfX8kydPGuOwsbER/kbdOVI/H0C5\n", + "//xmWfrhVve1OYT5D63K0KAOL7H3YazZKzfVtpQZnO9TfQXEPg/IAoC+Z1OsQmqexszbvl94v+Cx\n", + "4jmD96kPc0ldFhcXZ8xtZkdrAWOJvrp//76kL6BfONq6P9guLS2FuqqYgBi3w8PDGQ9t1AGCCB/I\n", + "lPdZ6SHrtODX6/LyciOhPdcnd8j2czuXSqaUqoD5sr29nUyxxg5QT58+raa9ioqKioqKioqzwLlp\n", + "pM6h2IqKioqKioqK1qgaqYqKioqKioqKM8C5RTZvyx85a/xp1ZJ5QqnqdyaMl5IuU+CAeCpPX1tw\n", + "cEMmh3r79s2bN8N9t27dMrMjjoQPfslctZTLL8J0mB3b+DlAJfpsOp2G93AQTM/X4fvaotPphDqA\n", + "73b//v0i/kOv1wukWw7ICn4T+kJFGlaR1weDgb344otmZvbss8+amdmrr76arAPGZW9vL9QfoUX+\n", + "7//9v/L+v/SX/pKZHUer/8pXvtK4bzgchnc/evQoSno2O+ZkMMcr54KtrpdyM08Tyr2c+RzKeYHH\n", + "LZVnTHHCSvkmzLNKub8zXyuVlxTtWFpaCtwy7ElcBvhCT548CX+jHTs7O8HZAHPtzp07jbUSc1gB\n", + "bty4Ecr1GRguXboUSN+4786dO2FOoP+uXLkS8ukBCwsLwZkA/Xv37t1GmBZ2lOp2u2F9Mh/OB4Jm\n", + "xyH1Pcs5o6DfwCPinKXzoITMrbjSy8vLYY9BH3z9619P7p+lc5bz8KU4yFgzscj7M21IXv0OQVtv\n", + "GwVOjBuL7XIaKI3tclbgDzwmXo70zwcC1JvvBzkeH+bDw0MZx6UtOM0MNij2ikNfYrO8d++eHDsf\n", + "L4XniYqvxWX4RLYqvVDucMTphRRSHz7ExXrrrbdCvUE2HY1Gjai+Cs8++2w4bPBBitMxeKhsABxv\n", + "Btf/+I//OFougz1SOYJyDAsLC+Hjm5pL+/v79vzzzyffxR6mqEPuAAWoMeOoz2ZxL0t8YN955x0z\n", + "K0+grIQ6FfuK35WK/m0268WMuqTmbQkZv+R+1AVjzoINDkAXL160b3/72zPtuHDhwozAYKaT0vJB\n", + "Cs/u7OzYM888M1MGz3tey74P2CEA6wz14Gc5KwPatri4GOqAvVA5v3C8Lp+FwOz44DAej0P/Xb58\n", + "Wa5x763b6XRC2Zjjm5ubM+R3tJOv+7LRb88995y9+eabjXJLoeaFX3sqOvnTp0/DuoGn7vXr1+2N\n", + "N96IloX3Mck9tX4XFxfD2CJNGyOVCqrRpuwdFRUVFRUVFRUVEn8qNFJ8sp3X1ZOl7NPQcMUAKfss\n", + "tV45eA0J9xnarrQGnU4nSFjQQnW73SC55UI1QJ2NMm7fvj0jqeJ9XvLNaXLQl7HxwvPqOpsXcupn\n", + "syNppq02MaeRggQJCYjNH5Cst7a2gmTOZkT0KcNH2X/ppZfsT/7kTxr3Ybxg9mOoNmLMO51OkAw5\n", + "Kj9McZBg2SzA2k8gpS7v9Xoz0mkM4/E45G4sxcHBQSM0gArF0ev1GhqL2BxR5k9I1D/0Qz9kZma/\n", + "8zu/U1Q/VYaaO7HI4NBm+phV/EwsunuqDhwziESDAAAgAElEQVRvyM8Pte9yuagfP4u+vXr1atBI\n", + "AY8ePQrxgz70oQ+Zmc3MYX73tWvXzMzsy1/+cvgNmtKf/MmfNLMjjQO0Upzfztefo6fzv9izPvrR\n", + "j5rZrJkZzz7zzDNhL0T9YCJjcDYI1iTiPdw2jAM0RAz+3qUS1D/33HNh30YfbG9v28c+9jEzO9J2\n", + "m80mfMd9GxsbyZhY2LsuXbo0E9stBT+XOYwLz2OYREs1/8DTp09Dv6Mv1d7/4MGDMBd8CA1GyZmi\n", + "aqQqKioqKioqKubEnwqN1EkCjjFh2AeyOwuN1ElyBJ4GcvZetJnbDmmMg6oBKtt5v99vaJUmk4nk\n", + "ukAjwIRRz4dS4PxxqczhV65cCWXgPuZDQRqPaT04VxPfHwPuN2tybpi8zvOAo1KbHfUJ584zM/vI\n", + "Rz5i/+t//a9GeZ7wPB6PG5rVXq+X5OaoOQkJjaVU5pMxRwTl/sW/+BfNzCSPAe0YjUbhWcXNAra3\n", + "t+2b3/ymmaU1UpcvX57Rcnkw34iJ0V4bxnXBePksAR4qIjvu4z4t1USp4IwMNZ9UwGDFh+IsBrg/\n", + "FZ06lSszppFN8T8h6V++fDloGjB37927Zy+99JKZmb3++uvhmg8Oa3a8Tyi+lCoXWqqPfvSjQcsC\n", + "rQeTjaF16fV6MpApygMBmjVSeMe1a9fCPECdmV8FTCaTmSCyqBP6CP28s7MT6qXmxGAwaATdVH3w\n", + "5ptvBq0t+IQPHz4Me/f3f//3m5nZf/tv/62xl6r8iQwE4t3c3AyaQ69dLAHax5YQ9A002xsbG42c\n", + "jDGUWnx8JoR5LUXfMQep0lDubaGSjJYednJ18h80jlR7lkip6tn7iz9A3uuMoQ5XTLiFeQmLcGtr\n", + "a8aLxOyoD/A3+mAymTS85/hggA2SzS4qtQYDfc3pFHAvFstoNJLphVAHbF4LCwthM8XHPFYuDh7q\n", + "sMkRjdEHbBJLmdhwkMEm5eEPGd1uN/QB+u/u3bshibNS0/PmgTkBkjsfpPiAizJgfnny5EmoCxN7\n", + "/bM3btyQh29/QN3c3JSmBPQRri0vLze8ohhqbfI8xgeGD4acXsYT1flvPlh4oYvnLObE8vJyo+18\n", + "GMK6UIl4VVt4fvq0Rfwb15k99PxHk6Pd8/rIJQoHMN98Si6z4w8uTEFmx1HAt7e3g6caAx9V9pjD\n", + "+mPTjZpPADxCf/qnf9p+//d/38yO++j5558PcxXzc2lpaUagMTs6IGGOxcjjZkeHqx/4gR8wM7Pf\n", + "+q3fMrMj72GsEV4Xvi+XlpbCPEG/3L17N4wDr0OAD8OYs7u7u/KQ4QUfbjMOrxsbG2H81TvQLxsb\n", + "G2E/YWoE2pf6Lg6HwxlHAQDtxLxfXFxs9NH9+/cb5t6vfe1r4fpf+At/wczM/uAP/iD8prwZGWhH\n", + "W3qARzXtVVRUVFRUVFTMie8YjZRXG5+WZorf47UNq6uryaTFKp4Hv8O/r9PpnCmR3dcrdk2ZxDiv\n", + "kNlsbjRoGvb392dMV3gfJEKOQaPaB+lJxa2BdLS8vNwwu02n02TMHtR1bW0tSLGQdliCRJ2UdMfA\n", + "9dh9KA9SzNLSUng3a5p8vKnBYNAIxXBwcBCkSWiLWJ2O+pfOl8PDwyD1w6xw9+7dMIaK/MpAHTAP\n", + "GKjLzs5OIPh+/OMfNzOz3/7t37b//t//e/S96IvV1dWG2QjtN0ur7MfjcXCFhrvy06dPky7ROcDc\n", + "zKE9UAfOAae0uyoHHMB58DCfY5oTH5dqb28v9D8nafXm5a2tLbt+/bqZHcdN4zWdMs91u92GhP70\n", + "6VNpOikN2YB3oz1Ke8MaM+wHKysrUlvgf2OtMb/Hk5x7vV7YB6C5/JM/+ZNQns9ZyGXt7u6GdY91\n", + "9PLLLweN1Oc///mZcsyOye6vvfZa0JgweH4Dnty8ublpN2/eNLPZdZta/zzHWOvpwwscHh7K/RO/\n", + "Ye50u90wdtD87u/vhzJQlydPnjS+MZ1OJ2iQVMJtYG9vL5gXWWMO8N7/4Q9/2MxmQ6xA64V/r127\n", + "FrRKwM2bN4MWU5m+OQemd7745Cc/GUyTGHPOfRtD1UhVVFRUVFRUVMyJ7xiN1FllsGZpy2sLSqOv\n", + "M1GdwWRfvO8kka098TVWbg6K9+HBrt+s8UHZqSCJ3KeQ6gaDQZAOU4HOdnd3G1GnmfcD7s7CwkKQ\n", + "8CGdeMkEKOXXld4HSU4FcVNgDaAn7vf7/RC4MRWosrSs4XDYiE5869atBlE4FhwSv0GDdfHixfA3\n", + "S7VYj9CcHBwcRPuf0e12Ax8G47a0tCTJ30qjC6kYayEXckOBtSc8NqxhMotHLvfzhLUFnEEA70Gd\n", + "VXgW1rayBglrAHVi7TjPT8V98Xwofoa16ABL6F4juLS01Ojj2NxBnVM8QdYkod2TyaTRL6urqw3+\n", + "3+HhYYO/dPny5QYnr9vtNur8uc99zj75yU+a2XF4jjfffLNB8FcEc9bOs7YYcwfr97XXXpNkZUUA\n", + "5wjjHhgDDhURc3ZAHTGu/X6/oeEcDochi4DSXEIDtrOz0yiHg81CM7O0tBQ0VtDajMfjMF4pztpg\n", + "MAh9CI0TRw7HHN/b2wuaqJRTxO3bt0PbwYcbj8eNbzi3Vzmv4Hu2t7cXHB8wN9jKEMN3zEHqrMAb\n", + "jN9s9vf3ZzaZNhiPxw1SKh+G5qmnJ3Cf9HCpzBWY0IpYOplMisnyXh0cM5F6UwIvFixqrgsWbq/X\n", + "a9TlwoULYSPjDUEdjNShiU1wZkfjpj7YODygzqXjsLe315gTvV4vbHzqcIpNKTf/8N7xeNw4APT7\n", + "/bAp4N/9/X1pLkA7UZcrV66Efub3+ojAMYK0go/GzKpzlKE+Ptvb2yGWEOJrzbMG2Lyt5oGKfJ+K\n", + "sRT74Pm1vrKyEuY3j6dfzyrq+OPHjxv0Br4vlR5DUQ8ODg4a5iXen1CXzc3Nxoc5ZupTcel8nfmw\n", + "jXLX1tYaB5DpdNowrR8cHIT5i/2EvfG4vcBzzz1nZkeHJqQzgil4Z2encZDa398PcxsfUOUty2C6\n", + "g/rYY01xP+LdPL+wn+Cgcf369RDjKQeeV/hmoW3379+fyRIBsPMN6oA+54OZ32en06n9uT/350Jb\n", + "zI7G0sev4yjxXE+0Dwel8XgcDi+o5//4H/+j0TYFXovoZyVc3bhxI8R1S+HJkydhvP0+n0I17VVU\n", + "VFRUVFRUzIk/8xopSHJ8smVpFa6okKx2d3eTkbKhzeBccCwFzKuRMjs+mXvCdxtwXUrNgmhTm9AN\n", + "yuzhESOlp6DCNHD9UuZKjhXkNWG9Xm8m+jLKgHTDIRR8NOF+vz8zP2Jg8xHquba2FuqlzDSlOQuZ\n", + "nAxp/c//+T9vZkdmEk78apaPAo9/33nnnYaE94M/+IPhb5A6S6O9TyaTUDZL/pBmYbqNSY/etX7e\n", + "cCIq8bDXnqgI3rE8eMr84PuYTR4cdsHnPGSND2tMvCYo5djCYG07a0D8uE6n0xlHEMAn4uVQMaoM\n", + "bje0jfgtli/OjyPfh3V5cHDQ0A6ovTDWF//5P//nmf+/fv16cJ/n+QAHit/93d81szhlwNe10+lI\n", + "zTG0T2jH9evXg4kNfTYYDELft8nx5sHfJ2gcp9Op3EfQl6jf9vZ2Q6uo5vve3p599atfDdd9uVgL\n", + "V65cScaUYjMp1nsJsTsHpR0/PDwMWjSVJB3odrtz7S1VI1VRUVFRUVFRMSeqRur/S1Z7e3szOfvM\n", + "jiRSH/BuOByGZzjKrnLZB5gc7kmX83A8cNrm03MpmGsF9Hq9GekF9YKk3FbqjwUF9JwYzgQPrKys\n", + "BII6RzbmvG0AXL9Rv0ePHklCvu9rHkPUZTQahbFml3Mf+XZ7e7vR591uN6mJAtiFHfXkHFqpSN8x\n", + "gq/ndTGfDITQr3zlKw1SqpkFd2sOeAhAWmXJDlqvZ5991r7whS/MXC+dI6x9Qnvv3bsXfvuu7/ou\n", + "MzviOajwE8zxwvtKwRonxbvw4So4snkq7IrKycfA2AwGgzA+0D4uLi6GflDcDvRrjHyvNE0eKro7\n", + "R/dHG/v9fiPcA0v3OQ2YL4OBEAFqrm1ubiY19Zh3m5ubRfPswoULQQPDdYHmCFYGXm8Yo93d3WIn\n", + "IwAaq+eff74xH9nBAGvqYx/7WNBIAd1utxGewbdVBez16HQ6je/Yyy+/HCKxK81xymEj9n3xhPKN\n", + "jY0wTmjbgwcPwringuaW1mU8HifHH98wDvqK9XZ4eBj2FkBppnLc2hj+zB6kFPnOdxybYrza0mw2\n", + "sjHex2p6v7nxJD4NL8SS+C4KyjThyeC5tCJKzQ81O3sn4gM5Ho/DpMZi4f7A5sZxXNjUho8+PqSj\n", + "0SgcrnhR+zovLCzMmOoAb2KIpQbAs2xS8oer0nHgZ9k7Dgs/lZpoNBpJ0iPex95niLWEcYGXktmx\n", + "SYk3Gz4sYB6rOsDz53Of+1z4YGDMSzcdThTKfe49165fvy4PUrieiu8WA/pIpQgya65TZdpTODw8\n", + "TApGylwGKJPd2tpag4zMf/PhKUV85/v9sxyDiFPiqJhWCr4tqi5mZUTdra2tRtwy9hbkvRcfUh+T\n", + "jvGRj3wkHKSwR/CBBu9l8zFMchcuXLA/+qM/mnkfR9lmUyL6BoeE9fX1xrxS9bt//35Yo4iBtbu7\n", + "20gz5PtOHTbVnMJ4goR/48YN+57v+R4zO05QfP/+/eI1672J+/1+w4R5//79YKrH2Dx+/LiRmubR\n", + "o0fhujrsptDr9cJhUqWuYeEKfckx3HCYfOWVV8zsaB7w3sjlMEr2gGraq6ioqKioqKiYE39mNVIp\n", + "NbRXeZvNuiYr6Y6TH/v3qoSoHwRwO7yJgLU37FoPaYk1UmxGM5tVSTMJ20vAo9EomNZ8dHQz7fLP\n", + "rrqchBj1hJTIdVa5AkuRigGD982jXVTxuLgdbFrBNSXdc0RmsyMtGeLaqPaCzP3ee+8F8xLa2O/3\n", + "g5YN489jifufPn06o0EEVB4/j93d3TB3lDkUkqaKrM7Rk1OJinPguc3zza9rdc3/jv/HOLBGR4Ur\n", + "8Dg8PGwQ1dn8yaY2HzpDmSEODg4aDgVsFlTP8rgpYrmH0j4xbYGfQZugHWFtG7C3t9fItcfjj71h\n", + "bW1txgxpprU0MPlzHzAwVkqrORgMghbLm6DRTrQL2hb02be+9S372Mc+NnOfwu3bt0P4DobPxsDx\n", + "q8z0fsjZJGLXvva1r9lHPvIRMzt28OBwC7yv+P7lfZtpKdhHmIiPdY/I5ltbW6Evsa/s7e2FdkIr\n", + "zqFseP75LBWbm5uhDn/tr/01MzvKq+ctHJwjk8cf2ieUsbq62nA66nQ6jX6v4Q8qKioqKioqKs4Q\n", + "f2Y1Up5YGoNy8/USpiJ9MgGVr5Wcbt8vKK6FkqRY0zQPud3sSDJQbrQlJO3BYBD6XN3PweO89KSi\n", + "7HY6nSDtKCItwBo4lmzm5bcpDcfu7m7gWEDLs7q6GjQvIKMPh8MkLwjvW15eDnVWfQXJ7+HDh0Ei\n", + "hKSbC+OAPuj3+6EM1j6VkHS571hLgr+huVBu7aw5ZR7QPNqpkkCbqWuoN7fDbJbr5Z/Z2dlpSMCK\n", + "9H1wcCCjnat8nkDKGUJx8xgYQ3ZeyYVTUGPtf+NxRRkbGxuSwO+1AHfu3Ananddee83MjrRATAo3\n", + "O9awMNjhQoX78IFIGTyfVZ5F7pcf+IEfMDOzL3/5y+F9WF/QqG1tbTXqsLW11Qh10u12G3uVH4OU\n", + "Rp3Xkg+qurW1FbQxnGsT8xf5Ae/cuRPGBFrK3d1d+c0CZ5WBfkf53W63kRXh6tWrMzn7zGbDh7DG\n", + "D3WAhv2dd94Jz4DHdv369RDYk4Mcp0jp0Iju7+83LA7T6VQGo87hz+xBCuCkj5h4PBHYRGR2NOg+\n", + "USR7uOGaUn8Ph8MP1EEKKD0ccWwsZfLynnBms2Rt/3EuLVd5RPHG6+OvxOrH5fpNklMroB2x6N8n\n", + "gVLF+wjuy8vLoQ99ShkPzDfc1+/3wxxTh0iORI6DG6dHUMRob8pcX18PhzrewFVfeXLoZDJppGLi\n", + "6MkqThgOk3xIYEFonoNUydzL3cMemH6+8YGRY0Gxuc3sqJ2KqK7Iyt48Z2bBJIYxZAGO36vMjN6D\n", + "NLZm1KEzZqbMYXNzM8xtFgzUx8vPbfaiTAkLHA1cHaRia8nsaI75bBZ7e3vB+wxr6uDgIBzi2AyJ\n", + "yPuI1P366683HDim02k4EDCR23/8d3d3Z8aw1PHB7zGHh4cNcjY7BLE3M+qIsel2uw0z6vb2dvib\n", + "D6Uxhx2z4/V8+/btxnybTCYzacjMjvoZBx41XhC4ePzxN6cNwns5vRSX29ZDM4Zq2quoqKioqKio\n", + "mBN/5jVSQKfTacTxODw8DKd1SA6K9Nnr9RqSvMrndZKI5B8U+DaxJgdSx/b2dpBivKbBTEvAkKz3\n", + "9/dnYn/EUGISRD19Pi3WrKl3lpruWFuE9paGQlDSJRPGfXyomDTqzUss7XL8Ik8ev3HjRkMCZscB\n", + "SNkc+whQGpirV6/KWF9Km+gJrTE1PJs18RwkZmjd+v1+Mv5WDKUJqn3mAxVKQIUN4Hqzy74i2vv5\n", + "ppIb43mz4z7tdrtBE8WOHEqb5dctz1M1t1KOKLFYVSlCO8Bu/tweFdUfmiVoTh89ehTejfmpknm/\n", + "9dZbYT9hrSznnjM7Cueh5izezeRuhP7AuO3u7ja0NzxuKpYR0O/3wxh6U68H6ry5udnKcsD/MtD2\n", + "CxcuhDnLoR8QcoQTUGO9og8mk0mgI+TWnp8z+/v7yXyEnCAZ9UrFaFM5KLe3txvhMZaXl8O70dcp\n", + "DVpbVI1URUVFRUVFRcWc+FOlkSoNoMfAiZVP74rrwTnSIElzlGCACZT4Haf20wjCeVLEAucppCTL\n", + "nITh2zoYDBpRqS9f/n/sfVmMZPdV/qm9uqr3np5uz4xn2p6xPR5P7PGS2CJWzBA7JgRCpCwiUQQP\n", + "IQ+8RUECEQkwL8RIIERYJBQQL0H8o0hkIZKJIRhHTnCM7dhWbMbjbezMjKdn66V6qb3+D6Xv9HfP\n", + "79xb1W3DxNH9Xnqmqu69v/3+znfO7zuzeoQYluPZs2dd5fDtio+i7OVyOZJPT6TfRyxnEVdHBqzo\n", + "YrEY8bvjHhgTgyw0L2bDlqHVagXxK3FWmR3vGxsbGmeAv9VqVeMNEJ+ytramljQs8Hw+r58hJuS1\n", + "114Lnlmv1wMrcHZ2NlBr5npyvcHQePOB289j5Wz7Mmu8HSTNAWaQkw43eMHhPCZs37RaLRUDfOaZ\n", + "Z4LnWeZnUJm73W5ifNOggHo77nieceygt0ZaRpe/44BwzAv0/8bGhn4PRiCOGbIHLlj+AsHOcYci\n", + "7JiYnp4OGIipqSn3uYAn58H1RHwQ5szY2JiuY97BEI41shIMY2NjOsc5Rgv/Xl9fDwLy3wpWVlaU\n", + "NcNzPVaQ2xeq9Pv379dyoT9YtBTf3XzzzVrnp59+WuuUBHzPQfFe9gIW1LZr99raWsD0eeK+Hlhi\n", + "A+8mLkscfqY2Uvl8ftsbKf59UkJXDiLHAoSB02q1Ii8jkWhqkmFOwvxfYVhXRiaTCdoyl8sF7gWv\n", + "vUulUqBHk81mA6Xic+fODZ06AAsnFqClpSWdJNyudgIxrb7dF26xWNT6oi/X19cHLgZJ92M9FQAb\n", + "TB5P9mSoVRcGsNijP9bX1+WGG24Qka024EUdixzrvyAwljdXSYrla2trwcvec1tnMpmIZgvqbdMu\n", + "iUQPeKC+aAPUrVarBXOI1djjkBQsnWQkdDqdIPCYjTX85SBdL4sB+iiTyegGioN07cas1WqpFhI2\n", + "p54rml22nmtxUH29JMi231utVuDeLBQK7hppx2qj0dBycVooO5aLxaLbR0jpgVNZlUolOM3oGS6T\n", + "k5PabjAmrr/+enn88ccjv+M+uv7660WkHyyOzRX0kNbX1/UzfqmjrfDZwsKCbqT4JKzdiDYajUjC\n", + "bpH+eMBGj+uEeXPu3LmhwxmGBZ4H1fE33nhjqOveeOMNLRfWRzZYUffXX39dXazWjcg4evSoqo7b\n", + "ssWB1w4+jAAkHeriTSDWY7yb6vV6oIA/TFqi1LWXIkWKFClSpEixQ/xMMVJvZcfOUgee9cYWOB9d\n", + "ts+2AesiW9bTICZjWDfT24Wk4FFO2AuUy+UgpyC7ujjHkg0o5aTQ2y3fzMyMWsCcH4utobgyiyQf\n", + "745TbkaZtyt/EMcciURzcQFe4ulMJqNlwJgZHx8PpARKpZLeD+XM5XIRnRSRKNMAC4xx+PBhEelT\n", + "99CU8SzCQ4cOiUifIQADizb1XCTsRka7rK6uBswgs5/M3mJOYXx5fTU2Nubqc3FQtXXBs+vUyxkJ\n", + "tNttbX/Oq2mf1Ww2Azbby+02Ozur9/Pal+tnmVqv7q1WKzhI4bV5vV4P9Jds3QEeRyJRto0TvFtw\n", + "MK8n48B9ZNnLS5cu6fcsGwDWjo+rA1aLiHHVVVcpIwUm23OLMVN79dVXi0jfpf29730vUs9cLhdh\n", + "cLncjOnpaXV/4fmVSkWfwwH/ds7zuOJyoa12Et4wCKzxJyJy1113BaxdHFBGLxsD/8bLaQngXbJr\n", + "1y65//77RUTk4YcfjpRtGGx3jeb3sH0nMPu0nfZOGakUKVKkSJEiRYod4meKkRoWcQHX2D3D2u71\n", + "errb5ViEpN0y+8FhEXKgMnbAcUraIn3LK2mXPezRbQYfB4W1yXEp+DfiVzwL0suh1mq1gmu57DZ4\n", + "VWQrXoJzIjHwPFiRKysrbnsw44JneO1qn+H1fyaTCeKXvJgqjsOLC7CNw+joqBvQ6cV5wFoD05PL\n", + "5ZQtAiOVy+WCo9XValW/Z2sdMTdsjWGc43ftdlvjQk6cOBGU5d3vfreI9BkpfIZ7eOKf3BcY2+Vy\n", + "OYg54HZEn/OBgCTZkEqlEomHSArYZqFKOw/Z4se1HOvniW+y8KEdn71eL2CLLl26JAcOHBCRfvwI\n", + "yoL7cH94Ae025rLX6+m9PQV0ZsltMDzLGniMLceB2bbkY/JApVLR4NwXXnhBLLyYFhZ4BDiw14pI\n", + "NhoNjW/BdzyWMH95Trz66qsiInLttdcGcWTMoh48eFBEojFQ+D1ndMDf66+/XvsQ4PbDWNu7d28Q\n", + "eH7ttdeqcCcQt5azcOd2FbeHfU+A/Ww2m0EM7LDIZrMaZ3by5EkRiYp04vAKzx+MiVdffVXHAPpw\n", + "enpa62vHwduJpPgnux4k4R2zkbJ6OrwQbBfeiRovzYN3CrDT6ehvETBYr9cjAZZcTjxPpL/Y2Xqw\n", + "qjNTv0nuqDgdl6TfscsDA3jY4Gt+SXguO6u/lMvlguBhTn7Jgbl4cYNab7fbusjgfnGbSpsEeRDw\n", + "shkZGQkU63u9nk5Y3G98fDxImeKl4CiVSkOXxasLXqDYqLZareAZXtoDb2HN5/O6WeLf48XH4wRl\n", + "+e///m8R6S9e3gKKDRwDfbNv3z4R8U/3MTBn9uzZoy83DxgPi4uLOnb4pW1fDpcuXUpU2eZNM282\n", + "+FAF/54/s8rSIr66NrtOeWyj/VGnS5cu6UbaUzPHJuKGG26QJ598MvIM3tRxOe192BVnQxX433wC\n", + "0guaZ9hNBOs5AZcuXdIXKQPjCRpES0tL6p7HS3NtbU3d1jw2PDVuPNcLk0B9WVsKm5hnnnlG7rzz\n", + "ThER+eEPfxhciw0UzzuUr9vtBhvHZrMZGJYXL15UVyJcfJubm8GGet++fcFGiscB2ur8+fP6XFYT\n", + "HxasuTWMZhK3N6u1J23gOBMB2vq2224Tka2TeiJb74vdu3frHMC1XpB7vV7X92vSITCRrX5nVXQP\n", + "2OjDJbtdXa4kpK69FClSpEiRIkWKHeIdw0jZxJ5xgWDD0JmDWAN247ElivtyYmKRKKsEsPXAFp1V\n", + "wM5ms0EQZy6X2zbb5lnWbDXybh6Uta2byBZDk8/n1SphNV/c03PzAZ1OR60IlIeD0lnDCdYBB25a\n", + "VVqRLevw1ltvFZG+pYkjs0l9PjIyos9ltyXXCWW26s8bGxtaBquHIxI9cj6MG2pzc9PV18IRYVif\n", + "cUHunlsQAJuRy+Xco7+wuMGO3HTTTWoJMkMQFzQuspWcVWRrjqDs1sIWibIoCNa99tprY+sgsmW1\n", + "8/xhloyZUJF+vyXJlfR6vUDHLU5vzmOJkgLjWRbAMsLdblfLCkufj7hjPPP90Q8bGxtBWZiN4vXH\n", + "lq/ZbAZH6/k3zELZ+eJJcjQajSB3WzabDZ7b6XRcKRMvPyDYJLjpRLZyMkLqgMuPecaJu71Aec4u\n", + "sXfvXhGJslNgejz88z//s4iI3HffffoZAsaPHj0a0f0S6Y9ne7DkzJkz8tGPflREthippaWl4F11\n", + "5syZSFJjkSgbxP2Audzr9QI9o0G6iey+ZlY0DiyngXKVy+WAEapWq0GC4unpaR0n+K5arep7AvW4\n", + "fPmyylp4awar2GMtGBRMjufi2lqt5npbsH5ibFy6dGkoaYNhkDJSKVKkSJEiRYoUO8Q7hpECBrFJ\n", + "22VyvOA6WBq5XE6tJlhHnU5HrQkOlrRWWy6XSzwybUU9GTtRavYYOu+zUqnkBoBbpsyLfRKRIFDd\n", + "i1XjZ3jZuYetC98X/YNARmZn+Li3tTD4aDpYAGY72OLzWAXuT1s+DiK1TAmDpQxsDBJnJYdFhczl\n", + "jMuXLyfGxqF8XH+PqUMfjI2NKZsEluSVV15RyxVSB2fPnlWmhKUn7Hj3LDseN6j3oMBR9OvExEQg\n", + "yJnJZIL29eIdGax8zHFsXgwiM1b2O/7Msr+5XC4SV4nf2bWlVqtpvBn3Mdoc/bC8vKxj1ZMcGKSA\n", + "jrWKWY9BCvl4FuqE/uS4KY4Js3IC+XzeVbYHOCcgys9xTla9mtkMDv5HG3lzHv1VrVbduYLyMTtj\n", + "++iNN94YKhNFp9PRYHOWBbGsMSvvY419+eWX9fAHrz/4ntvCk93hMgyD9fV1ZbMQJ1Sr1YL1uNVq\n", + "BYLG9XpdxxGvhVbqgplsTyoCv9+/f38sey0SfR/i30kxUocPH9aDMZxDEdd6quhgKcfGxlRYlPPv\n", + "oa1wj2Ha+R23kXq7kBSJz5osXsAmOrgay6EAACAASURBVBQDjE9U4LtSqeS68YBhE61yOXcaXM+I\n", + "28x4wdIchCoSv0GywbyD6FK02/T0tG5a4dZaWloKFrDZ2Vn9nhcqq2gdd2Jv2PQAANqiUChoG3jt\n", + "xpuYpBcUn+S0aDabugh5WjcYJ5ubm5EAUHtvvJQymYz2F2s3AVgkxsfHXVfMjTfeKCJbfeglha1U\n", + "KkGKCA/eAuRtEj2srq5q/3qpNfACjJsTfCLNO2Vpy+alRxEJlfJZb45PtnmLPdqG3XToJ2h3nThx\n", + "QjcZ6Jtms6nP4/lvN3g85tjVZU/R8jWcpikpkTHQbDaD5+bz+WAst9ttPY0LsGuX1b1tm05PT+u8\n", + "Zq00ezjl8uXLQdqWQqEQbKTiDk0ggP+zn/2siIh8+ctfDsZBuVzWzS42BJ67m09WY36Vy2V59NFH\n", + "tVwi/bXTO9zDSbfxnTdf2IDbaUYFka2TeXv27BGR/lhDW7POFcrF4xnjiDcd3rzDmoB6Tk9Pq/GF\n", + "eR83XzFO5ubmRCTq2ktaW0+cOKGbQ4yhyclJXUs9dz3GFZ8qxNrKm3VPMT0OqWsvRYoUKVKkSJFi\n", + "h7jijNRONJHeDnjHy+3Os9lsBlYbH4nGd7lczmWf8AwOruaAzbjnJpUzDt7Om8Fshy1Dt9vVcns6\n", + "V7C8ms2mqxyNf7PlgM9gffZ6vSD/HVvMHHgKSwCurtXV1YDW9Y5qVyoVrb9nXSdJSoiE7TKsK7Ld\n", + "bgcJqr378v3YsobllZQgVyRZzwv1ZlaA2w9gDR2PObQHArzxtLGxIdddd52IJAfADwKswGKxGFDw\n", + "rAmGscQq0UChUHBdz8wW2Vxxnkub9Zfw3EKhEATu87jia71E257SN8oFd8T4+LjWifsVfcdjA8/m\n", + "53pMmA2G5+Bw7nN7LJ/BLi97P5aP8K4BZmZmlJHgdkvKg4ZAeXZlsz6UF0Jhsbm5mXjog/vDrhOL\n", + "i4v6DHbZAZ5rFowV54xj2QebpYCfy+8Nuy5Vq9VIWyUFXVuNMRFfSR39kcvldIzBxV+tVuXFF1+M\n", + "PGtkZCTI2Tk6Oqp9zWs46gdJlHK5LLfffruIRMc7B4WL+G7BiYkJHZe8tg4KIRDpu2dRJ/zl/vLe\n", + "qcwec6LoYZHISP3kJz+R48ePy0033SRHjx6VL33pSyIi8sADD8i+ffvk1ltvlVtvvVUeeughveaL\n", + "X/yiXHfddXL48GGVe0+RIkWKFClSpPhZRCIjVSgU5M///M/l2LFjsra2Jrfffrvcd999kslk5POf\n", + "/7x8/vOfj/z+hRdekK9+9avywgsvyJkzZ+Tee++VkydPJsYDYSe9XSXVtwuehelZsxynYWNzstms\n", + "fobdcz6fjwRnikRjrlg6YdigwSQMClBntsNjz6xlFqf+7ln19nf5fN4NprdHlguFgraD5/9Piqfx\n", + "rDO22j2wZW3rwWJ/+MsWNsdN4RruN3zG49iKkjJ7Z8cQ3yPuMxuXxHIUnP+RJSfwF+0Fi+7ChQtB\n", + "jFS1WpXTp0+LyJYS+vz8vPzkJz8JygXm4Nlnn9XPkhgOD3ys3YLXDC/mJ44BtHF9Xo5HHtteH3oM\n", + "KzM0NhiZj40n5ctkBXQrCMqoVqsa14f4j0ajoe3Ac93ej5/Nf+1zisViIDXBB0e4PjYmLC6fJdhJ\n", + "lIXlAWDdT09Pa1CwJ6XivSs4+NcGvk9OTgZs5rlz57TdPHzjG98QkT5bYcUbT58+rXE6NuZLJPlA\n", + "yNraWhCv0263dd7yGsd5SUWiTAh+Nzc3pzIKHlhhHmOiUqmozAPmcrvdDuLSOp2O9gP+Tk1N6bxH\n", + "YL4nKLq+vq5K5ZjD3I547uzsrLYT+vjVV1/VeiZ5WziulQ91eED/o0znzp3T8mCdmp6e1vJ76wjq\n", + "sba2pkw5SzEMQuJGan5+Xgs3OjoqN954owafeo3wzW9+Uz75yU9KoVCQhYUFOXTokDzxxBNy1113\n", + "xT7j7dhEvB3g+ngvPg5eRYeymwsdwpsmb3Nj0zJ4gZv/m2BXCCeIBfjFnBSQm4S4TZ2dEKz+zOWz\n", + "7hl2sXA/gbbFwL9w4cJQ48mrb6VScXVLbFAzuxcGwepDvVV4CbF5UyoSfeGiLUqlUsQ9KxINIkf7\n", + "jY2NBfX1xubs7Ky7wOOFN+xGCuWr1WrBBqRSqegLhTWjAEv7A6g796F1e/MJTXYVWVeil+aFy+i5\n", + "1ZKSYHP5UJeVlZUgGTVvLPjfKD+fOrPGnzc2vXnLmQaSTvHGrWF2MzU3N6duIwQ0eyemPAOMxxi7\n", + "+AHrzmV4bsJut6vuIj65aNsZ89MCfcSGBq/XcVhaWtLy80bJu8Z+1m63Iy9zkX7f43ee4cgn6jhc\n", + "ApsgbCIuXrwYUcgX8ed1nCK4l9IJz8Bms1KpBAdPLl26pBs4BKqvrq5uO2ieQ2OSgD6fnJzUsrAB\n", + "hLrzCUG0Aydzx33Y5TkIQwebnzp1Sn70ox/ppugv//Iv5ZZbbpHPfOYzOmHOnj2r/lGRvq/UO/WT\n", + "IkWKFClSpEjxs4Chgs3X1tbkYx/7mPzFX/yFjI6Oym/91m/JH/zBH4iIyO///u/Lb//2b8vf//3f\n", + "u9cOSvg3DMPxdsM76tztdoOAPU7mC3AyVXYFWLdAHGthg7WHSYj4diBJi4PL7+UcA1jrJCnAnF1n\n", + "HGxuaXmPPWLXFKhVzlHI+jG4HtbRoLHEVqVNeBxnJSW5nFllP4ml4ntY9V92CwHsEmFr0DIz3rXF\n", + "YlHbCrQ6SyJ4bQQrenR0VJ+NoE/P4m+1WkHCVpHQJTrIXY82t6ySSJR1g9XIgdksw8HWvQ2M9nR8\n", + "ODjcSwrMLIyXsQDP8OYSjwnPFWfZrHa7rQwJrx1emwDMHHiMkaeH5v3GO3BjD8h4v8vn88FzvWDy\n", + "5eVl1y0EwA3GbjIe+5ZtGR0dDdp8cXExYFl4XnB7o8yeO4rhaSOBUUkKoajX6zru4F5bXFzUunM5\n", + "PTeVlT9ZXl7W+7GuFtBoNPQ5zAbZrA38b87QYNvSc5MOAspUKpWCvu52u/o96jE7O6vf8yGQJNYR\n", + "4NAYb71FXy8vL+v8YnV8lAUMU6lU0rnsBZbHjQ8PAxmpVqslH/3oR+XTn/60fOQjHxGRrZMImUxG\n", + "fvM3f1OeeOIJEelLr3M8xenTp1WOPUWKFClSpEiR4p2GBx54IPH7REaq1+vJZz7zGTly5Ih87nOf\n", + "08/ffPNNDUr7+te/Lu9617tEROTDH/6wfOpTn5LPf/7zcubMGXnppZfkPe95z1usws6QxMCwYrXH\n", + "DHnCmTZIXCTKZllLmL/3dtHe/f434cX9cIAygDKWSqXAOmXrntsLlhTHjsHygaW0k8MESSrY3lFi\n", + "htfmfIjAg8ekeHIPsJS9uC1mR5KOz9rg5LiyMCOCfyMWqdfrqZgj2mBkZMRVjuZDECL9PrWKxa1W\n", + "S5+Ba722jWPvuAxcxzgwK2xjvbz8j+Vy2bVcOa7GshPMnnhsAgdQW2Vz/h514v5g1ssbO7ZvWVDU\n", + "W5d4vcB98JcZBCvnwP/2WErvcAVf68mCeEHznpwDwPFEYAG63a6WmdkK3AfMADNSzALYmJtdu3Zp\n", + "IDMHZts1iduAWSqMHcS+xMWmep9j3iRJNzQaDc0jB0aXJSr4vjbnHYv/8v1w7eTkpLuegDXzAtoB\n", + "L/5vYmIiCJhfWVkJBE9FtvoO606r1QqYq2azmcii4vmXLl3S+3DMLNhJfm/Yuc5eI29t4bLb+cWH\n", + "xNBG5XJZ48gwB5aXl93+f+CBB+SP/uiPYuuXuJH6/ve/L1/5ylfk5ptv1mSxf/zHfyz/9E//JM88\n", + "84xkMhm55ppr5G//9m9FROTIkSPyiU98Qo4cOSL5fF7+5m/+5v/MdWUxbJoV3ijZl2Y+nw9OXnmn\n", + "WFiHib+zJ7Q4USjroNiFzKNd3yq4LMNsarzBVCqVAp0hdkNgkXmrJzCTEsoOq56+E10yz03mbb7s\n", + "Ap/L5XSx8V5GScjlcm4gMBYbaK2IbC1uBw8eFJFo0k+UvVAoBMrmm5ubwVgsFou6+OI7T2/KG4ec\n", + "zNuWG98nwW46+BnY3PFCjs+4LQBOAcNl8F4snuvOM3y8wwj8ArUuJ64Lb0A4Cbl9rgdeB2z5vXHl\n", + "3a/VagVuXO93/HLlQwlJCv48p7yXJn6Hcbe+vu6ms8HY9soFNz2f+GJY99za2lqwXnj9x2NskPFq\n", + "jederxdkrvCCq0X8uYn2wLV8chHYtWuXm2IH13gnW6+66iq9BuPE60NvM7y+vq5uQWzGer2ejjvO\n", + "ioC1Fn9x2IHBoRtJ6Ha7eviG1ySris5ufIADxj14G01+H2PcYS5vbm5qnVDf8fHxYNwhxCQJiRup\n", + "u+++27VIP/jBD8Ze84UvfEG+8IUvDHxwihQpUqRIkSLFOx1XXNl8GHjBjYOwXSYsk8kEsgb5fD5g\n", + "qfjob1LQNLsPAc+1x/pFnA/L0yV6KxiUtNQGCnuWaaPRcD/36G5rOfBxa3ZNWJdOLpdzNYLQ/4PU\n", + "ZllaQSQ+cTOXC9d5yvbe/e3vOp2Oa53aMcjX4rtisRj0CVt3Xi4u1InbnettZRI4XxratFQqBS7K\n", + "Tqejz01yycbNLfQNLL84QKcHbhqG51ICE9VqtQKmptfrRVgnT5fMMkLz8/PqiuLneO45227tdjvo\n", + "a09egPua5zUsYO7XJO0pgNucx0ZSsLmnc+XdD3VkXTLPbcgJy725YdlEri+PVbArniwA2paZfzwf\n", + "Ad8i0Xyoln32+s9LHM9gFsqTg7AJlHft2uXOebA1YKZOnDihEkJJ7nwvUTFL0Fy+fDmQhmAGCeN9\n", + "kJQOu4fBRHEOPWanAOvuW19fj8gZ7BTo/4mJiUDnrl6vu9IjSfI2HgvN71GrX8bgDAJWC2wYOZc0\n", + "116KFClSpEiRIsUO8Y5gpOJySiWBg7+TLD3eeVvBSI59SvKrs4XjSSLw/a21w0wYLJbV1VUNgoM1\n", + "PqxwaVx92XK1wmRcBi/A2xMoZQvOE0xLCthkkTkbBO0JmQ5SLGfYmAyvHxqNhrIiaFcO/uSDALYs\n", + "cUr0XkyWZc/m5+dVVw1tHxdHBSvIi0vBmGBGgi1vjnnBX8u2ViqVQBCx1Wqple0xf16sD89LlmXA\n", + "X48JscrLDDAXLG/BAcNJx55Rfy5roVDQtkTA+Llz5wLrlWMHef7b/ucYlCSxTl4T+OCAjdPiIGOO\n", + "n7TP9cZJHMNtGZdWqxUwCJ1OZyhBUY5VwfO8wOJMJqMHkJCbbt++ffpvjiuDpe+pjzPrZRkuZqTw\n", + "2ejoaBBgzfMT5eQ6egwDr7d2fnOfow2q1aobw4XP7r33XhHpM1KWXeb+wb83NzdVgxHzgiU5NjY2\n", + "gtikCxcuaO4/jO0LFy4oI4wyT09PB1kMeDwxq4RAfHx/6dKloD3q9XpwCKPb7SayYbwW4d5g4dbX\n", + "13Xeo8/j3h+Yc15QPebMxz/+cfna174WW5YkCZi1tTUdn8PKuIi8QzZSmUxmx8HXcUq/9vRKp9MJ\n", + "Tgx5C3ev1wt0pOy9udwi0VQs1vUUdx8Mbj4tlLSZss+KA7srk2jZyclJLRf/zkutYelzbgNvovFL\n", + "wgaPDwoSH5SCY9gNF07VMDCZWO8KtLbVfxLZepFms1mX5rcHC1g9l9vCujLZxeKlMEH5ZmdnNdgU\n", + "n42NjWn/okzsrkDgZLPZdE/3JbnQ7QZNJGpg2ID2XC7nui2T1KExDnbt2hUkRPZemrYMtt06nY6W\n", + "l/VrcB+8QNm1khR83Wg0IsriItHNhhfQjvvxxtc7Mctj22rtcKgAu8PtJoyzBfDmBeWDunen0wkU\n", + "9/m0LbC6uuoefLDzbGRkJDA2eY55ekjssuMNHu5v14Jnn31WX/Q43eeNB0794p1C816MnE7HzgHP\n", + "DRq3Tj3//PMiInLgwAH9zGYBmJiYkKuvvlpEJCIXhHKxawlrRrPZDMrFfYjTgoVCQdsE97t8+XKw\n", + "KdjY2NC2RL+22229H8aJiLjjyep0VatVXT8xLzzNtVwup/OR72fXLA/tdluf6ym0o5w/+clP5J57\n", + "7hERkUcffTS4j5d4Gm22e/dudW/iWcOECaWuvRQpUqRIkSJFih3iHcFIDdI8GfZagFWHmUVhut3+\n", + "ji0WTxHYUu8eFe9JLHhUPD8PO/RByY09BsNDu912WQfUGW6XpaUlN18RgHYZHR3Vz3HfYrGobgMv\n", + "aJn1XmxZPBcq18k7ypsUWD4IcBcwe8IMIihn/sxT8EW5vWPKuJZdCqylA5bojTfe0O/xXA7+Rflg\n", + "QYJNYYyNjalFCKttc3NTLXM+ip2UT80DuyM9GQpm3FBmD3BdeEfFAa8vW62WO755/tjrPFap1+tp\n", + "WZmJQhuh7ZkZ5PuifWGBx7E2tkysg8NzxZMpsM8dGRkJAp6ZpffcdJh7uVxOrXB28Vi2hscYM1O2\n", + "Tl6QO7MUfB3YFYQMcDu++OKLItI/xg9GCnVbWlpS5g/1qNVq6v4C4+SVZWJiQr/3xiCPWdQTbcCe\n", + "CYDrhX6OY/PRbw899JCIiBw/flweeeSRyG8uXLgg1113nYhEGSkweOzyRNuPjIy47xSM1RdeeEFE\n", + "onpT6POVlZUg/+Hy8rKr3I05jjY4ePCg5lBEP8zMzASs19ramr478LfT6ehcQdnr9XokmTruO6xc\n", + "zTB5aR9//HH57Gc/KyJb7ff000/r9/jMS2R88eJF90DLIKSMVIoUKVKkSJEixQ7xjmCkGIPihIbd\n", + "2dpj6L1eL1H9Ny6g3F7Lv7G/42BtvhZWAFs+NvZhEGswLENXKpXUEoDlwkHwnGSag4bxDFyLnbyN\n", + "sxAZfCAAdfesi2Hr4TFXzBZ6IqgePMuSrXHLcGQyGdePj3InCTeyT57lD2y8FseRWDE/vh8zoSyJ\n", + "gLKA6VpdXdU2QH9NTEwEMVxxCvE2Tozb1DsmbWO5LGDhIk7k6quvjljmIn1rEOMO7eiNNRGfyeEx\n", + "ZtnnQqEQSHawJAKL76JNWIjWSiyMjY2plcvsLVgvfpadx81mMzjAwfMR4P+Dqbl48aI7Dzx2zNYt\n", + "l8vpGPNYfk8qgg8beOwI2oMD2zF+ef183/veJyIi3/ve90SkL4eBWD+sL61WSxkVPghi5/Lhw4fl\n", + "xz/+ceQzZhkH5UtDW/E1llnjdsE48JhHka3YIjAgMzMzQRB5o9EIDjZ0Oh39N2IDefx1u91gzE5M\n", + "TARzguvBYxd9iJRty8vLWlY+YIRnYOyurKzomMZ60m63lXXCvM3lctomPFeS8lcyi4+1IimXHjOF\n", + "gwLAv/zlL4tIXwtTpN8PGEcssYDycVxaXOaGJLzjNlJJ2ImadZJLjN1unvYR/86e1uHfcICpl3LE\n", + "lpv1Q3ZSN+uO5PKza8877cSwaSpY0ZoDs7d7EGBQYuQkeHpedlMskrzxzGazEfetSH9Bta4zkWhy\n", + "WfzeJreO2/xZ9yZvHPmUJP7NitAAFjTv5KJV9eb68bWlUilIEDw5OakLtjdegLGxMb3G02dh4HnD\n", + "pj3CInzttdcG37G71HMLx40TWwdepPEi4JcPFlDvJJ9IcjA66lur1dzgV/tS4hehVw9eQ2wqDL4v\n", + "+m1kZCSiAYbP7EveC1SPc4PzeEO78ObGlpWBIF0EMYtsvaSxyV5dXQ1cuWxIJB1EEAkV1b3fr6+v\n", + "6wlCTy0cqFarrmGbFCIwSKXeGmYnT55UHSkGJ9MV6a8RdlzxeCmXy8GmaWVlJTDWeLzbwxoiIq++\n", + "+qqIiOzZs0cNGi4fNlze6W2uG1yFfJjIriOcHJxhk9fzePf0vLwTycPiscceE5H+BhLzm0NWMM7x\n", + "mbc5HQapay9FihQpUqRIkWKH+JlipHYC1p2xGjT8PWuAJCUjtteJRAOVAb6HtRK3s+v2jvd62il8\n", + "bJe1UESiOl1gRRqNRpC4lq1ittqtBcX1ZPrWHnu2/8bvbf1Z5yqJBRqWtet2u0GeuV6v59L1Htvm\n", + "WaNsmQGeZcPSALg/WA9PywptVigU9N4oE5cNv2fmhPN0oe/Qz6yRlaR6z+woJ4dN0mIBhu2P119/\n", + "Pfgsn88HVio/A/WwyV8tut2uWv3oD9aygdXuSSuMjY0FyVkzmUwkiB+w44QPUnjK/0lzwAsL8PTE\n", + "vHHIgdSezhXDBqgXCoWALeBgeJSBE5ozrCL05OSktt+hQ4dEpM9qIHwArBG7vPm++B3Xw7rVz549\n", + "GxyGGcRqAaVSKVjzOfzCq+MgPUOwrEePHhURkR//+MfuvEI9OBQB/cmJjzG+Z2Zm3PUE1zMDZ5nV\n", + "+fl5Xduwnpw9e1brCRaqUCgEDCy/79grA3YKbtzFxUUdJzxvmXED7PuQxx3AEis87rCOJamNHzp0\n", + "SJk3sKPnzp0LxjGvK0myC8MgZaRSpEiRIkWKFCl2iCvKSA0KDt+u1MGwiBNutP5vjpHi4G+bj4rj\n", + "dfheSXFOnuSBjYsYBp4Ctc3nFXdPvhY7fY+VSVI273Q6anHjeeVyOWCz4tgOK4LKbelZ7W/XWBjE\n", + "ZAAoC+II2K+OupXLZb0fs3be2Ia1iO82Nze1zdnatQH5vV4vovosEm1TtrJwLazjq666KhCy46D0\n", + "OHV1kSjr4al2M2CdbjdYs1wuB+OYcy6iXVZXVzXIFeWK60cOckW5vXgnVkq2zEatVguuYcFLgAUl\n", + "OVbKrhO8nvD6Y9c5jnNBmUZGRvQZ3O9oG09CgfPR2d83m80gBoXvC0t+dXVVy4W2RyyUBVgnMFK8\n", + "loBN4XUR8Uuzs7PKSnmyC8xOWObg/Pnz+lyoqMflvrTwFNq5DB7rBBY/DpivCJQXCZnDbDYbrLO3\n", + "3367PPXUUyKyFQC/vr6u45vlShhYe5kNtvPv3LlzOo5Z0NSuT5lMJmBgS6VSwOjityJbTHw2mw3W\n", + "GH6/e7n5mLmymRfW19f1M/wuLrOBRa1W09+h/by9Ri6Xk8OHD4tIX4Ee2L9/v4hE5WgG4YpupAY1\n", + "ytvx0oxL1eI9i0+04Hd28HKSYS+5JW+8LD3vqUD3ej2d9DvRQUoCT2Dv1CFrQXEaDpHoIsjtYTc0\n", + "xWJRr8HLcG1tLQigbjQawYJSLpd1sUoKDu/1eon6QcO6kNCXvDDj+a1WK3Alzc/Pa7t4Qat8msye\n", + "OhEJXR25XC7QKuIy4CXnuc44sJgXf9su7CLAPWZmZvSlit+vrq5u+2WTdDCDF9ztbqS4Puyq5g0U\n", + "gPb1lOlFtl4UvOijHfCS4GS6rCCOdmNXEq7BC6NarQZBvLzB402GFyyLNuRn2PHLc8HLLgCwO5LT\n", + "L7FGFeCNT4APa6CeuC+f1EXdSqWSu8nwTkAB2CjxCU30O58+RHtzPfhZmAOsTo3Tn9hIeSrgHtbW\n", + "1iJK74BXN2vwxQEvYdRxeno66LtcLhfMb14P0I7s8j59+rQelgC4/9G+XtYOEXE3SPbUdLPZ1BOh\n", + "WMvr9brOEdStVqvpaUisgRykjQ3V2NiYPsM7oe0dXkDd2Zjg0ALvIIs1gBYXF3UMcpkwjrHGLC0t\n", + "6TjBhqper2tf3HzzzSIi8txzzwXPtEhdeylSpEiRIkWKFDvEOy7Y/O1QNo+DDfaOUye3LhZ2H7AG\n", + "jQ3c9HbTce7N7bItg8BMCKxhlIutd3Zb2ABvDtLlgGdr7eZyOb2GXTb2ucMqajNYtsCOgWKxqM/g\n", + "HE+cv8uWiWH7h6ldT2uJlc0B7i+wFLDMWR+ImRAbRO65drit8JnHKDWbzWDcMqsAq41dO2izuHyB\n", + "NjDWQ6VSSXQRemAXhlWY5n9zni5YwnHBvlY3iJkyMAMe8+v16+TkpFr8sFI3NzdVroEDWsHWeBIL\n", + "3lrF84zXDJFoX+PfzEhinPI9+OAA8rwxo2EDkJmBYx07OwaYveNDJZ6bCW3PDCOSg4NB5HbGWOQg\n", + "ZzArrE4O1ogT6N56660iIvLwww+749b2sZdAWyScwzz3GCjfoLCLd7/73SIi8u1vf1tE+mMDUgLc\n", + "B1aeAcrkqCfgjSdgfn5eWTiAc1nieUtLS4FMQqPR0HcC/p4/f16fDXmDsbExVaDHenjs2DFluFC3\n", + "yclJZbMwrhqNhjJRXpuy3hzWAlYTxzhHG3hudZGtPuH8hZY1ZvcxK75jjmB95DAI1A1jOAkpI5Ui\n", + "RYoUKVKkSLFDvOMYqWGZKC8/3LBgBsmzwj2L38YOcdAvx5hYSynOyn+7mCiA41Y4gFmkb3XCYuGg\n", + "b8RJDauuPuzvOKv2sHFhNk6H+5XlHoYVB0XfwJfebreD/FGMQSyGB1sWPjYMcA41T7bCUwaGVclB\n", + "msy6wcLEZ5cvXw5YOY6HwXM9dtRrC89qr1QqQf97By64TmBYvNgHZkKATqejbcVB8xzzxuUR6beV\n", + "jf/jtvSENIG1tTX97fXXXy8ifYFFe7SaWTTOGWdjyrg9eH1KEsnEPTiGhqUzLDqdTkROgOsistUu\n", + "XF+v7pwbzZaBpTMYp06dEpFozkXb/ysrK6quDXmDqampIPiay8TH5HntAMCYcHydlX7gXJrMLts2\n", + "3LdvnyqQe/IxnpQFAyw0+pd/j7WGY7M49hLzAs8X2WKiKpVKUNZarRaJFRPptyXqjDYYHR3V9mIm\n", + "DOMWfVmpVLSNINbJdQLr+swzz+i9AR7b3PbsGUgCGCEwf0tLS5H1C/Wwh3V4jQBLduDAgaAe3A9g\n", + "3brdbpDl4/Tp09o3uBZsWRLecRspVKrZbA6VwHAnQCe1Wi03fYOnEmwl/wuFgpug2F7LJwy2izi6\n", + "2gM/1y6CnU4nUZcDGB8fD6haTnHjuWfYbWCfwfQtn3DyTjtxWUX6E48Xe4C1sUSip6fYdYJ7ey+d\n", + "YcEqvN6GISl9jp3AIlFNGCywvABgcWaXK/qDXyL2hXzx4kVdHDBeqtVqkL7D2/x7L45qterqJuHe\n", + "/PLy2sWmP7L/FumPG29M2vqKRF/c1oXFGzKeKzY5a6PR0Pvg9+12W9ebkydP6nPRZ3ySz75sWEMJ\n", + "4EBg7zSkF7bAIQM2PZOIr2tkle25D3kTbsMHuK3wXG+NiTNmbcqZSqUSuFg6nU5w8u38+fOBW2hj\n", + "YyNwfx06dEhdWXzYgJPQohzoV84iiAAAIABJREFUN+5LgA/P2LVw9+7duiZwmw67zmIziXHKp+l4\n", + "s+idNsV8RH9NT09Hkj3b+bC4uBhot9VqNR0TaLf5+Xnd4HuHZvg96iVd905p2hOhfLoTrjA+XMHZ\n", + "Pbx5bdNBZbNZnT+479raWvDOr1arej+0b61W01OCcAsykcDPt2XxDpgMo3SeuvZSpEiRIkWKFCl2\n", + "iHccIxWXLNKCLQjrihvWncQWPyucW8qeWRT+zqrmsg4GdvLbzVPH2I7bki1MTwsKFgPKNzMzo8F7\n", + "wCuvvBJYBFwnrzysqI3nern+gHK5HLgemdlIchsyNc1WsxfEC8Dq6PV6QRsUCgW1aPg4cFL5OQjX\n", + "O7LOR4P5viJbtDsncWXYZMTZbFatRU8TzKsvPmu1WloGPi4PizTJhc4BrfyXA7JF4sf2MO7yQqHg\n", + "uudxLefL4vtZ6QW2OD03Hn5/yy23yLPPPisiW5ph586dC8a0F2Sdy+W0H5iZsgmUmeFOYoFwT5Go\n", + "y9Zaz3yEnTMIePITSbn2UKZ6vR4cCGk2my5T5h0sADuCcb9nzx7tJ9YC8rSbcD/W0kNQP+YC9zMf\n", + "BOG1DUBbeQmck9bNcrnsfo+6J117/PhxLRd+t7S0pOwIz0eoiXMwvm17ZhK9+ciadmj7RqMR5Ow8\n", + "d+6cuqHf8573iEifOUMZmEHGs22iZQsv5ABlxHN37dqlcw6fLS0tRSRxUE8wbxgvY2NjWmbOWYpn\n", + "oD9brZaum2CSNjc3dQzC9Tk7O6vjB9fm83l3jUYZ8G6I081jpIxUihQpUqRIkSLFDvGOY6R2giRG\n", + "wvudxzTgWhaKY2bCi4fiIF78tWzWWxUdtWWOU223x1/jAOvz0qVLierfrKjsHceGFYayxIk02nbw\n", + "LL5hBTnj6uZZFF6OQq9sNhYgLp7NSmKI+OMIFlpSHi8va7tIOI6ZFeDyJTFR+Lu6uqptAOZobGxM\n", + "rUUICnp15LKyhIIV1Yurg9cuVsVcZMsiTAr+Z1FX1IHr5AVVe7m9nn322SD3GN8HiFN3xtjjeBL0\n", + "Nc8L2+9xSvhWRZ4D6nE/vhbzY3Nz02Wc7f04YBzPrVQqAQNfqVSCeRUX+wag/zlgGc+qVqvu2LJs\n", + "ZrFYlJdeeinyG7AWItH1BGsbMzhgHcCqD+vJqNfrQbxrp9MJMg14uPPOO+VLX/qSiESZMBbaxX29\n", + "9R/zHvNyY2ND477iBFnxOQsLY91mUUpISTz99NMisnVQQsQX2sX9OCaQwdk/8HubbaDVagWxSrw2\n", + "YK1pt9tB/lCvvl68XiaTUcYS44BjyxDvVigUIrF7ItH284DxZAPrPbyjN1JJGx+G1UuJmww2maEX\n", + "WM5S/Uy7cwCjiK83xfcedPpjWOB5LMufdNJLZGtg8IuKlYxxH5ygYO0RLw2IdTkUCgWtH5+y4cTP\n", + "eFbSBinp5CW7dNjtikUoKaAwn88nbqA8DKvCz/WJK7eIH8CIzxqNhrYVFlJ+QbPrE32JhdFzCYpI\n", + "8HLd3NzUxRX3KJfLrioygAWIg/XhUuDAYu8UHcDZAnh8WlcRnxbjcWDno33J4//cD/ZAA/cLp4NA\n", + "G/IL227C2ZDCS5r1mlD3bDYbJPHmwxUcFmDHOW82PSOF54fVcOMk0577zgt29xLL4sXHAcODkqpj\n", + "TWB3lQ14LxaLOkbhktnY2NCxj3Qvr732mo55e7pUZKvtX3nllYhrUiS6+cNf3rwkGVEXL14Mxkkm\n", + "kwlOuHlYWlrS58HFW6vV9GWNzRXPLcwZ1gnz3k/efFxdXQ1c8XxQBWVutVo6x1GWq6++Wt2QuPeh\n", + "Q4fUlYe2X1hY0OfhfpwSiceTPSm5urqqv8NGdmZmJtj8lUqlYH0qFovBJifOyLYGpve7VqsVHIbJ\n", + "ZDJaPxwS8DDMQazUtZciRYoUKVKkSLFDZHpvt2DRMA8dInjr/6oMXvWZQbLWrGcZ8lFiDnxkyhy/\n", + "t8F3mUwm0DfhgEwupw1U5wS/Xn2y2ay6KWAt8PHTJEX18fHxoY59MlD+arUaMG5e3j9+vsdSDAvP\n", + "XcHfXYEh7iayFvGPpAOcIBdWM6z2l19+WT8DC7S4uKgWFQIt7ZF7ANYw+qhWq+lYxHetVkv7PMkt\n", + "WSgU9BrUp1KpqBXLFqlFNpvVa5gRgGXNeRvxPAR/r62tKVvk5bdkFzueUSwWtU6YA6zqDuzevVvL\n", + "j7E4Pj6uz+Mxa3WQbr/9dnn++ecjdWfwtTaoml2HSWsSB6V7uftQn7GxsSAJNjO/ljVg5HK5YB6O\n", + "jIxEpCRE+uMEaxr6eH5+XiUJvABvgNsZ+OAHPygPPfSQiIjcddddItJnpHA/jPGLFy8GrNf58+cj\n", + "mRdE+qwHuxVForngOKgb7c/sPCeyRn2sq5jlLRCYXS6Xdb318qeCzd/Y2AjWqfn5+YhLGWCpExtE\n", + "Xi6Xta2ZDcb6wKEZ+IxZxRtvvFFE+rpQuJ93WAcsIcocx95YTSsP+/btU5Yd7Nfq6qqb5xLq6mDO\n", + "3y4vzk6A9TzuXZIyUilSpEiRIkWKFDvEOzpGapiAYZHQ0uN4DFjAvV5Pd+t87N7G9bCvnQPncA1/\n", + "BouQn2fz+LGgJft6YTHy870jzDamJS7fmed3hzWTy+UCP/MgNgp147gaWAyDAjs9NsHLb5ik9Ozl\n", + "t2Mrz2O40M4TExNqoXGMkY1HaTQaem/Ez3Q6HbVEOV8erM2k+CCRLf89ypfL5bRvmE2C1cbB12AB\n", + "+Bk2SNdeI9JnPdAnsOS9nIqe8F6pVNI24KPWrIYsEu3TOCZKpN+OlkG4fPlyEA+VzWYDUVDOD8b1\n", + "5TlnVdM3NzcDFjCXy2kboR7nz58PYig5VornNyxuMBFPPfWU/g7PajQaroCmzavI8SY8ti37XK/X\n", + "XfFNO0dqtZqymGApOp2OG2tl2alsNqt1R7+ura3p2Odcep5qP7OdIv1xYgUxvTHG6zfa9uqrr1ZG\n", + "yjJEIluCnBwPhbJ7TDCPEZTpjjvukCeffFJEouPJBlKvra0FivBcFoyDp59+OvAQMEPIc9/KUGxs\n", + "bARrlg3qt/Oa13SsP6z0Dybp7NmzWl5mxcBEcbsgTyPGfj6fD/L5xcFjomxM4OnTpyNi1FxflAEA\n", + "q/jT4MEahHfcRsrbvGACc9AaD1T7GVN0XnA4axbZjRQHcwKc4oInEv7N98BkYnee3QzxwGENGvsC\n", + "4sS9fCIpKXksB7IOe5LFgz1lYWFPbrESOX+HCc5t5FG4NkUMLyIc1I/y8GKEa/ESzmQySnvjPl4S\n", + "WQYfJrCHDdjFMiixrw2O5sWRU5hgw8PJTPE9U/YYR9we2CR67egdHMBLwqvvgQMHVNXbaqWJbLVp\n", + "3AlPq3q/uroaHMJgdzPGZrVa1fHJLy3WS0L9ue7WZZLL5YKgb3Z1cV1wH97QsDsQ94cBAtfE2NiY\n", + "9kPcBs+CFaG9QzD2s9HRUffkq90MTU9PR05N4TcYOzzn0dZWDV5ka5xUKpXgUALr6wGXLl1SdXK8\n", + "UBuNxsDQAxGRH//4x/oZ2uy1117Tzzx3tXWvMvjUq103GMViMUhAXSqVgtOMnMYJ4HGG5/FY84Dv\n", + "RkZGgg1wu90O3iv5fN49ScfwMk1gA4I5sn//ft0MJZ1SE4kenHirKJVKwea/0Who+bDutFqt4MAF\n", + "byJ5zGD+e2mIvLbnvQHanMcuxiyf9rVr6jB6jalrL0WKFClSpEiRYof4qWOkmMlhi9Vq5zA9zwrC\n", + "lqVi1W5mn6yFxDtWpnaTGIYkBVxWQOe62eSXHnOVzWYTpR2YwsZOHn/5956C8LCq7iJbFiiOQnN+\n", + "K3xWLpcDpqLRaAT91Ww23bxXKGPSEdNqtartxhaVtWI6nU6Qj65erwduV9bVwe8mJia0H7hvbH8x\n", + "C8gYRg/Mc69ymXGke2lpydXG8tTd0R6sFmzZkUwmo98zI5GUUNTLm4g+7/V6ykTBkltcXHSZA9QN\n", + "DAu7rfFduVzWenIyYg92Plran1XJUUfLSDPw2dTUVOAi4gBl1rlCG/Ixedu3lUolVjvN1sPLH4Z2\n", + "5/lj16xisRjonG1sbESOlaN8dn5xcLOnw4X25/FntcgYnU5HrwUj1Wq1dI1Gma+++mrVkULbg/ES\n", + "8VlXjCt2g3KZwayiHbk94SL3NOYuXbqk1wL5fD5Y1ycnJ93xiGDoJKyvrwcuO9ZDYuacMyrwd0CS\n", + "BqD3nkIbDeuaGwTWNMN4Qvt5TBe/e731EX3DCu18CMNT1LdM8vT0dESyR6TPrGLMsEo8WCw+1INx\n", + "lqSZOAxSRipFihQpUqRIkWKH+KlhpFhQ0opz8b/tTh7XiESZBo5ZsSwVW7HMpthd/aD4JX7+oPgm\n", + "kb4FiR0353izO2qWU+AdOCwMVlr1FIs94bykY/fValW/Rz9wQDGshWuvvTbi1xbpW1woFwebD8PQ\n", + "sAgdwIKHDGvxeFIH1WpVrTlmRwapq8chn88Hlnwul4uwK7g/LG+OebLxAVNTUxrEySKDtl8LhYKK\n", + "5XF7g6XgtvVYAstwlEoltf44pgRt5fUV7sF5ujB2e72extWApVpdXXWZLVs+jvuAxcmWtpUCsWBp\n", + "EpF+G3P5wbKw1cmxLiL9cWqPaq+urkby34lExwsr71sG2ZNE8dhHjk9kxtmOE+9+zWYz+B23N1Ss\n", + "mfGzMV8M7zDJ1NRUhB0SicZmoQ08hWkRP+YSc8XGLvJ3zFyg/zhGhmUfrPimyFY/gY1k6QOMU1sv\n", + "kX7fQ5AV92UG1ovr4tgsPOcXf/EXRaTP/Fjph263m3hoBuB1kNfvJFFiVvAeFmjza665Rucd5y3E\n", + "vED7cp+iHbjtk2KuvBhjryztdjsYq+VyWdsE68/o6KiymXguZ2jA79rtts511If3Aaj33NycvieS\n", + "FOuHwU/NRooXVxu466UI4cBt/swGN3on0jhwG2g0GpG0EyLRRRoLgbcosQuI3XOWmqzX64FKb1yK\n", + "CC9Q3abl8E648YkfnsA8URHIzAlCUUYsSisrK9veeHjAIBeJbpZFfDrV20R5pzK9l7+3CPLpL4Dr\n", + "mwTvFCBvrrFoxpUbwAI/OTkZbLg7nY5ObA4sxwIA6txLoBsHu6GZmJhwNzkYT0m0di6XUxcGNmGj\n", + "o6O6UcFCe/nyZf0dv8jsRnRmZsYNfLa/Hx0dDU7ysZsW9WGXiEh0AyUS1V/CHBgdHdUNFPpwbW3N\n", + "fVFgo+htPAYlHOcxIxIds2wA2bHI//fSxjDQNtgotNvtwN3iqclvbm7KsWPHRCSqI2TLzmuAVw+g\n", + "Wq26p7ZsH7PyPso+OTmpYQMcuG3B85vnAtqFP8O9Uf5msxkE5l++fFnd6Qg6f+WVV4L6ch8g6e/X\n", + "v/51/YzTrWC8eGObtbc4WJrrYJ/H2l3eOmbH+yDgfXPixAk91QedrkuXLrkJtIfB+Pi4XsvzAp/h\n", + "PcB9BD2qSqXiZsewrt+9e/fq+OD3GSeUF4mOT+/d4WUuwYY7m81qGRGIPsypwdS1lyJFihQpUqRI\n", + "sUNccUbKHmf2FKGZBfDkBfhYvQ1u63Q6usO02h14nkh0F82qyNjB4zPPCuVjnrDkCoVCxPqzz0O9\n", + "y+VyQCtyQDMrvlpGgo/2c7t4LkwGB42/nYBlVqlU1BKAJc+sohcEzzoowzIvANo8n89HAphF+tbM\n", + "MLmSmClB2fkAAlv8wCClXfT1TTfdJCL9RMAYPyhznAQF2ARm8ZKU6JMORbTb7YB1Onz4sFp3SbT2\n", + "7OysloHlEvA8SCOIbLFBVlWawZIASXo/rH3E7I09mm7ZEbRnUo46DgDm3+NeLAfgMVG2rflatIHn\n", + "SmIcPnxYRPrMgA2g9YLIvQB0DtJlBgdjh12BNt/o2NiYMlFevjGPkUC7eG1y8OBBee655xLrDKD8\n", + "YGI9lt9TbWdgjeAsCmDE2JXNDBjKz2MC6zr3l/Uk8JrPuecATq5sXVk8VsB+bmxsBEH9XEcOuPZk\n", + "XoC3Il8jMnwQOh/wEumvAyw/ItJfP7H+Y1xxOyd5Fbx68DuA1wzoXJ04cSK4Bm09MTGhDBjnFsW4\n", + "he5XrVbT9kf5OGQE8ibDIGWkUqRIkSJFihQpdogrzkhZwTRmpDyrk4N5+Wgw/nrWixc3ZRkuZho4\n", + "OJzzMvF3FlYVnZkhji3wBEOtwKMXZF8oFCLBmXiWZeA4SI+tIbAJ3lFSDgqE1eFZEMViUS09tMvG\n", + "xobGIcCqi7PGYaF4FiH6kNuX46tgmaEeo6OjAWu3tLSk1k1SjEKr1QrkGbw4Ie8eIyMjQT+Njo4G\n", + "SukiWz52T43bkzIAWP6CjxnDguc2SmKivFg0BMvefPPN8h//8R+x1wLz8/PKsvAYh0I1sxioU1LG\n", + "gXq97s45q57d7Xa1r3l+W/FIFuHlMjCsACgzNAwbgM4CqhwEa4+hMyPFeek8JhTBzWxRW/HNer0e\n", + "xCOtr68Ha0ej0QiCkVmyAe02NzenLLQnEcAClgD6kGPHkoLN40Rd7cGCTqcTUU0X6TNoSTkAPUV3\n", + "vq9d8ycmJjQOlBkpjGPUt1gsKjP4+OOP6+/snOL1zKsn8iyKSMCYMlgqhMU5RfzMBDzetxtUvhPk\n", + "8/ngYBa/Y9DO3lp58eJFLSvHSiblnsRadPbs2eDQFLcfxzajDaHez/2Le6ysrOgcwP3YQ+TlCuTx\n", + "h3HiHVyKwxXfSFlZf95ssIvKLiJ8egbwdKR4knkn2zhwG/9G5/OmzXPTAVxmTjJpF0OmKHmz5KWX\n", + "wb/55WUHtJf0l9uFn4FNwdTUVIQWF+n3gUfXY9DihdZqtXRRSXIHFYtFfUbSi35mZkbvg3Ytl8v6\n", + "QuMNGuqEcvJnwwZG8gsw6TQMnxJBG+G5PHGBer3uvoywkcKYaLVa7ibXolqtRvRPRKJBkMPCewbK\n", + "tLGxEQS8ejh06JC6itjN7J3WsSdS4zZSduyUy2UdYxhfnEEA/cYLvb2nBcpQr9cjbn6ReL05u2Dy\n", + "eLFrA8MzwjiND14wzWZTT0h5Rh3D6pzxIRIgm80Gp9JarVZEwV+k/+JGv+MlyCdmOaAcGwU2IryA\n", + "e6va7r1s+IQmtz0nbBfpj1MvZMIeEmJg/nrK8PV6PWLQAPbwzPT0tAabM5LWE0/LCe1YKBQS3doM\n", + "jBMvzIHXbR5HduwdO3ZM64R1qdFoaB96p0CBfD6v7zfUqVqt6jX2JPkwQFngfltYWEh0waFurAXF\n", + "xIBt6xdffHHosthnxR0MQRlYMxFGIt5DfJggDqlrL0WKFClSpEiRYoe44oyUpY2ZGWL3i0f5WY0n\n", + "1hkB+Bil9zvW0rG78Fqt5gZCWrar2WxGcgnhM9ZkwvMtS+VJNuB6C8vAcPAh7uclMhbZYpWWl5cT\n", + "c+3BSuF8UF4+qyQMOhYOMEXMrhM8jy1DtCH+VqvV4Ej3oOBJ7mvLHExNTem/0S7QLIm7D7uAPXcV\n", + "mAFmP5NkEqx7izFMwDzgKQIDYES63a5arkkB681mU90KPBeSZCo8qx1lajQaQb+Vy+Xg6Hy73Q7G\n", + "Z7FYDFguVm3nujCT56mhs+q3SH8ceElv8Tu0P+ddY80g637igHYOWrY6bB7LyIHlQK/X0zaEe/3C\n", + "hQvBWOn1esG9Obdk0nF5j30oFosuW23736uHx1qPjIzo+ODn2TWt0+m4Ol0Az0HrPlxdXdW1gJk4\n", + "aFQxOM8fYBkufidxYLlFHGuM8Yl8flwnnqM24Tb/jssAPPPMM3L99deLiETkSNA3LJeDazmUBvOZ\n", + "XfFJ69OwgKvznnvukYMHD4rIVu7E8+fPK3uPz44fPx6EqGxubuqY9Vxx20UulwsC/BuNRuDqLhQK\n", + "OkfBTIGRTULKSKVIkSJFihQpUuwQmV5SsMb/1kPJEsGumVkZT/3XskDM5ABsMXsxCHytlSHg2CJm\n", + "eiwLxMdyPXBgK3bXsHBYXZUDxq0sQLfbda1Day00Gg29N8dmcfvZoDsGi35uN/4mCdlsNoihaDab\n", + "Wj/Er6ytrQ0V3xSnpJwEjkux/crB9YME6NDXYIuazeZQx457vZ4KHl5zzTUiIvLII49oHAGex+3E\n", + "rGJSWfhaOyY4jshjpHAPWLAifiArrNS5ublAAkRkK2CXmQ0wJWBJvKWFmR/Ak3bgz7xgY6BYLEaO\n", + "OHt5ytDvzBraIF8ODmcFd0/cFuDYIXs/DlQHdu3aFaiSM9sCSzhO3NKqZjOSpAJEtvoGfc1zCoHZ\n", + "LIuCsnAdPMYU7TM6Opoofuix5ACXhZ/rlQHwxgQzzmiHpHvs379f64J+a7fbAePMYwMxVcxWe8/g\n", + "eySNtUGAYj3HYKINr7rqqogSPOpuxwLHXLLyvhdre6WBOTU6OqrtluRpKJVKbvYRb61AG6FvWEQ0\n", + "SaEd907KvXvFNlI/TZ2XIkWKFClSpEgRh6R9S+raS5EiRYoUKVKk2CGuWLC5dTXxcf8kdw8o3ZmZ\n", + "GfcoOgL7oA8ClVX7bNDZcE3U63WXtrVuIS/HH8PmrxLZyrV27ty5xEBgT38Hzy+XyxGXg8jgJLyT\n", + "k5NKXXuuvSTXqXcN78a9PH+sxWGp90Eup0FIcl14x7OZTrdUPVsWNrCUn5XNZtVFtHv3bhHZCkAc\n", + "BD5YwO3mJTf2+hGuSZQ5LnCXc8WJRFXxd+KuZRexSL8NOJkyvrPBytPT01oWjF8+2MD38/qf743/\n", + "o414rHmuWIwxdolzjjLcJ0mJPp/P64EMz9WJvGSbm5tDHb7Yv39/JBksAFcN6rG2thbM6263q+3B\n", + "Lopf//VfF5Gt9emRRx5xn21dGN1uV6677joR2eobL4D3pptukrvvvltERL7yla9Efs+Ym5vT8Qm3\n", + "iydN4R0W2dzcTNQJhAuSE3yzKxF9hN+dPn3aDZC+/fbbRUTkqaee0s8GuYhF+q49lJsD1dGW0AHj\n", + "nHxYG1ZWVoL1nedtklaWyFa/YU0qlUr63M3NTXXpWg3EYTCMi5XvN6zHiPUH0a5ezti34oHisg9z\n", + "Hw4twe/faujKoOemjFSKFClSpEiRIsUOccXlDwAvONTL7TQolxV2xcwI2czTIyMjykjxkVjLcHFg\n", + "LAeHA5wbC5YDP/fo0aMiIpHAZu/Ysa0vW4EcDA9LxTuOzLCCfIxBOdsYVrSQP0N92eLylIf5/2CO\n", + "hs1UvhNrBkxUnPhp0v3ssXyPCeHP2eJOYhoZNth4ZGREg3jRLr1eT9kTqASvrq4G/c7WPf7ycXCM\n", + "gxtuuEEDYVkgz2tfW/5utxswZp7Y4eXLl4dSX+50OtpH3L6W+Wi32wGDtJ3YSsz1TqcTMBC5XC4i\n", + "IYDngW245ZZbRCTK+IB5ueGGGwJxS5RNZIvF+PCHPyx/9Vd/FZTLY2G8HKAYi5yf7d///d9FZCso\n", + "fHJyUuvBR+utCGa5XNYxlrR2cFshgNpjpEZGRoIj4cxqc242MD0e62oD4Pnfs7OzgRDi0tKSPhes\n", + "XNx8Qz/Ay3Dx4kUdT1hHmcH08pOifxcWFuS+++4TEZEvf/nLwbOwFs7MzOj7hO/DuUAB7+AIyoU2\n", + "Z+X6YYPTWdaA36nDCLyKhGtjJpPRa/i+VqKIn8XB98NkXoiTwWBGVaTfRigL1jPODMKC1Z4gtM0Z\n", + "yOBgfCuD5P3e4optpKwuBg8sTBbvpAVcK/l83n0RWNcPJ11FEsJutxsk7uU0Ct4mgelU+9xutxss\n", + "OCMjI9qZWDB4A4FnVCoVHQBeMmE8Y3Z21j0NhZcl63Cg/Qap7HJbeakc7O9GR0cjKTBEfF0ge2+U\n", + "2dus2bQcIv5GJelUF5+4sBsQ1vjx3GOeLhk/A+DNlU2mKyKu+2iYjeDm5qYukkh7kMvl1H2Ev1df\n", + "fbVutDEHWq2WO0cAjMmnn35aP3vPe94jIiLPPfecPpfd1sPoyMQpJWOceydheHH1XGw2eXmn0wmU\n", + "/D3XA6d+4Pt4qZD4/9g0YUysrq7q+vChD31IRPrtZjceJ0+eDF7wfOoML/B8Pi933HGHiIg8+eST\n", + "+luUldvQc1ejXHAFZjKZYD4fPnxYjh8/LiIiX/ziF4N78EaFN1pxWF5eVvXopHEwPz8fjDse48O6\n", + "UTA+Dxw4IK+//nrkuxdffFHuv/9+EdmaA0tLS7Haboy5uTl5+OGHRUTk05/+tIiI/Ou//quOOz5d\n", + "asdyoVAIxkuv15Nvf/vbsc/DGvbmm28Gfblnzx5tK17/7e8WFhZ0vqBdWNtwEHitQd8NMpTs9/w7\n", + "GDuFQkHLj012LpfTNR/ExuTkpI7ZpD7i1GmeAcHltHWP0ye04411JwcZLElAOYcZz6lrL0WKFClS\n", + "pEiRYoe4YowUaFWrNtrtdhNdBEk50gqFghw5ckRERJ599lkR6Vtjdgc6NzenVg6sfGaD4tSGRfrB\n", + "jtYF6O2U9+/frxYI675w0KVIn/L2rA5Y5rBIa7Way6jA+kC75HI5Dcj0GKmBQXOkvG6t+zhl62HV\n", + "cMGoITiz1Wq5ejlgEJm5YA0okSgjNSj/Gtgz9AOzoTw27DjxWA0OBGbgGVxmqxXFAeawmJrNpo43\n", + "7i8bmPr666/r9WAcWaGdNcs4D5lIn93AtT/60Y9EpD+erbpyJpNJTDichHa7HeSoOnr0qLI8GDt7\n", + "9uzR+c3zHP2bFBDuWZJ2rqKtWbMM9+QxgXZgbSz8DuX6wAc+IF/72tci9+/1esH6tHv3bq07+vWF\n", + "F15w8y96rjUvAavNPcauDtR5aWlJ1wcP0C+7fPnyUDngzp07p/2eZIWPj48HDBKXmWHzel5zzTUa\n", + "qI32fv3112Xfvn0isuU1EBH57ne/KyJbbbB3794IG2uBcceuZwTN//Iv/7L88Ic/FJGtPuDxAIaS\n", + "c3hiXee6ch8gpxzCOaanp4Ok2rOzs1pWL6QBz61UKgNDNpIUtpPcdOVyWZkjlGttbS3QcOT1BH0T\n", + "l1sWwBj3xjrfm8tkxwmv5ezuQz+yRyFpfQAGMU7s4rNlGRkZCVTWh8EVjZHK5XI6mL2JgUEpsjUA\n", + "+GWExkfFb7755sgpDfzGJgXmDQnuy+KGfJILAxCf8WLnCbEtLCxomeBj540GXE4nT54M6svAhIXP\n", + "PW5w4EQg6ra6uuomimS4cAaRAAAgAElEQVQkuZw4Jsv+nj9DnXkw8iJjn8HxZnjBc/8i1cHJkycT\n", + "k7jy/716eNnS7diqVqu6qfI2ZrbeIv6pvqTyMbj/cS3HwMDVgPHiuRxEoulHRKK+e2/hw/gsFouB\n", + "m8y7P9cfL4nV1VU3HhEvfz79ipNg2BxfuHAh2BCur69rufnED8qKl2Gv1wte/sViUdsK9VldXY20\n", + "L8Yi7jc9Pa3jjeuMdYQ3jPg3yj/sZrLX6+mpOGxszp49qy8XnPiLExbEyxRuQU5bgjbYvXu33Hvv\n", + "vSKylabkxRdflD/90z+NLRdezMePHw9O+FWr1UjqGpH+2LBinzfffLN+j/K/8cYbgTHpvZQYaEuu\n", + "2w033KD388IarIGWy+V0LsNYZPcxv3Dt2nDixAmde0mJh8fGxoKXPxvKWF8+9rGP6bzARuvy5cty\n", + "0003ichWmpRnn31W9u7dGzwPZeUk3dhsesbl5OSk3nu7qNfrQXqcXC439IbBO7lu4b2/OT1TkgGf\n", + "z+eDd3O329V+4ncN+p1js6xoLoeReKKjbERbN+N2DUit646uSpEiRYoUKVKkSHFlGSkOKGWAbsfu\n", + "n3fT2J3u3r07sGIQKCkS1WSCVYxdr3eiot1uu5pCoGOZVoXl6Fk4YLg8qjOTyQT07ujoqD6P0yR4\n", + "ejmeFYb286j2OHiJk206jnq9HuzmS6WSWm7sSsRnSYHblUpF64m6MUMApsF+Hnc//oytTz7lJOIf\n", + "BPBQLBZd16kHz4JLCvoGeKzDyt3Y2NDPMWYPHTqklirrgHFCTwvWoEH7eSkrmJHCeGcmFm2Fv3v3\n", + "7lWLGmOsVqspI4E5OD09rcwL5uva2lrQl3G6Ovic2S/LKrAbFGW3wcGoC2va4DlYV7rdrtx1110i\n", + "IvLYY49FrkO5RZIT1DJYlw5zizW0vGS5DDCRYLW8RLrnz5/X+f8Lv/ALItJniDwtPQBs1rvf/e6g\n", + "LQuFQjAvvPQ9lUpFTzGiPp6b0DvdNShIF/22f/9+dfeBkRwbG9MAeazRrMuVlNLj3LlzwVr+8ssv\n", + "y/ve9z4RkUgSbowJZoHQzmDJX3rppWB8njp1SsvMqXuQiJdhdccKhYI+F6xhrVaTa6+9NrZOu3bt\n", + "SnT9eQcxPK0/II6FsifUOOXYoBCOYYLIRcLT0a1WKxgrhUIhONXXaDSCfueTfJwkHPMf146Pj0e0\n", + "5UT6bW41EJvNpn5m18fEug/8RYoUKVKkSJEiRQoXV5SR8liGbDaru0nPokEMArNRbI3DmoS1NTo6\n", + "qiwLdvSsacJJTr2dJ5gStu5hgXjqwEm+4F6vp3VjzRXsfNnaxmewgKrVarAbL5VKQeCrlyx1EJiR\n", + "Yq0TWxeUScQPrmaJAGuNxB1dPXjwoIiIPP7444llTJIwAHNZq9W0DOi3ixcvBuPIY7xyuVyg/htn\n", + "UXl12a5yL7Oj6Ff8LZVKyk5hrA1KqgkLc2NjQ6/hoHNvbNu23NjYCPR0zpw5o3MJjMnGxobG4aGN\n", + "Ll68GLCwHHfoSWSgH3bt2qWxfmjbV155xbWaWbspCahbrVYLGO5ut6vjF23FTBgYJA589oD7cjAv\n", + "UKvVAs07llhhYA4jkPrnf/7nNRgebdRoNDRGCXGWxWIxdl6JbK1ZtVpNWRbMhYWFBY3jSVLPf/zx\n", + "x3WOg5n02PZOpxNJgi4SPYrPQFnA6PR6PZ2viBdjVm7YoF+er15drJ6gyNaYZk8B5hrYpdHRUS0z\n", + "mKt/+7d/098jXrBWqw219rZaLX0HsdI93ifweBw8eFCeeOIJEekzahwfbDEortSyO97axqy3/Vwk\n", + "9GTwd5zJAfOiXq8HLBC/Z5NidVutVmI2C47HTWKMWCInaQ3FeCmVSromWA3JJPzUCHIC3W43CMQT\n", + "2aJZPY0KBMYy9Ytg00KhEGw2WA8J8Gjt8fHxwB01OTkZlKFYLOoijQDKH/zgB+4JQ5QLE3d0dDSg\n", + "ynO5XLBYeRN0165dAW3MG6E4eBpPVujMg+ciiwsytM+YmpoKTomJhG6PY8eO6SkYfvlaypmDW3kz\n", + "hzGTdMKFdX+AuIzxSZOZF6c48VP+y/dImvyNRmNoN6MHGzAcB++whFdPjFXoUZVKJXXBoO0bjUZQ\n", + "J/5/0kaTN2FYeD2XXKlU0jJj0xGXJonTKLH4qUj/RYW1wtuI4IU2qA9gWCwvL+tLF8KNP/jBD7Ss\n", + "g+6D9kWZ5ubm1OjDunfw4EEd23A5eoceGNg48CYB82h5eVluu+02ERE9zRYHHIy58cYbY+vjaRVV\n", + "KpVI6iIAmyZ+saFcGAf8DPQbj1OsDQsLC7rB9NycnCrqoYceEpHoCWxsJtGXV111lZaBjXLodSFo\n", + "n11KWMP4hCgwMTGhfQn9saWlJW0jlI/XH3x3+fLlyDtkUH+LRNciJhiw3rHLC/dmA5LTaOEza1jm\n", + "8/lA9DObzQZpnjqdjrYH7lcoFLTvuCxYr3G/9fX1RCMh7r2D+9lDPe12W6/x0tGhzPV6fWjx08iz\n", + "t31FihQpUqRIkSJFChH5KWSkstmsUqUIbs3lcsoC8Y7fuj3YArZy+4zdu3ertQEmiYMN8VmlUlFr\n", + "A64HtiaA6elp+cQnPiEiIl/60pdEpL/rtbvmsbGxIOkt07WwYNnK9lwiALNRnhZNHCw70Ov19Nlg\n", + "M9i64sSZgMdcJdHGCwsLamVyW7O6sUjUbcAsD9gJPLdSqQQSBvzvJDqW3Z9of+6rpCBNZts4uNHr\n", + "H+/or2WpqtWqPs8LIodVNsiNw0hKzurdG20/7IGFRqOhfcgWM57rJQrFfMxkMvpvj8Vg94F3KMFD\n", + "UgoHDmRFfx08eFB15rz1AQyOx1yKbLEIzHrhGvTryMiI1hOMeK/XU9cVs+cYTywbAeB+hw8flu9/\n", + "//sissW6DgrmBvOyurqqLiTMr1OnTqmLEIH3ce51qy0Wd3jDpr+p1+suo2vXjj179ui1nmaTt56g\n", + "L+MC+fFu8EIQwKYuLS3pc8EkPvroowHLWa1WA+aKGVhmOuEOtu0tsiUVUqlUdO3Ge21qakrLijZj\n", + "uYz5+fmhUmt5DFLcOBl2PbFgDwGvcWhjZpLtmpbL5fQankcYU3xwabspwrxMHV7dPTkaHmv4fjvh\n", + "GikjlSJFihQpUqRIsUP81DFSuVwusIzZ1wqMjY3pzpFjQqw1zrtuHC/lI6ps/cFiwO70zJkzrko0\n", + "gISYd9xxhzJRgMdQ8G4XFhUzVJ5YIn4/NTXlMjBgojw2A98NA+t/LxQKEbV5kShDlBSU6O3kV1dX\n", + "XUVwWI6w9FiolK0JW7+9e/dqwLMX65MUl8Lt5zF+sEi9WC9PCT2bzSbGPHlHk/G3VqtpzAgrsNs2\n", + "jLMe0abMBnrxWgDmB+d4xNj+0Ic+pGWBpfzaa68Fqt29Xi84wIFn8+/4EAP3zTByFDMzM9qH+D0z\n", + "REmJlhncXxhDnU5HYxnBDMQFvHqwjFq32w3iNE+dOqVyEGC42+22Hq5gRioJWAu++93vajtwrKEn\n", + "2WLru7a2pmOLxwbkBX7t135NRPoB3l7MGdowLlG8BTOSeB5iYFZWVnQ8gZF48803t9X+IlvrFZf3\n", + "2LFjWk6W6rDgQ0LoIwR18+8RF1UsFuU73/mOiGzFOXkCvZ1OJwi45mtQby/pd7vd1nWMY3rBnjUa\n", + "jaFjd5KCwxlWDqjT6QwloMnfY/yxgjsOVHj3aDabQzNhVt6GwXW09cvlckEb8LuHxwzGNvenjTEb\n", + "hpnK9LZ73OhtQNJC7/2Oi4hBmc/nXQXYJFdYEoU9Pz+vA5wnmlVmFklOU+P9Hhu0xcVFnWCsoeEB\n", + "Jzf4pWMn0r59+4ITX4w9e/boi2JQm9uNlLc5qFarkZeaSDRIkoMW0WdIB1Ov17WMvPFhbR+R/oBG\n", + "e2FB8dxu119/vW6kvD73MssD3mkyjxIf9gQk3w+IS9I8DIrForYvK3Czmw/PQNtw0l+0KasFY8OD\n", + "z/h0bBL279+vbQm38fLycuJGFa6g2dnZIHB3O0A90efNZjOihi4SXRs2NzeDNmdXAv7u3btXjh49\n", + "KiL9VC4i0Y0NByh7wPcoX6lUUtc+XDvf+MY39Pfvfe97RaR/Sg3l43HJqTxE/Lmcy+V0LmHda7fb\n", + "EQ2jOOzevVvbDe4hHtcf+chHRKT/ov/BD34QXI9nAPws1ixKypQAo259fX2oDdnCwkJwKpqNZ+4b\n", + "nI7EZm3fvn3qBgWOHj2qh3qSUpDl83l1v95zzz0iIvIP//AP2tcY214dcrmcprrBMzY2NrQNOLga\n", + "v0tK8Ds6Ohr0m0jyBiMOXjLvncLLAhEHGBGoR7Va1fUV42h9fT0SJiHSr6M1vLeTxNkDb25F+v0x\n", + "7P2wnsfVO3XtpUiRIkWKFClS7BA/da49LxltJpPRnS129XE0p8dEIfAP9C2D1ZgRuMi7dzBgsAg2\n", + "NzeVBeAElaBgPZaMrXdosYD+7HQ6bpA5LBrsypk9AFvVbrdd6xXW07CaOyJbLAy7CmygqCetUCgU\n", + "tH4eg4i6cVlgOW5sbGhbctA9yoDfccAmgv5PnDih1iGsax47cLt61uewMgSDkl9690gKfB4WTH/j\n", + "3hxsjr+s68VSEB6T4gW/2iDibDar1j3G1RtvvBG4oXK5nLIn6KPNzU29Bvfj9mOL0yovM3vHbgar\n", + "Tsw6bNuBtdxPnz4duJxmZmZ0jMJNF5ezEu2L9q9UKrpOeDk0MT84Vxw+W1hY0OeydYx5g3WOFaZh\n", + "WddqtaGkLrLZbGKgMuQP4qRTML84GNr7rRdYjjqhjvv37x+Kkep2uxEmX6Tffh4TirphXWQ2CgH1\n", + "zz//vFtm60Fot9sa+gHXJ6vnc9nhEv1//+//aV0xvzAHyuWyy1ajHt5BD6whuVxuaCmTJOTzeXfO\n", + "cXniwIr1DMt6e3IFrOsIxI1DjBnO9erNdctccc5ALrPn1hwm4TGXYTvMX8pIpUiRIkWKFClS7BBX\n", + "lJHyfI5xfnZYRTZGwv4OO1swOSyI5llMuN/a2ppap9htnzt3LhKPYO+H2BEW/WPgPrwLR8A7rHeP\n", + "QWCxNy+GilWs7bM4R94geEHQw+QV4t8xk+QFKiLAstPpaKwFP8OK0ImIG1QPsEWKdkNb8e/xLBZf\n", + "5YBsL2bAMmo78ccnqQ97GBRvgPp6ljhnuffagDOle2rUNui72+0GTOjIyEigxt/r9QJpAs9q43HN\n", + "gny4j3ct2rxUKg08vj0MOp1OxMJHPRGbgmdPTU0FTJ+nRM4HEFiA0LYbA7E5nL0e82J9fT1gnxiY\n", + "15lMRsuCZ3gxfKVSSccg5lGxWAzmJgsQI/aNmUagXq9rnzBDaH/HMYZerCSuPX/+/FBxXW+88Yay\n", + "yoDHZszMzOjnrESPGCS0PccTcowm2pzZWbwTONME+o3Fkz1mjTNqiPTfDd6aYL0aDLT3ysrKUCKc\n", + "g8BrwiB2xZM1sOtwNpsdiilrNBpuHjxvXUedk9Zcj32Kk51Juk/SoShWd0fZvTltccU2UvYF4lUO\n", + "n3FCYUxIDHyRqDsKAx4LjOdqE9kKAOfJhwnGWkx2U7KysqInb5DiIJvNugkl4U7Bon3bbbfJww8/\n", + "HPzOTrRsNpsYzIvfLy8vB+4ZXL9TJG3C+Dv0E5eTv+eFBMBk4knobaTsAsWnteAi4JQu3osWffir\n", + "v/qr8o//+I+R57darUA3y9vQxG2y7MlQzx3N1wBJiZctvE0/XkD4bHNzU3+HF1uxWNQ2H5RWBuAX\n", + "ud28cNsmLU7DnvJhg4MD3+1G0Bv/rGa/HeAab2xjfdi/f7+6NfFsG5yKe9hg88nJSQ1a5+TbAF70\n", + "u3fvDjZLFy5c0HbgoG6sX3gWa9+hT2644YYgwXGj0VD3N8b2xYsXNfSAN00WnU5Hy88B8Cg/q14P\n", + "c/KS04bwyT+sDUmhABsbG7rZ5I2XvV82m5WFhQUR2VqPuX5J69nu3bsDV5zIVptzWhMPOMnH18F4\n", + "wLrMRjbq1u129TPPwGHgJf5WMh0wBs3TYeYXnwzmccQq5yL9+eFls/AO0vA1Iv1xZzNXcD94+n+8\n", + "3ib1u7dGc8JtmyZrGKSuvRQpUqRIkSJFih3ipy7YnMGB1jYnDrsNsFsvFouJwdewAubn59Xig5U3\n", + "PT3tUrV2Z3v06NHACmSLmnMQ2d19XLCjtVK93XuhUNAdMizNSqXisk+DAnKtJcg7b/7O1n2Q289T\n", + "uWYkuSthwVWr1SD3YJyOiP08n88rMwPrFNoytvzWvcBWiscGJTFNDO47a/15ulRx8H6HsqKt8vm8\n", + "9jUzf7B8Ud9ut6tua7R9t9sNNFaazWbEBYf6eP0FVoFVrFFftio9t7VnYQ6DbDarQd1gj4bJLQl4\n", + "1jjKsrS0pGMC94xjC1Bn9MfCwkIgEcB9jXZmloWZZA4bQFls+TwG6ZprrgnWIr4G4JyRzDR6jBDn\n", + "IRPps/1ga3DtyMjI0My1daGzAjbGSbfbDQ6dbGxsRBLJikS9EFgzL1y44HodrBbhgQMHtF3xjpia\n", + "mgrqsbCwEKw/9Xo9eDewFAzGJM8TlI/dr/CWxKmxe2DF/+2M9Tjw+8JqLXW7XVeTybr7+Hdxeoki\n", + "8QfCPLbbXsPXot6FQkF/NyhxvGWaOOCe64Hyb3ctskgZqRQpUqRIkSJFih3iisdI2UBQFt3juChr\n", + "FXuKpoVCIaIELtLf2cJygAgfW3E4Mru8vBzc75ZbbtGcXLifZwFWq9UgRmpmZiawUldWVvQzWCn1\n", + "et0VlISVgOdeuHBB4xe2I2vgwQZTcl5Az9LkQHZPrNDGkrC1y4AV4QV6498c2Ie2arVaykAgXsML\n", + "WpyamlKrHnmq/uu//ku/Zws8iVXy4iu4zJbZKBQKWrekwMS4gxT4nC0/1M07EDAoPgVjC/cbGxvT\n", + "PudxirHPBw3ACMAijLOCkwQ2cb/V1dWA3fPYLQ6GxvM5HoqZNbBEcTkZLcbGxoLAWC/WamlpSe8D\n", + "8chyuezW04oyvvjii/Lxj39cRLZirvL5fBDjwTIpEAf+l3/5F22jpJg2j3WJi3fx2Cvcm+cAngsG\n", + "s9VqBUrP9Xo96LNcLqfrEsNjuLCGcztivcCcGRsb02B9zO9qtapj0GsXG6cqsiUtwzlIf+VXfkVE\n", + "+u1nWSovV+mpU6ciuVZF+syjl1kB8ggYB8z22FyuIslMVLFY1PaD8Ora2ppev7KyMhSbPejwincP\n", + "Dq5Gf3HMIvrJKqFboP44JNBqtbRfeT2znolut+sKcrIUiv2MD3rYucx7g0GMk1cX3BvzfJj4tCu2\n", + "kUKHYnPACwU60zsZwC8qmx5hfX1dT2vgZbK+vq5B394mCJsSfmEgfQReyvxvz/3HHYmXU6VSkRdf\n", + "fDHyu3vuuUf+7u/+TkR8ipWBTuQUMsNsoHiRi3sJ2kA9LzkrT0g+hYNJAr0cpvm9vmFgYWRa1iZb\n", + "HhkZ0bqjzU+fPq16K1hoPe2hlZWV4KQPHxzgl3rSosTBhmgDdnXZhapUKmmdkk6Y8YbBS67slQm/\n", + "P3DgQJBgm0984uU0NTWlLwjrgmJce+21+iJg4Br0wejoqL70cWjiueeei7SHSLRPPcoeyOfz+plH\n", + "0/O1SUmQGUkvjrm5uaD+rAsEZDIZfWFjjL3//e+Xr371q8E97Yt9Y2ND/ud//kdEomMcQdCs0I12\n", + "u/HGG0VE5JlnntHPuD+svlCtVgsOljz22GNune2J2maz6eqp8QtKJJo2CNfaJOv4HW9CROLd1t7a\n", + "ZpW+l5aW3MTI3mYJmwy0y+TkpK75nPoLwFyJS8iMsqC9FxcXdRNk1xwRUdXzI0eOBJpho6OjOjb4\n", + "gIOX7cIexhkfH1fjAO+YXC6n5ffcZMOeeh8Wg5TDvc2Id1DCS37Oa683j73PUBcmGgatBagH4G3u\n", + "2WC1+lV8EGA7mnWpay9FihQpUqRIkWKHuKLB5l6gdKVScXffVtNhY2MjYFwWFhZ0NzxsUlPkU3r0\n", + "0Uf1s3vvvVdERP76r/9aP/Nyrh0+fFhE+laFVfD12KPnnnsuUCdmdwp22ZOTk4muE9R7ZGQksLZn\n", + "Z2f1GUwlJwWRe66AarUaHLcW2bIIYY2Nj4+rvg0Hg3oWA8rNO33cD8zR3XffrdYj3wMWHLv4wDTC\n", + "Ymw2mwFbwOOALSpL17J1xznqgCQ1dB5fSVYbq8Wz5ACuYbqag25FolYejreLbDF/YKZqtZpey4Gq\n", + "YEcwJpj9gEV/+vRpLR8zA9/85jcj9alWq8HxfO5TlCmTyejnaL/tBHVaizAu9yEYZAbGC+cttKri\n", + "tk5oQzDXR44cCVzKIuF6MjIyouOXmR8wKsxIgYEHa7x3717X8n3Xu94lIltrzHe+8x0dM/gbJ+2C\n", + "OQB2PI6VBTDPS6WSsieevhEwPz8frDt79uyJSMmI9Mez/R23M9Dr9XR8oo9OnjwZYaJE+vk1rcYc\n", + "s8GecrUnYcG49dZb9d4iUeYqiVl58skn9TOMEY+Rq1QqgRbZ+Ph4JBhdJOqqRn94B5H+N8DeA7Sl\n", + "F7jNTL2dz+ypwXtgc3MzYJ/jgGv48IqVSWD3J2ezwGcYu5xBAH9ZT473HUnrEp4/jEs1kZGq1+ty\n", + "5513yrFjx+TIkSPye7/3eyLSXyzuu+8+uf766+UDH/hAZJH54he/KNddd50cPnzY1UxKkSJFihQp\n", + "UqT4WUEiI1Uul+WRRx5R3/ndd98tjz32mHzrW9+S++67T37nd35H/uRP/kQefPBBefDBB+WFF16Q\n", + "r371q/LCCy/ImTNn5N5775WTJ0/GCkRWq9XAqtrc3Az8vCx0xhYprBgEFjebTTd+xRPLhBXBTNSH\n", + "P/xhEdliolj9ly2rI0eOiMiWJfz1r389uP/U1JTu0m+++WYR6Vs7aAtYfBzngh1zrVYLrN69e/dq\n", + "XAKsGC8Is9PpuJYqBw9ay81j7DjQNslXzJtoZra8MnjxEtbqnJycdAPfwRIwm4AYBn4W/v1zP/dz\n", + "IiJuNvtSqRTEjHgBsnEip7CQUBa2Zti6syKybD1jHO/atUvLwgxcEnNjc0KKROPhbH91u11loDB2\n", + "brvtNnn66adFZEuUNpPJuM9FrBrm0fr6emDdTUxMaP9iXHa7XbXqMN8mJycj7JlIvx1RfsyL5eXl\n", + "gG3b2NgIssmvra0FsYhcrkwmE7Cj8/PzEZYGv7fW/6uvvqqWMsZ5nHAr8hHiHuVyWWPKONYH4/ip\n", + "p54SkX5sic1lyNdwvj8EqvMBFA8Yl2Cz4gSGbXD92bNntV2x1njxky+99FIgb1Iul5Vtw3geHx8P\n", + "mPn19XUdE8yOocxYy7mdMWZPnToVjG0WB+W6oa0eeeQREemPO7QHYqkWFxflmmuuERFR0V4G5Ap4\n", + "nWV2EcBcjssNB1YM7dxqtfSefNgKcUZ2jRDpB3BbL8V24qG8d7BlJzkGyXsO3hOZTCbCOgP4ftBh\n", + "GPQn6ru4uKhjDGOoXq/reuN5NzhLBTDouduVONhORoWBrj1UutlsahLfb33rW7oB+Y3f+A35+Z//\n", + "eXnwwQflm9/8pnzyk5+UQqEgCwsLcujQIXniiSc0WNXC0xrq9Xq66KIhC4VC8PKfmJgIBhbrf7Di\n", + "s6XyOeAV2LNnT/BSbzQaumhhU1Qul+XOO+8UkWhyTACThgOvUc5KpaLtyYk4k1yPXlJLHjBY6FGf\n", + "uMXVG0Sc9NeeHIwbdCgHKxADgyY2qFeU33PVfPe731Wam8eH546x7odcLqdjxnMBAbOzs7p5sAcW\n", + "dgJeTHjB4rljn4G2On/+vG5U+LQbwHpJNnFqp9OJaPGI9McdXJ4chM8Ut0h//GFeYszw+Ecy75df\n", + "flnbFAtfsVjUF6SnXI9+7na7urFAmXlc8ZzGv9FWc3NzugHgcWXnfDabddcRtGGcZhleqtioeK74\n", + "5eXlwAjj+Yr5Mz4+HmyG6vW6ur/RzqOjo3oKGKrYt9xyi3sYAC97DurG+MGYGAT01+7du92gcbQr\n", + "p1OxL6NsNhu4Rjm1CvDyyy9rv2PcLy8v6xzlpMC4D1zU9XpdN1DAkSNHtE0xrrw5vbq6GoQmLCws\n", + "BBvltbU1ee973ysiogcDZmZm5Gtf+1pwT8wbtMubb77pHjKya8fc3Jyu/9hwXbx4UTdrKBOPYYx7\n", + "Trnj1bNWqyUG7gNeAHWn03HdU0kuK3Zr2fcTp4gaBNQLZW82m1o/TvuGeT+sxpanfeYlj/cCz1lj\n", + "inUfB/0+CQODzbvdrhw7dkzm5ubk+PHjctNNN8ni4qKmWOF8VGfPntXBJ9IfiPZ0R4oUKVKkSJEi\n", + "xc8KBjJS2WxWnnnmGVlZWZH7779fqVLAU5i233vYt2+fGxwoEg26FfF36MViUXevrG3kqTV7dbJu\n", + "sbNnzyqjhWsPHDgQWErvf//71ZpkBgwaVc8//7yIbFllIlsMTCaTCdSSPTaKVWz5GQgehQXb6XRc\n", + "95K3QwfYoubjz5b6jaM14a5A8mUOWmYLx6rJe3Xd2NgI3Eb8G1w7PT3tHt+2fVMqlXSs8NFke9SY\n", + "3WBsdWC8eQwB60R5DCc+4zaAFQvmot1u6/dMTaPuME527dqlLJGXqJX7l/P9ifT7LW5eMc6cOaNG\n", + "Du7HCbnRr8ePH9f7IcB2c3MzYIFarVYQpD87O6vzAPdbXV1VS95jA9H/Z8+eVdcK5vfq6qrW1wbU\n", + "x8FjaJeXl9V1BlbEs4TPnz8f1LPdbgfyIpyclcuDOcUufjBSGGNra2v6bJ5T3/rWtyLPwHNEkrXK\n", + "OAQA97jhhhtcRgqAa3RhYUH7nw+aeArYHpsBloKZHIwdtMvk5KSOaazBV111lX4Gl9zrr7+uZcC6\n", + "x8C6Ua/Xdc7v2bNH72vXs3a7LX/2Z38W+YyNfuADH/iA/NIv/ZKIiHzuc58Tkai7ng8f2JyMi4uL\n", + "8v73v1+/x192zwJ33HGHiGzNqXq9Hqwr8/PzOjaWl5dd7a6k8T9obthg7m63q/2V5E4rlUpuJg+r\n", + "5L+5uekyV55LEcwVvms2m+77y5MzsDn+PBbNuzbuHeep8Q/C0PIHExMT8qEPfUieeuopmZub0w5+\n", + "88039eTV3r179U99RbsAACAASURBVEUr0o+9gEiaxcrKSqL7JUWKFClSpEiR4krjgQceSPw+00vY\n", + "bl28eFHy+bwGiN5///3yh3/4h/Kd73xHZmZm5Hd/93flwQcflOXlZQ02/9SnPiVPPPGEBpu//PLL\n", + "ASuVyWQiAeSMcrkcxHMwwC6USiWNa/CO9NpcarhGJGoBI2B9aWlJj8L+53/+Z/BcBJhfvnw5sF4P\n", + "Hz4cfMZMAmJWBmX6BkZGRoI2YPXsJLAVIxLm04s7UmslGCYmJlw2BMDmmS1dDs70GClYQOwvR3Ah\n", + "rABmENCvs7Oz6j72AkD5954lai2MOIbLgscot58dt+Pj41oejLF6vZ7I1KKc2WzWtbzQfrhfNpvV\n", + "scwBquhL3I9jqfD8uHi3JObSA6zx9fX/3963xUhWXWevqq6ue1+qp6d7Lk3TZgZmmGFuhjDEMcEI\n", + "gxNZwo6ILCyFoMTJQ6Q8RIqiJJal+CUXR0okEiUviSNZeQiOH2xsyWCMhAE7MjgGQoDMBDEDzEzP\n", + "rW/VPV3dVV1V53+o/1v1nb1Xna5pE9pO9vfSM1Wnztl77bX32evb67Ka6Ihp3RcG1ezsrGfhcY1E\n", + "9M0KENkMnKSVGSt3HSmVSvoc6LHLbop09BVy5TXDrTqwsbERCxQRifcd/ljHjx+Xxx9/PPaMgwcP\n", + "6voAmb744ov6PWdyRlvBpPRKMunCyu5uIZ/P6zhAfvPz8yo/MEPsT8brC+SCOVqr1bw1a2ZmRhk6\n", + "a4zxjMXFRS8DdiaTUXbXSnmwmb8jxgF/v/GNb3jX3HPPPVoNgduO9w7+8hp7+PBhEemeRoj4jJML\n", + "Ts8h0tFTVx7lcjnmT4W+4zOW+WZsocsgXY8jtQt+LtCL/QLDCAaY/eFApGyWXiApqSYnOeZqDG6m\n", + "9F4MG+RvsVmcjb3dbidmjU882rt48aI8+uijOjiPPPKI3HfffXLixAn5zGc+I1/+8pdlZmZG/vVf\n", + "/1VEOpuNz3zmM3Lo0CHJZDLy93//9z1fJmtra2ZECL8cLKDDlnMoH1vxwgFhYYKvrq7qM+AUWCgU\n", + "zA0UJgRevL2OALDpwMaAYS1ikMvQ0JC+hNE+LoKcFDnHLwTcg9tnUcG5XE77zk6kGAcrGsP9Pfrs\n", + "gvMwWe21lBmLBxwyr169GnN0FolPUt5IuRvodrut3/Oi5E7yhYUFb9G1nP6z2azKyp2sDF4IrH67\n", + "RT/dNrvOvFzigDOX4wgBR8WtVsuTARcetnLBQD/5GPzee+8Vkc7CgaMnLETnz5/Xe/PG2i2fwBsH\n", + "XoDQBstXEi+TWq3mOZFbGdBF/AjCXuBII3djt7q66kUYisTL04h0dM0yJtAerEETExM6hjjK5P5i\n", + "A7S2tubp9qlTp+Q3fuM3RCS5DMz09LRuMt56663EvrtgR2VEjl26dMl7gVnH8KVSSWXEpYeszPCQ\n", + "G2TGR2LQuytXrqiRi7nEGx/oQbvd1usw1u12W3XG0ifch4+osWm6cOGCHrHxHMacwt8LFy6Yczhp\n", + "k4bAlX379mnAxmZO065uW/p87dq1GCFgRaX1m6epn4zgFlKplFcaBoFnIt25UigUdA5AVhxBbuk2\n", + "roNOikisQDZXscCzXOOQN9IwAprNprdOc1AKl6tKCjJyC3gnIXEjdeTIEQ2RZoyNjckzzzxj/ubz\n", + "n/+8fP7zn9/0wQEBAQEBAQEBP+vY1szmVuZqtkzZ2maHU5E4fYfdZzabjWVzxn2x6+RdsRvaWK/X\n", + "TasDNDScZcfHx/WIznK4Bk2/sLDghYNb4e/NZtPLJt3r2BPWOBiuWq3mUY2cl4hDdq2+QeaLi4t6\n", + "H7S1H4dl3NetH1csFhMLsDLcjPDog0jXamc9YUvYtRiazabpIJgUHpsELqaJNlj0rnV8KOLr9ODg\n", + "oJeuYnl5OXZ04bYTWFlZ8ej0drvtHTNxODhbkmATLCb3W9/6Vk8ZjI2NKYuC1BeXL1/2rOOBgQGv\n", + "Nh7rGpjCgYEB1Us+osARAHSbLUp28HVTMTQaDdNiZJ1xWaxms2mydmAi+JiUa+IBrmXLIe7MbAAI\n", + "4280Gh5TMTQ0pH11i5wz1tfXVUZ89GfpHcD6h35iHFKplMfqtNtt7zq+Bp8tLCyYIfGQh3UEyKws\n", + "2GzIamBgwKwmgPFi1wjObyXSGSN3rdrY2FDHczBEO3bsUN3CKcTRo0fltddeE5HuerewsCAf/vCH\n", + "9XkinfHD2FjuGVwvDwBLxVHtrrxE7GAS6NfExEQsW7xVv9TSY+saa45AhlZBdl5HkxzPcR0HXGDc\n", + "2+22fgbWaWlpyUsHY+Xm6tVXd23k9ZjXDOgTnl+v1687S/z15J0KtfYCAgICAgICAraIbWOkXAdI\n", + "a9fLSQZhMbA/ieuXUKvVYqkQRDpWoBum2mq1dFcMS6PVanlRhHfddZda4VZSODBRg4ODasWwtQgL\n", + "0rI6OFwd/YTlVavVTAsTfcL17DgOWfRyaIdVzr5Nlh8UZ+m1WCyXXavX615GYw7PtlgWWPxRFKk1\n", + "AZaiXC57Vdyr1apaaWzRW3WSkiwvvo5rNYnE/T64fa5est8UV7F3s3CL+Mkj+dwfKJVKsWSFaG/S\n", + "fOAwZDfhpUjXSmRfD1jL+IytM4zf0tKSJ7+FhQV56aWXPBm4fiStVstjBjKZjPaJGUo37LpWqylb\n", + "DDmWSiWVAWRWLpe9rOgsD5FuzTROf4E2wCo+d+5cot8DvltcXNQ57K4raKNIRz8x1kinwI7CsLgv\n", + "XryobQGDWKvVdB254YYbRMR2Dk+lUqabBe6TxJQwMO6WH1A2m9V5bWXCZt8xi9lMckrH+BYKBTOt\n", + "DcbdkjP6xnMU16XTaU/vOGEoaqlaFQ54LjKz48q5XC7L9PS0iNjsCbPqbjqNy5cvq9zQx1qt5rW5\n", + "VCp5jtH1el11bHV11fPn6eVjDP2FnC0nbfbDZEbc+g3WfHwGx2v+bbvdNqPw8Qwwa9lsNvYeFum8\n", + "v7E+Id1PvV7X9SEpSTSn7sG7htftftMCcZCK69Paz+nMtm2k0Fg3+7OIP5k2NjZi0RzuPXjBcBWL\n", + "nW/xwrhw4UKsZAo/S6S7ELz88svaLkwkzmCMRWxycjK2gQI4J4YLznPllhJhhUQ7R0ZGvEiz9fX1\n", + "2IIi0hl8dvYFeGJA5pzfysq7hSMVpqbdBXZkZMRTNL4G/+ZFkDPvuhvGer2u48lHE7xpSYLlZNgP\n", + "RWsVsrSO//j+3Ca3gLZIdwHixcal4HuVNeAC0HgW7gN5W1R2r74mHbVCryqVih5Xcx4rPg7C9W60\n", + "EGdPdqNeXLhH2QzeoLvoVcibZWoVqcUREb/Q3Ptz5CUwMDBgZld3c1mJdDcN+Cyfz3sRiHz8gQ3a\n", + "xMSE3tsKrgBqtZq5eeGM2P0Ac5mrAuAeQ0NDOu5WVCteckNDQ6a+A1bAC9bttbU1fZ41l1gn3Gjn\n", + "gYEBM/t/Ui4wbIosfXrvvff02BqbKmtDevfdd2s29CTUajV9d2B8r169qrJGH60Nx/r6upcF/urV\n", + "qzr3SqWSN196OY67R+zW3LR0zJqvVukk7osVtYl1IpPJeJnDG42Gt4avrKx4hgNvCJOiEPnYku/L\n", + "0a64B9oA3eX2WdUn3tfM5gEBAQEBAQEBATa2jZGCBYDQYHaqc3eszMZYIeQMDrMV6ew6saNkx0k3\n", + "vFyku3u1QnCtwqKwEKzMtePj47qTx7P4SAR/BwYGdBfMfXOtMW4nLBfePbO1gn6wtcq/h8WCfvZy\n", + "VLSse9cqKhQKXugutwv95IzGjKRss2wJWfSqyypafUmn095nfCRqUdlu29xnWg7t1lGIa8lls9nY\n", + "saxIxzp19XhjY0P7tFlWXZcZKBaLseNKPIMZS7TXZfkWFxe1mC73F/3gwIzrBebl8vJy378HK8dH\n", + "s1aaBB5/OA9bwBpi6bXFSDUaDT0OtNgwyJ5zt2HdaTab2mcOmnHn3sTEhM5nZrVc1sJ6Poem95sT\n", + "DLpWq9US84yBCYmiyGsLOyUDe/bs0bWB1wOr7pvFcLjh9CI+O5TP501mFXMJ7Fe1Wk1MK8Cywv0s\n", + "dhQO6//xH/8RqzDRC8ViUXWMj5vcNrCDNDO67nXMalr95pMEzju4WUZzwD1y5DxsWBN66ZMVbNCv\n", + "c7abmZ/XP06d0O864a6f/M7nvYTLjm3GmPeT9kB/0/eVAQEBAQEBAQEBMWxr+oOxsbFE5z1YGtVq\n", + "1bOoC4WCxxjceOON6hwOWD41bH2yMx8csmH9NZtNM5mmlR3WdcyOoshjUay2tFotPeNnJsy1xorF\n", + "ot4P13ECOK6yDauXLRx+tuVQ6lqYqVTKPINP8lFip3PXz82qD8ZWjZWJfjMLB/dMSqppoVgselYx\n", + "18uD/CwrtVgsahvZJ8CyXlz/kEaj4TES+D0jiiK1mtlvAuMBOa+srHg6xvf6SbIXA5aFOzg4qOPL\n", + "NQbxPKtyPPvcoE9uHTaRuH+kJX83pQQzPyL91cWyfN9arZbWOoQfUb1e1zFGYkdm7KBDExMTytpw\n", + "slTIAz6J6+vrusbgunPnzqmesB+Ji5GRES8JLvcV/oybVU9gHzQ3GSWnh8G6uLGx4TFSnAgYmJ2d\n", + "jdUXFenoAfrJjBT6i7bUajXvGRMTE9pf/HZ8fNzTxdXVVX2HWCHzFjDOzWZTn8GyhP4msVC9HL2x\n", + "jvFv3WzxrVZL5QI5Dw8P64kJz4GkkP0oijxd6bXOWswgZLlZqTZ3rDlIyPWLEoknCcWYcLJb18nd\n", + "OoXYjA3iUx7IHPfpJTP3nuxYzuzX9TBRwLZupPiFi4Go1WpmTilQzTgeajabniJbOTfq9bo6AELp\n", + "lpeXVeF404ZFiAtiuhsk66U5PDzsLRjtdjtxEqDfXOzVou+x6Fh5lrCJEukuDu+++675XJ5wmAT8\n", + "mSvLXC7nvaTdkgW4DkiiYjd7qXOmdzdDsgUuo8NtwaLA9Kz7ck2KiBOxIzTdY19GFEWmzLGBYuda\n", + "yJz1ynr5o424R6FQ0Bctv1DdiMnr2Tyxw6ZIvNwCl1hwF1rOhO861Lv/xvd40V+6dKmn07hId3NV\n", + "qVR0bvKxBufkwrN4k8Y5pwCrSKqLKIq86N61tTW9N+YcA2NerVbVuRht5jI6HO3GhptIPEIXY229\n", + "2HrNLc583wvu8Sf3WaRrxLAc2XGbHafx15IH+muVhwLYeEvKlM7AGnjmzJnEe/d7FIS+tVotL5Bi\n", + "eHg4Vi+2F6z1Z2VlxRwHvE/QPtZnGGVsQELe7E6yY8eOvpyeuU0cxebmfWLHfWBgYEDXJXbgtnTH\n", + "LTnDecT4vknBIxaSjtWsgCB2Xkcfx8fHtc3svuIeZW8WuOSuj4nt3vSKgICAgICAgIAAE9vKSKXT\n", + "aWWfYO1MTk6aDoLurnhjY8Oroce0NpxEr1y54oUN5/N53dFa+XTYMnN30hYFPDY25jkDMnPFzr9u\n", + "ugV2CGeWAv+GLNhRnXfmYNv4SBNt5PBsBvrEx2mupddsNvsq7NsrxwY+5wzUgGVZwHLI5XKmVec6\n", + "VTKDADAF7RY8ZVjWEWeTZ+vYzRxtOZin0+lEJshiq9CGqakptcyT5M1h48xg4jdsPeF7yJELXkPO\n", + "Vj6sVqsVc4IX2Zzh4r5ZbAG+Bwvw0Y9+VNsAx3DL+uQ0JxaY/bB0i2sy4v6QB+fuApaWlsys/m71\n", + "BAaYkoWFBdVzrDvnz5+PORLjenducj68XkfJvZ4v0l0Xk9IgPPTQQ/LVr37V+xz3xPrIQRjMGros\n", + "ZbPZ9MaM69sBfDwHFAoFz3UjiqJYjiWReE0+Xtcx1mD28vm8mRbCXS9EujJHP3K5nH4G9wrUmmSk\n", + "02nt72aOyBazduedd4qIyHPPPRe7J/9tNpvq3A4mqlKp6DyYn583M9+jL6xPVg4lFyxzzgxuzXfc\n", + "m3NHJaVR6Bc8DphzSewX1810Hce5H5sdbwMc/MM1Zq1AtM0QGKmAgICAgICAgC1iWxNyjo+Pe34w\n", + "Vl2i22+/XZ08Ofkadqe8A4UFZzmxJ9Xzi6KoLwZGpHvmDb8kzqIMq5f7BUvCCmFlK4CZEteZt9Fo\n", + "mNnJcU9mY9gRzwJ27nv37hWRTvoGi5EC2NpxP+O2gB1bXV31wrHZouaM9W7StV5WgMswbWxsxDJ8\n", + "c9vd690UC0nV3fk6K0twsVhUqxlttULnGRj/sbEx1Qv8lv36GJAvWNKrV696rESlUlFdxpizn1iS\n", + "jx7XeORUHFYINr7vt8I82KB2ux0LtxcR+f73v6/Xs1O62+9UKuUxh/v371fmGu10xxIW/OHDh0Wk\n", + "M9exFuB5KysrXiDA+vq6ri08d10nXfbnwWccls8O3GBccD07KEMe7LthAc/PZDKeLjabTe2Tm8CV\n", + "ceXKFfnUpz4lIiJPPPGE9z2309WZm266KVZLFLCybLuIokjvDdnyunzo0CERETl9+rTeD/1IpVJe\n", + "WwqFgsoXa/Xq6qrKjxlAl1nJ5/PeOtxut3Ws+b3Dfq78F/cR6Z0cFvMalS5efvllrWWJ98/4+Lhe\n", + "BxYyk8l46/Xi4qKu0RcvXjSz3SeF8qO/HKjEfXfX2oGBATPx8Wa+RICVAd1NL8OfWW3n9AcW65XE\n", + "skE3crmc14/19XWPVeSam70SI4v05yO1bRupVqtlbppGR0dVST/2sY+JiMgzzzyj37MTJC9QInbO\n", + "ExHxonFE/CObqampni81F9gkYAPFR1Fu9m4RO8cQUCgUvM3kwYMHvdxUmUzGe1nfcMMNGulhTXZr\n", + "49NoNGIFbkU68rOOu3hjhN8CVlFY7udmC45IR1bucSpvDhhWhAxk7ZYr4M82A57PeoXJbEVs7t69\n", + "O+bkj7YA1lhbDqVANptVB2n8XVxc1A0D2jU6OqovFi4LYzkvW4VM8RnGKpVKeZsmi6a3sk/z8SF/\n", + "b0XhAFa5oSNHjmjbkdUbOlYsFtXpFu3ENSLxiEgrgz+Oum+99VZ9eXPBaBQZ5iNEXMcvUuglDLSp\n", + "qSm9Nwy4AwcOaAZ09G9lZUXXHW4b5hy/xJI2vHxEBd3qVfxcxHYsf/bZZ+WP/uiPRKSb6ZsdqtGW\n", + "vXv3ekeqCwsLXtFnbhewtLTkRR9fvXpV9cQybIHh4WHtE7/QOHIQ7YROsNGLzQYi5fiIko943QLk\n", + "HH0GcOkURr8Rga4Rc/z4cS14zdHWMEDR36GhIZURlzzjQvbuyz6bzapO8AYEbUhadwqFgr4zIPte\n", + "OajcjSpHhrOLzPUWBQbYYN3MKd0tVM/vPY7aS8oLaDnFA3yM209BaP3dplcEBAQEBAQEBASYSEX9\n", + "bLfe74f+/50e1w8CM1CtVpWSZKbm4x//uIh02amRkRHdAVu7WNyjXq971CRn2YaD3+zsrBYNhbVm\n", + "FWfFs/m5g4ODPXf9Il2ryGLgJicnvdB1PgJwGQeRrmUwPT3tWXqFQiGWR4prIQHIJg+riC04foZL\n", + "cbdaLS/fUyqV0s+Yqk06PsN1rVZL8/OAgePafZCBZSVajBSrclKYNKdxYOuP+45+u8zl4cOH5Y03\n", + "3ujZN86RYh05us6qVt03ke5RCMad9csdF5EO8yLSkSPnWhOJ09oMK3+Vi3Q67dVhtK7L5/M6rlZu\n", + "FsDKcD86Oqrt4zxMAGfqd+cZH7Vax2R79uxRpgJzfXh4WPWNGQsXnIEaDNjw8LAyUjiqSafT+j30\n", + "an5+XqampmLXDQ8P65xLYmgGBwe9Y+t2u20eP+zbt09EurLuxarjPr/9278tIiL/+I//6M35PXv2\n", + "6BoF5ufSpUtmIWGA1xekRHDTOTB27dqlhaWff/55Eekw627KgYGBAWX0sA5wniu8LzKZjMqU3SEw\n", + "ry12G7Iol8uqixYTwylAcG9eJ9yjrMHBQe95v/7rvy7//M//HLtOpFtcG2s/u6fgPTQ4OBg7VkWf\n", + "4VzfL+uez+dVP9GPd9991yvSznrHdfpchtNas3iuQC6NRiMxjUFSVQl+/1gMN+5RKBRijBru5xZG\n", + "73V0586zXulosLb02i4FRiogICAgICAgYIvY1vQHvLvDzjyfz3sW6y/90i/JU089JSJdNqhXLR73\n", + "PJ8d+BCafPHiRb2OM9C6/lWNRsNkEFz/kJWVlUS/FDcE2IW74x8bG1PLgS1X9AXXv/POO1446Nra\n", + "WmLYZqFQ8NpjWQ233HKLWu3spO/6RgwNDXnWfLlcVvaCGT83vNyqL1WtVr20Fnx/lyESiVuEzGL1\n", + "AvcBY57L5WIy5L6gXSK9k4TComHLB20FuzQ/P+9ZV6zD8PXYuXOnnD59WkS6Y81Wu2U9v/nmm/pv\n", + "sJicdRxgPe2HjG6327HM8Xi+65vBMkObU6mUjiGYJEt+S0tLqu9uygCRrkVaLpe9eebOWU5+KhKf\n", + "39Y8BJvKyVKxTlSrVb0/2BXoA8tjY2ND74N+zM/P65qG3xQKBa82ooVKpeKlZ+nFPrhZnXsBY/i9\n", + "731PRER+/ud/Xp599tnYNdeuXfNY3sHBwb7DwNlnTMRmg6vVqjJRgJVEcmBgQFkl9o2DfliBQVw/\n", + "0w0s4tMP6E69XjfnkptsspeDM55n+a4BzzzzjLLFPEcxl3luYiyZneM5108wVCaT0TnASSvhw2cB\n", + "1/E4sJ8Q3pWQm8Xesm+e5SvF8zYpaAXXcfogZpc4MbZIZ/5btVTxDrHaivFi31Zu8/X4RgHbupHi\n", + "RRA0OFPTeAFhEyXSpT1ff/312MZIxHbIq1QqSlfzd+4LfHR01MtHwo5nwPj4uD6Pv7NKrHDBXpHO\n", + "YuxuzObm5ryjMesIkCMcWcndbM2cDwkvMRG/nAqD8wxZiwf/2/29VUiUFZTz22DR4mdBluxUy5S6\n", + "SFy2lnJbGWhxD4uOrVarsehP9Av0N7843N9y4Wt+Ph9/ArgP388ty8EbC9zbesa5c+f0OADy4002\n", + "vrOie3qhH4qdwX2DrDkTOX6PPkVRpPMMz9qzZ48eLaMfb775pt6HqXY3ympxcTHxyFbE1m/3pVqt\n", + "VnVOsqxxHV5Yu3bt8kpO8RrBmzls2Pbv36/fY95w8WX3qL2XPqN/1hwA0um0bjaSqgAwXn/99Vhf\n", + "GYODgypzzMtsNuutsxY4WAfX8XrL8w19v+eee0Sks7m78cYbRaQbJNBsNnUDhbnC1SzQ7yiKvHVl\n", + "aGgoFjwiYgdFWA7kqVTKM9bS6XRiGZWkjcHs7KzK+hOf+ISIdDZX1uYU7UKQz/z8vLaBj7CBUqnk\n", + "GYy1Wi0xwAeyHBgY0DZYJc8AnsMMNyK13W57LgDuffqBm4Gd/221z4o0ZMd3fFcqlbyM5tb9CoWC\n", + "tx72U4w5HO0FBAQEBAQEBGwR28pIiXRZE7Z2YHW6VoVI16JyfyPSORKDhQkrkNkdK9cJnCo3q78G\n", + "62Vubq6vooZRFKnVa+VQAsrlsrnjt/LcYGds5cOCY2Ymk1EZMFOEtrDDJlgbthytYyBuv2ttWLLg\n", + "HTwseM7SCwwNDWnf+UgOz+X+uZmKrfpcvbKnu2i3295RCTs3MmAFsszdsWEnfCtHGay38fFxPf4A\n", + "68HZ/RGSz+kAmIHhfGUiHesJv+Xv4JTK2YI55JvlwBgYGPDqUeFz9BPAv6FD1WrVux+zgbjv7Oys\n", + "Vwx2fHxcr4O+1Ot1k13iMH+RjqVupT/gtsMKh37UajW5+eabRSTO5LiWr3UUyH20aqZxxnowNHwE\n", + "yOkdRHo7wfKxDLeNMTw8rLposdhJsObHxsaGpqT4t3/7N30+ZJXESEVRpEfTWH94jnLlAsgIuQHH\n", + "xsY8B/5ms6nrDsZ6bW1NZYn1eHFxUWZmZkSky9BagRluW7lNInG3CVeHMpmMOX8ArE38Ww6iwRr3\n", + "ne98x/stA/3F6QyznzfddFNs7RaJpzphvXQdrfkIk5kwl4lKp9Me08RzEDprFVNOp9Padw6QsJh6\n", + "wM01KNKVr1X9IpVKmYEv7juJ07Ogb9YRH6eeQT+td3E/CIxUQEBAQEBAQMAWsW2MFOowwWLA7nlg\n", + "YEAtBfbhwLkxh4m6zsiXL1/W+7Glh10s7/DdVAe4P4MtqiQWin2pLOs9KckY74ARPlwoFDwLc3p6\n", + "Wp0V2WEVfeNK9Baw62dWBBgaGvL8ahYXF5XZ4BBh60zeBVttaA/7awHr6+uezwufZTMs9sQN3+Va\n", + "TOwgbTnzu9b1zp07EzMHQz+uXbum/2aGDYwg39fN6s3V3Pka6C/X+bJYR+gsO27DwoTfUSqVMtkJ\n", + "Nyghk8l4fk4ivj+AlXqCnfqtrMSQPetBUk0u1ke2UjGX7rjjDhHpWMQ/+tGPRERiLFOSFbl3715t\n", + "D4dlW755rt9KKpXy0mOwJY77sQ8NmMaZmRkdO/xtt9uJzAbA7LjlfA8MDQ2Z9df6Ac9bWOVLS0s6\n", + "hjwOkK/LxDIuXLigTuYAtxky4HQUPN/ctCoMjAvXRkMbstlsoiyxhq2srHgyjKLI8xNMpVLe6URS\n", + "2LtIfLwgI9bJJLYQ8t65c6fOA3Y2h8/d66+/7mU+twJGmD3bLADBrTPXbDa99ZxZanzHfknMZrlO\n", + "61aABMuS1w6XneqVgsBlnwYHB7130tramteGYrHosb8bGxs6n5MqU/SqEMLYto2Umy+GIy4Afnm6\n", + "k6BYLGrn0VErM+uOHTu8AqwjIyOqrIhIsApf8sYBL7bFxcUYleu2mZ+PhTapACsrIDYs6XTaiyDi\n", + "iA+0eWlpSU6cOCEiIi+++KJ+Pz09LSLxYzx+KcF5H8+1NhHz8/N67MnjYDmb4964Rz6f1xc76HZr\n", + "81ev13WDxQ6j1hGsu2liyt5yjMffbDbrTdLx8XEvAqbVaiVmOeZJ6L5wd+3a5R1X4XORrn5cvnxZ\n", + "+4Z+82YS911fX1edxeZ6YWFBdRb9OXDggLz11lsiEj+GwgsN13MRbCCpJALDMiB6ZS5PMhhuv/12\n", + "Eem8UBGRCMzMzOjY4Dgsn8+r3Fi3AbyYBwYG9GVpYXl5WTdD7Lye5JBvbRiweW40GvpbrFlciQB6\n", + "cOjQIS8X2LVr10z9dcG5bJIMuGKxmPjSsoANfyqVUtcJ1oV///d/F5HuXJmZmdGNwGZOt1hvOHLS\n", + "lWU6nfaMvaZTKwAAIABJREFUp1Qq5Y0Hb7jw3JGREW9+NxoNc5PJ74QkuEfZ/eais1CpVHR8sVG3\n", + "CjeLdI7qRLqyOnPmjEY4c+4oLv3TTzss1wzWDUufkuYtvwNZHq5cLd3gNZ/Lbrkybzab3u/z+bw+\n", + "1zLWk3LV5XI5Xe+wR1hdXVVZ4r327rvvJm6ggH7kHo72AgICAgICAgK2iG1lpEZGRkxa3rUERkdH\n", + "1aKBRc+7bIsud7PAinQpzF27dulzredz+Cl2vriuWCx67Bm3Bb9dWlpSCy3JKmq321rgEv39r//6\n", + "L/2ej4p++Zd/WUREnnzySf3MdUAulUr6XGYh0AZkQu4F9Hd0dNRzbuRcIbj3xsaG17/h4WE9LuB2\n", + "uRncRboWAxia1dXVxLpWlpNsEu3eaDS8I2CLql1cXIzVTMR1YInYYnbTE2QyGTOjtBsswblsWC/x\n", + "GfrNLCUfe7FeinSKvYL1wLjMzc0p48OOo1adLnwPuTBbYB2RA1bm/WKx6DkWb2xs6NjAsVhEvHB6\n", + "TuMA9qjRaPQVduzmInMdnqMoijk6o5+Qr5V2BddxPyHzXbt26Tig3adOndI+4Vk8bliz1tbWtH9J\n", + "dclY16wjXmDnzp2x48V+AHaJdR19tIpvX716VS14MCucmoKB+Q35TU5Oeu2+cOGCN1/37t3rzZ9L\n", + "ly6pnKEHPM4PPPCAiIg8/fTT+luMwdWrV/U3m+Vecuu17t69W4/gmYlwWW12rsbfcrnsvXeuXLmi\n", + "98bae+rUKdUDDp5y2ZXx8fHYcb+LbDar8w9tbTQaOnfR1l6sJtrA7hD4Nxf4Tko/AFipgvh6Pgp0\n", + "r7NkuVndvqR3qhWokk6ndS3DXz665+NQyz1nMwRGKiAgICAgICBgi9jW9AfM7mAHaSUe4/9jB760\n", + "tBSrwSXS2T3DImBLxE2CyUn2ePdpJRTj+ncinV2+u6PmjMWwRIrFojIhYNOs89yDBw+qBcRWrOvk\n", + "WqlUtM4gcOONN3phw6lUSnfc8K/hNnCWYPSdZYVduMUGsCXJrJHloAjfCPdZDK7xx/WSks6k2bpP\n", + "uh/DtdbZSubxd8e1VCp5df+4/qJbX68X2Dkd4wo9rdVq2vfN/JagW3BAPX/+vMd6MYuSlK230Wh4\n", + "SVjZUdX6LdgqtjRdK68fcLJH/MWYWP4QbrZyRiqVisnfZTOr1aoyFWhjqVRS1sfKNI552Gw2Vd+w\n", + "7ly6dElZQAbaz+sA+sf1+lwn3YWFBW99YmANGRwc9Hwtr127pgyS5VfIgG8UWCVr/lhzlBli6Ozc\n", + "3FxsbRGJB7FYqWfw2+XlZWWz0B+LDazX657fKmf3R4Z21neAx62fVDUi3fXWCoqxTk44ASUHXrgM\n", + "UqFQ0O/h85VKpWJMFJ4BFhVrJ6+Dlg9is9lM9L9lYEyga6lUSnUAcy6VSplMjqsXnGQZa0O9XvfW\n", + "WU6WmpRBnhPQAta48nPZyR3sKpjToaEh7Rt0a3V1VZ/Hmd+xpkBPrOCafrCtGylr4Hgh5QXw6NGj\n", + "ItJdCJaWllSYWLx6OfYhzwic+CzKkTdSliMql70AeAHEgobvp6en1QE1CePj47oZghO5RaGWSiWd\n", + "NLju3XffNYtzYjFyC4GKSKxNaCtvSq2IDywuqVTKy/vkHoeJdF5e7rj2OsKFIvNEcl+YHKHHZWbc\n", + "NlsbMKvEBR8lcVRUEnWNiZbJZPQ3aOfa2ppZXBry5RcC9NvaMPBmB/+GfpbLZR1rbJ7y+bxu0rAI\n", + "N5tN77jKijriUhI8BpApL4pcUkOkI1PoIGQbRZGXZTuKIt104O/Vq1dVjyEDK/9XPp/3IuWGh4e1\n", + "DVZkoIhdDBjXuptike6mtNFoeM7NfC3yAv3whz8089u50WScdRz927lzp1deKpvNqixh0PBCjvtW\n", + "KhXvGDyTyejx+2YbWWxqrE0zUCwWzRcz2oUNUKlUMstCuTnSeHPFhqj1DAQjYM2y1vFKpaL95DbB\n", + "jYD7k+R8n1Tk3NrY8trFwSL4Hmvvjh07vGhgPrZKcmyuVqteJDkb49ZvrdxR/G8uFdWPU7XlImFt\n", + "RFnX+MjzekurJG2yeCzxjuFyVZwnKilXFAPtstZogPuLtbef/oSjvYCAgICAgICALWLbGKl0Oi2z\n", + "s7O6s+S/2OHDKjl+/LiG5TLcAsVsSfJ3sESZfXJ/K9K1kK2jBOzumfnBTrnVaqlFg/ueOnXKcxS1\n", + "mIHR0VHdkXNb3FpYvGu32syA9e/WCXP7xLWpOHO7SJzmh/x27tzpMUssD9R7O3PmjEddcwZpy+EW\n", + "loFlKbPVkHSE0W63vXw06XRarRh21sY9rUKdQLVa9VivnTt3xrLNo2/u8ZFI15KBTuTzeW0LjkYy\n", + "mYzqOaxsDvPG/ZaWlnoW/GVEUaRMFI5T6vW63odrKbr52oaGhlSfksLvNzY2VAaQY6VSUZlz2DXY\n", + "G2ZxrDHE/Oe5ZznSu+Asxr3ai8+QkoODBdDWo0ePmiksMK8hK8shW8RnhK5du6bjDoZhcnJS2RP8\n", + "3bVrl8lcuvfNZrO6JnAYN36TVAyZj7whi1KppG3AeOzYscOs8whAN6x0Ke+8804s87VIXDc575Ob\n", + "2qVUKqnLAa8vrtPva6+95gWKpFIprwbp4OCgypRr/CWxxmiTG2ADuDnSeKwQ4GDVL6zVanqa8p//\n", + "+Z+xdorEcyFCpjiiWlpail3LR1sicVnyOoZ/87sBawFOZ4rFour02bNnRSSeVwv6sr6+HqvPh8/c\n", + "NBTMvAGc6mCzmpGug7xI/NhQpCM3qxYsdB+y4mNX6Eu73fZqX2YyGdVVtI/zDia12evDplcEBAQE\n", + "BAQEBASY2DZGiuvniHQttEuXLumuE39//OMfq/WCHXypVJKXX345dk/elcOymZmZ8fwm8vm8fo/d\n", + "9traWuzfIh0rBFaldWYPX5Rz587pDh4WzdjYmPYJO/+xsTG1ZJDK4NVXXzV9e7iWmEjHQddNXsmW\n", + "FayYq1evmkyUG+rK2LFjh8c0cRgo5MrsEzstA7B6/vu//9vz5+AQfFh3Vg3CwcFBtRi4VhwzVtxG\n", + "Fxx4IBL39UHNsPn5ebPWmZsYc2Njw3NertfrJgtoWbLweYDfBMvYYpeg45yxHM/fsWOHytpK4wC5\n", + "TE9P6/O4TS6zxoDseyWpxHPwjFwuF0seKtI7zBwMIeTMliGHHrs6VqlUEpmofpHL5VTWlh8RmO7J\n", + "yUmPzWTfPCQ+3bFjh+piUkZ1toqBM2fOqNM3vpuamtL5arFpWJOYBUD7Wq2W6qKlT0AvJ3I3YePy\n", + "8rKG6L/99tvebyCLWq3mBaMMDQ3p2HHmatfvR6S7JkDebgoXkc64uSz/+fPnvQCJSqXi+Sqx7y0n\n", + "trVSSIAZ7sVEidhBLBzuD5k9//zz+j2S4p4+fVr9Uq3xZXYTY4gx39jY0Dki4q/dvd4bVqAQ5udm\n", + "6SAsWIEJrjO/5edkfTY4OOix3VyTj9Gvz5YbDNNut02mDrA+g47V6/W+0q642FZn88nJSVVQpv4h\n", + "GFClXNIBf0GnithHcW4hS5FOlJtIfNKwklglIly6nRdXN3W+SHcz0Ww2YxlqReJ08N133y0inZxQ\n", + "7mLDLyp22naPFG644QY9ruA8PRaw8KytrXk09erqqucAurGxoX2BvJaXl/X4jhc/LIyvvvqqfobF\n", + "AG1mR1Euu+PS9/V6XRc365hss4gK6AB0hycjRwe5L9VeRyOQEfp46dIl79peWb0tZ39slrAgXL16\n", + "1cuGLNJd4LGJ4GMn9zhCpDsfXnvtNf0Mi4NIt79ou5XJXaRLe2Mxqdfr+hwueYM2Y2NQrVbNfDPu\n", + "5owXemtDCrA+QvZ33323HkMg038URYlBAoODg/p7nvdYdDEXTp06JQ8++KCIiHzzm98UkY6M4IyO\n", + "jcWVK1fkIx/5iIiIfP/73xeReBFsyJRzaHFAiHusPTAwkHgsx8D6hbafOXNG176kzeb6+rq3RvLc\n", + "wwv8ypUr6lSPv7Ozs966Yx1tcrkSPmrhIuMiHZni91hfOCru/vvvFxGR7373uzqnrJxVx48fFxGJ\n", + "GdNWeRasoxyhheuazaZ5nArddstviXTn5cjIiOoElxfDPOTs/dbagGfg6LHVamlAAL+HOKO+lasO\n", + "suENN2RubYDYKML3uAfnWsJ4NRqNvqsb9GPsbla2httpVbNwy9Dw/Od3gzuGHMCD/g4PD+u8YZ3B\n", + "mnDrrbeKSJekSEI42gsICAgICAgI2CJSUb+xiu/nQ1MpL08ELDW20GDNMtX20Y9+VEQ61iDqFcFB\n", + "cvfu3V5tt2azqTtM7LLZosYOl8P48bxeu2dYJdjdz87OmvmrAD52A6MDK39gYEAtOS54iqMEMASp\n", + "VEq//7mf+zkREXnllVfUqsDOe2JiIsboIUs6hx9DDhz671odXNSWj8tgqXIahcOHD4uIyBtvvKHP\n", + "AgvAebXYMVGkd/bapJBfq7ipFXbLRxTusRZT9fxb92iXYdVfgxwzmYxndUZRpKwYWJuVlZXEIwRg\n", + "x44dnqV88OBBZTj5eMMdtxtvvFHbbx1Ho7+5XC4x3Qdf388SUSgUTLldLyBTrr9nHVXfe++9ItKp\n", + "HQl9+cIXvuDp7Pr6uh6x4358xMMFe++77z4R6Wabvnz5stx1110i0plrIh12Ab/BGjM3N2cenWKd\n", + "wNrw9ttv62dog5XJn2sjQva7d+/Wccf8P336tH5vHY8B+Xxe9aTfunEua90LeH4+n4/lWhOJF3MG\n", + "UqmUzk2s2+vr64k6hnnUbDZjRXxF4gwnxrxSqXhpCPg6rMHFYjHGogNuBQE+hWBYa+FPgqR8YgzO\n", + "S5Z0pAvk83mvQPn4+LiOE2TVi6F2j6OZbcNnuVxO5WsFEeH93m63YycSIp1xdWtQsvM615PEGo31\n", + "OJ/P63vCWu/eL4DR6qWngZEKCAgICAgICNgito2RGhgYkGw2q9ada0G418NKwN/Tp0/L9PS0iHSZ\n", + "i6WlJbN21rFjx0RENOssWxhgOLgmFz5rNBqeRbZnzx5tM/w0OAwVuOmmm5RBYBblC1/4goiIPPbY\n", + "YyISdxj9nwCGF8xWr2e5vkqcYf6OO+4QkY5jrsW8WTUAXQs9m816dY1qtZpaLGyFcfZdbpML14Lj\n", + "0HRUUp+dnVXmEuNRLpdNx9MkRsrNNM/tE/GtuSiKVKbcN1cGlUpFP2N/PviAoM0WO1cqlZTtxD2g\n", + "k/0AjAr6XSwWY9moXfCYuoEUzHRC9gcOHFD2BPP7a1/7ml4HH4RMJuNluU6lUqqzeG69Xlc5W+1k\n", + "PwhY2+x4DFnlcjnT3+Thhx8WEZHHH39cP4PTMHw46/W6WujMlMFCdp2cRbpr1vLyssoGsmen7kOH\n", + "DolIR2ddlnD37t36mw996EMiIvLee++prlqpGxiunwczo6ynrh4zM2AFieA7ZtY57Qcn/RXpjCUY\n", + "JmZ3sZajykMmk9HrOHErM4i9wD6L1rzFfT/84Q/HHMRxPfoHefPaznVgoQeWLiLBKNdcxTwrl8vK\n", + "nmH8R0ZGlOHC/dg3OIoi9YeF3vVKOuqmFOJ5k4ShoSEvDYG1Tg4PD3v+S9a78nrASTfR5usF1okD\n", + "Bw7oeKN9zMBjfLlvnOATuoU+gjFNYqS2zdm81WrJ2tqal+NpcHBQBxGUfbvdVqcwOFyKdKPmXnrp\n", + "Jf0tFJ2z/4J6teh3XrDw26Sjjmw2672srCKu7GjOL+a//uu/FpFkR1uR7uILJ7hekQ2uE2mvIxb+\n", + "zKLt3c1KuVzW53H+EmtiYWLzfa3ClFBq3lzh3pCHVdSSN0i8eXKVmqPY2HnQdfq3sqJns1lv8vIG\n", + "mRct6Bba3Gw2zRw11ni5496LjraOHFysrq56TvP79+83M6BDzvhseXnZiwJbWVkxjxfcbOdcYoX1\n", + "Bv+Gk/25c+e8skbZbFaf++KLL+rnWEjhIH/p0qXEqLjNjkEwbuz4ihdaOp3WtQPjf/nyZfPYFX3h\n", + "cePoMJHOSw76yflo8G8+puWyGC44sha/xcuz1Wrpixt6Xq1WTSdzyBDjNjc3573M+T44brQ2Y+zo\n", + "zXmEXLTbbTWyoJPr6+uew/jKyoqZ2Zyj00Tikbo8B90N1ODgoG5iMZfq9boafzBOarWa5xbwwx/+\n", + "0DMgR0dHVQ7WMSg2cnNzc/pvbHx4zDF/d+3apRs33Jc3XtDPcrksP/rRj1RuInHdTqVS3lrBfeci\n", + "zVaOJ+gEnNtHR0e9414OLEhyCt8sgzhvzN3IULj1iMTfF1xmB4CuchSjWzx6fX1d5wXu9+6773qb\n", + "f56D0AOrRB3fG3+tYAcX4WgvICAgICAgIGCL2DZGqlwux6xZMCacIRm77aGhId0FI8z/pptu0my4\n", + "vIt12YdecMMjOfeE5Vhs0dqw5NbW1mK5U0Q6LIAbDs7h6Ax3lz05OenRxeyAzCwULDlYPXNzczHH\n", + "fYDZG9eKt1I6MNPBcrBybGAc2ILjMHuRjpwxrpBHLpfzauhZlhDrCZiflZUV7RMXm8a4WjmDkjJg\n", + "s+M2ZGBl2eX7cI4qi2Z3c3dtZslBPz772c+qFYagg9XVVc8hc3l5WR38IVsuSv2TgNMDuDWqmC3A\n", + "dTt27FDWA3IbGRnRcHDOeu3q8fj4uDJlOHLbu3evsrKQAbOq/RajZQaMf4sjk1/8xV8UkY4OuQVn\n", + "8bkLNxDAKrA6OTmp8rCy51vtx7FWLpdTdgfrDgdw4K/L4gBYCzgjNfSDx8FNa2EdXVSrVS8djdVf\n", + "ka5+WMcySSz/0aNHte9AqVTSdkGH9u7dq8wg0mBsbGx42c5FuvnBwDxabWg0GqqDOC61irrz+gNW\n", + "aGpqyqyE4R4lcqZ4jEc2m42dNIjYebsYURSZNUhdlorzoWGMqtWqMnn9OKczisWil8qGK4NANry2\n", + "4bNcLufpGH+Pv70CIDDf8TeVSulzeSytY3q3IgGDGXgX+Xw+lv3dbXsvBEYqICAgICAgIGCL2DZn\n", + "c5HODh0+ALD8Zmdn33fna9cfZnR0VHftnDQR58fYtbMFwI6FSKoIpuHcuXNqlTAz5P52cXFRd998\n", + "Poz2sROm5QPCWd1FOjt5DtEV6bAAcAQfHh5WyyepGjpbDpY6JDl49sqk69YZzGQyKiO2EpjVQd+S\n", + "rFcLXOUc/2b/GsifK9Fbfh6cpsIFO6K7VcGz2ax3vyiKPJ3I5XKaXZ0ZO8ijn3qSInGmkXVBpHdK\n", + "CResD+y/kJTwFM9NpVJmrULMC+j2e++91zdzlATIft++fV7yytHRUW3XM888o0wO9CqbzarVzuPm\n", + "Mir5fF7uvPNOEemGs7O1byX9BVge6O/hw4eVSWOLGwwJ2mKldrjtttv0Phj3SqUiJ06cEJFuzbbL\n", + "ly9rP60aeVjjxsbGVPfBGrEvJRifxcXFWJoUkXimZ4wD+3Dhfknri0hXJ4aHh+UTn/hErM3PPfec\n", + "9hdzde/everfhPWsWCzqnOPM/xYDhiABpIWIosicSydPnhSRbiJbK2GxSHe8kA7jBz/4gX7HKXnc\n", + "dU+ky44wE5OU4oV/h/5yzVBOOeHWhesFrOHoh5WIdDPwewoyshJHu4yTiM3qWIwfA3Mdz+2VXgUn\n", + "SOzzh88wz1dXV3Xc8XezEwLGT62zeS6Xk9tvv12zA28GjpbohVKppIMCRU2n054D3fLysklNc4FL\n", + "F3zUhkFip3M3UkKkq7x4FredFY8dGNEP0Ip4qXOpG0sB0G+OpttMUbgAZFLRSCtjLJd0sTZS7ma4\n", + "2Wx6OXQY7Pho5YVyFzc+ioPMV1dXzT7jBY8x7HVf9yXNz0hyzO/1EsHnGJMoihKjqxC51G63la62\n", + "HK75+W5/C4WCbiZ4oeLjVJGOXmFT0K8ttdlibUXeYqPHRgpelmgnzwu80Pj4CAuoWwjbAu6NagFn\n", + "z571Iuos/VtfX9f5jJchL5xJfees3sDy8rK3VpVKJfMYwkUmk/GOrdvtto4djoFWVlbkgQceEBF7\n", + "I4V5mcvltE/Y+FgVHVjfOdDE/U0mk/Gc5dmgwneVSkX1lzcx3/nOd0SkO+67du3SMcEctSLhLAOb\n", + "C4EDt912m6krMJQ4sAVHiiwPaz1zqzww4G7C5WoYrh4UCgVv3nLxbXZ2BtGwurrqFUXmfnMhXrdy\n", + "QBRFZnAI5iQbuG5h32q1qmOD+WgFC1jIZrNe2a0oirxoXHbJ4ChADuZhOXH78vm8tg/Xz8/Pb6nM\n", + "i/sMN1N/EsLRXkBAQEBAQEDAFrFtjNTw8HCMjbLCxwH3+AefIT8Qdubnz5/X3XVSltNyuexZBCdP\n", + "njTpTpd+3Ldvnzq0Y6d64MABzSDO1q5bhFLEZ70mJia0rUwLu7XR3MLLLrC7Z+dYdrRk+W5GqeI+\n", + "bmFKEfGOtaIoUquDM9H2W5/JcnzH/Th0mnMJicTHkC0+lxk4fvy4Z1Ewg8Rtcpklps7xDCtnGMuR\n", + "5Z90zMbH2/g9O9xCF5DuY2VlRfUTMmNnfVica2trJjsB8PjByoajLddrRE6btbU11UWwCqlUynNq\n", + "B9so0mWPy+WyHq2wMy36gesqlYoyEJjr+Xz+uo948TsRiRW+5gzK6LsFMMLQMS4y3m+NMDDJzDx9\n", + "+tOfFpGOnnzrW9/q6x7umletVnW9ZLm4WdEZXFjanWeVSkWZBTCme/fu9QoAr6yseK4RnIkaYAYA\n", + "OjY3NxcLjBDpyADtx/yoVqse2wI54DcinXFz83BZx69WaolCoaBtxrNarZbJorrr4szMjK7bYKQs\n", + "xnR0dFT1mF0B3Lqfq6uryjRhHbh8+bJZl9A6HeH+4p7QWU49w3ru9imfzyfeG++uXC6n7xEr1xK/\n", + "r9Fu9DeTyZjv1K3MawB9gn5auaB6sVFYo/D80dFRZat5/eQ8h0n3YwRGKiAgICAgICBgi9g2Rmps\n", + "bCx23mwxUUAqlVI/Ily3urqqVi7vvF2HtNHRUbUOLMdM+FRMT0/HEgSKxH0B2PLHDh1WOULQXbg1\n", + "m4aHhz3Lq1qtmk7YYATQ1kajoTWqYN2x1cu+HLBOuP4WfEZOnTqlfUnawbMDtVWHkENDXUdbtlbB\n", + "Oqyvr3tn66Ojo9pWjFuz2TQZH9yHq5cDPOZu+LFVx8tikDY2NjxGiutCAalUSi0bMBjcXr7HL/zC\n", + "L4hI3JcOMsJ9LX8dbpelW5wg060ZODIyovK36j5yfyB7ZqJwb+gO+8BxAIWr21ZiSJGuXwonu3WZ\n", + "RPaHgXyWlpb0N/AdYwsXzES5XI6lPOEElnge7pnEEHIyX1in8LO8Hlh+PFi78HcznDx5UhluME75\n", + "fN6sp8d110Rs/5WFhQVPz4rFoufQvrCw4MmAGXOwfOVy2dQtAEwnJ+Rk5/8k303094YbbtC+4B6N\n", + "RsNk5rFGw7neSmOxtrbmye/ee+9VnzxmTjBOGEsOMEH7LIby4sWLnq/P+Pi4rknMOFsnJlhneS3n\n", + "Uwq8q4B+A0symYwXym+tO5VKRfsJxqler/fl1yfSXTuYecM6jbGx9HNoaEjfgRw0A1mDMc9kMtou\n", + "9ofCb6z3GPxjBwYGlH3E2nD58mXPF8+qX8oJqXth2zZS/TisYSGbnp42nQfdRYSzf2MhWFpaMqPN\n", + "oLR4AX3ta1/zrtmzZ4+X3+RDH/qQ5jABekWuYePDRYmxiHAeDig1Jt/evXu9ws0idvkPt2Bws9nU\n", + "ScMbGuuozd1Q4fcinYXCjZDhe3L5BCtqxo3+EfFfMpbcrGCCWq2mfcKEvHbtmhmAcPToURHpZC0W\n", + "6URUutmkeTOB+y4uLno0tFVaoV6v68sa4Dxc3B9E9kDXOBjCWsjQlmw2mzg/MJaW8WHpejqd1vHi\n", + "uYKXARboZrOpY43vepVqgKxwvzvvvFOPCvDCWltbSyzSjP7efPPNKje81Ofm5vRFYeXG6nVflJ3B\n", + "PIuiSOXERboBK8oKuJ6oniRg3t51110aJeYabdy+iYkJrxoDOyMzOHN3L1y7ds3T/Vqtpi8IyJwr\n", + "TQC8bnDEHxtXLqAHY2NjOsbWEQ/usXPnTr03jBRrzNlI4f5gTWCdwLoIveJCuygZdvnyZa9dxWLR\n", + "m0PWC7dcLmsbID9+CWMTYBkYN954o75X0BZuP4zndDodW0/cNhw8eFBlbc17GDutVsv7fmBgQI0c\n", + "tHl+ft5098C7yi03JhLXCbTVGmtez6B3HOjj5lxsNpu69lgbY/RtYGBA78O57zAm1tEtSAWR7thB\n", + "F1utlvZjs0hURjjaCwgICAgICAjYIraNkXKpTexSK5WKV/jTYqPGx8e9zKdMdXINI1id2Cmvra15\n", + "hSktMBv1yU9+Uu/nWpO9nNFgjYEGz+fzHvVbrVa92m3nzp2L5bcS6ey8QTnjvrlcTpkodtK1rFNY\n", + "LsViUeXLjJTLBDUaDe+YjJkN7OR7ZVfG55zHyirsm2RJs9WJ9sEayuVyXq0o9IX/tlotM9eNlRcI\n", + "/94s1QYsQ4wbW1Rswe/fv19Euta1lQdlZGTEy3xuySSbzWr7kwp6TkxMKGOG57333ns6B6yw8s36\n", + "e9ttt4lId0wbjUas1pWIaEg7Y2pqShkGWKTr6+tqHeN+b7/9tscI5fN5tTo5UzOsdViQQ0NDsbUE\n", + "cxa/yeVy3vgXCgVlepjVc49remXwdtErlxGAWqBXrlzRnE1W3U/ozksvvRRzxMd1+C0zL1xfrhfS\n", + "6bTHNPQbwm4xKtYx+OHDh5Ud47pvFjCHcQR45coV1aOk/Ea9nKcxb3hOo384FuZqEZgXfNT3kY98\n", + "REQ67hJgMfi43GVAucg90G63Ve+471i3Mc937dql+cOsmpqc1R5tsQIQwFqKSKzmHk4xkmTZy5Ed\n", + "eocx4txykLPF1PJnWC/y+bye3nCBdOgH5nK/6Vc40MfqG+ZAL2d2rDfuu9VtP9YstLmfo73ASAUE\n", + "BPyPoF8fjoDN0e/GJ2BzvN8JnwMCti2zOSyEpKzZfIYK51LsROv1uu4UOVwZO1ZMFuvMd2xszLOW\n", + "2Krk2lLIWot2/su//Eti31B1fGlpSe9n7YAB9q8B+KwdVjlbGpa/E2fvxtl3s9lUSwqWEg83rPGh\n", + "oSGcRkuHAAAHZklEQVRTXq4DYLvd9liqoaGhmKM44Dojl0olz6dnenpaLV5e3Di5nEg8KSWH1sMi\n", + "ZCYFdZLgINlqtTyLhzMGgxFAdmpOfFiv11UXWBaQEde+c5kLZMJlDA0NeX5nmyW5tIAxKBaLno+P\n", + "xSAws4J0Cvv371eLFKzm6OhozIlbpJNFu1dGYfcZkFsvB/r/KXBiv9/93d8VkS6L/eabb3psQiqV\n", + "8lJsiPg+dMyicuh8ku+UxXQm+WFt1ieM1+LiopdYNGldEYnXhExKZMxJdt30JtZaw6kTcF0vfxK3\n", + "7tv6+roXrHE9wLiBkSwWi54fzPj4uN4bOrlv3z7TxxRAtvXTp097zJWFmZmZWIJnkc4axnXmRDrj\n", + "iHUv6VU7Ojqqz4PMNzY2zAoXuM/o6KiZsNcF67GV7Ph6USqV9D5ra2uaQBa608964QJsK3R8bm5O\n", + "1yfMKc6oz36v0AXMs0ajYe4DIEP8ln1W+RkYL+h4s9ncNLO5RNsAEYn+5E/+ZDse/b8SQZbvH4Is\n", + "3z8EWb5/CLJ8/xBk+f7h/5Isk7ZL4WgvICAgICAgIGCL2JajvY997GPy3HPPfdCPDQgICAgICAi4\n", + "btxzzz3yve99z/xuWzZSAQEBAQEBAQH/GxCO9gICAgICAgICtoiwkQoICAgICAgI2CI+8I3UU089\n", + "JQcPHpSbb75ZvvSlL33Qj/+Zx8zMjBw9elROnDghd955p4h0kr/df//9csstt8gDDzxgppIIEPnN\n", + "3/xNmZyclCNHjuhnSbL78z//c7n55pvl4MGD8vTTT29Hk39qYcnyi1/8okxNTcmJEyfkxIkT8uST\n", + "T+p3QZa9ce7cObn33nvl8OHDctttt8nf/M3fiEjQza2glyyDbl4/1tfX5eTJk3L8+HE5dOiQ/PEf\n", + "/7GIBL008QFFDkZRFEXNZjPat29fdPbs2ajRaETHjh2L3nzzzQ+yCT/zmJmZiebn52Of/cEf/EH0\n", + "pS99KYqiKPqLv/iL6A//8A+3o2k/9Xj++eejl19+Obrtttv0s16ye+ONN6Jjx45FjUYjOnv2bLRv\n", + "376o1WptS7t/GmHJ8otf/GL0V3/1V961QZbJuHjxYvTKK69EURRFKysr0S233BK9+eabQTe3gF6y\n", + "DLq5NayurkZRFEUbGxvRyZMnoxdeeCHopYEPlJF66aWXZP/+/TIzMyODg4Py8MMPyxNPPPFBNuF/\n", + "BSInPuCb3/ymPProoyIi8uijj8o3vvGN7WjWTz3uvvtuTfgG9JLdE088IZ/97GdlcHBQZmZmZP/+\n", + "/VrqI8CWpYid6C/IMhm7du2S48ePi0gnqeCtt94qFy5cCLq5BfSSpUjQza2Ay0K1Wi2pVCpBLw18\n", + "oBupCxcuxCovT01NqZIH9IdUKiUf//jH5Y477pB/+Id/EJFO/TRkNueaUgGbo5fsZmdnZWpqSq8L\n", + "utof/vZv/1aOHTsmn/vc55TyD7LsH++884688sorcvLkyaCbPyEgy7vuuktEgm5uBe12W44fPy6T\n", + "k5N6ZBr00scHupHqVUYgoH/84Ac/kFdeeUWefPJJ+bu/+zt54YUXYt+j1EnA9WMz2QW5JuN3fud3\n", + "5OzZs/Lqq6/K7t275fd///d7Xhtk6ePatWvy0EMPyWOPPaalVYCgm9eHa9euya/+6q/KY489JuVy\n", + "OejmFpFOp+XVV1+V8+fPy/PPPy/PPvts7Puglx18oBupvXv3xupDnTt3LraDDdgcu3fvFhGRnTt3\n", + "yq/8yq/ISy+9JJOTk1qX6OLFizIxMbGdTfyZQi/Zubp6/vx5rQcVYGNiYkIX1t/6rd9SWj/IcnNs\n", + "bGzIQw89JI888oh8+tOfFpGgm1sFZPlrv/ZrKsugmz8ZRkZG5JOf/KT8+Mc/Dnpp4APdSN1xxx3y\n", + "1ltvyTvvvCONRkO++tWvyoMPPvhBNuFnGrVaTQsXr66uytNPPy1HjhyRBx98UL7yla+IiMhXvvIV\n", + "XTwCNkcv2T344IPy+OOPS6PRkLNnz8pbb72lUZIBNrh47Ne//nWN6AuyTEYURfK5z31ODh06JL/3\n", + "e7+nnwfdvH70kmXQzevH3NycHoGura3Jd7/7XTlx4kTQSwsftHf7t7/97eiWW26J9u3bF/3Zn/3Z\n", + "B/34n2mcOXMmOnbsWHTs2LHo8OHDKr/5+fnovvvui26++ebo/vvvjxYXF7e5pT+dePjhh6Pdu3dH\n", + "g4OD0dTUVPRP//RPibL70z/902jfvn3RgQMHoqeeemobW/7TB1eWX/7yl6NHHnkkOnLkSHT06NHo\n", + "U5/6VHTp0iW9PsiyN1544YUolUpFx44di44fPx4dP348evLJJ4NubgGWLL/97W8H3dwCXnvttejE\n", + "iRPRsWPHoiNHjkR/+Zd/GUVR8vvm/6osQ4mYgICAgICAgIAtImQ2DwgICAgICAjYIsJGKiAgICAg\n", + "ICBgiwgbqYCAgICAgICALSJspAICAgICAgICtoiwkQoICAgICAgI2CLCRiogICAgICAgYIsIG6mA\n", + "gICAgICAgC0ibKQCAgICAgICAraI/wdvk9M+hXkCqAAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text": [ - "" - ] - } - ], - "prompt_number": 13 - }, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['conv1'].data[0, :36]\n", + "vis_square(feat, padval=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second layer filters, `conv2`\n", + "\n", + "There are 256 filters, each of which has dimension 5 x 5 x 48. We show only the first 48 filters, with each channel shown separately, so that each filter is a row." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXuMr1V199fMnDmcO1c5wAEFFfBuVaiXat7GiMb+YWrS\n", + "WhtvpcoteI2gomKoaETF6FFMuWgoaY2paVrbNKmttrWttRFbQ1VEBZH7RZCLcO4zc94/Tj7Ps3+f\n", + "51nnR0d8533frO8/M7+Z/dvP2muvvZ+91l6Xmb179+6NQqFQKBQKhcL/GLMrTUChUCgUCoXC/6uo\n", + "g1ShUCgUCoXCMlEHqUKhUCgUCoVlog5ShUKhUCgUCstEHaQKhUKhUCgUlok6SBUKhUKhUCgsE7+S\n", + "g9RXvvKVeNKTnhTHH398fPSjH/1VPKJQKBQKhUJhxTHzaOeRWlxcjBNPPDG+9rWvxZYtW+Lkk0+O\n", + "L37xi/HkJz/50XxMoVAoFAqFworjUbdIXX311fHEJz4xjj322Jifn49Xv/rV8dd//deP9mMKhUKh\n", + "UCgUVhyP+kHq9ttvj2OOOab7fPTRR8ftt9/+aD+mUCgUCoVCYcWx6tHucGZmZmqbLVu2xB133PFo\n", + "P7pQKBQKhULhV4LME+pRP0ht2bIlbr311u7zrbfeGkcfffREmzvuuCOOOuqoOPbYYyNin9XqmGOO\n", + "iZ07d0ZExOrVqyMi4pOf/GRERJx++ukREbG0tBQR+/ywDjrooIiImJ3dZ1T7xCc+ERERr3zlKyMi\n", + "4oEHHoiIiCOOOCIiorOS0cfFF18cERGve93rJtrR73333RcREQsLCxERsXXr1oiIeP3rXx8REdu2\n", + "bYuDDz44IiLWrVsXERG7du2KiIjLLrssIiLOOuusiIjYsWNHRETMzc1FRMT69esjImJ+fn6C9re9\n", + "7W0REfHwww9HRMSqVasm2m3cuDEiIj7ykY9ERMS73/3uWFxcnKBzw4YNE8+kb2ih79nZ2bjmmmvi\n", + "xS9+ccfTiIhPf/rTERHxjne8Y4Jf/B9+c2DeunVrnH322RN/Q9gYLz+Zz3POOWeCX/yf7/ETWt7+\n", + "9rdHRMSBBx448b2HHnooIvbJC32/5z3vmejjF7/4xcQz4OmnPvWpiXH62QcccMDEuOHj+973voiI\n", + "2LNnzwQt27Zt6+bpj//4jyOin0/keu3atRPPWFxcjG9961vx7W9/OyIi3vnOd048E8BX1gUBHO9+\n", + "97sjImL37t3dM9asWTPxXfjy5je/eeLZVngYL+O84IILJmi+6667Jsaye/fuiIj4/Oc/HxH75Iu/\n", + "8R1kZdu2bRNtmSNoYI6QNfjI/MMXyyJo19GrX/3qiIg47LDD9tv3lVdeGRERL3jBC+I3fuM3OlpY\n", + "N8gJfLnooosiIuKtb31rRETccsstE89h3S0uLsZnPvOZiIh4y1veMtEHsgJf+MkcnXnmmRP8g2b4\n", + "ytzS/rzzzptoR/8zMzODfZE1xP7GOPnZrueIfr9AzgHfp/3HP/7xibEeeuihHS3mJXsu+/k999wT\n", + "Eftk6wUveMHEWoro54h1xPi3b98+wT/6Z6zsLxs2bOjoZ6/wXsTe9eCDD3bfiejXGry95JJLIiLi\n", + "3HPPnRg//Wfr4gMf+ED3frj33nsjYrgnsV+89rWvjYiIzZs3R0Qvq/TNM6EdvtAfz4F2+r/44ou7\n", + "fY53CONljq6++up41rOe1fGc9yLPNK+9151xxhkTtPidtbS01LX9/d///YiIeOxjHxsREYccckhE\n", + "9O9s3mXIFu0ZF30CaGO/+IM/+IOI6NcRNLfrgv2f+YfHtJ2dnY3bb7+9W+fXXHNN7A+P+kHqpJNO\n", + "iuuvvz5uuummOOqoo+LP//zP44tf/OKg3dFHHx0vfOELI2K4MRYKhUKhUCisFLZs2dIpBv/HD1Kr\n", + "Vq2KSy65JF72spfF4uJivPGNbxyN2Jufn+9O+2gLPoEDTsWcsBcWFjqthFM44LtoO/yfZ3HiBE96\n", + "0pMiIuLwww+PiF6j+vGPfxwR/cndtDz00ENdn1iYOO22Y2xp4qSdmQehFa2GMTBu+gOzs7MDK4D7\n", + "AGg5aFz33nvvhFXCffPM9lntT8Ye0fPkkR6IoQ2+oWmgiXr+rSWiRY0BuqHP828wbjRL2vHZc4p8\n", + "8D00sJ/+9KeDZ0AvYLytZaLlM+1//vOfT7RDAzMtyNPi4mLXD234H2BubLHK+ILlgX6tBXodzc/P\n", + "d/TDc1uYPU5ohabM4uQxMTc8p+XLkUceGRH7NsGI3pKGtmu5XlhYiJ07d3Zzw7h4lvmDrGOxRg6Q\n", + "0Za/9OX1zndMiy3WPMtz6X4YG/vFhg0bOnoA84flnX2NcUyTXb5v+QHQzHPn5ubSNQRY78wBfY/t\n", + "cy3gC/OPxQ/w/XXr1nXPyOQcnvNs9lE+ey9iTnk2c+v3BDj44IO7NnzX8g/YW7By8gxk2GAf9G2B\n", + "567ty+Pi5/z8fDeHEf083n///RExfAebn7Rv96SxdhG9BYp3ErLFe8HrxZZZ5pR5b+mO6OfQNM3O\n", + "zg5ki3HBF/qyJXYaHvWDVETEy1/+8nj5y1++3zaY9QorBzbVwsrB196F/7PgwFVYOdQcrDxqDn45\n", + "/EoOUo8Ej3nMY7qTJfDdN+AU2d5fWpsD+NFweuVUinbPT4A1jFMsNKHdQRNotWhOsZnGCI32t2l9\n", + "ZMZAe07L0GZLzPbt2wcnbMZjixSaBX+fnZ2NLVu2dCdvWxjgE2NjrGPBBNk4Mi3QGpo1b2uBreYa\n", + "EQOaWx4wX9ZqzHvgZ03TotH+oRl+bty4cdAXn20VazUvLCgtbYzHFhrzGVp37NjRaaHMk+ffMkp7\n", + "+GUNjGAQZI9x26cGLC4uDqyAlimAFQ8ga9Bk2qGRMZj37XNowzP4TBvvGz7Ioh3b9xDwTKwHtky0\n", + "+4u/C4/tj2f87Gc/m6AVechk0pYZ5qwFvpHwhTWVWQGYZ2hufcDa7wP+znO2b98+8IEEyAk+ptwG\n", + "ZPsIfLSvqa0fAHlZs2ZNRwO8sZxn+wJ8cXtot5WU9t7z7rrrroHl0H0AeIeVkLmCBo+TfvzMsb/b\n", + "z4rPjHvz5s0TY2W9YKGxj6HfO/DBty5j+ymyg+Wd8Xp+gZ9JX/RtWYQG721LS0sD62Xmb8l4s3OG\n", + "USViCoVCoVAoFJaJFbNIRfSnPTRRToPW5Gy5aE+VPtWjjaHt2E8hs3Y5coxTbOY7tG7duk57zTRp\n", + "+4hMs0g5wsj+Xz5Nt3e+9Jn5glkLhg98Ns95lu/1/ycwTS3dLfi/o9MAtPl+3mNoYc0rgzVLPmfa\n", + "MXNsi8zS0tLAf8QWM/swWF6swfM95iLzHZmbmxtEGZkn0EbftkR4Tsa0ufansbS01GmvnqdMFjO/\n", + "C/PW//eabWm3v54tRRktjNORleaLfc2ydi34n9fqmAy1fVu+rR2jibfReozF8su4aWuNO/NLgxa+\n", + "z/e8F41ZQDN/GmiwFWvTpk2j7Xm2LW2ZNb39P22ydeu9hjmalsbHFh3T2razJTWzcvB/RwT6FsW0\n", + "eg8fuyHJ/PGy8frdla1N4HUBDX6PRAytm8AyBPxMr4tsr7bv2Nzc3GB+/H6DXsab3TYZZZEqFAqF\n", + "QqFQWCYe9Vp7j+ihjyBpZ6FQKBQKhcL/LciOS2WRKhQKhUKhUFgmVsxH6v3vf3/nA0SkGd773LOS\n", + "ZZesrPhtzMzMdLk2uP/84Ac/GBERb3zjGyOiv1/Gb8O5WciaSnZg7oSdXRVarrjiiojos0lv2LCh\n", + "u0d1lI0zchOdwH0skULcT3/gAx+IiD6zsSNNiETkzpcMwe9+97sH0TX4WfGsq666KiL28bvtwz5g\n", + "fKZvssPCN2dv5zl/8id/0mUqto+T76PJyMt8wnP4w/fgD9mkyVRMzUbm5Ljjjuue8973vjci+gze\n", + "bT6biD7PC/N66aWXRkSfZRta+YmsIZtk5aV/Z23euHFjd8fP/MNznn3nnXd2bSP69BNkqkcWAXLF\n", + "M8i/QnuyD2/YsKGLImM9QJ/lnPE46ziyTGZjZJFszPgcQgP8IYv3e97znoFvB3NA36xRaIEG5ABa\n", + "kAP4+KY3vWmiP/vKIIuf/exnB1n2Lef8dHZoR1gyTnD++edHRMS73vWuiWc6wnbPnj3x2c9+dqIt\n", + "8sraY58DyBYZ3OELkcOM1xnfod1RnXNzc90zWc9knobHzoeGjLLPMUesF/ZFZBF/JrLsk/EdjX37\n", + "9u3dPLJ/sZ5Z/4yTdWP/rc997nMTfcNzovwYI7TzvmBNb9u2raMb2SE/GmuIvQWwbpyHy+NE/uE5\n", + "zwF/9Vd/FRH7ZAAZJB8U42YfYC/i3cI4aWffMWjh/eIcXswBc/3hD3+4W8/MJ3vs3XffPfHML3zh\n", + "CxHRr3/7DjnTOXNKJQT83ZiTVl6gGzm37xhgXr3/w2v7vUIL6w4+Ok9l60uFnJ922mkR0fMOXjNe\n", + "xgHtGcoiVSgUCoVCobBMrJhFau3atXH99ddHRMR//dd/RcS+3FIREc973vMm2qIVoy2++MUv7k6t\n", + "3/jGNybacgpFa+HkTR4l54WyJuHM3Y7G4eR61113xU033RQR/QnaSUYd+fC0pz1tok++Dzj9Yqmg\n", + "P/qxJvuLX/yi44nrlmGxA5zGqR3Es+A5mhqAZmix9bC9K3bUJVagLCcTPGdeoeWoo46a+D5wHSyy\n", + "0cN35Cii135p6xpKjoRE24fWH/7whxHRa8fUgwRoUfCXRHb33Xdf/PSnP51oi0XpRz/6UUT02trJ\n", + "J58cEcMoPHhKrUo02BNOOCEiepkGzM2mTZu6vpBzZ1pGdhgP/8fqYViLI98VfHTulpmZmUEeGEfC\n", + "AniOzN58880TzzrxxBMn2ttKxPegYSxijr4cCWRrFvKBdaDN6xURg+LqtEdzRQaxNrbatSPC2jqX\n", + "7XgA/EKO6BOasjXtnG8HHXTQwBoMr57+9KdHRMSLXvSiiOj33h/84AcT7eEba5Q1iwxmkZXI7LZt\n", + "27r17Ag/5AEZc/Zs70X8/ylPeUpERFda7D//8z8joreqAPhw5513djxirTgKi3XDPPMsaHckrvcq\n", + "5pS93O+A3bt3d22QHayBrhbA3k179jJn2we2mrHfjGXlZn5YW6wpxos8G7bsZhGHjI1bA+QAPrW0\n", + "O9cfFjXkwfICbF3OsqdnlVFmZ2cHEX7wkGe6gscj9ecui1ShUCgUCoXCMrFiFqn77ruvO4Fyisc6\n", + "Ym2XEzna/0033RS33XZbRAxP35z2OQlz+uWU6uzgrteDBoKWYwsGmstdd93VnWZdrRs4Rw1ay1gW\n", + "5Ihe43zc4x4XEb1GgrZozf7AAw/sNIwbbrhh4rvWpJxFlv+j/bk92rLrCLoKePs7mgG8Hmsb0c+B\n", + "76PRGm1hYA6Yk+9+97sRMcxaHzH0z7JWZwskGkqrSUf0PkHmOXONnLXatTVpZA8rCJYFaLLs0t4Z\n", + "kPk79R9Bm+GbNozflhesodDIM/hs64mziSP38Nyy/sADD3S8c50+W4XgLdYw55qxlQzarB264kHb\n", + "NsujZTlHBhnnt7/97Yjo9xpru/YVYQ+z70j7OzKG7GQ1JVmb0A4N7IvW1O33x3O2b9/e7X+A+cea\n", + "gyUC66fBfoGVBHlibr2mkRfW9gEHHNDNBZYSYHoZp+ueAW4VsEh961vfiojeuu51B+3btm3r9g7G\n", + "YYsE64D/Q3NWP/Xxj398RPT744033hgRvdWYtQ1Wr1498M9lHn07Au/s55pl5Ud+nDGfMbf9Y0lE\n", + "XpmTti5hC9e/pK/WJ7SF91W+P7ZfOP+bLU1+R7O/29fQFTKA+dVWN/Ae4vp9vIOyHGgZVuwgtbS0\n", + "1C0QFqkPPYBBcVhYs2ZNmqSQz047z6RlBQ6ZHF7WWcFRJv2www7rXghMwlgJl/bZdvT2xsgiRCg5\n", + "eJlGcMghh3QLgv858R5AgBAUC6X75vvwkQ1mrAQNffuZWbI3xsNLzEkxvSi5XmDzt7N+ewiAt5jH\n", + "4TEy5YXBeHj2E5/4xIjo+WhZZNxcu/Cc9evXD8bJBu+iw5ZJAG18jxeMX94A2nbv3t3NZ9Y3mzPz\n", + "yTiQOW/qdmD1YcbrrnUu5tm86H2QgmfIHId/5o45AZZR1qSLgfv3tm3mqIpswR94npV/cvJDJ/1r\n", + "+cK4nYCV8RvICfsK7e2MDXxozA6LET1vv/71r0dEf4Dytbz7Zr9ANqE94wvKwpo1a9KSH8gQyogV\n", + "sOzl9c///M8T/2ddWL543pYtWwZXNgZtffWXuXZAI+4E7GUuAgzWr18/KMqbJfNkfl042QcCgMz6\n", + "MDSWTBpFiGciY9NKZ0ETfU9LJsrexd6eXRlG9PzwVb/BM7M92fCVX+tq4PdcljSbfdJ7UYa62isU\n", + "CoVCoVBYJlbMIjU7O5sWUPS1hEtrtNqOzXqcKF1cNTvV+9lOB+D+oWXt2rWdFp+VWbBZ087Xvtpx\n", + "KDpaACf3sRIRtiS4aCSww66tZ1lBTGhCE0VDaWl3CYtpjnpYO7JnZhYszOe+Smz5wnzCc2tWmUbi\n", + "ucpk0cVMWyuT6YbnLhialc4BmOHttJ+VwmjHl10bY3lBXrBEZWUrkBN+Oi2ILRit5mmrjS0G9JVZ\n", + "ajOHcDuvZwWqI4blaTJZxGLB9Rl7TCYvgH6xGrTWQQB9WXmazIJpN4RsPUEb/GqLuvuqFouEr9td\n", + "AgjYWoR1MbNIwMe2wDD0ety0dXmdzArIHsR42T+gPbvBWL169UAWTb9TdGTlWIAtci5MbywtLXVt\n", + "/V1bDl0SijXFuLPyNubnWJAHcon7iK2dWQkZ9gkHkHj9s0/AP34y5rG9KysR5f2CcTLf/l4mXx57\n", + "xNDCSB/MBRaobF1kKItUoVAoFAqFwjJRJWIKhUKhUCgUpqBKxBQKhUKhUCg8ylgxH6nTTz99EGLJ\n", + "XbDT+JPyvw0xto8K6eTPPffciT4ddUbfpHx/y1veEhH9vbWj+/BzuOSSSyIi4qyzzoqIffew3K8T\n", + "wfHUpz41IvqSL5SIcDkO7p25P/7Upz4VEdGVt7CvAN+Hlssuuywi9pUIcBQVd9N8h1IY0I2vDH44\n", + "9Ml4GSdp9p3CwX4KH/nIR7qU/9BgfwPuqCmFQWkD/DDgg32emFPmyOVb2vB3eMg4ofsZz3hGRER8\n", + "73vfi4jen4JSKKeeeurEswlvJqyZuaIsB+3xfyJqctOmTZ08UKoCHjKfWVgzck4ZD6eawKeINCG0\n", + "pwTNLbfc0vlTIGN8hhZK/hCtA+AHfgXwkVIY9udz5CFlPC688MJOXgk/Zx6JWvrQhz4UEf0cwVvk\n", + "hBQURFC5pBD8wx8DuWFtb926tStt4XXBT6LVvvSlL0VEX67C4d+OOPN+Ab+gvV1HyArr2Wk+XCqI\n", + "Mi6M0yU+kB9ohBbGylrEz+s73/lO9ztlMxgn65e5coQgfVMSh3ERzYyPDWOhPXsdY1pYWBjIO+WK\n", + "XH4E+knmyL7gvQtZhR/ew+if90XEMDGtS9tQCoc15iSvpKygPeWwnOLDEWXQcs455wx4bn9cxulS\n", + "W/TpqE/mFHlhT2du8POBr1u3bu36ZvyOZuWZ0IKcA57NumAOLr/88glagPeL9evXd/sWbR1hbn8t\n", + "xom88HdSe7BfQLtLswH6X79+ffdM3i0f/vCHI2KYoJjxsY4ob5WhLFKFQqFQKBQKy8SK5pHCCkC5\n", + "gi9/+csRMYzCcAHiO++8sztZOhmbEy+SvBFrERoG4OTJMzhx89N3opyK77///vjd3/3diBjmoHJb\n", + "omqwipAHifw5AI0TrcGlc+xbtnfv3m68JKejjROmOQIMTRS+fOc735loj3ZALqtXvOIVEdGXUGlz\n", + "4TiPlCNZsmgjAO3Qdvzxx4/SAr+uvfbaiOjzSj3hCU/o2jKfLjuB9QPtDUArMgc/sP787d/+7UR7\n", + "+IosYvHctm3boISL8//85Cc/iYhec2ReAZon/TDev/iLv4iIXmMHaFE33HBDPPe5z42IiN/8zd+M\n", + "iD5fEGD8yD9JXuGPLTIAWaSMC9Yg0/6zn/2sswxAp/OEAeYfXr7kJS+JiIjPf/7zEdFrmgAZhwZK\n", + "BFHu5J/+6Z+6ts4t5Fw1pps9CLnBYoUsYh0zLfQH35hTZDliuA7IsXTddddNPBOw1yCjPBsLQxb1\n", + "Bz/R1B/72MfGX/7lX060hV6spqx3ZIg9CTiPHOOCRvMFsC/s2LGj2zsoLg5sYXnmM585Qb/Lfrl8\n", + "D2s7y5nW7i+0gS6X2XGCSmhCdl2Wi3UPTfAFvnrfXVhY6MaLrGSJRJ1Ml3Ex3qzkECWFXvziF0dE\n", + "L9P/8i//0rXF+sU+wLvKJVKAo1IdKZvxHHliP2W9OUo8Yhid6ShUwGcnVSXnG/sCsDW6vSFxtCFr\n", + "jfea90FbNDOURapQKBQKhUJhmVgxi9QRRxzRlXm5+uqrI6I/odoixSmYn/fee++gFAzAEsXJEs3J\n", + "GYiBc2/Y98GnY06027dv7/xojjnmmIiI+MpXvjJKt0umcEL26dh+WWgg8MkFMWdnZ7sTP1oL43Tf\n", + "aB5Yb5wPyAUw0USc4ZixfPOb3+zaukCsNQtbpKzVYeXISmfQH5YO5oqxtH4/Hg90usQBcBbh73//\n", + "+xHRy4+1RueuIbfVfffdN7Be2iLDZ/sbAHiNXLk0gmWRsRx//PEdT/HxsoURGhgP7VkvzuDLs/F3\n", + "Mt/GLJ7wvs1uHTEs+YRWjPWHigVo2LYaM99YTewr01p2XCbD1k9r9cynMxk7j45BO/7Pemr5Ag30\n", + "zU94aosUfbAHwQfWOFozaK3jERH/+I//GBERz3rWswZWIGfBtiXW+XLsn8Xe41xXGS133nnnoGA4\n", + "cHUJnsV3vUd7L2ZtY01w//Bx27ZtXZ981/OPvCBbrEmKe19zzTUT7eGT/bvGLC4R+/jHfGPdyApk\n", + "A/YH35YY8JxqDM431soX+x+0THsGcoKcI4vw3uvK2dWRYd7T7R7gvHFgLCN7Oy7Gi4+h5Qg4j1br\n", + "3+v5t5zzTmG87MXTUBapQqFQKBQKhWVixSxS999/f3dfbd8iTrGAEyqn6C1btnSnTt9hA2dydeZd\n", + "4Bpc1hKz+mZHH310fPWrX42I3qfHEVHOqkuBYf6Olgg4HaO5YKnxKR9s37690xiwdsAX1/NCk6Id\n", + "GhT+RtZI+Yxm+7WvfW3i7z7ZR+RZsg2sIGiazDdWL8+pLTHwZcziYe3VGcpNm33GoA0/nayA8lg2\n", + "e1teXAgVrT6zAtGO8WGBw2fKmhpzceSRR3Z9MU9Z7Sz8KejT0TXABaFdMwtNH7RFank2GqP90my9\n", + "4Rlo6LZIIav8HUsW/GnXNONxxmIXeAXQYMsE4/M4eRZy4CjYVr6cbZ62fNdWPdrZEm2/HoAlBnlh\n", + "3Vx//fUDHjJuMpxj5WKvyTJ6QwvrA356f2G/habNmzcPIoIB84k84ztKO/up0DfryTUWXd2Bftev\n", + "X9/tX74VcFv7JfFMv4ugAX6xZ7GmnZU7YuhXh1Uv80uEx8yNC7ED1j83IlihPYa2D3hmH0/vi84m\n", + "zvigzfVQacfY/J5t36P87lsQ1680XJ3E/AGOBnS1ixZYlFkP8A75zmo0GmWRKhQKhUKhUFgmVswi\n", + "tWfPnu4kyamQ0392mm1/cmq1Vm+LEtqa63oZPq1i/bGVAczOznZ9cqq3v5ZPs86DlPkZoC3Q3nmn\n", + "wNq1a7u/2QLjU7o1cvPPmhdao/22wFiF+exu29YuR1byOatB57ljbETatNoUMmIfsKx6Oc92DhPn\n", + "cAGuJ9hqx55PxgHv0MDgneUDntuHztYh0Faqpy8sDpnPm+vTITfmOc+yRdbWhPbv8IY1wzNsSeVZ\n", + "9IUWO80nxJYu+/20vzuvmqNWAfPO3EFL6ws5BltgaNfyy/LKGnOdQ8BnrH9o3PTtiEPGRv98b9eu\n", + "Xam1k3GyL7p2JGAuHJELbE2xNXr16tUDayBg3qHJ1hJoM5h/59mzFajlq/dD84Vx839Hn9maBo+R\n", + "YecdNJ+WlpY6GWFN8tmWWkecmqemxTcePBvZbS2e9p/iWVhcvZ/DB2h17dpsX/Rcs0bbvc55ER2B\n", + "n/mb8UzfBpgW+EG/8GHnzp0DOYeH8Jx5hz++DclQFqlCoVAoFAqFZaJq7RUKhUKhUChMQdXaKxQK\n", + "hUKhUHiUsWI+Um9/+9u7e1nnIeL++TOf+UxE9LV5+PuqVasGEUKutcddbebLkNVacw01rGdkl6Zm\n", + "UUR/1+toCurVUWvL/jqONqMGHe19P82dsGvWUd+q/Y5zq5AtmrpvjAe/LvjH/TQ1oqjNBp+hmTHQ\n", + "z8UXXzyYH+AMs/T95je/OSJ6/tmXgvFS94lxcr/tWnU7d+4c1OWyj1NbpzEi4mMf+1hEDGtEAfhC\n", + "P9RDo46T62E9/PDDnQ8E46TvzK/K46R9lm+Mz9DCWGdnZwd+Atzxsy7gITJknxGemdVmy3wFqJ/1\n", + "1re+deBn4txt1PGjdpb9uDxO6ptR98850uyn9fGPf7yTrWmRP6xR5rOt2xjR+2nQD3uR68SxX7R7\n", + "2YUXXjhBt31enE+M+T/ttNMioucXPLfvi2v5uV7amjVrur/RFtmyTyV0IwfsLeyj3tto5zpx8JHn\n", + "tn5x/I22niP7vvFM5p9x2qfWexhzBN/bmw/7I0IL44THrp1ItKLruDnyDL64Zt1pp53W8TjLFs4a\n", + "pXZmmwer/WzZZU07Nxhj4Huf+MQn4m1ve9vE37xfsOaozQkPWQfeT5Ej3i/0Dy3MLX6w69ev7+im\n", + "rfcW9w0ttPe73BGkruXqKh/bt28fvHNZz9DgiD/kmD09Q1mkCoVCoVAoFJaJFbNIzc/PDzKPOvqg\n", + "bRvRaxW7du3qTrqZ5ukMx0SCUN0ZcBLn5EnmVzLaPuMZz5ho3+b0cHSAIxYcKeHxOtoki+JC83I+\n", + "mb1793Z9wTNO3FlOK0C0Blqgo9k4ocMXa+xtZKWrmjvaxM+2BsW40eqyGmTOOo8MtNov8+kIQOTA\n", + "VgznJrF11LTAb/pDc73++uu7mmHuG1qYG/p2FM4Yb1uaHEHWtqeNtVIAH5gbeEdOJmfN9zOQ7Szf\n", + "2uzs7KCiPPPpCC9bNZk/W14BPOeZbm9LaPs/r8Es5wxwlu2ssoGtS0TUtXsANKAROwrXdbz4P3LB\n", + "M8iz5/qLvAWnAAAgAElEQVR2jGWsPqj3IubGkaNZVDK0M3do/bTPau21+4Vr6mUg55WrJwBbZqGB\n", + "CFXyKLn97OzswMrptWVrod9BXkeOMHbWekc/z83NDW4usjx7yLmj8UAWWWcgV61swwdHb7qKhmmB\n", + "P75VyfIOQiN5+Ki32NaVZXzwhXnP9q4sOhOZdDS7ozvBzp0701sT4HmflhMRlEWqUCgUCoVCYZlY\n", + "MYvUjh07Br4UrncHWktUxD5tmhO1swO7/haWGbRAn3ZdJZ66X1k9LGhbs2ZNd1J2zhXAZ5+C0WKt\n", + "eUED48XfCf7Yp2T16tUDrQUN0jXCrO3wLGcJNzIfqTYru/N8ORdTVt+Qv9uildFiC51pbGmwr4Zl\n", + "CDj3kflkC5b9+MgUPjMzM7AYetzMN/S6b/gADdBkKwho+etxTouMxQcQuKag+ZjlPGvb20LkPEGA\n", + "8Y3lHhrre+xZLcayD2d92grovGquveX2fMZShTWEz63V0H52rlDgtcvfae+cN7aeAfsabdy4cWBJ\n", + "s4UOLZ615Mz19Dkt2zSwP+S6deu68fi7rtjw1Kc+dYIGMtYDzy/7om8dQGuN9q1Bti5M47R3kfnI\n", + "3uw9emZmZmD1yuaxzQvX/vR7EjiLv63OLd88F86vldWta/2S236ydx00YdHle+0NidcFdNqfFfgd\n", + "b0un36/eX9ubEvM+8+e0v+c0lEWqUCgUCoVCYZlYUR+pTDPzCdOnxY0bN3YatLVVfD/oE02av9tH\n", + "ypEi+DqgHdmy0568nf3Y/gbWGGgPbVndJ07afEbrtXb00EMPDZ4J76zNWhNBQ2Dc9tewP5dP961l\n", + "x5qQv+s5so/UtCzbre9HxNBK1mpTtm7ZgmYNw5XS4bEzgANbftCWNm/enGbNBXzHVkFgHyloQha9\n", + "TlrLTuZXATz/aM6sI2ukrBvPKZ9NeztWa+3mg+ua0SfznFWFd4b7sTHDQ/vE2NLo9pYl5tm0IBfI\n", + "/09+8pOJ9q1FylY9fiKLmW+H/fuc8dq0w5c2gtAZvJ1t3lnhPf88m3GaD+7fY4joZch7FN+lT24B\n", + "+K5rrzqKjfHaHwm0e5V9PDOLlHlufz+QVU5Afmzx3rlz5yA63Xuqx5lVhMgqPoAsmjVi6F9pq5At\n", + "zoYzuWdWIJ7D3s7+0rbnWTyb+YYvvnHIrEK+0QDIlzOk79q1K+WZLW32lZ2GskgVCoVCoVAoLBMr\n", + "ZpFavXr1wNM/u4/3KfKAAw4YrXAdMTxpoyHwLPsO+O6Y+/tMm2qj13ynbU2Acfk073t74LtuNEzG\n", + "5Er0c3Nzg7ptjq4DWeSIfRuAtX37b7Uaqq0WzmtjLTCz8vgZ/j/Yn3aJFuK6bVkEof0R7O+WWUf5\n", + "ibVocXFxYO0EjoCy3BjOk+XIGdOyd+/egUUtizbimVhaM3+czLpmayOYmZkZ8Mz17tyXc9q0dQvH\n", + "2vNMxjhGCzzJ/EUsW9OsqV7/zl8HrbZUjNFi2HfMecZsqc18zUC7T9hi5KhFLKmOWgVZTcrMl8Y+\n", + "ZktLSx19ma+Xo3VteQSmzRZpz1Hbnj5d39F9eX/0T+A9zXvTmOy6j8zKwTpxxLSf7c+OJOb7LV8c\n", + "ETvN2uXbIsu9afGaxBI1tu48/7bUef69l9tqaP4io/Yxa88cwO9c8y5bu0ZZpAqFQqFQKBSWiaq1\n", + "VygUCoVCoTAFVWuvUCgUCoVC4VHGivlInXvuuYPIGtfpyWqt7d27t4t4wbp1xRVXRERfU8p31Y6E\n", + "ct/cATuPDHe/F1xwQUT0Nch27do1yF/iWmjnnXfexHj4vyMkXDuJe1v7jHCHfvnll0dExDnnnJNG\n", + "XbhG3DnnnDPKD/uxUFOKWkuu8+VIq61btw5q7fHT+aSghfpWzvjtaD7mCJ47ooLvzc3NdbWT3vKW\n", + "t0zQ6Xt44Bpk9u+CBtdagy/IRRt5xThdI9K+cfCHyDnq1VEjyn479stirK2s27+M8Vx66aWjtBBd\n", + "g9zg60V9K+qh2VeG7zHWlhbLkqNt4TlzZJ8q+0B5jrymPbeXXHLJoHaiNUjXQrPsmud8hhbWUZZ/\n", + "Zn5+flBrEWRRV9BCPUx4zP7iOaU2G3y0/9uqVas6eUAWWUMAueVZzD+1FqHF/jyObkJ2WdOtjDvS\n", + "9xOf+MQEX1z30eu/reMYMfS1c644aGcfXVpaSqPvqPsIX+CdaWI88JG6b64Ll62jt7/97QOfIJ4B\n", + "ba5vx7xn/n7so14XrkXH3y+77LJub3HEsHPbXXbZZRHRy3nmz+t39Hve856Jv9N/G/3qNedISYCf\n", + "ErUWzzjjjIl2fM+54rzvjkVJZu8Wv7uy2owZyiJVKBQKhUKhsEysmEWqjeTgBOo8S8B5mLZv3z5a\n", + "ZTyiP61a4z7qqKMiYnjSRMuxtkCeFVud2ugeok2IgMkyLkODa2KNZcFtafD3bR1YXFzseEIeKD4f\n", + "fvjhE23hEyfu1poz1rcz+zJfY9Estiw6z0+WmZr2zp/izObwCb4xN4zBfGyfzXdcGw04d5ejsLKI\n", + "QWu6e/bsSbPgI2Nor6YBOLLKFhdrbm1Eoq1dzlTOHCCzRIDSzhFhXovQzmfnV5udnR3kmMnqVGVy\n", + "4czfwHLiHGFjeXOsWWa+DciO884xZ1ndR+Sf/HRktR+TRVuLPb8epyOsXO8OQIMzPdtyEzFc9+Tq\n", + "Ye/yOG2J8po2xnLHZfl/rP3Dw8c//vETf3d774e2epjWxcXFQeSWLSvee/w5i15kLqiA4fxjoH0n\n", + "OOLNvGQencMrW0/ZOmqj1EwHvIN+vus9ifEzHr8/sqhQkFmP2r9ZPpyjz+OxtZBzg5/N+wEa2nqy\n", + "WUYA5J91kUVtZlixg1REzxA2dZeMADZD3n777R3TSVcAnNzrhS98YUT0G/+NN9440d5lGSi2iKC5\n", + "ICab9p49e7rDi1MQACaFjQL6t2zZEhHD1PcOZyWcnsV97LHHTrSfnZ3tDowcGCg+awHw5uVrRm9e\n", + "NgE7iVw7Vpuqs3l0ezYKxsBLyN+jJAQ/+R78aF9eLvkCxl5wEUPzr6+u/JLm2YyRjXTTpk2Dw4vH\n", + "x0/aeY5YDz4ouvgtaEP7GQey6IMRGx+yyMZJUkOnBaE9P+EDBwa/eOfm5gbJWrPSSYDxIbusUSsv\n", + "3tRZd/vbpP1SYg05/J29h3lkzT7taU+LiD5BL2DOmCP4x7prXzB+iWfh2sDFmfketGWpO1hPd955\n", + "Z/c/FxVm3vn5hCc8ISJ6mXKKAicqpKRQlkSZuWxLLSErTplghZESMczjzTffPNHeSgJzxMHLc8QY\n", + "d+3a1Y0vK1rsslTs+y7r4nHynkE2mX+vu8XFxYEinaXisSuHFYbsEOsQfieZjejlnPHx3jzyyCNH\n", + "+3SaB+Sa8WeHZF8rWgFv++BvGDngh0sEOX0M/ICfPrx6DnyIbOE9yy4vY0raGOpqr1AoFAqFQmGZ\n", + "WDGL1MLCwqDcgstuALQ/tITHPe5xnQZgTYq/UwJl8+bNEdFrObfeeutEe7RbTrecSNF2bMmwFth+\n", + "19cdtEVj4uTNd9E0TQvaH/xAexwruIqmgAbKKd9p9m3CNE99ineCSiwYYwV3rWFPM4taU29LW0QM\n", + "NS9fz5qPHmtEP29Z6n/A57bYakTPa1te7BiPvB1yyCGDqxdrv8wRmpetI07yaOfrTLOfnZ3tZC+7\n", + "ZobnLuKdXRu5PBGWF9q5/dLS0uC6PUuC6msT1ge0WG6ysi60by1YLnzqouTum3GwT7zoRS+a+P8t\n", + "t9wSY/CVxx133BERk2va18O2rNmCDT/YD60lZyVRsMAgL495zGMG+xb/wxqOHDiwBcBzl45yfwC+\n", + "YunYuHHj4EobwBfGg6U5S2jr7z/72c+eGIv39NYq62TPpnva9aqtHdCCzPkGgLGAubm5wTqGpiwh\n", + "s53us2tVJ1e2NbrtnzbeQ33VB+yGYvmw1dj8tWWnpZ29h/lHFnkn+drQ7wUnrPVtioNe+Dk3N5fu\n", + "LfTBey4r+ZOhLFKFQqFQKBQKy8SKWaQWFxcH4fGccjMnVDT6TZs2dVpYpjHyf/s++FTPKRhtAUsU\n", + "p2ZbDVpfFDsB2gLh+2e0O07cPuVba4AGh9qCbdu2DdI0ZAUbXVgZTWzMwsT42v/bktMWwXRKBDv4\n", + "ZiVieAbjRpvxOHGcRw7gI9pf6w9lh21rROa5HRIzHyOApk97NJgHH3xwYBnz3b4dVV1I1MU8XcbD\n", + "fl+tP5AdmD3/9GlLBTTbGoBlweVb7HQOFhcXu2dkzqQAGpFvO6mbL/b9wMcMy16rNbosiX00LItY\n", + "3NwXhXRdQJf9AprxqbSfX9sXMmIa7NDNZ1sgkLVMO+aZbdkfz7+tvi6ZkpVZYZz25zGcguEXv/jF\n", + "wHcS+JnwlGdYRu1rhWxSMNo+NR5j+7stUi29Ef1agwZbO7zuGRvraKyklItKZylrsoLJzHuWgoA9\n", + "Dv45WCGit/rQxmkbvFbNJ3iKjLk9/LN/FrLe7un2ceK79oEFLmvjkjiZNdXlz1atWjXom/95n+P8\n", + "kBWBN8oiVSgUCoVCobBMVImYQqFQKBQKhSmoEjGFQqFQKBQKjzJWzEfqrW9966DMAverLoVBuYr2\n", + "Dt1lUz72sY91/UYMo3fsZ0H6eVLnOw+PkwCSfv7000+PiH33tvTJs1yqgHICPNP3y5xuP/jBD0ZE\n", + "xFlnnRUR/d0vtHOXzHPakhLOj+LknZSfIRU+98v0DW38nVIYtOduGz4zB9CydevWQZp9l9fgHprS\n", + "BsynfYY8ziuvvDIi+pT/8AXfIfzBHn744a7MAuUh6MvRWuahyxU4ioPvUzqB9oypbcfv8Pzss8+e\n", + "aOP7dpdZYf5p71IRwKVTtm3bNsjNwjxRIoaSH/hr2E+Lufrc5z4XEX3JD/xRiKzDPw2fkA9/+MMR\n", + "sW/dwSvaOHEetCAvXv8AWXR750xzzqgrrriiK5vC/+yvx/qmjAuy6PVgvwvmiLJPwHKze/fuTraY\n", + "f/sKuXwR42QvAl5HtKe8yZve9KaIGPp5zM7Odr+zz1HCAx8fxkl+IdZ3W9okYpj7iH2FOWWsp512\n", + "2kS/bbQr4/De4sSU9o1lT6d9FmEHbdDerjv2XEeGU66GNWdaHfkGz5l/fKjYg/DvQXavuuqqiNi3\n", + "juwDDBj3Bz7wgYjoZRE4Z1dbCimin6M2b1ZEz3vk4vLLL+94iN8uvCb3GL7En//85yNiuEYBvKZv\n", + "+Mh+wbqBD/Bx3bp1XWkj3ov0kUXYsuZ453r9eM3CF7932/dSW9oson9f4KfldxDzXCViCoVCoVAo\n", + "FH5FWNHM5o5SsgUD2GK1du3aQdZn4HxBttSMZWSOGGpFttQYS0tLU329fHrPopKAs8K63I1p2bt3\n", + "78By5ig+4DIjtiwZjqhxfpA2ssbRFC6zYj7BD/rIMnaDLPs6mlj7d7Qy58kCLoVgyxM8d/4pt8ci\n", + "00YFWracHR3ZyvgCnE8qi4KD5oceeqjjkTP1A8sJwEJhbd+fnfl9LB+XrT7QkMkiliv6Riaz6CRH\n", + "DrbROMBryMiKmQNbSbI5ckZ8VwyI6OcHnnk/8N4Fn2wVtQULmF/wfffu3YOoPct5Zt0Dnks/2/vG\n", + "WBUDl40BWaZuW5hMO/2wxl1Cx+0faXmPiCGPs2Ln8NxZtuEHe1I7JngMz7Os2VkhbMZtK6krJ5if\n", + "7Zwwj9Cf5c8zLRmyOXJOq7F9lLasY1vezBfnQOQZ2V7kW6j2BsiyCE/56QhL710ZyiJVKBQKhUKh\n", + "sEysaB4p5zIBWcZfTtPr169PtRffi9q/wH3bL8saqDWtNg+FrV/OUeFCmP5/5jNjTT6rWdfWN3Mf\n", + "Hodz/ICsIKZpdRbdlnZO+bb+2AIDsEA50282p6bBeZba9llGXhd2Ba7jyJyN+Xq0sBwdcMABA+3F\n", + "4+Sn5R14LmyJsqbW+hRYm8syT/MMaLFvIMgsumDMyujcMZks0hf+JTzL1mBgzdvZp1u4uGrmh+Vx\n", + "wDcsdFlh4Xa8LQ1jfnAurmtfF2eqt0XK7TNfsjGrvNeQ+WJLimWLv/PTuYmyAtptnc1sPoH912jn\n", + "Ner9gX69VkHLP1uzzUP70rpvryPndvMcen9ta7L6GVn9T9c5hEav0bEbivZnO1YXIbfPaFY1wcgq\n", + "RPD9rDh0O6eZRd61Jk27ZdH1YoEtXD4LtHA1BlsaHynKIlUoFAqFQqGwTKyYRarVaGy5yOqhcdJ+\n", + "+OGHB/V4gP1KQGZZsNZnLXl/GKv0PfbZfhuOIAGcyK3tZtFbCwsL3Umfvqz9mhZ47MzPWX4MaHGk\n", + "RHtiN13QnWn11vb4vjM7A7dDA3EkYdvGGZlba+YYMt8IW5mg0b4xY9mkbe3Msm6bdmukmSy2z7Y/\n", + "Vka3LXVZXUR8zKyZZb5Hq1evHtQKyyyVYxXhW1heMiuCM6JH9DJhK06mKQNbAbNIMkeBZj50LX20\n", + "da099215sF9bZsEGLc1ZjThXNLDvpPuy1SizvtsPdGFhYdAHsLXTPlOWF/vD2g/HaNs5W7hpsXUE\n", + "Whx9BohyNO/3J+u2AgHTYh8gz1F2MzHN3zWif6/ZB9BRmcCWPFu092cFbGnO5rTty/tmtsf4vZm9\n", + "uyxfra9e5q9nyyztMou0URapQqFQKBQKhWViRaP2rO36JA7s5d9GQlgjdGV5R5BlkSKcmNEKfKp1\n", + "/63GNe2U7oierGq1T9quGWVa9u7dO9DWp0WqOKIh8wXIrErmr39vacj80lwpfJofiy10+7PUMD7a\n", + "WFuzpu4oRtOcaeq2viwtLaWWF+h0lEnmx2Z/NFsFPNYNGzZM5bl9Wxytl/ml8T3XQxyruG6raBZt\n", + "yWf7iGT5dmwddLReK/PZGsvWP33CD9plvmHeF/bnY8nvtpxkfknQ5tpqmUXKlor9Vao3X8C0KEfL\n", + "TRbl51uF9v/eH7JI2cxH0pbabD8BLQ2ez8xqY3+bzPLmmxBbycyX2dnZQc1U5z8D9lvye8P7nX3L\n", + "HCHX8gWrnn0ksxsMz9G0SGPftnj9tXzJouzG6I4Y+kRNq+Xq90krf5kVMMtpVrX2CoVCoVAoFH7F\n", + "qFp7hUKhUCgUClNQtfYKhUKhUCgUHmWsmI/U29/+9kG+Gde5or4NdXy4t1xcXOzu6rO6fIA7UO6I\n", + "2xpxEX1NIfKDOGcNn6mH1dZmsv+Qa0qdeeaZEdH73/AMaKFv1wiifXZvTy2/c845Z/A/TsyuhcU4\n", + "s8zO8InaSdRmc1RgGyEXEfGhD32oq2+YRcbwGVrOP//8iOj9DRyVc+ihh0ZEX8fNfITv8G9hYaHj\n", + "IfXn7BPhDM0XXnhhRPT1qhwR4igv+ocW+7ksLS11/kO0pY4T47TvG3451EOjb+ffcQ0q6mExRw8+\n", + "+OAgrw2fP/KRj0REL1sgy9XjGoT2vULeXD/x/PPPH0S8OjcLNSUZZ+vj1baHNmqtUd8sq7HH9z70\n", + "oQ9169MZ3plf1hRrCNm1H4rraFJrkzpulqvW/435p29HBgHvc/RtnyI+05697owzzoiIYSTezp07\n", + "u7+5Lf460ORM3PDFtTbhPf0yZ677Bj9Wr149kHu3hQbzkLXLHo0stvt/xNBHBj62+wVywPybh7xb\n", + "GB/teBb8Yo2+733vm2hnHyLGQvt3vOMdHa+YH2e6p+0b3/jGib6cu4vvU/cTPpKnyjTTz8UXX9zV\n", + "WgRZDT32f8uifYb4CR+pcWkfqdZ/i3qFzOdBBx000YaISOTF8+9oZ9fFo06o30etD6VrLTKfRCnb\n", + "fxP5Ye/KUBapQqFQKBQKhWVixSxSu3btGmSsdR4lMKaJOhoPZLXzgKNwnC3XEUNZtu72u1mmYsZH\n", + "n45OyOpb0Q+n4rvvvjsihhEjMzMzg1wajoBp20YMIwAzK5Jrcjmipq2Pl0WVAM8Bz8QShdZrPrl/\n", + "zwVyMRa1ZQ3UdZ3c3tFrzogP6I//t1aGLP8V48y0V9PiWnW2poJ2TtHmoO/ggw+eaMs44IMtl1le\n", + "nMyCab7s2rWrmw9HY2VZgl2/j+9nuasYG+2h/bDDDhv0nUW6OiLMEXLw3vuEv+9cRmN1vxzh6P3C\n", + "PM9qhDl6E/D/ww8/PCL6/eK2224b1PN0HqAsAsq0MyfIoKOagSsI7C9Ky1HOtjCb987dxRrOIkjb\n", + "tWueGq7j570oqwTx85//fOKzc4SBtg4mfWa1Vp3LyvXqsnx90I51kXbtunBeLFv1vLdMy3mW7dG8\n", + "o+jXlp2WFubVecSQNeB3ld9ZWaS6190BBxyQVvCwxfqR5o8CZZEqFAqFQqFQWCZWzCK1Zs2agUUK\n", + "bcAayVg19KyOm/McobVaSwb446DV0R8na592scTMzs4OqthnmpGzpNqnAdgfadOmTRHRaxrmy5o1\n", + "awZ3u1nWX1f9tqaW5cByJuwxzc5Znp0F2X17vtFAnIcIZPUR0fBaLcN+NvZHMP3wqfW3an86v5Yz\n", + "pCMPO3bsSHNO2ZKYZWR2n4wL/mQ5w/bu3duN0/4UwJq3/c1Mk/nAHDinF9izZ08nI86WbAsTz7ZM\n", + "2f/K4+T/tvC12m5WK8vjd9+M3z6AXnP4n/DMQw45JCJ62W+tDZZ7+DKtpph9fzLN2xYd5GbNmjUD\n", + "q4fz+eCfkuUR85x4jWYZwqGlzbbvtuxr8BrrqWUMuO4f37OfEuD78/PzA/+0LI9WlvuM+QW2ogMs\n", + "L2M5jex3l+Xiym4q2vG0cMULaOd90a4LW4u9jr1fOGcf46Nvy5f911x1oh0TsgdvkQdo8q0Q+6Kt\n", + "fdBi+cos4GvWrElvXuCPrcaV2bxQKBQKhULhV4wVs0jt2bNncB+ZVf+2n8OePXvSTKucLB2txwna\n", + "p1XuujkxZ1Ee7bNpby3PbX2azawi7vu+++6boAWY9l27dg0yLWcZ2bMMrVn7zHdqrLK4NWdbuTIf\n", + "Kfs8uNYUyOrBjY3NfaMRZb499gWyP5ZpsUbeZtvP/CmsrWV12iw/WBjgz/58R5yh12soy+ifzf9Y\n", + "TcWWds/F3NxcmpHdbW15AfbbAM4+Dx8c1dSOw3sL6z/r21Zj2ltesD5nUYFtJmxbGOyPlNVazKoM\n", + "ZGsRqzRYWFhIZcsRgK5N6L6dwT+zMoE2mtpZ0QH02seJ9s4mbgukI0in7afteKbVcbTMei6gxevA\n", + "6w8ceOCBg0hA0wRaC/PYOEwr/fJsfjJXLR+did9Z0L1G4S0/mbNsX7S8ZNU82r5s/WVt2UfKtVgz\n", + "XzngW6l23bktsA9htuYylEWqUCgUCoVCYZlYMYvUWG2usUgo2kZMnnqzE6NPxI7Kye72fQLnBO/K\n", + "1G3/1jizSIasvp3BXTHt7bfj/vfs2TPQYrJaUvYrwpKS1Yiincdgf4W2DzCtFhKwVsQ9vK0g1oZd\n", + "NX6slhJ9O+Llf6oFemyuyN5aKK3VuUYYtNgHCri2IpobcpDxZcOGDQOfpsznwT4jWUSQ58Z+fdYm\n", + "V61aNXgGMpTVmrPsZVYD+oNvjkxt+WjfBtNvWXS1d1u6s73IvpRjlejbHGMtndl6sCbtObHV0FGu\n", + "WNG2b98+Vc6df86gT/xTePaYX2L7uY2Umrbus2jMzDqe1az0umgt47Z22SLh9QCfPM+Ado68RTbt\n", + "37NmzZpB7byxeqXt5yyyLvPvxM8XOAfaGF18zuo++p1r62G253sPG4sKhXeOIMYSZct7FsXq9yPw\n", + "fgLaGxxgq5YjjT3ODGWRKhQKhUKhUFgmqtZeoVAoFAqFwhRUrb1CoVAoFAqFRxkr5iN19tlnD3Jv\n", + "ONcFdXyon8W95SGHHNLdr9KW+nYXXHBBRPQ5Jnxny50otdbo2xEPZIom58XHP/7xiIg49dRTI2Lf\n", + "3fLRRx898SzuX11TCDgikGdSD40aQa77xx0wn+HL+9///i7qELrx2XjMYx4TEX29MuoyMS54Tl4c\n", + "7syh5fWvf31EDHN83HvvvRPP+fKXv9zRneWN4jP1jVz3zREe3NtTO4v2vodv+2c+mR9ki2e7rt8X\n", + "v/jFiIh405veFBE9j+G9fSuuuOKKiOjn1NFdLY+QRdd9dEQZvEe2XIOMMdh/D76cc845EbHPlwpf\n", + "Fvs0uHYafbJ++InPE7L7ute9LiKGckL/8OXyyy+PiH11BfHpciQQ88n8QwvzCK3+PnJ++umnT/yd\n", + "NQkNRLleddVVgzXnXFxZTUF4Dh9Z08wVdb/gORFG9r1cXFzs6nJS8w3esT5Ys3wX2aJv1qjrW0Kb\n", + "6yfaf2337t0DupFF1jl+NbfccssELbSnvqHzkznb9kUXXTRBe/t/5oW+kXPopm9k0r4v1DdEXpwj\n", + "j/5db5Ual7Ozsx3PPF/QTd1PqkcgY/AcWeO9wn7B32nHnLHGkYFTTz114FfG+Fh7X/jCFyIiBvXw\n", + "7BPKOL1f0A95mXgO/N26dWu89rWvnaDbdV/ZH6+88sqI6GsQOooRPjIm3i+sI+9VvD/WrVvXyS10\n", + "M67NmzdHRD8H7ps6fuafIydZ08w/e1WbS9B7NO9/5Bu+2AeW+cywYgeppaWl7qWMMLKg+AnshLpj\n", + "x45u4u2AZydhmM7G6DIuwI6OLKgsjUDrXAvzXQCUyXDyQ57lpG5ODukFh1CO0eOkbA5/ZzwOlTav\n", + "wZFHHjnxf/O1PSzZ+ddFN7Owbb8oMmd8hJ+Dtg+DLV+YXzvL8/csWRtzYmdTO1UDNhReinNzc93B\n", + "2uO047ILgAIX/WXe/fICLY0Ow8+cQVlz/MycsI844oiJv7tUhGV9ZmZmEBSQpatwCLWThPqgzPqy\n", + "QzB8siNtxDC5px2bgZU35IAXjHnuUGyH+Lfryeveh66sFIZLAmUJXLPkgatXrx7QbWdo5i8rP2QH\n", + "Z77PeC27rIM2YMYHAfftpL/wy2vOCTitYFrOWJuto7cL3JqWLIQ+S0nCfuIEl95fDjrooIESwny1\n", + "ZbZaGl0qLHN4dsCD+23XNPu55YJnZHxxIFhWMsZ7VluWJWJyjbLG6IMDsdNiAAfSuByR5QuafRha\n", + "vXp16mzu1Dt+h01DXe0VCoVCoVAoLBMrZpGKGF4BZEWLKSHQlnHIkr2hYTnle5ZyICs7kJVaedKT\n", + "nvggY6MAACAASURBVNQ995hjjomI3iTp06utI2irY0nKIiJuvfXWCZpM+5gVAB66yGYWWk9fPt27\n", + "yK1Lbbi4bctPh7jaMpUVlvZ1apaQkDl1SQBfN0T0V5pZiL3LtfgqB2sXc2Ur4D333BMRvdaLnK1b\n", + "t25QNsFaHpopz/IcwTf+D63w3usCbWr16tUDS4Etr9CJ9gecsgBw9eNyJnympFILZCazQAJft3s8\n", + "BrRYrlirbfi3r1HGUqe08DwyZ9m6YPwO2Wdu2/7hEfyANsbJNQuAVmQus7YDl+Bp5S9L2wAPuQay\n", + "1Ry4LAf/tzUB2Pq8bt26NFQe2lpLQQvLC7T6FsLXMaBN2WLLWlbGK0s8aplkTqHZhYhtZdy4ceOg\n", + "KDNw31j12j0lopctr1HkJLOyttZR9kWnO7H1BjgFgy1u2X5ha/NYOTRky1Y91oP3Lt+K+GbHc4qs\n", + "OsXP/Pz8QBZdOs3W3SyRtVEWqUKhUCgUCoVlYsUsUuvWrRuUs+AkjZYI0NA5oS8sLKSFH/H94CTJ\n", + "qb0tNtwis1ygHdj/Atp27drVfQcrhTUD/m7HZ8Zt7SUrBeISAOCBBx7o6EXbye6wOXkfddRRERHx\n", + "s5/9LCJ6nttfi89oAbYatnPk0g4uFZNpr567rOSDk6W5IHWr2WFRYt75LvNonjupHePKaHHpIfo9\n", + "5JBDBpqU6UWDgk8ev7V/P9taY5vQjmfwE/kF1qx4hhMvAvhgh3f4aetI65NnB1Vr4vZftDbo9rbg\n", + "wSe04lZ2ocsWOng/LWGtEy16zVljtV9XO0f4fLj8BLQ42a8LZbfJLVvaAHNjf8g9e/YM/oa1Gzpt\n", + "WbbvpANo4HGWqNJjfPjhhwcO+xkcCGTZuummmyZoHSuV1aJNOpoVTPfnzL/T7bHoYqmEP+wHpuWh\n", + "hx4aFNfO1gWy5P2u9fkaGzd7EGvURb4j+v3edPMs7/9eP6bJVkAnsoY29pX2vYus2f+O79x1110T\n", + "fXutuYC298Vs756bmxvw0H05ie402e1ofEStCoVCoVAoFAoDrJhFqj2hcqLmDnxa+YGZmZnudGoL\n", + "E/fJ9p/J7nbRCq0d2KdgjH6+a98dj8vRSWBa+YlMKwZzc3ODIrp818+CVrQVLDbWONrxtTTx2Zav\n", + "dhxoBvZ9s/Zqvwz6Yn5tNULzdjuXZ2jpQ5b4HxqX/ZjsMwJNaIHZ/Nsqcthhhw3k1qWBXF7H2o4j\n", + "aGxdyTTxtWvXDqyZmd+JrUUuuwIclWYt175mLW32j/A4bYFwGRfznHGytl3WqW1vixEy4igigO8I\n", + "33OkVObfhT+H00i0/UOfaYGnlnNbMOE5fdtSDbAy8L1777134E8J4APW8rEo3PYztGYlZ4DThhx4\n", + "4IGpDwtw+RmsyW5PP+ynLhRsawpreffu3YOi5Z5/xmU5yXzq7MfIszIfzB07dnR92PfVco5MmZax\n", + "UkgtvEdj8WnfR07/Yf8k02JZdSklv+syy5VLEkUMi9q7FI7H6ULRft94Tx8rZk77zDru8l1Z0fIM\n", + "ZZEqFAqFQqFQWCaqREyhUCgUCoXCFFSJmEKhUCgUCoVHGSvmI3XeeecNfAjsS/LRj340IvoU8e0d\n", + "qaP2KCdAKQTfv/ozKeJJhe87dPv7kK6eUgi7du3q7pndN6nwKW1gnyHnqrr44osjYlhShjFyPw1t\n", + "tD/jjDMGPmGOhKRECH1n/jbQQhmPs88+OyKG/kj2Kbjooou6vp2Z3H5Vl1xyyQRf4AcRJdAELZR8\n", + "YE6dTwV/hJmZmY4nLj/gPEIunWKeA0crZmV/2ggR5BZZpBSGM5zbjw1aKLVjvxXPLbTQfmlpaZDl\n", + "2WUzaIvMEtUHbdAOLS6dRDt8Q/A9aefIvg72q6DMgksEeY4AsgjP6ceRVcjdpz/96W7+ga3fLstE\n", + "e0eY2lcG2UUWs31i9erV3b6VldmwTwelLVgX9hFyhnCXThobK3Qhi6xn/KnYW/CnQS4s5/Y5gz8u\n", + "h/W+971vgsbFxcWB3FJ+htI5ztlkHznaI4vA0X0uKQXfZ2ZmBpGgXhd+t/B/+8iZL/jSsAfhp4Uf\n", + "F7S///3v73x8GK9zIPIugi/wy35njJe+od0Z050T65Of/GRXNsVRx/Clbdvy0L6zjt6GFpfxcf6u\n", + "+fn5riwPbe0TjExadk877bSJZ9N3ttdRxscVJdo9Grpd2sY+U8wVtGT4pQ5Sxx57bGzatCnm5uZi\n", + "fn4+rr766rjvvvvi937v9+Lmm2+OY489Nr70pS8NEs8VCoVCoVAo/P+AX+ogNTMzE1//+te7yIWI\n", + "fRaKU045Jd71rnfFRz/60bjooou6k2iLnTt3DrIwZzmNHLV21113dadNW1b4jOZMToonPOEJEdFH\n", + "6QBHp5G51gVR2zFH7LOOOOOqIzZcS8i5NZy7x1Eabcbmtj+wadOm7uR8++23T3wnq1eIxuRMxkTM\n", + "+FmOlGCO2rFmmdqBI3wcXcJ4H/vYx0bEMNqCOcFy9W//9m8Rse8gHxHxlKc8pWtrq4VrrjmazVoc\n", + "P/mec5QA/t/Ooa0fPKu1nEX0da8ynsNPIquYY8sutG3YsKFrQ7Sh54L5vu666yKi58fTn/70iBjm\n", + "NIKGG2+8MSL67P0nnHBCRAxl84ADDujm1cXInaOorZkZ0c+r82gZjrxlPbVas2tlQUsWEeQsyOSh\n", + "o08rgdaCWdtjkbW2JJnerF4Zf6eYKxYs59dz9Gubp8prjnEgUzfffHNE9JUaeBaw5Zk9Psv1x9iw\n", + "dCwsLHQ8dc4hrGL833mCvP6dCZ5nw3vvddB4++23d/sde0gWtYdMMU7453xs8IO8XNBAnU33v23b\n", + "tkFhYOizbPHZUWd33nlnRAyrLHhPh8+st3ZN0/Z73/teRPTvx+c+97kRMVxztuZ4zXqOXJuQsYxF\n", + "Yvt9ccMNN0w801UTnNPpyU9+8gQtrFngqEdke8+ePYOzhSNqvY5tPc7wS/tIecP+m7/5m3jDG94Q\n", + "ERFveMMb4stf/vIv+4hCoVAoFAqF/yvxS1ukXvKSl8Tc3FycccYZcdppp8Xdd9/dnQA3b97cabJj\n", + "4NRK5lo+28rEqZCfa9euHfgCAbR8TpannnpqRPSnVluNfC//3e9+NyKGGbEBn9esWdNpddBga4dz\n", + "bjz1qU+d+Gxa+P5hhx0WEf0JHNrHagpdf/31E99Ba8mqXDsbsmkAzmXF6d/5qCKGh+lpNecYB5qT\n", + "K8s7X873v//9iIi44447IiLiqquummj/93//911b50lBA4fntuowHvhGe9dHBM4X1PoB2arjrMEn\n", + "nnhiRPQ8z/ICOb8WNLt9m4WXdWYNC7AunvjEJ0ZExAte8IKIiPjhD38YEcN1xLMe97jHRUTEe9/7\n", + "3ojoLZ98r6UFrRN5tQ8hQItHRnkWtSuzHFjMxW233RYR/Zpt6+E5fxwWBfhjvvB/xvWMZzwjInqL\n", + "m+cU2rCiQbPzbbWAbvY55N1t7TOE9dDWIUA/8BGa9u7dO6gR6IoPf/iHfxgREddee21ERPz4xz8e\n", + "HSeyyj6T5Z2iHWt/1apVnezYz4Y2zvSNTNlSx37B/xkva9SWfb7/7Gc/u1s7yJytwDwb+pkjW6gB\n", + "+wP9vfzlL4+Inve21O3YsWOQew++eN90hQxbRb0XMX72ftbFWLUC9lqs+L/zO78TERHf/OY3IyLi\n", + "lltuGdAdMcyTZgsecM68H/zgBxHRz1W7pvkba5I1lOXsYxzcWPz3f/93RPRr1xZPaIM/P/nJTyJi\n", + "3xq1VY+2rp0JvVn9T+OXOkj9+7//exx55JFxzz33xCmnnNKZiUFbVLdQKBQKhULh/zf8UgcpfD0e\n", + "85jHxCtf+cq4+uqrY/PmzXHXXXfFEUccEXfeeedolfiIiH/913/tToMbN26MI444ojt0WZty9exD\n", + "Dz00vbs84ogjIqI/jaI5cPp1HR9HL/n+2vSjdT/44INdW9fbAmgK9EGf3/72tyNiaAWwtuv6SNa8\n", + "7r///k5L4SdaTZbBG80E7YVnEhEHfACG92O0oIU4woe+rb1y+meu4A9akS1vz3zmMyMi4pRTTomI\n", + "XlO/7LLLImJSO6Jv/2T8+BsAxsHcMWdYJGzZg8+2VOzevXugecPDk08+OSIifvrTn0ZEL4uMH6D9\n", + "wGv4hp+SLVJt3Ts0LfvwAMaHNvwf//EfEdFrjvg+AWoywg+sr1j/nDl7165dndaaZWYGXg/0ldWO\n", + "gx+uocXctbLLOsZ6yTqAJlu72CdOOumkifGyb1xzzTUT7W15YmyMfSyLN+ODfp5hvxTWJnPnDPDW\n", + "vNmL2MNYByeccEK3DwDohedYd77xjW9ERK/tAyw30M6zuW3ILHWM7YEHHkhvIxgn/LCvlK3GjJO5\n", + "fc5znhMR/frC4gDaCFPkwJFzANlybVHamRb+jm8R/PnOd74TEb2vFNi8eXOamdz+V8gDvGyrJkQM\n", + "bw+QbfZN+wG2ezhyzvz93d/9XUREfOtb34qIfl8wkBu+z/i8v8AH1gf/x+fM7/SIoVWf79qPCSsf\n", + "703+730EYH21z+lhhx2W1isci6i+9dZbO/mZhmX7SG3fvr2b2G3btsU//MM/xNOf/vR4xSte0V29\n", + "XHXVVfHbv/3bo98/6aST4vnPf348//nPH7xQCoVCoVAoFFYKxxxzTLzgBS/o3CD2h2VbpO6+++54\n", + "5StfGRH7tLLXvOY18dKXvjROOumkeNWrXhWf//znu/QHY9i4cWN3UudkiUZqbRctgf8/9NBD3SkV\n", + "zRlwwuQnWpGjCVo6IvpT8fHHHz/xzKym2MzMTHc657Tu6CSsPo504eDoyCeAFoDFzzWawMLCQtcG\n", + "cKq3ZoT2Ah/gG33bguWcV4zRUZER/SkeDSOrCeW+GT/jggbzBa3gRz/6UUT0mhxa1OGHHx5f/epX\n", + "I6KXETQiW0ds7UCLs8ZKVI7henltvS9ru7ZeMT60f9dx4v/Ov+NcXqCdI9o4F4vpRntlXUCLacci\n", + "A++JlGRu8WsAe/fu7eQaCxEy4vpWrvcG77EW2/KK7DFG15ZrI4IcycTewmdH+LieHfyhnS3Stgqy\n", + "5nluq3lDF3sJcg3d9qeBRkc/MnfeX/i7rfB33HHHYP7Z55gLxvdrv/ZrE32ZFvZLfjoqFjB+rOir\n", + "Vq0aRG65b2hiz2W8tmRhbcUyw1xhibI1Df620Yvw3lZj2tI30d383e8iaGF9MN7jjjtuYmyglTfm\n", + "j3m3lcZR4IB9weuCNcuax3o2VsvREXKM62lPe1pEDPcW9nJHsyE/jmbn/4wfPkJDa8G077DfsTas\n", + "wHP4g59Xex5o4XyDbX5C7/8gy2X3SAu/LPsgddxxxw3M3hH7THlf+9rXltttoVAoFAqFwv8zqFp7\n", + "hUKhUCgUClNQtfYKhUKhUCgUHmWsWK29M888c3D3a98a6ltRJ4i75XXr1g1qYlEL6bzzzouIYWZy\n", + "2nMvT00h6hsRMeEs69BIHZ8zzjgjIiaziuM3wX0wbak/RR/cw+K/4HpV1JSiP2cV5/754x//eETs\n", + "q7WV1SnyOOkb3yj4RnQO/KE9NcWg2Xzhvv+KK67o6jJxWqdv10SjHh5zZB8SaKYfxsn8u7ZWm03X\n", + "43SEF/4arlf3ute9LiL6+3bmlHauzUidKNdP27lzZ/c7dFPHyXXwAH1k9Q3t58W44SO11g466KBB\n", + "zSzmlTX07ne/OyJ63wjn4vH8U1PSeYPa7NkRfc2qt73tbQOfL77jepWnn376xPgdvWaeUycQuBoB\n", + "MnnJJZd0dLu+JbKDbMFz2jtSCP8VnvXhD384Inr5cmRUq6nCc/YW+/5ldfyQLfvhuQIAdb/gI2ij\n", + "vVyvlDWHz47l1/XqqEEIj+1jyN9ZR9R9Y48+4IADuj7hFfNJW1enMC+ZI/ho/zfLz4c+9KGI2Fff\n", + "LmKf7wzfoW1WgxA/HGfRZu5cm9N1UL224eN5553X/a/13WrBuuDd4lxwznhP3/DR+aVoh+/Q1q1b\n", + "u/mkL/ZzR6szR+wtXve0Z79xLU/2cEegR/Q85N3iOrheq6wL3i/wg//7PeN91+/RhYWFjjf0DQ+9\n", + "5mjHvoCcZyiLVKFQKBQKhcIysWIWqZmZme5Uy+mPU7KzifJ/Tos7d+4cWC8AGgLRRpyIaZ9FlPF3\n", + "8l4QteVoJk65hx9++CDiz3B9Ir7rSDLA+KEZzSuLlJmZmenoRtNEO7OWAi2OrONnZk1wezSTlhbG\n", + "4T7QODxHfjZWQzR2WyjaqIuIXkvIarJF9DyD58iO+cI4+Tt9thmaWzAnjJn+d+zYMZgf2hKFZBlz\n", + "BAnPchZ5Z5kHWCqOPPLIjm5HpQEiWeAdMkaf5mUWgcnfHYk1OzvbWbv4HxFv5ovnne+R48a0wKds\n", + "DbdzlFUZyKJ1GA+8JnKQ+bW8IIvIOpYMvtfOEePG8sqzsHaZJmeB5v+u/2hA05YtWyJi39xmPHed\n", + "S0fjGa6V1mbTb8HYsII89NBD3Xp2tBk08JMoLaI4s8g6RwE6/xCAjw8++GC3jpFFy45rcjr3mfc0\n", + "v4uQG6L+xmpzet7oO+MhYM06uhPAJ57tCiAt7dDLd2yRzqKZbaHLMpvzLPqBBvjVzmmW4y6rb0pf\n", + "rp9JNQLv0XyGpvb94/m3lZCf7NHTItBBWaQKhUKhUCgUlokVs0jNzs52J1HnkfIdsvNO7Ny5sztl\n", + "OtsvJ2esXeQc4rTrkzQnTmta5OTIatHNz893+UvQpHwydm4ftEA0NWsgjNOnenJCjVmwnDerzeI6\n", + "BvpwNXhrR/ALrchZlltasszm1mJAZonh79ZgAfzB2oi8OHdLRD+fyAd0Z3W50HbgNdpOlmWb7+GL\n", + "tLCwkGppzhuEbGVWE/uCTKtA/uCDD8bjH//4iOh5Y9mib3iINQhazBdbHm3pGbMyMk6sM7RFuwPM\n", + "N/wi35pz0QBogPfkHWKsrQXLewXyi7w6I7cz4GM9pB+vafteYamBhlZebO10RnPz0NYRaGecbu8a\n", + "bjxnfn5+YJnkuzwDKyB8Gss8HdHzgX3UViS3a2tPZlYdeMT4+D8WNedwQ64YL/UiWU9ed9AyNzfX\n", + "rU/+Zlm0nyt5xJBdaAL2uXK+JWNpaanjAzzns+XcFknnE/Ne5GzsrGXWUyu79rOypcl7kX3K2ozf\n", + "bT/A8k8FibHKGTwz46H9FenTcsJazqzw9Nfun37POY8ga41cVZaXDGWRKhQKhUKhUFgmVswitWbN\n", + "msFp2NYlwKmxrReFpcinV98bu+aUT6SOznAkgO/r0Q7uvffeQaZi981pnkg5PnP6tabGM33itr9S\n", + "O1b6zLKEA07naJZt1tuIoeWNsXDadzX4Vgt0hBvw+ADzyXiYK/ox7a49h9UIbbP1QUCGMq3HVj1X\n", + "f0fLxWJnbccWz9bq6PEzTlcc51meT+bINbP4u/mJFemee+4Z+CLYr4L5pi9ngzbPWVe2njqCDMzO\n", + "zg78sDwHwLXjyM7PuLMs+/CNeUcG27HyTGTCdeiyHHZYxV07b8wvMWJo+bLGH9HzGo0arR1LhLNm\n", + "0xeyhWUmy1bPXuR9Z/369QMe8izoY7zek4AtDvZ5yeYIq0hLk60dzD/PdE3OLIqT9lhcWFeWRdBW\n", + "vchuFhy1iAy2vl4tsiztyNuYlZF5ok1mQWGcrd9lRG71gk9YUaFt7B1gi6ErWkzzkbJvoHnu9jzP\n", + "ctP2ZWs3vMxuDVgXWLwzf+DMH3JxcXGwF8FTZAlLGueGzP/ZKItUoVAoFAqFwjKxYhapubm57jTI\n", + "CZ3TrE+YY7XGOCk6IsL5dPAdGbOkRAzzI7V5gSKGWmCbV+XHP/5xRPQag61XjoygPpn9E4AjQujX\n", + "eUXasTqSYSxKAnrbvtEUfG8PbGWyljRWx8l5YMaqkEdM5vWI6PnjvCmAz/Ce6C4sGq1VEllx9B3j\n", + "zKL2oPnmm2+OiN4S4zmyj1RrbXJNOebAljfGk0Un8X9bdGzZauUCy0vmCwRtzL9rLbo9fIF/niNb\n", + "gmdnZzseYu2w7xxwfiysf/Y/AV7/aODQZFraZzDurG+DNQo/bZmhH+eCA62s8zvP9By5b/sUolkz\n", + "BluNbNHHgrVhw4bUX5O/s4agzRZMWw2wYLKOTIsjDOfm5gaWZ+BoXvwRve+ZFs8pe5L3l3aO8XXh\n", + "HZNF+PEewKKG5dXrwnudo1vH3kfQy97jiF9gywu0OgoNsMfBH/wevWe33/XtCWvKljZHFmaR1+04\n", + "I3p+sKbhY2vZ854LL1nHfkczHmhiLln/WX4+Rz3Pzs4OeA4NWNM5L0B3FilrlEWqUCgUCoVCYZmo\n", + "WnuFQqFQKBQKU5Adl1bsao9yCBG9SRJgFiQVPunqCdG98847O5MkPymFQMkHl+VwuPrll18eEX2K\n", + "eDvJuWwNZTkoPxDRm6T9ncsuuywi+jILTkDItQpmQ0ohUArFjsyAMZGW/8wzz+zMxb7+4lmf+9zn\n", + "JnhIH9CKCZPP0EJaftqTwBHzOyHo733ve7u+XfLBVxSUHyCFP8B5kJBql7eg/ABywRVJW+aA8gAu\n", + "m3HttddGRMQTnvCEiIh49rOfHRH93NA3ssVVFvyDFnhOqZWxKyOXNqEsB/MMr7mSdLkK+OLrNjuK\n", + "0j9jWLt2bWfu5ooGE/VFF100QTfw9RJOln/6p38aERGnnnrqBK1ceT7rWc+KiP6agvX2zne+s5NX\n", + "X6NjNocWSn4wTtYk7bgCveCCCyKiXxfwGkdQnoMsXnTRRd18uowE40TG6BueI0vMiXlPeQtKitg5\n", + "me/fd999naxQTgY+wEPWPz/PP//8jocRw3WP3FgWWaP8nbnftm1b90z2OdZom0Imol9T8JLSGbS3\n", + "CwXtCAtnj4aP7Me33XbbIFDB5WrgNWuO77rUFnOaJcNkjmgPLW36A67FkdsLL7wwInqe+yrLASHs\n", + "6W7P3nXiiSdGiw9+8IMREfGa17ym4zF7CvJN0Axr0yVfeHe1KVYiIi699NIJPsI39mj2R65jP/ax\n", + "j3XzCXDYf97znhcR/bXaH/3RH03wELg0DPJw5ZVXRkRfDs2pCriG37BhQydb9A1vuS62mwp7ut/p\n", + "dqGAT95HXZpt7dq1HV3IInsofcM79j2ueikRlaGu9gqFQqFQKBSWiRVNyMlJGyfJ//W//ldEDE+c\n", + "nHLREq699tp46UtfGhG9Y6vRnkIj+pNm5phoRz5OpHYIRlvauXNnpxE985nPjIih0yufOb2jMTz3\n", + "uc+NiKEjo5/NsxweCmZmZlLNm5M0cEhsFmoKmBu0YWj5rd/6rYjonVUjhkUn0V4Yvx08XVAare7k\n", + "k0+OiD4cHjgp4E9+8pOIiDjllFMiYnLu/Gy+87KXvSwiessUcCg27bGOWF7sCM73165dO0i1AQ/5\n", + "O3Py5Cc/eYIPwKHJBDM87nGPi4ihozzrZHFxMW644YaIiDjppJMiYqghM/8u/Mz4LAdOH8BcHXfc\n", + "cRExdPB8+OGHBwWwsV5lyWHRVtGOX/WqV0XEcC0is9DOWJ/znOdERM/PiGFIPDzCYueUAy4zcv31\n", + "10dE76RsB3+nVzA/2zWKrGDtg5anPe1pE88ETjCJDGLZGSvLE9HPIfvLpk2bBnSz13gP4bNTFJh/\n", + "/MQS1a7/Fszlbbfd1o3TDvl25IeGsRQSEf2aRv55D3gtgjbJ6k033RQR0b0vslB5O+63yU1bsE8g\n", + "63wf64+d8BcWFrp5ue666yKil/Nf//Vfn2iL5cqlosYcttv/83f4ioW2DSCCLvqyddzy0hbAjujn\n", + "hHXkOaU/9l36w9Lfyp2TgSL3rDmnv0DO2aOgCVp83ebgLMa4a9euQVAV+0FbbDuiP4tk70ejLFKF\n", + "QqFQKBQKy8SKpj/gZInGhRZgK5DLt+zdu3dQlBbYOtJq7RFDjYzTLKdXtDsX1jX27NnTnbo5taKN\n", + "mW6f3jm1Z2U8+J4T8ZmW1atXd+OxpmQrgMNcXTg5S4JJv4wVC+BYUjmXhvHfgRNNMl4sk+aLS8jA\n", + "P6wkY1ZJtHksM/SJ9Qs4RJ1noWFi/QIugwOfxpICum/7m3mcTqhnPz1ru22hUOQgSyRqCxQ8hH6n\n", + "1nBxZj5TQmGs7IvTV/CMrJg1mqf9VzJZNC1Yx9rQfSdvZdxZKg6Hg0Mbsma+0G+WqLDdu/gbGjHz\n", + "CU1Y5KbR4tQlHqtLCo2Ve2EcLvyNJcEWCad38Jr2HLmcycaNGwcFjwHj8Hy6YDCw/6r3Rc9Ra5Hw\n", + "PufbDuTBqVuAaUFmee/ARyyZbSkU+nXqjawcD/D7wUV9TTs0IV98hqb22W36nojeb883GLbQsK/Q\n", + "t+XBKRrgM3LVts/KtNhnzuO0xR4ap5Vaavv3GkKmvJ6hIUueapRFqlAoFAqFQmGZWDGL1OLiYnfS\n", + "JnoFC0OWBAvN7oQTTujuhTPtFfj0m6XC52Tqop7WSForGtochS7tI8Up3do70X7WpFzkk9M8J29b\n", + "6jZu3JiWNsg0RifDhOe21DlyhJ/f+973ImLcv8uJ9uxHA3iWLWzQjpZk2tH28HNC0219k8w7aMES\n", + "ZT8Da2poi5kswjcnS33wwQcH1g5ocKmQrLCwIy/REq3lAeZ+9erVnVXOET6G7/yRE1tN6RvLJjIM\n", + "X7yOZmZmujYucZIlEoXXzOtPf/rT/dLiyDrmtG2fae3mNfD+gH9eph17PbjA+Bjd/KTPG2+8MSL6\n", + "uQKsiyxqLytvxb7Q+oeZh60vX0tTts+x/p3cMEtUyPPYo7ds2dJZXrPSUcwn+1tWCsmJKl0yy3xp\n", + "o7/wL2TPtfy7QLAttpn/DbyGJsZq2jds2DCwLLH+s6S5LlNmi4xpgR/sAWPJZJl370VZomrT4gLc\n", + "nlPauczbWPJpW6/Y55ADW43Y580X+Or3DLT5Vmp2dnYwTm7DoIH55j33SLNDlUWqUCgUCoVCYZlY\n", + "MYtUqwGh3WRFTu0PtWHDhtR3iT78/6y9T7M8yxYa/z9iWEzTp3GXCLE2ZK2eZ/I9F4I02igEvgMN\n", + "PtU7OgVe2ocE2KcCjJV9oM+seLH7QBNzKRlHa7TjbJ+D5QMaWj5Ct6OpeEZW8sUWvczfhHZjaIOU\n", + "CwAAIABJREFUvhPZPFnG7AuX9e1SMuZjq6E5ysYWGPsruUCsZTfzP6FfWyRmZ2e7+c98VkBWAiIr\n", + "+WHNHNjXrn2Wy0/YEgt4piN9nFfItI75KxrOe4Q1h/m0vGdlbLACeL+wrDOWsb2ONcd47H+XjdNW\n", + "cs8tGIuGhq5M/nm2fWQyK5D/Dv+yMi6zs7MDK6Z5m/nYIucelyORmVusqmNFbu2f6shiYAuj5zEr\n", + "5uw8Y/xs17SLlmNpZpy2dtPOc+d3NcjKgI0VloZ38MH7Xlbkmv97bWfvmzH/1+xGKlsHjxRlkSoU\n", + "CoVCoVBYJqpETKFQKBQKhcIUZMelskgVCoVCoVAoLBMr5iP1tre9bZCThc9YrD72sY9FRMR73vOe\n", + "iJi8x/R9OnV5qIXFfbKfQRQBNahOO+20ib59N849NjXr2vpZ9r/gM3X5qBHlO3LuaV0jCtodAeQ7\n", + "3yuuuCIi9tUU8v0w4FnUN3JNQUdAQOOnPvWpifaOsPAYPvvZz3ZtDfs2UCOOcTprLrS4Nh98NNp8\n", + "NNBNnSXnbrKfDTXC6NtRO4brPtqHZnZ2tqOb+XGttSyvlGtE+d7eUTsf+chHJmhvabaf4datW0f5\n", + "Yj8VaEFeqCnG/x0xar68+c1v7v7m3Er4VVCvDlpcx81RWNR9dN0vgOwz/q1bt3Y1Ag37YfzZn/1Z\n", + "RPQ8tB+GfYqy/YL2rW8M65kaYQA67euB7FpenMuOOWBOvS7a6CTWBm2pV5jxAx8axknfll3n2WJO\n", + "WRdj/mrML7Lypje9KSKG/jf264P2ti5rxHAPYgzUw4Pvs7Ozg7VmHiK3ziPleqHeXzxGZ+v2umvH\n", + "SxvmizUHLfaVc9RiVoMwy9f2qU99KuWh4fXsvIp+70K768qC9h3Ae5G6fPj+2b+TSgDe5ywfrkpC\n", + "e+rhOndeRC/n1P1kzdkvy3nhGGeGskgVCoVCoVAoLBMrZpGK6E97aBacHH06dEX21vPeJ2BO2s6X\n", + "4iguMC2iKjvl7927d6ClZXmBiKpAo3DuEuDoGyxT0OSov5Z2R9NlFbJ5hvMnOdok4yvfG4tSAtN8\n", + "4PxdR1ra+mENztpCy0drKeaxkUVzZlna4SNzBE1zc3MD66BlaBpfrNUi7850bhoXFxcH0XhZLh7X\n", + "Zsxo8/gdQWq+jUUreVymxRalLOrMsuefbf+Ots2sAAB+YKnms61ChvMyZbm+2v/Zv8J7TxZhllVZ\n", + "gFb2Cfi3uLg4yLDt745lfR6j2VGvznUGbNlaXFxMZZHPWR4gR1bZgud1n31/ZmYmjdIC/m6WswmY\n", + "D75N8d7VRrNCC9+1rPg9Qp+ObvRYsrXZjs3r3zy0fNhCR3tnvHf/HovXeEuna7M6yt1w5LmtZX62\n", + "q5q0tWlNt+Xa78dpKItUoVAoFAqFwjKxYhappaWlQT6I9n8tbKlZWloaZAsG1ATK8kBZq/dJmxNq\n", + "ppG2vjb2k7F2Y98p+rSWDMhIS6Zun6jHMr5b68tyMfke3RqHtUbTvD8NxBp39gx/N8vtYi2AMfp+\n", + "fsxqmFkQMmQ+IBlfnMm61QJNt/2yLA9ZTit+Op9Ypj0fcMABg2dZ8/IcWOvN5te+NPuz1GRybbpd\n", + "ky/TKIGz99sS1X7f68F+Epm12z6S3gcA+4stv2NzmvmXWOZMu8ef8QkrGrLY7kcZT63VZxbmadmi\n", + "s/2i9ZHK1r9z3XkPdt/+vvd25wbbnxV6Wn5B712ei8xym1mNIoZWYGcLB7ZyZjn8gLPsZ9bjlk5b\n", + "A2nj+c/ezVlON/uisS7GrEtYS73WMot9Vu/R6wrYgtn6nGb7nPmTrf8MZZEqFAqFQqFQWCZWzCLV\n", + "VsWeVpttzJ8jswK50rija8ZqhLXtXO/J7du7U9Pl064jo6wNun3rbxPRa17OtgtaTYz/OSOxx+lT\n", + "f9bec2Pa25N65gOSwb5O7sdwhmRbbFptylGJ1tKyGnTWwDx3pt1zNJbZ3Bq2ZdbtM9oyf62xaB1H\n", + "mwGsFtZiM/8bZ5O3lpfVfWvpmZY125pmZnlhTpz52XPbPjujJbPUZdZEw5UBzI/2e7ZEuA/DWfZd\n", + "13HM/6qlvd0Lp9Ury3xjTLutqJYHtx+TD+8LWdRdtn/Yb9VyYr60n215y2Qx840yTbYmuQrB2Fgd\n", + "MZj17cz+tsRm8w+8Ltq14D0TmrL5z3zm/D417bZw2uoY0cti9t7wOKdVGfD32QNt6VpaWhrMgS3W\n", + "+/Pt2h/KIlUoFAqFQqGwTKyYRWpubm5wHz0t0qrVjnxaB458MjJ/HUenZFYj0NJgbQ1kvkPZONGG\n", + "8MOwtc1awMLCwiBaKLMYODeR6x1l47RlArQne2t7WaSjYb5l9/LuDw2dn60WaV8F9z3NXyurc2da\n", + "yIHS+txlVkDLeabl0Bdz4/nfn/XAeW8y+belIvOBs1zYZ2DM8uPxZTzPcvtMg9dk5jvR0mmt1LzH\n", + "Am3LdBY5ZIuOx9TSklkkPX5gqw7IfKegHato1m/7N1tekAdb3h3laN8ot7ff19LSUupPhcUg8/mb\n", + "Znm1LGY+la2vWJZryVGa5v00y2RWw3GsrenOIsiA58xwP56blr+Zr9e0GrS2XGe+Y7ZgOiKvfU5m\n", + "BbcPGcCanvnlWV5skWqjGDN/qsxXznKeoSxShUKhUCgUCstE1dorFAqFQqFQmIKqtVcoFAqFQqHw\n", + "KGPFfKTOOuus7nR36KGHRkSfAZz7Vdc3wydg7dq1cffdd0dE78tALSRqCjnP1H333RcR/V0odZmo\n", + "+8M9Kzkuvv/970dExCGHHBIRfd03+p+fn+98Wu66666Jvt3WvgzQ3tYIi+jrG5FHhPbUHuLvtD/3\n", + "3HO7O17fI/OTWljUFILn0G4fAeqbudYePkH333//RP+f/vSnBzXFssgH6GY+fedN5IfrhEE7c00e\n", + "GuZ0fn6+m3/qMmVReHymXhV9A/hCZAlzhyy6PfJxzz33dHRTl8m1sPg/9RsBc0QNMuaCcT744IMT\n", + "36c2XztW/mefFvhinsMfeM4z3Te0wxdyF8HHtr39UCyTrsvG3+n7oYcemvg7PKeOl6OZmKN2rGee\n", + "eeZEG+CooksvvTQihnUfDz744Ijo1zR9my9Z5uf5+flu/XsN4ftInjj45dp59i1jTpFFaGG/oB/2\n", + "rnvuuSfdF+E137nttttG+/YcwR/mn/5NC2M96qij4sYbb4yIfi7MF/ut2TcGeYF2t2ddMCbkBRlY\n", + "u3Ztx3P2UNNCLTz7ryEvnn/4Yln0u4s94Oyzz+7asJ/7XURb6IbXhx9+eERE3H777RHR8xx5gY/I\n", + "CXs0+0srX65vyU/oZjzwhXFCO/zwHLGPskYBz4aW2dnZri218OD1pk2bIiLiuuuum/jMfJ533nkT\n", + "7dlX2r4j+nf6ueeeOzEmVy+IiLjyyisjYriemSPv0cx/hrJIFQqFQqFQKCwTK5rZ3NrOWF6YiGGk\n", + "wJ49e9KIoP1ld91f31mNnf1lNndUyrQsuW6fZTZ2xECWZTuLzNofLY50yiIkrWlP4+MYxnLrtN/N\n", + "IsWyvp0DZSxCM4sQyz67b3ie5TiZll9rrE9H1WT16rIswhnN7bpw1OG0LMGZTGbt/dORUm2lgiy6\n", + "pm0bka/FjOeOchqLlMoigrKIUGvaaOD7i8KKyCNR2+dOk8Vp/3dkWCbLltXdu3cPIuIy2WO8jlJ0\n", + "VFdWtcBj4bmrV69O13O2D2b7RbbPZeuj/Xv2DNOdrfdpa++R7Dfer7L8R1letWk+xY5+HYsKdwSp\n", + "rYDZ+wL5yPKHgYxGR/G1fWRZw7McVu4TZLm+xvaA7Lzgz2PRhvtDWaQKhUKhUCgUlokVs0itWbOm\n", + "O1niC2L/C+DM3mvWrEm1EVd+5j41yyPjmmPcM3NPa00NP4R169Z1dPs+FZhGa/XuGx8otAA+M4ax\n", + "HED7y6zcwvXNshwuIMt5NcZHaxDTcnDZauA+M837kVgN8ZfI6pxZw6A9lgn7+ZhPzIH9e9pcTsB5\n", + "rlzfynDOFmvJ+6s55ramO8szNS23FTRbQ/VY165dO5hXfJiyNec5yaxGzpLszPBjVoOsL8N9wlP8\n", + "tTzOLNu012ZEv+Y8/1kuLq9/18fzM9h/QJtl322ztZXVFDM/nFU+W0eMYc2aNd3vlkX2UGhxn1ke\n", + "KQCt9mMy7e3cZ1ZgyzewxdZ9M7fO3D3WP315fi2bzvDOvp9Vn/BeR/+8j9r+nf0+W1PGNMssQE7g\n", + "J8+271j7P3gF3fizWXazChBZ/rnM4tfmXQR+/0PLIx03KItUoVAoFAqFwjKxYhapxcXFTtMiiiXT\n", + "YDnVtlmlM98da5K2jvhESuQHmiU0ELVjTe2OO+6IiH2nabQS6Dfd9A1NWLvIvOqsqT//+c8jYhiF\n", + "4SgP8MADD6RZwT1OZ+y2lpPd9VvzHjupWwOw75L5Yr8i10HLfEVci8qfI3reehxZ1twsUzV9Z+A5\n", + "PBvtcawP17kaoztiaD2jHd+zhQ8a9uzZM/Crc9+uQQmydcHfGZdpdz2sMX7xHdPiOeJzxhfGZFrH\n", + "xmpZsi9LVvfOmbwzrZY1CvaX1d88p42t5IB9DhrhCzRYU6e9fci2bds24DGRwrZIYL1gjzLt/ISv\n", + "jn4EfB+aIvIbBmgBtjBkfGGcWBGgzfto25/fA1mNOPMwWxfwiznkHeAIMtDKgP0qvZ9jkbGPT5ax\n", + "HhocgTsmX46gZf69jwGvd8+737vMtffwMUsd7zNA3+27dez//pzVbPUctnObWQH9nbH9fH8oi1Sh\n", + "UCgUCoXCMrFiFqn5+flBvafMX8P/n5ubm1p/KKv7NS1qw74k1khb/4ZptQHtTzEtasft0Xay++u2\n", + "3p/rdGUWpkyjMD/Nhyyq45Egi86yT012L40Gav+fMXnJKsRndGfRTVl9J/Mxq9EVMYx4meaPZL8s\n", + "+2Nl/i0zMzODec/WkCOBMsuLZZFxZhXo2zU5zV/P8zctMsb+HWDMRyKzzE7ji5HxxbK4v3WUyVYG\n", + "88HrInvWtH0oovdhsU8UFonsu95Pp2Gspl225jJreLbnOsI6m4N2j8v2O7fN9s1sX/Q49/fu8h46\n", + "LeJv2nsCTNvbWlrsu5S9J7NnZtGbGe37kxdooU9kM7MCgmyeM0yr4dr28Uh9KjNUiZhCoVD43+y9\n", + "eZDmVXX/f7pnejYGYdiGZdi3AUHAfcPEGPUPS2JMhRSVlIgCQqIIFZFF+aoIBSiUEkVFpIgmKTRl\n", + "ErHirkHFBZEoYlgHHGTfl2Gb6Z7u/v1BvT6f+7w+n9NP09Hq+Kv7rpp6pp/nPvdz7rnn3ueec89S\n", + "UVFRMQS1RExFRUVFRUVFxe8Y83a1d8IJJ3RCI0mJz7UK5UpI+Y4ZevHixY3Zjuuvs846q+m3BCGi\n", + "APMh7SltkDk6u0QA6eonJiY6zr+mhdIpOBfyuZ2szznnnIhoSyHYjGpHxrLUhk3NXL0Qxgkt9E0f\n", + "9IlZFQc++qZcAeZ3+Eh7+HXuuec2pQoyx1uX/IDnWCbhS+moGtGm/HcZBydNXLZsWZx55pkR0Zb8\n", + "wPmV71CGCL6cffbZA30jc4wPmuALtLsEEXxctGhR8yyXNnG6C1/DUpYBOacMD+MjzJ3vn3vuuR2+\n", + "eN6Ri4985CMR0ZZCYA1RCgU+ZXJuZ2NfmZZlnBwq76ACl7ZwmQ07NNOeOQWMFZks5Qu5JX0Jz7Dj\n", + "NuN873vfO0CjAc+RL3gOv3wFvHTp0obnlBNiPJ5HeE+5GnjugBDAM9kvTjrppAF+lM763iuYf2QP\n", + "x2aXCIJ2SoQgJ8iiHehdOol2W2yxRdMn36GteejEw54jaMnmiLX60Y9+dKD9E0880UlrA08pnQMt\n", + "Lp3DXgRt8BFZZJzMJXx06ZyyjJf3atbq//t//y8i2jmys7hTtCAv/L4w/wQ3UbaKub7gggs6+xz8\n", + "gDb4xG+u15yv+gF8ZK9j3cFn5n7p0qXNbxGy4j0XmngG+xzt6RN+lOeBiO7+YveLxx9/vPk/ZXng\n", + "i106oAW+QHuGapGqqKioqKioqJgj5s0itemmmzaJ2X75y19GRBsWu+uuuw60RTvgtLhw4cLYaqut\n", + "IqIb+upwfU7EnNLtAIqW6LIF1113XURErFy5cqB9WVKCPjkZZyGTfI6lAeuINU4nE0VjgYay6CJA\n", + "6ygThZZ0ArQ5xmueZknv+B4hq30p/51IEmTlU2jnciyMwQ7NLphr2tGCyr7gMRo18+kkhowTXt96\n", + "660D399xxx0H2mcJ3cbHx5s+gMeB5ozc3H///QOf22rG3ELT1ltvHX1YtmxZ853f/va3ERGx2267\n", + "DbRx8WFbJhz+Dl+QJ3if+QhMTU018jss+auteRS3Zf49TjRz5o55RybLNco4oQGekrbA4wR8Tt/I\n", + "jR3ava623377gbGUewC8Y/xr166NiIgddthh4H0Ajxk/37/pppsiop0rgHzZgXxqaqoTuMFag054\n", + "jSx6XC4IjYbuAAhQav0REVdeeWUjg6b7wQcfjIh23bLG4LXXhdNd7LTTThHR8sX7TpkcknEwL06C\n", + "zDOdWJU+PE4X8YU/yJn5uHHjxmb/d3ob86VMsBvRFitmzngGYH3BZwoz33jjjRERseeee3b6Ri4Y\n", + "L+/b0uj0QrwyZx4nY4NWaGOuynQc8JS5gKY1a9ZERMQee+wx0Ld/05Fd5IbC2+6fMTHGVatWpeuf\n", + "fXGm8mMzoVqkKioqKioqKirmiHmzSD3wwAOx9957R0TE+973voiI+Na3vhUR7ckUcArmVHv//fc3\n", + "GgYaIchC6bNCqWha9MOzeEVbBmhFDz30UHP6tvZuWoDDfW3B4JRvDYZTva0pGzZsaPqErlWrVkVE\n", + "N6zbPmD77bdfRET87Gc/i4iupoamhXYMzXfccUdEtFpBRDfZncPbPRfwHA0cywI8z4p5wl98Afba\n", + "a6+IaDVceFK22XbbbSMi4pWvfGVEtNoaYNwveclLIiLi0EMPjYiISy65JCIifv3rXw+0p38nSR0Z\n", + "Gen446FxMo/QmYX9k5COfvbdd9+IiMb6evvttw+0L62xaHH0TZJYYJ8IeA/PswKiWHb4PnPghI9T\n", + "U1MdqyUyaL4gg/vss09ERLzmNa+JiIj/+q//6qWdcWKJRHavvfbaiBhMkskaYt1i3dh5550jIk/f\n", + "gJy4LIct3ryPfEErVqZy3bEusLC/4hWviIiIK664IiK61i60ZfYVvofFzRZv7z/Im+cmop1nngEN\n", + "zMF222030J41iMzZtw5LFkBOnv/850dExMtf/vJmfmwFQO5vueWWiGgtL/SBvAMXFGfc/H7YglWm\n", + "G4An9jsFyAuyZUscfruAPdj7blaId8GCBc1eyTzyDCd3ZZ1gSWL+sbyV+1xEe8MBDQcffHBEtHNV\n", + "+py6zBo85DfItyO2VNEX32M/MO1Yz7lduv766yMi4kUvelHT1mVp7Avmkmv2R7zmmmsiopUTzxG0\n", + "s9ahYauttopddtlloC3ygIzaAl/edsyEapGqqKioqKioqJgj5s0itWzZsvjmN78ZEa0mnmmwnFjR\n", + "0B988MGhpS1855klluPZaEfPfe5zI6LVcmw1QGvadddd47bbbouIvFQBf7sAKPA9MzQ6oorTsbWd\n", + "TTbZpHkPDQCLkS1S9MU9OrzEgoWGDdACsQ7Sznft5fg87gyZH4pLqQA0FD6nfI+joCK60TdXX311\n", + "RLTaoGll3n/+859HRMRf//VfR0TEQQcdFBFdC5b9u8DixYs7lhS0HZ6NVocmaVlkjugH+ULzQvYA\n", + "2uRjjz3W0I/fgP0prOWhaWFFMs9d3sOvfRZMJ4d1JAxAs0ZTPOSQQwZot+XNRc2xdDgSK6JbTBZe\n", + "811bXmxhxTKVlf5BvmhH/32FYtkXfvGLX0REO//2gQNYxbFU4FMFbVnRWvjAsycmJjq+HewTq1ev\n", + "joh2/qHbEbPID5Yn+JCVWkGOkMMXvOAFnZIngHnGtwd5YA/LrKnQYr54HcG/DRs2dKzcvgWgD5d8\n", + "cZkmwJxhBWHNsh/Y4vnYY481eytWS/Y970XsNfSJ5RWa+B7gtuDmm2+OiIivf/3rEdHOMb9tEa0s\n", + "OrkttGWlU7D60S7bu6CFOcdXE766LFAfTchiZtnnN+iGG26IiNby5pIzzAVWaPaCRx99tGMFhA+M\n", + "iz55ZvWRqqioqKioqKj4PWPeLFIjIyPxvOc9LyJabQhtPysFgXf+pptummp1nN5d2BYtx35GaM18\n", + "D62AU7KtQGgqU1NTzckfbdeal6MTbM3wOF2MEW0qu9+fmprqaMicqE0L2hync2vHHic0owVx6keD\n", + "K/nOs+A54+or4VGOk+9Zo7ZG4ohKNFrmovTBQMthPtFinLsJYO2BP1/5ylcG3rcGC6C5LAJq6wXz\n", + "yJy4ZIxpYdyW0Sz6kX6f85znNPPJPJmHWdkWR84AR+04EsY+FaOjo808ISN819ZOeAuN3//+95tx\n", + "RHQtb8gLn0ODc6FFdNcWmjJzYwsD1kLGX+4x5bgBY0KDxTIBv8qxwlvG4/xgXv/MDX1Cq3O3eazs\n", + "P8hqWb4KuAA2Gjc8zcptQJPnxrKOdYl9qLw1cHSaraPMEWvQVh2sCNBAO5cvAqXlJisQDFzEF17T\n", + "pyOl2WucfysrLL3FFls0cmCrh+efvQqfMebTVnYAn7BcYYHit65s76LzzKNzeAH2k//+7/+OiHbP\n", + "ZbxeR96jkAfkpJxzr02exZ6a+RaztrAqZyWGAO3LKFjLlqNSAePMypYZ1SJVUVFRUVFRUTFH1Fp7\n", + "FRUVFRUVFRVDUGvtVVRUVFRUVFT8jjFvPlLvfve7O7XYXJOMmlJHHXVURAxG6XBXzX3q5z73uYho\n", + "6w9xcqRP5+6hjo/rfgHXc6OmUNnePkGu4wQtgOgU7pEZ50UXXRQRbU0hnu1su9yVU/fn6KOP7vhy\n", + "OecW9aeob8f4Xd+M++RPf/rTEdHWIOOOm/6dN+XCCy9s6hU526+jFJlPasoB+21AC7W5qJ/G5/C5\n", + "jNa4+OKLI6Kt+eQ6fgY8pKaUs2f7/h15oT337tD6+OOPN+OmFhZ8sV8C8u6acrSnHc92nThq8zFH\n", + "k5OTDU/wq2B9UFMK2ULmkCXXxaPWFjynP3wcGC9yc+mllw7QXtLvnDXwkJpyrkEJmIszzjhjoG/4\n", + "5ZqVyOhFF13UrDn4gWzRJ/5b9E3tROYOfw3miD0H2fV+4azi4+PjnTpuwP40ruPFumCctLMfG/LC\n", + "/DNGvjc6Oto8C1qOPPLIiGjXJHQjW8gD8w9fXBe0jAws+zffH3300Wa9ZvVQXXPO1SiobwfPHTHI\n", + "s5gjaIEvCxYs6ETV8Uz2OfZF+0rZR4r21PFz1C7fY/9Avk455ZSGV54n5qKsV1nSYprgC+vfv4sA\n", + "PiHLl1xySbOeM98f/M6oKUluR/sEIpOsI2ozumad/b+efPLJZi+C566EAE3wyTUoXe+z9FeOaPcX\n", + "1pH9oRYsWNDwnvnk98JyDk38ZvMbnaFapCoqKioqKioq5oh5s0iVUT5oOVl9GzROTpgjIyNNhtLM\n", + "w999onk5Cgttz5mMswrsfH9kZGSAnj5a0GZ431pdFrUFra6G3Red4kg/TvPWOHg2GpMjiJwXyJY8\n", + "5+cpsydbK+dvWxrdHpqZX3jrSBnG5HpQ9F9avujD0Zq0zTLhu7q5tUHTQoQMmtnSpUs7PIcua4jQ\n", + "6Nw9PBva0Ybolzw0oKw4zzhchR4gW/CDSCiirCy7tjyROd117krabYFifFndN+bfWYWd64l+bRW1\n", + "ZSqiu+6RmbImYt84+Z4jwiy7yIP3JPp1tGRE1xKBzGRRu8B7kqP2bJFjbU9MTKTr2eMlGstRe9AG\n", + "HxzF6bXIHPK9zTffvDeqNqKdN8bLXuT8Ywa0E5WH9d2Wh7LqAOPMLCX8bUs+smuew1fyDDIWIufI\n", + "cQWefvrphgbWHK/Osm2LNXxhzTqbPOvF/OT7Zc1Kr8mXv/zlEdHmWjLdtuQyl1kEOe29zvqi3pyr\n", + "y781XkPQzrMdSew5Yk5pV94YeT07vxj0wsvZ+nNXi1RFRUVFRUVFxRwxbxaplStXNtlP/+3f/i0i\n", + "2ppy1AwCnA4PPPDAiIg4/PDDm5o+//iP/zjQFu2HEyZaGqdZ5zBBs+JU63t7W8do99BDDzU5p6hX\n", + "hXYH6AtthRpKX/7ylyOia5HgtIx2hI8B4ye/CHj66acbTYI2BxxwQER0LSmcvMkwi7ZDTh9nwrZ1\n", + "ECsROW76qnmX1ecjujWyABoHn1MXzZYpgMZJ1vk3v/nNERFx1VVXRUTE5Zdf3rRFI4If5AXKoi2s\n", + "zZE3hTwotmC5Aj1z+uCDDzYZrAF8QVbRRMkXY9i3DE0U65frPpW5oWjDfJa1EMvxIUPQDS1kCwfI\n", + "z+te97qIaLOP/9M//VNEdLOPL1q0qKEfGcNyYF85ZMgZmVk/Xv/OQ4WcoHGXPiLOUcY4bJkArFH4\n", + "wFomQzeZ74Grw9N/X341+EEmfqoKUEPNFkZbS9gfyXXFK2C/oD/k65ZbbunUq7PVD58pxkH+NPcN\n", + "kBtk0PsF/IMPa9asaaoiOCM3e4krNjAOWzH4m/FTtw0af/rTnw60Zw9YvXp1Mz/sEc5/ZR8grMDI\n", + "qMfJ7wVzSS5BaCRTPthss82a/Y7Prrvuuojormf7xNo3zns6e5Et+exZpe8hvzXM/6te9aqIaGWM\n", + "KgOA/ZLxsgbhhy2e/q1y3kbnxovo+iUh/9n8s3Zpz5iy32hogW+Tk5NpPjF4hTWTv2utvYqKioqK\n", + "ioqK3zPmzSJ11113NVoAWuD+++8fEV0NhrpwnA4vv/zyplK8K2KjnVq7y3xebE2xJuaIorImE/Si\n", + "jdnahVaIpnDllVdGRKs5OuOvrSOMjVNyX007Z4Pl9J5lZOWZaHd9Pk/l347AQgsq747tP+E77L6K\n", + "6OWz0ZLQghyFgoZFP2iXl112WYcW13RyjUBrJMggvN1rr70iovVHsDUNjZvvMadPPfVUGj0DD9FM\n", + "ebXlDX5lz7RVrYxMw5rDOG3FcbQNMoVVzxXUsfageRMV+73vfW/g2WBkZKQZJz5O0GJDBPnNAAAg\n", + "AElEQVTZwkJDH2j1zPMwrRHtlr/tI9PXR9aWeUbz/vGPfxwRrUZtKzNgruxDVK5RrEDIBRYoeJv5\n", + "DtIHfLRVHbDGsSqwz+y0004dSwrjgA9XXHFFRLQWWO9z/M2aY276LNIR7b7ImO+7775mj7HPG33y\n", + "uaNU7fPiuqlYMqHBfOR34u67725kjfVgvyR4yv7GnsTatC8Ya5pnsN/Qvy2Bk5OTzV7Bs5gLr/+s\n", + "HqBpNZAXfieRTazxEd3s6ETb8htjC7YztTOHyLLniPH7ZqfPH5D59xry76fhaFbmwr+j9pNkXSxa\n", + "tKhjHfe5gHXDOOwLmqFapCoqKioqKioq5oh5s0hFtJYnayyc4AGnXSIlRkdHO/WZvva1r0VEexpF\n", + "e0FT4kRsaxfaHidVNFZHwwFOvyMjI53K0W7LSdjRA0RKGPbXYgzQ2FcnzbXCHHUGrO1yv9xnYYro\n", + "1hp07qM+i5f7sGUKOGIQTT3L+cSY8FdBAyWSrLR4ua6hIwitSaOJ8Op21rx439Gem266aWf8fBeZ\n", + "s+xZXhwpBl+wBmRzVFqw0OpsvWJ8WOhcB81WMOYZvy/4SHtrx08++WTzDLR1tF1r9dBGX2jxfeMp\n", + "aYdmZNjRYBFdXyhH4dg66hp0rufocTLv0MAr+0wp664H6txdli1HMdE3/LNPpX1noHlqaiq1pOCn\n", + "w7ORLctmNgdY6ky797qlS5d2rBygrAkY0c5BtrfwLNYe68bWJFCOHZ5jrfH8A/fJrYH3Lr7P747r\n", + "I5r20jLMbww1ZjMrEPNvC4yjOi0froNZzqHXOd/FQmernuubMgfsL5YP2sNv5Il2JR/oI/OR8s2L\n", + "nwH82wT8G8j3lixZ0lnP8BT59e+jfeoyVItURUVFRUVFRcUcUWvtVVRUVFRUVFQMQa21V1FRUVFR\n", + "UVHxO8a8+Ui9613v6txt24ufOnGu4zQ5Odm5/6TODjWCuNt0fS76pi6T61txf+u7bvLnUINqcnKy\n", + "uTd2Vmz6Pumkkwbed0QDljnGSd0f4IzpjJ/aTCeddFJzzwzdjkKgrWtnufYUr7Q/7rjjBtrbb4PX\n", + "j33sY01b31U7eoIaYdRa8ufAdcJcU4y5Ke/MoZu6XKYB2vib9tSIYo7o274Ubg8tpW8B9HziE58Y\n", + "aEuf+GEg99BC7Szam+fmK+0Z6/T0dIfucn76aMnyLMHzk08+eYAW+5ZBE3N63HHHdeq3OToz43nm\n", + "08C6oL6h/d08t+edd16njpvllnF7XTjbPnz0GjUfXV9ybGysmR/XTnPuKddxZP3bV8j+eK7l6P7L\n", + "vrNaePaVcR1H+nY9M+8vrm9W7pseJ3XZaMsezXccrQbtniP7s0Fbn3xltx+0hS/0aV8p70Uep/nI\n", + "KzULy3qLtmZ4L0JevB765DyiXf/2B/Q6+fjHP96pb9kntxHtfLpOJO28TqC9rPsZ0f4eIQMLFy5s\n", + "2rK30Iezpvv3Itu77FNL/6wj+i9rF/IM5tO19hx96300Q7VIVVRUVFRUVFTMEfNmkZqenu5oFun9\n", + "ozTy0grgaANr885tZA3FGVldqds0lf1bS7NlxXWKsvp32VgcpdCXR8aZlkGm/dg6Noz35ldfHSza\n", + "ZNqf33c9xKx+EzD/0KqyqMAStnqYFsuJtaOsb1s8yrpehvseBs+Vo1v62jlaNeO5I4GycZrnw2S3\n", + "pHOYPGQ0+nPD/OibG2vOWV3LjGbXi/S6svZvq3TJl8zimtHv2qOe0yyPmOVqbGys8x7Pcn1LRyGW\n", + "fZTPthXY/Tv79NTUVFo7Fdiq68oIpt17crZHl9bHbB903xnc3pF1w9Z2yYfMYlS27XtW9rnf9z5R\n", + "0u42XoOmxdawYX7NthayRzsbefl/r6XZ/v67H9OW5duanp5OeZo9Y5h8NO1m1aqioqKioqKioqKD\n", + "ebNIlT4ozllhjdSaV5nDxH5WzuvCyZjnuT15mOiT3DTklchomZiY6Giz1hhstTCyzMaZZtGneTE+\n", + "XhmfaXHdpsx6Zjg7eZ8Fy3TZQjdMYxjW3loxY7VVpfy/5y3LTcK4kJdsDgG5YMzHjRs3dnKrDNOG\n", + "M7lw31l+rZJvXkOZtmuNui8jdx+t1tz6LB5uY4tsBvvpZdaULDda+b41aFsvsr4z66jliDE65xs5\n", + "gcp9zbJjn43MOmKfKF4tT94vyhptzlHmcfEd2mVr1HwwnwC57ko/xmwt8jd77bD8Qa57Cu+hPbNI\n", + "lc/KrN5+f7bWdfsKZZap8nm2dpoW5zIE9DlsjjKfqj76hq1J+wpmOZsMW6a8tiO6+bPYe/lOtk/y\n", + "PnxyPjLTQE4r73l9fWfIrONGtUhVVFRUVFRUVMwR82aRKjX/zBIBbPEpo/Z8eucE6TvsPutFRFcL\n", + "QvufjY+E/UiyzNa2GmX+OvyNRmrN1JltSyvAsHFa05rt3be1pj7areUafp/x2D8ju6/2PbstNH13\n", + "4h5f5mdkC1um/QOezVyWGqnnx1F3w3zeMl8K+854jNPT053otGxeod+WqEyrs/+KfchKWjJLi2He\n", + "wjfXwXL7zGpQ0mJZ9Hczi4TXKLBGmq3dvooCmc9LJueOcoPnrmVp2u3Xaat7+R7WHFv5Mv/MzEpk\n", + "WlwJYP369b10lN/NLO5ZBn9bLjzHoLRgZxZ4w7KUWUHdzvvLMIt22WaYT6Wzx7uvzBLXZzVyFCKv\n", + "2bqwJTK7mfGz+R5z7+jX8v+2TPJdrJvAEcmONM6sxraiTUxMdHiaRdL6N2kY5u0gVTLW5uXMfNhn\n", + "lswOLxYqGOWwdooS2vRJ+5kYSVubQU0Lm3MWzg58YMgcRMvnZ2HJ2SYGX+wcm20Y2ULrw7AfPOCF\n", + "YPNvdlWYlWvoo9vfyX4QfHj1uH048uY9mwPpbK8ZfY0626vABQsWpH0CeG6nYW8gGU1ZAeqSNrfN\n", + "5NyHvWE/EFkKi74DvJ89THGgD4diu7i52yMvXrMlLZ4T7yVZiRi/P4x2H3qffvrpNAgHeL/InMef\n", + "bb7mklYfSt2Gqxn/WFtueJ/DGmty2H5RwkqK37eMzeSwXPaT7R9gcnIyVYAM3s9+e2br+Nx3IM0U\n", + "o2EH6eyK2+19uPU6LMfCPDoFz7CAIP+++HfVtPSlPsmUGx+gnu1Bql7tVVRUVFRUVFTMEbVETEVF\n", + "RUVFRUXFENQSMRUVFRUVFRUVv2PMm4/UCSeckDrocer75Cc/GRER73jHOwbaTUxMdO6mKZtQls0o\n", + "X7mrxaH1nHPOiYi2XAn3qSTotM8UqfMpV7BkyZLOvbtLPhx55JER0Tp48jkOv/gIfPrTn254EtF1\n", + "MuZO2Wn8TzzxxI4/he+2XU4gKw3icgWk/Df/oAWfkgsvvLBTTgD49E5a/ve///0DfZgW7r4pKXH0\n", + "0UcPvG952WSTTRoeepz20+BZtKdEAM82zxk3pTOQl5n8npBbl+Ww3x7jcIkg2jlJLLRTgoYSRGNj\n", + "Yw39TuNxwQUXRERb8sc+QP4b2Tr22GMH+mGuoI11Ah/f8573pL4gyD+0vP3tbx9oZ78K1gftKW9h\n", + "R3fKUMCniy66qDM/Gc+ZI2TLtEA7IdQu++S1XwZQMJ/HHHPMQF9Zws2sFAbPdhoJ1gXt7f/2+OOP\n", + "N+P1vkgb9kHWB3sRfbPPuT17EDyn/RFHHBERg3489k9EVujbco6MMW72LuY/K5nD+/D9rW99a0QM\n", + "7j/2CSzltqTVDvzAZXyQPQdIwB9oP+aYYzrJW/1bhJy7FJbLeTEe5pRyaF4/8JHv/cM//EOznp22\n", + "A7485znPGaCF9vYVtJ+Wy/LY964MnDn77LMjouW5y9TY74x9jr0LGfW+Alyai/6hpaQduin540Sz\n", + "LkdG3xmqRaqioqKioqKiYo6YN4tUCVsmhoXcTk9Pd6w2wNYhlx2whcIe/2gaWURRqfkPK4mRJRLN\n", + "QosdteAyDW4/Pj7e0bhdAgSgxfG+rVxZlNJsE5L1tc34khVMhib34xQFTrJaahpO0pdZgwB9WIvr\n", + "K/lRwknixsfHOzy0BYLP/SzTniVgnSmalXlnPE4R4XXA31nYP/3x6jnrQxbhmSV/taUWjTOTRctJ\n", + "n7+CLQqep2HpD8yfYWs6+37ZBzz0d7yevRc99thjEdFNLAhsZSstelmkrK1EWYJGv0/EMHLVl4ql\n", + "bDc1NRXLly/vHSfILBJe//DRVjQwUyQmvGH/s2zZosjnWQJX02RroWV9/fr1HQtTn4Wk7JN9INtP\n", + "/Tffw3o8U9RiFhGa7S3eD0GWwgQ+OEFr2d6Rg9nvm2ln3SMHWXRjFoG6cOHCNJ2J12+WHDRDtUhV\n", + "VFRUVFRUVMwR82qRsh8Sp0DnqnFStcnJyeY71rxt1eHuNysnQIkYl0zghJpp9uPj4813spwTzpdh\n", + "7SfTAuyfM1NJCU7nvLp8AkBDsEUhK52DNgktvPp7M9E57DQP36Dd99LAc2Jtoa9EDPC9u2lC20e7\n", + "eeihhwY+9xzBx76cYZn10qU/stwkjM/avpPnAeZoeno6zY8DbO2xb0dWWDezWMyUt4rPLIMgK76b\n", + "WY2h3SVH6Kcci9erLZLD4Nw0w/Kxsb/0WUdtebZ2bnmBdicazNrzTFtyR0dHO3xg3s3LzIqYJcnN\n", + "aPHf4+PjjXXK1gwnhbSFwbRAM3PB2OwjVz474hl+e6/1emYN0ZfHk82RrW22roINGzY08+M15TXo\n", + "OSPHYWaxcdkv7xMl3+2X5d/a2ZbtgkbvNzyLOff6KfluH2FoYO/NinlntHhvypJrjo6OdubHlnpk\n", + "qS//1UwYapF629veFitXroz999+/ee/hhx+O1772tbHXXnvF6173uqYuXUTEWWedFXvuuWesXr06\n", + "vv3tb8+KiIqKioqKioqKP0QMVdOOOOKIeNe73hVvectbmvfOPvvseO1rXxvvfe9745xzzomzzz47\n", + "zj777Lj++uvjS1/6Ulx//fVx1113xZ/+6Z/GzTff3Gt5mZiY6PhGgEzz6ivDYMuAyw+gnaAV2CLh\n", + "YrU+iXLvDMpMr77T9zh8j+6ovSwtf1auxJr66OhoMy5HMvmUvm7dugFas9IfwM+yT81MpTAynwXg\n", + "LNLAhaaBNS9rV6W82IcD7STzebK26AKpHgvyYItln1XIFoWyfEb5OeBZpj3zeyoz3TsC1tqrLbJ8\n", + "174NAD7YHw0LjK0M5fctv+7bvh22lrhvF/udyXdsmLU385GAt7MtoO21aT/Psi/6dqSk5wirhvci\n", + "a83ZWErLnn1h3Mb7o+fIVuCM94DnMdaFCxemWcKzig+sRfPFvmK2eHq/6LshgC7/XtiCb7/GzFKX\n", + "ZdM2Fi1a1LG0s29lFihHGALTwp5u9GUIt2UoiyAF0GYLU5at3nscv0N9Prjw3OWqsqhsQDvkJPOl\n", + "tJ9w6feU/c7ZKp7Nf4ahFqmDDz44VqxYMfDeV7/61Tj88MMjIuLwww+Pr3zlKxERcdlll8Vhhx0W\n", + "Y2Njscsuu8Qee+wRV1111awIqaioqKioqKj4Q8OcfKTuu+++xrdo5cqVcd9990VExN133x0vfelL\n", + "m3arVq2Ku+66q7eP6enp5vSX+TkBF+9ctGhRGk3mSABO1C4yCdBEHNWR1c8ra225rbUS50ey1pvV\n", + "t/N4s8iJkgeZNgt8EueO30U3s/aO+is/z+6ws9N8ZjXxnTbw/Tt/l9ovsLXPOXysHcM33t9ss80G\n", + "3s/40lestC+qMqJbUyzzS3EOlmHWkVLe0HKzyCdoySLF3J75pl9owSrgNbt+/frOWsnq8zkPEJ9n\n", + "kZVeV5n1qHzP/nqMf1j9Que/yaKcbF3qs764jqWtGX0+j+V47GNlebGfS2nRzLR6Wzuy6KQ+6/9M\n", + "tPh7pf+PeWw5H1ZrzXu5965sjFNTU50C8JZF+8TQLotStXwM8wddtmxZ57eE/cBrCCsO4/M6MWyh\n", + "x3+zz1LnHEzD8kPZmoqc2HIHXDDb+26fhRj6Mj9Ew+shs6baWlxaU/t8+frofbb4X0ftjYyMzOhU\n", + "XMvBVFRUVFRUVPz/FtOzwNq1a6f322+/5u+99957+p577pmenp6evvvuu6f33nvv6enp6emzzjpr\n", + "+qyzzmravf71r5++8sorO/1FRP1X/9V/9V/9V//Vf/XfH8y/DHOySB1yyCHx+c9/PiIiPv/5z8eb\n", + "3vSm5v0vfvGLMT4+HmvXro01a9bEi1/84rk8oqKioqKioqLi/zyGXggedthh8YMf/CAefPDB2HHH\n", + "HeP000+Pk08+OQ499NC4+OKLY5dddol//dd/jYiIfffdNw499NDYd999Y+HChfGpT30qvdr7u7/7\n", + "uyZtAveSW2+9dUS0d5zUw6G+Fd76k5OTHf8TaqFR84m+8Om47bbbIqK9E/2Xf/mXho6Ibk4ifGWI\n", + "0oIWai1FtNEk+ANAC3WZqPvF+Pic6AxoueSSSyKirSnoPDKOCqRO1Dvf+c6GVzvvvHNEtL49PIPa\n", + "SdCy/fbbR0TEDjvsEBERN9xwQ0S0fhmu44VfAnfjvr8/77zzmr4dXem8P9QUYz7djnt2XmkPz+07\n", + "xBgnJiYaHtKW8TD/zkVGLSzmn2g05vLuu++OiNZHgPmnZpn93rbbbrt48MEHIyLizDPPHOibunTI\n", + "wf333z8wDtfDQ654hqNBmf93v/vdTT/2M2C8lkV8G5lXeMjcUYOOWlv2MSFSCD5eeOGFEfFMzSpH\n", + "wGW10KDbkT2Mk36ob8ecOi8VNCE/5513XsNzxsf80zeyRd/UN3MNsi233HLgffYX1gXPxi+F/WXp\n", + "0qVNW9fxs38Zz2KO3DdjYC9jrlzfzH4eGzdu7NSrYz55Nq/ILH9TUww5tx8rvGZfRBbpv5QBr2v4\n", + "wvxvs802A30h915z1OaDVsbJHoYcsV9Q4/Dxxx9v5oe9g9+Qiy66aIDuLbbYIiLaNYmc8yzkhdps\n", + "9rWxbEL7scce2/hhOds3r5/73Ocioq0RyF7kqFdeoZ39gn74zbK/47nnntvw0PmxysjfiJaHzD98\n", + "YB2wP/Is17fj98ER2MuXL4+zzjorItpae661aL8tfosYJ3KBvDBO+IWsu35qOZfQx3yalswPlTWa\n", + "YehB6tJLL+19/7vf/W7v+6eeemqceuqpw7qtqKioqKioqPiDx7xmNt91110jotVibrzxxojoes5z\n", + "okQj22effRqtzZmo0W4feOCBiIi44447Bt7nRAo4BTuLbJYJnRPq7rvv3lgW1qxZExGt5gico2dY\n", + "Rla0IUeSYW1y9t3R0dFm/NCJ9SOzBMIXNAa0vCwjOM9+5JFHIqK/Hp61nGxcwDlH0G7QLKARoIEw\n", + "V8gN/L7zzjs742S+4Qd9OvdKWZ08orXY8D5yYTC3e+65Z/OeI6UYd5mBPKLVfk0LfW677bYD32fe\n", + "3b7MfbXddttFRDufzvYMsAJvtdVWERGx4447RkRrUQHOxs8cIbumZXp6ulmTw3Lx8Pcuu+wSEe0c\n", + "sY4yvtga6hxvEd0IT9YHPM9y80Dz7rvvHhHPWNcjugojsu39oS93keWecdgKBKxhM1dYR007+wT8\n", + "wNr82GOPddYEdN97770Dz0bWDOc0g59ZnVBHpJb5kzxPjirDEoWcO1KSdvTN9xm/97oy6pHUPVgk\n", + "HUXOPgENtqpncwStrAvky/vF1NRU0wdWQnjq/dxWP1v/LE+Mc9WqVRHRyg17dWltYk0hKzvttFNE\n", + "tFYyIu8B7dhjneMpy7LunHDO01cC+mhTRuWX8PwzFtcmBI7+LKPhPZ/wlD0IHsKPLGLSqLX2Kioq\n", + "KioqKirmiHmzSK1bt66xLHCaR/OyBstpF2vBqlWr4p577mn66WvL+7TDcsDJE/iu2O3te0K7O+64\n", + "o9Hq8aewLwunXzQnNNEspwl8OOCAAwa+jyZ+8803D7Sfnp5uTszQjWblcXIqR+t3rUJb6tACbB1z\n", + "Vtqyb8NZlA2sBWiJmdXAGhq0QmNplUTbQ0vBaoi2g8YB0EjWrl0bEa025zpYgLEiB8jZwoULO5o0\n", + "NOCHBj9cY8rjXL16dUS08s7cXn/99b3tH3jggUZrxYqRZf296aabIqJdazzDVgNoZL7pd6Ys27SF\n", + "h9DH+gBooNCArKKxm488k7mlX9fHimg1ZfuLZBY61iIaKOuHV1tHoRH/Hiwel19+eUR0LRgReRbs\n", + "vrZle6xHjBOfIOD8ZPB5+fLlnflBnpFXLBJYBW+55ZaB9vCY7zGnyInnFL5gZXn88ccbnmf1SukT\n", + "2GIPkOUXvvCFEdGuK68H0zIxMdGMF8tLdiPB/MNL+2MCfptYD8wRMpzlTItoedYntyVtzD+0s9cg\n", + "0wBZ59YFvtiKXI6DvZJn24cUIFvcSOy9994D32d9AFtbWReuMxnR8tB7tWkF8MX5uOjbPHe1D+Z+\n", + "cnKy8yza8rto65d5nqFapCoqKioqKioq5oh5s0gtW7as0dSBI2wAGgqn4LIYMlYMt/VJOotS4CS+\n", + "2267DXzPmVoBmscjjzzSWArwM7C1wzXSnIHYlhw0evjiukbW1JYuXdr4RVj7M92c3g888MCIaDUw\n", + "+OI7bzRRNAz45vv+iMFaRn3jy7KD04d9q6yRoFFAw5VXXjnwPD6HJxGtFuMMxOaL/W7QMNEGbdlD\n", + "U+WZ1157bUQ8o8FYS2e+rSFlNeUY9ze/+c2mz4h+nke0fN1mm20a7R66MisAVmDWUp+FsRy3x+Bo\n", + "yLJ/5gNZyqx69O31XEZAlnA2bawBzGlJi3nMZ173Br4gaNysQWukrEmsw/CF55XWV7Ry+xlhBTTP\n", + "+S6yh7VoWJZy1s0VV1wREc+MObNIY0lDzvHp8V5kiwz9OVu727MGRkdHG+uV93PPJ3ICXzILxa23\n", + "3hoR7Rwg6xktm2yySWMhY5263Bnj5naBvpHlrMIDfknMP+vE1pFNNtmkY/Xok9vyWTzb2cUzvyT2\n", + "OPvMlXxh3Ox3rkdneYEG5Nw1WW3Bguc8Gx891k9pCWT8zB/PhhbfSCFz8Iu+oNHtAWMs60VaFqHb\n", + "8+79YxiqRaqioqKioqKiYo6Y16g9TpacnF3PJ2u/bNmyNHrA1hHnqPDp1bW4fO+anXZXrFjR+U5W\n", + "GRuNy3WarGm6/hXgRN5X94/v2NplWlwxG03BWhBw/SbaZ3XfoKfsE2S5OeALp37nzwLmM9/rs6ZB\n", + "n6Op6NuyZflA03StNmANFE12amqq4wtmHyFr4uY5tGNldY1F919GRTFPWeSk14u1QPPcNSiB5ayE\n", + "86n1+UdEdP0zsAbb9wFAG++jXfdF1DAetHNHzpqHWE08n7TP9hfze6YadPDFNTS9/p3LznnYMgs2\n", + "7/OcxYsXd/r23oGVw7w1LbZMZXucrZHj4+Md+t3WdTGxHmWRUpklxygt2+xbWTSzfWJsWcraOx/X\n", + "TL54tihl0ayO7qa9o2EB/PLe5bxTJejDkePIEvC6cW67YXs6/dOupAVeeY1llld4zpy4dmVWJ5R9\n", + "qHy2ee7obvZe0zgM1SJVUVFRUVFRUTFHjExnJpff50NrIeOKioqKioqKPyBkx6VqkaqoqKioqKio\n", + "mCPmzUfquOOOa+7Qs2yj1CyjNlt5f+2og7PPPjsi2po/gHbOnkqtPer4cD/LnbozO7vW3sKFCzt3\n", + "tvRBTaGTTz45Irp5b7h3hXZqkNEe4AvCXThjoO7P8ccf3/TljM6uhUb9KVsDfWcOLfCczxkjvjO8\n", + "nn/++U1beEVbR2FQC4k58l03NLsenvunPTRMTU11aqHRN6/OYA4PPf/2kYCvZ5xxRkREnHLKKb20\n", + "PPnkk804Xa/MecNcQxHZok4ctDjqjfdpT52o0dHRjp8hfzOf1JTjc9dBA9Taom/XtATIEevuuOOO\n", + "a8aJLCGvrEHq+L3vfe8beLb97nil1pbrmzkaFD6ed955TX27zPeLOfjsZz87ME5rmo7yo6Yc8uV8\n", + "Q4xx4cKFnZqSHle2/l3fjr7tf1Wu/7I9+8VTTz3V4eEHPvCBgT6ggXFCP+Nkv3BknH0qGSv188r6\n", + "kI6E8hp1xCNgvPCF+Ue+TINrs7KmFyxY0FkX8Mo1JR0h5/XNXsT6B4768u9R+TsH7EcFz4866qje\n", + "vgH9wEdk12seIOsf+chHmvWf9c28ffjDH46IZ2rsluNxtCbtv/CFL0RE97fLud82btw4UH+wbOOc\n", + "dbxSPxXZBfYVY/4/+MEPRkQri2WdP8bCvFJrD1n0GcRzBO0ZqkWqoqKioqKiomKOmDeL1MjISHOS\n", + "tDXAsFa5cOHCjoXBbTmlO/+NT+2OkOAUm0WngMnJyU5kgr/jCLFh0QmuNQQ/stwt5bPNI7d1zhme\n", + "4ShH4MhC194qx2ZtzJFzRmYNyebI/VjT7cvibb5YcwSWQbTeLEeJI2vK5/k9W8NcA8pwtM0wPpbP\n", + "tnUmowXAhyzrvK2JzoXVRzvPpu8sLxifI0NZLjPTYhnvi361xmyeZ5GPbm/raEZL1i6iKyu2pDki\n", + "KIv69LhNe19UWJZlP4ugy3hP+2F5hEBpLcoigh0hx9rMaPQcOqLKvC/3NEenmeeOzvbcZFnpHXmb\n", + "Zfyfnp7uyBjIqg9klv2sHZ/7ZqTc68xDr+dMFrN59liyfcc0lnTxW0IOvGx/RDazyhZ9NWgjulF+\n", + "o6OjaV1G0z8sR5VRLVIVFRUVFRUVFXPEvFqkfHLONFhOrpwwly1b1qkEDnznzymW/BDWGFzNnKzJ\n", + "2f19+Ty0HZ7lvunDGpg1B0B+FF7xT8hqM0Xk2l52qrcWl2mi9hHxHXLZf6ZBZvPJnNhamFmqrBVk\n", + "NEd0eWStznyx3w3wXAHnsCppy7QX+2fYZw5k/LLGCUrN3HLcVwuv7CPTxE2z12aW02zJkiWppcV8\n", + "seUq8wUBmeWBsZTt7QPmHDSmzTnebEXK+OhalVgyy/b4etjS6nxCwHm0rBV7/tmbGAOa+lNPPdWh\n", + "m3xZmc9blqnaczWML6WlLsvdZSs3dNuvBtjKyDPYP8zH0rKVyQ5g3hifb0eyNeqxZTcZ4+PjnbXn\n", + "cQFkCQsLfMjySDGHWe68sr1/JzMrL7CV2HOY3ez4b8ZU8gXeMU5eybeXVXCgL0CBubIAACAASURB\n", + "VCqIUHXDvxfAOcSefPLJzu9a5kOb/UZnmNeEnN4wfPgxYMLExES6oTNwmE0JFR+w3Cdg84OxWWHR\n", + "9evXN4euviu3iG4SSG+o3sy82dG/k6OBRYsWNX17czYPnWDOJlcvUpuuae+ki+V3s2uULKmd/3bi\n", + "QuDNOzuYlf/3BgqfssAGX/05UScgMR39Y5bebLPNUqdZH7SzqywnJuUgjVxkB7Xp6emGDvr0ZuSN\n", + "E7lnk7a8WE7849dHi8eZHUbdlw+a2UHSV0UOlCi/67IS7guw3imV4mCDviS4Ea2c0H/fdYrHO5Pc\n", + "RnQPafCzdOAu4cAPSstMT0+nV7tek5lMWUl08sRs3y33DQd8mO7MJSBL9ujDTnYt1SfT2T5nGp1w\n", + "N3Nspp1dB7xflA7OjCtbFw7WsKxlV9tOBkr/ZTJdX8n64GBZtIIBmLvMFYRDEX+zPkpa6JNybMi1\n", + "A8IAxc3ZsyzDppF+eC2v/rIk2F572fkiQ73aq6ioqKioqKiYI/5POJtbK/JJ3e02btyYmtycun9Y\n", + "qQTg0g++IjDGxsY6ZVfct7U5axrWpCiYigUCYPJ0/wsWLGjMlra8ZOPLeJtZgXw1lmmZ5Xey1P3A\n", + "zrEO3x2mkfoKrGxvGoYlf3X5FZvuLZv87SLRo6Oj6fVIVrQ6uzawdpRpXmVJIWvQmandGpdDyoGd\n", + "0X2V2XdFbitGFiSRWUsyc7odQo2yfXb9ZxM+sPyjibvgKbC8OFijtBplVy2ZNcjWDxdBz0on9TlQ\n", + "2/JqixHavcv5mHYXge67Ti1pKANkHFQAvP7t0G459xUnV4G29JuW8sobOc9KhPlqN7PUQWNZCLcc\n", + "S5811YE9ICttYovusCAVMNP1mwMeTG9mqfFeNSxgyjT20Y5ce76zK2wsSsgsn2c3GL6Opt9Fixal\n", + "bgbmS/Z7maFapCoqKioqKioq5ohaIqaioqKioqKiYghqiZiKioqKioqKit8x5s1HivIJEe29NHfe\n", + "3EtSfoDSCbyPX1BExP333x8RbZp90sNzn8p9LHeh3PWTwj8rncIz8JUgRTztJyYmmvtUl/KgremG\n", + "Fu78eaX8gMssGNwFUzrhPe95T3OvzniJ9MMPAb5QfsS+PY6AoXQCZRaYE/hGO+61zzrrrIZu4Pv4\n", + "slRBRFsihM/vuuuugTHQ/p//+Z8H+ALNzA3fW7BgQSMrLhHEHMF76Eb+KClCqCxwJOlnPvOZiIg4\n", + "7bTTIqIb/bZx48amb+afchL4vBFVZX8T5ujtb3/7AM32qaM95Q3gy5NPPtnwzD6CWbkiotWYX+SI\n", + "vinjsHLlyoiI2HbbbSMi4r777ouINvSYcjinnHJK0yeRjdAEb5FzxrnddtsNjNcRtS77BP+QWVKa\n", + "EBl0+umnxxFHHDEwTkeb4V/DHFF+xMld2VfwmSzHWdJq36Knn366WUNHHnlkRLRy7jB2ZPL0008f\n", + "GCc0Oz2E55/+7Xu1ZMmSpi08L8umRLTRzIyT8TBOaEH22FecFJF1x75YRlTZb499C7lF9rxPuNTS\n", + "3//930cJ5Al5cAki9rqFCxd2EqYyn8gWexHj45W58b7IOmIPgs+sC6I/KW9y4okndsp3sTbpm/JT\n", + "rDlgnynauxSOfzfpn+eec845zXyy5nbccceIiLj22msjIuK2226LiIhLL700ItryM/SF/65/P9i7\n", + "XDrngQceiIhBP0HKlUGL5RtfKPpm/pGt0tep5I9LBMFH5oi9esOGDR3ZYv2zRzu6G5mkLE+GapGq\n", + "qKioqKioqJgj5s0itW7duuYUiIZOdFoWzcBpeptttok1a9b09uucRFlBVOCcPXyPk6nvRNEKHnvs\n", + "seYz6M+iTbbaaquIaE+3aOymhffpD82Lk7qjX9avX9/0OSz/iaOvnPvJgG/33nvvQDssE8xFRDcn\n", + "if82X7KU/mjJ/hw+OKKiL/oJLRUNCp7R9y677NLbt/MAZdFJ5GuiXzTziG6OKmhxKZSsXA3v8z0+\n", + "R34MZPbhhx+OW265JSIidthhh4hoNU6ABQnZcsK8LGJs1113jYhn1lxEV/MG09PTzXq2NdiWJnh9\n", + "xx13RESrUUKz5YW5wOIFDfCnnFNH8mSRfqDUVstX9pwy/01Eu86Yd2hzpG1JryPksPJllmcnqmRu\n", + "2B8A7zuScHp6Os2XxLqlb3L09CX7Ld93BOqwfWNsbKyTiw6YH8yZE22aBvjGvMPzvmhmxsz8Ma9Z\n", + "KRR/nq1/sNNOO0VEO8fsC+7/iSee6JSRgYe+yfC+UEblRnRlGUss68jroZSBrbfeOiIiDjrooIE+\n", + "s1xcnjPnp7PsMqdOQu0yahEtz1y+x3nlAHODhYnP6SfL9YZ1sYwk9XzSFgsatKxatap3nBmqRaqi\n", + "oqKioqKiYo6YN4tUmRmcUyCnXWfw5US5YsWKiHjmZJnleXA+GPq29Qug1VvzBD6RoomvX7++sRRk\n", + "JT9cANe5fKw1Qgsnb5dAsAaz+eabN+OxZcraS2aByIrXctr3qd95U8r3XCIkO80zDqxEAM3z1ltv\n", + "HXjfuZ1crqK0BNm3ie+gMTEeo8wKHdHNWA3s54JcLV++PM0mj/aPVQfrEFYzwHpwpm/GaxnFQvHY\n", + "Y4+l1gmApSrLk2TrGGuNdjfffHNEtJqbLRj33Xdf8x6WZeTYFkZkE2sIMgzPSx/I8llo/ba+lhYs\n", + "+8Ix31n5HWv7nl+vUVuJXAGhXHfInC2M0Oi9yFaQrJQScK43MD093ZlPLChY/e68886IaPlUWlYj\n", + "utnj2ZucdR24nMno6GjHugcYP33ax8cWSdYN7W+//faIyLNvsyZHR0ebcfUVz41o93PGhdwzN7bU\n", + "7L///hHR8hFavP5KWjILm2kp/S3L8bkMjceJfDHWvuoWe+yxx8B70M13LUPe983rrJA8a9g55Up5\n", + "cX456EUu+ip4RLQ+kYzbmdwBc9dXLNptGT9t2bvMy2GoFqmKioqKioqKijli3ixSm2++eXOqtQ+M\n", + "T6ScXO+5556IeOb0y4nZp3ROqS4YygnZ969Zvacsc2tZUNg1nbJTemb18WmXk7a13Cyz85NPPtmp\n", + "sZYVI0abc/2mbLy0QwvglM9rSYstUs4Sm/lTMFeOgPP8ozXAPxfCLLUpPsOfwlEm5iHjwRrkiDrz\n", + "0bX2wMTERMfy4uzBaL/24wO2xKCh8X0/k7GsXLmyE21ii4ELhKLloS27Jh3rBKsRcwCf+jKI4z/H\n", + "uKDbfUMjssU6cr0uj5N+Xe+xHGtWzLxPViK6ma1Ni+HIQct6KS+ev6z4LmActuRl1QccWQTt9qWK\n", + "aP3KHKWX7XPsn2jm9nfymsZqVEbiZfsioK1rlnqfxAqKFQX+IVee09Iq4kz+XkPIPzz3nmXaoRU+\n", + "8sre7d+XpUuXduYdntMX6MuOX9Ls3wv7Flp2S0sYvCM6j9+NzP+Kv22ZyQpFuyh4Vuw8ol0XtHFl\n", + "C8+nrb+2uGVzCkoaskzl3I7gS5ZVH8lQLVIVFRUVFRUVFXPEvFmkFi5c2Jz+0ExcSRtgqShfs9pZ\n", + "1s6yGkvAGizt0chMC/1PTU11NKjMquPq1lmtNecA8im/D9ak4ZH79p23eW1NCiuhtWqsAaXm7Qra\n", + "rq+U8d615exnAXhmWWux7L+UAUfOoVExB+4bTRJ/N/iQ+bE5n1bpF2YriC2W2bwD+1nYQpv58S1Z\n", + "sqSTO8ZabZ8lcSaasEQBLDH2JQKbb755JwISfpiHtMs0T1uwGBNaIzRgRSjH6lxk9o0yLdDqWmuZ\n", + "7LoGXaaZR3S1eVvSMp86+69lkWPQauvi2NhYar10tGkWnQyttPP+MMy6/sQTTzQyYkua8+jZmm5r\n", + "qi30nktbILC+r1+/vmPt8LrwPEOD5Qg4Gti3CObjihUrmra+/TAtyLNpyfz7HBnniOxyTrBI2hKZ\n", + "0W3fW9f/NC2Zb2FfhLp5zt+Z1djzbB9C72n4uTl6/Omnn+6sC37fsI6bFu8XGapFqqKioqKioqJi\n", + "jqi19ioqKioqKioqhqDW2quoqKioqKio+B1j3nykqBMU0b0Ldt0vavOUfgnOtUMtHOo4+T6au17u\n", + "RM8888yIaOs40d7+OrR3LbfyXtY5rajjwxiz3DVY5qjjRG0+A9q4t4Yvp5xySkOnfXug+5xzzhmg\n", + "2+0A9/PUZjv++OMHaHQuE94///zzm7pMwBlq+ZtaSPDcNaR8p02dMNrbkln6P9C3a+3Zl45xw3P6\n", + "tl+Gc/QgX65BVkZBmofvfe97B+i07wO+QLSHFmi0Txh8gRbqfm3cuLFztw+QW/PctOBnQT1E5tQ+\n", + "AvapQRZPPPHEjq+Cc8vQN7IF7OvmWpvmuf3TeD3//PPjne9850AfribAd6n7ZVoAcwBfqBMHH00r\n", + "NCxevLgZJzXf7E/kyFp4yH7hNca48Vc699xzB2i3f1tZB5S9iPpjjqRjnOwtrkFonxrXO/3whz88\n", + "QHsp6/Y/y/Y5y5jrRNLe+wp8ct2/vpqlzJd5zjiz6G36pjYfPLfvlGsvwsfjjz++E9npvYj1zJpz\n", + "DjzAOmL+qRdqH7E++YInjozz3mR5Ye7wmcPXttz/S76wP9g3bcWKFc1vEbQwPkcO8sysjh+fe8+m\n", + "f+onOi/Zhg0bmveob1nuoSUfHCnL+s9QLVIVFRUVFRUVFXPEvFmkyrvGYW5afbmPskg2W5acRdXW\n", + "oez9LLKqjH5x/b7MYmJa+3JrlH1nmcJN0/j4eJolN8uXkfVlWIuaCTzLURgZLbaKmCY/01qTNdNs\n", + "rH3I5MZZ511pHNgSxZxNTEx05sCalvni9o5i9DOyqNDy/1nOGfeRVQYw3K/5U/afjdPIMnTbGmBk\n", + "kXIlHNnFd5yZH6Bhm+dZHiFbwvl8WG22vr6ycWTjzyLxzPeZ1vZs54h2ttRk0dLOGzQ9Pd3Zg903\n", + "sPXQ69/r3bJolBFplvc+uTXdZftszfZlze7D5ORkh2fD1rOt4VkEsb8/LMqvD8OqT/BMbok8zwBL\n", + "lH+P+vie/T5kayiLYsz2uqwW6+TkZGodzn6jZ4tqkaqoqKioqKiomCPmzSI1OjraOaFnlhpXlC5P\n", + "4lmOEvfVl1ujfN+5Puyn4P4nJiY6Wonz32TZgxmHNQxnenWuD2fCnpycTKt0G9lJPMts7my8mYZe\n", + "wppUVgvMp31r0ln1b1tR7P9WjtNWrswS54rrINPc3V9Wq67sI7OOZtpuaeUqn+ncTaVm72cZ1iQz\n", + "yyzIMh5nlqypqamORTWzXtknKtMKM9pmso45B5vnN5tP84/veX/xvLPenMun/P9s8wJ5/LYGef5p\n", + "bx+Zvr5dg5PPnf/Hz56NNbTve+Pj46mFOpMtr2vg9U+OJ1c6AH259DKeZxapbL9zriOvZdMyMTGR\n", + "Wof9/jBrybBciDPlesosbn17aDkO5IPfNlvNTUN2C1PSzjidPzKzjtkSPeyWyb/55R6Q3XZkmd1r\n", + "HqmKioqKioqKit8z5s0iNTY21rFEZNq0rSYjIyOdDOaAkzQnYrLcOhuq4dMu/WSZi9evX9/RRoZp\n", + "GPbXsPbiLLIek8c6MjLSeeawU701j8wXIPOl6dOKMhqyO3prRbZguD9rgb63LzME+9m2NJj+rDZd\n", + "JouZH8/SpUs7/lTW+tyn22djyPzVyjka5vuW1UPMLJLmubOtW45GRkbSepWZtdNRTJlmav810GfB\n", + "srbqTMue/7JSQdkODZzoV4CsOarHfpwlLZlvT1+0Xd+4svWE7OLnVdLUNz/lK+NgXoetf8M00l9p\n", + "yXFGd7ellqD3f69Frx9oZo7cf7nXW8695jxH9gnMLBX0C5+zuoILFizoyFZmqbMlhf0tqxDA31mG\n", + "71JeTDey4z5AFlGXWXCyfbSvogDzxVzQhnFadgF89M2N+ZLRWvo1u89hvnTDUC1SFRUVFRUVFRVz\n", + "xLxZpJYsWdI5UWZe+5x2S98in6iB/ZT8eXaf6oiRrL5ZWU/MGqa1HWihb0cODau153w55suiRYua\n", + "0/2wunb2HXEuliw6DQyrtTQTMh+ZzJLnvx1B4vp/5RybR3yW1XECzCtaUebHZAtHKZuWlcwq4L4A\n", + "1lP7hMw0/7S3xTWzXjgCiL+t1QP6Y2yZH9PY2FhnPdtqAzJfr2H17cBMUWnWsD1f2fqn1hZzkM2/\n", + "ZdG+NOVYrXHzWVZDj/0Crd71/1ybjRxHtopNT0+ntfPsb8errePec0FmwaA9/JuamurUFjXdmYXG\n", + "8mGZppZaZk1jLkva7Rtmui1TWaRcdsuQ3XQsWrSo06bPn7KEaxRm+yTjd3411mFJk9cBz8huMPx7\n", + "aBrMR+bUlrw+PzZkxH3h2zYsOhFkVkDvnyVNmW9otp6rj1RFRUVFRUVFxe8ZtdZeRUVFRUVFRcUQ\n", + "1Fp7FRUVFRUVFRW/Y8ybj9Sxxx7b1Gt65JFHImLwfj2irbXm+llLly7tRJFRC+n9739/RLSRLNzd\n", + "PvjggxER8eijj0ZExKWXXhoREcccc0xEtHe43K/yN/fN1Ik66qijmn7xAYBefHeohUTtpCw3lWsK\n", + "UoPIfj1Et0ATNYhOOOGETvQi333ggQcG6Kam1Lp16yKi67dV1iuj74iIbbfdduBzapbhr/GBD3wg\n", + "reNmHwZqIcFz+3wwR1tuueUAX5h/R2sgPxFtbavTTjttgA9r1qwZ4B1+KIzzLW95S0S0PlKOUuOu\n", + "n/49p/izbLPNNg1djBO+QAsyyRysXLkyIto6TkcfffQAjfATPuFDQG0u6pstWrSoWUPQiyxSO8tz\n", + "xPjuv//+AV4yzg984AO9NMMf1iq0n3DCCc179Mla4n3opgYhNDDvzpdEe+p+QSM8hzZ8Zs4555x4\n", + "xzveERGtzLF2dtxxxwH6qbVJ3/Cc9vYhcd1P+IjvEf0+/PDDzfqkFhrjevzxxwfGzfseJ7LK/mJf\n", + "qQsuuCAi2lp+0I78LVmypOER88kaYr1vv/32A7x86KGHBsaJbDFOeM0zGPdnP/vZiGhll3U0MjLS\n", + "ieSiBiH7nGUV4PtyxhlnRES7d1k+4At8Zd+F9rGxsWa/QkbgqWttMi5klvW0zTbbDLR3TTn/hjFm\n", + "+Hj66ac3MnTXXXcNPIvv8jvnOqHwbeutt46Idv0zziOOOGLgmXffffcAzfz2fexjH2vGiXw7cpL5\n", + "RBapV8f8u/4fc2T5Yq9jTuDT4sWL4+KLL46Ids/1vPs3lz2a3wvnn2IMyBHrDnlhbGWtWtdaZI2y\n", + "fpnHbI4yVItURUVFRUVFRcUcMW8WqUWLFsUdd9wREe1J/eCDD46IbpQPmkiZfXz16tUREXH11VcP\n", + "tOUkjCWFU+xvf/vbiOhGp6DVEOmBxsLpn9M94JS/ZMmS5sTLez5hOz/G3nvvHRHPaK0lTR4nWh20\n", + "3nzzzRHRH1mFtsOpe+3atRHRWgE8TjQzW7kcGQHfbrvttoiI+M53vhMREfvvv39EROy7776dtvRF\n", + "35zu4Q9w/hv6vP322yOitVAAvg+/9ttvv4ho+fHDH/4wDDTsK664IiJa7RaLJGDO0FSuv/76iIh4\n", + "wxveEBGtZQ8gm/fdd19ERBxwwAER8YzcIHuAv7EYMCfIrCNIaMdcYgV64QtfGBHtXIAy4++VV14Z\n", + "ERHPf/7zIyJihx12GGjr7Pi77757RLTa/b333jvQHlqZk5e+9KUDtH31q1/t0OIcMsxvaTmMaDVJ\n", + "xsMz/uqv/ioi2jkAjjj88pe/HBHR7AF77rln09bRha7ThrWzpDuilZeDDjooItq5MC3A0T533nln\n", + "RAyuO56N3LIPvOhFL4qIrmwxN5ZJ9iTz0VZ05mbHHXfsyDn00je0XXXVVRHRXaOu1oAsY+FZtWrV\n", + "QHv4yHOXL1/e7J3sA4C9ZquttoqIlvfORG3anZ3/lltuiYh2vwTI17p16zpRauxNpgWrz29+85uB\n", + "z9kvAXzi92G33XaLiIivf/3rA++DxYsXN3RD76te9aqIiM5+4ezjrB/G4HFCC/sEv6PIcCkvtrA/\n", + "73nPi4iI6667LiKi2T8A42DdMEesceYOwHNe4SdWsr48UuylzEkWte/cV9C01157DTwDMEb6h29P\n", + "Pvlkw1PA/LPGbrrppoho5d7zn2HeDlKLFy9uFtib3/zmiGg3lhtvvHGgLYxlsx8bG+uE0AKEioPR\n", + "j370o+Z5ERH77LPPQHsY61BThJKNAyBIm222WdMXE+lFZDMx48uKrzrkFtoQNG+kk5OTzbjuueee\n", + "iGgnnh8ZQB8sKK6V2DjcN8+G53/2Z38WEe0BtTwE2tzLouM1+1H3hvEnf/InEdEK9Te+8Y2IaBcO\n", + "Gw/8fOUrXxkRg/ICz9nQX/ziF0dE+wP37W9/e4AWFj5zwwER+YKvgIXnA+lDDz3UKW3j6x/mJCtL\n", + "g2yVP0YRLc+5MnP/Tz31VDNOXn0YhdfMJz9y0OZrVuYIXl9zzTUR0fKnr/gvmw/rwpsWYH65duUw\n", + "utNOO0VExA9+8IPe73HgesUrXhEREYcccsjA+32AZyhtXv++or3hhhsior0KRJ4AfGSOkBtflUe0\n", + "ssGh+41vfGNEtHLswyv7hw8vzKV/YJxEkv4eeeSRhpfAyQzZ35DjTHnlR8ipW/yjTv8oicuWLYtf\n", + "//rXEdEtYWNakDG7VQArfezJjNeHQNrffffdzRUm+2RWbJm+OSDC86y8DUAZQBlk/N/61rci4hm5\n", + "Qs6RU9YzP9qA+YfWP/qjP4qIiG9+85sDNAH/9v3t3/5tRLT7cblHs79DLwrmS17ykoho5fjHP/5x\n", + "RHT3IOSBdp4jlxJCYaF9aWRwyo1sPwR2FcFYwPhs7HDhZA51Dz/8cGc+WWPQxxUlMsa+MQz1aq+i\n", + "oqKioqKiYo6YN4vU1NRUc2pFu7n22msjomvyRBPj5HnLLbc02i6mVcApHc2A72INyEqEcKLmtMwp\n", + "NksONjEx0WjzaEY+7dokjeWE6xdbgaCB8XNdgLXAWuPY2FhDD9+hT2uBLseBZoU2aA0TPuyyyy4R\n", + "EXHggQdGRMT3vve9zljtZO5EpE6SCt+wEqFxYQXYY489emnne7/61a8iomvhiWi1MTRtLG9oYFgs\n", + "TTvjRbOkH1tH4R9jQnMbHx/vmIHpE00S8z/jzJL4YU2FNqwkto6WFqnnPve5EdFeRXGNAJgLxvWT\n", + "n/wkIloN3NfS8HzXXXeNiNYitfPOO0dEyyc07+np6WZNwjM7ywJkB2sBMsYVtmXXcoUsMtaf//zn\n", + "TVsnb3Tyv4zn8AerAFcXvn6zwzM0cVVaXmPxTKxDtP3lL3858Ezg4Az4g1XA+wv7gp2vH3744c41\n", + "qx314TH7Z5Y0l33FlhzPEWPhOVtttVVDly2pvmZiX8ey730RWtijoAnromWX/pctW9aMlz3aLgz8\n", + "7Xlmn3ByUP5Grr773e9GRMSrX/3qiOheBY2NjTXvYc3NChzbeZr2WGBswSxvRyLaPZ09ukyey3pm\n", + "LWJ5wjrGngMcCMCc0I9dR2jPLQR7ARaw0hLs0mDw1IlFgRN3QgvWIluksgSoExMTnd+5bF/Emsq6\n", + "HoZqkaqoqKioqKiomCPmzSI1MTHRaGhoz3ayBNx58/luu+3W+K5klhdOrzikAd/Dor34Dt2Ov+5/\n", + "48aNjYXAFgTACXu77bYbGAfWsqxcCVqxQ/btQDo1NdUJBXUYPHApHDQHTvf2kXHRSiw6vI/D7CWX\n", + "XNIpv4DlCJ5mafnRarAw0De0mR9Yl+ysXPLdtNi/Akf1yy67bGB80Ir1B63XzsnwD7njddmyZc28\n", + "AuhEo2KukJssuRsy6SLW1o4Z45IlSxrrJXRjMcLPzP5a/O0AAUA/aLBY//BL8LpYsWJFszaQQeTW\n", + "ZWXs4IsPCTLKegFo3vARixf94lz7rW99q1PgFvnG8mI/RpfT4BXriB2lXTrC6UbK/plHtGB8pbB2\n", + "ZeWrTKOdkIHLO8HvBQsWdHx5GIcderOyJcwRew408X1bcFwGZ926dQ1dthiYfuQaa2dWQJd1wziR\n", + "Xe8X8AlrS0Qr9+YLz0beWc8uc2SaeTY+Rsibf4/Gx8eb+aYNltTMLxFrzhe/+MWIaHlvvjj1za23\n", + "3hoR7boqbwLgHesB/1Lf/gD45f2T3zpbPF1Kxj675U0A47ScI6Pec225Q06Qq8yaDr8yv67yPXiI\n", + "lYtzg/17M1SLVEVFRUVFRUXFHFFLxFRUVFRUVFRUDEEtEVNRUVFRUVFR8TvGvPlIvfvd7+5Eb3Av\n", + "z9+UQiC3A1iyZEknOuess86KiDblO/ev9q/ge6STJ80+7bif5W6cO1Snwl+8eHEnGSb0U06AUgX4\n", + "xjgXi9PsUzrD9/TOF1OWiPDdNH1CP6nwKW1gvtn/hlI7lAigX57DXTv8vfDCC5uyKdBnXzHGTYkI\n", + "SmHgO8Kznf+D9vCxLIHh51BOgPk3r/ku/geUQqDMBu38yrOQL8Zq+ShzvFx00UUDdAPGaV8HeE57\n", + "eM74aA9fXMYnohsJxXgZJ23pA7qdeI91QRkP88G+NJROOPbYYzvRY/Yvoe273vWugT4tizyD8jaU\n", + "fAD4lkAz6+XjH/94I+eOrnOkELJF315j8IVnwUdo99yUfzM/Lm3Sl1g4oi2zwvp3KRn6Zg2yXyC7\n", + "9rUq+c5eBN2sMfcNmP9Mzvk+46ZcCfJVykfWN+OED54bl+WhvAm04LeDvDD+z33ucxHR7tEbN27s\n", + "yArf+cxnPjNAi8dJe2jzOL2/eM8uy5vBK8sivEK2oBtaXL7L+//JJ58cfWCOGOsnP/nJZj6hxfsF\n", + "YJ9j/TuiDt7zN3yEFvgGH6B9amqq4QmJd112irb4dpF495RTThmg3T6DPIukyy7NVc4R32VvKX/P\n", + "I1rfMOeXY01nqBapioqKioqKioo5Yt4sUmNjY82J0jlc7EPFqbk8kdpyADgx+1TuMhOAUyunYJ4N\n", + "bY5OoJ8FCxY0p3o0K9Pi0znfZbyOIKEfZ/625gUWLVrUjAdafLov25bjp0+PD1jTtoZWjtUagu+R\n", + "s9wtHhd/u0SErQU8r48W/u8SISDLl2ONyyVV/H0Xc92wYUNvCZ+SFr5rEskLHQAAIABJREFUixNA\n", + "C8p477xDtNu4cWPTFhmynAOXRKBv89xz6bly/6Ojo01fjI/veA5smbOGbjm3VcFz3Ac+s6x4/om0\n", + "ZO9xln6vUfPDEbblHNm64XnP1omjsXjf46Vfr82NGzd2eIhsOidPxkN/7vItnlNbqqanp5vxmYem\n", + "oSxsW/ZheB2ZXzONw30A+vItAfPbJ+fl93yb0reOvI4z3iP//u1xOSLgOfCeVLb37Yn5Yh66tJLh\n", + "cZaWp/L7tqaXNPDaR28ffF4wP00br+U+k2VP9zzSzha7DNUiVVFRUVFRUVExR8yrRQpYG7Cm7pP3\n", + "2NhY2jbTJMgOnBXnJacRp2IsE87dU2ZKdtFQ1+VijLTDJ8inXpDlrPKdOVi0aFHHf4I2fdarsi8X\n", + "dpxJq4voamIlX3x3PQzQ5jvu7N7eVgWPqczHwjicNwvtLrN22LfIzwLWuPje0qVLOxncnasHHtqS\n", + "aThvTMbXcqy2dmU5p2zVQzadY8UaZZbzqBxrlrHY82n/EvM0G6+1YNqX7zOf9GEabO1ALmjvcWUR\n", + "xvaLpN/SKgldpRV7JtgfxRYpWweclbnUojNrheeTds5UbZrI1eP8acAWuZGRkdTC6Hm2Zcl7ka0F\n", + "8Jj1Y9qZw6VLl3Z8dbIbCX/XvoFu77xZyJ1pWbBgQSefXmYtz6yg2Y0EyCz8JR9tMfPeYp4zHvPP\n", + "1h4An2w1ol1Zd9N+yyCzvJnmYfunKwEgL3351bz/2ye4WqQqKioqKioqKn7PmNfM5o5KyzQYZ5+e\n", + "mppK6/Jk9Xs4lVqTsoXGvjJG6VMEXbyX3Sf7WZkvkceQWQPAhg0bUr8LW1QYN+PkNE/f9pXKsuny\n", + "PGelLZFleAfWMKHFUVjAlh1bsErrC3T5Hp3xeZymxfJjzQu5sEV0yZIlaaZ6Rw7alwHwLFsL+J4z\n", + "IcOnkZGRob4gmdbqWpOAtWj5ymRx/fr1DU9ma1EzsvaeU/jkKLiIlleZb1RW385rDl7bImE/Fvdb\n", + "WpWhi2c4ciyzSHuN8jrM97CUG4/TfoY8w5Z40wLtyD2RVl5H8K30OcysfMi9rcTZ3mK/nsz3DpQW\n", + "T8utLbWZz5AtlW5vq5grRoCJiYnOvmU/POBbA/svmnZHOQNb48u+MkuU59OyaHk374nmtnW5b0+3\n", + "VY9nETHvPRd5gVZH1nqO8Hv0Dcdjjz3W2efsSw1t/r0chmqRqqioqKioqKiYI+bVImWrgbVm4Hwa\n", + "4+PjqSbtHEOc4q31AEdtuE5PlqNlamqq449lzSCLTnJfAB8bxovWgxbY58fi3CuOzgC2uFgbympz\n", + "QROn+z7LjnloDPMzsW+Aafe47XNSWiScg8cahu/VnR/Hls7M18S+AhMTEx06bQ3xszKfL/MROTIt\n", + "1obL72bRKba4IIPmi6PenPsoi34q6XFUGTBfbEVye6wh0GxLZp+VGGRRrAAt2NZx+zcCywUWHc9t\n", + "RKtJMy5k0JZIwOf2FXKOIsCzzefJyclOBKl9IlnXjpxze487W+v4pZQRZ/DIllRgP6TMUgdPXYs1\n", + "s0y5xmXZp606WdQq8J7OXNi/M/MdW7x4cad2pmkCtrTaN8hz6hsc+/eU/fs31jUGTUtm0c2i+TKr\n", + "c59lz/U+7UtoZFbwzKfSfClvHbKbGmTRv2+ZH5ZRLVIVFRUVFRUVFXNErbVXUVFRUVFRUTEEtdZe\n", + "RUVFRUVFRcXvGPPmI3XcccelGX4BNYWoQdYXMcDdJnWZyvpjEd38FtyXUjvJ9aoyPx/qW7l+Wvkd\n", + "6HJb0+3Mvq6dZb44CqOsQWXfJ0epfPSjH42I6NQgy/Jp0Tf18DLQ/pOf/GRT28j8ADwTnlPHyZEg\n", + "9j+BL64T15eNmL6pnWSe+29qkGV88TNcD8v8Hh0dbeaHmlKe/yxPCu1Ni79nvlA/rQ98hxpRzFHm\n", + "8wBcU3JY//Dl+OOP79BtnwfXTszWP3JA331rrvw+7c8///yOLLotdLvu30yyFdHdXxytV66nsv7g\n", + "TCjXUES7LuzrAlwn0LXZSvBdaoohW1kknfcixmn/G79SJ7JvrJZbxknfzvXlXE/wnH3R0W6mhbGW\n", + "8pLtvawLatBl0amu5WrZBc67Bu3vfOc7h97AZHOUyaTHmUWBl+si2xf9W9RXx7OE5QFZpB5etq+M\n", + "jo7GmWeeGRHd+cz449qMwFVKmAvm6LTTTkvb850PfehDEZH/Rnv9s6YzVItURUVFRUVFRcUcMW8W\n", + "qRLWFjOrUHnitqUh68vRR7PNr+PnzASfYvvoLZ+V9Z09y7k5yveznE2Ousmsflnfw6Kd+vpw9uxs\n", + "PMPqwA3jubNz9yHjbRaFl33PfLPlqtQeHQk57LvDaM60JLefnp7uzFcme36dzVrzs2bqv/zMuWuG\n", + "9Z0hq02Y9Ve2ne2eMmx9ZM/K1ttcMNsM72CmNevPhtUcHOYqm1mD5oKsjmNWwcAyC4ZF1pafZXtS\n", + "Nv/QNGxP99990azZb5WR7UUZjZnVfTYY1jbrO9s3snqifVGeHuewvevZ0p5Fx5f5J0HGu2F7tVEt\n", + "UhUVFRUVFRUVc8S8WaRGRkaGatp935np84hurg5rLdaOsxpBWSbkMp/KTBWuZ6LTvgPA2YftA9KX\n", + "G2hYNu2MFvMl85nIxlBa7rLs8hmG1VQcpgXOpu9hPlJ+Zvb3/wYezzAriTVPW94yH4hSFjP6s77B\n", + "s53/meZ8rnnFMpiPtlD19TeM/gyZtpwh860rv+t5z3ygyKfjdZ/Jy0zr59ladbL5HEbDbJBVR7Dv\n", + "Z7bOh9WYy24Ryrkfts/NxpJS/m3LU/b7Un5/2Brt87cr/872dD+7b11ke03GF2OYVTijqe/5rn/p\n", + "uoX+LjnPnJcsyzvHbzr9krdq48aNQ9d3xtNhqBapioqKioqKioo54v+Ej9T/xkow7K52tsh8SGa6\n", + "U5+ttmsrQKZhWIMd5s/Td/+e3e1m/Jgtn2aak2G+YMP6nK2/xrC56etzmL/WbP263H8fbZlfmunO\n", + "fEFM02yfPZs2mZUr84UbZi17Ns8YZmEexvthc9f33rO1SGYybI3UsjeTb9T/1tqZ8dP99VnfZuv7\n", + "Nsznza+ZpebZ1FX0Hm05ebZ7d8aXku7MUpLN3zDLU4Zn4/+XWRhnu58Os/7M9OzZ7ncZstsUWzD9\n", + "vPL/9lvOqol4DoftRbZ0lc+ZrWzNxg+3RLVIVVRUVFRUVFTMEfNmkRodHX3W1oPy8+xk6RPksBOl\n", + "NRKf/v15nyWGZ2R5X4bl7vGz3T4bQ8kDf2dYNOOw9s/GUjNbCxTIIopmaw2aKVrFWvqzjRBz37ZI\n", + "ZHl4pqenU+12thFhw3zHMixYsKAT6ZVphNbWhkVtzlaD64vay6rce5yznaOZ/C4yzFamhu05wPwy\n", + "n0qaMt+gZ2sdyfYX0zTTe9kzh0Xx2YrKq31HZ7IOD3tmFvHlfob5iIG+dZTRMkz2spqSvwsZnas/\n", + "Y9aPZbB89lx9gYZFO4LZ+k6V/7dPVMYr17uzH6znyPXzSsvUbG8/QLbmjGqRqqioqKioqKiYI2qt\n", + "vYqKioqKioqKIciOS9UiVVFRUVFRUVExR8ybj1RZmwtwF8r7F154YUS0dX+4U52cnGyiBFzfjJo/\n", + "TzzxxEBfK1asiIiIp556aqC9a4o9/vjjEdHmnthmm20ioq3NAy0bN27s1GOCfmpKUSPIeS64T4Z2\n", + "6sSVfZdgDDyPOk7HH398Y92D7s033zwi2lwbH/7whyMi4qSTThrgy/r16yMiYrvttht4v6zjV9LK\n", + "s53L6vzzz29qhIHMX4c6TtTlIt8Hd9rkF8nqftkvo+SPawpCLzSQowfaqBF24oknRkQ7R74T531o\n", + "Z6y+lx8bG+vUN3QdJ3j5nOc8JyJanrvWlv2Z7DvndVF+h/Ex3nPOOSciWjmHRl6Rc+YA2k8++eSB\n", + "fpl3RwSVNQ5pyzrYbLPNIqJdc9TOor7dML8Vau3Bc8YEDc6I/fGPf7xTCw+eIe/IGDxnXTjCB5pZ\n", + "R/CFdcGzH3744Yho19HExERHbr3e7ZeCLLJf8Gx4Th4dxuQ1alnfsGFD857rfkKDecczkBdoR/6Z\n", + "0+XLlw/wi32UdVTuF3wHWpAV6GacjGvlypUREfHoo49GRLvmkF3Tzuumm24aEW3dt3Jd8B3mnz3H\n", + "bemLdYDsMgfIC7KLXNg3iOdR9+3YY49teOX8R4A5Ys15P2QOeOX3Bdk1P/ge/D///PObvpE9+MHc\n", + "WBZd99VrjrUIX+AjtPPsbbfdtnme1wXjca1F84X20Ayt/I38XHzxxRERcfTRR0dE17fwiSeeaOi+\n", + "5JJLIqK7RzM+5IRnsHdlmLeD1NTUVMcpDIbyCrwBTU5ONgLuH1cmhx8pO0fyTMCzeX/dunUR0Qq9\n", + "D3vlwoQefhh9YPKzhpVt4XMn5mSsbBglLbSlTeY0aMc7BJ325rk3Z/5GEMvNwAenYWHMXrxOzJc5\n", + "1zNW+No3VqcWoC0HBujP+oSPbOqWLx9Yyh9o8xD6fCBi/JnjI32CzOGxLGvEOPxD5z5ox8EbWHbt\n", + "4Alf7CgKFi9e3DnwsRllTvXwnM9RdrKSMj7sMJdl+yw4wH0BaCgPIeU4zXvGxCHAiSv7EnJ6nNCd\n", + "HdrdV5ZaABr8AzM2NtbIO/B8WSHy3zybA8VDDz008AzLF/sm/SxatKjpg73UtJjuYY7/8AvZzfY6\n", + "DmKTk5NDHZM9B7RHIWXcwAmcn3zyyYH33V/p4DwsNQ+yBy/ZTzjkZnsR8GGx3OuyfZE23ruQH9qz\n", + "r0Cbec/apb9HHnkkIlo+MicRrYzw+uCDDw6Mj2cBJ6r1b5j5AL8AY1u4cGFn/v17xp7qPoahXu1V\n", + "VFRUVFRUVMwR82aRWrRoUXOyfOyxxyKiPSVbI+EUzIm7tAZl6Qm23nrriOiaAbMSMZxMOeVCC7QB\n", + "TsWPP/545xrFloSs8CWap0/HnNCxpqF5ZabPUov0NZotDDZFcyXBODNrGv2ieVlz6YND6z1OF4hm\n", + "HFmiUvhhDX8m6xjaDW2gH1kCWPmYu3vuuSciWi0JTQtAK3KCprV48eKOtYtxYjngb56VaUeMwaUU\n", + "LIvldSR0Qc+wEkHwNLMwwSdossXTFoyNGzd2QuSh3+vCtPD57bff3vu5rxVpbz6Vz0ajNg9NN+0Z\n", + "L/zzNSxgLml/7733RkS7j/Aa0fIU7Zb1DO+9lngmNEIzPEfLB3z/gQceiIjWerL55pt39gqeyZpj\n", + "PQDLi2V3WMJfrAj0+8gjjzS8tCXdVlHkOtvnaMf4bXmxfG211VYNrfDuvvvui4iupdWgL8bvdQEf\n", + "6df86bO++ro4o4Hv+mbGe5bbM3fQZotf+X++Aw2+NgTe/y2b/h2lPXOOTGLZL8G8ITOsMebIv+ms\n", + "ZWix244tWIzV+8bSpUs7libvWXwnm88M1SJVUVFRUVFRUTFHzGuJGLTdnXfeOSLa0581b+7p0Ww2\n", + "btzYccAGWF449doiZU2MfmjPidVWE8Dpef369R3LkU/p22+/fUR0tT1O7/ah4mTNCRzNCliTmZqa\n", + "6viPZHTbJ4ZxZAn5XEjSTrtl/3aetX/JsFO9/Q5skdh1110HaLEVrdRgoM+OjDzDGiYyuO+++0ZE\n", + "xHOf+9yIaLVHLFQACxX8KeXMPLSFypY3ywvtrbFl/ZVWkMxyBLbYYouI6FouWS/WSPFtsD8C8N/T\n", + "09MdqwVrzfIP3WiryDt9YuUp+47oOtMy1nJN0+b+++8feBZr1Rrp7rvvPjBe+IP1w2sUPrN+PIaS\n", + "78gQ72Elt4wC5oIxeNy2jiEf+++//0C/69at66w5gmZ4pq2kWYkgt2dNex2xV7GXr1ixolk7tqTx\n", + "LPhBXzzDoB38sH9aaQWMaPm4cOHC5v9Zgln76/AK7V5H8DwrlGwsX768oaH8/YrIrePMs53TSz+j\n", + "iHZuaAefWB/lWC07XnNeo7Zq0Re/zV5HLhDMOuHmowT0uhixLbjAt0nwCVpswWJubJnasGFDp+9h\n", + "hcNnW6S7WqQqKioqKioqKuaIebNIrV+/vuNL41Mt8Ml9yZIlnagygHbKSZjTaqZ5Z2VdHDEDOD1v\n", + "ueWWjaXM980ArTiL2vCzHc1lHyD7VCxfvrw5xdt3xad0RwSBLPIhi9abTTHH2Rb69Pih2e1vu+22\n", + "iOhax0D5t/2MrN17/MwR/iVobrbYAPho37rp6emOlSYrvpmNE5nle2hcjv4DZeSl5yfzQ/K8ZhqX\n", + "LRa2LvbNv7U5R8IALE7wnPVu64H7Rf6RA4eHR7QWg0yztJxff/31A7RCSxa1B9BsHXna56/nSGL6\n", + "tGwxHr4H7dnaZV+09X3BggXpvgVfsFBlFmxr7rY62yKFfxsWvCVLlnSs/QCLAvun11wWtWpLhq3s\n", + "4K677mr+bznwuoDntqRk68IRx/6tMt/vueeezv4N77KoO15Zg5lPLd+nX55N+9IKZWsf33VEPGCO\n", + "eHVEnWmBX8gVYK5KqzHjYz0gH8yn+7Y82P/VtPNM37o88cQTnXl19HrmYzwMQy1Sb3vb22LlypWN\n", + "+Tgi4oMf/GCsWrUqDjrooDjooIPiG9/4RvPZWWedFXvuuWesXr06vv3tbz8rYioqKioqKioq/qAw\n", + "PQQ//OEPp3/xi19M77fffs17H/zgB6fPO++8Ttvrrrtu+oADDpgeHx+fXrt27fTuu+8+PTk52WkX\n", + "EfVf/Vf/1X/1X/1X/9V/fzD/Mgy1SB188MGdEPB4psfOe5dddlkcdthhMTY2FrvsskvssccecdVV\n", + "Vw17REVFRUVFRUXFHyTm7CP1iU98Ir7whS/EC1/4wjjvvPNi8803j7vvvjte+tKXNm1WrVo1cF9d\n", + "4h3veEfzfw5q5JEggoYU8cccc0xEtD4je+yxR3Pn6/IT73nPeyKi62dgn4+LLrpooG/u60lpzx0p\n", + "+TBc9mPp0qWxww47RETEb37zm4ho74/POOOMiGhLoRAxRXt8Q8hVRCkEUuHb/wK/J+6QKRFw3HHH\n", + "NeM64IADIqKNkMHfpiwnU46T19/+9rcR0d5L0ze0O2LyzjvvjIj2frosEePMxPYXoEQEPOTzl73s\n", + "ZRERceONN0ZEKwcXXHDBQHvmZO+99x6g/amnnmrKplDagLt6t8WXg75drmLVqlUDfOR+Hr689a1v\n", + "jYhWRonauvnmm5txUn7g7W9/e0S0crHHHntERMRNN90UEa0yAi3wnLlAbhzFiqzTfuHChU20IeNk\n", + "/uELbZF/ohRvueWWiGh5+9nPfjYiWj4SCUQ0Fu3xzylLZyC3u+22W0S06wK/GeTc88+6YK+ARvqG\n", + "dtA3/4wVWcT3AZpc8oM1etRRRw3QsuOOO0ZEG7UFLZ/5zGcG2tMvc8QY+0phOMcU6x/fFvYWaMcP\n", + "Z8stt4yIdg9yCaIjjjhigBZkccOGDY3vH/NJ+RlkC57fcccdEdEtKcR+wVqmBA60w3PmiDmFlu22\n", + "266RQXxhWP+U8EC27CPDHLF3uaQI43QpHcrVUMZlfHy8iZx2niPm0+WqaH/33XcPPJP1D+3I0377\n", + "7RcREf/zP/8zQEu5p+PTg2zBQ/hDKSTodhkWV4zwusBPa5dddomIdi+in09/+tMN3cjUnnvuGRGt\n", + "jyB7DL+L/D6z77uSCL5EyCK/o3xOFCdyODIy0vDQey57CzS4dJbLG9nvkfcpb0OZOGf+X7hwYTP+\n", + "008/PSLa8kPIFHN09dVXD/TNms4wp6i9Y489NtauXRvXXHNNbLfddg1j+pA5Gl999dXNPzbEioqK\n", + "ioqKior5xp133hk//elP46c//enQtnOySJWe+UceeWS88Y1vjIhntBw0HAhB8zFe9rKXNZo6ViBO\n", + "pPbSBzvttFNEPHOCvfXWWyMirxHmIr5onI74QoNCI7EWlWVC33zzzZvvcmo3LZyY0Syck8WHTNo7\n", + "o3lWV3BqaqrR6miT5fngWfAH/mWRkmjanOCxGjo3R0Rev8oRcwAewje0f+f+KccZ0S3I3BfN6Hn8\n", + "2te+FhGtVYg+gKNNiPTg+x4bfHB+oiVLlqQ85DvwwZl6AZ8zPtqhwTordymLjuxxDirGyfvIgXNX\n", + "AfiA/GM9dRQsWLx4ccey4AhHgGzCF2TYVgOA3DN3yI35HdFdK1g32ZecT4dxODKSv007NJe5ikra\n", + "yzUNfY6QzObfkXVZ1mngjOFYCZ944onOZ+w5rsWYVWVAFpkr52zL6gTy+vDDD6dRdVhzWGNEdMEX\n", + "0w4tfI/1zrrI+Ljppps2bV0IGDhS2nuvgQwiF+xd9O91t27dunRvyepZOlKO9o44g1/e8+inlHX2\n", + "cb6DVZzfC3gLeDbv833mCoud2zN+/u6rQ5tFPrPPe10zN8w3z/atADAfyog87y3+LaHv5cuXx+rV\n", + "q2OfffaJiIgrr7wyZsKcLFJlksL/+I//aCL6DjnkkPjiF78Y4+PjsXbt2lizZk28+MUvnssjKioq\n", + "KioqKir+z2OoReqwww6LH/zgB/Hggw/GjjvuGB/60Ifi+9//flxzzTUxMjISu+66a+OHse+++8ah\n", + "hx4a++67byxcuDA+9alPpVd7m266aeNv8+///u8REfH6178+IrrarqvCn3vuuc0p9DWvec1AW57n\n", + "PrJcTGgk+MSsWbMmItrTLtoy4HR87bXXxg033BAREa961atm7Jt7aLSAAw88MCK6OTc4maMVYQXg\n", + "5G6n/8WLFzfPJAWF78ABGgJ9wnvaWevlmaSwuOaaayIi4i//8i8jorW2RHRzy7juVmapwwLF3far\n", + "X/3qiIiBVBsR7X07B/hPfepTA+3Lw7q1tp///OcR0d59lz58Ea28MP9f+tKXIiLioIMOiojW7wBY\n", + "Ey35mGXZ//GPfzxAy1ve8pZeWhknfLviiisiovXbIMM7KPMM4duCj9cf//EfD7RFM4RuLHVvetOb\n", + "IqJrecVCgd/a9773vYiIeMMb3hARbUZwsGDBgsYn6ic/+UlEPBOoEtFdQ8gHfiX4K0ELvmQAPmJV\n", + "Oe200yKizUL/kpe8ZICOiJZnzDs0ubIBcoy2+/3vfz8iIvbaa6+I6Grq9lshmIYx4UsU0c4va2ft\n", + "2rUR8YzCWdIKkB/ybPGKxZ61DZxDDqvbkiVLOpZXtHzW/3e+852IiHjBC14QEV0LNuNEg4d/0MIr\n", + "wIrCGNesWdOsIdPiWwOsXOzp/s3gb9ber371q4ho5cHywj551113xY9+9KOBNr4hcf4v1urq1asj\n", + "ovs7YovOpZdeGhGD/oolttxyy2bNsbew5+LXCry3uMKF87E5+zi+k+yLJd/pi9+i//zP/4yI1s/O\n", + "43ROL/rKsonzO8Sefvnll0dE+1tXypdvh9hbeAZrFvAsZA6ZZb+xNRXa7YO1YMGCTqUC6P7Zz34W\n", + "ERE//OEPI6L9neurFdiHoQcpBKXE2972trT9qaeeGqeeeuqsHl5RUVFRUVFR8YeMec1sjkXmL/7i\n", + "LyKi1ZrR8gEnS07Nr3rVq5q2+KgAtB1O4Jxmaec7bEdEoNG7/hso7+uxblh7c1s0Ck63nMh9OrZf\n", + "lrM027KzcePG5jtEMmVZf/kumuMrXvGKgfGjkQM0d7QneM+r+Q495bjsbwJ4Jjz+m7/5m4ho+eQs\n", + "vGhBaJpEzjHHaEHlM/ns8MMPH3jfWfKhFRpf+9rXRkSrHZkW+Gh/nU022STNPI6cH3bYYQPjdg0y\n", + "5IfPiQjib8tXWf8QDaqvzlY5TtPCPFtemF8sO0TxQIsjCaemphrZIwoTDdI8ZNxYWKDF0buAOYPX\n", + "f/7nfz7weelrgvXLtSGZL1teGDdrjTWNPHiO4Bd8hmYsW+Ua5dlYQ7ByDaudxjgZC+Oz5m2/pbJG\n", + "m3lOH9DN+odP2bpAu///2HvXWE3L6v5/7T17z5lxhrMwnAURlEJt0Dba/nqg6ZvaNiamtlpLFLCV\n", + "KRCUg6iAQqCIQaytoBKkaZPWV9U0adqYpjZVYxPPCsr5zACio8xxH2b/X5DP/VzP577XPPz2n2b/\n", + "+8/6vtkzz3M/172udR3ua617rfXFA5nxZ3I/PHLHHXdc188s5tVce/THc5cxoh3zHXofRa8bN27s\n", + "vDO0nemQ8cbL6SrhgHnPOrrqqqvG+uB9dM+ePd08/7Vf+7WI6GcpAjN9mFvQnjpnpv75n//5WDvt\n", + "mKITPOxktjF3HPNEv7/xjW9ExMgjyfPRnhrGmucDe4C5btu26R+xz+jQzxZX+Hc1csPMIMRKTU1N\n", + "9fZodMpeiyz0z+siQ3HtFQqFQqFQKCwTK+aRWlpa6k6emfXfXhsxOokecsgh3anbljEnYn7DdVgF\n", + "PsU62wbLNOOUa2tSYI1yavX7cU7ClsmM2gBZaQfrESvY7S8tLXXyYcU6Ow9wnT0wyGDLi+uQ/Vd+\n", + "5VciYuT9aa1p2sBy4Lf839mG5pDD64EebakhO3+ZL8yfIYsX+bgGWTI+PGe6ZJxyXMf3zKu5ubme\n", + "HIwbcTZYOcS+eC6iR/TnjKmML+u5557rdEib3AM4q4/rGAtnp3ltYslx/ZA3lf5jtXIvW3Wea3iu\n", + "GBvr3HxdeAMYi5ZhHh15rdE/e6SALdXWim3BuPPXlnk7v9ARsrC3ZB4as9abH9DrHz3ZqzI1NdWb\n", + "58629G+9RkHLLRox0oszSL0u2rbtvXJsoD0U1rljLp156H205Xh0PI7lNmcr/WQMrEf2JuYTMlDr\n", + "y7LPzc1193CNQnuvaIs4Lu6RcbkiMx5cvCnI3urdvH3OqPb6Zz44K5y+ZPOFz1ln7COtXuin+S2B\n", + "93/z5Lo2pWOTkYGxZE/ftWtXb67gcaYN9i72FHuNM5RHqlAoFAqFQmGZmFoa4nr5n75pkslXKBQK\n", + "hUKh8P9FZMel8kgVCoVCoVAoLBMrFiN18cUXd54p3k86NgIeH/jzwMzMTC+25aabboqIEb+ZYxn8\n", + "Tvezn/1sRIy4k5wph2y8v73mmmsiYsRZtWbNmu49sLMKrr766oiIeN/73teTO2L0jpj31NQAgmuL\n", + "7505yH3o6yWXXNKLN7C3D34r+KqA66eYa8t1Udwuv7/lllt64wMXvJyeAAAgAElEQVRoG/nhzoJS\n", + "iDbdPwC/kXm/HEs2NzfXXQtHHG05y4i/1Fwx75tjH+gDta58fVvFnTnG+HAtbWWeWGSHa8sVrgHz\n", + "Cx6vdr5wb8cGZtxptO1YQPjKzG+XAT2269lcWB5/xojvnWnI7z2mrlcG+Pymm27qOL8A4+m9xTxe\n", + "bgvZ0Dl8aKwj1q5jq1atWtVxijGejnm0njxGXMdf4lvoQ7Yu2Kvm5+d743nFFVeM9Q+ZvA9ce+21\n", + "Y/20PvjL59dff/3Y9W1fHX/JumDeAu+H/M7cbK6b5Zgh2m/1MhRXGpHzfvpZ5HXE/u915ow7rn/X\n", + "u96V7qFcSx1Gz13vd6xZxh89opcsbumGG27o+sk923i6iJEu4f28/PLLx9pw9XHisJhfHn+ub+cL\n", + "z1Cyrs30AJDNvK+Wxc9Tnxc816emprpr4drznuu4Va6nnxnKI1UoFAqFQqGwTKyYR2pqamosu6L9\n", + "a3Bde7LkM3sx7Knyqd6WKb8355Z/18od8cJpOqvACzJPhOuEgOz//D5rf6hf2bXcm+/5nbNZgK0+\n", + "W7AR/XHL+ufv/X/X9MquB8jsvh/ot5M8eIA+WS9ZrZuFhYU0q8r9yjxwHhNbxe5n+/9sPRjc21lW\n", + "2bqwB2Lo3vzfnpZMFus8u/ek/w+tC1vck+aivWa2vD1fuI75YdnavmQeaI+r2/bek83RbB6tXr26\n", + "N2+drekstmzv8dzNxhS9tZZ9Jp8/dz+z5wCfu67egfZhj6/bHlrHEX1vOrBeJ8X7Tk9P93TojGng\n", + "uWv+R+/FfhPi9dDOxRe7DkBWbymDvY+eP+3+4X0QuL+W3c+wTHbLlK3l9hrPvSxrP0N5pAqFQqFQ\n", + "KBSWiRXzSEX0379n73h9XURec4RaI7b6bGkArEbHMWT1MrCGVq9enVqUGXyizrxIfE79EMeztLAV\n", + "A9y2PW2OHcpO9ZmXoZXFp/gX65HKrFtbJENWTdv+gSwvx0pltbuMzCNpPYI2bs9tOJ4is3LsRfXY\n", + "ZLFBQ97R7B5uM7O8+b//Zp6JpaWliR7V7HPr2P+3l+hAntzMEp6kD2BvoH9nffh3Q/3gHo55MxwD\n", + "xF+85ZnX2Jb81NRUGuthbx7IPM8g8yIA7u01cCB5s7XneW6vqOP8rPvMUxWRezOymlSZ18i1vQ7k\n", + "LWnHZahN3yvz0E7a0w/0DPCay9a1f2tPTfZ2xOvsQF5C17RzDatJXvUDvZkZ+jz7PiL3SGbfZyiP\n", + "VKFQKBQKhcIysaKVzTNr8MW8r590urcV66ws35MKrFh9ZBJk745b2bN4Gv6fWSuGrUX3e8jycgZL\n", + "5jFxDM2kasJYhR6ToT7Y2zOpnyCLFcg8FJlHopXd4z50zYFksOWVxXe44vH09HQ6bzN+MluQeEN9\n", + "XeZNbWW0NyuzpP3/bPxdLRhkMVPt/z1nJnmcsv76ess8FGvkcbPuJnlMvC58vauve921smRzx5lS\n", + "wPGKfJ95ojyvWm5L39t7UcZTBrJYwEnzCxn27t2b7nv/t3Eorsbtiukeo3YsJsWZOrbHbzAMz6NJ\n", + "byVmZ2d7HiNnhFpue+yztw4Z995QvOQkT9Ikz8yB4hKH7v1i1l1WyT+rVG6YSQNksbNDnvtJfH0v\n", + "tuZleaQKhUKhUCgUlokVjZGy9ZhlHvlU22YITXpvbGQnb59MOdU6rsEei1beF5ttkHlu/E7XdWcO\n", + "lM2WZYb5e+t4kmcvywRpZZmUvWj4/bxlymKhMmty6N6ZdTcpBmKStWy9tfWbbDlNyogz7GHI4nFA\n", + "y4I+KdPNFvekLCyQeY+GLPHMU5Rl59hjZc+DZfc8OZCn1/2ctB9ksTLZmgbemw60Jr0Gs1hA928S\n", + "H55rQrVtAXvOQBavlM3dzKM1NC8yj1oWU5mNlWXPvEGWcWlpqbcPTNK5ufcMtzPJ8zszM/OidBWR\n", + "xwwC38trOot/a6/JYocPlH3a3jt7vtrjiZdpKBMvq4+V7bmT4pS8Lg6UFZ09F7OM6kmeW1AeqUKh\n", + "UCgUCoVlorj2CoVCoVAoFCYgOy6t2Ku9yy67rHOfUbLAJQhcxr+lTuC1Bm1Qwh2KGNyGBI3jasTF\n", + "eMcdd0REn8Zhx44dY/fic8rVI8u+fft6BeIIZDflh18zIEvWttN76SuD2NJbOFUaN+fzzz8/1jYl\n", + "/Ll3lnIK/Qi0DLRLQJ9fO950001d29krKX5D2/QTih1k8usEy44s/A538p49ezr6EVMV2HXNfLjh\n", + "hhvGZAHozzQ9H/nIRyIi4sILLxyTYagoJuMPVYFf5QzpMGJEhcK4+9Uu/WWuI8vatWt7/URu2oZm\n", + "gbbRA/MEoHNoNkz1YJc9spj2o+031zL+pmXgFQX0TNzT9CNOJPArr49+9KNdP9EHpQMOPvjgiBgl\n", + "lbC3QMthOiYHwEKFQ/vck/bBwsJCpxMoopAXqhfuxRy67rrrIqKvQ79uok+mt/G6mZmZ6XRlyh90\n", + "jNyM/6T1jz78Gsbj376+pJ+mn2Lecu2mTZvG7kF/aZv5wpz9+c9/PvY72snosCJGOkeH0Il4X/Rr\n", + "N9Yg+ws693OFZxj6bZ8BfhWJTlnPtI1eaPPlL3/5mP7ot2UHDkehzzfccEM3Fx3gzb7+spe9LCL6\n", + "FGEu3Mv/mf+f+9znxq6nj8wrrlu7dm1HP+PnHNe4MLf3IuDkLvppGifLsri42I0ba8jXWgbT8mSo\n", + "V3uFQqFQKBQKy8SKeaT27dvXneKxErEwbOXZK3L//fd3J+QsVZITNpbo9u3bI6JvgTtIlHtxEnWw\n", + "Ge3v3bs3fvKTn0TE6PR6+OGHj13rV5g/+9nPut+2bQHTd/B95j1Ys2ZNd2/0wOkczxpwUOyWLVvG\n", + "+v3UU0+NXU//bbnQzjHHHBOGU1yzgD1ktbWbpTPbi2Yv3BAlBL/BisuocBygSb+ZP8xNwHXMXebX\n", + "IYcc0s0H99NBxsi0efPmGAKy43Fxv0E7f5hbfIa3A9AGFjP94178dT+ZR5NkaVPN8byga+aa2+Z7\n", + "PK7cI1v/6O+5554b+74lPWX8WBe0zVgwXoDP6T+yIbNT1NEfYAy5D/OiBd95TVoWF8tlnvD5oYce\n", + "OnY9c5c5yths2rSpt1d4P2OsPL6AttDLs88+OyYb8we4HEQb6O1SIXx+0EEHRUTEscceGxERP/7x\n", + "jwevZz789Kc/jYiIp59+euz3hxxyyKAse/bs6fpHf70uLBPwugf83qUYMnqT1atXd58hC/J5/2ec\n", + "DzvssIiIOO2008Y+p9/uJ/OAPeCII47oycI16JD93EHkwEHXfnvkNcp8Yc7yvEVfrd6Rm8/4Lf3L\n", + "ShTZW4wsft3Gmvaa3L9/fy95zJRy7C2ZxzlDeaQKhUKhUCgUlokV80ht3LixZ91zYveJlNMyVsLe\n", + "vXs7a87eC06SnEo5lWNJZpYXJ3Xa47SceQEOP/zw7h6PPPLIWD8A/eNkzD043ds68jt0rOLsdDw9\n", + "Pd31h9N86zFrgazoEAvTXjCD32Etcj8sj1bellQ6oh8TBBgLPBcA2TMqFOYH3jPuh2Ua0Y8PQAYs\n", + "DesFMCb2KhmMJfrC+tu8efOYTlr56CdegkkFFvGwYPUju3/X6p1+Y5VmKdTokPE/8sgjI2LkDQbI\n", + "wJxGb8hgb9qmTZs6XSPDJILboeKFEX2PhFOT7ckaSlF2XBFjk9GPZEVwM6+B95chfTPPHdPlODPQ\n", + "ltJo2+R6e0nwKrAvnHDCCRHxwtz32kIGPAWOBWUeAHteHOdny5750q5R5oG9V45fnVQM0mn+zD17\n", + "ESz74uJiz+PiZ4tjoRwz5uvtdWV9eA8Ea9eu7fTAtfTH+z9t0PYTTzwREaP9zWOKbN7zua7dF13W\n", + "gblE/y0L/WdenHjiiRER8eijj4793rLQN55drIG2fZNO02/mg98y0bbjlnkm+bnI/2m33atanbRt\n", + "e43awzoJ5ZEqFAqFQqFQWCZWzCO1a9eu7mR5yimnRMTIkvUpkJMop9yZmZk0zsjeHxdk8+nVcRku\n", + "N2/rqLVckQuLyxYmp3H+2lNjWbBY7E1BRlsBCwsLPSs3i0tx/BG/s7UH/H8sClMBtHJmhdQcK9Zm\n", + "UbT38rtz4Fgx/g7Fsdm6xXPpuCqAbLTJHMQazLyGyMT1jz/+eC8GxkX77HGydcTcG7Jq23u7/dnZ\n", + "2S5+xvFGvtbfO1PK/ST+xNmMnrtzc3Pdd7SVxRk6Hs1xCl7TyI7eHFPTtu+CrPYgZJY0wCOJnux5\n", + "Y4zwcKEH+t5607g3bdg7Zsvb3i1k45721Dm+E9kXFxfTfczZvawP69wFFpmrWaFiZGjndFZI1J4Z\n", + "9gPPSWBPDN5TPs/2rnXr1nXxRvZmAPrhmKGMasqeKmemDpHcszbtObIOHaf3ox/9aExmzxdkRibG\n", + "Eg9dGyfHPEUW77leB5aJ5ymyeX7Zg4ssQwVcuRaZHOuVrX/u7b74TZCvbz13WRFs9nnmVuZ5zVAe\n", + "qUKhUCgUCoVlYsU8UlNTU91JkpM2J02fAk2guXnz5rREP9e6DP2kDBKfQJ31AtqTOPfA42RZnOGA\n", + "ZZq9fzXxrD0cQ5lVtO134LZe/LljQjKdc5rHwzVEkTNEKt3+zWJlbA1k1AmA60zf0XrCHDdDf7Fe\n", + "MjJSW9qmLwC0x/X83b59ezqerqeTUZtgiWFpE8eUZT/S15mZmU4uLPCM2oR7OGMyyyAFmVcV7Nmz\n", + "p2vD9X3skbTnra01E5HHJbQeuIjRemplNYk33+GJsteUMcq8xJ6LJsx1val2jNrxiRitIbw22Vzk\n", + "d65t5Rg5e9/suWlhj7y9hda5ZcfDwOcZaW27pjNaJntDkDvTh2s2Od7JY8q+OzU11fNEZXMrq1E2\n", + "iSKJuW4PHti7d2/vjUqWQey4O5DJAlhPrAt7eiPy8bSnGjhrm7hUP18zGR3v146Rn7nOnB5689K2\n", + "4We791H64tjilloO0D90jwfe63oSyiNVKBQKhUKhsEwURUyhUCgUCoXCBGTHpfJIFQqFQqFQKCwT\n", + "KxYjdemll/ZqkzhrB26et7/97RExese8tLTUvbvkN3BhXXHFFRHRr9XBddwTvqLLLrts7HpnYfB+\n", + "Ht4veH8WFxd7bfIuFh6f888/PyJG71+JM3Elb3OQAVfuNtfWe9/73p4M5vH68Ic/HBERV199dUT0\n", + "4xEcMwMH3XnnnTcmC+/MkYX7fepTn4rLL7987DPAGPH3xhtvjIiIP/7jP46IftaR64r8/d//fUSM\n", + "+BPRr2MjFhYWOp3AV+WYFcffwMvFuPJeHf04pgzZ4axCf20mHte+//3vH9Ohq88bt912W0SMeJ+c\n", + "tWm+K/pK+6tWrerFyNF/1tA111wTEf2MKVfEv/baayNitC6c7enxh8vvbW97WzevXUWfeX/nnXeO\n", + "9RM4awfZ4c664IILxj73XOS+t912Wzc+9MuxX9yDfjK3mCdZjBRcWx/84Acjoh/HQV9XrVrVzRXz\n", + "PnJvZ+fR9lVXXRURo+w799dzMePmbLN54SvzvHUsCzLC+wfvo+PzHAvDvssYMY+mpqZ6WWWf+cxn\n", + "IiLiQx/6UEREr+q4ZWKNXnnllRHRjxF13SHahfdt7dq1nTye98jNfuEYL4As6BH+TPTo+CTGouVy\n", + "c1yq+8H48+xy3KLjr7gefkPHf3E//v/xj3+8e7Zk2ZaWheecYyu9RuFDRC9tFfGI8RpQ5v107S3H\n", + "PbN3sS6y2m78n/GHF5W9vG2fezLPf/d3f3dMZ44d5nOeRRnKI1UoFAqFQqGwTKyYR2p2drZX4ZrT\n", + "n0/JrmC9fv367pTuatLORnE9GdcRwfqjJo153cxv1dZfcp0U19ZAXtdqyWraUI/Knp2sHsvi4mLP\n", + "Qmx5plqgLz7n3kOVZyP6DOvOamnbt0fJNWtco4TMMtcooiaTq4vjibQFyn3bDEv6SX/MvO74PMYd\n", + "S4p+83tzq9E3y7h+/fretXAvWnfci/4Cc0rZ0rTsLccj93YmDDAvG3/tsTX4nMr5mVdt3bp1nQx4\n", + "deinrXw+tyfKnheArMwXZ6q213sO2tLMuLZYq6xBPBT2HjA/0AdeFX531FFHdddyL+Q1x6Dr33gO\n", + "DtVmamE90Pe5ublehqdrNZkBImMfYO2ae89ZXmRQttla5kYD1Dl64IEHImK0l7BeYAsArDV705m7\n", + "1k/7BsAeRj8v6JfrgWVZePb8OqPQWYG7du0ayyKM6HsB22sjRnPK9dhaTsmIfsY1c5D2276yj5u3\n", + "0pXcgTk4vYdltZ6GWAbavrX98jPJ2c3+LePvrPDs2eXn6+LiYq9tnu/sLT6TwAQwCeWRKhQKhUKh\n", + "UFgmVswj1XJ72Yq2dcxJm1PjmjVrulOqr8V6cRXszOLmNIwVwAkcL4itKeTes2dPr65FxuNlPics\n", + "CVsv3MuWZsYsvn///l5cgWNeAPfCGqS/WJbORoC3y1YfJ/VWn7TtmAh7gwD8TUcfffSYrFgScBca\n", + "js9xPZFWFqwRxzK5n7aaXV3YFi3tutLvUDbHySefPNaGvVlmcwfWo70sAAv+8MMP73RIP22N2ZPo\n", + "Wk626qnsTjtcn1Vl37p1a28OskbtHTUHpeMTrUvWPd4e11dqLW8zwrv6ta16rx9gTwNg/Tz55JMR\n", + "MdIPfWp55Vg7rvfkGEnA/12jCn1advptz0Ybv9l+FtGvm+VaXsAVwbHkszEdijHKav1RH81vARxL\n", + "CpCZPcveIq/RNhbNXs+MfcJvLszXBhz/l3lswI4dO3pVzx1L6H6a0SJ7dr385S8fu96VwltPrdsE\n", + "XJONJx4re/Q9F9nTuZ5150rhbVuZB8o6t6cWZNysGdPGqlWret7uX/qlX4qIkReU79mjX2xRg/JI\n", + "FQqFQqFQKCwTK1rZ3PE9nNQzfjtO5ktLS92J19V8OUHyFwsBS9FxJpyKecfPSZzrfYJtrUlb0j4B\n", + "O57AVbEzlntiZ1yVd6gqa/addehsLlsUWfVxc+thkbfWARaFdZ/x2z322GMR0Wevx8uDpWrZMwxV\n", + "K7bnzDxwwJmUzsC0Xp2N0nJLue2HHnpo7B60jYVlrxFzMMsgtSy088QTT3QeIn6LLgHjRRvMLbwm\n", + "GdeWOfaQcSjW0JZxNs+xUpkn9MMZpMB6c0Xsdr5YV/6/rVePI/3KPN54qmkPPeNdbT3tzG97Rew1\n", + "A5mnCv3Za2DPXMsk4PHh//YC8H/r/JlnnomI0T7I75lH3nddtX9mZqZr2/1hzuH1Ys6iW8e80M7W\n", + "rVsjYjQmzLNW521fZmdne+s+4/30/MgqoLNmXbE7i8HcsGFD6pn3vmZ+VNZTtjbx0DkbcChei33b\n", + "2cxZjBxxvZ4f9mRaFu9djg9r23Q2eva8YD74eZjFazkDt13bnov3339/RIzmO3pgXeM9nYTySBUK\n", + "hUKhUCgsEyvmkWotZteoyLxAxJQsLCyk73z9G06YWTYTFrZjTDILFkxNTfVqTfiUbqvN74/tNcLa\n", + "4UTtzES/S96yZUvvnb2zMgAWBm3Qti0TgJVvjw59HtKL+ZUy0E/HUqEXZzM5k9LWUesds1xYM+b1\n", + "A3yONeh4C7dHXBL6bGvg2JLiPTtz3fFYHn/6b8+M5xVo49sco+J5Tv/s9coscPOCeX4N8efZC2jO\n", + "OIOxwDuaMR4gA1av13I735y1O4m93bFD5sH0XHYWK/PB8SkRfS+nuSezuCz04mxNr1E8VM7y3L9/\n", + "f8/jbL24//Yaslc5li7jIHO81szMTDcffE88UfYGmhsN0Bfvi9m+23r2/LbD+6LXieOSPH8yz1MW\n", + "g7lhw4aeZ5lrvC7of1svMaJf8w9kXld7bCJGunL/XVcMmJPRz9GMP9NvZ/jb6pG5ksUMu21n3rru\n", + "VPaMdh8XFxdTTxp//Wwprr1CoVAoFAqF/2EU116hUCgUCoXCBBTXXqFQKBQKhcJLjBWLkfrABz7Q\n", + "vX/kfTzvOokpgZsJriXebz744INxzDHHjLVn/ilOjmTTEH3Pu2+4kP7kT/4kIkbvcKlVw/Xck+vh\n", + "N5qdne1iedq4gIgRXxFcW7RN3JHja+CUgivIMVHmGKKvF198cZfhd+qpp0bE6F0vOoUj6txzz42I\n", + "Uf0f6mY8+OCDETGKnYE7CT3yrpzrnM3413/913HppZeOycf7ctfRMi8T2XtnnHFGRIziNMgwgWvp\n", + "T//0TyNiFDtgDqXVq1enOnd1bd6B+3rz9wHiDBijd7zjHWOy0N7u3bu7NmgbTiniM04//fSxfjP+\n", + "cMrBb4XOmYOOETEf1rp163rV0ondgVOSa9ExsT7oxRyEXI8eifdijJGJMT333HM73f3qr/5qRER8\n", + "7WtfG2sDfjP0wlzi3s6YY+4yF7mnM5D4/JZbbunG07E/zHvkh1PSbZsrjN+x5syfiJ7bLCXzftJ/\n", + "KnmzJ3Ev5jncnMh81llnRUTEd77znYgYzVHaNx8i82XNmjXdHoPc7FvojHuz7oH50Ji7rFGynIhz\n", + "vOuuuyJitEe3fWWPRlfMRXNnspaQnzZYF/CEMrfZ44i1ov/MRbg/p6enu8rU1CJjnFhD73rXuyJi\n", + "NAd/+Zd/OSIi/uu//mvsd/ChwrXIHoR+qJDN3t3uAa407tguxt98iK5hxlgxd1mjjud1JuFHP/rR\n", + "bnzYcx5++OGIiDj22GMjYrRn85xj/DNeO/TFGHE97Zx99tkREfGNb3yj6+vtt98eESMeR+BMaXPQ\n", + "8rygn44lNjenef/Axo0bu9+yhpiL1MHi79e//vWIGO1RjFGG8kgVCoVCoVAoLBMr5pFqq87ylxN3\n", + "VsG05U/Dasu4fTjVuw6Ss1OcGeV6Mln14R07dvSudVaNK7hmGULuJ5+jB+un7aPZuOl3VkeK6zO2\n", + "c4BV6Otc6bht05Xps7pAzozh/0M1R9p28BZimT7++OMRMZ61Y04wcwY6mwlgYeLtwGNniwyLy3xg\n", + "P/3pT3vjY2T1ZNw27Zg/z79rK4hjeTPOWFa+Ft1NyiDinngLnDHnddTWNMNLgzcn445kDjn7xusI\n", + "ax/9MFbop70+40rLqh3TJt4N9IPl6vF3xqXXfmsFZ1lJ5iIEXMe9nWmbca25mv3+/ft742PvH/Mc\n", + "ZDXw0A9MB9RG81ykXWRcWFjojQVwhW9+y/7uPdfsAWYvcCYufW+zmu0lB66A72eN9yI/L9iDsjU9\n", + "Pz/f7T0tT2tEv/4V/XaFf9ag9/TWGx4xGlPWMt60Vl7aZD2zRq1D12G0V9wZ6eyzrlbv503bhueH\n", + "xwC09SPb72nbsvhc0e4BWTV5PmdPybg5M5RHqlAoFAqFQmGZWDGP1KpVq7pT6/e+972IiHj9618f\n", + "EX2L1FbDc889150Y7Rmw9eJTvy01LBVO5Mcdd1xEjKwGTu4Aa3LHjh09T5Hfadtb5Arn9tTQP36H\n", + "TMSn2CJZWlrq1Shx5V2D64nToJ+WHUvl0UcfHbv3ULVin/JtCfh7PjfTNnXCXOHXNWyIoUP2dr7Y\n", + "s+LqubYwuJ5xRn/IkNVXwUKD72rXrl09jjB7kvBAZLI4/oA4N8YWDwUY8oJklcqRgTbwvDhmCtC/\n", + "bK4O8btxz1/4hV+IiIhvfvObY/cCrt123333RUTE8ccfP3Zv4PpBtIf+WlmYl4y79eC5SBuMq9eN\n", + "axq5ho3jXdr5gtyOX3P9H8A6Zz2cdNJJERHxrW99q9f2kMx4BYY8o/SbOYVMeDHsBbB3mBhMYkdc\n", + "Zd1r/Wc/+1lvrwV+m8Cc5f/2liEb4w/PITq3N6UdC1fazvoJzjzzzIgYeZrQF2C82YuQFZ3bE7xh\n", + "w4aeZ9nzACCj9ZG9HWHuUpWbuT7E4sC1ruHnmlWt3BH9twaZ19g8sW984xsjYjSn4e6MGO01rtjf\n", + "vnFqwT29bvjcz2j6z32slxauXcg8v/vuu8f6PwnlkSoUCoVCoVBYJlaUaw9vEqd5xxABe2I2btzY\n", + "vf+1xemMLn7LydinUmeaZZxBoI1zcAyE4QrMfv9qL5Ar/HJiN98Z2L9/f9cGVo5jggD3pH/2Etgy\n", + "83tmx2u0VoDfeXOvrF4YOkQf5tiz58WePWJmLGvEyILMeArNQWePHhaVs9kAY0GGEe3u27ev571w\n", + "1iIeN+aiPW/uLxYaY+NYgDa2DC8O68I8fp6L/Na6ddusRdbZgRgFkO+73/1uRIys+iGOyIjRumEe\n", + "MKfsYXC8EvE+/K6du652jkzsMd5L+L851+hvxinHPV21vm0/47fMqkPTNn0gs8oV8d1X5jrekA0b\n", + "NvTGx+PsNZvx1dH/H/zgBxGRe7zNr7lp06bu35bFWc7cwzFElp32GBvLDBib9evX9zyr9gLTJrol\n", + "sxIPir2Gnj94pNmz/LzYvXt3z+ufPVvQh59FrEF7ahyD6zne7tH2buP9Zc+yhxEwrpOeyc4w/+EP\n", + "fxgR/SzYiNFzzXpwxXpgjkrGFNksu2N2+d2GDRt6cnMN+jGjR8ZBa6zYQWrXrl2910Uoxg9SJlDr\n", + "Es6CXk0F4olg164DNh1Emk32xcXFXul6v9oxLQODwoLywmAwkcE0LkMbDK/gTErqyZgdxrIy+3bl\n", + "Zu7liP6m6gdE9j2y02bm8mbhoI8D6cWvgbxxZskD9JPNyPcEzAf0zN+NGzem9AsEX5vqxvPFr2gc\n", + "jGlZkH316tW9A4BfSTB+9GsSIbIDX92noYOXDzZeW8A0LA5892bnQFmu537tRuogWdM4Za88TX3S\n", + "ltZowdj4oe5XG20//RrQ5R58Pdf5cOcxykihV61a1ZvnpghB7izA22PH4T+TxQ+viNyoQ1fI5CQb\n", + "70Xoj7nLGs1ekbKvTE9P96itvIeavoeDog0qy8L1WRgCmJ6e7iU+eA0C03VZFq8LGyQmIm8NDOax\n", + "5zljZL2YSJj+ZhQ5loH5wuft62bTzpgIPSMtzozBLFwDvbf0QBlxNG0+9dRTY795scXD69VeoVAo\n", + "FAqFwjJRFDGFQqFQKBQKE1AUMYVCoVAoFAovMVYsRuqiiy7qBT7yTpd3ni4R35bOd7EyqBCgTSAI\n", + "lPfLeMF4Jwr9xIUXXjh2He9dibto6Sfa9vfv39+9u+U9MxZNWrkAACAASURBVO9msxL+gP7RB2gZ\n", + "oFpxcKHjtpDl/PPP7+IBeCdNWQPScimFD0UE790J2HZgOzQO7373u8f0RTwKcRv0/dZbb+3kdrwB\n", + "/aQ/yI3OAf1zmvDHP/7xiIjYtm1bRPRjy9oicegQuXlX78BE+mlZkJlgbQLDTREE1YILFq5ataob\n", + "f9PsuKgdYK6ZroLrCKp2WQxT0ESMxsPFDrkWWRgLF/lDFnQOvYkDQh3XCKXMu9/97k7HyO9YBfSC\n", + "zh3P6JR71v8FF1wwpjfaZ2xa2ekn8mYFM6F88Bo1pRBzkn6aOqNNNqDP6BAqDK8xgExc/5GPfCQi\n", + "oiuuyr0dCwMVRkZvtGvXrh61zVVXXRURo/VPm6xR/jJGjD/XITtjZaoVrm+D1Pkt/WBvgWaFvYQY\n", + "mUceeWTsHuzR7P+MCdd5D0OP7fxyDIx1znpGL06qAPQTWYADp3mOtBRUjtd0LBx6Yb64rA6yIONt\n", + "t902dj37A/pgDNibbr311t6+xV9kQ+fMLe+jjiVEn9C+8FxkPdBu+xzmWcSac4kFAr0zKiT0wtzO\n", + "9miud1zcjh07Op362YJu2XMdE8a6yFAeqUKhUCgUCoVlYsU8UtPT093pkIJ8zoQBjtZ//PHHu1Op\n", + "rXysHFKH/8//+T8RMfIaOZ2Z07BPuRmJbXs9cpEK35bkjxidiF1qwOn7wMUBOaFnmTLr1q3rUlzJ\n", + "dEQfTvN3tgUycA9nbaAnqDPQD5+3mRIeH8bRXgGAhYoX7UClFVqZXdCUdlpLn3+7n5PKWZBZhO49\n", + "B4H7T99f9rKX9UoOuMDg1q1bx/6fZVbau4RsTn8HGzZs6JHyejzRB1YqhLiQ0GZUOPSJ/rJm3f7a\n", + "tWu78UdeewOAywI468Zj1N4jYjRfGOuhonmZHrICe4wjBWgpzGtZ6D9UKZC+unBhRN8zy5pk3rrf\n", + "zAvTk2SZkswv1jyemow2K2LkcWO+ZHOKucl8568LUhr06f777+/GyeufceMvWa0Qo3vMnHHJnmXP\n", + "rTE9Pd3pHA+s91D6xTxnPCEWz8qfuFRHRhGzsLDQ80Q5s7i9toU9mBldDXMSfSNbG89jWp0sexU4\n", + "+5u92tncgOcuc9v0La3s/JbCqtaPyxnwf8aGOdyWNWiBXpkXbQHnrBSHPdB+jkxCeaQKhUKhUCgU\n", + "lokV80jNzMx0XiOKnxHfYwuD0yHF0nbv3t0Vn7NHCksJTxTX0UZG+UJcwr333hsRo4JlPu1yQt2+\n", + "fXt3uufETHE24JotWA5ZsS+/h8ZCPfHEEyOiX2Rx/fr1ndx/9Ed/FBGj0va2btApVgyWN2261gt6\n", + "QX8UVwSt1YtObHliEflUj1XA9xRmZWxs7WJ54PGjjD9F31qvARaU55CL4QE8bvQHK4nfWxbGDg9n\n", + "S2uQWZhYUugSz4GtQo+RYwbtaWg9m4xXVosH2d7whjeMyYIOLTtzEZ1jqWVFc2dnZ8fqtbTyW+eu\n", + "l+MCjW6be5tSCBnb2k3WA/PWxT8BsuE1ZqxM0groEx4OewLb/YXvuAdzxoV5gb1feMfZX9gfAfMF\n", + "ryJ9OPPMM3t7Cx4D1g79uueeeyKiv3b5PXuQ6/ZZdtcvm5ub67UJGF/2WChOXBQX8Dlz9eSTT46I\n", + "0RhYb3hm9u/f33mWWKcef/rB+DFf2AfYH4A9c8jCGFjvCwsLvXg0fmuPE3K7jhhtWp9t8dOIkdfI\n", + "NdSQI2K0ZzC/mWOe5/Ya4gVEj35eMKZ4au0tbdvHQ+S6V64TZzCWjA1jmcnOs5G+b968ubcvOk7T\n", + "xOh+a5ChPFKFQqFQKBQKy8SKeaR2797dWW+c1I866qiIyCkC2mq8rhIMbOVzqieOyZ4aTtKOHXDV\n", + "bYD1s3Pnzu47rBbHPDhrZdJpF4uCv3iwOC3bgtm1a1dnQWNZQOXgd972rGC9ZpWt7ZFx5kkb9+UM\n", + "B1c5tg5dmZr+2tLw9VhsXIcl23oNnSFl2onsHbmr1DMfslgQQHzH888/39M5bdOfb3/72xGRV10H\n", + "zNms0jegndaCt3VvWajci+fVhKHA8Vquum49Li0t9SgusDxZS5bFFEv8LqN8oD3HErb6YV7aG4Yl\n", + "7jXEembvyahf3L49UXjVW68B48gcwjp3thIwLQu/wyuYxTHSBzzia9as6Xne+S37oKtIe980pRb7\n", + "QRY7aO/Jxo0be/QrgP/jMWC8MxoXdIu+2PMYS+akZdm7d28nv6unAxOI02/WbEa1hf7wYDEvhmhr\n", + "uDZjjwDORkVPzEnPF1Ps2KPb6pFxob94mJjf1ovJ3P0MzuYisnIdbxvaZx3jjSysY+aY9zvaRmbG\n", + "FA+t5xfXcx+eo5s2bepda0YIV0P3mGUoj1ShUCgUCoXCMrFiHqm5ubnutHfCCSdExMg6yuKYiOuI\n", + "yK15v3/GU2PyUsA9sTA5QWf8Zpya169f36vv5JO0M//43jV83CesGn5PH4ZijWjLcRKOp6D/WMOt\n", + "LlsZAad+Yqgyz1V7ra/BarGnhu+xhnwPxwJgqWF5cj19aNu3pc08QNfup2On+D2Wlb0jyGyvwp49\n", + "e3pyM36OpWOuWZf8n/k+KXOkrTfW1rNq+2PgkTJ/WcZBaBJvjzWYnZ3t2sIjQD+ytepMt4w7ztmg\n", + "ttjbMfJvyb7LuNZcX851hDym9Im9C88V7bSWt+PV7EX33sKcol/EENF/980xhuxtWO4t2LeQiWv4\n", + "TbZGadtz2Z4pZGQsjjzyyF7tOWDeP9ey8hj5jQX6YS47W7pdFyeddFJEjMbAe67j9OzlzPTiNxkZ\n", + "f15Ef62go4wonDYYbxOvA3v87S1q++psS36TkRbbk8c8AJ67Js72/Ghlt9fObwPsBab/2dsi69z8\n", + "sG3sqT1M3lMcl1pZe4VCoVAoFAr/wyiuvUKhUCgUCoUJKK69QqFQKBQKhZcYKxYjdd5553XvRrN6\n", + "Mtdff31ERFx++eURMV5niXf1vAe+8847IyLi2muv7a6J6HPn8f9Pf/rTY23zPSdO3h3zf/iQ/vAP\n", + "/7CTkffivKPnvfDVV18dESNeJjxwjgFDxs997nNj1/t9PjLw/hYOoquuuqr7zLFA6JBr4XFzPR1n\n", + "lMDNhV6Q0VWa+XvdddelnIIG/FO03cYXtbKZ3xCeKGextdkfcD7BP2bdOV6Nts8999wxGbmO9/j0\n", + "Ex40uJmc7REx0hV8Vea3cjYe90AW+K383p71QUwAvG/MF+ZAxCh+oB2fiIgPfOADETGaJ14/rC3r\n", + "EbT3iBjp8Y477uj6ynhwD8eTwVcFXx0yemxYo3DtwZ3FfDHfH/q5/vrrO/4xjz/z27xstA0cv0Rs\n", + "IfsLenGNtJZnErnhtzQzATJ4PM8///yxe9MmcZD0F17Jd77znWOfs2fNzMx0/UDn7KXmQCOLj3t9\n", + "/vOfH5OdecKYOvOw5ZSLGI3p9PR0L2uPfnq/cDwN85415/WP3ugj7bPXwbc4OzvbGx/6D9cicmex\n", + "Q8jGvnjNNdeM6YW93PphHV166aW9Kvt+NvEsgiOQ/nNvzxfGkj2ddtA9Gaqsi2uuuaa3Lzq+kHsw\n", + "zxkj81marYJ19L73vS8iRjG6Xh/r16/vrj3vvPPG5HMmJDLCncdcdJ1F9GM+PPZFxyZPTU1111pu\n", + "68WZwYx/hvJIFQqFQqFQKCwTK+aR2rlzZ2ftUR8oq93kk+uqVau6k6NriHAK5STJCTTLYuJeWb0I\n", + "Z+20FX6xuLI2kNeM6VldKKwlc8nRV2d/zM/P96x42nR1YCwEvjcvmmW3Bec6JK0+kSvjmzLMwUb/\n", + "7EUAfO+xoJ2WP9EWNDLRZlbri7/oI8uss37bvniO2Vtor45lcbabx8Y8kW0FcVuMrlFmj6U9LlnF\n", + "X3tH0a/rsSwsLPRqd2XZrNwTa76t8zJ0vT16ztZp9W4Pq73BnkPsH66TlMVC+HNkGOIVdM0txhWv\n", + "hVkZzK3nNev176wt9os1a9b05or1MWl/dOYt48688bowp93GjRs7XTurKqszh/zZPuKxdJ0u0HJy\n", + "so7RpTPCkc318vjr8fb8RwbGbIgvj/6ZWzLL2vNehSy+nn7iVeI6Z5628mZVwC23x9dvi7J6jK6V\n", + "OJTlay8h677NtmxBG/ylf5ksxtC9DXvoMm7WDOWRKhQKhUKhUFgmVswj9dxzz3UnbqwYW8HAJ9ep\n", + "qakeBxDgt/akcBK1t8txGlgYfu8MWqvbnjJbmD6Nu3KtvWlYT+YUy7iWNm/e3N3bHpis/glwRVt/\n", + "z7tus3cjWztG3AvLwBaYYUt1Uu0jrjMXFe3DBxYxGj/kxdthTj3Q/rZt27FygPaYs1ioP//5z1Om\n", + "eDOm27sHmMvEOLiumMcf2ffs2ZNynwF7e2xpW3Y8NMxJ5gE1zbJq1RH9mCCDyvTI6Lgu8yQyphnH\n", + "Xut9yzxSILMwbeWCTC94YMCQ5e36aPZIZNXn6Q8ezMw7hj7YV1r9eN4Sx8k+Yc+9PTXoDxn5iyxe\n", + "2+wXLY8g/fG+6Hva++X9n/XAPakm7lgi0NYMdG0qX+uxyTzxgPF3LSzGyvPriSee6PYtKs+7Lp5h\n", + "dgZkzp5F9mDRp5atIJMbeJ57b7L3MKv1hax+izD0LHCMk+ca8PdtLGBE/80O+rO3dUgGexjd7+yZ\n", + "ZJRHqlAoFAqFQmGZWDGP1CGHHNLxlGGROlsFcGpsPR9ca44wx19w0uQkbmvHFU3N52VrEI/EzMxM\n", + "d6I2t5jl5sQ8ySNhlnh+jyxD79+R21lJrh6LByWLL3E/+T+WrE/z7Ri5ajh/M+8Y/WJMkC3zAnpM\n", + "7XXA4mt/i9XHd3zuuYWninHld86UBOiPMWo9do5LskXuftlbwnWMHfPKenVfN2/e3OnYld0BHGL2\n", + "LNBvW95kczneKfMar127tjcPuJevxWtBFWR74LLKxvZIDsWa2BPlPcVtc529R85OAvaK+T7tGLM/\n", + "ILe9RLZ22Qf5ncfQXkDaQ4bWi8yaAngBaYP54HkAXE3aFfCzKv5tPB9rJKvITduOdbJe2FcdfwO8\n", + "LzI2c3Nz3TxGl67ITb+8fzrjFNj7gd6Yk5atnW/8O/MwIgu6NLuCf+dsTo9RKytyORudtWePpKvw\n", + "m2XBa5p7ek93HHH7mT1GzrIzXJU/4zD0WubeS0tLKTev9xJnHU5CeaQKhUKhUCgUlokV80ht3ry5\n", + "O7Vy4rZVDDihcmpev359ahlzGnX9oCwbx0zR2btfgDW9YcOGXsYDFiEwb4+9RJnnxfFcfJ5l7bRy\n", + "O7YBcHp3hiG/syVlvZkHaWissrgsf+5MMHOSGUPZWW27Q+++3T8s8Mw74jg9xo75BOg/1jZ9WLNm\n", + "Teq1s66wCj1GxDFgBdsrlulxw4YNPU9j5gVAH55jbtv1huxNNaanp7s5Zst7Uj/5Hp1mMRJc7wyi\n", + "A1n9bQ2ZIZiTES+JayABW66u29Z6ahhn5hjIMsJoG1mcITrkBYwYeQHwSOzbt6/neXGcGchiyRzP\n", + "Zd43712Og1pYWOjF1QB0OylLFzgrzbyI2b4xNzfXW0tZdiIYmlNDMLcgv7Nnb926db1aTOwp3lvs\n", + "ec7qjrVtR4z04IzDdkzQeebNG+LOHOpvtqYta8Yj2/7b/ZnksfO6yd5gWaY2Yzfbv1zLzl71SSiP\n", + "VKFQKBQKhcIyUVx7hUKhUCgUChNQXHuFQqFQKBQKLzFWLEbqkksu6d6V8l6VGCPeY8KHdOmll0bE\n", + "6L39s88+G0cfffRYe/APwYXmd7TEJ/GuH64dOIieeuqpiIg44YQTxn7Pe2x4nGh/zZo1XdyBs7L+\n", + "8i//MiJGnE/EXRCn4xou5hRDD8SSbN++PSJGMSLIcuGFF3bxM7ybJ0PogQceiIgRjx88Tq7ZAoiz\n", + "QBZ437gn17vm0yc/+cmUU8xxN3AhwZ316KOPRkTE6aefHhER991339j18D7Bh0SsAfrgvfbmzZvj\n", + "hhtuiIiICy64YEwPjpEhDue2226LiOi42RgLridbkVpNzBdkRwayXhYWFrqxMI/jgw8+GBERZ511\n", + "VkRE3H333RExip1BFuYL405MoDMOkYUxPeigg3qVpbkWXja4Ir/61a9GRMTv/M7vRETEvffeGxGj\n", + "OCxkMR8i68CZMvAKXnrppYNxY20/zSnH3HL2K3OL9Q83nysgoxd+94lPfKKbi1l2Gf9HH/Qzq8mD\n", + "jHCsXXXVVWMysKaZL88//3y3PllDztaz/PDVwYf4ve99LyIijjvuuIjox2lwPXpBv20NPPM4wv/J\n", + "mjvllFMiYjRWnufokXmFHohfYk9j/FlH6GHPnj29+DHrnLYZb2eQshd96EMfGpPRcaDmCWVdHHro\n", + "od289Z7EHs3+75gyx9dYloceeigiIk4++eSIGK0f9m7W0Tvf+c6uX/TT8YzMF/jtWvaMiD4HKTpH\n", + "j6w7xubEE08ck+nGG2/sni3MV8aTuWluRsaT/js2ENmzPZ15gD7Wr18/9txqgdzspcgN1x77omOF\n", + "0QeytHtRxGjP4rodO3Z0eyvzHJ27Sjxrir/FtVcoFAqFQqHwP4QV80itWrWqs5qeeeaZiOhnwgAs\n", + "Gq5bXFxMa4446+oVr3hFRPRZ7wGWCB4uLK1HHnkkIvpVlpFlx44d8cQTT0RE37oDWOS+Z8ZNh0XJ\n", + "KRhLhn47U2bdunXdafwNb3hDRETcf//9ETE5EwaPCnWUbDVzL2f7IVNbdyTLjOK3kzKm0N8Pf/jD\n", + "sXtYFioa02fGBiui7QdeDtficj9dZd21qpzlwRi5ku/OnTt748PcwjuGFYhlfdRRR41dz3zhdy1n\n", + "WCsjaLMZqZfDeFpuey5f9apXRUTE1772tYgYWYOA+cPcQyZqP3nuLiwsdNYuc406cc5aY41xT8YI\n", + "/dAOyNbLUM0sV9d3lmpWo4ZxxYJmP7BHi7lMH1/5yldGxGgOtrV7nPnqueU1Sht4FbGkkck1jVyH\n", + "5/vf/373ezwCALkYx9e97nUREfHv//7vg7JwPf084ogjxv6f1TRDP88++2wvSxkgg2veZfEnzAfG\n", + "0nOQtwmg9VTgrTG3oOXmutZ7EdFfo/aK8Abjv//7v8faA5s2bertmfQjywjDU8dcZU1nmbi0yx5w\n", + "7LHHRsT4XOTf7D2uVeWK71zv519W6Zt54SxQ/rbtm1WD/QD4eekaefSb67ynm+WjrfjuWn/0hzpr\n", + "zIPXvOY1Y/eahPJIFQqFQqFQKCwTK+aRams6YKFwMvUpECuAiqatVWnvBW1h5WBZfutb34qIvD7G\n", + "McccExEjy9QVbgHW9f3339+d5s3a3vYxYmQx8D2nfFsk3Ou1r31tREQ8/PDDY9f5NL2wsND184wz\n", + "zoiIiK9//etj/Qe0gdWL7KeddlpE9C1MW2783/E77W8dh8D/LTfWC140rHqsQVvetGPLi7HGYmuv\n", + "xdKgrawuCJYS7/axBrF6rRfax8rBKnrZy17W8/oh7+/93u+NycTYeJ7bG+rq09YjXoennnpqoucF\n", + "b95v/MZvRESfU9LWLp8zT8z3N8T7hQzI5XpBwPFowHEpwF4hfjfEcm/vlbk2bVEzh7BI2WvwRGQ1\n", + "jdwXPHetrIwFbfCXucUYADxPeGiHYp9aMAasB+bu6aef3pu3eCJOOumkiBhZ7T/4wQ8iYhTrA/ge\n", + "PSBzxg/HWPD9zMxMtzcjH0AP9ryzlrwu0Pnxxx8/9j2fZ16mnTt3powNwJ4T+PBo2+sCPeI1ZN+g\n", + "j8S1gdnZ2U5e1/0yEwZjRluuk5Xx4bkW4hAfInuRvcaMr73G9nYCdOuYMv7PcwhOTsdURYz2eZ7n\n", + "zD32PdckA+ZYzWCeVfRx0EEH9eR2tXTAXpzNd2NFD1Js0jzsssEzgey6det61B+AyYQrmldYLADc\n", + "noBJisJ4NcaDw4psC5gNuVCHwObOZGVCeJNGFl4ZEjDuIFuwd+/ebsC/8pWvRMTo8EXAITCdBJtS\n", + "VuyyvUcLFkjrfnUpfm+E/r9fcfznf/5nRIx0a1n4P4e4rVu3RsRIn237tMHc8uE8K96G7jkEmFIF\n", + "+PVbm3BgXbmY6Ze//OWIGG3Wpp8xCSuvpR3oD9pXgLwmcwFNX8uG8aUvfSkiRhupDwjcCwPDND7G\n", + "wsJCN6cA+vD4MwY8ABhXDhJ+eNEXk/jy/3aN8p1pmRg399P0M/w1lQ4wNRX6Zp/hwBHRL3bLA8KF\n", + "aIEftCQpZOSsxqmnnhoRL+jPewUyMCZf/OIXI6JPZgzYizFSWA/I7n3Xv9uyZUvvdQ9wUUfGLyMK\n", + "Njk5v2csbXih19bwyA4AtMGeYqLgbC9Clscee6zrb0R/v2z7w4M9KySJbl141hQqgO/Z23EaeI63\n", + "16JLZOHZkhnSNkgdMO8+OixhyDhCPhujpnMDnpvs6aZnAvyf/YHfb9q0qXctemHdskazfmaoV3uF\n", + "QqFQKBQKy8SKeaT27dvXK0/PidSvpbBoWpLGzKvjkzeBiJw4be1ymsfC8GspW15tqia/RRa/qrCF\n", + "wV+8GLYC6B9WDnoxkWoLPrvnnnsiYmRJ+RTP/wkARgb6ayvAVoNpCNpXGMiHzkwQmwWm8jqEMcLS\n", + "yIKqsY7Ro9OD23/bQsIit4XJ507FZ5ztBfKrozZo023j3cD9jzcPz40tRzx1ppDBYssCQjdu3Ngb\n", + "V1tSrCk8C3hQsEztHfNraHt0/LptaWmps+bwMPAbe3VMDUKb6NzX2yL3+Leu/uzVDXrJ5jn6Qcee\n", + "P8Dzgb4yd9v9yMkWftXpvYV+MCdd0iJL2vD6WLVqVS8A18HnzLVs/J1sgieTzy27yW3Xrl3bC5MA\n", + "phNBZ5nnzUkl3pPcfhtywXeZt4vPmRd4RTPyb3vwTG7sZ0D7+pZxQr4sUQrvMh53v6YG6ANPlIOy\n", + "27WAHniLwpzKKIJcmsiyW+dcbwoa+ui9q/2N9zfL4mQbk9tnYShc3z7TLTfXcD5wCEzmeTXKI1Uo\n", + "FAqFQqGwTBRFTKFQKBQKhcIEFEVMoVAoFAqFwkuMFYuR2rZtWy8rAU+VKWLOPffciBi9h25TSmmD\n", + "UvWUn+ddqDOCOFFSIh7KBxdmdPYT10MRs27dul42Fe9ioeWAZoG2HY/AvaBOoFw9IM7BadKf/OQn\n", + "I+KFUvjEpfCu3+m8UKdQwp9YEGIkeP/M9ddee21EjGhZ+B6ZHWvwqU99qivh73fVLotACX+PkVP3\n", + "0Sc0DtAVOCaiLQSKDqF8cGq8C+khi+lnTMvCvaA3QT9ut23D9BOeH44JhMYD6hTG3e/zAbJAhbBp\n", + "06ZODscw0DY6p2107jFDjx5TjyX/Z41ec8013bXEFzi+5LrrrouIkc753jExXqOsC8dGOf39r/7q\n", + "r7o1x2fowfFU6IX17FIdTn+HroL2vW7a2Bj2IveTMXIcHzr88Ic/HBHRizVjn6EvXAdFDO2xtp9/\n", + "/vnunuwVXkMAvTB30TnzHH05A5N2oJ6BDod2tmzZ0qP8QhboSrJ4NPrLGLH/EweILOiTe0JBgl4i\n", + "RnGKxAZyLeP5wQ9+MCJG693xePT/Ix/5SES8QPkS0c8cM5D9kksu6caCtdeWjmllQS9Zlh6yMEas\n", + "f2KpnMLfUhChE++xbpu5y97lthgrxgDZeY76ecFc3rt3b/csom3kRoeMkfcur3/A+Jsihmed4zh3\n", + "7tzZrVPk5lr0gdyOkft/RRHz2GOPxa//+q/H6aefHq9+9as7QX/yk5/EOeecE6ecckr89m//9tjE\n", + "uOGGG+Lkk0+OU089Nf7t3/7tgDcvFAqFQqFQ+N+MA3qkZmdn45Zbbokzzzwzdu7cGa997WvjnHPO\n", + "iTvvvDPOOeecuOyyy+Iv//Iv48Ybb4wbb7wx7r777vjHf/zHuPvuu+OJJ56I3/qt34p77713sIDW\n", + "/v37eyfGoRocyBExOnnOzs72rDrgE6WtHZ/yOdVyksYayKgkWuvC/bJl7boYfr9q2fne1BJZ7Z7F\n", + "xcVe9kiWbcLnzpDK6ArsechoYIaQFeb095bNBJnGpDozrZzozNadf+uMKsbKdVCA6xS1GSSZR873\n", + "or8uPOcsR9dy8fxp74c87RppwVyyF9i1jYAzRSeFUu7ataune9cuA4yBvWNZnST6wrzgPkNFcz0G\n", + "Hv8sg5Df8T3rw2PkdWEanzbLLys4mq1n95+9yfcEjBFj29a+yvbWrKaT23ZmmQubeh1Z9v3793dt\n", + "ZGsO2PtnWfD+IGtGig4YA2cutt9ln5uc2x485qD324z25/nnn+8VkkRXWV045g16yfZo5qYzKe35\n", + "buG9xW9iDM8PE1EDk8I7u7u93pRQkwqP0n/Ww6R90Zm5YGZmJt2jTfGEbC9JHakjjzwyzjzzzIh4\n", + "wQ33qle9Kp544on44he/GO94xzsiIuId73hH/NM//VNERHzhC1+It771rTE7OxvHH398vOIVr+g4\n", + "iAqFQqFQKBT+/4YXHSP18MMPx7e+9a143eteF08//XRXOfyII47o6uM8+eST8frXv777zdatW7sq\n", + "3cbatWt7Fib/9+nYsTQLCwspkSmnW96NU1uFOlGZNWhrkZO1ZWnpGmz5ZDVKXIMjq5fj98+O87Cn\n", + "ZseOHT1rhdO4rTGsAF7Dog+svawSNid1/qLfVu++ty1LW6DIknls7AWgfcYmI7Fsv7MllXkwHQPk\n", + "elPZ+EPjwDzZsmVLj2aBd/605UrEWS0WrKFJljd45plnesTW9oYw99A93zP+Q9Z7xPiai+h7BcDj\n", + "jz/e8yzYYnabXO+2s/gNZCd+cahqMm23RKXt5x5/e1oZE9eIA8T9OD7S92mvsecsi08jxoX1z5gi\n", + "Q0adZC/a6tWre3J7TvGbLGaG+c1853rG1B4JYlF5Lhx88MFp5WnqxnksaNufZ4TDQ8wG7pOJa90G\n", + "NftM0sw+Z53TF8ekIrvXdBvPa0+U1wVtueaXK38D9iqev8wXe3pauKp+RsuU/T/z7MII4jp2zItW\n", + "LzA2UE2e75B7ktfQzxfPRfTseTE/P9/bt6CGQsf28r7YOlIv6iC1c+fOePOb3xy33nprj6l5amrq\n", + "gK97su+++tWvdgo44ogjOiqKQqFQKBQKhZXE008/ywDnigAAIABJREFU3QvgzzDxIDU/Px9vfvOb\n", + "4+1vf3v8/u//fkS8cPDZvn17HHnkkfHUU0912RRHH310d8KPeMFKpeqqcfbZZ3fWwdzcXMzNzXUn\n", + "SJ92fXqempoarGrc/pbvsV6zGCnHADhOyWgzjZCHe2WkxQCLIntH7jgtvxP2SX3jxo0979bQe/G2\n", + "P/b2YNUNVapuP7dF1x6QudbWvSvXWxZgi93X2zuEXlx9uf3MHoJML64ePsmCpT2TIc/MzKRV8+1R\n", + "zOISGBu8Hs6osteozVxlHLPK07aCPR+yOCZkt+fO8+Wggw7q5i9/s6xD4CrI2fr35xnpcSun5ePz\n", + "rAoy1ztOw/ewx5O/rM1Wdq9n6y7zpHAdWb6Z18iVwFuPVxbT5j0ki0tinni/oE9DpNURI4/33r17\n", + "U8JXvBTmQxwioY4YrQfWnLkWM89OxMjrOcTI0LbJbxyf6vli75jvPRTHRn8cA5XF6zjDPIt7tAzs\n", + "AYxZO1+85/JdthdxL68L/u8xsufuQJ/DqoA+kM0efMueZQ5n54Us7ndIPr9NmZ2djU2bNsUrX/nK\n", + "iIj49re/Pdg/cMB3BktLS/HOd74zTjvttLHU/De96U1x1113RUTEXXfd1R2w3vSmN8U//MM/xNzc\n", + "XDz00ENx3333xdlnn31AAQqFQqFQKBT+t+KAHqmvfOUr8Xd/93dxxhlnxFlnnRURL5Q3uOKKK+It\n", + "b3lL3HHHHXH88cfH5z//+YiIOO200+Itb3lLnHbaaTEzMxN/8zd/k77am56e7k635s3zidTvcaem\n", + "pnqxCYCTsuORbIm4bX5na8FWYyuD4xCybDRnTGUxLxnfld/bg9ZC8SncFoNjR8wl6H5mfFaOsWiR\n", + "eaR8revHHKgmz1C/HTs25B1z21lcmjPosDgnZavxuzYewXJyb8/zSXDcxaQYqdnZ2Z4VmsUZOcYl\n", + "yzbKMk0zPqw25tFezMzCdLZZlrVry9w1n9q56xgw17ayVY8+Ml1nni17/sxF2cppr57jq7J+Mrfs\n", + "BQPWV+uF9fjY4zApCzfzDmd7mD2We/fuTb1A9t4xfubrA461cl0mw/vJkPwgi5k0T6LhtZ7ti2vW\n", + "rOmNf/Y2xfOZ77NMOe9xxAW7zl57TRa/6rZ5Fjn+1fygwB4u9DAUY+Q6YHgu+TzLdgXInnnqnFna\n", + "jrH7aY8r8DNqEg54kHrDG96QNvSlL31p8PP3v//98f73v/9F3bxQKBQKhULhfzOKa69QKBQKhUJh\n", + "Aoprr1AoFAqFQuElxopx7V100UWdZ4qSCm0dlIiI66+/PiIizjvvvIgYj/L3u01zirkSq2OB4GWC\n", + "98eZD2Sf8B6X6+HmmZ2d7ep9EJdBDQ14eVrOp4h+rAz9h9/sggsuGPuc069jgqDq2bZtW6czV2Km\n", + "P3AKwZ1G/9G5M+ssO5+7xgfxDJ/85Ce7RATXPfJrYcYIDjJXk3UsmfnQHO8Gt9jq1as7Liy40Fxx\n", + "2pWZ0SF6oT/EGTi+A54oc9Dx/dzcXDde6Bwdupqw47CQhbno2Afzm8FZx/WLi4tjnFYRo7lz6623\n", + "RsSIr4rYB8adcTXXGuvI8QrIzvXM3SuvvLJX58sxIS3/WNs2ay6bi4wp+nIWT8sTxrWOT3Lb8BXS\n", + "T2epOhYK/kTG3zVt2vpa7BWeK1mdHHT43ve+d+xzrmcPYn+57bbbxmRn7NHjnj17un4yV972treN\n", + "3Zvv+Q0y3n777RHRn4uOrWGskcX7y+bNm3sZvvD3wSnHXPV6YKyYi+9617vGZHStNH73mc98JiJG\n", + "626onhb9Zj2jc9f8cryW+8lYuAaS59ef/dmf9TLBPcfgZvV8QS+OMaRtc/Oxp5uD7pZbbum4EL0v\n", + "cg/LjSx8bk5X7skYsae7r9xv586dPS5E9v8tW7ZExGg+mCcS2R0b54x777uuv7awsNDJg9wf+MAH\n", + "xtpiPSAL5wD4MDOUR6pQKBQKhUJhmVgxj9Tq1at7XDlZlpfrpSwsLKQVlm1x0aYzhNw27ZmjLavd\n", + "0RYizTjlnF0Askq9rpdji9uytHpwhkKWjeIqyCDTub1itNv2KRuLSeF35qvL9JJl8w15vpw95X5n\n", + "dWGAMyd9vTPMWmsx4060foZ02Mpujq2Mo43rd+/e3Vs7GedcJkOmc9f6yTA/P9/LBMuyDbH68OR6\n", + "H8jqq6Fzcy4OVTa3pyirJ0a/3HZW8T+rUzWkR69j1xHyfHF9qUnVp52p2WYeZ0lCrnuVjZWzHifV\n", + "yLO+9+zZk9a/ok3XG8v2EX6fyWxZaLflImWteE/yenFNwCzjEK+P34wMZRyznp1Z7X5mnrasdpsZ\n", + "NVwrcWj9ec9xtiXIPPrZGHnOkok3lBXoLE1+w76Q6cXP8KwCuvva7n1ZfDY6n8RBm6E8UoVCoVAo\n", + "FArLxIp5pGZmZnqnWNesAD7BtrUsXM/DtSUmMW47bonTL1WFfeptubjMy5OxVnNv10/JKvLaInG1\n", + "dsvefpdZUryHzngNbb24BpDj19oxsufF/fHn1pO5CG3l2YtC5V9kaOeAdUvbrqMFsOoYG88bX+8a\n", + "SW3Nl6zKvj2umZVj1nZ7omxNcf3GjRu7a7K6KHxvDsUXm0HL+LuGE2j71DIQtHIaWeVmzxd7ZB2L\n", + "1fa59Ua012SVzR1j6LgLeyxd6dlj3HqCkMUeNPcLOF7N897wXG+rVGfeUWRxnSBTf7nf9thn3udW\n", + "f1kVdO+b3Is2YaMA1oe9TPYa8v2ePXt68YbuF7/le3vJM08d7aJH15Vr+4pu8GJla455zNq0hz7b\n", + "//kd96Ev7Zq03OY7zZgtHDuY8ad6XdijeaB9hjgknlHZWwCPYfZ2JfOiTU9Pp551e+aYs1mtst7v\n", + "X9RVhUKhUCgUCoUeVswjBb9eRJ9TLouF4bS/b9++iRWc/Y4z8wI5JsrZBvZItezvtjR8MnZlc8ex\n", + "+JTumAJ7brL39W1b9Ns69Ht6fptVk7ZFby9J+07dcSmTqsF6LGwtZeNvXjhnZrX9smXUVlxuYSvP\n", + "fH6ZN8XVh1evXj2Rl81ZSR5/e30m6RUZ165d25uLniv2Apgh3W3bS4Bsng+Wpe1vxilnr6nHwB4p\n", + "Z0i50nWr9yyuxB4EYE411lzGWcg6sh6GYskc+5XFTLqfrqqcWd6OjQGLi4sT40yyuQoYT/pniz3z\n", + "rrWyZ94L+mmvt2Na2v5E5ByM7v8QNyXjYo8EsnhvtgceOMOQ+cDvPZcj+hlvIIvvpQ3fO/OmZrG1\n", + "Q7yPjqfLPO/2zPK949QAMVGeu97zIvreK+9vHiO8Z/bsM0c9X+z5a72LnrdZPCqfv9gym+WRKhQK\n", + "hUKhUFgmVswj1Z6uHc+SXdvGZWSWsT0FIGNzt8VlDrrMCmzjEDKOQMcumGMpy9qzhYGMQxkX9rhZ\n", + "BmDLAAZ2YA4lx/PYarQcEZNjYowsG8lWgL0p9o61Y+q2svlhMFb2aGbxOvY2zczM9HTPNc6myeK1\n", + "QFYDKYs1a+vlOFbOsthTk3mBAe1m3hWwtLTU0102Zxzz1HLEtb8DthazjLy2LXvFsng9/p/xdRlZ\n", + "RtnQmnZMF8h0znXofFJ8J/C8GpKduWarPpNlSLft50Pj38o4OzubrrWsJpW9IMDxOY5Py+I7W09t\n", + "xiln+b0u3E+vTXuk/Lxo43I8RywL13lfcNwfcGYd7eF1bT1g9kTbO2pvmWu1Zc9J4DV8oH2Fz1wP\n", + "yny3wOPv/SPjoB16HmXZhn5+Zp63DOWRKhQKhUKhUFgmimuvUCgUCoVCYQKKa69QKBQKhULhJcaK\n", + "xUhdc801XQac3/Gb9+s973lPRIy/53ekP5xi5p9yhg+A9wtOIb9/t9fMvG9TU1O92CV+gyy07dgO\n", + "xwDAtQbvj+MQHPfScgo5W8bxAvB4mffP8UYtL1NExOWXXz52vbOawM0339zxm2Wg34wnegHUsHEs\n", + "ANxcXO/aRW1MDv00/5T7Z347rieugPF31qe5HF1/ZnFxsRs3+KrOP//8sf5lcVjwfn3wgx+MiH5M\n", + "lbPcaL/lQ3OcALLA48W85TpfzxzjetacM2y8Vpnr27Zt69Vkc9wE/bz00kvHPqdtxoD5AtdWyynY\n", + "Xu84tZtvvrnHneeYDvMhMv6W1bEecO3RPu2xz7QZpxmnoOOTADxu5557bkT0a7U5Nor2r7rqqojo\n", + "xxi1axQdMv6MkdeFxzPbL5wF+bGPfSwiRvtFy8VGP+kHbTO3HLdkWeA3Mx+mx5TfweWGLNPT02lm\n", + "G+sfHldnBnuNonOvi2zfZa5feOGF3XzNsljRodeFY3DpL/PF88v1pNDXLbfc0o2n9y2vIdY/e5fj\n", + "1tzPO++8s+tnKyMZ9u26gzsTuT2OHl90bv5Mr2Xvi6xp67mNMXPbjreyXuByzVAeqUKhUCgUCoVl\n", + "YkWz9jgV22vkzAcqn7ZZcPzb2TbOBHG2QQZXH/ZpF7SnZ7dprxf/z7KzbGlm1XSBPTKLi4tpPZAs\n", + "q8b6yTIlXG/nQHxYWUYUsGVA23hB+AvXkkGtF1cpHsqUIoumrWs0JEMmo/VmvZhDqvUaeDyR28zi\n", + "zgwCztKzN8ig3Z07d3ZrxlV9AdWikZGszSwj9JlnnomIfj0leybAnj17etk4nq+AtljXWSYdcEaU\n", + "eTBb2bP+8JuMI8/rwlWigTPohmo4+d/OpstqMXkt2kNvuLJ3m3nr3/z4xz8eu5YxytrO9OEsSIAH\n", + "gnb37duXVs+flEFpvXjcnbHtsW7fXNBfV0MHWXars1XBT37yk7H/b9q0KSKG52LEeMV47w9ZxXfP\n", + "yWzvYv0wB51p1uoXubNK754H9m5N4trLuPXMANG24VplwGPC/82LmV2fZVq29wY8i/gN88NvDyZh\n", + "xQ5SU1NTPdJNCm9lD5j2lYfLFIDsQcLAesKwAXgSZ4cCFsbu3bt7BLZDfRz6fyaLJ0zm2m9ld1Gy\n", + "7EBA+X27ujNCYO7pYqNDD/fM5ZrhkEMOiYjRQcNFMA3mg9N60U9LEcJhxfQcWTHEbMPMrme+IUtL\n", + "ueOHLnK1B562PxmljF+/ZTQOhx56aES8MBZsZNmmyzxHH+g+m1v0hf7Z0PC627JlSyeDdZ6RELs4\n", + "ZCZLRubqh3zbtl/RZtQmbtuHdPfTDwYOC3412H6WvYry3Nq6dWtEjB56k1KwPV8831ogF+POes5o\n", + "VjhoM2dd/DR7wNDnww47rPdKCrCHZqVGhkoItHAZmSylvX3GZHQ1UIFZL1k5GQ5OjDvXu8AtWLdu\n", + "Xe+1WEY/5DnKms3KH6BHQmQYK8/99lpT4GTlUtAT48newzzwXoQeMdj4a+OwbdNrya+dgQ0zxiDT\n", + "uV+lt892X/vyl788IiKeeuqpiOiPqw/eGerVXqFQKBQKhcIysWIeqSeffLKzFmwVZkTBrZXMaTMr\n", + "JOnTfVaQLaNt8V/QBsjaDZy92rNl6RM5wCPj4nlgiOSUE7M9BllhTvrvflsWTv18biuwle1AhQCH\n", + "wHhixdizYD36daWDdvGERPTpATICbIDl5FcWmccTmZm76KUl4QZHHXXUmEwZeS144IEHxmTGu5YV\n", + "n6X/GzZsSF8Tg8MPP3xMBuvYMuHBdAG/LGB206ZNPS8m8LzFgrYlOun1K3PyQAU/22Dn9t5ZsV+/\n", + "XrRHyr+zF+1AHmx75Px6LKO3csAz8D0effTRMZmw3Pfv399r+4gjjoiIfgHJ7NWePfWMWYZHHnlk\n", + "rL2NGzemlB/2yE0qKIoMmcfNY/Tkk092/zYZs/XicAI/N3z9YYcdFhF9b8hQoH/EC69Uh/bMiL5O\n", + "2cfQoZ9J2R7dvk6NGJ7rBx988Nh3TpCy3KZOcR88RuglK2Td6tGeyqzIMfCe5fVkWTIarCGPFDq0\n", + "N3TSmymjPFKFQqFQKBQKy8SKeaQi+gHhWYqlg9JXr149kfjXlBlZ6rGt/Ywqw2hPqsiQlarP6EYy\n", + "rxHgBJ5RCkxPT/feuztt3/eyRWK6FWA9HMizk3nv/L1/aws0C/DPSC6HaAgy4uNsbmUEyFngv+NS\n", + "Wusoo7YZillovwdZ6m0WdDoU3+CYBmBaBXtcMoLsbD69mCDMjPLCc886z2Ie7OEYIqK1J8FjciAP\n", + "c/t95j20Ryoj923hvSqTLYvrzGQHHsP9+/f3xtNxd9l+4Da9LrJx95psZcgoghyvk/XP8TrugzFU\n", + "wiab5+6PvYX+ns/xAnmP9lzfu3dv7xmTeV5dJsHIxshjNRTXk63fzOOSzZPsues+WMZWpiyQO9NL\n", + "tlc5BgpYxrYUiu9JbJzPCS82Sa2T8UVdVSgUCoVCoVDooShiCoVCoVAoFCagKGIKhUKhUCgUXmKs\n", + "WIzUtm3benUkeAdKjZ477rgjIkZl/HlvuXHjxl5tDcrPX3HFFRExOjk6/sKl8N/97ndHRL+ekrNa\n", + "PvOZz0TEOF2BaVPox2c/+9mIGJXN93tiZ865XD3fu84WuOaaayLihVL7WRE3+m36AfqZ1cuAlgG6\n", + "GsfWuH7SzTff3KM2AI6BgTaBtj02yELcATQOF1xwwZhenGkxPz/f9ZO2gYu48dcUQcjKX2RCFugn\n", + "6KvjEHbv3t3NZ+hEPvShD43pxfMb3UKdw3xxjIQzSm6//faIiHjf+97XtePMV2J3oOV473vfO9am\n", + "5w0xH1AhQOPgOesxov0rrrii52l2QUZTp5jeiLbJZmIdQfngeB3+T5zDxz/+8bj44osjIqcIAsxz\n", + "y+J+mq6C6x2H0cbBQVXBXMnqhpGlxdxiPInXQMdtZmjEaC9iv/DYt/LTNhQh6MO0TPTj6quvjoiI\n", + "K6+8sutP2zbzit8xd9lHQRsrQz/vuuuuMbknxb5AhYIegQva8n/mLs+LtWvX9mKZqLXE3KJtdGid\n", + "IwvzheeLx8T1ldiPLr744l6MF7pk3tJP06wYps7xGnW9PWT81Kc+1dv/syK/7NHsuY4hdewpcxG9\n", + "OAuQtbx27dqOlok91+vfz17mFvMFHWcxh9Ahcf0Q3RPjw3pmzTFP0AvzxOeFDOWRKhQKhUKhUFgm\n", + "VswjNTMz07MSOEk784Equ1hR69at61ltgFO+qS3s/QCcarG02krVETnx4dzcXHfaRhY8JcAZHvwd\n", + "qsjc3tO1nZDd9Xnm5+fH5Gl/6366Pgb1c9zfTBbGht+1cEYH8maVql3Dym1nVXNNw8Dv2utpwx6l\n", + "rHq2M+KoK8U8cvVhxprv2+rDWUYY94B2hTaY18DZfa6fklXxX1pa6saXqtj2wJg6h//TBnVmLDv9\n", + "BKZ+aK9HfjwQ/HUtH89F6EtcA8z9dJbmc889N9ZeK7ezDTPPlGu82dOQ1XqzN4S52K5pZxu6mnRW\n", + "L4e20Av38nzx/GD/mZqa6rXN2DBfTbY8KTvJ8ybLKGyJq+mvdWi6EpNVu5+mHrKnG30C+thm0mZ1\n", + "5UyYzLOI/tIW4HvmnOsYDq1RZOAvbWRZeM4czLLT/FzgL+uufR6hc1OD0T972O1FM7uIn4voF72w\n", + "19FXqva3bXAPV/z3s8uZka7Gb1kygvWhrD3qiCE3+z9ye+/KUB6pQqFQKBQKhWVixTxSzz33XHf6\n", + "48TN6S/jfeI02XqkfHrFsqYyMxYIp3Rfb+6orGYTePrppyMiYvv27V3bVHW1R8qVZzlJ+x22ZYeL\n", + "jt9RqdfVYufn53u1MjIdcsI2N9jRRx8dEX1LDQvGloz5jtq2JpE4A8dZAbjj7JGw1YgVgT7b69ER\n", + "90APyNvy8kWM3uEzrujxmGOOiYi+hUl7yMrcfO6553pzC48Jc4+2mC+uqoxuXVU4s6bxFu3YsaPr\n", + "N/20h8kekxNOOCEiRvqwt5O5icxegx7b+fn53rxGR9Y5emFuIVO2jugnc5j/D81F10uaxG9HxXd7\n", + "YJ999tmxzwF9ZKy5D2PZejDwKJkwlzVqDwM6RS/cGz3imQVUzufezJsnn3yyt7a4N23Qb8adMbEs\n", + "3jfpn+euPTfz8/MpL5tjYeA7Y55kBLr26ON9tjfFRMIRo3VuDzM6Y1xZc+jcY8SYMk+QDX14D2i9\n", + "xfZQez1ntQwneUf9loC13fbVnlT2/aziP+Npr445VwEy4Ini+hNPPDEixj076MrPKPrv9c9cNW/i\n", + "kEc6ou/xbe/j/iK3GQ6QwfM6Q3mkCoVCoVAoFJaJFfNIHXTQQZ0lwUmb059Pu1gBWJc7duzovFlZ\n", + "1VwsSiwNc3AZZgfPKtUi4zHHHNPxV2Vce/aa4fVAJls79IkTNhb4E088MShLRJ9nC1nM44SHgrY5\n", + "3eNpQCbA/2kfL9lQ1VxbWv5/loViSxP92cIw1xR6xXJvPXvIR9v+bcYpx/WMr/VlYMkyRvv27Uur\n", + "INOW2+S3vj6LEcqqtW/cuLHrB+NkD5O9o/TXnjjfkz65AvCQNemsSqxQy8Ln/LWH0evIHjlk5/ft\n", + "mDrbzpWZPX/xuHAPx2t6/PGa8bnjPNp1RL/wAqH7LIuPuYenyXFM9mCwL8K512ZI+Vr6z1jcf//9\n", + "EfGCZz2ivy86Vox9gna9d9mLOjc314uFBOZ99Nr0fPFYOLbK6wJPxdTUVPcb+mfvqKulM0b0lz0G\n", + "0H97/vFoeF38/Oc/7z3PuIf3c9pkDtr767noeWVPXPsM4Dt7zhzrCZhbwOwS9uwBe0/Z89oxNS8h\n", + "a8fjCvByOUbSXnPg2MS2orzHgv6wb7KPOk51EsojVSgUCoVCobBMrKhHytlefg8LXMtibm6usyDs\n", + "kbL3itMop1afSDmp+7SbcQpx4m6zlIAtTCwje7cyziWsA07qnOKHYoEiXrAunCGXeVD8fpl7Z4zh\n", + "fo/tWk8tMus/g61adI5VZ2sXy4o+eIzaMeXfziLJvGNYIK4FxlhkHk/XnVm7dm3Pw4TV5loz6Nyy\n", + "OGvNVl+WcTo9Pd3Jja4si7NY8cTQP2enZLGD/N56mZmZ6XHrYVnawmTNOZMOr0bGh+Z1MMQ16D3F\n", + "PGdes+jc+4Pj8oBr9rRZar7eWWaTGB2cYejaPc4Qo/9c32aQZhlhjmOj36wD4H6hN2TxPsB6afs4\n", + "Kd7U12XcjBn/GfuBPV6t1zTzoAHz2w3V5Grh2n7Wg9fswsJCL6Mx431FFuaYn4uZHrmeuTzkwXLN\n", + "rizeFFhfzK3sOWqPFvdjzrZz17LQJntX9vywp8kyAfMEtnuX16CfIcwddGfvaIbySBUKhUKhUCgs\n", + "E8W1VygUCoVCoTABxbVXKBQKhUKh8BJjxWKkLrvssu5dJu9P/c4YPpxt27ZFxHiWh983w8sDL1dW\n", + "HZXfwRFmriV+RywB78TNWbd69eouDsXxWMj9nve8JyL6cUjEo5hrDY4o2iOTwJkncApdcskl3Xt1\n", + "Z+u5bfTiGht+vwxPGDxOjmNyHNunP/3puOqqqwb7CfgNOkcvjnFAdmSCUwo+JOLfaO/II4/s+v7h\n", + "D394TG7670rX/IX3Cdkdf+EsJ8YfDipA5ub+/fu7OWNeNvrJHGS+cy84BeEJ5Hv04VpYcPnBKdVW\n", + "smZ+00/zODK3yKqhf2SMwp117rnnRsRo3JlfzEmALNu2bevFVbUVpiMiPvrRj0bEiPcPWR0TaK41\n", + "1r9jhxijdq7DV4bOnPnEb9E53HxmRGBv8tzleuA9a/369R0v1+WXXz4mg7POzONoHj9nHXmvQ4/m\n", + "bty/f3+3xyALXGjMLWJjXNGbvcV6dB0i74tc38bGoBuuZT2z/q1Dx+NxPTpn7OibY0rbfTHiBX23\n", + "MYytLMxF84Q6W9l7OnORWChiZsl+JcvvzjvvjIgXeOXcNmuJNrxfeL93tidzketdnZ72+f3HPvax\n", + "jguRtpxBjC5ZFzwvmB+MEf9HL8hiPkxzcm7YsKF7tjD+lpffMOe8dzkWzNl+jL/bb2NqWd/0Ew5K\n", + "1pYzg83NmqE8UoVCoVAoFArLxIp5pCIiHnrooYgYWUlYGs4gIJvr5JNPjogXarlQJ8oVeTn1Y3Gb\n", + "vyirssvp9ZFHHomI0QmVqrsAS+6ZZ57p5OIU68wFZMGTgPVi3iKAbHhaOA1nWX5tVgbeIDwL5qsy\n", + "izv9dWV0kNWJGeLksvWRZUwB39v8cK5syzxBL69+9avHfv/UU0/12jY3GPD4ZzVp7MEAjB31hMBQ\n", + "vRFXAaYeClaR+0m9MNe8aTnUWrSZg85K9Fxhnbzyla+MiJEHAks6y8I56aSTImJkyaJXZAVLS0u9\n", + "jDnG3bphTBh3Z205s841bJDBWTntPfmNudHsgUUvrGtXhDf7APOEtWx+vPZ6ZyNh9Wc16pyt5bVs\n", + "T69rZnHvlt8NIMMZZ5wREaN58qMf/WisH4DxdnYv/fZ8Qc/tWLm+EeBe6Nye/awukNkqmD+umcfn\n", + "bX012vYe7fUyxFvYgjlHxW7ude+99w72dfv27T0PLTJ5j/Y+yDOM3/ktiz00fkvTZpxxz1NPPTUi\n", + "RvOeemLO8s147+wNBuaP5d6McbtG+c7P6KziuzOxvUdnGYeWddWqVb1nEW2zJ5mLMqs7aZRHqlAo\n", + "FAqFQmGZWDGP1LPPPturweHq4uA1r3lNRIy8AM8880znhXCMAqdQn4TNRwQ4QXMyx9I+/fTTI6Jf\n", + "CbflrHOVV592qeBrywMLyt4S4m04BcOxR/u2pjZv3tx58fDaIEN2qrc16NgnQN+wkvjdUF0WM4o7\n", + "1sFeLPRBm1RXPv744yOiP/5nnXVWRIz0iUx4JbH02344xsGVmoEtd9c8srWDZce921ooGXci11K7\n", + "6RWveMUBZeF3rrbt8W/jvuwN9Lr4zd/8zTEZvvKVr0TEyONqneP9xcJG5z/84Q/HZAKLi4vdfEZH\n", + "zDGvPeYW/eF36MO1eJANS9bMAK3XwJ5Xfut6SACrmHXumBDPB7yiyG6+wFYWW86sE+Q2X5357eiv\n", + "vV8AWdlH25g0r+c3vvGNETHS7ec///mx33qfc5ye2Se8dzvGZPXq1elcpD+OdeEeHn8qvbPX4dlF\n", + "T+4r86ittm9vBqAftMVexdi0e0vESI9c/+Uvfzki+tX8wfz8fDfHeH5lbyT4P+sfPrysyn5Wlwp9\n", + "tGv0da97XUSMvJzIzT2Z15aFOetnXcaTh4cpxCPxAAAgAElEQVQbPbLXD3lq2SdcP877ovdw103z\n", + "vui4Xv6/efPm3rPIdQMZ96zuWIbySBUKhUKhUCgsEyvmkTrssMO698yc5jPeJ6wi4peefvrpQbb1\n", + "iNFJGauFNrFqbL1w8uak+ou/+IsR0a/0CzgtH3rooZ3cWCe2djjl4pHg3lh/9gJguWNJ0MesmvTa\n", + "tWvjwQcfjIiRjmD+tqfF1jB6M+s1oE/A74xby/v/9vROPx577LExWfA42duBLHjdsMyGPJj0AyvQ\n", + "MmYVv23dOA4HYHEhE/NkaWmppwcsKPrJfMeqs7XLvdvq+REji81jxBisXbs2rQYOHn/88YgYeaLQ\n", + "NX893nfffffY5+aqcyzIzMxMLxbE8TWA/pMBaNntBXJlc9Zg5k2NGO0DzjL1mmPM8Cy5irSv5/uH\n", + "H344IkbzxLE4rdwZD6LnC5/TL+vH8Tr83mt+x44dPZ3g3f7Xf/3Xsbb4reGYUsdMZZyVbTyX5xRg\n", + "Pjsmkv54PjB2jBHcgplHAiwuLnY6YQ56XdiTyHrIah0SW/Qv//IvY/fGy+wxPeSQQzqvLzrLPGno\n", + "jvXPOmDPcpVtx33RF8dmRkR85zvfiYiIb37zmxEx0kP2FoC2XfkdmexNdQVzvGlDYLzpl71eHiNn\n", + "1OL1Y53YO+Zs12x+tPc216IrnE9CeaQKhUKhUCgUlokV80hNT093p1vXeMosVE6HBx98cJoR5uwL\n", + "PBN8bq8OJ28sKlvTPpG2sTa2tLOMME7vzpCz1eOsHp+0fb+f/vSnnW6wAMx75366fsxQFl4ru78f\n", + "ytrwGEzi2jOIHXDmB2AMsBZsHbf3c00qLA2sGfen5eVqZQC+nuuIKWhr/ng8neHFXGRu2oNpa4h+\n", + "Of7JsqxatarHGWdrF48UsiC/YyEsu72njjkBa9as6a611yIbz7YunPvTwvFOtOe/rXzmhqQNx7yh\n", + "a2S37r3m7DXCi2AuuvZax0SZ7xJgqbMHedw9RrSLF4Drd+/e3ds7yM6jn4y/66YBdO1abxlPpHkT\n", + "20y6LIbJXo+h8YwYeXDwSHnteR2xl69atar3jHEsmPkwXUfQ6//73//+2P/Jas0yVDds2NB95kxg\n", + "x7Eit2vB8dfXe7/kr8c+IuKee+6JiFH/2YuGro3oe42o4Ye+hrKUI0brIeP/i+iPlz3Mbtt7ENdl\n", + "5wV7pPjd3r17e9d6z/G9X+zblvJIFQqFQqFQKCwTxbVXKBQKhUKhMAHFtVcoFAqFQqHwEmPFYqT+\n", + "4i/+oueZ4v0771nh8YJTiPeXzz//fJcBxTtYOKW4lnf1xB25OjBca/C4tXw8EaNsP95bw4d15ZVX\n", + "RsQLmTG0TdwJ72KRhbZ5L8s7fjJDuCfcWfA+mScO8Dk8URdffHEvZsnVnuGrgmsJWXn3TUYh/YSv\n", + "CA4iw5x0n/jEJzqdt/VbWlmQEa4l83g564T4CnMn0R51VlpuNsaTa82Z5po16JzrneXFX2RjLiI7\n", + "Y0cswWOPPdbNyeuvvz4iXpjjrSzEXTgDDt4nz0XgOD3mItfv3Lmzk5M5iY5uuOGGiBitC8cIcS/+\n", + "wikF76MzR5GFv7fffntEvMC15bgiVwumn/D4IQvxGm6bfjIXPfe4jvV03XXXdXIzFx0Tw29YF4wn\n", + "stOWY6vglPO6YE4S57dnz55ubjH+jAUZsq5VRT/hzmNtsibJEDz22GMjYpzfsNVLG2vEXPO+ZT04\n", + "po69BW4+ZHStOGJlzM3JmO7du7cXf4VekNv7BX+RnfXPPGcNo2vHQXqub9iwoVc1nXuaa49ni+uQ\n", + "MQY33nhjRIx432jHY8ucbzkLHfPqeBz0Aqcg64W4JPpAFqf3izZ2OGJUC/GYY46JiIirr766p3N0\n", + "lq1/5jnjzhi6/iDzC15JZPZ1mzZt6sYHnXufcDwrsphrEbD3kkmJzuEsdZ21paWl7t/weCJ3G1/Y\n", + "ykZtR9ZchhU7SM3Pz3eKI3jw29/+dkTkKccoZvv27V3gHR012EB/8IMfRMRo8Tkt3gGA3tRdNLNN\n", + "MWXCOpgcMGlZGAR8MjmPO+64wX7Sfw5eTs0FbeCcg6Z9CPP/X//610dExBe+8IWI6AfVOTibPlqm\n", + "Fl6U3NPXmtgSOOAXZPQ+Jt6MGI0nmw/zhGB8DsiAfjMXGSvKSrg4oBcnhVvvu+++tDisdZtRoTid\n", + "15QJGRn0rl27ujXEQZngcl/rAFUH/BoZGfLQOnJyRRaw7ZITpgqxLMwLNulTTjklIoYpQtC1S4+8\n", + "6lWvGpMfuP8uiumDp9OlkYGU7Nb177Ru+s3ByDRD6OuBBx6IiFERRQ7o9AUgK+3zMF+3bl1Pbq9F\n", + "P/BMjWPDEpi8GPgB3e6P3ucA/WEeYOxmNF701wcHSpIYMzMznU4ZJ3QJfKh1ur+LyToY2foYosOi\n", + "X+jS6fyGDUWKRXv/R0a+f+tb3xoRo2dWW37CAemUw8gof1xg1VRsXqPMK+5JH7hPW4KA/qMr+snB\n", + "yM8FEyYzluwLlt2FPdsxnHS22Lp1a0REfPe7342I/vM/Q73aKxQKhUKhUFgmVswjtX79+s47wCnQ\n", + "ZL0Aq4kT+T333NP9lhM1cCl73MScRH2q5wTNKfa1r31tRIys6CFyVtr5+te/HhEj6/y0004bu5YT\n", + "N14zv2YybP1h5bg8BJifn+9O5egjo6XBYqCo6R/8wR9ERMSZZ54ZEX1rFyuA0zx94/N2jJALedF5\n", + "VubBXgF7GlzszSS4LS2LgQXFXzwzGYEq446X4Oyzz46I0Vx0uiztQlFEQbutW7f2CkkiN3PMJQRs\n", + "1aNT7olemD+eu+hx06ZN3T2Q3x4p2sZ6R+6sUKWJpfG4mCC1BZamaVToB3BBUntDTLPBPdE9axPv\n", + "Ap7eiD6xLZQY3MuWNNfRX6eY2wtoQm5kGeoL16Bz5p6L4wJT3rDWKJqJJQ7QI/MCj/5zzz3X24tc\n", + "agJZ8OZ5v6Cf3IPv2Q8yWbjPQQcd1PP+Ar/ys2xZuQRebbkEg71vLT0UnmjWR1bOBqAX5hFkxJaF\n", + "39FvE3aDqampXrq+S2cA5gWysjejx8xrRJ+Yg7xt+I//+I8wXHqDtWUd2luMR8oFrNt+tjLyO/62\n", + "Y+q5wvMfGez1Y83yrGev5pnlfdF7Fr978skne3sNOqQtqLEosOq3DBnKI1UoFAqFQqGwTKyYR2rV\n", + "qlXd6ZAiZ5wgbalxUudUe8IJJ3TWv707WAbEW2DN0YYtEE7eWPCmqfFJvbVIkR9Z3DaWAm06SNLW\n", + "kS00vE0uvAdWrVrV8/a4cB5At7yzxpuGDPamYFlgDaAfe4UiRrrCokQm/mbxWrTNdVmRN+6FJcN9\n", + "0EdL+8K19Je/9M8eBxOl3nfffRHRj5UD9J92mbvz8/MpkStWPJ4ax0AZjLu9qg6cbgNieafv+CNg\n", + "yhPTS5iuxp5Hy+rYkdWrV3f3wItLf23VueglXiP6l80DZMWrClovE3PRJNuZ5e1YOsYVb0FGy8Ea\n", + "Zk3zeevBtJfPcSfWKf8npoi5xVzMCt+iP/ajhx9+uKdDz3vkpn8ef8eMsW/QjsfUSRozMzOdN8Ky\n", + "oAd07SLCWQFX0zcdyFMf8YJnBy8WusmKPTJ+7NWsvayfjqllPlj2xcXFTl4XlrTO+RxCYbzG7jdg\n", + "HeGF/ud//ueIiDjnnHPGZIwYjSfjZ+Jo68XE8HjF6WfmHUMf7A/ovY1jtGcePfAbt+3kK5IukJ35\n", + "D+g3suNlXFxcHJOjvZaxId4MuTOaI6M8UoVCoVAoFArLxIpm7XEyNY2LwamR97SHHXbYICVD2wZ/\n", + "fZLO3r9DLEm2VlZuv00Dx3Js0/BbmC4Ba5j+ZHEpWFRYRQcqYIqVyql7iMKl/RwvAVa9s9x8PZaL\n", + "T/1DwHLkt/THY+R+Yw0ciIQ2Itdz+77eqcV4FkzTALDq7IHiXtYj7XM95Nhr1qxJsw2xbuxZzWI7\n", + "uA5LFL14jNpUbeav47GAvXn0y5Yq8O8Zf6fat3Bmp8m6Da8HYD16vPGm0Nf2esbPGbAZ2S79ZqyQ\n", + "nf9bLybvRh9DcW/MNfrpFPJsL2Lc8dhgsTuD1OuL77ds2dKL7UOHyMC9M6+h9xGvmyyzjvvMzc11\n", + "/fQ8dxwjY8Y4ZrFjlpnrM+qkXbt2dd5c9gGvIXTo/hDXZy9w5kV3TCGYn5/vZd+2tFItkIFMYOKz\n", + "2Gu8F6Fz5gl6IX5zqHik4/Uycm6A1x/PHmORzRfGnLVpOq+I0biZGiojIWYusydPoqkBtM/e5bXc\n", + "9oeYOPZzZ8ROQnmkCoVCoVAoFJaJoogpFAqFQqFQmICiiCkUCoVCoVB4ibFiMVIXXXRR+h4Sj9Wt\n", + "t94aESPqBK6bnp7ufssJEaoCKD8ch8L7Zd5lU5YfOgFX8n700UcjYvQO9W//9m/Hrl9aWure1fI+\n", + "nd9Cm+HS9s5KoT+miHGdFN4d0xdK51900UVdv3wtbUMnAEUA8Qiu2YHslPznekDchuMYbr755k4n\n", + "IIsXYIzQi2vyuJ5M28/2Ot7r05eZmZkenYAtB9ei4nrmlr+nbV8P7Qfft9V4uZZ5a7ldZ4t39lyf\n", + "0RWhc8bAtBz79+/v5qKz0KA2YW61WVVt28wXrjd1Tlb5HtqHbdu2dfPbsS/EmVjnrgfG9dzT/UQv\n", + "zu7j+ptuuqmjfEHX2RxjntO29yDHEnku8v1RRx0VEaPYk127dsVnP/vZsWuB43BMnWIqHMdt8vmn\n", + "P/3piOjTuLTxTF5D3kMZI+I3+S37BbKgN1cRZ6zvvPPOiP+nvXeN1bSs7rjX3nv2DDPIwQPnAQZn\n", + "QM6HlqAfahqr0DZpaBut0aRGLRZDqEo9lKChgoKAllBAqoDU0pgo6QdrD2Loh6YaquIB2gpVQAcY\n", + "h4OFjjJ7DnvPZp73w+R3P9fzu581m3e/w+y3uP7JZM9+9v1c97rWdbivte611j+GVDttxi4ycC3z\n", + "3DRLZGERU8ccvvXWWyNiF/1Q2w5xOMie7eltvxxnhSzsc45nI8YHPUEp4rnoKv7ch3VBX1s4htT7\n", + "hTMDvZdBh8Vex/Xeu5DtU5/6VO9Z5JpW7X4eMdznHANIzBTfs16Qhb4xlsuWLevWHHRlvtaxUzxH\n", + "kcV7lfck9EhfPSZTU1Od3FxryifadtY+6yhDeaQKhUKhUCgUFokl80jt3LmzZ/VlGRQ+WW7btq1X\n", + "LRa0xJ0RQ0uKbJwsg8zkrGRMuBJqK78zOLLYL2fjZRmHrhPCaRgrYHcZBOa5yzwy/J3TPTI5O8Xf\n", + "Y4zM2fR84GwTE6AyhuZI8vdd24jf22wMZydlfGeWhf5hmboela/3z5mZmbQiu63djIMw80T5Xr5+\n", + "x44dve+48rDrqNkj5fHPiLMzK3kwGPQ8qVmdLK4bVyW//b77ac417wvj5HebWc2hhTKA3E5WR2gc\n", + "v5m9xZnHlnnM52RKUdvGsluPJnVuYc+cZcp4QvlJP82AYLRz0ntGJhOeN/Y574POuHR73kdbz7+9\n", + "ov4uOrN+mFuew56ryOwsUdB+3/tdtp+7Ppa9yG4Pmex1bdv3HPEaMuw1s2dqoTHg3s7Abdtw7cKM\n", + "ZYF7sz7wvnuv9/WWZTAYjF0bEf29FWTX9657XlcVCoVCoVAoFHpYUo+UrefMavBpcdu2bd2p1qdR\n", + "TrOutMqp3hWZ8ThRR8Lv0s3NRvuzs7O9Kq6W05YUsrquitvmOvqY1Z1atWpVT1fo1JYTsnKa53Sf\n", + "VZMFttTGYRzjeSu3rV33w9W1fb09Uo4JaGXPvJtZ//jcNarswQPMF4/R9u3be3VK2nfz7XezfmbV\n", + "9+35BK0eHfPmuehq6ng7qOScjaHnrq1ksGrVqu4eePGo++a27dVyxe/Ms5uNSbsHML8dl+aYkKyf\n", + "C81d1/air+aus1ztPVxPCDA/kBW+r3vvvXfkc4N22jjPrI5cVg3cY4QsfM58IXbU4z/Og5N5XFyz\n", + "jb3XfH5Z25m3HbQxqebj83giC2MCb1u2jjyPmG94Ij2/BoNBz9vtPRjwO9fZg+k92BXyHQ/cjoVj\n", + "hP15Vi+R/tI2uvb8Yf57vrAHtPf1mvN+ntW0s3cUb6C9yY53bmMw3XbLyxgxPIPYW7YQyiNVKBQK\n", + "hUKhsEgsmUeq5WKytZBZAe3p0XE2wKd5LG6sHHuDsLA4OXMi5YRuPqSWJwwrJLOU7ZHwe2cjq+js\n", + "bAywdevWnvXRZrK1oB/8nZO5ec9AVgF8XPXxrFJvxrVnay+LAQJ4ARzP5cy6VhaQ8ZNZRmczZfOL\n", + "WDvug2zPPfdcb67g5eIe/J3Ps3f5jkvIYl/aGMMsGwc4s8tteLyzmKIspmLz5s29uDTHuhiOFcnW\n", + "hWPHbKm3MrVZQu1PrFJbmtw78xZ5PpnjEyZ6uCjHWbLjqp5H9Oc7exBjgacmq/jP9xmr1sOfVf93\n", + "RXZ7HAHz3HOR/mWevXa+uAo8YIxYD/fff39EDPfqjPcxm8MGfV+1alUnlz2J7if9Qvf8vpD3C2R7\n", + "18TEROrt8fp3Jjpz0R4ZYC+qK4W3MvkZ5IxKr3/HjppdwXrg+cp1jCHPyPa5S9vIbU5G64uxQHb2\n", + "fc9lgIzOvBsXS+ksRMeZPd+al+WRKhQKhUKhUFgklswjNRgMeh6LjMfLGSaDwaCX8Qcy748tT+B7\n", + "c1LnnW8W99LGeGWZTJZxocw3c2ntjteM75u92lZKe23blvXhk7czjjjdj4tT4BpnwCyEcRbC7j63\n", + "l2ScJ8seOo//QjECjkfyfHE7zJPZ2dle27bSPdeeL5hnWVzKzp07e9lXHk9kwTpzfw1bjfb+WJZx\n", + "fIeO8TPsycwyBY2MHb6FPS327vq75tYzZx8wd59lafu6kIfacmdZec72BObibOeXPQxZDJg9DsDj\n", + "7vpxWfxXO58yD7xj4fhOxvtmnXuf8Zi2+yt6yLyjfBevCLKh83ExT+1Pzy+vp3YvzDjkgOO5nJ2W\n", + "ZVZ6Lo7LrMv2RcefWm4/u+hDxr3oLHh+trI7jnmh/dH7yO7WXPt3e+omJiZ6a8j9BllGYIbySBUK\n", + "hUKhUCgsEsW1VygUCoVCobAAimuvUCgUCoVCYQ9jyWKk3vve9/Z44syPBacQPD5tzBDvl4noN0ec\n", + "M4KcnUTbGTeX30tzPZxlc3Nz3d+c6QNfEW07JsLZR5/+9KcjYsj743o8gAyTlieMd75kHyAT3zVf\n", + "GVkU6I132NTm4Hpkcf0QwP1uvvnmuOSSSyKin1Xo+JNrrrlmbNuOQyPj46abbhqR3e2277vhQkLn\n", + "rpLs2iJwhMHjxfzgeq4jTsEcVM5i3GeffbrvMFe4Fji+ijbgN+N67unrGTP48NDjqlWrenEG9J+5\n", + "BY+fs274HllNjBE653rqI3l+wSt3wQUXdPFizpDatGnTiF7MhcV4MxeRCe409JLFOzJmn/nMZ7p+\n", + "ss6zGCDWEJyCzA/H7/C9T33qUxExnF/oj3vT54mJia6fH/nIR0bacKV79gXGEz481qjj1LgH8wXZ\n", + "GYs29oS59clPfjIi+ryPrD3HgsFBhs7NCOAMOq879Lds2bJuHOkvOmTeeoy4F/2kbdao90/muJ8X\n", + "tL98+fLuO5bb45/FApk/E1msN9as9XLeeef1snQd+8oaGqfD9h7ck34yph4bx45de+21HS8jewjr\n", + "mtha5jv7BevfMaRch+7Zo70vOgN95cqVPa499ous2j7zhf3COvczGg5KP4/a563H8/zzz4+IYQ0z\n", + "MmUZMzJpkT1DeaQKhUKhUCgUFokl80jNzc31eN+wSHfHKcd3s5oTrjVEm5zE28rDEX1ONmeS2BPT\n", + "ZrnZy2XPCt/l9O+Tt7M28Aohuyu4+pS/devWnnfGHjjg2k14AWxRAWQ49NBDR2R3vZC2jazCbJYZ\n", + "wT2wArIsL8bOdUPQd+uZcv/5LnKbUw6dMlZYMc5uA+aRw0t4wAEH9HTojEqqRfP5008/PfZ6e/I8\n", + "JwF62H///bt7oGssKWArzrWJ3DZekZ/97GcRMfQq4S0wryA6iBjOW68twOeMCXORz/k+YB7heXGN\n", + "tzYjy1a5M5gsC/1Bf/TB9XCAa9q5Zk87d50h5Zo13luYe/6JbF7TjIHHZHJyslfPCh26po6tdmC2\n", + "CWdaeR+lT+hj5cqVnS6cMef57cy3LGszk9lZXq13ybrLKlajF3uwLIvHEL1krByzs7Pd2nHF9oMO\n", + "Omjkd+YQ85zxzDLrXOPLHtoWjJffGiB3VjU/qybvTEzaRT/mh23HyDUMXdsqq0fon1mmpNduyzPo\n", + "fnJPnnNUtmesnm+F8/JIFQqFQqFQKCwSS+aReu6557rT3kIeKE7Yba0kVyIFtorh/MH6xzsEzDi9\n", + "UPXx9r2srXl/x7xWtnZsYWIV8ZNTPTLb4/Oyl72sV+XVsQAAWTmlcz3WAVYtgJHdngesiNab4lgH\n", + "xzJk9Y+A66fYI+EaX263tXb4Lh4VqiUzh7L6R64LZUvTsroO0/bt23tWG/3BwrTV63nPWPA5czm7\n", + "vuV5Q17GxXOl9Va012WeGvTl+YI+PF/22WefXoyLvwPGcSRGDOe5PQz2QLoGUjufshpt2Rpl/bzi\n", + "Fa+IiKFO6T8eR0DfXAF7XCYy401brsVk7wBwVWn65/pK9gq1cVrWIbLQhr0WWV0g9pGFane5xk87\n", + "P+zVQxa8puxz47ycEf29yvFI3uvQ6/z8fM8z6XlOW3zHbwuytwyA6x3XCJ577rlO1+Y1dQwsc9DP\n", + "LmTLPJKOGUP2VhYzfiBvts+xFltdRvSfUW7f3lR7Ktv/04Y9k9kbCa9tx+CB7Fk4LuPOb0XQvd/+\n", + "LITySBUKhUKhUCgsEkvmkVqxYkXvJDquCmpEvwrrxMREWgWZ0yvXEuOBZenTKxaHLQ9nEABOqjt2\n", + "7OjF4yxUeRZgDdjKy6yG3VUM96nc3jvD7/Jd0RlgPTkzhvf9tjIj+laqq20DvutsRqwY7gFcZRaZ\n", + "+L2NTXL8BV6dLEMQ68UxUrRpPWIl+v37YDDotU0/aJPvuL8ALxr6sh4yLwJzvL0mqzzN/OW7WKS+\n", + "HusY2HODHtq+2ovBT3t1zCGHzPY4AGSzB4bvtXq0Z8FZSdYh+mBs2D9ox9fbOkav9pZG9CvvO14r\n", + "i0sBji/xGNlzBebn51PeR2elZswGrDHmib3O9uzwO3N227Zt6b7Ftc6UZF64P95HzQ+XsTjMz8/3\n", + "PGUZ3yH9dWad4UxK2kcW2gFr1qzpeQMZV68x1glzEo9dFjvEevDe5UrxrbysB3RuJhCAR5F7+6c9\n", + "Nnhy7KFz5fiIftZqlr1pWcydB6zzrDL89PR0b/z/53/+Z6RfjAF7seNYM5RHqlAoFAqFQmGRWDKP\n", + "1OTkZC9WgFOgYwEcczM9PZ1aGP6d0ymeCVuYjh0xp1yGFStWdCdev5N122bz5tTueC1Ox5zAOWln\n", + "74JXrVrVfUZGmC0OwPt4PncskK1jTuJ8z16hcXFt1n2WfePaNI7zsjWNnrl39n6+bQtZyMLAgnI/\n", + "HQvhelPO2nCmZuuR8Ly1Zch8dw00gznqGELPyTbuC/mdyeN+0hZzc5wnJWKYUeR4vYwnbuvWrd24\n", + "2bplXQN0xjx3DNC4OJNWRnM7srbba53JlGVh8TnWvfekLPuN+9hj2bbP/z1fs2xG1pq9HRkHnb2M\n", + "rdfdbRvj4staZHMZuE/MP2f5ReQxUuPmUNsWsLfd42+wF7Zyo0N7O7mX54fj8gAyM1Zch2zW+6pV\n", + "qzrPkz2M7byN6Huo7YnKPJLIxJq2lzRiuN9n+1/G++e43uz56D3amXWtLNlzwlmuIHsjkcHes3ZM\n", + "vTehc2dUsu6zjHOjPFKFQqFQKBQKi0Rx7RUKhUKhUCgsgOy4tGSv9i666KJeYChuR35SZp+S/20g\n", + "IG5R2oAKgfLzuPMIfiQYDrcyZfYpEc/nvG6wO5rS+VAKTE9Pdy51u4e5Froa3KFcj/ubn5TCp4y/\n", + "A2Bd/A+9/Omf/mnqJscNevXVV0fEsIQ/srocALpFdsrsA6es4m6/7LLLOmqD7BUM44nO3/3ud0fE\n", + "cExwOwP6bdm5twMat23b1lGbQBHiEhOmI/jYxz4WEUP6gYUO9wvRVbSvgNAhctut7qDZq666aqRt\n", + "F/20zpnrUIq0r1nsUr/iiitG+sn8NiUG94IKB/oJvwo0Pcull17ate8UcORiPOknY8Q8d/IFc5Ex\n", + "gpbJrnp+5/rLLrust1fwCgbXPfP+9ttvj4jh3uK9x68TMnob+oBeJycnO8oX5HYCiKmlrrzyyojo\n", + "UyEhi1/5ZPRWfiUYMbpXRPTLIHiuffzjH4+IiIsvvnjkeocVoF/mF3pkTq9cubL3Woy5xbz1qxq/\n", + "dkN25gvj7nWELOwXLe0Lc9G6Zy6yRl1qAHAPUyehF76HDMyzyy+/PCJ2jZFLALDv0Y+PfvSjETHc\n", + "cz2vXdCZfrJf+HW0X8tec801XT/bIr5tPxhfZOE56mKgfp1qehu/Um8TDqBlYa6wxthb2v08Yjhf\n", + "eF44QQLZ+d00bk6smJqa6uRhbmX7ImOFXtB5hnq1VygUCoVCobBILGlBTqw5B5n5RG0rYTAYpIFp\n", + "LrC2u+KNEUMLihM6gYELBfhNTU31AlGzIp4OUDahMuAEzXUEn3PytuemDbp3ILODCl30kv4RCOzg\n", + "UfffZRDaoFpb8QvBdA0ZBYqBXrjPOG+cy1Z47jjA08U+AbJ5vthL2Hrf7NVyMDCwBwE46J7f8apk\n", + "hU137NjRC5b1eLogob2pni+07eSCcbQ8Ebv07TW30HxwWQgHwLdtt/fkd+ZD21ff20HzbamIiP5Y\n", + "YP1nSRi0gwwmx26Dz9GdCypmCSHuA7A3BZiWBlkmJyd74w9cYDMrweC9ykH8C+118/Pz6Tyn31zr\n", + "sh/e5xzwu7uEl/bv27Zt6+1X1ovLH9h7ZJ177pm0etybAZfp4LuUewBOwskCw/17VhaiLfhpD2pG\n", + "0g0c0O+917I5yScj3G7bcKJPtm84gN1rL6OIGVdsOHv+L9S/hVAeqUKhUCgUCoVFYsk8Uu2p06f/\n", + "jGqjJe/lZJlZ3lg1WLvZ+2NA23ikkB8Ai0kAACAASURBVMXkr63XzBanU6FNOutChbYw6BOWiuNv\n", + "xnkN/P58XJHKti2sFzwzJgIGJrm0N6C1diyXvRUZ4SX3duG5rKSFqXJayiCAvFxra9bzxaUGHCuR\n", + "peKPo0zJLCksbs9NeztduoA5mRFLm44hYqgby40lyk++Q3mIjECX612I0utox44dPU9aRoiazY+s\n", + "RIU91xltSQuPExaxx9/FLk1GmxWZzWKwWi8TctNfl5CwF8Cxhdw78y5Zv/Tx6aef7o2/KTv4DvE6\n", + "3otc3sN6MbiuvY+9v8C6o7/oMCMKdhkZrwfQ7rv28mZeQBf5zWh5aIf9BZlZR17T7TjY++G9iWeV\n", + "97esOLSL7zreqdWj3wIsRIHiOeUSPBmBuj2XptJq/+aYt4zGx94xy56VBQEuANsCHdoTuRCBtrFb\n", + "j9SGDRvida97XZx00klx8sknxw033BARu4I6V69eHWeccUacccYZceedd3bfueqqq+LYY4+N448/\n", + "Pu66667nJUShUCgUCoXC/0Xs1iM1PT0d1113XZx++ukxMzMTv/qrvxpnn312TExMxPvf//54//vf\n", + "P3L9Aw88EHfccUc88MADsXHjxnjDG94QDz744Nj36dPT072Clc4IAiZx3LRpUxpP5QJiWC2mDgFY\n", + "KFgWDz/8cET0yStBW8AQYl8X82r7GDE81Zus1bKbxgSLxIXcwJYtW3pZN84mA/xOoU3u5RgBg+8t\n", + "RLjcymfPomUxPQHWHdZBVgwQC5fCg+OKIpoKgTZNWWA4Xot2nL3pDBn0MTs725vnpsign7bEgCkN\n", + "3E5WyG56eroXR+QimFm8ReYFwlvA5+gHfY6bXy5OmHn1MkLdjLQ2GzP3JaJvvUNa7bgcgHfQdBvj\n", + "ihpGDPXg4qHMzXbvyuIOM+ooe6SYL543hmU9+OCDe94Le9i87u3dsQfCsUHWI/pt95UsRspUKL6n\n", + "4xo9dvYKuX3m0bJly7p+M84m2wa+Z7bPmTqFecMzwHN1xYoVvcKzJjEHjo2lsCjXWUY+txcNfbQU\n", + "U+gE+ZjHjL89daYOwuNmzzRg/pgyxwTjrdzsE8Qt0t8s7jkrmuy9K/NUT01NpfF6AB2jl8wDa+zW\n", + "I3XooYfG6aefHhG7BuKEE06IjRs3RsT4QNKvfOUr8da3vjWmp6djzZo1sW7durjnnnuelyCFQqFQ\n", + "KBQK/9fwvGOkHnnkkbj33nvjNa95Tdx9991x4403xt/+7d/GmWeeGddee20ceOCB8fjjj8drXvOa\n", + "7jurV6/uDl69GzenxuydKBj3LtXxRsCEiFncku/FqRfLwiXvjampqd774oUsRnt1stghWx67y2bj\n", + "xOwsm8w74racMeF72qs0juQ2e5+c1WayLOgaC9Vj6jFzzY/WsrXuAPJaRmRwphCwpW79tVZRJrct\n", + "ame4uC3TuWRZkW0mKm3jvTWcPWPvqOsEAdP44OkaV1fIFnJGiOuYDhNH26p3VqczUMdZoM7YyTII\n", + "neXqsXI/Hffo7KRWdntz3UbmaTNxbhYjA5CRdTA5OZkSv3v92oOQyeLYl8xryn47Ozvb042vdfyV\n", + "MwSNcVRh465v17j33Gxv9VhlWYm0be8I7Y7LCvNay+aWM0LdB3uwPKaOY2vfMlhn9kxllEJ+22Kv\n", + "KfCYeq3ujjqJe+Ohcj+z54tr4YGM1mf58uW9a73GTLy+R2KkwMzMTLzpTW+K66+/Pl7ykpfEBRdc\n", + "EOvXr4/77rsvDjvssK4A1jhkD9O77747vvnNb8Y3v/nN+OlPf/q8hC0UCoVCoVB4obFx48b47ne/\n", + "G9/97ncXvniwAObm5gbnnHPO4Lrrrhv79/Xr1w9OPvnkwWAwGFx11VWDq666qvvbb/7mbw6+9a1v\n", + "9b4TEfWv/tW/+lf/6l/9q3//Z/5l2K1HajAYxHnnnRcnnnhiV0o9IuKJJ57o/v/lL385TjnllIiI\n", + "OPfcc+NLX/pSzM3Nxfr16+Ohhx6Ks846a3e3KBQKhUKhUPg/i93GSN19993xhS98IU499dQ444wz\n", + "IiLiE5/4RHzxi1+M++67LyYmJuKYY46Jm2++OSIiTjzxxHjzm98cJ554Yixbtiz+6q/+Kn219853\n", + "vrMXz+Fq2nCWwW/UvkP1e1Dzj/HeNasPAe+P+a14Z0z7xB3ccsstETHkz9t33327rIg2cysi4gtf\n", + "+EJE9Hm8XA+Dz+Hag2uJ9+30lywP7vOXf/mXEbGLJ4r37MTyuHI5HFHveMc7ImJYJ8uVubkXHERw\n", + "baEHYmMcC3DTTTf1uLDMocg7aspnwBGFromrQBb6Au8XekHfzuKYmJjouLPe9ra3jfzNmWDmQzR3\n", + "Vha/BH9axoe2fPnyng6ZK44B8zygbTjCHBPkml/mZtt3333TOlGet8C8deieuYXOyYxCn+gF2ZDl\n", + "fe97Xy/TD30A1qj58LIYoM985jMj13ss6Str4LOf/WzXT2eEMseQn35iILpKtGPmzLUG2Ktavk3G\n", + "3xyRrslFv2+99daIGPIbOuOUtskgRS/eL2h3n3326XGKwf2GPljP9Jd7si8yF72fmO/Mc72NLXGd\n", + "N9o2dyKyMKfQE/00p5xlp/+f//znI2KUJw4ZXC2c/QKuVcbblb6RhT2a+WImCWTg+y2XK+NI/8g+\n", + "Z+6YxxNZXQvP+ygcdGS7cW/X27vhhht6PK6Athln+slz1BmkzmJjTN/1rneN9BF9tmOETtw2mY+O\n", + "x2PvMk8g64B9kXbg5mONoo8205C2mVtciw797KU/7F0ZdnuQ+rVf+7WxwVa//du/nX7nwx/+cHz4\n", + "wx/e7U0LhUKhUCgUXgxYssrmW7Zs6U6BZBJlVVedhTA/P99Zp842yPjvOBA6U8LZBZxEs2j9tuKr\n", + "q6JmPE78hPfLFmcG11VxXycnJ3uZIFnVZz5HP+aryrjWnGHE2LTZKbaYsswI4CwNfmJh2OoxrxUy\n", + "HX744SPttX9jTh155JERMawn5LpQrgvk/i+UedhmlGR1njznMr66p556KiKG84P5kmUctp5QV6B3\n", + "tqG9YMiaZW2x1tAX90LnRrtmnY3ldcFYHH300RExHCP675pmnqOugdSOkSv8O6PLXi9Xwmfe2Atk\n", + "uHr0uMxadI0XGLkJjfBehQ7RFzJl2X+uZdZme3qvoE2ysJytnNWdAqy9LIOM+nTUG9p///07GfA4\n", + "WBbvXfTXurRH1j+dQfj4449HxK51xHzlXs5CM5ec27Qsfu7QXsaf+Oijj3afnXTSSREx9NZQTwu4\n", + "7hr3yHg/vd+i52xPa//Gd2HR8P7vLFRkyuqIcb3f5IzL3HR2YevNjejvXVkNNPTn2mD2mrd126xD\n", + "dMc699xaqIZdd8/ndVWhUCgUCoVCoYcl80hNTU3FIYccEhG7Cn9GRDz44IMR0ee3o/Lp+vXrI2KX\n", + "RXPmmWdGxCjnW8TwJOm6J9zDdUQ4zWL1cELHaralxun58MMP7066VEPHorLcrk31yle+MiL6lhon\n", + "bKweLLdxdUEidnksqIKLNU9/jzjiiJFrsYrpL/fCwrCFiR6wXF0Jt9V7VptpXG2diGGtI8YCXfO7\n", + "LRIszB/96EcRMfRknHDCCb37IxdejjVr1kTEcCysc+6FfhjTxx57bKTfBrIyti9/+ct7MTyOQ6Kf\n", + "eGJd4wyrHplZH+iR7wNknp6e7rwcXGMdohf6Q8kRZLHljQeCuc28YR2Zuf7QQw/tdGtuwcySXr16\n", + "dUQMLXW+3yaztPfG28H+8OMf/zgMx/TYyrX3gnXAOqJ/yOZ+AsbOnql2LrKn4FlElkceeWTk3oD5\n", + "4nXPXHNMqfkhmX+Tk5O9yvbcmzlGvCH9dEwY/XP8FfuBvQCsA/q6bt267rseJ/ZQdMuektWdQg+M\n", + "IWNF+5al5Qn1/m9PCrrDg8Lcy7hcmYM8q+gbLBfed5966qlOt+z7a9eujYjoFatGt8hKvx599NGI\n", + "6M9d2mVeIAtru50vXPvQQw9FRHT1HdlD0YNlcW0rxzEBPmesWKOey21broaf1Uljb+J6eygzb6r3\n", + "tOXLl/c8b8xz5m/GXLAQyiNVKBQKhUKhsEgsmUdqxYoVnWWR8TwBTuhYyU888UTnYfBJGsub07s5\n", + "k2ztYIG4eionUnsksJ42bdrUndq51jFPyM1pnVMvXgOf6jMOLk7ejtfZvn1711+/23XMi9+3u7++\n", + "pytY2yJpkVUuzjiP8NxlVbjtNSTOgfnCmOE1aj1B9BOLyDq19Yo1hNcLK9mcS5bdWT0TExM9HdI2\n", + "Vo29BJ4veKAcQ5ZZR21fzQ3lcXIVeay7cUzxEUM94WGg3xs2bBh7/czMTM+r4VgFwHWsYXSfVXxm\n", + "LPCmEM8wrso+enD/+dyy4LnMKv8bWTVux320cjMXkXNcbFf7uWNBXKUdMJaMDZZ6y7oA+C7fYQ/C\n", + "e+N4GvYq9hfv0Zlnh/ZaT4zHAm8Y9+QejlMCjkXl9yx+5aijjoqIXXphzjgbD7Cn2NuRcS0iI+uC\n", + "NYs+vMaPOeaYbh7gxXKsH0Dn7Gtcx/5mbzp7D31k3tAHfkYMdcxeikz8zGJHQRb/Cpi7rlbuZ2Tb\n", + "FroyZ6rHlfnv58K49d+264zKwWDQ8zACxp/voC/HvGUoj1ShUCgUCoXCIrFkHql99923O/1xgswy\n", + "JTjtYgVE9OMHAG24lg33yLjTzFgPsmyGmZmZziLwO1u37bohtlrcNidyn/J9mv75z3/e81ZkFrXj\n", + "VVyryO+Z0RMWCFYRVkNr2Zl/KcvoAOY3w3LN+L6Q5dhjj42I4Vg5u7OVl3EkdgzLghiHTDasO2Sz\n", + "zjPev8Fg0PMw8TteLqyczJImzoJxb7nTInIOsunp6ZRRHhCPw3zBG5jVcGJe2BvMPLCnbseOHZ28\n", + "5gb0mmIOMQ+I10AvWPmAe5rnDNna9eSsRHt3bFHzd+5JH7D+Pd6OKcz4ztp+42ng2sza9b0ca5hx\n", + "s3EfPHzT09O9eBrXpHLGdMYth948r6xH1ih6aN8aePztYbTXwl4jZKdPzB/05X2A2MEDDzywu1eb\n", + "ydfCWdte9+4nfUJWvF/OmgX7779/93xgnuLVtdyMid8CmD8WoHP+zpp25lzbf+QmXmuhtyB+Vjl7\n", + "D/g55LqG4+BnkucsYC3SNnsPczfbF+3RXbFiRbr3Iqdjw/Yo116hUCgUCoVCoY+JQXYMfCFvmtTm\n", + "KRQKhUKhUPj/I7LjUnmkCoVCoVAoFBaJJYuRuuiii3pZHWS3tNxZEUMOqjYewVWjzZ1H1gHXOZsP\n", + "ri34ihyfhdeMd+pw7cDNtHLlyu49KvdCFjiC4MLic3vieIcNB5F5v3iH7BgZuJYuvPDC3rt9VySH\n", + "xwn+KcdGuXbLTTfdFBHR8ecR30NfyZjj/f11110Xf/InfxIR0cscc0wQ/FZw6GWZg8jE9XBzOQar\n", + "rRVGPz/ykY+MyEt8DfEYjBXj/853vjMihnFaxLNxHRlR6IX54rGfmJjoPmM8L7vssojo8xM69gHZ\n", + "zbVnjka+R/uM6QEHHNDVryEmzLx/tG0uQWer0TbcXOZiJP4EWRjLyy67rFeZnrgsMoLMtecaVl7/\n", + "cHiy/om7IFaS2CPuc9NNN/U43xzLxE84xdgvnI3p6vOM/9vf/vaR68bVyWF9fuITnxhpi3gTx50w\n", + "RvCVOYsJ/fB5y+PW/h3s2LGjkwtZ4DczS4JjIJGF9e/9gjnJWmdM0WMbI0bbfIc9mnnr+Mw2lqW9\n", + "njVHe8xZrkP3jCn7Rfudtup720/k5t7EGTlmFj2yJ7nyf8ZBeMkll/QyOr1/ITf9BN7vmP/Iwt5F\n", + "fB97NXsdslx77bXdPegPa8YctJbF1faRgf7CE+ox9V43MTHRzds//uM/Hukf42iuVcuSsXWgV9pn\n", + "7rri/3PPPdfJBdfqxz72sYgYPqsYf2LKWKtwbWYoj1ShUCgUCoXCIrGklc051bpSrStEY6G2WS4Z\n", + "G7XrKOFhMH8VMGs33+NUbC8S1vDOnTu7E685kty2rbisJpOznGgPi8OW7KpVq7r+0k9O0s6qcEYH\n", + "VgtwNiP1dfjeD37wg4gYZlC0WT4Zrxlw5gPWHmNCJW8q11NnBriCMfrDGmyrrNMmHiaqSNNfvCAA\n", + "q582aJt+ei46m5ExO+CAA9I6UrTBmHi+A/rDnLNHzxYZ3qHDDjusmwdZbTZ7Flyh2ll7jBF/p33q\n", + "D43TC20yN9Chs5PsuSITCv050wc94HVjDTsTqe0HMpivMuOr4zp7gS0L64e5zvowk0LbBv2iPhBw\n", + "Bpkzh5zV5DHy563+PP7MLTMTIGOWWem5h9fQGaqujTUzM9P1x/20t89calmVfdYP2a1ZHaG2thtz\n", + "JasTxn5AG8jM3HVMDHsT+uN5QCbeuAxlZ1Wij4wjDl0iE/u/ZWHfxBPF2wLzHkb0s9bRB5/7Oco4\n", + "+vnnNxkAGfxsoy/t88jeXLMuLMQp6XmVxVy7huSyZct6z1yec8xJ9jeqwz9flEeqUCgUCoVCYZFY\n", + "Mo/UQQcd1FlJP/zhDyMi4vjjj4+IvGYJXoZVq1Z173h9esUi54TNidMVzN22PVFYC2YL50Q+MzMT\n", + "999/f0QMT/62dvguljSneKwa83hxPbKceuqpEdGPwQLPPvtsJz/WiSvLAk7t1OxBBld2dj/hZvqP\n", + "//iPiBhWxh1XH8S1Q8x7CLDeXBUaXres9gifIyvxQK13hPHFE3XfffdFxLDmkL0jjA39/fa3vx0R\n", + "QyvJ1bodc0Edmc2bN/c8Uuiafrpmmecu3g36x5zF22hZ6PczzzwT3//+90f6v27dupFrmUPIQk0u\n", + "rFfPFyxV1gG6Z83aI7Fx48bub15THk97cbAC+dzWMf1nzn7nO9+JiKH+Wn4zx9053tD1r1hzcI4x\n", + "RvA6eo3SLrLiHcHb1K4j1hzzlDkJ15rh+EaATJ679uS09Zayas+Mxcknnzwik73deHLsHUeGrKYR\n", + "ennooYfSiuy0gYx4Vj12AH3gNUB/cMu5fdrZb7/9ujmJvJabdcE6QDbmveciXiV0/apXvSoi8lpP\n", + "MzMzvQr09pYC7mkvKm3aa+j4z+9973sR0a/DFjEcZ+YzMuF5M2etPa/MZXuagOs1tmMQMfpsdHwm\n", + "19A/vzVyjKjntsff3I0tq4Wfof/93/8dEcO92nyobXX43aE8UoVCoVAoFAqLxJJ5pObm5jqvEqdf\n", + "Z6cAVyf+xS9+0X3m98ycuP1e2bETAIuSe/PeFevXVgOn3TbGiPfkmdyOH8Cz4LaxMOypIS5hnAfD\n", + "7PXAMRJ8FxnwLHFPn+rvvffeiBha2liyWJytheF4Cu5Bv+0FdJwWsjueDbiaLu0ie+upwQLF00Cb\n", + "eC08RrRpHiv6ab3QV8YGPW/atKkXN0SbjBGWFxa4YY+TM2Qynsgnn3yyu9cpp5wSEX3vKDp1Negs\n", + "LonfXREbC919nZ2d7dYMOms9RS3wAqAX7oHX0F4APDqPPvpoRAwtVrxurTXtTGDaYj44zoh70t+M\n", + "Bw9gqeKFdnZw+z3uyfpln2DPsnVsyxwdey37evMrzs7O9uYtcvPTmXKeLx4jV4D3GCFrW70947ez\n", + "15/fzZEG8Ao4c9BrELTrxPPUexFjRH9pk/HN+ELxYLCf2DvY3p9rkCVjqqB/zGH2ReaJ28Y7Rmwp\n", + "c5D9pdU797LHiH3OsrDPMYbMLXt6ATIyd9HHOK469ECb7F3ZePJMZ/0gmxkgAH1ztuOyZct644nu\n", + "2EuZa8zzrBK6UR6pQqFQKBQKhUViyTxSrVdp9erVEdHnSQOcCtv33Zza/T6dUzinXNrC6vWJ1JaE\n", + "66z4RI3lsnz58i4+hpNvxtOXcchZdluF9JcTuNvZuXNnd4+2nlHbH9+L/mCBcHp323gXOKFj5aCv\n", + "cTx3fieNXiwLlrSz/fjcemH8HedjazOin4WCRyrzdjIv+Iklko2dOR7tVR0nNxYV8rquEMDT4gwi\n", + "4PmFbMuXL++8P3zHnhc+N48XstAPgBXHHGwzoca1Pz093fWzjUmI6HsBnJ143HHHRUSuc2dxMkbs\n", + "AW28VhbrtRC/Jf1Hpiw2wlZ0yywfMRo74uxUrznvRc6k5DrHngH0ZH7AlStX9nTYcoRGDOexa7hZ\n", + "FjwWbsdjih7G7XW+1txqzCV0l8nC53gRgO/Zxhg58zHjTkMf5liz7KwL1mimB7Bt27ZufLgH89ae\n", + "Oj+rHGvoty+0S3ut5yVidI2yzvksy9K1LN7Dzafp9pGRZ5br7bX3tl4yTsmsNhXXeU+3d7iN1bPO\n", + "/XaI+Y78rdy7Q1HEFAqFQqFQKCyAoogpFAqFQqFQ2MNYsld7l19+eeeCc1poSz8SMaROaUvmO9jx\n", + "L/7iLyJiSCeB29AF6HDhQRECnYBd3A6ao/w8dCj77bdf50rFxUg/aPvP/uzPImLoHuS1A+5E+sn1\n", + "0JuYngC4vP0HPvCBTl6CJnGl4mo1FQpAH1yH7imF/wd/8Acj9yT40q8Cb7755p4O7fbmJ3Jfeuml\n", + "I587NZtxRhZK/rt4YvsaCzoBxh8dM/7cg/6aZoVXgNkr0SuvvDIiIt7xjneMyM7rrGXLlnX9Nl2N\n", + "aSSYN8jGGF188cUj/WvT2SOGcxFaDsZofn6+e7WHax1ZWBdQYWSvQein6YpMy4HOGQv6eumll3bB\n", + "scjN6zG+Sz+RBfgVGHqi7fPOO2+kT4ytX1dcd911PXoIFwflNcFnPvOZiBiuf/YL1ijrg7nI/ILe\n", + "BriI5IoVK7p5y3giL207SBa9vPWtb42IftAw+jN1FhRUyNomY3j82bdayo6I4Zziu+gFSiEC5WmP\n", + "+U5/oc6BOoU+PfPMM73XaVCbIItpR9jDTG/FfGnXWsRwTFnbyI5etm3b1q09lzNAL6x/EhpYawQ2\n", + "cy/ahjoJ+LUSY8te9573vKf3+hdZPM9Zcy76y/cZM88X9EjihAOkr7jiit6aQw9OPvFz1OUPnJyA\n", + "7NC+uNAzMi1btqzbW5CF9esi2ugFiiDmi0NfGHf09PnPfz4ihs8LQN+2b9/eXfu5z30uIobrmfAB\n", + "+ofcHqMM5ZEqFAqFQqFQWCSWtPwBFiunQFIQHcjGqZgT67PPPtsFhTko1IGXWDmcLB2gbHJi/o6F\n", + "4qA8ZHvFK17R3Ru5HRTLSbu10iKGFoOpE+gnVo1L5rto2s6dOzudYAkgv4NEXdQO2TPqDGTjc9rj\n", + "fllacNs/e9SAAxcdTOvAbe6J54LA4KOPPjoiRsfU48j4MTYuMUA/8EjxPYqDZoVKkb2lRMjGk7nI\n", + "uJKkYAuLftIO84c0ZxeHpC9zc3M974WDRx1sTOE5ZHEgq1PqTYHiQPi5ubluvF0E0df6czxZWJhe\n", + "o/ZUYS2OCyDP6FXon5MkbPW71Ij3F8dIeD608Z/8jXXrfnpu2fqnnw4+Bi5oiMyPPvpoz/PYUrdE\n", + "DPdFEn08F7mXg21NRAxol79v3ry5R74MGE/GhHnMvPG+4VIN3ouyfWZ+fr5XcNZrCL3wd1PiZMlJ\n", + "1o+96e31fMb4Z6V7aJO/ozfT3ADu6ZT9cQWcve85KcclB0yV5LmZFUH1dVlZiPYa+umSLO6nC3ly\n", + "Txfw9Nuldr/x+nehXuT3WCyE8kgVCoVCoVAoLBJL5pHaunVrj2gVK9kFCzkdtjFJftfva7NTrU/e\n", + "LgKGNwTLBW+A25+dne3FBGVlDmjTnhZbavbQmJR33Gna1ljmYXIRPPrHSdztYPVhyZgUOSMojuin\n", + "d9url8VQYSWbWBggu63f1rJzGQvaxCuUlZxAD3wf3Ru2VNvYKnsrTA1jEl9biXwfjxtWo+P9QJtO\n", + "TQwb19pKw8tj7x/X2fNiq5i1mpGZzs7OpuTK9naYAgMLmv5lHgwTTOM9avuKnOjS8mZZNxlRrj27\n", + "Jm1tY6MiRteFPansb+wpnuf2anBv9kMTqTLWzJe20KH3ChNh46lhTlKg10DnyGp6H+A1uWXLlm58\n", + "M8on9IJMGYG2YwYZ92xdoPfBYNB9NytnA+wdy7yeJrN30UzP3bm5uZ7nxTGPwPGnJr22zpHZxXLH\n", + "efYcV+oyP57/jjF0QWfvo/YWsR8xd9v9lO+abNv3BujFsjiWzO3bi758+fI0RtTzP5snGcojVSgU\n", + "CoVCobBILJlHKqKf7WbPk8Fp+OUvf3nPCgGcPmnDpeqzku+czJHFxSUB9/3Zz37WtZ3FMJg+ACuH\n", + "ftgK4HcsS5e4t7XTntyxFDM6ERea83t0e2BsgTi+o31H7vfibsOy2Bqif+gxo9qx9eCMw3H9Anhc\n", + "bAXSJjFUxMbRjscoozPauXNnz9uBDC60yLhlxNIm50Rmx1SAqampbvyYv7bqTNfjwnNeF1mh1qwI\n", + "3vz8fOdZoO2MTsL9s07tqeP7zBu8ovbQtP1wYdqskKwzqrCgkSnzGjrbcVwsheM1nX3l/cL0Q6w5\n", + "5q6vNwk6c3Z2dnbBWn14Ur0eDMbShNL2YDseZd999+36Y6+e41CQ33GHwNm9XO+xBu1bBmdfZeS8\n", + "6Bi9tBniLRyvxPezwo2Tk5Pps8d7C3/3M8hxitn3WRfjZHG8reW2Dr0X2cvsvc7UUX5Wte270GhW\n", + "PNbXuxho9nzh747bGrdG6R9zFPl5Fj3fgpzlkSoUCoVCoVBYJJbUI8Up1t4Cn9zH1bDgpOhTOidt\n", + "003Qptu2RWqy08xi27FjRxfzsBC1AW2afDnLrOGeJp+0VbBz586ubWdtZaAtWyLWIzLi6cAaxFpq\n", + "4x5s/bvNLPMhsyxsaTFGfI4HCxnbOAaTzjrmLYvtyqh2sngfUy1MT0/3+tlSuLRtZXPKVj4eKO6Z\n", + "eaQGg0E3F/Fi2CK0J4WYl4yWAVmwAl0TyPNscnKy0xnjY4oTYCuXeIoszsT3pD1nTLVtWN5sDpp+\n", + "wnEV9o7wuz28vq79G7o0iW/mHfXexZobt/7bPrSUMfYYZN6vbP3TpuNTsmw2r/2VK1f2SIYBurKX\n", + "0Nl5wB58x6R6vxjXT9PRAL/BcNym47tMP+JaSNbjYDDoxWdxjT219IOfzHNk85pzPLDrarXryG9c\n", + "nu9zIotBzq7PCKTbMfJ+71ipfK1bWgAAIABJREFULHbMXrJsTXO9PeLT09OpZ81esiwGO0N5pAqF\n", + "QqFQKBQWieLaKxQKhUKhUFgAxbVXKBQKhUKhsIexZDFS73vf+3rvvA34bd7znvdExOi7YmcnmWeJ\n", + "96L83e+Gb7755ogYcif5HTrvafn86quvjoghj0/77tuZTLfccktEDLn2XG3acTzIAgcR93TmIDLB\n", + "QXT++ed3cTN+xwvQCzp0jIPfeV977bURkXNz+X32bbfd1vEyOc6Mn4wzfFzwW5ljy/W26CccVG2d\n", + "nIhRriWuhTuJuBTXZOHn7bffHhER733veyNiGE/g+ATGFJ6oD37wgyPXIcuWLVu6eAr6yXgybsQw\n", + "OBaQec5c9N/pCzqHyw29R/RrM3Et4894Eo/k+jf0B46w888/f6QddI0+iLG69dZbI2IXNxtzhDaZ\n", + "m8gGXx38dvZMsy6YY6wLeN8A33N842233dbNc9e08rVwxJnfzONPO+YgYx4x5m0M2hVXXBERw70C\n", + "ebNMIDjCmFuOqXRdHGRhvtA+smzatKmTh3WBDpnnyEJ8Evdi70IvrvnmGBN43z760Y9GxFDP27dv\n", + "7+2l5s5jniC3nwfMF3hCkd2xL+wXjCnPgOnp6a4txhNdoRf2IvM2Ov6G9c/8QmYyR/mdrEB4BT/4\n", + "wQ/2YnxcBZ9rzUHn2DfWB9fDQekK9/SB+3z2s5/tce0hN/0kxtbrwhm2wLyvzF3HHPH7ypUru32R\n", + "PddtAcaVtnmO0h/HnqIn1gXPALM7rFy5shsn5i37omOjmefse+glQ3mkCoVCoVAoFBaJJfNIzc/P\n", + "9ywSZ8IArEUsuccee6yr+3DYYYeNXOtMMVtz5vHi5OksraxCesY1FNE/WZtjj9/pD94BgGzUSVnI\n", + "e9SesKluTD+dyeJK1Vg9yGa4xgeWhbMi2785u8pj4H6iDyo9H3fccWNlNxfXI488EhH92i+tLHi5\n", + "0As8VGvWrBlpGwvaWVtZdhL6wzps/55lRuENZf7iqcnqSLXZVxFDq9BZe60HEN3YSgNYnMiCRXrk\n", + "kUdGRD87iXtzHf096aSTImLI0Qamp6d7HFiu5+K20QeyMy/Mh+Y6Zcgyrq+Zt4LfnRGEFW8OOnvT\n", + "AGPqqv3jqjRntb2Yt85OpB/031mp2XxBH/wctzfRH65hXNE5nIvAnHJeF84wpY94Onfu3Nn1w1Wi\n", + "aYN1bQ+K5Udf/N0V0z2meCJ+8YtfdPsbe633XN/D93Y/7YmCZ/X000+PiPEZx2ZXYNxdTdvZuejt\n", + "0UcfjYi+B9deVHsAx+H++++PiKEuX/3qV0dEv77WuP0tIs9+9P7hWmHj4LpZ9Ntt8RzBC54xiAD0\n", + "Zu7WqamptC6gs2+z/T9DeaQKhUKhUCgUFokl80i97GUv6yytH/7whxERcfTRR0fEqIchYuhVwNo5\n", + "+uijO++FPSrmGcoqswJOzsiCxYJXyNZ0e7pdv359RAyrotrywtOCRXLEEUdExNDitIWBxcLJ/Nhj\n", + "j42IiI0bN47oAUxOTnb1g7DuzQQPsFI4zdMWenIFZ76PTFgo69at68nuWjO74+Fr22I88W5gcfjd\n", + "NmPxox/9KCIijj/++IiIOOaYYyJiqN+IYf+xtOk319oitZcHDjI8OJ43rlOEVfnwww/3eLlaD2p7\n", + "bVa5H7iSM3rxfEHP++67b/z4xz+OiKGH1tx5rIuf/OQnERHxG7/xGyP3YB4BdEr/f+u3fisihh4s\n", + "LPFWZvrLnEK3notY5Kxd8715jByPhkeS9TSuvparh2deXfP9vepVr4qIoWeC+QDQl+uxMWYHHXRQ\n", + "TwZ7d5E78xy4ZltW8RsZmfP0bfPmzb01yHgx/ieffHJEDNczY+C2kdk1u2zZM7/8liGiz4VHP7jW\n", + "lc09dxkjWAeQmf3WvJItowAeaHRuWczX5r3Ha475QBVx1gVj6XW0ZcuWbi0xrshkrkXuxd5sT6Y9\n", + "mHjZmdvsM+N4ZRl/1tC5554bEcN9n2cMQA+u4ci+mvGn0j4yjGNacIwj+mEM7JF2TS/ulfHEuqYV\n", + "86mN2wOOX6YtziAZT6RRHqlCoVAoFAqFRWLJPFJbt27trH6/A/UJE8sDK2rNmjXd6RtrBriCK6dS\n", + "Tpaussx1WAuunmyPBNevWLGisz7NjQfMPeZTut/HO8YKjw2eL/OEbdmypTutc4rPTtCOn8hixgDt\n", + "YMlhDdHn1hPoCrVtte9x/eJ6LAU8Ull1YK577WtfGxFDzsIf/OAHETFqkZqvEc8lY2Gvnq/nXq6e\n", + "Dvzu/+GHH46IXdagvXrogc+xcrKq/PxuDyfX29pt5yYeN6zU1ksXMbTSGE/m90MPPRQR/RiJV77y\n", + "lSOy4OkiNsSemomJiU5+2nLWoWXhHmvXro2Ioc7tNaCfzHE8kszFdl2gK77j+Cp7jZ1pSr/Qi61j\n", + "Z7E6TqvtK54yZ5s6cw54b6It+uK1TV+Zo1kl+YjhHPyVX/mViBjGuuGJsGffnjp7GrwvmmFh2bJl\n", + "3bhkfKXOpDRfKEDnrHvmCR5/vzVAv/vvv38nL2vHunFGnPlNHY/DmLIXsV/gobJe9t9//26eOiPM\n", + "64J+o3OeScxZy8IaN0cr/W/3AN72+DmBh9I6d2Y5/XTGHPCext/Zm9vrvVaQm33D698ePbMxZFx7\n", + "9jL6+dn2D3147804fY3ySBUKhUKhUCgsEkvqkTJHG96C7J06J8uHH364xxwPOI1jUXDa5VTr99Kc\n", + "XrGkzJKdcZDNzc11p3vHhgBO3uazco0bYMuK99p87nfkBx54YGeNcqJ2bJhlcVZjdvK2d4G+Mgat\n", + "N8XZeY4rcD/5HY8EIE7DdXZcCwZLlPu0MXVmCscSIr7CcUxcbw5B1zQC/p159dKXvrTXb3SLfPZ2\n", + "+nrmGh5Ie3TskWBebN++vRunzAtgnkJbu7bqPP83bNgwIrsxGAw6q9Vz0WvIliT9YP2PsxwjhvPC\n", + "vImtRzLj6TL3HrD3FL3gRfD+wn7i2KtxWXv2gvE7XvRsv6AN7pXNRXt0+Ll8+fI0Lo028USx5uyZ\n", + "Rl/omnlDHxyX5P1iMBh0e4W9uubY5Dtcn2X5cm/GKOPya2OkLIPXkL/rmCnLgscCDzBz1tnNYHp6\n", + "uvcZ45956uwlt2fT/XQM1bg9mn6jB/ZQez3dT64336Fj5Fwby5m7bV+51rFc2fODtvz8zLj5vH+0\n", + "12dzBSATew16WgjlkSoUCoVCoVBYJIprr1AoFAqFQmEBFNdeoVAoFAqFwh7GksVIXXjhhT0+O97H\n", + "8k74k5/8ZEQM+XDaTBy/g4U7B04h3qeSjUKNGt5Dw+MDp5AzCVwTietbbh6+Q5wBcVZwCtE2/eS9\n", + "K++yuRc8Tuag4t68t8WTB2fVhRde2OMGc/yI+a24J7Lyvp7+wuNEP4nvIGOGKrvIeMstt3Q8S85C\n", + "c7wRY3TxxRePXE/MA3WziDtAj8jiuA9icmZmZrp+mjuN+AEyIJlbcCfB++RaJegF/cJZB08c793b\n", + "TENz56FzrmH8qYODTOgFbjbHBBILQH2lK6+8cqT9Z599tsvGc/0juPDgFKN/3Ns1qhh/eNxcndwx\n", + "ZS0HoeOzaBtZ0CE8fsRhoGtkYH2YDwuYLxDceOONPR6vrKI5XGtc79gIZ1jB+9byG0b0ORzn5uY6\n", + "nXj9O3vI+wVzi7a4Dj0Sj4de4CBD320WH3FHzEXzYQJXl2a+sEYdQ0NWKLEj8JuZy21ycrKTH1no\n", + "pzlI2UscM2SuVcdUOePO+2jbZsv5FjHkq/Se6yw1+uB+MqbsVewrjAF6/NCHPtTd25nT9J91wXyx\n", + "XhzXg15YF848QyZiqq6//vpObscvMqe45+c+97mIGHLnmYvT8bBwszK/zCfIGt++fXtvjwa0jX74\n", + "vX3OjWvb9aLMt+qYw8nJyW4N0k+vZ9Yk17E3ffazn43doTxShUKhUCgUCovEknmk9tlnnx6/DZaG\n", + "s1n4OyfstgqvszA4WbuGD6f6LDvN2TuuPwPabDBOrRn3D9eaWZp+uu3sZM73nSmxfPnyXmYgFoPr\n", + "axnOXrM3yVWZnVHpDMKIvIq0LU3zn5kHi9omAD26XpfnRfs3rEAsbeZBlvlmtm9nWgLXxGqtTWfV\n", + "8DvzxBlf2Tx3VhNWnXXecs4x3tzLcpo7Cp3y054KVyfHcmUOj8vMxBqncrM9q4B+ICM/8QJ4jZo3\n", + "Dw8XMraZdZ6DwNlEAB1zj8yDAbIYCfrUZjXa026+OuvFGafM1WyMnM3U1vjxXGFu0V9n3Xm+uE3m\n", + "IJ87s9Z6m5qa6tVPytp25qPhLE9zGBqtBwIdsv69F1mnzMGF+olMzEVksR7n5+d7bxTQR7a3OOsu\n", + "q93V3iNiWOON9tt1wVrheUHWJp+3Ffkj8mxXcy8CZDRDiL2lEcP1jXz0128cAP12ZiR7U8Y+wj3b\n", + "moC+hzMFWTecMbI5aZRHqlAoFAqFQmGRWDKP1OzsbK+SKXEeruBsy27jxo3dZ8SbGJw8ie3h1OsT\n", + "puvEcJLG0rBnp/VoUJuIqs9ZRV5O71yP9cL7WOD39PbQYBWCqampTg9Ue+a7cK8Bx7q4YrG9KdQ+\n", + "Quec0O0Ba/sH/C7bViAWJfFrvNNGt1/72tdGrrcX6YEHHhiR5dRTT+3dm/4yjtR9cQVvV42Gxw3O\n", + "NVu9rsOEfv73f/+3ZzE6JubNb35zRET867/+a0T09cL13IMYIGSx55MxmpycjHvuuScihrGArrKO\n", + "9UZsyznnnBMREd/5zndGZATME+5J5Wb0cdRRR/Vkdw0216ABtm65N2NEVXGAlchP4vSI12k9HvbS\n", + "uOq+axq13ou2n9zLlc3tcWDeoKdWj/Zu25L2eNpb5JhBe+pYR8wXan0dddRRvXlu7x+Vrr/5zW+O\n", + "9BdYj+bzsxeAudt6Df0dYJYJe5p9PevKnku8pPbs8vvy5cu7PQbdZv1kjrJusppW9hL+zu/8TkRE\n", + "fOtb34qI/n6xc+fOTh6eJaxnw7F07DHMQT+70Btz+j//8z8jIuKEE04Y6VvEUHeMCXOQ+W5+W8eA\n", + "urZZxpxA/1/96ldHxJAftX2bwljwGfewBx/Yc2nPdeZ9ZqzZJx555JHeM9pxZbBlmFtwIZRHqlAo\n", + "FAqFQmGRWDKP1IoVK7oTN6dbMzADTpx4ZNasWdNZ1vaGcLrl5MmJkirh9kABTrF4MLA4fIJtT+Tc\n", + "K+NlsrcH6yjLUuE0Tz/pN5bKuCrb6A4OLaz5LEaCUzwyjIt1ioheNiD64PrW2rFVD2yJA8YXnjq8\n", + "QIyp20HPWGZ4XbDAW704lgPLy+/wAZ87Pol54krefB89tJaa5xZjQ7/w2PzXf/1XRPS9Oo6lAHgD\n", + "LTvXTU1N9eKprENbkGeeeWZERHzjG9+IiL53lO/zOeuijctqsWPHjs6DRpuMFxak+2lGAHTtNY1e\n", + "GSPPxdbLlMUTOrallbuVEZnpp71AzGXzv7G2W+8p1r/5xviZeVIYV7wF9Derwk176OPlL3/5SBxp\n", + "KzcZgGeddVZEDOeiPRLIwpg6ztNz1HyCMzMz3T3Ny0h/GGdXrPbc8ud4GPAiZF6GAw44oPMCOWPO\n", + "YG09+OCDI236LQDrCN2jx+9+97tjr29lY47QhucW85y/M4ZZfB97G/plzrfV5QH/h9eUn+xNlpt7\n", + "em9nLOzB9psbPFG033rIGR+zjXAPjz/9or/eHwz6yvfaNe+YR8adt0WsOd502SOdYckOUlu2bOkG\n", + "CZd++7cWdv1OT093Cx/lAgaJQTG1hR8YgE0KRfJ9t98G4RJUy6SzS5JB86Rj0/bCQHa/CnRJhnG4\n", + "//77I2IYcMgGD5i0PmgguzdG2kEvftXXPgR8YHIwuMF4ooe77747IoaL0a+lHKTNQjvyyCMjYvR1\n", + "HW1wb/prVzXgIcc9TjzxxIgYbmoZ4bLJsScnJ3vX+rD6z//8zxEx1J03BH/OK+MsaJ8xXbFiRZxy\n", + "yikj/fWDFBnQ1V133RURQz35EMjnPKzom0mswf777z+S6hzRD1gFJoilTfpjvXA9uuc1Nn3BSIrI\n", + "H5Tozgdj1hxzClkdfOt20BfjT7utXtjH0KU3cR/qnHrfjm8rG0DP7DvtwdwPNh+6WHP0x2sOXfO5\n", + "CZI9/rSDjAcffHDXHx8YXZKCuWrdAgf+MydpJzsE/PznP+8ehONIpdt7uowF/fC+SL95+P/Lv/xL\n", + "RAwPM6a92rFjRzfO7KG06bnKHGJe+0CR0VMh0+tf//qR69q+so9zmGPN8DzMDG+XdbDufT1jYYdE\n", + "a2D4dar14X2OMWGeO1jdcJJX+yzzGmJO8SxHfsYgC/A36tVeoVAoFAqFwiJRFDGFQqFQKBQKC6Ao\n", + "YgqFQqFQKBT2MJaUIob3pryX5N0o70CvvvrqiOjTG0xNTXVxFARDfvGLX4yIYQl/3oU6ONg0K9AP\n", + "8H6Wd+m8O0XGj33sYxExTNWfnJzsxRcgH9Q2lNnnnS3vyh3b8Hd/93cj/cwKc1r2iy66qPcOl37y\n", + "+Z//+Z+P6IXPkcFxR7QNRQTvxvkeeuF9/qc//emu5L+DSBkDdEjb0JXwjtuBzfT7iiuu6PrZ9p+x\n", + "4n3/k08+2ZUU8LWmIaK/UD4wnvQP/TlFHVkyKoRW7r/5m78ZkYV+cm90SGwI1Aam2nHKOnEI0DJA\n", + "ndC27SJ1XIssDqbnd4JCoatAFuuc2ArmxT/90z9FxC6qFeTmWtYFOjKFh4OkHQsBpQg0LtaL+3r1\n", + "1Vf3xt/6od+sUahwnHrP+iDW44477oiIoc6zOb58+fJObuYK/TI9B21AywNFDHPOemTeXH755SPt\n", + "gzbmBJ1AJ+Pxz4LuGX/Lztwmzod2LEtbFNSxnbTN+DOfTc+U0VuNCx5uQV/R4+zsbPcd5ivjC0UI\n", + "c8vxXCS0MBehlHn3u98dEcMgZJdb4XrW3cUXX9yLnUXXfAf6MdObAX5Htttuuy0ihs8uB4AT38N9\n", + "rrvuuq6f6IN7E0vHuv7Hf/zHiOjvo8AJEx//+McjIuKSSy4ZuScyt/sva462XQzT9DPsi36mu21+\n", + "Z0/3Hk0c47Jly7q2b7nllogYzhUnshCnyPmBuZuhPFKFQqFQKBQKi8SSeaR27tzZnUApwEmGnTMf\n", + "nK12+OGHdydLp3VzOrUV4OKfAGvIHgusXWcQtCds7oEMpOVabqxgLEsKCjqd3cUDsRoozOlCpTt3\n", + "7uy9s6WIn/sPnGGIZ4nMqbbtiH7RNGRuM5BsUSCTs04Af3fBTqwAZ5BwLxcHBC4+GjHUHbKRueF0\n", + "VvrnQnuUZnDBV1tN4PDDD++8OsDUHswDMsKyNF57AR577LGIyDNUI4ZWOpYlcyZrG/2cdNJJEdHP\n", + "2rLHhbmNF5C1CtosHuRGR1lKOLrH60OWqte/vcTolfXQFs3zfHXquLP2TIXEGPG5M6U8p50m384L\n", + "r3/2CbwAHiPrnAwpU0UZptraunVrmhHINYwnxSHvu+++sbKga/TmMgruK7LOz893NCQuauhsTpO5\n", + "u3SFiwkzD0jhZ96AliaI7zgDGphAGO8F+4VLd5hQGi86RYG9LtpsXnSPLFnbgPnCmvPeZQ83MpHB\n", + "7fIqbT8pyEoG7Ne//vWR61zmw29TvEf7ecPvyNzuXawHe2b9/DB8vcscAOuxfZvifdu0TTzf2Ms9\n", + "RhnKI1UoFAqFQqGwSCyZR2rfffftvVfmBO46Uj6hTkxMdNaI66W4/ocJH7PTLtdhkWDt2lKn3enp\n", + "6a4tTrG2vE1tQ20nxwIATtbooy24GNGvmzE1NdWjE6C4pftJv7BeTM9hz54teq7j89YbMq44Y/vd\n", + "jLQWmandhez2jrk9PFJYus8++2xHkeKaXQAvkGv5uC6OC9G5HpNjaVrrJysk6MKc/LRnzZ49y5IV\n", + "6ly1alWPTDSrl4PO7Zm1FefCm8y9tWvXjlz/7//+711fHU+F5b0QOW9GDA6wit1HEymPa8sFei0L\n", + "nhbTj/DTenQfXIeqpQhBbq6xZ82WtGu7mYw2I5b1XjcYDFK6KsfdsYYWKlSMHvC4eI06dmZ+fr5r\n", + "03uR6/x4PmT15/ictYpHz3sXMszOzna65jte/yZzZr5QUJJadW6bezLerItxbwJcJNbjBkzO7rps\n", + "1gufM+78tAcsYuhRQj5q1EEnQyFS4BpPrg1nWTIaMLyqbV1Dxyt6L8q8vvbMZjFztIs+23VmOR0b\n", + "xd+ROytYbZRHqlAoFAqFQmGRWDKP1ObNm3vZWq5CbWCxPf300yOeoRa2grAYMk8Fbbp6OqdkWxht\n", + "zAVxBlivPkmb4BMLHe+YY6psPfM7mYm2ptv74dX53ve+FxF965Vr0Rc65921rSP6beLHcRWC6Z/f\n", + "cWc6d/V5UyIsVNkarwrewrav9NOWB5ZoVh3aWYnHHXdcRPQtL3sJ+f4zzzyT3tNtYO04dgR9mbwY\n", + "WQxknpyc7LKpsNIzuZlT6Pzb3/52RPT1BbgeTwT3JKsJ7Lffft240i/GwqTTjqFiHDNyZvpCe+wT\n", + "fK+VvY2PaX/PaIzsBeTezEF7mV1VGcubOdnuR6aZIq4IubMq7LTNvsK68Nx1rAk48MADe2sPfbTE\n", + "7xH9WElgD633JI+pPR6rVq3qYnTskTL1lb2oHiPaNFUWJL32GjNGs7OznR5YFxnll6lvTDANHJ+D\n", + "d/nf/u3fYhy2bNnSq+RuJg9gkntTvXic7dlEVuZX6x11zBsxoMRfeb/wWxDHs2Vj6njQcd5FrzXa\n", + "zjJKXXXeFGveuxh/xz/Pzc31nnPokHvzXESHRVpcKBQKhUKh8AJjyTxSmzZt6t7TmqzQMVKcFvk5\n", + "MzPTe88OHMvjekL2YDlbwxkl2fv66enpnlfMVqDjabhH5gXiXr4n7drj1VpcjnGwxej+79ixIzZs\n", + "2NB5MmypmWvIBKPj4Joqjm0BjI3rnriumGVHRiwze6raa21J24MEXOvIdbk8Fs4UaT09WYwc9+bv\n", + "jP9+++3XZXC2/Xd8Qhb3hLU0OTnZs748F71e7CW1h4n+ubabY0za6z1OeGC85mjDNWfskQN4RzK+\n", + "xNY6xlp1PIozYsFTTz0VRx55ZC+GzB4ZYH2Acdxs1pX3Jq85e31Y03hTLIut/jZjzla9ufLsUcji\n", + "+zx2eJmy/YaY1a1bt/b2AfcTfTzxxBNxxBFHdG1mhNPonCxP1q69Ri1v4jii9xYeZ3uBrBfmh/cX\n", + "Pnc24z777NPbgzLPCx5IPuenn2Eg05NrBLb99pzhmbRhw4aReDB7gZjLGa8s4O+uU9fK7lg4xz4t\n", + "tAdn88kymPN12bJl6bxlDnkdP18WliXzSDlNtLD3UWOw9KC0QWFpUGtg6cFrxsLSgYSGwuJQXHuF\n", + "QqFQKBQKC6C49gqFQqFQKBT2MJbkIPXrv/7rS3HbQqFQKBQKhf/X2N25ZUle7RUKhUKhUCi8GFCv\n", + "9gqFQqFQKBQWiTpIFQqFQqFQKCwSe/0g9bWvfS2OP/74OPbYY+Oaa67Z27f/pcWaNWvi1FNPjTPO\n", + "OCPOOuusiNhVYfvss8+O4447Ls4555weZ1Xh/xv+6I/+KA455JA45ZRTus92p/Orrroqjj322Dj+\n", + "+OPjrrvuWgqRX3QYNwaXXXZZrF69Os4444w444wz4s477+z+VmOwZ7Fhw4Z43eteFyeddFKcfPLJ\n", + "ccMNN0RErYO9iWwMah3sQQz2Iubn5wdr164drF+/fjA3Nzc47bTTBg888MDeFOGXFmvWrBk888wz\n", + "I5996EMfGlxzzTWDwWAwuPrqqwcXX3zxUoj2osXXv/71wfe///3BySef3H2W6fz+++8fnHbaaYO5\n", + "ubnB+vXrB2vXrh0899xzSyL3iwnjxuCyyy4bXHvttb1rawz2PJ544onBvffeOxgMBoPNmzcPjjvu\n", + "uMEDDzxQ62AvIhuDWgd7DnvVI3XPPffEunXrYs2aNTE9PR1vectb4itf+creFOGXGgPlFfzDP/xD\n", + "vP3tb4+IiLe//e3x93//90sh1osWr33ta+OlL33pyGeZzr/yla/EW9/61pieno41a9bEunXr4p57\n", + "7tnrMr/YMG4MIsbXg6kx2PM49NBD4/TTT4+IXZX4TzjhhNi4cWOtg72IbAwiah3sKezVg9TGjRtH\n", + "ytCvXr26qtruJUxMTMQb3vCGOPPMM+PWW2+NiF30GJARH3LIIR1dSOGFQ6bzxx9/PFavXt1dV2vj\n", + "hcWNN94Yp512Wpx33nnda6UagxcWjzzySNx7773x6le/utbBEoExeM1rXhMRtQ72FPbqQaoqmi8d\n", + "7r777rj33nvjzjvvjJtuuim+8Y1vjPx9YmKixmcvYyGd13i8MLjgggti/fr1cd9998Vhhx0WH/jA\n", + "B9Jrawz2DGZmZuKNb3xjXH/99R2fHah1sHcwMzMTb3rTm+L666+Pl7zkJbUO9iD26kHqiCOOGOG2\n", + "2rBhw8jJt/DCAYLogw46KH7/938/7rnnnjjkkEPiySefjIhdxKGQoxZeOGQ699r46U9/GkccccSS\n", + "yPhix8EHH9w9vN/1rnd1ry1qDF4Y7NixI974xjfG2972tvi93/u9iKh1sLfBGPzhH/5hNwa1DvYc\n", + "9upB6swzz4yHHnooHnnkkZibm4s77rgjzj333L0pwi8ltm7dGps3b46IXSzwd911V5xyyilx7rnn\n", + "xu233x4REbfffnu3wAovHDKdn3vuufGlL30p5ubmYv369fHQQw912ZWFPYsnnnii+/+Xv/zlLqOv\n", + "xmDPYzAYxHnnnRcnnnhiXHTRRd3ntQ72HrIxqHWwB7G3o9u/+tWvDo477rjB2rVrB5/4xCf29u1/\n", + "KfGTn/xkcNpppw1OO+20wUknndTp/Zlnnhm8/vWvHxx77LGDs88+e7Bp06YllvTFhbe85S2Dww47\n", + "bDA9PT1YvXr14K//+q93q/Mrr7xysHbt2sGrXvWqwde+9rUllPzFA4/BbbfdNnjb2942OOWUUwan\n", + "nnrq4Hd/93cHTz75ZHd9jcGexTe+8Y3BxMTE4LTTThucfvrpg9NPP31w55131jrYixg3Bl/96ldr\n", + "HexBFEVMoVAoFAqFwiJ6dsjvAAAAYElEQVRRlc0LhUKhUCgUFok6SBUKhUKhUCgsEnWQKhQKhUKh\n", + "UFgk6iBVKBQKhUKhsEjUQapQKBQKhUJhkaiDVKFQKBQKhcIiUQepQqFQKBQKhUWiDlKFQqFQKBQK\n", + "i8T/A2aklexSCttuAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "source": [ - "The fifth layer output, `conv5` (rectified, all 256 channels)" - ] - }, + "output_type": "display_data" + } + ], + "source": [ + "filters = net.params['conv2'][0].data\n", + "vis_square(filters[:48].reshape(48**2, 5, 5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second layer output, `conv2` (rectified, only the first 36 of 256 channels)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "feat = net.blobs['conv5'].data[0]\n", - "vis_square(feat, padval=0.5)" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJNCAYAAAARaCA+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3VmQHWd5//FnbO37OqPRaKSRtXgsy0tsAQJMGeMFXAES\n", + "EuLEkISCcBOqcoFTgRQ3mFQlOBdJqkKKqn8BqSJcEKiQ4FAE4TLBAhvLWizZ1jraRtKMZkbLaN8X\n", + "/y+cefXrV9Otnvf0ds58P1dP6/Tp7tOnT0/rfd73eZvefvvttw0AAAAjclvZBwAAAFCPeIgCAAAI\n", + "wEMUAABAAB6iAAAAAvAQBQAAEICHKAAAgACZP0StWbPGOjs7bdmyZfb3f//3WW8eAACgEpqyrBN1\n", + "7do1u/POO+3FF1+0trY2e9e73mXf//737a677spqFwAAAJWQaUvU+vXrbenSpdbR0WFjx461P/qj\n", + "P7Lnn38+y10AAABUwpgsN9bb22vt7e1uecGCBfbaa69F1mlqaspylwAAALl5+OGH7aWXXhr2tUwf\n", + "osp+QOrs7IwsHzlyxMWDg4Ox75s2bZqLly9f7uLdu3dH1jt16lRNx7do0aLIck9Pj4uvXbsW+74F\n", + "CxYM+54kmqUt63uZM2eOi/1zN2bMjUtv0qRJLvazy/q+pHM0a9asYbd38uTJyHpnz54d9v3jxo0z\n", + "M7OrV6/amDFjbMqUKcO+Z8KECZH36fLAwICLsz7nEydOjCxfuHAh0+3XK71e9DszMzt//ryLW1tb\n", + "XTxz5szIepcuXXLxnj17Uu23ubnZxXrtmZnt3Lkz1TbU2LFjXXz77bdHXrt48WKqbcyYMcPFei78\n", + "e4beh06fPu3iEydOpNqP/xut9Vr3P6/eN/Q35dPP6//Old7f9fPqfcLsxj3A355+Nz69J12/fj12\n", + "vdmzZ7tY7+dmZm+88caw75k+ffqwx2NmdtttN5JIzNyWn69+9atmZva1r30tdp1M+0StW7fOnn32\n", + "WVuzZo2ZmX3961+32267zb785S/f2GGOf9DHjx8fWdabY1r6Az527FjNx1SWoh6i9OZgFr0h6kPs\n", + "aBByzvVh0szsox/9qIt//OMf13xMn/70p128a9cuF2/cuLHmbSdZsmSJi/WPweuvv57pfvSc+30v\n", + "r1y54mL943nu3LnIevqwldZHPvIRF585cyby2iuvvDLi7RXp7rvvdvG2bdtG/P6sH6KqSB9C/f+w\n", + "JP1nLo7eJ48fPz7i94+Gc15FQ+e9qakp9mE10z5Rq1atst27d1t3d7ddvnzZfvCDH9jHP/7xLHcB\n", + "AABQCZmm88aMGWP/8i//Yh/+8Ift2rVr9md/9meMzAMAAA0p04coM7Mnn3zSnnzyyaw3CwAAUCmZ\n", + "P0SVKaQPlK+e+0EVRTvf+50zt2zZUvTh1LWrV69Glnfs2JHp9rWP3+HDhzPddhL9LWb9meJ0dHRE\n", + "lrXT///8z/+4+PLlyzXvS+8T/ndYdSH9oBpFS0uLi5M6rWvfzpA+UGbRe2NIPyjUB6Z9AQAACMBD\n", + "FAAAQICGSudVnQ77NjPbu3dvSUcycvPnz3ex1sh58803yzicytOis2Zmhw4dSvU+LUOQln4fflmJ\n", + "b3/72y7+0Ic+NOJth0pbzywtHdIdN9TYrwGmw8pDUzJxNG3t1zmqGv/4sj4XWsNMayppWYlQmhLz\n", + "6wBu3rzZxWkr9WiKV1PdZmYrV6508bp161Jt75FHHnGxXyrDLzSNxkRLFAAAQAAeogAAAAKQzitQ\n", + "1s3oRdKRXUWO8krrsccec/GLL75Y2H790YlD/PRd2ikqQiRVhtfq3HFT3pRJ0yG//OUvY9fTdM3k\n", + "yZOHXae7uzv2/Vn89jRtpVWsqz46L+/7jl7bWU9HpFP0+OmykMk2Dhw44OKlS5dGXtNRi2mn2km6\n", + "ZhHOn8mhqN+Yv980aIkCAAAIwEMUAABAAB6iAAAAAjS9HZJYrmWHo3j26XHjxkWWs6icHEe/1kY8\n", + "5+95z3siy9u3b3fxmTNnij4cM0t/zn/7t3/bxT/96U9zPSY1fvx4F2dR3T8Ln/nMZ1z83e9+d8Tv\n", + "13Pu/750WfuGhWptbXVxX19fzdurV/6fDC1rkHXflZDK4X4/Rb8vVZXFXWP+OW/Ee7p+b/51lOff\n", + "yiRD572pqSm2Dx4tUQAAAAF4iAIAAAhQSjpvqGps2mGkGLmqp/NWr17tYi0H0NvbG/ueNFWry5T2\n", + "nOtEuX5arVHSRNo0n2c6pcjrXL+3pHIKWgm7ESc09397OpuBVikvMoWq1cz9c16178BPO3/wgx90\n", + "8caNG108ODjo4kZN52nZEJ15QUtRlIl0HgAAQE54iAIAAAhQSjrvgQceMLObJ6+teuXfWs2aNSuy\n", + "rM21WYtLc2jzqVn2FYbTqvpIJ61cm/a6DEktTZs2LbKsKe6yRqTUEz3n/rUd113An8h2586dqfY1\n", + "b948F/f396c9xEq74447XLxv375U7/H/ZOhI2U2bNrnYH02n5+/UqVMuTroH6fEdPXo08lpZo3Dj\n", + "6OhXs+gk5EmpzTT3v0ZN582dO9fF/vdbBaTzAAAAcsJDFAAAQAAeogAAAAKMfMriDAwNZfQry+rw\n", + "2Ebkzz6fZ5+oOGX1gfJVsR+UKqp/nn/Na785/a7K+t5mz54dWT5+/Hgpx6G0hIDyZ2DXStpXrlxx\n", + "8f79+4P2q31eiirhkLcs7rl6H0uqKj5jxgwX63e4devW2Pfo8fn9B9P2ibrtthttBdevX0/1nrTu\n", + "vPNOF/t9erR0S1VmCKiaKvaDGilaogAAAALwEAUAABCglHTeUPN3o6fvfJpSAIajqRGdfLUs06dP\n", + "jyynTecNzUpglv3MBH5afMjZs2cjy1OmTHGx/vZCUytTp0518eHDh4O2UTVp08SaEvP5Kd8h/pBw\n", + "LdmhJQ6SZFFtPOsUnl7bu3fvzm0/qA+0RAEAAATgIQoAACBAKem8MkalVYGfbsDoNHPmTBefOHEi\n", + "dr2kkU5FSVvF2pfn5OJpJyfVCuZZ/PZ6enpcnJSar3o1fpU2tZmUqtJq3JrC27t3b/iBlUyvHT/l\n", + "mee1jfpDSxQAAEAAHqIAAAAC8BAFAAAQoOntuKmJ89phU5ObubkRqpWa3TwMPG747rhx4yLLOuQ3\n", + "a/q1NsqM32np0PYi+6HV0znXc2RWvf56Wm3cLL4PUhXOeVtbW2RZSyHs3LnTxUuWLImsp5XOq953\n", + "Svl/MvI871qlPO+SOB/5yEdcvGbNmlz3NVJFnnPcMHTem5qabvoOhtASBQAAEICHKAAAgAClpPOQ\n", + "vyqkOYr0vve9z8Vvvvmmi+s5nffII4+4eMOGDZHXqpZ+K0uR17mmlhYvXuxiv4q7HpOWqfjTP/3T\n", + "yHqvvfaai9euXZvZceYt69SSTrptFk3dasoztOSHTnys+2pubo6st23bNhenndy4KFVJ5+kk31r2\n", + "olGrtZPOAwAAyAkPUQAAAAFKqViOd2gz88mTJ0s8kvqzfPnyyPKOHTtc3Ciprl/+8pcu9kerjWb+\n", + "KNei6IjG+fPnu/jIkSOR9R588EEXf/SjHx32PWZmv/jFL7I+xErxRy3HVfrOegaLT3ziE5Fl/e1o\n", + "FfV169Zlut/R4OrVq2UfQuXQEgUAABCAhygAAIAAPEQBAAAEoE9UiZJmgsc74oYkHz58OLJe3tWM\n", + "R2ry5MmRZZ3pPgTXyg2TJk0qZb/aF0urkmsfKDOzD33oQy7WfkHf/e53I+tt2rQp60OsFH9GhkuX\n", + "LtW0vY6OjsiyliHQ72Pz5s2R9bq7u2vaL5CEligAAIAAPEQBAAAEIJ1XolpTPKNBa2vrsP9etfSd\n", + "b9WqVZHleqpInTU9Fxs3bgzaxsyZM7M6nGCaWh4/fryLb7/99sh6J06ccPH69etd/KMf/SjHo6ue\n", + "CxcuZLq9pLScXzU+S/73G1o5HY2JligAAIAAPEQBAAAEIJ1XIp1EsuB5oOvGqVOnXNzX11fikYzM\n", + "nj17yj6Eyujq6nLxypUrI69t3bo11TY0fVtWOmVgYMDFOvLMr6Cuk+a+8MILmR7DHXfc4eJ9+/Zl\n", + "uu3Rxp8F4LbbbrQp6EjCrK83v4tCPd3XcDNaogAAAALwEAUAABCAhygAAIAApfSJGhqurEOBRyOt\n", + "ZqzDaPMcrltv9Bqpp6HFvb29he1r/vz5sa/5ld3LoP2Z0vaB8k2cONHFZ8+erfmYQuh3evLkSRff\n", + "ddddkfW0enbWw/ynTZuW6fZGM+1fZma2a9eu3Pa1aNEiFw8ODua2HxSPligAAIAAPEQBAAAEKCWd\n", + "51eAHa20qV9TALihXqu6+8Pe/clYs6QpT3/YdqNoaWlxcVnpPKXXpV9N/erVq7ntN8/rqEialixy\n", + "9oG5c+e6WMunJPG/35BuKAcOHBjxe1AfaIkCAAAIwEMUAABAgFLSeceOHStjt5WjKbxGaabHO4r8\n", + "PjUtnPVosKqoclrXP+da2TyLtJVOfFzkqM88hZwLPQ9m0WtCK4wn0fdoZfkkzCYxctqdodH/ttES\n", + "BQAAEICHKAAAgAA8RAEAAAQopU8U3rFgwQIXaz+KIof8oj6sWrUqsrxx48aSjqQc/f39ZR9CrL17\n", + "90aWx4y5cVvV4fGhv+sPfOADLn7++eeDttEIsqj0nbYflJo0aVJkWavV49a0pFE9zTqRFi1RAAAA\n", + "AXiIAgAACEA6r0Q6NLqvr6/EI2lcfnV8Ha58/fr1og8n2IQJEzLdnn9eGrGZvSj+hOGTJ0928ZUr\n", + "V0a8PU3zm5nNmTMn7MBGkbvvvtvF/m9l06ZNI97ekiVLXBw6ibdOmq0TEPsVz7UrR6No9LIGipYo\n", + "AACAADxEAQAABCCdV6Jdu3aVfQgNr97SVM3NzS4+cuSIi19++eVM9+OfFx2BFDKCCTeETFCrfv/3\n", + "fz/T7VWFpjm1cviUKVMi6+lvYN++fbHbW758uYv1HIWm35TOJhE6C4C+b+fOnTUfE6qJligAAIAA\n", + "PEQBAAAE4CEKAAAgQCl9om677Z1nt7yHmDc1Nbl47NixLh5Nwy9RX7QfVJE6OjpcvH379lKOoVba\n", + "l8YsOtRd+8ycOXOm5n0N3cPMsrmfzJs3z8XTp0+PvPajH/0o1Ta0OrpWTT969GiNR5fetGnTXDxj\n", + "xozIa34piCFnz56NLMf1QdJzbmbW1dUVcoixVqxY4eKsS4qgcdESBQAAEICHKAAAgAClpPOKqhSt\n", + "Q2d1SO1oM3v2bBfHNaljdKvXFJ7ySwPs37/fxb/61a8y3VfW97B77rnHxYcOHYq81tPTk2obOjGu\n", + "n/rKk1ZU1xkB/HuNVsmfO3eui/10Y1xZkrz/bujnCLletCyCWXzaWO/HZtHyIv53j+qjJQoAACAA\n", + "D1EAAAABGqpiuY4MMYs2H2fRFNze3u7iLJpd4yr4Zu3ixYuZbu/BBx90sT+SphHSQmgM+hutehX2\n", + "e++918U/+clPgrYxfvx4F+to5CxGIybRkYD9/f2x6+mEvKdPn871mELUmvK9dOlSqvX8NGetXSw0\n", + "DekfQ97fPWiJAgAACMJDFAAAQAAeogAAAALUfZ+ocePGubi1tTXymlb+1WGzb775ZmS9K1euDLvt\n", + "BQsWRJa1n0Fa2k/LH7qrw3y16nHc8YRK299Kj9X/7PqaVld+7bXXajy6arr77rtdfODAARf71ZWr\n", + "TvsFxg0drzd+38chP/vZzyLL3d3dBRzNzZYuXeriPXv2pHrPW2+95eLQStxLlixx8dWrV128a9eu\n", + "oO2lldQPSsVVIm8URc6E0dbW5mL93v2+v1u3bnWxlsCoCi1DVNa9VWc20fOaFi1RAAAAAXiIAgAA\n", + "CND0tpaYLWKHTU1W8C4BAACCJD230BIFAAAQgIcoAACAAKWMzuvs7DQzs7vuuivy7zox47Fjx4aN\n", + "zaKjjGbMmOHi++67L7Le2rVrXbxu3boRH6dW5jYzmzVrlot10kitxGsWHf23d+9eF/vVZFeuXDls\n", + "rJXMzaIVgXWSS39UjI6+0KrHOvoA+dHm3rLOuV6XZtWv1B0i7j4xYcKEyHo68kdHq506dSp22zry\n", + "r8iq2jryN3R0rt6HdKRY1qMy/bRG3LWuI6f9Y9LvKu2MCv7IKR0lvGnTplTbyIJ+3vnz57t4YGAg\n", + "sp5ec7VKe87zpr8prbKvs3mYRauw68wBu3fvjqyX9aTS+rcyi/OfpusRLVEAAAABeIgCAAAIwEMU\n", + "AABAgFL6RA31afD7/mj/jaNHj7p4x44dkfU016lVybU6s5nZtm3bajpOv9Kv9lvS/Pfg4GBkvZ6e\n", + "nlTb12qyfX19Lvbzy5qH1kri2j/KrNiKuUg2fvz4yHLaGd5rVWQfKO1/lfd+tQp4XAV+v++P9stI\n", + "K+t+UIsWLXKx349FK+HPnDnTxUeOHAnal1YEb2lpcbHfVydr2i9Iv5szZ87EvidtPyjt4/KhD30o\n", + "8pre78vqE6XXXJZ9oKpKq4rrdZrUF1Pfk3UfKF8Z3wEtUQAAAAF4iAIAAAhQSjpvqMnXT3HEDdv0\n", + "hxlq2kpTZ3PmzImsl9ScnIY/IaI2FWqKMYsJgzX14JdM0OPQFF5zc3NkPS33gHIVlb4rU5GpwzQT\n", + "+WpKzCzaJaAsK1ascLGm5c2i5RmyPlZN4fkTp2c9wfnhw4cz3Z7SlJ2WNDAz279/f277TUpVa0oq\n", + "afJl/XvWiLN0aDrPT7Hr32i93vwuPHqfrNd0KC1RAAAAAXiIAgAACFBKOm+oGdYfTaejPLTp20/T\n", + "aepLR2/cdlu+z4RdXV0uzrpJXJt+tTK6WfRzaYrSP39+GhColZ8ivv/++1380ksvxb5Pm+31uvRn\n", + "H8iSPyJSj12r+RdJj8k/l353gbxkfa9KknXFaK1s7n+Hed7vsjj2hQsXulhHYjYKHclaZHX/qqEl\n", + "CgAAIAAPUQAAAAFKSecNNf3pRL1m0SZUTe1pQU2zaJOxpgf03/OQZ5OlFuVbtmxZ5DWdMFXTeTqx\n", + "o9nNE7CiPP53kba4YAgdtZQ0Wkj5qSVNlWgq7rHHHous9x//8R+ptq+jc+KKY+ZNP6MWoixy5KTe\n", + "n/zfa1n03qrXSxaFEDWFtW/fvpq3p5NN+2lJ/buQ9Ui4LAoXN2IKDzejJQoAACAAD1EAAAABeIgC\n", + "AAAIUEqfqCH+MFKd8FeH9fsVY3XSR10v78kN86QlHfw+G3GVYf0+YH41WJTHrxKdZ5+otP2gVNKQ\n", + "f73G0vaB8uU5rN6v/D3En/hbvwPto+ZX+s+6r5KWNdB+QWWVWfBlXWFcS634k0DXSvsm+aVutBSM\n", + "ftdMxI4i0RIFAAAQgIcoAACAAKWm83yaxtqyZUvsenEpvDxTJnnTY/eb23WiTT1HfsooLs2B4tU6\n", + "+fVoNHfuXBe3trZGXnvrrbdcnLbSt6YUNc77u9FuCnlOzptEU/t5l5jQFF7aYf06kXrS96H3NP/+\n", + "rqlSTdH6ad1GpJNtnzhxosQjAS1RAAAAAXiIAgAACFBKOm/atGlmdnMzc9qRHXGj8Op5EsSBgQEX\n", + "Dw4ORl6La+72R/ssWbIk+wNDkEmTJkWWdcRQyOSmfgV0rcYdMjov1IIFC1ycRdpk3LhxLj569Oiw\n", + "cb3JeoRaCH9y8qppaWlxsf93QO/vmqrasGFDZD2d5aGzs9PF9ZbO03OhfweSPProoy7We4GO5Pa3\n", + "19fX52L/nqG/w6Imxq6KWifNpiUKAAAgAA9RAAAAAXiIAgAACFBKn6ihYfpV6DtQFSHDro8fPx5Z\n", + "zrNKNEbGr7JfK394d5H9oFRIfxMdfu732aC6dHa0greWgSlS2tIFBw8edHHSTBNJfbve/e53u1j7\n", + "IL744ou3PM4iaOV6/W60b5JZ2L3i7rvvdnFHR4eL/XIHu3fvdrGWCUmaBaQK2traIst6PWvf5/b2\n", + "9sh62p9Lz7M/C4iWU9H+YL29vSM+VlqiAAAAAvAQBQAAEKDUdJ7f5FzPEwiXwU/f+akSIE/aJJ5U\n", + "kqAK16VW92/UtLemdbRMyrFjxwo7Bk2/+WU+NIWUNo2rfyP8lJMOR09bEuPhhx928dq1a1O9J5Re\n", + "Z9OnT3exn84L6cqh29BzuX379sh6e/fudfHWrVtHvJ8izZs3z8X+ZNOaptR0Xuhn0meNWmf6oCUK\n", + "AAAgAA9RAAAAAUqdgJj0XbbqeQJm5GPlypUu3rFjh4uzGI1TT1XFGzGF50/SrDMY+KORinLhwgUX\n", + "J6Xz0tJ7mv/3QiuYb968OdX2dIRa3jQV6afwarVp0yYXa8X3nTt3ZrqfrGkXALPo71JT7n4Ve628\n", + "/vbbb9d8HDqy3R/lPlK0RAEAAATgIQoAACAAD1EAAAABSu0ThWzpbNSAWfWHNWcpqb+F9hdKS4dc\n", + "m5VXJT6O38fo1KlTsa8VRftiJfXLmjx5sov9/i9qxowZLp49e3bkNe3Lcvjw4VTHp6Uf8tbU1ORi\n", + "/W6y8Oabb7q4nvr7+d+1Xqchv9EqoCUKAAAgAA9RAAAAAcj/VJAO9TRL31xbT826QNb863/BggUu\n", + "DkkVVC1958s6RVSkpBSe0rSfP7muVkcva8LlJHnej8u61+t51u9GY7Po96vlVMpKM+epelceAABA\n", + "HeAhCgAAIMCoSeeNGzfOxWknv/QtWrTIxdpcmTTBpzZ/pq3QHtpUqxMzAo1KRz0pv5KxTuyq6QZ/\n", + "vUZMMWQh7jwX6Y033nCxP1pSRyPzHRajra3NxTqpsk//htVaEbzqaIkCAAAIwEMUAABAAB6iAAAA\n", + "AoyaPlGh/aCUDpPW/hZJdBhu2j5RoZL6ZgETJkxw8cWLF0s8ktrEzeI+derUyHJPT4+LdZi137dm\n", + "4cKFLt65c2cWh1iK9vZ2Fy9evNjFfl/JLVu2pNqenme/7EqW0pZ08fs9hfQB1b6x/nVEiZhbO3To\n", + "kIuvXr3qYv9vW6P3g1K0RAEAAATgIQoAACDAqEnnZUGbk5NSczo0uMgmYpqjkSQkhTd+/PjIctKk\n", + "smXzr39N4Sm/Ermmk2bOnOliP2Wv5Uqy6B6QNe1u0NnZ6WK/mrR2Mdi0aVOqbVeh+rb/fejniPuu\n", + "fZrOO3v2bKr3ZG3ixImR5QsXLpRyHLXq6+sr+xAqgZYoAACAADxEAQAABCCdNwJpm501BaLvSdvk\n", + "jOFNmzbNxVRnz49Wgq5i+m7+/PnD/rufYk97vWhaQkcc1RtNd23fvt3F/mjEgYGBwo6pVpp+87/f\n", + "GTNmuDjtyOSyUnhKR4Oame3ataukI0EWaIkCAAAIwEMUAABAAB6iAAAAAjS9HVf+N68dVmBm8Lzp\n", + "ENayhq/q1zoaznkVVPGchwwD12PP+/agv5UHHnjAxTt27IisNzg4OOz7k8659k1M6ts1a9asW+6n\n", + "nmVdpsK/JuKu9enTp0eWT506VdN+G4XfR80vuTGctOcc2Ro6701NTbH3QlqiAAAAAvAQBQAAEIB0\n", + "Xg50ItS0ExVnrYqppUbHOb+1jo6OyHJ3d3dN2ws5562trZFlrVh++PBhF9dzuYOsaakBPx1Yr9e6\n", + "VqA3Sz9B/KJFi1x84MCBTI8pDum8cpDOAwAAyAkPUQAAAAGoWJ4DnfCzrHQe6sPcuXMjy0uWLHFx\n", + "V1eXixtl1Fit6TszsylTptT0fiZOTUdTRlWccFmFzGagFc/N0v/Gar3+0FhoiQIAAAjAQxQAAEAA\n", + "HqIAAAAC0CcqQdaVfgHf0aNHE5dxszlz5qT6d+3Hk7afjNJSJf72GvFe0NLSElkeGBioaXt+KYk8\n", + "+6KFfL+h1X1CyhrMnj3bxcePHw/ab1H0Orhy5UrktUbpm5klWqIAAAAC8BAFAAAQgHRegtAm+zQT\n", + "SuZBSysAvgkTJrj44sWLqd6jk/OahTXn6zYWLlwYeU2rRmu6rL29PbLeq6++6uJDhw4Nux//99rc\n", + "3OxiHa6fdiJcv6L14sWLXbxz585U70tbBbsKak3f+caMqfafl9AJkc+ePTvi92gpkyqm8/S70omj\n", + "dYJws+iE5nQ9eEfwVd7R0WHTpk2z22+/3caOHWvr16+3wcFB+8M//EM7cOCAdXR02A9/+MObanEA\n", + "AAA0guB0XlNTk7300ku2efNmW79+vZmZPffcc/b4449bV1eXPfroo/bcc89ldqAAAABVEjwB8eLF\n", + "i23jxo2RUQednZ22du1aa2lpsf7+fvvgBz94U7M3EyfmZ8WKFS7etm2biznnxch6AmJ/dKhKm2rW\n", + "baR9j45yO3bsWOx6mj5euXJl5LW9e/em2katmPS5eGknw9X0sVn6FHLVaZr4yJEjhewz7wmINQWt\n", + "Fdn9e5Cup6l9fxRfo8h1AuKmpiZ77LHHbNWqVfatb33LzN7JqQ8Nj2xpack8xw4AAFAVwX2iXnnl\n", + "FWttbbWjR4/a448/bp2dnZHXm5qa+J8hAABoWMEPUUOF1ObOnWuf+MQnbP369S6NN2/ePOvr64s0\n", + "ewIAANSLZ5999pbrBPWJOn/+vF27ds2mTp1q586dsyeeeMK++tWv2osvvmizZ8+2L3/5y/bcc8/Z\n", + "yZMnb+pcTutUfu69914Xv/HGGy7mnN9w3333uViHyp87dy6yXlyO3x+yrsOBT5486WK/NMDq1auH\n", + "3ZffT+m1116LPXa8Y968eS7WKthc58UI7Z8zbtw4F2s5i6rz+/vpse/fv9/FefYLSjrneq/xyzZc\n", + "u3Ytt2MaDdL0iQpqiRoYGLBPfOITZmZ29epV+/SnP21PPPGErVq1yp566in7zne+40ocAAAANKKg\n", + "h6jFixfbli1bbvr3WbNm2YsvvljzQQEAAFRdtUvKYkS0aRnv8Iu9alrtnnvucXF3d3dkPa06f/Xq\n", + "VRf7E53Onz9/2P1qms/M7Gc/+1m6A66Y97///ZHlV155paQjuaGsGQFQmyqk8LQC94ULF2LXW7p0\n", + "qYv91PzGjRtdrGUcxo4dG1nv/Pnzwcd5K0uWLBn2GE6cOJHbPjE85s4DAAAIwEMUAABAANJ5DSRk\n", + "YsyZM2e6WJu6Dx8+HHQMkyZNcnGezdlp+aPfurq6XKyjaXp6eiLr6Ui7BQsWuNgfnacV+5WfHozj\n", + "p/1CJ0WNo6N4QiYnyDt9p1XP/RGSqD86QW0WI8NCJs1OkpTCU9oNwL8udRuBE37UTGcE0CriZR3P\n", + "aEZLFADlD3hmAAAgAElEQVQAQAAeogAAAALwEAUAABCg1D5R/rQw2ocmpH9PFrSPUNJw0ba2Nhdr\n", + "XyIzsz179mR/YCn4w/mH6Kzc/nmdO3eui/X78Kv0aq5dh/zPmTMnsp7O+t3b2+vizZs3R9bTPkd5\n", + "0pIGZtGhwdpv6e67746sp+ds0aJFLj548GBkPT1/yp/BXod3ax+GLPpAab8q3bZZ/DXsnxf93tau\n", + "XRu7L50jUz+jP5u99ofRod967ZiFlSvwZ5ZHuRYuXOjiadOmuXjMmOifF+2PmNRfUu/BKqlP1IoV\n", + "K1y8ffv2+IMVfukC/e3ofdIvzTB16lQX+yVPyuD308ySfz/RqvNZ9FFLS68lvYf71fL1mNL2S60V\n", + "LVEAAAABeIgCAAAIEDQBcU07TJjIDwAAoEqSnltoiQIAAAjAQxQAAECAUkbn+T3qkQ2trH3o0CEX\n", + "Z3G+Ozo6XHzgwAEXp03N/tM//VNk+ec//7mL16xZU9vBJZg3b15kudbJa5MqjOu5yPsa15GY+hl3\n", + "7tyZ6v06isosbJSRjpjxR90VpaxzrtXuR0Olda0s74/w1RFbWrHc/63oejp6078WdeSzjuz0f7s6\n", + "ckxHivqjvpcvX+5iHRXoT9iuv+Wka1tH7ir/Xqij+rTKuT+6VK+fY8eOufi3fuu3XPyf//mfkffw\n", + "N7QYaf6+0RIFAAAQgIcoAACAADxEAQAABCi1Yjmydc8994z4Pdp/QPs6+BWFa63++sUvfjGy/Lu/\n", + "+7up3qd9MUL6nvj9KLT6uPZT8Cuo+1WKh/gVxuOqxGtfDrNoH5oQfnVl/a527do14u35leZD+kSV\n", + "1Q+qLFopeevWrSUeSfGSfnvab0QrRvsVrbUfj/aP8q8j/a3o76unpyeynvYf0m3rb9wseq3r/UT7\n", + "ZfnHoZ/pzJkzFkfvi37/Ge2npb+vSZMmxe5XZ3mI63uFaqElCgAAIAAPUQAAAAFI5zWQkHSeP3Fs\n", + "UX784x+nWk/TCKtWrXLxli1bIuvpJNBJze9ankH5w441JRD3HrP4iZRrTd/5/Mlc49KNae3bt6+m\n", + "948GfkpWly9dulT04VSWpsiSJtTWdFdLS4uL/cm/BwcHXawpQT/9FrdtTfOZRScNv/POO1189OjR\n", + "yHp79+51sd5P/Anm9d6gaXX/XqDXiL8vpek9vcbiJg/Pwr333htZfvPNN3PbV6OjJQoAACAAD1EA\n", + "AAABSOc1EL/ZuV78xV/8hYu/8Y1vxK63cePG2Nc0haepubRpF389TeHpSKJa02gjoVXis04P4tb8\n", + "9FFc6rZR6e8oqUK2jqCLq9JtFq1mriPX9Do3i45K01Tc7NmzI+tp6kv35Y+Se/nll4c9Bv9+6R9v\n", + "HJ0NYvHixS7W+4SZ2YYNG1JtT0dC6znXc5S3ou5xmsY1MxsYGMhtX2m9//3vd3HIiGNaogAAAALw\n", + "EAUAABCAhygAAIAA9IlqIP6s6VnS/LxfibhW3/rWt1z8j//4j5HXtF/KX/3VX6XanvZvuu+++yKv\n", + "vfHGGyM+vpA+AqEVy7W6clwl4yJpWQkzs507d7pYh3cn0SHhU6dOjbyWtvK39mVJGuqepevXr0eW\n", + "0/aZaRRp+xPqta59XvxyB/ob0Nf84f/aV0l/D36ZD63if/jw4djj00rnv/71r108f/78yHq6L60w\n", + "7vex0uteP7vfxyqpH1kcPed+2ZU0pk2bFlnWe4j2vSqrpEGRfaD0u0m6/77yyis17YeWKAAAgAA8\n", + "RAEAAAQgnddA4tJOWaRCsk7hxW37mWeeiV1vwYIFLvYnI40Tkr7LQtr0nZ+C1bRp0mfUKsf+ZNFZ\n", + "2rRpU2TZT23EaW9vd7EeX1L19yRFpfCS+Ok93EzTef5EwPodakkSf4YB/e3o0Hv/2tPK5nrva21t\n", + "jaynvyNNxXV1dcV8imgqra2tLfKafkbdr59S1HSSHpOfJtXPoXbs2BF7fHGefPLJyLKmFP/93/99\n", + "xNtLa+nSpZFl/U6LTOHp/VOrsj/++OOR9f72b/82s33SEgUAABCAhygAAIAApPMaiE7Wq7QZ3R/h\n", + "ElKhNURodWCVNoVXRZqW0IrMftN+2s+YZwpPpU3f+bSqcxIdYaXiUhxlSvuZRpvbbrvxf3G91/i/\n", + "eU2DHT9+3MV9fX2R9XQbWhHcv+b1fXof8+9xOkGyHqt/fDoZu/4um5ubI+vpNavpI39EbtqK4zqi\n", + "rru728Uhv71XX301shwyKX2IPXv2FLKfW9GuIevXr3exPyl1lmiJAgAACMBDFAAAQAAeogAAAALQ\n", + "J6qBLFu27JbrZNEH6oEHHnDx66+/nuo9eZZIqCKtfmwW7QOSRX+fPCvI50lLM5hF+7/4Fa5RHUnV\n", + "txcuXOhi7Rfk/wZ0Pa1cf/Lkych62vdMywv4fZO0/5D2B02qXq6lN5L6RCm/3572b9R4xowZkfW0\n", + "b5b2AfX7gGXp4MGDicuNTs+5/q3bt29fbvukJQoAACAAD1EAAAABSOc1kNmzZxeyH03h+RNe6sSd\n", + "KnSofNb0eDVFEZpK8tNTQ/IcUmtWXyk8VVRpBmQr6fervyNNM/sTVOvk1Zqa6+joiKyn14j+Lv2S\n", + "AWlLCCithp62krZ/zfqTaA/xP69WuNf37N69O7Je3L0n7t6CeEWV7FG0RAEAAATgIQoAACAA6bwG\n", + "EjfqSytk+03OSifDTZveikvfZUVH0IRUOffp8Wr14lB+deRaFTXqbv78+ZFlHSFFyg0joSkyTZf7\n", + "1fi1qrWmu/3Rb3H3IT8NFjKxbX9/f6r1dNJ2fz9639DRef79V0fk6mfUyY397SmttI7qoiUKAAAg\n", + "AA9RAAAAAXiIAgAACECfqAaiOXiV1A9KVbFidJ5DVnUIsj+cOG2/oLg+YX515bhqyL4FCxa4WCsb\n", + "a0XmLCRVdQZGQn9HJ06ccLH/G1Baldy/trXqufY5yvo3kET7kfr77erqGnY93+XLl12sFbO1v5W/\n", + "Db3vZPF5s+5TWjX++U/7ty5LtEQBAAAE4CEKAAAgAOm8BqLN4PXKnxS0qCborIf1p03f+TQlW2T6\n", + "AgilaStNE/uVvbV8h6a0/N+KVkfX+4FfoTzP1I2WIfBLEmgKX2O/qrumIvW8+J9j7ty5LtZ7eFxl\n", + "9JH44Ac/6OINGza4OO8ZFYriT3JNOg8AAKBO8BAFAAAQgHReHdOJP80aY/RF0mcIqaheb3R0E1AP\n", + "dAStpsWvXbsWWU9HUmnaSiuem0UreGuqr8j0tu7XH02ny5rO0/SdmVlbW5uLdQTj0aNHI+vp549L\n", + "ZYb62c9+VvM20vCrzut3mGfqsLu7O7dtp0VLFAAAQAAeogAAAALwEAUAABCAPlF1zB9S2+iy6AdV\n", + "VAVff2Z2Xc6zCnvW/OHdly5dGvE29LP7ZThCtodqGRgYcLH292lpaYmsp0P7x4y58afH/x36fYuG\n", + "+NdO2t/vzJkzXRzS59Dvi6W/icHBwdj36fB7nYnAL3Ggv4HJkye72J9FocqSzkOjoyUKAAAgAA9R\n", + "AAAAAUjnNZBam3+1Qu6ZM2dqPZxKunjxootXrVrl4o0bN2a6Hx3SPNxylc2bN8/F/f39NW9PPzvp\n", + "u8ajpQz093XgwIHIegsXLnSxprT8EgdadVqHx6edkWHatGmRZd2XVgfXYzWLpgc15R43yfitaOpw\n", + "0aJFLvbv0/oZtfp7Pd0z0vJLIWj6Uielrie0RAEAAATgIQoAACAA6bw6piNczG5uKh2pRk3hKR3R\n", + "qCk8HcFjln4Uj181Pg1NN4SmCtIKSdEy8TFGIm60aW9vb2RZf1N6Xfqj1TSlFVLt2h9RqsuaEvRH\n", + "0CpNKYaOgtZRi5ra9O/Tev40pdjc3By036rRkYn+iMp6TeEpWqIAAAAC8BAFAAAQgIcoAACAAPSJ\n", + "qmN+X4TRXDW2ViGVjM3C+kvk3Q9Kad+OtEZD3zhkR0scKL+chS7rdTllypTIerfffruLtd9n2kr/\n", + "fskE3YbGWlHczKyrq8vFWc8Gof3DDh48GHkt7n4we/bsVNueMWOGi0+ePBlwdNnTqvP6Xed9fNrf\n", + "rKi/h7REAQAABOAhCgAAIADpvAaS54S6GJ42pVfRaJukGsULue9oyi1tKt0v6aLpPS1doJOMm0VT\n", + "S/oef3vnz59PdRxp6b40jZX2N5n2eKqSwlNa+qXI4yujSwstUQAAAAF4iAIAAAhAOq+B6KiWeuVP\n", + "MuqPtEF986tJ6yTQx48fd/HOnTsLO6aq8Staa1rHnzR3NPGvHZ3UV0f++VXO9R6iqT2/Yrm+lvV5\n", + "DkmrVzFNl9ZommicligAAIAAPEQBAAAE4CEKAAAgAH2iGkgj5KHrrQ9UPfdbKMPkyZMjy3v37nVx\n", + "f39/0YdTSX7fxqr3g8q6NID2i9T7gV/ZXNfTqtj++dLh9lrWwK/mP2nSpNhtlMHvs4V8aL/My5cv\n", + "j/j9fEsAAAABeIgCAAAIQDqvjiUN0UV2dCi1P3z63Llzme7r4YcfdvG2bdti95s1TXNoyu3UqVOZ\n", + "7odJsm/t6NGjZR9CqeJS+v7E2Jp60XuhP4uATuSrKUD/WtQyBJoCLKvqf0hqqSz+ZM7ataTqE5pv\n", + "3LixpvfTEgUAABCAhygAAIAApPPq2PXr1yPLBw8eLOlIGtuBAwdc/Cd/8ieR1w4fPpzpvtauXZvp\n", + "9tLSyVInTJjg4qzTeUAofxSgLuukw5p+NzNrbW11sV7bmuYzM+vp6Rl2v3466tq1ay7OM9WXxUjl\n", + "mTNnuli7HmSdKvS7G7S3t7v4ve99r4tfeOGFTPdbBbREAQAABOAhCgAAIAAPUQAAAAHoE9VA/Iq+\n", + "Q7QCsubzq2jatGmR5dOnT2e6fR2Kq9XGW1paIutp9Ww9Z9/73vdit9cosq5AnZZ+90nfe3NzcxGH\n", + "gzpy4cIFF/vXjt4XtZ+Rfx0dP3582NgvJaP9B8uifZ1OnDgRu17Sa3k6dOjQsHEjoiUKAAAgAA9R\n", + "AAAAAUjnNZC2trZh/33+/Pku9ofkp03vaUXrPJuzs07f+eIqf/f29ma6vSSaHvDLVNRq6tSpkWWd\n", + "SDXtkOmyKgyn/e71ekYx6mkyXP8eFzeTgz8BsV73mtLO+jeahbLSdI1IZ2gImYGifn4ZAAAAFcJD\n", + "FAAAQADSeQ1k0qRJw/57yOiIvEfJqeXLl7u4q6srt/1URdbpAZ1wVUccZkEnbDXLpopyrbL+jLg1\n", + "TXnUm+7u7rIPoRJ0RJ9OEGxW3ojcKqh1EnlaogAAAALwEAUAABCAhygAAIAA9IkqkJYJMIuWCtCq\n", + "ulp91yy+DMH9998fWc5y6HfepQZUnv2g/HPS19fn4jxnYE+yYMECF8fNHO9L6puUZx+hKvSB8tEn\n", + "qnhVn+kAt0ZZhHzQEgUAABCAhygAAIAApaTzHnnkETMze+ihhyL/PnfuXBefOnXKxUlpqqTh4po+\n", + "0+ZoPx2gqavW1lYX79u3L7Kevm/ixIku9ssBaCXcpqYmF/uT1eoxzZ4928Xjx4+PrKdpJ03r+MOO\n", + "H330USva9OnTI8s6jFYrBS9cuDCynp7zTZs2uVjPq1m0/MHrr78eexz6HWia1K9erNu7fPmyi/Me\n", + "Bv3YY4+5WNN5/jW2ZcsWF+s5yjqt1tnZGVnW7/G1116Lfd/73vc+F//mN78Z8X7nzZsXWdZr5L77\n", + "7nPxW2+9FVlPv58iU814hz8kHuV6z3ve42L9e/GrX/2qjMOxj370o5HlxYsXu/gb3/hG7Pv+4A/+\n", + "wMV6L9S/CXnTv01pu1coWqIAAAAC8BAFAAAQoOntgocoNTU1lTYqCgAAYCSSnltoiQIAAAjAQxQA\n", + "AEAAHqIAAAAClFLiQIf9Ix+av9XSCn7l6yNHjrg4qVxEnKQSB4sWLXLxoUOHIuv5Q/uHaOV2f/s6\n", + "27ZfVkKX9bP7VXr9kgdxJk2a5OKpU6e6+MyZM5H1brvttmFfq/o17pfRmDBhgotvv/12F/v9ALT0\n", + "SMj14tMyHRcvXozddlx/BP33qp/zqtDzlNQ/NW49/z2c9/z551zv6cePHy/6cEaNNP23aYkCAAAI\n", + "wEMUAABAACYgHgU0daNpKjOz/v7+mrad1Mys+4pL3/m02vtwy0M09WMWrXytzduhk26eP39+2Nin\n", + "qb564legLqsitaZos6bpZP2e/IrnBw8erGk/msI2S3/NPfzwwy7Wavx+yjhkwuokmtLXqv36G/Jf\n", + "Q7X43xXKQ0sUAABAAB6iAAAAApSSzlu6dKmZ3Txiq9aUwqxZsyLLOuIo7aisRqQTHWfdDKyT/ZpF\n", + "UyU6ci1rfjpvcHDQxXmmiHx+6gXVceDAARfrde+PKK1V2vSdTjJuZrZ27dpU74tL4d1///2RZZ28\n", + "Oklcmo70Xf3Q0ch6D4rr/oD80BIFAAAQgIcoAACAAKWk88aMeWe3fvN2SMptxYoVLh5KEw63vdGc\n", + "ztPRZX76LW3hvTh+amRgYMDFaUfkhVi1alVk+Y477nDxm2++6eKdO3fmdgyoH1pANG1xwoULF0aW\n", + "J06c6OJdu3aN+BiS9qv3rj179qTaHqmb0UtHWOrIU38kcRYFcZGMligAAIAAPEQBAAAE4CEKAAAg\n", + "QCl9oob63viVfrU/jQ7LT7J9+3YX+0ON+/r6Qg+xLjU3Nw/773ous56s0v+erly54mK//1WWlixZ\n", + "ElletmyZi7VPVBItgeGXTEhrxowZw/67P9GznhcU78KFCyN+j07OnWSoj+eQzs5OF2/dujXVNtL2\n", + "gwp5j3+Nnjx5csT7QrXobBB6n/XLymhf4JA+r7g1WqIAAAAC8BAFAAAQoJR03tBQYa26amb2yU9+\n", + "0sU6NPN///d/I+vFpaTyTB/lbcqUKS72Uz9pK7mnTT9kyd+nlkzIWltbm4tbWloir+k1kbasQRbH\n", + "GreNBx98MLK8Y8cOF586darm/WaRikSytOfVL4WQZ6X+tDo6OlysEzGbpa+UrrS8A8qn15hOMO+X\n", + "NNAuMzqrQ5Jay96MNuX/2gEAAOoQD1EAAAABSknnDVXa9dNvOoFwa2uri/2JNn/xi18Mu12/2Vqb\n", + "PHXkX1n0M5lFP69W/vYn0D169KiLQyqv63n2JyDOetLRrJt/tTn6/e9/v4u1ArWZ2UsvvTTibYeM\n", + "2PLFpXw03ZYHUnj50JRxf39/5LW4EcN5VuZPoik7M7Pu7m4X6/1O/30kdIRpFr8VZEfvs9r9wx95\n", + "GVLVnhTeyNASBQAAEICHKAAAgAA8RAEAAAQopU/UwYMHzezm/jha3VeH/OsQziQbN27M4Oiypf0K\n", + "/GH5mr/Waut+f5e0Q1Pj6PDkuXPnRl7TvkUhM9On5Vd1TluOQvu5aR+3DRs2RNZLWxk6TtI1ptep\n", + "318grq+I308mi7IGyJ9W9+7t7a15e1rqYtOmTTVvTyX1dcqiD1N7e7uLh+7ZqAbtn6clCfyZEnQ5\n", + "6/6veActUQAAAAF4iAIAAAhQSjovTbOiDs0MGaZZFTr8dMuWLaUcg1Y891ODRVVXDq0mf+DAARdr\n", + "+sKvzBvHr7Qcl+ZIWxU+LdIf1bVq1arIsqbttm3bVvP2P/vZz7rYL5MQ5x//8R9d/Mwzz9R8DGlp\n", + "GttPad95550uDimtgvxo94/Tp0+7+MyZM5H1KIWSP1qiAAAAAvAQBQAAEKDp7YLLk+Y5QS1u0K91\n", + "NJxzHf1X1kTUo+2cV0HIOZ88eXJkWVO8adPEWfj85z/v4rvvvtvFX/ziF1O9P6lieZ78Pxlc6/nz\n", + "z/m8efNcXIXZOBrV0HlvamqKreROSxQAAEAAHqIAAAAC8BAFAAAQgD5RDapq/XO0Ar1ZdDj18ePH\n", + "R7w9rbTu02q+RaraOR8NqnDOJ02aFFk+f/78sOv5JQSyLqtRFPpEFc8/51pZn9kQ8kOfKAAAgJzw\n", + "EAUAABCglIrltZo+fbqLacqsrtWrV7tYh+SaRVMeL7zwwoi3XVbKDvD56TudBUBLJvgp7XpN56F8\n", + "RZbiQDJaogAAAALwEAUAABCgLtN5jZjCa29vd/HRo0cjr6WdRNIfJVQ2Hc3Q1tYWeU2bo5cuXeri\n", + "PXv21LxfHS1U8OBTVIiOhktKnTU3N7v4yJEjNe83LtUSMgoVGA73teqgJQoAACAAD1EAAAABeIgC\n", + "AAAIQMXyCvL7D2l17mPHjrnYH1o9ZsyNLm5XrlxxcRXOufZ7MjN74IEHXKyX4Ouvvx5Zb+/evfke\n", + "2Aj5VacvX77sYu0LU4VzPhokVSyfO3eui/1+hghHxfLi+edc+79euHCh6MMZNahYDgAAkBMeogAA\n", + "AAKUUuKgtbXVzMz6+vrK2H3l9fb2Br3v6tWrGR9Jdg4ePBhZvueee1ysTdMzZ86MrDdx4kQXV6HZ\n", + "mirT9SPrqs5xlciBonH9VQctUQAAAAF4iAIAAAhQSjpPR45hdPCrqetIwv7+fhf7o/GqkMJDfTp7\n", + "9mym22v0FMr8+fMjy4cPHy7pSHArdCuojsSWqM997nPW0tIS6b8yODhojz/+uC1fvtyeeOIJO3ny\n", + "pHvt61//ui1btsw6OzvthRdeyO+oAQAASpb4EPXZz37W1qxZE/m35557zh5//HHr6uqyRx991J57\n", + "7jkzM9u+fbv94Ac/sO3bt9uaNWvsC1/4QsP/zw0AAIxeiQ9RH/jAB24aLfXf//3f9pnPfMbMzD7z\n", + "mc/Yj3/8YzMze/755+3pp5+2sWPHWkdHhy1dutTWr1+f02EDAACUa8R9ogYGBqylpcXMzFpaWmxg\n", + "YMDM3smfr1692q23YMGC2KH6VR6Kj3xo2tfM7NChQy4eHBx08YkTJwo7JjQ27TeiVf9nzZoVWa8R\n", + "q5lPmzbNxadPn071HvpAASNX0+i8pqamxJL/TAcAAAAa1YhbolpaWqy/v9/mzZtnfX191tzcbGbv\n", + "zPemrQs9PT03zQE3hBFXAACgyp599tlbrnPLCYi7u7vtYx/7mL311ltmZvalL33JZs+ebV/+8pft\n", + "ueees5MnT9pzzz1n27dvt0996lO2fv166+3ttccee8z27NlzU2tUU1OTzZ4928zMjh8/HvjRcCtJ\n", + "E7NWgU5IrOUPduzYEVmvnsphVP2cN6K051xfK3jO9YbDBMTF45yXI80ExIktUU8//bStXbvWjh07\n", + "Zu3t7fY3f/M39td//df21FNP2Xe+8x3r6OiwH/7wh2ZmtmLFCnvqqadsxYoVNmbMGPvmN7/JFw0A\n", + "ABrWLVuiMt8hLVGFqHqrCC1RyAItUcWjVaR4nPNy1NwSlZeiHp50wlC96K5du1bI/hFvwoQJLp4y\n", + "ZYqLly1bFllv3759Lr548WL+B/Z/qjbxMW5t0aJFkeUDBw64mAenxjZ58mQXnzt3rsQjwWjD3HkA\n", + "AAABeIgCAAAIwEMUAABAgFI6liOZVlc2i+/D1dHREVmeM2eOizds2ODiKp7zqVOnuri1tdXF2snc\n", + "LFrp/OzZsy72K5vX2s+tvb09sqzHsWvXrlTboGN58TjntdHr/Pz586neQyfn4nHOy5GmYzktUQAA\n", + "AAF4iAIAAAhQSjpvqPTA9evXi9y146fLtBRCkXWJhuplmb0zYfMQHa5rZrZ7924XJ02WOm7cOBfr\n", + "5KtVb/rV8zB37tzIa+PHj3fxwYMHXZzFRMWa/vTTgSHbJ7VUPM558fw/Gfr71cnEUZuxY8e6+PLl\n", + "y5HXuNaLQToPAAAgJzxEAQAABCglnffQQw+ZmVlPT0/kNa00q6Oy/BSbVruePn26iwcGBjI91npW\n", + "T2mOMWNuFM6/evVqzdvTEUczZ86MvKbXjqbsskhD1NM5bxR6zrXKvFmxFe5HE/9PxpIlS1ysMwwg\n", + "O4zOKwfpPAAAgJzwEAUAABCAhygAAIAAY269SvaGhrG3tLRE/l1LD7zxxhsu9itGa18H+j3Uv7T5\n", + "/RkzZrhY+8yZRYcDJ1Vh7u3tDTlE1IGFCxdGlru6ulK9T0uKaL9MpNPX11f2IQCloSUKAAAgAA9R\n", + "AAAAAUpJ5+3fv9/MzLZs2VLG7lEBd999t4u1WrhfpkKrySdVGNcyGMeOHcvsOFE/QlNx9ZrC04m7\n", + "zcpLq124cKGU/QJVQEsUAABAAB6iAAAAApRSsRz5S1s9W0dE+imyPGml+VOnTqV6T3t7u4uPHz8e\n", + "ec0fhVcGKpYXbzSfc3+i8qLSklTPLh7nvBxULAcAAMgJD1EAAAABeIgCAAAIUEqJA5Rn3rx5keXZ\n", + "s2e7WPsZ9ff353ocaftBqcHBQRdXoQ+UmdnEiRPLPgRUzKxZs1y8bNkyF7/22ms1b3vChAkurtfS\n", + "DEAjoSUKAAAgAA9RAAAAAUpJ540fP97MzC5duhT0fm3STjsBsU5Qq1WwfdOmTXOxP+Rf3zdmzI1T\n", + "5w991FRV1hMk6yS8mjYwM7t+/fqw79HKxlop3OzGZNBm0c9x4sSJyHpaSfzQoUMu9ksN5EnLMeRN\n", + "r7EpU6bErtfc3FzE4aCOaNo561kZipxwfebMmS727wcA3kFLFAAAQAAeogAAAAKUUrG84F0CAAAE\n", + "oWI5AABAxniIAgAACMBDFAAAQIBSShyMdAbqSZMmRZZrrVbtz37e2dnpYh3O3tvbG1mvr6/PxSHV\n", + "gh966KHIsg7Z17IB/rD5TZs2ufjKlSsu1mrjZmZz5sxx8c6dO13MjN/F0Jw557wYWZxz/R1duHDB\n", + "xVlXxQ+9j40bN27Y+OzZsyN+v5nZ5cuXXbxw4UIX+9X3d+3aNez2/L4hXOv588+5lp84efJkqm1M\n", + "nz7dxSEzRphFryW9jhqFlrYxi94P4tASBQAAEICHKAAAgAB1MQFx1s3qfipO02VpLV++3MVdXV2p\n", + "3vPyyy+nWs+vPK7V1jWd51cLr8qkvMg+BY1b02r+ZunTHDpJsP721q9fn82B/Z/Qa0BTKDrjgF9F\n", + "XO9Dev0l7VdnjfBnQNDUhs7QgPLp95v2Og9N4Sn9jR05cqTm7VVNyIwAtEQBAAAE4CEKAAAgAG20\n", + "gdKm8EJ0d3cHvS/NSIKhyZ+H6Mikw4cPj3ifS5YsiSzrCEZNI/gjf9Ica950Qum4yZtD3XHHHZFl\n", + "TSo+yQwAACAASURBVIfs37/fxVk0seMdK1eujCzrKNwDBw64WEeumpmtW7fOxS0tLTkd3c1Wr17t\n", + "4j179rj42LFjkfX0t6MpfH/0sEqbOtSJxTU2M1u1apWLSedViz+KrCgf/vCHXfy9732vsP0uXbrU\n", + "xfpbyZr+TUj9nhyOAwAAoOHxEAUAABCAhygAAIAAJLo98+bNc7HfP+KNN96oadsdHR2R5dC+TyOl\n", + "+XO/GvrBgwdHvD3NT6cts5C2D9SiRYsiy7r9tBWa08qiH5Q/rH6I3/dMvwO9xrRqvVm0hIV+3rgZ\n", + "xHHDjh07Ist33XWXiz/5yU+6+Cc/+UlkPf1d+/2C8qT9jJKuxWvXrrk4i/4gbW1tLk7qV9XT0zPs\n", + "MaB8ZX0fZfWN09IeefaJCvmbQEsUAABAAB6iAAAAAjRUOm/q1KmRZU2NpK1E2t/fP2xsFp3AMW7Y\n", + "sb9fVVT6znffffe5OG5S0VvRUghaqfb06dPhBzYMHYo+EjqRqn5vfvOzVn9OW+lX6TWQtA1/v9Om\n", + "TXOxpvD8dJ5W09cJPrWyNIbn/w51hoD29nYXVyU1mnYGA72v6fWWlHpYsWKFi/0JiDXNuWHDBhf7\n", + "aRL//ofqiPsbk7ek9G+WOjs7I8t+df68hJSOoCUKAAAgAA9RAAAAARoqnXfmzJlct6/Vpeup0rSm\n", + "OfxJRvVzaLVWTd+ZVW+ySb869datW4ddT1NiZtHRg/p5k0bJKZ0M2sysqalp2PUOHToUWdY0nY5U\n", + "9NOBekxlNdk3oldffdXFWsncLPodpk316fWS90gpvXbSjh7S9MfVq1djXwtNn6NcOgFx2msx5Dr3\n", + "7du3L+h9I3XPPfdEll9//fVC9ssExAAAAAXhIQoAACAAD1EAAAABGqpPlN/fZ3BwMNX7FixY4GKt\n", + "0lt1frVsHeavDh8+7GK/ovjy5cuHfU/aWeDT8r8bXU5bgVbLSsT1gRoJ7V/i94mK62dw7NixVNvW\n", + "cz7cMoqVVF7kwQcfdPHmzZtdnNT/SPuk5N0XM+01p/r6+nI4ElSF9mlK2ycvi9IeeVYLV1OmTIks\n", + "p53xogy0RAEAAATgIQoAACBApdJ5Wpk3ZFhvaDqv1hSeppnMimt69IfHx1XPTkrNdXV1ZXpMcfzv\n", + "Iu13o9KeV01R+uckrlQD5QRGr71797o47b0m7xReGbS8hllyuhvlam1tdbGWsAmZhaEe6PNA1dAS\n", + "BQAAEICHKAAAgACVSudpE7lWzPbTOHHpqaJGDviySN/phLV+hWGMjDZvV7kZGNVQ9RSITooaUlE5\n", + "raRUZt5V2TEyM2fOdHHVU63z5s1zcdpJrf37dpVnCKElCgAAIAAPUQAAAAF4iAIAAAhQqT5RSvu1\n", + "zJkzJ/Ja1tW0lfbF0mPIG/2gslPk96bV7oE8pL03tLW1uViHwG/cuDHzY0K59G9i1furhfTjq/pn\n", + "UrREAQAABOAhCgAAIEBl03kqZALOUEWmgoqildz9Ssu1VurWKvPDbb9eafVmbTr3K57HDS8OrZ6P\n", + "fHR0dLj40KFDkdeqnjrQdJ6m7Hp7eyPr6W+5yhO2onbNzc0urnqJjpDj86/tKqMlCgAAIAAPUQAA\n", + "AAHqIp2H2qRNJWllWT/NpyMiNYVXZPpu7ty5Lj569GjsetrUHTfh8K1oReCkbRw4cGDYf+/s7Iws\n", + "6yTXBw8eDDqmRuBPcjtu3DgXjx071sVawd/M7MSJEzXtV1N4VU/fJfHT50qv09DrHqgCvV9WHS1R\n", + "AAAAAXiIAgAACMBDFAAAQIC67BPV1NTk4rffftvFkydPjqyny/QRuLW0M2xnMXxaK8Mrv8SEfodJ\n", + "/aBUFt91raUutGK0WfSaTRryq32EdObyWktRVMX169cjy1rNWPtE+SUi9JprlArI+nm1VEbS5+vq\n", + "6sr1mFAf0l7PSSUxqsyfpaTKfaRoiQIAAAjAQxQAAECASqXzVq1a5eKkSTM1hafOnTsXWb506VKq\n", + "/WpTug5tz7tSug5X1nRNSLoirenTp0eWNWWUp/Hjx0eWtblWU3Z+mi/P9IV+1/7xpU1txpk2bVpk\n", + "WatO62v+ZNq6nqYARwNN9fm/Af1+8vx95Mn/Pn/v937Pxd3d3S7esGFDZD09L346FKPT2bNnU613\n", + "+vTpnI8EtEQBAAAE4CEKAAAgQKXSeUkpvBA60knTJD4d6VDkZMdFVfueP3++iw8fPlzIPs2iaTo/\n", + "1bpr166atj1hwoTIsqbI0o7Oq7UKdhK/MreOxJo0aVLsepqC1tTN5cuXsz7ESvM/byOMTly2bFlk\n", + "edu2bS7eunXriLen15RZY5wjpON3F4hTrxPC19P9jpYoAACAADxEAQAABOAhCgAAIECl+kSllbaP\n", + "jz98fLQqsh+U8vtB1WrixIku1v5uZtWrSO/3ddJh+Zrv1zILZvGlLvzt6XpZn+eyaFVyv89bI/T3\n", + "8X+HaYepx9G+dWbFlStB+apefVzvVyFlOdL2+aoCWqIAAAAC8BAFAAAQoC7TeWWlp6rOn4C5CFrt\n", + "3az2iV797S1ZssTFOqnvr3/965r2cytaUT2p7IU/zHyI34StzduahtEUpVm0orxWuJ47d25kPS2F\n", + "sGXLltjjqydJlbmrOIHwSNWavvP51f3j0nlZ/0ZRPj+9XzW1Vtb3J3Cvsmp/EwAAABXFQxQAAECA\n", + "ukznpaXN2NqEPWZM9GMnVTOvJ2WM0mpubo4s9/X1pXqfpiKOHz/uYj/VoCO2Dhw44OKsJ2L1R/ul\n", + "rVwfN2rMHzmlo02mTJniYj+dp59XR5f616yO3NOUYhVHsekIRP+3puddz5mfmtbvezSPQtPz5f/2\n", + "9u3bN+x7ykrfJV3bqE1HR0fZh5CrgYGBsg8hNVqiAAAAAvAQBQAAEICHKAAAgAAN3Scqri9A1n2g\n", + "/OGmWffXKYr2IfMrRmt/K+2fk7YPlE/7QSU5dOhQ0PZHKutZw/3zp+dW+7UkVeZOGvL/9ttvu3j8\n", + "+PHDvr8q9Pehx20W/Y3qa/6w/Hrtt6i/lSw+g16nJ06cqHl7eaIPVH788haNZseOHWUfQmq0RAEA\n", + "AATgIQoAACBAXabzpk6d6uIzZ86UeCTvqNf0nU9TK0nlEkLSErNmzYosDw4ODrueXwG8rPTUvHnz\n", + "XKznxW9Gj/vu29vbI8uahtHP6KcRT5486WI9R37JBP0Oql69WMsx+JOCa1V2LWtw+vTpyHr1Osly\n", + "1uUF9Pqr+iS0yE9/f3/ZhxDELyUT142i6qlqVe27LwAAQEXxEAUAABCgLtN5VUjhVYFWgjbLfoRZ\n", + "luLSd74i03dJaeG45vKjR49Glv2qzEO0QnnSev5+u7u7XawT1vppRE19xU2CXEV+6lFH4Wlqr1FS\n", + "5DricPXq1ZHXdFTl2rVrU21PJ6LeuXNnjUdXX5hI+YaXX3657EMIUuR3ppO55znLAS1RAAAAAXiI\n", + "AgAACMBDFAAAQIC67BMVQvtilNXfYsqUKZHlJUuWuLi1tdXFflXnV1991cU69Fv7R5jdPKt7I8iz\n", + "nEUW/a/iqjL7fcDihvn7Q/kvXbrkYh0O7Pd7SiobUDVJ5Qm0j0RPT08Rh1OadevWRZb9avVpVLEK\n", + "uPb/0+866ZoN4d8/8+znUnXbtm0r+xCCFNknSvuh0icKAACgYniIAgAACND0tp87ynuHMow5iTbd\n", + "6lBvs+hwb20e1GrPo51+rWnPeT3xUyG1pgqyoOf8i1/8YuS1ffv2ufi1115zsd+8fezYMRdrOs+v\n", + "+K5pHU1zNkppgLQa/TrPg5YK0FScn1qOS734fzK0mn4W6UadLUCPyd92wX+6SuV/Vq71W9N0cmjX\n", + "jaHz3tTUFHu90RIFAAAQgIcoAACAAJUdneen8NTx48cLPJL6oc3gRfErUGvaSVNTSTo7O12cVIW5\n", + "paXFxf7IxK1bt6baV1H8z7Fnzx4XDwwMpNqGVqD3R5foa6MthYfaaJoui4lesx4xWK+T6/rGjBkz\n", + "bOyPWtQ00YwZM1xcxv28KubMmRNZTvu3RBU1+wUtUQAAAAF4iAIAAAjAQxQAAECAypY4qCc6G7tZ\n", + "tOp0kXTWai330IjnvIr0p7Rs2bLIa9onCtmpYokDvR/oMYWW4Zg8ebKLk6q/F4Xh9uloPyi9Jvy/\n", + "F3r+9LvWvo6HDh2KfU9ZtF/q0aNHM932qlWrIssbN27MdPtpUeIAAAAgJzxEAQAABKhsiYN6Ulb6\n", + "zteIE3JqZfIqVCVPS6s4m0Wr7GuJDk3BmkUnXNYyBn5Tsg6T1mb/pOHhOmzYn8w55BrWY9Wh2f7x\n", + "6VBjTVf479MK7T6d0DltOQstt+FPCJ0nPZerV692sT8BcZwHHnggsrxjx45sDqwOaXV1v5RH1SqW\n", + "+yUJ9Hi1ZI+fktW0n6bpkn4PWVTjrlWe57+szxSCligAAIAAPEQBAAAEIJ2HSvEroIek8DQFEDeJ\n", + "6q3UOiJq4cKFkWVN72nl9fnz50fWmzhxoouTUmx6njQF4E8iq/S8+KlfrVyt+/Wb7HXC2sWLF7v4\n", + "6tWrkfW0OV7366c5NZ3pTyqtNDWXNJuBKjKFFyfp+1D6fba1tUVee/311zM9pqL4o9A0vZWUttLJ\n", + "5/Xa8VM8R44cyeQ4s6Lpd7P015/+3vR+5/9WlN6fdCR23vT7uOOOO1ycVFFc7xn+OYq7v/tV3bOm\n", + "15x/TCNFSxQAAEAAHqIAAAAC8BAFAAAQoJSK5VUbmgoAADAcKpYDAABkjIcoAACAAKWUOChj8kSt\n", + "jHz//fdHXnvppZdcrMPPBwYGgvalwyd1X+vXr091fP6QVa00nTSUtLOz08Va5XjmzJkuXrp0aeQ9\n", + "2kS5e/duF6cdmu3TIftawbe7uzuyXtrhv4888oiLt23b5mJ/eLOe846Ojtj10g4H1uHF58+fj11P\n", + "vzctE1DWBKE6KahZdLj8li1bYt+npRUuXLgw4v22t7dHlv0JU9O48847Xbxr167Y9R5++GEX62+3\n", + "CpOyjgZ+WkPvL3od+eVF9BrRcgV+JfK0FenT0nuSlsrYv39/ZL2QUiZ6b/ar9uusAKF/S4YkTfoc\n", + "N4GxWbQkgfLLRWhJAS0hkrZEjM5eYBb9O6rH5N+P9e9MyPn3S+L411Kt0nQ9oiUKAAAgAA9RAAAA\n", + "AUZNxfIVK1a4eM+ePbHr1drsamb25JNPulgnl0xK5yWlmdJOLPzQQw8N+++a6vKbP7V5NTSFpw4f\n", + "PjxsHOqXv/xlqvW06mxXV1fN+01K4akiqwWnoc3oZmaLFi1ycVI6LySFp9XGe3t7R/x+X1IKTyVN\n", + "soziNTc3u1jTPzrRtln03lrk72bBggUu1qr4aa+3JEmfo6iJ6TXllLaaf9b8Cc395bxknb4LQUsU\n", + "AABAAB6iAAAAAtRlOi9kclhtWg1JXZjFj2DS0WBm0dESP/rRj4L2pfyRFHG+/e1vu/hb3/qWi7UJ\n", + "2x/dV7VJPDE8fzLSuHSjn0JZtmxZbseUNs2ctSzSMLg1TddqtwSfjgDV67Snpyeyno7IzTPtpOlF\n", + "s2h3Bh2tlkUqSCfe1ol2zaIpraLSWygeLVEAAAABeIgCAAAIwEMUAABAgLrsExVS2VT7Ufn9RuJo\n", + "Lt0s2g9Kq9N+6Utfiqz3hS98IdX2tSTByy+/nOo9IbSPlt8nKu1QfoyMVgA2S9+vTWk/lLSVg/2+\n", + "K1q5HtWlfXXSftd5076U/r1QabXq8ePHu1j7VJkVV9bALy2gsyWEVONOy69YrudMS7D4ZWZ0pgPU\n", + "H1qiAAAAAvAQBQAAEKBS6bysm7R1qKsOw01Lm2B9H/vYx1ysk6CORNYpPL+ZeIgOw61KqqAK8kyh\n", + "hKTvfPq9aezTFJ5OsGpm9sYbb9R8HGrlypUuDpkoNnTCUB0+rhNb50kn1jUzmz17touTZj0IUcXf\n", + "pVYY18r3Ph2+r9+n3+0ipBtGCL/0RlGlOPxuIvqd6mwQaSa1Rf2gJQoAACAAD1EAAAABmt4uuG1R\n", + "R4rlTavnJo1C00lbs5iAuAr0a9VRNv7oraKa2EcDPedFXuc6OspPQdc6CerDDz8cWV67dm1N20tL\n", + "U61m0fOpqT1NoeR9zvW3k5RebRQ6Q4Om8/wRn4sXL3axfjf+tRdX9fzQoUOR5SwmQi+DpnvNotej\n", + "jsALSd36f6bjrnU/Ba2pzCpM1ltvhs57U1NTbBqWligAAIAAPEQBAAAE4CEKAAAgQKVKHGQtbsi/\n", + "r1H6QcXRvgl+VV2tKqzVzJPKO+CGIvs+xcl6hviOjg4X9/T0pHqPfx5q7Wqp/RnNop9xcHCwpm2H\n", + "Gg39oJT2tdO+Tj6tCK4Vy/336KwR2n/IL8tRr32ipkyZElnu7+93cVElLPzfHf2g8kdLFAAAQAAe\n", + "ogAAAALURTpP0wtm0eZj5Tcfv/e973WxDvVct25dqv0uWbIksrx3795U78uzZMLSpUtdHFI12T8e\n", + "HRJ7xx13uHjnzp0BR9eYQiqb+8O5V61a5eK0119Z5s+f7+Lf/OY3qd4zd+7cyPKRI0dqOoasU5RZ\n", + "0HSNTmRbbzT1mpR21e8wadJ2/X1o+igp1a2prno+l3PmzHFxa2tr5DX9XDqDQZ4ptqImeW5U+n2m\n", + "RUsUAABAAB6iAAAAApSSzhtKdaQd7ZK2ad8f1fHzn//cxX4F5DiPP/64i19//fVU7/FlncLTUYZZ\n", + "T3yqlXQ1xg1JKby4dIifgk4a3VQ1aVN4mrLUFKBZ7em8KqrntJMKGTkZV23cLPr7iJt01yx6v9cR\n", + "ljqjQr3Rvyv+aHBN/+po5yqmqvEOHaGeFi1RAAAAAXiIAgAACMBDFAAAQIDEPlGf+9zn7Kc//ak1\n", + "NzfbW2+9ZWZmzz77rH372992Q5r/7u/+zp588kkzM/v6179u//qv/2q33367/fM//7M98cQTw253\n", + "3LhxZpa+T5Q/vFZzz2mHi6Ydmr5169bY/ap7773XxW+++WaqbYdK+xm1WjDKpeUizPK/Rsqgn7Gv\n", + "r6/EI0He2tvbY1/T6vJ6T584cWJkPb1vh5QNqSI99osXL0Ze88t+DKFPVGNJbIn67Gc/a2vWrIn8\n", + "W1NTkz3zzDO2efNm27x5s3uA2r59u/3gBz+w7du325o1a+wLX/gCJecBAEDDSnyI+sAHPhApxjhk\n", + "uNEdzz//vD399NM2duxY6+josKVLl9r69euzO1IAAIAKCSpx8I1vfMP+7d/+zVatWmX/8A//YDNm\n", + "zLDDhw/b6tWr3ToLFiyw3t7eYd9//vz5sKP9P1m3cD300EMufvnll2PXW7BggYuT0jM6ZNdv4s2T\n", + "TjSMcvnXuFZobhQLFy508YsvvljikSBv+/bti31Ny3cklS4YO3asi7VkQj2XVtHSBX5JB51k2U9t\n", + "onGMuGP5n//5n9v+/ftty5Yt1traan/5l38Zu24VZrgHAADIw4hbopqbm138+c9/3j72sY+ZmVlb\n", + "W5sdOnTIvdbT02NtbW0ZHCIAAECxnn322VuuM+KHqL6+PjfR4n/913/ZPffcY2ZmH//4x+1Tn/qU\n", + "PfPMM9bb22u7d++2d7/73SPdfCH8ptW4FN7UqVMjyz09PcOuN2PGjMgyk0Bi9+7dZR9CLrQS++TJ\n", + "k13sjwwltdxYkrpQaDpP01vTp0+PXU/T3foesxujt82iVeJDKq3nQUcWaorSH22ukw4zcro++Nmz\n", + "oYeor33ta7HvSXyIevrpp23t2rV27Ngxa29vt6997Wv20ksv2ZYtW6ypqckWL15s/+///T8zM1ux\n", + "YoU99dRTtmLFChszZox985vfJJ0HAAAaVuJD1Pe///2b/u1zn/tc7Ppf+cpX7Ctf+UrtRwUAAFBx\n", + "VCwHAAAIEFTioEpCyglcuHAh1Xrve9/7Iss///nPh12PPlDVon11zp07V8oxDAwMlLLfvM2bN8/F\n", + "+/fvd7HOWG9Gn6jRRPuYat8f7TtkFu0/tGzZMhf7fUq1L9HBgwddXJWq+Pq5tFp7UuV1/Ux+X1sq\n", + "mFdHSL87WqIAAAAC8BAFAAAQoO7TeTqpZRbuv/9+F7/00kuZbhvFKCuFV0/8atJpU+E7duxw8alT\n", + "p2K3h9FD01M6S4VfpV/TVlruwE/naSq4iqUBNG2npR/8Ug36Wtzky6h/tEQBAAAE4CEKAAAgQN2n\n", + "82qdzNi3ZcuWTLcHVIWmFNKOnktbjV8nlMXooteIFlg+fvx4ZD1d1lTXihUrIuvpteRff1WgqWut\n", + "yu5XLNdj11SmP2MGo7vrGy1RAAAAAXiIAgAACMBDFAAAQIBSOjIM9c1ImhkcQLYWLlzo4u7u7lTv\n", + "0T4fZvH9Nzo6OiLLW7duHdGx+dra2iLLOnQe1aKVyLW/z7hx4yLraT+8np4eF8+ZMyeynvYl0m34\n", + "5Q6qUBVf+zr5pQu0+rXOojBr1qzIeidOnHBx2lIjqA5aogAAAALwEAUAABCglHTe0KSNZ8+eLWP3\n", + "wKh0+vTpVOstWrTIxUklRDRFoROxZoH0Xf3QCd21erk/m0RcCtlPEc+dO9fFmk5ub2+PrLdnz54R\n", + "H2sWtJTB4OBg7Hr6+bXKuf93jxRefaMlCgAAIAAPUQAAAAFKSedVLY2nFXL9qrNAo0ibztNRT0eP\n", + "Ho1dT0fQ+WkNHaWl6R40nilTprhYv3e/ir2OwtNrzL/n6og3VZW/G3rsSSME9+3bV8ThoGS0RAEA\n", + "AATgIQoAACAAD1EAAAABRuXU6zrTuBn9oDA6JM0QoEPJ+/v7R7y9soabo3xaokCrdPuVuU+dOuVi\n", + "vXaSymholXK/ZAJQBVyVAAAAAXiIAgAACDBq0nk6keXly5dLPBKMBjqJqln8xL1FSkrnnTt3LtU2\n", + "dLLZrIecUxahuvwuEEqvA/3e/OH/cRXLJ0yYEFnW34qWT9BUIVAVtEQBAAAE4CEKAAAgwKhJ5xWZ\n", + "wtNJOOOq72ZBUytmZr/zO7+T274wMpqaMqtGOi9J2hGqV65ccXHSKL477rjDxZoqHBgYiH1P2hTe\n", + "ypUrU62Hd+jIS7PoKLkkt99+u4vf9a53xa6n6TytXJ82/eZPwHvw4EEXz58/f8TbA4pESxQAAEAA\n", + "HqIAAAAC8BAFAAAQoO77ROnM4MeOHSvxSG6odXj2woULI8s6NP306dOx79u+fXtN+x0NFixY4OKe\n", + "np7c9pO230nV+X274q7ttra2yPIf//Efu/ib3/xmpse0devWTLfXiPR7W7RoUeS1nTt3ulj7ivpl\n", + "OfQ+5G9DaX863Z5/7WgfTu1b59OyBtqfLm0lfaBItEQBAAAE4CEKAAAgQF2k8x566KHI8oEDB1ys\n", + "zcy/+c1vIuslVWjOU60TGusQ35GIS+dpM33Vh9pnbebMmZHlJUuWuPjEiRMuTluxO62kSVXrSdrU\n", + "tH+ed+zY4eKy0uxp00e18lNden8qi/7m/S4AmmbTSuT+/VJTc0ndCA4fPpxqvbSOHDlS8zaAotAS\n", + "BQAAEICHKAAAgABNbxdcBlabj5cvXx55TZtxdWRIc3NzZL2XX37ZxdoEXdbEwu973/siy35asQz6\n", + "tWrl4fHjx0fWY6LX7Og5T5qwtSx6TEk/e/29pU2t+CNKQ1PSI5V0zmfNmuViTdf66fZr166NeL9p\n", + "z2Wj6OzsdLGmas2qea03Gv8aG83nfNKkSS72/57pb1t/136q+rbbbrQfadcLfzLsob+PTU1Nsb9z\n", + "WqIAAAAC8BAFAAAQgIcoAACAAKWUOHj66afNzGz//v2Rf+/q6nJx1Yfi6yz1/vDuqtF8sN8HasyY\n", + "G5dAraUZcENHR0dkubu7u5Tj0KHu9957r4t/9atfxb7n7NmzLvb7HFy6dGnY95w5cyb0EHMzODiY\n", + "27az7gel/TyqWB6jCmUbALPo7yPr34o/80IatEQBAAAE4CEKAAAgQCnpvIsXL5qZ2bp168rY/U1C\n", + "Ulo6ZPqnP/1p5sdUFP28kydPdnHWFbxHm/vvvz+yXFY6T1O5Wlk6iZYG8CtQx6XztPp7VeRZsTzr\n", + "NHgVU3iKUig3aMV3HRJfxd8ARmbv3r0jfg8tUQAAAAF4iAIAAAhQSjqvr6+vjN067e3tkWVt9t+3\n", + "b1/s+x5++GEXr127NtW+dBRf0rbV1KlTI8tFjXwihZedtJPurl69OrIcl+LWUXZm6Uev6ui6PXv2\n", + "xK7X0tLi4oGBARfnOXGvWb4pZJ1seufOnbHrjRs3zsWa/tT7glk0zdna2uriKVOmRNbTKu9aGVln\n", + "DjCLfnZND/rr/frXv3axpg79idkfeOABF+vsDf4oxbiJynt7eyPLmp6aP3/+sO8xi15jceneRpL0\n", + "XWH0oSUKAAAgAA9RAAAAAUp7iDp16lRZuwaAuuJPoAqgGpreLngK8qHZkJ999ll79tlni9w1cEtc\n", + "l6girktU0Wi5LoeeW4ZDOg/A/2/v/l3S+eM4gD8P9A9oyENUuEDDBAtB2qKgNFokF0kapGwpmmpp\n", + "rJZs7gdENDiVLWWLh9NFtLick0EOBmYmtEUNkvAZgoP66vfz4fh87qB7Pia9O7jX8OR4Hm/ujoiI\n", + "dGCJIiIiItLB8OW8iYmJP349ABEREZGZxsfHoShK132GlygiIiKin4DLeUREREQ6sEQRERER6cAS\n", + "RURERKSDKSVKlmX4/X74fD7s7u6aMQIRAECSJAwPDyMUCmF0dBTA57fGIpEIBgcHEY1G//g7dUR6\n", + "LS4uQhRFBINBbdv/5XBnZwc+nw9+vx/FYtGMkckCuuVyc3MTbrcboVAIoVAIhUJB22fFXBpeojqd\n", + "DlZXVyHLMiqVCk5PT3F3d2f0GEQAPl+ipigKVFVFqVQCAGQyGUQiEdzf32NychKZTMbkKemnW1hY\n", + "gCzLX7b1ymGlUkEul0OlUoEsy1hZWeEbzemf6JZLQRCwtrYGVVWhqipmZmYAWDeXhpeoUqkEr9cL\n", + "SZJgt9sxNzeHfD5v9BhEmu8PqF5dXSGVSgEAUqkULi8vzRiLLGRsbAx9fX1ftvXKYT6fRzKZhN1u\n", + "hyRJ8Hq92g0A0d/ULZfAf6+ZgHVzaXiJajQa8Hg82n+3241Go2H0GEQAPu+qpqamEA6HcXx8MuSB\n", + "aQAAAd9JREFUDABotVoQRREAIIoiWq2WmSOSRfXK4dPTE9xut3Ycr6FktL29PYyMjCCdTmvLzFbN\n", + "peElShAEo09J1NPt7S1UVUWhUMDBwQFubm6+7BcEgZkl0/0uh8woGWV5eRm1Wg3lchlOpxPr6+s9\n", + "j7VCLg0vUS6XC/V6Xftfr9e/tFciIzmdTgBAf38/4vE4SqUSRFHE8/MzAKDZbMLhcJg5IllUrxx+\n", + "v4Y+Pj7C5XKZMiNZj8Ph0Er90tKStmRn1VwaXqLC4TCq1SoeHh7QbreRy+UQi8WMHoMI7+/veH19\n", + "BQC8vb2hWCwiGAwiFoshm80CALLZLGZnZ80ckyyqVw5jsRjOzs7QbrdRq9VQrVa1J0uJ/rVms6n9\n", + "vri40J7cs2oubYaf0GbD/v4+pqen0el0kE6nMTQ0ZPQYRGi1WojH4wCAj48PzM/PIxqNIhwOI5FI\n", + "4OTkBJIk4fz83ORJ6adLJpO4vr7Gy8sLPB4Ptre3sbGx0TWHgUAAiUQCgUAANpsNh4eHllg2IeN9\n", + "z+XW1hYURUG5XIYgCBgYGMDR0REA6+aS384jIiIi0oFvLCciIiLSgSWKiIiISAeWKCIiIiIdWKKI\n", + "iIiIdGCJIiIiItKBJYqIiIhIB5YoIiIiIh1+Ad4CxRoGhD90AAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nxEaKiIiISKf/AMt+wa3UEUvkAAAAAElFTkSuQmCC\n", - "text": [ - "" - ] - } - ], - "prompt_number": 14 - }, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['conv2'].data[0, :36]\n", + "vis_square(feat, padval=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The third layer output, `conv3` (rectified, all 384 channels)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXmwZVV1/78t4IBoolFRmbqlabqBBoFuhqAFBBpsgxTG\n", + "ImpiRDEOIWUoLcuRxEfwJ21MaZwSE4eExCqc4gAkEhAbFLBpgZ4YuwUkCEqMZnCIcQi/P6jPO+9+\n", + "31u99zn33Htfw/r8c/vdPvcMezp7ffdaay944IEHHlCSJEmSJEnSmkdM+gaSJEmSJEl2VHIilSRJ\n", + "kiRJ0pGcSCVJkiRJknQkJ1JJkiRJkiQdyYlUkiRJkiRJR3IilSRJkiRJ0pGRTKQuvfRSLV26VPvt\n", + "t5/e9a53jeISSZIkSZIkE2dB33mkfvnLX2r//ffXl7/8Ze2xxx5auXKlLrzwQi1btqzPyyRJkiRJ\n", + "kkyc3hWp9evXa/HixVq4cKF22WUXvehFL9IXv/jFvi+TJEmSJEkycXqfSN17773aa6+9pv/ec889\n", + "de+99/Z9mSRJkiRJkomzc98nXLBgQfGYRz7ykfr5z3/e96WTJEmSJEl6Z5999tG3vvWtOf+v94nU\n", + "HnvsoXvuuWf673vuuUd77rnnwDE///nP9djHPla//OUvJUmPecxj9KhHPUqLFy+WJP3oRz+SJD32\n", + "sY+VJJ1xxhmSpEc/+tGSpOuuu06SdN999w18/sqv/IokaaeddpIkHXnkkZKkqamp7d7zr/7qrw78\n", + "/u6775Yk7bzzg8Xz9Kc/XZL0r//6r3P+nuPOOeec7V6P5/nxj3888P0ee+whSfqv//ovSc3zR3Cf\n", + "r3vd6yRJ73//+yVJxxxzjCTpe9/7nqQHJ6yS9LOf/UySdOedd0qS/u3f/k3Sg+XO/++888763//9\n", + "X0nSM57xjIHn2nXXXSVJp512miTp3HPPlSS5e51fr8STnvQkSdK///u/z/n/lCOfxx9/vCRNK5zc\n", + "3yMe8aCwetttt0lqJvOPetSjJM0uzyOOOEKS9IQnPEFS87y77777wPUiqC/u//vf/74kabfddpPU\n", + "tNP/+Z//kSTdfvvtVc8HO++8sx75yEfqJz/5yXbvI+Lggw+W1JQL9/eKV7xizuv1Dc//5je/ec7r\n", + "Ue5+f8B48d///d8DnxG77LKLJOltb3ubzjvvPEmaHlvawj393//938D3tLVf/OIXkppnWrt2rSTp\n", + "qquuktSMPcuXLx/4/caNGzvdD0RtZVTM1+vttttuevzjHz895reFvvvKV75SkvQP//APkqT7779f\n", + "UnnsjfD2AYxBb3nLWyRJH/rQhyQ1Y33tWNmWSdXfZz7zGUnNGHTIIYdIkk4++WRJ0qc+9SlJ0gc/\n", + "+EFJ0lOf+lRJTbkxUXnKU54iSXrBC14g6cFJjCQ9+clPlqTpOcY73vGOgd8DY8i3v/3tTs/zpCc9\n", + "ST/72c+mx55jjz12uo/PRe9LeytWrNC2bdv0rW99Sz/72c/0qU99Sqeeeuqs43bbbTftuuuu2nXX\n", + "XacbW5IkSZIkyaRBGJAaIz6id0Vq55131gc/+EGdfPLJ+uUvf6lXvOIVc0bs3X///dPKAQoL3HHH\n", + "HZKkH/7wh9PHStK+++4rqVGMmM1ikaIYuSJV4nGPe5wk6YADDpAkLVmyRFKjcERKlP++xBOf+ERJ\n", + "sxWpH/zgB5KkX/u1X5NUtopQPvz3t956qyTppz/9qaTZihrXR5HiOKxwP39knXOe//zP/5TUKBB8\n", + "usIQ4RNo/kYhdK6++mpJql4Wjo5zdYDyXrVq1cD3rrDRXr/zne8MHIeSxydWL+XI71DwKKeIX/zi\n", + "F7MsrDaggFH/XQ0V+iXWcy1uZaPEotCh/HF/3l4oH87jitTSpUslNf3oP/7jP2b91vtYLd7WgT4+\n", + "81pSU0YHHXSQpNl9t63igMqJClzblyYNfrF77723pEZRuOaaayQ1Y44z82VVw6Me9Sg97nGPm65n\n", + "xrAI2hrvEB9bqE/qjbZFW2XsLwW308d9LJ3pLyw15YLCgrrOfZSeB1B1vT1OGur5u9/9rqSmvFGG\n", + "+J7y/uY3v7nd8zCGczz9ArxeePcPq0j7dUr0PpGSpNWrV2v16tWjOHUyArzzJ0mSzEfavuCSZByM\n", + "ZCJVC7NJfHXoJG6lMGvlE+Xm0EMPldT4/mD9YdXVgsV71113SdK0b8pMX6+5YALiClHETJ8wqXlO\n", + "rB8Untr7dVCmsFKwlikPPz9KhVtBN910k6TG6lm0aNHA/6O8+Kyf8kchpH5QJLAutmzZIkmzojmx\n", + "MiMlCQVj2EAF2h3niaxifPawjnhu2gf1CDwP9YOfDNYn5ROpHn3B83GfXa/nSlStFYxiCa4OofRS\n", + "n05kpQLlOFf/7MvnxFVExiZ/9uuvv16SQp+dxz/+8ZIaPzx+T514GeMvSFl3VdbGDc9B33b1uy2R\n", + "GvqIRzxCP/3pT6f7XknBcYWQsQjwK6W+qRfUfRQtxgKUFcYC/FF5Xu6LekedBt5dKJy0L94BPA/t\n", + "jT6C0sIYTjtyBYZ2Myl4PnyZGNO5v1qliHLjeJ7b37V+Pq5PedZCeaMYQq1imlJEkiRJkiRJRyam\n", + "SO2xxx7Ts2/3kWJdGYuedVUsbGb7rMdjmUYKQxQtB/wOazCKInNQdFCCHKwFjsPvBcUGawvrBJ8w\n", + "52lPe5qkxjcnmiVzHPfDbJ3noRwhsg6wyrCWXDlwKy8qV67H/WItRD43JV+clStXSmoiO2g/ba1e\n", + "2lupnlE3sFYoD65L/WJ9uZ8D1hgRJFu3bh04blS4KtNWkXI1Bkr3jTXsSl1EVz+w7fkN9ZVWxZ89\n", + "yoVXih5DncTSpYzoe1Gbn5TvS1ufJfxWGZsZo+gb+Ge2jbKjDXn50HdRimgL+NU6PjZ53+A6jL2s\n", + "bnA+xmY+eedwXzwv9eUKpo+xjIkoW4xBvsrAOwI/YMbOb3zjG5Kadu7n73mjktbgY3b44YdLat7l\n", + "+++/v6T61SL6G+VDvdOP8F2jnGlnKFYoWIzFfNK+OY53JWM1c4tobhKRilSSJEmSJElHJqZI/eQn\n", + "P5me9blSgqWK8oEVwbon69Lr1q2T1Mxaicxw5+mSnwHWVNu8PaV1WCIWsGaYDaMQYFVEShRg3XEe\n", + "nyX7bB2riueOrHS+ZzbOujTXY3be1koFj3Ys+b7UUsorVMKVqKjeaZdYfZQz5cV9YBX7ebAOKcdI\n", + "OeP/h32uiCgnEs+B9Us9Y6VzvzwXx1MO9DegnErBCyjEHF8bqQT4p/j5Zt5j23OOCsqSMsc/LIKy\n", + "49NVu0gtbAt1zpiChd7WmZsxGlUWVZwIaJ7/iiuukNSMTRD5tPk7AWjLKDSMsZEiFd0voBLz6X2Y\n", + "sfmWW26R1LR5b1/+jkKh8rETpYXjIrUYxas2YpZ20TVarS8oXxQ36on2hnJUC+XO77y8GDtpt/yN\n", + "8ovvmitP9Ee+511Jv+P3tWp+KlJJkiRJkiQdmZgi9aMf/Wh6tscsmlkhs3Csgcj6IkcJ68icb9jI\n", + "HWb3RKsxy+4agYIVg+LDrJnnwn+gpHD57B6wjig/zkt5RNY569VYdTynz85RqCYN1gQ+Z1jTlJsr\n", + "FVjDUbm6wuRQzpQf1irnKymJWGVEbEXUbKs0DK5IYiVTz5Qn5efRqPg9oHhu27ZN0mxFCvXE2wvW\n", + "H8rRzIz6UndFivqZ2R/GrUiV8tbQViI/Soe2wHldkSJjtPuAUMel6+DThOLD8ZRh26gv2gDPj18r\n", + "SgDn7StSlchq2lRtxLT/HugL+D5RjihcHh0YtSvaHW2cT8/hRr36GO5jV1tKCuWw+ZVK5wWei7GR\n", + "1SOPVmUsKb1TKRfqwdVurk+9cH7q1X2iUK68X3Ed96WqffelIpUkSZIkSdKRiSlSj3nMY2ZZKSgM\n", + "KDSlWTazSmabvmdeW7AiiDRAsdmwYUOn8wFWALNbnhursqRE+Z53rrgxm2Z2H+XnWbhwoaQmigwr\n", + "iig490vAnwO/hwiskFFtRO0+Yty3ZxR3ovtBGeR8nvcIUKBoZ219mPCd8uzGbo1GEUqjwv1A3Mqm\n", + "3aOAUv+028h/hfL250NloV3y/yiz/H9tFm/f03AmUduPiLL310IbinLAoUj4s7kq53l2IuWAaDXa\n", + "LGVO2+R7+gQRzVyPto9SAChL+Dq1hfvAl4U6xh+xq5rv8E6gT5Vy/TlervQF39/V1eySYkRbdEUw\n", + "Glto8ygfwypSEO2KwaoNMKZRnihGbcdwL0/f5QLVm0/eYbX50agP+rwrSbR7vqf/U3+uNNHuo3Ly\n", + "VbJUpJIkSZIkSUbMRBUpZvtYL8wmWT9ltlmavTKLRJGK9mqLYNaJJc5smhwhXbML+7ot5/FZcinP\n", + "FdFvpefzHBrA82GNeh4lrBL3lfG95iL6VqKi7LVYHaX8XRDlKaJ8UObwAXKG9eugHaPsUM+uCPE9\n", + "9YTVVvLBGhVebviL0C8iny6+d0WK9kE7ov6ivfRKUF7c50xFt62/2bB1XNrHkGf369D3UeVQI92H\n", + "xqO+PPu/56ajzfE3YwplzfE+xkLbjNBAW6WtoBRx/bYR0RHc34EHHiipGbt8/8wI7+uUL+2G8vF2\n", + "5L43XNf9DakXX30AL2/qpeTPWYuv4vhzecQ490+fqt1dI4L75/y0c94p+PihrHoUp0M7jvwpaXc8\n", + "J+0MpZn7QImKVH/fL5fr1vqUpSKVJEmSJEnSkYkpUo973OOmZ+G+NxgWuUejORyHguGe+rUw62TW\n", + "ij9DtI7quPXCbJZZN8/FrJpZMbNl1vuZXbs/AVYECgxKCqDkcb9uVXg+I/cxAsqT2Tn+DiVFiuf3\n", + "/apqYf0eayaK+uL+aDeoAXxfa/V6/iKu6+oCShLHtbXW8DehPZUy63Nfo1aiKF+3RrkuVrNbgx5x\n", + "E+1jFimB7uNGubfNcM590u9p113ONSw8C9FuvmcaZUhbcj9G9/fiOB8Dgb6M4kNd8Xvfo819SO6+\n", + "+25JsU9OVz89+j4Kg/vK9A1tz1XSkl+tZ9Z2pY42jF8gkbf0UX7vyhF9mzZOeyi1R+532I3juW9X\n", + "VsAjbEcF1+d5qCdWP4jq5B1WUqQYq3g30z/A80ZxvEce0y/oD95OOA/9gvqunQOkIpUkSZIkSdKR\n", + "iSlST3nKU2ZFnjBr9Sgwt/KA/Dy+U3rX2b3nd6qdjbpPjysMbi15PiT+jqxB96HyHcVLvkwoCczq\n", + "sbYoN6xUIjcoP8rb14lRqlDI3PeH+uK5seJcueP4KAoM3KrzrMyUXym7MVYJPmJEh5Jb5tBDD53z\n", + "uhxPOZZ8ejiecvYIKWdUGc0jqHfq25VI9ztAWaU8IsWM9uvWHlak+0qhLNKeUO5KOaBoT74fmdRf\n", + "viL3WYny3tBm+J4M2e4bQh9lzzHw3F2es8yz8OO36bsEUBacx31jINozEGr3GY1gTIt8sIbFdwFw\n", + "FbukAF199dWSpBNPPFHS7EzX7kNEW6aN0vY4ztsDfeOmm26SNHvfScrFVym6+uECv/cxdtx771EP\n", + "PBfvCMqDdlobDbdp06aBzyOOOEKS9NznPldSM3ZxXlfTGdM8xyJQP/w/73L+rs1Hl4pUkiRJkiRJ\n", + "RyamSH3/+9+fVjKYveKDgm+JZ5UFrB73QUFBKkXtRRESWCclq9aj21yxwfqM9mXi/jgPx0XWoFsr\n", + "W7ZskSQdeeSRkur3Crz++uslNevTWHe+0zzPHylyWF2e7RdryP1GjjnmGEmNlYcCtHnz5u3er4Oy\n", + "g1Vd61/A/dBesFppb5FihNLB8bV5jlCiqI9SjphhI2XawnNQfvztEWNYdzN9kKRYkXJrHiLrDnWG\n", + "fsD1IiuQfsuOA9TbzP7qEYNd8az5qOeuQFB3KERRHiHf15Cy931CS9CHnVHlcKuFvuU+XuyVBrQl\n", + "xhZvWyVQPf/+7/+++83OgPtkTInG/mXLlkmSVqxYIakZE9hdI1LV/R3Du652taMtozpvLex/S25C\n", + "uPjiiyU1yl9XX8b169dLahQp9wt2nzzeza5E+b61npPS/bZLpCKVJEmSJEnSkYkpUj/+8Y+nM4Zj\n", + "4WK5Y3WU1ieZ/fqsH8v1lFNOkdTMPrG4fV2c3+N/UFIQ/P991orVEVnHrkAwK458V7DasHqi9XTW\n", + "8SlPFD9+x99YzVwXXzPui/NzvCs+kSLBLB4rACuVWT712tYfgPryCBDui/olczv3Qfl7VJr78rjK\n", + "wO+4LtcrWXv4P/B81157raRybhiUL5QhfJIoN99RPQLfucWLF0tqlD+PYvXIFo+6pFxQiNy/odQ/\n", + "XB2hXXq7d3+EUrSiR97wu5nZzMkvRFl5RCj3gH+cjzFLliyR1OxJx/+j4rrPD3553oZ4Nlek+PSc\n", + "cIwhlMGwGde74pnhUZi4H8YoxjjKlT5GW+U5eC6PvIVJK2lf/epXq467/PLLBz670lZ9pv1QrqUI\n", + "6lJes2FBbY98jkpjZN9RtbQf3+WCMc7zSgHtmHcH903ORt5htRnnU5FKkiRJkiTpyIIHxu3Wrwct\n", + "36mpqXFfNkmSJEmSpDVTU1NhFGQqUkmSJEmSJB2ZmI/UOBQprjEu9WtS1/va174mafa6NT4ve++9\n", + "t6TZ/iGsp+ODhS8LPlX47OAX8tKXvlSS9Bd/8ReSGj8Ij1pkXR//D47D1wi/C37nUYP+fA+1+sOX\n", + "6qyzzhq4nudPK1GbzRl/gLPPPluS9M///M+SmggY6gv/FXzI8NUC/GE8FxE+WGTo9wintuWJH1Ft\n", + "DheYmpqabrP457mvAz5H+DwRVYYvBWXpfov4UPAs733vewf+HjVc52Mf+5ikJmKRuqMOPFqKOsD3\n", + "w325KCfKnPM9//nPlyR99KMflSQdcsghkho/PDJS33zzzZJm5wrDJwofNf6mPvBZwefnuOOOG3jO\n", + "UcN1LrroIkmz83fh48Z9Mybif4hvDfmNGHtpV/RN+szv/d7vSWr6+Pnnny+paWful0q53XrrrQP3\n", + "RblxHuqLsZvnOP300yVJH/7whwfum/bsu4bQ1zmv5wT0qDbKhfojgvwd73jHnMdzfd8TkevyXPgp\n", + "R/Cuev3rXy9p/O0lIhWpJEmSJEmSjkxMkZpPHHTQQZKaWfRtt9028P8ePTXfwNpGYcDqxtpxq4qc\n", + "N0Q28PxYBaVoM5QLz91BxBTliHWMUnHYYYdJapQu9gtDGcOKa6tEjIpaxact0V6QWGdYiVibUcb2\n", + "6L4oT6xF33/rhhtuGPibKE7PgVS75x/X4T75RA1pyzD1/4EPfKDzb2ugb2HZjxv6DKAuR0R5p8Bz\n", + "qHF+FCnaBG2WNoGSh4LAp+fJ8hxlKC5E2I56X8kSN954Y6vjGUOjfEilvQoZC3mX+DuFMRWV3iPC\n", + "aX+M+ZQ7ecg8Yzj1yxhNNKtHIvvej1F0IQomY+PMXQWk2eXB+V2JAlY7oj0CnVLU4qRIRSpJkiRJ\n", + "kqQjqUipsSKiHBys/89XRQorDyuZWT5WA34LKEJYKVg1HEc5cD7Kw62TKFuv58jBGuV7/nYrmfV9\n", + "FLHS3nTjYlQBrZGK4HmiIt+xEp77BP8YcJ+2pB5Uw0lZxr6rwqjxPQBRSfEFijKD0+d9H06UE/wE\n", + "fRcKFBtX3sYNzxXtXhHlQyr5OZZ8gKCtKut7xoErVCiA/i7z3R4iOJ/nfOwKSphnJI/oOnaRK5Hn\n", + "52/2mS3t91oiFakkSZIkSZKO7BCKFFYR1lgpU3RbsH6iHamH3Zl71KD0uKKGdYG1iDXJOjdWCT4t\n", + "WCVYU1iLbi1QHvhNuPWFVYb1VcrIzX1hnYzL2u6bWrUA37W+wV8BhTGyfqm3UakqbfdPgz580obd\n", + "y6vEsGXGM9K32qqO4+4b9HUig7HkUZjwtfEx2X3JUBJQWjjed3/wzPGTgvtr2xZLEbeRf6TTNqN9\n", + "pNSg9rOq0tUnjfv2veuGzUzP/dTeV9froYTiA4biOKwSBalIJUmSJEmSdGSHUKSYnfetRDnMtlGm\n", + "sKawukYFihuz5bZWGcoDvjdYvYAihDVNLhmeL7IGWP92Rcr31PN9jLBeUF48GgxcQcOfgs8dBcqH\n", + "SCSP+nQi5fNJT3qSpEZJxFqvbfccx3kABRLYT4499PqGdtwW6p3yIZKnpGjOZFRKFHTNceWM+j77\n", + "ApWT/FHcd8mnhv9nrHBfKMYOj0ob1uemL0blHzmqeqc94isFtFf3l22L763I2OTXi0ARY/WkK7XR\n", + "fY7vJ0r7o32nj1SSJEmSJMmEmJgitfPOOxdn5+w0TWZuFAyUF/Ih9QVKytKlSyU1s+5RK1Iobl39\n", + "A9xvI7Km3Bop+WdwvNcTVg7lhZJAJA4+T9RbpEjh74GihZIy333SHJ6jdp3fywO/HnyLsPpQDFEc\n", + "SxErWPP777+/pKYduB8K1xsVXaNb/XfzRZ2YCRGlXS1j1DrGMhQZr1v6VG1faKuU0Xf5jOqMtsP/\n", + "cz8oDJFf27777iup8T+lLjkfqmNttNZDhVFHzPoYT70wxuIbRL23fbfxLmAM8bElgnbP2OZKJLCK\n", + "EfX9SM0v4e2bsfWUU06R1GTw70oqUkmSJEmSJB2ZmCJVs1bM7HT58uWSmtl8pHAMC8oO+0ihsPS1\n", + "vjsq3CcqIlKgUJCicvXzo5xgTfon1kdtdBr+Exy/o1mpWGW11pmXJ/4n++yzj6TZPnNYmUSelKDd\n", + "omq4YhlZgxGchz5bihybL5FXo2BYHxcUAfzWaPOevT5SovBJcb+52jEAaBOl33m0HXWP0sFYgILA\n", + "nmoc73v7MZZ6m2oLvi0ohNwnY0kpH9KkGNW7C7w8XQHzsbWtIuUKVy3ka4pgrCu1x2HrFWWK9s+Y\n", + "O+w7PhWpJEmSJEmSjszrqD38CLDWNm/eLGn0uVSYtbIe67PlUUV0dAWr0K2/Ep4bJMJzmuAfQvm4\n", + "zw2z/Vr/DhRArO1R+6T1TdtIGN+njb+pR99ZvW3uF9QKPr1+anMXYXWSzZvnnHTW6UkybB4p+gyf\n", + "tVFPEEVwcl/UWW0eotJYynlQejg/ChS/Z6xGNY3arPsDdo3QRVV1v8quPjTjYtwZ8VEGUYn93dYW\n", + "6htltW2+q9J5R717CAow7zwUzWH9clORSpIkSZIk6ci8VqSwbrCgWb/Egh/1erhHT+F7UuurMi66\n", + "+hm4ddn2eliTKHV8z3lrfaTIE0S02Y6SYwdQKGuj4dwa5HlRJyg3zovV7XvmRWAl0i+8HmojhzgP\n", + "1lpf1ueOzLD5o6hjPmkzqN5dLXLqFKXAdyk48MADB87/rW99q+q8rhTQBlyRoq1GChf3hWrOWEpk\n", + "dltQWPikT83X/VBh1LkQHeqfPuzKZde9G2lfbX3zSvc5amiH+Krdfvvtkobv16lIJUmSJEmSdGRe\n", + "K1JkGyWqCbB+Rh2ZwSwZRWw+5rWR2kdhQWkWjpJBRIP/DivalRiOJ5fMFVdcsd3rEOnzzGc+U1J/\n", + "Vs64qfVlcl82rGraM+0Mq7Ft9mCs/ai9ogLURhChiI064mhHwLPGt4W6RE3Hsq/10aBuI39IVGKu\n", + "QxvyPd5qfak4D9Fe9HXfbSIaSziesYScaKj6w5YnjDo/U1+0jXZri48Vnol+2PtB+eN8O0q5A+2P\n", + "5+7LHzcVqSRJkiRJko7Ma0UK7r333oG/x7UOjvI1X5UowEpldo1V2nWnb3A/CFixYoUkadGiRZIa\n", + "JYXcLuTmYP2dvz2XCPf5m7/5m5Kkww47TNKOq3zUWjce9cm6vUfb4ZtX63uF6oBage8Z54e2ETvU\n", + "f63ySTuAtpFk85mnP/3pkrqPCdQNeaSo69pIYK9LBz9SypqxgfOX8vk4jL341hBth2qMCupjNKAy\n", + "++oBKuyoI7DnG6POkec+WKymeN9jDGirKHE81xm3v7CvTg1LbQRziVSkkiRJkiRJOrJDKFLOM57x\n", + "DEnSXXfdJanxZULh8N3uH+qgPGB1DKtEOe7/cOihh0pq8km5VeORPHvuuaek2dbwwoULB77Hyv/K\n", + "V74iSTrzzDN7uf9xgbXZNicJe0ZSjyiulGtbBYl+gfrh/jFtreK2e1ri8wbjVKJQ70YV+TlsniLq\n", + "BDW3rUVfirbzsm6bWy6CMQVFjL9LihLqsmeMRt0kjw+wP6dnRmesaRtBiiKGWtyXT1ZXxv1uisqp\n", + "L9+mcSuKw9Yfiirtq6+xKRWpJEmSJEmSjkxMkVq4cOF05ApWmWddZf0d64X1fvaGwzrB2inlRcJn\n", + "h9m4W634pPi6aWlH6knj6+KUq6+D81lSrNgzjnJ2ReOmm26SJG3YsEFSY1VSvu6zRfSlc/PNNw98\n", + "jgueB+t62BwigBpS8j+gfoDyxrrj75LfDNdDiaW+8EeJfKvOPvtsSdJnP/tZSc3zc19EW6IsYUXT\n", + "z+gfXG/Lli0Dn6eeeqqkpl+XfKQ4D9Yi7Qg1g/uL+veSJUum/z3qHGSoc9xzV1CW5tsuCRG0Zd+r\n", + "jLE5GiMZm2hb7mPlvlVEnaFMMZaQY442sXbt2u3eL22WvsF9EGk8LrwPPu95z5Mk/fVf/7WkRmmj\n", + "b/D3smXLJDXlQZ/mk+gz6oHf1eaa6wvP1M47Gx84yp9yaBslx1hN3/cx1ccMjmOVivKivTGWMHeg\n", + "3fLu9yjUkk8ipCKVJEmSJEnSkQUPTMAkWrBggaampsZ92SRJkiRJktZMTU2FCnIqUkmSJEmSJB2Z\n", + "mI/UJz7xCe21116SmtwsrKOyDn/rrbdKatZB8dlgHR7fHKKQWBflfOwvNS71i+tccsklkpp1a3xe\n", + "8IsgF8bSpUslNeuyHqXFOji+KZQLeXqOO+44SdIHPvCBgeMcjifigXKi/GrzNvF8fPJco9oniev8\n", + "6Z/+qaQmWhN/i/vuu2/gEziO9XLKBd8w/GgoF9bPX/3qVw9cN4J1c9bvyZPVdt8mrnPuuedKmu0v\n", + "w/3hV8B983z4gdBuiNajf7i/kNcf4F9wyimnSGraCX4cQAQU7fOGG26Y87mOOuooSdJznvMcSdJ5\n", + "5503cJ/4TeBf4XtZ4oMH9KPIt492+La3vW3az8wjIGkL9Cl8Uo4++uiBa3s0GcfRxikbnmHcY0vX\n", + "60V9lefwSNNS2+wbrveJT3xC0uzdFDwSlYhfxkDG1vXr10tqfKGod9oFf7/2ta8duO6o4Tqf//zn\n", + "JUmbNm2uRtxUAAAgAElEQVSS1LRtfMB4DtojY90tt9wiaXY+Lt6N+CTRl/CD/OQnPymp6TvUP2Pi\n", + "ypUrJTV9+pprrhn4m3c072bOQ1/mHXbiiScOPOeomNnXJelv//ZvJTX9fPfdd5fUjC2UK2P1unXr\n", + "JDXlxlhKudx4442SmjkF5Xn66adv975SkUqSJEmSJOnIxBSp+++/f3rWi6LA7BBrwrOyYjVhXRDR\n", + "wOyYWXbXHcX74vrrr9/u/2/dulVSOfIk4s4775TUWGOREgVEzUXRc22h3ryenLY72mP1eFQb9Y+V\n", + "gHUaKRQofKgPDlYp6oIrICVQLfgcds/HyNqP6ov6R0nsev2DDz5YUmP9r169WlKjgKFUYZWedtpp\n", + "kpry2rhxo6TZyusLXvACSU1/9UgbVz9QGYhUclAAsRpd8ZupshAFduWVV0pqxgosUM+JxblQZq69\n", + "9lpJTVsjqodnoM+hdo8K2mZfUYiRalzKeTZqJcqj2ihvxnDaIvePUoOqj3LoSiP1zXGMFdu2bRvB\n", + "U9TjUWvcl78zGFNL+Z48j5OPxbfddtt2f48yxrsXPNKbCFyPEK99pzBGUC++awhjB0qSX4cxwJVK\n", + "z03o70LKm37OJ+2FVQTmEvw/SpbnOYtIRSpJkiRJkqQjE1OkZlo6WNSsY2KVHHLIIZKaWbdnMic7\n", + "MLNYrJu2maWBfDTMnlHKImUjglk3s3m/H3xbame7DuUD7FHH+u6o4blK+xS13RMR6zvKNVKrHJXq\n", + "C6sVa8Tpug/VuBlWCUNRw6eQdkq94f+AYnTxxRdLavJFUT5YiZ67p20/xK8JHyvaA8omStz2cuV4\n", + "DjpA4WDcueOOOyQ1qpqDIkVWftQ/nm3UYJGjnnbFfYXwpYnAXzCi777BWAsoDChHlIMrarwTUHQ8\n", + "RxnPSb4vxvJhd33wsbdtbkGUTPou7ZG+SLtFneWdhx8mz8UYyf0wlrVdjeHd6WMu72Luh3JzpahW\n", + "seT3pfJHBffzth1LaveyROmi3XMcChxzjBKpSCVJkiRJknRkYorUggULpmeLzEJRcrBSsAZRbjZv\n", + "3iypmUUze8Q6wkrpmoGc87IOz3nbKlJYE1gJeP5jVTFbxppAAWC9mfVaysXXd13JinZed7BKKTes\n", + "y1Fng26L+0g5XRUPJ/IbGbcShVWEVdo3bvUD9Y4/Du3Os0/T/qN+gH8D7ZP2yPe1oHzxO/o//cOj\n", + "M2EulYixhWeg7Udl4eBbQxndc889khrVjKgxzsfY0dfeYygB3jdLEYwO90U0U0mRKikMffcNvx7K\n", + "Uuk+fYxHQWRMIzM6qxQlP9IS9FFUWhSctu8afPSisYtIXfqA7/6BYke78Ihr76PUe7SnI32dd5H7\n", + "v3qGcIc+Oiy86+jLUT9ynzrq3Xdn4DkYOxjbfDeLaMxltYVxoEQqUkmSJEmSJB2ZmCK12267TVuJ\n", + "zDI9Dw6zYazBaAdxfu/77bQFpYfZeNed05nlR7N4coJgdbiVx/o0s2uszyg/Ue0O8u5HMKwSNao8\n", + "Um51kD8Ma4V6aqtIEYmBqjCsotUXkVVEe3YFti3R71yR5D6wBkuqAFD/WH9Y6/hruP9B1G54XtQk\n", + "cuq435O3d9QhqWkbWO6eM833BnOwzLG0PWrM+6Cr4X2B0uD7XPqYUILnZQwtEe3PGMH9lco1wvsg\n", + "dcmqAHVd8sf0evH7oV7b7vUGrDLgc9W1vvHzc1BM/DlpX6ixvJt4t5TKHR8fypE+xv2j0LhPEX6I\n", + "kQLJfbhPnfd1YFWGd7u/i7gfj8jnfhgziCAGxgaI3rmch3cJz80qV0RtP0tFKkmSJEmSpCMTU6Qe\n", + "+chHTs9qsXyZjWP9+WzXLVnfuRlro3bHZgfrCOXLowlrra7aWWyk5DBr59N3LK/18xg1o8ox4+VC\n", + "PVM/JV8irGr8A/DZQeHAGkK5LEUqTYq+VA6PtAHaEdY8qgWKaWQ9O5Q3Vq/fNz5Y9E+seu7LI5Gw\n", + "mj3TPwoXyhftYaaPlEdD8clvSmXKtbgn90fk3mBUfm2ekR2GVZGJ/vL8O+AKWASKAWXPmOcZxPFh\n", + "icqJ8wBtg/ugbfkuBSWI8KXNMIZGfaEE5cU7qracHPoc5cQ7hXbF2Oftl1UOV3IcH8tcqfP2z9jo\n", + "ebhK0D591Yb2xVgL1APlVlpF8XrivhjTHfot5Ri1N88j1xepSCVJkiRJknRkYorU97///WlrhNmm\n", + "511ito4V4koFs2msHuia6wXrh+tgBbSNzPD7cYjMIJsszxFZiczyOa4U1RaBVVdrdZRoq+RwfRTE\n", + "yLp0qwnr0r/3aDfqz/OPUW59+7HsKER+DqgutG/+bptrh99hpXo/pZ9TP1iltB/3xfIoVKxNrHna\n", + "z1yRcljg/Ia+iA8Iv+Ha3JvnpmIM8r7Ste/Q9mmztTnW/Hq1/oj4k/FJG9h3330lNUqbW+61kZYo\n", + "BpHCw317PbhC4uXA8+Ej5n60/ne0SuCqM2NmydcqArW0q48VRH3LVz+IFuN+a/1gfZWg9l1Yq3T5\n", + "+f0d4KsnlD/tr6v6z+8jhZb/p12Qr+vmm29udR2UM9phbX9IRSpJkiRJkqQjE1OkZloiWCvMLpmV\n", + "8xlFD2Ed+Kw7im4rwfoq98E9tvVLYNYe+VYxa8daLEUHUj5koO6qSFFOWJHD+lu0zSnj/g8RXl6R\n", + "kuTHcV72l/KIIKxjfK48B8vDDerfrXyPjCmBqkOkG/Xs1/GdB2rVFdoZ/QqfK+pvprKJakVb52+U\n", + "IJ7V9w7z/RPJQ+QWaddITyz+YftcrSJGWaNA4VvC2PP1r399zt91zcEX4TnrnCh6K1KqOL5UDrRB\n", + "InVpQ6W95yYNYxr7sQ7rg0dfRpGlfrkOqy6lCF3K0/e/jRQvX/1AZe6qSLkPGTD2cF7eAV3znXnm\n", + "+tpM8alIJUmSJEmSdGRiipTUzB6x0rAOUWqwJrE4sUBdoWDWy++6RlRgbWK9drUemSVzHz6bxlrk\n", + "OLfgwXOfoFzhA9QW1ueHfT6otY55fqzSkmJYe16//5L1hnWOtYfaMF+iIMcNChI+R0B5oF6U/HlQ\n", + "iKJIM/w/fN+0tu0PK5N98mhHM++fe0cJ4RjaFGoun/R57tktabegu+ZLgq5qOdB3S2qqPy/5hLj+\n", + "sBnKa/0t6fuMhfwu8hVyn5eovEtth+vQ1nhnePkzxvatxA2Lvyv8Xdk2gtx9iKDWB4h3MAoW5eh7\n", + "Wkb9hn5WG+ntqznUH33/uOOOGziO6/GO4Z3J2FDyjUNZI9oQP2byTpVIRSpJkiRJkqQjE1WkmC1i\n", + "PTCb5HusS9YpmY17bhdmk1jYZMVtC7NaZtnMgrtab+6XgNWDVYDvE/4YZFlltu/WJxY9mbm7goJA\n", + "3qBR5YMCj/gY9fVQ+Nxq98gsrL75kuF83Pg+ZOz16PtuRdB+PSKN9kW/QXlFMWyrRHEdV5lgZnui\n", + "LrkGfZi6pm14H8eSZszhmh4huHz58lb33je1eZB87KLssbhrfW8ixaZWNaZtUe6MhSglvnpA+ePT\n", + "Qz1Sx7VRd9Qf5cBzeN6qrnmlRo3vs9rVV4r+QHm7kki5RlF5wFjAJ+9cj9JzRRHajvmRf7G/+1HB\n", + "99tvP0lNu6Gd1+7OQHuhvfJ79sst7bmXilSSJEmSJElHJqpIuU8Ss1ssWmaJ0R5bwB59nAero3bn\n", + "ZmDWjBXq+xzVwmyW5+M8KCLkj/JoJFcAfCdvGFaRcmVmVHgOEY8Y6ev8bh27EoV140qGKyoPFTwz\n", + "eORTR3tDrcGvAKvS99/yfcboX54PjnKl/buaQT+lHZQUKs8mDihqBxxwwPR3+DbwHZY8Odr4G4va\n", + "fTl4NlRtz8NUG8UTQdnw7G3zUtX6WGGJk4ONMearX/1qq+tRx8P6ENGGfHUBnxtgrEV58Azp1Hmt\n", + "qol/HsqFK1B9jUV9w/223fvQ4V3GXoGMhZQv7Y8+Sfun76Nk4UuFny6/a5tXq3Z/1qidu4JJf6bd\n", + "MBbx+1JORxTQqD3V9reH1hskSZIkSZJkjExUkSLrKJElWImejRilitm1Zz5mFr1ly5aB78luCrWR\n", + "JkQG1GbCdkWjlKsEXxSuw6z+oearU5vzZdjzl1i5cqUk6Zprrhn4ftgIqr5A6fH8SKgl7hdQ4tBD\n", + "D5XU9Bue36GfYaVjBaNmoMJwHJ+usKJ6AFbeihUrJM229vgbtQerMorkIuLMs1RTXlxn5j3yLLQR\n", + "LHssavq29znaxBVXXDHwO+6N/z/llFPmvNcSKDzUccnnx8cWyrZ2rEDVRglwVb+k8HjEJiomz1Gr\n", + "bqPCH3300ZIa/0yHsXDYHG9R5Oi4mdk2u9BXZLX73boSy/cLFy6U1LQL+rrnW/N9cv16DkoS/bOk\n", + "SEXP7XmegDHSx0rafeQ3SyQ3+4s669evlyQ997nP3e79piKVJEmSJEnSkYkqUtF+TezQTDQbs+PI\n", + "ZwiY5aIInXrqqZKkJUuWSJJWrVolqVGEmE37rJ3ZMLNZPlnPdwu67To2Vh6WvCsj5K7AYke5i/L0\n", + "OKUIjBL4maAQ1u64PiqwgttGT5IJflJ77GE9UQ+0N48cov3RvrDasOJofyVfPdQKzu85e/A14nwb\n", + "N26UVO5XWHOcL/I3gUsuuURSY41HUbC1+4fRv1CiURf4XLdunaQHc8ts2rRJUqNOc888O2VDGaCU\n", + "UAf4H3Kv/J66YOwAng0fIsYO+iB9iOP8PlyRoq0ThYRSALQNFAHOQ5m6xc35I+XroIMOGrhvr1PK\n", + "iQzhlBdjxLZt2yQ1fqGMZT420gcYmylnng+lilUIyguFqrS3n0P581yezwqOOuooSY0S46or5cn9\n", + "Rv6EvGOI6qR+fGynfimXrmNT7ZhIH2HsQcnkHYbaix8lmdCpV37PdYiMRxX2HHy0D/6f+vJypX9G\n", + "94+PovsUen8o4Xs3OoyBw5KKVJIkSZIkSUcWPDDqpD5zXXTBAk1NTY37skmSJEmSJK2ZmpoKV3lS\n", + "kUqSJEmSJOnIxHykxqFIcY1xqV/z9XpHHnmkpMaPwX1TPBM169oedXfOOedIkt7xjndIqo8o4fxR\n", + "zhHWvT17L8/1vve9T1Ls5+Hr6R5JVOtPEJWn509qG11JtCnr9fhPvOY1r5nzeqOC67zzne+UNDuH\n", + "Dn4p+MNQjjw3/j74fXhOGeB5zz77bEnSe97znoHrRfm88A3En8F9wqhH3ylg5vPxjFFGbn6L7xP3\n", + "gq8RuxHQV6I8Q1znIx/5iKTZkcR9w/Xe/e53S5qduT0i6luO+8+94Q1vkCR9/OMflzT63HM833nn\n", + "nSep8RHDp4k8YF6f7vNEfeGjgw+Y+zS95CUvGbjuqJnUu4GxGt8mfLPwQ4YTTzxRUlPua9euldS0\n", + "a/yVGQPcT/Gss84auO6oqS1PfOB4fvKo0U7wjaN9M/Z4hH/pOqlIJUmSJEmSdGSiUXvjhkgTLG+s\n", + "FvJNocRceOGFkhorlVwTWM58T5TVF7/4xZHf+zB4ZIXD81133XVV52ub26SU/bZkLZfyRaGMRFBf\n", + "nhOnFtoF6gXWe23EDVY0ikrXvSBPOOEESU2Oo65EKgvRmddff/2cx9Xms3LlsLTfFeWKAhVF2KAo\n", + "bq8esbhRnogC43vqgDqhLqhTLG6imYjSo827GonyNWpFCtqqobWZu2nLrvCMaxcEoI6JGiupyNHz\n", + "oZSgZNEmS5muH2rQbonMjcasL3/5y5Ka9s5uIRzvv7vzzjsHzu/wbiV6kv7nuyyggKIEU0+MGdQf\n", + "12nbHskDxXl5V6A4sTrjY07b3IepSCVJkiRJknRkh1Skop2hSzDb9l3umW0zi0a5wnrBYuaT2Wrb\n", + "jNN+/8cdd5wk6dZbb5XUWA1EBrTNmxSBBb/PPvtIasoNJY7nrVWkOA/WwqhxK9mh3lAhUMBYF6d+\n", + "axUpz76L1UR74bxYMVhnWF/klEGlwJpCGWubCwVF8bDDDpPU5LTheqtXr5Ykvf/975fUvd14zqW+\n", + "9yHDdyrydStls/a9G+eCsqbsKXPfU4tzcVwUjUNdoT67IkTenCgz8rD4/pttadsWShmnu1I7Znsd\n", + "oxC2VeJow9QfmdSjfRsf6tCO/J3m+C4Fnhmc31OOkSLlmeTpJyhT7pNIfaOKe3+Ndj0owbv69ttv\n", + "lzQ7M39fORJTkUqSJEmSJOnIDqlI9WUpe0Zy1k+xYrCO8N0gcgGfHs+AXgv3j3LCrJzZMhFDfYHP\n", + "C1YACk3Xfa26WgddKflYufXj+0V5hEoJt9ZYr/csu76OjlJHe+D6tBfOi49eLZT35ZdfLqlpj8ce\n", + "e6ykxoerVn3A2uO8KFvct1udbXd4jyj5SkVQXjzf9vZNow+hsmJx4hPFs5OBGsUDxQKV1bOwU9dY\n", + "5oA6OCq6qouUA32BfT0hUpWjiMrSvpREx5EZm9+xKwMqZEnF9z4VKVGo0FFbiFTokro9arqupgxL\n", + "yQ81ApXfy7utQshz0w587z5/53p/Y2wq7U0Zwf1z3q7PEZGKVJIkSZIkSUfmtSKFVenKUFewzrBw\n", + "idjxvczwh8BvAmsMKwtfD3xl3EqthcgUlAGs5ZIvSVuidWb2vWrLsDuzt6U2+T4KUFe/CqD+fcdy\n", + "2qPvB4bawSeKovtWYYV19XvxHCc33nijJOnrX/96q/N4O6B8seKxEsknxSf+RF0VU99RvhaeGxWF\n", + "+5/rPHznOa74nmck+ueAAw6Q1ChU9DmOI6qH86HeAf6No6JrlBnPy/O4pc95SznW/HkjGDsPP/xw\n", + "SdLSpUslSRs2bJDU3Z+UPuS+W/RFxl7apkeXuSI1aR+pcStRwFhG/ddGXjM2UN78XZufzCPGUYJ4\n", + "x1E/7t/qeyUOuwELiiljCPf9la98RdLs/GRtSUUqSZIkSZKkI/NakcISRfkhQzZWVq1li/LErNeV\n", + "Jnw3sJrc98nX7Znd8+mz8lq/AldMmOVjHZPbY9Tg14CfyI6K1y9/o4TUWmFYS+4zxHmwsojO4//x\n", + "Q6F9YkW7ooli1hZvH0R50n7pL8Nab7RL/Gd43mEjXFALIpUB/P95Ht9BfnuUos+oK/Ll4P/IuXlm\n", + "6pJ78PPW5hLrio8hriyVoE0wVrmlTw65rVu3zvl7VNTa61xwwQVVx0dwf1F5A9/zXFE9uNKwPf+6\n", + "YfBI1wlsYbtduL+2/q2UF2MNvkb425YUKY5nTEHZRUFkLOQ4VmloB/gPD5v/6+qrr5YkrVu3TlKj\n", + "ZA6rREEqUkmSJEmSJB2Z14qUR7c9/elPl9Ss13rOiwifzWLVge+hxiwbZYK/sTKw5rCG3MqpVcrc\n", + "qsQKxperb18pB4WlbV6j+QrlST1izbfNxI71Rj1i/bry4+XmOVc4jvblUaJtwaeNSDGsOdb/8dmq\n", + "zQdWAgWqr1wrEKkMlM+yZcskNX43KIv4rrUByxllxXN54aPh+aRGlUtrWCgjv6+SXyDH83va6tOe\n", + "9jRJjc9YSUUfNbVKDmNlW+Wn6+4GKCaM+ayO8P3mzZsl1SuUvIM436jKHf9M3iVdI67xx2RPvlIe\n", + "Jt+9geM8Uzr14fu/Asf5O7srvAtKu2G0ZaiRfeHChXr84x+vnXbaSbvssovWr1+vH/zgB3rhC1+o\n", + "u+++WwsXLtSnP/3p6caWJEmSJEnyUGKoidSCBQt05ZVXDkStrVmzRqtWrdIb3/hGvetd79KaNWu0\n", + "Zs2aoW6S2SizaazF2j3PUBawxjwfEIqP+z5xHNYs67Zcl9m0r7N2zQ6MJY6V1ZcSFfkI8fe4MpSP\n", + "GtoB9dT1uSgXFC7Ox/mpF8qVKDaUU4/WA77val3RLmmPnJ/23Vcm/Enh7ZFyR4lyf4ou/i5Y/vQx\n", + "6tDHmLYq5rhgrGV3BmgbhUU5oLb72DcpqOtSzrGNGzdWnQ9lBAWiq38i0V70MTJ100bb5mlibOFd\n", + "QfTksPuCOrRvVnNQLFGIan3tOJ56QRH09sL1aKe0s65jHvXVlyIVgTJLv2qrdA59d37Biy66SGec\n", + "cYYk6YwzztAXvvCFYS+RJEmSJEkyLxlakTrxxBO100476dWvfrVe+cpX6v7775/2tN99993Dtc82\n", + "MGt35ag2x4nnqkBR4vd8YhWgVHneKp9lYxl3jdDw9XY+h82X5UTWKtYf5dL3dceN+7cMC+XmWa65\n", + "Du0GXygUKfJMoWiicrjvVluoL/x7ukYlzndQeHleyhlVoY0SRd25r1RbS3nU/oq1UOf+PCVVHmWG\n", + "yGSP5mPsa7tLQ98M60fo9JXzzn3s6Mv07dp3gL97UIRoX1E9oj63jTLjPhm7XCVvm9+L6E76j/vq\n", + "UT4OClbb/U5pt7RTV2L7gqjErgzVaq+55ho97WlP0/e+9z2tWrVqOgkbLFiwoHqykyRJkiRJMt9Y\n", + "u3btdv9/qIkU64pPfvKT9fznP1/r16/X7rvvru9+97t66lOfqu985zuzvPe7wKwXZartejS/x6LF\n", + "qmSWzPn4HivBZ9uoa3yP9TBsbhKui69N31FSEUxyh52NzxeoX4/0qPUDAH6HwuO5bdyHCiURRQqr\n", + "kfO4AtVVkcKaczUFK3DU+76NC88kj/JLZF0bUFhQCbHAUc05N32bOnUlfb7kBXLfmlpQMVHVGbtd\n", + "9Rt1XqwSffkGgau0XfMGoehQTuQ78jxjJUrlG+16EN03Y0AUzclYQblyn213V6AfuaLmChfXpw97\n", + "bj+PZC5dj+dijJuUH+jxxx+vq666Kvz/zj5SP/nJTwaWLC677DItX75cp5566nRStgsuuECnnXZa\n", + "10skSZIkSZLMazorUvfff7+e//znS3pw1v+7v/u7Oumkk7RixQr99m//tj72sY9Npz8Ylq5RcMD6\n", + "tmfpRfmpneV6Do5hlRxm7ygaXRW3rvSV1XW+gbVDubbNGYKVST1gDWHdYt1Tfu47Vco91DUCBeuS\n", + "ve94PqxCFLEdHZ4TqxfrtosPGHXDbxkDqANyb2Gxf/Ob35zzPKPKiO1wX3ziOwOLFy+W1Fj67tNE\n", + "2d18880D39MnaCsocSgE/G7SPlJ9R2d51B67OLTFI0lpV23V7sjXjrGmbU4/+kbpncH9oii1VVhR\n", + "MFFyUWxd2aKd+ViJr1ZteXH8nXfeKalRToedC4yKzhOpRYsWzRmC+sQnPnFsW5skSZIkSZJMknmd\n", + "2bwr5MwowfqrR+tF4LPBrBylYthIAqxirJTIKk62D0oNSiP1QxbeWh8b91GjvrGmPGKKPQprrbxh\n", + "rW6UKJ6nb78S4D7xJRy3gkm2bcq7S1ZmLGPP+I2li89U14zPfUMb49OjqlAgiLBFYaCMiG7CJwxF\n", + "gN0S3DcFpY3rtPWdKdE2ovToo4+W1CgotDkUpdpVgAMOOECSdOCBB0pq+qj79NRSun/6ysEHHyxJ\n", + "2rRp05zHRVGftL+27bB29YL2z1jRNgiMdoQixPkiXyfyTXE8ymetIoVyV4pmnC/kXntJkiRJkiQd\n", + "magiRdZSIkmYxWKFYEUxi8Yq4HisKc+R8eu//usD18GC33PPPQe+x/pCgUBh8Igd/BKwBvEnwBoc\n", + "dmfqYa1Bsux6TpNanxnWnz03COU57v238P+ohXrAv4MsxPzdNj/W8573PElNO8Mao/2hIKLUoG5g\n", + "fdGufV8n2jfKZlfwf6H9960iANbjpHzpqD/acRfVCB8Zz+nFsw2rRNEGxqVofeMb35A0u2/7bgz0\n", + "WZ6TfRppK4yF3rb7iopiTFm0aJGkWKFx6CPUPc9Dn0Z15rkoB1YF8OXZb7/9JDXP5VnzUb4Y23lH\n", + "cBw+ZChZt99++5z3i7LDrhSUKwqV950okhjVnPIvrXL4GMc7LFLOuG7XPGi8o/gsRZajHKJIun9y\n", + "idp9PhlLeWe7is67gf6Bgsd5+T31Tz9G0a1VUlORSpIkSZIk6ciCByaQIGXBggWampoa92WTJEmS\n", + "JElaMzU1FfrBpiKVJEmSJEnSkYn5SI1DkeIal1xyiSTp+uuvl9Ssl7JOftNNN0lq1qePP/54SdIt\n", + "t9wiqVlXZ90V3xR8YvAlet3rXjdwXdZd8fnB1yvyXfIcHRFsxfOiF71IkrRhwwZJzbo+GdJZD+f+\n", + "iew56qijJDXr8KxnEyHBujL+E0RckDfs0ksvldSUj2fXZdbO9fAb4Hv8Blhvx1+A9Wj8K175yldK\n", + "Gn1b4b7POeecsVwPuM65554rqSkf93MhAgk/issvv3zgPPw//hqeQ4j6fMtb3iJJ+tjHPiZp9t6R\n", + "+HIRkRNFseID5lmMydGDn8vv//7vDzznqJmamhr6WvRBxoKor3KdcbeVyy67TFLT5+hb1D15+/Cd\n", + "oQ54nq985SuSZkcsM3bcddddkqRXvOIVA9d1It+wtj5j3jY/97nPSWoiUrlPfFYYQ2lzjBW0Zf6f\n", + "tsmn+4++9KUvlSR94AMfkBT74tDWuR73U7uHLPX0J3/yJ5LatxfKk7G49rq17ZN3Ie+o0t6EtCue\n", + "i2g6rvM3f/M3khq/VN6B+CZ5lCHnoV749GhPfNmIaOd6vONov1yPv9esWSOpGRNf/epXD5yPdz/g\n", + "b8xYS/viXReRilSSJEmSJElHHpJ5pByfxWOloFB5jplrr712zt9F0WulHbuxBkuz/ZK1wWzb12k9\n", + "Fwz37/mOUIK+8IUvzHl+rK99991XUmMVEnGDIkU5oDyU8Gg2otwisMLGRZeM2X2CNUi5ejujHp/5\n", + "zGdKaqxn2hMRSiiPlHOU64X2giLZNluw9xd+T2TYfN6onD6JeoZFimVOGVOW8y1b/N577y2piYZD\n", + "iaFPMdbwyfMxZrBHHFFmlAPRS7XPGylObaMXvW2iZLhCxH31vddaaQyjrXubh5IC1zbzuXPkkUdK\n", + "ap6/VpGqhdUJxoTSO6o0VngEsUeFuiKF0ujPxfGMfbRPz7HI/qIoU1u3bpXUvCu9fv/xH/9x4L7I\n", + "VYcC9Ru/8RuSmvKojbBORSpJkiRJkqQj81qRIo8UPj9difbJiqwM8gTVzv6xEh3PyxTt0F2CciBL\n", + "r+c0ueaaayTNVlba5u7Aerr11lvnvI4f58oHSoQrZrXliDUzqR2+a8GKYn3fn6+tnwjtAWXKc71g\n", + "NbIkeY4AACAASURBVN14442SGj8e3ycOFSVq1+A7wfcF7WI+K1KAosM9k5dnyZIlkmb7TswX8FHx\n", + "/Di+txmW/5VXXjnneagj1EzO4xY8Cp1vB9Z2t4AI8j759bZs2SKpqR/aPGNSrYpKeUXHMyaXzkd5\n", + "o6ChVOCjxupGVyL/2FFvt8bYwyrE5s2bJTW+QtQP75gSKJy0P3zLolx00bsBHyfGxGisol0y1qK0\n", + "0h8Yq8kHFimu3AftgHc3ymhpD8RUpJIkSZIkSToyrxUplB5ms1gFbfe243e1CkHJQ9+J1pU947pH\n", + "QxElh7IQ7bGHIof15LNjIgt8f6q2YBXhR8H5fG84skVjdXi2aN8fzMH6RYFCOeO53K8gUromBfWI\n", + "tQM8T9t9oTg++h0KFVmtsZpoN/wdZS2m/QP1POwekQ7tBGtyPuCKBGW2atUqSdKZZ54pqfGpuPji\n", + "iyXNVlp4pkjdriXKbF0LUXX0OeqSsaN27zX2I6VcfJcIB2WAMQilgb5cq7L78e4LhY+Ut2UUBuqT\n", + "scB3u2As5rhI5YWSao+PjvvcUI/46ESUlAzalftFosxRr76fJoog30djvkeMO7RzxnRWPdgzMFqV\n", + "AFefade0K8a02ncS5eqRwVH9UT8oSihO0WpBBO2JCHhWFQ499FBJqUglSZIkSZKMjHmtSN1xxx2S\n", + "uu8PBG6RQ2n9vJZotu3Wq1uLzLY9d8VVV1015/mwTvCZAvwcsCa7rtejULDOHfnaoFjhk9MWjywC\n", + "rGy3zuaLEgUogNQbVhd5mNr6wHnOFAfla/ny5ZIaq536wsqP8PZdOr4rWIfjjrrcHv7s/O17baGw\n", + "RPsWDqtEARb7sP6AtDnGxlolCrg+ljtjIcoEuG8UdC0P7xv+d7QaUOpTvipQUmlrQdFB2eA+ahWW\n", + "kpIRlSOrFaeccoqkRvm58MILJZX9IP36KGrub0w7ItIbRYf+EanWrLI4lDvKXe19Av2Deiv5W+Lb\n", + "xdjJ9XmX1F6ffkh5uKJZIhWpJEmSJEmSjsxrRWrYiBBgvdVBAcK66Gq9REoCyko0q2e2vHbtWkn1\n", + "ypiv+7L+XZp9Y23iF+A+Y+TgYF2YWblbTUSRdaVkhQ+rEI4arCZXF7r6vZTyWGEFowBSf7XXdR+3\n", + "trl+aqH94Yc0HyF650Mf+pCkRokinw6qGn0FlbFv6ANtIzw5nvumr2C5e+64CMY6nhPVHrV5XHC/\n", + "8/V6qOFdlUPqqS0oRJHfZK0iWGq/vpsFY1FpTOLd5sdRvq7EtVVMo9UKh/rh/LR7xsy2/qo8Fwqe\n", + "j50RqUglSZIkSZJ0ZF4rUl1BSYFoNkx0mSs5noslAiswUrxqrcO2CoyvG+Mzw/e+9x2zcyJ1sGZ8\n", + "ls96MLlRWE93qwMfm7az/VqidfG+fNqGBSuvq1pRa+UA/grRfmAlvP4in8G+mHT91OD5ZD772c9K\n", + "ko477jhJjf/bqBQp2vghhxwiqcnTU/IHxGJmbKIuaVO1Yw5+lERp8bzDZuIuQR9mzMTfEPie8omi\n", + "zUqgilIu+Ox4pG0J7oOxkyi9Wr/Nrn0h8tXrG8b6ww8/XFKjhLE3HXmk2I8VIr9O3p3eLqN3aeQr\n", + "yLuFd1KkCNKeuC71Sz/g3Y5PF59RNCKrR5SLzyUiUpFKkiRJkiTpyA6lSPlO3JGF7tZCtL4azZJr\n", + "13O5n2jWOqoM3Z6nB+uT9W7wSBesjMhKIirMlS33K6D83Wroaj3WsiNkzK4hUjDHBfXl2Zr7YlRR\n", + "gePA2/6oIE8PSketystY5qozv6dtee49H9NQEhgTsNxLeZGGxX26vK0wdnOcKxY8b+S75P/v+Yza\n", + "7vbgufQY62sjc2v3I3Vq30FtfewcdrHguVBkeG7PuI5iSXvxfuLtMtqfFjg/qyrA/Xj+Lq8/FE0U\n", + "Kdo/98FzsPpUUvVdSatVaFORSpIkSZIk6cjEFKnHPOYxra0D1jdLmbN9FhlZl8w+o1lzKXIHqyRS\n", + "YvpWpLDeyBsFzN49u69bt5EShVUM1113naTGGuC8QHnyifWH9ejWZsm6wqri91Fm7Lb5mUZNV2tw\n", + "3HsJeuQQ9YIy1VaRKilZXa3wSbL//vtLatp0X3mjHHwv2BOMKMLaOqCvcZ+ModQpfRVFKqoL310A\n", + "haq2j3XNg+VqrPvr8TyRDxLquO93yX3zvDyPP3+011oEYynXcd+lkk9a23dcW4ZdBXAliHeB+8ui\n", + "XPq71f+m3/Dc/H+k8ESR5rQTjo/KEV842j3tgPaDYkU9lvZcRCGjfzA3yMzmSZIkSZIkI2JiitQT\n", + "nvCE6tk6s1msDGarkdXoeWz4m+Pd14rZq1uFUQ4QjyQgO7KDtYVCw2zYrT4UJaybyIrkd66g8XvP\n", + "SM56N8dzfna6v+222wbOgxXr5er1RPlRXu67RD3Vri9Tnig7XXOvjJuufgldfb2wkmjPHkkT4ZE1\n", + "tKNSrpiIknoybDbpSUCZooaOKp8Sajp9saSuO1jYjCXUIf6RfPL/RN66KnzEEUdIavJnLVq0SFJ9\n", + "3XVVVVH+GGNckSpFw1FulANjB+ejPFGLfSwddpcElA9yHJb6kKv5fdPXrg/4QBFFyphPe6iNPqQ8\n", + "UMpKY3m0WkE7oZxRhPxdhJIE1LcrUhCp6dwn9XXYYYdJahSq0vOnIpUkSZIkSdKRiSlSixYtmhVJ\n", + "4bNT1ms9ssWVFMetPHKksHcf18EHilkn/899MatlFsvsl73uWHfFmnP4Hb5dKAG+Ls26e61vyebN\n", + "myVJq1evHjgvz+2RPUA5R0qUz8r9Ph2PcPD1ehQp991yqA9+39ZK39Fou/8UoJZgZaFI0R6xyl1R\n", + "dKsVP5Ha/cIeyqBc0FYZY4bN3h/hY0vbTNuoydQdfYe+y98oRlHUHn0Mix9VO1Kfu7ZZhzGOscWv\n", + "V4oAZmxjLPZcedRfrbJWG7lKtJfvRVhSKtz/tC08z6j9Q2kvX/rSlyQ1Y0pb/0naJ+2Kd0O0J6SX\n", + "H+1w7733Hvgef92vfe1rA99T/9QjYyTtivPx/1F9+7sHJZdyj1adIBWpJEmSJEmSjkxMkbr11ltD\n", + "hQKYHTI7ZZZb+p3DbBsrkM8777xTUmPNue8RPkaei+Smm24aOC5ap2YWzmdkfZZybThuxTFbv+GG\n", + "G+Y8Hp8cv08iX/APwcot+d6wnl67bl6KLHFlpGsG73HjebawWrBm+o7OQ4lCHWCvSBRR9mx0/D66\n", + "+kaVQE2YdJ6sGmjzixcvltSMKW3HllrooytXrpTUlFXbvs9+mCg6rqTVPgeZnVEnURK++c1vSpJO\n", + "OukkSf0pUcD5wcea0ljB2Icq77swtM3MXutjxHG+z2mJUrRXiUlHKjO2+apM1C5YXUG5492K/y6K\n", + "FO9Qry98o+iX9BNWNVg1ApRj6p/+xJjHahD1UFLYmGNwX8w9WP2JSEUqSZIkSZKkIxNTpB796EdP\n", + "zzqxDj1rLJZtZOFi5TFrZrbqs9xIGcCaQVnA2mA2jeKCMgW+55v/f4RbF8x2mW3ffffdkprZM74u\n", + "Pvv3SBDKDysUPwSsVJ4PxQTrivVkZvPM1vEbAY9Oa7t/1KStqlHhme09K3bfihTWEkoi9Ut24lpG\n", + "lSGe5x33XnsepVsDlivqp+9XWYv7/9F3iJ6jjxEFdPTRR0tqogI5HssZyz3Kg8ReaH0x7D6Ok4Ix\n", + "xRWEtqC8AYoXYyFjH32M67q/IsdRn/x/lBNvXBx00EEDf6MooRzR7smVSB/mnQDsyUi75t3EOwtQ\n", + "OlmFoV48/xblwv9zPsaOb3zjG5KaTPuUs/vt4u9Lf+G6jM08D3sG8i7lXc/vUM54PuqxVpFNRSpJ\n", + "kiRJkqQjCx7oKxFFm4suWKCpqalxXzZJkiRJkqQ1U1NToU9dKlJJkiRJkiQdmZiP1NTU1LSPEOvz\n", + "fUWI4DP1pje9afpa44DrXHjhhZKkZz3rWZKa/bRYh73lllskNREH+Efw6RnD8YVhPZkorWc/+9kD\n", + "1x0V+OT84R/+4ViuB1xn1NejfN/61rdKkj70oQ9Javxe2Nswyl9GxBP+LKUcNvjAvfGNb5QknXfe\n", + "eZKa+iYaj37hkUz4upEf7frrr5c0O5cOvn74GVCOX/7ylyU1kU/4heCfcPLJJ0tqfL8uueSSgeuv\n", + "WLFi4Hqe5Rn/o7e85S0D1x01U1NT+rM/+zNJs/PV4DNBH3NfC8+U7Xu24QtFH3zNa14zfc3twVi0\n", + "7777Spod8VuL9wWex6OUqDPqnroBxqCSPxvXOf/88yWVo51e/OIXS2rKhbF33bp1kqSlS5dKasYu\n", + "ovU2btw4cL33vOc9A/eHHyxj0KZNmwbuGx8nfFquuOIKSU2f4Xf0ScprXGMLcJ1zzz1XknTwwQdL\n", + "aiKW8bPleX0fWNqR+wDx//g48U4988wzJUmf+cxnJDXl6btj0A/wDcKXiOhKjnd/ZKI9Kfezzjpr\n", + "4DlHhb+L1qxZI6kc/Ypv2DHHHCOpGRPxqybfF2O+n6/0XKlIJUmSJEmSdGRiipQ0uuzBo95xuwTr\n", + "qEQqYAXzNxERWLtYz1hZRDAwi8Z6wSomE/u42FEyjXfdkd6tcqxZzlPKpO+RKxEoV57jh+/Ja8b5\n", + "PHoSaAdYjx4Vyd9YXQ5WXZRJn+clgozjUdKIkqOcaMddM6WjxGHtRvtv1eDKCedGVaRvuiJFXXuW\n", + "ffouilXXnG/Lly+X1ChCW7Zs2e59l4gyjhMViIX9yU9+UlJTDscff7ykRtlAMQIULaiNYkSF/63f\n", + "+q2B++M+yJ8F0Zji6ijP59/DZZddtt37qt2PclzQ/lAmfayK+qxTG2XJ+Up903MeOihQzrjftd5u\n", + "avsjYxTReq7UojR3dRlPRSpJkiRJkqQjE1WkJg0WcN+zaqwgFAasW6xdzywd+YZxHLNlFAQUgmQQ\n", + "1IPa7NTUv+9JiJ9M3+2C+vS8XL5DOfdF7pabb7554HcoQ5FViupBeXg25pISjCKGNUv747pYc1xn\n", + "2D37sAKXLFkiafZ+a/iP1ORrcwsfhYW8NVHm7KgPoqygDrdVpIA6fOYznymp8W/DX7Kt7xQ+MQ75\n", + "qVC48JejHLDoOc5xxaft8+LvhyqKIoWPGG0xyn0WKQKU/7B0zbp/wgknSGr6Kn0o2k2iROR36eov\n", + "75LaXHxeX9wvv5/0ag2+X+Rw9EzlJXw1huer3ac2Wl1AMWZV49JLL211X6lIJUmSJEmSdORhqUhh\n", + "nWFRM1tHCcAirs1Y7mBNoAhgJbTNvsvs26P58F1pC741WN9t/TLmO/gUoUgRaYKV7cpJZJ2VFC38\n", + "RrBeaveu83V54Dz4HmGt8TftAKseqxp1xfdKdJ8jh8gefk85YP1SXq7u0G6wKqPy65JpXGp8A489\n", + "9lhJzXNccMEFnc4nNX0bNa9t5nLfvSDyFSlBhCRqH306Upa6guKEysrz00Zpg94XGLMY+7rCc7Jr\n", + "BX58KC133XWXpLIK7/Tlp9k1Mhx1lrbtmbrbEo0FjO20D95VvkchuK+c91miJPtSpKJ9W2vhndNW\n", + "iQJX4WuVqBKMsR4tWtvfU5FKkiRJkiTpyMNSkcLK9AgF33enK1hfKAtcD6uv1h8ChQXrEuujqzXk\n", + "SgvKQkmZIm/RfIfn47nIGYL1E/nyYP2BW3VY6Vh91ANWi+dyaas80g6xtsjpQjtBOcIfgPaJnw1K\n", + "Dr+nHUdqB9Yk1ik5h7gP2ivtDzUHPxW+d6sU6zmKNixBNCsK1MKFCyUN74MlNWXTtm/3pYRQp7Q1\n", + "FALaWq2/Jn3RFQY+UUzc74/cZPQNh7L233kbqIU2yJjHeWkzqKu1yoSrzeOGPn7jjTdKanzPuhKV\n", + "J32I85f2rXSFzX0AUVLdT7IrE9gIZYBa9b8trhC2bWepSCVJkiRJknTkYalIRaDM+M7XXcFq9Mgh\n", + "8gaV8g9hbfB7Plm3xcoc9v5KDKvQ4ZOD9R35BwyLW3lY3/vvv7+kRl1w66ykIGHlocj4DvGeeb4t\n", + "bkXiq+TWJtelfaKURVF4UT6mrVu3DvyO+/byQyXhe6xB/DWIyIJI6W0LChtZr2l/XSPmpNiHZFxQ\n", + "JvRhlBrKrKQ8AH6OqI2RH5srafiAoOzw/x5RHEWwtlWkvI2innJ9z1cVwX2j8jOWMAbyGbUNroeK\n", + "zBjcFsqJvs75UGjalg/KpKut/E09lpQkxiT6preHUY21k4J+0zdEzxJV25ZUpJIkSZIkSToyLxSp\n", + "Wl+dUUEkAtbKsBY166vkSsFa4Py1kUP4dZCPCt8orNdhFana9e5h6wXlI/LP6BsihihvrMVo3bvW\n", + "mvT1eX6HLxxqQdv1dbemsb59HzVUAz5rowu9nl2JjJ4/iljBOqd8PZdL3/3Yo1+7QFm44jJuKKOu\n", + "2dtR53gOouJQKyO/OPZjPOSQQyTNVjBQx12xaau0OPj54U9IbjSUJc/rw3GMde4nisJS67tGX6Jv\n", + "ds1HhYLmYwCKWVdFCuWJ5+W5ajOX43uHkuVRl7XtHYUNdZr74bPWTxEVm99Fedsi8J3jnedj16gU\n", + "KcqdcYLr1N5/KlJJkiRJkiQdmReK1KTzGTELrfVTKIHVgq+HZ8quzeWBcnDPPfdIaqwYz9Pj6+S1\n", + "1EYK9RW51Fc9R0oL1iy+O1g1WIu19Yv16cdzXT6xljkuUojwD0Hh8dwnqAzcJ39j7eIzVasg0h6w\n", + "Vr3+iPzC1wm/D4/Qiny+aNf4b4xK5UFFQFUYJvIIy3LSYw3X76quUSe0Qeq65MfoajbqMIoI5/GI\n", + "4L6itGhrjDnu9wkoYjwPn9xXW7UXxY3ydlU82rPQIfqNPsUY3LYe6StEylIflINn9S+1V+6f+3K1\n", + "udYXjec//PDDJTX1Xtpn1KF9Rv63UXnjm4TC6pHI4NGSffhPSs19U96MhalIJUmSJEmSjJh5oUhN\n", + "Gmbtw85qwTNfM7vn/FgztRY2Pj/4Ffh+Q8zSS4qU5ybBOigpUrVWzbiIrGRXArGKsP4OOuggSbPz\n", + "eB1wwAEDf0fKFdflk3qO6pHrUe8oLFGuHpQqngPfI35fa41H1n6ERyLV+nuQ7Rk1g/LwvQPbQr+h\n", + "/GqjS7cHPklds673BYpMVx8p2h5tlLoqjV38jr7hvkL0AfffRCHi97TNtnWCWkxb27Bhw8BzOPio\n", + "8Ml9oShF5YdCgcJAH0BZ8HKi76FElMZQxkqUEtTiWnzfSlYZKF/GCJS022+/XVK8euDn83ptqxa7\n", + "Gt+2nXI/0RhN+VNPRFSz1x3tM/IjHtZ/uQTP3Va5TkUqSZIkSZKkI6lIqbGu+vIHwPrCimCWjTUV\n", + "7YEWwfFYKT5bxxopWQ/8jnVorB+UkMjKnFTuHcCKLVnBlPOqVaskNdaYR6I4ns8La8kzmkfK3ZIl\n", + "SyQ1WY/JE8Z5SpnssYKpZ4/yxJquVaR8v6j77rtv4P/dqsO/AmrbE9YbVjXW8LDKLvXN8w67r9lM\n", + "+vKD7EpXJQpoI7Qt+jBlHuXLct8V9z1h7HNLfNgoQ9hvv/0kSStXrpQUZzSn7dN3faxDXY5y/VEO\n", + "HEfbxMfJy8VV4BKcv60S5fBcqMD0Se4HP08inqOxh75Kn3EforZ7C+LH2TU6rtS/KH/aI8/HWEd0\n", + "YBQx7Ipb3/3Zd3eoJRWpJEmSJEmSjjysFClmvVhlzDo9Y3UJrCUUC8/dgbVItBTWF74jbZUvrC9y\n", + "weAj9Qd/8AeSmiis0k7VWJt8ch8lpacPH5U2+Lp+2+tv27ZNkrRs2TJJTbmsXbt2zuPdavP8TR51\n", + "CSg9KD+0L5THm2++uep+8UugXqlPlCKsZXySgOPdRwtrnP3TPPKE+8Tq5Pk8E38pGpTzo5L0ZR1S\n", + "zihSfUYFTjpqz0GRwB/Mn93bJj4zWM4oF4w5KDCuXnquPB8rNm/ePOf9RX2vViUGng9fGHyyPCrM\n", + "VVjuMxprI1B2UDwYi13RaKu00RY9CrIW+grlR3uk3umTe+21l6TGB46x32Gs477wOYLavFkcx2fX\n", + "XRpqYYykHRPVSXnyPJ7PqWsesBL0Q8Z8xrzanI+pSCVJkiRJknTkYaFI4UfgETOew6MWZuueDwju\n", + "uusuSbOtwq47l7v16AoE16sFK2dcmcbbQt6lrvB8lFvXKLLaveOw5sk0j6JUu7M9ihbWvVvdnisI\n", + "ax71wdsD2Z9pp+4jtWjRIknNc2ENY43x/1jdfL9p0yZJs/0wUMqw+oeNjMMKxVrH960PeCbP19MV\n", + "+hD3jBrIfoau3Lga7ZGO1DFjkrc9/ztSKhyu03Yf0UhxaasSc54vfelLkqRLL71U0my1k9xv0dha\n", + "C6qy++v59ag/+hL15yow/0+UH30Gn56TTjpJknTkkUcOPIcrXvyOvuSZ6PkbZQ7VFx8vV6Xpm3yi\n", + "UEFtBC67MzDWRPt39oXXi+8JSH8iUp298Px5+vLfZVzgXZpRe0mSJEmSJGPiYaFIMfv1CA3WRVGs\n", + "+MTKqJ3Nu/UUKU+eObovPFss1izWllvdWJPcJ8f7PklYz31GTdXQNVcISpBHwqAUkY+L9fhhOfjg\n", + "gyU15YsfCFGRKEGl6xE1SCQQOXbwk8BKJjqQqECsXfdlQtVwJQouuugiSbHVTzug33gmeay1yK8m\n", + "2u/Nwb8H5ZB26XsKOlF7r2HY6DOHuqEseRYUBZQv+j73Sp2j1FBmHiHa11iBOtnW98VzjJX2gON5\n", + "PZce+47y3KW25/+PvyD/H7VtIFM2am/Upo466ihJzdhAPdHWqReem/uiz9HXaQcoRn5/9FmI+ggK\n", + "C+2I5+Xd5IqU55fq6gPI7hnDKjz0acqR+2OMRD2nXUd7Ax522GGSZo+BtbtscB7ug3c67RL/UsZM\n", + "3h0of6lIJUmSJEmSjIkFD/SVPKnNRRcs0NTU1LgvmyRJkiRJ0pqpqakw4j4VqSRJkiRJko5MzEdq\n", + "LkXKM1GDZz2tFdG4Rlv1i3Vv1rVZNy1FvJSu1zb3iv+O9VzKh+v85V/+paQm0gHfFo6r9Vlx8EvA\n", + "18ifj/Vwz4Tt/gGsSxPRgm8N9c36NOvSrKefffbZkqT/9//+n6TZEUS0i67+AdwX/g5ve9vbBp5v\n", + "1ETtBX+I448/XpJ0xRVXSJodvVbK80T5Evnyspe9bM7r4UtHe6Gca3dWx+8HfxTu//TTT5/zeqX7\n", + "LuH9iHp8+9vfrs985jOSGp8P/o9IxI0bNw6ciz7OcbQ9fDdoy75v41lnnSWpyVpP3VBmtEmPxqNs\n", + "iZIiyuq6664buC/yAZFn6bWvfa2kuG2639iwcJ3zzz9f0ujyb+FD9cd//McD1x0VM9tKzfVo29Rj\n", + "yUcsgutccsklkppoS3/n0e5Wr14tSfr85z8vaXZfKfl7dn33deXhcr2IVKSSJEmSJEk6Mq+i9qKI\n", + "EizQUbtzYSl7xudhIxmwRokewyqqjR5D+cEq9H2envzkJ0tqlB3ut21+KTj88MMlNVbYlVdeOedx\n", + "UeQM1jRZmKm3devWzXl8qRyiXDbD5hfivia9/5qD0kZuleg5S4oO/amkpLragEKF1UuGdqxz8nzR\n", + "vlBDPON/RFclClzRnTku0PaJcOTZUZp4Ji9jnoHvyRvE3ygRnrMLRYm+QJmjOPE7VEGUKr8vz+nG\n", + "dUoKiJc5Y2XXyFenpER5rrG2tP0dkbG0Ic+MXqLtO4Sxoa/oSW+79ClX44F9Q1Gljz32WEnNagFj\n", + "Z7SakzxI34qtk4pUkiRJkiRJR+aVIhWBNcesG5+lvmbhKC/4eKD4oAQMm/0Y6xYfIpQpLHuy4EZw\n", + "X5GvE1YxygHHl/bei8AXzfNJlUARO+SQQyRJRx99tCTp7/7u7yTNzv6MH4v7WPWVrXZHwX3RaA9t\n", + "fduwusidgm9TW+UO65j+te+++0pq1BnO53s3QtudAvoEpefAAw+U1Cg0WKLkpeEeURpos/R18gXx\n", + "7ChGtFng2WmzKBiePwnlgDrhfKi3fE9ut9rs8L7LwrjLnvKhTXT1x6yFckLld2r9+qDWX498SJQ3\n", + "yibXc9+7CNoffqLRWHf55ZdLkl784hdLkl71qldJasb2q6++euD4USlRbcuzFi93z1XXN7X76HYl\n", + "FakkSZIkSZKO7BCKFPv+uLUTzcLZn6gWFCkUFKwrFAJ8QfBXqI26wzpkto3SxSwcpQpcmUCpIZtr\n", + "tP+R+/gMu4ceil9b65LfoaiceeaZkppoPay6z33uc5Ka56QeH25KFERZnqOdx1FZsOo4ju+ph65E\n", + "2brpF7QvsgOjYGK1to1K7RPu4YYbbpjz/3k2VFwUKBQj2iQKFj440TPhs8NxlA1tObKEV6xYIamJ\n", + "GiRqj9+jwhMVWMIVsXFBXx/W760WxlAURKetchL1MYc2DvjWtR2z3McOlddXD+hrF198sSTp2c9+\n", + "9sD1WH3g/jlPX8oU7bBvJQqOOeYYSY3ixfN69GpfUC6o9ly3axSmk4pUkiRJkiRJRyamSD31qU+d\n", + "nhViZbD+6ztB1yoj+HRwnlo4Hr8E9lDDmvzwhz8sKbZKo73o+N4VAhQm3zfII23wGYr27gOUCaL3\n", + "PCKpLVjpKHW1VhuwH9SWLVskSaeccoqkxsr+6Ec/Kqmx8qi3HQWiKEv7fdXiVi1KJO3RI4Zohyh8\n", + "1HttFCgqCvmeqCfqm/uhXXEdrDmUKP4fK5t6R/WZBJQdz0Lf878dxhjfaw0fKMqc8wAWO2MFf0fR\n", + "QZQN/oQoEYyF/A6lp6QwEB3IfdGXapUs8D3bahmXEgWUD5+0ffpK2yi+rgpe1yg+v17pPPQpfO2W\n", + "L18uqWmfvh9q27HaoX3yDtm6detQ54ugnRFtyt6IJUUK1b0trP54dG4qUkmSJEmSJBNmYorUox/9\n", + "6GkrDCuy62ya2ThWSVsrA2uTWf8tt9wiqbHusNDdauP/meU6zLa5P7dSa6MOsYqZjbsPFFYhn1Fu\n", + "mrbZid3qqYXr8twobyhr3Cc+ZFgL3Peo1uX7IvJp6gvqOVIHKFcy8LtKAp6xHFA+XbVwRZR6IdII\n", + "6x8rGiXK81QNm9+rLTP7H9FUjClAG4zqjr6K2kYbpI/yTK4+42uFokVdRH6KHPf1r3994N65LhtN\n", + "GQAAIABJREFUX8aayB8SqAvUdM6DSohfInVKm0JFdZV7R8s/xHNQr4wl+JlSXz52RasHXcEft5Sr\n", + "DfwdVzsm85woqkRL0k5557kvV1tovyg2o4qmW79+vaSmfx111FFVv+vqf0k5UT59rSZAKlJJkiRJ\n", + "kiQdmZgi9cMf/nBaocFq6pqN1yNkPNdLCWb7nr0YBYpPrD2sH2bT0bqtR+1hNWD1HnHEEZKaWbbn\n", + "EfJ9vlAI3Np1axbfKqwI7g/FrnY2Xjv757yUH4oTVgBWOz5bnkPHsyO39e8YN8PmFStBO/HyR4VY\n", + "tmyZpNmKn+PZtaE2vxjWPdchUz39IFJ+/b49Z0xXf5yImTmFeDYUF1c36ZPcOwoW/mL4a/oYQnSd\n", + "q8r8zTOibJXaCGMMipL7OJV+j7LGfdPn+Zs6oy74nmi3tWvXDpyv6z6V0FWxcOWwBGMZzws8H0oK\n", + "vjZ9RzQ7KHmct1SOkXpcgrGTMYBchIy9vDuG9TfFz5LrjHo3EcovirItQXnSH3h+2iefo9orElKR\n", + "SpIkSZIk6cjEFKm+vOVn0jWSIrLo3dqLzh9Z5ljH/v9YvVizWLFYy1hdvj7NZ2TxY+HjL4GVxH23\n", + "VVIinzXPduvn5bk3bNggqVEgiIgi6o0oPhQyrPTSXm0PdVzlANoR5Y0fSOSThD+OqyiuVEbKI6oO\n", + "fZX2hdJF/8BvwyOIgHZE++5bkZoZ9Ujb82fCUkXVpY2hSHHv+G44d99995zf8zvORx3VPhu/QwHw\n", + "6L+oz2Jh4/NBGfN76hZLnTpDDUfRKEX2Rm2EukRRY4xpOwa7slSC52Qs4fqUH8pMNCb3neGadlWr\n", + "eDA2d/U98ihP+lpfUXswatXd3yGo1b57QgkvP8ZMz+c26ujSVKSSJEmSJEk6skNkNh8XWMpY2kRF\n", + "RdYoRJEgWL/uk8LsmOhAlBl8UDgfVh/WYBRxxHVYb8ZKGnYWznndz4R1eZQOruN7r6EwHXDAAZKa\n", + "vQWxcrE6UASxjkdtDc03Ir8a2gHlS3nRbrC+KE8/T6QOYM2XrD73O8CfhfNHezF6e+H+scb55PzD\n", + "ttOZKoOrXygT9A3+pqzYtaBrpKH7I1InPGOUA46+haJC2aLWMvZceeWVc/7efT94Pu6H61MO3If7\n", + "bZbwMQj4m+t2jYZrq6B4Xi+i19yv0P0ugbY/LCiZbdsu9UM7od5ro+1opx5dGq2qdGXUe9P5GEE9\n", + "td0r0sc4b0/jyvSfilSSJEmSJElHHtaKFLNXPP9Zt8VqYZ2Vv5n9YgXhd+D7J0EpNwuzZaxHrBJm\n", + "57X7OGHVYIXhJzDs3nVRdmbPSuvWKIoFz0cWZ47HKiNvF59ds9bu6ETWPO3To94oV35H+yErcSm7\n", + "c9u9DWn/+KFg9d9xxx1zHu/WMWqNt4u+/BZm+qfQF6IIYPoY0Wv08ZIihU+RH4eyxCfPWjofYw5l\n", + "S13gj1aKvuI60XPSx/A5YeyiD9YqcJQnfZ62Q5vk76512TUqDIUNdZxypDxYXXCVty+1G7/OtlGA\n", + "1G/XvE+0M/wSu+5eMV8p7eJRgrFg3HtOpiKVJEmSJEnSkYeEIuUZwlk/BtZdsVpQknydGvDd8EgM\n", + "LH7PmxRZd6UM3fzedxJvqyRhDXo+rGGJrDeeCwUPq5frUx8eTYjCRXmhRGE9jNuKmBQejRdZpZ5d\n", + "G2gflCftutbaLuVr8+g6v49h/UxGmdOlNo8OmcNXrFghqezjE1n+XI8yq/V5oa9QlvQllI5h1VlU\n", + "Q+4DFZ2xrbatMNYxttIW6PM8f+1+qH1DvdFWWR2Inq+vDO5do+OivR5rQbFxH6bIJ2xHY9j7p13S\n", + "DxlrSzsFDEsqUkmSJEmSJB15SChSRLpgjRDxAsxKmc17Flisrv32209SozwxO8ZKROnh75JfAFYC\n", + "s2OsOawivi9l8va8UL6OzH250lDKE9QV/C/4jDKlU+5Yq1hx+Gu0zSEzLmr3QCxBZnB2NifajnZW\n", + "S+k+2lq5qCB8Uk/0H9rLokWLJDXWPtCOa7M5j5qZ6k2tGsveaChDkT9gCTKgo1ihTPGJ+k0d0lco\n", + "M+7D8920tcwjRYLrcJ9tfZlQPrxcKa9J+zX+y7/8i6TmufveSy+C52/bbjyCO4qIjXAlCv9TMu93\n", + "zZwe0ddYOC4oR8berj5xrmiVSEUqSZIkSZKkIxNTpBYvXjxr52rWN7/97W9LKs/22Xnb96lyHymf\n", + "xRMpghWDYtLXOj/+Dp7jhO95LleWsGKXLFky8DfH8Xwe6YISRUQOChYRHljdtXsZoujx+9rIElfg\n", + "UKDYv8kjhygfyoP7LPmW9Y371bATOUqPR1fSnrhfrHyUUb7n+VDeovrzqDz3+4isKtSAvfbaa+C6\n", + "Ub4xIK8X9YragNXpVi3KE6oL16GdoGChtvRtFTtLly6V1LSzYVSRrkoUuF+fq3PeN4E2UFJl6YOO\n", + "58ui7dF23H+TvjdzX8IaSjn0+la7a6HPUH6UA21j06ZNE7mvEowhQCQs9UJb5t20detWSbH/KO2L\n", + "MZN3Yl+0VaIY4xgbeBfTTvikvtjlg3cc7XflypWSGlWc791X0d9RjH2Up+9gwJge5eyjXzIW1/qD\n", + "piKVJEmSJEnSkQUPjHp757kuumCBpqamxn3ZJEmSJEmS1kxNTYV5z1KRSpIkSZIk6UjRR+rMM8/U\n", + "P/3TP+kpT3mKtmzZIunB9cwXvvCFuvvuu7Vw4UJ9+tOfnvZvOv/88/Xxj39cO+20k97//vfrpJNO\n", + "mvO873vf+6p9diLwE/A9ydgr74/+6I8kSe9+97sllf0hfAdtj3Dhe9ZdWcdm3fecc86RpFBt8x2v\n", + "gb32mO0SYRPBOvpb3/pWSdKf//mfS2r8JFgv5v494oZ1a9a/Pf8T6/asD7Ou/IY3vEFSE91FxBHl\n", + "QbTjDTfcIKlZlz7hhBMkNRErrIdTbuT4oFx4vuXLl0uSLrvsMkmN7xz/j78BfiDUj+fK8R3XIx+e\n", + "l73sZZLi+nOe9axnSZI2bNggqWlf+DaV9qviOnzi68TvKC/qwZ8PKHfaL346lDO/e/vb397q+YbF\n", + "n6821w1Rjvj1UO+0z6hcp6am9JGPfETS7D3niG6iTeAPSdulb/I7vqcMOZ4+9qpXvUqS9K53vUtS\n", + "4w8H9BmP0uI4+hhtn+vRNukb3M9LXvISSdLGjRslzc5eT1skApi+xBhIm/zSl74kqdnXk0/2/KPs\n", + "DzroIEnjbyuf+MQnJDVjDL5BPA8+MUSpUW4c79GPtCH6DGMs1/urv/qrgd/TVygPz9IfjeH4bPF7\n", + "39ORsfO9732vpKYtM2ZQ3/gW0X5cAfE+xPVoTzznm9/8ZklN3+F8jCX0i3Xr1kmStm3bJkk6/fTT\n", + "JTVj9zXXXDPwfLw7eN/zrqE+Su0Ff0ui6jzimP6Bb14UZcp1PvrRjw48J3B/XffQBJ7r5S9/+XaP\n", + "KypSL3/5y3XppZcOfLdmzRqtWrVKW7du1QknnKA1a9ZIejC8+1Of+pRuueUWXXrppTrrrLN2mLDJ\n", + "JEmSJEmSthQVqWc/+9nTygNcdNFFuuqqqyRJZ5xxho477jitWbNGX/ziF/XiF79Yu+yyixYuXKjF\n", + "ixdr/fr101FQMxlWjZJme9iDR8PVRuaULGWu5ztOO575HMii7LlnsEJr8wGRmwZQJLCisG6i/D5Y\n", + "JW4tYyU4HhXFHmtE4zFZxlrHyiFvEgrhV7/6VUlNfa1evVpSY32sX79eUmP1oEhhTROl5ZFHHlnk\n", + "GehpD9Sf5xnzcuJ+S/s+YdWde+65khrrjHq84IILJM2ObMLKAZ6PcvG+gbXpeccoByKVUFuI9IEJ\n", + "uEEOcPjhh0uSli1bJql5HvrHtddeK6lpvyeffLKkphwYf6hPrGM+yZAvzY7q4Rx8T1mgCGC5YtnT\n", + "FlAioig8QB1DCaCuvW8BfSfapxAlgDHLxyTuk+dA8eA5rrvuuoH/p4xpmyg+tF3KkOv1tRddV1xJ\n", + "cniOzZs3S2r2TEQB8gzWjF20Ha8XH6MpN1eiIIoojpQTL89SBDRRbBHeHrjfKOL8C1/4gqQ4f5UL\n", + "HbQPjySOcMWtBP3J+xX1QzuO+ocTvTOHVaKgFLUKnXyk7r///umX3e677z4ti953330DL/k999zz\n", + "IbepYpIkSZIkCQydR2rBggXb3Xeo655E8xGsuJLCRe4LrB33uWLWjRUbZTb3fa6whl2R4by+Ph9Z\n", + "E6yz+6z94IMPltRY78zG3XrguZhAR1mOeb4PfvCDA89x5JFHSmr8Vlz58fviPrgeCp5n3AbycGE9\n", + "YuVhhfF8WF0oUBDVr9c/9YHfBkoffixRjh23KlE1or0WsWpRsvbff39JTT1zPM/Vt6rgqof7I5Tg\n", + "+bg/1AasSZRNzks7Qbml/aHWeJ60mvuJVDnf9SBSIoD8N4DPB/dMGXnfp81GShWgWHC/7g/n+yBS\n", + "Fnzvz/nOd75TUlPm3Cdlh1rI73meURP5y5VyoDmo3lGeJfpgpCTRZ9uukNBuKK9ozNhjjz22ex7a\n", + "Bc9d8iOMVjsiaB/e7o4++mhJzdh45513Dvx/bQZ8H+NKux0gwPAcz3nOcyQ1+a+4D/KAle6D1YWS\n", + "X/Go6aRI7b777tOD4He+853ppZQ99thj4IG+/e1vFxtSkiRJkiTJfGXt2rXb/f9OitSpp56qCy64\n", + "QG9605t0wQUX6LTTTpv+/nd+53f0+te/Xvfee6+2bdumI444Ys5z7LrrrvN2r7UIIlnwQ4jAF4rZ\n", + "NBazKxhEKGAtMItnVo8FjkXP+r9n4sYKxYeGvyPrkuvg08SnZ92NAgUOPPBASY3CgFUSWXV+Hnxk\n", + "sKrdqnFly/0m+OS+nauvvnrO77H+XAFyRSqyprB6OR4r9OKLL5bUqA+oG1j5bi1H1iT158oU/g+U\n", + "G+d9xjOeIakpHxS7UdFGAZoJ5Y6yRfn+f/bONNjSqjr/TxuoMomp5JsDNDZDMzQNDXTL1HQAS3CI\n", + "ElJqJ1QZFRA1DtGIGqqN1CUQ0USMJkaNCXEWtYwIUZFJmrEZuoGmoRtBqxONmsFPKRItE/X/wf/v\n", + "vvc8967ee7/vOfdcdP2+3Lr3nvMOe6+9372ed621PQ4G1QBvlM9hD9w3/cdxF9pfzWOJStRW048q\n", + "mdMm9KF/Do+buD9sgFgfQJmIbBCPnbkAJxZVz4nGJNfDddAXHK91P8jamBqgndwGandRgEiJcqI9\n", + "+EpKlCuK2GCk6juluFtX4KLPM+fUKlHge8XxNoN4WI7H24Eo5ohnA9fnWZSAwuf2S3/7rhC7d++W\n", + "NF9RqlUKF0uJOvXUU2fjwheiuJA666yzdPPNN+v73/++li9frj/90z/VBRdcoI0bN+ryyy+fLX8g\n", + "/WzriY0bN2rVqlXaa6+99IEPfODn6tVekiRJkiTJXIoLqSuuuGLBv99www0L/n3Tpk2z9Y32xGKq\n", + "USXvtLa+DatqlAB/rwzUeMHbQLlASWK1zU/iKmgTvAS8A7w8lBv3+vAOfA/ByMvm+Oy5xvnxErwG\n", + "j3tdeGe0R2tf4j2Tpeft7vuSkZXG9dFu/rkIrpcYI2KuuC9XwDxuAWh/FCd+4lXhzRN/wHFdFvY6\n", + "SChzfJ/zewbSQw89JKmzI7z3STsrxFwRj9IK9+exgtF1uzcbKZ5k+c09DiqsZ6PRZtgMYx6bKmXi\n", + "1hKNha1bt4787pmjEClRwJyD7XlMVS0oK9y314RrxetwlcreRO3N+VuVKQelhOvouycgc03f62lV\n", + "kCJKGcQRft3YF3Mw+2MyRplrmXvoT8YRShZjmFgn8GcT446fzKk8W/id8/MWhvtl7qlVHqdFVjZP\n", + "kiRJkiTpyeCsvccDeBWuMPDemdgTqvxG4EXxPpnYFVc0qGvjMSsoEXye1T7HweNmdY4ywWqcz/t7\n", + "b1b7eJl46FEFaP6Pd4H3xt+5DpQiV6Tw4mlPzkPcRSnzCcUOJYz2JObKlTTun+tEiXDvme95PSZX\n", + "vPCiomxD2r82g4h+watfv369pC57kDpJeIOebUj7oUBG3pfX/qFfsGPahZi7SFnrC6oHWYPRePEY\n", + "Pkqi0H/ENdTG0wDKH7FxjGuU0YWuFWgz2gLbo02xFc/K875oveaIUvZehMf6YNutmZrYJHWYfAy0\n", + "wtwxtADzuAo4Y4PMCSWlL/o+9hBVLi9V0Ob/kya6DrezqO6UZ4FGcxBzHePAnzGuyNKfbp/MvV6D\n", + "kOOiiC11JQpSkUqSJEmSJOnJL4QixSrcY6Hca4nA48crKVUO5+/RXoAeK+JeA6t33zvN95ECVu2s\n", + "7vESIkWKz+Ft4Y26h8//vdquf4/rbPVquU/iRYhv8XgGlD0UG+8/MqZKsVp4QSiQfM+Lxroq0QqK\n", + "JHW5jj76aEldfSnO75SUo1J9K68vVtrrry/YicecgatBXB92Qr+1xnZxPyjDKJJzlcloTLpN4YGj\n", + "lnHN2GTUF6U4ygjUQcYex8HmaxWlqM2irLSIaD/Gvvc3rhiz2nag3aiWjwrOHFFbFyqqe+RKCv3H\n", + "HIcNo6azVx3twBzimcWe3RhVGAfGDooTn/M5mbFfO6YiNZ63BbVKkI/11lg0YriYG2trNbbCfrbM\n", + "FYx/7tOzZ1tJRSpJkiRJkqQnvxCKFKtbV6RYjbKqjqrGkk3F6t3f37o3ESk1eCEoJ6VVv3s34F4A\n", + "98PnS3EceEF4ccSscB+0F+3hXosrVh7DVfKygO/h7RHj4+3CdXI8FDzaoTZrkLgA90I9lg2vxe8v\n", + "2vnd2bFjh6T52X1R1mVfsC9vf5hUfEFpP6xIkcJbxp76xo9wHI67UIxUCTx6VC76pKSI9I3hQeHy\n", + "/REBj7xEZDt9+5o5gzE/rj3KSnhdIqjNPmRuQlEkXq9VUSvFTvnecNgsaixznStyUX8w9zAG+N0V\n", + "NN6CoP4yF9FurkhF2Zt8368PO+b83EdJCfL2GrqPp98HBbx55o6rNh5zOgoh8cF9YxWdVKSSJEmS\n", + "JEl68guhSLFqdm8Ob5TVKp6t75OFF4IC4IqVe0F4G3if/OT7nLdUYwSvgVU63rIrRHgVXEcpXgLv\n", + "mPf6/M4egZ61Fr33doWB66M+VbSHIBArRIwUv7uX41mA0T5kJfh8aUdv4hhcCSwpUp7xQhafQ+2W\n", + "oeCN43WW2nso9BP2WxuHwvVhn7Rv35pFqAHYS+0O7QvBvbRmdUHk8Ud4zbfW2KYI9+xrwcbpC5SA\n", + "STNUnWUM0W994wH9LQVzLf3pKi8xUdheSdF45JFHRn5H+eG8PHNQArELzsOzhzme38lgZU6j/1wJ\n", + "Y07ifnzO9gzmVsaVZQm1Owy0wtxN5jBvQcZVzzIVqSRJkiRJkp78QihSrL6jzAy8So8PwDtAEcGT\n", + "rvVevZoy3gReGNlieBFRpXBih7hOx2O+gPuOFCX+zmodL4jr2LZt24Lf4/94O+zozXXWxqyQzUa7\n", + "eNYZuNfD7329l1IcTOSNluJH8FLpB88GBK8D1he82r7KTiuoHq0xSa56UL0Y+1m+fLmk+n2ziC9i\n", + "hwH3+mtAXUPdQs0r2QaxFf47tlgbq8Tno76L9q5zBczPx1isjS2hDVEm2AswojZOsMS44veGVg73\n", + "LDeUGf7O/bqayu8lJTDaxYDj+lyK/fGMQUHxOEN/CxLV7vM5jGcax0Hp8l0Uaonm7L5g130r0Ue4\n", + "EjXu/UlTkUqSJEmSJOnJL4QiFSlIrErJ5or2M4qykyLwHvDaPDaK99p4ZaUsN7wuPHYyOsBr4JT2\n", + "MgOui+PhHfG9SDkhNoZ2RYlCWWh970wND2Jd8BrGDffJ/dE/1KIB38PN64Z5PS8UF47P51E98Pbp\n", + "X1c1+oIdlSrJjwviZ/rW2eL+GR+0A5k0JUUKNQb7Ik4Er3L//feftVnf+81tnT7xCtYOn2ducFUY\n", + "FdLnklLsD9fMPTjR90888URJXYyQZ2txH4zRyLP3uE+UFRQKzyqEScWwTAtvZ1edaQ9sFvpWlKf9\n", + "sCff5QJ45jDnEA/J9dbGNDEHeTwp9wV9Y8wi1b0vXssQ+8TO+86d7FHpMXG+B2ZfUpFKkiRJkiTp\n", + "yS+EIlWi787aJfBuWAXjLXuGj+9Ij9eCt0scA4qNe0GRd8P3I8WC62P178qd75kGN954o6SuMjg8\n", + "9NBDkuq9m6985SuSOu+a73ncge8hB9G+YxHez3hlvD8HvHG8P1QJ+onqyfQH3g73gfJyyimnSOqU\n", + "HPphXJlR46qBUoL2QTlqjafYuXPnyO+oJIyD2owz7OPee++V1PUD2ZHHH3/8rBJF9pXXRCNGhXNy\n", + "bZEa7Dbj8WFef6mkRGFLjDVXjEoxSFzPzTffvMfzlOB6b7rpppG/33nnnZKkmZmZQccfF6jCfesV\n", + "oWCglrdmttI/xNKh5NF/JWWIeEBwZSi6L+Zu7A27bc2SixQc3nL0rWQPbqc8g5greObRTthv9JaI\n", + "dua+Of7QWCzman66IjeUVKSSJEmSJEl6koqU6r0ejxFB+fGYHqrsAvEQUcxRVA8Jj533uFH1Zd4r\n", + "o1yxmsc78DgOlCbOy+fxdvgcq3YUIYjei7e+Z49iz1xpIpvQFZih3hRe0T333CNJ2rBhg6QuboVs\n", + "MOIjaGeUp5KSefXVV0vqvDPsAHXknHPOGXT9i4Xvh1XC+++qq66S1B5P4mCXKID8nAvnIFaJsYpt\n", + "Epfo1fxr8Rga1DA8ZxQLlAyPfYlshlgW1FBskyr5MHRPsFaYOxgDKH3E7NDezAmRjaDMrF69WlI3\n", + "5/qcwRxL/3m9n9ZsP1RkxpzPZSV4JjAXtGaIluL+ojkM9ZqffTJTpU5hjBh3JXtqCKJa177tIduU\n", + "ZxL3O3TOiOhbNy4iFakkSZIkSZKeLPvp0M1y+px02bIl8w4+SZIkSZJkT8zMzIRvrVKRSpIkSZIk\n", + "6cnUYqRmZmZm4wlY5RGLERFlb/H+3mOQ/uiP/kiSdMcdd0jq4iGICeJ9+8knnyypi3cgpuOoo46S\n", + "JK1du1bS/D3qyPxhj7o1a9bM3ttciEkic8T3BiMripgk4gNKcJ4///M/H/l7qY4T8QleVTnaL4xY\n", + "q02bNo2cd9Jwng9/+MOS6veowx5qa62Q2fKGN7xBkvTRj3505HzEaRDPULvHHNDexAEQZ/KCF7xA\n", + "Utyez3/+80fOe80114z8/7zzzpMkfeMb35A0PwMLsLtzzz13j+cbN5yn9Xz0Bz8XioWaC/Evr3/9\n", + "6+edy+vG9MVrvXGeyy67TFIXv+UxP7T59u3bJc2vW1OqRD733iTpoosuktRlcUV7wa1YsULS/BgZ\n", + "5hhispjz9ttvP0mdzf/Jn/zJyH1OGreVaK4fysaNGyV1sTxLfSxM+nzRbhq1EDd6/vnnS5Le//73\n", + "S+qyUxkPpVgx7JJnje/2gX0Se0g/LnZ7RqQilSRJkiRJ0pOpZu2h+OCxk/kRZShE3slJJ50kqas1\n", + "4YrPddddt8frIBPGs9HIaMBbRJFy5aukUODFRrvUl5S4EmTCkIngO4M7KIC1O9Z7bZxx7bdVC+2N\n", + "11LKuGjdydz7D/WCdhrqFbviWlvDhP7zzDIUTDKcvvSlL1Udp5WhNXwcz8iKeOYznympu+9IkULN\n", + "mWufvhcdthrZBKosHjC25UoWn/O2LI0h1MwoY5e6OZEi5XvJ0ReRgkBtLX463B9KFPTda80hy4/7\n", + "RbUv1bRzUCCi2nGuMKIYMrZQQvzzfSt4O6017JYqQ9vD7Z8sO7JlvUZctIsHdulzOwoUStVSbedU\n", + "pJIkSZIkSXoyVUVq8+bNkoZ7vihJrIZZBZ955plV349qk+DN+t5sKAt4k9OGVTr1ivDQqTTuRIoS\n", + "XiOxKSiD7j24NzZpuE6vg+XX5XaEGuAqAt4y/3cviIrt405oxfurrWGCIkpMFRA38OUvf1lSuTJ4\n", + "a60kwJ4YX0OVSFeiIpWC+mKR2nPggQdK6rzehx9+ePZ//p2SOokteZ+45xspSiWoUeZtxvFK+2GO\n", + "G85bqsDeCjFN9CUxWMwlrfcZKXSRIoGNu8KCjfC9vuqsc9xxx0nqKqWP67iLzbjnOGL3UM19biKe\n", + "uHb/WhRmj51aaqQilSRJkiRJ0pMlUdl86KqYVa/HE0TwHh3PPvKWiJ0h48A9arwRMkAi8IqGrqYj\n", + "JQZvl+t1LxzvEE8eZcErRPO9krfaGoM0lNosRuwIxSxSzri/qOou3s+4q99C7Xt+FBvug/7H3mv3\n", + "qKuNhXNQL4455hhJXbuUqiXXEtlZqYI6/bxQ/6Gi1WZ4Rtfgyg3Hbd2Xc9euXZI6xYaxR8byXXfd\n", + "1XS89evXS+qUF+Y8j7/Ek+f6iTUZtxLFfpLve9/7JEnbtm2TJG3ZskWS9Hd/93d7/H4UL9jXZh3m\n", + "XNq99f7JmiQLknbl7cfjVYmaFDyDmLN8zzwUSrL6SuOJtz88Q/neUiMVqSRJkiRJkp4sCUVqKLVK\n", + "FFBnCCWq9H28OWq08D1Wy1HWHt4W3i1KUmvmAUoA+1t5FhPxBFFMFN4AXhXvsaOMCt+Rnr8/Xuhb\n", + "7wnI0KIdxh1HQH+WwHvGq+Z7rTFK0f5iUQwZoHIQI0XWXYnaGLq+8UHYI+eZe3+HHHKIpG7M+Z53\n", + "3CtjAI+ZOcH39sIW2APPY3BKmaQoK+vWrRu5VuacKLsughgkbDsam64AcP/R3mUoNhHEvGCTqNLc\n", + "D0rB2WefLalTECJFymurOX1j0hyug35stTkyy5m7eTtB7bZkFOwxynTGbsnKhEiZYozTb0P3BuR4\n", + "PMujfWNbeXw9IZMkSZIkSZYQU1WkUEi8pklf8L7cmyEegdUsnjjeaklxwWvCq0GJwjtzD5zjkW2F\n", + "V8p1tdaN4r08WYKe5VSqc4QXcPfdd0taONtJijMj+mZ9RbRWm26tVD70+1zfpLahrN3RHFUBe+qb\n", + "NYf9O7XtgZ3Xxh1F/epZlX1VB8YhCi1ZlnPBllGcsHkUJVeWGGO0NWOAOYMx7DZRiqNjjuE4KFBR\n", + "TbkS3GupEjXX73WyIko2xZhwm/n85z8vqYsXxdOPan/52I/qV6EY0o+uktfC9zlva4wqnCKPAAAg\n", + "AElEQVQU9sBxWmPkftGgnRlvjHl/C8TYZ26K2hU7YfwNfTvC8calREEqUkmSJEmSJD2ZqiLFe/dx\n", + "7YeF91mqe0RMUVRT5aCDDpLUKVGsrskeQ+HBq2W17efDy0OB4DzEVdTG4BBPwX2V4hkieK9Pu3t7\n", + "Ez/S9/i1tPZzrXJCduIznvEMSV37o6TgNZeojWGiHbGPce8LhheGF9fXG+M6nXHHCZSIVAHUh9oq\n", + "y6grC1W/pi+wYfqSc/pYc4UqyoxFUapVEx12G6jNQI1o3RMNtX+oqlxSYlC3XeV2asc+Y7evEgXM\n", + "abVj2vG6WONW53/ecDWfdudZy9hlbqtVCLEHlOOlRipSSZIkSZIkPZmaIrXXXnv1VqKiHatZ5XoW\n", + "Ep9H2cHrROlg1czf8b7wPslI4XPUFiHrzeMkOA7n5Xe8XhQGfrqSESlUxFb1rUeFNxVlVdEP466f\n", + "NC7FsQR1svBaiL9oVRFK8SL0GxlLpdghjw1CgSmB8omd943PiKp0Y8fE7dT2DwpXa6yfx6qhzLbu\n", + "g8Z44brntgu2y7HoS2y/5AFHigP36v8vxa3x/9o+HzfjUlCGxim2EsXPcR0oVbVzIXbROneiSBFr\n", + "5grL0LpckQLqTKoi/bghTtnHoWdPMhcuFN84F7e7xa5hWEsqUkmSJEmSJD2ZmiL1xCc+sbe3FHl/\n", + "UT0cV4A4r8ccuSIFrIrJ9sOrwaP2Wih8nhgUz9zBy+F6a7PDWM0P3esuirPgOsa1nxFeOO0x7hgi\n", + "h0whzkO8BjFvZD2WMqZoZxROV+g8g6mkpHj/RnZPO3E+FM8jjzxSUmdn0T5kEdS+8fNjf61KYV9F\n", + "Cq+Uccb3W8/vNaHmzgcck7HGGB2qCHE8Hzul2l78va8a68rM0H1J+9J3f8W+RPWemEsZo6i2pXZh\n", + "LLeq06jN7DKAPfFzqEIUzQW+68ZSVWIcnzN5ljBH0o70U2kNwH27IrjUSEUqSZIkSZKkJ1NTpH7y\n", + "k5/09nJalSxWw6yCvaYMq2gUJAevkOtF8cAb8awoYqr4PF4sq2nf0RpQqvz+/D360Kq/VKgmg6g1\n", + "E6gW2nfSWYCA6nDsscdK6pRFr8ZcgvaNVASO11qVGiKvmJoqnkVHLBP2UqtI0e5kMQJ21Pf6a/f4\n", + "c7wmED+5P+ylNL5d8Z2rCKIcEQ9JG1Bzqi+Mmb5zVt+941zxWGwlqvW89AlqYd+5JYrTxDZQZ1Gk\n", + "aq+P7LtaOC42jxo9NJuwBO2G3fEMGNcehJOC/mEu5lnL/ZA5vnr1aknds7B0X8zFmbWXJEmSJEny\n", + "c8bUFKn/+Z//6V3dt5XSnmusdr3mCF4Hq2Wu171SrzTu2VwoCCgOrTEurPKpg9R3x3HfeR5va9L9\n", + "0HfPu1bwgvBaqDOEV1+rpBBTNKkMGeIEALXk5JNPliRt375dUuc9n3HGGZK6vRS3bt0qqYvZ8/pS\n", + "7DeH184OAk5fdaU1hg7F1uOUvMYTdo4X6+fxGlF8b248je/FRVuvXLlSUhfbEu1L6RBXt3btWknz\n", + "22zaCgGxNECb9FVMyLpysLXSXmfMLa37nzqMYd8rkb5G1eV8niUG2Bz/r90v0mHO5njjiiMtwflQ\n", + "whbL3ohJao0po9/Ym5K3AMxZ2CdzbG28L+O2NrN3sUlFKkmSJEmSpCdTrWy+WKtLVxbw4Fnl4qXg\n", + "OXvmAd4syg0KFErCmjVrRo6P8uH7SPWtA8QO5PDNb36z13GGxoksdfBurr32WkmdwuG1TRzsAMZd\n", + "R6vE8ccfL6lTFzwGbvPmzZKkq6++euTv3JcrinfddZekLlaPmL7TTz990HVGNZMYN1y3qxGoBq7c\n", + "evYgRN6+7393xx13SOrG1Zlnnjkbb4VysXz5ckmd+oWnXar/xOeZC6gQ7mOYuaSUlTcudZMMVK6f\n", + "NnWVm/tmTBAPF+2ZB5F6XFKiGEOPPvqopOE141atWiVJeuCBByR110s7ev0h1FeeKdjiYYcdJqkb\n", + "I6X7KLHYiojHeS4WfWPxfC5gjHucr88RzFVPe9rTJHUZ2K5EDt0ZYFKkIpUkSZIkSdKTqSpSDu9X\n", + "8T5qs/MOOOAASd2ql32tItwr4X2t19uBKLvp61//uqROwSA2hVgOKm3jBeIN33vvvXu8PuC+UMRY\n", + "nfv1177PZtXvewNyvNa6QIsFmUB4udwnXg/tSz/grePduDLlXrcrUChEKCC+1yGgpOAt0t9eCd9j\n", + "6/CS4ZFHHhk5HuoH8T2oLHj99Dd/d0WK+0QJ8n4lZmr//feX1CmcjDvul+9jH95O9AufY/y5okR/\n", + "ufJU8rJpR1QhV6QWYp999pHUjRWuGeWGsYmywzEZ43jUxKdhW9iUq4VkRKI+0zded4o+cSWIPvbM\n", + "Xz5HjBYwR5VUU+IzPYO4L7SXx+MRO8XcjSJFe3FfKAz8HVv2Oeukk06S1NVOo1+8krlnbx1++OGS\n", + "Olv3duc8bptkj3F/nI+f9AM2GLUj7Rxlhrfiyil2yHkmvT9m37pVvD1hrubtDGo7zzQUU5RUnnEO\n", + "z3Lac1LQzszxXq+sRCpSSZIkSZIkPVn20ykUJlm2bJlmZmYW+7RJkiRJkiTNzMzMhLFjqUglSZIk\n", + "SZL0ZGoxUpdccslsbRbep3pWnMN7Ys8IodYG7495L/2Hf/iHkqQPfvCDkrr33Lxv5b057/E9Bqc2\n", + "84Q4h9e+9rWSNE9t4/0r74lbs/eIaeI8vOc/77zzJEmXXXaZpMnXGOG+FktN9PPRjl492duT+BYy\n", + "ecjwwX6Im6A/sLdzzz135HyThvNcdNFFkjq79OrA9CvxKevWrZPUxYEQa8T/iaNxe5hW//3DP/yD\n", + "pPlZrEBcUynug/ps0Z6NMzMz1ffmWUQRPucQ97Zp06bZcy4GnOeSSy6RVI4vw8bPPPNMSdJ1110n\n", + "KW5jsuSIcXrb2942ct5JM+25Bah/RPwgNut1x4i/JGYqmtOJvXrJS14ycj7mMmJx3A7PPvtsSV0G\n", + "MjFv4HOh1wRsbc/f+Z3fkSRdeeWVVZ93ovNFNeGGwnk++tGPSuriSh1qCfrcQ4wd45rrjOKES+2Y\n", + "ilSSJEmSJElPpqZIPf3pT9cpp5wiqcvoYDWNUuD7NLFqZBWOF0C2HF7ENddcM/I9r7HCcfAuyTrC\n", + "gy8pUXizKFmlbDm8Fn565fQSZFBw33hDMFSJitq7L5PyQvAiqIdF9p17g3jr/N0VDNqR+mGt1Xsd\n", + "svzgzjvvbPo+mVlcD/aHwkpdKBQ4sgOxW7wxMspQI3bs2DHy+7SIlCiozUCKlKiFoE9Q51C9sE2U\n", + "JmwKW8WzZ4ySfcccdcQRR1RfwyTgupiDojnkla98paSu7UttvHPnzj3+n7kOJaR1d4ZaGAP0Exmk\n", + "2DBzlCsJ1BlyVdez/EqZyZzv4IMPHjmPwxxTmjPJanRKWZT0KzUKXZHi+4x9z6YEVPlSf3mF/HFR\n", + "+wzg/PysHetRBi/jm7meeYDx7c9M7Ia3AK3ZlqlIJUmSJEmS9GRqitQ3v/nN2febrAaj2CjAG8IL\n", + "YNWIp07NCV/tezwEq2R+UuuC40dwHDx/lIzWGhd4G14FFoUhqlzO333PsqGMS4mCSe1DRTvjtUTe\n", + "CP0U1f/CzvByh+5d+OxnP1tS56Xef//9kupr9+A1Yg98D++JWiZcJ5XOiZnDe0ORxavnd/eqUfSI\n", + "HUP56lt5vxbqV0XxDPSH731Jf9OvNQoife/KDW2Nh089JuLqaAN+YmPMNXP39ZsGjH1sD4WF66Pt\n", + "Pv3pT0uKa+PhqRN/WdotgfNEig7xrtu2bRv5O4pM7RjzytXcJ8dhbPB31Fn6G+WQfmIM1VY0ZyzQ\n", + "jswVtDt/Rw2P5jrO73XHarnpppskSRs2bJDUxW49/PDDkuaPpSjWr6REUc/r1ltvrbquKE55KDyD\n", + "Wp9F0eepU0VlfNrxlltuWfDz2BExgq2kIpUkSZIkSdKTqVY2Z7Vc+36W1afHBaBERTUeSpk5eHMo\n", + "QsQg4c2iWKEYuOdONlEtrOo5HjFe/M7/qXjtDI3pacX3+msFr8ezJVvBG0WBibxcr1LreGxc36q5\n", + "XM/ll18+ctxIicJLpSI54N3yf1cs8cZRUbBHfgKZV3wer9EzvPz3oVWva4mUKKC//D7IOGuBe0cx\n", + "4B6Za+h7xhjKFJ/je/RFa6VjBxtjbkF5aY3FIIYHW3GlBCIlCriOUgXrkgLB3PCa17xGkvThD39Y\n", + "0vy4vlpoJ+ZEFJhvfOMbkjqFh/vn+MzBKFLERHnMVKn/GBu0s9837QGRIsWzqK/aTb985StfkdRl\n", + "6qIkMof6mMKua6GdSnGM0KrITipeFnwtwJzBnMp4xt7JnnzBC14gSXrHO94hSdq+ffuCx6+NL01F\n", + "KkmSJEmSpCdTU6R+9Vd/dXbPMbwzFKcoYt9XnygPnsVVC94pq2y8Ft9pHK+klMFRix+P7Cq8rVIW\n", + "nu+zVYpxwWtlVU48CHEFeHsRxNz0BW+R9i0pUpHXiLdBe/M5vDTux/eei45PjJHHnPF3FEm8S2qS\n", + "kAGFvflO9BEoTFwv+Pex89YMEq6T68LL5H7AY8fGHSPXF8YjXvaQnd49pgRoG2yIjEnmHGIkiKVi\n", + "bPWN4QA88pJtlmAsMhZ87LJHHUoAc+NVV10lqVNDUU9930/fw66kSHEclKljjjlGUqdItYIaSf8x\n", + "Bn3PO1Ru+tH3e3QlyLMBI7A9H3Oe3Vn7rGnNqKZfyQ5lzuQ43Cf9unXr1pHv8/dauB/aM9rDkbmr\n", + "dT9W7CdSpIjRo94ZsWGepRjhGfCRAkh9LNqP+l5eH8yPV9vPqUglSZIkSZL0ZGqK1I9//OPZVR9K\n", + "DB6pv1fFK2TVzCqR1TurZRSX2ve9HB+PndU8sVvuPUar8dqMEIeMEFbHeB8lhcO9pVK2FZ+nXWlH\n", + "FD28La+gzfVE2W+1tO5U7ooV/Uv/cH2oA3hR9H/Jm0GR4vPYF+C1837d4yK8LlgtrgYAXhn27JX1\n", + "axUp7JWd1LGrvplD4wZ7o788phEVyJVgr/0Sec1zoc04FooGY5hj0vb8RC2kzfBwGeOlzOJJg7ob\n", + "XQdZSoxp7gubI/Yn8tzd1kpbsTLXovyVKkwz9qK6VcSqRDEr4FX/UeaiuEjUzZLKSbtxHPode2Cu\n", + "4D5K6nqrIkW/3HbbbSN/px+5bxQ7xxUUV5q8FmMplo775S1GqyJVmiMZl8RBtiq+/pYqqtHoClNU\n", + "qZx2rq3xCKlIJUmSJEmS9GRqruoPf/jDWQ+a1TKrbbwBvAOvJsz3WL3ynpP34LUxKyhSnB/FgOvg\n", + "OB4f4DVKSlmBEax6USK4nlJcQl+FAa/R40Ycr5IbKVKTqinioGTQL9w/akNtHTJwrxQvxP/vSl8p\n", + "jqCEZ5I43A8/8YZREUrgldNeKK2lzKxJg52UvFPqb+Fts/MBcTwtda44J33l8W54/qiXXJt79MRU\n", + "lDJBa+E68PBb1VrmHo6D7fM794sSEtXNYa458cQTJUl33HGHpPnxnth8FOPC3HDxxRdLiucWsp9q\n", + "a+CV9kJEOWvNeizBmPNYKlc26T8Undo5wZ8dtXBefvJs8jpdPtapjP71r39dUpcNybOnpEjxjCV2\n", + "jf4d95zfV+n1tymuJPE2g/YuzYV95/ZUpJIkSZIkSXoy1eAJ37Xeq/N6LIXHmOBNsppFSXAvhlWr\n", + "14gBPH5io1ilR6tuYjnwxoZWGmdvNtrBs9w8i3FSNTnAvdIormCxFCm8Q5Qj2oWYOpQKj/uI3pdT\n", + "dwwFx1WB1izMWrhOj5HC7vk/dur1oGqhvhTt1NfLGhettWe4fx/fULNXpdfkwnZcecLjLsWy4Nn2\n", + "Heuo5R7nx3lbK3/jWTMGmOPoe7cZFDXuH6WtVCentuab12bzuNFWJcar+S82kRJGu2M/pbHl6j73\n", + "T7t7DTnGvGfrOcxZnmXpqi92QP9wfFfcUIMd5kKfk1oz5CcFz+KonRj/vltERCpSSZIkSZIki8xU\n", + "FSlWf6x6vcI5q0m8G1afeD2e9ed7lflxSkoO+01FmQl4De6lucLQF2JaSvv+DI0LoJ1pl1YFBu/W\n", + "lYZSXENf8ILINEGh4zqirEnsxeMAUNK4f1f8vH4TdjN0nzXuwzNTOD52xe945a31pLg/jjdtRarV\n", + "vsj8ijLAajJqsAna0vuStsFWPe7Oz1WqJVcCBYC+95ibWqJYkmjOQgnzODva52tf+1rT+SMYiyef\n", + "fLKkLm6VeFbakbm7lPW2WNX2wWPPiA2Lssiwg8huIHo2+JhEKfFdDSKlBTv2uEFXmlyRovI7dk8d\n", + "tX322UdSrM6TVefX7RnNi00pyy+aM6NnlY9vVxQjUpFKkiRJkiTpydQUqSc84QnzqtMSA4V34HEA\n", + "eF146MQosTqPvIJaj5zvR7vU40W5l9CSTbQQnI9sJe4v8shbMz4c2pl2wzt1LxBvwyubc35v16GK\n", + "TYTXdMEuUO7wIlDw8EIir5b6SmSDek0blC+PA/D92lprntCObqd4PfS7ty9efK0ixXkYXyhhSx28\n", + "e7zqIcorYxIbj3ZLgJJy0Fe9BWzJFbJWhatVneS+S9lv0FdhIJuLMeoV15k7mbNLY6e1js9QGNMe\n", + "uxbh+2VGqrgrRNhZdP8+5rmeUm08Pu8KJzFmHAcFkM+hRB188MGS4ixSn+tb7XBS0C7cXym2DuWU\n", + "uaYUA1j7tikVqSRJkiRJkp5MTZH6yU9+Mm/1jPfkq1yUBjJvyHigNgbU1tuJqPWSSu/FW2G1715N\n", + "5JXVnjfKlMEr5mek3OAt+3viSOGbVPYeNVu4TpRJvA68R8/ui2Li8J557++V8Kl4jqpBjNUBBxww\n", + "ch63vwhqubAPmV8X3h1eJfaF1+sKWKm6MPePIoXX2ZeaLLlxgF3T/qgXfc6L7dMGjAHuhTbyscfn\n", + "qehMnB11e7ymXS30nSsDreBR1yoBrfGKfccwYzFSAu6+++5exx03UcyLx+fW7ndamou9/Uu2zOeZ\n", + "W7A/oEI8GebRswOYu1BqXGUng7m136etRAFzmz8TIog9i7IO/dleG6uXilSSJEmSJElPppq155Hz\n", + "vsoltgMvjNWmx+J4RfRIifBaMBwfhYtMkyg2iT3MUM7wWtxraIXMCWJ+WAVHcR21tWxQTtwLIkYI\n", + "L33Lli2SYu+1tfryuGH/MLwmvK8HH3xQ0nwvxKv9RqAyuPfp1XzXrVsnqVMzbr/99qbrP/LII0eu\n", + "y/sD5QuVgv/jbaKO1GZ43XXXXQv+PdpfqsSklShiuqiR5Aoh4x+7pb1oT7ztuRDzwdgm9ocxwXcY\n", + "Y8xFVH6m7/FM8VRb4+KcvkoULJX6PQ71sWp3lSiBYhjZPHOgK4uMZf6PGoxNRTEvZEPW7hpRe59e\n", + "56kW5mbfVYK/k+Ht1+HPRp6Fkd2UYq+WOvR3aVwdfvjhkrq5w+c05gfsg3FfG/ebilSSJEmSJElP\n", + "pqZI/dqv/drs+00yPFi9s3rGa/TK51F2me8WD3iny5cvHzkOx2V1j7dKDI1XI+Y9LO+nuT7PzIgU\n", + "Ea9c7soY3lfkJdA+tYpUpCTg5XC+cdd9Gjd4Byh//MRb8EyokhJFf5Kd55/HuyVuAiUT+yKOpgTX\n", + "h724+uFKpvcX/RTtdThuuF7f4Z7xRQ2a0vc93gSOOuqokf97XA3jEHUAJYpsVrxPxj/e49xMM/qU\n", + "+DLiKz1GCSWDscs9cw3YEmosNnjrrbdKkg477LAF7xHb4DwoYh53h0LCXIASwnm599Y6U9z3/vvv\n", + "L6lTbbFhzu/ni+D6OS5qMHMQP6Mxh02g8DG2mOMihc/7lv7ynz7G6CfiGek/4mfp5wieHfQf58dm\n", + "sUH+X4qR8v9zfs/09tgc2hW7oZ+YI6I5aGhG9+ONyO6wV+yecUTlf2BNwNzs9ljbnqlIJUmSJEmS\n", + "9GTZT6ewhF22bFnveI0kSZIkSZLFZGZmJlSoUpFKkiRJkiTpydRipGZmZmYrerMfU19xjPflvM/m\n", + "vSmqV0n9IhuIjJ0vf/nLI//nvTbvr6P3srXni2itT8V5LrnkkpHvEdvFe33PQly9erWkLkvR253v\n", + "e1Xk2vsj+5D4BI9pIy6ltPfh0PYs7ecVne/jH/+4pO69umcCec0W2o94jVJNFtr3Na95zch5I8jq\n", + "5Octt9yy5xsJ4DyXXXaZpPnZiuPaK5FYvvPPP3/kvEPrr3ksJHDdF1544diUbu4haqMLL7xQUn/b\n", + "bKU0FogNGxpPxxx41llnSZLuu+8+Sd1cQAYqY4NdAbBN4tmoX0T9KOZQ4hOJXWHupobaO97xDknd\n", + "3BXVR3K8Zl5UQw+i9iRGjhgzYtWiMeexYsQ++RzHed7znvdI6uxqUi+EON/FF18sqb5OVLTnXu35\n", + "+Mkch50w5rFTnvkRxOYRs8Rczrh8+ctfLkl697vfLWl+zB/PIM5fOh9gl16rrzTOU5FKkiRJkiTp\n", + "yVTrSEX1mlppzWxxqO6KJ+51bYbupVeCyt2sgls9dv88WU+Rt0MmTwQZLq3KhGeyRFVhyZTgfr0i\n", + "vVcfLtWUiZQUMltaa/dw3fQ/7Ti0hhCUMoccvLNICSUjCq+zVHE96tdxZW9GVaGH7gTA/aFM0e8l\n", + "ZVPqlIXaSsVk/fi9LNUMV8bIUMgSgxtvvFFSN4aiGmpbt24ddF48/qjyeImhyg5jjExaFKUoAxWw\n", + "Pd/3Exv1rMhSRvG4cSWqtEvBuGoGMnei1PkegiWFyOte+fchmtt9/9RaeCbx7Kjdp3eqC6mlAsZG\n", + "eneUWtp3s1q+x2THQodBizHUHrdU5G3opMLCjkFVO7nxkKmVUXlI+Ssbf1iVHn7RRpV9twxCfmbB\n", + "FxW4rH1F6XIx/V8Lrzcix4MFyiOPPFJ1vKW6GKiFyZRJbm77++tDFgYspBjj9C02Q9+cdtppkuaP\n", + "dUqU9HX+eGXG+Us2w6spCgmWwEbYQsSLmpZgDNFOQPhFyflqxcsXAGO9dsEb4WUtSq88eXD7NlOe\n", + "Lu9gZzjjPDuYQ6IxOa7X6CW4f+y3daHkokIrLCRZwNHfkXMclYeAoXZRS+0CCvLVXpIkSZIkSU+W\n", + "pCKFB79hwwZJnRdH4c7SlhUucyPTo3jgdUVeCqtnX5XinSJX1m7cyPf4PAGNz3nOcyR1XglbtXCf\n", + "EbXbDkTBuSV82wEvONoXvI1SYUendP1DN0t2xS3amsepeaUkzbejVqWspILUbmMArfYbEdlXVDDW\n", + "t8jp613SfgsppX4tUZFbivQyN1DQkSDjG264QVJnC751BNAGjOloTkEhqrWZtWvXSqp/FYSiFm2B\n", + "UgJV/JprrpEkHXfccZLGtzG70zccA1tHlYy2PiltFwauDHF8fn7zm98c+d3Vfi8iO7c4rBS332Kp\n", + "wiiyjL3WLWFalShXnPzVG8kGJC3Qf7fddpukchjNUtks2UlFKkmSJEmSpCdTVaRYJXsqKKtavDs+\n", + "F3nenoLqihReCcpQKVU4CpaFvqti7g+vhe0ruK8odobPR5s7Oyg/eKdDU6L7ek/cF4Gc7m20lieI\n", + "GJps4PfXGl8SQZxNrQpRAu+ZOBiUqlJwuTOu5IlICYwCdGvVFb5PKv2999674OcWsktXDDyNGfCA\n", + "SdtnzKBEuWoabVJLG5TGWKuy0xq8zfGjmB7iMVGzS6o3oNRNilIwt8OcghJEDA9KC3M37VFSf92G\n", + "2LKH/mZuYuxhX8cff7ykbm5DycPGS7FVi4UHl7tiVgvtwrMnmnNpD58beMvE/3lG8yxG+aJcho9j\n", + "zr9U4ztTkUqSJEmSJOnJVBWpyEONVs1RJD2rZLwVj53w87S+Jx43eHm1ShHKDd51SYFBAfF28Pf5\n", + "tZRi0iLwKlwBoQBq30yQiFJq72IzrnIJgDfGfdZmDTqlYoVDac14cWi3SIkaB1xjlFXFmOPnUFWX\n", + "uMxxqZMRZC0y9vH4N27cKKlTLyNFytV8VP4oFmkorTFdjIHaDNVWW/cN3YHrREEjszmK90SRQfGc\n", + "FihB2Dt22PpWBWWP++ZZ4vGb2J3PATy7sD8+x+/8nzISbp+1b2NqKZXUaSUVqSRJkiRJkp5MVZGK\n", + "ammwiiYzg+yekgeO1+FZQ67M4LX1zWoDVrWtq+RWJcBjtlxxwTtAeePznm03rtX3UNg+Yqhy4WAv\n", + "vE/vW5RtqVPrjUdMep/yvnEYSwEUB+LQiJVpLdDnlOIuh8L1UR+L60bdQ4UuKUA+R7TGMLXWR/I5\n", + "atxqaetxaC+eOcTnPuMZzxi5PuoxRRm1zMW1GdaTguug/z1Wj/561ateJUnasWOHpC6GEGhHlKMj\n", + "jjhC0vz7pz/pf9qTZxZzchQXSyyfK1JcN8/uobRmOpdIRSpJkiRJkqQnU1OknvSkJ81mypAlxSqR\n", + "1SxeHF4gq/so64jPudfo8Qkcd2j9IeIPWjNyWr3bSLEDvAX+Hm1tM66YHTIv+sZNjFuJAvp1UvEc\n", + "fcHLmnQG1FLBM+X67giwGDCnEAuFbeMxL/aWHn2hjfH8GWPMNSgNrTFJrbW+WrOqXAGbtFpaItrS\n", + "BQWKuZ4425JNj0tB6QvP1lJcLPXTeEa6IgX0V5TFir3Rjv7sjZQo6kuhADr0w7i2QhqaKe6kIpUk\n", + "SZIkSdKTqS2Xf+VXfmVWkcJTJ7aC1SerW1a1pT3f+Fz0HnjcGTMcz/enKtH6fpYYKLw1YoDAY74m\n", + "DbVbuI9Jb+pcy2JXvcU+af8oBm2pxQz5fnSTBi9yUopU341upfn7YKLotLYNSg9zwVAli+uqvQ5U\n", + "WH66uk/NOt+U2PG5ZdJ1e9wmorjVvvGsfI9+6Rsn+vDDD0uqjwGj/6atQqO4RooU97Fr1y5JXTuV\n", + "NvmO7gtlFzv0OdJjBckCRJGKjotSNWSsT5LiVZ1zzjl68pOfPBtcJv1sp+59991XRx99tI4++ujZ\n", + "YmSSdOmll2rlypU69NBDdd11103mqpMkSZIkSZYARUXq7LPP1utf/3q99KUvnf3bsmXL9KY3vUlv\n", + "etObRj67c+dOffazn9XOnTv1ne98R8961rP0yCOPLLiK/MEPfjDrbaG44C3gFZHeBHUAACAASURB\n", + "VKIwEIsUVYtlvyy8D69PxHnI5uP4Q72UaE++ErVxB56lyA7vDn/n/iddJ4j2QpnC6xhazRevY9xx\n", + "KXjZtXvo1UK/ky0Y2dFSi9liHEwqk8wVuEnf/xDVhLmHOYGfZO15zTnmougahsZd+m4PfT1wxj7H\n", + "Ya4rVcFfs2bNyO999+6rxTOsmUtcGUTh4Xpq96sk9oe5isrZ4HMlY5m/u+1SA4/ri7L26LdpxwVy\n", + "PyW4j2c/+9mSOoUoqjdGf/gc4tl1jAvai3ZhjkAJxg6iTGvG1biz7cZFcZRu2LBhNgBzLgs9pK+6\n", + "6iqdddZZ2nvvvbVixQoddNBB8ww3SZIkSZLk54XeMVJ//dd/rY9//ONat26dLrvsMv3Gb/yGvvvd\n", + "787uQST9bFVLtoPz67/+67OLMbwlYm1YxRNZz+ciRaHknaAAoUzss88+I8dlh+9aWG3j5ZQqMPet\n", + "QB0pUVHGwWLViaId8Z7pv76KFO2JEuW1ZfrC+3q83ElR8jrHHbuF99b3uOOOFTz44IMldV4tv4PH\n", + "+RAXMYn9yFozBFEssBW+F6lcXuEcj58ximJCPSfusRTrxPmf+cxnjlzHgw8+WHUfEFVsJjYqqsQN\n", + "njXVmrXXijvpKH60KxmgKBKuWJVUVRQQni3eD76/a6T6O8x5PAP8Lci4s8L6Eu0e4bFe2Nkhhxwi\n", + "qRzXGe1hyTM6eiZzXMYH/cH1RG8jlkoNxIheuvEf/MEfaPfu3br//vv11Kc+Veeff3742aUqxSVJ\n", + "kiRJkgyllyLFKlySXvGKV+gFL3iBpJ8pPVStln5WawL1x/nXf/3XsBaFg5eAF9D63hkPHiWF6y95\n", + "ZxEoKF4FN8IVAPcayaxgVY7SEO0Z5+c74IADJE2ukjcxaIDXwHXg1ZGF2ZrF516itxfxKqgNZNCU\n", + "WLFihaTJZ85Mumq1M1ThOvzwwyV1tWCwZ7zJ1pg/vE9UA7cXp6REoZ702ROzb0wK58LG7rzzzqrv\n", + "8flDDz1UUjfHoLTceOONI8d3mIuISaFPGEOlNvB9F6O4T5Q03wXB+5r6QcRKcT9D9xqM8Ov8l3/5\n", + "F0ndfTOnoGRwvbVjrnYXgNp40qG7Ckwar0QfPWNdcSWr70Mf+tCg85fiUGln5iDmsqGxheNmxYoV\n", + "+sEPfjD77Ljpppv2+PleitTcifDKK6+czeg744wz9JnPfEY/+tGPtHv3bj366KM69thj+5wiSZIk\n", + "SZJkKsxNhDj11FP3+NmiInXWWWfp5ptv1ve//30tX75cF110kTZv3qz7779fy5Yt0/7776+//du/\n", + "lSStWrVKGzdu1KpVq7TXXnvpAx/4QPhq75d+6Zdm33eXvEj3PlBuTjzxREmdF8Zq2DMN+D8KD15F\n", + "Xy8LJaavouXeD23Ee/XW1Tn3RUYJq2jOE72vj7L7iNfA28WLBd6Ps7M5ihLKEV425yVOjv4mDoP/\n", + "e/97TBOfjzKO8Fo5P8dFGYm8JM7j56vNesQOUXT4Hl5z39i4qM5TVKuoNS7IM2D4ifrgcY3YA+3L\n", + "ebke4jCYePp6l5xnMeMhUNPuueceSZ2nXAtjDwXJY2wiRYm2IyaIz5XmJNRn5h7PNvS24/iMiQMP\n", + "PFCStG3btgWP7/WGOB99znlQ1ZmbGUO+KwW2jE2w+wJjx7PK+Bw/+6iSv8j4HIAqT39gB+PaXaJ1\n", + "L0bsg2cw/Tx0zgTmMmIfeVbVZnlClI0ZUVxIXXHFFfP+ds4554Sf37RpkzZt2tR0EUmSJEmSJI9H\n", + "lv10CpsbLVu2TDMzM4t92iRJkiRJkmZmZmbCtxRLs956kiRJkiTJ44Cp7bU3MzNTrDhdiv3gvTzv\n", + "Uz0TAdXrPe95j6T5NSqIreH9MTEevGeNamU4ZJS8/e1vlyTt3r1bUhdrQkwVGRS8fyWmacOGDZK6\n", + "OAvagzgK2oEYErbeecMb3jByn5OG87Ser/a99+rVqyV177Nf9apX7fF8vP9vfZ8dwXnIXCFepW82\n", + "YgT9yivw1vYs7feFXXmsIOf56le/KinOTCOwkn544IEHJHVxMWSYEb/iMYzUiDn33HNHzttKbUV6\n", + "rustb3mLPv/5z0uaX39p/fr1kqRLLrlEUjd2uLcXv/jFkqTnPve5kqSLLrpIUpdFRlwacXfnnXee\n", + "JOnd7363pHLdoBe96EWSpM2bNy94Txw3qo/kY48sQfq4dW/AaBcB5pq3vvWtI+dzPPap74sNnztv\n", + "vvlmSZ2Nk9iErRGDdtRRR0mSTjjhBEnSfffdJ6mr6YftECtD7Bg1AynZU7LNKIOUOFCyM4ktox0Y\n", + "m8SAnX322SPnYy6vrTdFf7NnYhSHyPXUPhvWrl0rqYu580ruzFVRBjm0PhuwM/rv9ttvl9Q9K4lV\n", + "pN98jvfzEcfLOODZHc2R2Af/J0YLu/Zahq973ev2eD+pSCVJkiRJkvRkaorUk570JK1bt05Sl0HC\n", + "qp5sMBQHvBTn+c9/vqRuFfrQQw9Jml+pPKqW6gpD30wB9w6oDstqF2/GvUb+jhfAapzPUQEapYxV\n", + "fK1SBieddNLIca6//vqR/z/5yU+W1GVfjTtsrrZdURHI7InA+2jNxKgF9QHGpURB5N1Rcy3aDQCl\n", + "CS82yvCK9seCb33rW3v8P+MRJQ7wDkv7tc2tJdcHvGC89pIiNTdTLaoEjsf7+te/fsHPMUcw16BE\n", + "UeMNhcj7pjbDEDXabQv1DzX2b/7mb6qOxw4SrbsyQKTy19Yoo49QQLgvv55STTCfO71GXVQb7/77\n", + "7x/56XC+oVl/KBd+HOwB+2COcAUnmqtrlSjal7m/lBFbmrt524KKS1Yn/fRP//RPkjT7bEb5Q8X2\n", + "ulS+9yR2wBwe1fDD/hhPrhwxF9KePEOiuYDzoViiGNJPPk5ZW3A8rhMlFNW9pMRBKlJJkiRJkiQ9\n", + "mZoi9dhjj82uch1f1UbgBfB+s+SJ98W90hKugPHe1b0FVuVf/OIXR/7Oe3VW+6yOUapqd7vnOCh9\n", + "3AegUK1cuVJS5wW2Kl7jpnT+2usj7iRSrlDi3GvCK6H9vVq019qJwCvCm/L4AweljesmfgewK5Sp\n", + "SJEq1cEqKXmoEpE6gT3zs3Y/NsZz1H8ouXiVnN/vh/5AxWlRZSLF6tprrx25RiiN+Vr1lni03/qt\n", + "35IkPec5z5H0szp9Uqe81I5tlArGcKuaTowU30cZqL0f5i7Giu+htmrVKknd2KpVhuhr9mvk99b2\n", + "GRdRvSXmVh/TtQqGxxlG98Xei8RGlSgppDwDsBfGIrFS7FLC2NuyZYuk+UoUChlzAPCMQvEq7QuK\n", + "uu12x9sRlCNilnwvSPBnv1fEd7Zu3brg37nO0lztpCKVJEmSJEnSk6kpUnsCD7cUGwG8R43Ay8Sj\n", + "b40Bwiv17DO8Eo99wltDueB+5pac3xMcl+vEG/FMAmDV7e/P8ez5iZLBcU4//fSR77liUFvhe7Gp\n", + "9fpKykvkbdZWrEcZiRSZaOf1CGL8omrBHK903FJ/EXsXZTti36gJfp/E9VCdmHiiqCI7lJREYqJo\n", + "f7xKvFC+z3VEXuUQomtEnSxVhI7GInz5y1+W1ClSKEFf+cpXFvy8V90HPOYo/rMEbT0UFBCP+eG6\n", + "S3O4z2lk6aG21u7HGhFlJ5ZAHY76sbRfJMzdl3ah75cUtn/8x3+UNF/5AR9zJWWSdmBMc36UWlTw\n", + "kupO7JiPB66DOYrriTKNmas8tox+53tcd6S48WzleIxXroefvvtEKds1Gn9OKlJJkiRJkiQ9maoi\n", + "xWrPV7VR7QiH1atnIviqdVwxP77a9321gNU+ylStkgCszrkvvE/uz6nd28zfI6MkQOQtOKX6Xlw3\n", + "/VsbQ9NKX28Tov4j/qT0npx+5vO1XmoE7T/UXktZmHh5tXj/EUfg7dday8hhHsCbJFYsysxaiJJK\n", + "2JdSPBptWjsWiQ8lZsWz+SBSwKhVN5TWWBAHZctjyWrjVX1Ooz2j/mOvQM67ffv2BT+H0kUs0q5d\n", + "uyTNHwsoT67A8Dvtz3FaFbKofVv3o4zGVuuYo13IiuO+aO/atw8ojZ7ZC7VZieBvGTi+P2Oi+8WO\n", + "mDvJHOYZwVzCWxfuN7JT5qBor2AnFakkSZIkSZKeTE2RevrTnz7rOVOVFsWH1WXJq+TzrDbJGGmt\n", + "HRIpYyWiit0oYlwHcRC1NVrw9PFaWIVHGQhObdVcPH2ypfAuSl5XpEQBXs2klCjoq0SVoI4Z3g1e\n", + "jSsw/F5SkIhNw8uN+gWlrzY7NMIzc4Yez6F6dMkOIqJqyYwTvPioHpVnis0df9hcdI5SDFMrQ1XX\n", + "HTt2SOqqwKOcPPzww3v8XhRHV4ur+RFRe6GgRXGbsN9++0nq1Fr6CmXA40aJD3WFBBvmd+YsFKVb\n", + "b71VUjeH83+eCVFdp1K/cZ2MYcZ8reISxSxNSjktQUwVzyhUa8YLSoyr2q7YMfapP+W0Vm53uB7i\n", + "OWmvqC6Vx+LR7jzTfE0RHQew+9o5LhWpJEmSJEmSnkxNkVq5cuWsZ8mqE8WGmBNWz3ioeBWsgnnP\n", + "iyKFB9taU8W9GBQgr0/jWWxcn2fA4PVwHFbTrkjhzVIrg/e1ZJsRB8H9R5kbnhGBV1Ebp4C32Ro7\n", + "s1ToqyhGYI+0X9TuUIorwPuj/yM1pOTd14L3jjfmXmEplgtvkIwjVyjx0qh6jJJUW18ryrpknBC3\n", + "QVySx0Vg53uy1+gc41KioDaGIoK+QInh3kuKFIpBX7CRKDYLovaiD0pjg7maOY25meN6VhTtgM3y\n", + "eb7vGZ1uM1wPtfE4flTLr6TW+l5sfVVYZ7GUKH82+BzEGCMemfZmj8JSRry/JUH54RnO8VrnZsYv\n", + "/U7/RlmQUdwucweKFf1dejvEnJ0xUkmSJEmSJBNmaorUj3/843negmcD8X6amA+UH37n+6y6WX1G\n", + "q30+558Hqqyy6vX3vO7NRBWgid3BC2B17llZrNLJnnPvj9U8q+LofTPtxyq+lO3oRDvOP14ghon2\n", + "HBo7hZdFu9YqdVHdrdpsPpQwvO2+lfrpR8aPqzMlb4zP057sxE6dK0AJjvZDawWvkbgWlNUoZm9o\n", + "luA4qI1bjGBOYP/DWlVv6FjF4x4aa8Uc6RnJ2IbH5EA0l7FbBT8jW0Wt51lAP3jMFXMqY7A1Ixa1\n", + "le8tdmX1WnhmebuiKPkzEeXI6yuh/DCnluYgf/uDPfF92p9neqToRbuHeLwwMXEO9ubH970xSwqq\n", + "nzfKlHdSkUqSJEmSJOnJVOtIsVpmFcv7bjxivB1Wm8QK4XXgtfgeclHMCt5EyatorUjtsPpntY+i\n", + "wX3UZo6wCvcqtI57xa2eOt4wsVpLtaJ5BNc5riw++h+vhP7DXvnd+63UXth5FMOHPRMrVVvPysEr\n", + "o/J4iSgzC3UEu3W4j9pK8yU4Hu3MOEFZw1utUQVQtThmVAeqFvrOFZKhsS6okPRxbSyJZ81FNhX1\n", + "LZ45ygFzRmmvNvA+Z67m+omxKdmGKyiMLX9bwee4D85Dv6AcuDrPWBiq4PXNPhsXpWzT6JlFv9Cu\n", + "zFEcjzmHzzHn1MYSusLDs5k5Azv1Z7bPad4/fJ+xXpoDOT73xX36XNH6bKzdjSQVqSRJkiRJkp5M\n", + "TZH6z//8z9lVMu9h3bvD22JViYfsXgveCTFO0wYvyOtZsT+R72kX7UOEd0iGzgEHHCBpfkzKuN7b\n", + "U1ujpKyQWRNVBh8K7VNL7Z6MtZBp5LVeStlmJXWCz0X7N3ksFbFS/ERlIVZpXDFCUWYKdhcpW9gt\n", + "2bMej9AXVBrsGoUKb9bH1Vx74V6o+4NSg8fed6xwDR6Dwd/79gXxZygrtTFS2BJzCm3jilakLNBm\n", + "fJ8x755/SZ1GocNzp31Rh6Mxw+e9MjbKCPdDe3u/oYQQM4Mtcv30OzbMecY9VywWfbNNPd4Re/Ws\n", + "TeyPtxNRxXLALvwZ4BnmHJe3RiiH9H9U85HrYs5jDiplrjO3+tqgNtuS73mMX4lUpJIkSZIkSXoy\n", + "NUXqe9/73mw2TuTJ4z34apxVL6tHlJ1Jx/SQRVSKt8A7RblhtcxqnNU58Qncv2cosIrm83hXXktj\n", + "XPWTaiuv42WMS5HivTze0urVq8dy3L71pfDWvU5YFCdBf+DNReBl1+Kf5/e+sVPgCmikpkTVf6n8\n", + "/uxnP1tSeS+81pg72p/+Q92I5om5f+cceOLY1KpVqyR1Ga2lmBe+h+cc1dOp9VgjDj30UEldX1I3\n", + "pwTXxZhttXHOgy1ESk2pz2hnFCDmLI9lcrhuV+Doe+bGSLFg7sFGaQ+v/TdtqOzeF+9nh7mYdnZ7\n", + "ZAxh78xljHnsGmWSz9XWzvN4X47rdcCwC64Hu/HYQ46LXfDMLNU984r4DjUmmYuIpXL75HfsLnp7\n", + "4KQilSRJkiRJ0pOpKVI1nleUQcJqtqQAAIrB0Gy8WgXG92NiVY3XSewXq/ko24y/33bbbZI6z79v\n", + "BonH6LB653paj0ssC8djFd+axUV7uUIHKHGukODtodT49Ze8dGKh3Pu68847R46HF+fXF+3fNWn6\n", + "KlFAu7XWG4PnPe95kjqvrjQuWpXiq6++WlLX7qVszLn9fOKJJ0rqKmDjIaOQ1No4fVuy5b6Zoqiu\n", + "qPI333xz0/exWRQLzyz1uDLuG5un71AEmGujvdMifB6nz5hrqJEX4e3Lvqu1CtvQuLw1a9ZI6uon\n", + "3X333ZLKsWrE7hx44IGSpNtvv13S/D3ehsYxlt4SMLaw7+jtDfbCdaHw8HevfVh6VnoWIHC/2BVK\n", + "J/bne/oRX8l9EgvFnI99RHXCgDhrV1Zd3eZ+eeZxH1E719phKlJJkiRJkiQ9mWodKeoWsTpmleir\n", + "RVbHrEZRmHgvyqoVRcRjmFiF854WhYjVdK1S5UoJGSPuvXA8VueuWPh1eBZfxNBaJly/30drfEUU\n", + "twC8h8ar8Oq59COKor9vv+OOOyRJp512mqSuJg3eHnYDvP+uhYwu4gLcXjz709sdb4t+8/4fdx0u\n", + "z3Aa6oXTnrWKFOoCXuEnP/lJSeOrhM84JyuVdvW6Urt27ZK051pHqJaMwXHtrUfbt8a5RTz44IMj\n", + "P1t573vf2+t7pbHrlaxpe1eOIhtnrJBZ3DoG6Ft+YnMoXSgY9G8pC8/jCT3m5UUvepEk6corr5QU\n", + "K1HM1VwXShbt5XW8sJNS5fuoPhTKKkoRionHgEX7uAL3y+e4Tq6vbx00lCu3C44fzS3+Nil6qxTN\n", + "6aV4aodnCkoU7UB/8pNx0VdBTEUqSZIkSZKkJ8t+OoXy1cuWLdPMzMxinzZJkiRJkqSZmZmZUGFN\n", + "RSpJkiRJkqQnU4uRmpmZmY074D1x9H6azxETRWwG7zeJOeL7rBpRvRZL/Vqq5zv22GMldRkpDllc\n", + "0ftq2v2Nb3yjJOld73qXJOmUU06R1L1Xvv7660e+d9JJJ0nqKnYTv0JMzBFHHCGpe+/ttWVe+9rX\n", + "Supipq677rqR41Nfixgij3Wj3hHHLcXC0Y5/9md/JinevwxoF2itq8X5Lr30UknSCSecIEl69NFH\n", + "JXWxUGR4ERtGOxBvQEwRMWnEP3jcQGQvZCMSh1KKo6mF83zoQx+S1MWmEfdBho7HPfA54hpoB66P\n", + "/ia2jxpR69ev16c//WlJXdt4rEYU8wNeeyyKBfK29M9x7dSJimKhiLXB1hiDvl/nUp1b+uKZ1Jzn\n", + "8ssvlzQ/RoZ+Ye656aabJElXXXXVyOdOPfVUSdK2bdskxVmVnO+yyy6TNL54vwhvzyOPPFJSZxdR\n", + "hurZZ589cn1kFDNmmYOIWcLeX/3qV4+cL6J2V4YSfn9k5RFPSnYnMUvMzYwX7J52OOaYY0b+jp0w\n", + "B27cuFGS9P73v19SN9exJqAyefRMw/74Hu3H3OIV/1/xilfs8f5TkUqSJEmSJOnJ1BSpfffdd3b1\n", + "GGWjsTrFW/MaFawW+Rx1jbZv377g8fB0UTwWu/7PtPjt3/5tSZ0CgHKCJ0/tmGj17ll9KDzXXHON\n", + "pPmV1gHv8Gtf+5qk+Rkn1F6hhovv+A2RV4mXFnmTpRo2ESUlCsZV2R2FDiXIs/LwWqP9y7BjfkZV\n", + "uCM4bt+aSCU8OxJlMspowjv2/uUn+9Nxn3PrgFGXKdpbq1QXym29NoSUz6EU4NmWlA76HNV9w4YN\n", + "kjr1uFRvb9zZhM64M1Ahuq8oW4t+ufjiixf8PsoeSgdzHd/zveYgshNs058xtEfts4MMdIfr970J\n", + "HZ6N/B/7Rkli7sau95TRuhCuRKGg8nfsk/uuzfCmXbke/140N9PutC/f53i+z+whhxwiqVOWPOsz\n", + "wvfxBZ5t2GEp6xJSkUqSJEmSJOnJ1BSp//iP/5hVpKjHBKx+USioBYLnyarU9+fBG4zwGimO1wqZ\n", + "FO4VtVYCb2XHjh2S5isoKB++ynei2hpU9UUJxEtC2br22mslxbFZgEIR7c918MEHS+riA8YF1Ynd\n", + "C8bO+tYUwUvE26ndmxG7i/bSq63kP9SesE/iEfDuIYqriGriAPeJShONV7zuCLxz+m1ubSDvs9Je\n", + "ZUNBTQTUcvocheRtb3ubpG4s3nPPPZK6+EFUcvrcd7MH3xuNPkLtjfZHjGyK+DpUPuIRgbGASosn\n", + "z+/0OfWdSjaK7fDT56RSzE6kZBEvST9HtdZoB2DO98rgvusDtdeYi6jAXnqmuH2AX180dogFcztg\n", + "jPPs5DqGVlJH4aSd+84lxN3yfRRTnuleqw9QorBj7o9+9bdXfd8q1dbiYzyXSEUqSZIkSZKkJ1NT\n", + "pH784x/P2/cG8G6odOwZNNE+P0NjPCatRAHex6S8ZOC9fhR3UHu/tLuDt0GGBu+x8UrJPiuBd0u/\n", + "4iVDVCW3pICUiJSPoV4dGTklpQ+4f89Omxb0a9Q+eJXu1UX9gHePnQD2z7il/z1uweE8eOnME3Ov\n", + "3c8BqGAcY+iYJ1OS47rHzDWihJx//vmSpC1btkiSLrjggpHPk51EzI+PBd/FgTFXiteL4ua4f/bx\n", + "dDxe0H9HfSW2hjk5mnNcyXKIt6xVX2l3xporahA9axhrUaVvrpe4W9q9NnbG9/EE+pc9Ibkuj3Uj\n", + "9gelDphjUJC4jyjmC2UWu+e+/BnKXDs0cxdFCXvF/lEAUVL5nI9T/l7aB5b28bnD3yrUzi3+9it6\n", + "9jmpSCVJkiRJkvRkaorU3nvvPbs69VUfMRSslonFoTbIFIqxjxXiG1r3iGuF97usrn1VTvyGZ9M5\n", + "0Xt+rh+v2RUo4jHw2qP4Dbw7aqK4IhTFWOFl91X2JmVHmzdvllTvtTq1eyqWaiINJfJuW/f6Q3HC\n", + "22Z8u7rBuPBYO4d4Irzwln5E8aBmF7aPLbeOSWyaa3JVjviyN7/5zSN/R0mIiDKPndr6R3jaPgYZ\n", + "a31VWGJpsBXUSn73mKaSEhjNERG1byG4P1dZ+X6pjhLtx7OKGDiyxqKYH79P5rjDDjtMUhfjgy1z\n", + "nX5ffn3YPGOF64uy6lDumIv5SaweiiYxe7VEzwavCel78DE38gxCmQPur9QvKL4obrQ37cizj7mF\n", + "6+K6fQ7imcUzLWOkkiRJkiRJJszUFKkf/vCHYewLq3Tq5+BFsurGa/QMknHDKpbztK7WIyatRAHv\n", + "j70mBooU3mwps8m9AvrDvQ6vCg1RLRXAS8Wr43ogUnbwxrifUo0TzwjC60AZHRccn9gd97ZK1No1\n", + "SpT361Cljf4lDoN2ol+Ip6EWjKsi3l8oUSXVg+OXYsS4P9qnpZ4Xah+2yzn72gA2TxvhEZeUolLd\n", + "JzzhSBWEKC6Navi0ZSk2pC9cH2MXxSY6H9l1UfswhmtjWhzmbK/qH1EbX4nSxhzCfdbG0ABzA3My\n", + "z0DsqPZZRkwYtQBRnKLdG1D6+EmmtY+d1rmj9Hn6A3tGEfR2j7JKfXy6woe9RAqnnx8lONpFBbC7\n", + "2rcdqUglSZIkSZL0ZGqKVA14FV/96lcldav2Se+L5Odv9TomXW24FlbVJUUEBaK2EjjZV3g/eAvU\n", + "WNm6devI56PsL/rTfzp4g+514A1FSphfL9dJXAzqhNcxGwreIbF9tGut98v3S1WtITpuraoBqACM\n", + "L+wf79UzbrwCeXQ9taoCXmIpRozxWBtLNhdiW7DRWuUiwvc8K3m6tWDzJTU3AptmLirVO4ooKUiu\n", + "GHD/kULA50pzeF8FjbkgqhHn1MYXModx/dh+yX48247vuRJUWzEcUK7IrsNeaueMoW9XUJ397QFw\n", + "37SPZ+Lv3r1bUnf9kZ1jTyhWbldRjT4UYsYlymxt+6Ce1yqEqUglSZIkSZL0ZEkrUjCpPcBqYXVd\n", + "+74UbwrPmdXwYilptXA/rXWLaA+vcUNNmVrI2KAGDV6ZK1h4Fb5DOBkZpcwO9vLjulGkokrqQ8Fe\n", + "8WZKiqbHRNV6TRHEBWCHtUqYxwUQC0X7kqFEe7m3XTpuCZSzUn94rFWf+WGoEgVelZ824RpL9xLF\n", + "w3FPfetcEWfK9aBMRZXDowzQ0tjC1rw6f8S4Mkyj+0Bpqd1vstY26SfmHGy1FCMUtd+4MoZ37dol\n", + "qcsC7FtTrxXOU9ovE3j20Y5RJXmHz2O/Xt8q2gvS40Vpp9rx1JoJnopUkiRJkiRJTx4XilTfDI6h\n", + "4NXgiUfVfx28M1bDrUoUcReTVuJqs90cvF28Ue6TmKlSzBJQYwcvgfft7k2idPFenTgFrp/zRTEz\n", + "/J/aKe7FTKoOE3EL9GcUM+dqBPfPdfJ7rR2NS20BYq3od7xElMJxU/Kq3ft0ZVTqPGU8WWwDT5N7\n", + "8v06HWwHJSLyaMk2QimhbbwuEn/HJqJaWVxPlOlYGmOMFeIffY87VwAYGx5T5Koqtsh5ab9aD35c\n", + "caORgsGcUFLSoFYZIsbH270lY1Tq7Ii4Q+wSFbpVgaR/sZNxj/0StQoY/cG4jJQkB+Uv2iWDtYFf\n", + "B8flPJPetSQVqSRJkiRJkp48LhQpFInSrvDjhmyvaJf6iL4VrWGxYsLI7GnNNMJ7YrWPl4WiRIZF\n", + "lFHhUCn7oIMOkjS/Wq5ndOD9433STx5bRD/gNdKPKFruDY4LFBKvyF/rh9MsYQAAIABJREFUjaOQ\n", + "oR541uJQZZYYs9qsN66H/tx///3Hch3jYiE1BLUUBSWqeVaKk+Ne8agjz5bj0CbYqO/ZRRZcaS+5\n", + "aA5gbJWuG/WQz6PMcV133nnnyOex2agOEdft50MB4f8/r2BHzHF9VWzmIOyEuY45jDFZW+H9d3/3\n", + "dyV1Y/pLX/pS0/VglytXrpTUzTkPPPBA1fdLFfqB8cYc4koUyprbX6nyfqSIMSfQzq0ZzLDffvtV\n", + "fS4VqSRJkiRJkp48LhQpvKvFAgWM1XlrZepJVVrvC14PXiPtibcdVZjHWyF+AvBeOR7eAsfj91pF\n", + "Csi4IR4BPD7FlZDIO8RbefjhhyVJDz300IKf67vPWAQKEt5739pCqCD0DzVYUNj6xpu03q/Hph19\n", + "9NGS4vZ08ObxxqM4DuyU+BEydEpxFFyf1KmXnNP3BfRYIa+k7KBs8TkyTSOwRWwP24WhuxrQFigX\n", + "ePrcD2ObMUINM2zSs56AXSQiUHejvlgqGckoCCXFrxX6FbtqVTYA5Yeaex5nyHFvueUWSXHsGWq3\n", + "Z022vg1BCUJZqo2xoh1qFRvGAXaI3XK9tXNkKVOYOQTlkPasVaQ4Pt9nzi2RilSSJEmSJElPHheK\n", + "1GJ7O5HXVktfb6WWqAI4q368crwZlKM1a9ZIkm677TZJZS8A79MVIOowOSWvtgSKE9l84O+7nVI8\n", + "Ad5Ta22QvqBgfuELX5A0P66mbwwdx412XK8lymjy2CkUKJQkvEn6odbrP/bYYyV13m7k9XJc3xk+\n", + "UkxhbvviUTIGOSaeN8pCyWY4DrFKxGculCE4F4/ZQClAQYjGDmCrfM9tPqqIHcVKcRyUqb5KTUm5\n", + "q4U5ivbtU51+T8dt3YWidDzaD9VzaJ0m7pcxiArPM6e2f/gccwz2jPp+4oknLvg9ng2MZfCYuRKM\n", + "o2gsu71jPzxTmFtQfqLYPMfnrtNPP11S98xAkWVOiOKqUb29wjtzIG+VNm/eLEk65ZRT9nhdqUgl\n", + "SZIkSZL05HGhSPnO2HgLk6r/My5YdXtdoNbYFlbPrLIjrzjKcCBzh9ivI444QlJ9LFerIsj1+b5a\n", + "XBdeCP2IVxMpTtu3b286vzNUiSKOAYWE4+FF4iVxf9GekNz30L39hmbLoWjxE7vkd/qNivOoB16b\n", + "ifbAG46ULhTQWvC2a/eZm6tqoMxwre75YnN4nr73GX2I8uDZS33jNUtKFIxrTuP+du7cKal/xjN9\n", + "7bEmXn+LuYXr94xZstLoB2y4tQ5ThCtvtWDjKDl+PHDFL6pIXwI7YEzxVoB2JT7U3xbwVoEMY+JR\n", + "mWtQjaMsOt8zsTV+NSJSiyN7p7+jfm9tV+agW2+9VVJ5rj/++OMldXaI/fozulUpTUUqSZIkSZKk\n", + "J8t+Oq5Nf1pOumyZZmZmFvu0SZIkSZIkzczMzIRZq6lIJUmSJEmS9GRqMVJ7UqR4T+w1YCJ4L+yx\n", + "R5zDz8V71db36RG8777gggskSZ/4xCck1cdFlOB9LrFSvL8/55xzJEnvfe97JdXHG6xfv16SdO+9\n", + "90qa/16ZulG8pyeegXYke4z4C+IiduzYIUl6+ctfLknasGGDJOmVr3zlyHXTv2RzsY8Sx+V8tKf3\n", + "HxXQiX/xGKojjzxSUvfee+vWrQu2AzVCeC9/1llnSZI++MEPSipndvF57pusRWLEjjnmGEldLBXx\n", + "NcQnRPY5KTjPxRdfLKmLAyK+Ajsr3bfvfbnvvvtK6uJiuM83vvGNkqS/+Iu/GPk87U1G3IoVKyR1\n", + "49erepMBFFV95rxvf/vbZ8/lmZJ9Y1oivO+8fhXnX7dunaQuFosxg2fLmCamiTbiJ8f7vd/7vZHv\n", + "g9fVwaaZ26iq7/s+EvdH7BJtfu6550rqKmRP2jaZC8477zxJ0t///d9Lmh+Xh216Zim2QPYVsVrM\n", + "EdwXY5B4zAsvvFDS5O+P633zm98sSXr/+98vqbNDj7kjs5pn2k033TTyf9oliodlTnzLW94iafj9\n", + "lfbEw35f9apXSZI+/elPS+rmYOyM2ET2qyVW65nPfKakLkaMmCvGE3MUP8nOO/PMMyUt/twZkYpU\n", + "kiRJkiRJT5Zk1h41JaKdyt0rac2Cw4MelyLldX3GlYkCKEYoNu6Ftp7v9ttv3+P/adcoO+yGG26Q\n", + "FNfb+shHPiKpqx3iXhNK41133SWp83pWrVolaX4dqQiUDBQezx6L6nlxPqoLu0pRW2X3iiuukNQp\n", + "T4CXyXH4HW9x2vuSeS0c7LdUK+hFL3qRJOnzn//8yN89I8yzSr2+mdeewb7JZnRF6oQTTpDU2Y0r\n", + "UnPvxxUhmPRuAxzfz0Nfu9IEXqvtG9/4xsj/vS0/97nPjemKFwYlpDZjcii+zyW2RDYaY5yK8P55\n", + "rxzPnMQYJ2PZP1cLCl7f/U85P5QqhzNXoKg5hx9+uKROaXSivSD7Ugqh9jkDZYln7CGHHDJynC1b\n", + "tkjqxjLPBuZs+pm3RvQ//bdY+9C2kopUkiRJkiRJT5akIoVXt3z5cknz97rDS+tbFRcFh/fzvF9H\n", + "EUHxotprKWbLlY+hladLRPV6hkJ7E5cQeTf8H28rUjKuueaaPZ4P7xHvl34peVX0A9fr5y8pWnhH\n", + "eDeuErTWaYqUzaGV3h28MxQYvDfiR/AG3Wt3sE/26SKuBm/ZVRGI6l/htaOUuuLFdbEvl3vlqEhR\n", + "xX7iKaL74vtLkdIuCdiuV1iGoZW0W0ERwTYmTTSXcX7uP+p7YnA4Ds8E5iZ+xzZRhWvpq2RBa10w\n", + "j51CNSfmiHpWkSLVSikGCmUMO6UfmLNRniCqmYjyxHhgrv/iF78oqZvzfU6m35hDat++eGX6SZOK\n", + "VJIkSZIkSU+WpCKF58tqnPfmrO7xwPvCqphMFrwflK6jjjpK0vzMGVek+L57S+N+T71YoBjs2rVr\n", + "j5/zHew9iwui/b8cvMRab4Pj4r31rQaNt+ReVSv0P9mOpay3vhArxL5x2DFZg7V7RNJPxCLiBa5e\n", + "vXqP3yOb0WF8MC5doeM8/N/thSrNkcJMXEW0R+Hc/p/U2ItsnDmKDF1XkLgn5hZUN2wYjx8V1W3Z\n", + "26SkIAylFBvle9mhFHAfZF3VVoCPzsdcUMrcxnaZC3yvRdqPOb51lwZXu7FBlLC1a9dKkq677roF\n", + "v986F3C/ft9cP2N9XDAmo3hSzxIE2tvVa+yXuEfan3b09oyUWI5PnCnZmKW3MVF2bt9xU6vMpiKV\n", + "JEmSJEnSkyWpSHl209FHHy0priNTAq/Jd4RndYrHzE9isvAi8T6caBWPh+7/d290qVHK5ougPT2b\n", + "sgTKCl4l/YSXH9Ea5xBB/48ri27S/Yoyw16JJ598sqRuh/IooyWKPQIU4L7ebmkneFQaj3UEvO+o\n", + "HxiXNbGHk9p/M4qbw1P2DE0+z72hhLiN8Pfa62ZumZSt+X0yRomDQ8Xlc/yfmCRsk7cIKBbRXn+u\n", + "cKGKo5Qwl9BObuN8jvYjnhWbx2aiObyEKxges7VYMWx33HGHpK59apW1khLjzyjqimHHtGutwohy\n", + "hX2gIPH92pgl+h1lsqSc0d98DkUKhbpWiSIOFXuv7d9UpJIkSZIkSXqyJBUp3q96VhEVqh966KGm\n", + "4xHLxGqWVXr0vpX3tl4t12HV6ztuR94l79epreFeF9eHt8OqngyE0s7WJVCMvHZHK67w0Z68n+b/\n", + "/J0YGOJIuA8+h+IAVDp3aGd+oqRQ+bq1krxXox4K3hNeMFV/8YZKyk0J4k/4ef3110sq96N7gR5H\n", + "gF1GKgftjb16/Ebf2i7YB971ypUrJUnPfe5zJUm33XbbyHWiKvjO9eNSKPtw3333SSp77FEb0fao\n", + "36XjMBdMSpHy43LdPkYBmyfGy2PJ8OwjfK5E4aKvXZGgvXwu5boZa9gIn+ub4V1i9+7dEzluBNl7\n", + "jJlS7bfWmCD6GeWrtqYf+Nskxi5zVG023de//nVJ3RzBXB/N1awVGD+MJ66nlP3px0GZ83jgiFSk\n", + "kiRJkiRJerIkFSlioKIsoVY8toJVbm2WGMqJg1LlilT0Hpe/o0ig1OCFEX+Ad8X73aFKFJCdhjcQ\n", + "1Qsq4YoUXg/ekcdKsar3+4i8dPdW6C8UHhQVvF28FbwpzlvyxiLvpnWvR8fjY3jvTrv1VaScWkXR\n", + "FRuuA+8NhSuC9i55cxFRdqsrlw888ICkbjzRP3iTxEH43ppzM3TcNlvj9lqhDfG0sbna2Ao+h7Jy\n", + "99137/HzQ7MSo31JwesmtarWHmPVqlYy9zM3o7x4Zij9GlUO5zh8btyxTNhZa825oaDUkSFcUqRa\n", + "wT5qd3dwaGfGH3M5yiD9WBsrRTujFHmWn8fmYTfYMc9+v55I+eW+aefaCgGpSCVJkiRJkvRkSSpS\n", + "48azlvBgWR2jQOC1ej2eqLotnnRU3yYCz5zz47GzWvYdr8fFww8/XPW5UqYHXl6krLj3H63+vY4T\n", + "mT2eyYPyhPeBl8z18T7cszFLRLFs467Rw3mIO3CvKqpRNC48G66U/eb9j6rQN6YuGj8czyvbR/Ww\n", + "aEeUSa+aLM3P7mFsttaRqe2TqG5NLai0tZmjQ+tIlfYlHfeehMxxtVmJKCz0I797f2BTPlcyJ2ET\n", + "3M+4d5vg+JOq5+Vg88R+jXs/VyjtalGCZy1KEs8C+qF1jmN8oar7WwTshJ+ercn4Yg7DTtjFBHvh\n", + "bQYKKCp9bfxsKlJJkiRJkiQ9+YVQpDzGiVUySgerZN7DsjrF68D7cW+QCs59Y5h4j8/xeC9bm8Ez\n", + "KchYiKrOlrzaVrzGjHsBtAdeO14q3gexaq1eFMoa8Qbgx8F+6OdWLxSFxeMEAG8qun7+X7Izjzni\n", + "eO6Nt2b61No348njYlASvf4b3mHtPlrEb+CdYhd46wtdO0oI56i1kcMOO0xSd+++uwJgQ31jVbie\n", + "2rpAVJoeV9xkdPy+oCBgs4zZKN4wqnGGDUexNCiOtB+24/F+/N9V7qFgB7TXUGWyBPfB/Xnm6rho\n", + "jWnztzE8K2kX3zuvtR84Dm9tPB7ZM8U5j8ej0l+M10hx9v6rzY5NRSpJkiRJkqQnvxCKVBTLw2qZ\n", + "VTWeLjE7HvkfKRFRjZUSrKZZ9brXO+54jhJ4C09/+tMldYqB31/fukG1NUSi6sV4J8S0kemEd95a\n", + "OZ79wbydXQlE+eD6+95/VJOk1B7YZaRCcH1RNmqpls+4oF08SzCKkQIyZdw+sGu8SLJbqd1DP81V\n", + "UbwCNzbRqhQwJzBGoxifobvL02e1c0hrPCbUqpqepVQ7ZoGxVBsb5bZCf0WZz8Cc7m8F/DonnbVJ\n", + "7bN169ZJkj71qU9N5Dy06/LlyyXVZ1zzdqFWwXL7oEYfP7dt2yapi/M9/PDDRz7PmKVfGbNcP+p/\n", + "KVPYr59nsu+O4BXQ6X/f84+5gvGM/fjawOuO1T5TU5FKkiRJkiTpyeNSkTrqqKMkSffff3/V56N9\n", + "noD4BpQYvBjqE9Vmu7XCqtm9sFZliRiUvnV+gFU/q/G+SltEX+/dlSC8Cq6T47oaUcp6vOeeeyR1\n", + "971hwwZJ871YzltbU6QV+g9lhZ/EzGEP7j1xPdQj27Vr14LHZyeAF7/4xb2urzZTjOuhMjl4TRpX\n", + "DlEYuY+bbrpJ0ny75u/OXIWQGAo83r7ZTdS0Qu2LVF+PbapVRTkemYu1Hnpr5iR9VxtT5Spfa0wL\n", + "7c9YLNVic4WtdQ5jTNDuKBjMGaW5fyicJxp7fTn00ENHjs8c1xrDFil7pTFNe7Lv6W/+5m9K6pQw\n", + "+snnJGKZiI2jf7GrVnUc+0EJQ5HiWc14oBI6c7/HrtXWBOw7X6QilSRJkiRJ0pPHpSLVN0alBMoU\n", + "73HZuy3KXosg9qb0HhtvIFKi8EZ4/w6e9TVUifLrefDBB/f4OVb7fesKwXHHHSepa99vfetbC34O\n", + "ZYn3/HjX7o3ipaBwlBRL4ivw9lCk3AsnY2ZoVWniBqJMERRAlCiy/aLzomh6Rfy+0G5+PdhFKd6E\n", + "fkFdWb16taQuWy+KmyHWDS+Wdqq167kxWD430JZ4wrRppI7iQaNsoIqhtJTmnqgP2CON495yyy2S\n", + "uuyi2kzYVoWoNcOUzGWgPUoxZvTd+vXrR77HTxQDp28FbfCxiSrqmbiT4otf/OJEjstYxJ7Yd7L1\n", + "7YjbK3bMGI5i2Dgv/UbFfR+TXvONvfmYCzgP32u9fu4bhZj7OfXUUyV1/d53l44I7Kh2H89UpJIk\n", + "SZIkSXqypBUp6sOcfPLJkqTPfvazkuZH7o8LVs14uJFCUoKqqXgVeAEcFwWG9/f8ndU7Sg/KFpkR\n", + "KBmtFc/xCv17/B1vvVbRGHfFdfeKvLZM5MUMtQPaGeURamv6tBIpS+7leTVnlBze9/N33udjNyhG\n", + "KJz0q2fNRZk8URwBSh9qyNq1ayVJN99888jniCciJuv5z3/+yP8j7/faa6+V1HmBrTGCc/vLY2SI\n", + "u8KmyCKKYjsYc7Qtig5jo28MBSovChSKWKvCdPHFF0vqxgQ2Rd8TW8PeY9gW58eWUA64P+aCk046\n", + "SZK0ZcsWSbHq7JnO1HLj78SXYjvEyLjNecwPn+e6sGHUUfoNpRHlg3al/wDbwB68ltlS5cYbbxzL\n", + "cXj20J4oi9FY9N0jsJdadRjliJ/joqQEc53YE3aDvdS+PWH80G61tRxTkUqSJEmSJOnJsp8u1mZB\n", + "c0+6bJlmZmYW+7RJkiRJkiTNzMzMhDGHqUglSZIkSZL0ZGoxUu94xzuKVW9bq+o6qF4l9YvYjuc9\n", + "73mSuowajxkhZivK4iudr7XytuPViWvvb1ws1fO17jA/9HxDoR//+I//WJL0hS98QVIX70LlbuJe\n", + "iBEkZo9YKe4buyJeZefOnZK6WCniRN7ylrdIWvz++8QnPjHyd+IVaAcy1qLMtShLlFgx4p5e/epX\n", + "z7u3UkVvYnmi7DGOTVsSjxbZCjXu6BuynYDsNmK3uGfiJYnx4id/f93rXjdyvhUrVkiaX3/K4yGx\n", + "FeLaiJEh9gNb4/PY3Jvf/GZJ0rve9S5JXewM18txyY4rZefRHszptCexTm984xslSdddd52kLgaM\n", + "85EBSmVv5mCytegXsrmY04nj87jDCy+8UNLSm8seb+cjJu0lL3lJ0/mwm74xa9Nqz4hUpJIkSZIk\n", + "SXoyNUXqaU97WrGaL95iqY7TUOUK7wxvCu/LFSnP9MFbpTJ2Ca7TFSkyXvCePYsMhtYJ4r7w1mqr\n", + "KY975/RxM1SJikCBRPEhY8szt/CC+dxXv/rVkf979Wa8eaBfvd/JVPna174mqVzHqnVfrVpOOeUU\n", + "SdLmzZsX/D8Zb3j7Pk6IK+Dv3Beqypo1ayTFlcujjBuvXjwXlB/GVt86Rqh5kaLFmCZLiIxDr6iN\n", + "5/6KV7xCUmcTH/3oR0c+71l9USXraOx6Ri0K1J133rng5x2vEcZ9+/3TJ7SP17ZzGKPM6ShSUU08\n", + "zwL0WnNRFpfvO+kZoEP3I42IMqNbQVVGGYwUGz43tLbdUPyZFLUD13v00UdL6upDLRVQPIEs16wj\n", + "lSRJkiRJMmGmpkjV7GJeUqJQDNwD7su999674N+pSowXxXt5vLTaSutRxD/xC3htKBPUsiBOIPKm\n", + "qFdV2k8I7++EE06Q1HmTpRohU0jsbAJbQnFze0AxbN13y+2PdnZFiuq+Xq8J3DurtRcUz9o9D8ft\n", + "naIYleqpEbeCffnY5n69fVBfUPTY1+vKK6+UVL5vlLCF7htF6phjjpHUKVJRbFEEx4kUKZQjj/Pi\n", + "3gCFAaWFsUfNLaA2GrY8qf0dI1AVAZUVG45U/1pV2Pd+I3YJUBdRYmorn9O+qLG0r9te37cWJSIl\n", + "yhVFVGPmXK8Yz30Qa4dyg41jv74v5bTwfo/aATsqPUtq9/UcN7Q37YwihYJaYo+K1Le//W2deuqp\n", + "Ovzww7V69Wr91V/9laSfTRannXaaDj74YJ1++ukjD5ZLL71UK1eu1KGHHjobOJgkSZIkSfLzyB4V\n", + "qb333lt/+Zd/qaOOOkqPPfaY1q5dq9NOO00f+chHdNppp+mtb32r3vWud+md73yn3vnOd2rnzp36\n", + "7Gc/q507d+o73/mOnvWsZ+mRRx6Z5+VIo56Ix+BEq1G8NL7rigHeTGlfqFrwJlAG8EpRpPB6or3H\n", + "nCjWg/vAs4fa/bdYNRMfQNaWg5d3xRVX7PF4eOHjqvDdmq3Yuk8WXhDKE++78d6osjt0J/ioPVA7\n", + "+qoHeM0oOiiPtUqUX1+r9834pJ+wc8ZRpHQybj02i0ws4HiuHFHFGkVvx44dI/dRAnteSA3BJjgm\n", + "Ns0uAewpt337dknlOePAAw+UND+OLRor7G6AbbDv40tf+tI939T/B+WmbyX1vvhcPTQu03EFys/H\n", + "XOYVpVH4XNEC5uB77rlH0nxlhLHAMwRQNVGIIkWE/kSdrZ3zXYXlmYIyyX6fgAJ3/fXXS5r/FmLl\n", + "ypUj9zPuubqV2orhPMui60TFfsYzniGpG2dD92KshWcvz3bmtLHESD3lKU+Zlbye9KQn6bDDDtN3\n", + "vvMdXX311XrZy14mSXrZy142u3HjVVddpbPOOkt77723VqxYoYMOOmhe+m+SJEmSJMnPC9UxUv/8\n", + "z/+s++67T8cdd5z+/d//fVY1ePKTnzzrGX73u9/V8ccfP/udfffdN/Rm53oMrKrxZKOYDPdmnHFn\n", + "ZLDaJnaKzBvPrEEJcrgvvDoyFvBC8OBpPz7P8fG0XVnwHdrda2UVTXtwvNr9ktxriN4T8z4fJTDq\n", + "H7y72npPCymYNbDopz+IuXn00Ud7HQ9caeJ+jzvuOEmdsgKf+tSnFjwO3qnbSykW0Cl557VKFF4g\n", + "yh12ivdYimPkOvDivv3tb0vqYvv8c65IMd45L+MhikdysKOFMsb4Gyokbc6YIL6SuSZS//g7Y9Nj\n", + "XlAqGMP0MWOQ8/KT68GGUEjI+mOMlua6SdF37PXFFa9t27ZJmh9HGNm6U8qa87nNlcjobQj2tN9+\n", + "+0nqbNkVJcfbE9v2uYC/c55I8UJBw94YW9yXzy1DaxeW8PGwfv16SV0dMOyZ8eNzgNdmZA9Ibzfa\n", + "y2MPoVQvrgTtR3sxh9VmQFctpB577DG98IUv1Pve977ZBoFly5btMT0++t9cSfD//u//wkDdJEmS\n", + "JEmSxeS///u/ZxfwpaD+4urlf//3f/XCF75Qv//7v68zzzxT0s9UqH/7t3/TU57yFH3ve9+bjSHa\n", + "Z599Zr1S6WfeF5lOzlOf+tTZzBm8Mlbh/p66NpJ/aA0Ph9U9q1MWe1xPSVmJvB9XhmgzVtUoBFGs\n", + "kytveBusplESuD4ULFbzc/uohkiZqI0TaK3z1KrQAF7aAQccIKm731KNmxJ4ObQ7SpzvkF6bjTf0\n", + "emq98xLYNVmOeIu1O77zedQT7MTtIqqFdN9990nqsmJR9hhfxEeU2nUh+6LPGBP01a5du0auqTYO\n", + "jXtDOQLmMK/3Q9txbXyf2AvuleuJroPrnxQ+t0aKFPfN/dTGxrTifR3VJTr00EMldZXZI8WFOZzr\n", + "97mvdswS49aKH584TtobVZY3N8SGEZPH2wCekfzkWcIzAzshhgpQRnl2uSJEf9e+zfE4ZH82RHGi\n", + "PAv9mehzvccF0z5cX2R3QxWphZTrX/7lX54976mnnjpbJX8h9qjj/vSnP9W5556rVatWzZbwl6Qz\n", + "zjhDH/vYxyRJH/vYx2YXWGeccYY+85nP6Ec/+pF2796tRx99VMcee2yvG0uSJEmSJFnq7FGRuv32\n", + "2/XJT35SRx555Gx8z6WXXqoLLrhAGzdu1OWXX64VK1boc5/7nKSfxQts3LhRq1at0l577aUPfOAD\n", + "4au9Jz7xibPve1FgeN/MqhKli1UwsRglampU1YCahvfIatk94FrFJapTBVHWk+OrdrxhvBfay7Ov\n", + "+lKq6jyp2iytUAEctmzZIqmLuxgK3gneJJklvNcvQTtNqroy1MZFoBxxP3i7rZky3BfjwNWDKPuU\n", + "2DXUGLxN1AZi3K655pqm65E6m8XDJI7Qa4wxZlDnUJhoO2yce/M2jSpPo0R4W7jaV1JEJhXbAigS\n", + "XKfbJqou87grEUPfAnhVeo+jpP39PFzXiSeeKKmrx+XKHgrPYtfjiuA+GHOubvN3rhf7ZUyS7YfC\n", + "hv1hJ64G028eOsPx+cn/vf08HtOfJd4vZOB61iX3QUwUMVQlUNBKb4HIuqvNdPc5knpdxEHTDrX2\n", + "vceF1EknnRRO+jfccMOCf9+0aZM2bdpUdfIkSZIkSZLHM1OL8P6v//qvWW/EFQ1/H8oqvVYBWWjv\n", + "rT7wPh3PGS8AhWrc3mLt+3qH9nKvkdU03kxf5Si6z6WiRAFeBvEMKHx9q+S6183v2CXt4vZZYtI1\n", + "X2rt0mOk+sZu4X0y7jwhpbRXHvbre1f2jXeY+91ozzVAqWJM45GicGDjtZXQITofY3xaWXlOVG8J\n", + "iK9EuUOFZSzUZgIDigTt4woD2eC0T2TL9AfXV7Ldce8/2RfGPrFB/tYFeCvhMWn0l7+9Ae8PFEf/\n", + "nCtjwBzKTxSzKC7T+4eYPz8ucwSqNxnPKFhR3G7t25TaeF3gvrh+5kBiyhin1bX4ms6eJEmSJEmS\n", + "zDI1ReoJT3jC7PtZzyRglc4qFu+ldnU4rsrmrhzwHhblgZgn9j2qJaqn5IpHKxyX1TbeGu+Naz18\n", + "st7Y92tSGTrjBi/CK4Xj3bVWCndv3ZU/97pqFVP37qa1v5QrR7XxBQ5KLePD7cUrpnumEHZ6yCGH\n", + "SOq8wiHFfDk2c0vUtswVeKRRnZpWovPV1lCjDSalXkY255WcUQpQ7hhbeyp5syeY01H+PAvS+43+\n", + "YAwzJrEp4maZ84BnCzbO/xerUnYEyhPtR4wTdsj/6Rd+Ygdkl0Vj1RUp5kDPxsQOuQ7al/amvUpK\n", + "n9cw9CxZByWRTF0UodZMcqdVkfJ2oh2og0kMFzsflEhFKkmSJEmSpCdTU6Qee+yxWe/Eq/+izPB/\n", + "vIiSx0+WXVRNfShr1qyR1MUJ4D211j1i1e5ZXHhbfTNhvCI8XobMmIyBAAAgAElEQVTX4ijFYrWu\n", + "7pcqZIPineKF9G3fkppQUqKwa7JVwVWBcWVEEYMUeYfYBV5x35gk2pe4lui6uS+8Pz6HCsI49xi3\n", + "IZQqVaO+cg3jiq8sEanSjNGSEjW0bg7t4jbi50XJQDXkvFG2YgnuG1txZQulhfN6PCrKIbbD9aCG\n", + "MrfSjqi/jE2/v3Hvz1qC8/tbGOA6iYHimcfvPGuiucZj80r1l2hX7p/+od1a+5n+KL3F4Bk9LoWw\n", + "rz0CawcyhYmRrCUVqSRJkiRJkp5MTZH64Q9/OLtqxSvwCsieEYDXyGp+sbPGuE5/L/z/2jvXYL2q\n", + "s47/jxqnzoRRrCVAoyTmQu4nKQmXlhppAcWpFAzToUjLjKnOdMZWgRYGtXraacHWOkipVqelDoOj\n", + "7YdOAREiiqEkaWkICRASC7EJ5Za2I96KdUrV1w/4Ozvvc846a+313k7C//fl5OS8795rr9vez38/\n", + "l1j7LkesBYfljbUS32tH355Unqzoe0I7sXpLrVeUG6w7fNaOFvC7wDoiUqRU4Un5j+RqBabmI/1H\n", + "e2KesDiv+5WhP2cVEjGDOkA7mYe5+fIzP/MzXd9LZemOPmHMf+Yr2b75/YknnpA0WLWAMUR9xWen\n", + "39URUrC2cionEYyRXiIajyQ3R+gP+qnXaEP2JH7GfEOAjw5/j28ZYlRZWwUBhqVEQenbEtYmilSs\n", + "VlFKSvmKoATiU8aabbseSudHv3L79Qvyc3GvaOuzZUXKGGOMMaaSkSpSwNMwVgpPhVGRSlkvELMW\n", + "9xt8o/gJqVpikegjwk/ancqZwvF5aiaaDlDEsOCjz1bb2mwoJCgo5HYZFr0WsF6xYoWkpl/bZjXm\n", + "euP7+5jluhTUA5S+qAK0tfrwsWqbwwfWrl0rqfGVQyHCX+jBBx+c8fvkn0KRwqonoiinDsTxJUcR\n", + "1RO4rl6i9kqhzaiYqfqWOVjbrFHmHCobexxqXcoHirGIEcujpm3EaynRX5M8U/Qf48GexF6Hz1Db\n", + "XH7sDcOiNjdbKs9WW9rmJmwbJdrvjPG9+v7Vfv9tb3ubpGb9cQ8orZJiRcoYY4wxppKRKVI/8iM/\n", + "MqVCO74jVLBGWUGBSUXgYOHyvpwIjhRta8RhgeMLgiKANRt9pngqxvpB2cDPAOu09D0sVldKucC/\n", + "A6UMvwpygmAl83es3ZS1EvMxxRwkPKXTj/zkvHwvKmPRhyv6BkGtAsbxeU9PjpnSGo0RrguFlPkX\n", + "oytT8wjrhuhBxj+OY85PJfZbrRIFXA/zg/ak5gPriXmGlc240b9RqQVUBvqP/kIxJB8b/XDo0KH2\n", + "F9UjtUpUzLmWW9PscXHPgKi64yszLGrzQ7U9fio6kn6MfoTMVZSotsQ5n4O3AMx57lGor6xB5nRq\n", + "nNgDUtAe5j5rnL0HpZR7AP3C+eI9MY4f52eNs2aJUkPxyimO3FvxZ+QelqsLWwr9y97PvbX0Hn3+\n", + "+edLasaF/slF1DMv8F3Dd4s9t1RRtCJljDHGGFPJWGfY6ZT18lPzxMTEsE9rjDHGGNOaiYmJ5Fsx\n", + "K1LGGGOMMZWMzEeqH4oUPjb4WsUIF85xyy23dP1/bV0f3jfz/pr3qPhAcb7bbrtNUpMfiuy8+BDx\n", + "/pb3zrSfzxPFxPtifK74+5NPPilJuuqqq7rOy3tm2pfqF3y88NPg/TnXg/8C7+W57iuvvLLrfPiA\n", + "8X0+z/tmnt7PPvtsSc37bnxp8AvAJ47vk4/ot37rtyRJH/vYxyQ1vl70H59fvny5pKk+a/g5xMzb\n", + "cM4550hq+vNXf/VXJUkf/vCHu/qBfozRlqURVZwf3zJ8pejHYamznOdP//RPJTX+PfhH0D7qYdG/\n", + "+Ab+1E/9lKQmgz7XH+uc8fsll1zSdd5BMzExoTvvvFNS43cFXMOyZcskSQcOHJDU+FCwdvCJwe8r\n", + "FRWWGzvmPHN8165dXX/Hb4y9IRUpSbuuu+66Gc/Xb+L14SdKe1hLtXU4o+/O+973PknN3GSvS2Xn\n", + "x7coRiTj88IeECOQ8RG65ppruq6P/En4xOADlFIgok8P84R+wfcI/8LNmzdLkm644YauzwPHISox\n", + "FfnKvNq+ffu0f4dR7S3DPt9Xv/pVSdJXvvIVSc34pXy+8OniXhJ9I5lvp59+uqRm3TJfUliRMsYY\n", + "Y4ypZGSKlJTOFE3Gbyx/Mh0DVkesVRePC0QjlWZ5TcH5cvmsqPvD+XjqJUopFyHB94le4rwp6xgl\n", + "AeuJ/sRqi7XzUlFf9GOMlIiKA8RcN1HBilFZMXM3T/+oAihAqdwp9BtWKAoakTRYn1ijtCdas8wP\n", + "lLvYP1x/7Af6t21kU7+yUPcLrP3SWnb0e2rexvxtRCmOgqhEAW1nTFEcgDlZmyE7Qj6exx57bNq/\n", + "X3755ZIaizoFyseooR2o722rSqD40C+sybinxbWSUrxSufGi6sxelMsoTrvYU1CI4hpBmUPRePzx\n", + "xyU1ilfM8RbffqT2cPai1N8XLVokqYma6xXuGShmCxculNQosajPXBfrom1dWUCdRkmL/VqaGy9G\n", + "XW7dulVSuTIaM+tHOA71PktzMFqRMsYYY4ypZKSKVEp5wOJP5eDI1fOJx80pSCl4SsYa42mVn6m8\n", + "Tlgr+N5wHbGOUVRCIlFBox3RakHZiZ+vrSMVrytlfTJOWC1YayhD+IRhxdAerE76CWsspZCkrIKY\n", + "wyVm5U35NzA/UDrbZn5HEW2bzyk1fvjERWs9B1ZlLjP6oHMDRQZdYaAXyMsTFal+1+3EByvOwVWr\n", + "VkmSHn30UUnSAw88MONx4h4Yc+Cl5lQtqT23VomAuDZT7c3t1anM1cxxFCV+xjxBOVDX416EcoPC\n", + "xPyJ/qi16jPtS1XJQEHJZfsvzTTOnoE/5MUXX9z1k73lrrvuktT725zYLxyf/i5VXqMiVeujl6Nt\n", + "RngrUsYYY4wxlYxMkXrNa14zqcjEp1We+lE2IqlIDkhlzW0LVgdWbLSWsHqItIB4PXyvVBkjoida\n", + "gSkrDqu3bcb2UlDmUudFEYr9tGHDBknNOKFQ8feYIZ3vl9ae4/w5ZS9F2+y1kFKiiAjDxy0qp6nx\n", + "izX9SintJ5RCwM8Cv6FU9CHjgXVWWscq58eBShD7J7Yzqkb9AAu8X6R8O4gOoi84L3137733Fh0/\n", + "F2Hcay22SNzLhk3KbzY192gvKmj0NSqdQ/ggoWzhK0R7UA737NnT1b5LL710xuOi8ED0FYuk7mnM\n", + "r9w9pFYRw5eP9qGA3XPPPVXHi3C9+NtGxS83jxmXXuuwDgorUsYYY4wxlYzs8W4mKxyflVQETu69\n", + "aPQNStV0i/D+lfxIRDKQ4yVaAygq8Xyl0VAp2vojYPXGSvO0r63igaKH9UCumwjKAgohyhR+Fvj+\n", + "0A5+x6rD6mO8UUCiohitzlh7rjY5P+3ul4JJpEttnrJBEdWS0vkZayyWWrtRSY6qTexv1BvWHRDt\n", + "2k9linPFCNW2fnKQUiexoFFLOV+qHmEprBH6mN9Z47mI4AhjEetHAv2FwtPvCNSoBrOGYn3M1HlX\n", + "r14tqdkDUTm3bNkiqbxWIaorexWglJBbDmXsLW95y4zHQzmJSgtrIaVIReJeV/u2IUZ2RxX6vvvu\n", + "6/oZYa/nOLl7MMoWNf3IWcd54/hy3Hi9QB641L2o37T1PbQiZYwxxhhTyex84dhnUIxS79+Bp1Cs\n", + "G6LK4tM3vhz8f8xJURstF4mRDVg58fj4VPF5rEiUoZSVkYJ+wtpNVUwnk3jMAM55sbrWr1/fdTxy\n", + "f/B5+hMFLCo60XorzSieAyu0raKFLxRqBMoW1hdWMspbtGpSPmezjTjuqBU5azqqNDESKaomrB8q\n", + "rw8y7xYKUb/9CCMxQrVfYLEzZxmTqKS0JSoWgIrfrz0tEvfitnmzHnroIUnS61//eklNpHRbcqp9\n", + "rI7xyU9+csbPM7/+5m/+RlLjL9rWR4+9DqUO5bRtZGzM3Vca7RbvJeyZOb9UPs9ex9uc1NsW/EpT\n", + "GeuZ9/2KTs3R9jxWpIwxxhhjKjkqFalUVFsKlBze2/L0G+H9OtlqqfmGtRJr0WG9xafnttFzHA+r\n", + "D2UDuE6UsqjYoPSg6GAt4EeRespPwXVivaSsUZSEmKeI82LN0J5vfOMbXX+nvRwfX5joy1YandYW\n", + "/CdKI0EYJ6yraMXu3btXUjNO4+PjkqbmfqFfZjvM31QW4BSxP6PKkPKDGEYG+EFFtkZQ7VibpT4x\n", + "OfDRQTVGSSrNHxRh7TG3o7I1KCUqRdv8PezBX/7ylyWllZIYgXq0wT2PvbE2V1tKiUJB4l6BksQ8\n", + "w6+y1F+R87BX8nsuOi+lrMaamIOmNEIZrEgZY4wxxlRyVCpSWB1RyUmBooFyghLC03F8SuYpNEYX\n", + "YUGnFC3g+DlLnkgIopWwNsi3hI8N501Fg6G04WvEdXLdREygtOXAyuO4qWy78fPA+GDFfO1rX+v6\n", + "O9eZ60eIKgK/87M2uy3WTapWI/MqWmepKD/Gm1pz5KZBqWJeDUph6ze5CgIp4nqsrSwwCHrNhFya\n", + "JZ6x7rfyhX8Zewxzs9c5FVXhUYFylINxQGXP+TnWRvYOG66LPYZoNdZQ22oKpXB8Mrizh1HvtTT6\n", + "kfazt8a3IoxD6l7GPSyl4PbqC1hKW3XcipQxxhhjTCVHpSKFjwlWVC4vDh74vB/HmstlWc29h+bp\n", + "GOUGYv6dFEuXLpXUKFKxVh2KQK5OFNfH52k/VkEqSizlq4KiRP+movZSoDgRQYNSE3P4lLYH6G+s\n", + "/F6t/bVr10qaOv5YgVw37Yr+JLG9/L58+XJJzbhw3Vg5vdYtGxa1/jFx3UQVp19Rl/iNzGSll9Yj\n", + "HBTMFfqgbSbyuJcwJrGaQb98fwbtO9Yv2LtLfc/6fV0xt12/YFx5CxDzLg16fMhzhnIb8z3liDkI\n", + "uZeU+jalouViZPhsw4qUMcYYY0wlR5UihSc91mXbDOK8T+cnSk20GlGYeDrGSoiKBO/z41N0qXXI\n", + "8bAqsXLIX0Um8NLrQpHiulBCUr4uKWUARYzrapv1mevi+6U5QFLtoX+iEsQ8wNpJKROpCAyOF608\n", + "FDXOy3mw0uif2F6i+FDgyLNVWjNxtkJ/R9+7FPH6sE77bb2z/ttErLE2aGPbOo2pCM9Ufh7mVk6J\n", + "SkXW4rMC7An4F3IdnLdtRmZgLcSI4WFTuqe3zQxOVFqvikb0TeN4qaoZtVUTuIcMO8oQP9BaXyz6\n", + "GSWYtymsg1wtx9T4s+7wKx407HWlvnVWpIwxxhhjKjmqFCmecmuflqO1xk+sBqzBmP0YC5ynaayE\n", + "VNRZ6XtsrgPlAqUDReP2228vOg6K08GDByU1ERe1kThYV0TbYYXFWmgp6Ff6IVq51C5s2x6sA8YL\n", + "KyUXHZmyQp9++mlJU6PK6DcUpmhtprIg871t27ZJkh555JEZ2wW1KkIK6lHRP7WRLlinqCA5Xz2I\n", + "qg1qDD6BUJuFOp5nOoUspZ5RPxN27drV6pyptZ1SsWPUUmquplTfGDEbc+ExN2Put9K5RIQw31uy\n", + "ZEnR9/oFewvEvZ3+Y82n+i+l6KEap5SO2L+MW6r/+H98h3LqbL/zcJ1++umSpH379knK149tC3tF\n", + "SgnjLUdqHGKEM5+bN2+epOZtS1vfRd7+UFUC8Cvud7Qpe2hpJnorUsYYY4wxlRwVihSWJ0+ltYpU\n", + "tBpT/hHx6Zana5QDnoKx0KNVVQqZvrGasKKpXF5KtKpp/+7du6vaBVxv26g94Gme8cvVs0oR31Nj\n", + "5WHNEGWHlROjBPEfifMGpSVasW39ZuL3SpUoQE1gHsVoUNSHUusWaxKlEtUBOG7OzwQlKadEYSXi\n", + "C7Z48eKuv5ODBv+J6CfB9Z955pmSmnnLuJ199tmSpO3bt3d9b7r+yGUuJy9O7R6S8plgT2BvYa+i\n", + "7xkL5mYuQhWi6s33sPzpS+Y611Wau4ss/MyJUr/MFLSrtH+jwhBzA5YqLrS/rT9n9GnLVTmgXezV\n", + "qP9ta+i1hb2Ytw5tlSiuizUW5ytvH7gnRVatWiVJOu200ySl5xd7D/OS/nnTm94kqVEA43xNccEF\n", + "F0hq5hWqNuuGHIn9UqSoaXjOOedIkv78z/+86HtWpIwxxhhjKhmZIvXjP/7jxU+RWJel2VVT1EYN\n", + "YZnjUxOpVTCALK+pbK85yKcTawDy1I5SkLN+eS+MotBrHS9om4ukFK4nZgzHWktZbVhFzCsUxxxY\n", + "dfRv7v0+44KihwKUyqQP9DfqAxnSsbax9qLfyIEDByRNjdLEBw/6VfeNfouRS+SiiWDFRmt2zZo1\n", + "khrrc+PGjV3tZH1FRWo6cv6J/c4MjYJDH8RoK9ZenCulubSiLwpjSx9GtbetZU49UZQJ2stewE/U\n", + "UuYYigZ7BJ8D/CBz1xmVnNe97nWSpK9+9atF7addKGv0V/RxKvXJSc0f9kT2shjJHYl+nL0S/XpL\n", + "QRFFSWJvQVHjnprLbUe/7tixQ9LUSHPg/5kfwJ7LmmZPZD1Gf87Vq1d3fY+M/iiP+FzFeybKFesy\n", + "VtXIEatylGbatyJljDHGGFPJWGcERYjGxsY0MTEx7NMaY4wxxrRmYmIi6SNpRcoYY4wxppKR+Uh9\n", + "6lOfmhKRQlRPLuIklak6guqF5z1+C/E8qczfvI/l/S3vw/Fx4b05n8PH49Of/rSkJsIgZsOFBx54\n", + "QNLUjOb4O/Aem9wutB8/CHxJPvnJT0qa+v6Zmm8c57HHHuv6HFmTiVTg/TTf53p5j33RRRdJkm6+\n", + "+eau/68lF2HF+P3RH/2RpMYnh/flOXJ+ETFS6Z3vfGfXeSGVowa4DiKQuB58nPCriL5RnOdDH/qQ\n", + "pGZe8l6e9/Wxn7kucuykcr7QbtbJ7/3e7017fb0S1yPtev/739/T+XLRhTFiamJiYvJcublVC9d6\n", + "7bXXTp5zGHCetuerrTUYzxf7M0ZgYqnjJxf3dvYg9kD8VdkjL7vsMknSRz7yEUnNmmSvi/m5YP36\n", + "9V3te/jhh7uuN/po8bnf+Z3f6bq+QYGv1G//9m8P5Xz0M2v9rrvukpTPl8Z8pt8/8IEPSGrWND5J\n", + "rDnWwf333y+p/fwcHx+XJO3fv1/SVF8zovHw3Yr3+tr1UEvuPFakjDHGGGMqGZkiNV1W8NLcJ23r\n", + "JWEVYJ2ROySlREEuuomcNDH3Cnl3+MlTPOePUU3kBkmB9UZ7YhRdjEbEevvyl78843FjtCBKQlTe\n", + "AEWqVyUKxSXmcEmRy1yeImeF059to9hQxugfrHTmNDlfOG6sjxZVEqxm5mNuXnJduTpcKSu+38T1\n", + "WJtJPZIbl5kqyqPupiJtSyErP2NdmwstlTeKHGilKmtb2ipRKeKcZa9mbjPmqWoPzMG4V8Xxifmj\n", + "cnsEf0f15fsoZbG+ak6hJPqvbR1XiHmw1q1bV3WcWuJaz+0lsHXrVknSxz/+cUlT1zT9x72iNJot\n", + "xaOPPjrj33P3xNmGFSljjDHGmEpGpkidcMIJxVYYvjzk5dm5c2erc6WsoV7hqT1aVfhExXpbpYpb\n", + "6jxYs9HXKkXKPwJfHqxHrJZ+1W3CGkz1NzX7UjX3+qVo9AqKB/XZ8FnCP2Tv3r2SmnFGrUBlYLzx\n", + "Wzj33HMltc9cX0utGhHnTWkWbuD6B81M15dSolBQSpWl0vqCOWLfoZhh2Q9KkRo0KC/4tLStn8jc\n", + "ipTulY8//vi0/8/es3btWknl1QZy8yJXaw61mn45/vjji847KHhrkoN76nXXXTft3/GR4l4Wc9NF\n", + "2PNGkBRgJFiRMsYYY4ypZGSK1Le//e3iiBKUAKLL2ipSWBEoRTETNsR6TaUWfbSqeHrHGuF4pe+r\n", + "I2SnRTGKPlIoJ1wn58WqI/KBeknULiNigujBCO/7OS7Qj6mM7oxTSpHK+Tz16tdBu1Eya9+342OE\n", + "9YWagZWXsraiusD1pqxd/DIYR8at1jesLcz7mG0Y5RM/lJxiyTzhegZNqUJ2JMwNlAPaHOtv9su3\n", + "KAUZpXut1pCCaLi2ClFbqM1W61OUioTFr5S5F49fGpUZlaicQpQb99yajGsE362zzjprxu+lYE9o\n", + "m9Ec4hrJKUVkLo/wloH+IyN+ilIlircjfP6JJ54o+t5sw4qUMcYYY0wlI1OkpHKrDyWntqYdFj5K\n", + "ClZMPD9RQm3rI8W6QihAPMVj4bf1QcJ64PupfsB3jPpE/D0qQvgTpPwKAEWB/olWWK7Ces46ra0p\n", + "WAr+CaXzhX5OwfzhulP1tXKQ4yaCnwyKUIzKq1FepKnRhSm4nhhx1TY6E4UZ3zF8wgZFrNNWQlSA\n", + "onqYU1uHTW2tNmqr4Y94++23961NR8KY1yomEWqroRSmfJu4rg0bNkhq9qgvfOELMx4fRTIHamzb\n", + "NRAVn+jrxfWVRizTr/ig5dT1WDc0RhHW+izhJ0p/4Cea8ymjHzlvrAXZthZeCtYJ+al4i5CKIu03\n", + "VqSMMcYYYyoZqSJVCk/Z8Wm7FCx6rJacNZB7745PFIoTVmz8PtYAPk18DmUjpzTwFE/Fdd6Xx6g2\n", + "LHOsH3zASq2eSDxOJNfunN9Hv6IDc5RGZpVaaVGJolI9Ge3pNzLNR1LWKN9DEUV5ZL63HUfmHdZg\n", + "rrJ77TyJ0P6cAtaWVNRg22jC6cDvjba3VaJKVb8U+IjgSxP3nugPWUqsXsBc3b17d9fnatuPior/\n", + "Jj4zrCXmIEoBKivXw1qIezpzkT0vBVUa+FlKaXRkVNhQYLiO1Dzh+tjj495Su9ZK/Tyj4obKXRsx\n", + "DiiErLWUAokix72K/ujV35PjxdxxzCPmGVGFKSUKP2E+XxrNmcOKlDHGGGNMJUeFIoW1lMvUnYKn\n", + "Vn7ylFwbRYeVwdNx9GPAeuE8WAV8vq3VS6QECljKbyJ3PUTyAD5U8b1128zxbRl0NmcozWVSm6WX\n", + "rMXXXHONpMY6Jkvwvn37uj6/cuVKSVN9pWKkGFYr86YtKGczZf6uIZcfjHXar/Pm/JVYF0cqj7m6\n", + "iEDGchQhfDXa5o3qVX3D5ySlgrfNug/0HUoCkZkR9qjUdaQyfTNH+X5cY8xBVFHGkJ/sxamceLV+\n", + "iP2CdqKY0d6cL1icd7X3mFqi2s/49apIsS5OOeUUSc38itUV6CfuIXyv13xS7OXcWyEqfCm/Se6Z\n", + "tK/f9x4rUsYYY4wxlcwKRQqfn5h3KT7d12YmR3HAOuA9Mk/Jbd/f8j2sxeijwdM41mbbvFQRjs/T\n", + "eG2EDO2g3TmrrzZyJQdRjoxnLz4uM1F63NoILZQl1AysIyKJoiKVq/sWrSvGK/qxoDJgpaWs3tz4\n", + "xoieHIwbVmhKxehXZvOcr+J0f88pUbB48WJJzVrq1WKvpbZ2Xw7WFopRKjI1d92okNFvMo49e2xU\n", + "KPg95gzEhyXlA9YvP7teozBpL2usbbtqVeV+wfj1mp8JHz72HsY7+sPGnIrsMb2OJ3tjKhM+pDKu\n", + "s1fs2rWrp3aksCJljDHGGFPJrFCkeOrn6Zmnz5o8MdPB+1F8N3iqxW+Ap+VSaxZQsuL732gp83tt\n", + "tBoKElZhtPpKiU/rRDiksgSnlCiUiehbVQrvpwelRLWlth1EfNx1112Smjxe+BFEUupDzlqLfiyl\n", + "CmouhwoqQakihVWfq4XYaxRgjNJNHW86Ja40ko85z7E5Fz4lzH36ph8RgsOEOcJaxcep7XWkfGDo\n", + "N/YkoveolgDsqew1kX7t8SnaKlFxL+TeVPo2Iaq8o/b16leENOuB6MHUXsb1U90DRZB7Ra8+Y7m3\n", + "MaNan1akjDHGGGMqmRWKFGAFoEyR/6bXrLlY8ig7UXnqta5WfM/PUzE/eXqvtU74HlZm26duFASs\n", + "BPxD6Ie2uTRKswOnqFWySmE8aqMPY7Qf/Ye/Q4ykQuk7/fTTJUmLFi2S1Pi05fxQOF/KZynV37mo\n", + "RNSD1LxrqxzxedSFVP/26vfDeq3xq6DPc5YvysPy5cslNXsAY7xt27auz88WJaq09hpjH2vL5bL4\n", + "RzhPaqxZC+zZKYaVOy4F0Zm5tw45v7wcca3V5gHrFzn1uBT2IPaA1J7CPSrWf6X+aq+KVIweHbRS\n", + "nKvNONmOgZzdGGOMMeYVwEgVKfwSsAZ5n0rlbyztVI2yFDHTOFYV1ki0ymJUX1uFKj71Y4Xw9M51\n", + "1GYRJhsrT92lUXRY17Tn1FNPldREVVG5PWWFpTLJD6t+US1tlShqFQK+czHaMhUx8g//8A+SpJ//\n", + "+Z+XJB06dEhSeSQY85V5hKKDVZdSnGhPar72u14c6ygXOTNoTj75ZElN/bHt27dP/q3U4iVzNmuR\n", + "tYVa2mvem34R+7pUnadPYoRx270tt9aZ46yhVPReW/DtwmctZk5vC75Y/crinwK1FgVu/fr1Az1f\n", + "jl5zunEPYVxROlGYUnVbmae9RgvmSClRpW8DUrDuSqupWJEyxhhjjKlkpIoU1iCWOHWvcpZ2CixU\n", + "lBdAIUCp4PgoNZwfZaDtU2z0YYkZl7nO2krutD/lZ4DCxPVFHx7eZ6NkYS3m/Bb6XTMNRh0BFX2o\n", + "otWfsqZT8wJl7/bbb+/6vRSUo9jfWHUpFaJX3z4ozQaONYoqsHbtWknNutm7d6+k8vVTq9CiKM+k\n", + "LnBNrDnG9Oyzz5YkXXHFFZKaNYr/IIrWTTfdJEl65plnWrWt3/S6Rnbs2NGnlkwPY9CvmmWAMsjc\n", + "71UhLFWiUvUwc3APIIccSk18O0Ltw37Pq5S/ZMwE3paYexBSb0V6zduVorQaxsUXXyypecvy13/9\n", + "163Ow56EH3Gpz5wVKWOMMcaYSmZF1F6sFI5S0NYaI3oq1k6LCkPMpM57ZM6XyqsUIV9QzOSMX0H0\n", + "1WkbEcLTcU7JQlHhurgero96R9SC4/NYR5GYzbjXSJZIv5QolCXe12MFpeqlpbLs9urPAffdd5+k\n", + "qUoRkSup/E+DUv5yUPuP+YWSFtvJPEEdwFrD2sVqRdXJKWXM09x1p6IYWVfT5SBizfCZaKHjO/T1\n", + "r39dUmNZU4eSuT5qJapfsNbph9ni+8U45epcplTz17/+9ZN6kn8AACAASURBVJLq668CyuW5554r\n", + "qfFxYk/Ax4d+w1+VOU4UGW9DYmRvvAdwvaeddpqk5vo4H+dhTZWqu8zf6COIL2CvsKdSozLlO9dv\n", + "JQpSShRvnzgv67ZtBnPWCXtSzIeW/X6rTxtjjDHGmEnGOiMwUcbGxjQxMTHs0xpjjDHGtGZiYiId\n", + "QT3kthhjjDHGHDOMzEfqSEUKXwvem9dmRsYniPfEnKNW/Yo5QXL0er62xPOR/wifEiJPcpEUREvi\n", + "H0L/cf38/3XXXdd1vkGT6k/8DMgx8+STT077/VSGc3zauC4ihDgPPjyf+9znJDX9CvzOfMOniHbQ\n", + "3zGXCRFBmzZtktT4HHHen/u5n5PUROBs2bJFUuOX8Qu/8AuSpI997GNd7WHdkFn9yLxKRzKs+Um/\n", + "/MZv/IYk6cMf/rCkxg8BnzagsnwEH0R8pejnmNcLf5Jrr71WH//4xyU1fl/0Ob4PMav+L//yL0tq\n", + "/K2IcqONrCXWAmvjPe95j6SmL1P+XP1i1HvLsXq+T33qU5Kk8fFxSdLu3bslNXOKKE98dJgnK1as\n", + "6PqdvYR5EOtSvve97+06bwS/1H/+53+e9u/kTnv++ednvC72pquvvlpSE33KvCXDO75Ojz76aNd5\n", + "aT9/j36IMb8XvkS141eaqT8Sz5eKPGZ94xP54IMPSmrynm3cuFFSk6eM/kidL4UVKWOMMcaYSmZF\n", + "1B7WYq/uWm3rSOXoV32oXE20fhFzfUAukiKlAI66PlaE6DcUn1z0XyrDOQpRVJoi+/bta9vEIrgO\n", + "rF2sQKLmsJ4Aa3Lnzp3THg8rkQij+fPnS2oqBKQUqkERI4di1CdWNWpRiqefflpSo5imrPUjI7+Y\n", + "E6kIyQj5j+JYc25AWUhFJKayvdfmJYLa3HNHO9SrRGGI0W2R+DYiknq7EKte8JNxY1yZT/xMRQui\n", + "HKHY5DJ7o8igXsc5joKUi5xmDaxbt67r/1N7OO1DoQEU1dS8Q9GlP1OURr73WkcXUjnw2FMfeuih\n", + "rv+nji9RfiklqhQrUsYYY4wxlcwKc4en/9zTae49cvR/GDWxhhtPwZHa98SltPX16jel1kkOrEGs\n", + "prZ1pGI+p5SKkMue2yvRjwbFJVVZnRwuqfxYsSI6/g05q3FUROs/BeOVAkWR/is5JqAApFRHFKjV\n", + "q1dLymfuTq1dfK34e9us97N1DAcNyl/0+4ygujJeKUUqtfexF+Abh78hyia593K+ScAen/p83AvZ\n", + "w/DnRJ1GYeK6qW6RAqUu3mNirjbunVx3ql9ybzFy9Uz7nXswR7zH0Z9kmE9VS0k9S7TFipQxxhhj\n", + "TCWzQpHKVWznvTOVtO+8886BtOPKK6+U1FgnRALcf//9rY6DTxTWR0r5gFIlCgs9ZS1gZfN0jlXE\n", + "0zlP44OugB7pt3WC1dG21lz0qUpZVfgPDIqYCZ9xYr6VgjUeI2tyCtbRQmpfoJ9QfNtkpmcNsUZS\n", + "maNZS7m9CVK+UOwBtDkqUrnaa71WAUDZoF2jyqLflujHmFrrOWWFceRtRvQ/BMZn+fLlXZ/j/9es\n", + "WSOpUagijDMKJO3BdwviXsjcJWqM6yTjPvOU4+fGL6d4osBw/NTbgqhyR3J7Vb9qCuaiYelffOrI\n", + "uM552ePxq0UB5LpzPmxUa8hhRcoYY4wxppJZoUjlwGJvWz+nLV/5ylckSUuWLJHUWENtFSmi87BK\n", + "ctFJpeQikbDi4tM7Vsgb3vAGSU0kyJe+9CVJjdWdqug9W2mrrJUqF/hbDIpUdGmpfw9MV2vuaIL1\n", + "lYo2TYH1jHV+ZL/lImRj9FUKVPBSVQ/lA0WBNYhFG5UMlKJczjx8dtpC7bcNGzZIavagW2+9tep4\n", + "wwYlIecHmRtH5kpKsULxIQcbeyD9Tv8Bcy3mPuM8vH3gLUApqahQlBPUZ/awqBiVriWUGY5LPqyU\n", + "0pYi95ah7duCFPTnq1/9aklT71Gs96997WuS0m9r2tYAZPxSNQWntLPV0Y0xxhhjzCRHhSIFpZET\n", + "tZBTI+bWqCW+R069j24b1ZbLl5VSNvD9IrLj4MGDRefrN/2K4gP6GSt2tlS4T0EGdKzBYx3UEeYb\n", + "Kk2tvw7fm06Rw5JMrYFSyx21k+OlfKVQEogYjmowPh743tDmZ599dsbzQ62PFH3Nz9NOO63qOKMC\n", + "RYg1nfJly8E44ksT1WaUKn6iEDLu3HNQJlJZ+IF2oqTEqDD2Pq6P9pALLvo4MX74A6LM0E6UH46T\n", + "U8KY/7SDtcnxaC9/T/mRpiKbUbz6BWudyNyoSA0qUj8XlRixImWMMcYYU8lRpUgdLfBeP+YkSSkw\n", + "bZWZXBRgjkErUShE9EMu03Ut9ANRdqgBUSVoE9V15HEGRe3xiTziJ/1a+h5/VMTaeDFrNPOFiCdq\n", + "C2Ld33fffZLS6syRfjQ5PzPUMKJ88J2ISgO/5yzsGFUVLWQUDSzqqCanaoQBilavPPzww305zrAg\n", + "krnXahUxUjnlu0OephjVRR6inP8oPkxxz4t5wJhP3BsYd+Zhqj5ozA8VVXcUtVwmfPYe9uAYYU7/\n", + "pNoBqXFh7cZoxdq3SXGPxxcK6Eeua1RvI6xIGWOMMcZUYkVqAGA5836Xp+Z+ZTDvl5U6KGK9qkGB\n", + "8kR/4/eSiuTJ1eOCQefZqs1Wjf8C1uew84HVgpWIPwb+IKg3jB+Rb/iDMH9SViYZ3Nv4M2CJY4Gf\n", + "csopkpo1GfPe5KJ9GAPaHi11fE9QNiJEB6J4xLk5aHV0toIy0q+9LuVLw1rE94i9i70kpUQRdcl4\n", + "MxdjBHT0WeL43AtQlxln9ijmXYzO417C9zg/9TVzyhkqL75Y7Clx3uei7lLzkvXFuuhVIaIdqbcY\n", + "KHy9+kqhfEXV+8g6njN+v6ezG2OMMca8grEiNQ089WM589Re6tsTlRLAH+JYV6SgbeRDW7DqsCZS\n", + "OXdWrlwpqVE6/v7v/37G4/aaTTpHrzlW2vYr1jbkci31G7KJozCh1HJ+rocK7KyP6GuHlcv1sA5y\n", + "uYSOhKg5jo3vEmu9bSZmLHNUQuYibcuNFX3BNVmRehn2WpQ++pO50XYPZbyjwsha5++cN6dao2TR\n", + "LpQjxps1Hs/HeKOgMP+iqs7xmZfAmuFzKGFkEs/lwGM+8f3UXlerdnN9KGOsh1jntC2pe29p5YEc\n", + "UUlGGSy9F1iRMsYYY4yp5JhSpGozJUeo6Ue0F5Z0aSZprAasJp6ae1VoeErut+8R1jDWCtdda0Vg\n", + "heQiSNoS809h7fEeO/cenetcvHixpCZSp19ZeEthnub+jpUUow6ZB1ituZxEqWzAw1KkGBfUHtqd\n", + "ur5HHnlEUtMPROxgxfOzF18x5gRtqV2bKBKoocxRLNlcxChrObVWSn00jhZSvigpGNuYk4+5Uzr2\n", + "qf5F8cHHaP/+/ZKmqtvMExQk9kTGl/ahCDFno49TzHzOPETJiQon85L+4nr5f2oCspaJRs1B+1lj\n", + "XC/tYE9su1fE+U5/oCy2vZdwD0opbbSLaFyuh3t1vCfw95i3K94D2ipdVqSMMcYYYyqZUTJ45pln\n", + "9M53vlPf/va3NTY2pl/7tV/Te9/7Xk1MTOgzn/nM5NP59ddfrwsuuECSdMMNN+izn/2sfvAHf1Cf\n", + "+MQndP755w/+Kv6fXpUoILLi6aefltQ+DxHWD/3D0zS+VrV5f5YuXdp1/AhP/SgWpQoan4/KRan1\n", + "gNWMtYVSlKpvFYlWD9cRwWqM15XLUUI7qPSNNRdzp0DMRtxvcrlxUlmOgflZ6x8w7FwrzAdy4WDd\n", + "49eRgnmAtRzX4XRqBApPTqngWMz5mKenlOjvRZtzc4icWSeccIIkafv27dN+rrbW3mwlp0ShGKDU\n", + "MC5xL2GvYS7l9hoUoLinsRegclJbMSqUMQM6cH5+Tlf/8UhQrph/nIf5gLKCkoJqnmo/8w5lqm2N\n", + "v5RPIOPAvYF7YQ7uwexx0S+yLezRuXsRUYy8BYpKVPSjLa0sUNzOmf44Z84c3XjjjVq7dq1efPFF\n", + "nXbaaTrvvPM0Njamq666SldddVXX5/fv36/Pf/7z2r9/v5577jmde+65evLJJ3tOIGmMMcYYMxuZ\n", + "8UHqxBNPnHzXO3fuXC1fvnzyiX06q/aOO+7Q29/+ds2ZM0cLFizQ4sWLtXPnTp155pmtGhWzmWIF\n", + "xMiGCE/RPNXXgo9GLShQRBuRPwcfnbaKFJY7T/mpiBVyhKT+HrMo089LliyRlK8jFYmZqWPW3Bzk\n", + "0OE4zK2UVYWV3/a9fczRw7ikrCTm3aAgs/zGjRun/XtKiYJeoz6HrUhFa5b1nLvOqGShfM6kEJf6\n", + "zKBiYqH2qmYz96MSxfHXrFnT9fd169YVHfdoyRVWSzSyGQfUfJQp5mzMUJ5TolCKzjjjDElTlQiU\n", + "jpQimAPFhdpzjHdKQYlRfMwbFCWun+Mw5/EV4h6Yum7ylV1yySVtL6UL2tF2XcT8WYxvqjZfDt5C\n", + "5PyC9+3bN+Pf6bdcnq1aiqWip556Snv27Jl8KLr55ps1Pj6uzZs3T06a559/fvLCpZc7gZujMcYY\n", + "Y8yxRlFY1YsvvqhLLrlEN910k+bOnat3v/vd+t3f/V1J0gc+8AFdffXVuuWWW6b9bptaSTzFYnW0\n", + "rc/D03OtxU4ETq+5W3h6xmrgOnga5r0vn8MnhvNjfWBN8T2e6mszc8f39jnrJgffj5EppaTGl2zQ\n", + "EdpZqqjgf4ISyLyIFdOjgvbGN75RUpP1GgWL+cXvCxculNSMG3OdfmGcDxw4IKnp/7PPPruo/YMG\n", + "5TZGv7EOuY6U3wFw3fRX9OHD/4PPMa/x/0iBVU6uHJRPFMNecsigDMTaXbBs2TJJjQ9LTj1LgepJ\n", + "n2BossfkfDXarq3Y96XqMN9DJY70ujeyZmK0XYxKpB30G2ONDwxGe2rcIqjtsf4pMMeplYf/JXsw\n", + "48XaZx4wF6PCwRrnOo+sAzkTXDd7EgJEjBKkXfgu0Y9x7QLfT+2pMY8V44sSWFsjj/bVRsOS8y++\n", + "PaitCtGWeI/OkVWkvv/972vTpk26/PLLddFFF0l6+QY1NjamsbExvetd79LOnTslvbzhHem89uyz\n", + "z05ugsYYY4wxRwP/+7//q+9973v63ve+p61bt8742bHODOZ9p9PRFVdcoVe/+tW68cYbJ///8OHD\n", + "k0+MN954ox566CH95V/+pfbv36/LLrtMO3funHQ2/6d/+qcpqtTY2JgmJiZ6uERjjDHGmOEwMTGR\n", + "fBsy46u9HTt26C/+4i+0Zs2aSefI66+/Xn/1V3+lRx55RGNjY1q4cKH+7M/+TJK0YsUKve1tb9OK\n", + "FSv0Qz/0Q/qTP/mTVq/2jDHGGGOOJmZUpAZ20sTDVdustxGi2/D9eMtb3iJJU9QvfGfaRhLgy8T7\n", + "0/h9znPzzTdLanxLeC9PrhIya/MeOhUlyPVEHxyimK655pqu80UfrJR/RGmunRgdx/XF/ow1BNtm\n", + "CqcfYj9xns985jNd7eb6+B4RG7yP5/088ynWfeJ1Mz5O8KY3vUmS9Ad/8AeS0r5jMZIIv4LoS5Uj\n", + "1Z8puG78OdpGWZaeb+3atV3n27VrV9ff8aNh3FPt4Dwf/OAHJTX+Kqw/+okae0A0I/P+/vvvl9TM\n", + "Z9YP/iv4TWzYsGFoSneqL5ljy5cvl9RELHKt9On4+Lgkaffu3ZLSfn/Mtfe9733Tnm9QxOvDdwd/\n", + "w9Teed5550lqotCIUI0wtvhAbd68uet8/YJ28xNfm9xaWLVqlaTGJ4rxY87jq1TqQxTPR/UM8o5t\n", + "27atq33AWmfe4BfIXsmaYk/DHzPe+/h+rH1XG00X4Ty33XZbV3s4PpG29BftoR+45xN1SDuZb/h+\n", + "4ev1nve8p+u8jC97OtGx+JbRz9zTYtUO7h2cB989IuGvvPLKGRUpJ3gyxhhjjKlkZLX25s6dOyWn\n", + "BtZJfMrn6ZCn9ZSSgqN7rgJ2fArH6ovtiaCU5GrI5XJV8HSeq6NVWok+Xm8uUifVfzz90/7k03eo\n", + "cM918FTPU3wpfC8V4REjSfgc/491jzKViubC6omRIETqoEjlohiZJyif5AWrzd5bCuNaGolVC/M7\n", + "FamGMluaDZx5xLhgVabm/549eySl80WhgPGTebthw4ai9gwS5hiqbFxDMWN17oUAa6yUmCuuX3A9\n", + "KQUDdZC9IxeNyNrNZazmevDJRekqJTUOEfqZCFPOh0KCgoEaijrOXhf3DI7HnhUh6jAqZZFcdQrW\n", + "1Jvf/GZJ6TxmqPTMC35nLyy91+RgfLhX0r74Fop18OCDD854vNw9GRhn9gSuO+Ze5N7H/KP/+T7/\n", + "zzzYsWNH0fmtSBljjDHGVDIyRWq6J00sVJ6WURhKa93x9F9aYw6waFE6cj4+PE3Tzrb5bMh0niqd\n", + "s2nTJkmaTCuRsxbon5inp/Rp/uKLL5bUWJu5p/CYX6g2jxTk+hvFh58oJlh9ba1UrEuszpxVlIL5\n", + "Vls7sRTGFSup7fxuC/OJ/ok5aFgvuTxQEY6HtYhVH5Wv3HqPlerbVpSfDqoi9JrhHP8vfrI3xLWI\n", + "xZ4jp1pHUBx+8Rd/UVKzd6Aetp2rpVUEUDZy6ixrl+Pm+pv6oikV9q1vfaukZs6kwtRzfrf4xvBW\n", + "hL2QdqJcMOfZe3J+lCl/4NK9OQcKCwpX3BsYhzju+K71mjMxRbwnDssVm72B/ucehc8WvzN+7EEo\n", + "edzLHnroIUn5t09gRcoYY4wxppKRKVLTwdMgHvb4YpRab7VP+VjEWNoXXHCBpOapmveuTzzxRNf3\n", + "ajMrYx2mntKxQksrv0efJ66jbX9wnFqlDWLtvVKrJxdtCL36ChGFtnfv3qrvY7229QWrBf8TrPOU\n", + "7xLzhUgf1k30m8iB9c44sh6wvpkXKWs8zlsUUqxB2oMKhLVYWk6KdmFt96MoekoVRVFgL8r5P7J2\n", + "mZtEJdFXRCCW0tZHCrZs2SJJOuussyQ1Y9JWkSpVEvCJyn2+7ZpFGaLfGYcVK1ZIkr74xS9KauYC\n", + "Genbqrb0Txxf3h7w/6XqZ2rvZC2QTog9utf6rqVvbWBQStSoiQoie87KlSslNeuctxjc03lLAW2r\n", + "o1iRMsYYY4ypZGSK1NjY2BTrhad9LFUqdhMpAeRNSnHqqadWtQmrA6Xhda97naQmN0e/wPLGOsMa\n", + "oj/+8R//UVJ55Xf6CyUp+ifk8nORw4R24LdQ6h8RaatEAf4Jqei9Xut9YaVgfWAN0n+lYKVCSvGJ\n", + "0ZRt82sBCi1KGOsh5m9i3J988smu/y+t9wUog1wX84F1wTyK+choZ/R7IbqR+clxmW9cF+uN/0/5\n", + "rjF+KK/9SPqbinJj7ueUKK6BNc3xyInF2KBUxNxZKWpz6rFGHnjgAUnN2AyKUgs+RhXmVHciuFlL\n", + "rNXt27dLau4FKFClkaQRxo17EHOWtdAPPzypqW3HdeSUJGoM5lRlxjdVUy/Wp6ytRwvsKeQ6HBUx\n", + "6i764OGryJ6Bosn144fNfGRvRUFO9WfEipQxxhhjTCUjU6RmUjmINMHSxYpJWS+xUnMuD1AKrEqs\n", + "T55G8eGIlj6fb1vhmqdlrBN+jz5NsZI3xH7AOsCqilYO1g/+GzyVYxXTf7QHq4X/L1XGYvvaKkdY\n", + "XfF7sZI6f4/RWzmwWlBGiCJLWXspXzHOn8sKXKtAAePFvCCaMqeO4IfBOmirKNIvKJmPPfaYpKnr\n", + "gZ9EMjHv4vn4f9SVqDxHZQ3/l1Tleqx0+qVWtekncQ/AEo6RjW33plr1FdWUPmLNo0xEf89hEX2k\n", + "StcIn4v+gVdeeaWkRpmoVSfjPQT/wtL8SnyPPSOljKGcsefkfMZK/RtzkcvcQ9kb6E+OX+pPGzOj\n", + "t1W7eyVG0XEPiJnJ6VeuE2WTjPVcx9/+7d9KatYl0YxxPuSwImWMMcYYU8msitoD3vfy1EhOB54y\n", + "sdSxdPl/nqprrTierjkvljVRUJFUtFAu2pC/E7lBxAtP09TpwpqNFnt8SsbCT1k3+LagNFCfiad4\n", + "zsf17N+/X1J9P9I+/AxS9bYiKeWLcaC9HB9ro60yRX+SlylljaUib6IymSJGguT8LKKSBFxfabZq\n", + "5hf91dZqjHWxoiLEPOX6qCeXmi+ME+3CCo7+DIwz8y8F/QRtoxKnO2e/YK2x9plb9GXbaLLayFDW\n", + "MmNCny1atEhSs7f0Kxt/aX9yPhSk0jw9KVAjmYvMzdIIUPwu2TuZ622VQ+Z27vpRhlAGoW3dzEjq\n", + "vKx98irRX+xtKKf4FbNH4UPEvZZ+4SfRn8Mu1RszxUc1mvnFddNe/IBRYlPrCkUR1b90fViRMsYY\n", + "Y4ypZFYpUihRKCe8Z+apE58Mnv6xhHl6jj/bwtM1vhmnnHKKpMaK4CmX46esllzul5gZHWuO/ydv\n", + "UCpjeHxKLvULIPvt2rVrJTWKGIobNc56zTGCshQVmV5B2Uj5VdDvWN+MW6pCO/NnUKB4xYigCOoB\n", + "VjoKVFRI+T3nk8e8YV60zbOENZ+bf6UKMNYf6wZFkXFinTFOOSsQBQr1ocZHirWOnxZqX69+bVwr\n", + "beQac7XnUvSaAZu9bPXq1ZKaOdFvJYq9m+Pm1NPcWi6FNcZP1lCpIsXcjZG7/H9pP8Xca8zp6NPF\n", + "vEP17Vc+p5Qqz5rDn5N2Mj6MGwoTewv9wfWk1lj0E01VCIj3qFolK+6hKJq0j35FuYpqfkoR5vNE\n", + "7UWlMocVKWOMMcaYSmaVIoU1F58i49M2T5+8Z0YZKrVCcufn6ZynUs5fqnTlfFK4rmiVYE3xFJw6\n", + "TrTisHpLc51wfWTK5nj9in5iPIaV+TuC9VNq7faaGTuV34r8YzmFEusMhQUrMFptpZnu8U1jnsV8\n", + "VjlSUYFY/Vid5DvLEWsz0i4UL46HQsrnUvXhiFBifUSfqTbQFnJS5SIxU2AZM4bMPa6lrfJy8skn\n", + "S2ofMQtcF3MJX5F+KVEQ5y4qNErMoH1oUPVjxHEpvOV4wxveIKlREplbKIK5eqJcdy7vE2uBvaJf\n", + "e25uXJkPMeKZ32kv7WFNcd25SGGgH1CdmXdROcq9VShVThl/lDTa2VbJpd0PP/ywpGY/QMnNYUXK\n", + "GGOMMaaSWaVIAcpKfGpH6UDJSVkfWBm1EHGDD03bivA55YCn58cff1xS834WawbrIaUwReWjVKkA\n", + "IkSIyECRiRERvZKyylASS3OplML1EJmU80shX1Eqcqg0k3rq74xzzqpCNYh5w5jv9E+sTJ8CRQqr\n", + "r60vGNeDVcnvtJP2tLWmsRaZ31idXBf9jQqT8gXj74wb414DfdTrHKQtKBlcKxZzVJsjWMDsafRR\n", + "rWKBHyl7A2uhVuHKQT8ylrR7UH6I9Cc+PvTb7t27Wx0n5vJjrscot5iRPcK4066USsr40962VRVq\n", + "ibkFc36WqMFtfbjoR64fRar0OEQRlipgjA+R58zzlC9UKjcgeyrjE99KUaEghRUpY4wxxphKZqUi\n", + "FZ9eeTrFQs9ZVb365pBrAquEzM6llJ4fPwL8IVBSuF7qZOUozS8EMWM8ykNpFt9asNpz/gaR0npT\n", + "MfIqpwTFfEW/9Eu/1PV7r/4d5GbBKkvlFVu4cKGkxorjOqNPHpFA9GPK+qaSfFR42oKVHSONauuO\n", + "oRxhDTJOsZ1Yg7kcQzFHUy+kxiYVhQREvLJ26fsY2ZtTvKIFTh/X1jJD7UaxGXRGc+Zs9MkaFMwZ\n", + "lDzmTK52XQr2AuYk18HPlB8le1OM6E6Nd/QNYn6hZPWrpl+v1EYTonTVfp/rL92zWPvcQ5ctWyZp\n", + "qv8x6zcqUazfqGDFKNQcVqSMMcYYYyoZmSL1Az/wA63f/5c+pfaaewULfNeuXVXfL820jDVC3iys\n", + "Yq4TqysXLdj2erEWqbW3d+9eSY0VOyhq/VBK+5P+QvGqtU6htr3r16+X1Phg3X333TN+PvY7CiHz\n", + "gHXC/MCPAMUmVb+sXzmRIFU/rJTol8H1sc5YD/w/vo4ptQh6HecjifX9cv6R+FZQLQDlAn83LFp8\n", + "R1C5S/NW1daOA8aQ6wJqjtEelLRa9ZI52jZzey30C3OjNmKbvYU5xByNUWMoUygVMdqtdI+Kfof0\n", + "dz/n8CBhT4v+tdCrEllbJ5e3KcxDxm3Dhg2SmnXMXkME8gUXXCBJuu222yQ191J+lvpHW5Eyxhhj\n", + "jKlkZIpUiRrF+86YR2blypWSmvejpbXcIlhjOUWH99dEQ/E9ck9Ev4NS3xqsHzKK0ydYPbHOEfSa\n", + "9whyNc36Df2IVUYG92iVx7pTpdFzvCeP2XnxXyj1pSHzO/XIsErinOV6aD+/ozbQv219raIqEOcn\n", + "Vjj92K+oxxy9+ozlog2j9VejbqDSoQoCvhdk948Q3RbXGmOKL0zcixhrFBHGhjnLHGRNo1SheDDH\n", + "4tziOuLYcxx8p/B9Yq/ct2+fpGYNcd34huATgoLG37HQ20YADxr2Oq6PcaDd+JbRD1GZYA9lrUR1\n", + "vzTjfFs/1BRxbefU1n5B/7Hncg+jbmjuXsC85fuMy7D2nhQohazLuD63bt0qqVG3efvDXvOFL3xB\n", + "UrPe+Mn12UfKGGOMMWbAjHWGXb5ZL1tjExMTwz6tMcYYY0xrJiYmkqq8FSljjDHGmEpG5iN1pCJV\n", + "6qtUe45hqV+l54u+NRGisvDB4j126nzXX3+9pOZ9Me9/yUsUI0I4Ln4F+AnQ//gh8PSNP8ev//qv\n", + "z3hdxhhjzCsNK1LGGGOMMZWMNLM5nvFLly6V1L5OEhAhQyRLbRTfsMjljkGxQplKKVJAZEGMMEjl\n", + "JiHiJZVFtzQnijHGGPNKx4qUMcYYY0wlI1WkyPWRyqYb8ynxO3mBHn74YUlNfqF+5eQ444wzus77\n", + "d3/3dz0dD18lcpHkAiWpqUal6lpQ/GoryBtjjDFmZqxIGWOMMcZUMlJFCr7+9a93/Y6SErOnolyV\n", + "ZqOthVpt1J+qheg4ssJyPUTVkWWVCuZkOeZ6e61bZCXKGGOMGSxWpIwxxhhjKpkVihRRd9RBQkmh\n", + "PlQpvdaJIkoOUJRi/Z4c+DbhG0VepqgwoVShQFH5uFAhQgAACFxJREFUmuhF6l/RDuoAOarOGGOM\n", + "mR1YkTLGGGOMqWRkitRxxx03qSChzJBf6b/+67+m/Q6fW7hwoSTpiSee6PoeGdJzVeZTcF5+1ipc\n", + "sXI7v8dK2fh6oVwBitw3vvENSU30YKxcPihOPvlkSU0UZCqq0hhjjHmlY0XKGGOMMaaSkSlSxx9/\n", + "/KRCE6P0UqCUUFMO3yoUqV5r9RFN1ysvvPCCpEZZQpGKpDKSA/mmyHSe+ly/ibX66GdjjDHGdGNF\n", + "yhhjjDGmkpEpUkf6C+HbhG8S0WtAJvMY5UZGcxiWYpMj5m/qNcouZmw/7rjjejpeJGZAj8rc2NhY\n", + "X89njDHGHCtYkTLGGGOMqWRkitSrXvWqKbX2UJ4iKCb/8R//IanxOcI3Csi39G//9m99aSNKTK42\n", + "Hj5bgE9RVMx6heNynREUO/o1Rvmh/KHorVq1quvz5K8yxhhjTBlWpIwxxhhjKhmZIvVjP/Zjk1F2\n", + "KDooT7GWHn9H4Yk+VEDepRSvec1rJJXXsMspURAzokcfKRQ0ou9q80Fx/TFP1qte9SpJTZQd58Nn\n", + "DAULBQ9li+v793//d0mNYgXx88YYY4zpxoqUMcYYY0wlI1OkDh48OOnLhOKUUoDwVULR4WckpyCh\n", + "HBEdiDKEgpPKqJ5j/vz5Xb+j5KCw/eiP/qikRvnhek466SRJTVRfadRhVLR++qd/WlKjhKHooTCd\n", + "eOKJXec5fPiwpEaZo10pavvFGGOMOdaxImWMMcYYU8nIFKkjI+u++93vzvhZas3hU5VTUCIoXkS1\n", + "zZs3r+t3lBp8kI4//nhJjfJDtCDgk7RgwQJJ0imnnDLteVGIyHQewdeLaMXaPFhPP/20pKmZ3fn9\n", + "m9/8ZtVxjTHGGDMzVqSMMcYYYyoZmSJ1JETTpRSggwcPFh0nlb8JH6YlS5ZIanypfviHf1hSo9ig\n", + "NNGOZ555pqs9P/ETPyFJGh8f7/rckVna29BWWUvRa43BCD5d+HL1Ky+XKePQoUNauHDhqJth/h+P\n", + "x+zBYzG78Hi8jBUpY2YZTz311KibYI7A4zF78FjMLjweLzMyRWrjxo0655xzhnKuyy67bMa/E/UW\n", + "Oeuss6rONzExUfW9Wno939atW4c2FsYYY8yxhBUpY4wxxphKxjql6bv7yM/+7M/qS1/60rBPa4wx\n", + "xhjTmo0bN+r++++f9m8jeZAyxhhjjDkW8Ks9Y4wxxphK/CBljDHGGFPJ0B+ktmzZomXLlmnJkiX6\n", + "6Ec/OuzTG72ckX3NmjVat26dTj/9dEnSv/zLv+i8887T0qVLdf755zt31ID4lV/5Fc2bN0+rV6+e\n", + "/L+Z+v6GG27QkiVLtGzZMt17772jaPIxzXTjMTExofnz52vdunVat26d7rnnnsm/eTwGyzPPPKNz\n", + "zjlHK1eu1KpVq/SJT3xCktfIKEiNhdfHNHSGyH//9393Fi1a1Dl06FDnpZde6oyPj3f2798/zCaY\n", + "TqezYMGCzgsvvND1f+9///s7H/3oRzudTqfz+7//+51rr712FE075nnggQc6u3fv7qxatWry/1J9\n", + "v2/fvs74+HjnpZde6hw6dKizaNGizv/8z/+MpN3HKtONx8TEROcP//APp3zW4zF4Dh8+3NmzZ0+n\n", + "0+l0vvOd73SWLl3a2b9/v9fICEiNhdfHVIaqSO3cuVOLFy/WggULNGfOHF166aW64447htkE8/90\n", + "QozBnXfeqSuuuEKSdMUVV+j2228fRbOOed74xjdO1nKEVN/fcccdevvb3645c+ZowYIFWrx4sXbu\n", + "3Dn0Nh/LTDce0tT1IXk8hsGJJ56otWvXSpLmzp2r5cuX67nnnvMaGQGpsZC8PiJDfZB67rnn9JM/\n", + "+ZOTv8+fP39yYMzwGBsb07nnnqv169fr05/+tCTpW9/61mQx53nz5ulb3/rWKJv4iiLV988///xk\n", + "eSPJ62WY3HzzzRofH9fmzZsnXyN5PIbLU089pT179uiMM87wGhkxjMWZZ54pyesjMtQHKWq3mdGy\n", + "Y8cO7dmzR/fcc4/++I//WNu2bev6+9jYmMdqROT63uMyeN797nfr0KFDeuSRR3TSSSfp6quvTn7W\n", + "4zEYXnzxRW3atEk33XSTjjvuuK6/eY0MlxdffFGXXHKJbrrpJs2dO9frYxqG+iD12te+drIQsPSy\n", + "M9uRT7BmOJx00kmSXi4WffHFF2vnzp2aN2/eZPHmw4cP64QTThhlE19RpPo+rpdnn31Wr33ta0fS\n", + "xlcSJ5xwwuTN+l3vetfk6wmPx3D4/ve/r02bNukd73iHLrroIkleI6OCsbj88ssnx8LrYypDfZBa\n", + "v369Dhw4oKeeekovvfSSPv/5z+vCCy8cZhNe8Xz3u9/Vd77zHUnSf/7nf+ree+/V6tWrdeGFF+rW\n", + "W2+VJN16662Ti8YMnlTfX3jhhfrc5z6nl156SYcOHdKBAwcmoyzN4Dh8+PDkv7/4xS9ORvR5PAZP\n", + "p9PR5s2btWLFCv3mb/7m5P97jQyf1Fh4fUzDsL3b77777s7SpUs7ixYt6lx//fXDPv0rnoMHD3bG\n", + "x8c74+PjnZUrV06OwQsvvNB585vf3FmyZEnnvPPO6/zrv/7riFt6bHLppZd2TjrppM6cOXM68+fP\n", + "73z2s5+dse8/8pGPdBYtWtQ59dRTO1u2bBlhy49N4njccsstnXe84x2d1atXd9asWdN561vf2vnm\n", + "N785+XmPx2DZtm1bZ2xsrDM+Pt5Zu3ZtZ+3atZ177rnHa2QETDcWd999t9fHNLhEjDHGGGNMJc5s\n", + "bowxxhhTiR+kjDHGGGMq8YOUMcYYY0wlfpAyxhhjjKnED1LGGGOMMZX4QcoYY4wxphI/SBljjDHG\n", + "VOIHKWOMMcaYSv4PwNFhvU7XHUcAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "source": [ - "The fifth layer after pooling, `pool5`" - ] - }, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['conv3'].data[0]\n", + "vis_square(feat, padval=0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The fourth layer output, `conv4` (rectified, all 384 channels)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "feat = net.blobs['pool5'].data[0]\n", - "vis_square(feat, padval=1)" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXmwZVV1/78vgBE1JkGQoZumu2nophtsVJxBoQwmpFJE\n", + "qhRRUziVQzRxLMVgJbwCkcYBE0sxZcpYRKscq+KQVFAxCAiFLcjYzdDN0EwNOMUkmkRRfn/4+7zT\n", + "9/ve7r3PPufce1+zPv/ceu/ee/Y5e6+971nfs9baMw8//PDDCoIgCIIgCFrzW5M+gSAIgiAIgsVK\n", + "3EgFQRAEQRBUEjdSQRAEQRAElcSNVBAEQRAEQSVxIxUEQRAEQVBJ3EgFQRAEQRBUMsiN1IUXXqg1\n", + "a9bokEMO0bnnnjtEE0EQBEEQBBNnpu86Ur/61a+0evVqXXTRRVqyZIme9rSn6bOf/awOO+ywPpsJ\n", + "giAIgiCYOL0rUhs3btSqVau0fPly7bHHHjrllFP0la98pe9mgiAIgiAIJk7vN1L33nuvDjzwwLm/\n", + "ly5dqnvvvbfvZoIgCIIgCCbO7n0fcGZmppfPBEEQBEEQTAMHHXSQ7rzzzgXf6/1GasmSJbr77rvn\n", + "/r777ru1dOnSou8+/vGPlyT97//+ryTpF7/4hSTp937v9yRJe+65pyTpP/7jPyRJv/M7vyNJ+q3f\n", + "+o2w9uMf/3jke7OzsyOvOTjef/3XfxV93vH2Dj74YEnSbbfdVnW8FPvss48k6U1vetNIe23hhrY0\n", + "TK60P9evXy9Jc3Fxn/vc50beX758uSRp+/btkqT/+7//69ReX9DO2WefLamxR/oJ+/r1r3/da3vj\n", + "vr5ce7vv/ptl4bGPfawk6ac//enI+6V24+2l5tehhx4qSVq5cqUk6corrxw5j9WrV0uSNm3aJKmZ\n", + "/49+9KMlSXvssYck6R3veIc+8pGPjLSFbd1///0jbT7xiU8cuYYf/OAHkpq1hu/9+te/1kMPPaS9\n", + "99575Lh/9md/Jkn68Ic/LGl+Hz396U8fObfLL79cUrNWcc3//d//LUl68MEHJTVrF+3xesopp0ia\n", + "HlvZb7/9JM3v1xzM/R/96EeSGluY1FzYsGGDpOY353GPe5ykZlwYr2XLlklS8ofU+e3f/m1J0l57\n", + "7SVJev3rXz/SbgrmFr91P//5z4vac4bqT86L62MuTutaRn9yvowz+HineN7znqdLLrkk+X7vj/aO\n", + "OuoobdmyRXfeead+8Ytf6POf/7xOPPHEvpsJgiAIgiAYnOOOO26n7/euSO2+++766Ec/qj/8wz/U\n", + "r371K73mNa9JZuzh3fE+HvBPfvITSdJDDz008nm8R/6///77j7yicJR6Dc5jHvMYSfM9ZpQJlIjc\n", + "3Sv0rUQB3jPkFAK8KveSfvazn0lqvIpSUAp8fACv5fnPf74k6fbbb5fUeO377ruvpPpxqmW33XaT\n", + "9JvM0p1BP6IOoCrUKlEoJ4zT//zP/1QdZ9yk7Jx5+5//+Z+tjpdSelE1mMdr1qyR1PQb9ul2ine5\n", + "Y6gAY8TYYeMOClDqHN1GmEOcE6TCFPg+5wF4wJy7K1HAXEE5K4W5yXmWrlVtaatEwaMe9ShJ9ar/\n", + "0Hh/YU9t1yoUTX6TSmHtYdy9XdbwlIo/NMyD1No/bXC+/Obdd999I+/ztOzmm2/u1E7vN1KSdMIJ\n", + "J+iEE04Y4tBBEARBEARTwyA3UqXgtXHXjxLF83NXTn75y19Kkn74wx9KapQPYoZySkOOBx54QFJz\n", + "F4sSccABB0hqvJWhvLxacrEqeDEobiha7gWXkvNGOP4VV1whqfGuf//3f1+StHnz5lbt4cXWni8Q\n", + "/4J9peD6+vKa/bn8tJMb37ZKVA7mOYoUqgoKoiuwDnYlNWsJawa2wyue/j333LPTY7HGALEqqObg\n", + "c+93f/d3JTVrB7Cm8HnWmpRNM2fbJuYwdh4jRr90XSNr4Troh2mhtH/pT2yV3xx+C7oqGg5xxrSL\n", + "3aLuTwrmFXNz2sHeXYmCvsZtuqw6CIIgCIJgETExRerxj3/8nNflMTcoBjyHR4lyuNskdoK7ZJSX\n", + "WvDe8Ob69jbGDTE544rNQcn50pe+NPJ3LV2VKKiNK2ib3TjtoMzRr/QL8wkv+AlPeIKkZl7yuZxC\n", + "5F4+ynHK/pjnxIPwOeJ8aB81w2PVdsyY49xRlBgz1gbWmtQ5oTi5IkUbruh4DBZ96msW11I6F1A6\n", + "am2WsTvooIMkNWOWi9vMKUb0I8obmaw5GIcdM7qngdI1kXHjddu2bZKGU2awM283aEfXpxmlCmoo\n", + "UkEQBEEQBJVMVJHCs8RLJJaktHYGGRHEI6TiE3LgLS62WJa+yGWCtFX48NKIN3Fviloy487a85oi\n", + "OW+fbE2uhxi+ru1PWtnKZWl6XA0KFipJTpHy68t5g8y7a665RlKjQHEcxoH4FFeLdlSFmMt81zMl\n", + "WTOwaWJdUEpQGlKksrqAdliDmAOcxy233CKpXGHAVttCH6K8EX9GjE3KBlOZqR63hqffllQW5bTD\n", + "eLrSOKmYs1JQWBdLv3sGflewW7LzGC/GkTU9pUyWZmqHIhUEQRAEQVDJxBSphx56aO5uD4/UPc0c\n", + "fJ/n9HhLqZiqFHixeKnctXq14hR4fYsVj0HBe6Yf8BJKSdXc4W9q6YwblJHSTB3O173w2uftHGfa\n", + "a7BwfcxH1JqUioHXx3x0L67Ua+c4gDLmOxnsDDIKuQYfK45JDBFzvlYlRKlwdZOxRs1DEWg79iXX\n", + "vBCsgaj7Hv/WNvOS8+Z1sdRC6wvsBBvNZf72BWuVr8GpLLTU9/umbyXOFc++wP75LWeeonLn4jdL\n", + "CUUqCIIgCIKgkokpUr/+9a/nvMCuMSN4V147pRQUMWKseK6MAsHx8fJScRGTxp+Hl8bk5LwL9+pz\n", + "x+XznA93/yhV9957707bG4q2doEXw/V2VZL62qOP8+H1wAMPlJSP72kL8yI1zl4bKPe5nB3Svymv\n", + "tKT/cvFbgI22zchFYQKUCmzL/2bN8IzEHKihrtKVgqfN3GYs28aPpphUZe1JkasdmMoorcX3WmQt\n", + "LbVvmLaahw726Ipf37gCi/32FRcdilQQBEEQBEElE1Ok9txzzzlvDY81VcMlB8oRnmxbhYjzwEvF\n", + "M/a7ZZSevuoa9Q1386kMk1q89ktOYSCmhT312DkdhWfaasmk6Nvr7ttbxS67xkGkvGnPqk3tfZmb\n", + "D8zrnHfsqo6Tmtc11bJza0wqdsLVMu8zv1Y83raetscktYW5Rl+icBFrw3nVZnPtKopUacZ2TrXn\n", + "aUhpXG0O39+TSvipivyLFdYunloMpUh5fC7zu6/f8lCkgiAIgiAIKpmYIvXwww/PeTV4ttzVt33e\n", + "zD5EeF9tFSnu/vE2OS+PRelLURgK+rEvJQpWrlw58neuH2jfxxWlqq+98x5pYJ8offRf15gzVBTm\n", + "jasgXRUvvL+cIoXXyHzGXnhN2V3NvKQmlVfmpm5Tag3xueUZqvxNtfYVK1ZIklavXi1JevDBByXl\n", + "+4IxqJ0jqL7r1q2T1Hj6d9xxh6TudYUmXQutL/pS1vquPI6djDtLcNx4dm3f+3gC88kz0vv6TQ9F\n", + "KgiCIAiCoJKJKVK/+tWv5rw+nitz14hiURpRf8ghh0hqvKS77rpr5H2O50oJsB8VXiUePl7GtMcD\n", + "4PGvWbNGUuO98H+8mq1bt0pqvGH+T/VlnlPTn7zPcaFUMaTfUBjoXzKf8LqCMuhvr/PUVV3wGEXs\n", + "nva6Kpyl6oXH86DAlVaiXwjPZOVYVDrmfWyaGKItW7ZIaubSqlWrJDVrBbBm+XFcxWMN4tpyihTf\n", + "71pzjXao4N42/nTaScXvldJVWRtKXUcxwW6nJTN8KJjbfcWYOfQf48S45fo19toLgiAIgiAYmIkp\n", + "Uo9+9KPnlIr99ttPUlMjo1SJwlsjK4wqpniPQIxO7jkzd8OLzWt79rOfLalRfvDS8L65q8Y7JeYE\n", + "BQrlwffGYxz43rHHHitpvnKR2s8JL4M4FPq/6551tXCeeCV9x5INDSpFaZxNCld4UnEJeG3MM+YX\n", + "ypHHF6VIeevYJfPzgAMOGGmX88Q+8dJREVB3qKO1I6iofu7YvFf4PuywwyQ1aun1118/cjy+7x4q\n", + "x+Ec+ZsYLFQ1YpN8zqCkuNrGtZVWsE7hNfb6qiM1bXi217h2Dxg6zrN0jkHt3oyTZui1GAWatYv5\n", + "ym9+qj4X8zhHKFJBEARBEASVTEyRWrZs2ZxXdvDBB0tqPGyUEbw47sr9rvW4446TJB155JEj33ev\n", + "kb/xTvF4aR/vj+PzOY5HrBHeLB4x3qbXveH/KESpnay9MnTt/kV8b/PmzZKkm266SVJznbzP82Dq\n", + "ENEuShFKnNfV4npRpLgu+sUrynsMFePoe92VxiegMBLj1Ra8NOJfvI7VULVL+ob+RFGspTQLD/WC\n", + "cUOhbOuFr127VlKj6gB2gp2yswB2Qfte8whVh8/xfam5tlTFcubmEUccIanJqkOJwlb9XFGGqOfz\n", + "nOc8R5L0tKc9TZK0adMmSc0YcW6sXfyf+ENfY2688caR9phbKRWd62BN8rWP6yI2iv8ffvjhkpo1\n", + "D0+cftuxL6cZ5iz9yFoOpZmsrA385gD9gCJBe6zlvHqcKWtr20zX0t8C7MJrLvJ/VN2h8N9C5gPQ\n", + "vq8VfI95wfueGc8a4E9T6GffvzWH/zb7b1NOwStV/UORCoIgCIIgqGTm4QkUBJmZmdHs7Oy4mw2C\n", + "IAiCIGjN7Oxs8ilKKFJBEARBEASVTCw4ZByKFG187GMfk9R+5+za9j7+8Y9Lmv/8GIhvqI2J4rnv\n", + "u971LknSmWeeKampeE2tG55jX3rppZKa59JPeMITJEnHHHOMJOmyyy6T1MRjEC9CNiXn++IXv1iS\n", + "dOGFF0qSrrrqKknNc3HPjAL+z/Nyrpv/E5N16KGHSmriG975zndKStvK8uXLR66LatLge/ylapQQ\n", + "B/HmN79ZknTeeeeNnC/P52uz5Hjuz3UTT/Ga17xGknT++edLarLxUnW6vN4T50MsEbFqqUwf+vGs\n", + "s86SVF5LpRbae//73y+psQvGifgdvDzPliV+getOZfMS+/b6179+bEo37bz3ve+V1GSJYUucq8da\n", + "EaPEHN64cePI+4whtkfcIe3lrq/trhAOMSjvfve7JUkf/OAHJc2PH8XmmFNuQ7k97DgO8Zannnqq\n", + "pKY/ybLi+okL9HawIWzF96LD5nyPxLe85S2SpE996lOSpG3bti14nn3BuF188cWS5q/9zAniQFkz\n", + "iMFjrjNHWKO5bvqZcfmjP/ojSc1axhxiHLFL4hcZD7dH1mRinOgnxp2Yv5e97GUj11kK8wV7L11j\n", + "S+dDX2Tn3VjOIgiCIAiCYBdkcaQrdaTvfZBy4DV51V28Re7Ceb3lllskNd4EXkbq7ty9XLxPvFw8\n", + "dP7vNVVQnr785S8veHy8HTJ/POvwmmuuGTmuV5KvrcN16623tvo8/ZCqkI4CmVNcPFOp7/2eXAnz\n", + "rFKv54VC4xlb/N/tAu/W63vxeR9/z+IcGsbJ7TanEJdWMk9lxY4DH0v63K8VyM5LVSzH88cm21Zz\n", + "Zw1IrR05xcoVJD9O6fnkagGmVGSvZs/nUraasyEUGBQyj3HxDN6h4SkFayxrpZ8Ha8ZFF1204HGw\n", + "D1R51grmNopUbi3zDHZANX/yk58sqclK9Yzhrr+tbetkTSuhSAVBEARBEFTyiFCkSiul94XXBAG8\n", + "QO7CUXz8e159GC+T5+YpD9zr6uCN4F2UxogRx0EslVdXxnvBO0V588rTbSFeonTvuJx3XKq4+Ofo\n", + "Z+wGr9a9+No94Dxeg/Y9fqEUzguvFoULL7x2T8Oh9hED4oGwszvvvLPqOJOsA+Z9U9pXrvQwxxk7\n", + "VMTcbgxOau5wfI9tmhRcn6ulzCXWEuZYaveEUlJV/GtjyWpB0eG6vBZh6VrCbwVPNfhe2zhgzgeF\n", + "lNg06mGxhrhyCEPHHS8WQpEKgiAIgiCo5BGhSOUg8+OZz3ympEYRwBu89tprd/p94hog5+25p49i\n", + "hCJDzBSkYkyc22+/feR88N7wGvCCUFxSSgXP7fFCPKPFFRWuB+8yFZuVw3fozsF1dPWuXTnkelCI\n", + "vKI+XtqSJUskNeoC9uLXzfFTFd1LqzCXgtfdNdYLxYhXYuH68uKJr3DFte141uyrRkYqWUmorrXV\n", + "8yGnmKCs0IeontgU6lrt2KXU4FKVs23l6KFgbWLu1cbz8T36uVYtZ03lNwLIwiuFNZU1uTZzGzvy\n", + "NdrXshz0L/3DvECh2rJli6T0nBzXnobTTihSQRAEQRAElSxKRQoPua9sPI7H/lnsw8Vd/hvf+Mad\n", + "fr+tF4DXh7fE3f5PfvKTVsdJQb/48XiOnou74LpRCPz63ItCQfJ4BsDbyXnZpeOJgoGCR8xZbZ0n\n", + "98JTNYCA66N/UDTJliTDJRVb1TVbjoyf2j33SmsNYSd48SinbeN2cqTqrQ0Jnjxj3FemZq5GHLaL\n", + "6okywVz1bLUUKCTMvb5qglGLbtLQT6nYHNRdYspyKmbXDTzoV17ZH7ZtTUBUbJTH2vpVzEVeUVRZ\n", + "kyC3r6nHgfr+lqjl/N/V+b7ouqaVQjwm/cS86/rbG4pUEARBEARBJVOtSOE5c7eK99h3pgWxRV//\n", + "+tclNTFCpbE6bTNJ+roLdvDiyLjg/F3pyXlPZAVy905mCPh5czyel9Muf9cqRSnwrlCSuN7adlxB\n", + "y/UP3r9nWHm9sBSemdM2O66tAuq0nT9UL6Zf+H7f9jsJ+q4ZhlKEcuG2lMtyYq6iNKTOD5tBcWCN\n", + "ROnwOV+qnHgGZNdK6bV4bTeHNWDc2YdXXnnlyGtbUPxqsw8B5QaFi7XaySlxqMv8trIWEiPFmsRa\n", + "h133vUXv0EoUeOZ8X0+1QpEKgiAIgiCoZKoVKe4e8c6IHxiqkjH7DPG8mZgX7sb79l5TUK22bV0d\n", + "vGGe/+L14HW0fb5N/3sMkXsj7u3STluvyyvBp8BL9gryDrFvxDChBrgX4gpPrpYL3gyvnC9Kpvez\n", + "e/XubaMklipS46oG/IxnPENSo0h9+9vfljScEsV4eZxQ34rmkDAHarOxmDMphQGwYWwL20nN8dLz\n", + "cRssVaLYb/NZz3qWpCa26fLLLy/6voPStquB8pObwyhCzAXswnc9YM1hDfTYutLYJtZS1nLWQP7m\n", + "ONhbrX1PmqHWrlCkgiAIgiAIKplqRQq4G09lcPQFygLenseEpMg9z29L7V0z54/3wfmjKLVVpPBC\n", + "cgqNeym1z/9La5IwHrSTihnieT+KD/3gipR74V6pPXWerj649wbYB+16TFZb+/F2UhleXatBE7dw\n", + "1VVXSZLuueeequOUQr9zfXjlXF+fNWs8lgkbIt6uthp8110UUvsjOswBXrmOtlX2ndrzx8bIQuvq\n", + "+e+qihT95Cor18vTBHaXoB+J4/U9GJmjvjsClK792L/HIXtFfI7XNcZrVyMUqSAIgiAIgkoWhSI1\n", + "tBIFrmygIOS8w76rAddmonj2F15I7V5peCG566fdofc05Hzw2vGeqCflCgxeGupCKmPKvTWvPk2c\n", + "Al4k//c4Ao5DfxHz44pU6rpKKc3A6joeVNjvW3FNgQLF9WG3jEefGVooUihQZD/RZq0i1TWGBFWu\n", + "bVaUq7O1WVW1dYKYi9iM2x5jWxrv1lVZc4beN7IUj+8Exos1gvhY/xzZmfSP7yGIggSldsh5+VrP\n", + "XEQxCyVqYUKRCoIgCIIgqGRRKFJtq8fWwt0/WV4oBbnn/V3r+nTFFQO8FLyI0lgnJ5cJBF5HqpZc\n", + "zRr+z/kQH0CVYX9+X6pgpCqbc13uTeM9ej0r+tmzD90LTsVHQK4fuP6c6tDXfMHL5bpK921rC8dF\n", + "JaJdXtvuxbgz8OCZO4xJ2zgw3x+QDF+upe2cQxkjUzlXd8rpWt+nVn3EJlFMOA/PKizF4whr4Tgr\n", + "VqyQNHycXw7U7RTMWTLT161bJ6mxL34LUVQZL+wQ+4NS+0ut3fx/XHWeFiuhSAVBEARBEFSyKBSp\n", + "cdWs4O4ejxhFgLpSpeT2N3IOOuggSc2+Rm2VHbxBvFcUGa8w3pbrr7++6HPuPdbu94UXnqoLheKD\n", + "PTBejFOtnXiMEl4cx03F6NEeMVruTaa8QVf4XHlC4UopP66C9F1l2BmXN0ptnKVLl0pqlOG2Ow2U\n", + "wJxgbJkzbSsdY7OMBa+1WWesAaksrBy+j2dbPMamLaxBnuVV2q/UozrwwAMlNePCGnPbbbdJKrd5\n", + "vo8S1XUvwq6Uxi2iXDEHWBOJQeO6fG6mdp0A1g4UWfqR8aKfOU/+TtW9QiF7pBOKVBAEQRAEQSWL\n", + "QpHqCl5Rzhugojif526eu/KUZ+4Vz9sqBG3jIBxvb6gYFvBK7/zNc3v6OXddXnUXhcmvx+tB8Xni\n", + "L+644w5J82OiSvcJc6+/VNnie3jbtZXvXfHMjd+uHq9w9913S2q83bYV/muo3XMLBQm67knHNbdV\n", + "kbH1rvWXiAfsCiot6uK1114rKR+zw1xgDUDdrc1mhKHmTGnlcChd67lelDTsIZc1l+sfztd3D+B7\n", + "9BP2hD2gCjtkJvdNKi4aRW3aCEUqCIIgCIKgkqlWpFKKglclzpHzFrirxptDWfAMiZRX4+fnmS8c\n", + "Fy8A78Jjsfbaa6+R9tj7z70MdhBPQXyB1xjJKXJ4H3iRKHObN28e+Zx7lXiNqfHAu0JR8popfhzH\n", + "Y5bwUvg/7dLPbWv5eFwB+5xhF/QH4+bZerTH+OH1ET/D5zlfH0/PCuQ4KFNch2fP8X/+5nzwHrEv\n", + "z1Tab7/9JDX9hl1yHcwX91ZdKeP4ZGpxvK57AfJ92p3m2jWM1QMPPCCp2Z8T2+HceT+lNK1Zs0aS\n", + "dMQRR0hqbJmK1sCaxBqADbgyksoYdTgOx+0rW47zYs1sm73oa0GfVe37pO2uEcy13G8XazbHJVaK\n", + "rM5SFXzZsmWSmrXT1X3sDLvluLRLzJqvGYznoYceOtIe8wG7Y03z2nyp6+e81q5dK2m+EslvYwq+\n", + "T39hf7kMbn4z+e1GaX7qU5+60+9BKFJBEARBEASVzDw8dMrPQo3OzGh2dnbczQZBEARBELRmdnY2\n", + "GYMWilQQBEEQBEElE4uRmp2dnXue2jWmwiuLE7Px5je/WZL0iU98YuR9nodSt2br1q0j71NNlrtP\n", + "jxHieTKZKTxXPvXUUyVJ//RP/ySpyTYixobz5P88Xz/66KMlNc+VL7300gWvk+e3PP997WtfK0n6\n", + "53/+Z0nzY2noV7++E044YeT97373uyPfI7aH+AliY0455RRJ0nnnnScp/3ye75fGSRA/QL+ffvrp\n", + "kqQvfelLkprn6zzXJ66DOBKOf9hhh0lq+pf+5vNcJ9fFeb7whS+UJJ155pkj7eXweJVUhouDKptT\n", + "Z7E34hb8+LyfijHz9rAXjuPxNcRGrVq1SlITr8B82bZt28jf1GIie5N4lre//e2SpI997GOS5o8/\n", + "45iLX+Bz2D92wt/Y4emnnz53bcRW8FnawOaJ2fD9KMkK4pUYD8aWOXzyySdLkj760Y9Kmj8mnBu2\n", + "QR+zhx+xHsTjka3mc4oYl1e/+tWS8rbifVW7Zx3tcH2+fyW7CTCHeD322GMlNf1JLTquy2NjnvOc\n", + "50iSjjvuOEnSWWedJSkd37hy5cqR6/KsydS4pq7v7LPPljR/t4K2NemIiWOcaZfjnHbaaSPtDg3t\n", + "tF3LHN+lIdfeuK+vtD3mMxXuWbuIj83tAZlrJxSpIAiCIAiCSiaatddViQK/2/YsH7wXvBTuPlN7\n", + "6G3atGmn7eF90Y63h8fOeeE1eY0XPP+LLrpop+0BXo57YShweMucH/93qLvk/U8WFooX3rJnfXn2\n", + "X8prIVMpBe0xDoyT1yZhvFCWyCRBAXFvorQiewqum5ovqAqoCF7XCMUt1d9Qu2ckakqq4nvb6tdc\n", + "D+OFXaJcMr7YGwoe71PnCeXSs2hddaA/UW49y5D2UuqJqwWoLSjCO36Psa8N/cypeg6qOh6uZxcx\n", + "5tgItkv2FWObqh3Wtr4VY/nc5z5XkvTNb35z5P22NphSV6kw7nzrW9+S1IyNr1XOJZdcIqlRpHLn\n", + "RX9wHdgCWWXY5K233rrT40DbuZM7r2kjp0Rhp/R7n7sHjIPSOl6uerMGMl9zilSOUKSCIAiCIAgq\n", + "meo6UrW4Z4u3wN02XqffxebubvF+iElBAcrdzXbdK9A9eG/PY4RQGlL7Zt18880L/h/vGqWH/nKv\n", + "1L2WtjVe6GePP0kdj+fb9AN1l/AqUteTgu9hF75juntxeC2p66TfcwpcrR3kKp2XxmQB3pnvyehK\n", + "I/1z8cUXL3gcPo/deByNfw7lkfHnlf7zemt+PpwnSirf31ENwMMure6fmvNcE33l+zsCY+4KGNeQ\n", + "qhFGuyhVXmMOUipkCmyXWCyUIdYCYohyqnstXGeth496icKXep/+IlaL8bvrrrskldcYRBXn8/50\n", + "gfhW3vfzQglDvR7XvrB9wT6v9ANPU7zCvj+VmBba9jcV9sHjq2sJRSoIgiAIgqCSXVKRclxBScVm\n", + "5Z6z4kW69+Leb99eicc+OZ5t5d5uKSheeF201/au3fdp8kyk3I7w7pUTe4QSiHJRu0chXmYqzsMV\n", + "TVdSFjvErXgV7LZ4plLKTnyHAuzKd45HfeG4qUr8HGeh+Yp6yZzns6lYkdScxwZ8Lrt6mVJeaA8l\n", + "iJgorjGVeekZtrUe83XXXTfyN8pJTjWdNF652pU9+hWFhLUYRZD+SsVt+l6CfN6VRuyC/Vf5HO36\n", + "HnipNd9tfNpwdd/n6JYtWyZzYoV03dvSM8FrYytDkQqCIAiCIKjkEaFItQXvBOUERQUFCq+J98ly\n", + "y9E2Y8b3bAPPNsRL5nxQatruUYYXjzeeymrMwV1+KgMkl+HiKgFZhnjTpftVpSDuJeWFuMrA+dRm\n", + "+JTWYml7nNRelDl8n65aL4z4G84jVVcMVcaVJO9P/i5VGhcaD86F19o+Z+7gsfv+isDcdIWJ76P+\n", + "EYviMTXMEVdE+oZaX33Tdt/THB6DxFpEbBe2m4qhovaZ1wkCn9v87ftgYqvYEWs8Sg1xqbn4xGmP\n", + "mWJ+YNfkKbm1AAAgAElEQVTMVTJzp3mfyz5JxWWWEopUEARBEARBJY8IRQrlAe8J74+7bTxbj4FJ\n", + "edh4LcTauMJCBgTeCHEbZOzgHVLNOAXnxfc5rsc5cN5cZ20tEM7Ha9zUKjG1d/cOsV5cF16i1+Uq\n", + "hRg5V3aGgnHHm63NaHJ1pTY+AAUzV5k+B9dBbaSUqpJTKGtZKGaQsexrC1GPGfE+T2XVodCgSGFz\n", + "rgxxXNYSr1LfNs6RtQD12+cgWW6p+MC29KVE5Y6H7aAc5L5fOqdz2Z0bN26U1FSYHxeMH/ZVW6E+\n", + "B2uKZ+4yf0rrNC12uv5WhSIVBEEQBEFQyUQVqb5iR3J4HSDusvk/Sg+veJ2p6rg8fyejw+9mPRbK\n", + "MwPw3Hke7ftiuVeG4oW36pW/eR8vzL029yZ8rzkgboPrIj6krVfcN64U8jf9xnWXem1eu2fo+BTi\n", + "D8g+LK26PBTYJfZfW3GdCu/Mq5SddI0TYXxc0dqZl9yXB+1zxOdmqarH94itcVCdmdsoUm2VCK47\n", + "1efUYUJtbluDbFKUKk2shb62ptTQnO2ztqPgjSvmifMmBo/z4LW0TloOsg9ZC333AX4TsZNdXZmq\n", + "JRSpIAiCIAiCSiaqSKWq+XYlVdHbn7OjEHGXz9146fkQ/+DeAX/7XmZ4U3juXk8nFW+B15val4v4\n", + "C9rJxeCkYou8fZQUr+0yNF7rhfHkuvDa8Y5Q/Eq9dz6Pl+uKYteaIg5KH2rApPF+6uplY38pb5Xx\n", + "bJtlSCwXGVOoOb6f3Y4qkZ9D32Pp9KUMUFG6bSXzFLlYrlys0bTB+OXi7HwNz30+Z/veT+NSpLBp\n", + "zn+odvktIj4WtR97Yc4y10KRWphQpIIgCIIgCCqZqCI1VI2KlJfoVWbxVrnL5q681HtFyfA4CdrH\n", + "i6Adj80Cfy7t4F3yOd/JmvMv9WZTmTHUBaI9YnrGjfeP7/Tu2Ze8X5oNRz/xPVcwUzVFUrFlOTyT\n", + "atKUZqiUqjnEcdCvqCtAf7oilYtPQZHyGj+AUsX+atL8udFViUJFTGX29oXvTtAVHzsyR4l1QU1f\n", + "bLgt+VzkevtSCofKlitlXAoY/UrGNvaDCtw1w3dXJxSpIAiCIAiCSh4RdaSoistzczxiVwpKvQ8U\n", + "ERQbj0dAKfHn3K5MOanYLNrj1etWuULj7XmcADFGeDt4w16BOrfn2VC4N4n36c/nUUAY31LIkGLc\n", + "/fsoLGROEStGLRnG1ZWXFE960pMkNf2Zqso8LrAXV4SxZ+wTO0idL59HGSIWytUOjuP27RXqXT3K\n", + "1d0a0lunj6iM7Zm3Q7Xn11oby+R9+eCDD0pavDEu9H9tDbZg5zB3eSpBP3sl/2BhQpEKgiAIgiCo\n", + "5BGhSOHV4YGjPNXebeNB+w7ggKfO5/CcUUDaxm2QFZWqicLO3XgRrrg5nB/ngbeK8kD1ZfZbGrrO\n", + "l+PjguJBDBtxMFxnW0XKFRau//jjj5ckrV+/XtL8/sZb4+9SRYr4FFf+JgVVtF2RxC68vhvni0KH\n", + "3Xj9Lezd7SVlP57VynGZr3jJ2L+zUJxPW/UUJYi2+X4qjnCo7D/mqleSfvKTn9xrO/Rp7T6afXP0\n", + "0Ue3+nypComNsybSn7U14zgeleG3bNkiaf6cWKywOwFrHL+VPA14pFQ4Z354TckcoUgFQRAEQRBU\n", + "MlFFiliUvr0j7q4h5dF2jf1JedqueOCtdM2USe3gjjLmMS8p743MHa/X5FWOPQOqFGKQar/v2YJk\n", + "ZXl1X0iNby0oca44uaJZyr//+79Lmp74jlQmTtvzQ8njNUWqenaqxg+KGPW32tBWGei6V1zb2lgp\n", + "vP4RqlxbtdXPCwUGJSHVP+6JA0oMqiFzAzjP3JwgA9M/7zFgK1eulNTMPXZZoN4R/ZSyHZQTjoua\n", + "yv99jeQpAe8Tx4jtoY4fddRRkprxYC3n++NW7YG1lvZR71Pvc/6MJ39z/fwWs+bS39gH1+sq9q4C\n", + "a2DbtTAUqSAIgiAIgkompkitXLlyzvsh9gWvDi+Avz3GCK+Cu2qvfE1MSt9wXqm99WDt2rWSpE2b\n", + "Nklq7t6pSYPHjTfs3pBnzXksi++1l6vHhVdKf3u2GnEieJtds6G88rSfd06BTGUcjYvUXni1tVSG\n", + "VqLa7pU3bu+Z+Yi9e6V8+sdVDbdr5g3zheP0oUiWKivO0572NEmNgkLfMha8skbxvseHoc77Guhr\n", + "i481fcHnUWqYQ16Dy+eeK18eQ+S7BzipTFrGnMzL1D6JxBodc8wxkhpb4Dz4G1vIVSrnuOyN53jc\n", + "qI+TXw/nsXnzZkmNDfN0YNxzyW3fayF6LUGeCrjyh3LF9aHAsX8mT1U4rh8fpWrcGd3TSihSQRAE\n", + "QRAElcw8PIF0g5mZGc3Ozo672SAIgiAIgtbMzs4mYwxDkQqCIAiCIKhkYjFSX/ziF+eeS5NhwvNe\n", + "noeT6UFsEc/HeU7Nc3ue2/JKvMCxxx4rSVn1y6sV14p0tJNrj+fVnGdpdhvnSX/99V//tSTpk5/8\n", + "pKTmebXHY6SyBT0egufvxEswPsQ2vfKVr5SUv76+oJ2zzjpr5HxSYCe1lcNLxy8FNViIpcrFD3Rt\n", + "ry3T3h72TR0v4mO2bt068jnPCsVu3/Oe9+gTn/iEpGYMvDYVx2QtYS4ddthhI+97xiZtkkV20kkn\n", + "SZI++tGPjrRHOx7LxJrmsUasAR67w99kIL/oRS+SNLmxo5/oz9o1kn6kH+iXv/mbvxlpb2ho57LL\n", + "LpPUZJaSHbhq1SpJjR0QW3bIIYdIauY6GdPYIn/zW0SNv1NPPXWk3aGhnb/927+V1GRfspce53vt\n", + "tddKatYqxnm//faT1MQv8/9DDz1UUnP92PtznvMcSc1vkWd3em06WLNmjaQm5oz+d/g+53H66aeP\n", + "XOfQ5NoJRSoIgiAIgqCSiSlS999//1y2DXeZKcWBarIoJXfccYekJiMEL4dMBpSJHKkaMHgjtEeG\n", + "AnfNvhccd+/gtU/wVmkHxQhvBe8AhWjFihWSGi/J9/vy2jJktdF/eNW5fcE8A4a/PVtq0jt/l2aj\n", + "9VV1l/FDLcDLxAv3/kE5ZdxQxB544AFJzXhRc6W2vlaKVMX7WjhfMr7GlZlE/+Ilp6pQM29RSnfc\n", + "exIP2klltjKnbr75ZklpW2PMqMHl/8f2fAx8n0zmPmsUawTHoX2uiWy+trC2YINd6VonC7raPnOI\n", + "Na6rbXrNOGyeNdfXvlK1m+O4vYwb7Au7or/4v6vmjLPPI58n2HnpLg2pceIeIJctO6k6XaWEIhUE\n", + "QRAEQVDJxBSpPffcs7gqLDVBUvv9eK2SlBeHV4jSwN00d+V4gQceeODI+7RPdVeUHs7Hq7tSkyPl\n", + "BePteE0X7vo5j5T3416SKxL0a1/1izweoq9qzn2TUs4WUi52hscF5GKdaPe73/3ugu/TLq9dq2lj\n", + "b27vXSvng++z1RX6n+smToPzTc3/lLpD3BDn2aY/U7Eapaqnfy6l+jInWWu8kjR1lnz/TZ/zbWu6\n", + "sUZRJ8gVKdR2jztbLDB+Rx55pCTpqquu6nQ81mBXRGrXTuYi9lW65gwFMUw+l7yuVCn85qHCu2rc\n", + "di/DtjUCfTeOUlgzUzFYXQlFKgiCIAiCoJKJKVJ77733nLeFF1ZatRbw9rjbxKtIPbfFc+U43F2j\n", + "OPD/733ve5Kau3Y8X68mDK5YcF5tY0z4XCrOI4Wff+p5M9lQq1evltR4pd///veLzgvGrUThzddm\n", + "CrX1CvuKNXJyFehz0A+uwHrMXl/4jgG1uP14de9SmFeoOsSulRyHvkspUqV4X6P8ED+JjfqedX7N\n", + "rHlcE2qbq4BtbZ6xuvHGGxd8f7EqUUDcKGsYWWTEIrUd19R+jrVrXF/7xvouF/vvv7+kJqaotJo/\n", + "dshvn2e4twXFDWXHlS2vxN8XnG9tHCzzbChCkQqCIAiCIKhkYorUQw89NOd9+T5PpR6w12rhbjUV\n", + "24GH7TuD+/5YHIfzSe1/xff8bpcsQr6/ffv2kfe5u2ZHcf4mFsu9277wWJ2hlIzFRu1z93GDvXZV\n", + "tkrB7rvGxHkMU+35M984H1ScHRXHVAYjcymXyZrC9zgDr2nl+4LSZ3jyKFisGfQN32ct5PyH3qdx\n", + "seKK3rp16yRJ11133cTOqU9cRUdxazsHsVfsF7usnQccz/e9BK8flQN7z60JtSo2EMdKtiy/fV3j\n", + "VSEUqSAIgiAIgkompkj99Kc/nXvOy10yd7ulXphn7aSq7vpzYc/e8895BXX+5hWvl3bIYABillIZ\n", + "CdxV8zmq5XJeeB2lNWBKnxvj1aTqYU0rXWOkUHJS17tYvP6U19Y17ifFUPbhXmwpeOnEoTAPd4xH\n", + "ysW31caG8D2PAfG1wbPvvCIzyhQ2SU08vu+KQ20NNypPs7Zs2bJFUvssqWmDNZv+ZC2j33jakKtL\n", + "tNioVYO9kj9zxn8LS5WZu+66S1KTeesZ620VnnHF23LdKGCsGcxTYu9qCUUqCIIgCIKgkokpUlLj\n", + "veE91N6d8j28Rc+i4y4U5QiPmLtUPO9Sb81rwvhdOUpbrgbMTTfdJKl5rszdse9513dMzGJRoqCr\n", + "10Icy2K77lI8Vi9X92rcUDOJ+edxRW2zJFFgvZ5WCfRNqiZdCjxtjy3xa/A1iM+ThcXnyRYjQzcV\n", + "s1Fb74e1jDW2r2yyFCgbjC39WrvvZQr6g7Wb66K9obLGxo3PkVpQpLAvflMYL5RL1F6UUn7DfM3E\n", + "njhu1zje2littnhcMLXoWEO6KlKdbqSWL1+uxz/+8dptt920xx57aOPGjfrxj3+sl7zkJdq2bZuW\n", + "L1+uL3zhC/NuNIIgCIIgCHYFOt1IzczM6Nvf/vacxylJGzZs0PHHH693vetdOvfcc7VhwwZt2LBh\n", + "we96hk3Xu9tUrIhn93EXzF112+fpfD51N13qIXtVY+A6hs7Sosox7d15552Spk/R6Mpijwsppa9K\n", + "5H2DGkNcAn/X7hGIfWK3bRTLrvsx+tzwvz1rD+WLVxQaPsdawue9ErXHX7YlVSepb1DSiAFjdwgU\n", + "lb7i9zx7y20eVXZcma1D0bZCeAp/2uP273HFvJ+LJeS3s6ti1tf+qDn4rcZuUgpzLZ1XXr8J+OpX\n", + "v6pXvOIVkqRXvOIV+vKXv9y1iSAIgiAIgqmksyL1B3/wB9ptt930+te/Xq997Wv1wAMPzO08vu++\n", + "+yYzzx5++OG5u0GPA6it7cDdt3/fvRi8Pz7Pc+NU3ESqjg7eqN+Vl9bd4XktXqfXqRrKm8RbpDow\n", + "z4eHqug9adruV7ZYcKW170ylrtmSwHliX54x1DZr0uM0xuXVSo2aBqkMROY+fchcZq1Axef7rE0+\n", + "hpPeq60tvtsEa1tpJe4cKE30F7FEfe8POWn6iudkPHyOMBdZO7BLlLBcrFnKXtuCffAbnMt4r8UV\n", + "UeZVX09fOt1IXX755dp///31gx/8QMcff7zWrFkz8v7MzExSOvvpT386Nwi77757dVpyEARBEATB\n", + "UFx88cU7fb/T3Qv7/+yzzz466aSTtHHjRu277766//77td9++2n79u1zWQHOnnvuOXLXvWOl866V\n", + "lN0r8YwOPz7VhlHGSj1cvNOuz1mpFYOnPfRNJedLxsu9994rafx76AXdwIvDXr1CP9R66X1V1kd1\n", + "cUUKNaGt8krGDSoEtZjafLd0P8v99ttv5DW1b6BD37k6zrXzPn3j9ZBgsSlSnC/XPVSNNlfz2Z2g\n", + "a8xO39TOPa7PVWFXoXOk9oX1pzPYHYpU6W9aX2ow7Y2r/ldbxe+4447TJZdckny/Wgf9+c9/Pjdp\n", + "fvazn+kb3/iGjjjiCJ144om64IILJEkXXHCBXvjCF9Y2EQRBEARBMNVUSx8PPPCATjrpJEm/ubt9\n", + "+ctfrhe84AU66qijdPLJJ+uTn/zkXPmDhXjUox6VzHDhrrjUuyC7je+xnw54HSlUMn+eT9aa414i\n", + "32fn8eXLly94PqVVibl+zofvs8N236CkoRCUVlAPhsErr7tqAe6F8j5eJhlT/M3xiImbFB6HUVP/\n", + "aUdQHzjujsc5/PDDJTVzmc8wZ1euXCmpWSv4nGcQok4zN1FWXC1uW3mcsfF9L1Nq8NC71vcNigLX\n", + "NVTcJWokNs84DV0vqy21Kn9KDW4b7+mKae43JWfP/Eb7Prm1sEZh5+OqK9U31TdSK1as0LXXXjvv\n", + "/3vttZcuuuiiTicVBEEQBEGwGJhYhDdFPKVGIeEu1+s95WI18HDxKvFYAS+UmAzufjmuZyw4nlHA\n", + "Xf62bdskNd4qdZnaPn91L+Oee+5p9f1S8NpcuRhn1lMNKH6oB4yHZ+4sXbpUUuMF3nDDDZIaLwp7\n", + "In6D/nB7GTfE7WzdulVSY4eMC6+cP/bu3ncqM6qvjKlaiP9hnuAV19rdpk2bJDXXv+P6gGLksTnM\n", + "Ve8zbMnnLMoK8YOlsIYxVtgex/N9Nvk8qiS2zPk/6UlPatU+eDbU9u3bR9rrOx6S62UODq0seOwP\n", + "ytdiVTRSoKRi12SzldblQo2mfhlKK8oTa6HbI5/jt4k1ilhB/zywluZi41h7OS5/Dx3j5nGl2A1r\n", + "KufRtiL/rpErGgRBEARBMAEmpkj95Cc/mbsbxEPl7rbtc/XUvj/HHHPMyPt45nhj3I1TR8k9ZJQB\n", + "r5KLN8BdvXsHpd4e1+v7HQ0Fd914E4slNgo1AXw88NJQFRhHvKlUXAH/97gAvC7ssu9K76gO4PaC\n", + "14QXipfE91AUb731VknN9VOXCXWD4+6488CO4L1j56gmuR3hsSO8SdpnHqFKgPdf12xAxn+hcU3F\n", + "OQJj7Xvg0ac59c5jpOgLr7LONeLZ8zfn7J93W2VNueuuuxY8Dzx/xgybZ03hvOgr2mOtKVU2OB42\n", + "5Gst/XbwwQdLauJT6UdsgX6nv7GJXEyOP62gv1A5eXVKlZFpx+tm+XjldgfAPug/j8ddKM5Qaua+\n", + "2yn/57w8yy63VrI2cR6enVg7Xswz30/XY/ZSFe+XLVs28n3WstKYu1CkgiAIgiAIKpl5uK9iMW0a\n", + "nZnR7OzsuJsNgiAIgiBozezsbFJND0UqCIIgCIKgkonFSJ199tlzz/F5/k6kPM8nSyFWw+vxvO51\n", + "r5OksalftPPpT39aUhPf0HdWHM+TzzjjjJF2gf4kTsDjLF7wghdIauITiLXheTjH98wO2jn//PMl\n", + "NTFEPF8n/oJxIF6C59I8P+eunnHyveI4j7e97W0LXt9Q0M6//Mu/SJpfO4g4AyppE79BZgyfp1I3\n", + "cQBcP8/f6a83vvGNI+0ODe184AMfGDkv4HzZsYD4i9tvv33kc2SSET9w9913j7yfs8+hmJ2dndcW\n", + "5+IVnH3XeyeX3UY755xzjqTyisycB31buq8o7fn1sSsDtkgMDTbI2kPcHXF2niFNDAn99Za3vGXB\n", + "9oaCdt73vvdJKo+TXbJkycjnS6vk097nPve5Bd8nU5gK+Lyypq1YsUJSM37MEeYCawZr8aTmeq49\n", + "fiOwc9ZkrpMYODLJPQYKu3vHO94hSdqwYcPIcfl811g1Yrqw3z//8z+XVN6fuViyHLl2QpEKgiAI\n", + "giCoZGKK1C9/+cs578Gr/bbFvZBaBaivTA8yVoaqz5QLa6PdVC2Mb3/72yPH8fPEG0l5zVyfZ5D4\n", + "jt38jULFK//vOxuuL7huzs+VNK9K7fuL0S8oUHh71Ejpa2f3WlKZK6gTuTpm119//U7fn0DYZRLO\n", + "pbTuDpRm3rbdG4w+bqtIpWDtyykx2N607UXntFUM2tb5cuh/sr5QYHi9+uqrJTVPSXi95ZZbFjwe\n", + "2WKo8yiQ0wq/dVwvaxNrnteZcvw329fMvuB4tZX+h6qwD6FIBUEQBEEQVDIxRWpHUIK422y7Gzzf\n", + "b7vvlUPNk5tvvnnk/8QhlJ7XuHds5/pRktauXTtyHt/5zndGPp+6O0cxOuKIIyQ13ojXcaI/qJbs\n", + "4G37zuzEEtEOx+3qlffN5s2bJZXvdZgab6+IP237gE0bbXe2X8z0rQwR88T+n8TwoP763oN9Kwep\n", + "GBR2lfA4u2nB1zbWUPqp7W8Ra9tQFeT7Zt9995UkPe95z5PUzEFiwm677bZWx+sai5Sj9jeecaVG\n", + "IEocMYG5+nM5QpEKgiAIgiCoZCoUqZSyUUqugnUpHhvCXSzPz0tpG4/RFWJeOE/ab6v08Jycytb0\n", + "R+m+Q57151WH2UtuaOiHtvErUPs9oB9Q7rZs2dLpeNNK3wqS74k47nm0mHHlA8/78MMPl9SorFdc\n", + "cYWk/pQoniKQnYZNoD6n4vGmFda6WiUJ20UJbPvbMW44v6OPPlqS9PSnP12StHHjRknSWWed1ep4\n", + "Q6vJteOCUsZuJ4wTMXahSAVBEARBEEyIqVCkahUEPFjPtqu9a/VsPerpQC6baVxwdw30H/3gO3eX\n", + "giKFd8nzfhQqSO3Rl9oPKsVQz9OpbULGVtvjo0TiVbbNtOL6+Tz9yfFqsznx8om9In6h7fF8v7W2\n", + "YGfEwBFP0RXmc9vxYrwfyeBhU8fI91kktiSnRBHbUwoxWdgm0P60ZubmqI3bZBxQpYfOFusKNQa/\n", + "8Y1vSGoUxNrM4mmNbyTelXhW9tbrS/UORSoIgiAIgqCSiSlSMzMzc8oJygcefGnWG554ql5PLXjG\n", + "PP9HAegbPHvu4ku9IL/r5/zwzDn/tufNXTvHoWqwK3VdM1E4r6HqbLWtjO9QPReFlP7EuycDKee1\n", + "8T5eO96+VwIvBftYtWqVpMabaht7llIdUOIYb66fecC442VjL8y/rlmzrAPYRamaMe21eoYEW0V9\n", + "xUaovo9tMOa5vmob00N8K2sFsVm0h01dc801I+fZlaGz4ujXtooac55+XCyKHLs58DouUO6Gjodk\n", + "XpDBjoLKb11XewpFKgiCIAiCoJKJKVKPfexj55QJ7kp5bVuHiee6PJ9GQehyblITE4Vy1Dd4+ryW\n", + "xmC5IoUH79l6bb0h2keRQGlAKegLYs+mJebMoT9RXhgf+gOvm9igVD/z/kEHHSSpu7Lpe9uhOtQe\n", + "x2HeuXeIiuHX2Xf8B0qixwDmKK33NQ30nenox0upvMQ/sr9pqj5Q2zGlztLll18uSVqzZo2k+QoV\n", + "CoDv+9kWfiOYS0NVakehoJ3S7ENU3K6Zv4uVUmWHNZV4TX5z2DVjKKgbxuvBBx8sqbFPrytWSihS\n", + "QRAEQRAElUxMkXrc4x43p/TwXJnn53gd3LXiDZA9xv+5e+3rLtbvpr0OUt/gge+9996SGkWtbRwB\n", + "3ijnzSvHa4vvX9V170GHfp3W+AG8SfqVv4kBwuvPqQrYLbVpul4v7XWtx5XyllNqxLhqAfm8n7aK\n", + "910YKhYERSZniyhXObW+VilDzWQtR/Wk3b7Gkt+A2rg4xiFH7EJQR+kuI6yFKJpDxSHnYC33zPS2\n", + "hCIVBEEQBEFQycQUqcc85jFzmQ14MSgo3B2izBBZTyaFZ0vh5eFR12aGoOR0zT5qi8fitPXevG4U\n", + "508/tH3O795z31lRfStcfYO3RP/xN/2KnZbW3EGRikrdO6dU6VuMDDX2pX3F52ozRnOwxhBHCChm\n", + "XWOZWIP4bShdo/ntQDErjfdkTW4bO0M/EIu2WG2ZOEXstjSbre1vBf087n5ye2q7p6ITilQQBEEQ\n", + "BEElE1Okdt999znlxWN8UERQArjLR4nyvd8We4ZEVwWMzBi8CO6yydRBQbnqqqt2ehxitdavXy9p\n", + "/rg8UuB6PQOK/kA5zClSeOeMB9mK017tGLtJxYlgT3yOGEXib2rrgy32atjTTOl+mbV4prDv+1lq\n", + "8zx14DfA42ZRlEprxbnS4Wstc5nzxrapGUfGLbs55Gxz+fLlkholbLHaMrFObZXEthn3vmvEuOCe\n", + "gjWra5x1KFJBEARBEASVTEyReuihh+ayw1CU8GK4S8TLmdRz1No9AMcNigf9Q3+hmJTG8qAIcBy+\n", + "N1S/44WghFF3Ca9uUqxcuVJSU6cJO6A2Ds/X8YpTMW2+5x/9ecABBwxx2sXgbbsXxvWhnJEd6HWa\n", + "GC+nr0r1067YBfNh7SAOExtru2cbihNziuPxf16Zk7l40lz7rDUoVa7A+L6ZKYWJ80K5YveDxQKK\n", + "n9eMa7v218YCjjtDl99MlLeu+76GIhUEQRAEQVDJxBSphe7YU1VhJ5X5MK1KlO92j2LA832y4lBC\n", + "Sis/o1BcccUVI8fzCuReqXvz5s07PU+8DfdW8GI93qGv/bhqITbowQcfHPk/14E3k4sf4PvuFXet\n", + "WdIWt5dUPAAKsdcRcxifrnsa9kXflfcXgrlANtauimfdlYKKy76SxM+1rRTN3n1OX9l/zq233ipp\n", + "fhwoShhzJRcnyhxvq8D1Ta52YKpWIWvzPvvsM/J3raIIrD0oXqjWtJ9SwJYtWzbyfdZSlM5aUKDW\n", + "rl0rqZnPHLe2dmQoUkEQBEEQBJVMTJHaZ5995rwWanVwd4qiwt0hni93rewovnr1aknNfj0pTxov\n", + "CWWGGA8yDPByeD7qz0+JHeEuGi9r6dKlI+cJZJ649+SVm1P1lDz7js9xt+7eRGrfrFq+//3vS0rH\n", + "vFBzI+dt5jI4Us/Ta/c76otU+20VmJQX6/EA++67r6Qm7gNFzLNWsVvsg5gr/x79TqYW8wzcK83t\n", + "j4VXiLfq2aClNVjwAplPnC/zlvaZh1wn85B2ieFK7Q04BPSVZzKytnCuxMiwBjA2d955p6R0LTff\n", + "Q444UVfAvJYefcFawRqXq12GzaEud83MZc5gE1x37X6Q4yJ33UNlLJNpTX/x24cdsEZgT8D7jBvj\n", + "zxxmXIE5yxzFTlJKk+/bmoPfMmCusmZwfZw3axh2zm8bv5XYN/ONtaF2H06HfuUpCr+pXdX1UKSC\n", + "IAiCIAgqmXl4AgEpMzMzmp2dHXezQRAEQRAErZmdnU3G74YiFQRBEARBUMnEYqTGoUjRxmc+8xlJ\n", + "zXPQVBYbsVc8h+V5Mc+veV7O9z2GiPbOO+88ScPv2Ud741L3Flt7xAcQ18Jz/1TmyqSuD3sh1o/M\n", + "JTMqscQAACAASURBVOIIeI7PK58jlojPE5dAfAr2ynW+4Q1vGGl3aGhnw4YNkpr4CDJwOH/OFzxb\n", + "lrgJj+Ui3oFMobe+9a3Ja0vVzoLSmnHEmJx22mmSpHPOOUdS0/cew0EcF6+8T7wX7REjwlqD7RJP\n", + "9id/8ieSxj925557rqTh6vwwF8844wxJ0vvf/35Jw2e/cX1nnnmmpOF3b6C9888/X9L8jGAHO6F/\n", + "iJnjNbXrAHPlbW97myTprLPOktSsHbl9V4mxSsUO0T72y+f+8i//cuQ6+8Yr0NPO1772NUnNdXH+\n", + "2OuNN94oqVk7nv3sZ0tqYrPI2uR9YrmI26a6wItf/OKdnl8oUkEQBEEQBJVMTJGSmgj/VPZaKdy1\n", + "8+reBXexuXpKvh+Ve8DcreYyGvCQXUnwukq11815BDsnldU16TpVDpXO8aZcFbn77rtH/l6zZo2k\n", + "xg54RVXxWjLjyGrbGXixzC+vHkxmGtePl8j6wP/JPHJvfsfj0RZjzNx11csprRnnNblQqGgHm2Pt\n", + "ILuKtYdzR/1GeeF9xgqFatK2OrRSk6pnNC7GvY8oNo0doDzxm+G7VHB+2AtPQVKKlEN2IPaNPfI3\n", + "cwp7Q/lhDfFdLlCi+Ny4MqxTFeVR55/ylKdIkg4++GBJ8zPdeTpE/2NnrC2sqaxFXGepEhuKVBAE\n", + "QRAEQSUTlTa6KlGAV5Py3lLPg3O4t8JdbG6Xe+6CUQrwOnjeXOtlpvYDwpuZdFXdSYMX5TFE7s3k\n", + "6iaNG8YVu8CuUlW0r7zyygX/v2rVKkmN+uJxN23By6MfsS9Ul9L6Ubl6Ylw314vXiNfse0jujNSc\n", + "TFXMzkHMSYqcyo1n67XqUrsB4OnT16X7ZDrPeMYzJDW2j9LB+Vx44YWS8msRtjmuXR5QXmrHq2+Y\n", + "O6jGKBvYdNs1xNdo7IF2iOXzeEnWtpwS5XOdmEDGkVgir5XIeWzatEnS/H1WuX7mKL9ltb+tfeFr\n", + "OfOMewv2b73lllskSTfffLOkpl+8lh6KlsdkZc+jwzUEQRAEQRA8onlEBNv0tSs9d/G5u9RST70t\n", + "KY/8ka5EAcrc+vXrJTXe4zXXXCOp8ao9C3PSEDuEF4rXx2up4ujZbLzm9t9KwffWrVsnqbH/m266\n", + "SVJ/dk68CNfp8Rgou7U7s3cBDxcVmmw6wMPn1eO38Hxzqhxj3VeMEH3JHnh42jfccIOkclU8d94O\n", + "e/Uxx0pjeaBUifKK7LTT11MOwAZpDxu86qqrqo6X2jeWuYodsBawhtFurj99rnNcfgP57eK42Ddz\n", + "O6U8plTtofcNzT39Yfy5LtZIlDL6m/dTv92sZSh3tFtqT6FIBUEQBEEQVDIxRepxj3vcXEbB1q1b\n", + "Ox2Lu/dURkNfNVCGqqUS9APxFex/xj5V7PfF374T+aTxmCPiD1BmsG8yZFJqAt4W9o+91mZ5opTh\n", + "1RFPMVSmDsdFBeD6iUOapPKKp+9xa2T9cK47yyjcEZQbamtxjbSDwlWrUF199dWSmrEn9oaYkaHA\n", + "kye7sa0iVQq/HbRDvaC+FSnmIrFDXa8nZ8PsLcdcxp5cpUZx8TXMFRfsDPvEnnhljfA6Sm53vs8l\n", + "djsUKF0oq8QsuULK9aP8eqzUPffcU9Qe/Uy71G8r/Y0IRSoIgiAIgqCSiSlSj3rUo5LP33ke6zUs\n", + "vDIy4DmnntemnksHuxZe6RvvzjNLPKuybVYbChHZcV7nqS14f8wHvGCvrI/37c//ge/jxeGdts38\n", + "Qg055JBDJDXz6v777x9pp29Q2lAVUlXIxwkKANl79C0wBql4MRQm1i6ORywGY8m18vlczEoOYmA4\n", + "HmOGDQ2l7rEWD632oi577M9Q9KWs5WLTuC5eATUYO+K6vZ/9qQlzmfHHLphjXm8JRZE1x9thHrB2\n", + "kgUHKGC0g73nslsdj1Xiun3N43z4HPbua2oO1jbOFwWs9LchFKkgCIIgCIJKJqZI7czb5K7dM2Tw\n", + "prjr5K6du9S+n48Hiwu8issvv1xS4827IuVxK23jULAzV3pyFfZT+B6AgHdZmq2G97V69WpJjVfX\n", + "Vn3A+6R9FDf3PodiWrIppcaTRvFwD5WYo5QC44oUni7fc3Wdta8vxYjjsUaSxefn0RXfC47+Kt0N\n", + "oi0ogJz/JDI6ayh9OuJ7P2InxCql7MPnDn/zyprF2lCq3FCHiZhAlCD/zfU6aChUbRUpr+ye2h+V\n", + "9rzuVerzObgvYZ5jzzlCkQqCIAiCIKhkKutIcReKksDdLV4I2VlBsBDuveFFoVh1BXtEISWeBQWn\n", + "rRfE54lnALzStt42x/OaPqXQHgqU7wDPdXO+ffUruHrhascksvdQWNgNHnKxQF4NnmsrjX2qrUrv\n", + "kG1F9Xuupy9FirhBj3Mb6inBpCtq11I67kuXLpXUxBqhIPHbWLrGsIZgp6ndMXJgL65MeWwaf7eN\n", + "UXJ8VwNi78jGg1TtPP7P2lxqL8w3lNRQpIIgCIIgCAZmKhUpSHmeQ2doBNOFZ3Hm8OfqZGK4cuLx\n", + "Am3B2+H8auuMcZ5e2bt2T0a8ObzR2srmrkShQOGNjiurzqsXTxOlMUCopKh5qbHFBrCtrrE/jP2B\n", + "Bx44cr59K0VkyFKviv6Ypni3LjDHeR06JsvridXWvsPeWDtZ61gb2q6tfM/3kQVX3EoVKV+rUeKw\n", + "H+4FfA3w7ELaZx7x9KpUkSIum++RLZkjFKkgCIIgCIJKplqRgrVr10pqdkxfrM/HgzpSikpODfB4\n", + "DcCLaVtfyeG5fVfvlPPwPQDxsjyDJwdeFd5UV+WI9qkmjRfaNhOnlmmqA8eea+A25LvRA2OJh56y\n", + "PfqWsetas8uVL2JM7rrrrk7HTcF1l8aWLBZYa1B4XK0tpbSuEp8jzpPfPMYPpcpjhLzOGXbEWgVc\n", + "B58vtbMnPelJkhrl0Wvo+RpVmq2JnXpsFOdHP/h1sGZ6lihr4IoVKySV2zvtMQ9LfyNCkQqCIAiC\n", + "IKhkUShSKFG1cPfel5KVUwiIIeHu2e/Kucvl7jfqX+2clPKEF5N6H2/MvUe8HV5rqzD3VeH7yCOP\n", + "lCStW7dOUuN1up1t2bJl5G+HfqDGC8/5a/faA28PL5jj5hS52pou04hXuHa1LDWniXmiz1IqG0pF\n", + "X2ofnjWeO+c1VOzSrhYbBYwbqiwKUNvfFN9b0eG3g5g22sPuLrvssp2263OV47HfKL89KEqsEaVr\n", + "Ge0yl/t+OuRrMe2wlpOJDF4/irpSbRUlYFyI+Yu99oIgCIIgCAZmUShSgIcOnp2UunvES+zr7jkX\n", + "q+L7JDl4a6FElZHK1srFzqDsDBVTl4qHcfCiDj30UEnNTvWAF3TnnXdKarxdV5Jy+6+hBnzrW9+S\n", + "1KgQxFscffTRI8ehX1NKEbVs8GqpRUTMle8FyPkTfwHEN6BckYEzhGpROia1kE0ErD2prCJAJeT8\n", + "Unu3EVvU1151eObbtm2TVL93Xym76prGGkL2ZW2Gbi5Wh9+O733ve5Kk5cuXS2rsCqUkha+JW7du\n", + "ldScN2sNv4ltlc9/+7d/2+n7XSvZu91zPBQzf/+mm24a+T+KFGsUtSdL40ypncd8Zr4/73nP2+n3\n", + "QpEKgiAIgiCoZGKKFBV2pcZTxVvj7pu7TO5uuYtOVWnFs3YPO7L8HlnglfCKkoJygneCt+EVxQ8/\n", + "/HBJ0pIlSyQ1cQp4Obxu375dUuMtoYAtW7ZMknTYYYdJaqo+e/VnwAtK7WVHjBHxDBwHVSOlXnhV\n", + "YEAhI04CxcqVKm8fxYlMHb6HcpWqf+XVjr1KM2oNShbH8axIr13DuO1Yb44+YiwYc49NYcy8Oj2e\n", + "O8oQahy4rXAuXCPH4ZwYg1z19wMOOGDkeJxH2yrujBV9iHKSUor4PP3EnAH6h37wvc0YG88qoz2v\n", + "h4TNEfPidYiYOynlxmu3gcfKoDz4PpZ8vxbiLWtrs2HrKCXgSuQ999wz8lqLt8Oca6tEcb2cZyou\n", + "knnG+PM3a5VXJgfmttfU4/uctytdKHcet8nftRm/bbNaQ5EKgiAIgiCoZObhCaTSzMzMaHZ2dtzN\n", + "BkEQBEEQtGZ2djYZTxqKVBAEQRAEQSUTi5EahyJFG7Vttd2HiHbOPPNMSU0VWM+U4Hkxz3HJaiJe\n", + "gOfaxOL4fj/EpJx00kmSpE9/+tOSmswc4hqIFyEWiOvh/zzHJh7D4wuIJyDOguv77Gc/K6mJPaJ6\n", + "LMe96KKLJDX1v17+8pdLkp785CdLkr7xjW9IauINiL+gf4g3Wb9+vSTpM5/5jKQmXiCXGZV6Du/Q\n", + "TzxXf8tb3jJynUNDOxs2bJCU30uOWK1cvE2uPb8+4ksYB2K/vF3iFahJQ1wMdkt8x+rVqyVJp5xy\n", + "yoLtDcXs7Kw+9rGPSWpsm3PzKvdts/qI7eH7p59++lyb44B2PvShD0lq5tp9990nqYlZ8dphnkFM\n", + "DBJzPmVzXdfOFF5TjDn7tre9TZJ09tlnS2oqU7MGcR0e68W4EGPGWostegYpa8Ob3vQmSc3cI26S\n", + "WC76pzb7zLPEhurPFG4vqTpRnCd2Qz+X/uYxnmeccYYk6YMf/KCkxh6H2pNwUv2ZIhSpIAiCIAiC\n", + "Sqa6jhTZRV67ZVx03eMLpQYPHy+Lu34UJM9AQanBq0IJIGPCvSyUIbwtFCtePfODCtp4KWQ+oDDg\n", + "ZVD3iIra4BkwZPJwfe6NkH3Fca688kpJjQKFl0wWmO8Nh/eaU2xKlSjg+j1zaNzkrgtqlagcqDOu\n", + "RHm7qfbd60xlH44D1DXPzmIuM3dStpKq48T3ahWKvsBmU9lTnqEJKC2eGZ2DuZ36PBW4WdM4HxQi\n", + "XrEdX4u8VhoKCWsDa2NK2UDd990KXGHCHnzcuS5e264hKYau11VKrmI554my2RaPGeJ4u1pl+xyh\n", + "SAVBEARBEFQy1YpUX0pU21inHMSS4A25t8Td+A033CCpUVjwylB+iIXKVULPVbOl5gVKFq+33Xab\n", + "pPleCbFLOe+UWBivZcPx+D+Kjtf5AWKmUBg5P5Qo/7y3h9LF+FHPCLru5bbYvaddZS+75z73uZKk\n", + "Sy+9dOT/K1eulCTdfvvt2WMwt3hFicDWc5W3UzW5mOOTVqTagirt1fNT+O4RHrfoUNOM76HooC7T\n", + "bqoekitoHIe1gvZZM4jXJG4UxYzPsaay5qPWszbVqrqpit2027be165KXxX5FxuhSAVBEARBEFQy\n", + "1YpUX/SlRAFeUS4jAe+Kz6N8tFVA3BvyuAK8Iif1fLw0kwJv3pVBvA68fvqX/+NNepaZe214k/QP\n", + "7bhqwPP7lOJCf9R6Q213CJ82ul5/33jMXynYB0qlx9eUgM0yx8hG4pyYK2RlleLf74vavck8jtBh\n", + "btEPpbs7eGxPak85r3Ttu0qgRLXtZxQq5iSxaa5cpdYSlDPfo42/a1VbzsOzAYeK32XnD+zulltu\n", + "GaSdoB8W9y9IEARBEATBBHlEKFJ9U+qF4B3h1fHaVgFxb9XjFXIxVrWk9mPCu8M7x4sljsH3SkyB\n", + "koV3Tf+44sb7qfiWUoWPDB73zoeqdTIupkWJAnasbwtqAXE9Hh9TAnWFmDMoVBwLlRTVdOvWrUXH\n", + "9f1A+2KomCtsonSPtBQpRYqxIn6T/Re7Qjyk19bzfVUdXxNRclibfC+3thAP6+0NNX6ldtkXZGgz\n", + "X4iPHUpxY3zIIOe3YNOmTYO0NzShSAVBEARBEFQSitSApGKz8I5zGUQp3Atyb6kvUrVQ8MZQgmgf\n", + "BQsFKVXTBsjkwVsmE8e9/r4UI+IoSuNFphX6Czviemq9Y69sTvxJ25o6eP3UFmoLGWCHHHKIpEZV\n", + "QZG69tprs8fA5rBJroUK2tRkQ+Hw6v0piPXBhrqCIkYcWN+1t1h7chm/XcEWDz/8cEmNzfCKbaXU\n", + "bcfHifEhTq5UnWRtYvxRKj0rMQd2gpLJcVBUrr766lbHm1boL+bc0LUbsU+UR16JBVts2bGhSAVB\n", + "EARBEFQy1YrUtNfHyZ2fe694VygvKD5tY1xqs6L6wiuXo6zRD3gTuRorXD/xFSgRHiOVi48ozcpM\n", + "7SG42EDFQEGijlhpdhvjQj/gpfN3rhpyCo/HaQs1gDx2rk3leY+VYczxsD3TtLTCd+r4paBooNzw\n", + "N32G4pXLxps2sKUlS5ZIauYU/d42Y9orjWNLuTpNrInYCudB/Ch1rdqeD8dDZSVbD1v1ell9k6q0\n", + "3zfjjsnyjHaukzjWvirMj4tQpIIgCIIgCCqZakVqWpUoyJ0fNWyA59B4n7UVtV2xGTfEPfhzdbw9\n", + "vP/Sar9eh8q9fhS8VExZaS0evl+rmJSSU9C6wnWyd2HbGDm8PuJRiNdhHOintjF8jF+tonXTTTdJ\n", + "ml8Lij0rS/CxRanARlCkateW2qwvbAIFgzHARvqKvWqLz+W2sD8j30dRo7/b7jnH2sH3ec2dH+Ps\n", + "SofXqGurQjMujDvKDbFaKHK021cGNfaBvdDetOzh1xWvUchv4lBrJkpi7dqUIxSpIAiCIAiCSqZa\n", + "kZo0XZ9Pu/eJ99fVqyhVVLruMYiX5efrsTW8z3mRgVEa70G8CAqePx/PKVtt1YWhMkLGpRR2zcTy\n", + "PRF9PzXsdqj6ZClQi4j9QilrM19cMcL2OUZbW2HOEiNTm/FJHBu2zvmg+g0VY5Oj6z6TZEkyd3mt\n", + "3dPOx4v+R5VOxagx7j63UV1Zg9v2M0oQ14OCwnkwnthVX3OGcSF7kbU1t1fiYoFx8Bg4/mYc+4oN\n", + "G0qJglCkgiAIgiAIKglFagHwqnheW3tXjCLkO9Bzt932eX3bfblQHPBu2iphKSWL6/G6THh9VKbG\n", + "eyPDJcVhhx0mSVq5cqWkxnv39ugvHw/6FWUl5X3gtbZVzEoZd+0T3z+M15zKgB24V+jZe7V0rf7N\n", + "OOONt/HyuQbfA84zCkvnNH1JX3e9NhQc5hZ/l8YTTivEoGA7uRpyKRgn+oc1DFvwOlJ8ns+5Yuj2\n", + "UAuxUdSRwi5QpvpWipgDXE9ttmhbavd+rIVxwW5qM9knTShSQRAEQRAElYQitQDcFddmEKDMoJDg\n", + "veBl1Xq1eAlkyuToWicp5ZUQF0DcAgqQZ8jklChA2eJ4xMYAMTNe5dj39Mt5MXitQ1WCHxfU7KHf\n", + "8CJvv/12SXlFirgcFDkyZlAVumbOUO35BS94QdX3sR/mS5uaMlw7toQigWdfaisOtc5qs/YA5YLz\n", + "61ovp+86Q6jJbWGtaGs7XmmctZe1hMzUlMpMPF9KjcbWWTO67mrgKnbpWlxLbWxfLeNW1ffff39J\n", + "zbjdeuutY22/L0KRCoIgCIIgqGRRKFJ4XXibvA51l167Bx7g9RDrs9iqFecghgzv1RWk++67T1Lj\n", + "LTJevn8TXjkKF+Ps8QB4m+7tovyVKk27Sg0Wz9pbvny5pHJVwvsRL7Qvpa5rP6NGYEdt5jlqL7aG\n", + "bXk1d6Av/HspW227V5uDysY11da3Ya7k4hjpS+Yo7aUyP/3/XhNtn332GTl/1FHiDlGhU3GMZNFh\n", + "a8Q+AdeD8sfnUjFCvrefwxpE+22q5JcwtIKDErqrwvgutkrmTihSQRAEQRAElUylIkXsB94f3o3H\n", + "HKH84J3hdeB1TQrOk/NBwfG6S7nMFr5PZWe8NDJHJsW1114rqYkPwCtz5Yn/p7x4Pk/cCN4sfx9x\n", + "xBGSmuwyXjkuXmrXuAcH++G4xCC1jf9AFeirJopnKKECYF+oCd5OVxUlB+eBd4lSmMIrl7uCxf/J\n", + "1kNN8axCxn9HxcpjVugT5hIKFXWh6CtUY9rwavrYXteMRjJ5saVUTbYcOVtizSAGBVhzUoqUq39P\n", + "f/rTJTXKlis8jBWKAtfBnoJcH2s0Kj0KnKugKFQch/7yNYC5kIoHRC0nvpK57HOYfSuf+MQnSmps\n", + "GdvzbEpirbiugw46SNL8yvXY7ObNmxc8P0DhIxuxVH3lvBkH7L62ZqAzVPae1xrEbvg/CmfXWnk5\n", + "uD7mR1flLxSpIAiCIAiCSmYensCGdjMzM5qdnR13s0EQBEEQBK2ZnZ1NKoahSAVBEARBEFSSjZF6\n", + "9atfrX/913/VE5/4RN1www2SfhNP8JKXvETbtm3T8uXL9YUvfGHu2fA555yjf/zHf9Ruu+2mj3zk\n", + "I8laMueff/7cc1Kej5LRQQwOz7UPPfRQSU1MBM/ZeS5NRWziGnje/MpXvlKS9KUvfWmkbZ7Dc7w7\n", + "7rjjN53x/5+bUmmbWJ/bbrtNUvNcnmsllovzOPHEEyWpWG1rGxfh0A6vxMoQd8D5ES9AXALP0+l3\n", + "4kZ4n7tuxoPjvOxlL5Mk/d3f/d3I/z2GjRgjsq7oH86DfqdaMNfP94gbOPXUUyVJZ599tqSm/+k3\n", + "rzzP+PG5tv1KP2Iv2BPjTY0T6jURq/anf/qnkpr4je985zuSmrgS+hc7pV9e9KIXSZLe+973SpLW\n", + "rVu34HUSR0DcBv+n/z0ugvfpd+I4nvGMZ0iSLrvsMknz+5/r5PqI81izZo2kJl6CWDbOhzgixpe/\n", + "3/rWt0qSPv7xj0tq7NKrhfv8Zzy9DhnXlaqPNjs7Ozal2+fertreP/zDP0iaH7NCjND69eslNbbB\n", + "WortEePE91lbmDvE073mNa8ZaRd4vzYOkjmMjTO3Tj/99AXbK8WzIh3WYmLSaOeLX/yipGbusuYu\n", + "W7ZMUjMniROlHc6bNY+5wJrrMVovfvGLi66Pdvne9ddfv9PPO6zZ73jHO3baHufvig5rPefPnPds\n", + "WtYMrvuv/uqvdtpe3+TaySpSr3rVq3ThhReO/G/Dhg06/vjjdeutt+r5z3++NmzYIOk3gXWf//zn\n", + "tXnzZl144YV64xvf2HlTzCAIgiAIgmklq0gdc8wx8/YR+upXv6pLLrlEkvSKV7xCxx57rDZs2KCv\n", + "fOUreulLX6o99thDy5cv16pVq7Rx40Y985nPnHfcBx98cK6iMni2FKSqnXLXyl0sGRW+wzd3+aX7\n", + "FeUyBny/J+7m29J3XSPPAiTjJNV/eP6pjIVUbY9cvaFUxkduzzT6A8UG8FZQLryGjiswPj4pUFy8\n", + "ZhD95sqlZ4SR6fWpT31qp+2QYePHB/rpuuuuKzrvUlAD8OpQpBh35hn96NWp+RyZLd///vclNQot\n", + "XjcKFPbnXjr9m6pfRf/maimVVOpPeb5Oau+2YBTWVIexQMHwtRV1caHMSqmZO7kae10zcnM1AVmr\n", + "XF3Prc05WyRb0Ndkzgdbp3/5LfTfrlQ7zB3vH1/LcjAuT3nKUyTNV6SoUZfaS7C0/llqPrIWorz5\n", + "GuFCzLTWAqyKkXrggQfmDGXfffed+4G87777RrYYWLp06eBpjEEQBEEQBJOicx2pmZmZne4/1WZv\n", + "qrbVfTl2rh4Tz5Hda2pbKwPlwyusd90RvvZ8ppXa80/Vacp5pV4jKAdKTQpihFAruJ7avQvxMvG+\n", + "77nnnqrjlIJih9179ehLL710we+594ciSVyH4+Oc6h/Op+vej15leyFQQtyzd1CReUW17htUT1RJ\n", + "1iBUwGmvXI1SkFJ2UHK4LmyIv1NPAbBN4mT7hrWU+lCucoOrothqV1L1nFBUsE9smf7oSttadYwr\n", + "ayxrI+PK69BMq9JUStUdwL777jsnSW7fvn3OWJcsWTKyMNxzzz1zBbaCIAiCIAgWGxdffPFO369S\n", + "pE488URdcMEFOu2003TBBRfohS984dz/X/ayl+ntb3+77r33Xm3ZsmWuMm4JJR7njqS8T1eIuNtH\n", + "ESCTw2NDcnDXzF16rrpuW2qVHM6H76eOUxo/4ky6UnwO+j/ldTqMey6eoG28gUN/exxECtQLlBu3\n", + "KxRRMl3wHokzoB3PWvRK46gwOdUmBfbA4/3cPlmlsYk5StaF0msi3s33iewbFA5UQdasm2++edB2\n", + "gUxQQizajrlXeAdsirUVW0PZyKmPKCddq/2nYI0rVTpYM3NqdSk5dZY5xG8Vyl/tnKyF6/7Wt74l\n", + "af5vYi6GEOWvFP+Nx1763p3CYc2j/7kXKK0Ef9xxx83FhS9Ethde+tKX6pJLLtEPf/hDHXjggTrz\n", + "zDP17ne/WyeffLI++clPzpU/kKS1a9fq5JNP1tq1a7X77rvr/PPPb/VoLwiCIAiCYDGRvZH67Gc/\n", + "u+D/L7roogX/f/rpp8/V6MjhNULa7mmWunt3BQXvhLt/vCDujtl3qzReAQ+b5/tdY6Tw7HkMirfq\n", + "2V0puF5uWlPKR20R+677i00rqTpeZKn5nm9tob/x2lEjUl4yj8hRwmgfr4n5gb0yfzg/FCmvNeNe\n", + "NrFkPn9Kd2Dn+DmFDfra/6tPxuUJE795yy23SGo8/XHtdo/NlMaOOanP02/YWNt+ZA3OKR4oCNh6\n", + "KvbKlQ5srm3sTV/xqalYK86T8eA3py9ljuMCcz81B1lj/DeXfvPjOW2FEs6n9ulIV7w2XV9EZfMg\n", + "CIIgCIJKOmftdYG7f+7S8TpKlRgndfftFa9p17PvvApuykvwjJPa8wUUhVrlY6i7bOgaKzSt+HiD\n", + "Kzlkk9aOM95eqj0/H+yRecH58D5eIvWcqPSfws+7a8wS51/q7TNf2mbl7kqgvLgH7llvfUNdoNrY\n", + "n9x55epA5fA4QNR9bB+1njXcbYjYF6/5RmYsc4ZXr4vllbP7Uk85L8/GYy7SDsqkV/nnfIjhS9Xu\n", + "c2XHf7Ny10M/8zSEtZ7flNya11ZJ65q5W0vpU65aQpEKgiAIgiCoZKKKVF8ZEp4J4XfhxPigeNEu\n", + "d/mpoqHc7fPqx8HbaJu5sNjo6i3nntN3pfZ5e67qMeeL11arSNEOSlIqDoP/0w79TvucD8ejYn0q\n", + "a5R+8fPuq+5ZKW3HnXlV099da7G5QtEXKdtkzRpKkaLdaa1N5/GXvosB44n6iS1h295vKEEeZ4iy\n", + "4xmsjHdun862axj97nWYmLt+fB8fvpdb0zgvvt/26QHf47eQuMehsiknRdenRjlCkQqCIAiCIKhk\n", + "olIKXgAZH3gjbSHLClxp4O7evZFU1hbgDfDqe7v5XmbBKNQ7YnyH8grwatseP+Vd+vP0rt4ZO26j\n", + "pQAAIABJREFUShRecaoSP/EDxIG4902dLM4n562m6rL1VUV5KLqoM22VF5QPMiHp46EUImArLcYC\n", + "JWGxV3hui9tiqp6T74mH7aM4eSa2j59niwHjn1Oc2qqqtJ+KCUpdn1daz9kh55+rIZiCtYbv7WpK\n", + "1LiIO4AgCIIgCIJKJqpIec2P2rgEFCHu8lGMwLMC+TztcleeyyjwGCm8iHHVhJkUtXWkhs4mhFql\n", + "y9UAwC7wzrrWGqL/nvCEJ0iar5jiVXrtG7zE2rgdj7GCvhRUjrPXXntJauaBe7Vt22Me+/UOEWtH\n", + "jBLnPi4l6uCDD5bUxGcuViWqa0yZ11vieB675Hv+kQVJv6FQkUnNODK+/Na4YuO1BbuOA+ebitdl\n", + "LvqcqI1h6ysLbhprvS0mQpEKgiAIgiCoZKKKFF4G3gN36bVZWHgD/tyddjg+XhCfy93V++d9r71J\n", + "1cYYF7UKRpfsqx0hxqhv5S9VlZf2fEf72n2w6D+8Ts/kwRv2eAVXWFP9mJovrvhCbn+5XOwgHH74\n", + "4SPHQ9mjdhHQn7ksSWC+ubI1xHZTXesgtYUxJEuqdH/IaYX6TKy9bfvTbRbb4//8zVqCTbst8H/W\n", + "YmyIuYbtuXLmGbEcl++3rT/E04qDDjpIUpNZC8ztobZOq3164FmSQ2e57WqEIhUEQRAEQVDJRBUp\n", + "VzrwgL02Rg5qX3gFaUDJYF8jj4vIed54xtyl40Xi5fR9946XlKppMm5qY4S8SnFtddnabM4cKYWL\n", + "8URhwR5rq1BTZZk9FFPX49l8eMk5xTM3X2j3hBNOkCStW7dOUlMZHfCmiXnauHHjgscjG3PFihUj\n", + "x09V5m8b/5GaTyXHaTtGVM5mDRl67y/fdX6xe/7YHvtEtlWkfEy9cjnj4qoma6M/hfBxzK1d/nQB\n", + "PG4xtVuGnz/tsXb4+DL3U2tA15iz2linVCZw33XVap82oUx6hv60EIpUEARBEARBJRNVpNwDr401\n", + "8rt+j2VBieL43GW70sPdMoqWe0d4L3greD8e89IW7rZRBKjOy3XkFCm+l/K+8H5WrVolqfEaUWSG\n", + "ivEqjYlx/Dn/uLL/AAWpL7wfUsqce2set+DjhB0To+QxUby6Qrtp0yZJ0vbt2xc8j1xMHOdxySWX\n", + "SKqPHSslFTO1EFxrTpFizpBJ6Woac5o+JBsstedZDhQVroXzdLV72sipydjesmXLRv6P2pkbs1RN\n", + "NWBvPN8jr+1xUqC0sHay1vp+lyhP7OnHOPo+l3yOOEFfuz3jO3U+taQUKZRD3/eS81m/fr2kpp9Z\n", + "G44++mhJzVMY1o4U2HVKEWyrRHE81sb99tuv1ffHRShSQRAEQRAElezam8T9f9xb8cwPr2Ce2qU+\n", + "5cGnvN+2z4O9rlVpvEEuDoDrpR/wEmuVKLx1vFG8KF7xrvmb9vGKiEvBO8KLQ+FzBcX33/KsNtrx\n", + "rE/P+HHlkP5wb3vovQFTuJ1wHh6vwfly3SiLqfN1Re+KK67Y6XnkvOK2SiMxiag5qXgMV4Sxa7z3\n", + "EkXKz53YHWwDm0eJAt83E9vxvdq87lEpHo9HHaRpJxfXuG3btpHXvqD/qTjPXGBtREHk/yiGvg+q\n", + "r31+PakahqwVxANim/yfNcgzijnv1G8ICpbbH3A8r0PFXGEOpZ5S5Cqz+3kxx773ve9Jmj/HiH8s\n", + "tdfly5dLavqJWDHGh+P4bwLjhR3x/SVLlix4HG+PNY74TuYpaxW/pak4S8aD62e+l+6jG4pUEARB\n", + "EARBJTMPD52mslCjMzOanZ0dd7NBEARBEAStmZ2dTT5dCkUqCIIgCIKgkonFSA2pSB1wwAGSpNe9\n", + "7nWDt7UjtEPWF8/ViRki1ufLX/6ypOZ591FHHSWpeR6/ZcsWSU2GyOrVqyU1GQvEaq1cuVKS9LWv\n", + "fU1S85yX9nhuzH5ePC/m+Tv95PtVkTXnlbVPPPHEkescGto555xzJM2PT6nNCuS6yI6kv0477bSR\n", + "dqlZQj8SR8H3UzE7XhncaxsRx/HOd75TkvThD3945PuMD+NP3ARxDsQRcDyqKHuFdOJCuM5XvepV\n", + "kqTzzjtP0vxqz9gncSnY1+233y6psWv2iaPfsEeP26Afx2kvH/rQhySlY1ToC9/lwCtp830yEt32\n", + "3vOe98y1OQ5o5+///u8lNdlVZMsRA8KYEivisTVArAmxIH/8x38sSfr4xz8+0t5nPvMZSU1sCzZG\n", + "rImPuccz0n5qrzufC+Puz0984hOS8hXmWRM985s13rM7mRvM5b/4i7+QJH3gAx+Q1PQT/c+awlzj\n", + "+KzRzFHWIsaBtQW75vWUU06RJL3vfe+T1PQ/awlxql55/aUvfenIdX7nO9+R1MSAcZ6cPzFEb37z\n", + "myUNP3709xlnnCFJOv/88yU18bWeyexxum1rAHp7KUKRCoIgCIIgqGSXzNrL1Rzpi1QV5a9//euS\n", + "5tcowVtw7/Cqq65a8PhkeODF3XLLLZKkO++8U5L0hje8QVKjUHDdtIdX4V4j3jbHg1QVW8+iGzec\n", + "f18V3vEec7VnyPjy5+J4PynoP7xRFB7GBy8T8HqwD5QoMllonwwWvErsADvES0UN4NUzXVAByIQB\n", + "vLY77rhDUqPOPPWpT5XUKHSoNPRfblxQXG+44QZJjT15/3P9a9asGTk/1BDfG5P+3bp169wxch6n\n", + "17wqrbpfkjE4Dnxt8zpGkMv4ZQ3yV4d6UKWhtPRj6S4Gtbsm9EXpXoee4ZzKbPV+TNWRYs6ztru6\n", + "zvFzNe0YFxQwbw8FCXxvQYfzYVw8W8+VxnHPC7dDP7+u+6Lm2ksRilQQBEEQBEElu6QiVVsdlue9\n", + "eAu5u+2U14XX6N9vW5cI74G7brwNjzPwCth49sRJoFzk+oUYLc6Tdmpr54wbYnqI2elasZ2K+Kgc\n", + "Xi8rBeOe2k/NK4cTf4BSSBwEn8M7TLWb21/Oxw9FjHY5P9/PjNg6+hV78urIHo/k14dimlMWiUNB\n", + "QfNK7SiBnO9Ce/u19ZBr93+sZenSpZIatc1VwUmR2neS8/WYsV2FvvYBLf2+11JLPQUoraTPWs9a\n", + "5+PjayBrS2q3CBTOlFo/bRX4+c0b9zx2QpEKgiAIgiCoZJdUpPy5cClkveEB56q5khngXgCxNXjM\n", + "qQyXHMSSeFaUV8XlfF2x4rVUoeP7tIsyUfscvO+dw3PQT56xURtbRb/i1bUtuUb7qA54l5wfoPSg\n", + "KNHfeLu5/svFBaWun+PjZRITRfuoFN/85jdHvvesZz1L0vw9EcHPt9SL9dguYsWI9/G4H7zRVLXi\n", + "Handdb5vuu7j2FVByR3XoW8n7fEPBWpu2+vL7UeZwtfS0lirFAupsjXwm4l6XDKnpoFpsctQpIIg\n", + "CIIgCCrZJRUpv8sv9eKIwSj1WlN37Xj2eMGQa5+sLN9TzRUFPy6KBB468QwpJcn3bvNMB88W4++2\n", + "oMwddthhkhrFiP2b+gbliP4gq6utIkV8AvW7UBE8likHMWdku5GxQ1wDMA6MC+df6hX6Dul+fm53\n", + "V1999YLHSWUj0n/Yl9fTylHqveOFX3fddZLm762Iksc4MK9L+mnSSlRfYDuMFWpm6b6cKVizHNTE\n", + "oWJjapUd8JptbandT9PrE00Lvp8oaw/KFXOGV9Ry+iGV8c7cZ076fp+PdEKRCoIgCIIgqGSXVKRq\n", + "vc+230tV1ub/OW8Hb4rK1HjcfD+l3LjShIJR6qHjtaBgeOYQXgbvp2JhcuDd0K+pzKC+ob3ajCi8\n", + "W6/e29Y+UAlQDVJxOnh5XjGddnMxUChv4IpUX1mX2BWZPaX1xbxaeIpUFiBQjRlvGKV02jKJhsRj\n", + "mdpWak6Rqufk6nffpGKzSulaW27cdaxYe5k7PAXoGpOE+u1rAePHmo69lK5lHI/fMs6fDN9c/zG+\n", + "/Ia0/Q1g7aB/ahXEoQlFKgiCIAiCoJJdUpFyxl19FQ8ZLwBFgGw7FCc8bJ5jEy+QU1Lcm+AuvdTb\n", + "yCkD9BfeXtf+6yuzZFwwfniLjFdbRYpxwQvDe3MvHCWK42MHeK05L47vpeIVusahOCht7POWy87s\n", + "Kz6JGCraq83OnSTE3/GKbeWq5aeoVeN8zFI2Vqpmog4yJqVxhKiuk2JS2Zz0e5vM051BfKjHuqUy\n", + "z3NK3vLly0fOj90DsDf2fc0pRF4pvS2MS2o3hmkhFKkgCIIgCIJKFoUihZdT+nzUPfBxexupOkx4\n", + "AXgPKDXc5XPevE+GDteN9+RenO/b1BXOm/MtrWni8Dyd4yzWzCn6FyWprXeF/aa8e9732DTsAW8M\n", + "xdHnQW2dslq84niuunBf4+7HT2WaTSOod3j6jDF1e0rp65pdPUypzqXxkZ5pXEoqznRcoKSNK1aK\n", + "ucCc57eidI1Mqb+pfmwb44Z9HnnkkZKaCug77mcpNap0brxLd4NIwfGnZa/LFKFIBUEQBEEQVLIo\n", + "FKm2kfrTWtuCmBuP8cBr4H3uvlEivBL20NeHwuD1g9rSV0bRuGF8eEVJqs1g4jioCV6Xi/FEWfK9\n", + "Hl2Z8jgBvLZUvEztOKS8X+yW+IucV+oKcVuFOcWk1Yw2oDLTV/RB25iPobLoUnO87a4Iiw3m1LgU\n", + "KeY+7aJA+W4CgCLI+DCX/HP8RriCSMYwNfzA5yTfX7FihSTpwAMPlNT8JtG+K6LjqqM17U8zQpEK\n", + "giAIgiCoZFEoUpOiNqMj5d1wHM+yI2uP/xM7xd2+xyi5V5qLjSq9Dj7Hc3u8ELILHymgFngdqVol\n", + "EG+d8XRvkAwnFBbGwWOl8Ab5nMdUpdSKWm8bbxbvF68Zr7pUHXG1o69aMNOeybMjxJpgW4xl24rk\n", + "Q+2B5vWHACWtlJzC47W/sLFJ0bWOVQ7PLGX3CuYEc9mr9gNrMWtESl0+4IADJM23D3aXcEWKNR0F\n", + "i34gG8/jMlHlUao4/xtvvHHB83mkEYpUEARBEARBJaFILQDZclRvbZtZUxovwOeoFF2KK0vUpMFL\n", + "8FgrrgevJuXVeqwW5zeuiuTTAv2G14xX7nWeShUqrxHk3qF7mR43QfYj3vzee+89cn54l6gbqdox\n", + "4DF6qYwYrg/1hM9RD412safbbrtt5P/A+fo+Xrl+zO2jNu1xEwuR2suslL4UKRQGxjSnzLC2oCBh\n", + "s55xzFrEnPGxdTVy0pmX2DL7afaNXy82e++990pq1NTUuHr8ZIrULhip3QcYP5QwFCjsgt+Au+++\n", + "W1Iznthv7W4JbdfOxUIoUkEQBEEQBJWEIrUA3G27cuDwvBvvAtp6yl33CsO7SMUzlNaBwktYrBk4\n", + "peB9ofSkauUM9fzfK72nvE3iTHj90Y9+tODnbr311lbtk5njXqZ7iagU9JPvmUh8h3vzrrqkvP2c\n", + "V5qzw9Lq2YsJbBE13Ofu4YcfLqnpU2KbGCPfHYHjMVZLly6V1KjPqIjYhEP8JsoVCofvC4qCwVrm\n", + "MTaeecz1HXzwwQu2Oy7aPm1oi8dIbdq0qdX3U3O+lNT1YVduXyhozE3/bWOca2mrRGGnqPGx114Q\n", + "BEEQBMEuxsQUqf/H3rkGaVZV5/+ZRCpJaSr5q0GUAWYYGIbhjggogxQBvEQhRFMUpCRGJV4RBRTl\n", + "orSAMCiIBoXSaOGtolKViLdQISBgQLkqIAx3BpCLVvxoVapMqvh/sH5zpp+e1Xuffc7bb4+s35eu\n", + "7n7fc/bZe+19znrOWmu/8IUvnKP88DtP8WQ58RTLU6nHrHgsBe+94YADDpDUve/FK8Nrw4vC88eL\n", + "4vx4V3vttdes85IRce+9984630JXYe2bWTMpfM849z6Is2Ac8ZYZd8ahpNC1ZlPiFdNOlKDWGDDs\n", + "gp3XUQOeeuopSXGGzaQzhUqgQpSI4nn6ZgGilgB2QOwev2PHntHkyhQqDLFYQxXdIeywww6S5l4L\n", + "bUctjOrtYDOsJStXrpTU2YireV5hGlWOMaFPOB5zhb5FgXAV9Jprrtlk+1A0aKdX+Ueh8jHmej2+\n", + "ju+zNkxaESrh/cA4sjbRfmystCciawz3FsZhsRFlV95xxx3zfo9+YXxrawxiP3zed+OIlCa/l9RW\n", + "2l9oUpFKkiRJkiRpZMkzU0h9WbJkiWZmZhb6tEmSJEmSJL2ZmZkJ34KkIpUkSZIkSdLI1GKkFkKR\n", + "4hylcxFXsGrVKknS9ddfP+h8F198saQu9sbfw1M9NopBIe7A9xLj/TJxGUcfffSs806a2v4c+3zn\n", + "n3++pP6xYMRteKxd6Xxr166d9XmPbyHjiDiIvqIucRennnqqJOnCCy+U1MVuUXeJuAIyZYhncPug\n", + "X4jPoNaPV6v+m7/5m1nXORbEuBHnQLvPOOOMiZwvYmZmZsFt8yc/+Ykk6a677pLUzVFiiMjQZM4z\n", + "dxm7devWSepszXcTICbk9a9//azzLlu2TFJXg25oXR4ykIlHO/744yVJX/3qVyXNrXBNrFWpqrxX\n", + "xCZO1eNIo7XFY2ta93YjJoc14UMf+pAk6eyzz5YUx+gQb8t5PVOUOccc9Oti/DjfBRdcIGludiPH\n", + "Ze4zDowr9sR1kE2JfXF++uvkk0+WVJ57HrfaukvAWPeGUvwr8ajvec97JHX3BvqN7FPmldfUY+1m\n", + "XB955BFJ3ZrMcZin9C/32ohUpJIkSZIkSRrJOlLqnjqjWip4f48++mjV8Uq1P/CKosyJqK4Qf/e6\n", + "QaWneLwUvCevBYJysVjr8uy8886SuqrJKH1kx/meeGQ20V9423hdeB983pXBKNsOJYj20I9UFcbL\n", + "wQuPFEevqeP97uNDO7meKGuO7/n3GX8UqbFxL3yaVYsjNXdSXHfddZLKNa+wSc+6i3BPGkUKGGNs\n", + "uTVzF1ulv3zt8b3xUFhKNfYA24iUqKg9fA5b6ls/yNvN2uj9xFoczanSWl5ScHxNRnXmunzuc53+\n", + "d28f18Haz3XW7n8JjPe2224raW7tPLIO2TVhUns9Qknd9/72vQLp36gfuHd4pjbzl7pZZPbXzqtU\n", + "pJIkSZIkSRpZFIoUT5HTrlqKgoBSRE0Rr07bCt4j1Xx5X4u3wfvaSBEB3uP6cf14eJn+nt0p1Ttq\n", + "jUsYC7wh2sN14bXxu+//hPeEN0z/oMDx/9r9z7z/8OIYD4572223zXuc2torgKKG94WdMK4oTtE4\n", + "uUK00KpNLYwf44RagJdYE4u20DW6iP2pVZrGYmiFaSCejrnkNbk4Dx68VzYv7euIily7u4IrVigL\n", + "pXsEc4Q6XLxlIFYGIvtgDpeupy+ujHB90T6SteMaKSWtSfjMtV122UVSp/zQX6X6WUAsIPbkdcyG\n", + "3uOxJ6A/Wfuw36F7OLJG19aETEUqSZIkSZKkkUWhSI1dyqqvxw8eA9W3gnMJvA+8Jbwfnt5rY0v8\n", + "KRlFqaRkRQoE3qXHA0xbiQKqO//3f/+3pM5L8jgCz/DBrvg73hDH4e+1oIwRE4UXh5KCd8/xI/ra\n", + "lVfyRknj+n3vvhLEPSw2RQq7du+1z/rAGJWI4hP7Ql/6XB5LXe9ro/Ca17xGUpdNSDyh47bj6jvf\n", + "Y23i99q1oTULDFCKojm10047SZIOP/xwSdINN9wgaa4SBW5Lvp/l2LhyxHhi66ivKH60D/W5NkbH\n", + "M4n7sn79eknd+HMv6Xs8xoufzEfufWO/dfJ7AO13ZZV7BrFzJaWNeVG7a0IqUkmSJEmSJI0sCkUK\n", + "z9730Ov7fZ6ivX7OYoOYD7yQvllOrXvD+fvjHXfccdbfh+40PinwHkre43bbbSep80rIbsT7G2sP\n", + "xCiOgVisEh7LFeF7S6J6UDuoVTFE0fKaR9Pcs25jJq0SSN010xelrLsIxmKsmCUnWhuiGBv4u7/7\n", + "O0ldTbuDDjpIUqxMoYB4RqmfH0WhNnurVYFgDqMcRooUsVf8v7SP5ELvg+q4Chyt5X2zMFvvCa5A\n", + "saa0ZuexRhFLx1rn2ZitRG9dsFPWDFemua5ahdf3Ay2RilSSJEmSJEkjU1OklixZMifbjKdYnsZ5\n", + "iix5i3gtPPUu1h2igaddno77KlJD6/TQn0O9j4UCr6CkmLCTPJkjk7ouquuihNIuVA6PCwD+j72W\n", + "4LjEKbjX2IrXDFrs409GFkruGNRmkZUgfm+hKa2Jl112maSu3lMpdgylwJU1r1FX8uhZy1njsF1X\n", + "IlBbI4UCJatUu48Yl3/7t3+TNN0aZpsj9PNY6q/HCKKUjRVvG8U/16rYtfHErIm1GfupSCVJkiRJ\n", + "kjQyNUXqj//4j+dUbMY7ccWkBE+/KFx9q7suNFzftJQAvEGUu9b36wtF7XjiZdRWoG8FJQplCjvl\n", + "/L5PFl4NilTfWkd4WVHcRClexlkssVC1oEixPtTWtHk2c+211876WSJSJ4mZYo3AdlH/PauLz/nb\n", + "BlRQ5ggK11hrNUoIc61v1lsyDszRsdRzp5SRP1btQ2oLesxgRCpSSZIkSZIkjUxNkdrYU8Djbn2/\n", + "7e/18YIWK0Nrq9RmEkTgrdHvfesQ9YX6R2QF9lXi8DJbY8ocvBrspG+2Ip/Hm8b74ScKqWfERFml\n", + "JS/K9wZk7vB3KqxT38rx9/yl+IDFAnbjtV/GgDg6xnLa2VyLFcbAY11QZT1jGlBHGTsHG26tkxXB\n", + "3FssShS15Z4tYB+TilWr3atxrDjS2goCqUglSZIkSZI0sijqSI399LrYY36GMjQrEa8NJQ+lg2q0\n", + "tXvP1TLUO/AaIEPthdgmrztVCzFGZH6RbYr3QvuimCWviUMWX9RPeFnsSI5KgBrA99mDz48z7T0s\n", + "+4J9s6+W76c1BoxRVNX/2QZ97n3saw22iM2VlB/fDzL6/+8rY2WHbi5wD+Gegj3V7jhQomRvYynL\n", + "XsesRCpSSZIkSZIkjSwKRQr6Zh89WxlaRdkVjRe84AWSupifsRWpF7/4xZLm7itV663RTrwd2oky\n", + "1FeB5Lxcd6tigwKF18Lv2G/0ft3jRkqVzmkv/YgC5vvFLZa9EYdCvA3jy+9jZusxh1AnFyrLC093\n", + "oVXC0t6C2GRJzewb37jQbweYG/Tz2Ofve48aex/ZhQbFtjauF+WRNQ17IVasrzLl/e32R7wpawX9\n", + "zdreqjSz60dtXGYqUkmSJEmSJI1MTZF6znOes+Hpte8+OI4/tU6qjhTH5f0v72NLMUtje6FDvWZi\n", + "T3iKp9/GrBy9MShK9Jvv2F2Cz/uO6a3jjMJx9913N30fL4X4joceeqjqe3j9xGaB77/lcN2cZ8WK\n", + "FZI6u+vbn16/bSh4rdjR0Ewlz7yZRN0ojk1fsIb0nVuuspYorQHYFmvGWPuGlio+R567q8asGdgk\n", + "/Uc7+9ri2DC37rnnnlGPi3KJms8uCozn2LXZUBBdadlpp50kSffff/+o58P+uR7sevny5ZKk2267\n", + "reo4ZJR7JjNrRF9FypU/V0w9vpR7G2ttqyJFBjT3mDe84Q3zfj4VqSRJkiRJkkampkj9yZ/8yZyd\n", + "xFvrBW255ZaSuve4vB8F6uywLxZPzSgTeFeliH+edvFa+TznB/f4F1vWFDuk423S75OqpYPSxbjg\n", + "/dTiXsXQOlwlUHpQ0vBKXBHDW3JvFPsiXoPjcN1eBwzvCXv0jBdYtmyZJGmXXXaZdVxXB0pK0557\n", + "7imp86q9/bX7bmE3BxxwwKy/j5WlOXas3qbAllrjDrHpsWJxvO9aVUPi6VDzWtegSC2tXTP7MrQy\n", + "tWfEOn0zdIF7Ee1iLpeUqNbaZ9jVvvvuK2ny1fxf85rXSJJWrlwpSbrxxhubzkv/u5I5qTWb87AW\n", + "164ZL3nJSyR14/nrX/96k5/LOlJJkiRJkiQTZmqK1J/+6Z/OqViMh413SF2ciG222UaStPvuu0vq\n", + "lANXPPDq8Co8G6gEXkz0fhfPHrweEwoEShbtob3uddJ+YmF+8YtfSOriD1ort/OenxgW+p/23Xnn\n", + "nU3HLUHldPpxofd6K2WeuL3ssccekuYqPNgL4xh5v147h9/9+8B56B/3gnxvRNqDPfB5vCzaFcWk\n", + "Ec+Cwor3y/zj+6gRnJd56fuloTj6vDrwwANnXRfVxImBQrFjXOgXjzvxebrDDjvM6oeNFT7P1vH4\n", + "Sa+ZxneZi9Ec5zj0EUwqrhBc8aGdJU8ZRYrPP/XUU03nn1TWHf3pe5mVlCiuy/dnxTZLCopnzNb2\n", + "J2BHtD9SMqC0N1zE448/LqmbC8yBSdU7u+qqqyR1byvWr18vqV6dBvoFZYvvM04+t1kbPN6VWDDW\n", + "Bj7vcdT0L+PH8TxukzWY8fdnD5Qt2se6UJ2tWPWpJEmSJEmSZA5LnplCoYslS5ZoZmZmoU+bJEmS\n", + "JEnSm5mZmVC5TEUqSZIkSZKkkanFSNUoUvvss4+kLkaIWJu+5yida9WqVZK62hF94X3sSSedVHU+\n", + "3r8OrVDu10fsE8ctZT0SJ1J6zx+db2y8ujTnOffccyV1NUM8I4SYGa/n5O/diW/xGCVidT7wgQ/M\n", + "Oq/HSHm8De/ryawhVu7pp5+W1L1/x4shRoiYpfe///2SpHPOOWfWeWhPqb4UNW2iecH/aS/n+8Qn\n", + "PiGpiwegn7Afj6ch9or4lNtvv32T52P8iOF75zvfKUn69Kc/PetzjKNXdH/00Uc3eVyH7EXfx+vD\n", + "H/7whmsjHpCx4LO0jbkR1T2K6iLRV2eeeaakzla4djJ4OT5rlx+XNYCxIRYJW+H/9P2RRx4pSfr4\n", + "xz8+6zzYTN+1ETw+lZgQruuzn/2spPo1IqJUEdzXligDlbi+oXvY9V3Ltt56a0ld+/v2R+l8pcr6\n", + "zJUoS5L/s6a/4x3vkCRdfPHFkuLYKtYuxj26BxKzROa7x05xXZdeeqmkbr75OHlMk2eTsjYwf6L+\n", + "4Hyf+tSnJHVrZW2mf9+dDEp2kopUkiRJkiRJI1Pda4/IeTxwz7hAWWn1tmrZf//9JXVP0Z4tSN2e\n", + "qFpu3wrbeA0HH3ywJOnb3/72rP+TjUh/uBfndbIAhaS2Dlerl1nyKrw9pXagdHCd7iXghUVeKIoE\n", + "XrVnlQGKi2daufIT7Uvm3iDXddNNN22yXZ6BhDqBWgJeobykREGpZk40b3xPwJJ3hkLB0qclAAAg\n", + "AElEQVRV2l+M73sWpCuv9CP9UKtEAZ/n+xsrW2T30Dc+BvRxySYjpSqKkeA8nsEbHZc5xBzxvqXP\n", + "vC89S612d/oIr0DtWVFj7d9YW2+K87sSxRijoPzwhz/sddxWfPcNMlGvueYaSePVRyopI6XrxC7d\n", + "PkvtQ2EqZXWSxVeyB9oZZcSX6qKx5kb1t3wXEeYHn4/uaa7ojb2n5lQfpFj0onT40tYbdKIPbt/4\n", + "+bvuuktS/Epj++23lxQ/SNWWUQCu67jjjpMkLV26VJL01a9+VdLc1wFOZGRD5fdaeD1RktdrZVY+\n", + "Fx2vNJ612w7Uvg7gwd4fpEitrb2uSI7347ZO6tp2OP7gz/n977w+4jpq7avkWJRSwjnvy1/+cknS\n", + "rbfeKmnu/PRNozcGJ41r81dmfbeqKNG34KVvz+RwA49sAxvydH4gLIJXm7VlGtym+q5tEVGR2dL5\n", + "gTnEjT96sPBXpox763XQHh7Mv/vd70pqL7Q5KXhA8YKUtD96VV1bFqP2nsqD29Dtp3iFyzxlvH1t\n", + "YZ6UnEq+z+d5duDBbOh6kK/2kiRJkiRJGpmaIrXllltu8PwJhOtb/M29OV7tcNxaKH7mXgseeEke\n", + "Lb3yiPj6178uqXs6rr3+sWXJvoxdMcODsh28EBShyNtBQYy8rNpCoJF3gpeEXZQUIdQCxhVvyBWU\n", + "sTYPrqV0Pl6BosQyPrQ/UkxRHQhyj3Av39lxxx0lSa961askdeN/xRVXzPoc9rCp+RepZyhHYwUt\n", + "t1JaM2oVFO9DxuCwww6T1BVG/PKXvyxJuv766/s0c/CrPX/dPhTuFdHraG/vWOcF7Geh1mDeVqDE\n", + "9WWs7clq1/yx1jJeXbP2oCh5O7D/vm8/GL+xxjEVqSRJkiRJkkampkj93//935yg5aHgffT1Qkht\n", + "5WkVRQLv5r/+67/m/b6/t8Wj53hRmQPeZ/d9Pxs9fdcGd6OA8ZTfGmvjZRw4rm/yG3lFpKJTPoL3\n", + "+B7/gH14IKyDEoWSsttuu0mSvvOd78z7PY/ZieIvuC6C46OAZnCF0Tc+7UsU5xCBYuObJEfzDfWA\n", + "mCgPjC4penijpesjmN7LHwAbpv785z+ft73e7hpYG1A0KEmBbbVupTIp+q5lXBdjtXz5ckndRtWR\n", + "IjW2cgRjH492YmOuKHDdHqRfW1Kklb7p9A5zges79NBDJUlnnXWWJOmnP/2pJOmiiy6SJN1xxx2b\n", + "PA5Kq1O7ZkSMrZqzprz2ta+V1CXssKai2Lpy6/3beu8am1SkkiRJkiRJGpmaIvU///M/G1KFfSPI\n", + "hd7cFuWAGBveS5PNV3rqdY85ep/rEMdRKlbnRFlPtU/nrTFd4BkPZBCRbYUXTGyZe098jzIPHtvm\n", + "3iTUKjmUryhteg213hbjSXtdIcJu8Zp4v+/t7rsRKPT1KvvGc6CMEttFu2lvbbxFqdAsSiSxYrSP\n", + "eCXsozY2kTigGvgOcVwUGiTua7EpUn3BRn7wgx9I6sbQs7kc1NaS6jtpSsoRikU0hzwdHpsdK1Yo\n", + "gnb7Zsq18Hl+UhKH60BpisaHucQaBH03ZY6Oix2NVW6CfqKswuZOKlJJkiRJkiSNTFWRAjx8vAkU\n", + "l2233VZS99Q6VEmJKBUEJOYGb7X03r+vctD3uiZdhK72/CgyHqOCF4PCB17Gn/EeWutloSBjCG+q\n", + "NrbNFceFztJzZbdU54lxaFWEa71/Pw9xIvQXf48KpKJ8tagojB0Zu5u7EuVQq47ri+pNAUrGtOsj\n", + "lVRn5lBUo414QK6HtXjScw6lbOz++9a3vlX1OfrB5wjjXlLB+Rz3XIpBsx0T9jT2vefuu+8e9XjT\n", + "IhWpJEmSJEmSRqZa2dzxLCee7smqw7taaI+ep3BiO6atnEw7jsGz/fD+iPki1gXvhiy3e++9V1I3\n", + "fl4xm+/13XJnoegbc8R1LpbMEih5lUPbW4ptQnGif5hP2JHXdmIrmMir9q2l5oNYFuIgUSyGZjUt\n", + "NLUZuig8ZMaSUexqKp+b1Nwrbbrr7YhABafW2AMPPCCpu3cwvpxvqNLYN1N2rC11+sK90mvUecxU\n", + "hNfo4y0BqvC07jm1djNtUpFKkiRJkiRpZFEoUpHCg7dVm301Np49FNW9WWiirLaFAu8MLwEvjPEi\n", + "FopNc/EKydLE20HZ8RixsSunj01przhYLEqUe6WluAk+77FO2D/XHylzpfHDfomtw+v1Pf/IAi3t\n", + "VFA7Hhufm2NOq7J5LShnjmfMliB2KKqQPWklZSxFgfFiTWYcsSFsdixlzeP2JhWnOxTWXL831PYD\n", + "18XaTv+i9E1rLWON8LcYi42iIvXWt75VL3rRizYUN5SkmZkZLV26VHvttZf22msvXXnllRv+d955\n", + "52nHHXfUqlWrdNVVV02m1UmSJEmSJIuAoiv3lre8Re9973v193//9xv+tmTJEp100kk66aSTZn12\n", + "3bp1+ta3vqV169bpySef1KGHHqoHHnig+f0qisa0IK6Ap+Fo/65SRszYLNQ+T8SERe/ZIyWRmjyM\n", + "u+/EDmTBTZu+41cbdwAoJtgR/bpQvPCFL5z1e0mRirLuvNZNK08//bSkTiVxu+B37KaU2dNnZwA8\n", + "d8YQZWexQWxOtHb2zagk62paEOcW7a/Yl/vuu2+Tf0dRGUu5wAZRR6N9JmsZWgG9L7X7t6JITvue\n", + "67AWsSZMKwatRPEJ58ADD9xk2flNyfff+c53dMwxx2iLLbbQsmXLtMMOO+iWW24Zp6VJkiRJkiSL\n", + "jOYYqYsvvlhf/epXtc8+++jCCy/Un//5n+upp57S/vvvv+EzS5cu1ZNPPjlKQ2ug3lNrTJXHhuBF\n", + "oSRECkrJQx97n6dSBslY7/NrvZnoe+yV5nu9DYUszrFsy717FJxIgaxVWD0+AWXKFbCh1YdLeBwQ\n", + "SitKzthVn1FTIpgvJXWiVCEdonHaFMwJFAG3pVa1bey96pjjUTzkYo8jBJQcbGIsRSqCtWeszG7m\n", + "bN+4VCrnu8Iz9lxD3ea6h8bPcr1kAQ7dXSTa3aGWhdrdJKIUnwlN79ze9a53af369brjjjv04he/\n", + "WCeffHL42cWayp4kSZIkSTKUJkUKL0OSjjvuOB1++OGSfufdbfwO+Yknntjg8c3HH/zBH+gP/uAP\n", + "NngRPMXyNIgyRCYBMRbOUIVixYoVkroMBbzT0sNgKWZmaA2Ovt7uYskswWsuZUahWEUKhMcVTNqr\n", + "xWuMau5EMTlRHIh7xz6Ori7U1giqxb1Bfh/LO3Yl9wUveMEox50k7JZAjTNUyGhtiSAWh5+1c7R2\n", + "Tk+7vhXqZak2mMPazff7qIZDGLvGIGtp33pU3Duive/Gwt9y9B0nB4WrVUHyXQhajxOtvUNh3jEu\n", + "paxX1rRrr7123s813eE3Xmy+/e1vb8joO+KII/TNb35Tv/3tb7V+/Xo9+OCD2nfffYvHm3aBySRJ\n", + "kiRJko157nOfq+c+97k6+OCD5/1cUZE65phjdP311+vXv/61ttlmG33sYx/TddddpzvuuENLlizR\n", + "8uXL9fnPf16StHr1ah111FFavXq1nvOc5+iSSy6pegJ3L4I92njfy1N3yVssKTEoXbwH5v0rtVp4\n", + "6OMp9eGHH571uQj3KvHIUeNad7jGm6Mf8HJalQR/n75YIH6CfnSb8QyXSWdulBQ07AUVg3HBG0Nh\n", + "irxwP74rbiR3YM/E/mG//MROOS+KLPW6PFsQsKfttttOUufFYq94bb/85S83+T2Uw6222mrW+bne\n", + "jRXr+eBzeJ8PPvigpHr7jvZ6nA+PT6MydiuMfdQGxoC24gnzs6RITbtmHGNbq3Rgy14rLBpTr8Q9\n", + "FiWVG1hrmFNRfGmtys/3IyWF4zD+rBWt6vPYMVfEAaOw9n0bUtseYsi4ft+doFaJiuKPuXci0tB+\n", + "zlcbY1irpBYfpL7xjW/M+dtb3/rW8POnnXaaTjvttKqTJ0mSJEmSbM4seWYK6R9LlizRzMzMQp82\n", + "SZIkSZKkNzMzM6GSlcFJSZIkSZIkjUxtr70aRSqK8YBSRgnnmLT6xfvk008/fdb5SvWIxj5f32yv\n", + "2vpWfr5zzz1XUherxDgR20PcSG0dIOIKiGvgffaJJ54oSfrCF74w6zyPP/74rO/zvp3+vueee2b9\n", + "n2w6Yo1uvvnmTbaDfiTmj/f9vgfcNttss8nzEO9BjBzfJy4CO91hhx0kSUcddZQk6bLLLpPUZfsR\n", + "rxH1H+NGzJtnqxJ7RH+SSfuhD31o1nVyHq6HmKja/dsA++B8XPcJJ5ww63wloj3+apmZmdHHP/5x\n", + "SfV76dGHeJq+lnAcbI9rfc973iNJ+tSnPiVpbowNx/GsO47DNXLNjBnt4HPErJxyyimStOH6onpX\n", + "URxoXxizT37yk5Jim8B2oorfHjNFf3D9vrZ85jOfkRSP29577y2p2zPQY2u8Xdg0/UX/EH7yiU98\n", + "Ytb/x9oT0KE/yf569NFHJc3dO5C1gTntGbasdcuXL5fUXR/1qogBfO973zvrvBH0J+fxXQRWr14t\n", + "qYu7jOyA83z5y1+edTzufYwzayH3dOyUtYPvcS/Bfv2e5tfHPCKmq+8aBtgHcE95+9vfPu/3UpFK\n", + "kiRJkiRpZGqKlNQ9paKk4A3w9FmqCTJWpfChRF7MtttuK6lTKO6//35JXXbUAQccIEm6/PLL5z1+\n", + "SZkDnsbdC911110lzfU2avvPFQK8TLwH2uXKSy18D3vwasDYR7QnHt4ZWWiuFL3iFa+Q1HnFt912\n", + "m6RY+SBjJMrUWbdu3Sb/jhdU8ob8+/Qf41YqB8K4ReNH/5f29WKeoYJ4NmAttJfj9N1HDKUQFeH6\n", + "66/v9f2NoS9d0fD6NlDKYEUdpa+8ajtzjvP5/pIR9BXtpU4RY4BS5h4ya0G05qxcuVJSNzc9K7Fv\n", + "fZ6SLZT2nsMWIpvw6/DrdVAIo9p91AWj/7x9nvHLOExKiXJQGKO1kjkd9ReqdbQnXvS9KBuRTHhK\n", + "GHH8NWvWSOrWpGjN83FAKfR7lfe7v03ytzYol9gD7Y7sg7W8VYmK2llrF6lIJUmSJEmSNDJVRcoV\n", + "gb61NMaq/DwU32mcp+af/vSnm/z8kUceKUn67Gc/K6mLj+B3h6d7Yn2ip273DlBw8MYjr7yE93Pk\n", + "xUeKmStq9Jc/7ePNOLQ3Umrw5qP+Jt4Abw+7i/a4K3khePXEM6A01saE+Tj5PBi6v1Sp5gvn5zqw\n", + "Pz9vbcyS1+Lx/ivtJcjemH2VrE0RVYkn1qHW9qmRhefPcakhBihS/L+kRNHXeP7eV3jEzF33kEt9\n", + "hNJELT6nVCmduQqluMtSvSaUB9YerwWIigwlNZv4xqifUV5qK9TX2hyxRNEaUwv9H9UdQ3GL4ldb\n", + "73lR7T36iTnKGo0qXIrv9fZgP9yriOHyecnaE423K7al64Do3lJag6J6WbU1F1ORSpIkSZIkaWSq\n", + "ihRPs5NWlqKn1LFwj52n2+jpmQrOxEahaJQo7THnigJP8zxVt74/dsUtglgwbwdewPve9z5Jnbd8\n", + "ySWXSOoyQiLwJqLr9yw+h5goJ/JOuI7ofHj9eLOHHHKIJOlf//Vf520HuL14O0rzoaQsomYQIxWd\n", + "n/nAePF34oDIEMJLw64feuihWcfj/5EiWVuqru8+d/PhMUb0Bb+XYmNQNrB9FC2yiYCx8jHlPMuW\n", + "LZPUxSqV9mxDiYjiHUtw/Og8pTXQx7A0dsR7lhSp6P/+95LiUFL8yIYbG8Z9//33l9SN749+9KNe\n", + "x2HtiMahFP/YSmkc++4lGB2XtYC57HGa9FuUbekwr/rGCXv/0g6UMu4prKXRPbi0jy6kIpUkSZIk\n", + "SdLIVBWphWLSGRn+VF7KPLnqqqskST/84Q8ljbdjOUoE7+Hx7vrGnnAc30OuBN6i7+mHV3HNNddI\n", + "kv76r/961vEd32sPVaCkqLXuVO+UYoIY77vuumvWz1ZQgNw7j7xv+jfqD+JWiMfxvR7pT+zU42Dw\n", + "3vg+3mDktaLekD1ZGys2STy2wT1iFAZsxT9PvJ7Hqtx3332SpEMPPVRSHOvCHOo791C+gCyvaVFS\n", + "MkpzEluM4h+937G9SJFhLWIcmTv0c0m1r1XXHTKBV6xYISnOYnM805jzR7FqHqPWF9ZAKMUGTRpf\n", + "w4iNYl65uh3BPCuNX9Sv9APzCTsrKZiZtZckSZIkSTJhnhWK1KTxp31XVGq/1wrvfT22xr1v3s+X\n", + "Mnd46kfRqn0q53x4D5GXT+ZL9P7Z/06cSCk+Ai+D62vt36G1SCKiDChUCPqL//v1Ylclr5V+oKaO\n", + "qyYch89xPH7Sb3j7qApA/5LRRjv5nqsqiwEUC9TGUgyKxz5Fn/daXIAN0feoe6XYENRpr18FUT2g\n", + "WrCJseLRovhElBiyHL2GXUQpJoy1ibpdpcr1Tqv6T/YZ2ZylbDbmmCtSKEZRHS/W0NoMa19T3F6m\n", + "pUSxlmD/zB/6EUWKeNSS8sr3o7jPEt6PrTUUI1KRSpIkSZIkaWSzUKRa6x9Ni9J7esD7QIHhKZ2n\n", + "9lrwSlAQeLp3b6j2/TteW9+qv6V4ELL1UNCIN/Dqw97ukoIGxOZ4Ndy+1H6P8cLLLGW+RNl4jD/j\n", + "GNXLYjxKWYr0J+qDe1+cj1grFCdX8hgHPof9EFfk1ZVRW1BfpkGk+pU8S5Qe+saz8yIPNlJQmDM+\n", + "l1FUyHbzStBetyo6biu18Y61eD8TA/O6171OUqfMlOpNRcdzSjXSSni/lqr/A/1W2/+cx9vr6q6D\n", + "PdXe67y/at+GTBrsOcrCbM1OHKPWXB/IXC6RilSSJEmSJEkji1qRYudpvBzqDeE9ogAMrQQ9LfDw\n", + "UQJaa4fgxbJnGV4W3jneFIpQKa4gqlZbAm+T8XHI0GDvO/ZWc9yLqVUkWxWoVujPWsUswvfdKsVx\n", + "lOqi0X9k67kag9qCgonihP15tifXxzigKDq0v7b2yiRACeibrcQYsNYQ51Wak309ZMaMOetjzf+j\n", + "Phxac2/MWl0bwxqx3377SeraT7/WKlIlhipSjtf8i5RL1p6+bwvcPkoZ3ajbfK9UWZvj0f6hWX99\n", + "KSlgrfbKGkcMVd9+7wvKk6vstQpuKlJJkiRJkiSNLGpFCqWJp27iCviJN1GbEbLY4Gm7pGhE+y45\n", + "XnEbLwVvivOVMn/ci6r1KnwPO4f2uALiuNe5WN77O8TCRQpcLSiHXGdJcUJJQlmMVBfa5f1H7BNq\n", + "CPMMb5bfqbHCdVKlOwI7cfuZRoyjx8nVVkbm86iNjAFquH+/NqvHKSlZKGNj15Eaq2adg43xlgA1\n", + "FNWZPfUmVXm8FeYO9sFcjOZe36w6t49S5XbmdO2a58db6DjikuLbam/e/668RXi/RRn1/J01EpUd\n", + "xZR1IOtIJUmSJEmSTJhFrUjxNI8HTdwCtUn8febmRm1sV23slHsj9B9P2XhdfWOJ+n6+5IVQg6U2\n", + "3qE1dgzvEq9j7IwPvJqhcSv0A/ZQUriiGjROVHUbr47sPvoFJYx2EE+Dt4ZKEmWl0g8eg0fM3qTr\n", + "c0ldLA6xJihJrCGlqvcoKMT63HvvvZLmKhEwqTo9JXW3Fdo/djwhnjtV/hmTVatWSZJ22GEHSdL1\n", + "118/6nkjahVIYrlof2kusxYxR/vaNHOH87pihX1Sr6pvTFmtYjOt+lJ9ITYKFT4aH9aYaO8/YH7T\n", + "r9tuu62k+N6YdaSSJEmSJEkmzKJWpIjp2WuvvSR1T6M777yzpPrYqKHVgEu0ZimNnW0Yvc/lqbxU\n", + "jTeir/dS2iMOvH5ULcTIPfnkk5v8P3aD98F5x/aG8R6HKlJeN2osO0W58vHDDrA/6j8Ri+eKEl49\n", + "as+DDz64yfNFak9fr53sU9pP5hLXMV81Z1Q1V45qx+jlL3+5pE5JufPOOyXFHmttDEXffSCjelhD\n", + "qVUzW2GMUC+JjVrobLLa2Bw+V9vPY2XoRvuRonxSA46acbVrcFSDjrnNvZDYO+yS629V/6E2lqkv\n", + "HC+61/rbBt+Tj3Zhl/xkvrPbhlP71iQVqSRJkiRJkkYWtSLF0yDeJb8Tt3DNNddUHQeviHgJjocX\n", + "UKrV4fA+lve2pf1/ovfhC1X3CC94aFXkvtA/K1eulCTttttukrrK13j7fYmUKIf367Wf78tYakGr\n", + "Mleitho3dhHVF8NO6ce+ClNtbBpKI/FJjB+xkOvWrZM0f7/7Hm++tx1tdw//gAMOkNTZKLEsZJ/5\n", + "HniA0sLc5icKALaPSoqKzudoH/+n/SgLk1aQJgW2hAr8yCOPVH1vUopGRN+1f6zzRWsxihcV78eK\n", + "ZYoqidcqpLWMPW7cW5l/tfcw/xzzFEWO+QnR261ahS4VqSRJkiRJkkYWtSJ13333zfrZCpkKZP0R\n", + "6+ExGLXgZUaKlu/fFEX+89RMfR48cJ6aeRpurVUDXo9rKKUdu1EA8d5RXFADaIerBVTc5r19K0Nr\n", + "76CIUPOGmKLacUBVoBYRCgrjHdU24brpB8YfbyyyU4+rAOIEUFWGUtpDErtvtTPm47XXXiupLa6G\n", + "vr3lllskzc168rWAPqfN9BXqF1lokQrGWPN9zsdYczxsiTWBSsqsRYwV30eZ8L4cq0L4pMFmmfuR\n", + "8uFjXFI0+saatYKd8LNVffaYnigO0eEewFrrGdjEf7JGcDzfp3ShGTsrkOuOlKgoltCzXbFH5iMx\n", + "UvRnpLLT/yVSkUqSJEmSJGlkyTNTKCixZMkSzczMLPRpkyRJkiRJejMzMxMqbalIJUmSJEmSNDK1\n", + "GKmPf/zjE88iQ/Xqq361Zo5wns9//vOSpN13311SFw9xzz33SJJ+/vOfS+re6+69996zficmjPfr\n", + "ZBIRe3T//fdLkl7/+tfPOu+k4TznnXeepK5ydimWq7Y/iX8gjuDtb3/7rPNOGrcX4laIO/AYpZ12\n", + "2kmS9NBDD0nqrp8YJ7wXst74yThznosvvnjW8YmD4Xdin4ibieIrqE1D3AkxS8QLvO1tb5t13knj\n", + "/UlcArFjVE5nHcDeuQ7iF7zGDvOJ8aFfjz76aF100UWSujGgL8j8ow85V1SdntgIzkHMCm0+7bTT\n", + "Zl0btss1MnbRWGHjxC9yfjKKOS/tP/744yVJn/vc52b1AbZCVhx73QHHIZbEM4WpOE57iGs8+uij\n", + "Z12fQ+atxzkydtT64/9R1h5z65RTTpEkffGLX5TUxY3S7h/96Eeb/D7jQj945XBqkrFW8X/Wlksv\n", + "vVTS3LnHeGBHDz/8sKQu1oY5RfsYN85DPzN36c+1a9dKimN/1qxZI6mzU89spj2MU5QRy7idc845\n", + "s9rtRBnlEXye/sG+fD5MGs5zySWXSOrmmfcn9k173Q6JNeN7xClH54tIRSpJkiRJkqSRqSlS8+0h\n", + "teeee0qS7rjjjk3+/9BDD5XUeYcoPTA0Ow0vyRUUvCQycHga96dgvNk99thDUudFkBngNT3IMnMv\n", + "Be+WekyrV6+WNNfrXGjw4vFi8coi77tW2RurUvhYMA5RthzKoBP1Q2TzeLHYAf2FV//Sl75UknTj\n", + "jTdu8vivfe1rJXVKJzVoUKTYK68vkX33BfugH5mfnl2J4kpGHZ+nP/DS+R7H3XhPQZQBV5o8Oyyq\n", + "VM5c9UxXbD2yTdqCohHtIsDxSvVpUHw8C8vr6eBBR550aexQU10BKuFKFLALBf140003zXsc3w+S\n", + "vc8OPPBASd043nrrrZLmKjCMn++7yjhh+zvuuKOkrgYh+Pe8H6PrpF2s2axdnk3oa0epUjZzN9pH\n", + "lrmPnZVqtJUqvPfNCPfPj70XZES0dyKZvtF1Mk6RIsq9upSRXCIVqSRJkiRJkkampkjNp1JEShTg\n", + "zUVP97X7LEUQm8H7dzxkrwkSeXt4CexJhneJJ+0xNRF4H3gneEeTqtRdC2PH9fi+ZniZtfsUOUP3\n", + "e1qsRBkfPp54tSifeEv8nf49+OCDJXX7wl155ZWzjoMd9q2OjSqAIkrMXut40l7sPfKi2XkAL9f3\n", + "ZnT1CNVh4+PRx7SVz7iK58dirnNujslPYqCiMURtZk64DaMmEzNDzA3KFZ/nfFEldRQtFDPWoNa9\n", + "+VBsmMNDK31fd911vT7vtkn76U9UyNaK2cwdFLJS/SYHVZfxd6UIJQ/FhLUd+tbEY85HMNexi2nX\n", + "E1uo3Tmie3rpHso8i2A+D31mSEUqSZIkSZKkkUVd2TyC9+7R0/5YMTZ4j7yPrvXIecr1GBDPQqo9\n", + "DvD0P7TS+VjQH94v//iP/yhJ2mqrrSRJX/rSlyTV77f1bMMr4bsqElVxJkZw6I70DjF5ZIahfLFD\n", + "Ovun1YLqgTLFddFun6945fQLqgvxQr6v3cbKlceZ1eKZlU5pP0TaGH0OpYI+JZsITxhFir4gVgal\n", + "zM+DkoVC1epR8z2UmoVSGCJoD0oSNoLi1hrTg831VXBcmXTIQOU8jD/9OHZmOnNo2krUYoG1JYpl\n", + "c8jiRP1mDY2+X9pHF1KRSpIkSZIkaWSzVKQgetrHox6Kv4fGKyrVRcKrJMYEr9JjrErgpXI+FDjf\n", + "U60WPHcyWOgn9jarhXgA+oN+4PpQVF73utdJklasWCGpq6USsfXWW0tq967JwCBz6Oqrr246zkJD\n", + "DB5eEeNM1lyUpVmKJaQ/iA+phSxYvHBipogPYa/JBx54oOp4nB9l17NVo32uXKHzelNk0m18ffwP\n", + "2x5brWuFOcJeX4xxFL/G5z0rCqWDNcFVvr748cZaO1thbUGNxzZas8PoR2yPzNCxIAuQGDNX9Fr2\n", + "i5S69lKr7vHHH5dUnvMOazT3oFY76YtnmxLTB2Qik6HP24t//ud/ljRXIYoyiGuVZxTgt771rZK6\n", + "NY74z0iR4rwlUpFKkiRJkiRpZGqK1BZbbBEqSlR3/cu//EtJXVzBZZddJkm67bbbJHVP1zxt4w2M\n", + "9dRN+/AOePpFQYiUArxivEWeamvftzoeW9XqNZKRg+LT6q27YoS3SPv+/d//XVIX20N/8X46ipVC\n", + "AURp6AvKxEEHHSSp6//vf//7TcdbKFAw3ZuttePIW2NcWhU+xgn7Y3zIQKuF757PlOwAACAASURB\n", + "VBE/QjyOe6mAWoPdEA+EPXGdXN/GSq/XOGPODo39Ke1qX1shmjnINUV9AF7XyePFUJJ8DayF8zN3\n", + "PFNyoaEfWSu5flekandLwNZQZ8eue0T/1SoXtTDnbr755kHH2VRm60KAEhfFd3IPO/zwwyV1andU\n", + "AzJ6VqiNFePtEHGeKHul+Re130lFKkmSJEmSpJGpKVLzZTP4flh4qGRI+Pto98KG1oQAvFrOT72f\n", + "yCsFvCm+z3W0ZnCQWUA8xdCsvb7v2Ut4f5ChxM/aGi7EzLR6jR67RUYHdjPtivCRquHKIF5Wrb34\n", + "PmOAt1VbrToCu2Pe9d05gJgo4l1QETy+Z99995XUxfBRAwZFC++QfkSF2Xg+8FnmzFgwpyMPtnZO\n", + "9q1j5EoCihFzirFFEYkqbJfwfRmnTRQHR+Xx2tgYr0PVN5szqqgNzAn2bItie55tlOwPtZsMb1cO\n", + "x4ZnBOI6vd7XUFKRSpIkSZIkaWRRZu2xh9mPf/xjSV2EPe+L8dJaMyJKcFze4+JtepZaBJ62KwF4\n", + "e143qARxFSgOrRWmFwqPF+nrhZcUvwjeg6MgkqmBPU1bkUJBcS/VVQ7iGkpxORDt68ZxvRZRLXiH\n", + "KIWoA56RUwIVoeTVoyBiN6gJrjjTH2PHRM4H11yKqZjUecFVQfqCMWbN4v+om/Q96qVnIrfGJY4N\n", + "14cay1zAFqM9BUtwHLfB0n6SrNWoqV7zjP6P1vbFkjW62CBe0tc2xr815i8CJQr7H5tUpJIkSZIk\n", + "SRpZlIoUist//Md/SJrrmaMY4aWMHQ/h1YZRoPAOS4oQT9N4eyg0PA23xqxsLu/b8YbxcvvurN0a\n", + "A4ZagLfNeJH9NW24Lvf+3Uvue/0lxaq1P+k3FFayZ/sqUqWdBvD2iUFcunSppLLixN8XQqHtq6qO\n", + "hauJrCFeZ4k+QJ2MatahmDAm/F7aa2+hFDkUNcaedrYqCbSbOEl/m1CKCSspSvyfe5Lb4tiVzX9f\n", + "KO1ZOXaF/VKF+qGkIpUkSZIkSdLIolSkHH96dcVoKNHO6ez5hVezfPlySZ2HHsHTNEoMCoTXlaqF\n", + "73Ec9glarPDUj4LRN9uw1etFiULZQLEcquQRc0X7o0rcJfBOI69/UrTuPck4ohL0zXjqe37UFyrc\n", + "M7+pMROxEHtPTmt/S1dEfLd6bIo5U/LkXb1323aPPVLhh8awMCe9Jh5rHYoaqqjHqdbaFJ+LsvZa\n", + "bRr8OlrjO5PfUZrrY7HllltKqt+jr0QqUkmSJEmSJI1sFoqUw/v8sTIiSu/J8fbwimr3zCNegads\n", + "4iz67tyNN0jW2bp16yRJRxxxRK/jAE/jXDc1Wth3aCx42u/rzbd6idQuQUmk36P9zPoed6wYtb5x\n", + "E0P3jWtVbrF7VAsU0do99qC26jfqBnE77PHHPmPR9W9OmVHE+tSq6h4/56omfdY6xk888cSsn762\n", + "oUjxd2yC/T7pezI7a0FZ8nhRrsPjS2lfX3WVtfOKK66Q1PXnbrvt1us4EcwJ9lBM+rFs2TJJ3bi2\n", + "jnMt3Ov63oNLpCKVJEmSJEnSyGapSLXGqETg/ZQ8ZryZ0tMstU54qsarG/qUTcwPilwrKFJ33323\n", + "pPHeE0fnIWZp0hksKE+33HKLpM4bHVrZG6aVgYMS1jc+BGoVVId4Feye+I++yiXtd0XX5xsV9zkv\n", + "daVKcTjTil9qgba2xhYxlyYVZ+d9ydix5vJ/VN9WuH6vBcheaFwfc3hoLBNV8seGNWHsuNVaFXdz\n", + "Z6gd9WVS2bepSCVJkiRJkjSyKBSpVk8b8GB539rXW6tVGmr358HbIsaDGBe8O+os8V498k6p1P3K\n", + "V75SkrTHHntIiuMRSlV6yaIjvgEvjf5vVfp8/BgPMntcmZo0Q2OiFhqvIA4oMuyvRv8Ss1WaL/T/\n", + "zjvv3NQu4hX8eH3xzLDSfOO8jONC2c1CMDSeixgPFAt+sqbQZ7X1clijItV87Bp9DvFwgGKArQ1V\n", + "gbE9GDv2hrcTffefLEHsFeM4VJGrhf7qu1fjtCjthbhQpCKVJEmSJEnSyJJnplD4YsmSJZqZmVno\n", + "0yZJkiRJkvRmZmYmrBOWilSSJEmSJEkjU4uROvvss8OMBN4PU9U2iuwvvR9F9frkJz8pqYshirLu\n", + "DjroIEnS6tWrJUk333yzJOmuu+6SJO2yyy6SulgPYlqoF3X66afPOu+k4Tx9z0eMFO0vvX8nDuMj\n", + "H/mIJGnt2rWzvkcWIZ+L+pf9rqgVw/t/vs94M/5HHnmkpN/ZilTOYNlqq60kzd0hnhgu4kD4nfMT\n", + "p3HSSSdJ6vqTdvl1ErfhMWXEOhHn4fEYxI5xvve9732SpLPOOktSFxdSim/hONEec/QDsYJc7wc/\n", + "+MFZ1zcpmJdnnHGGpC7Lj6w8vDquY/fdd5fU1acic4uaS8QYEoeCfTGfjznmGEm/G1+/tu22205S\n", + "t0Zg8953xB7xd7cNxoZ4tbe85S2S5vZlKdvq4IMPltTVY2KNcZgD2Nqpp54qSfriF78oqYsjo130\n", + "EWuRH4f4SPoBG6UPaTf9QJ9Oey1jTcCWPWaK8WWOekwXNsbcJYbszDPPlNTdG5jL9Ce2xpoRVdzm\n", + "uL4WEN9IzNGxxx67yevDnjhf7b6kvv+s4/0ZxSHvuuuukro12e+1tN/jaH0covFjLaCdPi+wN+6t\n", + "N9xwwybP7xm8xx13nKRu7eS6OF5rdp6PP+095ZRT5v1eKlJJkiRJkiSNTE2Ret7znhdm1/F0jDcY\n", + "PWXWhnfV1hG6/vrrJXXKCU+leHF4M7SHv+PtbS5EikmEV/R2b55+KCkp1KtyBRGFAQXCx6u2loor\n", + "UcDx8OJoP144mUuOe5ml+mGl6s6c1/cXYxxqM60iJQq8H0rZdn1r1pQ+7+NLvbKo/tSdd965yb/j\n", + "nZe89EsvvVSSdPLJJ8/5Hxl/payeyINF6WBsUHiANYLPRX2ydOlSSdLRRx8tSbr88svnbQ/n8+NF\n", + "mbWuRAG29Ytf/GJWOyM1v2RbkwYFwtcmV0AYBxSVH/zgB5s8HmsXCqDvk+r9ieLBvYWMY1ekOK7X\n", + "wQJstlTDjXZFx3FoP0oW7eIeFGXbRWs9ClS09vD24v77769qH6DUcV3Yldsz8y6qzI8iGO33SX/Q\n", + "j6x12Effiv/c26G2AnoqUkmSJEmSJI1MTZGqqfvAUz31k3hP6jFKtU+NpT314Bvf+IYkac2aNbP+\n", + "zlPv8uXLJXV1oGqPu1jo63X65/39PN5MaS+60pjjVY9VMwW1gHZGNXxKdadcdaiFfsI7Qhkba8++\n", + "WsauDN63Fs+kqgnDfF7n0Poy3jeuOnocXQRq7JVXXilJ+uEPf9jrvICHTp9Sa452EaeHYoGSQ804\n", + "vu/txUbdIx8KigTXU3qLQLuYO9Gc5bgPPvjgvMdjbeprB7TX1WPwPQ8jSmsLx+m7V6GvIVEMV4mS\n", + "YtNXiaJd22yzjaROIXrkkUckxWsR8ZMO6jpvifxe62sR9tM67/ke41K75qcilSRJkiRJ0sjUFKk+\n", + "VbSJoSCGhqykWiUKRaGvZ0wGAd4aXgpeBt5Sa7VispXuueeeWcdf7OBluFI1dE87vKPW6sN423hD\n", + "KFy00+MsiF8oeWVcF95pabzxlmkPqsW0qu/2VUyJU/nc5z4nSbrxxhsldd7/NddcM+/3fS/ISe3k\n", + "DltvvfVEj78xHktSe214tldcccW8n4uywMAVEtY0jo9tRhm5tN+VIeZAbUxJ7W4U2HxtHJ6vKfSH\n", + "Kxms/aV7QGuZRGJvuOeUsuQivHJ7dJ7atwR8blK7N7Sq74A9YEf019B7A7Ffvi+s2xP90roLg8+7\n", + "2vmdilSSJEmSJEkji2KvvVrwPnjKrX16xptp9Yx5uqa+FApVlElQC/WpyAzxp+3Fimei0A+uuJDx\n", + "4bV5St6XZ0bVwp5yb3jDGyR1tXZuv/12SdItt9wy6/N4M1GmC94w7S21G6+LWD7UAffeFzozqq8X\n", + "TX8Qt7By5UpJXW2hm266SVKsmlDbB0pe+VCGbM6wYsWKWT+JCXnssceqvl+r4DBHiGny46N8uG34\n", + "XCDWBPzzpfaMtZEFx4n2iXSYA31V99b9P6FV5UeBYm1nfPq+1fBsPF8LSvekkmLVN+O2BG97Hn/8\n", + "8abve/wy9zT60dvrylEUQ8Va6v3AvEKJ4vio6rV1uYDxYt65uh6RilSSJEmSJEkjm5UiBcS67LXX\n", + "XpLmVgd2L2CsLDBqbuy9996Sxsu+2lyUKPCnfrwLjx8hdgWlCEXxe9/73rzHr62p4qxbt05Sp6Bw\n", + "HGLQ+kIGE5k5XCfZm4D3QnYp3jr1k2gHCuqkY4bG4sILL5z1+6pVqyTNjTVzGAfw2j1j4+PRB5So\n", + "V7/61ZI6G61VpLwyeLTWlOIpa+M9o+O75zxUySmBYkP9okiR2nPPPSV19bz6KgRObWzWUFD2uK7W\n", + "zFMfB7IpPbYtYqeddpr1+7333itpmM1vCtbMl73sZZI6+6edfddQ1kC/PtRpKtbzuaeeemre46E8\n", + "+XWj/jMPsYvWGCnWapTWUh0wSEUqSZIkSZKkkc1akYqykTxWx5WjVoWKp2EUJI5b8tB/36AfSrVh\n", + "8Grw7mpjg1q9LRQx6oANBa8GRSWyG1QNqizTft7bc93YS5TBMjRjZtJElclLRFW3x6KljhvV7PHE\n", + "iQl56KGHeh0HD7hkI7VKimeG1sZgYXN4+rQjWpuiDFQ8/BJcB2sAe6WhPBELhqrLeYYqUtFaM6m1\n", + "uFYpjPDx7ru2kYFM7BKK1Ngwh7zSOfbUF5QnX/N5i0Glf+Joqcl42223bfJ4rI0oRcC8o3+492Nv\n", + "pRgzYt+IC0WB4zz8v0QqUkmSJEmSJI1MTZH6oz/6o2LF5Qi8jlrvhqdZGOrxkw3Gcf34v+/U1kOq\n", + "3SvNGfv9f1+8ZkypFgreDu/X8baoJk39pShTBfvB+yvFC/RlaA2XoUx6PFviV1BeUFDw9PvW52Et\n", + "Ka0pjDmxTJFK17fWmGdB4YmXlJlI6eob94ltEyeIZ4+Sg7LRGrPiRIpUlLXWt06Tw3iU6ntF1Gal\n", + "RbBH4tVXXy1prp211rcC1iyUQ+YDcaE77rhj03G5TlfZqcCOYkXFcuZjpJT6HpEQjTtrHtfl84Pj\n", + "kWGMHbNWcc+iFmCJVKSSJEmSJEkamZoiNYaXXPv+Gq8AL80j8fvW4KDt0Q7tyTCmHSOEF+XeT5TB\n", + "Qe0hMmzIVsQrw14ibxT7nJQdTTtLsFV5rqVlLSEbC8WB2JBJgWdL5iO7Jjie+epgK8wRYk5QEGqV\n", + "F2wUBQ5PvK+6h21Ftdjw7MlWmxSRjQ+1fY8H7RuL1Xp+1h7icX1cUb1Rr1Gk+tZsw/6ffvppSZ0C\n", + "NrTfUNe5DuwKRc/3dsSut99+e0ndbibA/PG1hDWZ47r6jWLHPKF/UKb4vn8Pxbb2bUoqUkmSJEmS\n", + "JI1MTZEqeV411O6YjcLAU6tX5cUrq33PTCVynqpra85EDH3P/fsGmRxjw/twvK9I+cKLwvshnoVM\n", + "pAiqTuM94f0sW7ZM0txqvzB0z8bFzqSzWvE2+4ACFXm6Ea1V2hl7drNvhZgf1gpXSkrXwedY+4j3\n", + "hLH3g6R/ae9YlbhRMErXy1xuVblRgojdQamptenWel6MA0qjgyLl49da29DvYdyT+o4TyiPZbvQ7\n", + "dsDxuHeiJqNgUZfMY9u4R/tbAvqJ9jMu3PP5P+OG3bPWEsfq0E7uFSVSkUqSJEmSJGlkqjFSpfew\n", + "Y3kvPF17zQieVvFuauMLUNN4+h36PjmVqNm0xlN43Se8uTVr1kiqVxDxIj0bs+RdEiuFt8j7dewY\n", + "e6vNBEnqqInr8awrxhabqVXI/XOMJWtHaS2I6lSxNqF4RZ4wa47vXYZnT90hPG6PI8Wjj5SOvuph\n", + "KWaIv6PosBZHbxNqY5BqFUTWgtbMUdZmzldb6boWYuaiGm3ebsaPWCYnilWD0j2VtwEcp6+ixnFR\n", + "8b2WHlApHXsgvjTajxTlzfeexI7cXiIFks9z3rHeAqQilSRJkiRJ0sjUFKktttii6FXgxeA91So3\n", + "7jVECkTklZWofW/6+wpeQW3V5b60KjbYE14osWy082c/+1nVcbA7aqjgPeGt4WV5zaH99ttPUlfl\n", + "mfageqAOTLquknudXg14odlnn30kxVWLS6BQRvO1JkbKPWs8WBSQVlWYtrWOKbbGHmeomhHU3eF8\n", + "eNS0H9UzymhGUYuyFPvWxCvFVHE+fpYUjtYK5Sg1vttC37pgEZPKPHUFE0WS7DXqm/G5M844Q5L0\n", + "n//5n5K6uk+1UAE8+h7nZxx8D8cSrLWlewPj45XDS/bkx22NOfQagUNJRSpJkiRJkqSRqSlSNR4H\n", + "niZPjbUK0qTrOpH9xfvW1vfm1NDwGA8UhNqsxFaIq8ALwRsoeV9kr7k3hbfD9fjxfT8yvCIyNfAq\n", + "3Svuu+M7ihleO3Epte/78fLJwsObRomMjkNcwK233ippbq0ir/kyKciA4TpqM3lcyaLa8ND90Xbb\n", + "bTdJ0s9//nNJc+0LleXVr361pM6+GDf2xVu3bp0k6fbbb5fUKX0bV1/2a/XsHVctUT+xPWzVs5b4\n", + "v3vMqJSMdRSbwXG9QjNrHBWfS568x/8xxqwlzJG+yg7t4Di11Noy7S2tzbXKHvtaomgQQ9O3HhgZ\n", + "tcQEsdbQz9TbYk1h7rPWsUcjdY/8+kpz74EHHpj1O3OQe8Ahhxwiqetn7K01G7CkYHFcriOKxRoK\n", + "/ed1oLgXbG772KYilSRJkiRJ0siSZ6aQMrZkyRLNzMws9GmTJEmSJEl6MzMzEyqwqUglSZIkSZI0\n", + "MrUYqXPOOWdDvEHfGBgnqnaK6vWNb3xD0twIf+ILyJwhQ4FYlug8fB7IkDnzzDNnnRd8B2yyybzC\n", + "teMVz71mzOmnny5JOuussyR1sSK8dyfegc8Tw7PDDjtI6uIDiOmh36hFw3trMl8++MEPSpIuvPBC\n", + "SV2Miu9kv+eee0qS7rrrLklzx7V2vOlHfo5VV6x0vi984QuSulgj+sV3RscOiKPAvrAT4jeI+SH+\n", + "gziYf/iHf5DU9Sf9TTxNFAfB+aJ4B85HfAHjdPzxx8+6zknDeS699FJJXW2YKNaROBRipsi2Ja6J\n", + "+UnsFv9nfp166qm64IILZv2NvvbYJfrE48BoAz+Zo8TJMSeZ65/4xCckdX2NzXhm77777iupi8Uh\n", + "loc+wWaIgSFminbTl//yL/8iqRt7j/0itobrYu76WkOtM9rDT7IQTzzxREnS+eefP+v6+8J1MecZ\n", + "Q/qL8eH61q5dK6lbu1ij+RxrE2sB101/+Zrie7kxfu94xztmnXfS+Fq22M9H7GApZo1Ysg9/+MOS\n", + "pEsuuURSN15RHSxi8vpmVRI75fc+7Ar7pV1R3TbmN/aAPdIu5g8Z26V+TEUqSZIkSZKkkakpUhtn\n", + "v+BdtCpSHAulxb0vfscT5qmW8/H3UlYg5+m7Q7pnq5Wy/Ki7Q9YYT+0oMZ7Vhgf/ile8QlLnpXm9\n", + "JxQOvGCUNK6b6rIHHHCApE5puvvuu2edr7Q33B133DHv9UXjTHYWmTDOpLMxgf7CS2G83D64fq9K\n", + "jNfFuKFUYXe+XxvePv1SysgpZdG5l9eyF53UKZZ9M6Ec1IIS9LtnMgH94vu3bZwFSF/iCUd1kfgO\n", + "Sgy/R6osx/UYCfe4oxpzHIe+8MrNnLeUJcXciHZhIHuwlPHre7SB2/jQPVE9y7G05x3XFfUjay+Z\n", + "07SPccbWXWlbqLVjsdGa/VabPelri8+jCOpk+VrF2hjZnV8HayZrMWtvZN8QZcdif6W3RU4qUkmS\n", + "JEmSJI1MTZHamLFqRbiXCSgzvjeen5caFrUedC3uxeJt4fUS07Jy5cpZ/4/eH/vTvtcp4mmcuABX\n", + "OPi/P7Vz3fQfMSh9n86d2piovlV6JwVxFXg3KFL0S8lb8/HxWDf3yvEaS14c9N3JnvO3svfee0vq\n", + "lCDOf8sttww6bl+89gwQcyjNVR6i2KhoreD7qLXY7lCItRhKaQ5F9a5aQSGgXzj/WMdHra8FJcH3\n", + "agN+r903tRZicOgPjwudNJyf65vUrhJ98XsDylBkp9iNv+UgJmnnnXeWJP3oRz9qak/tWkf8arQD\n", + "QF/mXSV+8Ytf6OCDD9Yuu+yiXXfdVf/0T/8k6Xc3+MMOO0wrV67Uq171qlmNOe+887Tjjjtq1apV\n", + "uuqqq0ZpZJIkSZIkyWJkXkVqiy220EUXXaQ999xTv/nNb/TSl75Uhx12mC677DIddthhOuWUU3T+\n", + "+edr7dq1Wrt2rdatW6dvfetbWrdunZ588kkdeuiheuCBBwZ7dXz/r/7qryRJ3//+9zf5uSi+wP/u\n", + "lbnxXsZWoiCKJaJdHqcR7QQOrqTxlI+SwtM9cQMoKKWSYRyH46Pk9a127NTGwOH1Ev8wLeg/f+/u\n", + "ewCiJJVi6zgOXpCPw9A4lBKtlfeJjeInewhGMUwRKEmt+2KRCUc1ayqcw8ZxUK5+YrvEDDGWrAEo\n", + "VB4HhuKATQ7NLB4L+oK1yhU4FBPGHJUbBaDvnoD0F/3E8aMYJldfI7CJoWqpn2dSa/hRRx0lSTr2\n", + "2GMlSV/72tckSZdddtlEzue0VjJfrJXBXTFkvt18881Nx2Mtju61zAfuaSUlivWhdjeVeZ9wttpq\n", + "qw2p7M973vO0884768knn9R3v/tdvfnNb5YkvfnNb9YVV1whSfrOd76jY445RltssYWWLVumHXbY\n", + "YcHl/yRJkiRJkoWiOkbq0Ucf1c9+9jPtt99++tWvfrUhnuhFL3rRBi/gqaee0v7777/hO0uXLh0l\n", + "7uXd7363JOkNb3iDJOnqq6+W1P4enKfRkjfkNVA83sLrQ0WUvNnarEHwdvM0/+CDD0rqvDK88dri\n", + "9Xgvnt3o8RBcNwpLKYaqr1cUKRdjx39EYFcoRYwf5+3r1QNxDrV7343FWOcrxfl4rSDoGwfjoF5Q\n", + "E8bHfz6ly+cmnj01wFC5UINRWqIYlCgLcKHg/FEWmnvkQx1Z5gJKlCte2JbXh/LYM4c1JnpbwXk4\n", + "/1gbcFBnqC+sdcQLPvzww5I6ZWrSa9KkYT5gV61rHPbZ997M+LLGl/Z7dbA7xpe1m/nPddXeY/vW\n", + "t6p65/ab3/xGb3zjG/WZz3xmTjHKJUuWzPtAMlS6TZIkSZIkmRbXXnvtvP8vKlL/+7//qze+8Y06\n", + "9thjdeSRR0r6nQr1y1/+UltttZWefvrpDVkzW2+99ax4pCeeeGJDFeb5IPYEL8e9Kqr1Uj+HGJYo\n", + "JsornbtyVBvngJdBfADVgIm34H1rqWbL2PEV0cMp/cN5Su1yPJMJJcEVJfqTduCN+nt8Hrqj99YR\n", + "kcJX6/XVVkBH6XDvA6/Fr7uvl+TgvUexVlzf2NtftsZIlfCaL7Tb7XyoIkVMFMf1/tvYLvzcke2h\n", + "Yt12222zfi/RN2NybFiDhtb2qoW1j7nEHOd3fjIGtXOUtSOyTWxm0vGDtbA7Brs1/OQnP5E0nhJV\n", + "+3bDawOOxZo1ayRJK1askCRdeeWVkjrlrdQewF5a3xbttttukrpYqb5rIf1X6kdiDVn7S/fmgw8+\n", + "WNdff334/3kVqWeeeUZve9vbtHr1ar3//e/f8PcjjjhCX/nKVyRJX/nKVzY8YB1xxBH65je/qd/+\n", + "9rdav369HnzwwQ1bIyRJkiRJkvy+Ma8ideONN+rrX/+6dt99d+21116Sflfe4MMf/rCOOuoofelL\n", + "X9KyZct0+eWXS5JWr16to446SqtXr9ZznvMcXXLJJVWv9ngf6xWf4Zvf/KakLp4BhcoVKb7vXkJt\n", + "LE8EygReg+95x1N4RF+vBUWNp2R/Wo6enlGAhipgVA+maq17jXhDJa+I71F5PdrD0GlVZNinDG+o\n", + "VIHeK4oD7Wa8vbp1hNcocrguj7PBPlCmxlY9avu9FuzM+43rc2VyaE0fP09r/MamKClRk97fsS+u\n", + "AEwabJqx9fg36LvGMUci2+i7e0Tf8/YFO2nNPC1RmvPcR1FSxlKk/O3N+vXrJcVZmcC9we2hNgYp\n", + "grWq9R5Qmqdk46Fqj1UPbN4HqTVr1oQ3YwK+ndNOO02nnXba8JYlSZIkSZIschZFZXOIPP77779f\n", + "Uld5PMqcib7vMRV94WESbwSPGG9q7IwNjlcb24LXiFLH763xBZ5J05owQHYkP1v3faoFbwRlirpH\n", + "xI5hRxB5T16dF/sp1cgpebuMh3txUcXzsSgpOLXxGYA3WpuR26oulPbd2hS111JSDwE12yueL3bw\n", + "vPtmHznMBWyf/TCHMi2Fb9oxbq2wRpSUolawExSa0j2NONrWfTwjon1Wa/HxRXEj5o7fx1S1pdxr\n", + "L0mSJEmSpJlFpUiV4KmyVGnbFZWS91PrnfpT7KRrh9R6bfQHXihKFjU1+r63JguTDKGhe+1BSYnC\n", + "60V5dKLYL64XBYN2o0gRS+eKVIRXLKcf6V9Uib5eNd7SpOI/IjwOwsHbrVUM+9aG85jC2ti9SIki\n", + "axelcWNqd1GoVUXpm0llPvalNsaHGBpXUbFhbLAUi4LNEpuF2osi8cgjj1S3fWOwtcUSe7a50Brj\n", + "FWVWcw9jTeNz22+/vaROoYpiiYbGRE0azybF7oYqtU4qUkmSJEmSJI1sVooUT8WlzBX3eEvvxfHY\n", + "8VKnvZ9WX/CWUezIqsIb5Wm8dr8mvM5ly5ZJkm644YbR2jofeMdR/SuvUcL1esVwxpGYtqjeWATH\n", + "w2vxDCPOgx3WemW+g/tC4UV0HfprUqoL/Td0XmGXL33pSyV1Vbs3Vkw9CyxSwfg7cz9aI7CBxVJY\n", + "uLY2HHOJ+D7G2Gt+1YLCRYzOUDWe+oJ9a8wNZWhNs80N1PRIkQKUxZ122mnW3yO7L709WChqYyKZ\n", + "/9jx2PXJUpFKkiRJkiRpZLNSpKhwXKrb5JSUmNadtWvpmxXVFxQSYqU4D3EMfbPkUCZqa4qMTdRe\n", + "shJRIGgn7/dRLNmTrRWOS80WMrdQA7A/lB76ueTl4w0tX758UPv6Uqs05L+doAAAIABJREFUTSpe\n", + "xeM6Wuuc7bPPPpI6FalGnaGvvUIzx6hVZmo/h+IxtHZWRGm/Q28HtsrvfXc7oAYcqisKEmPY93pR\n", + "SJhbC60QDd2dYHODe4JnIHvNOhSau+++W1IXb1q6124qTnEhqb2n1lY8d2rXzlSkkiRJkiRJGtms\n", + "FCm8nr7e3tj7EvWFp3+8WjIiarPIHI95wUukKmxfr9NhHy8UHvfG8UZ5WncFyWvOoGh5bBGZQ3y+\n", + "5C1ynlbvwqEGiu9UjzJD9iJeHN4d3hrXQX+UaqDg1S+0F16rpqA+ML+ID0K9ieJi+B4qg/cD/UM2\n", + "5RNPPFHddqnrZ5RdVJkaBS3ak442Da0n41lxk1KioFY1RGFgzrWC4sC+lGRMogL3vV4+T+YnCtVC\n", + "sVizBFtVWvqPtcl3MSCG6b777pNUtnfWdNbG6F6Cvbdm7a1atUpSOSuwL6zNrNlR+0tvifg+b0FK\n", + "pCKVJEmSJEnSyGalSDmeUUAsS986PUP3pitBDBZKEj/xFn71q1/1Op57cTx1R8fhKZ2ncLxVvA9+\n", + "p12PPfaYpM5L8EryeCM8rePl8TvfQ5nwyt0oT65w0B9RjBTjjTfD+3u825JXg5eFUoZ3TVwAEBsW\n", + "2QNKFUoNx0VxYRyi63DFhkwZvkd/o6RyHN9LEbUBxQ+vlB3US+0AjhN5aaUMLcYTb9gV05UrV0rq\n", + "skA5fqk+GeNM7SOyL+erY+XqWaRAcEzUNI7ZN8OQbKiS6s35YOw6Ng7XH52ndv9Lz/aDFStWSOpi\n", + "0H76059K6sY0UkFZuzyb7NmC17xjzUPNZc5GSiqw1vga5HOd8WUeeMyPzw/WAuyZ/3N85jKKpCtS\n", + "zP1SNiYK2VBYs1jTsSuUVFekPL6VtQg7ZN6zlta+zUpFKkmSJEmSpJElz7RuszzkpEuWaGZmZqFP\n", + "myRJkiRJ0puZmZlQaU1FKkmSJEmSpJGpxUhdcMEF4ftH3t/zHtlrwNSC6sVPsn94D0oGA+/7ySaK\n", + "sseITeE9LO9neR/70Y9+dNb5Jo1fXwT9OLSaa+35xoLznHPOOZK6ceI9PrFNjANxIXvvvbekblzI\n", + "yuM9OPEIjDdxBSeeeOKs8+F9eBVmj10iZgo89od4BmL4yFx605veJEm66KKLJEnbbLONpC5OgvZ7\n", + "ZlgEcThcL9mBxOideeaZkqTPfOYzkubGElI5nPlBfI3HXZDRwvwh7oJxYZ6ccsopkqRLLrlE0tx+\n", + "4bqIVaM9feuecd7TTz99w7UxRvRZKc6LayhldRErctJJJ0maOxeGzjX6jtgZruPkk0+edT7iEek7\n", + "YkGiuj5R7IrbJrsBHH/88bPOB8SYEFtS+0KDfsH2PVbnjDPOkCRdfPHFkrrr53vMVY8DJTYG27/j\n", + "jjtmHf+Vr3ylpM5GiBn627/9201eH/cI5jyxc0MzvznPueeeO+u6/F7EGsDcJS4Qu+D/XC/xrNg3\n", + "MUs+92g//Y/d0J9cL+PpsXPYB/bC2ks7TjjhhFnX2ZdS5XWgH7jXnnXWWZK6+cBxaL/He65evVpS\n", + "F0/rNQk5DvcI4k/f9773zd+uef+bJEmSJEmShExNkZqv/ghP55F3iBdSqtvj8HTqWWg8vZbqGOE9\n", + "0C68vFL20bRx75gK0Xhbk6pc7nvftYK3hYLhey0yrngrVDYnswRQPFBasDMyX4DxxTvjc1E2aGn8\n", + "8abxglwdwYvES3VVAQWo1ltDNcBeXTXw60BhpR9KexPSH4wH/cVPz8SK+od2tVbgh42/h+LSdy+4\n", + "2vpCpTo8Q22dsWDsouwnbKGUqcz/fS4AtukZvRGtlcH9uNH4cN3cHzif13oD7gF+L2A8mUvYtvcT\n", + "awmKDf2AIsb5x6pFyJzh+nwOlbL12N2DrLJShno091zZ414QVfLGfrwumdtDrbLk1H7es2lRiN2+\n", + "ovpQrG0+r+h/+ovfa+vMpSKVJEmSJEnSyNQUqfk8Rp5+oxojxHK0KlL+tNo3ngHviKfV1sTH3Xff\n", + "XZJ07733ShruzdbCeWqVKK8LVAvj595wqVK2g9KCchPV+MG7K1XbxevCjtw78fEca38uqkNHtXuI\n", + "T3G4fpRErypNP1Mp3/dBczzGiXGIVIsI7yfUFJS16HzO0GrgG9eT66tE9cXVS2fo+Wtr4LGG0Xd+\n", + "Xjz1/fbbT1Kn0kbxpqxpkTKAUsOYD12roj36/O/MPVTWvms1n0dh8jmBYofixNrBXOxbhb8E10M7\n", + "mDP8vfZeUmsnzD1imVjzWSN8HCNlFiWK44H3J/38yCOPVLVvKKzd2Adre2RfpfpW4GtjiVSkkiRJ\n", + "kiRJGlnUlc15f+07mT/wwAPzfq92x+ZayMry981E+PetTA7Eeu2xxx6SpK997WutTezFnXfe2evz\n", + "rft1ucJx0EEHSerGr1YRYzyJd4i80pe97GWSOtXghhtu2OTn3Isvebm1XkwEihFeYOTllLwo5sOe\n", + "e+4pqeu/H/zgB7M+75lArhBxHP7fN54hgvO6ssZ5mL8lhQ8vvXYfLzKQWui7qwEKRl/w1BnL2tiL\n", + "SFWkvVEMDOpnpDw42GS0dqKA+W4SQKY1NllSViJbJ34xshG+RwYvCkpUKRsFzpUL4DxcF3OV3znf\n", + "WDFS7GLguwlwHsazr/JGxXG/N3J9HvtTUlYhirsE75colg08G3IoHss0dO9MxqFv/6cilSRJkiRJ\n", + "0siiVKTwoNnHiadh3leX9odqjemJiLy+obEdKDY77rjjoONMmrH2BeM9fd84EuI98DaiWJ7ttttO\n", + "krTLLrtI6t7Tu73gneOV+Xt/BwUnirErgZ2UYrxK/XLddddJkm6++WZJZa+J6/MsVbdblNVop/Ra\n", + "Ssod/VhSpPoqZEOyZvvur9mqdpf2oIsotS9Smh588EFJXRZYyWaxCd8T0Inaj23XXl80h5mLvueb\n", + "t/Oee+6pOg/H4a2CZ/x6hixqKMojCkurIuXKD7bNcVFUSjbPGhgpPlF8JfdOn/MoTaUsO+wvyhz2\n", + "uRzZGd8/5JBDJHX1vu66665Nfj7C1fWx8X6KFFgnFakkSZIkSZJGpqZI/dmf/VkYA8FTMB463sD6\n", + "9esllbOA3NuJdrUfSm0MRwQxPGNnhiw28Iqo4dHXq2CcSwrM97//fUmdd1ZSLqPjeVYhKkStd+Lg\n", + "deIFRtQqdbXv7zmeK0XuVdbGgHnNnb7UqhWTzrwbQm29Kac1s7fvmuUxX7XfxxNvjQEbK86O9qKU\n", + "DI1NQrGjX1yddfg/cx6Vu7XWnitSrWt9KfYo+j9zyZVNX0NoJ3Pc76EoqiX7iN7SoAxSmZ17eF9F\n", + "qnUN7ovHsJVIRSpJkiRJkqSRRRkjxXtXnm49vgBFozZCf6iH2zezpy+larYlJt2+VvAqPWOJOAy8\n", + "z+j9PtQqMHjFP/7xj/s3diPwRrAbVIjaGJ8I7NczhyaN24XvK1erWgxVB4YquIuBVmVpoRi6BrRm\n", + "6I4Fc5i55rsjRLFCpdp0rLHLli2b9/zMbXYhoNZcqxrbGkfLmkm8L+2Pri9SUGrvfbW15FCS+JzH\n", + "DEZrCXOf2L3WNXRoVl4tUQ3LiFSkkiRJkiRJGlmUe+0BMS48zeKN9FWYeEpv9Q54Oo1iSSadSVBi\n", + "0kpUKbYngvfZtI/9ofDy+lbSrmVo1WW/XuwGr88VnVpQoqZtL5OuoB/ZS9/4hqExWZOgti1RnaRJ\n", + "gzKD6ts3o3Gh1dIIlAfmGjYbrXUlRQoFy7P0HDKUWeupID6WDdbu6sAaSUwR1x1VDHfFDsa+N3jN\n", + "RM+CLEGdK+4Fk6bvLhqAslabpZuKVJIkSZIkSSNTU6Rq3pF6/SKefnm69P2YInivW/IOo4rKeGmu\n", + "SJXqD9XSt5LzQsHTfKuXihe3evVqSdIOO+wgqXvaH1q3aFKgGBGbRVyM/94XFK3WzK++4J36/Jh0\n", + "nE+kSPX1CheTEgW16uxQJYrz9I1Zoo+ZY2RZ1aq/Y1WcHoqv8RDFyNTG3JTUWFRT5s7QXQ0cj7+M\n", + "YPyYq0uXLp319yj7L1pTPdasFV+7+lYA57pRbFHcyOgem9b4aOysNlYqFakkSZIkSZJGFmXWnsPT\n", + "q/+s9bJqK3NHihDeAJkcgBc0VGEgM2OxKVI8zQ/NeiQTh37Cyxvb22vFY3f4HSUOLw5vsG/cAfEA\n", + "KKqRWkEsH95jVJunNkaL/nUFyuuqoawOVdyAjKPfRyJVeuxsImwsUoNLmbrYGGp3LX0Vhlaiitoe\n", + "h8jvXKfbfF+lpWTbKFG0j/4fK56zbwYyc5SYN/qlth4V6jo/W3epYE1kT0WUy751zlCZGc+x6kK5\n", + "gtuaFQi19aM2nH/Q2ZIkSZIkSZ7FbBaKFN4VGRTE7gx96nRWrVolqVMOUL72228/Sd3+QDBWrAve\n", + "FPtBoQDVeg881eNtoYDQX63wlB/tQF8LNVBoZ2sW4KRwLxXvzWuzkAFVqz6whx1eLdftmS9Qq3jV\n", + "2l3kffvxuR6ul3GKvE2PvfJ5OGlllfHwHRCmwaTr2kQVq0s28sIXvlCStNVWW0nqFJWhaya27Mfx\n", + "NaIUIxYpSCh82DhjG9ly35gfjyHienxPPpSTsStpu5KI0uRrPVl7xJfS36wpN910k6SywsW9gH7k\n", + "enkLgsIa2QXXT4V31GYUKc8SLIGShuL3+OOP9/q+w7MA9oIC69mqzAdfO6Iahn33VV1cd7QkSZIk\n", + "SZLNiM1CkQK8qpI39hd/8RdNx1+xYoWkzishNqr1eLWgULTWJ+J7tdVpa6Gfh3rdvO+/++67B7dp\n", + "IUCRouYM3gxKS9QfeG/RvlV4vaXYsEkrLNHxaXfk5eLF4oVGcRqebYd3TYwhKgLerSt0keoBfI//\n", + "962V1AIe9NZbb930fWJLqI2HZ7z99ttLku67776hTZwFfUpfYcNDs/KitwFk5HJdKD+PPfbYJo9T\n", + "qoC9UDAXuJ4777xz1v/HyswGr2kYvXWgAjj3JOYU/Vkba+VvK1xtRrHi/9gNyhl2z5yP5motfd+2\n", + "OF5/yteyaC1A2WU+jLU3JKQilSRJkiRJ0sjUFKn/9//+3wYPd9ttt5U0t04UT5G8x+Qp2d/z8jTN\n", + "03NtNVKHGChqr9x7772SFq4SdWvMFe+vUTrw/KO4AvqN6yKWyuMNSsqAHw/lDiWnpLzgndEOvu+K\n", + "j9fZ8qyzWvCmURzxStwLxmvz+AjiQIhT4Lo9m5T20W+egVOL17PqC+1zokyn0nlK8RTgWXtPP/30\n", + "Jj/nWbDePvrf42361JxhzWCN4ZprlRnWEtamVnWa8zMmKAx9Y0xqbR81mb4fS+V0T5727LLLLpI6\n", + "G1q5cqWkrv+iitwRrD2ePdU305e1kTXE+w3FiXZia/QfSiL3lvvvv3/W5/pS+z0UvRtvvFFSN+f6\n", + "xr1yHM8Y9nbw9oXrZBxZG7Efv7e6+kxMHmuhZ+lh77WZz9gBn++7Bx4w7qW1w3dTqI2RS0UqSZIk\n", + "SZKkkSXPTGE78yVLlmhmZmahT5skSZIkSdKbmZmZ8C1PKlJJkiRJkiSNTC1GapKKFO9VTz31VEnS\n", + "+eefL6l7H966xxvvZ3m/TCwHv3NN/OR9Me/1/T18Kc7Bd5Dn+8Rwvfe97511PvAMoVbIxCGu5C1v\n", + "eYsk6bzzzpvVfuIYoh3aPXPE/06/8l6a99Qf+MAHJPW3FcbZs9A8Jojx4+cpp5wy63yl6tFQu58Z\n", + "GSd87swzz5QkrV27VtLcuAXsmLgCYsfoR/qf+AXa65lB/P2jH/2oJOmCCy6Q1NkXsUq+D1hUEZ2/\n", + "l2r40I+f/vSnJXWZY4wz/RDFjUQ7t9Nuxpn6b6961av08Y9/XFKX7cQcvPXWWyXNjfEh3s2r+Hs2\n", + "En3INZ944omSpLPPPnvW5zzOsVT5vDZT19eWPffcc1Y7yTbzviRejTlFVhPnoy+xMWzq7W9/uyTp\n", + "8ssvl9TFqTKXauP2aB/9QNwr52d83vnOd0qSLr30Uklzs8PYk43x8pp+HJ//kxVGbJHHop1wwgmS\n", + "4rWldu6X4kiZM6eddpqkzl44bumFUBQnyVz1NY74z3e/+92SpHPPPVdSt/bQXsadmCviWoHjRFlw\n", + "9DPfZ2357Gc/K6nrf+Y814t90t7I7n1e0A/cM1irP/axj81qb1Sjz9vd9xmgdA9KRSpJkiRJkqSR\n", + "zaqOVC3uHfAU2/cpdO+995bUZb7wlM1TMseNsgTxaqKaFSg+Dz300Cb/jxfh9Xe8BgdP616/aCh4\n", + "557V5v1byuKKvC7+7t6WZ4L0Be+/5FXSn66seIZL9H284Nr2RspcpMjQr3iLeF0onK7UuNcH7o3T\n", + "Xv9cSWHqm3Xo5+tb3yzKNPPMo40zwrxuEpm3PgeXLVsmqZu7eNa+xxu2Sb2nqC4SfexZVRwv8vD7\n", + "Zuqifu6+++6SujHzGm2cN6og7bspLF++fJPtI7uxtb5TVP0efG5FNki7ovpDzPlI+etbt6ikRKF4\n", + "Mjej66N/AUUEpaq0Z16k/EVrl48fChT3CPoHu4vuXaXsQL7HPcf/Tv9hN30r6vu8iPqBtbQ2m7Pv\n", + "M0BtHbFUpJIkSZIkSRqZmiL1h3/4h811k6KKyJHXF3kppT3p7rrrLkmxZ1yqzRLVz4FIiQK8KPc6\n", + "XNHgaZ+n9rESMfFGPV4EL5fzlvqhtEM7la8Zz7Fq3tTWKnFqFaa+Fd8jr7j03p44kl133VVSp2yx\n", + "31bJG0NNcZh/tfEgtfheinjDpXbyPa6TPRqj/eZgY7tCefrJT34iKVZ8iB/Eg3YbxxapP0RMiStb\n", + "zAVs3GGtYgzp46iGVgna6/tW+nXye6l+E33stfugb92mvnitMxQA5grKDf3L57n+vuq1Kyh9wQ5o\n", + "x8MPPzzv531c6OdSO2rnpMfROnzf32bQf9GaXFKnWftdpcbOgXvS2PviOpPa87L2uKlIJUmSJEmS\n", + "NLJZKlKRgtR3z63SU/JQZWSoMlT7FE98Bt5qayyLg1eCVw5476Wndb6H9xPFyOCd8dMVjVqIWyh5\n", + "iU5rJXyH+BX6pXYciOeJFCkypqKdygGFFS+VcYoUHR8fn1etldW9GjBeccnL5u+MI+oEylvExvtv\n", + "eUxIlB3kY8PvXrkc20DB8u/Rt1EfM6YoK0Pj/4C1BWVrqJoYqdn049h7k4ErKR6LRX/zk9i2PfbY\n", + "Q1IXG1aKNcImPeYFpQv78H50m6W9njXosJZF94BSRnXteJbuEVyXr7GtldkBFd3Hi3swawnxpqXs\n", + "1UmDUoYiR3vG2pc2FakkSZIkSZJGpqZI9VFN8Brw+HmqLsUglZjW03HEYYcdJqnzdry2RwTeLv2D\n", + "lzA0viHau5Cx46ker83PV5vpg9eEl9S6nxL2gBdEu0vtcLUCRQe7i/qxVnFzPB6Hnd5bYdxRDTg+\n", + "akikrEbtpQ7ZmjVrJEm33367pHqlzxVFxhOFszT3v/3tb1edBzaO50Dde/7zny+pU2xKajU24Kof\n", + "SpPXHAOuLVJs8MxRJoYqAZ7JSRzjUBU6ah9q96QUKd/zsLRmsVcatl2rJnN9bpusndH1uTLEXGOO\n", + "rFu3bt7zeSyc92dr7BBKodeDcjzzuBT7VEt0Po+d4nrpL+KCh86DvnD9ZOJz709FKkmSJEmSZMps\n", + "FnWkeIrGC2uNoamFp3281LFijkpwHpSOSJFyLwyvmTiHsZQ2vAuPefH+L2VVlfCaJq3tH1thLHlv\n", + "KF1eK6aEe6Gt8S2oLmS5oWy5HWDPteBN4631VQi932or+beycdwRfYk6WaqHA1GFcdQ8+tKvbeut\n", + "t5bUKSWlejcRKAteYd2hfV7lvpQZWwKbdLW0No61VOF7LJhzrXWtXFHsa5PMBdZA1G+PfaPf/Hz0\n", + "k6+pfcHOqP/F75HSg5147cPWOOWSQsl18vYIu/TdQPrSmnWJIt03jrqWVKSSJEmSJEka2SwUKWes\n", + "ejcRfbOUxgKvtlRN1Wuv4B3xtB/VvOkLx+V4Tqs34+Cd4C1NenxL9PWWhnqXHmdTqy74/mh4gR47\n", + "2Neeiet44IEHJA2PI5j0eG6s9pSUKGJiyDryvcfuu+++TX4v6kPqNJUyfFFqokxIz66KjoeSQHYh\n", + "32NN6FvBG7A9rwNUm2U4aSVqKPRbaU4xl7EHHydiumqVTj8f9ob9eYxYXxgfr+3nsFZ4RXSP4XO4\n", + "F/n3WHN87eP/tAN77LtHY8TQtXZSpCKVJEmSJEnSyGapSI1F9H57WpAxxB58Ee6tuhc7llLEcT0m\n", + "i/4aS2nAi1ms3kYEMUpLly6VVM6Si4gUxpL3jL3g5UWxan3tgfNS9TqilLEGk87Q2ThepqQU4Enz\n", + "HcYQm45ifZgDPra1Y13KAMXzp8p/pIwRP0m7XUlqVaRon8/BxZbZDNG+lRHMAY+t8jWM43FvwA6i\n", + "+lLRvQPlMaqTNdbuDeyhyBqycU01qVOisC/sn+thDlOHy/uT+RCtRf55lDzsnP4ZKz5yrF07xiYV\n", + "qSRJkiRJkkaelYoUcRJDFSm8w9YMEoenfrwK2ulP895eapuwP9hYtUK4Ps/koV1jKQ14w3h5C5Ul\n", + "ORTPmKrdU85B+eP7qB+Mc+SF0f+lcWC8xgZvvRTXM2mlsaUyPUqLxy7huY+VWQme+RjVXCt53KwN\n", + "zEnmDO1uzcYiZmdSttJKpDxxnfQHv6PIRWuIH4e1M9pVIBr30j3D7zHAuI0dhxutOVwv58POUKpY\n", + "u0p2V3tP8aw6xmFolmB0/MVCKlJJkiRJkiSNLM7HuwnDU/LQ2Cie7sfaq42nfo5b6wXglaII4P3y\n", + "e6v3Q2aQe3ce0zT0vXVrXMe0IR4HdaPVDvi+7wM1VjxAlHU5lNo4j0ln7W28P16r5+t1dqL/t1Ib\n", + "V1iqyeYxKFwnf0dZ67u21dpuSX3si5/Xx4/YH+8X1rhtttlGUjduKEHEDjk+vtHbhNpdJSJc+QGu\n", + "p7TX3lgKDnZCPCXKG2sMbx2ifTD7xshxPM8cRpnjXtJ6TxqrhiTHwR6G9nMqUkmSJEmSJI08KxUp\n", + "3lPzlLxy5UpJXf2cyJuJYH+vsSjtLO5Q5wdvgmrLeFWtT/9UgXVvEK9vWvW2Fht4562qhfcvXmAU\n", + "I1ci8uodVIxJZ9WV4lCGsrHK4J4l1x7FkPB5st8ipWWoAjNWZjBzDjWU47J2tZ6Hekae9eWMpUTB\n", + "ihUrZv1OrFa09qAkUNEbhYz2lzJIfY6OfT2O1wSkfaU5jV1GdcegtqK8xxYxH1gDUM68Zly0prGb\n", + "wt133z3r75GyyXmG3jta1W2PP6W/uO6ha1MqUkmSJEmSJI08qxQpvFO8Njx/fm+N1RkrS64Vnu69\n", + "eu9QxYj36s6LXvQiSZ1y5zFaffHsx9b34NF+ZdTm8ff2Q0FpcXuirhS1WUpEdcGw11pvac2aNZI6\n", + "L5Wd1qP9pfDG+ipSJZXHFbAo0yaKtynFh6Akc57ddtttw/+op4Tn2vfamDujx1AEMSh9P3fPPfdI\n", + "6vrssccekzSeqtj3OltVU1i/fv2s30trFv3CvpLY0FiZ02Pjdc1od20/l/qjtOaytrImuWLJ2hKd\n", + "x8eVLD/ewniWp18v40MsGwpjawzatttu2/Q9FCnWRpTBsVTyVKSSJEmSJEkaWdSKFE/T2223nSTp\n", + "3nvvldQ9laKI1CpC7kHzdMx5ogyFksJQu++S05qZ4e+h/f04+3/5+22u02Nj+npznJ+fPO1HsVSc\n", + "16sL0w73klrfgxOPgGJB3ETf6yvFJfB/FCn2SOT6+u4wvmrVKkmdQkS/YdfYJe3hOvEO99prL0nS\n", + "fvvtJ6mbJ8S7REpr1E4UR9QYvNLaGLBIqUIZxB74nfZRzbsU7+F7DG6sYDJX8dRd8YhA3SIbjLnB\n", + "74ytq7R45owFnrYrBbV9x5yIqv1zHjIVaSfHJ1aK31EESrXNiFXydh9yyCGSpIcfflhStwbyuUiJ\n", + "Yg4yl/mcH9/ra7HWoxTwf2w+2v/T6yTx/2XLlknqbMrbiy15pXjGkfMRR0v7qdlHv7IWeIyR2zKK\n", + "CNfD2teqKDLHGXeH6+Enaxd2Rb/V7pXotfL8XkS/AP2LPaBMYResQYxL1A9Ds0Vpb+mtU61yPOd7\n", + "Ta1KkiRJkiRJtOSZKWxes2TJEs3MzCz0aZMkSZIkSXozMzMTKsupSCVJkiRJkjQytRip+RQp3m/z\n", + "Hpn3psQpbLnllpK6miNUifX3n2eccYYk6VOf+pSkOJvNK3hHMTV8Lso44Jr4yftwMomIr/D30Vwn\n", + "sV/Rzu/EDxCTddJJJ0mSzj33XEnd++OhtTY87gK4rrVr1876nEPMT3QdtXh/Rhx00EGz2nPzzTfP\n", + "+j/xL6WqwqXzEUcRvWfnPT79H40D/fyhD31o3vOV7K0WYp7e9a53zTpfabwd4nNqYxJrx8/pGw9B\n", + "u04//fQNc93nHDESYwnwXNN5550nqRxjgu1tv/32krqMSq97RKwNawFZeh/5yEckSWeffbYk6SUv\n", + "ecms45EN5rZNDBdrEf3BWsr5DjzwQEnd2nLooYdKki688EJJ3VgQK0Rc3jXXXCOpixPcaaedJHWZ\n", + "lI8++qgk6bbbbpPUxccR28NYv+lNb5IU2woxXMQC+RpNXSNidHzOcD5iro477jhJ0qWXXiqpi1Xi\n", + "3uNxiYcffrgk6YYbbpj1eWBtJkaKmCDiRk844YR5r28ozAE4/fTTJ3o+h/Mw/0oV+oF7XxRDB9g7\n", + "nzv++OMlSV/60pckzbVr74/aGDDg+8zDY489dt7PpyKVJEmSJEnSyKLM2ivtao/3gzLgdYMioqfS\n", + "PfbYQ5J09dVXz/t9vJmSQuBVXPk9Oj/eT6TgcJyoFgj/x7vjJ14BXiftKNWHImMmyvQpZZgMVaL6\n", + "7vCNFxqdl+su7W9VopTxUaug1NbcqfXqSkTj2LfO2Fj10krZqqV+xNtHzdlY+aPPmCsoU2P1pVPr\n", + "6TIGd95557yfQ9FAOfM+8sxQVEXPFgNsluO5Ike/oER59pfbDkoQawRrMTAXUcJQovz7tKNUSR24\n", + "7mhtIBsMpc9hzvned6xlnt2GcsYc+d73vjdv+/y89JvXWYogi45cf65JAAAgAElEQVS1Kpqb2DX9\n", + "QW085qb3J+dnjngdJUBJxB64RzDXuOe4/WB/gIITVTyn3by14HyltZnz+9rJ9UdrRl8lCuiv6v1u\n", + "m86SJEmSJEmSTE+Rev7zn7/hKZWn9761NEr7KkHJG8X7QHGqPW6EK2p9FRbHY7e8GiuKFu+b/Xx4\n", + "q1FVWLwcjoPXxlN53/4gtoe4EI7L032pmmzfyub0c1QDZGiM0djU1g0reVNc74477ihJuv/++zf5\n", + "ub47uLcSzR9XaIeqQ15/bOP+ZE1Zt27dJr9L9XdigBZb9jDKBPGfHgvE9aEs4MlHY1yKl+T/KEv/\n", + "v71zjbGqOt/4c2JJajK1WFsGZGwGuch9oBBKPxhrBJMmDdpAGm2wNGJMjEljNbb9YjO9qLVJS5G0\n", + "sRdNSBqt8UNLmwoxTfBSEjpYII1OU6QMBhCxgk2gjcE2+/+B/+8cZs2sWXvvc9kzw/P7MnDOPvuy\n", + "bnu9z3rfd6XU0lChCKEv/vWvfx32eZj3Cd+uvKT2Ety7d++w64fQJsNyChUHyjflS5d6V9B38yoi\n", + "XC+mROFj9ZnPfEaS9OCDD456HO0ivE8Ux7A9cDx7F4Z9KlQQAeUrVNxifZvrUP4cl3csiB3H9WO7\n", + "Q6TKP9aeef68Y7UVKWOMMcaYklSmSF155ZV1z3giHlhXxapYvXq1pMascd++fZLiUXVYc0Ujc/Cj\n", + "IBKFyIyQouutKDL4C/BcRRUClIeYNYaVkdr5HSUo3DGc2TzKFdZjrBxT1hgKUFklqOi+XUQGlYX2\n", + "VZZ7771XUiOzOBElKeusWW655RZJjWjCmCLVKWLtAT8KFNNmI+ioL6zsi63G1O7y+IKsX79eUmNM\n", + "+cMf/lDqXsruThADS5ooJXYpAK4TqvnNQt2FvlZhpCZjSEw1jvm38v8wo3fe/S9TYxttIZZhHMI2\n", + "FyoZlG+s7zL2kTGdqMqQsu+iGChA+LGGGcQh9H8Nn493RajY7Nq1a8zrU67UO+UQlhO7jYSE91HW\n", + "XzVcbYmt9uR9h6RWwVCGU1iRMsYYY4wpSWWK1D//+c/6LJVZbjg7HBgYkNTIE4Ri9OKLL456zrKz\n", + "f2bx5GKJUXSnaKwILOiyvlLh/kyhgpKyflCYYopBaMWkZvNld3ofr6Ss3RRYsatWrZKUXvcvG0kS\n", + "Qr6svJFPVUH5oBKh1Jb1lWLcoF8UiSakzFCgmlXxQpWtWcII3BixKKqyhPtmAmMLz4k/aZinJy/U\n", + "GWN92fOEoBxw/pgiFUI5M6alcpjNnDlTUtpvNNzrsFnI3ffyyy9LKr+/LIR7OMagvilfokXDaM0U\n", + "4f6sKQU3tuoRqvnh2E15U/6MNbFySEUIxyLcQ6xIGWOMMcaUpDJFKo81ynru7t27xzwu5bOTmpWy\n", + "o3kqwgWrJe+sGh8hFIiyFji/5/5CK471a74PfchS68BE6eG7xSw9pnSlZvGp+iA78qFDh8Y8z3gH\n", + "6weF9Iknnujo9fEzGO8KIe2Hdtjs/YZ+NRdbqai1sWzt+GE+/PDDktJKEgpN+AzQ6rKnD6b8C1Hx\n", + "Uz5BeWHMwJ8TeL7QJyZvzrSQ0D+O85aFul+xYoWkhoKQ1wcnbB/smkF5hGNYUb/PMG9VWXjn7Nmz\n", + "p9DvWI2g3TKm51W0wnKIRcdBbDeGlO9iCOUWln+opIXvbO6HfsHfsrkN8/ZvK1LGGGOMMSUZl5nN\n", + "i5Jar07NKvl93vXsvBE6zL7zrkfHYNaNNReeD6s5jOTJu+ceVhhWHFbHjBkzJI30DUv5ZYTZc7nf\n", + "tWvXSmr4GWAlxSI9xjuUd7OZ3Ft1HzGabX/NgnrCfcSiVmmHWNGxdhH2v4tVItp8qo3m9WlKWdCt\n", + "8ncD7psotNR1UdubhTKMKVuholFWkeJ31GGr7h8fnli9x1YRQmWGsS5Wr6l6CWlVNCcKDe+oEydO\n", + "SEq38/CdVtanLm9904dRpIgoxscuFnEfgt8n5+H6qfunnXKdMFN/UfLmNLQiZYwxxhhTksoUqQ9/\n", + "+MOFM5nnpejOz1gheXOa5PWR4rhWWa34J4QWfahYxZQo9jcibxb5l7jP2HlTikcIVi3KFJm3yawe\n", + "ZiKfqLRajShLSjVpNnIIaxLrEp/CvIyWgXw0sLq5HhFCqXHi4vYettVm8/ngw8M9tEphSNGsJV2W\n", + "WAQrYyp/i+7TGBJGV5WFPkgmdRQu8nChstO2Ur5kYRRfs/fXqqg9FBnGbvJIpXydwvbabN4zovhi\n", + "fTK2NyTlQD2k/IUpf5RGlKm8exc22z4hb87Hif0mM8YYY4ypkEp9pMKIglZRdJf6opnGUxEIWLE8\n", + "X9H8UxD6tnC+0L8DayXl94EvD0pQat+sspnJUQiwXrBG3nzzTUmN8s67Xm7GJmXdNWsVY8WW7aeo\n", + "BCk14B//+Iekxr5fqB+p6168j1uoEnJtxoSiliq7LtBnwl3t20XeaKFmo/XyghKCwsB1UQ/LjqGt\n", + "grZDxvHY+cMcfGG+pzCPV7NjFFFjzYIyw33hF5t614XtnectqtRSLjwPvmKxDPZh+XE99nVlNSTW\n", + "bg4fPjzq50VXR/KCTxbPxXWc2dwYY4wxps1Upki9//779dkts9dQGWEWy2yR4/CdaBXMmvHhSUWR\n", + "paxarLRUNGEKrGksbqLoml3/xZrB4o8pWaG/QFE4PxEmKFyxfb1Me2i2vdA+yraDMBtxzBqO5WpK\n", + "cbFyG94jClVZf7bBwcFSv2sW+nrKb7Ns9FyMUEFhLAvVQcaksooUbYrnbBbqHTU8VJ5QGlBEIOYr\n", + "hALXrCLVKl+3MDI7b0b4sK/ljeQOoXwZy2l3odpNuwjLlevzLi+bQ7BdftXhGMX95/WbtiJljDHG\n", + "GFOSMRWpY8eO6ctf/rLeeecd1Wo13X333frqV7+q/v5+/fKXv6xnMX3kkUf0uc99TpL06KOP6qmn\n", + "ntJll12mxx9/XDfffPOo5+7q6hqxdxyzXRQLsuwyy2VWHMvmi09OWSsCK6TZvEZYAc0qAfi+MDvm\n", + "uULlLu8sPVxfx58A6wIfJmg2Ko1ZPvVq2kOz7T4vZdvDmTNnhv0f6xS/o9BKRt3I238utn7D34T3\n", + "TFnRt1q1V12rwCeL+8xrEbeKcExF+cAXB18Zxuyy0V/U8dDQUKnfh9CGwgjmkFQbjvn+lKVVfZL7\n", + "IU9TXh8z3mm0ozBqL6zfFOE7pLu7e9j3vKvDfsX58X0qq6Q2uy9qjNg4kFfBG3MiNWXKFG3ZskXL\n", + "li3TuXPntGLFCq1du1a1Wk3333+/7r///mHHDw4O6tlnn9Xg4KBOnDihNWvW6NChQxM+zN0YY4wx\n", + "ZjTGnEhNnz69PqPt6urSggULxsyoumPHDt1+++2aMmWKent7NWfOHA0MDGj16tUjjr3iiiuS+yEx\n", + "GyR/DbP72Hp82dk/s2sUthixfYRCsBZSlnfR+0OJC/enyjtLxwpg3T6mRKXg+VI+M62yNltF3vor\n", + "Cn0k707hrQa/j6qiILFSY1ZmzNqN9YeivnN5fLfog6jc/L9opuqQOXPmSGo8e+j/l7L0Ua+XLl0q\n", + "qaH0kG+H/EhVESpjPF/ZsSykWdWe8kMZoS/Eyi1v329VHqJWQcQ19583Epx3Bf62+KShHIXRqChV\n", + "4fsdpZTf8w5hVQliCmreXT64X1YzQjU7dnyz/six6/DuTZFbKjp69KgOHDhQnxRt27ZNfX192rx5\n", + "c33QeOutt4Y58/X09HhZxxhjjDGTllxRe+fOndOGDRu0detWdXV16Z577tG3vvUtSdJDDz2kBx54\n", + "QE8++eSov43NQPPszs06d2gdxCzfMBdEXrAa//KXvwz7nNk6s+O8/hRYyFgBYebwotFPYYQGCkhZ\n", + "mt0bjujGWK4PqNr/BPUB66nVShQ5RrgO7a7TGc9Tyl+zuWyuvfZaSdKRI0ckNaxA2nFKdQnzlWHF\n", + "MjY0a01eHKFFXwkjZxkzyDfUKkK/Rcokr+8QfSTsSyhSeeG5GbPCNphSxVFrw9+F0Vn8nv+HCgZq\n", + "NWNfTDnh9/j8lIW2GNuHtCiM1bE9BVEoaHP4LjG2Ux6M0WHfK5pZnNUYFJOiqjP3F0YxMhbSzhBA\n", + "6DeUJ/VJOeNbyO9jeaRCwqhBxk6ei/bJ81LOKUWK9srxofJFu2Zsjo1Vsc9RZFMkFakPPvhA69ev\n", + "18aNG3XrrbdKutD4a7WaarWa7rrrLg0MDEi6sBntsWPH6r89fvx4fYNaY4wxxpiJwtmzZ3X27Fnt\n", + "3r17zONq2RiyQZZl2rRpk6666ipt2bKl/vnJkyfra6VbtmzRvn379PTTT2twcFBf+tKXNDAwUHc2\n", + "P3z48AgroVarqb+/v4nHM8YYY4zpDP39/dFVljGX9vbs2aNf/epXWrp0qZYvXy7pQqqDZ555RgcP\n", + "HlStVtOsWbP0s5/9TJK0cOFCffGLX9TChQv1oQ99SD/96U+bllqNMcYYY8YrYypSbbtoraapU6fW\n", + "ndTxbWJ9k3VW1lFZZ2ddHX+AMPKAdWqWEzdu3ChJdfUr5icQrkOH4COV8n3hOj/4wQ+G3U9IGOWU\n", + "un4Iz/3Nb35z2HXbDdfhb97oPSi6t2J4vRR56ynv9a655hpJjQgs/AbCzPCxve7wS6Ad0O7wk3jo\n", + "oYeGXa/dFC3PVl1v27Ztkhr9GDU7lrMH/xr8Gyg/yp9yp9/w+b333qvvfOc7kloXVRajbFnybKl9\n", + "MWPX+/a3vy2p4bNCGRAxmuqLlB3DfszflOt973vfG/O4VsH1fvzjH0saGbkZGzt4HvokfZ+xie/x\n", + "ScKwv++++4ZdN9WnP//5z0tq+Pbu379/2Pf4QoX7SlLPsefjXcDz8Q7kfnk38i4Moyd5Hv7S7rne\n", + "E088IanhC8WuILQT+hb3vWjRIkmNcj548KCk+NiKT9XXv/71Ydct+m4oms8qb/+j/Civsrsz9Pf3\n", + "j6lIOcGTMcYYY0xJKttr7+KZHREv4WwUq2D+/PmSGhYsyk2oYEEsmixmpaaUIHKUkPGc2Tb3G85S\n", + "U/sghfeRV4mCmKKD0kEkTGhFtjpqrejsvl37JEGro+UuDpy4mNBqjBHL71U2G/REJVzeT2WPxopH\n", + "QY5FKhEZhTUvtV+JapaiSlQIYw1tq2imZxSQvHmS2q1EhcTaROxzxuDw3VF0LOD8sXLhnRKLeEZh\n", + "SuVAC88f1mcIfSUWic7vY0oJfSeV4452uXfv3lG/j5VnbNWFd1HeHIp5lajYdWJjat4I/jDqryhW\n", + "pIwxxhhjSlKZInWxhRHORvFNYV33pptuktRQVPbt2ycpnhOGWWqrCPfeS1kBYS6V0Aptl9XMrBwl\n", + "j3Xh6667TpLq+yH+6U9/ktTwVeH5YgrMpRowgF8A7TOst5gi12wm+5BO7aXXLshRg/VK/4ipDJR7\n", + "6nlp32NtQRXz7VixYoWkkbnjJjtXX321pPz5tFJ+h4xx+AhRF/SN1F6B4Z5x7VatQ1Ai6OMxBS6V\n", + "ew9fIdo45RauTuA3SXmG+ZnKkvIh63Sm9k5dr1l1n7kC70h8wopiRcoYY4wxpiSVKVLTpk2LKiDM\n", + "Elk3JtoHC3Tu3LmS4r5QRWep+FpgTaWyrqfWc7Fq2pXhOuWDFWaKxkoiM/X1118vqWEF7dmzZ8zz\n", + "VZ2hvFnK7sdEO8Jqzfv7mBIV25MuZfWj0LZqf7hOg+pABnj+H/MnydtvKMexlL/YuVauXCmpoRC8\n", + "+uqrktJ1XFadDVWzVqmVsbYTRnOFY2qrIaqMXQ/wyaGOYv6ZVfsLhsoQSkrKNyyMKA99hTgvUWNA\n", + "fUFKiULx42+eHUEuBqWKd1ZZpYg+S31VVW/h3n4pUmo+UYphPRXFipQxxhhjTEkqU6TG8mtgXZ1Z\n", + "/ZtvvimpMbv+1Kc+1dJ7YX0fK6PorD+E2W+7fKGKRjgQFYgC+Prrr0uaeMpGWbDKi+YqwSrNuwN4\n", + "WVIKTCpyZ7xD+8N6p58VrY8Qyq1MbpiXXnpJ0sg901IUVWex5L/2ta9JauQjIh/UH//4x0Lnw8eJ\n", + "thBTGPB/RIFC+Th16lSh66XaJv6f+JaEPiYXR1SORqhslM2zVZYw/xLKXUqRiu0hGBK2F/b9TIFC\n", + "goJFvrDYuynWfskb1Sxl8y+1mlDRS5GqR9pbsz5dVqSMMcYYY0pSmSI11hprzApi1p3a7b4oqdwf\n", + "RRlvuWxCv49Q2SAT/IkTJzp2T52krF8ImbWxBv/+9783dR9YR0X9bDqdy6fVhMoRz4PPWFlFinaM\n", + "olyEVBRWq+CZd+zYIamhhMXy9aTA9yg1xjSrqldFp5QooC8W9Z/MS9i28yo74RidygN1qVA0cjml\n", + "NKHQkiGgLFakjDHGGGNKMi4ymxeFCJBW5ethvbtdES3jnaVLl0pqWEGxbLUTnbztJYzSI/KjVf4b\n", + "Rdv+rFmzJElz5syRlI6yHG9glaNAhVmk8Uvhb1F/jKKRPFXQKgUs71g3XnKP4dPS6fxQeaHtNJvH\n", + "KUarcxpOFJrd9zRGq1d7UG6J2iyLFSljjDHGmJJUpkg14/eBf1XMsi/qg0L0UFElhj3tWhUZ0WmI\n", + "AMJaHCuScjJABFGqnomYIdoM/wQUlbKwDl/U+uW65JOaaIpUqj+WzU1DfV6qmffHolUKEGWbV0Xl\n", + "eBQJlDHU/rCOUznx2k27x7xOR9qOl77QrhyKRUmN+XzO6kNZJW1yvzmNMcYYY9pIZYrU1KlTkzlN\n", + "sMRZF+UvuV9ivipFfVDK+gThMzPRFCny+PDcg4ODkia/j1jRjNn46rTKui+bYR1FjP2gyE00XnK7\n", + "pOA+6ZcouZRr0f5HOaImTHYltQytUgQo25RaSOQkdUMfSv2esXyy0umI23DvwkudvCo3ylVZnzaP\n", + "QMYYY4wxJalMkcqzNs56bxht1a6dpZnN59nDS8q/gzoU9TdoF3mz8k40UkoNvk+p7MJEOtHuqK9m\n", + "6436L+oLRH4vrKbFixdLkvbv39/U/XQK1JFQWS7rHxMqeqns2aY8qO7k2kNBYgwOM4KHe/qlxuqq\n", + "fXrGu6pb1GdnvPgmjRcoDzL9s3rEGEx7Zh/Q1157rdR1rEgZY4wxxpSkMkUqj18R+WfCPD4oRkRE\n", + "5J2Fx/IIsa5PJmv29stLXquqrKKBr9hEz3Ddbsj/RH3QLsi/tGDBAknS73//+zHP0y6rrqwvHtYT\n", + "GdbxlZooihT9lj002fOR50LFKKrU0Z8nUq6eqvM7Fc2FRp0wBhHpS1sOVVbGOMaqVJtPqf60eSJo\n", + "myX0IWLM6FTuvJ6eHknS8ePHcx2PPyvvS78DyhHLNUe7btY/2IqUMcYYY0xJKlOkilj9oQ9E2X2R\n", + "QusHBYooIjKmF1WOsNLaRausEKyvdvmYVU1MaaT9/PnPf+74PUkN5aRsRA3WFOv5fX19kqS//e1v\n", + "kqSDBw82e4tthczsoWpB1F5KHaEe+R3td9WqVZI6n6unDLTBZiMMUSjK+jkWzcofHn/o0KFh/8f3\n", + "JFS6WE1IjaXhPqf4zeX9fVFCn6h27bEXo2hm7om6Z2K7KNt/Yv7MtL9m1X0rUsYYY4wxJalMkZo+\n", + "fXrSTwDrBGsHSxSrDIu27M7YWHX8LbuPD1FVUNbno9VgBYd7m0008vp1oNzRPmhfhw8fllQ8HxRR\n", + "ftRnKtovBu2qbHtg/f65556T1PCzafW+U+0CJY7M7ihslAeRSXxOPZIBnt9TDnyPf8PF7QLVjmO7\n", + "u7uH/Qalg+OoW/y2UnCvecGCnj59uqSG6l0Wxqowc3i7ctnFosYoe3yLwszljN2UO+VM+fP/3t7e\n", + "YeflewjVRlYPOD8qO32b+zp69Giu50uNCYwBPH9RX6pQhc77+zBH2kTxjaIPoyTSHsKI6aJjIe2c\n", + "MaTVNBs9akXKGGOMMaYktayCpEa1Wk39/f2dvqwxxhhjTGH6+/ujPntWpIwxxhhjSlKZj9Rzzz1X\n", + "92FhHR7/AXwjrr32WkkNX5DQjyH0ucAfgnXYO++8U5L03e9+V1Ijeyl/WRcNs5mSd4h18fC67CvF\n", + "+jX38ZWvfEWS9POf/1xSPOLiRz/6kSRp9+7dkkbmNVqzZo2kht/B3r17h31PlODdd98tSdqyZYuk\n", + "hk8QvlGszxNZw/OEfhr4ILFuzfesS7O+zfMZY4wx5gJWpIwxxhhjSlKZIvXuu+/q1KlTYx5z5MiR\n", + "Mb8PIzrIFhtGA6K0cD3WOWP7LBHlFSPMfYKCBqncH08//bQk6dVXXx31+xUrVkiSnnnmmVG/D3Of\n", + "hM9BJAp/iRSJRX6QPTiMfqQcO5X11xhjjJloWJEyxhhjjClJZYrU+++/X/cxIidI2T3OUpmN8aHi\n", + "/Py/VTuPh7llUjt2x5QofK3wjYrlhgn3BQpzr4SkAjPxQcOnKlS4Uuc3xhhjLlWsSBljjDHGlKQy\n", + "RercuXN1JaSsEpWX0Men1b4/KGpQNoM1vlbbt2+XFM+6G+52n8p6m8q0zucch1JXQYoxY4wxZkJh\n", + "RcoYY4wxpiSVKVKjwS7vze7IHe5vBKFyxHEoMEX3YuP3+FxBs/si4QMVU5Ji0YYhPG9ehYzyn6h7\n", + "8hljjDGdxoqUMcYYY0xJKlOkrrjiihHRdq2KDgsVG5SZMEqPKDl8pYoqUmQEZ8fxGEQn4hOWgkzi\n", + "KENlfa74Xeq65I+66qqrSl3HGGOMuVSxImWMMcYYU5LKFKmPfexjIxSpUEnCR+gTn/iEpJGZt6Gr\n", + "q2vY/8MoQJQuFCn2okNJCq+DQoUixPnDDOb4MoU+UiFcJ69vE+dtVqFDicqriNk3yhhjjCmGFSlj\n", + "jDHGmJJUpkhdfvnldWUo5puEgpJSSj7+8Y9LavgEnTlzZtTjyIt0+eWXD/uLIoUShe9Ub2/vsPOG\n", + "ihTKVyofVV4lClJKVJhJPUVMUQvxnnrGGGNMMaxIGWOMMcaUpDJF6tSpU/VoupgihYJEJvIYZ8+e\n", + "ldSIokspQCgzXB8fInyZiF5DsXr33XfHPB+/7xRhPqwU3B95oigf76FnjDHGNIcVKWOMMcaYklSm\n", + "SL333nsjMoCn9oSLcfr0aUkNX6qU0oIvEL5D+Grhk8X1jx49Ouz8MVL3i88VSlBMgZs6deqw72PH\n", + "EdWXFzKw40t2+PDhUY/zHnvGGGNMMaxIGWOMMcaUpDJFarT96Mpm8Ia8UWcch+8TihF5rdjrL+Wb\n", + "BbH8TB/96EclNRQkng8fJ/7iu4Ry9K9//SvXdfPyzjvvSEr7jlmJMsYYY4phRcoYY4wxpiSVKVLN\n", + "gC8VPkUoKShDeRUdlKJwT7uiGb5RngCFC2WL85IBfdq0aZIaiheKVCrPU1m4H6IQYz5YlGerFTFj\n", + "jDFmsmJFyhhjjDGmJONKkULZQUHBtyfcOw+Fh73xyJNEdF2oEMXOT74o/LVee+21XPd59dVXS2oo\n", + "TDNnzhz2fUxZQjkjGhDCPQdjcN+xaL4Yn/zkJyWN3GMQTp06pcsuu6yujFmRqpahoSHNmjWr6tsw\n", + "/4/rY/zguhhfuD4uYEXKJDczNp0lnGibanF9jB9cF+ML18cFKlOkbrjhBt14440duVZ/f3+u4zZs\n", + "2NDR67WKZq+3e/fujtWFMcYYM5mwImWMMcYYU5JaVkHyoM9+9rN66aWXOn1ZY4wxxpjC3HDDDXrx\n", + "xRdH/a6SiZQxxhhjzGTAS3vGGGOMMSXxRMoYY4wxpiQdn0jt2rVL8+fP19y5c/XYY491+vJGUm9v\n", + "r5YuXarly5dr1apVkqQzZ85o7dq1mjdvnm6++WbnkmoTd955p7q7u7VkyZL6Z2OV/aOPPqq5c+dq\n", + "/vz5euGFF6q45UnNaPXR39+vnp4eLV++XMuXL9fOnTvr37k+2suxY8d04403atGiRVq8eLEef/xx\n", + "Se4jVRCrC/ePUcg6yH//+99s9uzZ2dDQUHb+/Pmsr68vGxwc7OQtmCzLent7s9OnTw/77MEHH8we\n", + "e+yxLMuy7Pvf/372jW98o4pbm/S8/PLL2f79+7PFixfXP4uV/euvv5719fVl58+fz4aGhrLZs2dn\n", + "//vf/yq578nKaPXR39+f/fCHPxxxrOuj/Zw8eTI7cOBAlmVZdvbs2WzevHnZ4OCg+0gFxOrC/WMk\n", + "HVWkBgYGNGfOHPX29mrKlCm67bbbtGPHjk7egvl/siDG4He/+502bdokSdq0aZN++9vfVnFbk57r\n", + "r79eV1555bDPYmW/Y8cO3X777ZoyZYp6e3s1Z84cDQwMdPyeJzOj1Yc0sn9Iro9OMH36dC1btkyS\n", + "1NXVpQULFujEiRPuIxUQqwvJ/SOkoxOpEydO6Jprrqn/v6enp14xpnPUajWtWbNGK1eu1C9+8QtJ\n", + "F7aJ6e7uliR1d3fr1KlTVd7iJUWs7N966y319PTUj3N/6Rzbtm1TX1+fNm/eXF9Gcn10lqNHj+rA\n", + "gQP69Kc/7T5SMdTF6tWrJbl/hHR0IlWr1Tp5ORNhz549OnDggHbu3Kmf/OQneuWVV4Z9X6vVXFcV\n", + "kSp710v7ueeeezQ0NKSDBw9qxowZeuCBB6LHuj7aw7lz57R+/Xpt3bpVH/nIR4Z95z7SWc6dO6cN\n", + "GzZo69at6urqcv8YhY5OpGbOnKljx47V/3/s2LFhM1jTGWbMmCHpwqbPX/jCFzQwMKDu7m69/fbb\n", + "kqSTJ09q2rRpVd7iJUWs7MP+cvz48REbZJvWM23atPrL+q677qovT7g+OsMHH3yg9evX64477tCt\n", + "t94qyX2kKqiLjRs31uvC/WMkHZ1IrVy5Um+88YaOHj2q8+fP69lnn9W6des6eQuXPP/5z3909uxZ\n", + "SdK///1vvfDCC1qyZInWrVun7du3S5K2b99e7zSm/cTKft26dfr1r3+t8+fPa2hoSG+88UY9ytK0\n", + "j5MnT9b//Zvf/KYe0ef6aD9Zlmnz5s1auHCh7rvvvvrn7iOdJ1YX7h+j0Gnv9ueffz6bN29eNnv2\n", + "7OyRRx7p9OUveY4cOZL19fVlfX192aJFi+p1cPr06eymm27K5s6dm61duzZ77733Kr7Tycltt92W\n", + "zZgxI5syZUrW09OTPfXUU2OW/cMPP5zNnj07u+6667Jdu+tes7EAAACgSURBVHZVeOeTk7A+nnzy\n", + "yeyOO+7IlixZki1dujS75ZZbsrfffrt+vOujvbzyyitZrVbL+vr6smXLlmXLli3Ldu7c6T5SAaPV\n", + "xfPPP+/+MQreIsYYY4wxpiTObG6MMcYYUxJPpIwxxhhjSuKJlDHGGGNMSTyRMsYYY4wpiSdSxhhj\n", + "jDEl8UTKGGOMMaYknkgZY4wxxpTEEyljjDHGmJL8HyFOTlbukMv2AAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJMCAYAAADaNPObAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzt3XuMHeV5+PHneO/3+8X22izxbVkbsI0hlLTBYK0JCBwS\nKLkpsQClUmmrgNICUlUJWiU2StuEJM0/FaVWknKp2oKLEos4yTqhDhBDiAO2sU28eL3eXdt7v1/P\n7482/sV+nzXvvvOemTlnvx8pUvZhzsyzM3POeTz7zDOJZDKZFAAAAMzLoqgTAAAASEcUUQAAAA4o\nogAAABxQRAEAADigiAIAAHBAEQUAAODAexG1Z88eaWpqklWrVskTTzzhe/UAAACxkPA5J2pmZkbW\nrFkje/fulaVLl8q1114rzzzzjFxxxRW+NgEAABAL2T5X9vrrr8vKlSulsbFRREQ+/elPy4svvnhB\nEZVIJHxuEgAAIGVuvPFGaW1tVf+b1yKqo6NDli1bdv7nhoYGee211z7wdQUFBUZsbGzMZ2qiXXCL\nqqALkktlZaXVcsPDw0ZscnLykrk89thj8thjj6XlfvEtSC7XXXed1XKvv/56ynPxLS65RJVHTk6O\nEdPeV0Fy0V5r+wcD3/tl0SKz42N2djbluXzkIx+55H8/efKkLF++XA4fPmz8t97eXq+5+GabS1ZW\nlhHLz8+3imn7IC8vz4hp37NaLtp5/zszMzPnc52amppzuQ8S52N0qTy8FlFcZQIAAOmstbV1zitP\nF/NaRC1dulTa29vP/9ze3i4NDQ0+NwEAAJAymzdvls2bN5//+fHHH59zWa9F1KZNm+TYsWPS1tYm\nS5Yskeeee06eeeaZD3yd7z/dZWd7/bUio11K1363wsJCI6ZdCj579uwlt/f7Jw0QhHb+rV271uq1\nBw8e9J2ON0H+XGErqmfCa//g1T6DtM8R35/hGzZsuOR/r6mpkYaGBuno6DD+m/anrHQ0MzNjxEZG\nRqximvHxcedcPui8t/0TbybyWm1kZ2fLt7/9bbnllltkZmZG7r//fu7MSyMUUQDSAX/hQFx4v2Rz\n6623yq233up7tQAAALHCxHIAAAAHFFEAAAAOMqMD+yKZ0liuzf/Izc01Yn19fUZsYGAgJTn9Ptu+\nhFOnTqU4k0vPMfl9YTQGv/HGG0Zs1apVRqypqcmIHTlyJCU5hU2bSbNkyRKr18a5sRx6s7lvtreX\nd3Z2pjYR0ecYat8xQ0NDKc8lKiUlJUbs+uuvt3rt3r17jVhUN0+kAleiAAAAHFBEAQAAOKCIAgAA\ncEARBQAA4CAzOrAvspCnp4YpTs2BxcXFVstpTfi+XX311Ubs8ssvN2LaZOVMaSyfnp42Yv39/RFk\nYlq6dKnVcoODg0Ysk5uHw7gBxNbbb7+d8m3YPlxZeyasduPE6OioEdOmjqcjnos7N65EAQAAOKCI\nAgAAcEARBQAA4IAiCgAAwEFGNpZrU73TkdaoODk5acS0Jt4wdHR0RLJdTRgN47a06b5aY+bExEQY\n6URCO09fffVVI6btFy0Wp5sY4iIrKyvqFBYE7XN4fHzciGXyDU3ad8w777xjxLT3fVVVlRE7d+6c\nn8RigCtRAAAADiiiAAAAHFBEAQAAOKCIAgAAcJCRjeXDw8NRpzBvzc3NRqywsNDqtdok6LGxMSO2\nePHi+SeGedOmFGvTr8+cORNGOpHQJjpv2rTJ6rUDAwNG7OTJk4Fz+p043RARRE5OTtQppDXb6eRl\nZWVGTLvRQTtvM4XWWF5TU2PEtH2lNebTWA4AALDAUUQBAAA4oIgCAABwQBEFAADgIJEMeRRwIpFg\n+jAAAEgLl6pbuBIFAADggCIKAADAAUUUAACAA4ooAAAAB5FMLNemwqaa1hQWRR4i8c8lPz/fiGmT\naFetWmW1jd/+9rdGrK+vz4hpU9bjtF/Ky8uNWJApxVlZWVaxiYkJI2a7X1auXGm13PHjx62W0/ZL\ndrb5MaJNbddov6/m4vXF/T1km0tpaakR06bbh5GLb1ou2pR1bRp2GLnEab+Qi56L9r0zNTVlxLTv\nDo323ab9vtqU9blwJQoAAMABRRQAAIADiigAAAAHFFEAAAAOImkst1FYWGjEtCbU8fFxI6Y1nsGe\n1shcUFBgxEpKSsJIJzZGRka8rk9rvrZtyPZNa7jU3lsa25xtzxetwXR4eNjqtelGe69lsjCayJE5\ntJtWtJsTbBvLtfXZ3twyF65EAQAAOKCIAgAAcEARBQAA4IAiCgAAwEEsGstzc3ONWG1trRHTmsds\nm1+DaGpqslqut7fXiJ05c8Z3OpHo6OgwYv39/Vav1Zr5tFgQWuO7xrYBUZOOTbHaJHKtiRzRsL2J\nQxPkXNb4nm4P/7Smak2m3FylPdkiSCN4Km7m4UoUAACAA4ooAAAABxRRAAAADiiiAAAAHMSisTyI\nODXQZfL0Ya2pemBgwOq1VVVVRiyMGwKiok3b14yOjqY4E5HLLrvMiGmNy9o09vb2dq+5DA0NWS2n\n3WjiU3FxsRHL1InoyCy2TdVx+l4MorS01IhpjeC271/thibbGznmwpUoAAAABxRRAAAADiiiAAAA\nHFBEAQAAOIhFY/nk5KTVckEbwFydPn3aiCUSCSNGc6qup6cn5dvwPb05CK2RXqM118/OznrNJS8v\nz+v6fNPeR6lm+3kTBm16vHbMwrgRo62tLeXbSEe2NzqEcV4Fna6dboqKioyY7Q0qYeFKFAAAgAOK\nKAAAAAcUUQAAAA4oogAAABxE0lh+8cRgrXlMaxROJpNGTGviDTIJetEis67UpnXn5OQYMW0aqtY4\nGnfa76HtgyC0SdpxV1ZWZsS0qe1BmqW1adoa7bzSjpHte6Gzs9OI1dTUWL1We89o7+nFixdbra+7\nu9uI+WyQj1NjudYwHtU0f9/v8UwRp/MljEnk2nstqqdx9Pf3G7Eg3+9aU3rQ9xtXogAAABxQRAEA\nADigiAIAAHBAEQUAAOAgkdS6tVO5wURCbRAHAACIm0vVLVyJAgAAcEARBQAA4IAiCgAAwAFFFAAA\ngINIJpavX7/+gp+Hh4eNZUpKSqzW1d7ebsS0ybva5NMgk6WD0BrU4pRLZWWlEdOOx+zsrBHTJtsW\nFBRYLdfV1WXE4rRf6uvrjZg2sdx2Aq42Gb6urs6InTp1yojZ7pfa2lojdvbsWSNme7NHXM7duOQh\nQi5zCZLLNddcY7XcG2+8kfJcfCMXXZBcsrKyrJabmZkxYtr303ymonMlCgAAwAFFFAAAgAOKKAAA\nAAcUUQAAAA4iaSx/7733LvhZayyHvZycHCM2NTXlvL6+vj4jZttsrjUtnzx50jmXOOnu7va6Pu0G\niNOnTzuvr7y83Iht3LjR6rV79uxx3i7gm/aZpikrKzNi2s0eyGwNDQ1Wy73//vtGTDuH5oMrUQAA\nAA4oogAAABxQRAEAADigiAIAAHAQSWO5Nq0adrSJ1hrfTdBas7nGdnIs/NOm8h88eNCI2U4nR+pV\nVFRYLWf7/ssU2pMoNEFuoElH119/vdVyr776aoozCUdpaakRKyoqMmJjY2PO29DWNx9ciQIAAHBA\nEQUAAOCAIgoAAMABRRQAAICDSBrL4U6bxhtVo3B2tnn6aI2eiUTCiPnOuba21ogNDQ0ZsSANiNrv\nq00dD8L3frGd/BzG7wbYOnPmjBHTztHx8fEw0kGMaDcvdXZ2Oq8v6DnElSgAAAAHFFEAAAAOKKIA\nAAAcUEQBAAA4iKSxfKFNmfUpqkZKrUm7uLg4gkx0hYWFVrG2trYQsomPsrIyq+U6OjpSnAk0C20S\nuS3thgjtXD579qwRy+QbIjJlErmtwcFBI6ZNMQ+ip6cn0Ou5EgUAAOCAIgoAAMABRRQAAIADiigA\nAAAHTCxPMW26qm+5ublGbGZmxipmKy8vz/m1YUwsD4PW7FpQUGD1Wu33LSoqcl6f1jQ/OjpqxLTG\nTE0mN+NebNEi89+Os7OzEWQSL9r5ODIy4nUb2ueh9rlk+z7QBPmsQrxox7K3t9d5fVVVVUZsYmLC\neX0iXIkCAABwQhEFAADggCIKAADAgVMR1d7eLjfddJOsXbtW1q1bJ9/85jdF5H//VtnS0iKrV6+W\nrVu3Sn9/v9dkAQAA4iKRdOjw7erqkq6uLlm/fr0MDw/LNddcIy+88II8/fTTUl1dLQ8//LA88cQT\n0tfXJzt37rxwg4lEWjYVAwCAhedSdYvTlaj6+npZv369iPzvoz+uuOIK6ejokN27d8v27dtFRGT7\n9u3ywgsvOKYMAAAQb05Xon5fW1ub3HjjjfL222/L8uXLzz8LKplMSmVlpfFsKK5EAQCAdHGpuiXQ\nnKjh4WG566675Mknn5SSkhJjo9p8IBGRxx577Pz/37x5s2zevDlIGgAAAF60trZKa2ur1bLOV6Km\npqbk9ttvl1tvvVUefPBBERFpamqS1tZWqa+vl87OTrnpppvkyJEjF26QK1EAACBNeL8SlUwm5f77\n75fm5ubzBZSIyLZt22TXrl3yyCOPyK5du+TOO++cM6GwaTvANg9tyql256E2eVebjqwtZ5uLNsE1\nyMTVIPvFNy2Xuro6I3bmzBmv29UmNQ8PDxux/Px8IxZ02q2NuB8jLZfy8nIjdtVVVxmxEydOGLFT\np0594HbTcZ+EwXYyvjbx3vYftz09PUasuLjYiA0NDRmxOO0XctFzqampMWLnzp1z3ob2pIepqSmr\nXLT9osXWrl1rlcv7779vxLTzdD4XepyKqP/5n/+R733ve3LVVVfJhg0bRERkx44d8uijj8o999wj\nTz31lDQ2Nsrzzz/vsnoAAIDYcyqi/vAP/3DOZ03t3bs3UEIAAADpgInlAAAADiiiAAAAHAQaceCL\n1si2ePFiIzY5OWnELr77L27m+rOnqzAameOkt7c35dsYGRmxWi4d9712I4LG9++WlZVltZzW9Ay/\nRkdHrWJBaDdipKPc3Fwjpt0QoXn77beN2Pj4uPN2te+O6elpq/UFoTVaB6F9BmmN5ba0pm/b88/2\neMwHV6IAAAAcUEQBAAA4oIgCAABwQBEFAADgIBaN5XE3NjYWdQoLVhiNlJls2bJlVssdP37c63a1\nqdZa4+3AwIAR47FQ6cf2BoZMVlFRYcQ6OzutXuv7BqS40ybcB9HW1uZ1ffPBlSgAAAAHFFEAAAAO\nKKIAAAAcUEQBAAA4iEVj+dmzZ61icaI1UvqeAgwEFaeG1SuuuMKIZWebH0Ht7e1G7Le//W1KcoIf\nOTk5UafghfZUjHPnzhkxbcJ4kH0QpxtotH0QRGFhodf1xQ1XogAAABxQRAEAADigiAIAAHBAEQUA\nAOAgFo3lGttJy1oTqm9lZWVWy9FYLpKfn2+13Pj4eIozgYhIf3+/1XLajRITExNec/E9pRjxMTw8\nHHUKKaPd5KS9X3w3ZPtm+/7jiQHzw5UoAAAABxRRAAAADiiiAAAAHFBEAQAAOIhtY3lVVZXVckEa\ny7OysozYzMyMEcuUJugwpgrTWB5/WlOsNjn8zJkzYaRjCONmEcCW9j2hNV8Haa4vKioyYiMjI87r\n0yxaFM01k6g+R8LClSgAAAAHFFEAAAAOKKIAAAAcUEQBAAA4SCRDHk+aSCSYiAoAANLCpeoWrkQB\nAAA4oIgCAABwQBEFAADggCIKAADAQSQTyxOJROjb1JrCSkpKjFhubq4Rm56eNmITExPO29VeG8U+\nEdHzi1MupaWlRmxoaCiSXOK0X4qLi42Y7wnHtrn4PkbaZP2pqakPzCNOx8c2F+3JDLZPTdBiQXK5\n5ZZbrJb70Y9+ZMRmZ2e95uIbuegyJZelS5caMW0KfG9vrxE7d+6cVS5z4UoUAACAA4ooAAAABxRR\nAAAADiiiAAAAHETSWB4Xk5OTRmx4eNjrNqJq0gvDvffea7Xcv/3bvxkx28b8MJrICwoKUr4N3+J0\nXvk+Rhc3kSMcixbZ/Zs6TudeVlaWEcvPz3den/a7fexjH7N67a9+9Ssj1tXV5ZwLdNp5Wl1dbfVa\n7aaVoLgSBQAA4IAiCgAAwAFFFAAAgAOKKAAAAAexbSzXJvlq08Q7Ozudt6E1qGVnm7tEm1huS2t8\nXGjC2Ad5eXlWy9k2tMed7xsgFpLy8nIjpp0//f39Rsz3+dPT0+N1fUG88sorVstpE9WDKCsrM2ID\nAwNWr9WmUmtPorClTaoO40kAtrQnFfBZYN8wbntezQdXogAAABxQRAEAADigiAIAAHBAEQUAAOAg\nkdQ66VK5Qctpt1oDndZE2N3dbbU+7desqakxYloT+ejoqBHTpp1rtGZ4rTnVdr9ozfCzs7NWr9Vo\n+yWqicRBcvHdWJ4p+8W3uOQSJA/fjeVx2Sci6ZmLtu+DNPBr3xNa83Xc94vGd2N5Op4vGtunToyN\njTnlkkgk1PxEuBIFAADghCIKAADAAUUUAACAA4ooAAAAB7FtLPdN+zW1qehak3aQxnLbXOK0X8iF\nXOYSl1x856E1I9tOqo7LPhEhl7mQi45cdDSWAwAApBhFFAAAgAOKKAAAAAcUUQAAAA6yo04gSr29\nvVGnACBkK1assFquq6vLiNk2m9vKysoyYtnZ5sey1tRqe3NLZWWlEdOefKBNaNee4KBNGK+oqLDK\nRWsUDnJvU35+vhG77LLLnNcXhHbcqqurrV7b0NBgxGybqtvb251fmym095FmZmbG+7a5EgUAAOCA\nIgoAAMABRRQAAIADiigAAAAHkUwsD3mTAAAATphYDgAA4BlFFAAAgAOKKAAAAAcUUQAAAA4imVge\nxTRVrSksqqmutrnk5OQ4r8+2eV+bSKzlEsZE2HQ8RmHQcrGddG071VqjbcP2fEm1IMdn9erVVssd\nPXo05bn4puWyePFiI6ZNYw8jlzjtlz/4gz8wYuPj40bs3XffNWLae62wsNCI1dTUGLHf/OY3RixO\n+0X7PcbGxrxuV9uG9jSAOO2XuXAlCgAAwAFFFAAAgAOKKAAAAAcUUQAAAA4iaSyHnampKa/r05r5\nbAVpGA+D1oBYVFRk9drh4WHf6aTc7OysEdOayBsbG63W19bWZsTifsxhJ4wmct+uu+46q+UOHDhg\nxLT3huaNN94wYrafudpnqdaU/s4771itL07y8vKMmO13R09Pj+90Yo8rUQAAAA4oogAAABxQRAEA\nADigiAIAAHBAYzkylm0zZDo2ltsKcjNBprKdRB4G7akEvm8osXXZZZdZLff++++nOJPo5ObmGjGt\n0Xp0dNSIRTVdOwzaTSvafqmurjZig4ODRmw+E8HjjitRAAAADiiiAAAAHFBEAQAAOKCIAgAAcEBj\n+QKSlZUVdQopozUqag2NYdAaLrVmYdvJykEMDQ2lfBu28vPzjZg25Xmhi1OzeVRef/31lG9D26da\nY7lG+7wJ8tSEONE+M7SnF9TW1lqt79y5c4FzijOuRAEAADigiAIAAHBAEQUAAOCAIgoAAMABjeXI\nWFE1LcepCbi9vT3qFGKntLTUiFVUVBixnp4eI+Z7un2czpXu7m4jlslTuDXaZG4tlskWLTKvrWiN\n5cuXL7da33vvvRc4pzjjShQAAIADiigAAAAHgYqomZkZ2bBhg9xxxx0iItLb2ystLS2yevVq2bp1\nq/T393tJEgAAIG4CFVFPPvmkNDc3n/+7+c6dO6WlpUWOHj0qW7ZskZ07d3pJEgAAIG6cG8tPnTol\nP/jBD+Sv//qv5R//8R9FRGT37t2yb98+ERHZvn27bN68mUIqRuI0vTpTaBOObSeWa43vxcXFfhIL\nUXV1tRHTphRPTEwYMdsJ0T6be5ctW2bEysrKjJh2fHw3lmuys+0+lqenp71uN8gEb1vaNHZt+rfW\nyKwtp7Hdf0FoDfcjIyNGzDbnOCkoKDBiWrN5GE9cSAfOV6Ieeugh+drXvnbBzu3u7pa6ujoREamr\nq1Pv9gAAAMgETkXUSy+9JLW1tbJhw4Y5K+1EIrHgbo8FAAALh9N1z/3798vu3bvlBz/4gYyPj8vg\n4KB8/vOfl7q6Ounq6pL6+nrp7Oy0fkAhAABAHLS2tkpra6vVsolkwD/a7tu3T/7+7/9e/vu//1se\nfvhhqaqqkkceeUR27twp/f39Rk9UVFenbJ+6HQZy0aVjLmH0RGm9bHHaLzU1NUZM64nSctZ6ZDQX\n90QFOVfWrl1rxLSeKG1IoNai4Pu8DdITFSSXrKwsI6ad32NjY1br03LR1hdGT5T2/gtyjGxfq+Uc\n98857b2g9TNef/31Vtv4XZ+0Sy5x2S+JRGLO889LB97vftFHH31U7rnnHnnqqaeksbFRnn/+easE\noxKXPETIZS7kootTLmfPno06BRGJ1z4hF12cpn/Hab/EKZeBgYGoUzgvTvtlLoGvRM17g5eo6AAA\nAOLkUnULE8sBAAAcUEQBAAA4oIgCAABwkPrRroqL717y3WxYVFRkxLRJw2F0/ufn5xsx7e4W33fz\n2E4z1v7Ou2nTJiOmjavQ7hrTpkG/8sorRmzlypVG7Cc/+YkRKy8vN2K2U6O1O3w0lZWVRqynp8eI\n2R4j7fzTphnbivNdKyLR5KLl0djYaMS0/a7dOWirqqrKan22+0Sb9q6xzTnI8SktLbVabnBwMOW5\naO/7IM9iDZKLdgepdrdfGLn4lil3lvo2n75trkQBAAA4oIgCAABwQBEFAADggCIKAADAQSSN5ame\nWhukiVdrItQajzXaIyG0R3v4ZttEbuvw4cNG7P333zdits2uWpPoyZMnrV4bxvTc3t5er+sLcv7B\nnfbe1R5hEaSxXHssz0KjPR7G9iYOTVNTkxG79dZbrV77H//xH0bM9rPFVpAm8oVG+6zXBHkPxg1X\nogAAABxQRAEAADigiAIAAHBAEQUAAOAgksbyOMvNzTViJSUlVq89c+aMEZvP5NO40KbETkxMOK8v\nyKThILRp8Zowmv8RDW2qfhC+bxqIU4OtNrFcm0BdUVFhxLQbT8KwatUqI+a7sVyjPcFBo30nZLKF\n+FnKlSgAAAAHFFEAAAAOKKIAAAAcUEQBAAA4oLH8IlpjnG1zajo2kWu0xnJtGrTWuK1NT9cmHDc0\nNDhmh3SVl5dnxAoKCoyY9j4KY3K9jbGxMa/r095XmjCmZmvTprVj1tfX53W7R44cMWLaDT6LFy/2\nul1bWnM9dMPDw1GnEDquRAEAADigiAIAAHBAEQUAAOCAIgoAAMABHXMXmZmZMWLpOIVVmz5sO2VX\no+0XreFydnbWiGmN5YWFhc652Ir7cdMa+LV9tdC4TsefnJw0YraN25pFi8x/Y2qN8JlCu4FGa/DW\nPgt8025a0Y5vb29vynPRaNvlvbswcSUKAADAAUUUAACAA4ooAAAABxRRAAAADmgstxBkWrJts2FR\nUZERGxkZcd6ub0GatLWG0La2tgDZRKOpqcmIac312tTenp4eI3bNNdcYMa2RN1NoDeOuTeRh0G6S\n0GIa7SYO7T00ODhotb4PfehDRsz3uaKdt1pjvvZ+9k373bRm8zCa3LWnMARZDuHQbtzRBH3SCFei\nAAAAHFBEAQAAOKCIAgAAcEARBQAA4CCRDNpVNd8NJhKBG7kAAADCcKm6hStRAAAADiiiAAAAHFBE\nAQAAOKCIAgAAcBDJxHKbSaIrV660Wpc2Cbqvr8+IaU1hthNNfcuUXLZs2WK13K9//Wsjdu7cOa+5\n+GabS0lJiRHTJhePjY1ZbVebgD41NWXEtAn3hYWFRkybiF1cXGzEent7jVhVVZUR046b7THSplBr\nE7FtJvVrx2ft2rVGTMu3v7/fiGn7PS8vz2q72udN3M9bTUFBgRGzPW9tc9Gm9Gu0c1nT3t5uxOrq\n6ozYa6+9ZsTS8Rj5FiSXhoYGI6Z99mmfLdrU+7jvl7lwJQoAAMABRRQAAIADiigAAAAHFFEAAAAO\nImksd5WVlWXEtMZU38rLy62W0xpWkdmGhoa8rk9rzNRoDb+zs7NGTGvg1Bo9NdpNG0GsXr3aiGnN\n5h0dHUasu7v7A9d/8uRJIzY8PGyVm7afRkdHrV4bd1qTtva7BWkit6UdjzNnzhgx289S7fyx/bwG\nRPSbdOaDK1EAAAAOKKIAAAAcUEQBAAA4oIgCAABwENvGctuGXa2Z1rfq6mqr5RZaY/mPf/xjI1ZR\nURFBJguPNlF3fHzceX3aDRq+pwX/9re/NWLalOyF9j5a6LTzTIvNZ4p0plq8eLHVcp2dnSnORL8Z\nQ6M1/9u+VnuSgPaZ4fsGn/ngShQAAIADiigAAAAHFFEAAAAOKKIAAAAcxLaxXJueqzW/zszMpDwX\n2wnPvtlOUh0ZGUlxJva06ciavr4+r9utra21Wk6bjpyOtIZL7b1g24w7NTUVOKcPok3J9jkV3LZZ\nNQjb89tWXl6eESsrKzNi2vR428++OE1et50MrzUjT0xMGDHtM1J7bwRhe4PFQmt8154gEgbf7/Og\n359ciQIAAHBAEQUAAOCAIgoAAMABRRQAAICD2DaWa81jWmN5GKJqLNeaKzVxaizv6OiIOoUFobKy\n0ojZNsB2d3dbLed7Ynmq1dfXGzHb94bWuK01ePtuwC8vLzdi2kRmLb905LsxPwzaeaAZHBw0Yr6f\nqBHGJHJb2k0RmiA5a/tvenraeX2pwJUoAAAABxRRAAAADiiiAAAAHFBEAQAAOIiksfzixkmtUUyb\nhqo1m+fn5xux6urqANmZSktLrZYbGhoyYkGm2Pqe6h2E1uyqTZW31dDQECQdg7bvF5rx8XGv6wty\n7mqN7xqtGbeurs6I2byntWn02j5ZtMju344DAwNWywWhbUObzB3kyQzaDQK+p2vb3vSj3aSj/b62\nDffaZ+Qbb7xhlYst2/NF+87y3VgehpKSEiOmffdqDeO+p4kvWbLEiGnf+dp5oN2MsW7dOiO2ePFi\nx+z+F1eiAAAAHFBEAQAAOKCIAgAAcEARBQAA4CCR9N1h+EEbTCS8NzUCAACkwqXqFq5EAQAAOKCI\nAgAAcEARBQAA4IAiCgAAwEEkE8u1CbqppjWFRZGHSLBctAmuZ8+etXrt1NSUcy7aFGmN7XIHDx50\nzkXT1NTL6yctAAAgAElEQVRkxDo6OoxYcXGxEdMm72bK+eJbkFyWLVtmtVx7e3tK8/DNNpeysjKr\n9QWZlG6bS15entX6tGni2mRubaK6bS62sSDTv21zsT1Hbc+1kydPOufim+0+1Sa0h3EzmO1+0SaM\na9872tMKtCcknD592iqXuXAlCgAAwAFFFAAAgAOKKAAAAAcUUQAAAA4iaSy3UV1dbbXcuXPnvG63\nsbHRiL344otWr3300UeN2A9/+MOgKV1Aa4LTGj2DNGFq+vv7rbZr21jum21z/fDwcIozgYhIQUGB\nEfvoRz9q9drvf//7vtO5wNVXX2213K9//Wuv29UaxsvLy61i2vsvCK1h3JbvJmNtfVE91cLmpgYR\nkeXLl6c4E72pOsh+sX1t3J8okpuba7Vcfn6+EdMay4PiShQAAIADiigAAAAHFFEAAAAOYtsTpQ1F\n1GgDtTK570UbtqnReqeCsO2h0IZohqGnpyeS7SL9NDQ0WC3nuycqU/jut9Ro/SyTk5OR5KLRhmj6\npvX+BOlly2TT09NWy9n2U80HV6IAAAAcUEQBAAA4oIgCAABwQBEFAADgIJEMebKW7dOqS0pKjJg2\n3FFrIteazNLxqe8a343lmbJffCMXXVxyCZJHRUWF1XJ9fX0pz8W3TMlFawDWGsvDyMU321yCDNvU\nvis12ndl3PeL7e9m20Q+Njb2gbkkEok59z1XogAAABxQRAEAADigiAIAAHDgXET19/fL3XffLVdc\ncYU0NzfLa6+9Jr29vdLS0iKrV6+WrVu3en9oJgAAQFw4N5Zv375dbrzxRrnvvvtkenpaRkZG5Ctf\n+YpUV1fLww8/LE888YT09fXJzp07L9xgzJvWwhAkl6KiIiNWVVVl9Vptym6m7BffyEUXJJfGxkar\nmKa1tdVbHr6Riy5ILuXl5VbLDQ0NGbGZmRmvudTV1Rkx7XNY+3wNcpOTbX7a+mxvnujt7XXerm++\nz92cnBwjNjU15ZSL98bygYEB+fnPfy733XefiIhkZ2dLWVmZ7N69W7Zv3y4i/1tkvfDCCy6rBwAA\niD2nIurEiRNSU1Mj9957r2zcuFG++MUvysjIiHR3d5+v2uvq6qS7u9trsgAAAHHh9ADi6elpefPN\nN+Xb3/62XHvttfLggw+qf7aL6rIgAACAi9bWVqOFYC5ORVRDQ4M0NDTItddeKyIid999t+zYsUPq\n6+ulq6tL6uvrpbOzU2pra11WDwAAEInNmzfL5s2bz//8+OOPz7msUxFVX18vy5Ytk6NHj8rq1atl\n7969snbtWlm7dq3s2rVLHnnkEdm1a5fceeedLqufU2VlpdVyWrNcptCmsBYWFkaQSbxoVz3z8/ON\nWHV1tRFrb29PSU640HXXXWfEtAn84+PjRsz2X4XIDLY3HBw7dsyIjYyMeM1F+8zwTZvCbXvDUJBJ\n7ulI+76rqamxem1HR4cR05r/58OpiBIR+da3viWf+9znZHJyUlasWCFPP/20zMzMyD333CNPPfWU\nNDY2yvPPPx8oOQAAgLhyLqKuvvpq+eUvf2nE9+7dGyghAACAdMDEcgAAAAcUUQAAAA6cJ5Y7b/AS\nkz8BAADixPvEcgAAgIWOIgoAAMABRRQAAIADiigAAAAHznOigrh4uvSf/umfGstcf/31RuzgwYNW\n6/+Hf/gHI6Y1hWlTrv/sz/7MiG3cuNGIaVOu//Vf/9WItbW1OeeiKSoqslrOdmpvkFx8IxddOuai\nTdbXaK/VJjWfPn3aKY8wZEouTU1NVssdOXIk5bn4FiSXnJwcI7ZokXn9YWJiwogVFxcbsaGhIedc\nfIv7MSooKDBif/EXf2HEPvrRj1qtb//+/UbsW9/6lhEbHh6eM8+LcSUKAADAAUUUAACAA4ooAAAA\nBxRRAAAADiJpLL/YT3/6UyOmNS9qDd5R0Zpfs7NTvzttG8Z9W7p0qdVyHR0dKc4Ec1m8eLER+9jH\nPmb12qefftprLlrjrYanF0Rj2bJlRuzw4cNWr/3CF75gxL773e8655KVlWUVm5ycdN5GEIWFhVbL\naY3l82lQXkhsm9fHx8dTnEnw71SuRAEAADigiAIAAHBAEQUAAOCAIgoAAMBBIhlyZ2ecpqFquQSZ\nCK5Ntp2amnLOJQy2uZSUlFitT5vG6zuXMKRjLmE0ltvmojUGa2ZmZoyYdq5dfF6l4/GxlZ+fb8Rs\nG2xtc9Eay0+ePGm1DdvG8kw+RkGQi76N2dlZq+Vsv7e1z6DBwUEjpu2Di2OJRGLOm2C4EgUAAOCA\nIgoAAMABRRQAAIADiigAAAAHNJZfpLi42Gp92iRabX02TWtzvTYMtrloTfMarZHedy5hIBddGLl8\n6EMfMmIXv9+6u7tTnoetdGws19h+ftlaaOetLXLRxTkXGssBAAA8o4gCAABwQBEFAADggCIKAADA\nQXbUCcSN1jBuK+QefSDtVVVVGbHa2lojpk02z1S2TeS+aZ9fS5YssXrt6dOnveaSnW1+NWnnika7\n6QBIFa5EAQAAOKCIAgAAcEARBQAA4IAiCgAAwEFsG8uXLVtmtdzo6KgR6+npsXptXl6eEZuYmLB6\nraawsNCIafmlo6KiIqvl+vv7U5xJdLKysqxi69ats1rf7OysETt48OD8E0sTWrOwNpFY2y9nz55N\nSU7pzPc05zVr1hixhoYGq9f6bixfv369EdMmuWtsG8tLSkqMmNZcX1FRYbW+wcFBI2b7pIc40b57\ntRuu+vr6jJj2PaGt79ixY47ZxQ9XogAAABxQRAEAADigiAIAAHBAEQUAAOAgkQx5zHYikWCyNwAA\nSAuXqlu4EgUAAOCAIgoAAMABRRQAAIADiigAAAAHkUwst5m0azshe9Eisw4cGhoyYlpTmJZHQUGB\n1XbHxsasltPY5qJNw9amPmtT1ktLS42YNlHXNpcwkIvONpfc3Fyr9U1OTqY8l1SLSx4i9rls2bLF\nan3Hjx+3Wu799993ziUMQXKxnRKuTc0OksvnPvc5q/X96le/slru0KFDzrloamtrrZY7c+aM1XLp\neL5UV1cbsY9//ONGTJuK/rOf/cw5l7lwJQoAAMABRRQAAIADiigAAAAHFFEAAAAOImksv9iaNWuM\n2BVXXGHEtGavV155xWsus7OzXtcXxMzMjFVMozWRZ4rVq1cbsUceecTqtdpy586dC5zT71u+fLnV\ncidPnvS6Xa1hfP369Vavfeutt7zmAtPBgwetlhsdHU1xJtEpKyszYgMDA0bMtmHct+9///uRbFez\nYsUKI7Zp0yYjpt3ktHv37pTkFAfa+dLW1hZ+Iv+HK1EAAAAOKKIAAAAcUEQBAAA4oIgCAABwEIvG\n8iB6enq8rk+b/h0VbWp7fn6+EdMaC8NoTt22bZvVcj/+8Y+N2MjIiO90IqFNldemxceddl6Nj49H\nkEnm6u/vt1rOdvI8otPc3Gy1nDax3Jb2/tNuGMqUz1JbU1NTRkz7jgkLV6IAAAAcUEQBAAA4oIgC\nAABwQBEFAADgIJHUxoCncoOJRJibO0/7NeOei9ZgWlJSYsS0hlXbyeZB9ovvxvJ0PEYa7Rhp6xse\nHk55LgUFBUZMu3nCdlJ/XI5RXPIQIZe5ZEou2ntoy5YtVq996aWXvObyqU99yuq1x48fN2IHDhzw\nmotvcc4lkUio+YlwJQoAAMAJRRQAAIADiigAAAAHFFEAAAAO0mpiuTZVWWuInZycDCOdlNN+D98T\n2oPYt2+fEauurjZi5eXlRiyTp+wODQ1FncJ52jR7xIf2mZadbX4sa02t6fgeqqioMGJ9fX1et+G7\nGVnb93H6jtHOIYSHK1EAAAAOKKIAAAAcUEQBAAA4oIgCAABwENvG8ubmZiOWk5NjxLTG2aNHj1pt\no6qqyogNDAxYvXZ6etpquUzW1NRkxG6//Xar1/7N3/yN73RiQ2uk16bKLzSVlZVWy/X29qY4k2ho\n58WGDRusXtvR0WHEbD/n4k5rBNc+6zVag3deXl7gnH7f+Pi4EXv33Xe9bsOWdh5o++rgwYNet6tt\nY2pqynl9UU0iTwWuRAEAADigiAIAAHBAEQUAAOCAIgoAAMBBIqmNY03lBhMJdQIsAABA3FyqbuFK\nFAAAgAOKKAAAAAcUUQAAAA4oogAAABxEMrHcZlppdraZmu3Eco3WFGY7NXXlypVGTJs+fOLECSPW\n09PjNZcgcnNzjdjExEQkuWii2i+aTMll/fr1VstpE5i191Zc9ktc8hAJlkt+fr4R0yZBz8zMeM2l\noKDAan1ZWVlWyw0PDzvnom3jox/9qNV2z5w5Y8Teeecdr7kUFRUZMe27SHvahfZki3Q8dxsbG63W\n19DQYLXcK6+8YpWLdjy02kCbXF9WVmbEbJ9IMp+b37gSBQAA4IAiCgAAwAFFFAAAgAOKKAAAAAeR\nNJb7pDVLa01mQTQ3NxuxZcuWGbHx8XEjpjWWR8X3fgFgT/usWrFihdVrDx06ZMSCPPnBtuFZu7nA\ndxN0TU2NEWtqarJ6bV9fn9dctEZ/ral/cHDQ63ZtlZSUWC03NDTkdbttbW1Wy2lN30HMzs4asbq6\nOqvXFhYWGjGt2fzkyZPzT+z3cCUKAADAAUUUAACAA4ooAAAABxRRAAAADmLbWK41PmqxONGa4OJE\na2xdaLTGTN9NmHHy1ltvGTGtmXnJkiVG7L333ktJTguVdmNHb2+v1WuDNJFrFi0y//0cZCq6b8eP\nHzdixcXFKd8udIsXLzZiWpO29h2tHcsgtO8x7WYH7QkimqDN8FyJAgAAcEARBQAA4IAiCgAAwIFz\nEbVjxw5Zu3atXHnllfLZz35WJiYmpLe3V1paWmT16tWydetW6e/v95krAABAbCSSDl2CbW1tcvPN\nN8vhw4clLy9PPvWpT8ltt90m77zzjlRXV8vDDz8sTzzxhPT19cnOnTsv3KDnabe2tF8zTrlojZ6+\nGzi1hryJiQkjFqf9Qi7+c1m3bp3Vcm+//XbKc3EVlzxEyGUunLe6TMmlqKjIiI2MjKQ8F227Gp+5\nJBKJOb+Pna5ElZaWSk5OjoyOjsr09LSMjo7KkiVLZPfu3bJ9+3YREdm+fbu88MILLqsHAACIPaci\nqrKyUr785S/L8uXLZcmSJVJeXi4tLS3S3d19/rk2dXV10t3d7TVZAACAuHAakPDee+/JN77xDWlr\na5OysjL54z/+Y/ne9753wTKJRCKyS5QAAAAuWltbpbW11WpZpyLqwIEDcsMNN0hVVZWIiHzyk5+U\nX/ziF1JfXy9dXV1SX18vnZ2dUltb67J6AACASGzevFk2b958/ufHH398zmWdiqimpib5u7/7Oxkb\nG5P8/HzZu3evXHfddVJUVCS7du2SRx55RHbt2iV33nmny+rTQkFBgdVyY2NjVstpV+18N5ZrE5N9\na2xstFqura3N63YX2iTyIE6fPh11CsAlrVy50oiVlpZGkAnmEqRxO5M4FVFXX321fOELX5BNmzbJ\nokWLZOPGjfInf/InMjQ0JPfcc4889dRT0tjYKM8//7zvfAEAAGLBacRBoA2m4a2cmiBXorRcsrKy\njFgYz+LzvV+CXIkKkovvK1GZchuyprKy0mo57blucdkvcclDhFzmEiQX7UqUbXvI/v37vebiG7no\nFtSIAwAAgIWOIgoAAMCBU08U/AvjT3eZYsmSJUZMazo9evSoEcuU/aztg4qKCiOmXdLW/pSq/RlW\n20YQ2sR8jesNEL4nKAdRVlZmxPLz842Ydsy0Pxv09PRYxWxpT0jQjs/4+LjzNoJYsWKFEdNyHhgY\nCCMdxIjvP+cF/fMlV6IAAAAcUEQBAAA4oIgCAABwQBEFAADgIJI5USFvEgAAwAlzogAAADyjiAIA\nAHBAEQUAAOCAIgoAAMBBJBPLXSeElpeXGzFtou7U1JQRm56e9pZHUOn40Mcw2OaiTS6+6qqrjNjw\n8LARO378uHMuvh8SrU2I1qZ12+6X4uJiq+1qv4dmcHDQiGm/r+35cuedd1ot97Of/cyIXfww5HQ8\nb7Oz7T5utc+qILlo0/xtPzc12nmmncvaRPW4H6MwBMklyAPefefim20uy5YtM2JVVVVG7Ny5c0ZM\ne6j66OioVS5z4UoUAACAA4ooAAAABxRRAAAADiiiAAAAHETSWH4xrVFY09/fn+JMRPLy8pxfOzEx\n4TGTeNEa/LSGVc3AwIDXXHJycozY8uXLrV5r21iuCdJErtGayIOoqKgwYl/60pesXvuXf/mXXnMJ\norCw0IhpDaGppn0uBTkHtIbxpqYmq9ceOXLEebtDQ0POr9VoN2xkspUrV1otF+SzxdaSJUuslrNt\nLE9HXV1dRizKp6BwJQoAAMABRRQAAIADiigAAAAHFFEAAAAOYtFY7rthNwhtmrMW890UHHda4542\n0ToMWgP/2NhYBJnES1lZmRG75pprIshE98ILLxix/Px8I6ZN045ClM2qiI8wGsZt7d+/P+oUIqdN\n1j99+rTVa1PxnuZKFAAAgAOKKAAAAAcUUQAAAA4oogAAABwkkiF3T2qTr8Og/ZrkQi5zyZRcPvzh\nDxuxmZkZI3bgwIGU5+JTXPIQyZxcfDf5Z8p+8Y1cdLa5ZGfb3Q+n3bCmbcMmlkgk5mxK50oUAACA\nA4ooAAAABxRRAAAADiiiAAAAHKR9Y3leXp4R0yZap2MDXRgyJZfi4mIjpjUWjo6OpjwX38glvnmI\nZE4u2k0IJSUlRkybDn3o0CGvudDkHo50zKW8vNxqff39/d5yobEcAADAM4ooAAAABxRRAAAADiii\nAAAAHNiN/vTs4mYxrWFr06ZNVusaHh42YkeOHHFLDGlLa0TVaM2pWgN6psjJyTFiU1NTEWSSerY3\nmdiqrKwMkk5s2J4D9fX1RmzJkiVGTJt4rzWWBzE9Pe11femotLTUarmhoSEjpp27Id9DljJBGsZT\ngStRAAAADiiiAAAAHFBEAQAAOKCIAgAAcBDJxPJMaXADAACZjYnlAAAAnlFEAQAAOKCIAgAAcEAR\nBQAA4CAWE8ubmpqsXtfb22u1nDaNV3vtxXmERWtQs81l69atVsu9/PLLKc/FtyC5ZGVlWS2nTVv2\nnYtvmZzLQw89ZLXc17/+dac8cnNzrdZfUVFhxLRz6vTp00YsyD65/vrrrZZ79dVXrZazzaWkpMRq\nfdo0bFtB9stHPvIRq+WOHTtmxM6cOeM1F9+C5KJNkM/ONr/GBwYGrGJB3kcbN240Yl1dXVYx7ckR\nvo9RcXGxVUzLbz43v3ElCgAAwAFFFAAAgAOKKAAAAAcUUQAAAA4iaSy/WF9fnxG77bbbrF77n//5\nn0ZMa6DLFAcOHIg6hfM+8YlPWC33X//1XynOZOHRGi5tmyGXLl1qtVxHR8e8coqjyclJq+VuuOEG\nq+U4l4MpLS01YoODgxFkkp60GxvKyspSvt2WlhYj9pWvfMXqtX/1V39lxH70ox8553LVVVcZsbq6\nOiM2OztrxH75y186b3cuXIkCAABwQBEFAADggCIKAADAAUUUAACAg1g0lnd3dzu/NpObyDW2U9vD\noE3KjYrtJHLEy8WTyH2znXisTVAOw2uvvRbJduczkTkK+/fvt1oujN9j3bp1Vsu9/fbbKc5EF/fv\nwIKCAq/rKywsNGK2x+iNN97wmosIV6IAAACcUEQBAAA4oIgCAABwQBEFAADgIJEMucPQttHTN+3X\nJBdymQu56OKSi20etrkF+RgMsk+ysrKslrO9ccI2F9tm37GxMavlguSiKS8vN2Ja87/tDQFBcvHd\nWB6X95BIsPPlgQceMGLazUY//elPjdjrr7/unIs2nfzyyy83Ytq58dZbbxkxzcW5JBKJOT8juBIF\nAADggCIKAADAAUUUAACAA4ooAAAABzSWR4BcdOSiI5do8qioqDBifX19keRiK4xc6uvrjVhXV5fX\nXDZu3Gi13OHDh42Y1gy/0I6RrSC55ObmGjGtwVvz7rvves3FNxrLAQAAUowiCgAAwAFFFAAAgAOK\nKAAAAAfmeNEQ5OTkXPCz1qCmGRkZSUU6saBNLradUoxwaOfp5ORkBJmILFpk/vtndnbW6rV5eXlG\nLD8/34gNDAzMP7H/43sits8GU+131aYbFxUVGTGtsTyTaU3ksFdZWel1fdr7IOR7wy5J+44eHBx0\nXl+Q3zfIZ+R8cCUKAADAAUUUAACAA4ooAAAABxRRAAAADiKZWB6nRjgAAIC5MLEcAADAM4ooAAAA\nBxRRAAAADiiiAAAAHEQysbywsPCCn22nFgehNYX5nII8H+Sis81l48aNVus7duyY1XJDQ0POudgq\nKSmJTS5BpuPb5qJNC9amN587d85qu655aLRJ5BrbJyQEyeX++++3Wu6pp55KeS7aJHvNxMREynPx\nLUgupaWlRkybfD08POw1F+09tHjxYqttdHR0eM0lO9ssFRoaGoxYV1eXEdOeBhAklzDM5+Y3rkQB\nAAA4oIgCAABwQBEFAADggCIKAADAQSSN5RfLycmxWm5qairFmei0Bj+N1mwI/44fP261nNboGdW0\nfK1hPCq2TeRB+H4v2H5GpJuCgoKoU0BMae8h24Zx32pqaiLZbjrgShQAAIADiigAAAAHlyyi7rvv\nPqmrq5Mrr7zyfKy3t1daWlpk9erVsnXrVunv7z//33bs2CGrVq2SpqYmefnll1OXNQAAQMQuWUTd\ne++9smfPngtiO3fulJaWFjl69Khs2bJFdu7cKSIihw4dkueee04OHToke/bskQceeIAeIQAAkLEu\n2Vj+R3/0R9LW1nZBbPfu3bJv3z4REdm+fbts3rxZdu7cKS+++KJ85jOfkZycHGlsbJSVK1fK66+/\nLtdff72x3osnlMe9aZRi0H5Srjax1ncz9+DgoNVy2mRuTZBGa+3cveuuu6xe++///u9ec4k71+nk\nIn7fg7aTyMNge5OEdp75vtHGdhL5QmP7eRMn2vT5IMe3r6/Pajnb6eSZZN49Ud3d3VJXVyciInV1\nddLd3S0iIqdPn75gDHxDQ0NkdxIAAACkWqDG8kQiccln20T13BsAAIBUm/ecqLq6Ounq6pL6+nrp\n7OyU2tpaERFZunSptLe3n1/u1KlTsnTpUn+ZAgAApFhra6u0trZaLTvvK1Hbtm2TXbt2iYjIrl27\n5M477zwff/bZZ2VyclJOnDghx44dk+uuu26+qwcAAIjM5s2b5bHHHjv/v0u55JWoz3zmM7Jv3z45\nd+6cLFu2TP72b/9WHn30UbnnnnvkqaeeksbGRnn++edFRKS5uVnuueceaW5uluzsbPnOd75j/ee8\nIA2SUTWlFxUVGTGt+fXiJvp01dvba7VcVBPBNWHcEBDk/Lv88suN2HvvvRcknYyVqQ33F9/9LEIb\nBILzfZOA9tSO5uZmI6Z95mqfaQMDA34Si4FEMuRvPd8fELZfYpOTk15zCVJEabs8qg9O21y0uz00\nQd68vveL7Wu17drmUlhYaMS2bdtmtd0DBw4YMe0DRzuv4n6+LJQ8RNLzvA0DuejSMRftc853ERXn\n/ZJIJOa8QMDEcgAAAAcUUQAAAA4oogAAABzMe8TBQrRy5UojVlVVZcS0qa5Hjx71msv69euNWE1N\njRHTesB+N2neRTpOM46qyb28vNyILV++3Ihp59B3vvOdlOSE9BGnmzOAuZSUlBix3NxcI6Z9d2RS\nYzlXogAAABxQRAEAADigiAIAAHBAEQUAAOAgksby4uLiC37WBlLaTigOMu3c1sX5zmVkZCTFmYhU\nV1cbsbKyMiN29uxZ521oA86CNLv6Xl+cjI6Oel1fpuyXKGjvU+0GCy0GfXCxFhsfHzditk8H0D4L\nbAcX277XbD+vYU9rIl+7dq0Rq6ystHrtO++84yexGOBKFAAAgAOKKAAAAAcUUQAAAA4oogAAABwk\nkiF3sl7qacgAAABxcqm6hStRAAAADiiiAAAAHFBEAQAAOKCIAgAAcBDJxHJtam2qaU1hWh7l5eVW\n6+vv7095LraWLl1qtVxHR0fKcwlCy2XRIrPOz8rKct6Gtj5tgnXc90vcc9EmF2t6e3tTmsfGjRuN\nmDbhf2BgwGq7b775pnMuGt/7SctFe7/YThi3lZeXZ8S0yebafqmvr7faxoc+9CGr5fbv32/E0vE9\nVFBQYLU+7YkfQXLRtqs9GUR7eoaWy+DgoHMucTpGc+FKFAAAgAOKKAAAAAcUUQAAAA4oogAAABxE\n0lgeZ1qTMUSuuuoqI/alL33JiJ07d86IPfLII87b1Rr8pqenrV6bnR3N6V1RUWHE+vr6Ur7dyy67\nzGo520bPIDnffPPNVst1dXVZLffKK6845aE1gmvWrFnjtP65aDcw+G7mzsnJsVquoaHBiJ08eTKS\nXDS2Tf3pKMhNMEEaxoPQbgiw/T2CnAdB3HjjjVbL7du3z/u2uRIFAADggCIKAADAAUUUAACAA4oo\nAAAABzSWX2R0dDTqFOZNm0QelaiauVesWGHEtCbHI0eOpDyXMJrI425mZibqFObl3XffjWS7rhPb\nReY3VTnOioqKjFhVVZURO3XqlBHz3SDvW7q9D+ai/R7d3d0RZBI/XIkCAABwQBEFAADggCIKAADA\nAUUUAACAg0Qy5O7ERCIR5ubO035NcgmWS15enhHTGhBtJ4wHyaWmpsaI5ebmGjHbJvx0PEbV1dVW\n69OmyvvOpbGx0Wp9/f39RkybsP3+++9f8LM2dT3uxycMWi5ak3aQhvYguWj7JT8/34iVl5cbMW2C\nt+20c9/HyPYGGu2zL+7nC7mYuSQSiTlv5OBKFAAAgAOKKAAAAAcUUQAAAA4oogAAABwwsRzOJiYm\nok7hvLNnz0adAn5PW1ubEdOahZcsWWLEtEbozs5OL3ktRGE0kQcxPj5uxLq6uiLIxJ72NASN7U01\nSF9ciQIAAHBAEQUAAOCAIgoAAMABRRQAAICDWDSWL1pk1nJZWVlGbGpqKox0gLQUZBJ5ENr0Zq2h\ndqLs8QcAAAYuSURBVHJy0mp92k0CPT09H/g6rdnX9jMjyGs19fX1Rmx2dtaInTlzxmp92jR67ekA\nmoKCAiOmTf8OQrtpIAjtaQO254+t2tpaI2Z7PGz3X2Vl5bxy+iBFRUVGTNsvfFeGhytRAAAADiii\nAAAAHFBEAQAAOKCIAgAAcJBIJpPJUDeYSEjImwQAAHByqbol0itRra2tUW4eF+F4xAfHIl44HvHC\n8YiPhX4sKKJwHscjPjgW8cLxiBeOR3ws9GNBTxQAAIADiigAAAAHoTeWb968Wfbt2xfmJgEAAJzc\neOONc/7ZMvQiCgAAIBPw5zwAAAAHFFEAAAAOKKIAAAAcRFJE7dmzR5qammTVqlXyxBNPRJHCgtbe\n3i433XSTrF27VtatWyff/OY3RUSkt7dXWlpaZPXq1bJ161bp7++PONOFY2ZmRjZs2CB33HGHiHAs\notTf3y933323XHHFFdLc3CyvvfYaxyNCO3bskLVr18qVV14pn/3sZ2ViYoLjEaL77rtP6urq5Mor\nrzwfu9T+37Fjh6xatUqamprk5ZdfjiLlUIVeRM3MzMif//mfy549e+TQoUPyzDPPyOHDh8NOY0HL\nycmRr3/96/LOO+/Iq6++Kv/0T/8khw8flp07d0pLS4scPXpUtmzZIjt37ow61QXjySeflObmZkkk\nEiIiHIsIfelLX5LbbrtNDh8+LAcPHpSmpiaOR0Ta2trkn//5n+XNN9+U3/zmNzIzMyPPPvssxyNE\n9957r+zZs+eC2Fz7/9ChQ/Lcc8/JoUOHZM+ePfLAAw/I7OxsFGmHJxmy/fv3J2+55ZbzP+/YsSO5\nY8eOsNPA7/n4xz+e/NGPfpRcs2ZNsqurK5lMJpOdnZ3JNWvWRJzZwtDe3p7csmVL8ic/+Uny9ttv\nTyaTSY5FRPr7+5OXX365Eed4RKOnpye5evXqZG9vb3Jqaip5++23J19++WWOR8hOnDiRXLdu3fmf\n59r/X/3qV5M7d+48v9wtt9yS/MUvfhFusiEL/UpUR0eHLFu27PzPDQ0N0tHREXYa+D9tbW3yq1/9\nSj784Q9Ld3e31NXViYhIXV2ddHd3R5zdwvDQQw/J1772NVm06P+/HTkW0Thx4oTU1NTIvffeKxs3\nbpQvfvGLMjIywvGISGVlpXz5y1+W5cuXy5IlS6S8vFxaWlo4HhGba/+fPn1aGhoazi+3EL7fQy+i\nfvfnCkRveHhY7rrrLnnyySelpKTkgv+WSCQ4ViF46aWXpLa2VjZs2DDnU8I5FuGZnp6WN998Ux54\n4AF58803paioyPhTEccjPO+995584xvfkLa2Njl9+rQMDw/L9773vQuW4XhE64P2f6Yfm9CLqKVL\nl0p7e/v5n9vb2y+oXBGOqakpueuuu+Tzn/+83HnnnSLyv/+i6OrqEhGRzs5Oqa2tjTLFBWH//v2y\ne/duufzyy+Uzn/mM/OQnP5HPf/7zHIuINDQ0SENDg1x77bUiInL33XfLm2++KfX19RyPCBw4cEBu\nuOEGqaqqkuzsbPnkJz8pv/jFLzgeEZvr8+ni7/dTp07J0qVLI8kxLKEXUZs2bZJjx45JW1ubTE5O\nynPPPSfbtm0LO40FLZlMyv333y/Nzc3y4IMPno9v27ZNdu3aJSIiu3btOl9cIXW++tWvSnt7u5w4\ncUKeffZZufnmm+W73/0uxyIi9fX1smzZMjl69KiIiOzdu1fWrl0rd9xxB8cjAk1NTfLqq6/K2NiY\nJJNJ2bt3rzQ3N3M8IjbX59O2bdvk2WeflcnJSTlx4oQcO3ZMrrvuuihTTb0oGrF+8IMfJFevXp1c\nsWJF8qtf/WoUKSxoP//5z5OJRCJ59dVXJ9evX59cv3598oc//GGyp6cnuWXLluSqVauSLS0tyb6+\nvqhTXVBaW1uTd9xxRzKZTHIsIvTWW28lN23alLzqqquSn/jEJ5L9/f0cjwg98cQTyebm5uS6deuS\nX/jCF5KTk5McjxB9+tOfTi5evDiZk5OTbGhoSP7Lv/zLJff/V77yleSKFSuSa9asSe7ZsyfCzMPB\ns/MAAAAcMLEcAADAAUUUAACAA4ooAAAABxRRAAAADiiiAAAAHFBEAQAAOKCIAgAAcPD/ADWWZox7\nIqDoAAAAAElFTkSuQmCC\n", - "text": [ - "" - ] - } - ], - "prompt_number": 15 - }, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['conv4'].data[0]\n", + "vis_square(feat, padval=0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The fifth layer output, `conv5` (rectified, all 256 channels)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3XuM3Gd1//HPEN/vXtu7vqzjTeI4xiShoSFQCUpTCBVS\n", + "GwUh0oYKIqBV1UoBmnJJ3RYGihRTFaFfC0H8gUQqJEjUKoR/QCFVSJXQYG5pEjuO7ZD1Zb273ptv\n", + "sZM4iX9/ROeZM/HXOzPPfG8z835JKF+eXe88Ozvzne/3nPOcp3Lu3LlzAgAAQMveUPQEAAAAOhUX\n", + "UgAAAJG4kAIAAIjEhRQAAEAkLqQAAAAicSEFAAAQKZMLqR//+MfaunWrLr/8cn3lK1/J4iEAAAAK\n", + "V0m7j9Qrr7yiK664Qg8++KA2bNigt771rfre976nN77xjWk+DAAAQOFSj0jt3LlTmzdv1tDQkObO\n", + "nas/+7M/0/3335/2wwAAABQu9QupkZERbdy4Mfz/wcFBjYyMpP0wAAAAhZuT9g+sVCqpfA8AAEAZ\n", + "bNq0ScPDw4lfS/1CasOGDTp06FD4/4cOHdLg4GDT/37hwoXh+MyZM6nOzVSr1cTjIjCXZMwlGXNJ\n", + "Zo9f1Dzmzp0bjv/hH/4h1bnYjWdMOWvRz4vHXJK1OpeLLrooHL/66quSpEWLFoWxBQsWSJKmp6fD\n", + "2GyvHft+Sbrjjjtamssb3vCGMJ+zZ8829W+aVaa/0bve9S49/PDDF/x66qm9a6+9Vvv27dPw8LBe\n", + "eukl3XPPPbrxxhub/vdnzpwJ/wOATnD27Nnwv7SdO3cu6iIK3emVV14J/7PXxgsvvBD+Z+xrjV47\n", + "L7/8cvhfq1599dXMXvdlcv3118/69dQjUnPmzNHXv/51/dEf/ZFeeeUVffzjH2fFHgAA6EqpX0hJ\n", + "0vve9z69733vy+JHw/FpUDt+5ZVXwphF9V566aV8J4bgd3/3d8OxhcCffPLJMEbkFZ3kDW94LYlh\n", + "KaW8XHzxxZJUt5DJoi/PPfdcGPPprF7iz/tTU1Mt/duYSBTq0dkcAAAgUiYRKeTDFxhatGPZsmVh\n", + "bN68eZKkiYmJfCeGRHbn5wuTiUihrJKK3POORJnLLrtMkvSmN70pjFnkxUdgejUihWIRkQIAAIjE\n", + "hRQAAECknkrtzZnTHb+uFXz6IvKTJ08WNR3M4vHHHw/HviC0V1kKetOmTWFsyZIlkqSZmZkw5nvR\n", + "oRhLly6VVF8uYOceXy6QR3r6V7/61XmPa8Xmo6OjmT8+MBsiUgAAAJG6I0TTpG6JSFmxsu9Ie+rU\n", + "KUlx3Y/T4OeyevVqSdLzzz8fxny0oZcQhao3f/58SbXXiCT19fVJkk6fPl3InJDsxIkTkuo7adu5\n", + "xyJTec/lqaeeyvVxMTu/4CmpBY9lSrr9PEhECgAAIBIXUgAAAJG6I9fVJL8PUSezULulSaRaQejx\n", + "48cLmZMP9Vt6sQypVEtF+P43RYeZN2/eHI7tOdqzZ09R08mV9dLyCyWOHTsmSRofHy9kTphdr6bl\n", + "G/E7S9j7uNcW/fi079DQkKRaql6S9u3bJ0k6cOBAGOvGfSOJSAEAAEQqPmSAltlyY7/suOho24sv\n", + "vhiOJycnJZVjDydbWu8L34uKSK1bt06StHXr1jBm8zpy5EgYs8LabmSRKLtTler/NkXyEVSLYFp3\n", + "b6n4SCbKxb82LDvgF0z0wuvFPwf2GeDbUdhxN0ahPCJSAAAAkbiQAgAAiNRTqT3bxLfTWZjUF5YX\n", + "nUbzYewyhbSLLpT1xZiW2vOLBGyTVZ8a7QVlSedJtV44K1euDGM2v6SeOOgefpFMqxsy+zSelVYU\n", + "talzUfznjm0e7UsTeuW8RkQKAAAgEhGpDlZ0FAqN+SJL27vMF2jaXW2v3Lk1y56jPIpU7W+wfPny\n", + "Qh4fxUkrgtRrkShz9uzZcGzvGX9+Mz4K343nOiJSAAAAkbiQAgAAiNRTqT3b2BfIS1JHdV+MyWsy\n", + "WREpNd//ppP5BQ5Alnxqz3rE+QUatuOGL6shtQcAAICgpyJSncyWaEu1wj2/15NFOfyycrszXbx4\n", + "cRizOwj/b1etWpXBjPF6hw8fPm/M70HVq+y1aPsiSt3d3T1r/nkEsuRfa0l7wNpni/8+2/mimxCR\n", + "AgAAiMSFFAAAQCRSeyXS398vSVq9enUYsx43fX19Ycy68fpCZkv9+W7nVsi8YMGCMGab+PqOvlYQ\n", + "iGwNDw8XPYXCWdh/zZo1YWzTpk2S6gvMLbXni/Ht+fOvV1KA5yt6A/Nu5HsjWb8x/3q1rve91k/K\n", + "Py/22bJ27dowZs+V7wLfjYhIAQAARKqcK2CdcaVSUbVazfthAQAAWlatVi/YloWIFAAAQCQupAAA\n", + "ACIVVmxeZGrPP3bRKUbmkqysc/na174mqb6oPw2+G7XvDGysM/D27dsT51UE//j//M//LCl57nnO\n", + "pejnxM8hZi5pb5Zcxufly1/+chgrauP1Mj4vzKWezWHHjh1hLKuFFL5o3i/OMp/73Odm/fdEpAAA\n", + "ACLR/gCz8l1qbWmvb51gXal9RMW+fubMmfO+b86c2ksuaW+zpLuBMsnqDrpRJMf2sSqroiJR3Wbp\n", + "0qWSurutQ1FRKHSmRuc+++xp5xzk9wK0n+OjVI0QkQIAAIjEhRQAAEAkUnuY1Ysvvjjr161zrXVl\n", + "92M+dWdpvpmZmVl/Xtm7MvtNoTuN75i/YsUKSfUbiB47diz3OV1IGuH6TtTo/Qb0GuuYLiWnvC0t\n", + "50tJWuXTePYebKXMhIgUAABApI6ISPniZitWLnvxba+wInKLcEi1O4jx8fEwZlf5Z8+ezXF26bPX\n", + "XycWzPo52/HixYvDmEUDi4oK+rvCuXPnSiIiBfQ6v5DJFmPY+UGqnTdiIlJJi6Xs5/mFVo0QkQIA\n", + "AIjEhRQAAECkjkjtWf8iqZZa8WE3S0V0etqoE42MjEiqLyK30GhS928LpUq1UKxP3fp+HmXUiSk9\n", + "44vJkwrLW+mb0i4fmreiTp/G868JAL3Ln6uSOv773oStsvO5/7l23EqanbMVAABApI6ISPkrTrtT\n", + "LcMyeYuKWQGcVJufj9B0c6TMruib7cTsl5RaRCop4oj8pbW/WzP8eyLp/cHr4Hw+itfN5xS0zkeT\n", + "83wf56HR79NOlmC29xERKQAAgBxwIQUAABCp1PFzKzxev359GLN00KlTpwqZ08DAQDheuXKlpPrU\n", + "lPVOIvSerFERcdopWytub6frba+wtGsZ0uadXNSfFZ/uzOP8Yue3VatWhbGxsTFJxZ1/kcy/NmzR\n", + "hv9cwuz882fPWysLn4hIAQAARCp1RCrpirpMnX8tyjE9PR3GTp48WdR0OkKjvfbSjkSUKRK1aNEi\n", + "SdLp06cLnkltoYTvSG93ZdbSoldYJ/6yR1nyjnLbudbvUFD256hX+c7c3RbNTdrxwO9sYpGjdnY7\n", + "Seqe3koLFiJSAAAAkbiQAgAAiFTq1J6FKH04uehNTH2YO42QYq/p5QLIMqUZ165dK6m+0/zzzz9f\n", + "1HQuyBd8ZvU+65T3b94pmzKkoNEc/7nYbX2k/Dkqq9SeTx/az2vls4qIFAAAQKRSR6SMLwSzpbg+\n", + "SlXUFbgtF/f7/tldXNGRM5SDL1i0wm6/ICHPAmL/PrLXrI9ylGmhhN0h5hGFKWNEyu8AkNSWIs8W\n", + "FX5peLcVMrcjaXl8Ua+lbm634xfEGH+uSmOPUP/zLDLvI2GNEJECAACIxIUUAABApI5I7fmiR0vj\n", + "laGgzsLcfjNRUnrwfNh58eLFkupTJZOTk5LyKcL3r017T/kC+DKl9sr0Pi9CUWm8JKTzkpUxJdyN\n", + "jh07Fo6TFkCkfd6yc3Erf18iUgAAAJE6IiLlrzjLdNfM8uDes3z5ckn1dyuztTXwhZIWnfIF6M1G\n", + "oqz7dlpsz7SYaIMvhI61Zs2acGwROh+9s4LP48ePt/1YADpXURHZVgr4iUgBAABE4kIKAAAgUmGp\n", + "vTlz5tSlCCxVYgW5Uq1Phy82S9q02P6N/3lTU1PnfV8rfSGkuBSM8T17LHXh5+5/zzKyOeddaLpp\n", + "06ZcH69VlnJq9nlJSvvFFKkmbRZrr3cfgraC8ka9f5qdv70H/OvfNvVs9H1J7N/aBs5SraeVf16a\n", + "TeEnzQVAe3xvxKTP3Dx1wm4YRKQAAAAiVc4VsL64UqmoWq3m/bAAAAAtq1arF2zHQkQKAAAgEhdS\n", + "AAAAkQorNr/vvvvqOi1bUa4vzh0fH5ckLVu2LIxZMbLvLTExMSGpvijNioJ9Abr1qfnbv/3bMFZ0\n", + "itE/fpnmsmPHDkn1naWtQNgX+NpzfuLEiTCWVExt/8YX/NvfKKkw+rbbbkucVxH843/zm9+UVN9D\n", + "zIq90+p3Ys/HwMBAGBsdHZUkff7zn0+cVxHK+Noteh5+DsylHnNJxlySpTEXv+ir2V1H7DPKX4s0\n", + "mgMRKQAAgEiFRaRefPHFukiE3eHbnbc3MzOTePx6/urTP07SMWaXFF2x52+2v0ErP68TWZQ0SxaV\n", + "GxkZyfyxAKBbxex9O9tOFRdCRAoAACASF1IAAACRCkvtHT58uC7dk0YH7aQwXkxoD81bv369pFrh\n", + "uMRGs2XV398fjm2BRgFt5ICWrV27VpK0YcOGMGbd7/fu3VvInABDRAoAACBSYRGppL3D0HlsqWhS\n", + "tMPvAXf06NF8J4ZgxYoVkqQ3v/nNYcwWZuzfvz+M+WOgTGwvx7lz54axvr4+SdLy5cvDGNFwSLVz\n", + "nn9t2GdQo2Jy2+O3lT1RiUgBAABE4kIKAAAgUmGpPWTDh759ai0rBw8elJTc7dx3/0brrBO/1F5R\n", + "+LFjxyRJ//d//xfGLLU3NjYW/XOBvFjvOv+esPNMHuc5dBZbyGZpOqmWHm7EUsatnBuJSAEAAEQq\n", + "LCI1d+5c7iTa5Du5r169WlLyHnBZsjtE/1jWsb6VYj2cL+3WBBaZkvjblF3MHmHdzAqE/aIVPj96\n", + "l9+zdcmSJZJqi5ykWkTK72bS7Pl08eLFLc+HiBQAAEAkLqQAAAAiUWzewXxhuaVt8t6Y2cKqK1eu\n", + "DGMWcj9x4kQYIz1RPEv/SrXi3ZgNOpGdBQsWSKpPXdh7my70pPNeb/PmzZLq39tPP/20pO7uqeU/\n", + "+6yUJEnMe8bvuNIsIlIAAACRCotIcWfRvpgr56z4uwKLivmlp3lGPnw3Wyuq9sXV7UTHrLi+E6MD\n", + "fj/E+fPnS6pfEuy/jmIkLdu2u28WCOD17H1s+w5K3R2JMv76wbfESIN/LptFRAoAACASF1IAAACR\n", + "KDZHWywM6ov/LLXn0195psQs3C3VUiVpFbtbf5+XX345lZ+XJ78QYWBgQFL938O+3om/W7fxCzVQ\n", + "k1Rk7EscOjHl3o5du3YVPYVC+FKRVatWpfqzY1LoRKQAAAAiEZFCW6zo79SpU2Fs0aJFkoq7U7Q9\n", + "uKRal1r/+O0U7XbyHa8vLLeC/DItWAAa8a9hi07RwqO3pR29pf0BAABAjriQAgAAiERqD6nwvTys\n", + "K3NRIXffD8mKqtPqkdQtHdotHO77sVBkjrLzmzlb2t5v1M5ruPeUYWEGESkAAIBIRKSQCr83mEVt\n", + "/J1innwk7NChQ3VzKivfsiGpM3waXa393+PgwYNt/zx0N4v4lKnjvY84WVEwUSgUjYgUAABAJC6k\n", + "AAAAIpHay5EvlPS9jtLk00GWzsoyrbVkyRJJ9f2VxsfHz/s+3//FZPUceGn/7lZU759n+938xs2m\n", + "0QaY9vxZGsX/m/7+/jA2PT193r+1fl0xKdQ8nvtOYX8/npN6WaX0/Hmw2fenvT8WLFgQxlr9e/n0\n", + "OTpHUtmD18550Lqi+95Rdo5vpZ8UESkAAIBIlXMFtGquVCqqVqt5PywAAEDLqtXqBXe2ICIFAAAQ\n", + "iQspAACASIUVmxeZ2vOPXdQ8rMD185//fPRcGhXhtaoMz0vS4991112SpGPHjoWxNPoqJfFF5LYp\n", + "6mc+85kw9uUvf1lSfcFsGs99s8r6NyrLXIqeh59DmeZir1vPv9atYNd3ibb+TCtXrgxjVoDbqBDd\n", + "3jv+HPXpT3+6bk5FKuPfqExz+frXvx7GrKg/acFLHnNp9nnxu2usWLFCkjQzM5PqXC6EiBQAAEAk\n", + "2h8UJI2l1nlGQoo0OTkpKZ/l6T7SlRT1srt0uim3J+2u7Zhd0uvVj822dHxqaqrlx7M9HP1ejugc\n", + "p06dCsettAEoki8EX7ZsmSRpw4YNYcyirT5K1ag9TbOISAEAAETiQgoAACASqb0WWSdUqVb8XPYN\n", + "cTsdnae7hxWBXn311WHsueeek1SfQrKNpwtocwf0vCzTebYQIcu0r23KvmnTpjBmnyNZ/G5EpAAA\n", + "ACKVOiJle5f5fciOHz9e1HQkxRVeoj1EJbqHtY3wxc32/vbLl+2OEigD/9q85JJLJNXv+zc2Niap\n", + "vRYBZVqA4X/ftM+/1hIjy4iUzXl4eDizx/CISAEAAETiQgoAACBSqVN71lF33bp1YcxCniMjI2Es\n", + "rV4QKCeK+dNn4fW8e5FZapwUOTqJFUhLtS7wPrXX19cnqT5l3WpRc9JiGitv8fLoYefTjGmfIxp1\n", + "xe9ERKQAAAAilToiNTExUfdfz98NAGhs+fLl4XjNmjWS6vcvtA7yAOr54m+LNCVFi/zegq1GpBp1\n", + "n89Tlgt8unHxEBEpAACASFxIAQAARCp1am82RW2kaIWGUq0Ij2JodALr4STVCluLCrNbca5U6w3H\n", + "+6j7+FRXt7BSE592s67Z/vOh6J6H7chjs+klS5aEY79JciciIgUAABCprYjU0NCQli1bposuukhz\n", + "587Vzp07NT09rT/90z/VgQMHNDQ0pHvvvTfsr9UN/F2IFRtyJ41O4KO44+Pjkopbirx69epw3N/f\n", + "L6m+oNdamiQtNEH5WbsA3zagW5w4cUKStHTp0jBmkSj/+9rnQ1EF4+3IMlJtz5FfMNbTEalKpaKf\n", + "/vSn+s1vfqOdO3dKknbs2KEbbrhBe/fu1bvf/W7t2LEjlYkCAACUTdupvddfuf7whz/UrbfeKkm6\n", + "9dZb9YMf/KDdhwAAACiltlJ7lUpF73nPe3TRRRfpr/7qr/SXf/mXGh8f18DAgCRpYGAgpBC6kS/e\n", + "BcrOF5AmdVHOk08zbty4UVJ9X55Dhw5JIrXXqey1lkfRct4seDAzMxPGrKO5T093YkovD5baswL9\n", + "btDWhdSjjz6qdevWaWJiQjfccIO2bt1a9/VKpVK3izQAAEA3aetCyvbAW7Nmjd7//vdr586dGhgY\n", + "0NjYmNauXavR0dFQSJoWiwIVVeC9cOHCcGwFhv6uqxvvwGL5Ow67i+vGrradyLqc+yJP+9vk8Rr2\n", + "j+GXQSd9HSgjvwedBQzOnDlT1HQ6Tiftt/nQQw/N+vXo2Nrp06fDyprnn39eDzzwgK666irdeOON\n", + "uvvuuyVJd999t2666abYhwAAACjU9ddfP+vXoyNS4+Pjev/73y/ptVzwn//5n+u9732vrr32Wt18\n", + "88369re/HdofAAAAdKPoC6lLLrlEjz/++HnjfX19evDBB9ua1OutXLkyHFsaYHR0NIzlWdTniwkt\n", + "deWLZElJ1PiCZusZUlRHeiQXm/vXbp7pcv9Ylg6x/jySNDY2lttcgBj+NWzHndRT0NKRixcvzvVx\n", + "rTC/m3RP2TwAAEDOOmKvPd9B1vboOnbsWBizWq08+Lt6u/vwUapO4Tvw5hFFIyJVTn5vMItS+SLa\n", + "rKxfvz4c2wIO/55mUQLKzn8u2SKodorNfWQojx0HbM7d1IagKDyDAAAAkbiQAgAAiNQRqb2DBw+G\n", + "Y+t4nFbov9W+VN3SrTbvovhO35SyG/jmuBbO9ynePAtlh4eHw/Hhw4cl1ad9u+V9hu7lF0ekIe9z\n", + "sr3H0v49ehERKQAAgEiVcwVUdVYqFVWr1bwfFgAAoGXVavWCmTAiUgAAAJG4kAIAAIhUWLF5kak9\n", + "/9j/+q//Kqm+F5SF73yfECvM8z127N/4Il4r3vUhwKQ+U/PmzZMkbd++PXFeRfCPX8a5+M1t8yxe\n", + "L+vzcuedd0rKp+9To7l89atflZS8CXI7mu13ZnMp+u/j58Bc6jGXZMwlWRnnciFEpAAAACJ1RPuD\n", + "LM0W2Zienm7qZ/g772ajA+zJ1zof+UNxkagkWe0u0GvvkxUrVkiq7/JelFZbwwBl4z8zslxXR0QK\n", + "AAAgEhdSAAAAkXo+tWcdnm3D1rywKWvr8tycuhPYJqd5bHCKfFg6zVJ8Ui215tOceWz+feWVV0qS\n", + "1q5dG8asC/3TTz8dxvI+dwLN8puj2/nSl+xMTk6m8jhEpAAAACL1fERqzpzXnoKkFgVZ6rbC6fnz\n", + "54fj/v5+SdLo6GgYY++09HXbawi1InMfsS4q4mORMIvaS7X3ea+99vzvu2XLFknSpZdeGsYsQvjE\n", + "E0+EsampqZxmh9eztin+c92ivb6lSlqISAEAAETiQgoAACBSz6f28k7pmW4rNt+6dWs4fstb3iJJ\n", + "evLJJ8OYHZep91ESH/a1tG9Z5dndHfkoU8+mvXv3SpIOHDgQxmx+ZZpnEkvjSNKCBQskSWfOnIn+\n", + "ef58PTExIUkaGBgIY5Z+zSJthOb4FLSVl6xevTqMWdr8+PHj6T926j8RAACgR5T7ljvBqlWrJNX2\n", + "qpPqi5pRjH379oVjuxv00Sd/h1hmfok5y7rRyyxan3fUfvny5ZLaixzYUneptmdqWucgWz7/2GOP\n", + "hTFrV0GUuDj+fJ0UIbSFEllEU4lIAQAAROJCCgAAIFLHpfYsXZRWIbCF/nzY13qC+MdIuw9S2QuZ\n", + "W3X69Olw/Otf/7rAmdT3fLEUcEyRe9kLapEOey8uWbIkjFkawG8eXPaFEt0ija7tJ06cCMf2Pk47\n", + "Rel/3tGjR1P92c2y1ywpxXpjY2OS6t+/7Sw2aISIFAAAQKSOC4vYlXdaV+AWsVi4cGEYszsYWzYr\n", + "pb/Pm1+qmcbPoDC6xkekiCKgEYs2+6hz0oIJ5CPt57yb96IkEpXM2lVkGYXyiEgBAABE4kIKAAAg\n", + "Usel9tJmKTGfGrOUmS9AtxRgWgWLafwc0nnJeF4Qw6dJum3nAQDZISIFAAAQqecjUlaM5qMYVuyY\n", + "1CkVQPdLu90JgO5FRAoAACASF1IAAACRej61Z5J6l/gNbAEAAF6PiBQAAEAkIlIAoNr+ev44787m\n", + "1nqFxS3pW7x4ca6PZ3s4+lYatrfrihUrcp1Lr/ItjLLcO5WIFAAAQCQupAAAACKR2gPQ02zD8vXr\n", + "14cx6yPl0wF5bH5rKT2fkkhKEbW6M0JfX184np6ellTbrUGSli1bJkk6duxYGGu1l5ZPjVoazT+G\n", + "8ZuKZ9VB3m84v3TpUkn1z0Eekp4/ez2NjY2d9zWfely5cqWk+tecvU79a+PkyZOS6v9us8njuS+T\n", + "LNN5HhEpAACASJVzBVyWVioVVavVvB8WAACgZdVq9YJRPCJSAAAAkbiQAgAAiFRYsXmRqT3/2EWn\n", + "GGPmYr1IkjqvW2GqVCsmbFRwZ8WL//RP/9TyXLLS6X+jrDCXZPb4Rc/Dz6FMc/nGN74Rxl544QVJ\n", + "tULlvOdSpufl+9//fhiz3k72/Ei1Iu4jR46EMSv0t+JvqXbe9X3H7Dy9ZMmSMLZmzRpJ0pkzZ8LY\n", + "hz/84bo5Fcnm8JWvfCWM+blmbdGiReH4s5/9bN2citRoDkSkAAAAItH+oAPNtgdgq0uWpfa6KFs0\n", + "K69lpqiZrQu2X3be6lL5Rvzy625gy+PzjtDkyf/NLFIC6fDhw+F4z549Lf3bRpEae9/5FgYTExOS\n", + "yt+5vqjzedrnqrwQkQIAAIjEhRQAAEAkUntoq8MtKb3izJYeyDJE3m1/c+sivW7dujC2d+/eoqaT\n", + "iaRO2pBOnTqV2c9OSr2XPaVnikqx2XPWaTpz1gAAACVARAodexcApMGWuNvyd5SP7UPnl8dbEffp\n", + "06cLmVMSPz8r6j9+/HhR04nm9030LR1eb9WqVeHYiu/b+Xv49j2dhE9QAACASFxIAQAAROrMOBpS\n", + "tWDBgqKnkJlKpSKpvqDeOg1nWWhaRr6X0MaNGyXVd3Hu1YLkEydO1P0X5WNp1w0bNoQxS+09/fTT\n", + "YazVYm7fU2u2/nzN8mkwO/d4SeejMvJd22dL7fmi9DRSrGV/Xi6EiBQAAEAkIlLoakl3OFYQ2msR\n", + "KV/Iac9Bt7UyQHqWLVsmqb5Lvr1nfCQzDyMjI3WPL9UiSO20FGg2AuLfOxbFSups7t9PZSqCb1Wz\n", + "7Q8a7QZgETgf+ZvtZ+e5r1+aiEgBAABE4kIKAAAgEqk9pFJk2Ul6tajY94axkHyvFpiXlaVAyvCe\n", + "tAJvXzRddOol7Z5MzW7y7nvtWZrPjyWlF5PShp1STB2TlrSeUv71YqnOmZmZdCZWUkSkAAAAIhGR\n", + "Qt2y+F6QZ6Fssx2C82DLxaXio3K+5UbehctlZnfwaS/Lj2HRH19A7V9DvcQXSNvz0Sn75uXF2sr4\n", + "iFS3R6IMESkAAIBIXEgBAABEIrWHujQC0uXTeVacWlRKgJ5R5WevjTKkjTpxs908NPs+sl5tvijd\n", + "is2LLtpvxJd7NPv7WuG+T9v3StkIESkAAIBIRKRQirvfXsDzXEN0rHP4CIO9hpvtfN3LLBLViTso\n", + "+Chas+9Va5fR398fxiwCNz09neLsyoeIFAAAQCQupAAAACKR2kPP9oZBcZrtKJ0n26RXklauXClJ\n", + "mpqaCmOdmKJJg+9j5Tcwxux67fVi/aN8CUOvpICJSAEAAEQiIgUgNc0umy7jnmMbN24Mx8uXL5dU\n", + "33W91yIMxv8dy75sH+nwxebNGh4eliQdOnQojPVKCw0iUgAAAJG4kAIAAIhEag/IgBXl+k2LrWg3\n", + "ZpNe2xC07KxIW5ImJyejf449f3kWq46NjYXj0dFRSeXqfzNnTu10XVSxvhUUt5Oa9WkjSwX7gnb7\n", + "PX1KMY1UsH/+suI37C1j+rpZ/rxlfwf/97DdMPzva+/VXikw94hIAQAARKqcK+CyuVKpqFqt5v2w\n", + "AAAALatWqxeMMhKRAgAAiMSFFAAAQKTCis2LTO35x85zHr7Y0Y7vuOOOVOfSTkGqf/zvfOc7kuqL\n", + "Dq3g2W+JEOp0AAAgAElEQVRK+ctf/lKSNDExEcbe8Y53SKrvy/PII49IkmZmZs77eZdddlkYsyLj\n", + "d73rXefNy3r7SMn9SaxwNa0Ncfv6+iRJn/jEJ86bS1GKeu0mKeNcip6Hn0M7c7FiXqn2eo7Z9Lrb\n", + "npe0MJdkzCVZozkQkQIAAIhUWETq9Xs2ZbVkcvHixeH4xRdfzOQxmuUjRFktX07r59py5AULFoQx\n", + "uzP2S5V9JMr87//+ryRp165dYcxHooxFmPzdd9LPM4265KYViTJpLH33rz/2NMyej4LaOcW/Luwc\n", + "cPLkyVQez6KqaXc9X7RoUTi2SFRac0Z77Hzlz4PobUSkAAAAInEhBQAAEKmw1F5e3U9Jp8QZGRm5\n", + "4NdWr14967+1VEpSOs+zv43f5NIfdwNef/nyXbOt54sv0k47HWOLMdJO7SUVm+fNyi98ev/EiROF\n", + "zGXFihWSpGPHjhXy+B4pvdaVoSt/lohIAQAARGKvPSSaraCyUdF3sywq6e8yu/FuBfnxkRzbB8za\n", + "Yki1KFXMfodJrNg8rZ9n2tmnMC2z7Z3mI38xbRmacemll4bjbdu2Sarfv25qakqStHfv3jBWpr0R\n", + "UWMRRakcr+20EZECAACIxIUUAABAJFJ7TbKUge8LZIWmvgDzzJkz+U4sI/b7+kJXC+GnVWx5+vTp\n", + "88Z8USLQKt8rzl5fPrWXdgrOFhP0Wkra0qZS+jsKGN9rcNWqVZJquw1I0tjYmCTpyJEjYYzUXjml\n", + "/b4rGyJSAAAAkbj9b5LdHS1dujSMWUTKF2PalbcviuxEdnfp99qzu/20i0v9nacvYgVa5aNPFjXx\n", + "kZK0I0cWne21iJRvgWLPQdrRIN+C5dlnn5WU3H7BR6kOHjyY6hyaZZkKH1FPa1FON0i7PUjZ8KkF\n", + "AAAQiQspAACASKT2mmQpO19Mbik9X+Da6Sk9Y+kQH6peuHChpPr0WxobqfrnLI+uwdapudsLIHuR\n", + "f71aWtq/ptLecNZSekV1H8/D4OBgOLbn179ns+oj5c8tu3fvliStX78+jG3YsEFSrRBdqpVe5L3B\n", + "sz0vvhTCjv3nA7oTESkAAIBIRKSaZHecvgu33YlldUdWpKSib7v79i0g7E7MF9smjc3G38XlsTdd\n", + "N0cPOkVSUbh/HdhrqNWCXR8psWM/lnZ7jawi0H6e9vzkvcebnQN8V2r7G/l9NPOIwluRuT/3LFu2\n", + "TFL9YpVFixZJyj8iZcXU/m9kkW8iUt2PiBQAAEAkLqQAAAAikdprkU/j+e6+3cZSC/53tOJ6C1n7\n", + "7/NpvFZTev39/WEsjzRp3ikSnM+nV+114Dccjl0I4Hu6WbrFp57Sfs9m1T/Kz7Oo16u9F32azNJo\n", + "/u+XtKlx2uycs3LlyvPm59OMefYr8ulXex343Rp8qhrdjYgUAABAJCJSLfJ3ikuWLJFUf/fcKYWF\n", + "vmgzac52h5VUvOvvkJOKd5stNreCYysQleoLW9Eb7PWXxnvHRzST9trzr/tYfiGGFTxPTk62/XO9\n", + "MkVN/QIQHxEyeUSk7G/oo+EW8fHPfR6LVZrVKZ8FaB8RKQAAgEhcSAEAAEQitdciX2TZiZtSWirC\n", + "F3gn9VzxvVmMpRv8c5DUk8lSH/5nJIX/bWx4eHjWn9cLkoqgfUqq1zbFjeWfM3sd+iJ2687fDp8+\n", + "7MYecq/nzw9WzJ20w0OW7Lzgzw/29y1qNwnekzBEpAAAACIRkSqIv3M2rXYEj2Edgv1detJdtY0l\n", + "Fb02KqJs9g7Vfs+jR4829f1lYpE9qba/ly/EtTv3AwcOhLHZ7pyvvvrqcGw/x0f0ylREW2b+tWfH\n", + "SWNpmZ6evuDXkpbHp23t2rXhOKlDfBpsUY1Uew3781ceUTl7T/iIohWepxFlRO/w0f+0oplEpAAA\n", + "ACJxIQUAABCJ1F5BkoqqLSSfZWrPwuA+xZEU3vQdelFz6aWXSqpPu1kfsaTndNWqVWEsaWNT66Hl\n", + "U0S2iMH3K0p7s91uNTU1NevX8yiMNn19feHYNjv37zV7L1q6PYbvwWbp+rS7t/vntNHzm5WkDeIn\n", + "JiYkSYcOHSpkTuhMWSxOICIFAAAQqXKugLWjlUpF1Wo174cFAABoWbVavWA0i4gUAABAJC6kAAAA\n", + "IhVWwVpkas8/dtEpRuaSrBPnYv2kpNqCAd8Buh1WbP6P//iPYexf/uVfJNUXT1rhuy90tuJ1v4jB\n", + "fp7vhzVbTyTPCuhvu+22MFaWv9E3v/nNMGbzHB0dDWNWkD0zMxPGrPjfLyCw58c/t9a3yP9b4zfb\n", + "/tSnPlU3pyLZHMo0l+985zthLGlRhr0O/Y4Httn0Nddcc973+WJz63nl/5YDAwOSpP3794exT3zi\n", + "E3VzKlIZ/0bMpV6jOTSMSH3sYx/TwMCArrrqqjA2PT2tG264QVu2bNF73/vesCJFku68805dfvnl\n", + "2rp1qx544IH4mQMAAJRcw4jURz/6Ud122236yEc+EsZ27NihG264QZ/97Gf1la98RTt27NCOHTu0\n", + "e/du3XPPPdq9e7dGRkb0nve8R3v37q1bxh3Dd+8dGxs77+vWZbdX92krA/837oX9x5Ik7VmYlqSW\n", + "GBZ98uwO3y+BT3r/2c9rNgrlFbUEvhn+ps6en2b3xGzUAX226KJ/3G5h7RnSiqqagwcPhmM7V/gd\n", + "AJJYZ/9HHnlk1u+zFiM+kmg7McS81oFmNLzCeec731m39YUk/fCHP9Stt94qSbr11lv1gx/8QJJ0\n", + "//3365ZbbtHcuXM1NDSkzZs3a+fOnRlMGwAAoHhRoaLx8fGQdx4YGND4+Lgk6ciRIxocHAzfNzg4\n", + "qJGRkRSmCQAAUD5tF5tXKpVZO+mm0WXXb5q5efNmSfWpDgvdJxWBIh9btmwJxxs2bJBU/zfatWuX\n", + "JGlycjLfiXUxS18k9TaxFIeUbzfvGFYY7DfSjt2k2W+o3Whzbcwu7ZReHuzzxr8n2PA7HxZE8ed9\n", + "K3fwuzmU/XwUIyoiNTAwEGqVRkdH1d/fL+m1D1C/guLw4cPhQxUAAKDTPPTQQ7N+PSoideONN+ru\n", + "u+/W5z73Od1999266aabwviHPvQh3X777RoZGdG+fft03XXXxTxEHX93bdEp25dOqr+TRTF8CteW\n", + "ifu7QiJR+UoqRC8TKw2QpDVr1kiqX7JurycrG2iWj17780avswU5UvGLclavXh2OrQA8rf1FbWGF\n", + "X/BiLT6ITGXLnnMfcerkhUe22EKSrr/+ej388MMX/N6GF1K33HKLHn74YU1OTmrjxo360pe+pDvu\n", + "uEM333yzvv3tb2toaEj33nuvJGnbtm26+eabtW3bNs2ZM0d33XVX6htoAgAAlEXDC6nvfe97ieMP\n", + "Pvhg4vj27du1ffv29mYFAADQAQrrbN4KH963wnIfdmu3T1UrfBrRuu36otZOLNBMg++h9Pjjjxc4\n", + "k95RwH7jqZmYmAjH9trx7+k0+jLRX67Gl0KcPn26wJnUd4G31I9P7VlqKGae9lng08SWSiS1ly2r\n", + "m+7kdJ7XynUFe+0BAABE6oiI1KJFi8KxFZP6O5g87zj93mTWqNS3XejViBS6k0Vgfa2jX8ocy9+1\n", + "WuQhjUiJjw4TiaopOgrl+b+L/b3868uiZ/5c2mz0NWlpvS28KNNz0I1skZFf6GLvc/va67+eBtvj\n", + "NO2dJVpZAEFECgAAIBIXUgAAAJE6IrXnQ8EW7vVh3zRSDc3yYUnrgcJmmI0lpUFRfnm+t9JAu5Xy\n", + "8+k3S7f5c/ycOa99LKW1mMJ62HVjR+2+vj5J9YsJRkdHC5mLlQH4Xm72OZ3W39JeG0mLE9LWys4I\n", + "RKQAAAAidUREykeB7ErUd+q1q/E89tbyS2hZTjs73yrCFgzkHZGyFhX+rqXToixoXrcsvU5Spu7k\n", + "7fDRiaTfI60u58Y/b93GPhvLkBWxYm9/3rfnPo12JhdShj01iUgBAABE4kIKAAAgUkek9jwrNrOU\n", + "jVQLD5chxJcVX0xoz0HZU4s+heY3Nc6aPT9S7XXiUz7dltrzv6+lRXzRdSd3QG9VnrscSLWUddoF\n", + "r/79vnz5cknS1NRUqo9RFP96TeJ/d9Pqud0Wt0jSxo0bJaX//JXhPVam3lh2jvWpvbRT0GVN3ROR\n", + "AgAAiNRxESkrrvN3LWW9Sk2Tv/uxfaTKHpEqir8LskhBN0Yrbemzf/1bUad9TapFAPyela3qlLYC\n", + "a9euDcf2/vCRCLtb9jsU2F19o10JLDLk33f2b9N+fvx+dLYHYbdEpPxOFUnSOJ/7n2H7s6YdHfG/\n", + "h30udfIigLT4z+a0o/9l/awnIgUAABCJCykAAIBIHZfaMxaulTon7dAO30sr7U0fu40v/LSUXllD\n", + "wu2wlN3Ro0fP+5pPA1lKqh2dUrDun4ukNIulGvzz02yBuj/nvF7az49/LHsNd0vaqFHPozTSQf75\n", + "m+3v1g5fVG2fQb74uxvPOc04cOBAOO6U80a7iEgBAABE6tiIlI9CLViwQFLjYtGsWDGoVIsW9cqV\n", + "eNqSlj63o6jXRB5OnDjR1PdldUdeRjHR2jJGDnw7hU6ORPmojRkbGytgJunzkUzr4O27qJfxdZWH\n", + "Tv/ss0h/K5F8IlIAAACRuJACAACIVFhqb+HChXWbU9pxUpdm65vkv+5Te3a8Zs2aMGa9XnxYfOnS\n", + "panNX6r1ovEh3E4PazbDpzLTSJ35LvW+IzFm1ymLDvzf1N6r/n1p79WkzWr9+3z9+vWS6nssNeqS\n", + "3an8OSWNFFFRXbjT6iNkPZv8Z4Gde4rqEVeGjYKz4j8r7b3qC+kthenff3n8HQYHB88bs9KemZmZ\n", + "MNZszzUrJbn88svD2Lp16yS1tnk2ESkAAIBIlXMFhFAqlYqq1WreDwsAANCyarV6wWguESkAAIBI\n", + "XEgBAABEKqxSs8jUnn/solOMnT4XK/70fW+KmovZunVrOB4eHpaUXJhtRYWSNDo6mslc0sZcktnj\n", + "Fz0PP4dm52LFslL6CwjaeV6skLiVotus5pK2Vufie0al3R+q6OfFL0T4whe+IEn64he/GMaKWkBV\n", + "9PPiNZoDESkAAIBI3bl2uEfYcnBJOnLkyHlft67C/g4q7S7JtrTd37Uk7f1mc02aZ9oOHjwYjpPu\n", + "Hu0OLK2l2UA7fDd/W0JeVBTAz6XZyIsthU/73JLU4qaobuEbNmwIx6dOnZJUv9zerF69OhxPTk5m\n", + "P7EUJL3WOrGNj88wWEuVZnd/aBcRKQAAgEhEpDpYo+iORVz8nV3ajh07Jql+jylrntfX1xfG7DiP\n", + "iJRvGGq1W76Ga8mSJZLqG8yhOBs3bpRUey1J0smTJ4uaTu7KtBdiTFPFrKIX/ucWHSE5dOjQrF+3\n", + "c4qd+6RaRoDIdz78Of7SSy+VVIseSrWaPx+lSuvziIgUAABAJC6kAAAAIpHaa5It8//ABz4Qxqyw\n", + "0Idu77vvPknS+Ph4jrObXZZh8dlSAX7Z9OHDhzObw+v5ItCk4lR7PvySZuTL75e3efNmSbUCUUna\n", + "uXNn7nNCnKIKwMvEUkg+leTLHZA9n1a1c7ylXKXa3ohZLALgkwQAACBSR0SkknZ79wVjaTeDTGLL\n", + "932zx5tuuklS/RXugQMHJEk/+tGPMp9TEn8XlPZy5Fbl8XdJ0ugO2d81Il+2EODiiy8OY/beevbZ\n", + "ZwuZkxW7+8URtnt8npFUz5/zLOp75syZQuaCOFm1gyi68L6sfIbBFqv4KJWde3yLj7Q+o4hIAQAA\n", + "ROJCCgAAIFJHpPY8Kx6zFJ+UXOiXNuuW/ZOf/CSMWW8R/7hJXb3zYKkA30Nptv3jgCJYempiYiKM\n", + "2cIM30cqT5YOHxwcDGPWA6io1J7fcy+tve46me1H6FMxvVbkbgueYnp99QL/OWwLV/xCMNuFY9Wq\n", + "VWEsrX51RKQAAAAidUREyheWWwGfL6pOe8f0JHb388gjj4Qxf1wEv6+T3a2UqUsycCE+Wlp05HR4\n", + "eFhS/XvHt2IoQh7ntE5i599ei0J5RS3e6RQ+op1U6G+LwrJ4bxORAgAAiMSFFAAAQKSOSO35cG4v\n", + "bWbaiC9CteeFQkQgju+Ij3IhrUX/qEaa7duVRT82IlIAAACROiIihWT+ytq63gIAkKRMO190EyJS\n", + "AAAAkbiQAgAAiERqr4P5wnLbiNH6SUm1MC6bnaJTWUdrid5KKAfreu8X+9iOEqdPny5kTo3Y54Pf\n", + "xJfFFekhIgUAABCJiFSXsL0HbT8hSXrDG167Tvado/3eQ0BRhoaGwrHd2dt+kVKta7/tZylJzz77\n", + "bD6TQ+ksW7ZMUu2cJtWiP75oOo8Caov09/X1hbHFixdLqu3JKmW3R6JfWNRsSwSL7CbtR2sRtm5n\n", + "v2cWn4FEpAAAACJxIQUAABCJ1F6XsNSeL861MTriomwuu+yycLxq1SpJ0vr168OYFZaPjY3lOzGU\n", + "kpUs+NIF283Bv0by2Gx66dKlkuo3jTdZpfOkWkpvzZo1Ycx+30a/t6VEk9JaS5YsSWuKhfKF9JZ2\n", + "9alg+xz0pS5p/b2ISAEAAETqioiUXX1OT08XPJPi+CtvY/tTZXmXVHZ2F+ejcrZU2d9R+qJmZG/v\n", + "3r3h2O6wfaGuLc1+5pln8p0YSskiLr6VixWb5xGF8iYmJiTVF2mnsRdgo67jdg47evRoGLP3jj//\n", + "21zsPCfN/hx1SxsEH22b7TnI4vOQiBQAAEAkLqQAAAAiVc4VUIlcqVRUrVbzflgAAICWVavVCy7c\n", + "IiIFAAAQqbBi82YiUn/8x38sqb64bufOned9n3VJ9stgZ9uXyz920ZGxtOaSVFRd1FzSwFySdfpc\n", + "rCVH2gWf9vhFPyd+DsylXjfPxfay8/ufzsa3HPj0pz+d6lza0Sl/ozz24LRu9ZL0mc98ZtbvJSIF\n", + "AAAQiQspAACASKXuI7Vx40ZJ0gc/+MEwtm7dOknSvn37wtjv/d7vSarvBfTAAw+kOpfrrrtOknTi\n", + "xIkwtmfPnlQfox3W1dWnTJoNMwN56eWeZuherZ5rkzYPRvOS0nlbt24Nx9dcc40k6dixY2HM+n9Z\n", + "/zGpthF60t+vlf5kRKQAAAAilToi9dBDD0mqj/xY1MkXm61YsUKS9OSTT2Y2l7e+9a2SpLe85S3n\n", + "zeWnP/1pGBseHpYkjY+PhzHfjTcreXf3BWLMmzdPUuNO0Fa8a/vwSdKRI0eymxjOY4t4/Lm2TFH4\n", + "ovnO5kl72CEfy5YtkyT9yZ/8SRj7/d//fUn1i69effVVSdJjjz0Wxu6++25J9fvvxSAiBQAAEIkL\n", + "KQAAgEilTu1ZGLlRODmPcLMVqp08eTKMWdrBNo6UpMOHD0uq70GRR2ovT5aekWq/uz0/UjobeCI9\n", + "y5cvlyRdcsklYcw2Od2/f38Y8wspspK0uXYSK/6kOD1f/lxmvXPe/e53h7Hdu3dLkr7xjW+Esf/+\n", + "7//OZC5+E187LtO5xRb4SNLx48cLnElvs7KWycnJMLZr1y5J9SlXe237MhhfjN4OIlIAAACRSh2R\n", + "alYed6333XefJOnee+9t6vt9IWK38c+3RTHKdKeIenbn/MY3vjGMWQGxX4adR0Sq1aLcbovmlp0v\n", + "LB8cHJQkXXHFFWHMopt2PszSK6+8knhcFkSh0tPOzhz22vjOd74Txmyxiu2kINWimv48l9ZWw0Sk\n", + "AAAAInEhBQAAEKkrUnt5aDUl0c19Rawfh5TdhpFIj/VI+cUvfhHGLEWTdwq61RSN70Lcqyzdlsd7\n", + "ze8O8Z//+Z+S6vvkWao1qwJz9KY0Umz+Z+T9uURECgAAIBIRqSZZOwM6iNfr5shbt/GtDjqFj34i\n", + "X9/97nclpVeQC3QrIlIAAACRuJACAACIRGqvSdbnIub7uzk0br05ytjnBZ3PiuKlWgFpry1wKOr3\n", + "7ebzFpAmIlIAAACRiEg1yXeAbkav3M3Z3mlEpJCFvr6+cGzvwV6LSAEoNyJSAAAAkbiQAgAAiERq\n", + "D0Bp9ff3h2PSx+W0cOFCSWwwjd5FRAoAACASESm0hc7TyMKqVask1b++JiYmipoOXmf9+vXh+KWX\n", + "XpKUT0RqzpzaR9bLL78sSRoYGAhjk5OTkoheIl9EpAAAACJxIQUAABCpI1J7c+fODccLFiyQVN/X\n", + "ad68eZKkF198Md+JQUuXLpVU3zfr+PHjRU2nY9nzKEknT56UVOvRJXVfCjUpRePZzgAnTpwIY6dP\n", + "n85+YgjsXLtp06YwZilXKzCXpEcffTTzuSxZskSStHXr1vPm542Pj0c/hv28Rn3K7LW5aNGi877W\n", + "7Kb29vugOxCRAgAAiNQREamzZ8+G47Vr10qqvxuwO9qYiNT8+fOj/+1s/Py6+U7aCk17pdt0s3sL\n", + "WpTUL9+346To0szMTDi2iFS3RaG8pCiUZ0XDre4o0MssUpLWrgr2nn7mmWfCmJ0v/V6iebz37XVw\n", + "6NChMLZy5UpJ9e+ddljmw38WLF68WFL9Z5BFk/w53p5zH2k1vgjfzpdJ0bQy8Vkg+8z178VWn3N7\n", + "HiVp48aNkqS9e/eGMXs9deoiASJSAAAAkbiQAgAAiFQ5V8DuupVKRdVqNe+HBQAAaFm1Wr1g2pyI\n", + "FAAAQKTCis2LjEj5x252Hs0WGecxl6wwl2SdPhcrfLdC1yLnkhV7/KLn4efQ7FyGhobCsRVuj42N\n", + "nfd9vgDYFz+nOZcspTEXKzCXaot4YhYKNTuXwcFBSdK73vWuMHbgwAFJ0iOPPBLGrH2JFVJL0u7d\n", + "u1OdSx46eS6+oN0K5J999tlU53IhRKQAAAAicSEFAAAQqSP6SDUrqTt0Wiw9ksfGnI1YmtH3LJkt\n", + "vL1s2bJw7DtFozc0mwZCvtasWSNJuuyyy8KYnbd8bybrV+RTe5Ze6jVp9Yxqlu3SsGvXrjCWlHa1\n", + "NOP09HQ+E8N5fLf9P/iDP5AkLV++PIz9+te/zuyxiUgBAABE6riIlBWU+aJv65KcdhTKK0Mkytjv\n", + "3mzhO1Go3lZAhxM0YWJiQpL0xBNPhDHr6O7/Zvb+9XfcyId9pjz++OOzfp+di5OiVVlK6rJ+9OjR\n", + "XOdQFn6P1+HhYUn57WlIRAoAACASF1IAAACRSp3a6+vrk1TrCSHVeuGsXr06jO3bt0+SNDU1ldlc\n", + "strcGOlZsWKFJOl973tfGBsYGJAk7dy5M4w99thjkvLZFPgNb6jdq3TzJsRonS0W8SUJSWlYe908\n", + "//zz+UwsY7ZYRurcTWqL5BcnXHvttZLqS09sk2m/2XQv8ItqrMdXXp/XRKQAAAAilToiZcuDt2zZ\n", + "Esbsjs0XlmUZiTJEosqvv79fUn0E88orr5RUey1J0t69eyXVCnuz5OeSFIHIczm377q8atUqSdKR\n", + "I0fCWK8WqRbFFslUKpWmvt93bu7k6JQvAD516pQkIlOt8K0xbCGCfz34Nhm9Ku/PayJSAAAAkbiQ\n", + "AgAAiFTq1J5tOOjDdBbe/u1vf1vInMrAnoMFCxaEMUsX+W7n1m03Dz5tZP1uDh8+nOtcLGVnixSk\n", + "Wl8XX3iZR0rPCmr938h6vfi0dJ58l19LK/n+MzZXnzpA9prtPN/J6TzP/76k9Fo3MjISjo8dOyap\n", + "/j3rU8DIBxEpAACASKWOSNlds3UpxWvsjs5HO+zOztpD5M3fBdniAL9M93/+538k5XNXbe0NXn+c\n", + "J/t7WPdqqbZQwgps82YRXqkW5aUlA/KWZ6Q8L7Z4w9qtSLV997Lsdm6fkb7AvEy7cPQKIlIAAACR\n", + "uJACAACIVOrUHpJZ+i6P/lnNOnDgQDi2AmafNioq5Vi0LDfSbhUhfyA9fhPpwcFBSfWLbmzhT5ap\n", + "PXvclStXhjErPB8fHw9jvsQA6SMiBQAAEImIFFLhox379++XVL/PnBVf256FEt3iAXQuvy+iHfvI\n", + "uxWCZ8lamviFPdYp3y9GIiKVLSJSAAAAkRpeSH3sYx/TwMCArrrqqjBWrVY1ODioa665Rtdcc41+\n", + "9KMfha/deeeduvzyy7V161Y98MAD2cwaAACgBBqm9j760Y/qtttu00c+8pEwVqlUdPvtt+v222+v\n", + "+97du3frnnvu0e7duzUyMqL3vOc92rt3b12KB93PQss+jbdixQpJtY7fEuFmoBf5TZp9eqzT+G7i\n", + "di7zqb08+mVZeYRPIy5dulRS8x3z0b6GVzjvfOc761YEmKQ3wP33369bbrlFc+fO1dDQkDZv3qyd\n", + "O3emM1MAAICSiS42//d//3f9x3/8h6699lp99atf1YoVK3TkyBG9/e1vD98zODhYty9QmnwhnS2z\n", + "79Ul9mVjheerV68OY3b3VqZ2AEDZ2HnN36ha12o/1sn77ll0WpJmZmZye1wfCUub7Xk3b968MJbH\n", + "rgH2OvCtDqyj+tNPP5354+M1UTm3v/7rv9Zzzz2nxx9/XOvWrdPf/d3fXfB7s3zxAgAAFCnqQqq/\n", + "v1+VSkWVSkV/8Rd/EdJ3GzZs0KFDh8L3HT58WBs2bEhnpgAAADl76KGHZv16VGpvdHRU69atkyTd\n", + "d999YUXfjTfeqA996EO6/fbbNTIyon379um6666LeYg6Po136aWXSkrepHHv3r1tPxbi+HC9FZT7\n", + "1J51/D1y5EgY+9nPfpbT7FA2PgViUWv/ni5qY+ci+PfOm9/8Zkn1PdgspeffO5zrWpdlYbv9DX06\n", + "z1JsWRoeHq77b16sa3tavbLsHFDWxQfXX3+9Hn744Qt+veGF1C233KKHH35Yk5OT2rhxo774xS/q\n", + "pz/9qR5//HFVKhVdcskl+ta3viVJ2rZtm26++WZt27ZNc+bM0V133UVqDwAAdK2GF1Lf+973zhv7\n", + "2Mc+dsHv3759u7Zv397erF5nyZIl4diK6k6cOBHG2lnmuWrVKkm1zttSrXDQS/sKvNv09/eHY1vl\n", + "uW3btjBmkUS/ZLgX+GhD0uuqV/n3m3Vn7tWFCP51YZEmO99ItUU0x48fz3diGWl2UVBSmwQfybRz\n", + "cbNF3T6zkTZrQ+Bf13m0PyhK2gGSskaimkWDJwAAgEhcSAEAAESqnCsgplapVFStVvN+WAAAgJZV\n", + "q3b7suYAAB+fSURBVNULpiCJSAEAAESK7mzeriIjUv6xi46MFTWXpKLNz3/+84XMJQl/o2TMJZk9\n", + "ftHz8HPoxLksXLgwHFtbmSR+H00rtE57LllKey62aMkvCGh2YVInPy9DQ0PheLYWDP77Dhw4IKlx\n", + "gXmzc7HPsix3Nmk0ByJSAAAAkbiQAgAAiFRYaq8VvstvHhtB9gIfVuU57T2LFi2SVN+DrZ1+bOgO\n", + "s6XzpFp/K9+FvtnUXqtshwSp9npN6jW2ePHicGyv4bTTPP4zyPoa+l6GdtwrfQYttes3S04yMDAg\n", + "SRocHAxjY2NjkprvKdjo8z/LlF6ziEgBAABE6oiIlL8KTbojanQXlZXNmzdLqu9e/dxzz0mSpqam\n", + "CplTs4g+9B7f2XnLli2S6t87Bw8ePG8M+bK/kX9/+m7ZRbOISx57Ifqo+RVXXCFJWrp06Xlfn5iY\n", + "CGO//e1vM5mL7+SdFBXrtfNps1FIK763KJRUH2lsRloZE9tBIYsdAohIAQAAROJCCgAAIFJHpPY8\n", + "Cy37or48+kgYH5a0jXgvv/zyMGYFdGVP7aH3+OLOxx9/vMCZwPM93aw412/UbqmIkZGRMFamTV4t\n", + "7ZX2nPxG6OvWrZNUX7Rsjh49Go6zSkv7vlndvBlx2uyc49OvWS1OaGTt2rWSaik+qVbO0C4iUgAA\n", + "AJE6LiKVJM/lj77o0BfvGloJoNPZgg6pd5ZzF8mfv2wZvR+bnJyUlG0Uyhbv+Mdo9m+fR3TMIk37\n", + "9+8PYxa18xG9rPjzfpnY381/Ftlrp6jIT5IsCryNdZW3FhmSdOjQofO+75lnnpGUzeuFiBQAAEAk\n", + "LqQAAAAidUVqL08+3P3II49Iqi+K3LNnT+5zQhzfkyapN0yvWrZsWTienp4ucCa9Z2ZmppDHte7R\n", + "ZUrl+t5Dlq7yr8c1a9ZIqu9sbumdtAvCn3/++VR/Xlqsf1VRfaxsEYBUK+L2ryFLsWWZZrRzt+/n\n", + "aD0efSrYNFsK5EscGiEiBQAAEImIVBvs7qgT79p98aTvEt9LiELVu+yyyyTVd9LuxNc2WlemwuQk\n", + "Sa9DW1K/cOHCMGZREVoU5GN0dDQc20KJvKN3FmF69tlnw1gaiwNaic4SkQIAAIjEhRQAAEAkUns9\n", + "yvd+KdOmqMiX771iKRLfKRooO784wtIxPuWEfJSpID/vzv9EpAAAACIRkSohXyiXx5U1Eane5Yty\n", + "jxw5Ikk6duxYUdMBmmZtD/xuEuws0Xt8+wuTd3SMiBQAAEAkLqQAAAAikdorobxTe3mw38m6EUsU\n", + "NZcNPaNQdr7nnW1a7BdMkJbuPZbGS0rx5YWIFAAAQCQiUim46KKLwvG8efMkSWfOnIn+ed1YMLlp\n", + "0yZJte63WWIPPaC7WIsDv6/p6tWrJdX2CZSkU6dO5TsxlEaR7ReISAEAAETiQgoAACASqb0U+D5M\n", + "7aT0upk9L1kWNK9fv15SfafjPXv2ZPZ4vcSnrxcsWJDqz7Z0uG0+2g5fcFqmTsv2O/pzhc3VP7fW\n", + "XX5qaiqMJW0obOksXwZgCzraWaDi02Q25xdeeCH656XFNiO2jbWl2lx37doVxsbGxvKdGCAiUgAA\n", + "ANGISCEX4+PjmT+Gdeb2ku7cu8XKlSsl1UcR5s+fX/c1qRaZGR4eburn+oJeW1puS82zkEYkypQp\n", + "CuVZpOn48eNhzH5vi7ZItWiqXzBh0SnbR06S5sx57dQ9OTkZxtJoleLfJ2Xa8eDQoUN1/5VqrRDO\n", + "nj1byJxQLv68lUZrHd+GqBEiUgAAAJG4kAIAAIhUOVdA6+xKpaJqtZr3wwIAALSsWq1eMH1ORAoA\n", + "ACBSYcXm7UakVqxYEY6twNQvI7YCxKSCSf/YRUfGmEuyss7lS1/6kqT0i9dtqbk0e/F1zPNiheJp\n", + "dX22IswvfOELLc8lK/b4Rc/Dz6FMc/nqV78axpK6/bdTuG2vL3+3boseZmZmwpi9Xsr0vDCXep04\n", + "F3ut2YIOqbaDRtJ52u/X2OzrvdEciEgBAABE4kIKAAAgUsf2kTp27Nh5Y/QTQday6keVZi+l1/P9\n", + "h2Zj/Yx8r6MkaaxP8X2p7Nj3RGp2zt3AekJJ2f3ejTbvbufcmZQyLms/L3Qfe8/43mtDQ0OSpNHR\n", + "0TBmvQz9az2N3QAkIlIAAADROjYiBbyedfi++uqrw5jdLe/fv7+QOZVBs3ulNYpEpemKK64Ixxs3\n", + "bpRUH5HavXu3pGz3ZiyLXoq+IV1WOL1hw4YwZgX+eb6fi2QLyvw+i3be8Ds8rFu3TlL982L7WLbb\n", + "xZ+IFAAAQCQupAAAACKVOrXXzRvOdgsr1rNeHv4479CyhbnXrFkTxi6++GJJtb4iUjobWnYiv7mx\n", + "FWYWFf73BZ9W6On7wNhmyWVK7eVxPrL3ji9Ap3C7XOx1cOmll4YxW/zk09N5sNfi+vXrw9jatWsl\n", + "SY899liucymaP6fYcaP3jn1mkNoDAAAoSKkjUmWKRNmdor9ytSJRH42x4rVeYdEEX9Bc1HNgj7tn\n", + "z54wtnXrVknS4OBgGOu1iJQVc7///e8PYxap8x2v/VLhrD3xxBPnHS9YsCCMNVsgn6c8tiXdtGmT\n", + "pProoX89o3j2uVSGBSz2efSzn/2s4Jl0prRaJhGRAgAAiMSFFAAAQKRSp/bKxDZE9pvLWrfgXkvn\n", + "NZJHCmQ2hw4dCsdWTG0FmL3IOpb/zu/8Thi75JJLJNX3c8oztZekjOk8L4/X9d69ezN/DADpIiIF\n", + "AAAQiYhUk06fPl30FBDB2h749ge95qmnnpIkfetb3wpjVqT6y1/+spA5AUDW/KKNpMVr7LUHAABQ\n", + "MC6kAAAAIpHaA3rEz3/+86KngA5ifb3KvggAuJBGvSjTWkBCRAoAACASESkAwHnS6voM5MHvT2m7\n", + "juSFiBQAAEAkLqQAAAAikdoDAJzHis19L56XXnpJUv3m7QsXLpRU2+khy7lQ+I4LWbJkSTg+duxY\n", + "ro9NRAoAACBSV0Wk5s+fH47Z/653+TsTW/5KZ3qgNfY+GhoaCmNLly6VJB05ciSMPfvss5nPJe/i\n", + "YXSevKNQHhEpAACASFxIAQAAROqI1N6yZcvC8cqVKyXVig+l2saDU1NTYWxiYiKn2aFsfFp3+fLl\n", + "kqSLLroojD3//POSGne9RWebO3eupPT6IVlRtf1Xqr3W7DVVVvZcSM0/H5bGW7t2bRhbv369pPpi\n", + "8927d6cxxVmR2kOZEZECAACIVFhEqlKpNL3PjY9IrVmzRlJ9NGF6eloSUSi8xt9xnzlz5ryv92ok\n", + "KiYq0Wn8gpO09tF6Pb/Mv1Oex5h52vl0165dYWx0dFSSdPTo0XQmhqb5z0Fz4sSJC36/ZWokqa+v\n", + "T1L9e8JaWaB9RKQAAAAicSEFAAAQqXIuq/j3bA9aqahareb9sAAAAC2rVqsXLBcgIgUAABCpsGLz\n", + "IiJS1jrhk5/8ZKHz8PzjtzMXK8L3BYatFoSmNZc0pD0Xv19Yq8Xm3fy8tKOMc2l2Hv71YNJahNDq\n", + "XLLEXJJ121z6+/vPG4tZENBtz0sjze7h2GgORKQAAAAicSEFAAAQqdSdzbdu3Sqpvt/F5OSkpPow\n", + "/KJFiyQ1DmWeOnUq7SkWyjoPS9I111wjSdq/f38Yo9dLTa/2jupUtmHu4sWLw9j4+HhqP3/OnNqp\n", + "j346Nf55KVM3ceuo7lMw1j+wrHPOk38O/HERcyj738Bvam/HY2Njbf1MIlIAAACRSh2RmpmZkVTf\n", + "kdmWH/qiar+32mw6pQtxs/zv/ctf/lJS7S4Nr7E99vzeYCinD37wg+F4cHBQknTfffdl8ljNRqEG\n", + "BgbCsb2Wjhw5ksmcpFoR/HXXXRfGLJL+1FNPZfa4xu8j6Du4F23evHmSpEsuuSSMHT9+XFJ95N32\n", + "W+2197t/TVqmwvYZlWrPVdrs7yJJb3nLWyQlR3f8WKPC7qz5zFRamQoiUgAAAJG4kAIAAIhU6tSe\n", + "bZq5efPmMHbxxRdLkp577rkwZhtp9hqfniCll6zXQvxpsN4qUr5h+NWrV4djSysNDw/n9vje0NCQ\n", + "pNoiDqmWPskytWephsceeyyzx5jN6dOnC3ncRux14Aup7TXCopp6eaZkr7zyynD81re+VVItLS/V\n", + "/m7/9V//FcayOqf4tHTSZvXGn9/SWmhCRAoAACBSqSNSdnfmrzSvuOIKSdyFlI0VGkrSpk2bJEm/\n", + "+MUvwtjhw4dzn1O3swUXaW2XuWHDBkm1RR55++Y3v1nI4yaxyIy/e+629ilJ8ojgzp8//7zjEydO\n", + "NPVvfXsXFG/dunXh+J3vfKckacuWLWFs165dkur/bj/5yU8ymcvll18ejm2RiC8mf/755yVJu3fv\n", + "DmNpRceISAEAAETiQgoAACBSqVN7xhfPWZH5s88+W9R0kMAXqVpB6IoVK8IYqb30pZHSs10BpFoY\n", + "nAL9WunAj370ozDm+9l1K9/12fruNdunr1k+3dKJXeUtHenff534e6TBFoRJtZIAX+i9atUqSfXl\n", + "OVnx57Jt27ZJqt+c3NKMSRuWt4uIFAAAQKSOiEj99re/TTxGeezZsyfxGOXmI4llXfqeBb8zQrOR\n", + "vTx3RoiZXxp8NNLPIU3+eWz1OS3qefEsytLX1xfG8ug6X0ZPPvlkOLZdCPbu3RvGLDvhO5tbRC/t\n", + "SKdviWR8MbnNK4vzHBEpAACASFxIAQAAROqI1B4ApKmotFCzfEFsnsX/s3WELpIVwfui7qIKvCcn\n", + "JyXV+hL1Mv96sf5QTzzxRBizPlM+hdvf3y9JOnToUKpzGR8fTzzOAxEpAACASESkAKBkaEFRz4qW\n", + "X3755YJnUouE9WrLgwux16zfi9KidmvXrg1jvrN9tyAiBQAAEIkLKQAAgEik9gAA0ZYuXSqpfgeK\n", + "tC1evFhS/W4J1kn7+PHjmT0u2mO9onyxeVGbomeJiBQAAEAkIlIA0ISVK1dK6s476nZYtCjLiJTt\n", + "c+i7iSe1RChr+4ZeMm/evHC8evVqSbWWEZJ04sSJ3OeUNSJSAAAAkbiQAgAAiERqr0QuuugiSfSQ\n", + "QbEWLVoUjnthI2NLRTTqC2QpLFJ7tbSalE8/peHhYUnSxMREGLN+RJ14vrS+WN3I9/qyVGs3pvM8\n", + "IlIAAACRCrssnjt3bt2SyCR2B/jqq6+GsW4uJuzEO6te02z0Ig+2H5t/f7TD7vCtsDctFmmVas9f\n", + "Wu/jSqXS9s/w+9rN5vDhw20/VrfwEamxsbHcHtfvb9eJe93Z8+YLstthr/8y7R3pz0dTU1Nt/zz/\n", + "Hm/n90z7fFn3s1P/iQAAAD2CCykAAIBIlXMFxAQrlYqq1WreDwsAANCyarV6wdQiESkAAIBIhRWb\n", + "FxmR8o9ddGSMuSSLmYst2097yX6Wz4vtU3bq1KkwNluQuNP/Rlmxxy96Hn4OzKUec0nW6lz84gjr\n", + "HO4Xb7TTYb6Tn5csNZoDESkAAIBIXEgBAABEKiy1N3/+fL344otFPTy60NatWyVJ4+PjYWxkZOS8\n", + "77N0WpabrDar6Dn4Hk959DGztIT1iJOKfw5Mr3V0b1ZafXyQDt8Hyd6zy5YtC2NFvZ+sD10vfq4T\n", + "kQIAAIhUWESq2W7CQLP279/f1PeVJQJSBnl307e7abt7lcrz90ijS3q73vSmN0mS3v72t4exp556\n", + "SpL085//vJA5+S7cvRhteD2L/vjIkF8skqc0Ooe3w+8ZuG7dOkn1ne5feOGF3OdUhFmvZg4dOqTr\n", + "r79eb3rTm3TllVfq3/7t3yRJ09PTuuGGG7Rlyxa9973v1bFjx8K/ufPOO3X55Zdr69ateuCBB7Kd\n", + "PQAAQIFmvZCaO3euvva1r2nXrl167LHH9I1vfENPP/20duzYoRtuuEF79+7Vu9/9bu3YsUOStHv3\n", + "bt1zzz3avXu3fvzjH+tv/uZvMtnXBgAAoAxmTe2tXbtWa9eulfTaZotvfOMbNTIyoh/+8Id6+OGH\n", + "JUm33nqr/uAP/kA7duzQ/fffr1tuuUVz587V0NCQNm/erJ07d9aFqU03bD6c5SaIaN2JEycu+DUK\n", + "ZstlcnIylZ+T5gbLZdgE1+awcOHCMOaPi0A6r95s55les2bNmnBsKb1eSed5TRcqDQ8P6ze/+Y3e\n", + "9ra3aXx8XAMDA5KkgYGBsErqyJEjGhwcDP9mcHAwcdUUAABAN2iq2PzUqVP6wAc+oP/3//5fWDpu\n", + "KpXKrEWa7RRw2t3m2bNno39GlohEdQ6iUN2p296DVrTsF06UpRgfeL2ZmZlw3IuRKNMwInX27Fl9\n", + "4AMf0Ic//GHddNNNkl6LQlkYb3R0VP39/ZKkDRs26NChQ+HfHj58WBs2bMhi3gAAAJl76KGHZv36\n", + "rBdS586d08c//nFt27ZNn/rUp8L4jTfeqLvvvluSdPfdd4cLrBtvvFHf//739dJLL+m5557Tvn37\n", + "dN1117X7OwAAABTi+uuvn/Xrs6b2Hn30UX33u9/V1VdfrWuuuUbSa+0N7rjjDt1888369re/raGh\n", + "Id17772SpG3btunmm2/Wtm3bNGfOHN11111tpfbKmtJDjfUO8YW6loooazrNunnn0UPJF2NadNbX\n", + "DU5MTGQ+h26Wdx+srNkClsOHD4ex48ePS6ovrOfciFZk1XW8l9N53qwXUu94xzsuWIPw4IMPJo5v\n", + "375d27dvb39mAAAAJVdYZ3N0h+npaUmdtUQ6jwJlix5s2bIljG3cuFGStHz58jD2yCOPSOq+yAri\n", + "HD16tO6/Xhk6r6MzddL5uROxTwsAAEAkLqQAAAAikdpDWzoxZJxHEbxt5ukfy54rv2H36tWrJdUX\n", + "nXdbbySko6yLN9C7FixYEI77+vok1W9kbK/Z0dHRMPbyyy/nNLv8EJECAACI1LURqTy7oi9evDgc\n", + "29W2jzp0w76CaE1SYXDSUmHbKcCWJ0sKTW2JQAAoM/85t379ekn1EXVr3eE/I22smxCRAgAAiMSF\n", + "FAAAQKSuTe1lldLzKZiVK1dKUt1+gtbV26fz/P6DaVq1alU4ts1OrWu3JK1YsUKSdOTIkUweHxd2\n", + "+vRpSfVhbgtv+7+bpfasH5ckHTx4MI8pAkBb7Dzn+RIGKzy3zyKJ1B4AAACcro1IZcUXzS1ZskRS\n", + "/XJP23PuxIkTmc9lcHAwHFtxs9/b7aWXXpJERKpIfqmvtTq4+OKLw5jtu5d0ZwcAnWLevHmSalF2\n", + "P+b3juxGRKQAAAAicSEFAAAQqbDU3pIlS0KBtOeLpcu4kavvm2GpPd/de2pqSlJyz6C02eNL0sKF\n", + "CyXVb4j7xBNPZD6HVvn+Sr3QJ2l8fPy8Y58ets1puz30XQR7f/i0qaXhLe2N7mfdt/M4J/eagYGB\n", + "cGyLrvyYdTv36b6nn35aUnft4EBECgAAIFJhEakL3R2UMQrlTU5OnndcVJTl0UcfDceLFi2SVOvo\n", + "LqWzzDTt360XolCeb31hCxF+/vOfhzFrl2H/RXv86z8p4k0kqnX+ObVjf/5uJ7Jg5xd/XrBIov+5\n", + "1s4mpq2NXwyEdB07diwc/+IXv5Ak9ff3hzGLUnX7XqJEpAAAACJxIQUAABCpcq6AXEulUlG1Ws37\n", + "YQEAAFpWrVYvWJpCRAoAACBSYVV4RUak/GMXHRnLci5WZOm7axc1l1a1M5e0W2h0y/OStjLOpdl5\n", + "XHnlleHY3h979uw57/v83pr2Wmr0fmp1LllKmou1cMmy6NeKyK2ztST9/d///XlzmU2z72NrbyDV\n", + "fqdGiwrK/jcqis1hx44dYayothFlfF4uhIgUAABAJC6kAAAAItFgo0krVqyQVN83o4x8Z3MrjMtj\n", + "A+UsJfWaSdJqvxjfHyemPw06l0852Ubf/n1i7/OtW7eGMUtx7N69O48pZiaPPj72XvW7PrTKb8A+\n", + "NjZ2we/bsmVLOLa/4fDwcPTjlp3tYiFJZ86cyeQxmk3n+T6D9p5q52/eqYhIAQAARCIi1aRO6Yjs\n", + "u5lbV9lOj0g126Gj2aJ6i1z5uynkw/bemp6eLnQev/71r2f9ut1dWzd6KZ/9EK243e/HaNGxbuwI\n", + "PZtGOzNYZMbvOZrGbg5ll1UUKobfe9ayNn5+nf7Z0ywiUgAAAJG4kAIAAIhEaq9Jp0+fLnoKLTt6\n", + "9Gjmj2HpMV/waamI8fHxzB8/RrMpwDSsXLkyHM/MzOT2uJ6l03wBqR3nnS76wz/8Q0nSc889F8Z+\n", + "9atfSaptvC1JV199tSTpN7/5TRjLs4jVUvnPPPNMbo8p1X7Hdn5Xv4giiaUNfdqyTOyc0qgHnKWQ\n", + "/EbynZLa8z2yOpn/G9n5ftWqVWEsj55lZUBECgAAIBIRqS6Wx5L+q666SpL0yU9+MozZHeL27dvD\n", + "WBodxjtRUVEoXwS6dOlSSfULJuwOcdmyZWHM7pKznLO9DtavXx/GLCLlX6+ttrIouzzvzBstzrCI\n", + "QZYRKSsAP3XqVMv/1ubf7GKQvXv3tvwYRevm8+HU1FTRU9Db3vY2SfVd7y1ilrSDQbuISAEAAETi\n", + "QgoAACBSd8XPkTvrB+QL260Hj/WxkqSDBw/mNidfyDk0NCSpvgA3i9Bu2fi0yMTEhKTkBRO+z0se\n", + "BbCHDh2SlJx+8qk9S/fluTAgS3kW2zZ6zprty9aOmJTe61lKWqq9j32PojzPKegslrb2JQJZLr4i\n", + "IgUAABCJiBTaYt2eq9VqGLNCyqKiCb6Q0yIufm+1XtNs6448CmBtIUKjhRAWefBdq9OIcqC8bQ9e\n", + "z/+9LbJQpq7eKK+nnnoq18cjIgUAABCJCykAAIBIpPaQijy7TrfCCq17jS82t41wy/A3stReo03A\n", + "bc6+M7ylpPIolu5mnZLa8534x8bGCpwJMDsiUgAAAJGISAFdzpaRlyEi1WzB+MKFCyVJy5cvD2O2\n", + "h+PJkyfTn1gPKcProFv55fbd0roDjRGRAgAAiMSFFAAAQCRSe0AX8mkFX7RbFitWrAjHlrLz3efX\n", + "rl0rqbbBriSNjo7mNDsgjn8N20bVjRZWoPMRkQIAAIhERArocmXsCJ50l75gwYJwbHfzftn71NRU\n", + "9hMD2kDn9d5ERAoAACASF1IAAACRSO0ByF3SRso+3WfpyOnp6ZZ+ri/2bbQxchF8n6FFixZJqm2s\n", + "HcNSoFJtY+4yLi4AuhkRKQAAgEiljkjZ3dZFF10Uxsp4lwn0Oou0tNPN2Xfctj35kiJXs/n/7d09\n", + "TBp/GAfwLwNTdahRkYgJCYKveJAQnYwaX0Za46KDMald3JoY48qi1cHBNp0aTdx08mUQ4+JbujAU\n", + "F11MxAQRHUwHqwPWPP/BcCn2aPM/4S7g9zPB3YV7wpcfPPkBv8vV+0N6Zus5j/f7+1ZFRQWAzOcn\n", + "/f6mZ0aqvLwcAPDw8KBuS89E/X6dRS3pVePz+cPo9PIW6aUtnis925brpQQqKyvV2+nZTyNWJC8r\n", + "K8vJ47x69QqA9vPCz0rjcEaKiIiISCc2UkREREQ6WUREDD+pxYKOjg50dXUZfWoy0c7ODjN/QZj3\n", + "y8PMX5aXlHcoFEK2dokzUkREREQ6mTIj1dnZib29PaNPS0RERPS/dXR0YHd3V3OfKY0UERERUTHg\n", + "V3tEREREOrGRIiIiItLJlEZqa2sL9fX1cLvdmJ2dNaMEyjOn04mWlhb4/X60trYCeFzwrre3Fx6P\n", + "B319fTlbrI/M8e7dO9hsNni9XnXb3zL++PEj3G436uvrsb29bUbJ9AxaeYdCITgcDvj9fvj9foTD\n", + "YXUf8y5s8XgcXV1daGpqQnNzMz59+gSAY1yTGOzXr1/icrkkFotJKpUSRVHk+PjY6DIoz5xOp1xf\n", + "X2dsm5iYkNnZWRERmZmZkcnJSTNKoxzZ39+X79+/S3Nzs7otW8ZHR0eiKIqkUimJxWLicrnk4eHB\n", + "lLpJH628Q6GQzM3N/XEs8y58yWRSotGoiIjc3NyIx+OR4+NjjnENhs9IRSIR1NbWwul0wmq1YnBw\n", + "EOvr60aXQQaQJ/9j2NjYwMjICABgZGQEa2trZpRFOdLe3o7Xr19nbMuW8fr6OoaGhmC1WuF0OlFb\n", + "W4tIJGJ4zaSfVt7An+McYN7FoKqqCj6fDwBQUlKChoYGJBIJjnENhjdSiUQCNTU16n2Hw4FEImF0\n", + "GZRnFosFPT09CAQC+Pr1KwDg6uoKNpsNAGCz2XB1dWVmiZQH2TK+uLiAw+FQj+O4Lx6fP3+GoigY\n", + "HR1Vv+Zh3sXl7OwM0WgUbW1tHOMaDG+k/nVBTSoO3759QzQaRTgcxpcvX3BwcJCx32Kx8LVQ5P6V\n", + "MfMvfGNjY4jFYjg8PITdbsf4+HjWY5l3Yfr58ycGBgYwPz+P0tLSjH0c448Mb6Sqq6sRj8fV+/F4\n", + "PKOLpeJgt9sBPF71vr+/H5FIBDabDZeXlwCAZDKZceV1Kg7ZMn467s/Pz1FdXW1KjZQ7lZWV6ofp\n", + "+/fv1a9ymHdxuL+/x8DAAIaHh/H27VsAHONaDG+kAoEATk5OcHZ2hlQqhZWVFQSDQaPLoDy6u7vD\n", + "zc0NAOD29hbb29vwer0IBoNYWloCACwtLakDk4pHtoyDwSCWl5eRSqUQi8VwcnKi/puTClcymVRv\n", + "r66uqv/oY96FT0QwOjqKxsZGfPjwQd3OMa7BjF+4b25uisfjEZfLJdPT02aUQHl0enoqiqKIoijS\n", + "1NSkZnx9fS3d3d3idrult7dXfvz4YXKl9ByDg4Nit9vFarWKw+GQxcXFv2Y8NTUlLpdL6urqZGtr\n", + "y8TKSY+neS8sLMjw8LB4vV5paWmRN2/eyOXlpXo88y5sBwcHYrFYRFEU8fl84vP5JBwOc4xr4CVi\n", + "iIiIiHTiyuZEREREOrGRIiIiItKJjRQRERGRTmykiIiIiHRiI0VERESkExspIiIiIp3YSBERERHp\n", + "xEaKiIiISKf/AMt+wa3UEUvkAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "source": [ - "The first fully connected layer, `fc6` (rectified)\n", - "\n", - "We show the output values and the histogram of the positive values" - ] - }, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['conv5'].data[0]\n", + "vis_square(feat, padval=0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The fifth layer after pooling, `pool5`" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "feat = net.blobs['fc6'].data[0]\n", - "plt.subplot(2, 1, 1)\n", - "plt.plot(feat.flat)\n", - "plt.subplot(2, 1, 2)\n", - "_ = plt.hist(feat.flat[feat.flat > 0], bins=100)" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJMCAYAAADaNPObAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XuMHeV5+PHneO/3+8X22izxbVkbsI0hlLTBYK0JCBwS\n", + "KLkpsQClUmmrgNICUlUJWiU2StuEJM0/FaVWknKp2oKLEos4yTqhDhBDiAO2sU28eL3eXdt7v1/P\n", + "7482/sV+nzXvvvOemTlnvx8pUvZhzsyzM3POeTz7zDOJZDKZFAAAAMzLoqgTAAAASEcUUQAAAA4o\n", + "ogAAABxQRAEAADigiAIAAHBAEQUAAODAexG1Z88eaWpqklWrVskTTzzhe/UAAACxkPA5J2pmZkbW\n", + "rFkje/fulaVLl8q1114rzzzzjFxxxRW+NgEAABAL2T5X9vrrr8vKlSulsbFRREQ+/elPy4svvnhB\n", + "EZVIJHxuEgAAIGVuvPFGaW1tVf+b1yKqo6NDli1bdv7nhoYGee211z7wdQUFBUZsbGzMZ2qiXXCL\n", + "qqALkktlZaXVcsPDw0ZscnLykrk89thj8thjj6XlfvEtSC7XXXed1XKvv/56ynPxLS65RJVHTk6O\n", + "EdPeV0Fy0V5r+wcD3/tl0SKz42N2djbluXzkIx+55H8/efKkLF++XA4fPmz8t97eXq+5+GabS1ZW\n", + "lhHLz8+3imn7IC8vz4hp37NaLtp5/zszMzPnc52amppzuQ8S52N0qTy8FlFcZQIAAOmstbV1zitP\n", + "F/NaRC1dulTa29vP/9ze3i4NDQ0+NwEAAJAymzdvls2bN5//+fHHH59zWa9F1KZNm+TYsWPS1tYm\n", + "S5Yskeeee06eeeaZD3yd7z/dZWd7/bUio11K1363wsJCI6ZdCj579uwlt/f7Jw0QhHb+rV271uq1\n", + "Bw8e9J2ON0H+XGErqmfCa//g1T6DtM8R35/hGzZsuOR/r6mpkYaGBuno6DD+m/anrHQ0MzNjxEZG\n", + "RqximvHxcedcPui8t/0TbybyWm1kZ2fLt7/9bbnllltkZmZG7r//fu7MSyMUUQDSAX/hQFx4v2Rz\n", + "6623yq233up7tQAAALHCxHIAAAAHFFEAAAAOMqMD+yKZ0liuzf/Izc01Yn19fUZsYGAgJTn9Ptu+\n", + "hFOnTqU4k0vPMfl9YTQGv/HGG0Zs1apVRqypqcmIHTlyJCU5hU2bSbNkyRKr18a5sRx6s7lvtreX\n", + "d3Z2pjYR0ecYat8xQ0NDKc8lKiUlJUbs+uuvt3rt3r17jVhUN0+kAleiAAAAHFBEAQAAOKCIAgAA\n", + "cEARBQAA4CAzOrAvspCnp4YpTs2BxcXFVstpTfi+XX311Ubs8ssvN2LaZOVMaSyfnp42Yv39/RFk\n", + "Ylq6dKnVcoODg0Ysk5uHw7gBxNbbb7+d8m3YPlxZeyasduPE6OioEdOmjqcjnos7N65EAQAAOKCI\n", + "AgAAcEARBQAA4IAiCgAAwEFGNpZrU73TkdaoODk5acS0Jt4wdHR0RLJdTRgN47a06b5aY+bExEQY\n", + "6URCO09fffVVI6btFy0Wp5sY4iIrKyvqFBYE7XN4fHzciGXyDU3ad8w777xjxLT3fVVVlRE7d+6c\n", + "n8RigCtRAAAADiiiAAAAHFBEAQAAOKCIAgAAcJCRjeXDw8NRpzBvzc3NRqywsNDqtdok6LGxMSO2\n", + "ePHi+SeGedOmFGvTr8+cORNGOpHQJjpv2rTJ6rUDAwNG7OTJk4Fz+p043RARRE5OTtQppDXb6eRl\n", + "ZWVGTLvRQTtvM4XWWF5TU2PEtH2lNebTWA4AALDAUUQBAAA4oIgCAABwQBEFAADgIJEMeRRwIpFg\n", + "+jAAAEgLl6pbuBIFAADggCIKAADAAUUUAACAA4ooAAAAB5FMLNemwqaa1hQWRR4i8c8lPz/fiGmT\n", + "aFetWmW1jd/+9rdGrK+vz4hpU9bjtF/Ky8uNWJApxVlZWVaxiYkJI2a7X1auXGm13PHjx62W0/ZL\n", + "drb5MaJNbddov6/m4vXF/T1km0tpaakR06bbh5GLb1ou2pR1bRp2GLnEab+Qi56L9r0zNTVlxLTv\n", + "Do323ab9vtqU9blwJQoAAMABRRQAAIADiigAAAAHFFEAAAAOImkst1FYWGjEtCbU8fFxI6Y1nsGe\n", + "1shcUFBgxEpKSsJIJzZGRka8rk9rvrZtyPZNa7jU3lsa25xtzxetwXR4eNjqtelGe69lsjCayJE5\n", + "tJtWtJsTbBvLtfXZ3twyF65EAQAAOKCIAgAAcEARBQAA4IAiCgAAwEEsGstzc3ONWG1trRHTmsds\n", + "m1+DaGpqslqut7fXiJ05c8Z3OpHo6OgwYv39/Vav1Zr5tFgQWuO7xrYBUZOOTbHaJHKtiRzRsL2J\n", + "QxPkXNb4nm4P/7Smak2m3FylPdkiSCN4Km7m4UoUAACAA4ooAAAABxRRAAAADiiiAAAAHMSisTyI\n", + "ODXQZfL0Ya2pemBgwOq1VVVVRiyMGwKiok3b14yOjqY4E5HLLrvMiGmNy9o09vb2dq+5DA0NWS2n\n", + "3WjiU3FxsRHL1InoyCy2TdVx+l4MorS01IhpjeC271/thibbGznmwpUoAAAABxRRAAAADiiiAAAA\n", + "HFBEAQAAOIhFY/nk5KTVckEbwFydPn3aiCUSCSNGc6qup6cn5dvwPb05CK2RXqM118/OznrNJS8v\n", + "z+v6fNPeR6lm+3kTBm16vHbMwrgRo62tLeXbSEe2NzqEcV4Fna6dboqKioyY7Q0qYeFKFAAAgAOK\n", + "KAAAAAcUUQAAAA4oogAAABxE0lh+8cRgrXlMaxROJpNGTGviDTIJetEis67UpnXn5OQYMW0aqtY4\n", + "Gnfa76HtgyC0SdpxV1ZWZsS0qe1BmqW1adoa7bzSjpHte6Gzs9OI1dTUWL1We89o7+nFixdbra+7\n", + "u9uI+WyQj1NjudYwHtU0f9/v8UwRp/MljEnk2nstqqdx9Pf3G7Eg3+9aU3rQ9xtXogAAABxQRAEA\n", + "ADigiAIAAHBAEQUAAOAgkdS6tVO5wURCbRAHAACIm0vVLVyJAgAAcEARBQAA4IAiCgAAwAFFFAAA\n", + "gINIJpavX7/+gp+Hh4eNZUpKSqzW1d7ebsS0ybva5NMgk6WD0BrU4pRLZWWlEdOOx+zsrBHTJtsW\n", + "FBRYLdfV1WXE4rRf6uvrjZg2sdx2Aq42Gb6urs6InTp1yojZ7pfa2lojdvbsWSNme7NHXM7duOQh\n", + "Qi5zCZLLNddcY7XcG2+8kfJcfCMXXZBcsrKyrJabmZkxYtr303ymonMlCgAAwAFFFAAAgAOKKAAA\n", + "AAcUUQAAAA4iaSx/7733LvhZayyHvZycHCM2NTXlvL6+vj4jZttsrjUtnzx50jmXOOnu7va6Pu0G\n", + "iNOnTzuvr7y83Iht3LjR6rV79uxx3i7gm/aZpikrKzNi2s0eyGwNDQ1Wy73//vtGTDuH5oMrUQAA\n", + "AA4oogAAABxQRAEAADigiAIAAHAQSWO5Nq0adrSJ1hrfTdBas7nGdnIs/NOm8h88eNCI2U4nR+pV\n", + "VFRYLWf7/ssU2pMoNEFuoElH119/vdVyr776aoozCUdpaakRKyoqMmJjY2PO29DWNx9ciQIAAHBA\n", + "EQUAAOCAIgoAAMABRRQAAICDSBrL4U6bxhtVo3B2tnn6aI2eiUTCiPnOuba21ogNDQ0ZsSANiNrv\n", + "q00dD8L3frGd/BzG7wbYOnPmjBHTztHx8fEw0kGMaDcvdXZ2Oq8v6DnElSgAAAAHFFEAAAAOKKIA\n", + "AAAcUEQBAAA4iKSxfKFNmfUpqkZKrUm7uLg4gkx0hYWFVrG2trYQsomPsrIyq+U6OjpSnAk0C20S\n", + "uS3thgjtXD579qwRy+QbIjJlErmtwcFBI6ZNMQ+ip6cn0Ou5EgUAAOCAIgoAAMABRRQAAIADiigA\n", + "AAAHTCxPMW26qm+5ublGbGZmxipmKy8vz/m1YUwsD4PW7FpQUGD1Wu33LSoqcl6f1jQ/OjpqxLTG\n", + "TE0mN+NebNEi89+Os7OzEWQSL9r5ODIy4nUb2ueh9rlk+z7QBPmsQrxox7K3t9d5fVVVVUZsYmLC\n", + "eX0iXIkCAABwQhEFAADggCIKAADAgVMR1d7eLjfddJOsXbtW1q1bJ9/85jdF5H//VtnS0iKrV6+W\n", + "rVu3Sn9/v9dkAQAA4iKRdOjw7erqkq6uLlm/fr0MDw/LNddcIy+88II8/fTTUl1dLQ8//LA88cQT\n", + "0tfXJzt37rxwg4lEWjYVAwCAhedSdYvTlaj6+npZv369iPzvoz+uuOIK6ejokN27d8v27dtFRGT7\n", + "9u3ywgsvOKYMAAAQb05Xon5fW1ub3HjjjfL222/L8uXLzz8LKplMSmVlpfFsKK5EAQCAdHGpuiXQ\n", + "nKjh4WG566675Mknn5SSkhJjo9p8IBGRxx577Pz/37x5s2zevDlIGgAAAF60trZKa2ur1bLOV6Km\n", + "pqbk9ttvl1tvvVUefPBBERFpamqS1tZWqa+vl87OTrnpppvkyJEjF26QK1EAACBNeL8SlUwm5f77\n", + "75fm5ubzBZSIyLZt22TXrl3yyCOPyK5du+TOO++cM6GwaTvANg9tyql256E2eVebjqwtZ5uLNsE1\n", + "yMTVIPvFNy2Xuro6I3bmzBmv29UmNQ8PDxux/Px8IxZ02q2NuB8jLZfy8nIjdtVVVxmxEydOGLFT\n", + "p0594HbTcZ+EwXYyvjbx3vYftz09PUasuLjYiA0NDRmxOO0XctFzqampMWLnzp1z3ob2pIepqSmr\n", + "XLT9osXWrl1rlcv7779vxLTzdD4XepyKqP/5n/+R733ve3LVVVfJhg0bRERkx44d8uijj8o999wj\n", + "Tz31lDQ2Nsrzzz/vsnoAAIDYcyqi/vAP/3DOZ03t3bs3UEIAAADpgInlAAAADiiiAAAAHAQaceCL\n", + "1si2ePFiIzY5OWnELr77L27m+rOnqzAameOkt7c35dsYGRmxWi4d9712I4LG9++WlZVltZzW9Ay/\n", + "RkdHrWJBaDdipKPc3Fwjpt0QoXn77beN2Pj4uPN2te+O6elpq/UFoTVaB6F9BmmN5ba0pm/b88/2\n", + "eMwHV6IAAAAcUEQBAAA4oIgCAABwQBEFAADgIBaN5XE3NjYWdQoLVhiNlJls2bJlVssdP37c63a1\n", + "qdZa4+3AwIAR47FQ6cf2BoZMVlFRYcQ6OzutXuv7BqS40ybcB9HW1uZ1ffPBlSgAAAAHFFEAAAAO\n", + "KKIAAAAcUEQBAAA4iEVj+dmzZ61icaI1UvqeAgwEFaeG1SuuuMKIZWebH0Ht7e1G7Le//W1KcoIf\n", + "OTk5UafghfZUjHPnzhkxbcJ4kH0QpxtotH0QRGFhodf1xQ1XogAAABxQRAEAADigiAIAAHBAEQUA\n", + "AOAgFo3lGttJy1oTqm9lZWVWy9FYLpKfn2+13Pj4eIozgYhIf3+/1XLajRITExNec/E9pRjxMTw8\n", + "HHUKKaPd5KS9X3w3ZPtm+/7jiQHzw5UoAAAABxRRAAAADiiiAAAAHFBEAQAAOIhtY3lVVZXVckEa\n", + "y7OysozYzMyMEcuUJugwpgrTWB5/WlOsNjn8zJkzYaRjCONmEcCW9j2hNV8Haa4vKioyYiMjI87r\n", + "0yxaFM01k6g+R8LClSgAAAAHFFEAAAAOKKIAAAAcUEQBAAA4SCRDHk+aSCSYiAoAANLCpeoWrkQB\n", + "AAA4oIgCAABwQBEFAADggCIKAADAQSQTyxOJROjb1JrCSkpKjFhubq4Rm56eNmITExPO29VeG8U+\n", + "EdHzi1MupaWlRmxoaCiSXOK0X4qLi42Y7wnHtrn4PkbaZP2pqakPzCNOx8c2F+3JDLZPTdBiQXK5\n", + "5ZZbrJb70Y9+ZMRmZ2e95uIbuegyJZelS5caMW0KfG9vrxE7d+6cVS5z4UoUAACAA4ooAAAABxRR\n", + "AAAADiiiAAAAHETSWB4Xk5OTRmx4eNjrNqJq0gvDvffea7Xcv/3bvxkx28b8MJrICwoKUr4N3+J0\n", + "Xvk+Rhc3kSMcixbZ/Zs6TudeVlaWEcvPz3den/a7fexjH7N67a9+9Ssj1tXV5ZwLdNp5Wl1dbfVa\n", + "7aaVoLgSBQAA4IAiCgAAwAFFFAAAgAOKKAAAAAexbSzXJvlq08Q7Ozudt6E1qGVnm7tEm1huS2t8\n", + "XGjC2Ad5eXlWy9k2tMed7xsgFpLy8nIjpp0//f39Rsz3+dPT0+N1fUG88sorVstpE9WDKCsrM2ID\n", + "AwNWr9WmUmtPorClTaoO40kAtrQnFfBZYN8wbntezQdXogAAABxQRAEAADigiAIAAHBAEQUAAOAg\n", + "kdQ66VK5Qctpt1oDndZE2N3dbbU+7desqakxYloT+ejoqBHTpp1rtGZ4rTnVdr9ozfCzs7NWr9Vo\n", + "+yWqicRBcvHdWJ4p+8W3uOQSJA/fjeVx2Sci6ZmLtu+DNPBr3xNa83Xc94vGd2N5Op4vGtunToyN\n", + "jTnlkkgk1PxEuBIFAADghCIKAADAAUUUAACAA4ooAAAAB7FtLPdN+zW1qehak3aQxnLbXOK0X8iF\n", + "XOYSl1x856E1I9tOqo7LPhEhl7mQi45cdDSWAwAApBhFFAAAgAOKKAAAAAcUUQAAAA6yo04gSr29\n", + "vVGnACBkK1assFquq6vLiNk2m9vKysoyYtnZ5sey1tRqe3NLZWWlEdOefKBNaNee4KBNGK+oqLDK\n", + "RWsUDnJvU35+vhG77LLLnNcXhHbcqqurrV7b0NBgxGybqtvb251fmym095FmZmbG+7a5EgUAAOCA\n", + "IgoAAMABRRQAAIADiigAAAAHkUwsD3mTAAAATphYDgAA4BlFFAAAgAOKKAAAAAcUUQAAAA4imVge\n", + "xTRVrSksqqmutrnk5OQ4r8+2eV+bSKzlEsZE2HQ8RmHQcrGddG071VqjbcP2fEm1IMdn9erVVssd\n", + "PXo05bn4puWyePFiI6ZNYw8jlzjtlz/4gz8wYuPj40bs3XffNWLae62wsNCI1dTUGLHf/OY3RixO\n", + "+0X7PcbGxrxuV9uG9jSAOO2XuXAlCgAAwAFFFAAAgAOKKAAAAAcUUQAAAA4iaSyHnampKa/r05r5\n", + "bAVpGA+D1oBYVFRk9drh4WHf6aTc7OysEdOayBsbG63W19bWZsTifsxhJ4wmct+uu+46q+UOHDhg\n", + "xLT3huaNN94wYrafudpnqdaU/s4771itL07y8vKMmO13R09Pj+90Yo8rUQAAAA4oogAAABxQRAEA\n", + "ADigiAIAAHBAYzkylm0zZDo2ltsKcjNBprKdRB4G7akEvm8osXXZZZdZLff++++nOJPo5ObmGjGt\n", + "0Xp0dNSIRTVdOwzaTSvafqmurjZig4ODRmw+E8HjjitRAAAADiiiAAAAHFBEAQAAOKCIAgAAcEBj\n", + "+QKSlZUVdQopozUqag2NYdAaLrVmYdvJykEMDQ2lfBu28vPzjZg25Xmhi1OzeVRef/31lG9D26da\n", + "Y7lG+7wJ8tSEONE+M7SnF9TW1lqt79y5c4FzijOuRAEAADigiAIAAHBAEQUAAOCAIgoAAMABjeXI\n", + "WFE1LcepCbi9vT3qFGKntLTUiFVUVBixnp4eI+Z7un2czpXu7m4jlslTuDXaZG4tlskWLTKvrWiN\n", + "5cuXL7da33vvvRc4pzjjShQAAIADiigAAAAHgYqomZkZ2bBhg9xxxx0iItLb2ystLS2yevVq2bp1\n", + "q/T393tJEgAAIG4CFVFPPvmkNDc3n/+7+c6dO6WlpUWOHj0qW7ZskZ07d3pJEgAAIG6cG8tPnTol\n", + "P/jBD+Sv//qv5R//8R9FRGT37t2yb98+ERHZvn27bN68mUIqRuI0vTpTaBOObSeWa43vxcXFfhIL\n", + "UXV1tRHTphRPTEwYMdsJ0T6be5ctW2bEysrKjJh2fHw3lmuys+0+lqenp71uN8gEb1vaNHZt+rfW\n", + "yKwtp7Hdf0FoDfcjIyNGzDbnOCkoKDBiWrN5GE9cSAfOV6Ieeugh+drXvnbBzu3u7pa6ujoREamr\n", + "q1Pv9gAAAMgETkXUSy+9JLW1tbJhw4Y5K+1EIrHgbo8FAAALh9N1z/3798vu3bvlBz/4gYyPj8vg\n", + "4KB8/vOfl7q6Ounq6pL6+nrp7Oy0fkAhAABAHLS2tkpra6vVsolkwD/a7tu3T/7+7/9e/vu//1se\n", + "fvhhqaqqkkceeUR27twp/f39Rk9UVFenbJ+6HQZy0aVjLmH0RGm9bHHaLzU1NUZM64nSctZ6ZDQX\n", + "90QFOVfWrl1rxLSeKG1IoNai4Pu8DdITFSSXrKwsI6ad32NjY1br03LR1hdGT5T2/gtyjGxfq+Uc\n", + "98857b2g9TNef/31Vtv4XZ+0Sy5x2S+JRGLO889LB97vftFHH31U7rnnHnnqqaeksbFRnn/+easE\n", + "oxKXPETIZS7kootTLmfPno06BRGJ1z4hF12cpn/Hab/EKZeBgYGoUzgvTvtlLoGvRM17g5eo6AAA\n", + "AOLkUnULE8sBAAAcUEQBAAA4oIgCAABwkPrRroqL717y3WxYVFRkxLRJw2F0/ufn5xsx7e4W33fz\n", + "2E4z1v7Ou2nTJiOmjavQ7hrTpkG/8sorRmzlypVG7Cc/+YkRKy8vN2K2U6O1O3w0lZWVRqynp8eI\n", + "2R4j7fzTphnbivNdKyLR5KLl0djYaMS0/a7dOWirqqrKan22+0Sb9q6xzTnI8SktLbVabnBwMOW5\n", + "aO/7IM9iDZKLdgepdrdfGLn4lil3lvo2n75trkQBAAA4oIgCAABwQBEFAADggCIKAADAQSSN5ame\n", + "WhukiVdrItQajzXaIyG0R3v4ZttEbuvw4cNG7P333zdits2uWpPoyZMnrV4bxvTc3t5er+sLcv7B\n", + "nfbe1R5hEaSxXHssz0KjPR7G9iYOTVNTkxG79dZbrV77H//xH0bM9rPFVpAm8oVG+6zXBHkPxg1X\n", + "ogAAABxQRAEAADigiAIAAHBAEQUAAOAgksbyOMvNzTViJSUlVq89c+aMEZvP5NO40KbETkxMOK8v\n", + "yKThILRp8Zowmv8RDW2qfhC+bxqIU4OtNrFcm0BdUVFhxLQbT8KwatUqI+a7sVyjPcFBo30nZLKF\n", + "+FnKlSgAAAAHFFEAAAAOKKIAAAAcUEQBAAA4oLH8IlpjnG1zajo2kWu0xnJtGrTWuK1NT9cmHDc0\n", + "NDhmh3SVl5dnxAoKCoyY9j4KY3K9jbGxMa/r095XmjCmZmvTprVj1tfX53W7R44cMWLaDT6LFy/2\n", + "ul1bWnM9dMPDw1GnEDquRAEAADigiAIAAHBAEQUAAOCAIgoAAMABHXMXmZmZMWLpOIVVmz5sO2VX\n", + "o+0XreFydnbWiGmN5YWFhc652Ir7cdMa+LV9tdC4TsefnJw0YraN25pFi8x/Y2qN8JlCu4FGa/DW\n", + "Pgt8025a0Y5vb29vynPRaNvlvbswcSUKAADAAUUUAACAA4ooAAAABxRRAAAADmgstxBkWrJts2FR\n", + "UZERGxkZcd6ub0GatLWG0La2tgDZRKOpqcmIac312tTenp4eI3bNNdcYMa2RN1NoDeOuTeRh0G6S\n", + "0GIa7SYO7T00ODhotb4PfehDRsz3uaKdt1pjvvZ+9k373bRm8zCa3LWnMARZDuHQbtzRBH3SCFei\n", + "AAAAHFBEAQAAOKCIAgAAcEARBQAA4CCRDNpVNd8NJhKBG7kAAADCcKm6hStRAAAADiiiAAAAHFBE\n", + "AQAAOKCIAgAAcBDJxHKbSaIrV660Wpc2Cbqvr8+IaU1hthNNfcuUXLZs2WK13K9//Wsjdu7cOa+5\n", + "+GabS0lJiRHTJhePjY1ZbVebgD41NWXEtAn3hYWFRkybiF1cXGzEent7jVhVVZUR046b7THSplBr\n", + "E7FtJvVrx2ft2rVGTMu3v7/fiGn7PS8vz2q72udN3M9bTUFBgRGzPW9tc9Gm9Gu0c1nT3t5uxOrq\n", + "6ozYa6+9ZsTS8Rj5FiSXhoYGI6Z99mmfLdrU+7jvl7lwJQoAAMABRRQAAIADiigAAAAHFFEAAAAO\n", + "Imksd5WVlWXEtMZU38rLy62W0xpWkdmGhoa8rk9rzNRoDb+zs7NGTGvg1Bo9NdpNG0GsXr3aiGnN\n", + "5h0dHUasu7v7A9d/8uRJIzY8PGyVm7afRkdHrV4bd1qTtva7BWkit6UdjzNnzhgx289S7fyx/bwG\n", + "RPSbdOaDK1EAAAAOKKIAAAAcUEQBAAA4oIgCAABwENvGctuGXa2Z1rfq6mqr5RZaY/mPf/xjI1ZR\n", + "URFBJguPNlF3fHzceX3aDRq+pwX/9re/NWLalOyF9j5a6LTzTIvNZ4p0plq8eLHVcp2dnSnORL8Z\n", + "Q6M1/9u+VnuSgPaZ4fsGn/ngShQAAIADiigAAAAHFFEAAAAOKKIAAAAcxLaxXJueqzW/zszMpDwX\n", + "2wnPvtlOUh0ZGUlxJva06ciavr4+r9utra21Wk6bjpyOtIZL7b1g24w7NTUVOKcPok3J9jkV3LZZ\n", + "NQjb89tWXl6eESsrKzNi2vR428++OE1et50MrzUjT0xMGDHtM1J7bwRhe4PFQmt8154gEgbf7/Og\n", + "359ciQIAAHBAEQUAAOCAIgoAAMABRRQAAICD2DaWa81jWmN5GKJqLNeaKzVxaizv6OiIOoUFobKy\n", + "0ojZNsB2d3dbLed7Ynmq1dfXGzHb94bWuK01ePtuwC8vLzdi2kRmLb905LsxPwzaeaAZHBw0Yr6f\n", + "qBHGJHJb2k0RmiA5a/tvenraeX2pwJUoAAAABxRRAAAADiiiAAAAHFBEAQAAOIiksfzixkmtUUyb\n", + "hqo1m+fn5xux6urqANmZSktLrZYbGhoyYkGm2Pqe6h2E1uyqTZW31dDQECQdg7bvF5rx8XGv6wty\n", + "7mqN7xqtGbeurs6I2byntWn02j5ZtMju344DAwNWywWhbUObzB3kyQzaDQK+p2vb3vSj3aSj/b62\n", + "DffaZ+Qbb7xhlYst2/NF+87y3VgehpKSEiOmffdqDeO+p4kvWbLEiGnf+dp5oN2MsW7dOiO2ePFi\n", + "x+z+F1eiAAAAHFBEAQAAOKCIAgAAcEARBQAA4CCR9N1h+EEbTCS8NzUCAACkwqXqFq5EAQAAOKCI\n", + "AgAAcEARBQAA4IAiCgAAwEEkE8u1CbqppjWFRZGHSLBctAmuZ8+etXrt1NSUcy7aFGmN7XIHDx50\n", + "zkXT1NTL6yctAAAgAElEQVRkxDo6OoxYcXGxEdMm72bK+eJbkFyWLVtmtVx7e3tK8/DNNpeysjKr\n", + "9QWZlG6bS15entX6tGni2mRubaK6bS62sSDTv21zsT1Hbc+1kydPOufim+0+1Sa0h3EzmO1+0SaM\n", + "a9872tMKtCcknD592iqXuXAlCgAAwAFFFAAAgAOKKAAAAAcUUQAAAA4iaSy3UV1dbbXcuXPnvG63\n", + "sbHRiL344otWr3300UeN2A9/+MOgKV1Aa4LTGj2DNGFq+vv7rbZr21jum21z/fDwcIozgYhIQUGB\n", + "EfvoRz9q9drvf//7vtO5wNVXX2213K9//Wuv29UaxsvLy61i2vsvCK1h3JbvJmNtfVE91cLmpgYR\n", + "keXLl6c4E72pOsh+sX1t3J8okpuba7Vcfn6+EdMay4PiShQAAIADiigAAAAHFFEAAAAOYtsTpQ1F\n", + "1GgDtTK570UbtqnReqeCsO2h0IZohqGnpyeS7SL9NDQ0WC3nuycqU/jut9Ro/SyTk5OR5KLRhmj6\n", + "pvX+BOlly2TT09NWy9n2U80HV6IAAAAcUEQBAAA4oIgCAABwQBEFAADgIJEMebKW7dOqS0pKjJg2\n", + "3FFrIteazNLxqe8a343lmbJffCMXXVxyCZJHRUWF1XJ9fX0pz8W3TMlFawDWGsvDyMU321yCDNvU\n", + "vis12ndl3PeL7e9m20Q+Njb2gbkkEok59z1XogAAABxQRAEAADigiAIAAHDgXET19/fL3XffLVdc\n", + "cYU0NzfLa6+9Jr29vdLS0iKrV6+WrVu3en9oJgAAQFw4N5Zv375dbrzxRrnvvvtkenpaRkZG5Ctf\n", + "+YpUV1fLww8/LE888YT09fXJzp07L9xgzJvWwhAkl6KiIiNWVVVl9Vptym6m7BffyEUXJJfGxkar\n", + "mKa1tdVbHr6Riy5ILuXl5VbLDQ0NGbGZmRmvudTV1Rkx7XNY+3wNcpOTbX7a+mxvnujt7XXerm++\n", + "z92cnBwjNjU15ZSL98bygYEB+fnPfy733XefiIhkZ2dLWVmZ7N69W7Zv3y4i/1tkvfDCCy6rBwAA\n", + "iD2nIurEiRNSU1Mj9957r2zcuFG++MUvysjIiHR3d5+v2uvq6qS7u9trsgAAAHHh9ADi6elpefPN\n", + "N+Xb3/62XHvttfLggw+qf7aL6rIgAACAi9bWVqOFYC5ORVRDQ4M0NDTItddeKyIid999t+zYsUPq\n", + "6+ulq6tL6uvrpbOzU2pra11WDwAAEInNmzfL5s2bz//8+OOPz7msUxFVX18vy5Ytk6NHj8rq1atl\n", + "7969snbtWlm7dq3s2rVLHnnkEdm1a5fceeedLqufU2VlpdVyWrNcptCmsBYWFkaQSbxoVz3z8/ON\n", + "WHV1tRFrb29PSU640HXXXWfEtAn84+PjRsz2X4XIDLY3HBw7dsyIjYyMeM1F+8zwTZvCbXvDUJBJ\n", + "7ulI+76rqamxem1HR4cR05r/58OpiBIR+da3viWf+9znZHJyUlasWCFPP/20zMzMyD333CNPPfWU\n", + "NDY2yvPPPx8oOQAAgLhyLqKuvvpq+eUvf2nE9+7dGyghAACAdMDEcgAAAAcUUQAAAA6cJ5Y7b/AS\n", + "kz8BAADixPvEcgAAgIWOIgoAAMABRRQAAIADiigAAAAHznOigrh4uvSf/umfGstcf/31RuzgwYNW\n", + "6/+Hf/gHI6Y1hWlTrv/sz/7MiG3cuNGIaVOu//Vf/9WItbW1OeeiKSoqslrOdmpvkFx8IxddOuai\n", + "TdbXaK/VJjWfPn3aKY8wZEouTU1NVssdOXIk5bn4FiSXnJwcI7ZokXn9YWJiwogVFxcbsaGhIedc\n", + "fIv7MSooKDBif/EXf2HEPvrRj1qtb//+/UbsW9/6lhEbHh6eM8+LcSUKAADAAUUUAACAA4ooAAAA\n", + "BxRRAAAADiJpLL/YT3/6UyOmNS9qDd5R0Zpfs7NTvzttG8Z9W7p0qdVyHR0dKc4Ec1m8eLER+9jH\n", + "Pmb12qefftprLlrjrYanF0Rj2bJlRuzw4cNWr/3CF75gxL773e8655KVlWUVm5ycdN5GEIWFhVbL\n", + "aY3l82lQXkhsm9fHx8dTnEnw71SuRAEAADigiAIAAHBAEQUAAOCAIgoAAMBBIhlyZ2ecpqFquQSZ\n", + "CK5Ntp2amnLOJQy2uZSUlFitT5vG6zuXMKRjLmE0ltvmojUGa2ZmZoyYdq5dfF6l4/GxlZ+fb8Rs\n", + "G2xtc9Eay0+ePGm1DdvG8kw+RkGQi76N2dlZq+Vsv7e1z6DBwUEjpu2Di2OJRGLOm2C4EgUAAOCA\n", + "IgoAAMABRRQAAIADiigAAAAHNJZfpLi42Gp92iRabX02TWtzvTYMtrloTfMarZHedy5hIBddGLl8\n", + "6EMfMmIXv9+6u7tTnoetdGws19h+ftlaaOetLXLRxTkXGssBAAA8o4gCAABwQBEFAADggCIKAADA\n", + "QXbUCcSN1jBuK+QefSDtVVVVGbHa2lojpk02z1S2TeS+aZ9fS5YssXrt6dOnveaSnW1+NWnnika7\n", + "6QBIFa5EAQAAOKCIAgAAcEARBQAA4IAiCgAAwEFsG8uXLVtmtdzo6KgR6+npsXptXl6eEZuYmLB6\n", + "raawsNCIafmlo6KiIqvl+vv7U5xJdLKysqxi69ats1rf7OysETt48OD8E0sTWrOwNpFY2y9nz55N\n", + "SU7pzPc05zVr1hixhoYGq9f6bixfv369EdMmuWtsG8tLSkqMmNZcX1FRYbW+wcFBI2b7pIc40b57\n", + "tRuu+vr6jJj2PaGt79ixY47ZxQ9XogAAABxQRAEAADigiAIAAHBAEQUAAOAgkQx5zHYikWCyNwAA\n", + "SAuXqlu4EgUAAOCAIgoAAMABRRQAAIADiigAAAAHkUwst5m0azshe9Eisw4cGhoyYlpTmJZHQUGB\n", + "1XbHxsasltPY5qJNw9amPmtT1ktLS42YNlHXNpcwkIvONpfc3Fyr9U1OTqY8l1SLSx4i9rls2bLF\n", + "an3Hjx+3Wu799993ziUMQXKxnRKuTc0OksvnPvc5q/X96le/slru0KFDzrloamtrrZY7c+aM1XLp\n", + "eL5UV1cbsY9//ONGTJuK/rOf/cw5l7lwJQoAAMABRRQAAIADiigAAAAHFFEAAAAOImksv9iaNWuM\n", + "2BVXXGHEtGavV155xWsus7OzXtcXxMzMjFVMozWRZ4rVq1cbsUceecTqtdpy586dC5zT71u+fLnV\n", + "cidPnvS6Xa1hfP369Vavfeutt7zmAtPBgwetlhsdHU1xJtEpKyszYgMDA0bMtmHct+9///uRbFez\n", + "YsUKI7Zp0yYjpt3ktHv37pTkFAfa+dLW1hZ+Iv+HK1EAAAAOKKIAAAAcUEQBAAA4oIgCAABwEIvG\n", + "8iB6enq8rk+b/h0VbWp7fn6+EdMaC8NoTt22bZvVcj/+8Y+N2MjIiO90IqFNldemxceddl6Nj49H\n", + "kEnm6u/vt1rOdvI8otPc3Gy1nDax3Jb2/tNuGMqUz1JbU1NTRkz7jgkLV6IAAAAcUEQBAAA4oIgC\n", + "AABwQBEFAADgIJHUxoCncoOJRJibO0/7NeOei9ZgWlJSYsS0hlXbyeZB9ovvxvJ0PEYa7Rhp6xse\n", + "Hk55LgUFBUZMu3nCdlJ/XI5RXPIQIZe5ZEou2ntoy5YtVq996aWXvObyqU99yuq1x48fN2IHDhzw\n", + "motvcc4lkUio+YlwJQoAAMAJRRQAAIADiigAAAAHFFEAAAAO0mpiuTZVWWuInZycDCOdlNN+D98T\n", + "2oPYt2+fEauurjZi5eXlRiyTp+wODQ1FncJ52jR7xIf2mZadbX4sa02t6fgeqqioMGJ9fX1et+G7\n", + "GVnb93H6jtHOIYSHK1EAAAAOKKIAAAAcUEQBAAA4oIgCAABwENvG8ubmZiOWk5NjxLTG2aNHj1pt\n", + "o6qqyogNDAxYvXZ6etpquUzW1NRkxG6//Xar1/7N3/yN73RiQ2uk16bKLzSVlZVWy/X29qY4k2ho\n", + "58WGDRusXtvR0WHEbD/n4k5rBNc+6zVag3deXl7gnH7f+Pi4EXv33Xe9bsOWdh5o++rgwYNet6tt\n", + "Y2pqynl9UU0iTwWuRAEAADigiAIAAHBAEQUAAOCAIgoAAMBBIqmNY03lBhMJdQIsAABA3FyqbuFK\n", + "FAAAgAOKKAAAAAcUUQAAAA4oogAAABxEMrHcZlppdraZmu3Eco3WFGY7NXXlypVGTJs+fOLECSPW\n", + "09PjNZcgcnNzjdjExEQkuWii2i+aTMll/fr1VstpE5i191Zc9ktc8hAJlkt+fr4R0yZBz8zMeM2l\n", + "oKDAan1ZWVlWyw0PDzvnom3jox/9qNV2z5w5Y8Teeecdr7kUFRUZMe27SHvahfZki3Q8dxsbG63W\n", + "19DQYLXcK6+8YpWLdjy02kCbXF9WVmbEbJ9IMp+b37gSBQAA4IAiCgAAwAFFFAAAgAOKKAAAAAeR\n", + "NJb7pDVLa01mQTQ3NxuxZcuWGbHx8XEjpjWWR8X3fgFgT/usWrFihdVrDx06ZMSCPPnBtuFZu7nA\n", + "dxN0TU2NEWtqarJ6bV9fn9dctEZ/ral/cHDQ63ZtlZSUWC03NDTkdbttbW1Wy2lN30HMzs4asbq6\n", + "OqvXFhYWGjGt2fzkyZPzT+z3cCUKAADAAUUUAACAA4ooAAAABxRRAAAADmLbWK41PmqxONGa4OJE\n", + "a2xdaLTGTN9NmHHy1ltvGTGtmXnJkiVG7L333ktJTguVdmNHb2+v1WuDNJFrFi0y//0cZCq6b8eP\n", + "HzdixcXFKd8udIsXLzZiWpO29h2tHcsgtO8x7WYH7QkimqDN8FyJAgAAcEARBQAA4IAiCgAAwIFz\n", + "EbVjxw5Zu3atXHnllfLZz35WJiYmpLe3V1paWmT16tWydetW6e/v95krAABAbCSSDl2CbW1tcvPN\n", + "N8vhw4clLy9PPvWpT8ltt90m77zzjlRXV8vDDz8sTzzxhPT19cnOnTsv3KDnabe2tF8zTrlojZ6+\n", + "Gzi1hryJiQkjFqf9Qi7+c1m3bp3Vcm+//XbKc3EVlzxEyGUunLe6TMmlqKjIiI2MjKQ8F227Gp+5\n", + "JBKJOb+Pna5ElZaWSk5OjoyOjsr09LSMjo7KkiVLZPfu3bJ9+3YREdm+fbu88MILLqsHAACIPaci\n", + "qrKyUr785S/L8uXLZcmSJVJeXi4tLS3S3d19/rk2dXV10t3d7TVZAACAuHAakPDee+/JN77xDWlr\n", + "a5OysjL54z/+Y/ne9753wTKJRCKyS5QAAAAuWltbpbW11WpZpyLqwIEDcsMNN0hVVZWIiHzyk5+U\n", + "X/ziF1JfXy9dXV1SX18vnZ2dUltb67J6AACASGzevFk2b958/ufHH398zmWdiqimpib5u7/7Oxkb\n", + "G5P8/HzZu3evXHfddVJUVCS7du2SRx55RHbt2iV33nmny+rTQkFBgdVyY2NjVstpV+18N5ZrE5N9\n", + "a2xstFqura3N63YX2iTyIE6fPh11CsAlrVy50oiVlpZGkAnmEqRxO5M4FVFXX321fOELX5BNmzbJ\n", + "okWLZOPGjfInf/InMjQ0JPfcc4889dRT0tjYKM8//7zvfAEAAGLBacRBoA2m4a2cmiBXorRcsrKy\n", + "jFgYz+LzvV+CXIkKkovvK1GZchuyprKy0mo57blucdkvcclDhFzmEiQX7UqUbXvI/v37vebiG7no\n", + "FtSIAwAAgIWOIgoAAMCBU08U/AvjT3eZYsmSJUZMazo9evSoEcuU/aztg4qKCiOmXdLW/pSq/RlW\n", + "20YQ2sR8jesNEL4nKAdRVlZmxPLz842Ydsy0Pxv09PRYxWxpT0jQjs/4+LjzNoJYsWKFEdNyHhgY\n", + "CCMdxIjvP+cF/fMlV6IAAAAcUEQBAAA4oIgCAABwQBEFAADgIJI5USFvEgAAwAlzogAAADyjiAIA\n", + "AHBAEQUAAOCAIgoAAMBBJBPLXSeElpeXGzFtou7U1JQRm56e9pZHUOn40Mcw2OaiTS6+6qqrjNjw\n", + "8LARO378uHMuvh8SrU2I1qZ12+6X4uJiq+1qv4dmcHDQiGm/r+35cuedd1ot97Of/cyIXfww5HQ8\n", + "b7Oz7T5utc+qILlo0/xtPzc12nmmncvaRPW4H6MwBMklyAPefefim20uy5YtM2JVVVVG7Ny5c0ZM\n", + "e6j66OioVS5z4UoUAACAA4ooAAAABxRRAAAADiiiAAAAHETSWH4xrVFY09/fn+JMRPLy8pxfOzEx\n", + "4TGTeNEa/LSGVc3AwIDXXHJycozY8uXLrV5r21iuCdJErtGayIOoqKgwYl/60pesXvuXf/mXXnMJ\n", + "orCw0IhpDaGppn0uBTkHtIbxpqYmq9ceOXLEebtDQ0POr9VoN2xkspUrV1otF+SzxdaSJUuslrNt\n", + "LE9HXV1dRizKp6BwJQoAAMABRRQAAIADiigAAAAHFFEAAAAOYtFY7rthNwhtmrMW890UHHda4542\n", + "0ToMWgP/2NhYBJnES1lZmRG75pprIshE98ILLxix/Px8I6ZN045ClM2qiI8wGsZt7d+/P+oUIqdN\n", + "1j99+rTVa1PxnuZKFAAAgAOKKAAAAAcUUQAAAA4oogAAABwkkiF3T2qTr8Og/ZrkQi5zyZRcPvzh\n", + "DxuxmZkZI3bgwIGU5+JTXPIQyZxcfDf5Z8p+8Y1cdLa5ZGfb3Q+n3bCmbcMmlkgk5mxK50oUAACA\n", + "A4ooAAAABxRRAAAADiiiAAAAHKR9Y3leXp4R0yZap2MDXRgyJZfi4mIjpjUWjo6OpjwX38glvnmI\n", + "ZE4u2k0IJSUlRkybDn3o0CGvudDkHo50zKW8vNxqff39/d5yobEcAADAM4ooAAAABxRRAAAADiii\n", + "AAAAHNiN/vTs4mYxrWFr06ZNVusaHh42YkeOHHFLDGlLa0TVaM2pWgN6psjJyTFiU1NTEWSSerY3\n", + "mdiqrKwMkk5s2J4D9fX1RmzJkiVGTJt4rzWWBzE9Pe11femotLTUarmhoSEjpp27Id9DljJBGsZT\n", + "gStRAAAADiiiAAAAHFBEAQAAOKCIAgAAcBDJxPJMaXADAACZjYnlAAAAnlFEAQAAOKCIAgAAcEAR\n", + "BQAA4CAWE8ubmpqsXtfb22u1nDaNV3vtxXmERWtQs81l69atVsu9/PLLKc/FtyC5ZGVlWS2nTVv2\n", + "nYtvmZzLQw89ZLXc17/+dac8cnNzrdZfUVFhxLRz6vTp00YsyD65/vrrrZZ79dVXrZazzaWkpMRq\n", + "fdo0bFtB9stHPvIRq+WOHTtmxM6cOeM1F9+C5KJNkM/ONr/GBwYGrGJB3kcbN240Yl1dXVYx7ckR\n", + "vo9RcXGxVUzLbz43v3ElCgAAwAFFFAAAgAOKKAAAAAcUUQAAAA4iaSy/WF9fnxG77bbbrF77n//5\n", + "n0ZMa6DLFAcOHIg6hfM+8YlPWC33X//1XynOZOHRGi5tmyGXLl1qtVxHR8e8coqjyclJq+VuuOEG\n", + "q+U4l4MpLS01YoODgxFkkp60GxvKyspSvt2WlhYj9pWvfMXqtX/1V39lxH70ox8553LVVVcZsbq6\n", + "OiM2OztrxH75y186b3cuXIkCAABwQBEFAADggCIKAADAAUUUAACAg1g0lnd3dzu/NpObyDW2U9vD\n", + "oE3KjYrtJHLEy8WTyH2znXisTVAOw2uvvRbJduczkTkK+/fvt1oujN9j3bp1Vsu9/fbbKc5EF/fv\n", + "wIKCAq/rKywsNGK2x+iNN97wmosIV6IAAACcUEQBAAA4oIgCAABwQBEFAADgIJEMucPQttHTN+3X\n", + "JBdymQu56OKSi20etrkF+RgMsk+ysrKslrO9ccI2F9tm37GxMavlguSiKS8vN2Ja87/tDQFBcvHd\n", + "WB6X95BIsPPlgQceMGLazUY//elPjdjrr7/unIs2nfzyyy83Ytq58dZbbxkxzcW5JBKJOT8juBIF\n", + "AADggCIKAADAAUUUAACAA4ooAAAABzSWR4BcdOSiI5do8qioqDBifX19keRiK4xc6uvrjVhXV5fX\n", + "XDZu3Gi13OHDh42Y1gy/0I6RrSC55ObmGjGtwVvz7rvves3FNxrLAQAAUowiCgAAwAFFFAAAgAOK\n", + "KAAAAAfmeNEQ5OTkXPCz1qCmGRkZSUU6saBNLradUoxwaOfp5ORkBJmILFpk/vtndnbW6rV5eXlG\n", + "LD8/34gNDAzMP7H/43sits8GU+131aYbFxUVGTGtsTyTaU3ksFdZWel1fdr7IOR7wy5J+44eHBx0\n", + "Xl+Q3zfIZ+R8cCUKAADAAUUUAACAA4ooAAAABxRRAAAADiKZWB6nRjgAAIC5MLEcAADAM4ooAAAA\n", + "BxRRAAAADiiiAAAAHEQysbywsPCCn22nFgehNYX5nII8H+Sis81l48aNVus7duyY1XJDQ0POudgq\n", + "KSmJTS5BpuPb5qJNC9amN587d85qu655aLRJ5BrbJyQEyeX++++3Wu6pp55KeS7aJHvNxMREynPx\n", + "LUgupaWlRkybfD08POw1F+09tHjxYqttdHR0eM0lO9ssFRoaGoxYV1eXEdOeBhAklzDM5+Y3rkQB\n", + "AAA4oIgCAABwQBEFAADggCIKAADAQSSN5RfLycmxWm5qairFmei0Bj+N1mwI/44fP261nNboGdW0\n", + "fK1hPCq2TeRB+H4v2H5GpJuCgoKoU0BMae8h24Zx32pqaiLZbjrgShQAAIADiigAAAAHlyyi7rvv\n", + "Pqmrq5Mrr7zyfKy3t1daWlpk9erVsnXrVunv7z//33bs2CGrVq2SpqYmefnll1OXNQAAQMQuWUTd\n", + "e++9smfPngtiO3fulJaWFjl69Khs2bJFdu7cKSIihw4dkueee04OHToke/bskQceeIAeIQAAkLEu\n", + "2Vj+R3/0R9LW1nZBbPfu3bJv3z4REdm+fbts3rxZdu7cKS+++KJ85jOfkZycHGlsbJSVK1fK66+/\n", + "Ltdff72x3osnlMe9aZRi0H5Srjax1ncz9+DgoNVy2mRuTZBGa+3cveuuu6xe++///u9ec4k71+nk\n", + "In7fg7aTyMNge5OEdp75vtHGdhL5QmP7eRMn2vT5IMe3r6/Pajnb6eSZZN49Ud3d3VJXVyciInV1\n", + "ddLd3S0iIqdPn75gDHxDQ0NkdxIAAACkWqDG8kQiccln20T13BsAAIBUm/ecqLq6Ounq6pL6+nrp\n", + "7OyU2tpaERFZunSptLe3n1/u1KlTsnTpUn+ZAgAApFhra6u0trZaLTvvK1Hbtm2TXbt2iYjIrl27\n", + "5M477zwff/bZZ2VyclJOnDghx44dk+uuu26+qwcAAIjM5s2b5bHHHjv/v0u55JWoz3zmM7Jv3z45\n", + "d+6cLFu2TP72b/9WHn30UbnnnnvkqaeeksbGRnn++edFRKS5uVnuueceaW5uluzsbPnOd75j/ee8\n", + "IA2SUTWlFxUVGTGt+fXiJvp01dvba7VcVBPBNWHcEBDk/Lv88suN2HvvvRcknYyVqQ33F9/9LEIb\n", + "BILzfZOA9tSO5uZmI6Z95mqfaQMDA34Si4FEMuRvPd8fELZfYpOTk15zCVJEabs8qg9O21y0uz00\n", + "Qd68vveL7Wu17drmUlhYaMS2bdtmtd0DBw4YMe0DRzuv4n6+LJQ8RNLzvA0DuejSMRftc853ERXn\n", + "/ZJIJOa8QMDEcgAAAAcUUQAAAA4oogAAABzMe8TBQrRy5UojVlVVZcS0qa5Hjx71msv69euNWE1N\n", + "jRHTesB+N2neRTpOM46qyb28vNyILV++3Ihp59B3vvOdlOSE9BGnmzOAuZSUlBix3NxcI6Z9d2RS\n", + "YzlXogAAABxQRAEAADigiAIAAHBAEQUAAOAgksby4uLiC37WBlLaTigOMu3c1sX5zmVkZCTFmYhU\n", + "V1cbsbKyMiN29uxZ521oA86CNLv6Xl+cjI6Oel1fpuyXKGjvU+0GCy0GfXCxFhsfHzditk8H0D4L\n", + "bAcX277XbD+vYU9rIl+7dq0Rq6ystHrtO++84yexGOBKFAAAgAOKKAAAAAcUUQAAAA4oogAAABwk\n", + "kiF3sl7qacgAAABxcqm6hStRAAAADiiiAAAAHFBEAQAAOKCIAgAAcBDJxHJtam2qaU1hWh7l5eVW\n", + "6+vv7095LraWLl1qtVxHR0fKcwlCy2XRIrPOz8rKct6Gtj5tgnXc90vcc9EmF2t6e3tTmsfGjRuN\n", + "mDbhf2BgwGq7b775pnMuGt/7SctFe7/YThi3lZeXZ8S0yebafqmvr7faxoc+9CGr5fbv32/E0vE9\n", + "VFBQYLU+7YkfQXLRtqs9GUR7eoaWy+DgoHMucTpGc+FKFAAAgAOKKAAAAAcUUQAAAA4oogAAABxE\n", + "0lgeZ1qTMUSuuuoqI/alL33JiJ07d86IPfLII87b1Rr8pqenrV6bnR3N6V1RUWHE+vr6Ur7dyy67\n", + "zGo520bPIDnffPPNVst1dXVZLffKK6845aE1gmvWrFnjtP65aDcw+G7mzsnJsVquoaHBiJ08eTKS\n", + "XDS2Tf3pKMhNMEEaxoPQbgiw/T2CnAdB3HjjjVbL7du3z/u2uRIFAADggCIKAADAAUUUAACAA4oo\n", + "AAAABzSWX2R0dDTqFOZNm0QelaiauVesWGHEtCbHI0eOpDyXMJrI425mZibqFObl3XffjWS7rhPb\n", + "ReY3VTnOioqKjFhVVZURO3XqlBHz3SDvW7q9D+ai/R7d3d0RZBI/XIkCAABwQBEFAADggCIKAADA\n", + "AUUUAACAg0Qy5O7ERCIR5ubO035NcgmWS15enhHTGhBtJ4wHyaWmpsaI5ebmGjHbJvx0PEbV1dVW\n", + "69OmyvvOpbGx0Wp9/f39RkybsP3+++9f8LM2dT3uxycMWi5ak3aQhvYguWj7JT8/34iVl5cbMW2C\n", + "t+20c9/HyPYGGu2zL+7nC7mYuSQSiTlv5OBKFAAAgAOKKAAAAAcUUQAAAA4oogAAABwwsRzOJiYm\n", + "ok7hvLNnz0adAn5PW1ubEdOahZcsWWLEtEbozs5OL3ktRGE0kQcxPj5uxLq6uiLIxJ72NASN7U01\n", + "SF9ciQIAAHBAEQUAAOCAIgoAAMABRRQAAICDWDSWL1pk1nJZWVlGbGpqKox0gLQUZBJ5ENr0Zq2h\n", + "dqLs8QcAAAYuSURBVHJy0mp92k0CPT09H/g6rdnX9jMjyGs19fX1Rmx2dtaInTlzxmp92jR67ekA\n", + "moKCAiOmTf8OQrtpIAjtaQO254+t2tpaI2Z7PGz3X2Vl5bxy+iBFRUVGTNsvfFeGhytRAAAADiii\n", + "AAAAHFBEAQAAOKCIAgAAcJBIJpPJUDeYSEjImwQAAHByqbol0itRra2tUW4eF+F4xAfHIl44HvHC\n", + "8YiPhX4sKKJwHscjPjgW8cLxiBeOR3ws9GNBTxQAAIADiigAAAAHoTeWb968Wfbt2xfmJgEAAJzc\n", + "eOONc/7ZMvQiCgAAIBPw5zwAAAAHFFEAAAAOKKIAAAAcRFJE7dmzR5qammTVqlXyxBNPRJHCgtbe\n", + "3i433XSTrF27VtatWyff/OY3RUSkt7dXWlpaZPXq1bJ161bp7++PONOFY2ZmRjZs2CB33HGHiHAs\n", + "otTf3y933323XHHFFdLc3CyvvfYaxyNCO3bskLVr18qVV14pn/3sZ2ViYoLjEaL77rtP6urq5Mor\n", + "rzwfu9T+37Fjh6xatUqamprk5ZdfjiLlUIVeRM3MzMif//mfy549e+TQoUPyzDPPyOHDh8NOY0HL\n", + "ycmRr3/96/LOO+/Iq6++Kv/0T/8khw8flp07d0pLS4scPXpUtmzZIjt37ow61QXjySeflObmZkkk\n", + "EiIiHIsIfelLX5LbbrtNDh8+LAcPHpSmpiaOR0Ta2trkn//5n+XNN9+U3/zmNzIzMyPPPvssxyNE\n", + "9957r+zZs+eC2Fz7/9ChQ/Lcc8/JoUOHZM+ePfLAAw/I7OxsFGmHJxmy/fv3J2+55ZbzP+/YsSO5\n", + "Y8eOsNPA7/n4xz+e/NGPfpRcs2ZNsqurK5lMJpOdnZ3JNWvWRJzZwtDe3p7csmVL8ic/+Uny9ttv\n", + "TyaTSY5FRPr7+5OXX365Eed4RKOnpye5evXqZG9vb3Jqaip5++23J19++WWOR8hOnDiRXLdu3fmf\n", + "59r/X/3qV5M7d+48v9wtt9yS/MUvfhFusiEL/UpUR0eHLFu27PzPDQ0N0tHREXYa+D9tbW3yq1/9\n", + "Sj784Q9Ld3e31NXViYhIXV2ddHd3R5zdwvDQQw/J1772NVm06P+/HTkW0Thx4oTU1NTIvffeKxs3\n", + "bpQvfvGLMjIywvGISGVlpXz5y1+W5cuXy5IlS6S8vFxaWlo4HhGba/+fPn1aGhoazi+3EL7fQy+i\n", + "fvfnCkRveHhY7rrrLnnyySelpKTkgv+WSCQ4ViF46aWXpLa2VjZs2DDnU8I5FuGZnp6WN998Ux54\n", + "4AF58803paioyPhTEccjPO+995584xvfkLa2Njl9+rQMDw/L9773vQuW4XhE64P2f6Yfm9CLqKVL\n", + "l0p7e/v5n9vb2y+oXBGOqakpueuuu+Tzn/+83HnnnSLyv/+i6OrqEhGRzs5Oqa2tjTLFBWH//v2y\n", + "e/duufzyy+Uzn/mM/OQnP5HPf/7zHIuINDQ0SENDg1x77bUiInL33XfLm2++KfX19RyPCBw4cEBu\n", + "uOEGqaqqkuzsbPnkJz8pv/jFLzgeEZvr8+ni7/dTp07J0qVLI8kxLKEXUZs2bZJjx45JW1ubTE5O\n", + "ynPPPSfbtm0LO40FLZlMyv333y/Nzc3y4IMPno9v27ZNdu3aJSIiu3btOl9cIXW++tWvSnt7u5w4\n", + "cUKeffZZufnmm+W73/0uxyIi9fX1smzZMjl69KiIiOzdu1fWrl0rd9xxB8cjAk1NTfLqq6/K2NiY\n", + "JJNJ2bt3rzQ3N3M8IjbX59O2bdvk2WeflcnJSTlx4oQcO3ZMrrvuuihTTb0oGrF+8IMfJFevXp1c\n", + "sWJF8qtf/WoUKSxoP//5z5OJRCJ59dVXJ9evX59cv3598oc//GGyp6cnuWXLluSqVauSLS0tyb6+\n", + "vqhTXVBaW1uTd9xxRzKZTHIsIvTWW28lN23alLzqqquSn/jEJ5L9/f0cjwg98cQTyebm5uS6deuS\n", + "X/jCF5KTk5McjxB9+tOfTi5evDiZk5OTbGhoSP7Lv/zLJff/V77yleSKFSuSa9asSe7ZsyfCzMPB\n", + "s/MAAAAcMLEcAADAAUUUAACAA4ooAAAABxRRAAAADiiiAAAAHFBEAQAAOKCIAgAAcPD/ADWWZox7\n", + "IqDoAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAJPCAYAAACgtar/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ni4iIiEgxDlhEREREinHAIiIiIlLsO5hP7FaK+KtUAAAAAElFTkSuQmCC\n", - "text": [ - "" - ] - } - ], - "prompt_number": 16 - }, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['pool5'].data[0]\n", + "vis_square(feat, padval=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first fully connected layer, `fc6` (rectified)\n", + "\n", + "We show the output values and the histogram of the positive values" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlgAAAJPCAYAAACgtar/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3XucFNWd9/FvK+zmyQoGjAysmMUgBAWEiSZmEzVDcMhV\n", + "g4svozE4j5dsHvPkoibe4maDuegYV101vjbGNT6sPjFhn2yQZBUjwfaCAYxCYryEKKCAMxN0RG4i\n", + "MFPPH2MPPT3V3XU5p+pU9ef9evFipqfqnFNVp6p+fc6pUwXP8zwBAADAmP3SLgAAAEDeEGABAAAY\n", + "RoAFAABgGAEWAACAYQRYAAAAhhFgAQAAGBYowNqyZYtOPfVUHXHEETryyCO1YsUKdXd3q7W1VRMn\n", + "TtSsWbO0ZcsW22UFAADIhEAB1le/+lV94hOf0LPPPqs//OEPmjRpktrb29Xa2qo1a9Zo5syZam9v\n", + "t11WAACATCjUm2j09ddfV3Nzs9auXTvg80mTJumhhx5SU1OTOjs71dLSoueee85qYQEAALKgbgvW\n", + "unXrdPDBB+vss8/We9/7Xn3+85/Xjh071NXVpaamJklSU1OTurq6rBcWAAAgC+oGWHv37tWTTz6p\n", + "L37xi3ryySf1N3/zN4O6AwuFggqFgrVCAgAAZMmQeguMHTtWY8eO1fve9z5J0qmnnqqrr75ao0eP\n", + "Vmdnp0aPHq2Ojg6NGjVq0LqHH364XnjhBfOlBgAAMGz8+PF6/vnnjaRVtwVr9OjROvTQQ7VmzRpJ\n", + "0pIlSzR58mSddNJJmj9/viRp/vz5mj179qB1X3jhBXme13D/vvWtb6VeBrab7Wa72W62m+1mu8P9\n", + "M9koVLcFS5JuvvlmnXnmmdq9e7fGjx+vO+64Qz09PTrttNN0++23a9y4cVqwYIGxQgEAAGRZoABr\n", + "2rRpevzxxwd9vmTJEuMFAgAAyDpmcregpaUl7SKkgu1uLGx3Y2G7G0ujbrdJdefBipV4oSCLyQMA\n", + "ABhjMm6hBQsAAMAwAiwAAADDCLAAAAAMI8ACAAAwjAALAADAMAIsAAAAwwiwAAAADCPAAgAAMIwA\n", + "CwAAwDACLABoAB0d0iGHpF0KoHEQYAFAA1izRnr55bRLATQOAiwAAADDCLAAAAAMI8ACgAa3cyfj\n", + "swDTCLAAoMG9+irjswDTCLAAAAAMI8ACAAAwjAALAADAMAIsAAAAwwiwAAAADCPAAgAAMIwACwAA\n", + "wDACLAAAAMMIsAAAAAwjwAIAADCMAAsAAMAwAiwAAADDCLAAAAAMI8AC0LCWLJH+9V/TLgWAPCLA\n", + "AtCwLr9cuvDCtEsBII8IsAAAAAwbEmShcePGafjw4dp///01dOhQrVy5Ut3d3frMZz6jF198UePG\n", + "jdOCBQv0jne8w3Z5AcCYQiHtEgDIq0AtWIVCQcViUatWrdLKlSslSe3t7WptbdWaNWs0c+ZMtbe3\n", + "Wy0oAABAVgTuIvQ8b8DvixYtUltbmySpra1NCxcuNFsyALCMFiwAtgRuwTrxxBN1zDHH6LbbbpMk\n", + "dXV1qampSZLU1NSkrq4ue6UEAAsIsADYEmgM1rJlyzRmzBht3rxZra2tmjRp0oC/FwoFFbhSAUAm\n", + "cfkGzAsUYI0ZM0aSdPDBB+uUU07RypUr1dTUpM7OTo0ePVodHR0aNWqU77rz5s3r/7mlpUUtLS2x\n", + "Cw0AMKdiBAjQMIrFoorFopW0C17l4KoKO3fuVE9Pj4YNG6YdO3Zo1qxZ+ta3vqUlS5booIMO0qWX\n", + "Xqr29nZt2bJl0ED3QqEwaOwWAHM8T9pvP26QUX3gA9KKFQP336239s2NtXNneuWy4aGHpJYW/7qy\n", + "YYP0rndRjwCTcUvdFqyuri6dcsopkqS9e/fqzDPP1KxZs3TMMcfotNNO0+23394/TQMAZIlf19jy\n", + "5dIbbyRfFgD5UjfAOuyww7R69epBn48cOVJLliyxUigAAIAsYyZ3AA2Lwd3Z8dJLaZcACIcAC0DD\n", + "IsDKBs+T/u7v0i4FEA4BFgAAgGEEWECG8dQXALiJACtnNm5MuwRIA4EWALiFACtnDj1UevzxtEsB\n", + "ZANjsADYQoCVQ9u3p10CIBsIsADYQoAFAHBaqQucrnBkCQEWgIaV1RasrVvTLoF5y5YRQCFfCLAA\n", + "IEOefFI68MC0S2Heccf1vRMRyAsCLAc98kjfP6Aeuk7Mc31fdnebT9OVljzX9z0QRt13ESJ5J5zQ\n", + "9z8XGwCV9rPwtZhrDWAeLVgAGpZfy40rrTnVuF4+AH0IsAA0rCwGKzZasACYx6kKABmSxaAwLsYa\n", + "IosIsAA0rCwGK1ksM9CICLAcxUUUgB+uDUA2EGA5Kk5TOM3ojYOuk8ZjYwwWQRtgHgEWAGSIjWCI\n", + "AB0wjwArh/g2CgSTxXOFpwiBbOBUdVQWL/xA1mTxPMtimeOihQ1ZRICVQ3v2SDt2pF0KADY0YoBV\n", + "QqCFLCHAyqHzz5cOOCDtUgDuy2KwksUyA42IACuH1q5NuwRICt/ozXN9nzIGC8gGTlUgB1wPClyV\n", + "xdYgG2XO4n4AXEeABQBlXA82aMECsoFTFQAypBHnwXK9fIAfAiwH/Pa30m9+k3YpgMbjemuVnyyW\n", + "2RQCLWTJkLQLAOljH5O2bh148WjkiyiA6qJeGwhOgGTRguUoLobJevNN6amn0i4FkpbFLzKMwQKy\n", + "gVMVkHT99dJRR6VdivAIxM1zfZ9GDQqzGEwCWUaABUjauTPtEsTjelDgqiwGHY0+TcN73iPdcEPa\n", + "pQDqI8BCKJ2d0rp1aZcCsCdLwUYjWrNGWrIk7VIA9SUaYF13nTRnTpI5ZperF/mZM6V3vzvtUgAw\n", + "yfUWUNfLB/gJFGD19PSoublZJ510kiSpu7tbra2tmjhxombNmqUtW7YEyuw//kP6r/+KXlikb+vW\n", + "tEsAE7ZvlzZsSLsU6XP1i0wtjRxsNPK2I3sCBVg33nijjjzySBXeuhq1t7ertbVVa9as0cyZM9Xe\n", + "3m61kADM+vznpXe9K+1SAEB+1Q2wNm7cqHvvvVfnnXeevLe+PixatEhtbW2SpLa2Ni1cuNBuKeGM\n", + "LH7jz7Oo3+hfecVsObLKrz7TSgLAhLoB1oUXXqhrr71W+5VNvtLV1aWmpiZJUlNTk7q6ugJlxs0Z\n", + "sIOgIJosXpOyWGagEdWcyf1Xv/qVRo0apebmZhWLRd9lCoVCf9ehn3nz5vX/vH17i6SW8KUEAFhD\n", + "0NbYCgVp9Wpp2rS0S5K8YrFYNb6Jq2aA9dhjj2nRokW69957tWvXLm3dulVz585VU1OTOjs7NXr0\n", + "aHV0dGjUqFFV0ygPsOhJBNxAi1d1BBvuob7a99xzjRlgtbS0qKWlpf/3K6+80ljaNbsIr7rqKm3Y\n", + "sEHr1q3TT3/6U33kIx/RnXfeqZNPPlnz58+XJM2fP1+zZ882ViAAQHUEG0A2hJoHq9QVeNlll+mB\n", + "Bx7QxIkTtXTpUl122WVWCpeUQsG9mbz5Fg2bqF992A99XA3ali+XHn543++ulhPwU7OLsNyHP/xh\n", + "ffjDH5YkjRw5UksiTKXr8sVsxw7p7W9PuxT7uHohcfkYAo2gkc7BGTOkXbv6/sGuRqpXSeFVOQjF\n", + "1cCvUUU9HhzHPkzTAMAWAiwHcEFHXDbr0DXXSD099tJPE9/aAdhCgOUoVy/8rpYL9lx2Wd9LvhtF\n", + "I9bxRtxmwDYCLAdwcUPS8lbnAr4ONRcascW7EbcZ2UeAFcCPf5y/G1JU7Ae4ZudOacSItEuRvEYM\n", + "Ohpxm5PCtd28RAOsrB7Ap55KPs9GuJB0dkrbtqVdisaUp/q1Z0/0dbN6TTItT/UBcAUtWAFw8bFj\n", + "zBjptNPSLoV9vb3Sn/5kJ23qZjw8RYioli+XNm9OuxRwGQFWiv76r6U//tH/gp6lb9azZ0t/+Uuw\n", + "Ze+4Qxo/ft/vjTB4+j//U5o0Ke1SAAjr29+W/umf/P/2938vffnLyZYH2UKAlaLduwd2P86eLa1Y\n", + "kXw5/uqvpOefj77+PfdIjz8ebNklS6S1a6Pn5apt26SHHtr3e/m7Q7dvt58/rS7RZOmLDJL3ne9I\n", + "3/te9b9z3qEWAiwHlC7y99wT/YXYmzZJL70Ubd09e6Rnn422bpYVCtLvf28mre9/Xyq9L7S7u28G\n", + "amST60GXjZt6I24zBnK9DmQRg9xz4uijpQkT7Odj6hiedZaZdKK66qq+/6MGpZV6e/f9zM0ASaCe\n", + "2cc+Rhy0YDkqbCDz+ut9XY62xb3glNa/8874ZYnjmmvspc1FGbCDcwtZQoAVgO2T2i99LiSAfXFb\n", + "ZDdv5lwF4K9hA6xXX5WuvjrtUtj19NPS5ZebTTPuDYluYrO4uccTd5qGUaOk//gPc+VJC/UIMK9h\n", + "A6yFC6VvfCPtUvQxEXT4XSB//GOpvT1+2ib85S/Sb37DhRz5E3SKEiTLxAvKG+l6xZdf8xjk7ihX\n", + "91XUcl1+uXTiiWbL4qo0LsqNdCMwydXzrBaOdX3r10tDhvRNZPzDH6ZdmnR4nrR1a9qlaGwN24KV\n", + "N1m8UWTNo4+ynxtBVo6xyUDL9W0Ou62vvtr3/3/+pzR/vvnyZMEdd0gHHph2KRpbwwZYQS4opSZm\n", + "vjHu08j7Iug7KYPsow0b3L+pAa5p5OtPWBs2pF0CpBpgvfFGMlMLRPH0031NzEnI0kVj/fq0S2BW\n", + "WkHOyy+nk29JluqcTQS5AGxJNcA67DDp1FPTLEF1WXtHHjfMaLK+38rL/+tfS9Onp1eWvMh6nciT\n", + "tI9FGvl/97vSsGHJ5wvzUg2wurqCd7vkGd+iYcL99wd/9U+Sde6NN6S2tuTyC4NzD65ZsSKZ95dW\n", + "4lwwr2GfInSpLCZkZXvS/kaahEbYxjDWrs3HXFHVJH3uleqXyXpWLa0XX0z32pKV6xrgp2EHuddT\n", + "fsHhhplfebmAh62j1Ok+tuagywu/Ob56eqS/+7tky5HnfYz8Sj3A4sRpLK4FNHmqf3naljS5VkeT\n", + "EGabd+8295J0DMZ5nB+pB1iuSvIia+KE4qSEq4LWzWIxm/W4EQOypFTWh6TrRxbrI9yReoDlysXp\n", + "0kvTLkFjaIQLVlrbGOZccuW8KzdjRvIPvbi4H/LsjTeCP4jRqEzUyXXrpNdeSz5fDMQg97fcccfA\n", + "35O6SRYKZvaLS/s2S7K+34KMFezpkZ57rvp6toXZxy4E4C6UIa+uvTbcVCJZPz/T8u53SzfemHYp\n", + "kHoLVhbYvOCmcTG/6aa+l13DDtdu0D/9qXTEEenl79r+KJflG3gS+9V0Hm+8YSadLB83NA4CrCrS\n", + "PoFt5v/Vr0oXX2wvfT+u3mRdLVdYtbYjyTl1Nm+WXnghufxM27kz7RLUZ6POun4epD0WC4iCAMsB\n", + "XCySl8d9nvaXAkn69Kelww9PuxTBle+z116T/uZv7O/HQkH65S/t5pEXeTxP0TgIsKrI+4n9/PPJ\n", + "5ufCzT/vwtRZW8cjjRmoTdm1q/4yfufNxReHf7Huk08O/qxQkLq7w6VjCuene1avTjY/6oB5DRtg\n", + "uVKZXClHoyntdxv7PwvBua0y7pfzK8qECf4vqH/lFTPpb95sJp28qDw/s3BumdLcbCadmTPTC9wb\n", + "XepPEWbhhLE9yL18v2RhfyBfPE9av95MWvvvbyadpEQJsLN+jj72mNTamnYpUI3p+rV0qfTss2bT\n", + "RDA1A6xdu3bp2GOP1fTp03XkkUfq8ssvlyR1d3ertbVVEydO1KxZs7Rly5ZECpskWpbMcvWm5Gq5\n", + "gjJR/scekw47LH46UvwvUS4cDxfKEIRfOTdtkr7whdrr/fKX0pIldsoUVG+v9Pjj6ZYBsK1mgPW2\n", + "t71NDz74oFavXq0//OEPevDBB/Xoo4+qvb1dra2tWrNmjWbOnKn29vZAmfldfF0NZLIwWSSiy8pN\n", + "NAkmx01lrYswi+dbrbq7eLH0ox8FS+ePf4yXVz1HHCFdeKH/3+6/X3r/+6OnHZbnSR//eHL5xeFX\n", + "J7/5zWw84YqB6l4O3/72t0uSdu/erZ6eHo0YMUKLFi1SW1ubJKmtrU0L60yq9OCDff+7dFNz6cLq\n", + "0n6xpbS/XdvWvIzBcmW/+nURZn2G+bwp7eOpU6OtH7SuPfdc3+uP/PiNY6uVV9z63dvbF3xm1Xe/\n", + "G28GfFeuD42mboDV29ur6dOnq6mpSTNmzNDkyZPV1dWlpqYmSVJTU5O6urqqrr9nj/SRj5grcN5U\n", + "u6GEvdEEeQIK+3Ajt8OvBcvli3uWWtVtMhXIhM0PwdneZ41Y720bUm+B/fbbT6tXr9brr7+uj370\n", + "o3qw1Bz1lkKhoELAI8Mgd/+0/Qa5Z2G/wF8jH7usdREivCRvxI34FGG1bYyz7QRP6agbYJUceOCB\n", + "+uQnP6knnnhCTU1N6uzs1OjRo9XR0aFRo0ZVXe/b354nSZo3T9q6tUVSS6wCN6J586SHH+57GiSr\n", + "ShcHTvR8a9QAq5G7hU3q6ZF27Oib8LWWRryO0IJlR7FYVLFaX3ZMNS+Hr7zySv8Tgm+88YYeeOAB\n", + "NTc36+STT9b8+fMlSfPnz9fs2bOrpvHP/zxP0jzNmzdPw4e3DPp7ox7Uavz2x89/vm8cW9a5clNw\n", + "pRxxRd0OW9sfdwxW0rLaqh6Hy8fjyiulAw6ov1yej1FaxyfP+7SWlpYWzZs3r/+fSTVbsDo6OtTW\n", + "1qbe3l719vZq7ty5mjlzppqbm3Xaaafp9ttv17hx47RgwQKjhUqCKxeZQqExKrYr+xt2ZW0MlilJ\n", + "1u+4+9OF41GtDH/+c7DlksS1C1HVDLCmTp2qJ33e6TBy5EgtMTSRigsnkIv27JFWrJCOPTbtkuST\n", + "zYtmeZ1esUK66CJ7eVXLtx5b298IE4364TpmVx6CyrjqbcM//ZN02mnSUUdFS59A0rwGHTERju1B\n", + "7tV+P+44e/maVu/kzMMFLoof/UjautV+Pq7s37gXaVe2o9IjjwxuXcmqLN1Is1TWtH3ve9Jtt6Vd\n", + "CpRL/VU5nEDZ2gfVyurqjTENaR3PLNUjVwS9Jp1wgnT66fbLkxYbT665yOb2LF0qffGL9tK3jeuH\n", + "ebRglWlvl/77v5PNs3J2XtcredQLlMntuvRS6cwz46WRVKtkkjeorL2Sxk+cehJnm9askf7lX6Kv\n", + "n8Z5a+MYBknTRL5xH85w8Tp5663Sv/2bvfRtn7OuXhOyLPUWrLT4leXyy/umREjSeeclm19cLhzD\n", + "H/9Y+slP0i4FXGHixnDzzdL116dbBhOSvJ4ksc2mWtbyMIeUK3UMwSUaYPlVECpNY+0DV7Y1qUHu\n", + "ti/OLrQo1uNyy1oWp2mIWz5XAoa8MVVvsvAe3FdftVeOPKGLMABXu3lckuQgd5M3CFcDoCi4cdqV\n", + "1XMzy0zX6SjHkPNqsHe+U9q4Me1SuM96gFX+6hcGuedX6TgvWSJt21Z9OVeOdx5fSeRqS5HLL3uO\n", + "kp/fvnOlXgfhQlmT7OKLu37QdU3t16w8SPTGG2mXwH3WA6wjjrCdQ/aVn1AuXPxqqVe+1lbpX/+1\n", + "+nquXSTyIokbSBi7d0t795pJ/wMfkNavr79cmq0TjVSvXdhW16+TNriw3xGO9QBr7draf3e1v5nK\n", + "HF2j77tG335Jes97pFNPNZPWihV9/6oxvb+zcvNOu55laZB7HEHrQ9rHA+4J/LJnE7Jy4YLbTNSj\n", + "UhrUSTv7YP36fS1YeZHnG2hWuswbYUZ3VxsdEF5ig9yzULHLlVe2JOcfydp+KqFFMB3sV/Pq7dO0\n", + "x2Dl4SnCpOttEtM02NivP/yhmeCX60Q6Un+K0IWTHfFl7QTOyjf2JNjaB1nYt4zBCs/F7jmbgm6v\n", + "qf1Svs3nny/19ppNH8lJPcBKi6stLi5cUGoJUr60v+GnrZEvhGke50be77bU2qc2WlRcGHOVR0HO\n", + "y0a6Ricl9QAr6W9Df/lLevlXQ8UOJ+15sH75y76n5FziykzVcSdZjbIdrmx70ly4dtlWbRvDHrc4\n", + "LdZJ15G0jmsj1KekJToGy4WLWWdnsOVcKKuL4r5DzJWTOM7xPflkadGi6n/Pw5g6P489NvD37u7a\n", + "MzpnYdvDzM3nWh2OKkzdv/lme+XwE+eJvbFjB7/b1bSeHv/PN2+2m6/EGKwsSv1VOVkIZBppkPsf\n", + "/1j7mFT7WxaOox+br5pJ+1hW8/vfSw8+uO/3oOX80If6gqqS5mZp2jSzZctqPcqrBx5IuwQD1aqr\n", + "mzbZeYVLqU7+/vfSkCrP3Y8aJd17r9n8Ktm+nnDumZfoNA0uSHrAYtbUm7esmiSDxFoXggULpH/4\n", + "h+oXwhKbXQVJvoswisWLo69bvm0vvTT471maNDer/OrujTf23eTjplmZtq13NQYda+VSHXr55dp/\n", + "37EjmXJE4dJ+bCSJtmC5cJBLJ7ALZfGTdrnqXSSili+peac+8xnp8ceDLx+mPEmPDwqbvs3WuKD8\n", + "ypPUK3xM7Wsbx+yKK6Sf/9x8uiUXXCBddJGZtJ58Utq6te/nWnUjS19C89K9a1Pa9548Sn0erLQr\n", + "fNr5m2ByG3btMpeWnzzs73oaYRtdktQg9zj5XHWV1N5e/e833hg97bDqbfPRR/cFhEGWNa0yP1OD\n", + "3LOkcpvDBIdx7rNct8xL/SnCpAVtwUryBHbpYhFlksUgy7h28rq0z02Juk0uHZu0b+hB2NhfF1zg\n", + "RjlKXHtK1q872gULFqRdArgs9S7CtG50YQKJJG9ALt3s/LgwyN1Wl5bpNJOuN0Hzs3ms8hi4muL6\n", + "ue0n7TFYJZUPU+R5stM4g9zjXJ85d81ruBasSi+8kHYJ3Lrwxp2GISuyMB9OUlwPWOO6//5wN568\n", + "Huco0h6DZXqmfRfrZz1ZLnujy/QYrK1bpTfeiLZu6cSdODF6/ja40mVRTdxB7q6xMQbH1PHo7e17\n", + "F5lJccfYzZxpphzV2Bjk/txz0dMMkn5QrpwDYcrhSutNSSMEGUnOkF/OlfqZJ5luwfrbv5Vmzw63\n", + "jisn6Ne/nnYJ/Jk4yVzZx5K0bZu0d2/apQjmG98YOO/Qpk197yKrJeyUEP/jf0i//W31NOr5/e+D\n", + "L+uKsPXRxDhEm+LmX2v9tKZJqNZKk/a+BuLIdIC1Y4f0/PPh1nFlmobrrtv3c3lZ0r6g2Lq51Frv\n", + "pZfsHY/hw6V//ufBn9s8/lH30dVXS9dfbz/foG8ziCLufnW9BTevwjytF2Z/VxssH7dHI+qrcrLM\n", + "9hgsmNewg9zDyMPJWU9SN0a/fblhQ7y860lrnJ2r9abyWMU99mG/5LgkC9efapKY9yzu/nnmmXjr\n", + "V5OFYRGm8mMMVnal/qqcpLlQhko2m/zDpPHkk9Kdd9ZeLuoTLkm+oDntOV/SegI1LVOm1P57UhON\n", + "RknT1Bg8F45zb6/5NJMe5G47mHHhONnk6nyTjSq1Qe6liwEHfqA0v1F/7WvSQw/FTyfsDS3LrQiu\n", + "SPM82rMn/Dpvvin9+7+bLUdS+8DVa9Zf/mIuLVe2Meq1weS+SJor+x7xpdZFuP/+9vNauHDw51Te\n", + "dCTZzJ12wBZ24LltLj6ZtXy59PnPD/581qxky2Eq4HfhONtga7tst7R84hPm003r3hHm2nnLLdHz\n", + "yWsdTlPqg9xtHtRVqwZ/lnaAtXp1+nPLIJmLSZjJP22XI818w+zrzZuj5xP170n53e/MPNGaxHQR\n", + "td4dmmQ3brWnCvMcDMSZaDRsmrAr9UHuWWDygvLUU4M/i7tfTJQvaBmCPKUStjxhtz+tqSTiDOS3\n", + "xcR2BAn4bczNY1qU17uECSBMjMGq153q8ni1JPK3Lc75ktX7F9LjzESjn/2sdNxxyZUjTyeLiYkU\n", + "4z4eneQg97Rk8YaSpqSP+cc+lmx+eVKtbu+Xeh+HP9Nzm7kk7cAZ5jhz+tx/v7RsWdqlSMfWrft+\n", + "jnJTmjrVXFnqceFEdT1Yc2EfhWGrvJXp2j6/n3wyWDni8kvP9Top2W21DStoK2EW9qttJsevPvOM\n", + "tGVL/HQkaeNG6bzzzKSVV3UDrA0bNmjGjBmaPHmypkyZoptuukmS1N3drdbWVk2cOFGzZs3SlgBH\n", + "7eGH4xc4rjy2YGWBqUflTeH4J+/ll/f97EoQ6lo9CLNfdu3qexozLBeGJCA8E2OwJk+W/vf/rr1M\n", + "UPffL91+e/QyNYK6AdbQoUN1ww036Omnn9by5ct1yy236Nlnn1V7e7taW1u1Zs0azZw5U+3t7ZEK\n", + "kNYFztWLhKvlKglyvFzfhnI26l+1b5xx3wNYL88kJp7009sr/eu/xkujXNS3M9jm2jxY06dLJ54Y\n", + "fPksPB1ZbZJNU7JwbbK9z3futJs+9qkbYI0ePVrTp0+XJB1wwAE64ogjtGnTJi1atEhtbW2SpLa2\n", + "Ni30mxOhTFLdEFnNI21pzuRuK68g5QhTnrj5TpgQb31TokyuWW8//fKX5soQpVWm3JIlA4PZLM3L\n", + "FmaS3Jdf7nsq2aaknngOWs+i9kD4pdveLq1cWX/dUl5Zvg9kuexZFmoM1vr167Vq1Sode+yx6urq\n", + "UlNTkySpqalJXV1dkQqQ9IEPeoK6VCGTmlLA5vq1tsH09qUdzFdbbuNGc2Wpl1fSaYSdbNRma1Br\n", + "a/03EtQSZdoHm+fom29Kr75qL/1a0h6DZdPll0vXXptcfkFVm5oi7XtST4/02GPpliFrAgdY27dv\n", + "15w5c3TjjTdq2LBhA/5WKBRUSOlrn2tjKOJKat6ZSja7r8rl7Xi5JM0XvUad38nzzL0rsvw8CfLa\n", + "mIsvlt4aUuoMv3P9wguld77TXB5hpuVI+3y1MSdUWG+8UbssSUl7Hqz77pM+9KH46TSSIUEW2rNn\n", + "j+bMmaO5c+dq9uzZkvparTo7OzV69Gh1dHRo1KhRVdaeJ0n67nclqeWtf+ZEfVy3XoVL+2RK2mmn\n", + "SS0tZtLyOyZJXhDjTqQYV/m2ujAnVr0ns0zsg7ABVinPZcuk448fWMby8vyf/xOtPEGOwaOPRku7\n", + "Xn6m2X4ZelgmtrX8gYdytlvMsjCfWxh79vRNpWHizSj19n2UV2JlQbFYVLFYtJJ23QDL8zyde+65\n", + "OvLII3XBBRf0f37yySdr/vz5uvTSSzV//vz+wGuweZKkK66Qvve9wX91vX/bb2JQm1zdDyVZeALJ\n", + "lX1osxzX87ezAAAgAElEQVQ339w3WPXcc+3lEUati2/5fvjRj6QdO6Tm5r7fd+yone7ZZ9fP2+/m\n", + "Wf7zJZfUTyOItOpuGvmWzvMvfEG66KJg64QRNGhM81zu6Ukn3zAD/SdMkN73Puk//7N2mq5cE13U\n", + "0tKilrLWhSuvvNJY2nW7CJctW6a77rpLDz74oJqbm9Xc3KzFixfrsssu0wMPPKCJEydq6dKluuyy\n", + "yyIVIO6BNzHYsdZyzc3pV84stKZloYzlkhrkbmu/XHKJVH7KLV0afN1qYzxqLVtvPwVtwbrwwuo3\n", + "bJNsnrNJXg/++7/7/iWttI0HHjjwd9PpB/28ks3rzbJlfcHV44/bzXPIEOlf/mXw52H2zYsv9r2C\n", + "CW6q24J13HHHqbfKgIYlS5YYK0jUypt28JOELGxjvS4Zk4PcX3ml9t+THphba7mkjt2jjwYfg2Vj\n", + "/0TtIjQpzuuaqqWTtMpyf+5z9ZcJK8pTpLa5dI077jjpF7+Q3nqGy4jvflc66yzpXe/a91lPj/TE\n", + "E8HTiBOUZu0LcF4EGoOVBFdP5KRP/PITIU8nhcn9WBp0akKYffzFL5rLN6qlS6XOTv9B3GmOwQrL\n", + "xnllKrB16WafFr9uqkJBKhbDtZaaFnUsVdj1THcPfvObffvviisG/+211/qeFB092myeSF/q7yJM\n", + "Yv6lri7p5JMHliPoIPekmsbjLot90v5GZ/O4zZkjnXnmvhcbR8krrXr17W9X/5uJYQ+2AyyT++36\n", + "6/2f3K0XDJsQJ80rrpC+8x1zZaknT18yq5k1SxozZt/vYSdbzdvkz3nizLsIbXYRrlwZfiLEtOYe\n", + "SXqOnbBsTAXgUpeMSbfcEn36AhuqPTlpay6tys/++MfqX3AivghiQD6mugiD5hdn3a1bw3UPJSXK\n", + "+DwT+UTJP6jly+OnYVNnZ7DlbN+LXLrP5EXqAVbSgUzakXyUSpx2mcNKqrzjxknr1g3+PKlvdH/6\n", + "U+3A4qKLpD//OX4+Ut+4s02bBn+e1pNOcQVpqYnzUtqsnTMlSbRgRZHV/Vli60uEDUm0oCIZqQdY\n", + "cWVhlvOoablycS0X9eS3sS0vvij94Q/hy1IuTrkmTZIefDD6+mHMmCGNHTv481tuCZ9Wtf3j99qV\n", + "oF+A/FqR4ryGpqtLGjEi2LK1ypP0uiasXJn8uZ/2NpcE3e4sPhQVNW8TZTZZn66+2lxaeZf6GKyS\n", + "pE6YsGOwkpZUN0dJUpPH1dqW0ja//e3JlKXSm29Gby3xG3Af97jNmCHNnTvws2pPTpY+jxNUln6P\n", + "8w7AsNtcbzbxyhfShm2VtD2I3lYanif9/vd2yxFmXybVw5DWkIwwXPzCG5TJusu0EMGl3oLl6mDj\n", + "qOsuXy699FL1v5ueS2n79vDplbz0kvRXf2WuLCVR952ppwPDzOQu9T0d+IMfmMnbhGJRuvfe5PIL\n", + "crwql6n24uqwU1kE/cKT5NO/Lt1Ibb9pIC1Rn3hNMxAr5Rml1ViK3zrnwnFDOKkHWEnO6RJl+bD+\n", + "/u+lM86o/vegXS1B15kxI1i5/Lz2WvR1KwXdr0lcJMLmsXZt9Lx+8IO+V73EyT+OtC66zz8ffFmT\n", + "rVtB0w+bZ3mAHeUcNcX0cITu7mjrBnkQwsVz2XY6kvSlL5lLy0/YYRhB3rsZRNheHZe+iLgq9QDL\n", + "prRenGxKkAoc5kZnQtSTyuREoyaYqgeLF9d+p53tG0SQb/Qmgt8TTgiWRthv6X5PNnpe/P3m6his\n", + "MGlv3RovvQULpIMOGvx5lC7CpKR5016yRDrvvOp/T6ts9Y7BSy9JjzxSe5m8toS6zpkxWC7nGSSd\n", + "J56Qjjmm/nJpzKK8YYP0kY+YSatk8+bkx4sFlfY3K5f2hVS/26XeeCip/rvjarVwpPFFx9UxWGGU\n", + "XlMTVdDH/8sl9QRb3Hyq1dk5c/bNERc2/dtv7/tny4032kt7/fraf3ftmtQonG/BevTRvhfEmmb6\n", + "Jrx0abB5baIM9o9b1uXLzT3tVip/rYt32Jttnpna3moT35bv16g3JxPHxq/Fo6Nj8GdBylgoxJ/O\n", + "JKs3lHrBsJ84DydUk9Xz9PHHpVdfHfx5lHGGUdKoZfPmaOu9/LKZ/E3ze+oYA6UeYNU7kS++uO+N\n", + "7jbSzoo0u0sqhd2npYtDrbKYPk5Bb+K2hL3RP/JI35QTSXHhQl0ZMEZtDS2fByypACvJ7sd69XTH\n", + "Dultb6u9TNhJlqVgXYSmx4v5ycs1PIzKbZ40KZ1y1HP//WmXwH2pB1hxvzWEvQCkfcKGeVoq7bL6\n", + "CTOT+9at0iGH2C1PVC4EGSUnnCD9z/8ZbNkoT1UlOTg16VdQDRniP5mrS8c3DBMtLZVKrwkridJl\n", + "6/f3z3xG+vKXw5UlrKS6LCV3pu6xsc1hn6yGGbkbg9XTI91zT/W8077whsk/6bIWi2bTK59jK8mT\n", + "N+0LRRpBsudFf7zbRBmj1lW/Qe5hy1PqerE9JjDta0eSghyDe++V7rrLbL62u+lcffjBNhNlz/L2\n", + "pyWVFiyTj/xWXghWrpRmz/b/W1RpV6y0A4Yg6gWxJp5yi1KWtEUtS9D1qu333bulk04KlrbJbqCw\n", + "48BsdTPFeXQ9ze7FKGOwbLL1NGHS56hL14So8rANjSb1LsK4F5AgNwcbA8ejitIMHffEMrmtnOT1\n", + "2WgxrXajq1bHN2+WfvUr/7T2C3HWP/VU8GWDCHrDdqHO257w0W8wtitcP89rHd9LL00+zyzmE5ar\n", + "5XJZ6i1YYZ9gMjWpWlrC3FhsV+gbbgi/TpAyzZ8f7hU8prezVnr33y/dfffAZaLMIG/7nWkm90mc\n", + "tD7xiWDLRZ2Sodo8WNWWS0Jl/rbmmvv0p+vnbWO7g0zLEfRz00xs7513xk/DT1L7IO1jcPrp0g9/\n", + "mF7+eZJ6gOX3Wa3Xv+y/v7Rp077fXZvA0iTbFXr+/PDrBBnkvnlzuu+rqrXfzjpL+uxnBy6zYoXZ\n", + "PGwOwK01w3bUCUXTGB8XtiXXxuDvoEqvBUpiHEux2Peia5vKn7ysxnadCBpEmGpFtNXVmSelff2z\n", + "n0l33JFuWfJiSFIZhanYw4ZJu3ZJf/3X/n/fsmXf02lBbnQunVRRLlxxL3ZRAohqoowNkuyMucE+\n", + "YQK+KMFLnPyDtGrFGeTuWp3q7JRGj/b/26231l73kkvqpx93e6+4Inge9a6hSXWBpy3KpK2mubIv\n", + "EJwzLViVF1VbXYFxJzCMK0xapoKS666Lt34QccbU2P62nHRLZpgxWMuXm8vLBtvBl80HXmypV74x\n", + "YwbP/1YSdnyQK9vUCGrtgylTst8jguSlHmBVCyLCjHG55RZp2zb/v1WmFXbMV9LCPmqe1oUxqZvg\n", + "T34iffOb0fIqcfnm8fd/H2y5JFpjTaRd7/15Ns4/0/vGRNlszK6eJFcfAnrmmWDLmfbqq+Hr1wMP\n", + "9E1lEZbthyuicvWe6bLUnyKMW2k8r+/t5n4VOUrapbFDtipzmIlG8yjs9n3nO9J3v2u+HEHHAkVh\n", + "4kEFzwv2sl+/PCvVm2jU5DxYy5aFW97EPFiVacZVrzusq0vaubN2Gr//vZmypCVoF2EYxx1Xv8W2\n", + "Xj4tLdHyDrIdpq8Fn/qU9MlP1l7G7/U5NsdwxpH3e5MNqYzBCtJFmNcxO1G2JwsD+SvLsXSp9J73\n", + "RFu3FlPdnS6Ozyv32mt93RIl1QLCUlf6rl3VJ30M2n1rqy7VCp5KeW/ZMvAz0+dJGPXynjq1bxbz\n", + "n/60+jqnnOJW3frCF4INbg8rzD4vD76D7puoD27YYKp+bdwojR3b93N3d/D14myjS3WxkaTeRVj5\n", + "WdiKECT4yGrlynL5r7lm4O+mLk5f/3r9ZZIIOoM+6p7UsSsW7XRLBX1BbdBxVlGDuSDLJ3melF5k\n", + "bZupuvyjH0m3315/ubSnCAiabxrlMZHntm3SoYfGT8eGKHM0orbUuwgrhQ20oj4uH6YymTyZw1TS\n", + "LAVWcQa5m5ZEXq4cG1vlWLKk+kBtE2oFWoWCnScdbbLVrWlj4uEwksorCw9rmLB3b/R1096GtPPP\n", + "osS6CMvV6iJ0pf/ZVmWKckGNk14WpPnNyPYYrLCqTXoa53H5KN0sra19Ew6mIc7+e+WV+sts2iQd\n", + "eGD0PBqR6etMWi1TcdK39aU7CYWC228OyKtUXvYcpIuwcpnS0yOV8tZFGGR8mgtc3qdBuu9c3KdS\n", + "31iqKNI+Hia79qPq7ZUOPrj+cmPHSm1t4dOP2loeNU3JjfmXXJT0XG6m8igpH78XVNwxWI8+Gn19\n", + "ROPMGKx6f5s82f+9aGHTSvtGFEaWAkSXApYg+8vmIHeb3/ZNzHCeZqtdZZ02Pdg5qFqzpbt0viX1\n", + "arBqdSTth0Fcuq6Ui7s/rrzSTDlMcKm+540zY7CCnNC7dydXHhfkseLncZtMitpFHGY92+9RrMVG\n", + "S0+UNKOss3Zt+HVslCMJleU68ECz72Sstt22xt5lZT+bWtYGV4Ndl6XeglUvsDLVZ16ZXpjKUu/F\n", + "xb/4RfC08iqJVhIbXAoiaq1bb/LBMGOwwuYRV61ub1uTKsbZlih5Z6W+x2EywIx73KPeJ1wbg1Xt\n", + "IQ8/pu+FYdNNO8DLotTHYFU7UWodzPL5gcqtX++fVtyL34IFtf/+D/9gbgBhmBMuTVFPNhe3JYok\n", + "5+fxvGS6airT/vWvzedhootw3br49SipQds21kuiDvgNTzCZb5Trftqy/ERl+TUkL9fgLHCmi7Ck\n", + "VuWqNffMc89Jhx0WPk3X1Grd85OHkyWN4xN3fJuNAc+SnadIK5cJOst4mC8NQeuoiTFXGzcGzxvR\n", + "uN6qkYWnrV2tl1Gf4MzDvSZpiQVY5a+WCHJz8ry+V4U8/vi+v111VfX1/B5vT3sOmbii3Dxti9q9\n", + "5NqAfVfKUclUwPf009WXrRY4/eIX0qhRZvIP+jc/WT9vw8jSdtkoq43XNkVV73VNaU/TYKvb3PVg\n", + "OssSC7DOPXffz0EvxuXBVb319vPZkrQrxJIl0g03xE8ni98cKrsWbB0LvydLbQz4DrNeraf+pL7Z\n", + "nKuNZ4kaXFSu99GP1k7Tz8MPB5+53aYkzlvTeWTxHA3C1tjKynRLX5CT7GqtlYZfemnfT2yO+0qj\n", + "HI2gboB1zjnnqKmpSVOnTu3/rLu7W62trZo4caJmzZqlLeUvEqsiwCKS7PfFJ9kPfcUV0kUX2c8n\n", + "SdX22wsvpDPw9JvfNJteUHG27Utfkj772XD5VZtWwMT54mJwEObGbnocU5Ljoly5WQVtLbdV3vHj\n", + "wy2f9v5O67jdeWf8h6pcqXONoG6AdfbZZ2vx4sUDPmtvb1dra6vWrFmjmTNnqr29vW5Gb3vbvp/L\n", + "D/CLL/Z9oy+JOu9LVgaH1+PXTO3iCVFZpq98Rbr77mDLZpHJbaj1ZSNsPia6kU1/+6/1tyDnZBJd\n", + "hHmok0mzuc+CfgGPqlrZ/+u/7OZr2llnSeecE23d0j5YuND/c5hXN8A6/vjjNWLEiAGfLVq0SG1v\n", + "TYXc1tamhZVHrI7KA3rFFYP/tmvX4Fmta12c/cZnudjMW4+tp3aS8Kc/Dfw9KwNgTUsyGDCZVxL7\n", + "zcVxhWn63e/Cz++X5P6x3ZMQVeU7/aKmF/ULfZj8gj5UYjJPF9NvRJHGYHV1dampqUmS1NTUpK5a\n", + "0yK/pdYrH8oHqJcO8oc+JH3qUwOXa9QKkHbAUC5q90mt1rigaXZ3B8/PNFtjUVwSZ79FXddvP95y\n", + "S183qk0rV1b/W5RtiVofPvQh6dZbo62btCSuv0GDERtTiJjyf//vwN+nTzeTrivBbqPeh6OI/bLn\n", + "QqGgQs2ryzxJpdaNFkktgb6R//nPcUsW7D2FpqR1w3X1Rl8o+LfGxTk5Dzoo2HKlAeQf/OC+slRT\n", + "OXdaULW2o/ICm7agT3imwW8//vCHgz+zUUaTacap1y69oSLKo/rd3dKwYdLQoXbKZILpsb210vnc\n", + "56Qzz4yfDpJRLBZVLBatpB0pwGpqalJnZ6dGjx6tjo4Ojar5bPe8QZ9UVqp//3ep1AtpssIl2UVo\n", + "8xHmpLqIgogyLizpMs6dOzDfWvl/8Yvm8//3f9/3s4k6aLtbLQtdD7W6ztMY8Pzww9HXddHrr/t/\n", + "HuRp4IMOkr7+denaa+2ULYgkrjFhA/JaYwlNP2x11lnRyhPEzTdL//iP7n6Zj6ulpUUtLS39v19p\n", + "8EWRkboITz75ZM2fP1+SNH/+fM2ePdtYgbIa0ZuqfGnPtWJSlCftXN3mqF2Eti9KroxpSuNLwAMP\n", + "xFv/pZfMlCMPvvGN+svUOo5h96Wr53kttr/8J5l/mHS/8hXpySfNtwI2groB1hlnnKEPfvCD+tOf\n", + "/qRDDz1Ud9xxhy677DI98MADmjhxopYuXarLLrssVKbnn1/9b7YP3k03BVsuSDkWL97XWmKKX75Z\n", + "/+YQJoCy2RJoUpxymixP1EG6fpJ8F2FYfk/XzpoVL82XX463fp5E7aaMOnmlizfpMPU/avn9JsQO\n", + "m2eWemEaXd0uwrurPHu/ZMmSyJnWerdfrYNs4gbwq1/FT6Nk/nzppz/t+zmJwGDmTOk3vzGfTxiV\n", + "21nrMeco3WM2B6jfdVf0iTRNdkPVSssvYIrbSpXEexPz8GRbUunHlcRDHH6fh6nLUcZy2RQkOEni\n", + "uAcdm2WD6/U6jzL1LsLf/tZcPiYG/iZ1kSjtk6VLk8kvjDlz6i8TJqiyeRG47z5zabnSqlhvLIcL\n", + "F1XTY7CQniRfch5GVvJ74YXa6+/YUT8NE9eesNfc8lfdIbhMBViNxuV9YaslKitdhJWefTb4sml9\n", + "e0+L6fwr91/a25cHQVtJg+7rel3XWTxmYXsPorSWHXDAwIm3/dYxse9KPS9BnXji4HKgPmcCrKiz\n", + "ltt4l1zQciR1o3SltUSKP04hjZPTRgtK5e9xX19RLd1qn8VJLy6/qS1sd73k6eGPSmm3Dtxyi/TY\n", + "Y30/16rnJp8cDjk3deL8rnPXX7/vZ5tfIJOYtqN8TsG8nU8uiT0PlilRo/Ooj2ybrlRZbXkJoqtL\n", + "2rpVmjAh2vqeV/uikYWnCG2zeaxNp+03GaRr46JMbXMSN7t//mf7edTiN6nrbbdJH/hA9DTrHa+g\n", + "r8Z5800z+YW9v6R5HSp1I1Zjq1EB5jnTglWSpRts0mOw0vKpT0kTJw78LMgYtvJylybfjNq1+Mgj\n", + "tderV5a4ok7TYPuCXnrIoFqXTNp1x5UyhFFe3qgPReTBddcN/D3McTT5dGselfblqlWD/1Yt+Ix7\n", + "HmXxyc6sy12AZWM+qnJ/+7fSv/3b4M+TfLInadu37/s5SkujiWkaTjgheH5B04wjaJqV79OMkm75\n", + "i9KrcfnbqekuQiSn/Ng9+6ydQe4ujde0nfdrr8XPM+3eF1fuS1mQuwDLz6OPmitHR0e0WZyPPNL/\n", + "20oQLt5c4k4dULJ6db67CJ97bvBnST4qHmZgsi3l+ceZB6jExfMhSUGO52OPSRdcED+v8ll6rrjC\n", + "3CB3E0x8cUtaabxdrfKkVb9XrRr4ZRrxOTMGq8RGM6jfKxySHnj77LN9gd6BB0ZL3xVRylS+b+o9\n", + "hmxrLNvRR/fNRlxS7UmdaqJ2ESYl7RtIkmOwoo67jJJXVkX9MlfpiSeiredqC1bQdQqF2sMSbHbX\n", + "Jf3u0FJZLr1UeuUVs2k3uty1YCV5cQz7ZNNXvhItnzQv+OVBiRT/wlmv9c/Gtq5bN3g70lTrAhl1\n", + "+2vNg2X6gnzRRf75VJOHgCXP9t/ffJpJBFg2eV5fwFFNT09yZSmx1UVYLsgrj1w8Xq4iwKrChRaK\n", + "tCvy66/3tfzEFab53sY2r1wZPw2TrSY2gpEk68rateGWN91a7MK5WU3a52xcpsqfdBdh0uI+/BCl\n", + "BSuJ7f3Zz/r+r3XNdPn8c03uAixTJ3aQclRrwTJdAdOq0LX2pakxWCbWQXWujcFyMT0TXCxTUGFa\n", + "Y1wd5B70S9zll0fLK0lpdRFWqvaATpbretJyF2AFWX/jxvBPd6XB5W8Kf/rT4M/Ky7t7t/Sud/X9\n", + "nPXuAj+1js3UqdHXzcr2V3Kti9BWC6PNdbPAxiD3JFtt77gjWl4m8g66/n5V7spJdBGWc/n+kxUN\n", + "GWAdemjt/vWgkppd2sWL9ty5gz8rL2fQCQIr14s6mPyll/omQ7UlTBeh374Jum5U5WmWT45pYwyW\n", + "a/z2Z163edUqM09impal1xcl9b6/Wvz2T+kzV+vuxRf3/e/ysXVNQwZYUrw+9P/+b+ljH6tfhrhP\n", + "3LlWkR9/PNp6SWzH3/2d1NZmP58g0j5uixYFX3bdOjN5utaCldZNyva2vve90g032M2jlqDjgypb\n", + "sG69tXqaF14YrSxRp2n44hfDpZ2UtKaaqJZu5efVxl7a/GKbdbkLsMpP7N7eaHNg1bNtm3T//QM/\n", + "q/WNJIzydfbu7ZvV15VvNLNn288jzvEvf7+WaWFa1uptg9+6Ud/F6Zdm5Y2nVprvfrfU3h4tz6BM\n", + "3BjCppHnF2pnYXhD5f74X/+r+rK33BItj//3/6Kt95e/RFuvnCsPY9lUrYyV59brr9svS1blLsAq\n", + "X/+hh6Tjj7eTj2SnizDMN7+siPMUYRYuRJXifBONur0bNkRbT+o7T8qZvoFnrQUrSnnffLNvMuEs\n", + "1lcbktgPL75oL+00vtTWG7eWdguW7XLkUeYDrMoujsoWoKTYHAdSmXbSs+0GPSbf/nZyeSGYKGOw\n", + "onTZRD1uH/94sOVK21AoDH4Bswt1ZsuWvsmEs85UN1V5sJDE9cqFOhCGX3nDdO2b8rvfScuX+/8t\n", + "a/vURbmbyT3Jl4xWu3HF6e6pt84DD0izZiVT+U09tWL7KcI//jH8OmEl9SSkCxe1zk6z6Znepj17\n", + "6i+T1zFYrqo1yP0f/9FOnmk+nWzjmlgay5Rky9H73lf9b0FfIO/KEBYXZb4Fy/T6YSTRRViZz8sv\n", + "m8kniKQeC447sL/etAhJcynAcuGGn+UxWEHzTXI/B8nL1k0vyiD3jg47ZUnzyW0b96mkrrdBuVKO\n", + "LHMmwCq9ZdyVAMv0GK2g/AKsp56KX5YoshJgJSHM2DBXt8Em1/ZH0gFW1OXzqnw/2BqUn+a+thlg\n", + "BW05so0xWPE5E2CVuNJFGCSdWk9uVX4WlEuVt7QPbAe95fvape3Pg7zsz0Ih3HllapB7XvZf0sr3\n", + "W7UxPrbyi/L3SvXqTxoBVklSXXJBt5EuwupyF2C51IKVpXwrvfpqci1Y5a/qcGX76zE9G7tr3QNh\n", + "JdGClcY+CttFmNXjF1S17as8H1x7F6Hp4xJ3+2qtn8TThEHSCHqsly+Xhg6NX6Y8atgAK0yrStT0\n", + "4k406qdy/i1bnnvO/6Zho1UuCy1Yrgxyd7XLKokAq1qLqqlzDwPFqfNJPoQThOmAL40xWK52ET7x\n", + "RLJP7GcJAVaMdGw0I9e7ECxe3Pf/li3S8OHh0w8jqW/lWQiwwkhz8K2pdUwy3YIVtvveRJ5Bl0t7\n", + "X8dVr/xB92vSLVhJfGEO8/co6Sc5BivIcTzttGBpZb3O29Sw0zTUq2B+LzOupbzclWmfcEK0dPzs\n", + "v3/f/x0dfTPK2+R3wttolctCF6ELLUFRyuHq/oyiVA9tB1hRWmzDBH9xJXVMk56s1abKyXTjinuc\n", + "o7Rgff3r8fIM6ze/8f88jdbKrKIFq4ogL4OuN01D6e+PPBKsTEHKVR6M2JZGC1alpLt6nn9eWr++\n", + "/nK19omJV3FEybeaJPah7S5Cz3N7DFaY4C+PXB+D9YUvhEs7zUHuWdOodT6I3LVgJVlJbcyDZbqp\n", + "u1z5k1hhymL7mLjURThhgvSOd+ybNqSaO+/0//zRR6O/W00yv/1p70+TZUhjDFbQspe++NSrN1ln\n", + "6gusCXHHhsZhswUra7Ja7iTkrgUryWi6Vlkvv1x64QWzaQb5e9z0/Za1fSFzrYvQb96eynJ1dfmv\n", + "G/WF00EDAhf2j5+wLVhnnx0u/fIvB66c4+VKg3zf9S57ZXGZ64Pcy5mYl6teHdy6tfYbB9IOsEzm\n", + "5eo1yQXOtWB94xvx1k/yG1Z5Gj/84cC/tbdHS7PeiRu3i3Dt2vBlaaQWrLjitpw0yhisIN2wlcJ0\n", + "w8XZ7ihfKBrlKSqXBrlHVSxG+/Jbrt72nX9+7b+nHWCZPD4uH+u0OdeCVXpKLioXvgWYurj7iVuZ\n", + "wwRofi1YNsbzZCHASuobuokAK2rZ0tqmsOm4cI5L0osv7vu5UQKsamq9izCKiy+WVq+uvUycPLZs\n", + "ib5ukLzrdRWnfZ2Lcx9hkHtwzrVgxZVkNG0jr3ppxs0zTIBkqksmqacIOdEH87zo3ZZh84nytzCS\n", + "asEKms5RR+37OcgLqE2xWc+TfBNGLf/yL9Kbb9ZeJs0xWDZa9ZMM0k3eu7juVudcC1ZcLozPMNnK\n", + "U+3bwhtvmMujXt5JPkXoanNz5T4I+tLbuPlESb+ybJdfHr08JthuwbJZP2ulXT5NSl5asOpth6uD\n", + "3E2rtx9szOT+1a/GSzNu/i6klTeZDbC2bvX/POib202cnGm0YJVaey65xHzelUwNcg/T7RnnRhVm\n", + "Oox6LrlE+v73zaVnis0xWK5/E63WgmV6PMuOHcHSKf+bX72tdo1ymalA0cS1Mc3Z+D/zmdp/Lz/2\n", + "UaZlKa9jSaisx7RgJSNWgLV48WJNmjRJEyZM0DXXXGOqTIEceKD/50lOxlatYr3+ejFympUVv9r8\n", + "MtWeYqsnzDfQygDr5ZfrNdsXI5WpvItw9+5ISRh37bW1H1QYeFyKxvLN1sWq2P+Ta12EcXR27vvZ\n", + "v+zFQZ/4BSaf/rSpEoUXdZ/X7uosOvW0a3JdhMVBn5TXwYsuspm3HcHOoaLvp4zBCi5ygNXT06Mv\n", + "felLWrx4sZ555hndfffdevbZZ02WzXnVKmmcACtoF1HUpwnjDnKvfWIWa6YTpExJjmWpxu8mUnsb\n", + "ipZKMphbLVjFQEvNmRM2XX9hugjjXPTrz29XHPSJX4C1cWP0MqSlXoC1bFmwdLLeRThQsWbeWQww\n", + "gp3wnLAAAB85SURBVAZYQbaNLsLqIgdYK1eu1OGHH65x48Zp6NChOv3003XPPfeYLJtVJiqFjYoV\n", + "9GSNmnfcACuKMF2ELgRYaTI9TUNSkihXUi1YUR668AuwsnjjcamL0Oa5ELe+ZvHYlgtafptPLTeC\n", + "yE8Rbtq0SYceemj/72PHjtWKFSuMFMqUWt1Ntbq6qj3CW/l5tTRqBQn1+t4rB69XWz5IH/7OnYM/\n", + "CzrT9LZt0l//dd/P9Z7mqade7/H27ft+7u4euJ/j5B31UexSnrt27Uvj9df9l6lUvi3VyuQ30WHp\n", + "uNfb3iA3wPK6EWYflM4Xv3pTz549/nnFfRy+ZPv2fcegsu77nQs7d/bV9aefDl+W8rFTQcdR+b0X\n", + "9PXXzW2/tC+tIOdE0DE+leUrf+I0yIScpWV27hyYlonxZ/Xq4fbt1c/PesqXL6UR5sGh8uPtV84w\n", + "2x/2Gld+XfLj97dt2wZem7ZuDVY3/Zap3E+l3z0v3XFzLip4XrT48+c//7kWL16s2267TZJ01113\n", + "acWKFbr55pv7lzn88MP1QtwZ3QAAABIwfvx4Pf/880bSityCdcghh2jDhg39v2/YsEFjx44dsIyp\n", + "QgIAAGRJ5DFYxxxzjP785z9r/fr12r17t372s5/p5JNPNlk2AACATIrcgjVkyBD94Ac/0Ec/+lH1\n", + "9PTo3HPP1RFHHGGybAAAAJkUeQwWAAAA/FmZyT3NCUiTMG7cOB111FFqbm7W+9//fklSd3e3Wltb\n", + "NXHiRM2aNUtbyh6/uPrqqzVhwgRNmjRJv/71r9MqdmjnnHOOmpqaNHXq1P7PomznE088oalTp2rC\n", + "hAn6apLvg4jIb7vnzZunsWPHqrm5Wc3Nzbrvvvv6/5aX7d6wYYNmzJihyZMna8qUKbrpppsk5f+Y\n", + "V9vuvB/zXbt26dhjj9X06dN15JFH6vK33qmU9+NdbbvzfrxLenp61NzcrJNOOklS/o93SeV2J3K8\n", + "PcP27t3rjR8/3lu3bp23e/dub9q0ad4zzzxjOptUjRs3znv11VcHfHbxxRd711xzjed5ntfe3u5d\n", + "eumlnud53tNPP+1NmzbN2717t7du3Tpv/PjxXk9PT+JljuLhhx/2nnzySW/KlCn9n4XZzt7eXs/z\n", + "PO9973uft2LFCs/zPO/jH/+4d9999yW8JeH4bfe8efO86667btCyedrujo4Ob9WqVZ7ned62bdu8\n", + "iRMnes8880zuj3m17W6EY75jxw7P8zxvz5493rHHHus98sgjuT/enue/3Y1wvD3P86677jrvs5/9\n", + "rHfSSSd5ntcY13TPG7zdSRxv4y1YWZ+ANCivomd10aJFamtrkyS1tbVp4cKFkqR77rlHZ5xxhoYO\n", + "Hapx48bp8MMP18qVKxMvbxTHH3+8RowYMeCzMNu5YsUKdXR0aNu2bf0tfWeddVb/Oq7y225p8DGX\n", + "8rXdo0eP1vTp0yVJBxxwgI444ght2rQp98e82nZL+T/mb3/72yVJu3fvVk9Pj0aMGJH74y35b7eU\n", + "/+O9ceNG3XvvvTrvvPP6t7URjrffdnueZ/14Gw+w/CYgLV2s8qJQKOjEE0/UMccc0z8PWFdXl5qa\n", + "miRJTU1N6nrrZYEvv/zygOkrsr4/wm5n5eeHHHJIZrf/5ptv1rRp03Tuuef2N6PndbvXr1+vVatW\n", + "6dhjj22oY17a7g984AOS8n/Me3t7NX36dDU1NfV3kzbC8fbbbin/x/vCCy/Utddeq/3223frb4Tj\n", + "7bfdhULB+vE2HmAVGmAq12XLlmnVqlW67777dMstt+iRRx4Z8PdCoVBzP+RlH9Xbzjw5//zztW7d\n", + "Oq1evVpjxozR1772tbSLZM327ds1Z84c3XjjjRo2bNiAv+X5mG/fvl2nnnqqbrzxRh1wwAENccz3\n", + "228/rV69Whs3btTDDz+sBx98cMDf83q8K7e7WCzm/nj/6le/0qhRo9Tc3OzbciPl83hX2+4kjrfx\n", + "ACvIBKRZN2bMGEnSwQcfrFNOOUUrV65UU1OTOjs7JUkdHR0aNWqUpMH7Y+PGjTrkkEOSL7QhYbZz\n", + "7NixOuSQQ7Sx7K23Wd3+UaNG9V98zjvvvP5u3rxt9549ezRnzhzNnTtXs2fPltQYx7y03Z/73Of6\n", + "t7tRjrkkHXjggfrkJz+pJ554oiGOd0lpu3/3u9/l/ng/9thjWrRokQ477DCdccYZWrp0qebOnZv7\n", + "4+233WeddVYyx9vI6LEye/bs8d797nd769at8958883cDXLfsWOHt3XrVs/zPG/79u3eBz/4Qe/+\n", + "++/3Lr74Yq+9vd3zPM+7+uqrBw0UfPPNN721a9d67373u/sHzGXBunXrBg1yD7ud73//+73ly5d7\n", + "vb29mRkQWbndL7/8cv/P119/vXfGGWd4npev7e7t7fXmzp3rXXDBBQM+z/sxr7bdeT/mmzdv9l57\n", + "7TXP8zxv586d3vHHH+8tWbIk98e72nZ3dHT0L5PH412uWCx6n/rUpzzPy//5Xa58u5M4v40HWJ7n\n", + "effee683ceJEb/z48d5VV11lI4vUrF271ps2bZo3bdo0b/Lkyf3b9+qrr3ozZ870JkyY4LW2tvaf\n", + "wJ7ned/73ve88ePHe+95z3u8xYsXp1X00E4//XRvzJgx3tChQ72xY8d6P/7xjyNt5+9+9ztvypQp\n", + "3vjx470vf/nLaWxKKJXbffvtt3tz5871pk6d6h111FHepz/9aa+zs7N/+bxs9yOPPOIVCgVv2rRp\n", + "3vTp073p06d79913X+6Pud9233vvvbk/5n/4wx+85uZmb9q0ad7UqVO973//+57nRbuW5WG78368\n", + "yxWLxf6n6fJ+vMs9+OCD/dv9uc99zvrxZqJRAAAAw6xMNAoAANDICLAAAAAMI8ACAAAwjAALAADA\n", + "MAIsAAAAwwiwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsAAAAAwjwAIAADCMAAsAAMAwAiwAAADD\n", + "CLAAAAAMI8ACAAAwjAALAADAMAIsAAAAwwiwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsAAAAAwj\n", + "wAIAADCMAAsAAMAwAiwAAADDCLAAAAAMI8ACAAAwjAALAADAMAIsAAAAwwiwAAAADCPAAgAAMIwA\n", + "CwAAwDACLAAAAMPqBlgbNmzQjBkzNHnyZE2ZMkU33XSTJGnevHkaO3asmpub1dzcrMWLF1svLAAA\n", + "QBYUPM/zai3Q2dmpzs5OTZ8+Xdu3b9fRRx+thQsXasGCBRo2bJguuuiipMoKAACQCUPqLTB69GiN\n", + "Hj1aknTAAQfoiCOO0KZNmyRJdWIzAACAhhRqDNb69eu1atUqfeADH5Ak3XzzzZo2bZrOPfdcbdmy\n", + "xUoBAQAAMscLaNu2bd7RRx/t/eIXv/A8z/O6urq83t5er7e317viiiu8c845Z9A648eP9yTxj3/8\n", + "4x//+Mc//jn/b/z48UHDoroCBVi7d+/2Zs2a5d1www2+f1+3bp03ZcqUwYlrcPJ9G+H5/Asc66GG\n", + "b33rW2kXoeGwz5PHPk8e+zx57PPkmYxF6nYRep6nc889V0ceeaQuuOCC/s87Ojr6f/7FL36hqVOn\n", + "1ksKAACgIdQd5L5s2TLdddddOuqoo9Tc3CxJuuqqq3T33Xdr9erVKhQKOuyww3TrrbdaLywAAEAW\n", + "1A2wjjvuOPX29g76/OMf/7iVAiGelpaWtIvQcNjnyWOfJ499njz2ebbVnQcrVuKFwqCpHAqFgvrG\n", + "kg1ammkfAABAavzilqh4VQ4AAIBhBFgAAACGEWABAAAYRoAFAABgGAEWAACAYQRYAAAAhhFgAQAA\n", + "GEaABQAAYBgBFgAAgGEEWAAAAIYRYAEAABhGgAUAAGAYARYAAIBhBFgAAACGEWABAAAYRoAFAABg\n", + "GAEWAACAYQRYAAAAhhFgAQAAGEaABQAAYBgBFgAAgGEEWAAAAIYRYAEAABhGgAUAAGAYARYAAIBh\n", + "BFgAAACGEWABAAAYRoAFAABgGAEWAACAYQRYAAAAhhFgAQAAGEaABQAAYBgBFgAAgGEEWAAAAIYR\n", + "YAEAABhGgCVp+PCRKhQKA/4NHz4y0HJhlvVbDgAA5E/B8zzPWuKFgiqTLxQKkvyyHLxsUvzLFK/s\n", + "QdMEAABu8ItboqIFCwAAwDACLAAAAMMIsAAAAAyrG2Bt2LBBM2bM0OTJkzVlyhTddNNNkqTu7m61\n", + "trZq4sSJmjVrlrZs2WK9sAAAAFlQd5B7Z2enOjs7NX36dG3fvl1HH320Fi5cqDvuuEPvfOc7dckl\n", + "l+iaa67Ra6+9pvb29oGJM8i97nIAAMANiQ5yHz16tKZPny5JOuCAA3TEEUdo06ZNWrRokdra2iRJ\n", + "bW1tWrhwoZECAQAAZF2oMVjr16/XqlWrdOyxx6qrq0tNTU2SpKamJnV1dVkpIAAAQNYEDrC2b9+u\n", + "OXPm6MYbb9SwYcMG/K00kSYAAACkIUEW2rNnj+bMmaO5c+dq9uzZkvparTo7OzV69Gh1dHRo1KhR\n", + "vuvOmzev/+eWlpbYBU7OEILGiIYPH6lt214b8NmwYSO0dWt3SiUCAGCwYrGoYrFoJe26g9w9z1Nb\n", + "W5sOOugg3XDDDf2fX3LJJTrooIN06aWXqr29XVu2bMndIPdgn/V9ziD3fRp52wEA2WVykHvdAOvR\n", + "Rx/VCSecoKOOOqq/Refqq6/W+9//fp122ml66aWXNG7cOC1YsEDveMc76haUACv/QUYjbzsAILsS\n", + "DbBiJU6AVXe5PGrkbQcAZBfvIgQAAHAYARYAAIBhBFgAAACGEWABAAAYRoAFAABgGAEWAACAYQ4F\n", + "WEP6X7lT+jd8+Mi0CwUAABBaoFflJGOvKudO2raNV9UAAIDscagFCwAAIB8IsAAAAAwjwAIAADCM\n", + "AAsAAMAwAiwAAADDCLAAAAAMI8ACAAAwjAALAADAsMwFWMOHj8zVjO9xtydv+wMAgDwoeJ7n1V8s\n", + "YuKFgiqTLxQKqpyx/a2/+HwedP3By4Utp1+awT6LV86422Njf8TlYpkAAKjHL26JKnMtWAAAAK4j\n", + "wAIAADCMAAsAAMAwAiwAAADDCLAAAAAMI8ACAAAwjAALAADAMAIsAAAAw3IbYPnNcM4s54MxEzwA\n", + "AObldib3WvkETbMRZnJPcmZ8ZnIHALiMmdwBAAAcRoAFAABgGAEWAACAYQRYAAAAhhFgAQAAGEaA\n", + "BQAAYBgBFgAAgGEEWAAAAIYNSbsAtQ15a9JKU8ulLSvlBAAAcTgeYO2V/2zqUZdLW1bKCQAA4qCL\n", + "EAAAwDACLAAAAMMIsAAAAAwjwAIAADCsboB1zjnnqKmpSVOnTu3/bN68eRo7dqyam5vV3NysxYsX\n", + "Wy0kAABAltQNsM4+++xBAVShUNBFF12kVatWadWqVfrYxz5mrYAAAABZUzfAOv744zVixIhBn3te\n", + "5XQDAAAAkGKMwbr55ps1bdo0nXvuudqyZYvJMgEAAGRapADr/PPP17p167R69WqNGTNGX/va10yX\n", + "CwAAILMizeQ+atSo/p/PO+88nXTSSVWXnTdvXv/PLS0tUbJDTg0fPlLbtr024LNhw0Zo69buRNYH\n", + "ADS2YrGoYrFoJe2CF2Aw1fr163XSSSfpqaeekiR1dHRozJgxkqQbbrhBjz/+uH7yk58MTrxQGDRW\n", + "q+9dfH5Z+n1u+rO+z4OVKc00B6dXTbV8klo/Tpoulh0A0Lj84pao6rZgnXHGGXrooYf0yiuv6NBD\n", + "D9WVV16pYrGo1atXq1Ao6LDDDtOtt95qpDAAAAB5EKgFK3LitGBFLjstWObyAQAgCJMtWMzkDgAA\n", + "YBgBFgAAgGEEWAAAAIYRYAEAABhGgAUAAGAYARYAAIBhkWZyh+uGvDWFQbmhkvakURgAABoOAVYu\n", + "7VWYObwAAIBZdBECAAAYRoAFAABgGAEWAACAYQRYAAAAhhFgAQAAGEaABQAAYBgBFgAAgGHW58Fq\n", + "azvfdhYAAABOsR5g/cd/HFX22wbb2QXgN8u5a2lWSy/Ls7Hb2O8AALip4Hme3/TeZhIvVM4evkrS\n", + "e1V9RvEgs4/H+SwraaZf9jjVYvBxD1Om4HlXy8dilQYA5FihYO4ewhgsAAAAwwiwAAAADCPAAgAA\n", + "MIwACwAAwDACLAAAAMMIsAAAAAwjwAIAADCMAAsAAMAwAiygzPDhI1UoFAb8Gz58ZNrFAgBkjPVX\n", + "5QBZsm3ba6qcHX7bNl7xAwAIhxYsAAAAwwiwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsAAAAAwj\n", + "wAIAADCMAAsAAMAwAiygriHM7g4ACIWZ3IG69orZ3QEAYdCCBQAAYBgBFgAAgGEEWAAAAIYRYAEA\n", + "ABhWN8A655xz1NTUpKlTp/Z/1t3drdbWVk2cOFGzZs3Sli1brBYSAAAgS+oGWGeffbYWL1484LP2\n", + "9na1trZqzZo1mjlzptrb260VEAAAIGvqBljHH3+8RowYMeCzRYsWqa2tTZLU1tamhQsX2ikdAABA\n", + "BkUag9XV1aWmpiZJUlNTk7q6uowWCgAAIMtiTzRamtm6unllPx8SNzskYsigYzps2Aht3dqdUnnC\n", + "GFx2aaikPQM+ib895vfR8OEjtW3ba0bTBABUVywWVSwWraRd8DzPq7fQ+vXrddJJJ+mpp56SJE2a\n", + "NEnFYlGjR49WR0eHZsyYoeeee25w4oWCBs6AvUrSe1U5K/ZbS/t8bvqzrKTpZtkDVJW+JQcd9+zk\n", + "k1TZ/VTLO06aAIDgCgVz19xIXYQnn3yy5s+fL0maP3++Zs+ebaQwAAAAeVC3BeuMM87QQw89pFde\n", + "eUVNTU369re/rU9/+tM67bTT9NJLL2ncuHFasGCB3vGOdwxOnBYsx/MJtz4tWNHSDIoWLABIl8kW\n", + "rEBdhJETJ8ByPJ9w6xNgRUszKAIsAEhX6l2EAAAAqI4ACwAAwDACLAAAAMMIsAAAAAwjwAIAADCM\n", + "AAvOGz58ZP8bA8r/xTPEQpqAPX7nwfDhI9MuFoAqYr8qB7Ct7/Ux1aaYiGqvhTQBe/zOg23bqK+A\n", + "q2jBAgAAMIwACwAAwDACLAAAAMMIsAAAAAwjwAIAADCMAAsAAMAwAiwAAADDCLAAAAAMI8ACAAAw\n", + "jAALAQ1+tQyv6QiGV5y4g2MBICm8KgcBDX61DK/pCIZXnLiDYwEgKbRgAQAAGEaABQAAYBgBFgAA\n", + "gGEEWAAAAIYRYAEAABhGgAUAAGAYARYAAIBhBFgAAACGEWAhhsGzuxcKcSdtHJwmBvKbjbzajORB\n", + "Zy4PkyYAoD5mckcMg2d37xMnKPJLkyCrnN9s5H2fD95PQWcuD5MmAKA+WrAAAAAMI8ACAAAwjAAL\n", + "AADAMAIsAAAAwwiwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsABkGrPQA3ARM7kDyDRmoQfgIlqw\n", + "AAAADCPAAgAAMIwACwAAwLBYY7DGjRun4cOHa//999fQoUO1cuVKU+UCAADIrFgBVqFQULFY1MiR\n", + "PK0DAABQEruL0PMGP70DAADQyGIFWIVCQSeeeKKOOeYY3XbbbabKBAAAkGmxugiXLVumMWPGaPPm\n", + "zWptbdWkSZN0/PHHmyobAABAJsUKsMaMGSNJOvjgg3XKKado5cqVPgHWvLKfD4mTHeC4ISoUsjC5\n", + "ZXrlHD585FsTg1YaKmnPgE+GDRuhrVu7EylXEvy2PW/bCGRNsVhUsVi0knbBiziIaufOnerp6dGw\n", + "YcO0Y8cOzZo1S9/61rc0a9asfYkXCho4w/IqSe+V36zLUuWyNj7LSppZLruNNLNc9urLVp56g8+X\n", + "MMuFSzNM2U2Os6xV9iDbHjbNqPvYhrh5p1l2oFEUCubOqcgtWF1dXTrllFMkSXv37tWZZ545ILgC\n", + "AABoVJEDrMMOO0yrV682WRYAAIBcYCZ3AAAAwwiwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsAAA\n", + "AAwjwAKc1jfrevk/2Dd8+MhB+71QKGj48JEBl/2rhI7b4PrhV0YAyYv1qhwAtu2V/6zrsKnvlTaD\n", + "Z3Petm3wvvdfttps+aYNrh9+ZQSQPFqwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsAAAAAwjwAIA\n", + "ADCMAAsAAMAwAiwAAADDCLCA3Ehv1ne/2czTn1E8C7PgDy5jsjPBm+dmXQCSx0zuQG6kN+u732zm\n", + "6c8onoVZ8P3KKCU3E7x5btYFIHm0YAEAABhGgAUAAGAYARYAAIBhBFgAAACGEWABAAAYRoAFAABg\n", + "GAEWAACAYQRYAAAAhhFgAQAAGEaABaQiC69xkfzKGfy1J3G30e81MjZeIROmnFk4bv6v3/E7bkFf\n", + "axP/9Tdx6lG6knr1D68Yyp+C53l+72kwk3ih8nUPqyS9V+FeDWHys6ykmeWy20gzy2W3kWb6Za+8\n", + "bAw+183kk/80ky170OMWdblaywZd3zVhtj0L+aC2QsHcPqcFCwAAwDACLAAAAMMIsAAAAAwjwAIA\n", + "ADCMAAsAAMAwAiwAAADDCLAAAAAMI8ACAAAwjAALQEhZmM0cg5k+bv4zxsdZv9rM5WnOph5n3Wpv\n", + "H2iEmeDT3h8uYCZ3J9PMctltpJnlsttIk7LnJ003yx59pv645Qw3O3xSs6lH30dx1w++ja7NBB93\n", + "f6SFmdwBAAAcRoAFAABgGAEWAACAYbECrMWLF2vSpEmaMGGCrrnmGlNlAgAAyLTIAVZPT4++9KUv\n", + "afHixXrmmWd0991369lnnzVZNkRSTLsADaiYdgEaUDHtAjSgYtoFADIlcoC1cuVKHX744Ro3bpyG\n", + "Dh2q008/Xffcc4/JsiGSYtoFaEDFtAvQgIppF6ABFdMuAJApkQOsTZs26dBDD+3/fezYsdq0aZOR\n", + "QgEAAGTZkKgrBp2Abfjwk/p/7u19Xdu3R80RAAAgGyIHWIcccog2bNjQ//uGDRs0duzYAcuMHz9e\n", + "L7zwK5+1qwVnfp+b/iwraWa57DbSdL3sV1pIM+xnWUnTVD5X1lkubpmytj/Mpen/BfpKDdzn8fMJ\n", + "nvf/b+cOXpr+4ziOvyYKQYQn/WoscEhON+f2jaXnXEuoZg095MGDShcv6tF/QKUOsWinIBAP1TUi\n", + "I8tJpqjQNoYiGDRhggqag5pKqe8OP9gPqd+Pys9n+/309bjt+xW/H58D92bb9/O7P3sUR1nnUdd+\n", + "1L8xV41+Vb6fy99XWVmp7Hf98U7ue3t7sNvtePPmDc6ePYv6+no8fvwYNTU1yhZHRERE9H/0x+9g\n", + "FRYW4sGDB2hqasL+/j66uro4XBERERHhCO9gEREREdHPadnJnRuQ6tfZ2QnDMOByubLHPn36BL/f\n", + "j6qqKly5cgXpdDqPKzx+UqkULl26BKfTidraWty/fx8Au+u0u7uLhoYGeDweOBwO9Pf3A2DzXNjf\n", + "34dpmggE/rpRic31qqioQF1dHUzTRH19PQA21y2dTqO1tRU1NTVwOByYnZ1V2lz5gMUNSHOjo6MD\n", + "L1++PHRsaGgIfr8fS0tL8Pl8GBoaytPqjqeioiLcu3cPCwsLmJmZQTgcxuLiIrtrdOrUKUQiEcTj\n", + "cSQSCUQiEbx7947NcyAUCsHhcGS/fMzmelksFkxMTCAWi2Fubg4Am+vW09ODq1evYnFxEYlEAtXV\n", + "1Wqbi2LT09PS1NSUfTw4OCiDg4OqL0Mikkwmpba2NvvYbrfL2tqaiIisrq6K3W7P19JOhBs3bsjY\n", + "2Bi750gmkxGv1yvz8/NsrlkqlRKfzyfj4+Ny/fp1EeH/F90qKipkY2Pj0DE21yedTovNZvvhuMrm\n", + "yt/B4gak+bO+vg7DMAAAhmFgfX09zys6vpaXlxGLxdDQ0MDumh0cHMDj8cAwjOxHtGyuV19fH+7e\n", + "vYuCgr9fIthcL4vFgsuXL8Pr9eLhw4cA2FynZDKJkpISdHR04MKFC7h9+zYymYzS5soHrP/KXhYn\n", + "ncVi4XOhyZcvX9DS0oJQKIQzZ84cOsfu6hUUFCAej2NlZQVv375FJBI5dJ7N1Xr+/DlKS0thmibk\n", + "H+6BYnP1pqamEIvFMDo6inA4jMnJyUPn2Vytvb09RKNRdHd3IxqN4vTp0z98HHjU5soHrF/ZgJT0\n", + "MAwDa2trAIDV1VWUlpbmeUXHz7dv39DS0oL29nbcvHkTALvnSnFxMa5du4b379+zuUbT09N49uwZ\n", + "bDYb2traMD4+jvb2djbXrLy8HABQUlKCYDCIubk5NtfIarXCarXi4sWLAIDW1lZEo1GUlZUpa658\n", + "wPJ6vfjw4QOWl5fx9etXPH36FM3NzaovQz/R3NyM4eFhAMDw8HB2ACA1RARdXV1wOBzo7e3NHmd3\n", + "fTY2NrJ38ezs7GBsbAymabK5RgMDA0ilUkgmk3jy5AkaGxsxMjLC5hptb2/j8+fPAIBMJoNXr17B\n", + "5XKxuUZlZWU4d+4clpaWAACvX7+G0+lEIBBQ1/yPv731L168eCFVVVVSWVkpAwMDOi5x4t26dUvK\n", + "y8ulqKhIrFarPHr0SDY3N8Xn88n58+fF7/fL1tZWvpd5rExOTorFYhG32y0ej0c8Ho+Mjo6yu0aJ\n", + "REJM0xS32y0ul0vu3LkjIsLmOTIxMSGBQEBE2Fynjx8/itvtFrfbLU6nM/u6yeZ6xeNx8Xq9UldX\n", + "J8FgUNLptNLm3GiUiIiISDEtG40SERERnWQcsIiIiIgU44BFREREpBgHLCIiIiLFOGARERERKcYB\n", + "i4iIiEgxDlhEREREinHAIiIiIlLsO5hP7FaK+KtUAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "source": [ - "The second fully connected layer, `fc7` (rectified)" - ] - }, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['fc6'].data[0]\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(feat.flat)\n", + "plt.subplot(2, 1, 2)\n", + "_ = plt.hist(feat.flat[feat.flat > 0], bins=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second fully connected layer, `fc7` (rectified)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "feat = net.blobs['fc7'].data[0]\n", - "plt.subplot(2, 1, 1)\n", - "plt.plot(feat.flat)\n", - "plt.subplot(2, 1, 2)\n", - "_ = plt.hist(feat.flat[feat.flat > 0], bins=100)" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlcAAAJPCAYAAABRvvFyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XucFOWd7/FvJ5BNToAEVAYW3AOiKHKbWQ14XHGHKESO\n", + "eGExboiSeQmePWtiEqNH1M0mDm5UWDdrEF3DcSNhQw5KLiAxMl6i7S1RohlcE+8KK+LMKMLIDCiX\n", + "mTp/tD309FR11+WpW/fn/XrxYqan6qlf1VOXXz/11FMZy7IsAQAAwIiPxR0AAABAJSG5AgAAMIjk\n", + "CgAAwCCSKwAAAINIrgAAAAwiuQIAADCoZHK1bds2TZ8+XePHj9eECRN0yy23SJIaGxs1cuRI1dXV\n", + "qa6uTk1NTZEECwAAkHSZUuNctba2qrW1VbW1ters7NQJJ5yg9evXa+3atRo4cKAuv/zyKGMFAABI\n", + "vH6l/jhs2DANGzZMkjRgwACNGzdO27dvlyQx9igAAEBfrvtcbd26Vc3NzTrppJMkScuXL9fkyZO1\n", + "cOFCtbe3hxYgAABAmrhKrjo7O3Xeeedp2bJlGjBggC655BJt2bJFmzdv1vDhw3XFFVeEHScAAEAq\n", + "lOxzJUkHDhzQ7NmzNWvWLF122WV9/r5161adddZZev7553t9fvTRR+v11183Gy0AAEAIxowZo9de\n", + "e81IWSVbrizL0sKFC3X88cf3SqxaWlp6fl63bp0mTpzYZ97XX39dlmVV3b9rr7029hhYb9ab9Wa9\n", + "WW/Wm/X29s9kg1DJDu1PPvmkVq9erUmTJqmurk6SdMMNN2jNmjXavHmzMpmMRo8erRUrVhgLCAAA\n", + "IM1KJlennHKKuru7+3w+a9as0AICAABIM0ZoN6y+vj7uEGLBelcX1ru6sN7VpVrX26SyHdp9F5zJ\n", + "KKSiAQAAjDKZt9ByBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAGkVwB\n", + "AAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUA\n", + "AGAQyRUAAIBBJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAA\n", + "gEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRXAAAA\n", + "BpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhUMrnatm2bpk+frvHjx2vChAm65ZZbJEk7\n", + "d+7UjBkzNHbsWM2cOVPt7e2RBAsAAJB0GcuyLKc/tra2qrW1VbW1ters7NQJJ5yg9evXa+XKlTr8\n", + "8MO1aNEiLV26VLt27dKSJUt6F5zJqETRAAAAiWEybynZcjVs2DDV1tZKkgYMGKBx48Zp+/bt2rBh\n", + "gxoaGiRJDQ0NWr9+vZFgAACI0ltvSV1dcUeBSuO6z9XWrVvV3NysqVOnqq2tTTU1NZKkmpoatbW1\n", + "hRYgAABhOfJI6bbb4o4ClcZVctXZ2am5c+dq2bJlGjhwYK+/ZTIZZTKZUIIDACBs770XdwSoNP3K\n", + "TXDgwAHNnTtX8+fP17nnnisp11rV2tqqYcOGqaWlRUOHDrWdt7Gxsefn+vp61dfXGwkaAAAgiGw2\n", + "q2w2G0rZJTu0W5alhoYGHXbYYbr55pt7Pl+0aJEOO+wwXXXVVVqyZIna29vp0A4ASJ1MRvrud6XF\n", + "i+OOBHEzmbeUTK6eeOIJnXrqqZo0aVLPrb8bb7xRU6ZM0fnnn68333xTo0aN0tq1a/XZz342tCAB\n", + "AAgDyRXyTOYtJW8LnnLKKeru7rb920MPPWQkAAAAgErCCO0AAAAGkVwBAAAYRHIFAABgEMkVAACA\n", + "QSRXAAAABpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAG\n", + "kVwBAAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXNl47jnp\n", + "xhvjjgLw5+23pZtuijsKAKheJFc2fvAD6R/+Ie4oAH9+8hNp0aK4owCA6kVyBQCApJ07pS1b4o4C\n", + "lYDkCgAASV/8onTUUXFHgUpAcmUjk4k7AgBA1Nrb444AlYLkCgAAwCCSKwAAAINIrgAAAAwiuQIA\n", + "ADCI5AoAAMAgkisbPC0IAAD8IrmyYVlxRwAAANKK5AoAAMAgkisb3BYEAAB+kVwBKdXennvJOAAg\n", + "WUiubNByhTS45x7pW9+KOwoAQDGSKwAAAINIrgAAAAwiuQIAADCI5AoAAMAgkiuk0nPPSS+9FHcU\n", + "AAD0VTa5WrBggWpqajRx4sSezxobGzVy5EjV1dWprq5OTU1NoQYZNZ4WTL7aWul//I+4owAAoK+y\n", + "ydVFF13UJ3nKZDK6/PLL1dzcrObmZp1xxhmhBRgHXn8DAAD8KptcTZs2TYMHD+7zuUUGAgAA0Ifv\n", + "PlfLly/X5MmTtXDhQrW3t5uMKXbcFgQAAH718zPTJZdcou9+97uSpO985zu64oor9KMf/ajPdI2N\n", + "jT0/19fXq76+3leQgB0aTwEAfmWzWWWz2VDK9pVcDR06tOfniy++WGeddZbtdIXJFQAAlerUU3Pv\n", + "+vzLv4w7ErhV3OizePFiY2X7ui3Y0tLS8/O6det6PUlYCbgtmA7UE4CkePxx6cEH444CSVG25Wre\n", + "vHl69NFHtWPHDh155JFavHixstmsNm/erEwmo9GjR2vFihVRxAoAAJB4ZZOrNWvW9PlswYIFoQQD\n", + "AACQdozQjtSiQzsAIIlIrjx4/32pwkadAAAAhpFc2XDqKH3yydLxx0cbC5zRoR0AkES+hmKodE63\n", + "m954Q/rww2hjqST790v79kkDB8YdCQAA4aHlCpG55BJp0KC4owAAIFwkVza43RSOV14xWx4d2gEA\n", + "SURyBQAAYBDJFSJjuqWJFkYAQBKRXNngog0AAPwiuUJkSFoBANWA5AqpRYd2AEASkVwhMiRDAIBq\n", + "QHKF1OI2IwAgiUiubHDRBgAAfpFc2eD2FQAA8IvkygOSrmShPgAASURyZYPbggAAwC+SKw9IupKF\n", + "+gBQabZvl/74x7ijQFAkVyVYltTaGncUAIBqMXu2NHFi3FH09p3vSF1dcUeRLiRXNvItIj//uTR8\n", + "eLyxAHDnlVekBQvijgIIZv/+uCPo63vfk3bujDuKdCG5spHvKL1jR7xxoDQ6tKPQunXSypVxRwEA\n", + "JFeIEMkQAKQTfVy9Ibmykd+JSAaSjYMdhdgfACQFyRUiw8UPALyhr1M6kVzZyCcBxckALVnJtGcP\n", + "T7IAqEyHHSY1NcUdBbwiubKRT6JIpswyvT3z5Q0YkHuaBQD8SPq5/t13446AOw9ekVx5kJSd67vf\n", + "la67ru/nGzZIe/dGH08SvPZa3BEgbkk5PitFd3euVRiAdyRXNpJ+kv6nf8r9K3bOOdJPfxp9PG6Z\n", + "3q5JrycgzZYvz7UKV4Okn0uSHh/6IrlCZJLe9A7gkDfeiDsC5HHuTJ/UJle33CJ98EG0y2QHTxbq\n", + "AwCiQeuZN6lNrr75Tempp8IpO0k7kWVJTzwRdxRA8iXpuAVMYt9On9QmV2FyahGJYwd//nlp2rTo\n", + "lwsAAPwhuUo4xm9yVpjscosQAJAUJFc2nFqo8hfwd9+V3nknungAAIgTtya96Rd3AEnm1BoyeXKu\n", + "RamtLdp40Fth/XDgg33ALFqDAf9oufIgf/JuaaHlqho99pj0wx/GHQWAasMXh/QhuSqBHTo9oviW\n", + "feWV0iWXhL8ct9g/EaZK3b8OP5w3OiB8JFclJKFZ3CmGJMQWt0o9+bvFPgB49957uaewK8WAAdKD\n", + "D4a/nGo/33pFcmWjXId2+BPm9uPAB/sAqtGePdKmTXFHgWIkVwnndMHgQkKyCwAS58IkSnVyFfUO\n", + "FUdCU0kHTZjbr5K2EwAg3comVwsWLFBNTY0mTpzY89nOnTs1Y8YMjR07VjNnzlR7e3uoQUYtDa1C\n", + "JBPV5733pMJDLQ37KYB041rjT9nk6qKLLlJTU1Ovz5YsWaIZM2bolVde0WmnnaYlS5aEFmApYV1c\n", + "ktSJvJIuoKa3X+G2qaTt5OS446S/+qtDv3PS660a9gFUp3L7NueC5CmbXE2bNk2DBw/u9dmGDRvU\n", + "0NAgSWpoaND69evDiQ6Jes8h4rVjh/Tmm3FHAaCa5K9BJHDe+Opz1dbWppqaGklSTU2N2mIaqjys\n", + "yiZxSQcOdqBynHmmdMcdcUcBmBG4Q3smk1GmSrKRJK0miQUq3ac/Ld1/f9xRICr33SfddVfcUaAY\n", + "1xp/fL1bsKamRq2trRo2bJhaWlo0dOhQ2+kaGxt7fq6vr1d9fb2fxTkKO9lhp0KSJSnZD8Pevbnx\n", + "e77whbgjQaWptHN7pa1PVLLZrLLZbChl+0quzj77bK1atUpXXXWVVq1apXPPPdd2usLkqhIkaQeu\n", + "9AurG9W+DZK0PyZBte8PqFxx7tuV3OequNFn8eLFxsoue1tw3rx5Ovnkk/Xyyy/ryCOP1MqVK3X1\n", + "1VfrwQcf1NixY/Xwww/r6quvNhZQknCyBoDKk7ZzeyUmNpWubMvVmjVrbD9/6KGHjAeTNMU7dNoO\n", + "yEpXWD+7d8cXB2DCuHHSrbdKp50WdyQ5XNDTI8y6Yj/wJ9UjtIeFJCp9NmyIOwIgmJdekh5+OO4o\n", + "kERck9In1clV1Bk1GTyShBNub2wPs9iepX3jG9LFF8cdRfgquc9VmFKdXIUlDSeVNO7oYY7QXo3S\n", + "uA8AlWLFCulHP4o7CiRVqpOrqF9/g3TIZKTnnos7CiDdKvk8WGnrRp+r5El1chW1JLWUJCkWt0zH\n", + "XOqgf+01s8sCAMCtVCdX1fD6G741VLevflVauzbuKNIhScdtJbDbntdfL+3cGX0sprGvuMc1yJ9U\n", + "J1dRS9JOlqRY3EpjzHG7/Xbpttvs/5bkC0R3t/TOO3FHAdP+8R+lX/867ihQLIpzK+dvb1KRXB04\n", + "IO3b1/fzJF9cTKmGdfSLbZNcd9whffRud6QUF9PkSMII7fAmFcnV7NnS+PHRLzcJO5VTDGlMLNIY\n", + "c9IU7g9J2D+dtLTEHQEAxMfXuwWj9oc/SDt29P086osLyUEwTvV18KDU1SX92Z+ZKc+UX/0q12J6\n", + "3nnhLgdmcHyaxfaElOwvcUmWiparuCT55FJJO/yXvyyNGhV3FH2df770xS/GHUVvSd4nkR4vvyx9\n", + "8EHpaSrpHFOs0taNPlfJk+rkKqwLTb7c4p2JnSsczc1Sa2t45R99tPT22+GVH6XCfTDJiRbHSrw2\n", + "bSp9TB13nNTYGFk4VS+TkTo7447CH45lf1KdXFVzpSf5wurGvn3Sz34WrAy32+D116UXXwy2LFSW\n", + "ffukSn73/NSp0oIFpadJ68XehDjOn++/H/0yEZ9UJFdJSaLSntAkSVNT7rYbvCncB5NyXCSFl+Nz\n", + "9WppxozwYkmCoPsH57v0YIT25ElFcuWkmg9+dvjwtwHb2L+kb7vu7rgjCF9TU7D5k16HQVTyuoWF\n", + "beZNJMlVV1ew+ZOSRLFzAQC8eOml4GUwzlX6RJJc9esntbebL7caXn/jJA0xJkklbq9KXCckRyXv\n", + "X1Gu27hx0S0LyRHZbcFyj/0CXpU6QVbyhSEN4vi2S53DrUprjaHPVfLQ5yrByyu0cmV6RueOSqlt\n", + "UKnbh30AUam2/Wv79rgjSLZq2x+CSnVyVU0WLJD27o07imDiPDjff1/6xjfiWz6A5Cj+ovz009LI\n", + "kd7KqJZko1rW07RUJ1dRPy2WpJ0sjla073zH3DYIe1sWb5/f/15avtxbGUmq77y03PqK4th85JFw\n", + "l1Ht0rKvmbB7d9wRlFauLpJ4rqp2qU6uqlkcB9P3vpeeR9iLt0+lXCg4ieZs3Sp9/vO9P6uUOo5K\n", + "Ne9LJs4PUe5vcdZVNe8nQcSeXB19tPTOO/7mDfv1N2k8WSc55sLYTMSZ5HWNQpLXP+wTclqS/CTo\n", + "6vLXMsNFtbRS26ezs/Ie4mJ/8Cb25Or116VXX/U3b9S3BZN8McuzLGn2bOn+++OOpC/T9VWNBzsj\n", + "tCfLdddJX/ta3FGU9v3vS5/5TN/P03A+C0vxupveFmPHSrNmmSuPca7SJ/bkyo2kVK6JOB59VBoz\n", + "pvdn77yTe9eZF6UOtl//Wvr5z73Hht6SePFJyrFQzQrfybdsmfRv/xZfLG5s2eJvviTu/6aYOI5K\n", + "bZ+WlmjfZ8p5IXkSkVzFcRDfdZf0938f/XKzWemNN3p/VlMjXX65t3IOHsy1+jkxebBZlvS735kv\n", + "N++118yXaWKf4oTlX6WOc/Xuu9LAge6nv+kmacWK8OIJE/t/adWyfaplPU1LRHJVjtNJM8jJ9Lbb\n", + "knXSe/tt7/OsXdv3szAuMM88I518svlyw8QJwb3W1spupTDJ63Aoixbl/iFZwr4tWImczqm//710\n", + "xRXRxpIGqUiunCo16gtoHAeg13XMT28y1oMHzZVlUjWeEE0/FCBJu3aZKSftdu8Op6N83Il+3MuP\n", + "woUXSj/5ifvpw74taGoZbsU5QvvOndLzz4e3/LRKRXIVtWq8aLsV5ThXmYy0Zo2/Miq1DtNyoUxy\n", + "nB98IB040Pfzz3xGuv326ONJqjQdQz/9qXTnndEuM8p9PMl1YVnJji8uqUiuklJxldqPJMmeecbf\n", + "fGl80tOrJCcwcXBbx2PGOD/h9+ab5uLJi3vfc1p+uf2H/SuYuOvdFDf7SaWsq0mpSK6cKrcaKtTr\n", + "CS7sbWLqhFsNdReGTCb3JNLcuXFHkl4tLXFHgLiZ6HOVpHNYFIlwqe45SdoWSZGK5MpJJX2zMrVz\n", + "VtI2CaJ4e/rZLkls/bIs6YknpF/+Mu5ISmM/TL4k7M9xMXFsV8s+TsuVP6lIrkxX3JlnSjt2lJ8u\n", + "CRdXv8ushgM/6vpI2jblhBa/pO0TxSxL+uEPnf9WCvsX3CC5speI5MrvUxd+K/S++6SXXvIeTxwn\n", + "0qSdvP3E8+1vS4MG9Z7XxHp5KaNSDv5KWQ8v9uxxN101bpswJe3cY1JaXr+VhDpw+/ARektEcuVX\n", + "YaWfdpr5x0GTtsN42clNxh70AN+0SeroiGfZlcayDm0Tr9tm+nRp5UrzMdkxVW/PPisNGGCmrDAk\n", + "4Rwxfry/110lIfa4RPHlzsQytm7t/Xt7e3jLKicpQyKlRSqSKzcngYcflh56yOxy/ew09913aDTz\n", + "OET9vsVS9uzJJVV2CV8aT+xpjLlQNpv8vlrF3Ny+r3YvvOB87it1vIbxrs8PPzRbZlTsju1t29x9\n", + "YXdKeEwoHLfwjTekwYPDW1a5GEr9Pe3nxjCkIrlKkzPPlL74xXDK9noyfOCB3Os6gnJz4OzfL11y\n", + "Se/PPv95adw4++ndrktUB+1tt5UfSbtavqFt2CD97GdxR5Hz8Y9Hu7ww6jit+43XY2/VKulTnwon\n", + "lrDZreusWdKkSeXnufBC92UGictv63+Y/uVfpHPOIbmyk+rkKsoKnTLF/cuV4zyZFm6TL3xBuu66\n", + "aJbb0tK34+xLL0nbtx+KyfR2MVn/S5bk3gOXdFG0/v3t30rnnx+sDFN1/TEPZyhO8H0FqQev85Z6\n", + "12nSuNlX7AaaLZTfPmG2XLndp+MaoT3fEs6x11eik6vVq3MXvSD3ev/wB+kv/iJ4LL//vftp40yu\n", + "knRbsJSoX6xcbnlu4knCCaTamuCjbrkKY9tWU32V8utf51o5wvKnP7k/JySlNfHHP86929NJXPvO\n", + "rbdKX/96+enC6ONbKRKdXF1zTe5fEL/7Xe7euRdBd5SwDlwv5Sbl5CHZb88kxedW0mJOWjx+HDwo\n", + "Pfec89+9tFyV4ufF6G7EVQft7d5fIl0s6gviXXflbjmH5d13cw9ARMXE9rvoIunf/i3cZfhx8825\n", + "BKuQ3b5OcuUsEcmViVaFJKmEi56TtK5bmsf0SfuDAIUWLJA2bjz0++rVUm2t8/RBWq4ymdzTVh0d\n", + "0ogR/stJosMPl847r/x0UXZoTwK/HeqDDCIa5nZMQvLi5h2uaT8vhSERyVU5aXv9TZwtV363yXvv\n", + "Ob9Xze/6FD7pUkk6O3MtLlExPT5YFJziXLmy9wt2P/igdDlB+1xt3x5tXUWlq0vasiXuKOJ3xx3S\n", + "zJnBywlyjgo6RIGb6ZL6HkiSK2eBkqtRo0Zp0qRJqqur05QpU0zF5FpSLzRp7HP1P/+n9N//e3jl\n", + "hyHK9yju3HloeQMHSlddFe6y3UjyCS2ODu3oy02rQ5qtXSs9+OCh36NcJ9MP6mze7LyMONFy5U+g\n", + "U1cmk1E2m1Vzc7M2bdoUoJxgf0+aJCQgXrfZzp3hxCHZxxJVh/YXX3RXVql4urulww7rvbzXXnNX\n", + "rmlpOxaCSnpy5aY+knA+sOP3VnmYb7AIun93drof0b/ccu0+u/126bjjcj+b6mpgWbkW3Lq63O8v\n", + "vNC3jCQc96X6XKGvwKcuK4IzR5BFXHqp93mCfiNJQof2Ug4eDN6xNJOR7r3X//xRXXBMDJqZpItj\n", + "Gm8RFvNyQg76tOB//Vew+atZHCNyuy374EHp5Zf7fn7GGbn+dZ/+dOn5/SYFDzzQd7kmtkd3t/3n\n", + "hXHG1X+Olit/ArdcnX766TrxxBN1xx13mIop9fzs6Ka+DbrZyX/zm0OPRJcby6W4zHfflWbPzv1s\n", + "olWonKiGfkjLUAxOfv1r6ctfLj9d0CfM3IpjyA67aS+4wNvy0pqwOknSbUGT2/bOOw+1IBV7//3y\n", + "+3kSWtnykrjPeR3kOcnnxrgESq6efPJJNTc3a+PGjbrtttv0+OOPm4qrl7gqzu9y42y58voEyyc+\n", + "4a0Vq7k5dyEPKk0HYxRPBQX1H/8hrVlTfjq3CbEkDR0aTt+yoAlTkiR5nyjHb+xOddLV5T+WcmUX\n", + "i3q08u5u6dVXe39W7rxgct9watkyob1d+uY3nf9Oy5U//YLMPHz4cEnSEUccoTlz5mjTpk2aNm1a\n", + "z98bGxt7fv7tb+s1d269p/Ljvqgl4bZgFDutl6eOTLXKJembo9uyknYhDXuIhnfflZ56yny5SduO\n", + "YfNTNwcO5F4pVe72VjlBtrXX1nQTCUBcg4CWq6O77sq1gp57rtnlSmaeFiznySelqVOlfjZX/N/9\n", + "TrrlFmnZMu8xpD25ymazymazoZTtO7nau3evurq6NHDgQO3Zs0cPPPCArr322l7T5JOrxYulk092\n", + "LstvxSS1Qk0e+FFdiNI2srEU3Wj0cazzM8+4u2Wbl6R6kZIXj2mzZvUer8u0//W/pJ/8JHhrUEOD\n", + "/3krvQ4LlbuW2LWUhfVar0Juz0Hl/n7KKbn3hboZG81L2WlPrurr61VfX9/z++LFi42V7Tu5amtr\n", + "05w5cyRJBw8e1AUXXKCZNgOOeLlof/ihtxd/JvXgT/o4V1Ftt7AOvM5O98s24aWXzJXl1rRpzgMi\n", + "xt2iG1RYJ+IoT/BNTeGW/+KLZlqC7r47eBmmlKqft96KLg5T7I4/P8ekm47qJvYFpy9rQZ4CzD/N\n", + "m9bkKky+k6vRo0drs93AHA7K7XS33y597WvJuGAk6fU3XmPxO3BnqelNrY+fcuzeu3X99c7T//Vf\n", + "2y/LT4f2/GeTJtmXGQenx8yTdHJrayvf4tLSIg0bFk08YUrSlxmv3O4zmYy0Y0duOJKwFPdnSpOg\n", + "rf5R3BYsLOPAAal/f+/z2Ul7y1WYQh9Fxu1O8cYbfT9La4WZ7Hzo99H7Uq0bUW/XIONcrVnTt6Vq\n", + "/37n6R97zP5zE98oo7xIJvWCXOztt6XLL+/92bBhuT4cTjIZ6c//XFq/PtzYomC6nm64IdzOy6tX\n", + "HzqevIzT9M477peRhn3XxNPBpsbvM9Fy5Wabd3fnrrOf+ETvz72Mx1WM5MpZZEP0lat8u4525SSl\n", + "Ql9+Off4b16cJxfT2+Tmm3N95vLiaMXy01pjsuUuqcLu0O7Gr36V20f82LHD/vO1a3PvIKxWXo4N\n", + "r2M3z58v/fzn5uMonD6K81/QZXht2S5VhlMsxWUG+YJnquXqvff8x2AnjefNqCRm/GM/gwUm5RvS\n", + "ccdJX/3qod+TEpcJ3/1ubuC8vCBPC/o9EJ2SKy+D6pkY5yrKeg3rpJWkfdMplhUrcu8g9Cq/zfxc\n", + "QIrLMO3//l/p+efNl3vddf7nTeKFMW3D7pRi6k6D17KCxvPv/25/J8kOLVfOEnFbMJPx13Jlyttv\n", + "Bz/xFd66MjmIaCG/9+aXLpX+4i+8lePF3r3SK6+Un87vcvft8zefF3EkV08+mbvdUl/f9wXGSUqC\n", + "wuJmVOo8L9vj8MOlZ5/1F1NY/vf/dp8I+bkoe1F4Ic9kzB1fJlpZ3Mw7bZr07W/7X4Yppp4WLNX1\n", + "I/+7ieuj29vNN91kH4Mdkitnqb4taMqcOYc6LZuQtAtjNitt21Z6miAxX3tt6TfTBz3w/DSvh3Gw\n", + "O93G8uuUU6RvfUt69FFvfVryCrdDqfX9xS+ke+4pP50XBw5IX/+6v3nzT7C5uZ3id79sb/c3XxJE\n", + "NcRIfhRzp6dSg5Yfliee8DZMSVgK19NN4uKlpb3485oa93H5Wb7f+UmunIWe0ritULvbglElKcUd\n", + "pNP8bkG7nfz118tPEySG3bv9l5cm5RJUP9z21/ArX05xJ9ag3n5buvVW6Yc/9F9GvuXE9LT56Yt/\n", + "dlNG0r4YhWnVKrPlBR2LSUrWRbrUECy//e2hny0rWOuf34eWgizH1HwkV84S03JVqs9V2iouCSfo\n", + "wm1musXFK9P1F8b+ENc+FqSPRdoTBdMtV3Fsj6T31QlavhfFsbS3++8UHzWv9bh2rb+6/4//kOze\n", + "ElfuPGAicXVqXStO7tx08cgjuXIWanJl91j8yJHSN75hE0iJSJJ6wDm9Y6843v37pT/8wUxM5dgd\n", + "jHFfZE0feH77niVRmHHanUyj3i6PPppr4bITVp+r4jLKzbt3r//hD8JojUlCohREPqbBg3OjgidR\n", + "cZ2YHkLBafqGBunSS3PjvBXeIXFKotwu4wc/cLf8cuy6J9By5U+oydVf/3Xfitm+Pfcuo2ImKsft\n", + "Ew5uldtqX2UMAAAgAElEQVQZzznH/vODB6UHHzz0+x13SCecEH48QcpJ8sERxQUkrPcflhPmbcEk\n", + "1PPVVzv3zfKSJIfZkvfpT0vLl5cv36+k3eqJsttCS4u3eaPaP4NuAzfJe6l12brV/vOw95Ug5wT6\n", + "XHmTmNuCJjh9Qw5LqXX6f//v0M+mO4yW4ndgO7e3p/x8qzY94r2JAQCjdvCgdP/90iOPuJveTWf1\n", + "ctMUtsYksYXDS8uVV15bbk1/MQsiqqcF/Sq3P4b9tGBauF0Xp6SnsIx333X32i8/8QS55ZjfF5yS\n", + "xWoWy1AMzzyT+/+hh3L/J+1CGCST97usMIcCMNEEHjQGk5xiuPTS8tNE5e/+rvd4S/37S2ecIc2e\n", + "3Xu6MG9xxr0NynGTXJm4YBeXlXRxxOk26ZfC77vW2Zl7hVJaeEmiyn3u9GX2y1/OPdUehNeHQtzI\n", + "l/fww2bLrQSxDiI6Y0acS49H2Imk3QEcpPXJRNJnuuXKyW23+Y/BdL3ccYf01FPlp3MaX81E61xh\n", + "8pK0LzCSt9spYfa58lJ+0hI0Uy1Xn/988PGugiTCha3c8+bF997JoF9k/K67m/mCPpjkdjl28zlJ\n", + "4nklKUJPrp57Lvd/kAt8Oc3N5soqZOIJDRPzxCkJ8Zq4LZiE9bDj9Li3m9uChQqnyX/rD/MddSa4\n", + "Sa68HINJeXpy0SJp6FD/84cdZ9S3BQcOPHS3ohzLyg3zEZegyVGp+d38LczrZNDzQRL6cKZJ6MmV\n", + "03vHTO40f/mX5soqlLQLsolOvWHE4LZVyNTtrbBvSySN1/XNH3Ne+x1Jue0QVR/BMJ8WdFr3e+91\n", + "v8xy5Tr53e9yfWT8CrvPVVBel9nZWX7E/DCOv44O7/ME3Z5J/sLtdFswyJeSJJ834xZbh/akJS6m\n", + "xL2zmd6uca8PnJWr67S2XLmZxk8CYlm5EfEriYmLualzhonbgiYNGhTN8v3ebrNbfpjXSac4gyyD\n", + "64Oz2N4tWNyc7/cptzD52enCjNnP7TE7QbZ1uYOzVMuWqZarShpE1A2/sXm9tRg1Ey00Yfbb8rK8\n", + "IB55RNq1K9xlFHK6gHtp3SxVbpov1n773gW5LeimQ3uxffu8b+cwxnKLu76SLBHJldN0cbVuBUkG\n", + "TL3MM8/rweq3A7qJFgI/y/UzX9KSXhNKxeclgShkquWqtVX64x/NlFXIbr1Gj+49OK+Xb/ROfbWS\n", + "3kr++c9L3/veod/Dvi1YPE9+P/GbWJTi9rgzfd70KmirW9DE0ut8n/ykdOed3pdhuhEj6efVOHFb\n", + "0LBq3NnKdUA23XKVZnv32icqQdfx1VdLl1n8/sznnpMaG92Vff750sSJvkNzZJf8eR0vx1QiktZ9\n", + "zGRrXBi3tsJI2MLk9otMWIm8l+vka695L7vcF+tSLb5+v8xXq9iGYojiVk8cTIxY+8orh56uCeOR\n", + "8qVL3cdS7qm7/fvdt5CYOoGm/bbg/fd7m95NbHad0EvVy623SosXu1t+0Ef0nXjZn4P2ifGyTLdl\n", + "+VXugYGkt1yFeazEfR3w04Lvts9VqbKjuHPg5jztdXlx11eS9YtqQWlsufLT/G2i2fW006S33jLT\n", + "UdJONut+2nL19md/VvrvkvRf/+V+eZL0y19KI0a4jyEs5Zbzgx9IX/taboDQMD36qP3n5eJL+jFm\n", + "ImGKus9VUO+8I9XUxNuK5pRcufX++6XL9dPCkZTbgn6nN3Vb0Mv8TvVQbhlelZqv1DuBq11i+lwl\n", + "kZ9vkOVO6mGPjp7EbxJPP5373+32nDtXWrDg0O+m95VPfrJvwuJnu33rW6Wb5sPom1JuWYXLdHPR\n", + "fOEFadIkd8uYP1/as8dbXKXWy8s3aa/7vlNrlVM8Ub2Vwev2KyeO24KXXmo/IrfbcpKa+Er+Yw/a\n", + "Z8tp+aXKu/12b8vp7vZ+nvnDH0oncUm83iRFYm4LxmX79r6fmejQbseypAMHvJcZVJBt7XUwTjfL\n", + "ymalN9/M/Wz3FvZyZXo5oLu6+n62b5/7QQ2jEnRf85tcPfFE7r2HbmJYvTp3y9oLUy00Jlovozrn\n", + "RPVGAq/TOt3+83pbUHL/ehqv2yKui7Xb5CjI3+++23meqBohvJZ3wgnSNdc4z0ty5SwRL26OM9Ea\n", + "OdJseaUSs5/9rPdTQW4Eba4OymR5+bKmT5e++c3cz3bJj6mYfvlL6dpr3U2b5pPEW28d6iTvtX+R\n", + "3ycKTb1cOeio6lH12/KyvKQuI39xN5Fc2bHbzl63fdxfuv30O3PbcvXtb5dfZpjr77dfWPHDMMuW\n", + "SSeemPs5zefNsHFbsATTLVd2T3R54XebRflevTDq1anMcn0OCrd3WC8szbfAxemqqw797LblqtSF\n", + "sFC5MY2C6O72f9H1c/vGS/lu7NvXe3wqU8Jqudq92/5zU8lVXhrO7U7C6JcUZH6T29LNbUG75RV/\n", + "du+9h0bcJ7lylpjbgkmsJNPJlen5TI1ZEtbJ3NS8liX99rdmxm1at87+c78X4zPOCBaPaV6/BQdt\n", + "GQq7D2G5FoH857W10rZt9mWbarl67bVcK2Hej39cOqYoeFnW3/+9/Tymto+J9Y77tqCf6ePqc+Vn\n", + "OeW+QHldXhKv20kRWctVqZ3G7w50ww25e8JhMZVcmboAxfGN0GQLQJDk6q/+Slqxwt/8hcv+m7+x\n", + "/3uUwzv8n//T97MwWg3CePTa6/x+Bkf147nnnF/gbmo5xxyTG/Azz2v/Sb+d5t98U9q82duyvJQf\n", + "5m3BuJnqVuF2iJ2gLV9x3BYsd40pFRvJlbPEtFz5aZX4zW9yTzMkQfHBF+TbQBBumnWDlBdHy1Xe\n", + "V7/qf14/jwzHXW9By3GzLxQed35aMIPEHeRpQS/LnzHD/bRemLpwl5tu9myprs5MDHbCvC0Y9sXX\n", + "VLLjtoXU79/LLTsptwW9IrlylogR2j/8ULryyqgi6ctp9F0/F5sox/2I+xui10eqTfRnCGudwzxJ\n", + "fPBBeGVLztvHLnkxMcht4XKC3FaM6sXSL79cfpqwb6d7lY9n7lzp+efNxuCn5WrhQu/lJkFYCbBT\n", + "h/agwm658nO8lpqH5MpZIjq0Fz+NkBRBbgtG1RLhtPxyn3n5e9zivjVqx8s2u/nm8tMk4bagl2Z/\n", + "Ey1XbubNT3PXXeXnDdKKUS4WP0+1umE3FEzhRfCXvyw9v4nkyk0Zv/ud+3KTdLyaarkqNyRNGlqu\n", + "vBxvbiX92hGn2G4LPvfcoZ+TegAGSa5MlVdunrffDv5SXT8tdE5eesn8crwmDH6WZ+ok0dHRd/lu\n", + "Wq6C7BtB3nNWbnuWK+NrXyv996eecl/2e+85T5vvjF2ujFKCnGd27Ahent0+ZjcUTNDzodcWQRO3\n", + "BS+7LDcgbVCmW5pMlec2MQ9ad8XHi8lrY0eHdOGFpacp1XJlWdI//7P00EOH/kZy5Sy2Du1/93dh\n", + "LzlaJl9/U6hcn5i/+ZtwXqrrhl08tbXepvfK7YXD6+CnpgwaJD3+uPdl+4lv7dq+87pNRP/930vP\n", + "W04YdXnnneEsJyxBLtzlBmMNMmJ8uTsBbltdSr0DsTi+ZctyT/Q6xRQXp1gee0waOND7ezNNtOT+\n", + "53/2nTc/36xZ3uIp9sYbh96IUezll8sPB1Qu/nwd55FcOQs9uWpttf/cKWlobfU+CnRQJsbysWtF\n", + "cLucUn8rdYHcs8f5QPLCywFi+jaQm2Z4PwmAZYV74JeKw82o80GsXJn7/777+v6t3LbyeksozHGu\n", + "gtSRn9swSbrol7rN5qUPj9c+MnacWq5KvarHbUtO3CO0O8X59NNSZ2fuBeaF07m9LVi8DK/7o9v3\n", + "Anqty3POkU46qXxZv/qVdPnl3mMofpcsyZWz0JMrp28zhUlD4c+zZ0vHHht2VOExvbOVSq6uv97M\n", + "Mgrr5te/dn9Amxql28s0fjtBOy3n+utzyVCYF1677XT22b1/97L8pibn8sttq1Itel6SMVPJlYlp\n", + "8kwde24HBg2rf0rYtwXDrNOgTMdQrry9e80sP2jcXm5H+l1W4X7xgx/Y9wUtV/YnP9n7d5IrZ7H1\n", + "uXrjjUM/F1a66RebulG8Q/nplF58W/DgQWnnTu/llIotigN/9uzwRh33e6Lwsw3cHvT/+I+5gUUL\n", + "90evvL6dXsp9cywUxj5ios9VmIIsO0gftUL5W1+F+8uQIe46sAeJwW+LoZsYysXu9EXXVGJjV05Y\n", + "F2FTr09yWy/lzmF+9wkvyZVffr/MFG6bfv16/y3/dDxJVl+xJVeF4jzBm1J8W/CnP5UOOyx4uVFs\n", + "mzhvC/rtfOt1Wdmst+V4UXwb0MQJ0WtfELtl222rUrcF3VwUTT4N6+b2l5e/u4mpuJtCvhN98cXV\n", + "73G3b1/pW6luLuJubws6TRNFh3a3D+6E1brnltfl+01ygrT+lZrHLlEO80u23/oiueorES9utjsZ\n", + "FD51FTaT/Ur87mRO42P5HeSxUFg7vokTV1QtV4891vv3NWvcleO2/KDCaDUI42QadD7TZRQqVyfv\n", + "vZfrZ1NK/mJWfE5yu+9+8pN9OyzbzVMuuXJy7bXS3/5t6Wm9tlw5xZSE24RBmWohLDW926TZKa5S\n", + "ybTdtbHcE7pulullmsLPnL5skVz11a/8JOGzOxkMGhR9HMWC3Ba0+1spbpIrv5LyYmYTyZXb7fHx\n", + "j5f+e/7Fo3kmt1Fjo/cyTdz+LZ43zNffmE6u7r/f/nUy5VoSSp34i7lpDQyaXEnOt4kzmeC3BX/8\n", + "40O37QvLK+S1z5VTy5XXVk67v8U9OKvXZMdpetOvvXF7HrOb7oc/9LasPBPbleTKvUQkV3HfFjR5\n", + "vzvMliu/gt56cRJHh3a3sZZLroIqFcef/lR+mlLlRZlclWsZDbMvSOGyzzjD+SknU9zEnI+p+Auf\n", + "qXNU0JYrN+vgdcBTp3Ur/tzkedqyorkge91PC1/+7bYcPy1Xxced03wmB6+1W8Y770hnnll6mlLr\n", + "RlLlLLG3BeMU5NuW352tMBlwutBG1crwyCPhXFT9fMv2O72b1xCVG/26lDBvmQQ5oZq4jRyV4gvs\n", + "wYP20zjNW+rvduxGQy+W335uEgs/t8WDJldupjXVclVqGwQdLLnUNCb7gPq5TVfKunVmynHTMmo3\n", + "XRB2ZRUO5l0qDie0XDmrmg7tpcbOCrvPlV05F18s/exnh36P87Zg8d8vuig38rvk7+lNL4lZWLcF\n", + "3Rzsc+f2nX7LFmnDBm8xmVBYnqnkKowO7aWm9aq4jOITvWlnnFE+BqfbgiaSq8J5TLUWh9nnym/L\n", + "VdDkyiRTXxJNj3Pl9kuQ6dZCP9PQ58qfyG4Lxt1y9fzz0tix3uYx1efKzo9+JG3deuj3wuSqsIwk\n", + "t0SU+rZld1vORHJl+ptosSuvlH7xi/BupbopL8yWq+JbEKbHDfOieNle+lyZUjwkhpfbgn4u0E4t\n", + "Y37L9dNyVTzKdr6PWLnkytStaxPz55nuC+WX1+SqeP+KouWqcBkPP1x+GjskV+5VTcuVn2b4/Odt\n", + "be6X46VDe+FynfoIRdHnyonfC4rp9/+ZSAZKyWScWyycmE56o2q5Kv7c6wUzaMuLXVlB5g16wf/q\n", + "V3v/nh85vbs7957Mf/iHQ7+bYPq2oJ1y+8+99/b+Pf/KlWpqufI7ndO8XucvrKNS85rscxX0i1Tx\n", + "bXyJ5KoU38lVU1OTjjvuOB1zzDFaunRpoCCS1ueqWP4WmRv79mVdT1t4UDndFjR5EvJSVne3fUtC\n", + "od4HVLbXvG6X77XuwzgpW9ahJ8m8X0CyZecp10+jWJDjoXDeFSv6/t2ygiWG+Xl///us59jsYjEx\n", + "jUn5l6B3deVeM3TjjcVxZHumjeO2oFN5krRkifTAA/Z917yWJRXvh733c699rr7zndzYf/Zlhyf4\n", + "crKSzCdppW7P5/30p9LGje7Kc3L11dLvf+8+Nrv9vBSSK2e+kquuri5deumlampq0gsvvKA1a9bo\n", + "xRdfLDlP3LcFpdxtOD8tS15OhKaTKxMtJA0N3ufv6vLWwdguuSoeqyzKPldet1X+ZbduvykWnoTK\n", + "zZN/etBdeeZarn78Y/vlmGi52rQp6ye8XoIMFWE6SSnm3GqTDVSu6ZarwmmvuUb6p38KPgBtV1fu\n", + "5ePFyVWQbR3GQLtuWFbuy3G599WWO6+VOiYLW66WLZMWLSofl5uWqwsvzL2mJoilS6Xbb++7TCde\n", + "v0SQXDnzlVxt2rRJRx99tEaNGqX+/fvrS1/6ku655x7fQUSVXDm9RDqveEcJ+wRQOGp4WB3aDx6U\n", + "Hnoo97OX9TlwoHzLlZPubve3FMPqc+WFUx+3UkzfqgwjuXIzTZwth2Ee90Hj7O4uv1+YbLkyuY/n\n", + "X+njVX65Dz8snXpq5dwWPOMM5/fVuo0j/+XLqYzCcm66qXx5bvtceWVXTuEr2fzMb1dWflqSK2e+\n", + "OrRv375dRx55ZM/vI0eO1NNPP11ynt27pfZ2+78Vjpps960r/5nT/IXy01x22aEmfinXiuI0OnPh\n", + "yai9Xfrgg9zP+f937y6/vL17cz8Xn4Da2w+9HLT4JaGF9u07VFbh+ha2/rz/vvM2yH+eX8f8sjZt\n", + "OtRysmtX73dDFc5TvN137rRP+ArXwelJQqd57U5Qhdu2cN0K66RwG+za1TuGUvtUqe1dPG1efp3K\n", + "7Wv5fSM/bSbTd4ycjg53+6zU+/iwe3FwqXKKYyll797e5Zfblh980Lsu8nEW7y/llutUdrmnUQuX\n", + "U1hGfp8oPOYKp/X6hofifaVwP2tvtx8YtNy2y3+Wj2Xv3kP7e/G+UVjW3XfbJ0jF271wmvx2/OCD\n", + "Q6/08Sp/fsm/E7W4bgr3m85O5zp//31p4MDcz9/8pv00u3b1XpfC81Z+vdwcO+USyfZ2aceOvuXl\n", + "z0X57V5qf7ar/z17Dn353LfP/hrx4YfurnmF+4VXxXHaXSvz9Wh3bS2Mo73dPo78fLt3997eTU2l\n", + "k85ql7Es7znzL37xCzU1NemOO+6QJK1evVpPP/20li9f3jPN0Ucfrddff91cpAAAACEZM2aMXnvt\n", + "NSNl+Wq5GjFihLYVfE3ftm2bRo4c2WsaUwECAACkia8+VyeeeKJeffVVbd26Vfv379fdd9+ts88+\n", + "23RsAAAAqeOr5apfv3669dZb9YUvfEFdXV1auHChxo0bZzo2AACA1PHV5woAAAD2Qhmh3eQAo0k0\n", + "atQoTZo0SXV1dZoyZYokaefOnZoxY4bGjh2rmTNnqr3gcY0bb7xRxxxzjI477jg98MADcYXt2YIF\n", + "C1RTU6OJEyf2fOZnPZ999llNnDhRxxxzjL7p9PhQgtitd2Njo0aOHKm6ujrV1dVpY8HofpWw3tu2\n", + "bdP06dM1fvx4TZgwQbfccoukyq9vp/Wu9Pr+8MMPNXXqVNXW1ur444/XNddcI6ny69tpvSu9vvO6\n", + "urpUV1ens846S1Ll13de8XpHUt+WYQcPHrTGjBljbdmyxdq/f781efJk64UXXjC9mFiNGjXKeu+9\n", + "93p9duWVV1pLly61LMuylixZYl111VWWZVnWn/70J2vy5MnW/v37rS1btlhjxoyxurq6Io/Zj8ce\n", + "e8z6wx/+YE2YMKHnMy/r2d3dbVmWZX3uc5+znn76acuyLGvWrFnWxo0bI14Tb+zWu7Gx0fr+97/f\n", + "Z9pKWe+WlharubnZsizL6ujosMaOHWu98MILFV/fTutd6fVtWZa1Z88ey7Is68CBA9bUqVOtxx9/\n", + "vOLr27Ls17sa6tuyLOv73/++9eUvf9k666yzLMuqjvO5ZfVd7yjq23jLlekBRpPKKrqbumHDBjV8\n", + "NBR6Q0OD1q9fL0m65557NG/ePPXv31+jRo3S0UcfrU2bNkUerx/Tpk3T4MGDe33mZT2ffvpptbS0\n", + "qKOjo6eF7ytf+UrPPEllt95S3zqXKme9hw0bptraWknSgAEDNG7cOG3fvr3i69tpvaXKrm9J+m//\n", + "7b9Jkvbv36+uri4NHjy44utbsl9vqfLr+6233tJ9992niy++uGddq6G+7dbbsqzQ69t4cmU3wGj+\n", + "ZFUpMpmMTj/9dJ144ok9Y321tbWppqZGklRTU6O2j972/Pbbb/capiLt28PrehZ/PmLEiNSu//Ll\n", + "yzV58mQtXLiwp/m8Etd769atam5u1tSpU6uqvvPrfdJJJ0mq/Pru7u5WbW2tampqem6NVkN92623\n", + "VPn1/a1vfUs33XSTPlYwwnM11LfdemcymdDr23hylamCcfCffPJJNTc3a+PGjbrtttv0+OOP9/p7\n", + "JpMpuR0qZRuVW89Kcskll2jLli3avHmzhg8friuuuCLukELR2dmpuXPnatmyZRqYH2b7I5Vc352d\n", + "nTrvvPO0bNkyDRgwoCrq+2Mf+5g2b96st956S4899pgeeeSRXn+v1PouXu9sNlvx9X3vvfdq6NCh\n", + "qqurs22xkSqzvp3WO4r6Np5cuRlgNO2GDx8uSTriiCM0Z84cbdq0STU1NWr96OWFLS0tGjp0qKS+\n", + "2+Ott97SiBEjog/aEC/rOXLkSI0YMUJvvfVWr8/TuP5Dhw7tOflcfPHFPbd2K2m9Dxw4oLlz52r+\n", + "/Pk699xzJVVHfefX+8ILL+xZ72qo77zPfOYzOvPMM/Xss89WRX3n5df7mWeeqfj6/u1vf6sNGzZo\n", + "9OjRmjdvnh5++GHNnz+/4uvbbr2/8pWvRFPfRnqLFThw4IB11FFHWVu2bLH27dtXcR3a9+zZY+3e\n", + "vduyLMvq7Oy0Tj75ZOv++++3rrzySmvJkiWWZVnWjTfe2Kdj4L59+6w33njDOuqoo3o6yKXBli1b\n", + "+nRo97qeU6ZMsZ566imru7s7NR0gi9f77bff7vn5X//1X6158+ZZllU5693d3W3Nnz/fuuyyy3p9\n", + "Xun17bTelV7f7777rrVr1y7Lsixr79691rRp06yHHnqo4uvbab1bWlp6pqnE+i6UzWat2bNnW5ZV\n", + "+cd3ocL1juL4Np5cWZZl3XfffdbYsWOtMWPGWDfccEMYi4jNG2+8YU2ePNmaPHmyNX78+J71e++9\n", + "96zTTjvNOuaYY6wZM2b0HMCWZVnXX3+9NWbMGOvYY4+1mpqa4grdsy996UvW8OHDrf79+1sjR460\n", + "7rzzTl/r+cwzz1gTJkywxowZY33961+PY1U8KV7vH/3oR9b8+fOtiRMnWpMmTbLOOeccq7W1tWf6\n", + "Sljvxx9/3MpkMtbkyZOt2tpaq7a21tq4cWPF17fdet93330VX9//+Z//adXV1VmTJ0+2Jk6caP3z\n", + "P/+zZVn+zmOVsN6VXt+Fstlsz1NzlV7fhR555JGe9b7wwgtDr28GEQUAADAolEFEAQAAqhXJFQAA\n", + "gEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRXAAAA\n", + "BpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAGkVwBAAAY\n", + "RHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGAQ\n", + "yRUAAIBBJFcAAAAGkVwBAAAYRHIFAABgUMnkatu2bZo+fbrGjx+vCRMm6JZbbpEkNTY2auTIkaqr\n", + "q1NdXZ2ampoiCRYAACDpMpZlWU5/bG1tVWtrq2pra9XZ2akTTjhB69ev19q1azVw4EBdfvnlUcYK\n", + "AACQeP1K/XHYsGEaNmyYJGnAgAEaN26ctm/fLkkqkZMBAABULdd9rrZu3arm5maddNJJkqTly5dr\n", + "8uTJWrhwodrb20MLEAAAIFUsFzo6OqwTTjjBWrdunWVZltXW1mZ1d3db3d3d1re//W1rwYIFfeYZ\n", + "M2aMJYl//OMf//jHP/7xL/H/xowZ4yYlcqVknytJOnDggGbPnq1Zs2bpsssu6/P3rVu36qyzztLz\n", + "zz/f6/NMJsOtwxRrbGxUY2Nj3GHAJ+ovvai7dKP+0stk3lLytqBlWVq4cKGOP/74XolVS0tLz8/r\n", + "1q3TxIkTjQQDAACQdiU7tD/55JNavXq1Jk2apLq6OknSDTfcoDVr1mjz5s3KZDIaPXq0VqxYEUmw\n", + "AAAASVcyuTrllFPU3d3d5/NZs2aFFhCSob6+Pu4QEAD1l17UXbpRf5DKjHMVqGD6XAEAgJSIrM8V\n", + "AAAAvCG5AgAAMIjkCgAAwCCSKwAAAINIrgAAAAwiuQIAADCI5AoAAMAgkisAAACDSK4AAAAMIrkC\n", + "AAAwiOQKAADAIJIrAAAAg0iuAAAADCK5AgAAMIjkCgAAwCCSKwAAAINIrgAAAAwiuQIAADCI5AoA\n", + "AMAgkisAAACDSK4AAAAMIrkCAAAwiOQKAADAIJIrAAAAg0iuAAAADCK5AgAAMIjkCgAAwCCSKwAA\n", + "AINIrgAAAAwiuQIAADCI5AoAAMAgkisAAACDSK4AAAAMIrkCAAAwiOQKAADAoIpNrgYNGqJMJtPr\n", + "36BBQ+IOCwAAVLiMZVlWKAVnMgqpaNfLl4qXH29MAAAgmUzmLRXbcgUAABAHkisAAACDSK4AAAAM\n", + "Kplcbdu2TdOnT9f48eM1YcIE3XLLLZKknTt3asaMGRo7dqxmzpyp9vb2SIIFAABIupId2ltbW9Xa\n", + "2qra2lp1dnbqhBNO0Pr167Vy5UodfvjhWrRokZYuXapdu3ZpyZIlvQumQzsAAEiJyDq0Dxs2TLW1\n", + "tZKkAQMGaNy4cdq+fbs2bNighoYGSVJDQ4PWr19vJBgAAIC0c93nauvWrWpubtbUqVPV1tammpoa\n", + "SVJNTY3a2tpCCxAAACBNXCVXnZ2dmjt3rpYtW6aBAwf2+lt+gE4AAABI/cpNcODAAc2dO1fz58/X\n", + "ueeeKynXWtXa2qphw4appaVFQ4cOtZ23sbGx5+f6+nqdffbfqKNjV69pBg4crN27dwZYBbMGDRrS\n", + "K8akxQcAAILLZrPKZrOhlF2yQ7tlWWpoaNBhhx2mm2++uefzRYsW6bDDDtNVV12lJUuWqL293VWH\n", + "9o5qW0QAABBCSURBVCg7mftdVt/56AQPAEClM9mhvWRy9cQTT+jUU0/VpEmTem793XjjjZoyZYrO\n", + "P/98vfnmmxo1apTWrl2rz372s2WDJLkCAABJFFlyFahgkisAAJASvFsQAAAgoUiuAAAADCK5AgAA\n", + "MIjkCgAAwCCSKwAAAINIrgAAAAwiuaoAgwYN6XkNUSaT0aBBQ+IOCQCAqsU4V2XnS/44V2mMGQCA\n", + "JGGcKwAAgIQiuQIAADCI5AoAAMAgkisAAACDSK4AAAAMIrkCAAAwiOQKAADAIJIrAAAAgyomuSoe\n", + "pRwAACAO/eIOwJSOjl0qHqUcAAAgahXTcgUAAJAEJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRX\n", + "AAAABpFcAQAAGBTqOFd//OMfwyweAAAgcTKWZVnlJ/NRcCajT31qhPr3/6wkqatrn/bseU29B/qU\n", + "pIxMhJAblb14EFHvy7IrJ6RNZEwaYwYAIEkyGXPXzlCTK2m1pAs++uQlSeNEcmVeGmMGACBJTCZX\n", + "9LkCAAAwiOQKAADAIJIrAAAAg0iuAAAADCK5AgAAMIjkCgAAwCCSKwAAAINIrgAAAAyqsuSqnzKZ\n", + "TM+/QYOGxB0QAACoMKG+WzB5DqpwJPOOjkx8oQAAgIpUZS1XAAAA4SK5AgAAMIjkCgAAwCCSKwAA\n", + "AIPKJlcLFixQTU2NJk6c2PNZY2OjRo4cqbq6OtXV1ampqSnUIAEAANKibHJ10UUX9UmeMpmMLr/8\n", + "cjU3N6u5uVlnnHFGaAECAACkSdnkatq0aRo8eHCfzy3LspkaAACguvnuc7V8+XJNnjxZCxcuVHt7\n", + "u8mYAAAAUstXcnXJJZdoy5Yt2rx5s4YPH64rrrjCdFwAAACp5GuE9qFDh/b8fPHFF+uss85ymPIX\n", + "kl796Oej/CwKAADAuGw2q2w2G0rZvpKrlpYWDR8+XJK0bt26Xk8S9jZX0gUf/fySn0UBAAAYV19f\n", + "r/r6+p7fFy9ebKzsssnVvHnz9Oijj2rHjh068sgjtXjxYmWzWW3evFmZTEajR4/WihUrjAUEAACQ\n", + "ZhkrpMf+MpmMpNXq3XI1ToUvTv5oSiNPHuaWV1hO8e92n/Vdtl05SX8yMo0xAwCQJJmMuWsnI7QD\n", + "AAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYFACkqt+ymQyPf8GDRoSd0CeDRo0pNc6\n", + "+F0PU+UAAID4+Bqh3ayDKhyjqaMjE18oPnV07FLxmFp+1sNUOQAAID4JaLkCAACoHCRXAAAABpFc\n", + "AQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGBQApOrfmVHKbcbyRwAACAJEjBCe7He\n", + "I7ZLfUcptxvJXCLBAgAA8UtgyxUAAEB6kVwBAAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERy\n", + "BQAAYBDJFQAAgEEkVz4UjxAPAACQl8AR2pOv7wjxJFgAACCHlisAAACDSK4AAAAMIrkCAAAwiOQK\n", + "AADAIJIrAAAAg0iuAAAADCK5AgAAMIjkCgAAwKCUJFf9GBE9oOJR5QcNGuJ5HrfzAQBQzVIyQvtB\n", + "MSJ6MMWjynd0lN+GfUeidzcfAADVLCUtVwAAAOlAcgUAAGAQyRUAAIBBJFcAAAAGlU2uFixYoJqa\n", + "Gk2cOLHns507d2rGjBkaO3asZs6cqfb29lCDBAAASIuyydVFF12kpqamXp8tWbJEM2bM0CuvvKLT\n", + "TjtNS5YsCS1AAACANCmbXE2bNk2DBw/u9dmGDRvU0NAgSWpoaND69evDiQ4AACBlfPW5amtrU01N\n", + "jSSppqZGbW1tRoMCAABIq8CDiJYeNf0Xkl796Oejgi6qSvXrtX0HDhys3bt3xhgPAADpl81mlc1m\n", + "QynbV3JVU1Oj1tZWDRs2TC0tLRo6dKjDlHMlXfDRzy/5ChC9R6dnhHQAAIKrr69XfX19z++LFy82\n", + "Vrav24Jnn322Vq1aJUlatWqVzj33XGMBAQAApFnZ5GrevHk6+eST9fLLL+vII4/UypUrdfXVV+vB\n", + "Bx/U2LFj9fDDD+vqq6+OIlYAAIDEy1iWZZWfzEfBmYyk1ep9W3Ccil8EnHsJc/FLmaObpnj1c3F7\n", + "n8ZuWV43bd9yw425XHxO8YS0ywAAEJtMxtz1jRHaAQAADCK5AgAAMIjkCgAAwCCSKwAAAINIrgAA\n", + "AAyq8uSqX88I884jzbuZpnzZgwYN6TPFoEFDfJTrfdlmy/aueD2dtgcAAJUg8Otv0q336Oc5xYmI\n", + "m2nKl203snpHxy71HdLBBL8xh6PvejLSPACgclV5yxUAAIBZJFcAAAAGkVwBAAAYRHIFAABgEMkV\n", + "AACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAAgEEkV6mTrFfb+Ff+9UAAAKRRlb/+Jo2S9Wob/8q/\n", + "HggAgDSi5QoAAMAgkisAAACDSK4AAAAMIrkCAAAwiOQKAADAIJIrAAAAg0iuAAAADCK5AgAAMIjk\n", + "qmr1HendzyjpgwYNMVKOKcXxMPI7ACBqjNBetfqO9O5nlPSOjl1GyjGlOB5GfgcARI2WKwAAAINI\n", + "rgAAAAwiuQIAADCI5AoAAMAgkisAAACDSK4AAAAMIrkCAAAwiOQKAADAIAYRjUxuRPRkcxOjqWkA\n", + "AKhMJFeR6TsiupS0BKQ4Rrv4TE0DAEBl4rYgAACAQSRXAAAABpFcAQAAGBSoz9WoUaM0aNAgffzj\n", + "H1f//v21adMmU3EBAACkUqDkKpPJKJvNasiQIabiAQAASLXAtwUtq/gJOAAAgOoVKLnKZDI6/fTT\n", + "deKJJ+qOO+4wFRMAAEBqBbot+OSTT2r48OF69913NWPGDB133HGaNm2aqdgAAABSJ1ByNXz4cEnS\n", + "EUccoTlz5mjTpk1FydUvJL360c9HBVkU0MegQUPU0bGrzFR9R4sfOHCwdu/eaXz5psoFAIQvm80q\n", + "m82GUnbG8tlpau/everq6tLAgQO1Z88ezZw5U9dee61mzpyZKziTkbRa0gUfzfGSpHGyH6W8eDRv\n", + "pqnGabzuirl9zN+yTfQV7Lt8M+UCAKKXyZg7h/tuuWpra9OcOXMkSQcPHtQFF1zQk1gBAABUK9/J\n", + "1ejRo7V582aTsQAAAKQeI7QDAAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAA\n", + "gEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRXAAAA\n", + "BpFcISH6KZPJ9PwbNGhInykGDRrSa5owl2WiXLuyi9fB7PKrA9sQQNL1izsAIOegJKvnt46OvslT\n", + "R8euXtNIfhOs8ssyUa5d2X3XweTyqwPbEEDS0XIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAA\n", + "YBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGAQyRVg89qaTOYTiXq9SvErX6KMx9TrZuzKSdp2hnlx\n", + "7rtAXHj9DWDz2prcq3XCeEWOP8WvfIkyHlOvm7ErJ2nbGebFue8CcaHlCgAAwCCSKwAAAINIrgAA\n", + "AAwiuQIAADCI5AoAAMAgkisAAACDSK4AAAAMIrkCAAAwiOQKCdV31PR0xtPPxTzFZX/C17L6joDe\n", + "txw3I6IXl+M35uLP3Om7nd2N6N3Pxzxm+Bl53u+o935GOzc1wr4bdsuqFlFuZyRfxrKs4iGTzRSc\n", + "yUhaLemCjz55SdI4lRuhue/vTFOd0yQ9vvinKT50c8dcfOWEOU1hjH3jsy8npFNbH37icZqnXMx2\n", + "deN9Hnfz+ZG0uolSlNsZ4chkzNUXLVcAAAAGkVwBAAAYRHIFAABgkO/kqqmpSccdd5yOOeYYLV26\n", + "1GRMAAAAqeUruerq6tKll16qpqYmvfDCC1qzZo1efPFF07EhVtm4A0Ag2bgDgE/ZbDbuEBBINu4A\n", + "kAC+kqtNmzbp6KOP1qhRo9S/f3996Utf0j333GM6NsQqG3cACCQbdwDwieQq7bJxB4AE8JVcbd++\n", + "XUceeWTP7yNHjtT27duNBQUAAJBW/fzM5HZguE996l/Uv/9dkqTu7g51dvpZGgAAQHr4Sq5GjBih\n", + "bdu29fy+bds2jRw5stc0Y8aM0euvb9YHH2wumtsuMSv+jGmYJu5lJ38a+y858ZUT5jR9Y/S7XmHx\n", + "E4/zei5evNj1stytp5ttakrS6iZK+fU6VH+Vu66VZ8yYMcbK8jVC+8GDB3XsscfqN7/5jf78z/9c\n", + "U6ZM0Zo1azRu3DhjgQEAAKSRr5arfv366dZbb9UXvvAFdXV1aeHChSRWAAAA8tlyBQAAAHuhjNDO\n", + "AKPpNmrUKE2aNEl1dXWaMmVK3OGghAULFqimpkYTJ07s+Wznzp2aMWOGxo4dq5kzZ6q9vT3GCFGK\n", + "Xf01NjZq5MiRqqurU11dnZqammKMEE62bdum6dOna/z48ZowYYJuueUWSRx/aeFUf6aOP+MtV11d\n", + "XTr22GP10EMPacSIEfrc5z5Hf6yUGT16tJ599lkNGTIk7lBQxuOPP64BAwboK1/5ip5//nlJ0qJF\n", + "i3T44Ydr0aJFWrp0qXbt2qUlS5bEHCns2NXf4sWLNXDgQF1++eUxR4dSWltb1draqtraWnV2duqE\n", + "E07Q+vXrtXLlSo6/FHCqv7Vr1xo5/oy3XDHAaGXgbnE6TJs2TYMHD+712YYNG9TQ0CBJamho0Pr1\n", + "6+MIDS7Y1Z/E8ZcGw4YNU21trSRpwIABGjdunLZv387xlxJO9SeZOf6MJ1cMMJp+mUxGp59+uk48\n", + "8UTdcccdcYcDj9ra2lRTUyNJqqmpUVtbW8wRwavly5dr8uTJWrhwIbeVUmDr1q1qbm7W1KlTOf5S\n", + "KF9/J510kiQzx5/x5IoxPdLvySefVHNzszZu3KjbbrtNjz/+eNwhwadMJsMxmTKXXHKJtmzZos2b\n", + "N2v48OG64oor4g4JJXR2dmru3LlatmyZBg4c2OtvHH/J19nZqfPOO0/Lli3TgAEDjB1/xpMrNwOM\n", + "ItmGDx8uSTriiCM0Z84cbdq0KeaI4EVNTY1aW1slSS0tLRo6dGjMEcGLoUOH9lyUL774Yo6/BDtw\n", + "4IDmzp2r+fPn69xzz5XE8Zcm+fq78MILe+rP1PFnPLk68cQT9eqrr2rr1q3av3+/7r77bp199tmm\n", + "F4OQ7N27Vx0dHZKkPXv26IEHHuj1JBOS7+yzz9aqVaskSatWreo5aSAdWlpaen5et24dx19CWZal\n", + "hQsX6vjjj9dll13W8znHXzo41Z+p4y+Uca42btyoyy67rGeA0Wuuucb0IhCSLVu2aM6cOZJyI/Ff\n", + "cMEF1F+CzZs3T48++qh27NihmpoaXXfddTrnnHN0/vnn680339SoUaO0du1affazn407VNgorr/F\n", + "ixcrm81q8+bNymQyGj16tFasWNHThwfJ8cQTT+jUU0/VpEmTem793XjjjZoyZQrHXwrY1d8NN9yg\n", + "NWvWGDn+GEQUAADAoFAGEQUAAKhWJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAA\n", + "GERyBQAAYND/B6hFJTD2mK/NAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlcAAAJPCAYAAABRvvFyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nGERyBQAAYND/B6hFJTD2mK/NAAAAAElFTkSuQmCC\n", - "text": [ - "" - ] - } - ], - "prompt_number": 17 - }, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['fc7'].data[0]\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(feat.flat)\n", + "plt.subplot(2, 1, 2)\n", + "_ = plt.hist(feat.flat[feat.flat > 0], bins=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The final probability output, `prob`" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 18, "metadata": {}, - "source": [ - "The final probability output, `prob`" - ] + "output_type": "execute_result" }, { - "cell_type": "code", - "collapsed": false, - "input": [ - "feat = net.blobs['prob'].data[0]\n", - "plt.plot(feat.flat)" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAmEAAAJPCAYAAAA0UwMNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3X9w1/Wd4PHX1ya37flbpAoJO1ESSayCbAPW7TGTdkVO\n", + "d+XE/lhaV52WWsYd225nu+3dzXWqnWsrs9u5teX+YL3a7a9B5q4zYndozqM11dpCzmIPZ9EKLLQh\n", + "iroq/gAV8/Vzf3ybCCF8CZDw/iTvx2Mmk3zz/Xy++YRPQp55vz/fdypFURQBAMAJdVLqAwAAyJEI\n", + "AwBIQIQBACQgwgAAEhBhAAAJiDAAgASOGGHd3d3R3t4ebW1tsWLFikPuX7t2bcyZMyfmzp0b7373\n", + "u+OnP/3p0H0tLS0xe/bsmDt3bsyfP39sjxwAYAKr1FsnrFqtxqxZs2L9+vXR1NQU8+bNi9WrV0dH\n", + "R8fQNnv37o2TTz45IiIeffTRWLJkSWzbti0iIs4777z41a9+FWedddY4fxoAABNL3ZGw3t7eaG1t\n", + "jZaWlmhsbIylS5fG2rVrD9pmMMAiIl555ZU4++yzD7rfWrAAAIeqG2H9/f0xY8aModvNzc3R399/\n", + "yHb33HNPdHR0xJVXXhnf+MY3ht5fqVTi8ssvj87OzrjzzjvH8LABACa2hnp3ViqVUT3INddcE9dc\n", + "c008+OCDcf3118dvfvObiIh46KGHYtq0afHss8/GwoULo729PRYsWHD8Rw0AMMHVjbCmpqbo6+sb\n", + "ut3X1xfNzc2H3X7BggUxMDAQzz33XEyZMiWmTZsWERFTp06NJUuWRG9v7yER1traGtu3bz+ezwEA\n", + "4ISYOXPm0LXvx6vudGRnZ2ds3bo1du7cGfv37481a9bE4sWLD9pm+/btQ9d9bdq0KSIipkyZEvv2\n", + "7YuXX345ImoX7993331x8cUXH/IxBvf3MjFfvvSlLyU/Bi/OXY4vzt/EfnH+Ju7LWA4c1R0Ja2ho\n", + "iJUrV8aiRYuiWq3GsmXLoqOjI1atWhUREcuXL48f/vCH8d3vfjcaGxvjlFNOibvvvjsiInbv3h3X\n", + "XnttREQMDAzEddddF1dcccWYHTgAwERWN8IiIq688sq48sorD3rf8uXLh97+/Oc/H5///OcP2e/8\n", + "88+PX//612NwiAAAk48V8zkuXV1dqQ+BY+TcTWzO38Tm/BFxhMVaT8gBVCqR+BAAAEZlLLvFSBgA\n", + "QAIiDAAgAREGAJCACAMASECEAQAkIMIAABIQYQAACYgwAIAERBgAQAIiDAAgAREGAJCACAMASECE\n", + "AQAkIMIAABIQYQAACYgwAIAERBgAQAIiDAAgAREGAJCACAMASECEAQAkIMIAABIQYQAACYgwAIAE\n", + "RBgAQAIiDAAgAREGAJCACAMASECEAQAkIMIAABIQYQAACYgwAIAERBgAQAIiDAAgAREGAJCACAMA\n", + "SECEAQAkIMIAABIQYQAACYgwAIAERBgAQAIiDAAgAREGAJCACAMASECEAQAkIMIAABIQYQAACYgw\n", + "AIAERBgAQAIiDAAgAREGAJCACAMASECEAQAkIMIAABIQYQAACYgwAIAERBgAQAIiDAAgAREGAJCA\n", + "CAMASECEAQAkIMIAABIQYQAACYgwsvLZz0Z87nOpjwIAIipFURRJD6BSicSHQEYqldrLm2+mPhIA\n", + "JqKx7BYjYWRH8wNQBiIMACABEQYAkIAIAwBI4IgR1t3dHe3t7dHW1hYrVqw45P61a9fGnDlzYu7c\n", + "ufHud787fvrTn456XwCAXNV9dmS1Wo1Zs2bF+vXro6mpKebNmxerV6+Ojo6OoW327t0bJ598ckRE\n", + "PProo7FkyZLYtm3bqPaN8OxITqxKpfbalxwAx+KEPTuyt7c3Wltbo6WlJRobG2Pp0qWxdu3ag7YZ\n", + "DLCIiFdeeSXOPvvsUe8LAJCruhHW398fM2bMGLrd3Nwc/f39h2x3zz33REdHR1x55ZXxjW9846j2\n", + "hRNpcCQMAFKrG2GVUf7Euuaaa+Kxxx6LH/3oR3H99debXqS0RBgAZdFQ786mpqbo6+sbut3X1xfN\n", + "zc2H3X7BggUxMDAQzz//fDQ3N49631tvvXXo7a6urujq6hrl4QMAjJ+enp7o6ekZl8eue2H+wMBA\n", + "zJo1K37yk5/E9OnTY/78+YdcXL99+/Y4//zzo1KpxKZNm+JDH/pQbN++fVT7RrgwnxOroSGiWnVh\n", + "PgDHZiy7pe5IWENDQ6xcuTIWLVoU1Wo1li1bFh0dHbFq1aqIiFi+fHn88Ic/jO9+97vR2NgYp5xy\n", + "Stx9991194WUTEcCUBb+gDdZaWyMGBgwEgbAsfEHvAEAJjgRRlZMRwJQFiKMrIgwAMpChAEAJCDC\n", + "yIqRMADKQoSRFREGQFmIMACABEQYWTESBkBZiDCyIsIAKAsRBgCQgAgDAEhAhJEV05EAlIUIIysi\n", + "DICyEGEAAAmIMLJiJAyAshBhZEWEAVAWIgwAIAERRlaMhAFQFiKMrIgwAMpChAEAJCDCAAASEGFk\n", + "xXQkAGUhwsiKCAOgLEQYAEACIoysGAkDoCxEGFkRYQCUhQgDAEhAhJEVI2EAlIUIIysiDICyEGEA\n", + "AAmIMACABEQYWTEdCUBZiDCyIsIAKAsRBgCQgAgjK0bCACgLEUZWRBgAZSHCAAASEGFkxUgYAGUh\n", + "wgAAEhBhZMVIGABlIcIAABIQYWTFSBgAZSHCyIoIA6AsRBgAQAIijKwYCQOgLEQYWRFhAJSFCAMA\n", + "SECEkRUjYQCUhQgDAEhAhJEVI2EAlIUIAwBIQISRFSNhAJSFCCMrIgyAshBhAAAJiDCyYiQMgLIQ\n", + "YWRFhAFQFiIMACABEUZWjIQBUBYiDAAgARFGVoyEAVAWIgwAIAERRlaMhAFQFiKMrIgwAMpChAEA\n", + "JCDCyIqRMADKQoSRFREGQFmIMACABEQYAEACIoysmI4EoCxEGFkRYQCUhQgDAEjgiBHW3d0d7e3t\n", + "0dbWFitWrDjk/h/84AcxZ86cmD17drz3ve+NzZs3D93X0tISs2fPjrlz58b8+fPH9sjhGBgJA6As\n", + "GurdWa1W45Zbbon169dHU1NTzJs3LxYvXhwdHR1D25x//vnxwAMPxOmnnx7d3d3xyU9+MjZs2BAR\n", + "EZVKJXp6euKss84a388CRkmEAVAWdUfCent7o7W1NVpaWqKxsTGWLl0aa9euPWibyy67LE4//fSI\n", + "iLj00ktj165dB91fFMUYHzIAwMRXN8L6+/tjxowZQ7ebm5ujv7//sNt/61vfiquuumrodqVSicsv\n", + "vzw6OzvjzjvvHIPDheNjJAyAsqg7HVk5ip9Y999/f9x1113x0EMPDb3voYceimnTpsWzzz4bCxcu\n", + "jPb29liwYMEh+956661Db3d1dUVXV9eoPy4cDREGwNHo6emJnp6ecXnsuhHW1NQUfX19Q7f7+vqi\n", + "ubn5kO02b94cN910U3R3d8eZZ5459P5p06ZFRMTUqVNjyZIl0dvbe8QIAwAoi+GDQ7fddtuYPXbd\n", + "6cjOzs7YunVr7Ny5M/bv3x9r1qyJxYsXH7TN7373u7j22mvj+9//frS2tg69f9++ffHyyy9HRMTe\n", + "vXvjvvvui4svvnjMDhwAYCKrOxLW0NAQK1eujEWLFkW1Wo1ly5ZFR0dHrFq1KiIili9fHl/+8pfj\n", + "hRdeiJtvvjkiIhobG6O3tzd2794d1157bUREDAwMxHXXXRdXXHHFOH86UJ/pSADKolIkfvpipVLx\n", + "DEpOmHnzIh5+OMKXHADHYiy7xYr5AAAJiDCyYjoSgLIQYWRFhAFQFiIMACABEUZWjIQBUBYijKyI\n", + "MADKQoQBACQgwgAAEhBhZMV0JABlIcLIiggDoCxEGABAAiKMrBgJA6AsRBhZEWEAlIUIAwBIQISR\n", + "FSNhAJSFCAMASECEAQAkIMLIiulIAMpChJEVEQZAWYgwsiLCACgLEQYAkIAIIytGwgAoCxFGVkQY\n", + "AGUhwgAAEhBhZMVIGABlIcLIiggDoCxEGABAAiIMACABEUZWTEcCUBYijKyIMADKQoQBACQgwsiK\n", + "kTAAykKEkRURBkBZiDAAgAREGFkxEgZAWYgwsiLCACgLEQYAkIAIAwBIQISRFdORAJSFCCMrIgyA\n", + "shBhAAAJiDCyYiQMgLIQYWRFhAFQFiIMACABEUZWjIQBUBYijKyIMADKQoQBACQgwgAAEhBhZMV0\n", + "JABlIcLIiggDoCxEGFkqitRHAEDuRBhZEmEApCbCyMpgfIkwAFITYWRJhAGQmggDAEhAhJElI2EA\n", + "pCbCyIprwgAoCxFGlkQYAKmJMLIkwgBITYSRFdORAJSFCCNLIgyA1EQYWRJhAKQmwsiK6UgAykKE\n", + "kSURBkBqIgwAIAERRpaMhAGQmggjK+ILgLIQYWRJjAGQmggDAEhAhJEVS1QAUBZHjLDu7u5ob2+P\n", + "tra2WLFixSH3/+AHP4g5c+bE7Nmz473vfW9s3rx51PsCAOSqboRVq9W45ZZboru7O7Zs2RKrV6+O\n", + "xx577KBtzj///HjggQdi8+bN8cUvfjE++clPjnpfSMVIGACp1Y2w3t7eaG1tjZaWlmhsbIylS5fG\n", + "2rVrD9rmsssui9NPPz0iIi699NLYtWvXqPeFE018AVAWdSOsv78/ZsyYMXS7ubk5+vv7D7v9t771\n", + "rbjqqquOaV84kcQYAKk11LuzUqmM+oHuv//+uOuuu+Khhx466n0BAHJTN8Kampqir69v6HZfX180\n", + "Nzcfst3mzZvjpptuiu7u7jjzzDOPat+IiFtvvXXo7a6urujq6jqazwEAYFz09PRET0/PuDx2pSgO\n", + "PzEzMDAQs2bNip/85Ccxffr0mD9/fqxevTo6OjqGtvnd734X73//++P73/9+vOc97zmqfSNqI2Z1\n", + "DgHG1J/+acS6dRH/+q8RU6akPhoAJpqx7Ja6I2ENDQ2xcuXKWLRoUVSr1Vi2bFl0dHTEqlWrIiJi\n", + "+fLl8eUvfzleeOGFuPnmmyMiorGxMXp7ew+7LwAARxgJOyEHYCSME2hwJOzZZyPOPjv10QAw0Yxl\n", + "t1gxn6zofQDKQoSRJTEGQGoiDAAgARFGVvwBbwDKQoQBACQgwsiSkTAAUhNhAAAJiDCy4powAMpC\n", + "hAEAJCDCAAASEGFkxXQkAGUhwgAAEhBhZMlIGACpiTCyIr4AKAsRRpbEGACpiTAAgAREGFkyEgZA\n", + "aiKMrIgvAMpChJElMQZAaiIMACABEUZWjIABUBYijCyJMQBSE2EAAAmIMLLiD3gDUBYiDAAgARFG\n", + "loyEAZCaCAMASECEkRXXhAFQFiIMACABEUaWjIQBkJoIIyviC4CyEGEAAAmIMLJkRAyA1EQYAEAC\n", + "IoysWKICgLIQYQAACYgwsmQkDIDURBhZEV8AlIUII0tiDIDURBgAQAIijKx4diQAZSHCAAASEGEA\n", + "AAmIMLJkOhKA1EQYWRFfAJSFCCNLYgyA1EQYAEACIoysWKICgLIQYQAACYgwsmQkDIDURBhZEV8A\n", + "lIUII0tiDIDURBgAQAIiDAAgARFGVixRAUBZiDAAgAREGFkyEgZAaiKMrIgvAMpChJElMQZAaiIM\n", + "ACABEUZWPDsSgLIQYQAACYgwsmQkDIDURBgAQAIijKy4JgyAshBhAAAJiDAAgAREGFkxHQlAWYgw\n", + "AIAERBhZMhIGQGoijKyILwDK4ogR1t3dHe3t7dHW1hYrVqw45P7HH388Lrvssnj7298eX//61w+6\n", + "r6WlJWbPnh1z586N+fPnj91Rw3ESYwCk1lDvzmq1GrfcckusX78+mpqaYt68ebF48eLo6OgY2mbK\n", + "lCnxzW9+M+65555D9q9UKtHT0xNnnXXW2B85AMAEVnckrLe3N1pbW6OlpSUaGxtj6dKlsXbt2oO2\n", + "mTp1anR2dkZjY+OIj1EYcqCEfFkCkFrdCOvv748ZM2YM3W5ubo7+/v5RP3ilUonLL788Ojs74847\n", + "7zz2o4QxIr4AKIu605GVSuW4Hvyhhx6KadOmxbPPPhsLFy6M9vb2WLBgwXE9JhyvSkWMAZBe3Qhr\n", + "amqKvr6+odt9fX3R3Nw86gefNm1aRNSmLJcsWRK9vb0jRtitt9469HZXV1d0dXWN+mPA0TrO3y0A\n", + "yEhPT0/09PSMy2PXjbDOzs7YunVr7Ny5M6ZPnx5r1qyJ1atXj7jt8Gu/9u3bF9VqNU499dTYu3dv\n", + "3HffffGlL31pxH0PjDAYT0bAADgawweHbrvttjF77LoR1tDQECtXroxFixZFtVqNZcuWRUdHR6xa\n", + "tSoiIpYvXx67d++OefPmxUsvvRQnnXRS3HHHHbFly5Z45pln4tprr42IiIGBgbjuuuviiiuuGLMD\n", + "h2NlOhKAMqgUiZ++WKlUPIOSE+bd747YvDniwQcj3vOe1EcDwEQzlt1ixXyyUhRGwgAoBxFGdlyY\n", + "D0AZiDCyZCQMgNREGNkxEgZAGYgwsuKaMADKQoSRHSNhAJSBCCNLRsIASE2EkZXB6UgASE2EkR0R\n", + "BkAZiDCyZDoSgNREGFkxHQlAWYgwsmOJCgDKQISRHSNhAJSBCCNLRsIASE2EkRXXhAFQFiKM7Lgm\n", + "DIAyEGFkx0gYAGUgwsiKP+ANQFmIMLJjJAyAMhBhAAAJiDCyYjoSgLIQYWTHdCQAZSDCyJKRMABS\n", + "E2Fkx0gYAGUgwsjK4DVhb7wRsWtX6qMBIGcijOxUKhEPPBBx002pjwSAnIkwsvTGG7UXAEhFhJEV\n", + "S1QAUBYijOwMRpgQAyAlEUZ2KpWIN98UYQCkJcLIwnPPHRxeAgyA1EQYWfiLv4j4+c9rb5uOBKAM\n", + "RBhZeP312kuECAOgHEQY2XjzzbfeFmAApCbCyMLgyNeBS1QIMQBSEmFkoSjeGgkTYQCUgQgjCwdG\n", + "lyUqACgDEUY2BsPLivkAlIEIIwvDR8JMRwKQmggjC8OjS4QBkJoIIxumIwEoExFGFkxHAlA2Iows\n", + "HLhExeBtEQZASiKMbAxfogIAUhJhZMGK+QCUjQgjC1bMB6BsRBhZGGmJCgBISYSRjeFLVAgxAFIS\n", + "YWTBEhUAlI0IIwsj/QFvAEhJhJEN64QBUCYijCxYogKAshFhZGGkJSoAICURRjaGXxMmxABISYSR\n", + "hQOnIw98HwCkIsLIghXzASgbEUYWLFEBQNmIMLJhxXwAykSEkQUr5gNQNiKMLLgoH4CyEWFkw4X5\n", + "AJSJCCMLVswHoGxEGFkYvkSFZ0cCkJoIIxvDrwkzEgZASiKMLJiOBKBsRBhZ8Ae8ASgbEUYWRlqi\n", + "QogBkJIIIxtWzAegTEQYWRhpxXwASEmEkYWR/oC3EAMgJRFGNg5cG8x0JACpHTHCuru7o729Pdra\n", + "2mLFihWH3P/444/HZZddFm9/+9vj61//+lHtCyfKSEtUAEBKdSOsWq3GLbfcEt3d3bFly5ZYvXp1\n", + "PPbYYwdtM2XKlPjmN78Zn/vc5456XzhRRlqiQogBkFLdCOvt7Y3W1tZoaWmJxsbGWLp0aaxdu/ag\n", + "baZOnRqdnZ3R2Nh41PvCiTLShfkiDICU6kZYf39/zJgxY+h2c3Nz9Pf3j+qBj2dfGA/Dl6gAgJQa\n", + "6t1ZqVSO+YGPZt9bb7116O2urq7o6uo65o8LIxk+ElatCjEAjqynpyd6enrG5bHrRlhTU1P09fUN\n", + "3e7r64vm5uZRPfDR7HtghMF4sGI+AMdi+ODQbbfdNmaPXXc6srOzM7Zu3Ro7d+6M/fv3x5o1a2Lx\n", + "4sUjblsM+4l2NPvCiWDFfADKpO5IWENDQ6xcuTIWLVoU1Wo1li1bFh0dHbFq1aqIiFi+fHns3r07\n", + "5s2bFy+99FKcdNJJcccdd8SWLVvilFNOGXFfSMGK+QCUTaUYPoR1og+gUjlkFA3G2nnnRfz5n0d8\n", + "73sRF1wQ8eqrEbt3R+zcmfrIAJhIxrJbrJhPNixRAUCZiDCyYMV8AMpGhJGF4Svm+wPeAKQmwsiC\n", + "JSoAKBsRRjasmA9AmYgwsuBvRwJQNiKMLAyPMNeEAZCaCCMbwguAMhFhZMF0JABlI8LIgiUqACgb\n", + "EUY2hi9RAQApiTCyMNKK+UIMgJREGFkYPh0pwgBITYSRhZEuzAeAlEQY2Ri+Yr4QAyAlEUYWLNYK\n", + "QNmIMLIw0h/wBoCURBjZMB0JQJmIMLJgxXwAykaEkYUDl6gYvC3CAEhJhJENS1QAUCYijCxYMR+A\n", + "shFhZMEf8AagbEQYWbBEBQBlI8LIhiUqACgTEUYWLFEBQNmIMLIw0jVhAJCSCCMbnh0JQJmIMLJg\n", + "OhKAshFhZGGkFfMBICURRhaMhAFQNiKMbBy4QKsIAyA1EUYWRhoJA4CURBhZMB0JQNmIMLJhxXwA\n", + "ykSEkYXhI2EWawUgNRFGFkZaosJIGAApiTCyYcV8AMpEhJEFF+YDUDYijCyM9Ae8BwYi7rkn7XEB\n", + "kC8RRhaGj3wNvv35z6c5HgAQYWRj+BIVEaYkAUhHhJGFw62YL8IASEWEkYXDTUeKMABSEWFkw3Qk\n", + "AGUiwsjC4aYjrZwPQCoijGwcuESFkTAAUhNhZGP4ivmD7wOAFEQYk97w4KpU3rrPdCQAqYgwJr16\n", + "13+JMABSEWFMekbCACgjEUY2Dlyi4sD3AUAKIoxJz0gYAGUkwpj06j0TUoQBkIoIIxumIwEoExHG\n", + "pFdvOtI6YQCkIsKY9OotUVGtnthjAYBBIoxsHLhi/iDTkQCkIsKY9ExHAlBGIoxJb/h0pJEwAMpA\n", + "hDHp1VuiwjVhAKQiwsiGJSoAKBMRxqTnmjAAykiEMenVuyYMAFIRYWRjcIkKACgDEcakV286EgBS\n", + "EWFMeqYjASgjEcakV2+JCgBIRYSRjZGWqACAVEQYk55rwgAooyNGWHd3d7S3t0dbW1usWLFixG0+\n", + "/elPR1tbW8yZMyceeeSRofe3tLTE7NmzY+7cuTF//vyxO2o4CiIMgDJqqHdntVqNW265JdavXx9N\n", + "TU0xb968WLx4cXR0dAxts27duti2bVts3bo1Nm7cGDfffHNs2LAhIiIqlUr09PTEWWedNb6fBYyC\n", + "6UgAyqTuSFhvb2+0trZGS0tLNDY2xtKlS2Pt2rUHbXPvvffGjTfeGBERl156aezZsyeefvrpofsL\n", + "V0OT2JFGwnyJApBC3Qjr7++PGTNmDN1ubm6O/v7+UW9TqVTi8ssvj87OzrjzzjvH8rhh1IYvUTGc\n", + "vx8JQAp1pyMro5y3Odxo189//vOYPn16PPvss7Fw4cJob2+PBQsWHP1RwnE66aS3Vsw3EgZAGdSN\n", + "sKampujr6xu63dfXF83NzXW32bVrVzQ1NUVExPTp0yMiYurUqbFkyZLo7e0dMcJuvfXWobe7urqi\n", + "q6vrqD8ROJyiiHjb20xHAnD0enp6oqenZ1weu26EdXZ2xtatW2Pnzp0xffr0WLNmTaxevfqgbRYv\n", + "XhwrV66MpUuXxoYNG+KMM86Ic845J/bt2xfVajVOPfXU2Lt3b9x3333xpS99acSPc2CEwVgbHP06\n", + "3LSjCAPgcIYPDt12221j9th1I6yhoSFWrlwZixYtimq1GsuWLYuOjo5YtWpVREQsX748rrrqqli3\n", + "bl20trbGySefHN/+9rcjImL37t1x7bXXRkTEwMBAXHfddXHFFVeM2YHDaBXFW9OREUbCACiHSpH4\n", + "6YuVSsUzKBlXzzwTcf75EdVqxP79Ef/5P0f81//61v379kW84x3pjg+AiWMsu8WK+Ux6RsIAKCMR\n", + "xqQ3PMJGuh8ATjQRRhZOOunwK+aLMABSEGFMekeajrRYKwApiDAmvcEIG4wtI2EAlEHdJSpgsnBh\n", + "PgBlYySMSW9wJGyQCAOgDEQYk95IF+MfyDVhAKQgwpj0BiPspMN8tRsJAyAFEUY2BkfDTEcCUAYi\n", + "jElv+EiYCAOgDEQYk95ghB1uJMw1YQCkIMLIxuEuzjcSBkAKIoxJ70gjYSIMgBREGJPe8Agb6X4A\n", + "ONFEGNlwTRgAZSLCmPSMhAFQRiKMSc81YQCUkQhj0rNiPgBlJMLIhmvCACgTEcak55owAMpIhDHp\n", + "iTAAykiEkQ0X5gNQJiKMSe9II2GuCQMgBRHGpGeJCgDKSIQx6bkmDIAyEmFkw0gYAGUiwpj0XBMG\n", + "QBmJMCa94SvmGwkDoAxEGNlwTRgAZSLCmPQ8OxKAMhJhTHqeHQlAGYkwsuHCfADKRIQx6ZmOBKCM\n", + "RBiTnulIAMpIhDHpGQkDoIxEGNlwTRgAZSLCmPSMhAFQRiKMSW/4ivkj3Q8AJ5oIIxtGwgAoExHG\n", + "pOcPeANQRiKMSc81YQCUkQgjC9YJA6BsRBiT3mBkiTAAykSEMekdaTrSNWEApCDCmPT82SIAykiE\n", + "kQ0X5gNQJiKMSc9irQCUkQhj0nNNGABlJMLIgmvCACgbEcakN3yJCteEAVAGIoxJz7MjASgjEUYW\n", + "XBMGQNmIMCY9K+YDUEYijEnPdCQAZSTCmPSOtESFCAMgBRFGNg43EuaaMABSEGFMesNXzDcSBkAZ\n", + "iDAmPdeEAVBGIowsuCYM4Ojcf3/E+vWpj2JyE2FMelbMBzh669eLsPHWkPoAYLwNn448+eSD73dh\n", + "PsChXn01olpNfRSTmwhj0hseYaeeeuj9ABxMhI0/EUY2Xnut9lqEARyZCBt/IoxJb3AkbN++2u3T\n", + "Tjv0fgAOJsLGnwhj0huMsFdfrd0ePhLmmjCAQ4mw8SfCmNTWrIn4b/+tFl6HizAjYQCHEmHjzxIV\n", + "TGj/7/9FvPHG4e//l3+J2Lat9vbgdKQIAziyV19965fXY3HXXW9di8vIRBgT2sc+FvGLXxz+/hdf\n", + "jNiz5+DpyLe//eBtxivCBgYienrG57Enm8FQBsrjtdeOL8L+43/0vX0kIowJ7V//NeK55w5//4sv\n", + "1obTK5WI118f+c8Xjdc1YT/7WcT73mek7UiKImL27PrnETjxjmckrCginn++9sLhiTAmtOefr//D\n", + "e8+eg2+/4x2HbjNekbR/f+317343Po8/Wbz0Uu0/+meeSX0k8JaBgYjf/Cb1UYyvrq6I/v7D3388\n", + "Efbyy7VfgEVYfUeMsO7u7mhvb4+2trZYsWLFiNt8+tOfjra2tpgzZ0488sgjR7UvHKvXX4/Yu7cW\n", + "YffcU/vAg9n7AAALaElEQVQ7Z8O9+GLt9eDo12CETZ361jbjFWHPPlt7/Xd/ZzSsnsH4EmGUyQMP\n", + "RHzoQ6mPYvwURcSGDfWnC48nwgbjS4TVVzfCqtVq3HLLLdHd3R1btmyJ1atXx2OPPXbQNuvWrYtt\n", + "27bF1q1b4x/+4R/i5ptvHvW+THw9CS96GhwBe/752rMg1649dJvBkbDhEXbgD/zxjLDLLqtNS/6n\n", + "/xTxv//36Pe9//6Ivr7xOa5BKc/dgUYTYa+9Vv8JGDkqy/mbrHbsqL2M1/8Pqc/fc8/VfpEdr5Gw\n", + "wfgqy2UGr7wSceedqY/iUHUjrLe3N1pbW6OlpSUaGxtj6dKlsXbYT7p77703brzxxoiIuPTSS2PP\n", + "nj2xe/fuUe3L2HrhhYi2thP7wyrlfyQHfpNv2xaxdeuh2wyOhA0+zfrf/ttDtxmva8KeeSbiz/4s\n", + "4gtfiFixIuJrXxv9vl/8YsQPfjA+xzUo9Q+BQaOJsE99KuKOO07M8UwUZTl/ZfPqqxH/5b8c/+P8\n", + "9re1H9zjNZKT+vwNxtdoIuxYQrRsI2EPPhjxmc/UppnLpG6E9ff3x4wZM4ZuNzc3R/+wM3a4bZ58\n", + "8skj7puLN9889Nqk8fDzn9diZNOmsXm822+vTaWNlzffjPgf/+Ota6eO1uBvWM89F7F9+6HD6r/6\n", + "VcSWLbW3X3qp9nqkCBvPkbB3vrN20XlExCOPjC74qtXaths2jM9xjYf/9b8iHnro2PYdnLYdfD2S\n", + "n/2sNj00HnburP/b/t69tW2OpKcn4qabxuigovZ9vHjxxJ7KTnHs998f8ZWv1P5PGMnzz4986cJw\n", + "v/1t7fVozv1ENPjj+MknR76/Wq39Ql+pjO4X+8cfj/jEJ9769xrLCHvlleP/GfrII7Xv87JNyNVd\n", + "rLUy/Glkh1Ec53fa1Vcf1+6l99RTtUD4d/9ufD/O9u215Rc++cmIGTNqI2NPPx3R3n74feqdusEf\n", + "qv/n/0Q0Nta+eM84I2L69Le2+c1varFzLF58sba8xH//7xHTpkW87W1Ht//TT0dMmVL74fzGGxFP\n", + "PBHxp39aC5033zw4Rl9/vfb6/PMPfZyVKyN+9KNj+xzqefjhiGuuiZg1K+Lf/Jvab2BXXll7u57X\n", + "Xqudx56e2uczym/Do/bEE7VjHK1qtfY5DH89MFD7+n7HOyLmzRvdY73+eu3C3SlTal+3Z54Z8Z3v\n", + "1I7njTciNm6MmDu39m8xZUrErl21Hxb//t/XPu5IL297W+1xTvr9r5bDv7Z37Kh9Xwz/9//Zz2rv\n", + "b2kZ+Vj/5V9q38MLFtSmiBsbI84559DtHn20tt1vfxvR0FA7juM5d48/XvuBdvnlBz+hZPDzeuKJ\n", + "iP/7f+t/Dw8+K/jll2vHdOaZx348R2vnztq/x3veU/t+3Lev9kPwne888r7PPx9xyilH/l4Z9PTT\n", + "ta+Vwem1P/iDiD//89r/K8Nt21b7Wrj88vrnZ+PG2v5/8RcRM2cefN+bb9Z+qF9ySe3fNaJ2Hp56\n", + "KuLcc9/6Ghy0d2/tuNra3nrfSN9/v/517f+o005767yO1euI2tduQ0Pt8+7vjzj99Ij/+T9Hvi6s\n", + "Wq390vq2t0X8h/9Qe/3ii7VzMtIvs48+WjvuRYsiLrig9oSks8+u/d+6a9eh29cz/Lxs2VL7Zf2S\n", + "S47ucQ60eXPteD784dq/cVEc28uYK+r45S9/WSxatGjo9le/+tXi9ttvP2ib5cuXF6tXrx66PWvW\n", + "rGL37t2j2rcoimLmzJlFRHjx4sWLFy9evJT+ZebMmfXS6ajUHQnr7OyMrVu3xs6dO2P69OmxZs2a\n", + "WL169UHbLF68OFauXBlLly6NDRs2xBlnnBHnnHNOTJky5Yj7RkRss5IbAJChuhHW0NAQK1eujEWL\n", + "FkW1Wo1ly5ZFR0dHrFq1KiIili9fHldddVWsW7cuWltb4+STT45vf/vbdfcFACCiUhQT+bJPAICJ\n", + "KemK+RZzLbe+vr543/veF+9617vioosuim984xsREfH888/HwoUL44ILLogrrrgi9hzwtJWvfe1r\n", + "0dbWFu3t7XHfffelOnR+r1qtxty5c+Pq3z/7xbmbOPbs2RMf/OAHo6OjIy688MLYuHGj8zeBfO1r\n", + "X4t3vetdcfHFF8dHP/rReP31152/kvr4xz8e55xzTlx88cVD7zuWc/WrX/0qLr744mhra4vPfOYz\n", + "o/vgY3Z12VEaGBgoZs6cWezYsaPYv39/MWfOnGLLli2pDocRPPXUU8UjjzxSFEVRvPzyy8UFF1xQ\n", + "bNmypfibv/mbYsWKFUVRFMXtt99efOELXyiKoij++Z//uZgzZ06xf//+YseOHcXMmTOLarWa7Pgp\n", + "iq9//evFRz/60eLqq68uiqJw7iaQG264ofjWt75VFEVRvPHGG8WePXucvwlix44dxXnnnVe89tpr\n", + "RVEUxYc//OHiH//xH52/knrggQeKTZs2FRdddNHQ+47mXL355ptFURTFvHnzio0bNxZFURRXXnll\n", + "8eMf//iIHzvZSJjFXMvv3HPPjUt+/5zgU045JTo6OqK/v/+gBXpvvPHGuOeeeyIiYu3atfGRj3wk\n", + "Ghsbo6WlJVpbW6O3tzfZ8edu165dsW7duvjEJz4xtIyMczcxvPjii/Hggw/Gxz/+8YioXWN7+umn\n", + "O38TxGmnnRaNjY2xb9++GBgYiH379sX06dOdv5JasGBBnDls/ZajOVcbN26Mp556Kl5++eWYP39+\n", + "RETccMMNQ/vUkyzCRrMQLOWxc+fOeOSRR+LSSy+Np59+Os75/UJJ55xzTjz99NMREfHkk09Gc3Pz\n", + "0D7OaVqf/exn42//9m/jpAMWLXLuJoYdO3bE1KlT42Mf+1j80R/9Udx0002xd+9e52+COOuss+Kv\n", + "//qv4w//8A9j+vTpccYZZ8TChQudvwnkaM/V8Pc3NTWN6hwmi7DRLgRLeq+88kp84AMfiDvuuCNO\n", + "PfXUg+6rVCp1z6XznMY//dM/xTvf+c6YO3fuYRdTdu7Ka2BgIDZt2hR/+Zd/GZs2bYqTTz45br/9\n", + "9oO2cf7Ka/v27fH3f//3sXPnznjyySfjlVdeie9///sHbeP8TRxHOlfHI1mENTU1Rd8Bf6G4r6/v\n", + "oIqkHN544434wAc+ENdff31cc801EVH7rWD37t0REfHUU0/FO3+/BPbwc7pr165oamo68QdN/OIX\n", + "v4h77703zjvvvPjIRz4SP/3pT+P666937iaI5ubmaG5ujnm//xMEH/zgB2PTpk1x7rnnOn8TwMMP\n", + "Pxx//Md/HFOmTImGhoa49tpr45e//KXzN4Eczf+Vzc3N0dTUFLsO+NMAoz2HySLswIVg9+/fH2vW\n", + "rInFixenOhxGUBRFLFu2LC688ML4q7/6q6H3L168OL7zne9ERMR3vvOdoThbvHhx3H333bF///7Y\n", + "sWNHbN26dWh+nBPrq1/9avT19cWOHTvi7rvvjve///3xve99z7mbIM4999yYMWNGPPHEExERsX79\n", + "+njXu94VV199tfM3AbS3t8eGDRvi1VdfjaIoYv369XHhhRc6fxPI0f5fee6558Zpp50WGzdujKIo\n", + "4nvf+97QPnWN4RMMjtq6deuKCy64oJg5c2bx1a9+NeWhMIIHH3ywqFQqxZw5c4pLLrmkuOSSS4of\n", + "//jHxXPPPVf8yZ/8SdHW1lYsXLiweOGFF4b2+cpXvlLMnDmzmDVrVtHd3Z3w6BnU09Mz9OxI527i\n", + "+PWvf110dnYWs2fPLpYsWVLs2bPH+ZtAVqxYUVx44YXFRRddVNxwww3F/v37nb+SWrp0aTFt2rSi\n", + "sbGxaG5uLu66665jOlcPP/xwcdFFFxUzZ84sPvWpT43qY1usFQAggaSLtQIA5EqEAQAkIMIAABIQ\n", + "YQAACYgwAIAERBgAQAIiDAAgAREGAJDA/wckYxa5Es1/mgAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "pyout", - "prompt_number": 18, - "text": [ - "[]" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAJPCAYAAAA0UwMNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text": [ - "" - ] - } - ], - "prompt_number": 18 - }, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['prob'].data[0]\n", + "plt.plot(feat.flat)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see the top 5 predicted labels." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's see the top 5 predicted labels." + "name": "stdout", + "output_type": "stream", + "text": [ + "['n02123045 tabby, tabby cat' 'n02123159 tiger cat'\n", + " 'n02124075 Egyptian cat' 'n02119022 red fox, Vulpes vulpes'\n", + " 'n02127052 lynx, catamount']\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "# load labels\n", - "imagenet_labels_filename = caffe_root + 'data/ilsvrc12/synset_words.txt'\n", - "try:\n", - " labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\\t')\n", - "except:\n", - " !../data/ilsvrc12/get_ilsvrc_aux.sh\n", - " labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\\t')\n", - "\n", - "# sort top k predictions from softmax output\n", - "top_k = net.blobs['prob'].data[0].flatten().argsort()[-1:-6:-1]\n", - "print labels[top_k]" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "['n02123045 tabby, tabby cat' 'n02123159 tiger cat'\n", - " 'n02124075 Egyptian cat' 'n02119022 red fox, Vulpes vulpes'\n", - " 'n02127052 lynx, catamount']\n" - ] - } - ], - "prompt_number": 19 } ], - "metadata": {} + "source": [ + "# load labels\n", + "imagenet_labels_filename = caffe_root + 'data/ilsvrc12/synset_words.txt'\n", + "try:\n", + " labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\\t')\n", + "except:\n", + " !../data/ilsvrc12/get_ilsvrc_aux.sh\n", + " labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\\t')\n", + "\n", + "# sort top k predictions from softmax output\n", + "top_k = net.blobs['prob'].data[0].flatten().argsort()[-1:-6:-1]\n", + "print labels[top_k]" + ] } - ] -} \ No newline at end of file + ], + "metadata": { + "description": "Extracting features and visualizing trained filters with an example image, viewed layer-by-layer.", + "example_name": "Filter visualization", + "include_in_docs": true, + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + }, + "priority": 2 + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/hdf5_classification.ipynb b/examples/hdf5_classification.ipynb index 03c811b5120..e98d13dd501 100644 --- a/examples/hdf5_classification.ipynb +++ b/examples/hdf5_classification.ipynb @@ -1,1075 +1,6290 @@ { - "metadata": { - "description": "Use Caffe as a generic SGD optimizer to train logistic regression on non-image HDF5 data.", - "example_name": "Off-the-shelf SGD for classification", - "include_in_docs": true, - "priority": 4, - "signature": "sha256:741422697d76b1667287180dc7c6360cf105ee774b1e2def800dc8fe80f78f67" - }, - "nbformat": 3, - "nbformat_minor": 0, - "worksheets": [ + "cells": [ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Caffeinated Logistic Regression of HDF5 Data\n", - "\n", - "While Caffe is made for deep networks it can likewise represent \"shallow\" models like logistic regression for classification. We'll do simple logistic regression on synthetic data that we'll generate and save to HDF5 to feed vectors to Caffe. Once that model is done, we'll add layers to improve accuracy. That's what Caffe is about: define a model, experiment, and then deploy." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "\n", - "# Make sure that caffe is on the python path:\n", - "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", - "import sys\n", - "sys.path.insert(0, caffe_root + 'python')\n", - "\n", - "import caffe\n", - "\n", - "import os\n", - "import h5py\n", - "import shutil\n", - "import tempfile\n", - "\n", - "# You may need to 'pip install scikit-learn'\n", - "import sklearn\n", - "import sklearn.datasets\n", - "import sklearn.linear_model" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 1 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Synthesize a dataset of 10,000 4-vectors for binary classification with 2 informative features and 2 noise features." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "X, y = sklearn.datasets.make_classification(\n", - " n_samples=10000, n_features=4, n_redundant=0, n_informative=2, \n", - " n_clusters_per_class=2, hypercube=False, random_state=0\n", - ")\n", - "\n", - "# Split into train and test\n", - "X, Xt, y, yt = sklearn.cross_validation.train_test_split(X, y)\n", - "\n", - "# Visualize sample of the data\n", - "ind = np.random.permutation(X.shape[0])[:1000]\n", - "df = pd.DataFrame(X[ind])\n", - "_ = pd.scatter_matrix(df, figsize=(9, 9), diagonal='kde', marker='o', s=40, alpha=.4, c=y[ind])" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAImCAYAAACB54oCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text": [ - "" - ] - } - ], - "prompt_number": 2 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Learn and evaluate scikit-learn's logistic regression with stochastic gradient descent (SGD) training. Time and check the classifier's accuracy." - ] - }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Caffeinated Logistic Regression of HDF5 Data\n", + "\n", + "While Caffe is made for deep networks it can likewise represent \"shallow\" models like logistic regression for classification. We'll do simple logistic regression on synthetic data that we'll generate and save to HDF5 to feed vectors to Caffe. Once that model is done, we'll add layers to improve accuracy. That's what Caffe is about: define a model, experiment, and then deploy." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Make sure that caffe is on the python path:\n", + "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", + "import sys\n", + "sys.path.insert(0, caffe_root + 'python')\n", + "\n", + "import caffe\n", + "\n", + "import os\n", + "import h5py\n", + "import shutil\n", + "import tempfile\n", + "\n", + "# You may need to 'pip install scikit-learn'\n", + "import sklearn\n", + "import sklearn.datasets\n", + "import sklearn.linear_model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Synthesize a dataset of 10,000 4-vectors for binary classification with 2 informative features and 2 noise features." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "# Train and test the scikit-learn SGD logistic regression.\n", - "clf = sklearn.linear_model.SGDClassifier(\n", - " loss='log', n_iter=1000, penalty='l2', alpha=1e-3, class_weight='auto')\n", - "\n", - "%timeit clf.fit(X, y)\n", - "yt_pred = clf.predict(Xt)\n", - "print('Accuracy: {:.3f}'.format(sklearn.metrics.accuracy_score(yt, yt_pred)))" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAiMAAAImCAYAAACB54oCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXd4HPd57/uZme2LbcCid5AgCPZeVCja6qIKrViWbcmJ\n", + "jhLLshM7Tuyce+95ro99zuPclOPYThxbyoks+cgy1TslFlFi7yBAggQBEHXRge29zOzM/QMURIqU\n", + "REkESUv7eR4+WM7sb/admd2Z77y/twiappEjR44cOXLkyHG5EC+3ATly5MiRI0eOzzc5MZIjR44c\n", + "OXLkuKzkxEiOHDly5MiR47KSEyM5cuTIkSNHjstKTozkyJEjR44cOS4rOTGSI0eOHDly5LisTKsY\n", + "EQThF4Ig7BIE4ZfvW24SBOG3giC8LQjCv06nDTly5MiRI0eOK5tpEyOCICwBrJqmrQEMgiAsO2P1\n", + "94A/aJp2vaZpfz1dNuTIkSNHjhw5rnym0zOyEth6+vU2YPUZ664D7hQEYbsgCHdMow05cuTIkSNH\n", + "jiuc6RQjTiB6+nX49P/fZQawEVgH/EgQBGka7ciRI0eOHDlyXMHopnHbYcB++rUDCL1v3U5N02RB\n", + "ELqBYmDkzMGCIOTq1OfIkSNHjhyfITRNE863fDrFyH7gW8DzwPXAE2es2wcsFAShBagBJs63gVzf\n", + "nM8XgiBc9nO+ceNm9u8fpapq/pQ9Hk8r11xTwW233XTZ7Orp6WHfviP4fGFmzCjnqqtW4Ha7L5s9\n", + "F5Mr4bxfarLZLEePHuPQoeMoSpaFC2exfPlSzGbzR47ds2cfGzcep6ZmMaIooWkaw8OdNDQYue++\n", + "L18C6y8On8fz/knQNI329nb27z9KNJpg9uwaVq9ejsPhuKDxiqLwr//6GOl0OW53GQCZTIrh4SP8\n", + "xV+sY8aMGdNp/lkIwnl1CDCN0zSaprUAKUEQdgGKpmlNgiD82+nV/wT8PbAH+E9N05TpsiNHjgsl\n", + "lUpx6FA7FRVzpn40giBQUTGHgwfbyGQyl8Wuw4eP8NhjGxkasiCKs2hpifGb32xgbGzsstiT49Oh\n", + "aRovvPAazz9/mHi8FEWpYcuWbh5//GnS6fRHjt216whlZXMQxcnZbUEQKC9v4OTJIUKh0IeOz/HH\n", + "xzvv7OTJJ9/B53MhCPXs2zfBI488dcHnur+/n0BAmBIiAAaDCZutlv37W6bL7I/NtKb2apr2fU3T\n", + "1rybMaNp2vdO/x3TNO1mTdNWa5r2xIdvJUeOS0MqlULTdCSTKUZHRwkEAqiqhk6nR1UlUqnUJbcp\n", + "nU6zadMeysqWUlBQitmcR2npDESxim3bdl9ye3J8egYHBzl6dIja2qXY7QVYrQ6qq+czMqJx4kTb\n", + "1PsmPR7DtLe3TwnPbDZLIpHGZLKctU1BEJAkE4lE4pLuS47pJRwOs337Uaqrl+NyFWE251FR0UAy\n", + "WcDevQc/dKyqqng8Hk6cOMH5Ll1mcx6BQGSaLP/4TOc0TY4cf1RYLBYG+zs4fmAAh8GMomlIdjsN\n", + "8+dit+vJy8u75DZNTEwgy0aMxrPd9253OR0dO9A07UNdnzmuPAYGhtDpCs45bzZbCe3tvSxduoR4\n", + "PM4rzzxDsLcXqygSVVVKGxu58557qKgoIhicwOUqmhory2kkKUVBQcGl3p0c08ikCLUjSWffqgsK\n", + "yjl5so11684/zu/389Lvf4/i9ZJOJGg95CGT0jN3/gJEcfJ7FwqNs2pV5TTvwYWTEyM5cpzmSFMT\n", + "lboUmpjAaarBYrQx5B9h3642/vFnP0QUL33BYqPRiKbJ5yyX5TRmsyknRP4IsVhMqOq5U36ZTAqb\n", + "bdLjsfWNN8DjYXV19dT64+3t7Hz7bW6++Voee+xVVDWL01lIIhHF6+3gjjtWYjQaL9l+5Jh+DAYD\n", + "mna+70oSq9V03jGapvHyH/5AUTxOxenvTyKWZmfzNgxGPTPrZzExMYheP8GqVTdPq/0fh1w5+Bw5\n", + "TtOyZw83LFrAnVfXYjEN4Y8cobIwwpIZFoqKCi+LTUVFRVRW2pmY8Ewt0zSNkZEOrrlm0WWxKcen\n", + "o76+Hr0+TDz+notcljOkUsMsXjyPWCxGf2srs8rKzho3u7yctkOHqKio4KGHvkRxcZTx8b0YDB7u\n", + "u+86rrpq1aXelRzTTFVVFS6XRjD4Xo6Hqmbx+bq56qrF5x0zPDxMZnycisL3rlnXL5nPumWFeLo3\n", + "MzGxjzlz9Dz88NdxuVzTvg8XSs4zkiPHaRKxGGa7nZqSEmpKSqaWNw0OXpZ4kXf5ylfu5Pe/fwGP\n", + "ZxxBMKNpERYtqvjQm48sywwNDaGqKhUVFbkn5iuARCLByMgIOp2Or371Zp57bit+vwWQEIQQd9yx\n", + "mqqqKvx+P3pBOMcTp9fpEBQFWZaprq7mwQerz/9BOT4zSJLE/fd/iSeffAmPZwBBMKJpIa69tpEF\n", + "C+af8/5EIkFnZyeRcJisqiKd/g7pJIlls2dBcSHf+3//5lLvxgWREyM5cpympqGBkb4+Kovem4tP\n", + "yzJJSaLojGWXGpfLxV/+5YMMDAwQj8cpLCykuLj4A9/f29vLG08/jSGZRACSej3X33038+afe/HK\n", + "cWk4eOAA+958E5uqogCq3c599/0JiqKQzWaprKzEZrMB4HQ6EfLyiCYS2CzvBar6wmHsJSUXlP6b\n", + "47NDSUkJf/u3D9Hf3086naakpOS8sUGHDx5k75tvYkil6Dx6lNDwMGtWraL4tPdjxOejdt68S23+\n", + "BSNcqXnegiBoV6ptOaaHy113YGxsjGcffZRyUaTY6SSWTNIVDLLirrtYtXqym4Hf78fv92Oz2Sgt\n", + "Lf3Q7cmyzMDAANlsloqKCiwWy4e+/2IQiUR44uc/Z77DgcNqBSCeStEyMcFXv/vdDxUxl4vLfd6n\n", + "i3g8zsjICGNjYzRv3MjyqiqMej0wKSy6ZJlv/uAH5/VaHTxwgFcff5w6h4P6igpCsRh9iQR3PPjg\n", + "Ja0LMZ38MZz3aDTKyMgIBoOByspKdLor8/nd4/HwyqOPsqy8HJPBQEd7Oy0HDuDT6bhn3Tri6TRj\n", + "osjXHn6YwsLLM+UMU+f8khc9y5Hjj4qSkhK+9p3vcGjvXtq6u7EVFHDz+vU0NDQgyzKbXnuN3uZm\n", + "7KJIXFXJr6tj/Ve/ivX0Tf9M+vr62LBhI8mkERCRpBi3334ty5cvndZ96Ghvx6koU0IEwGoyUaLT\n", + "0XbsGMU3Xb7CbZ8nzvSEtLS14UgkSObnYzz9lOp2OBj0eOjt7aWxsXFqnKZpbN++i3feaSFiaODN\n", + "zh44uY/b7/gC9zzwAOXl5Zdrlz537N69l61bD6FpdjRNxuFQue++u67Ic3D00CGqrVZMBgOhYJBR\n", + "jwe7Xs/gyAiPvPIKN9x9N9/48z+/orOtcmIkR44zKCoq4vYvfemc5Xt37WKiqYlramqmMlg6BwbY\n", + "9MorfPm++856bygU4uc/fxxJrMVdWEpBQQGpVIKXXtpNaWkxFRUV02Z/IhbDrNMRDocZ8nhIxmI4\n", + "CgqQrFai4fC0fe7lYHx8nKNNTQQnJiitqWHRkiUXXJXy/cjyZMaS/rTn4tPQ19fHgVdfZWVFBUa9\n", + "ngmPB3smQ8v+/Vx7443oTn+GEUgmk2eN7ejoYOvW41RXr6aqSseCBWsJBMbwRQYu2KsVjUbp7u5G\n", + "URQqKyspOSP+KceF0d3dzZtvNlNZuRqdbvJ8hcM+nnzyZX7wg4cwGAyX2cKziYfDuE0mEvE4W15/\n", + "HcJhDJJERUEBdatWkQ0GiUajOTGS46PZuRP+4R8gEIA774Qf/hBM58/cynGJUVWVY/v2say8/KxU\n", + "2lllZew+eZJwODx1EwwEAvzLT3/KqcNe8oQgh/x+otksFeXlSCZ45eWN/NV3H542W8urqtgzMkL/\n", + "0BBOScJsMBDw+Tgei/GVtWun7XMvNadOnWLT739PqU6Hy2JhqK+P4/v2ce9DD30sN7Tf72fHli30\n", + "nTyJIAjMXLCAtTfddMGiZrIIWQKz2Tzlwj966BA1eXlTUzJFRUX4fD4Uv589u3ZRVFREaXk5IThH\n", + "YOzffxSXa8ZZdSXy80sYGBjC4/F85BTNybY2tj77LM5sFgnYr2k0XH01N912Wy4N/GNw4MBRbLaa\n", + "KSEC4HC48XgG6O3tZfbs2ZfRunPJ6nQ8/eyzBHp7MUSjVFksaAYDndksCZuNa1au5Njhw9TU1Hys\n", + "7cqyTDqdxmq1Tvv3JydGrgD+8IdJ8fGzn0F1NfzLv8B118HmzXAFZV59blEUBSWdxvS+pyFBEDCK\n", + "IqlUaurmtenll0kODOEdjjCRCpJJxYln9ZzwpXG59Gz43/vQ63Vcf8Na6urqLnrtkqqqKnp9Pqoy\n", + "GUrz8xEFgVgqhc5iwTsy8tEb+CMgm82y7eWXmZ+fPzUd5XY4GBgfZ+fWred4qj6IeDzOM489Rkkm\n", + "w3UVFWhAX1sbzw0P82ff+c6HPv1qmkZTUzPbtu0nkchiMAisWbOYa6+9mlgoRMkZcSB15eXs3L4d\n", + "aWKCOqB/dJQNG99EqarD0TCHW265cSpAOhyOYTKVnecTjR+Z0RWNRtn63HMscbuxnn6Syaoqh/fs\n", + "oWbmTBoaGi7ouHzeSSQSnDjRjt9fQCKhUFJScsZ3wXBZM+veTzKZ5OWXX+XRf/ol8dEBChMxaiZX\n", + "MKJplDgcWCYm6B8Zoaa29oK3K8syb7+9kwMHjqMoAi6XiVtuWcPcuXOma1dydUYuN8ePw/e/D9u2\n", + "wX33wTXXwEsvwapVcNddcJnaoeQ4A4PBgLu8nIlg8KzliVQKxWAgPz8fmJyeOX7oMC1tw0TiKSZi\n", + "BsYzxaiUgmLHOxEn6IXnn9zI44+/xYYNL6IoF7ctk9/vZ1FDA5WLFtGpqpxUFByzZvHlm29moLMT\n", + "VVUv6uddDnw+H1osdlZcDEBFYSGejo4LPqZtx49jjUSoKS5GFEUkUWRmWRmC10tnZ+eHjm1pOcqL\n", + "L+7DYplPZeU1uFxL2bSpje3bd1Hd0MDYGX1Dgl4vc1wu5JISjqfSbOgYplueSV9/Bb/5zSG+/e0f\n", + "09HRAUBjYy1+/9miUVWzaFroI6dbent7ccjylBABkESRKpuNE0eOXNAx+bzj9Xr51a+eYGgowalT\n", + "IzQ3D7J9+35isRiqqqJp4Y8MXL9UhMNhfv3r3/Hvv3gFS7qatFDLuGCkTRAYEkVUWWaR241DUeg4\n", + "dYrqWbMueNuvvbaJXbs8FBauoqrqWgShnqeeeouenp5p25+cGLmMqCo89BD8/d/D3LnvLRcE+MUv\n", + "wOGAv/u7y2dfjve47tZb6YxGGfJ6ScsyE8EgzSMjXHPrrej1ejRNY3R0lKbj/Vi1SkrydCSzXsyS\n", + "nYyqI5IexyjFqSlcTiAQobx8EW1tQVpbj19UOyVJQpAkFs2axZduuom7b76ZZY2N6HU6JJ3uM+Gq\n", + "lySJ7HmyMLKqiiCKF+xtGhsaouA8wcdOgwHv6OgHjtM0jW3bDlBaugCzebJFgMFgorJyIbt3H6Vx\n", + "7lxiDgenhoZIptP0dHcTUVXmzJtHIGvH5voitSXXUGirxO1eQDBYziOPPIWiKKxatQyzOcDwcBep\n", + "VIJIJEB/fxOrV8/+yPl+RVGQznN+9TodmSvoaf5K5rXXtqIoFaxYcStut4YoyqRSBg4fPkR//xGW\n", + "Lau7YjLStm/fQyTiJB0WqHAVY9XbydcX4pLMlBsMFIkiyUSCQCqFbDKxaMmSC9puMBikubmX6uqF\n", + "6PWTHqG8PCdO5yzeeWf/tO1PToxcRl55BWQZ/uIvzl0nivD730++Z8uWS29bjrOpqanhyw8/jFxT\n", + "Q3M4jD8/n1sffJAly5YxPDzME7/+Nc/++78THxllPNRHgdWOWYwj0otGD4IQpsxSTkaBhKyRzSrk\n", + "51fT1HTiotpZVFSEpbiYUb//rOVdo6PMX7nyMyFGCgoKsJeXM+T1nrW8a2SEOcuXX7AYyS8qInKe\n", + "m3RMlhF0Onp7e/G/7zjCZEPFSCQ1JUTeRa83kM1OXry//tBDFKxaxdF4nD5RpHTuXAS9nkGPB12k\n", + "h/DoDiKh4yhKGqezgr6+MOPj4zidTh5++OusWOEilTqB2TzMvfdexW23fXQWVGVlJQFNQ8lmz1o+\n", + "FAoxa8GCCzomn2ei0Sh9fV7c7nJMJitr1txEXZ0Zo3GUQKCV22+fz1133fqR28lmswwODtLX1/eR\n", + "XZg/DS0tHZSW1qEzGhgJDaBmxggoUeKKSlQQGNc0BrNZJux2/vRv/uaCe2uFQiFEMe+ca4Xdns/w\n", + "8MQHjPr0TGvMiCAIvwCWAs2apn3/jOU/AdYDQeA1TdN+MZ12XIloGvz0p/DjH08Kj/PhdMLjj8MD\n", + "D0Bray5+5HJTUVFxTjxCJBLhxccfZ6bBQEVFBdGaOk51DTM40YXJlIeolIKogeBjOK2gjAfQ2XTs\n", + "3LmJOXPmYbdPzvsePdpKZ2c/NpuFpUvnf+xAs3cRBIHbv/IVXvzd7xjzeCCZpGfCi+zMZ15hIbIs\n", + "X5SMkcuJIAis+/KXeeF3v2PC48EiCEQ1DXNlJWu++MUL3s68BQto3rEDXziM+3TMz8D4OLt6BnFn\n", + "jmA09qJpcebPr2T9+nVT9UCMRiN5eXqSydhZgiSbVRDFDFarFZ/Ph6yJCDYXlvIZ7Dl2FDEwykxB\n", + "xG20o2owkgoQ97dgNl+NpmlTIsrlcrFu3c0f2ATtgygqKmL+2rUc3r6dyrw8DDodw+EwhpqaXMG7\n", + "C+Ddmifv3oTN5jzmzVvJ3Lkag4O7Wbx4EZIknTMulUrR2nqckyd7SaVi9PWNYDAUAiKCEGXu3CrM\n", + "5jwKChzMmzf3E2d8vR9JElHVLK4iC4lmD0utTiY0gYnkEGoigc5iQSwqYvX69dzwMVL67XY7mhY/\n", + "pwlnLBaipMR9UWw/H9NW9EwQhCXAw5qmPSQIwm+AxzVNazq97sfAHk3T3v6Q8Z/pomfbt8Nf/dVk\n", + "zMhHPch973uTWTZPPXVpbLtc/DEUQXo/2956i70bNlDicKCXJJr3HCQZUeic8DIgOlCyZWQyetJy\n", + "CpujDqMlTsPsuVit+Xi9u/jRj75BW1sfXq8eh6OEdDpJIjHInXeuYPXqT95rJJ1Os3nzFl595R2s\n", + "eTW43ZWk035qakz86Z9+BdMVlKr1Sc97JpOhu7ubSDhMYVERNTU1571ZfBiDg4NsfvFFUn4/mqbR\n", + "H4iS1c9kzpzVU3Z5PMeZMUNkZl0Vkk5H/axZ9PcP8PLLh6ioWITBYEKWMwwNHWft2hmAxjvvnODU\n", + "qSBe72Q33cDYUWqiY2RTcXRiJTpjPo6CAkbUGBFbNatX5/Gzn/3kUwc0a5pGd3c3J5qbkVMpymfO\n", + "RE6l6G1rQ2cwsGDlSuYvWPCxj9N0cCX+3v/jP57E73fhdr8XROz1DlFaGufBB79+zvuTySSPP/40\n", + "w8NgtRawffsWVNXN4sVzqKoqZceOTUxMhLj66qswGkV0Oj8PPLCe6upPV8o/nU7z639/hF2bDzPu\n", + "6cAcSaClslgEiaziRbTqEGfN4r//7GcsX778Y3tEn332JVpbI1RUNCJJOpLJGGNjx/izP7vpU2US\n", + "Xa6iZyuBradfbwNWA01nrP8nQRCCwA81TTs2jXZckTz2GHzrWx8tRAD+8R9hwQLYuBFuv336bcvx\n", + "Hqqq0tfXR++pU+gNBmbPnTsVSDg4OMjLv/0tzvFxgpJEZ38/WUmiVDSh2gzIogb5KpGYH1EqJZ0e\n", + "o6ioHoPBSSIRxuFw09vbh89norr6vSh1WS5h06b9zJ8/74Jdq+9H0zSOHu1j0eK7MZnejYuoweM5\n", + "zqFDTaxZc82nPTSXHYPBwJw5ny66v7Kykr/467/G7/cjyzKPPvoMxcVnX7xjwQCbn9jEXWtWIOp0\n", + "NG3axIp167jjjiW8885hMhkRUZT54hcXMmvWDB599FUMhmpSKY2ammo0TSU43k9lQxnh0VPE42Ek\n", + "vYF0WiAdH8NWJvK97/2vi5JZJQgC9fX11NbW0tbWxu8feQRjLMay2bOxmkwcePZZPD093Pknf/KZ\n", + "mLK72KxffzOPPfY8g4NBTCYHyWQIqzXG7bffc973Nze3MDIiUlMzn8HBUxgMFbhcs2hv7yUYHECW\n", + "iygoqCORgJkzG4lE/Dz//Jv87d9+6xOfb1mWefb//B8so0MIvk6SQ6ewixI6yYBiMrDomtXcddNN\n", + "HB4fp7Gx8ROd5/Xr12EybaOpaR+gw2IRuPfe66Y1pXk6xYgT6D39OgycEaLJv2ma9j8EQZgJPA6s\n", + "mUY7rjgCAXjjDfjVry7s/RYL/Od/wp/+KVx77WRga47pJ5vN8toLLzBy9CjFJhNyNsvRt99m9Z13\n", + "snzFCjY++yyL3G5SkQhpv58lNhtjioKY78Qty9xcUYlYWUFJ/QLGxiyYTA7GxrzIskJR0SzS6UJO\n", + "nmyjru7seehEIsLAgI8339zEDTdcP5Wt83EYHBxElq1nCJFJCgtraGpq+0yIkYuFIAi43W6i0SjZ\n", + "rHhWbQmvd4hk33Ea7PlUFxVhsViolWUOvvkm933/+6xYsYxYLIbFYsFoNLJ581sEgzAychJZNqNp\n", + "KoIgYrbW4E300jhjEeVlEql0inA4Rr6umu/+fz/9xNNy5yOdTvPCU0/RtXs3pt5enDYbB/bvZ+my\n", + "ZSyrreVASwvDq1ZNa/G9P1aKi4v5679+gOPH2xgb81Fa2si8eXM+8KHg2LEuCgoqAUinkwiCCUEQ\n", + "0TQT3d1tVFRcTyqVJB6fLG5ntxcwMNDF+Pj4J87K6ejoINXXx/DQEMmxYRboRVySxJiaobC0HGSZ\n", + "8VAIyWL5xC0ojEYjd921jptu+iKpVAq73T7t3rTpFCNhwH76tQOYynXTNC14+m/3h6m2n/zkJ1Ov\n", + "165dy9rPSNGmDRvgttvg49xjvvCFyTH/9b/Cf/zH9Nn2WUdVVcLhMEaj8SN/qO3t7Yy1tLCytnbq\n", + "6aJGltm/cSN5NhtaMMjchgb2DA7i8/koM5uxKwqHhoaYvXgxt163huaxMSoqChke9pGfX0d+/mRG\n", + "RDA4wcDASaxWlXR6Mhhy0puxh8OHD+H1Bmlv7+PVV3fxrW/d+wnFw/ld4Lkn4kk0TWNkZIQBjwe9\n", + "Xs+MmTNxOAzE42Gs1knFPzF0CpcoYjZJU1NbBr2eQlGkp6uLVVddNdWGfWJighdffJOODgPJpJVg\n", + "cJhgMEB9/XzMtjzaByYY8vqoT7hZs2w29opyZjU0TNX/8Pv9DA0Nodfrqa2t/cQN8ZqPHCHZ3U2p\n", + "IGByu7FZLJTKMkeamykvLMQlCAwNDubEyAeQl5fH6tUrz7sum83S398/Vc3UYNARi01W73U63ahq\n", + "/+l3qoji5O8slYpSX3/xMnB6OzpoP3qcw4cOszCrYZJMqJkELr2eIx4vgl+mOfAWf/433/7Un2U2\n", + "my9ZY8bpFCP7gW8BzwPXA0+8u0IQBJumaVFBENwfZsOZYuSzxPPPf7KU3X/+Z5g/fzLe5AtfuPh2\n", + "fdZpazvJG2/sJBpVEASFBQtmsG7djR/4Y2tvaaHK6Tzr5m3Q63FpGh6PZ7LomdFIdUMDzQcOEA6H\n", + "0QQBnyRRarOhE0VkTWPJkkV0dLzK8HAXBQVlNDXtoru7j4KCQtxuC5s3P81tt91HPB5m+/YdCEID\n", + "dvtsqqvr8Pk8/OM//icNDfUYjUba2zs4deoUExMRzGYr8+fPZNmyJef0x6mqqsJgSJwTZDkx0cdt\n", + "t83l846qqrz52mv0HTpEviShaBq7RZGGpcvYf+A4Tucs7PZ84tEQanycq5ctO8etnj2jZoumaTz/\n", + "/BsYjTWEwzvx+zUikQzBoItAYBQYobj4OhIRLz7VxtP7R7lm7Uz+n3vvPZ0qvJ2dO1vRNCeQRdNe\n", + "Z8mSmRQUuKmpqaK6uvqC3fonm5qoLSxkIBhEPp1ZY9brsakqY4EAGU3DlOv8e15isRgdHZ1EozEq\n", + "Ksqoq6ub8ggEg0GefPIFJiZUBMGMpkUxGuNEIj7s9gLy80spLjYzNHQMg0FHXV0t3d3HKCoqoKJi\n", + "sp9NJOLH6RQ/VXrwkZajNB85RpGsYEJDp4p0KiLdSScGQzFRxUTAWMS///p1jrX2cv/9X5rWYmUX\n", + "i2kTI5qmtQiCkBIEYRfQomlakyAI/6Zp2veA/yUIwjwmU4v/r+my4UpkbGwyM+bGGz/+WIcDHnlk\n", + "MhW4tRXOUyIhx3kYHR3llWef5YUX9+B2z6N+zgLKKso5dqyLWOwVHnjgax97m4qi0NTZS//hVmKj\n", + "gzRUViIlk8iCQLHbTXp0lP2trZSuXk1ZWRnf/ObX2bVrH6+88hIDA2nmzFmBpmnodDpsNpWtW39P\n", + "NisQi9mw2UyUlZWg11soLGykr2+MJ598imhUoqtrjIGBKAZDPhUVBYyM9NLc3M5DD913liAxGo3c\n", + "c89NbNiwBShErzeRSvmprTWzfPmyi3h0r3wSiQTBYJC8vLypTIaOjg48Bw6wqqZm6iYfT6VoaWnm\n", + "a1+7m4MHWxkZ6aC6wYGUV4HL6aCnpxefz0844OOEz8cSoxG7w8G8efPw+Xy0t3vo6YkRChlJp63o\n", + "dBKp1ACJxDA2WzX19TZuuGEVRUXFhMMhxsebCJ7uGfL2221UV69GknSMjY2xZ88ge/Zs5JprvkAm\n", + "04IoBnE6CzCZjKxcOZ8VK5Z/aFaUIAiUV1VxzOPBkc1O3lA1jVgyScRkor6+/pIc+09KMBjk5Ml2\n", + "Eok0tbWV01Kt+P14PB5+97tXyGQc6HRmFKWdurpD3H//l4nFYvz4x/9MR4eG213OjBlFVFbOYWDg\n", + "BGbzEAMD+xHFfIqLC4A2CgsLMJkEdLokdruJYHAMv38MSfLy7W9//RPvSzwep3X/YWQkNEXFp2TQ\n", + "ayKerAOrVIMm6YlmNWYWz8ftdtPXN8xTT73FQw+Zqf0YFVgvB9Oa2ntmOu/p/3/v9N/pa85xhfPy\n", + "y7BuHZyna/gFsW4dPP00/OhH8POfX1zbPouMjo7y3KOP0nuim4aC2Rh1JnqPHCERjzN7zhy6uvYx\n", + "Ojp63vnb2YsWsbetjWKXa8o7kpFl+sJhju04jqNyDZ2HN2OJZNB0EBFkopLIYoOBkUyGVCzGA+vX\n", + "A+BwOLjZkGjqAAAgAElEQVTjjls5caKHWCzB4V0HMGiTxbtUg0BZjRFFGQNKEEUTw8MBvN4ANTWV\n", + "CIKNbdsOsnbtNwiHx6iuXosoSni9/dTUOPD7IzQ1NXPdddeeZX9jYyPf/34RbW3tRKNx6urmUF9f\n", + "f8W2Qb/YqKrKznfe4eiuXViARDZLzcKF3HbXXZxoaqLG6TzrpmA1mbCdLnn8zW/eD0y65X/zy1/y\n", + "mxffIC9rxjs6RkRLUTWrijl6PTv/8Aeit9/OjPp6urs9yPIs7HYnBQV5JJNhUqk8gsFxamsX0tBQ\n", + "hcViZceOfaRSIpGIl3/4h19RXV2G3V6DJOmQZZmmpjZcrgaiUT0g0t+vMjoaZvXqSioqZrJx40l6\n", + "e4e4//57zjvl1rh0KR1vvMHCmhqq58+n98QJJEXhVDKJSa9n/X33nbfT9JVCW9tJnnlmK4JQiCga\n", + "2L69g9mz8/na1+6etrR0RVF4+unXycubi832Xg2Fnp5WtmzZxoEDrbS2higr+wLZbJYjR/oIh6M0\n", + "Njbg84V46KEvMTIyislkZMaMr0/FmKTTafbs2cOGDa+TzeopLCzn6aff5M4717Jo0cKPbWd/fz/x\n", + "kRHSqRSDchJ3VkXWDKQFKxICASWLpWQeoVCCsjI7kcgp7PaV7Nx58PMtRnKcywsvwHe/++m28ctf\n", + "Tk7XfOUrk2Xjc3ww+3fsoEqno1vTkWeyo9cZqDYY6Dl1ipq6OkQxj0gkMiVGotEoXV1dJBIpystL\n", + "KViwgLf27MElSRjNZiI6HXGTg5KipTidhYiihCf9IjEE9EKcr990HYgisqKQrajA4/GwZ08L0Wic\n", + "xsYa2traaT8cptZZhiSKpFMJQrEwxw61U1RpQhCcZLMJNC1DNmugu7sPQRimrKyCZDIOOBHFSbex\n", + "1eqmv3+ExYsbOHGi5xwxApMFwv5YglUvpHOuoih0dXXR3t6D2WxkwYI5H9jS/fChQ3Rs28ZV1dXo\n", + "JAlVVWk/fpwtooiSyaA7IyAvkUrhDYfxh0JnFarKZDL4IiJ11z1Ay97tmMpczCmuJZb0MeIPUmaz\n", + "sun55/nmD35AJpNBUQRAhywLSJIDi8VCNltAXp6FWCzB/v1HSaetKIpKLBbj5Mk0b799gFWr1uN0\n", + "FuH3+1EUI3q9EdAzPDxCImGmtHQhw8ODzJq1mNraxXR0HMTj8Zw38HXpsmX0trfT1NtLkc1G8fz5\n", + "dIVCfHndOubPn4+iKIRCIZxO5yc6T9NJMpnkhRe2Uli45Izg6zra25tpaTnKihXLP9F2NU1jaGiI\n", + "RCKB2+0+p5rt8PAwsZiOqqqzizmVlMzgpZdewGyuRa+3I4o6dDoDBkMVvb29VFaWMTw8Sk9PL2Vl\n", + "pcyYMeOcQM+DB9uZNetmXK7J/kOpVILnntuB213wgXE7fr+f1tYT+P1hamrKmTt3DmazmY6ODtLe\n", + "UaolM1FLPhOJGGYtj4gq41dVdAUzKS+aQyIxTiTixWo1Y7O5GB3t/8hjFIvFOHDgMMeOnUKv17Fq\n", + "1QKWLFn8gQ8v0WiU4eFh9Ho9VVVVn1oo5sTIJSQQgMOH4eabP9123G7413+FP/9zaG7+5F6WzwMD\n", + "3d2sKiigyDnKWCCKM68AURAxCQLRaBRVjeJ0Ounv7+e5555n8+bDWK01p2MukkR9HVRY9XT7/aRE\n", + "kWU33shETxCnc7IzrNtdSXNKoEwxkZEjtBw4xuLFjaQlkYSs8dRTu3C7Z2IyWWhqGqGl+RjZuJ3h\n", + "jEIsEkZFh8lkIxP14e9OEk33EVKL0UkFaBKoYozGuTYkqZCmA2/i8YRRVTP5+WXIsoLP56OnR6S+\n", + "fvJG/e6FQ1VVTpw4wdH9+0knEsyYN4/lq1Zhs9ku5+n4QF557jl6jk+Wxq+bN4+1N900FRj6LrIs\n", + "84c/vEBnZ5i8vFIUJcTu3S9wxx0rz6nJomkah3fsYEFZGbKi0D00RCKZxOVw0N3SwuLrr6dn2zbc\n", + "DgfHenrZd2IYVbUxGAkQfX07paWlVFRUMDAwQDZro6qqkc6jpygrkIjEAwyOj/KbDVuZW+QCUeO3\n", + "gkBxcR6trf0MDiro9SWIIghCApfLTDzeQyikcrRliExSIBrrQc0O48qrweRysnfvERRFT03NpLCa\n", + "7EcTIJNxYzLZEQTQtPdiVETRydDQCG63G0VRsNlsCIKAKIoYjUa++sADdHV14enqIt9mY011NXve\n", + "eos3Dh7ELIpEVJXG1au58dZbr4iaI+/i8XjIZPLOyQJzu2s5fLjtE4mRcDjMU0+9xMjIZLaLpkVY\n", + "saKe22+/ZWrfJ3s2netlSiZTHD58nNLSfIaGBhkfN1NVVUV+fj6ZjMhrr72Ky6XwzjujRKPN6PVh\n", + "1q37InPnzsHtdtPd3U08bqK6umhqmyaTBZOpgqamYxQXFyNJ0lkeuu7ubp58ciOq6sZisdPScoyd\n", + "Ow9TWGjhp//tv5EIBggCAgITgCSYSAgKQp4Nd0HN6WwemURigEWLFhCJ+Kms/PAYlUQiwWOPPY3f\n", + "b8btno2iKLz0Ugu9vQPce+/d53jg9uzaxeGtW3EAMiDn5bH+/vs/VVB0ToxcQt55Z7IR3sWIHbvn\n", + "nsnqrE88AQ9/bie9Ppo8u514KsWSWVW8uLMdvc6A1WQjnVWYmOhm0aICXn11I08/vYmurggm0xIk\n", + "SSQQ8GGUojg1mYa5k9VVjQYD3tZW/EkDpaUpDAYT7e29ZCyNDIVOocYjBAcV3mprpby+mrzSeSxf\n", + "ee+US7y8fCZaxkU00ooolCFlzWgk8KU6yc8GQBUQ1SIEyYGs6lElPWkthX+sD+vgSarNLlLBEAPe\n", + "PvrzF6FlrdQWCRzt28upAxFamlq48ZYbuOmm62g+dIi+vXupy8/HZDAwtGsXTx07xv3f+tYVKUjS\n", + "J09y7WkPR39HB88MDvLAX/7lWcHFra3H6eyMUVv73g1Jlit4880DNDbOPutJX1EUUtEoMUFg1759\n", + "OGQZsygynM0yKIrc9o1vMFRby5bmZlraQ7jy6omqCjWz55FI2HjkkT/w3//7908X5RIAjWCgFzk0\n", + "ghyO4A+NUiplsVjLiClxXMEwwa52fD4boliCLAcxGPJwOCQEwUhRUZKD+58hErQjqBGM2TTV+kqE\n", + "eJpoOkE0z0dbm5n8fDPp9DgeTw951gjevl5icT16h5tFi2fg949isdgIhcb43f/eRl/3CD5fGJ1J\n", + "x7LVK7j99hu4/vrrsFgsNDY20tjYCMAffvtbTGNjzD1dbCurqrTs2cPhggJWrV49/Sf4AnnveJ/N\n", + "ZLGsT9bk8bnnXsPvt1FdPVkSX1VV9u9vprDwEFddNbnvZWVlGAwpUqn4lBBSVZW3396C3V6I3V5O\n", + "fb2L3t42urpi1NfPpL+/laIigTVrvobXG+bYMT/RqJ/u7leYM6eZm29ejslkQBDOveAnkzFeemkH\n", + "TU0dmEw6rrpqEWvWXI2qqvzLv/wng4NWVDWJw2GlsXEGr7zwJP4TW5BiYW4EjEAPGpVARPMT0rmJ\n", + "WkbQtBOMjrZhNEaYP/9mCgpKCQZPsmbNl857bBRFwePxcOjQYQYHszQ0NE6ts1qX0Np6gKuvHqKy\n", + "snJqeXd3Ny2bNrG6shL96YcffyTCK08+yTd/8IOpSsUfl5wYuYS89RZ8jKq8H4ogwE9+AvfeCw8+\n", + "CB/S7fxzzbI1a9j7zDMsq6nh9tUz2Huij87BMHKemVmzJnvD7NnTSyCQQVEM2GxudLo8/P5RtFSA\n", + "hDHChv7DzHTasZtFDHYr2fIqRkbacbnq8Hrj6M1l9He+Q0F6BFsEqsx5RIfGkNNlHMzsxl1Wweio\n", + "H1XNkkmLGJQMNt0YGTEPm6ijQA4QUxPEBAe1+hLMJgPxbAp/JkZCZyI9mmJGkY5MNES+aCCbCHOy\n", + "bwsmVzUZi5Vqm4mFtVfRNuHlrbe62Lx5BxWGJOuXLZu6WMyurKR9cJDmpiauuwJTsWaWvVfxckZp\n", + "KTGPh/aTJ1mydOnU8qNHO8jPrzprnF5vQFWdeDyes8SIXq/HWVzMW1u3Ms9oxHVagJVns3iHhujv\n", + "6eHeP/szfhGIo/NFyFpcRL0hoqMpRsayhEK9lJf/jm984+tIUhSPpx1zyks2GiWcylAhStRb8/CG\n", + "xnBWz6f71Ai2pIbNnMHlshKLxUgm+4lEQsxprEMZ76YwPIygjJNRFSyUoJMFdJIevaKAyYVODBGP\n", + "n8BgGKT75CnydS6MYho1MoFvVGRvdAGlFUESiQkGe3cwq2QR5kQFlcbZxOQY+3ccR68vZ3h4nG9+\n", + "8xtTT/1erxd/by9Xn1H1UxJFZpeW0rx795QYGRwcZMeOAwwMjFFU5GLt2pWXPNC1qqoKUdxMJjMp\n", + "9t/F5/Owbt3HL7g1MTGBxxOiquq9bBJRFCktnc3u3S1TYsRoNHL33TfwzDPbkKQSTCYrg4On0DQ/\n", + "a9feTkvLKfLzFzB7toXBwTaGhnZgsfi5++7/m0gkzMaNLyOKBQiCgRMnOpg1ayGbNh1h/fpVKEqA\n", + "8fFxotHJejR6vcbu3buYObORWCyP7u4Rjhx5ia6ubux2G8eO+amsXIRebySVirN1614mTh7AFItQ\n", + "C5QAJ4E5gAHoR0XIhtFFJEaUBHqjhcLCYvT6IDpdPw88cNt5K76OjIzw5JMvE43qaG1tJR53oap2\n", + "Zs+ehSAIpz1tLgYHh1AUhUAggN1up+XgQapttqlrC0CB3Y5pYIDe3t4pAfxxyYmRS4Smwdatk6Xd\n", + "LxarVkFDw2TdkgceuHjb/SyxcNEign4/+3buxAbU1JcyY9U8XCUl/P7x1/FOGEnE7JhMM8hkoni9\n", + "xyktXYWq6giHA8SzforyZmDRFxKKR5iY6CLc72XBKgN7977O4EAaOTTAAiOUmNyUGqwkMmmGExHG\n", + "4iG8J07R3h2lqrqeZDLG+HgQk6rQkAljkmSyQh7prEhMkAAROZMmq2TIqhqiBpmsjBE9PlkD2UKB\n", + "vRCrQSEZGcdHFqc+y4qGJSRTKRKD4wwFjKSzKnH5JPvSKqtWLZ16Uil1ueg7efKKFCPvJ99sZnx4\n", + "GM4QI6Ionnanvx/tvIGcDYsXs+fZZ9GfrpibymQYjURYuWQJnc3N3LJuHS6Xm8XL53DwYCvJpIFs\n", + "No0gKGiak/37e1ix4hS33XYVP/jWd3GHomixGPF4iBAaJqMOh8mAM9/BwEAEk95Mvr0IW2Ex4+M9\n", + "SFKGWEym/dhhrOkAquIGnFiANGZGtQkKFAsiYEybScVE+rraCQcc1OY1IKiQTCqMZ4Posi5inhSC\n", + "LgJkkVPlIIsgWLCYbRgUE4GxAEeajpBMzmLNms6p6rSpVArjebI3rCYTca8XTdPo6+vjt799Fat1\n", + "Bk7nMgKBEI8/vol77omxZMniT39CLxCr1cqXvrSWl17ahSSVYDCYiMfHqakxsWzZ0o/ewPtIpVII\n", + "wrlP6kajBa83cdayefPm8t3vumlpOU44HKO6ugybzUZNzRwymQwdHU1omh29Pk4iMYHV6mLfvrfp\n", + "7u4kHq/AYnGj0xmRJIGWljYaG6sZHZ1gcPAEJ07sR6fLx2DQE4n04nJV4PONMzaWJZnMw+9PcuzY\n", + "M8yYYcVun3M6ZghMJivxeBJrMoKChovJhm4mwAYkgSR6sriZUboMUdRw1y4nmx1ieHiIa69dOFUf\n", + "J5PJcORIC01NbSiKQmdnJ1VV11FdXY7fn2J4WKC9fQSn0z4VQ5fJxHhn8yYKslnygARwpKuLL8ya\n", + "xYljxxgfGkKUJMpraxF1OlKfojt0ToxcInp6IJOBT1m9+hy+9z34n/8zJ0Y+CEEQ+MINN7Bs5Uq8\n", + "Xi9ms5mWw4d548mnKdKVYjUrdAYC+DMhRElHNptHKjWOKOqJJfyUWiupdOoxSEa8cQNjkVqyBh8e\n", + "D8Ri5fi8bdhUEyEtToU+i2ASQNAgk6a3v4W0uhiz1UQ2cZSh8Q7SShpRquQocVzZIDMJk9TpQDOi\n", + "ynGiJMnLmsmioaBDyYJBTBGMSFj0DjIZGU3OYFJBL5voGYqwsDrM6IgPASt5Zid2s4vsaA/hsERn\n", + "RxcLFs4DJm/G5o9oQ3+lEEmlqHef3ZRr6dI5bNiwF6ezcEp8pNNJJCl0VqaAqqq0tbVx4MAx/KKN\n", + "5nAEVyyGLS+P2iVLKC0vZ//pjr+zZ9fwH4++TUdLF8m4Slazomg6VJ0Hnc7Nli27uXrlPBblWyk0\n", + "ieyIy+hpRMsInFSyFGVj5GfTaJqKotMTT4YJDnhIRMZJRuNEZTf5mo2oZENV8jEKcfJQJlMzcaPh\n", + "xa3LYzQSxBsfodS+nCK9DT1hfOE4dncpvmwFZjEfcypMaqwXq92KqLjpHx+jvqiIZDKJzxcG2cyA\n", + "ZwB/IMLAQBM/+tHfsXr1atxuN0lRJCPLGM4IMhzx+6msr0cQBDZt2onTOQeHY/KYu1xFmM1W3nxz\n", + "N/Pnz7ukzRWXLFlMWVkpra0nicUS1NevZvbs2Z/IhsLCQkQxjiynp27wAH7/CA0N53oLiouLueWW\n", + "yfiK0dFR2tpeAKChYTHV1bPo7j7G/v1pli//EtFolvHxUXp7Q+j1ZaiqQCYzgdWaQpKqGB4e5JVX\n", + "Wjl1youm2YnFMqhqiFhsDIPBjN1ej8+XIZUSMJlqiMdljh3bR2FhjGQS3O4ZmM0uTKY8gnIcAzAG\n", + "lAHq6X8xIIkdndFNvsvNWDpOIpHHyEiGSETHli2dHDrUS3m5kaamk0xMyMyevQiDwUFra4Z4vJWr\n", + "riqmunoGHs9ejMY6ensHKS0tJRYLMTTQzNpKO0vP8JAFBwbY8NJLrKuro9ZmI6tpjLW10a7Tccun\n", + "qJ+SEyOXiK1bJ2uLXOzil7feOtlwr6kJln2OykdomsbAwACBQACdTofD4cBut39ghoDNZsNmsxEI\n", + "BOg8eJBCqwNJdWAUZPIDcWKZJIrkJJkOkkhkyGYBScOkS+AwuPEnEgQSOiymUkYSw9jti8lmQkja\n", + "MDr0hDMGhlI9CIrCYDaCS5MpyWgMZfuIZMIEIhlkWYckOBGEEgz6LIH0ECeVdvRakjFkrFiYIEgc\n", + "C6AjTYYoAayqRlZ1EE2l0TIhyvML8ScESm0FBGNxWo8eBjnDhAYU1JInSSStdgS9hX7PKPPmTz7Z\n", + "HejspMxiYfu2bcxdsICioqLzHqvLwUQwSNG7lUyDQUJG4zmdZufOncvixT0cPXoQo7GQbFZG07z8\n", + "yZ984aw4mNdf38T+/R4cjlr0tiX45DA6R4Ib1izFZDDQNTzM7NMel+rqSib695KKglHfgKJmiYW7\n", + "0Gl+htuzPDfxFESuZ/WSJWzcvBNXwULMEY2ImGQ8EWE0A4eOH8GiVwjry4nFMhhCYxSlEqAWkmCC\n", + "oBBHogqDsYRUeoAYGdzECGMgSBS9miSqBHBbZZJpiTyDRDKZwmW24Q97UVU96WScwjwbemseNrsJ\n", + "/4SPVCJNKp0gFlGQdEYmIieIkSGedBMOW/jOd37FXXft4Yc//DYrbryRptdfZ5bbjd1iYTwYpD+T\n", + "4Z4bbiCVSjE6GqSqasFZx9tksuL1SgSDwUv+XSkpKZnqAfVpMJvN3HzzKl57rQmXayZWq51AYAxV\n", + "HeKGG77yoWNLS0uZO7eUEyeOUVragF5voqenG5erhgULFpFIJHjiia3odNXIsoSqgtFoxWLJZ2Ji\n", + "gljsEOm0hiQtwGh0YbNp1NU10Nl5iIGBfTidV5FKiVitk9csTcuQTlsJhewkk4MMDfVRUFCA3z9K\n", + "CJmZTJYxdzFZ3jwMeJFIYsQgmAgkwqjWciLBFFZrLaLoxWTKY3Q0wNatR7BaaygurqOjYwiTqR+b\n", + "rRaPZxi7fR8NDctYtKiRI0eaSaWyNDcHOXVyL6mRTvqGSshOTNC4YAE2m42KggJSySS+TIY8VUXO\n", + "ZgkBksFwjmckm82iquoFCcmcGLlEvPXWZNDpxUaS4KGHJnvXfF7ESDKZ5KUNGwj19BAaGKDP40Ex\n", + "m5k1bx4Ny5dz2/r1H1hVtaenh2w0SoHTxKA3RJGzgqL8MJFUgNGkF70hjqqO43aLlBQVUWmsRpFl\n", + "RsIJDNYiFEEhEzUwMuIjEw6Sn1eIlEmil40MKRqZ2Dhleh36TIZ8SUIyWjGYJdriWUTRiV6cSVrL\n", + "Ek6GMGolTBBCRw8y+RgoRyZNkBHSCMgo6MU6wnoNUzaAWbWQVCOMJ4IkDaUE4inCiWEGowkUnRFz\n", + "YR0ObyfeyEluWPc1etoPooaCHOnpYf/x4xTn51MWjTK+ezcHNm9m1W23cdXVV3/igLOLybDZTNfA\n", + "AAJgLizk7vvuOyfQVpIkvvKV9axY0U9PTz8mk4HGxlvOStMcGxvj0KEeampWI4oii1ZdzYmDB+kZ\n", + "TXKgrZ2CAhdJp5Nbr7sOgKHBQW5ZOIPH+/YhqyLhkJda0UC+3k1Glgj5IuzcsoXF995LACsmRSKZ\n", + "iZBKRNBUDc3sYiDmw2WSGY4OI0TTlGNAQSKlJTDrsihalIlMgDypDNCTQENAw0QchSCClmQWImLW\n", + "TE/fCdxFC5FTaSqteRgEHZnkEFZ9IRlJwihIOKxWNJ2HTDxMKDCGqjmJZscIphJIhoWgOjEbC1AU\n", + "mQMHArz88ib+y3/5Gg6Xi6ZduzgVCFA+Ywb3rl1Laen/z957Btl13Ve+v33Szalv54zuBhogAGaC\n", + "YASpQFGiKYvWiENpZEkuzYytcZjnmXpTU66penaVP3jKnueSnzXzniXb8liSZYk2FShSFCNIEIBI\n", + "ZBKN1Dnee/vmdPLZ78OFIFJMSqBsWetD172nT9/Tvfep3uv89/qvNYDv+xiG+hqdRhAESOm8bXbg\n", + "b4UgCFhaWmJzc5NYLMbU1NQPde/efPNNZDJpDhw4Srm8wI4dQ9x++wM/lAvqhz70ywwMHOTgwWM0\n", + "m200rcWdd36AeDyOED79/aN4nkuzqaCqLTKZfoRQmJ8/wMhIkkKhhhACTWujKA6WdYTh4UkWFp5j\n", + "c3OVUGgckNTrq7iuSyIxiKp2MTU1gW27zJz6Bl71BbbT2ZpxgZOABSwAaXzAxZQtmr5AVwfQtAi+\n", + "n0cIC9+32Nz00LRxIEkkkiYSSTM//yzr6y+i6z20WqdYXMyxe/cVXHvtbggucObAw1wvBBuKQrJc\n", + "ZrPdplGtcss730mrVmPb6Cjh8XHOVSrous7W665jK5BbX2diYoJ2u80zTzzB2aNHCXyf4a1bufPu\n", + "u990rH9BRt4GeF7Hwv1yZcp85CMdIvLnfw5vYzX1Z4Znn3oKf2GBAcAqFnnP8DC5Vot6sYg5M8Mj\n", + "UvLBj7w67tt1XR5++DGeeuooc8c36Y5CqV5BCI3xLSNoEQ2vsMjkdJxf/dWPcccd+/jTP/3/eO7J\n", + "RZJ6hHRPlpfmS9RqFwirFTZXjiLpRUqPTFjSCmo4QuL5kpgbUJMQEwpCq5IJd6M1m/hKFhl4KLQx\n", + "JCBUhIyhoJPWRon6AkVNoMk4bd9CEsELwjQZw4ts4pt5IuEtZCMqW7t3ML/+LP2KRa8QWL6DVV7C\n", + "9ptMjk0QCoWZuOp2UqkdhNNR9kpJTyLBMyfOc+rCIl67zqPffJjhsVFGJid55733svfWW0kmk687\n", + "5pcbn/zt36ZUKgEdb5Q3ys8RQrBly5Y3NHBaW1sDMpdaJfv7+4m94x2cP/sSc+4Fxq++msFkmoWF\n", + "BbZt24bZbNKdTrN1bJRzczClpekJRXBcB03x6E8kMUt5XjxxAs0IUzdDtKWGYUQJfI+kptO0daaM\n", + "DKZfwhE+VQS2v0G/kiQtdCpuiwIL1P0sYSwCFBp41KjTIxz69DhDepxl30Y4RWq5czgiSa20gaGD\n", + "UMpUAgevLnBKNi/nN3G9VQxRY9Wex2zbtAMLRR0kGc6Sjqfxg4BmrY4cHODo0bPcf3+LnTt3snPn\n", + "a6MAVFXl5puv5MknzzA+fvWlsV9fP8+uXWP/JLqvbNvmS1/6By5cqKIoKaQ0UdWH2bv3SpLJFBMT\n", + "4wy+QgT9g3hlZ9H38L2cmUqlQjKZZGJi4jWeGrquc+ed+7jzzn34vs9//+//E8PonCOlJJnMMjTk\n", + "srFRIZPpolzewHFKOM4Svr8P224BBr6fQ0qbctml0TCJxVRM8wyeJ9A0FVW1iUYTJJMhfD+GaRbI\n", + "rRag7RIiwKKzRZMFhuhYl68DJcA0ApJdQ0SNCcJqCNdt4DhzbN06hu8r6Ho3qrqJlJ1oAM/zKBYF\n", + "sVgay4JodIBIZJoDBw5yww09UMlxTSLBlT09HPA8FNsm7Dj45XInnC8I2LQsxn2f4aEhJkdGyCQS\n", + "nFxaIpZIEAQBD37hCygrK9wy2PFTWltd5e//4i/edI5/QUbeBrzwAmzZAper0jk+Dtu2daov73vf\n", + "5bnGPwVYlsWpkyd58K//miv7+phfXmbbxTTJwUSCtWKRwauv5tTMDJVK5VU+FU888Qwvvphnx473\n", + "UtuMEm238IJVYJ5ifYV60OA//ucP8W/+zQPMzJzhv/23P+L48XNUqxY5mSafW4dGntFIhC4Zxm7l\n", + "KIkNGgqkNQvpVUDV2XAhZ4RISR2p6nSJGr6/hMRE0qDlK8QUBV2N4EiLQEpULYaQ0FRCBEGbFjo+\n", + "ffjE8IWFToFIbAvxvgxePYdlLZIvVhmmynWZHtrtNr7Q8LwGi+0ipSWH5578O8a3jTM1dSMXTh6h\n", + "3w/44hMzlCoa6WCUlrOMrBaZ6moQOn+ema9/nbmZGT72qU/9TNw5v5ec+5PCMAykdF91LJFIMDg8\n", + "xOrqAseOF9E0H89bIRJ5ln37rqENbJ/o4+z8AhFNUHZNGl6AlB6DVos0Og+9eAq7YpKMxbADn3Yg\n", + "iYT6aNstIiJKwRGUmiFU0Y3rrzGERAuK1F2VNILdBJzlu4ToQUNHp4JKmSukQBKwhE3eN3l31xAN\n", + "isx7NUq+S0nC+LZtzJ9ZRMomuuFhe4KIMUU4Wuedd7+b/fv3Yy6fw9B9omEbVVFxPYtsNEy9WiUI\n", + "wnie96bjtm/frVSrdY4fP4CiJAmCFlNTWd7//jd/mn278OyzzzM76zA+3gmwW1w8w4EDyxw+nGfP\n", + "nuT92G0AACAASURBVOsIgiPcdtsO7r77XT9UEGSr1eJv//arrKxYQBxo0du7n49//ENvuNWrqio3\n", + "3XQln/3s1zFNjSCQNBobwDDRqEmrdZ5YTEfTWrRaIep1n2QyTbF4jiDoR4hehKhTLObYvXuC0dEw\n", + "8/MrpNPbqdcr+H6VoaHbEaLJlVdu5dEvfhFLqyEdjzowQSdxtkYnAnMQOI/gtmu2YQlBzpunXD5D\n", + "sbjG9PQ06XSWcjmHaSaJxzXAx/Mc6vUmQSDp7e2l3V4jmcwgZZGJiSm6u6GZmyN98al2x9AQR2dn\n", + "6fJ9/GqVl8+d41yphOG6RDc3aeXzPH7hAtM7d9JKpdi2bRsLCwu0FhfZ8wpDvuGeHlpra286J78g\n", + "I28DvqcXuZz48Ic7NvE/r2Sk2Wzyd5/7HGxs0FUq4VkWM2fOkN6+nVHDQAKNVosTs/OUXYfjx4+z\n", + "uJhneXmDVCrG+fNL7N79fjRN5Zobb+TooUNsboZo5PLsuX6KD//HX+Pd73kPjz/+FF/96kHm5mKM\n", + "jT1ANltgaelxMnqZvliIbCyO6/rIZpmk1QTNI6WnCcdVHK2HkaZCSJWoQoF2kzXLJqoETGZCLDZn\n", + "cYIdOGoXtmeiijZhBWL00QzqCCmpYSFIE2ENBROpxAmEiufWkH439eYSaXcTpxkQkg5zeKQjKYyQ\n", + "DoFgAJf5ZpHc6RfZtus2lpbCPH1gldzicUbjO7FrNfKKR8QvMxnup1K1uWFwkEqtRrRa5cTx49xy\n", + "6z99x9Z8Ps+JI0co5/MMjI5y1XXXkclkmJycJBR66lXJu77vcebMITKZXsbGvu9RUqsVOXToJYa3\n", + "bSPbbIK2wdl6jJDSg+3baDQIWT5Nr0ZghQnaTdasAzScHuKiiygtXHeJpCoou1GCII0SzLIVm0Fi\n", + "CEyissUskhiwEwtJlQgaYUUnCAIqqsIIMOe0GE/2kLNaFNwmG45KLJahX3OZn53DllOM9kzTbBQJ\n", + "C4nrBNR9OH78BbLZaylshPB9n3x5jZCxQTY5RjqeJl+/wNTUrZcyeV4Jz/M69uKtFt3d3Xzwg+/n\n", + "zjvLlMtlEonET0Wz8dPC4cMvMTDQ2YdutWqcOPESvb23Uq+vkUoNkEhs5dlnX2DbtgkmJyff8vMe\n", + "e+wp1td1xsa+r0vK5Rb42te+zSc+8cDr/kwQBCwuruH7EcrlFqbp0Gw2cZz9ZLPXMzCwHdetkcud\n", + "QVV3UCg0MQwPRWmgKD34vo2m2eh6k8nJqxgbS3LXXRkOHXoZx0kyM1NjdfUsmUyaI0deZrNaQLZX\n", + "0IAkYANFOtTJp6MfQY3RExpktrZG73CaHdndHDnisLBgUSqtEI9LcrnD3H33AwwMDHHs2BlKpRrt\n", + "9jk2cyGGsn2kkEjfpKdnBChihMMsLS1Ry+c7lcieHgqtFovtNqlolHdu3Up/LMa548fRgoCE4/D0\n", + "yy/zh//rfxGJRCiVSiRfp3ur+y0qbL8gI28DHn8c/uAPLu81PvShTl6N4/x8eo4cPnCASKnEjslJ\n", + "vFyOUK3GlZkMJ+bn6d69m6fn1zhTj9COhjhX2OCZM5/lttvuZWzsVjY31zl58gCp1CoTE1uQUuJ7\n", + "HtlojHCQYTKd5vyxY0xu3cr+/Sfx/R7icZV6vUKjVKSUs8l6PmGpIM0NcEziioGmm/iBhdmyqdsR\n", + "kA0GYhHWGnXafohQEMOTgpmWzc5EArfHxy5dIGZsoVRpE1VMol6A4UXxWcKlgiEGSMtFetGJqjYR\n", + "0aLqedQrPlY1QOKj4qEKA1Uo6L5CwzaJBzZbkxHyUpK3BTekxthcmGF6+gY02YVj9qLGHLKahi8t\n", + "pGXhJaIIVUdRFMxmk+2pFMvnz/+TJyOzs7M8/Dd/w6CmkY3FWF9a4tShQ9z/7/4d/f39fPSjv8QX\n", + "v/gtisUoQmhIWSEadbjiilf/XalUN8vL81x1zx4W1os4eoim72AoRbqEIKX2st6cIxNYbA8p6Gjk\n", + "nBongwomIYQdIalEqVo2LTeOGThMEBBCIPHQUfER9BJQAjJCJy49dMAMXGoElAKVYTVMUpi0cRG2\n", + "RcSP0a+GaPthLD+B726iBAbF/AK9oSiaFicUjrBcr7C6tMnuq28lbkCrVcf0YnjeJqpiUG+dYfsV\n", + "Bh/60D2vqRaUSiU+//mvUi4LoONKunNnP/ff/4HXWKX/rCGlxHVdVLWzXOXzK0AWTQshRKfdW1FU\n", + "YrFhTpyYeUsy4jgOx49fYHDwllcd7+sbZ3b2APPz8xw9+hIzM/PE4xFuvvkaxsZGOHjwEI8//gKt\n", + "FhQKVUxTQ4gIphkwNFSm2TyP6wboepZMJko+/xS23Y1hjCIlCLFBNpslk9lLrdZEVft573vv4oMf\n", + "/AAnTpzgT/7kc9RqAdFoN6urq2xUVhmghQ/00amMAGwAeTq6kVCki0XHpqz2E6kPk0oZTE6+D0WJ\n", + "s7Z2nqmpPnbvHmZl5RCRyPV0dzsIsYrVbHHD+HX0ZTrVSMtxOHX4KT752+/jW88/SXNzkysNg+5Q\n", + "iEouR83z2HbnnUQTCa6enERVOsnDtWoVoShk6vVLItVkMklbyteMe63VetN5+QUZucyo1ToJu5f7\n", + "/3t/f8dz5Nln4V3vurzX+lng7PHjXH1xn2t61y6OPvcc0WQSt1jkmzNnWTYH2b7t+k48erKXcGQH\n", + "58/nGBvbSk/PID09A5w8eZrR0RFmTp0i6brEsmncVBc3bd/ORqnEQ1/+MtCL53kU1ucx2g0yoQgZ\n", + "qdNurJAIAnqNGJoEU7jkfQtH0Rgf2k3ebOE01ik3Wuiih4QRQpeSth/DkU1qnkEm2kUiqaH6TZLh\n", + "Gm0zQJVRfHwEDjHqWDKgnxQRFboVMAKVrCo57dfpkQmW8UkSRhM2lqoRkmC7JmlFwyTCBcehN7WF\n", + "VCzFRjHPN77xNfx6Cz+IcHYjT69IoEiTSODiC0GrWWVtDcIjI7Qti/jrPEG/Hmq1Gi+fOkWlUKBv\n", + "ZISdu3YRjUYv4x3QQRAEPP7QQ+zOZEhfDCPLJpPENjd55rHHeODjH2dycpL/8l/+PQsLCziOQyqV\n", + "4nOf+3ukfLVlfgeChx9+gmYzy/QV76I+1M38zFHqzQIl0aBX08jIFF2Kw7plEkNhFyEKhAn7Fg2/\n", + "gYFGwW+iECeKgo2GiYOKQEUSBZaBuJTYgMCni46d94YiOO871AKbLXUPjX4UIsSlwHQtTvsenlAQ\n", + "FIh43WgxHU1TsR0Ty26iY3DqyH5iZoXheDfoOkv1Apo4SqZ7nDvedROjo682ipNS8uUvfwPLGmBs\n", + "bPjSsdOnT3LgwEHuvHPfZZ/HHwVCCHbv3srMzDIDAxMEgY8QCq5ro2n+JZ2Toqi47ptvR0FHKyKl\n", + "uJTx9MrrmKbDZz/790Qi2+jpuQnHsfj0p7+C6zrE40McPVqmWNwkk9lBJDKMZdm0Wh5Hjpxk377f\n", + "oKcnS6mU48KFOZLJDKbZQtO66ZCnQWIxg1hMo1xepVg0WF5eJpcr8PDDT6AovQwNhdjYeJFcbgmD\n", + "EjYdErIL0AEViNEhInnA0g3KJKjUfEqVVTY2alx11YcJhaJs2bILz9vkhhveyaOPLlAuzxKJ9NLT\n", + "M8HG7AUa7VXikTCqolJtFhhNtSjlNpjq68O3bVYKBRYbDdwgoBaN8sC/+lecOnAA3/dRO1kHZLq6\n", + "OvqsVuuSyd7k5CRPZzKsbG4y0tOJzag2m6y/xVbhZSUjQog/Ba4Djv1ggq/oUPXjwP8jpfzLy/l7\n", + "/Czx9NNw880QDr/1uT8p7r0XvvnNn08yomoa/kXDq1QqxZ477mB5cRHD9zlXDegamsaORBiZmqD8\n", + "0lG6uoYplxep1WpkMhmuvPJannzy2xw//iJHvnsCXXoEcoP7bh1DEYKh7m5OzMxgG2Hi8QxOeY2R\n", + "7hFAoCstPCQhBYRvdSyrg4C8tGgQodquo5g2JauGFYQp4qJqkr6IThC4BKKLiifoc2ysdp1SrQ9N\n", + "DhIOLBxKeDTRiBAljUIdHRfV3yCE2jETkD5RwghpMIaFQhxdRmlSRioSn4BmJMxSNMqOkRHadZ1i\n", + "s029pVGTHq1CDdfuNAqnEoPE/TCb7SJGZY0d3SobBYeoplFOJvnkxz72lnOxsrLCP/7VX9Ht+yTC\n", + "YU4fP86R/fv515/8JF1dXZf1PiiVSvj1OulX2FMDDHV3s//CBRzHwTAMwuEwge9z8LHHaJdKnHr+\n", + "EBuVpxgZvpbs4BDTO3eh6x1fiEolzfDwNKdOnaG7p5/l2AB1S0HRNuiP9OJVKwSKgiMhQxzvYvWj\n", + "iz5Cap2mrpGw1vBQKdNGI0IFFR+T1MX8kDLQRacq0k3HOXMJwYiqcNZtU5IhHD/McDRCygujS4Fl\n", + "13GECWICN9ikhI6wQsQUl7bbQBMFNHcC3/PQiVCzbUKyQVq36Y0nmNh7B74fpdFovEqEWigUWF9v\n", + "XrJHbzQaeJ5Pb+8UBw+e/CdHRgDe8Y5bmZ39MqurDqFQmEZjjiDw2LNn56VFsF5fY9eut37qi0Qi\n", + "jI52Uy7n6er6/lZUvV6mVssxOLiH/v5xoLOVV60aQDdDQ4O023Po+o3k86eJx6MYRgYpe7Htl8nn\n", + "F+jq6qe3d4R6vcjiYhHD8Gg0HCzrLJqWwnH6aTQCYrEShw9vcPZsDtdVWF5uEYlk8P11qlULv+mQ\n", + "wSagI1qVdDppfDri1QjQQBCWEIvtotHwsCyLcuFZjj7/bXp7+4hnB0ilFZaWltnctLn99vtJJNIs\n", + "Li6xpa+EIpbQ1XkCCTfu6GYgey0HZ2e5YWKCrl27yG9sUGu16MpmkZqGb9vsvOEGnnzoIc6fPcvq\n", + "0hKu55HOZJi65ZZLDyO6rnP/r/0a33rwQQ4sL6MJgYjHee+v/ir/xx/+4RvOy2UjI0KIa4GYlPJ2\n", + "IcT/FEJcL6U88opT7gUKdMb55xZvh17ke7j3Xrjvvk6q70/bz+RnjV179jD72GNceVEUFY/HGRwf\n", + "57qBAcbsMNnsHkKhMEEQcO78STzPQghxybFzaGiSoSGNc+eeo9EukTSiQIpvPL+OaR/k/bfsJRmP\n", + "k8hGOHWySDaq0WxV0LQQjrNGVhUUZUBTumgI8nj0IsgEHiulWRpBQE16eHSRYoiIjLDUblH3l+kz\n", + "ohhWnWY5h+n14mMToGMQQyfAZp3thMmicgGbLjZQ0IkHHkiHlpRItQvhe4CBSQILn3ZQJRAORaDq\n", + "+Uw7KuvrDUrNJuHYJG46hdMywWwxGArQZRNbXqAgQ7RxMJU63Ykhhnt7McNhFHjLdkcpJY8++CDb\n", + "o1G6L1ZRhoCFXI5nHnuMX/nwhy/XLQCApmn4P1ACdhyH9fV11nI5VlZWmJiYYG5uji/+j/8bvdJg\n", + "fW6ObYFL2NqksiGJSYfvzJ9m13Uj3HnnNbzwQgnDCKOqCi+9dAi/tUqvKNBub5KzLDLCYdP2UYWB\n", + "FBG8oI1BGIGO4hvU/RxXI2liUMRAwQQETSQ1YAPBAJIZYJQOv6wDFgElB1pMopJAlQbLlkeIEr1B\n", + "gINAlSGywkBVMlhBnU1zDUfx6YmGGdC7mDUrdIWytK0lNGudRKAwEBXEwxkqhXMMjV6H7/uvGS9F\n", + "0Wm1Whw9eopy2UQIFVV16esrIuXrO9r+uFhdXWX//sMsLXVs5vft2/Mj28xns1l+8zd/lWPHTrCw\n", + "sI4Qw5TLEl332dxcY3b2u/h+na9/3eHChUVuu23vmwqi77nnHXzucw+yttYgkcjSalXwvHX6+7vJ\n", + "Zgcunbe2toSuD+D7Al3X8DyLRsPEddNAnng8ghA2sVgfKyv7SSZVwGdj4zDtdgkpMziOQTg8gG23\n", + "qNePYVlt4vE+stlfZn7+ENnsTnp6JMvLZwiHt+O1N1DswwzgYdNZIJt08mhUOtqRCmCjcU1mFKGp\n", + "OE6eoFpgONlNw7KJeyYbM4/STMHyadCSaSqVGoqiE4/H0SIpIvSx7+otDFzclju3tkbf+Di1YpG2\n", + "aVK3bTLd3Qz197OQzxOJxYjEYjy1fz9b6nVu9H08ITi7vs65o0f50l/8BR/9jd8gFouRzWb52K//\n", + "OuVyGc/zyGazbxnIeDkrIzcC37n4+gngJuCVZOTDwJd5vVSknyM8/jg8+ODbc60rr+y0Ec/MwOt0\n", + "8P2zxp69e1mem+OF2Vm6dB3T86gZBr/88Y9z6tQMR4+uMDS0FUVRmJzcyqlTM0QiCVKpFFJK1tbO\n", + "EQ6Hufvu+/jHB78NLYOuZBeuZ/OtwwepN56i/8rt3HHjlaysPEI+WqTdstgsbqKFXNLxDMPNJmFV\n", + "5Uyrxe16BK9tsoyCEUjSCFqim4jsp0FA1XcQIkmYacrOIo6TYxMFHx2BgWSTJg4BYRKkieBiEhBD\n", + "Q+JjKB5tPJJCUg/AC3wkIaooaEgkNfoQJKRABxbaNhkdRlM9CE3hXHkWixBqy0R6JWJ+kelInGRS\n", + "4eVqHndsgi2jfdz/jmuRUtKTTnPm4mL+ZgtFqVTCLpXo/oHS/2hvL8+dPo3rupfVrTOTyZAdH2c5\n", + "l2O0t5dSqcThwydZKrWxBqf4y798lF27+jl99Ls05oukolliQZiknmRKVrngr2OVm4TNFrW17awu\n", + "JZmZOc3i4jrr6xuI1gwTQkMTKlo0xqZTQQibOgoKITxVkJOQlRFCqk7ed+gXkm402tInjUMbH5MA\n", + "DwMfHQuPHA5bUIgBOoIYkjbgkiVGmBoeURnG9gwco5eyt0IIBYUu1ECgoJMhSkwo6OoKw0oPZjhK\n", + "KqHRKB2lyykwhoLug6KmifguTmEVTbviNeLVvr4+NM3iuecO4ftZuro6LbGVyhKFQpXl5eXXzTL5\n", + "cbC4uMjnPvc1IpEtpFLXUCrVLtnMAzzxxNOsrOTp6+vi+uuvflNztWQyyR133M4dd3RI8fz8PCdO\n", + "zHD06HGEMNi16x6i0QSnTq3z8stf4lOf+sgbEpKhoSF+67c+yosvHmd1Nc/0dBd79nyYb37zCc6c\n", + "OUckEiMeT+N5Hoqi4fs2oVAIwwDHKaAo4Pstms1FhOiE+6lqnGZziaWll3GcDK47QDh8NZ5Xpd0u\n", + "Egr1EInswHWXmJ3dZG3tK0gZp1TKkck4tNsuzWYNzZ0nQ4UkPhadqlovnaoIQBvBIgq+0k/DdzAs\n", + "C8Uv0xuWpJMD1M1jrK29xKRmEDF16q0yipnl8Df/lszgToa3bSPc3U1hfoG2ZREEAaubmxR1nT03\n", + "38yf/97vscMwSIfDzM3OciIUIj01xbt37uTP//iPuam3FwVIaBqapjERCvGdSoXK+fMcO3KE2/Z9\n", + "v7L2o1RKLycZSQPzF1/XgEvLoxDiLuAZOuP7c6tbWViARgN+wEjyskEIeP/7O1s1P29kJBQK8cDH\n", + "P87CwgJrKyvEEwmmt28nHo+TyWQ4f/5LLC29RDLZSzweI5MpkU4HXLhwkMXFCwjRptHwEWKedNcE\n", + "NdmkadoYqkqrHeZbR5a4JbmdF//4H9jcPEd1c40tvVeyfXIPKxurzC/sR/V9ru/vp8f3odWiFvgE\n", + "SMIoCCWMDJJE8AjQKQOB9Gjjo1KmF5sJ+qhjs0IRm2kEDTw28LFwL37txsdEkA8cFBEgpSQMKLJO\n", + "R9YaJkKNrUgiqAhCdAmXiIgy65qE43G8SIJmPsBqLLEr3QOKhhEMs+7kaLR9MulBnFQfw71phi/u\n", + "6f6wEEK8cSnzbSrHvfe++/jq5z9Pfm6OU989iallUMd2snfvPRhGmGPHDnPk6UO8d+te6tUCEUUh\n", + "HIriui7B5hx7rxkiE+tnxnZ45O+eoGB3oRoW+bwgGmj0dsVpVdcIazqOHGC5vYAtXTQ0EsInFRpA\n", + "98ENfGq06EajIiGOQpQwHgHrNGgRkESjSogmghIRwGIUiUJAFZUmGRyySAJWRZUuqWE7PjY2PiFC\n", + "RC+eHcbGxQw86o7Dml9D2AHj268nUZ1jhybQAw+kjtZuc8FsMNabYXyw6zVVDsMwuOaaSR577B/o\n", + "6dmDbTcwzRKqWuCKK27l0UefZKS/i/zKCj2Dg1x3001v6uHxZnj00f0kEtNkMr0Xrx0mEknwyCPP\n", + "AfDccxvE41mWliocPvwlPvGJ9zMxMfFmHwl07sPJyUm6u7s5dmyWG264+ZLAdWBggo0NeO65w9x3\n", + "3y+94Wdks1nuvvv7e9rFYpHZ2QUOHVoimZxAiLOEwy3KZZ/+/nGq1ToTEzsplY7geU10fYggMDDN\n", + "lzAMSTq9k2i0m3Z7FdfNoigGrZbA88JImaDdnkNVRwiCJFKCaQoMw8D3MzSbDTxvjbD3NKkgRzcS\n", + "BXmpKvICCp2NtoACghyjpGPjVEWFO64YISoabEunKZUqFFsO10Q1JrLdXFheYHy0G9frYs1v0htW\n", + "yJ09y9g1V+N4KeY9j5W1Nca2b+dfv+tdPPLgg9y5ezeVhQUCzyMhBOVqlUh3Nz09PSzNzHB1OIwX\n", + "CpF+hQVAVgg8z2NhZuZVZORHweUkAjU6HUnQaY+uvuJ7nwQ+Rqc68ob4/d///Uuv77jjDu64446f\n", + "6i94ufH44x39xut0OV02vPe98Cd/Av/1v75913y7oKoqU1NTTE1Nvep4KpXiP/yHj3Py5EvMza3Q\n", + "1dXFpz71f1Gr1fjMZ77I9PQNDA1t5ZFHvsILL5ymv387k9PT5HLzbK6dpmGukR3YwbHDB8lIg0ar\n", + "TKGRwLLqRCMm6XQ/WmIHs2YFc32dwDQRUuKLzhOuED4ubWzaFBnAJ4mFhodEp0APKlEygMRGo4st\n", + "lDEQF3svbM5iUUaQwRIavfgkpI0rEwRalIrXpIBLHRWLBJOsIAjwFZ06kogQ9AqdZc/CiIyxY2yM\n", + "ldIJLDeEa7XxHIeG10IRKoofIh6NUjM32bPjqktj2LIsmpr2qqjw10O5XOb4hSXmDh5juLeb6ekt\n", + "DA0NsZDLMXXllW9Lhkk2m+WTv/M7PPPMM7xQEExN3UQ2O3BJkBiNZmnYGm3HQjfCNC5u69imQ9OT\n", + "pGMxcs0m5+sB20beQbjeRM2kWFnywE9TMDfYNjTI4lKFwIeMPsGs4mBZkqoT0NJsisKjiYmNT01K\n", + "hlEwCKPREagawAohPIZxCBEmoEGODAnyNPGoUmcQm2EMEggULJkixwUcJAEBCXx0FDzCCDw8JE1c\n", + "fLEbJ8iiyzSLZ1/gCtWh7fvEtSSaqqEYIfo0l3AsRDabpVAocOH8eQAmJicZGBhgbGyUa6/dhW2b\n", + "NJtFJia62bLlLsrlPM997Uvcd/MNbEkkKJ8+zVeOHeOeT3ziR95asW2btbUSo6O7XnU8HI6yudlZ\n", + "eoaGpoFOZ1OjkeWhh77D7/7uv79kWvdWyOfzKErqEhH5/j0yyLlzJ4BOFaXRaKCq6ht66Egp+cpX\n", + "HiaR2M1tt01z+vQCUmbJ50vEYjkGB0e5cGGeUCjNyIjK0tIivt9E03R03cUwBmg0FjAMD9dVkLIP\n", + "2z6HlN/rTGoC4/h+L6qq4vuTCJHD93OEQmUsKw3OOQxiSMawsClRwadIjQRxMixjU8HCQyUkrkGN\n", + "W2y9apCxsX6apSKubaLFHLYNpbh5oBvhOKyvq+wYG+bMUh6tEVBrlAhpEc6cepz/8/d+jVtuuYkg\n", + "CFBVlXK5TH1jg1t378beto1yqQRCcG06zYvFIrZto8dizC8vEzNNYpEIuqJ0th2lJKzrhC+Kyn8c\n", + "XE4ycgj4deCrwDuBv37F97YBX6Oz3SyEEM9JKc//4Ae8koz8c8R3vtOpVLyd2LcPHngAmk34Ce6L\n", + "f3aIRqPcdNON3HTTjZeOPfHEc/T1XUdPT6djYNeua1hZeYa1tQ3ajWWclReI1jdJKx612adxQgrb\n", + "tr6blyyboWgWW9ost9u85+67mdy7l3/8/CqDMYfVjQ2GDAO3VmPOdYlISUUGuJjE0HGJIolj4KOw\n", + "SA8BCdIUKOEzgIKGQRGFBlDFI84iJmklgittAlljhCghJQSE2BSCjFRRsVggShOVCmHUQEdQx8DD\n", + "pUYgNVbWX2J6yxbSEZd8vUjVddimxtAUhzqwaTpstjze/+EPULQsRD6P5XkUgoC7HnjgUsLn6+Hs\n", + "2bN8/vPfZmjre1myDmBvVpldfZHhrcv0X3UVd9911+Wd5FdA13XGxsYYHJq6NL/fQzgcI5TqYslq\n", + "MRFN4hhhqmaThUYZx9B5/ty5jr01CeaYoVSHeLtNWPcJ6gGu8GhcOIu0bUwRwdc1RsNZGlLBcQ0c\n", + "tUVN+iipEerl0+Qw2XKxIjKLSh2dAiECBohd3GxJEaeIziLLxAhTJ4FOCgUbSRQNSYowJgkinCOG\n", + "TwYfOMsmSQIGMFkBBonq00hVYrubaDJABi6+FsPQdOKZNP0Dg6y2apzNV8iXy3zp05+m5+LifsT3\n", + "2X3nnUxfcQXJZIjx8ZtfNXYHH/8CNw/0suWix0gyFiPVaPDkN77B1H/6Tz+SlkTTtNe1mZdSIqXz\n", + "mvMTiQwrKy6VSuWHbi8Oh8MEgf2a45bVIpmMsbq6yte//jgbG3UgYHp6iHvvves1xmbFYpH19Qaj\n", + "o7vp6YGRkWHq9TpBsA3PO8stt+zmD/7gz6hefKQeHNyOoqSoVApYlksQtGi1KihKG99vIETzovbm\n", + "e39rgo5DSKnTjaIaSJkGGsAatn0BDYU4XYTw0Qiw0XGIE8cEwnh0YTMAKASGx+Cwxu///n/m7770\n", + "NebmDtHMr7N3Sw/Dgz20bJtGpUI4mSQTj3PdthDN+SW8UJ7uZJy+niQDA3202+1LBE1KeUkzEQqF\n", + "GLhYDQuCAN/z+Me//3tiqspssciI41Cp10kYBjnLYikcZqTV4t49e36oeXs9XDYyIqU8LoSwhBDP\n", + "AsellEeEEH8mpfwdKeU1AEKIjwPq6xGRf+7wfXjqKfizP3t7rxuPww03wDPPwC+9cYXyXwTOn19m\n", + "cPC2S+8nJ3dx7bUrfOPrX4NckzEJEVWiyAhpvwSexkurR2i6HhGnSH9YI3d+gfktXcQSw/RlBggi\n", + "VZxcjgONBlHfZ0VGaZPGJkSAgskiLaoIugjRRCHAwkAhQEWn0/vSoBsbBQUJ2MRpU0YRvbik4vmI\n", + "zAAAIABJREFUOSlNSkhCgYMfSCL0EBc6NbmMjksNjSYQx6QbBUGEFSxEEEavbrCcn8VylugSJpPJ\n", + "LQivSVRPEBMqllUhe9VePvmpT9Fut1manaUnmeQ9u3a96QIgpeTRR5+lp2cXiUSGvr5RchvzNCqb\n", + "5NUCv/tv/y3xt5n9Dg0NoarN1yx2plnn5pt3YrbTzBdWqUZSrKzMUjQbjBseKT/O7vFxzqzWWZo7\n", + "iaenGRgYpCo8Cp5FsbVJIF0axDBlmIptMiI9Ro04OVnBFxBTNMr1BeJCEMgYZ3EpEwGGMQmQNIER\n", + "ipTpQhLFR7loedbAQCWOJEKaNjY2gjgeCgF1pjCJkSZHmG5sQuRZZZMAlQAD2/eIGSnUIM9QZpxW\n", + "rcZIIgmKj2W3yZULvGy38AYmOfP889x/443oF9uZPd/n0BNPYDoOzc0ZvnPyGFO79zEyMk0+v4Tf\n", + "XOXad73adTWTSOAsL1OtVl/lavxWUFWVW265iieeeK3N/I4dw685v0NSgtdYsr8ZhoeH6e3V2Nxc\n", + "vURKfd+jWLzAPfdcyV/+5T8QDm9jdPTKizqTBT796c9xzz13kEql2LJlC5qmYVkWa2sFzp3bj2U5\n", + "9Pd3Mz09STwe58yZw3zrW4fYuvVmzpwpkc97eF4Zy7qAEGOAjuf5OM4wrZaB78/RkZn2IEQeKXN0\n", + "pKdNoNNxIsQGkUgPuh4jkxmgUDiI18wQx0fBw6TEEJIwKVw8XCQNSkiGEWhoxiLvfvevUC4U2KLa\n", + "3PWRu1nJ5Th28iQzCwuckZJbpqfpKpcJpKRqmniGSrK5yQsvv8jAyAjf+sxn8ONx9r7nPWyZnKRU\n", + "KuEYBvlymb5XaD2WCwWCcJjmmTN8dN8+njYMnnnySezNzY5/TlcXN2/Zgua65NfXmZ6e/qHn75W4\n", + "rHqNH2znlVL+zg+8/5vLef2fJY4cgaEh+DG3Wn8i3HVXpyrzL52MpFIxTLNFLJak2aySzy2iSOhN\n", + "2gyZbbplhMDzaLUrZGSA7qtcKC+yJdqFBih+lF5bcP7Jxzjb8OkWeSKhEFl0MhGV/ZZHiwlahNGQ\n", + "OKQxKePTJEGSND2Y6LgUMPCJESApECaCgoKggUEESY00Pqt+BYs0DiPkUYnio9EmTBhLSsoECMI0\n", + "6WKOAkO4WHiYqBTpRZE2hl3jxMlv0NUVJ9lQSMgQrh7FjScQQrJ7yzYKro2maa+b1/FGsCyLUqnF\n", + "6GhnMQqFIoyN78QeMFlePky73X7byUgsFuOee27loYeeJxIZJhyOUSot0dXl8pu/+Zs88siTfOc7\n", + "a+T8JNGxG4jJIyjlPOVSjYTvU96skZHdlO0Cq4tzqI0mil+nIR2ajKGTxEFHJ6DuOKQ0jyF0THcN\n", + "Q8SwPBsFFRcHExUYJUCjD4sKoGLgEadNhU08mvgodKOi4rOCS4QGEbox0fCwkeiU6SeEj0qn3yZB\n", + "BB0VF1BIIan5BeqOyoCu0p3qZlXpoRXSiYWibFQKzBUr6GM347ZMcjOLXMh0sWPHdoQQKEJQvXCB\n", + "J+bnueuaa1hgkRef/wLz2T7ec+970a/fRfgHgvGCIMCnozX5UXH77bdQLtc4ceJ7NvNtJiYyfOAD\n", + "733NuZuby2zZ0v26brFvBEVR+OhHf4UvfOEfWVpaRwgDaPDOd16JZbn4fu8lvUoQBKyt1Xn55fNs\n", + "bLgXDcie4GMf+yBHjpxgbm6BbHaMZDJNoVAll3uRsbEEBw7sp1RK4DhRWq087fYmUnbTIRclVBVc\n", + "10DKMTqVDh04AyQIgs7jBjjAFBBCCAdV9YE1dF0nGtUIhxUqTXmxhdemC480Bk3AQyGJTh8eedYJ\n", + "1CS9XSEMNeDo00+zb2wMTVXJTE2xY3yc+fV1TpsmJBLkTpzg2MsvU2u1iEjJy+UyAxd1aCtS8o73\n", + "vY+//aM/Ij04yNaeHpx6nQcXFrjliivoTiapmCZmMknY95lIJBBCcOdNNyFrNbxqlcVmk+v27uWK\n", + "yUk0Xee7+/ez56ab3rTC+kb4uRWP/qzxdrb0/iDuuqsTnvcvHbfeeh0PPXQEVYmxcnI/PQisxTmy\n", + "bg3sJhndoeX6hBVB4Emark1EBERtE0tzsR0VRYtiNG2iso7u+XRFE1RdnYX2BgFZIsRQiVBHx0dD\n", + "MgHMYSPp+KWatPHI4WPQAGqYCMKkCaHgYBOjSBcRCjRpEEWwmzZFNFxUdDZYwKVJmyFUJhF4NBhl\n", + "mU001gkTIqVOYnEeQ28QjQTcdeutPPLY87zcLGMoKkmnwp5r9qAY0IhaP7LVt2EYGIZyqQphmk3O\n", + "nXqO+vocrcYKD/6N5J777/+pdWH8sNiz53oGBvp4+ukDPPfc83ieAvTyyCNPsWfPVZw8ucDOnbcx\n", + "PztD9aXv0KcKSsUS+WIeD4kqmoQTPVhBnYa7QVhWUEQvEWOCtuuhSUlVmhhkWTcvMKkFRGjj+hoK\n", + "EXwCemiycpEwRPGIAmUkDg0sokg8mlhIdqBSI4aBYIgWR2njUMYgdNHgO0mTNiFUXCQ6EQQGUVQs\n", + "krQJU8NGwRJtdOHiW2UGkiokB8nZCsueh9s1hKFGaVYXKLYCvv3tF3Ecm6uuuopCoYBdLLJl1y4G\n", + "ursZ6O5m73XX8sLiIvv27eVsV4zZ48fZPvz9ysXcxgajV1zxY2UW6brOhz70y9x5Z/GSzfzAwPdb\n", + "Z5eWXkSIBEHQortbct99P3q0eTab5bd/+5Osra1hmiZ9fX2kUin+9//+CvH49ys5i4tLrKw0yGS2\n", + "k0ymGRu7ilJpg89+9ku023D77b/E0aMn8P1hDCNGLlfh9Omv4nnDSDlFu12k3e5DyhSwRKfZ1sL3\n", + "Azr9Gg2+7wYyefF1m45F2RSKUiEIkoTDKlI2aDaP0W77VCoaqlsgIMsGfWh4pOm0f7epk8TARhBB\n", + "RcMlmbS5adsoseImC4uLqK8IjdQ1jW0jIywtLNA7Nka1UMB1XRYPHsQHMpbFuK4jazU26nW+vLmJ\n", + "EgRsLC0hJyfZPj1N386d5HSdvh07MEwTzXU5fvAgW8fHIR7H930Cx2Egm2W21WJxY4NQNMrU8DAh\n", + "36darf5YUQK/ICOXCY891rFn/1ng6quhXIalJXib14afOizLwjRNkhcD8d4I+Xyew4ePsrpaYHi4\n", + "l717r+OGG65jeXmFL/zZ/8uOaDe6KsnGPRKNCC82GlxoNrG8EKrQiCIoCxMVgRcEqEocPWzgSQtX\n", + "akRlkhZp5lp5ojLCphujiYaGRhONgH4UXFxsQMEjoMxZ4jRRLxINAwOHEElKhKkigCRhUqSp0MbB\n", + "JQU4NGmhUqOfFgY+SaCMzjgAgjohYgT0IokQZgMryKNHoIFCJJ1lbl0QTV9HyvCwnIBNc4XTcy/i\n", + "KTa3ffwjVKvVH8n2W1VVbr31ah5/fIaRkV2cPPQw3a0aXUjGd00zAnztr/6Kj/zWb9HzI3bo/KTo\n", + "6ekhn68yOnoLvb2dG35jY43PfOZvSSa3EY0mWDryNIbvYTdLjAuBisKG9HGkSd7KcUMmy3PFVUKB\n", + "oC2j6MIjYuiYdoMWoFInLOuIoEnIt6gIjxiDNC52N3RjUMQGwrQQpEmSZwOTFDoSSQwNF4NeHGpE\n", + "MJAMo3KWOD59qPQSEAEKmFQAD0GOCgFgoTGODmzQFFW6koJoJGAwYzIWDXG0OM9y2WOt7uCaPsGG\n", + "RiKk8bJbYDAeZfNb+/naoZfx/QDpNtj+inRmRVHoi0RYuPD/s/emQZad9Znn7z3r3febW+VWu0ol\n", + "FdoXEAKhFrLEFtjY4MENAxh3dEe3OzpiImYc/aGZDia6JyY6/KG7HeC2GzzYjWkYjBAGraBdaKtN\n", + "qj2rsirXm3dfz37OOx/ORVAWGCQklRTBE5ERmefeuPnmPSfved7///k/zxned+ed/H/NJj9eXiaj\n", + "KFhSkpid5QMf+tCvdY4qlcrPHbP9zGf+Cc1mi0Ihz86dO1+zAFpRlFeIr2dmqpw9u0mhEF+PS0ur\n", + "5HLT9PtnyGTi66RcnuaFF54lkSizf/9ustkcS0vHOXfuMI3GOs3miERCYzDYJIqSYyKiEOs/KsAs\n", + "cJyYnFxHnB6zQOyT2uanqTImiiLIZnu47gjPG6HrCySTU/i+TegfJY9DwDlMYIRLDoUSFhYqGsTi\n", + "ZfrctP86PnnHjRiaxtEjR+Jxe+DFs2vU230KaY26ElEMQ3bm85zv9aioKuFwSElKKpqGFQQ0XY/G\n", + "8jJXTk+TKxTYbxicOXyY6b17MaKIHz74IJ0jR5jQdZabTf7miSc4cP31jCyLQ6dPE7kuVV1ndmqK\n", + "2osvcurMGTLbt7/mCulvyMgbgF4PjhyBW2+9NL9fUeKqzAMPwOc/f2nW8OvCdV0evv9+Tj3/PJqU\n", + "iFSKd991F++46qpXPHd5eZn//t/vQddnyWTmuO++E/zZn32DPXu2USrluGHvPLuqVVabHQ4vn6DT\n", + "qjOyLCQKk0S4MuIUGkM1S0JYZJDoCFKKSbNnM3AdWkLBk4J2GJFkgINPBKQRBBTQMJGk0WnGpqkM\n", + "CdlEwUEjQ4hGCxWFaVxcKgwpI+gzoseALhZ7SaJh4NGnh80KAoMKGjoRKSJcEgzIEzBkAGQYYdOj\n", + "xpS0SdnQ0XVSoxQThd2kEz7Ly+dQej2ivsGFYZuPvO86dgQBf/Nf/yu/+/nPX7RL/WW49dZ3MRyO\n", + "uO++e3HWjmHmMszOlrjyysvRdJ2p0YhDzz3H+9/ktMYTJ07S6yWYn198+Vi1OsvSUp5a7SDHX3oB\n", + "v7kKzpARko5UGaAxRKUJ1D2NR08ss4CLH0XU6LDhdAlUjUD4aDJihA16wJnQZQ6F7dJgwBoWEp8c\n", + "LQQWm8A8BXIo47OWZYsAgUISkzQSE0EamxGQpIDOZZgEeEg0LGxsfGpozJCggAcE5HFoI5lCYyYr\n", + "+MgHdlJIpzl94gSPHzuB5sCiaSLUkHrUJeMLJqWCgkK9scS6mmOmO0lo6oyEwY8On2OqVMIPQ3RN\n", + "wwsCzGSSVCrFH/zhH7Iy1ojk83nm5+d/5emWV4ufNx33euHaa6/iqadepN3OUypN4boujlMjk/HI\n", + "ZAqEYYCqaphmiiCwACgUJgiCo0hZod9vEAQZej0D33eIh7IKxCRkCxgRVz62AceIaxld4LLx8SSx\n", + "VmQT2EDKPFG0iOc1UJRpVHULyxKEgUuGKTIc4vKxeLU2/hsSgCCiS4MBUEqWSCXy/OCZY1y1a4Zs\n", + "ucy9P36WRj/BoAnCl6yNagzCFTaLGkXbJrAskv0+IylpAH3bQwoNM5QoEWy0OhSrVWzbZk8ux5Gl\n", + "JdYsi8RwyAf27EERgssnJvhvjz3G6Ac/4H3XXkvVdRl2u8ht26hmMkwKwcGVFdxdu35DRt5K+OEP\n", + "Ywv4f9B6fVPx/vfHfiNvVzLy99/5Dv2jR3nn7CyaqrLWaPDl//D/cNm73s2tt97Evn37ME0TKSX3\n", + "3vswudw+8vkKS0vnWF52MIzr2dqqA2WOPPcAz2carJ8bMGxIhmGRFBFZ8owQRIBKgCVLuOYETfcc\n", + "RbtDB4O6G/tESOmQpkkeDw8TmMSmhsUKkiwBKSQdBMuopAlJ4uPQIk2PEVVmCGgjqQAKJ1mmzIAI\n", + "A48We0hjYuPSp4pJBp0+W7iYeDSRCASrZCmSJ0KjTZ8uggvM06OIzkBm2FfJMvA8Ov0tcpkptESC\n", + "tfV10kaCcmWWdx44wGS1SrrZ5JH77uP3P/OZX/mcaJrGhz98N9lskuNKnyt37ryodF/KZKhvbLze\n", + "l8IvxdZWE8P46U4/iiJWVlY5fPgc6+vHmCpvR3c18oFknSzn0AhRxxkyEh0d6ejomQ7VREDNiTjP\n", + "OjLcjmQCQZ2EsoUXOkiZJCRggE4DnRESFZNobP8esUKDDBkgjQPMUyNC4iARKAT4OIT0UWiRwQGy\n", + "KCQJCKmjUGMahQIdsnTpUKXFDjqUBGwqKkZ5J4fPbCC8IUfOrpDpDSlqJTQzQzqKmPPbFJQsiiiS\n", + "0EJwcxhoeAmThW2z2J0OR04NqbUeZHZiJ37gMKDL/zXu7QohWFhYeNNbbq83isUin/vc7/Dd7z7E\n", + "ysoZDOM8zeaAMKzy8MMPoeuwc+cOcjkN8Dh06GlMM8naWpdWqwvMoeshYZglth1bI27FxC6r8e1z\n", + "Hca1szjdJA3UiN0sOsSEZB+wSRi2sO0CUWQRRQ2k1Mavu06SDaYIiTDxyZBH0mDEBVwkKl3M+FFz\n", + "F3PVm2n02vzp3z6NPTiOK9NE4Tzz5SqZTIY9E9M89ux53OY5Fkt5aq4LQUAGeEJK+kHEjGqghBFD\n", + "BdpewJVrG2y6Lo6i0DVNzrZafPbAAZSx6LjvulxVLOKORrSiiGq1ypXz87xYq/Hs2hoTmQw79u2j\n", + "pWmv2cH3N2TkDcD998Odd17aNbz//fBv/k3syPoqxOlvCbRaLVaOHuWW+XmEEJxd3+CB589hu2Ue\n", + "e3iVrS2dqakX+OxnP0EYhtTrI+bnK/h+wIkT5ygWF1FVnXZ7jSuumKDW19lYcZhyfSZJoAgDW6aR\n", + "9PBR2BAZIjmJQMGy1nAweEn6iKGKSZI0AQKTNAkm2SCJx9LY6yPHWeqM8CnG+THkgQlc1vApoLOL\n", + "kBpdOsTjfXk8hkgm6ZJDZ8AUPRYJcRD06SLJoqJSxMNinQQNFFQ2cOnRpE8BiQ70mKHJIhptBLqu\n", + "k07pFBN5TiwdQle3kQxDqrrO3skJOt4Jjh08SPn225kpl3lkaekfdUyVUtJsNgnDkGq1+nKbbHZ2\n", + "ltP5/Cs0BO3hkIlL4LZXrZbwvNWX1/zCC0c4eXKNen1EtXoF7d6QhB8QkMBkG30sBIIFBBoRCi49\n", + "HFZDk1ZooWBSIIuNxMeibE7gRzY5/zTTuEwqBuejEW0y7CZJFpUuCg3SrCEx8BjgjgeuBwTsRGMF\n", + "mzOoFFBokaJNQBuPEBebEjouAW1KaGzHQKBgYGIwQqfOgKp0EVoKzxlw8ngDQ2qkXIvJMEDFJ7Q8\n", + "ZBQwJRXCyMaP0tjukISaoaIEbI3aeKM5hh6s1rt0hha6sYCRnWF6xw3ce+8P2blz52sSqr5VsW3b\n", + "Nv75P/80g8GA733vPr70pQcRYgfpdAXL6vHEE09w4ECGTGaB5eVjbGxs0Gz6GEaV3buv4cUX20i5\n", + "iqLMEoYp4jbMBjHRMIj/p03iSshPUmS648dyxG0cj3HGLkHwzPg5k4ShB5wGPAR1VEwSlEmg4CHQ\n", + "yCHosEWIYJEOgn2ZDAPb5shLJ0kONBJqAV3JYVs+61tb7MxmqXe7pKVPWpiYisJUKsXaYEAxiojl\n", + "6grroUsDCCOV96ZzFFEoaRpeGPLk2hqZqSmMn7lxtIdDJg2DdhCwa98+tk6fZqFUQisUGJZKvOu6\n", + "61BUlR83m6/5XL3NblNvfUgZk5F/9a8u7Tqmp2F2Np7quemmS7uWV4t+v09GURBC4Pk+Pzx0lkJm\n", + "P9WCwVK/z8LCVaysHOepp57hlltuRoiQKAqxrBFS6qiqPk72jPC8EUZ6nrW1s2QUiSc1hjLAIMuA\n", + "AbYwMOUCEoNh6JJgiiEeAosZTHRCXKCApI/JOiaLJChjAzY6KlXquDgozNIlxGCdHCNsygSM0MkQ\n", + "UUfiIsd74AIOKpINYiv5ISYmHtPYjLAZoSCQlGiQJ85M8IAOGUwKZNDG5X5Bgy0gTzEzja6F3PKu\n", + "6zn5oxcolUqUM1mi9TWGUYurthWg32djY4PpmRlUXf+F5fdGo8E3v/n3rK/3URSNVCrit3/7Dvbu\n", + "3cuOHTt4fGaGM+vr7JieRlUU6p0ONeD2669/sy6Tl3H55ft46KGnaTTWECLB0tIG58+fwXFaSLmD\n", + "TCbHyFth5PaYDk1cGuwlT5YkFhZpEpSAF+wG80RItUIqzBIg6OETSYnwkyhk8WkxiFx6KCxgINBw\n", + "iQc2F9BpY9NmDpV4jM5jFZUlVBR0ljGwMXCwSVNkAZURTVpYuIxw8JnDw0RDRccEhuhk6WESCZ8w\n", + "CrFr57CEyj5zmpbjUCGiF1q0hxYOGrqeJAp8FNVHR8P1XZQQtHQaqScYWTYlVSUlA0p0sVRBt5fk\n", + "8D0nWF/f4q67buW2296NaZpv+rl8o2AYBidPrvGhD32c1dUa9XqbiQmTUulqzpw5zCc+cRs7d97C\n", + "0aOP8/jjzxBFWSYnq5w8WSSKXMKwBjSIyYgJzBFXNVziTOYscYWkSqwfGQF7EWKElEOgCNjAJIaR\n", + "wvO2EU/dtFE5ioJHgiImCipgoKCisI5Biwgdi5IQhMMRjzz1d3i2wWXlCS50IzqjCxTkNLnAZHlp\n", + "CUdKqpqGFUQ0bRt0nbyikIkiWsQ1m22onCJigwiMBH0ZsGXbDBIJ9h04QEsIVvp9rhxPxRiaRtvz\n", + "8HSd7du309rYYGBZ+EC5UiGRSHB8ZYX973zna841+g0ZeZ2xtAS+D5dffqlXEldH7r//7UdGCoUC\n", + "wyi2Qq93u/hhGlNPMLBGZPOxWdHExCIvvHCEO+54H1deuZ1jx85SKs0RRXFMdadzHlUJOfzsc7Tr\n", + "dTwELVHCUEEKGyW06OGhyWkUoeIREEiPDB5O7KvKkAlCfBR6TBAi0cb7XociPtvQiUjj0yCizxan\n", + "GDKJwRwaSUx8bEak0XBxkASEXCBDQBaLgIAkHUaENHCYxSU7diJxCDGJpXAlwENhgMIQFUmauCzs\n", + "M2KCDYbsFSG+3yRfWCA/UWb73inEqM4o6FIfvoT0OqzZWYQwWBk+TXXnDNd//Pd+rijY8zy+8pV4\n", + "imBhIc4yGI36fO1rP+Bf/ss8U1NT/O6nPsVD3/8+T7z0EoqUFGZm+O3/5RdngbyRSCaTfPazv8d3\n", + "v/sAP/zhjzh37hiGkSKdPkA2u50oCglDyVDxWWkq6KGHisACQnQiPEChTICGIIoEAQJQyQLrXp8k\n", + "ERYK20mRRgFs8uPRy4hYECuIyKIwIgEkiPCQzAAvMc0KUwhKCM6SRTJNnAXtoOFjEuDj4+PgYI6v\n", + "NIkggcMAgceilCyEEQ0UlAg6bodQCo6LHMgyDjpD2oRBmwlhkjMEfmAjoiYN8uQL03Q6W5RkREMd\n", + "MpUsoHQHbJ58id7E9UzNXk8qNcfjj69Rq32bT3/6E69rYN6lxGAwIIoMcrnYQTWXy6DrGgcPHsc0\n", + "SywtHeHUqTN4nspwWKff76MoRSCLaYLr1omiIlJ2gCni/8rs+EsnrnCYxBM0GrF+JCDeRhT5iYgV\n", + "qhjGBGG4RRgmYPw5kQf6CMpEeCj4gI1PHR3GQYtlvUAlHQAK5/rnWWttMOmMIBzRj8Amie1M4Eno\n", + "CI9p1aPlqXSHQ3KALQSWlMwBqCppCWYUcLSzwWIuSytIMDU5ye0338yZKGLp2WdxazVm02ls3+fZ\n", + "4ZDfvv12kskkB66/nicfeYSz3S7vUhSev3ABc26OW34Nl/TfkJHXGfffH5OAt8L/8J13whe+AP/u\n", + "313qlbw6FItFdlxzDUdfeIG8aYKU2J5LzbI4cM0142fJl2+kd999B+32t1hdfRHD6HLu3IOEbp89\n", + "5VkKmQwH/cdQZRlFZCmmTUb2kJ5sY0ZDRlhEsoGFIElcnnYpkcbCQBCRwcaji0WAJDGemJlGo084\n", + "npDR0YEOgog+KjUEBUY4eJhIHBQGmASUOY+CjiCghE8Rh3PAWQJGRDSI918KMENsVewg8IBZtPHO\n", + "20WSRUEnIE2bNdakhWa7bE8ssKmqfOJ//RTPfOtbXDhzhqLicqYnaXQdEvik1RzZbMh16s8vxy8t\n", + "LdHr6SwsbHv5WDqdo9+f4fnnD/PBD/4W2WyWj37849gf/jBBEFwUUX8pUK1W+dznPomqBiwtOWzb\n", + "di2nTx8ek1OJ5zmoahI7NUQZGoT0UdExlBRO5ODLARCiIXBkF48ZsghAEuLg4lMmIIuCCWQJcXFQ\n", + "SRIhkONAvAAXgwEJ1sdWdwEWGcyxT64CSBIE6PgMmMVCw6BFEoskKkN0+gwpY2OPr7c287ikgL4M\n", + "cFEo4RNFIccxSMp5yoqJFoWEJKgrEjU1ZK7qM+h5LLsRAy2iuXEYLfBIiQE53SBl6YRKQFWfoNvZ\n", + "ZEOeIXXrZUxObuf06adZXV1l/h8EIr4dsLm5yTPPHGRjo8nc3AQ33ngtmqaxtPQi3/72A3S7Q3K5\n", + "KtPTV7C2do5q1ePFF01SqT2sr58nmbyRRuNBlpZ+RCIxj5QCITooyhZhqBGTjyI/kZfGPy8T+460\n", + "iXUjPWAdKRPELR0F8NH1AFWtoKoQRVso2BhSRY6fFRCSJ6CPQocUQ9Lk6VM1Kii6oNeukY0strkj\n", + "+g7oBFQIqYoBunRxpADpEckGfU2J3V6FYBQE2MCsqsapv6FCC40WOdLSpVTI855rrqE+GHCuVuOu\n", + "f/bP8D7wAe79xjc4tLJC/rLL+PznPkf73DleWFlBAZJXX80H3/EOJqpVpmZm2Llz5y9N5v3H8Bsy\n", + "8jrj/vvhD/7gUq8ixi23wNGj0OnAqzBOfEvgrg9/mEdSKY489RQ1e5OeOsEVN930cqrn1tY57rgj\n", + "1idkMhn+6I8+xYULF6jVanzzf36HU89sYup9bHeTA7uSHD3RZeiphK6JofYxpUvdS+EpDpooYUYu\n", + "aelik0FjSAIFlwuETBKh0sTGoMU2BAEhNgA6ET4+GZxxRFps2dzBYJ0sKQy2GKLiUyKgi4/LBBYT\n", + "2CRJ0iPFTnSWGTAkQkGhgqSHpES8645rPWK8z1bp4+JSIEsBwQCbHOvMYGoqD55uYOxcwwkCvvf4\n", + "U5TVOZbaOQL1ZmqySyRGFOUE82GZH/zgMd73vve8wqCo3x8gROoV5ySVytNodC46lryUKu2fg+3b\n", + "F9H159H1DNPTM6yvP0+n02QwCEmpSfZMZ1he3cJyh+Qji1BKhKLTDWEDk4AAkz6WOEdNTqChoeDj\n", + "MCSPTQ6Bhs4UBht0KCEJSBIiGNKnR4IsOhlCkgQkUaiNPTTnMckC6XHmjI2NR0SNCioTqASo2ARs\n", + "4I2nbRy6JOmSJUsLi7T0qSCwULDRcEgRsoEdGbjkECRJp3dQ3Kew7Fqkpy6n6OvIU0eoIgp/AAAg\n", + "AElEQVRJ2k10MWRHwqTjWYS2iWdmUdQshD7VZEi/12VycgIhcrRarbcdGVlaWuKv/urvx5N1sxw8\n", + "2OLHP/4a4HD4cJu1tRyKskC3u8HGxvcolfKsrXlcffW7WV1dwbIStNsOcC1wlCg6QRTZRFGaZPJ2\n", + "HOcIYegTVz0CGGcvwxCVFjoKPklCysApYv3IJDEZWQW2o6oeuZzJqO8jvGVytImADD1GTI2zuxU8\n", + "JAE9kiTRVA/Pq1ORDkL46EgaqECSJjZ7pIONg8OAOSTPATLSqGoafeJG0jyQiCIGSgaUHHYEaaqY\n", + "0ufJzRo3eB4d12Xoeezfvx/DMLjhhhsIw/BlV1zXdVldXUVKydzc3GsyN/tF+A0ZeR1h2/DYY/DV\n", + "r17qlcRIJuPx4gcfhN/7vUu9mlcHXde54667eM/tt/P+kyf51rceJgg6nD3bwXWb7N9f5aabfpqD\n", + "oCgK27dvJ5fLkYgcKv46yqDNO/bv5537b0H6p1lbb9IN+wSRJDDyJDKTTBV2Mah1wNEYyToOK2RI\n", + "EJLDIEKhDggs1giw6FDCRWCikSSBi4VGGg9BgMIkaQQ6kgGCAT4ONhXWUZBcT0ALD4cTrDFNkwlM\n", + "EgQkUDiPRglBTs1QC/tsjUPDJQoBKgqSHkMsUkCNOjUEgiwFCoaHmoqYiuDCw0+hbitS6dnUWGfk\n", + "TZBLlJFKhoF3gl4n4nwkabeX+Iu/+Bqf//ynLtIHVKsVoujgK87JYNDkuuteaeP9VsLu3bvZv7/E\n", + "+voKup5F0yICXyGp+uyfKrNtcorFyjzPHf0m7qiPEaXwjSLdTJXAapPzV9kpXCazNs8OTnFGaoRo\n", + "+CyyRp0CEgOfBhKLJB7DsbmZiU2WAAMdBQUDicGAEJcOi0gkAhuNMjarNAlwaCDQqRKhAAo5EkRk\n", + "iGiTpoQ/DkfssU6OJC4mppBkpUIThzxQJgN0sHDpUGHomvRtyd0f/DzT0/v50d99iaKWoVKa4sLo\n", + "Aomoz6wS4pkdhq5DE4e5Hdeye26eVq3G7j17APtNd9T9dSGl5J57HqJQ2E82G+++MpkCx441eOyx\n", + "5wiCOTQtJIpUdH0nnucyGq1jGDqbm6vU6x06HY0w1MjntzMceui6SxCcRIgpgkAd58xIYhFrirhd\n", + "s0meLZL4jJhEpYCPgkeaeAR4CchhGDOoqo9p9ogiCL1TzLDGLAFVoEPIiHUGmFgo6IQY5FASSTJJ\n", + "E3sgSCqCTpQgIQRJqZEkQw+XIzQpE1ISgrKUJIE9iQTVTIYFXWd6MODQcMiFIESPElgoSIrMqQah\n", + "MDkblfnbo0d5/223sf/d735ZxCyEuMie3zTNN2wU+zdk5HXEww/D1VfDq/CSesNx993w/e+//cjI\n", + "T2AYBgcOHCCZTPJXX/5zBhtblPJpgm7I1tbWReOH7Xab//If/yPHHnmEymCAoao8urLC1J49LMyW\n", + "qTfT6LZHJWmyNtwkIo2hp5gtjahv1FEBFZcseVpoDEmhEhACDjNEJBiwQZoyBgMqDIkQOKj0cEiT\n", + "J4WKgYlFir14PEtERIYUE7gUkHTQyQMShxE5AuxxYHwOhTMETIcjNFS2ABdJcaxHGKFQR0ejgkkC\n", + "lwEBK2SIqJLCtx2qjkqn5eIqHnvNDAXPpcM6ZlphaG8hxB5UNUsqNYFhGKyswBNPPM3tt7/35fdx\n", + "+/btLC6mWVk5zvT0LlRVo9FYxTTbXHPNBxmNRrz44jHW1mpMTJQ4cOCKVwSPvdH4ReODMzMz3HHH\n", + "Nfz4x2u0Wj4vHjxB6Bl49oDltR6DgUMlP8nsxPV0OsdYdbdRnruVkpknu3wP+AU26dIfjYhkSIUQ\n", + "E4FDmwidZQJ04rygPLHTap0cLhlMRqRYIcDBYxYPB0GLMh4hCkM8kjAe8F0hAThMkcXFQ8MnQaxe\n", + "qmACeSaQjNggQZ0BZVQEAlvqRHSxkFRRMYlJQxGBUEPCTJr2yimWlo6TSFTJhQGVShktjCgGec5Y\n", + "LRZ1FdXU0BMqZq7E3oU9eEGEmUxRr1+gUhFs/xlnz7cDut0unY73cmTBT+A4AZ0OeF5EJjONoihI\n", + "CWF4BYoCiUQHyzpPq+UTBFOoagLb9omiNsNhBSkjFCWBEJuoqoIQPmF4nthfpI3OMlVy1DBQ2I1B\n", + "dhwiMCJAJxa9KoRhklRK0u0cJ3KWKFJnhlgKqxOrT1zgGHHwX5oEkT6FktjGQB2io9H1AhgHa06h\n", + "YxCrTiwSdBihR9HLcz65KKIgBMlUCsW2ef/0NF9ebVAUVSqkURRBJCW+qpJSM0hrgxeOHeO63//9\n", + "N+eE/QP8hoy8jrjnHvjIRy71Ki7GXXfBv//3EEWxGdrbEbZtc/83v8lN5RLTe+IY81a/z3e+8hU+\n", + "9a//9cvhXU8++ijrBw+yL5fjeK1GRVEwheDoCy/gpbLUai3SWoKu7ZMOIyrmkPpKF0MpUVA0EBIR\n", + "pnBZJmAnkgl8Qlw2kGxHYRqBw4g+4XhAF8BBJaLAZWSI/QckKj6xiiLCQyOBiYNNiIKDQxoFF501\n", + "2mNlQnwzGSA5S4RGgQiNHn1cPFIIlsmSY5KdePSwGBAwIkuWLUZenrziI6RKRsBmd8iEmmLGSFN1\n", + "ezStZ/CjCSQZzKSJZW1yxRXbmJ+/nKeffv4iMqIoCv/0n/4uP/rR4zz77I8JgpDLL9/OHXd8giAI\n", + "+NKX/pp+P006Xebo0Qs88shBPvOZj77CAfONwNmzZ3nwwSdZXa1RqRS47bYbecc7DlxETO6++w76\n", + "vb/lT7/4X/AsgapcQTa1Hx2XjfYSw6GHH3Tj+DEp6G2dxBcOc26DoplBkSpppU4tdNhNih4RHbq4\n", + "eFj44/jDTRQMbMpEVNBIkGMDDZ0kDkUuECLQEQzJsYbCBCYGLn08pjDo4dPGpUNIEkHIgAYmEUUE\n", + "HRwkIQEqaSBDmxZpfEYoNNDZNjZWAw+JQShsksJhxT5DSkty9OiT7N59PYoWm8uvex2WnB5mcobD\n", + "/oAcEe/bt48rr7+BRw6fZLnlsmvblUxMpPjYxz72qgLr3gqIR9Qjoii6aErMNHWCwCGKJMNhHUXR\n", + "iTVnbTIZldGoy3C4hOdFRJFGFDVwnAtABNhI2UfKc0CRKBoSRVlihcc2oEKSLXxsIqYxSAEaYqwS\n", + "CsgS60nKhGGHbtdDY4VZWghiC7UesdIkIq6zFInlrw45BqENYYZWLkOjeQYNFw0dkxJ1PCI8bGL3\n", + "kwFwFbGU1heCpu+Tsyy2ul1soTJwfbJ6hEqbVjjAjTIYpJnVNHS67EgY5HSdY08+yU033fSm68De\n", + "XlfbWxhhGJuM/cmfXOqVXIwdO2K9yKFDcO21l3o1rw2nTp0ibVlM/0z/upzLUen3OXr4MO+57TYA\n", + "jjzzDLrn0W+3ualcxur3kZ5Hc2BxvjfinbkdjCKbvD/EUByGkU3WD1kVfUZyioJqIqI+WdmmRQIT\n", + "E4lKWinQiSCijU+fPEly7GLAJh08QuYp4uGMC/ouPeYZMBgbYqmM6NPHxUaQpk0ADJC4TALbiXdG\n", + "NiEuCm0m8NmJDrQIEBwng4fPBLMk6TGijYZHkYCALUaUMfCRRFJFkUO6PRvF9EmIJBoauuwy8BUU\n", + "zUBV06TMLjmzwObmMvEH7sWVhmQyyd13v5/f+q1/gpQ/FQv/9V9/E8+bYmFhcfzMGXq9Jt/+9v38\n", + "8R9/7g2dvjh9+jRf+cr3KRT2Mj9/OaNRj69//XFGI4t3vetmICau3/jqV9l47jkuk3BZqcCh+imc\n", + "ZILhyIBghk54AUMbkPRtNENhoZzi7GYDx/cIjTRW5NLxAypoqKh08JkmokAwNklTaKOhotClzynW\n", + "6JHAIo3BNA2G9GkzjY6NoE6ZHlOEbFJAwcFDw6OCRGdAB4eQNF0koBHRQqCPJdRFoMUMXbYD6XGI\n", + "3nk8VonYI3QM6eOJEaHioSlZpjIHGDoBrVaHe+75S3TfY7hxFtfWKRk5ClRoMsGK26aumwyjkF0H\n", + "tvPhm2/mxptuelUxAW8lZDIZ9u2b5cyZc8zM7GIw6HD+/GlOnTqIpm3R6+XQtO1IaSCljWUt4/s1\n", + "THMb5fLldLuncJxDRFEVRdk7DrlbBbJIaRIEk8A8qtomDH8iYi0RYhAyROATUwqQ2Hj0iTcn+fFX\n", + "AMwRITFosMhPnUhM4mi9gNhabQSMRJW0gLS6ytAR2Noilu+QJE+ODjDiFC4hPhKPaWI3kxzQ1zSW\n", + "whBnaKGrKj1Npeu67DVThM4IgzxdpU8PwZLvM1d2WFxYYM8NN+CHIcdefJGb3vnON+nMxXhDyYgQ\n", + "4k+JlUAHfzbBVwjxvwN3EdvT/Z9Syu+/ket4M/DMMzAxEd/832r4Savm7UpGuq0W6Z+zS8snk3Tq\n", + "9Zd/NlIpthoNbkgkKJkmYTrNS6vruKgsSA/LH5BCMmfmGHkRI6/LlD6BqUYcsRs0A5eE6OOINIlo\n", + "FNu9izKaomFLG0fagIKLwhYbuFSAnZisM6RDnYAkfaq0SRGyBej4QIMhOSJ2oKEhsOjRoMSQWUyy\n", + "hJiEGChUUVjDp06fkAANhRQZDNpjIaVDmxRJZhGoRLhxqixdgsinwIgkGYLQphcInJRLUs+gJjTy\n", + "aZd8TlAMz3L11DSFzgarZw+S21PFcZyfK0ZVFAXf9xFCEAQBp06tsG3bxTkH+XyFlZVTtNvtN/RG\n", + "9sADT1AuX04uF/+OTKaAYVzNgw8+w3XXXYNpmhx84QXE+jqLhQJntSyldJlux2bJfomBvBw/CpGi\n", + "zjQ+s5lJmlrA+vp5rMCgL0sY7pCiAFumKY2bMxKoIEkQE60aCg4q54EcKiY9II1CdkxfZqkzRYdl\n", + "JDMoLOBzgXXmadFAZ0CRiBIhJSIUzjIgT4oEfVYRJBEcwCBJSJcM60wSkMUkBfgI5tDYwqYnQ3IM\n", + "MRUfoUzS1jVcx6XjBSzuvJ1crkF9YwnXstil5EmGNv3BBUI9TWXqMsLKNt71yU8yPz//moLw3koY\n", + "DodMTpZ49NHv8dJLj7KxMUBVJ5mc3Em16tBqHSYMW6hqhiBojUlFhlSqihB5pqZ2U6upBEGaIGgR\n", + "T8tUiElHnbh+kUfXsyiKQRSdJgz3YLFIlg6CDUIyqBi4jAhIEtcrZoEd4+8bQIICgjQyTgcfr78K\n", + "nCPemDQwiGQeJdzE7dtE5hxCpMmIJo5UsMaZVIso48kwnwHgopNEJ/RDmobGXKFK03MYCIXFfJlU\n", + "MkPK7dIb2TD0aEZdFnQdkwRbQcBts7O0hkO6v4Z52WvFG0ZGhBDXAGkp5a1CiD8TQlwnpXx+/PB/\n", + "klL+30KINHA/8LYnI2/FFs1PcPfdcWjfpQru+3UxMT3NGd9/xfG2ZbHnZ1oD77nzTu79i7/AHH+o\n", + "bg2HDPp9NBlSUTTaThdThrT9LKEEU/o0vBqBmkaROko0ixB5PLlJngERL2DLPKOgjIYgJSwqImAQ\n", + "tehTHY/XDggpYiAZcBwTC5eQIwgsJCMS2GwnztzcREFg4JAcm5mpKOOUG4GNQEVDH1uEC3K4DNmi\n", + "yR4MNLqsU0RnGwIFlWBsxSZwyBARcgIfkz4OClGksiubYzJpUJkv85FPfIJvfPlrXFteJJfO4zgD\n", + "dldMKvk0zzz9NO993/suen/X1ta4775HOX9+E13XuPHG/eOEUvlzztJrs4D+VeF5HrVah/n5d1x0\n", + "3DAShKFJvV5ndnaWU4cOsVip4Ns2nVGHkRWiEJCNRnRYwTSmIDlHVfOYKORIjtoc6pxhJGfQlQzr\n", + "MqKLhouNRUiISwYYECIRY5niFCYZJDYtigzZGPvlCjQkESMiknhUUEkQcAaBYJI+JVR6mGSxUTAx\n", + "SLAHwZAOF3AZkCTERXKeEWkCukzRIkeSAA0Ln5A4lj6NwhpNtikgQ51e1MbxVUy6JM0cBjWiKE3Y\n", + "OMduvUJez5BWJAnPwxAe9W6D48+3+fFjj7HzVcQCvBVRq9X4y7/8Jo6TZ27uVk6evA9QufXWG5id\n", + "XeTee2Fi4gaWlu4liiwajQGuayDEIu22x9bWsySTBlGkoigm0CJWcATEQtUhcRNliKbNMD19M5ub\n", + "TxCGzyHRaTDEICBkmZAWHiHxXjsApol9garAS6hs4mBgj32FWsQaD5u4PaMS35g9TpNAI4gEoR3g\n", + "0yVDSJo2eVpMoJGiRZGAInAMA58iOUwMBWrRCMdIU5rZRckZsk1GWL7HRLHK4rRg69w5DMtlXzbD\n", + "CSlJ6jrnt7YIVJWrZt98ofo/SkaEEPuAjxA3xyCuIH1XSnniV3jtG4EHxt8/BNwMPA8gpQzGx1PE\n", + "s09ve3znO/A//selXsXPx7vfDcePQ7MJl8CT6tfG7t27eWpyktNra+yYnkYRgpV6nUEmw45du9jY\n", + "2CCfz3PDDTdw+a238txjj7FgmpzfrJH0QqQUdAERRbgIpKIgZZJu4BKpJqX0BBmviulO0g86KFjM\n", + "IElg41FniyZJM0Fo6uRDnaMjiUafLB4JTFxGeDjAAZq0CdgiSZpNuoTMkGYHOhF6LD9EZQODNCYj\n", + "HAI0JB4Cl2jcpdZJMT2e28gzwOEMpymg0aeDRp8ELjouBj5DTEIcVPrMoONTxmBENxAca7hct+8A\n", + "gZXl0KHT3PqOXUzrCYbDAfPzBRYWDhACJw4evIiMbG1t8ed//i2SyV3Mze3F910ee+wUo1GbWm2Z\n", + "mZmfKupbrU1mZvKUSqU37BrQdZ1UysBxLBKJn44db2yc49lnn8S2O1QqOdz2GrPVCsvLK0g1S7uf\n", + "IGmUwGtiBz6KukI5PY3vnWc0KtHuNkEWqSg78dUMivQZhjVsmSTPCrOE2HgYRNRRsciQI49DhCSL\n", + "TXU8E5MnJMNoPPKp0Blb19WJSFNCJYVOD4mLoI06VhiFgIKDjiQiwCeiSJIsYJFBG+eVOOgIIkIk\n", + "ESEGAp0eCn3KSHVANRTMq3l0LYOiZAnOv8R5w2IRhbShEqKCDBCRiumpWGGXcJDi0EOPsPvyy7nl\n", + "3e9+w87f6wkpJRsbGwwGA8rlMtVqlXvueQAhFpmbm8FxHDKZHeh6mrW1JRYWdpJOJ4EyO3ZcS612\n", + "niC4lcGgxmgU4vspXNfEdXtomkUQ+MRTMBXidN4ssJu4ZdPAcWxWVjYJwwHxwOw2QgJsNGLFRuwY\n", + "ErsE2cStmwRxTU1QYAdDAmx6hLjkkbjEtRdnbAXvIZkCdqGxjsRDxUWhR0AOl1kiVAIq48F/F5UJ\n", + "TGqEeEBG0SE0OdQe8dFdZVptn8ixCMIAhEZgO+xcXOT86iqpXI6qaXJFtcoTzz/PVXfeyb5L4Nr5\n", + "C8nIuJXy+8DfAs+MD88BXxdCfENK+R9+yWsXiKtOEGt0LgqtEEL8GfBR4C3iyvHacfIkWBa87Mf1\n", + "FoNpwm23xR4on/zkpV7Nq4eu63z8M5/h0Yce4slDh5BRxPzevUxoGn/zn/8zSSGwpeTym27iT774\n", + "Rb78xS/SPHoUZ71BOlNE9T1qvsMOJctW2EfxBxjCwFF07CjH2tAmFAWGREgEJlO08CiTJIHGoiI4\n", + "j09VRiRKkyTtGtXIpMcIjTIhAaCjkAHqJChikUOyjYARDi4eQ3RyaJTx6SLpEaBxHpcpTFJoWHis\n", + "oNBhigIKggCJi02RLnNIEqh0iN1QPDQMDNL4GHRYpYpKwDQKQxK4TFFiLdjEGUjSxSl0fYHVpWP8\n", + "1kc/eFEVY2BZiH+gbn7iiWfRtDnK5TjV1zASLCwc4PTpJkKscOHCAMMo4PtD0ukRv/M7H3tDr4Ew\n", + "DFlYqPCD7/0d89uvZmZmB83mJg88cD+7dl3Lnj23YttDjlw4xZEH/ieDlQ6KMgdqQNft0dEgl6ng\n", + "++fZs+caLpxwKYYetlAxtCQIBYmCo9mM/AxFuuSZxlA7OBE0ZYABSHQsQtbw6XMZISYRSUDikRy3\n", + "aQQRCpKTSAxi2zp1XCGzAY01aiQYoqCQIU2EQgcdcBGMCBlSIUeGAIsJzrLCTjwqRHRQuICgTYoc\n", + "RcJohogLTJBCRDlkJDGTWXAsVK9BtjSFNhhgez1GgUFCSzMMbDxsbthxK832gIe/9723BRkZDod8\n", + "/et/x/nzPRQlTRT12b27yoULDRYX41uMoigIEZFOT9BoXMB1bfbt28Ezz5zAslr0eqAoZaKoDqwg\n", + "5Q3ouo7vtwmCDnHlL0vcWomIw/AsYkKxAyGmCYI8se17GiF2IeUqsS5kknjP7RBXQgbENEMDhhhI\n", + "kqRwUXERNNERY1eZ3rgpu0EaSTg2DPCoINhkQIkKHgoO8ZRdHoss8ayOREWgoqOiCJVuYMdtPtfh\n", + "2PMPY6Wy1GRERVdZ1JNIF845Dvsvu4zOYIDUNGq2jcxm+dinP/26+of8qvjHKiN/CFwupbyoPi6E\n", + "+E/AceCXkZEesZYG4rN0UQVESvkvhBD/B/AgcRXlFfjCF77w8vfvfe97ee+vYTX7RuI734EPf/it\n", + "4br6i3D33fCDH7w9yQhANpvlgx/9KMGHPoSUkicefZSlhx/mnfPzaKpKEIYcfeIJdF3nj/7tv+V/\n", + "+xd/zDl9FS+dISFNiv0+qwE4gcF5LMqJJKEfUg8V3CAXm18Jg6IwkFKOiYWHADIiRxjYbERdFsI8\n", + "SblBAYFkRI9VfAxCfATnyRDRJU9AEZUWJdYoYREg6LOOyw4ieuOE3oAmaYZoY+GrRp0CKvMYBOM6\n", + "SoCBSUAWSYBGFp0hQ1JUyCIwCNkgRZMUBWALgYJGDh2LamBTXz3IqLfFgZtu4KwdUWs0mB6bxwGc\n", + "q9fZf9ddF73f589vUCjsu+iYEIJkcoKPfOQqVFVlc7NBubyDffsuI5V6pUna64XRaMQ3vvpVvLU1\n", + "9il1Tj/2/3LMyNCLVLZvv5kbb4zFq6qqMbQSHFp3KZBm2szg+i4NQ2V2+w3s2bvI8vIPqdefYhAK\n", + "lmQHMyEJFQM7aKGRJfKHaCJLXkpMIvJagaxS5Kxdw2b0/7P35kGSnnV+5+d57zfvzMq676o+pL50\n", + "ttQ6QAeCHTAQnB4OQQThMWu8G/ba4/GuZyYmdh2x4Ql717Ez/9hjMzMxnpXHgBkhBhAgECAJoW66\n", + "1a0+q++6q7Iq7+u932f/yJRAEgiN2FG3IvSNyKjoNysr336fqnx+7+/3PWjTpk2eNjtRGCZmG0EB\n", + "SYUYDYUsAh+V3sxd9GmNkhwKG6RxSCJpk+AyXUw0DDQ0DNrYqDSIGMdhm3Y/lyamtxWuElF7afwX\n", + "9AeEOToEfb2WgRBV4tCn22limDp5I4tjGdihhk2Zrg9e1GYt7jA6eRvTIzNUmhWuLq79na3f/594\n", + "9NFvsbqqMz3dW3MpJadOHWZzc4Xp6d6o0DAMxseLrK3110AIJibG2di4wupqkyDo4HmXSCYtOh2N\n", + "IDiGlCawARQRoo6Uo/TcVTV6FPOf0hvTuKhhGYHWp4yWkHKdXgHTGw8Likgc4Hy/vFBoc54YD7Vv\n", + "d2ci0MlSImCFBgAKOapohKQZYIMh9L6PjY7FGg4BCgpdYio0KOAS9s+wQkiLEB2binRw0TBJEsZ1\n", + "pv0Ol9s1Vm0bbWiI729uEAUBe6emsJNJCtPTfOj223E8j6JhMDg4+GYt58vwWsVIRG88s/iK42P9\n", + "534VfgL8j8BXgHcBf/7iE0IIU0rp0Ssff6ng9OeLkesZjz3Wk89ez3jve+F3f/etmeL789A0Dd/3\n", + "OfHMMxyamEDrqzw0VWXfxATPPfss995/PwcO3cuF46tETRdbxKSlgibSLCmQS88zPzDOyvoitnQY\n", + "kBpXpYslc3SJsKiRQaDjE6JTixxcDJqRQqrTRchekFWOLgYxNRo0cMmyE4McbSIEghybDCFQsZGo\n", + "ZIhZ4wwBXcYJWUYlZKrv6OrTRSHGQ9IgRqKTJCZEo4WGSRbooKNioLBOQBMLnUEk65jESDRUNMCm\n", + "iYaDgcqwPUgzdPjWt77J/n27OFmvU3NdbF2n4vuk5uc5eMcdL7vOQ0N5VlebWNbLSY1SdikUCkxN\n", + "TbF//5uz5j/6/vcxNze5aXYWZme533W5vLLCl4+d453vvO+lLs/GxiKOY6Eld9BVFFb1KVTNRsQW\n", + "mewQGxvr7NoxRtzc4Lzikk7tJ9RVKs02nUbA9ubl3phE0wiDJgkh8f2IpowoIGkhqWLiM4nBCAoq\n", + "Pl2gjcIeBKsobBGjYWOjUMRgkzIFQlqM4pAnjyQiR4xNiqsYGOzEoonHOmn20MbGpojKcWzWmKTL\n", + "eH97W0PiIMkBTVTGUVgmwENHETZCJjH1JrEaoCoKgSEJLRUlZVOUkyxc3KIZS9rGOKPqCCfPX0Ax\n", + "4IZd17eZHUCj0WBhYZ2pqXtfOiaEYHb2Zi5dOsrW1irDwz0O2b59N7K+/jhCNNjcvIqUbQ4cSPP7\n", + "v/9v+cIX/ncWFlJ0u116XKcxoIqUg4CGlOPQLyF7dNIX03lVEoqFqliEYe+mIKBLr3My2f/aS6IS\n", + "GMAyBTy0/s1GmzSCIUJCJII0BkkSCCLqJIBhyjQYo8UQGvm+saIk5AIeeTbo0mSKmClUyggEst+P\n", + "jdlCQ8NEx6aIxRZtxkWblKpwi2HyE1R2Tt2CKjwWWiWM6Wn27t3LjrExmt0uC7Ua7/7MZ96s5XwV\n", + "Xmtb+l+A7wkhLtEblkHviu8E/udf9YOllMeFEK4Q4inguJTyqBDij6WU/wT4f4QQN9BTNP27X++/\n", + "cG2xsdEb09x337U+k9fG5CTMzPQcYl/BU3zLodvtUtnY4NilS/iOQ2FkhNn5eVKpFFoU4TgOUrpU\n", + "2yGamiGNhyIMFoNNanGOu7NjSDdA1zUKwSqWmkONJT4+XbaxqSDQ+u6XPYGeSRYbWG0sYaDQxcMm\n", + "T0zMABp1gr4jqoWPjsY6Y7goBEjKCCJMGhTosobgDCoeBnq/dNDwSLDNNAEep6mh0SBHSIzFNBIf\n", + "gzQmMSXagCSDQYRkhZgWI2TpkKOFTYcBTAJCGqqBCDsMJYs0mhsEocU//v1/w4njx7ly8SKjIyPc\n", + "ddddr0poveee2/nP//lvSCYzWFYSKSWbm1cYH7ffFD+RFxHHMQvHjnHP2NhLx5ui6Q8AACAASURB\n", + "VCzLYs+OHaSPnqRcXmNwsLeRbmyssLFxmUajSjo9juNsoetThG6VS84WinaRfYNF9s7NsrzwY+Jq\n", + "k07gE1tpiiNjtGs+UilT76zQoMuadEkjGUAjIqRNREQXwXliygSEqHSQCKCDykCfWBwRcrXfiJdI\n", + "mmjYaOiE+PS8ZzwUYgwCmrRx2CDDIAomAZIECjFFAkrY/Xfo0hsavEjhLeNQJWQAwSKSddoMSR1b\n", + "WJi6QU2vcOuD92JpOtWVMhdrVS4KMLVJbh6bI2OY1NttLnklPn//B960NX2jcF0XRTHwPI9qtYai\n", + "CAYGiui6ydzcDIqyzPJyHdPM4Lp13vGOMd71rg8hhCCbzTI7O4uqqvyjf/Rx/tk/+2OaTZ84TiLE\n", + "IBChKDFxbCHlIvSj6ngpNaYDqMTYmEqxP9C1UWgSU+RFsqrCRWK2UWlgESLJEBGRRUeyhYJAkABs\n", + "LlJBIcJEYmLhExLQJUeIjUUdBwhJEGMSUn6pxwZNElRIs0qIShdJ0D8XhTZduvjMC4/5OIBARVc0\n", + "9Chkq1Hh3n134119ntEDB6gYBhsrK6SKRd798MPsuYYJr7+0GJFSflsIsRu4g16HRNIr/Y7+HAH1\n", + "NfHzct7+v/9J/+sX3vAZX2f4m7/pdR2MX5w5dl3hIx+BRx996xcjx44c4eq5c0zmchQTCRrLyxxZ\n", + "XWXfnXcibBvbtrl4bpVsRkf6Jl0ljxd1kSLA6q7T8hTc0GdMaZDTQ9b9daCOwQg2kjLQwUPFIKLQ\n", + "b8dvMYtPjMMyBa5Qw6bniujSpomFwhCCAUBBcg6FEEiTokmCDpKICB35UlM9oE3ABjEWJXbSU34Y\n", + "JMihsEyXMjoxWyTJ9JUaEmjjE3IJmxgVlV1IMqxzii4rxHQQwiNQDaaUFFHQoOUpaGnJ+Pgw5XKZ\n", + "F55+mpTnUV1a4pHDh7n5wQe578EHX+oyzM3N8ff//n1885tPsb2tI6XHjh0jfOQjH31Tk1yllMg4\n", + "ftV7CiGYmxmnVFoglxsijiMuX75As5kkn59EVWepl48TB98jpRr4bpdCqo7X0FioVhiO6lTKLWaE\n", + "xtr6eRYVFeE2sGNIiDQZCTkkEo0VBCY2PVaJh0kZFxeVAVR2YiCJOA8E9DJVu32L9xwOOWALQR2f\n", + "AXycvsmdCoTYeERcIk+KmAFKeKRQSRKQJEmVPBvUGURDI+QWerqOTcDAockSLTIUkZSkT0vEpGMw\n", + "opixqVHMhsulckx+7HYKBZV07RksrUtL97hSWSUIKuSTIaefP8bdd991XXuMFAoFSqWrHDlSRlXz\n", + "QISmnWX37hFuuGGWz3zmY5w7t8D6eonx8VluvPGGXyhXv/vuO7j33km+9KUfADegKGsoio3vn0NK\n", + "jV6Sy9307pVVeiTVZ4AtvDiFGmRB5BCygk1Ih2V66hv6nJCejV2RUVIY1Ikpsw2oJOnSoEGERGEQ\n", + "i54BW0CNkAo2LikkETo+Fj5tMoR0AJ8eiwVUKhhE5MlgkAKu0mSCTbK6jx/UKCIJUWijkEPBEYIR\n", + "06a6vUrXczCMDKpu8Y//198hCAIMw7jmCc2v2bCXUkb0xi1v45fgscfgs5+91mfx+vDhD8O73w1/\n", + "9EdvXTfWVqvFyaee4j13382FEyfYZZoMZrN0trf5ztGjfOZf/Sva7TaNusPM6BzLiz+l1ayT1Qwm\n", + "7DRbQmXnmEG0UiIRBFSlSV1JY0kFIf2+bmKaOtMo+BhUsFDQKSCoMUOFJlUaDFAnSdhvm8MeFEb7\n", + "YWcegmk6nCbBFnl8PAwgh0tEihwNuqQYQyOBQCeDTpMVZvARfVukGTR8TLo08an1Z8seKnUsIqpc\n", + "RbKPEIFGlYAibQSLqGiixoiapBE3sRXATrL/jvuZmZnkG488wk2ZDJmREQDCKOLIE08wPjXFzp07\n", + "X7rWt9xyM/v27aVSqWCa5ktOt28mVFVldu9eFs+dwwLW1kpomkqmkGX8ht3suu0Onn76MCsrm/i+\n", + "zthYGsua4eypH5NQbFRjjLSxwYEJk4yjsHbhAuPZLEG3y66ESqfZZFZYaEGNuoxpY7Bb2oTUSJPF\n", + "RyXEZRUISeExQx4NF4lHiMomw2xTpAV0cYgoM4eCiUD2H8P4VIlYQWGwf2/7ouamQYIWPlChCiTI\n", + "oqARUKNLnQidWdZQyRLyHGXmaZNExSJNTESdGhohczj4ikoxn2f/jXu489AhnnqhwsG5G1iqVkmO\n", + "DXHXnjt44fKzrDS20DyDIXsaXda58OQPeERReOijH2Xp8mVKy8sUR0e59dAhxn6uK3Utsb6+ThBA\n", + "HHdIJEYwzTTN5gZHjjzO5z73+ywuLvL0089TLtfJ55eA3u9ws9nkyJFjnDt3Fc9zOXz4MFE0wtDQ\n", + "MEEwQ7u9ietexTCG8TwX2A1cpjeaeVHw2Uvplag48goqHSzAoI2gQUgViwTTQIAkYICAXqquSZuY\n", + "IQyKqMSotAjJkUWiorFNSIhGgRYzxGSBBAFlHHRiXkzDuY1eN0BiMoxAsEGGNAoCjZgWKreh4KoG\n", + "nchjAsF5JH4UIA2DvJ3CspJsVkuU44jbhnvW+K/sil4rvIXZA9cerRY8/TT81V9d6zN5fbjxRkil\n", + "4OhReAVF4C2Dzc1NMkKwb24OU9c5s7CAU62iJ5PYY2PcdvAgi4uLdLeuYG3U2ek5GKpFGUk2kSWv\n", + "x6wBemqQ5e4GHZkiSBSY8bvgtVlXhgmiHCYKJiY6o0RcYJAcLjZXECgkuAmDFl1OodJj0O8gxkIS\n", + "ENHAArawSVLt+21m+h6NWYbI0aFIjQYTuLi4DACSASIcxvuamXbfvzViCI9lBtExsdkihYuNThsf\n", + "A0NpYGo2YRxiRYJAHWcxdin5SVRlmFB0MBSbnTmDmZlhttYvk/k5gytNVZnOZDh19OjLihHoKZlG\n", + "+kXLtcK9Dz7I//bVx5BrDYrpQdq+y5p/mY9+/tM89NAD3HPPIR555CtoWgMpTU6dOktK17DibRQl\n", + "YP94yAf37uTK5ZBTl6+wXAnYqSXpKia1UAFaZGWMIQRdKbERdFAw0XEJ0UnQRBJzAJ+YGk1idBSS\n", + "WJxgNz4xOjEZPAQ6CVrYZEji4ZPBQVKgzAajQEwHB5syKgF7aXKBHA08LpNgnIgsAR4V0hhMk8Ki\n", + "ikeVNYr91OYh8v3QvTbDaChMEFAmFLDS6PDA5AwrWxU0JY+qqBQsm0qrSbOxSRgNY4mA26cG0BSF\n", + "WmeAhlcl3Nzkj//gD3hw/36mMhlqp0/zleef572f/Sy7du1609ddSsnCwgJHjpzEcTxqtS0mJ29l\n", + "ft7m4sVztFpLjI8XSCQOcurUGU6c2GBg4EYGB2/A8zp8+cs/plqtcuzYAu12jjBM8eSTJ1ldbTM2\n", + "5uD7Ftvbz9IrOPYipdNX1bTocUXW6XVGBHAD9C3cNWxUQGEFjRE00gjKpNgmBgJssphEhJTx8VH6\n", + "kXc+BTRK6BiM0mabPD4hKgU0BkkzRatvi9Yrf1r0ei5pQEcli6DW19BNoFFCMqDY7FJD3CAm1HQG\n", + "7DSdboP10McESrrOhJmkqWoMajpXaiWyO3Zx331vrsPqr8Lbxcivge98B+6+GzKZX/291wteHNW8\n", + "VYsRy7Lw457l8s7JSXZOThJGEa1ul6X+rOz5Z5/lwECaU+fOMxBLkqqOHUtOrl/h9gM3oE+Msz07\n", + "xeXjz+HUEthRh3ElYFVJkhdZPBH34ruli0KHgJg2lX7WhGAHKZJorBCiMNRX3iRQMInRiWjRZRsD\n", + "hU0iGhh9c/kcaRIERKiYRGTw6ZBHRyKx0fD7f5IBCsv4eOg0cUhQRCVBmQ4wT4IEXa4SYxDJEWIl\n", + "AiVHU7rkbImq7kRTJoiiGDcWKJpPPq8xOjpK7Re0Y01dp93pvFnL+LfC5uYm+am70OdStCsbJFN5\n", + "3jG+g3PnzrC5uUkikeDMmfOcPduhUNiLlDl03WQ2O07CcLhl3MPSNFL5PCU/QcHIk9R04jAGmcGN\n", + "JcQ1pOyVkl1CAqCDS5cEoh9nqPQj7xxET2WlDqJEabo00MiQJgK6+NiYFNCRmHgUSFHGJiLJKjYx\n", + "gjoJYsZRSRCwRYUKg7QQdPFJ0SKBRpEkK8QEaKT7/jEedVKMYtDEYQADiY6r6fgyS8JOkXa3+cmp\n", + "GpYFbaeNEDblep2mprFa2qDdSDNkhmiKQtfzCDWdVHqaC5cvkwsC5kd7cu5sMkmu3eb7jz3Gjt/+\n", + "7ZflvbwZ+Pa3v8ePfnSeXG4WXR/guefOIuU673nPR7nnnp/xlpaWzvHUU8cYGDjI0aNnaTY9IGZo\n", + "KM1/+A9/STK5G9u2+clPnqZUUul0hqhUjqHrOkJ0iOMMQrjEscAwugSBx4vb/88My0xgEMk2fl8V\n", + "YzGCSREIEaTpcAWTbQSw3o+N8Impo5JAwcIggUBDwcYgRKeDR0BPbqojKfbf8Qo9r9YSPY3OEPS7\n", + "KjYWETZW/3NEwTJNVF2QQMNN6HRkTGJ8B6JTwzAVtGQCTcswoCVYdzukd97Ax37zN5ifn3/T1vL1\n", + "4O1i5NfA9ey6+svw4Q/DZz4D/+ZXCbOvU4yPj6MNDrJWLjPed3ATQnBhe5u7f/M3AbiysEDY6pLT\n", + "FXKxCjHoQmHEUPEiyFsGG0FIIjdGMjdAde00bac38ZcywJAeUKdNF4ckghRr1FBoM0HMVQxiEpSI\n", + "CFBQyRFRIqZAkrNkaWFSJmILC4jRMChgYCPR6CBxEEhi6giGkERAFZ8xOixgs8YgDQZQKRKxRIwk\n", + "QEVgYmETIbAYJGCNSBSRiiRj6XQcgRuWKOq3ki+OE6kqUwMDJFMuvm9gmiY1KYniGPXnNpf1ep09\n", + "99776gt+HeDkyQsMDs5TKIzA/E2USiVOHXuBjdXz/Nv6/8Hg5ByGsYPBwYvEccDo6Bztco1LtTPc\n", + "OuowlettXMvtNpnRvXie5HR1iSE1iy8VgkgliA3qwsJBpYyNjkaHKjp5WjiEmETERJjAKJJlvKiJ\n", + "JMAlhdnviZm0+zJviYdLhpCIGJNW3zt1gIAsEgWJjkcNQZUsETtQUJH4tDlPgAYYFIlRKFDDoU2Z\n", + "iCEkPuAge3RZEeJHXSJCwlBHlQncIGLP3EG+9tS38JsuXtfD0HVE0IIwpuW7XNlSGRwdZWZsjO3W\n", + "Gs16nZ3j4y+79rlUinBlhVqt9qbySba3t3nmmbPMzNyFovQUc3v33sEPf/g0KysXmZ/vSbmklHhe\n", + "Cc+D55+/DORotaDRaHHx4mm2to6xb988zeZlLl5so+s2UubxPBvP8xFiB0IE6LpOFHXwfeh1Ol16\n", + "xcgqPb8Qg16/QkOli4ZFAo8MXj9AMSRHng5NOmRp41Ghl2+k0cSmiECh2R/YNtlGvtRDTVCmhkkH\n", + "k95QSPKzNJsGPdGxQNLFwxQ6sRTUVJ2inqFDRBA7qBqkdbATSUgJMtPzVDodPnrffYSdDk8eOU47\n", + "bXH/nXu4885brzlH5JV4uxh5gwgC+OY34Q//8Fqfyd8Ot98OnQ6cO9cb27zVoCgKH374Yf76L/+S\n", + "taUlLEWhHsfsfec7OXBTT2cgFIX69haTI5MY7TpJ1UBRFcq+y+LGGocrVTxfR7oRg+gMxU1cp4KU\n", + "4EiTPGk2qaExh8oUPh4xY0Sk2GCFIaYBHZ0EHl0kGWJWSHCEYUzSSEyajOGzjWCTDnVapLDpElAn\n", + "0fdNjHEYYIUGs7jEbNLEZ5nRPmk2TYSDZASnf58OOgYxLhARYlLEVzcw1DqTgxOUamUKmWlUZZx2\n", + "FHHj3j3Ytk2jcRlVtUmn0+y86y5++swzzBUK6JrGarWKHB3lwM03X7N1fS0YhkYU9a7Y1tYWp599\n", + "ltFkEj2TZndC8Ni3fsDOWz7Ovfc+yMmTR9jeXsTK1vC9KkrC4NTWFk3XZdOyuPHWW1laDKgECkbQ\n", + "QAkFrTCkThKHAQQpVtgg0ZdnO7SoksQnQrCMxk5CJGChsYqkSoSNjoEALFRiVulZUaXxiBFUGcKl\n", + "iU+JGm1SBBSJMYB1soTMkiFD3PcocdkgJmACg1EiIKSBzmUCHKaULiEWRqzj4YG0SCk2jtwEmaaG\n", + "RmW7iucfw5Yha9VTFPQ8Y8URrE6DlCUoFnYQt9uMjI2haiqqqOMBozMzL7v2UkoiKTHeZIb+6uoq\n", + "QuRfKkQAxsfHGB4ucvLkEUZGpoiikHL5KrfdNs03vnEVxxlke7uMEEkMY4C1tefpdBJcurRGux2j\n", + "KAVUNYHnbdHTJY0hZQshAqLIRVFUgiBLr+joeY7QF1T3ChIHre/io9GgiILaZw6lCanh0uZGMkyS\n", + "xsWnQbOfNNXT4qSRdNEIcNkgYIiQMQRq38HG4BwCC8lOet2RAmBgcBGTGgkGCAnp0kwoDKbyCN8l\n", + "W0wxW5jkVCtHcWiInQMDeEHA8VqNsfvvZzEMOb6wxuhNH+D2Gw/S7bb4j//xv/Nbv/UhZl6x3tcS\n", + "bxcjbxBPPw07dsArbiSuewjRG9V85SvwB39wrc/m9WNjY4MjzzzD5tIS+eFh3vXBD6JpGo7jMDw8\n", + "/DJy5Z6DB3nyz/6C+cwIJaeFQoQbBCx0m3RbTebzQ4RhnWYo6YQGA9JkKIJFQkzKtPFwSaJSRKOD\n", + "LiI8qRIwT0AbiYWCjU6rr7g5xiAB0zSwiKjhYyCw0ZkixiXAY5UVAgJGiYiQNPv9kG0aNFhhk50E\n", + "1DBQyeID4OCgoPQlvh1qJPAJcHGQ+DhIkUYQMj88wg3T08yNRpTqJjKOUSOLOJY0GlukUjqXLp3i\n", + "G9+w2LNnnts/8hGunj2L57rsOnSIW2699RcqD64H3HTTjXz7249w4fRFLp8/z2QigUhYCFFhx8TN\n", + "jCxssn7lMvO7dnPPPf8DnufgOF1OnXqCndMmvu9z6MABHnjgAf75P/8/KQzsIZeb4/LCT1DEBhtu\n", + "CSfeiSkNNDYpopNA0sKiho9FkkmgQ4kuTVqYBIDHKgYGq8QIYkIi1ggpUmUMk4AyZQJ2YBAQo2NQ\n", + "YZsAA4mkt9HlKTKISRUTixYOERHDJFmnTYiHREEnQYiNKdaJTI22V8PF5hwRoyikZZmU0ClFZTpW\n", + "BksbZqORJGtmUZQFdg4H3DMjkXKc//rCJc6tB9TbKgvNMnPjGrccGGVy/zsIXlF0XNncZGz37jc9\n", + "Tt4wDF7ht4mu69xyyx48D1T1Kqoas39/Gtu2iSKHjY2zqOoebDtJuXyJbtfBtqdwnC2knCOOfTzP\n", + "Iww36RUYbcBFiGGkPEkUjSFljyTee4zRG5pcBi4BBSRVNMqotIgYxSQiQqAS0CaByjAqGiEKSTw0\n", + "AgqEwDJBf0SjoJBBsNG3eHdJk2eKJmlO0eRWfBYR1JFomBiMMo5JiWFKCOqyQireJi8D0gWTsYlB\n", + "fEXh7911F+lkksWlJbBthopFPv7ww3z96z/kroceIAwDwjBgcHCCet3k8cd/xBe+MPMmrupr4+1i\n", + "5A3ia197641oXsQnPwmf+1wvOO8669QB4HkenU6HdDqNrussLS3x6Be/yJRhsCebpb6ywje++EUe\n", + "+MQnXuqG/DweeNe7+LPdOzh+aZWBZI7TTpNlt4PWbXG7qjEoIIpDHF3nbOxgJzI4bZtiGBKjU4w9\n", + "mlgkEBj41KWKiUZvqpvBJcImQCcDXGGYGiMkKdKLwxtCYQOBh4qNQxKwiHDoAiYKQf8OOoPfN1Tq\n", + "0OIsHh5ZHIYRTPa7J+tABYMGESU6WHicAoZRGSCWMWG4ydJ2jGm1+cS7buX0lXWePf1T6h0bJziL\n", + "ZkEsBLfffhuOM8mTT66QTrf4/Oc/SS6Xe93rEgQBFy5cYGlpjWw2xZ49N74hhY3neUgpX7fl9JUL\n", + "FzCbF6hWBG69Sa0J5fJRPvmBe8ilUuyaKPDjhTLdbgchJE8/9SQXTh3GaV1ia2SAW3bPsW0YXBwd\n", + "ZefOcZ599jyl1YCh9ABbkYOdGUcPZpHeaSZCC5vBvq9LhTSLxPjkydLAwybCJqZECoM5bCwczrBF\n", + "Fh+fPG32ABYxCjpDwFk88kh8TJokCRmnxwQooNDCIO7nz0h0DFxUVHRiuqi0MBAohETArKnSikxK\n", + "ms1gHJEJI7Zp4ugpFKEQazpWaoh8/i6kVyZrRoyoBk3nCh3f5+iqT8efJZMcQVXaREYHmUlx19/7\n", + "AO9//3v56iOPcPjqVdJC0JESY3SUj12DD7q5uTlM83t0Og2SySwAURTS7a7xuc99jJGREf70T/8b\n", + "Z8+62HaCOC5QrR4jkwmJ4wz1+nls28Y0p4jjDRqNs0AB112hx8QYoJcdowENhLCJ4wq6bhLHJlIO\n", + "EMc+vaGJChgIzmGqOunIJ02HBm3afV6IS4O4P4oN0HBxSLDJFAoJJFkghWQFSYqIBXQK+DSpEmIR\n", + "YKNi02WBDiGGlUANfJQoCSRJEqEqBh1ZJJYjVP2LnFAiDu2epZW1uH/HDubHxlgrl5mensZSVbZc\n", + "l2azycmTF2g2V+jxYBzyeZM77riP1dUKruteE+v3X4S3i5E3ACl7fJFvvUWzhu+8EzwPXngBrrfO\n", + "/Pe+9wOefvoEcayj6xH3338bV8+cYlcqxXB/40tYFplkkqe++U327N2L9gpLWcuy+O1//a/5r//X\n", + "/013s8acOUb1/AlGNYXJVA5DN4hDj0QckYwCWtLFUnRMTaEkQ9Io6HEd6OCgoSIJiRFsoLONJKBK\n", + "Hh8bSJKnhkDDIcbGRidkgJAmgoiefdI2CjET2LQYo0WSAQQONUqsAa1+FqXODBKXCA1wMVSThNoh\n", + "CqrcKiNiHErkaNGmSwsbHVdJoaIyM7if58/XeN+hPTiNJ9lcWmAqP0mpUkUMzTIxPkcmUyCTKbC2\n", + "dpFnnnmO97//N17XujiOw1/8xZdYXvax7SJBsM13v/tTHn74fa9S4Pwy1Go1Hn/8Sc6dW0JK2LVr\n", + "gve977VNb7a3tzn/3HN87qH7qTab/PnXHsPqdvBdl6ee+wlLK8tksllClimVznPiuacIV5YYDWuM\n", + "Jy18N2ZlYZX9oyOc+e53yQ2OkErqVOUStpEmk1AppA9wcfUCNiEmNqrQCWQENBhHsE2MT5M5FDQk\n", + "NXQkNRxmMWigIdC4CmgUcDEBE4lLhxQwREyNHCUyxGSQDKFT6bvlanSBDAFdDDShoQAV2StthghI\n", + "oxEhWMWh6YYMWYPUZchYuoAeSZrSZ3p2iFQqxeELZwmCLNWtyxhmQNYUzE9NcHGhzLPLqzj+JLHI\n", + "MVrcTcVxmLlhN53OCQ4fPs+DD97Hp//BP2B5eZlarUYmk2F6ehpVVV9rif5OYNs2n/70+3nkkW9Q\n", + "LqeQUkWIOg88sI9du3bx1a/+Dc1mjrGxSUBwxx3v4fjxU3ieSz6fJZudoNOpomkuqjqD627R7bbo\n", + "mYcXUJQMUhqoagJF0dD1TeJYMja2lyCw2Ny8gu+n6A1LdISwSKi3Aav4Ypt9yTS+bHC1W8aXOlBG\n", + "x0QQEOBjU2UMgUabHBEWvWiAAXoeMUOEgGSELiW2WELiM46BQVNVKJhZpCwTRAJNiWkJ6KLjyYhY\n", + "SAxb4ebb7mbvbYcwjRXq1S3+6vuHWdsM2N528IM6jtbg3ZgsLraYm3vHSyOvZnOVw4d/yO7dWXRd\n", + "f9PX9pfh7WLkDeCFF0DX4Rqa1f1aEAI+8YleyvD1Vox8//sXmZg4hK4b+L7L179+lLh8gk/ffdfL\n", + "vi9l23RXVvjm17+OIiWjU1Ps3bfvpVHDnYcOYf7e7/LsE09Q2dxErJ5jXB3EjhVAxY1C1EiihT71\n", + "TpNhIVkNTTblEFmpkqBEmwUiZpCoqLQoUKWAR46QbTa5QhoTBwUdGKRLCpMGkiQeNUr4tIEWSVwK\n", + "qDiMUiXHJD2hXkQRC49FSsxCP7O15/b4PClsUvjo0SoDNPEViRJb2CQZRmcLiaHqxHqWLbfF4TMn\n", + "2T01x1d/8BSDUcSHH/4kiqryve8dgTjmp0/8v9z/4f+JbLbI4OAkL7xw7HUXIz/+8WFWVgQzM7e9\n", + "dKzTafLlL3+bf/kvZ37lh5rruvzZn32JdnuA8fF3IIRgaWmZL37xS6/5us3NTXKAqijUmk0yAtxK\n", + "BcNx8CsVNtpt2rbN5NgYMzMR5x6/yM1zO/C3BdOZArGUnGzXOHnmIrccPMDXvv1N4rZGNtBI+xpr\n", + "HQeh1VGVCkkjQsMjjrtIWcek3Y8xi9iJRg4TkAg8xonZ4BKTDGGQwaXJVl/10iFEEBMTkSImg2Ab\n", + "hQEKbOADl8mSwsNDJU8LlQwehjBxpIurhCzKHkW5hoIHdOmQpssQCpFUSKbyrEmfISWGUFIul1BS\n", + "KerSI0WTQtImlQ4pby9zPt7A1QRr5SaqiLEzBSqOw+DEBJZl4zhpHEdjdXWVOI6RUrJjxw5SqdTr\n", + "+t34u8L8/Dy/8zuf5+rVqwRBwPj4OMVikSiKePbZ45TLOj/96VEAUimNbDbDxYtVwKbVWiKdNhGi\n", + "RLtdY2xsB4uLR4giD0WZJY4dEgmbVKpAq7WOEDH5fJFq9QWGh/ejqi2EKCFlHphCoBPIAIVthnI2\n", + "9aDLQBwyqUaM6FlOuXkcWcVhCZMMCWLCvkNvkl4/lD5hXUFQQNAgIkajSIqQOovE6EywxQp5t40R\n", + "xHjUqcY+WyRwGQTmEFobTRmlXHYJQ0kQwJnlMrVlDbduoOkFfH2CREbjiSdOYlmzNJtlcrlhADKZ\n", + "Ca5efYEPfvC916TQ/GV4uxh5A3j0UfjQh67PEcfrxac+1QvP+8M/vL4M0CYnD6BpvY3NMCwmJm7i\n", + "qePfwfU8rJ8z51nZ2uL44cMUFYViLsep55/n2FNP8Ynf+i2y2SxCCG659VZuufVWoihivVTCff55\n", + "bEWhWWniRxIRBmwTYyg+1cikJAZADNCSklhmieR5hDiMKg0KhBQxyJMkoEaRgArLNEnTxcSkgiRB\n", + "gwxd6qwh8Pst3CpFBumg4zBMQMwFQiaJidBpMoVGmw4uITkcdGxCFkkTYUVdsriMaCkq0qdOB0UE\n", + "KFJHR+JrFlkzTY4ORjbLSlcyovo8/P7fIJNM8qMnnkBurlBID5Js13n2pSPT6AAAIABJREFU8T/n\n", + "4EOfIpHIYFmvn5R49OhpRkZeXrkmkxkqFZ21tbVfSYQ7f/481arO9PTcS8eGh6dZXm6+5utM08QH\n", + "XN/nxIkTvHNsjCOlEqbvo+s6lWYTY2KCd+3Zw7MvvMDusWkGMkNUaxsAKEIwqKps1ZucXlhgRkru\n", + "/8iD/MWXv8765hJhrcx2oKIoe2mKEgUdFL+FTYk0vbIwRGEQlQifGK3vKiIo0pNgg4NgAJsYhxZx\n", + "n9mTIsJDYQmfEj4KkhQaMQsoJDGx8VjEwqdFli3ZwNIlhcwMcWWbJJu0EBgoTCIYIUFEl9WgSyVK\n", + "MZhI0Q4bEHdY3NrgUm2RXfkBSsESqmgzHWe5cSBH2etQpYm1e45YzqJoYwwNjb3UnpfSBWy+/fWv\n", + "Y3sethC0gZve+U4eeOiha6q6sG37VRbljUaD558/RyZzL7ncbsLQ58SJx7DtaXbtmiKVStBuj7Cx\n", + "cZF8XmVoaBjD8AkCaDQmSKdn2dx8HkXp4PshUvrMze3HtiMcZw3LslCUMqY5jO9ryLjSy6OJVlFF\n", + "GVUOsK7ENFNZ/G5MUhlkxOiw3XgeSZOIFF2gQ4ORvmmZ0WeIVYjJoNDsa2NcbAxq5PBJIrFIMSYL\n", + "LEcNkkLHEjGKhAksKtRYZwFdFaTTk4yPH2Jh4QzT0yaT87fQdNt40iGRyjFaGEHXdY4fP0exWMS2\n", + "u1SrVxDCJI5dhoYy3Hbbq0fc1xJvFyNvAH/91/Anf3Ktz+LXw759kM3Cj38M11Ny+IuFyItIJNKk\n", + "hqc4vbLCbfPzCCGI4pjHf/hDDk5OctOOHXiehxZFLC0t8YPvfpcPffzjL/sZqqpy5zvfyQ9XVri0\n", + "tYUuQjxdckVAx0qgCR2/O0w6TuHLAKEm6CoJkHvI6ReYSLjMt9rEUqURdYmlSgKfKVzOY7HJIApd\n", + "ClQBjU0cJClGGWedNabwGCZFhwY5TFR8timhkCWNQYcYjTY6Dh4KClWmcUgQs07IClla4RiKGlEV\n", + "JdJykxaTdFHJmjm6YQ1V3UKVJpqlMDE1RiaT4cKZMxQVBbJJQJCyEhTMBOePfo/RXXv54Adf/4eR\n", + "lL/smde3UW1sbGOar+anJBKF13zdzMwMfirFuaUl0nFMFEUULAvDMBiYmGBHKsWypjE7NsYTp05h\n", + "Sw9N1/GAWMYoQsEPQzTDora9zYHZWQZzOd6xfyfPXnmMexIKT3sdrnjnaQcZVo0mY0qD0UihAtSR\n", + "uAjqhOgI2viUAQ2BIAQcgr79e4aQDVoU0Wlh0iSgTpcqw6QZpo7T33xUMmxjEZAlJujbdptEqNoI\n", + "iajLLhwKaLQJaOKTIw+4NAlZlzGJWHDz4E4qnRKXW8e40TLJqArzY0MEseTE5UXa0TgJK4sRN/n0\n", + "e+/hnOex6SbY2oowzV46daOxSDars7l2hjuyY+zrF5VhFHHs+98nk8tx+8GDr2uN3yycOnWGVGqK\n", + "VstD113CsIFhjOO6BiMjBu9730M0m02uXp3g9OnHMYw2mUxMMjnLsWPHKZVqQIiUdVw3iRBd8vl5\n", + "TLOMZdmsr7fwHA1VsVFxiZVtVCWHrqbwAp2rLgyk94OWoDimovlNVldPMEVMjphL1MjTG89CL1NI\n", + "ImnQY6A4SAIEaWKm8HGo0cFAkqFgSLTIIiHb7FJsFJEkRrAc1sgRURNVMtl72XnjrSQSeZaXt3no\n", + "oUNsbARoWsT0jt2oam9blzLGsizC0Gf//lswTQvXdTBNg25XY/w6U1+8XYz8LXHhAlQqcOjQtT6T\n", + "Xx+f+lTPPfZ6KkaCwEPXf9YBcZw2u/feSGGmyLNnz5JRFNYbDYRhcOehQ1y9usipU5eIY4soDvnu\n", + "6T/l5oMHX3Wn/p4PfID1CxfwSyWOHz2KmkySjCImu10iX2ANjNPwJKttMKWFVASBkkWY83S5hK85\n", + "ZFUVw/cIhaDthaxikSOkRZ3L5KgBGh0sTPKME1ElooNPmi0giUmDDhNAkjouXTwMrhCQZJBhRmlS\n", + "ZgKFMXxsDAwKrPdb9akoi8TG4xKSCzhKGs1rIKRHxhhgs5tECbZRbp7gwvo626ur7MjlSJsmJ89f\n", + "phIojMqYbuk80+8+wMGDt7/udbn99j386EdXmZr62V1qt9vCsrzX9aE2OFjA91dfddxxGq/5OsMw\n", + "+PBnP8uf/Pt/z3ajge55lF2XfTMzDA0N0fI8hKIQhCHjs7O4pW0a5Q3swiib5TX0OGKxU+Xu23ex\n", + "cPUq87t3E0URV8+dY9/wMKHrkg5a7EwKyo7NaghrUQWBQhsVm5gBdLYJSCJpouCSIaaKQ5siDj4K\n", + "MQ5FK8tWOEBF5GmHbXyZRiPLEFOUaWNzAEXo1GSbBHWmUNGR2OiUiTmKSei0mcyOoCZMgm6XUVKY\n", + "6CzQwURSRqejqkxKl5Xt8+jOJpNKyP1jY9TrNerr60SmyQ26ypnWOsPCQ1UjctkMe4E9O3bzxBNH\n", + "WFq6AAgKBYuhoSJpP8He6emXrrumqtw4PMzRp566boqROI45fPgIv/d7/46VlZgwvIiuj5BI6Hie\n", + "i6pqTE/PYlkWlmWRTicYGWnTaHgsLraxrN3Mz1ssLCziujpCVIA1stk83e5JNG2CVsukUb6AjLeI\n", + "4xU0ZRRVmSSIXULWMQyVlC1wvAaCNBdbFXLJVcbzFtPtkDOdDkls2rj9xCho0uOJhP3HVXrU2Rwx\n", + "ETEeMWVMVKPYC2BUJXocoWomMraI/QCNbs86TTq0/Dal0gnCcJtUyuNjH/sg/+k//TdSKZ12u0Mq\n", + "1SP8tlqb7Nmzj5WVS3S7uxgYmEdVI8rlC7z3vbeTSCSu0Ur+YrxdjPwt8eijPeOw62m08UbxiU/0\n", + "yKx/9Ec9Dsz1gJWVE4yPH8A0bVy3w8bGKT760Xs5ePA2Njc3qVardLtdDj/6KN1ulxMnrpDLzaCp\n", + "OmEUoVU1/st/eYx/8S/+4cv+2MbGxnj4n/5TnvrOd1jtdlk9fpwJwyAPNKI2p5urbPl5FAaJpYEh\n", + "A5CbZK0b2W5vMZrwmRMCU1XZ8H2WEGSxGSNFB1inRpOAEQIsBpCUaIokjpwl348+a9Ghw1U8OhjE\n", + "/QAtaDFBGoMGVf4/9t40SI7zvPP8vXlV1n13V98HunFfBMFLAEGIt0jJFoeWRIkKcSTRHtszkm3N\n", + "7tgTlr2anZiInQlHeGPWsfaMJ2zRq4OWLIoiTUokIR4gQIIQiPtooBt93133mXfuh4YoygSpwyRB\n", + "OvT70lVZld1v55OV9eT7Ps//345PmhQtGtiARpAufKZosSR0KoTwaSciqmQ0m5hcRdY6yetRuvu2\n", + "EYsJQpEQs2KF41NTLI2PYwuBlUxy99VXk4lG8RckMokwTz3+OH3Dw6xfv/5n1nzs2nU9Fy48zOTk\n", + "UUKhLJbVQIg899//oZ+rCG7DhvU8/fTL5PPzZDKrXiel0hKaVvqZ+3Z1dfG/f+Ur/Nmf/An9uo6S\n", + "SBBw3dXzpVZjYNs2Rubn2XvXXdi2zbPf+jb18RkuVpdYalZJZjNMVCpkNmyg7jjoloVZrxNUVUby\n", + "FbLpTjJKkENT80y5JvVLqqbtCIpwyTfGI4CHIEULlyIhsngEL3W9mDhMmAbLUhZHtIGiYdnn0bFo\n", + "sIJHCgRUfYMoZbqQSF9q9VzEZpR2FHIIVBbrGl4ohDBmwXPR8HCFTFXrR0g6iphFC7rIUon+uE7T\n", + "dokl4tQadVTbZrFaZ000TUwVhCNJIpkujh0bI7O2gztuuJZPfvLjnDt3jmKxSDabRdM0XvzGN96w\n", + "HBMJBqnPvjGBvFJ8//vP8Dd/8wzN5hDRaBIhXExzDEVJ4HlFurr6yeXa8C9N4y0vT3Lzzddz+PCr\n", + "HD9eJpGQKZdX6OjYhmGs0GqFwYdmw+bE8aNEQosoWjet5jwhbMJ0gNdEFicxpHZa4ioQBwkHNyHL\n", + "IUKyia0HKdZkbDOBonWQZ5QBoliXbkOyQA7ovmSbeQGPJXwal0wVLTwmhEwl1IGkWhTNFhnNo9I0\n", + "CITa8GwVW67jWBE8P4avdBEKr0VVg9RqJ/jyl79IW1sbv/7rN7Ow8AjT03N43mpNDCzQ1tbNjTf2\n", + "kUqFGBs7TDIZ4/77b2Lz5s1XLpBvwjuajAgh/pxVf5+jr3fwFUL8H8Adl55+2ff9Z9/JcbydfOc7\n", + "71/10n/KwMCqVsozz6zWj7wX+PCHt/P880cwTZ9QSObee29g584dAORyOXK5HJ7n8eoLL3Di+Gk0\n", + "LYEir34ZLlTzdA3vwDRjjI2NsXXrVpaWlti370VGRibRNJUPfGAb195solarRJeWCPg+QpFxvUXq\n", + "nk9MbcP1LQx/cVUh1fIIRfvQOqOcnptBajaZtCxkSSMr4iiySlxRCJkGo26dEk0SFHFFjGU/hMGq\n", + "uygIZAJYpDBpMEOQBhuR6EUlSIsCHrN0kgeCWEQwqKID8mpZJaaSIiBlMEUTLdnOXKXMxdYKUVUQ\n", + "0eI0mxdpT/cxMTLPqcqrZNNpGo0GPfE4ihBY1SrPjc/wwtlJzo+tsLYnzcX2FMfWr+cTDzzwloZZ\n", + "oVCI3/zNTzMyMsLk5ByxWIqtWz9EKvXWyyyv3/9zn/sNvvvdHzA9PX4pnlE+/el7+dM//b2fuX80\n", + "GuVTv/M7fP/rXyfS18fI6dOUl5cJpNMELIu8LzHx/FFkWWHD3psZSR3jpuE+dm3aRCwcxnFdnj93\n", + "jlcWF1EvjnMo3+KFhokkBFtVm2qzjmLXMYkgiDBNjbXYxC4py9goXCSIIIaKBKyjwAIeMyjIVLBp\n", + "+hKS0geujOudQ5V9PL+bBa+ARwPJtwFBDA+dCCYeFgYLhAjTSQsFG5mWAZFwjla4QavlMudYrPgS\n", + "qgsBVaKnZ4BkwiJjtNjR0c6PpqZYyedpGAaO62KZJme9PFY0jRvP0N05yHJxgbFimd8ZHCQQCLBj\n", + "x47Xjm2j0VitjXFdlNcVNC6VSnQNDr4hFleCYrHI/v2nMIw0g4PdXLhwDkVpR4ghEgmHZrOOaZ7g\n", + "7Fmb/fsPUCrNEAxWaTZ3ks8X2LZtPUIEWVqSabVamA0Z14gi3AKW4YGfRGvZtOpT4KdRpQGE1yJE\n", + "Ftct47hzeKKILvk0VsZoeSa+7wEWiAEUJUwkGEWrzGOhoxOnyQomq/4ydWRaqCwgIfBIBkL4ER/H\n", + "csgSIJCJkVu3g3hcJz/+KvqUwZlqgawcpYWPp3VT8G0IpBCiSSIRpatrK11dq9L9W7Zs5o/+KM53\n", + "v/sEL754FEVR6e3t5KabNnDLLTe9Z8zw3op3LBkRQuwAwr7v7xFC/L9CiJ2+7x+59PJDvu//JyFE\n", + "HHgMeF8kI9PTMD4Oe/Zc6ZG8fdx/P3z96++dZGT37g9www3X0Wq1CAaDl632liSJuz7+cf70wCto\n", + "NYOW51NxbMxEhu3rdrK0NEWj0aRYLPI//+ffAz10dd2E41j88IcjzJ19nk/deSc/2LePsfPnWWq1\n", + "iIogA0qNmj+KosQIBDXCqd3Y1gqy5LJ2zTCLvsuZqSlM22ZQ0jAdD1UIbMcmq6qseIKSCDDteTR8\n", + "iVUviyxlCrQh0AlgYVFkGZMUMt34CBw0Vu9/M+SZJYOOhMWPu2sagKmkUZUIdXsCtBTd3buZNA9h\n", + "2v34joKws+QXirilZwl7TYS5gNTTgZzJ4EsSAUni4ecPs+J0sPeqXyMZjVGoLGJaKwTkUY6++io3\n", + "fOCtjbM0TWPr1q1s3br1l4pte3s7v/3bD1Aul/F9n0Qi8QsVR65bt472L32JkbNnGbz9dpBlwuEw\n", + "Tz31IprXQ2fnGiqVAo898iSLFw5w38278C7dJSuyzDUDA3zv/CgltwPRuYfCuVEk2+CAsULSrzIj\n", + "cnj+OiBKnRWOcpEYeWp4mGSQ6bskWqUhCBMSA5T9Fr6IYxMlHC0jqBEwoeyAovQh/HY8OvGo4VMl\n", + "TB0dhToeMquzOzb6JZFxCU3SUYSFVS5TdVo0PRWLbiQpDVIYw1+mszPMVVft4MBjj7GmoiN5Hofy\n", + "efpiMSKKguyrzCsqSjQJ8QwT5RUWXI+brtl92S+lcDjMVXv3cuSZZ1jf1kY0FGKpWORis8m9t932\n", + "S8X67WZpaQnPi+D7VXQ9zNDQWqanJ7DtJsvL5xkYSDA83E+h4BAMNmm1woTD21hYCKKqcU6ePMWd\n", + "d97F8PAAzzx1mkRgPYX6FJJbR/N1HMC0LDxMQqzFQ8ZmDpkyCi4tKmT8Ag23Hc8N06YO0PRsKn6L\n", + "gKjT8n0u5vNIhKnRIkuMImVmcXFIIJHGQFBCp0mICXOMm8I+mUQMX9U5bqyQjKsMrOlj165B9IDP\n", + "f/k//5K5pqDVLOCrEE5upS0Uo6Mjx65dG/D9Os1m87Vj1NPTwxe/+Nt84Qs+zWYTTdPeU627P4t3\n", + "cmbkOuDpS4/3ATcARwB835+8tP3H7sjvCx59FD7ykffOksbbwcc/Dn/8x1Cvrzr6vheQZflnthX2\n", + "9PTw6X/3O3z9a89hxdpoS7bT3t6LJMn4fpmurk5eeeVVXLedzs5eYLU7p79/OycPfpcT587hC0G9\n", + "0UCRJKpCISxpmE6Viu8jojvQFBNNW2bjxo1MO7PM1ev0pFLM2DZWy6RJE8fXSApBDYOCHCKrdiO1\n", + "DOo4+FSQGaKGhEcJDeuSJ03gkrqryqokvIGPhk6KIhoLVEnSoAefCVYYJ0TLDeB5M1iegyoE02NH\n", + "CGptmIEEmtZCcUycpoXkyqSpcFUqQr3RYAa46e67OTcxgRFwGGpfQya+qteSTXSxWDTwHJdzR4/+\n", + "zGTk7eIXEVq73L7Xv26cx48fx3Ey9PWtY3l5hvMHHyPXMlFaEkunTzM3Pc3eG28km0igyDJnz87S\n", + "3TfEUMbDDc/TKhi03DhnaQJpdCWG5Wj4JJBJUycERBDI+ECTRVR6iOJg+RYImYCcBqGSToSRvSTV\n", + "8gItO0eAAIgWplAQvs9qrOdxgClMujGw0MhjYuPioqNJOkt2hXYcDJpo9OFLUZJqiEhQo2xqrIwv\n", + "sO3Gq6lt3syBo0fBMDGTfbxsaJSqNTRV4q6dNzFjG6hbdhEPRQk1i+za9ebumDfdfDOxRIIj+/dT\n", + "nZ+ne80a7r35Znp6et50n3cC13VZWFjthOro6HjtZkTXdTQNwmEV02wRCsVYv34blco84JBOWzhO\n", + "kquu2snzzz/NwMCNyLJKoTDNpk2dzM8XOHbsFdraevDsR1lsrmBZCppvYYsiYb8NhI3wxSU1mVly\n", + "FBhAQ0ZmEYmC5FH3VAIijuSspiu+r+J4NrqYYskPEyJGAQOTMkF0jiPQSaAQwCaJQRqBwKJEszmN\n", + "IzQ82SMeCRK2L3L99TcSicQIBgP8q4/fzj/8wxE0fR2mGcEwfDStAOhks1mWlubJXPLnej1CCMKv\n", + "c+V+v/BOJiMJVhVjYNXrZ9Nl3vMV4K/ewTG8rTzyCPz7f3+lR/H2ks3Crl2rIm7333+lR/OL8YEP\n", + "XM+pU2MUCkFSqXZarTorK+Ns25ajp6eHxx9/lni896f28X0fw5UZOXKETYkE6VSK6VqN54wW+WAX\n", + "ejiO44Xp6eqlUpnHs+qcO36QRr5Ij2NR9H3KXoKgGiDh+lTcAjXP56KkkZD7iNsQIYBBgAJ1ZBaI\n", + "kMa4ZKIFy0AEiwYuChLKJX+LCtAghImumDRclzO+wzIyNZJ4/hCuDz5xXFdjuXScZDRLOCBwfZ9S\n", + "rUC7cMCRsVUDw5Rpi0SYLq3WZGRTbcSj0hvulHQtwWJxkcGhN5+hcF2X+fl5PM+jo6PjXfcpeSum\n", + "pxcIBtMYhsGLT36DXLmMJWTMpocwbPqTMkdPn+aO3bsZm5tDDqQx80VEvU7UdckEg1SdAFW7Rlh4\n", + "rLhlAnIYy61cEp7ruKS928QmiCAEzOEQQZJqhOUQDXcZobUj2za2BWFdZaVpEFZUNE9QcyusTtaD\n", + "R5xlAoQoUGSBrkvqEUVahInQcAokcbCpARYRoWD4Joa1Ar7HQFCiYqp8/+BBGoUqLV/hbMGmM9ZO\n", + "e0cXOUVlbmacpw4+S7ojw/B1H8JxDHp7NTZvvtwleBUhBDuuvpodV1/9pu95p5mcnOTv//5JarXV\n", + "czEcdvnEJ+5icHCQ3t5eUino7o4zMjKHbWcIBALMzBzG8+aZnFSpVi+iac+hKAk2bdqCLKsoSgjH\n", + "cdm7dxfPP///IcsNhHDRlSyy7eD5EsJvo8Ey+CYyEjUqZMiTQ0bGxQMCOLR5LlVJR/XzOERx/RZZ\n", + "PALo6L6ERJUaFi5BTOrY6LSIYrIBCR0PgYNMCBeJMI4XQpXi5H0P2wpy8ewkDz/8ImvW7MDzLMbG\n", + "lunoWEO1qrC0VMRxklSrCouLo7zwwpPs2JGks3O1/mphYYFTp85RKpVRVUinM3R3dzEwMPCuuy3/\n", + "sryTyUgFiF16HGe1q+k1hBD3AEnf9x9+s1/wla985bXHe/fuZe/evW/7IH9elpfh+HF4j8xavq3c\n", + "fz987Wvvv2QkGAzy4IOf5NChH3H8+Fk0TeWjH93G1VevOlJmMnHGxmqvyUkDFIuLJFyDLZs2MX78\n", + "OBlZpjOVYpNco5HJsKH/Os7PL7Jcn6JVeJWU5uL5CYr1Fp7XTkkF38uQVxs01TotT0XVWth2nDZX\n", + "wvZWP1QpoIGCywk82gnhY1Ihjk+RBpDCYxFI49JCFhUS0kXWynU2qCqmFeBZO0iBLnzW45PGp44k\n", + "dITQESQpN5boCYdIxyMszTeJ4tHyakR8i3y+Qb5YpCoES8Xiasu0LiPHYpiOTeBSC7VpN2naBpve\n", + "pGNiZmaGb37zcapVAQgCAYt77731DdoPVwLDMIjFQhhGnpHTI/hL8/RkOhAIzGqeqZkpurIpCsvL\n", + "TCwssOC6ROM6egOm5+dJBgK4vk9EsQl6LnFZUHWLtPBYtSH8sSy8Q4IshuRS9gL48jRqIEDQj6JH\n", + "MzTq40SDGpIZQvJL1L0WSA0skaDq1C6VwUaQCRIihUSUOtMkqJO6NIcmpCWafhPPB48aOcoIFLKS\n", + "iiokKngUXZ+VlkW+NceRkyGGs1tw/CCK7KL7Cs1SFd90adfS5J06K4tTPPO9/4c//i9f5vbbb31P\n", + "1w1UKhW++tXvEY1uord3deauXi/z0EOP8/u//xmSySSf+cy9fP3rj+I4HtPTZ5mevoimeSSTG6lW\n", + "E0AM3zdYXDzIhQtn2bBhK65rEgpliMXC3HbbbtraIkyOLGHVQ0xMN5ClGCoWVXeJEEFAockEQZoo\n", + "KBi4mDSJCRvZ9xjzWvRoURpeEcv1VitAhI/iOWRREVQwaJDDpkqDOgKPOglimICBwMBGUKXq+xyp\n", + "lkglcwSVELOVMCkzTUfHIOBz+PARXFchFgsTDOYoFpcpl8vMz8+xdm0n5XKOr33t26xbN8g//uMh\n", + "mk2VU6dO02oppNMxNm3qZN26JJ/61L3v6dj/mHcyGXkZ+DfAt4FbgL/98QtCiK3A7wJ3v9UveH0y\n", + "cqV57DG44w54j8j4v638+q/D7/7uasLV1nalR/OLEYlEuPXWD3LrrR98w2vXX7+DEyceJRpNouur\n", + "05ZTU2fpDMvs2rMHz3GQKxXioRDdQnDGdgjo0+iBRaKtOfZ0RzHqAWZXCpieR1P2MFwVXcmhYCEp\n", + "JhUlQ0xdRuQlUIO4fouav+oJmsLHoUGSEgYyPjIWZZKX7Olb5HGYAmySQY1uGghFx0Yw6fsURAZo\n", + "x/UjSMhohHD8Ip636iyqiEVsO42mhOjKpijPThLRlhiUBbasUmqaNHyXv/jOY9xzz4fZdm0fkjTA\n", + "9LkxokLg2C3yjTFuuPsOtl911RuOX6PR4Ktf/S7B4Hp6e1ft41utOt/4xtN84Qtp2tvb37nAvgUL\n", + "Cws88cSzTEws4Tgm586NYBUDhIJB8MF0TFJJmfZIHxfyeWYDAXb09PCv77iDhx56mJeeOItj2wRU\n", + "lZZjYxpLdOtNbNVDaYTQAylsO49j1gnRBsLBFg7hQAJXChANt4iHHQzbRY469GbbUVsFisuTeG6T\n", + "aMRHUkLUa+eJC5UAEjUsII9PH+BiESaIjoFJGIlBSQbXYpkCJk2ykoLtSVS9ZeIix4pvo/rguA3S\n", + "UpU+EjRaJWQRIBFOsWwW0esF+rMdlC2DvA0DuXaSapD56an3XBvnP+XMmXO4bopo9CdeR5FIgnI5\n", + "w6lTZ9izZzfZbJYvfvHzzM3NYRgGzz33MmfOVBkdLdPTM8TIyDialkLXk1QqyywuTpFIyGSzGRYW\n", + "TnPPPdcyPT3P5quvZfzkeZSFJp5jYbsuOhqCZQQqQYr4NPAJoGCTwyKp6YxbPsJfYcVJ0PIUogJU\n", + "4VD1Z4iQx0QQxUUAg0AEj1eossQ0LVRsYnj4CGaIKTXSeheeohMXIU6W85TkNk6fnqRWe5pAABYW\n", + "likWY2zdOkgsluXsWYVsdgulkiCRyDE8/AFOnTrIgQPH2LbtI7zwwlMkEtfQ0ZGgUJhGkjoYHa3w\n", + "0kuH+OAHb7pisf15ecfmb3zfPwYYQoj9gOP7/hEhxH+/9PJ/A9qAp4QQj75TY3g7+da34N57r/Qo\n", + "3hnC4dVamL9/a2Xu9x19fX3cfvt2Dh/+e/7hH/6Cf/zHv0KS5lm3ZR2yLDO8cSOuEETDYQzXZbC3\n", + "h5t3rGdgOMeWaJihVBrFVwgqEdJyG46XR/IdPGwQChXTRgpksZVeSpSYt8uUPReLVWEjjTpRlggx\n", + "RYpZ+pkkSGFVZFzqI6ZcQ1jZSUjagi9itJJZuvv7ORcMcUqKIoJZFFkjQJ44NnEUoujILCMpJQKa\n", + "R73xPOXlQyyWz1P2xhjwClRqJkUjiKG24ek51LrEYl3lYx+7nfb2Bh1DIeyUidZt8aX/9EU++9u/\n", + "fdlCt5GR85hmjFgs/dq2YDCConRw/PjpdzGSP2G1KPlbLC/H6O3dQ3//zcRiQ+TzJ6lLBpPli8AK\n", + "29Z00N/Tg4jFeOAP/oD7P/c5urq6+K3feoBERwtDWWS+OYWlzjMQr5LTQRVT2HKejVuSXLWzg2Co\n", + "jhSII6sZLEXBUnVCQY9EtA2PAN3pIXrDObZ1bwdHJmo16PNNtuI5NTAEAAAgAElEQVQSrc/RaY+A\n", + "O4vHNAGKpMni0wBcVBoIIC7p5ISG7BnUaSIDJSFRkYIklHZ0f4mz3hlMfwmXFWTytIkoMc9HNAqr\n", + "7keShxRto+hLXKgWsSyD9qDHFj1MoF7hyUe+C0ChUODAgYPs2/cc4+PjeJ53RWJ4OcrlKqr6xoRJ\n", + "08KUSrXXnkuSRE9PD8PDwxiGg2U5SFIETdMYHOzG8yoIEcU0J5iZeZJczqRYfJVbb93ANddcTV9f\n", + "J7mOJNt27ybT3U+6rZv29h5EQAMpQ0rpZTDaf8lNxiaJBZJg0XEoyioGPkWxRFmuUKJIxbvIRn+Z\n", + "dXj04hIEgkA7oAO7MEgzT4Bj2LxCSLxEm3QGyVcYNxo0PZsVu87FegMR6CEaHWB+Hs6dMygUTKrV\n", + "IlNTY5TLRXxfxbbLxOMxKpUGAEIEWFhwaTZrGIZMMLhajxUOp5meXiCXG+KVV0694/F7O3hHW3tf\n", + "38576fkXL/38+Qwx3iMsLcHhw6sFrP9Suf9++MpX4AtfuNIjeftYWVnhxRdPMDCwi+HhMLZt0mrN\n", + "MNUYZahSobOzk8ratZw7f57JRoO1fX2MuS5rhoYoLy6iCYGPgSzLxGI5yqU6NZpgj+NaKWpCRm/q\n", + "5M0lApTxMWmRw0IQoYRghSSwSTJRJJuGp6J4MnnCyEoPshJBwgNJJ5yOk+6YwVY9BoIh5nwLq+Ii\n", + "u1WCko/jBZHIoCLwWCGWUvBEiJgzzYZcDFnTuDAOsy2fFTeAqkcwFZ3ecDcrrSJTkyvs33+YYDAM\n", + "mKTTAW66aTe7du160zXlWq2OLAffsF3XI5RKby3j/k5x5MhxPK/9Na0SWVbYvPl6lsdP8+vXdnBx\n", + "fJyQZZE3TeZLJfw1a/jg7be/tn8mk+H/+r//G3/xX/8rL333u4SFwI9GWZPqxa/VUKNbuevDtxMI\n", + "RDDNbzA2No/rxLGdBhHdJxUNEwkJStV55uYm6evs4+LEcTLNFp2pXubLY8Qti6ArCKOTUjqpOkss\n", + "YOGjI7Cp0CDDquS6K1xMWSWshWi1qkxgseAHWXFDKLTQcBEorBE+CSWI7cs0fZ183UTTLdxAmnja\n", + "YrniIiSZrkgUhQYZHbrDcSK+x8lyieeee55nnz0OZJBljR/+8CxbtrTz8Y9/9A1Gk1eC3t5ODhx4\n", + "Gej/qe2tVoH+/suL8w0P93DmzFE8b1XrNBQKEgjYSJJCV9cWBgcVdN3m3ns/yPZLJlxbtmxm//4j\n", + "mKZGV08aWc4wNX4CqlU0pR1VtomoATQ5zZw7v1q547lUgBIhPNagBGP05YJUp1/kBgd0VFTfoe77\n", + "OKw28tdQLzX0O3RgEpQdVhSFgKzhOBFmHcEkXRS8EPXmMnJkDapm0moZaFqaUCiA59VptV7CMKLM\n", + "zJzANCWiUZ9MpodS6TyPPfYwxeI8lmVhGE18/yefY9/3EUIgyzK27f5cMbBtm4WFBYQQdHZ2vuu+\n", + "NVf+LHwf8K1vrc4cvMdnOv9Z3HorPPAAjI2tao/8S+C55w7i+1309PS/ts22uxkbq/LKygqFQz+i\n", + "1Wjhx5Pc+MlPsmv3bvr7+3n04YeRu7sZO3qcarNCqdpC19rw9SRNuQvPzWNbs+haJwqTaO4ig3Rc\n", + "qqKvoyLj0ETFQkgSbiyGUBQQKlpdoBoBED6qFqFpVQgEdUIRmUCii3h/F8eOHMJtXiRopZFFiyBZ\n", + "KkzS4iKSqNKj+dSbPrJVYWdPho5IhM1dXeQXF3EbPr7aQSzeQUgOYlgWciRBteXyve8d4J57HmTT\n", + "pqtwXYcjR0aoVB7lgQfuu+zx6+rqwLbPvmF7vb7C4OCbF0O+k0xPLxCN/vRaYjKZJBDvpliv8rE7\n", + "7mCxWGSxWCRsmvzmH/7hG5Youru7+dwXvgDhNAdeOIDfqOKl0/yrz3+es+cLRKMpVFVj1649lEov\n", + "YhglNEUnqmaRRBVBE7m5sKoGY6cp5WdItGxa4Ra5gE8VFSQZ1RP4AZ+wFCRpmRSZxCKFBCgsEZKb\n", + "jHguIV8mYJmUPJMSEdLSWlxkSp6NRZag2iQWiBORNITkYrdaWHIES67T1bcGTYtSsV6hrk7hOhGG\n", + "kxESksLY0jzlZpmuTYN885uPs3nzR9H11WNRLKb45jef4ODBI2zfvpk9e65h3bp171YY38C6devo\n", + "7DzMzMw5crk1ACwujtPW5rF+/frL7nP99Ts5fPgUExOTVCoxGg2L5eUKsdhq59mqzmk73/nOPgYG\n", + "Bjh+/CQvv3yS0yeOkZ+bplJoMrVQIZYYINe5ntmZUSIs051bR8WaRql5LKEwT4AoAgdBmxoiHkpS\n", + "yM+jeBKLuoJs26gOFIE2FHwENiFCyNRxaMktEopEe38/M1WJdGQHQ47NeHEWLxhGmFFCoTiDgxqT\n", + "kzMoSoBWqwisMDg4SCzWT71+hlQqRzq9ifPnv097+xZisS20WhdptUY5efIIkuRh2y1UNUijUWDD\n", + "hn6Wlqa47rrLH7/Xc/78eb797acwDA3wiUZ97rvvbvpep8r7TvOrZOTn4JvfhC9/+UqP4p1FUeAT\n", + "n1h18v3TP73So3l7OHt2nPb2XT+1TVUDNJvQEkEiA7cR1UOAx/RMiQ/FYqiqyvrt23nkr/8GUdOw\n", + "/DSKWmextsKK6rJ587UU5qp4To6kHqHVCFF1PSpGnoC/majwkISGS4WyP0Y447FjaIhEOg2SxGMv\n", + "HSNkV6lJKzTcFtFkFE2TqVRabN06zOysSrXQwZpuhcL8GG7TJu0tEtMkkFp0BCWMRoNlT3B1SGGj\n", + "olCtVnnVtrlx7VoeXjlKznGRXImma2LJPmY0SaNRo7d3C/H4aiugLCv09m7mwoWXmJ+ff60q//UM\n", + "Dg4yOPgKExOnyOWGkCSJpaVJUimTLVuujIJje3uKubkSsdhPxNaEEKzfPECiw+LQwgKKECidnXz6\n", + "Ix+57MX0xImTPPzwcyQS13Df/bdRLq9gGJPs2rOHweElnnjiRwSDXbS1xdm8OczZs2dIp4dwnCIB\n", + "xUb1Kty6ZTMdsszFyhKziyXiskVQSOi+i0mAtlCE5cYKQadJKNiDL1lYxjRlqqgCYnKRcLiPqNJL\n", + "xaxQtVrUsdCx6dFStHwfYZZpILAQLLgV4lqKeDSJJUHJaVILBQiFdPywzR/84WeZHz/P+W8/QqO0\n", + "SMEOI2SdWHYdS0WD2tgiO3asFrwVCgVefPE4ntdNqdSgWEzzt3/7FPfeW+eaa65MN42qqnz2s5/g\n", + "hRcOcuTIIXwfrr9+I3v2fOBNiy+TyST/9t9+ht7eH/Doo/uYnZ1GlkM4jkZ39/X4fpbR0UUc5wJ/\n", + "/ud/iW3nmJ8x8fNJcqEQCeccV6eyjNWb6J1REok15Ocspmrn6YwGOG2mqFhpgoSQsZFECxFw0X2P\n", + "EBIyCsOxdmbLs0R9l6AnwAtg4yALgfAFVWVV60NJ6Vy/axdHzjQxahH0aBxVz2Imk5RKZ1HVEMPD\n", + "V1GpvIqul1EUjXQ6x3XXbWdysoDjSKxbl+HIkUdQ1Q4ikU4mJk7h+01SqU7Onz/P2rU55uf34/sx\n", + "urszeF6ZRMLgxhvfsjSTfD7P1772fdLp7bS1RQGo1Up89auP8qUvfY5oNPq2x/ty/CoZ+RlMTMDo\n", + "6L/MLpp/yv33w2c+A3/yJ+9vR+IfEw4HsSyDYPAnmiWu6zAyMsqtt36S9vaffAEvL8/w9NP7uemm\n", + "6/irv/o79l8wCLQcQpaFIoMRTdGWipMMz9A/HGB0JkitYGM7Oo4IYok4SRFcVdoUPoFACFn0ouU8\n", + "RDpNNBrFNE06ImHisqCrZy2RSCeNRpWlpRUUxaSjo5+FhVnCSoxqrUkiqNPwGth2g6TwcDWZhiuh\n", + "qDJ9bT0EGzUqVYuAZoHv097VRWdHO2OFFqaooYfiOJE4gdQw3twLXHWZIlUhopRKpcsmI7Is8+lP\n", + "/wYHDx7i8OFjOI7Ldddt4MYbP0ww+Mblm3eDa6/dweHD36ReTxOJJCiVSoyMnEDXF7n7o79DW1sb\n", + "lmWRSCQuu/zkui5PPLGfXG77686LACMjLb7wha/w0Y/ezp13bqNcblCvt7jzzk/T0fG/cebMWQzD\n", + "pqurnae/9S3WqyoXDx/mtuEewsKkOjaGaDapOQ6WLxB+gClHAmmZRKOO43vUVJ2OxHoGs0kuTD5P\n", + "TM6gShBWYtRaLogIrm8zZtYJyB14UgjHK+F5VQwtx4hVIVVqYkoStZjHb37pQTZs2MzQUD/9/f0c\n", + "P36cvzx+guL5PKloO51dXaghnaPFAs1mkEJhnmy2mzNnLqDrbQjhIUkGyWQboVCUH/zgINu2bbli\n", + "rdvhcJi77rqdu+66/We/+RKZTIbPfvbTfPazn+Y//sf/zKFDS3R27kWI1djrepwzZ85w4sQyN954\n", + "A2PHLrKmvRPXcTgweoHeDVmuCdv8qDRNV9d6QqEoczMvYZs1tPh61rga9YZJFBnHsZlrLBGywcOn\n", + "6QjOLs8wFPAxZBnhyyygsCJkHAFNLLxABNMzEa7LzOQkphugt3eIlXyRml0mG4/j+2EWF1cYHS3Q\n", + "aGiATEdHhkDApa9vLZp2kdtuu5ubb97N44+38dxzC8zMnMXzNPr6NqNpOq2WjevO8OCDd2PbNuVy\n", + "Hd+vMjg4QKlUIhqNvqnA4IkTp5GkHKHQT5KOaDRJqZTg3LkRrr323fEm+lUy8jN4+GH4jd/4lyV0\n", + "9mZcey14Hrz6Kuz8+T3U3rPs2rWdxx8/RX//jtc+iJOTZwkGo7S1dfzUezOZLk6f3sf4+BwjIwVC\n", + "0RswVZ2aVcH3DXKZJEF1hYg9z7n5FngaihLGsjx8L0jJA08YxBUNw3OoWHlinUnKwuRUq8XJfJ5K\n", + "tcao0WDTrnu4OD7J5OQkjuNRrVZpa+tEVcOUywXyy7NEZYEphQm7VTKeQQwXw4A516YRybDWD+Bq\n", + "Jqbr4psusmxQaTZJJUOsHepledmmbMvEtAC6dIFf+7XdRCJvbAXz/QbxePwN23+Mruvccstebrll\n", + "79sam1+W9vZ2Hnjgw3zve/vYv/8iExPzpNNZ1q/fwl//9RPs2jXM3Xff8aYX3lKpRKslyGQiNJtN\n", + "zpw5y5nT4yRT/fh+O8vLUSYmjvOpT93Cxo0bOHfuHPv2HcD3fbZtW8eGDRt4QdfJpFLke3uZmJmh\n", + "IxbjhOPQNEwygShNx2bCtxBShoS3SIQwshwmI0k0jDE6O+5kudWN78fJ111akk/eB10Iyn4QXQSI\n", + "qGEs16FhCRx/BSFpOGofo2YRR2rybz77SX7v97742v+1srLCU0+9xIV6iCZh0k2HmYtjJNcMcNVN\n", + "9/Dssy+xsDBNKtVBsVgjleqkUDjL2rWrM0eBQBDLUigUCnR0dFz22L3X6e/PsX9/5bVEBMBxbHwf\n", + "HCeCYRhoQiAQ+L6PKiWYnJ9BM3xqrkSqaz3B4CJqQMcSgngoTH3RxBMyVa+JhY3q+yyYY6i00xCC\n", + "Ec+mZri0awoTnk1JJAiqOVYkiQZ1ekMwFFZIpwI0Ck0KS1MYlqC38yo2r1tDsbaErg9x5503sLIy\n", + "j+8rjI0dRlXj3HTT3czOnqKtzefjH78P0zQ5c2aUuTmHSiVKIBBkamqcNWvWk0gkSad1hoYGWVrK\n", + "c/Fig2Cwm1OnLH70o8f44Ac3cvvtt1z2uJVKVQKBN4qkKUqIarX+jsXrDX/vXftL70N8f1V/46/e\n", + "N7Js/zyE+InmyPs9GRkfH2d2dolGY5yXXhqjo2MtsuwQiTTZtGnwDV9WjmNRrVaANM2miSSpSK5K\n", + "JNSFabdwHIeK1SIa9DHtMBFKlBtncL0EDSeGi0dLb8NwbQwxjx5ai2kFSHe1c2zhFKYhSMaGUFWD\n", + "fT/8IaFQH/F4Gll2keUk/f07OXnyNMWZQ2Q9h5jdpEKenBYgLOI0cVDae8mZMmW7hhbqJV88jR6K\n", + "YDarXKzWmS+VqKUGuPrqu2k2XRYWZpCkee67715isRhPP32MUChKOBzH8zwWFkbp74+956zEfxZD\n", + "Q0Pcd1+QmZmH2LHjTiKR1Q4Cz3M5ePAVNm5cy+CbeKrouo5tNxm9cI7JMyMsT0wTEBEKldNIsRKp\n", + "VI5wOM6TT+7n9OkRjh1bJJUaQAjB2bOH6O9/lXOzszzxyCNs7ullw/AwbqNBZnKSU2GBHu+maTXw\n", + "KiXk0jJhP4IqB1CkAIGggo7F4WPPsn1rN+VSmJJQUYIR/JaD02rhkcfxBmjYFr7nYkoNfFkib1eQ\n", + "PB9UmUDQR1VVHn/8+1x99TY6Ozt58skf4jhdbL/6NkbCRRQ1hGsaiFiAzs5+hofHqVQusrTUjmWV\n", + "WV4+Ri6n09MzDKwWPHqedcVmvH5ZlpaWGB0dAwS9vd2Ew6dYWholGEzh+x6uW2FgoAvwURSFfL2O\n", + "Lnxcp0HNmKFVLdCf3UwomkWSZGZnR7GsNZhOg2INDHMRz3Xw3TgeAg8PDYmUUqBbCyJpXUxWJph0\n", + "DdK5HLqXJhLqoGE0UZpNkqpCCR9F34jTFISCbZybnMAIaWzuvZb8RIHt2zeyZcsmhIBGo0KlcgPV\n", + "6gn27u2mq6uddevWoWka3/7246RS21CUA8hymnC4A8MoMzFxms5On8HBazlw4DD5vKCvbyfl8jKG\n", + "0SAc7ua5506xadP6y37W+/u7OHbsxGtF4T/Gsor09Pxy1g+/DL9KRt6CQ4fAtmH37is9kneP++9f\n", + "9d75sz9brSN5P/L88/t56qnj1GoaExM6y8sXmZm5wG/91ie5997P8zd/8w2Wl6dpa/uJOuv8/AXW\n", + "retmaSlAOJykVMrj+RkggCxkLLuOLK1QqTXpQmKovYeSJJhbush5bwJXbUNVE1hSA8XtBlunWVri\n", + "yMElDAeSWo32UhXJlWnzw5QMBZHoxfcXyWZrRKM6o6deZb0eQJaTmI2LhH2fqNlkxXOItK1haHgH\n", + "U1PLlIs1Gq6NEskxKkzmrBqBXDtrrv8gG9LX0dnZj+e5OE6LkZEK/+N/vMTOnRswzRorKy9TLMbx\n", + "fZstW/r58Idv/4X8Yd4rjI2NE4sNvJaIAEiSTDDYyenT5y+bjDQaDZ79wQ+YP3OQ88cnyaS6kf0Y\n", + "6ViKYn0KYa5w7NgLtFomZ8++gBAp2tt30Nk5z8aNa2m1QvzRH/4FEWeZNk/lxXOHORh6mTXbNlEM\n", + "x7h6YDfd2X4Azk0d59yhp0gpGSJBDYGEYXtYNCACbQM5JssTGOF1+ATJdu9g/uL3CXoWME/NlbBp\n", + "EU4k0fQhdL2DSKSdWm0Zyyrz8suz+P4gL7/8Le65Zzejo/P09OwhEAhy4cIk0eggiYRGsThGqVSg\n", + "o0PlvvseZGZmAUlKMTNjcNVVt6yK4QHz86Ns2ND1z5Lqf7d57rkXeOaZ4yhKFs/zmBx/CWP5KIlg\n", + "jmZZkO7bzPard7O4eIzZ2Qn27TvASgVGT++jU2rRq9QwWnXOLpwgs/VTjI//CMPQ2bx5D/n8aSYn\n", + "VjCa/bjOFFkpiOIFEAjquHiiTH9yJ5oSIeh5rFglhDZMT6aNo2OnUbQ1tCccEvEIU2WV/IJDrj1D\n", + "W1sXmaEN6DmHm27qIxwOs379T+qvIpEEiqIRDndy5523vra9Xq8zPr5Ef/+NVKsN9u07QKNRAHws\n", + "a4KdO/81lUqBM2deolrN8uSTB9H1LJlMN5LURJZLnDp15rLJyObNmzhw4CgzMyPkcgP4vs/Cwhi9\n", + "vTpr1qx5N0IJ/CoZeUv+1/+CBx/8l1E/8fMyPAw9PfDss3D7z790+56hWCyyb99RZLmPixfHiESG\n", + "WbduK0tLJ3nyyVdpb+/gYx/7CA899A9MTS0jRBDPq7J+fZbrrvsADz20j+7uHly3zoXyaeqtGI5r\n", + "EA9XWNsdZGF8lo19O2nv6CCYCNM2OIh67hhzajdDG4fY//zTROQU6aCHZGu0bA/NahLWMsg0CMpZ\n", + "VKmBJMp0dcVJpTZQLL5Eq3UKapNEAnH0SAsv3c3IskvBNnFsk3A8SzKZYGGhgBPrYgLI5+vE40ME\n", + "uraw9bphTp89yUc+stppMjMzysREic7OPZRK47S1rSOZ7MU0z/Hggx8jEom8L/0rfozneZdNooSQ\n", + "XrOQfz2+7/Odr38deWaGO4cHSU5NUzMWOb48gk2RzoTOYsXj6JFxLEdnaSlANBqnszPNygrs2/ci\n", + "J05cQDbTdEUj9ES6sO0W5fJJJkbGMbMdlKbPYDsWiUiK+ZVFHF8jqIaIhEIE9ACu6+LUTTKdKX7v\n", + "j/8YwzD4/d//z4yPzxKP9zG8dRsz4+O4Zgw9JBMJa8STSQxDZ+PGbZTLBTyvi0ikA8epEgxGSSR2\n", + "8NhjL+C67iXzwSzbt2/k5Mlj+H6cSmWWYtHjk5/8EJs3b2bz5s3cdtsH+d73nuTo0UNIUgzPazAw\n", + "kOKjH/3QuxG6fzaWZXHw4EH+7u+eYM2a3WSz3UxNnEYv1NkajhEJ+SCFmJp7lfPBMrfc/gEajSqG\n", + "UUX1pxnUPVTLRVEE2fY2suFuphvnEEJn69bbUFWVbDaLLPscPQpRkSQdDeMaJqYhEbey+LKDIxQc\n", + "s4rrqXQmhmhlIqQG17NeH0BVQ6QCkxQnx7GNBC4KxaJJteZS8Jts6t7A+fPjnD59nlJJZv36dSST\n", + "q4JvKytT7Nnz051Nq+f06vm+fv02ZmaqeF4IVdUxjNXl11deeY5sto/FxSKStBHTDFOpCIaGtjM9\n", + "/QrHjp3izjvfeFHXdZ3Pf/4+9u9/iaNHDyNJEnv3bmb37hve1bbvXyUjb0K1uupFc+7clR7Ju8+P\n", + "nXzfj8nIzMwMnpdgdHSKSKSTQGB12jkW68W2Z3jhhaPccMO1fPGLn2diYoJ6vU46naa7uxuADRtO\n", + "UK+b6HqdweENzEyMEVJLrOsJ0dMRRKnGKBhFzpxrIkgBMnk7gB6q0te3noi0j45AFAkwXBeQSAqF\n", + "ZmsRtBABPYFh1El4No3GMm1tgyhKhN7eFPZCkGwoQDTczcmFCtHMddRKoyhujXK5QLmSR08HMEWM\n", + "WtUjlL6agbWDXHXVejo62hgZucDY2EW2bt3CxMQ4kUjfpfVz/9IxSDE1pVOr1a6Yeurbxdq1Qzzz\n", + "zAlcdwBZXr2M+b5PsznPxo1vPHGnp6epT01xXV8fF8fGWNfTQUTXiY7azPo1dC0OJJGI0WxCV9d6\n", + "TFNjdnaajRu3c+7cKOWyQ0ZWkDAvLQF4QBbRmMGJaUwswdTiDO3JAiulGQJqlBJV0moMSUg4kkve\n", + "twiHNcrlMvV6nZ071zIzc5JwOEM4HEWWIRCIk0j0YxhzjI0dIZ2+Fl0Ps7JyFt9P0tWVRlVX1XDj\n", + "8Qy+H6GtzWN5eZpcrp+BgU3kcn1cvHiCRKKL//Af/t1PGU8qisK99/4ae/cWKBaLRCIRcrnc+2KG\n", + "bGlpiYce+g7Hjs0xN6exuHiEtrazOIUptibaaaoBBgaCpNMpdhgG44AkKQwMXMfWrSmee+S/s63v\n", + "KsKhGKXSHJJUQw/0INvG/8/ee4fHVZ55/58zvWm6ujQqlixZtmRbrtjYGIyxMcamBwgGAkuAbJZk\n", + "U678tr0hV7KbvHu9IbvJbhohJBBCMaH3jjHuRbZkFatrVGfUpvdzfn+MkRE27rYkez7X5cuaMzPP\n", + "ec48c858z/Pc9/emX9ShVCrweAaYOdOBw5HFoYaPUUbl2G0WlDItba1NCDIBdSJB72g/GiRkci0G\n", + "nRJjuh2z1Uw4qkIUFchUCZzDe9ArHKhkGiQJwsgJijp27apBp1vI7Nkr2LlzL62t7cyeXUY4PIzd\n", + "HqO6erwwTEtLw+GwMTjYi92eyyWXzGXHjgOMjAyg13tpaHifkpLZmM0G9u1rwG5fgEwmx+8fxOfz\n", + "otWacbuDxGKxYxocpqWlcc01q7nmmtXnaSSPJiVGvoRnnoHLL4esrInuyfnnK19JGqAFg1PPW0Uu\n", + "l5NIxAgEwlitR9a/JSmBWq0hkVDj8XjIzMyk5BiGKrfeej3Tpu3mww9ldHV1MWdOMVkZJgrzsjBY\n", + "rRx480227ehCIaajkKuRpDh52XNoDxzi/fdfRJeI4w31okJNLB4jjpxI3I9MHEYhaQERtVpFMOol\n", + "HgszNOSkvX0PPl8WKkMlLinA9voajJqZpGmsuDRZxPUaJJWSNw7uYsbCK6ialsGBAw0sW3Y5RUVF\n", + "qFQqEok4FouezZvfQKNJEAh4UasV+Hwj2O1pY7EAgqAgFoudr+E4Z+Tm5nLZZRV89NFONJpsBEEg\n", + "FOpjwYKCY04tj46Ooj/8Y2uz2egURTI0GuZOL8XX209zXxcRsYSQ3IfZnIPDkUtLy26iUQuhUABR\n", + "hGg0RoReZHITo7EhEokECkUawXAUtSqbhYtX0tBQT4AwSl0eIm7CehM1wQEEMUZAhKF4kEUmB7/4\n", + "xeu0tnaSlqbEbrcgihI6XYI77rgHj2eAffu2MG9eJkuWrKS5WU447EShiJKTY8dqtTMy0jmW/SBJ\n", + "IldeeSlvv72Fzk4ParWJaNRHdrace++970srYNtsNmw22zGfm4xIksSzz75KIuHAbk8jEAhjNNro\n", + "69uPyuNEbZ5LWJAhCLKx7DCX04nbPYxaXYRSqUKnM2I0WJDJZMjlasrLMnB2u/AMDqPNKKW7exsz\n", + "ZlQybVoRfr8fs1VCCMTQqgSUigQzZjjYX7cFgxQiLkrECIAYQ222Yi+ehSbNTFdXH2BEFEPEDOl0\n", + "D7egk2dj1Jqw2QqJu0aRYl1Mn16NRqPHZsviww9f5oMPnmPBgksQxSx+85unuOOO9RQWFo4d/4YN\n", + "V/HYY5twOkfRaExUVNiJRoNs2PBV/vrXl2lt7aG7W0U4HGRgoAajsYBw2M/gYAuLFs1Eq+0jkUgc\n", + "U4xMBlJi5BhIEvzmN/Af/zHRPZkYsrKSmTWvvpoUJlOJoqIiNJr3kMvjxGIRlEo1kiQSDDqpqCgH\n", + "BtBqtWMOhV9EqVSyZMklLFlyyVHPxeNx3n/1Tcy2EnKtuUSiUeRyBf0BPxkhDXK5h8HRPnSChyE/\n", + "RCQNcRJIQjsFKj3RKESjrShVCqylDvLmlrNv3ydMmzadFY0yVUkAACAASURBVCtupKnpEDWfbsMd\n", + "SEeh9pBhziAvr5LFl69AJoP6+o9YtaoKg0GHxaKntDQ5lRuNhtm69T28Xi2hkJLt2xvweA6hVPoo\n", + "LCxlzpz5h/sfAzxTLmD1MxKJBDKZbGzcrrpqJeXlpRw82EQiIVJRcTXFxUcHJwOYzWYCh5dvzBYL\n", + "GcXFdLS2Eo3FcBQV0Ce6ycoqJbewiEOHRtHrLeTmFtPcvAWPR8HwcAuC0AYyGTqlBTERJxbzE48P\n", + "EhQEHPkLsNkzMJmMDA42MGvWJXz8zm9JM2jo6U8nFk8jHAuBIsDwsIzm5j4slgpEUcRobAeiuFxh\n", + "mpvrMJkUrFkzh7vu+gput5vf/vYFrNaZTJuWS11dHyMjw2RnWzEabXg8g1gsUFFRQWlpKY2NjfT1\n", + "ucnIKGLGjPJJX5PmVOjv78flCuNwZCOKClpaDgI2zOZSOp0fEopFiMW9ZGUlM4TC0SgJpZKqqul8\n", + "8IETo9GGOacYt8tJhtEKBMnKKsOUkQHBIJetXcvHH+/E65UYGOgkFgtQMVPA1S4nI8uMUqGkp7+R\n", + "/Gw1/qiFQrsFoy6XLpebxkCCrxTOQqPRUle3n8bGbVithQiyKuS6FjzhHrLTC5GrooTDDcycWTxW\n", + "LysaDSMI6eTnF1FdvRyNRoPfP8qTT77C97//dTSHC6JlZmby0EN3U1t7kP7+QbKyZlBZeRN799Yw\n", + "MCCgUs3AZEonMzOA369FLh/GZpOzdOkczGYdNpt9rC1Iirv6+nq2bt2Hx+Nn+nQHS5cumjCBmhIj\n", + "x2DzZgiFkoXxLlbuuCOZVTPVxIher+e229bQ3f0YDQ1bMRrzkMm8FBTY8PtdyGRDfPe7D9PXN0Re\n", + "XgY33LCaZcuWnlQWgUKhYN6y5TzfvZdevx85ECZKblkZPftqmDVrCZ2qNHx1e1CpBOLKKP5APz6t\n", + "loQ1k0Q4giAbRMpKJ73MQW5uFI/HjMlUzYsvvoEkmckougR3YDdObyfWIi2rV62itaWWQzVb8A23\n", + "UJAR55a77qKx0YnHM4jJZKet7SCjoxq0WgvXXFOJ0ZhGb28h9fXvMG3afEQxyuBgDz5fJ2vWzMdo\n", + "NJ7wWCcTbrebd9/dTENDBwqFjAULZnL55cvQarUUFBSclEukw+FAn59PU08PJdnZzKyqokmvZ0tL\n", + "C3MXL+bapSqcTjW5uSV0dHyKzzdMJBLFZJLh89URi3WSl2egt3uQes9O0iWQxDg+WQh14Uws1iIA\n", + "BEHCbrdRWVnF0OB8Og61kJtTilyuoN01jE4+D6fTiVKpJhJR4ff7MJlkXHllNb29HQhCJ7feejvl\n", + "5eWoVCocDgdf+9o1vP76xyiVo2g09ajVBjIy5tHZuR+dLsDdd9+AXC5HLpczZ84cDjufX3B0dXXR\n", + "3NxJf7+GzEwbeXkmurvbUamMJDRmajoPsHxWETabjXA0Sm13N3PXrGHeggXs3duI09lIfslc9g90\n", + "0tNWw3SHhV6/nxGlko0PPEBubi4LFiygpaWF7u4+jMZC/umfbuKdt9/mzedfRhaL4w+1kdCpycxz\n", + "EFRpUdlzSC+uxNPeRWvrQex2GxqNl8zMDAyGDEZGnOTnz8VqNeD3H2D27DK83mZmz16A3+9l795t\n", + "bN/+CYlEGhkZR4z8DAYzQ0N62traxlXINhgMXHLJorHHiUSCzZv3Ul29gq1bDxKLGcnPn0l7+wE8\n", + "njC5ucX093ewZ89+Zs6cxh/+8BSrVy8nPz+fDz/czNtv12KzlaDRONizp48DB57iwQe/OiGCRDhW\n", + "sNdkQBAEaaL6dt11SSHy4IMTsvtJgc+XDGRtaQG7/fzsUxCEYwYfng4ej4fnntvEjh116PUZh6tg\n", + "9hEOa/F6teh0efj9oygU/axdO4P77rtj3F3D5wmFQjQ1NTE4OEIo5Gfz5nas1nJisRgmkwmFQsFf\n", + "//ob1qy5Dqs1kzde+gMdB5vQyPUEJD9Fs+aQEEXioRFmzMzgB//8faxWKw0NDXznO79AEGYyMBBC\n", + "qTShUiUwGuU4nbsoKJiJUj5MqLWWDLkasyGB3qwjbJJx27cfYsuWA4RCBnbs2IFMVkB2toWFC6tR\n", + "KpP3GC0tW5k7NxOvN4LRqGfBgqpjLk1NNMcbd4/Hw//8z5OIYg7p6fkkEnH6+g5RWCjnnntu/9K6\n", + "OsfC7/fz7htv0FFbi0yS0NpsXHHttZSUlBAKhXjyyU10dAQIBATeffc9vN5hFIp0EokogcAAarWD\n", + "qG8UWSKIGHejFdzY06zoCkvJKrgerdbC0FAnc+cWYDJp8Hh2I4p5GAw5yGQCTz/9CkplOT5fJx7P\n", + "QWy2KlQqI6HQIe6++2bkchm5uUE2brz5qL4n42GCyOVy+vr66OvrR6/XMX369CmXjvsZp3K+b9++\n", + "gxdf/JRdu5rQ6+cQj0cxm6G0tJCmpjpyc0MsWjCTvuZmFPE4CYWC6ssuY+myZchkMrxeL9u27eLA\n", + "gUMIAqTbddiMadiyspg5a9YJBbrf72fT00/z3p/+Qom9ArPBwkjAS2csTMXyGxgYaGTp0kLy8/N5\n", + "442PsVgWIJerGBhwUVPTRCKhxettprLSgkYTR5Jy2bx5Ox6PgVAIwmEZKtUgl146jSuv3IBMJqez\n", + "s46bb549VlfnWASDQX7609+Tn7+M/v5+amoa8fsjDA+34vU2UFKSi1abw4IFV2GxZDIyMkAg0MzG\n", + "jWt54onXyc1dMhZzBdDX10pVlY7rr193coN4ihwe82MGJ6VmRr5ASwt8+mkygPNiJi0N1q5NVvL9\n", + "+7+f6N6cOiaTifvu+zvuvDOCx+OhpqaW11+v49AhF3Z7FYIgoNfbGBqSc/DgKAcO1B7TadDlcvHH\n", + "P27C59OiVKYRiYzQ19dEPC6SlVVGOOxlZKSL+fNzDteFULN4+bXEhByUykzMZonLLkta0judDaxa\n", + "VYjD4SAej/POO9vJyCjA6Qyi1dpQq42EQj4ikSB2u5zR0UZ8zoMsTM/BaFBQVDQTuULJvuad/PqR\n", + "X7NizdWYTBoGB41kZpaTk+NAJjtynqtUKhYtmv+lnhtTgd279xEOW8jPT85+yGQqHI5ZtLfvpLOz\n", + "k6KiopNuy2AwcP0ttxBct45YLIbRaBxb0tFqtdx771dpb2/n3Xc/wO+vRBTT6e4Oo9Eo2LbtTWJR\n", + "C3kGHQaFnJzs5fQON5KhakMS/Didb6FU5mA2K6it7UClCnH11Qvp6FCSmZlxOL5ETiDQhcfTQSSi\n", + "xeuVkKQ2JKkDUQSfr4P16y8/Zt+T39fktH5RUdEpHfdUx+fz8frrW3E4FqNS5bBnTw1KZS4ulw+N\n", + "ppE5c8x8/esPYLPZiMViBAIB9Hr9uNgIo9HI6tUrWb362MZfJ0IURTydnaxfspjaul4EwYrVYELy\n", + "SzQd+ITiGdlce+06VCoVH3+8G0ief/n5eaSn23G5XHR1ubn99iuprq7m7ru/gdsdwGyejiQNIJMp\n", + "sNkWs3PnZqLRIDZbFmq1h+zs49eU1Wq1GI1qAgEvWVlZLFwIH3/8PiZTHhqNnpGRAEajBb3ehCAI\n", + "WK1ZxGJRXn/9PQTBOE6IANhsuTQ07OP660/rYzojTv624jQQBOEXgiBsFgThv76w/R5BENoEQXjy\n", + "XO7/dPjVr5LpvFM46/Gscddd8Oc/T3Qvzgy1Wk1GRgYDA8PEYiKCYBkXUyCTaREEPY2N7cd8/wsv\n", + "vIko5lNQMJucnGKKiuZRXHwpOTkCmZlesrL83H77En70ox9gtwfp6NhDNBpGLh8gEmmjqmoGoijS\n", + "39+BTudh7tzZQHL9OxxWMm/eEqCLYLCXeDwI+HG7D3DNNTeTmakn36anoryU6dMrUSpU1DrbaHGp\n", + "aaxP0Noqo7Y26VESi42OEyLBoA+1OjKWJTRV6ejow2RKP2q7IBhxu92n1aZOp8NkMh0VWyKXyw/P\n", + "HKmpqFjK6GgQuz2ZwqvX5yFFh5FLIIoy/EEvaoUGe34+c6ZlcfWaGZSUJBAEGVlZ06moWMnBg8N0\n", + "dOwjFosiCDJsNhMjI41IUjrp6eUkEiLRqBJRTKOp6X0WLy740qJwFzNdXV1IkhmlUk1+fimXXbac\n", + "nBwRmy2EwTDCTTddRWdnJ7W1tWOlAM52kObg4CAGQaCouJDsbC2DQ+2MjLpIhH0M9dRw661rx2z0\n", + "58+vwOU6cj3RaDSkp1spLbWzaNGiwzOwambMWEBhYQaVlXPIyNDjcjXi9epwOkO0tXkZHAxTU1N7\n", + "3H4JgsDq1ZfictXi842wZ892FIppKJVplJdXYLXOxufT09S0f+w9FksGAwMjiGL0qPYikRBpaRMz\n", + "03bOZkYEQagG9JIkLRcE4deCIMyXJGn34adfBj4GHj5X+z8d3G548kmoPf74XzRceSV87WvJ9OYZ\n", + "Mya6N2eG3W4mkWjlszTXz5CkKDKZCr3+yAnocrkIh8MolUq6uz04HOOLwuXkTKOnp49vf/uGcRe9\n", + "Bx+8i5aWFlyuQa655l76+tzU1NTi84nMnFnMqlVfGSs6JZPJkCQRuz2H1auv5rXXXkaSQqSlGcjM\n", + "nEZamgWLRYF31I5WY0BAwO0bprbZjTxmR1RH6K9vRmY0Ysk0o9H00dERR6u1E42GkMkGuf32NRNW\n", + "Z+RskZFhpqfHi9E4fg1bFIPnrICXQqFAFJPBsqIoIpcrMRgsxMIRYolRZJKAIJiIxbyM9jjR+bWM\n", + "BsOMxAu5+pobxz7zRKKI4eGnaWn5GKOxEIMhhEKhwGrVotWqsNs1iKIKgyGNqqpCNmy4Zkqk155v\n", + "kqXsE2OPLZZMVCotbnc3o+6dvPH441gEgQTwvlLJ2ttvZ/r06We1D3q9npAoIpfLWbSwmqHhYUaG\n", + "RwnFo+TlVo5b/ly8eCFNTR10dOw55vmYSCTQaJQEg8qxwpVWq5eRkSjxeACzWcXy5YvIzMxg8+bt\n", + "VFfPJj39aEH+GVVVlchkMv72tzfo6+sgM9NCVdW0w7FjNZhMDjo6dlNZuQhBEAgEvBQXOwgGw4dT\n", + "hZOZR6KYwO0+xC23HB28fz44l8s0i4B3Dv/9HnAJsBtAkqQhQRDOTynAU+CRR5IBm1M02eCsI5cn\n", + "A1mfeAJ++tOJ7s2ZMW/ebD76aC+dnf1EIrmo1QYCAQ9KZRidLsG8eZWMjIzw6nPP4enqQiWTMRiJ\n", + "0OOW4XB8sTXhsH22iCRJeL1eVCoVWq2WGTNmjBNuGzYkX5O8oB4hKysLi0XO6Kib/PwyrrlmAzU1\n", + "NYyMhEhPN+D31/LNb97JL//fo3QM91Fky6GlowMhriNCmLJp0yi02Rn0enD1CSxcOIPq6pm0tzsx\n", + "GjOZOfNqrFYrU5358+ewY8dzBAI29Prkuv7gYA8WS/ycuUMuWDCTZ57ZRmFhNvX1LkymLOAgBpMB\n", + "laDFQJBBzxBRfys5UpA2omRb8zAmVDTV11N5eI1fLleQnz+HK67IRxQFdLocAoEQSmUWgqADolgs\n", + "VioqijAah1NC5EsoKChAqXybUMiPQqGioeYjvN3NjPa3ICRGKb/0UsqrqpDLZPiCQd54+mnyvv/9\n", + "s5pJlJmZibWoiJbubqZlZ2O32zGaTOxxOln+BUOm5JLf7TQ3Nx/zfJTL5SxfPp/HHvuYtLQcFAo1\n", + "Pp8fjSYNna6bdevWk5ZmOdyahe7u7uOKEUi6qFqtFsJhLYWFi8ficaxWDSMjQ4AIJDN3Rkaaue66\n", + "1VitVv7ylxfp7OxGJtMgih6WLZvBnDmzz9rndiqcSzFiBtoO/+0BZp7DfZ0xQ0Pw+9/Dvn0T3ZPJ\n", + "xZ13wpo18JOfJMXJVCUjI4N7772eRx99ip073yGR0KPTqamoSGfDhmU4HA7+9OtfYxoZYebh7IxQ\n", + "JMLeve/Rkt5ASckRheF2Oykry6enp4dXXvmAwcEAkKCqqoi1a1eN83X4sgBLmUzGrbeu409/eoHO\n", + "zj4EQUVBgZnZs+Pceuv1TJ8+HbVaTfibUX73yz/S2V5L10A7wzE7JUUzmJ6fD4DNaKSrqxm5fCYV\n", + "FRXjIu8vBLKzs7njjtW88MJ7DA/LEMU4OTlp3HLLTeds1qeyspLm5g527+5AoXDjdLah0/mBUaJR\n", + "Ob3uPvTBXqosAkU2G+lZWbzrbCMjv4iBri4qKiuRy+VEIhECAS+Dg0O0troYGUkcrvcxk/z8PHQ6\n", + "HRaLhc7O/Vx5ZeU5OZYLAa1Wy623ruGvf32T5vo21H1d5Bs0ZJvklJqK6G1r44BWy9yyMtJ0Ooxu\n", + "N21tbcyaNevEjR8mGAwSCCSLRn7Z92r9V77Cq88/z6ctLWhkMkIyGfOuvprKqqPrtyiVymOej6FQ\n", + "iLfeep/WVhcy2Sg7dvweq7UUr3cUSQqzfv11nxMiACfvC5KZmYnZLBAIeDAYzAiCwMKFc/ngg7dQ\n", + "KAL09OxGoYhwww1LKCtL2gI89NC9OJ1OQqFQUnBN4A3MOcumEQThG4BbkqRNgiDcAORKkvSrzz1f\n", + "APxEkqSNX/J+6Yc//OHY4xUrVrBixYpz0leAf/1XcLmSgiTFeObNg5/9DFatOrf7OZvZNF9GIpGg\n", + "q6uLvr4+jEYjDocDo9FIV1cXr//udyz8QppoXXs7rzb0U1F1JVqtiWBwGJ3Ox7XXXsazz76HyVSB\n", + "0WhDFBP09bWQnR3l61+/85giJB6P09PTQyKRIDc3F7VaTTAY5OUXX2TXhx9iUavRmUyUVlez6ppr\n", + "xrIk3G4327Zt55k/PEbcp6AgYwEqpTp5PGKCPR3b+H+/+Tdmz56YO5oz5WTGPR6P43a7USgU2O32\n", + "cz6LIEkSTqeT9vZOhoeHUKnU2GwWGurqaN+8mXhnJ+V2OxqVCl8oxIHeXg5JmejtVVy6eg3NjY30\n", + "tDQxPFqDXGNl3qJrmV5WQXNzDZ9+uoWCglIqK2fh9/dTXKxj48abUavV5/SYJhuner739fXxyL/+\n", + "K3PNFux2G80HD2IMh1EoFNSEQtx49dXIZTLqOjupuukm5s6de8I2Y7EY7731Fo07d6IC4kolC1eu\n", + "ZPGSJV/6HRscHCQUCmG3208pkykcDvOrXz1KV5dAWVk1crmC5uaDNDd/zPz5RQwP65gx4zJksuRd\n", + "XyDgxevdz/e///WTnuVpaWnhySdfR5LS0WqNBAKDmM0hbrxxDWq1GpvNNqHfs4nKptkG3A9sAlYC\n", + "j3+xXydq4OGHHz77vToGw8NJk7Pdu0/82ouRe+5JirRzLUbOB3K5/JjZCIFAAM0xLj7F2dks0emo\n", + "XpaPyzVCXl4pVVWVvPfexyiV+WOxDDKZnNzcMjo7d9LV1TXOORGgs7OTp59+Fb9fgSDIUCiC3HDD\n", + "lSgUcty1tVxfVYVOoyEhijTW1PBaOMzNd9wBQHp6OuvXX8toXy+++gZqWutIiBZARjjST9WcbKqO\n", + "cXd2IaFQKM5raXtBEHA4HDi+sEY33N+PpbSUtkCAYZ+Pzn4vCUnFSFjElWjDlmZg84evERvsI9sq\n", + "YlNZ0Kgr6D7YiCHNQmnpHGy2TGpq3iAvr4S5cy+hvLx80rpiTiYUCgWFOTmUHZ4V9Obm0ldbS67V\n", + "ihSLEYvHkeRyRoD8w685Ee+88QYDO3awJD8fhVxOOBplzyuvoFKrmfclpcvtp+F1UFOznyeffIkd\n", + "OzoxGmfR07ONhQurKC+vwm63kZ8fYeFCM1u2bAMsQByVysvtt19zSstNJSUlPPTQHdTU1DI05KGw\n", + "cCazZs2cEuZ350yMSJK0TxCEsCAIm4F9kiTtFgThl5IkPSQIwjrgB8A0QRA2SZJ0dGL9eeQnP4Gb\n", + "b4aLKFvulLjzTvg//we6ujhG/MSFQXp6Oh5JOsqZdWB0lOmVlaxYsRxIpvg1NTXx1ksvE4vaiMdj\n", + "ZGcfqY8iCHo8Hs+4tv1+P3/+88vo9RU4HMkp2HA4wLPPvke6IUy5zYbusMeJXCajIj+fTxsaGBwc\n", + "HHfhW7luHc/39bG0UkskEmE0GCRuyOO2b3wjFW9wnsgpKGDPrl3klZTw6t/ewazJQqvS4A9JmLJm\n", + "kVtgwij2c8nsQnLsdv73pQ8IBZwEA6Ps2DzC1dfditWazfTps1m5cumUdcOdCMxmMwmVilAkgpRI\n", + "EAwG6Rgaormnh1hmJkMeD50+H5VXXHFSgsHv93No1y6WOhzID89kalQqZmVns/PDD6meN++snFe9\n", + "vb1s2vQhGs00TCYlFksh4XCAbdtquPLKpaSlWenrq2XjxpuZP38O3d3dKBQKpk2bdloiwmazsXLl\n", + "ijPu9/nmnPqMSJL07S88fujw/68Br53LfZ8sbW3JAM2DBye6J5OXtLSkIPn1r5PLNRcidrudknnz\n", + "2LtrF2VZWejUanqHhugRRW5bmvQJkSSJ1196CefOnRQnIvS7u3AP9+HOKWb2wjXIZHIkyY/JZBrX\n", + "dlPTIaJRI1lZR9aCNRo9SmUOB+veYPHSReNeLwgCBrkcr9c77qKam5vLHf/wD+zduZOB7m4KsrOZ\n", + "u2DBlC96N5WYUVHBrvR0GnfsJqtwJvEodI24iOQVcvU1G+noqCUtcpDSvDxaursJ9rWTIXjJUOvp\n", + "cNax56NNVC1djygGp5wT7kSjVCpZfNVVfPCXvxBqbiZTLiffamVXby+RcJgurZbVN99MaWnpSbXn\n", + "8/nQymRjQuQz0nQ6Al1dxOPxszJjtXfvAVSqXHQ6I6JYDyTP/2BQg8vlQquVUVCQDFBNT08/YbDq\n", + "hcpFb3r2z/8M3/oWpK7nx+eb34TFi5OxNV9Sd2vKc/WGDezIzGTfJ58QcrspKC/nlpUrycjIAJJ+\n", + "B527drG4qAivzcZHw7tI19jp6G2jv78DUYyRn68fsyeXJIm6ujqefvplDhxw4/OFKS6egVab/ADV\n", + "aj1KnZFBj4eszwWOiaKIN5EYKyn+eWw2G6uunhql3i9E1Go1t957L//RPUCruxOdOY2s2dewdPo8\n", + "1Goter2ZUW+MSDTKvpoarizIpsXpg4QWhy0LdSTIrk9f4Pa7rz1hanI8Hmffvhp27qwjFoszd24Z\n", + "CxfOn7KOq2eDhYsW8dHbbzPa1oYfMFut3LRkCUa9nkOJBCUlJSc9m2E2mwkLAvFEAsXnovNHfD5M\n", + "dvtZWzobHfWj0egxmexkZRkZGGjBbC5CEBSMjLhJJAIsW3bDGe3D6/WyY8du6upa0Ok0XHLJHGbN\n", + "mnVKDsUTzUUtRrZsSf577LGJ7snkZ9q0pO/IL3+ZFHAXInK5nCVLl7Lk8EzIF2lvaSFdpSIQCBCL\n", + "xZg7dzqNjW0oQqM0173JdV+5jrVrryQajdLS0sJbb71PU5MPs7kUUVTR2hqgu/sdli+/Cq3WgM/n\n", + "YtXalTTv3IFSocBmNBKORmno6aF04cJjipEU54doNIokSccM9ktLS+P6W27gFc1BHI5KEok4LpeT\n", + "/n4no6MdLF00h8319cgjEfLT00nE49Q6u7HZCtAgYtXpWLv2qmPs9QiSJLFp00scODCM3V6MTCbn\n", + "3XfbqKtr5u/+7qsXXbDrZ0SjUeTRKBvXrz9KdCScToaGhk5qZiESiaBQKKi69FL2vf8+s3Jz0arV\n", + "eAIBDrrdrNp4zLyKY5JIJOjt7UWSJLKzs48SMaWlDhob67FYMpk/fzkHD+6ms3Mno6P9GI0V3H33\n", + "jUfFJn0Rj8dDS0sL0WiMggLHWFViSM7w/O53T+H1GrHby/B6wzz99KcsXdrLunXHd3CdTFy0YiQa\n", + "hfvvh//+75Tb6snyox/B0qXwjW+A2TzRvTn/iMC+/QdRRGR4vX6GhtwYDHrkehXzFlZw003rcbvd\n", + "PP748wwMxNi5sw6DoQy/f4TMTCPDwxI+n55Dhw5gtVpJT4+zevVVOCtmsPmttzjY1YVMpWL2lVdy\n", + "6WWXTfThXpSMjo7y5psfUF/fjiTBjBkFrFlz+VGFwyorZ7F1aw3NzXtoaKinudlFICCg1UYYGnKz\n", + "ZFEpPQcPYhweRmO1cuOll2K2WIiLIgeCQRSK4196u7q6qK0doLBw0diPrl4/i87OGurqDjJvXvU5\n", + "+wwmMzKZDJlcTkIUx81mACQk6YSfq9vt5s03P6C5uQeAyspipl1+OXt37SIRDqO1WFj51a9SMfPk\n", + "nCi6urp45pnX8HgEBEFAo4ly001XjXPSraycxaef7sPpbCQzs5CystkYDCqKisr5+tfvPsqD6IvU\n", + "1taxadN7JBIWBEGBKO5kyZLpXHPNagRBYNeuPfh8RvLzk/vUag2kpVnYtm0rixbNmzLLPhetGPnP\n", + "/0ze7d9wZrNjFxXTpyc/r3/7t6Rt/sVGW3s3TYMxSrVGRkf96PWzCAR9jEohpPYw27fvYO/eBhKJ\n", + "PIzGMEZjEKu1mNHRfvLyNGRn62hq8tHRsYtrr72TpUsXodVqmT59OqWlpYTDYVQq1QkvTinODeFw\n", + "mMceewa/30pu7jJAoK2ti8cee45vfvOuccGESWOrW3n44f+ksbEftbqUiopcbDY7Xm8ne2oauGTp\n", + "Usq1WnIzMsYExYGODqpWnrg+itPZjVxuPeruPy0ti8bG9otWjCgUCsrmzaNl927KP1fqoMvlwlZQ\n", + "cNzZRJ/Px6OPPksikUte3nIkSaS+vh2Lxc393/sekiSh0WhOepnH7/fzpz+9hE5XTkFBUqwGgz6e\n", + "euotHnrINiYCdDod9913O598so2amr0olQrWratk8eKFJzzXvV4vmza9i90+H40m+f0TxQRbtuyk\n", + "tLSIsrIyGhraMZvHz6wk04PN9PX1pcTIZGbfvuRyw+7dkEpCODV++lOYNQtuvTU5S3Kx4PP56OgY\n", + "oWzJBja//BgZMjuBiJdBRCR1HuXlK3j11Y8ANYWFVbhcTiBZ+8FoTKe7u5V1664kPd2EzVbImjVX\n", + "jmtfEISLOhZgMtDY2MjwsJKCgiPOrpmZhXR1+airO3hUIUWZTEYwKFFauhCbrXBsu9lcQG9vC7qM\n", + "PJwhD+6uLrSCwKgoYikt5ZJLLz1hX7RaDaIYOWp7NBomLW3yp2meSy5buZJNvb3s6uwkTRAIShIJ\n", + "q5WbT3BnuX//AUIhE/n5yR9uQZCTk1NCR8ce2tra84f/OgAAIABJREFUTtkwsLGx6XBg+pFZM50u\n", + "jZGRLGpqalm16oqx7Wlpaaxde9UJl+e+SFtbG4mEZUyIQFJoGI0F7N17kLKyMvR6HT5f+Bjvjk6p\n", + "5byLToz4fEnL91/+8sJNUz2XWK1JT5bbb4ddu+BwbOcFTzAYRBBUZOdOw1CwkKg8BwmJdH0GwWA/\n", + "CoWKSARksjgANls2Gs1OgsFhtFoLoigRj0cZGWll3bpjV2YFGB4eZseOPbS395Kebmbx4uqT9kxI\n", + "cWb09blRq49ef9RqLfT0uI7ankgkiMdFBGG8Y2fSR0ZNIgEPfuc7tLS0EPD7ycjMpKCg4KTuvHNy\n", + "cujpeYpDh1ykpZkpKsrDajUTDnczd+7FPZ2r1+vZeN99dHR0MDQ4iNFkYtq0aScMOO3udqHXH+0w\n", + "qlKZGRhwc6rmxR6PD4XiaGGo0RgYHvYetb25uZkdO/bj9wcpKytg/vzqkwpihqNnT+RyBZFIEIBL\n", + "LpnD44+/g8lkH7MY8HgG0eujU6q680UlRhIJuPtuWL48eWef4vTYsCE5q7R+Pbz11sURP2KxWFAq\n", + "k0JDrVai1+ehUKgJhfyYTDoggcGgRqWS4/ePYjCYWbx4Odu3b6a7O4zFoqSrawtGIzz//Nts2vQO\n", + "8+aVs2LFpWMXpIGBAX73u2dJJDIwmfJobPSyb98L3HbbSiorT97aOsXpYbOZiUZ7xh4nEgna2trZ\n", + "s+dTDh2SCIXCrFx56VgqtdFopKgok5aWPuBIQGEgMIhSGWfmzKSl/8yTjD/4DJ/Px1NPvYRWm83A\n", + "QDeDg0M0Nu6jtFTDN75xe0qckgw2nzZt2inVJ0pPt9DQ0Atkjdsei/mxWstOuQ95ednEYk1HbR8Z\n", + "6WVgIMGPf/xfJBIi1dXlyOUyPvnkEEZjERqNhQ8+cLJ7dz333//V46Z4JwNbPyWRiI8JDYDR0W5W\n", + "rUqask2fPp1Vq/r48MNtgAmIYTBEufPO66ZUocyLRoxIEnz3u8kaNH/960T3Zurzox+B1wuXXw4v\n", + "vQRfcFG/4FCpVKxevZgXX9xBbm42HR1NaDR5RCLDzJpVTnd3HVdeOReHI5cnnngdrzcbnc7EjBll\n", + "RCLtXHvt5ezceQCv10JWVjGCIGPXrjZaW5/hgQc2otFoeOedzchkDrKykj82BoOZUMjKK698SHl5\n", + "Wcql8xwzc2YF7767naGhPmy2bGpqajl0yIlWq2DOnHW0tnpobn6Gv//7r475v9x5543s2/cTOjq2\n", + "YbUWEY8HCIVaWbAgh0WL5p1WP7Zv34XHY2Tu3IXMmhVleLiPWCxKONxJefnZrUZ7MVFdPZtPPtmP\n", + "x2Mbq5brdndjNIbHarWcCiUlJRQU7KCzs5bs7FIEQUZvbyttbTsRhMXk51chk8nZurWe3bs/ZN26\n", + "+9DpktkSBoMZp7OR7dt3cdVVXx5DlJGRwYoVlXzwwU4MBgdyuQKPp4eSEv3YDYogCKxcuYJ58+bQ\n", + "29uLSqU6XFxwal0vzlltmjNFEATpbPVNFOGhh2DrVnj/fUhlTJ4dJAl+/vNkMPDPf56s8HsmMTjn\n", + "ozbNmVJXV8cHH2xn5859eDwhCgtLsFp1XHppFVdccRlyuRyXy8WePftxu0coLMxhzpwqnE4nTz31\n", + "KYWF43+gOjv3c+ONc5k9u4of/vAX5OVddpQ3gNO5kwcf3DAune9CYjKNe39/Py+88BbNzX3s3HmQ\n", + "vLxpVFcvxmJJrkf29bUyd66B9evXjr3H5XLx178+y7ZtdahUCq64YgnXXrv6tGzDAX7xi98jk5WN\n", + "+dF8htN5gNtvX8yMz5eFnsJMxLh3dXXxwgvvMDgYBCTy8y3ccMPVpx3kGQqF2LJlGzt31pFIJMjI\n", + "MNLc7KOsbNnYa/r7O3jnnc0sW7acoqLCse3hcIBYrIHvfvf+4+5DkiTa2trYt+8g4XCUWbNKmDlz\n", + "5pQTGzBxtWkmBQMDyaWZUAg+/BC+YI6Z4gwQBPje92DFCnjgAfjd75JZNidRn2rKMmvWrLFqoOFw\n", + "GJ/PR1paGprDdu6QvJu5+urxhXyczj40mvHpoQA6nY2Ojh7mzp2DSqUgHo+iUmnGvUaSYlNqunUq\n", + "k5WVxTe+cTdbt25FJktj+vTF42I8zOZMWlvHT81nZGTw7W//A9/+9hdbOz00Gg2BQOQoMSJJsSn5\n", + "AzSZcDgcfOtb9zI8PIxMJjtjLx+tVsuqVVeMBau+//5H9PePjy+SyxUolSoGB0fHlRyJRiPodCcO\n", + "MBUE4ZSXpKYiF6wYCQSSxd1++lO47z54+GFIncfnhvnzYccOePxxWLsWrrgCfvxjKC6e6J6dWzQa\n", + "zTgRAklzoj179tHZ2U96upkFC+aSmZmJxWIkFus9qo1IxI/Vmo8gCFxySRUffniIwsIjRe9cri7y\n", + "803HvctOJBI0NDRw4MAhZDKBuXMrKC0tnVLui5ON7OxsNBr5UcGmoZCf7OwjdzQ+n4+tW7ezefMO\n", + "AoEwc+bMYOXK5WcU17F4cRXPPLMVg8EyNoZe7xB6fXTM3TfF6SMIwlG+MWcLs9lIPN4xbpvVmoVM\n", + "5gGOZLyIosjgYCu33DK+FMTo6Ch79tTQ1dVPZqaV+fPnjDlAf0YoFOLAgVqamjowmQxUV1deEHFE\n", + "F9QyzeAgfPxxMqjyb3+Dyy5LFsE7xfixFGeA3w+PPJLMVrrttqR9/Mla7U+m6frTwe128/vfP0M4\n", + "bMVotBMMeojH+9i48Wqys7N55JE/otdXYDQmI/r9/lE8njq+9a2NWK1WIpEIzzzzIk1NgwiCEQhh\n", + "twvcdddNWK1HZwFAUog888wL1NYOYTLlIUkiXq+TxYsL2LDhmilRQG8yjnsikeB//ueP+Hx2MjKS\n", + "aXfRaJju7t3ce+9aSktLGRoa4le/epxPPmlEknKRy/VEIm5mzNBy//3XU119elOEoijy6qtvsmNH\n", + "C4JgBqLo9RE2btxwQfzofMZkHPczJRAI8Mgjj6HRlI3FpQQCXjo6PsZg0CIINiRJiSR5WLiwmPXr\n", + "144Jzv7+fh599DnicTsGg+3w9aOXu+5aR0lJCZD0NvnDH57G7VZgNGYRiQQJh7u5/vpLWbDg9GKU\n", + "zifHW6aZ0mJkcBA2b04KkI8+go6OpPfFypXJbJlUQcyJw+2Gf/93ePLJZF2b73znxEtkU/3i9Je/\n", + "bKK9XUFm5pGc8UDAQzTawPe+9wDd3d08++zr+HwCkgR6fYKbb14zdqGB5Ppwd3c3Q0ND6PV6ioqK\n", + "jusq2djYyJ///CGFhQvGhIcoinR17eCBB9af0GZ6MjBZx314eJhnn32F7m4fMpkauTzA1VcvZdGi\n", + "hQA899xLvPzyHjweC2ZzIZAULMFgB3PnaviXf/nGUTNnp8LAwAB9fX2o1WqKi4unlGfEyTBZx/1M\n", + "cTqdPPvsa4yOSgiCDK02zo03rqKwsJD29nbC4TDZ2dlHFbh8/PGn6e3VkZ5+xMzN7x8lkTjEd797\n", + "PzKZjHff/YDNm3vJzz8SNxSNhnG7d/GDH3z9tKr8nk8mLGZEEIRfAPOAvZ+v4CsIQg7wF0AN7Acq\n", + "JUladuxWjtDff0R8fPwxOJ1J8XHZZcl4hXnzUksxk4X0dPiv/4Jvfxt++EMoLISbbkrG7yxeDBea\n", + "yWg8HqexsZO8vPE27nq9iaEhGBwcpKCggO9+9376+/uRJImsrKyjhIYgCOTn55/0HXB9fQsGQ864\n", + "GRCZTIZSmU5zc9uUECOTFavVygMP3IXL5SISiZCRkTEmLiRJora2Bb8/isGQPfYelUpDIKDB50uW\n", + "ji8+g7XKzMzMVEXmKUh+fj7f+c799PX1IYoi2dnZY+f5523iP08kEqG1tZf8/PHXj2TWTWKs5s7+\n", + "/YdITx9viKJSaUgkDHR3dzN9+tTNtjpnYkQQhGpAL0nSckEQfi0IwnxJknYffvr/A/4FaATqgeYv\n", + "a+f99+G555LiY2AAli1Lio+vfQ3mzIETlCJIMcEUFsKf/5wUkn/8YzLQtb8fVq9OBr4uW5a0mZ8C\n", + "qwnHRSaTIZfLEMXEUbEagiCO2T7L5XJyz+KUXTLo9Wj3RVGMo1anlPmZIgjClwoChUKOTCZDFOMk\n", + "76uSSJKIIHDCOikpLlxkMtkpnedy+WffpcQ4PxFJkpCkxNh3SalUkEjEj3q/JCWmfBmJcxnhtgh4\n", + "5/Df7wGXfO65WZIkbQNuA9o4jigaHIQZM+Dpp5N/v/JK0i9k/vyUEJlKZGUlq/3W1sKePUkR8tFH\n", + "cOONSTO6qY5MJmPhwpn09o7X1W53Nzk5aaed5nkiKitnEIn0jbtAxWIRJMlNWdnUvUua7AiCwMKF\n", + "s0hLU+D1do5tDwa9KJUhsrK0Z1V0priwUSgUVFdPp7e3Zdx2t9tJYaFtLOtn0aIqXK7Wcctbfv8o\n", + "en1sys+CnsufczNJoQHgAT4fRioXBEEJXHb4NV961fzKV85Z/1JMEA5HsmLy/cdPr59yXHHFcnp6\n", + "NtHRsROZzIgoBrFY4tx8883nbJ8FBQWsXFnJBx9sQxDsh+/Kh7n22iVTpkDWVGXFikvp6HDy5ps7\n", + "6ejoRZJ0qFQBFi928NWvbpjyd6opzi+rVq2gv38TnZ27EIQ0RDGAzSZy/fVHrh/z5s2ltbWT+vod\n", + "CIIZSYqi0fjYuHH9lE/7PmcBrIIgfANwS5K0SRCEG4BcSZJ+dfi5D4EngSHgHsAuSdLSL7z/wots\n", + "SpEiRYoUKS5iJiKAdRtwP7AJWAk8/rnnDgArgGygGhAEQfh7SZL+9/MNTKVI60AgwM9+9nuyshah\n", + "VB5ZP3Y6G1i+PGdcBccUx+ZCja5PcXwm47i7XC7++7+fJi9v8bg1/I6OfVx//RwWLJg/gb27MJiM\n", + "4z4ZEUWRRx75HYJQSlraEZO2wcEesrIC3HPPbRPYu1PjeFYD5yxmRJKkfUBYEITNQFySpN2CIPzy\n", + "8NP/CeQCeuArQN0XhchUo7u7G0kyjhMiAOnpDvbvPzRBvUqRIsXp4HQ6Acs4IQJgseRTW/ul8fYp\n", + "Upx1hoeH8XgS44QIgM2WQ1tbH5FIZIJ6dnY5pyGgn0/nPfz4ocP/95CcLfmM985lP84HCoUCSTo6\n", + "yjkej6WyGlKkmGIksxeOjqyOxaJoNClr/hTnj89+WyRJGjezkMzcEy4Yp+UL4ygmAQ6HA70+hs83\n", + "MrZNkiTc7lYWLao6zjtTpEgx2SguLkap9BIK+ce2iWICn6+LefNmTWDPUlxsmM1miorScbu7xm3v\n", + "7W1h7tzSKR+4+hlT2oF1stHZ2ckTT7xMOKwH1EjSCLNn53LjjetTngMnQWoN+eJkso57fX0Dzz77\n", + "NvG4GUFQIIrDLF1axtq1V00Jm/3JzmQd98nI8PAwf/rTJoaGBARBjyh6cTi0bNx4M3q9fqK7d9Jc\n", + "sHbwk5FQKERLSwvhcJisrCzy8vJSF66TJHVxujiZzOPu8/lobW0lFkv6OKQcUc8ek3ncJyOxWIzW\n", + "1la8Xi82m43CwsIplz6eEiMppgSpi9PFSWrcL05S437xcTwxkooZSZEiRYoUKVJMKCkxkiJFihQp\n", + "UqSYUFJiJEWKFClSpEgxoaTESIoUKVKkSJFiQknlm05xmpqa2Pvpp3hHRsgvLWXR0qXYbLZxr5Ek\n", + "CY/Hg1KpnFJpYClSXIh4vV4AjEYjkiTR0NDAvk8/xe/1UlhezsIlS8aqtKa4uBgZGWHXtm20NzSg\n", + "VKspr65m0aJFUy5r5nSYsGwaQRBmAr8naXN4UJKkB7/w/EWdTROJROjv70epVJKdnX3M9OCtW7aw\n", + "57XXmGaxYNBq6R8ZoV8m47YHHhir2NrW1sZ7L79MeGiIBOCoqOCqa68lLS3tPB/RibnQo+t/9Sv4\n", + "+c+huBgeewyKiia6R5ODC33cP8PlcvHOyy8z2NkJkoTV4cBot9O9axfTLBZ0Gg39IyO4lUpuf/BB\n", + "rFbrMduJxWL09/cjCALZ2dlT9ofqQhr3kZERPB4PFosFk8l02m389be/xejz4e3ro9fppDcYxDJr\n", + "Fvf94z8yY8aMs9zr88+kTO0VBEEhHfZPFwThj8CvDtez+ez5i1aM7N27j9de20wspkGSEtjtSm67\n", + "bf04j4NAIMDv/+//ZXFmJqrPOfC19/Xhz8pi5dq1SJLEC48+SoXJhM1oRBRF2vr7CaSnc9cDD0y6\n", + "i9iFdHH6Io8+mhQizzwD776bfFxTAzrdRPds4rmQx/0zAoEAf/rlL8kTRXLtdgRBoKWnh5c//pgH\n", + "NmwYN2PZ0ttLWnU1a9evB8DtdhMMBklPT8fpdPK3v71LKKRAkiSMRolbb12Hw+GYqEM7bS6EcY9E\n", + "Irz88hscONCJTGZAFP3Mm1fCunWrT9kZ9c1XX8Wzaxe9jY1Ig4PkZ2SATManbjfZlZXc9q1vUVBQ\n", + "cI6O5PxwPDEyYcs00vhCLlpgdKL6crYZHh6mt7cXlUpFYWEhKtXJ17Lo6uri+ec3k509D7Vae7i9\n", + "fv7857/xj/9439gX3OVyYZCkcULE6/VyqLaJre/voMUp0dW6h4VmJbb8fABkMhklOTns6uyks7OT\n", + "4uLis3jUKb6M3l74p3+CLVugvBzmzEkKkR//GH7604nuXYrzQUN9PfpAgLzPiQaVQoE9Hsc1MEDR\n", + "587FPLudmvp6fJdfzqZNr9DaOoRMpiEUcjMwMEBV1TricR+JRJxwWMGf/vQS3/nOPRgMhok4tClB\n", + "MBiks7MTURQpKCg4a5/V22+/z/79HhyOSxEEAVEU2bVrPwbDJ6dcqb1+zx5G99bS39BEji6NhsEW\n", + "cnIzyFCpMEoSOzdvpmDjxrPS78nIhMaMCIKwHvh3YLckSe0T2ZezgSRJvP32+2zZUgeYgRg63Tvc\n", + "eed15OXlnVQbO3bsQ6t1jAkRAKs1i87OXlpbWykvLwdApVIR/dxdRTweZ+vWvYSietIzM3E4FtB9\n", + "qJm2Q62UFxaMW4PWAx6P52wccoqT4N/+Df7u75JC5DN+9rOkKPne9+ALIT4pLkCGXC6M6vEVvZUK\n", + "BXKFAv/hGJLPCEUiaA0Gnn32Fbq7FRQULAWgru4gDQ1NdHc/j1abDyiQpBEsFhkHD9azaNHC83U4\n", + "U4q6uoNs2vQu8XgagiBDJnuHa69dzoIF886o3VAoxK5dTeTlLRlbRpfJZOTmzmTr1h2sWLHspGdH\n", + "EokE+2sPkeYBs86KXmckISbocroI2w1MN5kY7Os7o/5OdiY0m0aSpFckSaoEfIIgrPri8w8//PDY\n", + "v48++uj8d/AUqa+v56OPkl9Oh6MSh6MalWo6TzzxErFY7KTaGB72otMdK55DQzAYHHuUk5ODJjOT\n", + "brcbSE7lhkIyhuIxskvmAGBOzyMqqulod45ryU+y+FKKc09vL7zwAvzgB+O35+fD9dfDb387Mf1K\n", + "cX5Jz8rCEw6P25ZpseBTKvn81oQocsjloqC8nPb2YXJySsaeCwSCeL0xRkZMWK0zsVrLsFgW0NXl\n", + "p76+4TwdydRieHiYZ599F5utmoKCOTgcVWRkLOTFFz+h7wx/3EOhEKBELh9/T69UqojHBSKRyEm3\n", + "1dHRgdpShF+hIiiKAMhlcoKigoFgGLlcTsZJ3tBOVSZsZkQQBJUkSdHDD73AUWsZDz/88Hnt0/Ho\n", + "7+9nx4699PYOkpeXzqJF88jIyBj3mu3b92OxFCOTHYnFMBptdHWpaW9vZ/r06SfcT0lJPh991ENa\n", + "2pGZjOS6qmcsKBWSa2/X3X47f3viCXo7Oxnp76fO68Ux+zIcBclAp7yiWew+tIdut5u5JC90zb29\n", + "aPPzp/za41Thf/8X7rgDjpUc8cADcMstySWcC6QKeIovYUZFBdvfe49OlwvH4fO4Z3CQkkWLiOp0\n", + "7OrsRClJtLpcRA1WhrfX0NcXJDc3PlZkUy6PkkikIYpH7rZlMjkKhRWX64JZ5T6rNDQ0AnY0miMx\n", + "OSqVBpUqmwMH6snOzj7tto1GI1othMOBce37/aOYzeovzVx0Op1s376XwUEPxcW5LFxYnYwJyigh\n", + "pM2kfvPzDA/2oNHoCCrV5FmNdIXD3Lhs2Wn3dSowkcs0awRB+A4gAO3AmxPYl+PS1tbG44+/glKZ\n", + "h8GQy969w+ze/TT33HPduB/1QCCMSqU5RgtKotHoMbYfIRgM0traikwmEY930Nen+v/Ze8/wuq7z\n", + "zve3y+kFpwAHvbGAJECCRSwiKUoUJTuW5SLJkh07rrFiO5Fv6s08mdzJ8/hOJhlnnDvjJGNnYtmO\n", + "bEm2ZcmyVSJajaTE3kGCKEQ/AHEAnIPT+673A2hIlKhKyizi74vEfdZZe529sNd611rv+38JhZpQ\n", + "VYXp6QHa26tfd9QTDAb58h//MRMTEwwNDRF9+ijt7VvnP/d6A1S3r6PMCLvHxzEEgUUrV3LLbbch\n", + "Xpv93nNKJfje92D//vN/ft114PXCjh1w662/3bZd4+JSKpUYHh6mUCicN0Gmw+HgU/fey/NPP83u\n", + "wUEAahYt4su3304gECAcDvPEE8+Qzweoq+1AVUucPv0rFOUQmzfPhXYGAj4EQUUUdXRdBwzS6RjB\n", + "oPMNdlOvUSyWkSTb665bLHby+eIF1S3LMh/60GZ+/vPdVFYuxe32k8nESST6+dznzp/Z+cCBA3z/\n", + "+79EliupqWlmejrGoUMPcued2xCELEuXb6K2sY2Tx3eQmAkjqgpGY4jbv/hFGs/6/l2tXEoH1ieB\n", + "Jy/V/d8upmnyxBMvUFHRjtc7d7jvdvtIJt08/fQO7rvvS/NlOzoWsGvXGVwu7/w1XdcwzRR1dXVv\n", + "eI+RkREefPApymUPgmChVJLR9VNMT4dxOOx88IOdbN68kXA4zN69R4hGk7S01LJp0zqqq6tpaWmh\n", + "ubmZyclZTp8+QW1tG7JsIRaboKZG5o/+6L8iSRIWiwWb7fUv5jXeG558cs4vZNGi838uCPClL8GD\n", + "D14zRq5kJicneeCBxykUnAiCDcM4yPLlNdxzz8fnfQYURWFgYIh4zoBgA6tWLWPz5o3zzu2SJBGN\n", + "mrS3b52fxNauvZ5Dh05QVxdgwYI2JEmksrLAkiWNJBIjiKJIW1sdNpuDzs7Fl+z3X860tjbx4ot9\n", + "wLnO+rncNG1tmy+o7mQyydRUFMjQ1fUkXq+Tzs7l3Hnn7Sxe/Pr+6O3t5a//+p+Q5aVYLBAOH6e1\n", + "tZbq6npOnjxNZ2cDXV3Hqa1dwg033c3U1Ci6HuZP//T3qaysvKC2XglcEz17C9LpNPF4iaamc70M\n", + "/f4Q4+OnyeVy857Z69dfx/HjfUxM9BEI1KMoJZLJEbZuXf6GmgHlcpmHH34aj2c5tbVzfhyGsZSx\n", + "sSPcddcmVq5cCcCJEyf52c924vG04nK10d0do6vrZ3zlK3dTX1+PIAh8+tN3sWfPPvbvP0a5rLJi\n", + "xSK2bfvddx33fo0L48c/hs9//s3L3HMPfOMbc7so9vNtql3jskbXdR5++Ams1jaqquYmDNM06e4+\n", + "TkvLUTZtuh5N03jooUcZHCxSVTUnLvPcc4OMjU3y+c9/CkmSGBsbx2KpOmc1vWzZWhSlyOTkfqzW\n", + "KRYvbqCt7aP09aXp6FiJxWIlHp8kENBYu3bNJfn9lzutra20t1fS23uMYLAFQRCIx8dZuNDFkiVL\n", + "3nW98Xicf/3Xh9G0amprt+Dz5Ugmh1m+fNF5DZFiscgPf/gLZLmDUKgdANNsZWTkJMFgFX19k/zN\n", + "3/wxdXWH2bv3OLOzJdrbF7Bt2xffF4YIXDNG3pK5lY2OYRjnHG0Yho4gGPPnuQAej4evfvWzHDp0\n", + "lJ6eESor7XzkI1tpb29/w/rHxsYol51UV7/iUCqKIsHgAg4d6mblypWoqspTT+2ipmYVDsec4eNw\n", + "uInH7Wzfvot77/09YC7CZtu2rWzbtvXiPYBrvCtmZmDvXnjkkTcvV1cHnZ3w7LPw8Y//dtp2jYvH\n", + "mTNnSKcFmptfmTAEQaC6ejEHDpxg06brGRoaYmgoR2vr2vkybvdqBgYOMzQ0xJIlS7DbbRjGuU7u\n", + "oihSW9vMbbct42Mfuw2YM3R6eno4ePAkhUKJW25ZyLp1111TVn4DRFHkd3/3Trq6TnD0aC+6bvDR\n", + "j3awZs2qd6wD8mpefnk/ul5LXd3cjovD4cbjCfDccwdYvXrl6/pjdHQUTatAll9xahUEEaezkZGR\n", + "QZYu9WKxWNiyZTNbtlzYjs2VyjVj5C1wuVy0tzcxMDByjmd7JDLIypWLsL9mOevxeLjllq3ccsvW\n", + "t1W/pmmY5uvFx2TZQqk052cSj8cpl2VCoXNj4wOBGsbG+lFV9YJerGtcfH7ykznj4u3MEZ/61JzR\n", + "cs0YufLQNA1RfP0wKssWstk542JwcAyHo+p1ZRyOKoaGxliyZAltbYsRhH3nOENqmkqpNMmqVXfM\n", + "f0cQBJYvX87y5cvfo1909WGxWFi3bi3r1q1968Jvk7nF5rrX3MeKabqZnp5m4cKF53ymaRoulxe/\n", + "P0sul8TtnvNoF0WZeDzCxo1bzutj8n7imhfj2+CjH/0gVVV5wuHDhMM9hMOHqKtTue22Wy647jmn\n", + "1BSadu6qKB6fYOXKuegbm82GaaqvUyvUNAWLRb7slFSvMWeMfPazb6/s3XfDM8/AqyK3r3GFUFdX\n", + "hyjmUZRzw3aj0fF5Pw6324Gqvj7MU9PKuFxzekJ+v59PfvJWEonjhMMnCYe7iUQOcNtt112R6qpX\n", + "Oy6XA0V5vQOsaarn9cv7zTi/alU7FkuaRGKcRCJCJHKEtWsb2LJl02+h1Zc313ZG3gYej4c//MMv\n", + "MjY2Rjqdxufz0dzcfFEiUioqKvjgB9eyffshPJ5mrFY7yWSEmhp9/hzY7/ezcGEV4+Oj1NbObQua\n", + "psnkZD8339x5LTLmMmN8HEZHYevWt1c+FIJ16+YMkrvvfk+bdo2LjMPh4CMf2cLjj+/B6WzCbneS\n", + "Ts9QUZHnhhs+DMDy5e288MJxyuXGeTHDUqmAacbo6HhFXmnFiuUsWNDKyMgIhmHQ1NR0LWHeZcrm\n", + "zat4/PFjtLSsmR9/Z2cjVFZaqK+vf135QCCwZzwXAAAgAElEQVTAtm2reP75k3R2tpLNFojHw2zc\n", + "uIC/+Is/vBZYwCXMTfNWvN9y0wwPD3PkyEny+RLLli1g1apOHI5XVFjT6TQPPfQLIpESguDENLMs\n", + "W1bDJz/58XckN385czXkqgD49rfh5En44Q/f/nd+8IM5Y+QXv3jv2nW5cjX0ezgc5vDhE6RSOZYu\n", + "bWbVqpXnSI53dZ3gl7/cia7PZeqV5Sx33bWNlSs7L2GrLy1Xcr/rus5TT23n0KEhRNEHlPH7TT7/\n", + "+U+cowf1WoaGhjh6tJt8vkRHx0JWrux83VH/1cxlmSjvrXi/GSNvB8MwmJiYIJvNEgwGL0iw53Lk\n", + "Sh6cXs2NN84prt5++9v/TjIJLS1zuyrvt+Cnq6Xf34p8Ps/4+DgAzc3NON/nWRKvhn6PxebyBTkc\n", + "DlpaWq4dmb8F14yR9zkzMzPzifuampro7+uj5/BhNE1jyapVrF2//pxdmEvF1TA4TU/DsmVz/32n\n", + "O68f/zjcdRd84QvvTdsuV66Gfn8zstkso6Oj80cvkiRxeP9+Rvr6cLrdrNq4kY6OjvedA+PV3u8X\n", + "C9M02bVrF/t37EArl1m7ZQubb7zxipRsuGaMXEbMzMxwaM8eJkdH8QWDrN2yhUWvUcUyTfOiDEyG\n", + "YfDsf/wHgwcO4AMU0+TAwABtVVWsPpsldDKZxKiv5/fuvfeSn1teDYPTv/0bvPTSnAPrO+VnP4MH\n", + "HoBf//qiN+uy5lL0e6FQ4PDBg5zu6kK2WFixfj2r16w5J1T/YtB98iQvPvYYFbqOCERKJRLZLGtq\n", + "aqgLBimWywzF47TfeivbPjDnP1Iul5Hl98Yx/WKNLReDq+F9f68xDIP//o1vMPz887Ta7UiiSFTX\n", + "CW3cyH1/9Vd4vXMCm4Iwlwvn2NGj9B45gmmaLLvuOtauW3fJx/VX82bGyKXMTbMB+J+AARw2TfPP\n", + "L1Vb3g3JZJK9u3YxdOoUNrudzo0bWb9hw5uG2E5OTvLY975HgyTR4fORmZnhmR/8gM133cV169YR\n", + "i8XY/cILjPT2IlutrNq4ketvuAHDMLBare94oOzp6WF07142trQgiiKR2Vl8iQSz09Mcj0QwVBW7\n", + "2005FqPn1CnWXHdhWSyvMefz8ZWvvLvvfvSjc/lqYjF4k2Pna1wgpVKJn3z/+1ijUZZUVaEpCscf\n", + "f5zxkRHu+tSn3vFknUwm2ffSSwx2d2O1WuncuJENGzeSy+V48dFHua6qCudZv4DMiRNEe3sJtrbi\n", + "djhwOxz4PR727txJRSBAz5EjzE5MIMgyHevXc+O2bRfsU6CqKvv27OHEvn0opRLNS5Zw4wc+QHV1\n", + "9QXVezVQLpc5sG8f3QcPoqkqS1evZtONN85P8hf7XsA7Mg727NlD969/zQpZJnc2KWrA7Sb80kt8\n", + "x2rFLggYhsHizk5i09OIkQitVVUIwMAzzzDS18fvfvGLV4T0w6WMphkDbjZNUxEE4SFBEJabpnnq\n", + "ErbndRSLRYaHhykWi9TW1s4rnabTab793/4bybFpPA4njSEvJ594gqnxcT7x6U+/4WD28rPPssBm\n", + "o+6sop7TbqfC5WLv9u00NDXxyP3302Ca3FRfj6Jp7H/sMR74wcPUL+jEZhPZvHklN910w9s2SroP\n", + "HWJBIDDv7R1NJiGXQ52dxWaz4auoQNB1+gYG2LtjxzVj5ALJZufy0Dz++Lv7vssFH/4wPPoo/NEf\n", + "Xdy2XeMVuk+eRJyepqOlZf7aGpeLgydPMr5x49tOIqnrOiMjI/zixz+mWRDYUF2Nquuc/vWviYTD\n", + "NC9eTNA05w0RgGg0SqvHQ2RigmAwiGkYjI2OcXzPIR579hBtVX7WLK7F5bBz6Je/ZGRoiKWdqxga\n", + "OkMg4GXdupXvOEfJE48+SvrUKa6rq8MaDDI5NsbP/s//4bNf/zrBYPCtK7gCiUQiHD7cRSyWpLW1\n", + "nrVrV7/uWMMwDB57+GGUoSFW1tQgSRLhQ4f4yenTfP4P//Bd+/RMTk4SiUSw2+0sWrSIQqHAM8+8\n", + "yOnTZxAEWLasmdtu2/a2IqV2bt+OmEhgdblodTrRDIOpVIrB2VkAvvh7v4coiuzbtYu+3l6+dNdd\n", + "8wENnS4XR0dHGRwcfFPhzcuFS5mbZuZV/1QB7VK15XxMTEzwox/9kmLRdTbfxAE6O+u4++6Pc/+/\n", + "fZ9jByZoqlpCrihzsG+WkL9ASTzB5I03zie003UdQRAQRRFd1zkzPMzNr9EMcNhsWFSVXTt2UKUo\n", + "NJ/9bjadJjmWwNAseFa24Xb7eOqpY4yNjfOZz9wz7+ORyWQQBAGP5/WJssqlEpazhoum65QUhclY\n", + "DE/JoHc8hSwXMfU8slNgsLf3vXyc7wt27IANG8Dtfuuyb8RnPgN///fXjJH3kvDAADWvmZgEQcAv\n", + "SQz09xMIBM77Pr2a0dFRHn10Oz3dYVKjI8zUuqhwuaj2+1nV0sKB/n5Mi4V0Nks8kyHg8SAIAjab\n", + "DT2XQ1PndIUGBoc4dWqSWAp8rkbOzBQ43N/Povom3A6BYy8+xPU3FejoWMPUVI7Dh3/BPffcxOrV\n", + "q9B1/S0XJlNTU0z19LCxuXl+kdQYClGenOTIgQP8zjvxsr5C6Ovr46GHnsVma8TprGLXrkkOHDjF\n", + "V77yqXMiXUZHR8kMDbH+VUZpW0MD3ePjdJ84wYaNG9/0PrquI4ri/HPVdZ1f/vJpjh8fp1x2Ui5n\n", + "cTqfAjTc7g4aGuay7g4NhfnBD37G17/+pXN2vRRFIZ/P43a753cyZmZmEHUdn93ORDLNeKpESgMh\n", + "V0JJpDENA0mWETWNSlUlMjlJS2vrfJ0hp5Pw0NA1Y+TtIAhCJ1Blmmb/pW7Lb9A0jYcffgK7fRmh\n", + "0FxOGdM06eo6ht+/g5d3nmBBzUrcjjmlRLejgqnEMDZrlGg0isvl4vnnX6K7exhRFFi9egm33HIj\n", + "NoeDkqLgeNU2nWmaKKZJfHKSJb5XJOH7+oZwOmuoLOUZHR1kcHCWRCLPyy+H6e8fZ9Om5WRnpklM\n", + "TIAgUNXaygc/9rFzXrbFK1Yw8Otfc3piihND05yJxeiNxGkTK6lERjY0RMFCX3Qat9BFX18fy5Yt\n", + "+y095auPZ56Z29m4EH7nd+aOeXp6oKPj4rTrGufi9Hgols8VIUun0xw5ehRhcpKe3bvP+z79hmQy\n", + "yY9+9CQeTwcWQaW1xodhKDy5t4ffu3UtTrud1HSU/eGXiY7EcBwZRVTiLG2qweX10pNI8OHrrkNT\n", + "VU6eHGBoJMlALIFdKJNUXNitTQwpORprJURzOePjedav9+H1BikWq/judx+muXkX5bJObW2QD3xg\n", + "M21tbef9rbFYDK8gvG63ttrvZ2R4+OI91MsETdP45S9fJBRaPZ86w+sNMj09xgsv7ObTn75rvuxU\n", + "JIL/PMZcyONhYnj4DY2RsbExHnjgEbq6BnG57Nx++xY+8Yk76Onp5eDBSbJZF+PjMQTBSjQ6RbEY\n", + "5qtfvWV+h7qmppVwOENfX/+8Ubl71y66du9G0nVMq5V127axYeNGbA4HY7kcSjJFseQgYA2gaDlE\n", + "Q6aoutm1aw+yZKN/fAJ1ehrLsS4aGhqQzxozJVXFd4WkCrikalmCIASAfwF+/1K247VMTEyQy1nw\n", + "el9JbicIAqHQQl54YQ82Rx2qbpzzHY8jxGAkxcTEBN/61nfo6SlTX7+FmprNHD+e5oEHfs6K66+n\n", + "PxI5x2lrbGaGytZW6pubyeTz89dTqSwOh5sz8Tg7dhxlclLCNFtJp/309mb5/v/3PZS+PrY0N3ND\n", + "YyOuqSke/eEPKRaLZDIZ+vv7qfD72TE0xo+fOcDIeJzJsXFUI0TEEDmTijGWTzJkqjgDy7CLdp59\n", + "5BGKxbeXVvua49m5mCZs3w633XZh9Vgs8OUvzznCXuO9YcWaNZwplSgpc+kWSqUSu3fupFwuc8eq\n", + "VdzQ2Ih7epqfn32fXsuJE93oeiUejx+700VJVXE7KlC1ACNT00wnEuztm6W+fgtWpx8tMosvIxHr\n", + "HeLUkSP0ZrM8e+oU2w8c4OkjxzmaKKDIrcSLBpJZj2jYKJQEhsYjiKIfw7ATj8eJx+McO3aCkyeT\n", + "qGotTU03UyjU8cAD2xkcHDzvb3W5XBTP865mCgUqrsIEbNFolGJRmjdEfkMo1Ehv75yY3G9wezyU\n", + "DOO1VZArlfC+QWLTiYkJ7rvvG+zcmUcQNpNMLuV//++X+OY3v82BAydIJg3C4Sx+/0L8/mYcjkaS\n", + "SQs7djxJPp+Zr8du953N+Asv79zJ6eefZ31lJRvq6mjSNF740Y/4x29+k2hfH7KucyxbYtYQGSnn\n", + "OGNqlG1uDM3K8eMjFIsOFjauIiG7mIorHD16EoBCqcS0rtPReWVo2VxKB1YZeAj4v03TjJ6vzDe+\n", + "8Y35/9+6dStb366k5TvENE3Gx8eJRqO43e6zf7Dnzxej6ybVdTXEhmdxOxxYpLlHODw5wWwmzNHH\n", + "H2dkKIGtJorT6cXvD1Ffv4SxsaPceGMV6dWr2dvVRYUkUTAMbLW13HnnncRiMX62cycWoCYUwuNx\n", + "EZ4KMxAvoOmNlEsK8dgYghCjvyfFMkuWniOnqPJ6qampoTEUYnJggP/nr/6K4e5hBNFFPJ8jP9pP\n", + "R20b2dkJVDVH1tmM23SimTkqPA5S2LBZXFRVefCqKsPDw2+a9yIajfLii3vo6RnB4bCxefNKNm/e\n", + "eEU4SL2X9PaCKMLSpRde1733wpo18M1vwvtciuI9oaGhgdYNG/jJT3+KV9cpqSrpfJ6Pf/CD8/4d\n", + "DVVVJMbH6e/rY/WaVzLiplIpDh8+TjJpEgjU0tDSzPHwGF5NRZYcZPIlukfGmcroJF76D0rRMdoC\n", + "lRiKzmh0gmU1Xhb7/Zh2O8/t24daLNPkczGWPUPaMHAhYpRLSGYRwS4xnUxSMvI8/OPTuCtqSSZz\n", + "mGaZcHiK6uoW4rOThHt6+K9/uYcvfO3LbNi8+ZwjppaWFqSqKsajUZpCIWBukhrNZvnYWxxDXInI\n", + "soxpvv7EX9c1ZFk6Z4eora2Nl+124pkMwbMOq/lSiYiisGX16vPW/9BDPyeTqaW5eRUALlcFHk+Q\n", + "J598jIULvfT12QkEluFwFLFYRFLTB7AluxnZcYxY726aVlzPlls+RTI5TS5XxfDwMHt//Wuso6M8\n", + "9MwzxJJFrBXVpNUifT9+kGWhKqoEgZToIitUI8kSjgo/BSNGsVTG6nAgnZ2D5PpFpG1O9p0eo+y2\n", + "kTAMOjZvJpPJEAwGL3ul7ksW2isIwqeBfwJ6zl76z6ZpHnjV57+V0N5yucxPf/o4AwMJBKECKGK3\n", + "50kkMixadCsWy9yRimEYjI/3sWFDkK6uQTLpAEPdvaiZDNligdn4af70ng1QUJiIqCTLRc6YBjd/\n", + "5Ks4nW4ikRGWLRPo7OxAVefyzPT3D3D69CSnTw+QyZSp8PrJnOkn5BSorA5ysH+K8ViI6IwFi1AF\n", + "TCMQRdbSLLOkWFJroX1hPQW7ncWdnTzx3HMUU2U6l2xmcGiY0XA3Bd1GwCrhFgqE3B72ZSyIYjM2\n", + "JUPI6yaiaYSaqvjIpkrsDgviokUoqRSYJsvWrGH9pk3zjlyJRILvfOchoIGqqgZUVSES6WfFCh+f\n", + "+cycjnk+n0eSpHcVAXAlh/p961tzEvDf/e7Fqe/22+Gee+CLX7w49V3OXEi/a5pGsVjE5XK97cH2\n", + "xeeeo3fnTgKSRCKT4WB/P0t9Pj60bRvCq+oYnZqi2NREbW0tFpuNYlllz55eIpESp09Hqaiw0NGx\n", + "FJvNR/+xo8xMnSBUkWNX1xg6y3E6QviVLKaRB+EMzUaKFZUuJJ+LrmQCeypNNFsCuRK15OOMmWOW\n", + "hciCG6tUwOoyMU0rboeL2mATJc1gJpukusZCZeUCKuyThNQ0DZ4AqdQQK9avIO/389mvfe2crLGJ\n", + "RIInf/5zMhMTWEURxWJhy0c+co6RdSl4L9530zT57ncfIJ0OUln5iix7ONzNli0NfOhDt55T/vDh\n", + "wzxy//1IuRyVlZVYKyu55c47Wb5ixXnrv+uuP0DX1yFJVmKxEaanx8nnC2SzUbzeEvl8iJqaG5Bl\n", + "HVE5iWd2FK2YQLYHqa+pZbY4RS5YjdPjZMOGG0mnpzn5xP1stluJF0ExKgjno3hQCBplAk4n46U8\n", + "42VQhEbyqFgcFloWLmFkfIwKOyzv6MR0V9B23a34fFUcPfprBCGBx7MAp7MKyNHU5ORzn7v7kmd3\n", + "vixDe03T/Cnw00t1/9+wZ89+BgZKtLRcP38tHp9CFA8xMXEIm62eiYkpentPYrUmqK29jZtvXsMP\n", + "v/8Y+WwS0TApFEZZ5stjUxRGkrP0nB6gxuZCLubY9cR3Wb31Ho4ff4lw2MuhQ1GgQD4/ja5XEJ8Y\n", + "YbD3FIh+rH6DO+76Q6LREQR3klsWtfHP/7wdDBHJmsZh9WCUl1Cil5I2hWy1cTpRYHg2xX/0JElO\n", + "T9LR2MJ0JIpa1Fni9NOfmiFTqkQUJIqCgVqOEdUVvBYXlS4PdsNCfZVKW0MNP921i3XlMstbWxEE\n", + "gbFduxg5fZrP/sEfYLVaOXDgCLpeTV3dXLSBzeagpWUVPT376erqoufIEaJjY5iAr6GBQDBINpGg\n", + "sq6ONevXX9WhhNu3w5/92cWr77774K//ek4A7TKRhbis0HWdPS+9RNeePaCqyG43mz/4QVa9wYr2\n", + "N0QiEXpeeokNTU3IZ3U8PA4Hx3fvZiYaRRVFDvePM5PMMjEZpnFBLb/TuYJ4NssvDgzTueEe1qxZ\n", + "QDZ7gHzewvHjp2hsrCKSChPN6pwcLlDMC0iEKRdmKOomAamRvCnjEdOczsDImTGcskiDIFKnqyS0\n", + "CEkzRqVYS9ocRhHasDga0LQ0VsspRLEShEpMI0GpcJpQ6HOIIiSHeti0eh3ZXJpyMYdQKGAUCpw8\n", + "cYKNm15JvBYIBPji175GLBajXC4TCoWumhQSr0UQBD75yY/w7//+GOHwDOAAMixYUMHWrTecU/al\n", + "nTvpev55rquuZspiYSqTYeMNN9DxJjvDqpqnq+s/mJ2dQtMETNONKMroeoL6+qXoepx4vJ9QqIHk\n", + "RBcSWTwUcBamiZ8ZIye5mEpP8cWv/z2apjHU34OezWOIIImVFAyVxRYLiVwKWQCzBK2yg4iWx2JM\n", + "U2N68di8BNQsw0aW4PJttN/yCbzeALquMR7uY+9zj6ApLqyOMF5/LWs3X08kIvP887u4447L12H5\n", + "fS969rd/+0/4/WuxWu3ouk4mk0WSJJLJU9xxxwb+1//6HkeOjOJyBZBFE6us07QgxCKfwJJAANM0\n", + "6RsYYKFpMjg7S05V8WXLOKx+MuUiWk0zR2dnKFgbaWxcQalkUCwW6e3dR0Acpb6YwyFUYbd6GS8l\n", + "idn9dC7fSD4/RFGLMD5UQDAMSmI1Lscq1LxJXh3BL+ylMeAn5F8DRZPj09NYDR3JWiYkagQDNdjT\n", + "Y0SzGaapxmcTiBUTiNZWogrYXVYULUltdYk/+9RH6J+ZQUmn+eSt564cjo2Nsf5Tn2LlypX8y7/8\n", + "EE1rxeU6NwZ/YOAQ1uIprq+vpy4YZDoe58lnn8XncHDLtm2ki0Uius7Hv/QlWl/l6f1artSdkUwG\n", + "6uvnVFcv1sLDNKGzE/7xH+ecWq9m3k2/v/jsswzv2kVHfT12q5VcsciJqSlu/sxnWPEmZ+R7du9m\n", + "/PnnWXI2ag3mji1+9vTTWGWZhBHC62xmNpnj9PgI7Qu93La+iVgqzfb9cRJZg9b2dmqbmjndP0B/\n", + "bxflcpigv5NUWiGf0rHiR9OHsOpuEkzgoIhMjg4pS61FIqsWKQkmrS4XnrxC2ZSIGAYDgoeotIy8\n", + "4EEkg0NKsLa2wGzJR1FyYbNWMJ2MYshBfG43jaUx2hrqGR3qxuuw4LTZKEkqTR/axv/7rW9dVmJX\n", + "5+O9fN8VRWF4eJhcLkdVVRVNTU3n7JxNT0/zyD//MytDIfb1DDI8mcVEZjYf43Nf/wLXXbeGioqK\n", + "c0Kfjxw5xn/6T//A/v3jGEYQWIGuC5hmHEGI4vPlWLx4OUODh3BYQIl2sUG2sMDuxuNyYmDQk0py\n", + "wuZmQdty5OQMUzOjeAs5DEOn0hYgbuqEVIO0XiaAjF0wkCWdQQyWWaxENAHT7qKmOoi9JsBssJWN\n", + "N30Bq9XB0b2/YmLfk6gzCaoqFpESTXLWEEXRzbpbtlBbW+Bv/ubrl/RI/bLcGbkcME0TVVWRZQuT\n", + "kxG6uvrRNAnT1DGMYdrb/YTDJZoaN6FMnsCRzVMuZTh66gC9QSufvOVmGmpqaG5oID44SD6Xo1KW\n", + "WbCwkfFwhGQpj0fzIyWnEGvbgCq8XieRiW6MjIOyXsJPDk2AnFrGYYpYUmOUpmooGzPUakk0vUhZ\n", + "UVGYIVocQCVEwAmLqgLM6jVQglQyCQ4HNQ4n2bxCSRtHyecpqWV0yY5NhCyQM2oRdImg30dNvR9L\n", + "xXIQp8kEg7Q0NmIdG0NT1XlPbICQy8XE8DArV66kstLHyEjmdcZIbHqQtRVQf9Yh7tipU6wLBsmX\n", + "SqiFAgvr6vBlMrzwxBPc+yd/ctkoQF4sXnwRNm68eIYIzO2G/OVfwv/4H1e/MfJOKRQKnNyzh02v\n", + "2t1wOxx0hELsf+EFlq9Y8YZ/Y7+ZAJPZLOMzM+iaRl0oxJqVK3lwzwlcVjcZo0heN1jV1oEoKjyx\n", + "9zh6MYGZDdFi8eLK5ejfsxvNNFnRVE+pbMcUfExNjGKjGsG0YFKJwlFaKaNRppISVsOgqJl4JJlW\n", + "DGKahiiCVZAIaDIWs0hemMQjSdj0DB6LhZZgiOHBPJK0DJurFqdoRSZDMnqSSjFLz8kwTdWLaaqu\n", + "BUz6Jkd47GdPIOs6C9vb2frhD7/pAuBqxWq1vmlk4NDgIEFR5Je7D9M9KmKR/Pg9DmZnU/zJ//VN\n", + "FtQ3YLGbNLUGuP3DH6BzzRqefXYPXm8zdnuSfN6NaZYAA9MEq9UGxTNEex6jXpSwIZIxijgMsNqt\n", + "2GxWTMOgCjDyCezxCOsqKnkmNolpmjgMk+lynqhhYlCBhAddKAASSS2PRVQoGDI2r49gbQO3/M4W\n", + "mlpaeGZgEE07TU/3MOXhwwTLOQRvNV6HD59pMqDEcPqrOX7wGJW3L0LX9cvWv+99a4zE43EmJyfx\n", + "+5309XUxOJjC42nEYrGhqkXi8RF+8pNn0PUqlEg3gayKQ3SStWkEchr2yRj7n3wSR0UFeiBATSBA\n", + "PJej0udDtlpxhfysaF/M4vZ2hh+MkCjLKIpOLhdHLCvYRBBKVnSLjK6LxNRJZMPEgsnxgV2Ish3d\n", + "Z1InlKmwOvE4fIyVswyRo85fQbAySMjVgZ6XkHWdBfX1ZGIx7KpKtlSm3jCISQ5GinFagrXMKgqi\n", + "v5aK+jpMVAILa7nppg8yNTVAqMnFrh37KZzoZsg3TEtzDe3tS5AtFgrlMrVnNRmuv341J08+idcb\n", + "nE+FHoudQTJTtDYsBuZWmflUimAggKEo5HI5AIJeL/3j46TTaXyvCmG+GrgYUTTn49Ofhv/yX+DI\n", + "EVi79uLXf6WSTqexC8K8IfIbfG432fFxNE17wwF30eLFPP797yMePky1JCECe3p7Ces6muRFszvR\n", + "BYNcOcpYdIqQLJNMjiKLJVRZQ7J4kUURl6JQME1SeoqGyjqiKR3RBEMTEUQdTc9TiUoVrcQ5Q4Ug\n", + "Y5MgqecQDA3ZbkHWdUoOF0Grk2Q6hWb1ssTto1ExqLBXkMqN0dt9ipJai84siXSUhgo/ddXtzGYl\n", + "NKWbqoIXWZAolnIMTU0wnM9gdfowpmeobW7mV/ffz6aPz2X2drlcLFiw4KJL3l+JhMfG+Mnz+zg+\n", + "nCHoWUbQ6+bkSJjpmQTVgesQlBzlmR5Od59gaud+ggvrSUoOBPtiAoEaZDmIrnspl3VMU6dCHaBR\n", + "KNBksRCwVxDREmQFAcFQGElME8o40SWJWVXBYqo0WG2MZ+KY5RwVpoFThLKgoBOkLNpxGAIl0Y4k\n", + "KJRMC7NGCY/Dg7uxDavXQX1DA4VymdbFi/jSfV/l37/zHfJiiq7JCVR0VK2MRbbhRyCHRi6TIhi8\n", + "vDMEX9Z/lf39/fT0DGKxyHR2LqPlVeI07xbTNHn22RfZvfsU4KNYVNi581c4nctxOCopFmdR1Uk2\n", + "bdrKSy89Tz43ha9QxC7ImIJJPj/FAsOCXZLAMGj3eBjO5cjabJSqqhhXVbymSeOqVTQ2NXHyxAnG\n", + "41FKzgwxdZR4JkON14OBCqiIsoN0OUGTIZDGhYwfmyYyoUWJzQrYRUAuYDVlqkSRWSNJzmbhhiXr\n", + "6BqMkso4sHi9LKpvIO52c2rgBG5R5XSyjxkgK/lJZ8oYQp7qQI7K8gRSMQHhKV58chxPTQ2xmElz\n", + "8030hzNYHC5GRpOUyt20r1jGjGFw69lt79bWVu6550aefvplVNWGYajU1bm54+6Pkj5+nFpAkiQM\n", + "QUA3DEqGQe3Z7QLDMNDhsrXK3y2mOacv8hd/cfHrtljgz/8c/uEf5lRZrzGH1+ulZJpoun6OQZLJ\n", + "53FWVLzpZGuxWMAw8JkmLkFABPKKwuxUEtXbjM93HYJgMnX6B/hy07S2LEVIwBq/nz2JaUazAkuN\n", + "ShStQElNUN0gkSmkyBXtaFoRq2ggiRZMJvHhIUuGGYo4TTsO3Ypm6qRJU7JYkG020ppOMZcmLQnk\n", + "9CILlTKSrqEbJUplFUG1YpoKqpDA1HVS6TiSK0NNXSXZdIiIojKVmoSMhVhJxu3ZgKrqvNQzxebr\n", + "NPIDA/zg7/6OG1asoARsd7n4wB130Nraelkkx7wUvPTSbvbuH6dvsgKLuJBMoUgis59iOYNdaEMW\n", + "LETCB+mwB/D6O0kVEixwLmRPz17MVjeBQIh0OorX20wmk8HIj1EnGtiMPA7BCloGSyaBgoVpw4ti\n", + "QERTsEkGstVGWVGIzUaxCRqdoozdYkUzNERd54ygkKSSpJhCcjiIqxYykkxWVVkoiWhjfcQrHPzP\n", + "fx3GdHlZ94m7mJqaYmR4mGJvL4VCDvR44pQAACAASURBVJ8kMZMfwemspWyqRGbDZNQzzI5U8+D3\n", + "vsfNH/7wvDDnu8E0TSKRCLOzs7jd7ouWrfiyNkZ+9KOduN116HqB/fufYtu2Dj7wgW0XVGdvby+7\n", + "dp2mpWUTojj3AIeH00xNncJm81NdXUFz8034/SFqavpJJg9SLGTw2wJk1RxeTUMWSviddhK6Tjyb\n", + "xVR1uuPjNK1bT+PyhQQkiUAoRHd/P0dOnKBzZTtdo7PYpBpsgsHkdD9lcwJDKDJSLFBrqhg40HGh\n", + "YgAZgoCu6SiYpA0D05EjFPSwddlKln/iExiiyNHRH6OoZ1CKFmbiTpwOL+1tHhbWbuUXz+6g2bYE\n", + "UQiQKImkc6M4ZnpxBFvw2GQq8grjE8fYdXCS1Rs+RCiUx924hGf3bceplBHDRaJeJ/fce+85wk9r\n", + "1qymo6OdaDSK1WolFAqRSqV4sLubaDJJyO+ntq6Ok4OD+CsrqT4bTjgyPU3jsmWX3Jv7YnPqFFit\n", + "8AaaUxfMvffOKbIODsLixe/NPa40XC4XyzZsoHvvXpY3NmKRZYrlMj0zM2z+5Cff9BhwZHiYVU1N\n", + "1K9YQXR6GsMwSJ6J4J9IkZrtYnD2DJq9Ek9JRdeddI+exCaVGU0o1Msi/gYrtdVpxsOnKSglwtNB\n", + "FE2jrIbQRZmSOoHFakFmFgs+Biiisoq8EMWPlwJ+VHGC8Vyc8VwOpygiSBJWj59K3cBrTKGgIygB\n", + "PHI9skUnUshTxIIplTEIMRt3kDcLVHrtiDYno2ULsrQMSZaxih7KQoqgbxlPvXSANsoEHA6WNDSw\n", + "v+c0+/b18+KeYVatXc6WLSu55Zatl33I58VC0zROnDjB/fc/gte7lIpgPWMjA4hUoputFIonwGoy\n", + "FttHg1lEEQUSagRTmJuAl9S1cXBqGG9NBaI4Qyz2MoIQwEEYl0XFY9FY3FzFyMQZdLkKr1miWzPw\n", + "4aBSqKQsZpiW3BSdfiYK06yw2EhrRSSLBUGQ8UkSvjJYvH6mE3lmNQUDkUK5zCKLjLWUQ9M1vKJB\n", + "Kl0k5vVQ2D7KsWN/S5U5S6XXS3VtNYVohha3m6lShCldBynGx29Yzd0rVzKTSPCL++/n0/fdR+js\n", + "2PxOUBSFJ37+c2b6+vAIAiXTRKis5O4vfIHAG2izvF0ua2OkpWXdq6R2G9i58wCdnR0XFJVx6FA3\n", + "fn/rvCECsGDBYuLxJG1tS6mrWzB/PRiUsNuKjOciSJkMZVGlQk9RYdPJWixMY2UkY2AT7FQEm/D7\n", + "NzCZLDFWHEXpPc3E2ATLmxv52NpVmNJJzsRGMYmTyMexCjUogpuwMYZMAisaCgIGBQRC2JjGQCWE\n", + "A1MroydVhnIZzujDGEt6qJFEvnzzFiLjE+zbe5TBrl+RtDmxiTp79kaRZR9L2hZQV9mEbpocPx7G\n", + "lXajlcbxeRsYj09QLqSo1ksYA8fojp7hjF5Bw4JPoKpFZmb6yAje8+bBsNls51z3+/3c9fu/z3O/\n", + "+hUD4+Oofj+Jxkb8lZUMRCIUAKm6mk9+9KPvut8uV35zRPNeucG43XPS8N/6Fnzve+/NPa5Ebv3Q\n", + "h9gpSRw4cADZMDBsNq6/8863jKYxDINMPk8qk2d0Ypp8YpbkQD8eawVLQ40UYkX6wwfRdJWiYaJI\n", + "JvaqRmZVBYeog2wBBOyeZYQzk/gdHTisdkxGsbk0MNOo+TOAwgQ5NBqQkUkKVajEcJgapukgKohU\n", + "idDsdGKKIqOFHJOKgEeuQtVMBDRspLFgRzcL6EIew2xFEu2YuoaWzWN11XE6sY+C2UbQ2US5NMtU\n", + "KoXbU2BJ8wqOHT/B0sUhZrNZ/vHHP2Fi1kVLfQdW3YbLtZwXXxzAarVw001bfit9dinJ5/M88MAj\n", + "nDoVJRx2Y7XOkkgOYXV40PUWbJKdUnmEkjqDqruxWA1EqiiXixTVceLxKLUNjTgLEZLJIQShhGFE\n", + "0PUydinHkvZWxJKTiako06kSmugki4scC8khMkUEUxWprGjAI9mZjIVZK4kscLmgXEYBSi4XFRQZ\n", + "nemmFj9+zYJipoiTRETAanVRsNgYLsvUVjUhOpwsqGrgyOAwjmqBZYsXUDQMssUiw8kYUdVAdbi4\n", + "cd1KFjc08PNdh6lwWvF5rBzet4/b77jjHT/Hfbt3k+ntZeOrTinGo1GeevRRvvDVr15QH13Wxsir\n", + "VziSJCNJlYyMjF6QMVIoFLFYXlnpZ7NZYrE4ExOjPP10gvXrt7JwYSsTE730H32elWaeoWor01Pj\n", + "VAIFWWNIl5kq+jGFSmTZx4yYx64JZPIqiTMaIyOT1Nd3kCvYiScreObgEKsWVTOd7CeRnUWjllK5\n", + "hNe0kKOZGCJBSoCOieWsLK5ADgsFwEkAm1BCsBpEyhYeeegpbm+r42SyRD5foFTO4TatTEVjhGxB\n", + "/KoLpaAydOg5Bvx1hKoWY5MkKmw+bFYoiils5TgdbgfDmTKJxBSUBSo8DuLRfmRdQdKLZDJ2Dh48\n", + "yq23bn3L59rQ0MCX7ruPdDqNJEk4nU7GxsZIpVJUVFTQ2tr6nqREv9Rs3/7eHNG8mq9/fW7n5Rvf\n", + "gLq69/ZeVwqyLPOB227jxm3bKBQK5+TzeDN0w+DJwyNYShXkMzLZrIC1ZMORzyCpcTyGTJVpY6I8\n", + "Q60YoNFbRb6g4G9qYjo1w+nBKNZRDV/VMtzVJqJUh6JqKGINHr9ENuNEJU/AGserlAihYDDJjCER\n", + "oRkoYTXCLEGk0tDIFjTyBjgFHxWym6QhIqt2RMGgZKbJkyJLAAQwzQJxNU5AgArBRiajooserJYS\n", + "ZWZQ5CyVNpFGf4BCIY+ha+waHWVxMEgiY9LubSQTjxPRdTRNp6FhBbt3H+WGGzZdle/mq9mx42Wm\n", + "p200N19HONxNINDCwMAEgpCistLD7OwUiBqKUkISFzClzGJXEggIIHjoPdnDiZEB8vU+fL520uky\n", + "NpuJJJVQtQFeODZEi92HC4G8IZI1ZBJCEMQGTMFFUW/E5BCFgoTDBjZRJiNJOOx2VFnGabVSKpcZ\n", + "z+VosVVgKllMM0clOpUYRHQYyeWosbloEiA1NcoZmwVf7QpERUNRXYi6TtDlQli0gMV+PzP5PA6H\n", + "A0Vx0D9uw+2oIRIv0j02zKnUk7QsXkxDQ8PrEgjCnNFeLpex2+3z87BpmpzYt4+1rxmEmkIh9obD\n", + "xGKx86ZPeLtc1sbIazFN44IjMTo6FvLCC2O43T6KxSK7dx9B1z0sWtRCdbWP7u6XGB/fRVO1nUY1\n", + "S2swyKr6eqILGtg7MMBMsch02ka9pQpZspNXRLJSiHzBwDYVpVgUkFWB0uwpymWNrtNnWLmsjUd2\n", + "9rC0aTUzgUnUeABF0Mkpkyi6j2lMZCZwUsREJss4ZVw4kRjBxCtqiKZKSdVQNSf5eJGu+FFsliok\n", + "uYJ0vgi6gls0mJLtKIoNxZjFqUehFKEw20tRtNBicdEYsiFkMnRarZTLKnZBpEFR6DPiCJqOv5zC\n", + "Y6/E4YLiSDfPbs+/LWME5ozHVzunLly48IL66nInk5lzLt12YSeHb0llJXz+8/Dtb89F11zjFWw2\n", + "G7IsEw6HKZVK1NTUvOF2sa7r7Np1lLqFN3Fi9zFC7ioKmQI5qZUUgwSTJQTBjaDYyJoy6ApyOkXA\n", + "4+ZMbJKEpwI0D26PhQqryvjkJHUt7dQ2NrNr10HKZRNFMbGj4cOBEwGNIlb81FKmxBls+BBIEURH\n", + "M0FWVQwqUAUPFgQGdA8OcrhMgTIOMtixImAYBZzkcKIScHqR/H6KhkCF1Y6VBKrSjd8qIEoWxlI2\n", + "0iPTOANWAhosr6lhNBFHKSsY+SLlconp6Wmqqqool01KpdJVd3z6akzT5MiRPmprNyGKMpCnp+cI\n", + "IFAuF9D1FLqexeVyUBS9mIZMUqkAZglhx2v1kDIzTGRzWKY9OBwNlEppHA43+fwU+bxMxvCRyRcI\n", + "SHYyCGTwoZo1YEYBKwJ2wIkpVJHMjrJEsjOum1T6fAREkVQuR388TlmQcIoeBCFJi+ihqGfJAnk0\n", + "Wg0DR7GATZSoFi2YmslA70EM7wJGJ8KECnnaq6tp9vmYSaU4rSgUTQtOsZ4q39wCvqwWiZ6JkJlM\n", + "8tg//AMD0STBRW3c+YmPsX79WpxOJ4cOHuTwjh3kUynSpRKNixaxccsW2pYsQVUUrOfxybKIIsrZ\n", + "9ArvlsvaGDEMY/48U1XLQJzFixe943pSqRS7d+9haGgSm81CsRhmbMwklVLIZstYLGmWL19KR8d6\n", + "NE3jxRd/xoHnH6etWCSZyTBjtSJ6vXxh40YeONVDSQjgDjQyFIljCDaCngBZtUQqNY2cmCCo5MgV\n", + "ZASxmmSpxJ7uIRQ1QTrbxVRKQzcdSKaAIFgQ8KIQZIwpKsmjUKZIDV485NERKSAZYBcErIZGLlGk\n", + "rBuoehmHmqTALG5MdBSihgtLsQqraANitJo6IV1AlOyMKRn6S3HSmpVlpsmwpqNbXAQ8NWRzaazF\n", + "FIam4nb6aKzxU1dbQzwT48j+3fzd3/0zVquF665bxsaNG963jm+v5YUXYNOm345k+5//OaxeDf/5\n", + "P8PbyDz+vmFmZoYHH3ycZFJAFO1oWpzGRhfZ+CzDw2dwB0Js2bKerVs3UywWyedFauubGWvWUE2D\n", + "QjFLUKoimZxFKSaIlX6TTFyjRBVjap7BdAq/exHN7lbK6jSz6Qym0YxVaqLv1F4KpSyaZmIRgogY\n", + "gJtJEliRsQAyUZyI+MngxYFKEh0NOzJFVDRUVFMkrVnRWUEeG2mmMZnBQpoq4pQoIqLjwCCejmCW\n", + "nYgWF00OsJomdjWGQ/CR1wyKchZPQyN3/e7XOPnggyTTaeLxKQTDiSZYsTv8HNx7DJtNprraisPh\n", + "wDTN/5+9Nw+y7KrvPD/n7vftL9/L5WVl5VL7IqlKCxLakAQ0IIwYSfbYGsB2Y4+XgY7ocEdHtMPd\n", + "MXbP9MREdxDhCAfRBgLcQLC2EIuwbCS0IYykKlWpqlQqVVVWZVbu29u3u9975o9MZDCysSRQCTPf\n", + "vzJu5n3nRp777v2d7/l+vz86nQ6apv3CFSZhGLK+vo6u6wwNDf3EglVK+fK75MiRo5x78QL9nkoU\n", + "CVyvQav5LOXyTpKkjGmaOI5OElm0ZIWm7GCEVfJpi0p6kvlWxPp6Hd836PeXiWONJJkCcnQp4yTT\n", + "aPgYZBCsEVEkRAdWEdTo9F1SLGFJl4Ew5IULF5CmiQHErgdIOuEaFpKaUHGJ6RPRB7KAToyT9OjJ\n", + "FFmZp9qts9KV+OEcYcPi6KUNSlmVPRPjTG3bxpG5JrvzOlIm1Bo1zpx6hGIYo5lQvVBj/+gups+t\n", + "8rWvHeX06Qsc2DfOhSeeYDKV4uz0NPl+nzMnT7Jx6hRD+/dTHhtjuVpl+4/oTfqeR7ilH3w9eFMX\n", + "I/Pzz6DrQ0gZI2WVu+666cdCaH4apJQ88eijfOovPkWrYWNaJTLlMqXhHOn0It3uOqVSjoMHr2Zk\n", + "ZBIpJSdOnObUsUtMhjoVTWA5McXEpyu6zNRq+K6DZQ6T6MNsG93GUrVHw5F43gYyqTHlh6z6DkX7\n", + "GlQUVClZaDXwsHHDAlFUJ47Vra0YH4mKxhpDKGQYoksRiywxfSwUXPI0mKMse1SDHAECl5CL5MnT\n", + "ZxKHLAZnkHTIkJU1/LjPTnxGsHHpEURtBmTADmLqrsdGIkkJFZOQTrdO3tDRvBgvClAMlcJAloSY\n", + "5y+dJ7S24ftjZLNlHntslunpOX73dz/4L84V81rw87L0vhLGx+F979tsoPfHf/zGjPlmRxzHfOEL\n", + "3yCKxpmYGCFJYk4c+VuO3v9lxvJZhoamqK7M8WA15vz5eX7t194NJKiqhm3bDAxsI5UdYO38c7T6\n", + "XZI4R4pBNAzAw6VLhhEEEX1Hw1A1HLdBEgxTr/Xp9Dv0nC4Rawh2E8s0EhMJROxEMk8GiwSXKkvs\n", + "oItKF4hwEMSoeFgEhPRZo8EuVFJoQkfIARIukmIFg4AcfTr4OOhkpCTjOgh/kWpPsFvPMDW8jWwx\n", + "z2qnQWp0kF1X7sdKpdhzzTVUL86SsXXWQ4/BgSlCVLxUgWeffYSPfeyjzM/P881vfpdGw0PKmAMH\n", + "xrnrrnf9WI+bNyteOHWKJx98ECMICJOEdKXC+++7j/KPNAFUFIWDB6f48pe/xbN/d4GiNoJlCDyl\n", + "haXpJDIijpbR9EmEWCOKmiTJdjS1jJQuqJfIWBInUIljj42NZZIkhRAJUlaAzdZqEgtFGujo+Cwg\n", + "mEDDJkElZhxJhpiXSFCZj3VMJEUZYYY9ImAdFUGeDVRGMLgkO0giykCOzayoGJBE9KVP4nk0hYcr\n", + "HQrmDght3MDjpX6LeW+Rf713H5VRg0DP8sz589RXZ0l3Wuh6hna3xUqgYuoDbC/maQcRy8sJiy/c\n", + "z92HD3H8Bz9gUFHIDQ9T8X3Ot9sM9Hr0Mxnm4xh/ZYWhfJ6O4zDX63H7b/zG634nXM5GeRXgIWA/\n", + "kJZS/kT7xI985B4uXpxF1zX27n3Xq96POvH88zz25a9gBgNcO7UfiWS91cLp5EinLd7+9nHm500q\n", + "lc1QoFqtzvnzi+iJTzGbhygk8PpIN6acEjw6Pc1Cz6flr5L3doCSQlUzeH6CGznEnXliXaBrU3hx\n", + "QOC3sJMYXbok7AO/j43A4yQxZWJ6QAeDDmVS1AlJUcKlTUhIgxyCDAk+q/j0aKJgkecwIV161LnI\n", + "KoIODcZRmKKHAZzEANok9ESKDJKchICYAIGuGCgoiDCgS0wmM8iy0IhFFrfqcP7732fbkIk0Roko\n", + "cOTIixSLeXbtmmB+fp0LFy5w4MCB1zX/nucBvKl97/8Uftil99//+zduzI9+FD7wAfgP/+H/j4iH\n", + "zQ6q9XpCKqUwMzNLt7OOO3OGYXUESwgsYZJpdTi//Cx+fBNXX32Jctmk05Eoiku9vkJt5RKza+dw\n", + "XAdbjhPiA2CToodkjRmKsky767HRCchqKbpRl5XmCjKsIKgAbQQxEguDLDEhKjkkra1vnIXFEA4e\n", + "Y0CIZIbMVtmi0EOljoZPE4ULRNIgoY6gj4qHSkyL7QyQR0dQp0+DZW5MPM4IldjvsrG+jB/00G3B\n", + "5GQF1XVZWlzi1PQsYnGdqw/cRC8OeWllhjXHY3LyGoaHp5Ay4a/+6lvk8wfYvr1EkiScPz9Dq/U1\n", + "/vAPf/tN7bSZn5/na5/8JNtsm3I+z9jgIGfn5/mL//pf+Z2PfpSJiYmXWZJsNsXMzHOIxCYhpNdv\n", + "EycrFK0sjoypV19kcMSkWCzQbDrEuCTxOopIIDJZabhoRkwqHeC6HcLQAWykXANWgSwJ80gsEnaS\n", + "UAOyhHgIxhBEQBGFARRGiVjnHH2KsssQHTwkg+QoYXEaSURIloRhdEYI2dwA0YnRERgkuIRynVgY\n", + "DOi7iGKNtaiPZRbRtTzV1iW+8tjzXHPrlRiWQiGfx+umqYRpUghkolFWDRpLy2SVbUR5F8PIUa02\n", + "iMMQv91+uXNxxjQJGw0qAwMcW17mf/vIRzh94gRzs7Pkd+7k7htvZGJi4nXP5+VkRhrA24Fv/GN/\n", + "sH379ld0c/xzceypp9ASlbS1WcQIBMOFAudXVkjlJsnlcsTxHL1emUymwMmTp5mZuYDpraDagyy5\n", + "85Q0Hen5vLSwyNHAIj30FsRGjfXmSSQVitkS2ZSPaRdwehX6yTIdv05eQhpwEYTEgIuKi0aBDAU8\n", + "NohYI6GHwiABMT4BFh6CAA0bkxwJCi4KGSwctiOI0dAxEWRI41HBwSJFBUGRHhKFEZrMkJBGlzEp\n", + "AkKgQRqkoCkCbFXDTgROAsuJQBm4mnSQwrYUNnpNTq06SLHBwNAuthX3Eschx47NMDiYcOnS4msu\n", + "RprNJg899Cjnzi0iJezdO8Z73/v2H1vJ/CLg523pfSW85S1gWfDUU3DbbW/cuG8GLC8v88yTT7I6\n", + "P09xcJDrbr0Vz/M4efI84CGETW35OUa6G6TUIvXaKqobkzFNRuKY2dMn+MTHz/F//l9/wt/+7Q9Q\n", + "xQoXT53Faa6Slz2EGKCVQB7BNhSyKARY1HBRkrPYehoUwXJdxQktkjCNTFZRyGNRICAFCCBBUqRP\n", + "hE5MiIJPhI6NRxoFl2Vs8kwRE1FHAywkgxhcwmcGQRaTUUJapMjQJkuKIUJCTCRjFJhGUuUStlAR\n", + "hkWsqZxr1JFpC3mpzdnFk0Tj67z1rXfyxLn/wcWXzjI6UqY8NcH1h25j27ZdLCwc4/Tpc+j6GLnc\n", + "JuOsKArbtu1mfv4oc3Nz7Nix45+YlcsH13X5b//vn7N+ts1SyiZOlllrPEUpN0zbV6n2Ps911+3k\n", + "vvvuJpVKcerURa6++kaebTxN0p8jYwrcSGO9H5BNl0iZu+j1GiwuzqKqN6GINIkMSGQI6ARxF9wG\n", + "aQVgGU3bThjWEEJlM9F+YyueYQSdGgKBRCEkjUoEaAg8FFKkSaFRRWUIlSJLzDNGBwMD0CgQoGCT\n", + "Q5CQIKlikGcFSBMRo9EgR48OfqIgkbihj6bswAttlCjBCWPOLy2Smg7RtO9Tn9/AbflEQZWdpqRg\n", + "DWDqOiJJWFhdYv8N7wASpGUQRtGPrXbcMEQ1TUxNQwKlUol3vfe9P/M5vWxlr5TSl1K2fp5jdBoN\n", + "BjJp4iQEwPE9jp4+zYsnT/P4Xz/Iw9/6BnfccRVxPM3Jk3/D2bN/RzYLmeIQrppCLR5kXUsza6aY\n", + "jiQDqTK91hpOVEDKcZABze5phKqzfeJKLMtgLUgoyjZZJAOoDAAWkNAiTRETGwObFFMYWOTxkDSp\n", + "EhGQsE4LjwSJjY5AwyOFg42KRQHwcOiRIIlQiTARmBRISOgBkh7bWSaFB0T4BFLSwsQhj8UI2WSA\n", + "bhyxrOisKimS1Dhj+QM0ww381jST0QZDTpegPYNh+GiajmmmKJUmmJtb5LUuljzP49Of/gqzs4Kx\n", + "sVsZH38b8/M6n/nMV+n3+z+bSX+D8PO29L4ShIDf/V34zGfeuDHfDFhYWOD+v/xL9Lk5rs3nKTeb\n", + "PPLZz/Kdh75Dp9OlUBijWBwmky0DNrXaCpqUDGQyOLHP2eos0epLBC8c539+/OOMDVlMDLQ4NNxl\n", + "30CWayYOU7Cy5ElQ8UkRkuDRwSNHzA2K5KCQtC7O0ez2cL1xkmSChCli2gh8dHwkHWJ8JH1CwCOm\n", + "iU0HnS59miScJsMyGhsIHDRM8phbT4gEG4MJdFJErKNRxMBGZRsKeQRpPMAHDNKskSaWGudihZNe\n", + "jpVkDyvBHh578RILrT7+Wp0zzz/Fze/5IGLsGmr2bq69/T7GxnbT67XIZCJ8X5LJvJIIKU273X4j\n", + "p/lV4fHHn2JxHrYPXUmltB0vUKm1x2j2BhnOTVAqXcn8PDz00CMkSYLj+Bw48BakEoKAti+pOVmC\n", + "uEy9t4Kdy1Mq7ccwIIoaIDZDKSU+MT6go6p5PDePSEok0TlULiBYI0udPCtYJMQ0UABd0QlwEWjE\n", + "xICDwAUiBJvb9BJBDoM8aXKARpc2fSJCfCJUVBIkdTRSZBmhSJcU57C5RIkeNhYBA8EcWdqEyTJq\n", + "4KAHARYmOW2YXqeDre2Cfo2r8nX2DqgIEdDxanSCPrXYZV0xGByeII5r3Hrnu7nUaKCm03QchzCO\n", + "mW632bdnD4u1GpP79//cmiy+eTm4nwFGp6YoZC3CeAM38Hjyuedpr7QoiDRFNURcqvHApz7Nhz50\n", + "NwcPVrjxxpvIygbDMsGrTbNWPcu59QXsxirlUMHvOUTdAiQ2UpQR6l4k+1irznP6xafoORZOUiIk\n", + "pM0CVdGjS4BFF6iTIsEgQSEhpkqahAiLDBNEjGAxjEKPFgEuDj4tYuapYJJC4tBGpYfBMh49ekh8\n", + "fDQSUgRY1AnYQCWgxgBnSTgPnEGwgIVBDp+IEEE/UenLgEAmbHQ6zNZPMKn1uTY/yPbCEPvzw+wz\n", + "VPqrR+j3N2vGMHSBDqXSa1NQnj17jnbbYmRkCkVREEIwPDxOt5vmzJmXfmbz/kbgjdSL/Cg++EF4\n", + "8EHY2uX6pcD3vvMddmcyjA0OYuo6g4UCV4+O8uyjT3L48GEajRdwnDpmdoQWPlG0hq3pNL0eT86d\n", + "I+UaDFOirJbonbnA8QcfZO6FF9E9g4KVJ3IcYq+OQYIFeIQ0CYnoMImDJQVJr8+obzNCB0ELgxgT\n", + "A31L36VxCYUFoEPCKirnMBgAXLK0iHBxyNNkjIAxqkgW6aOj4uKh0SBhGZ82CktoeKQZwEElISFG\n", + "INGI0OiwSWkL1aRu5KjL7ayLCm1tiF6kEoQjKDLP9kRDXDpHc+UiO3cO4vtNLlx4gYWF0zjOS3zg\n", + "A3cxOVmh2228wn+9/6Zt25AkCUePnmFq1yG6rkucxKzUGgzm99Dpx7R8n0wmw+joHl54YQ7P85iY\n", + "GEEIwchkhcXuCvWehR+mcaMEJ8ixutai0eihaRXieBUpe6hqHkX5oe21hYzTqMl+LK7AlDdhMkZZ\n", + "rrKLLsM4FOgzKFw6xARJhog1IhbYfPZvoDCDQpYedRJAByIkMR424BCwhKBOmRoFZjY3lAhQqJKw\n", + "gUcV8BjEQmVsq1wV+JQRbKeGFC36eKCEFI0BgsYCmSShlNtFgMJ1g4PsHhnBNyWngjXWM2nSI2N8\n", + "/4nP4VTP4HW7MDFBb3SUJxsNvrO8jLVtG4mmUbVt7njPe35u8/qmFrD+2Z/92cs/33777dx+++2v\n", + "6vyb3/EOvj4zw8HJFN858jidlkNeS2OkQt66eyeVYplz8ye4/0tfotmLaS2e423bKzQ2OgR6hmZ9\n", + "hrzfQx8ZwGt4tP0cNlNI6dCnQZLkkTKEqE5WmSQhC8Q45FDFLBkuUcAgS0AXDZdpYiwgxEKQRcdl\n", + "mGHyhEjq9IAUFh0iVlAoMUoaiUaVBkPUGd1iS1aIcLAI6aNgUkelg4XO0JY8rkef3BbFa1KhSYoa\n", + "eQJcInpC0MHETu3ANip0G3N4ccCiW2W4XEHIkLFsijBcZXHxKYaGptB1l4MHJxkZGXlN87m6uoFh\n", + "5H7iuG0XWV7eeE2feTnwQ0vv3Ah10gAAIABJREFUHXe88WMPDcHhw/DII/D+97/x47/RiKKIjYUF\n", + "9v+D7VpT1zHDiLGxXZRKI8zOXkRRXPR9u2krdVreKkcWVpCBIJ8ukbVNuv2YpXMb6BdmmPMdMsYg\n", + "bi/EUgcoa2VW42W6qAhMAjqM0yKHSV8GpFUdpMouIvqsEmGjAQYSECR4ZLlEnWUEeRRiJNNkiQkI\n", + "MRhB4yABFgkBCSYJK6xxlhIqwwRbT4B1FBQiQroYOGxHYQUFC4GCD3hIIpooho2hj2Cp2wn1DEES\n", + "kQ99UmqRAJNGv4ctA8K1WfbdeQeZDNxyywh79+6iUqmgqipXX30lx449QKuVpVAYJEliVlYusH27\n", + "/TPRAbwabOpVznPy5FkADh3ax969e38iAyVJEuI4YWJqB0cXl5CtBrHcZBq6rs/U4DjFYhEhBEJo\n", + "eJ7Hu9/9Nj7+8a+wtlYlFuMk5JCoKKKMpqtE0Vnq9TWy2TK6rhHHdZKkipRtQAUUNAZRSQijiESA\n", + "IjV0UigkFI1h+mEfRRbREVvzHJFiBo1lDDRyWPSYRUGw+ZxPWKTNDrokwDLDeGSxEfgImpSJ6JLF\n", + "I0eLDCo5TCJaxHhIHIbZFLU2WCEggyvnCNSrsBim6sxRVl1UGWDkyswuCf6q1WJYl1RMkz1X7mFB\n", + "VWltnKaSFNk9NMFAtcpSEHDHvffym//237IwP4/TbjM4OsrBK674uTop3yzFyCuS3T9ajLwWTExM\n", + "cO/v/z7ff+QRopMvsT3TYc9khanRCWzDpNtrUl9r8uADj5MZmqR25jgHD72VkQO7aDSq9BunGdcE\n", + "DdelEdkImUYRBqZUcQUksoOgh6WmsfUsgV8lS8ggKUK1RC5Zx8OnLwUBLhKbLComGSw8mtTRyRMD\n", + "IQkm4GGRQqNMjy51VogJkZSoUqGPhQr0GUIwS50uMTXS9GmjkCFkHckMBbqUUAm3gql1wEbDRyDI\n", + "MEGHOUyylQP0ejFxAorYhiMbVLsOumhRyWiMprJkD06wZ89hoiikUGi+5r4Gg4MDBMHKTxz3vA7D\n", + "w6/esn258PDDcPPNP9suva8Gv/qr8MADvxzFiKqq6JaFFwTYpvnycUVRyJbzdDo1JicPsm3bZqZN\n", + "t9tkcfcgzbkXyU13KLoe6dAgim36fhM7CDFlhEgCyuEaUiq4gU9dGgQEuASkEBSIGUMjQKcFpFTo\n", + "Bg5gUCFkgzo+GSK6aLRJCMlSYJwebdroxAyhsB2TGQKWMNBJo6ESoQMJMQFFqpTJo+NQxkAQcFFA\n", + "RmqkCVhE4lEgZB7IEuMznHXxgg4rURldOmhqQiBdYreDrheRmPhBFVIauj6IW69Tr68wOprjzjvf\n", + "xeMPP8yTDzyAIQSJZXH9dVdxaX6FxcXzQMyhQ7u48853vKHiVSklX//6tzl+fJlsdjtCCE6depLD\n", + "h8/y679+D4qisL6+zlNPPcvs7DIrK0t0uzZvufVWps+exZk/R6ezTrFS5K233IIQAsfpkskoFAoF\n", + "SqUSV101zhe/2EHTykQMADFCZIjjBNBQlBjf30BVHZIkg5SSTWmjDWhohChEeDJCEpHCAnLErGAz\n", + "wIBoU5NLqOTxcNGosR2TFAYBfbJsoBCwikmEhSRgnC4aMacxCYkZo0kWhS6SNRQCUhToYxPQpYxB\n", + "hlECNqiyFxVD0YgUi0LcY024bJDGUrIkSodSIU2QGEwvzRHGguuveT++p7CytsTx3iV2qCaRZ3Dz\n", + "xE4KmQL1WpNadZobbjzEie99j7f+8R+/oR2fL6ebRgO+AxwCHhZC/ImU8uhPO8/3fZaXlxFCMDY2\n", + "9lPtRBMTE0z83u/RcGOOfv0xDoxtKg6D0Gd2dgY/yTKy/TCTu6/g2dOnOfrcs2SzJdzmIqLTwCYh\n", + "dEJ0mUcnIJQtImyk3FRxCKqosgfuaQqJg0ClQxo9hiIaJ4SkKsZIkgwORTyamGwgiFCoYhLRQMfB\n", + "JkTHJ8Chh4rDBDohKwRIRojIoWMhSROiIlCQVAGBwSoOKueIcRklS4XdGEpAI1mnyAZ5BH0lg60o\n", + "yLhHlwgDk2ZzgyDYgbSHcb1lNBJ6UZ3hgkkvdllREvYrMd/73gNEUY+77347Gxsbr4kdOXBgP48+\n", + "eoRabZlyeRsAjcYahtHkyiuveNWfd7nwzW/CPfdcvvHvuQf+9E8hDDeb6f1LhhCCw7fcwtmHH+bw\n", + "xMTLL8iLKyu89Z13sNHpsLR0jkymhOO0ieNVPvKR32JxYYH/508/yVrzElpkousCVbYpGVnm/A7b\n", + "dYuKTIgDybrw6CcRLYqEDFNDo8UiHhuMCJNAscmHXSJaLGFiYxET4SCxaZEG2qTw6BKi4hIyicIk\n", + "FllMhvHoAB0uEW8tLjTKpGhSJMSgikmChopKipJ0qVHHwkenSYpRBCY+M2iKQ8kqI3KHGBjZx9za\n", + "Mkv1dUxjB5FqE6GiKxqK6BF0A6zKODPNRfyXHuOuu97Np//7f2eo3+eWsTEURcHxPJ7/wQ94z4c/\n", + "zOjoKLquXxaH29zcHMePLzE5ecPLDpiBgRFOnTrCddfNkkql+OQn70dVxxgYOMS2bYM8+eRf0+02\n", + "OHDgBqx0wvHjP+Da696OlDG12grd7gwf/OC/QlVVpJScPHmW4eER+v0ucbyHOI4IwxZxLIE14rhG\n", + "kuSx7d3EsQMsAwkggVUcYjSKSAqoRMRIoIdBhSj2MBOooLNElR46FgYWRVyWkHToEJEiIoNPmx4F\n", + "YIyEBKgD40jEloIoDRQJOY/LKDo1FExagEMDnywhhqaQiATd0LD1As1um4gmffl91EhidIdI1Awb\n", + "rRe5YtdBRkvbEUJhdGiIsxsjNJ1lJrI5BrKbrplctkSzFbO2soZayNFsNl8xO6Rer/PMU08xd/Ys\n", + "VibDNTffzOGrr37dxetlK0aklBHwzldzztmzZ7n//u8SBBZCgGl6/MZv3Mnuf0YHsXe/+w4ef+gJ\n", + "FpvrbMsP0m7X6biSmgY3XvVWmo0Wq50Oo25As/sCRhyTN9KsBgERKnkp8VWdZjKLK0sICijUEZyn\n", + "mCRsI00RHY+ARaq0ZZdFfAJlByhlokRHYCPxcDc3SDDZiccG4KChEWNjUCYgR50cPgsMkaVLnSwh\n", + "KWI0ElRAQ6IhidlMK1EYYJP7iJG0CYnwkx5FIchIFQ2XiSRBS0BoWSKR5ywJq22HJFlCEdtYEk2s\n", + "YA41yrC4ruEoKpkxm2PHjmOauykU9vPVr07z2GN/wn/5L3/ElVde+armPJ1O8zu/82t885sPs7Aw\n", + "CwhGR/Pcc8//+guRaQAQBJt6kY997PJdw9gYTEzA0aObDM2/dNx0yy10Gg1+8Pzz5ITASRIKU1Pc\n", + "d999JEnC88+fZH5+jcHBItdddwdDQ0Ps3LmTp595kW9+3aDVrjFq2USupBV0qZPwFruMTR837rDg\n", + "ezSYRGWEGIvN9pT7WcYmlEtcFUNKKAgk4HOBNh6TmGjEKPRZYAIXiywZDFpUcbGo46MjsbHosoFD\n", + "HpgkJiFhBpsaZXyGUeiTkAF8+iioqFtkv0oLF4cCHtemMihxyHKrS095CU332Ta6m9BwqNdbCF2n\n", + "7ldJh3W22QbDxSEcsU5LSTFh7uFbXz3ByuIZrpg0OV8+TxAEjAwPMzoywnNPPcWHfu/3Ltscnz8/\n", + "g2UN/1hgmRAC2x7h7NmLNJttDGOSwcFNVnb79h3cdddv8uKLf006vczb3z7Fb/3WW7lwYZ6FhdOM\n", + "jQ1w663/C1NTU7RaLb74xa9z7NgCvl8iis7hu49gKHsRUcimNbeOpo2gaddhWR5SQhwfII4vsikZ\n", + "3gMIIiJUVtDIolAjxiGmgEwCElwc6kRkUFBwyeJykQnApkxETI0ma/hkyLJGjw4h9hZLFiBJAxFg\n", + "AiYaGh5NYnagoGHSR2MAnyVgIQqpGDZxnLAe+5xNBgiUXSSygkwaNJx5hkwYICasz/PiwgVy2TKR\n", + "rrPzyqs5fryBG3o0O3VymQKqopJO51lbW8fMZ19xS6bRaPDFv/xLRuKYq0slvCDgyP33s7G6ynve\n", + "977XdQ+8WbZpfipqtRpf+tLDlMtXY9sZAPr9Dl/4wt/wR3/02z9VbLVnzx7+9f/xIb782Qd4Yfp5\n", + "6hurdMIUt7z71wlDwUvPPkc2NYGnLJHva2RVhYaqUtdzCC2hG4d04zVCxjAMCINFFBYZYZ0p0oTo\n", + "hKjowCgeSwQ0GSASo7hREYmDRgOTFBpj2Myj0UPFpEOdhACNXVgEGOQIGaCOgkuMwiBpzmASUtq6\n", + "YWMk60ADHbEVmRZiopECctSYpkyPKT3PbORhSp+SKvAjBSdWQFVJywQlhkB2MaVPDw+fYdJJAcMQ\n", + "pI0M9dU+woLJqVGKxQlGRvaytnacT3ziC/z5n//fr1pZPTw8zB/8wW/Ram2KYt+sIrl/DE8+Cfv2\n", + "QaVyea/jXe/a1I38MhQjmqbxvnvvpX7bbTQaDWzbJpPJYJomuq5z++1v+4lzVFXlN3/zbp577gWq\n", + "1h4u9aq08SjqGgWzQuK0yKY1fMOgEQySF1fRR0MqaRRAiBmiUCVLQpeEQMZYKOjY7MJkmj4lioRY\n", + "pMmQJSYhhYLK4NYatk0RnSYuFgkVFKaIyCBQ0EkR0KZPjQIxEaAQYgN9LIxNHpYAmyySq8ghvB49\n", + "JWa3qlEYKNNWY/xonfPdBrncDmCZVsvFDRWWfZeVahs1n6NcvpphTIZzZapumqPHLpHbafCO/fvZ\n", + "WFvj2NISxTB8Yyf1H2BTp/GT15AkEYahMz29wNjY7T/2u0KhyMTEft73vne+HAFx7bXX/sRn3H//\n", + "t6nXcxw+/E6OHDmPoXaIlRph9AIJNiohCQlJYmIYEb2eSxxbJEkM5BCkMcRuItklZpF4i6XKYdJm\n", + "lBAPVa5hEGChsxOFDVwarJPBx6AACFQibMDEIMJnFJ0+GnOE5AhI0SKiiLvlu7HxUYnIAGkEPhIh\n", + "fEoS+oAQOn4SIG2TS2GBWNmBnT+A31exRIU4KdGVJ9lh5MkGEk822LHnWixLp1bboLv2Erl8gefO\n", + "HKFoWAyN76VQHKIvHG686qpXXCAeffpphsOQnds2mW3LMLg2leIHzzzDW2688VWFkv5D/MIUI6dP\n", + "n0GIoZcLEYB0OkejUeKll85y0003vnw8jmMWFhbo9/sMDg4yPLxZcd999114nsdDDz1NfnI/S0se\n", + "8/NNLk3/LUNSRSvsou4K1oI63cBlPQrR7VEGbQ836ULfxs6quN4aOWqUqZIhpoTDOi4hGjlUBkjo\n", + "YbKGTifSSBgA0lgsAJKEdYqsUsYmRmWOiC4GJezNltEoKKiE2IQ0GKJAC5M00RbhB2tAD1BRyNHG\n", + "p0+TbUQopIkBA5sEP+6gJx4h0E7AFBqJktAXEEQGgjqCnQQso1NnmClMIvQQPOGiJ0MEUZ0gkCwv\n", + "r7FjxwSmWeHMmaf57ne/y6233kou95Oi1J+GX7Qi5If4xjfgNTS7/JnjXe+C//Sf4D//58t9JW8c\n", + "SqUSs7Nz3H//w7hugqYl3HLLYW6//dZXbPQ2OTnJf/yPf8Bf/MX/JJ+/idbGKGLuIotzM7SjLuNK\n", + "icUEbHOEOJQgE2w9RhE2np/C5DwV/C0qXbJOQEKWmM30TIsMCS45bCQRNjoeMRoGKVwcAgISlpAI\n", + "RpEEQAeBxCDGoMw6iywRkGFzU6AL9AgJCOkQUSCLRp8TtChIOCRUBiwbM2XS7KyzXcAFZ4N1/wKh\n", + "AmDhKRX6sQveKVJC5+C4wDJ0Tp+bxe90GFLznLg4Td/1GEkVaPkO3cuc83Pw4D4ef/wUYTiJrm8u\n", + "cKIoJAjWueKKWzhx4ixB4GJZPy7UktL/J7eVNjY2mJ9vMTg4xcmTT7O4OIsSx2iKRkgbgY6tDyLI\n", + "4yQJrtMkTiySpIMQI8AykhyRTBCkERQAF50KaQIkOh3y2NSpMIpGhKBNmYiQDpI866Qw6QEhWQTb\n", + "gT4BCRIPHZ0UPjFrBERUyWyZXOvEaGwyJR0SImIUGeMRkgbmpY8WCbxeREcrIopjIAUQIxAoSh4/\n", + "CkhlFBwvpnr6e+zIpEiSiAvnjlCWAZmuTdcYZtlpcun0c4S5FPf94W/znrs235VRFJHJ/P07d/78\n", + "efb/g4JDVRQKQrC+vv7LUYy0Wj1M8ycVg7pu0+n8fUZFs9nka5//PNHGBrYQdKRk/NAhfuWee9jY\n", + "2OCFF1a57rp7mZ4+yfnzT1CrObRqC3jlNLq0GSpKEm+IXsMhj4orJvA0hcHRKo2lsxQyWTruAjfq\n", + "ESWh8myosSZ1dArECBw6hIR00Oig4OEhMDDoYhGgEpKhxl5UYlw8bLYBl9jAZxx1q0CJt9otbRJ1\n", + "HikiEhSWUEiRELFJHDZRAZNBJLMssIC25QGQOEQQB5gE9NAIpEpbKrRjBUERnxBJHpUWGiEqFhqC\n", + "PDGqqmOpCp04xg8TNE2h03FYWVlhaWke6PA3f/MSR45Mc++9b+fw4UNv0J1w+ZAk8K1vbbIjlxs3\n", + "37wZvNZs/vL0qjlx4iRf+9rTbNt2iHI5TRj6PProiwRByJ13/qtXPOf666/n938/4NFHnyOX28lM\n", + "0ED3lmjVbM4pAbJYYptS4uJGSFFLEWsaQeTiJy5ZuphbRkohBLFMqOHTwkLF4ocui2jrGwuCNg4e\n", + "OiEdMgTkUVCRREgkaVRMFLoYRAgggwmoVIlY20raXEbFxGSMCkVa5NAAySnZYT1UCftQ1jQG0jkG\n", + "0jnGzBZV/xKOsxehTaFE56nIJQZUkH6P/uJJnq0vMqSWGbNtQq9FKo4Iag7LhQE0pcDC9ConTpxk\n", + "cLDMkaeeYn1xkdLICNe/7W1viIhxZGSEX/mV63nooSPAAJuehjo33bSHpaVlcjmdM2eeZv/+zbQ/\n", + "wzBYXr5IJiPxfZ84jl+xIO31emxsNPnGNz5PoxGiaYOoWhoZKhhajlJmAkNYJH4D310ilkOoQiBF\n", + "hJQe4AAZYgRs5YboBCS0cdAIiLCpkkGi4QE6CQYGCWnULV9MFpM0Bi5ldDqEZNjMbA2QrKIyQY4O\n", + "DvsxMPBJCOki2UDQRWIAXWJyJIyyyYyMAlkkvTigk4TktQKDhRzLvUU0xSCM+tgiYo9usdpbpRsE\n", + "JJ0VdEPh1uECS/UWNWAkO0qYHqLuVglHK+y96moe/va3mT19GkVK8pUK77jrLsbHx0nncvQbDdL/\n", + "oAD0pXzdTptfmGJk587tHDt2FPhxJ4fn1ZmcPAhsKrK/9dWvUu52Gd+ypUkpOXniBEdGRlivNjh9\n", + "eo0nnvgKGxs9hodvplwGrxez0VljW26FvaWrmG32CFKDNNw1QplgWhUaIRy+0WaoWWM50hgKJWEQ\n", + "40Q2QqYYIo2OCRRZYI0GWXT2Am1UZkjootMkpMEePApoxAiW8BFoZIhZ27JrGcxQoo1FgrdF3kX0\n", + "KZCiiMUyHTJABgiI8EgwsCigsY4gIkcXg5ktk2FJLeHFffpy02YYMowX91glhSBPTq1TSHLUZRXB\n", + "JtuiCEFWVYEWSdRGVVO4bp3V1QZCdBkbq3DFFW8jikK+9rUnmJjYtNP9S8aRI1AovLGpq/8YLAtu\n", + "uQWeeALuvfdyX83PH1JKHn30GUZGriCOI5aWLqCqGpXKPp555ji33XYzqVfoWCiE4LbbbuXaa69m\n", + "fX0dy7qb2dlZvvu5zzGazfLizCVm17LsMCRLa21imcELHQx1gcOJQ5AIVggpSQUDhT4e6+QwSQES\n", + "lRTrOIwQMo+CzyAqNg5l+tTpU0XiI1jHoESwlfPjAwpN0gjymOgYbOATERCSZowCaXoMoKBgUiOi\n", + "BLSJqUUOM72Y63N5wqhHX3aIlTxqEhNFlxiiwXa1yEA2RbWzRKofQbiCOphHNXT6XouKIsiqNpf8\n", + "DocO3oCWL/D5zz/AmBmyK5vlUD5Pc2WFBz/1Kd7xgQ9wxavUh70W3HTTjezdu4eZmVlgMyTx0UeP\n", + "kyQ1osjixIkTPP74IwwM7EaIHqYZcM01N/OJT3ybQgHuu++uH3P6bTY9/TueffYYy8ujZDJTBEGT\n", + "RCjoepYkMej2q4woaXRpYErwmEeTeUJCYIHNyMofZnMmSAIkAWnqmCSYqNhIHPr0yZOliIKOxCeF\n", + "pEOPEjYGCjYRDhARM0bAOhILwQQChxALkzoWFvbWaD0y+MwSYwLprWCIOpsl0gEECgo2MRdki87a\n", + "cYx4DIWAKLZR5AaTZkxWQEeR3Do4iGpHXHv11SwfO4Z0wFEV9u7aTiIlEduZNyw+/+kvcc+hHdyy\n", + "bRuqorDRbPKNz3yGD/ybf8M1N9/MY5/7HAO5HNpW8bdSq8HAAOPj469r/n9hipF9+/YxOnqMhYUz\n", + "DA1NArC+PsvkpMWuXZu20Gq1SndxkSt/xB8vhGBvpcLT3/0uZ5e6dLt5PC+hWLyGXi8mDGP2HryG\n", + "qHGeATtNq3WJIIKO0iPMDjC+6yosy2LnwDiTkx6r3/8udjrN+WqVvutRS0a25E8tChj46NQpEWNs\n", + "7QTnAY0MZ5jY6kHQI0MDgU245arRUdARzGDTYy8OFTZb9cQ02CCmBizhYaK9XBVbWzxKjw4OCgYW\n", + "Gg0ifNKiQoYs88zjxSEasICBQ0SXGi4GUuRJ5Dw58liqgh1laDOPQZF0kibwe0i5hG6orK8fQUqB\n", + "qroMDSncdtt9qKqGqmpAienpC9xww/Vv2P1wOfDlL8N9913uq/h73HbbZjT8L0MxEoYhrZZDvz/N\n", + "9PQsUAQiNO0opdKmuP3QoUNor9DeHCCTybxMNw8NDXHu+HHMapUrd+1gqXqavitR8BnQHdrJOpa7\n", + "Qj7Z3N+vIVgloYfGGhDj06BKQBeDFhAyjU9IBZMMARFlDHKU6eCTByQz1HGBCSTQZwmLFnWyNGgD\n", + "ghZpPCwENio+afqoWKzjk8FlEkGAJAdUNY2FuMdwqYzTzZFddxmS63RlzLDw0dUCQRxj6AmOt0xK\n", + "KdLoLxPJPkW5TtrOk7JTaBrUZcD4vrfw4pGvc/MN+xjb6gFWKZXIplJ876GH2H/gwCsyDz9rlEol\n", + "SqUSvV6Pj33sM5TL12CaKZ555jny+VswjAWmpjKcP38JVd3N0NBV5PN52u0an/3s1/l3/+5/Z2Nj\n", + "g+9//yjPP3+KmRmXTKaCojQRooJpVmh7JwjCi6iKSpw0aEZNTDWDLWwS6ZETCa6MUSgi6ZBwChhm\n", + "M6asQ8QqaSQjBOQZIMbHYRCXOg4KafJIhnGYY5UAhxUaaPioCFS24dNEMgWEKKxhEuHTR6JS2LIM\n", + "J4TkSbGKQo9lEhQ2uTiAvWzmw0pi5oCdSpeWuIDoBRSESdPbwBRVhtSYi60mhiaYGBzEsyykpuGy\n", + "mXgqkwTLtlGEYKG5jsyUiWsddlYqzCwvc2l+frMRl2Vx9Omnee/730/tzjt5+rHHyEpJKCVqucyv\n", + "fuhDr/v+eF3FiBDiw1LK//G6ruCfCcMw+PCH7+Ppp49y/PiLKIrgne88wI033vDyA8j3ffRXsBdZ\n", + "hsHc7CWKwzeysjJHEARkMmlsG/r9GrbtcM1tt3Ls6W9Q63eohxrW0AGu3X0l+/btoF5fYWbmDM1m\n", + "i2Ynot+LMKOYRcYJ2UdMhnUaNKlSJmQAm0XmCYgBi5geaTxMFOoMEVIij0qdEJcqWQQ9TNII/j/u\n", + "3jRKsrO88/y9d4+4sUdkRu6VmVWqUqlUm0q7kFglaAlrZLcHm56xDeNj+wOGMYf2mfY53TM+TDc+\n", + "bvdpz7HbM4MbmsZuYBi2QVi0MQitaC1ttVdlZeW+Rsa+3P2+8yGCAqEFmkUF/n+KEzci6s26N+I+\n", + "7/P8lwIOI0hMQhIIzIFqJh54hJwhHgRS97UzMUmy+ECPOh10DDL4uNIjpQ0RxVli2cNDZZIUARHz\n", + "xMAqgUySZBKJShQ5QBKFNVpKjbZIIMOAvKZT03SmpzdJpVIUiwe44YY7SSa/R24SQsP3/TfgKrhy\n", + "CEP4/Ofh8cev9Eq+h9tvhw996Eqv4qeHVquFlJJsNvuKY7quEwRtTpzYpFC4hkplnu3tFer1beJ4\n", + "i0ymRLn8JL/6q3ex9/taV57ncfbsWbZWV1EMA6EoPP/Ms8ydOs3C2dPko4iwskNca5Awcwwnc+wp\n", + "wflLfaP3EhFpEoTE9NAQA55InhUUInw0HLK0KJNiFwoWKj367A+FmBwRCxxF8iwX2aSHSgHBNDFX\n", + "s8rqgGkWEZBliBprNAnwMYkQeAR0mUDiAqaiEugaE4bB8VaL53o9UqHkmvIYl9Za6CJBAY8oXsPr\n", + "GmSMLrmUZM3bwCIklVQ4VddZckxip05PlzCT4mB+hKhbp/wD3c1UIoHc2aHRaPxEfID/VjzzzDOc\n", + "O1cll5vHsjQ2N9uUSnvo9SxWV5+lWDyCEDbz80scPXoQ1+3xwgsL/Mt/+b/T6cDU1E1Uq0lcN0uz\n", + "uUQikULT1ghDH8vqoutput1RFNUlly/TCxbQ/HlyUZcwnMSUKgYJJA4agpgaPUICEgiliBNvoyFw\n", + "aBBgIRnBIGKdBg1UQrp4QAEVnYBtikQMM0aCDZqUWL6slPEIEBjkCamyhSSBgkaMRoWIApAbXFEG\n", + "/T7NdzVHAf2b+H4h6Vg+qckuFa9OZXMNW9XYn8uhAsvtFvVmE7VUIpvNUtq1iycXH8co7UHKmM1W\n", + "naphEcmIfSNZHn/+eVrLy4wnk6hCML++zte/9CXuuvtu7njLWzh67Bibm5tYlsX4+PhrynodxyGK\n", + "opfxTl4LP2ln5KPAG1KMACSTSd7xjrfwjne85VWPDw8P42karu9jfZ/KY21nB9XOMTq6ByFMVlb+\n", + "jlZrAU3L4DhblMtjZLMZQkVw+92/z6lTp0mljrK5ucWzz34aVc3j+wGl0jDb26D0QlqhiScniFAR\n", + "6GhkUdHpskTENhnSdBH0kEg02licBXZTpo1KF4jQaTHBNuuMMkqbNQxUEijo+CQHhYgJhIQMo5JB\n", + "5TTaQP5lUECQRFAZNBb3Y6Ih2aBKJWyi4JHHH7SOA7ZEQEcGxBRQcAnEDorI0FUcmtEqGSKGVAPC\n", + "NoGMacY54iDHynzEwWOVbjKiAAAgAElEQVRlKpXNl8nv+m6IO8zM3P4zPPNXHt/+dl9O+yOoyN8w\n", + "XH89nD/fd4T9MTjEP1f4m49/nNryMkII8pOTvPO++yiXy5ePCyHIZFK4bpu5uScJwzKt1ihxPI6q\n", + "LrC8vMnY2F3863/9H9i9exe2bTM2luf4ww8i19aIOx3WKxXOr26wK1cmbSYZ6zVZdTpYisGd2RJO\n", + "4LLR2mIksFjwJWcQqGjYWHTR2CZCp0GJNDMkKeKyhuQ0eQw0dBTsgV27j4IYhMd38VnGpEYKwS0Y\n", + "pAgJiAjwsRDsoCIRVNkkg42kSoUtIsYGlogOMQ6SbKzixCqGbhI7DpdWmxTbMQveNn7kIfDYosMI\n", + "PkKFq7MpssPDCEXhfK3GeifJ+NA11HsKXc0gn01Q29jiqaceIp210b/PWA763+9ASswfeP5niePH\n", + "n+czn/mvrK0puK5kZ2eRRqNGPj+NEAq9nksqlcQwUlSrW5w8+RQXL27iunlWVzfJZLLE8RyGYZFI\n", + "JCiXZ2i15kkmd2FZGVZWHkXXy+h6g9CtU+94xEISBgoZOUovrqCzQ0AGk2EMbHRGUWlSYwkYx1dG\n", + "WIpbJNgij0TQQZAlwKGFzzgeQ3hoKFwgS8wMKjqrdNBQkNgcJ0AgSRMQouBgEKNjYrNFHZMOE2iU\n", + "6RcdCjAHpOlvRjXApz9IEnFMpdeEiootBDnbZjmKiHUT1ARlq8jF7RUa0UVuuO02MhMTmNcfZXWz\n", + "wbdXzlMY3U1xbIShIUGwkqS2tMTRYvHyb/2E5+F0Opw5c4bDhw+TTqdJJpMsLi7y7DPPkMlm2b17\n", + "92V1Zbvd5ltf/zoLp06hSEl+fJy3/9Ivve55/6HFiBDi5OscfqUjys8IUkouXrzIc8+dwnV9DhzY\n", + "zaFDB1/2JTFNkzfdfTePf/nL7M5kSCeTbDUabAA3v/l25uYa7Nt3FFVVePjhRzFNg1KpxNRUma99\n", + "7ZNIaXHmzBKe57C29hVaLZtWq0OpNIOu+6wu+0SeSeiUcKmhMoKBIERFo0CERY8XGcVlmhQ1Kqwj\n", + "qDCJxz56tBBoDCNxEDSADiUiHEBHwSRApYtLCgUXBYWIkAgdSGFhoLEbwSWaXCAYUKsi2vjMMna5\n", + "ayKZJgG06HABB2uQHOlIhyQjZMihoeIpDdrxEmHsksZnSrVIYWKpKSrCI1KnGEvvJ5XU2VrTGJko\n", + "8vd//xne+tZfIY4jGo1FbrpphvGB1OsfKz73Ofhn/+xKr+LlME04dgyefBLe+c4rvZqfDLlqlQOD\n", + "8er6zg5f+OQned+HPvSyHdXQUJmRkSqnT+uEoSQIoFgsoao2m5vLPPnkP1Ctmth2miBo8Zf/7uPk\n", + "/TrjRsC4At1Ol5v0BI36FlW3R1poZBBUjYCOEAwrKsu+x1yjS5IEK2h4jA4KhW3GBt/WkAqrA4m9\n", + "SZISSbaJcKmhoJAfPO/SRKFGHoWLhITkiAlxqSPR6E//RwaZMxKNCJUWU4wSU+AiF1jCR0EliU5u\n", + "UOgo0majEdC10vgiheN0kXEGSQMPhzYhHi6jUcx6VzBfraJNznCpWicIijQNH00FQ7PptFTa7jIO\n", + "NfZfPc03nniSe25/0+Wb0IX1daYPHfqRdrY/DXQ6Hb761UfYu/dtbGw8TCJhMzQ0zcZGk1ptC0Vp\n", + "Mjs7S7VaQ0qVZNJnfn6bQuEo29vzJJNlyuVrWV09weSkzdraSVR1BlV1SCQ6tFoVGo1zKMo0mibQ\n", + "zAyd3g4GwyiUULQkUZQdkI0DQooExAjOAx1UsY8o7nvRGKTxsGmzSIY2EWVCfMboK6JqDBNjDOLx\n", + "FAQmgik82gN7f8kMHi4qbQxUoEKGBjEpFHKkgA4CmKTPE9GBg/THNVX6SpsaYMgIG8g6DvU4ZiiT\n", + "4YzrMdd2mSwV2PBcTml5pFLis8++yO984Hf5d3/4hwghOH36LO12l+npCWZmZvhfP/IRjF4PCn0z\n", + "tNMbG5xaXyddKPDxP/1TfvODH+TgoUN88W//FmdlhfTA++fhQoH//n3vI5/P84VPf5pkpXKZd7JZ\n", + "q/GlT3zidc/9j9IZGQbeBdRf5dgTP8L7fyr45je/zUMPnSWdnkLTsly48CLPPXeK97//vS8rSCam\n", + "pjB37eErTz6HpcXccsct/A/33IOUkgsXPkurVWDPnsOk03meeeZhXLfC6uoShlFicvJtmGaSVMpl\n", + "aekBikWLOC4zNlbmzJmLEGQQCAxh40qBQRrwsHCIcYnpMESLWbKE6OgYjDOMoMsmIyjEVMjSpkIO\n", + "iYaJQhcI2cIhHNS6GwSMD36aOkhWicgBKiY9YlL4jKKywhgNUqSQlNhG0GQHA8ksKhoJAppk8ZjC\n", + "Yw6DLBa7CNjEJUQoPboySxCnUVHxqdNhizEpEWYeL5LkyeMGLXZl93KptcOhQ29nZeVJKpXHiWPB\n", + "tdfuxvd9/uRP/grbtrjttqNcd91P7sb38wTH6buu/pt/c6VX8krcfjs89tgvfjEy/n3S0rFSidry\n", + "MmdOneLGm2++/Py11+7m/vuf4sCBo9RqDrVagGWl6PWqSJlma6tFuXwzFy+eYGWxgvTGcd0h5nst\n", + "trUKcbfGKG18JFkkJQJ8obAVOiybCYpmgpofASUqeEgMMqRps8QMCjbDSFqoeOSIeYqYMgE9uoQU\n", + "8egQcokEOUICJMvk6GKQJk8PH0mHOjHDQAsoDcwTv9snLaJwFkmAggFMYBBSJcUCS+zBJImPH0as\n", + "4LEa2kQ+WDImRZsNYgKG0Rljmy5NUccVIZPZMpfmBSYlCum95BImHW+LuLdDMTtGNlnmmsOHuO6m\n", + "f8Jj3/oE8sUX2VUq0Y1j8rt3c9c997xh18HKygpxnCGfH2b//r2cOfMSuj5KIgFzc49w662Hue66\n", + "N/PQQw+ws7PJvn1j1Go5Go1NhoYS9IOGJVGU4bnnTqOqGarV03S7VcKwguuuYRhdEgkLzwsJwxSu\n", + "VHFkB8E2XUbxiUiyG51lbAQRKgEFOgTElFCJMAgQRORJ4aKisEUFnwCLHRw8yujkkPiDeDuAWQQh\n", + "Nk2ylAb6nGVGUXGJmMfGIAuYFFAxCfHpK0U9+gVI39pSMA7kkawC24BLn52oxjG6EMx1u4yj4Qc+\n", + "j29u4SmT2NlDlPYcYa12jqXVHd6eTqOqKrfeevPLzsGd997Lt1dXuVivs9FsUqtWecvu3aiKAqkU\n", + "L9x/P48/9BAjjsMN38fPXK1UeOBLX+LWt72NYGODq77v2EihQHtt7XXP/Y9SjDwApKSUL/zgASHE\n", + "Iz/C+18TQog/B44Bz0sp/+C1XlepVHjkkZNMTd0yIExCLjfE4uKLvPTSCW688Qagbyn8yU/+f+j6\n", + "BNce+VXa7RrnL65yW7vNzMwM73vfvXzlK99kZeUcUsbcd9+N3H77DXzqU3+HorjMnfk2im5jJUdQ\n", + "1TF8v4Kuhwih4DkeeStNt+eAiFClIGINQR6JAngozJEjoI2HJEVMCg2TAjFbqMS4CFQcsjhEaLTI\n", + "00VlixZbjBOjoNAmxRw+DgENBDqjdFBYxyWNxxgRNVKMkaKFRXuwr7LR2KCLhY+HSkx6QIYbw6VK\n", + "SA+FFFKk6ak9NJEjkjlSwiaOFVQ5Ql3YrMRzTAVNQlLoSHRdoGsmIAmCgNXVOrncAWy7zN/8zROo\n", + "asA73nEvUWTxxS8+w/r6Fvfee/dPcmn8XOHrX4frroOxsSu9klfi9tvhYx+70qv46SNrWVS3Xx6e\n", + "ePToEcrlzzM/v4RljeF5VaKoyfBwnlbrIpaVZHn5SbrdGiKcIPAdTCWFjokXaURUcPDJCkEKBVPG\n", + "JIGkjKn7Hk8EIetxAg8LD4lOkhbOQDExREiDmAx9b8wGCg6XyNOjQcQ0MVlSXMBgDYMGWSLKWGio\n", + "BCh0qdJjiJgJ+tTFAgoOoKGjIvuDGOqs00PHJUVAGxWLFQ7SYAmbgJCYNjl0OY5wWzQHGcM+EygI\n", + "AhQ0soxaU9SCOfSWSjKyMCyJKx2224KunySKHLpxBzPTYHL2WhIJm2O3vod0ep1b3nEHmUyG0dHR\n", + "l41lf9boh9tJAPbtO0KpVGZl5RLJZIJez2RqKkmtdppjx8YolVI899xpPA+OHLmJPXtmeeml06yt\n", + "bbO+vkk2W2Jk5CoqlS+Qy6VJJIpUqwaq2qNWO07KPIZUFKRMAg0kwwSBCvi4OIDE7jt24KHjYoDc\n", + "JoVJCYUesINEohNisIZA0sKjgCRNiEL/L/HpG7ynkXRI0k9g9smzzjYaEjnYUoZ0sOjh0iGBgoUx\n", + "cA3xBr5SfcfteQQRGmMoRASsD9y4O3FMU9PoxTEHRYTUDRpikrQYZssP2ZMbRdNCLlxoMD8//zJ+\n", + "1Xdx3fXXc/Laa9mXTLLwjW9woFAg7HapKgo3zc6SsG3+8ktf4gM/kIkxMTTE4vIyi4uLpF7lmin8\n", + "EJftH1qMSCn/p9c59t4f9v7XghDiOsCWUt4hhPg/hRDXSymPv9prV1dXgfzlQuS7yOcnOHFijhtv\n", + "vAEpJfff/y0ymf1ks/1dlm1naTbTfO1rD/LBD/42MzMzfPjDv0OtVkPTNLLZLBcuXODCyZfoXlrF\n", + "2mgiSVBRVXbCHAm7xdRUmXptkdiv0Y5MwtBDk9skUXHZRrKIxEJjgxSNwfyw13dzJD0wb49Q6BBj\n", + "I8hg4ZNAxSdFl0U0kmRokUVllRyQRBDSw8VhgjwpYlxcJF0uUWSbNjpJNEIMfDJs0yI7YKj0AG3w\n", + "CQJBRA1JBkmXNgEJ1cI0HbpeAkUmUaSKJ318VcXWx6n464zGXSxFQ5ohmWyJeq9JIptiaWkFITT2\n", + "7buZc+cuYtvXoighp049z6FD1zM0tJennjrBrbfeSOkKGyn9tPCZz8B7f+wr/WeLW2+F554Dz+uP\n", + "bf6xoOG6HPiB/KNkMsm/+Bcf4KMf/Wtct0M+30HXc6TTSVZXL3DxYgQkCMMUob+FJhRM2SWrxmii\n", + "r1Sp0GVUQkpVaEYxNRmxhUYjtmmh08PGIkWODjY1KnSI0YmRgyjLDCkqpNDp4gMdHFSSPEeWAIOQ\n", + "kO+aEfYtvHu4uMTsBrZZAbIog02IioYgTUiTJIIuHSQGKjOoSBTG8YiRtOnxDpyBti4gJiGbjNFg\n", + "iAyL1EnTxKSfltJDpx3ZhFqWnU6IH3joaYud+hLIvRhKijDu0Ao8SlaCdLqA63ZZX79Euz3P/v17\n", + "GR4efkMLEehnien63+M4HRKJFMXiKMXiKAsLz/PLv3wvIyNlHn74O8zNrdFouNx991s4fnyeyclp\n", + "dF3n0KFraDSeoNF4EUXJs7DwOHE8iW3PEMeCKGpjeOvMxC4p/yK90GWDJi1uQBW7ieUyggIxq/SI\n", + "8DGRCCIm6Q9EBEkcJAoKSXrExJfTZHxiplAYRmMPMSukeAIbnTZrBGg4JAfC7gCJiaBIgIakhyAi\n", + "oIFJmzY+KSIkCQIkdfrj9745nsAjwRAR8UD8oGOxRY9CrNP2I8qJNCv4rDkeGCbJpIGM4OmnH6ZY\n", + "TDA6Os2FCwuvWozkcjnuuO8+/o9/9a/YnJsja1msKwpmsUi71SKbzWKEIX4Y8oPOX5oQ2LZNN45f\n", + "8bn1Tud1z/2VlPbeBPzD4PG3gFuAVy1G+mqZV/5xYRgghORb33qIxx57jkceOc6hQ3dgmkksq+85\n", + "kM2WWF4+R2vwnyiEeBkrfHl5mdaZ51DbRXLWEK7rMCbBkav4MqaYnqB54Zvk0en568TSGeTDdPFw\n", + "kSQIWSeHP7gcLcZRMfGoskKIoEoXSQYVmywuI0SYxPjAJiYuDRxiTpNDMIaKCdQIGSckQRWDAqBh\n", + "4jPGHFUkFttYuKQxUFC5ihXOo1InoIFOgoAkBWxcqjRZwx9U5pHiMlQcRmsbdHsmbugSawmkkqAT\n", + "7CBJ82zUJSl6uMESXjuFruS55dYbOXXqGd785rvQdYOtrSqmmWdz8yzHn3mcF554hIQRk8lZPH3b\n", + "Xu55A9u7Pyvs7MCDD8Kn3jCa9n8b0um+78nzz8Mtt/zw1/+8Yml7m6mBpHRle5tuOs2Ba78Xnug4\n", + "Ds8//wIvvnie6ekc1WqV2dlpVleXuXjxcdrtHqnUYYTQaTR6xGQJ4goN1UHGEj120JCcQ9IENqOA\n", + "BrBGApVpIIEC6FSYZZssJjYeKSRrxPSoYjKMTY0cCVx6+KQZAiyaGAiuwkYQ0KPHJi5nsVDQ6PZZ\n", + "WFiYJAlx2SZGINlGMoskJqaFC8Ts4DKCTgcFCCkgySNpI+gQ0wZMJKskqDGKjUObWSJSaAMSfYxN\n", + "jw08NEXBkx1SWp6rs8NIv0PHW6bhecSySjE7y/jEbZw9+wLNZptKJebqq/fw6KPrPPbYS7z//fex\n", + "6/va7T9rJBIJ3vOed/K5z30DKUuoqoHn7XDNNSX27NnNn/zJXzA318ay0gwNDVGvb2IYDmtrT6Oq\n", + "Q0gpmJgI2bVLR1EmgQymeZggiFhZOU3QmWNW1jFkEjWOsBSNRJRkjh26coJ+KJ5Hn51hERLQH4C0\n", + "EQhMNi9LDDrExHhkOEDADoIQixw+KhE9hlmmTG7gp+oR0YOBhFcnIKRDnn7SZRcHiWCCNkeJWSdk\n", + "a8A46YcvqpQHypoEOhEq24RsoFHBQDJGiE4vjNmmSdd1KCbTIBzU0KNa7+DLDIliiqmpQ5w7d5KX\n", + "Xgp597u/N9+t1Wo8+OBjnDw5x/raGpV6j6aWZhOTfMJgMpdn7sQJikNDWKUSZ5eWcLtdut0upWKR\n", + "sZERRCrFsWPHOP3ss1za2GBmZAQhBDvNJptSvu65v5LFSA64NHjcBA681gtnZ2fR9W9frpYB4jii\n", + "Xp/H81wuXQopFK7DshwuXmyztfVN7rjjn6DrxiBfIHpFhsry8jJPPHGc//LxjxM2HFQVDCOHaRZx\n", + "nG3GDY9gYor6yQe5u5jnkmhR7zbB7TBHSMgEaVRa5NEYRiWiQx2fHSQeKRIEOGxQocoM0MPAo4g6\n", + "kOQG+GwzRQ+dkAYKNWw8htHJ46DjAxF5oEt9YAwcksIngY5DiwQ6BTRCfHYQKPhoJFklxkOlQEiM\n", + "TYiNYJMWpqiRKSXpxBEdt0MYXk0Y2yS1BBDSiddBJtGS11PYVUI1AwyrwZvffDVTUyk0bYrp6f0A\n", + "JBImp08/y9aGgx5OsssewQs7LM0/w7/93/6M5eUt7r33nb/Q5NbPfhbe/W54FbXpzw3e9Ka+5PgX\n", + "uRgJJid5dG4OAYzs2cOvvfvdl03MPM/jP/2n/4f1dUGxOEU2O0a1epxe+xw3H5nC6WRIJG7Ctkc4\n", + "fvxZhNhC1xN4rkRJDOHrSXZaT5LQNcYDlbKIWJYJKmRxuAqbNA5thmjSF7jraMSDUU1AgQIrVCnR\n", + "wsanRkwFiUEZlRoFIhRsFHQ0IrIkmEOjyy6yWNjoCFTWOD2IyRP4KKzTwsMfaOZ6hDhIhpDk8dlE\n", + "DnwpoDcY4ZwiQQh4GGxiE6ANBgjjQGdgoBijkMDGooUre6QUh5mJIq2mi6WX0KWHDM6QMHOMJHK0\n", + "Vxd4emOVkbE3Mzyc4uDBoyQSCVqtEl/+8jf4gz/4nTe0Q7J//34+/OERzp49T6/nMDNzjJmZGf7q\n", + "rz7Od76zTrl8jCiyuHRpm0SiwfR0kV//9dsJw4goipmauoMPfOA8cbwHzzuP63ap1TpACTPqkbV2\n", + "4zhzRFFATNC3QxAuntgmijtAAkmXfidEpS+qrZGmzRQFaizRRiXLOOogfKOf6FtGEqHgIFhliH6H\n", + "DByKTFKlRRKTKgYxCxTxkeTYIKCLis0Os7hs0O+zXIVCHVgkGGw5k9Tp0UZgE+EhWUIBRkkxSo8e\n", + "PqAyxlawiutvc9fkCC/WmyjhNEJYYGoEgYPjrPO1r12k241461tv5MiRg3zyk/8vnjfM6OjtPPQP\n", + "n6G2WSZrJ/Fw0bQUpxe3gBYnNzcJR0f51uOPc10mQzmdZmNzkydOneIDH/sYpmnynve9j2/cfz+P\n", + "nT+PAtjDw9z3nvfwBx/96Gue9ytZjDSB7woSs3zP5u4y/viP//jy49nZWS5depGtrQyKohPHNWZm\n", + "Eiwvm4yM7EbTdKamxlhf92m1AjY3F5ic3MfGxjyHDs28zKr25MlTfO5zD5JITLK15ZPXR4jDEMdb\n", + "wI1DdE1FUxX8IOb6yXFumJnhgOfxd99+GNP12CRFFYseOjBKgi5JdBx0QpI4rNIkZguLGkVi6ugs\n", + "ozOCwTCSEIc6Y/j0TXUDQoawsFjkEj5XI0gQ0hq4C/gojAAmKut0sLFJorNDPLDKEfTQqZMmYgyN\n", + "iBCHChE+CZI0CEjS5VgqjZkr4QRd2qMBC5tncMI9BLJDFFWQAopD4xw+eifj4zo33niU5eWT3Hvv\n", + "AW688Qb+43/8L1Qq65RK45TLaR56aIvIKWDFPjvby6x2KsAuvG6WRx9aZW3tC/zmb979qu3AXwR8\n", + "6lPwZ392pVfx+rjttr7a5w//8Eqv5MfHr/3Wb+E4DlLKVzipnjhxkvX1mF27jgCwtbVMd/kSydYG\n", + "5XwG79ISjcAifdUkw8N7CIISOzsvQdjE9SWRMLHzCWaVFLNCsNZo4XuTJICINC4mKXSqdBgmxEAj\n", + "gY+KTQ8HQYUuBk2yBOyQJIOFhYoxaJJ7A0sqHR1JgxDJMBaJQVNe4NJgHJuYBjEGCVSSwDI7dFBJ\n", + "MYFKGYFDQJIe0wRsozFMTAfJDhodBD1MMiSYpU2XTWqUgRwWkjZtQiKRRtUMYnWTm99yL/b2IuNj\n", + "kvNrbeoXF9EDOFAcQubLzE5McGbhJNX6FpM3FbjuuiOoqsry8jKdZpN2d4Hl5eU3tDsCkM/nX0as\n", + "bDabfPObLzA8fBO23fdCMc009fol1tdruK7Pm9506+XXXnXVXpaWHAxDY2XlBFE0QxSFJEwbTZOY\n", + "pk4UuGjCwA1bKEIhmYiQcYGeB1Ec0e/GZ+kPR0YJWKJDhRE1w1LUwiaJpJ+r3LeiaxGTxcInpEZf\n", + "69Kh798UkkOjS4MaaXqk8fCpEBMRs4sOSRwCoDj4tAQqZcBEsIVGTJZ40BURWFg02EbBIoNH3xu2\n", + "hYEphkHG+F4NP5SU0oL11jJSG0aNepw69Ry7dl1HIjFCtWrzF3/xAF7v3zNcvoHrrr8Wx3FptSNG\n", + "CgdxvIv4+ZhTtXXqOx3iuMq7Dh2k0WgwlMlg5HKIbJY909PstW3WFxbgttvIZrO85zd+g263SxiG\n", + "ZDKZH1rQXsli5Eng94AvAG/nVfxK/uiP/oj19XUURWF8fBzHcbh06RK+7zM5OclXv/pfOX78HIbR\n", + "RoiYsbEiqZTH5qbDmTPPE8dNJiYs7r77e/rmMAz52tceplw+gqKo6NkxetVz+K0ddqSCopcxkmka\n", + "cZdCsoI9lUfXdZxKBZOYhBJhxAZpQnxGibFxcQgH1ryQpkcCG0mMh8EaJRoUUKixSheQJAmpD1Ip\n", + "uriDWbRGjiQtdmihkUVjBYUWGUoY1OnSxmFroAPooAykvwIFmxwZFukM3EkyWKQGOaAdmgQ0KZGn\n", + "YwyzvNVgXO2SEj7TNqy0L4BI4cUBplaiXNiLoihoWt9Rz7ZLLCysceONN3DvvXfyyU9+geXlOkHQ\n", + "VwJ12vNEqs5GZxtdTJIxU6xv1JjaC4XCQb761Qf5yEf2/MIpbF58EapVeNvbrvRKXh+33Qa///t9\n", + "o8Q3eMT/U8VrZVucO7dAJtOPSY7jiPkXH2ZfMoMHiCjimokytbkKjcoSoCCcJXbj4IhV0tksbdmj\n", + "roSUzAhX6CzKBFLY+LKLICCJiYVCDZ2YFrmB7fYOCltY+BSRCKBJg5AiPgoh/aySLt3L4ZR1YiDA\n", + "Q2McD0kTSUyIpIvEJkQCPQRDmGhYVHGxyTCEgzfogDiYpImJsXGIaaLQxSAmYpwCGRIDwa9HhnXm\n", + "uEo1yYuQSHHxjRSxEpGyMtgyxldNdmUy/Mrbb+evv3g/lTWNTHKIZb/J8ws7SNnFTtrEoUccxzz5\n", + "0MNoTo+ErrNdPc/nP/EJ3vfBDzI8/IY5ObwC6+vrJBJD9Hrh5eeiKMJ1Y+bmnuKBByyWlpbobG3Q\n", + "qFRYvLDEzL67OXBgD93uF6jVFokiCycIcVhldHiWVmMDRTZot7t0hIGMU3hBEyl3EMJBymuAWUBH\n", + "sIbKNDVqqFETH5MtXGJiHLLoWAi6qFRRSeNj02GDIVo4QBWJIEdrYBWvYKOzTRETnwCNJhoRDpLS\n", + "4F8ESQcD0MjCgH+Yw6COpEMFDQ+DFhKJg46Ci0FSVjFoQ+zw7GaLdCKPaY4wMZmm67Uw5DWUy0c4\n", + "+9K3aM/3SEnJXGOZat7AqQdMX3MN6dwwnYaHJrKkbYGq5FGiPE40z/UHD/L8U09xzdAQ8/U6B44e\n", + "JZlMEscxj5w/TxzHl3/rbfuVeXKvhStWjEgpXxBCuEKIR4EXXo28+qd/+n/j+xYgSaVC3vveX+Lw\n", + "4X4g2/z8PN/5zkmEyJPP70bKmNXVDcbGkhw6NM6115rceefb2LVr18tugjs7OziOQqmUIggCnHaN\n", + "VquCHxtk2IWIdCqtgCA1TaEEDSVgs91mZ3ubWEriuE8ltQY/TzomLYoIKmQJCekR06aBTgODMbaY\n", + "xUfSn0K2OU9IkogAmxgfA4cUIBF4KPTN4y0EUCNPE58mMQZDQEiTRfKEXEVmICtzaOKxRIoQhQLn\n", + "aZMgwAAUfCpodChSpAhtQVf6LAofLW5wrJijkLNIqKOsdWqc76nUduoIM+L66/tGZo7TpljskwlL\n", + "pRL/9J/eyblzF1hZcRFsY1tTWFKA9NDUUeK4hRm4bGxukkrlWFkJqdfrb6iD408D//k/w2/9Fvy8\n", + "11ATE2DbcOEC7Nt3pVfz00cyaeH73sBr6CXWLjxHoJsoimDv/jw3HbmGxa1nOL19HC1RJtNeRHca\n", + "JI0CeWuGYdFj0Z2n2XE4YOscLBXpNZNUuz4rbA24WAo2FbJohDjYxMxRJM0Em5gIRgZKt9OssEkJ\n", + "GxWVNkVceoyikcYnps0OEQ26GIP4hSYRNi4+JoIs0BrcPCQmAQptapxCo4VBhMkQAUUUtgB/kHo1\n", + "gsMaMTmSBCAUdBCYZskAACAASURBVFRiPce2n+FJWaMcg4wVYs2nouqkkjnG4ohnKsucSrjsPXAV\n", + "bz5wFS86L/DQ6gKhtourp65hdmyE4+eOc/z5E6ytrJJwXcaGhpCxy8FdRa5OJPj7r3yF3/y937ti\n", + "14BhGIyMFJibaxIEGTRNZ2HhHJVKDcsq4PTyfPk//C3XlpNcd3A/UdHkwUe/xOFb/zvuuOMunnzy\n", + "BI3G06Ryu6lKF5wecdggxGTHshkZOkSrV0H4DTy/TRjmQO5CESpBFCCx8aigkqJORJ69tEjgoQKb\n", + "BFRIY6OzREAeDZU6DVQctimgYAMxEUVMcsScZBpJkTYKAQYREX2Sqo7OMpJw0DUR2Li00aiRRkGg\n", + "0sNlB4UubTRMLPbiY6MiSeCi02AIyWQqyfCuUVbaEWHTZdvrMTK7i4Xzz5L1O0xnUqQTCbphEd/t\n", + "QafD4vnzpNIWXZmitrVIz0uzud0kISXX7N+DnUwSSIkiRN/LqtUimUzihyGGZf3YI70rmk3zenJe\n", + "gFzu6OXI6Ha7zqc//VU+8pHfxrZtHnroKWZnb6FeP47rtrCsDIXCOEtLJzl0SOdXfuV3X1XNYRgG\n", + "Ugasra3z7LMv4GyuY4YmnjpDTzHRDYNU5OFZGkIb5bn1FzjhreOtLxJ2u4SAS48ObbosIcmhUKKJ\n", + "PyhSGqTwsTAosUGRmFH0AblVcImALbo0EMyjopNADuKPfLo00XHZIKbOKFskgTTrhEQEKCTQsEnS\n", + "ATr4qKRRGSdgjQ4+DgKF/YQYOGwOONkm6UFWTss/z3W2jefaiKhLrdFBWBErUQeiLHrcwHcN8mIX\n", + "ixcvkkpZwBZHjtzJwsICD3z+86gDVvTF9U3Stk2l0caSWXwFVGJ6UYchS6JF0cDiO3wFZ+fnHb7f\n", + "54s8+eSVXsmPhttu6/NG/jEWI8eOHeT48fs5e3KJxtmnmfQ9xlWNSqfCS+cT3P22t/Hu2w9Re+I4\n", + "jt/CVjfxFEkiMUEUdZGyQ8H36cqIQqhiZlROdDzSwiQje7S5SBfBEBXS9Ngh5jwabYaIseigI3BQ\n", + "BvZTO9jUURADNpaGRo9V1lhHQTCBQZotWqgIJlEp0mUJj0UKOGgodDFpkGITEOhMIEkzhIGLww6b\n", + "1ACbPJMIugRUkXgYLNIFhExTU0zScos8LqpQ2FLAlwZ+ZNKJi0wxxRMXNuk2qqzqPv/XZz9Ly3Fw\n", + "o4ji0C6G8wfZabqcvLSKT5LY22D+5FmuLU8wV5tHs3vc8+v3MFYscml5mVarReYKWf1OTU0xOmqi\n", + "61nm5lZpNDpsbzcwjDZvf/tbqa+cZcJIcfbkMq0apFJJZs0OZ1/6IvsOX4/nvUg+P0EudyO6rlKp\n", + "v0Q7rKEaE0xMTuC5KfbtnqLRWOLixfN43iVgcaCAFIBBQESEgsooKgER3mDQngLW6SExyQATxCwx\n", + "hMYOu/G5CkEOiYvCJhodQkwCIuboDkS/UMWiSY6INlehkBxYXlZpsAwIUrTwsPDpEgzYgglianRZ\n", + "RDCDjUGbZSaoE9LDd2POLC4wNlxmvVOh0QvxFp4i7nnkBXRDCyuKyBgaW91NXrpgkC0OMzQ1jqK7\n", + "jExnGN1/jKY4QSpY466bD6NrGsK2WW+3CelHNUgpObe+zuE77/zFLEZ+GL5biACk03nq9Qznzp3n\n", + "2LHr2NioUC7fwi23mDz77JPU6yZSQhgu8K53/Y+vKSstFArkchr33/8I6fQEWbWAbyfQexG69DCA\n", + "yNDZrsdcvNhFlRZKPSJ0bZJ0CUmhMYWFSYeYkNP03fpSZNihhCDBBBHgsIOBoIZFiEDHJYPgEjZd\n", + "plikRxGHBB1CklSxkExg4aOyTZqQaSRl1EGlLTmFT4I2Gk0S2PTo0MEhxqeChU6OInkifBxGiNlF\n", + "xHrfVFpASZ8mFhUsVceXJuOKZDmMGfc3ccQGQhM0DZfIj9m4uI2eWOWGwzN86i//kjPHj/O2/fvZ\n", + "f9VVNDodnnvsCUxnB0NVidQaUdTGjSQpvYidyVDKZllZOc+NN06S/iEa8583PPAAXH017N59pVfy\n", + "o+G7JNbf/u0rvZKfPqanp7n99qv464/9ew6kRtk2NBy3ys3791CLIs5eukQml+ND/8v/zInjx1l9\n", + "5HnctkLkQ9zbwfMaeL0WGTvNdhwzokp0fZ0tYaLJBP0s6zUSAxVFX0NjDBxGxogwiQjRiNBYR2cD\n", + "nwwh4whsBEV6TNLhLLs4hySkgYlPmZiQmHkCdDbIIogZGfgSrdHDYZoJXAoD+rnAIoFPkU22KWJR\n", + "p889WGcGlxCTEgbr1PFFxB6jCAKmrATbocJLvkqKGWxNgVDBcxSyxiiW6nCoWMSIIp7f3OTphR1W\n", + "KltYmoUXBjihx8GpWerho9w82SNlGvixxvLaGuOlEkII5A9RQ/wsoes6v/Ebv8ynP/0Vrrkmw8mT\n", + "WwwPdzh69Aizs/t5/KVvI3e62PZuVNWgWBjDtos0ts/w4Q+/Hykj1tZiTpx4lFZLks+Pomp7MYwy\n", + "9/3yu9nY2OKhh56m0WgRhqvoepkgABhGUgW2gDYxTVz24OAhUEnhAS16GAiG6dEBQpLU2CaLJI9N\n", + "k5gOIVkC8ihcGuizEgiGsAnQaZCjgIlJCgcFiC97xmjkyNBmmh41iqxxNZI1AkqkWMKhiMMKz6GS\n", + "QSHAo8aUplMSKuk4xnYdDF1wIAubzbMY/hBeKKkGAetaTCA2yZkl6p0aHUeHikcm0+bw4SPYdptD\n", + "x3IEGzu8dOYMnVqNWr3Oo2trfZnv5iay02H02mu59U1v+rHP8c91MfKDUNUE7XZ/Vz46OkS1WqVU\n", + "Gueuu+6j2dwhjmPa7QxHjx593c8ZHR0ilTpDr7dML2qRUSRd00SLM6RSw2z0Wmh6jnptnnzsUVDy\n", + "uIpBN+6hMIYkgQ3kUNhCp04Ngw3GhIomISTHFhcYxmCIGI2YVSBGRxmkyfSdEjOs0yBiDYUUNntJ\n", + "0KGAQ0yaFA2ywCI6TdKASkQbBY8U0cCKp4dBmZAhosHFHtJCISCghCDCQEGhgyrBiC22vJBhoRMo\n", + "Ei2dptPcwQwjdusKG7rO1Ti41TPs9EzaS22Kk1lot5n2PLZPnWJ1Y4NarUax2+GwjDhHj1CLObz7\n", + "AGvNHTba62AXqTuL3DS5i3vv/cWzB/3Up+D977/Sq/jRcdtt8Od/fqVX8bPDzMw077rlCGPJJJ47\n", + "ytLcHA3XhTDk6TNnePuv/Rp33XMP1WaLc4+dIe6tkugF5BJ5diIfV9FI9toUp0aJpGQma9Btr0Cs\n", + "MaHBiiuJMKkSU0SjRIDFNpsohBwA7ME+dYMiDVwEPj4eGRQioIFBSIKADkNojJDu9yzwCJCsEHIb\n", + "F3mBGlWy2NjUaQ1sE/teFhGSLjESDRWDKhEBIdvsxicLbNOgQQ6NmPHIJZRN9hSTWHFEKYwZDVSk\n", + "1UNoaXqKy+5ykY1mBO4ShweufZcqO7hBi+r2C1iGSSGZpiALXFxZZW85x5htUUinCaKI48vLTE9M\n", + "kJuYeNUAwzcS4+Pj/PN//rssLCzw2GMaZ8+G7Nt3PVEUUm01SakFQKLr/duarpt4sUGlUkHTNFQ1\n", + "ZmZmFsdxSKcthoePcv78MoZh4rouQSBQ1ahvAKlOE0XzxPHT9IWfG/RVNRKVS6iMAjVyFOhgYBBh\n", + "UAM0fFYG3eoOZapk0DEQtNlihQI9/n/u3jxIsqu+8/2cu+fNPSuzKmvvru5W71paVtNqSa2WBAiJ\n", + "RWBsjMEMHgeGeW9msCN4EzMv3gvsF/PPi/fCjrEDvxgmsJmw5RUMGGywMMggI7S21K3uVu9dXXtV\n", + "7tvNm3c9749MtwEbAzK4JX3/qcrMupkn85y6+bvn910GDIMIikyhkUdQoYCHQ5aQLGkaQIxHRB4D\n", + "hRzQQZCgSJsKu+kyzBW2SNEjoMXBUUHbpYtDQKxZ9KOYvpCEmkbBdRFhyJ17pvj2pQ0GA52qMyCb\n", + "8FGNSSYz2zELKolykSPH7qXVusoHPnCc2dlZFEXh47/yK3QuXYJajdRgwF7bpmFZXG61ePjhh3nz\n", + "v9AG+jVVjARBg5mZ2wG4774jfOpTf4lhJEgmM2SzRVZXz3HzzfMUi0Ucx+HixYv0eg5TU5Ns3779\n", + "OnfE92PuvfetBIHPN8NVlOUNnG6brmczCPp0fJdB7EDYIyVKxFE0ktvmSGCjM5ReJRGkkSxjMmAd\n", + "KW0kaSpcYwyTMQxMQKfDBJKLgM3kyB11B4MRPWkYlrUM1DFxgM6IzAbnsNHYjs2Q3OfgE7CJQpcA\n", + "jYgJDNIEVJFIoIuPj4IzyrMxgIAMIT0kndBjTPhoekRCj+n6A7oxzKsGVQXQbKYT4wyimHqrTn1p\n", + "C+OoJAoCJLBYrXLy2WdZGB9nemyMtA775+ZZ3Wqy0t4kly5RnIo4uDvP9qNH+aUPf/g1R1zd3IQn\n", + "nhi2aV4r2L8fKhXY2oLvyJd73cA0TTCM6zLx+W3bqFarbNRq3DI+zi986EMoisLeffv4y8JTdNav\n", + "UGJA2xl2+mPNoh+02GjUccwCy12dAfP0tR5F08MMhuTYovQYEyY96ZAGBG0clvHZiaQ18knNMk+f\n", + "VS4woIdPjgSQYkAbSDOGQkyARIwypwR5FLoYJJEjq8IE6qh5amORIUbFJ0TSIULg08TGRaePAvgY\n", + "lHHpU6GCSkZTSJeT6EIwbZr0Y8m65+LqIBSVpu+jCkHX87h1csjXqjkOX19yCaJ9GMokupam2V/C\n", + "YZGcoVIqZmmrKm6jga6qVDsdrsUxP/POd96oqf8uGIbB7t27KRQKXLv2hwwGfSzLxijMsLmyzrhh\n", + "k81OEccx15pbpKduwnVdKpU6tdo4k5NDxU23u8na2lnm5kLOn/8GTzyxSBSl6PeX0LQpPG+DODaA\n", + "OYaFyAGGMt8OIT6SLTIoODSAGgY+Ov2R+nEShR45mkxRJiYcib9V0tTo4SNIE+NjouMTYWHRJiCJ\n", + "NzqPG0j0kdS7jYeHoIeBRTwK0lMwMYhI4KGgEqPSo4OOz6RmMBuHJKVBJpNhpd3mUrvNpKbh1Wvs\n", + "SgT0oya5cEAfm9W+zrV+n9LCAkeO3U8+n8d1O6yvb7Fv3z5eOHGCg+Uyqm2zfOoUU/k8Xr/PS8vL\n", + "OBcu8LlPfYq9+/YxOzv7iuf2VV2MrKycZ2JiG3Ecsbl5hR07Mmzfvh2AHTt28Au/8CY++9kvs7Tk\n", + "kkwmOHJkP29+8/2srKzwP//n5/G8DIpiEUWn2bkzy/ve925M02THjhmuXFlkbm4fb333v+dvvvQH\n", + "DE5+i0gushWsEakSQ1lAjSeR0iWIfaSUyGGANDEqCdUklAGGJjAZICKLVuSRIEaik8XCw8bFAWxU\n", + "Imximvg47EIlN7oaChDEIzNghQ5dmhTwMGnSAybJYxEgGEaSD70d+6wBLsO46TYCG40DhIQIYjQu\n", + "YlPBJEFIjxQSn4g+K+zExRaQS+VY6fdpRSGXhUo5lOzUc+iaMfRBGbjMZad47rmTTOyc4/TiIjcn\n", + "EhzSNLbrOlvtNjU1ZGpMJ5Ge4sn1JdLbxrj14GHufOMbuef48ddcIQJDx9V3vhP+lbLBfixQ1aHP\n", + "yLe/Dd/j0vy6wNzcHDKXY6s5jLlXVZXS+DjX+n3e9Mgj19fZ/v37mN5WJtHdR9FI4HsOU1HE5asn\n", + "afUM/qoZYKlpDGFiaRqlXIZutEXorTApbISnsR5HhJhE5LCwSLKGj49JEp0iCm1gjZtwOccifdLE\n", + "QJKYLgYhEfYoFkLFZsBQQSeok0CiUyJiCTHSYtTJkidARxv5mzhUAJcdCDKE1EhRYRIHDxVdibkl\n", + "m2bTcSgUizi1Gj3XJXBdmoGPK8YJ9KH/8rlWFyyPqXyKWrXO585coOfNk9fGGCjxkEKvz9Lrr7A7\n", + "3cYiw5333cfG+jqnr1zh9uPH+cWPfORfLSjvh0WpVOJnf/Z+Pve5x4miFONTJV7a2EBNSp66cp5K\n", + "z8UozrFtXKHZbDM9fQtx3KfRWEIIi8Ggy2Dg86u/+tM8+eQL7No1xtpakyiaQ0oTz1sCdjNskY0D\n", + "M4A3EhkMz+SwSYg/Ckr0EOxAx0Gwk5gzTBCi4hJf9+WFPC4VYmImR426mCwmOiERIT46a/SZREHi\n", + "EtG+LgHWsAlR8BAskiCPRkAVnZgDqMQEdCyDy0qCbXEEQuBoKknDwGk0KAFJw8DqOIR+jCsSGHaC\n", + "rTgiziS58+1vZ9v27dez3sLQI5kcyuwb1Sppw2B1c5PtExNUNjbwm00mDYOBYeBtbfE/fvM3+div\n", + "/Rq5XO4Vzemruhg5enScF198AVVVefObD3DnnW9AVYdy006nw7PPnsTzNHQ9jabFTE1NoGkaf/RH\n", + "XyKR2MPExD+oNy5dOsVTTz3D8ePHuO22W3jqqVMsLb2M7/uUZnew1d4kRZKHH34fX/nyoyxejOlL\n", + "iRNBjix9qqSJcdkEpomESoTPBhEyblGOE6yhU0WQGXGjAwwaKCToYKDRBdYwCNmGMios/r6JEwMO\n", + "dTzGUCghqLGBTZYUSVR0Auo0gQFjRIR4mNTpUqSOBA6iYKDTJKKDSp6ACpJnMUnREDpStkjQo6la\n", + "eFqGJcehXJim5IdUxXCRh90GMyJiIAQVKcg3+1xodLm0vs6YohCGIWEcoysKpThmTVW5943HUIFy\n", + "ez+/8vGPY5rmyDX3tQcphy2a3/mdGz2SHx1/zxt5PRYjmqbxrg98gM//wR+wePUqnWqV1XabXYcP\n", + "f5epnqqqbNtW5KkvnSXSMyiKpN/vE/YTRKGFL5IkrF0gmmTVmH6nh0iM42pbDAZ9CnGIQ4TCNgQ1\n", + "JAUEGgq7EdRRqGORRgEcBAkKmMSELGGiECMZ0EbHRtCgTURAGlhGISLJOBFVYuoM8MmSpk/IJXqj\n", + "NJOABjptJtAZwyJCYZwqPQI8MvgYErqDARfCkP6FyyTiiFbgUQlj1iWEwSX6ShE1tQuhRCQEfOX0\n", + "VY5kMlzrChJWmdCTSGIms1mEIqiKWUJRwQtDNppNGorC3L338nO/+Is/kjzzXwOVSoUXXzxNvd7m\n", + "+PHbyGbTCHE7X/jCGF/5ysv0BjohAmpttMQaTz/9ApnMrdxzzyQXLlzkxImzSKkjRJYvfOGrJJNZ\n", + "jh9/G5/+9KcwzRk6nReJ4w7Dr8c+YI9+WqP7fGxsMqiEBET4SNJ4bDEgABqYmITYBLTxEQxJrgGQ\n", + "QqAjUYlIU6WJjoJOTIEmAyJqGATU0XEI6NMlg0eCMdYYOrl26JAnoodFQAIFW0hcy2DvzAJOq04c\n", + "eghg5+6dBEKSrDVoBH2abkDGcynk8nihz6adZld5G2e6HnPzs5imiZSS9fUVrl19hq21BEtLZcbG\n", + "x1nxfVAU+r0ebrNJKZnkquOQTSTwVRXb93nhuee4/01vekXz+qr+xnjooTfx0EP/+I1JKXn00T+n\n", + "Wk0xPX0E3w+IY5/f+cQfsa38Gc6e3WDvoRKpVP76FVO5vJNnnjnD8ePHSKfTvPe9b+PjH/8Nrl4N\n", + "MM0smdQ8y1ee5TOf/r/ohxaOWyMMJ2kSEysrpKWLwGKNNoINlDhDQJ9sNGCfkUZoBrbvcTl2Rp3E\n", + "LjY9Igr0RhXtBml88ihsEVMgpkPMRTTWkECbBBo3AVUiJDEH2KRJBxWNLWbwSaGjISkQUiFmi2VC\n", + "tqGhjK60VEwCNHqYRNyHg1BDfGlQo09F2Ows7KQTBgy8TfC6KHqalDmD4uusxn0GskcY+IT5W/H1\n", + "DGOGRj+uklFt4qRGs91my/cpl8vcZBgMgoB+EPCG++9/1Z24flScODFM6b3nnhs9kh8dd90F/+W/\n", + "3OhR/ORQLpd574c+xP/3G7+B1DSO7tkD3S5/8Fu/xds/+EFmZmb4vd/7E9rtErff9/N0zj5Hb6OG\n", + "jEC1yjT9LVKJBSRZ/KBNY9AlIwR9v4MrA66FAxJoaAgiukgEAxbpU0CjjsslkuSIaOMTsYpKzCwx\n", + "DSJMFAT7FZvLcZsKEh0LcEZcAp+YGZo4wDp5YnYjqRIRkWGLDA4xEcHIWXmYidPBIkEEqNgopNCx\n", + "kNRdH0XJcjkaJxx0iUKfopLgWHE77X6Xmi9Z9C7ywLv/HcFA4W++/HncbgXVtpA+uNLAkApuv4Np\n", + "Wqhql32HDnDrm99MZvduds/Osnv3bnRdv7GT/j04f/48f/iHj+H7KZq1dRqbVymULD72v/8q09NF\n", + "gqCJouTI5XJkMrMoisezz57mllsmsKwsly6tMTGxH9NM0GicwzBSPP30V5ma8uh0Ful0qmjaDLAE\n", + "XGbYmhHAwqjUHPq9WChExDQI0MjhsQsoolAlpoVLhgo201hIegwt/Mdo08BkgpgNIgxiBEt0gRoJ\n", + "GmjAfiRtYtIwYoDATcSYI2cpQZ4mARvYJGkziaCFZMKy0KMOlhwQGhoyn6UZBVy+dJWUVGml8mgh\n", + "bMWCSr1Gw1Rxc0Um5/dyqxGxvPwEllXm6uVLdNZf5k23bCM4c4YvnjjBtsOHGWSzkE6zvrxMQkoq\n", + "gwFNTWMhmeRSGPJT8/OsXLoEr8di5PthdXWVlZUenmfx/PNPEIaSxsYJpmnRn7KYcFXWn/4rGtsP\n", + "sP/W4wghUBSVMPwHw5yTJ8+yfftd3HnnAs9++9uEWwpKcjft3gUmadGNq2jmTgzFRNUzDIIuNa+K\n", + "Zh9gMieQziUmuk1ysU0Yq4QyYsy06bkubbosozFBnwSLIwqaNiK2lVBoE3CNoensOguYpMmwjhxJ\n", + "BYfh0R5ZQNIhYA6FFAYWIRF9HAxMfJK0cKkQsIWCgkGPJBE9JAU8VCXGiwe4MkBTFDQRoSYMTCek\n", + "53t45gSeDahZ2qGPH6SoOD3M1BQ3H3of1Y3n0PQauIKNQcjsRJ6f//CHuXDyJHEQsNHtotfrTO7b\n", + "x9FjxwBoNps0m02y2exrzlvk937vteEt8k/h8GE4fRr6ffgeE9PXDZ76u79jQVFYuPVWVqtVXM+j\n", + "JCVf+bM/4+iDD7K5Kclm84i5m1jbXOPy0jJ+twaGh6tMoise/UEVLRZ0KdCTAWFUQ1MlbXbxEg1K\n", + "+BioeOhsYBExhY5OgEWdHlnW0dCYxqDBGhUc0hTp4vJCPMCnjxgVEwU8QCMiR8hFYjocpMduhuFn\n", + "Hk1qpElRwEEnIsRggwwWAwwC0vSosp0EEQX6hDiiTULmmRUaV8IiLlOMi1VyhGy2+2i6SS5RYkHz\n", + "2Vzf5Lbb7+bgHe8kii4yUcrxjSdeYHzibpxWmzDso+sNMok2t7/5/XzwIx/5vuZzNxphGPK5z30N\n", + "XZ9l6dRXmYgjZhNZNq6t8d/+z19j3VOZnDxGobD9+jFxHLG4uMhgsMhLLzlImULXdRqNa1iWg5Rp\n", + "er08V640gCmEKCKlTzK5HcdpIOUY0ENQJybEYIBBH4cNmkSEFBBMMAw3tNDIMkyWabGFgWSVPBGQ\n", + "o0uTNjlylIjo0eEUKn2SSALa17NnOsA2hvbkdSIiukxgEaCPdtMlOUyq9IdEZ6HgqpJACJKJBIbr\n", + "splMUk6ncZw+qmFT9QZYdpo40ljzJF7cQzFMbrrjrdxx9CFWV5/hl3/5HVy5cgWl9hwP3v1mEqN2\n", + "zXwc88yzz3Lsve/lbKnEU1euUFteZnZsjNlikUu+z+HDh/GDgHSh8Irn9zVZjPR6PVZW6tTrIbnc\n", + "NrqdNcZ8H1vaeD2XsVwOKzHGhWsv05zfS6FQplJZ4siRPdef48UXzzM+fpRqtYZXrZIzDEwtSy63\n", + "wN6SRrddo6Z2EIyjqwaqaeJo2wniFANf4gdF0rKDI2JCICkEXuCSQZCmQx9YwkJjkgAFkwEmkpDT\n", + "gIqFBzRQGEMnRMWiADTpo5MlYhiJpVBE5ykMeiObNY0xUkSkcPFQaZNngw7nsJkGIkxCQtrkaeMi\n", + "0WWMiqQoDJxowOMrL5JXFJQIrnXr9M0D2IkpdBucqIowBoyPTwFNjh47ztzcFCsr57j61F9RnCky\n", + "PT1NoVDg2TNnGMtmedcv/zI7d+4kjmO++Od/ztUXXiClKPTimNmDB3nbu951vQ/5aka7PbRVP3Pm\n", + "Ro/klcG24cABeO45uPfeGz2aHz+klJx7/nn2p1J88etfx3QcLCHoSElF15GpPFfOniQVPI3wXBoX\n", + "TzItBdKcxLINNhyHVb+F45vklR2YmgKKg6tGDEILRJq2GKMVr6KhA/NEDFBoEXMNkzWmcJhEIUKn\n", + "QReFKil8JiiwHZuzeGgsYDKGSRuDPjZLBFyjAowBeZSRa6sgS4jDGg0a9Ehh4TJNE9hGTB8fgywe\n", + "eWIsfBQEUSwxFIs+GgmpImMfW5ooqo0nPYSqkUumEGqI06xgGDoQY1lpjh3/GQwrxVNPPYPUVCK9\n", + "S2E2wcf+t/+Dt73tba/q9urm5iauq1FZPsWcUMhn8jiOQylVottYorJVpbRw7LuOURQVRcnywAOH\n", + "eeyxb7O+vs7Fiz62nWJ8vMzGxllmZ4/Sbp9ieVkjjhMMBhIhEkjZANbQ6KGwxDDcUNBDAOOEzAEh\n", + "khaMUtlDasARYIkYh00UKlwDemjchE4BiPBpMk6bBVwGpOkh2YGCNfJZnQB8ho2hYfZRgIGBgwQE\n", + "uqogoz5NJLfbBpO2hWuaXHYcrLk5/EqFpWoVp9OhFypYqRyTQcxWu4OUeTTyrPV9lJfOYpl5Dt6c\n", + "ZG5ujkvnznHz5OT1QgRAVRQmTJPa5ibv+8Vf5OF3vpP/97/+V1KtFlPFIvOTk+iaxvNrazxy5Aiv\n", + "FK/elffPIJ1Os7R0ienpR1BVDbe9yqSRRA0DXLfBvfce5sSJC5j9iKXFM/R6VQoFj6NHH6bRaGCa\n", + "JrquEccR7VYTW1UJ/QBQEcTYdpKpwhSVXhPbKKNrIZg6bgeUsEFaJtD1HLpVJBV06QZNDJEkBNqi\n", + "w5QMiQlYBTqUMLHIERDSwUchZpOdSGJUzhMSMiBJDhWXkCZdPPqYCHwEWxQpENBBJ4GBgYeDjmQo\n", + "/jJxEYRsjER/FkKEjMkG05pgm6KyFASUibEJWCTipjjGVtN0VQ0tSqBIFz/WyOay7Dh4iK3KEyws\n", + "ZHjggXuuQiResAAAIABJREFUm5Xt2XMYp1enqm7w1MoKoZRse+ABPvL2t19vzTz+1a9SO3GCu+fn\n", + "r/sSnDl9mq/bNg+/4x03arn80Pj0p+HBB+E1nOt3nTfyeixGhBAgBE8+/zyzYcj4d+y6Pb64yNN/\n", + "+zUyjYD98/t5efkct1kJGo0lOhEkRZpiELPkBShMEourhEqEqijkU3tp9Nr4gYKISghSRKwgh/oz\n", + "YprY1MjSZ/+IKt4hokuLLCEzDPleF+gyYJYyBQI8kugkKVAjAK6ywFCFZxCTIqaCQMUiRQobjSQW\n", + "0KVMRIVVPIKRHVqPLhUKCCIG6KpGP47pSYUwTqPi41IlGetkkhkkXbzIIzIEY5PTFItFXHeJRMKk\n", + "3W5z5Mhb2LPnEKdPP8bP/uz9PPTQQ68JU0JFUQhDH6e6ypRmc/bsRaJIRcqIINgiayvU65dIpQoo\n", + "ypBb2Os1SSZDDh06xOrqJidPutx22xEMI0m9fpVKpYmUm4ShpFAoIcQEtVoFGEdGGYx4kaLSpBAr\n", + "aDEsEyPZSURMjTaQQFUXgCWiqEJECnBR8FExSdPFJoVHDZ8AnzQuASU6HGCAgsIGIW3AJEYHSgz3\n", + "zMsMWSYdIEWTHhEpEkgkHdlj2oZ5I8VGFLEZS6JBTF/6yGCDUrvB4elp9EKBrWaXp50WL7oRiSAk\n", + "Fj1aIk06exfddo/Lp/+Cj/7Kb/3QZmW5XI5f+c//mb/44z+mV61yoV6nr6oce/e72bZt2yue3xtW\n", + "jAghHgJ+E6hJKX+kDr1t20xMpGm1LpLL7UAoGoNBh7Thk83mGS+VuO++DN88cRJ1KuLBt+xDVVU+\n", + "+ck/pNeTSBkgZY92+wyWVaIWx2QSFoNglVTSp5Qb41q2xHRKoed3GMsmObdUJQo9imLYMAl8HxcT\n", + "TemSFE2ENqDuu5QEZIhoyjQp0qPU3kl0THQmSNDHoMUOFK7ioNOjTUyODhYaOVwCOlQBlQQJDEyK\n", + "1FkmjQY4lJHECDooTGJRoYdglpgNptAZ17oUcikq/T6eYZDudChoGhuKgjqAXYrBQNHxlSQytlFj\n", + "n02tT6a0HT9oksslGB9Psr5+nsnJXSiKyubmIrl8xD13vglF09h/8OB3hWcFQcCZZ57hzpmZ64ta\n", + "CMHemRm+/dxz3PemN71qt38B4hg+8Qn4/d+/0SP5l+Guu+BTn7rRo/jJYXrXLi49/ji3fcfacwYD\n", + "JnI51jfX2ZGfZuD1aTYrTPVbzCVtrvXa6PgY0iYhBL42TsFMMJZNs96tY5vT9IMYqXTAh1huJ4hc\n", + "JCGCFDZlApZIsIiJiYNPnT4TwB6GgfOSmMsEvEQLwTjmdYGmwCZDF40ZQlzgBQwMMqiouHgYhHQJ\n", + "mEWSxEUVCiU5QLCEZAWJwEAlgaBAyErk0cBkS01jq0V0BareNcy4iuknSGVtBqLC8iBmu1Pjz/7o\n", + "NzDCGmrb4ut/sYSVK7H34Dz/4T+8jyNH3nBjJvIVoFwuk89rnHd7XK01sMwChqFSrS6haQkq9Sp2\n", + "ao1m8xKKYiNlhKK0ue++fUxMTLCx0aFcTuG6TaRUURQNKV2azXV03aTdXgEy+L7EMDxyuTHc1mnK\n", + "ukDxAX2MNBoyGqMtXDQRkUiMI0Qep3t5REwdZrmr+ORpM0cKgYWBRQ6fS6xjoTCPhoVCl5AaPg4K\n", + "F4iYAwyGbJU0wwgRGxgQk6SFTRsHha0YVGExME1EILHsMuXMOF3X5fz6BbbCJLJlYmohGSGwem22\n", + "ywy2PknOtOnELoveWWZnbuWm2TS9bheAXXv38sVvfpP5OEYd9aqjOGbT8ziyd+/1uRgfH+dDH/0o\n", + "q6urRFHE5OTkv3j3+0YH5d0CfP1HPTCVSrF//000myZLSycJlTodvcO+uZswtB66YRALQX7XAh/8\n", + "6P9Cu93mk5/8AuPjtzA7myGOI5aXz1GpPEexeBObbgNvEGAmVpgwbc6eeYmVfo8WGVJ2m2JBoG9l\n", + "MZwacVzHixMINAahQdMK6QiNbuiyTYObTZMVz0MLLCSSIoI6bVxMTExiuqQZUMGngkOZARXKLNLH\n", + "JCJWBF6skcEnxiMgS4NFIrKsY+KPIqRVdAwMksTsQuMcLaQQzFkppJ6gEzaQlsWLvo+tKHQTCRp9\n", + "lzmhoqBiyBhNU0gZGbx+lW7rOc6ePo+pxlgqeLWAg7c36bQvUBgrEjqblIkZnDqFF4Z8/plneON7\n", + "3sOBgwcBGAwGKFGE/j3bvJqqoo0efzUXI1/5CuRyQ3nsaxl33QW/9EvD4uq1yHv5Qbjtjjv4xqOP\n", + "stxokNQ0vCiiryjsu/VWzj7xBAcOLHDy5Dm6nQqh12MskWAqXcTFIhEVWO1UyJQmyVp5zDgg6LXo\n", + "OB3Q+mTtJJ1WBz8IAAeLARbTSDT6CDQKDHAQgAscIkZjWIwkUJgk5Bo9anQZw0CijKLvfCwitlA4\n", + "SxaP7agY6IQj2e8WO3DJ0GMSj7SUnBq9xjgxNwuBiqSiqCzGkpqUrIoBYRzh+VtAiKMmqWfT9IIN\n", + "tpXKNDo9ZjQF88LX0Ad9yjt3cv+xu0kmElze2KB4U+k1VYjAcGfk/e9/hG/97ddZba4xnVWp19dR\n", + "VYFqTyC1Iorik0qtMD6+gKpG7Nw5x/vf/y4cx0HT0uzYMclf//WXaTTaaBpYVowQZfr9NOXyIba2\n", + "zhHHAUJkCKIzmMmQji+Z1AtE0iMI+8TCIdAsdDR8v0scd4EtVHwENWw0InzG8dFwYRhfh0KfBRRa\n", + "I8lCm5A2CXzShHi0aeASYzLcQbvGcGdEMmzXmCM9V0KopKSgO/CoeB7jRpqc5lCrLXGq2yOKpila\n", + "ZUQgsc0ELweXGadGJIc7gcmETtFKIwYd6q0KCv/A85ibm2PPsWM888QTTIyKi03PY++xY9/lIbK1\n", + "tcU3H3uM5YsX0XSdg0eOcPfx4/+iguRGBuW1gFfkY28YBg88cJgvf/klHnjgbei6wfmXn+Lk81/h\n", + "zt1TnF1Zoamq3P/ud5PP5/nSl75KOr2DZHKYq6AoKtu2HUDKNm996yHuuGOKk9/+O0x3Jy9++ylq\n", + "ToCaznFTRmLqBeqxIDc2QaMRI6JrSPqARl4ZMGUotJNFcp7HrONgC0FCCPoiJJYJqtTxyeEMTycY\n", + "VDFo0EFhGpVpFM5TZZU820o7SRoCVTTpNNosuQYd6QEGJgY9GsxjIxDU0AkxUXGYwEBlQFvqtOIu\n", + "c3qJajxgdt822ktLyF6POyYmOLe8Sj0akFGG3H7NShMJyVakgjLHTeWD+J0u/WCZQrBBqllj++Q4\n", + "6bkc4ZU6h7b/AzFsbjDga5/9LAs7dmDbNqlUCjOXo9XrkfsOT4Ke6yJs+4ZlWvyw+O3fho9+9LWd\n", + "egtDw7Px8SGRdZQp+brCwsICe+68k7LrEvb75JNJJicnuby6St1xuHDiBGO6Tt4StH2F7YUs0jDA\n", + "U/BJUbQTuOmIZDpHs9HDVUDVNygUBJZZoN9dwXdXEGwQY+NSQQFUPNqY1HHIEiORmKgMiEaPS3QE\n", + "CTyq+AwwSKCxiYdHhSwabSaJGKfITnwCPOqo9EgyhuQqJcMmiAI6sU+AQl2mkWQ4icSkx5T0MGRE\n", + "AhiXAwytwmK4RaiMoWkLSDPiwZ+7F81rkbh0icOzs5w4c4apQo5Kvc63n3qK9zzyCHfl83zryhXa\n", + "7fYNd1XdGLk5ZzIZZr5jV/X7YXp6ml/+X/8tv/3//C4btU0UQ4V0iU0rw1T5FiYmAsbGYt7znuOU\n", + "y2VqtTqPPvp5NjdrfO1rj7O4GGAYU2SzB1GUBO32ORznGWx7H6a5HcsK6fcrgIrn9Zkay9HtGjSd\n", + "PgU9QugRA8VFF3ncvouMXRK2hRoKJlyHTQI8ioToVOkhaZGnj8UEfcCnxYCYAQpbjJOlyAALRQmp\n", + "xQla1Mhhj/ykHLI4ZID96OiqhhtJdEXjsozYiiMOmxp9YwwjWcBwOwykjZ6YJZfK0+5vYgYRMsqx\n", + "RZKcDql0Etu2kXGM4g3Ycs5z6eoYLz3/PDt37aJYLPLGt7yF3fv3c+ncOYQQHNmzh9nZ2etz02g0\n", + "+NNPfpI5ReH47Cx+GHLxiSf43MYG7/3gB1+f2TT/HO6++yiKovCNbzyP50kmJjUe/vWPUSyOoaoq\n", + "CwsL178ANzcbpNP/mAigaWnGxsa4++67+ZmfeRe/99//O51mB+dqjUrLxhnkySZVFjdfIm6dZr9S\n", + "IhQhUVxFU4sYcTCkldpJ9k9PU7lyZRgcFEXYUZ+rkU6faSLmEWSJcBhwkU0C5inSJsahS0gf8Dhf\n", + "fZmCHjFtmdSFoCuLROwGTAYkifkGm1xDZw6bCQQxkGUdly6baMxyKfJYaa0TGxahO85y0ET028iV\n", + "FTJC0EbBjHzaqMRBkqq3QTPMMD+7QK/bQhcOu0oFLE2l32wxnUzypS98gZ/7Hq2rbVmkw5Br166x\n", + "b98+hBAce8tb+JtHH2VXEDCWydDq9Thfr3P8ve+97g/znXAch263SyaTwb6B8o9z5+DUKfjiF2/Y\n", + "EH6seOAB+OpXX5/FiK7rvPGnf5qv/fEfM1cqkbFtFisVHj9zhvsOHaKzusqYrlPO5/nrlRonnQ12\n", + "TRSRqqCvZSlN3Uxm+zQvvvg0rbZPzBoiNnDdHSQSHgP/KpIEJjswmKFPiI+DAdSpkGZoCBigsUFE\n", + "WijoUjIYUV27QJ8KESZtYlRcdEpUSJAiDaRGcWuCkCwxAWkEQrVJW1m8IGLNc+kYM6S1eXzXIYhj\n", + "mtJjQ15hP4IxTCpEyNBlt1Doixr1sEmvpfKGN/wCf/foo9w+MYEEZBRhWRb5MKRVr7NRr7OtXMZQ\n", + "FFzXveHFyCc+8VmESCOlw+xsive//6d/YI7VwYMH+Km77+ellyp4Ax0zmWcmNUGrdZlyeQ5FCbEs\n", + "i6tXr/HlL5+iVNpDrSa5fDmF67bI5Qq02018/wJxDFKmyedLNJtX0PUypdJBms02Iu5jKBHluTQ9\n", + "R0V4A1r9HjoxbWcFgUk61cVKRPjtBlvoRMwRYY0a6SZ9lplggEMNgzwONj2SbDFAo0QbCw8TK/bQ\n", + "sYnYhzJqEPYJqLHKFA0UIrZFCqqqs4WkpmrMpSxUVcXzfHwlhV0uMW/Datui7jlM5fOYCRMlDKkP\n", + "dO7cXqLR7bHccYjdgKWoQTpr8fZjxyi2Wvzp7/4u//Y//kds22Zubo65ubl/8vM/8cwzjEcRs+Vh\n", + "krup6xycn+fpS5dYWVn5vsf9IPzEixEhxATwJ99z96aU8ud/0LG//uu/fv3348ePc/z48eu3FUXh\n", + "7ruPcuTIYVzXxbbtf/ILD2BmZoLFxTql0sx33R/HXfL5PDA0S1peXOTc0oDlLRtVvQlV0Wn2Wthu\n", + "n0ykMplP4idydLsVNqINXMPC1BPcfettGB50Wm1ObW6QBlAjOpGgTx6LBOCNiKYLhPTwyaCRZmuk\n", + "qhkDQhy0OKDqDyCUKNjYIqAvHWJq6Cj0yJMjj05IjpgO0CWBR5IMLilN0I4SyMQsh9/089wWRnz5\n", + "zz7N4uAis6KP48WciCSxopFQWnTtJKnkBHvnElSWq8znsyQNg6YbMfDqQ1l0FOENBv/oc1W+Jzxr\n", + "3/79mB/6EE89/jjn19Yolsu85R3vYPcoSnZzc5Nms4lt25w+fY5nnz3PcAPS5a67bv5By+Enhk98\n", + "Aj78YXgNCH5+KDz44NC07T/9pxs9kp8MDhw8SC6f5+Szz7JZq6GMj3Or63Js927WFhb4ypNPcbKR\n", + "RB87SiaRIDE3TrO7RBT0cHXJoLLB+PhdDAbPMzn5NsbHt3HlyjlWFk+gq5MookFCTiBRSQFdBApj\n", + "uKyxKGziyUl61cucCvsc1jTiIKCOwWWgQgLIkGWATohPkh55YvL0CBB0CMiPjK40Bqis4zIXOWw5\n", + "Dt1YUKWAaS0wVt7HpWuX2Bg0MYAk49haCy90KRCTI8STJtVIRSdL3434+Md+jXHdJy6OcdPUFE4Y\n", + "cmZ5HSEFFU3Q6XTo53KEhvGqkN3Pzx+9/vva2iW++MXHeP/7f+YHHDPP/v1lTp26imntxLIytFqL\n", + "ZDIe09MLbGycJY5jHn/8BHNzb6DVanPtWgPD2IaqxnjeFaQsEQQOk5M34TgauVyRIMgjhE+5nEeR\n", + "TaQXUEhPQXCeyYTghbUKIp4iY6m4YR1dlURBknY4QFBEVUqocQ6LkBwRAZKYMh5tCnRZo0cFHR8H\n", + "D4sEZQJUNCLS+PgUsEmTo0GEZBMdj0nW6dMCLhCTjQJ83SSbz3FbwcZQFBQvxhpLMTO/g8snz1Kc\n", + "3EW7uYGpSBqDAXFmGFbQCCMSts1Kd4O23wRD45ZdeymXSkwXi3SWlzl75gx3HD78z37+G9euMf1P\n", + "FLFpoF6vv3qLESnlFnDfKzn2O4uR7wdN075vJX327FmefvxxFi9d4qVLLfYcfJCdO/cQhgFra+fZ\n", + "u3eS8qi6A7i4WOHiSp8g3kZSzeC4IX23zkyokk9mGPhrpBJFLMMgKSfYsrPESYVqO8vTLy/i9ecJ\n", + "Q8GE3Sb2u7R8CxUb8BBCoEtJiE1Mmjo60EFhHOiRZJ0pbGyZouMPuCJ9dDQyWopmsEUXSZIJdDQ8\n", + "SmziUqdPlhiQWCSYEQp5TTChFPENj3rtGqZR4PDe21mr5lhc/AZG9ibGzBk8T6Gd0BgvBvSdJLqu\n", + "UsqmkXHM5XqbtfYmqVSbOxtNMuUym90us5OT1z+rge/TVpTvIrHC0KZ/x/dE3Xqexxc/8xk2zp0j\n", + "LQTPX7nGSjvH/W9+D7adJIpCvvGNUz/kqvjxotUaZtCcPXtDXv4ngvvvhw984PXtNzIzM8PMzPDi\n", + "4syZMzx/4QIA47kcsZrjnkP34AcR52pVZGaMhJFmotjm6N0H+NM//SZjYyUsSyMcmKxcXcYy0qS0\n", + "iLHSHi5efZFELJC4SCkYoBDSRhNZkmYBI59HeA36ffi61ydCIDHQSZDHIT+6NIhHDZ0t6mxiYlDE\n", + "ZAWFJn1y+Ag8IhQcYiVPWwoi4TNA0g8U/LaD40lisqQQuMScDqtkUChhkEDwImkEB7AVhYS8QKFr\n", + "kTElWbvPmTMv05Q24yQx4ogGGi+ceJlN3+fBf/NvXnWGZlNTOzl37lt0u91/dnfk7JkzNFevkOUC\n", + "5y49SXnhp9i37zYWFu7GdXvYtkc6nSaOE+i6wdZWFU3LYBgN4rhAHG8ipU0y+VOoaoBlFUgmu1Qq\n", + "AapqkEyGaOoKP7XvJtxWRLWdZPfCJC9cWEGGTRx1nqw1QxxbdLwaTnyKhDmJoqTw4pAUEh0DZZRW\n", + "cxWDDt6oGAWfcTRSeEgCfHIj0wdBFjnKLJKE+CiUyGJSZlxotGWfNUKmEhE/f2gfz1+8yN5ikfmi\n", + "RV9zWbryHH7Ywhqb4J77HuTCqdMMGlV0WiTSk7zcMwlaK5Riwbw9Qz5ncYtt85XHHuPQHXeQtm2q\n", + "6+s/cJ5ypRKdc+e+qx0PQ47TvyQ24EaqaW4H/m/ggBDiq8DbpZTej+v5Tzz3HE9+9rPsLZW4Zf9+\n", + "Fqwr/OWLn6HT2c/ERJGjR/fxxjcev/73UkqqTRepFlFRUBUNVVHp9TViqZJKW2TNCENXESJJ2++w\n", + "4ldA7uL8xQ2CcA6CASkrw5a/QuheQAgHTcZoI6+PFgmM0bLTGScgQZ9rZGiRRMPDx49dBArjSDps\n", + "4ofTRLjozKGwxt9fvBuM4SEwRtdtGRGRtDU0QxINVIz2gMc/9yjZ+TewdyxPLpVnIzHHrskHEIpK\n", + "y+1SHp8Dpcea9yT1oICm65y8sokfG0gGzBcO88WnN7jjjbtJb5vlxJUrTCSTDHyfzSji2Dvf+UMt\n", + "vicefxzn3DmOzs0RhCFPnVxijBznz5zl0OHDqKrG9PT+H9fU/0j49KfhoYdgFGj6ukAmA4cOwTe/\n", + "OXxvr3eMj4/TjmOklHT7faLIQNcMmr0me26+mf0jkvXy8hM88sjDLC93qFZU3GaPcjZC03W2GlV6\n", + "PQdL64IS0Y8CDDRUJDERCilUWoggprt2lQUl4tbJcVqVFi/3HHpolLDYpEOBGJ2AYZmSZpIkHTYJ\n", + "USmRQGGTkA0cfCQKCaZZQ2OLCoZeINJ6+LFko7qJKkooUqLjEbGFJ2boyBXKGLQIiJkkpaTwWWEa\n", + "A8vIEioWF2urmH5ITRkwSOSpi5hEJsdz61tsS2q8odlkMBhgWdYNnr1/gBACIXQ8z/u+xciT3/oW\n", + "f/Kb/w29HbDLymEk26yuPEN/foarV5+h01nh6NHb2djYIAwdpJSoqoqqKpRKeVZWqui6ghAaENPr\n", + "Ndi+fZyHH34rn/nMn9HprFIuT5KxDxJWWriDkFiEnFhaxQcCUSAvSpi6StsJUOIUsSwRyhAvrqKQ\n", + "JyZGkhyVqFCmjIHJGhWybGcHE7QIaNInIk9AlwQQUidDggBBFUiiozBMNtOUHHNGEW+wwmZvwF9f\n", + "ucL2nTs5vbaG1W4zZtus1+vouk4hVeHcS18gL3T27E6xY3IPL152afZNRC7NjmSefrUCccDLF69i\n", + "GwpP/u3fImybe36IoLtDR47w2RdeoOC6pEaihOVKBcbGrmfHvRLcSALrCeCV+cb+AARBwJOPPcZt\n", + "09PYo3+2W3buZG5ignO+z0c+9u//ka7ecRwymSwzC1NcvvgykVdAoGOkZ+lGL2NnNGYKY4yn08Rx\n", + "zLdWajR7GUr6HAkmCIMtGv2TtJUxpChDbKDKc8RcRbATl8SItrSORjC6rRCQxWQVjcQoUElHoT+i\n", + "MFXwZAtBhIaCjySLIGADwTQqGh2GHq2zaYtSNofXaRDikk8kGUQenbVNntnaYr4cM16YwfUcTDNJ\n", + "N46ZzpXwPIP5+THuvHOBP/j9L7Hp+ShSJ5ta4GpTsO/AHvwwyYOPPMLW1hZLly6RTia59+DB79pV\n", + "+n4Iw5CzzzzDG6amEEIw8P3/n7z3jpLsrO+8PzfXrZyrOufu6cmjGc1olCVLSEIJYQRIYGzABo7h\n", + "GHzswwafPcs67O5Ze/3ar9nX3jW28S4G2TIgRBCSXoRymjw9oSd093QOVV256lbduH/0MDBWQEia\n", + "GZA/f3XfvuGpfm4993ef5/f7fnE9hbZYnNMLC+cGRFW9+IOi46wt0fzDP1z0S19wbrkFHn30X08w\n", + "0rd9O/v27KE7FsN1W+TKRaqSxOjZwbHVMvD5JFKpFO3tIfY8/TLxgIAouuTLDfLlBqIcZWl1HJ/g\n", + "wxILCG4bVSxMDOJig3ZRBamGZlSQPIkps0RfIkuifpKq53ASHyniuPhoUUVCAgJnv9kNVE4hIRNB\n", + "QaXGPAFkrsCPgqeFENRuGlYLvzxJs3Yc3A5UKUTDNWmyTBQL0fNTRqR8VhTRw4/gAdQQPQlBUkEQ\n", + "8dQkdTGI6dSYCvSgq3Vu7B0iHYxg2YvMPPkkizMz3PfRj/7cmFk2GlUCAc4tnf9LLMviK//fXxGu\n", + "qWSyQ4iCSCTcRWjuOMvzLyJ0bSGTuYz5+QCnTx9lcXEKUYzT3t7N+PgcPT1ZisUjeJ5Eo1Gm2Zxj\n", + "eHiIO++8hUAgyOjoCFNTdZLJXvKUeOnAMYTmIrYrYjpxXDeEQ4SSKeFi4rguBg0E4nieD1kFy2xQ\n", + "c+vIiLhUkJlHQsTBxiJKlCAiIKMRwMZgmgYGKgZBGsh04BKgiYeCg0CeED5k16VluYTEIGVdo9BK\n", + "EpF1IuvXo1UqFJeXuXb9enpjMZ6fmuJMvc5H7r2XbDrN6fl5JFEkqHoYuRqRjm7mp45SX10ipJr0\n", + "t6eZsSx6IxFWx8eZnp5+xYz3T9LZ2cnN99/PDx9+GDGfx/Y8Il1d3HvvvW9JNO8XNoH19SiXy0it\n", + "1rlA5EfEQiGcmRls235FMKIoCn19XZhmjcHhIXK5FVw3gmmWaYZEoiNtJFIJ5qenmSoUmFKCpLJb\n", + "EQSJVukIemWGsJvGL0ao2y1aYgTV6UPiFE2KNPEjIOPHxSKDI8hY3pqXjEUTB406OrWzOn8JdCRq\n", + "eMI+bE9FPRtlN5BxKVOhjH22dMyHiVjXKVo1ghLIXp1mM0Fd1PApGjOlSeIJiOqD1ColZusVYp3D\n", + "NJtVqtVJPvKRW9m+fTN/93ffoqPzOlQ1gW23kCSLUgVaLY1SqcSGDRvYsOFnm8GwLAvPtlHPTgn7\n", + "fT40xcZyLCRBOCfRbxi1N9/hb5JHHoFEAnb9YlU4viFuuQU+9KFL3YqLx+3veQ972ts58OyzEBUp\n", + "tAx27b6FYDCI49jMzx/h9tu3I4oiV1yxlR9+42G0kMbJ2Zco1fxEAxHwp5hbmiIa8KhVC5TdNYkr\n", + "CZWU4Cck+Vl0qqRdiPuDOG6VQnWViiBiewkkwrRo4kPAQcOkgEPrrGVmgw00ieORESVedkVUKYMn\n", + "lKk7NrLXwC/FaTVOIzbniAsCAhM03SUQbfCCSF4ICwELldOih89t4VHEFZOYroQhemA6eHKT7sEB\n", + "DEPHwSWS3EZj7iC4ArZlEY+F2dTTw8uTk0xNTb1iWfVisrw8TSSSpFYrUatNcf/9N71m7t/c3Bz5\n", + "mRWGerYjCmsBlCTJtGX6eWLfM9y7/VdYXV1hZmaWaDRKINCL45yhVKqQydQ5der77NjRRTicJJc7\n", + "hSRlGRnZjm3XmJ1dIBotEQrZPPbYV3FdhXJrgVp1FVXZTsDfhS9kg2HgOHWqdhPXW1mrSpRVBKGF\n", + "LO/Cdc/gmIfxaNKBdTavz2WZICIyKgIWFjY+RAJIhLHJYWCTAmCGeSQMPHy4tJFCRcHxQPCgLrj0\n", + "dw5w5cYb2De3j01tYRq1GjeOjp7TBemMRsnn8yxMTdGWyRAJBHDdOYJ6G3NGnaXJQ6Qlhxouumtx\n", + "ZH4et7eXK667jlKzyZEDB143GAHYsHEjI+vWkcvlUBSFZDL5lu+Fd2Qw4vf7MQUB5yeEW2Atz0FQ\n", + "1VethdY0jWuv3Y7rTlKpGPh8FWy7SDCoctttn+amm65l/PBhWidO0JycpHJshYYpcHTyOKnG8pqP\n", + "o5ACyyQEeEIFBBmfl2KLUqdgVZkjRkiMkfPAIYeFh8oiFRSmsBGJIBPEpUGBBTwUdDFPxqmcVehr\n", + "o4CJSLDnAAAgAElEQVRDk24cXMJUUKijSQVygkXWKYPl4RNkVn1VJJ+fkL9EVhboXreZTCaDbXfg\n", + "98ep1QxE0cHvT3Hnnbfy3//7/8CyFAShCMiEQllcFxYXz7C62nrTGiG6rhNtayNXKpGKRpEliZ2j\n", + "nTz68nFMXwd+v596vczS0sXXYH+nlPO+Gtu2Qa0G4+Owbt1P3/8XHUmSuGL3bq7YvZuPmybf+c6j\n", + "7N8/RrXqw/MMbrhhM1deuSZV3d7ezlU71tGp6zz83MucnKsR0BQKtTzdfTeiqDqV6SPojWUkx6WJ\n", + "iiho5PFQXQWXFqZZJawKiI5EydVQiCEh4+GjQYW1NEYZyFPAogcPVRAICCJ5UWTaC+CQpuUmMD0J\n", + "oVWhZk/i2Q4BOvH7fNTNCglKbBZlxl2bIiZNr4Em25hKkqIlgLNChQCulMEvLqF6VVTJoLd3mH3H\n", + "j1GVM/hMh6AaI18r4xfqDAysLVtFRZGVpaVLGoysWycxOztOT0+cq69+z+s+BD3PwxQkziqin6Ns\n", + "1DFaKi+//BKy3ImmtVEqlbGsOS6/PM1v/dZ91Go1BEFgZSUHQH//x9F1nSNHjjI/v0Iq1c+3vnWK\n", + "RiNGW9sorivh801zOP8U8WQX6fQIhpFkdur7CE6Flr2E6yWxvTTYJQSniGk+juCtWSemkAggIuAR\n", + "R6GEjUMdQXFxbQfBa9HEwSOMQh2FDHOE0CigUSVKCZcALk1cVFwUWl6VitLkmr4t2LaJZSocmZpl\n", + "i08+7zkX8fmwVZX8ygoAqWiU3qzKgVOLVCUPs2XgFyVCfpF0uoOGZaGn0wSCQVquS7VSeUN9J8sy\n", + "bT+RR/hWeccGI0PbtnFs7142dncjnA1Mjs3Ps+Wm1468b7nlRgqFMpOTZTo6dtJqFenq8vMrv/IB\n", + "gsEg4XCYif37uWvzZv5heQ+61snkxEv47SqG4CIIFpZg4HkGOC0sxUfFbpGjgSSIKN4yq4JIyEvh\n", + "kx1WnBwt10bAR4F2woRxBQHLU9EYoMU0LSrUhXYUL0CRIhZBIshYNLAJUiOG7Qr4/X4a5gRR28QS\n", + "JOxGk1ggyUAsg1ETiUQ6+NVfvYtHH32GfH6aVCpEMOhxzz2/jOu6PPLI8whCB9WqTaNRQJZnSKe3\n", + "YRgFfL4Q7W8hqeL6d7+bh770JZqmSTISIRYM0N4l4sZl5uefIRr1c9991/Hf/tubvsTPzLFja1oc\n", + "99578a55MRFFuPtueOihd7aT76uhqirvfe+d3HRThWq1evYt+cdu0plMhnhfHywvs2VwkIAvSDSU\n", + "4IXj+yjYfswypHxd6IpLSDAZK05StHUEJ0laCDHnrbIeE9u0kYU6qqiw4AokRQ3FTXIGcCihUcfF\n", + "JoZHRBCY8TzOeC66oKJJXWhqG81WC1FI4Ylhms5+IoSQZQWfX8K2HUpOC79bYNXVgBRBKUgy0UXF\n", + "mKfpyrSkLIK8QtRfx5I8ym6BsJ5kvF7GN7qJLi/F7JkFrNoCfTGT7dt3kUqtvYM3XJfgJdb/uffe\n", + "u9/wvu3t7YTaskwVFulPrC37uq7LVH4eR5Lw+0fR9bUlHkUJUirBsWNjpFKpc5/5X8qV79q1Vjky\n", + "Pz/P/v0TxOM3IUkqMzP7WV1dxXF8LC7+EFVVUZQI4fggq6uHcc04shzGbjYRhCiu6yIKIhJ1TAwM\n", + "5ugUQ5guWJikxDrzgs2KNA+eH8+2sVEQ0NgsqEgSzDsKmhenjokPsGgwjYOPIi0kDMHH6ODl1Iw6\n", + "e06cBH+C47MmNTlHfzCIfnb2udZs0jMywplqlVypRMDnY6Azxbw5Q93UqJotCs06gi5haxrb+/tZ\n", + "chxKtRpLlQobb3hT9SZvmXdkMAJw87vfzfcsi+cOH8YvCNQ8j5Hdu7n6dUw7/H4/H/vY/Rw6dIiH\n", + "H36McrnByorL17/+He6442aOjo3RWFnhqakpWpUljqwsIVotooqM5RSZs0+QUWPEdY0zpRqCm6ND\n", + "rJMRFKoYBIQWeHOoUgvJ8+jyGkwRwEZGIkqLBC0sErKOhEDJ9pDpolfppeE4GI6NiIuOQQUJER1N\n", + "kFGkNF5zFRudFCbtno4iyUyXpnmyukxy6Cpq1VUeeeAB4pqG59aIRGXu+7VfIxgM8m8//wUaJR2z\n", + "IaCqfhzPo9VSWVp6DE2rc999X3jTQjYAfX19vP83f5OXnnmGI3NzxLu7+fT999Pb24tlWSiK8pbO\n", + "/2Z4p5Xzvhr33AO/93v/+oKRHxEOh19VbM8wDEYvu4wffPvbVG2D6dUl8pbA0NbLefbZZ7GaUST7\n", + "DAGWCRgGo5Qos0LRK6BKfiSnwZxlEBRk8EwKnownWhiiwrJr4+EjgZ8QLikC1CjTxGSLILPXc1j2\n", + "NCJikJyZx3aC+OVJZKlJzVJwaCI4AnKlSY+qUHLCTJnLOHQyEE0S8vmZbTj4tS4CwhlQQwz3p1ld\n", + "3ccV3VFyjTCTlkxOSOLV44BHNOGnQYu7brueznQagJViESMQYGho6IL3g23bnD59mqWlFeLxKMPD\n", + "w28qcdbn8/ErH/8QX/rLr1HIzRJSNEqmgZmMEm/JVCotisUFqtUahmFjGAUSiTzj4+Os+ynTg4uL\n", + "i1iWjqoGOXjg69RXLcJSjIzSS7G1RNM4Rm/vjayspKjXI4RCHfj9QXJLE7SMSWAIGxFZENC8BKro\n", + "oIpzJBQRyzTwISAFAiiKi11cQBNlLMFl0VHRvQEkx0LxCjjkSVMjwpqQno8mqwjUEPEkj1pxjj2r\n", + "kGq/glBUYnTdNTz96Dd54OA4dw53U7Nt5GSSVCJBx8AAB/N5tFaLkcsv548++1n+zxe/yPZYDFEU\n", + "2b9nD/byMmFVZaJSYWJpCbWn55yq9utRLBZ57sknOXHgwDkF1iuvueYtJUS/Y4MRTdO45/3vp3jz\n", + "zVQqFWKxGLqus3//AfbtO4bnwfbto2zbtvW8/JFGo8EjjzyHJI2wceOaUNrs7Ax/8zf/SDV/hurx\n", + "42zOZEhGgiwf28OKa1FHJiSZrJMXcUQPn5JGlPL0i2VUUcJAQpZlehyHk6JH2h9AsE1ynozYLCJ4\n", + "NgJ5WthonoYlO3jiMrpbxCZFwamjCTquJCKTIeceRfHCxAU/eNC0LaIU8XAJiBqOZ9GwTARBRVU1\n", + "WrbOnqeeZ/1tO9i5czuCIHBmaYlvfOUruKLI6b3jXNE7xNGpZcqtCi1BJxBOYJoTXHXVRq688srX\n", + "+je/YTo6OnjvBz/4iu2XwqCrVFpz5z127KJf+qJy3XVw+jTMz/9im/+9nRw6dJhvfOMJHCeE53XR\n", + "CAhcdkMnjUaASKST6GGFyaWn6cNgJBDCcBu0AQtNnZJnsOgK6B4k0NHRaXkFMiLkhDPIOAhiiKxb\n", + "IYpJEBk/Kroos+ou0VRkkqJOXoviuQrN+hxpigRsCdHWSOJSFAQCwgAy4FkWgmCi4Mcva7hOi7zh\n", + "IXopQv4MueYkQquGXQ6SUdpICE3i4TBOocbU0lHimTXtHlGssH77Zk5bFouzszieh5JI8Msf/OAF\n", + "r6ap1Wp8+cv/xOKijSxHsO1ThMPP8NGPvrkpyXe965eIREI88shTFAoVtnakGR3t5Q/+4EtMTh6j\n", + "WhWwbdB1j46OBH5/lq985Tt87nPJ181rSCQSaJrAwsIhGrlVuoPrcd0WVamKT2pSyE1zUvoGiuJD\n", + "0xwymSzlpTEGfAVyVnjNpJU1F3cLh6gSp+osM6xCXlA5JYCs++gPhahaNp0olOs1PFqMM4foyaRp\n", + "kqFONy6zrHnSpIE2PAzBpSB5nK5UcGWXYu4IKhEqqzI33vF+9r30IPtlkZ6uLlaBernMxsVFQqJI\n", + "yXEIRSLYtk0L+D/f+Q6jfX0MrVuH1dnJ3kOHaCQSbLjjDnbs3PlTl+RrtRoP/PVfE280uLqtDdtx\n", + "OPXkkyxMT3P/xz72phOi37HByI+IxWLEYjEcx+ErX3mQvXuXsCwNy3I4ePBJdu48wa/92n3nsoDH\n", + "xo5Srwfp7v6xQFo63cPY2CQsTtETDBLVdeZrNa7OJIgtLzNrNRGAq3w+5s1FFuw8eqBFueXguJAM\n", + "h1GsIFXDIRSQmNZihFoeirnCFskhTJ0loUDBFci7NTJug17dR84GlBanzCWc0DpSup+looNpCKQQ\n", + "kbHWhKeFIllPxMCjiUZQ9ai7CrqcJOxVOTM/SVtkkH9+6hQ+ReaGy7aSjkbZu38/puuSjkRIhrM0\n", + "GgaFikm+XsaVRWKxEJ/5zEeYmpqi0WiQSqXo6Oi46LMYbzd/+7fw7nfD27jc+XOJosDtt68t1Xz6\n", + "05e6NW8e13WZmJjg5MlJNE1lw4Z1b2itutFo8O1vf5v9z7+MTxVZt3kzew/O0dt7DZq2NuA2myOs\n", + "rOzjwx++juXlVSQ28tw3jzNQdRgMa5TLAcYLLSaaBqIQouiGKNHGiuAhMEW7LLLJpxOyWrS8Gep2\n", + "kAAmDgoIEoqiIAkKMSFIuL2HhlGlC5lKfYWUmKPD8eOTY+RtgxVMskCJHBF/G5WmQcFaJq7rOIJG\n", + "WrAYrxu4apRWy0BWQPH5kIGKKVCSZEYHBmhJNWRkRq++Ap8vQCAQYWbmMNfduZY3Jssy2Wz2onyP\n", + "H3/8SXI5Hz09I+e25fPzfP3r33tT5xMEgSuu2MWuXTuxLAuAP/7j/8nIyGXMzLjMzxsoSgDHqSPL\n", + "BsPDI8hyB3v2HOC22167eLOzs5OtW7v43sPPobk+LMtgoTKFS5L25AiVVgPTzJNINOnq6qFaWSZh\n", + "rhLS4tRaAuCheiC54Cgqc3aVpCJyShUpyCK93d1MlcucMU0c16HatCh4GiYZNPzIeFSpotEgg4MK\n", + "9EoSDc+jXRSZ8gALqq6N6koEzBY7+npxTYv548fZuHUXn/zk7aiqykNf/jLDkQiyKJKMRGjzPL70\n", + "//wZWC6Xd7ezPp1m8cQJjhw9StfGjQzdfjt3f/CDhMPhN1QNc/jQIQKVCoNnxc1kSXpbEqLf8cHI\n", + "j5iYmOCpp8ZZWvIjij4kyYdpmiws7GHnzi1s3rz2FrG4mEPXo684vtk06ZQVol1dnJmdpVGrgePQ\n", + "FgxStixCioKiKPgNA9dxsFebZG2XsGfSrFqURYWaGMbzdDLdl7E8/gxdZole2aXpiZTtEk00/NTQ\n", + "LVgtzaCLoEt+2j2LGbOIP92P4izgNnKAg+cV0YUScU/AxkPFBlEC0SMaSJGvV3G1GNn0FtqCHTRa\n", + "Fb794hjFmsFSwWZiLo8om6QifjS1wvDQAKVyidxqibzc4tY7ruWpp/ZSLsusKaVW2LAhy7333v1z\n", + "J5j0RvlROe/XvnapW3JxeM971tRYf1GDEcdxePDBhzh0aBldz+A4Nk88cZg779zF7t1XvOZxy8vL\n", + "/NvP/yGLp0okAwmgyr4f/g0EUnR3/3imz+cLIAhparUGt912M1deuZOpIwep7dvHZKHAC0tL6KbJ\n", + "KCotTAqUyQsSVUYRlSCu7wRlp0zdamGrYFFHkCDiediux4xlEhE1JMFkpVqg0DIYjmWZLs+TdDxC\n", + "kobrNUnhguix6oKnFNCT3RRzUwxQxpQEZj2LOVsBSaVuN/GaC6TiATraB9nY2cXi6hjXXz/C4vQ8\n", + "PjWI32ohSQrB4NpYpmkR8vkSO3bsuNBddg7btjlw4CRtbVedtz2Z7GBm5sxbOrcgCKiqyuTkJIah\n", + "snPnDeRy/4wgtFBVH7Zdp9lcYuPGOzHNJvPzK697PkVR+MQnPsjY3hdZLFdpuSKiHCMRypLOpJGL\n", + "y3Su62HdugShUJXHHv4Bop2jUl7BcGUC2hA+LYZZXUJWJep2kyhNbEuhAew/PUGH6xGXVfKGhYtL\n", + "1VXQULFxkGgioFAiRYV5ZEBxXRygAVTwEZAyqIJNNpKk6cocnphn52gfaddmevIww8O/zdNPP82+\n", + "l45zyt8FqBQrR6k0DJqVGgMBP0tulXhc5aZbbyVXLHLKdYmn03z5z/4Mz/PoW7+e6971rtdV552b\n", + "mCD1KjowUUlieXHxTQcjPx8F5heBI0fGmZysEYn0EI2mCYXiJBK9VCohHn/8qXP7ZbNJms3yK473\n", + "PAs1oLNl+3YGd+1Cy2apKArxnh6uvOEGIl1diJEIq4qCT1UZFUR2KBob9QBbfD5GdR+q2KCqSPj9\n", + "ZfyhJiG1SUiGVX+GdGA9cUWlXW6iUSKKQFKwkew8XbpDlCUW5scwGpOEaSIzTYscsufhYGHjskSD\n", + "kOaiqhKm52FKftx4G/FUH4ZpIUsqlTo8O1YnFd1KMDJCJLwFjyjzuQPkK7OIigdanf4BBdO0WVrS\n", + "UZQ20ul+uruvYGysxIsvvnwxu+5t5Xvfg1TqnVnO+2rcdhvs2wdLS5e6JW+OY8eOcfBgjt7enWSz\n", + "vXR0DNLRsZPvfvdFisXiqx7jeR5///cPsjID2/q20ZPppSezHlHowcyvMDM5dt7+iuKjXjcAiEQi\n", + "fOrznye4fj3jhkFQEFivKGiCRBKXQSz6vTyydwRVDNOww7TFY4gBP7uGBhjSbOKuQKcaJStqdHgW\n", + "OSfHtG2xZJkk41kk16ZHVfHJCmHNJRmS0FWbrE8mEBDRNJdaawbPauBTfPjlFlV7BkPWCIeTiNIy\n", + "jrBEIDlIIBxkenmcgU6dbDxOJBLAaNZoAH7/jx8Yplkhnb648u+e5+G6LoLwao+Zt2dWxnEcQELX\n", + "g1x11S10dibp7AzT3z9Ib+8IPp+fer1Ie3vqp55reHiY3/l3n6Wt00XUG6RTGTKZDKbdwqbC5s0b\n", + "sW2NWCxMui2KL6AQC0fpCPrXtJ9Ui0gmQUUu0xkss7GjnRU9woobQrV0goqffn+UYclPxRFJoJ71\n", + "O8rTRpU+ysi0WEagDuQ9DweY90REOY4puIS0EJY9g6J4lKoWp86cZrV0iu6Ujud5fPvhH6KI/bTF\n", + "h0hFOshXNEq1bkTLIh5IkEz0UCx65POrDPX1MTM2xvJLL3FVWxvXdnTgnTrFA1/6EvV6/TX/T9Fk\n", + "kuqr2IMYbzEh+l9NMFKplLDtNaOhn0TT/MzOLp77fePG9fh8ZfL5NVncVqvFsWMH8PlakExSMww6\n", + "OjrYdfXV6O0dHMrnScRi3Hj99YzLMg3ANk16FAVLlLEkAQnQLAOfIiAFVNraEvSNbkJJpij5NUwp\n", + "TjqepqezF0d0iKESU5OoUoiMpiJbBVp2Dr9YJugJBNUsjrQenT5aZMkRZJUqiiIzicAZCWbFOlOS\n", + "QnLgl8hk2zHwKNWWcR0BSUyyUCySHRjAF08QD/WTigbZvUGjI1WgZ0Dg1tuv5bkn9pMfn2Tq5Zd5\n", + "7tFHmTh9mra2YZ5//tJIt78d/Kic918Lug533QX/9E+XuiVvjoMHx4lGu85bUlAUFYgzOTl5btvK\n", + "ygovvPAiL7zwIidOnGBiYoWUHj2nRwHQme6h2rBYnZ847xqGsUJ//4/9NLZt24YTj+MoCt3hMC1F\n", + "IeK5hNAIoZNFIEaNZnORZtNhxnTIdHezalms01VcSWLOXKbpVZBkE0nyqKlBiqaN0PIzV2hRbRi0\n", + "RA9FElEkiXA4jOZTKIgCDWWQmtEBwhAnhGGWfBm2do4ymIDBXpltGzq4/c6bCATqiPoCgWiJZFhj\n", + "YmGBQCTCXGMeLdWFpq09oFZWZgmFGoyOXtwab0VRWLeuh1xu9rztlUqBWOztmVnt7OxElmu0WgaZ\n", + "TIZoNEyl4lAs5kinM5TLeVx3kcsv3/aGznftdddxxwfuoLPNw7AXKNbOUGvOsn7zANPTC+zZc4jv\n", + "f/8AM4sBliyBrp5NbF+3i6uG1hH35YikDdb1+Pj0Rz6A178VLXs1CWUDQXk9C1YHh1s2juASxaOO\n", + "hY8Gw/gJoBFBZYS1Sk8HeAmYkiQKsoKryEwLIqFID5lgCNGdorS6h/LiM8SNU3hOi/n5eQQxjqP4\n", + "8TyXSqOI64aIBNpYrZvooTW17FAoyczMEktLS9i1GqNdXciShCiK9GazBKtVxg699hi/+bLLWDBN\n", + "aoZxbttKsUjjLSZE/6tZphkc7AeewLabyPJa0pZtt3DdFTo6hlhcXKTZbJLNZvn4x+/lW996jH37\n", + "XuL48QlCoQhDQ+tYqOd47NRpwrbN+LFJCq4G3Tv5/vF5Ojvq3PbJT7Lvu9/l1L59+CUJ2RZQZB+u\n", + "6yK1mtgti0zAYYO0xHKwyfGwD12XaBZElho1zpTPoLaqOGjgykiSREAJU7Nz6IqOKEepmkV8Sh+i\n", + "oFF28yheiwBB6oTpD0HW7+egaVFRk9S8MNPTOSxLIJTQMAMS83MOYU0itW4dA0ND1Ot1Du/ZS27B\n", + "oCZAqLedd73rXXzna18jrQboiq+9TTmuw5kjRwiGgryNqv0XlWPH4MiRd24572tx333w+7//zgrC\n", + "PM87F6A8+eTTPPbYfiRp7e23Wp1ieTlHkPMTFsORMIoKC8vT7NvzIqpPQ5abbN4cZ3Bw8Nx+siyT\n", + "SiQopdNrwlG2jSYIeB4ICFiALPiABVooCAp88oMf5J8efRSjUMI66+YrKRqyoBH1XFxJW7OPlxug\n", + "S6yik3IsZqwmOi7JZIKj5TpFIc5gdgil0UBKaUiui22VqNsm3aE0VU+ja3CQoB4holdx6scJRHRO\n", + "jo3RbDYpaxrXfuCX8QQ/MzPPAh59fSnuuuv9b1or6K1w66038Nd//Y/MztYJBhPU62VgmY9+9G5+\n", + "93ff+vl1Xefuu6/nwQefZG7OZHV1lVxuDttewvPS6Hqez33uN86V9v40fD4fH/v0p+lbt44v/vn/\n", + "RhQCjGzaRrlcZ2pqhVBIBkL09W3hpeUF9uUX6QkHcRGoqiE2b7uBxaPfJ1c1cOmgXl7EatpIrohi\n", + "B1iwSkSFNddmEwNVCGFKIj4bRAEaNMgoCqueR9h1KYVC6KrO0YpKtnMzkXSW6uwsXUqUTLTB7aNZ\n", + "8o5Dxbb54z/6Iw48M0az7jKuhBjsGcFyLGzXwgm10RDs8z7rsakp0tnsK8RBk8EgS7PnB5A/STab\n", + "5ZYPf5j//xvfQMnncTwPNZnklz/wgbd0j11Kb5pPAB89++v/63neBV3F37p1K+vXp5md3YsgxAEB\n", + "UayQTvtYWVnhi1/8OqKoIooN3vWuXbzvfbczMbHAHXf8KtHo2o3cahlMTT3DyeIS7dd8mMuyveh6\n", + "EM/zmJraw8bNm6ksLCCbJrUTJ+gWBIxqg0qtznytSk6A0VKAsf1HEMwmctVgT6NKob6KRI12ycUv\n", + "RFn2DAyrguwJLDgqrhal2bTwZBfT9VDxk/D5MZwqcbdFTHCYlZIMbWvHKrcY8YK0X/te5ucnOH58\n", + "hUKhyi/90i4CgW5++MNFrrzmKrq7+5BlmUgkwrYrdlAsetzzG/fR1tbG0aNH6VBVlnwmlm2iyCqS\n", + "KBFTVcaP7uN9H9h+IbvqgvEXfwGf+hRcggKeS8pNN8FHPgKTk9Dff6lb87Oxdes6jh59jlgscy74\n", + "sCwTQSjS19fH3Nwcjz12kK6u3UiSfPbv/Rw+/EWago+4oRPS19wC86VlFNWkM+pgzz9J03WJtsfY\n", + "vv23ztMemp6e5sTJaYpFA8MUWXVEgoCDQQuROQQUSUYVPFSfy46+Pvy6zs5t29izWsItLqN4YQRb\n", + "wfJa5CWXulWkUzIZUVXaMx0cyi1wurSCjkssm+Sg52EmYwz7RhGQ8XSd9UNDVOt1Tk02Wa0u48kp\n", + "9HgcuVQiUK/jlmYJ1aZp87Ks272bTDZLo9XiSD7PJz7/eSzLQhCE1/R5mZ+f59jhw7QMg4HRUYaG\n", + "ht6SnPerkUwm+cxnPsKhQ4eZnl4ik8mybdvr5yT8rGzbthXLMvnjP/7fDA93c+21W0gm23Bdl2Lx\n", + "6M/8gAwEAgwMDbFt5xb27j3Fiy9+l/n5eYLBLO3tG1lYOIGqTpFt20SxaGB1D2PbBu7cXvLHX6Be\n", + "XuaJFxq4jCDLYVpKFctoYjlrZnhNsYghiLiegeq1aHpNZKGJKjbJSiZeKERvOMxyocBkPM6Oa65h\n", + "2PLT1X0l42MnmTtxnJpTIK2u8NTJHNuuuIKVqSlqp0/TbfnwSR3kygX2H3oGIdaNqgXpH76MfMCg\n", + "VljEreTI9MUIdnXRb5qv+Pxlw6D9pyiqjo6OMvj5z7O0tPS2JURfypmRRz3P+1/CmmPRi8AFDUaC\n", + "wSCf+tR9PPDA41SrApKkoGl+FhdPoKpXU6/XmZ2dBjwmJx/k5psvQ9O6zgUiAJqmYxgBTFOnr2/j\n", + "ue2CIBCL9XLo0EluuOsu8gsLLC8tYRSLuFaTBaPKjCTSFYqTcmHl9CQrgsRQxxChlonjjxNuFmlX\n", + "MxRsky5bouyWcAUZPwpN28JwDDZlk5xZqFE2GriuREt0kRSJGhJdPRHWDQ2yON3ARSSRSDI0tJGe\n", + "nqMcOLCHqakfEA4H6Ozs4Omnf0Ak0smOHVuIx0Pkcke57753n7N+bjWbBBSFazb38IP9x9HVDjTF\n", + "R7m2jKcYXHfdZy5kV10QikV44AE4fvxSt+Tioyhrs0EPPAD//t9f6tb8bKxfv56tW09y6NBL6HoW\n", + "x7Gw7WXuvHM3sViMvXsPoKqZc4EIrC3jbNq0m/n5MU4X51ELIo5Vo9SYZNtQNx+++WYM00SVZUzb\n", + "5smHHmJkZARN06hWq3z5yw/ROXILS6fnwecw1Vqkho0CFAQbCz+K2CTb0UM65K4JFZomiqpypC7i\n", + "ihohDxRJY8FzKJh5BgTQXY+juVkqjkl/KErBtQlv28Bd77mdyRdeYDCZ5FtPTlMteMwtl3iqepK2\n", + "dIy+vm7C5SKOpKL7ddx8gVPVAvX6QXb1ZeiJRDg1NkZ7RwfRUIhgocDk5OTrWje88PzzvPyd79Cm\n", + "aWiyzFN79nBwZIT3fehDb3tyeigU4uqrr+Lqq9/W057HykqBTZtuIJvtPW97pZJmfPwk6bP6Km+E\n", + "2dlZvvKVR0mnr+Z977uNEyf28sADD6Lr28hkRpBlHxMTM+h6DEmaxTCSrJx+nkR9mZAXYNe2LTy+\n", + "/wjLS2fo7bmMnKLQqJbwATY1pt0GBSQk0UdalvCLJlqriAaYop+phoffdXD8EX79c5/jU5/5DDDO\n", + "AD4AACAASURBVLlcjv/xF/+TyuKztEWL7MgG0ZVBBGDi1Cnq8/N0uiK+dJalskFbOEWtOM9kYZpg\n", + "uo5SW0exoaDG/Wy+cRcf+tC9dHZ28nd//ucsrq7SdjY4LFQq5IBbt/30ZS1FUeh6A8Z6b5RLaZQ3\n", + "ffZHB7Bfb9+3i8su20ZnZwdHjx6n0Wji88k88ojA6dMnqVaDhELrcV2H2dnjfPWrD7N79/tfcQ5R\n", + "VGm1XtlcSZKwLIsNGzcS/jf/hicefZS9zz3HgeefRwsmCRUKXBcMI9gOAUEjJcJ07gym45Lwp0nj\n", + "ogk1fDJMenUyePjdFnO1OeYFkWu3bCLeJmEToTq9zEqrDoJI0/ORjSts6PUT9fs50SzQimdJJNoQ\n", + "RYnBwS2EQjHGxh5l06a7iESSzMyc4MiRQzzxxNe4+ebtfOhDt7Nx448Hro7OTvZ4Hld0dxMNBhib\n", + "WqBaX6E9Y3D7r3/0bX2ruVj87d/CHXfAG/D2e0dy333wm7/5ixeMSJLE+99/Dzt2THLq1BSqqrB+\n", + "/XXnSnsty0YUXzmMxeNZrrqqnXg8yrFjp0gmI8yeHCfbavHVH7xEzQCwWd+bwBf2Mzs7y+DgIMeO\n", + "Hce2YwyPrOfwoZeYrY7TbAlMt3IEXJOI4MMviOSxSHgFbr7ylxhfWWF/pcLhyQVGrrqXZ595mtLq\n", + "BCFcTLvBRlza8WgKMqOpTqZdh0osTbvu57q7bsMsFrlu3Tqa9TrF1TP4fNvozoaYWF1hueQxufgS\n", + "1+xI42+P8MQj3yOjRulKxWjJKfJLZWKahqgo1Go1IpEIMpwre301isUiL33ve+zq6DjnGdWZSrHv\n", + "xAmOjI2x7bLLLkBPXlhs20UUX6msLQgSlvWzPV5efHE/Pl8PgcBaMma5XCEW66Beb1Cv14jH+6hW\n", + "V5mbO0VHR4x8fg/BxhQbh9bT3taDUa4z2p5hJp9jrllFTHZQrTXAKiN4ZcJigPXBCJNGmVUsKpJK\n", + "WPMhyT5qko6mx4iFUiz6XFbLLTzPI5VK4TVKDGTT7M2XeObENAM+kc6gznQ+j9No0J/oJhmOIVFg\n", + "rjhDxCvTrcl86u5340gqlUaTnG3wyU9+lI6zwkPv+9jH+O6DDzI5M7Nm4BeLcfdHP0o8Hn/LffKz\n", + "8vOQM/Ip4KGLdbF0On0uSj569Cirq09TrerE4z9eM85kNjMzM8Hy8mna2s63RFZVk0RCwrYtZPnH\n", + "bxCFwizXXLOmXNfV1cWv/vqvc+udd/K/vvAFpg6eodww8FwP76xssIJLxHGYAkKijiMo6JJKQJdI\n", + "1loYjkldEIjLPtKeRWVuhuHuTq65extf+s4TTC42UMO9hMM6ZmORhVKN8VKRKVpcs+u2876YMzNj\n", + "BIM/nuXp6VlHd/cICwsTbNsWPC8QgTWBsq5t29izdy/9iQQ71/Uxu7qK29bG7rdBAO1iY9triatf\n", + "//qlbsml46qr1sTexsbgDQgs/lwhiiKDg4Pn5XX8iJGRAZ555hE8r+fcNLHneTSbS1x++e309fVx\n", + "0003AvBHv/d7PL53llR0lEwsgOM6HJ2aQVAmuNnzAKhU6kiSjiAIbNy8i4UlmVCii3p9Ca/0DJ5t\n", + "4Xo1Losl6Mvq7DlyhN/6r/+VXVdcwT/8w9dZWAhw8nSBVWWA4vJjDODgkxWano3qubSqJbqTbSxW\n", + "VgmkgmzdupUffvObRLu72Tt+mh19Q5zMzVJ3VFStQqW5TNyv0ReJsLQ4RyqgceuGrfg1nTO5AI25\n", + "UywurKJ3JFFkGdtxKLKW2PlaTE9PE/W8c4HIj+iOxTh+4MAvZDAyOjrASy/9AM/rPHcfuK6Laa4w\n", + "PPyzjVlLS6sEgz8e9xuNJp2d6zl9+gjFog9V7SYWa6fVmmL37gjHj8RZ33kdnYk1y4wgUZxci03t\n", + "JebkVepNlYhWIaGU6HfjBMQmIRxEReOML0ikvZczxXnMUIakFiao+WmGQuy8/CYajQqLi4uYpskL\n", + "+2bpDw8TUhZJCx5yy8aUDHpEkVOWRU1WkVZmoWUQaNVwadH0JHRJYnh4rdx2fHaW2ZmZc8FINpvl\n", + "Y5/5DKurq7iuSzKZvGQuzhc8GBEEIQM88C82L3qed78gCLuAW4H3vNqxX/jCF879fP3113P99de/\n", + "rW1Lp9Osrs6jaTvP295oVOjs3EAk0mJq6gCp1NqNmc9Ps359jIGBzTz++Mvoegeq6qNcXqCvT2Pr\n", + "1i3nnSccDiMGg1h2nVQkQa5aIuA5mDjUHAdb9xH0BbDcJsuAKloEZYgJLp7oYes+0pEwqmUyKUmc\n", + "Ghujq7OTgc6tjPRmaAQ1+gYHzi43zdC3I8zwDRpHj84gihKSJJPLTROJmMjyELVajUqlgqIoJBIJ\n", + "gsHoq5ZHCoLAHffcw9jgIGMvv4xlmozcdhuXbd9+wRUbLwTf/CZ0d8NFlFj4uUMU12ZHvvpV+C//\n", + "5VK35u2jr6+P7du72LfvZYLBtQG2Wp1j586eV/iQ1ByFph3Dr6351EiiRDTUwdjiwjnzzK6uNkzz\n", + "JNBPb+86kskXWVhYguYyw7FOAoqHqji4do14VyeJZJJQOIwkSWzduo7jx19gZKSPZ5aeJ6xGUQWQ\n", + "XANHaBFWQBFauG4ZNRhn841Xs3nzZg698AKrlQqNRpN4KMa1iXaWSjnyRya4adPNgMVQjx8OnmBB\n", + "DzA+d4pt/Ztoj2UZKywzvjzBup4sJcPgyOnTZLZswTCM85J8f5LXWtv3PO81fbt+3hkcHGTLliMc\n", + "OrSHUKgDz/Oo1ebYvXvgdQOzV6OnJ8uBA/lzMyPpdIpq1aCnp5+2NhfHmaCzM8rAwBY2b+6j2ezA\n", + "mDp83jl8vgjtmTjBdAeVikm95hD1ElBZwLUbIPmpOy3Qw+zoa6ctoiGP3kx79wiu6xCLZfA8gWPH\n", + "nuXo0aPMzKzQ07+b3OlTtGsKbdlOKrUa87VZktkMKVHi+Mo0WwMRkj4/hZbBkiDQ7fczf+YMw8PD\n", + "ALiv0seCILwtrrtvlQsejHietwy8wnlHEIQO4E+Auzzv7GvJv+Ang5ELQSqVYsOGbp55ZgJFCaIo\n", + "KtVqEUGo0NWV4p57duA4Hvv2HcV1PW6/fZQdO7ajaRoDA30cPHiURqPJ+vU7GR0dfYW0ua7rXHXr\n", + "rZw+dITVfJ71yQ4KtSKL1Qp1SUUKp+nr2Myxif2YgOdT8dcWsF2DZDjA5q4ufJLE/MICuC5xQWB8\n", + "YhIYYalSwLRkCvsaAChKk97ePn77tz/F/v0HePnlMWzb5eabh0mnL+c//scvcfjwMqADFoEAdHX5\n", + "2b371V+T1wbXrWzduvWC9sHF4E//FD7/+UvdikvPRz4Ct94Kf/iH8Av6zHkFoijy3vfeyaZNpzh0\n", + "aC0haMuWmxgaGnrFQ9enR9AzOjOreUKqiuk4VD2P/vU7aJ7VTRgcHKS7+yVmZo6QyQxw881388//\n", + "/DeUKzOEgim6sp2Ioksmo7J79+Ucm5k5tySyYcMGNm06Sa02RVgvEjU8amad/kgQSYtgegaSqrAi\n", + "Qt+Vu/nQJz6BoihcedNNPPr3f48e8rFaKDG3NM/+6UWqdoITM2cI6DUigavx6Rqb2gfYm5/ncGGJ\n", + "kCggxzPMihaX7djB42fmMcU4tWmFib/6Nr29Ie6//73nmQTCWgD3hCjSNE18Z8csz/OYLha58rbb\n", + "LnSXXRAkSeLee9/Dli0nGRs7gSiKbNnyLgYHB3/mxMrduy9n376vUij4icUydHUNcPDgA8RiXVx1\n", + "1c3Ytsni4km2bOkim01x8qTFfCDKYjlPJhRHEASWy3n8w3184jd/nUcffZKnZg4QFXW8RB/G3CkK\n", + "Tgsr7OOGK7Zx45VXsOfAYV6cO8nWHTcBMDk5xaFDJ6lWTxIM6hw69CKXX34PK4vz2HMGBHX8AT9N\n", + "IcHWK7exd2KWH/xwHzOWgiJVkUSLtD/Exp4O3EYDwzAQZZlVz6P/Ero0vx7Ca8QBF/7CgvBXrAUp\n", + "C2c33eZ5XvMn/v5aMcrbyszMDP/hP3yRcjmO4wi0tSXp7EwC0/zO73z8FV/kf0mz2eT48XEWF1dI\n", + "JmNs2LD+vGNc1+XZp57iT//T72NNTRNVNbr6+2iIAsfKTWJtvQwOdTKyro9isc7hZ55Am5qkp9U6\n", + "p3J3YnWVacPAVRRivb2cbsSpE6ar65pzLpVLSydpa1vkL//yjwgGg+e18eWX9/D7v/8lbLuLSKQX\n", + "UZRZXj6JLB/jP//n36Wnp+cNl75dSARB4O3u8xdegA9/GE6efOc8gN8Kl18Of/AHa0HJzwsXot9f\n", + "jb/7uwdYWPBjmlDI5dB8PrLt7RSLY3z2sx88t3xrGAbPPvsCe/YcxXFchoc7OXF8nKkfPEF/IkV/\n", + "fweDA/0IksQLs7Pc99nPkk6nWVxcpFgsUiqVeOjr32Ll2eeo1Q18zTqjmRQdmRT75ubQtm/nP/3J\n", + "n5w3Thw7epTHH3qIB//xYZbLKZLZHViVJrLYRJVn+PBNg8RVmRf3nCYXzrBx9x3U62VqtSL9/Sod\n", + "HRn27MnT3b225FoqlRgbe4nuboff+I1foaen57yH8oH9+3nqG98gJQgokkSu1aJ961buet/7Ltrs\n", + "yJvtd+P/svfe0VWdZ6L+s/fpRaeo944khCii2phmwMYN9xYnTtwmmbEn8SRzp2TuFN8pmcnv3jUz\n", + "SWaSiRPixHFwwd0xxsaA6SCKQAj1etR1mk7vZ//+OEAAgY1tIQk4z1qshbZ2eff+tvb3fm8NBGhq\n", + "amZkxEZmZhrV1TPRarUTKlt/fz+bN+/AYrEilwtUVOQhSQKtrRa0WhVLl87j+uuX4Ha7+c///C06\n", + "3Qz6OxsYG+wkGgkhaeP84w//nsrKSuLxOJt+9zv69u8nZHNga28jxWhAzM1l3Q03oFQoaOvp4d1m\n", + "C9Xz70MU1WzffhBRjFBdXUBR0Uy2b38HpxNuu20Nh7b8mhJBhVqlJi45ENMNnOwTsfkETKKI3elC\n", + "EGzMKhLIVMqJBAJULVqEV63m+vXrWXLdxSsXX25OjfkFtcMpU0Y+i8lSRgCOHDnKu+/uIhbTAXG0\n", + "2jCPPLJ+nJn3fJxOJxs2vMLYmBqVykgo5EahcPL44/edyUw5TTAY5FBdHe3HjxOPx5m5YAFz5s5F\n", + "qVQSDofxer2YTCbaWlv55b/8C64DB5ibloYrFmNUFBO/i0S47RvfYO+BBjo7jRQUJJreBQJeQqFh\n", + "KipSePjhhSxevOica//oR78kFMpndHSA7u4uAoEg4UCAuH+Q25YUokhJoWjuXG6/554pLfN+OSal\n", + "Bx+EZcuurhobX4af/Qx27JheRdAmSxnp7u7m+effITNzDjqdkVgsysBAC1VVWr72tU8vPhMMBtm4\n", + "YQP092NSqYhEIlijUWasWMGK1at5+9VXsbW3oxdFPLEYuoICxiwWakwmrGNjdPf2MubxEE1L429+\n", + "+EOysrLGXcPv9/O///f/w+vNZnDQRn9XJ7PzMslKMxAINfGNm6/ng1276RAMlJQvIR4PkJEh5667\n", + "bubXv36b7OylyGRy2traOXmyD1HU4fHUs2hRFcuXV3LXXbefo5DYbDZaW1oIB4MUl5VRXFw8qX2n\n", + "vsi422w2Nmx4Dbdbg1qd+Obq9T6efPLBy7KgCoVCyGSyT015bm5u5rXXPiQS0RKLRZHL/Xz1q3dQ\n", + "VVWFJEn4/X4EQeBkYyPHDxxg3/btVKSns3zePNRKJcFwmCMDAyy+6y66uwd5992PGRsTmTfvOtzO\n", + "AFaLhZh/jKMdLVRUzqaqugRP6yGUPhd6Q5xWtxxDzmLkCiX6QACTXo8v6EEh76a2PJfDo6Pc88gj\n", + "VMycecH3bjJJKiOXQCAQoL+/H5lMRkFBwSVNyhs3vkFHh0R2dgkOxzCdJ/bgGOhErQ3x8FPfYPW6\n", + "dRe1rEiSRCgUYuvmzXQePYpaFAkKAvNWrKCguJh/+uu/pufIEXJSUjAYDAhGI4tuu42v/9Ef8dpr\n", + "b/POO+14vTJAwGhUM3fuTMJhN4sWGcY1hPrBD36CwTAfpTIR73HkwEFioyOEI0PcUJNCSXY2FoeD\n", + "sjVruHHt2i/9LL8oEz0pdXcnLAHd3XCRUgvXHE4nlJQkao5MQcD8BZksZQSgqamZ99//BJcrgiBE\n", + "WbiwknXr1lxSLFR7ezsbfvxjRjs7kclk5M+axRPPPMPhffvwNTYy81SaoyRJNFosRAsLCdhsyAMB\n", + "EASCSiWLV6+moqLighOnzWbjxz9+jfz8RK+Crs4uehqOk6pSMeZtZNWCYqTMTG594AGsVivHDh7E\n", + "NTREJBTiUGMPi1c9gSiq2LbtEGZzCaIow+k8zOrVa7DZWnjiiZu/VIXMieaLjPuvf/0yfX1qsrL+\n", + "sNizWvvJzvby5JNfnWgRL5lQKETfqUJhBQUFqFQqWlpa2LV5M36HA+RyZl9/PStWr8btdvPOK6/g\n", + "HxxEIYr4ZTKWrlvHkuuvB+Cll15nYECL3eZm8MQJUnU6YrE4/dZ2guE+RHNuYuEbsJKiVtDnSeWm\n", + "27+BwWDg6J49pMTjaFRKhux1LFs+h9u+/vVpM+6fpoxMh2yaaYFGo/lcAxYKhWhu7iUvbzkej5Om\n", + "ve9QIlcxK38GVlsbo/v38/roKI9+85vnRCf7fD52bd9O8+HDNJ08SWY8zs3LlpGi1xOJRjm6dSua\n", + "u+/mV6++ytGjR6nbvRuZKLJo2TJqZs9GoVBQUVHCjBlesrMTJkC1Wo0gCPT29pKXN/4eZs4soaFh\n", + "gJycMgKBAI6hQcSAH0v/MQow09vcjNpsxrFjBytXr56yaOqJ5t/+Db71raQicjZmc6JfzcaN8KdX\n", + "XrmYL0119UyqqirxeDyoVKpLDsh2uVxs3riRGwsLSZ89Gykep76xkb987DECPh+1paWkqNXkZ2Qg\n", + "CAJVeXnsHxzkW3/1V4yOjrJ35078ra00bdnCkc2byayo4M4HHjjHvZDomholHA6iVKopLSvFYDTQ\n", + "2XoSSa6h+o47qJ0/H7VazcfvvovOamV2Xh4C4Gru4MjHG8mqWoUo6hFFGaGQB7VaQKczEAzm09DQ\n", + "Mm0mpS+Cz+ejo2OYgoLl52xPT8+ju3sPHo/nogXeLjcqleqcbK+uri4+fPFFatLTMRUWEo5EaN65\n", + "kw+8Xu687z4ef/pphoaGqK+vp+vECXb9/vecPHKEpWvXUllZTHNzA53NvYTsduz9/ciB0UA3t95Q\n", + "TGNPDw9ffz01ZXfgDQT4xe/303rkMItXr2HJjTdi6elhsL+L/DlVPPTMM2RfIfUMro5ZZwqQJInT\n", + "Sn1fdyM5gPlU9LUoyqjIzcXf10dvb++ZYyKRCK/++tc46uqYazRi9vkoCIc5uncv4XAYhVzOrJwc\n", + "Dn3yCYIgsHDhQp7+7nf51rPPMn/BgjMBsjU1szCbgzgc/ahUSuLxGAMD7WRkSFRWVp4vKitWXI9c\n", + "PsLgYAcezxij1kEGeg9zS5GJBRkZLExNRe9y0dTQQDQ6KSVfLjsWC7z+Onzve1MtyfTj8cfhhRem\n", + "WoqpQxRFjEbj58oMO9nYSFo0SrrRCEBbayvujg5mxOMUiiJ5wSD79uxhwGYDQCGXI8RiSJLEYH8/\n", + "3uZmlhcWMr+ggKWFhcQ6O/ng7XMrGiiVStasWURfXz1+vwcAtVpORo6Mv/6777Fs+XJ0Oh1dXV1E\n", + "hoaYkZeHTBQRRZEV1y3AEBihu+MQ0WgQj2cYr7eZOXNqr5rFxZXEgR07KDcYMJ2K31MqFMwpKqKr\n", + "vh6Hw5FYPHZ30717NzUqFauLisgPBvnwN79BoZCTlRWntaUOud9NplJALtm5LltkpLMTldtN/imz\n", + "pl6jYWFFNlFPH53treh0OnLyMimvMvFnf/70FaOIQFIZ+cKo1WoqK/OxWi34naOknEoX9PndmExq\n", + "NFotKYJwTupsR0cH0YEBqgoKiMZiaGQyskwmFIEAAwMDQOLlCnm9n6oUaDQannrqK1RXqxgY2M3Q\n", + "0F7mzdPzxBMPnUlRPJu0tDSefvprLFpkIh5vw+msY0F2hMqzunimKhTIo1E8Hs9EPaIp5V//Ff7o\n", + "j+AKrM922VmzBux2OHRoqiW5cnCMjBD1++nv72d4eBhLaytFaWlk6PVEJAmtXE65RkNDU1Nif7cb\n", + "fXo6Go2GI7t2UZ2bi+yUUiAIApV5efSdPMnY2Ng511m69DoefHApkUgzvb07EIROvva1tcydO+fM\n", + "PnabjZTzFIyMjAxuWrGQvIwwsdhR0tK8rFy5nJycklNprgPU1FRc5qd0edHpdJSUZGKzDZyz3W4f\n", + "pKgofcqsIhdipL//jOJ6GkEQ0J+aE8LhMAc//pja/HwMp1z5aQYDs9LTqduxgzvuWE1Zhget2IUo\n", + "dFFidlFo1KIVRSIezzlJCktnV7FsjgGn7QAWyw5SUkZ48sk7KSoqmtR7/rIk3TRfgttuW8Mvf/kK\n", + "voiPUecoYbUGudxPbe2CxIpobIxCr5dIJIJCoWBkcBDzKetGilZLCIjEYuhVKlx2O5SU4PR4MGZk\n", + "MDo6Sv3BgzitVvJKS6lduBCz2Xzm2ikpKdx//53ce28c4DMj4M1mMyk6FSkhO3NS5HhHR/lwbIx5\n", + "ZWXo5XLs4TAVM2bg9/uvyAqrZ9PaCps2XZul3y8FmQyeeQZ+9CN46aWplubSkCTpTPGn7Ozsy1Lv\n", + "JhaL0dTURNORI8RiMarmzWP2nDlngs9tBw4w02RizO/HZrdTYjTiisWYOWcO/RYL6SoVVquVfquV\n", + "br+f2x97jHg8TsjvR3teHQdBEFDLZAQCAfR6PTKZDEEQEASBBQvmM39+LdFo9IKxayazGW88Pv4Z\n", + "KRTc9/D9iEoN27Y1EAz6GB7uIRAYZsGC/CvaRXOa9etvYsOGTVgsTjQaM4HAGFqthzvvnF7dL9Oy\n", + "s3G6XGSYTGe2SZKELx7HaDQyNjaGMhpFrVQiSVKi/ocoYk5JwWuxEAqFWLV4AT1HjjA82E+KR06f\n", + "dZRWvx9Bo0F+1nshE0Wy01P543vvZtnKlZ8rCSEajdLY2EhLfT0AVbW11NTUTHiPokshqYx8CdLS\n", + "0vj2tx9n586dvPvCbyjM0jFzxjy8Xi+vvfEGVlFE/+GHNOzZw83334/BZKLnlMVDpVAwo7KSkydP\n", + "YpIksnU6HG43TXY7ZUuXsumnP6VApSJHp2N4925+e+AAD3/rW0iSxNatu2hu7kGplHPddXNYtWrZ\n", + "ZyojnZ2dHP/wQ5YWFqKeM4fY8DBjTif7OjtZsXgxsysqaA2Hp0Xxmy/Ld78L3/8+TINs5WnLU08l\n", + "muYNDcGpyurTFqvVyjsvv0xodBSFIOCXy1l2660sXLz4sw++RCRJ4r0332ToyBGKzGZkosiR11+n\n", + "paEBuVxOuUxGPDeXaDBISVoaDouFA+3t6EtLWTRnDu6iIhpPnMAZiRAuLOTelSvPZNRl5ucz6nSS\n", + "edZiIhgO0+9ysWnT+4yOjqHXq1mxYgHXXbcEURQRBOGik0pZWRm70tPpGR6mKCvRQNDmcjEsSaxZ\n", + "tIj09HQqKso4ebKVaDTKzJm3UFJSclW4azIzM/nOdx7jxImTDA/byM6eSU1N9bhyBlPNklWr2PLC\n", + "C2hUKvQaDbF4nOb+fvKqq0lPT8fn8+GJRNjd0ERTr41YLE5prpm5ZfkoNBpyc3OxuFz0DwxQEg4j\n", + "+P0ICgVLcnPZHwpR19zMvPJy5DIZ/VYrDpWKOxYt+lyKSDwe561XX8Vx4gSFp97Ng6+8QntNDfd+\n", + "5SuTXgAvmU0zQXR2drLtnXdwDw9z9OBBZuTmsvq669BrNLh9Po47ndz71FO8/eKLzFAoyDSbkSSJ\n", + "uqYm9pw8ycy5c8kpKuK61av55N13ma3ToT+r26RlZARXVhZ9I0GggIyMfGKxCIODbZSXK3nssa98\n", + "alreW6++itjRQX5GBg6Hg6O7dpGpVDIQDJJVU0NIJmPubbexfOXKSXhaF2Yisipefx3+9m+hoeHa\n", + "6877efmTP0kobP/4j1Mrx6eNezQa5Zc/+hG5oRB5pxTl06mQtz/1FGUTVMCpp6eH959/niXn1ePY\n", + "09rKqM/H3fPm4Q+FONrUxEB/PwP9/TgiEf7iiScwGwxEolGOWCxcd//9LDiv1G93dzfv/PKXlOv1\n", + "ZJrNuH0+9rS10R1IYVbNWkymDIJBH4ODJ1m1aga33PLZGW1Op5Mt77zDSEcHIqBNT+eme+65okzz\n", + "k5lFNRUcq69nzwcfIAUCRAWBGbW1rL31VtRqNfF4nGef+V/0NIwxs6AKmSjH7hllxH2SZ77/DAsW\n", + "LeKbDz2EqbOT2tRUlDIZDr+f3nCYitWriRcWIobDxKJRimfOZMVNN32uZoCQyA7b+qtfsfislG5J\n", + "kqjr6eGmJ564LJa0ZDbNJFBWVkbpd7/Lto8/JgVYeFZktUGnI8vppKu9nfsef5zNmzbR1deHIEmQ\n", + "m8s/fec7FBYWolAoGBoaQhYIoD/PQpGfkcHmHbvJLr+FgoLTaW1KcnNn0tFxGIvF8qkfoqDPR+qp\n", + "2Tk1NZX5K1bQ1drKcEcHgXichx59lNlz5lz0+CuBgYGE++Hdd5OKyKXw3e8metZ873twljV5WtHT\n", + "04PgcJB31rutViopSUmh/sCBiVNGurpIVyjGKfRpajUdvb2Iooheo2HFggXEamsJh8O8uH079VYr\n", + "KS4XQVFk/i23MH/BgnHnLikp4Z5vfpNdH35IS18f5sxMpOxSqtSzzvSLUqt1FBXNZ+/efdxww5LP\n", + "jH8wm8185bHH8Hg8RKNRTCbTpNYISfLZzKutZfacObhcLtRq9TmZU93d3WhSSiicrabHYkEpioRR\n", + "kZK3EEQ5x44coSo9HXk4jNXvJxwMkmI0UqJWI5MkZs6ezc233048Hv/CLpXu9nayNJpz3htBEMjS\n", + "aOhqa5t0t15SGZlABEFAlCTSLlBbRKdW4xkbIy8vj6eefZbR0VHi8TiZmZnnmMPkcjmRC/iDI7EY\n", + "Y94wVaYs4vE4He3t9HV0EI9ECMTcHFt87FOVkbJZszj57rtngqpSU1MxLVlCKCeH+//08dpH0AAA\n", + "IABJREFUT8nNzZ2AJzB1eL1w113w7LOwZMlUS3NlUFGR6GT8H/8B/+f/TLU0F8bv96O+wCSr12iw\n", + "OhwTdh2VSnXBvzulXI7caGTM6z2TGSETRTyBAEtvvpm7H3kEn89HamoqmrMsmWczMDDAnq1bGbVY\n", + "kMnlFJSV0T5wnNzcczMdZDI5oMPhcFxyMOZ0CtpMMh6ZTHbBDrijo1aUylTK51cRmDmTYDAESJxs\n", + "OMqG//oFJmUMMRDApFKx6KwCmjaXiy6Xi5tnzEA8lUn1RVGqVERisXHbI7EYqinoQTZlTkRBEL4u\n", + "CMJOQRAOCILwxFTJMdHkFBTgCIXGbbf5fOSXJBruCYJAVlYWOTk54/xyGRkZGPLz6bdaz9neNjjI\n", + "rHk1+P1uTp44wfDJkxRptVSkppEScXNw82Z6enouKtfsOXOQcnI40dvLmNeLdWyMQz09lC5efMUr\n", + "Ii4X3HknzJ2biBVJcun8/d/Df/0XjI5OtSQXJiMjA1c8Ps6cPzI2RsEFuvh+USqqqrBJEoGz/nbD\n", + "kQjDkQh3PfooJ+x2LCMjePx+uoeHafX5uPH22zGZTOTl5V1UEbFarbz+i19gtFpZWVDAdRkZDO7d\n", + "y6ClC6/33EyaRLmAwLSLf0gy8RiNBiQpACSyI3U6LQ2HDhEY7GVJQTY3zZhBittN59gYDaOjjAUC\n", + "uIJBjttsZM6dOyFWi5k1NQxHowTD4TPbQpEIw9EoVbNmfcqRl4epjGjaKEnSSmAp8PQUyjGhzJgx\n", + "A7KyONTcjC8QIBSJ0NLXRywjg5nV1Zd0jvUPPsiQWs2R3l6aens50NODsrycRx97BJernf62ZgrS\n", + "0lDI5Di9VrLTJK4rLGT/9u0XPadGo+ErTz7JjFtvxaJSYU9NZdkjj3DbnXdO1K1PCceOwdKlMGsW\n", + "PP88JC3Vn4+SEnjyyYRFaTqSk5ND4bx51Pf04A0EiMZi9AwPM6pQsHACe2ykpaVx4/33c8hq5YTF\n", + "womeHg4ODbHwtttYtWoVDzz9NGJVFV2iiHr2bL7yzDOXFJ9x+MABcgSBnLQ0BEFAqVAwu6iIHC10\n", + "dh4iEklMBJIkMTDQSlVVLgaDAavVit/vn7D7SzK9KCsrw2gMn0lTHh4aIuayY9B6mFWcT35+Prk5\n", + "OeQoFEjZ2fQqFBzy+UhfuZI/+bM/+9Tg0mg0is1mw+v1fqoMWVlZLLvrLg4ND3Oit5cTvb3UDQ2x\n", + "9M47p6Q+yZQHsAqCoAG2nFJMzt5+RQWwQqJ/xebNW6mra2Kwrw/vSDelZQXcdOd6lq5Y8blMqpFI\n", + "hK6uLnw+H2lpaRQWFiIIAh9++BH/82//TZo2E0mKkmmWsXZBNXqNhr0jI3zvMnc6vpx8noC2kRH4\n", + "4Q8Tqan/9/8mOtImFZEvht+fsCr9y78kevlMNp817tFolLqDBzm2dy9Bv5/S6mqWrV59WTK/PB4P\n", + "XV1dSJJEUVHROen0X4Rf/eQnlESjZ2pJnOZEby/xsgosFifxuIZ4PEB1dQG5uens2nWcSESGIIRZ\n", + "uLCSW25ZO64j+NXA1R7A+llYrVZee+33DA156WzrRD7Wx93L5lJ8ShEIBoPsraujB6iaOZOaxYu5\n", + "ftmyi1rhAI4dO87mzbsJBECSosyZU8Qdd6z71EaCLpfrjFW9uLgY43n1USaSadubRhCEvwf+CPhb\n", + "SZJ+c97vrjhl5OWX36CpyUdeXtWpcswBBgaO8uija5g1QWYvq9XKb//936k2m1HI5Wf82Ha3mwGN\n", + "hsefeWZCrjMVXMrHaWAgUR9jwwZ45BH4m7+Z/qmpVwJHj8K6dfDeezDZTT2v5knprVdfRWhvp+C8\n", + "TIdDvb3c/OST5Obm4nA40Gq1dHV189pre8nPr0WpVBOLRenvb2LBgnTuvXf9FN3B5eNqHvdLRZIk\n", + "bDYbB/bvx3HwIDXnWdsaLRZmrl/P4ksIhOvo6GDDhvfJzp6HRqMnHo8zONhGSYnA448/crlu4XPx\n", + "acrIZXfTCIKQJQjCjvP+vQwgSdI/AmXAU4IgjHOUPvfcc2f+ffLJJ5db1C+F3W6nsbGP/PxqRDFh\n", + "QlOpNKSnV7FjR92EXScjI4P86mpsHg+GU9puMBym1WZj8apVE3ad6UZdXUL5mD0bgkE4fhx+8pOk\n", + "IjJRzJ8PL74I69fDr34FF4jlTPIFWLh0KT1+P55TLhdJkugZGUGelUVRURFqtZrc3FxMJhM7dtSR\n", + "lVV9pqGlTCanoGAW9fWduN3uqbyNJJcJQRDIyMhg5apVuFQqrGdV5B1xOnGp1VRf4kJ2165DGI3l\n", + "aDSJqVQURfLzq+josDM8PHxZ5J9ILns2jSRJI8CN528XBEEpSVIYiABxYJy29NwV5HLweDyIom5c\n", + "ep1eb2ZwsGFCr7X+/vvZ8t577D1xAiUQVSi47p57Jsz6Ml3weOCNN+DnP4fhYfj2t+GnP52+aahX\n", + "OrfeClu3JuqPPPccLF+eaKzndoPNBlZr4p/dDgYDFBQkMpeWL4fVq6dPF+DpREFBATd/9atsf+cd\n", + "BLudiCSRWVbGA/fee47fPxaL4XC4KSo610QuijIEQYPH48FgMEy2+EkmCYPBwL1PPMEHr79Ou8WC\n", + "BOiysrj/vvsuOaB5eNiO0Tg+jkkm0+N2u6d9n5qpTO39viAIqwAV8IokSVd0UxSz2Ywk+YjHY2cs\n", + "IwAul438/KwJvZZGo+GeBx/Ec+ut+P1+zGbzVeVT9njg6acTLoOVK+Gv/iqxYp/kgoDXJPPmwb59\n", + "0NSUcN2MjSW6HqenJwqkZWYmlA6PB7q74cCBRNO9J56Aykq46SZYuzZRv+QCbZKuSapnzaKyqgq7\n", + "3Y5CobhgHIpMJiMnJw23247B8Id2DLFYFPBjSmrgVz35+fk89eyz2Gw2BEEg7VTQ86VSUJBFX5+N\n", + "9PS8M9skSSIadX3p2KfJYMoDWC/GlRgz8s4773PgwCB5eQlTq8fjxGZr5Kmn1k9YcaarmdM+ZElK\n", + "xITcdVeypPuVQjicUEy2bk38O3kykeVUXJywrigUIEmc6XS9YkUiRgWSsQOnaWlp4Te/+ZCMjBr0\n", + "ehPhcJD+/kZWrizl1ltvmmrxJpzkuE8sfX19/M//vIHJNBOjMZ1IJMzAQDNz55p46KF7p1o8YBoH\n", + "sH4agiBMT8GSJEmSJEmSJF+IK7Ic/HRVlKY7wWCQH/1oA7FYwRmTndttx+Np5jvf+dq07co7GSul\n", + "gYEBfvrTTaSnz0WnMyBJEiMjPZhMTp555olJbw6VJLlCvlaZiHGXJIkNGzbS1yeQm1uBIAin+vzU\n", + "89RTt1M+gYXxknx5Ps3tdOW3cUwyjra2Ntxu9Tm+Q4MhDUnKpL5+YoNprzT27z+CWl2ITpcIBhQE\n", + "gezsEkZGYp9awTZJkiTTj+HhYbq7neTlVZ6Z6NRqHWbzDHbtOjTF0iX5PCSVkasQh2MMuXx8BLZW\n", + "a2B01DkFEk0fRkYc6HTji/oIgg6P54qOoU6S5JrD7XYjiuMLeul0RkZG7FMgUZIvSlIZuQrJysog\n", + "GnWN2+7zOSgsnNjMniuN4uIc3G7buO2S5L5gQ6skSZJMX1JTU4nH3ePcPS6XjaKiK7vn1rVGUhm5\n", + "CikvLyc7W0Z/fyuxWJR4PM7ISC9arZu5c+dMtXhTypIlC4BhbLZBJEkiEgljsTRSXm6moKBgqsVL\n", + "kiTJ5yAjI4O5c4vp7T1OOBwEwOkcJRDoZuXKZPvuK4lpnU0zXWW7EvB4PHz88U7q69uIx+NUVRWx\n", + "bt0qMqZxruxkBTIODg7ywQc76O4eRi4XWbSomjVrVqKegrbZSZIBrNcqEzXukUiEnTv3sG9fA+Fw\n", + "jLy8NG69dSXFxcVfXsgkE8oVm9o7XWW7kohGo0iShEKhmGpRPpPJnpTC4TAymSyZQTPFXAvKSDQK\n", + "LS1QVQXyaZ3DOHlM9LjHYjGi0SiqZLW9aUtSGUlyRXAtTEpJxnO1j/vAQKIyrdebaGWwdStkXduh\n", + "W8DVP+5JxjOljfKSJEmS5FolHodHH4UHHwSLJdH/54kn/lCJNkmSJAmmTBkRBGGWIAh7BUHYJQjC\n", + "z6ZKjiRJkiS5XGzalGg0+Hd/l/j5n/8Z2tpg586plStJkunGVFpGWiVJukGSpBWAShCE2imUJUmS\n", + "JEkmFEmCf/3XRAfk02FJCgV8//vwwx9OqWhJkkw7pkwZkSQpetaPGmBsqmRJkiRJkolmzx6IROD2\n", + "28/d/vDDcPAg9PdPjVxJkkxHpjRmRBCEOwVBOAEEJUnqnkpZkiRJkmQiee01eOQROL8dh1YLDzwA\n", + "L744NXIlSTIdmRbZNIIg/Bh4T5KkrWdtk/7hH/7hzD6rVq1i1apVUyBdkskiGV1/bXI1jns8Dvn5\n", + "8MknUFEx/ve7dsGzz0J9/aSLNm24Gsc9yafzadk0U5bxLgiCUpKk8Kkf3YDy/H2ee+65SZUpSZIk\n", + "SSaC/fshPf3CigjA0qUJN43FAoWFkytbkiTTkal009wiCMIngiDsBPKBD6ZQliRJkiSZMDZtgvvv\n", + "v/jv5fJELMm7706eTEmSTGemhZvmQiSLnl17JM221yZX27jH41BUBB99BDNnXny/N9+En/0sUQTt\n", + "WuRqG/ckn02y6FmSJEmSTBIHD4LB8OmKCCSqsh44AD7f5MiVJMl0JqmMXKW4XC7cbvdUi3HNIkkS\n", + "Y2NjeDyeqRYlySTz+uuJbJnPIiUF5s9PBLMmSXI+8Xgcp9OJ7xrRVpMtmyaR0xOUIAiYTKbLco2R\n", + "kRE+fPttnH19SJJEamEh6+6+m6xkM4xJw2Kx8NHbb+MfHSUO5MyYwbq77vrUMfd4PEQiEUwmE6KY\n", + "XCNcqUhSQhl5//1L2//mmxPunFtvvbxyJZk+uFwuYrEYZrMZ4fy871O0tray/d13ibhcxASB4tmz\n", + "ufn229HpdJMs7eSRjBmZJAYHB/no7bdxDw4iAab8fG65554JVRK8Xi8v/OhHFAsCuenpAAzYbPQJ\n", + "Ao995zuf+SI7nU5isRhpaWkX/SO5nFwNPmS73c5LP/4xVXo96UYjkiTRPTxMv1zOI089RWZm5jnP\n", + "1uVyseWddxhqa0MmCChMJtbedRfl5eVTeBeTy9Uw7qepq4Ovfx2am8fXF7kQhw7BY4/ByZOXXbRp\n", + "x9U07peCw+Fgy9tvM9rZiUwUUaWmsu7eeykqKjpnv76+Pt742c+YnZ6OSa8nFo/TPjhIvKCArz31\n", + "1AW/zZIk4XA4EAThU5WcqSbZtXcSaGpq4sD27TiGh8nIy+P6NWuoOJXX5/F4eOE//5MyhYLs1FQA\n", + "Bm02LJeoJFwqdQcO0Pz731NzXq7gCYuFWXfeyaLFiy94nM1m4403NtPX5wREUlNV3HvvzRQXF0+I\n", + "XJfKlf5xcrlc/PTf/532nTtJNxopKykhKz2dPY1dNPePUVBTw+zZJdx3361kZ2cTi8V44b//G6PT\n", + "SUl2NoIg4PR4ODk2xoNPP01OTs5U39KkcKWP+9n85V+CSgX/9E+Xtn8sBpmZcPx4oi7JtcTVNO4X\n", + "wuFwsHfHDtqOH0eUyxkcHGRRVhalubkIgoDN5aLZ4+Fr3/kO6acWjwBvvvwysq4u8jMyzjnfwd5e\n", + "1v/xH1NQUHDO9v7+ft54YwtWqx9JksjLM3LvvbeQnZ09Kff5eUgGsF5mjh4+zMcvvkh+MMiqggKy\n", + "vV4+eOEFmk4tdxpPnMAUCp1RRABy09PR+Xw0NzVd8nWCwSBNTU0cO3aM0dHRcb+3j45i0mjGbTeq\n", + "VDgusD9AKBTihRc2YbMZKSxcRmHhUuLxYl544R3sdvsly3at4/f72fiLX+A/doxlZjO1Gg3DJ0/y\n", + "401bCYYKyDHWYDLOxuPJZMOGTfh8Prq7u4mNjFCak3NmJWNOSSFPoaC+ru6C14nFYnR0dFBfX4/F\n", + "YrmqP+ZXGpL02Sm95yOTwdq1125GzdWKx+Ph5eefJ9DYyLKcHNICAex1dbQdPYrDbkeSJNKNRnJE\n", + "keNHjpxzrG14GJNeP+6cWkEYFwfocrnYsOENQqF8CgtvoKhoGS5XOi+88AZ+v/+y3uNEk4wZ+ZJE\n", + "o1H2ffQR83Jz0anVAKQbjcyWy9m1ZQszq6txjIxgvICSkKJU4rBaL+k6vb29vPjiOwSDWkAB7OT6\n", + "6yu5/fZ1Zyay9OxsTtbVcf4CaywUougiq+y2tjbGxhQUFf3hKIMhDY8ni/r6BtauvfGS5LvWaWxo\n", + "QDM2xszSUlzt7Zh0OuSCjIhXRywuIyhF0Ol1pKZmYbFYaWpqRiYT0V7gXGa9nsHh4XHbnU4nL774\n", + "OqOjcRLtnDyUl5v5ylfuRX3q3UsydRw9mmiEN2fO5zvudNzI449fHrmSTD7Hjh7F6PNRVlCAx+/n\n", + "w4PHibuhzWXH6amjqCiNRYtqMel02M/7W8/Kz8fR0oL+vDnDK0nj4s4aGhqJxdIxmf5gRUlLy8Fi\n", + "sdHc3MKCBfMv301OMEnLyJfE7XZDIHBGETmNUacjNDaGz+cjMy8PZyAw7lhXKETmJZjiQ6EQv/3t\n", + "O2i11RQV1VJUVENBwfXs2dPJybOczbNqavClpGAZGUGSJOx2O5u37WT7iTa6uvuwWq3jVtJOpwu5\n", + "PGXcNbVaI8PDScvIpdLf1UWGXk9BYSFeUcTt9+MKRtHLNfRbrYgGA+np6fh8Pnp6RnnhhdfYvfsg\n", + "/WPj+0Pa3G4yL2Czf/PNzbjdqRQVLaSoaBZFRdfR2Rlh+/ZkOsZ04LRV5PO662+6CT7+OFGfJMmV\n", + "w8WskpIkUbd7N71tXXyyYx8bN+8gEssBdRomjRmNJgurNU5razs2j2fc3/qiG26gNxTC5nIBEI3F\n", + "aOrrI7W8nNzc3HP2HR11oFaP/34rlSnYbM4JutPJIWkZuQinJ/NYLEZGRsZFMxw0Gg0REi+M/HSf\n", + "cCAUiSDJ5ahUKqpnzaJuxw46+vsJO50M9PZi9XqJl5Rw53n+vwvR1dWFxeKFSAvxWIyMvDy0Wi3B\n", + "oJYPPtjBrFmzEAQBrVbLQ08+ydbf/563Dhyg4UQnKVkzqV60mj17+vnNb/6CkpICioryWLVqMfPn\n", + "15KZmU40Ot5V5PXaKSws/qKPb8qJRCKcaGig5dgxZDIZ1QsWUF1djeysMZooPB4P7R0dtGzbhkIm\n", + "wy+B3eZn1DGG1e+jpriSBddfj8/nY9euwzidIyxZUoXbnc7Rrk9Qhg+zbH4twUCAYYeDIVFk9Xnx\n", + "PU6nk+5uGwUFN5yzPSengoMH97Nu3ZrLcm9JLo3TWTSvvfb5jy0sTJSOr6+HBQsmXrYkX5xIJILd\n", + "bketVp+xSjQ2NvL66x/Q3z9CYWEO9913C7NmzTpzzNat2zlUbyHbLWDUamjq7CfNkI2k1BJ3OzHJ\n", + "RAwpmdQ3NVK6YjG3nxr0xsZGDu7YgdNqRa7VctTjQeNyIYkiFQsWsHrdunGBqfn5WdTXNwF552wP\n", + "hcZISyvi8KFDtB0/jlyppGbhQqqqqqZttl5SGbkAIyMjvP76ZoaGPAiCDINB5L771lFaWjpuX41G\n", + "Q+WiRTQfPMisggJEUSQej3O4owNdZSUtLS2UlJRw3ze+wT/95V9ib2lBlMnIyMykXK/n7Y0befRb\n", + "30KlUl1QFkmS2LZlC32NLZRnVxKNxdh+uIGgzEB6ZhZNTa2Yzb9j+fJFDPT2IogiN6xeTVuvg+Wl\n", + "92AypWO19tPa2ockzcbpVFNSUsmmTfvxeLwsW7aU7Oy99Pe3kZNTiijKsFr7UaudzJt35+V+1JeF\n", + "aDTKppdewtfWRmFqKrF4nD2/+x1dCxdy5333TWikeSAQYMNPfkLL7t20tXQiSBqsITNxTQ5l+XNx\n", + "Wbuw9A/RcKwejy+C1+snO1tLSUkNCoWSG9Y8Rd2+33D43c343CGUxlQq5tXgcDjIOCuALRwOIwiK\n", + "cbLL5Qqi0TjxeDypjEwhR46AKEJt7Rc7/rSrJqmMTB8OHTrCK6+8h9sdBqIUFKSSmprC66/vRyab\n", + "gUpVTHe3jQMHfsw//MMTLFmyBIfDwc6dJ5i7cD2tu95Cj4BWayIaUaFOyWM0VYMsFkIcsxJUa/ne\n", + "Y49hMpmoO3iQXS+/jCkaJQOIKRTEFApWPfIIM2fOvOj8UFMzi08+OcTISA8ZGYWAxPBwNyZTiIa6\n", + "OuL9/RSYzURjMXa8+CJd113HHXffPZmP8ZKZykZ5S4B/B+LAIUmSvjdVspxNMBjk179+nXi8iMLC\n", + "hPPX43Hym9+8x7e//dVzop5Ps2bdOraEQuw9dgytKNJo6WfEryIj4qO+4QNSU0Vqa0sRAhGU5ipE\n", + "wYzNE6DvQAvmxkbiKhUGYyr7dh3AP2ajsqqMm9avZ+68efT39+OzWMgxgkIG9S3H8TucxAU5dnGM\n", + "VTcuYdvWNg5ueZ+baiqRJIkD771Hl13ihhUrAWhqakCjKUerTcNub0Op1FJQMJ8dOw6yZMkiHnvs\n", + "QbZu/YRjx/YSj0tUVORzyy0PYTAYJvXZTxQtLS1429tZUFJyZlumycSBo0exLFo0LpXuy/C7l17i\n", + "5z9/C6/bTCy+CJe/h1RljJSIgoY+F2V5+cRCY9Tt/B0utxtTTiHl5Wvx+z3Y7YMM9DTS3GKhdtEd\n", + "LFm3BJu1n97mg3z7sWeonFlIXk4OReXlLF6xAq02jt/vQav9g1nWbh+krCwPhUIxYfeU5PPzyivw\n", + "0EOf30VzmltugR/8AL7//YmVK8kX48SJE/z93/+EWCybQCDM8HAX0agKv38MnS6dkhIRmUxJKKRi\n", + "eFjJP//zT9i0aS4DAwMIgom0tFyKFt1MR/0OXBE7sbgRMSiy9ta70Om0hMNBiopiFBUVEQ6H+f3G\n", + "jYwcPIjbZiPk8yETRQzp6QTlcub94Afj5PP7/TQ2NNDX2Ul5cToj9jEGBnoAgdmzS8nJrqHlgw+Y\n", + "f/438NAhBhYtIi8vb9w5p5qptIz0ADdKkhQWBOElQRBqJElqnEJ5gERAp9utoajoD7EcKSlm3O5E\n", + "QOdNN60ed4xKpeKuBx7AuXYtzc3NHH1xC1FvlO7uMSRJTne3ix3bPsaMkdkl8/B6PQwOdCOLp9E9\n", + "2kTTf/wMTzibWUWVpGizqd/ZgrWji4H778VgMlGo16MsjfPWR2+jcASZqcnBH3Ljsg4x0pdKzKNA\n", + "UsgozMxEIZeTaTBw6PAHOGePYjSm4XSOkZo6i1gshkwmIJOJiKKceFyNw+EgLy+Pe+9dz/r1EeLx\n", + "OCqV6orO0uhsbib7vGh0QRDIUCjo6eqaMGXE7Xbz0/9+FYW4AJNGhyBTEheK8IXb0cpcaOQFmNRG\n", + "SopnsKvhfQpNM/CHUmlv97D1o39GHQetqMfq8NOhOIJtoIs8MUBWXCQ2GiDiO4azxE6JXM577e3M\n", + "XbaMvXuPoVYXotMZcbttiOIIt976ALFYjGAwiFqtTlpIJpl4HF59FbZs+eLnuPFGePhhsNshLW3i\n", + "ZEvyxfif//ktfn8eWVlVDA3twWhci883xujoEXJyFtHefhiVagSdrhSFopRjx7bw85//mjVrliFJ\n", + "EQDy8meQlV1M1oxj7NixDX8oSl3dccJhH0qlndtuexaA0dFR9m3dSkUgQGkggFomwylJ9AwPs/3N\n", + "N1n/8MPMOSsq2uVysfEXv0AzNkaGXo8vFCISiXDf/fcza9YsFAoFr7/0ErlG4zn3JIoiqaKIpbc3\n", + "qYycjSRJI2f9GAGiUyXL2SQCOhN1P4JBHz09rQwPDxONBklJyb6gMnIas9nMyIidri4bWu0czOZM\n", + "ANzuMdo69pNv0FJVEGHIYsGsUiGXaem264nH45SozBCXkWbIwOoc5f1dTexp/AlzFs1BO9JF2GEn\n", + "LzBEAAUyHKRqZBRlV9DX04IhtRIQicZiKORyDCkpVKQbaGupY8n1d6BWqwiHfXi9LsrKchFFEUmS\n", + "iMeD59Q4USgUtLS0sH/bNqyDg6RlZ3P9mjVUV1df1mc+0ag0GnzR8a9T5JSidTF8Ph/t7e0E/H5y\n", + "8/IoLCy8qEtHkiQ2bdrEqFWOJiIixEOo1Qpi8QhyWTGjnn0U5FQQjUm0WPrQKNOpyqumsa2PlpOH\n", + "CHpMmFVKDAYtRl0eHo8La8/7iJlZdPn8ZGpNpGt0mGMxnGNj1BQW0tXayp/8yQMcOHCUwcEeCgvl\n", + "zJmzlI6OzlOpfFG0Wjlr1ixm8eJF07bw0dXGvn1gMsFZYQOfG7UaVq+GzZvh0UcnTrZrDY/Hw6FD\n", + "R2hp6SUlRct1181jxowZl3x8MBhk8+aP2Lx5HxrN9Vite4hGdWi1atRqE7GYiN/vIRg0IpdLSJIS\n", + "iKFWp9DTEyYQCKDRBPB4nKSkmJHLFeTklBKL/Z709BkoFDrKyyvIzU1jy5YDzJw5k23bthEaHEQf\n", + "j6OSy1FrtRQplQT8foZ8PvZ8+CGzZ89GEAT8fj///R//Qecnn2DW6yksLGRuZSVZwK733jvzrVZp\n", + "NIQjkXH3F5UkFEolAwMDeL1e0tPTSZsm2u+Ux4wIgjAHyJAkqWWqZQHIzs4kEmkmGPSxa9eHBAJG\n", + "tNpC7HYL9fX9fPLJLlatWnHR43t6LITDOjIzM5EkGBzow2uzIUa1DNtdnKivRwHIU1MJRaPYw5Cn\n", + "M5BlMNBpHaapdz9uqxOloMYXirProw48Y82UqtzMlMuJht2EQlr8Kj3Dg0P0e+1Eh50srDq3ampV\n", + "1QyCfi+9vYcwGBS0tu6ivHwuVVUzkCSJgYFWamoKzkkVazh+nB0vv8zM9HRmFxbi9Hj4+MUXCT34\n", + "ILXzr5wUseo5c3hr717yolEU8sQrHgiFsAG3VVVd8Jienh7effFFDOEwCuBIPE727Nnc/cADyOVy\n", + "QqEQTqcTnU5HSkoK27Z9wvvvH0AQjQQFFRG/G7fPgyCIBCMQIUQ4EsCk03C4tZFso4nu/j6GHO04\n", + "QyE0zMAT9KMVPAj6bILuMJqIQGVUwhONMuLoY1SbSoUmm66RERbNmoXfYsFsNlNTU0Fzcw+jo2p2\n", + "7nydrq5RVqy4laKiUoJBH2+9lahRsmTJhYvctbW1Ub9/Pz63m+KqKhYsXozxvFULAokLAAAgAElE\n", + "QVRUkkvn5ZcTLpovy/r18N57SWXki+JyuXj++Y14PAZMpnxcrgAbNnzAbbeNsGLFss88XpIkXnnl\n", + "LZqbvRiNxcTjeQSDUZxOF3p9EKVSiUIhw+sdIhyW43A4CAbHCIXaSU2FlJRcWlp6+PrX7+a//uvX\n", + "7N1rw+32M9TXgErKZYZeT5QwzoE+Cgvz8HpNbNz4Mnvee5c0uZxgKIRRknC53Sg1GuKxGDFg/9at\n", + "RCMRZi1eTFdTE4M7drAyI4NBr5eje/bwyf793LJ6NaJSydDQEEVFRcyqreX3hw+Te1ZihS8YZDAS\n", + "IbhnDxGrFa0o4o7HKV+wgFvuvBO5fGrVgSm9uiAIqcBPgAu2lXruuefO/H/VqlWsWrXqsstUVlZG\n", + "Xt5e9u37EJ/PQGpqGR6PA6NRy8KFK/j446PU1s696Mc7Ly+DSKQDAJdrDK/VRqpGg0urRSaLEJLL\n", + "6RwcZDAYQZLLUGjDGLVmhj0uuvrrSA95mS3LJi6G8Pr7sHt16GSZeEJuIn43mkiMgfgAdlIJBdMJ\n", + "RjLwBqFnUOC1HQdZUFmA3W6n2+3msb/4C0wmEy6Xi+bmNpqbBxkebiAe91Ndnc/dd992Ru54PM7e\n", + "Dz9kbnY2KdpE9YtUg4G5CgV7t2xhzty5yGSyxLm7u5EkiZKSkgvG0Ew1hYWFLLztNvZv2YJZkpCA\n", + "Mbmc1ffdR+pZhedOE4lEeO93v2OWXn+m2JAkSdQ3NHC0tJRoJELdtm2oolFCkkRmeTnHm63U1t7G\n", + "iRO/QtSmYvM40URjyGVxggyRovTjdR9myJaKOj5MkbKQ/qEeQuEociEDhTwLcCNTB/F6hkgTNUQk\n", + "Ea/bisvvJozE0Z4ACoWcgpoawqeyszweDxs3biEtrRalUs2hQ40IUjEff7ibZSsjpKWlYzSWsW1b\n", + "HQsXLhjnstmzaxdHN2+mzGQiU6VicPduXjpyhK/+8R9ftn5JVzOBQMJFc17dqi/E7bfDn/85hMOg\n", + "VH75811r7NtXh8djJD+/EgC93oTRmM7WrfuprZ1LSsr4FNizGRwcpL3dTlnZ9ZSW9nDy5CAgEg4P\n", + "MjCgQafTUVychtvtxe/vIyXFRDTagF4vUly8lKNHG6ipmU8wGEQQtBQUzGbM6cFuGUBAj1qpwqTX\n", + "4w8F2bV1KxDk6AcHMcshLIrYJAl7IIBKkggEgwwBgigijYwgGxpi98svM9rfT77BQEN/P+GxMYoA\n", + "RzBIw65deNPSWDA4iF6vp7S0lDlr17J/xw7MkkQccCsUKFJSMI2NUX7KVR2Pxzl26BD709JYvnLl\n", + "5Ryez2QqA1jlwEvA/5Ik6YLlQc9WRiYLuVzOY489xNGjf0s8rmBsrJ2cnDSqqxei0+mx2w0MDg5e\n", + "VBlZvHgxRuPH2GwWnDYP0YCHbmsXStFLimwEly+GR9IgxbUYZAEMSg3DgWGcQy4KpQCpcgNaUUE0\n", + "HkEdFokKLmRqMz5RT5fbxwylDnU0RCgikqbJYEwtkq2SIw/K+GBPF9bORgqNBrILCtj15pusfegh\n", + "amtrqa2txefz4XA40Ol04yZlr9dLxOMh5bxUY71Gg2Sz4fF4aG1pYd9773HaqLdXEFi0bh03LF9+\n", + "OYbiS3HD8uVU19TQ09ODKIqUlpZe9GNksVhQBQKYMjKQJImRkRE6Oy3Yxtzsbv1/zCnIZWlFBSqF\n", + "gng8zkf79tFpM3HzLauprZ3F7t170KrTiQtRvKFhMjW9rCk2MBQMMBYc5Ia8dHqcw/R6XWQaZkNg\n", + "gEAsTKZWi0quR4o5MeijjHrG6AvJcIrZaAQjxAU2t7tYl+cho7+fmhUraGvrADLQaPS0tx1mqLOF\n", + "HG01kTE7O199FXVqKjm5uUQVQwwNDZF/Vg0Dj8fDoY8/5vrCwjMWI4NOR1t/Pwf27OGWO+6YjKG5\n", + "qnjjDVi4ECYiDCkrCyorE11816798ue71jh5spP09HNdynK5AklKfLMrKys/9Xin04kgJBYjS5bc\n", + "QFfXBgYGYsTjIm53O5JkpqqqHKczQCTix2SqRKHQIIpqnM4xgsFGzOblvPfedrKyatHrTezdsYPq\n", + "wnLa+jy0D4yysFJHJBrFbbGQmSFSlqKhNjub10ZHcbpclMtkaOVyRsJh3LEYBaEQpSoV3q4uOsbG\n", + "yIhGCWRn02exMEOSUAgC+lgMS3c3w/39vP+rX1GXlUV6aSnr77+f2fPmYbFYkMlkmEwm3nr+ecrO\n", + "+saLosjM3FyO7tnDshUrptS1O5WWkQeAhcD/d+oBfF+SpANTKM8ZdDodCxfOo7Iyi5SU1HNWl5IU\n", + "QXmRZYvH48Hr9bJiRRUnTjgY6u9H8tspMkCGLsrcnELebBzFpDagMqgozszBpKlkx7GPkYsjaGJx\n", + "IjEfUZSkaFQEIhEMMQmL145OJ0OjLaY94sURdBFQGAmlGClMzSEccCCqQeN1ojYbWbNuBampqfiC\n", + "QT5+4w3KZ8xArVaj0+ku2gdHo9EQk8kIRyIoz8rMiMZiRAUBl8vF9k2bKNZq0arVZKemIkkSBz/4\n", + "gOLS0mkZEGU2mzGbzZ+5XzQa5fQIt7d30NjYh1abgVymob1xL+neIB1qNSl6PTlpaVTm5fHJyTb8\n", + "fj+rV99HNOCk9eBu4tEQFXkidy1aiEmt5nBHB0d8PhYsnIP9eCsxuxKZQoEuriAQaCcmFuIKKHGF\n", + "/bhjI9QUptHnMWGW5RAOBvGGQqSmlLG/2UHtunyuW7aMjRs34XJFMRpdDDQdJFutQCbFUAR95Bu1\n", + "ROJxlNEwYtjJh++8wxNPP33mAzM0NIQhHj+jiJymICOD4ydPQlIZ+dz84hfw7W9P3PnuuSdRPC2p\n", + "jHx+1GoVoVAYtfrcb9ynfbPPxmAwIEmJEuoymZy0tEKMxhwcDht6vYfCwiw8nkGKi0WWLfsmH320\n", + "Ga/XjEIhA0aBOJs2vYdcnsqcOYkcbb/fj0rQoFQMMuLwEQhl0z80gCziJCfVSLqQglImY15BAdvd\n", + "bnoFAVk0Sns8ToVazSyDgVyTiUyzGafXy6DNRkSr/f/Ze9Mgy67yTPdZez7zmPNUWVmTai6NJSGE\n", + "LAaBEYMBmbERzbVN+7a5jW+4o319u23HdUSHHURHd1/7hruxAhBtSRYCJIQlNKDSrJKqpJqHrJwz\n", + "T2aek3nmcZ893x9VFJIlhDAIYdDzK/NErL3OWStzn3ev7/vej4jrYigKEufNMwPPYzQSIWRZvG1k\n", + "hPlcju/ccQe3fOELF3NCVlZW0IR4heAwNA2r03nT7QHezATWO4E736z5fxLj4/18/esPMTCwlYGB\n", + "MZLJHhqNMrGYw+hLGtE1m02OHz/Bk48/w9q5U2zt7SGtqqSUNQTncPwKSSPKlcN9VEyH4cQE3ZrF\n", + "+Mad6JEIeirFFusKIh2Z/naD/GKeTuDhBTIELk3PoUWVy3sm0DsBppslZ9bwVR1NgYWFwwR4CC2K\n", + "7rpEwvGLpx4RwyDquuRyuZ+YxKWqKruvvprTTzzB7tFR5At+KadzOS655hru/da3mD10iCAexwkC\n", + "LMPguv376dc0Jk+detPEiOu6TE5OcubMDLqusXv3JYy/pJztx9FqtThz5izVaoN0Ok4lCMjl8zz4\n", + "9BGE2kNWMrE8Fw+Z06enWTt3inRvFiWb5bprrkERZZ5++gG6XZtm0yGqOFw/mGDrpkGSF9x4fcMg\n", + "ZNts2rqVDZs2UftfD+E36wzFksw2HWx7hpZlYRglDENQdQRGOIIeCiH8OGOhEGMDAyw7DdRQjP/6\n", + "X7/G8nKV06eLHDt2jlGvyeb+DIfOnCVBiHDIwJcF8yunuOX9u+murrK6unpxbzRNw36VKinLcTDC\n", + "r2ZM/xavxdQUTE7CB3+Odjyf+MR5r5G//uu3QjU/jnq9zrFjJ1hdLTEwkGHv3t0kk0muvnoPd9/9\n", + "PL4/wdpaDtd1CYUMEgn3Fc3lXo2RkRFGRiKsrExjmiaGMUQkMoCue2zefAm+L0ilehBiActq09u7\n", + "maGhLL7v0WxmKBRUjhxp4vtLrK1FyaQiVAsFpFIJRUCxcpSHDy/QajUZ0UwmYvuRRIzlSoWoJLE7\n", + "myU+OEi1VqNZqbA3GiWuafgXkvF39fdzeGEBv16nJ5FAkmUWSyVM26YvHGa52WRyeZn3CsHGgQGe\n", + "np3lwe9/H6fTIZ5KsXnbNmxVpWvbGC/54ypUKgxt3PimV+G96Qmsv2wEQcBDDz3KE09MAikOH57E\n", + "dQ+SyQg2bRrg93//sxc9HdbX17n11m+yvh5QOP4iGw2DYm2ZK67cScP1ea7RJJrZTrnr8tBMFUOu\n", + "M7dmouhJ4o5DuNulurSEHgqRifSy1miihAaRbAcvaFN1Tea9BkPpHsJSCFd3KLbKBNEsQWcOc2mZ\n", + "fqHiShL59jIN2WNtvsPCwsLFjrs+vObRm+d5NBoNDMPguhtuoNvt8szhw0QlibbvM3H55QyOjvLo\n", + "N77BZfE4fRdOGqqmyRMHD7Jvzx4c26bZbHLsyBFy09PE02n2XHHF67oB/Cy4rssdd3ybM2eqxOOD\n", + "eF6X5577R975zl28613X/9hxKysrfPWr36bbjaPrMbrdOQqFGvcemcSqRIhHY5xeLdGRSxjlIptk\n", + "lVDgM2RZlBYXebDTwXQ1OsUuodAwitJLrnOGF9QKSdfl0OQ8+VoFLarT6na556FH2dw/wObhOLNL\n", + "grOLebQgYFiP0o4Itm8dxysXWZ1fJKyrrLerkNnA/m37qLdaGHqEb33rAXbseBdjYxtotY6yuFhh\n", + "ZXWdiV3byUjL2IpM2zdx3Q6bBiLs3TTOyeVlWq3Wxc89MjICqRTr1Sq9F/bR932m1te58qfp7vYW\n", + "ANx6K9xyy89XNIyNwbZt5w3Q3jqoeiX5fJ5bb70bx8kQDic5ezbHk08e43d+52Ps27eXAwee5N57\n", + "b0OIYYQAWV7nE594++sKPwgh+MxnPsp99z3Eww8/T73uI4SD53U4fXqVTsem3V5jYKBILFbE8ybI\n", + "ZkdYXp5mYeEMIyNj9PQM0O2eZHLyDEG5zLbhISrAUqnMYHgQ/Ay2aGH5DQq5PCOxEPlOB991ma7X\n", + "6XddMvE4cVlmtV4niEYZvXCaLQORnh6C/n5OHz9Ov2kyqOv0qCpxTWOl06G1vs4jzz+P2enw4uQk\n", + "tXyefdu2ke92Ofb44wzt2sWLR46wOZUiHomwXq2yaNt89D3veWM37nXwlhj5JywuLvLQQ0cZG9vP\n", + "+HiYybNHmDn8MMryCmZngf/j5vtJjY7xoU99nGbLJQhGkIMcY9EEyVCM5cUz3Pm1b+CLNH1SlCAW\n", + "IZscZi6X42T+BQxRoy88QCaRIKwbROwuLyydZnhTlIJIEYk7aJZNpVGnEo8Qjm8impBwkymcwCcy\n", + "Nkx4eYHk1LOkRBhEFtWXyXgOhcBkra7w8MPP8/73q8RTKbq6flEUvFR4hEIhjh8/wT33/IBisYGi\n", + "CK6//jJ+8zffy7XXX0+9XieRSJBIJPiHr32N3Rs2sH7y5MV1SoVChCoVzuTz3DQwwN//7d8SbTTo\n", + "SyZp5fN854UXeMfNN7P3n2tJ+To4c+YMZ87U2LjxCgB836PdjvHQQ4fYs2fHyxxMf0gQBHzzm/ej\n", + "61vo6+u5sC7DPPfc86RH3s6aVMfTE0SNDaxPPsioEqIjPMKSIBYKIbpdjpybIrLvQ/zmTZ+gVCri\n", + "uh7Z5Ac4fui73Hm6BV2dmLEBr1nA9Du86K2y2pDxu3WmV2axpChROYocNZmIOVhzRfZkMniaQqFd\n", + "IxEapNla49ziNLmWRaP4AlkRMLO4gpbOYgxvYc+eDTyXf5q19bO8be9mUp5LLBrlxeU2XUXw7Qcf\n", + "pCwE+z3v4meXZZnf+sxn+M43vkFucRENqAMT+/e/ofv0q4htw223wVNP/fyv/alPwR13vCVGXo37\n", + "7nsERdlIX995H6h0up9KpcB3v/sIn/zkh6jX4aab/hWdjoWqKmQyGRYWjnL27Fl27tz5smsVCgWe\n", + "e+5FVlbWGRrqZf/+ywiCgJDsMt6jUMgt4fspWi2JdruLJMWwbYd6PY4kNUgkLBanvou5OsNOI47c\n", + "slgqvUAg1SmtrCHZIQ62qnS9FrJk0aP102xVuWTrTsxGkzOlKfYO9+MFAYuShJlIsHFoiHQ0SsX3\n", + "aZfLnKjXqRUKeEs5qrbDxuvezud+/9/wV//hP1CfmqIvHKbRaDDT7RIKhQh1OiycOEFEVUkXiwS5\n", + "HNrWrQwNDzPQ6XByepobPvMZjh08yGypxODmzfz2dde9oufNm8FbYuQlzMzM8Fd/9f9x7pzMuXMH\n", + "SSZlROk4V/UPcSyXwyoucmmyl8nJRe7+L/+TFT/go5/8E7qdBvEAcrPHidgWTQsSmTR+u8nRlRzV\n", + "to4sD6FLLWQ5x3JzhWQuymA2g+uV2D5ikC9VaZdrdCyHittCSW1gYtvbaTRWsOQ6w9d9CFXViUaT\n", + "lL7yx/SmU3TMGJ4r8IOAntAIrl1lutEgm4pw54MHGN67nctvuIHv33sv6+UyC8tVZDkOODhOlUcf\n", + "Pkqr2UMsOUQsHubs2R9QLJb4vd/73MsSdDvNJhv6+7HrdRaWlkgZBkIIitUq49dfT35piXS7zaYL\n", + "4atMPE6vZfHEffdxyfbtr+nt8bNw/Pg5ksnzCZpLS1OcPn0C2xY0GgVuu+1OvvjFV9rsr6+vU6k4\n", + "jIz8SKjU6yV0fRDf1xkYybC+cI5Io02mmadKAyWRIhELMdtuIykKQjUIR+L84KFvUSuuk+gdIpGM\n", + "0fEHCckS2wYSmLbNfFcikurjio39rIdirNXLNKwCshSl7Xi43QpurcFEYFPxfVqWCnKIartBux1w\n", + "rPoimYTE7liCED20Kg2s0hy1lWVC2y/jmvd9BmftOXqGB5g+epRSPk/bdbk+m8XsdEik0zzyzW+S\n", + "+sIXGLjQkLG/v5/f/cM/ZGFhAdM06e/vp7e39w3Zn19l7rvv/AnGli0//2vffDP8yZ9AqwWv0kn+\n", + "15ZWq0UuV2F09OWGLul0P4uL05w8eZIgSJLJ9LzMOC6ZHOXo0TMvEyPz8/N89avfRVGGiMc3cOJE\n", + "mccf/zvifpF9PT28e8MGQs02f3PvA7jSFjKZCTxvif7+Hnp7t7Ow8CC6OsXutIbrj6IoKSyrjr1+\n", + "iqYWYiQcp+EFqIFLwddxvRhzZYESBCwXc2wdHqFQzPDE+johXWfZdfnIu9/DgSPTlFe6tKwk+foa\n", + "cavBTPXM+XbQmQGu8AZ4/PFDbN67l3qtRjIWw0il8FZW8IOAfl2n4fucmp5lixHBzFd44J77+K1P\n", + "3Ew8Hkctl4nH43zmd3/3Dd0rz/M4euQIJ55/Hsey2LpnD5fv3/+aY94SIxfI5/Pcdtv9eF4fyWSE\n", + "WGyQxbln6G+sU+mC0+iQ7ushEU2ScGwWmy2q+SWevvu/EYRjNJeniXbqGJJMtd1gONTECxnE1DRr\n", + "LQ1dDWgHsHdsJxuHRlksHGbHhijRUJa/ufseYi2frJvGcSAhJjAtj24HarU09foZvvvd/5d9+24g\n", + "lUoh+S2MaBzHCWE5Dogwlge+UOgqfZy2PRSyLB+Z49TBF9g02Eu11KbsyyRHtxNoGQ498zCOM8rE\n", + "4AaKxQarKy1iiQi33nofN930npcp5Q2XXEL+ySfZvW8fawMDFJaXcV2XeDbLp2+5hTu/8hWu+idf\n", + "aCFdJ+S65PP5iyGjnzeKIuP7Pvn8PC+8cJJEYgeRSBjPy3H2bId7772fj3/8Iy8bEwQBP0yb6Hbb\n", + "mGYb2+4ixPlmZxGxzqhbQieKpMRI2GV0ucvYxp0MJxII4LGnnyX37MMMa72EPcHa1BTPdUoE4e3U\n", + "RZsTroMmy2iRFKZl8szUGWrNMu1WG8MfxCaMKnQMqZfZxguEgzYrbQlH9BOOZokZ0GzM0jErZEUE\n", + "SUmxWMqhx9IQxMnKEebOTFJvVbn5Y28n3dvL1i1bOPQ/b0XpatwztcauzSO8/7LLaFsWzz72GB/9\n", + "1KcuroGqqj+VEdRbvJK/+zv4vd97Y67d0wNXX31e8Lxk237tOd/gLSAIgpeFXc7/HlzIeXhlOEYI\n", + "Cc/7Ua6U67r8xV/8F44ezQEyGzdu48orr6VcUGg3C3zwQuPRt+3czgMHT7NQbpPJgGvHsWttCtUX\n", + "aTU7dESeeKqPgl1hdfUcVqdOGI2iabOGjO70IUkuspNDFv043X66IozZGeLFc7OMDwo+dOONCODb\n", + "hw7x1Mkc5WaWtu9SqU2z0RNkAw2BQsWV6ZRqPPfIvXjeh7juuu2cmJtDchz6+vvZfOmlvPDYYyy3\n", + "WpTbFpaI4AUxrI5Crd3iwIFnef/73/mKtXs1bNtmenqaWrVKtqeHiYmJn8qDJAgCvvftb7N25Aib\n", + "entRFIXcE08wfeq1DdbfEiMXeP75I6jqMBMTCvn8YWCAkBHCLQWsFVaRJRtNjXNwrcRSXaLl64SD\n", + "QdZyOS7fvofDxRwDwHg0SUOXOVWcRhraTa3i4ephdDWBrzSZWi7TtWqoqkrbbHPw2aexSm2G5GGa\n", + "VhUvSBEKZ7AaRaaOPIhPHzG9l9bCPI8s/S8mdu2kJSTOFtdImipaoOJLbWzCFJCxHZvB4XeynnuW\n", + "eGuVjZE4S88fo4HPRHaQ1ZPP0rKgXm+iGztZKdZARNAROLbBwkKXP/3T/4c/+7P/m+HhYYQQXH7V\n", + "Vdx+9CjTq6sMZTKokQiz5TLXvf3t9PX1oWkajue9rAoHwAuCN9RI59JLd3DixA9YXCwTiUygqmE8\n", + "z0GSLHbuvIYTJ47w7ndXsG2bQqGAruts2LCBSMTn8LPfwyouYwCdIGBtdZWxjVcQ6bbZeMk25ucn\n", + "EXILW1cZ1FRmCgWSoRDHCgVMBCPI6F2BKing6niey1Rjhv74ED2eh2nZ1KwOa16DUaPJoKdge734\n", + "TosWJfLE0EjikmKVOkOej6+7mKbA8VtUghCqvgvfWWSpVqPsa1ADVY2y0l3Fo0omKKPNDbE8N8cP\n", + "jp/G98bYuWMPqmYwuTDJka/dw/W7R5EqlZeJkbf42ZifhyNH4LvffePm+PSn4fbb3xIjLyUcDrN1\n", + "6xDz8wv09/8oSX19fZHNmwfYtm0b99//PI5jo6o/SuSpVpe48carLv7+B3/wf3L33S+gaeddTRcX\n", + "j3L8+GFS0SSjcZtGp0MiEsHQNMYHUqzWYni2ilKvMBCJ07XaeIpNZSVH2Q4QwsA0AwIvi6wrqFab\n", + "WtcjKZUZcWx6SOIGIdp+kXnfJDA1uq7NysIMP3jCp3d0lKLt8vzhc2SlMKbTIe6uMSx0RGCgCJ8E\n", + "MvOeg1Pt8MTD95KfSjGejbNSLJJuNpEMAzeRQEmlia7LOFJAxa7SLxuYZoelpSpnZ2YIBgZeMyRT\n", + "Lpf55le/ilqrEZEkTnkezwwNcfNnP/sTfVp+yMrKCrljx7h6fPyi8LlkZISTi4uvOe4tMXKB1dUS\n", + "0egwkUiC8fFF5ueP4wmJYreFLLWI6R6zbYuOO4TjtRmLZfBci3JQ44kTT7FTkuh0W8x1AgYG+9ml\n", + "6DxZWMB0N+CKeazSMwRmncAS1MpFOkGdWyfbpHWdwDJwVJB8CcttYZrrBG4H4ZUZzGzCoU696xNT\n", + "L+H4wSppI0rDVJBwGZZDmK5DSVSxQ0OAw/LCGZLlc+wdHiUajtByFAY1n5VmjY4dUA76cO0EbXsa\n", + "PzJGNtmDaXUolYoIyebQoSpf/vLfc9112/mt37qJeDzOp77wBQ4fPMjk6dOEYjGuvfFGdu3aBcDu\n", + "q6/m3IMPsvclJyDr1SoilXpDY5Fbtmzh6qtnefrpJ4nHM3S7BYKgxb59m4lEIpRKYb5z1110lpdJ\n", + "CoEVBDwaiWAoCu7sM4zGhjG0MJ1uk65cZXnpCWrFGvONNp6XQJZ7aHlhzhQrtK0iVjaLvmUL2aqJ\n", + "VISuvUzHl1ECj35DsNRaQ3XjBJLAdQMkN04sWCHlyPiA5HqoCELoNOkCPhpx6oRR0ejxbGrBMmuE\n", + "qYhRJClMy/dxTUE6sgvP7YKwaLoZYobHJSMbaK6vMze7Qmu+TEka4IyzRK5aQ/YjeEEP3370DK7y\n", + "HGo4zI0f+hC7du9+w8Jmvy7ceut5l9QLRVNvCB/+MPzBH8D6OrwVRfsRN930br761btYXKyhqnEc\n", + "p0Eq5fCBD3ycdDrN+953Fd///mFUtR9F0Wi3C+zYkb4Yonn66af53vdOEolch2EM4romtdp5QbJm\n", + "lClGNO5/9ggfu34/mqryvv17eer0I5TzPuOxLMvFWebWZnD8AAONU9UlUrEMY2P7KK2XaTTXaAgX\n", + "VdHpxUURKrYnIXAIBx3GWCVo1OkjQNh1jh49SqzZ5PCRU/S5CQbVBOu+TwaBHLTwCBN4BooaIeE3\n", + "WLEaBLhEVlvc8qk/ZHp5mZm5OQ7Nz5Pauxf7xBkIIoz09LFYnKLeKSHpMSp1k6cWc/zZl76E67rM\n", + "zMzgui7Dw8MvC8k/8O1vM2BZjLzEOOfcygqPP/IIH/jIR16xH69GPp8nJUmvOIEZ+Ammim+JkQuM\n", + "jPRy5EiZaDTJnj3XMDS0wvLyAqdaYQayCdZOnmW15REIGVtS0CWJGgH9A+PkFubY1ZNkpegQi4Ro\n", + "NZsMjqaIrxdx5HOkfINau0vSAU3rwwskUkqYRnueptOk7mlkPEEgEghh4toOrmgjJAnVmsXorhNF\n", + "p2bOo/o6pmeQ8McpsIQfeMhKhIhsEPfyIHoJNRcZ1UPUyyVajSaB6+G4Ft1Wm6bWSzg8yGBUMFPz\n", + "6Dp1bKdKrWnieEUkuUit5DEzvYIQKps3n2LPnvOOs+9673t513vf+4q1u+rqq1ldXOS5yUkSQBfo\n", + "RiJ89LOfvXC0+uq0Wi0ajQaJROLH+p+8FoVCAU14jPcrNLozbJjYx+joDqLR8/1+CvlJeto+b9u2\n", + "7eL7yJdK/P2DD/I7N93I+nqRdrsLhNG9GFqrxanmOuluP5LQUSWFIAhR7hqU4xJf/NznuP/+x1hY\n", + "XGNcjCLLCqZVJyJDIhJF7ywTsmcIeVFaVpeWCND9NsJ1SUsKnSCKTJQAiXvETYMAACAASURBVDAm\n", + "Jh4eDkmi+OisEaMYdFlnEM3YRMAZLC2OZ0UJOV1EYGEHdUDCsRNMnX4BbzlBx1eIBWFKQYelSptu\n", + "O8pQOknbqiGbDS5JZ5i653tkLYuThw/zyc9/HuON/Cb9FcZx4KtfhQMH3th5otHzjqzf/OZ5UfIW\n", + "50mlUnzxi59namqKYrFMNnsJW7ZsuSiwr732GjZsGOXkybNYlsO2bdezefPmi2Wrt912J6aZRQib\n", + "bjeP41TwPBUhtuE4eVw/xSMvLhAJS7z7sssQQvAbv7GVU0eXyNeLLORzaF4fvaqH7ankRBm72Uao\n", + "a0RTcRZthWhqG5HCHGq3iiaiBAIUCVSvTFoIGpJESpJQJInJpknt1Fm2dTtEZZV1a5F2YJHFO/8A\n", + "g4aMhOd6+CjUhEDtmkS889bvm4aG2Do6SrXVYtkweGA2x7pVpt/UkCIZipEMsfRmqo0cH33XdRQK\n", + "Bb7+N39DryzTbbWYKxYZ37ePD//2b5NMJqksLbH9JdYVABP9/Txz7BjOBz7wurqDG4bxqhYCpmW9\n", + "5ri3xMgFrrrqMg4fvoNqNUoq1Uc63Y9ltfjUv/4kV1y+i7/+8peZvv8oitfE92yWbIu+4X4828FQ\n", + "QzStDlFVJSxJ0O1y9PRpih585O0fY2lxitP1WTKeQr2zjCVieCIg5MvUfYcWGmVhkfFDBAR0abAa\n", + "NOgRGj3dLu3ARPPCxHFxqdPx+shgUCdOJKiSCifxdY+o0FkTCkM9WdJOCLuyil2uEeDje108T6dE\n", + "QEwShGQfXW3hegbl+jM0ux4SJj1aLzGnh+VTK+SXphgZMdizZ89rrp2qqtz8mc+Qy+VYW1sjHA6z\n", + "adOmH/sE7jgODz74Aw4dmkSIMNBh//6frsvY2bNnefj22xlUVW7cOMyjTx2l4DcZHf0kjmOzsnKG\n", + "qNRm58gWOhcMfaLRKDHDIG7btF2XzZs3sVws8viBAwxpGnFdpyEn8X2HuGuDCZ5wqeBTWrb437/w\n", + "fxGO7SCQ4xQbi0TlDEIYtLwGS9Yqm2WJqzM6SizEYqFJnxUwZ7vI+PSgUKRFFwkXHRvwMdHooBNC\n", + "oY0e6HQCBUW4ePYU4bjAMELU6yHybgPhd9FCPYSsGqJbB7eDFEoykE7R6rTwfYmKDbpsUGhWUZ05\n", + "9iXTbOkfZ6U8RZ9hUMnlOHbkCPuvueanWu+3OM8//iNs3gyXXPLGz/XpT8Nf/MVbYuSHBEHA8vIy\n", + "xWKRSCTCtdde86pfjsPDwy9zHv4hR48e49ixBXw/STw+TLW6iGm20bQJgsBG0wK0iMxyOc7XH5zn\n", + "qTN5YlGPq/buZl4u0SrNMSiPMxg20AhodVWmPIk5OWC902B8aDPR1A58q0TYLKKYM+hKgJAEllMn\n", + "E9g0CPB9D1eysUUfSWsN3VVIC52w3yEdwDQ+TXwCVCJ0MYhhBV1ydDHdISRpDavb4Rtfv41UJs3E\n", + "8DBaPM6MUIn1jXB6vo4fHyadmWCDHqNWW0RRm9xzz6N8+S/vIK5qJLQO+1KC7ek0p+6/n28sLrL1\n", + "bW/j1R4dZUkC38f3/de1T5s2beIxw6DabJK6ENqxHYeldvs1x70lRi6QTCZ53/uu4sCB51hYmERR\n", + "BPv2beY97/kNJEliaNNOoskcqujHth0ss0qrWsNXXFJhWGo0uWJoiEg4TKlSZX01j+T6zJw7garr\n", + "BIGDLemE/SQIB1noeMjYdOhFZSVwqdLCw6aLTSB1ifktPLoEfgQbHWgTxcLBQpHC6L5DmgCz3cF3\n", + "AmzdY2xY4OkylY6J7/p4XhvFM9FkhUU/QFPHsLotmpJDPNZLo92k4xRQkNicvpyYlgUsBgYmmCue\n", + "5eDTz8If/eS7oRCC0dHRlxnC/Th+8IPHOXhwhdHRtyFJMp7n8tRTx1/3Xrmuy6P33MPenh6ioRAA\n", + "8VCIxw6+yAvP/D1bdu3huut28syDJ3nmwAF010WRZYRhsGX3biRZptZscmhygcVVh0IuypzqUgla\n", + "dB2Fqt9LKlhDFT6IFCpJ4sFpbNOmbge4joZDhF7PQRUqzUDGwmG7JgiFw8gEJHQFyekyFQSUkBj3\n", + "JbIIyqyzQogOEj20iTGII8KEVJfhvhiL66vEFAslsPC8zQgxiCxXkNQIgaehCImOUychVUkrYSql\n", + "KqoSomlXcJQRVCOGJmVw3TnGFJ8N/UMECNpdi6efPowvqTyXKzA4PPy69uql1Ot1Dh8+wpkzc3S7\n", + "LQYGeti1aztbt24ldGEfftW59VZ4gwsRLvLud8PnPgezszAx8YuZ85cV27a56657OXt2HSESgEkq\n", + "dYBbbvnYq5bwvxTP8zh69Cj/+T//LaFQFljGdZuEQhEsywY8JClPPK6TSF5ONCYwzdOEYkmMIM/O\n", + "bJaZTAZvagbTk1CEoGo51FyHkDBoo9DwTPIVHc/NMT6mo4V9iKiMREJoQmG1WcLptKkIiaTwiWob\n", + "qHkmGaFiSTq2sEj5LjoBowTMErCMhEGAoEkRgckABikaLHOunaVXDLC22mGlnsM125RSW+jPRvEa\n", + "Mvn649RKR4j5LmHZJ18o0up7B0l9I77ZYTa/SGl9gbErE+xIp+k4DsVTp2grCuVGg0w8fnH9Vi6U\n", + "AL/e8G4oFOJDn/0s991+O3q1igw0JImrP/hB+Mu//LHj3hIjwMmTp7jnngM4jo7vG0QiFp/4xAeY\n", + "uHAHePbZgxw7XOC6nddwfGoa2Y7iqUkWWgsIf4Fr+3VSIyOc8X3M3Ar5ZoeykmBY0SgWbURQp+Za\n", + "xAkRZo0E4PoSdSxa6KQQjGJQQcImjoJCIE/hBSaOa6BjYCMQJBB42Jis+wZZ6kToUvW6VF2Zjf19\n", + "bI6pHKyus9BqE+qY6IGHHO2h5rt0tTQhOUXdNZFjSS698p2srJyiVuvQyTcJSVGEsMlk0wghSGhJ\n", + "aqWVn+taW5bFc8+dZnh4P5J0/uhUlhWGhl7/ycja2hpyp0P0JU36BgcH+fiH+3h0YYF/9b99lG9+\n", + "8x957PFDjFdLbErEyQz1ElYUTj73HPLAAE+cncHu9DOQ2URt5QQ2gnh8gPbSAZQgTky+hMDzCYC2\n", + "X0WnRTiQaNlzxMQECS1D1S3g08GSsyREG0c3mfM8wq6LLSksWYK2b1DEoEODQRzaCHwMNhAhTwtZ\n", + "ctCogy5YDqr09upEG+f3YsE6S8Otk0hEKK1XSCi9SF4TmwqIKm3HxbdtOmvgxuJI9jq269G2NKJa\n", + "g0DyqNRbtO0iHQfS6W1YgUfRFHzlK9/h93//5tftnFutVvkf/+MOarUwk5MF6vUurnuOzZsn2bKl\n", + "j89//mP09fX9VH8L/9IoFuGZZ843xvtFoKrnuwHfcQf8p//0i5nzl5Wnn36Ws2ebbNhw9cXXSqUV\n", + "7rrre/zbf/uvf2yFiO/73H33vRw8uES9PkwmM0wk8i3q9SdR1QF838T3c6RSDrHYTjQtQbW6SkhX\n", + "6DfCGOpGTi/k6UunaSfjnCnVabUTyHICXU/i2F3anSIea/iteTK0qa36yEZAzNCoxxX8doemJlF1\n", + "JIaDgLLr0LIc6lhkZB1JimJLTboBqIGHjiCNzzo+VaLU0fHJoiDoModKGl0fJaZFkOwwC9UOHeEy\n", + "bofYNTDKxniWp178PpniFONDE1TaTQbjm7BbDpXWEhkjSa+apW61eeTEOd67ZxuObTMeDtMeGeHs\n", + "wgL9rRbxUIhKu01Z0/j4q4TnX4uxsTH+zb//9ywtLeG6LkNDQ0R/Qp36jw/ov8EIIQaEEEeEEKYQ\n", + "4k17H/l8nn/4hx+QTO5lZORyxsauRNMu4c4778c0TQBOnpzB7vpY3SZhr0lftEx/vMGmXp3tI1Es\n", + "SWLn0BA7evvQ1SiSkWXr0OU0NZWwKpMQIUBhjRoKNiIQCBxcPOIEeDTwgFEEEbr45DCdNoVA0MbD\n", + "FW081umwRhkTlxYWs1jYTAqFNSMM/b1sHB9jviGjdQYYSV9ON7SNKa+fST9N5JKPoEQNGt0lFOHg\n", + "dlY4duQu4vEaV111DYYuoSgtYnGdwPdotSuomk1vT+Y11++n5XzIREFRXn68qmmvP4dBURS8V3nd\n", + "8310w+DOO7/HyopgW89GvMww657G5PwqS8UiR1dWKXky665B10hzfGWFs9Uyk6trzCxU8fwInj9L\n", + "w52mERRp+fPInGUYh7BvIwc1QEaSFBRZJaIq6LKD0CN0JZloXx8Fz2Ou7iP0Xgylj6y2FYtNrGMQ\n", + "JoROhCI2FTFALhSj3hemHFNJDKT48MQobxvawP7RMW4YGuaKwSxb+sfpT4VwvCnSyjK9SpGk26Xs\n", + "dlkRDjNOC0cK4wgDnHUiYpaN8Ti2olIq5SiUF9iy7XIMI0yh02R8xzWEQuM8/vjB173mTzzxLJaV\n", + "pVbz8f0sw8P7GB5+O8WihW338e1vf/91X+tfKnffDb/5m79Y748fVtW8Sgj+14qDB08wOLjtZa9l\n", + "s0MUCh3W11+1zyoACwsLnDixxsTEleh6mHA4xXXXfZ6JiWEGBlokErPoegFNk1hbW2Jm5jDl8jRd\n", + "0+X0/BqleotWx2bH5s1gGAxETBzJRNNUNE2l4hXxMQkJn8s1h3fEsuxU02xyAxqmSW61gGFkGE4O\n", + "Yjoec26AQ4DpNGk4FvO2Rdtq4UsyDUliTficxqWDYBsdHAJ0xjCIYdBFRsf3PVLpBE1VJe95dI0+\n", + "hNSL8FssrE5i0yYmuwwKQcKrogYuTkdC6ToQmEgCZEkQkuO4ruD08jIDAwP4vs9Afz+f/uIX6bnm\n", + "GpoDA4zccAO3fPGL/6wHDVVVmZiYYOvWrT9RiMCbezJSAW4A7nkT3wNHjpxA0wbR9TCVSgHb7hKL\n", + "panVopw7d45du3Zx/OghKrPPINsOfUiYWgg9PoQsJ4knPYJwmAeWl4kFEus+6LExkqEUZ+QwSiBI\n", + "eIKwCIgGGgVkfBwiSGSJoVCjSoEOTWoYtHBII5MAPBzWyOMFKj0EWLgMoaIhMICqHCETSuJoCjdc\n", + "ug1Z05k+u4ZZb+MJh4ar0pXGke0o86ceZX/fMIutJZa7NQIvS9AQnDlZYHVhmba7Sq4eILfzRKMh\n", + "JoaHaNtttu7aycGDzzE+voH+/v6feb1jsRiGEdDtdjCMH/VDMc3Wa4x6Ob29vRi9vRQqFfpf0n14\n", + "anWVzPg40/M+hmEgVJ1Nmy9ltZxnZnWGZ+eL9AztJeRtpNHMsd6t0inN4bldgiBAshtoAThECTFP\n", + "DJ8EATEENRysQGFYdlj25+nYc/QFLhHJx6fLgl1jWrQJvfgijgddX2NZsukGo6Q8B5cQBRI0KNLC\n", + "xKIHTUSQrBVCbY9o0KY0XeRQMsmwiOA16tRsE8XxsFWboewwpfI8tl0m4vmYgWAwsBkHTgc+K5ZO\n", + "PLmBAdskmtTosowSUVmr15DbGqfm5zheKtK/8zL2DmwkCHzm559/3Wt+6tQs6fQ+Dh9+hmRyEwCK\n", + "ohMEERRFZXW1TqVSeUU36F8l7rgD/viPf7FzXnXVefOzqanzHX1/HQmCAMuyX/EAAyCEgm3bP3bs\n", + "3NwimpbFMAxGRrIsL6+TSvWzYcPVJJM1zp416HbjBEGI2dkpHMcgGvVBGsaxHc4u5dg8HGLz8DCx\n", + "jRuZffYF+kI1Gn6TgmnRAeLhS5HMp1hxNBY9DzuwEL7PmGQRBHCumGPelJHYiA8YdGj6JgYS0EYL\n", + "6lh2gI9LSwh8SSHpB5RQkIiTpoBOhT4EDhoVPGaXX2DP+DWYqRQdU8aq5cD20YIm6ys+5coS8ZCg\n", + "Wa0i6WE8v4jihlEUmXbgIXseptdAV1yWHYfxwUGOFwpcuX072WyWG94Ee/g3s1GeBVhvZstigGq1\n", + "SRDA44//I/W6hxAGllXGMFzGxwX//b9/hRcfOEDWipzPFZDaDKoBS5V5qprLjbv3snXDBmaCgKfv\n", + "exDX1qg3q5yqNQCFlgr5bh1XkenzOuhBEiPQUAAbEw2TPqCXNpO0SaMQR2UIBdAAjSlcVpHZQ0CS\n", + "gBodYijYXptTHZt0qJeGJYjLAasd6Hhp5CBETIvgUqTj1Il6Hfxaka7nklF3kIhm8YFVs0WjUUGo\n", + "gyhaP3gR2l2JF2YmSffYmNb7eOCBWTzved7xjh285z3v/JnaTCuKwrvedRX33PM8fX07iEQStFo1\n", + "1tdPv+5rCCH4wMc/zre+/nXyi4uEJYm67xMbH2fTzp1Mz08RiSQoETCi6mzs38BSpU5au4Te1BiJ\n", + "sc3YgcUTjx0iJA2RDm1HjWnU20tEWKEpNLq2wnDgEUXQwaYBdLEJeza6sBjwQyREhIgvaAc2G+kQ\n", + "C4fIqCrHa200wqQ86GIRFmEMBD5hiqi0SSOIIfmzjPkdNlk6fakwitVldn2dI67PpYksY8keirUG\n", + "J1rLJDIeOgWq3Qw+vdgErNEkxioxP4TvdggFLm6nw6IZoMb62TyUYMXMMddaoze6hdHxSynWuhw9\n", + "eohMJsbg4OuvYAqFNGzbuvCE/lLDKRdZVhBCIvgVfnxfWIBz5+DGG3+x8wpx3hb+e9/79RUjQgh2\n", + "7Jjg3Lkc/f0baDabVCoVHMdG05o/9ql9bW2NSqVIu10HYNeu7dj2cdbWZmm1ylSrk4yO7iWbHeGp\n", + "pw7j+yaq6uF5IQIklis5+uJV5pfb/O0d3+H4YofV8ChhKUYoFCYZ76Uy3cS0CyjBAF16cLw4JiYy\n", + "iyz7NhEq0HIR9GITpkfR8V0HjzWyrDFMQEgI2oHLEhALwApghRhLgIKOTJFLUBBINBEIQnSsKs/O\n", + "HmNwdBedylFG3TYbI/1orsBqVhhyW4Q9nX3RJI6isFJepOyAGpog1dPH4uoZCObp60nhJ5McX1tj\n", + "+/XX/9R5ZD9P/sXnjARBwPT0NMePn8X3A3bv3sqWLVtedwfC8fEhbr/9NlR1B6nUALncKuVyQLn8\n", + "HMePP4XdEuySIhhI1F2brmdQMlfJBw5tLcX9z+S4/4VZ+jcOs2RGWG8WcOwG/QT0CkGPEcdFkBdd\n", + "oiGJSrvCHGEMApI0CeOT5nw5rAXECBjFRgJkQmjIbCDAxiMgRSBKqEBZSChBgCZsYtEUp07P4dQW\n", + "kZpZDDwsIrT9HmQ0JH+Frl9gplWlzQDpkIEky9htE4FH1/FIRUe5dtcm1ms1Cq0WUmQfg4MG4+N7\n", + "kSQJz3N5/PFDbNo0fjGX5qfF931M0+Tyyy9D0zQOHHiOpaUWmUycT3/6Bv7qr17/tfr6+vidL32J\n", + "mZkZmo0GvX19bNiwgbNnzzI/9TSKq7NayuM3q4z1jVFumPT3xqn4/vlutrMzeJZC3XUInDKaJIFw\n", + "SOiDNFvHMQOFSXwS+CSQ2IBKFpc6FlrgksbEl7pUPR8hC/p8lWKnS0OYZBGYSGRRmKFJEEToImPS\n", + "RGEEjSEC2iRwGCaE7EvUKjUMPAZsmyUEjXoVxXFpdNrEAhDOApraT+AkCCHoBTQyLBJgUyNoN/C1\n", + "JsWOjSynsR2bNbnCQHIfpdYL1Jodhn2ftbV5ZmdbZLMaV145yOTkJNu2bfuJ63311Xu4776ThMMK\n", + "Z868gO8LhLDo6zMRQiKd1n+lT0Xuugs++tHzeRy/aD7wAfjyl+GP/ugXP/cvCzfccC3T03fy5JPn\n", + "KBQsHCfAcVbYuTPNuXNT7Nr1I6v3drvNXXfdy+xsmW4Xnn/+IM1mk717r+Xqq6+gXC6xuHiQnp79\n", + "rK3FmZ4u4XkZUqkrgYBm8zSNRo5YupfVEsw9fQRJZIgkdpBMx7CsOp4+ht1pIyjguBaCDCYhBBEk\n", + "VFQmgDUa6HiUiJHAwiVwHUrYpPAunLw6JAMISxIZP2COABOfPDYgI9FBRtBGwgAMfNrUMADdq5Fb\n", + "PEVc5MnGNCpeg6BZp9suMBy4zHcDAiEYjsW4rsfmO6vnMH2bdrfAVTujfPDKjzCdzzO0fz8f/MhH\n", + "XrUC6RfJL7UY+fM///OLP19//fVcf/31dDodcrkccL4L6cMPH+D55xeJRocRQuLYscfZu3eSm2/+\n", + "0Gt6XPyQgYE+bLuLLKusrKxSLLaRJNC0QdrNAnHXwNBM+uNpNL9MudVgOZBRxSB9IopcU1j1k8zl\n", + "S8RFBMVPEg/OsBXQAwmzU6AkzldXPN8OcMigECaDxDwp0uTJ0mUNSAEGAVECLGQEoOOj4hPCw8fH\n", + "DEDgkxYgC5mCJPDy01iORZ/nEqDSIkYTj7bbIMDCwCTGRiwvoBa4hD0XxWlhBx00Q0e3QlimR36l\n", + "juXatM02fT2X4PtNHMdC10PIskI4PMyxY2f+WWLk6JEjHHzkEexWCyUU4rJ3vIMvfel3CX4Gl1Zd\n", + "19mx40eJr9VqlQP33suEX8VqKQz2DnNyZYbJSoGi49KbTVMtVxCVCnFZpz/SR71ZgG6RcDRJQtM5\n", + "V7ZxvR4iZFBxMEUTNcijqiqKUyGNjCMChgPBouchk8TzAjpUsYAgkIni0qbOGnHW0XFRkSgTYCGQ\n", + "EIBEBgWBBvhOCwMXV/KxAJmAsm3jBQ0qeAwJmafX1+kGW+hHBQK6F7Jm0sQoUiISGKxX69SDML2a\n", + "iusUWVtuYScjSCKL25nn8MElQtF9GKEE+/ZdyqZNm7j99gf5d/8uS/YlycCvxpVXXsHhw0d59NEX\n", + "qdfDCHE+x6hcVpidPcB//I9f/JlOzH7Z+e534SW3o18oN9wAn/wkVKtwodnyrx09PT28//1v59Sp\n", + "r9HTkyUWizE4uJtarcif/ul/45ZbPszQUB8vvniW73//MWw7xJVXXs/WrRMYxjCPP/4AnU6F0dFN\n", + "QJUrrhjjscde4Nlna6hqH6bpIYRA00aBNo5TptEwaHQSILLo+mW0rS4hR0NRZIrFF3Gd88FXmxQu\n", + "UTroyJgI2rh4dLBQiOCxgkeVFiod+vGwiVBAxyOFwCDA9300wEPCQkEhSwB4FNDQ0Qnh4dHARKMB\n", + "CAJkMnIDw7cJazpdT8ZsO4SEjhtIBFLA8XyeyVKJcCTC6OgA7775AwS1GqVSnbsOn6N3bJTrL9n5\n", + "ioqkXC7HzLlzAGzauvUN78AOvzxi5FXvYn/+T/77jx07zj33PIbnnU+GabdztFpw2WU3XRQemcwg\n", + "x44d4tJLZ19X/w1Jkrj00stptXQOHDiKYWRIpzN4Xh/tapdkZBPr7VNE/DqSMJDkJoGbxhch2rZE\n", + "w5NIRnpptVRMqUAMizQ6McLYqMxi4gRR/n/y3jRKrvO87/y9d6996a7eV+wgAQIkwX0TBYmylphj\n", + "K7ST2PKS5MxxjhN78iVjz3yanDMzJ2fOaOIkYzlxbDmW4sgKZdESJUILCRIEFxAAAZLYG0Cj9+6q\n", + "7tpv1V3fdz5UCxKGlERTliFK/3PqS9Xtum/f9956n/f//J//U/UcDGIcPFws5hhAZw2TImdYZjfg\n", + "AitImpiYGCgMXCI6KFx0+lHEGASY5KXPOoJ+Cf0hNITo0XxAmxXaGJh0EeTIMIRNjKNimsql3CkT\n", + "eGk6tsFIeoBq6xoD2TFqrTpmHKJ1fa6dO8nEzhQXL56mXC7jOA7FYp4g+MG6EaUUy8vL1Ot1stks\n", + "Y2NjnD51iqNf/CK3DQ+TLhTo+j6nvvpVwjDk4Q984IfO0bvFq0ePknVd7vrgB5ibm+PKlUUOjPaz\n", + "bMP2TJG5c3NQ65JIJFhtVHEDkz5T0a8J6iqk1o0JY4kt0mgqpkNIR2VpksILawR43G8IGtKnpsDA\n", + "wUfhYRFi4KETEAMJBglYYgPIYnEZhU4HmwgHnUEkDh2SeCgc2jQJSUkNE4iBs4QUQ50pzaRt2Sil\n", + "0ElgXlcTBZsyN4VGiIvCxSAWDitxG5sqRA6dRovt2/fR6LQxjVEkGZyiwfbtW0kk0ggxyBtvnOHg\n", + "wR88Dz2m0eKjH/15PM+nWm0ADomERS5Xvt6I76cRa2tw7hw88sjNOX8i0Tv3oUO9oORnFVeuLLBn\n", + "zwcZGBin3a5z9Oiz+H6OTmeSz3/+RVZWFjlw4IMEwU6SyQGOHXuDO+4ImJrazeOP/zLLyy/wxBO3\n", + "U6vVOXToLXbvfoxXX/08ljVIrbaMrvusV14mjhcJQh2lDJRqYhjg+/NIGbGy0iKdThAEPpZsMFXM\n", + "MLPu0Q4lHl2gjiCPgUIjIkOHcSJSuNhABQuTFJIuJoIADQeJhqRMjx0fRpBDwyXa3FiuUadBb2tq\n", + "4VOgS0hHJrF8j5TuoeptErZBPlsk9mJanoeQPntTCbqAcBxWUik++Su/whe+8DRSpPjgXbtxHJvn\n", + "n7/M/PwKv/mb/xAhBM9+4xucP3KEgU0a8Mxzz7H7kUc4+NhjP9YNx00LRoQQBnAI2Ad8Qwjxvyil\n", + "Xvt+x5fLZZ588nkGBw9g2z1Pg9On21y6NM8tt3SvO3gKIUgmhzl3buZdBSMDAwMkEiHDw1PMz1fI\n", + "57dQq63TaJzC0mM64RoxDspv0KelaURtXArkgZyA5ciAjosMXSJWsGjTwiDG5BoakmlGMdhAx6CA\n", + "zzpZFulQQDJMlS4ZoAhEwBopFJIJQgQ6awSsYFMlR5sa/fikSXKSFhEJ0ujo+BRUyAaCRSQpMpi0\n", + "CNAx2YmGJEbSVR4ZobGiVlHaICrOc3XlNI5ZIfQlXjBAXWmkMnnCxgzV2Q4XktsoFrfTbnvMzBxj\n", + "794Hv++19DyPv/zLp7h0aR0h0ijlMjGRplOe547h4eueIAnb5vbxcY698AL33Hff2+rXm80mrVaL\n", + "fD7/rpxZlVIcP36S//iZz5OLDY6fX+SunWPsvXMPzU6H4No1VmurRF6VlYYLcZGkEREG54itScqx\n", + "oNwp48UeJuvkRY51dIQaxBaDhKpKGxOHDEtyli0q5jgGEkiQpQG06cchZJk2A/i00VjGIcEQGiZV\n", + "KnTIIkgSs4JCp84El7nAJBGjCAwMVoABEoygOEPAhMxw3mvjME2LOj55FBYaOpKAiBpZQipU8ZWJ\n", + "rrVBGUiVwdAjtBgqq9ewMiEpp0A3iPE6dYIgQEqJ46So11s/9Bp7nkel0mJi4va3fbaw8Cr1ev2H\n", + "+j28X/G1r8Fjj8HNdNF/7DF49tmf7WDE8wIMo/cbcv78aaJoiEJhJ15xYgAAIABJREFUDClXqFZX\n", + "6et7kJmZFYRIkkjkMYxbOHfuLcbHt5PLFZibU7z88imefPIQqdQ4e/cWuO22vVy6dJFEImRt7QwG\n", + "OpY2iiddoAb0qsekjBAiTRSl0fUtBEGbMK6w3MrSCT1iWkAA7NzcHqxjMESbi9TQaNEihUU/Vcq0\n", + "8YjooFGn97vfBZaBfnQ8HBK4DBBzFWhicQ2NAVI42LTRKOOgEWHRRyX2aChFot1CdQM8Qjoq5o7s\n", + "ELHjowPewAAf2rePJ//iCyixjX37vpvWmpzcy9WrrzE7O4tpmpx74QXunZzsmZ0B01Jy7IUX2LF7\n", + "949VU3IzBawR8KF3e/xbb51D1wevByIAyWQGKe2eLe62bdfflzLGNN/dv5ZMJvnQh+7ia187hZQt\n", + "zp49jut2kHKdpqvRkBtoyqJqWMzFVSLaWAgmxAABYMuIKKiRo0YRxQgxTQwuUMNjhCw2ihiFiURg\n", + "0k9MhRwuJnmaRFTo3fbzOCSYYoMuFdZR+HQYoM0wGhZNClRZw8DHZjslCgToLLJOi3WSNBlAMoZD\n", + "C48WXVZZRmdyMxPpIIWFroFUc9j6PMLWmJrcwtLMAjVNx3H6aYcVIqoMRWl8t0GUjel02uzYcTuX\n", + "L2/QbDbJfo8pznfwrW8dZmbGZ3Lyu14A166dY+HcGR7+2MEbjrVMEzOKaLVaNwQjX/7y05w8OYOm\n", + "JVGqw3333cpHPnLwB2qAjh17jaeeOk46czv5SCGE5D8+/QrFjMFgYQuvnL1MrEzu3H4n3dY1Ytmh\n", + "Ey5zt9OkwywroYGjAkxcdupJbDq8qnQ8BvGVSQyYGGRFgpZKoqsmTQxcthDi4JJgEIGky1WW6bBE\n", + "lwIpduCRok0V2A0kN5M0fehUsPFYZASXC3TRidCwSTOIhYuPBrxBSAuTFGkiDJrMkWIADYhYo491\n", + "fNIYGICOLV3SooUggadilLYBwsEILBbLp0AMYaULfOMbr2FZIZOTCT760e/vIaCU4urVq5w6dZaZ\n", + "mYvABGNjE9eZSCljlAp+qk3PvvIV+Pt//+aO4eBB+PSnb+4Ybjb27NnG2bPHyedLLC+vkMvdg1KK\n", + "OK4jhEE2O8j6epM4bhPHEaaZoN3W6XbbrKwsMTu7xNjYfVjWPoQocPToSUZGcjhOAc/zQCmy6dtQ\n", + "KsT1yihSSDWIlD22U6mAOF6m1ZLoeoFYWTT9EI1+NJaRZBHUAYHARrCBZCsdWmSIqdEgRYM0Nimy\n", + "lHE3UzmwDoyibTLiggIWNhHgcRxFkgnW0VEIfHLk6aPNEtClgg1qGEUBKRWBlkXKZbz2EtIQxOk0\n", + "j+zdy9233sofHn6VvXe/3X1Z0/KsrKzitVsM2fb1QKTVatGo19EaDc699dYNwUgcx5TLZXRdp1Qq\n", + "/cisyU9KmuaHotXqYJo3elEMDo4hxAlct3P9vTiO8P0V9uy5+11/90MPPUBfX4F/82/+X86evUyx\n", + "uJW15SYi2oKFSUwFQp0uAUMEZESHulwnpeXQiEAFWPoGaWUTSJ1hbJoE9LqIxEgUERKNGB2DGA2B\n", + "RR13U0Mwzgx1OmiYZEiQZxWHOinSDJAgJkUDgzSruHiMkCOLho3EQ2OIVbpswUUAPhEBaTLEdKhu\n", + "xtgdwCWSDdKaT1LvJ6FJdK3J7JWrjDu3kLUcAiS54i5W1gzMQodksotprjI+bjI6OoDvV1lZWXlb\n", + "MBKGISdOXGB09MYbfWxsB6+/ElNpNCh9T0OmKI4JNe1tzMeJExXGx290Zk0kXuLRRx9+x7mLoohv\n", + "f/sYo6N3YNtVLr36KrEfIeU2Wp1V+jKCZpCiL3UrDRe2Tm6lvLjIxvo6k6KM61eJojyT9iBerDEb\n", + "tSjikcJGMyzCWCEwCK0c5aiKHgvO0MsrRqQJKOKQoMM6GQQaJSQbmAwSY6Bw8JAICuhY9IjaJgY6\n", + "ijXyKBQ6JRwsTCQOIYoWCSJMAkIsOgQsYrEdiU3EIgkUMW2WMIiwaTOIvRm6TlgFkqbOWmcezYJb\n", + "t97K2dUyi66PUjn0MIGtqgRRhZXZSxx8eJS9e/e8o3bn0KFvc+TIBZLJMZLJcZ599lluueU27rqr\n", + "17djaeki+/dvfVc+Au9HdLu9PjR/+qc3dxy7d4PnwdWrsGXLzR3LzcKtt97K1q1nOH/+NVy3jq7X\n", + "CIIWW7cOs7jYII4DNE1j27ZJZmbmSKVKKOXTbNY4c+Z5du++l+XleWYuvIweaaSMDEfeOszw5AGE\n", + "UAhhY5ltbt8+wqFjJ/DCbUCJHm8BoAMxSs3S19fP+noOPx5C0aJAlQ4DWGjYKLqUCcjhUASuksBH\n", + "Z5AqMT4GCXwmyLFGiyRtkoAEXEz6KCKICYnRUSRRSFpYKDwMIEWMQsemRZ0uCWyxHV0U8VDkM8O0\n", + "3SFqcZvZbpWCGaGEYLVaZXCkhOe1gBu7L0rZJZNJ0201EfQ2IefOnGH1yhWSwFKrxYV2m9179jA5\n", + "OcmlS5f45l/9FVq7TQwkBwf5xC/90o9kfHjTzMb+pti2bYJO50Zzm1yun6mpLFLOMj9/noWFCywu\n", + "vsrBg3v/RnSSEIKRkRF03WLHjrtYnptB6yqG9CwlK01GZEgiCEgQaEX69ByausJq/AYtzhOwiNR1\n", + "Wo6iKRQ12hRxUIT0OIYGkgUkS3RZJqRNE0FMgxJZcpRYZIAqOjW6tDDpYGBRpFdfo6FTRMPBxEaS\n", + "oYtBhEFACh8dRYENdFrELOHSwKVCAosWVWaQzFOiyQQRe5XBNr1XBWFKyEqTMIopWCmKmk1zbY5i\n", + "ro+qH6ElLJrNNktLMceOnee1117CfYceA2EYEsc9N9XvhWEYDE9t483FRfww7B0bRbw5P8+t9977\n", + "th312Ngtb3NmffHFU8TxO9mc9ZTznge2nWBkZIShXbs4u1QhVknm1pZ58+LzZA2HTqPM3EqFgb4+\n", + "OlKiS4dLsUnFGqbfmCQtExSNJEmtSEOksEWLSF5FM+psHZtk+9R2QsuiSosyoOMDy2RooNPYZLh0\n", + "fBrUCXCpU2WDKm/h0cRliYg5FDUE9c0ANU0XEw+DNUJcYmr4rGFQJ0NAm1FgApsJJCOsoRHjcyuL\n", + "DLPGEA0G6TCOJE0OCweHiIAAgWUaJM0Mhy+WeXMtg5R70IRLUszRaZ5i+5DO/ulbufryy7x27O2e\n", + "I8vLy7z44nkmJ+9hcHCCu+/+EPv2bef8+Zd4443nmJ9/iZ07HT7+8Q+/62ft/YbDh2H/frjZhUJC\n", + "9ISsP+4GfT/JiKKIfD5DozFPp1NhdvYZdu7Msn//bWzbto2VldOk0wZ79tzKPffswHXfIJttMTUV\n", + "MjaWZ3Z2niOHz5JQY0TdDKvlJRKRjVO/TDLRolQoMD28m3rLpbfJHwESm68M0AEaCGHi+8MYRha0\n", + "ChYVsqTQqOMgSaBt8px5JD4mEhvw0DYbetRoABepI/FokOIaBeZIkgAkLhUaXKXOBVroeAzjMYrJ\n", + "FhKMsUGXJSIadOmgiSwJu4+AmFBLUO/WCeMQG5PpVJG7cyWqZ8/y+UOHuO3Aftrtazf4OjUa6yST\n", + "Ljt27GD77t2s+j4Li4tUZmbYUigwmM+jpdPcOzbGX3/ucywsLPD1z32OW2ybeyYmuH9igsF2myf/\n", + "7M/wf0gzvB+E9w0zsnPnTqamXufatTcplSZRSlGpzPLoo/v42McOcvXqLFIqtm370N84OqvX6/zR\n", + "H/0F8/MdksldKO8VDJUETWDpOoE0GTIK+N46Hj6aajCBxwIJYJwEDpqVwUiliOxZcJeoBi4ugjR1\n", + "BjHIYuGzyDLtzRKwJYYYwsShjYliEJ82LlfJkkSQQtEgxEJQoYkiJtjkW1L45Gjg4RAjCOjQxiNk\n", + "HIMhJAKdBh2uoohw0dEJgJyWJG+mieMuelwnjtr0J5Kshj4rnSr9CZu+bIK6Lqm5LkNBPwMDvfxi\n", + "p9MEfF5++RS33377DbRcMplkeDhPo7FOLvfdygzXbbJr1wT33L2b40eOYEQRoaax9wMf4JGDN6Zu\n", + "4O3BjGU5hKHC87x31I8kk0ksSxGGPqZps2PXLs6en6O+4VLsSg7ecjun5zuQKLBQnuWtmRn0OEZz\n", + "LArpfgx9Gn+9S8cLCJHk8jmaLUEYb6CLZTQjRa06i9aSZOQC47j0pJwgWEQBGhoeFgEuedbpw0Cn\n", + "QUiFDUooJpAM4+MiuYbc5EgS+IxSIMBmhhmKmJj0+hCts0E/5ua8xUgaJNBJUGMDD0igMUZIB4vd\n", + "xCyRoAkiS0c1Sdk+pUwJJXM0amsEooBBDunWiZw0yrKYW/LZZiUYzec5/dJL3P/AAzdc2ytXrmIY\n", + "/TcEh3fc8TCl0iD9/XV27dzCwsWL/Nm///dsv+027r7//ndM372f8dxzvR4xPwk4eBC+9S34p//0\n", + "Zo/k5uCLX/xrZmYC7rzzk9x2W8zhw4c5ceIoQgQkEhZjYy36+9MsLZ1CKZd/8k8e5vHHP4ZlWXz1\n", + "q99gZgaqaxvoUhJ5McrL0tDmmKpL4lREYnyKSmWOWvsyQWijsQ4YaFhIdCQuMEAY2HRFCphEqXUE\n", + "FXIkaNJAsoSgH4OQLk18PEIkC+h08AmJsPGwCfBwmaOPPMN4ZFlnlkXKm/WQkhzwnVxAa1PAqgMZ\n", + "dCwWqBECbWIVUQuqYPaTzxQJ/A2yCQNNZpEpn8V2i6Bdp53I87WvnUSpFqurC0xN7UGpmHxe8Bu/\n", + "8YskEgkmJyfZ/sADPPWHf8hkFLHcbLIWhoxs387OiQlOzc/zrUOHGNZ1ct/zezzc18fq3BwzMzPs\n", + "2bOH94L3TTBimia//uu/zPHjJzh58nzP+Orv7eHAgTuwLOtHoodefvk1PK+PvXvv5IUXziIiA0WL\n", + "TtjGjwOgSYIcQgT4ss2iiEggqVMiIkEZg1Ig8Lw2yVQf+WKI78fskpJUq46jTKTqkCNmmIgVXGY3\n", + "q8ZDbHoFuBKDNDpJ2lwgJoVFF40aGltQJLGo9cpNaaDh0CRJjI9JjEmLLfRKewUhgg5NArpkEQwi\n", + "sXFtEyHXyQqBjCVZzadgCYRwqeLhDEygJZP4YYiyA7YOb0UInWp1CYhIJBQHD36I1dUzVCoVBgZu\n", + "pPo+/vFH+c//+Sk8b4Jcrp9Wq4brzvKpT32E3bt3c98DD9BqtUilUt+3hb3vd2/QBblug1zOIZlM\n", + "UqlU6Ha7lEql64yKaZo89NDtfPObbzE2dhumadHXl2buwst8cPs0g7l+LOMcaH1MDA/QFAItnabc\n", + "nKNTr+B7NbS4jzx9NGOBaAQEUUBX08im+wjDCyS7AaoD02xQFFBQcE7oDCmfReZoMEZMnj7WGSKP\n", + "RgIdjyQGOi5LNIhIk8SmxRARTXQWSWzyIwZJfPJcI0DQBRqYNDGRmNjkEEQoNkQdWynAQZAnZA2d\n", + "rRgiRayGaHGFgrJRaPhxFdUdw9NCfK1AHKfw3UVslSEOspjYNOMuM4vXkLKE1+m8bS503XhHIzPT\n", + "dFiZu0ZiZZ5tg4OYjsP8Sy/xX8+c4df+2T97V6Lj9wsOH4Y/+IObPYoeDh6E3//9njX8T3EV9Tti\n", + "eXmZS5cqTE7eTxAEVCplJienyGRMUqkNnnji59m581cJgoBarUY2m73ue+O6LvPzazQa0wR+AXwf\n", + "oepEapaCbnP7WB/HO03G9k/z/PKrbDRjlBrYrG+popFE4NNT9vURxRB11ugFByE6G/gosihC1hE0\n", + "SRHQpAkM41PCQ8MhRGcVBxOXgHFgCReTNjkUGgbraGwjZBTIIVhFkQdmUUSsEV1P5nZJAGObK1FZ\n", + "vkZX3oLq2ggRASvkshLfMJhbKTPVP4y3scraS88wPrKFlh6S3jHAL/3qrzI5OYmmabTbbRYWFpjc\n", + "upXx22/HKJcxHId7h4cZ7utDCIEpBGsrKwTNJi+trWHbNlvGxihms6Q0jWa9/p7n+H0TjEDPV+LB\n", + "Bx/gwQcf+OEH/xD4vs+bb77FW2/N8OyzR5mc/ACl0jie9yyh3kZGVdrEGDKLQ8BZb4aAZSY1SUk6\n", + "tFD4pPBIYusFVkIXVAyNLguNNUYyfbQ6TfrlADYGGjERHoI2EBLTpIZLiIaJtmn3XsNlnRAPk54K\n", + "ulfoGZJknTySgBKCKgazdEljYaKzTIkW/dhEKC4SE5CmTT8GDhYuKXRUYNLSM3SMDk7soukhRSNL\n", + "hCKK51ha6ZLecRthWGZ4vIRhDrF1ay9tYlkWxWIRXddpNAzCzZTL92Jqaorf/u1f5ujR11hcvMD0\n", + "dD8PPviL11NmlmVRKBRuMKnbt2/XDSZ1i4unGBy8hXQ6T7NZZX39HI8/fg9/8id/wezsBppmo2ld\n", + "Dh48wEMPPYAQgocffgApJS++eIw4NikUKgzla/Q7I0SRz47+DKfmTzI4tIP19QZzixcp0SAb2nRC\n", + "hSaqLNAkZAQ9cugSYJpbiIMJEnGLYdVFx2XYSdMJJK04IsBknSQNTJLkAZc+IMkQIRKQaKRx0NAp\n", + "I+gt0IoOkho+JeokqFMnJkCQZwSPKmsM0kER0wdsoYtLAqElyMuA0wg8BrHoBcwQEKoQkLjCASvA\n", + "NjQ0qdFyDFYEuLJDWri05RIhO1Bk8cM2Ml5iV/8wr5yd5WO/9naF5vbtW/n6118lDKcxzZ7IWMqY\n", + "tbUzDMoWd+zcf50d2zU+zpn5eU6fOsUDD37/iqv3E6rVng373e9efvZjxeRkry/O2bPwHjef71vU\n", + "63U0LUOz2eSll17H90103cb3FY3GLL/3e1uxbZu1tTUajQZCCAqFAkIIzp49h+NMYtsZKt4qlhQY\n", + "wkYTKQy5xlp9g/6+IS6efYv+/r3E4UXcapVuZBJhorAQaPTKdnUgiSIkyTLjxCRwyOMi6VInJETg\n", + "IjHRiTBx6UcR0GENmxI+RVw2uEIXmxR1PAIalAgpAkP0qistFEkgBHIo6jgokghMPCpsI2ZC19Gt\n", + "BEPEzPivs+avEqiQnNNiuCswyxtMI1isLKAZJluzfTSXr2IXhymfOs3c/fczPT3NiROv89RTz1Ov\n", + "R9Tr62ysz3HngMMH77rr+hxEcUwlDFmv11k6dYpd/f24ccyzly6x/847aUhJ6UcgBd5XwcjfFoIg\n", + "4L/8l7/k2rWAQmGcTifFyy+/SV9fmunphwi6X6M8F5PDRtckvkwgqTKKz4RIEWMxpFlUpUBgshG3\n", + "sAhIofAI0PFwWytE5JFYSCQOGg5JArpE+AjatFkhg0WRLC2W6NIkRYEMG+Tp4COp4ODRIomOTxpF\n", + "lxQZDFboYwmBzRQpWuSBCJeAGkOkyeIwgoaNj0tdLDKobIJYZ8ldZsIKcNL9rHgeFa/NXjNN073C\n", + "pbPXaFJiShWItArXrh3ljjv2sXfvLQgh6HbbOE50AysShiFra2sYhsHQ0BBPPPH4O153pRRPPfU1\n", + "Xnttnmy2Z6LzxhvfNakD+Af/4CEOH36NubkGg4MFfu3XPsyLL55gdTXB5OQDm+cL+PrXT1Is5tmz\n", + "Zw+6rnPw4Ad48MH7aLVaOI7Df/g/oFhr4LYa3LqtwIc/sJuFapU3nzrOdrPJbmHTDDzKWsyG1Cgi\n", + "uaYbxLKFrecpZbbhBxGhF6ILi6zmYlv9uKFkmRhPJZEkCVBkcDaLpy0MTDQkAaAIiLAJCLApEtFG\n", + "sIrFNCZZQgQao/jMotGiQo4sVZIYxMSk6AllHSLasovCIU2EzgaCQSyyRFzEZpmiiMjqAQ3hs+SX\n", + "Gc4k2GgtkNUstoctItFgSKSpqAu05RIJYTOQtBDYnFtb4fcOHHjbfJVKJT7xift4+ulXEaIfIQRR\n", + "tM727QX6K/7b1PNDuRxzFy781AQjR47A/feDZd3skXwXjz7aY2t+1oKRXC5HHLc4efIMUKRY7Inh\n", + "W60YTSvw1a8eotl0WVjoIESKMGywZUuOT33qCRYWVlHKZH19A7QcUdRF12NMPUEku1yqNRkvDbGx\n", + "3sBOKXZsv5eZU1/Gjy10NQV0EASY6ISY9Ep46wxTJb35lAZo5LBoEhKgsOjDwCFGJ8sqMV0k2wjJ\n", + "0KEGDBMwR561zade4tMgg8ShtzCb9IwwV4EuAoVBgEGTiDQOOhH1uE0uSDCSsDAsMPRVjJRF2m2y\n", + "U9mkbAtdmCS7bU52fUSrxhbTYr0yz6rZ4fDXv86O3bv50peep1KJWFpqoOsjhFGWLxz9NkEc85E7\n", + "78ALAmbrdeyhIbYtLdEeGMCMYwZyOUpBwDeff577nniCLT+CuvpnJhhptVocP36S8+evsb5e5urV\n", + "Jjt3PkAYhmzfvos33rjCwsIGqVRMIj1J/+QeaqunMUKXki4I9TQFmWbISlPtttGEgy4qoAxyWIyg\n", + "0yEgwQpbEMxt+qa2aeKRwEUg8HHRuboZMRfpkmeeAAMPi2FGMVhmkjQ6EolPjE+bzCYh2CEigYZL\n", + "CoMUDhIHAx0QdJCUsbDIYAMhvQ6RCbJ0lc0qHSIV0cZDiyHXqNFQMTudPPlIse538YISJXsAfb1D\n", + "VwasqFO0WnVsG3K5FJ63wD/6Rx/G3DTEOX78BH/8x3/J8rKHaSr27h3jn//zf/y2FA70OmieODHP\n", + "9PQ91xey75jU3XnnVQBuv30/t9++nziO0XWdlZUV5uebTE5+12nVNC36+3dw5MiJG/KTtm1fLxN+\n", + "9Od/nte+/GVu276VfDrNRrPJpWqVfsNiX7YP2eoQxJIhaSOBDWJSho4b3UEcX6PjVtFUH6Hop8o8\n", + "1QgW2nVUHAI2y3TJIMmgSCBpY1JHox8fY1MXHuHTREOSw8LC2zT8D4iJNmttPDrEGBjEWDQoELCT\n", + "BOvElIhoAwERTQQeGjr92EyhyBAxQIJXmKaKo0qYMqY/7tBJgKPr9KkWg6GHpelU4jpXaDGpbWXF\n", + "1pBWH914DuFeY+eAwV9/9rPc+9GPct/9N1ZD3XvvPWzduoVLly4jZczWrR+gWq1y7L/9t7fNb9f3\n", + "Sefz7+0B/QnE4cO9xf8nCY8+Cl/6EvyLf3GzR/J3i5GREQYHLY4cOcvExEMA+H6LIJjnwQcf4ckn\n", + "v8KePR8kldrGmTMXqdc7vPrqZZaXl8hmEywtreH7MVK2UZqBrzQ6co3hYpG8BQOjaQpCZ3BwJ5cv\n", + "n6EdatjKoUsF8HFI0aVIzw2kiI1DEgWUAQOFhYXBAJIYezOR4jNGgT4Ea+TQyNJEEKKRBmwGadNF\n", + "YGJh0qJGtJkccjZfJj3Z7FUkAh+FTQOT4c1ONf2AjCOCbkCCGEeE2Nk8WSfFZT/GCaoUIp91FPt1\n", + "A1NGFKwMcdBlupjn+JkzHD36KqurHZaWPEqlO75nk+HwVvUNppSif3SUD//CL3DkmWcYzudZ7utj\n", + "5tw5unNz5Pv6GBoZ4a6HH37XbVjeCe8qGBFC7KYnLT6mlGp/z/s/p5Q69J7P/neERqPBf/pPf0Gz\n", + "mUHXczz11EssL8/z7LOvksmMMziYIZGIiOM65fIVPA8y2QJJcxqrukImjqiFEZ6n0Q164cBq3GIQ\n", + "nwodXFKEGGRxGcYljWCBkDYmLQbJb6qpOyQps0bIMII0Xao4NGmQQzJOnZghJIqALBoKB4syBll8\n", + "JAl0wk1rtCIGi+ikMakRYuIQYVAhRCGJAY8mFgObC58gj6JJjaKmKJJiSjPQY49V38VT0EFjWBRJ\n", + "hDH15TVsM4VhKjrJGkePfoHf+q1f4bHHnmB0dBQpJS+88AK///v/FsfZT1/fXuI45MiRK5TL/xf/\n", + "7t/971j/vy3lzMwslnVjPXrPpG6I8+cv33Dsd25q13UR4u36kkQiQ7Xa/L5zfvc99+A4Dseee47G\n", + "3BzFoSG2HjjApZdOU91YZ8BOk0451NqCPqFTjupEMgESpMoQeVUcZSFRXMIiyRTDsUMdnxbrTCMp\n", + "ENGgQ0iNJDmuYXEVjyIRAp8qBhtITBpUOUtEgMYoBqMIIKSF2gwkJRohOjqQQJBAp0tECaiiU0Yj\n", + "IkUDkzwSB5cOLjaKBC4WMZrSMFSXSd1ksVVj2HQYd9I0my3G0alJHzPRZSw9QNlf5u7hYabG+rnn\n", + "np0MDA5w/KtfZWh4mOnp6RuuZalUusHQrFgsckjTeP3NN7GUIpvPU+jrY851+R++h9Z9v+PwYfjj\n", + "P77Zo7gRjz4Kv/M7ICW8i24XPzUQQvD44x/hxRdP02gcB3QSCZ377ruLdLpApdJGiAxf+cq38Twd\n", + "x0mRz2/jmWeOEgQ1hCigaSWkdIhZB9ZJWZL+dD8BdSbvuotTh17j9ddfpNkEP3QwN3Ue0CYAIkx6\n", + "XOVqz7MJA0EJRY2IDhVCXCLmiYkxSeCSZ2BzW2nQxSAkxCDcNHvow6JLihThpn5sjiUGSVClS4EI\n", + "AcwBCg2JQ5YCQ6QpM49FhI5AwwCp4RoahulwcSFi/9CtjA4WWVi8yka0gAhXGUdQ9z1WVZVcqUjC\n", + "smislvnc577ClSsdlJpC12v09fW0NolEhmx2B3c/8ggHNpnTZ/77f+fk0aPko4hiGNLodtmYn0cZ\n", + "xrtqv/KD8EODESHE7wC/DZwH/lQI8btKqac2P/4/6bmo/kTjlVeO02rlGByc5tvfPorvJ1FqB3Fc\n", + "w7L2sLHhMTwMw8OSffsGeO65M3SaddJRgCYEjqmR1rJUugGNzaqULpIUMToRtwD5TVszG2ih0IgJ\n", + "yKGxhTVc2uj06tVLmGTRyRAxS4sZ8nTxuEoXQUgHjwCFwAS20OISF1kiTWpTnDqMoolGxBANYmos\n", + "oSNpYdJEIACJSYKADhtomJuNpzsMUGbMtLkWuLSloB8wpeICAkgQyYA8bTTyGMom7XdpBQYDA9Ms\n", + "LS2TzWap1Wo8+ed/zuEvfYXkso/InmE9aJLK7yaV2sIbb7zC66+/zsDAAPV6nVwux9TUFKapbxoI\n", + "3YieQdE734q9RbCNlPH1qg6AWm2N8fEBlpeXyWQyZDKZG/5OCMG+/fvZtXs3p0+f5uTJ0zz91Fdp\n", + "ri2ghQax8IjDCKF0grhFE0kY2uj6GpoyEbpBO/Rps4bGCDE6y0QoFBpDBFymSEQGnwZztCiQQLCB\n", + "QZ0EASliJGlqDKDRReKh4xIBOpIu0IfCAsqbfShaSLKcp01qvD7QAAAgAElEQVQHkw6SYUJMFB1g\n", + "gzothhjCIcAHPLIoDBRJaiSVRaiZaFKiZIxnaiyHHRIEJAT0CaiGy6w0qpRSabZMb2HfvmnGxkYB\n", + "mEilePPEievByMrKCufOXSQIQnbs2ML09DSaprG+vo7b6XDu3DnyUhJGEbVEgt/8V/+KycnJ9/qY\n", + "/kShUoG5Objzzps9khsxMgL9/fDmm72S458lTExMcN99+wiCMRKJNI6TQtM0ZmfPks/n+cY3jlCt\n", + "JshkBvH9mIWFDTqdKpAjnR4DLgIOmiaI5SLtMOKtZostW8fxpcS2TFqtU0TRViwCBCtoDOCQJmQD\n", + "RURAFUgSkqRCzAgJdFwsQhQOZWxgCIlPnjV0rrFOgRYSKGEhiSltWse7pDEI0YAuDoOs0yXGw8ag\n", + "DEREJIEUFjqKFgu0SG86DwUk6VX2VVWH9TCiHCq6THBhpcpAIs9Q3zjlDZ1VNkhHLjkipAntyOfY\n", + "zBUoTrNr10PMzT2LEAXm5yuYpkE2myWK2mQyaVqt1nWmuhOG1JtNzHabjKbRXyhQ932evniRY0eO\n", + "sHfv3vdsfvZumJH/EbhTKdUWQkwBTwohppRS//Y9nfHvENVqlW63y6lT5+nv38fKyipB0MvIGYaN\n", + "EAqlOkCSIDDodhv81m/9r9xzzyn+t//50/QXJlmLoO16BME8kXA4HdmkEYSAj4GkxTQShb0Z20Ib\n", + "iY+GQUxEg5AkPcOcKoJdCJrE1BikRj/FTQ2AxCOkTMggEG326TVQFOhi4lNGQ9DHCiaQQiNJSEST\n", + "DBGTSLJAHajgMkgEWFRIskGOChlCNGKsIOIWJWkpDQ04i0OLUYZJ0iTLOhKLBnacJtBCymtnqdU+\n", + "wqFDV2i1PoMhNziQy5DtRtj5CYJAMXvpNRYzNZKpCVbqNT7z6U9z7/btpOn13LGGh3nwsceIotOE\n", + "4RSm2WNN4jgiCFbZs+ftroBRFFEulxkacjhz5kW2bz+AbSdZX1/m0sXDxFWdr1w5hyclW++4g498\n", + "4hM3sDErKyt8/jOf4cLRY/iNmG55cdPpNOKa18SSCk9GLBoa7WiQnNnCNou0/AWkqhFTQ6cPiwEc\n", + "BBERGjV0uhiYCJqUsDAJMamwDvSRQtKgTUSAYoQSOTQCsnRpcpkVQjQEQ0gsFBtAA41xIqpcYRGD\n", + "ESzySGLmWMehhWSQDvnNZN884yQpIYmISRKRQCcgwgwjZpWGpxQ50yBqNqmaOnnDhNigZDtEhRyf\n", + "fPhhHj5w4AZaNWHbVFs9a/hXXnmVp58+hmEMomkGR44cYv/+ET75yb/HoS99iXsGB/m5J55grVYj\n", + "jnu9MJrV6t/yE3zz8Pzz8NBD8B57OP5Y8cEPftf/5KcNy8vLXLw4g1KKHTu23dBJVtM0PvnJn+Oz\n", + "n/1rPK9EIpHDdTfIZpsMDSU5d65DsbgdTdNRStJstllbWyKdHmJjY5m+vltpt7t4Xo0o2oGuu3T9\n", + "LhfOrLJw+b/ihZJu1we1wShlBA51FmhiAn2AApL0DNxdyrTwqZInRmAQM4RgijwGEU26XKafDerE\n", + "FMnTZg6NcXzU5loxj8M0Eh9JihYQksMgyQAaDgE6NSJcFggYQSMmJM0GFjENFJcASUwKnTImDUok\n", + "GaIddHnmwmV2DxSJlc1qbDNpSNKZPJatUcrlWKrU6Zu8lS1b9jA+/jrnz18glbqNpaUlgqAOqs7l\n", + "s+d45elFzr7yCgcefRTh+wSOw1y5zFgyyZrrsi4Et05OUrl0ifn5+fe8IXk3j5r4TmpGKXVNCPEB\n", + "4EtCiEm+T4O7dwshxP8D3Am8rpT6n36U7/petNtt/uqvvsalS6sIYfP66yeYmkpgmgk0zUTTdGw7\n", + "ZmPjEkqt4DjDWJbFXXfdgu/7jI6Ocs++IRbmVmjJDUJ/DcNrEsnt+OQ2Q4cENg2SzLCAzygGCSQV\n", + "YpbRUCiMTYlih5Cev1weQRMdF4NFilhoCARpUljkyNPCZYYWXXzSSBro6Bik0OlJJvMkyVAhxiRg\n", + "iRUMRgnpwyGJxQAB/bQ5RUABg0Wm8Slu2vBoxOxUMesIdHQa6EgGEWQIgTQedTJ0sSnLRdYJMe2d\n", + "9PfvJwiWSaVu4cVvfJb7PnGAbDbJtWs14q7GVKrIpWiNYuoWymvXkBdj9j/88PXg4PLyMm8eP87H\n", + "P343zzxzDOgJIqWs8Nhjd7ytfXWlUuFLf/7niGqVpFJY7VVePz7D6MQ0hh6yOxvx6LadmIZBLCVn\n", + "T57km0LwiV/4BaCnvv+///W/pnL6TaIgQdZKcn++xJsKKvUaBdXFSSdY9RV+YppsJ0Wf9KgFF0jI\n", + "RSaVywZpKphECGIgg0VEP10WEcRscjYU0LiMTh4dRRYDo9cviCYRbbrkN+8YGCbiGk1AIakCNlBE\n", + "RyfGI2SYFL2eSgECjd24nMJmBybWZp3OFQI0khj4SEIiuig0TBaUhgtsIybp+9iaRhiGvOX7hI5D\n", + "f6mPR/buZandZnFhgWqlgu04jIyPs9JosOuBB6hWqzz99CuMjNx7PWhUaopTp15jZOQVupUKpc0K\n", + "qdHNbr+xlLz41luEv/iL1/VE72f8JOpFvoNHH4XPfx7+5b+82SP528Wzzz7Pc8+9ia73Urnf/vab\n", + "PPLILTz22MHru+2pqSl+93c/xalTb7K+Xmd8fDu33baXP/iDP8K2j9NuL5BMlqjXr9BsXiGV2oZh\n", + "ZEmlHDodlzhuIEQ/hnEVJSWhnyefv5Vm5zzIETTOoZBYwqGhQlwEMeP0qhrTCDIoDARXEQzSZIkG\n", + "VTR2k2eEpNCIVIRLlxY5TrJOkgwlxlC0qHEJMOn16O2JYU3kZvOPPA4xkyQAe1MvEpBGMoGOwmIY\n", + "GCDCImJhc1QrKKroaIyRJkmaNLrIUlENzm3USaYzDBUHyY6UiGWEjCMu1Ks0DIfR0ii6bvCRj/wy\n", + "QnyRy5dPEIYGQ4PDRBuXePyeae7fuRPX8zj+1FPUGw2m+/rAsnCDgJRhsD2X46LrktM0qtXqjzUY\n", + "KQsh9iulTgNsMiSfAP4EuO09nRUQQtwBpJRSDwsh/lAIcUApdeK9fl+j0eCl55/nwqlTnH7jDFpq\n", + "B3fe8zFsO0EQOLzwwlH277+bIHBpt2u4rkEqlSWV2orvX2NkZJKZmdP8xq8/D52QlbmrZJwJHt73\n", + "/5H3prGWneWd72+9a97zdOap6tTgKteEy7iMB2wTaAyGkBA66ctw3YTciI6UCPIB3VZ/iJA6Uqu7\n", + "o1Z0OyhRmktDAuFGEC7pbsaA8YApj1Ueah7OUOecfc6e573m9d4Pe1NxAaHB4Lbh/qUj7dpnndpL\n", + "a9rP87z/4a28cOESz609jWQCiUmWJBKNmAwOdTx6XCbAJaZFbmwDXMengcssgklUNtBoYVAii0JM\n", + "DxODiCQKCgYmoJBAMGCWLUASMcBjBkGCiINouKzTHmec2Djo6AwpoJEnRsWhj0UKQQGJSp4MCg6S\n", + "Pgajun40IIQUMatoKKRRUGmOjXZy9OgS0mMNVT+OnVrE9wdMT+cxDBMRF/j2E6eYnypw5sVT2Mo0\n", + "qp4jivpUWufIqg2OTd1ErVZjbm60BLA8Pc13z5/n7b/+6+zfv5erV1eQUrJnzz/7IbKrlJIv/83f\n", + "MOd5zI4v7KNLS5xeW+PmB+7i9KOPcuymUSECoArBoYUFHj91isFb30qtVuNP/uiPGJ4+Td6NUC24\n", + "Wi8TGCa3Ts3zTTdk6CUoZBMsxjGr0qHm1un7faaFy2E1wo7h6ThDQEiPDiEZFFQ0VEIcQvp0gAEx\n", + "O6hskSbFHApJfKpoDFhCx8WlT4CkgiSJRTjuov4xHlEZs0VCKkh2M8DAR44XhVJIlgkpo7EXhQGC\n", + "kDZl0gTsYUAPSRmDDkVcUizHPm36DLstckLDUAW2lHQieH0uT29zk6d6Pbz1dQ4UiwyiiKdOnaLw\n", + "hjfwW697HefOnQMK1wuR8f1KNrvI2bNX+GHnkesbvdzb9zWHhx6C3/3dV3svfjTuuw8+/GHGjsev\n", + "9t78fLC1tcW3v/0CCwu3Xzc+jKLdPPzwkxw8uP8GR+1CocDu3YuUr17ie2ee5dwzT6MKhTe+8Q08\n", + "9dQZ4rhBGG4wN3c3zeYKqlrDsg6jqgk2Np4mn48RwqBVNzCtKRL2FJ1BGUvPEURHGQbfY0MGwBwg\n", + "0NlPwA4xqfHs20PBw8BBoY2GT588XXWevuzgyzOMBLlHqNJGsEMFh8x4xqqhUCOiT58GOXQMOoRA\n", + "B4PRtFoQ4qMiMdHoYyLYJmAGddy4+KhExNgEBDRIs0SGAX1C+mikSGHTigYEkcvuuSluO3yCWrfF\n", + "wOlj9bPMRS6aOmocdN3kvvvexa5d54EyfnObd9x1G/NjrljSsjg6O8tqs0kjitit6yyPG5Fyr4ed\n", + "z6Mlkz+0XP7T4CcpRh4cH9nrkFIGiqL8S+AvX/Ynw+3AN8evvwXcAbysYmQ4HPI3/+W/kO/1OGzb\n", + "VIfgehVeeOpr3HrXr7F79yEqlS2uXj1Juy3xvB6qGlAsHkfTciBDHn/0G1hRh0XNIo1gITIg7vLI\n", + "43+PZ+5DAXQUNHwCHBQyQECfgDVsVJZwmMFCjDNzn2GCLC3KwDYmLSxcIEQjTYiCgg+4jBTloCBw\n", + "UTDGZvIqDh1Ckvgk6WADGWAXPdbxsVC4xDQKU6ikAJUI6FAjHq8wDojokGSIwwQ+DtBnxNQeEhPg\n", + "4RMTk0RBo4OPpYTEiocmDTwlRTavYdsOhw/fyuXLK1zbbqP326QWFjCMiMBdZ7u3wdCwWMoqTOam\n", + "GAwG1Go1ZmZmEEIghEBlJAP+QULkD6JcLhPUasy+5AGkKAr7p6d59rHHCAcDEqXSDX+jCoEJPP/8\n", + "8/zVn/4p9toaJdclaHcJ9IAlM8FztU1sBJZtkTJtmnGfZqfGXCKLHbSpxUOiOEZRBFUZ08VHoURM\n", + "GZcOPdLEtElwjf2ENIAyMRsU0dmPhk6f/nUKa3WcwayQQhKgUkMisNnBoYxgkZAEkiIenTETaJSF\n", + "E2OPfUQkKmJMalUYoiOAPCF78PBRUdDRmURykJAQGdWIKeAS0ZQe+Vgho+ukcxMMai1aCZ1FVWXh\n", + "yBHa/T5hGHLTvn0MbiAc/3BhoSgKyWQKfWqKSqvFVD5//XdrlQp7jhz5pZiKlMtQrcKxY6/2nvxo\n", + "TE7C3BycPg0/QpH9C4nz5y+h61M3ODCrqoZpznD27MUbipFLly7xtU9/mv3ZLAfn52n3+5RXL+I6\n", + "Kd72trfzwgvn6fXaeJ5LqZTi7ruP8/DDj+E4KVS1zMREkWTyFhq1U2QTecIoQgiJEBGx3AFMXCZQ\n", + "mEVhjYg6kggFG0EXhRCTiAI2ETpF+lzjDJ1oEZXz6MSoHBgrGW1AGcenjnygTHTSNEnTpYuOREfg\n", + "ADO4xHQZjBtVFxUPHwUXSYjAH89lVAQKMRYhMSEaKklisphsscJA5gixiNmikM4RDnRWr64SuS4y\n", + "jgnDHn5BZeC2OfvCY+xcfR7Vd+n7Td753l/D29KuFyLfR8q2mSmVsA8c4LEvfYl9rkus60SpFHsW\n", + "FggmJ3+I/P7T4H9ajEgpN/6J9yXw3Zf9yZADVsavO8ChH7Ptj8WZF17AbrfZt7hItVrFHYYETpv1\n", + "S5foDATHT9zD7be/hZWVCCkDrl6NaTZjGo0acVxDRE10cswYMUcyC/i+Q6XTJdJDEkOftneBBWJ6\n", + "tDGYJqJFk3ViFoBpAhL4RKgoJIQgjkfJMS4wi0aDGvtwsAhocIUBJhGSOi5pdATzODj0iQiYBCQ6\n", + "UEXDIUOXKiYGDh0kFh4xLWLAJMYkHlvES1wCAiIS6ECWKTwCNtgkjUGAhzc+0J6iEiPRZcSAGhr7\n", + "sLQMUvFxwzJ5tYXQJImpHsdeN086nebKlStcuVLFzGXYGW6y2mkzuXiE8upzTC2VeNeJE9QqFc69\n", + "uMP2YIBpWZxstTj+hjcwDAKsYpHsS8Ly/in4vo/+I7psU9cJPY/0xATtfp/cS8LZvCBgCDzxjW9g\n", + "dLvcsrDA41vbJPyQbmuLSFExZchZ5zw7uoUTK5QMlRk7Sd6yScQhi4rgjJQ0gR6COgEeBoISkhaC\n", + "Kik67KOLCWwDDUAlT4xFm21iJhAUUdnNFo8zyRADgUEGiUIfh2OoQJvLXGRIHoc1dNrk6dGmAOTw\n", + "8VEJUOgi2UCQRhCPKbBdHCLOYZGgj42ki4NLB5jAE4KSTOCRIasM6EV9HKmgtDr0Bgk8S2N/KUPs\n", + "ebzjJWsRz127xsbGxviB8l2CwH/JMo2k3d7gne+8m0LhLr74qU9Ru3aNjGnScl2CQoF/8da3/tT3\n", + "7msRDz8M99772larfN9v5JelGIlj+SOJj0II4ji+/m8pJY9+/escLBQojqMH8uk0v3LkCI1nTyPl\n", + "KocOTdNun0fTPBYXl2m3JSdO3MvW1iq6rpJICHTdw7RG53joVQiCPq63SRClEGJmJAGmw6gPr6Ax\n", + "A0gkBtrYfkyngGQHkySzdBjwFdKESA6iIvDokEWlh0qEhUMakAyoUGSbJKlxly8oYdGkimSRGjtM\n", + "o6FhINmkQ0ADQRaTOg5TgEdAABTGzicBPVpMMI/BLIIefbrUUZRtiopNLZAML5/h+OIykYioeG0S\n", + "yQXaO89y4bnnyWk62VKB99xzN8PVVc5vbXHb3Nz16TNA33FI5HL83h/+IUdvu41vfOlL6EFAPptF\n", + "37OHX3/Pe155ae8rhA6jRh8gy4h5eQM+/vGPX3993333cd999/3I/2hrdZWJ8RdTtVKhubXCdG6Z\n", + "XbZNvVLm1KOPsuvwPo4cuQnPC5maKpFOF5BSsra6yslvfAenWyWnqghFQVN1TKFQH4TosUJOcZnU\n", + "F1GCMl26OAjEOEtmpHmxkfgjOlGcQMMhiYnPRXRMJvAxGGBikcbGJY1Bkj5tavTRaRCTISSFjkRh\n", + "kwFJOuQAjTJZBG1UYloM2UYhg04F0EjisYlDHxDECFT65DGYxaSLTZcsdTavFyLngAkZYgF5BMs0\n", + "ucz3iKNlEkYKtAZWwmXx6OsIrGnW11dIp3exs7NNpXKRfN5gZvZtXGjt4LnXkOlZ3ro0T6/TwWg0\n", + "uHligs1kEiuRwG80+Najj5K7+WZ+7UMf+omY1tPT0wxUFdf3sV7SrW/Wauw9fJi9N9/MP/z1X3Nz\n", + "HFPIZOgNh5zd2WHu6FEG586RtG22yjuoIsFOMBipnGIYSIUaNhktTyeo4jhdwuGAuujQikaKk2mg\n", + "KiVrWAgEgh2GYypxlxYJquygsIqKScgUI1OiDlsEpFDHMeKSNj0m6BKSoEESA8EEGim2uECRgGVC\n", + "KgzoEbOExiwKz7BGGx2DCTQiJFuoVEekNCqMXEdChkyhYeEywKXKNHlyDKgQ0qaIkHWS+HiRRguF\n", + "taiArkwwmYy4dWKGodflwrVt3vaS4x4xklQXi0UeeOB2vvKVp9D1aVRVw3EqvO51Uxw8eBBVVfnQ\n", + "Rz/KubNnadXr7J6b48CBA/+kxf8vGh56aEQSfS3jTW8ayY4/9rFXe09+Prjppj08/PA54njXddVc\n", + "HMc4zjYHDz5wfTvf9+lWKhR/gJdgmyY3Lczx5g+8C9/3WVjw+NznnqRWmyaVylGp1BkOK3zsYx+i\n", + "XK5y5kyZ7amIjWuPYGOgyRx+uIEkh2CbmDyjZNs8cImYPpBC4qMxRMGixSUmkICOTkSWBiY2zjhT\n", + "V0MS0yckjUWeDDuohCRI0SSLg0objQgFizoqGSwi+hRZoUaSASo6CSJSRDTp4aPQJ2KaEePkCnAz\n", + "Fnl6nGEHnxJJRjGeDj0Wk3mW8Fjrd9mxpjjZ2aHeqVBMGmjnLmCEPu89cYKJdJqW43D+4kV+5d57\n", + "Ob+1xXeef54js7OUSiXCOObF7W3ueM97EEJwzz33cNeYX6brOrmfg7/Qq1mMnAQ+DHwBeDPwX39w\n", + "g5cWIz8OmUKB+oUL+L5PZXWVg/NFyo0WQ6mSz+SIYpezz3+dt771Q3S7Xc6fv0g6fQeqqhLHMUHo\n", + "Yps+QagShAG+HxBHAVHgI6WLZVokDYtJKTDDNhUsLIZjVUQJlCyK9IDL5ACFDC1eZDd9pnCoE1NB\n", + "5SYkq2TJsoxEoTxerumyxoiuqI/VFRoQoGGgM0WRDiZJdlAZYKGS5woKDl0EBhFFUlTHlfw8YmwB\n", + "Pxjn+WYwmRqXPDv4HESSB7pADYVFDAQ+bW2TXpRBKEX6CZW6V6JdCVGUDa5dO0e32ySKLKan72Zu\n", + "7hDK/BHC0GNj45vM3HqIMw8/xO0zM8wvL3NPOs2ltTX6rRaVIODB3/7tn3iEZ9s2d7797Tzx5S+z\n", + "K50mbdtU2m1qhsF777uPUqmE8uCDPP4P/8Dz166RyGS4/Td+g1Qmw3fPnWNxfp4nXjiP7QX4mHgE\n", + "9OOAa4rGhDDJRQNk7CHRkbJEBgOhJKjKJj0CQgQLZLFYYEjMFkMaFBEkaJMnyTRZVIa00CkDTWAP\n", + "sISGjklmbE63hcIuBvikyWKh4o+VVoskxwssESFdqnjEmMyRQOUcKjYRsIhCFochFygjqGOisYsh\n", + "KQJCUuQQmDg0KZCjiMt2nGadCJst+qTwMInJklZ2IRkSWAb1YUxKJhm4LknLojsY4FrW9XH4XXfd\n", + "we7dS5w9ewHfD7jppmMsLy9f9xJIpVKcuP32n+h8/qLhO9+Bj/7c6PSvDO69Fz74QQgC+CVYGWNx\n", + "cZE779zL448/hW3PoCgKw2GZ22/fdcNzQ9d1VNvG8TxMXafb7SKEIJFM4kvJ7OwsyWSSr33tMe64\n", + "4y6uXdug07lMHLvMzk5w+vQ50ulZZmb2YRgp2rW/YtDTGIZpJClUJLEcpaUrio6UOSBLzDPoXEES\n", + "EaERkMEkT5uQDjuksQGVFAMCgvFTRBtHgJgYXGISHwOFbUKGzJLApIBKDwWYJ0GHRRyaSNKkiMZm\n", + "8DpXsPGZZ2QP32dktVZkpNE0iChhUqLFFsNxxrDk5tLNlAyDXDJmzrtAV6kRiwVuKS5RVC1qOxv0\n", + "hw2+c+oUdx44wPzEBJO+z5lLlxhUq6y5LufOnycGFg8f5tcffJBbbr2VRqOBlJJisfhjl9t/Wrxq\n", + "xYiU8rSiKK6iKI8Cp38W8uqRW27h89/9Lma9ji4lywuzhKLMpWqTyWgDVQS0m0MeeugaELO5eYZu\n", + "t8b09AFcr0EsVtk7P8Xmyhqb9QoJJUHf8wlkl5ZwkFFAKayQMCcgcujRwVMUckqJlGrRinxCaePL\n", + "IhXZQqfCEgOOYqARkEPQQOdFYgQ5BoQ4qARY4xD5KSyu4ePRJUOEhyBCkELjEkXaY/+SeQqUsHEZ\n", + "oDJgD5IrJHCZJEENBQ+dJAkiNBr0mUUhYkgeGKKxQEBm7EWSYyQQvqxIprQ0cVwkVAQVDHQlzcpK\n", + "nXz+LlqtATMzu4jj5+n1Kmxv1ykUVpmf34OqjiZDhw7fjN5tc/tL1nbfcHTEb3782rXroVU/KU7c\n", + "fjvFUonTTzzBarPJ4h13cP/tt5Mf8xQOHjzIwYMHCcMQIQSO4xCGIX1VZf/0NN8wTFb6LZIihSdc\n", + "thSLJZFiJnTRNJWCouFjsRN5ZISBkAYJMpRpsIROiEk8NnefQjBgiIdJjt0UUdFRsDBpoyKpAwYG\n", + "XTIUkGOXlwiTBC3EOJvIZDTXSCCw0Bji0cHHpwgUGIlq2+jEHMKjySiOPEWCEgl0nPGkKz8uVF1i\n", + "YjQsHFxidjDQ8bmKxYAl5rGx2cZniEI7LjMp57jQrTO1fJT+sMLlzU00w6CtabzjAx+4QRo9OzvL\n", + "7Ozsy7wrfzGxvg69Hhx62YvG/2tQLMLyMjzzDNxxx6u9Nz87FEXhHe+4n5tv3s/Zs5eQUnLo0NtZ\n", + "Xl6+YZoqhOD4G9/Io5/9LN52izjWAUkr7HHLu9/J9vY25XKZ7e02Bw/ej5QK5897aNoC1arD9773\n", + "EO9////BgQOHOXv2SfL2Lrx+lYS2G5QEblAhlnNADiGGRFEL8BAUETiMIk2XSZAgHhuYgaTFBTyS\n", + "6KhYVIgAjwTQIM+QJVRsDJJATMiAAQKLNAo9BGkSBDjExOiM+G8ClRYDkvgcQ46VdKPn9iSjpYQQ\n", + "qGKTZoKiEuCLRdRoQNLoMmVNEMddTD1F15ekMwXmbYuDiRzrlR30QCWhZEkNh5y7fJmg1yM9Pc3J\n", + "Z54hlc/z/je/GaEotPt9zjWbCFXlv37iEwwqFRTAKpV423vew8LCws/lGnhVVfT/Mzmv53mUy2WE\n", + "EMzNzaH9gOi/XC7z+ONPs76+hVac4tnVy2y12zSlJC4V+cjb34aUks9/+wzzc69j164RI216+iau\n", + "Xv02i4tDzp/fYXZ5D+efO80w0ulKDytoIYXHUInxZQktbhAG26ixgiZDbBHR0+ZJqEmC2EdRAmJq\n", + "CAYMpEYeSGEyIGIUrCSZRGOLiBYaLjYWJgY9IhR8NGCCGG08GdGRpIioIaljodNHRSWPwoh4qmKh\n", + "YyMoUeQ0LllsZlGpYTKLIIOPRpl1MlSpEpEaZyv0UElhIICQgFBGdOMYJRbkVWgZHradxnFSNJs+\n", + "qppBUVQsa4LhMCYMu5TL29j2SJuzsFBkaWmJ6toa1VaLyZcQGxvd7k/MFflB7Nmzhz179vzYbS5e\n", + "uMBjX/86XqcDuk5yeprza2uYmgHJOdbD0aMkHcZMKTaKIvGjPkosSAgTI/boBT4+PnUkGikYW+4r\n", + "1JAk0UmiUWXIJCqCNiEaI/M2lzQhbTIMkGMnEmMs2RaECGpoZHCBCMmAIQW6dFGpE9EnR4p5EozE\n", + "3xFpNtjmGm0CcgwQBLQpoLCJR5ssgiwONRQMVFQEw1GeheLSlTUKWMwxi4tLgzpdEhRYoq1WMM0s\n", + "U/NF9h+5k3b7GfInTrC4tMRNBw78EBO+0Wjw6KMnOX9+lWTS5q67buH48Vt+ZqfF1zK+L+n9RRAG\n", + "fZ838stQjMCoIFleXv6x+SZhGFLeqfOFkxfQhh4F0yBZmkQtLvH5v3uES2sQhipPPXWWatWhXg8p\n", + "Fk8ghEa5XEbTbuKb3/wa09PP8PzzT9KtuRAlkSJEU87UAcYAACAASURBVFVC2QWmgBRR1ELT0kSR\n", + "ATIkJEaiElOkQZsiw/FdbiFIMjV+hkyik6BMBYchA3LYhBSvSwViVPIEdBkiSY6ND0cKnSYRISli\n", + "QOLiss0yEsFI6qCMf7KMloe7CIoUcFBoAIFiEGgJkBpVt0XeFoS2RZTNEml5Mkj8MMRzHAASVhYv\n", + "GBJGEXIw4OL6Om3f566jRzHHI7eJXI6ZXo9P/6f/xAPHjjG1sMB2o8Hlixf503/7b/nDP/qjH7Jm\n", + "eDl4DVr6/CP+3b/7c9rtGEWRTE6avO99v3pdw3z58mX+43/8v1lb6wIWvt9nakph/xvfyIzvc9v+\n", + "/QgheOyFc7SdBEdf/4+tjmUlCII8jz56luPHf5UDB7IY1kM88tB/x9QMSlN7mSyUOPnct5h0PPZq\n", + "E3g2VPs1hPDQTA1drdDoRwiKgI8flxEih64WsWKPUOo4OGTHCppRxRvTx8HExiUiwCGFBNpjqzMb\n", + "hXkUUkCdiBQ+GjVWyKAxZNRZBygExGOCk0CgkSRDgixdmvRYQ47Z1irb7GFIB4UhAkjRHl/cJoKY\n", + "BA493KhPUSToqTHZ7Dy2ncY0Nfr9AYlEEkVRSKVydDplJiezJJMW+XzAvn17ieMVdu3aRSaT4Uuf\n", + "/CRdx6GYTtPq99kKw5+YK/LT4sKFC/zDZz/L0akpsgsLeEHA2WvXmDl0iGytw9nHrjH0CmjCYlD5\n", + "JlEQIonwI59IKGT1JKrn0ZY+MRpdbAIcMtj00YnwSCDp4RChE+MzRCUHBAg8BD4WMWsEeORRCKnj\n", + "YeMDBpsk6TIgJjPufDLUsPBZGzPxBUtEY/vnJIz7rBJDmswxYIBOBZMaXdpIYpKEdIk5jE9EAkFA\n", + "BUGFvoS+kWTox1ykQ0wJ2IOuWvjUUWKHgVOl19C5/NT/y71HZtg6fRpdCG45fvyGY9tsNvnzP/8c\n", + "UTRNsXgc33f54hefZnu7yq/+6tt/7ufytYLXsr/ID+JNb4L//J/h3/ybV3tP/tfhq1/9Jl/60mlm\n", + "Fv8F6XSOXq9Cy1lHHwbE8SEMY5bFxWkuX67w2GOPMDl5jFJpVDw3Gtv0el0Gg5DV1ccZDieJAhWN\n", + "DrbcIQxb6OQJqAATKIpAShNVjQnDMtBiRHOMUYjok0VgI4mJqVBiQIDHVUIiQkIWMAhRGDIqZdQx\n", + "myTCBhpk2QFcDAQeGk20sSwXFKYZEuLRG39yf/zpU4yWaXYYZYP3hE4dSZUZVDWFEDlCv4uaijlw\n", + "9CjrtVUW3/B6NhtJVi48T58+ke/TkyGa00MqIZVmj14YUbFM7jpxgltuuumG497sdLC7XUrZLN95\n", + "+mnam5uIToftcpnfefpp3v2hD/Gb73sfxWLxZZ/b13Qx8swzfeLYBiSrqx2azc/y8Y9/lEQiwac+\n", + "9f9w5YpLsXg7ppkmjkN2dl5EVaskD8zxV989STFpc7XaZmLPrczMzhLH8fWubn29ytTUFBsbFdbX\n", + "T7OzU8eyDzCZaHH7oVuxDJtL5x9ml99AY0hKSZC2VWb0JJc1DT8OSGazGKrN0DXo+rM40SyqWsNU\n", + "LIIwoIOCioJBzBCXBgoqbWK2RsobHFz6SHxU5onYwmI/o8wDn5Fja5odLAy6OJTRKOEREuASsYmk\n", + "SYTJAAUDDwONRdK0gBDJBCqzZLCRXMMlIsQde8gahHSJaIoik4qJJGBgl8hmC0xMzOF5bbrdHcIQ\n", + "oshGSpdkskMuN4Fp+kxN2UTRGv/8n7+ZOI6xLIvf+lf/ihdOnWJ7c5PS/v2898QJpn6GWOkfh5Pf\n", + "+hYHi0WyySQwUtscW1ri8UuX+N9/+wPo9pM0GoIrV9apB7soN1awIxeNBIoM2PIbdJQYVUb0SdIm\n", + "QxqVDgNsNBwEMQ16QJ8EGhtETNDEoEgKA4UWVXQCcrTokyNBdpxnUSVFSERAkTVyqNikMNFpEbFC\n", + "jEqRGA0PFY8MQ0IkQzJY6Eyg4JPHx8FjhVFSUYhAYiLwiLDo00TFIyDLVQKUKImu9tC116PJ6fE1\n", + "rxOSJAzXyYjz3H/0Xt549AClbJY4jnn2qad4cXmZ173E0vPkyacJginm5kaTKcOwSCSO88QT3+PO\n", + "O0/8TA+d1yqkHBUjvyhf7vfcA+9/P3gejPMhf6nR7XZ56qmLJBILBIGJricoFHZTq/msrp5mcfEA\n", + "zWaT8+ev4jg2QZDi6tU1BoOYqakCjcYqYVgkiuoEwQRxnCEhfNQ4g5QmEdukmaPNCjHPoWkF4rhJ\n", + "FK2RTksGPZ14vNAiSWBQRKAS0MDAYoiGTZsWMZI8GvvxqeOxgwlI+kQMyGCwwwAXcEkCfTzKTNDl\n", + "XnQsApr4NEd6Ry4SUABsRuw0D1hHsIpGjIUZa5jaHgwZY6oOsVBx7Bh19x7OBW1uftPt3HL8MJ/4\n", + "k0/hGzq9fh+nOyQlXGw5pKEpTFoZrnoBd7/zLSxNTl5vHoeuixcEbFSrzExOcunaNZzNTUr9Pv1G\n", + "g/koQqvX+fKf/RlrFy/yr//4j182mfU1XYwkEssYxoihPxx2efrpp3n++Rc4ePAAL7ywSjb7Bkxz\n", + "NFoWQqNYvJnvfe975PO7safvo+Y0IHWZjbWzDGpdFF1nYe9e9uzdS6u1gabtZmenQSYzT7FY4OqV\n", + "p9h2ewzcPpZhkzQTJIZtErFDRkJdgctDQSP2CI0EpmEipUW+kKdfP4MhQpRwCyGHNGgzgUoDlRCF\n", + "Cjo2sEiPIRcISKLgMKDPgKOAjyAmxiAmxEIngYoQLkGcok+PPi18VAxaFBklRnaRVIEETTwS2EAf\n", + "FR+TBD0mAAUVnQgLlR0EkgGQp0lIWxmNGLtKlY7UyJUS6GqFfq2LN9whnU4zNTVLPj86xvv2HWRm\n", + "poBtd3n3uw+xtLTIE088yxe/+B0URce2JQ888Ebuf8c7XrHrIooinnziCb72d3/HvG0zOTnJsYMH\n", + "mcznUYUgqSjMzs5wyy1TrKy43HLL/Tx10mbzVJN9aUG/WsEMY84OA9Z8Ax2TSMwg4pgJklTYRuCj\n", + "E+DTpIuOzZBJ+iRpMcCgTBZIYdFCkmCfInhebtKmhYVHBuW6e+sdaBhYCHR8RomdAR41IKJNliUy\n", + "mHTxUfGJaGOgEJJFRZLHHRv1u/ToMeqPVFQUJJMvyQmOmJ7KMOxcwB/6CDVAxiBFSECXRLrE/bdN\n", + "Ml3IUW93SNk2lmGwu1jkhSefvKEYuXBhjWLx4A3HXQgVIXJUKpVfymLk6tWRkdj+/a/2nvxkyOXg\n", + "wAF44okRofWXHe12G0VJMjmZp1qtkEhk2N7e4dyZi7Q7NZq1p1lZgX373sDU1CzgcuXKi5RK0/h+\n", + "lURiAcNIsb19DiGOIeM6SdlBU1Ij4rocZc9oxARKFUXxUBQwzR4zM3u55itoYg995xQRC8RYRAxR\n", + "KJPHJELQpTdmlCVQ6GGyQ48mSTw0bAJs1oEKWXT6pGnSp8wsQ1KoeIwsFzQMEkgaJAkJeQaXHB55\n", + "YlYw2EYnYJIQCx9BGDvMmjaRFHSVHe69d4mPfOR3WFqaJ5fL8a9/7/eI66v0Gw3KjospfSZig56d\n", + "JmOVWMjlyUQDvKHH1M0389Rzz1GpdTi3VqczjBgKhzv3z9BfW2NKVdmpVgn7fWQUsb9QIC0l6ydP\n", + "8vm//mt+72VGSr+mi5HvFyIAiUSGWi3F+fMXOXbsKP3+gJmZzA3bb22VkTLDxMQeZmeX2dra4NRj\n", + "jxG7ayRKDjOlfayeepKN9eeYnJR0Osp1h9Bs1mD38h7On32OtZ3LdAcNmsMmeX9IPmnT1U00pUTR\n", + "tLjSXkdVkxhSJbYd3DhEYYDqnmJJSOaNDJVIpUePAV0iMoQkOUSEhiCDgo5KjyHhuK+VKIRATJdR\n", + "VqSJAxCHKDiopIjIk2GbeXQS4whrD7iCR4M+DmVCJjBREDjobDKNgkfEEHdMa9U5T4ZNRkRTW9FA\n", + "vYqeTkIcs5jRmJQeatRjPuPg5gXpeZft7VNks1mWl5c4fnyZd7/7AZLJJJ/+9OdZWYmZn78LIQSu\n", + "O+Bv//ZhUqkke/fufUWui29+9atce/xxbs3lmFVV+u02Dz/2GL9y770U0mmGUlIqlXjwwd/ixRfP\n", + "8OyzZ7GVNT78vz3AYDDgiVOnCLtdXiclrK4jwpgmAwJRwpcBSlSiQ4ygyQFmuUKPA3Q5MDZx9hmy\n", + "ic8GXZYpcoGYa7JLBoFKCo9FrmLgI5jhLAEREp+R1dyIhOYT0ecwJmsMaBKRw8VHp0IOhwmyxCPt\n", + "Cx4+BioKFhlqdFknZgbIIhmFNaqKRJgKCVvg9IvEIsCX6+i6SQCki1kMq8BGzcbSDcKoQ+L8Br92\n", + "11EMTSPwvBuOcTabotEYYFnJG96PYxfbtl+R8/pq4xeJL/J9PPAAfOUr//8oRjKZDHE8oFDYzXD4\n", + "XbbWTrFRdkioGUytTzFt0Wl5XLywRqk0ja4b7N6dRNddLl6skkxOAVvkcgaum0bqoPa30eSAjKLi\n", + "yhohApUkgUwSxyphOEBReiST02jKJYSvopMjoI5Hg9RYuxghaSIJyKEwgwRSXGUR0JnHoUefBm08\n", + "HA6SRh9PTiUaHofwWUMnwEJFjE0SDUJMfGwCFulTZ40aJjZzFK9z0bbxGcZX6bgemqqQnJrgE5/4\n", + "E6anR5PRv/iLv+T8yTPcVtxNNZugKYZ0emW6qsEubZqskWa702d2eZ5hf8A7fuM3+D+ffI7vPLZJ\n", + "RqRJZyfIptN879IqS1qVXMJm2O9jSElsmhRTKbqOw0w+z1Pf+Aa/8+EP/1Bi+0+C13Qx8oOI4yGp\n", + "VIJkMsm+fXOsra0xPT1qY8IwpFIpUywmyWQKdDp1HvnyX7LLG6LGkly0xrWNNRaWlukEDrO7l/nu\n", + "46sEwT4URVCvXcJrPcPCtEon3ESpXeJY1mJAEqGq9AcxjhITJkOSc3tRZcBO16dfS6JIBS9MM8Uq\n", + "epyg7nroWGRQSQIVInRSDOigoxCjo42Nfkdjv5EKZuRyMVoK8PAJgJAWghwOk4RsMYeHzdzYBDhE\n", + "JWYanT4ZbAIyVGniMI2JTYiCwMfBQjCDwgoOOkkC+hSMNDnbZULNk0uoXBhskG5XEPoEqmayVEqw\n", + "tG+WcNccH/zEHxMEAZZlXVe07OzscPlynaWlfwy5G0V37+ORR556RYqRVqvFhSee4O5du9g2TS4+\n", + "8QQL+TzRcMjz588zMTPD8vHj1wmzt956nJtu2k935SyL+Tz69DRz+Tyf/MIXuLK5hfA9DA28aB1H\n", + "ghtr5AhJ0sakwcbIN5b9SArEGGP3jwQR27hs4NMiTZMOJjEeBlAiJocgyZAaWzRJ4hPRI8SgS0Af\n", + "A0GERRJBnz5dfFxKbFDExiVmxKd3cAjpjQW+ginMMbk1IBh7MypI2SOXKKDILPMlHy+TYiJnoWsG\n", + "qhCUey0mZhYoJmbIpwuoYopWr87Dz11k/9Ik+97ylhuO8113Heczn/kW6XQeTRsR2er1MoUCN7hh\n", + "/jLh29+GXzTftne+Ex58EP7Df3i19+SVRy6XY9euPP/9c3/BTZrNlfpFYmdATbgsTs6iG10c18Tt\n", + "D1hZeZaZGcGb3/w+arUyKyvfZn6+wGCQw7Jm2Vp/BiXwGMgGBX0KoYQkgxA/DhhSRXIEoiyaMiAI\n", + "Klw99wgTps+m+zzheDI5pEBIhD5mejmESKYQ+IDKBAMMCkh8LEys8QSzxYAJ8gxwadIgQ0gdhQSS\n", + "Mj7zqIy+ExTq+BgUmUIjYjcuQzJExExhY5NSXCzpUzfmmbCvocQRm/U2D37gd7nt4C4m83n+9n88\n", + "xLKeI22l2Ilr5JKzKG4TS6q0RYhBB5UhneolxNQyW1tbXHhujbccv4ekNWo8/DDgzHZAU/c41djG\n", + "cxz2FIvszmaRQEdR2GVZVHWdZrPJ9PT0T31+X9PFSKu1Qjo9N05gXCef9zh2bCQX/YM/+Jd87GP/\n", + "F5VKiK7n8P0usMrRo7eRSuV4+pEvMu267MlN0h263Ll7FxcrFV5Yv8BCMknK0Cn4Fa5d/QK18gZ2\n", + "Y4uEEFiaiuLr7D12mF36HlTH4ezWFtc2msRCpTi7n/3FBU6tPMlwWEaEBUy1QCx7ZIkxqBKgEWEx\n", + "MpafZYCDS52QmDlMJIIUA3wkXYqozBByCkEe0Ig5i4KHRUAKlz5TRDhYDMZDuZGtToTERJIjwiJi\n", + "FDjtMYegQUwbnSZ9poEEMTtKREXqLJgKXe8iBCUMNccWEWu+SywTeLHKwaV5FASNap1TjzyDf/Ys\n", + "hCHvfO97mZmZuX5+ut0uqpr6ofM2Mhla+aH3fx6o1+tkFAUhBMWJCZid5Tvnz6MrCjudDr/z7nfz\n", + "5vvvp1wus7Ozg2ma1CoVXnjxRXquy9B1eXZtHUsKDufzVFpdkopgEAxpyvNkRYogdpkVAck4Znuc\n", + "A1FAIGHM65CogEXEKi1cUtgcxKA5NnAHgywRgj4zlNlhHh8bD38s3A4Q6JymSB4diyp9kvQwsKii\n", + "MYGKgqCLRhmXPB4D7FHXhkSjjoKOx0h6aJpL3H33b7J1dQ01MkGepZRZxDA0au0qrdYl/tnb/wBT\n", + "z7J29gwF00RTEzy/UmXy0DK33nbbDcf5wIEDvO1tNR566CRSZpDSp1TSeP/7fzaXxdcqpByZnf37\n", + "f/9q78lPh1tvhXYbrlyBV2gQ+ZqBlBLF6XL3Yop+w+Ga7DGrR8yqFu3IJqmpDIx1/KFOPv867r33\n", + "Xdh2Cs8bcu+9t9BuG1y58iSDrassSIEIE3hyQMuvoGgJMoksO/0ukkVM0qhIEtYEA1fF8RpUvT4G\n", + "XZK0CZA4OPjM4WMA14AiGioWLSIa47yxNt9XyqgIDFwcNtkmIKJJmj5JNDqE7CKkSsgFRubzLQRt\n", + "JrFJ0UQyyhuHOWJqVLDII6VHEkkl3Gazb2Ia82jqBJdecCmvvsDdhyfx2j06rkZQCNE1laHbBzxE\n", + "4NAb9MgrE0wKhdhQyFoWn/vMZ0hgXS9EAAxNZzaZxcnM8oa3/wpf+7M/Q2garSCgHMfsmp2lF4YU\n", + "du162ZPT13Qxks936fdrgEKppHPixAn27Rslmh47dow/+ZOP8vnP/zfq9W0SCZ19+5aZmzvIYNAl\n", + "aFcpZvL0hl0yCX0kia3VCIcOW6FGIemh9zo06quYQ4e8uRddzxEEbWRth9PPnOLW33wPvUuXeOuh\n", + "Q3TiNfxoF7GeZavZQLdmKCUc+p02brCKwCciSZKIHjEBJUIMIgJ05pCEtDlLlwiVAhoZAvqETGPh\n", + "EqIjmRqTExexaGJSZYoVZqmwiUcWFwWJwciwS4yH/0NiYoYkcQiZpUuEIKCrSJrSpIdHDp2MzLMb\n", + "HTccohIjjASVQCNh7iZjR3QGfVZ2Oij+M0yGAZGqkUgX0FTJoUSCb3z2s+R+//evV72FQoEo6owe\n", + "Ei+ZbXc6dRYWXhnSaiKRoO151DsdHjl5kpTrcmhigu1Oh342yy233cZX//7v2XjuOXKMXFtfvHCB\n", + "Ww8f5isPP8mVay16jkVCMbhoCSw1RgybTMqIkgKzeoSwsoSaJJfIUGjucHLoE2sqMojQx0I8BxgC\n", + "eUwskvjk0OmQoM2APgFd4vHyW5IEKsGYrJYgh4+Di4tNiavkMCkRsAroTKMxSwOHUTi4QoRDl9FD\n", + "UpBEIAjojK+jSaCGbeq02zViRRKFLmnbR7LNTiNNJlHCNJe5ePEKt912K0fuvpvNtXWGnksxvZff\n", + "+uAHSSZvXI5RFIX77ruH17/++PWibm5u7pdW1nvmDGQy8DIDR181CAHveMdoqeYjH3m19+aVRbvd\n", + "ZlCt8ua776LT6XDx3IvEcZZcapJe0CNtzjGfEvhyhampSVx3QKOxSRRtUSiUWF2t4neGHEjtRwQ+\n", + "QdCgYE5gdnfYEB5Nz8YlM1r2pIUpptGlBAZICoQETJBF4uBTJ00WhyodNCAkwyS6EjJtaNQ9h5A6\n", + "Eh+FFIJJLGy61FDxydGkiYOHTxadAIMNPFK4dBHUMOmzG4sCSXx0FAJGDW8fhR5VpuiRR6WDRz9W\n", + "CdiPG5iYuIhIpz+4mcdeXEFG81zzN0lWt8Br4rcrJIVNUxmyW1UInCpX8xnuv+Mu7rntNj796KMQ\n", + "ukg5yukC8AOPzqBKfkrjQ7//+7hxzLc/8xlmdZ3ZbBZhmqiTkxy5886XZeMAr/Fi5F3vOs6LL15B\n", + "01Ruu+0Qb3rTG2/oyo4ePcLhw4fo9XqYpkmz2eSTn/wi5bKF6wwoJFQa7TJHlnfT7PVYaQ+5PMgw\n", + "q++ivmrisUi/f5VZOUcUpdA0ST6/SBAUKTeeoOd5yFyO7VaL/XmDL595Eax5ZmdmGTQr/x95bx4k\n", + "2XWdd/7u23NfKmvfq7qq9wVodGMHsXGHCIKiYJOixSFjtIwkygprLE9MTMwowjOyJyTLYUsOx4Ql\n", + "DYOSg/s2JAASYIMglm6A6AVodFev1VXVtWZlVe758u13/qhkiwRAUwKaACF/f2a99+rEuy/znXvO\n", + "d74P2dKxZQZTDCKkwjIzuGygIbAo0URhAwOPPhwahKQRDOGLEUIMArmKpIjeKe/pjODjo7FIkjVC\n", + "GtSJ2EFIiTV66GeZCIMyXeRQ0dnEYRmf7QgECiVUXCIQAlVLkUjlyVZX2CFyCARu6GGEFjY2ZekS\n", + "s3Yj1IhqvYwIA4SWYqHh0mtGpCKHs0sX0IwR6rZNr6rynW9/m8mpKeKJBNPbt7N//xgvvXSawcEd\n", + "6LpJrbaBbV/h7rt/+bo/DxcvXuSpRx7h7JkzPD43x425HNMTE0RRhOv7jI2N8Zf/6T/R7fvcOj6O\n", + "lJKrp08z5nl8+dEjODKL74aoUuJEXShBL7VoEz06w7Ci41MjlBFELrYd0AgChnoLyGWfY16b/Z2f\n", + "FZuQCygd3RaDOGXWWKebiH4kl1jGJ4GNikmTOKIjHN+Hi03AOgV8NvFYRTBBmxwac/gE5MmQBFJA\n", + "QJsWEh0HQZI8slNxs8mgsYyu9ZKyeogldK5e/haJXB92fZVYrELdyRCzUrR9wfZd+9G0fk6dOsX7\n", + "3vchug/dRLm8Rjqd+W+WVJPJ5M+N+/OLhCNH4L773u4o3hgeeAD+4i/+8SQjUkrOnDnDsWMv0Wza\n", + "9PVl2bt315bycueYUqnEwPBOrpyfwXZjSCFBkZRbVaa3Z/n4xw9RLJYZGhqm2czxwx9W2Lu3m81L\n", + "LzMY76FebxAEFn19vTiXbEzfp67uZGuAtoeQFoHcwI2SCKGhSLXTakki6aWFh4JKikHaRAjaCHwk\n", + "0A4CYnRTx0bDJkYfESabVCiiENDDCmdJ46GTpNSxvUtiImlygIhnkaj4+NgkMHAIENToRiUOlDHY\n", + "RKMXnwgXjQQRBnm9n6pbwRcJ+tIFPL/IjuFBZmYFl+vnuUHxSMXjLLk2ga5gduU4NDzAaszi9oMH\n", + "sQyDke5u3OYSq5uzdKWHWS1dobx6kXZzjd7efXz329/mN3/nd5jato1TTz1FXEpELEb/zp2878EH\n", + "3/C6/0InIw8//GE++tEIIcRP1alQFOVaJjYwMMDv/d6vcerUy3xp/YeMmwoHb7yPlStXmC8WuVC3\n", + "KPRsR8EiFiuQ04Y4v3AKTTewrDiqGqHrFppm4FZjzCwu8on3vY/lpSVePnIEqW+imAbFWg1Lb1Ai\n", + "hSK7CVA7VZBeKswy0Rm29Tu76KtUcOhCMo5PGuQGAo0kLgEgqaEyQESAYJZhVujHJMRCENHCA0Ic\n", + "AoZQsVBZZhNnS7yYQSR5UngIWmKFPtGFp+hsGt0s1UqMGXFCH5zIxcYmwCPApO41CMMy+ZhORiiE\n", + "uoZlxCm1FV5yVuk3ChSlwa7MAb59bAnpzZFNxrFuvBE3inhW03jPP/kn5HKrHD36Q3w/oq8vy0c+\n", + "8kvXTZXvR5ifn+fRz36W3fk84/fcw/+7uIhTLPK869I9MMDEvn2MT07yH776VQ7ecw+e5/H88yc4\n", + "d2Edt92mXCyRFg36pdlxd7lA2V1FUfbiyyFa8gq2CEiRQLpxND1Bud1ivWLjJXop+UVOSge9w+VI\n", + "IBlHsEaDJm2GOgoCATBAkyVsFNJEWGzZjmfxcZCsM4EKJIjjoeAyAwxgASF12qjUkbQIOo6dggRb\n", + "LJ0WDlvEMJUUqBpCLZJM7CSf1enOZKiHBtZASLvWIG3lURWFlhDs3beL2dkVSqU2s7Mvk0ymMIwK\n", + "Dz30K9d1nd6pOHIE/tk/e7ujeGO4//6t2Gs1eIOb0l8ofPe7R3jqqQuYZoHTp8+wsdFA149w6NAY\n", + "QX2TnOdhVxrkcn3sOpDkpTPPUwpVmrUXyQzl+MSnP8a73/135kL/5b/8Lel0L7bdRjdN4ok49XqL\n", + "KPJYWztHGLYJIp1UdpJa9SIyrBGQJIwWCf04vmwRsQZ0IwmICDHowWUNnQwQECNJyAJS6oTRVkU8\n", + "wGYOFYMWkio2ASYuaYoMEwIpDEzSRKwiSJLEI2KNJgZJUjhUWcfB6Cg+S2qEuPiIjvHeLLOoRPRj\n", + "0sCBsIiUJjEtQ6VRJ58O2Dk2zHKpTKWicUW0yRsGo6MT3IBk0fMYGhrEs23arkvMMIin09z+3nu5\n", + "9MJxzs1+F3W9yFjMoH/fBO++807OnzzJ9zWNBx56iNvvvptyuUwymXzTEg6/0MkIcK0sHEURp0+f\n", + "5oUXTuM4Hnv3buPmmw+9pryczWa55553sX37FF/5q78i8jwmDx7kYiBorzTpEjqVioumNVBViUuB\n", + "ctQmpZg0vHWatosf+lQ0wdgtt/BCqUQ7injZhr7B23A8Qb1VpdGuU/cXOnLAfZi4SOYokCPAxaJJ\n", + "PyoqKhYaF2hQQ+nskH1gBZOQLIImVTxWkFhkWWYQCwXwaJDBQ0WhTURIiV5UsljkMfA6ImpJxaIY\n", + "OQR49EmBrdTxMIiiAEvRaEeCTdVDRpt0AwqSCh5FXNrUSMRG8F0oxHRUxaThB/ieQdvoYiSp09fV\n", + "j92us3Z5ifs//B6mOmp79VaLJ776VX7rD/+Qe+99F57n/dwmLZ5/6im2pVLk02lsx2FoZIT9sRiX\n", + "y2UO3nknuVwOKSVhEKBpGjMzF6hUBGBytbxM0jJu0wAAIABJREFUX6SyEbYo0GQADUHEChvMy3NU\n", + "yVIFFBnjvG8wKARR2KSpKazTw8DoFFVeJl9eJUvYYbtDEhcFlxV0LEZRSWLTwGeTBBU8JC46G7QZ\n", + "QOLRZgAdHYMKEBHD7FBZ50jgoKCziUedHhS27qTPZdbppUDAOmvUaDCAJIFpOPSlcwRUKNdLSJnE\n", + "823uvmOaSj1Js9m3JYgXBJRWVrjnnls5ebLF+Ljg4MFJ9u7dQzqd/m/c9euLMAw5d+4cp06dI4ok\n", + "Bw5sZ/cvgO56EMAzz8Bf//XbHckbQzK5NU3zyCPw8Y+/3dG8OZTLZZ555gzDw4d58slHkHKc0dEe\n", + "isWrPPvsIo6zwRntMlmvgS7j5AfGyB68h/1mhnrdxbbLXLmyyPr6Oj09PQDkcmnW1pr09Y2gpNJs\n", + "tDdxnBKeFxGL5bCjBm19kMitoBtZIncVEfkELOHKFJJuIrZTp0KIR4oGCpCgSZuzeHSh0iSNQ4KA\n", + "SEo0QrSOt7pLHQeDLgJiCPpQ6AOaRGiEpDCRBJRQyJDBpkVIQESWJG2iTtUli0DHp4mCz5ZlXz8h\n", + "NyI4j8MZGuTDHFXpgJS43hpJPaJcrhGP6UwP7mR/VjKkaeTSaSqVCqvnzrFSq1GJItx2m1fKZbbd\n", + "eCPv+9CHeGH/MVb/+I/Z1T3B2LZtjE9OYpgmu4aGOHriBPe8+93kcrlrAw1vFm9bMiKEeD/wZ8CG\n", + "lPLOn3X8N7/5KC+8sEhX1wSaZvDkk4ucPn2J3/iNXyUej7/m+IGBAT71+7/PmVdeobK+zoRmcmzu\n", + "NA3PwgvLSDWi7gUII8NyGFCzL6JEMXSZox7YJLpGOHD4Vu67724ef/xJvvitM7ScHA27RbWRx26l\n", + "kHK94/qxhEEBCDGQZGjQjX7NgzeHTYoUAS5NNEICNAq02MBngxg+KqtAiQwBLZKotEnRJEdIhRAd\n", + "FbdTCNwSLzep4WEjaUQBc2hkhEZSS6CKPlKKSTloo4cZ1qIio0bATjWJDANU2UaIiD2q4JxaIp7d\n", + "T+jqZOI67aBGt2ejaClSKZN2KkXcSnF59gQ5K0fqx15e6USC2OYmCwsLTE1N/VxHPotLS4x1/G3i\n", + "lkW2UKBWq5FLJPD9LSPu5Y0NxvbuZa1aZXFxHc8ziUSSCANfuiRwmcJAQyciopc2NbnJJj62opBW\n", + "EsSjURap4ouQtIxTrydonV/BbvvESQAuBRRMQhq0WUWhxTixjuiRZAKXFA4aChEqcYo08aiSRhCx\n", + "JWVn04NglQgTjTZF6qTJEVFkDImJRdhRZtyGzRo+kyTpRXCRVdbJkrEyJGMh9aBIKt7NZrOBIddZ\n", + "WdJoNhrMr8wxlpmkHYasrq/TPzLI+Hia3/iNT73lDrtSSr761W9x8uQq2ewIQgg+//nn2b37wlsa\n", + "x+vh+PEtrsh19Px6y/HRj8JXvvLOT0ZWV1cRIsvm5iq2bdLV1YOUEaVSgyjSGB+/m1yuTjaT5tnv\n", + "f4lRM0MoNfz21ijv4GCAlMP85V9+ic985pOkUikOHz7AyZNfJ5s9yM133Mszj3+NllMkFqRY8xqs\n", + "Rm08MU3ogK610PUhFNaQfgxdH8EPs/hhD6oW4vovESGJMUeMNlUSQDcBIUlWyBCnjY+gQZIMeVQ2\n", + "CKgTw7jWrm8SIEkR4BGiIDqTeG0ctrx2NJrUOk3abhR66UXpMA9TnfRng02G2JIKiBGSVTdA1bEi\n", + "lYZfR4oWSW2cudVVWn6D4d4kN92wm7PHjmE4ztYGLpXiOzMzJHM5yk88QXpkhN/+1V/FNE1uOnyY\n", + "k4cPc+erpuc0VcWQEtu2X/fd+0bxdrv27geO/KwDV1dXOX78CmNjt16rlCQSu7h69QynTr3E7bff\n", + "9rrnpVIpbr1t62/Fyt+i6sepejkaGARNG8XKks5tGSIViypCjGIKhb7hLj7+8Qd5+ukZ9u3bzczM\n", + "JRSjC6elUG8pKH6anGgjhUdb5hFs4uKi0sKgQQpBHBCEgIGPIIWGTYk681j0ENuS1qGLOgY6FjVU\n", + "LAIicjQB6EeionYcDHRW0Gni0oPGJio+WRL42NRpqgo+KZp+HEsRDMXj9Kghq6Fkw/EZ8BpUhdbp\n", + "Q/qkUIlpFnNRhXL9GKOj26jUlhhNhfTEuzhV92llMwSJYeabLUQqSX/BulaJCsMQ13WRYUgURW/6\n", + "YfhZ6OrtpVIuX/O9ObRvH08++yyNSoWuZpN1x6GZSPDpz3yG73zlKyxWK7QrPnaQoK6bGPYawwg0\n", + "AgQhKhEqkgIu66KGGzmsRAqaCEmbOQoRVMI2vmzQanuEhFwhTpUkZWxcKngISh3p5hJ1YkwTUgNG\n", + "EcSJqCFoI9lNmRlqpDFpkCTd4cprCFIU8RHE6aMGwAQhLg02gBg6XShIHAQxUorFNAFJa5W+0TiB\n", + "LxnNHKDlO5hqnR4ni3ulSC6qUw0j1tuA0kUulebk0S/wf/7p//qWJyIAc3NznDq1zPj4zddarrlc\n", + "LzMzP3zLY3k1vve9dy5f5Ed48MEtzkizuVUpeafCNE2k9PA8ByG2ntNWy8ZxArLZFLqewPfL7Np9\n", + "C7l8D5cvP8H8vCSb7WJsrMDU1DYsy2Rx0eb06Ve4/fbbGBkZ4aMfvYtvfetpMpkYuw7u4ZincGXN\n", + "xtT7CJwmvr+MIvpBCoSh4bQ30fVB4rExaq0yQimjKAWEVcD15nEjmzKTSMZR1R5CKbgqV0nTRpM1\n", + "hsgR0ouLjUuaOBZtwMeiSYIUATnaCFQsoNH5PVqjjkOOMgoByxj0kqeOgk+EwCVPg0pHfcSmjkaD\n", + "gIppcVfXKLbrcqm+xLlAI50dZnp6HFW41O0K1UqRrsK72H3rrVyemeHM0hIzts2DH/gA+6eniZkm\n", + "fhDwvS9+kd7eXgqFArF8nmqzSfbHHqq26xIaxhsmqv40vJ2uvVXg7+VZsrq6CuRew+TXtBhf+9qj\n", + "bGzUmJwcZvv27eg/xU+7VCqjqjqm6WH0jlCrFXGcSzhOg0RCYWRkG6nUAJommJjopaenh2KxyeXL\n", + "sxiGghXPsLB2iUYjgSV9wjAkKbUODVGgM8tgp4S25b24Zam0jkMNQRql48p6FYV5QjzUTvmtBw0T\n", + "g4gkm8JDlU1MoIWCgUIVSQqLDbKsYrJJSIwcJjplAVKtI6Iq7ah3q4cZxZhtrdFjCWKmhxEI/KBN\n", + "oGukhUaXmcYPAooIjFQX8STce2CAneO3c/XqVZ5+6SWcRDf3f/C3KBS2WjKnTiRwLn+fXC7HxYuX\n", + "uHhxEccLuOA2GbvnPqanp38u/jM/ws13382jf/3XxC2LZCxGJplkcvt21vfvJ3fDDRT6+ti9dy+J\n", + "RIL/4Xd/l8vLGxz5wnfRzH7C7B0EjSV8GaAJCGUTXwoCITCkS0Z4DKOxIBu0ZAUlyLEhPUoyThRl\n", + "UGhhkCSiyAYN1sh3zL8XCBlEZxwXSZ0UkhVgGjpPhY6NhoLcGpamhIOFh0kehYg6q1RI0o9CAZ82\n", + "kEXFEAZIlxKSGAqakCT1Fn5YR0Qhg2qcM5dn8YMJVlKXSVhtxoVLT6GfjaUmeUtwRz7NU7UFsqMq\n", + "d980SaR0v8Zs8q3C7Ow8ptn9mmckHv+H6xFcbzzyCPzrf/12R/HmkMvBbbfBo4/Cww+/3dG8cYyO\n", + "jpJK+dTrEbA1qef7Hp5Xp1DYQbu9wfDwVvslm+0hlcpy3303MTDwk4aaiUSepaV1ms0mMzPnqFTq\n", + "PPjgu4jFYrzySp7jxy/Sm99JV6qLpfUKdXuNIJwlijYQogtFa9FyUtjeKqAhpQvUMM2QdGYYGKNe\n", + "XwFeAnQUJSQWVMlj4GOSJUMLh01CItK00EiQJINGDQ+DkDgNXCI2aLOGgo2HwwAecbpQaGAjiaPQ\n", + "BJSOqEDQ2Zr41EWKV1SPMd2jz1BZLs3QCGE+EsTNGJacJ6P3ceuBPYz27uALR4/y5OXL5ISgkU5T\n", + "Bh7YuZN7brjh2n2LmSZ91SpnXn6Ze+6/nzvf+16e+Nu/ZUcYUshkthx819e5+cMf/qnv2jeKX3jO\n", + "CGxly+D9xGdLS5d55pkfkM93k8u5vPDCUcbGTvJrv/bw6+78PM8lnZ6iu3uSVmsdKQsIcYBTpx5h\n", + "cnIQw9hFOj2AZSXY3FxmYWEB09waWd23byd/+qdfQGjdKGqOwFfwow0ibBSSaBSJUyVFHAeTDXxm\n", + "cbAAHYGGQo0aJfpI02YHOkkSBNg4BNhIYqgIYTFh5VhrR0hcfFR8wESQwceghIWByiguBiExsmaW\n", + "ml+gHS1jkKKCwKWNkDHm2xeZJM8UBm0hcKVkDZWiI5CoFIMGOcsk02zylcceIz88zD3vex+/+8lP\n", + "srFZ47nnZlhaqiKly9CISWL0Th49eozNxQaxRBclEbHtpvfx/e9fIh6Pc8cdr1+huh7Ytm0bU3fc\n", + "wVe+8AUUxyHV3c1N99zDrz7wwGvaQ8lkkqkdO0j2nMP3+7H0JLaRZ8XbIKFIUkKi6yp5z2MxDLk5\n", + "nYG2Q8XXKWJTDZJ42IQUMNFQyeF2Jp5MdGIMENGgThudDA4NdNZJYRGxQYsr+PShoaDQIksdFejC\n", + "J6CLNer4VBCEHcXFNDFK5NCIiKgQ0Y3syMfHaAhBSwgSnkOGrRHkZssmFqkklIhos0JFrLAr202p\n", + "fRVpmix7AWtlF1/EsBJd9OaztD2PoNPSeqthGDpRFLzm8yh6e+L5EUolOHduy+flnY4ftWreycmI\n", + "rut88pMf4XOf+xq6XmZu7gcYRpqtgmgbw9hkbGxLE6dcXmX37glWVpqvuY5tVxHC5N//+7/GdTPo\n", + "egLXnaVYnCGR6KPRcJFuRBQ1kCKiv7CXavMEMoRAFImirYk2RRlHCEEQLBFFPr7fRlFUuru3kUop\n", + "bGysbfmn+VvjtzXawCZOx0NqawR/jgRxfBKYDKAzxlUcymyQxcemTQIFm0FcklTQ6MHDRNCmixIl\n", + "EkSkO78PW6olCoqWQbMCArHJaDbNbFBnyc8RhVkUstQClW88e5G665CNm8yvrdHwfbxmk51DQ2SF\n", + "oDgzw1ldJwq2vpu9AwMkTJPa5iYAu3bvRvnkJzl25AgvXrxIrdkkmckwf+EC2VyO7a8y1Hsz+Lkn\n", + "I0KIXuALr/p4TUr5sZ917h/90R8B4Ps+q6t1urrGSCazeJ7DiRMvomkD3HjjTXR3dwPDzM+f5vjx\n", + "E9xxx+2vuVZPTx+JxGXa7RaZzDBRFLGycgldT9FqNVlcPIFlNYjFVPr7B5mbW2J6WmV6+t08//xx\n", + "tm27gStX6gitCn43vtRwUIkj0WmQxiJOhE+Eik8GSQFJHI0WIQ1CQqoMoRJHR1Ahh4KPTgWbJhED\n", + "ioqCTlKY2FJSJWQUkwyCJh49OKygkcYkRRwfScXZoEUaSQFVdeiKFBRp4hBioaN4AQk1Rj45wXpj\n", + "CUvLUUgPcLW6iqdmyAuFCEFCSXLpXJFy9AP0/CDvfvcd3HrrIVZXVzFNk9HRURzH4X/+g/8Dxifx\n", + "k1l2Dm8nl+vBdds89dRxbrnl8M9t533ku99l9tlnuXNyEsfz2HRdkLKTqP4ktp6XGg8//Gm+851v\n", + "UK83sbK95F2dUnuDtiUYMAxmKhUUy2Iin+dsqUlOibMvMczpjSIekCJDHoGHoE2ys49ZRyeggc2W\n", + "0mqMJJcZJsBgAkhjM88aNSIGMPAp4NKmzFZ3tUQMjS1JuF7SxCmzgUMdnYheFJYJ2ZARbQzWgTkU\n", + "xqRClgQqkpL0mZMxIhRq0QZ9Yhw7UthstOhNxVnaXCOfTrFtaDd+u4ZlbOfrz1wgnvUwd+/GisXY\n", + "vn376967nxd27tzOE0+cwPNGr9k8+L6H666+ZTG8Hr7zHbj3XngD6tW/cHjwQfgX/wJsG65jK/8t\n", + "R39/P3/wB7/Jgw9e5oUXjjM7u8aFCxt43iwHD96Lpumsrs5iGBt85CO/zOc+93VKpSUKhUGEEFQq\n", + "6yhKiYsXJZa1i97eAgBrazHOnTvH/v0xJidvYuHyJcDCdoqoyioTfZOs19v4ikUkU3heGSkvImUX\n", + "qhoBZ4EQTfPo6+tlz57beOSR79NsmrjuHAExQhRc6ixRJ4XKts70C8RpYrPGLDCKh4JCjinKBCi0\n", + "kASkiFDIoNJEdGZ32tTIUaSESoSPTxUXQYaUX8XoSXDD9ptYuHCRBbVAPrYTvyFoRRYZs5tmK8aR\n", + "Z8+xL9XCTFq4vs8tPT3QbLJt2za+fvw4pbPn6O3qJptJsZq6QDOf58Ef61vu2LGDvr4+/uY//2fG\n", + "43EGcjns1VWe+OxnKb73vdx1993XZd1/7smIlLIIvCFT7h8lIwALCwv8zd98k3I5xuZmiVqtzi23\n", + "/CgR2UJ39xgnTpx73WTkwIEdXLjQwPMSLC5eRVVVhod15ubq9PR8hERijVKpQrMZY2bmOUZGQn7v\n", + "9/4nenp6OHNmlgce+DAzMxc5evQp5mZP4NGFgk5ECUmBKi7T+Ci0WUdhBAVJRBENjxRpkuQpYiAJ\n", + "qVEggYlJEx+BTxWDRKTQbEe45KiwThYXC0ENnw1CepAoImBThihCoElJFkGZFioemjDIGUkanktM\n", + "eiTwSRCgxLMkdRvPHOGsY7PkGMTUPgZUiyv2BoNGjpRrkZMFFufh299+gRdfnOGhh+7kgQceuKbt\n", + "EgQB3T1jDA//ZAXENGN4nsC27Z/LdMby8jLnnnmGm0dHUTutOiklPzx1issHDjD9KmczIQSKIujp\n", + "GeLhhz/FlSvnOXvaJlq5QNxXyOYSLK6vY6VSHMzliCUSxO0YC06EFxqECqgRWJgdyXWJikaMAJda\n", + "R1cggyCGgcoAMUwCBCtINDK0CLBZI0Sjhck6/XhYpGlhYyKp4tOkic0KSQIcIspI4vgoisrJKIZN\n", + "BodukA5xFunFYB6DGkPopOnFpI5NSa5hkOSqV8atthGaTstPcGphhqBnlIQneOVSjcmBFsqlS/zw\n", + "zBle6O7m4U996rr3fX8aenp6ePDBO/nmN59BymxHTKnMBz5wmH/zb96SEF4Xjz66JRr2jwGFAhw+\n", + "DI89Br98/WV+3lJomsaOHTvYsWMHsMVRO3HiJM8+e4pKZZF9+ya4666P0dXVxac//St84xvfZWHh\n", + "OQB6e5Pcf/+dfP3rz9PTU+icHzAz8zKaFufixRl27DhE27YImnVUJQDpUKoXafkOfpDHdUFVI1RV\n", + "IkSFMKyhaS1GR3dy0005IMHJk89Rr1cJwxxSbkdHdNoosMJVdhIhgRCPiBox0nRR5yqzFFCAgBYR\n", + "ORRUFOZoIcjSj0EZBxsD0TGkEOSYo46PTT9pVBxMvU2YHKZg5vAHhpi/AhtuhBEbwPM8Wu0mKVJE\n", + "UQwHhRtySa7WalgjI9jVKqdOvsRipck2qaGJBG5bZaO2RsXzSKZSP7EePzx6lG7HuTZJmU4kKGQy\n", + "HP3e97jh4EFSrzr+Da35m77CG4QQ4iDwb4E9QojHgV+SW42518Xo6Ch/+Ie/xfz8PJcuXSKRSDM9\n", + "PfWqo+RP/X/79u3lxRdfYWUl4q67biQIfJ5//hEymUGSyTzZbB+p1Bpzc+fZ3LyKYRQ4ffoiY2Mj\n", + "xOMWUkYcPnyQ0dEevvKVL3HhbBUZtojoRiWGj8F5ztOPJEFIGskiKiG9CAYAlyRVwELiUcNGx8FD\n", + "UibJOhBIhQidWofOKikiREgan52miR0ETJuCb9jr2NLCAiwiTKp4hGhBH6oBMV2h6pUZxSMfT5Md\n", + "y3NltoYu+jD1JC2vByVYpUwTGfYhhIOhS/zAo16tc/ZsjFarwJ/92be4cmWNT3/6n5LJZEgkEhiG\n", + "xPOcnzAxdN02UWRz+qWX8D2P4bExJiYmrpta55XLlymo6rVEBLYSjsFkkguvvPKaZETTNPbt28aZ\n", + "M/MMDGxj796b2b37EGdOP0N1+RgT44OUNjZQSiXWL16kXq9zuiVp6NMIZRAj7mC2q7jRGpHMEhca\n", + "SBufZULanTVVgFKnmaJ2PHSTwFxHmizEYwWLDW4koEKsI+KfotXpD3s06SOgG58GgjlDxYlUNhjG\n", + "iwaRmokmbHx/kFVsNOpUKJAnQwaDLdF5lTYRPvNUUUE2yCk9hPEsNS1LV7aPpUaDvRPTFPJlxvr6\n", + "GAMur6zwgyee4EMf/eh1WaO/Dw4dOsjU1CRzc3NIKRkbGyPfmZB6OxAE8Pjj8O/+3dsWwnXHRz8K\n", + "X/7yOysZCYIAVVX/m5wzVVU5fPgQhw8fes3furu7+fVf/wS1Wo0oishmsx2e4db16vUyx449xZUr\n", + "NZpNnSgqoutnCEKfui8J0Mjm21Rrm+RSO1hbC1HVNFE0hqIsEYtt22rnyFeQsoVl9TM767G+7tBs\n", + "1lHIoyptwkjHxAAmgGVMDFqoQBqBg8DpmJgmqNLCpMFZFIZRCBC41InRh8Ajj6BMiEKFPqokUdHQ\n", + "SGKiUSLCpRHLEe+dIFJyIIr4WkAYxbCsFAo2piII3AppI0m2UEAqDfpVldVajS5d58LlOW7qG2ej\n", + "WeVM4BI3TMzUADv6CywvLLBr165r93j2zBn2vMqpW1NV0sDKysp1ade8nQTWE8C7/yHnGIbB9PQ0\n", + "IyMjHD/+/9BuN4nF/o7lWyrN88EP7nrdcy3L4tOf/hinTr3ESy9dxDR1Dh4cZ3y8iwsXFomiOAsL\n", + "K3iexcDALvbsOUCz2cdf/dXXuP323Rw5conx8YO02000rQ9FjRA0kVEaT1pIIlZZoYlHHA3DsBBh\n", + "HFVmEdIgkiE21paDKnESqCioRIRUhUNDpmgbU+DrRPgklSaG9EnKFqqWphoKnGCDZOSSkUsoNNGV\n", + "NJH06ZU2ESENKpTbOXQ8fEqsq2naZpJSaZ2urmGWyi0ifYx8shev2sYOlkgYGgmhYWgGl51NVH2E\n", + "yO8nnR5Byjyrqwaf/eznufPOw8RiMW67bS/f+95pBgb2YpoxXLfN6dPfJxbMM/9EE0NVOf/kk+R3\n", + "7OAjH/vYdSE5Kar6umlmGEXoP6Ut9J733M3S0hdZWDiJYeTw/Sb9gzr/2//+5/T19XVE0Z7nL//k\n", + "T7g0N8fipiRrTKCaMYb6DlBbOkbTbuHIKk6kEkVtpFTQGUDTxonCHIG8RMBlQmqoKB0/CoWUMGlK\n", + "mzweJgHrqIRAkxguEU0C6gySp0IOSVI0OTjSzwXN5GwxiRJOkrKSuFEc220huYrHMHXOYZHEYGuc\n", + "r0GIQ0SBGAoxutUhpOlQVHxi3dPsnr6TcvkFskqClAG9+b/7roz39fHs6dMEH/7wW0pqzWaz3PBj\n", + "hLm3E08/DePjMDDwdkdy/fCRj8C/+lfvnKma//gf/5L19RqZTJx7772ZG2+84Q0T4X+8ytfb20sq\n", + "BY1GhePHnyUMhxkZmebs2RkMYxuXLjUZHCzQ39/LysoPGB3NU61ux7ImabfPUSz6gEYQZGg2zyNE\n", + "HcNIAJtcvNgmnT5ELueyulxCJY0f1WhRIqAASEIUGoQkKSBJIgGBR4AkJELSZiCZZqHlUpYG3cTZ\n", + "h84KV/A6NhAWbVQaWIBLyAEVLBHiCZUVxcQ2LGS7wfNr80SlRRQnwveg3lJxVAPdsoinPXqtDJrS\n", + "pDef53KlghVFNGwbVUugCpVCMsfu6RtJxNN4nsNa7dJr/KeseBzXdYm/io/pwxty6H09vCMIrK+G\n", + "ZVk8/PB7+Pznv4uU3ei6heOUmJxMcdNNB3/qeVsv01u57bZbAXjmmed4/PEr3HffrZw+fZqF+Qpd\n", + "6TQhbXRdI5XKUa/nCUPJoUP9PPfcEZ58/GnmLpVIksCTEZ4wMFQFN2gAdTzSeFoMU4noFjoykATR\n", + "VkG+Tr6zd16kRAOBBghMEZK0uvH9GpoWByVOLBxkI1oiIzKkNBM/dGmR4XzUJEabcWq4UYM2goRl\n", + "MhAJLntVIiXCliZZYweOtJB+kmoQUDSqODGDXGaIffsOcvF8nCvnztOv1ZHoLDlNNoGBzDQVb40o\n", + "CpHSY2OtwcvPHSG2eBlhmjiJBDffvJczZ07ieQJF8YmHV3lo/15SnUb1JHDq3DlOnTzJ4ZtvftPr\n", + "vW1qihcfe4xx38foJDdhFLFs23xw797XPSedTvPbv/1JLl68yMrKOl1dE+zcuePaXLxhGNx1113s\n", + "2rWL//v/+lOaT89Ra1TQrASO3WKzVccgx2jvbjRDZ3b5PEJuYun9+FEbD0EQ9CKVFsWoSU+n/WKj\n", + "sCYrVDucIYHGMgmahAg86miUUQnZQKeCUD2ErnPVdmgZcdJWD1EYQ5UadrsFQkeyRd/eICCBT9iR\n", + "h45Q2aJ2+xgIdNMkk4mR0RWW7BUURduSyg+auEqFA5N/JzDWbLe5urTEsaNHmZicZHBw8E2v0zsN\n", + "X/4y/Mo/MgHa7m64/Xb4xjfgE594u6P52fD9MUZGcrRadb785aM4jsvtt9/6pq+rqiq/8ivv4y/+\n", + "4m9ZXi7S1TWK79dJpWzKZY9Uaphi8RUmJ0Puv//9HD36KK5rMTIyhqoatFrHaTaXcd0KijJPIrGN\n", + "np5BhKgSht1Uq1cprYcoYqsWLkSWSFr4zKOgIgkpUkdDYAKCLA4tSoTo9KPrEj9TYCQTp7X8EiYu\n", + "cXR20cYjZJ6QDCZBKkU2CLjUbnNGUbAk1GRITejsT3fRmJ9hM/BRvDZ39xf4fmmBpXaFuNlLO/DZ\n", + "OTBGu7LJZF6jL5fjmGEQui5xTSOVTnOhtMb2gUni8a02i+M5NHSFqZ07f+J+HrjtNp7/0pe4KZG4\n", + "VvFer1SQ6fR1c/F+RyYjADt37uT3f7+XmZlzNBo2ExN72LZt2z/IUfTAgX0899xLlEoLrM7PkXLb\n", + "6GGNhLbGc99Z4mh6GF23KBZN/viP/xdOHnuacTmPGquhMkGj6VGP1qgE0KussTfy2bAStKIkS47E\n", + "iXvE1ICG6+KSQIZxhFikm4ABEeETsiYjasLAsAoI4ijRAKqUBIqDE/QxRxnbKaMZMVrJEUrtMonw\n", + "KioBDoIqOj16HkfWUVBoWxFxMYCl5fBTKWqKSdtRUdQuRkfTZLMqrdbLFHpaVMugygbLfgFViZMn\n", + "RiQdTD3E89okEiF+aZ2hTJ5tg4NkEgnOBFLHAAAgAElEQVTWKxXmL1/gX/7Lz+C6LouLixz7fPla\n", + "IvIjjHd3c+bFF69LMtLb28vh97+fFx57jB5VRRGCku8zfccdjI+P/9TzDMNgz5497Nnz069dKBS4\n", + "4dBh8j13MPPKKyyeP8NmVGS4/1ZKpWWKm+eJJeJYiSQj49uQMsbK0ipRs4WMFMCnQRfnqTFhJFCE\n", + "TskN0AjYxMUmRZ0ubAoYeOSRNBBYXGVS87glmUZGIUUv4nS7jidtVMVGiSSq7xHHpU2bkA26SCHx\n", + "8UngEdHCICMCNLVKl2pgR00ULU6hO4MsLzE7+ziJRJ1qc529mRwiCJBSMru8zJM/+AH5fJ6rTzzB\n", + "qe98h2233ML7f+mXfq7j2b9ICEP42tfg2LG3O5Lrj098Aj73uXdGMpJKbekGJRJphoZu4MiRH3Lo\n", + "0MHrstuemJjgU596iFLp82iaS7ncwDQthPCJok1SqYi7734X8XiKo0e/j+9vjRJns910dWVpt9cw\n", + "1DK5VIxEDnp7NVqtNKX1JaqlRTR/iqQwcaIaUm6RwU1cYpQYY5Ms8DLVjvmpTpsMNgOEyhK37NtP\n", + "KGuEnkaxOMjF4Cp5WmgEqAhAYU2J+NCePeQsi+UTJ9hUFGLxBJEb8dDgFClNZ6Zept+waCoRXjbL\n", + "YV3nQKPJWqvMmtDYaLjcd3CasLLB4wsLpKemSAwN0dfXx/rpCyQGd1C2G2iVdaIoYra6xC//5sdf\n", + "Y+ex/8ABVhYXee6FF8gKgQf4qRQf+bVfu24u3u/YZAS2XGNfj6z690UqleLXf/2f8md/8h+gcQpD\n", + "cdneP0KxnkC4PTSqSRKD0wSBw5//+eeYPXGC8VSKUKyw5J6nJmM4UgFq7NE1xhJd7Ch08dzKEnGZ\n", + "wBUTtMQySnycKMjhtl8hJWukRbBlJ60IMuhUUwXGdu9n4fIsbmUFkzRe2CJUXAytl6ru4yeH6e7e\n", + "RebKN+m1TbLkSBDDJ+RSw+OsyGOlyuwfmaBk9wAxhscnKGsaoRanXG5x001j7NhxI+12i+XlM7zn\n", + "nkH01WXmV+vMzm9wYXGRINBI5AoMDsbxGg5JQ8HUJelOstGTyzG/sECxWGRkZGSr1ytf20QRQhCF\n", + "4Rtem1fjtjvuYHJqiksXLxIGAXdMTTE4OPi6L08pJWtrazSbTSzLot1uo2kaw8PD6LqO7/tcuHCB\n", + "q1dXyGZTjI/3c/Toc3jlJrftuomnTj3LRs3CSk7TlY6T6ClQqZYol1fRtE0IBHEtia1XCPxFsoqH\n", + "qyRZMA1inoeqajRClw1imIyQYYIcCk1CKmySwUbBo0HESafFsG6SNEyEXaVvMEUgVZbX6iSFQSh9\n", + "AkoMUcVQUsS0LjbCFVJWDyVnmTY10rEkTixPw60Qr9cwRZOpWIxS9QVGu0e49caDnDh5kscefZTe\n", + "0VEuLS4ylctx5113EU8kiKKIF48d4/zUFDtftSP6x4qnn4ahIZiYeLsjuf740Ifgt38b1teho4j+\n", + "joBhWPi+Rq1W+4nBhDeD7du3MzaW5/TpKlIW6Orqodks4/vrqKpKPJ5CCIGux+jpMdjcPEs8Pkit\n", + "uozmLtGtNNhmDtOobbDSmmP3oXfx1BPfIAoTGJqFYSSIex4tuVXvlLIMeHhMsQYU2GCROh5dWw7u\n", + "2llMJcRt1THMKmvrTXZ2TXJh3ceR6/QhyBAhCAl1jedPn2Yyn0eoKiO5HB/8wAd46luPUatt0pIQ\n", + "IhF4DGWSXF5b4/0DA+iZDKutFlpfH+vd3ey45x5ymQz5/n4mJiYYGBhAURTW19f5r//1G8zPlymV\n", + "N0HYfPI3foeHHnqt2Z2iKHzwwQcp3XYba2trWJbF2NjYddUaeUcnI9cDXV1dKG6D23f0c27mApvl\n", + "JepeLz2ZAVq1Ep63zr5997Kycp7FtXWyQqKrCTJqD/lYkoYTsBomWBE1RlIJik6NAk2k2eKSF7Bt\n", + "7H5k5DO3eoaE2CBJFkPPEQqHhO4zFkjabhu3vU4yE0epzRP5RWRYJ6e0yes7yfQMM9vUsBuLFLw6\n", + "cdUiiDI4UiCIyGBzSQpiDY/zl86SNMs00Wm4m6R6t5HM53GdRep1yeKijudtMjmZ4+677+MHjz7K\n", + "nswGB7cPslDs48mZVXYc2M/U1BRHHvv/MLUy7z204yde+pqiXJNgHx4epq6qOJ6H9WO7mYVSiZ0f\n", + "+MB1Xave3t6facbUbDb5whe+wdxcleJqhYVLp5jqNdkzPU6USnH/Qw9x5MhRVlZCTDOP5xVRlA1i\n", + "sQqt+hWqpqDlVGm0LUZ6xkklYrR8wcTEdo4efRpdGyZGL8lUkqYWUW3kIdDoVuPosSRRbJWMu0DK\n", + "1qj4Q0CIj8QHHFQsUigU6aJFMpBshgEtzSQRBezoyaAPQdNWicmIxdVFgmCNEVYYUZNUpEuohdw0\n", + "MI0nBM7KMu3YTnp7t6HKiMbGZVrhPLa0uXHfHvyNdepRxMTAANPDw1y6epXHX3qJ6YEB7rnzzmu7\n", + "T0VRGEmnOXP8+H83yciXvvSPr0XzIyQSW06+X/wifOYzb3c0f3+EYYAQ/mv8xn768SGrq6tEUUR/\n", + "fz+bm5scP3aM9aUlugcGOHjrrQwMDLBr1zBHjnyXQiGFYcTwvKsYhkMqNcnq6jz9/WNks5KJiX3E\n", + "YnFOnjyK5p1jKm7RZfWQSZgMWBlSjVWOHX0SPerGjwp4fh9B6KKIq3RbMVy3gqNo9CvbyKBCFKGG\n", + "aVwWaSlLNOUI/am91CI4eWWeoVyFZGCz0agTV9r0Rxl02cCljgbUXZea59FwHKxYjJXiJv/2s98i\n", + "R5oF4SOpMp5UGBse4tLqKl2Arii0PQ/dslDjcXb19bG0vEY7MFHjLQzDuNZm6enp4Z//8/+RpaUl\n", + "PM+jr6+P5M8gGnV3d19LFMvlMq+8/DK1zU36R0bYs3fvm7IE+e8+GXn+2LH/n733jpOjvvO83xU6\n", + "5zSpJ2dJoyyNAkhCIJDIYHAGY+MXeG3v7Tq8fM+FvV3f3d6+7tbrvXuevfWuExjbOKwNNskiCZCE\n", + "hLI00sxoNDlPT3dP59xdVc8fIwaERJYRwe9/JLWqun9d3dX1qW/4fJk4fpzVNhtX1frZ032aoWgE\n", + "HWYkSaSzcylWqxW3209O1JNNRUjrKnFoLjRFQZEUzIqJtKqnJzpFp0lmqcfJeDRKVC+QzyWQpDzl\n", + "7kWUZBFnSYegJrEINgqEsBnyVOntJDIpzD4vszMJjIKERS9jdTYxkS0yOTNJQRApJuKUl0JoohlE\n", + "N0kliYwCGFDJUqEp1OZzpEthqh11TBVCVLo7sFt0KPkYN9xwO8lkiq6uLFNTdn72s2eoqnKw4vp1\n", + "ZBIJFns8fK6sjN7efiYmZlizzk1VTkfNq26vcoUCaVGk6mzVn8Vi4YpbbmH3b39LpU6HyWBgNpVC\n", + "V1vL6jVr3vPP8+GHn2BiQsZma2Pw2G5W+NcTjo0h50s0evT8v3/399grL6epadXCPqlUjGTyedZ0\n", + "2LCISQJRgaKSwWk1kS8qyGYDweAwmqaiKhqaMkMmWUIrzeKSGsmrCaxkKWWzGCwVhPLTuNUCvrOt\n", + "wQnGMVCGdHbihJ1xFqNRIUhE0IgWiiQMOsrKyrju8qW8cOgYY4FhFutjVBugUNAjqOp8zlmJIcuV\n", + "hBPTCKKbltaNuH1+hrtfwqH3klEFqpfZ8bmdqIUcUqFAIBKhvbaWlW1tBBMJtFzuvDC4LEmXzBDt\n", + "vSaXm68XOXr0Uq/kj8dnPwt/8zfvfzGiKCUkSUZVFSYne1m3rvUtzTuZnJzkV796jHgcQCSTmcaU\n", + "nmVFVRUNNhuRnh7+7fhxbvj857FaHWzcuIFkMkU6HWfTpnoCgSypVJaBgWNIUpA///NP0dU1QDxe\n", + "wm430WSxYlOM+HzVmExmQCM/O0Ypq6Pa14qa0gjlE6iqCb3Oh91VJBCN49H5kVUd5PKoaGiChE70\n", + "IGkFHDorgpzFqGrYqhchG7MooX3UWWL0x2P4NBUTCgIwDrQAaU2jAFgNBnqLJnSlCgoGGx2VlWhS\n", + "iWSyi2A0yqyiUAaEUimihQKW6mpqamrYvecQs7ZK2pe5mZwUOHLkl3zxi7cu1HmIoviOaj6Gh4d5\n", + "9Cc/oUwQsBoM9Jw4wZE9e/jMPfe8Y7uAj7QYSafTvLRzJ1uXLyfR34/L4WBDewuF0wEyjiK+6g7q\n", + "6uoAyOcTbNl+FUd/9lMEzYjLbCaTz6MIAgaziVQ+hUmUaSr3EslkCIoiLb5KZKOeuKgCfqZLMYRi\n", + "DCkDHoeBgubGJEfJ5FRcZhMz8TwFyUmd2Y9JpyLLBdzJM6QKcTx2O2opj5rPoalGShTQY8DIfGGj\n", + "EwEfoACKmkQRozTayxgc3UdFhZcWt5GnHn0Mq2cZjY3b0OnmL0aBwAinTg3wpS/dtRD9qK+vByAW\n", + "i/GL73+fvslJyh0O0rkcY6kUl91yyzkKeOWqVVRUVtJ78iSZVIp1Z8P9F9su+M2IRqP0989QU3M5\n", + "p46fwKXXo5f1eJ21HB/sZlVrE7PjIZz+c9W/1erEbK7EYIF2sxmf00y+OEwseYJoVsQkmSgUwOWq\n", + "weNahKuQIRYMMJWYRaea0YQsCS2DT6cjkkhjUIyIUhwDBSpUKzEtR5jxhSk29RSwIYCmohdE9IJA\n", + "ud7InE6HxWSirbGW3OluWux2MqUiKZORXCoJiorFpsdoTGI3yJhkL56yWhwOD76qRqyZBKm0hM1j\n", + "QRBFNE1DhXNaot12O4P5PCVFQX5VrncyGmXVB31Ay1vkkUdg5cr54XgfVrZtg89/HgYGoOW1Dgjv\n", + "I6an9yMIZlQ1y5o1zezYse1N98lkMvzkJw9jMLRRU+NF0zRefLoXT3QaT3MzdosFu8WCI5nkuUcf\n", + "ZdnGyzAaZ2ltfcVmV1EUurtfYvPmKm644TosFgubN1/O6dN9PPlkmANnZFbWdTA2NkM6XaBYVIhn\n", + "w1isjVi8lWhaBIfNRTKfJl0sghjC63dRYa5DzUExGERLZ4gpecJKgTxm6i1GPGUOQskcNYvWIYpF\n", + "+qJdmAtZXLKIXCwiMW9Q4QO8QBao1OuJKQJVmpGiXkGwWIgoCj6dCVFfwbQwhdTQQCQaZUKSsFVW\n", + "4qquZt/ze4hkFBqcdTB0gklJprrjMh57bBdf/eoX3vFnpigKT/7mNyx1Ohdm1viZtwvY+9xz3HDr\n", + "re/oeT/SYiQQCGDTNNpbWzkajTIaCmEQBMxSnsHwKLfd+gVEUSQeDyMIIf7yL/8d3x4dpvdwmICq\n", + "orfZaKypISPL9I73I2aDDCgKNr+fqzZt4rGXukmm4sTkErKpROOSKxk59huqxByKZCKey5K16HEZ\n", + "ZDJCnmQ6Rlpfx7AWxZaNImlmgkUVTV+HVrTir7ExPLwXf0lFUueQsBKhRBABDwUcgoYNkXEBlpbZ\n", + "kdxmpiYm2OKcL4r99b5jlC2u5qzWAKCiooGxsQNMT08jiiIv7trFWH8/ZquVRatXc+XNNzM+OsrM\n", + "2BjW6mpuWrduQay8msrKSiorK9+zz+5C5HI5BMGAIAjkc1lMZ1tWdZKeQlFFUVVEDYqF8yMAoiix\n", + "42O3cWTPHpLRKLIhh91Yw6olyxifCKEodqamXsDlcRGdSpFKFygWQdU0NFEjLTspFksIhQJlZh0r\n", + "yms5E0qB6sBbchLPpDGSxkwCB2CTJFKqRlhTSKkFXFY3Kzs7mTUaieXzTBcK5NJp7Ho7mt7MBGlm\n", + "hCLkZkjbHNQ0tSMkyiiVokQiOTRZZjYRoMqro7qijAq7lcMDAyQMBvzeeeOnQrFIzmjk8ptu4tDR\n", + "o9RYLOhkmel4HFNTEx2v05n0YeO+++AL7/y3+AOBLMOnPw0PPAB/+7eXejWvz3/8j18iFoths9ne\n", + "snFWf38/2axtwdAsn88iZFM4LeWMj0/S0TFv7+Cy2ciNj1Nd7cdkOkQkEsDtnp+FFI+HqKwUuO66\n", + "HQtpIaPRyMqVK2hvb+Mrhw+TTIRobaklnckQCEwimIrUNLTgr17GSOEw2UgMCQGFHPZyB7d9+iaO\n", + "HpkmHZWZFATGxqfJaTZyShpZdDCuWCmVNGyV1TidPsLhAdxON+FSAi2TYACoAayABATP/ikrKpl8\n", + "HkkU0KQSlWfrP8an+olFp/C6YevmzQz19UEggM9k4vTRo4xPTOFrWUNLRT2iIODMJBkf6kIU/aTT\n", + "6becDnsts7OzkErhfE2Ra315OXuPH+f6W255R4XwH2kxotfrKaoqsk7H2o0bmZubIxaN0llfTzEw\n", + "RyrVSzot4vGYuPvu+dDWn/+n/8S3/5+/RV+qxmFxkQHc1ZUscSXZ4q9jWUMDRoMBQRTxVFXx/Z1H\n", + "aK1fTiSioNNJ2GuXEQr0kkpHkeQim8sqkXw+mlpaePZMP31jOuz2dYyMnCGRmEYpmHCKNkyWSiyS\n", + "h46lLg6fehGhkEMijYIRCyZUijg05scoCRITsThSocDisjKMOh2BWAyH3YUxW2RsdJSWVxmFCYKR\n", + "8fFxDj31FPU6HRvLyjh+7BgP/v73mGpqaGpvZ8XmzWzeuvWiGZn9MfB4POh08xM/PeXlBIJBbCYz\n", + "yUyMCrdlvkZdX6L36KPMTRzDV9NGTf1iSqUCJlOJpUuXsmLFCqanp7l8aor9+08QDmcJH++hsrKR\n", + "lSs30H3yJNG8yHQ+C0oRlSGs+lpkyU2eEDohSJNDxKXXc3mFRERJMpAoIpUilJPFUCgRBWZVDdAo\n", + "IuA0WUgV8rSvWMFn7riDZ555hoMHjxMSNAKoJFOzeAWZJYJExmykpqqKdddew+n+EDpdI9lsCUVR\n", + "GB8RiE4doKRWEEinCfl8WCwWJsNhVE0jpKqsu/56NmzcyPCqVfQcP042m6Xz2mtZvHjxex7JuhSM\n", + "j8ORI/Otrx927rlnfhrxX//1+9fu3mw2v+0x9IlECkl6JTIrSTKqICBKetLp3MLjqqqiAC6Xi7vv\n", + "vp2HH36S8fFBACoqbNx228cvKIBMJhPf+ttv84P/9R2Gx3oQFBVdnZ1GfydF5qcKt63YTCQSZGqq\n", + "jzpXhu9851usXbuW++77OTt3dhMrahRkJy6PkfLyRpLJPMWij1h6EsmQpLvrOSRdmAqjAY+jjJ5E\n", + "BCfQLwjoNQ0DUAeYBR0pRaYoQKCQRjOVkSgUiAwdx5yYolHLUClaUXt70UcirNiwgXgsRmBmhjpv\n", + "JXKpAGddTpxmG6Nz02SzjnflLSSejbq+Fk3T3tX14SMtRvx+P4LbTSASocLtxufz4fV6OToywp/f\n", + "dRetbW0oioLb7V5QeqvXrOEf//U7/OAHP2dgIEgmkSQ+cJIVK5sJ5LK0FIvE43GG+/oYnp7GX+1g\n", + "/dZGBgbGCAYH0EkGBuYUIskgtbLCUDxOi9/P8fEpXFVtaKMnOHHiFFqxEh01QAOqpjCXDmBN6Oio\n", + "aaLfM0o4DeaURq2qUCJ71u9TRUbCafFwJp6DXB4hnmFgcBSLUYfmdDNHP4w7FsSIqipAkpH+fqpF\n", + "kWqfj1MnTqAGAlxTX8/RWIxFViunn3kGo9nM+g3v3gPgj4Ver2f79g38/vcHsdnrGDcZOTM5iFkf\n", + "YcOSRr7/2GOEZ+co5uJExyeYOX2UvrJKlnSu5O67b104Qf1+P36/n9WrVxMMBrHZYP/zk6SjU1hS\n", + "k6RDEzjUInmxgKivxKQvUFSCpLKDWIRRjFkDitlLMBKjQpKo1olYKixIKZGeSJ4MGnZNwwWUiyKK\n", + "pKM7HqBz/XoMBgMtLS04GpZiMscZHOqhRXJjk8zMFpKoJSNaYI6uPXv41Fe+wlNP7SOb1ZAkjZVr\n", + "XGz55n9BKZXQ6fV8rKWFZDLJ8OAgoiRxdWsrZWfrfxobG2n8MLaSvAnf+958y+u7qLP7wLB4MbS1\n", + "zQuvD/LwvNdSVVWBonQv/Fun0+OuaWO8Zy+L2l7x0hmcmaGuowOLxYLFYuErX/k8sVgMTdNwuVxv\n", + "ePe+ePFi/vaf/4mBgQFy2SzVNTWEQmG+971fcvjwY8Tjytk24Dxr167niSde4umnX2J2dgafz0uh\n", + "0IfN5kEQYC4UJZXMk0gNgFJAn9EjKkGsYoLJUp4yTyUeq4WpQg6jIFAly0RUlaAmYVM1dEqBvGxk\n", + "VpcnlSlSI0exlaaoEUu4jCIVDgfjg4Msb2ggFo2yZe1aZgMByqMJhkMpstkUFvP8mI5UMsqWjoZ3\n", + "NZeqrKwM2eUiHI/jfVV9yNDMDIvXrXvH9gAfaTEiiiK33nEHDz3wAFNjYxgEgbiqUr92LavXrHnd\n", + "/umWlhY+8+mbeeL++2lw1NNQWUkinebF4WEeOXWK2MAALqOR8poaNjY1MT01yp996U6isRj/8I1v\n", + "cGu9nvK2DubCYYbicX7/4gl07hXU1trp6Lie0ZEnUEpxBFlAlKqRZR0GnZ5gdILTwwJzCQveCpm4\n", + "MMZsKkKZUsSDxoRsQm+2kJN1pPV2dOk51ssWKr1uZJ2IQprjwW6mzXZU9UrS6QQ9Pc/jdIo8+cRx\n", + "rmqqIpPNMjs2RpPLhSgI2AWBVDbLkqoqjrzwAp3r1r2voyPr1nXicNjZu/cIxaVGCjkvNtnJYKlE\n", + "/3SGJXXbcFrcRONRpoJjkJ7iis1LaXlVYr1YLLJ794vs33+SQkFhuP8U6dAk2azKUqOJuNVLsBCk\n", + "IBkICBApRXCoQap1CpJOoD+RZiJVQDNbOVkoYJIkbDYzAdFOSBbwllQGAR05jFqJKjXPotpq8vn5\n", + "aQiFQoHmpZsYkk8QHzqJX2ciqBTBWI7TIDM3GWd28lnG4nnu+dIXqKnxYzabKS8vP++zsdvtH0lD\n", + "swuRTsOPfgQHD17qlbx3fPnL8C//8uESIw0NDTQ0WBkZOUVFRTOSJGN1lxEptzGllsiMj5PWNMw1\n", + "Ndx4ww0L+wmCgGt+/O9bwmq1nuMWbDQacTrtdHRsolQCVY0xOjpBJFJOa+sG9u7dw8GDYzQ3g8Xi\n", + "p1CoIT4Xp5jpRhZl7PiQtNM4lQJWj59gUENFYM/sGNdWlbPeYubY1BT9qkoCCY+oJyGLWOxuzBY3\n", + "Kw0melOzmE15zIkY1WVOmuo7cDmdTB86hKSqhEMhZEmiyu9HU1V08TiRyDijQRibC5G1GVi8uAVF\n", + "Ud6xP4goilz/yU/y8P33MxOPY9XpiOTzyH4/m7a+ozF0wKWdTXMv8HLm9v/TNO2Xl2Id5eXl3PP1\n", + "rzM6Okomk6G8vJyKioo33EdRFF54/HHW19fjOhvm8zmdbGlp4SfPPMPipmYGh8bJDE1TTORoaW1g\n", + "986dxNNplhgMrDyba7PY7RzomiCRFPC5FyMIFfSeegm3FsSpA1UYJSGmUEzLiOdk8vkkkUAaRdCj\n", + "aYuwuRvICy+RLRVAUHHbdIi+Wlas3crRo8exhk/Q7KvEIM/HaFNpaHGoBKxzTE3tZnh4GEkqx+db\n", + "y9SoxBMvjdLmD2DXNMSz6janaZgMBixGI4XZWYrF4ns67fWd8OoBWy/zT//0L3hsETyO+ciA1+PD\n", + "6/ExPC3S19XF9muvXdj20Ud3cuRIkOrqtUiSjhMvTSBLM9i1GQTFjE6XwGPMkcGAaJTIZAM0GvwU\n", + "spPorG4CiTyZUhZzKoXVYmdOb6A/LVPCTUa1okpOrDoDJZLo5Bn81iKWigry2SwwX3+j1+dx+Jpw\n", + "1qzFhIQQTSOjoJOzRJIiUUkj1RPl/vtfYOXKSu655zPva5H4fuCBB2DTJmhqutQree+49Vb42teg\n", + "pweWLHnz7T8ISJLEHXfczosvHuDgwWOUSgrr17fx7//9PxOPx4nFYjgcDmpray/qObFv3yFstjZa\n", + "WxvRNI1dux6lru5KgsEgu3fvo7d3BklaQl/fSVIpjWQihUV0g2ajWEqjI4tMjmDKRCJvQcWOQctj\n", + "V4ycDs5hMRso8/sps1h4cWKG1Q3raG1ZhMlgXEiNRPY/zKeu3cTU0BBrXjXXyet0Mjo3h+lsVfaq\n", + "xYv5/dQUpQofWR0MzghInhVcdvll/O53xxkZmeQTn7j1HR+f6upq7v761+k7fZpENMqSmhqam5vf\n", + "Var3UkZGntI07QeCIMjAAeCSiBEAnU53zp3xGxEOh3nsN7/h0NNPM+VwUOX3s3rJEqwmE6IgMNR3\n", + "hnTfONVmO4Ikczo6zlQoRvnSJkKJOG1mM6l8nvF4kr1DU4yFbaiKlUSyyODgEKZoP3UYcdsdZHLj\n", + "+CgymD0GUgMmqxdFLOGy+vB42imVcmQNemLxAHqXQO2qZlatuZrx8T4kSaa6to1AIow5n0UG4qUi\n", + "Jp+XDWtXcuMdt3Dffc9QX9+JIAgsWraG0/vzjMwGqFRz1CkKgXQayeGgzOkklkph9Xov2hyC95pQ\n", + "KI5Bf34PvaKaeXU569zcHMeODVNff/m8cZuqYjLZQalGjk/gNKhoyRzxXIqMVqSg2hELSWRzGIPD\n", + "hK+yhtzIELWim0Qxi2Isx6G3kS2MEyxZsNs7KKQnMCGiFz1EinmC2iyNDgfesykUr9fLhg3tPPDA\n", + "TkRbFZMzZ3AWS+gNGrFkllhuDskmUJ+PEeh6iZPCWg4dOsLWrVveo6P5waNUgn/8x/ni1Y8Sev18\n", + "e+///J/ws59d6tVcPIxGI9u2XcG2bVec87jT6VzogLzYDA1N4nItolgsMDU1yNDQAF6vj1QqTyqV\n", + "wWSyEghEURQ9mmZD1WbJKkVk4qhqjpQWwCZkkKgikgtQRxi/KKOTXUCaRS47U6LIVdu2MbtrFx6X\n", + "GYvplXqaTDaJy2FF1umweL2MR6PUnk2TyA4HoVKJCquV/okJsqpKbWcnDr+fp5/soXPHvOeKyWRC\n", + "0zS6ug6ydu0ITe9CmVutVtasPX9w4TvlUg7KGzv7VwUoXap1vFU0TePYsWN8/+/+Dk8qRWU+zzKT\n", + "icjMDLvica7bsoXxmRlKkTirW5oxyPMKsVxROBGJEO4fpqGlnq7hYTITaTTNx5mgAUUrJ62EcJsd\n", + "iMoIHsECcoJsMU2Zy0G5qwJ9eJLDiV4s1jKc3nry+fkvqE5nIpMRMZkkwvFRFK2JQGCQdHqYxYvr\n", + "UcNT1FTVk07FUZUSNqWEo0ykvkE6/IgAACAASURBVL2d/v5hTKbyhfxeVVUl2RUr6Dq0B0XSExwd\n", + "paa2lm3r1hFLpegOhbjmzjs/sHbhS5a0cXjvJJl8DrNhftiToirECjFWvMoPJRKJIIrzroyJRILR\n", + "oSEikQjp4BzFcIhOUxVCSUNvtjOey5PVK+iM5YAep9NAXlMpR8BtdJDXmUiVzMiiFYuaJ58vIOlz\n", + "5BAQFAmraALBwUQxwrKGhnNqOK677hqMRh3/8A8/J5B2ki6O4JFkJrIRdEaBbdVLEVTwWsyEJofY\n", + "t8/5JzHyBvzsZ1BTA5s3v/m2Hza++tX5aNDQ0EcrKvRuKJVKnDlzhp6uLuKzszi8XkqlPKnULL29\n", + "p0gkdGQyIhMTIaLRMRobm+Yn+IolFKWA0einVDSiZE9jlgcplvJUawoCeiRVJCfE8GgiIgI2WSKr\n", + "yQSjMWYQGYzEcJSXozOUCM+NIoomNK2AKGXp2NhJ0mymqaGBYeDg7CypdJqC18vn/t2/o6a+nmAg\n", + "gMVmo7W1lWeeeYGO5W7Ky18RaIIgYDSWMzDw7sTIxeb9UDPyZ8D7vrZ97+7dPPKjH1ERjbLI5+NU\n", + "IMCuA4doaWggE48zND3Nvu5u/O5ykvkMetmOgIAsiQipOKcnihjLFrF/OI1T9lBt1SEKRnKaGUG2\n", + "kMtNYBZyGPVmVC2NThcjr6pEUyo6IYHf72Ttxk8wOwvR6BixWDfFokY43IvZXEZLSyeSpEdRJvgP\n", + "/+HL/OpXjzM6aGBo4gy1NheyABPBM9gqFrFx61a6u0+jKOdqwKbmZkSpwNKlm/G47AydPMnRcBiH\n", + "18s1n/vcOSOlPygoisLw8DDFYh6Do8CZSBCPwYKgaYQyEdpW1nLFFVcsbG+321HVDJFIhGMvvohb\n", + "FFlcUcEzQ6fRlUocn53FWgDJaMHl9jGaL9DcvhZLeIpSNonZaEIVCkTzCWR7DWosRyh0hlwuj4ZA\n", + "NKWgk9wUhSw5oYhsMKLonVx+zfZzcriiKLJt21X4/VX87GePcPA5lchcANkssrWuHbNOTzidpsrr\n", + "RU3PkYiFL8HR/WBQLMJ//+/zaZqPIg7HvD383/0d/PjHl3o1fzw0TWNsbIwzZ4aQJJH29haqq6vf\n", + "9vN0d/fw4IOPcWzfCSyUaPbbWNVSQ3J2lpcGXkKnX4HX24KmGRgaGsJodJ+1SPditWZIpeKUSiNI\n", + "chpZF6XGJEA2j1t1MlnMUCKLHgWLqCMrCGSUEslShqRiRvL6OHimgGZz0FxfQb3RiB6BEhpRUWTD\n", + "bbdRW1fH7iefxKAo2CoqWLFsGduvuw732bTNqwWG0ahHUeLnvUdFKWIwvL+65/7oYkQQhHLgV695\n", + "eEbTtM8IgrAO2AHccqF9v/3tby/8/YorrjjnovFekkwmOfrss1QZjVjsdqLJJMmSkYLi5fhQmpKU\n", + "42RxD8tWdmBIayiKkYl4CL0gkMxnmStoeGvXsGjxFnq7ExTTJoazs5SMblQlTU3ZZaTTp8gIOYKp\n", + "YSpMJT5358cwmQxEolEGMxmuX72Ovr4S09NJ6upW4XRO0dW1E6+3Gb+/kh07LsflcjI+3sPg4Cg3\n", + "3HAF3/3uD+mJxDgxMYzLLnH9bTfwyTvvoKKiAk3TeP75kxSLNeh08zUgxWIeUZzjyis/Nb/Njh2U\n", + "SqUPbMtnsVjkV7/6Hb29c5hMZVRVtdLTcwSLuwy32861S1Zy5523n9PmVl5eTkuLl9//9kmqdU4c\n", + "Fhv5Yg6rJcfVTe0MhcPMFkTsdh8edwVL9EYaLt/BmVMvMXDkSerwEjPqcct6ZEkhkTiDIDgxOZox\n", + "qybEnJdiAUriDK7yalRphiuu2s7ISOCC72HRokX81//azM51f+CX3/se+dwsyUSMQCGHqtMhzIyT\n", + "KEa5svWK9+iofvD48Y+huXm+XuSjyte+Bu3t0N3NGw6O/KCiaRqPP/4k+/cPYjBUACq7dp1k27bl\n", + "XHXVFW/5ecbHx/nFL54lMKmjwbkIg05HMBrmyJkJbty4gmcP/R5neZFodAxBgLo6M8Vijv7+fkql\n", + "UerrV+F2f4aenh7AitPewPTwb2lEQxQ03CaZYDGKUedGIYdR1FOQM4gFF7LBxHheQc5ZqPF3ECjN\n", + "0bFyJYGxMZweD9ds3sySs4U/n777borFIpIkvWHdx5Il7Tz//CmKxdoFo8tCIYeizLJ48ZXv4ohf\n", + "fP7oYkTTtFngvBJbQRD8wD8AN2kXalrmXDHyXlAsFjl9+jQDA2NYrWaWLVtMZWUlMzMz2AHN4SA0\n", + "OUlgKobNXI3NDKF8Hs1tJVtVw9otazk8G8KUNeOtrEcpFUlNjpLKGVm3egM6nQ5/bQ06XSMz06ex\n", + "iwVMJidDQyfJZCLY7XZCuhLrOurxVpRRVBQyuRyrN23iqh07+PnPHyIcHmNkZIJcLoZeb6auroZl\n", + "y5pwuZwAlJXVs3v3AWTZQH395TQ1bSWbTVEozLF87cqF4tzKykpuvHE9jz/+EprmQtM0JCnGTTdt\n", + "XNhmfoDU2xMiytnheBdrkuO74eTJU/T2xmho6ASgoqKe9vZORkdf4C//8q7XzS3fcsu17HrkEbL5\n", + "ELm8DoO+yKpmC612Gy6Hg6iix+VqQSfrORGdxWZzUdeymNUbahgYCFKwOtDF5zCWUujNMmkcZG21\n", + "uCU3s7MjoPciigqaYZyG+kZUVU8mk3nd96HT6WhobMJW10FgcIpIcByDwY/XUkk8nmGaLDan+7z9\n", + "NE37QIvJi0E0Ct/+NuzcealXcmlxu+Gv/gq+8Q146in4gGZbX5fh4WH27x+irm79wsVZUerZtesA\n", + "ixa1LoyveDNeeukoJlMt0+MvUkjkKJQk0DTOTIRZ1hjAY7Owdv1yjEYjsixjs9kolQo8//wvGBsb\n", + "Qaezk8+n8Xr1CIIeKLJs/ZVkzuzHoRlZ1byKwdEuZhI5huIxKmTwWm1Y5TJ6EwmMdZtpaNpIPp+j\n", + "u3uQG2908hd33rmwvmQyycmTp5iZCVNZ6WXZsqUX9Ep5+dyvqqrixhvX8cQTBxZ+50Uxxk03Xfam\n", + "c77eay5lmua/AGXAw2frEK7VNC33xrv88cjlcjzwwL8xNpbHYimjWAyzZ8+v+djHNuP1eihoGotq\n", + "ajh09CilgoTdLFEolcijILh8LOnYRCwWZ+V1Ozj2h50kImEUVeT03CjVK7bT0bEcVVUwGArodCK+\n", + "smoaGiy88MJxBMFKY6MLl8uLzdZCVJfkSDxOeUUF6668kmXLlyNJEvfeeyfbt48xMDDAmTMDHD4c\n", + "YNmyjdjt9oX3oWkaIyNjtLZeSUVF/cLjpVKR5547wIoVy7BarciyzPr162hra2V0dBSYt4F/O61v\n", + "r2Zubo7dTz/NcE8PoiTRvno1W6666h27/F0Mjh3rxe0+V3AYjRZMphoSicTr7mez2Vi9YhEdZ62O\n", + "bWYzo4EAJw8exKSqrFzRzsnuYWaSRZTKRkKhARobLdx555+RSqXo6eml73Qvk/39HE/mKcgdSJof\n", + "QRUxGOIYjWaSyXHs9g70+kV0d58A9ExMTJw3uhtgbGyMX/ziWRYtup7RgQAKsxg0mYwSxeYvY3Hr\n", + "Frq7J7jhhgxmsxlVVTl08CBHdu8ml0rhrqjg8muuofVVRncfFb79bbjllnn79486X/7yvM/KE0/M\n", + "D9L7MNHT04/ZXHVOlECSZGS5jP7+wbcsRoLBKJrmYzKQoMzsx3HWkG02mmbnoW7KvRYSiQBVVa/M\n", + "tspm06xbt4RvfvOz3H//o4DEypVLSaeD6PVRtm3bTs+heqTJSWIzUer8leiKZzAYTSxe1sGxniFi\n", + "BRHPkluprV0OgNmsw26vYPfuY1xzzTXIsszU1BQ//envyeddmExOurqGeOGFo3zxix9fuIFUFIUD\n", + "+/dzbO9e8pkMPr+fTdu3881v3rXwO9/Q0IDT6bwIR/3icikLWP/sUr32hTh69BhjYwr19a98yQqF\n", + "ah55ZDdf/epnmM7nKQwNUdfUxK7gANF0lFg2g7u1gw2X3YSmqeTzOfw+D3KZj0hpmrLaWm66/kqC\n", + "QTexWAyr1caqVZ0cOnSQRCJHqdSMxZKlslJHU9NiKiurKS+vJRIJUN2o8OlPf+ycNYqieLbHvoGt\n", + "W7cSj/8Lrw1ABIMj6HQSXu+53hK5XJozXd38w3/+z7g9HlpWrOCKq6/G5XK9YwHyMslkkl/98IdU\n", + "FApsqa5G1TQGDx/m1xMTfO5LX3pXbn/vhtcJuL1pEa4kSXSsW8fEnj0sO2t93+z30+XxsLevj+79\n", + "+ygAtpoaNm/t4LLL1tHW1oYsyxgMBjZv3sSKFct5/OGHeX7XfjLJWdy+Sly+aqqrnXR1HUOSiuh0\n", + "MsHgfmpry6iv38DDDz/FX/zFF89b3759R7FaG7BYHOjM5eja15COjZPOzFG/cjPt7SuYnDxOMBik\n", + "vr6e3c89R9+zz7KsqgqL281cIsEf7r8fvvCFj5Qg6e6GX/4Sensv9UreH+h08E//BPfeC1u3zk/3\n", + "/bDweuf6m/3fa6mvr+TgwRM4PI1kExmMeg0BAaO+RDxtpGVNPe5KjbGx4xiNHgqFNLI8x+c/fwt1\n", + "dXW0tbXR3d3LSy8dohQfxq4zMXGmj41XX81oXx+lM2cw5HK41i9he3MzZr2e6g2zPPz7fsrK6olE\n", + "hhEEEVk2YrGISJKD3/zyl4RGRzly6BgY61mx4XocDi9QRTg8xaOPPsO9985HT57ZuZPxfftYUVmJ\n", + "2eslFIvx6I9/zK333nuOZ8r7kfdDAev7gmPH+vB6z72L1uuNRKNF/sf/+GcEoZbDPX0omTniShFT\n", + "2XJamtpYtXY9oigwMHAAozJE2ZyNjy1bhtrRQe/oKLv37SYQUjAbGtBb3NS3t9LS4sdmS+Dz6VDV\n", + "elatuhpJeuWjsFgcjI6eYnZ2Fq/Xe8GUh06n45OfvJaf//wPRCIedDoTuVyY+noTTmc7+XwGWZ5v\n", + "+8rl0nTt/R2e2AxbNmzC7nAwfOIEv56c5K4vf/m8MH4oFGJychKdTkdjY+Ob2jWf7OrClkpR//Ik\n", + "SKC9poYjo6MMDQ3R1tb2Tj6Sd82qVYt56KFjZ0/ceQqFHIIQveB8nVezaetWHgmF2N/Xh10UCSST\n", + "TEej3LV9O5Ki0HfyJIGxMY4/9QRaKobT6VwwFysUCvz6vvuwx2J8tnMFOw/0EQgdYSIxgd1bhap2\n", + "UVbmI5vNIst2xsdDaNo+/H47p0+fpqmp6Rwvl3A4itXaDIDJZEYUvbhcdUQiU9jtZWdbkHMYjUbS\n", + "6TQn9uxhY13dwiA8j93OIk1j/7PPfmTESKkEX/wi/Lf/Bl7vm2//UeHqq+drZ/76r+G7373Uq7l4\n", + "dHS0ceDATlS15lVpmhKlUuicAXlvxoYNa7nvvt9htbaQF10EI2GK+RkslhyCvYqNW69i69Yt9PX1\n", + "MTY2g8dTTkfHjQuTaiVJYs8zT9G/axdNZjM6kwnyeQ5MTbHlk59kxy23UCwWcbvdiKKIoiiMjo7y\n", + "b7/9EkePhpFlP5qWQxCmWbduJUf3/QFfpI7V7e3MaQYEVeHU3t+x4oqPY7U68XiqGB8fJplMoqoq\n", + "pw8c4LK6uoXhmD6nE0VV2b9rF3V3333xD/xF5E9i5CyiKJynoBWlRHd3D52d22lqaqO9fT1zc3Mc\n", + "PvwUZnOJymovodA4mcwsNmsCd0wjHo/zRG8vsiyTmJvDm8uxvnM1M3Npxmb7OHXgCJ++59N86lN/\n", + "RigUYmbm4XOESDqd4fnnn8VojPB//+9vsVrh5puvOs/EC+adYL/+9bvo7e0jkUhRX7+E5uZmjh8/\n", + "wUMPHaG+fhWiKDE9OYAhOktTlXfBBrm1upqjY2MMDg6yaNEiYP4O4qmndrF3bzfgAhT0+l185jPX\n", + "vaEPS2BsDO8F8pZOnY5gIHDJxMjy5cvo6Rmgr+8QZnM5pVKBUinALbdsftOhXAaDgU/ceSfT09NE\n", + "IhEO7t3LDU4nXpuNQ889R4vNRofbzeFIBGc8zsM/+Qmf/4u/YKC/n50PP8zwwYN0Ll3KosVt2GwW\n", + "Dnf10TN9Cld5iXS6jLq62wmFwkSjaVTVwdDQCQRhhEwmR2WliyuuWM3mzfNeJ3V1lZw4EcRkstLc\n", + "3MKJE0N4PB1ADrPZQjA4Rk2NjfLycqampjDDORN5AbwOByfHxlBV9SNhjvbd74LVOh8F+BPn8t3v\n", + "zhexfuYzsHr1pV7NxaGxsZF16+o5ePAgRmMFmqZSKMyydWvH23Ig9nq9fPazO3jggReQZT1GSxGf\n", + "r4nW1uVksxM0Nc1bqS9fvpzly5efs6+mafzmpz9l8sABtvn9hDMZxmZmON7fT8vKlTz76KN8/a/+\n", + "auHmsqenl0ceeY6pqTC5nBlJKqeiovpsxNTGc8/tp9GUJGbzcDLfA6i4rQ5ysTCTY720L9n48isj\n", + "iiLhcBirIJwzpRvmBcmZsTHe7/xJjJxl7doOfve7E9hsr6QspqYGURQdNTUNwLzqLSsrY/PmG8jn\n", + "e+jsrCCbzdHaeiVdhw+z98E91IoiLRYL8ViM0cFB9C4XgqJwy+VrCEQi9IyMMj06RDabpaqqipYW\n", + "D8eP76GmZhEWi4tnn32GTCbMli23Y7O5SKcT/PznT/KVr9gvmPd0Op1s3Lj+nMdWr15FMDjH/v37\n", + "EAQHo/37aLKrrO1ccU4KwCHLBAOBBTHS39/PCy/0UV+/EVGcP2HS6QS/+MUTfOtb975uhMRVVkaw\n", + "v5/y16R70qUS9kuYm9TpdNxxx8cZHBykv38Es9lNR8fWt1W4VVVVRVVVFS/u3EmFx8PY0BAOUcR4\n", + "1vzNLopIoog1k+G+f/1XDHNzuCIRlsky8TNn2DkywvKWFi5b3cHq1UtI+f2UlAmCwRmiURWrtZZI\n", + "JIaqNqLXlwiFSixZsoadO7swmUx0dq5h48a1HD/+C8bHCzidPmprg/T0PIHH4yGROENlpZFPfvJW\n", + "BEHAZrORUZTzREcincbqdH4khMjJk/Cd78wPxPsIvN23jc83f3zuuQcOHZqf8PtBRxAEbr75epYv\n", + "H+X06QFEUWTx4vXUno3Wvkwul2NgYIBkMkV5eRkNDQ3nnRPXXLON/v5pCoUyysrqAI1AYIi6OvMb\n", + "znOanJwkPjqKS69nKBwmFgxSq9fjNxgInD7NUDDI9N13U1NTw8TEBA8++DRlZSsoFo/T2Hg1MzOz\n", + "hMMTiKJEsWjHZPJT7Y3i9TQSCk2gqnmSyQgOo5nxufnuu2BwjObmCiwWC1arlWSxSCwWQ6/XL/xe\n", + "x1MpHB+A8OCH4Gv49kin0wwNDZHP56murl4Ye79y5Qr6+obp6zuEXu9BUQpEIj0sXtx6nuuoLOsA\n", + "4znuf7ueegpTKkVTXR2qphFOpajM5TgxNoaroYG8InByJEGxZCMyPEumdD/tbT6io/0Y5oY5cOIP\n", + "ZHVGVJ2XHTs+sSCKLBY7yWQNhw4d55Zb3loRliiKXH/9djZu7CQYDNJ11Eixt/e8YtJ0qYTzVZbC\n", + "hw6dxOGoXxAiL79+OGxneHiYjtfpCVy2ciUPvvgivlQK59miz5m5ObI220WLigSDQY4cOEBgbAx3\n", + "eTmrN2y4YLHna5Ekiba2toV1hEIhjhw5gizLNDY2nlP8+0Y4PB4SoRDZVArDq9JaL9vlh2IxJsfG\n", + "+OSmTUxIEpOTk3gEgb7uMzwTKFDtqWQyNolng0ZjYyPDw6dR1TLS6QSxWBi9HrzeSrJZmVQqRmVl\n", + "By+8cIi1a1cjyzIec57je35DKpaiaDBw++3XsG3blTidTqqrqxdEpsPhoH75cnpPnmRxdTWiKFIo\n", + "FumdnWX97be/gyP/wSIeh9tug//zf+BNMnEfae68c94I7n//b/jWty71ai4OgiAs1NRdiJmZGe6/\n", + "/yHSaROiaEJVT9DYaOezn70No9G4sJ3dbueeez7J00/v5vTpF5EkgbVrF3HVVVvesEswlUph0+sZ\n", + "LRbJB4OssVgQBQFFVSmVSpRKJXpOnqSmpoYDB45hMtVhNtsoFovodFba21cxNtZ19trURiikEo5N\n", + "MDTQj6oqSPosFkucyWCAXFULY2NdOJ15brxxfvDQyPAw3WfOMDE3R4XFgquykpYlS+ienqZ+0yYO\n", + "Hz5MRUXFOb8X7yc+UmJkcHCQBx98nELBAcho2kt0djZy003XLdxFDw8PMzo6gdlsorp6Mz/84UMU\n", + "i4WFHm2AcHiCLVvOzb1LqorRaCSTyxGemSEdDpMvlbBoGlP9/RztS7Fy6TaiqTRNtbVomoGHv/dj\n", + "vnTzdrZs2YSqKOw+coT9MxpOp++c57ZYHMzOzrzt9/tycarP5+NnZ84wl0jgOXvxnQqHydrt54iF\n", + "XC6PTue4wDNJFIvFCzw+j9fr5ca77uKphx5CGR9H1TRsVVXcfvvt55zk75TJyUke+uEPqRJFGux2\n", + "4v39PHTiBNfcccdbNmLTNI1nn32eF144CXgABUl6nttuu4rly5e96f6rL7+cJ++7D4/dTmR6GrvZ\n", + "zGQigehwUO5ysa+/n2rbvHNrRWUlfcePMz40ToW1nBkEJKOVoruOdMYCTFNTU0Gp5CWZzJDP69Hr\n", + "i/h8NQiChqKUMJmshEIZCoUCv33gAaryeTbedB3K2XbvrtAsTqfzgoLs2ptu4ilBYN/JkxiAvCSx\n", + "+tprWfVhicm/DooCn//8fF3EHXdc6tW8vxEE+P73obMTbr4ZPuylRJqm8etfP44kNVJX90pkdHj4\n", + "FHv37ufqq8/13PD5fHz2s7dTKpUQBOEtWRX4fD4yoojD6yUwOLhQIZzJ50lLEovb25kaGgIgGIxg\n", + "tc7XKFZV+ZmZGcZs9qDTmQERg0FHPDqKOaeSVWM49WbCkVlqanw4W71svqqTxYtbaWtrw2g0cvr0\n", + "aQ787nd8dtMmjvf2EpyaYnxwkOcnJ3E0dBA+EuXo0TSadpClSyu5/fabL1ljwevx/lrNH5FsNssv\n", + "fvEEdvtyLJb5C7Kqqhw8eISmph6WLl2KKIo0NzfT3Ny8sN+OHet5/PHDWK11GAwmYrEZ3O4c69ef\n", + "68nvKy/HsGwZw6dOEQ4EcJhMpCwWJEVBEY1IWRNTgQBFq432pkbOHH8Wv8FDMh7H7XQiShLLmpo4\n", + "0LeHeDx8jiBJJMIsWVL5jt+72+3m5i98gaceeoj+iQkUTcNRVcXHXyMWOjpaePzxXux2z8Jjqqqg\n", + "adE3dTJsbGzkS9/8JqFQCFEU8Xq9F019v7BzJ01GI5We+XXZLRYc6TTPP/YYbW1tb+mHYmRkhOee\n", + "66G2dsNCjU4ul+Ghh56jrq72TVvdWltbid16K7sffZSBQoHe8XEqamrYuGIFpycmMPv9WM56rOj1\n", + "eqqamxkai1DIJAkKIkgSSy67GUUpoSh9hEIB5uYUvN4KAoHTGAwyLlc72WwvTqePRCJCWZmTyclJ\n", + "1FCI+rOeKJIkYbNYqEunOXbgwAXFiNFo5OaPf5zE9u2k02lcLtdFEYXvZzRt3vY8HodfvdZi8U9c\n", + "kMZG+Ju/gbvvht27Oa8z78NEIBAgHC5QW3tuiraysoUDB46cJ0Ze5u1csL1eL82rVxMPBlHtdkYz\n", + "GdRikbiqsnTjRvz19aTORo7r66s4fDiExeLA729ifHyEcLgXTcuhaWlGRvbi1sOqRTsYmzjJxNw4\n", + "HruRrtlZ7vriF7n66qvPee3De/bQ5vHgtFrZ2tlJKpsllc3yvZ17aa24DL+/HpgXZSdOHKO+/hjr\n", + "13e+jSP4x+cjI0ZGR0fJ561UVLwSlhdFEZergUOHTrF06dIL7nfZZRuoqqrg8OEuEokwGza0sGLF\n", + "8vNSHss7O3ni5ElqW1uxqipeh4N6VWVPMEgwrTJXUkAUuXLzJqxWK9lUFLfehKqqC8/h9niochkZ\n", + "Geli6dItSJJMODyFKM7S2XnNu3r/9fX13PuNbxAOhxFFEY/Hc942K1Ys4+jRHkZHT+J2+ymVisRi\n", + "I2zZsgSfz3eBZz0XURQvupFOPp8nODZG+2suunaLBSIR5ubmKDs7YO6NOH68B4ul5pxiYaPRjKK4\n", + "GBgYZO3aNW+w9zyd69axbPlyBgcH6TpyhJnhYXoyGTouu4zrOjt58J//mWgyictmw2wy46tuY6JU\n", + "YNW666irW4QgCEQiAerqmrjppu38/d//gGQyxJIlTsJhjVism9Wrl5LPZ5mb6+Wuu7aTSqUwXUDU\n", + "2S0WxoPBN1yv3W5/y2moDzKqOp9qOHIEnnsO3udDpd9XfPWr8JvfzLf8fu1rl3o1fzzmIxznqy1J\n", + "kikWL95otB033YTN5eIH4+MUslkqKyrY1NGB1+fj8NgYV916KwDr1q3m8OEHCYdNeDxVrFmzma6u\n", + "5xCEFI2Ntex54RButRxNU3F7q3G64dp1iygpCvIFfg9ioRAtr6rZs5pMxNNpUBxnoy3zCIJAWVkT\n", + "Bw+e/JMYuVS83pdRlnXk86+fggDeMA/5Mk1NTay+7joe/tGPUHM5kno9OYOBT9x4I/F0ml8/P0pj\n", + "R8dCC5jVXUl8YAS3+9w6jNrFrfhXNtLXtx9FUWlq8rNjxycW5g68GwRBeENRYTKZ+OIXP83x4110\n", + "dw9gMhm55ZZtl6wbBubvTARZpqQo6F51l6JpGiVNO6cF9o3I54vI8vnbiqL8himo12I0Guno6KCj\n", + "owNN086J/tx81108+uCDGKJRcrksPekA7etvo77+lVRSPD7FddetZ9myZXz/+/+LI0eO0dc3Sig0\n", + "SzKZQZbnkKQin/vcNbS3tzM5OUniAj4JoXicyos4MfODSqEwf2c/MjLvLPoR0F4XFVGct8vfsGHe\n", + "CO1VQeEPFRUVFRgMBbLZFCbTK9O7g8Exli+/eDkqWZbZsnUrLW1tPPzTn6JLpQgWiwxMTbF827aF\n", + "rkiv18u9936cJ598gaGhF9DrZW6/fSNXXrkZo9FIQ81POfz405h02f+fvfeOjuM687Sfqs4RjW4A\n", + "DTRCIxCJAcxJpEiKoiUrWrIkW9LI+hzkMOPxN9m7nvlmxzvnTLDXk2fHXnstW7ISrSzREhVJUcwZ\n", + "mcixATTQ3eicq+r7AxDMv9Cc7AAAIABJREFUqGSSAEk85+AAqND1Vt2uW7+69w0sKLGyqHwdFqOR\n", + "9qEhdAbDOcd1VVQwMTBA8WmOqplslgwiJtOZ1crVai3J5Mfv8y4X14wYKSkpQVHeRpKyZ7wd+/1D\n", + "3Hrrxfkybrj+ekrKyvjJP/4jNXl5VLpcqFUqzAYDRlsbWdlHIDCGJGUR9ApisY2EJGFVFFKZDO0e\n", + "DzVr13LnPfcgTUdEXO5U3gaDgeuuW3dOhM5soVKpWLh6NR0HDrD4NM/4vrExnAsWzIi7j2LRoipa\n", + "Wg5jtxfOLJNlGUnyU15+TrWCj8XZ01But5tv/cVfMDAwQCaToajlFMeODTMxMYxKpSYU8lBTY56J\n", + "XrJYLNxww+aZaruKokw7s2lmPru4uJi8mhqaOzupcbnQqtV4fD68osi2dXOjjWaLQADuuw8sFnj7\n", + "bThPHz3Px6C6Gv7yL6fysuzadXVGIGk0Gu6+extPP/0mGk0xBoOFcHgciyXC1q0PXvTjuVwuvvXn\n", + "f87AwADpdBqXy3VOX+VyufjqVx8kk8kgiuIZ081btm1joqODVUVFM5F78WQSH3DrdP9xOus2b+a5\n", + "n/wE9eQkztxcEqkUo6EQdpcJjebMBp2YGGTjxrnnJCR8kux0lxNBEC5UsuZTs2vXe7z5ZhNmc9l0\n", + "QjMPLhd87WsPYLiIPVlLczNvP/cc1mnnp6AgsP6WWzCYTDQ1daLTaVi+fBFarZY9b7yBd3AQrV7P\n", + "so0buW7jxjnnWHS5EIRzc73AVDjei888g7+rC4sgEFcUdEVF3POlL31sMZLJZHj88V/T3R3HZitB\n", + "krKEw4Ns2FDJHXfccrFPBZgSF93d3Zw40UoqlaGhoYaFCxd+YoGZSqXYu3s3zQcPks1kKKmuZvNN\n", + "N81Egl3pXKjdP4z2drjzzinnyx/84Or2d7gcSNJUMrQHH4Q//MPLc8xP0+6/K6Ojoxw71ojfH6aq\n", + "qphly5ZiNps/esdZ4Ojhw7z/6qvYFAVFUQir1Wy7914WX8ClYGBggPd27mR8aGjmeaLS6Nix4zBG\n", + "Yxl6vZFQaIzc3CTf+MaDH5lr6VIw3ebndSacNTEiCMLDwNcAHfBTRVEePWv9RRcjAD09PRw92kQ8\n", + "nmLhwkqWLm24JM59sViM/v5+FEXB7XZ/aMNns1lUKtWcDLe6nHxY56QoCh6Ph0AggMViwe12f+Kc\n", + "GZlMhubmFpqaOtFo1KxcuYja2tor5rrLsowsy1edWP2kD6WdO+Hhh6dEyFe+cgkNu8bo6ICNG6eu\n", + "7+UIvJoNMXKlEYlEGBgYQBAEysvLP1atr0wmMzW9Pd2vDQwMTPs8xqitdZ/X5/FyMVfFiFpRlKwg\n", + "CCJwWFGUVWetvyRiZJ4PZ2JigraWFhLRKO4FC6iurr5sD79rpXOKRCK0Njcz6fPhLC6mfuHCizoy\n", + "d6XxcdtdUeDf/m1KhDz77NSDc56Ly7PPwne/O+UMfB4f94vKtXK/X0wymQynTp3C09eH2WZj4eLF\n", + "F8Wf8HIxJ8XIjAGCYAB2Koqy+azl82LkMtPU2Mi7zz6LUxTRazSMJxKYq6q470tfOifx26XgWuic\n", + "PB4Pzz/6KLnpNBadjslkkqTNxv1f+9rvXLDwSuXjtHs6PRX5cegQvPLKfEKzS8l/+2+wb9+UQ/Cl\n", + "fIG+Fu73i0k8Hmf7L39JdniYPIOBeDrNhCBw60MPXTE1pz5MjMyqq5IgCP8D6AQe/aht57m0xONx\n", + "3n3hBVY5ndSUlFDmdLKqvJxkTw8njh2bbfOuChRF4fXnn6daq2VhaSmlBQU0lJWRF4ux+803Z9u8\n", + "Ocvo6FQis/HxqYfkvBC5tPzDP0xF1dx1F8Ris23NPB9waP9+VCMjrCgvp8zppK60lGV2Ozt//etP\n", + "FBE4V7nkYkQQBKcgCLvO+nkaQFGUvwWqgEcEQTjHi+j73//+zM/u3bsvtanXNAMDA1iyWQxnhcqW\n", + "5+XROi9GLgqBQID4+DgFZ42AuJ1Oepubr4oO5WLz2muwYgVs2QIvvjgVOTPPpUUU4f/+XygpgU2b\n", + "YHh4ti2aB6D16FEqzsqpZDEa0SWTDF8FjXTJnQEURfEC58ROCoKgVRQlDWQAGThn6Ob73//+pTZv\n", + "nmmuFCfOea4NjhyBv/s7aG6Gp56CGz5d9PU8nxK1Gh59FH74wykx+Pd/P5Vq/yrznZ5nDjGb0zTf\n", + "EwRhF7APeF5RlMgs2nLNU1ZWRkStJp5MnrG8b2KCRVd5TZPLhd1ux+R04p2cPGN5v9dL5ZIllz2n\n", + "zFzj+HH48z+HJUvgC1+YCjVtbZ0XIrOFIEz5j7z1Fjz+ONTWTjkPd3RMORPPc3lZvGoVvV7vGcvC\n", + "sRgpvf4jy3VcCcy6A+uFmHdgvfy0NDfz9vbtFIgiOrWaiUQCa00N9/7e7807sF4kRkZGeO7nP8eW\n", + "TmPRagmmUiRtNh545JGPrI9ztfJBu7/6Kpw8CTfeCGvXzucOmWvs2wdPPgk7dkzVAKqrg7w8sNmm\n", + "hIssT+UricWmfqLR3/7+4G+PZ2ofuDbu94tJIpHgmV/+kszQEHkGA4lMhgm4ahxY57QYmW0b5pln\n", + "nnnmmWeei8eFxMicngGcq0LpSiYWi/HTH/yANQUFM2mGAU7297Po9ttZd911s2bb1f6mJMsy/+ef\n", + "/okFgoD9tCIq3SMjGJcs4Y577plF62aPq73dLzWJRIL/84MfsNJux3haAsfmgQEW3HwzGzdtmkXr\n", + "Lsx8u197fJhv4lVYhWCeD2NwcBCrJJ0hRGAqaqbt+PFZsuraYHx8HDkUOkOIAJQ7nXQ2Np5RwXme\n", + "eT4uQ0NDmLPZM4QIQHl+Pm3zkXDzXCHMi5FrjAspU0VREOcjai4pgiBMTa6ff+XlNWaeq4YPvaev\n", + "xqp381yVzH9TrzHcbjcRjYbYWVEz/T4fC1etusBe81wMCgoKUOfm4guFzljeMzpK3fLl8w+OeT4V\n", + "ZWVlxLRaoonEGct7Jybm7+l5rhhmszbNIuCngAS0Kory+2etn4+muUS0trTw1vbt5MNU1EwqRW5t\n", + "Lfc8+OCshpdeC3PIw8PDvPCLX5CTSmHWagmkUlBQwP1f/eqsVNGcC1wL7X6pOXXqFDufemrqnlap\n", + "8KVSWBYs4L6HHroskXCfhvl2v/aYk9E0HxTKm/77UeA/FEU5cdr6eTHyKUilUqTTacxm84c6CwUC\n", + "Adrb2qYK4lVVUVlZiWqWYymvlc4pEolw7OhR4pEIpRUV1NbWztkHxuXgSm/3dDpNKpX6yHvuUjM5\n", + "OUl7WxvxSISyykqqqqpm/Z7+MK70dp/nk/NhYmTWomk+ECLTGIDgbNlypRKJRDi8fz+djY0ogkAi\n", + "m0WORtEIAuaCArbefjuSJHGqqQlFUahdsoTq6mpEUcRut7NhuuxpMpmkq6uLbDZLSUkJmUyGQCCA\n", + "1WqlqKhols/y0pDJZOjv7yeZTFJYWEh+fv55t5NlGY/HQyKRoKCg4JxcIB6Ph+YTJ0hEo5TX1LBw\n", + "0SJ00yn1M5kMx44cofnQIbKZDLXLl5PndHJ41y6iExPIgoAsSSxYsOCSn+88U0L96JEjtBw+jCLL\n", + "1K1YwZp16zAajZ/q89LpNLveeosj776Lb2SErChy/e23c8fnPnfBz1QUhbGxMcLhMHa7/Zzv3cjI\n", + "CD6fD7PZjNvt/kRiIjc3l+s2bPhU5zLPPLPNrOYZEQThTuDvgKOKonzlrHXzIyMfQjwe51c/+Qnm\n", + "yUlK8/I4tH8/nuFhCmtr2bZ2Lb5QiFePHKGooAAzkMpkUJvNVK1fzx2f/zyRSAS1Ws3Y2BivPfUU\n", + "xnQaJImDp05hM5lYWFFBTJaxV1Vx9/33f+oO+5Nwud6URkdHeeGxx9BEImgFgaAsU7t+PTffdtsZ\n", + "fhuBQIAXnniCjNeLVhCIAIs3bmTrTTchiiLHjhxh74sv4tJq0arVdHq9iIWFfPOP/giTycRzTz5J\n", + "sLWVBQUFqFQqWnt62NfWxhe3bsXlcJCVJDo9HsTKSh78yldm3qo/eGCl02kKCwtnxM2HIUkS4XAY\n", + "vV6PwWC4VJfuknA52l2SJJ557DGS3d1UFRQgCAIDExNki4r4vUce+VjX+Gxe/PWv6XnnHdIDA9hE\n", + "EX8ySWsoxMKbbuKPv/c9rGdFTcViMV565hkme3tRZbMEMxmqV69m5bp1yLLMkb17mejsxCoIJBQF\n", + "VUEB9z788FVbzXl+ZOTaY06OjAAoivIK8IogCP8uCMJnFEV56/T1p9em2bJlC1u2bLm8Bs5hGk+e\n", + "ROf3U+d2EwgEECMRri8v5/joKN7JSTSKQqKnhzePHqVApUIHBFUqDp48yammJoyKQjKdpqO7m7tW\n", + "rcJVWMiR1lbc8Ti6RAJXfT35+fmc6u/njR07uPsLX5jtU74oSJLES7/6FVWiSL7bDUyNfhzdt4+m\n", + "khKWLV8OTAmCF598krxIhNLp7SRZ5uju3TgKCqiprWXPK6+wxuXCGwhw8NgxtOk03hMn+NvhYe76\n", + "0pcYb2tjbXn5jMjQJpOUpFJMhsO4HA7UKhULy8o40NODx+OhpKSEiYkJXnnmGRJjY2hEkaRazcZb\n", + "b2Xl6tUXPKeW5mbee+015GiULFC9YgXbbrkF/VmhntcyPT09RLq7WX1ayd9FZWUc7++nvb2dZcuW\n", + "faLP8/v99B0/jjw6ihZo8ngwSBKWTIYDL79MRW0tX/ryl8/YZ+fLL5Pq7ibp8zHu8RBNJHjz5Zep\n", + "W7QIm9XK6PAwn7vxRsqcTmCqTMCO557jS1//+u949vPMM/eZNfd9QRBOnyQPA+dMmp9etXdeiJzJ\n", + "YGcnRo2Glt5eTnR0kEwmEQQBiyzTMTjIqa4uOoeGqEsk+KzDwQ0OB1t0OkaOHmXs6FE2lJVRo9Xi\n", + "9Pk40thIMp2mt7eXGrsdh16PZ3AQgBqXi4GmJqLR6Cyf8cVhcHAQIRQi/7TpFlEUWZCXx8kDB2aW\n", + "jYyMkBobo/S0YXSVKFJbUMCxvXsZGhrCKssk02kOHTpElSCQAxSo1SRPneKZn/8cUzZLJBIhEAiQ\n", + "zWaJTE5SmpPD2NjYGTaZBYFgMEg2m+X5xx8nPxJhvdvNqtJSVjkc7H3hBfr6+s57Pj09Pbz95JMs\n", + "0um4rrSU61wu/MeO8epzz13cC3eF4xkcxHEevxyn2cxgd/fM/4qi4PV6GRoaIpVKXfDzgsEgxOMk\n", + "YjG6h4dZqFZTZzRSpdWSF43y9H/9F4FAYGb7cDjMYGsrw4ODiKOjLDabkf1+bjQaob0drdfL9XY7\n", + "Bw8dIhSLAVP5ZyYHBvD5fBfxSswzz9xkNkdGPisIwp8yVa23D3h9Fm254vCMjtK1axeVZjOpRIJT\n", + "/f2MBoNMhkJY43GGx8cRolGKT/P5kNJpFokigyMjAGQliRKzmYlwmEGvFyQJjUqFRqUiMd0Ri6KI\n", + "WhBIJpOYzeZZOdeLSTqdRnseJ0OdVksyHp/5P5FInHc7o05HfHISURSRBYHuwUGM6TTHRkawZDJo\n", + "ZZmEIDAeiTApijTk5aECsmo1skpFNBbDWlp6xmfGFYWcnBz6+voQAwGKp0diAPRaLeVmMycOHqSi\n", + "ouIcew6/9x7VNhuW6Wk0tUrFotJS9re3Mz4+TsFZJcevVYxmM0lJOmd5Ip0mPycHmJqWe2X7diLD\n", + "w2hEkZRGw6bbb2f5ihXn7Ge1WokrCmPBIEXT90jX+DhKIkGBSkVqbIwf/s//yZ/+1V9RUFBAMpkk\n", + "Gg6TnZyk3G6na2ICuyxTaDIRTSYJTEyw1OkkP5Wid3iY5bW1AGgEgXQ6fWkvzjzzzAFmbWREUZRX\n", + "FEXZoijKZkVRvqwoynz6yY/JxMQE0ZERSnU6yqxWFrlcVBuN9PX0kFWr2VRcjNtgwCbLBDOZmf3S\n", + "6TQmtXpmnjbXZiMGGIFUOo3GaMQfjxNKJHBMi5hoIgEGw1Uzb11UVESIKSF2Oh6fj8qFC2f+dzqd\n", + "RAThnO1G/H7K6+pwu90ktFr8k5MMjo9TpijUmExYRZFVJSWY/H6GJybIMxopt9spMxqJ+f0cDwbJ\n", + "s9tJptNkJYlTw8NYKyooKSkhHo9zPs8Fi9FI6LS37NPxjY5iPyskWBAETIJA6Kx8JtcydfX1+EWR\n", + "8PSoA0A8mWQsm2VRQwOSJPHcY4+R4/dzndvN6tJSVubmsufZZ2dGpRRFIR6PI0kS+fn51Kxdy0gy\n", + "iSBJjIZC6FIpjCoVNrOZGpcLWyzGa9MjVHa7nRignf4+JdNpDKJIMpPBYrGg1emYjEYxqtXEpm2M\n", + "JZNkdLoLOlfPc3UxPAx/+ZfwF38B0wPT1xRzujbNPOenu7OTKpsNw8qVdDc3o5NlQpKExWBA0GoZ\n", + "DocxOxwIOTkkEgm84TAGjYaELOMXRcorKwGw5eaSV1bG6wcOYEkmUdJp9g0OUlFSwkMOB2OBAN2h\n", + "EFu++MU5HSL4SbBarazcto3DO3dSabNh1OkYmZwkaDJx62mRCBaLheVbtnDkzTepyc/HpNczGgjg\n", + "URQe3LwZnU7HLQ88wL/87d8yHgiwODcXXyyGPicHUaslXxBQ5+fTnslgiscRgXFRxFRZyWtHjyJH\n", + "owgGA+tuuYWvPvAAgiCQn59PmKmH3ukhot7JSUovUDMov7gY/+goRQ7HzDJFUYgqyjVbBfh85OTk\n", + "cNtDD/H69u3o/X4EIKbRsO2LX8TpdNLT04Ps81F22qiUQaejwmLh2P79JOJx3n/jDRKBAIJWy/JN\n", + "m7j985+nra2NY088gSkSoUSrxWC1YrTbSVmt1LrdDI2M4Pf7cTgcbL7lFrYfPUqJyYRJr6cvmUSl\n", + "1WIuLMTmchEIBvEGg9RVVzM8MUF/NMqWL35xVnP/zHN5eOcduP9+ePhhUKth3To4cABO+zpe9cyL\n", + "kSuQbDaLKAi4Kyqw5+XhGR7GEw5zXVUVaaeTtUuWYNDr+YUkMdbRgdNiwWqxIBsM9Pl8bJkuNy3J\n", + "MpOiiGIwUONwYNRoWFVfT+foKC82NbFhyxZuv+8+qqqqZvmMLy7Xb96Ms6iIkwcO4A2HKb/+em5f\n", + "s4ac6eH6D9i8dSuOggJO7N1LJBTCvWQJD27cOPOmWl1dzbf/+3/nbzo6iKtUuPLzMRqNdHg86A0G\n", + "8u127ty2DX84TDqdJtrSguT18vC99yIoCtFkks6JCTweDzU1NbhcLlxLlnCysZGaoiJ0Gg3DExNM\n", + "aLV8du3a857Lui1beOmnP8Wg02Ezm8lks7R7PJQsWTL/Rn0W1dXVuL/7XYaGhlAUhZKSkhkn31gs\n", + "huE803JWo5F9ra14WlpYnJ+PrayMZDpN6xtvkIjF+Iu/+iv+t1pN20svUeJwoDca8csy+rw8ivPz\n", + "GR4enqk59NlbbqHtxAk6Dh7EolaTdDiIqFQoajUr6+sZ9vkY9PvxarVIVit3PPAAldMvDvNcvezd\n", + "Cw88AM89B5s3Ty2zWuE734FXXpld2y4nsxra+2HMh/ZeGI/Hw3P/+Z8Iw8N0HD+OKp0mFI8TU6u5\n", + "8/77WTQtHmKJBP/1m98gZ7PIkkTdihV85q67GGhvxz88TDyVou3UKVY7HNRWVZGXn48oikiyzP7h\n", + "Yb763e+eE554Pk6dOsX+/ScIh2PU1rpZt27Vp5rWuRJD/RRF4d///u8RurtJ+HwIokhOfj7dp06R\n", + "V1PDoupqdh1uorW9i7BviFXFhZRVVdGwahUarZZT3d0MGwx860//lJKSErLZLIcPHuTEvn2k4nGq\n", + "Fi9mww03nCEsgsEge3ftoquxEbVWS05xMVGvl3Q4jKJSsXDNGrZs2/apwlVng7nQ7qOjozz3n//J\n", + "+rKyM0aluj0ejo2Pc2NlJXmnidV0JsOzR46gLyxjMhRnuKsVSyxImdNJRXk5S6qriSUS9AgC3/iT\n", + "P6Gzs5NDu3bhGRzEHwigV6uxmkz4IhGMej02mw2V2Ux8YgKHRkNWURDtdj734IMUFhbOxiW55MyF\n", + "dp9tenpgwwZ47DG4+ebfLk+loLYWnn0WPiSQ7opjTmZg/SjmxciH81ff/S7Hn3iC1TYbBq2WrnCY\n", + "tnCY9YsW8cD995NIp2kbHaVq0yZuuvVWYCocsbenB4BwJMKb27fTsmcP661WRJOJXLebFWvWoFar\n", + "OT48zM2PPEJZWdmH2vHee+/z+usnyc2tQq83EQiMotf7+eY3H8But3+ic7qSOqexsTEGBwYQVSq0\n", + "Wi27nn+eAkXBajQSiMXY19mJVaOlfyhFaDQLikTE38HyQguLKwroDwaxmUzkaDTsDwQoqqzEWFLC\n", + "rXffzZKGhgvmdYlGo/zqxz/GHo3idjrJShJdo6NoFyzg9nvuwWAwXHHZXOdKuz//zDNMNjZS53LN\n", + "jEoNSBKhcJjb6+pmtstmMrz37ru8drgZS8l6rGYn3kSEVMbDTUucFBr0eEZHCRoMfOmP/xiNWs2u\n", + "p5+mzuHAbrEQiERoGR9n4z33sGbtWgRBoLe3l1d/9jNWFRfPVNTuGBri5OQkdz/4IDW1tThOm4q7\n", + "Gpgr7T5bTE7C+vXwR38Ev//7567/4Q+hrQ1++cvLbtolY87mGZnn05FKpRg5dYr1CxeSTqWIAMtK\n", + "S1mUyfD28DAvt7ZitdsRTSaaDhygu6UFTU4O4f5+8kWRVCrF06+8wjKLhSKNBqJRiMcZTyQYdDqp\n", + "qKwkJkkfWSslEonw9ttHKStbj1o9Na9dXFyNxyOwd+9B7rzz1stwNS4viqLwzhtv0LZnDw6Viqws\n", + "MykILLvxRpBlAl4vVW43N3/nO/x/f/mPeOMRskoEhyMHtSqMXmukf8xPIjhB5YIFZGQZKRymPBik\n", + "a3iY3ZEIxysquP+RR847utR48iTGYJAs8Jtdu4jH4+Tn5yOFwwRuuOG8ETfzfDzuvOceDhQWTo1K\n", + "JRJULFzIAzfeyMtPPUUwGsU2HU3W39dHf3sPelMhNaV16LUGCtMp2n0G3mptoSFfT3FeHoscDt57\n", + "4QXCySQ3lJVhnk5Gl5eTw0qNhuN79rB6zRoEQeDkoUNUWCwzQuRkZyddbW1kQyEOShKH7HbW3nYb\n", + "68/jOxQMBtm3ezcdJ0+i1mhoWLuWdRs3zueZmcNks3DffXDrrecXIgBf/jJUV8NPfgLXQlPOi5Er\n", + "kMnJSeR4nCqHA8NZzm1l0SifufdemvbsoQQodrkY9/l49bHHqF64kEVr1nDg+HEqslkMqRQOp5PR\n", + "sTFqtVr8oRA9HR1MKgqqoiLGxsbQaDQXDOkdGxtDUawzQuQD8vNLaG09wZ13XqorMHv09vbSvns3\n", + "68rLUU1na02m0xx55x3+nz/7sxkB4fV6cRZVISoC0cFujDoN40oB/lgAJRShWJwKKz02MkKD201R\n", + "bi6o1WRkGXssxp633+Zz9913zvE93d2Mj48TGRpigcWCMScHfzDI0e5umhob58XI74BGo2HTli1s\n", + "2rLlDCfidVu38t7TT7Nco8Gg09HX1cVoMo2tpAq9dkpg6LU65EgcnaLlrs2byZ0W8mOBAE/v28et\n", + "Z6X8txiNREdHOXr0KFarFb/XS+X0E2d8cpLu1laW22xMACV5eTgLCzm8YwflFRVnlGiIxWI8/bOf\n", + "YY9Guc7pRJJlunbtwjMwwANf+cp8Jeg5yl//NQgC/K//deFtCgpg2TJ46y24447LZ9tsMS9GLoAk\n", + "SfT19REKhbDZbJSXl8+ZiBKj0YjRbmc8FsN9WsREKpMhplbj9XhwyjJulwuASCDAstxcBkdGCITD\n", + "TIyOYtJqyRFFNIC7tJSW0VEiqRTe3j4K9YWUilU8+eQBRPEN7rjjelavXnmOHVPTAefmQEink5jN\n", + "V1ZK8o9L64kTlFksM0IEpnKBOIDmpiZy7XYymQxWq5VIJEBH7wj+wRAWQw6yIuJDJJtJMkkKZyaD\n", + "w+GgdjoXiAAosky508nepibke+4552GiMZno6upim8uFenpdgdmMKxiku6UF7rrrcl2Kq5rT/UYa\n", + "li4lmUxy8M03EdNpmiIREjYHCwprz9gnGgxSUKhBo/5tt2q3WECS8Pn9OE/L+dLc28fbBzoYiO0l\n", + "Ho/j93WyqkDHrWtWMzg6ilOtnsr3w1QEmFajoUCtpqOt7Qwx0tTYiCkcZsF07hoNsMTt5nBvL319\n", + "fVed8/nVwEsvwVNPwdGj8FGPlM9/fmr7eTFyjRIKhXjssWfxeiWmsnDEKC7W8fDD982JxF9Wq5X1\n", + "N9/M7scfRyUIOM1mouk0+4eGaLjzTsLj49ScNsQvSxJqUcQmSUxGozjMZgYFgYyioJJlqvLycNvt\n", + "7Dx1CkPhItasfwCDYeo80+kkL720l+LiIlzT4uYDSkpKyM0VCATGsNunnOxkWWZ8vIt7772KvK5O\n", + "I5tOoz3P2+aYP8Dux17BWbgIQVAjy35OnDiGKK7GmFsKqRQWfQnDviPUVJRi1Wu4e/Nm2vbvB6br\n", + "0aTTLC0pmZpHF8WZB2I6nSaTyWA0Gil2u5EzmakIjWk7IvE45pwcMqfl0Jjn4rJm7VqWr1hBKBRi\n", + "wdq1vP3EMwTCoxTap0aiUtkMoWyE60sLZqZjAFQqFZb8fE6NjJCfl4coioxPTvLsnnZU1kX09kpA\n", + "LolELY83v4ZWPVW6IZvNMuj3Yy8tnYny0qhUZE/LGwQw3NND/nn6JJsoMjY6Oi9G5hijo/CNb8Cr\n", + "r8LHCXa7+Wb4l3+59HbNBebFyHnYseMtJietuN2/vZE9ng5ef/0d7rvvc5fFhmQySXd3N+FgkHyn\n", + "k8rKypmRmXQ6TX1DA80NDexuaSEyMEA0EqGyqgp1NsvY+DhFFstv56idTlq6ukgw9RbvrqxkoLeX\n", + "o14vy/Lz8UajjMXjjOj11NdumBEiAFqtHq22iMbG1nPEiEql4qGH7ubxx19gYGAYQdChKEE2bKhl\n", + "xYrlF/2aBAIBerq7kSSJispKnNM1PD4ukUiE9rY2oqEQxW43VVVVqNWf7BZYsHgxB5qazsjrEU0k\n", + "eLdliPWf+TqFhcUAjI8PEo0eIy8vg8ZuJDSZYjg0hDEnl9Kltdx2yyY69+7FL8vI4+NERZGc0lJK\n", + "Cwro8nioX72aZDKMaeRFAAAgAElEQVTJu2+8Qefx4wiyjLmggGXXXUfhwoUMjY+jzmaRFQXBZKK6\n", + "oYGJjxH5NM+H84GTtyRJlJSWEolEGB0awmKzUVdfT15eHpu2bqW7vR3v2+/TMTiGjJmIFGH5dS7K\n", + "iqaEg6IotPf3c6yxkXA8TpdGw+D+/Sx0uzne3Y9kLkeWc8l3VEyLziIUJcW7vS0sry3Gn05z08qV\n", + "uKen3RRFYSyZZGXtmaMxVrudUG8vZ+fZTcgy5o/w+Zrn8qIo8Ad/MCVGLhCpfw61tVORNX19cLXP\n", + "wF5zYkSSJJqamjl2rA1Jkli+vI5ly5bORCBEo1Ha24cpLd14xn5FRQtoatrLnXemLnnIpNfr5blf\n", + "/hJ9OIxRFGmSZd53uVi6bh39XV0cef99irVaGiwWPOk0Xr+fpRUV5NlsFEkSXX4/u/v7uXvDBvRa\n", + "LXl5eWRtNvonJlguy4h6PXJBAeacHLIOB72pFJmiIupsefT2jiBJbbjdpTMOrBqNnmg0fl5bnU4n\n", + "f/InX2dgYIBEIkFhYSF5eXkX/ZocOXyYfa+8gl1RUIkih2SZpTfcwJZt2z7W/v39/bz82GPkZrMY\n", + "1Wq6du/mkNvNfQ8/PFPlNp1Oc+rUKUb6+7HY7SxctOgcJ9L6+npa6+o41tFBcU4OWUniYG8vtqIl\n", + "M0JkcjLI0QMHCPvSqLOjuKvKaGiox+ncjE6nIZls4eZbb6V+8WL27d7N+2+8QbHZTEJS+PeX3kJj\n", + "t/H1W/L46X/8B+NHjlFgtFDsykcXibD3pZcoXrgQi9NJgcmEShQxmc0cHxpi7e23X9yLfo3xm1de\n", + "YccTT2FKpLHmmOjwjlGen8/y2lqGMhkO7NzJ7Q89RH93N8lgkOIyJx6vl5I6N/d+8Q+or6/nuSee\n", + "4OjAAF6Ph5PHjmHVaFi/bh21lZW0DA2hdrsxxhRGWkcxGrOYzXGMRhMAFosDs7mSL3/7EdoaG/Ge\n", + "PIkhGERRFIYiEUpXrqT8tEJ/AA0rVrD9wAGcicTMy8dEMEjMaKRmOp/QPHODN9+cio555pmPv48g\n", + "wA03wLvvwte+dulsmwvMWmivIAhrgX8GZOCIoih/etb6ix7aqygK27e/wMmTEzim30j8/kEWLDDw\n", + "8MNfQKPREAwG+dGPHqesbMM5+w8O7uF73/sGJpPpotr1AS0tLRzevZvdr79OicnExpUrser1jHg8\n", + "vLlnD6q8PPJMJoSxMcwmE+OA1NdHkUpFymik3O2mPRbjug0b2NXTQ7HLhUUQyMgyhqIiSqqrObp3\n", + "L/FIhLoVK9DpDXR19KLXqxkZi5JKWWlr82A0LgDCrF/fQH5+Pv39x7n//rU0NDRckvP+gAuF+vl8\n", + "Pp74l39hdVHRTLRBVpI4PDjIHd/85jkd9Nlks1l+8qMfUa/VzkREADQPDFA+LWhisRhP//zn4PXi\n", + "0OuJZzKMShJ169djy8nBWVg4MzqVyWRob2+ns6kJtVYLWi2HD4coL19MIpFg12uvkfSP097fgdVU\n", + "RF15CSq7nY033sjExABr1uRy222/TSoQDAb5px/9Jx0dYbQaAxrS9A93IY10cuPC61CrtSSTISwW\n", + "mbKacqipITAxQdfR42hkGZ0jly2f+xxbP/OZM3wdrhTmQojnO++8y3/8j39ksa0Mo95I+0A7xugI\n", + "5aUuVm7disPhwB8O81p7O/V5eSx1u9Go1cSSSV49coSYIIAM5rx8VBqR9154gWUmEzUlJSQFgbBW\n", + "S0N9Pc8cOEFB9SZ2725Cq10OZCkvL8Jmy8HvP0lFhZFvf/sO6urq6Ojo4FRjIwD1y5ZRW1t7hg+R\n", + "z+ejp7ub3p4e+pqbsavVyICYm8sd999PcXHx7FzMj8lcaPfLhSzDihXwN38Dd9/9yfb96U9h376p\n", + "XCRXOnM1tLcfuEFRlLQgCE8IgrBYUZSWS3rA/n4aG8eoqFg702lbrQ56eo7R0dHB4sWLycnJweHQ\n", + "Ew77sVp/OxQ/OemluNh+yYTIgX37OPrqqxTrdNRLErZ0mt+89hpWtRoxGkUZGeHU0BD2nBweWLoU\n", + "bzTKRFsbC7Ra7AYDg/E4akGgRK2mZ3CQ6uJibnvkEQB0Oh3JZJKXf/lLygUB0WLhpcefJyQ7WbHu\n", + "Bg4ePkEiEWHbttXE4xlGRsbRavM4dOgIixYV43ZrqTstz8LlprOjg3xRnBEiMFUQzmUw0N7U9JFi\n", + "ZGRkBHU0iu2snCkLCgs5efQoW7ZtY/+ePQgjI1S7XBh1OsLhMN27dvH8/v1s27CBFlnmwGkjKQ0N\n", + "DTPirLe3l337nkeWJbq7upjo66NUr6fYKJPMDjDUn0Dtz6Ep30RFhZbrrrv5DDsGBweJRE0YJC+5\n", + "MT8GlYaeviGITpJOJ8mxOjAZLfgDo0T8k/QcPY5ocqNybSIry0hCHK8vjCzLc8bJ+koikUjw1BMv\n", + "4jYXkZc7NfWXTqcoU+cghSOMeTw4HA5Mej0TnZ3cVFFBatp343hrKxNHj5NMKdgLauh4r4Xu2Ci1\n", + "WigzGFCCQRZUVDAejfLm7r3odYVUV6+gt7eX/v5uzOZq+vu7KS7WUViox2bTUFJSgkqloqamBq1W\n", + "Szwex2aznSFEDuzfz6HXXiOPqQ5eD+QuXMjGzZspKiqaj6KZY7zwAuh0n86/fO3aa8NvZNbEiKIo\n", + "3tP+zQDZS33M3t4BtNq8c94eTSYnHR19LF68GEEQuOuuz/Dooy8Ti7kwm+1EIn5gjAcf/PwlsSuZ\n", + "THLorbdYU1rK5OQkg34/A+k0w6OjqHJyGAtmiCYsRCU1neOT+Ly7WFyQS3YyiFdUkwlGGVeBNDJC\n", + "PJ0mHA6zwGqloKAAg8GAoij89J//mXqzGYfVys7DjdgM9dgEA76xSSTJjtVazcmTh9m06bMMD3fT\n", + "39+H39/Dhg0r2bZt66wm0spmMqjO88avPo9D3/mQZfm8IwaCICBLEuFwmO2PPoo1EqGzqQlZq2V8\n", + "ZIQcWUbUaNBqNKwuKqJ1cJCdO3ZQVVuLSqXCZDLx9tv76O+foL+/i/f3HCE4GkMTT9Cvz5KRQ9iN\n", + "dgJxH0PDXRRPCnzzH//tnKmf9vZe/CNDlGYzFNgLCYXD5BvyCcYDePpayctzISBgsdhp7GzFay1l\n", + "w6Zl+H0ewj4PGoOZgwf7Wby49ZKPXl2NjIyMkM1o0KmnvuPJVJxEMgpqHeFQFCk71TUlUimikQhv\n", + "7t2LQaUilsnQ3tlJeUxNWBEZiXgozrWTiI3TH46Qp9OijcfRWSzkOxz4mjsw1lRiNFq59dYH+M1v\n", + "nmR09DiSlKWwsAGn08hNN60gJycHn8/HY489RyAgIAh6FCXE0qVlfP7zt+P3+zm0YwcrCwsZ8fsZ\n", + "83rRa7V0HTjA+o0bzytEJiYmOLR3L33t7ZisVlZs2MDSZcuuyJG0K5F//Vf47nenpl0+KYsWwdAQ\n", + "hEJwVsWKq4pZ9xkRBKEByFcU5dSlPpZer0OWz314ZbNpjMbfhshWVFTwne88yOHDx/F4Rqmvd7Jm\n", + "zY2XxBcCppzm9JKEoigcbGxEjERwATbg1WE/MbmCKrWJpCKRlacKtgUne7GIAg5nOQMRH/3JOAui\n", + "Uey2HCSdjvHRUfx+PyUlJUxMTJAJBnGUlpKVJPpGQ+TnVIEAnWOjpNMK2axCNNrPxMQw5eX1lJfX\n", + "Mzi4lw0b1s968qSKqioa33yTKlk+o6MdiUa5YdGij9zf5XKR0umInjavnpUkujweajZs4NnHHsPi\n", + "97OmoABfLMaBlhbSgQALXC7iwSB7DhzAftNNJKJRXvynf2JRbR2pbJbGoUkWrvg8NTXrGOkZoVjq\n", + "IxlpxS4IBOMq9MbFVNndLHAIdPp8ZKQ8BgYGz8lMq9WKRMYGyCudck4UBAGTxsCk3kwwFiKRjGPU\n", + "m4gkopyaDKASKnjhFz8iT05R5ixC0OsYS0TZsUOcFyOfArVaTY49D58vACPdxMeH0ScTDMfGUIQs\n", + "S6e/Mx1DQwTGx9lQWEipxULv0BAdXh8ThiJErQmjYGIoECARj+CQs8SCQbJqNe+fOsVNK1YQySQp\n", + "cS9Co9Gi0Wi5++6v0tfXRmvr+2zc6OaGG65jwYIFKIrCU0+9RCrlwu2emmpRFIUTJ05QVHSQnq5O\n", + "Oo8fZ4/XS54oUldQgKxSMRwOs+PFF/mDP/qjM87P5/Px9I9/jEtRWOFwkEil2L99Oz6vl22f/exl\n", + "v97XGkePTomJz33K2Ae1GpYvh2PHYOvWi2vbXGJWxYggCHbgP4BzszsB3//+92f+3rJlC1u2bPmd\n", + "jldfX8vOnYdIJuPo9VPptjOZNKnUKA0NZ2Y2LCgo4PbbL8+NajAYSCkKPR4P2kgEs83Goc5OUokE\n", + "yYwBgwrGUikKgbQgIGPCr2iQpThvjfQgiwIVgkggEsWXTLBgxQpuqKvjrZdf5ivf/jaCIJBKpxmf\n", + "nER7VpK0QHCUUDJLOGxDEFS8//4+GhoCOBwFlJXZP1WNmY9DIBDg+PFGRkd9uFz5rFix9ILblpSU\n", + "ULVuHYcPHKDEbEYligyHQuQtXkx1dfVHHkur1XLTvfey88knsWWz9A0O0jcwgGI0slivRwwEWLF4\n", + "Mb7ublpHR1mk1eKRFXrHA+gsJoplmad37qS5pY1QTEM4WoRGb2LEL5HJHCAWm2CwZT+GdJJSETKZ\n", + "CGm5GJMGgskkGiCpUlFYWMeePUdZvnzZGfY1NCwingzQ1t9GLB5EpdIQTqXJN1mZ0JloCvkxxCOM\n", + "hMYw51rwDp6iJBHDrjYSGhihuLKKWqOFrqOHyGQy81VePyHFxcUUFVk5PmhivOMYC612SnLyOBKb\n", + "pMhiormpiZCisH3nTspzc+no6qJTrycdS2AV1fTGJzCLVuxSgmDGT34GEiozGSWXWHSSRGyCp44c\n", + "IXdxA6JGpK+3BUmWCPs8DHcchdQoh9+IE/EOsunmmyksKsLrTc4IEZgSqIWFNfzqseexRUbIer0o\n", + "vgBjkoqAP8TWJfUssVho3b+f2COPnDGdfPD99ylSFCqm85PotVpWGo0c2LePVevWzVd3vsT87Gfw\n", + "rW9NiYpPy+rVcPjwvBi5JAiCoAaeAP5cUZTx821zuhi5GNjtdu69dyvPP/8OkpSDIIhAkDvvXH/R\n", + "nb2SySTj4+M0N7dx8mQnkiSxcuVCNm26DovFgizLDAwMcOzYCWKxKDFRpL+5mbTPhzmZZIvLRefA\n", + "AEpWYEwaJyrZSar0+KUEZnzYyOJAJECWsCxQIGoQFcgIAt6uLjobGxGrqwmFQjQ2trC7aYijqVEM\n", + "eogngyjKCMmMQiAaJS9/EZHIMKIoolZXcvDgQW64oYp77vnWRb0mHzA0NMTPf/4CslyAyWSjq8vD\n", + "vn1NF9xeEARuueMOuurqaDt5krQksXHJEurr6z+2j0RdXR22b3+bf/27v0OfTnPnpk2UuFwca23l\n", + "RFsbS2+7jf7BQUKBAPqkTDytJSBpKMx10doxyBHfEIasngVGC+nxXgYlNaKpgd7WvSQH9mJNBCnR\n", + "G0iqNAgqPeGkjkA0SlajQa3WENFZ6Onx0d5+EptNy8KF9ZSVleF0OrHZbORYRNJdzZSb80jLUVLp\n", + "SXwCTIpOkjEZozFOjk2kPKui19uO1eBCLaeRJImO1ibKFhRRUe3A4/F8pA/NtUAkEqGrq4tMJktZ\n", + "WekZicLORq1W89BDn6P58H50eU66o2Gy2STLljWwYuUyjnd1cWxkhJV5eVzvdjPh8zEyPMyOsTGU\n", + "dBaTIpJVvHTJWXKkBGnRSEY0I8gq9GoHitrCmJKgUFAYO/kKoZTAkN+HJZ3AYdCwsqKMWCBA46s7\n", + "GGtpwb1+PaJ4btJASVLo7+jkS+sX8devH0SUS9GJVpLZCN0He7mpzk6F283AwAALFy6c2W+gs5Nl\n", + "Z9W1UatUWBQFr9c7L0YuIek0PP88HD/+u33OmjXw619fHJvmKrM5MnIfsAr44fS85fcURTl4KQ+o\n", + "KAp6vY6ysjyGhkaoqCji5pu/+KEd1SdFkiR27drDe++d4NixDiKRNA0NK6irW82hQ4N0dj7N1752\n", + "Py+99Do7XnwLZcJHjiKTUCL0B73YgkE25eaSFARclZWMdQ1TkIKkGCehaFALASoVAZUAhYKaqAxN\n", + "yGhUWvLVIqJaIZTN0tPcTDQa5Z//4Qec6kmzdOU9dLe0IaVSxJIifeP7CWe0ROM2YvEJBEEkN1cm\n", + "Ly9CVdVq1qxxX5LCXIqi8PLLb2Ew1JCbO5UdITe3AL9/9EP3EwSBmpqa3ylc0efzoYtEsektjI5M\n", + "oNVoKC8qoqelhYGxMVatX09jcztqkxmDLo0BHWq1EX8ghSqVpUbvoMg6lalIHh+hOfw+VSoj2fAk\n", + "hUi4rAb8iTBpiwWtkkSfseNXBMzmIurq1+L1niQWU/GTnxxm2bJJcnP3cf31i5DTce5YvZoxi4W0\n", + "30+eSoUurPDORIjl192FKFrpaz9Be2sLDk2IXCFBJOlF0ecSTMSZTCZRNElSk0Pws5+x7dZbWbps\n", + "2SVztr7cJJNJTpxopLm5E51Oy+rVU0L0Qv4Ora1tbN/+JpJkQxDUKMpB1q+v4bbbbj4jguP0/UtL\n", + "S1m1op4R/zBmtRqL3oGiVZEcH6e4oICUJGFVFBLpNPn5+XSMT1CoiOjUOcSVNKIsIUlJfEoKUc7F\n", + "oTcgq9SodFryzXrGUsNEugfIUVlQ5ZhxCWnq8ixMRKP4x7yEAhEyEgyndXQMvoyjbjlO5yK02t9O\n", + "kfb3d1CZb+H1Y+2khCU4BAd6lRqD6MQb83LI5+f3rNZzfeIsFmLx+BkO4ABpRZkJa5/n0vD661M+\n", + "Hx9Rb/QjWbkSvve9i2PTXGU2HVifBp6+nMd8++1dvPNOKzk5FVitRXR3ewgGd/D1rz940Tru99/f\n", + "xzvvdKLRVKIoAiUlLnp7O9Bq26ivX8nAQCPbtz/LazsOo4wOU51XgjPHgSRlkTOHCIfDiDk5JKJJ\n", + "ZAmsBpFQOo4CRNBSpKTRqBKYFAlZBhCxAKNSEpdWj06lJq4odI+NoddqGRIs6OVKOk80UrdyJbIk\n", + "YY9WY/Ia8XqDhMM15Oe7sNlyEAQIBE7gcn2yZGKfhHA4zNhYhLKyM6dlPsjgerGPNTQ0hCAIuFwu\n", + "fvX4MwS6JtAXLUCWJQ4f7sbtziEnN5eOvj5qSkqQdSaygg5BZaTevYTx8Qlichyr3oqg1yGIIvFY\n", + "jHy1AWvKg1ptQaU3ISezBENBbBYNCb2eNU4Hr3UGUOeUUVBSS3//MXy+Vhoa7kOSoKWlB4vFwp49\n", + "T1DtSvHQ2tU4c3Px+f2ko1GGmjpZXr+QPFcpXY2dLHVVEPZ4CGbaWeMsYGR8nHgqi06dj1VvIJNU\n", + "E1LraT/QSV4ySeP+/Tzw9a9f8W+9qVSKRx99muFhBbu9hGw2w+OP72LDhgHuuOOWc7aPRqP8+tdv\n", + "4nAsn0neJ8sSe/cepqzMxdDQCAcPNgMC9fUVbNt2PQUFBSiKwoTPRzabRWcxkxUECs1mgmNjtKlU\n", + "rKutpbioiM4jRyiUZXpGxnHrTQzFExhttYhqPZmIl5GkF4PFhKjVUVbkwqDT0T05xkQkyfKichRB\n", + "h8acgyEYIjDuJZOM4fWHcZpzUUjTOzFCTvECQiEf/f0HsdurMRgsBINetNpxHAU2DjaN4C7eSMTn\n", + "BwSQJeyGcsLZNKOZzMzIWCAQQFEUlm/YwN6nnybHZEI9PZI4PDEBublEo1Gam5unsylfminZa5kn\n", + "n4QHH/zdP6eyEiYmrm4n1ll3YL1cBAIBdu9uwu1ej0o1ddoWSy6Dgy0cP36S668/N6/IJyWTybBn\n", + "z0mKi1fS0zOAWm1CpdJgs9XQ3X2c6uoG1GoTTz/6Y4z+KC4BenwjHFckKkrrsOhyGRcGOT7oJUdr\n", + "QlSryRjtCEkPsXSCeHaCAtLkIBJGYRAFPSCh0CODOZ3ClM3gE0UCBgOfq67muD+FwypiUanpaW3j\n", + "+s98BlEUmPA3UVlZxciIjN3umHmbEoQChoZaqa+//ne+Hqfj9Xo5dvAgfZ2ddLZ1YTYvPMOR82Ln\n", + "Gzh86BD7duzApijIikK7z0+/X48zpwCDfkp4GgwWBgZ6KawsBYuFQ14vEYOBvf4Y+WojoeF+4iqR\n", + "SYOZFVYj8XiWQDxOOBojJWVRIyGrAhh0FgJZSKQjONNG/J4Q6nCYXKuGnolGhOQ4OQYVBgrpOdVL\n", + "LC0hijHWrFlJOi1y4NhzBJpbWFheCoJAWhBQNFZktZZoNIZOymLQ5VCY56K3p4XNRbl0BoMEYioK\n", + "jQK+RBzRrKdh0RYy2SSKpGCPRtm/Zw+3XuHVChsbmxgeVigv/614tdnyOXjwIKtXL6ew8EwR29PT\n", + "QyaTc0YWYVFUoVLl8Wf/7/cwZATMFgdmp5tMJkpPzzP84R9+iWQySdDjYTwYJDM+jlGtplVRUFmt\n", + "iGVlJNRqXMXFSJJE89GjhDJpbIBoyUWnU5DkNDarCRM6wlYj2bREWIozHIvTm5WwW/LRa4wkZAW9\n", + "zkBEo0NKycSiUWS9BRIxJJWaXL0Oz0gfzqpFLFvm5Pjh9/GOjFOzsJKvfe0LPPerXxGKREiLg8TT\n", + "cWKygigasdmKmUymuP6226aiw37xC0IjIwiAIS+PvIYG9re1YRUEUrJMWK1GiUbZ9+STqIG3geVb\n", + "t7J569b5CJuLRDIJO3fCj3/8u3+WSjU1wtLSAht+90fVnOSaESMejwewzQiRD7DbS9i9+yBdXYP0\n", + "9XnQakUqK4toaFhMVVUVRqPxYx8jkUiQzQpotXr0eh2S5AdApdIiyxrS6SRdrfspzqTRav5/9t48\n", + "yLKzPPP8ne3u+5b7nllZqk2q0lJSgTYkIQzIBowHA27sxh3ydHvcETi6e6L7jwm7Y9rj9vTg8LTD\n", + "HtvCAgMyq8CAVJJAa2mrfc2qzMp9v3n35Zx79nPmjyxKSAgMDskIrCfiRuS9ee53MuOc833v977P\n", + "+zwBas0KUdvC6LQ4X1zBkhXauESTXWQlGRfQLRPVdvilZAJfFjlfLlNyXZrABBAAmsCwKLIBNHwf\n", + "NxhkuFBgpVZDLNepF+voSggz3o+q3owsC9i2xshIH8GgzszMZXw/jCAIGMYme/fGGX+Ny+hPina7\n", + "zYXz5ylvbJDt7mbvvn00m02+/jd/Q78ssyseZ5o2zz76MLfc/f6ri8nW1uI/6Xyvh/X1dV7+h3/g\n", + "YF8fwStkzqXVMp2qSz0RotSqongSHVWl0m7RTEv8H3/wB3Q6HU5eWiAaSZEIR9F0Fd2X8aMVgmGd\n", + "oAyXl5dQbA8HCV0R6U4EUGWPhuAhui7L7TZtQaBXEAgrCjsiIqFQlkBCoVG3sBsl2qZBOg1nXvo2\n", + "QcmFRh3ZbhCSIBqNcnFtjZcrDUh1M+GFCNkBfD9DMhFkSfZ5rtFAUIIU5QJ6NI0lWBzad4hULEu7\n", + "06DaLHFgYoTHnnmGUk1jYWGDWCzMO9+5n4MHb/q50iK5eHGBVOrVNgSiKAFpVldXfygYcV0XQXj1\n", + "/2dZFidffAlno8qdN24zACv1MmvtOn07b+Do0ZPEYiHMzU0+vGcPxXqdaq3GgO9zsdnEXltjWhBY\n", + "OH+eQr6HGSvEkhtBE1xGYj0M5XsRBOjYBsVQBymbxw3kuFAt4nsaqlFEFPKcW1tk9/guupM5VkQR\n", + "U2vhOg5dpk7b6HDGdchGEniBIMVTz/LN9eP82u23kx++lrPz8/yXf/NvqDebWI1lQCEf6MeRFUzF\n", + "xZSbjAzmaTQa/F//+T9zXSbDofFxRFGk0mwyMzfHr95/P6ZpAvDIQw+xN5+/KgLouC7Hvvtd+gYH\n", + "fyJS+Nv4x/Hcc7B3L7xR1e59++DcubeDkZ97qKrK7OxZLl26TDAYZGxsgoGBHZTLa5w/P8OhQzuo\n", + "13NcurTIo4/OMTp6lh07uvn4x9//Ey/M0WiUUEigWq0QiYQRBA3D0JBlCVl2MU2D9tYlfvmGa/nW\n", + "d18goas09TaDrssQPoZpccKx0fKDVINhHNtkzVDpCYaR9Q6FaIRaOMyipjEMOFdcPdueR9b3iYgi\n", + "wXSaGU0jK0nckMngJxKcnS+jSDLH187x+ON/j6ZpFAoyly4do1DYi21rtNsNfN9Flle4557fudpC\n", + "u7S0xNGjp6nX24yN9XPTTddfNe76Qei6zveeeIIv/+VfEgd2jI5SS6U4+fTTEAgwEYnQfSUT8qFb\n", + "b+Irz5zgxWe+zg2H7sbzVAqFV3ZjrVaLVqtFKpX6JxkTXjhzhpwgXHW1BUhEQsiWiUYP3zz3HCG9\n", + "TjoSQsVlj5ugWq1y6exZ3rt7nLNzmzQ0i0wiQ9RpUkn5PLlWQWwb5D2TuGBSFkRSkTRbgk+6WWEn\n", + "4IWDqLZFJBJBSSbp1TTslE/dKLO+JiLYNrLfS0BoExOiRDoadb/GdekkWTvIzOoqng84Hr2egKYJ\n", + "NI8/xXo4TLk+RrneIdd9kI12ibq1TDyXpLdvL512m0xmm8vSMVtkEyG++L2n+cbzl0gmlsn3DHHD\n", + "wf18+9vnKRarfOhDPz+y8aFQANs2X+c3DuVyma994QvUymV6h4e58dAhBgYGgOdwXefqxmNjfR2z\n", + "tspornB1159PZGjXNjF0jfn5NfoLUbLBIAv1JtMVE92K0a5vEfZURicn+cgdd/B///03eWp6g5AU\n", + "R45ey6bapNPYxNAtUsk4y3qJkQOT3P2hD/Lk499jbnGOgNqkIMO661APp1goLlOy2sxWGqxaEr1S\n", + "EMdzAdgnisxaOmOZbkS9wbAbpFKr0VJVVs+fZ6hYJG1Z7Myneam+iCFLSFKWZFRmqXiCcGyC//qH\n", + "D5GqLqHmk2wsrnPbbTeTSyaptNssLy5y6+23MzU1RdyyXqVGLEsSw4kE544ffzsYeYNw+DD80g9X\n", + "Ev/J2LcPrgjy/kLiX0QwUqvVeOKJo5TLIqnUOLYtcOLENM1m/Ur55BbK5RZnz67Q07OTQmEXzeZJ\n", + "QqFJHnroEf7jf7x/20L85RPMzCyTTMY4dGg/k68xrTIMA8tSeeKJvyce34HjmNTrp4AWO3bk6XSm\n", + "2HPNMLFclm8SXyQAACAASURBVJbTotZuMOLaxGSZju8RliV2IbDRrDJ0zc2cXbxAFogZHWKRMNlC\n", + "gYGtLRqmCb5PQxDYmcngCwKb7TaRWIzkzp1MmCYFyyJ9hZx2zaDN2fkVBLVNq1LjXe/5GH193fzD\n", + "P/wtJ09+nX373kcms50VKRT2cOTIeQ4dOsTU1CW+/vUjxGLDhMN9HDmyyYkTX+D++3/9VeRW0zT5\n", + "sz/+Y05/5Sv0WhbhUIilapXK2BhduRzPTk1x6Nd//erxiWiU33rPO/nW2bPcfHOK8fEDjI2N8alP\n", + "3c83vvEdTp6cRRQj+H6HW27Zzb333vUT7+YXFxc5/PDDhObnWY3HSRUK9PT3kwyJzK9P41fDREM3\n", + "Eoh51IwSfbkKv3pgP0989asYhsEdQ0PsHBxktVSiqXWotSRm1+NE49fjuW1ajk5HKrM/oCK4cFZX\n", + "6ZEVVNdg1/g4bqOB5Dgc39ggCjQsi9FehaXKFqlogoZbJa6kMAybqGQg28v0hQcQfZtIPM50tcFk\n", + "eoCo77Poymg6VLQt5qstdo0dYKR/BFXvRzQncMQNhvaOUVmroXZ0HLeDIlc4OdPghaNTpIMT9ISz\n", + "2OU23/vWd7nvIx/k5Mk5br21jKIozF6+jG1ZDA4P09fX95ZMz99ww17Onj1MJtON63p0Oh08z6ZW\n", + "ucjFpy8ymU4zGY1SPn+eL505w4fvv5877tjHk08eIx4fRJYDLMwdZyBnkiaEYXYIBsMICOA4XJ46\n", + "Sj6/m3Ykj5Iv8N1j6wTFJFVVpdkOYwsOXR5sVCpkEhPkGxqDhQL5XJYzc4usbIrM+2vIuLz3Nz7A\n", + "v/3df8sXv/hl7KUq+3r3gqri2Boho8KmIrPkQWm+iUQ3ffE8KcmkYy8z4TToCoSwDJ358ho7M1mo\n", + "qXznkUcJiwLjjoNgWZiWxU0jIyTCTc53NhH9Mo4jsiObREpcj+C5RBob1NY2MSqb1Irr/NKvvJ9E\n", + "KESttN20aFkWr9f8HQwEaL7t/PyG4fDhbc7IG4Vrr4W//2dlWf7z4hciGLFtm7W1NWBb4Oq1RnYv\n", + "vHAU3+/hnnuu4eWXz2GaAQQhx4kTR0gkPNbWGszNTWGaSer1Rbq70wSDEXzfwzRjnD59mmeeOYVp\n", + "5shkJtjaUnnwwSd473vL3HbbK4Z6X/vat2k0ohQKKWZnXwJkQiGHj33sLg4dOkihUODTf/iHHHv2\n", + "WQqGQcm12PB8BMsGwWfJE9nwYxhNn+LLT7EvHkYOhHC1JglFRm008DyPlCwj+T5hQSDousRCIZRI\n", + "hK2uLu694w6eXVhA3thgrlSiVi6jtlqopkM2VqAVDrCyskGlUiOZnCSbNQkG14hGE0SjaeLxDOXy\n", + "BlNTU3znO0fo7j5AsbjMuXOncF2XSETm8OEn+Y3f+F+AbXXTxx97jLnHHqPbshiNxUCWObaxweXV\n", + "Va7buZPm/DzffOopfunWW68y+iVRJJ/Lcdtt7yTxA26zJ06UGRh4B6Io4boOR46cJRx+gTvvvO0f\n", + "vQ/W19f5h898hslEgnIohFRr8MKpC2w6Di1foG4nCXmzJGKDgE8kpBMMSMTDYYLtNk3LwrAsoqEQ\n", + "Iz09OK7L3z3+Ejg5Ygr0dMfxVRVByKIL84yLBpfbbbryGTKJfiKizHy5RthxCeETk0Rcw6C4topo\n", + "d9gXT9MJmzy/cZGAI9Iblgh5BsVakd6AgIeAhMRRrcNlXUBHJCKFiQojhAIh1rc2adQuIYVjJHv3\n", + "kIh14Xuz2GKbsxsbDKdD5GMyz7x0DsV16aWBXFPRBYGQ0sXR51/i5lt38eLzz7N46hQZ30cWRU46\n", + "DiM33cR7f/mX33Iy4mNjY9x11x4+9+CXKK60UHwHmyqFhMeBu+4iecXMMRYOE6pWeeaxx/jYJz/J\n", + "yMggp05dQNfb3Hr7ILOPnENdmqG9uowST6IpIUpby8QTUWIbcU5cOs+xi0uk8xPMrzbR2nkkv4uO\n", + "r/L4S3MkQjF8vxfPqDC3Os2xWQfXEwgGRW7ZvYuxvZP8/n/9AzY2Njhx5Ay7usaYPXcRyQUIs6la\n", + "LLUvUve7EBkASSVRyNMVybNV92n6bQq+het75HqGcQSBjZZGtVFjNBYiHA4j+D6GaVLXNJKiSFBw\n", + "GMsmqPlxpnWXntQIK5cPE+zUGYukwTcRqnVe+t73CA0Pc+311wPbc+QR38d7rYhgvc6OW275GVzl\n", + "XzwsLkK9vi1W9kZh7144f37b5+Yt9pi+Ifi5D0bm5ub48pcPo+vbi1wwaPLhD9/DNddcc/WY6ell\n", + "MpndhEIR3v3ud1Iul1lcXKbRiDA9fY5otBtJChCNZlGUIBsbFbLZ6pW2OpmjR0+h61kgzIULsyiK\n", + "TE/PCN/97nEOHLiOWCxGuVzm5MkZ5uc1JGmcPXtuxDCarK6+zOGvPEysUeXc5cvItRqS7SC7ElkE\n", + "cqLAmu9R80OU3X7ChPBRMRsGp9UmCirdnkuq0yHhOGi+z5brIgsCKc/nfMsg2rao+xZdO3dS7XQ4\n", + "eOed1GZmUKemSEYiTPT1MbNe5sxKh7WlJsGUhKYJzM6uEIl0MTAwyPz8HLOzKr4fwLabSFKNcHiA\n", + "1dWXmZ+vEY0OEI0mKZc3+Pznv8lAf4ELL79Mp93m8COP0LW2htnpsC5JLPs+mVCILlEkJwhc19VF\n", + "Z2WFY+fPc9uVCXGhWKR3cvJVgQhAf/+uK5wAkCSZvr7dPP/8SW677R0/NjuytrbGn/7J/0t9dpGx\n", + "3jzzqsb6zAK+rpL1PTw/QLcQpOKvMDIxTCwUJRUfodZeodxs4vs+8Z4evvn44wzGYuR7ekjk81Sa\n", + "NqF0DqNcxnI86ppOJqigCTLBVJiA7yNlM2yUK0iVJrZlgi9giBJ6x6TsuAgEKSLy8OVNImHokiSC\n", + "rkraELAEkZlmkUo4jKBbnLMUfHcclzyykMDwymj2FPnAIGElQbnhkDUKXC5dpONVUdfyfOCde1mQ\n", + "41TrdVbKNnJHY2cgTkQOE1Ii2J7DrLFOcV1A07o4/fQp7hofJ3JFWdfzPI69/DIzk5Ovem7eChAE\n", + "gUQ8wt6cxz2DBYKBAEFlgscef5yly5evLrAA3ZkM04uLOI7D+Pg44+PjWJbFX/yP/4HpOOwcGcSo\n", + "NpgvrbNSK9Ff6OLWWw7QKhZJ1+s011ZY8CWi8l4CYQnd6BALF9Asi0eefQ5LmWCt3AKhh1BwiHQ8\n", + "Q0Pd4PkL0xRGtnWKFhaWcd0A5xcuoasu2XCKqlFjrqUTpIc4A0ik6bg6FzZLDO2epLdnhHppE93V\n", + "sJQYJVtmpgWqKmGQpGyqiIk462oHV/R4bHGR3mAQU1LY0ktsUkbNTuC6JlnPxYmkqdoGScFD1A3m\n", + "L11iq1TCTSZpViq870MfYuKWWzj+wguMZjIossxatYqZzZJMpTh+/DiJRILR0dG3BfT+iTh8GN7z\n", + "njc2aEint19LS9vdNb9o+LkORprNJl/4wiMkk3vJ57d5DLqu8tBDj/Pv/32OfH67jp5IRGi1tlVX\n", + "A4EAzWabUslGlpNks9fS6Tjouocsr5JOT+B5TTzPuMLIr7O1pbG8bNNoCIRCSVzXZnHxEvm8SrFY\n", + "ZHx8HE3TWFraRFGuJRbbbo3tdDSCegSzZbGnq4u5M2cYCQQ4rRr44Th2s0rbsegAm8TpJYJKiWEg\n", + "LYWp2j5twWVLlqmZJoKuowEaECbIppwlKiu0HAddlOgrNcm02wxubrJYr9Pe3OTW4WFkUWSlPs0a\n", + "cfozw3SaZTIje+jpGWVm5llOnChSLPooyiAgoOtFZmfbWNZzrK15KMpuqtUykrRJNpthbVXjs//P\n", + "p/nobbcip1J8Y24O03VJhkLgeZiGQcJx0KNRWp0OQ5OTCKLIS1NTRFMpXFkm2NvLh19HH/m1BONA\n", + "IIRleRiG8SPbr2dnZ/nc5x7h8ozLaGwfq6UOF9ccNNPgYCCE4HugJBgMDTFXX2VxbYW7brwLAN93\n", + "MC2L6WKRfk3Dcl1OXriAcvYsWjxOLTLINfuv49GHH8XxJKKhLGvtEqZd5mjHoJXLca5SIdVoEvJB\n", + "8EXmbYMt1waCBMigksIjju3E0NorJEId4orCSadDnyTxznicimUxbRm0vAHiwX4kgkjE8fw4BjXq\n", + "+hqauRfXS1HV6jhOEheJy4ubfNlscsdggQFRpJxK0ZJFugMK6+1NAulhFFEm4/tsGUU0bZXJRPBq\n", + "IAIgiiLDqRQXTpx4ywUjvu9z7OmnOTg6elXKv6VpJGMxyqur6Lt2XdXKMG0bORB4VdA6NzdHVNP4\n", + "4L33cvTMGVSg2mkzIKbZf/B6NhfmCbZaKIZBj+BR82RqHZ1gIIznezRbFRTJp215NOwF8AaIBMbw\n", + "bCiWi0SDOqrXxZnZVUzT5MEHv8jTL50noPtEBEipJVpWkRh9RBBoYBMRAsQIsuGbHJmbY9dAASkc\n", + "5HS1ypoUx1bTIPSi+iayJLFpn+Vkc51xQSFuO8iCzZrjsyFJNJI5Gr6AqTWp15boEkUSuUlWy7Os\n", + "GusEjDYTI8McGB3lrvFxpqenefSb3+SDH/kIU8PDnD92DEPXGbz9di5OL/HQQ88BcaBDLvcsv/Vb\n", + "v/Z2y+8/AYcPw8c//saP+33eyNvByFsMU1OXcN0M0egrhMpwOIYgdHHu3BR33XUHAO94xwE+//ln\n", + "iMVSuK7H3NwaoVAC3/eIRvdgWW02NuZoNC7jecskEklisSzLy8d417v28thjz1IqCfT0vOJc63kp\n", + "FhYeQdd1YFvdtVarMjj4in9No7RCQlQgkqPW2nZVzSeTmLWzYHoMhZOU1BoV30EgShWVPB5BIUzb\n", + "tokiEfRFDM9CBkaBJLAMnKYb2StgSSGGx4ZJRGMsr55iZyzGjmgUzfdZ9zymTJP5zTLThoxGhJVy\n", + "hYBp0zu0i2DQQ1GKXL4cpKvrVxCEAJal0t9/CMNY4eLFKWKxe0ilBvE8l1LxDMXZ48QDJmWpzdPi\n", + "83imSciVKTs+TsejInmYvo/l+6zrOplUin3XX080GqWRTrPrvvvo6+tjaGjodUsCpqkTDL4ixKRp\n", + "TZLJ0I/savJ9n+9852nS6T309ik4tTrpWA7LKSD5y4wn0zQsg1Q8w1a7RW8kxVR7i+VqBcE1sN0i\n", + "C0aCiCwTqtUYA4ShIRq6zkqziZuWOXPmBMn8CJsbS0StDrZdIynYdDJZhrNZOisrNC2bLSlEHQi7\n", + "AFEqxHFJkWQQiQCikAFfZtG4gODpxBSRsOOw0Wggx+Mk8/1kKlmaXgffFwEbXwCEHJa3QUhIYng1\n", + "Il6IOEFCgQIhUaa4usJmuMw1o6NUOh2isSCe7ZJWfDrmGr4foNbcQOjK0OlIHJs6TcR2uWbnDoQr\n", + "10ASxauGcG8lOI6DoarEfqANPBGNkioUqC4vY1nWVTPI6Y0N9t1556vuq2a9TkwUySYSvPe221B1\n", + "nedPniRcLrO1vo69tkZfJEIyEKAQFDldrhCW+0lGYjgimJ0Wut3AdXV2yD6LnollLSIIYUTRxvc9\n", + "HDfCsZePcfPNd1NZF1G8ARwphmmXqNsOKj4DBIgh0qKO5WeRCKMQZsts0147z2iPRyccZb0eIRga\n", + "wBcCiEqMeDhFvV1D9tfIRiKoHZem55EKdRPKZOnefRuKH+apMy9SrpxAMn2CLuQiYTRERvJD+IEA\n", + "8StiaDv7+3lhaopWq8XevXvZu3cvAN/61qNUKlGGhl6Z47a2lnj44Uf57d9+E1bVX2AYBjz7LHzu\n", + "c2/82Hv3brf3fvCDb/zYP2v8XAcj7baGLP+wgmAwGKHZVK++3717N/fcU+aZZ15CVQUajVl6enq4\n", + "/vq7eOmlS/T07CKfH2Nz80n27NnHzMxFEoktRkcnGBsbJhh8Ac9r4fveFQl50PUaoZCMc2UCTyQS\n", + "TEz0sbo6SzY7gqIE6ahNohhksjEioRB9fX1cnpsDy0QSgliuTVKJEHRt2q6JA0SQMH0dBw8LgQgu\n", + "vUAGaAC6IFDxZWJCCFcUCcoK+UwWtVqlEO2irZlEQiGuGxtjcWoKzRJIF25hwtHpWB4L5UW2aiUu\n", + "XVK59tq9yPI1XL5soygu0CSsVEBrUGnUEEUZSeqgqhVqpUtE2uvkRQHb0lHrFfxyiBdnFukKD9Ay\n", + "Oyw5DbrFOCWKCHhEs1nuue8+AoEADVUlOzDAoUOHfiwvYW3tNF1du4jFUrRaNSqVi3z843f9SHJl\n", + "u92mWtUZHEwzND7B2SPPEQooJCJxipUgdVNHDEcoJLOYTom1eoNoppfIQBTbbPKrH/gtevv6ePKB\n", + "B7DLZYaumCEOAiO5HH919jS6FSai9CLHJFa2ZohJHUYLOyg1l8lKNQ4WClRaLeRoN8fmzlMlQpYY\n", + "VaKI7KCKi4tD0F8mjQ2kyfgNIpZNt6KgAm4gQE8sxFrDR04E8UM5Wi0bfBe3VUWhheMcRfYEguIw\n", + "rh8ERDxE4kKWlXIZa8glGYsxPD6KurJOp94mFoaGWUPJJ/jgR/93CoV+jm8WefHF85SLm1yzexe5\n", + "fJ7Vep3r77rrp30E33QoikKmu5tqq0X2B0p6N+zdy9+VSlyoVEg0m7R8n949e3jn7be/6vvZfJ7v\n", + "VSqsrK1td5Hl8xQKBc7Pz+NoGn2KQiwUwvN9IskEuXaDprFCx/ARbI18zKfeatLrOwwmCpiqj+c4\n", + "NEQVSe6i4ZQICDW6RZv67DpRZTem2EETBDzBxxOT6J6AhkeeIH0EWWeBDjEsDDIU6Q7IUNEQxBAh\n", + "KY4ixRFDSeq1Ks32FkG/Q1wIIoYztEyBcDhJd7wHVZHQtRZd/X2Mjk6S6LVoF5eQnS3kgIiw6hLT\n", + "dZZrNTYMg7VKhYn+ftqCwMrKCrZtk8vlcF2Xkydn6Ol5rT/XEIuLz1Ov19/OjvwUOHIE9uyB1/hh\n", + "viHYswe+9a03fty3An6W3jQ9wCPANUDU933vtcc4jsPW1haSJNHV1fVDC9LQUB/PPjsHjLzq806n\n", + "zOjoDT94Lu6++05uvPEACwsLuG6Fa655H7KsMDbWYHZ2mUAgSjqdo902cByN0dG7WFkJ8kd/9ACt\n", + "1jrZbA+12gkEIQWYRCIWe/bseVVN9ZOf/DX++q+fQFXXaLcdEpkgIafD2ECCRCSCCzyzsICoaeCo\n", + "zDouTURyuDhUgRA2Pll8bHyKGGi4WMA62wtk2PfpxUHyK7QcH0WDc1NTDKVShOJh4tHt9Hs+lSLV\n", + "3c3Tp1a48+CtCHaNs1NLOF6ORLJAu73O5qZKNOoQVARk2cBvnadfhHggyppWB6NBS5qhqjWJqGVy\n", + "ooJvWQhscm1Y58LURcJiBEOErniK9U6ARqgbVVAoS2X27t2L6/usVyosqCrv+cQn/lGC5Ec/ehtP\n", + "PXWU5eUmXV1pfvM33/0jSweqqnL61CnmZi5im930DfRzzcGDXDx9GickU3E0pgyBnak8teoGolaH\n", + "kMvNd1/H//q7H2BsbAxBELhw4QIbxSIHXuNOvNJokDVNBnuGKPRNMHN5mkHdxZXi5GJJHE0gpOts\n", + "tNv4nsdW6QJ5y6KFh4NHBxsPDxGBEC2SeCgImEg0bJMoHhuOg+X7qKZJJmJgm03KJYV0bw+yX4FW\n", + "kbQ3xw5BRcNCJYbrORTpQ7Ez4KmkgiEM22euWmXnjTcix+MkgkHCzSZDO3Zw/NISIxO3MDg4Sa1W\n", + "pK42UMubONVlasVN2tEo+++7jz1XdslvNbzjnns4/OCD7AKyiQSqrjNbqfDb/+E/MDI+jqqqZDKZ\n", + "17V1qJbLzE1P02sYDORyWMvLXNA0WskkWr2Oo6qsaxoVzyNbKHBvt8OT67P4io8iilhOhQmliuxB\n", + "MhzFa63Q9DwEL0rNdXB8HcsvE45KNDyPiBiiaTrYfpGUt05KEPAwKVMjSoEECilC1GgRZ4UubLr0\n", + "BDHPp6NY6M4yTb0H1exD8QxCSOC5IJhonSrhaATFc3Ask81WE9ePUim2aYRtdqa7ueX9n+DYsWMY\n", + "Z8+Si0YpaRqS7+OsrLCytEQzHmfN85hbWmL/vn0EMxnufP/7cV3/Klfr+xAEAUF4ZcP1Nn4yvNEt\n", + "vT+IvXvhv/23N2fsnzV+lpmRGvAu4Bs/6oA/+ZP/j05HAlxyuSAf+cj7XzXhjI+PMzx8jOXl83R1\n", + "jSIIIltbi/T0iK+7gCWTSfbv388992zy8ssXGRjYze7du4hE5jl16ikGBoK026u8733/Cl1XOXHi\n", + "OI6TZGNDRhQXOXBgP319wwSDYaLRBPX6WUZGXgmEDh26mVqtwbFjs0AGTRNZv7zI7uHdzKysUFtY\n", + "YCIW52zZIBIK4ugGZVekjEmSOhksEohEkVBw6cLhJFBCph8FG1Ax2CtAyDeZo0lCSNDsdFiVRQ6O\n", + "phjufkXKfcfoKC+ueiy22zQ1lQougUw/gUAWXV+gWrqAKG6RU3IszD9DXqvRCCSpuBpGZ40UKqrm\n", + "YDvLiITRHBlZbDCqNIk4Mnlg1bPQFZ+2pTPRdw2JcJaFSoBQIcnE+9/PhU6H3NAQH3znOxkaGvpH\n", + "b4rrrruW6667Ftd1fyxhdWtri69+5jMkdJ3hgMmll7/L8uwQe2+8EUVRSIc93n3DJOrlixyfP0M8\n", + "GCSSiBPsH4Bqlc//5V/SMUy2mh7dvaMcXWqiyzrv3jmOLIq4nsfFYpGJfB4hJFAtFgmbPuFwEsvU\n", + "KLa2COAQtnxmGi3CrksCARAx8HAQ6UNmiRVidGPhEyaKgoBLHYiwisqA7yMBIwh4epukr1H1LlLZ\n", + "KJMJSQTlGhOiRm8gRqvZ5jI+YVKEWcf02gQkhYZj0lZVAmWF0sUGoZCJHIsR7O/H6e8nJOTZf+O2\n", + "EuvMiSe4dWASo3uYhZWTpEZHkQWBkZ07CbzGu+SfE77vUy6XAcjn86/aeExOTiJ88pM8/8QTnFtZ\n", + "IZJIcOMHP8gNN92EIAh4nve6Cr6apvGFP/9zRkQRyzS5cOkSYiRCdmCAkYMHea7VYrZWo0uSKIRC\n", + "bK2uU9R1cuEAw4MuttmhVWowkYix0GhxrjrDgNMhTZMSYVp+AAEXwYmzZvRT8VZo6yZRKULKqzLq\n", + "K0QR6Edgg00W0AmSwMYhSZNePFJIdDsCniSTkgO4gs954wKGHCEZTGJaTRA1Or6DYrcRwi4dCy43\n", + "DJYlGaml4XlrDAdMetoBohsb1OfmOLhrF8FAgKOPPophmtwcjVIyDMr1OoVAgHilQsp16fV9Hnvo\n", + "IfL5PqrVDXK5VwxDVbVBIiG9KR5Vv8g4fBg+//k3Z+zJye1OHdOE1zSN/txDeKNluH/qP0AQngbu\n", + "em1mRBAE/9OffopodDs1W69v4boLfOpTv/0qcyfDMHjppaMcPz6F53lcf/0uDh06+GO9Zmzb5okn\n", + "nuLlly8CARTF4a67bqJY3OSzn30W0/RZXl6gp+cd9PVN0G7X0bQlyuU5CoUs6XSOnh6J++//MHv2\n", + "7P6h8efn53niiadZWSkRDodQUDnz3HMMuy5zi0WaJZ+0JG/rWPgGDnF05jiIhwaIQBQwgMuEqJBg\n", + "DIUwIjoqORoEgWUhxJbSRTqRZ0tocP/73slt111LOBzGcV2en5tjwQgzOfkejhw5Squ1PWmbpo7v\n", + "X6YXk14ZphsrnD63wKAbREYggEmEBgEcFpFQ5R7yrknS7zAQkEiFFGwB1l2TGV8kNXIdttKD1QYB\n", + "kBMG/+d//9+4++67f9p74SeWhf/iAw8Q29qiP5/HsCweO3aO6ZU2Gx2BXMBmZ3+UXV1JXnz6adRi\n", + "kUXXZe+ePYyOjdFeXaXYVtGjk4RC/aiiQnagj2e/80WuzXfY152j4XkUdR2xXKYvm2VheYtW3SEg\n", + "S6hWFSUcwDc1Bn2RVU3H8R10oImHgYhJEB2ZFiDQS4AM3Yg4NBHZII1GCIt1fDJAAWgDJtsZsGkE\n", + "EoEw6XCcmCmgyBKWYbPpqNQIY6KgBUcRPI+Gs0osPkx39yCC66JEFMb3JvmLv/gjAoEAf/zHf0Wh\n", + "cJBGo8TykW8wGk9jWSbxuM5tt91Cu9NhxvP4nd///Z/qer1REASBv/r0pzGrVQQgkM3ySx/+8BUB\n", + "s1fDcRwkSUIQBFRV5Xvfe5bTp2fwPJ+9e8e4557br5YUvvaVr/C9P/sz7hkevhq0zCwtsdHpMG3b\n", + "xF2XUVEkGY2yvLKO68tctC1S+T5unjiAIjcptitcOnMGwbZRVJUxBCQEjuIjEEZCwaOXtgBLvoCF\n", + "QkLw2CGYpDwXjxoZNJAUTrgaJiAjE0JAQGAXEhEEPFx8WQIlzAVdZYY8spjD82oEadNNh4zgYMsi\n", + "mhChToFg7np8R0DR1xjN1Ll9zxB3v//9fOvJJxHrdbr6+1mbmaGyvEzBdVlptwnKMqlQCC0cploo\n", + "8Huf+ARrlQryrl1MTRdx3QKJRA5Na+A4G3ziE+9900TQfprn/ecFS0tw8CBsbr557be7d8NDD23r\n", + "jvy84co1f92a+1uaM/L9QAQgne5iebnI7Ows+/btu/p5KBTizjtv5847b3+9IV4XiqLwvvfdy7ve\n", + "dRuappFIJGg0GjzwwNfQtDzhcARJClCpuDjOLKlUBsfxiEYHcZwy6XQUSfKp1xv4vs/6+jrtdptk\n", + "Msn581P86Z/+HbquMDw8zvBwPx2zio3I+vIqVsNFcUUW9ToBQEbAIEgHGRuLPOABKlAnSIgEEhJR\n", + "fGIIBImi0kHDRZCDhKMyjrdFJupzeWWZucsz9A8NkRod5cb77mOipfGZBz7D7Nnz9IW7cR2L+foy\n", + "oihSsjq80CkTdAyi+EhIdCOSxSYBuEAJlw2nRF4KIHgWirhdX3ckhVokQG8yT9eeWzh0x4fpdDps\n", + "bS0wPAzvete73pib4HWgqirlpSUmryxWoUCAX3nH9dy8q86ff/3r7MkNYpXqPHlyik6zxTWpLD2K\n", + "SAQ4/eKL3D05yYvzJfpGc3Snc1RbTXBcbrzzA5x86UtEukUmhgZYW1/Hr1QIOQ59ERFaNbyOQdH3\n", + "6I4kkYGnVI0cIh0gjUcXChI5bCRqGLQwcVlEpk0HnSgOI3jkAQUZBRuD7QB0kO0HMoaEhguWieAB\n", + "UhjXHIqDRgAAIABJREFUaKF4MgoCQcGh4Wu45iUUySEnhkl5ZWRd4fprb0UQRObXVvn61x8mIoDd\n", + "WOaly/O0OxL1i+doKHEEocOtt+67qjXh2fabdr2+j06nw3PPvcjx41P4/vbG4bbbtnkKg7ZN/oq1\n", + "aaXZ5OG//Vv+9ac+9UOt37K8PWXZts3f/u2XqFQi9PS8A0EQuHRpieXlL/G7v/ubhMNhpk+eJBmN\n", + "Xs2yaJpGbbPIesumJIcIpbqZ6ZRJt7fwUfA8l6QkYmZ6OKU1qJVX6XQqNJwovtFkHyJtPDbxcZEY\n", + "J4yBzCYiSZL0oLGIgeVvofodTFzCbFs32K7FfkBHRieAT4ctAERkwMOj4gikfYkAIiG2kD2bCHHi\n", + "9LMd1qyDYFF2exgZvRbZ92nVavSEorQ7Ooubm9i2zejICGc3Ngg3m0SjUZxMBq/RIBQOMxQM4gPR\n", + "UIhmp8O5y5cZ7u9Hdxx+7/f+FSdPnmF5eZPJyQw33viRH5Lbfxs/HocPw733vrk6IHv2bJNYfx6D\n", + "kR+Ht3Qw8u1v/9XVn3fsuJ5oNEmr1b76mWmaTE9Ps7CwRjIZY9++3eRyudcb6nURDoevZlleeOEY\n", + "udxeisUSnuciigrRaBeNxjKGUSESydLb200kkuaGG+7GcWy+/e1nOXHiPJWKiyhGmZ4+xcrKBsnk\n", + "zfT1DVGpbDA//xhDQ4O8fHKGdydiWKJFy66TwcfDZRkfSCMTYAMLHTAJYxDCQmIdhyQJ6rRx8Whj\n", + "YwKKEMCLFxiMTrLWbhOJw6/dcw+WbXNsfp7YwABPPv08jz12grXFFo7ms2GexHdrBHBI4RO6sisP\n", + "ILAMWLiM4qKwvTjWAQXI4pCIpGh0LOpygHXfoybBfe97HwSDmF0ZVlePIIpw003j3Hvvu34kN8R1\n", + "Xaampjh16tK2o+j+nezZs+fqIvOT4PXIrIIg0JVOo5suWlNG9mNkwh6CGWS1VcePGAyKItW6xsNT\n", + "WyzWJdRVlUZnmfG+Lk6fu0Aw2Y8fGGGq5LOolunOh5BzOWZWVhgOh6kgsGLbKIJA3bKwPJ8SISqE\n", + "8ZHo0KELBQcVD5MgkEOmSYAUHTJY6Fi0kRDwUfAZAFaAEBADLAB8OkANl6zjojsNBgIyuutTRkD2\n", + "RTooZFAZdAUiYoooAqXaZV54YYmh/p2U2zWe/twCH33ve3jXQB+fe/GrnJ6tEiREOmQSicY4dmyG\n", + "2UsXERJxdn3gA1iW9aaVamzb5rOf/TIbGzLd3TcgCCIvv7zA7OyXgG2O0/eRSybJtFpMXbjALYcO\n", + "ve54ly9fZmvLZ2joFRXknp4xVlY6nD9/gQMH9hOUZdxcjk1VpScWY35pibImo4kR4ukxUqEcltLN\n", + "zOrz3JBI0pPrRlSbTC9ewHFMzI5O0w5gB7qwPIdLuJhEcUkQwuUiOnl8fIJ4fpAwHRRsXHR8LApX\n", + "rqvOdsawCQi4SHTw2PaVmsejlwAGIg4+bVdjAw+BNApZfOJUMRExsP0YEbdKDJXV5YvcNnEt1USc\n", + "lOMgWlHKpQWajQY7h4Z46cIFyqKI2OmwoGnETZPRbBZUFZPtzc6u3l6WlpdJpFIMDwyQyWS45543\n", + "bxPxLwGHD8NHP/rmnuP74me/aHirBCOvm7a5777fedX75eXjdHdvE1M1TePBB7/MxoZLNFrANNd5\n", + "+unTfPzj72Hnzp2vN9yPxdLSBv39k3hekDNnpjGMdQQhh64bhMM2uVwfpdIFEgmd5557jEIhx6VL\n", + "87Rau9i16yZKpS2q1RzNpkUgUKdUCjIzfY52e4OpqRl0NcERu8iQbzPiS/jIaHgMEGSVTXbioyEx\n", + "S4gcSTx8NpFo041ECx0JiyZ9iIBP03fZsgzaXotYOs9E/wDTK5tMDnSzsNzg60cepFR1cK0xFDuD\n", + "7izQRZlBXOJsT0YuEAQUfHrY7taZArJXfqexTQ3eEHy6AmHWfCiGgwgC3HX7IZLZLJk9e/jQRz+K\n", + "ZVlIkvRjFzPP8/jqV7/JmTNl0ult/siXv3yM8+cv87GP/eo/eo08z2N5eXnbayQQYGF9nbH+flzX\n", + "xTAMFre28OM9mIEwflMnKMsk4gm2yiqbukbKdChZBcb9QWLhCp4dYGGpzcb6OoYSIWrbiIbK/rHr\n", + "8XyPIy99k515gRsnJvjKqQsImkM/IQzXpdVUiUhhdot5HM+hik2DND5lJrDIINBCYQ2LawgioaAQ\n", + "JkcLHyjiM45OHoEKPpuABDjAIh5Btks3OiYNoGZ51FFwKKATw8QlSg2fJppXR9BaDEoBJM8lpbfR\n", + "agsI2SGy8TgL8/PIjQ539AxSDKfYWl8gsrmGYqmsizZeKoruOPiWxb/+d//uTQlIZmdnWVuzGR5+\n", + "Jas5MLCT5eUzr3t8PBikUan8yPGmp+corm/QLleJprvo7Z8gGAwTiWRZXS1y8KBC18AAQUliamaG\n", + "Uq3G6WIVlRTtcI7J/p3UNzZIiRE8L4GgKNgInFyfZ4fn4lkGNT9LkgiOvo6AS4AAOgHq6PhINBCp\n", + "oRFFJUwUnw4KJcax2Qmk2Q5A1oAutgP8DBISLuBjIzBNHJ0gUSQ8dOp4BPEQUXBJEKCbCAJVpulC\n", + "Je+6WBjo7iZnF3V2DN7AZkWlo5cY8Q2+8tnP4oWitLp7uPnD7+Pi0aMIsszW4iLdokjdtlFlmXwq\n", + "xXAmwzOlEvVQiF++7ro37mL/C4Vpbrf0Pvjgm3uePXvggQfe3HP8LPCz7KaRgceAa4HHBUH4L77v\n", + "H/vBYzY35ykUhvA8l83NWYaGIlcJoy++eJRiUXmVtbiu9/G1rz3Bf/pPoz/1hJrLpVhdbTE5uYNC\n", + "ocDRow7Ly3NEIhGy2SSzs8/iuk1Cof1cuLBMs3mcen2VVstnaamFqtqsrNRx3QCN2jkUf556u4Hr\n", + "FPC9CIJfoOI0KEgqVQQcZGwUfDp0YeDhUUJhk24abJdvWkSwSNPCI0udnJBClwzCgkBIUBiIZtiQ\n", + "PW7efwCwWS/P8/ixM1xYNCg1BHyvC4FNXC4yQp0DeCSBBNuBxgwQYXvCDAMttgMR8crnw8AsoPs+\n", + "y55Kf083ZNNcd+P1TO6/ll0HDrB7924kSXoVj+dHYXFxkbNni4yMHLya3UinC1y8eIy5ubkf+13D\n", + "MPib//k/KV28SCEcxnccHjh2jKzvE3BdpFCIWjhMJrcHP9vLSuMEwXYNJRhkPRxG910ulDQMMUPJ\n", + "dckGI5TVy0QDI6xVVJSojW2c4vodA/i+ycWl81TaGi+WS8yvl9BbGvs8jxywIHgUfAHVjdPBI4hA\n", + "DhmVGiY55nFZoUMCjwQCIYJsLyEi4JADBGx8fIoIyMDmlVcQ2AWkEGjgUyBAAJ8VRNIUWCOIRZw4\n", + "m2SRCRFGoE3MDyD7CmkEVraWGZeh1Wzy1W88RnV1mVq1RSAYYnWrSiKUp+KV6FLixMMC16TDREyT\n", + "C488wrl3vIMbbrzxp3p2fhKsrGwQCv0wETISef1MZt0wuK6//+r7TqfD/Pw8lmXheR7HnziMML9B\n", + "KjtIa32OE5dPce2tH8AwWuRy2+W7W++9l4f/+q+ZHB/HcRy+e3kDU+8iFM5SKRYptlqsGgYCQcqu\n", + "yom1BhHLpFcUWPMVXCJ4tCkg00HEQ2EAjQQuAj5JRDbxSLJFgzJbQDc243h0s/1chdgOSorA8Dbl\n", + "GRHwMPBwiREhTS9zFEmhMEgWkSYCCZrU2EQGJAoYJFCQcBHxiZGi0+lwZOYoCAFkymiGhNTQMIMO\n", + "flMg//I6+/ffzAd+4zf4sz/8Q1ZrNaK5HL2xGEng2MYG+QMH+PX77/+hctjb+Olx5Ajs2vXGufT+\n", + "KLydGXmD4fv/P3vvGiTZXZ55/s795Ml71v1eXVVdfVXrjiQkBEJIICGQYgBBLBh7jYNl7PnAbDDr\n", + "nYmYtSO8M4aYWBze8G54wONw2NwMY7BZtUCiJYSEpL6p1Wr1vaq7quuelVl5P5nn/t8PJyUuuiAx\n", + "tADB0x+6uiozT3X+85zz/N/3eZ5XBMCrKhz37DE5ceIJVFXhlluu4O1v/1Ek+DPPnGZg4CfZfCKR\n", + "olw2WV1d/QmXy2vBLbdczxe+8G1SqRz5fI4777yPM2cOUq/PUShELC9vsmPH+7hw4VkUZYZsdjfl\n", + "8mEWFyMymXmiKE+zWYL2BsKbpyMZ+FyLShoZFx2JFP1EYYOQNkkkXNp0iCd2ngICNJLkcFHpEKIj\n", + "8KjToEUvLcCkoCi0Ig1PT5K3dJxGkefOHefC+iKRd4FSS0ZmpNtssZBx0OgwSoRJXBqGuCXQB2wR\n", + "k486ce7iIvEuzgROA88DhZ07+f0//mP27t3Ljp07f65JugBzcwuY5kst2pY1yLlzF1/xee12mz//\n", + "kz+h8uST7MnlqHY6rBWLXG1ZHF5fZ9fQEB1d55Y9e3jg0DkMfYK9d36MQz84QFZRuXI6RxDOMbda\n", + "YXb2JiobG4hqichfYqk5TyAEpquSsfKsb0V8/+ADJH2dnghaUZKFss80LgVFw4sCBCEJJBwkQBA3\n", + "pAQGKQymUHBpobDFBnk2iQCfAiEVPDwcBH73vXYRVInFypPEJX0FKCKRQiOQdPpEghouOhZ5ynRo\n", + "kiNExkEQogIJPOywhiNZpGWFlusS1XSqzZBqaROn2aHRAF8xsZ0qgxgM60lU3WYklWKj3aZgGBx+\n", + "/PHLQkZyuTSet/aS77tunAc0v7bG5EDsBFssFvHyeXbt3g3EgvAHvvQl0p6HKgQPHz7MVQMDWAUL\n", + "RZaZzA9gNSqcfOYA49sHufLKuwGwWy2qnQ6P/uAJypUaZRdqTYspEbDp28iRTLUDodLk+jtu58KD\n", + "D1KQIhIRRFis0yAe0GDRQUJDJiQki0MZjQgVGY9LCHRCWjjMEicqbxG3ODUgB6yjUAF6iGcQNdCp\n", + "4SJo4uKSISKPgSDER0YnJI1GkVVU0hQIkIgISJMniUNEHxorQkWIJjo72cLGkKrkwxC16XDw0f0o\n", + "yr0UV+axazXK5TJTqRSSEFTzeWbuvpuP/+EfvuwU7mq1Sq1WI5vNUrgcgRlvQuzfD3ffffmPs20b\n", + "bG1BowFvJg75q9KmeVl88IPv5wMfEK+oEXg5JXYcTPb6p49u27aN++9/O/v3P065rBFFHvv29fLB\n", + "D/4Zp0+f5tIlhcXFZ+l0UhiGArQwDB0hCpTLK6SSNrnOWXKBhoKFJ9qUmadCC0tWMYWLh0kLmSEC\n", + "ehB4xBWK54AhZFQS1FFRSFPCZYuAtF5ABHU8YREpJqUooCM0NEZZW7MpuxKXtk7Qx0VMPPbQi0mZ\n", + "JiFFNpDpAUwU2rzwbvnEpOSFtkAbKAGzwCaxVgTi26yeK/A3f//3XP8LuEGZpk4Yei/5fhB4JBIv\n", + "vSC+gMcOHGDj2We5dXSUpK6zNT/PsBA0ymX2ZDLsGh7mTKnGNx89TSbXz8Gnvk+95XDz7e9j/txJ\n", + "zl06zA3XjKKOjtHTt48H//EsbvEUEyJkJpKxRZnQl7lQ3MJdvcSUKJAghSJLSGqORW+FCiFRCJYs\n", + "IaIID0GEh4WKR0SESoSCS4SNDySQGKROhRQRGjISFhIhZVrYxOQv2/07JPa6K8TE0EbCRMIUIdBG\n", + "IsKnRQEPFZMMCSp4jNDBIyaUPgEl12ZKTeIhEwpB6dxRsh2bPk3hhN8iJbI4UYQfBdT8KlcPZdBk\n", + "mSgIUIUgfI3uhvX1dZ49fJhKscjQxARXX3/9q960du/exUMPHaTZrJJOx24X224Qf/LAuuIKfnj8\n", + "OJIkMX3FFXzkzjsxTRPHcdj/5S9zRSZDNplktVxGqTc5t1IiOzSEqjbpdFLISDQ2Fvmf/uQvyefz\n", + "saPtH/4BZWGNG8avx9qV4wfHnuRY/Rx+SWdCTxBIAkn1cUWDwwcPErougSzjRxFNPBR6sFBRkNEI\n", + "UBEIcgQEQJqLqERkCNFRUFBZoMYGg8RVxgxx/9kGWggUDCpEaERY6KSRUYAa6yg4JDCQ8QjwEQQI\n", + "HBL4hAh8AhL4JEmhABlCIjx0MrgUCLEpsMpIaCKLgKZXwfVaHHr4H5k1fD6yexfBxATHVldZDkMm\n", + "slmuuPHGlxAR3/f5zre/zcVjx0jKMnYUMb5vH++9776XDCD9LX4S+/fD1752+Y8jy3EF5uRJeAVJ\n", + "1a8lfqXJCECn00GWZcyfCqS67ro9PProBSYmfhTUZNt1EgmfkZGRn36Z14Srr76KvXv3UC6XMQyD\n", + "QqFAtVrl0KFjlMtLeF6VdHonfX0pstkRbHuTRqMIWNjlZ9muJIm8i2j4qET00SSiRL+UwySkLoUU\n", + "hcMAsZCtTnzjTwNyd1ckWMVnjBQmDQSm5ZNU0ljaNpTQQfLq6J6C74UUvRo+CXpQEcAEoGMgodCD\n", + "TBaXOk18Emx1f+50j+cQx8rbQBkYIy4lF4ERVDQtSdXKMrzvJpaXN/hFbJZ3797JgQPH8LyJ7hBC\n", + "8H0P399gz563vexzgiDg7NGjFJLJF/M/2q0W29JpyuUyimWxUKmx1siS0wtsH9sB2gKdzipPPjnH\n", + "fffdwTv/j//M7OwsFy9e5DOf+Rwby6e4QZWIAoEXlhiQ2oSd2MacIoNJIpYTShIhEj0kWEJmg4Cp\n", + "SKaFIAtYNHBQAJkqClvoFFgiD+jUqOLQokMLhRTlbhUswkZiCsF09/9oAvPEN64y4CORRKB1i/ot\n", + "wEBBpkQbjQygd6szm4S0gfPEu3ArDKk6Do6SZK5RZzDw6EiCtqLgSzIiWkTDohjWGUtbjGRHqXQ6\n", + "ZLJZzrou77nllp9egpfg3LlzfOfv/54RXUePIs6eOcOJp57iI5/61MsGj0GcUPx7v3cfX/vafpaW\n", + "JCRJIpEI+J3feS9/9mf/lvd94AOE990H8BP5MgsLC1ieRzaZpO047H/6BOtV2JMco91Uyfcm6e83\n", + "2L17B7lm88WK6KHHHiMfBFR9g3whrpsLx2EnDgnFRRJNMrpJjyK46AZcXFmBKKLoeV13kyBBng2q\n", + "9KGioSARItDZBCIkYBgVBZc2Gh4KA9SpIeOgEp9nAE0kUqjYBPShkkXGxmcdlzQaMi4hAQoBJoIm\n", + "0KCERg4PDQXBJjYTuGjkcIEUEUXipp+PQ5Zl9mKSwERRLPywzoXQw9m4RN/0OKnu9fOdMzOcrVTI\n", + "9/Vx/vhx3nHbbT+xTo8/+iilZ57h5vFxZFlGCMHJEyd4JJHg7ve//2d+Nn5TMTcHrdYvdkrvq+EF\n", + "R81vycgbhP/2377MwsImkiTYvXuSu+++/UUm/9a33sDc3CUWF5/BNHvwvDaKssXv/M49Lztp0nEc\n", + "lpeXkWWZsbGxV9SUaJr24gW10WjwhS98hWo1RTK5Hc/bYmOjhqIsY1k6mYyGqlrUakvoYZmkrJLR\n", + "LVQvwJFtFsMtRogYoDeOdhdtMvgsE9/4LeJWSQrIoFInQMEmYpHN7sVPcvJIWpIOBS6EK0hODeFq\n", + "NHGoI5Apo+OTJyIJtKiRJEkbFwufIi1CTFxi/UeWmHAUiV0cCrGDYxFoYtC//V/hahnswGVkeIh7\n", + "772Lo0ef5aab1l/xRvNa0d/fz733vo1vf/sJoih2T8hyjfe//yaGh4dfds1OnTrF4tISPdksq+Uy\n", + "k/k8UvciKRSFShAQtQRZs5+2GyDLMpnsIHe/5z2srBzkxhv3MTIyEg+Dm5wkK2/RmyjTsjtkQo+J\n", + "bvtqFcgi8AlR8BHI+CKgFTi0u/6IZUIahMjEVYw4sL9ICZU1chgI+lFJoCIRkKWJDUhkSVHHoMM5\n", + "IvrRkBHUAfBpEleq6sQi4jaCGQRbQIs4pbcfWMKnjU+BCI+QMTxEd+2SxOJImZCTXkBHS2MqKdJh\n", + "g0TkMa7KJA2D+aCDqTtshirrqsrRchlXlvEMg9133cUNN9zwqmtYqVT4wv/1eaxyhdNbJbKaimUY\n", + "bLou/6Cq/G//8T++4nMnJib4zGf+F9bX1xFCMDQ09BMuqpcLuQuC4MWL1NmlVfxwkGQ+oNNpoeoJ\n", + "enomKJUuMre6yvC11774GuX1dQpISFK8m4+EoNWp0OM5ZGWDjAiIgoj1loMLXDs8zOT4OIePHmXJ\n", + "cQgI2aRNSJ4OTfoRBETUaeMjoyBIoNEmIkSihoNMCw+DIzhMEWfGlIE2MhIqGXzSSOjICEIG8Kng\n", + "IRMLxWOCCwNIzOOzSJEOJi4VEoSsEmLj4KLiIfDJdVNPSvQjsFAJhUfoRyCH9CNYDnw0Q8dutei4\n", + "LoqiENbrPP344/iFAlYqxa3vfjfj4+P4vs+Jp5/mxu75AnEFetfoKE8dOcJtd9zxmrRhv4l48MG4\n", + "RfNzFOV/LrwZdSO/0mSkWEwzNrYDISLOn1+kWPw6f/RHv4emaSQSCf7gDz7K/Pw8i4srZDIj7Nnz\n", + "/pftf5448Tzf+tYj+H4KSRIYRocPf/guCoUC5XKZVCrF8PDwS9o7R44co9XKMTExQ7vt8sgjh6lW\n", + "t6hUxiiVygwPpxCijedFyF6afCQwZZVA2CTCDhoNksh40SYSHgot+gmxidsjk8SViTpqV1MCG7gM\n", + "kMAkYgtwXR/Jq1BrnyCjGhTdWDuikCRFgz7krqgtJAu4uNQxSZBDISKkRi9VNGI9wipxuJYDZJAI\n", + "SKJYY9hhAi2psm3bPvr6ZgGo1YosLi6RTObY2Nj4HyYjANdffy2zszMsLi4ihGBycpLcj9k6X8Da\n", + "2hrf/Lu/I2HbpMplitUqZc/DjSKUVIrn1tcpJhKM9fSw3AjwohAjlaLcatG/bZKFhVMcPXqcTscn\n", + "m32cqakChiZx7swZVEUQhh2yxOJcNxKkgCwRy4Rda67CKhHQh4egg8kK6+i0MIHB7to5QD8BLg1C\n", + "BBIDOFgolMgRkURmkyp9SKSQsRHE8sUkFSI6xETE72aVjKPQwOUSIRZxCy1CIkKnQ4okbTxCAlI4\n", + "RMg0aREyjkYaiRYyfWQoqRp54dMv6yhCJ/BtZE1lMpGmmEsxODhIcniYhusyNDrKHffcw53vfver\n", + "tjiLxSKf//zfsHhqHam+xWjgYemCmalRtqdS7P/ud1n42MdeVa+lKAqjPyZM/VkYHR3lgBAEYcji\n", + "RpWMNUZ6vIdnnvseecWns3yelY01gmqRa4xR5v/Pv+Bd73or/SMjdCoVosgBwPNc7PoW+UggCY9a\n", + "4OF7cTXKlyQuVipMTE9jGwaO41DrNs9k+igxSI0SEQ4eLUZQaOJRxcXHAspYlJnBwMREpU0Tn3ks\n", + "EvSjk6BJkUEkGiRooQEuJgIbh13EomWPuFLaQXTthYK9qARILGFQx6BMB4k8OhYBPjBPhgAJQYsW\n", + "CgZC+EihIIo8bCVgdWWFXLNJUlWpNZucrdfZsCxoNPji5z7H3/3VX3Hfxz/One97H1IQoP/UZk5V\n", + "FFTizcFvycjLY/9++NSn3rjjvRln1PxKk5EXooklSWFoaJpLl44xNzfH7q6wTVVVdu7c+apW3mKx\n", + "yNe//ij9/ddimvHk12azyn/4D59nfHwcyxogitpMTmb5yEfuI51Ov/jc8+eXUBSTAwe+TbFYpd1O\n", + "kc324DhFBgZS6HqLmRkJWR7hqYfPUYsE42Ya33cIJBCSjiWHdJQqsh8QiQAd6IUXg648VFyyNAjJ\n", + "YiLjskqbEhoeIIlJEqxSiNYwQ5eACMEwCRrsQMMkQQOTGh0ahEiksEiSQKJKSJJeQEanThqFZjfc\n", + "zMVinTzb+qbQE1lMZZBsIcvS0kl6eqaQZRXLyrKxUWZ62vqF9ouz2SxXvkpiTxiG/MtXvsKMqtI3\n", + "McG2XI6jjz+OWi5Ttixk0+RiGLJndpbBRILnn3qGcrvK9Mgo/Tt3omg+zz67QCazix073s7ayjm+\n", + "9PkvYtWXGKhucaHToRxFbANSioIjBKvEbY4AjyIbBFjIzBIi4+KR6zZHmsyj4qITawIqxHqPEh4+\n", + "LVQSCDxUmuiohARotMgjAxK9wAoBaWwietHI4FDHxWOUYUxk0qwiCHGR2EYOlSRbBJxHp8wgMmUm\n", + "MGl3c0sUwJI0DFlhPexgSXnAJyVrNIRHghBZSGh+m3YoOOG0+d//+I/5xCc/+brWbf/+R9G0SULl\n", + "GP1CMJztw/NdllbWmd0+xYiuc/LYsdctHn815PN5rrn9dg49/DCu71BrNVivlqhq/UTWKKdX1mi3\n", + "Fd5z8ztYW3PZ3Kzw0EP/D9dfP0becxBKm43iIrV6GzcMaSkKVuiiASPE2o6UEJi+z9d++BQDvoRP\n", + "EphARyEhbdAS8bnYpkyKEUIMLCq4dGgT0McGu5Ax6RBi00FgoaMyTo5kNyHIBPoJaaLRg4mERxmV\n", + "DRRCEsTtugTxpsEGBjEYJImGwMDnIgpbpIhYJ0BlGzY9uJwljQO08MnioCCIpDR1PUENFQMotlqM\n", + "ZLMs1uvM2TapTodp10VSFGqNBs9+5Sv4lQqOLFNrtcj9mEi91ekgJRK/ddy8AppNePpp+Kd/euOO\n", + "+UJlRIg3rhpzufErTUZ+GqqaYXOzTJeLvCacOHEKRRl8kYgArK2VWVszmZoaZmxsLwCrq/N861sP\n", + "ct99d3HkyDHm5pZ4/vlTnDy5QW/vLXhem1zuGjQtTal0mr17p7nqqqvZ2DjBxz52G3+VUzj43/+F\n", + "cqOKJSVoCxVbNhhQZXQridwqkvIDRogFpC+EXIXIbBHiYbJChwUi6hhINFBRCXiclAhIdLUBCTJY\n", + "uCTxMNG7YjiJqDvrRCdCw6eDYBONNFkcQKLBIhJNegkTY6SzKQYGbmD79h4GB/t47rlL6HqaSmWB\n", + "RmOdXG6MIPDQdRfLkpienn7pm3uZsL6+DrXai4mc2WyWG9/5Ts7PzXGwWOQDn/gEn7nuOqIoolKp\n", + "cNsnXf75nx9DkobI54d46KF/AgbZt2+WMPSYO/w9RhyVph2xra+P4soKiSjiEpAPQxzialEEJPBx\n", + "8GmRxOwGl+0gvmlVMXCw8HB5nriylSG25HYAQRKTBB4BESYBNh4CBRmBwOvueHMobKCQR0HFokYb\n", + "CYUUEQbJrg7IZbV7mzKQyaDTg0ubHsrkkLGR0IhIMorGpqigiwQtEgQiwA4VlgKXfmHRFG1MQvxw\n", + "ykkqAAAgAElEQVRQwtUttg+PsnbiBOfPn2d2dvY1rYnjOFy4sM74+K2cSmUJ1xcA0DWDlt1gpVxm\n", + "Yts2GtXqz3il14+3v/OdjIyP8/ADD/Dst56kKXrYc8W7CcOISvU8eXOYp58+zPbt72ZgYA+2XWd5\n", + "eZW51jxmu0S7tMWFlXVsfJIEeN212yCuFOYAzfUxkWgSIdFLAZMqgi2hkiVCId5AWJzHJ42KisoG\n", + "SST6kH7MdithAsdJomEhAQYym1iEaCiYqEQ4qPiYgEoViRoBFnTnT8WV02TX/+YREBKRRKOGBIRM\n", + "ojEmBTSEwh5sSig4gIIGqGyIDiV1lP5sBj9TZ7PTYaHVYrHd5kpZRgDbdZ20aXLBcVgvFsm029DX\n", + "x8lSiVnfpyebpdpscq5S4db773/VWVG/yXjwQbj5ZvixfexlR9d4RrEIb5aQ3F8rMhIELXp6Xt8o\n", + "63q9hWH8qLTYatU5ePAJwlCmVvtRqNLQ0DTPPfcw8/NfQIgh8vkRXHedixdPYpptfN9BVRP4vkcy\n", + "mcW2BYaRQJZNfN+nZ3gbueFtOEsVHE/BREbGZi6o01uvkok8JOL+/ggggAtI9ACCDi10trCok0Gj\n", + "xAguOm73AhNrAmLbp0AnIkuI2rV1GkCAjEBiHgMZixQGKiYNVGxMamSoKNegaCMk0iWmpvrp6dmG\n", + "71dZWChSLFaJojqOU6dYfIIg2Ee9vsxb3zrCxz/+kTdUSR8EAT+d3+oLgauZCCPF0NgYCxcvcuLg\n", + "QdqNBuOzs3z0o+9lcXGFM2fmMU2Xt7zlevr6+lhePo/WqLPVrOA4Nk1ZJifLlLvvqUcsNOwFnkKi\n", + "RR8qbSwURjC6YVdgEmIiUIlj28Pu77VArPPIo3KWBAYtBlARyKwR0UIwgUSLsDuzRmYcgzUk1kh3\n", + "Q/5dplHx6QBy949ORNS1D8etnB4kSoRdQ6+HikEDlS28mNgYeZSgwarfYCizl2JlHV/yUYVMTkmQ\n", + "tFKcDwN2pnvYlcvxxEMPvWYyoigKsgxRFLL32ndxdOEkGbuODtQ6LfKFKTIDA4xeJtI6MzPDzKc/\n", + "zWbN4cCBTTY3F3HdDlBlYGCMpaUWURSvimlaXDi/SkHVuGHfLkbekuah73yHp+fm6FcUlsJ4ErZK\n", + "fC6WAYGEimAYuZuYalDAwMVhjZAefHoQjOIQ4pAgDqV7FhmFBDIhKhoyPkl0QgQdYoIbIBHQR4kK\n", + "vYTIRCgErBLhdeXuSwT0E+tMikAdmQlMAtRuIy7EYp0EYOAjST6rkkQoQnahYAEryGyikJAK1GSV\n", + "fO9uMlqNG6Z6WFhZoRGG6NUq40DJdXFsG1NV6VMUlsMQ1fcJHYf3feITPP3oo5xZXaV3cJA73/e+\n", + "nytI8jcF3/gGfOhDb+wxJelH1ZHfkpE3ANXqJvl8f3ei5zK5nPeaL54vYGZmnGPHjtDbO8Lx40/z\n", + "2GNPsb4eIURArbaOaabYvftaAJaX1xkbu5IdO+ITb3x8mtHRIouLZ7CskFptHsPIkUxazM9fJJs1\n", + "kaQl1tZGCMNBvPwoCxdqDEgmjiwo+XG6YokiCgZ5PK7sBo/5QAbBHIIVFEBCxiDDFkPEI7sTxBfL\n", + "qPt1D7BMmwZBN79AECLhdjMnIqCBSZY8FjIe4KDj4uHIs2BcQd9gFkVpsW3bJPPz5wCZ/v4pEolL\n", + "rK9v4jh1NjZqTE9n+d3fvZMPfvBfvawg+HJiaGgIR9dpOw6WabKwvs53D1+k2jKwxnby2f/8Vaid\n", + "43dvv4nC4CAbi4s8PDfHhz/1Ke666w4URSYIXvhoCxqdFpFTYVqEKK02sq/TT4bzQBGFfsokgDZJ\n", + "8gxTZp1eAlq4BBi00QCFBhUs2rSJKyJJYpIQEpPMHnwiCpRxkBDU6KNOEwWbJhJpZNLACSS2SJFA\n", + "RkYCJCo0usTHwwU8dBza9BEhoeACDQQSAXlqjCJjIdFEsEhABRstKiELl/60RbN1CilSWUVGk6oI\n", + "LUmvkWREqLj1IhOjozyxsvKaI+A1TePKK2c4ceICo6OzbFx/J81LZ7DCiJGZIUZ37mTTNLnqmmt+\n", + "0R+HFxEEAZubVRRFJ4p8wEVVFaJIQpYtoig+b1aWn6OzegRhynz3/1tlW38Pim0zJQQrYUgoSUhC\n", + "YBKT0YAkLh4RARYqMuAg4eCj45NFoOJgEKAyRApBnQZzdOglwkewQcgAKiqgESLTRqdDlnhgZxON\n", + "IgNssYhBh4CQFhoGJkZXoWIDTRSKxEQnViK5GLgkEXTwmUAgE4EQOAjGEOQRSEgkkTmDQb/RTyj7\n", + "pBIG2STYrkuj2WR4fJzq2hqu6+JJEglFwWm3cTUN3bIIhCCTy8XEb2bmsq3jmwm2Dd/7HvzX//qz\n", + "H/uLxguOmjvueOOPfTnwK01GLGuNpaU5IGLbtj7uu+/+171D37VrFyMjx3jmmQN873tHsKzrSCTW\n", + "UBQZSRrgm998kOefX0DTEqyvn+Gaa+558bm5XB+Fgko6Pc30dIqjRw9SqwmqFR81XOWJteNMjgR8\n", + "rTxPeuhGZLUHzxhk2dFw/QpxmHcehR1k8GiwyhkusYgALFxCitgEpNnGICqCkAYGNmni8LEX0jlL\n", + "xNbcLULarFEmjY6PjkSHFhE+y93kkDWqbJFFQxCyHgsglT50aZ1GY4Xh4VGEEEjSeXx/iPPnnyaK\n", + "hlAUn1yunyCwOXduhcnJiTeciAAYhsFt997Lo//4jwwoCt89fI4gmsDsLbB7z7U8+8QTJJVJFjZK\n", + "9OfzjPb1ERaLHHz8ce67/36uuGKKL/zVl0noBfJD29jymoyGDr7fpomFRg4FGMBllQKL3TkvggI1\n", + "VBwK6GywxTIOU2iYRLRQaGOTZ4EN8sAMEBLHuceEUVDBR8MghSBNgE+DfiTqgIvBGgZt+hFksJHR\n", + "WWEEhwQuBgGbrCMhU8IjS0RIHY8cGoIWMr00GKLebd6ohHgUaJIGDCVkJpXGSCbpVKuUvSplNISs\n", + "Maga5DUTL6iSz/Xh+j5aIvG6ZgK9+923USx+g6WlZ+gdmWUlsKlX5umbmUbbs4eP3H77ywrIf1F4\n", + "/PEnabVkLCtNT0+8YTh16hBra0uEYZFEYh8bG+epn/0O41GEaDaYzEKP73PK87i2v59vb2zQKwQX\n", + "gZ2Ah4KQshRFoxsymGCEFCc4j06OXgwadDCoksKgCfhYJNGpUUPQYIQ2pW6FSgdaeJTJoGDT6uaK\n", + "OMThbj4TuChIZDBokqFFjTVaFDGJ0EkgkeMCbZp4jHYN4VuE9BFfExzgJBGDAiLFwI4EhpCQZBiQ\n", + "YMMvU1Y1pgs2b9s3ywOPHEButTDX1ylHEX4QkNE0ykGALknY6TS53l7qqsrbb731sq3fmxEPPgg3\n", + "3nj5U1dfDldcAQcPvvHHvVz4lSYj/+bf/D61Wg1FUV63eOrSpUscPnycWq3J1NQIzzxzGDAxjA4z\n", + "M0NsbdWo1SrYdi/Vap3+fgnL6uGpp45w5523o+s6up4gn09z8OAPse0xSqU2tdoidJaYyWQYTiYJ\n", + "yzal6jOcOvQsgTVF4F6iz6+TJ8JHZxOJLQxUevAosIBLDykyyGwhqNGhwBYJ2ng0CWkwQUiKH0VJ\n", + "p4Gn4EXR5DoOSRyKyN2RWyYhQ9j047OCoWxgJFM4jk0U7cUwpjHNOtmsRCIxQKVyhsnJ67jzzo/w\n", + "zW8eZGlJx7bb5HJjpNPDOI4NzPOFL/wTg4MDv1BB4mvFviuvpKe3l4f276d5vMLMrusYHR2jXq9j\n", + "Ar2ZIc5cOs0Nu+JK2WChwLH5eQ4fOsTJAwe4bTTJ8uICi08fodbaJBW2CSOBhwVCwiYmEhIgU6CE\n", + "x7TcQ1NWuRjkudR1zZg43ZaIikuOUEqyLjrUaVMiwiIuq0sMMcwEKSI8Ito0yLOChIuKRLur//BJ\n", + "04NNLA9sI+gQISEQ+AjStFlBxsJkkwCbNgputxYmsZsOGtDGp04Lh9iJUU+n2VUoYIUhzUoFQ5IY\n", + "kSRkEVAJPLY6HlM5hchUGZ2d5dTqKte8972vONDwBXiex+HDRzh8+CRhGLFv3yw339yDbXfI569j\n", + "ZmYGTdN+rqDB14MoinjqqeNcddUdHDr0GJXKHMnkIBMT05w+/QCWVWdz8yRbl46zzzKxq1UCv0ml\n", + "YVBp12nj4A70099xqdkttEhwRpZoBhGeFNEUBSw2aRDgEjJMi0Fq1FGQ8NGx6EdCIcQloATYqMgY\n", + "LOORJ2AQOIPBKsPojJJGJkChgQ2sUKCHEstETJCmQRYZFZkk0wTodGhQI8Qkh8s4Jc5gYeMguJLY\n", + "/hsCiizTiCLKqEhKgg0CzAg0IXCiOuu6y+w1V5PtiTh4YZ4dExMkczkKsoyVTnNmbY2W77MURdSD\n", + "AFSVq/ft46p77uGaa6+9rOv4ZsMvo0XzAt5sM2p+qWREkqS/AK4FjgkhPv0yPyeff30aEYAjR57h\n", + "W996EssaxzQHWF7e5Pz5VcbHr2N0NA5J0/VFGo15FKWDJNW55ZY7aLV28sQTR1hdXWNiYoKjR4+z\n", + "uhpQKGisrc1RrbYxgy3emu0no+pU3TpZt8lQSqFf+JxafYZRr8Y0EKHRIoeFgsIlKgh8fAJmWcNm\n", + "HRsJCYMkAo+ITfJErHbbOApxKyckdt1kuv/eAjw0mqRx8HEwCRlDJgmYaGYaWGLXrvexsnKJVquK\n", + "JGm47hDN5hYTE70UCgU+9KF7MQyDf/mXw/T2juD7bZLJOOsjDF0KhSEg4sknn/mlkBGAkZERbrvj\n", + "DhaWYWwsLht3Ojo+IBDIP3YDbHU6aIkET+3fz1tGRjA0jZ2Tkzz22EHWKk3qLR9ZJGh7OglFQw0F\n", + "RVw6aF1JoIQcRSjCpo1PQIYOESl6ULBoxc0uNCEjY5LHp9AN1y8h4VEgQEZHwcCjhwxbpLuR/wqb\n", + "5GihMYqgnz4EASYVCihcwsHAw8NCR0HHZRWNDClKtJglZIyQNaCCQo0UAo02bSZpA+DLMv25HGvL\n", + "y6SJdSwoKm7gIysavgRPV+vo+Sz5gQF233orN/6MxKROp8NnP/sXHD++Tl/fGOPjUzzxxBr9/Qt8\n", + "8pMfe0kQ4eVEEAQ4TkB/f5ZbbrmTxcWzrK4uYBgab3/7Xv7oj+7nG1//Zx756iYEESguWTlPSjKo\n", + "dlzqkccDK2vc3DeGkxtmtbFFfxTREBErnTRDuRnOl1UWog00OuSIyCIhEbKGYJKQPhI4xOe2hss6\n", + "Ah0FH4NLBETIlDHwmcQnS0AHmQCJFC6D+MhkUAGVXkJ8QCKBhsBHoY8Uq7iksdGRSHat4Vb3miCI\n", + "w9g6UUSSuAXXCVNkjAydsEkj7FA1Va69ci837dvDroEBHn3yScaAmmmSSSbZWSiwZ2KC7ywsQDbL\n", + "O++4g3vuuYdt27aRTqfpdDqcPnWKzbU1evr72b137889/uHNjmoVHn4Y/vqvfznH37sXTp+GKIpT\n", + "WX/d8csclHcNkBRC3CpJ0v8rSdJ1Qoijr/acIAg4efIkx4+fA+Caa3a9OKjtBbTbbb785QcwzV0o\n", + "ikU6nSeTKdDTs5Pz508yMrK3GyUPudwkmnaGt73tHQwMTNDbG7C0dJ7z5x+jXp/hzJkz9PfnkOVp\n", + "DEPB6yyh2x4yCltOC88tMZvN4TsNTFUi4TcZJiSFSgufgAYWLUaJcChiYxBQQMOlQNS1fsr4aHhd\n", + "Fb+MYBOHNLGIc42YhMjEYskNEmwxjcc4ERniZAIFlG1I0ga6Ds3mRdbXV2g263Q6HYQ4hKYN0GpV\n", + "WF6us29fH+l0mkwmw/R0hgMH5omiUcLQx3FaJJMyhhHS1zdMuVy7PB+A14jR0VEMw8G2GySTGXK5\n", + "LHoux8LqGe64tg8APwg4XyoxfvPNlA4dwtA0gjDk0acO8/jzp/HbDWzPJo2KLZrUhYaDg0+SIWQi\n", + "bEwqLOGzJYYwmQJ8fEo0SCJwUFEwcMngENJmlgCZkAoSAWlAZ4MO/RgYKFTxWUPHAEJ0Eli4QAKD\n", + "NhI2ETIyCi4ZArYIGcfGQqVFSAKBA2iYdOggABuFIuOMkUVCxqVNkWWykk3Q6dBRVTRNww9Dqo5L\n", + "TrdYl1wUzaQTBQxdcweT2yf43f/13/7MrI9Op8PnPvd/873vrTIwcCXFosPa2jNceeVuikWZU6dO\n", + "c+21l08f8tPQdZ2Rkd4XdWQ7dlzNjh1X47odarVj7Nmzh/ndJ2nunebsD49hiT4agY3nd4gQ2GqS\n", + "AJVnayUmp/cRmCmeq2yQj3ws0aZOld27r2Njc4mVzZPYBGQQpFFIEOLRYYuQqBsKb6NgEFDGx0Cn\n", + "SY4sfd349iQWdfq6Wo4mAhcJCR8fgUJAiI6EjkMNmwAPFxkbjRQNNvDJUMClSZIULk1CDEAlpNEl\n", + "L1UkQuGSihqYgUNbeHRCQW1ujkY+T3Z6migM2dbfz8rWFk4yyXylQtN16SBxz/338z///u+/2Pre\n", + "2tri63/7tyTqdXKmyVnX5eCBA3zoE5/4hWQMvdnw1a/Ce94Dv6zRPZlM3B5aWIA30Ox42fDLrIzc\n", + "ADzc/foAcBPwimQkDEO++tVvcvp0jVxuDBB85StPcfXV83zoQ/chyzK2bfOXf/nXHDmyRjbbA6yQ\n", + "z+vceOM13Hjj7czPf5bV1YPk8zMEgU2tdoqRkRSzs3G1JAh8crkcu3YNEYaCIJimseWxvHQWS0/h\n", + "NOfxQpmtoERSVVF8j4VakYTqoyeTyJqC7kW08Gggk6SFTKo7DLyMTwKBRpIEDgkCfBJIdHARmBgI\n", + "UiSoElJFJk3swGkRE5EWEk3GQZ8k8mLTYOwDWUKSLqCqIe32FqDQbPr4/gBhaAMlPG+ddNpg+/ab\n", + "WFp6iL/5m/+OqlqoapK+vhrnz7dQVYmBgR5M00PTWmxubqEoDgcPHuaKK/aQTCYv00fhlaFpGh/+\n", + "8F186UsPUq32oqomPYMakiSwVYlnlpexJYnr7r6bgaEhNg4dwvE8HnnqKQ499hi5toMu6XSEylIU\n", + "oWKjRDppEgwQssESPVLAHknmhLCpiQCTJglMfBScbqPEQiDhUafEKA5ZVNpELKNjk0CQpUVEgxYJ\n", + "BBERgjY58tSJ2KLZfUwNlwwKw0jkuEQFiWXSRAwQ4uJ3nTOCTWSSaGygskmER4Y0OcpI3WD5BE2S\n", + "NIRHMgg5uLDIqIjIqSqWKdPQU1w7OMlousDBdoMbb7sfzytx9uxZVlZWGRjoZ2Ji4mVbNYcPH2V+\n", + "3qNQ2EcyGU/WDYI+Tpx4luuvv565uUtvKBkBuOuut/PFL/4zQeCRy/Vj23UqlfN84AM3o2kanSDg\n", + "9JmzrDkBs0pAQgjaUUSVEEfuwZBtJLnFJZEjP3wL05MpLi08idw4S1+vQiBqoHWYTGmstTqcI4mM\n", + "SkCDBAEaISHQQMJB70qck7gYZBlCx0TuzpMx0PCooWChENHHFr14bBJRwu9mmXiojKCSRkJjg3UM\n", + "qkzRYZkODSy2k2WVKmkibCICwEGhRYQgj4vEVgQpI4MlZPbIJTZabR45eoLT5YhmQ2J9fZE9fSYD\n", + "hsFCqLJYC3CS0yxekvn857/Ivfe+k3PnLvKNf/gqA60GN161i+GREcYUhY1KhYe+9S1+7w//8A1d\n", + "618H/O3fwn/6T7/c3+EFR81vDBmRJOkWoCKEOC1J0juA64BnhRCP/A8cOwe8MKq1Dux5tQfPz89z\n", + "+vQW27a95UcvkOvnuecOc/31i0xNTfGd7zxCsaiRzQ5QKMQth1qtyPPPn2HPnhne//47kOWI558/\n", + "Qirls3NnyI033kGxeInjxw+yuLiEridR1avY2rrIxqrDtuQwQ4kECauHWjLBZmWBFTnADwPsIIcZ\n", + "poicCpm2Ta+qskgcMSaI0ACDJiXAQKcPm3VkdPZikqZKmzKraLiUSdHCBVQckiSRsamiE1BGECBT\n", + "ZZyB4XfSbIWEwiYIthCiH2gTBDqKMkEYVkgkbsK2A8LQRZIGCcMkcBDb3mJl5WFcV+fYsVUKhR5S\n", + "KZ1q1cO256hUzrK5mWF2dgdCJKhUzjIychsPPHCG73//CH/wB/fT19eHEIJ6vY6maW8IQdm+fTuf\n", + "/vTHOX36DPV6i8nJdzEz8ykqlQqO49DX10cymcTzPJxEgqeff55wdZWcGzCk5+KUBjXB0UaRYSx0\n", + "XHxa2EhskwWmapAxMySaLQq4yASEeCSw0GnSoYpNEw2JMVxMLGxUTiBosJs0KZq4wCAB6a6apEFE\n", + "ggV0BEHXGFqmgkIOAwmfeMKIThUJhXXO0cAgYAgoIyEj2CDOL1mk3q2XAHRQEAjAJ8U5GkzKCvV2\n", + "xKLfJhAhQ2aCiXSSjGHxfKuG3D+GoigcOvRDgkDCMLJE0TPMzGT56Ec/+BJh+PHj5+jrm6BSabz4\n", + "PVU1gCzl8jLZ7BW80ZicnORf/+sP8oMfHGRx8Sj9/Xnuvffd7NixAyEEK/Pz9PiCTqaXpZZMJFxc\n", + "SWZT5OhhiEJvnWIF0uEoQ0NX0m43kBhmqbLKYO8QhVwf5+ZKOG4crp9ApwIY5FmiSQ8tEnikiWjS\n", + "ponKEAY1esiQZgtwKNPDKjmSdAip0iYig4mLQx2FYRLksJGRGUTuJs1IJPDYRojNGjoWKj451glJ\n", + "kuQSIWkUBCYddFrItHGYwsKS0mQ1g7q3jh9m8YOQTXsCe8nn6h27KW9s8ej8PImFp/HlKUKlQHYy\n", + "T6EwQ6fT4N/9u89y9dV3QFtnIDfL88+vU602uP76axgsFLiwtES1Wv25WuZvVpw4EWd8vOtV585f\n", + "frzgqOmOdfq1xs8kI5Ik/TlwG6BIkvR94FZgP/AnkiRdI4T4Lz/nsevEUgiIxzK8pB/wp3/6py9+\n", + "rWkJLOsnbb2SJKHrfczPLzI0NMRzz11gx46bWF19gHZ7C8vqIZvtY2VljmzW5777buPmm99Ko9FA\n", + "URRKpRL//t//OXNzLUqlDqY5hQhanDx4AUOHM6eeYOi62ynk01SqDZIJk0mlyUIYUot2IzNAJGQC\n", + "fFrRIm3vDDZgELKLiAwKNQQ5IkZxuYhKDxoSy/ho6PgEtFGREfTgoSMhAwk2qbOARMgIUEehhp6Y\n", + "IhIhmtYL9BIEK3jeIkHQAkYIgiaaZiJEBt8PEaKCJHkoikwUZUgkMiwsLFMo3Ey7Pcry8hqrq88h\n", + "Sf0MDLyDwcEBlpef5+zZw0xN7eMDH/j/2XvTKMnO+szz99499siIjIys3LNKtVdpA0lICAFaMDaY\n", + "AZsGY9y4jX3UH9z2Od3MdI/tM32m50N/mub0abeNZ3w4gz09TTdgMwYZkDCSEKBdVVpqU1VlZeWe\n", + "sa837n7f+XBDAlkCZIFUYszzpSojbka8ed/MuM/9/5//83ycQiG5K67XN/jqV7/JbbfdyFe+cj/t\n", + "tgtEHDu2yPvf/57Xva88MTHB29/+Uo3D9PQ0g8GAwWCApmmYpskvf/zj/MFv/zbz3R6oKv1ghFRT\n", + "7Iz6lJFUFRVD6KQ1jSCGldjF1yW7+PiEKLpGOvBRx061FgYd+pg4FCiRx0OisYZHh2lSzAAaA3YI\n", + "OEPyaxyhomORQ7CQTGywBcwyREdFJYWGRMXGwmEOQYBLlr2ss0UGxtlEIwQhNtNIuoywGSEpkmGS\n", + "mJARfVz6tMMYxDLZXBGpBFz0LrG5s4q2u4av6hidHqfP/c/sO/YO9u//fv7MyspzfOc7D3PnnS8N\n", + "TFNVlUqlxMWLu3ie86JXTxj6hKHNtdcee133+4dhbm6Oj3/8wy97vN1uI2ybmcUDeJs7nOm4WHIa\n", + "kxSWAm6whT/0EMYewthmbfUJejuXGfWHZMxlnjz/HKMwjxlVCZFIdJr0SbGPDDp1LhFikGGIjmSb\n", + "mJh9NGnh0aI+rlLtwWMZHZshaQzKdKnRJcMs22SpUMLCYJMRkgwqAocBISoQkaZExIgOETEuDuVx\n", + "0tQ0babGYmebCgZC7BLKJnbQJpYajiwghIIvFPLWDLFS5NLOJnOVBS7tbhOgcnRpgfmZeSzD4OTD\n", + "jzA5v0C/nyWVKiAUBd8LUdU8ly7tsP+qDsWJCV5djvM/LvzZn8Fv/RZcaR+448f//2ML/2oqI/8D\n", + "cDXJMEcNmJNS9oQQ/zvwGPBaycgjwD8HvgjcAfxff/+AHyQj9977LR55pPn3DyGOA0xTJwgCpFTQ\n", + "NJ2bbnoHDz/8IO32LmDS653l4MG7uPHGJHo2n88TBAEXLlygUtlPKiXZ3JQ4/SGm7aOPPBYrU3Qz\n", + "s6ycvY/ZvbcQCJe2fY6S6uEHZTTmAJ0hIRlCdAIyKGNnxySRVxJRRiFG0BtPS0gsyhSwgB4hXQxc\n", + "NrEJCLEQRPh08fCRzJPk6SqErFJKWXQ66wjRJgjssZdGC5CYZpVMxsJ1O4xGgkQCGyNlijguoqp9\n", + "4ljiuja+b9BsRnQ6HVz3KuLYY2PjMtXqNNdf/0ucODEik1lEVb8vUKxU5njmmXt4/vltpqauZWFh\n", + "gjiOOXduhW73S9x99yd+7GTGTxOu63LfPfew8vTTWELgaRo33H47t9x6K9ffcguDp09heBbDrS3i\n", + "yGA9UjGZ4XxsIfQh+zKS/ZpOY9jGLxdJaxqqqoDrkpOSKPQJgR4DirSIsMgyxMJHQ+ESEhuLEIjY\n", + "ZIIOBVxifFpkcdlDRAqNLho5TFwmcOhRZQT0KJJ48CZS1IgMJhnWaHEN2jjdRpJB0sMgR4SBwwoa\n", + "PiU8ekjkePYjg84ecuZBwriBaWjk/RSzmkU2DCkIlV27TdsoE6yd5ukT93Pt9bcDsGfPfh555MmX\n", + "kZEbbzzGX//1Sd72tqt54onnsG0tiTkIn+eTn/zUFdMQrK2tcerkSex+n8UDBzh85Aj5fB5VVTEt\n", + "i2Ixx9H0DDu799IOu1ikiKSDIg022iYd4VJNu6jxLpW0QTBUSWkG9khBiZYwOMsMI0wS348umyhc\n", + "heAAa1wmQx6THn0kGg4lNEwcXHYI8cmRZoiPQoY0MVksNEJqxMTswcFGJeYF0/kIOZ6v03CJkGMv\n", + "Vp8UGhoGNgU8/HEFDfJMEaJqBmGYYUSNJUWwGQTkAU0IPAlbzTMIfS+5Xpdes0MhU8DXRsfZCXkA\n", + "ACAASURBVFx94BCalgive+0WKyvrWFYB13XZadnEnYtMGlm6ToenHn+cg9ddR2Fm5udVkR9As5no\n", + "Rc6evdIrSSoj//7fX+lV/HTwasiIL6UMgVAIsSKl7AFIKR0hRPxa31hKeVII4QohHiJp+fxI8eqx\n", + "Y4f4+tf/kn4/IR2VSplcLkMc1zl8+E5yuRyVSoZ+v0WhMMmdd36AZnOLTqdGsXiMT37y4y9eLJ9+\n", + "+hnuuefbPPnkCr2eJAi66PoBnNY2OTNFGEIYhGQyBQ4Vp9AnepT3T+L2YloDH5cMJiCIgRiLXRaI\n", + "yCG4ajxuu0ySyBuPw8ZzSC4RkSKHjYpDzACJiyDAQbCDQ0xIlsSsOkOiB7kEdBEix3CYIo5XCENJ\n", + "4nIRAzNAiOc9g6LsxfczKEqXODZI9Pc6Um4TxwOiKPEOdZwmcTxBt9skDA+jKB5x7LO2ViOOYxQl\n", + "RxCEOI7zkorH1tY2hw/fTi6XfDApisLMzH7W1h5jfX2dpaWl1/rr8A/G17/yFfrPPsutc3MoioIX\n", + "BJy45x7SmQzX3Hwzp2o11i/3CLNTrA/6IJbQpIYuBFpcYtXpohl1hkTEmsZ52yaIIlxvl9V4wGhs\n", + "HG7QpURIDp9JppBo5PDZh0aTIQF9JukwyQSCHaBCDpUOdZocI8AgyzYGKXLoBAxJk6eFi88iiQC5\n", + "iSDDLm2qxONUYMEIgxImKWBrbAeeRsFhF9iHxCJEAjVCVmkPAyQuuX6HRV0gY4W5dI7qxARVx+ZR\n", + "z2FP6ghnH7uPo8dvRdcNVFUbE3n5kvHc66+/josX1zh1aoWjR/fQ7bZQFIe77/4jjh9/41s0AI89\n", + "+iiPfeUrzJomnVqNhz73Odqaxm3vfS93/PIvM7m8jNJs8eiDz1CMdXKqQTPsYZMnqx4gUq1xtXCW\n", + "jc3zaKbLqOfQD7bxZZYUNWaBNAoSnRQWKRx22RxrO9JoZPAYMUJlPzoVJnAZYCEADQ2VgCwCFZUI\n", + "h4gQSYg69oUR+EgKqLhs4TOLhkWRgDYODjYZrkanTQkDkxJDdilhA1u0GeFi4IQe+rjZ1xCCORlj\n", + "otJHpTSmSFtxiCdVijkFvB473Sb3PvkkC1NzLO+poAuBO+rRaF7m298cMKmVsNND9NADJeD8pUs0\n", + "ymU+9Tu/c0X2+82Kz3wGfuVX3hzOp4cOwaVL4HnwBppkvy54NWTEE0KkpZQj4EXFmhCiSHI1fM14\n", + "pXHeH4ZarU6nU2NlZQUhykSRzZ49If/6X3+SqakpAD7wgTv47Gf/htFonlyuhBCCXC7kE5/48ItE\n", + "ZG1tjS984UGmp69jaiozfu1nOXPmfqpqlY4uCIIBphmRm1CIA4+nnn6aBUVhsl4nDALS2GNj7xQh\n", + "IRZ9DHxyhGhj++4KyV2PMVbTu4CGpMMIkzxDXEZYKAzRKTCFyjYNQsokXqt5En/IaWAdKQW+v04y\n", + "7DtLsnUvhCEkWZ+Oszs+vkOSvDHDC6kqcVwmCBpYVh7HaaOqIapaQMqAOLbHDpZZut0huu7g+31M\n", + "8/uVkXp9jVTKpFSq4nke29s79Ps2hUKWMDTp9Xr/8F+A14hut8vaM89w68LCixdQU9c5Mj3NYw88\n", + "wMfvvpvVc+fYffBRIi1NS6kw1Ay00COlmWiKgilKXHR2GZgK1xcKXN7ZoRKE+FKlhUaagCoxGgVc\n", + "ulSJGDEkS5EeQ3xGqDTwUMmTRZAIhyFAR6EINOkhmCAmRmWIwRQTCDpsopPDB5KoPYkkIqKBjmRA\n", + "YZxbMkAhjU5AhM6ANAEuJss4GDCe1YEZJA6C/ePXeoQ4EPh00SIDRVEwVB3dabFba9KhzokTD3PD\n", + "DbdRr69z/Pj+l/mEaJrGxz72q6ytrbGxsUkqdZiDBw+8JEjyjcRwOOSRr32NG2dnOfvcc2w89RRz\n", + "UmLGMbtPPcXfNhrc8qEP8e2tLerBg0Siy1AVrEUGoZjHESaaopKzCphmm4bTY7XfIq24WHTxmSNF\n", + "D4MMIR4CB0lEliwqQ0bYFAjp08VGI4NKmiIeQ2JiYAoDh5g2gioxLt5Y8rqOjkMFlwYeHhKdAxSo\n", + "s4U39hWJCVDYImYKB4s8KiV8fCCiiE2HKgYhHhopPGwCtcVbp/eyNayjuBE1X0Wo84hIIYeBEdfw\n", + "gwyrjV1SSpm9pWOEeshWq0e90wHFZoCNohjYLYesaWGl5nDyAVEY8bYbjuOVSky/Ga66bxK4LvzJ\n", + "n8C3fhK15E8RpgnLy3DuHPyI7NGfCbwaMvJOKaULIKX8QfKhAb/5uqzq76Hf7/PlLz/IDTf8E669\n", + "1qfV2gbAtmuk09/PnVleXuZ3f/ejPPLIU2xtrXLs2BQ33/yRl5SUH374KTKZJSwrw/z8DGtrz+E4\n", + "aRQlYhB1KFp5iHVq3R0mgxornS713oCAmChIxm2ztBmwwoh5JAoSF4UuWSIiBEWSCRgNEEh8EtWH\n", + "SkyPy+g4xOQp42MRMmIGly1ypAgBjy2SlApJ0oaxx1/nSELldZJhX5VEerOHJFprc/w99fG7O0AJ\n", + "WEBRBIoCQdAik9EJgnVUVSMMzyJEEUVZJo5DXLdDtaowMxPS7V5mNMrh+30KBZe77rqFU6fWuXCh\n", + "iecZ6HqK1dUtHOckv/Zr171Ou/9yDAYDUorysgtoIZNhsLZGNpvln/3u73J6tcbzp9ZQ1mPKcRbR\n", + "3UWNY6IwRDEMbKEzoUT01tY4EkmCKCaQE5SJaWJjMY0/vlRNE6DRoY9HSJaQEiYODo0xEUkh0DAo\n", + "AhEhiS14wJCYDgVCFNqk8DAwialhUwNyaIBFA5MOIwyGqASoKGTHQ6VDIItBHhdvnIyioRIDOjFt\n", + "YiZRcVC0KlE4TYcNimg0wxEZ18EeujiKIB7V6AvJffc9xJkzT3HXXddyxx2vfOcrhGBpaekNrXj9\n", + "MGxubpKPY4b9Pk8++CB7NY2MaYLv8/SJE/zC1BTnTpzg+tveyQOPr3G6+y1mNRPTDvADlVgq+HGP\n", + "SmGaQsFiNdokRURGCOI4YsQKUECQR5JH0kdQQ+CgomIQ4BGQoU+AgTLOLQrpAwYClTQT1BiQQ8FA\n", + "IaBPH50+y0g0VDRiLDwa9DFI0UNFYxIfFRUHE0EKixgVSW+c3J2E5AkC+oywURiRZUDZEuiWxWSU\n", + "pmqlGHRs/NAhqdC4yLiFiBdxA42rqhWyms7U/AJhaHP68gU80eQ3/tm/ZXd3jce++TeEVKm3O1y1\n", + "ZPDrH/glitksD21vX9mNf5Phv/wXuP56OPojxy3eWFx3HZw48Y+AjLxARF7h8SZJxtTrjtXVVeJ4\n", + "AsOwMAyLTCbRvXY6E5w4cfYlZeM9e/bwK7/y/h/2UjSbXdLpxMRraqrCzEyOixc3yOePEfvP0nEe\n", + "Y6FSIRVH+IOAdqSTNdKURx6ZSCdNyBxDHmMdnyE+2jhafDh+B0mBpKbRB0boSNK4pOgTY2KRwyQY\n", + "d4UnSdF9wTOAkBCNhFCskRCQNIluRIxfsQe0EOIFAlJCyhcs0g6Mj3GAHELkxtM2Q0wzh2FIguD8\n", + "OOgv6T+bpo6ULqPR04ShII6H3HTT2/nAB34RXTcYDEZUq/s4fPgQ3W6XL3zhjwjDI0xOzhLHEb1e\n", + "h3y+yNNPn+P61zGX5AdRKpUYCUEYRWg/oCBr9npMzc0hhMCyLH71w+/j/2z9DT27jtPTWFg+Srvb\n", + "IAwHmDnBZEOh7EvywIxpsSY11EAnxKaI4CIxKiUc8lxkhGCHHCoWZRI7fxcPhwFNpsigM0QjJkan\n", + "y4gIB4N1plgjTY6QmKT9FuDio7FECoHKNgcZchGVNiEWNbLkCTCp0aFPCosFHLYJ8QnpopEhZIRg\n", + "hI5JhINEgdghQqfHkFk04sjmcquOrWh4ah7LLJGemCE3eS2+v0kqZVIsFt+QfftJoKoqoZScefZZ\n", + "8nHMxHiKy5SSMtBYWSEyTS5sNen2CpQXP8T5C9/BC4pIKujaFBg6oWywu9vCUK+iGteZkioKBXQu\n", + "0qSOT4DBNBJnPM5tAypp1sigkELisYtDFo9tDASC/PimY0CfEjUqGNSI6KOwZzz/ItGYoY8c++6e\n", + "4jpi6mgoFOkhGAIqHVwUXHLYFAALny16pBmQAYooDNCx0Z0eF2vr7JkqEdgRFiDxkGqAFBFlZQ8o\n", + "0FcLVCtVunFAF5VMfpqjN8xRb16gWp2nVJqis/osC6qGkFnK+YByPs96rcbyzwPyXkQcw6c/DX/8\n", + "x1d6JS/FjTfC448ngtqfZbyp7eBfQBzHwMvtpoVQxs+9euzdO8vjj9fJZPIIIThwYB8bGz06nRUW\n", + "F29HlSP89gbrq9vU+zaRB/uCAXswCDCJ8Jkm4q0MeAoPlzRFYtZRGRKRI6lXXABMdEwqCFS2kKjM\n", + "EBHTweYwmXFCZ4xghIvDiAIRMQn5uEBCRKpoOKjkCMgT4wCXkLJCEp+XaAaScv0Lfq0pIEJKgCcR\n", + "IosQk3jeBQxjABQxjCG2PcA0lykUMszMBAhRR4gM7XaWe+45Q7EY8pu/+SHm5+cByGQyLC3NUqv1\n", + "2Nx8ACEk+/fv5fjxX+HSpSewbfsNGfXNZDJc/fa3c+KBBzg6M0PGsmj1+5xtt3nfeMZtdXWVe7/0\n", + "RTK158l1W+w0FIRWYmF2nsnpRcLgMspA5flRiB0q2H6AKcBSFJwYOqj4zJKjShoXFx2BhUuDSUJq\n", + "2NhMo2CzPR7DTezsajQxaTOByQ4l2rRIoVAgRYkIhQYxNgdRx+RFJcm2sUkxjURDocOIEUOGTBIz\n", + "SYo+Nml89qDTRSOFjo6LRKGHgo1PiiynyWu7pGK4KPs0owg3shkoaTQlTWFqiePXfABdT9HpZGg0\n", + "otes9/n7OpPXE4uLi7ipFDs7O6iGkUx4SMmG57E4P4/vOAwGA0ZKGU3LY7sdQn0RxB58d5so6jJX\n", + "OUQYdun3R1iaR1GYyCgCVceIKhxnhadpUSUkg8IAQUSKOcooOIRY46pE8nnUIkeRYGx/1qWOicsi\n", + "UMJlRIYsEYvjsd2IIQEOWWCKOgWeZIhFkz4+DiV0DCQNAkJgmYAc0EMSEnKYHrvkiNGZwCamTI9+\n", + "5GEOBmw4HrEf4COI1AnqUsEIU+haDxmGXNze4cb33M6NY9fd06dPYjtbAOi6ydI1t7F78gEmhSCM\n", + "Y1Z2dtgBfu2OO96Q/f1ZwNe/nrRFbr/9Sq/kpbjpJviLv7jSq/jJ8TNBRpIPygcJAh9d/37CaL1+\n", + "kYWFCvfddz/T05McPHjwxwbpve1tb+Wpp/4fGg2LcnkGyzLY3X0aUHHdKUDS9mJqnoNlSqTfJaMo\n", + "xFFEhBwXZ5PL/hQ+l7DQyJNFp02XHUbjAHG4TIksRRwUXCZJkcIkYESLPlkmMBniUqeFjwUcJhkN\n", + "fYgXtABpXEwmEBiESGwyRMwAJ0jaNhMk2pBpkupIlRfyP2ESVV1ACI04rpNOa5TLBzGMI7iuwsKC\n", + "Qq12nlbrGRqNENNc4ODBG6nXdXq9Da655jo+//mv8qlP/fMXXW49L2A0KmCaGUDQaMQMBvZPZ6P/\n", + "AXj3XXeRzuV46sEH8ep1itUqv/Rbv8X+/fs5d+4c/8v/+G+pDiOm0wsU57PMT7c5u7YBqsehhaNU\n", + "c8t85pnH2IjmmYgy+EJlENWQcQcdgxoaGiVUlHEiiUUdFYU0PTQ8coRESNL4eKwzSYcmMT4CCWgE\n", + "OGxRRZKjj4GGR0R5bN+fJeQRfDyK+NSZJINFGROVBlkURoRASJ0RDjEKFXQKiS+FqBFJBUGAYIBg\n", + "CZMNFuIek2pMysxCNGKYmaSHRteYJ1e6g0g1AA0pY4SIMYwitv0P27/z58/zzW9+j+3tJuVygXe/\n", + "+0auvfaa15WYGIbBL3/84/zh/feTVRT6rRaYJtlikblCgb/b2OCqmUV0Zw7fP0kU6ZhWCU1bQBtJ\n", + "4riGoqzhedvk8wVKZgWl0UC1HaQQiChpiQzIYBNjEuOiMIOgMA6k7NPCpY/CJCZLqBjU2WGEhz/O\n", + "9lUYElDDoM40Jg18IqZQUDHGpmkObTJchUaaBjso9FkiJmSAN17FiB1CGsToOMwS4aIzT0TECIOQ\n", + "Hpdjk2tRuOi6BMVFPF0hcBzsUCGIBAWrxrSl0HVt/FyeoRsTx5IgcNH1LsvLRRxnSCqVZWn5GFYq\n", + "xzOP/r+k56bIXncdH7/lFiYnJ1+3Pf1Zw3/4D/CpT8EbxL9fNa69NtGMOA6kUj/++DcrfibIyMTE\n", + "BL/4izfxta89gWHsQdcN6vXz7OxcQNdvxLJUfP8SpdLDfPKTH/2RY2jlcpm77/4I9933EOfPfxvb\n", + "7jM7qwJ70LQYXU/jOh6+d4mJ7AJhv8tOlNzVKMQwdgToA/WxA+oOAzRMMlTIM6RDb+yqatBjGo0c\n", + "aVIYRAgcdHr4dOmioyOJMcZJGC/oQSSMvSgssiTVDh+FGBOBQw75YluoT2LTIkiErzV48bnLCGGg\n", + "qhZCjLAsl8XF9zA5eYDV1TOoap9sNkUYziDEEpXKIZrNBq3WDuCxtfVXHD26l/X1dZaXlxkOh2xt\n", + "7aAo01QqSbXE80Z861v38+EPH35DHVoVReHmW27hbTffTBAEGEZCUm3b5nOf+zKGb3LV3AIAsaxi\n", + "tC6z9+0z3PfUSR47rdMY9LkUVikZJTqezyiMUON5HDRMbNooGOOsXdAZYQAxKurY1G6SpMGjo7BL\n", + "TEifJVSy+FwgIYNvIYeCZAeDIgEuISqSNjE1BF0MHLJMsYHPNCkgNXZXHZAC9qDg0EMZy1gjPBw0\n", + "CnIClRiFCIUODs9TGAfwKbEkb2iktSq+muIpd4gfCjqdNsXiHJ1OF1V12beviqJ0XhSAvxKazSZR\n", + "FDE5OYmqqpw7d47Pfe4blMuHWVy8muGwy3//79/FdV1uvvltr+OOJ5qwT/yrf8X3vvAF+t0uwWCA\n", + "nkrxnUaD6g03cNPbbuSLX3yaUmmOSiXNE098AcfpoSiCfF5h//4Ss7N7qdVa4Gp0ADvaJXIdarTY\n", + "ZgqFJVQmEQgEK+zSxGFAmpgRLnmKxOOap6bq5NV9rPm7xMhxE2cHCDFIY6GTZhcfhReca5Kh/4gs\n", + "s+gIdAYItjBRiOmSR8fBokCFmDQOMTYhMElEk5AASZ6ABSxaFGSKlNth7oZ34gwgaO/Q3jmLFcdE\n", + "YkRWz1EtV5ma17l48WGmplwmJ1P8+q/fQSaT5r/+168ThkWE0InjNh/75K/yoQ+9/yURGz9Hosm4\n", + "cAE++tErvZKXw7LgyBE4eRJ+TNzUmxo/E2QE4NZbb2FpaYHnnjuL43hIKSiX38v09OKLx+zurvK1\n", + "r33rFU2RfhDT09N84hMfIY5j/uqvvsrk5FvQNJ21tYsMh3VmqirpaJ7NnW1Uv8Ucgjl0eoxokVCD\n", + "JEE3Mx7gm6ZLZ2z5PaKCxxzwGF1CfHR0QkJcHCI2mWVANPZlHDGFzwSSLBEHSLwntoAnx7m+OcR4\n", + "kDhigEYdDYMACRwk0ZA0SSoqDRJNwqGxIVyTuTkbw5hjcnKOweBZDCODqurMzCwzGDxNNns1YbiC\n", + "5+WRUmE4hCAImJk5xGDwNGfP1nnwwe+yvLzMyZPPcfTo27l4cZVOx0HTcgTBgDhusH//e37qe/5q\n", + "kPyc36+Wra6u4vtZdO37jylCoKppLp0+R2HyEJVjt7HzyNeZtFL0my0iYVGTIESKSMok4Eyfxwlc\n", + "QpIRbgsdAxuNDiNmCCkBfVT6aBwlYJeY0xhMoLIDzBDRJqaPzgCPDAEpNEKgj0cPjQ4+OXaI0YkY\n", + "0cVFYJFHAiEePTpMo2JRZJchOmlGIqQpDQwmEdRRmCMSQ4qKwYTpMF80mCgW2Nz1cAIHV1XYu/da\n", + "Vlaeo15vkM3OcfXVe0mnHd761quoVCovO6+NRoMvfelv2drqI4RKNgsf/OCdfP3rD1GpHHtxvDub\n", + "LWIY1/HNbz7OW95y/Uv24vXA7XfdRa/VonX+PJrr0g8CKtUqH7v7bqSUfP7z9xJFFVx3i3R6Hkgj\n", + "pUEqlef8+VPMzc3zznfu48kntnDbaWptSdNtEaCiUUIiERhYZFE5Tsh5QoZAl2Ac5RAgaOGjyiJK\n", + "wDhpqofJGjpNLEq4DKkTMgk4NHHQcdAJqaBzFEUEhNLDosYkAWV6NMf2YgEBPm0UzHEgRIKYLhFT\n", + "GOjo5NGUNIqh0xkotC72qFYXGbYeZ07qTJgWfjhi5LToZasYxiHgJIrS4v3v/zXa7S47O3U++MF3\n", + "EkURvh8wP38bc2PN1c/xUnz60/B7vwe6fqVX8sq46SZ47LGfk5E3DHNzc8zNzdHv9zlx4iLz8wsv\n", + "eX5qapGzZ7+D4zikXkW9Kooidnfr2HaWyckqpgqDwS52d5fIl6hynTJDyqrOIPboyvjFy38dgzwZ\n", + "VulTx2TBmGehXKYzPMOct8l530fHIWQFnwE+Gio+WYZIFnFoIQmooxJhkLRaRiQjvUlfGS6N+8ez\n", + "xEhU1knRoM8kCR3aIWnNTJBURK4hmbaWgEEcNxgOPVKpIY1GnV6vRbN5HwcP/gKGoRMEPhMTFcLw\n", + "NOVykVptGyHyaJokilyE0CgWF3n++Rq9Xo9ud0i5PMPCwmG2t1fp93vk87PAnpe0z64koijCsrIo\n", + "+RLd0YBiOhlF3d3dYHV7wKA6Tf2BezFcm4xSQs1UcZwBAZIeeaSIEELBsg7jK88QBzYZUULIAWq8\n", + "waTicSluA+skY7QzxKTQUDFoopMmQ4oQwZAKAS4qc4S4aBhAlohtVDrEWJQQlCig4RLTwGGXiDIW\n", + "IQEWAT4FighsCkpMX0boMo2KgUMLBRWFQwjZpxt9F0/NEk6keXpzh75tMhIWbb3IcOMs8/PL1Gqn\n", + "2LevwKFDgre//RpuuunGl51D3/f53Oe+hO/PsLCQiMNtu8fnPncPjjPkyJGXxswbhkUQaPR6vVck\n", + "Nj9NmKbJRz/xCTY2Nmg0GmQyGfbt24c+vkp89KN38kd/9J9oNCTp9FvQ9Q6WpREEXY4dO87sbIZ/\n", + "8S9+hz/90/+Dzzz+DdpOFzPOEoklbFlEEiOp440nZCQGkKZNnZFSZBAPGDFBhI+ITWJUgvG0m0aB\n", + "CYqASwXJCFhDx0IhpEWfMjHvQFUFbrSNxWX24qOiUSSHxYgBPn06RETY+EiK41dqwliRJhmiM0KX\n", + "EdueR0OaVLUqKXXIzOQevM6I9qiFqkpmZ2/BUFWGwyHdbpb77nue++//X9m79xqOHj1CFF3k2LFJ\n", + "PvaxD/+8GvJDsLUFX/sa/Of/fKVX8sNx443wjW9c6VX8ZPiZIiMvQEoJiJcx+ORrMX7+R+P06TN8\n", + "+ct/x/p6nZMn1zGcJlelDezmEN122eldQMYjlkxBVgZ4AvZESY1ClRIHsIlIIdBVlx1K2K0uui6R\n", + "hQKtrk8lvcRObw04T5Y9TJJGMsEAHYUJHFbGeTQWCQmxSS5yOpAmIqCES8zz6GgYRNRIkQhbMySk\n", + "I0XiKaIBD5MYpU0jxBaGoeM4Gq6rEIbnMYwsntfk29/+c0qlCY4fP0qrtY4QNt3uLt2uh6r66LqP\n", + "bffJ5SJuuOFqpGzQaDS46qp5zpw5Tak0zfLykRfP5dra48zNzfxEe/rTwvz8PEI8wFVX38bzj/4t\n", + "5U4NA8HTl57HLRxgas9xsrvPoesZnry8jikrKCJLBsFQqolLrvQIwzNABkVvE9BEo4khfRrkkb6K\n", + "qoyQZInjFpI0BiME/tgSPk3ALrCLj8THxKKMzgiVLVQkOgKDAVNIJGryXsyRYZsNtrFI0yUmi44q\n", + "MiiKTlXPkY1adII6Ayx85omZIqYBSBoYbHg9jkwu0F/1sEWKHQQuB+g3BzQaj5PJlNjYaPK+9xW4\n", + "+ea3veJd8MrKCt2uxuLi95N9M5kChjHLxsZ3XmIPDxDHEeCRTqdf591NIIRgYWGBhYWX3ozUajVW\n", + "VjapVkusra1imk1mZuaRMqRSsXjXu25hZ+dhLly4wFf/+htkpIpROsigFdDz1LHfbQ6fxPRLxCkQ\n", + "MZ7IEzCPZJk1dtAJMDAYcQaP5DMnRYlJRugkLj8tAlIEGPTIkyaFyiQ2O/wtw+g6OjRYYBMNFx+D\n", + "OgKBho5KFo0JDDo06LOBS56YuXHGc2KXGNDHw+UxX2WERbP5JH7H59pMgT2zM6yu1jBTBXL5aZrN\n", + "VVZWnmd29ij9vodhzDMaTXDPPV/HdUd8/vNt7r33Af7gD36fI0eOvNIp/0eNP/kT+I3fgDfz0NmN\n", + "N8K/+3dXehU/GX4myUihUGBmpkC7vUup9H1DnmZzi337pn/oh2Icx5w6dYqH7r2Xb33zEeYP3MaR\n", + "I3eyduHPEbttLl92MIwCUTBiWityzu7iqJKyZbIVhGQRxHFMW0o6oowuFhjFKkHsowpBU8mTM7uk\n", + "81XmRRFCmyljgrN+RIoy4Vj+aiDGnp4TGPRwaZBUQwKEmEfKPLCFy14alMmwjUvMCB+fm0iIywSJ\n", + "O2uLRDOSIskeXEeICEVRCcPsOKNmFSigKPMIsYiuR9j2JufPP4Nh5JidvY1ebwfbjnCcNq67yvLy\n", + "LO9730dIpXS++93H+cxntpib20MQbLO+rlGtLhHHEbXaRfbvL7C8vPx6bvmrRqlU4s47r+O++55h\n", + "7vg7aDc3efbMIwyq+1hYfBeKUNAFTGYr5MQ52t6IdGqZKO5DvINgLwBhOCAMLCAkEA3y2Rxaegln\n", + "NIMiDVKpZWx7k2QEu4tFk0l8wKSNjsEMgoAhJtDDJcJEI880IRE2DQQWfXxUGqQYopHCRMEgTZsC\n", + "HlVS1JGykIhRoxUUcuRJs/vi3FabpIqmEitltvSY//bEc8iwiiemcMQyvhOhKCaKYlMszjM19S7+\n", + "7M++ydLSPO94xztedg57vT5CvPxvKJudYG6uytbWaRYXr0VVNeI4ZmPjDG996/4rkur8Amzb5rOf\n", + "/SKwyHve89t0u/836+sKZ848M9Y7CU6depZcrs+//Jf/GxdP2QhZxg8VRpFNSqkiZEg4HucO4gGG\n", + "aaMbcwSBA8EARVyFHxv41PEpEDNJUpEso+ASo9DAIWYRgY6gjskImzpFCqTxMRmwHl/c4AAAIABJ\n", + "REFUwvdwMIgxcSiNc4kUQMcmYhNnnEFTxKOMRoSkiakO8SIdD0Goqqip2xgOL6KgISODYeSyPTpH\n", + "5G8xM5MjjiNsu0Zt2GZ++QaKRYPBoEIURVy8eJJOJ2R+/mYsC5588jx/+Id/zKc//T+xd+/eK7aP\n", + "bzbYNvz5n8Ojj17plfxoHDwI/X5SxZmdvdKreW24YmRECPGLwKeBppTy5Z+IPwYf/OB7+Oxnv8TG\n", + "RodUqoDjdEil+rzvfR/5od/zjXvu4fLDDxPsNjig5PBXn+OZxgbFlIlZSHGp2UKGCpPZMmlziXoc\n", + "8LyzieHr7J9c4HJnm5Hnc4EMM8oc3VjgY+LJadS4hSrXyKYPstPyuGZ+is0L9zMXDkljkQLyBIRo\n", + "OOhjSqKTYhKJJGCHGA0pOyQmZknmTMAsXZZJ9CA2iftqQFI9WSRpy/RI3DgT51YpV5BSJZNR0PVJ\n", + "hsMeun4NQTCgWLwKEKRSBwjDRzCMCCE2qVangBVarRZzc8e4+uq96Lrgy1/+b2SzVZaW7sTzRvj+\n", + "gKmpNsNhF01Tee97j3PTTTe8obk0Pw7vfvc7WVpa4MSJU9RqU6j6XsJTPisrJ1HVacqBTdkqUVZV\n", + "dNUhnXXQ1R5dr0zohwhZQoZrWKKAySFipYtGD9+NcEcBmpEnihpEkQOUkTxLRA9nHHxnMEWGIi1G\n", + "qKhozKCyRpkCMR36hCjsHxtqQZceIetUkKgUCRkhKZBGMsCizgaSNJIKCkN8PFymUZQ8cTyNrk8D\n", + "XVKpKRRli5Y9wDBuRdOmUYMARRkCKaRcIZ/PkckUSKUO8td/fd8rkpFKZRIpT77s8cGgyV13vQPP\n", + "C3jkkYeBNHE84tpr9/JLv3TX67yrPxqnTp3GtrMsLiYVOtNMo+su2ewBJibK5HIFnnzyW0i5iT1c\n", + "Jq9ohCgMbElEGssIMAKPQG4jZYOYEaqWJ5PJ0+uNgIgw7GBxkRQBaaaAmB4RQ5Tx37WPZAadKj49\n", + "dDQEJQIUbHqMMAjQxhNQFfp0KFFFwSFpw0zioGNTQqoGQnSSyR2xScbIMpsLWGs3GUbTqPoUrn2K\n", + "AlnK6hSx72KjUEPB7LeYnc1RKldx1QKGprK0dJxebx3fH2AYGYZDl1TqGoQwUZSAiYlF+v0RX/zi\n", + "3/Jv/s3vXcGdfHPhL/8Sbr0V9u270iv50VAUuO02+Pa34dd//Uqv5rXhSlZGHiERObwmY92ZmRl+\n", + "//d/k+eeO8XOTpPZ2f0cP37sh9pV12o1Lj76KDcvLfHoTotipkgqlUW2d6iPBsR+QKgUQNOTdobf\n", + "w8CjQY6zQcx6c5dBHKKrEIbTOAiisRH0hAjwRZpQmphaBl0r0HQCdCumgpE0X9yQLDohw7E9/IAI\n", + "m5AJYpZRySFwx2r704CLYZiE4WXieImEcCQW4QnpiMY/WZpE8JoBNki0JA5x3CKTqWIYS/R6bXTd\n", + "RUoXx9nBMEqYZgHPMygUFllaKnPw4HFU9Va2t1ucOXOe558/wUMPfZU43kc+X+Hv/u5hrr/+MFdd\n", + "dTP1+mP8wR/cjWVZvFkxNzfHU089y7lza3zvexdpt/OUSgeQssVad0g4eoS85ZBVdPxwiJuZoVKc\n", + "Z3e3jvTbWELFIoumGujaNH1vHY9ZFEUjjof4vkOyBxl0QibJowM+GhJvPK5dJk1nbOwdoSGxGaJQ\n", + "JI9JiI+PQGeKITZVhvRoEmJikTTqBgS0qAKT6KiE2MS4SGrIeBIhPBSliaIopNOzjEZtVNVAiAGF\n", + "wn46nSZCqCQxUqMXp6BMM0+zufWK5255eZnFxTTr62eYmdmPoqg0GpuYZpu3vvX9FAoFbrvtFjqd\n", + "Dvl8nkKh8MZs6o9ArdbGspJ1DIdDdL3K4mLA5uZZGg0d05xhdrbCyZO7HNh/lJ32ExT0LI1hnTgs\n", + "4sfbpIx5jIzLREmn2+0yNWXylre8g29963tsbY2AS0zTJERnxCoWM2TJMmIHjymGxJjkiImI8ZDE\n", + "+GgITOoI8hzGeDGRaoIePWqMKBOjkMLFZQuTkEksPQXYRNE2btTGd8GLNAK1wuz81RhGh96Kz5y1\n", + "lyCI8XybeS3FelRmI9oh3L1MxQK1YDG9dJhOZz0hU1adINiDlALXXWE0mkBRBLOzB4iiHBcvrr+h\n", + "/jFvZkiZ5ND8x/94pVfy6vDOd8KDD/6cjPyDIaXsAj/RL32hUODWW9/+qo7d3t6mKASKolCpTNBo\n", + "NkmlspTTec4Nu6w0L4Pr0I3T1NwNrMgHYZERe8GIcVICN44oVktsXGhixGAoKuk4hyosfCWgg4If\n", + "KQRBk9YgJh+q9HWFchSxxSYXySOZGHtUuJiUCTAwxSxSQkTiGxGyF8NYp1o9ys7OCeJ4jcTTNUkK\n", + "TizeAxKCkugFkhHfZAYjMTzLoGkzxHGDOK7heUXCsEwUtYmiTXz/MPm8jqaBpumUy4llvqal2Npa\n", + "4cKFbTStxKFDd2CaJkHg8dhjZ7j99huI4xStVovZN3E98Nvf/i4nTjQZDtPMzt6Bql6k1xtRqVzF\n", + "jbe8hZWL91GpDOjuDpDmASbUWba3t5BygBAtFG0ZU1NI6QI/8BAxqGpELpXDc0eosSDGY0AXAx2b\n", + "JRx8HEZoCCQFJB5ZFAR9Qpp0aSCRVEgjhUCXKRqExAg0pcj52MNCISJmhDNOBfZIsYyLhouJJioo\n", + "MkQRbRTNIgz7QBZNKxFFQ9JpDcPIEcc7OM7z40TWXWCApikvkpHhcJN3v/vAK547RVH4p//0n3D/\n", + "/Q/x+OMPE0WSw4cXec97fu1F4pHNZl8SonilsWfPJI8/fgpIBLiKYrJnzwF0HY4cmWL//mt56KGH\n", + "EEKlVK5SL+SIhz5lQ2fT38YPN9GMEUuL17NnzyE6naeZmdG4fPkShrGXfF5n2P0OQ0xUFlEQ2FzC\n", + "YIRFzIgUNuDSQcNDYNPEpISBQw+VCWx2ccbJNxIXyQTbZOgwQKGKi0fENOCjaSVMcxFd36DdXiSM\n", + "6rjCxTRNhEjB6CJlw0QKiAnJGRpZTSPtWeyKKlgTnN/UyXsh1epZFCXF4cNv5eqrF/nCF/6Cfl8j\n", + "lTpGtzvCstoEQYUoCqlUJn5ORMZ44gkYjeBd77rSK3l1eNe74E//9Eqv4rXjZ1Iz8lpgGAbB+P/z\n", + "C3OsXNqg12swiiOcbgNVS9FWMhj+BH7sscMuaXwimuSVJUxjAi0K2K13sdQBWVJkNVjzBgip4cgG\n", + "KSuNH0f48SqDnsFccZrTwxqOm5SCfTJEpIiIkWTHVZEm4CfTLdGQOAZDnwIi+v1phLgWIYZIGY7/\n", + "7ZK0awQJ8dgF9gL7SYjKeWCEEDsIUcayWkxNHaDRSBPHJqlUBcMI6XQe4xd+4Tbq9S0MI9HTtNtt\n", + "HnjgezSb50inj9Nutzh79nkOHTqAZVmoaoG1tQ0KBe9HTis1Go0X75qvRMhWFEU8/PCzzM7ewOnT\n", + "f0Mudz2ZzCS12nm2th4ln59lbj7LRz76fk6fXuWxx9Z4/vnvEQQKqtrFkDNEcYq+r2KoklB2qKQr\n", + "9BQXogbFUEMVGWxpY9Pk/2PvzaPtrM4zz9/+xjPPd56v5gmhWYySTGMM2GATz4HYjhM7jiupVUmq\n", + "q1fVqiyvrlq1vKp7pd1d1b0Sm7KrHMfGxlUQA0kIxgxGQgg0IwnpDrrzeOb5G3f/ca4Vy0AFbEAI\n", + "5/nrnO/c79x99j5n73e/+32eR6dnRR01jUDgkMUgj0cXVUoEmKcbF0MxyPlNXBw8aVJDUCOJRw1V\n", + "mEg6gAI6q2nJgBtIEiuE8n4EAXRiGKaO57chlDk0LY2i1EkmE6RSUYLBELlciHR6LbWaRy43jmHk\n", + "8DyLrq5VSCmZnj5JODzHJz/5+6/bh8FgkDvvvI3bb78V3/fRtHf3VLFp00aeeupFpqdHCIVS+H6T\n", + "UmmacLjJ8PBmVFVDVSWRCHhek4ENO5gbO0VANAg0cjhqmUz3TiKRNIXCCdatM9B1nx//+CC23YOm\n", + "Gfiik4ZMEkclRAyFNBYXV/x2HVQELlN4bKJV06VTJIeggo6BTTs2EXw0WlPvCFCggUYrsxlDAJIi\n", + "jUYZKes0GjaKkiCZ3IXjvEIsZmLbs3hWnX4dFuuzqL5JKhxAAgVPQ9MhE1qHjkLHwHamp5+is9MG\n", + "Zpmfz5PJdOP7GqpqEIl0EAxuYHz8KB0dko985J9fqSF81+Eb34DPf751BHI1YMsWWF6G+Xn4OTu2\n", + "qwZv+wwjhOgAHviFywtSyk+93f/757Fq1SqeDAYpVqskIhFuumk3Z86e55EXjqK6Lh19OwiGfBbn\n", + "S2i+JOKaZJlDRWHUWmQooFGr1Cm4FXQWyVIj62XwUGkwhyZtmo5Go7CAL21cR+HYUh1EO6pox1MW\n", + "cfw2ILyiwyjx0PAwacpRPCeCAGzpgF0BFnCcxIrvTBpFOY2UMRSlihBRPG+RVibEo3U0U6VVNxJH\n", + "CI1IpExPT4J8XmXPno8wMXGBqakxwMY0TcLhOKGQw6c/fROapnHu3E954YVThEIZduzYxvy8STTa\n", + "xcWLU8zORlm1aghdN5mdHWXXrk2kUqlX9bFt2zz00KOcOjWNokTx/Spr17bz8Y/f/Yao1m8VHMfB\n", + "tj103URVNfL5RWKxNnp7t6JpAk2rks/rHDtWx/MMarUZwmGTQGAL+fw8zfIMuD6uGyJbyxMiS8VP\n", + "Y8RsFHsWiKAoETx/CkmAOsFLgS64SMI0OQ7kqaPjouMSpB2DGDEmaGIRAlwURUXIJp6XpVXE3ItF\n", + "BoEOOCtCWSo6FXQEnmxQtRq4QiUcKaBpCtVqmXx+Ed+3aWtzSQZd7Oo5EskBursHgV6Wly8QCFTJ\n", + "5R7h+us38ru/+6f09va+Ru9dDkVR3lX1QK+Fubk5pqenwckzevIn5PMWhVqTUDzDLbd8FE3TyeXm\n", + "icfrbNu2hlzuDJWKxnJxhmJpASXSZNf2W5mfn2BhYRTTVDl0KAiEqVY1pJRI6WOYvdjNClUkQaor\n", + "YxTGZQoNi6C6GVetULdHaOU5JS4W/koeVKxkPUBZMRAwaW0mkrQynJ20RPZ8PM+hVluidQw7j+No\n", + "mKZPPJ7BNOvkK0WqjQUyepGcFaVUj1FVJBZNhjPrCIcS5BsVCoWLFIuSWi1EV1cPlUqe1auvQVWX\n", + "OH9+kmx2ClUVhEIVfvd3b2Pnzh2v0cO/fqhU4Ic/hLNnr3RL3jh+vm7kk5+80q1583jbgxEp5SJw\n", + "4Je59ytf+cqlx/v372f/r5AvCwQC3H3fffz1X/4lwXweHbA6Mnzgs7/J8ScOEQ9tZNSZwdCTzExf\n", + "RHGjKHTQrqrYUmWsOIIiLSLU6dd8kl4OT+bIoVMRUJcqBbkaxbsG2zmBqg/QtJqE9fVIfxnbX0bS\n", + "uyJrFKJFDF4GHFzquNKkVRNi0HLdjaxQlKsI0YUQEQKB7biujmE0qNdn8P0BWkFIlFbBawpNEwSD\n", + "MZLJXrq7JeVynXp9mp0713DbbbsolUo4jkuxOMYnPnEzBw4cQFEUJicnsW2X1avfx/LyDLOzx0mn\n", + "N2NZDaanDxOP16hUptm/f4B77rnzVf3reR5PPvk0J08WGRi44VKqd3T0HI899gQf/ehdv/TYvVmY\n", + "pkk6HeYnP/kJS0sN5uePYprDxOMhyuVzdHRcw6pVQySTvZw8WWBhwSAe1+jrG0aIdtzYAPn5F8Ad\n", + "QxENJAIUm7DSTgiVkObgyzpRFPIIPFIIOvFRYcVxqJW5SuGtuIm4GEz75wmKCo6MrIwXGP4UGnVU\n", + "BqlSwCNJixWloBHAJYRkApcC5grt1GUJoQgqFUkiFKIt5KEpRYqLk/Q7bdy4bSeT0xNcHDtCavsu\n", + "tm7fzu23f/o1NUWuZti2zQ9+8NecPTvPmRNjOIUZupJw1/uuJR4O85PzF3CcUebmxhke7uXeez/P\n", + "xMQUf/Z//L9MvPI8oapCuxnDDEeYOH+crsEbWVqymJ+fQ8oynjeN55lI2YllGahqHPQqVecEGg7g\n", + "0aCJQoj2cJ6CexREGkERSQ2V1Aoh38IliCCIJAg0UCijIJAkcelFoYnCMi6S1iYjRivbGadVO1Kk\n", + "2aySzQaJBFW6QlFWr9+AurBAZ73CUnkRKQQ97dvoTA6Qr5dRI2GWl5cJBjdjmlVUNU4k0suzz57D\n", + "NLvZuPEDNBo1ms08vj+ClK+WS/h1xfe/3zr2uNoyDO97H/z4x/8UjLwpCCF2AF8FNgsh/h74kJTS\n", + "+vm/+flg5K3AwMAAX/yX/5KJiQkcx6G3t5dcLsdzf/ssEV8ifVA0STCapmy3CJpJXUf3BaYdwVgJ\n", + "HlajEtFNZm2LBAq+hAKCiFfGUidRlF6QElXpo+lr+F51JQVfpCVu1qKAtiacOVrHLh6tiaew8jfB\n", + "ldcEUtbxfbDtRXzfxfdnUJQBpMwgJahqCt8PoCgFDCNAPN6BaWZZsybKhz70BY4eLTE9XWRqqogQ\n", + "ClCjtxeuv/76S7veWCy2ch4tyGS6yWReJpsdo6NjLbrus3p1jFRqNf/qX/2zyyicc3NzPPHEs5w7\n", + "N8GRIyfYtOl2fN+/JKDU07OWEycOcvvt74yJHrTqkExTMD19jra2XQQCKWZnz3Px4jyhkEZvbwKr\n", + "VuaHf/UQeCHcSpKp/BkajWcJBDYTTwxRK1cImxF6UwU2drQxurzAcjNGNr/IOjVA1SkiBAjp4hNB\n", + "4tGq42l5p7ayHBHEikG8TQ3JMHV5FlgNqMSYR6OOg0KMNlyK1PBoUXZDSCSGSGHJESQzVFFW/ocD\n", + "XhRI4boW8USIQnWJQSWCWmwgbY8NQxsZtAaZrM/xhS98nO7ud4cOzFuJZ555jnPnqoTDa8kvHMa3\n", + "TRZzgvPTL/K+7X3sGuxFX9/HPZ/6hySspmm0KxbxrnU0G2ESiTSNRhVrfoLlpVmWlwWNRgPT3Eiz\n", + "+TLQhu9b+L6NlB7ST+KTosR5VPrxCKEiafg2GzffQLmyzPx8mUoljUcXHnV8NBTqQAEfFxUBlFBR\n", + "CGJQx8cggUUMhRoCC5+tyBWfmtZckF0pno5QLR7nxq0x/uBT93BidJQz58/j5/P45TKerjFZyRHr\n", + "GMIIqoiajufVCIUCqCosLGQplUrE421I6RMOxwgGg+TzLzM2tkC5XCYWi12J4XxX4f774d/+2yvd\n", + "ijePO+6Ar361VXx7tcWVV7KA9SjwjvMBTdNk3bp1l57HYjE27NzMU397nOVclXpTo2Y1qYk6UeFh\n", + "yzBNmljoOAh68NB8SdETNEgSJUoQSR0dWwmDO4MjtmG7s/h+BolDK8BI0doNV2kVoras9Fqp2Sgt\n", + "RswWWpPPBK2ApERrUTuFlC5SltF1HzBRlE5UVcNxgijKDJrWi5RZEgkP1z1FR4fE8yzm5pY4cuQJ\n", + "TPNaEokBXLdBvV7Eslo1Ij8rQk0mk/T1JVlenqGtrZe9e9/Hyy8f4dCh76KqLqq6k7vu+shlAcXy\n", + "8jJf//qDGMYQPT03outLjI4WaTZPsmvXdoDWMYTQaTab71gwUq/XmZ+vcuedH2Zk5BxQZdu2VYRC\n", + "6zlz5hUyqRjPHDlKR3QATTXw6x52HRampxHGLL29B3CsLNFgCSEUzswtYYQkMc1n2VTIuVkCJhRs\n", + "HzwVGKM1vm20siJZWhTsJK2jljStbMckrfGOoZInShyXKBYNbIqo6LQC0E4kApcanizT+s600aoR\n", + "MoCW2JeKiutVmMhWUd0mw3oHll3m4HPPEY9mUFQNL1RkYmLiPReM+L7PoUOn6O7ezZEjz1IsqfSm\n", + "NxELC8q1GS7OCzx/lsFfUKqanJiAfJnurkFmZ6soikKjUSepJ5nNz1GtVlCUDWhaB6o6i+vGUdUE\n", + "vj+LImoI1cV1bRQ60EQnChbQTb4xR/X046hqBNuOo6rr8T2BpAwM4/MSPnkUkhiksakC82h0oFOh\n", + "CfgkViTUVFR83EuMuQZCKEi5hGUtY/jLxBI9HDpzFtfX2LB2I3f3dfHS3Bwj2SJP/2QUZ8nE9so4\n", + "Xoiu7n40rcnIyCzZrIEQHvX6ONPTLqlUHEUp0t7eh5QatVrt1z4YOX26pdfxgQ9c6Za8eaxeDeEw\n", + "nDzZMtC7mvDurkp7B6AoCvd9/rM88fT/imX0UG+qWAoo2iKqWEDTVYRiYNsNhnEwEei+YAmDMCFU\n", + "BI4ApILityMoIJUcQoaAJv/AdonQynyM0lpw2mhphCRp7YQNWtmSBi2dkQo/o45CH6oaADIEgzWa\n", + "zWl0PYCux/E8cN0sQpzFdYtYlk0mE+aGG36P7u4hxsdHsO0EfX0umrZAMBhkcPBmXNfmpZdOXsaI\n", + "+Y3fuINvfetBJieXcRzBK68cp7t7I/v23QJ4/PCHz1OrNdi3r6VNcfDgEYToJpPpQUpJIhHFdaPM\n", + "zuZYu7ZEPB6n0agSCkHiHZQvbDabgEEm00Mm8w+fz3FsLlw4zbnTJ9CVMJpqsLi4RKlSIGqkUZ0Q\n", + "BWucycmHCBhNNKWHoLqOUEgwUythu0Xibd1MLc/hNDU8GcS7pKDboDVmBq3xG0dhM1LMowlwfWgx\n", + "ngSQX7FN81tHQBg45FdsEF0kZ/mZA5JE0vqeWLTsAtKoajueV8IniOM7qLIT189StRoEiBJQU6iy\n", + "QcxI8Up2iscf/zHXX82mFa8B3/dxHA9V1Zmfn0c3e1ayfoBQSEY6OD91jI23XG6aqRsGvoBoJIIQ\n", + "OWzbolqrMVZYJOebeF4vQkRpNM7S+t3m+BmVPh3toVK7iEeupZGqmQTUDjxFxW2AbefRtDBS9iJE\n", + "EFWzcd1WXUnryGUEQQmfLArTBFBXvGciyJX6E48cYKFcyp4KoIaUBTxPRdOGCATbOTrW5IXRBdb3\n", + "9ZKM6Rw+e5yGkuMju3Zy82+28dcHT7GQrzGTc4jH+zHNAKbZSzqtsrg4QTLZg+u6wDLr119HrXaR\n", + "UIjXrAX7dcM3vgGf+xxcrer4d9zRkq//p2DkKsSZMxe49f2fAIKMjl7k6NHT5LNpDF8Sy5hML5ZJ\n", + "qTninmAWnTgKkgASQRXJrPQpE8NEBTRcfwrd2IvCFI4TRMpVtBYTjVYQMk9rYWqJyrcCFXXlsbFy\n", + "fZlW8NIEViPlGUzTwLICuG4D359jeLif4eGtTE5OMTExQjCokEh4tLXtYnq6QF/fGgwjQjK5nUpl\n", + "jg98YB+G0dIGKZWyFArFy/ohk8nwh3/424yOjvLYY3/Pxo272Lx596Ujl1gszRNPPM/27dcSjUa5\n", + "eHGORKJFDxVCsHnztRw69AKNRoBiMY/nNSiVRvnkJw+8o74X8XiccFhcskf/GZrNGjt3ruHIcyex\n", + "nDilskaxMo+q5OhNriFvW4QDOpFIgMXFV0DJkE6FUE2Xpdkl8hUBahlN60MNr6ZeyQIXEKKElG20\n", + "pPhtYAaBis80SIkUErhISzHXADwcahTRVn6ANSyaqGxBYRkPB9iMouhIWUaIbnz/JDCAEAFai5uN\n", + "xEBKE0VEcUSEvCzTQ4iAGcX1qtTsLFo8zUvPv4xlWZim+Y6NwdsNTdMYHu5mdnYGTdMIJdIUyxVC\n", + "AQNddZHSp+yrbPqFGXn16tUEejooZrP09XVw/Pg5srUaeTeIavZjKCZStuN5KXz/RXxfpZXRqlCu\n", + "X8Bzp4AaLlFM6WK7HpbXoEWvjqIoHkJIXLeMlB6qauD7daQMAR1IIigsEcUjgsoiy0i6MXFwxATI\n", + "Bh4+rSCoDVhAoYCPgiKixGJJIhGd2ZxLf9tq5vJlUrEQRbedanWJ4a4uAobBNatWUarVePLoCY4t\n", + "jlEqdZBIRNC0JTo6PFw3SiLRjW3PUi4vIuUUH/7w599T35FfBs0mfPe78NJLV7olvzzuuAP+/b+H\n", + "f/2vr3RL3hzec8GIlJIzZ87w4jPPUMrn6R0e5rr9+/+nmhiLi3lisU4CgSiNRpNm02V2dpaZiUUa\n", + "6gzRYIG14TjZgo5oapwlR4AGEKKMQY0OfDooUQTKeATBG8EMuEAU36/gupJWRiRNq2bAolWomqO1\n", + "s7ZXnhu00v4/Y8moKIqNlAHC4b34fgPfB98/y9xcEM8rUq3m6eszSaW2YFkL9PdvJ5+fYXZ2llgs\n", + "hqJMImWQarV4ST6/VFrkuuteLStomiabNm3isceeZf36LZcFEZqmAzHm5uZYt24dmUyc6enypQW/\n", + "o6Ofm2/WOXToEWxbob19DR/72AdZ9Q7LF6qqyu2338QDDzxFIrGGaDRFuZyjVBrhi1+8l7VD7Txw\n", + "/4PkCwvEDJNweAhF6NT9Zfr71qKqOqrqsmP7zWTnxrkwOodU16LoQRTlIprWoo6GokksqxshyjQa\n", + "ZxFiAUUJIKVOILCZZuMMviwhWaQVYPbT+skFkQSoYRBARXIBhQIWuZVMSwIhsvi+gWkG0bQmltWL\n", + "lD5SNvH9wkpQAr60cP0sghCLuEiRw2s2sPwFmgQZ6L2eaqVIvV6/tNDkcjnOnTlDo1ZjYNUqVq1a\n", + "dVWapN1228184xs/RFFc4kmTvGczm5ugrytMXlPZvGvjq7xW4vE49/7hP+M//+//AWtuiqZqs6DV\n", + "UeOr6Ex0UCpVqFaLqKqK66YIBMBxphGihOuG0NUehC9wSNLwymjSxSWGSw3hNfH9GlIaSLkVaNVr\n", + "tI5ga4CDj41gnhQ6DhYQxmaZsGqRMHwadoyaFwVxAUM9hS8dPC9F6xiwBlRwnArxtp2UfQfqDi9O\n", + "z2O70Cy5PHf6NAe2bUNVFBKRCB+6fg+cP8/4UpNMRqW7ez+OcwPPP/9TpqePUC5fZNOm9Xz5y7/D\n", + "zTe/aSHs9xweegh27IDBwSvdkl8e+/bBxz4G+TxcTYmu91wwcui55zj+2GOszWTYkE6zODHBg3/+\n", + "53z0i198XSpjX18Hhw4tMTFxnmzWIxrtJJWKsrAwRlVRsM0gy45N+8B12EtzSCfF+eoELjGiDBAi\n", + "jIOPr1goRoq43kXvwA48bx5F6WRx0SKXO7Oyex6m5SfSBPpo7ZZfAlYhhIeULwMmQrSj6xlct4SU\n", + "M2jaOur1OlI2SaXWousBHOci1WoTzzNob1/N4GA7S0sKrtsgGEwwN7fMddeaJGXeAAAgAElEQVT1\n", + "09kZ5sKFs/j+dhzHZnFxglCowJYtm1+3H0MhE8tqXmaIBiClc2lRu+GGnXzjG48QiSQIBFpeJo5j\n", + "8f737+bLX/7cFaWEbt16DeFwiKeffoGFhRG6u9v5xCfuZmhoiFQqxdLUFD/5m0PkbY1yM0+VCqG2\n", + "FN3dm8nlziOERW9fL45bZJU2SDZrIefKFIuLWJaJEGl0XcX324nFutG0boTIoWmDNBrzeN4JdMNF\n", + "0/pxnDlcN4ZgGN+3kCtWAB4nqBMmTDeCBmlFw/FFS7NEJPHwUBSHcDiKokhcdxLXzeC659G0fjQt\n", + "juuWUdUcmjaE1aixLF0WmnOEzXYGonuYWXBoqPOMjo6ya9cuXj59mh9///u0CUFA1/nJT3/K0bVr\n", + "+Y1PfxrDeHc4L79R9PT08Pu//ykefvgxHnzwGfoH1/H+D3wIwxBUKhf5yEduec3PtGfvXlZ9+5v8\n", + "2Z/935w4Ps9Q3SGVuhFdD5PNzvHKK2eoVn0MQyEabVKptGwYfHcQ6fogZhCyiSvj+EzhUkAwT0Am\n", + "caW5wogZoXVc5wM1VGUZX6aRcomWlmsKIRyk2oWuJkh3Behpb2d0/AhWqUAyrLFpaC/pWJKnT87R\n", + "aDZw/Sq6HqVcLlCrzazUj0k8OjGMCPnyJN/78cs0mj637b4WQ9fJlkps3bmTNZ7GzIx56djywx/u\n", + "Z2zsBJs23cZnP/ub79iYvdtx//3wxS9e6Vb8aggEWqyaRx6Bz3zmSrfmjUO8EYfbKwEhhHyzbWs0\n", + "GvzFV7/KnvZ2jBVLcYC5bJZqVxef+tznXvO+XC7Hn/7p/8WZMwo9PVupVMqcPfsi0aikrS1DubzA\n", + "0oVnMPwQvtuF1bQoeItIwvjYqKhIbISaJNLWSU9vG4GATT5fJZutEI+vZnz8xZXz6DSquoyuaziO\n", + "juu2UvdCpJGy5UcDJTStF00L4vslbHsCTbsFIVRCIZXu7gyxmEc4vERnZ5zjx8/wkY98kv7+1YyP\n", + "v8zJk5OYZjft7YJdu7YxMzNCo3GWdLqD2dlpGg2LRKKdWCzEjTdey8033/AqUatjx47zgx+8wODg\n", + "jktBRaGwhKJM8Ed/9IVLO+ljx47z2GM/xbZ1fN9maCjNRz/6wV+qRkSIN+a4/FagUCjw4AMP8K2/\n", + "+C65kk5X/266u7fhOA0qlWPAPKrazsWLUyjKahxHwbbrOM4clhVBiEESiTBzc4voeh0pZ+jpuYZK\n", + "ZYR6fZ5AoAMpA6TTaS6OHcG2u9G1IHWrREsLRgKzBM0A7Z6GI2fxKVF127CI4NGLaggCgTiOo+B5\n", + "z2EYcYSIIEQd217E8xSGhzeTzxdRlH7y+Wk8p4iphQhoaYLCoCmnWT0YZ2BI4w//t3/OS08+yY50\n", + "mtDPSfkfv3iRaz78YXbv2fOO9P0v4q0Y9+npaZ5++jCTk3NkMkn27dvFhg0b/qf3HDnyIj/60Rkc\n", + "B06fniOVWg/A4uIEk5OnKJXOE1AF1WqZhqUhlC2g+PiewLHzeNIDljEooJPAI7RSkBqhzCweJTQR\n", + "RUqBREGINlRlGUEGxz+HlCXMQJhYbDu7du1jcnIUKRvksufIBHtJxXqYWR6haUUpN07h001b+z4s\n", + "a4JSKYvrSqLRMKtX78Z1a+Syh5BND12b4drV7Qx2Jol2JvjcH/8x0WiUb33rB2SzAlWN4PsVurp0\n", + "PvOZj72uhcbbjXfy9/5GMD4Oe/bAzAxc7adVf/VX8L3vwaOPXumWXI6VMX9Nns97KjOSzWYJ+v5l\n", + "gQhAVzrNU2Njr+u5kE6n2bFjPRMTR8jlDjI3t0Am08Xg4E7q9SzJpMbS0jCz8xYhYWJ5ORQcFEI0\n", + "aBAUAoSBoQo8v0Rn55qVVG8Kx5llcvIYvu+iaR5CVPB9g2YzgK67aFoAz7NQlCCeBy3mRCdSWkSj\n", + "JprWw9JSE0V5BUVpJ53uIRx26OjoxDRddu++henpaVS1RcsdGtpIuVzk5Mln6O29lsnJ5+nri/Cp\n", + "T/0x2WyW++9/hMHBzUSjSWy7yRNPnKVarXHXXXdc1ifXXruV6ek5jhw5RKt2xSYadbj33nsuS+lv\n", + "376NzZs3kc1mV/Q90m/5uL4dSCaTfOFLX2LD5mv41rf+mpGRItPTz6CqZa69thcpNzA/HyAUsiiX\n", + "fWzbx7ZnSSY34vseudw5fH8IXV8iGGwg5TKuO0EyGcU0e9E0iapCOrWahekLaEoGRdRp2jGkbEOg\n", + "4Mtxms0sFS2JL5qElQCmp+LLLIg6vh+nVssBFXy/gpRJFMWjo2OQUKiP5eXzSAmx2BCuu0QwWKUu\n", + "PVwsqvY4IgiZ5CAbB9fhe+M8/N/+G0OJBKFfOLIcamvj7EsvXbFg5K1AX18f993X96bu2bRpI088\n", + "cRjPS+E485w9O08wmEZVizSbowTVDF3JAcbqr+BLF98JIAUEApJIdAfl8jmQM3QaQSr1RWpSwaKB\n", + "R5ggKmpgPY7v0bBnUWmgqgbJ0FokJg1LRdefZ901Q1QqC8zMPE61XKWtLcHGm7czen6C6ewpFnI5\n", + "JDV8PJLJTmx7EjDw/SkUJYKUHtXqKLXaBUrlOpYFmuoxUw7ix7rplQahUIhkMskf/EGrHqxQKJLJ\n", + "pBkeHn7XK+u+k/jmN+Hee6/+QATgQx+C3/99KBbhHeQO/Eq4qr+JlmUxPj6OZVl0dXURDAZp+v6r\n", + "go5as0koGn1dQZ+JiQkunHgRvTxNPJqkqAvS6R6WJg9RLU7Qv3aAvr5eHKdCITuF0GP4joFNHY0E\n", + "QgaoyRplu4JZy5LNZkgkdgPzuG4MVZX4voqUEwixFUVx8H0Xz9MRooFhrMdxSrTqRgZQ1WE8bwzb\n", + "FrS1DaPrLq47TiJh0NbWSTIZp9EYY/v2nZhmkI0bu6nXz3L27Ay6HiSVgj/5k4+xadN6IpEI3d3d\n", + "CCH4/vd/RCKxjmi0xTAwjAADA1s5cuQg+/ffeBmlT1EU7r77Tq6/fpmFhQUCgQCDg4PovxDotd7H\n", + "uGqpozfddANbt25hdHSUXC5Hf38/ExPTHDq0xObN61hamueJJx5DUQaYmytRKs0SCHTR0dGJYRRI\n", + "pUw8L86WLXsYHt7Ck08+SqNR4YYbduO6kuMvXSQRjrK0eAgTgyQ6VUpYMg7EkETw/HYUM4LUPCKe\n", + "pI0uKkaDgtWg7o0gUYAUnmfieS653AUMvRsNjaX5n9LWuQchogjR8otRRAK7cZ5IuEBHai25cp32\n", + "hEJCUSgUi6/ZD/67aIf6TiEcDnPDDdfw1a/eT60WQFEqlMsjDA/HKRVMmkWDhdwUifAOGtZZ6m4O\n", + "XetFOKPQOEhSeLhKHemaxI11hGyTktRQEQgxj+NVUIQBVAiow0ilStObxvNBiDqGqnL7rTtJJ5Oc\n", + "ePJJFmWr7iR7apRoJIOTCtFhDABhbLuKZamEwxLDUIhEVqFpJqXSOPl8mULBxvO6EcLBcRbJ14r8\n", + "xs0HqNUKvPDCUe688zZ0Xf9Hs0W/rnBd+K//Ff7u7650S94axGJw4AD86EfwW791pVvzxnDVBiMz\n", + "MzN8+9sPU6+3VEt9/1l27x4mNTTE2MwMq1cWR8/3OTc/z467737N95mfn+fh//Jf2JVMYMQWCIUT\n", + "5M4dZHb2DBvb1iJEnXarwvjSLKYZpbN9E80KlIuLRJU0dW+WBsvorMcXgnAYJiaK1GqHcJwA0IHr\n", + "eivCZRZSTiKESUu8qoGud+C6TYQYRlWbSOmgaQqaFsL3a3jeFLXaJKaZw7Yl58+fJxZL0dvbx6FD\n", + "z6JpNlu2tKMoKpXKItVqg5tu2s6dd37gVZXx09OL9PSsv+xaSwckcslL5hfR1tZGW1vbWzBi717E\n", + "YjG2b99+6fnBg8eIRjMUi0WefPJ5JierNBrP0mzOoaoe4bBAyiDh8AChUILJyWe5eHGOjg6NLVti\n", + "rFmTZOvWa2g0Ghx98TBW4TyD3gI6CSBBg1Eu4tLgAELkcMQcMSWDqSVo+McJmzF0ox1h51BI4xED\n", + "NqEoLTuAZm2ExdlJksFBNEWhlJ1F0ZO0t+/F8xQK+SaGriFlhkptjqDhs74/RSJicr5QoGFZBH/u\n", + "uzGRzbLpgx985zv+TaBWq3H48IucOHEeXdfYu/catm/f9ivt7JvNJs88c4Lbb/8dfN9DSkkut8Cj\n", + "j/6AQiGF4TvkKyWioSLhYDuON4HmHqdP0Yngoioadddjwa8QMXWEEMQxqEmbhgyiewsoSpmAZhEw\n", + "SqhmHyGzB03VaTqLVKtz/N3jz2MuL2I2LfLlPOuTbayOJzk+fo54cjXBVBe2p+O6PkL0YduL9Pam\n", + "GRgY5Nix41QqBRqNFLq+a8WtOY+i7GB5eYpjxw6xe/fNTExMvoUj8d7E449Dby9sfv0yuqsOH/tY\n", + "66jmaglG3t2mE68Dx3H4zncexjDW0t+/jf7+TfT3X8fhwzMMrluP3dPDoclJTkxPc2hmhqGbbnrd\n", + "FPSLBw/Sp+skIxEGBjLksudJeyWitSUWyiOYyRjJcIJuzaJWydE7uAVVESiKjiJMNIIowsTUJeGA\n", + "2jKrKpRwXZ1wOEMo1AEk8TwVKYv4fhJwEWIMRRFEIoP4fhFVHUFRLDStiBAnUBQNx5HMzp7C88qY\n", + "5nqazQia5lKvw+KiIBDoQdfbeeaZMcLhDezY8RF27vwEFy44PPro46/6rO3tSarVy3fGLd+N2hU7\n", + "N343orMzTaGwzAMP/HdGRxcIhXqJxVYhRA+BwBBSZqnXHebmFmk2x3jf+/axYcON6Hqdj370dkql\n", + "MR588Ad897s/opDP0ql4ZMIRDNVEpUpcDdJJiHA4gGGGwYhSsissVSsUhcucX8fFo+nmkQTQ6UNV\n", + "FUDDcQCC4PZRbxRIGlEUqZIvLJHNHsayRhDKBTy/gJRRsqWzrO1z2blumKphcOdv/iZHFxcZmZ1l\n", + "anGRlyYmCKxaxbYd715Pkkajwf33f5ennppG09bjuoM89NAJHnzw4V+65sC2bZ566inGxuYplbIE\n", + "AmGklBw/foqOjv1oRhvRyADpWA+6JuhvTxMNZehUTXoT/SSTCdau3UMq0k2aADl7AYcGPk0QKi4h\n", + "hNKgqy1NJGxR9ywS4QE0VaNUL5ArLuCLdi6Oz6D5SbKeSaHu88JClb8eW+TlimQpV2Fu4hAbN6bo\n", + "7c1Qrx/HtpcZHAxj2yWEWEZVG0AY1y1j2+MIUSceH0RVBzh//mWq1RLt7VcRpeIK4f77W6Z47yXc\n", + "dRccPAhLS1e6JW8MV2VmZGpqikpFZ2DgH+oTFEUhk1nF6dOjfOlLv8PCwgL1ep1MJnPJ9vy1MDcx\n", + "Qe3CRU7kGwhhtoIG4RAM6Cz7CZwllfMLJ1nTFyDRsDEDFr4mEaqD55eRAixMDC2K0EykzKNpJori\n", + "4/s2zWYTz3NpiRfFEELi+1Xi8VWoagEhDgI5dH0t4XAviuJRr1soSoV6fRzP0/C8JNVqB4qiUyzW\n", + "aGvz6e7uY9++vRw8eJRkcifj4xdoa+tFUVT6+jZy4sQhbr31cmnnAwf28J3vPIVpbsM0g/i+x8zM\n", + "OTZv7r8kdjQ7O8tPf/oC09NLdHamuOmm3QxezTy3XwI7d17L1772h4yNFQmHN1IoNCiXTxAOdxGN\n", + "DtFonGbjxg1YVp1QyGZ5eZlKReXUqWWeffbbRKNhenrizMycxq2PIbw6aBGkdPAJoAqdmG6QpYmi\n", + "2/i+iWIGcGwVTQ/iiSK5ah6fPBpt6EYQV4RWmFU1BCF8USVkSLKVKsHIGoKmJBTSsO0KkUiNUGaA\n", + "enmW7Wti3LRlNaeXlth2663sO3CAjZs2cfb0aRq1GjevWcOaNWveUIbB8zzGx8eZmZkjGo2wbt3a\n", + "dySIPXXqNEtLGgMD/0DTDYe3cfr0YW64YZr+/v439X65XI5vfesHjI9XGR/3mJ8/im0/iud5FIs+\n", + "nZ0RwmGJosVxypP4boRyrUTDmqNHCWJZdUwzzNLSIq7bxFQiKEaSqr6eemMZHxVFuITTBjfe8UFq\n", + "tRyHnz/LYuE0lgWqouBTo+mGqOd8jlVLVJsQUXbguzV818MkQ9Uu0d6+mtnZLPv3X8/OnVs5ffrv\n", + "SadzHD58lJ07r8OyXObmTDQtQLPpoutJTDOKbQt836XRmGLv3nve6iF5T2FqqmUu9+1vX+mWvLWI\n", + "RuHuu+E734E/+qMr3Zp/HFfSm+YLwM/oLf+PlPJ7b/Rex3EQ4tW1C7pu0GhYCCHoeoMOR3PLeXLT\n", + "Jdb0tc5SVTXMmfIIdijFddtuwNRDKEKwUDxHT1eW3btX0ZZWGT1uU6nqTC9XMNQIiXgXNbeIakQo\n", + "Fl00bRTLKuM4JkLUV5gyVaTMIoTE8xps3LiP/n6VXO4sZ84IgsEOSqUi7e2baTSmgBlsO4Gu78L3\n", + "fQwjiq4HKBaPU6nMYVkWjYZFPD5MNnt0pZ5gHsexqNVsqtXqZcHI5s2bueeeBo8//jy2rQI227ev\n", + "5o47Wqr8Y2NjfPObjxAKDRGLbWZ6usBf/MXD3Hvv+9m0aeOrO+89Cs/zaDbBMDoRQuD7Dpq2GkXx\n", + "kNLHdRWSySFUVeHkyf/O4OBeMpkeyuWXCAZXoSg+lpUnHu9AkSEC9TniQYOGPQpODcdzqYoqTfsl\n", + "otFNVKs27e1dVKtnseoqmrYalCKGHkF6NpY3RiB4E45jI3BQaBAzLUxNw/M7MNUoulqhv3+IoaH1\n", + "zM4eYcuWYWq1Nq7b2U2sv5+911xzadFub2+n/ZZb3lSfWJbFd77zQ8bGKuh6EtdtYBjP8dnPfpiB\n", + "gYG3Yxgu4fz5CWKxzsuuCSFQlCQzM7NvOhh5+OG/o9nsZNOmbiYmnmB2dpp6PYKmSYRIMz4+xbp1\n", + "UTKZDnRziIvjJ7BUk1RbgMbSPGnVQNfbVkTNEkh1DqkZoGbQzQiue55gcIFrrtnD7t23cvbs8+zZ\n", + "6zM/b9JsaiwsnGNpSeC5JhKVitWBItK46CgKaEodRS0TCPZgyTqRyBrOnDnF6tV93HXXPo4dG8f3\n", + "VzE3Z6AoATwvSySykVCog0plhmZzEds+x+rVq/jUp26hr+/NFfb+uuHP/xzuu6+1eL/X8Nu/DV/6\n", + "EvyLf/Hu96q5kpmRx6WUXxdCaMBh4A0HI61iyRKu66wIcbWQzc5w881r3nADHMehYmuUA1FqVp2w\n", + "GaLZrNHUIiy4BruCMQy9JcldtcNcs7MTKacZXt2Da9V45fQxFH0cVUlRsS+S6ejGtlNo2hTBYBeq\n", + "2kYul8f3s7T8Jdagqu3oehIhCkxNvcz27Zv52tfu5xvf+Et+9KMXaDYVPO8UqZSDEFFKpR6ECOB5\n", + "5RWKrYeq9lEszhGNRonHw1QqWXQdnnzyEep1DSkNKpUzPP30EJ/4xOXsl927d7Ft27UUi0VCodAl\n", + "vxgpJX/zN0+TSGwgHs8AYJpBQqEojz76FOvXr7sqhbF+GZw9e57e3k1MTIzh+8soioOi2AjRS72+\n", + "SCxmYtslpATL8ojFumk2awjhEQzGCYejTEycpVyuk0jtZrE+D+UFTHMVimJT9aZphruIa0FqtZNA\n", + "CMsSaJqOZ7RjGklMz8RzFTyh0XQnUNVzqKqGRwUhZoloXbiuTSScRALhqEs47FEozOI4knp9hPvu\n", + "u4sDB/a9JX1y6NBhxsZsBgd3XbpWqRT43vce4U/+5PfeVlZGLBZmYqL+Gq84hELB17j++iiVSly8\n", + "mKWvr+Us3dlpMjKiYJr9VKtjQJZAIMn4+Biq6rNnzzquvbaN667r4dFHf8r5Y02SZjsJM0Gz2aTp\n", + "OSzZLh29KQqFYzQaFTQtgaZ1kcvlWVqaJhj0WbUqwcxMHgDfb0NR+tC0ZTxvDa4XRBVgexqa4mKQ\n", + "RgQqRKJxKm4BKRssL1/gt3/7Jg4fPkdn524uXnyFZHKAcLid5eWvU60eRFF6UBQbeIVbbunj29/+\n", + "/wiFQr9y/7+X0Wy2jmiee+5Kt+TtwU03gWXBiy/C7ne5afeVNMr7WVWVR8sB7A0jFotx6607+du/\n", + "PUIsNoRpBikU5kkkquzZ86E3/D6O4xAOJ0nesJWRU88iCgssVXLUulajOVHGczmihkETiHb3smv3\n", + "Bvbvv44jR47T1TXI+i0Kx4/2YwbiVKoVpqcX0HWV/v40S0vTOI6GlC3nXeghEFiDprn4fpFYLERH\n", + "Rze33fY+Ojo6+Df/5o+54Yan+dM//RpCRAmF2ikUplEUD89roOstCy1FsfH9Kp2d7RiGwZo1/Tz+\n", + "+EOEQgrx+B5isQTF4hw7d97BqVN5hoZe4rrrLq+X0XX9VUWpjUaDxcUK/f2Zy66HQlFyOZ9isXjV\n", + "0HZ/Vdi2g21X8LwmjtOHaSaBCYrFU8TjBu9//0cZHT1PLlcnkYhQqeTwvCJbtqxlaqqOEAlMM4Ci\n", + "1BAiQEGEyVlZQmSxnCZ1NUYkuBadEsFgiXj8ZpLJNczPHyQY3EqzOYMeiKD4NVYPrCOXUwiFLGZn\n", + "LxAKxYlEEjQLDVQfSvYSvoA779jP9u3Xks1mmZkp8uUv38W2bdvesj45cuQMnZ2XV/dFo0mmpjRm\n", + "Z2ff1uzI9u1bOHLkYWy785KdQbVaxDDKrFnzxjcfAK7rIoRyiVnnOA4bNlxLsynJZoN4nkWlIlHV\n", + "PsrlIC++eI716wV79/4GIyMWicRaTrzwHDPVaTzbZtGvorT1k8mswnWXMM0eyuU8kKVQCPP1r/+f\n", + "fPzj+9mzZysPPfSfmZ938P1+VFXFMOLU601ULYOUy3iKiSdtdN1EqgoyJLj1xvfT1zdMNJqgv7+X\n", + "gwfn6OnpJJVqaY3E4xn27Pk4S0sHKZcnWbUqzWc+8wXuueeeKyo6eLXggQdaiqtr117plrw9EKLl\n", + "s3P//f8UjLwR/B7w8Ju9ad++m+ju7uSFF05SrRbYsWOQnTu3E4lE/vGbVxAMBmlvj2JZEfb+L/fS\n", + "aFSpVos888xBeiPtbN91DY7jEIlEyeVeYevW9XR1dfHBD7bz0ktHefLJIuXqWTb2r+G66w9w8OBL\n", + "SNmBZeXo7jY4c2YEVU0jpYqmteP7DTwvgOcV6e9PsHfvNjyvNSnW63VefPEVOjp2UKvFSSQ66O62\n", + "OX36BXQ9gKaFsaxZ0mkFRakzPDzI9PRLKEqDT396J488cgrbLgJVtm4dYGhoiGazyqFDx18VjLwW\n", + "dF1H0+Srsk2+7yOlS+DnRLLe62hvTzE3N8eOHbcxMjJBsVhEVUNomsHwsE48Llm3LkI0GuPUqXGS\n", + "SYtNm3ZhmiaLi8+ztDRCb283uq5x7tzz1OsF9MBeil4IdFCVIqlUN7Y9gWEMkUolaDbrqKqGEBJN\n", + "iyPELNdfv4N4PM758yNs376OgYEDzM259PVtY3l5ltOnj3Du3FmuvfYAe/fuXmGEVNmxo5+tW7e+\n", + "6nNZlsULL7zIkSMvI6Vk+/YNXHfd7je0e/Y8D0V5dWZMCAXf99+Sfn899Pf3c/fd1/Hoo88hZRTw\n", + "CQSa3Hffh960E3QqlSKVMimXc8RiaQIBk3LZIxQy6enJ4DhhenujTE4eJR6PcM01B3DdOZrNJopS\n", + "Y+vWGxkaWs/ExAiu6xAYmSCTidJoNFDVOKZpY5pLJBI9pNO9KEqG6WmLF198lK6uHThOFVXtJ5ud\n", + "IRSKYlkTSOkgpUUg4BCLpZHSJR5vZ3AoSiaT4ejRxxgc7OR731tiacmnv/8adu26lqNHT5HNjmHb\n", + "DTIZg//4H7/CTTfd8LoSBv+EyyEl/Kf/BP/u313plry9+PznYcMG+OpX393y8G97MCKE6AAe+IXL\n", + "81LKTwsh9gAfAD78Wvd+5StfufR4//797N+//7LX16wU3/0KbePOOw/wzW8+gm0PEYulURSVeLyK\n", + "ovicO9dSCFSUCnv29LNu3ToA/sf/eISjRxfp6NjM+vUhjh8/x8TEGAMDGzh9+iyJhI+mxenr20Es\n", + "lmZ29gxSVhAigaKUGRoaYt++PUCegYFWbcvp02colYIcOHAbr7xynosXJ8lkBujpOUOz+QpSdqLr\n", + "Gp2dKh/72J184hN347oumUyGxcVFlpdNurq2oqoqitKajHTdpFJpvqG+0HWdXbs2cujQKwwMbLl0\n", + "fW7uAlu2DL7pSf/djkKhwMmTp8nlSvT3d7F58yaCwVbKPxAI0NXVR62WZ+3afmzbxrKK9PevYtUq\n", + "l9/6rdtIJpM0m00OHz7M3//9UYrFBRKJNKtWxRkZeZ5Uqh/TNJicnKOtbRfLy0UsK4quQzrdDywj\n", + "ZYNm02d5eZyWsJxKpXIW3w/T16dz883XUSot8v+3997hcV3Xoe9vTy8YAIM2g95JohEEexObSIqk\n", + "iiVZvVuUYl/LjuPY1765L7kvyed745c4fknudfIiyZIVx+q9kjIlUWITKRIkQYAAQfQ+AGYGmMH0\n", + "ct4fA4Gk2EmAA5Ln933zcXgws/c6Z+1zZu29V1mwYD1PPvkQKpWK2tqDfPzxLpTKKPPmFXHvvUtx\n", + "ODx0dn6BQiFRVVXEpk23njYrjkQi4z4fQSyWMoQQfPZZB01NbTzxxIPnLZBWUzOL3bs7yM09ERru\n", + "93tQq/3nrPs0WSxatIDKynJ6enpQKpXk5+efMefN+RBCcOedN/H88+/gdmdgNps5enQfZnM+qalm\n", + "Rke1qFQKiouTWL9+E2q1lv7+CAMDw6xbt5APPjiA2VxCZeVCnM4BEhP9jI3Z+fzzQ4TDBVgsaWRl\n", + "VZCTE1tFsttjeWG02gry8xPp6/sMIUCpNOBydVNYWIrfP0g4rCE9XaDRBHC7W7FaE7Fa0/jqq62U\n", + "li6lpKSakRE79fVvotfvo7JyEcuXL8LtdtPWVst99z3BDTcsB2Jbrm1tbTQ0NKNQCCoqZk44oQ8O\n", + "DhIMBrFYLFdd+v/JZs8eGB2FDRviLcnUYrXGImueeQZ+/vN4S3N24pYOXgiRTcxIuU2SJOcZ/n7R\n", + "6eAvlZ6eHrZv/5Kurn5yciz4fC5qa7tpbR2gr28YjUaipMTC2rWLWbVqEb///R+xWOZit9sJh8P4\n", + "/X4aGw+RnR1Gq1Xh8+lpa/MyPOzEZhPo9am43UeJRJIxm9MpLbVQWhx3rgEAACAASURBVKpj5kw9\n", + "3/veI2i1Wl599R1aW5WYzRaEEITDEXw+H1u3foBe7yEpyUokEouYqKhI4wc/eHziYezz+fjlL/+d\n", + "jIyFqNUnflT6+tqoqtLx7W9f2NZVIBDgtdfepbGxH4XCRDTqobDQzP33335FjJGpSg9ts9no7e1F\n", + "rVZTXFyMzWbjhRfeJRJJQ6834fU6SErysnnzfaSkpNDW1sazz25Fp8uju7sfgJwcK1qtIC1thDvv\n", + "3Mhzz73MJ58cxO2OEo2OkJysYu7cOcydW0FOjhWj0YjRaORXv3oBtzuDnTu34PWmkJFRhUZjoKvr\n", + "E3Q6B0plAZmZ5YTDLpzOXvR6H6GQmxUrbiA1NYGsLC0PPngnycnJSJKE3+9HqVTi9/vR6XRoNBok\n", + "SWJsbAy1Wn3WFazm5mZ+97tPT/H5AOjoqOXeexeecSXlZNxuN7/97csMDioxmTIIBDyEQv3cf/86\n", + "KisrLks/k6H3kZEROjo6ACgoKDhnOYJIJMLg4CD19Y309w8zMjJMd7eLvj4vXV2jpKUZWLRo+URR\n", + "ya6uo2zaVMrSpYtpbGxk165anE43ubnpNDa2IkQ+IyNO6utt+HxqRkeHqa5eCsDw8FdEIm6Sk5dg\n", + "MLhJTJTYsmU3Pp+ZUMiNwRDAaBzmttuWUlhYSm6uhdmzK0hPT+cPf3iNjg416enZqNWxDMvNzc3s\n", + "2fMeK1duJCEhmbGxAYqK9Dz88N1otVokSeLttz9g374ODIYsJEnC5+ujujqT4WEX/f0eFAo1anWQ\n", + "W265gblzJ28r72KJdzr422+HdevgqafiJsIVo7Y2dr6trXAJNvykMV3Twf8VkAG8Ob6suFGSpAub\n", + "xk8i4XCY1uZm7O2NaP1+bO0O2gYksrIW0tnZQHX1GoRQ4HQe4vhxH21tL+F2J1NXt4twWIcQCiTJ\n", + "S1ZWHuXlaqqqZvDhh5/gch0lHDai16uRJCNqdQGBQAs9PfV4PBGKi9eyfv0TEzNSpTLK3r3bCQYV\n", + "qNVKCguL0evNeL0hFi5cRn7+iRlpR0ctx44do3I8Q49er2fDhsW8884+kpKK0OsTcDoH0GiGWLXq\n", + "gQu+FlqtloceupuBgYGJJGhfZ2+9GpEkifff38KePccRIhlJCqNW/xG/30tGxmJMJjOBgI/e3i4+\n", + "/3w/H330KTNm5FNZOYtAoJeEhBwWLIg9rCORMB0dX3HzzSt5/vlX+fTTXjSaRRQUpBAK+bDbD1Jb\n", + "28jQkAf/mB9HzzF06jBeRQKLlj9CSsrd7Np1gEDgGG63B4Wil7lzH6et7UsikT5ycytJTDSSmupm\n", + "+fJcVq1aSmJiIrm5uQghaGpqYsuWHQwPj6HVKrjhhhpuuGEZELvBzxdi29HRg1abdtpxozGDlpau\n", + "8xojJpOJ7373IerrG2hr6yE5OY05c1ZhsVguUTuTx5df7uWDD/YQiSQjBAjxGbfeuoxFi07dJA8E\n", + "Anzx6afU791LNBwms7CQGzdsIDs7G7fbTV1dHX/4w0eUlq7BaIylA/B63SiVDsrLY/dfWVnZRBbT\n", + "3bu/pL5+jLy8EhITRzlyZD+DgyGcTj/JyXUkJEBhYSY2mwKfbxSDAfbvb8fnUxAMtuHxtGEwWDEY\n", + "UsjISOexx+6dWK2IRCJs3/4ldruWaFRBQoKOyspqZsyYQSg0j6KiMCZThLKyRZSVlU1MTNra2ti3\n", + "r4OCgsUn+cVk8cwzTzN37jJKS2NGkt/v5fXXd5CamjLl0VDTkaNHYysjL74Yb0muDHPnxioRv/EG\n", + "3HdfvKU5M/F0YP1evPo+mS3vvkv/V18xPzsbnUbD53u+ZLB1lKEhDQZDFkpl7CZXKtPxev309HTS\n", + "3HyIoqJ1pKRYx42RKI2Ne7DZbNjtBrKzV2E2B7DZWlAo7AQCfvx+CUlSkJiYh9Wag0o1k5df/pin\n", + "nkpFpVKxf38zLpcas7kCtVpDc3M7IyN7MBj0ZGYWnCKzTpdCT8/AhDECsGTJYtLSUvnyy4M4nTYW\n", + "LswhKSmHd9/9I+FwmOrqmVRXzz7vcjyA1WrFarWe93PTnYaGBnbtaqOgYPGEv0N/fwe7dr3JggUZ\n", + "2GwDtLU1olYX4PPl0ts7ikKRSldXPXl5Fuz2rYyNlaNQaAEX69fXoNfraWsbAVIxmWIbsGq1nlBI\n", + "RU9PiLDXxgxdiIrMMgL+MZoHm/h8y8ssvfFuLJZMNBor/f21aLXgcHSh0ympqrLg8fRgMnkpLNTx\n", + "3e9+55QtiJaWFn73uy2kp1eSlxerKbR1awNjY15uueXC1phNJiOhUO9px4NBH0lJF2ZQ6PV6FiyY\n", + "z4IF8y/o81eC/v5+3n13D9nZJ1YFg0E/7723h4KC/AljSZIk3nr5ZfzNzSzOykKtUtFvs/H6M8/w\n", + "wFNPkZ6ezrJly0hMTOLNN7dhtycghIQQLmpqitm3rxarNY2ZM2dO3EPt7b0kJKQRDPrZu3c7SmUe\n", + "mZk+nM5aOjp2sHLlcubMWcaxY7Xs3r2XQCCbkRE9Fks1PT3bSU9fg9GYQkpKOm+/3Uhq6ps8/PC9\n", + "CCH44IOt9PZGSUyswGBIwu8fZc+er1i+XEVCgpabb95wxvQFDQ3NGAynTiAcjhGCwTQikRO+PTqd\n", + "AaMxnz17Dky5MWK329m79wCdnQNYLCksWlRzRbb2zsU//AP88IdwPQUb/fzn8N/+G9xzD0xH3+bp\n", + "4MA65TgcDoaGhjAYDOTk5EzcqA6Hg+MHDrA8P39ijz3VlEiu2seBznqyi4sm2hgbG+TQoW7cbjUj\n", + "Iy6OH28mLc1JYeEsIIrb3YFen0NeXiwfR1XVHLq7vQwODpKSkkoo1Elq6hySkrJRqbwMDnpJT89m\n", + "z579aDRqtNoC1q6t4eDBelyuKKAmFBqjoKB4IoLga0IhD2bz6bkDvvahkSSJN954lx072jCbC1Aq\n", + "lbz11mHq6o7x6KP3XtJe+9XIV1/VYzYXnuJ4qVar6esb4MCBTnQ6Aw5HMpGIj3BYkJRkwWKZhdOp\n", + "IDk5EyESuO22uSQlJRGJRDAYDAwPDxMKKYFTr+HoqBOFIpngYCvFNfMRQqBJMJMXyMCaEKWp4T0K\n", + "CkpoaNhCKORgeFgiEEghMzOXnh4HZWVFmM1pVFRoTtPPtm27SUmZNVFTyO8PodVa2bbtK1asWHrG\n", + "NP7fpLx8Flu27MHjcWE0Jo634yESGWD27DWXeaXjR0NDE2q19ZTtSY1Gh1JpoaGhccIY6e3tZbi5\n", + "mSUn/fBmpaXh6+9n/5dfsvHW2FZmVVUlpaUldHd343Q6+eMf97B/vwONJkww2E5Kym42b76P5ORk\n", + "UlOT2LPnGDabjYEBifz82ORArU5BiFE6O9vJzNxBUpKCm28u4YMP6ohEtNjth9Hrs8nIqCYc9uF2\n", + "j5GcnEdDwwB9fbGQ/X37jjF//ioOHuxCrzeh0yURjRazb9/n3HRT1VknCwrF6VsfwWAQUBKL6jtB\n", + "LFKu63JVcE76+/t55pnXiEYtJCZmU18/woEDr/Hww/Fz1OjuhnfeiW1ZXE9s2gR//dfw1lvw7W/H\n", + "W5rTuaaNkUgkwtYPPuDY3r0kCYFfktBlZXHngw+SnJyMw+EgUREL87Pb7YyOjCJJETQiiIYIXq+L\n", + "xMQ0wmE/PT2HMZlqGB3tR6Mpxu3uwO3uIBodICPDSGKigdTUEwZCamoK6ekp+P0FpKdr0WrnYDKV\n", + "4vWOkpKSSCAwRmJiGl1d7SgUChITc0lISObGG1cwNjaGENDXl4jH08LY2AgJCbE9cJfLjkrlpLz8\n", + "7AWvuru7qa3tprDwxFJtYmIqbW21NDY2Mnv27Km98NOEQCCISnWqk57TOUQ0mopabSUSGUGny8Tj\n", + "8TM2NkZOjh4hQKOJjQ2r1UJfXz9ffFGLyyUQQonH04fb7UaSTl1N8PlG0WgSydDpCIXDuN0uIhGJ\n", + "SCTK8opyMoXg/j95DIfDwf/5P2/S3h5Fq83BZDITjYY5cmQfZWX9LFjw+Gnn0dMzSG5uOaFQiP17\n", + "9zJms2FQqbCNHud3Tz/NE9///nkjYpKSknjooZt55ZWPsNu1gECt9nLffevIyMi47GsdL/z+wMTq\n", + "5ckolWoCgdDE/+12O6YzbDemJybSPu5r8jU6nY7S0lL+/d//AyggPz9n4m+9va387ncvUV5ewvNP\n", + "P81Xe3vw+Y1EKcY2sJ8ZM4swmWDt2ptpbj7AunWlrF69mmPHjjE6aubIkT4GB/UolWUoFEoUChU+\n", + "n4ecnAyUSjPDw8Pj4ccJFBQUMjLipr39GEplApIURJIGuf/+28+6dVpZOYtdu94jGs2dMML1eh2R\n", + "SC8Wy6k5Z0ZGBlmyJOdMzUwaH330GSpVAWlpsZWQhIRkPJ4U3nnnkynt91z84z/GkoGZzXETIS4I\n", + "Af/jf8Bf/iXcccf0Wx255owRr9eLQqFAp9Px1b59dO/ezfKCgomVj46BAd595RUe+e53MZlMjIXD\n", + "7NtXS1+fCyEMSFKYQUc/QpfE6Ggjbncy0egAkmTA5QqQk1OI261Ar5+Pw1FPONzDTTf9lPff/z1p\n", + "aYkMDAwwNDRER0c/Tqcdh6MHozERSfLi94+hUoXQag1YramMjY0wa1Yq0WiU48fdJCQko1AIEhNj\n", + "+/86Hdxyyyb27Wukqys2mJKSBI8/fuc5fQQ6O7tQKlNPe2CZTJkcOdKMWq2mo6MHk8lARUU55mv0\n", + "rqyqKuHDD5snVhQg5qyck5OPRuPC5XLj8wUIBhXjdYJiTrrhsIeEhEQCAR8ff1xLScl6srOTGBjo\n", + "wOv10t1di0rlpr8/RFpaIT6fA7XajU5nJKRU0tjYQjSqGU+K1kGKRUvO6pVkZmZy6FA9FsssSkrS\n", + "2b+/DofDgd8fwu12YbWmn7H6cUZGMu3tLezedZDRvmFMBi0WswGLUYnOZuPj99/n9nvuOe/1KC0t\n", + "5ec/L6C7uxtJksjJybmgbbvpzMyZxeza9UckKX9ivMecNm2Ulp7wg/n6Xu/t7cXhGMVg0JGVlcmo\n", + "x0PKGZJMjI6O0t3tJC/vhHNuKBSirW2Q9vY9qPgjzg43+Ql5dEt9hCJBRoZ7aIr2csutaxkZGcFo\n", + "1JKXl4cQgoSEBLTaANXVlWzdupVweASVyojX68BoDFJRUUIw2EtCQgImkwmPx87evfux2UaRJAmV\n", + "ykNRUSZFRavPeb/m5+ezYsUsduzYi1qdMZ4xeJDVq0sZHe3DYDChVmsYHOxGpRpk0aKbJlEbpxIM\n", + "Bmlr6yc391QjyGhMxOGYsm7PSW9vLO17fX18+o83t9wSWx15+224c5pVCbhmjJGBgQE+ef99Bjs6\n", + "kID88nI6jh9nfmbmKWGOBVYruzs7sdlsWCwWXAoVHU29lBdUoRQKAuEg4UCAwqIMVq9ZQn19E11d\n", + "Ep2dY5SUZGOx5DAwMIjN5kSvz8HtPk5Pz1EKCrTU1e2lqWkGXV2DqFRKkpLM5OUZGB1tIxQKkpmp\n", + "JT09H6XSTXb2LPz+NpYsuYtoNMrhw2/h96eg08V+EAcHu0hLE6xYsYIVK1Zgs9kQQmCxWM6bzCgW\n", + "YXF6Hjmfz8OuXftpaHCg06USDg/y8cdf8dBDm5hxlWf9ic0mxSlZYufOreHgwSY6O+tITs4iFArg\n", + "dvcwa9ZsZs+eR2dnO7t3f4ZCkUN/vwOVSoXf7wIGSU+fQXv7bkymArRaA1988REjIwokSYt7KIrC\n", + "/zlGg4FjvSqsBcU88sg6enudfPZRNyVKPSk6NcGgnaycQva22pjzSGzVLBqNolAoMJlMLFu2gC++\n", + "2IPP50erTeXIERu/+c3zPPro3afUUyorK+DFF1/AM5JBdmopSFFa+45SnGWnumgZu+vq8Nx88wVF\n", + "PKnVaoqKis77uauFoqIiKivTqa8/QHJyHiDhdHZRXZ1xynmmpaWxr7WLepsHS5KVaNRF7eFj6Ioy\n", + "2fzoo6e1G8udcqoxf/x4K8PDUQyGdGxttRRZFyNFoggFjIR9eP0mhhxj1NcPAZ0olU3UVBnZ+sor\n", + "iEgEd38/XjHEggXl7NixH5/PQUKCxIYNq1EqQ6SlCQoKCohEIgwNddHVNUp29lwUCiWjo4McOLCd\n", + "e+89t6udEIKNG9dRVVVGY2MzQkBFxSrS0tLYuXM3u3fX4vMFqago4sYb75vSiYhSqUSlUhCJhE/J\n", + "XRQrznlReS4njV/8Ap54As5g818XCBG7Bj/+Mdx6a3wja77JNWGMjI6O8uqzz1KgUDAzNxdJkug4\n", + "fpxPtmzBmZ2Nz+cjOTmZqrIycjMy0CoU+P1+BgcHae5ycNwn0Vq3B2tKGuqkdPIXb0Kh9LN48Xwe\n", + "eOAe+vv7ue++n5Camo4QCjIzrSQkGOjqqkOIMCMjx2hq6sfj0TI0dAghrKhU4HAc56abNpKaamH3\n", + "7vfQagfQ6bykpKTidO7n5ptXEAgE2L59L05nD/X1h8nOLiIlJZG8vCTuvvuuiR/XM82Yz8bMmTP4\n", + "4IPd+P2eCeMmHA7R2rofs9lCQcGJCq1ebzavvrqFn/2s4KrMOzA0NMTWrdtpaupCqRTMn1/GjTeu\n", + "xGAwoNfr2bz5fg4dqqOhoRWjUUdNzZ1s396GRqNi5sxZZGSksGfPp4yNddLX14fdbkcZidLZ/AXz\n", + "5hcTNebS3FyHy2UkOTmP3mMfUiyU6HSZaFQB0nMyIC+ZzZsfpq6ujs5OB7aeLpz+bjJSUxlOTCGz\n", + "fCFHj7aSlXUEiyUVn+840Wgex44dZ2xMQ1ZWHnb7QWbPXsPIiJ+33vqQxx67f+Ich4ddlJeXs2/n\n", + "HsZ8Q0CQ4qwkEvRKHC4XKiEIBALXXC6YC0GpVHLvvXdQWdnAwYNNAGzcuJSKiopTjPbdu/eRUbCS\n", + "UUMv7UO9qITAo0ghU5N8xnsrOTkZqzUBp9OG2Rzbkmtv70Wp1KLXq+nwOBnw7QUBksJAVOXFNtJF\n", + "IGyit/cwOTkJJOgT2f7Cizx06wa0Gg2Vyclsq69HnWNi06ZiBgYchEJadu58E7NZxaOP3kEoFKKl\n", + "pYWsrCqMxgDd3V8RCglCIRfp6WmMjZ0pLf6pjI2NsX//YWprjxGNRhkaGmH9+pWsXh17SZJ0RSLk\n", + "lEolCxaUs2fPMfLyTjjb22ydFBaeHtk11bS1wWuvwbFjV7zracWGDfDrX8PTT0+vsOZrwhg5cvgw\n", + "KYEA2eMFocT4w1kzNIRKpWJJXh4jPh9f7tyJb8ECvIpY1sh/+7eXGBhIIKfobgIBF7axVuaWVpFf\n", + "UEFX10EikQgQKyxWU1NIQ8N+tNpcVCo9oZCd5GQPY2Na+vvDOJ0qLJZy2tubMZvVExEzdns/s2cv\n", + "Y9Giddx+ewX79x/h2DEber2F117bQXv7iyxdejOzZ99Ffv4wPT21rFlTyY03XrpTYXJyMvfcs47X\n", + "X99GKJQICIQYITERSktjeSYikVgeE41GSyCgo6en56qbMY+OjvL0068QjWaTk7OCaDTCvn0t9Pa+\n", + "xpNPPoRSqUSv17NkyaKJLLQx575t7Ny5GzADYWpqsrnnnhp+//wb5CpU5KdaSdbq6Wk5Tt2xV1Cl\n", + "VZGScgMuVy9JARch1xBKnQmFIgmDMouu+m5+/Q//wm13bKKiYiH5mx7D5xsjEPAxMNDDtm3b2LXb\n", + "RX39IGlpCahUPtra9lBf34XRmIvDcYiSEutEXovjx3cyOjqKQqEgFArR0zNIdfUygm4w+MdIMiai\n", + "UWkZcLZhczpRmM3nrEx9raNSqaiurj5nePL+/UfJz5+HpnQ+Ho+LSCREQkIyvb219PX1nVZMTgjB\n", + "HXfcxHPPvUl3twO9PgmHo4OkJD2asIfcqI9MhYRWaaDL1UVn0I/RcANqKUBGRg6RyChiZJAUvZFg\n", + "IIBWoyHZZGJVeTkDCQnc8xc/4l//9Xd0d0eYP38tkiTx0ks7eOutbcycmYckJTN37kI0miM0NLSh\n", + "1c7E6XTy9NOvUlRUQFFREU6nE7VafcqWbSgU4oUXXsVm05KZGcvGevx4N52dL/ODHzxKQkLCFQ3V\n", + "X7NmBQMDb9La+iVCmAAf6ekK7rzzLp544oqJAcSiSX70I7hOqlqcFSHgV7+C9evhoYdgujw6rglj\n", + "ZLCnB/NJs8JwJEJ9QwNLc3MZ8vtxut0kGo1k+/28unUrVetu4de/fhqlsoTy8ipaWlyYzTkkJGRw\n", + "7NhBsrOLUCrHJsLPlEoljz9+H88++w5ebwghJLRaE5991jLulJpJIKCmv98BBHG5YMaMLMLhAKFQ\n", + "zIlOkrzU1zfR3S0oK1uHJEm0tLQBFXR0DJKVVUBKihWDYSV799axcuWKyyo+VllZQWFhAW1tbUSj\n", + "UfLy8nj22ZcRQtDV1UV9fSuhEOPF3ez4/csvXQFxorb2EIGAmZycWNVWhUJBbm4ZHR37aG9vp6Sk\n", + "5LTvfL2MPX/+nIlEaPn5+fz93/8rKeiZN2smivGHtVFnxNu4k8auOkymhQQ8w2jG7IiogtTUfHw+\n", + "JxqNjtz0fJqP9Y0brw4ikTA6nZHGxoN89tkhQqF0Cgpm09sbIRj0YbEksWxZLu3tDRiNPiKRZMbG\n", + "1LS0tJKbm0MwGOI///N1+vvdCKGkra0Ji0ViVvUc6nbvRu0PIfRKxrzDdI6l8O0HH7xuihheKpIU\n", + "nfgR/jqaKHb87Em3srOz2bz527z99nscPVpPfn6IcCiRVFeA3PJ5NNcfJhw2o46ESYtq6QuGqKhe\n", + "TG5uLnZ7C56uI4j8bCLhE1sSqYmJHOnupr6+AbtdS3l5NXZ7P7t370KILIaHRwmFfHR3H0GStBw/\n", + "PoTVOhshFIyMhMnISOGf//l5MjMteL0gSRFmzszitttuIikpidbWVnp7wxQUnDDMrNYCurs91NUd\n", + "YenSJVNwdc+OXq/n8ccfoKurC4fDgclkorCw8IqP1y1bYom//uM/rmi305bq6pj/yP/8n/D3fx9v\n", + "aWJMM3/aSyM1M5MR74nlyzGfD1U4jFavp2bpUhSZmXT5fLQ5RnEHdai0FdTX22lqshMMhjAagzgc\n", + "vQQCAdzuIK2tn3PLLTecEqEwe3YVP/zhvSxalE1enpLMzDA6nZni4rWkpcW2OPT6UpTKVLzeLlyu\n", + "ETyeAaxWK729x8jJ0dPRMURWViylfCgUwOMJkpFRyOCgG++4/DqdEZ8vNuu/XIxGI1VVVVRXV2M2\n", + "m5k3r4yGhq/Yv/84Ol0OZnMRBkMmg4ND7N9fd9n9XWk6OwcwmU5f7lUqkxgaGj7nd9PT05kzZw4V\n", + "FRWEw2GGhkZJUWsnDBEAndZAfmYuJTlGnM5DRPAQUQdJS8smGo2gVkvo9XrcIT8JKfmMjnpYubKS\n", + "rq59tLXVcejQUUKhWEIrq7WUtLQKhoclolENAwMuKitL6OwcZWQkEbfbwNGjw2zduo0jRw4yNJRA\n", + "bu5ycnOXUli4in37dhAOjzF3xQqC5mSODLaRXJjMQz/+MZVVVec4UxmAefPKGRhoP+WYxzOKwRA5\n", + "Y74OAJfLxUsvvUdfn468vFXk5i7neMNuPEN9mFMs5M+YgV85SFgZxqzXkpWlJi8vtsKSkGDF4fMD\n", + "fkwnhV473G5SrVba2nowmTKQJInDh/ej1ZaSlJSHwWAlLa2ApKQCPvnkPTQaM0Io8HiGUCrtWCy5\n", + "HDjQg92eTG7uUnJzl9PWJnjhhdeIRCL099tQq0+f6hqNqXR2DkzeBb0IhBDk5+dTU1NDSUnJFTdE\n", + "xsbgBz+I1aHRX1yR52uaX/wCnn8eGhriLUmMa8IYmT1nDnaVikFnLKu8Vq1m2OMhpNNRXFTEnHnz\n", + "KKmsQpOYR2ZeGenpOaSkpGMyWejoGGLOnDKqqjJJSvKTkSGxefO3WLBg3mn9lJaW8uSTD/FXf/Vn\n", + "LF++kMTEXKLRCCqVZnym0oNSmYTBEMLrrcfrrUWvH6WiwsB9932LcDg64cilVKpQKCQikRBCKAmP\n", + "z56i0QgQmqiTMpksWbKI0dFmgkEnPp+dkZF2PJ4GVq/eRHOzDbvdPul9TiUZGWa83tONNknykpR0\n", + "/twbX6PT6VCrFfiikVOOR6IRQlKIm26+idtuK2PBwlkEk5Owjw0QDDrJz89i1OvGodKQkmrBZDKw\n", + "bt0aNm/eiNE4iNFoICsrkaKisokwS602g+FhOy6XB4/Hh1YbALwoFBJKpYTN1kQkYiQrq2RiJp+X\n", + "V8TcuSvo7NyBx9OINSfEk09t5J9+848UFxdf+gW8jlixYinp6T46Ow8yNNRDd3cTTmcd99yz4awr\n", + "kDt27GF01EReXiXJyekUFlay+Ibb8IedGI0eamoK+N5Tj7NoyTwqaspJTjUyOjpEMOgjEPDh1SjR\n", + "W5L5eu3F4/fTNDzMojVrSE42EQh48Ps9uN1+9PqYI2kkEiQhwciNN64lGh1jZGQfTuc+DIZBli1b\n", + "ycBAD0plLhpNbKIkhCAzswibLUJ7eztmcxLhsOe0c/F6XaSnnz1F/rXM978PK1fG8mzInCAzE/72\n", + "b+F734MprnV5QVwT2zRms5k7H3+cj99+m+auLiQgsaICo1aLcvxB09MzwHAogrWiGqVSRUlJKYcP\n", + "dyBEKmNjYxQXF2IyKUhL015Q6XW9XkdubjqDg72kpuaRkZGLVqvn+PG9FBSo+NnPbmfmzBJSU1PR\n", + "arW0tLRgtw/Q0fE+s2bNIT09h+LiYurrGzAaEzAajUiSRE9PI3PnllxQJdWLRa/XU1paTGlpDsPD\n", + "w+j1ieTkzCEhIZnu7lFcLhepV9GG6rx51ezZ8zJjY6kTeViGhnpISgqdcYvmbOh0OtasWcTvmtqx\n", + "uexYElORkBga7iFqNrBq40YKCgpobGwkN1fBmy++jkGvpTXkRZWURvGsBYTD3ZSXxwrQlZSUsGHD\n", + "jbhchzh61HnKHn00Gsbnc5GVVcTYmII1axZy4MDn9PQcICEhgfLyGbS3n76qU1BQil6v54EHbh9f\n", + "hZOneBdDQkIC3/3uwzQ1NdHe3ovZnEdV1UZSzlHG9PDhZjIy5hIM+untbWN4eAilUoFLl0xmrpXi\n", + "8QRqSakG6rpcbNz0IAMDdoaGHCiVffzwz58kx5rK7v37UUsSwdta1QAAFcpJREFU6PUsv+suysvL\n", + "SU1NZceOlwgEkpCkKJIUJRj0o1T6sFqtaDQqamrKSErKp6hozoQj+sjIftRq5WlRMEIYcblclJWV\n", + "kZCwC7u9n9TU2IqP2+1EiEFqatZP0dWdvvzDP8S2Z/bujbck05PvfhdeeAGee44r7sPzTeJmjAgh\n", + "HgE2A1rgaUmSnruc9nJycvjOU09NOP5ptVo+fOcddtbVYRSCw6NOojkzKZoRW/EoLCzH7XZx+HAt\n", + "g4OlCDGI1arh3nvvvCAHr9LSEnJzd2AyJdHZ2QaoiET8VFaa+F//6+cTobLRaHS8ym8PJtNsmpqO\n", + "0NGxjVmz8sjNLSIxsZa0tAh9fXVEox7Ky7PZtGnd5VyKc5KXl4XDkUxu7syJY9FolGjUfc7iYtMR\n", + "i8XCww9v5K23ttHdLSFJEbKzE7nrrrsuOjJo48Z12O0OPnj9PY53dKMihMlq5pEfPjVRrXnOnDnM\n", + "mTOHVauW8eKL7xMKGdDpDEAP999/0yk/bDNmlKLX76KwMI2WlnaMxnQUCgV2ez3LlmWxcOFcGho+\n", + "4siR/bhcetLTlxKJhGhvb8Tt7j5NPpdrmJkzrde1o+rlotVqz+voejIajRqPZ5T9+/fg8RjQaMxE\n", + "Ij5sIQN7bDbs488J1YxillWZGB1tIynJiMkkUVY2l7vvvg2tVsvqdevw+XwkJiZOrMJYLBbuv389\n", + "b765DbXaTXf3XtLSLCxdOgedTktv73FWr17IyIgbm62N1NRcIpEwweAgaWnpp40DSXJjNpvHfTTu\n", + "4tVX36erqw0hlCQmKnjssduuqonG5SJJsYiR3/wGdu6E6zDQ7IJQKGJRNWvXxooGxrNMUTyr9qok\n", + "SQoLIRTAPkmS5n/j75NStdfpdOJyuRgeHua11/ZQULBwYsnc7/fS2fk59967HqvVSk5OznlzeJzM\n", + "4cN1vPHGJwQCJvz+IBqNhw0bFnDjjasmPtPS0sJvf7uVgoJFCCFwudy0trbR0rKb226bz223bcRk\n", + "MuF0OklKSiItbWpD3lpbW3n22fdIT68iISGZUChAb+9R5s+3cuedt0x8zufzcfjwEZqa2jGZDMyb\n", + "VzVRhnyquNQqnpFIhOHhYVQq1WU/cIeHh2lra0Oj0TBz5syzrkD4fD66u7sRQpCXl3fG5GGHD9fx\n", + "+uufMDQUpadniGDQxtq11TzxxCN0d3fzs5/9gu5uPcXFy0lMjCWpGxrqwOnczqpVt1JYOBulUoXD\n", + "MYDf38JTTz1Aenr6ZZ3fdCTe1VvPxs6du/jnf34dny8HlSoFh2MIr3cMnW6MVassPP743Wg0GjLH\n", + "cxn19/czOjqK2Wy+4NpOwWCQpqYm3nprK4GACSESAA9ZWWoeeeRulEol+/fXUlfXjFarpbQ0m08/\n", + "PYTBUEpKipVIJEx/fwtZWWH+5E8ennh+SZKE3W4nEomQnp5+Uc+1K8VU6f3YsVgNlrY2eO89yMub\n", + "9C6uOX71q1ia+M8/h8uImzgv56raGzdjZEIAIfTAFkmSVn7j+KQYI18jSRIffvgxu3YdQ6FIASIo\n", + "FE6+/e01VFdfenp0l8t1SsTKN42J997bwsGDHqzWglOO9/a2cMMNGaxdu/qS+75Umpqa+PDDL3A6\n", + "vahUsHTpbFatumGiJorH4+HZZ19kaEhNYqI1tv/t7ea22xayZMniKZNruv4oXQ5fj49IJEJ+fj5m\n", + "s5kXX3yDo0edHDrUQGurknAYzGY9GRmppKfrSUuD3NwITmeYaBRyclK55ZY15ORMberueDFd9R4K\n", + "hbj33v9Cb28Kw8MhlMoE1GrIyDChVrfyL//yY2bNmnX+hi6ASCRCW1sbIyMjmM3mc0ac9PT08P77\n", + "n9LTY0ehgJqaUtavX33V5ZmZbL339p7ILvrTn15/hfAuh2g05lMzZw788pdT18+5jJG4+owIIf4H\n", + "8CTwl1egL26++Sbmzaums7MLlUpJSUnJRS17BwIBWlpacDicpKenUVxcTGJiInPmzDnrd1Qq5Rlv\n", + "OEmKolTGZ7Yya9YsZs6cidfrRavVnubAt2/ffoaGdBNF/wBCISsffriHysqK85arlznBN8dHY2Mj\n", + "R486KCxcQG+vHa02lXBYhd3eTlVVDkVFxXR317Fu3ULMZjPNzcfR6XRXZUK6qx21Wk1FxQyGh0cp\n", + "KipEq9VgMiWiVCrp6Ginru7IBRsjNpuNtrZYNE9paclpkxalUklpaekFtZWTk8P3vvcIXq8XlUp1\n", + "3Y+N0VH4u7+DZ56J+T00N19/dWcuF4UCfv97WLIESkri4z8y5caIEMICvPyNwwOSJN0vSdLfCiF+\n", + "CXwihHhDkqSxkz/013/91xPvV61axapVqy5bHqvVesFLqCdjt9t5/vlXcTrVqFQmQqGjWK07eOyx\n", + "e89ZNbWiYiZffPE2kUguSmXscofDIcLhIWbNWnWpp3HZCCHOOpM6dKiZtLRTH4xqtQZJSqKnp4ey\n", + "srMX6ZM5N0ePtpCQEHMszM8v5KuvjpGaWgXkEolECQa9qFQu+voGeOmlbSgUsW2ZaPRL1q2by6pV\n", + "K+Io/fVHfn46kUj/RPVfAJ9vBLPZSE+P84La+OST7Xz66WEUirTxicmXbNq06LJzfkyFk/vVxu9/\n", + "Dz/7GWzcCIcPwzW6eHhFSE+Hjz6CFStiaeLPUCVhSplyY0SSJBtw2l6EEEIjSVIQCAGnF4LgVGMk\n", + "3rz99hb8fiv5+Sc2IPv6Wtiy5RPuueeOs34vLy+PNWsq+eyzvahUsdlQJDLETTfNPWt+g3ij0ajx\n", + "+0+vHSFJ4ctKxCYDWq2aSCQWepmdXczAQB89PQcZG5Ow240YDDZWr65m27Yj5OQsnggFj0RK+Pjj\n", + "vZSUFF2z2zXTkUWL5vPmm7ux2+tQKpORJD9K5QizZ9eg04XO+/2uri4++eQIubmLJyYjoVCQDz7Y\n", + "S3Fx0SlGjsyF4/fHcofs2RPzC5k///zfkTk/paXw6acx466pCf7mb+BKLbzF06vpL4QQnwG7gDck\n", + "SXLHUZZzMjo6SlvbEOnpp6aMtloLOXKknUAgcM7vr1u3hh/+8G7Wrctj/fp8/vRP72PlyhumUuTL\n", + "YtGiKoaGWk/ZXhobG0Gv95MfT3fra4CqqjL8/j4ikTAKhZL581eyePEc8vLc3HffPP78zx8lGhWo\n", + "1ZZTiosplSo0GgtHjzbHUfrrjxkzZrB4cQVz5hQyY4aB6uocbrxxE5HIGIsWnd/XrL6+Ca02c8IQ\n", + "gdgqo1JpoalJ1uWl0NUFN9wALlcsZFc2RCaXsrLYda2vh5oaeOUVCJ3f7r5s4jbNlSTpb4C/iVf/\n", + "F0M0GkUIxWkhv0IokKSvK3yem8zMzCu+EuLz+SbCnC+Gmpo5tLV1c/jwlwhhRpKCaLVuHn741utq\n", + "fzpWit6HRqOZtBWh/Px81q2bzbZte4BUIIpC4eTP/uzRiUR74XB4IuLrZBQK1UR5AZnJIxKJ4Pf7\n", + "MRgMp93jWq2Whx/+Fr///XsoFCaEENhsh5k7N5c5c84fIhwKnVmXQigIheJTufZq5pNPYvVUfvpT\n", + "+PM/j9VZkZl8LBZ4993Yts3f/V2soN6tt8LNN8dCgKciw4C85n4BJCcnk55uYHR0mKSkE45nw8O9\n", + "FBVZp10CKpvNxocffkpraz9CQFVVIRs23HhO35aTUSqV3H33t1iypIfe3j4MBj3FxcVXnbf+5dDU\n", + "1MRHH32B3e5BrRanRRxdDqtXr6SyspyOjg4UCgVFRUWnJLGaObOYzz//AEkqmPhxjBlGA8yateGy\n", + "+5eJEYlE2LlzN198UUswKJGYqOWmm5Yze/ap6fULCwv5yU8209rais/nJzs7i+zs7AvKR1RWVsKX\n", + "X25DknInPh+NRgmFhigtnbrItGuNaDSWwOyf/glefBFWX/kgxOsOIWIRNps2xVaj3n4bfvtb+M53\n", + "YO7cE3+brGoUcQ/tPRuTHdp7uXR1dfHcc28RjWZgNCbj8ThQq+08+eQ9l+QQO1W4XC7+9/9+Acgj\n", + "LS0bSYoyMNCO2ezi+99/bFJ+TKeK6RLi+XUulrS0SkwmM6FQgJ6eoyxcaOWOO245fwOXiSRJvPXW\n", + "+3z1VTcJCdnj+Wm6mTcvm29/+7ZpmTPicoiX3rdu/YTPPmshJ6cSjUaHx+NicPAIDz20loqK8vM3\n", + "cAFEo1Fee+1tDh2yYTJlI0kSbnc3ixcX8K1v3XxFK+hONy5U73Z7zJnS4YhtGXyjwLLMFcbrhe3b\n", + "4cMPY6snBQXwl38ZWzE533Ce1nlGzsZ0M0YAHA4HtbWHGRiwk5OTQU1N9bTLiPnFFzv54x87yM09\n", + "NeKlo+MADz98w7SOhJkuxsgzz/wnDkcqZnPGxLFoNEp3907+63/9zhXJVBuNRjl+/DiHDzcCMHv2\n", + "LGbMmHHNGSIQH717vV5++cunycxccoo/h9vtRKns4M/+bPJiGyORCM3NzdTVHUOhEFRXl1FaWnpd\n", + "GyJwfr1LUsz4+MlP4L77YvkvpvFc6rokHI7p6Be/gJSU2L/nWrU6lzFyzT3Ztm/fPmVtp6SksHbt\n", + "anJy0li1asWUGyKXci49PYMYjacH2avVSdhsQ5PWz6VwKf1MhmwX20ZPzyBJSadmcj1+vBaFIgGn\n", + "88LCOS9XFoVCwcyZM7nnntu5557bmTVr1oQhEo9rMtXtTEWb52pnZGQE0J9iiACYTGaGh0cmCldO\n", + "hjxKpZKysjIslmTuvvtbzJgx47IMkemmu8keA34/vPoqLFoU81f4i7/Yzj/+4+UbItPpfK8VWVQq\n", + "ePDBmLPrqlXbefJJWLMGdu26+LZkY2Sa9nGp/VgsKfh8p1eyDYfHSEk584x+Op9PPG42iyUFt/tU\n", + "o+PYsQNIkveC/W4mS5bp3MZktjMVbZ6rHZPJhCT5xqtkn8DjcZGUZDwl++l0u1bXWjvhcCxHyL//\n", + "OzzwQKya7L/+K/z3/w4HD8Lw8PSQczLbudZkUSpBrd5OY2PMOHnwQVi/Pubf477AONlrzhi53qmp\n", + "mY0QQ4yOxiq/SpLE4GA3ycnBiYJvMudm9epF2O3H8Ptj+UCi0Qgu1xAVFTnXVbGxaxmTycT8+aV0\n", + "ddUTicRWQYJBPzZbAzfeuPi630K5UkhSrHbMfffFcoasWgWNjTGfhNtvj2UGlbl6UKth8+ZYFtyH\n", + "H4Y//CGWlO5CkKNprjFSUlLYvPlO3nprK11dxwCJgoJUbr/97osO8b1eKSsr4667fHz88W6GhkCI\n", + "EJmZeu644+Z4iyYziWzatB6V6lP27t2NJGnQaCJ861sLqak5e3kHmclFCDh+XK6qe62h0cSMkYcf\n", + "jhmcF8K0dmCNtwwyMjIyMjIyk8dVF00jIyMjIyMjc30g78jJyMjIyMjIxBXZGJEBQAixMN4yyFw4\n", + "sr6uX2Tdy3zNtTQWrrltGiGETpIk/xXoRytJ0rkr5F18m/OBJUAyMALskSRp/yT3cSYDVABbJUla\n", + "O4n9VAJhSZKaTjq2WJKkLy/w+wnExuekFFCcjHFxsTqfDH1Olr4uVx/jn68BRiRJahdCrAM0wEeS\n", + "JJ2/ONPZ23xKkqTfjL+fdjofb+ei7/XppPvxti5b/+PfmfQxcJ7+Jm1MXM3jYbqNhSl5FlytxogQ\n", + "4n7gJ0AYeBv4fyRJkoQQn0mSNOWVC4QQH0uStH4S2/snYgrdBowCScCNxAbNjyaxHx9wpkFXLUlS\n", + "yiT18WsgAwgB6cDjkiQNnks3QojHge8DHuA54AkgSqyi879cRN9TNi4uRueTpc/J0Nel6OMMbfwb\n", + "oAX0gB9wAy4gR5Kkxy6wjR2AROwhCmABioAx4EdMQ52Pt39R9/p00v14O5et//F2LnsMXEAfl/0c\n", + "uBbHw3QaC1M2DiRJuipfwB5iockC+C/AO4AZ+GyS+9lxlpdzkvv54mKOX0Y/tUDyGY5vm8xrdtL7\n", + "2cDnwIJz6YbYjaYYH+DdxG5eAey+0uNiMnQ+WfqcDH1dij7OJTdw5KT3n19EGz8GfgesPknnH00H\n", + "nU+W3qeb7idL/5M1Bi6gj8t+DlyL42E6jYWpGgdXdZ4RSZK+ztn8b0KIWuBdYlbfZJJGzPoMnnxQ\n", + "CPHHSe7ngBDiaeBjYpZmIjHruXaS+7kZ8J3h+GSWg1UIITSSJAUlSaoTQtwB/CdQcY7vBKTYEp9P\n", + "CPHM19dbCHHRW2GTMC4mQ+eTpc/J0Nel6OObKE96/3+d9P6Cl1YlSfp/hRBaYLMQ4ntAArGl3umg\n", + "c5i8e3066R4mR/8wCWPgApiU58A1OB6m01iYmnFwOZZMPF/AnwD53ziWDfx/k9zPRs5skc6bgnOa\n", + "S8yS/wtiS5U18b7Ol3geiwDLN46pgPvP8Z1HANU3jmmA//tKj4vJ0vl00eel6OMMbVScRT+3XaJM\n", + "auBZYkvocdf5ZOp9Oul+svQ/FWPgLH1c9nNAHg9TOxamahxctT4j30QI8aIkSQ9cgX5ekiTp/qnu\n", + "53pnsq7zZIwLWedXhumk88mUR+bSmQwdyOPh6uBaCu3NvEL9WK9QP9c7k3WdJ2NcyDq/MkwnnYOs\n", + "9+nAZOhAHg9XAdeSMSIjIyMjIyNzFSIbIzIyMjIyMjJxRTZGZGRkZGRkZOLKteTAapEkyXat9HO9\n", + "M1nXeTLakXV+ZZhOOp/MdmQunel0/8rjYWq5ZowRGRkZGRkZmasTeZtGRkZGRkZGJq7IxoiMjIyM\n", + "jIxMXJGNERkZGRkZGZm4Ihsj0wghxAYhRJMQ4rgQ4ufxlkdm6hFCPCeEsAkhjsRbFpkrgxAiVwjx\n", + "mRCiQQhRL4T403jLJDP1CCF0Qoi9QohDQoijQoi/i7dM0wnZgXWaIIRQAseAtUAv8BWxegGNcRVM\n", + "ZkoRQtwAjAH/IUlSVbzlkZl6hBBWwCpJ0iEhRAJwALhdvtevfYQQBkmSvEIIFbAT+KkkSTvjLdd0\n", + "QF4ZmT4sBFokSeqQJCkEvAx8K84yyUwxkiTtAJzxlkPmyiFJ0oAkSYfG348BjUBWfKWSuRJIkuQd\n", + "f6shVv3WEUdxphWyMTJ9yAa6T/p/z/gxGRmZaxQhRAFQA+yNryQyVwIhhEIIcQiwAZ9JknQ03jJN\n", + "F2RjZPog75fJyFxHjG/RvA78aHyFROYaR5KkqCRJc4AcYIUQYlWcRZo2yMbI9KEXyD3p/7nEVkdk\n", + "ZGSuMYQQauAN4D8lSXo73vLIXFkkSRoFPgDmx1uW6YJsjEwf9gOlQogCIYQGuBd4N84yycjITDJC\n", + "CAH8FjgqSdI/xVsemSuDECJNCJE8/l4PrAMOxleq6YNsjEwTJEkKAz8AtgJHgVdk7/prHyHES8Bu\n", + "YIYQolsI8Z14yyQz5SwDHgJWCyEOjr82xFsomSknE/h03GdkL/CeJEmfxFmmaYMc2isjIyMjIyMT\n", + "V+SVERkZGRkZGZm4IhsjMjIyMjIyMnFFNkZkZGRkZGRk4opsjMjIyMjIyMjEFdkYkZGRkZGRkYkr\n", + "sjEiIyMjIyMjE1dkY0RGRkZGRkYmrsjGiIyMjIyMjExc+f8Bo2OouhAS2pgAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "1 loops, best of 3: 499 ms per loop\n", - "Accuracy: 0.756\n" - ] - } - ], - "prompt_number": 3 - }, + "output_type": "display_data" + } + ], + "source": [ + "X, y = sklearn.datasets.make_classification(\n", + " n_samples=10000, n_features=4, n_redundant=0, n_informative=2, \n", + " n_clusters_per_class=2, hypercube=False, random_state=0\n", + ")\n", + "\n", + "# Split into train and test\n", + "X, Xt, y, yt = sklearn.cross_validation.train_test_split(X, y)\n", + "\n", + "# Visualize sample of the data\n", + "ind = np.random.permutation(X.shape[0])[:1000]\n", + "df = pd.DataFrame(X[ind])\n", + "_ = pd.scatter_matrix(df, figsize=(9, 9), diagonal='kde', marker='o', s=40, alpha=.4, c=y[ind])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Learn and evaluate scikit-learn's logistic regression with stochastic gradient descent (SGD) training. Time and check the classifier's accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Save the dataset to HDF5 for loading in Caffe." + "name": "stdout", + "output_type": "stream", + "text": [ + "1 loops, best of 3: 499 ms per loop\n", + "Accuracy: 0.756\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "# Write out the data to HDF5 files in a temp directory.\n", - "# This file is assumed to be caffe_root/examples/hdf5_classification.ipynb\n", - "dirname = os.path.abspath('./hdf5_classification/data')\n", - "if not os.path.exists(dirname):\n", - " os.makedirs(dirname)\n", - "\n", - "train_filename = os.path.join(dirname, 'train.h5')\n", - "test_filename = os.path.join(dirname, 'test.h5')\n", - "\n", - "# HDF5DataLayer source should be a file containing a list of HDF5 filenames.\n", - "# To show this off, we'll list the same data file twice.\n", - "with h5py.File(train_filename, 'w') as f:\n", - " f['data'] = X\n", - " f['label'] = y.astype(np.float32)\n", - "with open(os.path.join(dirname, 'train.txt'), 'w') as f:\n", - " f.write(train_filename + '\\n')\n", - " f.write(train_filename + '\\n')\n", - " \n", - "# HDF5 is pretty efficient, but can be further compressed.\n", - "comp_kwargs = {'compression': 'gzip', 'compression_opts': 1}\n", - "with h5py.File(test_filename, 'w') as f:\n", - " f.create_dataset('data', data=Xt, **comp_kwargs)\n", - " f.create_dataset('label', data=yt.astype(np.float32), **comp_kwargs)\n", - "with open(os.path.join(dirname, 'test.txt'), 'w') as f:\n", - " f.write(test_filename + '\\n')" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 4 - }, + } + ], + "source": [ + "# Train and test the scikit-learn SGD logistic regression.\n", + "clf = sklearn.linear_model.SGDClassifier(\n", + " loss='log', n_iter=1000, penalty='l2', alpha=1e-3, class_weight='auto')\n", + "\n", + "%timeit clf.fit(X, y)\n", + "yt_pred = clf.predict(Xt)\n", + "print('Accuracy: {:.3f}'.format(sklearn.metrics.accuracy_score(yt, yt_pred)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Save the dataset to HDF5 for loading in Caffe." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Write out the data to HDF5 files in a temp directory.\n", + "# This file is assumed to be caffe_root/examples/hdf5_classification.ipynb\n", + "dirname = os.path.abspath('./hdf5_classification/data')\n", + "if not os.path.exists(dirname):\n", + " os.makedirs(dirname)\n", + "\n", + "train_filename = os.path.join(dirname, 'train.h5')\n", + "test_filename = os.path.join(dirname, 'test.h5')\n", + "\n", + "# HDF5DataLayer source should be a file containing a list of HDF5 filenames.\n", + "# To show this off, we'll list the same data file twice.\n", + "with h5py.File(train_filename, 'w') as f:\n", + " f['data'] = X\n", + " f['label'] = y.astype(np.float32)\n", + "with open(os.path.join(dirname, 'train.txt'), 'w') as f:\n", + " f.write(train_filename + '\\n')\n", + " f.write(train_filename + '\\n')\n", + " \n", + "# HDF5 is pretty efficient, but can be further compressed.\n", + "comp_kwargs = {'compression': 'gzip', 'compression_opts': 1}\n", + "with h5py.File(test_filename, 'w') as f:\n", + " f.create_dataset('data', data=Xt, **comp_kwargs)\n", + " f.create_dataset('label', data=yt.astype(np.float32), **comp_kwargs)\n", + "with open(os.path.join(dirname, 'test.txt'), 'w') as f:\n", + " f.write(test_filename + '\\n')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Learn and evaluate logistic regression in Caffe." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Learn and evaluate logistic regression in Caffe." + "name": "stdout", + "output_type": "stream", + "text": [ + "1 loops, best of 3: 240 ms per loop\n", + "Accuracy: 0.752\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "def learn_and_test(solver_file):\n", - " caffe.set_mode_cpu()\n", - " solver = caffe.get_solver(solver_file)\n", - " solver.solve()\n", - "\n", - " accuracy = 0\n", - " test_iters = int(len(Xt) / solver.test_nets[0].blobs['data'].num)\n", - " for i in range(test_iters):\n", - " solver.test_nets[0].forward()\n", - " accuracy += solver.test_nets[0].blobs['accuracy'].data\n", - " accuracy /= test_iters\n", - " return accuracy\n", - "\n", - "%timeit learn_and_test('hdf5_classification/solver.prototxt')\n", - "acc = learn_and_test('hdf5_classification/solver.prototxt')\n", - "print(\"Accuracy: {:.3f}\".format(acc))" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "1 loops, best of 3: 240 ms per loop\n", - "Accuracy: 0.752" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "\n" - ] - } - ], - "prompt_number": 5 - }, + } + ], + "source": [ + "def learn_and_test(solver_file):\n", + " caffe.set_mode_cpu()\n", + " solver = caffe.get_solver(solver_file)\n", + " solver.solve()\n", + "\n", + " accuracy = 0\n", + " test_iters = int(len(Xt) / solver.test_nets[0].blobs['data'].num)\n", + " for i in range(test_iters):\n", + " solver.test_nets[0].forward()\n", + " accuracy += solver.test_nets[0].blobs['accuracy'].data\n", + " accuracy /= test_iters\n", + " return accuracy\n", + "\n", + "%timeit learn_and_test('hdf5_classification/solver.prototxt')\n", + "acc = learn_and_test('hdf5_classification/solver.prototxt')\n", + "print(\"Accuracy: {:.3f}\".format(acc))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Do the same through the command line interface for detailed output on the model and solving." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Do the same through the command line interface for detailed output on the model and solving." + "name": "stdout", + "output_type": "stream", + "text": [ + "I0307 01:34:29.141863 2099749632 caffe.cpp:103] Use CPU.\n", + "I0307 01:34:29.418283 2099749632 caffe.cpp:107] Starting Optimization\n", + "I0307 01:34:29.418323 2099749632 solver.cpp:32] Initializing solver from parameters: \n", + "test_iter: 250\n", + "test_interval: 1000\n", + "base_lr: 0.01\n", + "display: 1000\n", + "max_iter: 10000\n", + "lr_policy: \"step\"\n", + "gamma: 0.1\n", + "momentum: 0.9\n", + "weight_decay: 0.0005\n", + "stepsize: 5000\n", + "snapshot: 10000\n", + "snapshot_prefix: \"hdf5_classification/data/train\"\n", + "solver_mode: CPU\n", + "net: \"hdf5_classification/train_val.prototxt\"\n", + "I0307 01:34:29.418416 2099749632 solver.cpp:70] Creating training net from net file: hdf5_classification/train_val.prototxt\n", + "I0307 01:34:29.418583 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer data\n", + "I0307 01:34:29.418598 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer accuracy\n", + "I0307 01:34:29.418608 2099749632 net.cpp:42] Initializing net from parameters: \n", + "name: \"LogisticRegressionNet\"\n", + "state {\n", + " phase: TRAIN\n", + "}\n", + "layer {\n", + " name: \"data\"\n", + " type: \"HDF5Data\"\n", + " top: \"data\"\n", + " top: \"label\"\n", + " include {\n", + " phase: TRAIN\n", + " }\n", + " hdf5_data_param {\n", + " source: \"hdf5_classification/data/train.txt\"\n", + " batch_size: 10\n", + " }\n", + "}\n", + "layer {\n", + " name: \"fc1\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"data\"\n", + " top: \"fc1\"\n", + " param {\n", + " lr_mult: 1\n", + " decay_mult: 1\n", + " }\n", + " param {\n", + " lr_mult: 2\n", + " decay_mult: 0\n", + " }\n", + " inner_product_param {\n", + " num_output: 2\n", + " weight_filler {\n", + " type: \"gaussian\"\n", + " std: 0.01\n", + " }\n", + " bias_filler {\n", + " type: \"constant\"\n", + " value: 0\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"loss\"\n", + " type: \"SoftmaxWithLoss\"\n", + " bottom: \"fc1\"\n", + " bottom: \"label\"\n", + " top: \"loss\"\n", + "}\n", + "I0307 01:34:29.418692 2099749632 layer_factory.hpp:74] Creating layer data\n", + "I0307 01:34:29.418853 2099749632 net.cpp:84] Creating Layer data\n", + "I0307 01:34:29.418879 2099749632 net.cpp:338] data -> data\n", + "I0307 01:34:29.418905 2099749632 net.cpp:338] data -> label\n", + "I0307 01:34:29.418918 2099749632 net.cpp:113] Setting up data\n", + "I0307 01:34:29.418926 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/train.txt\n", + "I0307 01:34:29.418992 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 2\n", + "I0307 01:34:29.420812 2099749632 net.cpp:120] Top shape: 10 4 (40)\n", + "I0307 01:34:29.420841 2099749632 net.cpp:120] Top shape: 10 (10)\n", + "I0307 01:34:29.420852 2099749632 layer_factory.hpp:74] Creating layer fc1\n", + "I0307 01:34:29.420866 2099749632 net.cpp:84] Creating Layer fc1\n", + "I0307 01:34:29.420872 2099749632 net.cpp:380] fc1 <- data\n", + "I0307 01:34:29.420882 2099749632 net.cpp:338] fc1 -> fc1\n", + "I0307 01:34:29.420894 2099749632 net.cpp:113] Setting up fc1\n", + "I0307 01:34:29.425689 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", + "I0307 01:34:29.425709 2099749632 layer_factory.hpp:74] Creating layer loss\n", + "I0307 01:34:29.425724 2099749632 net.cpp:84] Creating Layer loss\n", + "I0307 01:34:29.425731 2099749632 net.cpp:380] loss <- fc1\n", + "I0307 01:34:29.425739 2099749632 net.cpp:380] loss <- label\n", + "I0307 01:34:29.425747 2099749632 net.cpp:338] loss -> loss\n", + "I0307 01:34:29.425756 2099749632 net.cpp:113] Setting up loss\n", + "I0307 01:34:29.425767 2099749632 layer_factory.hpp:74] Creating layer loss\n", + "I0307 01:34:29.425781 2099749632 net.cpp:120] Top shape: (1)\n", + "I0307 01:34:29.425789 2099749632 net.cpp:122] with loss weight 1\n", + "I0307 01:34:29.425801 2099749632 net.cpp:167] loss needs backward computation.\n", + "I0307 01:34:29.425808 2099749632 net.cpp:167] fc1 needs backward computation.\n", + "I0307 01:34:29.425815 2099749632 net.cpp:169] data does not need backward computation.\n", + "I0307 01:34:29.425822 2099749632 net.cpp:205] This network produces output loss\n", + "I0307 01:34:29.425829 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", + "I0307 01:34:29.425837 2099749632 net.cpp:217] Network initialization done.\n", + "I0307 01:34:29.425843 2099749632 net.cpp:218] Memory required for data: 284\n", + "I0307 01:34:29.425961 2099749632 solver.cpp:154] Creating test net (#0) specified by net file: hdf5_classification/train_val.prototxt\n", + "I0307 01:34:29.425984 2099749632 net.cpp:257] The NetState phase (1) differed from the phase (0) specified by a rule in layer data\n", + "I0307 01:34:29.425997 2099749632 net.cpp:42] Initializing net from parameters: \n", + "name: \"LogisticRegressionNet\"\n", + "state {\n", + " phase: TEST\n", + "}\n", + "layer {\n", + " name: \"data\"\n", + " type: \"HDF5Data\"\n", + " top: \"data\"\n", + " top: \"label\"\n", + " include {\n", + " phase: TEST\n", + " }\n", + " hdf5_data_param {\n", + " source: \"hdf5_classification/data/test.txt\"\n", + " batch_size: 10\n", + " }\n", + "}\n", + "layer {\n", + " name: \"fc1\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"data\"\n", + " top: \"fc1\"\n", + " param {\n", + " lr_mult: 1\n", + " decay_mult: 1\n", + " }\n", + " param {\n", + " lr_mult: 2\n", + " decay_mult: 0\n", + " }\n", + " inner_product_param {\n", + " num_output: 2\n", + " weight_filler {\n", + " type: \"gaussian\"\n", + " std: 0.01\n", + " }\n", + " bias_filler {\n", + " type: \"constant\"\n", + " value: 0\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"loss\"\n", + " type: \"SoftmaxWithLoss\"\n", + " bottom: \"fc1\"\n", + " bottom: \"label\"\n", + " top: \"loss\"\n", + "}\n", + "layer {\n", + " name: \"accuracy\"\n", + " type: \"Accuracy\"\n", + " bottom: \"fc1\"\n", + " bottom: \"label\"\n", + " top: \"accuracy\"\n", + " include {\n", + " phase: TEST\n", + " }\n", + "}\n", + "I0307 01:34:29.426126 2099749632 layer_factory.hpp:74] Creating layer data\n", + "I0307 01:34:29.426311 2099749632 net.cpp:84] Creating Layer data\n", + "I0307 01:34:29.426331 2099749632 net.cpp:338] data -> data\n", + "I0307 01:34:29.426343 2099749632 net.cpp:338] data -> label\n", + "I0307 01:34:29.426354 2099749632 net.cpp:113] Setting up data\n", + "I0307 01:34:29.426362 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/test.txt\n", + "I0307 01:34:29.426484 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 1\n", + "I0307 01:34:29.427692 2099749632 net.cpp:120] Top shape: 10 4 (40)\n", + "I0307 01:34:29.427711 2099749632 net.cpp:120] Top shape: 10 (10)\n", + "I0307 01:34:29.427721 2099749632 layer_factory.hpp:74] Creating layer label_data_1_split\n", + "I0307 01:34:29.427731 2099749632 net.cpp:84] Creating Layer label_data_1_split\n", + "I0307 01:34:29.427738 2099749632 net.cpp:380] label_data_1_split <- label\n", + "I0307 01:34:29.427747 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_0\n", + "I0307 01:34:29.427759 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_1\n", + "I0307 01:34:29.427768 2099749632 net.cpp:113] Setting up label_data_1_split\n", + "I0307 01:34:29.427777 2099749632 net.cpp:120] Top shape: 10 (10)\n", + "I0307 01:34:29.427784 2099749632 net.cpp:120] Top shape: 10 (10)\n", + "I0307 01:34:29.427791 2099749632 layer_factory.hpp:74] Creating layer fc1\n", + "I0307 01:34:29.427804 2099749632 net.cpp:84] Creating Layer fc1\n", + "I0307 01:34:29.427813 2099749632 net.cpp:380] fc1 <- data\n", + "I0307 01:34:29.427821 2099749632 net.cpp:338] fc1 -> fc1\n", + "I0307 01:34:29.427831 2099749632 net.cpp:113] Setting up fc1\n", + "I0307 01:34:29.427845 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", + "I0307 01:34:29.427857 2099749632 layer_factory.hpp:74] Creating layer fc1_fc1_0_split\n", + "I0307 01:34:29.427866 2099749632 net.cpp:84] Creating Layer fc1_fc1_0_split\n", + "I0307 01:34:29.427872 2099749632 net.cpp:380] fc1_fc1_0_split <- fc1\n", + "I0307 01:34:29.427881 2099749632 net.cpp:338] fc1_fc1_0_split -> fc1_fc1_0_split_0\n", + "I0307 01:34:29.427891 2099749632 net.cpp:338] fc1_fc1_0_split -> fc1_fc1_0_split_1\n", + "I0307 01:34:29.427942 2099749632 net.cpp:113] Setting up fc1_fc1_0_split\n", + "I0307 01:34:29.427955 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", + "I0307 01:34:29.427965 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", + "I0307 01:34:29.427976 2099749632 layer_factory.hpp:74] Creating layer loss\n", + "I0307 01:34:29.427991 2099749632 net.cpp:84] Creating Layer loss\n", + "I0307 01:34:29.428001 2099749632 net.cpp:380] loss <- fc1_fc1_0_split_0\n", + "I0307 01:34:29.428009 2099749632 net.cpp:380] loss <- label_data_1_split_0\n", + "I0307 01:34:29.428017 2099749632 net.cpp:338] loss -> loss\n", + "I0307 01:34:29.428026 2099749632 net.cpp:113] Setting up loss\n", + "I0307 01:34:29.428035 2099749632 layer_factory.hpp:74] Creating layer loss\n", + "I0307 01:34:29.428048 2099749632 net.cpp:120] Top shape: (1)\n", + "I0307 01:34:29.428056 2099749632 net.cpp:122] with loss weight 1\n", + "I0307 01:34:29.428064 2099749632 layer_factory.hpp:74] Creating layer accuracy\n", + "I0307 01:34:29.428076 2099749632 net.cpp:84] Creating Layer accuracy\n", + "I0307 01:34:29.428084 2099749632 net.cpp:380] accuracy <- fc1_fc1_0_split_1\n", + "I0307 01:34:29.428092 2099749632 net.cpp:380] accuracy <- label_data_1_split_1\n", + "I0307 01:34:29.428102 2099749632 net.cpp:338] accuracy -> accuracy\n", + "I0307 01:34:29.428131 2099749632 net.cpp:113] Setting up accuracy\n", + "I0307 01:34:29.428140 2099749632 net.cpp:120] Top shape: (1)\n", + "I0307 01:34:29.428148 2099749632 net.cpp:169] accuracy does not need backward computation.\n", + "I0307 01:34:29.428154 2099749632 net.cpp:167] loss needs backward computation.\n", + "I0307 01:34:29.428161 2099749632 net.cpp:167] fc1_fc1_0_split needs backward computation.\n", + "I0307 01:34:29.428167 2099749632 net.cpp:167] fc1 needs backward computation.\n", + "I0307 01:34:29.428174 2099749632 net.cpp:169] label_data_1_split does not need backward computation.\n", + "I0307 01:34:29.428181 2099749632 net.cpp:169] data does not need backward computation.\n", + "I0307 01:34:29.428189 2099749632 net.cpp:205] This network produces output accuracy\n", + "I0307 01:34:29.428324 2099749632 net.cpp:205] This network produces output loss\n", + "I0307 01:34:29.428342 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", + "I0307 01:34:29.428350 2099749632 net.cpp:217] Network initialization done.\n", + "I0307 01:34:29.428357 2099749632 net.cpp:218] Memory required for data: 528\n", + "I0307 01:34:29.428388 2099749632 solver.cpp:42] Solver scaffolding done.\n", + "I0307 01:34:29.428412 2099749632 solver.cpp:222] Solving LogisticRegressionNet\n", + "I0307 01:34:29.428421 2099749632 solver.cpp:223] Learning Rate Policy: step\n", + "I0307 01:34:29.428431 2099749632 solver.cpp:266] Iteration 0, Testing net (#0)\n", + "I0307 01:34:29.471674 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.4532\n", + "I0307 01:34:29.471724 2099749632 solver.cpp:315] Test net output #1: loss = 0.694067 (* 1 = 0.694067 loss)\n", + "I0307 01:34:29.471853 2099749632 solver.cpp:189] Iteration 0, loss = 0.692695\n", + "I0307 01:34:29.471878 2099749632 solver.cpp:204] Train net output #0: loss = 0.692695 (* 1 = 0.692695 loss)\n", + "I0307 01:34:29.471890 2099749632 solver.cpp:464] Iteration 0, lr = 0.01\n", + "I0307 01:34:29.483834 2099749632 solver.cpp:266] Iteration 1000, Testing net (#0)\n", + "I0307 01:34:29.486868 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7424\n", + "I0307 01:34:29.486896 2099749632 solver.cpp:315] Test net output #1: loss = 0.601764 (* 1 = 0.601764 loss)\n", + "I0307 01:34:29.486922 2099749632 solver.cpp:189] Iteration 1000, loss = 0.472665\n", + "I0307 01:34:29.486934 2099749632 solver.cpp:204] Train net output #0: loss = 0.472665 (* 1 = 0.472665 loss)\n", + "I0307 01:34:29.486944 2099749632 solver.cpp:464] Iteration 1000, lr = 0.01\n", + "I0307 01:34:29.498821 2099749632 solver.cpp:266] Iteration 2000, Testing net (#0)\n", + "I0307 01:34:29.501900 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7364\n", + "I0307 01:34:29.501941 2099749632 solver.cpp:315] Test net output #1: loss = 0.60818 (* 1 = 0.60818 loss)\n", + "I0307 01:34:29.501988 2099749632 solver.cpp:189] Iteration 2000, loss = 0.6863\n", + "I0307 01:34:29.502003 2099749632 solver.cpp:204] Train net output #0: loss = 0.6863 (* 1 = 0.6863 loss)\n", + "I0307 01:34:29.502013 2099749632 solver.cpp:464] Iteration 2000, lr = 0.01\n", + "I0307 01:34:29.513921 2099749632 solver.cpp:266] Iteration 3000, Testing net (#0)\n", + "I0307 01:34:29.517227 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.6964\n", + "I0307 01:34:29.517300 2099749632 solver.cpp:315] Test net output #1: loss = 0.604707 (* 1 = 0.604707 loss)\n", + "I0307 01:34:29.518105 2099749632 solver.cpp:189] Iteration 3000, loss = 0.617542\n", + "I0307 01:34:29.518154 2099749632 solver.cpp:204] Train net output #0: loss = 0.617542 (* 1 = 0.617542 loss)\n", + "I0307 01:34:29.518170 2099749632 solver.cpp:464] Iteration 3000, lr = 0.01\n", + "I0307 01:34:29.531672 2099749632 solver.cpp:266] Iteration 4000, Testing net (#0)\n", + "I0307 01:34:29.534873 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7424\n", + "I0307 01:34:29.534920 2099749632 solver.cpp:315] Test net output #1: loss = 0.601764 (* 1 = 0.601764 loss)\n", + "I0307 01:34:29.534950 2099749632 solver.cpp:189] Iteration 4000, loss = 0.472666\n", + "I0307 01:34:29.534962 2099749632 solver.cpp:204] Train net output #0: loss = 0.472665 (* 1 = 0.472665 loss)\n", + "I0307 01:34:29.534973 2099749632 solver.cpp:464] Iteration 4000, lr = 0.01\n", + "I0307 01:34:29.546567 2099749632 solver.cpp:266] Iteration 5000, Testing net (#0)\n", + "I0307 01:34:29.549762 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7364\n", + "I0307 01:34:29.549789 2099749632 solver.cpp:315] Test net output #1: loss = 0.60818 (* 1 = 0.60818 loss)\n", + "I0307 01:34:29.549815 2099749632 solver.cpp:189] Iteration 5000, loss = 0.686301\n", + "I0307 01:34:29.549828 2099749632 solver.cpp:204] Train net output #0: loss = 0.6863 (* 1 = 0.6863 loss)\n", + "I0307 01:34:29.549837 2099749632 solver.cpp:464] Iteration 5000, lr = 0.001\n", + "I0307 01:34:29.562142 2099749632 solver.cpp:266] Iteration 6000, Testing net (#0)\n", + "I0307 01:34:29.565335 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7476\n", + "I0307 01:34:29.565373 2099749632 solver.cpp:315] Test net output #1: loss = 0.59775 (* 1 = 0.59775 loss)\n", + "I0307 01:34:29.566051 2099749632 solver.cpp:189] Iteration 6000, loss = 0.664614\n", + "I0307 01:34:29.566086 2099749632 solver.cpp:204] Train net output #0: loss = 0.664614 (* 1 = 0.664614 loss)\n", + "I0307 01:34:29.566097 2099749632 solver.cpp:464] Iteration 6000, lr = 0.001\n", + "I0307 01:34:29.577900 2099749632 solver.cpp:266] Iteration 7000, Testing net (#0)\n", + "I0307 01:34:29.580993 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7524\n", + "I0307 01:34:29.581015 2099749632 solver.cpp:315] Test net output #1: loss = 0.597349 (* 1 = 0.597349 loss)\n", + "I0307 01:34:29.581038 2099749632 solver.cpp:189] Iteration 7000, loss = 0.456775\n", + "I0307 01:34:29.581050 2099749632 solver.cpp:204] Train net output #0: loss = 0.456774 (* 1 = 0.456774 loss)\n", + "I0307 01:34:29.581059 2099749632 solver.cpp:464] Iteration 7000, lr = 0.001\n", + "I0307 01:34:29.592854 2099749632 solver.cpp:266] Iteration 8000, Testing net (#0)\n", + "I0307 01:34:29.595973 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7568\n", + "I0307 01:34:29.596002 2099749632 solver.cpp:315] Test net output #1: loss = 0.597265 (* 1 = 0.597265 loss)\n", + "I0307 01:34:29.596027 2099749632 solver.cpp:189] Iteration 8000, loss = 0.673885\n", + "I0307 01:34:29.596040 2099749632 solver.cpp:204] Train net output #0: loss = 0.673885 (* 1 = 0.673885 loss)\n", + "I0307 01:34:29.596048 2099749632 solver.cpp:464] Iteration 8000, lr = 0.001\n", + "I0307 01:34:29.607822 2099749632 solver.cpp:266] Iteration 9000, Testing net (#0)\n", + "I0307 01:34:29.610930 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7432\n", + "I0307 01:34:29.610960 2099749632 solver.cpp:315] Test net output #1: loss = 0.597777 (* 1 = 0.597777 loss)\n", + "I0307 01:34:29.611558 2099749632 solver.cpp:189] Iteration 9000, loss = 0.66526\n", + "I0307 01:34:29.611583 2099749632 solver.cpp:204] Train net output #0: loss = 0.66526 (* 1 = 0.66526 loss)\n", + "I0307 01:34:29.611593 2099749632 solver.cpp:464] Iteration 9000, lr = 0.001\n", + "I0307 01:34:29.623009 2099749632 solver.cpp:334] Snapshotting to hdf5_classification/data/train_iter_10000.caffemodel\n", + "I0307 01:34:29.623209 2099749632 solver.cpp:342] Snapshotting solver state to hdf5_classification/data/train_iter_10000.solverstate\n", + "I0307 01:34:29.623319 2099749632 solver.cpp:248] Iteration 10000, loss = 0.457922\n", + "I0307 01:34:29.623333 2099749632 solver.cpp:266] Iteration 10000, Testing net (#0)\n", + "I0307 01:34:29.626454 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.752\n", + "I0307 01:34:29.626484 2099749632 solver.cpp:315] Test net output #1: loss = 0.597362 (* 1 = 0.597362 loss)\n", + "I0307 01:34:29.626493 2099749632 solver.cpp:253] Optimization Done.\n", + "I0307 01:34:29.626502 2099749632 caffe.cpp:121] Optimization Done.\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "!../build/tools/caffe train -solver hdf5_classification/solver.prototxt" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:29.141863 2099749632 caffe.cpp:103] Use CPU.\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:29.418283 2099749632 caffe.cpp:107] Starting Optimization\r\n", - "I0307 01:34:29.418323 2099749632 solver.cpp:32] Initializing solver from parameters: \r\n", - "test_iter: 250\r\n", - "test_interval: 1000\r\n", - "base_lr: 0.01\r\n", - "display: 1000\r\n", - "max_iter: 10000\r\n", - "lr_policy: \"step\"\r\n", - "gamma: 0.1\r\n", - "momentum: 0.9\r\n", - "weight_decay: 0.0005\r\n", - "stepsize: 5000\r\n", - "snapshot: 10000\r\n", - "snapshot_prefix: \"hdf5_classification/data/train\"\r\n", - "solver_mode: CPU\r\n", - "net: \"hdf5_classification/train_val.prototxt\"\r\n", - "I0307 01:34:29.418416 2099749632 solver.cpp:70] Creating training net from net file: hdf5_classification/train_val.prototxt\r\n", - "I0307 01:34:29.418583 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer data\r\n", - "I0307 01:34:29.418598 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer accuracy\r\n", - "I0307 01:34:29.418608 2099749632 net.cpp:42] Initializing net from parameters: \r\n", - "name: \"LogisticRegressionNet\"\r\n", - "state {\r\n", - " phase: TRAIN\r\n", - "}\r\n", - "layer {\r\n", - " name: \"data\"\r\n", - " type: \"HDF5Data\"\r\n", - " top: \"data\"\r\n", - " top: \"label\"\r\n", - " include {\r\n", - " phase: TRAIN\r\n", - " }\r\n", - " hdf5_data_param {\r\n", - " source: \"hdf5_classification/data/train.txt\"\r\n", - " batch_size: 10\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"fc1\"\r\n", - " type: \"InnerProduct\"\r\n", - " bottom: \"data\"\r\n", - " top: \"fc1\"\r\n", - " param {\r\n", - " lr_mult: 1\r\n", - " decay_mult: 1\r\n", - " }\r\n", - " param {\r\n", - " lr_mult: 2\r\n", - " decay_mult: 0\r\n", - " }\r\n", - " inner_product_param {\r\n", - " num_output: 2\r\n", - " weight_filler {\r\n", - " type: \"gaussian\"\r\n", - " std: 0.01\r\n", - " }\r\n", - " bias_filler {\r\n", - " type: \"constant\"\r\n", - " value: 0\r\n", - " }\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"loss\"\r\n", - " type: \"SoftmaxWithLoss\"\r\n", - " bottom: \"fc1\"\r\n", - " bottom: \"label\"\r\n", - " top: \"loss\"\r\n", - "}\r\n", - "I0307 01:34:29.418692 2099749632 layer_factory.hpp:74] Creating layer data\r\n", - "I0307 01:34:29.418853 2099749632 net.cpp:84] Creating Layer data\r\n", - "I0307 01:34:29.418879 2099749632 net.cpp:338] data -> data\r\n", - "I0307 01:34:29.418905 2099749632 net.cpp:338] data -> label\r\n", - "I0307 01:34:29.418918 2099749632 net.cpp:113] Setting up data\r\n", - "I0307 01:34:29.418926 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/train.txt\r\n", - "I0307 01:34:29.418992 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 2\r\n", - "I0307 01:34:29.420812 2099749632 net.cpp:120] Top shape: 10 4 (40)\r\n", - "I0307 01:34:29.420841 2099749632 net.cpp:120] Top shape: 10 (10)\r\n", - "I0307 01:34:29.420852 2099749632 layer_factory.hpp:74] Creating layer fc1\r\n", - "I0307 01:34:29.420866 2099749632 net.cpp:84] Creating Layer fc1\r\n", - "I0307 01:34:29.420872 2099749632 net.cpp:380] fc1 <- data\r\n", - "I0307 01:34:29.420882 2099749632 net.cpp:338] fc1 -> fc1\r\n", - "I0307 01:34:29.420894 2099749632 net.cpp:113] Setting up fc1\r\n", - "I0307 01:34:29.425689 2099749632 net.cpp:120] Top shape: 10 2 (20)\r\n", - "I0307 01:34:29.425709 2099749632 layer_factory.hpp:74] Creating layer loss\r\n", - "I0307 01:34:29.425724 2099749632 net.cpp:84] Creating Layer loss\r\n", - "I0307 01:34:29.425731 2099749632 net.cpp:380] loss <- fc1\r\n", - "I0307 01:34:29.425739 2099749632 net.cpp:380] loss <- label\r\n", - "I0307 01:34:29.425747 2099749632 net.cpp:338] loss -> loss\r\n", - "I0307 01:34:29.425756 2099749632 net.cpp:113] Setting up loss\r\n", - "I0307 01:34:29.425767 2099749632 layer_factory.hpp:74] Creating layer loss\r\n", - "I0307 01:34:29.425781 2099749632 net.cpp:120] Top shape: (1)\r\n", - "I0307 01:34:29.425789 2099749632 net.cpp:122] with loss weight 1\r\n", - "I0307 01:34:29.425801 2099749632 net.cpp:167] loss needs backward computation.\r\n", - "I0307 01:34:29.425808 2099749632 net.cpp:167] fc1 needs backward computation.\r\n", - "I0307 01:34:29.425815 2099749632 net.cpp:169] data does not need backward computation.\r\n", - "I0307 01:34:29.425822 2099749632 net.cpp:205] This network produces output loss\r\n", - "I0307 01:34:29.425829 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\r\n", - "I0307 01:34:29.425837 2099749632 net.cpp:217] Network initialization done.\r\n", - "I0307 01:34:29.425843 2099749632 net.cpp:218] Memory required for data: 284\r\n", - "I0307 01:34:29.425961 2099749632 solver.cpp:154] Creating test net (#0) specified by net file: hdf5_classification/train_val.prototxt\r\n", - "I0307 01:34:29.425984 2099749632 net.cpp:257] The NetState phase (1) differed from the phase (0) specified by a rule in layer data\r\n", - "I0307 01:34:29.425997 2099749632 net.cpp:42] Initializing net from parameters: \r\n", - "name: \"LogisticRegressionNet\"\r\n", - "state {\r\n", - " phase: TEST\r\n", - "}\r\n", - "layer {\r\n", - " name: \"data\"\r\n", - " type: \"HDF5Data\"\r\n", - " top: \"data\"\r\n", - " top: \"label\"\r\n", - " include {\r\n", - " phase: TEST\r\n", - " }\r\n", - " hdf5_data_param {\r\n", - " source: \"hdf5_classification/data/test.txt\"\r\n", - " batch_size: 10\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"fc1\"\r\n", - " type: \"InnerProduct\"\r\n", - " bottom: \"data\"\r\n", - " top: \"fc1\"\r\n", - " param {\r\n", - " lr_mult: 1\r\n", - " decay_mult: 1\r\n", - " }\r\n", - " param {\r\n", - " lr_mult: 2\r\n", - " decay_mult: 0\r\n", - " }\r\n", - " inner_product_param {\r\n", - " num_output: 2\r\n", - " weight_filler {\r\n", - " type: \"gaussian\"\r\n", - " std: 0.01\r\n", - " }\r\n", - " bias_filler {\r\n", - " type: \"constant\"\r\n", - " value: 0\r\n", - " }\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"loss\"\r\n", - " type: \"SoftmaxWithLoss\"\r\n", - " bottom: \"fc1\"\r\n", - " bottom: \"label\"\r\n", - " top: \"loss\"\r\n", - "}\r\n", - "layer {\r\n", - " name: \"accuracy\"\r\n", - " type: \"Accuracy\"\r\n", - " bottom: \"fc1\"\r\n", - " bottom: \"label\"\r\n", - " top: \"accuracy\"\r\n", - " include {\r\n", - " phase: TEST\r\n", - " }\r\n", - "}\r\n", - "I0307 01:34:29.426126 2099749632 layer_factory.hpp:74] Creating layer data\r\n", - "I0307 01:34:29.426311 2099749632 net.cpp:84] Creating Layer data\r\n", - "I0307 01:34:29.426331 2099749632 net.cpp:338] data -> data\r\n", - "I0307 01:34:29.426343 2099749632 net.cpp:338] data -> label\r\n", - "I0307 01:34:29.426354 2099749632 net.cpp:113] Setting up data\r\n", - "I0307 01:34:29.426362 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/test.txt\r\n", - "I0307 01:34:29.426484 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 1\r\n", - "I0307 01:34:29.427692 2099749632 net.cpp:120] Top shape: 10 4 (40)\r\n", - "I0307 01:34:29.427711 2099749632 net.cpp:120] Top shape: 10 (10)\r\n", - "I0307 01:34:29.427721 2099749632 layer_factory.hpp:74] Creating layer label_data_1_split\r\n", - "I0307 01:34:29.427731 2099749632 net.cpp:84] Creating Layer label_data_1_split\r\n", - "I0307 01:34:29.427738 2099749632 net.cpp:380] label_data_1_split <- label\r\n", - "I0307 01:34:29.427747 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_0\r\n", - "I0307 01:34:29.427759 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_1\r\n", - "I0307 01:34:29.427768 2099749632 net.cpp:113] Setting up label_data_1_split\r\n", - "I0307 01:34:29.427777 2099749632 net.cpp:120] Top shape: 10 (10)\r\n", - "I0307 01:34:29.427784 2099749632 net.cpp:120] Top shape: 10 (10)\r\n", - "I0307 01:34:29.427791 2099749632 layer_factory.hpp:74] Creating layer fc1\r\n", - "I0307 01:34:29.427804 2099749632 net.cpp:84] Creating Layer fc1\r\n", - "I0307 01:34:29.427813 2099749632 net.cpp:380] fc1 <- data\r\n", - "I0307 01:34:29.427821 2099749632 net.cpp:338] fc1 -> fc1\r\n", - "I0307 01:34:29.427831 2099749632 net.cpp:113] Setting up fc1\r\n", - "I0307 01:34:29.427845 2099749632 net.cpp:120] Top shape: 10 2 (20)\r\n", - "I0307 01:34:29.427857 2099749632 layer_factory.hpp:74] Creating layer fc1_fc1_0_split\r\n", - "I0307 01:34:29.427866 2099749632 net.cpp:84] Creating Layer fc1_fc1_0_split\r\n", - "I0307 01:34:29.427872 2099749632 net.cpp:380] fc1_fc1_0_split <- fc1\r\n", - "I0307 01:34:29.427881 2099749632 net.cpp:338] fc1_fc1_0_split -> fc1_fc1_0_split_0\r\n", - "I0307 01:34:29.427891 2099749632 net.cpp:338] fc1_fc1_0_split -> fc1_fc1_0_split_1\r\n", - "I0307 01:34:29.427942 2099749632 net.cpp:113] Setting up fc1_fc1_0_split\r\n", - "I0307 01:34:29.427955 2099749632 net.cpp:120] Top shape: 10 2 (20)\r\n", - "I0307 01:34:29.427965 2099749632 net.cpp:120] Top shape: 10 2 (20)\r\n", - "I0307 01:34:29.427976 2099749632 layer_factory.hpp:74] Creating layer loss\r\n", - "I0307 01:34:29.427991 2099749632 net.cpp:84] Creating Layer loss\r\n", - "I0307 01:34:29.428001 2099749632 net.cpp:380] loss <- fc1_fc1_0_split_0\r\n", - "I0307 01:34:29.428009 2099749632 net.cpp:380] loss <- label_data_1_split_0\r\n", - "I0307 01:34:29.428017 2099749632 net.cpp:338] loss -> loss\r\n", - "I0307 01:34:29.428026 2099749632 net.cpp:113] Setting up loss\r\n", - "I0307 01:34:29.428035 2099749632 layer_factory.hpp:74] Creating layer loss\r\n", - "I0307 01:34:29.428048 2099749632 net.cpp:120] Top shape: (1)\r\n", - "I0307 01:34:29.428056 2099749632 net.cpp:122] with loss weight 1\r\n", - "I0307 01:34:29.428064 2099749632 layer_factory.hpp:74] Creating layer accuracy\r\n", - "I0307 01:34:29.428076 2099749632 net.cpp:84] Creating Layer accuracy\r\n", - "I0307 01:34:29.428084 2099749632 net.cpp:380] accuracy <- fc1_fc1_0_split_1\r\n", - "I0307 01:34:29.428092 2099749632 net.cpp:380] accuracy <- label_data_1_split_1\r\n", - "I0307 01:34:29.428102 2099749632 net.cpp:338] accuracy -> accuracy\r\n", - "I0307 01:34:29.428131 2099749632 net.cpp:113] Setting up accuracy\r\n", - "I0307 01:34:29.428140 2099749632 net.cpp:120] Top shape: (1)\r\n", - "I0307 01:34:29.428148 2099749632 net.cpp:169] accuracy does not need backward computation.\r\n", - "I0307 01:34:29.428154 2099749632 net.cpp:167] loss needs backward computation.\r\n", - "I0307 01:34:29.428161 2099749632 net.cpp:167] fc1_fc1_0_split needs backward computation.\r\n", - "I0307 01:34:29.428167 2099749632 net.cpp:167] fc1 needs backward computation.\r\n", - "I0307 01:34:29.428174 2099749632 net.cpp:169] label_data_1_split does not need backward computation.\r\n", - "I0307 01:34:29.428181 2099749632 net.cpp:169] data does not need backward computation.\r\n", - "I0307 01:34:29.428189 2099749632 net.cpp:205] This network produces output accuracy\r\n", - "I0307 01:34:29.428324 2099749632 net.cpp:205] This network produces output loss\r\n", - "I0307 01:34:29.428342 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\r\n", - "I0307 01:34:29.428350 2099749632 net.cpp:217] Network initialization done.\r\n", - "I0307 01:34:29.428357 2099749632 net.cpp:218] Memory required for data: 528\r\n", - "I0307 01:34:29.428388 2099749632 solver.cpp:42] Solver scaffolding done.\r\n", - "I0307 01:34:29.428412 2099749632 solver.cpp:222] Solving LogisticRegressionNet\r\n", - "I0307 01:34:29.428421 2099749632 solver.cpp:223] Learning Rate Policy: step\r\n", - "I0307 01:34:29.428431 2099749632 solver.cpp:266] Iteration 0, Testing net (#0)\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:29.471674 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.4532\r\n", - "I0307 01:34:29.471724 2099749632 solver.cpp:315] Test net output #1: loss = 0.694067 (* 1 = 0.694067 loss)\r\n", - "I0307 01:34:29.471853 2099749632 solver.cpp:189] Iteration 0, loss = 0.692695\r\n", - "I0307 01:34:29.471878 2099749632 solver.cpp:204] Train net output #0: loss = 0.692695 (* 1 = 0.692695 loss)\r\n", - "I0307 01:34:29.471890 2099749632 solver.cpp:464] Iteration 0, lr = 0.01\r\n", - "I0307 01:34:29.483834 2099749632 solver.cpp:266] Iteration 1000, Testing net (#0)\r\n", - "I0307 01:34:29.486868 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7424\r\n", - "I0307 01:34:29.486896 2099749632 solver.cpp:315] Test net output #1: loss = 0.601764 (* 1 = 0.601764 loss)\r\n", - "I0307 01:34:29.486922 2099749632 solver.cpp:189] Iteration 1000, loss = 0.472665\r\n", - "I0307 01:34:29.486934 2099749632 solver.cpp:204] Train net output #0: loss = 0.472665 (* 1 = 0.472665 loss)\r\n", - "I0307 01:34:29.486944 2099749632 solver.cpp:464] Iteration 1000, lr = 0.01\r\n", - "I0307 01:34:29.498821 2099749632 solver.cpp:266] Iteration 2000, Testing net (#0)\r\n", - "I0307 01:34:29.501900 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7364\r\n", - "I0307 01:34:29.501941 2099749632 solver.cpp:315] Test net output #1: loss = 0.60818 (* 1 = 0.60818 loss)\r\n", - "I0307 01:34:29.501988 2099749632 solver.cpp:189] Iteration 2000, loss = 0.6863\r\n", - "I0307 01:34:29.502003 2099749632 solver.cpp:204] Train net output #0: loss = 0.6863 (* 1 = 0.6863 loss)\r\n", - "I0307 01:34:29.502013 2099749632 solver.cpp:464] Iteration 2000, lr = 0.01\r\n", - "I0307 01:34:29.513921 2099749632 solver.cpp:266] Iteration 3000, Testing net (#0)\r\n", - "I0307 01:34:29.517227 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.6964\r\n", - "I0307 01:34:29.517300 2099749632 solver.cpp:315] Test net output #1: loss = 0.604707 (* 1 = 0.604707 loss)\r\n", - "I0307 01:34:29.518105 2099749632 solver.cpp:189] Iteration 3000, loss = 0.617542\r\n", - "I0307 01:34:29.518154 2099749632 solver.cpp:204] Train net output #0: loss = 0.617542 (* 1 = 0.617542 loss)\r\n", - "I0307 01:34:29.518170 2099749632 solver.cpp:464] Iteration 3000, lr = 0.01\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:29.531672 2099749632 solver.cpp:266] Iteration 4000, Testing net (#0)\r\n", - "I0307 01:34:29.534873 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7424\r\n", - "I0307 01:34:29.534920 2099749632 solver.cpp:315] Test net output #1: loss = 0.601764 (* 1 = 0.601764 loss)\r\n", - "I0307 01:34:29.534950 2099749632 solver.cpp:189] Iteration 4000, loss = 0.472666\r\n", - "I0307 01:34:29.534962 2099749632 solver.cpp:204] Train net output #0: loss = 0.472665 (* 1 = 0.472665 loss)\r\n", - "I0307 01:34:29.534973 2099749632 solver.cpp:464] Iteration 4000, lr = 0.01\r\n", - "I0307 01:34:29.546567 2099749632 solver.cpp:266] Iteration 5000, Testing net (#0)\r\n", - "I0307 01:34:29.549762 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7364\r\n", - "I0307 01:34:29.549789 2099749632 solver.cpp:315] Test net output #1: loss = 0.60818 (* 1 = 0.60818 loss)\r\n", - "I0307 01:34:29.549815 2099749632 solver.cpp:189] Iteration 5000, loss = 0.686301\r\n", - "I0307 01:34:29.549828 2099749632 solver.cpp:204] Train net output #0: loss = 0.6863 (* 1 = 0.6863 loss)\r\n", - "I0307 01:34:29.549837 2099749632 solver.cpp:464] Iteration 5000, lr = 0.001\r\n", - "I0307 01:34:29.562142 2099749632 solver.cpp:266] Iteration 6000, Testing net (#0)\r\n", - "I0307 01:34:29.565335 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7476\r\n", - "I0307 01:34:29.565373 2099749632 solver.cpp:315] Test net output #1: loss = 0.59775 (* 1 = 0.59775 loss)\r\n", - "I0307 01:34:29.566051 2099749632 solver.cpp:189] Iteration 6000, loss = 0.664614\r\n", - "I0307 01:34:29.566086 2099749632 solver.cpp:204] Train net output #0: loss = 0.664614 (* 1 = 0.664614 loss)\r\n", - "I0307 01:34:29.566097 2099749632 solver.cpp:464] Iteration 6000, lr = 0.001\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:29.577900 2099749632 solver.cpp:266] Iteration 7000, Testing net (#0)\r\n", - "I0307 01:34:29.580993 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7524\r\n", - "I0307 01:34:29.581015 2099749632 solver.cpp:315] Test net output #1: loss = 0.597349 (* 1 = 0.597349 loss)\r\n", - "I0307 01:34:29.581038 2099749632 solver.cpp:189] Iteration 7000, loss = 0.456775\r\n", - "I0307 01:34:29.581050 2099749632 solver.cpp:204] Train net output #0: loss = 0.456774 (* 1 = 0.456774 loss)\r\n", - "I0307 01:34:29.581059 2099749632 solver.cpp:464] Iteration 7000, lr = 0.001\r\n", - "I0307 01:34:29.592854 2099749632 solver.cpp:266] Iteration 8000, Testing net (#0)\r\n", - "I0307 01:34:29.595973 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7568\r\n", - "I0307 01:34:29.596002 2099749632 solver.cpp:315] Test net output #1: loss = 0.597265 (* 1 = 0.597265 loss)\r\n", - "I0307 01:34:29.596027 2099749632 solver.cpp:189] Iteration 8000, loss = 0.673885\r\n", - "I0307 01:34:29.596040 2099749632 solver.cpp:204] Train net output #0: loss = 0.673885 (* 1 = 0.673885 loss)\r\n", - "I0307 01:34:29.596048 2099749632 solver.cpp:464] Iteration 8000, lr = 0.001\r\n", - "I0307 01:34:29.607822 2099749632 solver.cpp:266] Iteration 9000, Testing net (#0)\r\n", - "I0307 01:34:29.610930 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7432\r\n", - "I0307 01:34:29.610960 2099749632 solver.cpp:315] Test net output #1: loss = 0.597777 (* 1 = 0.597777 loss)\r\n", - "I0307 01:34:29.611558 2099749632 solver.cpp:189] Iteration 9000, loss = 0.66526\r\n", - "I0307 01:34:29.611583 2099749632 solver.cpp:204] Train net output #0: loss = 0.66526 (* 1 = 0.66526 loss)\r\n", - "I0307 01:34:29.611593 2099749632 solver.cpp:464] Iteration 9000, lr = 0.001\r\n", - "I0307 01:34:29.623009 2099749632 solver.cpp:334] Snapshotting to hdf5_classification/data/train_iter_10000.caffemodel\r\n", - "I0307 01:34:29.623209 2099749632 solver.cpp:342] Snapshotting solver state to hdf5_classification/data/train_iter_10000.solverstate\r\n", - "I0307 01:34:29.623319 2099749632 solver.cpp:248] Iteration 10000, loss = 0.457922\r\n", - "I0307 01:34:29.623333 2099749632 solver.cpp:266] Iteration 10000, Testing net (#0)\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:29.626454 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.752\r\n", - "I0307 01:34:29.626484 2099749632 solver.cpp:315] Test net output #1: loss = 0.597362 (* 1 = 0.597362 loss)\r\n", - "I0307 01:34:29.626493 2099749632 solver.cpp:253] Optimization Done.\r\n", - "I0307 01:34:29.626502 2099749632 caffe.cpp:121] Optimization Done.\r\n" - ] - } - ], - "prompt_number": 6 - }, + } + ], + "source": [ + "!../build/tools/caffe train -solver hdf5_classification/solver.prototxt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you look at output or the `train_val.prototxt`, you'll see that the model is simple logistic regression.\n", + "We can make it a little more advanced by introducing a non-linearity between weights that take the input and weights that give the output -- now we have a two-layer network.\n", + "That network is given in `train_val2.prototxt`, and that's the only change made in `solver2.prototxt` which we will now use.\n", + "\n", + "The final accuracy of the new network be higher than logistic regression!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you look at output or the `train_val.prototxt`, you'll see that the model is simple logistic regression.\n", - "We can make it a little more advanced by introducing a non-linearity between weights that take the input and weights that give the output -- now we have a two-layer network.\n", - "That network is given in `train_val2.prototxt`, and that's the only change made in `solver2.prototxt` which we will now use.\n", - "\n", - "The final accuracy of the new network be higher than logistic regression!" + "name": "stdout", + "output_type": "stream", + "text": [ + "1 loops, best of 3: 333 ms per loop\n", + "Accuracy: 0.818\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "def learn_and_test(solver_file):\n", - " caffe.set_mode_cpu()\n", - " solver = caffe.get_solver(solver_file)\n", - " solver.solve()\n", - "\n", - " accuracy = 0\n", - " test_iters = int(len(Xt) / solver.test_nets[0].blobs['data'].num)\n", - " for i in range(test_iters):\n", - " solver.test_nets[0].forward()\n", - " accuracy += solver.test_nets[0].blobs['accuracy'].data\n", - " accuracy /= test_iters\n", - " return accuracy\n", - "\n", - "%timeit learn_and_test('hdf5_classification/solver2.prototxt')\n", - "acc = learn_and_test('hdf5_classification/solver2.prototxt')\n", - "print(\"Accuracy: {:.3f}\".format(acc))" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "1 loops, best of 3: 333 ms per loop\n", - "Accuracy: 0.818" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "\n" - ] - } - ], - "prompt_number": 7 - }, + } + ], + "source": [ + "def learn_and_test(solver_file):\n", + " caffe.set_mode_cpu()\n", + " solver = caffe.get_solver(solver_file)\n", + " solver.solve()\n", + "\n", + " accuracy = 0\n", + " test_iters = int(len(Xt) / solver.test_nets[0].blobs['data'].num)\n", + " for i in range(test_iters):\n", + " solver.test_nets[0].forward()\n", + " accuracy += solver.test_nets[0].blobs['accuracy'].data\n", + " accuracy /= test_iters\n", + " return accuracy\n", + "\n", + "%timeit learn_and_test('hdf5_classification/solver2.prototxt')\n", + "acc = learn_and_test('hdf5_classification/solver2.prototxt')\n", + "print(\"Accuracy: {:.3f}\".format(acc))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Do the same through the command line interface for detailed output on the model and solving." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Do the same through the command line interface for detailed output on the model and solving." + "name": "stdout", + "output_type": "stream", + "text": [ + "I0307 01:34:31.589234 2099749632 caffe.cpp:103] Use CPU.\n", + "I0307 01:34:31.872560 2099749632 caffe.cpp:107] Starting Optimization\n", + "I0307 01:34:31.872596 2099749632 solver.cpp:32] Initializing solver from parameters: \n", + "test_iter: 250\n", + "test_interval: 1000\n", + "base_lr: 0.01\n", + "display: 1000\n", + "max_iter: 10000\n", + "lr_policy: \"step\"\n", + "gamma: 0.1\n", + "momentum: 0.9\n", + "weight_decay: 0.0005\n", + "stepsize: 5000\n", + "snapshot: 10000\n", + "snapshot_prefix: \"hdf5_classification/data/train\"\n", + "solver_mode: CPU\n", + "net: \"hdf5_classification/train_val2.prototxt\"\n", + "I0307 01:34:31.872687 2099749632 solver.cpp:70] Creating training net from net file: hdf5_classification/train_val2.prototxt\n", + "I0307 01:34:31.872865 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer data\n", + "I0307 01:34:31.872882 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer accuracy\n", + "I0307 01:34:31.872891 2099749632 net.cpp:42] Initializing net from parameters: \n", + "name: \"LogisticRegressionNet\"\n", + "state {\n", + " phase: TRAIN\n", + "}\n", + "layer {\n", + " name: \"data\"\n", + " type: \"HDF5Data\"\n", + " top: \"data\"\n", + " top: \"label\"\n", + " include {\n", + " phase: TRAIN\n", + " }\n", + " hdf5_data_param {\n", + " source: \"hdf5_classification/data/train.txt\"\n", + " batch_size: 10\n", + " }\n", + "}\n", + "layer {\n", + " name: \"fc1\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"data\"\n", + " top: \"fc1\"\n", + " param {\n", + " lr_mult: 1\n", + " decay_mult: 1\n", + " }\n", + " param {\n", + " lr_mult: 2\n", + " decay_mult: 0\n", + " }\n", + " inner_product_param {\n", + " num_output: 40\n", + " weight_filler {\n", + " type: \"gaussian\"\n", + " std: 0.01\n", + " }\n", + " bias_filler {\n", + " type: \"constant\"\n", + " value: 0\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"relu1\"\n", + " type: \"ReLU\"\n", + " bottom: \"fc1\"\n", + " top: \"fc1\"\n", + "}\n", + "layer {\n", + " name: \"fc2\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"fc1\"\n", + " top: \"fc2\"\n", + " param {\n", + " lr_mult: 1\n", + " decay_mult: 1\n", + " }\n", + " param {\n", + " lr_mult: 2\n", + " decay_mult: 0\n", + " }\n", + " inner_product_param {\n", + " num_output: 2\n", + " weight_filler {\n", + " type: \"gaussian\"\n", + " std: 0.01\n", + " }\n", + " bias_filler {\n", + " type: \"constant\"\n", + " value: 0\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"loss\"\n", + " type: \"SoftmaxWithLoss\"\n", + " bottom: \"fc2\"\n", + " bottom: \"label\"\n", + " top: \"loss\"\n", + "}\n", + "I0307 01:34:31.873246 2099749632 layer_factory.hpp:74] Creating layer data\n", + "I0307 01:34:31.873276 2099749632 net.cpp:84] Creating Layer data\n", + "I0307 01:34:31.873292 2099749632 net.cpp:338] data -> data\n", + "I0307 01:34:31.873332 2099749632 net.cpp:338] data -> label\n", + "I0307 01:34:31.873352 2099749632 net.cpp:113] Setting up data\n", + "I0307 01:34:31.873361 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/train.txt\n", + "I0307 01:34:31.873443 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 2\n", + "I0307 01:34:31.875783 2099749632 net.cpp:120] Top shape: 10 4 (40)\n", + "I0307 01:34:31.875816 2099749632 net.cpp:120] Top shape: 10 (10)\n", + "I0307 01:34:31.875829 2099749632 layer_factory.hpp:74] Creating layer fc1\n", + "I0307 01:34:31.875846 2099749632 net.cpp:84] Creating Layer fc1\n", + "I0307 01:34:31.875857 2099749632 net.cpp:380] fc1 <- data\n", + "I0307 01:34:31.875875 2099749632 net.cpp:338] fc1 -> fc1\n", + "I0307 01:34:31.875892 2099749632 net.cpp:113] Setting up fc1\n", + "I0307 01:34:31.882478 2099749632 net.cpp:120] Top shape: 10 40 (400)\n", + "I0307 01:34:31.882505 2099749632 layer_factory.hpp:74] Creating layer relu1\n", + "I0307 01:34:31.882524 2099749632 net.cpp:84] Creating Layer relu1\n", + "I0307 01:34:31.882532 2099749632 net.cpp:380] relu1 <- fc1\n", + "I0307 01:34:31.882544 2099749632 net.cpp:327] relu1 -> fc1 (in-place)\n", + "I0307 01:34:31.882555 2099749632 net.cpp:113] Setting up relu1\n", + "I0307 01:34:31.882565 2099749632 net.cpp:120] Top shape: 10 40 (400)\n", + "I0307 01:34:31.882583 2099749632 layer_factory.hpp:74] Creating layer fc2\n", + "I0307 01:34:31.882609 2099749632 net.cpp:84] Creating Layer fc2\n", + "I0307 01:34:31.882619 2099749632 net.cpp:380] fc2 <- fc1\n", + "I0307 01:34:31.882632 2099749632 net.cpp:338] fc2 -> fc2\n", + "I0307 01:34:31.882644 2099749632 net.cpp:113] Setting up fc2\n", + "I0307 01:34:31.882663 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", + "I0307 01:34:31.882678 2099749632 layer_factory.hpp:74] Creating layer loss\n", + "I0307 01:34:31.882694 2099749632 net.cpp:84] Creating Layer loss\n", + "I0307 01:34:31.882704 2099749632 net.cpp:380] loss <- fc2\n", + "I0307 01:34:31.882712 2099749632 net.cpp:380] loss <- label\n", + "I0307 01:34:31.882779 2099749632 net.cpp:338] loss -> loss\n", + "I0307 01:34:31.882796 2099749632 net.cpp:113] Setting up loss\n", + "I0307 01:34:31.882810 2099749632 layer_factory.hpp:74] Creating layer loss\n", + "I0307 01:34:31.882833 2099749632 net.cpp:120] Top shape: (1)\n", + "I0307 01:34:31.882844 2099749632 net.cpp:122] with loss weight 1\n", + "I0307 01:34:31.882860 2099749632 net.cpp:167] loss needs backward computation.\n", + "I0307 01:34:31.882869 2099749632 net.cpp:167] fc2 needs backward computation.\n", + "I0307 01:34:31.882877 2099749632 net.cpp:167] relu1 needs backward computation.\n", + "I0307 01:34:31.882886 2099749632 net.cpp:167] fc1 needs backward computation.\n", + "I0307 01:34:31.882894 2099749632 net.cpp:169] data does not need backward computation.\n", + "I0307 01:34:31.882904 2099749632 net.cpp:205] This network produces output loss\n", + "I0307 01:34:31.882931 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", + "I0307 01:34:31.882942 2099749632 net.cpp:217] Network initialization done.\n", + "I0307 01:34:31.882951 2099749632 net.cpp:218] Memory required for data: 3484\n", + "I0307 01:34:31.883157 2099749632 solver.cpp:154] Creating test net (#0) specified by net file: hdf5_classification/train_val2.prototxt\n", + "I0307 01:34:31.883189 2099749632 net.cpp:257] The NetState phase (1) differed from the phase (0) specified by a rule in layer data\n", + "I0307 01:34:31.883203 2099749632 net.cpp:42] Initializing net from parameters: \n", + "name: \"LogisticRegressionNet\"\n", + "state {\n", + " phase: TEST\n", + "}\n", + "layer {\n", + " name: \"data\"\n", + " type: \"HDF5Data\"\n", + " top: \"data\"\n", + " top: \"label\"\n", + " include {\n", + " phase: TEST\n", + " }\n", + " hdf5_data_param {\n", + " source: \"hdf5_classification/data/test.txt\"\n", + " batch_size: 10\n", + " }\n", + "}\n", + "layer {\n", + " name: \"fc1\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"data\"\n", + " top: \"fc1\"\n", + " param {\n", + " lr_mult: 1\n", + " decay_mult: 1\n", + " }\n", + " param {\n", + " lr_mult: 2\n", + " decay_mult: 0\n", + " }\n", + " inner_product_param {\n", + " num_output: 40\n", + " weight_filler {\n", + " type: \"gaussian\"\n", + " std: 0.01\n", + " }\n", + " bias_filler {\n", + " type: \"constant\"\n", + " value: 0\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"relu1\"\n", + " type: \"ReLU\"\n", + " bottom: \"fc1\"\n", + " top: \"fc1\"\n", + "}\n", + "layer {\n", + " name: \"fc2\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"fc1\"\n", + " top: \"fc2\"\n", + " param {\n", + " lr_mult: 1\n", + " decay_mult: 1\n", + " }\n", + " param {\n", + " lr_mult: 2\n", + " decay_mult: 0\n", + " }\n", + " inner_product_param {\n", + " num_output: 2\n", + " weight_filler {\n", + " type: \"gaussian\"\n", + " std: 0.01\n", + " }\n", + " bias_filler {\n", + " type: \"constant\"\n", + " value: 0\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"loss\"\n", + " type: \"SoftmaxWithLoss\"\n", + " bottom: \"fc2\"\n", + " bottom: \"label\"\n", + " top: \"loss\"\n", + "}\n", + "layer {\n", + " name: \"accuracy\"\n", + " type: \"Accuracy\"\n", + " bottom: \"fc2\"\n", + " bottom: \"label\"\n", + " top: \"accuracy\"\n", + " include {\n", + " phase: TEST\n", + " }\n", + "}\n", + "I0307 01:34:31.883535 2099749632 layer_factory.hpp:74] Creating layer data\n", + "I0307 01:34:31.883548 2099749632 net.cpp:84] Creating Layer data\n", + "I0307 01:34:31.883556 2099749632 net.cpp:338] data -> data\n", + "I0307 01:34:31.883569 2099749632 net.cpp:338] data -> label\n", + "I0307 01:34:31.883579 2099749632 net.cpp:113] Setting up data\n", + "I0307 01:34:31.883585 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/test.txt\n", + "I0307 01:34:31.883664 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 1\n", + "I0307 01:34:31.884842 2099749632 net.cpp:120] Top shape: 10 4 (40)\n", + "I0307 01:34:31.884860 2099749632 net.cpp:120] Top shape: 10 (10)\n", + "I0307 01:34:31.884870 2099749632 layer_factory.hpp:74] Creating layer label_data_1_split\n", + "I0307 01:34:31.884879 2099749632 net.cpp:84] Creating Layer label_data_1_split\n", + "I0307 01:34:31.884886 2099749632 net.cpp:380] label_data_1_split <- label\n", + "I0307 01:34:31.884896 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_0\n", + "I0307 01:34:31.884909 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_1\n", + "I0307 01:34:31.884919 2099749632 net.cpp:113] Setting up label_data_1_split\n", + "I0307 01:34:31.884927 2099749632 net.cpp:120] Top shape: 10 (10)\n", + "I0307 01:34:31.884934 2099749632 net.cpp:120] Top shape: 10 (10)\n", + "I0307 01:34:31.884941 2099749632 layer_factory.hpp:74] Creating layer fc1\n", + "I0307 01:34:31.884951 2099749632 net.cpp:84] Creating Layer fc1\n", + "I0307 01:34:31.884958 2099749632 net.cpp:380] fc1 <- data\n", + "I0307 01:34:31.884989 2099749632 net.cpp:338] fc1 -> fc1\n", + "I0307 01:34:31.885000 2099749632 net.cpp:113] Setting up fc1\n", + "I0307 01:34:31.885017 2099749632 net.cpp:120] Top shape: 10 40 (400)\n", + "I0307 01:34:31.885030 2099749632 layer_factory.hpp:74] Creating layer relu1\n", + "I0307 01:34:31.885041 2099749632 net.cpp:84] Creating Layer relu1\n", + "I0307 01:34:31.885048 2099749632 net.cpp:380] relu1 <- fc1\n", + "I0307 01:34:31.885056 2099749632 net.cpp:327] relu1 -> fc1 (in-place)\n", + "I0307 01:34:31.885064 2099749632 net.cpp:113] Setting up relu1\n", + "I0307 01:34:31.885071 2099749632 net.cpp:120] Top shape: 10 40 (400)\n", + "I0307 01:34:31.885079 2099749632 layer_factory.hpp:74] Creating layer fc2\n", + "I0307 01:34:31.885088 2099749632 net.cpp:84] Creating Layer fc2\n", + "I0307 01:34:31.885094 2099749632 net.cpp:380] fc2 <- fc1\n", + "I0307 01:34:31.885103 2099749632 net.cpp:338] fc2 -> fc2\n", + "I0307 01:34:31.885113 2099749632 net.cpp:113] Setting up fc2\n", + "I0307 01:34:31.885126 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", + "I0307 01:34:31.885138 2099749632 layer_factory.hpp:74] Creating layer fc2_fc2_0_split\n", + "I0307 01:34:31.885149 2099749632 net.cpp:84] Creating Layer fc2_fc2_0_split\n", + "I0307 01:34:31.885155 2099749632 net.cpp:380] fc2_fc2_0_split <- fc2\n", + "I0307 01:34:31.885164 2099749632 net.cpp:338] fc2_fc2_0_split -> fc2_fc2_0_split_0\n", + "I0307 01:34:31.885174 2099749632 net.cpp:338] fc2_fc2_0_split -> fc2_fc2_0_split_1\n", + "I0307 01:34:31.885182 2099749632 net.cpp:113] Setting up fc2_fc2_0_split\n", + "I0307 01:34:31.885190 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", + "I0307 01:34:31.885242 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", + "I0307 01:34:31.885256 2099749632 layer_factory.hpp:74] Creating layer loss\n", + "I0307 01:34:31.885267 2099749632 net.cpp:84] Creating Layer loss\n", + "I0307 01:34:31.885275 2099749632 net.cpp:380] loss <- fc2_fc2_0_split_0\n", + "I0307 01:34:31.885285 2099749632 net.cpp:380] loss <- label_data_1_split_0\n", + "I0307 01:34:31.885296 2099749632 net.cpp:338] loss -> loss\n", + "I0307 01:34:31.885308 2099749632 net.cpp:113] Setting up loss\n", + "I0307 01:34:31.885316 2099749632 layer_factory.hpp:74] Creating layer loss\n", + "I0307 01:34:31.885330 2099749632 net.cpp:120] Top shape: (1)\n", + "I0307 01:34:31.885337 2099749632 net.cpp:122] with loss weight 1\n", + "I0307 01:34:31.885346 2099749632 layer_factory.hpp:74] Creating layer accuracy\n", + "I0307 01:34:31.885360 2099749632 net.cpp:84] Creating Layer accuracy\n", + "I0307 01:34:31.885368 2099749632 net.cpp:380] accuracy <- fc2_fc2_0_split_1\n", + "I0307 01:34:31.885375 2099749632 net.cpp:380] accuracy <- label_data_1_split_1\n", + "I0307 01:34:31.885383 2099749632 net.cpp:338] accuracy -> accuracy\n", + "I0307 01:34:31.885392 2099749632 net.cpp:113] Setting up accuracy\n", + "I0307 01:34:31.885401 2099749632 net.cpp:120] Top shape: (1)\n", + "I0307 01:34:31.885407 2099749632 net.cpp:169] accuracy does not need backward computation.\n", + "I0307 01:34:31.885413 2099749632 net.cpp:167] loss needs backward computation.\n", + "I0307 01:34:31.885419 2099749632 net.cpp:167] fc2_fc2_0_split needs backward computation.\n", + "I0307 01:34:31.885426 2099749632 net.cpp:167] fc2 needs backward computation.\n", + "I0307 01:34:31.885432 2099749632 net.cpp:167] relu1 needs backward computation.\n", + "I0307 01:34:31.885438 2099749632 net.cpp:167] fc1 needs backward computation.\n", + "I0307 01:34:31.885444 2099749632 net.cpp:169] label_data_1_split does not need backward computation.\n", + "I0307 01:34:31.885452 2099749632 net.cpp:169] data does not need backward computation.\n", + "I0307 01:34:31.885457 2099749632 net.cpp:205] This network produces output accuracy\n", + "I0307 01:34:31.885613 2099749632 net.cpp:205] This network produces output loss\n", + "I0307 01:34:31.885632 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", + "I0307 01:34:31.885639 2099749632 net.cpp:217] Network initialization done.\n", + "I0307 01:34:31.885645 2099749632 net.cpp:218] Memory required for data: 3728\n", + "I0307 01:34:31.885685 2099749632 solver.cpp:42] Solver scaffolding done.\n", + "I0307 01:34:31.885711 2099749632 solver.cpp:222] Solving LogisticRegressionNet\n", + "I0307 01:34:31.885721 2099749632 solver.cpp:223] Learning Rate Policy: step\n", + "I0307 01:34:31.885730 2099749632 solver.cpp:266] Iteration 0, Testing net (#0)\n", + "I0307 01:34:31.901005 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.5944\n", + "I0307 01:34:31.901049 2099749632 solver.cpp:315] Test net output #1: loss = 0.693021 (* 1 = 0.693021 loss)\n", + "I0307 01:34:31.901177 2099749632 solver.cpp:189] Iteration 0, loss = 0.693163\n", + "I0307 01:34:31.901192 2099749632 solver.cpp:204] Train net output #0: loss = 0.693163 (* 1 = 0.693163 loss)\n", + "I0307 01:34:31.901203 2099749632 solver.cpp:464] Iteration 0, lr = 0.01\n", + "I0307 01:34:31.920586 2099749632 solver.cpp:266] Iteration 1000, Testing net (#0)\n", + "I0307 01:34:31.924612 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7556\n", + "I0307 01:34:31.924646 2099749632 solver.cpp:315] Test net output #1: loss = 0.511002 (* 1 = 0.511002 loss)\n", + "I0307 01:34:31.924684 2099749632 solver.cpp:189] Iteration 1000, loss = 0.38536\n", + "I0307 01:34:31.924696 2099749632 solver.cpp:204] Train net output #0: loss = 0.38536 (* 1 = 0.38536 loss)\n", + "I0307 01:34:31.924706 2099749632 solver.cpp:464] Iteration 1000, lr = 0.01\n", + "I0307 01:34:31.944727 2099749632 solver.cpp:266] Iteration 2000, Testing net (#0)\n", + "I0307 01:34:31.948729 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7824\n", + "I0307 01:34:31.948763 2099749632 solver.cpp:315] Test net output #1: loss = 0.489214 (* 1 = 0.489214 loss)\n", + "I0307 01:34:31.948799 2099749632 solver.cpp:189] Iteration 2000, loss = 0.532582\n", + "I0307 01:34:31.948812 2099749632 solver.cpp:204] Train net output #0: loss = 0.532582 (* 1 = 0.532582 loss)\n", + "I0307 01:34:31.948823 2099749632 solver.cpp:464] Iteration 2000, lr = 0.01\n", + "I0307 01:34:31.968670 2099749632 solver.cpp:266] Iteration 3000, Testing net (#0)\n", + "I0307 01:34:31.972393 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7956\n", + "I0307 01:34:31.972411 2099749632 solver.cpp:315] Test net output #1: loss = 0.454184 (* 1 = 0.454184 loss)\n", + "I0307 01:34:31.973024 2099749632 solver.cpp:189] Iteration 3000, loss = 0.541374\n", + "I0307 01:34:31.973057 2099749632 solver.cpp:204] Train net output #0: loss = 0.541374 (* 1 = 0.541374 loss)\n", + "I0307 01:34:31.973067 2099749632 solver.cpp:464] Iteration 3000, lr = 0.01\n", + "I0307 01:34:31.994829 2099749632 solver.cpp:266] Iteration 4000, Testing net (#0)\n", + "I0307 01:34:31.998638 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.798\n", + "I0307 01:34:31.998663 2099749632 solver.cpp:315] Test net output #1: loss = 0.456348 (* 1 = 0.456348 loss)\n", + "I0307 01:34:31.998705 2099749632 solver.cpp:189] Iteration 4000, loss = 0.490437\n", + "I0307 01:34:31.998718 2099749632 solver.cpp:204] Train net output #0: loss = 0.490437 (* 1 = 0.490437 loss)\n", + "I0307 01:34:31.998725 2099749632 solver.cpp:464] Iteration 4000, lr = 0.01\n", + "I0307 01:34:32.021085 2099749632 solver.cpp:266] Iteration 5000, Testing net (#0)\n", + "I0307 01:34:32.024950 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.804\n", + "I0307 01:34:32.024981 2099749632 solver.cpp:315] Test net output #1: loss = 0.46184 (* 1 = 0.46184 loss)\n", + "I0307 01:34:32.025017 2099749632 solver.cpp:189] Iteration 5000, loss = 0.467703\n", + "I0307 01:34:32.025028 2099749632 solver.cpp:204] Train net output #0: loss = 0.467704 (* 1 = 0.467704 loss)\n", + "I0307 01:34:32.025038 2099749632 solver.cpp:464] Iteration 5000, lr = 0.001\n", + "I0307 01:34:32.044390 2099749632 solver.cpp:266] Iteration 6000, Testing net (#0)\n", + "I0307 01:34:32.048216 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8208\n", + "I0307 01:34:32.048239 2099749632 solver.cpp:315] Test net output #1: loss = 0.423084 (* 1 = 0.423084 loss)\n", + "I0307 01:34:32.048790 2099749632 solver.cpp:189] Iteration 6000, loss = 0.480104\n", + "I0307 01:34:32.048809 2099749632 solver.cpp:204] Train net output #0: loss = 0.480105 (* 1 = 0.480105 loss)\n", + "I0307 01:34:32.048827 2099749632 solver.cpp:464] Iteration 6000, lr = 0.001\n", + "I0307 01:34:32.067795 2099749632 solver.cpp:266] Iteration 7000, Testing net (#0)\n", + "I0307 01:34:32.071524 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8124\n", + "I0307 01:34:32.071542 2099749632 solver.cpp:315] Test net output #1: loss = 0.423947 (* 1 = 0.423947 loss)\n", + "I0307 01:34:32.071570 2099749632 solver.cpp:189] Iteration 7000, loss = 0.447471\n", + "I0307 01:34:32.071617 2099749632 solver.cpp:204] Train net output #0: loss = 0.447472 (* 1 = 0.447472 loss)\n", + "I0307 01:34:32.071626 2099749632 solver.cpp:464] Iteration 7000, lr = 0.001\n", + "I0307 01:34:32.091625 2099749632 solver.cpp:266] Iteration 8000, Testing net (#0)\n", + "I0307 01:34:32.095410 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.814\n", + "I0307 01:34:32.095432 2099749632 solver.cpp:315] Test net output #1: loss = 0.423586 (* 1 = 0.423586 loss)\n", + "I0307 01:34:32.095461 2099749632 solver.cpp:189] Iteration 8000, loss = 0.386258\n", + "I0307 01:34:32.095474 2099749632 solver.cpp:204] Train net output #0: loss = 0.386259 (* 1 = 0.386259 loss)\n", + "I0307 01:34:32.095481 2099749632 solver.cpp:464] Iteration 8000, lr = 0.001\n", + "I0307 01:34:32.117184 2099749632 solver.cpp:266] Iteration 9000, Testing net (#0)\n", + "I0307 01:34:32.121587 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8208\n", + "I0307 01:34:32.121608 2099749632 solver.cpp:315] Test net output #1: loss = 0.419969 (* 1 = 0.419969 loss)\n", + "I0307 01:34:32.122161 2099749632 solver.cpp:189] Iteration 9000, loss = 0.468262\n", + "I0307 01:34:32.122181 2099749632 solver.cpp:204] Train net output #0: loss = 0.468262 (* 1 = 0.468262 loss)\n", + "I0307 01:34:32.122191 2099749632 solver.cpp:464] Iteration 9000, lr = 0.001\n", + "I0307 01:34:32.141635 2099749632 solver.cpp:334] Snapshotting to hdf5_classification/data/train_iter_10000.caffemodel\n", + "I0307 01:34:32.141860 2099749632 solver.cpp:342] Snapshotting solver state to hdf5_classification/data/train_iter_10000.solverstate\n", + "I0307 01:34:32.141978 2099749632 solver.cpp:248] Iteration 10000, loss = 0.441529\n", + "I0307 01:34:32.141995 2099749632 solver.cpp:266] Iteration 10000, Testing net (#0)\n", + "I0307 01:34:32.145747 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8148\n", + "I0307 01:34:32.145771 2099749632 solver.cpp:315] Test net output #1: loss = 0.4216 (* 1 = 0.4216 loss)\n", + "I0307 01:34:32.145779 2099749632 solver.cpp:253] Optimization Done.\n", + "I0307 01:34:32.145786 2099749632 caffe.cpp:121] Optimization Done.\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "!../build/tools/caffe train -solver hdf5_classification/solver2.prototxt" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:31.589234 2099749632 caffe.cpp:103] Use CPU.\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:31.872560 2099749632 caffe.cpp:107] Starting Optimization\r\n", - "I0307 01:34:31.872596 2099749632 solver.cpp:32] Initializing solver from parameters: \r\n", - "test_iter: 250\r\n", - "test_interval: 1000\r\n", - "base_lr: 0.01\r\n", - "display: 1000\r\n", - "max_iter: 10000\r\n", - "lr_policy: \"step\"\r\n", - "gamma: 0.1\r\n", - "momentum: 0.9\r\n", - "weight_decay: 0.0005\r\n", - "stepsize: 5000\r\n", - "snapshot: 10000\r\n", - "snapshot_prefix: \"hdf5_classification/data/train\"\r\n", - "solver_mode: CPU\r\n", - "net: \"hdf5_classification/train_val2.prototxt\"\r\n", - "I0307 01:34:31.872687 2099749632 solver.cpp:70] Creating training net from net file: hdf5_classification/train_val2.prototxt\r\n", - "I0307 01:34:31.872865 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer data\r\n", - "I0307 01:34:31.872882 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer accuracy\r\n", - "I0307 01:34:31.872891 2099749632 net.cpp:42] Initializing net from parameters: \r\n", - "name: \"LogisticRegressionNet\"\r\n", - "state {\r\n", - " phase: TRAIN\r\n", - "}\r\n", - "layer {\r\n", - " name: \"data\"\r\n", - " type: \"HDF5Data\"\r\n", - " top: \"data\"\r\n", - " top: \"label\"\r\n", - " include {\r\n", - " phase: TRAIN\r\n", - " }\r\n", - " hdf5_data_param {\r\n", - " source: \"hdf5_classification/data/train.txt\"\r\n", - " batch_size: 10\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"fc1\"\r\n", - " type: \"InnerProduct\"\r\n", - " bottom: \"data\"\r\n", - " top: \"fc1\"\r\n", - " param {\r\n", - " lr_mult: 1\r\n", - " decay_mult: 1\r\n", - " }\r\n", - " param {\r\n", - " lr_mult: 2\r\n", - " decay_mult: 0\r\n", - " }\r\n", - " inner_product_param {\r\n", - " num_output: 40\r\n", - " weight_filler {\r\n", - " type: \"gaussian\"\r\n", - " std: 0.01\r\n", - " }\r\n", - " bias_filler {\r\n", - " type: \"constant\"\r\n", - " value: 0\r\n", - " }\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"relu1\"\r\n", - " type: \"ReLU\"\r\n", - " bottom: \"fc1\"\r\n", - " top: \"fc1\"\r\n", - "}\r\n", - "layer {\r\n", - " name: \"fc2\"\r\n", - " type: \"InnerProduct\"\r\n", - " bottom: \"fc1\"\r\n", - " top: \"fc2\"\r\n", - " param {\r\n", - " lr_mult: 1\r\n", - " decay_mult: 1\r\n", - " }\r\n", - " param {\r\n", - " lr_mult: 2\r\n", - " decay_mult: 0\r\n", - " }\r\n", - " inner_product_param {\r\n", - " num_output: 2\r\n", - " weight_filler {\r\n", - " type: \"gaussian\"\r\n", - " std: 0.01\r\n", - " }\r\n", - " bias_filler {\r\n", - " type: \"constant\"\r\n", - " value: 0\r\n", - " }\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"loss\"\r\n", - " type: \"SoftmaxWithLoss\"\r\n", - " bottom: \"fc2\"\r\n", - " bottom: \"label\"\r\n", - " top: \"loss\"\r\n", - "}\r\n", - "I0307 01:34:31.873246 2099749632 layer_factory.hpp:74] Creating layer data\r\n", - "I0307 01:34:31.873276 2099749632 net.cpp:84] Creating Layer data\r\n", - "I0307 01:34:31.873292 2099749632 net.cpp:338] data -> data\r\n", - "I0307 01:34:31.873332 2099749632 net.cpp:338] data -> label\r\n", - "I0307 01:34:31.873352 2099749632 net.cpp:113] Setting up data\r\n", - "I0307 01:34:31.873361 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/train.txt\r\n", - "I0307 01:34:31.873443 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 2\r\n", - "I0307 01:34:31.875783 2099749632 net.cpp:120] Top shape: 10 4 (40)\r\n", - "I0307 01:34:31.875816 2099749632 net.cpp:120] Top shape: 10 (10)\r\n", - "I0307 01:34:31.875829 2099749632 layer_factory.hpp:74] Creating layer fc1\r\n", - "I0307 01:34:31.875846 2099749632 net.cpp:84] Creating Layer fc1\r\n", - "I0307 01:34:31.875857 2099749632 net.cpp:380] fc1 <- data\r\n", - "I0307 01:34:31.875875 2099749632 net.cpp:338] fc1 -> fc1\r\n", - "I0307 01:34:31.875892 2099749632 net.cpp:113] Setting up fc1\r\n", - "I0307 01:34:31.882478 2099749632 net.cpp:120] Top shape: 10 40 (400)\r\n", - "I0307 01:34:31.882505 2099749632 layer_factory.hpp:74] Creating layer relu1\r\n", - "I0307 01:34:31.882524 2099749632 net.cpp:84] Creating Layer relu1\r\n", - "I0307 01:34:31.882532 2099749632 net.cpp:380] relu1 <- fc1\r\n", - "I0307 01:34:31.882544 2099749632 net.cpp:327] relu1 -> fc1 (in-place)\r\n", - "I0307 01:34:31.882555 2099749632 net.cpp:113] Setting up relu1\r\n", - "I0307 01:34:31.882565 2099749632 net.cpp:120] Top shape: 10 40 (400)\r\n", - "I0307 01:34:31.882583 2099749632 layer_factory.hpp:74] Creating layer fc2\r\n", - "I0307 01:34:31.882609 2099749632 net.cpp:84] Creating Layer fc2\r\n", - "I0307 01:34:31.882619 2099749632 net.cpp:380] fc2 <- fc1\r\n", - "I0307 01:34:31.882632 2099749632 net.cpp:338] fc2 -> fc2\r\n", - "I0307 01:34:31.882644 2099749632 net.cpp:113] Setting up fc2\r\n", - "I0307 01:34:31.882663 2099749632 net.cpp:120] Top shape: 10 2 (20)\r\n", - "I0307 01:34:31.882678 2099749632 layer_factory.hpp:74] Creating layer loss\r\n", - "I0307 01:34:31.882694 2099749632 net.cpp:84] Creating Layer loss\r\n", - "I0307 01:34:31.882704 2099749632 net.cpp:380] loss <- fc2\r\n", - "I0307 01:34:31.882712 2099749632 net.cpp:380] loss <- label\r\n", - "I0307 01:34:31.882779 2099749632 net.cpp:338] loss -> loss\r\n", - "I0307 01:34:31.882796 2099749632 net.cpp:113] Setting up loss\r\n", - "I0307 01:34:31.882810 2099749632 layer_factory.hpp:74] Creating layer loss\r\n", - "I0307 01:34:31.882833 2099749632 net.cpp:120] Top shape: (1)\r\n", - "I0307 01:34:31.882844 2099749632 net.cpp:122] with loss weight 1\r\n", - "I0307 01:34:31.882860 2099749632 net.cpp:167] loss needs backward computation.\r\n", - "I0307 01:34:31.882869 2099749632 net.cpp:167] fc2 needs backward computation.\r\n", - "I0307 01:34:31.882877 2099749632 net.cpp:167] relu1 needs backward computation.\r\n", - "I0307 01:34:31.882886 2099749632 net.cpp:167] fc1 needs backward computation.\r\n", - "I0307 01:34:31.882894 2099749632 net.cpp:169] data does not need backward computation.\r\n", - "I0307 01:34:31.882904 2099749632 net.cpp:205] This network produces output loss\r\n", - "I0307 01:34:31.882931 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\r\n", - "I0307 01:34:31.882942 2099749632 net.cpp:217] Network initialization done.\r\n", - "I0307 01:34:31.882951 2099749632 net.cpp:218] Memory required for data: 3484\r\n", - "I0307 01:34:31.883157 2099749632 solver.cpp:154] Creating test net (#0) specified by net file: hdf5_classification/train_val2.prototxt\r\n", - "I0307 01:34:31.883189 2099749632 net.cpp:257] The NetState phase (1) differed from the phase (0) specified by a rule in layer data\r\n", - "I0307 01:34:31.883203 2099749632 net.cpp:42] Initializing net from parameters: \r\n", - "name: \"LogisticRegressionNet\"\r\n", - "state {\r\n", - " phase: TEST\r\n", - "}\r\n", - "layer {\r\n", - " name: \"data\"\r\n", - " type: \"HDF5Data\"\r\n", - " top: \"data\"\r\n", - " top: \"label\"\r\n", - " include {\r\n", - " phase: TEST\r\n", - " }\r\n", - " hdf5_data_param {\r\n", - " source: \"hdf5_classification/data/test.txt\"\r\n", - " batch_size: 10\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"fc1\"\r\n", - " type: \"InnerProduct\"\r\n", - " bottom: \"data\"\r\n", - " top: \"fc1\"\r\n", - " param {\r\n", - " lr_mult: 1\r\n", - " decay_mult: 1\r\n", - " }\r\n", - " param {\r\n", - " lr_mult: 2\r\n", - " decay_mult: 0\r\n", - " }\r\n", - " inner_product_param {\r\n", - " num_output: 40\r\n", - " weight_filler {\r\n", - " type: \"gaussian\"\r\n", - " std: 0.01\r\n", - " }\r\n", - " bias_filler {\r\n", - " type: \"constant\"\r\n", - " value: 0\r\n", - " }\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"relu1\"\r\n", - " type: \"ReLU\"\r\n", - " bottom: \"fc1\"\r\n", - " top: \"fc1\"\r\n", - "}\r\n", - "layer {\r\n", - " name: \"fc2\"\r\n", - " type: \"InnerProduct\"\r\n", - " bottom: \"fc1\"\r\n", - " top: \"fc2\"\r\n", - " param {\r\n", - " lr_mult: 1\r\n", - " decay_mult: 1\r\n", - " }\r\n", - " param {\r\n", - " lr_mult: 2\r\n", - " decay_mult: 0\r\n", - " }\r\n", - " inner_product_param {\r\n", - " num_output: 2\r\n", - " weight_filler {\r\n", - " type: \"gaussian\"\r\n", - " std: 0.01\r\n", - " }\r\n", - " bias_filler {\r\n", - " type: \"constant\"\r\n", - " value: 0\r\n", - " }\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"loss\"\r\n", - " type: \"SoftmaxWithLoss\"\r\n", - " bottom: \"fc2\"\r\n", - " bottom: \"label\"\r\n", - " top: \"loss\"\r\n", - "}\r\n", - "layer {\r\n", - " name: \"accuracy\"\r\n", - " type: \"Accuracy\"\r\n", - " bottom: \"fc2\"\r\n", - " bottom: \"label\"\r\n", - " top: \"accuracy\"\r\n", - " include {\r\n", - " phase: TEST\r\n", - " }\r\n", - "}\r\n", - "I0307 01:34:31.883535 2099749632 layer_factory.hpp:74] Creating layer data\r\n", - "I0307 01:34:31.883548 2099749632 net.cpp:84] Creating Layer data\r\n", - "I0307 01:34:31.883556 2099749632 net.cpp:338] data -> data\r\n", - "I0307 01:34:31.883569 2099749632 net.cpp:338] data -> label\r\n", - "I0307 01:34:31.883579 2099749632 net.cpp:113] Setting up data\r\n", - "I0307 01:34:31.883585 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/test.txt\r\n", - "I0307 01:34:31.883664 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 1\r\n", - "I0307 01:34:31.884842 2099749632 net.cpp:120] Top shape: 10 4 (40)\r\n", - "I0307 01:34:31.884860 2099749632 net.cpp:120] Top shape: 10 (10)\r\n", - "I0307 01:34:31.884870 2099749632 layer_factory.hpp:74] Creating layer label_data_1_split\r\n", - "I0307 01:34:31.884879 2099749632 net.cpp:84] Creating Layer label_data_1_split\r\n", - "I0307 01:34:31.884886 2099749632 net.cpp:380] label_data_1_split <- label\r\n", - "I0307 01:34:31.884896 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_0\r\n", - "I0307 01:34:31.884909 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_1\r\n", - "I0307 01:34:31.884919 2099749632 net.cpp:113] Setting up label_data_1_split\r\n", - "I0307 01:34:31.884927 2099749632 net.cpp:120] Top shape: 10 (10)\r\n", - "I0307 01:34:31.884934 2099749632 net.cpp:120] Top shape: 10 (10)\r\n", - "I0307 01:34:31.884941 2099749632 layer_factory.hpp:74] Creating layer fc1\r\n", - "I0307 01:34:31.884951 2099749632 net.cpp:84] Creating Layer fc1\r\n", - "I0307 01:34:31.884958 2099749632 net.cpp:380] fc1 <- data\r\n", - "I0307 01:34:31.884989 2099749632 net.cpp:338] fc1 -> fc1\r\n", - "I0307 01:34:31.885000 2099749632 net.cpp:113] Setting up fc1\r\n", - "I0307 01:34:31.885017 2099749632 net.cpp:120] Top shape: 10 40 (400)\r\n", - "I0307 01:34:31.885030 2099749632 layer_factory.hpp:74] Creating layer relu1\r\n", - "I0307 01:34:31.885041 2099749632 net.cpp:84] Creating Layer relu1\r\n", - "I0307 01:34:31.885048 2099749632 net.cpp:380] relu1 <- fc1\r\n", - "I0307 01:34:31.885056 2099749632 net.cpp:327] relu1 -> fc1 (in-place)\r\n", - "I0307 01:34:31.885064 2099749632 net.cpp:113] Setting up relu1\r\n", - "I0307 01:34:31.885071 2099749632 net.cpp:120] Top shape: 10 40 (400)\r\n", - "I0307 01:34:31.885079 2099749632 layer_factory.hpp:74] Creating layer fc2\r\n", - "I0307 01:34:31.885088 2099749632 net.cpp:84] Creating Layer fc2\r\n", - "I0307 01:34:31.885094 2099749632 net.cpp:380] fc2 <- fc1\r\n", - "I0307 01:34:31.885103 2099749632 net.cpp:338] fc2 -> fc2\r\n", - "I0307 01:34:31.885113 2099749632 net.cpp:113] Setting up fc2\r\n", - "I0307 01:34:31.885126 2099749632 net.cpp:120] Top shape: 10 2 (20)\r\n", - "I0307 01:34:31.885138 2099749632 layer_factory.hpp:74] Creating layer fc2_fc2_0_split\r\n", - "I0307 01:34:31.885149 2099749632 net.cpp:84] Creating Layer fc2_fc2_0_split\r\n", - "I0307 01:34:31.885155 2099749632 net.cpp:380] fc2_fc2_0_split <- fc2\r\n", - "I0307 01:34:31.885164 2099749632 net.cpp:338] fc2_fc2_0_split -> fc2_fc2_0_split_0\r\n", - "I0307 01:34:31.885174 2099749632 net.cpp:338] fc2_fc2_0_split -> fc2_fc2_0_split_1\r\n", - "I0307 01:34:31.885182 2099749632 net.cpp:113] Setting up fc2_fc2_0_split\r\n", - "I0307 01:34:31.885190 2099749632 net.cpp:120] Top shape: 10 2 (20)\r\n", - "I0307 01:34:31.885242 2099749632 net.cpp:120] Top shape: 10 2 (20)\r\n", - "I0307 01:34:31.885256 2099749632 layer_factory.hpp:74] Creating layer loss\r\n", - "I0307 01:34:31.885267 2099749632 net.cpp:84] Creating Layer loss\r\n", - "I0307 01:34:31.885275 2099749632 net.cpp:380] loss <- fc2_fc2_0_split_0\r\n", - "I0307 01:34:31.885285 2099749632 net.cpp:380] loss <- label_data_1_split_0\r\n", - "I0307 01:34:31.885296 2099749632 net.cpp:338] loss -> loss\r\n", - "I0307 01:34:31.885308 2099749632 net.cpp:113] Setting up loss\r\n", - "I0307 01:34:31.885316 2099749632 layer_factory.hpp:74] Creating layer loss\r\n", - "I0307 01:34:31.885330 2099749632 net.cpp:120] Top shape: (1)\r\n", - "I0307 01:34:31.885337 2099749632 net.cpp:122] with loss weight 1\r\n", - "I0307 01:34:31.885346 2099749632 layer_factory.hpp:74] Creating layer accuracy\r\n", - "I0307 01:34:31.885360 2099749632 net.cpp:84] Creating Layer accuracy\r\n", - "I0307 01:34:31.885368 2099749632 net.cpp:380] accuracy <- fc2_fc2_0_split_1\r\n", - "I0307 01:34:31.885375 2099749632 net.cpp:380] accuracy <- label_data_1_split_1\r\n", - "I0307 01:34:31.885383 2099749632 net.cpp:338] accuracy -> accuracy\r\n", - "I0307 01:34:31.885392 2099749632 net.cpp:113] Setting up accuracy\r\n", - "I0307 01:34:31.885401 2099749632 net.cpp:120] Top shape: (1)\r\n", - "I0307 01:34:31.885407 2099749632 net.cpp:169] accuracy does not need backward computation.\r\n", - "I0307 01:34:31.885413 2099749632 net.cpp:167] loss needs backward computation.\r\n", - "I0307 01:34:31.885419 2099749632 net.cpp:167] fc2_fc2_0_split needs backward computation.\r\n", - "I0307 01:34:31.885426 2099749632 net.cpp:167] fc2 needs backward computation.\r\n", - "I0307 01:34:31.885432 2099749632 net.cpp:167] relu1 needs backward computation.\r\n", - "I0307 01:34:31.885438 2099749632 net.cpp:167] fc1 needs backward computation.\r\n", - "I0307 01:34:31.885444 2099749632 net.cpp:169] label_data_1_split does not need backward computation.\r\n", - "I0307 01:34:31.885452 2099749632 net.cpp:169] data does not need backward computation.\r\n", - "I0307 01:34:31.885457 2099749632 net.cpp:205] This network produces output accuracy\r\n", - "I0307 01:34:31.885613 2099749632 net.cpp:205] This network produces output loss\r\n", - "I0307 01:34:31.885632 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\r\n", - "I0307 01:34:31.885639 2099749632 net.cpp:217] Network initialization done.\r\n", - "I0307 01:34:31.885645 2099749632 net.cpp:218] Memory required for data: 3728\r\n", - "I0307 01:34:31.885685 2099749632 solver.cpp:42] Solver scaffolding done.\r\n", - "I0307 01:34:31.885711 2099749632 solver.cpp:222] Solving LogisticRegressionNet\r\n", - "I0307 01:34:31.885721 2099749632 solver.cpp:223] Learning Rate Policy: step\r\n", - "I0307 01:34:31.885730 2099749632 solver.cpp:266] Iteration 0, Testing net (#0)\r\n", - "I0307 01:34:31.901005 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.5944\r\n", - "I0307 01:34:31.901049 2099749632 solver.cpp:315] Test net output #1: loss = 0.693021 (* 1 = 0.693021 loss)\r\n", - "I0307 01:34:31.901177 2099749632 solver.cpp:189] Iteration 0, loss = 0.693163\r\n", - "I0307 01:34:31.901192 2099749632 solver.cpp:204] Train net output #0: loss = 0.693163 (* 1 = 0.693163 loss)\r\n", - "I0307 01:34:31.901203 2099749632 solver.cpp:464] Iteration 0, lr = 0.01\r\n", - "I0307 01:34:31.920586 2099749632 solver.cpp:266] Iteration 1000, Testing net (#0)\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:31.924612 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7556\r\n", - "I0307 01:34:31.924646 2099749632 solver.cpp:315] Test net output #1: loss = 0.511002 (* 1 = 0.511002 loss)\r\n", - "I0307 01:34:31.924684 2099749632 solver.cpp:189] Iteration 1000, loss = 0.38536\r\n", - "I0307 01:34:31.924696 2099749632 solver.cpp:204] Train net output #0: loss = 0.38536 (* 1 = 0.38536 loss)\r\n", - "I0307 01:34:31.924706 2099749632 solver.cpp:464] Iteration 1000, lr = 0.01\r\n", - "I0307 01:34:31.944727 2099749632 solver.cpp:266] Iteration 2000, Testing net (#0)\r\n", - "I0307 01:34:31.948729 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7824\r\n", - "I0307 01:34:31.948763 2099749632 solver.cpp:315] Test net output #1: loss = 0.489214 (* 1 = 0.489214 loss)\r\n", - "I0307 01:34:31.948799 2099749632 solver.cpp:189] Iteration 2000, loss = 0.532582\r\n", - "I0307 01:34:31.948812 2099749632 solver.cpp:204] Train net output #0: loss = 0.532582 (* 1 = 0.532582 loss)\r\n", - "I0307 01:34:31.948823 2099749632 solver.cpp:464] Iteration 2000, lr = 0.01\r\n", - "I0307 01:34:31.968670 2099749632 solver.cpp:266] Iteration 3000, Testing net (#0)\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:31.972393 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7956\r\n", - "I0307 01:34:31.972411 2099749632 solver.cpp:315] Test net output #1: loss = 0.454184 (* 1 = 0.454184 loss)\r\n", - "I0307 01:34:31.973024 2099749632 solver.cpp:189] Iteration 3000, loss = 0.541374\r\n", - "I0307 01:34:31.973057 2099749632 solver.cpp:204] Train net output #0: loss = 0.541374 (* 1 = 0.541374 loss)\r\n", - "I0307 01:34:31.973067 2099749632 solver.cpp:464] Iteration 3000, lr = 0.01\r\n", - "I0307 01:34:31.994829 2099749632 solver.cpp:266] Iteration 4000, Testing net (#0)\r\n", - "I0307 01:34:31.998638 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.798\r\n", - "I0307 01:34:31.998663 2099749632 solver.cpp:315] Test net output #1: loss = 0.456348 (* 1 = 0.456348 loss)\r\n", - "I0307 01:34:31.998705 2099749632 solver.cpp:189] Iteration 4000, loss = 0.490437\r\n", - "I0307 01:34:31.998718 2099749632 solver.cpp:204] Train net output #0: loss = 0.490437 (* 1 = 0.490437 loss)\r\n", - "I0307 01:34:31.998725 2099749632 solver.cpp:464] Iteration 4000, lr = 0.01\r\n", - "I0307 01:34:32.021085 2099749632 solver.cpp:266] Iteration 5000, Testing net (#0)\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:32.024950 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.804\r\n", - "I0307 01:34:32.024981 2099749632 solver.cpp:315] Test net output #1: loss = 0.46184 (* 1 = 0.46184 loss)\r\n", - "I0307 01:34:32.025017 2099749632 solver.cpp:189] Iteration 5000, loss = 0.467703\r\n", - "I0307 01:34:32.025028 2099749632 solver.cpp:204] Train net output #0: loss = 0.467704 (* 1 = 0.467704 loss)\r\n", - "I0307 01:34:32.025038 2099749632 solver.cpp:464] Iteration 5000, lr = 0.001\r\n", - "I0307 01:34:32.044390 2099749632 solver.cpp:266] Iteration 6000, Testing net (#0)\r\n", - "I0307 01:34:32.048216 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8208\r\n", - "I0307 01:34:32.048239 2099749632 solver.cpp:315] Test net output #1: loss = 0.423084 (* 1 = 0.423084 loss)\r\n", - "I0307 01:34:32.048790 2099749632 solver.cpp:189] Iteration 6000, loss = 0.480104\r\n", - "I0307 01:34:32.048809 2099749632 solver.cpp:204] Train net output #0: loss = 0.480105 (* 1 = 0.480105 loss)\r\n", - "I0307 01:34:32.048827 2099749632 solver.cpp:464] Iteration 6000, lr = 0.001\r\n", - "I0307 01:34:32.067795 2099749632 solver.cpp:266] Iteration 7000, Testing net (#0)\r\n", - "I0307 01:34:32.071524 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8124\r\n", - "I0307 01:34:32.071542 2099749632 solver.cpp:315] Test net output #1: loss = 0.423947 (* 1 = 0.423947 loss)\r\n", - "I0307 01:34:32.071570 2099749632 solver.cpp:189] Iteration 7000, loss = 0.447471\r\n", - "I0307 01:34:32.071617 2099749632 solver.cpp:204] Train net output #0: loss = 0.447472 (* 1 = 0.447472 loss)\r\n", - "I0307 01:34:32.071626 2099749632 solver.cpp:464] Iteration 7000, lr = 0.001\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:32.091625 2099749632 solver.cpp:266] Iteration 8000, Testing net (#0)\r\n", - "I0307 01:34:32.095410 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.814\r\n", - "I0307 01:34:32.095432 2099749632 solver.cpp:315] Test net output #1: loss = 0.423586 (* 1 = 0.423586 loss)\r\n", - "I0307 01:34:32.095461 2099749632 solver.cpp:189] Iteration 8000, loss = 0.386258\r\n", - "I0307 01:34:32.095474 2099749632 solver.cpp:204] Train net output #0: loss = 0.386259 (* 1 = 0.386259 loss)\r\n", - "I0307 01:34:32.095481 2099749632 solver.cpp:464] Iteration 8000, lr = 0.001\r\n", - "I0307 01:34:32.117184 2099749632 solver.cpp:266] Iteration 9000, Testing net (#0)\r\n", - "I0307 01:34:32.121587 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8208\r\n", - "I0307 01:34:32.121608 2099749632 solver.cpp:315] Test net output #1: loss = 0.419969 (* 1 = 0.419969 loss)\r\n", - "I0307 01:34:32.122161 2099749632 solver.cpp:189] Iteration 9000, loss = 0.468262\r\n", - "I0307 01:34:32.122181 2099749632 solver.cpp:204] Train net output #0: loss = 0.468262 (* 1 = 0.468262 loss)\r\n", - "I0307 01:34:32.122191 2099749632 solver.cpp:464] Iteration 9000, lr = 0.001\r\n" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "I0307 01:34:32.141635 2099749632 solver.cpp:334] Snapshotting to hdf5_classification/data/train_iter_10000.caffemodel\r\n", - "I0307 01:34:32.141860 2099749632 solver.cpp:342] Snapshotting solver state to hdf5_classification/data/train_iter_10000.solverstate\r\n", - "I0307 01:34:32.141978 2099749632 solver.cpp:248] Iteration 10000, loss = 0.441529\r\n", - "I0307 01:34:32.141995 2099749632 solver.cpp:266] Iteration 10000, Testing net (#0)\r\n", - "I0307 01:34:32.145747 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8148\r\n", - "I0307 01:34:32.145771 2099749632 solver.cpp:315] Test net output #1: loss = 0.4216 (* 1 = 0.4216 loss)\r\n", - "I0307 01:34:32.145779 2099749632 solver.cpp:253] Optimization Done.\r\n", - "I0307 01:34:32.145786 2099749632 caffe.cpp:121] Optimization Done.\r\n" - ] - } - ], - "prompt_number": 8 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "# Clean up (comment this out if you want to examine the hdf5_classification/data directory).\n", - "shutil.rmtree(dirname)" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 9 } ], - "metadata": {} + "source": [ + "!../build/tools/caffe train -solver hdf5_classification/solver2.prototxt" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Clean up (comment this out if you want to examine the hdf5_classification/data directory).\n", + "shutil.rmtree(dirname)" + ] } - ] + ], + "metadata": { + "description": "Use Caffe as a generic SGD optimizer to train logistic regression on non-image HDF5 data.", + "example_name": "Off-the-shelf SGD for classification", + "include_in_docs": true, + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + }, + "priority": 4 + }, + "nbformat": 4, + "nbformat_minor": 0 } diff --git a/examples/net_surgery.ipynb b/examples/net_surgery.ipynb index 75c9889fb5a..1fb99bd3726 100644 --- a/examples/net_surgery.ipynb +++ b/examples/net_surgery.ipynb @@ -1,464 +1,6827 @@ { - "metadata": { - "description": "How to do net surgery and manually change model parameters, making a fully-convolutional classifier for dense feature extraction.", - "example_name": "Editing model parameters", - "include_in_docs": true, - "priority": 5, - "signature": "sha256:f21c804f76329e70847ccb87e28a91e5d8a375f5da0ba6dd85d3b87a05bebd72" - }, - "nbformat": 3, - "nbformat_minor": 0, - "worksheets": [ + "cells": [ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Net Surgery\n", - "\n", - "Caffe networks can be transformed to your particular needs by editing the model parameters. The data, diffs, and parameters of a net are all exposed in pycaffe.\n", - "\n", - "Roll up your sleeves for net surgery with pycaffe!" - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "import Image\n", - "\n", - "# Make sure that caffe is on the python path:\n", - "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", - "import sys\n", - "sys.path.insert(0, caffe_root + 'python')\n", - "\n", - "import caffe\n", - "\n", - "# configure plotting\n", - "plt.rcParams['figure.figsize'] = (10, 10)\n", - "plt.rcParams['image.interpolation'] = 'nearest'\n", - "plt.rcParams['image.cmap'] = 'gray'" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 1 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Designer Filters\n", - "\n", - "To show how to load, manipulate, and save parameters we'll design our own filters into a simple network that's only a single convolution layer. This net has two blobs, `data` for the input and `conv` for the convolution output and one parameter `conv` for the convolution filter weights and biases." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "# Load the net, list its data and params, and filter an example image.\n", - "caffe.set_mode_cpu()\n", - "net = caffe.Net('net_surgery/conv.prototxt', caffe.TEST)\n", - "print(\"blobs {}\\nparams {}\".format(net.blobs.keys(), net.params.keys()))\n", - "\n", - "# load image and prepare as a single input batch for Caffe\n", - "im = np.array(Image.open('images/cat_gray.jpg'))\n", - "plt.title(\"original image\")\n", - "plt.imshow(im)\n", - "plt.axis('off')\n", - "\n", - "im_input = im[np.newaxis, np.newaxis, :, :]\n", - "net.blobs['data'].reshape(*im_input.shape)\n", - "net.blobs['data'].data[...] = im_input" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "blobs ['data', 'conv']\n", - "params ['conv']\n" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAHNCAYAAADVB5V4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nn59+FodZjgAAAABJRU5ErkJggg==\n", - "text": [ - "" - ] - } - ], - "prompt_number": 2 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The convolution weights are initialized from Gaussian noise while the biases are initialized to zero. These random filters give output somewhat like edge detections." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "# helper show filter outputs\n", - "def show_filters(net):\n", - " net.forward()\n", - " plt.figure()\n", - " filt_min, filt_max = net.blobs['conv'].data.min(), net.blobs['conv'].data.max()\n", - " for i in range(3):\n", - " plt.subplot(1,4,i+2)\n", - " plt.title(\"filter #{} output\".format(i))\n", - " plt.imshow(net.blobs['conv'].data[0, i], vmin=filt_min, vmax=filt_max)\n", - " plt.tight_layout()\n", - " plt.axis('off')\n", - "\n", - "# filter the image with initial \n", - "show_filters(net)" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAicAAACbCAYAAAC5xzv6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text": [ - "" - ] - } - ], - "prompt_number": 3 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Raising the bias of a filter will correspondingly raise its output:" - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "# pick first filter output\n", - "conv0 = net.blobs['conv'].data[0, 0]\n", - "print(\"pre-surgery output mean {:.2f}\".format(conv0.mean()))\n", - "# set first filter bias to 10\n", - "net.params['conv'][1].data[0] = 1.\n", - "net.forward()\n", - "print(\"post-surgery output mean {:.2f}\".format(conv0.mean()))" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "pre-surgery output mean -12.93\n", - "post-surgery output mean -11.93\n" - ] - } - ], - "prompt_number": 4 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Altering the filter weights is more exciting since we can assign any kernel like Gaussian blur, the Sobel operator for edges, and so on. The following surgery turns the 0th filter into a Gaussian blur and the 1st and 2nd filters into the horizontal and vertical gradient parts of the Sobel operator.\n", - "\n", - "See how the 0th output is blurred, the 1st picks up horizontal edges, and the 2nd picks up vertical edges." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "ksize = net.params['conv'][0].data.shape[2:]\n", - "# make Gaussian blur\n", - "sigma = 1.\n", - "y, x = np.mgrid[-ksize[0]//2 + 1:ksize[0]//2 + 1, -ksize[1]//2 + 1:ksize[1]//2 + 1]\n", - "g = np.exp(-((x**2 + y**2)/(2.0*sigma**2)))\n", - "gaussian = (g / g.sum()).astype(np.float32)\n", - "net.params['conv'][0].data[0] = gaussian\n", - "# make Sobel operator for edge detection\n", - "net.params['conv'][0].data[1:] = 0.\n", - "sobel = np.array((-1, -2, -1, 0, 0, 0, 1, 2, 1), dtype=np.float32).reshape((3,3))\n", - "net.params['conv'][0].data[1, 0, 1:-1, 1:-1] = sobel # horizontal\n", - "net.params['conv'][0].data[2, 0, 1:-1, 1:-1] = sobel.T # vertical\n", - "show_filters(net)" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAicAAACbCAYAAAC5xzv6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIiIi4pXfPRZNtgyLF3IAAAAASUVORK5CYII=\n", - "text": [ - "" - ] - } - ], - "prompt_number": 5 - }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Net Surgery\n", + "\n", + "Caffe networks can be transformed to your particular needs by editing the model parameters. The data, diffs, and parameters of a net are all exposed in pycaffe.\n", + "\n", + "Roll up your sleeves for net surgery with pycaffe!" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import Image\n", + "\n", + "# Make sure that caffe is on the python path:\n", + "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", + "import sys\n", + "sys.path.insert(0, caffe_root + 'python')\n", + "\n", + "import caffe\n", + "\n", + "# configure plotting\n", + "plt.rcParams['figure.figsize'] = (10, 10)\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Designer Filters\n", + "\n", + "To show how to load, manipulate, and save parameters we'll design our own filters into a simple network that's only a single convolution layer. This net has two blobs, `data` for the input and `conv` for the convolution output and one parameter `conv` for the convolution filter weights and biases." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "With net surgery, parameters can be transplanted across nets, regularized by custom per-parameter operations, and transformed according to your schemes." + "name": "stdout", + "output_type": "stream", + "text": [ + "blobs ['data', 'conv']\n", + "params ['conv']\n" ] }, { - "cell_type": "markdown", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAHNCAYAAADVB5V4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvWuMZdl13/c/tx733np393T3PPkYDUccPsQZiaRkCYpE\n", + "CYklOwYhfwjCIAEiJDLswAkQf3AQIEoC64OcIEDiIHESBAiCCAkkJ4GtJHCM+KHQjmGZtmxKJBVC\n", + "wxkOZyac4Uz3dHe97q1bt+7Jh+r/rt/517499ER008xZQKGq7j1nn73XXns9/mvtfZq2bdVTTz31\n", + "1FNPPfXU0z86DR52B3rqqaeeeuqpp57+SaXekeqpp5566qmnnnp6j9Q7Uj311FNPPfXUU0/vkXpH\n", + "qqeeeuqpp5566uk9Uu9I9dRTTz311FNPPb1H6h2pnnrqqaeeeuqpp/dIvSPVU089/b5T0zT/RdM0\n", + "/87v97Xv0s4HmqZZNE1T1WtN03y5aZp/6v/rc3rqqaeeSE1/jlRPPfX0vUBN03xA0suSVtu2XTzc\n", + "3vTUU0//f6Eekeqpp55+X2kZItRTTz319L1IvcLrqaee3pWapnmuaZr/s2maO/dTZH8E3/2399Nz\n", + "f7lpmkNJn7n/2S/hmj/dNM03m6Z5vWmaf/V+Cu5p3P9L9//+yfvX/Kmmab51/55/Ge384aZp/mHT\n", + "NPeapnm1aZp/7x9hDK80TfNT9//+95um+R+bpvmVpmn2m6b5naZpPtQ0zb99/7nfaJrmn8a9P980\n", + "ze/ev/alpmn+WLT9oPENm6b5j+63+eZ9Xo3+Ueegp556+u6k3pHqqaeeHkhN06xJ+l8l/RVJ1yX9\n", + "65L++6ZpnsVln5P0S23bbkn6vyS193/UNM3PSPo3Jf20pA9J+sl4RLn2Pt2UtCPpcUn/iqT/vGma\n", + "3fvfHUr6F9u23ZX0hyX9iaZpPvttDiXrGP5ZSf+dpCuS/qGkv3r/88cl/ZKk/wrXfkvSH27bdkfS\n", + "z0v6j5umeeHbHN+flfSMpE/c//2EpH/32+xzTz319F1OvSPVU089vRv9iKTNtm3/bNu287Ztf0PS\n", + "/6Zz58n0l9q2/TuS1LbtSdz/z0n6b9q2/b/btp1IqqFIDf4+lfRn2rY9a9v2f9e58/T999v+fNu2\n", + "X7n/95ck/aqkn3iP4/qbbdv+1bZtzyT9T5KuSfqz9///NUkfaJpm5/6z/nLbtl+///fflPR/SPrx\n", + "dxtf0zSNpF+Q9Kfatr3btu2hpF+W9M+/xz731FNP32W0+rA70FNPPX3X0+OSXovPvnH/c+kc6Xn9\n", + "Afc/JukL+P9B10rS7SgWP5a0JUlN0/ywzhGej0palzSU9Bfepb1l9Bb+nki61V7svpnc/70lab9p\n", + "mp/VuYP0IZ0HoBuSfuf+NQ8a3/X71/7WuU8l6dxp7IPYnnr6HqF+MffUU0/vRt+U9FQDT0DS+yX9\n", + "P9/m/W9Iegr/P1W55tvdPvw/SPpLkp5s23ZP0n+p77Aea5pmKOl/lvQfSrrRtu0VSX9ZFyjag8Z3\n", + "S+dO2Ufatr1y/2fvfoqwp556+h6g3pHqqaee3o1+U+eo0J9ummataZqf1Hl90a/e/76p3NPg878g\n", + "6eebpvlw0zQbkn7xAde+G21JutO27axpmk9L+hf07Tth75XW7//ckrS4j079M/h+6fjuI2v/taT/\n", + "pGma65LUNM0TTdPw/p566umfYOodqZ566umB1LbtqaQ/IulnJb0t6T+T9C+1bft7vkSXnZnyWdu2\n", + "f0XSfyrpNyT9nqS/c/+akyX3P8gx+tck/ZmmafZ17rD8WuW53w4t6/Ol/9u2PZD0b+jcYXpH57Vh\n", + "v14uevfx/VuSvibpN5umuafzonYW6vfUU0//BFN/IGdPPfX0j5WapnlO0pckrX8vHpz5vT6+nnrq\n", + "qUs9ItVTTz19x6lpmp+7f57SFUn/gaT/5XvJyfheH19PPfW0nHpHqqeeevrHQX9M52cxfU3nxxv8\n", + "iYfbnd93+l4fX0899bSE+tReTz311FNPPfXU03ukh3KO1BNPPNE2TaPFYiHvqB4MBhoMBlosFuV/\n", + "O3n+3TSN2rYVnb/FYqGVlZXqc05PT7VYLDQcDstnvLdpms5z3Jemacqz+FzT2dlZ55n+brFYlHH4\n", + "Jx1VjpfP8/0cvz9L8rPdL/PS95DIV//tdufzebl/MBjo7OxMknRycqL5fK7FYqGzs7NOv9xX3ucx\n", + "um3zb2VlpVzvfq+urmplZUVra2vl89XV1dI3f+/71tbWNBgMtLKyUr73vb7O/fAzJWk+n+vs7Eyn\n", + "p6c6OTnR6empjo+PJUmz2Uyz2UxnZ2c6OzvTdDot43Pbq6urha85d23b6uzsrDM2X+f+sR32lfeb\n", + "b6enp6W/Jycnl9bBYrFQ27YdnrkdEvtLWXAfSOvr6+U6yvLKykpZU+6Tn3N2dtaRi9PT0yIz5oHX\n", + "p+cq57Bt2zLffObZ2dklHZAyzb7kGC2P8/m8fMd1nOs++8223EZtTS1bl9RVlo1cp+4jn+371tbW\n", + "tLKyUtaI52gwGGg8Hms4HGo0GpU2LZ8ep/uc7fr5ptXV1fIzGo3KnGU/Z7OZjo6OdHJyXi9/fHys\n", + "k5MTHR8fa39/X7PZrHOv1+dgMNBsNtPp6WlHH3D+qE/5v+eLvLWs+Huubz8v9bWfSX3n+9q2LfJt\n", + "vtV4Zdvk/1dXV8sapL7ydysrK1pfX+/MI+ns7KzMK9e9pKKL5vO5ZrNZGZ919Gw203w+78ilx8Hx\n", + "5/z7/tXV1aodSVk+OzvT2tqatra2tL6+rvX1dY1G528yGo/HGo1GHVvHZ7m/bdtqZWVFk8mkyM3R\n", + "0VFn/LQltD2eY/LIY1wsFh09NhqNihxT1wwGA62trZX7PW+cX//YP+AYTk5OOuvTbQ4GA62vr+tv\n", + "/+2/Xd1d/FAP5OTkp3GpkYW7ptxSWbr9FOhUvlRwXNxcvOwrhY6LM9uuKWE6HxQMGxLyo+YUuR90\n", + "xmqGM9twX7y4OEb/b8UkXRhezwevYz+TJzlGj82fe6HZQNvBPT09VdM0Rei9+Gu8oMHwuOikeBFQ\n", + "yfNzf0cn0f3zdTZSVLocHwOAmhOZPHe/05Fi36yI3A5/WxH6s1zo6USQas6Vx2eniW36ev+4Xx6D\n", + "nU+PwfflWkonM+Uz1yWNDOfE8lbTC/zMz2a77puNPOc428hgin9TFvkcyg+NOR0o3pPt+38avGXO\n", + "oQ0Ency1tbXyXDvGkooTs76+Xox/ytNoNCpGkkZrNpsVZ97P9H1ux/JKPnrsdrBozNx2zQiTGBT6\n", + "mXTO2VeOJYljTVmkITWPvG7szDMoonw/SD/bAbY+SpmhLPh5/JyBrXShE8kH/+9167mogQm5HpYF\n", + "IPx7fX298MUOYwZZvp5OiHnlZ9jx87gsjx57ggnU2an/amtQurAD7hPXBfuba926NGWQPPZaok7k\n", + "2GvU10j11FNPPfXUU089vUd6KIhUQrn+jPAeI5OE52sRrz8n2fs0qpJ9yL+XpfLyvloUZGLkW0sL\n", + "Ealh5OroIlNUCb8yYuczE4FJpGRZipFtJIrk69KrTwQvowf2MXnrMRLpWBZZsm1GXgnVJkpkfrmv\n", + "hMKTl0wFcYyJspHMH/LF0WimpXiN++7ok+1ndJ9RG9uuESNnPt9tE+1gSnR1dbWkGCR1/jZ/2KZR\n", + "KCJTfC7TTSbKVkah7kvKlL/jmBMFznRAppm9/i1zNWKKJJ+Ra8Tk9ZmIOsdBhNd98N+1SNkoD++b\n", + "zWZlXayurmo2m5Vo2eiU59XolPm2vr5evtvY2CjtNE2jtbU1DYfDS+j+6elp0Uuz2ayDco5Go/L/\n", + "cDjU1tZWQZ88Bqd6c70wzWIko5YZyPVCvZI6jql3y1eiGWyH3zFd5LY4T5mKdB8TJed6MoLj/i7T\n", + "r9PptIN0MIVHOaFey/Xk750GJI/5P/mW65F21qijZcufU8aJVhnlNLHf8/m8yJd0IcMea9oWzgOf\n", + "R31qtNa6iXLpezKN7jWWKHUikkTkh8NhR7+kj/CgbNlDcaRcf/Fuxt1Uc6DSmDJ1lQ4RnYma8ksj\n", + "RZg+IfmaEmV7tTSGKVMstVRDpm9qfaNgGKZcljpIZZFUUyx8tttIaPhBqRbynIqByiH7QMeC/6cS\n", + "rEHUNn40DHRoamkBGi8aWjs7mWo1eRxe3CmH7EfNYGTagvfW/qahogzm9w+613VblhvWszgNQyVF\n", + "3pBvNvRUnBybx03nz2Pl5zXFV1uHOXfpcHK8NbmiwiRRRjIwyrXJOc60L/ubTikdVxuTWuqVfXU9\n", + "Uuq7tbU1zedznZ6eajweSzp3bE5PTzUcDotTZePlmir3Y21tTRsbG5LUSfNxLJwnp3S4Dj3no9Go\n", + "OFDr6+udtK9rVuxQUV6X6Xp/TqeZDom/s5OVASmvqzlSKQM1R9/EObKusZzSUTU/7EzQqWAKy8+z\n", + "TuA95pn5armhfiDvycO0cymzXNt0UsgPyy9tyXw+13g8Lk6465DMG9dImS+cQ/d/Pp9rOp2WNl03\n", + "5vor8t68qQEP7Bf7kGRniXWzGYBxjdqZo8NF8lpjepZB3zJ6KI6UF4SFS7pcgFYz1Mu+s2BZ4DhR\n", + "ifRQGOmAJWqVTlQ6QdLFxFppsdbFPxTgzDcvMwrJq6RliJT7zfFln0kWuHQaaTxS4dXQoFq7OR5G\n", + "eUYkzLc0IHSe2J4VP4lzV3MibYASAXJBPcfN+7wg0/GmE8L+nJ6elgXNaI/oVdb+pANtviRRcTEA\n", + "YXTlfidfbNzIRyKAvocKfjablTXFfvK35SZlkQhBLSp3PyhXlI1a/RINajqWjLhrwQCdu3T0jejw\n", + "Gdkn8sY1M0ROEo2lImbUTIch5c28MiKUhtE65fDwsGOwiFKxEN3y4s8530YW3Bfy1M82atS2baf4\n", + "mePZ2Njo1MK4bW+YmEwmHcTEsmLjzfusbygfUleW+LnbY11dGjmui1zH+Xmi0v6faycdcmYUqAey\n", + "XsnriN/T4bMT7Pmn82TKNUZnJvV+Xlfru5+dn5mnGxsbGo/HpehcunAkE6RwW9YVRjo9jpOTk0vB\n", + "ittMJ4/rn85eAiJeX9ZDGSBbxiwDXjM5hpqudV8pLw9yoEwPxZGqIUy16CWNeP5tIrPTuFPYsu0H\n", + "OWwPui6NgP/f2trSYrEou1aYJnFfahD0g1I2y/rIsdfuz+hpWXTO67NQl22z6JTOIgU8F1cqr+SX\n", + "+WOlYCcrHRRCvORbRlN8Jp1rOgUe2zJidOO+1CJct51zyfHVEJRlz2SElPPNtOayaKtGq6urGo/H\n", + "BWHgzhYTETj3n3NsR9TP4hzTQNBYZWFmyhwRwORVBjQcZxpSts/ou9Yuv2O0nw5YRtyZcq31xd9R\n", + "4ZM36bRJ3eJ6ts35d8GxkbDFYlGifbc3nU5L0bh/M4jz3Cca6X6lvNJBbZqLtI/lwCksr8ssql5Z\n", + "WSlIhh0pOoCZikkkcVn6jP30d6mj89osneC9lBcaaDpl5Jvn07KUc8ni+uRpkp9np9t8zLS626L9\n", + "Yhsu3M6AmTwl+sI2OPe+zw6OHWXu2vPGBfMisyAMZtimHTMHZ3ROzUvPZdM0nfRibWMTx+Q5465E\n", + "o6UMHIiaWi5qjiUdd+rEZYEh6aHXSOXkZzTo73xfMraWusnrKUzLnDQKbEaFqYRTCXJS1tbWyk4Q\n", + "RnFMi+T2WaJiOU6OaZmx8PcP4lt64eY9lUrNQawZjexD7m6wMUklQqXExcBnZ/uG2wkNW+F4LrjA\n", + "OXYa0ZzD4XCoweC8ZoEQt6FoO1E1VKo29uTRMgWakL+vpbKko2H5riGYbpPjZd9Go1ExfHQIrTCS\n", + "7/4ud9xQdigbtUiQqY1Ee2ikUmbYb/fTz6OyzfVrfqX8p9NOxeiaFtaskei85Nbx/J9rP50nGyFJ\n", + "HSRpWX1JGj1f73XIMR4dHRVEwwbKCK+PNXD7dL69ZigDdBz8HP6YWAs0HA4vbcl3W0YMmE6cTCaa\n", + "TCalTfaPfeLcEkFNBMW8zpS+7880UNqN1HWeW1IGbzT81CmWd/Yz26/ZN/PCa9N1aJI69WfZT/eF\n", + "Nsv99fe0d+lEel2srq52HI3hcFhknulIP399fb2DJtLhp7NP/lt/s+bJ8s5Uam3Ocodd6o4sUSAP\n", + "0kHjZ9mGx0J542/Td50jZcNVixRraT9peY2Pr2UxJwdsRcRoS7q8JdXPdxtZdFZLV9UMLRUwhdTn\n", + "GTnq4aRyLKaag0dllf2mYUo+8HmpjDhu9sNKxHynQlldXdXJyUkR5OSplXsa2nRslzkhdBjIJ6N9\n", + "jlqcguAC5pi4aDlOR5D+YbrM33FuyYNaFMb2H4SqWBYtI4mK0DAxuk6lxmtSeZq2trYKMmA55BiT\n", + "T/7OxbBO0XC7Mucx5akW6XJeE33NNmtyaaVt+aUO8PNpGBOd5f+cRxrudKLosKaDXgsoMuBiSsHE\n", + "SDjboQwlslBzEpb1M5HDZWlSo0Scd39HXrN/kgrCbid/ZWXl0hZ9/3bAkw6h+zibzTprkQ5IyhQd\n", + "/pQny0Q6Xrkm2Re2l8FlIra8j+k+857nQBFdYmDGZ5qfnO+1tTWdnJyUtLHJ/5vfDMLolJlqtsPy\n", + "yPVFJ8q8J/9cX+dn2jln4FFzUt2GA14Wn/se2xTKs9vMAIJjMVrHdDBlv7beag6S+0rbn8FpbcPA\n", + "sr6R+uMPeuqpp5566qmnnt4jPbQDOTPKq6FG9KLtmdvDpIf4btub7ZHXoLlEpdgXEqOUjJoyIkp0\n", + "ROqecJ31R0zfZX/ordfgz2XpUPcvd5cxQieMnMgSU5isr3G06wiMCBn5xkidffV15GFNFjJiIIJF\n", + "apruDrq8z5EzecCxZHGk++7xJ4pX47XbSpSHfOD9teLFZeki3+OxMLpMlCZl0SdjJ1rj6NKpFp7s\n", + "7qjRhcS5LjJNlM9mio98ItReGyPRkUzp5L2mRLRr7Zp/mW5wn31PDTFIMpJIPZTPtpzxwEq2lyla\n", + "98upx5QvRvcei8fgnVTr6+saDoed0+qlCxQoU4mudTLKQTTfJzsbcUl0inUjHH+tEJwImVN90+m0\n", + "s0s06+USTSIim8iK5TtloIbmE6mnPPD51mdMCfm+1Lvc1epTvLmzL/Uex8W++H/zk8+ZTqcFESKS\n", + "46yN9UGuC46fetyUpSmsf2V7zLb42UQbieS5Xq+GEBFNTH3FbEnOI/mWtaFEnCgXtCGLxaKzucKf\n", + "my+5zolAZSnEu9W6PrRi84RqOQF0qkz8nLAmHZvcsr4sx1z7nukOCkme8JoTkbuiMi1QG3M6WZzA\n", + "WrqBcHS2nUJbG5/vpTDkIqnxhqmFWlrExtbPsQKuOYT+u5aarPWBCns2m5XCz6ZpSsFtykC26e/G\n", + "43FV4dChS55L3WJ46SKnbwcjnWHKbebseS3Tekk5127DhjudePLSZ/ywz3aoTk9PL51kvb6+rslk\n", + "0nE+BoNBqYtKntJJ4v/uS65p04MCnVwL6dSQz7mGmfbw9emcS11D4X5n6j7byDQ6yddwvec81NK+\n", + "NVmgk5tOlmstaRhNbduW18bYmWIK2k6mj15gOtxOgHWC15P153Q6LXJuJ+Hk5KTU7XitppNlXZi7\n", + "YRk4DofDjp7mRgrztBbs8RmcS/Yhi4M5jzTgdog572y/dk8G0Jyr2k7dTDXZWWaKzs6mZYXrx8Gf\n", + "5yIBhlpqjzqXa/Ps7OJsNPPXNi3H5P5m2pf6x33hphynNy3/eTZVHjPDfvs3bUDWidYCL96f7ZFP\n", + "tM8eS8695SH9ELe5rLSo3P/Ab79DlB6xpEtOUCoNDrKm5KloKVC5GKmUiKC4DT4/nTbpcrFerd7h\n", + "QQXINBKpMOgQJoJUUxxE8JaNnUqa9S6JHGRk6MJSP5vndNjL39zcLAiGpPJOO+/oSWfB/a1F6nkd\n", + "58F9pAKSLuoWjLBwYbB+ywo6597jT4TTfXc9h/vrV2cQeWQ/+ZnHSmXj/qURrjkS5A3XCxWDDaT5\n", + "sLW11eGjjdrGxoZ2d3d1dHRU+LZYLLS9va3RaKQ7d+6UNnwQI5V7IhxE/2p1UP6byF+2ybmmovfc\n", + "+TvKbN7H+fVz0iG2A+57cq5oGDgGritS1riQWBz/IMoaEuoBFvOyP5ZJRuj+2zUtvM+8MAKVemrZ\n", + "GUZ8rxvfpejaKq8VoiLJ76ZpOs+0HNZqmIhGZ7Evn+f7OH46Tpwr94sOXOqOZSgI+0RdlYdVeh7d\n", + "pvVNDSXjLjW3a57O5+fvdyMSLKmzycOoejp9bIsyTEcg1xydS7bj+wgMJL/TiWWAaVnyRgR/58DO\n", + "6FDKqNtLnuW851jz+mW2tMajmm6l/LHuzv1LPZD00IrNM8KkN5reZio+Ks9EWUheCF4ED0K5GPnx\n", + "Oct2SjFVlEJaixj8PxUcBclCT0hRulC0NaPt8SfsmX3xdTXEh5T8JgpkgXMagUW1VAwnJyelSJlG\n", + "wuN3P2qITE1RZBrUPPH1VmY1x6XWf99H5ctFxIgwn+d5SDl1mzxnJ5E5olC1uXI/mD7ytcsUsw/I\n", + "cyR48+bNslPqnXfeKdecnp5qd3e33Pf222+X+bh69aomk4nu3r1b+O31lYqf823+1tApU64nUhrQ\n", + "WuCSCs/r1G3TWJCX/Jv/p7OUn7vdmoLmdwyg3FemhdIxJw8sP4z+a333d9ztRCTNhs2yk/rB629l\n", + "ZaUEOOYjdcpkMuk4S0Q/WLCeaF/bdl8+TSTH+pFrKA0j1zADOF9L3lMfk9/We6nbPC88r4j3mV/L\n", + "HGXzO3Wk9Y1l0f30phXOB8fqteTfNYc3X0xs/UEdQseKzgvXpK/jeqJc0V6kbuHc+R7zkAief3t+\n", + "fQ4g1yjn1A4mN5J5LrJ/tP2cm2WOTM0hTB1APcY0N51Gy6EdYT7T6+BBAdJDfWlxzdNLB8O/GdVy\n", + "UVKhZhSZ3icdsHSq0qPP74gyeRGn05OMToXsyWB7fp5pPp93YHorJEPAtYh7mYfetm1nl072iahU\n", + "wpzul3ex+XsrDSNWdChPTk7K2SNEp6QLYeQ81RQKHeokf8++LjPWnEsrvExt1QwrDYd5z+sodySO\n", + "j4suFbhlmONINCFRHo7F50K5baKHbduWk69v3LihtbU17e7u6u2339bR0ZGuX78u6fxcn9lspsPD\n", + "w9Ju1g3RGfQY6CTQkSYPa5Egx5Jkx9HP5trLtc01yr7WiP0xcS5qn9eIc+F55VpchnLVomvKKB1s\n", + "95MpbD+PazvrS7z+bBxtJPy/9VTuvGTazrszJXWcLc8j09uWbbfLQJMy7TXDl78S/aND7HvdL+kC\n", + "xSD/0rmyM1ALWjPQoQxTj6ceomNSs0F2MqwP3ad83Q4dW8tv7nZkP2vItOeBvMv7arYz/2eQTr6Z\n", + "31yvzEBYr9euTQczn8s1zN2H1il5vqLHknqYgAPlxfaT81rjnX8vC/D4TDtQPCDVtEyfdZ639Jvv\n", + "IDG1k8rQSp1MIrOWwX1s10Tna1k/an2g8NGIuE0LU0ZQjAJM2feMVPK5NbTKW1LzoM+MElOBJyKW\n", + "4/CPo41EAMwHKw/pomaMyBTn04Wk9u6Pj48ldbekppPBhcGo3v1gfj0dVyploj5OdzCKSx7UiBGO\n", + "lQcXfipn/5+FuaZMP/jvjJrSQaHctW3bORiPxteo0GKx0ObmZvnuySef1M2bN3VwcKCjoyNNJpPy\n", + "3Qc+8AG9/vrrZW6YSl5fXy8pQLfrvrKPHk8qHMt1Takn4snvOFeJEPmzNJZ0rLh2/L/vf7d70zmj\n", + "M7wMOeWp3RwDU3OMvNk+ibojnVken8IaTqn7qhdTbrDwuiJvjXycnp6W2iiiIGybcmFq24vXgWQG\n", + "4Ozs7FI9mvvuYGEwOD+7rZYez/FQzmvBLddIBpl0ZLwxxp9nDRd1dKIXWRtjJ2NlZaU4fDbAGQCw\n", + "baLNXstOnRo1pI7w3JlPTrm7n3TkExRg8EEkTFKnRMPz4e8SRWf//Qw7+wwWrRcsczUEkGsqbSDt\n", + "EJ/rdhPl8vW09ymnvt6orufJPE2AgKlyBjKmd6uR6o8/6KmnnnrqqaeeenqP9FAQKUag9AIdtWYx\n", + "Mj1XwvzSBYxKDzyjHXvoNXTK9xiG5n2MhOid5q6mHIPbleq1SPa2s76Lz6WHzfTbcDgskWTuwMn0\n", + "FseyjByhJTxuqNPeu/njQnOfAM7IzGmP09NTra+vazqdFt64borRPOeZEQERKc/bsnoHp0L9HWuc\n", + "vHtkGQLFCGcZ8iFdrhEyn/muMcPXhLQpb45wKTNZNJ8pahMRCkZGa2tr2tzcLJGuEUvpPI25u7ur\n", + "nZ2dMi9GoK5evarr16/r9ddfL+/CMgrld7OZL5kCYyEmUVWmUGuolGU607fmEefORP4k3J7P+XbQ\n", + "xkT5/Dd1jqNfR8+JDpovNaTLfU20mXNtqqWOjDrVULbFYtE5+dqoIHcVU9aMmJ+cnHRQJKdWvD6I\n", + "uvl+oyOca88do/WcX6fgBoNBKaD2PBoZMPKQNVIp8x5jTf/6+TU97756TnP9U3e4nUQ6vA5ZYM0U\n", + "K1FZ6WKzi9vwvLh9rzGj26yt8jWuIaJObNu2HNZJniWyYz5ST/n7zJ4wxWbExqldv7DYesx/u6/U\n", + "B4nUGnk6OzvTbDbrvMrI/aghzrkBoWYDPQ9ZT0hEjvcxE8W5kbqZllpfPO+ZPXJby+ihvSImoU8q\n", + "p3R6qLBS4aZjlSkTTmItx8kUhZ9nITPTs0DQ189mMw2Hw046qJbek7q7c6y8MiXoSSTM6X7ZmeF3\n", + "8/n5m7a5RXYZ7G7KflGJ0JhQwVhxmKy47US5P3agzs7OdHx83Jk3GlH/JJRL2JUK27tAEr63M2Ml\n", + "7q3e7qPbzfScx5MpGPOBcDl3z7iPi8WinL2USjyNZi5YK3grMc8VDRqdkpRFzqGV9COPPKKrV69q\n", + "Y2Oj1D299tprOjs70/PPP6+bN2/qox/9qL72ta9Jkt566y09+uijms/nevPNN3Xjxg298cYbki7O\n", + "rjk8PCxjSXifxj8dF65fKl1+nulAy3SmcNJBSsPhdUl4nqlUznemK2igm6ZbJ5PzWktJe3x0CMwf\n", + "zzEdoizArfWtZjBMLIJ1X3JuPHYWmVueuRuMDhSdf6/PxWJR3q2Wzo0pa+TcB6+tmlNsObBDTt5Q\n", + "b1JPMmXjdQ3XAAAgAElEQVTmsbEPNYeWupz1aVI3jc2Uln8zcGOtls+Isp5kP1nL5jmiDuBOQZ7Z\n", + "Zp75eazH5JxmKpLymPV+Hn+m9vJ5Juph6zvrIzp9rN/L1B5tWwaUlEuvGcobbY774+eZbPMpF9SZ\n", + "DLS5GaUmgwYjaIfcN65df0Y+1fyH0vbSb77DxHy+yYOhopa6RbX+30QFZsVSi158H+8lCkIB83OX\n", + "1XI5ak1kidFMkoXmQYhHjtvfsSaFyJmjPBdFE5FIHqTCoaHLKNERlGugMjqwl88IVFJHQM1bCn8q\n", + "nozS6VhwjshbzqHbc/TD9mgUJF3ajcGaq+QLo1YrFKn7mh+jgZxLjikNCuWMBsD9TiPNdsk7Opmj\n", + "0Uj37t3TRz7yET3yyCNaX1/XU089JUm6c+eOptOprl69queee07r6+v65Cc/KUn6W3/rb+nWrVtq\n", + "mka3bt3SzZs39fTTT0uSXn75ZY3H4yIDHveyeck1STmhMeN6ZzDAufF1NTSu5iDlOiNKkcYy17rv\n", + "z8g+dQCfx3lLRMbkuaoVufp7yonXYU0vZD8oz+ms5/qiI85de9xR634QDUjDukyXmXIe+W5H8571\n", + "g2ncs+CZ75hjQbudw1owkWvMn+drW0y0MenUSBfvS01ZYzt0zoiomoeJHvmeDOASkXMfvM4dsLNG\n", + "yqgibSI3FNjpa5qm8xotPpPjJRJJuU0UyfNLdDGpFjjyu7zH9XzmH201bSllhvzKoI38tM1wm0bb\n", + "bdusc8gXBkk1gGQZPTRHih2WLhu+7DQhVSo/MjMdErfFk3zTqcq2pK5xqDlHXCw80JCQYc2RqSn1\n", + "GlHYapGfF8XKykpJ9+T7mqww6bXnWDk2evBGunxaMu+z8FEIs2DWO/c4TjuS7sva2lopuuQ1jpJN\n", + "LIhM40g+5a5GojhWOHTUKHtZtGhDkzsPeSihr8u5TxkiWZ64lZjjoPznXFMeeH7NI488ojfeeENP\n", + "PvmkmqbRk08+KUl6/vnny0nDu7u7Ojs706OPPipJ+rmf+zm98sor+o3f+A198Ytf1O3bt/Xxj39c\n", + "0rkDNplMOjsy6cRkVFyT41RuVpJUrjRSuY0+EZlc69Ll1IKJfaWM0imwnHp9cK54v40FnUQGe+m8\n", + "0FFLBIrPoXLnRo+a/jKvanog+WviWvOPZfjo6Kjzkln/li6/A9B6js+jHqYsrqysdDY7mAf+24Zw\n", + "MplcQpXT4SS/2QfqgKZpHojy2SinbufYcnzmW81hzfVMx8X6xbzMAJJjoZw4ADYRYUxkxw6H26It\n", + "M3JXmyuuAT+j5uCbqAuJkltWuP54rBCRP+qMmu5gH2sInHmaPKwhssvsKG0ZgwofYJs6ymhwzX67\n", + "L7UyHdNDc6QywmJ+WOoqzZo3SONrhUPFY2rbtqSGEnXy5GZEWPuM7fG5XIyMLjMdSGXi6/L0VypE\n", + "pqjSM+dClFS2xHOXj3fPuR+LxaJzuGSOh5GdpOJI2JmiwNqBS0fKnzl62d3d7QgqPf5UwuY1Uw/u\n", + "l6Mxzov5xV0knlf/pvLKM214GnGiSjQ+dKT8ORVM8sXPdrsZXZMYlVNZpKKzonQQwV0/TzzxhNbW\n", + "1nT79m29733vK/UOH/jAB0r91PHxsTY2NjrG4YMf/KAef/xxrays6Dd/8zfLePb29rS6uqqdnR3t\n", + "7+9rNpuVs6nsrNaMV40Pte8T5RgOh5d2PDEV4rXkwCWROj6vthY5B9Qn6RBzXXBe+Bz3z7+5Xmv9\n", + "MjF4s8HLNu3ceczsB4POdAbT+PB5PteNuojrKxH6JKLfHpeNptEJ7iYdj8edde51s7a2puPj4xLQ\n", + "+hTs5Fc6hBxL8p/6vuYseb0ZqefaZDvkAflGZM5EpI0vXmZg6d90Ij22WpqNMktngzVHadeIcllf\n", + "0AlgDW/WBNlhIJ8YxJhPltNEssyvwWBQMgHZL64njt/31Wwoeez77Cj7ANuac+rnp27Ndk22UUYc\n", + "aWct27ad+RqjWnul30u/+Q4SDSGVBhVeKuGMKGvtSZch17wuryVUz+tqk2XKiUul6EnnIqXR9iRT\n", + "AVjgEy2hAq05fL7GyJRzy/bYLZBte/5ONX+fC90RBWk6nWp1dbVTB5ZGh4rPffC1VrLkjdtN9MZ/\n", + "GzqmQvEb0lmv5HlwZJZpIc6b2+PBcUZc3A+Oz/PDE4fNU0fCXnSUX8uR26SSSgeJfzOiJQyf1/l5\n", + "5vnOzo5u3bqlZ599VisrK5pOp3riiScKH40M3r17V2+99ZZ2d3dLm1tbWxqNRvr5n/95Pffcc/rq\n", + "V78q6Vxp3L59W0dHR0WReR5v3brVUaxpxAi3M4IjUmpZdztZDMr167Vkw+S5JF+WOQK+z+uG/aEu\n", + "qUWZnkPqJ/ZP6m5Q4PhJD0LXM7peJhs0ooni+blek+aj0Wkjy4lsUEdxzTCgyQjcBtCoizc6+DR9\n", + "R/mM7JnaW11dLRsajJa7Xc/PdDq9NHbq8gySqS9zLqgbciwcR81JJg85/zxjiGvb93IsWXdF5zJR\n", + "Ko7R9zEtad1Ane0atpoz74Brsbh41xyDb+otrkU6Oa53pa1hip/zS/3IwJ1jJAJMnZi1x/6Ozu+y\n", + "miWvQY6PNpKOpHThRPlz6h7y07rdtLKycum4k6T++IOeeuqpp5566qmn90gPDZHKVBu99kQVMs1H\n", + "BMFETzej5Myzsx0jNlmMyjQSUYAawkQiGuXn+HpHGPbQCSUTlchtljWkKvvg3+6n05ncESNdbLl1\n", + "VObt0X4O+ekaMEYtUjeK4edMXWb9xXA41MbGhlZXVzWZTDroEusKHNUwtcd0G8fCCM1btjOn7zER\n", + "6WHUnKkm/+9+sC98aSujKs6R5zxTCYz6/X/KSKYS3B/3aTablWMlpPPTy0ejkV5++WX9wA/8gK5f\n", + "v64rV65IOo+w3nzzzVJUvr+/X3izubmp2Wymxx9/XB/5yEf0Iz/yI/rhH/5hSecHeX7+85/Xiy++\n", + "qJ2dHY3HY+3t7UmSjo+PC5roiJnjYoTNNcA14ojYKJf54/Rezhl1BaP3lFVTIsWMXIkmLSuWJd8f\n", + "hFqx3exDjsPXU96IvhMNTj3k56RO5JrPvgwGg1KgnCUG7A8jcLfp9qTLB4kSOTci5ZP0R6NR2cGb\n", + "KRwjwX4Gj+JwOUKmWvlc95fjp84wypBrMtM2kjpF2pkupq1omqaDkFlenBZiX1Ivs99sN1NZRP4S\n", + "4WzbtqS0rAN5Unwt80JdQyTG9WzZN6NVlOFEizIDwCyH26wdrZEy5XE6vevrs9+JjmY2wGSEKNeF\n", + "EUDLh0te/ByvfaNRfAUOUU+vYfL3QfTQTjbP1IB0udKfE2xlk4bP1zP1lQVzmUYxURh9rT9nOo1K\n", + "2G3U+s3vqCjdZjo2CVtL3SLXGl+o6MwLwqYJYbN+RLq8s80GkS8o5Xis9OgAMD3jv/kdU1BeNIb+\n", + "5/O5hsNhqZnwmN0f95njcF1Fjd80FLyGdQPpMPk7Kxumarl4CB1L3ddS1FJ1djBIGSi4nZRTGoja\n", + "GK1YCZtL0s2bNzUej7VYLPThD3+4GKjf/d3f1dnZmd555x1NJhPt7OxoMplIkvb397W2tqZ33nlH\n", + "r7/+un7oh35I165dkyR95jOf0ebmpn7lV36lGGKnb3Z2doojVXO+M/VMnjLd4rQj73EaplaLkE4U\n", + "5yd5ZaoVv7JfXitMybjdZW1ynDXj5fVdKy2gHiCPqEcyrev7MkVZ60c+Lw1zli5Yx9RqTzwPdGra\n", + "9rx2bTweazQald88X25zc7OzY4w8cnueZ6b9uIWdu9MexHePwXqVRpG1oi43MC/sHFnfDQaD4ugl\n", + "r/k89zk3TfA3X+GSThHtE4N6yijtDNPiKSvWo9Szqd/YN9a6JSBBuch6Kq6ZlPn8339z3bnP1KWe\n", + "f/JGurzjnZtO/LLjZQ5NtufnUMdLKvK6srJSdqSzTpf1aAQ0ci3V6KEhUu4wJ4DKiDloT2g6QVJ9\n", + "NwCvs/GjsyXpkkKqCUoKHYmL40FjZD+WOYJEqzx2GlYbgqxjqil/fsa6CTujuZuitquJyv7s7KwT\n", + "mbkIcTqdajweV2savFgyGnCU52ttNGxouehoUHgoHZU7ayD8ORVQOpzpyORWX5MVe62Y10q65kh5\n", + "jMztZ4TlvtSCAUZvGV1KF2c8+d7t7W1tbGxoOBzqySef1Gg00sHBgSTplVdekSTt7u6WImC/a+/g\n", + "4EBN02hnZ0f37t3T3/t7f0/PPfecJOn973+/fvRHf1Tj8Vh/7s/9Ob300kultmp7e1u3bt3ScDgs\n", + "O/tqyttjqJ35MxgMyo5Of055Ic8sJ9QDiVYl5b3uT35HNK2mJNMwsX3qo6w19PzXiqRpYHLd1IrW\n", + "+fzUUb6PNX35uREFGiE6OenweCcWDSgde4/JheV2pqRzI+X17ppKHgHQtm05HJY1l8fHx2W9Oyiq\n", + "6dRcw4lisPCdSJTl0s5S256/j3I2m+n4+LjzPKIsdhwZGCXKaOImjET/GPzWAnDqmVwvPKIiA29m\n", + "FtwW73Vfc7NS8nQZyJBBtR3cxWJxaSe3+8YsRKKaNdCA9/qZ387mDY4xgRKuFdsM2yBnIszb4XBY\n", + "zgo7O7s4FNXEXZL2I5bRQ3OkclspvXIbHTpZUtfA0wgnFGeqRZspyLnjgp9LFxNTK3JNRyq9bio+\n", + "omqLxaIUYEoXsKLh7fl8XlUK3u1CA0DnLJ0398N9zyJAeuDkMyMS981C5VTfaDQq51ZZGG2cGD3T\n", + "AWPERYcgF3TOIXlAZWMDYgeKBom7P7yguEuSz6PT5rlftvCtMNJ4eV7oRC07Cdd84nEMLHBm35yK\n", + "GI/H2tzcVNu22t/flyTdu3dP73vf+7SxsaEPfehD2t/f1zvvvCPpfCcnnTOujUcffVS3b98uBaUn\n", + "Jyd66aWXyjgef/xxvfDCC/qTf/JP6hd/8Rd17969wksrJZ/JQscgnUTuRrUhcfqHfPKasKJLhTWb\n", + "zS6NoRYQpTHy2HNrOJ0IX2M0M9dAznPqnkQQTHQImRJhBC5dTj+lsU7jVou+ibrxc/Yj0RMaQV7r\n", + "9HHy13z02jfCvLm5KUklbe8f8oaHJTqtzBS85cjpQgcDx8fHnefWguma/na/fR/XFI29EV7LN7MB\n", + "RCvIB88PUS/pPMgxcs5+2tbZEU2AIOeH9pDBLG2X15LfaWr9UUMz6az5XpYscC3awXBK0denvNWC\n", + "BzrBtIvD4bDoMKKPlgdSolWZHTDRuXefM4PhPo3H47Lr2HK7vr7eKTx3W3SYjL6aLy5HWUYPxZEi\n", + "/EbHhJNH4a9F8bVJkOqKlWhA1qjUUCde475QELN/CYXaSBoVYlv0oi2IfAlxRjbT6bQ4VRlh+28v\n", + "/vyc/SS8yv6YlzTs/p588ziMipycnJSddL7PzpIXI5W062LovDJKdt+86PmdFSIjBPKNn1H4rbgy\n", + "H+5FxAiICB2VGCkVcsoAIfTc5s4goIY6sT98tuVyOp1qc3NTu7u7xei//fbbOjk50QsvvKDNzU29\n", + "8sorZWfUeDzuGBJH4B7H5uamJpOJhsOh9vf3y3dvvPGGVldXdf36dX3yk5/UH//jf1y/9mu/VuTE\n", + "Dv3m5mbn0M50jIhgmAdWZKzZYK1aIs9U+jT8nAvzOI2sece5JVHXZAqHCj0dfAYuNWJ/OId0OGtR\n", + "NNtMncF2Ui44Hn9nw+LPuK551MQylCJ1BvlkJ2I8Hmt3d7fops3NzeLoJxopnc/XaDQqiBSP8ODu\n", + "NPJhdXW1yCWdbfLUDlG+fsnG0zz02hwOh8Xo2/FhXyzTlsd0TrwGmBJ1/4zapLxZ/6S9oLPu+WLA\n", + "Th2e99GhN69qQEAGJ+Qh+57tM4VpIqpG+bOcZLbD91C+yQeibqlvbT8Tacv2s4+eN6d0LVeSyi7m\n", + "jY2NS3o29S9tg9TdRVijh+JI1RAiTj4jRv9vAUiUigVxTC+4TS6IjMw4yWyTBZMW5HTA7Mmnckvj\n", + "SzTIDhKRJPLBjh6L9Tx2e9FS1wh4TFRG0uX6L1/PBZWpARqrmmPqZ9uBmk6n2t/f76CLnqM0Nv7O\n", + "/Ga7jjw5HhoT95Nnq5AsLxsbG6Weh3UX/skCecoc+2o+1QxwLeVmYvRpPibaZR4SefB4E6Hk+H3N\n", + "yclJOb3cZzCNRqNy0CL57eMbtre3y3k60gXCY8XStq1u374tSbp9+7Z2dnbUNI0eeeQRffazny08\n", + "+ut//a/r1q1beuONNwpvc55yzjwezz/XHakWLNkRoIEhb/09EWkikbw+5Zjrj/PKYGYZlF/7PNdL\n", + "puG9tmsGg0Rlzb/tNCQST2cnDbT/rvGUupKIlJGcROL9HCLiDo6kc0RqY2NDbXvxmhG273SeX+NE\n", + "dJiGu2masmFie3tb9+7d0+HhYXl/G9cI9Q7bdDqH43E//Zm/51pz4GGdyPokyhWRZPKPzn3Kac4R\n", + "76s5tERu/Kxsk31IO0S9k1kZykTqMK4l1yaR6PQksGHUqYaqWp+ynwyc/f+yWljy1GvLjhJ1Ltfv\n", + "YHBej+ngmnV9NX8gecYx0xmvUX/8QU899dRTTz311NN7pIee2kuyx8xIK3cCSN3TgumVp3fPIteE\n", + "042QEAnxd0ahEuIk9J1pDf9v+NdtsU1He/S+7aUbceEOOkf2fB+Rn+M6o6zHcB8Y+WaemZA9UTJ+\n", + "xzF5PIvFQkdHRyV1xKiUp50TRWRbTrExFTEajQoqZf4y1cK31fOt8szpr66uanNzszPHTCXx8DVC\n", + "y0lG9/w3EUt/lvNO/vhzX8f0tH9nOol89r3ug1MRx8fHunLlis7OznTr1i1J56+B+b7v+z5NJhPd\n", + "u3dPg8Ggc0DidDot8u+onfPQtq2Oj481HA4LyvXWW2/pm9/8Znlx8fb2tn7mZ35GkvSlL31Jw+Gw\n", + "vAqEKSojYIxgKfs8AJXwvmUk6yNMRKWy4DNlheTvslDXfeVxC7X1kygJ5/DbodRDWbzL/jiqzoM1\n", + "eX1NjrJeqsYDj9dEtDhTkP48i65zXOZNFnhbXyZaQV09mUw6qV2+SirRupWVFW1vb6tpGh0dHV1C\n", + "g6yDbTPMI89tns7t+3ywZqagXcvDFBbLFvycGm+o9zIzQvQw58K8y9Qlvzffc8243bSP1HNcg+wz\n", + "0UyiW6xzytTaMp0mdXdMJxLLdvLFzOYP54Xj5701ftTG7DlwnRNrpCgTiWQxm0L/hHV/y+ihvmuP\n", + "TEoHZTAYVIu7crHVlJyZyxxzwtlmIhcajRknY1kaIuF7P8f3OB2V/VoGqXsCCQUzFeYxMK3pZ+WC\n", + "Ia+YussCPvahVvxs/iXseXh4WNrxd94FYSNLwTOsT8eVRngwGHS2PvNskhTgNNBbW1udRSGdpxpc\n", + "O8E0gPlCqJltpszw+Qn3kprm4ugDywblmw507mSh88zFa/Kuu/l8rmvXrpVjDO7du1fOeDo6Oiq8\n", + "l85lw68O8jO4Q8XpDab5pPPjFKbTqU5PT/XWW29pPp+XZ3z2s5/VN77xDR0eHhbDz/Xk4lfzjfzK\n", + "gIR8t4JmutkywFREprEywGEqxm3znpRTpyJc72fesG8pe3ROavorZYJj9L1Zp0THufYsqZuySKK8\n", + "kuyEZtG05S0Nhv+nI2XyOVHuv+uceCaQ5YHjM9/p7NCRog5lIOr+uADdgRDfTpA6knzzZ6PRqKNP\n", + "neZhKpmBE4NryoIDEf9PvcAAsTYPHCuJutfjYMCa9oN8YZCf/K6lCik36XgyXewaSPOP4/Uc2PGh\n", + "A+71n7qNfcqi+dS9Kdt0dnk9++T+8Dm2C9vb250dwizzsNwycJIuCtW9Rthmja+mh+ZISd0dUYwA\n", + "zUAKXm3Bs51Uam7T7WZ9TBaP83lUPInImHhfLdedn7EgPCefB3IaqcozlvwcjoU1IYmq0YCmQ0PK\n", + "XU7J67zeSptoh9tfX18vhXzHx8eduqRapFbjl8fPwkUqNO7cMwLjxULH24vFirEWlXuRUhFlzVjN\n", + "OHFeajvz6IRSvnPREgG0o1RTtk3TaG9vr/TNr4F57LHHdHBwoMFgUN6rx7nwWpK679jKiHKxWJSi\n", + "3qY534llBODu3bt6/vnnJUnPPfec/ugf/aN69dVXS7s+zsIKisqPjkPTNJ0dQrXAJ/+3c8KC1JSZ\n", + "5HFuIaczYWeRhdJnZ2c6OjoqO8W8O2eZY0OekdyPWtS6WCwKsuj/ExXN3XIcQw1x8+c0TPmbR4+k\n", + "0V5ZWSlzZ6Jc2rF3NO/59Vry2qJjaX1UQ2Rc32dZ5xk9RCJSLrzDb2VlpdQEShfvvaS9MCoyGAyK\n", + "k0cbIF0UZbPfzAwQ7eH8UJ97HdYQ7XdDDjkHXCtN0xRHlXzhGniQ7ubaqq1B9s9y6uvZPx+BYd7z\n", + "6ADKLeXO/XIfszA712wN/MisCANa8pXPTvnjs8xPZyXMI/Iq+2J+5TpKB7BGD82RIjQpXThDiSxI\n", + "deYTkqNTQ3TG1xMFIZMYfSSSkyhPKjg+k/e5P+5zOiRMabF9pjDoyBB2Tg/cCsLIVKIudkxTCfiZ\n", + "iRqR7x4HF6ev8TgN07qNO3fuaGNjo4yHi5/jcrt0lty33L1SQyXpEBh5srFMBIgRCndH+jOPp+bU\n", + "ZeTGOZO6BaHpaPvamvPC1Jafs1ic72piFMR55HsLPSdXr14tzs729nZnZyPnKZFTO/WLxfnuPaMy\n", + "bntjY6MUoR8eHuq1116TdP4i5J/+6Z/WX/trf01//+//fQ2Hw04Eyg0VngM/j1uOfX3yquZE04ki\n", + "QpTBUo33vmZ19fx9kUYjNjc3S6G9nVCflWWnygXOGUHXdBPny5/VrnP/aZBqyrlWwL/sWj47fzP6\n", + "Tj1iHhH1oIGvjcMOCueRc0X0PFM0fs+nn8/1QmeBzzeiTF7wXaE0tImAEikjcuZ1b91Hp86o+Orq\n", + "annjQ65394W6hkF8Bpcco+Un9QvRJY+HtjB1VCKQLv3g/FO3Uw+nDSR5rLYni8Wi6AXysxbsWYd7\n", + "HmqbInztsvVkOfB9DyIHZh6b2/RcOxPB3ZzcIZz2mTbY/OffecRC0kNN7ZGRhOvSm+bA+b8pvUUK\n", + "DR2ZTC+QGLGnocv/0ws2WZC8rdaT7edzIaW3bQXhA+1yh5UdDC5aw7CO9mg86LC4rxmheNFTgMk/\n", + "54XTyeR30oWCefvttztGiwgJHUGmmPzbfXA6h8o9HT5GFl40nuucE+6upJIiakR5omJNOcuFRqeB\n", + "0b/b4XzkMRyMaJc5YX6ODztcXT0/w8epNu9COTo60tHRUUHnfJ+Vsf/muU48ysDX+buDg4OyTbhp\n", + "mlKTdeXKFe3s7OgXfuEX9Morr2h/f/8S0mEZ4XpyKs0GLAOTRFY8T0aGlim3TD+0bXvJQJtvw+Gw\n", + "1I8Nh8PO29/NV/N0a2tLd+/eLTvGshaJ67eGkqeO4Vr3d4km2AmmrjEyRCPNdWpngvLiZ7hNH9jK\n", + "wMzGZzqdltf+SOdonE+u39jYuLRLaTQaaXNzs5wK7Tny8y1PDpJshL3jji8e5zqx3nS/6NjYaZlO\n", + "pwV99Tim02lHpknWw0agiCwxg8HvzDd+R1lMuaXj8aBAP4NtrvuU4zzA2DxKgKHm0JDm83kHzePu\n", + "ceox98NkmTMaRbTJ/cgxEgBg/9g+5SFBCTrFtD1+pueMQWnbth0AgbrGZ5p5/lk/ZSSViGj2iXbJ\n", + "/cua46SH4kjRqSBCYsOUkQAdq5rjlUyoRWi+n/VQVDjShUB5cVsAKPz8P59DuDEF3wLq79hvQ+gW\n", + "KAohoef0sH0tD/JkxG7BdxtUxIwcLJQUOI49Bd9zyDSbpFK4fPXqVW1sbFxygPxcj4dG2FGVx0LF\n", + "mIbZ/XFNEGHxmiPlRZpRo/lFRVKL3hKpq6EqrP/yew5JdKAsWx6H/0+5Yv99Bpd0ntKTpOvXr+v0\n", + "9FRXrlzR0dFROQHePKKD3LZt5/123/rWtwpKd3JyUr6zw/nyyy/rySef1M7OTlHub7zxhnZ2dvR9\n", + "3/d9+tznPqc//+f/fAcBTAeRqfJ0GhOp9bP5WfIwgwB+nvrEz3JtjzdHSBebIlzrw/XN9WXeZH+s\n", + "p2ho340YDCZKTMeW7dmYzufz0s9lPGBQ6sDCr3JhytAp35OTE02nU+3s7JS05p07d0p7W1tbHWTB\n", + "NUC7u7vlEM50wGm0vTFEOnfQZrNZqUWjUaqlZ8gDf2b0k2gdt+eTN/P5vByQaUokM3lm3vj5RolS\n", + "f1E3PSjtxGcQnaE+9Zp3m5xP62X3MWXN/as9x/22TjU/PBeUOc6h+0hbTBvFYDSDTEkFzSNvmO7n\n", + "mNxP88/ONFE3IvR0Bq0jqW/pgDrATDAhUSg76f6uht6THoRI9ccf9NRTTz311FNPPb1HeiiIFD1E\n", + "eoeGOe3B1iJSe+iMBjINmIVn9koZgRDy8zUmXpcpMXrDGSEmesMiyoycMirNMTIScORs9Iw8My8c\n", + "Yfo5rkfw27YdpdRSeO4fa0ocjTgSIILAnWFEegaD8xeA7u/va2dn51KkVsudmxw5JYyaUQqRKR6s\n", + "xjRAzkcN4XR7WdPBOq1EG9ieEYREURxZZUSXc8Z5Z+SUtYOOkFwPtbKyUg4sXCwWOjw81NbWVgcC\n", + "931N05RXEY1Go/L6mBs3bmhnZ0eHh4flOIPs087Ojt5+++2yU1A6j2Zff/11PfXUU/rZn/1Z/Y2/\n", + "8Tf0la98pcgM35uW0bXnJ1MgHgdTwEYyrAcYIed8eM48ZpN56fTW5uZmQd34olLzyZ/x9RLb29s6\n", + "Pj6+BPFzTDUZqaXDvd4T4TQxDZztEY1KXeFxUGc4micSR9R9dXVVu7u7Jd3ilOd4PNbx8XE53dtp\n", + "EukcoeLmDacLqcM8bs+hd5c69Xx0dKTpdFrejmB+14q7PT6XBBhx2d7elnS+yaFt25K+IpJPBMTI\n", + "CwuO3V6mjGg3skyAO1yznsb/ExWqyYQzCjn/RJf42+Pw2k67Rt1Lm0iZHI1GnfGPRiNNJpOCXrMe\n", + "1WO27kv0jfq+VlrD+2jj2/aifpXpS/+f2R6P3zymXXKbRPX4zjzXBPI1Rn4e++BnEH0mkkey7XpQ\n", + "KjnPKggAACAASURBVPWhpfZsrCmMUtc5oKEhcRKpaBOay5qJGiN8L40iUywJxWc/c1HQYCQMT8XP\n", + "GqOac8WCXQtL1mpJ6jg1fIfV0dGRDg8PO4oo+89UE5Uii1FNXGyZYjVf19fX1bbnBcqTyaSTjmIO\n", + "3M4ZF5D7njl8G9larjxfvZBwN52brK9ZZpS4iGj8zGv3hw6hf7uP5gnrPehgpFNPma3VdKytreng\n", + "4EAf+MAHdO3aNd24cUPSxXsPV1ZWOu9udH84N3aqJZXi9Dt37mixWJSXyXIcOzs75Vr38+mnn9bd\n", + "u3d1584dXblyRT/+4z9e3tHHPngsTgExnVdL6dlgch5yLtwu55BknpJvliPWaEkXRcxMN7Iuh6nf\n", + "jY2NToEz+5zk+2xQsg6FNTWcbzqXqVNYK1MzOqytoRH2uxntUNkh4vqxo82TnyeTiQ4ODnR0dKTV\n", + "1dUyh1tbW9re3u7UJJpHnGMXldORmk6nRR9NJpNLtTQOiLJ+zvWS7jeDG+uS3NDi75qmqZ5tZIPr\n", + "52RQnnNL5zSDHM6770sblAF56pxlujTrsUjWpZRVyluuET7Xc+e6M84HeVlLbXq+M4DJeaL+8tqy\n", + "48Z3rHoNso419T5fNZbz4vlz2lk6l2E/3zaTfeHOSJa6UJ9btpgO5jqs0UMrNk+vj0KQyA6/l7qC\n", + "kUzmwpAu76jI+yjEiaBIlwuBa0xN71zqFpiyfdYBpDKmgfd3VpBWuIz2M1fMgj575o4Ca7n7RPWo\n", + "6ImI1ZAlf84jDoiCnJycaGdn55Iz6cVI48nC8tzVlPxlTZt5TMRjWR6bjkTWYBHJ4Ti4Y8zPM+/8\n", + "PfnC+fNcL6ujSKc+60PoHLqW6c0339TTTz9dovLj4+Ny3IR32WWNnJVh0zQlKt3f3y+v03HBsR0J\n", + "7tZ79NFH1bYXL0l+6aWX9PTTTxcD9ZnPfEZf+MIXJElf+cpXyjvYPA4GClxn6cRarr1TKpWax5OG\n", + "iBF7KjnPh2Vxd3e340AQ3Uxk2nyaz+fa3t4u9SWJlNaM6jKqGWyPy455onXkoYO9Gio3GAwu7XAb\n", + "j8elVsSvb5G6Dt3JycmlQMTHRPi9eeaZD2H12p9Op6Wu0+QNL0bHvd6MlFsXEzmnYfX6zfF7nnks\n", + "hXVdrUaNZ4IZmSDiTP2R69AOO424eeMgg3Vgfg71fda/5nzTVvn/DDCI1qROsyNkPcJ15r76O/Oc\n", + "gYp1aC3AJD/zuXS4zs7OOvq7NhbykwFAOoveYJU7IS0L1gt08hiwMiiyLrRdqqF9zCZxzZ2cnJR1\n", + "neOrIVWkh+JI0VHg71RKNApETxLtyfY4aURcEgrNScuitGyb/2fEwbG4vVT6fv76+npnWz8XhK+x\n", + "58x0ngWHHraNgRe/PXMW2h4eHurw8PCSICxD17wAiRrVlJ2VO2Fz99MFpjasHJv7SjTHz0vHmI6b\n", + "+7Ys8mKxbkbvVHyeC8tEzWCbP+kAJVLKSIwy2rbnxd3cKJAF/OnUu082NtJ5im13d7fsrnr99ddL\n", + "KsbGxQaF27w9P8sCDKd0DPtbHr1LzTvX2vY8rShJ3/zmN7W2tqannnpK+/v7un79uj73uc9Jkn75\n", + "l3+5nEVl5yNTJaREXYgOuM/mn2WDc06+8fOcL6e4KYt2HhghU76NJI7HY+3t7XWeeXBwcGmDQlIt\n", + "+Mr5zbm3/sl5IvqQn3uMTA1LKs6QkSgfESKpUyJg9Mgyar5sbGx0Dr6U1HHGzs7OdOXKlY5jaWM3\n", + "n89LetAy7LSeC9B5BMPJyYlms1k584cpXPPMYySKb7mgw8FDfKfTabmWeiERl0zB+rk1PlvP+dkk\n", + "7pDLIIEOaepU/zBtlXLBYNnjM9Vkwp8zKKeuNzmDYKKO5C5rPsdrikS+pXPKlKf5TZTPx5BwZ7J0\n", + "UV4yn8/LC9LZLsdFB2wwOD/OxHYiAyXzn84Y+WV7QBlt2+7ZjjV6aK+ISQdF6uaFU1AZkSbMx4ms\n", + "tWuEhY4EhZnwKNusQbTsT418n710tsn0BCNDO1JUloyevZPIcCUFkc6LJ9zf+TMbhcPDw6IguTuy\n", + "Bqsm6sa/ueXfi0G6gGrtbFH4iRxZEWVNQzpG5jOdI6kL4XMea9dauedCsJLKZ0vdLd0ZaVJB+RrP\n", + "F99kL+nS4rdMZFpQuoxImccnJyel9ujatWva2dkpDkvW+vDZnDeiUtK5UZxOp7py5Uo5NdpGggbR\n", + "NVR+3iOPPKJXXnlFkvToo49qa2tLP/iDPyhJ+uQnP6lf//Vf15UrV8q5RUQ6SJl+tazZUHKebATp\n", + "jHhcNYNCR9IoyOHhYamTklRSzozMuaa820k6l3GnOf0MGlIiVL4/dZfXGuWfz/M1RksyeMkxkm+1\n", + "dJT1pA/IdUrO/DSfnN5JI0vnn7U1Dtq2trZ0enqq0WjUOX/MaUE7MpYbIlRO41OvOhiYz+cdFMj9\n", + "8o5jzgtlImWDc+Qxcfx01Kj3GOQlgs/gjz+c41ow5mfWgq90KhIQqAX7vta6hE40x0HggI4UUaPB\n", + "YNBJdVHnMOjM7x3YpszbHtVsG2XSMmXnmSk46gYequy+cwxe47lm7FyZL5TvRPjoLDGgTvR7mb0v\n", + "c/zAb79DRGHK/LLULTL1dxnFkdJrJ3NqxiUpUa6muXxCsimNbhLh0dp1hFtTgRlB4EK0YBqqtJBI\n", + "l9+czsiHaT9GyHZ6eIJzIiSpwKXuIloW5Tgf7v5RSTP1NBgMOhGj+bGyslLQFTpVVlKpYP15LmyT\n", + "c/eOotIQpdPlz83/B6EollfLhqO7RNdShvMMLbdrBMcnYNMZ83sIr169qg9+8IOlH8fHx8XZsXHj\n", + "dmH+9tj8vIODA+3t7alpGr322mu6fv26JJX3FR4eHpZzenzfZDLR008/rVu3bpWCd8/JH/pDf0j/\n", + "4B/8gwKDM9pN5JOyZnQza9PY35rjSiNB2UjndD6fazKZaH9/v6REfd6WI9laarAWsPlEdBdMs1+O\n", + "3qmMTYlc1pBOOti1ddi27aW5JD/pKNtwO+3hQEpSOaOOAQ8DI+qf4XBYeObPHnvsscLTw8PDok/8\n", + "2crKSiknsKwfHR110EGm6KizF4uFxuNxZ66ti/nj75zyJrJNnnvbvwuJOUbz12UP/s58qRnvNPQZ\n", + "2NUCh0RoMmD1/+4j59BE5I9tZPCYRLTOlGtpsVh0shj+3g4nA2/OE/tDx9C6r3aauH8c0PCQ3lyH\n", + "tJF2qDLYdXBOu2eZoZ3MdWE7yzSybQk3G5GPtTdYkPrjD3rqqaeeeuqpp57eIz201F7CqvSsCd2Z\n", + "GCHYm5S61faZ1mPqypHgsr64DT+LxXgZRRAurD3PkQCjRLaRkYuvZWozoWEjUtx95H44leI0nr+z\n", + "p15DJ/w8w+xE/Lg7LfvOMTGSky5OsDaqwkjJJzS7qDhrpIjesG0fYkqkg2NwxJoIEcl9ycithjqY\n", + "h0RNWL/A1FvC6cy953icsmKtBIua3Uby4vT0VFevXi01KbPZrPqeMm9ZJ2LjPhPql87lb2dnR2+8\n", + "8Yb29vY0Go107949Sec1Ui7Y9An95Nd4PNbNmzf11ltvaWdnp5yy/gM/8AP6sR/7MX3+85/XeDzu\n", + "FPUmypepW6ZmiEwxhZG7fKXL6VDWybi/5u90Oi0v2t7b29Pu7m4H4eb6NkpDxMdk1LUmb0ZULW+W\n", + "7zz0j+05Emb9D9tj1E2+pZxTJ/r7rKeULlAAIgxc5y7Mns1m2tvb69Tj+aDd4+Pjcp3bPTg4KDK6\n", + "v7+v9fX1zsu1XWDutczdfp73GoJOBJ96kbKSfOManc/PDzM9OjqSpLLJwvqA2QevedbPEL1x/410\n", + "mizT7Lfvs462vuUYuLa4a9FjYEkB7yM66bXBZ/vafB6/8/wbneH8N01T3syRqS+uE/aV9Vsso7H9\n", + "mc/n5a0BlEmm39Lm8busS+Q9HANLZJj29HfWI7QdHvsyf6TmWyQ9tGLzXBiZWuNvKjoyzERG5nOY\n", + "6qNSNLxdWxg0hMvqO7i4KVy+Lx0iO2W11JH7wUllLQPz2ePxuJO+Y/7d4yJ5gVqxG25PA0VF8CAj\n", + "zDGyv5LKrq2VlZVSP1WD6W1obPRy9555JV0cjZBC7fGzHfad8uScPw1rKqZ0lphL59j5N6Fo85Dp\n", + "nZp8u26KTgqdQ9eJcDv+wcGBHn30UV27dq3jTHj+bAzdrr8zP1dWVjppVs+Nzxh75JFHdPfu3fI8\n", + "pxn39vY0GAyKETo7O9OLL76oGzduaHNzUy+99JK+//u/X9J5uuynfuqn9Fu/9VulH56X7FMqb64z\n", + "Ow1+HgOTTM2mE0wZpiI/OzsrDqKkcuK3HdlMdzhtYLlg3SGPUCC5H2tra5cMPOWmlqJin5M3/HxZ\n", + "iQJl0uR0SNM0nZPNmSIxf53281EXjzzyiLa3tzUYDEoK98aNG9re3i4bZZzGM28Wi4Umk4leeeUV\n", + "3bt3TwcHB7p9+7akcyfLcp2pZwckDjRynFzDdGz43r408uS79b+duoODA21sbHScZfbFMuR58HfW\n", + "d54vrkPfY1lLvUd5oRzTTtQKuK3rrLsZ6DNgltTZaMLnZZlJreyEOsrjyzSm+UoHlm15HP4+Azq+\n", + "OSFLQmjbsy+skcrNUgxk3Kb7bnua8k7HkDxggbl/aEseVGguPUREKhnN7xKtSuOYHjaNewoIJ5vG\n", + "lJPp6Jl9SVQpc+ZepMwXu22+HysXTTorbIuLlWPm7jwWgLpGytdYEXEMZ2cXB3om+ubizVTQOTYq\n", + "MCstKg86du4Xc+P+zblh8TcNTxoTL0z3g44UUUH3mbJBhy0Vbcpg7hSqXeddSFY2vK9mABlF0SGw\n", + "A0bZ5HXk5Xg8Vtu2evXVV/Xcc89dir7m83mnxoFIrevSjFy5rz7uwKgCjy0YjUba3d0tdUV855qN\n", + "8ze/+U0988wz2t7e1te+9jVJ0vPPP6+Pf/zj+qEf+iH99m//dqeIlTUJKQvpBGQxqNcFgxBTLfhK\n", + "ZctgwQ7h22+/XXbkOYJ9UCBGA+W16LlNVCz1jL9bLBadukD3k7UZeZaWg7UMukyscyJ6QCczkWEX\n", + "mA+HQ929e7cU/EoXxuSZZ57RE088UWpZ3KZloWmaUjtjlM9y+MQTT2g2m+nOnTudnadt25ZCdD/L\n", + "Y/W484wpz0s6Sh67P89gi8GjdK6P3RejLhsbG5eCcr9qhDLJfro/KRN0qmqoI4GDtDF+tsdBnWRZ\n", + "cv0Ui8G9nrkDk4ec+twmB9ocP20Sdaafz01RdHzpQFK+ySsGDP7cbQ6Hw0u7eRlc0TFK3ri/Jjo8\n", + "DETNY/fDgImJtpU6yXx2XRg3DyzzVUgPDZGykjClIlvmMS9DrR5EVmy1CNbMpLPg5xMGZV+o6BMt\n", + "80QmFGiBIkqQSJZU3/XjiN3CSMPJXXtZrGcD6iiSkYzb8PjZn+wzHQb33f3JQl1+xqgmIyvyzYuT\n", + "xeFUgu4jHU1+RyWVY+Di5gLiSzlrEVRtkwI/q6EDVKKeM0ZMNtpWLLWNAU1zcUaMdH6UgFOljOo8\n", + "fvN8sVh0dgmapywg5X1OeRwcHGhtba1zCvXGxoYGg/PzgO7evVui5a2tLV27dk0rKyt688039eST\n", + "T5Y233jjDd28eVN/4A/8AX31q1/tKH46vJYLosScIzquRGoyIkw5sZzSWSPKxbTA8fGxbt26paa5\n", + "eDkvHWmmB1ZWLl6ybWTP17VtW9YRneNEKx1Ysdja/fS4ZrNZcfRIteCAc05jwzEyrcj3zjnNaaTq\n", + "6tWrhYcf//jHNR6PyzEHPAvq4OCg6Jr5fF62mHuuvDPw7OxMx8fHevHFF8tux/X1dR0eHhZ0wIX6\n", + "OZ/Sxa5RjtFGjevbTobT3Ua6PXY635z/yWSiO3fuFF1IXe5AjjqlllHwT6IbbIuBsK+xDqDTb0ff\n", + "88M2vbvT64UbVZxCtt40uiypnGbPF5jXUpEpWyYGB5Qby5h5b0pEiQ6h5d46jw6S+8K0JrMNBDnI\n", + "G8+Fx8xANEtGMuXJFGQ6fj4KxH/nLu8M0kgP7UDOGrIkLXeMUqjzvmXtSl0lx8nI692WjWzNgTNl\n", + "xMG2fD2dojS87CMXLe+XumceJeTq2qlEcKSLt5XTkDONwL+zBoPoWI4/HYFEVjJyTEoF5DYdrVuZ\n", + "UcAp8Ibq2S86ZRkRsS80zF68OU9ECog+8DMq6UTFEh1LRMrXEmXgCe3kq3Quizdv3iw1C1kjxZcl\n", + "S906Pzr9RIGsFLxD0kZSUjnt3G0SXZ1Op+VU883NTX3rW98qp6xbeX7iE5/Q+9//fr366qvFIOdr\n", + "PDzH/i4jdZK/YwrH91EmaJSki/Rlyj35Zscl0WErYM8ZX2lhw0wjTdnys7lm3OfRaHRp/N496zcY\n", + "8Dsew+G+UY/4+XZaGTDQkBtpki7Sd2dnZ9rc3NTe3l6nxlE6d5oWi0XHsTPPPB/7+/saDAYFtRqP\n", + "x+UF10dHR3riiSfK8QdGQO2cE1XmWqTO8Xd2Aiw/lBsHrBwvx++AJJ2lyWSiyWRyKcVEBJq6mHzk\n", + "Gqfek7oHRSYxWDIxPefvaAedVq7VgtlR4lEF5A3Tlk3TFMTZgQKdUup56jP3TVIJNvy7VotYmwu3\n", + "5QCEjmTq7CQH+Nmm9cD6+volxNU6hvqYAR11Nx1MO06WNcoNAYBl9NAcKQsNPVAqykSkzBQLAiPv\n", + "GqLk+/w7J89EtIqeMgWthoR5EXNh0KAnJE9KFIewcRp2OlE5PqJmvofnpbgOhwiS28iIlsaM11uI\n", + "OG63beVIheLDD33eVUYRTClSUP3bCtufpdPE+pKcZ7bFv6m0pctQbUa6td/mGduuBQOUIzpPlAf/\n", + "7evMRyKN/vv4+FgHBwfFmRoOhyWt4joVO6J8Xq3+w+RonA6Yi8Z5zMbJycmlV6RYeTs1dufOHUnn\n", + "hvT27du6du2afuInfkK/+qu/Wgyz59XHONDBI4Kb8yd1z+5yCofzkvLhKDxRpVxzs9lMk8nkUkTL\n", + "Z1rO6bAxXcqUjr/3WFibkc4WD8H0GrGD7Ejbc8+1R2rbtjwjr3EbrGUispDnS3l877zzTnm2ZdRy\n", + "wwJ7vrbDmxSm06meeuopvf/979d8Ptfbb7+tN954o/DTZ0ml8+F0EcfFcTDYcr/8nWU8nR4iShnc\n", + "ORg5OjrSysrFq5DMGyKSXgeSOnxhvzj37F9+R0TK97qGzc4wgxZf73f82RHx2P08llFk0E7kOWXQ\n", + "iNcyJ8a6g+d2ea68rlkfx3mlHfU15hvTcP5sOBwW20A59fqrpbXJf9sd88P9sfymjqasZEBn+8Sz\n", + "zuiYLaP++IOeeuqpp5566qmn90gPNbUndSMMIiLp9WfkQTQhIdiaB0qoT9IluJf3JPJAymsTlXC0\n", + "UEtvJTTPNphXXhaFJp98jZGIjI4JzzJ9yHvIN+4scXTNvDL543otv9eIzzXiwAiC8LSjSSJSTK0x\n", + "KneapZZeNdzKnRokIh+sb2IhZO5ASXTMCAfv804jzkHOT0aJ/t+RXqaGnd5zlOr7Njc39c477+ix\n", + "xx7T1atX1bZtOSSxlupxv1w/xlohzgdTyOT3aDQqBy1aDswDoxyurfJrHaTzlJH/fuGFF/TFL35R\n", + "L774oqSLOh1HdpwX84vpJ/LbP5nyJeTvcXOHD+WcSLH7Y+TTqZFMszLtkOuCaG7qKP4mMmk95XVj\n", + "VNF8JcrOlB5TO3yeI2ZH7Jl2MPJiVNH3ra+va3t7W4899lipvfPuurZttbe3V1JyTJUahfIrXYhK\n", + "Sedr8eWXX9bx8bHe97736amnniqI1MHBgWazWVmvbNd1kSkTHj9RfSKXTt2SP5wz6j+md4i0JNrO\n", + "sVhP1bIcqb/8eSJinHuWZng8Ror8mZEZqVua4M1C/s6viyKaSznMbEIiWJYfp8ZYZ0d7zNIQ1jx6\n", + "XFk/lWlBtuP5OD4+vrROfA/TaSyi91xThxqFMgLFNCX5n74Cn2fkyWN3loQHG5syhZj00F8Rs8wh\n", + "krpwKeE6MlzqnjFFyjRPLnw/w0zNepeawSTcnUVwNYcmFyn7kBNL45Y74Hhf3s8FQGVkQ7psgbN2\n", + "jAbZ4/D3rK+xQLnonekk1rG4XS5MQqdURHSePM8J3abD6jYJtafTx8XJwkM+I40seWuZ4Pg4Z0yN\n", + "OQ3AtCjnKCHlnE8rJhbq+5mj0ajU0qRR8P9N03ROjGbtjJ+dTkittm57e3tp6nV1dVWTyaSsCzoZ\n", + "t2/f1mg0Kum/F154QV//+tfL/NJRYB2QeUpnOp3ZDIJ4jechAyz3l0ERee96pMPDw3J2jttlHRxl\n", + "wkePsPYqg6haXyV10hdMCY7H43Latp06OlmuU7Pj5k0BqWtYsNy2F0Xwg8GgPENSOUZjfX29HCng\n", + "WjaniF1/c3x8fCmotMHPtKXH5Xd67uzslB19k8mko69pkOkIcD3Vxsg5YV2VdUeWEdAusL/Wqaen\n", + "p2VzBftjouNaW7/U+8sKnF3D6HtdC+f2WR7B4nemFdm2pPJuzIODAx0dHRVZpo1aWVkp7y5Mcn+8\n", + "Pjxmy13N0aGeo041z1JH+3fWiKZ8+z47dix3kM7XDc8gdJseo3Wfr3dtMIEajoNpugzgrUPTznq9\n", + "flcWm6eDQQSEkTOpZkxr6E86MqzHYnRDR4TPtHedhsREQ8I+0VDVIhn+zu+8aK0AuNg8Tu768vO4\n", + "m4K1AHRqKOQ0DrUIgv0h8sXtvlZaPKvG13GXBZGZs7OzcijfdDrt7M5hFGCnyn1jcWBGRUTaPH4q\n", + "HY/B8070iY5dGk06TMnTdBAzb+8fKnLfK3Vrl+gwWO7NT19vh7VtWx0dHWlvb68TmXpXGR0/z4Wf\n", + "kw6/eeMt1E1z/soYSSX6tYNBnrImZW1tTUdHR7p586Yk6cknnyxnB924cUOf/OQn9du//duSpC9/\n", + "+csF/fCOMcuT64WIDDEap9Odc0F5TVlm8JU1cVyzdgzzkFMHD+yP1731CZ1DKuZ0pIispHw1TVNe\n", + "nOx6GAZvXvd2pkzus5/l89u4LuxM+6wwSXr88cfLLrq7d+9qNBqVQzfNaxcUz2az4mS48Nl9tYzb\n", + "sTP/XMg9n89L/dTx8XHp7+HhYSeA9jg9L/zcTgiDaK5/FjBnYOI+Uh48F24z9buv9QYT2gXOXxpa\n", + "6wXLS47NP5wP85TBF/Wlx5DHMUgqcuL31uWLoP0Mn5fFPuVL1KnLXPtkZ4LOIj/zM4gccr1kbSj5\n", + "bjnzeGwPiNZ6jK4Rs8xxI4n1JFFok+ePdZJ+LgvJGdB5fEQqU5d8VzpS6Zyw01wIy76rOSTpEPgz\n", + "e7SM9LmryTA1i5GpRBmB2WkhEsAIhM9t2/aSA+J+EzqksvazCX1vbGx0JpMQp3f8WBBYGGzv30WF\n", + "XnAeR+7WoPPCBUBjRIifaTXpQjEsFouyy4xKyhGg0zw8kJNpnFq058VRi3rMl0T4fJZKfm/lRQPJ\n", + "fhLF4UGWiXqRT0w/JprpPtYCAUkdRWLHx7uhbCxt3BeLRdmBY8fU8uPI3H1z6iCDCMv9/v5+MZg2\n", + "Srdu3dKNGzd0eHioyWTSiYwXi4W2trbUNOdpo93d3YI63Lx5U5ubm7p9+7aGw6H29vb0Yz/2Y5Kk\n", + "b3zjG8VZMr/9N/vsYxgSWXCxMonri06Tiam/RF0t+0ylUUlyfdsBdL+Hw2Hnt7+zzNpJyt1J7kdG\n", + "6nTMrE9YMM+XRtP4e/w2wr5WUjGgq6urunbtmp577rmyu9LOj78fj8edFw/7hdbz+Vy7u7udAnmi\n", + "4zwSgzw9OjrS4eGhtre3O+82XCwW5Qwh8tv60WuVAWwi/5yj2WzWQWKo21PvkO/mEY02HRDziHIm\n", + "dXddJ/qSG4H4HV/Ia96lA0J7Y6JOdpE39Y7bs+5nitO8YIrPtFgsinNCGeL35gnfUWg95H7wAFHL\n", + "dg0AoBNpvUo7fXJyUnYPM303GAzK0SQuIWEq0Q5UHutj3tgpTTTK65OZEbeZoE6iqOmzkB7aOVLS\n", + "csfH1zxIiGt583TAfC8njwbaz/H9Fg5H+L7GELifQeVMg2xhYr64lvYjDOsx1PhT+34ZqkSIW1J5\n", + "sSoj/qwncF9SUVGY05HisyaTSWdHiL/zYmPEbqNjo03H1ULshcr5I6/pbLK/fmYaL85NKhOPPb8n\n", + "gkc0i3Of6VL3hf1ynzLFJ3UjXukCUmfaIaNdG1k7pH62+WVHy0bX83pyclJeK0Q5tRJOtOr27dtq\n", + "2/NambfeequDgNnAbm5uljHaWL766qvl9OvDw0NtbW3pmWeekSQ9++yzevnll3Xr1i1NJpMSAEjq\n", + "IBSWEc6/x0fEmrJW0xecF8su15SVur+jfuDRJ1wHbsuBiwMFyg+DA0mdeUqEl/1msEAnxfpla2ur\n", + "cyq426bjRQdkdXVVe3t7evbZZ/XMM8/okUceKam9w8PD8iJsG1Oi3l6bfIOC2yTysrKy0jl/y47N\n", + "YDDQZDLRlStXCppFxDxrdqgfExmyPjdvanrR37NNrtM03EY5vHbYLp1a/8/vuBYTcSYaQ5mh02O0\n", + "j4Eg7VAafn9u5IWIFPXN6upqOVyX/LN+YzDkPvl5nhepixQl32o1n/7bKUnPF/WXx2S+e90kETXy\n", + "fUZnadfyHuoN3+dn0mHluDK952t4QLSBApORs2X00GqkpMsOAyNnevX8nI6TdPmwvzR8CfsSaaEC\n", + "p+J0WzRSCeslzMwxME1QM7hExTgGIm6e4IQt3VeOgYaGxXPz+bykzHy4HpU0n01DX/uM47ZSsLAl\n", + "muZ7jaR4/P4s0zR0XIhGuc00kukUWYHxPvIuoXH/zWcl+knFSH7bOWQNivmdTjnvraX52K75aaed\n", + "9QCOnv1M3s+am5WVFV27dk3SeYrl4OBAOzs7JW3GQlMXDNtYeJ6uX7+u4+NjXblypRzWuLu7K0nl\n", + "ZGIbYjtt0nndxp07d/Tkk08WRW9k5Q/+wT+ov/gX/6Jee+21gvJRTj0PXi+eA6JQRBaTiBBQ/jLt\n", + "RmOQaUTODwu5a3LjfhNtdpDAVLvJCB4NLeeQssu0Hw2T58h8Yw2JHSmeQP+xj31MH/vYxy6dvrc/\n", + "rwAAIABJREFUNeT5c1qIemw+nxe0k4Gi+U8EINO+liOiFXakxuNxObcpEZCcz0wL0R6YJ76OPLSj\n", + "4zYzPWN++YBiox8ZtLRtW+SXNiiRQCJLNUcl0TFf75IIPs/rm/qDZQupS63zvH7tnKTusT1I/jGj\n", + "wbqspmnK6fKUCfeHmRnKomXI7xLl/LqPBhess0wM5ms1Ys7iJALIPrNNpvXSQczAlo6U59sBCkEH\n", + "64ka8FPmfOk3PfXUU0899dRTTz09kB5qsXkNdeJ3JOZhE8LnvYlYMcqtwaZug78Tgq+llfxc5pF5\n", + "n68l8sOomaiTP7PHTlTNEa6RB46PuWAiUJIK+sQj7xlB8pUCmZ92JJq8lrpQvGsi2A75lFEjkTMi\n", + "Wb6XqZsH5aN5j3+bb5zLWhoz57kmF+4no06PwXPjiJGvafFziJ4wUuV883OmmbxzhQfhuZDY6R3e\n", + "S2RnsViU2qoPfvCDun37tvb390sKz/M7Ho+1WJzXzB0dHWk0GpWDCV2k6jm9d+/epZSvC9L9XOmi\n", + "ANZydevWLT3xxBOSzuunPvrRj+rrX/+6RqORvv71r1/a4u/0Bw9tzHS4PzMP+TvXPefc8kx5oewx\n", + "neb2t7e3L6XgPVde71xPXGt+VY+f5znzHGQayykl7hiSuqiEr+F78c7OzrS1taXNzU2dnZ0V5PBD\n", + "H/qQPvGJT5Q0GwuWXV/iOiqn5KSLHVKeY84va6pMREHOzs5Kql86r4t63/veJ0n60pe+VJBIZhY4\n", + "fq+Z2roncsj5MBLhua6l6WtZisViUY5tIdJDquk+t5kpNPLBlKll2wmmkKQLdMVb+TNb4faJ1BEt\n", + "N/JLefahsUZNyVMiPqx/8nNcx2Z9lkhc01ycks7UN9FMfud2PM5MJRo9slzTlvjHa4d8Z73Zsg0/\n", + "HlOt1mnZ+1f9zLTBy2SzjHfpN99BSgeGn5m42HhN5m5r7TA1ZUbX8ut0bhIepDLnThovBvaP46FA\n", + "53NTodfG7HaoDFicS6GxgNE5ch7XgmJl6bbIKxqKWmqvVpfC/rVtW2otpIttuXR4afgswKenpzo5\n", + "ObmUQkwF5b/Tsa7l2HnysMfGugm2S6ctZTFrNlJJsn3D68mbmiPm9A7JbTntdnp6Wk7/9nyPx2Nd\n", + "uXJFW1tbRTG6wLttz0/y5u4l75R68cUX9eyzz+rGjRv6vd/7vc66WVtb03g81vb2duGF03RUoDs7\n", + "O5fqZFZXVzvOmR23vb09vfPOO3r77bf1+OOPa2trS3fv3i3ffepTn9KLL76or371q521Y7h9e3u7\n", + "GP3kJ+dgWSrIay1T1myHae1MvdLp9ny4loY8cPDkMTBtMJvNykn0kkr9mNtyP3k2mbe/MwWeqS2m\n", + "wi3nW1tbJf24urqqra0tPf/885KkH/zBH9T6+rr29/dLoOW5dyrQKRwaVAYJJpYf1D73b+vIzc3N\n", + "kh65fv26pHMZtm7i7i7LFNdJzhsLgvk9U4TWK2kvfG06Jf5tOedYUr9mfQ31BuWCuiJrNX29HQ46\n", + "GQw8Ux8nr/J0dbfB8fhvp9n4mZ/DoJ3OkqQim4PBQEdHRx1nQlJZE7zPMkTeeR0zRWqnjvPCE8S5\n", + "HmtUq/NiDRo/J/8pw94tzlRr8i+DNa/1lE3SQ0OkpMuM4UKgAGW0mYZ12QBr9VNs320lYsXiRgs3\n", + "PXMvIhtTCrgXiwududi9WOxMcXw03ByPc73Og9cKQL04lu1CqDlDHov7yMXEZyS//DcRuf39/fKd\n", + "x8KdGKamacpWaBohOjFZm5BzmMTIJZ9nZyqjFCqCZYuGTnWNd7PZrER+fB5rRei4Ek00OkgZtDGY\n", + "TqflBa+SdO3aNY3H44IicZ7sxI7H44IG8fUNX/7yl/XpT39aP/qjP6ovfOELnV1z0+m07LjiqyLW\n", + "1ta0t7enjY0N7e3taTgclgMbrbRu3rxZNjP4u+l0quvXr+vu3bu6ffu2nnrqqeLwra2taWtrS5/+\n", + "9Kf1xS9+Uffu3SvPu3btmkajkW7fvl0KvRPFowOURa+pI/Je8pjyRmQv5d9zMB6POzUtNEBZQ2LZ\n", + "nc/npX7M49/a2tJ4PO44UkSBiJwx8nX/WQNnx9UbE2ycXnjhBX3qU58q/Day0DRNeRWOx+pNA96B\n", + "6bE70KOxJZ2dnRV01I4TdYwPap1MJjo8PCx9HY1GOjo6KhtTuHvZ+rOWOSCvuZPS47dRtA6nk+Qx\n", + "eI3TcfNYjPARkTF5rhhYEY16kD0iscYs2yBSaR3vdliDSTTHcph94jwOBoOy25Q2iJS6h2M2r9fX\n", + "1zsv6SaaSN3pAMvPotzQGfT8kXfc6ETUyXNG5yrXdr4OymNIZ4rO6bIA2faoZpf8Wa0+s4xj6Tff\n", + "QaoNJCk9bE52DZ1IzzvbMtGY0nEjskO0ytcQzqfDlTvWfD/bYB8o8Bnp+p6Eov3MLJz3c3xCLXcv\n", + "WNhtfGyk8l6Po8YbOpnkVRp0Gzqfa+Q+5qIx0uIIu/bcdJgcXaVzSbITkjCuF3A+h/cRQeIz2Qb/\n", + "ZwSbznBen/d5oVrpUA7Mb74/TVLZReXv8rBG78qzcaMyXVtb09/9u39Xzz33nD71qU/pi1/8Ypmv\n", + "lZUV3b59W+PxWMPhsKT2RqORRqORZrOZfud3fkfXrl0rZwUdHBx0ItWmaYqxPDk50d27d7W9va13\n", + "3nlHq6urJdV0cnKizc1NffjDH9bVq1cLAiWdozY+qdmK00YkAwCmSskjGpZENVksSwfFha1EtDj/\n", + "TpNTnqhrnI5JBW4ZPzg4KCjfbDbTzs5OcWyI4jolOhqNSh/ZTyKrGxsbHSSvbVvt7OzoIx/5iD72\n", + "sY910Anzw8+kQW/btqQDiSS4/3zpsvlomamhPJYbO2+LxUL37t0rsmEn38XtNb3q5zC9af1Dg5pz\n", + "7rESfaFT5nElb6SLwnMGcgxyOfd0lOmYkYwQUu8zsGqaizPD3E8H3rZx/s5rwO2lLuGp5H4Wgwzb\n", + "DAYB/s1gNXV5on8ep4M195lrzbLMsRJcsENKR8z95f98Hn9nxsKfk9+cA17Hde8+ZGDtcfvHjj2P\n", + "EkpdkPRQHKkak7jYPclUhnRslqFLKfyMcNJYppOTCFfNGSJZ4BhdSZePDiBs7udYIVGAPEZuF+XY\n", + "6FARWXBkZiVDqJJ9snGkoWFemLzzXHiBU2nWFpL7yC3VNe/dnr2h/xpilouNjgkVninnkHUS3ObO\n", + "OaYD5Pmlckv54hySx4TpM7XkvjG6sUz9v+y9aW+kx3X2f3U3t17Z3MlZNKNtZMmRBVmILTtAYiBI\n", + "XuQDJB8zrwMDToAEcmAgtmF5kceWRtss3Ju9sJtLd/9f8PkVr/tM9fhBgD/4vGABBMnue6k6VXXq\n", + "Otc5dQrLDWsPIEWMhMea1Ot1bW1taXV1Vfv7+wXFwHsZgz5WUTK1Wk2/+93vdHZ2pnfffVeSUqLM\n", + "1dXVl8YizBDMWblcTiCr1+up3W6neBhYEUnJlTQ/P6/t7W11Op3EeBGPs7CwoH/4h39Qp9NJbR+N\n", + "Rur1emo2m1kWk4WORcMNBQAPMvG+oX9w0+X6lD7z+UYf46qLOY9inKLHelE/r6N0BSQ6nU4BCPE+\n", + "AMjy8nJi43zsA9ZYFPmuWq2qVqvp/fff1w9+8ANNp9euSxaC6XSq4XCYwDHfwW5SvO2MO2ff+D9+\n", + "7vPW9R19yEHYMKpnZ2eFDNTStTGK/nFDJWdw8h3sK+2OAJT7AYbO8JBihDEQXe48K8c6RWDEOGMe\n", + "RXbMZYxud0Oc+jOu6CeMFGQZZYB+djlR3PXs7JfXBUPAgQfXe/yQvxdDjvr4uInrsRtDMW7W6009\n", + "YdBcLzuL6sCH+YlxSR38N22JBhc6mXr5muAy8v89UfSscqOuvag0XTFKxbgFSYUJnANSPMPBGdfl\n", + "6E2vx6xn8L8LnBIBhSNtH8S83wMmo5JCCcXB5lR0nJyOrKMFyXuweBcXF1+iXKH4I5PjFGickF5Y\n", + "OBzMEFCa2y46a8HjXn+/09juZo2Fz5FZbmI4iKUAXN1K4X1en8iMIo+4zRfZO6vo48i307pyoS88\n", + "v4orzuXlZa2urqb7/LeDKK8730lX42Zzc1NPnz5N8njnnXf01VdfaTKZFI6EkZTOZeO+Xq+XtrEv\n", + "LCxob28vndN2cnKSWJeLi4sUH0OyzuPj49QGAPmPfvQjPXv2TJ988omkq7xGc3NzheBn6l6tVpMy\n", + "d/aQ9jmgjf3vGZxJ6kc5OztLDBBHongBgPtGDy/UJbKdng/M5xtjkbbGvgRM8JmDDbKL48KD5bl7\n", + "967eeustPXjwIMkN5pD0BuVyOeWDclckCxcyc2MA3RoNDNfBzElnQ3q9XtpoAOD0MQWIgEnxfowG\n", + "pRf62RdtZEwfO+Ph/7Ogx74g4N6ZOJ7JQhvfFxlIXzPcwGf+AyRoswPPCAiYby4X3GWeEoAxzHPo\n", + "Azemab/Ln+d5/6M3YzC6G3s5r4EHj0e9yLU+X3I6MgekfKy5TNGF/r64TkZQ5yW2gXnNOx1El0ql\n", + "ZIS4N8VJlVnlNv3Bbbktt+W23Jbbcltuy/+y3Cgj5QVK190Tbr3lEKtU3CKdYxMokcVy68AZBO6L\n", + "/uNc8HGMAXImJiJjrBwsFd9pAOLGao8umsjQuMycAYmWG9aA+9mxPthBA9qOFoYzVU7x5vzVbrU6\n", + "MxNpXSyw/5uSe0/s38gI5O5Hlu4yiNf4Lhsv0QLxMRRZTHfHYPXEuByvp9cFFxrf+3ur1Wpyy47H\n", + "43QauvTyIaMxNgHZnJ+fq9FoaH9/Pz13a2tLz549S3LxhIV3795N57GVStfn8O3s7Gg8Huv58+dq\n", + "NpsqlUqJkapWqzo5OUnM0ubmZnLt9Xo9bW9vp3H093//93r+/Lkk6csvv9Tq6mo6u8/7olKppFQC\n", + "jN/IVk8mk8RAeP8wT0lWiXUvqRBgDBvkO7fG43HBwo9sLX3oO8WcxXEWkn7h/1xMEC5x5En8GKwA\n", + "MtnZ2dH3vvc9SVeM1MbGRtrsERlgdGJMKsrRNq4/fRyii2i3x5j5XCqVihtfPEi5Xq8XmJRarZaO\n", + "E8Jl4y4678/ofnW2LvaDMyuuc91FiFxpJ24+5orrBeass518B2PM974OePwP7iZPmOrF2wGrRhud\n", + "OYPdh6113Z1zqcH08T0/rAk+7qhvZGLpGx8Tcb65ro/rqbvKXc/TV8xR6hnjqHLxxu7x8bAZ+hBW\n", + "ytvn3h2fE+jmuLZTR4qvWcjA51Ku3DiQiguNC44SP/MF1EFWdN/4OzxAmBIX5lgnv4YSXUG54oPI\n", + "FRGUN/V3xY7fnmf7QuHuzBiTxQTmJ4LB6I7ybdbIEqrT+yK6M2McgU8kjxVwGUZXm/eVKyvq4e/P\n", + "9U2MD/J2eFvj85Bf9NXzd3Tf+ef+XQS4noMHJcKmBffNS8UjNrg/F8jsLimvOwHZUnFzADFAUP2u\n", + "3NklxcK1srIiSWlH2srKivr9vlqtVsG9MR6Ptbu7q/F4rNXV1eRanJub09bWlr799tvCdn7qOTc3\n", + "p16vl1IfkGVdUgpsr1arWl9f15tvvilJ+sUvfqGHDx/qyy+/TItwjPNzsIfy5WDcCJ5wb5HegfiZ\n", + "ubnrHEgeNO1uLx83nqLAXYj+PhYGisdfeN+SQ8jBsy8mlUpF/X5fk8kkHRZNYbdbs9nUBx98kI7d\n", + "wX2DHHxMMxZzAcnj8TgdJxJjupAxYy5uhnFjNbo26/V6ci+Wy1e7xtjNe3BwkPKD8R1GgMe4sGU/\n", + "hnT4WIj6hL/jtQATXLu0JR6L5Pe5DJEb8xG9xSLuMqVdDsbdMGGuu37mmWSId93FuJCUYhHdwOK9\n", + "gIlofDlgiK47ZOOGneeEc/eyGwVc60ZLNK75PoISrvcNNv69g3BfU5CZAygv/r/r8wj6vf5eZ5+n\n", + "/O1B575+uIGRKzd2REwEL+5fzgXu+gSL7JE/NyJQrpkFfCL4kGbnM/K6xvZwH4Mp904GDR3jPnoU\n", + "TByccau8A4ToF/a2OEBwAMC9npDTmQyuiTvLPGaLQZiLZYsTxRfaaMHFgenxBy7jyCZF68Pb5e1n\n", + "cswaK7PGUQ6MesmNJZ7nIMrPIvPnUDePY5pOp2nnGjFtkhKjguyl4hlu0Tp1ObAIAHq4ttFo6PT0\n", + "VA8fPtR4PFa/3y/s7un3+8maHw6HiXWCFZmfn9fz58+1sbFRCGKGdTg5OVG73U7vr9fr6na7SbFX\n", + "KhW9/vrrkqS/+7u/U6VS0ZdffqlWq5UWFuRE3jFig6gLKSLK5XKy3GM/1mo1bWxspBQNyJRga2Jl\n", + "SqVSAmAe3O2ypj459sPHADrAYyqiFc/BwNL1OZ6DwaAwXviu2+3qnXfe0d/8zd/o3XffLYyZ+A5n\n", + "nRhHcWFj7AFmfHEhsSNxJxE0utHGO/0gWTf+FhYWUh6x4+PjpPt8Wz6FdtOmWQZu/Mxj5+L85V2c\n", + "M+l6yA0AB7jR+HRD0BdzB1XIzUGox+xEo5Rn8B0gwjc0eJlMigeR8xtA44HuDoKk4maXyITybJfp\n", + "3Nx1agoHP15vX99c3m44O0BBVm5I+3v5389qpNBvThRQDwAW4zc3ZsAD/pn3aW58zTLm2XE6q9x4\n", + "Qs6ceyUCohwL4YtdziLxvx0g5RZBlEROUHHB9et5Zlx4vV1u4cRdGxQGBZOK66TrbMN+iGJu4nN/\n", + "DqCWSqWXrFY/Zy1aZi7zuIgzIWYpPL6jTUxEFnNn9OI7ojWE3Px3LA5KvC+c2s6BSd8pFJksCs/k\n", + "M6w8V6QR7KOA+S4mWgRk5erqk5iFfTKZqNVqpfxbw+EwXVev19OCSf9HOno6nSYQg6uNpIyHh4dp\n", + "Ud/d3X1JpixuruQrlYoePXqkn//859rb29P29nYaA6PRKD3Xd5hJ0vr6ui4vLxNoe+eddyRdWdy/\n", + "/OUvtbm5mWTk4HMwGKher6dF/uDgQJKS27HZbOrw8FD9fl+j0aiQZ6nb7erOnTtaWlrS7u5uem6t\n", + "VlOj0UjB8O7O6PV6BVDqIJ6+BWhEpoffkX1gXNBPjUYjyQYwIykxRfx/eXmphw8f6h//8R/1ne98\n", + "R81ms5B5fDAY6PLyMuUzi6DKx6iDLPqGccf72MXldfe+976JOwwBLuRCajabevHiRRrDKysr6T2e\n", + "eNUX0eiqpt7Mm5wB7nWNYGVhYSHNEWek4n0Un4/MfTfg0M38eAoLngcD7CcTVCqVQrJixgrXoQsd\n", + "cHHd5eXLyZgByugR9Jm3x92akfn2dcTDQZyVcX3F2HBQ48+h/hg9zlTGtd6BIbJy8BVZNzcEvH9y\n", + "bkBvk5MhnjLGQ1acKPD54kDV5RZDQ7zcKCPloCIHnFxATPwo1FeBKJ4bBc3n/LiVEe99FXrl82hx\n", + "0inxHhRqXLRzlLJTwyhtrPHImDEAvLNd+fCOaJlGoOGyoQ0RwLgrINdObwvWi8uTxccBSqyffx5B\n", + "l7ebvs/1H7KIoNyLy8bBsFvpPqEcpPg7KN6mONldfs5cSMUcOLjqyAoNK4QbYDKZpOzl1NsXSp5D\n", + "7iYYLZcfTMf5+bna7bY2NzcLB5ASi0U6At9F9utf/1rNZlMff/yx/u3f/i0pxfX19SSDxcVFdTod\n", + "bW1tSVJy8+Eqcbnt7Oyo3++r2WwmV1y0okkCeXJyosFgIElaWVnRYDDQ9vZ2WoTPz8+TG/L8/Fyj\n", + "0Uinp6e6c+dOYRdTq9XSxsZGmleDwaAAhKiDsz/Ilv7zRcP7dhbgZ0HF1ei7utziXV5eTvVcXV3V\n", + "v/zLv+jDDz9MC5AnJ/X4Ltg1xhA6gQXQD8rlWCcHiPyOQCrqYFy/MfbGGQyP95SuAD8u236/r+Fw\n", + "mL5zN5P3Pe+LYMbnDEZQjEcslUopWanfEwvpE6KOJHcb4FG6BiYOopApfed6z2NaeQbAKc5VBy3O\n", + "PvmC70apg3hYJ5e3M/7EYfn8zoW5eH1cN/m1TlqUSqXCWGQcuyuU9zmz5V4Lxr3rLx8XDvId1NFm\n", + "d20i47iL2cGSr/kAVAxW6uceIF8PMVhmlRuLkcoxPd5RPnmiVeXFJ/2rlJgPEn675enfRRDiEzEC\n", + "M+9gt/KYBD4wQPQM5rjQ+mT0giIslUoFZer5g+JAdMDiSsHb6NS/g5VoBfrgd8siV89o6Uag4axc\n", + "lBtK0+XmblIHcF6c5ckpTW+HPzOCea7le4CmTyiPr/B7HdjHxcd/A5oi8HMrtVQqpZQDq6urhbgp\n", + "4mWk6w0DLGrRIkdJLC8vq16vF5L8Sdfb6z1+6ujoSKurq1paWlK329XR0VECbtVqVdvb2/r5z3+u\n", + "73//+3rnnXf06aefSrpSRLjmkLG7KZ4/f6719fUU7IwcG42G3njjDR0dHaW6IO/hcKg7d+6oUrlK\n", + "Hor7ULpanEejkba2trS0tKTj42PNzc0lQNftdjUajXRycqK1tTXdu3cvxeyQH6rZbCZXoh/Jg6w9\n", + "BQLyctYslzrALVrfch7Hrh+FA/hksUaGP/nJT/TRRx+lxdQTrp6dnaUxQlySxzH6ppZqtZr6Yjgc\n", + "prEdXUK0m/EYxxQ6hb6NBgDhAnNzcxoMBml8k1eMcx2dhUOfOgMa57dnAOc+mC83TNzQQYa+4Ho7\n", + "AKbOnvhvdLT3E0HkDqi8Da7XeBbzk/a5nnWd5TqM+2BromuL692QdN0OG0ecjzPV1NHXyhhIHvWh\n", + "/x1BepRbpVIpJK8sl8vJm+Jy4b0+h9z4ZL30+CnXkV63uB7nSATGEYYM49XHYfQUOIj+S+U2/cFt\n", + "uS235bbclttyW27L/7LcWIyUU4QULBO37vk8d38skZbmGe7Ci35P7vPfkbmJriU+i/WI9ZaKO344\n", + "YwtrA2Tt8UcxUN0pdtiKGMjHdTnXpLcHi1e6tkz9x60PD6qNLI/3ndcBVO80u9cBSz7uwnDLF3eF\n", + "WxO+ldrlS8wK78n1UbR8uQ8Llrp7H2AZUdec5YNbIBa3GiNzF92XOVerM5q8BwaAA43dJePxJe5q\n", + "WVhYUKPRSBS5W4kkhsS91e/3C1mou91ucsdtbGwkGRMDNT8/r88++0zvv/9+YSegJJ2cnGhpaSkl\n", + "+pSuY96m06lOTk5SrJZ0xUh98MEH+vLLL7W3t5d2WUlXc+bNN9/UdDp96Vy49fV1DQYD9ft9ra+v\n", + "68GDByqVSsmd+OLFi7Rt/Pz8XPfu3UuyYdciMT0cU+N9wbmHPv7ZIYcrh9QM0jVDAuvqTAZ9BOPm\n", + "Jwz4Nm7k/d3vfleS9PHHH6cYIuYOLGNkij0mDVYAZpN7pesEpeiZuDvJYxhhc/iO96HHfHzzu16v\n", + "J9chcwHrH6aoVCoVErnCftEfHrTONZS4yyo3ByNrHOeZs81+P890pi6GX9B217fuqor6hHFBH56e\n", + "nhb0tG8cQeYUr0fc1ODB2Yw7Z85h24jNoh3oNR+r8Z2483Fx0n760IPcaT/rAN9TX1hU34zg7Yiu\n", + "Z5eNB/C7bqMdET/4/XF+0L9SkSGO7FMMu+FZHg+ZKzd61p6XSM9KL+9K43tfFB3Q5J7B/fzEhU56\n", + "eUeDu/yoK/e50uF3nIw5UAM1jyKJgMip2/g+BjfvdpcJ7iYW/5xbKbo1+SzStj6YiLtwCtn7gN9x\n", + "oPr7HTS5C8Tlx/uoP0DKARLvdjeWv496xnFBO6K7gD5jcriLlXoRMO4FGSHn6EpEMXCNj7EccMr1\n", + "U7lcTjEl0jX9Px6PX4qxQJ7T6TQtjr6dnLPEeBY7xarVqkajkV68eJEWBZ5JTNb8/Lz6/b7G43GK\n", + "O+p2u+p2uylA/eLiIgWNf/LJJ5pMJmm3Xr/fT66nWq2WXA3n5+cp8zb1X1pa0vb2dprb1LdUKmlj\n", + "YyMFkQNeJOn+/ft69uxZajPKn/azK/H09DTFTtG39Xpdr7/+ejoTr1arpfE2GAw0HA7T0SoeG/H8\n", + "+fPC4uKbO+IGg3q9np7pQCIu0Mi2Xq/r0aNH+vGPf6y7d++m9hOcT7wa7/PjOkir4gv7ZDJJ7fL3\n", + "+bhkAXMXlYcC+DP5HEMMUO+yqFarKf6JnWy0g1xo0S0TF6cY3uC6OQKfaFC6geHueR/fDhSje348\n", + "HqfjQHDxutzQNa5XqDNz1PWj1991lwc/O+hxfTGZTArxOw4wmevVarUQfkA/siuVthGHJF27ganj\n", + "xcVFwXCJa6XrWtqIcRL7zOMHXUdFgzKSBOPxWLVarQBWfEzmwmDQ24BPH4fI0o938uKbmbyO1Cm2\n", + "3denWeXGGCkmYQQccSB6ieDJ75GuFxX3z3pQ3iwAx/OibzjH1jh7kmO0fOI6s3B5eanRaFQ4ssGt\n", + "1tjGHGKOSsGBI8jdFV+Mf/IB7YsuStrl6Qye3+fvjBaft3cWqOJ7X4Sk66DTGACbezeFfong2tvA\n", + "fXFLsjM3sX+jn9yfQz/E9rm8aa9PRrfk+DzGFszPz2tpaUmtVkubm5vpPq5xS5H6oJgnk0kh+Z/H\n", + "7GAhelzS3bt3NRqNdHx8rPPz87RrjzHx4sULtVotLS8vp/tarZb6/b5OT081Ho/1hz/8QR9++KGk\n", + "q2Nndnd3NTc3p7W1tQT8GF+M9Wq1WrAIy+VyauvZ2Znm5uYKixiLPYwN+adWVlZ0cHCQ7iVuBfBW\n", + "rVbTjr+VlZUCS3R+fp7ivV68eJEC05Hz6uqq+v2+ut1uYvYYC91uV9VqVXt7e6pWqylZ6eLiYprb\n", + "EZwTy+a79ohzm5ub04MHD7Szs6Mf/OAHevToUQqo51w8jl/xnWIsypPJJC3MjLVqtVrIxzULSMXv\n", + "nGHGGPBnELPiDFHOIAIY+DuRR6lUSjuRee4sHUyhjtHIjgHY/h1g0AGTlzjnkWluF5df4+tBbLs/\n", + "O8rX2S4/z9CDs31xh7lyvcm4gGmGIcbopQBmAb7O6GMUjEajpBMcFCFT+j8GYUd96H3IZ1EvRk9K\n", + "lKXPGV9TfY3wcQoAjOBTejlJNv3KdzC8MUYK4Orrohv/eJFmlRtjpKTZOR+YtDF4PLIOs57rHZUD\n", + "TxQGOJ0dF0x/Z5x0fOef5awsB10XFxeJ9naWZJYC8Xq6fLx9HsD+lwAfVib1woLIMVbNoBA5AAAg\n", + "AElEQVT8H9vktDsT2GXijFGuDX69W6xMiOj287r4s/iMCcrf3mYHz66IYwB5rAvyjPKj0AbfKeUB\n", + "7MjWAZvLE6XqYLnVahUAA0yFM0ywTNEyAizB9khXSmA4HGo8HqvdbhdcLQSRz83NpUOIed/i4mLa\n", + "7dbv9zWdThOQIMAZmQ6Hw7TFfXNzU0dHR9rZ2dHR0VHKui1dAYK1tbUEdnI0/fz8vFqtliaT62SY\n", + "WJXSdWZpXHflclk7OztaWVnR6elpAl8csHz//n19++23qW6VSkVfffVV4Z1ra2taWlrSN998kxa3\n", + "ra2txKhUq1UtLCwk0LO8vKxf/vKXkqR79+5JUsrQ3mq11Gw209i5vLxM7tLLy0vt7+8nQLG+vp6S\n", + "lU6nU/3kJz/R66+/rmazWdgphsvW5wxjhnmPLqG+PJOxG4PC3XXF/7NYZZ//LKIwcoxFZ3oAL+TG\n", + "ikYbCzPsVHwH/eosDgA3GtgReHAv13JNTq/6LjhnzaOR6Bt7pGICTC/OwvgpEhQHZ36KAQYF48X7\n", + "wTdA+C496QpkLS8vF9IveFvH43Fy9cZksLQRttrXIeonvRw+47o+rhes1bMYIOofx5p7UtCbMYCf\n", + "9zkYRn5sbvA6OVhjjEQwyI5b3K6UXKZ36unzMldubNdeXPidpZKKYMQXRQdb0stb1x2URNbLQUjs\n", + "1AjauJ7nxEnqVkmcWKDi2AYUERYqFrKja97hbJUj9bgIUeLgjjKKCsD/zsU7uEuJ334v1gz38hxn\n", + "BN1aYNLE/vH2OdPjQIqYEj7PTdY48X0x8rHDd0xaxohbH0xaLHIHp66U/D2AC2el/J3l8tVOGg6K\n", + "dgW+urqq5eXlQpZjwATgCCDuCTqh5d3a9fpcXl7q+PhYnU5HS0tLCYQ0Go0U34OVS+l2u9re3tb7\n", + "77+vb775Rufn52nXnscEEbtFXqf79++rUqlob29P9+7d02g0SjvsOJqmXq/r9PQ0ue4YAyh7EoXS\n", + "dsYeliPAhvsAeLguyJvDvYypxcXFgrsUpocUCp7QczKZaHd3V0tLS7p//74uLy8T67S9va2NjQ0N\n", + "h0O9+eabOj4+Tu9bW1tLB+SWSqWUdkG6isk6Pj5OuwRXVlb02muvJRlsb29rc3OzwC7RhsFgkHSF\n", + "L7YsyL64O7uB2+fi4qJw9AhWuRth0fD0xcf1jt+HHH18X1xcaDgcpiNicE3htmEeA7ioD7o4GqSS\n", + "klvT6+7y8RL1irMqnlID4BKNwxzbDpBzYywaSFLxwGOvvzMgl5eXic3lOweiEdDCYJPdPMrHTyRw\n", + "IxnjEqAUZZvbeUeh/nH9Qk86MRHXC5ez61M3VuNa5nL1tcP1aAwHYQ1x74X3oRvXDu54Pu/LxYf5\n", + "nIhEx/9zrj13OVFyHRcBkX9HcRdaDoz5gI/0awRITuNG4BCZnhyTkwMKEYxNJlfHfYDSuQ/wFBdE\n", + "961HEOXMSZSf5yOJbZGKE9cDq/06romWqU9qR/HuPnpVX0Uw7FZyToH7/dTX+8V9+7n3RoDj488X\n", + "Xq6dZZnEz/xzmAGnlv0aFJQrGGc61tfXC3JlUaxWq6luvMOpZw/69PPhptOrRHQeIAojs7y8rFar\n", + "pZWVldRnyOvk5EQnJyfa2dlJ7IMv7hz1Ua/X1e/3U3+Nx2P94Ac/0L/+67+q2WzqwYMHCfSsrq5q\n", + "b29Px8fHybJ1sD2dXsd4EeTtckeBN5vNxLqwmI1Go8RkEawsXbk3Wq1WcoksLy+ne2GfUY5vv/12\n", + "Ss5J8tJyuaytrS0dHBykDN3Ly8vprLvFxUX1er3kaiQf1tramkajkY6OjhLQ29ra0tbWltrtdqrr\n", + "o0ePJEkPHjzQysqKut2uGo1GgVX09Ca+oPN+xtTi4mJyTfAd90XWARkAzOOCEQ2VaOGjc3KuL8IX\n", + "YEvctUsdMb58caQ/Yhwlz3QdGHUG88H1jjNu/hljiXrnGHnGGqyF3w/wyQVG+4YAN74uLy9Tugfm\n", + "Y9Rx1CGCGt6HG8p1lQNpAICve9zLc/075rvHFzLe3F0GIOE719tuXPv4ikHZORIjpx9zfebXOHBy\n", + "uUWm0kEqfZHzGNFu17cOsNyVR91yBEaq58xvbsttuS235bbclttyW27LK8uNxUhF/3V0jznDEl10\n", + "UtFajbTjrOc6LRn9sfGeWeyY18198Xweg92iq2E6naadE46icduw84jv/IBRp0K9bjwr1ps2I6/I\n", + "BHhf+H0xwNktDiwWrEqnPB25R9nwt/c9snE62etMiS49ZxGhi5G7x3A5W+fWR2SkIruUk633Z2TG\n", + "vJ+x1tzS9oKrpd1uJ9cXiSyx4huNRiFOqFarJRePW8rIE8uScUUbCU4mlob6Xl5eptQBxBhw38rK\n", + "SmLKWq2WPvvss0LsDZZ3v9/XyspKkvdPf/pT/dM//ZP++Z//WZ988ona7XY6YFdSCmzHNcb7iO9g\n", + "DnBen3R1XAsJHM/Pz7WyslJweeO+4jnuNmg2m5qbm9P+/r5qtdpLAc9YpbgUiTdpNBrJyr93715h\n", + "R9/Z2ZmWl5e1tbWlo6MjbW5upjMDcSG+9tprOj09LewgbLfbeu+993R2dpZioWCk7t27p+FwmHZI\n", + "uruHDSndbldzc3Oq1+uFecVZcoxjZ5uIRXJmgvsY/9HCdgYkMuO569wVw5iDKfPn08eUONf4bmFh\n", + "IW1G4H9cY7C1pE2AjYJB8PQPzmTFbfcwsLCfOV1D+3zuexJR3zSCvEulYqZvCmwS7cgFviPLqGvc\n", + "JZZLH0Aak0ajUWBMiN10t7jrLMIxmPvOxqPfyIbuSTd9fXWGyF18zjrSBt9gE9dw5izPi54I17fO\n", + "SLkrPvahrzPU3dtAXVzvwdwiIw/hYI3IzQXKjR0Rk/vbK5obUP5/BFIMpAgK3BXnricfNO4ik4rb\n", + "anOgyoGAd7RPiAi2eC5t5JwsPmeL68LCQmG7KvVmsWTw0TYHQj7RUCbuWnLKmffy/Nh+H3A53zCK\n", + "zb9HmTmt7TS2pylwBezuAeTj9H6ki2MbKQ4yaVsOIHk/RJDubq44IePCk3M7UmIwu4OrWq2mVquV\n", + "gpHZhcOus3K5nOJryMe0sLCgfr+ftrxLV6Cn1+sVYlc86z11pA4eSLq0tJRSIJRKpbTl/vDwUIPB\n", + "QIuLi3rvvfc0NzenP/7xj0k2CwsLuri40Onpqcrlsh4+fCjpKg7mD3/4g/7mb/5GP/nJT/T48eMU\n", + "iP3aa6+l3Yaj0SgFuEtX8yDGUQDkOGPy9PRUlUol7aLjuk6nk44CKZVKKdUB3/d6vXS8Tr1eL+RQ\n", + "YwGpVqs6Pz9PQeqNRiMBrJ2dnUIG8efPn6tWq6lWq+n58+d69OhR2jWI+5D3EA8nXc2DRqOh0Wik\n", + "u3fvamVlJbn9mCPlcjmlnWA+cYTF4uJiih9jnNVqtcLxQb4zi52o6BPGvI9Zro9g4lUGqeuZ3Lwh\n", + "TxY5z3zxRp/4pgzGov/tcW5kRwcQcai3z6+cEeSAEBkzvqiLH/HjOsRjV12nOnhE7/rOQ3SX52vj\n", + "uxhG4bqd75Fl1BezAOjFxYX6/X7Sv37kD/d7oHkuhMFBDmNiNBoVdJdv9oi7OP1ZzGFPpUCdfYOJ\n", + "63gHUBFoIWMfM5FA8L99DXH554Ab19br9eRGjwefu8wwSnNrCeX/mYScCNXZHf5GqB4r5H59BxPO\n", + "OknFAemLCgLnebNYp1f9HYFWfMcsZotO8h0pgCmpuGDTJiwMX+gdxMV3uYLMLfgRXcdB7GxNjMuK\n", + "fmvfWeZH2Tiqd7AZg0QdtHmbeaYra1f63j4UucsGQIgF7s/hubTD5ZHbeOAy8wB2Z8d4N0yUB8fy\n", + "PWfKOetUq9XS0RONRqMQBI51CAiTrpNfkqSSg3Ynk+sUCFjs0jVbQyEoGiC0u7ubxuLi4qL29/dT\n", + "rNJHH32UgsVZtDmmhmM/JKVUAp9//rnW1tZ0//79FFv05MmTdN7dYDDQ6uqqjo6OJF2N05WVlcSa\n", + "Ef8hXTE5n3/+uQaDQQKdFA5Hnk6n6azAk5OT1P5Op6Pj4+PEhngSTPoNgIRlLynlOgJYwWwxLhqN\n", + "hg4PD7W9va2dnZ00Z2GGlpaWNBgMtLm5mdiTubk5nZycpP53UEdaA7ajOxvtfUVsmlvq5Lwi31Uu\n", + "nQqpHpyN9E0Uvgghe58zbs3zG7DjDKBvkmDXo4N6AG88mBggyzPcMONZ8/Pzhdg3qWhEOosmFRNZ\n", + "+rzkHc6y+K48wEBkQKQiG+vrUSzOZiFv6ueAC7nwHgenPMe9G9EoBJwBPn3XJmsLG1Pi7jT0FzFb\n", + "sY9dH8aYo9zmHTeCWB9z8UxRz+aCyGNx/ZoDUoxVnxcY6nzmYx/miX6MORl9/Yj1jMaylxtz7TlT\n", + "JBWDvyPI4joXWGQiCLp11CxdT87IELGwuuUewZlbynFi+KCIgYyzAJjXyf+HNqYNkTaN9CzFd6BE\n", + "MOagxJknfwaLM5MtHnoqXU92X4jdredACgBBPiR2nEhK1mR0fXqJioa6OECNQLVcvj5XSlKBXmdh\n", + "Rt5x4lJmWToAtwjMseLiThsfa5EBcPaOzN8s1ix0c3NXKQvW1taSUjw4OEgMTaPR0PLycnp2v99X\n", + "o9FI9YhAEvkhV2dkyNLdbrd19+7dAogmPcKf//xnTafT5KL77LPPUsLNarWqdrudFsZms6nJZKK9\n", + "vT1VKhX1+33dv39fkvTs2TMdHR0l4HJ6epr6C9bJ3XQRDBOAvbi4mNoOqzQcDvX06VNVKpXkAkQ2\n", + "JDCdTqfq9XqFjOrj8VitVksnJyeJ8eKdnjuq2WymNt67dy/lxHrvvfd0enqaZMpuzGaz+RJwnZub\n", + "U6vVSuBxc3OzkJhyNBoll1g0gAighxFAhufn50kG1NkX/hgADMhiDrprzMcKAAmd4Kw548i38FN4\n", + "N8bAZDJJQNqZ8Og2kZSyhQPeXId5UL2zEvSZy8t1pq8hzjr5WpErDgR8HtNXtMcXYWfYo25Bpr5G\n", + "uPHL+yJL78Wv5x3cBzMVE6tSf/SXyzSCUd6L69HXSGf+fL32NSzu1va1MQeE+M4/yxEkcYOQ6+ac\n", + "68770L1TzrgRtM96621Adk4WuNxfVW4s/QHF0agzSpHpcUSbE1xE81JxJ0BkZ3IAx5/ntGPOzeiD\n", + "JT4jx6b4NZHNYEIwyH3iUWcW2lynspDG7cFeF6eQkQ2f+zX+nQMtL+QD8ngDr+dkMnnpoFBJiTbG\n", + "VRn7IMrE2+9/u3wdODu1jPLMKThXsLHvXFnH+3zbMHKPIMzl76wQ7WNR80URGQOeut1uAk8wRMvL\n", + "y2mM40765ptvUl4y3gtbBYhl+ziLvKTEiJ2fnycGCcZnc3MzuajW1tb0+eefp636b731lp49e6at\n", + "ra20Q5B8SJPJRBsbG3r8+HGK9Xr27Jmkq4Xy4OBArVZL8/PzOjg4SIrLY17q9bp6vV5ix87Pz3V6\n", + "epp237EDSroCUiS4PTw8TOObsUiM0tHRUdr5GN81HA7V6XTU6/UKOygBbMgQUAXwYoel97/3Wb1e\n", + "T4CUvsAVurGxUdiqDkNydnaW+tF1FSASl68fZYPBkmNH3Z0ymUzSfaQiQDd6pnbmOzl2HJj7tnYM\n", + "iWjwsQgvLy+n7Pb+nRtlnljUM7TD0lIf+hvWhkIfue53FsWNUi/oCGf/XScCGHKuNZ6NDnI2y0GR\n", + "60w3DqM+LJfL2Tgtl7e7Fr14HCtydkDM0TC4mf3gc57nTA2/Ac/uPeG+VzEygHlnwakfMqHe0bWZ\n", + "Y3xcp8d+BETlXJbUBZzgOjmGdPg7Z3leeF4uts3Ljbn24t+RzYm+TkpcfHM0Y6QcX1UPBzpxAQWd\n", + "guy9XpEx8+flkLkruxy4inFSvuUcpQ1Qoi7u7nNWSnoZlLhcpGvXn3/ukwwQgO/dQZaff+TUqLMu\n", + "TDwGJwoSK9KtgVmgxutOXSN4AUx5P9AGB1q+yLpcZk0s5DwroNzfkyuAXq+bM1goOOk6psVlR+4i\n", + "4p5wRbEpQZLu3r2rg4ODQiyMA0lYDNxOjKm9vT3t7u4m96Iv7E+fPlW5XFaj0VCr1dIHH3yQsp5/\n", + "/PHHKfblzp07hfQHJOF87bXXdHh4qHv37iUgQXwQGdidybm8vNTJyYmq1aqWlpYSuHHZkgRUuorh\n", + "Qn5cQxZzADzy73Q6Gg6HWl9fV6lUSvVZWVlJQMzjtnjXYDBITFG3203f+fEh0+lVHqu9vT1JV3Nx\n", + "ZWUlMWCueAkmb7fb6XzDmBsJ4O/noqEPms2mxuOxTk5OCpnbfUz6/AEcxAB7iusvNjDwOXLGxReN\n", + "K+obj3rhXvQfAJV7ACjMgQj6kIEv+gSv49Z0dtjdePGZ7tpDNhQHY9Et5HPevRg8IxrlOUOQee9t\n", + "8Lr7WkJxNscZGgBN/C664hiXXj9csLzb+xFdCIDN9bkDKorXjTWH+kc3mt9HuyOQ9M8iGHbihLbG\n", + "a/06lyUGNG1xeSF/Z55oUw60eVti/b3cpj+4LbflttyW23Jbbstt+V+WGz9rzz9zZB9jU/w+t/Yc\n", + "4ef8svHZXtyi8Ngbtx6im83r7e5Ify/X5dgTvoufY8mxiyfGOlF8G67/dutAKh6D4vEN8b1uKbql\n", + "hKWCLHiW76BwFoXvoEj53PvJ73Nrz/s6bvF1tixagN6WuLPQ5RDZJi/eTq53H7l/h5xol1tDtAmX\n", + "AnL17+MOKq+DBwq7TGEkCLx1BqFer6e4qtFolCh+6YqZGg6HGgwGKb6IY2Cm02nabt/v93VycpLi\n", + "mVZXV9XtdvXs2bO0sxD249tvv9VHH32k//qv/0pB8wSbj0YjnZycaH5+XicnJ9rc3EwxYGQzx2UU\n", + "4zDm5uZSwPd4PE7PdHfQ0tJS2qVE+/r9fspaXi6XE5MkXbFuJIdkZ6AHeBM4zvNhndi0UCqVdHJy\n", + "osFg8NKhrsyBXq+XXGacL+jZ351V3traKiQp5b1cs7S0lA4C9nHA4cfD4VDVajX1BSVa5BRYKbK4\n", + "x7ntbimKu9LcVcf/uMR87rpudAaj1+uljPgwStQnZm93necsLjqLjSvO9uMuGo1GqS0xLMDnr8sV\n", + "l6WzM7Sf+9zF58+mzh7n5euSewK4lrZEj4W77Vxf8Zn/758xT3x9I1Yq9gn9iEzZnYb7PDJyfiyO\n", + "93OMp/O64bnw58VwGG+Hx4u5nH0NdhnPWr/xqsDoI1PWaHS/uw4jE+XF5ZbDHq8qN3pEjPun3f3E\n", + "dz6IvXN8q2903zld6ILzv7kuuuR8wfVnuBDjzo5IK8b3xLpFwBjrzAGqEZz49fE+qNgczUm7oH5z\n", + "rqp4X44ijyCGAc6ZTXyHK5CJkMsODNjIKSnqk6OUZ/nDXVFEZRgntFQ8UDjGUHkgql/n97vS9B1d\n", + "sS0eixFpaV90AEiMG3fvlMtlbW9vpzQIfiwEu+iov6cVQKkuLS2pVqvp7OwsxSxVq1Wtra0VQDLf\n", + "vXjxQtvb22o0GumsPgDR/v6+VlZW9KMf/Ui//vWv1W63k6xqtVoKIh+Px9rd3dU777wjSfr000/V\n", + "aDRUrVbV7/c1GAzSM5eXlxMgKZfLyR1B+0qlkjqdjqrVqkajkdbX1yVdufZIf1CtVpPb0OXmO8U8\n", + "SL/T6Wh9fV2tVkt7e3tqNpupHaenp1pYWFCn09H+/n4hoH4ymajdbmthYUGHh4fqdDppASmXy8nV\n", + "iXLnSJpGo5GymhPk78HPABvGFAvZ8vJyWtzYoRmPLJGKqUgYT7jdoz5yoI9LzMeuv8MzYpdKpeQi\n", + "nk6vM9H7/CIHF24fAHG/3087yOL5dcxfAJXPFeYkOy/dYMTtie7y+NAcwPG5y7z1sADeG12CLlPX\n", + "DVEnMt5ybiDqGF2CXnJhA9GYm2WIo2/pNzc6yYPmIRjoYNyH/jmbJnzd8Ho5+ImAzceUgyXuibGx\n", + "LovorvT+i/o3gpoYv+RGu6/VOdn52sp4zgE3xwe5ciNAKsfSxMBct0z43zvKOyAyQ5HpYtBHNA17\n", + "Qp1y90cg5ZM9x6rxO8eexMU0AjcUwtnZWWp73GLs9QMYuV/YZexWU87CQTYeb8Dn0ece5T2ZTNIW\n", + "emerqK+DXZe5x1J4wK3X260tnp+bRMjMA1EdBPl1OYYTWXrf+I4mZ5m8n/jbF7PY92z5jkwZz/Zn\n", + "ETjLZ8T8UOr1ekoZ4IzHcDhMC2/c2dnv99NuMIKrHfCenZ2lNjabzZRYcjweJxas0Wi8xHL96U9/\n", + "0ocffqjvfe97+t3vfqeNjY3ULoDX0tKSdnd30/EpDx480LfffquFhYWU6yla4+fn5+r1eoWFliSc\n", + "l5eX2tvbSwHXFOK4Tk9PdXp6WkiTQODyZDJJweIebF6tVtXpdFQqlVSv11NcFuOh0+mo2+1qZWUl\n", + "PRNZnJycpHgrz7NTqVQKgfLEsrVarRQXValUdHR0VOh7mCh0FIlap9NpYsSiweBxUNHQ8kLgsxuh\n", + "FMaLL+LEyw0GA43H45eO1XHwHVmG8XicAu4PDw8TI3V6eqrRaFR4htfVAZ0zNj7HAIWA00qlopOT\n", + "k7QLK7e4unziAcBe58hI8W5nYCILhfz8ep7v4DTKPzJMDrCkIoj0Y2Fi2zwONbJYvnMZ2Xl6E2cX\n", + "o25HbnE98fWK7xzY8T4/fskL66XLIm6eijsw4666CM6oO2kZ+M7X++hRoJ3udfD6OQDzdnnf5MqN\n", + "ACka4gJ3cCS9zPRIxQU957abBWxmuQn93U4ruvspChUUz6CIuxAc5efa4J+76y0OKLaokiDOF163\n", + "rgAsUbFRVxZoH3z+fe47B4IRhfv1Dpx4Hp9HgIEyy2X7pv3xN+/LKUGvD5alKxXkG9NkUBfaFunq\n", + "aJFGCj0nZ68b9XHLN/YJ1rTn1OFzTjSHsQFknZ6eJpBBfT0BJYsf/7NhYTQaJYaL+2q1WmKTjo6O\n", + "Up4o6XrXXq1WS2yW57uZn5/Xr3/9a/34xz/WgwcP9PjxY0lXLsFms5mykddqNX322WeSpHfeeUdb\n", + "W1s6PDxUtVpNzIaktOtwPB4nBgr5kvxzOBwmMAjAnE6narVaajQa6vV6iSVhwTg7O9P6+rpGo5HW\n", + "1tb0xRdfJNns7Ozo4uIiMU6VyvXhy2SY7/f7Gg6HSRa0fzgcpms9NxUuQRZ7LHuuI/AfEBcBGODS\n", + "3Y24JH2MUdCdjDVP5AmoRj85WHB9xqYRd6XBXkS9B9gdj8cpU7zrb+YtTDWuXtrIgdy+GErXrj3c\n", + "uJHl8va6cU2KCgwGX+SiPvWxn2PUXb5xIafkwjuiPkF+/n5n5HOAl7nv45428C4M5ly4R2StuAdd\n", + "yLmu7vHwPHde3JXO3677Li8vC260yJC57vc2UrdYT38/oC6u2c42er7C+NychyquM85GRRAY1/FZ\n", + "BMmscmN5pFAALpRIm8YFK+emcQCUE5yzBjlQwPc++HOupPjuyIJxPZMzUoRex1gPJpIzVQwyXAHR\n", + "kpKKh9ZG1IzFEAdZHAw5CzEqsuhT5zeT1d1qruzZSs3fsT7uFstNagqLQW4iu8wcaPO90+LeB67Q\n", + "3c0GMJzlKuDzCOhcbihkbxMWJM9nt5h0tWDW6/U0Xk5PTxPTs76+rkqlkoDU8fFx6mMWZIBE3GWD\n", + "WygqNrKX3717V++++67G43ECPU+ePNH29nayvuk36Sq+olS6cvH84he/0A9/+MPEQJDZu1Qq6fj4\n", + "WGtrawlwbGxsaHl5WZ999pnef/99DYfDxOgQq7S2tqbDw8PUTr7DeibBIDIlj1C73U79vrS0lJ7r\n", + "QLRUutqx50zP4eGhFhcXk8uQHWZkDO90OikDOUAT9ypjsdfrJYYEcFyv19Mi7WARQEr2cgAhu6fO\n", + "z89Vq9USy0jdfVy5geIWd07xs+jEWKiYxwlGjDYwj2CiuN/dRmxzx1UnXemdVquVdjQeHBzoxYsX\n", + "kq4TwgKkHBTAqLreirrdx7XrBY5TYnz4fHNdF9l1xjR18bnhRxbFtcWZGP8OudBHrof8vXEdcjaf\n", + "+nqKCPRWDBuIDBwAweOUGCscVwQ7ik5gjERGLK6l3kZY0EiCsH5hOMb1za9zOVCY53EtdYOduvvz\n", + "XMe6PvZxE+uRc+vFZ7uB4t+9qtx4ZnMq68Aqgo8cEpzFTPh9lEjR+vty11McrUa/uwM9f68v8v5e\n", + "B1252CGvq1sG1NkT03G9M1X8OGp3atgBDP9T3+hqcjlRd7daqR/KyJUcn/E83El+xEClUinEDxEz\n", + "Ehk03o2ijdZ1rj0RzDhT5f3p8oiWkPe1T1a3DmO/0W4K73TQ6xnFYZ+k6+SSyJkz1CSlWKbj4+OU\n", + "/RoXU7/fT3ViAfZJ74uW1wVAcXh4qFKppAcPHujjjz+WJH311Vfq9/vp+IRarZb6kKzdFxcXGgwG\n", + "+tOf/qTvf//7kqT/+I//ULfb1erqqiqV4nEun3/+uT788MOk2Gu1WmIr6B+Py8HNhpvT28N1uO2m\n", + "02mKTSLbuqSUDbvVaqWxR7sZY+vr6+r1egl8SUouv/n5eT169CixMPR/r9dLR6D4+Ot2u4nFgFX0\n", + "BKS4ttzNwndnZ2dqtVoFd5RUPIMyxxD5vHUm3DckxKNDYMcWFhYSuPNgesZ/Tic68EC3oTOYU8zR\n", + "r776KqXNaDabBeDi9fF4QPSGMwPOWPFZLO7CkpSAqYMU1wvIl/e68edpW2AZeYfr3siuIXvYwMhy\n", + "07bIcmF0U9/oofH+dmPZjWcMWHfd0z+AJdhv0ktQZ89BFw3I2BfULweGousuelsiGxX7LxdLyu+I\n", + "A1iPXafTPuaCG9gRMM0Ct9Er5d/lvFqF9s/85rbclttyW27Lbbktt+W2vLLcCCOV84NH2s9RfbTK\n", + "pJfPBZrFRkl/OUaK/ymvYsmcLXHmxe9zRO/Pd1QeGTF3F/q9ntk310be79aCdL2Tx5/p97q7EuvE\n", + "LbMY60OJKD3Wh3uwUN2K4L0wUl5XLM/4TH93jH2Iso8smltApdJ1+oH4XLfA6V8fa96fbpG5tUMf\n", + "YtESB5Qbd24V81xYClg8/77RaGgwGKQz9Zyx6Pf7Bfrft9Xzbqx+2nN5eXU0DNv/+NEAACAASURB\n", + "VLv5Pvvss+RK/Ou//mu9ePFCv/nNb9Rutws7AwlY55iUP/3pT8m19f777+unP/2p5ufntbq6qr29\n", + "vcQQvHjxQqPRSN/5znf0+PFjvfnmm4VUEH4gM+d/IQuez/xxFwW76y4vL1MyTwLDp9OpOp2O7ty5\n", + "o5OTk8KzeD5xUCcnJ8lFSX0Zw6PRqBCsPhqN0u5EUkxISnFtHNexsbFRiO1jbFxeXhZciXNzc1pZ\n", + "WUnsoo83DxFgfrubh0SMuNr8iCfGYHQPuWuOQHafF7QNViuyuDGmkLHIYc/I/euvvy4wb5eXlynj\n", + "vVv73h9eN5cD7fTPYLDRXe6+jjrDC0wGzJjHllFc57vegrF5lYsuriuRifFnoveIRYrhFegw+j4y\n", + "3vQFOoHvnYVEH/FsXzdhgmg/qXXQpT5unPmMupV6OKMY174Y8+WydsaKQqD5rF3m0W0X5eaeIR8D\n", + "UR97G+J64mM/d6+XG01/EMGLL/qu+HONz4GK3MLl18RrEVr0d0dXTw6IuMuM4oPBO5L7ZlGE7Jbw\n", + "2IroovJMuV5PlEKObuV6B6HRHeauPRSauy9zz+Td7pLzukXFIhUP8kVZOiBgkYnxaUxKJpaDRV8A\n", + "fOAjU+ofA1wd1MZ20g+4LqPCwN3CIufyceULre71c1eMj3XiMYiT8bgN6sd5ZJ7ZnN2dBNxyFArP\n", + "RG7UEeVDgHe73U4uPOKAPvnkE/34xz/WeDzW48ePC1n2J5OJWq1WYXz+7Gc/kyT97d/+rT7++GP9\n", + "53/+ZwKKjKfV1VV9+eWXeuONN5KL2uPjut1uOryWQ3wlpYznuNsGg0FyeQK+CDp+/vy5SqVSAoTj\n", + "8Vj1el3T6TTFJVFYmDmrkENfpeucR2trayk3Dy466kVAvR/Ci/tpfn5e1WpVw+Ew1ZU6jMdj9Xo9\n", + "HR8fp2eurq7q4OCgoB8cEDHucDF64D/uLOaTZ8PHJco9vquJcToajTQYDFLby+VyOv7JA+l5JmOb\n", + "nX2ckShduUSp997envb29hLIRK68Z25urpA2wtvJLlPGm8vF9RfzEiBExn2+o63+29vvbkZ39cWY\n", + "oXgWKz+5+BqKz21AbXSBUpdXHYTsYQQ8N7bHQWHuulyOLdf77qKkvnwenxU3UeXWtigPX/MiqKfN\n", + "ubXU18hIPLixG6/1+nBtdB1j1Hhf+3XMj7hevKrcCJCKbBPFhR3LXwJZOSbqVWDAhR0X4Rwb4u/j\n", + "J7d7y+vkHcDCnrvfF+b4DAdmOXYJ5ULOHJ/AXEPshreT9/tgoj7O0ETZuH+5VCql+JOc7GKOllm7\n", + "HT12ivt8gDs4iLtpnNny4sCFNrkSnjUuXLEDcCi02Vk2f360RL3Qdx7z4XEVPGNhYUGvvfZaWoS6\n", + "3a6WlpbUaDR0cnKS+ky63ogAMGDXG++LQNG/YxFtt9taXFxM+ZlOTk707//+7/rud7+rN998U0+f\n", + "Pi0k1uz1eqltZ2dnaXH85JNP9JOf/ETvvfeeHj9+rLfffjvFQVUqFR0eHmp7e1vtdrvQf8T/efwT\n", + "iv3s7EyDwSCBneFwmN5XKl3ll1pdXS0YACwcS0tL6Rw+gCjfVatVHR8fp5xcvnAAwFZXV7M7iZBj\n", + "PJSbpKCTydUROLAX0vXuu/Pzc52cnGhhYaEQp8aGkbiQ53YzurHCoj4YDBLYQg4AeYCGz0tnjTkG\n", + "B7l4igKPTYLRY74BtABEMOCMcQ+oJz6M+DL6h/vo8/F4nOLy+M5jhdyoof6VSiUlLfVzJt34cbnB\n", + "TCMjZ8f8sxyz5HVx/YGs/FoK8qbdUcc7iIk6aRZ7ghxgbCIRwLNyejGuaaVSqXB+I3PBUw/4vdwT\n", + "mUnaHdcSH2+lUqkQExfzlEXZ+H0RSHG950rz+/w53r/kP0PWcY3i+d6W3HiI5cYYqcgeOYiKSJXv\n", + "vTFxh0ZO4H5fpPykIkqPwMgXzdyk4v/oTpo1ESJlGJkcf0cESx7E7c90Cw2ZudWAAnXZxOKDLLJr\n", + "3o4I0FxOEehwTw7J85mDPs9cHCcoLgyXQ2RYfAL44M/JiHpGSjdn6VLf2CYOZEbGUtGV6u2Myozn\n", + "O5CiXXNzVwcZLy8vJ3dSr9fTcDhM6Qg8WauzOsjJZSEp5aSKliesG4kw/Qy3fr+v3/zmN3r48GEh\n", + "e3mlUklsCu0FxNRqNf33f/+3fvjDH+r4+FiHh4cJnJE4czQaqV6va39/P7Xv4uIiBYS7K0u6OhMP\n", + "ppSFF7AwnU5TmgG38gFjyARZT6fTAmDl3cfHx2q32wXGl0Dx8/PzQjbxvb099fv9BOaRnXQF6AeD\n", + "gS4vL5PLlPd5biUysR8fH6f6EhhPADjtx40Ia+JuL85J8/HjDDvti/O1Wq0WNg9wuC0yLZVKaVcl\n", + "6Upon+sBZLOysiLpWn+Xy2Xt7+/rD3/4Qxo3tI/rfBfwwsJC4aBiX8Cr1WoBJLixCVij3cvLy6lf\n", + "B4NB2gzgoIPCAuqbiCjMcXeTIZtZBhj/+4acyMg7s+X9BLtHHzpzGg11b4Pry6gzI8ng/eZrIHKh\n", + "bgSfA6Zc3r4zm3t97UA+zvTzXW7N8Hrm5OUGfJS3h7FED5DLgH7MuSf5cfZzFlDKAdJYbhxI5cAS\n", + "f3tnOCDwweyf+//8nXtvfNer6ujv5D63TCMAis/09kj55F6vqrtfF60MR+xOO8f7uNcn8asKiN2f\n", + "H4GGKw1KHNi5+jJR3RqIC0DOEgIkxFQFOTDF/65I+d9lG60l3s3kcmXlcgFE+ER010fsa28/MmH3\n", + "FIX6AZhY7LDkWVA90Sk5lIg9OT4+LgAN2k1eJAABixPt8ASZsGylUknffvttSnopSQcHBwUL2McT\n", + "7Ngf//hH7ezs6IsvvkgxSZIKC/Pl5WViQVjM6ANneZrNpvr9viaTSXL9eU4n3FbT6ZXrDIArXadV\n", + "6Pf7aRcdfQWw63Q6mpub0+rqagGc8myMHZi1w8PDNKbYbk992IXqiw8A6uLiIoFBmEXGiOeBg7Vi\n", + "YQNkYnS4BQ+w4jPfpQYAcZemg3Zip2JsGCwPdcoBCk5emE6nWl5eTiDIgfrjx491cHDwkoXP+Ped\n", + "gs6kkXrAY6Y8/YbPRXdn0U/xIGf6zRdzxgJpMVy3M58B5jD9tG8Wy4PB6u2Nxrwv7BTkgpspMln+\n", + "d3wvYyKn1328R1adfvb1wvUVLmQ+c93H/25oevt4ro8FXI8w57MMa36cdXNZ5tbVSJrEEtdQ3OAQ\n", + "DuVyuTAOkRVj1Q2uWR4Myo259tx95MU7MS5IdFSOvXFGK4KzHGp1cBDBEt9Ht5a/j9/eDlcW/uP3\n", + "+n2UHADJsVk5dsMRtS/s0rVF6otELlbC2+PFB7bL2SeuMz456nmWjN1SoN5Yq94uf2ccDzEFg/e1\n", + "B3DGieHxVrHdLPTOOEUmh2dFxeegKrKHbgAQW+Z1ZSHAFePsCYkuWeR8PHi+GS+0ATZrbW3tpQWL\n", + "3Ee0mffV6/WUUqDT6SSw8OjRI/3+979PR7y4S4ws5AcHB1pdXdX29rZ++9vfSrpKyPnWW2/pm2++\n", + "SS43cgytr68XkpMuLCzo6Ogo/Q0bA2hyNxT9WKlU1O/3tbOzUwCgk8lEe3t7KpfLKQeU98/p6alW\n", + "VlbU6/VSbNXFxUU6VoO0G34sC0BnMpmoVqsVguFZYKrVqlqtVqprt9tVo9FIwDfGazHWvH8kpWN1\n", + "nFGLqTdgKXEn0vbpdFoINneWi884VodYrnK5rKOjIw2Hw5SGg7pwzXA4TGklGo1Ggammbl988UWB\n", + "OY3jH+AQxzCLpqcxoF78jgHV7sql0KbFxcUCm039y+VyYuP8+VEfuJ7Luboo7gWgfa7P0RU5Q5a+\n", + "8jABCuPU3W2xvr5eevF1ahbYQL+78Ukf0Rf0P2CRseRMofclbfF3+LyL6zHPiW3n8wg+vU2RJYtt\n", + "p66+5g0Gg5QPD4OD90W2zcNjcu8p1HfmN7flttyW23JbbsttuS235ZXlxs7aiy45qbjl05Eo1CwI\n", + "0+nKiJBz1rn7cyND5MxERNZ+vTM3zkJFdyT1iCyNF0f9/r+70WL7Irviz3Y6lffCXBDP4Qh7Vp9E\n", + "dsotIH8n/QFl61uTx+NxsuTdx4/FBXPjfeIxYlht7pKIQZ65MRNlwv/4+qPF5+xh7BtKjKOItG9k\n", + "P93diwvMZe50+Xh8fcgorrVy+eoYHZI7eh80Go3CziTq6vFafvTIdDpN5+mdnp5qdXU1WZewVH4+\n", + "n7sEkRf98/z581Tvv/qrv9Jvf/vbxLJQTxiX6XSqJ0+e6P3330+uld3dXdVqNT148CC51VzGjAt2\n", + "E/Jetuefn5+r0+mksYUsSYwJ++IyJXM8FrufUUiMTr1eV61WU6/XK7hw/Pw2d7kgU+arxyzh8iNb\n", + "Oi5FSYnt2t3dTQcQM86azWZKIIkrC/YHGUyn03TUj+90JZi8VqsVDl5mZyR95pnDYfjm5ubUaDRe\n", + "0jVY+hzl47GCyI34KM803+/300aCzz//vHDWoOvZ6M733WG5mB2uja50nussD8/2eCTYHK7Bvcwu\n", + "11lsDnojegNiLA/1ZE1wN60XxpE/09/HNTzX3cRRb8d0D9ENi070NcjlzHfI2tcRZwvRYd5+7wNv\n", + "B+uWxyH5dzyLMA3azXPdC8C7WfMdL3gfuPzi+3xNoO0cW3R+fp7YXmSLq9xZOu8Xdznnyo3HSPnC\n", + "5YMxN9h84vgOM3+eDzCnKqNwfeLOKgxOFnJKfPcs12HOt0vxyeH1jT5i6pkDOu5C83bxXQRl8b1O\n", + "10a/eK5OFAeCXi9++0Sb9Z23sVK5znROfXzBQBky6aPvmzrlQBZtdFBHvXLyczrZY6GQl4MlL1zH\n", + "ZIwuDL8vN24mk6szBQ8ODrS9va21tTVJV2Ot1+up0Wgkl59nRC+VSqrVappMJoXA4VLpamcZrqle\n", + "r5dinXCF3blzJwVJUwAvvgGA2JMnT57o+PhYDx480N7enjqdTsrbtLS0pOl0qrW1NX311Vc6PDzU\n", + "22+/LUn6/e9/r/39/RR8PhqNkrsQMEgQt8fPICMCyl0J12q1pAhZyPgtXcczLS8v6+LiojAPzs/P\n", + "1e12E9B1fQKoJf5pPB4nQNjpdJJ7lTgij4cCfA4Gg7RxgL5/+vSpJpOrc/iI+aKfqPfCwoLq9Xrh\n", + "iJzFxcW06CNj6Tr4m+t8LuB+Qx+6C5b7PcM+4BOg7ptU4qJHigXGLMAWF9XPfvYz/eIXvyjMfQfl\n", + "xKjEkAx307iuBQSib3gm+sLnl8vA527UGeQGI5YoGliMQZcr/Z0zkh0k+G+Kt99dl1IxX5LrYAcS\n", + "HrrgxXVWdI85gHRjNxqOHmLgcyjKk/7MuUEjkeCyQQ/6dZ4LDpDHdRE8x3f5cyjebjeAaF+Mj+O5\n", + "fvIHxgt9HGNdGaezyo3FSDnAkfTS5PJdbc5QRLTI4HOrZ5aCiXXIoVj/n/f5/17HaAnwfbw23h9B\n", + "pC+yEUhxr6NyZ8vi5z4QmdBY/R6zwOSPu7n83T4ZKLQ5go/c79inKAQGpstnfn5e9Xo9WYIocBZP\n", + "HyteFwdC8XsmDXLwAEhn7mLxseH9y+TKxR9g5ZfL17lwYEpcJihNB7T47OkPtxKr1aomk6st9eQu\n", + "8tgy4og8jsfL6uqqer1eSnYpXSmyUqmUzoaL89APl4bNka62+B8cHKjT6ejh/9nRxzEg7XZbo9FI\n", + "Kysr+uijj/SrX/0qtYHz8J49e6aFhYV0jIyktHWfmJxoffti1+l0EgAh2Ju+JUkodWUbPfmLYGZ4\n", + "JgqzXC6nnY2SEgBhwRsMBinHFs+o1WppPLH7ENZoOp2q2WymYzh4X7/f1+uvv54OknZjDPah2WwW\n", + "Fmr6pNVqvcRQXlxcJHYIoOnjGz2ZM8zYRQeocJBFDBvv8DkOw8kBxC5TjIb/+Z//0Wg0KuSDijFR\n", + "cS57ey8vLxOQnk6vg+jdoGQsejwl7ZKUGCe/L74PMO9B+sjW3+9AivfHXcC0ywEo8o5y8A0RPCN6\n", + "YCgOUKKxHAO6I5Ci/own5oV/F4sDCNoZGfrIzOWKr7sRADrL5aQJ+jKuHb62u072z+Oa64SLvw95\n", + "U38/gzC3WzIG2Odklto185v/H8sslia6Lf5v7nEw4f/783Lo2d/B9/7OCILid3TmLKZo1jt8Usd3\n", + "8LzYabPAoE+sOJGcYp1OrwPzInjMBWo7xctzc4MxFpdLtIAdFMf6475hMfBJSpbvyETmZBHZTVeC\n", + "UlFhRyvPxwoTOwaMswPF5e7bwwH8OWofWXhQPbvTYHVYAE9PT3V4eChJKdXAwsKCTk5OCophaWkp\n", + "HUrKOIQFKZVKaZFst9sFWhowNhqN0s4uZMN5egCTqIiazaZGo5GePHmihw8f6sGDB5KUDk4eDAZa\n", + "WVnR22+/rW+++UaS9NZbb6W+63a7Oj09TYxbo9HQs2fPtLi4qFqtVkgQiTtrY2ND3W63YD2zm+/O\n", + "nTtqNpvprEHaAWODK40M5rSBnEjIzXNeAebn5uaSK4Ax0mw21W63dXp6qmq1mvrZF3wHh9x37969\n", + "5L4k672kJGvqOBqNCocrw4wRkM9iT9A4bfCAfT5nUwGg2cegu0ApjDV3+zDWAa4LCwvJJeb90Ww2\n", + "dXh4qMePH6cx4uwK4zsyHa6/+d4Xa8aNt5P61Gq1wmLnQIh5mtsUIqmQnsJ3s+JKY065Tndg5oCX\n", + "+vE+13+uRzC2XP+7PGIoRFyrouHphjLGAe2gzrTH74061HeuUWi760fX0dLLa6n/xA06sR8ovuZ5\n", + "yAxj0Osxi5HzZ6MDeJ6z2xEgwyzzGc/if5dnlH8sN8pIRQTti3kEKJ5QMqJzR/VxMeV+f7dUzBvh\n", + "CJdrIsKN9fe/fWDm6sX7/PscUONZkcl5VT1dls66xIGNBeM+aWepooKL7Y1AA/lGpcgPLJJbH7CM\n", + "DMw4cZ3idUXkTEUcN3Ey8z/vyQFwv86vl/QSUPLfcTcKypFrsHLoo5gIkd9RwRPDtLy8nNg42kuu\n", + "oqWlpcRmeH14Xr1eTwkfKQCtxcXFwjZ3j+/y3VaSkiXPmIFpkVQAH8PhUM+fP0+AaHt7W71eT51O\n", + "R5PJRFtbW3r06JEkpV1xx8fHWl9fTwf1Ikd2WE2n05RLSbpypeFOK5fL6RgS6frIEel6dxdJO6Vi\n", + "hnrkRjuWl5c1NzdXcDGwQMMI7uzs6PDwsJCvaTKZJFchYxR537t3TxcXFzo4OEhuWMBwq9VKQI++\n", + "o54wYIyZxcXFl2SDm1K6XgzcZc11PtaY39F16ZY+xwj5PHT3ui/OGA3Ulfgqxs7S0pJevHihwWCQ\n", + "2Dj6h3Ea89rxXPoqzlfXa/QRdT07O0vPR67OWJCtHpYwB+oODw/VbrfTfaREmMWA+5x3wwRWmLa6\n", + "3nM9lFvzaGduIWc9jADJgUJu115kI70f/bn0ZXRReh187Md1x3VnjMHiWg+HcD3Dc2gPrlpfj3yM\n", + "eHtyxriDb9fhs3atOyj2eqObfU3PvTeWGwVS0svAwhfZiJzpeO+UyP64cLhnFqJ06yKHeON1uef5\n", + "PQ4aaENEuLHjve0OinJsGiXe6+62Wf5ip/ula4WCTzwCy1z7JBUUBrLwNmHFovy8Pq5QXKnEtpbL\n", + "1/k9PKgWl5wHHEcLNgJQ6Gh3Fc9iF70OswAY10RXabw39hvuPMaO5yDCxbK+vp6sfZdNuVxO8Svu\n", + "lkRJ+3EkvtUX8BHbPD8/r+Xl5bQVfG7u+pR7z8nD4k+fE6sjKQUj4xJ78eKFHv4fd9/nn3+uWq2m\n", + "ra0tSUrs1tramobDYXo27WPx6Xa7arfbhQBnWB+UI+0hfgSgSYA0rkaAFnpkNBolgFIqldK5hZXK\n", + "VdZ1Tz2Aa+ji4iJtoZeuWBfG9NLSUkq5gNx3d3eTpdvpdNJ4gz1ifHKeHfcRXwWrR/txazK2PTga\n", + "wJ0zPAEC5ATyBdENEs73gxEtlUopEJeUGFzP+ML1x5jwTPPkjiII3ecHLEXUP4yBuB7wd2RXuI/4\n", + "QOLGXJ8AfsnHxoYE5Mj1zBt/B6DIA6f9Pmf6vS+8vq7znIVDJ3i6BF/0ud7/dtbvVSW6cX1ceCxf\n", + "BHSxHyJIieuJ3xuD2ykuG/6OOtbf5zJ2Wfi6lGP4Zxm4Odl4/WcZ2G7Ax/v/Uh/cpj+4LbflttyW\n", + "23Jbbstt+V+WG4uRihRg7nv/3691BBwtAK7nN6g3RynPctlFZO4WHc/IMQ/+/FdRuJGFi6xW/H9W\n", + "PR3pe5yB3xfp8ZjUTSpSntJ1nEguWN/jAairU+peR7doYnxEdG1GOtzrQrwKrI7Lm+udiaFNLsP4\n", + "TGfgIqsWrSQKrAL3ujylomXq7Yp18DgX6SpOqFwuJwqeQGLpiiHpdrtpezwuFuk6Lqler2swGKhU\n", + "KqX4GjKnkxLB5w9xVT42fEyen5+nw2vZvYcs2NVG3BZsxvHxsb744gu99dZbunv3rnZ3dwtuz8Fg\n", + "oI2NjXRWn8sb90ulUinErszNzenOnTuJ/SFRpnTFkBwcHKRjSk5PT3V8fJzOW1tZWUmuoFLp2o1F\n", + "XxADc3x8rGfPniWmq1qtpizya2trevbsWRrDsBvNZlOl0tUByeyE3N3dVaVSUa1W08HBgZrNZpqL\n", + "sAqkYBgOhymRJzLe399PrkN2xhGAz7Eyk8kkMXkwh6QkINaKvvedZLEMh8Pk9pyfny88s16vp2By\n", + "YsXoQ092yjzgiJjpdKovv/xStVpNm5ubOjw8LMjb52rOZebzJbIgzhI4kxePyYl6kp2TMX4M5oln\n", + "xOOg2ADAM/jt9Y6bVKKXJecujQHV3p7IgsNGodNzCUFzepDfjDnWLpexrwHTaXFnZgyr8DahL5yd\n", + "4ztfE3O6nXti7JS33XUy7BQyiOuxe314D/3L5zw3rmGwgjG9Q9zkEduRwyqUG0t/kBO4lE8JHxdo\n", + "/yx2dBRu7HAvs1x+sZ6z6h1BgdcdheG+aQc2sU1xEsY2zHI3eT1iQWl4YHW81mUQwcirZDDr3T7Z\n", + "AAVeUAg5ypjnRXed74gjZkq6jhXwieiBkF43fPDIxXeLvKrNsW+4z92ptIvJCfij/rwTdwlxRij3\n", + "o6OjlFH78PCwENAJGADE+JEZAEtkRDslFVIhAHwBZ6SUYIz6zqVKpZIWUwLPARk8x2NS6Ceu/f3v\n", + "f6979+5pZ2cnZSiv1WoppmZlZaUQW3V+fq5+v1/Y0YSbbXFxUcvLyzo5OVGtVtP8/HzKFs691J8+\n", + "AdiUSiX1+/10BpvH81xeXqbnHh8fpx2R9DeB7wA4z09EsHmv11O73U47+o6OjrS9va2Dg4O0K47+\n", + "dfe5dH3AMeOi3++nLOIARklpiz7uW8Y8fS9dxZEdHx8nN5F0DVYYk65PAP+lUinlEqMsLS1pcXEx\n", + "7QScTK6znrN7FODNzjyeu7+/n0DmwsKCms1mQd4s7tQvtzDGOQyI8LUBGY5Go/RMP42AMcz4xMWb\n", + "c+e7PJApoQmz1iDXGf48gGckAZgjtNHbE3VUDNlAl8Y1g7lLmzyujXul61MafDMJc9/1ZE429LOD\n", + "WIwP1x08YxaYQu/52aouHzd4S6XrHGLueozuthgDhZy5L24q8uczT2IcmceMSUU3I3L0I71iufFd\n", + "e7kYmhzQ8EGSA1ZxMEjF42Z4bw7A5CZNrEeOaZrFhOU+i+xQrDuK3n3Ksc4RgLjcpCJ74pOWCeug\n", + "wLct89utowho/F0OyqJf2weoD+r43BjMx+TOAVvui4faslA5WM69i3fk2pHbXejxBV6wVD0Y0Rkw\n", + "t54cTPM9DAJt9P7qdrvJqq7X64WdRDADsBi8k/iQ4XCYApy9eAoDrHDkxgISGTg/Uw2FBcvD4ghj\n", + "5TE7zWZTrVZLe3t7+vbbb/Xw4cOUNwo5Hx0d6c6dO5pOpwlkNRqNFFNDu/xYknhsCjFJT548SXEy\n", + "x8fHiWEBEMG29Pv9FMDuCnY8Hqvf7yd2DmA3nU61sbGRFO7y8nLqC1IUDAaDtEvtyZMnkqQ33nij\n", + "wJDBMHl/cTizB6n7FmxA6+rqqiSlg3cZF6VSKQGbwWCg4XCY4s88ZQjy9nnlgMkXu+l0moAymzro\n", + "U98VR86u6fR6QwBsmHR1DiPzghgq2k/us5gnSCoaNdTLWXVf1H2BZnx6OoE4/svl8kvj1AOvc7tr\n", + "HfR43zkwoES97LtnfQ2Kuj+uVQ4wYn5B5BO9JP5/9B44cZALnAasxu9harwdvivS5RMBLjokgqUY\n", + "fO/P4p2+frmcATye+oj7y+VyykkWAZEHlOc2RLFueeyYfxeJEq6fRVhINwSkfED5YPTspt5RPtii\n", + "K4LveUZOaLmJwSBx1E+JFsmsxTX3zFyd+Y6BkVv43Q3i9zkzw4DJWRBu8fn7Hb37wIkZdiN17O/1\n", + "z93ag32h0Gc+MWPwJIrFJw3PdUsnBhACpFx2pE2Iz6H+uKV8h5P3xSwFFUEz32PNeQCoL5al0nUG\n", + "7cjuucUWz/9ikrKzzHeYtdttnZ+fq9frpbP43K0wnU7T585yEczurtWYXLFcLqcdgoA0gqt5lp9h\n", + "xnNwk7HFXrrOA4b1xvcUdtTt7+8nNoiyurpaOBDZmRUyfff7fTUajUKeKNyWa2tr2tvb02g0Su8E\n", + "gJEtfW1tLcl0Op2q0+no6OhIlUpF7XY7MVmA00qlklg5ZONZ0BcXF/X48WO9/vrrqR3or6dPnxaY\n", + "w/H46gBlEoE6eDk9PU1gD8DR6XTSdw52XMmPx+Pkfp2fn9fZ2VkK/G82m7q4uEjnM/pi5fmV4nZ2\n", + "Ukq02+0EopA3Z+fV63UtLi6q3W6r3+/r008/lSQ9ffpUz549S2kqpGvwS9JXNy4cUPlGDN/pyvcU\n", + "Z914Rr/fV6vVSrnCuMfnsB+ejewAhQ5Ambe+9Z7ncP6gj1Ha4GsV8nLGh7ERQygim+5sHC5v9JED\n", + "pZgMljEdjTvXUw4OnFVyhg1DEcDuxp7rwmggUz+u9b+p19LSUpbJiyEYvtHC1wNfg319cIDsz6Rv\n", + "c4QMsvNkrD7O4noRwXGu3NiuvRh/49RaZIn4zF0KFAZhrpGRaswxHfx4TwFGhwAAIABJREFUR8V3\n", + "5wCa05l+X66O/h1/++/YbkmFTowskN/Pfb4TJL4j0pY8n8U0x9ZE+cUyC517O3KTfTKZFNiOXF08\n", + "RoH/fZK7dcRCkdsGTHGFJb28y8Pfx3UoPt8lyL2ePdwXfe5nl5gr92jJuhUFyCHvj7sbut1uco0N\n", + "BoPEiElKO9V8YWLxcmq8VCoVGAkSV6JM/H5yLF1cXOjk5ERnZ2cp7oodZvV6PcU6UZfDw0MtLS2l\n", + "pJIcaispHajL4gu44btWq5UWpnq9ntxYzWYzKXRX8NIVqCGX03Q6LWyHR8bsIptMJtrY2Egs2MXF\n", + "hV68eKHz83Otrq4mpklSyhE1Nzenfr9fAFKeFPWbb77Rd77znSRn4qI6nU7qI9/tNxqN0vOk6wXX\n", + "E46i5AFEDnrYoYdsAHMcanx4eJjaT16ti4sLDYfDgpFUqVzn1mGhhHGEjQCcEQ/H+K7X68kQkKS9\n", + "vT39+c9/liQ9e/ZMz58/T/mmfDHF1c0C7s/w+cxY9QU5lriwMzY855VUdEMBUmmjszCeANS/5x2u\n", + "C6NR6+CE/6MBFY1b7wv+9/UuhoJ4mhreDwvpMo4pGZwl8ne6Low6nOc7U+3tYc7yXGfbnY13efI/\n", + "Ojwayf5cYta4z+vlhjfPAtC5256x68asy5R+zK0Vvta7fo6pgnLlxoCUlA/qll52wVF8MMRANWee\n", + "fAI6rejvcnYiMkQ+SF4lcO5zVOvM0V8qESjG9nhdIrijDdEycBk6tT8LVTt1THGmyQGdt93bn6Pp\n", + "Y3ELgwU8WiOU8/Pzgq88x+xJxVPX/cfllusLlDkTKvYhn3m8hLfP7/dxxP/R2vbvqXe04ACYABz/\n", + "DkajWq0mECopATVXwrS/Xq8ni5Y2AQhZSFhk6vV6Yoj6/b5WVlbUbrc1nU7V7XZTX5DLqtlsanl5\n", + "uZBpfHFxUXt7e0lxHh4eJtfe3bt39cUXX2h+fl6tVist3LSPWKbT09NCP3nQdMwWPp1OdXx8rHff\n", + "fVenp6daWFhIrI90tbAzH8mvhdwGg4F6vZ6azabK5bJqtVqKS5pMJin/0NnZWSGZ6fn5uZrNprrd\n", + "rjY3N1Uul9M5hH5kCcCQPhwMBhoMBqlPPE8YdSiVrpOpspisrKxoeXk5sYPOZLGwDodD7e7u6uTk\n", + "JIE0smkfHx8ng4B+Ylx2u90CK8m4gMXsdruFc/+Wl5eTW5MA7idPnujZs2eSpK+//lrHx8eSrty1\n", + "jD36Siq6jaNedcPKmQc3Lp0d9zAAnxO0D9kDUnOMCnJ3vepMdvR8wFTA2ObcgrQ3gkBAkbuI0ANu\n", + "OPmz/HnRoKUNyCgaks6qeH24Ltc+13PIis+cTYt1hX0GmDtrjj5wDwhAy2N3+T0LrPjnrl+5h3oC\n", + "2kql0kuhILTNvSr+3auAlMd45cpt+oPbcltuy225LbflttyW/2W5EUYK1iYyKJE5ir7yyAL4fc7k\n", + "5Fx/0cXiSJT6OOvi90dGJJacHzbXPv6HcvZ7nIVw+pPngaKjdUWJMTsxritHc0pK1rFb0FCZzvL4\n", + "u5z6zvnpvR/cEuJ6WKbY97zLGTK/nrbkfO3RWsj1U2SW3MqLTJ67Jn3sRKvT6X7+90Nn3dqNY84t\n", + "day5paWlAo1PQOVwOEzuMncJnp+fF8a0M4icNUe9vK1xhxdpDIbDoY6OjlQqlXTv3j11u920Uw73\n", + "I4k5t7e3U3vW1ta0ubmpr7/+Ol375Zdfpu8fPnyow8PDFP/jcsC9R0B4ZJ5pC+ySdMXytNttDQYD\n", + "VSoVra6uajqdpucPBgPt7OxoMrlOsuhM3ng8TiwLLkTpipFrNpvpuJrpdJrYHDK3r6+vq1wu69NP\n", + "P02xVbANGxsbmpub097eXiHJKQlQOdAYeRMsfXl5qV6vp4uLi/RMguVxKzSbzUKKA5glSVpfX08u\n", + "2J2dHX3zzTeJKXBXFkyRu0KZTzCc/X5f4/HV0UI+ZkjkCuM1GAzS+2EL6TPfKBB1k3TNMDBXIjtA\n", + "iUyLjw1SGLjrkPZ4SISvCc4I5dxMzhbFGBrXMzEkwtch1xMuv+jug5FCfq5r0E/+vwdRo6PcpZlj\n", + "wSLLhHvcw1N812L0rvhuYK6P6yXXS9fZ4WFHeQb3+uYAnulhFc7gezs8VQGyQ4d6HxI3GHWe1zPG\n", + "+VJPLzGeOHqtYrmx9Ac5msxpyjhond6MrjenLv077nFQE104PMMFGRfXXB2je8vb5fWMPu+cO4//\n", + "o9uMetLx8TtoTad5o5JAcUSXoVOYuUHigy0CFXff/SWQ6c8DZMQ4ghg46FQ3sSHIMbpgXe5RplER\n", + "OQiKSpD7omsSSt4LSsTdePyNYnAglGtjrg5LS0taW1vTysrKS4dpslvOFwXmideVwnfEL7iSvLy8\n", + "TC6l6ErExYbrp9Fo6M6dO5KUdonNz8+rWq2mLejS1fb3+/fva2NjI7m76OejoyMtLi5qbW0tHdfi\n", + "7QYocpiyu0vn5+dVq9VSfJMbWx988IGm06sjbLrdbiE24969eylA/f79+wXXBGOBYPKtra2Ca8Az\n", + "rzt4q1QqKYfUkydP1Gq1Ul0XFhb09ttv6/DwUE+fPi24KdgNt7CwoO3t7cIiNBgMUgyZL0CSkqsM\n", + "l9vR0VGSHf2Fu3Fubi4BW462ITj+8vIy3YfbHBBFSg3+lpQ2Q3jwPkDq7OwsudIIaOcedE2cL/SX\n", + "Awf/nODpCE5Y6Nyoc/cSICqmHMG1xFxkdx/1lK530cbFGdkChqJbiOvdFUm9GcuzAI0bkjzPQyti\n", + "GINfm3Mj0r4oN+qUixt1d53Xjb+JL5L00noBsESWOYAbQa2fCQjIimttbhMWesANUJeFg+SYQgH5\n", + "x91+Pi6p46xd68jK25aL2aPcCJBy364XX+jcYvfvGfzRj87fcXHyToiD1FmeHLqOFkKuxM53688X\n", + "8pwfexbwiEyctyUu8pIK8UR+ve8yife6bDjV3QdVZG8cAPJ9ZFlif0Vrj+fE2AmXBbFUDGrAA/3n\n", + "8kXeKP7Yxw6iHXSgPHJWcO45XqLypC4XFxfpwF2sLn8Gipd3+nfEBhHg6+OGOBW34KPVyPMiWCLR\n", + "ZQShi4uLmkwmqlarqlarKf6G+9bX1zWdTnVycqLDw0NtbGxIumI6zs/P1el0UvyQA8P9/f20oAMo\n", + "pKsYqadPn2p1dTXFMnEO3fn5uRYWFtJxNXHss5MNBoTFfnt7OyUcZUz6MTDr6+sajUbqdDqFJKK8\n", + "c319PTFRvjhw7A1xMHt7ey8tYi9evEggjLl3584d7e/v6+uvv9b8/LwajUa6j12OvuuTPvdUErBH\n", + "fDeZTFLKBMCLgwWPkVxeXk5B6hyTQ7vL5XICaHHRp89d5uyymk6nSd5bW1sp0H5ubk7Pnz/Xt99+\n", + "W0gc64Ze9Br4HIxgy3VTLkbGwbPvBHTd5EYqC6TrCWekKBF8OFPO9TFInT6KAIT3UHIMObJ1ubtO\n", + "9vscbM1i62gP7YyB5+icaIi6IRgJBQed/kyuYwz4e6Vr8Ersp7fD11NYRNrq60g0aDFMfSely8lJ\n", + "FwwD2useAl+fXQfnxoIDuly/zio3mpDTBeeMQnR95QZTZJ18MMRreFdOqN7hOSbqL4GF+D11pSMi\n", + "ePF2+vu87bENgEe/JrbdFaR0rUxA75EFkl4+P+ovtYvfrkT8ur8kN1dw3hcsckwMduHwnQ/+XB29\n", + "PpGKz4F2d+vNYrH4PE4o6u27jngmu/+cuvadNFyLIoqgrFqtprPMottlFv2NFSldMwnS9YLkIMnr\n", + "NZ1O07l3npiRxXN1dTVlB8d9c3R0pNXVVT18+FDn5+cpaaV0BQYbjYbq9bqOjo4KFvuTJ0+0sbGh\n", + "/f39lG+KOvf7/SSzo6MjVavV5KKinwhO9vY1Gg0dHx+n3Uunp6eFvEeekZ30AsiEnFGNRkOLi4s6\n", + "OTnR5uZmeifzgZ2JjKl2u62jo6NkXVer1fTM/f19dTod7ezspN1HAJpS6Srj/GQySekTkDeygAHi\n", + "sN04xp3RpX9xP7G1HBat1WolNyRnEXqoAAA6MiTMGZiDfr+f+tDPLWRe+Fj3TRi8L+fSY5FzfcOC\n", + "jqEUd58xD6LrKRq/OSOTOZkzsHie3xeZKN9oMZ0WdxtG0J9ruzPcABpf8+LGKC/oPndVcp/rxOgO\n", + "Q0dQF1KyIA8HQQ5OMbwBRQ6IeP/i4mJqkwMR5rsf4Iz80PvIyF2Jrr+jjo8g2ccw7fVdlnyGfnOg\n", + "5f1OX/hvD0GJfeN9MKvcaPoDKZ+cK9KZjlgpzjRxbw64IGyu8XdxTWRXfEJQfDJEEBffGRWT9HK8\n", + "TGRWqAcd5laGA6bcJOUnunpoAxMkKk2UjLt2vF3ezthfOTbJnxFp2UgZu/sO8MQzPWmey4G2e2oE\n", + "nxA5+tstsRxwncU00g9eF1eE9JUzOa7sooJ21ysLIDuwAFXr6+t64403tL6+nurqOxMja8Nht6QT\n", + "8LiUSG/7mMKdwnURLJbLV0enNBoNbW1tpQSRz54908HBgdrttpaWljQcDhPImk6nGgwGarVaWllZ\n", + "SRmupavdZ3t7ezo8PNTe3l7haBVPM7C4uFjY8eOU/+XlpQaDQTqS5PT0VPfu3dP8/LyePHmi7e1t\n", + "jUajBCbm5q6OV2k0GmmnndeHfEcsHN7HAB2+Y6EiLQI5s0qlUooJq1arunfvns7OzhKIoQ/b7bYu\n", + "Ly9TXJK7t9F3MG++MJRK11nbkTHfjUYj1Wq1lJ9rd3c3AdDT01O9ePEipeAYj8eFQ6JhTJlTOWaF\n", + "dzmT5Qu4J22kPrTB3VWMMfQkfZljA3yR5XPACzu//D76iXnncpvl9YgsSGTAoqsoMkNeT2f/3ZCL\n", + "xm7Uy67TXDY59xzxaPzv33G9h3fwnR/6LhWPtHFQ5M/FMPA56O+gnbwvxlnSB143xpqzRN4XDvD8\n", + "N/L1dcRBDr9ZA/jOCQPGm6/B3t4IYn0cxnq+yq0n3XCMlAtHyi/S/O8LofQy2+RsQRzgkYWKdWBg\n", + "xIWYEpE59faO9Pf5AMm5seKE4V5AD+4G6eWtns5kAECov8fm0C6PDfEFwwdTjrqMiiNaVTw3IvUo\n", + "C6flkQvWq7s3PLeUTwwHq5EN4kw0+sLb4vWgbx2gM54iaMTH7+3zc7pcBg7+vF1cc3l5mRYiLDIH\n", + "MCxu6+vrWltb0927d9VqtQpxOTArvM+34RKYPD8/n7b3u9XmBoQrTrJrw2R4WgHaDuDb3d1NeZSI\n", + "wWExJiGqdJ1p++DgQLVaTffv308Le6PRULvd1u9+9zv95je/0d7ent566y1J10wHBg8uG+pNIkT6\n", + "he9gVQ4ODnT//n21Wi396le/SvInMJtUDp7G4ezsLKVmGI1Gunv3biFLfrl8fUwNzI10HYD8/7H3\n", + "Jr2RJdcZ9psDp5yYHIs1s6pbPbpbguV2t2XBhlcybMswDHjjP+Bfoj9hLQwv7YU2hleGBcmyBQuW\n", + "ujWrq4fqanYNJItDzskpM78FvyfyvYeX+gADH8oLBkCQzJv33ogTJ87wnhMnOELm+fPnunbtWppf\n", + "5rXX62XQquFwmHgV+nkZg9FolMoODIfDjHyglpTnW9EvQsHUGdve3pZ0nlvFPLJemF8M1tFolAw6\n", + "52EQqfn5eXU6ndRPakjxHa+6Lk2rsEej0NcNfEe9sLzGPNAfZFrMu8LA8qOY8iIH7nj493y9u0Mb\n", + "nW3+J18MY8EdZl9zUe5LU0PSc6/4ftRR3m/KYWD4eA4X33MHmXdjCLGuvOioy2r0jL/bHVZHcV0f\n", + "RPQvT3/QkLNuYLpsHo1GF4w8aZpbSl2yKBd8fhwsoXnZC3cQ3Dj3vjugEJ9Hvl2e3k79vvTKVbtq\n", + "V+2qXbWrdtWu2lX7re2FhfZiTBQvn8/ycm8us3zdMnUPK3oljjzkvdc9s+jhRE8DT8bvc+jb/6YP\n", + "HhbKS8b0xOIIDXtIzhv9AK3KO/QRjzYvHOf/e5/IwYgoHda6JyV6rk+E7/E2yGVxyNmRFeYh5k9F\n", + "7895hmt58+vzEceK5wV8DO0ZNyEmxu4oHp68lx2ABowbL8w9R57n26qZy3a7nRCMiHKenp6mzQBx\n", + "p8l4PNbz58/VaDTUbDbTLi/6zI9D7tI034Px+hhHo1FCB4H5QQnIX2LnXa/XS8jN4eGh2u12Qis+\n", + "/vhjbW5upv4sLy/rzTff1PHxsf77v/87FeV89dVXM4VGHVVrtVqpTADhS0827na7Go1Gaadhv99P\n", + "+U+lUimF+hqNRgZd4UzAcrmcDib2eSwWzw8JJgne5Qhz0Gq1tLy8nEEj2IHHcS7saINGVKSuVCpp\n", + "LsjfAl1yFODo6CjDl9IUkQINJFwI7aVzhJPiqCcnJ6lgKWOgsCqoMHRhbguFggaDgVZXV9OOTXjJ\n", + "Q321Wi2Vm2A9sCvw+Pj4QhK7y9cYwsvLbyI5n2seTnMZGWW1py04isM4kGFRXvBc+gPyTp8IZ0EL\n", + "R5cd4Xcki2f5mqbx/Lx0Ft6Zh9ZEZAu5m7eVn3yhvBMPGKOnD7jcjkg98iymvXjOKYiPo/eMg3fF\n", + "yuesOUeP+Bv9R64f7/PfzluuS/NymgqFQioZAdrL+JiPiEySo5m3EYL2Qiub+0RFZZgXxvN7vTk8\n", + "6kS9LByYd837gjL1PBoPsUVF6VClh/5iHz3c5de9pD2Lwhl/ZmYm1X+Ji9H74QvaG4ImCo4ovKLh\n", + "yt8xXMq9LK7LaBgNKRcAvqsGgXd8fJxykrwPeVuVoRswLcnePhfQLxrP0ZCHhtI09MGzyuVpzR/p\n", + "XLmxUH1buYeX83InPNRBKIZ8H86oQxF7Um0Mx7oQw3De3d3V8vKy5ubmUs6Sh0ViCLZQKKRjYhCc\n", + "GOCEBfr9fjKgyGfqdrva2dnRcDhUt9tVu91OFdEHg0FGIEtKdaSq1apu3Liht956S++++6663a4+\n", + "+OCDNBe/+7u/m+hNjRtoTV6UG48+9kajoXa7rW63q+vXrydDo9VqaTI5r8x+7do1NRqNFE4iVLSx\n", + "saF2u62zs7M0RsJwGCrk4EjTXXDkt1Wr1Qy/nZycaH19XZ1OJ9WEct6gDpjLDK8eDq9ieKEA4VUP\n", + "73h18Gi0HBwcpPAeBwjDQ7VaLSlMjDCMTww5Qm++K3MwGKTSD5PJRPv7+9ra2krhaY6iwSnyDSMo\n", + "KF93zivufPm698R/1pobC8hiD81JyhgnGL+eM+gyNG+9IpuibMOBzHNm+U7si38HI86dF5+bPBmH\n", + "/I+Gp5Q9DsodTO8jz3TZ5/LOaU5/XIchAwgzuoHiuoA+Rb3ndKNFh93H5M+hb8PhMHNMF9+LBhXP\n", + "i8ZfNMCgqYfMXaZ6eJMxuKGa116IIcXCcYZmwl3x5RlNlz0rzwDLQwz8f97B4nHvjwnweiVSdicB\n", + "fY3GGoT3Fo3GaCzEBFC+S2yYvvg1mD3G+Z0u0JUfZz6PCUevEPrljSV6UZ4/xf9R6UNfvuu5EG6w\n", + "8l0/c8nRPV/4Lizz6O3NFwbNhQ3KjIKYfM4p99K0TIHv4PFFSt9Go+mBsp4AC+JCfhHe/a1bt1St\n", + "VtP/PkZ/ni98+gfNdnd3tbi4mIRrr9dLAjFv+zD5McPhMON50zyHBcTm5OREvV5Pg8EgGfa8n2NQ\n", + "QCZmZ2fT+XW9Xk+7u7va3d3VO++8o69//etJAf/sZz/T+vq6ms1myvXy8/QajYb29/eT0QLK02g0\n", + "1Gg0MsebzMzMpOdKSjWbTk9Ptb6+nnK2QBzhH/f6QbLckIwHLC8uLqZEbwzpo6Mjrays6PPPP9f+\n", + "/r7G43EyzvDIQb9w0uClSqWiTqejk5OTlCMHT/nxJ2dnZ5mjXsi7QslCm263q0qloqWlJQ0GA43H\n", + "43RftVpVv99Psuv27dvp/na7rVu3bqUcqclkkkE52RVZKBS0sLCQ8uLo69nZWeZ4p+goueyK69Ud\n", + "zagXaKenp4nelL2gxXIK8H1EtZAD7uS5HGAMHnHgmTH6gHInh4bPHZHy8UQUzJ04v4f74jvdaHeU\n", + "nmuelI7ecBnPNf73HDeeyz2+s4659PpcHiXxvvF3RIgYX5TD5fK0Ph5zLCmdFdnr9XR0dJThq3K5\n", + "nDn4PebpOu1wJPk8LyGfZ/qZgP48jyxd1l54QU5XRLHD0RCKVn7ec3wSY2jPmxtWIAwIG0dA3GCg\n", + "uVJyJc67Y7jJ3+fM5EzMJMbdML5DAi/UPSAWKko2IjKXIXL+WTRE8CJ4v9M30t7H4EnoGIbc77tB\n", + "CoVCStiVsmfGcTCvJ3g7miVlC62x6NmdRPOQLf/TfGHxf9wCTL88JEphRTd0HBWAlnNzc6pWq7k7\n", + "gkCjVlZW0m44BBhKcTgcZubYlYDzcqfTyQjU58+fJ/QM2hBm8uZnUFH6gO9Qe0qahlxdmZCYPplM\n", + "tLW1lc5a29vbyyjVQmFaXHJtbU3r6+v6/PPP1ev19M477+i9995LY/joo4/0+uuva319PbPz7tat\n", + "W4nH2GVHTSsgen6q1WqmmjjoCYVHZ2dnk0G4vLyc6metra2lZ9AODg6S4u/1eokX6/V6GhPolBsN\n", + "jx8/VqfTSYg28gQeps6To06gJZPJ5EJtKuiIMejXUD6TySQV9GRdLC8vq1qtprAeuxelqYIaj8eJ\n", + "V6DL4uKiSqVSQis9SZnDqOFJisYiJ1izzj+OADhq4vLGx+jKj4bB4uuB3474ufJz58vXOPd54nKU\n", + "fW7E+qafKOejPCHsGGU7Y4qVy2PDOOE6eiAqf8bgqQk+bu+r6yEHCfh7OBxmdG4EMByRw/Fyg42G\n", + "ER3RLZ4BAkoo3YujuhM/Go0yjgmHbiMTfC4uAyy8FAwFhGNqBjrTZT3Og28K8qjG/0lEKioh6eKO\n", + "vTwDIFrs8XtReUYUKvbBITtnKPcY+a4r6Rg6dI8xD53y/x069cbkgWK4IYXgjQuL+1wRRzpGQ86f\n", + "63TLW1AufBwh4zs+bj5DaeWF9tglBs0Zhx9jUSwWNRgMEvrjyB8C67LcABeQ9Mtj9pE2eB+E86Sp\n", + "Uef5OI6UORSN8PP5K5VKqbhiXHiEJ/CSab1eLx0Ey04zlLCjt3hhLqyOj48TD5ydnSWlyMGxfM/7\n", + "ipD2XWhueJ+cnKSjZUBnaDMzM/rkk0/08ccfq91up/ltNptaWVlJBwR3u13t7u5KUipU+fLLL6tQ\n", + "KOi73/2uvva1r0mS3n77bf34xz/O5M8xBs/LefLkiVZWVpJBACJWqVTS4byLi4uZStuHh4epLldE\n", + "OqgGHnM2MIjn5uZSuNLzi1Bi9Xpdh4eHicbj8VhHR0eqVquJDhiE5AdijOzt7WVyvQhZYcDAN5VK\n", + "JYUoaV7eASQjOhGEZlutljY2NjQ3N5eKo8JHlUolGVv0BZStVColQ5F1we5Q1ujW1lYy4JgrR2Th\n", + "L+aC9XuZIQEPe9X734YoeJjPQ3fcVywW09qgf1L2yBKfU2kq0+C5mP6BDIGP3Mnk+b9Nf+UZPN4c\n", + "wY7ymXEyFpe/7sBznSgL44sABQ6f6ygv4hlRGZ7jMuiyCI8jWh7xkZQxbAgjM1cuF3mO53rmyWHu\n", + "h0as30JhehwN8oSadfQXR5LnnJ6eamFhQcViMcOHkRZ57YUhUlJ2e6kjNlI+9HvZ/x7LdCMEBssz\n", + "plxxwFS80xPOohGH8OVaREriePIQNg+5eYNB/HMWz2WIHEzkXkikny90f5eUzZ9y2lzGOL/Nq4qG\n", + "iqTkwWNYuEfkW7lRNggSlLd7K3nGCc+OxpmP0ekkTQtXYvR55XA8E2jgiA/3AS37O1C4hAJdUDnt\n", + "4MlWq5XGuLKyorW1NXW73XRkB7TEyKMf5JHRH/rEewhDgSwQKot1bwhpoeTceAZRYS5JKB6Px3r0\n", + "6JEePXqk1dVVvfPOO+mZGF+DwSAJS0J70vmxJT/60Y90+/Zt3bp1S//5n/8pSfr617+uW7duqdVq\n", + "aTQ6TxynL9TNarVaSfG7x8r5dZw/eHh4mMJpHJ3C2LwcATWYSqVpFXFQJzxnjFQ3vqrVqqrVqkql\n", + "kvb29iQpjRGkgxy6crmcQolSNjG20WgkgY6QL5fLKemeNeDH1BDm8/XN9v88VF6S7t69q1KppKdP\n", + "n6Zx0n8PbRLGrdfrajabqWJ8THyHN7rdrj766CNtb28n3vDk7rhJhfe5Yo/IOTSYn5/PGKfQlnn0\n", + "8wvpG0fe+FzxTi806++Dbi7PovyMCdXRAXaHBqM2bsN3Zw59EeV4RG/ynu/6CXkdoy8xlOp08Ocy\n", + "P25EQn+nNXSg8VnUGc7bbigxNz7XbpxLU+c30gT0i/C56yScAfrAdfrGuNA1rMNqtarhcJjOksT5\n", + "4X0e1o3AQp7u9XZV/uCqXbWrdtWu2lW7alftf9leaGgvxsOxTGNYioZlmBcuk3QBXuX6ZSiKow6e\n", + "yItHGa11aZpwnLc7w3dm0A+3onkm34khNA/rQReS/AjNxHi3NPXOYsIl93uOgickYrF7aMPv9/F7\n", + "WMjzFfx7oB6Mzz0sL3LJM+KuGI7RIL4tKW0/d8g5eoqEqEBhoI3nUPl8eg4KeVuOnPnWX0/mhWY+\n", + "B5E/Yq6df+4e29zcXPKUlpaWtLS0lLbF+8G+HrpkDhw98d03Hgahyvh4PE4Jm3yX890Ijzl0DX3J\n", + "83Ke+eEPf6jHjx9rc3NT9+/f13g8TqharVbTvXv3NB6Ptb29rQ8//DAViGw0Grp586YODw/161//\n", + "Wp1OR6+//rqk8519GxsbOjw8VLfbVbPZ1N27dyWdo1i9Xi+Ny+F2UEOOueEoHBALwqP9fj/xFfNP\n", + "Aje5dRzNAo3L5bIGg4G63a7m5uZ08+ZNSeeIzWg0SiECCpTS13K5nBK8fU15Mj+8xPomz4jQ7tHR\n", + "USZ3rlKppBBj3GzgoSA/mqNSqWh1dVXHx8c6PDzMhGZBNiaTSSoNQa4UoT7CIn5eoKMGBwcHevbs\n", + "WQZ54JxDD+nAUxQP5Xnxe47Qe0jQkVb+j6gL93jyM5EJ1qnv+IKXyOmKyc+g1NDfdYK3y1D5PJkY\n", + "9VhMGne9wXOZ7zw94zoNGefj9wOkY46rz2NMRaGhZxw5Qg64TPMTeIfZAAAgAElEQVQUiUKhkNn4\n", + "wXPJDeNdcTccz/Z0DX5Dk5mZmUyJEs+Roq8+DsYdU2FYn41GQwcHB5mdxsgEohuMA3qTunFZeyGG\n", + "FMrpMqOD/z38xvUYMosQZzQAYj6T3wdjeE6P95GJcKPHq0DHfvLMvFCfK3ZPTqTPl+UnMR5PRI2L\n", + "zePgzuRudPhhm/78crmcyTuBVozDv8dvTxr3PhMKYes4Y3aa+o8rG3YkUaPJc0HcQPSQKELZ87Hc\n", + "cKFPvguHZ7oBzmL1a7QoZKELMLXTF8FLnonPh4doKYWAUV6pVNJxHhhTHlpzge+hamBtpy3t6OhI\n", + "tVpNMzMz6cw4F3RUDC+Xy5mzuNhtt7KykujKmXGtVksvv/xyygH65JNPUj//+q//Wt/85jc1mUz0\n", + "7W9/Wz/72c/S+7a2trSxsaHr169rdnZWn376aXrf6uqqms2marVaypnAEF1YWEjG7vHxsRYXF1MY\n", + "ajAYqNPppHDY8+fPUyiAeTs5OVG1WtXCwoKePHmSqpC7oGXnWwwZd7tdNRoN3blzJ/EpBomH3uAp\n", + "cutI0vZdqXNzc+mYGkK3zl9UT2fsbiwQNiL07ZtAMIow0n2LOs5Ds9nMhDAItUwmE62urqaDpKEp\n", + "/YG/WWvwt6Rk9B4dHaXnDgaD5MwQBvPQPXK2UqmoXq9nTifAWYoymudgXGHgMYe+/d/5P4bnvOQB\n", + "OoS16u9zY47m8pK1F0M9Hg5i3vLe50Yj11y+eGM80RBivA4OxGcQBsbZyDNIXZZAN095iLlVPge8\n", + "z/O5XPZQwZ5rrudxeumnb0iIvzGS3NihLxFEcAfa6/ThFDLuYrGYSs8cHR2lXansRqY/MfE/LyTr\n", + "7YWVP5CmsWU+c2MoWuBuIPl33cJ2tOeyez0eDaFhnFj+wBcgzyQJ0S3heK6Rx8TdMCKZj8mPcWhf\n", + "tO4JOnLkAt8RIJ7jaBFjcis7Wu4umJyJIxoXc6rcKHNDB6HIFnNPOK1UKpn6Hb6gyI8gNyXW0eIZ\n", + "9IexkBzoBp40PYeLz/0QW77vgtvH54LGBS3KiyRs956ZGwS078LkXkfEXCnym+e6kVmpVDJCGCEq\n", + "TTdFYJi5cVgul7W9vZ05FobGdmKEjOcPNRoNXb9+PR0KPBwO9cUXX0ialkTo9/s6OjpSp9NJ1+7d\n", + "u6evfe1r+uyzz/Rf//VfevDgQSYBFPRnc3NTZ2dn6Yy6L774QpubmwkB4+gVaXq4cKfTUbVa1eHh\n", + "YernwsKCer1eMmYWFha0vLycFDv8B/38oGTnW+bX+ypJL730ktbX17W7u5sM3mLxPHEVXn769Gmi\n", + "69raWkIbG41GJgF8PB6r1WppZmZGzWYzs2YpU0GJh9FoenSS57dAQ+dv1kChUMjk0LCearWaBoOB\n", + "FhYWUu7c4eFhQhpJuPdSIyA4c3NzCZVi7unHRx99pF//+tfJGJfOdwqWy2W1Wq0L5T0iCu3rwvO/\n", + "kN+OxtMvvutyEdnA+o1OKHI9yjzkjxtqPB/+QH66QeDvdkXrxmNMRI9Ik6N4bpAgV6MT50rckRzf\n", + "wYlOcfni80g0g/FHnRbpTT5qdL64lmdw4pgwFjfc3RjyvkAXdKkbVjEq5QBFdCjcWIJezCEODs8g\n", + "lxEnAzS20+loMBio3W4nECCijpcZvdILMqQQbl4dGqXmFnQ0iPw3zY2qy8J3Pil5VqUbINLUyMqD\n", + "Q52JokdAX9x7YUF5COUyWNhDV+4J8ByMg7goHLXxcTBmxuf9QcAgkECSpIuwebT46SOM70JiPB6n\n", + "itNUUJay9bAYX0wM59BdR8mkqeERz4byMGM81JR+etjTFx8L2o0f5oDfEYJGgLK7LhpZ0FVSQpbc\n", + "S2auKpVKpj6V0xtjMHrJrJXRaJRJoHXUz2FsSaleEPzoyCOKhERdlB51jIDSt7a2MrA6zxiPx2q3\n", + "2/r4448lSf/wD/+g999/X9vb2zo8PLwAxX/yySfa3t7WX/3VX+nOnTsp7Lezs5MMZ3amgqy4MUsi\n", + "/r179yRNE0cRsLVaLe06o62traWk8MXFxTSPviOS/32HIyjZw4cPNRwOExK1vb2dDKnBYJCSsuE/\n", + "aludnJxobW3tgsFPmNWVQqVS0XA4zChGxo+xzvNdLrC5wQ0FD+d7EV+MJp7dbreTMePoAcU74Tl3\n", + "YpCjn3/+uZ48eaLZ2Vldv35dd+7ckTQ9KJn3sUNXUtrMwRp1p4KxoUzdWMI4gM99rKyZPAeTPvj9\n", + "0fHOQ3s8zCZdlKWuk1wnuEEQ54JrbuRFHYSh5P30Z0QjC3q5LnFjxdd1XuiL70cnAoTb6Ro3C3na\n", + "RtRjbvC50wK6Sd9iaR2fozz9nocGuc73uYevmV93LpGrDqLQz8XFRZ2dnWlvby85kI6AeXQpr70Q\n", + "QworGQUhZb3DSNQ8WNIVTbRw/buOcknTxQETQtTotdBQwu5d5oWrGENcsL7wfBE5IzIekB9nHGcY\n", + "qj5HONQ9qZjP44apI1NUTHakxoWU09f74yGFuPBR9qAEvssKo8qVZJxff5eHEjGGIqrGIuH7cUGB\n", + "HlLMLQpI6O4GJgsQNAuEjO9HWrkwdto42sd15/E4RvjBjQefY//tUHepVEo09R0yGKSE7bygHcq7\n", + "0WioUqmo2WxmtrljdJ+dnen58+cJIVpfX9f9+/f19OlTPXjwQF988UVCqbrdrr773e9mlCdCqtfr\n", + "aX19XX/yJ3+ibrer5eVl3b9/X9J5uHB7ezsTDnNjYX5+XoPBQKenp1pdXU3ywncyIRN6vV4y9Kgb\n", + "hWEKX0rnQhM0HBkEbywuLmp1dVUffvihtra2tLe3l4wxPHz3bL2AYK/X0/b2tubn53Xt2jXdvn1b\n", + "klKxVZDGWq2WUSz0BYONNcOBxI4MOArhvO/PPDs7SzV0vCSH8zwGOAcsQzPCUp6GQD/ho8XFRb31\n", + "1lsqFosp7Ht4eJhqXVFSwQ0RR4fc+I9r3sfqDnUeCkLzQ5kZY8xDik65p1e4PPdr0RH250MTb76m\n", + "aY42RV2U56y7Lotz7LqFZxP6d0cRmmBQudz3vkJj+kzJC0nJUXCZS6Qhponk6U9kH+MnxcKjHXnp\n", + "ON6vmEfnY/P38CNNkTGMwIjSQ2MPl/uzrl27poWFBbVarVRKBRpFw9rbCwvtIQTpHLA4CEqeZR5D\n", + "TnzGdy6D3pyJnInzlC/XWHwwsDOvCwKfKDxNlJ0vYO7xYmSeK+EG1mUT5go3b4x+rxsXLogiIsU9\n", + "k8kko6QQYpFGLtjwIFGAIFInJycJteFeknqHw2E6Sd5hW0e3HCEhbIWX7bzB3EAT7qFRP+gyHuCd\n", + "k8k0eRyli6HpwtJp6CFO5wueQf/8fkcb3SCiinS/38945v5OTwz1CuhOtyjs+RkOh6rX68kgWF9f\n", + "19LSkubm5rS8vKzV1dX0TN5Nrlqr1UrXqIL9+PFjHR8fq1arZbbv00/6Tu2ir33ta/rnf/5nXb9+\n", + "Xd/61rf0wx/+MOUr7e3taXt7W2tra6rVahnDnjPkMIYoh0A/q9Vq5oy9vb29JPxWVlbU7/e1vr6e\n", + "BCcGg8P/rAPmaW1tTVtbW/rkk0+0tbWlk5OTBP8fHx9rf38/vcP5u9lspurr7XY7U3/r7t27mpmZ\n", + "Ub1e19zcXKb6er/fTwavo42SEj0KhUIyqHi3r+3Z2fMzAb1ulTRF/t2Bm0wmqlQqiWcoc8A1UM9S\n", + "6bxWlssitq5vbGyo1+vp0aNHevjwoSSliu2lUikpYS8O62vC1wUKDKXNPHMfSiwiNr5+ovHiKLEr\n", + "Y5rL8+g054X3aK47ohGV1w8pq1Ni//yZ7tzRMHrduPNnIJ9cDvh7MaJ8vNzrBpwbGsgRZDL85jly\n", + "3i9ohV5wB8XfxbWYfM+8eppFpE0e3fjfIz00dBkbHBxVjYac1wpkLeGY8pvNJXnzm/py6ZWrdtWu\n", + "2lW7alftql21q/Zb2wtBpGIYRTr3EoHwpWyYzi3ePGuY7/O9COu6BexQpSMMjryAfLi34Ie6ekJk\n", + "DHvRp+gh+PvjAYz+DPrnniDjImnav4MlHT2bGELKg7h5LiiEJ56DAGHNx/FyL3A/38HjYOs176PE\n", + "AIm0bFmHbtwbkzNp9IW8J/rioTkPJ0lKOQI8O26rZl79fXg5EeHxuQHBil6mh1N9bqWpxzM3N5fQ\n", + "SMJpq6uraVwk3Tp/gyzxOeE0kCLfbekhI77f6/VUr9fTdn3QJGjFOXHQrNPpJN4i1wKeAtUajUYp\n", + "X8jnIo+XqdYuSd/4xjf0y1/+Ml0DceQ+RxUJNbAb1HOZOJvPER08UNqtW7cyyKgjJLybfuB9DgYD\n", + "PXjwQHt7e+n577//vqTzbf/j8TiFNwqFQipI+ejRI62srKQDmmdnZxOtoNft27fTGLwEByUH5ubm\n", + "Moc2exXpwWCQCZl4jhDoIfME2g/qRC6gNEVx4fFGo5HhH/hyfn7+QkHRfr+v58+f69GjRyn06QUN\n", + "QZ3Zru6IqyO5jojQN5DgvDwZR2Sct8bjcUJdPKzGu5ALLhNiuDFuTuJ95MS4fnG94iiP6zPChY7y\n", + "ECL1SEecQ5c7NO5hw4HrLniDNY8c87Expx7qBIl1FNuTzPPSHqTz0DU5qjEq5KkXrGNPGifKwPOj\n", + "XM3Tz9I0r5aiyR7S4zehYPrNOgDh96OaYi6xj4WixZ5o7ykdHvbMay+ssjlE9wUuKR1NEaE6Wh7T\n", + "+zOjoRCNMY/d+gKI7+NZTFaEuJnkmAjnCXdepZi+8jyH9z0/wPN+fFw8mzwG+uGhIs87wvCAKaBp\n", + "jEU77X0MMHDMEXADggXt4QgXFJyTJCmFH+iPjwNY340dF1okqca5QKD5dQ8lukHk4QVXpIzf+YT3\n", + "RLjZ89ycd7jP5zEaYhHCdv7D6OHvvIZwZ2cfY4SWsb4ZCobkXg6klc75qdVqpcOSS6VS2gZ869Yt\n", + "zc/Pa29vL13rdDpprJzfxgGyvrXYeX00GiVF/OMf/1i/+tWv9NWvflXvvPOO7t27p0ePHiUekabJ\n", + "np7PUSyeJ0k/f/48JTcj3I6OjlLdKencAKrVaommCwsLqcYU+W5u2LlQ9TDUb37zGx0cHKhUKunj\n", + "jz/WBx98kIysV155ReVyOdHl5OREL7/8sqRz+H9vb0+dTkfb29va/H9rbdHXR48e6fT0VNevX8+c\n", + "N4bh7IYBfMORMfCTH6jteV3UrfJEe2QT8+LhDPKgeJevXwwPwu+04XCojz76SA8ePNDu7m46UxDD\n", + "ldINVHf3texhcH77eoOPvNwD19yAiakL7iT6Mz30XigUMgc/j8djdTqdjKK/zMjEmXCa+t9OH2Rm\n", + "dKaQ2R7ii4aIO/yuh/xeNz793Dv64sayPwPZFx1Txh7HwD1OX0kpzNdoNC4Yux5mhA7uQPIdZBH9\n", + "9ntiaNNDdhhwOOzoi4WFhcRzHr7zvlHeRDrP/8TIQl94TnHcUAVtvL7fZe2FIVIQz2PVoEJ+sCbX\n", + "sHLzkCiEUF7CmjOpeyckf/oCdwHuk4G3KCnFXrGCowfucVs/qd29n3K5rHq9njEanNHjDgHGHhOP\n", + "/dnRO0JY461FoQADe66FX3N6oZSd3ixCf6YbC3hnMN/x8bG63e4F71SaJukTQ8+L2/vYnE5x518U\n", + "ir67xQWy13rxFvnMkzw5kDVu3aZdlr/mz/YaJ7Tj4+N0JhzfcXTT+cHfwaGjlA4ALZHODQm8Y/7G\n", + "WFpaWkrjQgixqwtEolqt6vj4WM1mMxk9JHNjsMzPz2dydpg/R6do3/nOd5Ln7GjkYDBISeHUfPKD\n", + "h9kZRzI18wLyMTMzo4ODg4zBDW1wJFqtViqTAQ0lpdyc5eXllFD/ySefqFQq6YMPPtDW1pZ+53d+\n", + "JxmprVZLtVpNrVYrGU0Yi3fv3tWtW7dUKpX05MkT/epXv0oG7+///u+nk+wPDg5Uq9USqsjcgrrF\n", + "/BKvSZbnXIGq4ZkzF752XUZ5DguKxJF4EE8SdWnPnj3T+++/r52dHXU6HVUqlQwC6geQ+1rmnf7b\n", + "/3Y0HIPAnUFvLjOglTs70aElP4j3MOeTyUTdblf9fv+Cs+vJ3t4cwYnr1xEndILLLzf2XI77zjZ+\n", + "oqHoxlV0zBijb/GnId/i55PJJIPEuoFGf6GpG0yg0/BpnpxDx4HqMA84C1HP+j3+Hh8jMr5cnu4c\n", + "9/NQ0XMur73vp6enSUaNx+OUG+rGMu8tlUqpbInLeZ+zy9oL3bXnDMdEoWQxpqRpnR3PuvcWEwlp\n", + "DpdicSI0CAPBOJcRih0o3IfgcYXoC9+VtBsEpdL57iqu+YGaLEL3XC5D3mIisu/gi54C48vbzgvt\n", + "YWIXWg5rw2ARwcLjdIMXeh0dHWXqKkE3qh+XSiW12+0kfKXpAbwxJIrR5mEBNyiZW0cQI72id+ke\n", + "eKR3Xo0veMoVU0yadQWIUnAlRf9coNBAE/CwIq25ZzQ6rzHkByyDUMVdRihqR2I9pLy8vJwEVL1e\n", + "z2y5J4zW7/d1+/Zt/eQnP5EkffbZZ3r77be1sbGhg4MD1ev1lGwOneEdRyRefvll/eu//qt+8Ytf\n", + "aG1tTWdnZ9rf309zgeCl7pivmcFgkNBFDFnoMjc3l6rAU16Ae09PT5NxiTfruxuhO8YZu89KpZLe\n", + "f/99/fznP9d7772nhYUF3bhxQ9J50vzMzIz+5V/+RR9//LGePn2q3/zmN5Kkhw8f6t1339X6+rru\n", + "3LmjV155Rf/zP/8jSfr5z3+uP/qjP0qCOu5Q9Lnz9e3hFb7POoXnMX4iz7MuCZU6MsAP6zvyqMtl\n", + "5vfBgwd6/vx5CqXWajUVCoXMRpN+v5/ORCwWi6l2FQY4KCbvYoyOFGOUSNOyCcw5JUcYI84qitWN\n", + "A75TLpfVaDQya351dVX1el39fj9zigLoBXTx8J3Txku50G8+Zx7c2XKjwneKeXg3hq0YXzQQ4QGc\n", + "JJ7tzpbLGZqjfN5iArsjatHoOTk5UbfbTQgNvMVvZJTfE/vhOgq9R+kPd5Sgqzu8DoK4rPPGHDnC\n", + "76Hr09NTNZvNJAuc3ugexu0OVwydxvbCdu05AiVllQLXvRAewsZDPvzO+0y6WGsCL1qahr48NMH3\n", + "Hd1BIbjXRtjL86akbKVXR0P4DMFXqVQy9ztyEE/kjjuySqVp7YsINTqS4SEm6BENO98h5iG7PEHi\n", + "hgVGm4cJ6Cuxe+8n9+EdcA0GR7HAyDHEF3Mr3HBzr8EXqUPTLI5ocLv36MYp70XZRGMLgcii5T6n\n", + "l3+fvyOs75464QcMhHgf4/bDWd2QZY0QhuNoFOZydnY2ha8kJQPliy++0K1btxKywhw2m00Nh0O9\n", + "9NJL6b6nT5/q/v37ajQaunHjRiasu7OzkxwM5pJnbmxsaHNzU5ubm2q32/rss89SHSlCZeQgDIfD\n", + "dEQK9OI3/XLazczMaGVlRd1uV8fHxwkFZrfe2dmZlpeXMwUrWRPkUOzu7qb+7O7u6ic/+Ylefvll\n", + "lctlHRwc6G//9m8lSffv39dnn32mTz/9VI8fP86EZD///HNJ0le+8hVtbm6qUCjoq1/9qiTpgw8+\n", + "0MOHD/X2229rfn5eS0tLF5xEZJ3PPeMDBfDDtTGMcfScLwj9ECZF/knnSJ2HbvydHimAr0Hqut2u\n", + "ZmdnVa1WE6rIu7gX2Ug4zeuWeb4WcyBNHUBkgpdeoY84HnHdsw5xin1nYAz9uQFKIVHCieyuJJRK\n", + "OYFYVsEjGB5tYP3RJ1fCjizjgPnuaF/bLqOcBp5H5n2JqJLrL4/CuA5ANzny7yFYL9/ihvh4PE5A\n", + "APPr749OkOtQ5j2GHuN8Rn3J54wlpn3grLtByfy4AQzPtVqtBJwUi8WEqtKQlS7XvX/RCPX2Qgwp\n", + "GI7fkpJlSjjKjQK207pXGhebM08MFzqC4JPpC8Ohcb4vXTw13EMYQH4OHzsjucVM3+i75zu4V8Di\n", + "d0YE8kaZ+PcjeuNWNJ4aRmgst+BGhi9MDJIYuqM/0Jjxe4iO552enqper18IQRwfHydUB0OQd7li\n", + "9sXtc+lz76HSaDT6onQjUFJKXHTj1BUUhlwU3tAGOju9oXOEgZ3fvN8+Ni+sGIXGZDJJStKNVGiK\n", + "AUJoDCRqOBxqMBgkVMYRuWKxqKOjo1Tn65e//KWePXsm6bzEAfkxc3NzajQa+ou/+AtJ0re//W1t\n", + "bW3pS1/6khqNhmq1mjY3NxNNd3Z2dHZ2pnq9rnq9nkoc3L9/X/fu3VOn09HTp0/V6/US3L60tKRr\n", + "164lujv6OxqNVKvVEm+4MmEeQDmWl5cznigKazgcanFx8QKSDTpULBa1tbWV5uxHP/qRlpaWdP/+\n", + "fe3u7urTTz/Vt771rTSODz/8UL/4xS/07NkzFYvTQpeDwUA///nP1Wg0VCyeh+ReeuklSdK9e/f0\n", + "61//Wq+88ko6XsdzOlhPzH9EQz3M7kfkgA6VSqULqRDlcjnV7skLpzgdWIcoUt7p9zWbTRUKBT19\n", + "+lTb29uJ/xk/RgnozmQySX+jzHy9xPXhoRiUImhVXiK6RxSQAdDUNwNEFNuPTWFzB/dVq1X1+/2k\n", + "b7woI/IcerthjhFBGDY6Zr6BypU0PI+jAxrMMx0Zd32CIYAcI5KBzAAphF5Rz3K/yz/nRQ8pusxE\n", + "X7KO4pEthP7iGvZ5j/wd5SjONXLO+d83Q9Fvfpw28EOkG7UM2+126qPraNflUa/6JpC8dlX+4Kpd\n", + "tat21a7aVbtqV+1/2V4IIuWQs1d/9nCbw9g0UI3o9Tv8L13MJ+KZviPIUSrPF5KyOwccAaHF/BgP\n", + "J+FF4Gl4c+TGUSU8Ct+Z5mPhWt72T/di3RJ3Sz8vEZ93eOl/9xa57igJNPWwnoc3vG+S0sGZ0NIt\n", + "+5jkyfwyx44A4vlERAqP0hNy3fNx+sR58FCuezRxnvLi+/CLe3ru/TmdHBVzT5/vcM0RRK/Czvc8\n", + "1OD8xvyCzDAOjioBWYq5JtJ5AvH6+romk0kKb2xtbaXdcXjvX/7ylyWdH0z8T//0Tzo5OdFrr72m\n", + "V199NSFZjUZD165dS5WvFxYWtL6+Luk8Efv4+FhPnjzRs2fP0lEi0jlac+/evcwuGkcyCEWBfsQd\n", + "i51OJ61tEuThPRLX+/2+6vV6Ji8JBGN7e1snJycp1+lXv/qV/viP/1gzM+fHpxwcHOj73/9+4gvy\n", + "M8gTefz4saTz5P5ms6nHjx/r9u3bmp2dTXlXN27cUKvV0uHhoTY3N3V4eJiQHPg77mBlPfDseGYi\n", + "oT5HK10mgu6BbHhI38PxyIDI3/AqIaz5+Xk9evQo5eiVy2UtLy8nmvouPg//QG8PpUfe95BgRMsc\n", + "aSKEJGWPlfFoBvcREuJvD4c7CgiaBL3n5+cTUutFVRkLGxg8dQGEKk8OcT3mPfpcez6lh/24j+9E\n", + "BAnUDRkIj4COsf49GsH3Pf0ElJOwPvrA0z3Qoeg3T1iP8+zz63nEHvWIcxzTQTwqQ19i2BCkymU8\n", + "vO5IHrLUUcR+v69isZhJaXA6Oy8yv//nyh9gMBUK091w3nFCETHmy9EjfkafQ5F5hhSMErfHe95N\n", + "vIahRp9cCXk4iZBZzB/yyfSdK/Gdnn9EvN+ZTsqe+8e27XgfeRRugNDvaHjm5R9Eg5V4MCFMh4H5\n", + "HAZ1hR93wnlyM+fLkQOWR1P+R6B5X3x+aZ7LFYVVNDDdaIcmUbj7vd588btAQHAyBr93NBplFq40\n", + "FaCRb8jJKBTOD9eNMXrmAJ7zZGlyF2IomvpP8I7vpIH/hsOhDg8Pde/evZQLMxwO1W63tby8nLa0\n", + "M4b33ntPZ2dn+vd//3d99NFHeuWVVzIlFZaWlpLBs7Kykvr57Nkz7e/v6/Hjx3ry5In6/b7eeuut\n", + "9MylpaUUhpKm8L6HMqPxSSkNkvNRHnwPZUHYC2HoczUajbS7u6ter6f/+I//SOMYDAZaXFxMPMp9\n", + "MVS2v7+vd999V5L093//9+p2u/rLv/zLlEtG3lO/31ej0dDDhw/10ksvZUoLHBwcpBCtK3v4pVQq\n", + "pVIHHtZtNBrpvEFCQjEHxY/icp5GWZFAy/ji8U3+vrm5OdXr9ZTPhiJyxYTRxkYhngv9Wa9x3dDH\n", + "qIRZYzzHQ0bu0Hi4SlKmz9CQZ2I4eWI79CZv1WVv3LnlxqafBoCBhbzyNAnvL84BdOEaITMvbRNz\n", + "lLgG/VyfeIoFaSOlUinVLHPni+YOKc8tFqfnevq6Y7zu8PC+4+PjdPg2a5Fxs1EEg8flmstn3uU6\n", + "3zf+uHMJ38VcP7/mNPV15Ruwjo+P01xwYHiU/d7XqCe9vRBDiol2hMgXE9Yh3hCM6YrbGc7jtj4Z\n", + "fO5x2ohIEWuPgojFhzESvQGu8bc0tb6Pjo4y3oSkTN/jgpemQjNa1M4o7G5wA4Ux+f3+uQs70Atv\n", + "LhgQGp6T4P3nN4gagjYib57jwPtWVlYyuzUdiYzootMIpU8phWjUFAqFzELNi2NftghiYdTYZ3jO\n", + "G/wAvZwH3PvyhF/64M/wnTrulcUcQBfMeKmeiAmCM5lMMsUsOR4nb9wuXCaTiXZ2dlIS98HBgQ4P\n", + "D9MhwZVKRTdv3kz9/tM//VPdunVL3/ve9/Sb3/wm9XN+fl6VSiUVnPzss8+SkHry5In29/d1cnKi\n", + "27dv691339VXvvKV1B/QlFarpeXl5QsKHTnAUTfSeY7QYDBIGzcoxeA7Qbvdrmq1WkrWdidqNBrp\n", + "4OBAJycn+sUvfpGOOnn99ddVqVTU7/cTyuJzgUGKwUUe1BtvvKHJZKIvf/nLevz4se7cuZM8fZQi\n", + "R8fcuHEjGYutVivxDgVOuc8RtF6vp2azmRK4WXfkwjgCTm0dFKLzP7vckE2+BqIB4M6ldL7Tk/wh\n", + "Cp0yHxsbG4mnQUYZB0izI0H+Hl/HGCTwKfweZaYbQO4w8kwpm4zs73MdQk4P/IbxC784wuyRCuaF\n", + "5lvyvbmBQ1QBWUCRSt8BTd+9vlF0yAqFaeFadCYOlXRuFKD7Ym4PRp/nULmMIwE75g9hJPouUd6H\n", + "7Op0OsmA5l6KDzO/oEvMJfLS88Gk6Q5NRxldB7sjGuntxtSHDXsAACAASURBVJk7EY4oxQ1bbhi7\n", + "0cr4fpuRJb1ARMo9CulixVk3INjaPBwOMwwmZRWYL0qu8TlM7tAh/18W2suz3uME+sJ0ryomoktT\n", + "gcq7HT1yS9qZGOHD7+i18ONGGPR0dMsNQ677ova+02Agfyd9wphwpnODiPGw2EjC9Z0qjkB6crfX\n", + "BXEvJm6P9fsvS6CELg7xEk6IgpdrLijj9mApm+gaF58bsD7H7oF7P/2dIK7+LgTfeDwtSMccelFX\n", + "N4Jpk8kkCaRCYbpV3UNGo9EoY4DcuXNHn376qdrttk5OTrS/v5/CG3fu3ElFJf/8z/9cT58+1dbW\n", + "lqRzo6XX66nf76dyDI1GQ5L05ptvSjpP1n7ttddSbSfpHMlYXV1Nhsv+/n5mmzNnyEFXFF0eAhnX\n", + "BmfNYVR6An+/39fBwYE6nY4ePXp0wRFjzbgh57skUQhUPaf90R/9kf7xH/9RxWIx0W0ymSQkR1LG\n", + "ADk5OdHe3l7iQUdquR8E6+xsWguMHYeOarrCdgXrCsnXILX0PHTmzkC73dbTp08Tz/iGB0cnpOkh\n", + "0SBkvqYIwzm6HCvi8/fMzEzmnE2cEeSzjxHHMk9ex52wXhEe2cU73bByB8/TN5hz5Gh0SB0dc6PH\n", + "E8BpjnK54xVlKWOIpWSYI+iKYQzdovHhOpF5B0XyNcOuV+q3uQHukSP6HY0Nkud9HN6Hy5LF+cwN\n", + "d482EMb2ufVdgG6sOhLlfeNadBRopJqA8rtDze//c4gUSiYS0hefMz+xZI/7xu2sLFAnqiv7aGU7\n", + "LMr3WNzsLMObyVPmjqA5oR25cc/fDUWHLaUs7Ivw9jFwD4vAFzdbi6OX5EYZ/fawIH3CSHMm9v7g\n", + "1frzPVxALgn3OXM3m810NAjC1xeI9xXYlXH6YnMB5kYIf/v4ozFHv3wREd93oRg9PubQaYYScuM0\n", + "hkn4wYhyzxEh7krTeQPkxPMBWAduYDqfQlfmw9cQ9IlGB8LTFQgGymQyScgH92P0/PKXv9TGxoaW\n", + "l5dTHtTdu3fT+Hu9no6Pj1PoAeFHXaHxeJzqPnldJL5br9e1uLiYMfjw4ieTiWq1WmbHkPPJaDTS\n", + "wsJCBlGoVCrpfz865vj4WP1+X8fHx+noFeaCMTSbTa2traVipDwTfigWz0OYBwcHkqTvf//7WllZ\n", + "0RdffKHV1dULKAo7KJFhoDWSUj2jer2uyWSS6i+BwJXL5zui9vf3M2jG+vp6urawsJBZe6QBsKsL\n", + "HoanWUuOdji/cw0Dm12RXvdrOBymOlPD4TCFSqJDRugZ5cy7oA18jbPgzi4/8LAr2slkklkbvr5x\n", + "HAhN815Hn0ajkSqVSlpPjs5hqHitp4hO0zzHh3v9OciEqLxdt0QDzA03xu10Jf2hXC6nuXc0n5Aw\n", + "/EZzhNyPQGGMR0dHmbUfHVIvT8Fv5oS5cLDBU0EwpqIsykMZoYcb3YzPneMo23m284kbdYwLmvJu\n", + "6O3z4EZtDCFe4IFLr/z/2BB6UlbxMwFucUtTaxGh64odr8qPJXBF5YiOv5fPHcXy0J6jHHzf+8tk\n", + "upXqaAMLzwUHiIUngvIsxl0qZWuUuBeHAeoGT7lcTudaRYQvGlPOcBhJQOmEOaXp6dmSMh4a4/Dw\n", + "q38H+o9Go5R87BWcCTe4MSZlK7tTediRHN7nc0Y/+U1/XNjkhXt5Jt+PixR6uWHngsLDCf5c984Z\n", + "kyspV3L8RslzJIlvn3ZepD+VSiUjFOfn5zN5BG7U48kiiNyoo7I4Qmxubi6hHw8ePNDrr7+e0KTl\n", + "5eWkLLe2tvT48WO1222tr69ncrNqtZpu376dnAnQCeaB5F3oSCixWCympN5qtaqDg4PE/zdv3kzX\n", + "YvXm/f19zc7OamlpKVVuh57MB+9nbhgHhhly5fr166k/ID7UrFpZWUkJ5V5uAJSJd/zZn/2Z5ufn\n", + "tbm5qddffz3jOC0tLenDDz9Mxmez2UzXZ2dntbGxkYx0H4PnQYE4gWRhmPua97p7jhxEBCbyyGUe\n", + "9/z8fOKDVquls7OzlPPS7/d1dnaW5pRilh6miUoxbrDhnRhtLtelafkDlKajV55aQCK0ywMMtOhc\n", + "R4TaDQP4pFAopDyvuA5dznj5FkdUXC64jKO5XGJu8kqycJ2+er0vngky6AYDxpmffZiH5HtaCDRl\n", + "Tuv1esYodjmSF0WCj+AP3zwRUXJaBBOcT+EXN7ScNvBxdISjHcFapbmj4O/jOfQJPe28mJc2kmh6\n", + "6ZWrdtWu2lW7alftql21q/Zb2wtBpNyLd4vXEQXgNGkK/wJnel4SrVAoJOjYw2uO4HhYiP95t4eH\n", + "gMTzPDXPrfFkRN7n/XcvgebhnejteB6No1LQBuSId/h2V+D2mMgHbfCmHHnxcKKPw61vwlTe/6Oj\n", + "o3S/h1l91wvHMNDHuG3Z4XYPzzE+35Lt0GqEjfGU3LuAhngdjN+PifD55FnQzcNh7s2BinmxPM/P\n", + "gC/wjguF6Y4ovChyCDz05Vv62YXm+VCMHTrAU3iOc3NzKcE3zj88QEjNx8q1+fn5FPqan5/X7u6u\n", + "bt++rZmZGbVarTTGlZUVraysaG9vL+UreliXM+SYM55ZLpfTLruYe3F0dJSQlGfPnqnRaKTk9u3t\n", + "bZ2dnalaraaChYSaqLxO+KJarWowGGR2RFE2oFarpZQASemok2LxPIcPpEg6r9B+eHio69eva25u\n", + "Trdv304oFaEsX3fuJd++fVs3b95MHi9zcXR0pPn5ed27d0/j8TjtCKQtLS2pVDo/ONqPEDk7O1Ov\n", + "11OpVFKz2cygOu5Be94SDbTcEU34AATHQ/SMwcPo5NCwThiTo1p+BA3PJeXAk8ZBl0B5PORNdfKI\n", + "EoCaOgpCA1FnPbLBh77Ck65H+Ix3kqzveWYRRfbjRRxB4TpzwTuRYS57I2ri9HYky/OgPAISc7I8\n", + "1IesdmSJ++hLDH3RJ89f4hp5WRy7xPh9HplLGvoZ/vTSNi4foJXrFubIdSp8RfFpaO85rdAgpi64\n", + "TvFxQxMPBTpPOQ+A9EJz+vt/rvwBE+KJfvGaNwSBJw56UqkzkCsan5woNFxBwhi+APlcysKRMSE9\n", + "LnCYwnOBeCafMR6vTcJCiBPMQuK6LypPjmRBusESBZkrVsbvRpw/18OeHj6g5o3npHneGefFoZyc\n", + "pv7jdIZOMfbNd+ATD8MyL4RQPabOPPBdFlpefgbN4+EeSvV++iJEEUUB52FLF4wuXD3kJE2VEbzr\n", + "ix+F5MLGt00TXoDWMVmdkADhb+hGWPD4+FitViuFYFGEz54908bGRjoYWVI6sLhWq6W54kiaSqWS\n", + "hO/KykoKu0nniehPnjxJQoqwGOPDIJqfn9err76awoyE7xYXFy+EIfjbDyeem5vLGFLwJvzhByWf\n", + "np4mo+wrX/lKSqr+zne+o1arpW63q6Ojo1TlnL4+evRI/X4/5QthgL3xxhtaXFxUpVLR+vq6Zmdn\n", + "df36dUnSp59+qo2NDX3pS19KBz5D04WFBbXbbR0fH6vRaGg4HCaaHh8fpwOm2Q3nBj+hynK5nMm5\n", + "cgXP77hLNtZr43PGxTwho1jTGHvNZlPz8/NprjCaJ5PznaeEqpgL6B3DzOTM4AS4HB4MBikP8DKd\n", + "wNx6GgX9Zjen0wKZyfrwJGaX3WwO4JnkmmG0ut7x/zE08px3fjM+FDbhMN+xiLyOubw01zGkS8DP\n", + "hOiga5xnjE8fL59jYLLBwx1ND6tiODNGjFNo6/XO3HiL4TF3FF1+uy6DFk5HPotpGy6r81JPPEXE\n", + "+cLpEw1T13mXtRdiSEnTE+89iRtC+g+NwWNoOMFhJI+3SvlZ9s6M/M+EONPExEGP0zrRPTcGYsMY\n", + "Mblbyu7mYwwoO09487G7co7GAnHpuPARSDCg7xiENhhIeUmSzvw8j8Y4o7c4mUzSoaW1Wi1T9yUa\n", + "sR5Hj0aWG9gYj84fbsyiMKNQiDHtyE9unHlzRYWAjgY1dIlJvDFvzlFB5x9H2XjeeDxOxgAFJn0e\n", + "HaUgb8XzFuhTXPyMIa4l6Ibhi9Lb399XtVpNO+bq9Xo6zoX6QeTr1Go1vfzyy5KmhlSj0UhePsKU\n", + "HX3wC8YNdGMHGqUE9vb20jPZIo6hj5HBuieZmBwdRzLxrD2Phnv5DgbA3/zN3yT6/tu//ZsWFha0\n", + "ubmpxcXF1C9ytXZ2dtTr9TIHGq+srGh5eVnNZjPVW6I213g81nvvvadicVpry8cPL0VnqFarpXUC\n", + "audGRql0fhB6vV5PO7ecTx1Big1j2vOHHEXnbD2nmaMcOIKuvCmNgIx2WUM+EgaTI9WOivsczs/P\n", + "azAYqNvtXuBvrh8dHaU8HHcEPRcGY0OanlHIs8ijYox+LmC5XL5gnFA6wOWwO3OsZX8mfWc9xh2L\n", + "jN2RWuYlOoHch1zMyyFinlgzLnujg+rXyJMdjUbJmHZn3J1830HNnDJmR0ahhecMR+fSc9NcxjrI\n", + "4u92PRk3AXj+a3T0Y3PdBZ3yDDmci8s2G0gvsLI5gtYFH2f1sBAcxpamXmhUkggbBCS/+dyNkDyh\n", + "4te5H2MNRvY+RIal0T9HnbwvhHMQntEgQsFFVCImC8YEcASJhxqkbH0VBI2PH0ECPf0au/W8j4zR\n", + "oXH6Lk1DU6AjHq7MQ2YcYfECilL2/Cfo6kYTDQGVVyk9Gg/xkGdHoeKigV5Od+YCIeZhRgSJI2De\n", + "3Dsaj8eZooTQi23e7hTwLt9Z5IiUG+Vs9+c9vAtl44Kf7eMYaTxzcXExVfvd39/XaDTS7du3JSmd\n", + "UQUidXx8nIws+kPYLKLGJycn6nQ66dkYGZQCoCDe06dP030U3IQvBoNBJnzK2AqFaXKwIxCgB0dH\n", + "R3r+/HlS3uPxOFOC4Pnz5+lcwL/7u7/T7du39YMf/EDb29uZxPg33nhDd+7c0dOnT9O7QN0ajYbW\n", + "19c1MzOjnZ0dff7554nfvv71ryd6Ly4uJgeA+WQTAQfm0nzchK9cRp2eniZ0rFQqJVSKEIsrSd9I\n", + "4oaGKxOuz87Oql6vZzaUgJYSembuuI7cOjs7S3PjssNLMlA+hDF6+gUIDc/k7263m4yxPP7m/dK5\n", + "Ae6IQ55D7hsOeLeHHklRcNnG+3mnPzOG4P0a1z0iQd/c2fZdgr5bMG5k8bnCqCgUCqlPrBl38vKi\n", + "Kqx9rrm+YLefyxPmEn5yGkNXdx7j+9xR9ve5QelyE4c9Jrl7n93h9eYy2sfHHEQHw/WTy3He4YZ6\n", + "Xnth5Q9KpdKFwpIwqsOWUjaj38M/fq80NVbcqne40eE+t4S5FhET3h3hQ+6PiwbDyo0ynunvjXCi\n", + "ozaSLjBFtJz9+xiKjhjFZ7iF7kyOwo4GmAsymhu1eILOzNDNi606OkPf/VkojV6vl4xrN/x4tiMo\n", + "l4VLyf1wIeWGtKOYCB6Emgt9F4bRiHbh78oKWjpyxTuhJYKW/sZ3ouDwsBBcXqSP+fOwiHukEf73\n", + "uffG3LA2+v1+ConBS+RAUWtJOq8jRWHNRqOhcrmc8ocI9ezt7SVPlrDXwsJCKpzJYcrQqt/va2lp\n", + "Sc+fP0/0dJ7Z39/X0tKSOp1OhsaEik5OTjJGkh8vUygU1O/3U0gKeUPeFU5NpVLJKJdvfvObun//\n", + "vt5//33t7e1pd3dXknTv3j3duHEjoRR+bMT8/Hw66HZ3d1czMzP6gz/4A0nS9evXtbi4mKrAu9OC\n", + "gURdH4x45oK8OvJ3XCZSvsEROx87Ctx5v1QqJcMdJRTlkZfX8C3yGBnQyx0QLyQbUysmk0lCVmN4\n", + "y5HXGNZ3RHs0Oq935sqUsaI7nDfQJdHBos+uZGO6Bu/Mmwuuz8xky74gbxivz5O/y3kYeeeos6M5\n", + "tLyQkst3csloGCCEDiMigyGNXvS+QlOv8C5NjQl3uhwBdSfd+RvUk888jxdaxCiO08Zln/OT69po\n", + "LDtgEiMKrI0YhXEQhPF6VMSN3Lz2wgpygiy414oCc+UhTZWpW/ZMIorVESC3JF3ASNm8p2h5RqOI\n", + "97qC8smMC889BEfP/Nko4RhmcwvaDRunB8LGvUAWe0TjECJuSFwWxosWPd6nx7lpbt1DD0dbPKbv\n", + "Rkg0grxCu9dEifkA9N29pwj5+uLLQxzpP9ecvyKky9iYHxcKPl9ReGKcYUzG8RMWkJQUJ7zf6/VS\n", + "iIZnOJ/hYYNIwPt40+5lu2d/fHycqg2DdjFPGDQgOghw7kFZNpvNJECePHmijY0NDQYDbW1tZeYe\n", + "ZOr09FTLy8tqtVpJCbNVHgHvypYq4o5GraysSFKqk4TiOz4+TqG44XCoYvH8rCzQHPcyEfjwEyE5\n", + "51PmOVaEPz4+1o0bN7S2tqbd3V09ePBA0nn5h36/r7W1Nc3OzqrT6aRxzMzMaGFhQd1uV+vr63r1\n", + "1VcTQrS8vKw333wzoQbdbjfRhm3mEXFxvkXuueE+Go20tramcrmckEEPX3nivz8LXvRTBmigOhhv\n", + "vAc+9FAT80l/UDY4Ai6joxL2xGHWPHlefo338dzT09NMiNPDVB7BcF6DLzzfhtAzazI6rhhzvr6L\n", + "xWlNvUKhkElKd3QK+e3IymVRjEKhkJDbvBCs6yg3YFyGgzQjx5hHN3SjQeKGtiPHUVf6/9Bzfn4+\n", + "JYI7vSLw4PIbY9aRJx8jY3FgwkOzMUeU5t/3CIbznzsR3i9/xmV/+xiY88vaVfmDq3bVrtpVu2pX\n", + "7apdtf9le2GhPazkeHI0Vr+jFzHG7SEch57xXGOozGPQvsst7uCIUDSWvlv7niiN9+ZWdR7E7u9z\n", + "BMWh0Jij5Pd5oqaHIfC4SU52KHoymaRdLx5j9nc7XT3M6t5iTOaLfXXP06HqiCwxnyAgoBT+zLzQ\n", + "lHvi5DA4H7nnEPuCV4ZH4fPrf8fkZ7xkUCafE88B8Gsk+0JTP9yWcXg+w2QySWEoShMcHh5qZmZG\n", + "1Wo15RLhMTqSyU6piJbG8CJrCVSHa6wZeP/o6CiF70BboLdXfiYE+PbbbyeUhjyjVqulZrOZPH6Q\n", + "HfpZKBRSgja79OgDzwdl4L7RaKRarZaKY5IL5bzJTkHCG3HNg9SMx+PM2Z3j8TjlVfFu6Txct7y8\n", + "rGKxqO3tbd26dUubm5uSzsszfPbZZ+r3+ynna2NjQ5LSurxz546Wlpa0tLSkO3fuSJLu3r2bvGd2\n", + "usFvlJIYDAbJ4wV1mZubS+VeGJMj1YTT/ABneNFzq2LVc3gFnnQaELJCzvJM37zg/YBu8AnoU8wP\n", + "jSg7c0zpDT+CxMN9nr5QKBRSmBVEknHFXXSRTq4TWBPIQEddPNRfLpcTv3nKiSMl8CIHSzNOR+49\n", + "jyeGoNBbCwsLaecqYwA543sxBIkcgUYeMuO6pynwXD73VBau0U8/cJpxcJ0ctzwE0HWAz72P2xFH\n", + "vhPDlz4unutzzTgdtWPMLs89n9jXEbrb0T34Im7M4t68aAfthe3ak7L5Qh7aizHPmBDnTIVyizkB\n", + "0lRB+24Qh+c89IdB4u+MuVL+PhohFZ7n59e5AeaGBWGFmNvi4UoPGWAEIDDdyCJMgZCOyd2zs7Mp\n", + "jyLmn9Avvu8LA0aGSV0A+/z5gmIO3AB25vUdZg5VM59Oa38mi5jdYv58X7D+2+nOHHkOhQsbTwBl\n", + "3t1gdoHDnBIacQMMIes86bSCtz0USp9RhMDYKBoXTswDhhQ8i5FFjg7PBIanVhPPJEcIh4TDhqXp\n", + "UR/VajUpY3ik2Wzq8ePH6vV6un79ura2tjIGEXk8sXYYIeilpaWMESGdVxJ3nlxcXMzMKWHHaDSy\n", + "65e5hAZeOoDf9Xo9HXHCZ4Q+l5eXM7zI92/evKmzszPt7++n+1566SVtbm7q4OAgbfGHT/v9vmZm\n", + "ZlSv11Wr1VLld655MrRXjPZSAyRvsyszHtp+cnKSSh6g6DEgOfbG+cplDrxIrlretnaMfHa2ebKx\n", + "O7cuF3xrOUnmbpAx/mKxmHbzEj72eWKN+LrBKKPf165dS7TZ39/X/v5+UoieK0gf4RHfXetJ+O54\n", + "8H5P8vZ58jBYdPDJOxuNpqUIvKo/zcfl72T9u87zkJ479JJS7TRSFKKBwbvQbZ7LRp/43FNFnDZx\n", + "fpHlOKHuJMZDlX2M0RmPG5Ccv/IMFX+fy1N/j+sc9Bx0dX5i7vicMKyk5LDgQLizDV/G0KK3F2pI\n", + "uVESE/fi99wTcIJjQV6WPBm3lXKNnBGIHHNvILQLDe8PfXEmdSvWDQGuMcEYQM587j24cYYQQLl2\n", + "Op2EAsQjEHwnGIoUb8HzaWg+Nvci4uKPiA33+Xj8+/7bcy1Y+NzvBihjcMPM54u5dM/W+YfF5tei\n", + "9+xIHuN3LwSaci+L3sfA1m0UhSNkjlZFh8ARMObMx+bz4kUZOZ3ehYkn6iIASOB2Id9ut9Xtdi+c\n", + "t+aJoAsLC1paWkr39Xq9dJwLXrgfsFsqlfT06VPNzs7qlVde0ccff5yZ52vXrmlubi4lpdO84KIr\n", + "PeiLJ+65Lxh4vmPNjVA8Z3jYUU7qD/G+g4ODC7l0IFWNRiMZIdK54m80Gtrc3NTy8nI6mBmHpFar\n", + "aW1tLd0vSbdv3047VkEXXJkOBgN1Oh212+3ER1wjGd/5h7nAAUCper0vDghm3WDAzs7OqlqtJofE\n", + "eRTjGuXmCtHRdwxsPxhbyh4/43XicFRBOKNc8N1x7igNBgO1Wi2tra0lxNydIMbKO/mMQqrPnj1T\n", + "r9fLlH/w5HNQHYzavOTjaARwzdeTO708PxpU9N1lOwn7OGFuuLrjhdHiaE2j0dB4PE5lPFwusm4c\n", + "4Y7INHzmaBXvRR67E4NsgQ9cfqEPQSYjmOBghvcFJ9hlvRtn3Iej7cgp/fSiqcxhNLppPk7PCaW5\n", + "4Q1tGTsFSBmrjz3SMLYXYki5weBKLn7mqIF7V27YYBx42Mq9DAwB/57fx3e8MVGXWcHc4wuC+7xf\n", + "3lhkLJi4w8x3gvkY4k4BQhmS0inejnDF/pbL5YRauBCRpohcTA6FST3k5ve5gHGUi7njXR7mhJYg\n", + "CA6VuvCkX96gD7uWomHkcxLhWIRCRMrcwHJe4HO/5vOM8ILWcZ49fJdn2Pnf7vGcnZ1pOBwmRe0V\n", + "0V15ueBHWfMuR+vOzs7r+kwmk5TEToP+JCWfnU3PTPNwtyd2S+eKHaH405/+VN1uV6+99pqk8yrk\n", + "pVJJOzs7mp2dVaPRSMYRAovQRblcTsiKJHU6HQ2HQzUajQyi5cUroSXjAP1wD9drvRBuQZlGBLhU\n", + "Ot9R2W63Va1Wtbq6Kuk8FMh8YGRRK+vp06cqFM6TZ3d2dlSr1bS8vCxpuhbb7bYODg6SIUtfQYxO\n", + "T0/TepSUhDdhMUrAOJ9AE1c08OHi4mIyiuA1SiJgPPuZeb6BAqXiiKukhKwQrqJ5gj686SEz5ATG\n", + "lKcRuIJ2HgZhbTQaSR5FpN6dZN95yc7R/f39lKzvdEPx+9rDoMpbhy7X/Fm8j3mLUQopmxjOnDF2\n", + "R0L4Lu9wkMD7Ca1Ho1Faj466QwfWo+sqlz8eGpOyTpqPnf9dzvNZ/B9edR3gYcUoazEuYz9jgrh0\n", + "sRI6z4jOPe+IwAV84oag09SdefhUOl8zbsz6+JibSBtvLyxHKi9kJk0VWYQAHQFy1EnKHiAcLXNH\n", + "sBwqvsxAkrIeBlCtowe0PIXo3pR7EL51HkMqz8LFI6fPHC8B3Hh2dpZg8ajIo6EUDVanGcYTNPOc\n", + "Bv72ReRM5ULGPTP3SpyxGZfDtB6iJJTJos9Ddng2z5GUqu/SPw9h8C4XPh66dFp7P+l7Xi4UC9MV\n", + "kBuRKDc3RPNCopPJJOUfSVNkqVwuq1arXTDg4Xno7eEHDI3xeJwQCqebdG4cYCBJSmhFq9VSp9PJ\n", + "5MIgpFHmbgwPh0PNz89rbm5OlUpFrVYrveOtt97SgwcPEvo1mUwyyrvT6ajT6aR8plarleaiUqmk\n", + "HXClUint2qvVaolWPu/c52sIw9DlCoYViATzjiKAfhyYLJ0bNr1eLxnQrVYr0ebu3buSzsOR8CRz\n", + "wa5FQm0YI5JSeLDZbGp1dVWTySQZks+fP09ozdLSUmaXJP0ndFQsFtN7OKjcUVU3+KEbx+vQ+J6v\n", + "F6eZhzucD0FffY1G5YJ8hZaO8tEYkxuSyDQUsstaDsYmf4n7yG8rFovpmCTeF3PzYjqAh4MceXDa\n", + "RQfSDXJfi1xzneMKHsV8fHycZFBUyMhUDA6eQ4t6BpmLfIm5t64/HAX2e/29jirSD67H6I+HF/ke\n", + "+ol3gy5JyuUlR/8JU8aUFEekGEdEEpHREcn1eYifMca8cGGv10sGvfclomx57YWF9rCSo+WJcnJm\n", + "8Obb4Pnfn4FhIE0RF9plMVhX6DQEtYd9+NzDSW6ouSCKW1URbCT+ej4WC8WtaDfm/DgHXxTdbjfl\n", + "ungOkDRNrEeoRIPQtxnHxc3CdG/V0So8fZ4X0SpHnXyRuoHhuQaOvsXxQxc3WmKIyo0hD236nHiM\n", + "O0LrvuBc8DD3LgAcvYoOgfOeP9/7g+Dz7zlqyHV/hzsVjspEDx0Uge85UgGfwDd4uvSZBGeUAAab\n", + "oxI4AKAqfg4dob6dnR3Nzc1pZWUlw3uHh4cJNvcz3ECpNjY2knDDURgOh6pWq8kYALGTsoVR3YBl\n", + "XZGXw2eOFg+Hw7QOMZKgL+u+3++rUqlkio4SEqvVarp165YODw/TOm+1WlpeXk5lEU5OThJaRaHU\n", + "o6Mj7e7uZsofNBqNZEyAhMEbjka3Wq3kcNBfR04xJJkLHDme6xW64TNHQKQpkgGPuzHo/Op1mJzf\n", + "xuNxJgEbRBMDx2tNxdxGShsUi9M6adFZcd7n/cgML+9BhfW8/CRPXHfnimc6XVxfFIvFdO4hSfDR\n", + "GeczlxHoAhBCn1+/n7G6I45T4mvR54nP3fhgfqJMdFnvecbIDebMk61xRugrtPPQGPNKyRdfZ5Gu\n", + "PjZpGn5nc4obTvydl5cEnTxE6A5VnFOXl5737IYiNkW/309OixvHEaSI7ar8wVW7alftql21q3bV\n", + "rtr/sr0QRAqL0eGyGOby+Lt0bvV60bKIZrgF7l6WpnlYRwAAIABJREFUw5ERLnWPztExLGiSa90b\n", + "43sxd4O+eJzcty7H+7zPHp6JSB1eF/TwEBxhnHq9fgEB8rHiDbg35JZ+tLTxKkhU9O/i7UAbpy/0\n", + "xGuLCYlA9XhDsS/s7oIm0AjvM4ZuQSfdW/KxxDE73O5zH3O+3BuLKBPfiV6W52F5zpmP0Z8TE9VB\n", + "QvCu47lwjMPzgCibgJcYn0li6Onp6YWigXjwEQEkNEWBUA8lg4IQUjs8PExzvLu7m1CuVquVQW7r\n", + "9bru3buXSbZmXP1+X9vb27pz546Gw6FarVZmLZMDc/36dVWr1QthBzzshYUFDQaDlM/FPHh+hoci\n", + "8DzhJxA5r/rN2YEehvMkX6/83Ww2U8ju7OwsHVgsKSFXoHeFwrS4nyMglCpxXiQVgP44gjYanVf7\n", + "dj6E1+bm5lSv11WpVFJ4zJvzaVxrjm47euu8GkP30JhwuydcU6iU8caQN9/znarMEzssvSyDNK0I\n", + "T+5YPG7MkXN4BNqAUHvaAeNnPkAgXA6Dxnq0ItLUEXDG5+vLS7j4PPO/o+0gc6Br/j4PsXp+sfON\n", + "I+YxGsNYR6NRWjOe1H9ZXpCvJ66NRudlSCgc7HPqiBCywyNGbExgjI4Qud6JuXrQir8jwu95ZP7+\n", + "KIdjdIGxlEqljAxmfV7WXlhoD4HkQhMmdKOD5nF+h0AhMELXBYpDiRFOdQZ3uFPKLghnFr+P5/J9\n", + "7xv9Q5FL2WTz2D/uY3HH2DC5WrzLc5TYEeK7UqTp4sNgcLiT5wDh+tjjeKCrM7JvKfYF7PlMHhbk\n", + "mv9G2NJXDARqYUV4mAUQIVYWALT1vvh8xnExZu5zvvAcCJ8jz3vK29gQDS7PJ0PxewjXhdtoNEo7\n", + "vuI5dQhe4HMvY+BHo2BUeV8IYdF/KXuUj9cHkqb5WhhNvkaHw2HKgeF8PM6hW1lZ0f7+vsrlstbX\n", + "1/XFF1+kkM6NGze0sLCgarWacSQY93A41IMHD5KgJSTEmX67u7va29tTo9HI5F0xTgwFD4EeHR1p\n", + "PB6nhHXPyUMpQ08EpzQ9p63b7aat+t7Xs7Mz1ev1FKaCh4fDoRYXF1Wr1VIY/fPPP5ekZIhxkLcr\n", + "dniNWk+EO+AZjAHyUJzffKOJ8ypOAJXgnQ+LxWIKGeXlfDj/ezmVmGODonGe93URc+tmZmbUbDZT\n", + "yMplKPlHfIbRPxgMLhxjkrfGfG4ZPzIc2eKyIO6o9jQMHDNoFp1rfij1IU03PtAXf4enUuSFhtxR\n", + "jGkuHK+CU+Iyx8N4HlL0OWRMl+kcxsF9HuKLYTr4BjkWUxh6vV7iYz+Wx0uEcF+sHelz4Dt9XUe7\n", + "USspY+xFeRnH6LwL7aKcdJuCcCONOY285+2FIVIoWzdUnACxhpNvHwWJ4FqMgeYRJ8aRaUySE4oE\n", + "PBZUzK+JBoJ7AihLR1G8nxhMbix4P5lkzyFA4dP36A1yOrqfxcXY+C4Lwxk3eofeQHmgqfeP/0GQ\n", + "8oxU/z7XnDbRw6C/3OPCDhpwj+/U8DnyuXHPKjaMU4SbC2Ke44nJvpvJ+x8NYUd3oJ0vWBcwzjd4\n", + "024Euwfr3hJ955ko99PT0xTbp98Yu9Hz9fGT5OuJ75zhJp2jCRQHxVA5OjpSs9nUnTt3UkFK6mCd\n", + "nJxocXExIUnSuWIkgZvSEYyh0WhoOBxqZ2dH7XY7c5YdXjle/P7+vvb29iQp1bmamZlJRo/zEMaT\n", + "F3d0/rp27VpS3l5jqt1uq9lsql6vJ/TBd2CBrrTbbTUajTR+0DAMv4ODgwwiA1oHmkd/oTXor+fm\n", + "kP8yHo/VarUyCsNRY+QT95XL5VTmIDYcFhR3dLBYe6PR6ELNL3f0+D8mdjvq7oU+eaaXZYBuo9Eo\n", + "c2ZgrC3F+nalTPK25zG6sQTtPe+Q53Edg9aNHnd8HBXBIHGHDkfBd/T5sUQ0N8xcJnk/oyPohm5E\n", + "0FkPzEVE1uDXvIRq3umomOuEaHi5nnVD17/HmNgtGo3a+H7+j7miMUrgfB1lu+v1GOVhTIwz6ieu\n", + "xYiJ63mQWX9HXo417YWVP2CSvXPA79HC9glD8XtyGYwNokFjEUVPTsomW8ekZfrg3pMjYlJWEcZJ\n", + "dOQiImQIufg+/s9DSHzscSFijOL1OUyNgvV73HBFAMEkjtxgBDrCxjU+82J89NWFex6NXajSFzcM\n", + "YpK+G5RR+DN2Ry4dUnceiIKNcUNDpzPj8ARgf7Y/x+nqhil9cx5xj9ZDdAhNVz4YLzMzM6lQY/TK\n", + "xuOxBoOBzs7O6zB51ft+v5+ZTzfOR6ORWq2WisWims1mZkcbCgpjxsOCa2trWl9f1+LiopaXl3V2\n", + "dpYqTVerVS0sLCRE5tq1a3rppZckTcN+MzMz2tvb0/HxsZaWltL4OCC53+/ryZMnevjwYaL322+/\n", + "nalBFR2ier2e+LTb7aYQEn0hxOWhn1qtlgxEjF6eS82sYrGYUUiSdOvWrVSramVlRfV6PaNoQIY2\n", + "NjYyPAdqzLMGg0EqjcC4QK1AIZxnkBuTySSF9nBwfF1ggGBEM1aMNmgaEWeXCePxOJVrcLq4IwTv\n", + "erjJEVUKh8LLlG/o9/sJIfME/pOTE1WrVQ2Hw/R+nokxByLjicq0GNpiXB6Kjjt2oaevwxhNQK5y\n", + "DQSOdcizjo6OkqEML+bJfcLv0bGJ6zo2n2saKRJuNESEjM/9+S6XcK5dvrkD6062n5JAnz0dh2cR\n", + "Mne56O/IQ4yYQ9cJjqhFMMTnijl0fenrB+NWypao4DseVYImDoDQN/9uXnth5Q+kiyEkfrvnz/dg\n", + "zsiEKJr4PClb5ZrnRw+M+9w74F6ER4TGvS/+Tmd4R2VoPvlu4fv1+Ey8D645EuLGGl6XMx39xkCN\n", + "wobvIDB9YTP+iBa5IuO6LwYY2+FhaOPeZRQehFtAbdyw8bF680UQjWEXir5wfOzej4hG8nekNzQG\n", + "xXKUw9FN9+SlaQ5JNGjpC1vg5+bmVK1W03VQExSDw+2gO9xP8U3o7R4dh+UyDmgzGAwyVbfdY+eI\n", + "Ep+LmZkZ3bp1K5VpYO11Oh198cUXWl9fV7Va1bNnz1JtppWVlWRcg5RwX7FY1Guvvaaf/exnSQCT\n", + "k/Xo0SNJ0le/+tWUS+F5IxzKu7e3l8lroq/Ly8t6/vy5ZmZmtLq6mikb4YUu3YuGP8mD8aNuWIvM\n", + "77NnzzJClu+vrq6m3XnM4Xg8Tjk+boCheEHYyFOBZ4rFYqZ6uedtTCbnRy4RSozoZ61Wu6BIL3Me\n", + "nYd5nh8P5OEOz1V0Be1Oj4eicEbcwfS++hz4WsWYg+cdOfZ1hMPosg9ax13XvBtaRjnkSLKjfMgm\n", + "6Bl5kdwa38rP2PNQZPriO089SoGR6norprf4uJze/O8Ii/fHHXGXYYyPH78XOnNPNHqi3Isy03WQ\n", + "P5PfLjv9Gs+KRpQ/33PnHL3nur/P6ev2RHy+j8H122XthSFS0chwQyYaGRGS88/cI3MDgGsolMss\n", + "TUfG/D4IDTP6pPN5XiKyNI0x+4T6IkHQRBr4oo+QL/f5Ncab56VhkLl1DsLm1z1fI2+B8S6Hvwk3\n", + "YThFww6kxJNcHbFBUXHNi/X5Nl+nFfPl0LAbQTHp0FG9aNj4QomwMYYgfYn0duPMBa17xXmIYl6h\n", + "Oeh9dnaWcnNAZ3guBgtz5/yNouj3+9rb28uc1VUul5NRsbi4qPX19YRm+JEwEdIej8fpSJlbt25l\n", + "wsGdTkeTySTVpapUKplK23Nzczo4OEjHzGAIraysaDgcamlpSW+88Ybu3r2rnZ0dSefe/PLysh4+\n", + "fKhKpaJarZbZ/j43N5feu7y8nMbeaDTU7Xb1gx/8QMPhUOvr67p582bqz82bN5MCu3btmiqVSqb8\n", + "g5/RWavVEgKIHOE9cYMGZ/7t7e2pVDqv8s41jDlChSi+ZrOZQqU80z1ijm1xj5lroMyj0ShTTBK5\n", + "5Xlu9NPRRWScG06eM+JhHvK+CPGQjA+fOMobHRt39Hxtcy/rGNTJEQcadYV83Z2cnCS6ttvtzLpC\n", + "xvLj8gQnydcktGHduzFPX1xWRLnvTpWvcYwWp4HLG3eqHTmiWjm6ydMIMDw4ncLpDV9joHpfaPQ3\n", + "Ikf+OTrMdYRHBdzw4R6X59FY8fvzDEeXt1yj72xggHf9xAJ3eJyn4GU3vrnf590NTje46bPzQDTS\n", + "fFy/zZC6Kn9w1a7aVbtqV+2qXbWr9r9sLzS0Fy1MrMq4s0fKFr+MaBXJeDFkhPXru/ncUsaad4+F\n", + "Z/JO/8019wzyIMdoPXMtjimiEzFBmc/xOt0z9vt5L8+gb3hkjNefGyF/p6l7sTEUhWeKNxP7Sh6A\n", + "pMwZSR4y4tkewsBLBZaPuzdIFo5esHvakb5eAC/Gznl/pLc0RSH4gd6efE8ozufE8y/yaMp7QBAc\n", + "lej1eims46FoPCveRSiHRjjppZdeUqVSyXhWJOeyRvCEgcMpXMj3Jen69eu6efNmJkzhOULkwTBe\n", + "Em5B0zj3rFarZSrw1+t1HR8f6/3339fKykqmyvrp6aleeeUVvfrqq/rpT3+aEsrX19dTUjioJTRu\n", + "NBpqt9uan5/Xl7/8ZZ2enmpjY0Nra2uSlBCg1157Le3cgzaLi4vqdDoJ5XPecPQABNDlFeGmcrmc\n", + "kCRpyuuERzz3hjybUqmkfr+vdrudyQGs1+uZs+Kcx2dnZzM5bI4cUhYBOefP9NBODPnH6tlRniwu\n", + "LmZQEmjBmgeduAyRKhQKF8JUhEVBUTxFww9e9yOC2HnJYe2O9Li8uCzMeHZ2lo7f8fF7qkRML3F9\n", + "4PzGeAm5OTrlOUGOULMu6JufFiBNiy27bPD3gVDFHDDkl48/6hzPJ3ZU2fWTy1/e7UfqRP0BH/A+\n", + "L6kCiuwomfNU3i5RR6cI27JuXe7FKBR9dR3k9IsoMo359p3hUX/HcKd//tvaCzGkXAG7wvBtkXlG\n", + "hw8o1p3Ky6WJho3HfTFQYtyWZ+T97c/knR7HxjDx6uvOUHmwob8nT5j7fQiqGD/mcw/deR8RCm4U\n", + "RIXtfXVI1KuUx37mJekjOKLQIAEWmsd4P1vDI4zqELL3w+mdZwzzfU9I90RK+MHDdD4WX4get6cP\n", + "hUIhkxjs8xgTWn0c8L7fh/Kl9IGPE2UymUxS2QFCPAgDkjzZgsx9nU4n5UB1u900F5VKJRk7lLIg\n", + "1Lezs6OtrS3Nzs6mvCT6WqvV1Gw2Ux6UH1o7mZzn0NTrdTWbzZTzIZ0fZFyr1TQajVJYkGTrfr+v\n", + "2dnZVAX83r17qWwA32F+Dw8Pk5Ld2dnRysqKvvGNb2h9fV2dTicl/DL+jY0NLS0tpRAY4yD5vVqt\n", + "plAS97EumDs/gYCE9fX1dZVKJT158iTxzeHhYeLjw8PDzGG/3EdOFzvXpKmCYZ16uQvCugh+D6/B\n", + "U3y33++nd87Pz6ter2tlZeVCjhC8xU4zDzXhsHlaAv2Efq6Y3chmzbrz4XKYH56T91w2NvBMQtWe\n", + "OxlDNxiMLpfcyKHOFErf0zx8PUtT5Zw3BvgZ2rmT6degnctVrnsNKfriOWDQimuj0ShzDJYb+Hlh\n", + "VsbhBpXTl/64DIrGhNPVZZTfE8OlkpLjxVqNG5D8XV7r0MPZlFZhDl0H+Pj9ndSWuywM53TBgKY/\n", + "seyP0yLqmbjDMLYXhkh5zPj/q7myzLO+EUTRg+Q91FpxQ8aVKj/+mS+2SGAEQhxLRKpcCdEvR8jc\n", + "WHJG94WIhc+z4sKPnqN7tQhRvgeNpGxNDZ7lSt8XdqzrhLCNxzz4vRiT8X1sAZemxrBvUV9cXNR4\n", + "PE04ZsyMwenGc6NR7c0NV0c882LifM8VgiuhiAa4oI2Cxb1b7vW5cyOLuk7j8Vi7u7sqlUopURtj\n", + "AMHmieGDwUAHBwfp0N8opClTcOPGjZRvQf89Afrg4CA9c35+Xjs7O+k4lnq9rhs3bqQ+j0Yj7e3t\n", + "XdgNOj8/r+XlZa2srKQE7T/8wz9M4zs+Pk41oA4ODvT8+XNJ50jO4uKiCoWChsOhNjY29Hu/93uS\n", + "pO9973tqt9u6du2ahsNh5nwvvOdGo5F2dvX7/eTRbm5upnPtfDerpHSe1sLCQjrj77IdqD7vXuD0\n", + "yZMnOjw8TP3hfMLDw0M1Go1UM4n7MZiQRfQT55E+sjtKOs/lYr2g4P0IFlCw+fl5ra2tZRTt3Nyc\n", + "arVaoj1j8YR5jDTPS5mbm9PJyUnGoJEuJuPCC87PvhvXZbQrIMpS+C4ul3kcFcM4MPSYb2/uCHpD\n", + "Hrrij3KY8XteqctoFLAraMbFNZf7nj9E3/gNneJubUnp0HGe48f8QE8vVePNUTn+93f7/Ph3XGZF\n", + "o8MjG1EuwhvIz7ixBfTQnQ/0rkeUXLdE5Mh36kd0z/vNNXJxvZ/8dqdIyj9jNfIFfO15he7MX9Ze\n", + "aGgvfuYejn8nWolu9HiiX9x9Fqtrx/c508SwEf+zeOIi8V0SUci4ceJojRtYeUiYe3A0klD9fp9g\n", + "Whw7cDhhHEeu4vj43xPRoSmL0Q1H0AeMGEdzHN1hfrjGOykG6coNZYPiYzFSI8u/616bG9f0L9Iz\n", + "/h0RxzyliRDzOYyhAPckfeG5F5YHZ/PjZ5AVi0VtbGyoXq+ncJ10zsP9fl+tVkuDweCCl1gsFtNZ\n", + "dGdnZ6l6tiS9+uqrmpubS4U6MV4ODw/VbrdTeNEF040bN/T2229rcXFR9XpdhUIhKbB2u629vT3d\n", + "u3dPMzMzevLkScaQmp+f19LSUkooBgVot9taXFzUycmJKpWKBoNBotvi4mIKG/V6Pc3MzOi1115L\n", + "8/yjH/0onc3nybiFQiGdNUl4cG5uLhmgJO/Do76+KSIqKSFWNEcoozc/Go10eHiYDJ7hcJjmaW1t\n", + "Taenp8mwdXSMit+sj1hKxStzgyZJ00Oi5+fnk2HrmwngVWpRYaguLi6mUC4omSssxsX8uAHmRReL\n", + "xelZjhwuGxPNY/Ix97oc9MR4D3kyj1xHtsGL/js6KnlIiitHd4b9e6BJ/l3vT146B/c5Yu46iHWI\n", + "go7Iuctrn3uMEeRuRD1w1kAaY9qG089lE2kgOErufGLwwOcxhMV4oJPrC3fc3ZH2sDN0YcygcU7z\n", + "+L6oe6VsTauo/91gxCn0cLUbUW5MsksTfvJNEcgK31R1WUpPXnshhpTHd71zEVZ1uD2iQ/GIBYdz\n", + "4+4NRwcgKu93RoxKGGPJr7mFy8J3YeJVkn18LnjyGAMhlGcscY+jJdALlMLDA5KSp8nnvMNRN++X\n", + "/x29HxcMbtRFFEy6KIAQxHEO3DBCkTvaFz0p/+19dqHCWHlm5C3vI8aw84H3Jc5PHCd8E2H3+Ky4\n", + "RVk6V5CTySQhPZQHoB0fH6dilpJSjg+KMdJkNBql42Lu3LmTnnl0dKQnT56o1Wpl6NHtdtXr9VSv\n", + "1/Xmm29qc3Mz4wnjkXW7XT18+DDVOPp/2DuTH0mzq+w/MWRmzBE51VzuqnKVwe1u2thmYQMWyF6w\n", + "QLDA8sIbNkjwB/AHIGGJHYIVYo+EkNhhscFCCATGlsCiy91tuqvb1V1DjpEZGWMOMXyL+H43nvdU\n", + "lBeWvq+8yCuVsiLeeN/33nPPPcNzzj33F37hF/SlL31Jq6urqYAm/dzY2FC5XNaHH36oK1euZDzF\n", + "er2uvb091Wq1lMuEAULJBsoZuKL5xV/8RQ2HQ73//vuaTCYJ9ZHm/L2xsZEOBC4UClpfX08hQnYO\n", + "zWYzPXv2LB1hIWVDRqVSSY1GI9EfIwNDxY341dXVZPhtbGxof38/7UwsFova2tpSpVLR+fl5JtQm\n", + "LarST6dTHR0dpbngeCcKi+7v72fyxwjB1ev1tBsSfsMoZbedoyteniKirsViMdHfETCcB+jnaJXn\n", + "s7COfe3BX4TvY30m593xeJxBnTxUFHP5YlglIkTugPv7YijUZQHVvCPiAQ2WKU1kho8d2YaBBdoW\n", + "ZQ9oJAaGyxdKYVxcXKT8O+dRaOe7mV3Xca8bjDhI6AqXQZ6H6boMvkA+x5AwNHR9Rx9cF2PEuXEO\n", + "ksp6ipEP5i8ada4TPUrjBhyOvId83Rn2fvJcvvPwpfMA7/u5N6QkvaBMXwZdSgs0x8NbXFuWFxTD\n", + "Nq6o47OlbK0mKZt8iRHjCjMmuNEQbjAyyak8i78RDaI/XgkY5nQhuAy1c0TGFw0CCBrBxMvQomXh\n", + "MfdoPDfBjR1JGW9gGWLj/WEcFG1bZtz4/EkLxYYR6d4V73PjOyJA0Dl6phGJ8rg9itT77v3x+YyL\n", + "yz2xOD62+t+5cyezHf/s7EzPnz9Xr9dTuVxWo9FIyAN5UYRoff6Y48FgoGKxqPv376dnPnnyRLu7\n", + "uwn5Ojw8TPkH9+/f1+uvv65Go6HpdKqTk5NkLD158kQffvihnjx5onv37unLX/6y7t+/L2muEHZ2\n", + "dlI19OPjY925c0fSPBH90aNHunXrVqrUDa0wtnK5nI6Pj7W1taVOpyNpjsbVarVkeFDQU5qfbVev\n", + "1/Xaa6/pv//7v1UsLorZlkol3bp1K/ULw5FxsKan06n6/b46nU4mFA0iihHCfHLGIHPp/IwSGgwG\n", + "qtfr+pVf+RU9e/ZM0hzlY47q9XpGEDuqM51OVS6X0zgwgAjDFgqFlBs2nU5VrVbVbreTse2hcnLq\n", + "6H9Md5hOF8U13Rlgw4I7DTRQlUKhkEFAkQcYLKxDV2oeuvH6Y6Di1FviPVyjeXV/xkCfXQb4HPr2\n", + "f5fR/P5ljuMymYDMjmkOPk8YQq7YY0jd++IoDzLQHWE3XjC24BXQQ2rJeVjbK5s7qkdfHWFx9Gw2\n", + "W+T9scnHmzujGKM+Du+HX3OH1HUbMgqa+LqIqGHUifH+6NDmcrkMiABN6SM868aiz7ejuq4nYuN7\n", + "f05sl+UPLttlu2yX7bJdtst22X7G9kpDe26dT6fT5MViSTu64DAcno+UtYpBlRwhoUWPDQvUkRKP\n", + "j3v/PLbtFq9XwKbl8/lMbpJDiR5KdCg6wot+HIB7HctCTo5ERTTId6q4FwQ9HEHyQ0OlRTJvDF2B\n", + "xkHrZYX3JL2QC+G7uE5PT3VycpLCMHhMjjbGEgJOD0cOPXbv3owjf+7x8AxHtvg9tOdIlkIheyYi\n", + "4Q7CmiQO0xeeC/+ANEjz3KObN2+muT08PEzb/GezmdbX17W1tZWB3aE7OUXc60m3FxcXKaTV6XT0\n", + "v//7v5IW4Ya9vT3dunVLb731lq5cuSJJCTV9++239d5772k4HGaS+3/9139dv/u7v5sKJHJky7vv\n", + "vqu1tbWU/P2lL31Jn/nMZyRJH3zwge7fv6/BYJBy4Ci6Se5Xr9fT1atX1W63E5JTrVa1vr6eksW7\n", + "3W5CZCaTeXXyUqmUPGmOO8nn8zo8PNTW1lYKAcQzEx0NXl9fT7xEQiweP+ERflsqlZKH7+fVgUav\n", + "r6+r0+mo1+slnqZvIAVnZ2cpfBbLlziy6Ghwp9PJhCdB1yqVik5PT9O5gzTWCYnzhC6LxWLKr5rN\n", + "ZpkxeOh7OBxmKqmDiudyucy8QLOzs7OE8pGYzpg8ZSGivJ6rw3rx/CfQW0JunpRNLmbc3eboDQWC\n", + "vTmCwO5EaY6Gx9MTXMYgg+AHR6T8N45Yx7AUuYWMD7lPOJmGjGJtR1SeMReL86K73hfkvW+coTnS\n", + "wljon/fVc9Ocn3h3TIXxXe4uh52OoF2MExnMrj7WKrRhXXiIT8rmspHL5PobuRw3Ifih79DHedTR\n", + "SqcFctfDiVyLvLCsvdLQnpQ95sMhQBSrtFAKhUIhwb8x+ZvJdXjOE3sjZOehwhhLdQibWi0uaIHE\n", + "HZZlDBgXCFRPOEXYAxM7zIjh4VtsvU8ueDx8xBhiXSPot2wbqn+m327YOYQew6YYuzCeL9IIIUfD\n", + "xnPRvB6SH67L2B36J0fA4WJpsUXWF2dcGNGY8t/E3/FMfgvP+UKM74jXeMfR0ZGuXr2q119/XdI8\n", + "FDUYDPTkyROdnp5qdXU1JQejCKCNCylCT4RaXGGdnZ1pY2NDa2trev78earhJM1zj+7fv69f/dVf\n", + "1XQ6rzSPkfX06VOdnJykPJpcLqevfvWrkqTPf/7zms1mevr0qd5++22dnZ0l46XZbOrs7EwfffSR\n", + "fu/3fk/NZlP/8A//IEn6whe+oE6nk0JOBwcHqaZTo9HQ0dFRRily1h6J0iTck0/BtW63m8Jh7O6T\n", + "pN3d3RROKxaL6eBinjscDjUYDFIJAEnJsNnc3FQ+n1en00nV2TG6qMWFYvN16gqnXq9nQnT0OeZn\n", + "8F25XM7MG8fHjMfjlEt1cXGhg4ODZEg1Gg3NZrPEL+7soEhWVlaSjIqGg4fEWB+Mp1KpJFlCvpKf\n", + "6chZeYyH44I8/OJj9PUXw0HIUd9F7E7WaDRK8oAdrNxHf2NYhbIVvBfjnfuiLkCeUHrCFbfLNpdR\n", + "0Wnh2fl8PmOc4TRLC8cHg4ISIR4SpJGDhkPmNMHo8qRv+IR3oadimskyYzOmNcTf+mefP5dr5IBJ\n", + "2dQFaEZf/HeM4fT0NPGx76Jz+eppLM67MYyMUQXPY6BBE59znBjo4ZXj+T3Nx+o0cgPvZe2VGFJu\n", + "KPhxEK7Io3XqExCRqlxucVaZx+F5xstivW5tR0TDUQxPgKVv0cCSlLGafXcE1zxnyN/HgliWz8PC\n", + "5bu4CLgvjg/r2xnSx+zjcXQOertgdAZ3uvNbN7b4PcIyGoLQ5PT0NOXJ+JlgESX0RYMQdsOV/0cv\n", + "0xEpWkwe5J+PNyKf0ViibkmM58Ob5OJ87nOfyxSlfP/991UsFlWv15Mz4CgnPFAozI/RQNGurq6m\n", + "BNyoTDY3N1UozI8pYVfXa6+9JmmOgF1cXOjjjz/Ww4cPdXp6qs3NTUlzhGhlZUX7+/t688039cYb\n", + "byQj4/Hjx/rud7+r6XSqO/83lwuaPn36VLdu3dI3v/lN7e/v6x//8R/1jW98Q9LcsGm323rw4IGe\n", + "PXuWMU6fPn2aFMZsNlO3202Gy7Vr1zQajdTpdFSr1bS5uZnuY+MGByxTiwq6oPAprTAej9ORLRsb\n", + "G1pZWdHBwUE6JNllTqPRyORCuWEH7yJzlhlCppsiAAAgAElEQVRHp6enaWesND+SZjgcZoxCFJ8n\n", + "N5NT6CU/JKXiorncoihhq9VKNAPZJM9NWmz9hj94JgdWk7wPcg3dcIBAIDCUY86Rrx/y8OBfrnkC\n", + "NDxMf1nzvtNvMsluGuA4Igzo2Sx7cDnyHX7yYr8gaM4T0DTumHaEyHWL6wuXc1EOkd8GasEuRu7D\n", + "kJhOF6VFuObRhOiUg+6DfjvKRV4VPOtOcsw34tnQG7kG/VyGOV19jMhT14duaKFH/H7oTdFc1z88\n", + "E7nMvPuGERBR74e3QqGQduBGlM/H7GgVQAY8Fw0kDDDXwe4sxSgI8xeNTm+vxJDyRefGEwsOIsRE\n", + "SAScewMOm7KwIQDKtVAoZGpbSItznJZNoDMU/YzJ3whYfidlk7dBFqLydsjVkRVHY3yxwfguDJyJ\n", + "QKVisjj9w1pflnTpXpsLTf+Nf/YxuDHjY0LYMfaYfI1wyOVyGU8c796NMd7HYojoEYLU++EGpRtW\n", + "bvDCY7lc7oWKu8wdxlUut9ghyli8rAY0Oj091WAw0LVr13Tjxg0NBgO9/fbbie4bGxtpmz50cDQW\n", + "bw5aojDhXe8Hc12r1fTJJ5/o/Pxct2/fVrVaTdd2dnb08OFDTSYTXb9+XaVSKSnojz/+WDdu3NDX\n", + "vvY1ra2t6dGjR/rP//zPNI5r166p1WolhUGI7jd+4zf0rW99S3//93+v7373u/qTP/kT7e7uSpL+\n", + "53/+R7/1W7+ld955J6Ed+/v7iRd7vV5ao71eL5UpYIciCE+3281URB+NRnr27JmeP3+eCoLCa5xD\n", + "RkI1nq80RwQ3Nzd1dHSUwtwo2lqtpp2dHTUajYSaOW+AjDC/8CL1jGazWapF5UphMBikAqNukGO0\n", + "+G4q5p4xsJbX1tZSiI534Siys0uaG1nVajUpCUcBMJ4o0YCShm7w/draWjJEJaVaZMhi53NQEyqF\n", + "QyuvTZbL5ZJR5sVqmRsfj69TKuXDb27YQB8pu8MQtAqZ6SHBqAAdxcUQc+XqSKEjPNHpXCYPJWXk\n", + "KCEsGmvOFX5Ev/nnCJCXoaBPzGGlUkl99eZhQeYQw8+NTcaGDHLH0ekWoy3QOqblsBbhAV8zfM89\n", + "vhOU+fRd6ZGu3Of6D7p4H/xengk/eckU6OHz7WOHHu5c857YP2+vLEcKoiwLq0WDgYFAvBgy4nvy\n", + "VuKxF75N0mE/mD8iHR4qwrr1PANX2tGi90XonoiP0WP9/kynhU+ab8V2rwkjjlwW6Me1WD/HFx6M\n", + "6WHRZdtdY3/IEfJxOZ1h3rgwHJGjyKDniTCH0cPA21kG3XrozpWTt2VehKN9IJnRMOL50+ni0M+4\n", + "IJ3X1tbWdOvWLa2ururRo0fa39/PFGVkQeN1RzqzgKMB6AYkixtl9eTJExUKBX3uc59ToVDQ3t6e\n", + "nj59mvrIrrZcLqf9/f2kMH/t135Nt2/f1s7Ojr73ve9pOp2m/CnCUCjMbrerb33rW5Kk3/7t39af\n", + "/dmf6d///d/1V3/1V/r444/1N3/zN5KkP/iDP9CjR480HA61sbGhZ8+epRAV5R7y+bwGg4FarVai\n", + "wf7+fkIk9/f3dXR0lJn7Xq+XQngHBwfpGjTAYMD5cAMUob++vq5+v58MtGazqZOTkwza4sYLeVCg\n", + "Eq6EqUXDuue+2Wym27dvq9frqdvtpp190jxnZjAYaDweJ2QBg4/SBuwgdKeH/8OH7kB2u12trKyo\n", + "1WqpXC6nqunch+HjRUzhaVc+VL1n7B5W8xpHKPLodNJXeHOZg0LlfMK4HrpHTniBV+aYtYK+cHnq\n", + "aFihUMgYWYwTGrgSZh25AcUzI52Q/VK2sCS0c+cUA8KNQP4SMuU3NJ7hzqwbM/QD3oi7z0A6vV/M\n", + "HX1mbnxsjrAs251MP9zIis4ehjbXYmjS6Yh+ZSy+0xP5zbuiDOc7l+PIRw8lRpmOzPR8Yzcsya1y\n", + "nec6OxpuPifL2isL7TEZLGoEYYxRSwvhxtlfJD1KWebHy3KPyT0c95JcIUe0xicFyxwlxLlKwPoR\n", + "DnYl6KhaDAM6WgVKgzfoC4p+OJ2cjv7u+NcZwuF13unM6McOxMR1F2DRA4ihMxSPw9vMDQYL8+9j\n", + "8WNS/LkonmXeAM9yGNdDdD5OFxhOP/rM4naaYaS6t+ILdDweJ8V9/fp1HRwc6OHDhyoUCtrY2Ejo\n", + "EzTF0Ed5wFN4UCAAzvvkRfFdo9FI5QRarZZu3ryp4+Njvf/++8rlckmx8//pdKrd3V1tbGyksF+x\n", + "WNQ///M/q9fraWNjI+M4tFqtlM8wnU71R3/0R3rw4IEk6Y//+I/1ox/9SH/xF3+hZ8+e6a//+q/1\n", + "+7//+5KkDz/8UO+9956+8pWv6O2339bW1lYydp4/f65Go5EEHLlA0tzIGg6H6YgVVxgkom5sbGhj\n", + "Y0P5fD55+L1eT+vr67p7926iLUYxvEgpA451oQDqeDzW3bt3M0fgYNhgTLhj4or24uIi5SvhKdPX\n", + "fr+fkC/QHknp2e5A+FrL5/NJbrkAZ7s9hokbMl6Elf67AYKhByLtRgNhSWlxdBPjm06nKfQYz7v0\n", + "dRBReBQhChX6QEOQiIh+gJaRguGKD345OztTv9/PGEu+5jGaoTdH/0A3KZuT69EEeIXmBkFUnBhC\n", + "UbG7XIFHvHAqSCn9cb3DPw+1SXO5F+WNn20XoyLQmbF6eM7LSsBv9N91QnRSlzn76F9Pcse4ch51\n", + "3c24HLSQFuUu6K+/zw1PnAgaBqvrX+83ujXqY5A5N6Kcdq7vI2DhdFrWLssfXLbLdtku22W7bJft\n", + "sv2M7ZUgUliCbp3iNYFouAWI93F+fp62N2Kd492BuPhZbngwy5IJHdqN+TVYrnjPHtfmXVjYETIF\n", + "PWMc7iFLCyTK0SqPOwOn+xjc+vZ3OgoTz9SCbn4gaYSjl4WzeG5EBX2M3tyL4V63+B2OxrMA/o9J\n", + "ooRo4tEx7lG4Z+zXPCwW++noEvSO6JXTlOeBTrjXzfyTwEyS8s7Ojvb29jLFMz1/rFCY747ifuaE\n", + "/uAF4ZVznyNlIBR+9t2jR490cnKiarWaQSXW19dTmOn+/fuq1WqpCvfTp0/VaDQySe940OThNBoN\n", + "feMb31CpVNKf/umfSpqXOPj2t7+t4XCoP//zP9c3v/nNRLfvfe97+trXvqZ33nlH5+fnunXrVkKA\n", + "HKE8Pz/X48ePE6pGAvx4PE67AkHqKEwLD5OHxNi73a5+8pOfaHt7OyGZ9Ofk5CQV+Mzl5gnc5GV5\n", + "flIul1Oj0UgIzebmpkajUUKcCU1ISrk8vuPHk61Z05RXIJ+L9z958iSFOZFfoJTINZdX0gKVIiwM\n", + "D29tbaVjacitol9eSBNe8iTtQqHwwi5AGmOH7r6OkDOeb0VzWRFRVc9dk5RBeZERyE5kIHRzOeso\n", + "PsiCI3ye+wId8/l8Ji3DUzG8f3x22kfaxFQNv854GQPP9Dyf09PTlNrA3PNe0FRkgqPkUnYjE9f5\n", + "LSFhxgWa4/98bqABOiGmpiwLZblczOfzmXQLDkFnvTqaya5UEGKQbqc7esxRLr4HQZUWu279uiNv\n", + "fg863PnCx4T+8eiVz3HcrPDT8qOkV2RIufJlkMPhME0GDBljtyROrq2tZeKzENNL1fu7mHQ3LNxQ\n", + "wGjysFWcGD6fnp6mEIxPFs1/G5nbf+Phqphs579FUHreSIz3swBdSEh6IW/AjUdpkdPEAqL5+COM\n", + "Da15tzMqxgl0cUOCcfpvvDHv8fwvp+WyPDeO2BgOh5n8khj/j2OAVvCiHx5LGJbvfacUeRMbGxtq\n", + "NBop2XowGKjRaKT+YxQ6HTmjjbmPOXGE+1yIorhIZL97927amfbs2TOVy+VkvG1tbaWSCvzmzTff\n", + "1Onpqd55553Ulxs3bqR+oqD5PBgMtL29rTfffFOdTkff+c539MEHH0iS/vAP/1ArKyv69re/rS98\n", + "4Qu6deuW/u7v/k6S9JWvfEW7u7t6/PixfvM3f1NHR0fp3D/4YDwe691339XBwUHKycKIWFlZUbfb\n", + "TYnqtEqlkpKcY2i+VCqp2+2q1+vp+vXrKdfIebHb7SaDgOT3arWaDEmMNuQC4eVer6dKpaJarZaZ\n", + "07W1NY1GIx0fH2cMm36/r9lsfuTH2dmZnjx5koR0uVzW9va2Pv/5z2tnZ0fD4TDlJRGy4kxJ8p2k\n", + "xWn1s9ksGZB+Dh/H/GCYMIbJZL5V3r9jnITJ4H3Pg2Ke2CEa1y5yK4aHoI3vMvPrxWJRlUolY9Dx\n", + "bIxjHEZPZu/3+8mwi3k+KF3yc8iTYhzxnLooT1z2I08wSJCTHpr3vFf0k+8ixxDwv9yHwR5DRO4I\n", + "e4gLesKXXuaBFhV+TMXAeVwWhowy3Pvq+UfRAPH8KE/LYcee3xv1Hc/w0C0lLxyYcJ2PY4EO5zmk\n", + "LPBstyegacy387HDO17Z3Q3ISNNlhmVsr2zXnpStv+ELJSZ5xTONJGWYOE4awrRer6d8D1pMLoOB\n", + "x+NxJmeFiUBxxnipnx0U4/7RG+A7FDv3eZ4AAsHf7+9zD8SvwdC5XC4lwtKcGZbllNEiquQGD/31\n", + "EhAxjyIKBt7jVj39Jt7vi8YRMBdk9CUaQd5XDKx4FIYbmC4EoEukQ8yLw+tC2UiLwohXrlxRo9HQ\n", + "wcFBJqeBfBMEsOemMEaMJTeynD88l4VxdLtd3b17V9euXdN7772XQXNASTBGHj16JGm+Vl5//XXt\n", + "7u5qd3c3UyQQ5AoBPxqNUiL2nTt39ODBA/X7ff3Hf/yHnj17pt/5nd9J1/7yL/9S169f15tvvqnv\n", + "fOc7+tznPpf6//DhQ73xxhs6OTnRzs5O8iA5Eqjdbms2mydls0ZJRMaAmE6nqSAnhTEvLi7UarW0\n", + "traWntntdjUej1Wr1dTv99Vut9VutxMK5Nv0e72eNjc3kzGC0ba9va3pdJpKL0jz3X7Xrl1L/cbQ\n", + "ZC7I4dra2tLe3l7GUD84OEhn+l25ciXN4fvvv68PPvhADx480L1793R2dpYMnM3NTe3u7qbSDhgT\n", + "9NNRCd8Qsrq6mg5HrlQqGfQon8+ng4pBqd2o4zid4+NjnZ2dZersYEBFNNqT3vk/yJb0Yg0eR5ZY\n", + "Ry4naOS2cY8jwOTMYpThREtzxxsjwfMNpey5psj1iLogR1zWggxx3RVxjAa4HnG6k4PFvHFckiPL\n", + "nm9K8j2ffe6X0Z3vkNluUDl9mUvmE1SOunTuTLreoUXD09HSaEiR2+g6ItbfQh56Aj/vH4/HydCO\n", + "eg9ZHDdNoH+hgzvc3D+dTjMlStBryN9icVH6g+8w6N0Ai1GpZe2Vlj+I4RWuRUXnqAGLzWvwuAUu\n", + "LWpTsf2XZ7higzFhRkdPllm3fOdIFCG4yMA8fxk0SovhQv/snoB7ThgmnlQak/d8sfEXYzPC1u41\n", + "LoO8uceNHlAh3w0TaUMfPawHfV1A0JgHr3zuwg2FT58iDX1B+wJ2YeOhVH7rnlNMvuSze+ydTidV\n", + "6X769GnGaEeQubfufY0GvNPGw7IYDyAW0+lUn/3sZ1UsFvWjH/1I0+lUzWYzzTe0nkwmevz4cUIz\n", + "3nrrLb333nvq9/spMdlDJqur8wN4B4OBhsNhMoi2t7fVbrf16NEj7e3t6Ytf/KLeeOMNSdLf/u3f\n", + "am1tTV//+tf1gx/8QJubmwlZ+qd/+ifdu3dPzWZTDx8+TMpaUjIcqMFFQry0qMItKRUXZQx4rCAk\n", + "HhIC3cNgpjwA1eLxkCn7wMHP0hyRGg6HaSdlt9tN7yyXyzo+PtbVq1d1eHiok5OTNEaQO0K+t2/f\n", + "TkbteDw/Y293d1ez2UytViuhg/fv31er1dInn3yijz76SJ/61KdSSLjb7WpzczOz08/TFigLUijM\n", + "a10x/nK5rFarlRwZ5328fJwLr7JObS2cQd/peHp6mupcRQTEDauIRjlf41h6oV5kJE4U5+5J86Kj\n", + "7BJlDL7rmjA6ss+RWl/7ntYA8oVeYFMB64n+8zvWBfzkCJOPzZvLa5ddpJa4MTgcDtVsNl9A/3Gc\n", + "6JPTOK5VeIwxOMpLf6IRQbiU58R5ZAwxnOYOfkykx9gEZaQ/k8n8ZAJQ0KjPXb5GwGFlZXHWbTSy\n", + "3CDEWGbeWPfuJMf3+Q5RjHtHv1zPoNfdLuEZUWbH9soqm0dL0hX9spikI0Su6JzY0ROKjOKK0xEC\n", + "D7FIi91Cjib5IvVn0C9+xyQsM46WhQ5p7hksM3r4PsKV/r2jeuQp+S4VaOL3+dg9bOIonOcQeUgs\n", + "Mq1/Zp6iUcg/wmfQ2+c0jh20TVKGmemLe2a+gOGxlwl+DKzoeUbPmRDVzZs3Va1W9cEHH6R3RQ+K\n", + "RUeffEwYvRFVBfGDn3q9XurPF7/4Rc1mM73zzjva2trKIBSOmh0dHanVaqVK6j/84Q/V7XaT8mW3\n", + "mzQvHYASPT4+1oMHDxKS0+/39fjxY3U6HX3qU5/SV7/6Vf3Lv/yLpHmpgq9+9aupQvqDBw/03e9+\n", + "V9I8J+vq1av66KOPMiUBpDk6BGKCcQA6JM2VKYLSqxSPx2Ntb2+nWkJuEJDDw/b9brer0WiUlDCo\n", + "FoaJO0r9fl+NRkPD4VCtViv1T1oYS4TN2FUoKRlm7NDL5Ra7JPFor1+/rk6nk3LmJOnq1asqFou6\n", + "evWqjo+PtbOzk/qC3Nrc3NT29rZ2dnYydANtpWYUeV4gV9DLHQjqDFG5HVROUqasBQg265ADo5FV\n", + "jjCwnjwC4IYM9HHD3u9HniBzuIahkM/nU/6YI8cg3yC4zD8GCv33d6EDYkRAenF3lhtuoGPIYnda\n", + "I8LMe7gPQ593sLbhFxwC1xcun5BD/szZbH6qA31y586d+dhXnsc15sr5zcfE/GPwujykP+gk3xEX\n", + "5eR4PFan01G1Ws2EmT186cgZzwIJch3kBZZdn8Zn4rC6QQSvcJ/vlnd+nkwmyThznQa/RNQxpqN4\n", + "e2XlDyCCw5yxPIDnO0Cs6XSa8iUkJRgVD8ULcEmLMvFskY6Wsof3YBp+70iHM4ujDTG2CqNGQ9DD\n", + "hT7JjNUNymhgRu/DFzPCC7pwzfMFYojN+wSNovfinmVMAoyfPV/Ncx+cBj5u5t29S5KcHZWSlHJS\n", + "MAhdkEe0zY3VZWGz+B1CPdLbjUEQA2leGuD999/P5DxEg9iFAzShRZ6Iwh0Pazwe60tf+pKkeS7M\n", + "kydPtLW1lcJ4sTLwYDBQtVrVgwcP9MMf/lCSUuhqNpsl4UZ+DTRrt9u6d++eSqVS2jp+cnKi4XCo\n", + "crmsr3/96/rggw/03nvvSZrXn5pOp3r27Jm+/vWv6/vf/34aAxXNz8/Pk3HBPHEGHWMcDocJrSHJ\n", + "mi3VIEXS4igXkuFdkeEtr66uamtrS5VKRfv7+5nt7lTNxmjHWPTjSjDGIk2RB2tra8kIqdfrySBY\n", + "XV1NOVf09fDwUO12W81mU81mM4VLyaeqVqup6CjPLJfLKhQKOjk5Ub1e12c+85lkZBJyrNfrqYK5\n", + "G2Ae/nWnzfO7CP8hW6lnlc/Pa3p5xXzyqtzQcCSBNQOy5A6WK0hksstMR/ZdTrhMZDweappOp+lY\n", + "FyrHS9lcUfghIite/HaZE8tadz3jjpAbRJ5CAY2cNm4cehgOQ5CNJg4SOAoS9QblVTwVJKJVjq7x\n", + "GZryvRsb3lx/xc0DzI8bL9CYvkqLvDsMOXdefW6YR57reh4dwxp1MIUwOmkTPrf8defZxxYNVmlx\n", + "QoqHdmkOHCwDCCL9Yrssf3DZLttlu2yX7bJdtsv2M7ZXVtl8GWrjiINbgVTFBaJ3OJaQAYnP7pnF\n", + "EJtbqR4Lx2r30Foul8skn9PcYvZ3MC7QMjwNt3KxxuO4sY6BlB1B8uQ3fxcNZATvI3p6NJ4f7/dd\n", + "HQ638z7y0TxEGUNmEblb5mW6hxI9JLy22WyWPE6Hos/PzzUYDDIesT8rzoc394aW3edQcPxMlW4K\n", + "WT558iSTs+C8Bv1JwPV58PHQV/f2oif8xS9+MXOcy9bWVvJw3aMDEi+Xy7p586Z+/OMfp/fdvHlT\n", + "hUIhJXrX6/V0rVKp6OTkRJubm6rVahoOh2lMnU5HpVJJv/zLv6xOp6Pvfe97mfypf/3Xf9WXv/xl\n", + "ffLJJzo4OEjI2f7+fgoXMW+OVnCeGuE5Txrm+Bj6QLL3ZDLRcDhULpdLOUfOh6xfkJ5isZjQHBLq\n", + "z87O0tE5eN4cIAxd2BXGc0GqSqWS1tbW0lxMJpPMkS6UmJDmSepbW1sqlUpqt9taXV3NHD4MsrCy\n", + "sqJyuZzkFzvTrl+/rna7rcPDQ92+fVvSHAE9OTlJfEGIS1qUqWAHs6+vUqmUDnFutVoajUYJjRuN\n", + "Rjo4OEi7pOE/SWnrOghSDPGQq+K5avGsPZAFR4DjX/f2nffz+XwqeAwP+fu9ErWXGYj5jvAFqFQM\n", + "7aND6AutUChk5sZD9/TH5aj3k7BgRHeQ2WxUqFarS1F7T0+QssnmHh3gt9AceevrLSLvUfbGtJoY\n", + "xiPfzHW0R2u43xP8QdCYT57tRTddVvp9Ple+KSqmMUQd5FEBD+F6mDtGB3yXYNSPjjJ6WNT56mXt\n", + "lZU/gDBO3Bh2g6h+ICeJyIR+/MDbmD8VQ3A82/sQ4VZvL1O8LNxlzEainYcguD/C5MsYnmd6EqFD\n", + "zX4tQpH0j3e4Eo+hPR87zO+5O24oOUPD7AguLzHgRumyBUVfCYH63DBXlUolIzDJn+K5KEDnGQwf\n", + "FrP3xQ0pp7/f799Np/NkShKU7927pydPnqSx+1lvMf7uysWhblrcAeSKhVyKN998U+fn53r33Xcl\n", + "zUNG5+fnScE5bYC2b926pQ8//FDn5+cphwbnA+PDw2nklty/f18ffPCB1tfXdXR0lPp55coV1Wo1\n", + "/du//ZsqlYo+/elPS5IePnyou3fvajKZ6Mc//nHaoSdJ7XZb5XJZs9niuAhXeoTa6DMHVhNGG41G\n", + "GgwGunPnTqakwMXFhba3t9OOLYTb4eGhisViynUqFAqZ0gmNRiPRmWNYaLPZ/EBfHB/CB8wda2w0\n", + "GqlarWaMEDe0kT3S/NBmwqmNRkOHh4eJNzwHaDqdqlKppDVVrVZTWPXevXvqdDqJptVqVdevX8/0\n", + "x3NvCoVC4lMMTuaekLi0yH2Cv90YdMeA61F2Od3cGXTjhdCay0xf36w/N5r8uW4MeZ4Kn70MgrQI\n", + "7eFM+Dp0w4O+esiXtYeydHmATGNMbgTCq/CwyxqMqWVhTYwCjC36wkYAdxBdTyH7kc2u5H1Ti4+b\n", + "v8ucTil7ogXzj0GELEWu+fzTb88V4n2UF4I2uVwuc1KAO9yeG+ty2R1JrvkufU89ic6pAwhuC6DX\n", + "Yx6w/3Vn1sPB6AGnWdyJmKHrS6/8P2wwckQsmCQG4szIonHjQXpx6340ijze7sYFBoDXIHFjhAXF\n", + "PW61x91+rhCZnKi0Yx5PFCbu/TjK4wvK+0FjXCgwT5zkOh4L+QL+DsYRc4ig9TLjww1UN+IcTfO8\n", + "Kf76HPr4PTmQPjoiR/9Qeo4IuZBywcH7lnktywS58wwIzb179/T8+fOk6La2thKdoreKkPBFHnPf\n", + "aFEAcqbc66+/rkKhoB/84AdJebvh6YUqec7du3d1eHio8XismzdvpmeSE4ji8x1fBwcHeuONN1Ji\n", + "OFvppbmCvnLlih4+fKher6e33noroS6TyUQ3btzQw4cP9dprr+n09DQZYHiWKysrKadtmSeHseve\n", + "HjzMQcAIPpQgOUTNZjMhWSAXrLVicX4+niMN1J2aTCapxAJ8ShK285GkVDcKw2o0GqX/s7vMnTfy\n", + "wVqtlnq9ng4PD7WysqKNjY00XycnJyoW5/WyUO6u2JvNZupLvV5PtCF513cAxvXN9m2vBcZ2f0/M\n", + "dqXA4dmerM77kBUYf4668Bd55LuzoKPLRZrnvsRcoLgjzWU0vH92dqbBYJCS0eGbXC6X+uD9cBSK\n", + "Z7BmPB+Wa8wvypq/GO8+BpwEd8ygE0ZCPAbGnWaQWcbqDpfzpBs60MONE9/p7JuJGIcbi06faIDF\n", + "XXkuN7z5OpXmfOhFfHluRMdcLtMvT4BnLPCeG98+p8yH85rTBqfBDVmPPjEGR8B8PP77ZXrWc+CW\n", + "tVeGSEVvgAXkW0edGV3hRyKjLCCs38dnRzWkxena7k24QeCWa9z26My3bBeVlD1lm7G4Be5j94Xp\n", + "wp37CFPAPP5MlDfM78wArdzDdCUMYhQRK198LlwYFwvXUQenB3PrNM3n52UrKpVK8phdgHk9Ga+H\n", + "xftZIA7/updTrVYzULPvPooo309DLkejkVZWVnT//n3t7u7q8PAwGTXQHW/YFx+Cwo1Fn2P/nRtY\n", + "0jw5eHt7W+vr6/qv//ovbW5upi3ppVLphSR7DJvbt2/r9PRU+/v7KREaYYvRCXKyurqaDjS+cuVK\n", + "QoCuX7+uZ8+epZDYm2++qbOzMx0fH+v69etqNpv6/ve/n64dHByoXq+rUCgkowEa0uKacUMfGmAA\n", + "sOWeMFi/33/hvEBq7TjcXiqVUlFK+Mnf4d5sqVTKOFigVawrL2EC33O/8wbPZoeRG4icrYhjcXJy\n", + "ksbhSeoxZOGOXj6fz5SpINyJYRQNF+hHKBKaEkpl5yFrh2u9Xi8ZZigx+uBJ5DH04fNHX52/HVXH\n", + "OZWyhy+jbL1+IPxBzS760+l00tgpdBpDcvTLjRU3eHh3RDPcEXeZ7YiYh39Ys/TXHUhkgRcVdsMN\n", + "A4vnxffR2OggLeQo7/czYx3hczr47js3FrlO8wR8N5iQrchtvyfSIqLxrgscIEGHOGrkKB86Cx0T\n", + "3+lRKnfM/LcYcjRkL7rRjTPGEcONcWefyzN3NF7WXokh5bUcfCHCrExU9PidgSEwQoJ7MVKkrDED\n", + "8Vwo+kKIMK4rSW/AxChmRzdAYpYJWpjbJ9PREzfc/L0oAIQ0O7ekbL4Mz6E5I/g1/42UPc7BLXdn\n", + "VheqvgjZeh9RN1AFjDXeG70NLHyUi0PKTgMgfebPCwhGQy1CvPSDvkM3N8jds5nNZvr0pz+tw8ND\n", + "7e/vp5pN3BcNYV9cLuigqxfCg095N7h5EYgAACAASURBVAJ1Npvp/v37+vDDDzNFJ6UFbC5lC/FJ\n", + "87DYxx9/nN5BCQBJaafQxsaGisWi2u12osPGxobeeecdffrTn9bR0ZGePn2awnflclnvvvuu6vW6\n", + "bt26lXK0GNdgMFChUNDx8XEmhOEoXS6XyxTQY35Resw1fW61WklJ+nE1w+FQa2trCVFgVx80A1Fp\n", + "Npsql8sZR4bPGOZxe/x0Ok15Y27w0r/JZFHh28Pl5Hyw9v1929vbOjk5SXPLfZubmzo6Okr3E7Zg\n", + "DuEVvHx4Gjq1Wq1kFDgPu7Ls9XqZHLBGo6GjoyO12+2UIyYplT5ANnqxSj+6hHxTmq8XZFUMdUwm\n", + "k4yj5buAMZDimnGEl3XiyIs7Tr57ixAlhqTLU69L5DmW3hwVZ57YNey5tl4MmvfyrmhE0hgn1wjf\n", + "ebqCpFTSwvWZI4AvMxzQhS4j/fnRWYPHoY3f4wYvOtL1pNPL3+3hO0/vIBfR14zfE1EgRyrd8Y7o\n", + "k/OTG2mML6YR4GC7bIeOrmNdr7GmPELi9/209koMKZhw2YQxaIQZjQlwr0b66VYiSssZMoYb6EdM\n", + "jsQTjedROVEjyuXP82R2vnfDMYYgY/NFkM8vtoL6AsLLZcGzCBi709SVF/1B0CBsXIBH9MuFoguh\n", + "aGTF0KnDq87sLgQiIuCookOxCGoXfGw2YDyM2yvfYlBFqNi3NNNviizu7e2lc9pi0iH/j4YEig6e\n", + "c6FRqVQS7fC8UQpvvfWWTk5OdHJyoq2trWQk8B4EXavV0sXFhe7cuZPmFRqBQvgRIlQ7n0zmSdv3\n", + "7t2TNA/tEQra2dlJuTjSPNfn7OxMt2/f1mw20+HhoX7pl35J0hwhwHhAWbrgo5SAI5LSXGHMZrOE\n", + "rk2n0xRKrNVqWltb0+7ubtrm7gUpye0CpeQaBoejDh72nc1m6XiZwWCgs7OzDGKzurqaSkdg4DCP\n", + "lUolHaPi4XI3yN3JcF5cX19Xv99PeUjSHGVbX1/XYDBIxSF97YNMQBuUHc/wyt/OfygFEDaMTLz7\n", + "arWqvb09HR0dJb7Y2NhIhUORCY7EYwCyNjyMzrPpI8Yt9zImHB+XffSZe11JTSaTdMTOZLKowo1S\n", + "IxyGUc08YQT6OqOvhHXdEeU+D295or4jI8gLl3/+O6cJfXUEKeonrjs/zWaLcDbPdic56hVH1Tz6\n", + "AO94OG1Z/7zvL4tGuA70cjRuzDnYIS3yWD0czDUHMBiDR1uYf3+u98V1lDd4BX0RK9vzzmhfeFgx\n", + "jpfv/cgb6B2d+9guyx9ctst22S7bZbtsl+2y/YztlVU2jxCee0ae8ChlD98FtoyICxatW+7ErTmC\n", + "w98LUuHImG//pzmUzX1StsK2X4vwqo8Ja53+R2iWPvlz/C/hBqzpGJaI4/PcIIctoQ395HvfXovn\n", + "EMNi9NNDavwmhrYcoSKUhyflYUlCL+4BuKfg+R2eqOyJxqB9HtbFc4vevHs/oBnb29vpHQcHB0u3\n", + "8ft5WXHuCWeBmhGmdJrwDEp13Lp1S9Icefjoo4/UarWSt+xhT1AuttQTbvzJT36icrmcEIBGo5HJ\n", + "k9ja2tJgMND+/r7u3r2b+vrJJ5/ozp07yft68OBB4rPHjx9re3tbtVpNH374oT71qU+lZ3Y6nZSz\n", + "E7fcxzCuo4NsCyfk6/Sr1+vq9XrK5/MpCdoriROWAXXx9QBKRYmDZWdNeuVveN5zU0DWfF2Anjlq\n", + "wTvdo/UxwrP5/GILP3PY7XZTkjo08PCG78bz0hkXFxfp3fBWDLGAHvmZYp4bsrW1pclkcXjv0dFR\n", + "Juxdq9WSbGR8oC9OTx+foz2OcEgvljOAN1xOsP59nnwnLs9knhwVhjfOz89TtCDKZvpWqVQyPMl9\n", + "y/oIvaUsEsh1wssuXz3E5DlMzoPwu8u0uGvP86J4vufUkccHDVyuQEvnN8aFXPcQGjohFsWkr85f\n", + "Thufb/76fVHWRxntNHfd47zq+sYjHvyW98XcMH+mp0wwdp8n15mOZMYcLQ8zgnzH/ERvr8SQ8h1d\n", + "cRFIC+jSt8y74OE7aWHoOKzq0CawJzF6h04hJIvCDRImF8HihoQrN4dG3QCKCtQhzBgW8LFFmFrK\n", + "VgYmLwQ6OoTpBp/XQpEWoQeHpRmz00GaQ/OEA3kXjXF435ctcIzYmOdGDoX30YUJRkSEyLnmAgD6\n", + "R6bntx66cKPWoenJZJIOuJWkZ8+eZcJGkUfjllzfYcUYWegxGZd+wVMksR8dHWXqKPEbxkjezunp\n", + "qba2ttKRNZyLRm0iwlTSPAx4dHSUduzV63X95Cc/kTRPtkbJrKysqFaraXd3N/HU5uamRqORzs7O\n", + "tLW1lZQXOSrQLcLt0MHHyBwyFxgSJNNj5PgxICh96j35jjP+3+v10vEZGC4YFdJi7RNK8zwpDHKc\n", + "LMoy0Nh55ZtcmFsfpysMd+JwNLiv0Wik0BUHX8d1yvMuLi4y9Z2oiB0ru0fnLobYp9Oper2eisWi\n", + "tre3085TjrdhPUAH5gLF48+D9h5Cmk6nGUOD8UYFSH+QNR6Sgaaz2SwdsoyM452e9xjrA/EvGgcx\n", + "vQF6QmdoGEO2LwurOU0Zq8tL1gP3xfvduWYt8EyqydN884anH/h46KOHTz3XCefAU1RiiobLQ5dR\n", + "UT/Q+J6wrBsd5Hl5LhLXyAEkdcT1NHzkaQIxYR3+WOYIw3PeF9dlnvLB+2JOqxvfDqp4SkVMi1nW\n", + "XllBTppPJpPOAD2BDSJwDWF7cnKScitoy4jlRI8txpZ9YlDIEUFzgUJjDJ5UySJmXPw/9sMXZrSw\n", + "fSzkSkmLAzLph48Pj8obAkpa1KGBrhg+Uva0dvdupGws2WlHczo5muRekRt+cVwkkMaF43zCczyP\n", + "iMKEPj6nSUycxfjGsGMbvyfLgti4gRPzASIqw/MRLNzruV6j0Ug3b95M4z8+Pk5b9xmrJyMjgNip\n", + "trOzk/oKz7I13Hdjce3q1avqdrsZgyiXy6Xjb4bDYRp/o9HQ6uqqRqORms1mJvkXI8gNKDd0oZuj\n", + "eIzBd8JGpKNUKiX+j3mTXD87O0tFKOlLsTgvicF9nuCNAHdHweeH30JrLy3hAtw9feiKQeG86Dtk\n", + "URaeqLy2tpbZYUfyMwYt8gyeoy8Y46PRKPGC96VQKGROrpfmMhEniPIJbBhot9tJRkUv3BW2O45c\n", + "QyYPBoNk4CPfQP5YN45u0Ffe58aBK074wx0txo+hRJ6bNF9vw+Ew7fzkWezYov+e78J8npycpHw+\n", + "rvmuO+acvjAud64iKs+8R+TCjVMvRcH7iDQgk2Jz3cD7MKIwUKKRwDhfZtS50euyHP70fDTGH9He\n", + "SBvWPQgaY+Qd0MF1lDs/HulgvplLd2Kcv3wOpMWOc1+Xy5x+tyfoCzTxCBfXvIbdsvZKQ3tu6cXd\n", + "BK6EmAg8TJ/g4XCYMXQgspQtyhhRHkcOHE7m/dy/bCJZ8PxzFIb+LjOy/H73ylwASNmKt7wbpnHF\n", + "xbsi4sL30WB1SN3hVA8n0D83pnxuXDHRNz+VO9IuevHU6IlG1mg0SoUKfRzMk/fXkTNpAcV7UiJC\n", + "3oWW0wIkBGHMOyPKiHJgLugTgtHnyeuXOALDc+k7ioqE6/X19QzShUEiLUI6w+EwheMcquaZ0+k0\n", + "HXIrzROca7WaxuN5HZ79/f2MwphMJnr8+LE++9nPZvh0ZWVFpVJJ+/v7L6CR7D6KiCT8Np1Ok8Bx\n", + "A9SdDmjjYV0PZTnPjsdjVSqVZMBGfmJdIDh9nUIznCw3bHgnOykdJSA04LtI4e+oXFxuuFCPaxEn\n", + "hT4Ui8VUGoECq6urqzo4OFCz2cwkW/NsP/8PmoIsxdpc1WpV+/v7ms1mKfSLAVIqlXRwcJAcRJeN\n", + "jrS6rJAWu+TYVYkh62iOe/XR4KbP/jze5aGfaNjRT1BZaMM7MKCiQeTP9rICIJw44258L5PRjuzT\n", + "R+R/lK9uGMT5j6g/9zha5rqEviOjXCYh1/ykj9hcTi4zxDwFwOcdvneeg97IIubI5wnDqlgsvuDU\n", + "evgbow8a8xzGG41vB1aWNfiA++KcuFHtCJ3rWH7rPOm8T799TLG9EkMKgRhDGFL2AE4fjCskFoc0\n", + "F+7Ao0yGGzYQE4+I5kwTIUf3ZD1u6/dy3YVDRE5cKLjRxjtdCHOPf/b3oTSXTaaH0HyxuTCEYXkH\n", + "IRpXdm4EITToq3sN0NIFJ9d8oU0mLx5QyTEi5MPQN1AB3hm9OgS3P8/r9rA4oA87thxxcwMEmuLR\n", + "eR4MNMUT8flw/nOkwo0anzdoQ60jDH88aUnp2AjWA8KB/pRKpRSe6/V66RBlpwUoE6hTPp9Xt9vV\n", + "1taWLi4u1Ol0tL6+LmluEHS73bQGOaJFkprNptrtdjoepd1uL0UjoSW0ccdhNptljDDPYcPo9XxE\n", + "+NBzqWgYp74e+X46XRwPE50dr6lVr9cz3j4CFT731AGQL5TCbDbLbJ3HSKTPUUn4Goc28F+5XE5H\n", + "wmDYOILdbDY1Ho/1/Pnz1O9ms5mEPmFIaEwlefoCrw2HQ127dk29Xk/dble5XC6NgWNjjo+P03yx\n", + "tqE1CBlHN0lKBpTvzIryxRVWlFWsaTcOeLcrSoyjOE8R5ZTmiHS/31+6sxraeuiGayhXdpnSQMBc\n", + "jsXwliOnNJANL8Pj6wNDD55wOvGswWCQdglDT/gqAgHIK48wuG5DntJ/50WniecK0Z+IskeECF3j\n", + "78aRWVtbU6PRSOgzzyT1wlMdoDe6gntcfsbUgEg315sxBSSO26/x1yM40UFzZ8hPqnhZe6XlD9wC\n", + "dQPDPXIpm38SjY6Li4t0ijmEcwKw6FHEoBggMRgcLohiMqgbGQgaFJ+HYaKFLr2YyBe3k0rZHLDo\n", + "DbrFjoewzDr3cBTPj6iYK2j3KmAoNzSWbTf1FvNHeD7IAO+KaN3p6akODw9TWBIa8Xs8dubZw1fQ\n", + "2o1oQjoYEs5PnmPnAhMDCQ/Lx+rJxHHufeMCvOiekAtdFB/0phwBZQcoBkl/oNtoNMoYhBge165d\n", + "02w2S2evMccIae8j/cEgoCo4vxkOhyoWi7px40ZSmih2aLK5uZnyetyD9NwiP1sMYe/oqKPNGJ7c\n", + "B51d2KOkl9UXQzjG0DpJyswp/MZ6psq6o1nUawLddofHc29AxRkHiBzKxBFY5AKKOOZVephvOp2m\n", + "Y2BKpVIqJkvtK96HcsV4435pgVqDTLlRXy6Xtbe3p83NTe3t7cnb6upqOoeRzQMuSz106coryiqQ\n", + "HEdrQY4ieuZORlRS0cF1g4z3ufNGMdp2u61Op6PRaJRxlnlmRCFidIB5jAoSJA0Z5nlH7oiC2sOn\n", + "HtaK6A9/oYPzDHoE4xyk0hGTZeF0nsfv3HiLzq0DFjTPeVtWlw955AYRNOE7z0X2DUNuQCN7+W10\n", + "MNwg8ve5PmOtRUTT5yKGbplfv+bhd3Sj0wlegHfd+I4GZmyX5Q8u22W7bJftsl22y3bZfsb2ShAp\n", + "oLqYFOiwZ0ycc2/ALWyPdQNpxriztAjnYFX6MSigU25p8zy8ZYfwHRWhD9LCK/XYrKMnPt6Xhe88\n", + "74P3ee7Fsti8o27QiERVYFCq9Triwnex7IN/F0OGeD+OaMUwnPctzkOlUklQNqEm3zkEZO0hSsYH\n", + "yuR5GdDXUR3eTZ7U2dmZhsNhJpQYQ8Ee3iB0Bz0dPYE+8EnMI8Lrgda+fd3REZAp+u5ek3t0QN6z\n", + "2Uz9fj+TX8Q6ICzmPMmOO0J8jUYjobEgIH4mW0Td+v2+Op1OJpwK3aiu7/0GFQNtdh6KIXPewTVH\n", + "Tz3PjblwuoNAkZjPmuD9vr7IJSH/jrmCVnjY+Xw+0cY3bzgCxzyBHHGUkCevwksgadAND7nX66X+\n", + "MffT6TTNE/PMbk4qvoPSeYmDtbW1TO7WaDRKOXf1ej3t2rxy5Yr29/cTXxwdHalaraYE/1jIkDE5\n", + "MsG1QmFxYgHzDG3gQw8X+TVQIa+iDd8gN6EV1wj1n52d6eTkRN1uN4NwIxvIvfT7QHaWIfggHPTR\n", + "5bcjzS6/YvgohsRIFvfIivO3o3sxRER/+v1+Zh0iYx0xlV48XHmZfqS/jvwxF/7OmM/lSI2fsIB8\n", + "9f44Uh378LLQv+809L4yZteLjnw6AuXoZgzR5fP5FGb06IS/j40oZ2dnaR3CB45EMU/I5J+7HCl2\n", + "RTj8D5GA9GLNjphQ5wbSeDxOYQhnWIgJ7OuGDIaVQ83OmD6hcSK4z5lLWoRFPIna4UHizDHPy0N+\n", + "McxIc1iS5pPrDMvv3eDhfX64I4I/JgE6LWL+QTR4vbmx5cbdsntJBJaUhB6LwJU39HRFGUMm0NaF\n", + "CwvD4V1PsPRF5H2Hbg4Ve/gC3vAwQhy750qg+Mrlctqqj6B2qNpp6sJlOp2ms+16vV4KD/JuD6O6\n", + "QpIWtXbIR/PwFRXDNzc39cknn6QxEuI7OjrK5IpAN54Td8eMx/OSBqxtDxl4cjrzi7MzGAzS2J3v\n", + "GHsUkl4ugDAh68XvHQ6HyWiF990gi+vS83I8h46cM8bPETC5XC45R9KiFIXzCvzlxr7ngklzWcjB\n", + "yBhCXKvVaiqVSur3+5pOpyqXy2l+STR22UHb39/X7du3VSqV1Ol0UvkFv95sNtVoNDLGCXzLnLsc\n", + "JGyKzImbMlxBY/jF/CJXok5/7keW+mYh/7uyspL4s1CYb9bo9/tpJxxzyCYCz6+j8Q4PQ3sC+7L0\n", + "DJ9fl9sxrcHlko+d9Q6Pej4wziCGD/PkMnFZfk50QDx86e9nrG68uEHnSfp+v4c16asfneMJ3m5Q\n", + "xYaco4+e7sDYPOzpciJuGvO5cWOXZzM2aIWD5SkG7vy4HGJM0MrlKDSJ4Ie3V2JIocRcAPjCcqXE\n", + "dwhmGCjG7skV8YXo9VhgYveSPLk5xmqjZezM4p5LNPBQ7iwYjwfDoHGBR2TImbtQKGTQBhecEWWL\n", + "dHRh7n2jP57LED2u6I25UetM5YsnIjf+/5gzMR6Pk5JqNBov0MSfj2CGyb2kQMxXiomUHrN3Lxih\n", + "iVKFvi7oUAq+gLkHgcIz/YgdjPZogJPn4Tk4Ths3lnnncDhUpVLJCBrnzdPT04yn6M/0hHgXTKA1\n", + "pVJJw+FQx8fHyfu8du1aQntA3OBFDghGeHnuTqPRSOPb2trS6elpymdhNya08fPkoDfjzuVyGeMU\n", + "wYgA5j6SwumHtMhDk+aKn0N7QV9pjImSEX5+5enpaabGVswJmUwmOj4+1vb2djr4mb6en58n1MsN\n", + "8F6vp62trYSOuhJqNBo6ODjQzZs3VSqVtLe3lxAplECtVkuGgj+fPmJQ+zN3dnZ0+/ZttVotPXv2\n", + "LJXFIKe00+mkg8PdwHb5OpksjmthxyLXWAtuSDuP5nK5jOxxxZ/LLXarYZiQ67gM+QGJdh7GMWKz\n", + "kdP0/PxcvV5PtVotzYM7Zi4jPB/RDazYD4wol2M05A7PcWfax+y6gPfxGz67ocx6eFmeGs8GdHAe\n", + "d2cg5ke5g02+IM375jIN2sOT7vQgn13murEGzd1A94bcch5GLjA2jClpsS5wkt2I9dyuuDPPHQD4\n", + "hbEjW9BNTjdHFV/WXokhBdzui1jKLjbpxeJhy7wF32be6/XSdmLu9+fjvUrZM+PwFPmtJ8H5byRl\n", + "mAjjLFqvTKQzjPfXGZlxw6jRK5eUUY6erOh082fxPh+jCwnGiJce4WM3fvy6tEBsXDi4R8f4HYWg\n", + "Xxg18ZrvluFdKAyEK7zi97KLCMM1himZI/ruStiRB7xFSal+kgtXD28u+ywtFjfC2Xd9eX8wpNyL\n", + "wnhgTXgjVI1g87nGcMHoiXyI8wE/+UkB9Gd/f1/5fD6dxTadTtXpdFKZinx+Efaijg/PGQwGmZDs\n", + "eDxORh9JwJJSwjSGhq81+AgB5vSl0KYbbnjsfOcVwz1MxWYCykCAwsGf8AAK2qt7S0rhLxwZeIH/\n", + "9/v9zDolJE3BXFcm5XI5hfXG47Hq9Xqm/tfFxYX29/d17do1NZvNTKjJlbSjqNT6OT8/13A4VK1W\n", + "S2gNu5ifPn2qzc1NXblyJaFdhEdxAiPywmdkH/10z34Z8gHtHAHhd+74uBNKgy4oTXhqMBhkduau\n", + "rKxk5IKHoXw9TafTtCmDNephb5Q78tbRDHiS8bjyhDej/JayDkFE4pAvrHNf9yh7N2y4z51p5zV3\n", + "fn23myMtbkR55MLrWPk8Mj/u5FGfjHc6os9ccj9GOQ4j13AcXEY50oTxFOfQHWD6HA1JlyFRJmLc\n", + "xbIyjrTGqICnvTgfuC59WXslhhQMMxgMEoTpuyJgDI/PuwXqCgNisBiBIKXF4nfUwKvmRqQlQpxu\n", + "pXpD+HPNJ1FaCHnfbcFCwRiKhddYaNE4cW8zekku3OJ16BghXxo0xnJ3A9YZk2fRyFECJXMER1LK\n", + "VWARuOGG8sbQ8mrmzIUjTtJCQYGgOPODqJF75EaGG4DLcgG83EVUJih8Dzf4/PpY3IDl/cViMeXl\n", + "+OJzIeOK1qv+giJh2OBpOr85n1E2IvKb51xFZXJxcZGOXGEOaaPRSMfHx2o2myoUCpmQEDQpFovJ\n", + "iPKDgKfTacZo4RphzZhTJCmDTETlPZvNUj5iPp9P6BvPxMEZjUaqVquq1+upsGg+n0+5Qzha7rFX\n", + "KpXMTjjeSSXx1dVV9Xq9NFfQhtw+cqRAwAqFQkJtQEC4Ro5Po9FIxU85HgjlheLf3NxMMsrzNzwc\n", + "CG2Y37W1NR0cHCR61+v1NEftdlvXr1/PhJPgW5QhNEWZsT593cN7rBPWoaMwUS77kTVuPDgaKy1q\n", + "ziGrmRfWkhum/g7kIs/3UDJyCEXqSEt0LB2hYh3jlHm/WW8Yd97cKfOCs47cwa/uYMfwFY2ixC5H\n", + "o4L3yIwjbdDKIxfRCIhzTR8wrqFhNDIdJPC1DHrtckxaGEE8MxpSGDvIRm/IWHSGOzQ8x1Ej7sFe\n", + "QCZ6mBSZHp0Cj4TRF19vP9eGlFeQZSAxP0palA7Awo6TCMNRh4OQAswCsSaTSYLiyTvBYHOhwXMj\n", + "yhO/xyCKFr1Pki/gyWSSOVfLkR9fNBGxkbQU+YpxbM/9wFBwL93H4guc+L8LFH+/zwXv8JwWZ0bC\n", + "PREG5zufLw+9IjThgYgigYa4VwqcDHJxdnaWKcCJoPctzNLCAMNbKpfLmQr0bly6kYERFI+qoJ94\n", + "VuQSDYfDTMKml6/wZGQMXk8kduOfMYD2uIcFXbnHnQCEKciNC0OQXHdemCcM1uFwmEnu99IUuVxO\n", + "1Wo10QLjk7wcSSmchLFHWNCdCJQ568jzGMfjcTLMHAWF7ryfJHxqdUU+HwwGqlaraS69rg31tZin\n", + "wWCQ7u12u5pOp+kcRtBBDHdXQvAO/6bTxekLhUIhhT7X1tb07Nmz1JdGo5Hqqk2nUx0fHyderNfr\n", + "GgwGGaSVvnmdp1KppHq9roODg0TTZrOpWq2mfr+v/f39NAaUGjSM6IkbTM77HiJGFruTOpvNEtrI\n", + "d/7X0xBcLrjXHzcMQAfqRbEBgrkZjUaZUKSPYzqd16wrlUpJefoYWa+OgtCgj4egoR3z6WuG/jP3\n", + "MV8PZ8XTSOhL/C7qC+gR3+UOEnPuERs3MFyfYOCSY+dGLX3H2IuOOfzip2JwzR1WB0E8jSIa29A0\n", + "psHEecBJiZEap7uXICI1xulEX7Ah3N5wurtB7AjVshCpt8vyB5ftsl22y3bZLttlu2w/Y3sliBRe\n", + "gO+0kBZbX6MV7TlKeNNuffN9hDB9VwLWJ3A5Xjx5Jx6iW5bI7qiWtIBVydHxPvgYPHTI/REWdm/T\n", + "UTfGF70/moevsLCdLuSL4dXE4nt+5EcMYcatqIwxJgo7hOyeDP32Pjv0/DKY1HMWoBdhHWjl7weV\n", + "wrPzHVKgMSRV837fnUSI0mFwD3sug8Qdqvex0Rc8t5jo72E0dng6rUHQ/Nlra2tqtVqZ3V2OrNBf\n", + "iksyRiqT5/P5dOQJYyyVSqpUKol3IuLIswmpgOKyY3AyWRSq5BqI8MXFRTo30cP2nn8Sd5uCUJAH\n", + "E+kqLZLAHcGQlBKxybPjPfSPhGkP33ruWK1Wy6QY1Ov1FAqqVCoajUYv8D6J7s6LJycnKhaLarVa\n", + "6na7mTAmsoudkq+99lpCViiWWiqVdHh4qPX19SQTDw4OVKlU0rsIG0pKhx8jc6rVahr706dP05mJ\n", + "XOeZV69e1eHhYUItnPehvW+2iOkOPmcgbMyHh1P8OdzvKEoMeSMvHCUgrM/8np6epkKmg8Egg675\n", + "/DoSS5jJ+x+jGTTPxQK18DF4WDLK4xjCYwzwPv1zPcP1ZZEPR82ibAaBQd5BTx8Lc+n5SdwbkWrX\n", + "ey77PFWCcSM3HXXztBX0jaNuUVbGHFPfUOP84ii0I6TINdYDaKjzgYeLvaFjY7qOpGQLsK6ivv25\n", + "C+3FGKa0UK6eMOehplxufvwF8LFDtcCsCGlCCoPBIC0OzwPwaw5B0iIM7TkULlxgSodlXan7ex36\n", + "dYXuY2fBLEtW5Lozt+9UWQan03dnZn7v35Mo7MYbv/N58P4wB77Io0J0iNeVNXT1kGAUSjGHjFwY\n", + "jkfhORGG9dIAHlJgx5TPdb1eTweeevgPvvB4O2N3g8WFF+En8gToj2+f59muVBgHApYkbXgYY9F3\n", + "FXpI2JPXi8XFdl5Ch14/zBUkpwF4/See6YKVXCBo67TxHD12XnIYrNdzgx7wjdPUQxf8DpkQwyO9\n", + "Xi/ljjGOXC6XzhR05c14PXXAeYlQKPLEE3AJA8Y8P9Z+rVZLfENeEnPELqjRaJSZe+7v9/spnCfN\n", + "DaLz8/NUCoQdgZJ0eHiojY2N5Ei4bMARPDw8VLVaVaVSSeHJ9fV1dbvd9Pn4+Djxz61bt5TL5dTv\n", + "91MI10PM/GWNunyGfzG+oowmpyY6oi7XPOeM5o6X50Exp+R8EY6XlGrDjUajlLvmTjnOEmvbZY3L\n", + "QDd6uMfTLFwuYZygxD30487ksrFhfPn1ZcaXG2D8nv5CNzdeMWzcifbwFDLM5wSZ4RuopGwSdwQz\n", + "4H1fFxHMcMPG86DizmKah9wY7wx+SQAAIABJREFUl++q5xr3MgZSBFZWVpKj4yUpXH/5fe7AR31J\n", + "fx3kcN6PvBDbKzOkpOwuGBYRdYGcmX3LJcmgL1P0nkPiyjx6JeTHIDTiuUu+8GPekxtlnrPjkxhr\n", + "QblBgYG1LHkQL3qZVx4T5bjm8XBHvlBQMLAnrFIXxlENV7RxzJ634h6sN+aM/i+bFxceNM+PirRh\n", + "HnK5nLrdbsqVcrp4bg3KC0VG3hxJq4zPhbcLOEfpEFKMHYTPk03dqPYYPAaK57RgZCGwobcbsvTT\n", + "BRi5IPCUe4l8T/I0yoT6TJ7PQp9Zc8tyLVZXVzM5Z9PpNClk3wQAT4DkrKysJHQqn8+r2WxmjkXB\n", + "AHFBzrW4y8Z3zuXzi91lvta5JikZyZPJJPEGyi2XyyWEzNFhp3m1Wk1jA7mMNIE3ML4qlYqGw2EG\n", + "kWN++I0rfWQF6KDTEsOsXq/ryZMnqVDt5uZmMtbK5XI6MkZa5N00m03t7e1ljGj4T1IyPNvttiTp\n", + "k08+SUgaRnJ0zNit5aUvkAls5kGmeF06X7P+GUcJ5MmVqSu9WEqmUJjvMPRdYr6ZwlE/5Dnvg2/g\n", + "gShvPJ8tlirwxPeYa0S+oiNLEUlytMbf65EKrsX6bm4AeH+9MU+uB6Nzwl+MLXe+3DF3HUxzpMkN\n", + "jhixcGQPGTMajTJG2nQ6zaDvEamkkVwfEU7klveF/FpQc0kZxI17ItDBvLpucoAk6qWov6KRnKHZ\n", + "S6/8f2oMxFGZWI5AUkIV+v1+ggJpKESHh6WFx4FH4krIt2iyaNwzQcm4B8YznUncM/EE4ig0HKJ0\n", + "b4FrrvSk7AKMi8sXhe9MdEaAWfw7XwiumDAWfFEiLFgUy4w+3w5Lv/BYfNsrz3SGxmjmmgtCn0Pn\n", + "jdFolDz6+Ezm370kdmx5ojH9dAPI6c32dRCX6IWMx+NUksGVLQYS4cJlCZQo6Bi+5Z0kS/sWZVcK\n", + "7F7knWwBPzs7S4nRCBZ2tXm/3OtCaLEVnvuYF++/hwTZxeeGCX2B30iqd14sl8sZoy0meVYqlYRW\n", + "0RcMTujrCac8k3n3Q7AZBwn3IDaEWkulUlLM3O8bHxyRjggGic/senQEwWUGoUinD8qg0+mkWlHS\n", + "3NjZ3d3VbDbT/fv3tbOzI0m6cuWKZrNZojk7CRlDr9dTo9HQxsaG9vb2kgFG+BejbWtrKxlgBwcH\n", + "6axFjAZXvI4yu7zkr4dpMUi5Dt2QKS6n3ADC2OQZvvYcdWONMPcbGxvJAOVA53a7rcPDQ62srCRj\n", + "cTgcZvjMDRR39DCMXA7TX490SFl5DGoa9YDLV99Zy7hdXjlN3QD19/g8uOHizv0yxN/nCVq70+nl\n", + "Ynwton+Q226cYbxwn6PYLkPRl5407yUfPNrgG2TcePP+05/pdJoxeqITCA09fYK1HEGQSKtItzg/\n", + "6MMIHGTue+mV/8cNQeXKhIUdyw645ctRCfFIB6oMe26PL14gxmgQuNXuXiJ9YzIc/vZQlgsbXzTk\n", + "YdBceCDk8PRd2Xp/JC1V5jFMiWJ3w81/Ez1FWoSP3bDxMGS01KGVIzreVwQgNJdehEljWAx6uoHp\n", + "42XhttvtpDAwXD3M5M/kO4wTF94uBCP6h2EJH7pQRMCAzMW+QuMonJ2uvBN+IwTFNb6Dbuz0xFjg\n", + "Nxj1IBxxjNDTlSD3IRQpPgl6QpgJHq1WqynshLfJM30MhUIhra9Y9gHUFvQMhIY+wS8YN76O2I0H\n", + "Es2acdRZWuzwoiFHQDMckaTvGKWuAFdXVxOS7Uguz8TYoJinOxHkHcYdRqCpoH3Hx8eJ3q1WS7lc\n", + "TvV6PckE+lksFpNRUCqVkpHOGDgCh/wSP3amWq1qNpvp9PRUR0dHKSS+vr6e4a1YooW59TAufOwG\n", + "V2wefnJji/44oo1xxDXWE0rXDX54mPu8LAxGfrlcTv8kpSKdONCu9EHumFt3CN2QQbbE3EkQJEel\n", + "3UiIYSDeH1Ef7nNDwNdMTPFwow5UzGWypAzi7iF71yfMN7IR5JG+uuPsO3ahG2vSnV03mvyvzy8O\n", + "Bv1j/CCX1WpVuVwurQv6Dh3cAPIwHjI/6m43imN40sOMEU2MMlrKRlpe1l6JIeXK1xU/lmycfP4P\n", + "E4BOcB9QNZ6gG1BMeNweHpnWlZgXFvNQjLTwLN3zcmbzyXBhykSAvDgi48qEMUbPxQ2b6CWxEH2x\n", + "+W9iAiA0RRHEfCYXoPzWn+dJrE43+gJNvfRAhPBdaHk4D2Xq84QhRyiBRN1Wq5UWBOEi91pIUpWU\n", + "EqGlrDCP6JcbHs5/PjZHIL1sAsYyOTh4kjwLtMYRU+6l/xhF9JuQIOGfZrOZoTVIEIrd+wzNmM8I\n", + "+TMfrrzK5bKq1Wo6wmdlZSUTLoWPp9NppjgnlcwJxWD4SUp/XRn7GkVpw08uFFlH8KnnOyDo4TVJ\n", + "GZTUESi+4zesa/rkfOMGrgtU+gji5l4q6xJj1uVLtVrVxsaG9vf3M4i4ND+updPp6M6dOymx+ubN\n", + "m5Lm4dlcbh6a3NjYkLRQlqyhQmF+VEq9Xk8IGDWUSGAfDAYp72p9fT0ZLO5QwI84gIzHUQdHOOLa\n", + "iblobjhgrDhCEGUYdPU1y/PJsfFrg8EgI/fW1taSg4XDRT9clzCvzoeONHAmZwzbuTLGMIgIPk5b\n", + "DHO6U+eOmZTVbV5KBznEO9A78EA+v9iA4+gTz+T9OHvu7COLGBv9iY6Yr0UcEUdefV3wFwPPESJH\n", + "nx3hHo/HyWmDnu7QwROu+7iGTmP+IoAA7ZGPPpfuOMQxLPsd8/bTEKnL8geX7bJdtst22S7bZbts\n", + "P2N7JYgUHjH/5y/oSYzB+v/xTN0KBk4HGsTKBBWQsltipQVUipfkcDQokyNDHm4gqdg9EknJK8GL\n", + "LRQKS3MvxuNxpmK0hyVizNif7+iMtEBWfBu209h3UWB9ex4JNC+VSpk4NgiG5625VQ+aViqVXoj7\n", + "S9ljCNzDcm825o/xnBjXZi58PGyB9u31Drszv4yj0+lkvA88Grxsz3uLSKUfseJ5EA47S1rKW/48\n", + "xgBE7iFozgoDbfDjR+r1etrizxhAYz1s4Eiu040QBXzCuNwb9VALiea+bZrfehI8eUfHx8eSlHbU\n", + "El7xkCD9ogwFHih9cWTJ+8k4crlcQr/cS8Rj9nCDIyMcqUIyuXudyAue4+iuh3IdqSUUCv/5/FLI\n", + "FP7yKuy1Wk0bGxtpLgjJwcO7u7uq1Wq6fv26Dg4OEuI6nU5VqVS0tram/f19VSqVTF+YPzYjkFhe\n", + "KCx2W167dk2dTkdPnjyRND9LsdFo6OTkJK1xRyuQXR5i4X3QBXkTc+v8rLwoH32+l/1lHhxdZA6J\n", + "VCDrnS848cALHZfL5RReBmGLaSKg376GCUsPh8OUauKyDVlKzpfvEuS3RBw87EW/YxiZMTv/uc5z\n", + "OeKoKSH0KO88ooKcyOVymfWETGP+HGXxlI6IwjjS7XMlLVAnZImvs5iDxe9pKysrqlarGT0F3Xxe\n", + "pAXKGVFG3zDhyJznbPE7Px7M+xTnxHmWOf+5C+0ty4ORsnkt0gIu9tAPBPSdNAzQt/T7NReO0UBx\n", + "5ReNumVQnicNejxVyu6mQJF5zJw8EPrpApm6PlG4eZiTd8fdA4QjnEFYZD6u2Fxw+liBaGGmeD/z\n", + "FMMtbEP15H7mwuclhtNeZsTQRw/DTKfTtFOq1+slujHHbmRiBCAY/UxAr4DuNAKyxuhxQepKnJ1L\n", + "9JOcMeD4yWRxBE5s/M5LGpCbE+FvnoWy6HQ6SYB7KIF+A/djPBDmITEb2niYyoUG9Lq4uEh5Ni6I\n", + "vczA3t5eorcf48GuNnc+SH53GktKSeh+/puHMPr9fgrNuyEFHQmzESbwUDJHuXgCqjQPCxWLRTUa\n", + "jZRb6flT1KSify7AJWV2SMK7pVJJBwcHKcdpZWUlnW/nmx4Io/phz81mU51ORwcHB7p69ap2d3cl\n", + "zcsW5PN5tVotHR8fq91up35Wq9UU9sW4g1cbjYZms1l6no/96OgoGRrlcjnxB/zE3+h0MR9SNhzH\n", + "OOAZtqa7sewGmPTicRueL+WGDc9uNptpo4krZXLSqLHG8UCc0cda9PG7gYCc9XVdKpXSDsnhcJg5\n", + "box59pQP+k2/MCqiEUAozvOuWEse2o9pBp77CR29KrnT1+mIYeWywmnMmvcNQe5g0S9fs562Eg0Q\n", + "D126TuR3LivdGWAd4czGtBzG5XSBv7y5rOEdkS5OG/rJc9zgjnMHryzLc6O90mTzuPXWDR4pG2fH\n", + "w4GJ3fOGqRD6nguDIuL5TlQEeoyhwiwgTO4NYNTwTGcoR1RIzPMcAjfmPOmTmjRs54yJqjC0K0LG\n", + "7tvmoyfA/f5bz+lxo89zBYg5+5gjbfB6Z7PsjifPt0HQ8X4fU/SEY86Fo1WMP9Zqgf4sYgwReIf+\n", + "nZ9nz3X0vCHmw/OePPfC0U9frNFbjXF8aObCgO39GE6ef0Bx2uihgiyQByUpoT6+MYO8KlCg2WyW\n", + "aqX5Thv6QpLuxcVFRmGMRiOVy2W1Wq0kaKANNC0Wi8mYhaYIIBACzy1y4344HKbDpqE3zgWoI/y0\n", + "urqqbrebHAWKjNIXeAjB6qgTieascYxRaa4M2+12QgZB9Hgn84FCZJdot9tVv99PxoLvoiPHo9Pp\n", + "pKNy4Nd+v5+UKIoWJO/s7Eybm5u6du2a9vb21Ol0Uo7UaDTS8+fPVSqVklHrMgSDYX19XblcLuWy\n", + "YXCRP+U1vfDKJ5OJGo1GRsaCmIGauqz0HEyX2e4oMo8Yt3G9LHOgmRt36GJOGrIBtAia9vv91CeX\n", + "O9SOQjY67/OZAqY+BpzRXC6nZrOZWRedTiedh4h8XJbcHQuAujPtiBbrkH6Px+PMXHgNtojgRxQZ\n", + "PeXyGsfTaUB/XGe5IcncO/rt8+VoD7/nGeg+zyHzOfRIi/PFbDZTt9vV5uZmJtcpRgEimuybuXw8\n", + "cWxuKHqL4AHothuKnieHM/iy9soQKSlb/A8C+4J16NQ9nejNO3waCelM5Ra/MyLMHqE792p8dw7/\n", + "PITFc9yIiAmO/hnBIM0X/mAwUL/fT0aBG1N+GCpeOGNA4HOIrHuRjCuGeHim0xvPXFIKPYAwQQPG\n", + "j1GGcojhBmmx2D1k4uiGL2D66ugh9HZUCKPNkwW51409voM+9B+0JgqVKNxZUI6AMk8YtvCLe/GO\n", + "SlGLxwWqoy0ejoXPSbaVshX0p9NFUbtarZbmfzyeV98uFovJwHEDDFSJPkLTZrOZFO/JyYkGg0ES\n", + "Ehg5hIpWV1dT4i5n2rHrx7fw5/P5lGgO4uKGryN9zsMgUigD3+aNUYPR53OOondDilAP72TcGHnQ\n", + "FgOy2+2q0Wio2+2mOQBJG4/n5/wdHx9nPFPO4ltdXVW1Ws0Ydvl8XvV6Xe12W51OJ+2UW1lZ0fHx\n", + "cQZ983PkDg4OVK1W1Wq1MsjSrVu3NB6PdXR0lMocEPbb399Pa5jq6Kyt/f39tFmg3W6rUqlk6LK6\n", + "uqrBYKDBYJCKXcJ/Kysr6vV6mfCUtNi2jtzEcHTHwefbP/MdssjloPMEz3Sd4Oi/8/Dq6vxgb0fB\n", + "kb3T6VRHR0dJHziS6YhJDLHj3PCbZrOZ1tPNmzd1fHysw8PDF+QIhtrFxYUqlYoGg0HqC3ICZeyJ\n", + "2NAIGRuTpplPxu9hPJfdIOz+e2SNI/qMkZAfutPlq6Pb9MPXk8vVmMqArHW9znwv07ukTVxcXKjf\n", + "76eNELwXmhJdYI3GKEnUwf4XR5r/u33gupKIhTvJUb9EFMzbKzGkIAQCi8YgY4jPF/HLYpUgDD5g\n", + "z8dhsh3K4zdMnuc4oEBjuXgEOOEAP3oEIenWuS+2aDnzvmq1qmazqV6vp06nk6nDgXKMuxHoy2g0\n", + "Sn2M6JiPCUMFj458C6dZDBl6PJ3nubEgvbibhLnyujnMoSMI7iWw2MhVi8YwjOwhHK5hAHqoVVrA\n", + "scu8ESlb3iIKMJ8zX1DOBzH0598zVje0YtiVIy68IcDc4HT0CCic+6iQzeGsoJrc50aXI0tra2s6\n", + "OTlJlahBoJjPfD6fUI5er5cEGErm4uIiGVkuMJkXFI0LftYSv4EvvX9eYI9GYU/oHUOJjh572QWQ\n", + "Dectp7OHElx5g+LBF6enp3r+/LmkRRHQ09PTNEavebWzs6P19fV07AxrrdVqZXZFOnK4sbGhp0+f\n", + "psOJq9VqOnz44uJCN27cSEprPB6neep2u2q326meVb/fTzxYr9fV6/U0m83UarXU6/UyW/xbrVZ6\n", + "jit2jAsMIb/2snCfI66OPLiB4msoOi08N4ZseTY8RmjPHRMMH/8nLQwi8mEwcrmG4UFZDjfqKVHB\n", + "+mUOqWO1sbGho6OjVM8QfnLkGqSLsftY8/nFzjRH4h1NlxaIK0rd830xuqCdGzI8F752xAuecmTL\n", + "6Y0+QFZ42kbUxT6PPB+eiXPsURynB/IRtN2dZJB4R/lorAU35J1PGTeARPyNj9vnbDKZJEfKkTv0\n", + "yM9djhST7MRxDxxl5IrGjSDPhaEBWfs1FiiCiDCCtEB5IJIr71wulzGm4nZYJhzP3WOxDmnGpDqY\n", + "31Ei7gO+r1QqyZiiRcVMX0lQBhWKi9Yha5jLoXGO1oiJyowD4RAhfBQasCkhJ4e3PQ9HWuRPYfVH\n", + "i58xQlenNwIHujJOX+TRiOY55IBEYc2z3ZD2732R+n3D4VCz2eyFGmCed8AzvK/+1w1Kfyd5VVQq\n", + "Z+6bzaZms1ky2kE6CoVCCiVBJwwUN7xIEmecFxcXac5qtVpGQVUqlVS8sd/vZ5AlQkLr6+tqNBov\n", + "5EJgnNIPFBRhR5CoGOYFvcVodIEH71LTyoU+1cOhJ+UXnKdc0TAOeAVFQZkH3nl+fp5o6qgKYc9i\n", + "saiTk5O0hqDbZDLfCNFoNLS+vp7Cn/1+X2tra4kX8/m89vb2JEk3btzQzZs39fjxY3U6HV2/fj0l\n", + "jTO3IJWj0SgZCxsbGyoUCjo4ONDx8bGazWYqcXB6eqqtrS3l8/mUDwafQjP4z1MOMJqZy8ifHhFw\n", + "NAReJNcF+YCx6bIPnqb5M3yN++eo6Jknz9dzY9kNAXiLZ3iVexwUl5PkjzGv6CCOPiqXy2o2m5nx\n", + "EK7O5/PJIIghZuS3K3b41Mfocvb09DTj5PlGCtaJy2k3pKLT7mE4eBoecN2L7HXHi2vISpcl0iIv\n", + "zKMuzjv0B0fYZQbzNZ1O1W63E91Btd2I4ZkR+VwWVeC96BRo6sgaz6Bh0LEunJ+QIS9rl+UPLttl\n", + "u2yX7bJdtst22X7G9kpzpDwvya1ELFCsXodmsWrd4sfLixWssdJ5llvYeB+gEsRheSY5Jngsy7bz\n", + "Az37zg7PoXFvi/AbeSTAuTwLpIIkX3b0MbaYM+M083HF/B9P9CQZVFpsscd79G3+9A1vyMOXHiKI\n", + "oUB+47C2Q67QGfSJRjI11z3h3p8B7UFTqIbrYTV+U6lU0vM8KRUe8pi9o2N8xpMBMfG+4hnzDnjN\n", + "m4cbuc5nQqCMkZ2HhBocQSAMCM03NzczCEK1Wk27lnyMlExwpCgmvfpBtzHZ/vj4OIWqvcTB9va2\n", + "tre3k2fn/AbsX6vVMonMIDyE7xwFYN5YS77DDvQXr9l5n3dyD0iXh2JAoxmHI1148iAT9JXQz3Q6\n", + "zXjxtOFwmPG+KWMCPc/OzlLOErTFm87n86kUB+NHLlSrVXU6HXW7XW1tbaX5JndyY2MjMxcgH1ev\n", + "XtXp6alOTk7S+xqNho6Pj9P6cH4vl8tJZlar1RQCpPnpBhGtZQzuoTtaxPeeH8Q1p0MM+UOPiM6A\n", + "0iLTPbTL+6rVakIuaCDirGtHxkFnhsNh2nrvaF21Wk0hPtalNA9FHx0dKZfLZULi9AXZ7yVCoCdp\n", + "Dsh735zjsssjH15IkzXsCA7zgN6bTrNlQ+I8eiPC4JtVoM2yXDI+cy9z7PPE/TGC4yHG2BfWGCiY\n", + "hwx9Fy3NUy5Yo8idGK70MUTZDA966oXThmKv0GIZChfbKw3tRXiQheOTICkxL/DtsoXoytYJhyHl\n", + "ORP8zkNInjhOTJbPnpDp7ywUCpm4rm+H9rCgtKg2TG6Vw6D0DRrk84ujMOgD43f6xHABz6ahiFgQ\n", + "hLukeS7IycmJarVaUnBc4x62pJOgKGW3lcbjPpxpPWeCvjjMyuKSFiEcF8o0n1voxHXCEB4GY34R\n", + "hvADCpBn+sLz8BXX4T8Ox2QOuE4OQ6zD4mFSD0V4/pYbbdJcKcLbhJY8QZKq1hcXF5nq2OVyOSUf\n", + "N5vNTBVfNyIQnL6rqdFoqNVqpfXhQhrjoFQqvXCcye3bt1NYxQ0+nI21tTW1Wq0XDGDWQrE4r8UU\n", + "6cZYPckWGlIXxw1Fz1tjXJQEkOY5RPQD3o73YLw6f/sxOIRW3KFjDDyLXCdoQgV6D8PBA27c+4HG\n", + "bIm/evWqjo+P0xomv6ndbms6nWp7ezu9jx17udx8h5lvVMDR/Pjjj3X//n3l84tK39Cy1+upXq+r\n", + "XC7r8PBQ0sLZ8ZIgMVzEPGD4uAxHkcawoCs3NwyYC3eOPZTF2kc2uGL3UguDweCFGmOeUiBlD1jn\n", + "nUdHR6pWq5lD0Ak/k2bBfa1WS/V6XU+fPk3r2nOkMN7gWc/Xgmb0P4a0uG82W9Tvwtl25xQ5h2MM\n", + "cMCzYniLMgluaBDq9PxCGjTk+S7rXSaTvxyNWt917noQR5nP0bBBPjmwwjy5/nCZCP/lcrlM6onr\n", + "yJin5uHFGIrkXujkub/sRP65M6Q8UdStWowCz12SFrFQj4W78I2eavSE3BuAcRCgeFGTySQJ00Kh\n", + "kMkr4WR23he9KE/o9t11rtjJV3Cjx/MLXPi4scA4XAnH+DuoGEYP78N4cg/YE4exvGu1WiauD5OR\n", + "D1KtVpNy7ff7L2yZdgZzIzkuVOjmNa6krLBbhjrgWXp+EeMnd4aFzDg9iXk6nWpnZyfNr3tgvkCZ\n", + "Cww76Oa5bCwwhCnjw9vybceu+MkZId/H5xihiVDwhHqMY99Vxv/Z5o4RRa4G7wPlmUwmCdWS5krB\n", + "k4o9H2JlZUWj0Ui1Wk29Xi9tTZbmeTnkEZBb41vAy+Vycjp8Vw9jn0zmW+7dqPHET8bl65fdSPCA\n", + "K0hHEjF6oJsrAebNnaGY/8Y4jo+PkyxgV6rnSoA+uNEhLRwxch056w0+Y/yVSkWNRiOjIAaDQVoz\n", + "d+7cSWj0cDhMOWIrKyva3d3N5MCR/9Rut1Wv19PYz8/P05w9f/5cN27c0PXr1yUtjhyazWY6PDzU\n", + "xsaGrl27Jmm+2w/aMTeO0mNMIWfoG3yDvMMYijtQkZfuUPFsd2gj8uLN6wdypA7y3XkYeRELZIJA\n", + "sc6Pj4+TbGfn1tnZWUJrvbwHBpc7UsxT1Gc0lxGeCwhfoNMwDlzWuG7DwZKU+os8BBTwHGJoiqzx\n", + "eXJjyR1VdIUjUzGfDQMK0MObz2vMr6pWq2lzFAaozzXvjAY4SJYb4xhsroPdOYVW0N6NJc/txRnk\n", + "/egnDD8cZ9erL2uvrI4UzVEIFIkbSdKCyBDWEwtRVjBEJJq0UHIxgcyTes/PzxMKRKVgdu240kMJ\n", + "wEg+GUxqnEhpUaOl3++niefd7gVGhM3LC0jKKBPQD4eMPdnPBZdXv+b69P+w92bNcSTJubZXFdba\n", + "CwBBsls8PdMtyWQmk270/3+HTBppemOTxF47tirUuajv8XwyAM4xmxt+FwgzGghUZWZkhIcvr7/h\n", + "8fSUBQ9BXxhT/oaR93Wz2SyVhh0bI4U4o54DPscg2ZGwYbNT6TF8CYp9eHiI+Xwe/X6/FmEY/h6N\n", + "RnF3d5eLESPsiNpRsN/Z0Q6GA6NoObTz6OJ0VkRcV5JcQQ5RzhDO6SvXHR4exv39faZ3cBym02mM\n", + "x+M0pBFVpXFKHAwGg1rKCDmkFADPA+WcTCZxe3tb21aPs2qyqguAUnDSBFjmje97bCzDODuHh4f5\n", + "fRwyI0fICagdRTg3m00SvekPuqR0epvNZiyXy0z3eX0Nh8N4fHyM33//PW5vb6PX69UMJrLKVnfO\n", + "d8MIg1j1er0syEn/jTpjlCOihl7d3d3ljrrLy8v44YcfUg/d39/nPb2eKYtQBlHff/99XF5expcv\n", + "X+KHH37I50HKJ7jj/XAiTIou0/Wk/HkXZw0IPrneiBx6qly/DprKdCHvYqfYz6NsDDQMnD7QIU4M\n", + "cCBhvdtqtWI2m8Xnz58jotrtt7e3F91uN25vb2vfjYg4OTnJnbPc004z7+T3Mhpmp4bfccIc0KB3\n", + "XL6FQPDg4KBGK0DPGHlBx9AX9892pqylZP3n+eE+zE9ZKwskz0GPn4dOsGNDoGJ7Y/DDSFfZ0L+l\n", + "Hudap+/op51U981/MxWGz0D6PVZl+2aHFkc8R1e8WDwANtr+PaJeUt/oBZ+Zf+PUF9G60QCUG8gR\n", + "k7RarbLw3tHRUUbzTLDTG/SF7bW0p6enhGJvbm5itaq2MhsdK1EQSgmAPhmyNHqCk+g6TQituQk0\n", + "c8eIfDkQF6HmPoxdxNZAobS43ve141im0Lif89u8I3ONo1qmd90XO9r0A36ZHRvkaG9vLw84jog4\n", + "OzurFb90dOXUAs/wIqOPdpq4jvdx+sOQM04YP82V4D4UT+R3EJmDg4PcUo/DT8kMUhTv3r3L6s6k\n", + "MjebTRwfH6czyVwwPhgdxnmxWMR0Ok1EkmiXMUVRLpfLWK1WGR3DM8KBJQDhM6fl7dAj61bQDgzs\n", + "fHo8nRZBSeMA8kzqBCEj5XrFadjb28soudnc1oI6OjrKHZolmttsNrPK9j/8wz9ExBYl8K7hw8PD\n", + "RIVwghjj2WxW01seX6rwR2yNxcePH2M0GuW7mJPF2DQa212SfIZczGazeP/+fbRarUzfwbVC3zIf\n", + "PI/+WG7pJ/Lp+WKOmTtQCa995r00eNzXKR0jNjjApnxwPWsC1HQymeQc8l7WBbS7u7ta6vjp6SnX\n", + "jJEhIx4RVX2xRqMR/X6/Nk93d3fx5cuXdFhKZ6m0S/x0yQOQetM9IiKrz9uh4B3M1/QzkTPeE/5k\n", + "RD3NZXSROUT3Oo1G4znQlcQrAAAgAElEQVTofzsmDlL4x+/MG2AGzwNdh3Pm9zdfinnxuDEX6AE3\n", + "vttsNp+VajByZRCg/NzoGrucX3LoaN/EkeJFHQl6sGn+nIWLcPt7pOe4j68xAhJRrwpNdMXCx8ki\n", + "Kid6RhlHVIaN/jFZ3NMpNfcfoW+1tvV0Li8vcxFRCM/kVysy0DgXKPV9nb+1E8n1NDt/GCGihdvb\n", + "27z/yclJonJE00aF6A+L206P58UOSukU21H2WKGk/TzGrYxmiRRIN/V6vVpKz5C30z5v3ryJq6ur\n", + "Z2fWRUSWaLDTZg6Y03aOrpBN38upD/rj8TLS0263U1mTKmA+WdDr9TrJsBGRROS3b9/Gu3fv4vz8\n", + "PB0JoHQqOF9cXKTiI9rmHo1Go3bsDvN9d3cX7XY7HX5k5fHxMZERnO/JZJKcGxxjnucjUuBg8RmE\n", + "XgcKNIwaypA0JWOGPDsQ4v2n02k8PT3lVnUcRsbUKU8McERVvBMk8/r6ura+1+t19Hq9RHJIh5EO\n", + "bbfb2S8/D0QB/mGZRgdh44gS2nK5jMViEf1+P4uv0hfSfefn5/Hu3btaBN3v9+Pu7i6ur6/j+Pg4\n", + "n+f5BQUtaREOFLhnv9/PscZR6ff7tWCANf21lL4DjDJYcQDlOTYK4n4y38vlMkajUQ2RMpqPrXDt\n", + "JgfsDtTOzs5qqS3P03A4zA0cm82mVrmedTYej58R7bkfSKsDQSNCfs+Iuq7B0fS2fwqu4owRUPO5\n", + "y594TB3QYt9sa0iVYte4jrG13JpT62ft7e09qwcH2uWswXq9zlMACLyQC4IyB90voZ/o4ZKHZ3kx\n", + "Il7Oq+WUAIPvORCkT19rr+UPXttre22v7bW9ttf22v7O9k0QqdI7jqgQG8OCL6V1yobXivdo5MJo\n", + "ARGhOTy+jpxyROSZTkTWTik8PDzEeDyObreb6JLRLqI9oinD1I7I1ut1QsqHh4f57yUeCv0tkRz6\n", + "jAdtUp5TnUQwjnhIc8Jz2Gw2yb2BF0OEbFQEBI9rzCEqI0iQJBqRRZnXNnIHT8gRnSO4rxE67+7u\n", + "Yj6fJ+pEpEVK1VBtt9vNcSTVxj2J0LnW/Xczt8fzY5JoCXHzXqSzjDQxxhC4TTYHOdjf369xdhqN\n", + "RhwdHcXp6WlcXFzE1dVVTYYjIneQHR4e1sjIFF/kXDwQKeQHJPb4+LgWQW42m0ylnJ6eZjoJefLu\n", + "Wqd5SV/v7e3lwbkRkegOCBa8loiopcPm8/mLu2cdKVufEBGTCt3Z2amRRyOqSNqVv3d2duLm5iba\n", + "7XZu4LCOgB94dHRUK5uAfgKpNSeLNCD9PTo6yr7e3NzkGmPN8RlI4GQyScQKeSP19Pbt27i+vo7p\n", + "dFrjTi6Xy+j1es/Ghf6hmyhaS4Pgz0+nQ50JACn02ofyALroNAprxUiUm9NeXnNePxH1qvmbzbYw\n", + "LlX4fYAy6TnKh5R8HlAxo2etVisPjEZfcB2bCbrdbq5V1hgNFBKUxe9lZMU62iicsxv0z1xP68nH\n", + "x8cYj8cp26ZDmIu0v78f/X4/7Ql2wNw3I4DwbOlvWe7GXDnbY5A6l12IiFoqj3krsy3oB1LpERVf\n", + "j7EzkshGF9Bs22DWGciSx4W/I2NO7TEvzoS4OQX6UvsmjtRyuUxDXC5EG9eXUmMMhuE6Gy4z/0tS\n", + "pHcM9Pv9GlmcFFlEJIF3uVzmoJvrQ5Vh0hhMOKRh18yx42K41FwnyuHjeDiNV+aHDeH2er0kHZKf\n", + "N7fJabX1el1LDbpys53EiC3JdTQa1e5Z7myjMnxJFmWsmBf6jZOA8sChiqifS1gSI73Dq7yOOUVx\n", + "w++J2KYn+X7Jw2COn5621XSBpCO2C4Zq4OxktMNTjmnJPSgNAQqM+SdVWpIoSQN2u90aERmHnrG+\n", + "vr6uOQKdTid+//33+PXXX2vwt+uz7O/v1w58Zf1BOLYjwWdHR0d5BI2VIjV4UJDMzeHhYRow1raN\n", + "rrkzTrVA4J5MJuls4dCzAWRvb3s4MNvcI6LGI5rP51nV+6VAAk6JHQ3k7PDwMPr9fo17BHcKZ4/3\n", + "YPcunBX6yPMIAnCoPE84mKT9vIZJk5Q7ER8eHmI4HObzdnZ2stxFRMRoNMo0ignPHGGz2Wzi5OSk\n", + "5hDg7Ji74p1wm80mdwOSiqYvOC5sImFnI7LhnXyUJ2ANWBeU3CqoEHzHzhayYl4b78hYoYPNYfTa\n", + "LDfsoG9MWI6onLUvX75kCqokY9NXc2qPj49z8wb60ilYGlSEkn9qvqb5Spa9kgDeam0PjR+Px5n2\n", + "tS3F+Wg2t+VhTHmgtlWz2cwdnNzX5Hqc6YhI6oedFHNccdzMt/NP8wBpHlvLDWPF707hWX5wPkt5\n", + "4Tmkey1rdqJMLzJlp+wn41H+ze2bOFIoDNcO8ouVAo6j8NKAmfVfogcmOeLRGnWByGfUIyLSiOL5\n", + "enGjhGezWU1pRlRRGwgROWeui6gfl2FkAWPJ9Xyf92bC2+12EnyJNBwJo9iIflA4fM9ePlGto5OI\n", + "alcP48P7cJ139ZhoiLAhwL63uV5G13h/R26MZUTFY/DiodnpZp4wiLu7uzEcDmsOjI1fs9lM3sf1\n", + "9XUNWWCnXKmQnWOH62J0DDmDk2OFihIm4qNeEfLGuEIadt0ucyks49QA+u2336LZ3O7eAnXa399P\n", + "5wbjyDuyBdx8CRzQ/f39OD4+zhIJds5ms1ltl54LFhKx9/v9DF5sSJFvxtDzDc8DJNZOHcHV/v5+\n", + "zOfz2m5GO43j8TiOjo5qSBS6wdwWvg+azM4/b+4wVws0EDnF8TCiGxFZfgInGa5URHUsCQHgZrNJ\n", + "NJqz8iaTSa5H5ALjjNMN18bvzHjjEEZE7uK0E4nOiIh8NjJgcjKGnkDBvBR0NgbTzhFGF46V61qZ\n", + "/8QaKblAyKGdLAdQjLMLNYKQ0Ed0DbqV9VlykVxuxe8ACnt/fx8fP36scX3evXtXQ73MAXr//n2+\n", + "P+gu64TSMgTrDrzpj5ESO2BweYwYMZ7YyMfHx+Qy0tA95lVxLbWxyr9H1DM4ZSbGtpi+GszA1pVZ\n", + "Cl/LuDG/3vTCGL10sDyZIda+gYPy+Cv6jj9gW2o7w3f8O/JZcvicTfha+2aIFPCjvVKEvzRQbDfF\n", + "GBmaRKBsVC0cEdXuQBuM8Xicu6Ps+NBAqIBCSyfu4eEhC1rSVqtVnquFI8Y9Oc+M/mIgI56ft+S/\n", + "IbikE9g1yHjR77u7u1gulzXHjR0RXA+iEFGv3cTfrZAgpTpC57MSBbTTw9+NwHke/E52JB0VeT75\n", + "DGVq4beA43iwaKbTaabIdnd3M2r3+D49PSVZmoKFKGbQG4qO8n4Yw3I7vjcmYIzKBYlBcXTHM/f3\n", + "92M0GsVyuYzpdJqfsTuHMd3d3a0V5ru8vKyRkO2A/fHHH7mmdnZ20slqtVqJuu3u7sbHjx9Tpt69\n", + "e1c7a4wUV0RFTG+1WjUZjKjScDYIGG/vnMH4ITOcUWcHwcVo7QiQUqRRKA8iL2e90bwxwrKIgcII\n", + "NRrVGYXj8Tg/Zw4wmsi+yeNGejCS3NO7kwhiQHJo0+k0jo6OkjiNg4a8UawVp4fdw6DhIOPL5bI2\n", + "phFVxH9/f18rqnp8fBzj8Th1kKN4jCznLJakcKPpNm5e8/6c64xUMpYR9a3qvKPXN7q5vCeBMYGe\n", + "nQMCRxxop4xsP1izRhp2dnYy2P348WOO5eHhYQYWd3d3tcOON5tNHi4dEXFxcVFLcXHPfr8fq9Uq\n", + "bRC0AtaFA90yW2CHwOPWam2r36PjGDdnUjyHvINtHboDOSO16+dhswjMnbpmDNHFpp80Go0Yj8c1\n", + "Z8/Imfvg8j00AqKX0r22LfTVwArjVqaN0f12XO10EehZDg0YvNS+mSOFo1HWdiihuoh6yf+I52k/\n", + "rmGBeNEwIHi13OPy8jIhUXbgGHK1cJQcA/rCAkWAfcgkCsZw83Q6TY/bSsXva0SDd2BR9fv9OD4+\n", + "rm3fZUFTKNPoEnD/SzsfykqtpQG6u7uL2WyWKbwSdXLK0gqTMStzzM73G8ou71EufqdBQDoYb+65\n", + "2WwSLaGuz2azyd1hOLSOjHiGDX7E1rCRCigjEaJw7u9xK51hnJ4yMnNEi7PWarUSmcCBpeFEAX0T\n", + "hUVsiy2SZnMJCT4DugfFNNcJZ5ZSB6enpxFRHVrsVIudVJAuZNw7COk3z/WYGFWcTqc1hA1DaLSW\n", + "z5h/UtpO+2LQUIzUzoqokKTSKY/Y6h+UOsbYZVHgwkREreo96xv+htGNRqORTvt8Po/JZFKjCsCf\n", + "nM1mNRSl2dzWcgIhd+FUZHS1WuVRKIw3qaxGo5FpHYIBdBm7BHEoIiL7hVxjFLknjsJLKAifIxfI\n", + "ON/DGLK2S0NsQ+TUj1GA0mChU0BhcCRxWp1iZ06hbTiVylpzCYuI58e0WH4Xi0X89ttvOYd7e3tx\n", + "enqaa8K79h4eHuL09DSf6xQsBpy1w5iy/gj0Pe78HzuJc887WKdHbNefHRUH2dZBrEHWRWn3LJsl\n", + "dYMA0s5yRKWj2u126k7kbWdnJ4EQAioH0N6xbp1BORPWmNex5w29ZweUMfD3Pb92Mj0uZeqZvrAG\n", + "PRZl+yaOlB0iT4YJ2eWCInoyehFRRUlfi4RQsiX/YDqd5nli9MOViLneqAF9tyPnqMKNCN31QFjU\n", + "5GPt0ePskRpAsaM8gWQxOtyz3W5nVP709FQ7IgPl4cjTwsACsMJzIxq2ssWgGdp11MQYMU82mBCb\n", + "PcY05omF7c9Br7inESKczL29baV2HAIW0nQ6Ta4PRsjwMcoEZ2p/fz/G43HWBLLxwnh47mlEMRgF\n", + "5rfkSHiMGBsUyGKxyLl8KUrGqPP+pF+pE2OEzBw4jkpB9jl7cLFYxGw2i9FoVKshxjiD2pToJQ5i\n", + "u92ucYvYdm1ieUQVCB0eHiaixD3H43Gcnp6mUTT5GafZ6Xka/BUI88gx/Tk8PIzpdJoy5+tbrVZM\n", + "JpOsL0ZR14jIEgpsL/f823ihr2x8qR3X6/VqnCWcNcb58vKyljrcbDYxHo/j7du36Ux73jE0RmuQ\n", + "d7huBwcHmdpDzlqtVgZvFGNFznBOmTtkEoNXcly4J3OPAeMeln/mztE+uofPuS+o0EsN54v7EtTR\n", + "H28Isq4muFytVskjfIk0XRpT7A/oZavVirOzs5wnMg3dbjcDQsYPxInrnGJmvggoqC9GUNRut+Py\n", + "8rI2DuhcEFlnTEgpI4/YFuQG3UM/SsTfa9z6ySCEx/5rnzm4Hg6HGeigNzzPPinA84S9I0h2cE2t\n", + "MGrWOa2PLCGXzkiVjlIJzDjgLxEwnMASDSxtUtleyx+8ttf22l7ba3ttr+21/Z3tm5U/AE4vSV3A\n", + "aEZ9TGorURV+N0TpnQMgJ2XxMaoge7eeIV6iE6NkEdXRDEZo8FS9VdxQLPcEYscrN4wJOkL0Tp96\n", + "vV40m9tihiAXjoJBL+B5gMiwo8MRiMcNCJ/IvkSl6D/ImgmSRAdEyOYmfC3CJIIhumLnSETUECYi\n", + "JafIDPn73iBEIC+bTbX9ttz5BkrCPU2iB02IqA47ns1mWQyR8QaZ8E42o3IgUEQ63tUGaoq8Okok\n", + "VcDYeNs/HB/QSqMum80mi11CNId/0W63o9lsZuFAE2Cvr68zHUTaz++PrLhQHrJIfzudTiJaXOex\n", + "KNEa0m6kf4w6lfJkJOv+/j5LjXjMKMTI2EJidRmDiCrl4fQd6Aay6rMM7+7uEuUrd6yCbEyn0yyh\n", + "Ye4gP0tKAPL1+fPnGA6HcXJykmm4+Xye5UY415B3cIqZ1BnIIf25u7vLOXdK+OlpewzN09N2ZyqF\n", + "QweDQepf5MmlVowYGB2EgwVxHqTMZHSQt3INmxeKnka/+YxP7mPUmjXD+5G+YrfmZDLJzRnIovlJ\n", + "pJxchRw74vQ13zfiaMTmt99+y/V8enr6jBvbarXi8PAw5QI9dX9/XztyzDqB9wFJHo/H+X4uwYOe\n", + "duoJu0W67O7urpYWfvPmTXS73WeoozM76HiPt7M6RqGMyDgVH1Eh4yCnLt/DGsammuPY6XSi1+vV\n", + "9KH1JRxHMifuJ4hdeV3pT+AbML9896XrvIZLpNJZopfaN6tsDunS3AQgY/NpIuqpL64v4bqIisNS\n", + "OlJc59om6/U6rq6uotVq5WGsXlBwjJyH57py4fM8titzD3avRVRcGlIe5XbL8p3NHXMqE+PIdzA+\n", + "ZYXmXq+XaQOnapyidArUTi3vaD6YF2TpkJnEa6i/5AeRf+c9Pb+kAvibn4dhsiPGMyIiFY3LW3Q6\n", + "nRw3uB1eiOaAeBcZ0PxgMEgip40zysaKKWJrsHu9Xo5PuduO56P8Sr4W88OmCjvqfMamAhTmZrOJ\n", + "Xq8XvV4vBoNB7kLjeRi66XQas9kseRtPT08ppygQVynm0FacNB9MDBeFQARZhMzPM73RAqNlo23Y\n", + "HGcKSJ7PkF+nLklfff78OcbjcZycnORc8M6MGw4xir80Jjs72xpSe3t7ScTHKCGvTm0if/yfOmue\n", + "X/7v9CwpnIeHhzg7O4v379/H999/HxERv//+e8xms3jz5k08PDzExcVFzg2OASR6+FsRkSl9+Dns\n", + "tLVMR2x1xHfffZcpf9K6cOvsKJqrxDrAeTY1ATk1dcG80nIe0Sde75Z9gsjyc+tjpwkjtnp0NBpF\n", + "u92Oi4uL+Pz5c82p44DccrcfPDYH5earUavLzg73/PnnnzO1f3p6mk4PdIPd3d3cBEDjOBlvNnJA\n", + "t7Ozk84+toZGEFTWaLI98Lj6wPLxeFxzdmgmerP2vE5JzZV2zo0+IqdsdrFN9lyQZsbGIteXl5fJ\n", + "3bTsMBfoG9vtiMo2YJvKoNTy5XXJvHJfBzu2Azs7OzVubglgvNS+iSO1WCyi2+3mqecRlYNQ5q0j\n", + "qtonNjQl8Szi+eGNEVXESzOxDkK1OS18dn9/n9diqCMi0S2T5miz2SwVnL3biEjiJ3lrO2fkilGW\n", + "nnyTxyHUoty63W7uyAFxcATpBRtR5ZZpLJaXOChGDNww7DgFNvrOjZfGi3cxP8zRAO/OvUsuhccJ\n", + "hcFzcCIajcYzZcP7+XBWO3k4KeaeYPAZZ4yQeR+QX41MeYdVSdy0I9hqtWpOr7eJl3WSuNYKHYNJ\n", + "+YtGoxHT6TQuLy9r5F/Q0svLy2fRKmR3uGPeNRdRIQWgSdzz4OAgLi4ukoeCA2K+Ds4X48YYIB/w\n", + "ixh/b2N3gOHxZc1hEI+OjuL8/DzG43EiU3Y0eA6cJ7gy3BdHC+ffc0DfkRNkic0LvV4vDRyNaNdr\n", + "zLv9QCx2dnaSmxmx3TpPLbNutxtXV1d5Peub8QJFoi84Beys9KG2GCbkyBsqeM/JZFLjlFoXY1TM\n", + "LWLtEUjQJ88xrTTE5pRhyHgWusC8Ke7JWkLv8xwQUHSpDyVfLBZJ1LaepR/ozJdKGURUMlnyWOfz\n", + "efzlL3+JiO2affv2bW1s0aPwVWnU3mK8zQOy7nXJCAjW9K8s90FggSx7Mw3BAI6Kg6G/NUdc6+DB\n", + "gTdj8/j4mJwxvz/zYV7heDzOABDEivfiAPbhcPgsu4FcMF7mfzIGOMIlclaid+aHlcR7fw8nys+I\n", + "qIpQf82xjPiGdaSA1S04JrI2GlXNDtINwO2QwSLqSBYL1AaaKIsB5TMWGdtj2ZFAs1duh8AGytEY\n", + "11xfX8f79+9zG7wjZCM3VtAoKXYuONWwWq2yBhDXcwAphoNxKdNvCAZCUO6cscJ0BPn09JR9YDdc\n", + "iSQ4vUlzasVpjYioGUeMJvcy6ZvvlM1RiZUbCp3UDg4DCBHOgNG4kjRpZw8ZIVJzygoHl0jeuw1J\n", + "g5IyczTt8SaC8n1BLFCMfv9Wq5U7hjabTa6FiLqhubi4iMFgkKTi8XicAQGpQjugJrY7AudcN2Tp\n", + "6uqqtmY+ffqUaSP6HlGhAPzfxGjgfeScjQfMKwiQU7t85rVO8BNR1VMjdYIMowiNuJJWQgZx+pA7\n", + "nGDmcTAYRK/Xi/F4XKslhMHiEGKnIXlf1oB3JqKXkJtms5nPYzcuaES3262hKAQkpSxFRNYiI/VB\n", + "Pzn3j2dbTrnX7u5uppyMnJEmJO3reyLDTrcYuXEw6PXGdfyzsbJeZm34fU0k9z3v7+9jOp3GfD7P\n", + "INKpZe6NETbST//L9B3zBBpZkpFJt/33f/93UjwiIt6+fRv9fr+WFkS+CfCo9wXhmnXhcSxRet4b\n", + "h6IM/spyHh5rdgSuVqssMRIROT+murhaPJ+VZHGuZeeuz4QkZY9N8BzTN9YKp0wwT5QLQmegv12n\n", + "r3T0WWPIh6kQ7HI0SODnObVp++xgmubf7ZC91L6JI0VU4BwukCIDGFEtCIwaEwlcT/OC9o4TrjH/\n", + "yErKQmUIFEH1IncUgVEnJWDEgpQHBs3KxIrQPBv6ybMbjUZ6+YvFImvTcN3FxUVEbKPSfr+fEDYL\n", + "w2NHH1AY9s4Zu/Jv5LkjIg+9LT9z+orxRmiJmGwEiSiJTO3U2VB+DVJmPnBYIup8nlIRYQRxXgxh\n", + "42AaheI6Fibj0mw2n/EhnBb03FJ9m3e0kUKWzJHi+fAqQB8sDygGnCIcK8/xZDKJwWAQx8fHKRs3\n", + "NzeJ0LGVGwd8NBrF0dFRzt3Ozk4t7Uf0XMrm5eVlFr6cz+c13kCZHnPKBMSHQ27hBzGGZYrFaxSn\n", + "xQEJ3+FoFYIu6wHu65Qh6xRZeXp6ypIDyPdiscgdhoeHh7VyDCh7jDHpf97ffD7Pz3q9TlTPfWbu\n", + "2u12HB8fx2QyqaVqCBBAI7w2QE1IL1qeneJpNpt5rE1E1OZoMBjUPiPtDBLPESQRUeNi2pGiMf9l\n", + "mi6iChydDbD+dtBXUhkw7mQj0IO3t7exWCzi+vo6ZrNZ3NzcJHeQcSGrQP+4H84aHDCjLU4rmi+G\n", + "c9Dr9WI2m8Uff/xRQ9Dev38fw+GwFoQhhw8PD3lEE44//bRjRzqSz0xRcbPxJw1lXcNzcdycwrLz\n", + "UKI8yLepHXxOAOD15RpbRnaMAjK+pPBMIUGGOJLJKHxEvShniSxGVHxlI/bYGOyrx9H0HeTMAT/2\n", + "hb45GEYvfq19M0eKCWVx4Sx0u91EpgzxItQYHRe1sxCVSM9ms6lxhfge0C19QPlHVAsfQTWSRX/M\n", + "a3EF54eHhzQUJQHXxtSCaCSM97EA47mv19s6KiiM8Xgc3333XS1Sd/TsiAalWiIk/M1OCNfh7FAf\n", + "xOOGcff9LNQlQmZIn7pHJScCBe7owPMF3O2/MVe8L9eBpkG4xZGjL0Rt5fgzNyas2tB0Op2asXMk\n", + "xHl/m80mick8A0XO4t5sqvpjT09PiargSHlMzGcZDocp36Cpj4+Pefo8lfsp7gjn6e7uLo6OjiJi\n", + "uykC9PTw8DCPPYnYppoitk46zgTOGTVvxuNxDIfDGAwGNePNlnNkx2PocXZ6g/FAcTFXbqASNgIR\n", + "9XpYjImLJPL/3d3d3DwQseV2OJrHufGY3t3dJRLochnIp+tX8U7oC1LQ5l9gXEkPYyQ4qmi9Xsdo\n", + "NEoHNaKqiI7+wrHj3Y3GEYVz3dPTU4xGo5RDnGgoBryPA0GCANK68/m8ZtzYiAFFwc6UdSuOq3WD\n", + "0W47SzbWpY7iu4xP6ejw/ZKaAMWBcSiReE4S4O+uQeTMAXKEXNCgpfz+++8REbk9v9FoJDezTN95\n", + "ffMZRZRZO+YAEkQQJBtZKYNHnlHyIymZYi6fU2W2eTSjcoAb3JN/LiVDfxy42OGHG0bQYuSauSHo\n", + "to4ukTCCYfrCdxgX6xP0D+vM64lrcKIcTGP3Sl4ZY/a3Unuv5Q9e22t7ba/ttb221/ba/s72TRAp\n", + "V0AFlcEDhqjmHVx8F++SLZMRzwnUTmmRljCHwMToMp9ryJHo05wgGh44SJCPdOD75HrL9B3Pw3uP\n", + "qLZj4xW7EfltNpuE4bn3bDbLgoRs68Wbxksnp00qgvubl0BzJEhU5bw/fYWXYb5TRHWUD1G5ycJw\n", + "PZhn+sW4GUJ3lEoapNlsPktfUrCRSKkkxnNWGRGtU4lEsMD/JYGdOTcBkQjKRe6cxmEXC+jh7u5u\n", + "LedPJE+EZs4WUSXjYggalJY0j6s7r1arTNd4LcABgYR7cnKSpOxms5kV3N+9e1eDsQ8PD+P333/P\n", + "atvz+TzTfp4DCLXMhdNJ/B10DJnneqMXzBncs7JyOYgRXEDewZwu5o/iqxHV0TZw2Q4ODmpbr9l2\n", + "PpvNaqn0RqORPA54m47m0UGz2axGQ0BuSb964wDrl/WBvHBPdnrB40L+XGyVeyBjy+Uy05mLxSI2\n", + "m00WemQzw/X1dTw+Pubh5lxHdE9fWYf7+/tZeb3T6USn06khnMwTqIJRHvNI+Y7XKTsPnSaNqBAb\n", + "6xyuM++pTAeScoeyQQqYe3JNibbTyrQNc0EzV5JmXWZu0ZcvX/JZ3333XWZNIipOEjtgjcjAXzQn\n", + "y7u7fWSKU8wgn+i2EgE0gluiK4yxETyPK3YDGeE9QI2Rf3S5x8VZBLImnP5hhJdme0img2b+mGk2\n", + "fMY8W5/SB8aynPeSMO57+vlkmoyo/620XsQ3cqTgffj0cNJgy+UyD3p0jhTBgA/w0q4C7waKqCox\n", + "M/mGlBFMLzTXmYFo7PPreI65EE4R2dBCBiy5AsCU7ouJcUyihZz7Qy61crm+vq4ZKj6DtI4DFvF8\n", + "txqQJcLnviKcJiZyD67HSHFPDKGrIHvXGtA2Qu/UH/fBYfYCZvGXhFM4WIx36YSuVqtadXen13A0\n", + "GE/SGyxMUsl26Hkm8uSFihyh2E1oZu6oQA2J1TvFzLtzmgaFwE4aFFQ5hxgrzz9jz84uuF7spHn/\n", + "/n28f/8+rq+v01Eej8fx8ePH+Omnn2J/fz/++OOP2vPYmec5jYgsvcBzz8/Pc54IfEib9Pv9WorK\n", + "81DW3oIUz+5Z9EWj0ci6PdPpNI0LzhL9wFBRwZw5pB8oTO+KfHh4yBSNS7QQAKF/LFPIgnfY2Tn3\n", + "BoVymzvpPOTK+oS0IEaHtUw9qZubm0yN8O4nJyexv78f19fXcXl5Gbe3t+koHh0dpRzhoOLsI3/W\n", + "TU418R3mxtyUiNIT4uAAACAASURBVPqZiqXjwtqwE807Wpas+1jX5uyYI4ccUuPKaRrGmmtMlShT\n", + "eE4X8jsBgVNbJVWCuZ9Op/Hzzz9nKvH777+vkfTR+RDNTSlA19iZ5B2wSegrPrNDznt7V58dw3KO\n", + "nPJysOY55R39TPSMuXJeMyUXzYAF/eE0AZ6Hc4atsCMLtae0V34/NveUTryDe2wbn9nxcvBt2cOB\n", + "NMfT7/RS+6YcKZRjRCX8cFt8ECsDw8JAwURUpG3/4zOQLeeTza/xYnG0ZOfIzkFEfWssiuElcimI\n", + "lksQmExdKiCfG2akg37wHAwmz+G5OAZ2ePb29qLb7cZsNkuF6kjQjlTZrPD8HROsebadPqIj3tXk\n", + "d39mAqQXyUvRFU5NSeQkp47slA4I48czeQbOCTL1+PhY49yZy2KjgsIyqliO2cHBQQwGgxiPx7Vi\n", + "nkRl3W43I2krqf39/ej3+9HpdGqEdrgSlisWPwRuo7m8NzsWaaPRqMaB6/f70Wptj8C4ublJwzyZ\n", + "TJL/BKLhdQgyhsNII2hpNpvJEyy3RbN2HSThJMAH6fV6uWa4/2KxyKAGo9/pdJ5xbZjLiMjjYVCk\n", + "m011Fhv3pvbS09NT7lajdg99tTGFd+UDmr3e+J3Cu6UM4/S3Wq0aemIOFX2IqLhOyATX8xm7C2ez\n", + "WUwmk1qtqNFoFN1uN/UjyNLd3V3WmHOQwjwhl+hGxhc0gb+zc4u58jiXQZ3J0f5/RDwzlNZ9BLTs\n", + "LiQ4Zf585pwNdkTUdIERCyMXfk/aS0ET1/l+pVFdLpfx6dOndIg+fPiQ3+X8TJwozz3oD/LrjTd2\n", + "9Kx3HVRGVOcuGjFjLl3OhHHh/Wl2Qvx+Rsj4O8iSv49Tiw4y/3c4HCY/cblcxng8zoDOa6l03OxQ\n", + "l05WRKWLIPI7iPZ7l/23g4cd4n4RVSBd8mbtAL/UvpkjhXLlxahU3Gg08rBcYHwcIe8Y88ChMCHm\n", + "mZRH9F8So5kEDCOVjiPqOw9emkATX7l/RL1eDs6Zya8+T8zIEue6NRqN3KpaLiKiGveHseB0eSLK\n", + "iK0h7Xa7MRwO4/T0NI6OjuLjx4/x6dOn7I/RljKdRtQCoueonEVpyJ7rQK+4v50Q1+1x1MC7WwE4\n", + "dQt6aHSHcSOqhiDrKIt+eZu4ZdCOL8+DZMt3mAM+s3PpqsxEMJCCcbQg+W42m9qZcJyxRXMK17tg\n", + "vB3dMhMR6QxFVHA+le13dnbSAen3+9Hv9+OXX37JeSNt5nGmn8fHxzGbzeL6+roGaTPeRLXz+TzH\n", + "+O3bt2nYKA1g2WLnICiCkYjDw8PatU55+7mDwSBRF8j0rDHWFmPKVn6Mk9NE3M+puDLap7iq09r0\n", + "mX45GLC8+fBymoMKgh7eg6rQGCru3+1203kHzfAGFXQMxTI9T2dnZzEcDlOv0beHh4cYj8e1mnZ2\n", + "bkj5euck7w6yB1JnJxuZ47ukHRkbjzFjh7w5ELXO5X7oKeuAzWZ7KDkZA3Qhn5UImNNCRpbskCDX\n", + "LuRJXzy+nkveD1v26dOnrOsXsUUACSL5ng/MdkbA5GeQX+ocgpggf9gQgqzSSTDqQnDjsbS+s63h\n", + "Pr6GBuIMiuvxdnbB5XIIjPb3t2eYejMF88DmI48pDVtQ2m/0frk5oEzzEahEPC/MXM5p+a72Ixi7\n", + "r7Vv5khhoFlsi8Uibm9vYzgcxnq9rcxqZAkhQ2mWRQxBYxyVRtQPYeV3mp0JFwIs8+r+/+3tbUaH\n", + "KGlzDIzAkIZ0X15KQUVE1p4pUS63l9Ajw8wYJcYM2PPg4CD+z//5P9Hr9fL63377rbZw7UwwtmyH\n", + "7nQ6z1J0TpfSMGzsfIIr5ftznatw8/58r0RrSv6T+Q3A4nxuY8U8Mp7mp6CULRs8nz6wuMoImXn0\n", + "bhgca3hM6/U6C81FbFMwLM5ytyBKkaNscIIiKqMABw4Dzzyt1+tEbz98+JDzf3Nzkwqs0WjEx48f\n", + "0ymjvyAWcGoiqiNEPn/+nAiMq8Xj6OM4ukK6+YJ2Eh8eHmpVoMv16EBhNpulowxvkPWOgxoRGWwR\n", + "/WJUmH/PA0ggYzOdTmMymeSOTo7T4TOnZm2EGQvvOrZSJjgEXSnRBYwPCKrHbWdnJ1E20negek6J\n", + "I8MYK4JA70SEW8WRI5SN4XnsYsTBAmFoNps5lre3tzXqhWkMjKPLERA4OLBk3Fhv1oVGQaxv0Q80\n", + "1j8GmbHBdrBTlh1wEfVijS+labATpeFG75jfWaZ+rBuMUDnQub6+rqWTkK+yZATBL7XDVquqMCzP\n", + "YcydJcHZ5HrmwoiSUS9nRuyolnbG70WgyJgSKDgVztg4aOD/zC8OP+l9H9zO2vd4GDWnv6w1j53p\n", + "FS5uzFwQfON00hfbEds/1qydVSPRphO91L6JI4Xxc54VztTu7m4MBoNYraozxVhgEZWxttMDxIz3\n", + "WW67jqgKcFrxmXsFzyCiUho22I5aICgjbDQiFStgC6qjVgs7wsmCtxGKqIwP+WV7zwg/aSVQPB8h\n", + "wdh1u9346aefImLrnV9fX6dht/OCUJX5dfqNUkBp2glicZRl9UuyngnVjAOwagm3c1/Gx6gTi4E5\n", + "9LZcpxfNu+Iz8wz8dwwWkbnROBbb7u5ujXsCemAC5Gq1So4JKetGo5GGjsZY4oDCRYiIJFHD2+G4\n", + "CcZlOBwmInt3d5elCnAqWCs4CIxzp9NJJ+jLly85z4wTqI25KJztxljjvEdUpFKu6/V6NXI3SAtK\n", + "3ak9z2WJ1JpXiEMUUSHDk8kk1yFHOiFfBwcHWazRpPx3797Fr7/+GpPJJA4PDzOdyVzQjzII47mP\n", + "j48xGo1q8oQMErUTLEZUyh3U7fb2Ntc4SF2z2czaetSgm8/nuQ7hkJbIAqgQ1bO5DqRqOp1Gq9WK\n", + "N2/e5FzjRONsgZru7u7GcDhMFNOlH5xGIx0DtyWiSqF4LZUpf3SHxw2HCGTExhWdxHOMvKFbQKWM\n", + "1iMbjJObMwoue8H7o0OYZztE6Ogyw8E8YKdw/iMizs7OYjAYRL/fT7TLxpo1wPyyLthYhBPselfI\n", + "ptPPdrIZu1JfMidOJ9q2svYAFYzGAjY4qOXnfD5PDibyaF1DUMPmFY+bwRTzA5EXv4vXE/d239zo\n", + "50upYt+3HBuanVTG+yXELJ/31U9e22t7ba/ttb221/baXtvfbN8EkQKKM6ROtOjdTbSSiNxut2v5\n", + "TbaKgkgRRRF9cE1ElbYi2ii9fK5z3p5nRzzfjeLcrmFEPP5yq2ZE5WE7v813F4tFonM8F/SGNEwJ\n", + "xxIl2isnAiJ6IqKk/2/evMldUOW4ma9E2tRoHTs3HM3w/jzDxUhp5go48qSPRrYctRFxedMB80TU\n", + "YXlhTBkfEB9D3/7n7zsq4xk0okyiYefbneJljLyLCcTUkDz3plimizPSnA6CbI2MjUajJJvTD0oV\n", + "rNfr3P1KqgN0zMTw6+vrTA9GRI1nSPFGiOjr9bYg7GAwSETCZ7k1m82MTg2TszGDXTZeX57XMvJj\n", + "HszT4TPu2Ww2M93OO3neSP9Np9P48uVLREScnp7G6elpnJ+fJ7p2dnYWEdtipaQjymNwWq1WdLvd\n", + "rKZdbnN3BAySxHvs7OwkCd27Dw8ODmpn5a1Wq0Sk2u127nRiPTo1wc5ckEjmt9vtxs3NTdzf38fp\n", + "6WmmeSO2aNzt7W3tXNDPnz/n3LNrmirlfgfSlWzbd2HGErkreThO+fi7rIWX0n6sXZPCzZvyhiMj\n", + "9Tc3N7V0nrmMcM1A9FzklP6AtnqTERXvWYtlio7rSM0bbRqPx/Hw8JAHHTslxvuhA0GA2CQEKlva\n", + "nVKX+TvWMUZWPE8eU+tK72b3GBphQhasv4wE2656w47l2J/RvHnDfK8SvXZDB9CQC/PzLGv+vtG1\n", + "krLi76Gb/lb7Jo6Uc79eiHt7ezGfz/P8HZcjcOopokoVke6CK+C0gQmPJsnyGUoNY2WyuEmK8J0i\n", + "qoNr7dwxyIbd6S8ChRBxv5eEIqKqKG2SekSVUvMuLjtm7EJid8779+9rBGyUlQn1kHCBcO0EsojI\n", + "h9uhdB7d/TB5Ex6CU6nMO5/RcNY45sHj5gUFhMtckLu2wjCviTktOUkYJBZPSXAu03M0O1+bTVW9\n", + "PCKS00ffmCufUQbEDZTPHDN3BBMR1aHFm80mIfPLy8tot9uZhvIOMI5egVuFMWTH03A4zPcnRbFc\n", + "LuP29jYNMM/lvZl310QjWMDQuEr24+NjOhdwQ3h3O4iMH+/nTQOWJwcH7D7z/G42m1pQxc445hg+\n", + "5d7eXh6lFBFxfn6e1y6Xyzg9Pc00JGOMM1Te//DwMIbDYe5CshzjgMFnImBk3tFNDpQeHh4yLQz5\n", + "HYfv7du3WZkeA877XV1dxXw+z40k8/k8rq+vIyLi+vo6hsNh3Nzc5Jicn59HxNbh7XQ6cXR0FJPJ\n", + "JO7v7zM9jY7iMHdzwJgXBw7mgNqBLIOskjPl/5vrik3gnjaQcIa8gQQd1uv1ckMD482OU9az7QCG\n", + "HhkpUz+kWZ1KJMBwSozmVBMbB8o00e3tbczn86wJhwyjd91XvzunZJiyAtfHQaavQdegH80v4r1Z\n", + "27ZDUDrQiTs7OzUSOY10ozlbLjNSliPwmvBZkgRGTrGV69ubFPiJfBG42z4/PT0lxw1dZeespOv4\n", + "npZtpxzNT/ta+yaOlCMdIz9MAJFZ6UmbNMxLW+lF1POeOGclxyqi8kbhTxhZstKCe1Q6LRhtGwV4\n", + "HDzXdZTw9B19lVFGxDbyYSs8jf6ASpnESnRAH+DInJ2dxZ///OeIqKNm9u5RROYyRdSj/VJx4Cwx\n", + "BnZ6PEdE5GVES0RjYry5co+Pj1nQknd3P02AtbCzMPx+kCPhgXn3lftqArhliPm3sXx8fEwekzco\n", + "REQeVOv6MCa/866Mh40UxOCTk5M0yMwFCq3X69V2fEG23d/fj5ubm7i5uUmjGLGNzN+9exftdjvL\n", + "MfAOnHPZ7Xaj3W6nEWY8QdSWy2U6bnCROp1OlhdwLR+IuuzOY2wODg7y7D94QOZGWX7Kmk44wiYB\n", + "05gDnE0jmRidbrebO4W4L8URkcXxeJzrzXxEEGLvsqL+krlaljfWi/tqAixrzeRfrsVpYp4uLi7i\n", + "xx9/zHpQ5kCenp7GbDaL8XicBoq5o4gqKCYOQ0TkeZD9fj+Ojo6Ss8V4QuhHLzpYctHViEhuF5+j\n", + "L6xHPVfMqaN9xoyxLPUJP12ehuvgG8HDsU3Z3d2NyWSSx/3QIFC7bz5KCJ2F3rGjx4aP0sFGP1G/\n", + "yw6RETj4jSCONvKsA6NVBwcH0e/38/BhGn1DhyOrHmtsA0i59Tc8Y+aNcSVQcNDrHX3Wl3ZC7Nw+\n", + "Pj6mvvCceg4NWHgOsJ/0hXEpuV44SThaRn/R7eiv0nZZPiPqO02NJpZc3BI9K9s3caSIQDlDKqIy\n", + "3nj0EVVUjjFx/Smu8w46tjgbqjWZ0QvRA9hoNGrbZ2kmDzMZbDlfLBZZVdnfZ2Jd04d+skAdRURU\n", + "njKRhreP4nnTdzsdhndZaOxq+f333zMtQ7TgCIT7EiUTVTBm9JV3MOnSEZ3fEcSNcTOsDDyKovbu\n", + "DZwkl7tghxmIAn00wmTFWUYNbPsGHSzJ5jakTichQyhmO8MRkc4TqI4RE8afcaU8BH3keqe0+Wy9\n", + "XsfNzU0isTa09JsUK+k7vutzKvnuyclJ/PnPf47lchk///xzbhWOqB9EfXx8HJ8/f07jPRqNYjgc\n", + "xq+//hrz+Tz++Z//uVYVm8NFHfkxbswrDqxRB2TBKQ/mmnQRP/kOzyIt7bQA+oJ7r9frRBsiIonU\n", + "EVuDPxwOawocWWq1WrkJICJqKAuyhh7yzjmTxbknShvZZg7ZtMD9ymAKA8V72Rn8/PlzljGhDk9E\n", + "5CHVpAmNLA2Hw3TIkDWnMJrNZr7z6elpzhP6zP1xw4DRP4zf175HY97soNiB8Bi4ryCg/N33BMkB\n", + "mXKwvL+/n7tbcTiQCxfxxa4Y4XbWwrvo+v3+s4DURHtqc5UoHn3l2aChEds0MmsIh8Zzwd/R29wX\n", + "mTdoUAatzAGfG3lhNy/3N9JlPVrW0UJ2cIYcKNDu7u7i/Py8tmHqawAC9zOyxHqCkmD6i9+FTSH8\n", + "3fbRqVv3zde/hJqCFtvu8+wShSzbN3Gk4D3YsUEw4BLYCOGEYORQ2hFVntXIhJ0bL+oSbiUatEce\n", + "UUF5XsQ0Sgrg1ft6eCFlnpdnM4H26vkek8f2YxpCBkRv6JvnoaBd1+Xm5ib+53/+J969e5fCZQVp\n", + "hYZAITgU7iQ6dMqMqAyj7pSox4n7enu0OQ3sooyoc6eOjo5qc2jDymIuI136X0bQ3mJeLgI7qDYO\n", + "GGyQH1cIp+9sqfZOGuYVQ1vubCHqB+Wy88a7LRaLODs7i7dv36byhRO1s7OTqRhQIJxElJDTficn\n", + "J/Hly5f4y1/+kv3zDsPNpqoX9fnz54ySj4+P4+zsLH799df4t3/7txiNRolWWX4xHjjuIFdOjzA2\n", + "pBeRX6J65qaMcC0z/KS4KfNE1EgARbkC5Jt1NB6P4+rqKtN7jPV0Ok0E0WmKiCrVzPsa0eC5rENz\n", + "ID0nBFPMuWuh2Tn22mQdeJcoyBAHSCNH7DRkTq+urmrlD0hZLZfLWvqK9XxwcBDz+TwajUYeLbNe\n", + "r/NvZb0vHEXQcfpq9LB0dkp9a2e6XMN2tLxTmLHCqfKa9r1KRAZaAzqSNCsZA3Y6Wi+xhlxjzfOE\n", + "LLDuGXsKozqQtGFnLnd3t0dGkbpdr9e5S5L+WbcbzbFT5NQZ3/OYGpHC4TH9gnHmsxJUMD3D92TO\n", + "+d32koYjaX1HfwEXPN6lnJjr6rXC2mGMCFT4WdpaxuQlCg0yZkCDuUeH2PHj2S8FDbRv4kgRuboy\n", + "LguFgXZ6A8ElNWAym6NQBJ/rgMxfguVs8BAmC1TJb7IzRokGCgnaaDrHbAWMAWXyjDI5V1ymgEyU\n", + "JJowcR4BiKjOboqIVB7z+bzG5fEc8E7l+FDg0+ifieCPj9vCgERKJqLjZLJ4HQUwN1zv8WbR7u3t\n", + "xWAwqD0P561cGDyj2Ww+g7Bfmu8ynWDj4kVq5edUKoYc5NBFXDGIZWqpJNAbCXPj3rPZrKYYSDc4\n", + "rWsiPGvp3bt3cXx8nPP/yy+/xHQ6zaNOOp1OGszJZBLtdjvu7+/jl19+iVarlfys+/v7GI/H8eHD\n", + "h3j37l3M5/PkaQyHw5r8N5vNTCX3er1ajTdqNDH3pOFKYjC/o8C95X61WmW6y2uAe2LQIbguFot8\n", + "j263G7u7u3FxcRGtViuurq5qDjG8osViUdM1oGJOG7h0ByiYgynPhcm13JO0JH8j6kU+HBARFdPM\n", + "2cH4R2x1InXnms1m7QgcUw9AjbzWlstlOsOTyaSGkJC+RO78fnakcX6c+kKOy9QcDgY6z4GN0WUC\n", + "ytLJcurdDgrlLUD8cEYw2qw3r2mCddKY1lFlOYSIqK01+KmksZE10Cg7krZJ/GSMQH+vrq7i4eEh\n", + "hsNhGuoyDYUzGBG1NWAebqNRnbhAs7Pg9394eKihcLYDlhs7aJ4fxsuoIt+jkLBlH33pFJznHBvy\n", + "UvoM5L/MKPEM7KVTm3DJsF32Byy7OHhG1bDRRspoZUarbK/lD17ba3ttr+21vbbX9tr+zvZNECm8\n", + "XrZXR1TpHVAHIqaI6rgHvlOm0xzhOq1Cjtv5WrxhQ6cR9ZOg4QuZ4OocMz9NzIyoDtk00dqRJ5FE\n", + "yZECojQnx6mCMlIFIen3+5lLh2zqCGq1WuVWbXviEdUuxvL96A8RD1GRUQLG0DslGEM3eCvM79PT\n", + "U0aKoD00ECLuBWy+Wq3i06dPNZlwpE8EATrAeNNPoxCOMEjLGLrnJ5Esc2GEymkdkBe/O1EQiKej\n", + "KKc2DRW7j6vVKrflR2yRE9AIdn8xx0TU8Jqurq4yKifVsF6vs/gmxwPNZrP48OFD/P7777XvMg/t\n", + "djtLHPzXf/1XjTT++LitdN9sNuPs7Cxl4c2bN9FsNnPXJegC/VwsFnF/f5/8LG//h+dIpI7M3N7e\n", + "JuLGdaQMXO4EVMtnSTKHoCx3d3fJL6JYJRtVqJJuuQDlckrFKACy7J3FToN5rTkt32w2a0flgBqA\n", + "upacndlsVkPHQEH29rZVvklDNZvNODo6iogt4vH0tC04aY4JcxFRbVlvtVq1Y4g6nU5uvTfa3GxW\n", + "h7qDrlhu6a+Rp5KozHecRrWclOkwo/boBtYr6x2S/nq9TvkZj8epv9kFDlJrkjVjZBSbOYB0bfSf\n", + "MeC9jVSD1L6UAnKKESSNOQDd4h14X3N0sCfWr4w140wWhf4Y8fb/yRYwT6UtMupotMopwXJOjcSW\n", + "5G9sEmvA/GXslncVWg85Q2MEDLQJm1pSe/icfjjzgNz67353xtlySfv/HUeKF/cRA6PRKCeuhH9R\n", + "vHd3dzkQziV7EixQm80myxsgXObeuLq04UgTmq0sI+qnjuMQmE8AlAgPiPuQnvT7lVwonC/qCdFw\n", + "sJzO4O/NZjMNCNWdIyKP2iAVEVFPUdrZLHPWKOYy1857wEkBtvUCN9HeHCAWC6RnUlgRVe0RHFvn\n", + "w9m94maFTr9NhORvhoDtKHuueJbLQhhKN9yObABzo8QtM9SegdvCHOMIO13sBR5RGRAO8KU/du4a\n", + "jUY6mcDTjcb2CJj7+/sk7GMIu91u9Hq9+Otf/5ppuH/4h3+I6+vr7AOORcR26/xyuYx/+qd/irOz\n", + "s7i/v4/vv/8++4JcTyaTuL6+jj/96U8RsXX4qEeEUTG8z/U0r1FkCGWJXLCeSdm22+2s6u5UD/do\n", + "tVq18g+TySSJx+bBwTNrtVq5Ziw3yBHv4DIVbJDxzuGIKi1kQ0Nj/drIUKZkMBjkPLCbkLno9/vp\n", + "BN7e3uaOyIitQ9Tr9fI8QY8JKRGcTHZBR9SP68HBcKmV+XyevJ1Wqzo6yBwlAgzrTBuy0ijyuR1C\n", + "ZB3jzBq2TrTTyucmXOPYOOhinnCsKDvA+u71etl3TgswSdsUE2p88RmnBUDdsAxzHf0qid+uis67\n", + "E4ShKyIqLmV53JhpC6Qynford6cxFyXlgPuZjmJnhb+x7uzYoYuYF8ubbabnCVACp9XOGUEA82c6\n", + "DQ4R48r6sSwtFosMLO0M02/e28G8OVpl+o7xNAWHd/9/tW/iSCFojlparVZuyTYxNaJaGNQ2Iaec\n", + "L6H8f0RlkDA0zp1bgKzwbbxNfkZImQy+78E1zyuiyqdagP0cFizfJyLHWHAwaERF7ja3onSkMO6t\n", + "VnWqPErJx+V4MZHzNzfFAscYec4iKtStRFx4BouMe3vHE0YIUisN48+7lk4m6BmOFgufd2ShOUpy\n", + "n5h7I44eEzvtzHnE81PVPdc4IEayMDL0uVRgzFXJ40IJ8hlISUTUtqYTQTI/OG0gKJxnxdwdHR1F\n", + "o9GI//3f/62VMWi1Wrn79OrqKtrtdjpB0+k0/uM//iPG43FMJpP405/+VON2YNzn83kMBoN0sggU\n", + "iPpANRjnZrOZu5ow8owTHI+SbE2Q4I0NyKiP02H++v1+EnnH43EiZPAIcUIcUCF/DixK3pbrW/Ee\n", + "IJKus+N5K51GjAZGkXty5l+3242dnZ2YzWbp8D4+Pkav10sZIApHLkajUR4bRF+RW8uvOSQU5+Tc\n", + "RIyRx3uxWGQRVgez3IuAzOuC57sfNtDmQZbcSX/uYMgoNU42fWVevIMYmaJILXO9XC5rXEWXJzFX\n", + "Ep3NWjY66KKTBC9G3HBOGK9y3fNeluFms5m6H9vAO5Q7PyHJc2/GxFkVmjdyvBRE4pzj1JtfxHiU\n", + "G4jgWuGk2H69NJfmKbNxjADGGwbIlpT8KPsBL70DcsguaaOcrVZVWsd/517oW29qMO8aOXVdSNb+\n", + "19o3caSYFEogRFQkQG+pNgmw3W6nYvYL2XiWRE0GgAVgeJAokf7YQNuz32w2uaWbe7qhcLknjk7p\n", + "nLFLDQ/aaBgCjxDv7+8nhE8dFJwMjwtRCv2zQOHBf/nyJRVEGUXbgTBaRZ9N2LOQY/DL+zlKIerk\n", + "XovFIueY75FSWK/Xeb7i7e3ts8gU+N2pFfrvui1W0I6WIuopX+YbZVo6p3ZCgcLpJ3Lj/3NPGjt/\n", + "jMp4zB0EMI+kPIlE6f90Ok2UBkTECoxgABTCjjSE5GazGZ1OJ43jYDCI/f39OD8/z5pd3PPf//3f\n", + "Yzqdxs3NTbx9+zYJye4rNa9+/PHHnEPqez0+Psb79+9ryDBGwakNFx+ldhrIsaNg3os5NXpyd3cX\n", + "nU4nlaBR0JubmxgMBnF5eRmj0ajmZHqDCGkVxoZ16ajc+sBrFJlg/hlHo5Zch0EhYOH9IUvz7tZf\n", + "k8kkv3t2dlbrC87saDSqUSUYt3a7nboLRwuZmc/niXAdHh7WUD7Gu9y9ZxKxEfcyrU/gUeoZrgcB\n", + "t/EtEYDyOtBEB4bM/3K5zFIPzCk7StF7dly5D3rE5x4yXhGRBh/75E0P9LcM6HDSyjQvc4Ls29nC\n", + "QIPaYF9wPuyg0kB/SC8b4UMWsYu8p8EG+o4edzBgRBF55Zl2gMpd97x/SZnB1nFff8Y9WMcObgjI\n", + "CKJs51kv5WYgnjebzTLA9o5Vnm09YZuHvbPTH1GVdvlb7Zs4Uru7u3kMjA9njaiiPhucdrudfCoW\n", + "+0vfL1EXDCyD4PyseVYINM/jXkykBxXhKhd4RJWuMcJkhW1nwGkfvm+0A+EYDAZxcHBQ40PQ4ExQ\n", + "HM4CBe9qsVjkifXcm/6U/xzJ0Fe+S7OBJCX3krPA4ud5KCHm0NfgLLIbzgubcWOePcceU3+/7AvO\n", + "UOn0WaEy9+zEw/Fy6oPrO51OLnBD/yxCO+WlU8DYGlYG5cAZ8Nig+Oinjfju7m5GyqQxnGrkmBC2\n", + "/r979y7l5suXL3FxcZE7Z/mMQ2zfv3+fUT/je3R0FHd3d3F4eBhv3rxJ7mLEdm1NJpP48OFDNBqN\n", + "mEwmKfukz3AEHh4ect3zDGS/THmyFghCGDMCBYw6yINT0IzV/f19HB0d1Zxq5AinlzH10T4YMqf2\n", + "LQcg3jwPAE5hCwAAIABJREFUJwFuF89DP1EM0ty6vb29dOyYCwd+Z2dneXyQFTpcQZ4F0sX8Ird7\n", + "e3vPnIxGoxGLxSJPkCC1wgHAIC42sow7awkn7KXGOkX2jcgQXDht4u8ZIUJ/oJuNLhCQPj4+5vEt\n", + "Tl8a2bYRxrkiI+Lgw4gEuyl5b8pp8CwQScY7YmuL2NHpNJkDVgelOE7oRae2kF9SgiWPEn3vXWpG\n", + "UMq5cMqs1OvuG84EffG6NE/L/2eesKnW0fSV59pRs+PJWqPhYGGLDZKUjqRtADsHoZ+UTqZ3QZfO\n", + "J0h1GYwzfmUA7PZNHCkWLk5ARIVycO7US3WkUHoR9e3t5aQZAkUR41BZEFjcLxlZ/k4E4QgDZ25v\n", + "b68GG3PfiEp5um9WEBYM5+TL55HTpdQCW8jd106nk3V0SpLf8fHxM3Ih/cHZiqhQg4gq522iu+F/\n", + "uEAsNISYBY/w+/1xOIn0rRSbzS0Bt9vtZmTgaN78CCslX89Y+DPfAyeN3/lXKvanp6c8S5BoyqkK\n", + "5h8EjWgex8oRr+UUeWPeS+XOfZ2q4h3m83kqCwxuRIWacL3R3C9fvsTT0/Z8PY4FMX/u+vo62u12\n", + "vH37NlqtVhLRV6tVjEajNDj9fr+GvoCQUJuJfp6fn8fR0VF0u93aWW4RdUI5TjQ6gNpwpOncWPc4\n", + "J4bXGQ+cEPhnyCn13g4PD9PZNCeP4An5dkFSlCny5Ll0WsVGH8cGI2QjjGOy2WyyZhByA0cKOWu1\n", + "qlIUyNf5+fkzsj1oCRsRkAEaaE273Y7j4+M8IgbHeDAYxGQyqSHdh4eHacDMSWFdeCxIMzr4fMlx\n", + "Kj+zbuY9+P0l9AXUGB2OA4qeaTS23DIQHdZFmWLld/cNWXHNI5OUbaAxvs5yGOVh3eOA81zkxMib\n", + "ZZifOF8u8Iu+LtOFpfxRssOZnPKaMsA0guTUHsip0dWI6lxcxqG0lw4+nTovEX87Z5av0pnFcUMf\n", + "e+5xlqbTaXKg/TwQfBxinmPqSGlnDCaUwECZxn6pvZY/eG2v7bW9ttf22l7ba/s72zdBpEajUcLU\n", + "eLx44ERtRiyI7rwLjobn7Dw73rijVe8qiKg4UnACSvIcKTryyWWEY8Ia183n8/SE8d5fSo85vRNR\n", + "oTygbsDKfBcEp4wCgURB9oCxI7Ze+9PTU0KcLrZGg+DL+72EANK4LykK+ASGPP0dw9f8NNLn1Kqj\n", + "J1IP/szIAXPnVsLX/I2oDfnwThpSL07v0k++T3Tmwqr8PaIqLBtRFTEl3VtGMKAN5PSRL48XyILR\n", + "KpAx754qd6yaQwWfaXd3e5grxNvpdJr3JAV4cnKSu1dJUfGsvb29ODo6itvb24yS4Uydn5/H+fl5\n", + "/Ou//muSu5fLZXz48CHu7+/zqBvI7WzxdukLk3+R75c4jUTcpLG9RknhuOQDRG3QwX6/H81mM5bL\n", + "ZaJg+/v7MZ1OE/32bjgQpfV6neiaURNHvE5v0CdayRMBRWw0trsu6TNn9+3sVEdcse4oQ4E+cLqQ\n", + "MfVmmpLW4PQIpRFms1mmUTgPkesXi0WmF42yMGZ7e3u5/b9E5Iy8Iqfl+nbqzH8rKQ4eR3Qlusop\n", + "HOYNBJjyFug0Ut9GGczrRCa5rtfrJUrDeHqNIqtGuv2u/CvHxTQCnut3QBdYlmxX0G/Wf6Q2ndJl\n", + "DYO2Oo1Jf8wlJV3qFNbj42MN9UQ2yh13nnOPATbTGRzktCz7UqJm9JvP6OvR0VFSgXxPTsG4v79P\n", + "/vR4PM77QXlxdofM0EsoE/rbxw5FVPawTPG7fTOOVEQFaUZUC/D29jYrxZZnv5FOi6igQBoD6p0T\n", + "XGuCop0pjFu5648+4sSYQ1OS9pyiW61WydPwYvLzEG5PMEqfrcdOa5owCJmXMSOdAFfHfBYWCie9\n", + "25BFVAbMBDveA4fMZx2WitJpljJX/lLqAy4AzgsOB9fjPGAw+Iz58Th4btfrdRoGO4p8D+VgJeCx\n", + "Z1F5yz0LB8K2nSzabDbLVAjX4WTZKTJUzZbykhPnvnItjflhF9r+/n7tOIl2u52E29vb20wLQeTE\n", + "EYLPxvwOh8N4enqK2WwWnU4njQl9xYCbl0NZh0+fPsUPP/wQ+/v7cXl5GRHbqthwekgn8e6LxaKW\n", + "0sTBpy+eAzvJpPuQTXMOcaSY12azmbvfIqrDu0nvcbxOxJZSQLqUtca4jcfjXL+c+4mTRfV2gjOn\n", + "r1iLcFbKtPbd3V2NZI5Sht+GnJPG5DrkBFnhmJvd3d24ubmJx8fHGI/HMRqN8jtsIMDxMmmY47fg\n", + "m+3u7qbjtlgsYjab1Wp0OdBAFk2JMK8ThwXdUKZIWL8lcZfxdnDFPfn8/v4+D5+m0Q8cPJxFKtZv\n", + "Nps86BvZn81muduPPvPZZrN5xlWyjuP9GAtXkmcOv+ZcW/e7XA625SVnCV3h4Jl72W7B47Njx3g6\n", + "nY2cEpzyPrwrOgSaQFkuh8DFqVOa72XqBoFjs1nVXfTYOnh0OhlnuNvtRr/fj+FwmOvCO3b5PjaR\n", + "6vN7e3vZJwe+pFDNieZ5zBv3sK9gp/ql9s3KH5DnfMmrXS6Xz4htJRHNxpt6VPP5vEYAxji3Wq3o\n", + "9XrPJp9m40YzEmSSekTdq+f3iOqEcHvldgjg6UBwtHOyWq3i5uYm+v1+HB8f15w/cuB2eiIqD346\n", + "naaxwcj6Pfr9fvJQTJDEszefw9exNR1UgDHFyUIB2EB7F5sdD4wBC6fMj+O8lWRrE05ZqH+LM2Bl\n", + "gnJizFx0kTEw0sX7gS4xXy5GimPC2PjdI6LmyL+0HdqLn35gdOwMlvwpHG3X1aLEguXE26XhdGFI\n", + "mA8iOWoQcdRIxPaMvuPj47i9vU1ekhX/bDaLH374IT58+BAfP37MvnBg8tPTUwyHw+h2u1lSAYNr\n", + "JWpngeOCvCOPuScQYi3ZAcEpJ9o1fwynDIeJDRuMG4fQQkZnHo1QTyaTLD4asTXCw+Ew9YvHNKIK\n", + "viyTyAF1veA2cU8MoI054w2SzK5GNt1EbJ3B9XqdZ+xdXV3lzkOcAwwOHEueNxqNYrlcxmQyyaDB\n", + "c2iU3zoRuWQeza/h3c0DMv8S/VeuU3OCynHzWqH/5Zl5BC82dAThOMDwq5ApHy3jYA++TatVlTJw\n", + "RgF9CZeJvoMOsjvNtovfzZGzjkKvY/i9KQgdav1Iw/EoESCutS4xj5U1ZSeS96CQK+jL3l51HFm3\n", + "242Dg4Pc0cnYRlR6jHVjgMRrgrl0AImjz1zwGU4XZ0xSuJNxA7TAsYNz6B1+Jd8Jnc544eBFVPYQ\n", + "Hqht9/+LHxXxDc/aM5kuooLrcDIQLD7jOgsEn2HsIGPbATMZknSXrwdJKCMoP8cKw9FxmbZD8bCg\n", + "PAFMEg6NYUyUy2q1iouLi2fn0Hk3CgsronJIqeHT7XZr6TkWY6vVyoNqEVQrH0dlfueI+kLgmShU\n", + "E/Y9h95JYqfBBFEraIoGEkWXAu77lOPNvf0ufIdxBbXw9w1D27FzGtCy4zFtt9uJQLwUdQMNO51M\n", + "UUWQGRvhMvr1+/r/L6Xh+I7J18yb0zBOC+Fg7OzsxHg8joODg0RyTk5OotGo6rusVlUNtdVqW+l5\n", + "NBpligiEBIfkzZs30W634+bmJpXb4eFhbm9eLpfR7XZr6xfD43pREfVzJnGkyzpeGL71el0bm8Fg\n", + "kMZnNptFt9tNYz0ej/N9n56e4s2bNzUna2dnJ1EdIwiz2Sym02kiH05RsduNMXeg1G63c+fiZDKp\n", + "obm8vw/Z9U6p5XKZQRYOCeMNujSdTms7KNlVulqtsnQK+ouU/f7+fqbGXOsNB5Q+uoYW6TICCqP9\n", + "OFjonDJN85Khj6ijURi5MmhGL3gOJ5NJjMfjdAScgqWvh4eHiT5ZbhycujmtizNhG8R7gcw6eLIu\n", + "sL2wYw2ibH2C7POOTkPZoS3BA+anJK7zLGTE9sDX4jiUtm13d1unsdPpxMHBQe2gc8CPk5OTmjM1\n", + "mUyy6KkRQt7D+tRZkzIVuLOzk/ccDAa5RiHvs+7YMToej2M2m8VyuUwHm/WKHSkDGmcn7Jyie7Dt\n", + "6BX6+VKGye2bIVIMnAWNhU9kWfJWIiKhca5DiBlMFg7Piah2BrFV0v0oHQHuzeQzgDx/PB4nKkB5\n", + "BDsLPt7CSA9pBN4F+J/rIrYTNplM4vLyMgUYp8XRkB0pIF5H1VyH4eEdOMCUZ6LsEXBD0oayvWBx\n", + "2jyPFkbSli+l4UB/XkoJehu455doHYcXeSjlyf3h/dmlQXTl6Bk0g0Jx3lpr9Mi5cuYd5Wf0D6O7\n", + "Wq3yfu4nyr6s98W7olDMV/Bc0Mx1enp6yiKQIDJOlYN8PD4+Jl+AvqzXVYHbo6OjWuQ/Ho9TuQ+H\n", + "w1rEyRZ+EElQECK54+PjuLm5iel0mn2hphHpFiJ+xtvOyO3tbXKrdnd34+zsLKNhR5gYHvpFGpax\n", + "wXHzESl2el0qgfIQEVVNK8ogePzZ+Qj9wIYYhxVF7Xd0KQbk3Gv+/v6+dugtzgm7eClT4CrmrAfG\n", + "ZjqdZn/u7u7S6eB+vAMIpE9a4J6grfTfc4NBQmdbvpBhr2enjNCRyFRJvbD+ceDgNc/cIVMgijc3\n", + "N6kj4Qcy9kbduQ9oFSgPcxZROTY8z2uUccSJBGHku+h1B+iMhdGl2WxWQ2boQxmQeecfes16AHk2\n", + "CMCzmQsQd+tFEDBnTEqH/+TkJB0ngghKDlFU15mDyWQSFxcX8eXLl0TNjbZbfqj7xrh5N7jt/HQ6\n", + "Td2DrqVw87t373ItgdRbXzqgtn13MVFnDdy8Tkod7GC+bN/EkQI2da4VQwSU7Tx1RP2sMje2MuMY\n", + "4KxE1CvQAsWW6R0iMASSZ+EIlAt/tVrl1u7BYJDRD/dcrVapwHg2DQ8ZI4/iM1LTbDZrXAAbAD63\n", + "h2042FESzgef43Q5p0wEQMqkVBwIpAWohJq9oFCWOAXmifCe5lvRUNAQbv0eVrLlAn5JPvhbyVPw\n", + "IsXweu4cudlY2JHi+8yJiyc6jegjbTx2yAPGAiOPkraDamSNOXcV84jIjQk4py6Sh1LEYcfxYdwu\n", + "Li6i2WzGn/70p0x3RGxRl8lkEu12O3q9XoxGo+wLHC/m3+nynZ2dODo6iouLi5hOp3F4eFhDbs7O\n", + "ztIRfXqqOFInJyeJvJQI3/39fTq9yBuK9+7uLobDYRoC82AiIonpjJ1lkfXJfSeTSQYuGFqcKVBA\n", + "3h8Hi3F1oUenFOBXRWyDr/l8HqvVKrlnyJvnDF3E86bTaTorOKomhiPTIIrML6kOc2l43nK5TN4K\n", + "fCGaNwHwTPpGSgr9Rl+dirLDYn5VGQQZ8WaNOJApr2NcrQv39vbi+Pg4ms1mXFxcZLAQsTXsLgJp\n", + "buhms8l6WWUpFqNRERW/LiJqWQb0rtNb9JE+lzoOFAj9xpihR5BTb2xAp30tyDVqwv24FufO+svf\n", + "KYNYz816vT2fs9Pp5Pu32+3o9/u5PsqyGaenp7G/vx9XV1d51BHzyRhjSxwsUtgVmgLyDeL4p//v\n", + "CKqIqNlLBxi+J6iYuVZG/rHRzJODIQc/zohZfr/WXssfvLbX9tpe22t7ba/ttf2d7ZshUnjbJiSa\n", + "0FdG0EQ/L6FSRKrwHJz2wyMGHizRqpLgF1GPkEgdmo8CeRS40ygI7wTXgqjFRDzQFzxeUBATac11\n", + "MTpjIp/TlbwL1xEhE0X5ufQHJAK0zrwl8yQcCXIfPP8S/jdq5pQoCN9L3r1TcyCTHm9kxTwN3tE7\n", + "kIxaMqaeX1f+Bf3kXQ19g/LwLMshssR7esemPzf3B9kiMkOGyk0McBQcUXEvpzrpN3NNuujw8DCj\n", + "cu7DmB4eHqYsXl1dxXA4jH6/n7sPzeWCHxGxRUW88wfonvsz3p1OJ6bTaczn8zg8PIx+v5/jPp1O\n", + "k7S+t7cX19fX+e69Xi83aJTrwOgb/DTLN2sK9MnzX3KV1ut1DX00Z+b6+jplsNvtJmpwfHycCDl9\n", + "6HQ6Od6gPfSHdJA5fhGR6BQ6ylxN1hbIsPlqFNXkHg8PD5n25FByZMSEcsjUpIE7nU6tn8gKRTlp\n", + "ICnmOprnVPJyjIiUKSzTNlgL6HGnAXl/aAfmMpYcxZI7tbe3l7tPXSKk3+/H/f19pkJNGWAeeUdz\n", + "hDjmaHd3NzqdzjPEgjWPHbKu8fp01sDjgAyASNlegLTzzu4jNsgFnEE1bRPMvcIucF/3weP4EoEd\n", + "efTmFdZlu92upWkjtutpMpkkSuq0O/PN2HlDCMgmyHC/36+lruHvnZycJDKHfG82m2i324mce10w\n", + "V8yvqSQvcd4i6kdCoVdsZ5xyfql9E0cqImoGJ6LiCsDELw0uLwMR2/UtgCLLVjoShnip4RFRKQRv\n", + "/0dBt1qtrKsTESmgKFgbWsimCA7OVMQW3rcjZ2WK4baTiJJkxwVQKoQ/PmMcymrZGGxvC3WDw4NC\n", + "cjqJBY2xNMSPQWIhe9EwjzYS7g8OdJmiY+xw/nhfnuf0BlyTiOdbhCOeVxKnHygVPqMBt5fEWDuv\n", + "NDtY5iDw3jYmfj73Ne8CnhJ9Nr+MHYHc105A6fQhN5xHaRnm3hgTZIXSBJPJJDlhvAelRyIiU1t+\n", + "/+FwmAqu1+vlO04mk+TsQNTFAfHxMHBMUHwofQjqb968yXdAcQLhe4dRufOHs+EYJ2TtJUODs3B9\n", + "fR1HR0fR6/WSGM9643NSD8gRTjvvwrhhaNgs463nfEb60QYTmSFVtFgs0iEidcpacOBJ3Ti4TlSj\n", + "Z9zYgUddHe7poBMjxpiaIE8Kz5whO0AOsvjd6VNzJO1A2ajyGY5CaYQdhJS8V/NpGU8+Q3fiTMFl\n", + "5Z6Hh4exXm83J3gnM2e0HRwc5Lt7V6EpBQ6CSse5lDWaAxsajq0Da77rVJt1B7KHLkCmmONut5u7\n", + "TW0T6Lvvb3oEY4jceA5sr3EibfccBDsgd3r56al+EgYyjH5zYLa3tz2Q+NOnT9Hv92upctb509NT\n", + "DAaD3LEfETVZKpvTdeUckj51CtU25W85URHf2JEynwnhoh6SvXwf6UDEXZaUh6lvTo/RAr5b5ovN\n", + "rfEgRlR1RUo+ixcCzhR9iKgQj1arlSRWHEUiCyMlEXUis9+dhU2UZwFGKWA0/G7O/TsqMXEawjWL\n", + "wxwLhBEhsmHG2D89PSWpnnmiMaZGB1G8cNUsnDhrnhP+bifI8+moECVvw8911BVBdnB2MXg20EaV\n", + "kM8SBUXhY8j8fp1OJ4nfcP2YKxt5lE5E5dRybx93gbJk/I3KMkcYate1ohAr48WOlIhIRwgkh7pR\n", + "3B+HiF1m8BTa7XZuK+/3+zVuAuOKscAp8NywPr0pA6I1xoTdpbwDRW4Hg0H88ccfz9AKnETOoWTn\n", + "GvdBH3gNU6YEVHB3t6oVZQ4RjqePbMEhIEhxkUCQnv39/bi5ucmxwYFip5yRYwIjxsbIOhGynWOj\n", + "IHA97u7uktcWUTkSg8EgHVT+RiAKR5Pgj3vyDAIbZNS8KFoZLDDHpUOEzkCWHbTZAfW93JAHjCdj\n", + "MZ/P80xHry8QRcoZ0Ad+8rz5fJ71qSIiZQG55lgUnodjYieQcbCz4t9L0nKppxkTdvq6n9hIvufN\n", + "D5ZDdBtIJqUCuLcdYNBfxqa0ew5KvduTsxlHo1He344lc/4SL8tghscJ+UAOncFoNBqxXC7jr3/9\n", + "a3S73dpOdnSFuYXmN/udSn4v4+hjZbgOzuNLOoZx/1r7Zo5URLUdMaLa1dVsbgvrmXnPIjEpr0x1\n", + "AA/7IE2ntPg/SondTjzbUQXXEFnbeKHcOBAxooITXX0VR8GHyK7X6zg7O0tDiSDyLAx/uf3fKQ4v\n", + "ZP6P02RBdASJILu4ohUdC9aKj7+h9LgvTiJGxM4LDh3v5oWDwjcK5uKEXMP1jvSdtijlwgRiRw6Q\n", + "e3l/qjZH1HdR8f7e3cU1yJU3ExC1QFalLzx7d3c3d0yBakRUu8QYS6f9UGxOmdlZL1Msjio9vrPZ\n", + "LO9pZWGSPPcYDodZc+3NmzfpSFBD6/z8PO7v7+Onn37Ksb+5uUmnlIgeWez3+wnH23GKiHS6GVOn\n", + "w5fLZTpSw+GwdnYl6X4czfF4nDKD3JGKw7B4JxVjS/BjFAtj6iiV63hHHEOjk8iCHRPmn1IEvV4v\n", + "jo+Pc+5vbm6SUEs07RQ7fWa7uY0//xgDy4GbN68wt7PZLPr9fpyenqaz4Cr9EVWtqojKSfduMho6\n", + "0alCI2tln8pxIxgrEVCjxegwf8b13BvnFnSf3bDMtRvoJ+PHmOJksKvTwRCBK880Gsma3d3dTTQF\n", + "mbG+c5BM4OC1YGcY+4Vd89w7Y+G0FBt2ms1mnJycxGg0yvM0I6qAnnfkLELmiB3eOO4+NcF63rLy\n", + "9u3b3DSBzCM3nN3J2idgiKjOvESOLVM+H9YOFM8/ODiIq6urODs7i+Pj47zOB7y7dhdjit5HPplD\n", + "9LptrQNUHFQcQaNjBBlfa9/EkcKgl3lH5599HAwGC2PValXHSKCIyM96m3fpmRoiJqL04LphpHDe\n", + "zK9gCyi1j2g3Nze5Wwlnw5yN0WiUUVS5swBOR5mic6qp9JT5HAiaBc13vKWY7zki4HqUl6MhBBIH\n", + "oOSC8E4ggYyNnS732TwJlH6ZejOCUDqZdgZ8JIajWws/ix2F+/j4mHA1KTA7Fu4nsgZqZbSI8QSx\n", + "4h2QCcaj3NV0e3sb0+k0VqtVLkyUDeUErIzdN5QCn7nOEE400WU59kD8ZVoxYpviGwwGcXNzkzJ1\n", + "d3eXu+7+5V/+JXZ2duLjx4+5Joge37x5U+sLjg5Ov2vJGIWF20DwwXgC3eOs0T92wOFgMU/IAcaD\n", + "delUFGkE1hD9WSwWMRqNMqq2o+5AgMYcYrhZr/P5PI34cDhMWaBa/Nu3byNii2idn5/HbDbLsQE9\n", + "IEA0j8cRsPkz1KKime7Q6XRqOhGe1OXlZS3A4z34HnwYZJh5QoYdtCCPBF1Gap3WQ19aFq17rL+d\n", + "6isLspbUDHQ2Y0S1+sVikXWtPGe9Xq+GSPK8vb29Z0eO8BnrnUDbaJJ1aYmGe94c7PJ3nDfrBBA/\n", + "bCFOX0S169rv7lRxt9uNXq8XJycn8ebNmyxXEFEhw+zeNGcrorKnrCHzDnkutov3R2bX63Vyahm3\n", + "29vbuL6+TlS4PFrM8mAdtbe3l/QAOIK2ewTrFxcX8fnz57yOEgqMnxEwp5BZP0by+D/p3bIOmndV\n", + "O/PDevha+2aIlJViRDXgX4NOidZRelYGl5eXtbowL8GK/LPBiKigVyMPEfEsAjDSBPy3u1s/dXu1\n", + "WsVkMskT3bmWdxiNRmmE5/P5s8VtVMOGvSRK+p5GjEqvmYX48PDwTJmyOBGSElpnQRGlsRCJql/y\n", + "+JvNZjoE9NP3xAlDgJ3ztsNYCjGKgMXFO2IAcAKtLOC2tNvtrHhvmcFZhDPibewvGVOPGYrHUTeG\n", + "jrkD2WAe2+12HlVCLRnky1W+TRKNiNqYlP3BkMJzKQMHIPj5fJ6IRMTW6FOj5fPnz8lRYixHo1ES\n", + "rc/OzvI6qmh/+PAhlRXt/Pw8NptNPtM1hkC+4HFA6o2oUvKk3rwOcQR3d3fj/Pw8DVJExZtC1kAP\n", + "eP/7+/vke4FAMf/U8+r3+7UjnRhveJcmqtNASymFAFnb9XNAdJCpdrsd3333XVxfX2etLNY0ZSqo\n", + "i2SU3s4I+stIR6/Xi6urq6y5Y94Z66vUNUTzjFer1ao5w+iBMsB0msjGruRHlpwg/5/rLd92jP0M\n", + "PmOdsP7p6+7u9hw9Ni4YHcWAsjGA+3NPOFOWPcYNtJnvligX34uoHCcHob4f98CJQh86o8B3+LtR\n", + "avfZDgpHIR0fH8fx8XGMRqMa0uXMBmND/6iDBvhgvYiux6G07ub4Keut0unhPubaYTvshJR8T9LL\n", + "FJ+NiOQEdzqdmM1m8eXLl1oxVmdg3CfI8GRyeCfLk8fJQZK5WvSdn6V/ULbX8gev7bW9ttf22l7b\n", + "a3ttf2f7ZkfEEP3Q8LZNirbnC6cGb9yRxtXVVUK4jpCA/ZzWcCMyMyRN/0zms+dKhWwfKeFidxA/\n", + "v//++0SJIioO2GAwyPcGiQDFMCzpaAC40QRC99epMb8bKAZcAUctvh+5eROjndp0lExRRj/H6UtQ\n", + "Mg6VdPRFuhCeBOPmSAfI2OfJ0UjXODIwCRRZ4XkgI6RESn4IHBzzrnhXw7vIB7C/eUnMJVwk8wcc\n", + "vdOXbrcbk8kktwtzHxdmNBoGpwjuUpmChptjNDOiqpoMB8SIBf3+9OlTNBqNWmXz4XCY79xobI/D\n", + "+e233yJim7L6x3/8xzg6Okr0lfcHoXGBW6dFQAxAnoxwEpG+tA6bze0RLxcXF7WjZUBwkRe4Hy6S\n", + "eHd3F/1+P49Q8Rl5lGTgOiMKpGzhiZQ8zogqfUaKDmQL5IS+8TwQ6VarFbPZLGWROfPGBsYNukK3\n", + "2817mwO2v78fx8fH8fPPP8disYiTk5OIqPM/WRs8zzoXlNq6kY0+ROGgAGQEQBiMftIf5q1ETtHB\n", + "rB3TGpBhj1MpB3zXOyEbjUa8ffu2htL5uZSHaDabcXx8nPNGMU7QQ/NRkdu7u7uYzWZJ0aBvfMfp\n", + "f/5m7pr1kxE90si2Ud5IYKTOckmanNQdx6dAwGYuTP6GPkHaE1oDRzvd398nLcbVxUHOGo3GsywG\n", + "RzAhH6YKlHxNyxm6H26ZU6KQ3km3IlOsa747mUwSHUcX8t4u8kza/eDgIMfAdBcoNKW8mF9b0mSc\n", + "Qvxa+2ZHxJBSQVCddmHQnTIjL3x8fPxsgqfTaUK8hhAZjOVymXAlCoVjK1CIdnpQ4F40Jp4BObIr\n", + "y1uL2S01n8/j5OSkRmREATHRJQ/IcKj5BU7vGHrEsJK2wEiV42zyOO/BgsGAe7cG6T4LpwWcbdMm\n", + "YPIe5gdhCCIqDgWOoB1CeDU7OztJjCQVdXp6Wsu505+ISNL/09NTpoCsoHEG7ExFVAbKaRs7mGyJ\n", + "RtF64aMwkJ0yzUjeP6I66JM+c583b97UlC0y4/Sc5x/DYz5aREWQJI1jhxLl3mq18uwsV8zGQcO5\n", + "Mmkhkt0rAAAgAElEQVTaHKBPnz6lXPz4448xHA5zfqbTaXz//fcRsd2qP5vNkh9kxx4lv9lsnjk1\n", + "7XY7FotFchst+5BlF4tFEstpOKlwS2j8v9frxePjY+6apSQA98WYMJ/mOpEOGAwGqacsT+gJ6wWC\n", + "OxNTS7I19+cYHuYeRc3zvL6pB0VZCesI6iQdHR3F1dVVHhLd6/VSR2JomcMyYMKR5XfWMPrQgRCO\n", + "J30z36Xk8TmIYK3hpNqRMuWiTHmxFng2mzV4XrPZjHfv3iWV4uLiIiKqndQ+fxV5Y5ezd0mXwUmz\n", + "ud39ae4kzrW5tuZysW7os+/pVJF3FZsP63sgM8gQARpOrY9HIQVHMG254d9yuYyrq6uIiORE+VgV\n", + "7zonqME+OAVrWgNEfd6L5xLsWrez3gBD0InIBGNmXes0LqAL74Df4DReuQOeMbF9KmXRtpRSMuif\n", + "ssaf/Y2X2jdxpDBgCEPENlLodrs1h8oC2Ov1otvtxmAweLaLrtfrJQfDEYa5P+v1OksrRFSCQKT1\n", + "UqTPdXZOUBAonPKIBQZ8Pp9Hp9PJd7i7u0uP26eS01j4Jpry004Mz46oHByEAuMfUW0RRTFbYCOq\n", + "Mg54/RgtmqNLowXeMs7C9+JnfECu2I5Ozt+L15wGBJnf6ctkMkkkwjn1iMhCkpAnqVWEXPj+cIb4\n", + "HcSsRPkiqoJvLGZzIUz+Rh54P5w/5LBE71C+RJn0r9frpUOE019ypIzwWG4ajUY6w5YNR9soThck\n", + "3dnZiV6vl+/nOmmdTifm83n89ttv0Wq14ocffkiZmM1m+fPDhw/x7t27iIj45Zdf4vHxMR2Yku9h\n", + "vt16vc5dOBDwefbt7W1thw7bwr2jkbVAYNHpdGIymdTOokPeMYiHh4c1gjsOD/LE+9/c3KQjuFgs\n", + "kksVUW0Hhw8C8Z7nEZCg12xgzEXp9/u1s/2oPUVJCq/DTqdTc9iN0j8+Pia68vbt29RTIBGLxeJZ\n", + "fT2cdProulV8hgPW6/We8XRwvJAtI3nIKfrdXCcHUs4CRMSzde8xjah2hxmlZ7yQ3ePj4+Q2zWaz\n", + "nNfHx8faMT+gfqwnb1CgD5vNJnlFXt/oPO7r/ltPWy4YN+yZSzIMBoMM4sssDI4fusubNwgeAAcg\n", + "lLuMBRshOPeSsQFVp78GJQgEmGPPE0619aQRKH56juirHS4K0jK/XttuzmBgGxjz6+vruL+/Ty4n\n", + "epl7An5g+x0o8BP7YE6fkaiXHF6/e9m+iSNlD9GQa0R1fpgJzgjSwcFBIg8M3N3dXRrQciLxSL3t\n", + "GWO6s7OTqTi8ZUf7EXVkyIsNhc5EMOh8B0V7c3OTC4LnOP3C+3nRWfmWf4uoH2ZpR6bVqh8iasFi\n", + "0TjCREiJhktCrYXGSAeLkJo5VnyOaJ1GjKgIgihTFFJEVQQRobcimkwmuRMSpWKUp9frJXkSo8J7\n", + "ozDLVEO/34+9vb086BXHppxD+shnpHvYUuw5RA7Yudjv93NsI+rVeBl/pyy4/0v95fuO5HjHMpK1\n", + "Y080zrg6LeICkc1mM2Hz09PTWK1WcX5+Hu12O46OjvJdHZV2u9346aef4j//8z8jIuLLly/x/fff\n", + "55g7JYaTiLM7GAzSYHz+/Dl+/PHHRHF3d3ezphUlLCIiKxjbgPEsEN7r6+taIMK7objRMSBuTg16\n", + "XgguMCQYIeoKgUyQjmMOHdHaCFuBs4UcRwrjRSDlYIgxNBLqgqSs7Yioka2Nitl55N3t8BnBR77R\n", + "F6Sc/dn/Ze/NfttKkjzcIClq46bNdpXdNd3ThcG8z8z//zbvszxMowvdXVWu8iJLJMVVEkXyPhBf\n", + "nu+EWXMvGhjoPigBw7YonpNLZCy/+GUkjhB/m2aADHoOeHc+CGT9ApLF851KZ24oEWKn+8uXL8X5\n", + "pC4Ua+j0k20Jz2G9nGoz2szY6IsPJ7muodce5y2ntXl2pp6QDuZ2CdsY0DcCIh9Acn9ADq3bHx8f\n", + "yxhx1HPmB8fNwT9OKQVJjWT6uzyP/2MTcGLywSWc16enpxiPx2WvcdIVe+D0MPuBFKpTa+yBxWJR\n", + "Ds0gF7bZgCXMKw6R9asP+jhdmIOEiK9Ljrg9iyOFoXReFUTFhp5FBGoEdnRkCvxoFr8dJ35nX979\n", + "6uqqHPE3IsJ3zdfKCEREvRQA/+cZ+fJdPGyEzekqn9CwgPI+KyU7Ofyco98cX2bM3mygWeZlOVrw\n", + "WvAOlIznBUVMmhDEI6KKonB2XI02IuLz58+l767ezfwQnWRFZJTAGwqZQOHhOERUl6yyUR0xNhqN\n", + "gmJOJpOYTqdlI5pX5e/zPaf5zK3i+ZvNJobDYTnlwjvZ8EbNnMJxCi+nxVg/UEYaa4TSdzkGGwXk\n", + "ysejKRrKZyBL/X4/3r9/HycnJ9Hr9eLm5qbICHPSbrfjj3/8Y3z48CF+/fXXiNjVmen1etFq7W4C\n", + "IHWFLFrpNZvN8jlXyXz58iVOTk5qx/hns1lJGVLoFIQT5Utqo9FolAKUEXXFSGqHlCvGhdQA5Qci\n", + "KmNiOUWm+I7RFaMQ/L6d5Iio8RNZJ8YBaomsgZSyLk6h2ZiCcNMH73eOoeP0g5AyPtARZDsHH+io\n", + "jCDjuOIQ2Olx6svpE9YC3Yc8O/jCCTBixR7z3np8fCxyMxwOY7vd1U776aefagjCZDKp3SQB8kRf\n", + "cDLYI+bd2TEEDeH/lhHkgf5hh3xaknlzZgV7gsxwMTVcVFqer5zuJ2ADmSOIo6/8Xg607JRnxwDZ\n", + "R5/4e6D+rIOzNDirppA4S+Gxr9frGI1G5bsEVft4S0b/cxqZ/X97e/tVCpaWKQHIL/OaA1DQOnwI\n", + "15/ah7bV5u43P/k/bJBNM78moiLp2rnAyOBQmSsQUU3C/f194T5F1AvamfMTUTkXh4eHcX5+XgTT\n", + "ffGGt/OCcsLZQ4CdIgT+dRqPiJwog2gPw8uC+eipNzqC5X7a4XC66PT0NO7v72M8Htfy+a7fYvjd\n", + "ggJ/i7WwMgAyJUoAQeJ7kAm9KVnzu7u7WtToHLiJmCbwHx7urv+4vb2Nb775poaAkQpmDhyZgDbi\n", + "NHgTMI84TBR+i9ilBQw5k86IiBp0jvOeG4oKkiPOC7VPkDk7x0Sc/DxHdGx4Uo05vcP4HHmjzKik\n", + "3el0as77ZDKJzabilqFsbm9vCyry/v37WCwWBT0hzfv999/Her2OX375paBHkNTZDzlNzd1+y+Wy\n", + "5pxTDmG1WsW3335bS+kfHR0VxJDvei88PT2VUiibza72D5wvUoYYZ6OujoI56OAUhh1G1oc55boo\n", + "Uil2pHESMUTWQwQeFN1EvpElxujaVOhJy7D362q1u7KHAMlXJ6FDcL4cXcNHwzgbBffvOqjjWayd\n", + "6QXIBnKDrs0omH9GY96sX7Jjw7sp+hoR8Ze//KWUdZnNZrWq94+Pj3F3dxej0WjvO3E60BE0HE76\n", + "awd0s9mU4MxBDt/DGcyBEJ+xh0FCkYvNZhPT6bR25Q/vA2kFdTL6CJeU+xhtB1gndEJOb+EU0XJq\n", + "zw67i53iQFFY2QgVeg0ZNRptp7LZbJZnsu/gf5liYRlj/DRz0VarVQyHw9qBAyOa+AQenwEPyz4p\n", + "0+12G5eXl+V7Dqp+q72UP3hpL+2lvbSX9tJe2kv7O9uzkc3xsJ0qIXVDysL53Ih67tunB5bLZYlk\n", + "fRWII8RMGMMTBZ4178oeaGb98128cPNlQC84yulrBHxCDvQBrxj0yDA+jdSVI1/Dpk4LZGI06RsX\n", + "WvMxf3OfQBsidkgPiArpEx91hXsGIudCaaBSRHT0td/vx/n5ee24Os90Cq3RaNQKrrK20+m0kCB5\n", + "Jgif8/JGwCi8eHFxUTudBBpHtH9+fl7m7fPnz6XyfLPZjF6vVyO3A20z10ReVKbOJFM4KqQMF4tF\n", + "Qao8DlJMrC9yg+wR6eVjxUS8ufAgEV2j0SicB/q6WCwK+R5uzZ///Ocip1wcvtls4urqqqBqj4+P\n", + "hZMGcsWpPTgN7LHlchkXFxdlDOfn5+VdFNnzWsCXcCoVOeWOP1Jk9IVn+UJvk/RBnFxgMaJ+d+fR\n", + "0VG5EobvwVdh7xjl4y4+iqBa3s7OzopucqoNlIt97JOd6BDW0ukl5IoLhnOa3frOqaGcnrMOI5W3\n", + "Xq9L9G19wv/z/XdGXMxDYQ8zJ6TNXAAVtNlrYHQwo2B8ZhoBKAmI47t37+JPf/pTOY15fHxcTi1C\n", + "tAe9v76+LnMGgs6+MfnbiB/vN3pkjiHzynwbQXYajv0AsmYkGp3tAsG/deraGRquJyMTw/s8x+wr\n", + "dPg+JNDUCGTRtIrtdls7dQ6CZ9pNRHXlljlGNBBPp25pli/G6cwP68WhCMtFRHWbAbo+Imo2Bf1u\n", + "ZJz+OCXNZ+axIR8RFaUhnx53e7Y6Uvvys0B2FsKIiq/EJaZ2LIBoUdIWRlfhdh6b9xkeNK8h9y0r\n", + "9oj6qZmc24aUahg3oroPDkVkweCkFA6NlT7v5TSG+wdcifLEkJsH43oa5lhYMbPRI6r7rJz3z2P0\n", + "fBmqHY1GtbsSPX7nnd2YE893zk8/Pj7GfD6vEY4pXQG/zmuHHGGw+/1+MV7Ox6MQ+YzULWkBH7k3\n", + "9M8fO7gYdOqaWE6n02kxyigik+3NPbHTYwXK85z2pQ+sh9NRrCm8JQcmOHWbzSZubm6+4hUeHByU\n", + "K41YZ47ncyEvvDVkBsNwe3tbg+k7nU40GjsC+jfffFOrst7tdmuydXh4WOSJe/jgpzjFTPkG0kL0\n", + "P9emg+/glCjryB42n+fg4KCWQnx8fCx7kHc1m82yp3wCibRw3i+ZrDqZTEq6lEuOfR+aDz64XlZO\n", + "l6Hw5/N54Y4yb+wNc3voA4aNAM6pYhtjX9rLHuQ0qoORiJ0+YT1szPiuqQKu+5MdKq8xP3eqlGd+\n", + "//33MZ1O4+effy57mGdyKTdpqsfHx8LLIViPqNJVdlxt2E3E93jZd7YXDoqgNfh96HtSvH4mOjYf\n", + "+OF7OEbMC79r0rdTf8wVTj22yH1FN1g+sJ/mvxmwADzIlBaew7p7LQj06Yc5nsw/e8Z2wGn57PBZ\n", + "Xpgnp/74jHIL5qQR4LpeGu/DGXVql/nM78/tWRwp35HliCaiykNaESGAkOtM8iVfbKKueTJm7OOh\n", + "RlSOAwrWgsiC47ka6fFkmrjod+wzbC4+aVQmokKWUELk/pkHPjNRlL7QB4yOyeYRUa6eoFaRyd8m\n", + "v2dnEUcTwTI3w/NgxcRJOG6iz+Rnk6OtNMwLy84skS3v4Th7RIVs8jveTMzN09NT3N7e1hzefr9f\n", + "5tf9YAyvX7+O9XpdSKusPQ6ueRM+DYPsse7mBzCHh4e7m9p9TYg5UHa23SdkgEtA6bsdYDuuPA/5\n", + "wAgig1YioGX0BfmHAP7dd99FRMT79+9LuQF4OD4J980338Rf//rXgtjRF+48Qz6/fPlSHIl2e3e/\n", + "Hg5Uq1XVQluv14UvB5cCzuHj42MMBoNy3Q7Iqfc7z8Dw55NX/r85REavfTzeAaBRK+YebmFGE82x\n", + "Yl1w8EGocJ7t9KC8XZ6AqDiTmH2whbnHcTFnpdGoymUg03bUMSDZGcr8VAy8kTzrYOtJ81TR4+ZY\n", + "8V3WwEiWUSC3VqsV3333XaxWq/jhhx9iPB6XS6LzNVWQ0plvo2lPT1UNIjss7DnztbLOsk7EmWMv\n", + "ZSfSyBTOPmvBWB0g571sp3W7rV9jw3hMhqeved54nrlcRt2Yf3SZZdkHqH7rpDey5+CBAHKzqd+P\n", + "yfdyPSrPKTIMQsozsZW2t3zGOuZx2dml8UzLApmynC3LqJ7bszlSEVGL9vedmjNZk0ldLpe10xTA\n", + "jUYJeA5CbOWQoUR77vaWgQRttCPqpHicDBNHSRHiRLBJ8YJZlExGRZE6VcczgcbZqBYEPiOKR/Fg\n", + "HEgvTiaTWoFMKzungZg3lB19zg6h4W0TGTebTXz8+DHOz8/LJsj9iqg7ITyPZxpiR1njGLkKNesA\n", + "apCVDf0jIjVakZ1jK7eIKCkEn1BxypENZ5QDBwj0xOli+kZUjQLlHTmNQN+QWaJ9EAEa91PxnuzU\n", + "s69AN1gDR7NOeyLDkMK/++67eP/+fUTs7tP7l3/5lzg4OIj/+q//ipOTk3j16lVE7NCqu7u7uLm5\n", + "iYeHh9oJuuPj40KMHo1G0Ww2y95nP5+cnBQHjMb36QupNtYCB2swGNT2IWNcrVYFBXXFcxwrZNx7\n", + "itTPyclJQW0dYPkAxsPDQ1nH5XJZCosif3a6+Bmpa/pDtG5Umd93LaN+v18zrugDn5BiDCaS814b\n", + "K4KPiCoFyr9B63LAlJ0a9BljRN68j63fIio9472f98i+tHYOkCKq0hDdbjfOzs5iOBx+ha47lWZn\n", + "kb2KfkT27QTiODozwHx7bvns6ekp5vN52btZlxIgWyc6Bcf/mWMHxYzB9AocGZAp20v+DeqaM0Am\n", + "1FuHIYPoQztLnGjDEbXcoa+dQrNjY/TecoGso989r6wZyBF6ivlA9jJKZPuBw8n7MiptB4y95YDP\n", + "yPD/5kRFPCNHCpjQJ6EYCM6DlRtGgdM4hjkRSBbMgunN3GhUx/+d42YBUTa8z6mwfWMAIfCx44OD\n", + "g1KBGmXDMxk3C2OjDG+C/rmuDUUa7TFH1IuWNZu7o9PwUlAk/M7Z2VlMp9PixFq48e4zPIpQMUf8\n", + "nO9ZcTKnmbPGWuAIYJgcuUdUjit9M/TfbDbj4uIiNptNjMfjEl2ykdhUTiuguKxQmdvPnz/H09NT\n", + "XFxclOs3aCim9XpdjtxbBtjw7i/f8+ZEdoz0oLhcUZtnGv1zetvy4XpbXot9R7lx9H1qC3kHwcTR\n", + "6PV6ZS045XJ4eBhXV1dxfX0dP/30U0RE/PM//3NcXV3Fv//7v8dwOIx//dd/LcqGAp6r1SouLi6i\n", + "1+uVyJNIdbVaxd3dXa3QIykh+m+nEM4NhsnGAM4R8+UghHeCxOB822CyD1GuDgY4IccfdJSjV97j\n", + "9R2NRnF0dBSnp6dxe3tb5AM0A+fK6SRzwAiK+B5GBHQEh5Q+MH6CwGzIrL/sKA+Hwzg5OYlut1sL\n", + "PpAT9o0DW+TNDpMdBpBYI6R2bBzY2CkAMaSBavF962bXykIv3t3dFZ7jt99+W+YUBDYHZk45s/7Z\n", + "kWLNfNqXZ7AmDnZZH3QvThXy7XSaUR4KCmP7DAJQOgbd5SDCts+OhlEwvo/TlB0pI0UeI2vCz+0Q\n", + "gsqwJ5yWRdcgG8wxKWaQZdKCyBvlQkDXLcNGvtx/mp0yo77oWcAMAiyP9elpd20aY/B7mTNnHv63\n", + "tF7EMxbk3Gx2VYfhprD5DTd6EUlPAeHnaIXFiqgEwkRRCwKfkU4Cyt/Hs0FBZIcK4adYZESUu8eI\n", + "sM0Hyn3K0WVERazjGfQhC7ohRzsr3CPFfDin3+l0ym33PCvPsfPFkEeNGvFOoiiUt4XThGZvRMPb\n", + "fg7vxtBlB6vZbJZrBUBmMN6Qwp0eyAKPkXGqCbI0Ssx5dKJRNo8RoMFgUIPqGTPNKBKlJ0xUJ9WW\n", + "o33PrbkRNL6DwvY7I+r3eTk4oC84YSgU114CjSEtAupGam80GpU73H7/+9/Hf/zHf8Tnz5/j3/7t\n", + "3+Lg4KDcwweacHFxEZ1Op2bYIf2Px+NinO7u7iIiyvwSqXvclhUUW1ZuzClOodcR9IG0t6NKp7iz\n", + "XsDQMEdGfChrAkqUkczr6+v4/e9/H4PBoMwp84qSdnXn9XpH+saozufz8j6QDiJ2owB8F+fEe8by\n", + "wVF/p3GPjo5iOp2WquYucJs5S5YnHCfQIKdoPLfoAOstZIo96vQ0Tk+O/NELjH84HNaoIOjRX3/9\n", + "NT58+FCrMYb+y6lG7ADy6WDI+jjrXPpNf7wORu3zdWNZ39uOIO/+mR1MO6I4h7yPdK5tofeGUT07\n", + "xZZr5NzvJDDNDhGyYOfZhynM87Q8gIYSkFoWjV4yT0admHNssPc26+xglPHRRwcrXif+jUzzfZxB\n", + "yke4EZT9Vnspf/DSXtpLe2kv7aW9tJf2d7ZnQaSIgrfbbYki8AINM2evkOOOERUxjWj31atXBc3I\n", + "RHWnBTKHxnCiv+Ncqb+XoU4QE8ZALhkYmsjT5F9QFEcYQMwHBwdxd3dXoGFQJ8ZgLxoEj0ji6emp\n", + "nE5xocGcQuS7GbWyx79arQqXxH01zwfSrlMRoIdOtzF+5of3Eb3QR9bcXBcXkiSV6iPw4/G4Fn3k\n", + "dAScj30RBkRpl3BABpHRRqNREMfBYFDSMhzH5b2WXZCu2WxW3uvrjUA1kFOjCVl+Sd1RcDFD8Ya8\n", + "c/rLc+so2b97eHgYHz58qJ1aQ/4hf799+zYidoVjf/nll/inf/qnaDab8cMPP5Tn9Xq9glQis6RS\n", + "KbrJGt/d3RUOWrfbraWSHHmDUBKpWp4gLVMtfR/Pj1QDe8R8Ra+XOR2gFIzB8kSVc1CJdrtd9BdF\n", + "NofDYSlOCtrOaT5OnZpG0O12y54h1eQUItwxUFCnzeDjUWrFyAJyStrESHG73S5pPd9DR5kMo0PM\n", + "p9FQo+smamfU38greiNzQPm+9YVRDfpwfHwc5+fncXNzExFRkI3VahWz2Syur69L1XPeY6TE6TD3\n", + "LaNBIDXsT/oHdwiujrlNRpXg74L8I3eupo4Mm6vldDJzy+9EVFeMMXbSUqZYmH5BSswcNMZhBDvr\n", + "HsaVv8ucMJ+et+l0WuNist8sF5R9MVrm8bP3nYJ1RsPvM9/Up2/ppw+BOP0H2gaH1adSmXuKg4Ke\n", + "MWdkxH6rPetdezYKuYZFRAWr+pjzdDqtOVksFEezqSHi75uv44Xi+0wQv08/yAXnnK8JqoaiSYdx\n", + "rBxnhGe3Wq2iGP0+w8ZsZHhAzAuGwmOgTz4tyPdGo1EMBoMiuIzfuWAElZQcY0FpzGazr4y335lh\n", + "XOaAvjpd6E1hUj7PzFwEGu8xNI8jxf175tPxPvM1SCXQX5cnmEwm5ToXZM0pouPj41K9G9gew0Xl\n", + "3IhqA6NsmQPWmtN/+5SbTzJlhwBlBx/CcsO7rODNyzGJ3ScoI6rLiVG4jJFgBeVsnsiPP/4Yg8Eg\n", + "Dg4O4qeffqrtQ4wavBSud4mo7iEkvdftdsta4Fizp+BM8b31el3qkrmEw2KxKDwQFKpTNexNHGTL\n", + "DYbCqXGXDeH3ebYPKTAnOOLmlcDjIWXGs0hduoQHqU0CHhP/aRj236I74HjhCPG+w8PDmM/n5YJp\n", + "OwStVium02ms1+u4uLionYayc4BMe1+iJ3BqkVn6gx7ACWNPkpY2l4fP0G3sU1Me0AV8p9/vl0Dx\n", + "06dPZf/haHGAgT3tZv1ASQS/x+PHaYUSEVHtNVNJkEWCcfZvpoGQpuMAQ05DZZ1Hc3radtHpKObX\n", + "up13klKz/s7pzkwo93wZZDAvzCnXiCicYM8ffeP/7HM79TzTZHPr74io6T2aaSmtVr1avKkX1PZz\n", + "ag/7jVwxBkAG9IjlEAcs98PtWRwpn8JyLhfuBpvfXIHtdhuz2eyr0194wiyE66kQBZjPY+8UD5p3\n", + "o8Q48mzF4U1DTp8J9zMbjUatcNc+j98kWhqb1E4FY2DD2TGIqAieRol4H0iNDbEVscm1/pu+mIRn\n", + "ATePANQhH1HO/Cs3b+j8MzshfE4EnSPkiChEcdZvPB4XYXd0heLwprGMmFt2dHQUl5eXpf8YGxoG\n", + "FufNXCnehTNhJGy9Xsd4PC6cFK8xRscbnHHC/WMNPW+sqb+Xlfs+hMAcFu5sMz+u1WqV8gzv3r0r\n", + "BQ3n83m8efMmRqPRVzwYnHWcJDun0+m0zMnp6Wmcnp6W+W6323F2dlYrAGlnIvNYTLiF94Wz4b1j\n", + "3eGCuTyDtTPi4sYzzTujzArzZMU6mUyKEV0ulzEYDGpGAQXOOqMjZrNZnJ+f1/a/+2KF7n2BU847\n", + "4Z9FVLWpbm9va/IQsXPczs7OYrlcxmg0in6/X9bJKHuzWV0v47ljbtCN/NyBlZEd3m3UOQd0OIWZ\n", + "f5iDDTiRrOtkMinXax0cVJfvbre7y6HNu2PeTHTGCTMyjqHH4SIQ9ljQHy78zNhAbjwGozmscZY1\n", + "nr1PZxJoZztjMr6dU+wrJ44dmKEPQEF9yIh5wgm5v78vzim614RyNx+gMDqGXKPjzKNFJoyk0bDr\n", + "BKoEhW6np6eFe+q5Qvf7PsKISkcTKOeA3air14gx/P8OkUIAXQzOpxqIThnMdDotkbEJ4jzDxjIj\n", + "KxCNjUDxN9+xoaTRH28svscC5VNUPoaaIU76aCE0ugN0aCFmfETBRi1o9/f3JXLkhEREdRs8pyLy\n", + "0VtHXRZ6GhsOpZg3yXq9rtWgYb7tvPAczztzYEK9YXcrWMZxdHRUijpmcreh2KOjo/jy5UttLdjg\n", + "RIQRUUMvQF981x7RyT7EjY2P7Jocyd+OTP1ODDOy7RQeP8uHG9brdYn4qOPC9wxn4/zbKWUfGRX0\n", + "3KHYSCdH7Gps3d/fx2QyiTdv3hRSckSUC4SROc8p+wQD7wurqUr/9PRULikFOb26uqqltI1yeX5B\n", + "MbMz6HnPSIdTe/tSnqzJPuMVUZH37bw6qs4pMwzcarUqRTE9RqJyggOex7w1Go1YLBa1u8Gc3vIa\n", + "YhScTkOGDw8PYzAYxOXlZQyHw1gsFjVndDAY1Iq+IudGVdin1jXMox1E61MjLXZemENSJH4na4HD\n", + "4aDNcz6fz0s1/YgoqZn1elfaJdM5kIl8QtZrBvpLAy3ySTHS/ybH08+ctnfQk4MX1shzwNo76LRO\n", + "zMG/aRL8n/2Sswa8D0fKFBXmw7YpoiKxozOQS2QKCgpyYEQMPZsDOmRjX4rut5xG5gFHDzn0HiBz\n", + "4EwNDRTKJ8g9pzTsgufWiFruS5ZLt2dxpHL0SGMRnCKIqC6hHAwGZUCuRE3OE0OEMFJp2sgAk+MU\n", + "GY6ZNyDRsbkdfGYUKC8GjhyolRUfAsz3Mupjz9kKmg1jQ0lf/LehdrhGhljzOJhzDHwWfiMlOdok\n", + "YvA62Vm0gucz5p+xu6w/x40zUkZ0gJPVarVqhoZNxdzQz+FwWFIscAqIvPv9fkH5Wq1W9Pv9MhtC\n", + "9csAACAASURBVPfj8ThGo1G5VgauUET9VCVpHRfUw3lpNBo1tIjvUtOIOXdqNxsiO6AogG63WzPQ\n", + "nst9yCLFP70eNIIOInMbttvb2+j3+3F4eBjX19e1S025WcDHxiMqnpkRGXPn6Av9N7IAsgkny4YG\n", + "pbxvfHZA8l4gzb/dbr+6mJi153lGSLzHnPrmd/luhvqREwzqarWqnYRkDY6Pj2vHrk9PT2sGLKJK\n", + "sdh4ZFTCOoM+Iac3NzexWCzi7du3cXJyEp8+fapF9uv1rrQHCIn1IIEhhtfp5Jx6+a3+sSbeNy4C\n", + "6jnNgSF7ww2DuFwuy5w6C5FT3/BgnPFwIJ2RL2SGOUUGMxJPYIIsZS4jc2QZYl54b9bfvpjaOtiB\n", + "KE6PP0OOWDOPlcY6ZIQsol5RPqfh0PsEBP6eHUP/DNTNzhXzho1AXrz2/l3LIv1gDbzvSWmDGNpR\n", + "Zt32lU1ANul7Djz5PnNtR9N7b197tjpSTIaPUOI547wYNvYGv7u7i8+fP0fEblK5EoAjxI5aEGJD\n", + "uHzPnrkFdTKZlPdtNjtODEaYRUBI891ILJ55DxFVJMMCYWwjohwl5nlGjpgbNkM2mnZ2ECDmjD4w\n", + "VnN2UKKsg9NGKDMbNKNWQNsWdsZv/lHuq//vjcia0R8r18ViUYo4np6elhIEEVWFcqITOGoRu036\n", + "6dOnaDabJXWVSbwoNztnIE1E/Mvlspb2g+fCMXWnNa2QQRDpa6vVKmkv0kom2rKGrLOLweFInp6e\n", + "lut3WAvkFjn0++gXCtxpXRAp1pO1ABWK2Bnkk5OTgjrhBJ2entaQWBpV9I+OjqLX6xWEhLFThXy5\n", + "XJaUAc/AMXdai3Ejj4bcQWDNZ8u8O5AxG3vmBLQHJyobLtI11guOaJEPv49CpHCUkJvJZFLumWQ8\n", + "fMY8YhS979ATBCx2Fk5OTspeIxBhDDhxh4eHcXl5Ga9evarxXxyYGDkkELWsECjY6PAuIw04EZSV\n", + "saNtZBuHynOKfDr1x2c8p9frxWg0KgjRaDQqe4mrgByIoivZG8gV/cQhcvCFEXbAuY+a4SrvEdVd\n", + "bOxd6wKPFZ1pZ2a9rooME2Qx3xnFsSFHDvdlU0yQx07ZnmRagtfQNZc2m00tLc5tFYzP+x9b43Qz\n", + "jWdZfnivnalMk4moHHkDHwYWWG90opHinPFgv/B31hf+/Qw6+B372kv5g5f20l7aS3tpL+2lvbS/\n", + "sz0LIhVRoTf2ToGAiUrwJDudTrmvCxgUb3E4HBZ4m9QADSg9R7K8L0cPJtxyegjvnb4AJeLtG+Ll\n", + "ma5ebk8ZZMnpvYiKqGfYme+Z3EckmcfoNF2upA4MTVTrKsJwvZjT3IjIHZU5ktvHsbA372ie+SL9\n", + "5TQkaVqQSJPB4XJMp9Ov0qytVqugUPATQJaIrrgvzpEu/fGamQtA/0CKHBXBZYO/gzwxB/TfRFDG\n", + "0el0ylp6/pxeZT0cQdNAF00AhfuWo0sTYA1le+zA1ZkAyrvOz8+j1WoV9ATCLKmr4+PjghAQTT8+\n", + "Psbl5WVst9vCu3r9+nXc3NzUIkhOCSLrIDzmV4BiGC0yx8Gpa+bM4wB5Y0w+qs+cIY+ZX4L+MeeS\n", + "SDYjiMhup9MpJ7PgNvLZ2dlZ7bQSn0G+59Jic9pIXbLfTD/g+piDg4OyPtxfyOXny+WyoIBG+tB7\n", + "yJPTmv7/er2uFevkfXALM5ePueP53hMglcy/v+f0EjqQNeVz0Fini9FfyKOv5yHVSRrazXxF9ilj\n", + "dDYgp5G9R9nnNL7jK7QYX5brfSn9XC4G+TLdxPNi7hConhGyiPq9kaZ8gEbxPc+p18LjQdfSV1A9\n", + "t30onNN4UEJymtH20FQQ1n+z2dRoHx4zupj3QeNYLBbl1B7rT6ke9DNzQV/Qp/TJ47Fc7mvP4kgh\n", + "XDnHTPO1KxERl5eXNeVmSI4FYELyUUg3Q3MIl6Fl+tBq7a5dIH3jflp49zlg/DyTVHkuStHQ6sPD\n", + "Q0lTkN7zpZQIN6kvK33Dj84V+7QfQmHnBW4RZDwLqlOShtw9DpzgbrdbOy3z+PhYq3HiOcjOgSsj\n", + "t9vtUmHc78KxWa93FapJu7LWlCdwOoy1oPYKc+sN5ZOjHp8rImNg2VxWMN1uNzabTVknDDlyZEct\n", + "ojpJZQVkp4d1xRC7BhPrinzSH3hT6/W6EGX5HStpxumUAo6lT7DRjo+Po9/vx3q9jru7u9p6NRqN\n", + "mM/npW6bHeXhcBjdbjdOT0/j48ePNY7BbDaLt2/fxmKxiKurqzJ2k6uRGada2PPZcDHHrBHGhblB\n", + "6ZNmyukkjD77g8b6oRc875Q8wfnabreldhE/e3x8jMlkUkuLcO8ka7BcLmsne5GFfLyalA8Oix2p\n", + "x8fHwp/EqSAgefPmTdzd3ZV9mnki6DAcGr/35OSkpged4uPAj51zp5StQ3LQgs7L3CrG7r9zehdZ\n", + "9R5HL8FF9clqKrfbuTHXyzowE5U9H6wp823ZcH9tQzglZtvAPOMY2DlCdnmO+5Fl1in9ZrNZLt7m\n", + "3XZQPE95/dk7dnwjqjJD6E1/bz6fF71p3ULLoERucETN5aPlAzbMW54P5BK9g33x7y6Xy7i7u6vt\n", + "txyI4RSi55kXvsPBFq+hSf/72rM4UkRk7pw3dzaKLDboko8i+tilnxNRGSgEMp/ow/HhcwutT1b5\n", + "tJCjyexgRFROIv3KUYSRMCsQrjIBgfE77DQ6V8x3UbDmSHmzmkeSCbdcG2PUjZNsFjK+B4mTwpjm\n", + "QjAfGGcLI3NHP3yShJ/zvHzM36dIjORERHE6KHZpx6Xf78f5+Xnc3t4WdJKx0wecRvME2LTInfP2\n", + "/IHvxPhwXDE2djD8TkfBzK8NFHwOHDQ7EE9PT4V7FVFFyVzr4popILy824VTGZORMPp3enoajUYj\n", + "JpNJQTUonkl/cN6enp4KOsbJvIuLixiNRjGZTMr7XQ6g0WhEt9utnThkDTNX0QGSOS+WH9bIDq9l\n", + "ln5STJN5pKFzMv/EPCbPv3lOllN0GSccvYcPDw9LTSe4Scz34+NjDSX2HvHJPMsf/cZpIyBiXBym\n", + "QP8YxfOpMiPVPJ/Cif1+v7Z3vT9wUO2E2gEBrTLXCZm37PE8DCm6LuvX7XZbC/iYbxwk86/y2kdU\n", + "qJf7b32Y+XGWB+tL/nZGgrVgvDhc5pfaeWTd/Cz+YLDdT5rl00gd+tL2xDXzmPMcvNEXo5XsRes8\n", + "vjeZTL7imjmgx1HKBU+t67D56IzM1fL3CP58ctCymJFsnLP7+/tasWTuDaXPHq/BG+ya0S0aeigj\n", + "cG7P4khl5nxEFe0b2kYxLJfLWhTrNM1sNqvBjo44HH2tVquSBomoCi9CfrUj4X6iII0eRFTk2Kz4\n", + "nTbxGOzx0kwIRpggnXoj5pMtdgaBN7OhMRLTau1OplF9mv6hwKjwahQK+B4HkOPqs9msEDyppmxj\n", + "YkXgzYZhMYnfhsYb3uNHQVjJG+2h72wOKz5QKCI3YOqzs7PyTKBek/Adydh44eTiwKA8IuqVh7vd\n", + "bjnubhnmO6B5bMzBYFAzJC7ah2FmnC5Y6Sj17OysKB/mwcqVOeFv5N3KkHGgoNg7duSRN2q4/O1v\n", + "fyvvf/XqVQyHwwL98z3WdDab1W4BoC/ed74zE0eGk4cumZERaeSK+Vqv18V5NCLLd3wowg44cmxn\n", + "ne+BAmVEgf4Q3FHj6Pz8vMjpbDar1eui4QDjJHst0FutVis6nU7NWWIMpPEGg0FBxwj+fKDAhzB8\n", + "0tSNgHGz2VXuN/kZmSf9yLr5WP1isahlDLLcgP7YUcnZAxfKZO2Y97u7u9rhJHQ6joWJ8RRB3Ww2\n", + "pfAsDUeSPZ77YDI573NAbuSZz2zUnU3hO+i+HODYKfL+xTm0Pst2kfmzvmbeeKbfwXPQi0aimBcj\n", + "kHYyQao43OOTvkaUmWcHqw5OszPCvBFkGHiwDUCGvE7YOFfnZ3+ia72+/r/T1/zNHzt2/1/bszlS\n", + "CJ0XignDAGSjjxK3sCJEKIEcgRkFMofCG4SJZVJt8A2vRlSX4PJsvwshsZKmsUAWanNvaAhb5gyg\n", + "EB2xue+kdeBJ0Afms9vt1hwOUlMooNPT02LkuJYFgzudTktF4Zubm5jNZsWwRdSjJUfQmXvCnLFu\n", + "VkSkTbbbbTkSzvfIkV9dXcVwOKxFszgkjIP32Jgb/aGhuFByKAM7ShiyvK6srRFO5oHSCKQ881F+\n", + "Ih87z61WqzitPi3GOKbTaTktd3JyUjuSTP+JmByJ2nnI6CiyRXMwYJTXaCwRW6/Xi8PDw/jxxx9L\n", + "Py8uLuLLly8xnU5LZGp+Dc8EeYRbhdHjRCRONeOz07her2scFAwpKQkj3OawOeqPqAzlvlOpdp69\n", + "Dp5DHC2nIXFAQZ9saFD0PBuuHGP0dSIeP+gXgUu73S6O4nw+L6dYr6+vYzAYlNSejQHOkCN9dMLx\n", + "8XEtDcX4SaNz/Qw/d7CZeVfsocViEYvFIrrdbi3wRR4dlPKZjet6va6lS32adj6fl8/u7u5isVjU\n", + "ys14j/N//tDYM9ng+3PrWJprGtlJ9Jx6DH5e5tPRsi7M+xE9470ZUe1t1sDoLA0aAXbNto3Peee+\n", + "kjPMH8+ECoHddHCPHWde/D50tJFABx/sTzvEPNOBisfPvgQBNBXFJyfRK+bbunZcDjyxs/Q5gyIZ\n", + "GXN71jpS/DuiXjMmok5IXK12VW1R8laoIEvm2xgVceVjIyYQ0djY+wSZln9uQ5sdAjsvhi1ZNH5m\n", + "Hg1j8sJmiNNEbvfNYz09PY0//OEPERHxzTfflFpAKACuhmDeyHmjJHDCLi4uCnrlO94idh4/5SbY\n", + "QEakiKAzIsV8OJ3qqIXfyfW3OE5NBGrCaUTUkJ19iog1cRQHomK5YA3NQ2EtfedSRP26BDcTGTFQ\n", + "dpascB1EGPrfbDa1NBTcMQyUAwX33xErfWFc/HwfAsr/M6q6Xld1jRwZomB++eWXmE6n8Y//+I8R\n", + "UdUuQhlxPD9ilxYAHXI6lebUjfe2jRafmScGoRvlbh3AOrGmTvs5LcdagWbY8cp7kTlpNBqlRpXn\n", + "nOfe3NzEdrstTsh0Oi10hG63G0dHR8V5coCUG7wUHMyzs7Ov6kH1+/3CCWL/sv+Qt4xms098PQ9j\n", + "JyjJFALzM9lXzElEFQifnJyUK1qcsmSuLYP0x/rAKf8ff/yxHFggoKCOFI6rHSnXrcpVqL0PMyLm\n", + "z2jej/QTR9loFg09jd7Z5xDk9zgr41Sbn5mRVPpMJsHBtZE82x2PFydhvV6XPeqK+Ov1rkbjzc1N\n", + "DS02Gpf1DSgi8+IsRZ53+ue/XbvJBzKs53P6nb2HTWF/8x70DfXreAbBtm0/fSGNaB+EZzr7sK+9\n", + "lD94aS/tpb20l/bSXtpL+zvbs15abC8TDzNHAfxtBAteQ0R1RNepQUeiJmI7kgKqzoRL3mEv39B/\n", + "jvqJ4mhOqWVOQ/aE88kuIitDoxEVXGluS0SUO6aOjo6i2+3GH/7wh3j79m1ERLx9+zZev34dFxcX\n", + "EbHjNs1ms9oN4qAfoAA+Xpr5NY4GOJmCB+/0EWkF0lB8xpyAZEEWzc8nSqYvPkoOkuESB+aYOIom\n", + "0oQUbzRusViU+QfRyjJHis/jZr5BedxPTovmS2f9b6ORLvEA/8L9cfTj9JGRFbiB5ld5HI5M3R+i\n", + "NaJV5Io5Zf5AB/M+fP/+fSyXy3j79m1J0a1Wq5jP53F4eFiuILHsk3o1GhQRBX0zkdVE9Ha7XfaR\n", + "9y/cIFASyOqG4ZEzUCsib9bWvBcaew+emtFM9i0pN0fQpG05en12dlaTN/YGiBbfm81mZZ1ms1lB\n", + "IPke6ZsvX74Urhj9BE0mmrZeZa4sE8gMc4IuMeeLeTd6zzPRdei2xWJR43WRwuGkKY15A7Fwf5A5\n", + "+DXtdrsga91uN3744Yd4//592WsgebPZrKR12FvIIqgRpUqc9gM1ps/eHyBilllkkrW27XF60NQF\n", + "/vAcf25kJu9xpxSdWja/lPVxWo7DJk67MlbQGo+Dz0A5mW+4T6A4vV4vPn78WOvPPp4Rssfesb3E\n", + "rpj7+luZg8xTBpXaR0WIqC5mNhUB1MlpXacS2fvmyTEfLn3A7zOfWZfm9iyOlCczOxrAooZHgTEh\n", + "8ObTOXmy/UzXDDGnATKdDbEn0NCtnbu8MBmyxanj/2x8uFUYMDZ6xNcXpnperCgMtfI7bLZXr14V\n", + "QnlElIrUHAuGw+ATC9PpNCaTSTEOFn4MkY1DRJQUDMIL/yWiSgv5FBpzikLYx0tBHphvX6HhtWm3\n", + "23F3d1fjlrHxTeZmzTBKrAnv5lQHp4tcD8qp2cxpILXs/iMXOECu++UUg1M4mYOB42QOEZ/jSNJP\n", + "jjvTH4/VhiFzwPibvttomODrlCrf8RpmR8GptsViUaqbO53GuwzB40S7wniv16uNgXlErqgLRF98\n", + "uXjm63kP+znMG2tFX/fxL9in2dGiwrv5gA8PD4Wzg9zB58GYEIBQ+Zx+ku4j/YcjtV7vyka8evWq\n", + "lP7wZcd2RglSIqq0rnlpNHN2rDcZOzqSdbV8M9/cvmB9xL7BiO2rsZRTJl4v7zs+f/PmTfzDP/xD\n", + "fPr0KX7++eeaY4Ne4m/vfV94i6OaCdUOALMD6n3itCe6n72fnS70pfUE62GOrNP25jRa1ngWcpaN\n", + "OHKNfeNQkZ/l9JqdZMZ9cHBQ+I4R1Z5Hh5+fn8dkMinyZhsRUbdRtpfWNU9PT6VMB7LH9xhDXgeP\n", + "Mac7mRvey/tyqtY0C+s20zasA9G76Gm/E93hwDi3Z3GkuEjRCorOo8gwDhGVo2HByPlgC5qVG5sP\n", + "z53fQ0idh7YC5/8Wdt6dOUCMA4XokwruC0oWAcpKDG+aSJoxwxHJRticqdvb27i7uytH1REIvG82\n", + "JnMIMoQR4lQMfeX0w2KxiPF4HNfX1xER5eJQO0GOchzx4QTwbzgNKLKMAkEOZK4iKqWL8nGNMRwV\n", + "jPF2u62dCkMpgo4Z1eT3MWw+1ZSNqBUUyFdWpqwN8mbHO/+NA2huD2uBrBoFYtMjd2xoHAHkBXSR\n", + "/iAH9DnzkuxgGJVgzjGKVryQuClyyjrd3t7WDjA4aGFuTERnPZfLZRwfHxeZAS2MqE4TEUBlDiH7\n", + "meKUliVH56BPNPPKspKOiHJpOL/Hszi5BFJnLshyuSxOLtwgDmiAAKFz7BCiP1jbjDqydw8ODsr9\n", + "jqwNe/zgYHekHI7QfD6vRfmZH4bh8ykvr5M5e/4MZIf1MoLQbDZrwaKdbOSKsWYHzOvi1ul04urq\n", + "Kl69ehWfP38uPDzWlz1EaQlzGJnv1WoVr1+/Lg5oNqz7goh9Db2GPgbd8BryPoJGf4YutjEngHIZ\n", + "D88Xjvd2W5WPoOGsWu4zX8/rh2wYgYd/SnPpHPYwzYTx/PsEJoAY3lfojPl8XkMC6WPODNkm8Md6\n", + "xO/2qWjmAd2JPFgX23ly4B4R5UCHA37z3DJCm9uzOFJAslmR2ZGKqBdwRMF6siOqUykIKAY7ImqK\n", + "DoXjUygoLjtQEdWE5z8R1f197rOdOgTVhoxnm6DthtF2VGWvPY+B5k10d3cXv/76a0GkECjSA0S0\n", + "PAsh5FTeeDwuCvf29rY4J5zYc2SCUiEStjJlg/NzNpuLdLrvfI/oiurkHjOONSfTjICB1jAe5pa6\n", + "UtvtNnq9XvR6veK4OAWcU2nZObYDYifWp/toRlptsDxGZMtwtCs+ZyTATjvPsXFjHKCKtIzQOl1s\n", + "xWL0xZ/xb6dFPAand5jvo6OjUmzSyHC32y0nPdfrdUwmk9phERwiyOpGajFOGBTWkEMmoIvcA+YT\n", + "SDZq9Js1zWlBIygEBxgv5n69XhckifG56jvvbTZ3aTp+5nsFswOCPsEJc3QNAmkSLPN2enpanEvI\n", + "8qzTarWK2WxWHGtkzvKMI2CEBCQCPbYvTY0MnJyc1MpR4Dz5cnA31iEj1TaYdrQiKoI5znu73a6l\n", + "kh8eHmqnDhkHc/b4+BgXFxcFlWbd0FM5E0F/9jlWBPaM3zQCUwsIFu3U4AxYv0fU64IR0LD2yKj/\n", + "uGwCiKzXJ6N7/J71EjaIvd9sNuPy8rLIooNYzw1pZWeETGsgzZyzK+gnp81+K6BDhrxODnqzTTBI\n", + "YL2Zi7b6XTwDxyjTL+wLeA35/Lfas6X2iIhyNEREnL3ziMrQ2KAhDBg2BCWiyrFuNpty8ozvkS4k\n", + "WmVj8Uw88OzZs6jeMK4ldH5+XsZhLxbPG0Vh1MFKOI+PPru+UebWsIE/f/5cvvfhw4fo9Xo1Lo5T\n", + "EaTfiL7H43ERlOl0WjbNcrmspREYF+vFc7wWFl7PN0JOn5364XcoxWDOAQaFSB7HAycQZMhoAI7U\n", + "ZrMplbqJynhOLnXAM73OHguKxbJqfhiN73kunKrOCKv5LVaYPNcOljc7xh5ZArXkfcwd77Aj2WzW\n", + "i97ug7+RDxu29XodnU4nnp6e4u7urqwFNbZms1ntOif6zJH42WxWLpyNiJJudo03o0qkBbbbqthl\n", + "xM45cd0uZNsOsHkXeX1sWCiSyfdQ1Ow15sPFOBeLRY0DaQUNkgsKQloSFM9OJmm/09PTcprPaBpc\n", + "Qp7F9/j9VqsVs9msoDK8jz6x1zIagM4kOrdsGbFzs0PtcgARVYV65txyFFGllDCkpk3we/yM/4/H\n", + "4xgOhzEejwtPkjVHz+/jaq5Wq1gul9Hv9+Pbb7+NXq9XmxsbZ88XDogDnoxy2WDn1BJ2IZfIARWx\n", + "/vX7jCx7LeyoYm+YHzvCOSWGg2bUzGthRNU6CocfJ5QK/bnlWlA8i2yL9RA6HwfMto2+OP1Og4u6\n", + "b76ZD/4YbGCsyKKBDuYNnWlk1HzBzWZT6iVGVMj4PvS69Pc3P/k/bEymNzjohr1Q13rCkWAy+QyF\n", + "yQS4mCHCizFwuhBPlujJi4SBtEIz5MjGQeAsrL1erxRH3CeEjNFRgo2yo7WIeg2WvLkRCMZ5f38f\n", + "P/30U+lLTgu9evWqjJd0l9NYNCJ0ogzDyk7d0V8LGvO8b4z8nZUshgXFYRTEBGFD0vTl6ekplstl\n", + "Oca7z7BRbweZcS2nzWZTyMD8vg1QNsI5HWBo3NwQK0Q+I4XH/NPs/Dv9yzgyguE0If1DBjL/wpwq\n", + "r2FO69B8LYn7xJgwRBi2nMZCpiynnz59Kr93fX1djFzEbq/ZIeFqk4hdhW76MZ/Pa1XWIf7jZJPi\n", + "5Tkc03bh3Jz2xOBmNI/5zqjqer07Mk4aLyOOrBXf974g9eGAjM+8DkazQdvRlQ48mX/SKqTzaK1W\n", + "qzhuRrLMi+MdONSgqBhhGz2cWWTOSD7vc9rLzYEl85gDFjv1ds5ms1mRj9lsVvYwP+OP9yEBxOvX\n", + "r6PX69U4kBh97EROw7OP8rpwbN5IjsdHP7J9MocUXZXBA6NA1sME3kavWSeXSOFZdnT9HT/T6Sr0\n", + "gwvfdjqdstaAHTxzMpnUHB4jZNbpdl7QTfxxOhLZ9p+cyeFZDj6wldb1zCllfdB/OKm8L4MmzqZg\n", + "f0A5vU5G7fe1l/IHL+2lvbSX9tJe2kt7aX9nexZECh4PKauI+nUAREQmFhJRkgrAO+Q0gSMiPHVz\n", + "HfZFguZROJIy6gEilGFtPNSMVsBN4DnO+RKRZoSAZs5P9vrzBaaMgWf7RE1ERX5l/PAXvvvuu9JX\n", + "OGOgM/AP8Pg5CeIoGUTCpEXe6agSNIfv5cq7hsmZe9ICvJv3Ad+SAjL5m2gb2aEvpJJAKUDgeCbz\n", + "vF6vy/U3EbuojHcSkTtqcYqk3W7HYDAofWm32yVyBWkx3wUOivk3ERWXjz+MhzV2FOl5A0HwPDvN\n", + "CroFquj8v7lnTjnkfZQROU6DzWaz6Pf7Ze6Wy2V88803ZQ06nU45vLBareLk5CSGw2FBDowac8ko\n", + "qS1QUw6lgEY4KmUeOEGH7JgjR9TtPW6Z4gLsfegwiMt8Pv8KjSZq9VrQWEuXMXAKgetjzC/h2fCS\n", + "HM1nsiyNiu6gwp1Op/AYjWRAZjafJyIKSo/cek2MOBuRMPJJoV5H7ehN5HFf+s78JMZtVHSxWJSD\n", + "LT/++GPc3NyU+SRrQV9ZcxAIp8EuLy/j1atXhVuVdQbr+FsUkswZBJ0BlfIBBqOdNMbkTAPvxj6h\n", + "z9AlOWUGwpznk3XEZoKe5DQga+uMilFs0Ni8xhEV9QN96u9jO7K+dzqT+QC55XtGeninm+0e46a/\n", + "RobJotAPI1KgrKSC6QtpevaH9Rr6Mp8gZ+ym4uxrz+JIuQ5Q6YhOugGl0XELXq/Xi06nU5TUwcHu\n", + "1nmcLhsMjGur1YrJZFKu2fD7fA0Dgsh34AH4NJRz0iZsMx6qOJMW8+kNp2S8kCbPmSzHZwhuhhaZ\n", + "KwQtp30Wi0XtuorxeFyc2IuLizLfOBZWUu43HBTGb8VmZzFzg5zeYf2c1vX7nBO3s8hzXQfFBFcT\n", + "IDl9yLtcSTqiqnzd7XbLFRhOtUbUT6Iwl3bqbFRNqiUVyrgg1zudhlzCAcMJ4fd8EsUwOfNhBUEf\n", + "zPewMnNqIh9ggPjtk4xuOCSso8fQaDSKg+6ThxcXF7Fe747rX15elis8InYpuvV6d/VHfmbEzglD\n", + "8Tvd//j4WNtjNsBHR0cxHA7LaVyUK86ygxKUJ59tt9uSJsIZcaAFiZnx2rGBU2jj6DWMqBxu3ucT\n", + "UyhxE4XZKwR8JrV6b5h7Yl7hPgcIvg7cOT5rt9vleXyGw+u6e8ynU3AYLIy/Tx9SJds63XNjMnUO\n", + "SPiMNNft7W1ERAyHw/jy5Uvc3NyUfjCn7Pmjo6Na6i5it7+4VDyiCjhYi/l8Xpxrp0tJW7EGDlCc\n", + "XkIPZHqCA+4cQNPsrFh3M347vDzP9AzWnL3CuzL/Kn83Uywi6ulk+or8kDbn9+ERIgfIkcdIn1ar\n", + "VbEzzLlTxt4n9I858DOzXaEhR6QJj46Oio63Q+p38n8feMjyjZwyd56ffUGT27MV5KRjTKr5P0ag\n", + "InYL2+l0Sr7bXKfLy8tyuoPfN2vfJ198XJJNDwKQvdNc98mKD6HNRhjF741KM/pGiQN7cuaZAgAA\n", + "IABJREFU+0Zw9kVJzjPn5/K3NzInVY6Pj2MymZRo1YRrol0QJ96FAOLxm9th7sS+/ngtnU9H4aMQ\n", + "LJR2HHL0YWQwol4HhfcTkRodQ2HacLCGg8GgnEZEDs0twunx/XcR1Y3z3mjmchHxgK40m80y38yd\n", + "x+IoHfn0VSl8xkbGONuRYo585RGySO01F+20XIFYeZ38b6M/rCHPxvFzNHt9fR3v3r2Lx8fHuL29\n", + "LcVgW61WQUDY10bH7u7uiqNkZ4kSHEblGN9oNIqnp921RhDfOegREQVtshHhu1wwjYEFYaGvrAEH\n", + "IzK6AKfOhHcrYpBzrzt7DfK8uUrIE9w7O0kYKYI9notT52icv3GGMhpPX+gPjm5GG/hjRMrIBnw/\n", + "rslBVlqtVgkiHXCiC3imZcpZAAj8vvOz0WjEdDqNu7u7mkOCTNsYw7vjeivGsVqtiv4bjUbFwfYf\n", + "+uRg0HPD5+bLZITCqG7mq+F4O1DgWXZK7Chnuc3vyjwkyw0OBXvA/DT+oL/4HgVzWU/khDmNqLiJ\n", + "+4qJmvzOGLmmbLFY1AKiiCoww75YLzCH7Ll9iHJExYXMTibv8il7I1roGfsf9IF3+5nes/vas57a\n", + "c2TiiMUQfkRFGPalnBZwECMMGMIAYuLFyKkFnuf3sThGmvievXwrWP5er9dF0WZ0jN/B83ZxTIwN\n", + "EauFhu9ltAIHaF/EgYM0GAyKU+XSEHd3d+VyYMPWfldEfKUAbSTw8C2Mnh+iTfrKJsMpcIrT76Zk\n", + "A435oB/8LlGjjYn7iUywvswbztfp6Wl5Hv10VVzkyugQlznTB9aQlKChfJNPeY+jX69tji5pJmIy\n", + "D5yuQdmRxvUYGQsKgNRvfq5TmJZvO+VGDj0OR3+j0SgGg0EcHx/Hzc1NzUA9PDzU0micqEGGbm9v\n", + "o91ux9XVVQ3lIaXHOhwdHdUKnOIocmLNaTCQYaOG/i6OIM4xDSSTvkXU7wPNhOF82ADlbQXOAQoc\n", + "YgJC5pTvshd5dqfTKbKBYbChcRBH2pi1NaqELuAzBx9eZ+ZovV6X6tbIBQEuCADpdx9rd0rMe4Q1\n", + "xcBaRjFcm80mPn78GB8/fqyhIOx75sDGjGet1+vodrvFPmADWK/5fF4cKcopoDN8uTT6hSAb+WDt\n", + "s/PiMaAnmYeMzGU7wJxiA52moy/ekwYd6BcoEXonIz127GxPCKLYB3bY2C/0w4R21w9DtzLfRhit\n", + "h5BBkN+cRuf9GXVjL6NLeRbvcDbFjib7hXkxoMHPQdWto+zcGeVHzvZlhNyetSBnxG974M1ms3bM\n", + "nQ2XYT7gaRaVCDyiqprcbDYLKmWDzXuJtuwQdDqdGl/Eih+h9QZ0P1Fe3hg+RbRYLGppODsVhhv5\n", + "LKLaDPboOZHE9xCSiKpOBv188+ZNOaXEGszn84K6tNvV1QwHBwelrhSCbmTICs0Kk4gUAbXwZcVj\n", + "ZYPQ2oB6LegDa4/xyjLhuVsul19d6WIl2G63yyWwpM0Yw2ZTpVet+PicyMUKkrlmI8/n8xgOhzVj\n", + "DLJgY4hMoTBAshg/6Rbk2gqaueNZv2XIcKic3jGaiNPPOOgnishjZD+gcBhfp9MptY2QVd53c3NT\n", + "ngNSxjPH43GsVqt49epVbY6RUQwgR9iNHOH8b7fbePXqVRwcHJR0Kf1yqQmvP0EVDpX5JaxFs9ks\n", + "6HLELq0E5+L09LRWK4o5Zy/ZOQaFAgFEL7EW/swpG+YQx4a54Hs4GMiU0xvZWPoUlNfRkT7yh6xY\n", + "nzCudrtdUnsOWtl77B+nshkLv2ddT2s0GjEej+N//ud/alyv4XBYgg4bffYf6TmuguJd6Ajq5+Ec\n", + "45h5r7oiPDo2IxDoc+su17Nj7tA1diKRUebF68ReyWkjO5vZgDvt7sDSmRh/17bKTibyz/epEcj+\n", + "9HNwgAAYXE/KJ40dWNAX7MA+gMIOIHuDZrvgvhCws17WQ+wVZ7XyiXyekZE1z31GInOQmtuzpfZA\n", + "V+x1I8Sk2kyMJL0HidQGGqV/dHQUJycnNSKnc8URX9dsMgRKY6FwpvZVGiY9kBf58fGxcDYspDzT\n", + "KZYcmTkKsKKxIsybG+VFxIZgoExxJNjs5onglCBUvB+j9eXLl6JsvGmazWZBFWz0czRmw29HcTab\n", + "FePCmHxlT85He/1cBRujZ2XC3/BxVquqSByfHRwcFFTn5OSk5iw4PWPlx/f53AY3okpDrdc7ntB4\n", + "PK5ddWP0Edkz0Zh1hLPB99jscNI838wVCF+73S6KjHQfht/H3B00MAZHiY707IBlHgHoC880tG/+\n", + "Fc+hRIERzul0Gufn59FqtWI+n9f4eNQwOzzc3QmWUWoU5uXlZUEyaexpAq3tdlvmO9d/MlLdaDQK\n", + "0mKibESUK0dwQFwviL3Ivttut7XinZ1OJ2azWTG2fMbeZOzHx8fl0Md8Pi+6pN1ux8XFRY0OYAR4\n", + "X4rKQYYdKe99O7zdbrdwi9CjdrIODg7KtSy80/okI2o0B0n79jd9PT8/j81mEz/88ENERFkDHA1n\n", + "Djy/V1dXtVQqKPVsNovJZFI7MICxNippZ5B5zKi5ETfmz0FMDqzcsjNqZ5AACf2HnsXBdSCZOTv0\n", + "OZdMQQcb9bYNw+7hMBnpQS/jlDrAZD/wXdpsNis8O+xNTouZU+h9jKPDM22nT09PS61Hk8at90hj\n", + "0+xcOpNB35AlAg/bWfY032cMDhB+q72UP3hpL+2lvbSX9tJe2kv7O9uzIFJ4fYY5ncckteDoa7lc\n", + "xsePH+N3v/td4SFF1AskEj3zTLxhIganAEnvEB35Ql/4FkRX9Ie+m+Nl5MynWohmTIzm/4bhI+op\n", + "wdVqVSumlnPgPqFANAliMZ/Py7xA+uQZRH1454Y0STkalQAuJ32R89P8ntN+pD2JZI0G4dEzp0Sw\n", + "EfW0QYb+Gbu5YE5tIkv39/c1/oWfDZJjFILn7LsihnUAgTKXy2k4TnDxPdaXIndOERoFog/MI/07\n", + "ODgo62ekw1GnUz+kYUCDvL6UKCAd5aPjcAUcsTqSZm9mNJF3wDHw+Ej5cBKOasZ8HxknCvbVMp1O\n", + "J25ubgqnyVd9kCbNp+Q8P5BZ1+t1QUjMU2TPMR7k5uzsrJYG8vg5AZq5TkTDeZ1Mokb2+d5gMCjr\n", + "a54X3wPJIso2Wsh63d/fR7/fL3uf/XpyclLG57W0jBuRcoqMvWuS+uHhYSkbYmTJZT32Veo+ODgo\n", + "l0475U4DzUF+8v1/8/k8Wq1WvHv3Lv76179GRMRf/vKXMldGQJBFOLFOqyOLyE3mwvD7ZD7W66r8\n", + "CYdzzImkWX9xwnkftYODIs5EGJHKtAh+x2lFv9Of79PZzLXRHNaI5zklStkM0LDMn2JtSFVmCgxp\n", + "aCO8EVFOiIO6+io20HdTdLyGTm2a9oCu4BAOaX2nZVkrj93FYp2iZbzOhNh2weFifLaHeW1ye7bU\n", + "Hik54Nl9REQb7O12d+/br7/++pXy8xUPNg4IHgbAKSIUD5PLwkVUqSSMFD/j7+zE0Xy6ACeC76EM\n", + "UZqZm4DSwdmzEnLe3kqRNBdCDs8gYkcmRzHgVGUuFpsJ5Y+goqAMWTOOXCU455+Bh7mbyRuD57Va\n", + "rej1erWNQVqS8bBOTi/kzeO0RualoEibzV1tL6fSSGUwt05HopQx3CaqIh/MiU+Bkj5CcXv96Ctz\n", + "h7IyRw5lgpNi54W5gOjs+SYNmZ1znL7pdFqD11lDxm5Z5x18hlNppx4Zx4jb2WIdUNQmd/NeHCx+\n", + "9ubNm0KWJ8XnvQ38ztqavI9D6Jo53kco88yjIDXL/uWEntcWJ86pD9/7x/zntUDmHx4eSvqYtI2v\n", + "ZWJNcXKdmnFwieyuVtX1OxFRHCjz++zwO3hysMNn5qv4vayRT3wxZ5YB7xnkm1Srj+7z3cxz9BH1\n", + "L1++xPX1dTm9eX5+HhG7E1+sz2QyKfIYEV+l9eywsP7I2eHhYSFR41ijD1wtnc+tA/I1Sk7xmU5g\n", + "59QBNLLDuNnfrCFEbZP2mWfsGjrOOop3npycFF1rh81XOzHmiPpVPXkd0dHor/v7+6/2EH30wYej\n", + "o6M4Ozsr9eDMceX3Scs6aMXxJI0KVYZ+5sDJV9hkPeDmOUMnWQ5x6H0LiteH30Un4hhbTnJ7FkeK\n", + "/LvvEuLOK5P17IRERHGmvKFQ6iwWiE7E/gt/zYWBmGYCZkR1CtAnmuyouViZERqe6xolfObTNe6D\n", + "x0Cfs3PG99hAvvA1olp0bxgULwgJCBNzavRsNBoVZU8fbDC8Kc2DwmgYQeDdOGlshG63W5xnjKIj\n", + "XjZqPo7P/DpHzffsYBgl4Xsce2Z9fS0GRGUXFuVZ8OPYvBQInE6nxXnAYNj5NCKFY44iOjk5KQqa\n", + "KMyGLyKKExJRlalA1n1C08TKrHhsFJkDHKqM5vD7R0dHNZlDEeVIjDXDaTNP5OnpqTZG9hbvYY1w\n", + "cJkX+sZccRiDhpJlfRj7fD6Ps7OzYtTyiS7ewZ7YbKoSJr6yw46X55H18T133PdoZI/G+JCzw8PD\n", + "WgFYz5NPipn/0m63Y7lc1vQD1zUR0TM3Rt7Mn2PO7FQ4Kke3Mp8Y84j6lVOg6uarwfkDseZd/M1Y\n", + "WHcHbehR8wojojg50+k0/vznPxf0IWIXuPT7/RgOh2VvWxbfvHkT/X6/hi6zlvP5vNiTfGKVPqGn\n", + "zE3FHvCujNagoxzQ8Szz0RxgmnNjXqFrwjkI9Lp5Tfy9x8fHghzybJ+cs23KNsrBF9kefk5RWOvi\n", + "iKqgMDaIE7MRVSYCGwu3EZnieaBk5pbRjJ4xBmqcAUBkJMu8RjugRvzQD36HMw40Aj+cqX08vyxD\n", + "tbX6zU/+D9tgMIinp6cC2UdUG9E1nfZ5/Cb70fgMJZWNMIuybzHwkBGuiChRPBOfC74RJWcSGu/y\n", + "ouSIzgrUhhSY1saKMZjg7MjAkRb9otK2U4pcagp5LyLKEeyHh4eYTqc1UjFwP0egQZkidoam0+nE\n", + "4eFhSVOwaVzPC8PoU4Kkl3AADDc7mjXUi3PCGtqpIxXBnBjJsuIl8rFjiDE7OjqKbrdbDBOGm8j8\n", + "9PQ03r59GxG7i6A/fvwY0+m0GFynEp26cLoyokKzDLX71I/RKUefRNXIi+UwHyW2I2Vj5tQn7wCZ\n", + "QMaNMtIn0q92sDEoHLawEeZ7rFFWRkSBEZUjAEG52+1+lfLFqOFEWg5pmVhqMjLvY208V5BUiWjt\n", + "UPF/jGx2vCy7GR0FcTWSgfE4PT0t83Z5eVm+z95zmg9ZZJ2NqCIXXHjcau1qX/n+RAwvz3IaGUOf\n", + "5cnpG1LD3k927iOqUiGsO303OuPPLCfMN87J0dFRPDw8xIcPHwoCTDDm0i085+rqKi4uLgrq4EAY\n", + "fcfzbStYx31IBuvtAxg52GF+fa+na6Txe9bftO22XqqFuTZy58AZvQBC5LX03X9ZNph/9lpGB0Eo\n", + "6Rvrip05ODgodRstH3bkcrYFHbJYLOLk5KScAMdeYEc8DkAH9oRJ9F5/DgyAQiKLOH527AFP0AXY\n", + "eM8N+9GOm9OOzhCwFpaFfe3ZECk8SqfJUCZGnPjMnAh+FlEvkmZBjqgfjweWd6TAd4wiRVTHOfnD\n", + "aSO/1wowIwTeHHzm3Kx5LhH1iMX5/Ih6Ne2np6dSE4pmRbPZbAr0z+Lf3d0VxTidTmunQhyxcxop\n", + "IkpF8PPz8+h0OtHtdsupjHZ7VyZhMBjEwcFB3N7elv644vV8Po9Op1PWdz6fx/n5+VenLGi8H4Qo\n", + "p1RRfrkuiIv/2ZFgXTKfLSIKqoDSd8oXtKrb7ZYNykW5r1+/jm+//TZ++OGH+Omnn2qOMgoB5QhU\n", + "bcfEacucFvIm9rhZWzhARnEjvr740w4hcgDfh+85TZxlzkoj86BwdLiWxcqbz1DKRrlIkbCP+/1+\n", + "kZmnp6fodrsxGAyKMbXDg6PbbrdraZiLi4vYbDYlGON5KFu4Vqy1nR8cVT7DeWbe7HSDgrNOpB55\n", + "hmUZeTDyGxEF1To+Po7RaBTdbrcYmi9fvhTejiuFe16pbeV1Ql8S9IBO0A9+x+P1M5E50yIcyeNw\n", + "8SxQepDNRqNRDCTzZLTBXBh0jNEr1mk8Hsd0Oi2lQqbTaaEnYNhJi67X66Lfrq6uyryxt5GN0WhU\n", + "6uRhMJ3aJHXO3rdtITjBbiDDGFZslDlLPN+oDA0nHtk3hSSvVXbQWbd8GtIBFPbPzqplmsLLDqyw\n", + "P9hEZzEYG+vFvFGyCCcJPcH6bja7WwXOzs6KXeEz9Ln3GfOGDMKvIigHEGk2m4Ub6MCCtSM16ufy\n", + "bJ5vm8+c2yeIqCqiQ4Oxw8sa5L3p9iyOlBWz0zM4Ihg+p/Qi6l5+9rAj6gXaIqLGVzEUyLPYOEDW\n", + "5oegLDFMjjxBxPyHts+o80xvTBtvzwnHPf08+spYzWchEjUxMGJnSF6/fl1+h42BoC6Xy1J1FofD\n", + "qS+M/Wq1uyft+++/L+/E0YjYOcWOhDEkpAIMm/NdhNbKHUXovDzzwsZHRowCOS3CumUZIRLMUDyf\n", + "+2gt88RVRL1erxi9VqsVg8Egvvvuu/jTn/4U//mf/xnD4bCsL0bW8DTrStSKI2VEEtTJt5bbgLHu\n", + "KAejjTiEzIH5T0boLBvmXvBzFBGRPc+m0Cj9BOEBceT5RpNBHu3wub6YDUGn0ynOOd/xFVI4y6vV\n", + "KhaLRRkf/BajypPJpOwd7u1j/3ivYWAc/duxg6SMM4GBtrJGvrLj4CryyBRR+XQ6jc1mE+fn5zU0\n", + "g8Kbs9msoL3MKVE58m/n1U4VBomfo18w7Nad6CbW2PrV6Y8czDp1OZvN4vT0tFbAMafrbaQyOokj\n", + "9de//jVubm7i5uYmvnz5EqPRqHbHqp2gi4uL4khh6OCKUeogoqp677XyGK1PPI/MicuheI6dqiZg\n", + "jqicTPa7qRrIBuiJUTxSdqyJMy12kIx2Mh70DX/b3uRg3ugRQQLvpaRBRNTmbD6fF3pKRJRUHraN\n", + "qvo8v9lsxmAwKOUznCpnXo0wM6fISa/Xi6enpxKwj8fjGI/H5Wo3gxlXV1clqwV5nn6iW0Cb7ACZ\n", + "e+xMB82p1Jze+9+cqIiX8gcv7aW9tJf20l7aS3tpf3d7FkSK9J0JmeTA8c5NArTnmKNLokJH8TRg\n", + "PaNbjsyI7vHQDXHzBxItzeRW0kw5dwp8nI8QO5WYYU6e7Zw4P8PzNnxLP5fLZZycnESv16shK0RA\n", + "g8GgHAflZFnELjIZj8clmjHScX9/X+654udEwhwZBynhpA9z6xTtdDqtpW45jt/r9Uqaj3nh+Zy0\n", + "c7TCWuS1N3cORCYjYEbzvE5E0ETRPBeiJLwdrpKJiFIcsd/vl2j8v//7vyNix58immV9OZEVESXd\n", + "Q9RDusMyBVpocmxOJxithCdAhEqqw+MzGZ1m+crROXsPJMipa6LXfr9fSyVFVAVJfQqJMZCaY67N\n", + "2QBhcArHiCtzBtrE73uujci47IW5aKR5eC4IIRGs0UHGn1PJlq+cnvfedVorouJUNhqNODs7K6kM\n", + "5DQiSuTtS7aREVLGRqMiKg6JTy7yPpel8PicyrJei6hO6zIvvjnBd+ixVk6BHh0dlfQWaAoNdGBf\n", + "qnG5XMYvv/wSNzc3MR6PayejWAf2InLE+9DPy+UyptNp3NzcRESUA0kej/Ui68ffToM7HeR+ooc8\n", + "NsuCT95ZT8GnMvLrkiiZo+jsijl/tm3m8NAnZ2accqMotVE+xpdTwNjZ+/v7ImvoPqPi2CKfggUh\n", + "uru7q6FORgKZX5p1HPab752fn8doNIrb29u4vb2tpei2223JhDAe0wGcsTCdJcuBqRnOLpGVYH5A\n", + "0X0gJ7dncaQMX9q4sehZUIEUUXImgtnostA53cBGtlGwYPq294jKkQKKNMTpMaBkrbzNE7Bid5/J\n", + "PTtdyN84BZ4Xb0znyk9PT2O9XpfqzxjciArGxKHKRFE7hAiQlcuXL1/i1atXtes8IqLwWRBscwVI\n", + "tZ2cnBRY1afafK0A9YNYdxOUzZNptapq3/w7H6unL05t9Xq9kkqh9pYNtMefa9Q8Pj7Ghw8fipJi\n", + "cwMh4/Sfn5/HH//4xzJnP//8czHA9M1ke1KakJF9Qo/vLBaLWK1WNeeN9edIvlMSXjPzXZgXnIFM\n", + "nrSxxfGPqO6OI3VLfRi+d3V1VQ5nWGbg6TC/BwcHZQw+4YWh9TVOELwhKzsdyd43p493MC/T6TS6\n", + "3W7hbiFfOFOcfDMH0EECZG3Gj9NOanofcZh58/gxNjg4yDckXMZ/c3PzVdrMxHGnIni2dQfvpuU0\n", + "hJ0Dp4b4zKevTLrm/zjlJlR7jUipuT/oGTsFTjUhY+bLsP7w37jSibWg7+fn57XDCBFVSQl4NfP5\n", + "vAQivnEiOxnI0j5iOGuIo5ADV5PQ85wyfqetmQOCOQIJ82ztrDm4MoeL5+f+8gxsm/mVPjDhsbLe\n", + "Xnf+9tyzf7PdIUC0TUQv4dS7Vhpj9z5yStDcJI9ru91Gr9crJzdxrCKinMhsNpvl5C6O4mKxKAEs\n", + "NoUDWOgA9JffBzjAHwfX2JBcb87t2RApIi07NgxwH3HRvBOUcUTl9CCEv3UaA+OVo90cqfAZKA7H\n", + "5BGMXq9Xi/JyVIp3jBfrz/OxUnvYmd+VlTdzY0/ZxMDJZFK7RgOHk/eiyFyqwIiaBX29Xsd4PI5P\n", + "nz6VInteJyKd4XBYnFA+I6ImmspFGVFuNiSNxq4WDgqMUxyM24RFbzhQCis8RxEoAtbdPAHeAVJH\n", + "Y21Ho1F5rj/v9/tlXMhQxA6pe3h4iOFwWE4uOorCECHXJp0iWyjxZrNZfoZzimPsvWBFzJz6KDN/\n", + "81k+vWIjQWOfwIcyIjsYDGqkbDtnzCVzYkeRnyP3j4+PBVmyobGjxztwrEHIMm+Sz7iXLyt371Hm\n", + "lNIIrIk5HeYNsXZGJRy5Zh4MsoS88TmBgU/yOlCYTqe1k8Pwh3CiGWNGpPJdmzwTh5r5Mr+H3+Xd\n", + "x8fHNZTT+xK0h59D0sYJ84lhAhk7GEY52eM4P+adcfqY+TWKPRgMCprrZ7NX0NVwelgL+owM2JEw\n", + "Nw7Zo4GoIgdGI1lHZDyjSOwH633PtYM5non+Bi3JzyIzs4+jg244OzurodXsNetgB9jMPX8bPYXD\n", + "yqEmH5Biv+D8eE5Bxwjmrb9AW3HQ2fsg271erwYmMG/sFUrRoC/JIFm3ucYfVwKhvwjwWN+M+vFe\n", + "uF6MzXNuXb6vPYsjhaA5ZcciUYsmoo44+Hi5UShHQHzPzsvBwa7iro9UR1RwIv82pOyjtrlmEwoa\n", + "RYkDwHvZtPzbDtH9/X0h7x4dHRWFmcmduQaJj8lamZg0mNEhb2afhLNTsNlsahdX+oRZRMTPP/8c\n", + "h4eH8bvf/a4QOc/OzmKxWJRNul6va0eNqevCOjraYa0cDUdE2Ujr9boUdWPecCqog+Xostvtxng8\n", + "LmlG+mC5oFKzDRupM5OYMVKGrUejUfk8YpcyePfuXTl16jlrt9txfn5eNud4PK45B5vNphRbpZ9O\n", + "b1HzKh8tRqFzIMCKwAaCuWK+UfoYbTvpGE8Uh1E3DAunffr9fq0vjup86pZnsDfsuCJ7jMPGiwAK\n", + "4w9hH7ll7/Ne3ud0wOHhYQ3Cj9idAmWd7UBH7BBAB17IAb/D2tLPjEowDqcw0GcuIEozCsEYjGI3\n", + "Go0SgNhxPzk5KU4suggdh7OGgjdiAZkeo8d88Rnr2263a0VVI6qsAOiokWwcL6ejnBnImQajpfTj\n", + "4eEhrq+v48OHDxGxu9B6u92WuwhJ4zFG3/lnfYIzZtQw2wEMO3/TN+8fp7iQJ88Hn7laNpkNIxY8\n", + "L1M97HDxu5nEDJJnpNbUEz+LuXbakv3mQxrsa+qEeR1Jw6JnrBetz/LJNf4mEEQ2jfjzPAchLhzt\n", + "vUFAy7Ndm8oEe4IyZw6MdkbUbT52EefeqXJsBX2xrCAbIJ9e1wya5PYsjhTXN1i5w6lwusLKDUcL\n", + "A+S6ETgsmYXvWin27mn8m1M7OdpFkFHk7hMbzt68I4yIqI2PvrLRDg4OSkRHCmq73Zajzl5Ep1Ai\n", + "6mgDEfBms4nxeFw7Een0m3PqfM4fjAf95mTJ09NTfPr0qbbByIHj4JjvwfyyoTi6zjiMlqCw3U5O\n", + "TuLi4qLmnD09VSf92ARG8nAOObWFXBi+Pjg4iMFgUFN8zM8+B9Och+FwWIz3x48f429/+1tcXV2V\n", + "vlhm2u12dLvdchLUChwFtNlsas53RJRSCzhChtSdTsBo2CjyO0a8aHbOLft2uLMRQsmcnJwUR8bO\n", + "MO+9v78vR8xZu/F4XL7PdS80X9KbT3AZ3bLRZb5Q0vP5vMgQSDFjmM/ntdQEjj9Ij1M/8PDy3EVU\n", + "aVY7oMw3eySnaDwOR7s23kTQcBORfRxQAh87505pwm9kj+IAohvNAWPeQJBwcJFD5pqUGuPgmDnO\n", + "XaPRqBkvn9g0AoBsZP2ZeTKbzSYmk0nc3NzE+/fvI2LHLZxOp+WkpGvj5bSQUQF+H7qAg1bQGfYf\n", + "e5z5zs5OPkXOnDnNCvqDg2FEBj4pfbUNYxzIVj45bgfI82l9QeDptCZOFH0hOOdzbA160KnrvE6W\n", + "WWeEvFcZE/bNgRJOFb/vsfMs+mL7i5whk0axj4+PaydCTZPhO7ZtjAmbTf/tyLKmzFd2vplj5sB2\n", + "Ntuq3J7trr2IekSNgC8Wi5qXzO8xmdmjt4OTc8mZN+L3odgwxuYD8LtEnxGVgIPgIDSOYJw7t7Ph\n", + "vlowvbldNfjk5KQYHsO9/G52qoBNMeARUbvviOjJhFRHMhjr/BlHi3/55ZfyPjYKzzMSgBA7heTr\n", + "Lugj68mmGo/HpTZJp9MpRUJZJ37O77iiLZEsRofvMcfMj4nf1DhiDb3ZqLdENLfdbosBvrm5ievr\n", + "6zg6Oiq1tLzx2ZxET8iy5xTFYmeKqJT0IGhZRBUJU+IiEx7t9Du9Y8csNyJxp1wcpbMXMWyuobZe\n", + "r0tpCx80GI1G8fj4WI7vcww6Iso1O8fHx3F5eVnQtX3zZmdhu62KWObrGUBnSCuY94PJAAAgAElE\n", + "QVSwnuZ44GA1m82vCvrRb2TJTqmd8OyYImc4Wk5fgSqxd3jm4eFh3N3dlSr7nU6nli5cr9c1nei+\n", + "GBGwzuC59NXBHo3negyZk+Pv8Bz012AwKEGESfggFXYm0InIh9EMdMt8Po/RaBTX19dFp/z8889l\n", + "XeCn7HNCqHhuJwD9wdwYeWCeKbZrpGNfHaKISlc5Tcn6Ukep3+/XSr4gO1nvOzuC3aLmGbIPqtnp\n", + "dIoDa12a9y79w+mgYDDvdWrc+hzbyb+dDcIp4TOoECA5Rn6c9nbQwPtAY/cFagZO6FdOXZLGQxYY\n", + "Hylz0zdAnAiGnSqnL6BgyEmmBjgrgL50cGZd6nna117KH7y0l/bSXtpLe2kv7aX9ne1ZECkiOnt9\n", + "IA1E5M5dR1Qn8CIqz5xngdo4qqZlbxwPNJO6IyqIk1QZUYUJzuSusyfL951+dPRHdEmaarvd1nLM\n", + "nKwDIs6pBiJhv9upJZNJI6I2f0QB5k0ZkQIVMCJnyPXx8TE+fvxYPnN/XOiUuTafIeffibR8pQVo\n", + "A+lVUkMRUS5/7ff7cXZ2Fp1Op5zeoHgn7z08PCzRLRyC4+PjGrE4IgqR0vA5c5qRyXa7XQpykl4a\n", + "DoclzcRnRqcajV1BTxNAiYDgpZkL6OrHHDGnEaGDHJGqolGdF/k3QmDo3PuA3yUyN/JKOmO73ZaU\n", + "I+tLZM/cRkRBAJfLZUENT09P4/GxupDcldDhZ3iOQZ2I7B01kk5gHzEGkGHkb1/qYD6fl+dxMCKi\n", + "OilIP4xuEO16n2d9wt/ef4PBoBCjiXzNzeI+y8vLy3KCL6KOGu1LheX9nnmgPt5vHovTki6M+/T0\n", + "FN9++21Zn1evXtWQGF8XQnqQ7202mxqnynJozo0RTr57f38f4/E4bm5uauly+mi03il4dBYIqfUX\n", + "qInTmMgwXKter1e7TxCOGDqKdHxElbr23COnoNfw1rwPzVXi3x4DXC4u5zYRnfkCrTYCxhyB8PgC\n", + "Yb6HHjP3yOhK5hIh8yBjtl+M0ffqGZXhO5nWwrtZR8+Nsz408wOZB2TYfDX/rnmc6C37AT4FbOI4\n", + "v88YeB9/3E/rJGea3M/fas/iSJFnt5JCmbFghvJQdk5BeXAokXwKyXlOfteTYSfKBF/exxHqLDQ0\n", + "E8D9PvrkmiEoChwKw+pWCjyLaxLgFiFkwM55TOv1unYCh7niGRkmxmjjKLnuj51baifRbm9vi1IF\n", + "5vcpGxSH6y/Rz4gojs9qtSopM04GQgLmvRE7p2cwGES/34/Ly8saN8ZH8/meDS4OAQqSucGJg2Rs\n", + "XgpkZxxCG0QcC5z66+vrr4jIPKfT6USr1SrOhDkO2XCSQrChpK9Uusc4+AAEyqXf79fSB6w5f5t/\n", + "SF8YXyZdcu2HFbTLP0TsHBR+jqGlZlm32y1zk3lXcEmQG75HatPGjX7ijMORywEGBs9lTlgL0rNw\n", + "aVgr+G/MleXTwYeNE59l5ZvvroTgbsVMgESq3Pucgw7oGe9tZA0Z9jrZ6Nop83dx2nEc+Z3RaFT6\n", + "6TQnv8dcIXeWUeQok6gz/cBtu92VU7m+vi4pMo6kOz2ZHUf6i/PB6S3LFO8y+ZuggxS703AEyDgL\n", + "rorN/HvvmANmI22Hn5+ht+ycIMP39/elrh7OKsE0e82cpOVyWTtV6nRZPiCQObQ4LgRMtl84Uug4\n", + "02hciiBzGVn/fbYWGUWGLafIinl6lmGn/MxJcyqRMZijad6hHTUfdMmfmSKUU/c5Jcm8IoNOA+5r\n", + "z4ZIkce0cmdBF4tFiWojqlN0VhgmAdrDjKgjUlmg7LVHVJGtT/9F7ISVSMWePXwM+uuoFGGirxZg\n", + "nCeIeZC8eT4C4FNZjBXBN5LAZwgu9TMcsToK9ZHoiMoJzBFJRB2ZazabBWXguXDZIPtlwvV6vS53\n", + "p3kc/L3dbmvcGxRoRBQukB2pXq9XDJUdglzozsfBKRgJyulrOYhy920OSLy0HIW02+1ymedisSik\n", + "ZiNvdrB5FkYeZWO+mhUR/ATL9z4eg+fUXCWOFi+XyxiNRjVukeeb92I8/H1OEbo//D7HzHu9XtnD\n", + "rBNF+a6vr2O5XNaOHXOlDPObo2ATRB0A4DxhYLn3sN1uF86REVLGa4SPUg6eL1AyuFRGDmmZC2Id\n", + "wbyBSBIg4UDBzaMvzNf9/X25sDiiQs326Sbkx84s/UNGMBbZiex2u3F1dRXD4bAWUCK37D/zchz4\n", + "8ZmdM0jdyI33Po19tc+AsQ7Hx8fxzTffFDlFpphro0cELaAojJH+cTDH/TBaYx4o/YPUTLCH7Ltk\n", + "QHZcCbaM+toxwJYhwz7NaWTDwQABBCimneNer1fj6nkf0qzHMn/H8uFj/qBQ7p9lw2vm/zM2n6i2\n", + "3s+Ode5P5kcxfvalHXRkzXwzj8GIK33LfC36lfuAc4bM8Dsmydt583j+N47UszhSEdXmslHMpQZQ\n", + "LK5ia2URUZ3QcLqQzzxwNoGFJqJeA8QeL+kfo1/8PpMOouZNyu/Td6d7GDffNbLCO4l0MELr9bqc\n", + "UGETW2g8T2y8ffPM73lunN7LiAVz2e124927dyWCPDg4iMViER8+fIjr6+ty1NRziIL1vXMRO+eG\n", + "Qmlee6pio0x4BvPGpsGhBEngokscUSt+iKTeAD7pSZ/pK30BqWKuXHsLInqr1SplLPxZLvppdAXD\n", + "CjKBEaAPGWmFdOm0TE7rMF9GRmgcqaYir42knUWfaOIz1/ixQzCfz2O73Ua/3y9oCXJBSYjb29uY\n", + "Tqdf3cGIXK3X69qJHyJ51jDXSkKZ8z2fArUDleePVC/pZxO3nY7OQZRT2tmJzk5UruoPQooDZ4cV\n", + "J3KxWJQLvZlj5iaiIuCyzqvVqoYYOdVkXZNTEaQuz8/PizPFOlHM0vsmoqpLxR2DnK7mmegtB2me\n", + "N36Wg1bQee5TYywRlW4nNejTWjhCOGEmm/Oex8fH2gER5tQHJFhz+hJR7U8/E6ceGbTu9NxmKgl/\n", + "gxQ5jQ5SttlsirzwTJe5yXaDvWKk3X3nOw7a6SN72nKc0SDmyPbE5RDsDPKunG6zk4XTaxuS598Z\n", + "n4ioIetGqegfwRzP9cELbI33gdfHQYazV54rk9SxMaxXdqL2Oatuz4ZIWVAiqguHSY84usTb57SP\n", + "uT4oUzaVI3anL1CWjiZc3dn/NqQZUVUi59/2xP1/n7TIkZojZBSdDaRz196k8FIYZ04z4gAxpz5e\n", + "mzemlRvPw9jbeUF5PT09xdXVVbx7965E0XDZUEKu0sxcoJydhuSKBxTV01N1QSXKzDwaR0bb7bZE\n", + "rg8PD4UjxWWnpImbzfqlxYeHh8WZWiwWRUHb8BrVi9gpb4w1StqpS1If/K6LanJaCYXK/PJdw82O\n", + "kkk1ohidFj0+Po7JZFIiea8pCginpd1u12qTRVTH/532pNbXPmeXsXAdB+OK2O3Rs7Ozks61zGw2\n", + "mxiNRjGZTMoaY5C63e5XqKidN/YFStFyaDlHtiIqFA45Y12sNFk/5pp3mk/D33xmNMjPiqiuVLHO\n", + "siPE6cJmsxm9Xq98n9Sd69tkPgaGwwbHCLfTJpZv+uZaWOiPyWQSl5eXcXV1VagCj4+PBRHPJSqc\n", + "ZmGvWSfakBA0OkBEpnKgiB7nJgbv06enXcFXir0eHx/H+fl5RFQXWm82m5hOp185vBSX9PUnrA/7\n", + "jHUxv4Y+YGP4HmMB/bZ843wakbPMYD9arVZJyzFPToWC6tAX9KxRPq8HqLBr0DF//Az9nU/XGm2y\n", + "k8n/87iNKoFkGbhg3rBHNH7PKBeN72E3vE68y7yyjN4x3znNzvwbyOB7ZEroi/WJ05m23TxzHxrF\n", + "c3Jg5fZsjlTOiRKZkitHOCPqV8Uw4c4zO41mD5QUAgLqlAK/7yObNnoYdoSZ75G3diTo5hQBSpyf\n", + "O9LJUR3OgmHKiIpfAYKR04UR9UiIfqIgMpRKy9F8RNTG32zujqOfnZ3Ft99+W5QbimA+n8fFxUWN\n", + "xEsDnneEQiSGMnRfSYeYJ5TnYLFYxHa7LXVoInaOFFXE90UNfAcj5Tz6ZDKppVFdxgDndTab1coN\n", + "EOkBz9tw46zbwWg0GjXEwiiA1xGD73U0UntwcBDj8bimNFlPIjWiQqclURLMC/LnO9bgLTn6zKgi\n", + "xnYwGBQ5BVXzPpzNZsUxtzPIAQH2qvcTc0Pw5OBqX7rL+gIUDB6ZycGuep1T5uZeuA/MtxEeI0Q2\n", + "FDhyTnMYMTZnx4VzncbhmSDSEXWUwgRukEnWkGCF9+V0NJXCHx4e4uLiogQH5iV2u92vUpcusmrS\n", + "sB2pnO5FxtiH7EXvfdJ6yKJ1NH93u92SAmZuCDJ5nknFjUajxo3LurjVapX37iu4Sr9zyQGccHQB\n", + "v2eZPTio6j/1+/1arb19NQkt40YVPV/W18wRAQjrijyxV4w+edz8HvrP8sZaOrhzX/m3gQEH5Pvs\n", + "BfNjqk1E5YA43UtfkWHsutFRUoiM0/1jDf1er72DVQcfyA2ygpPKs60XbIP+39CoiJfyBy/tpb20\n", + "l/bSXtpLe2l/d3sWRMq8JLxNkB48TUjZERUE6sg5F+jjuY7YHanjpRLR+Fl4tDyTyACY0MRgIEaQ\n", + "hcxJ4r0RUXumI2O8crxhCOxEWY7YSE9Cms2et087MRaeCfzriMARBlE373AqA+Tl/Pw8zs/PC6mW\n", + "MRGR93q9EsHyXubTcCwRkBE9omM4DnBAKAQZUXHnptNpjEajGsEb0uxmszutlhFHIF4QAtIboGPc\n", + "ydRut786WkyF5cViUb7nQoMgIiawwzEhskGWmDfzuEA8WWOOR19eXpZIO6Lil9CXiApRAqbmea6I\n", + "Tz/4Tq4kDzzPeJk3n2KKiHj9+nV5H3eaudI4awgyBEJGWobPQBtJhznVQLROFLnvdAzrnPkO7G+e\n", + "YZ1BQw7yQQz+D+GXfyMHGeUwVwVUxgi00wTsd55Jior0tm9IAMEgtZWJ7+xVEGv6ws/pp6NrUr4g\n", + "GhcXFxER5aAEXKmMyvl+P+s9kEanzbLOsO7KqASIFQiYUQnmB1n25cOkG41gR1TpXtBSI4DIGIgK\n", + "KcCIqJ1KhGJhPhPIdZZTz5M5Qcw340ZOzQfy+M3PY//RF8s988d8k6nhfTldaKQLnh7fz5kJ7xmn\n", + "+Iw25TUEoeJ5mROHns0ps2xT/DOjwvYJLN/IisfnPmcCPuNzCnYfny8j404L0y+vef5/bs921x4E\n", + "WCuqTIpjkOZBIUSZxxQRX8GcTushjBYU/m8YMCJqBu7u7q4cteYdbHz3KaJevRvIOJ8iQsE1Go3a\n", + "VQi87/HxMbrdbg1KBdL3JoyonBYfo+dZKCHmgLGa6Ggh8nzCZeEklisDNxqNcoy30djVSxoOh6Wv\n", + "vIP19aYhXYTRd6VpGv2lkfZgQ1CLhTGgFEgb2hCycXHcmDvGjoK1U9vtdktKkFQRY3eqmMa84Xii\n", + "nDMXxOuEcvW1DfP5PMbjcTSbza+u+0DhGvpmvlkrO6i8o9lslgMMVN2OiCJ/PjThqu849Dj9cNIe\n", + "Hh7i9PQ0Op1OjMfjuLu7K+M/Pz8vzh77zWlmO/sm9LJuKDCcFH7PTpiblSAOgOXIqSV+3/w5GyP3\n", + "h7QkgQtX/dAfHNRWqzotyDNxnigZwglKZI7ncGkycoODzjvMWbEzQwqYMftwgxU9PCzW8ODgoHzv\n", + "4uKiHJRwatDzjZPvNCvzgMNgg8P7bVhJcyM32VmhOe0KfcE6ykaPtCjr6YMS3pc4xvQNKgJzwx/2\n", + "iw9TOJhGrhiTU+WZ5wa30Zcns2bMGfrdTkY+KJXT8ayRHRE7eKxBPjDiFJWDk+wg2kFxmo059QEV\n", + "/rZzw/f4m+fZJtqJRp95juHcGgTJB0gcqJgaYeDAfzslSrPNxkG1DfS8ICu0HCjl9mx1pEA1zDGI\n", + "qOpV2NP0orMomQti3pI3d/Y+feO1c8QINf1brVYFjbAy9ak3E9loOC9EdNlRBAnx9xCiw8PDUuoh\n", + "EwfZ1CipiHokZOGIiK+EYh+HiD7tO1p8eHgYvV4v+v1+DV1Amd/c3BTlgcGAr2RkwdwWNia/Y+cM\n", + "RUg/mTeUD3eCUXbBMmPFzmeQna3cnX+3HDIO5AJl02w24/9h7816G9uO8/0iRWrgrKlbPZwcx7Gd\n", + "xBe5yvf/CrmKgQSGY5+xWwPFUdTA4X9BPMVnL6nzAwwE+l9oAwc6LYp777VWrRreeqvWbDbL59B+\n", + "gWdaHhgr9wIhKBFA3tuKkUObiZTX63UFIeNdQSu4Z6vVSie72dydTu/1dlEFMudjOHgnV81w1Mtm\n", + "s0mSr2VqNBrluY6sPf2jQHqMuiyXy9xDyBLybeJteSQNCtPor5W2ESj4LDinRoNZWxsDxsO6lRG7\n", + "+T3WP8yrCcIRkc7m2dlZrhXjwDGv1XbnJfLeGBbzjqwbjKCbs+LWDQ4m+Fuc/hLlQ74YC+NizlwN\n", + "bX1C0QGOD/e23ubffM8VrUaBeD+ew/2QbRBn7yHW3xWl3gu12o6PCPLptXPTUeaM90QGkR/0YRn8\n", + "WFZKPYQzjB4uOWsEEzg3XAR1jJP3dXEEsm6bUNo47oXM2sFwUMk7IgPmFRoFM3rDZ3bYjA67kIR3\n", + "eMnBfykY4vcEhdYZ7K9y3tAJyJsRN9aX35nj6MCgfE8j3gRLdpTtcL50vRrZHI/ekSnRHMrbhzAC\n", + "yTJICziTRqqjREFsVDwZbHaTObnKqjYuOx4lyc2wtpUe74KhtyKO2LUUKEt2+QyFz0+MBU6NEQVH\n", + "l5Ab/Xt+lv2NTH5/fHyMXq8XJycncXx8nEhSxK4/0WQyqVRxROwqYlqtViyXy0rkidLiXUtvn7ll\n", + "bR2VktLg/nxmJMrjZlxl+sDpFH9vs9nEzc1Nju/4+LjSfqJMm7pSy6kkV1ExZiOLjppL2Biir5Gw\n", + "iEgnCceOXj68mxEltw6o1WpJDjfszjjYLxg4R/MoRObIChO0gmfyPcr6QQ0cwd/d3cV4PI7T09Nn\n", + "qbvlcpkHPS+XyxgMBhUSvpFjOzxOwfJOzWYzU3Q44KS2bXSNABg95WKeQTztZCF/q9Wq4rhtNpv4\n", + "9OlTrvXBwUGmqJbLZeqhsqAEpIX96ojdxODlclmpsOO+rLXXd7OpUhgODg6yTQUo27eaDWMwmW/u\n", + "6SaQdsDsSFnO+X/eEyNV6tOyn5VRBJ7PWNw0GFTbwZQd1/v7+wxQPFcgXiCP3ofYH+TOqLEDPAoZ\n", + "QDgh0e/t7eWJBg6wnJosg10yDUZb+Gl94u/ZObLT46q+Ui4sG8ivG1OWf29nhe+VqCdjtHOP01fu\n", + "U/7fziK/s71zGg5ZYC1eyrzw3g6S7LCXqT+nij0e5tdj9/h4l48fP8ZL16s4UpTfGhpm8vf29ipQ\n", + "b8R28CiAiGojRnvKbGxvbgQ/Ip4ZBd7B1QMRu8V1btbGG+XKhHtRcRJ5vo2eo3/SVDwvIjItYo5K\n", + "t9tNw4TBszBTOo9Rs5E3j+Ilp8/polqtVulrhFFiM/PZcDjMXkERUUE6SDExjs1mUzl+wfCyv0cv\n", + "KBwsp6gwJmx4O1lErHt7ewmps/bL5TIbiZaOratznNLleWx2KtOYb9YF2fHam7tiKNpGx6kWR/PT\n", + "6TQajW2PJH5vp8cw9tHRUUWB8zdE5DyPPWY0xfPmVC97gHsxjyAlvCfOFYgw88CF01dykFgbd/3m\n", + "YrwYE7fMwLjyPjZ8/lnyRSIinfnxeJz713uYOeEzR+VOx5RUAWQVx4TvnZycZAqJZsI2bGVazIEJ\n", + "vCnm1I5brbbtEUagVzopDsqc9np4eEjnez6f5/vSBd9pYsZAdSzrZ0TnJU4NY+OZGCKOTyK15/1m\n", + "Q8k4jOx4vzm7wJ5yqtyVya6EZK5IGRnhRodaT1uWMJqk+fgeDp9TWuV7rtfbNg1lypX0LO1YjDQZ\n", + "TbRuL/meXien60BquFdEpIPpLIT3vmXEOpN7gBg6gC51q4NXZ16MSPOuZAf8rp4bAsgSEeX9S54X\n", + "qBm/cxrPDlxpn0E9zVFzup99yrt5f9h2vnS9iiOFQrUBIx1mpe6XJ8IrkSwGD2xHuWvETuAwevy9\n", + "L4x06Z3ymSN137NUaFx2zCKi4tXyfRSK/+alKI73tYMU8fwIF/+/HSkUgcnbfk+E3pAtYwWtG4/H\n", + "FY98Pp/H1dVVxZHiXTG6jO3+/j6jcvrEcE5V6dgYKnfKxJuSsTvt4jmP2PHbvC4o6JKHQsRiWWy1\n", + "WhkplqkWNqI3ael82+CU5FEcSIyf4WUceZQysmFiaEQ8i/aQXZxfv7Ojfz+vbNtgQ+PfEy2bM4jM\n", + "YKRKbgKO0NHRUfYJe3x8TJJz+RwQAIz7YrGopFlRkvTS4XKKiN9b8ZNKIQVUIqA2gmVEzBqXaXue\n", + "Qed9Chz43nA4jHa7nXMKgkTK9eDgINNWfk/4PG53YHl7qfyfMdspKNtbYCjr9XpcXV1FRMT5+Xki\n", + "jpZP/t4yab1UBmJ2cjyvj4+PMRqNYjKZ5Fhd8GJDGVFFwTDWDjjtPDkwZQ9j/FmXiK2s0werdP5s\n", + "L0rUxYgTMsI6cS+coYidQ848O2BjfUgxko2wrsFAOwiwA1JmU+ys2EkHWfJakQYt18jvWepKO3Ps\n", + "uZe+R2BnFMiBg+WUlDV70ek/9j3tKdwAln1Arz4HhbbT5gIjgyXowUUgQ4sPZITLDqqfZ+f7W9db\n", + "+4O36+16u96ut+vterverr/zehVEyhBmvog8QBAbIy9EbF+/fs0IIGLXFRVv8yWEiIjOeVe8fxCi\n", + "x8fHZxwSOBg+M8xpP3OlPA7gW+fYSRcQfZSQNvd2RBQRCY9TyfWSBw2079TH/v5+JRLyO0fsCLUg\n", + "CEYlWJ/JZBKXl5cxn89zjIvFIptDgiAYfjdMXKvVErm6vLzMKJ1xOlrwmUu8f0Q1lVrmykEk+N3T\n", + "01MlLdpqtXJOLHNGuZADIihIwuYGOPIyP8ERG6kpGlh6nZFToiy+zztAFPe6OBI2OuV0Ycl/sBzy\n", + "PubRlGhQKUc8w+lAw9pEa6TpXF3Knux2u9Fut2M2myXvDITRcu/IezweJ6/IqMVLKTEjGozRqT1z\n", + "/0C5PL989lLpP3JH9Oln80z0DWgL8jaZTHJsnPPo1NbBwUEi5bVaLT+zzuMZrD0I5WKxyK7gXE6h\n", + "griA/q7X62y4WSJL7PdyP0Rs036k540UMc4yg+DP2WOkS+7v77NtyGQyybWwfuQ+INRO7XAxp6Cu\n", + "Rl1AlCk0MOqE3ivXl3EYqXKatF6vV1LQyBP/b46uW7QwbtA3I9Xs9TIlxmeWeSO7RnzNmyRV6H1b\n", + "Vtvxk33guWFe0R2MH/2FTfQ+BRUrW4lE7NKE2ALrT/QF/GYj4/P5PCaTSUyn0yxmYN7oLO+xlf6B\n", + "EUX+1ilmrxHjY6z4AeZou9mt9aALN751vYojZTj8pTQVEJ8NBsb04eEhxuNxLobPGGPA3B8yrY1m\n", + "aRRQjK4g5FnNZjPLxl1NYAHld9wfISuNt/+O3zFeFIgFmqtMQbD5eE/4KqVSsGLCGBviRticRuFA\n", + "2Ha7HZ1OJ2F6Q9Wj0SghYypcmF9KxuEucGZXROT5a8y1nQW4TvAySGexvqQ+MG4mx+JAeQ24p1Nd\n", + "3hg2zNwPmeEdgY1xnlgXjDYKGUfZaQH+zr2bHCggW4aODeWbS4Iswk2yDJMKsUL0+pPSBFb3OMwj\n", + "fKnC06kzKykcdkr8kYu9vb04OzuLXq8XNzc38csvv1ScHj/74eEhq/0oJmCt9/b20uFgLcwh8bxQ\n", + "5epAxHID38dGnr/jd8w53yv7PJXpKK9xs9ms9IlbrVYxGAxis9nEly9fct6Yq4eHhwpHLmJXFeie\n", + "YE6R0LUd54Z34Z4ljwvZf3x8zM7vrgi0nvPfc7HvTZC2nPjvS74Uzs5LKWHSKdAPvBcptPF+9HPY\n", + "R66EhFPI+Gy80ROuYmUt0D1OCzp4Q+59aD3ri8OHTjDdgj1tPpTniJS8gxsCATvETtkh4yV/iL93\n", + "xZ/twsHBQQY5nAHq9J15U6QA+Qx7gcNnR4SghL1kpwQnsky/uYCAcbh9Tdn7rpQl3tNBtp2aUn8R\n", + "oJdcLJ7Pfbrd7jMfw4Gm0/+M+3/jSb2KI1VykiJ2+WYLpD8jv8rkwL+4v7/PzYliLKMaR2V2qngX\n", + "8rB2spi4b+WfEWRvGjYlQgCfJGKHKJngZm4RwoKwefwRO6cBEjHf5z3xzM1xGAwG8d1338X5+Xm0\n", + "Wq2KMWEz2alAcdATqNvtJoeFPiyz2SyVXuloMI8oG5en7+3tZRNAjlOwMR8MBtFoNNJw4yBjeMoq\n", + "TeQCRcUmsSNlZ4J59k9vLDsLlh9zKDC4oH2utkEWarVaOpLmGeAIehy8K+Pgd+UzI3ZOnJ0g/g5l\n", + "UvYcIhJFIdsB9Rwhr6xFKYMlz8pyDA/o+Pg46vV6/Pzzz3FzcxPr9boS5IDSULXGe5qXQ38lG2zP\n", + "Q8lnMukXQ2J+I8a0dArMH3PJOmOFH4czYGVrJQ7iwjg4hxDd5BYH3Ofo6KjS84rAAq4HbWGYb8sJ\n", + "+43vbTabLEbBGeWyLEVEBallv+Bkm8SLE4XzZSPEVRotPmce2ScOFAkkcJTKwg10ETLIOqHfCEyM\n", + "UtiZcGBWOkasKfOG0cTJ9vid4SgzDZ5H26/FYlEJMGxn7LTd398/O07LSJP1jmU1YleswnsSfPKe\n", + "dpY5K3C93h0VZD6Ugy7QPp6Pw4+Dilx5/AcHB5XeinzP728bhc1A1sp+buj9EiXF5iNfjKF0suxH\n", + "MNcGElzNjGw6mOL3PAO9aZl3kPrS9SqOlHtqMBCiDgwKJMyI54eE2mGgDB/hsSHkJHEqWGww7JE7\n", + "RcTzUKQ2WhE7Q4tBsYIGZrYidiRgheJIgPfFsBvCRkD5XlkeDBR9dHRUUVBEVN9//32OqUTIeA+n\n", + "SSN2yABGzaRFHK7RaBSz2awStfD3rsC008K8OvXFGLk/CpjPkAEcUxSgv1c6H8wpBEi+42jWG8My\n", + "46qxUjEzJ6yDDRsG2+OyYfeckzryOkK2LNEFO78gQE6fGrEp03yOqrzOL0r9hz4AACAASURBVP3O\n", + "c4dcl+/C/sFB8f3puXZ7e5tIru9Zr9dzHx4eHqbs39zcpEOGs4Eclmiyf1oOHBRYEZNeQzbKlAqH\n", + "Pbfb7WeNF7mXnSyu1Wp7qG8ZYBHlPjw8ZHEF42AvcLahURcQEAyyAzN0kBHCiKhE8uzX0qkhSCwJ\n", + "uI7mPS92bko5tRyUTr5lir/f399PhLvT6cR8Pk+ytaN/5Iy9Y5kxisw82CjyDuwRrxMpOJBpp5Ih\n", + "8GMsjSxxHwwyzye1aj1jNJYABwfArXt4P9a9dLDZ34vFohJkg046dc09jWyWjp9/8re8K/Ns3cgY\n", + "sVugwk4XMk4cP9Au1ubu7i5Tey+thQn8pk3YGbIDip4BZHjJibGe5p6MCafY54qyruwr20KvRakT\n", + "3bvsW9erOFI+zJcJAolAkRkSPDs7q6AB6/U6ERJY/44AHLWsVqvk5XhjIJj8zoYNQXGlnb1vIEnn\n", + "Zvk7M/+tMCJ2R2WU71mmpdiQEZHpMZyp5XLXrNNdq2mc6YNinZZxGsP/5t44OqwFCIbTSoxhsVhk\n", + "ry8rcO6JoLIGjJdndLvdilNrhIn343coIs+nq/0ceXgNidAeHh7SkNkIs4m5p40skTmGtIwOee58\n", + "Pq8cj4OSQMm9xGGAK+IxOnePgfQzUQx3d3cVRxrkzsiUEYQyhWUFgbPQbDYrvA0+93whn8w9zoK5\n", + "R3S7xzlZLnedrUnBHBwcRLvdjvV6nRwjl+m7WSDPc/TJe/szO9F2GIjYQczKI6VIa4OQ2rlE6ePY\n", + "2TmDy0FQxNyw35gDZIh79vv9NHy0u4jYdZnnvc3/xAFgjNYl/J53LXtMkfqLiIrzgWzZmHndmW9+\n", + "X6Z1mTsjwdyX4LAMQJhDH95cogteY6eHQEeQ17LlB/sJ2eK5HLtT6nf0kINgyxTpV+7tzwjcTDPx\n", + "vLFOBAsR1SOHarVapmr5HqgQ+ob5xlF3IO35BG2jythOqNsfcFnv22EwWIAdMOfMz8Qh4p2NcEN1\n", + "KOeUABZns3TIrbOcvgP4YL6tj1g/ZN+ABWvG+hlZ5/vYb1/MM/cymlvazpeuV3GkHL1zTSaTNAoM\n", + "ngm4ubmJ9+/fV9JbFxcXEbHdGNfX1xGxg7Md0TldZ8PGxOBNm+vTaDQqTdmswIigMEDm4fhyCsrP\n", + "J+r0uXkIE0JuRypi1y6CCJNIr9frpQOFE+UNbJjdabOInWFHQbzETSBn73QSUCkG0Uq5zEVHRCUy\n", + "Y1M4zcTziMR5lhW0N1KJALo8vHx35p1/28ii/MrvReyOsWDuzCNDHsr1ZQ4pjy55RyhzI6Ceb2Qe\n", + "JWjH1albyzBjQg55Dz8Tg2+H11E66+/0ldEIo4VE1lZcRlXZC/QS42JPksIiamUNO51OOjYR1dJ+\n", + "FDsOjtFbK+ASOWYezYHyOBhfrbZNxRrNQS/wOXvK84ETyTv3+/0cM58xDvf0Yp6McuIk8zfmZ3lf\n", + "2pg4pYN8uImsZc6y5rUmALWuKVMlvr71e9Z/OBxm/yXLAAEXAbIROQw0PEgjsDgfNpZ2CsfjcUwm\n", + "kwzOGBd0BBtExohcYMTt1BHcWhaQbzt0XiP+Dr0MbcGcLL5vhCxi197h6enpWcoXuX3pNIX9/f1n\n", + "fFOey7NIETMHvofTe6ZN2KlhzxlM4KfllTESPGM3S7TSOpw5YT/xX1kcAIpdIuMeh5FF1rdE6nGw\n", + "mW/aLRjYsD5hH3rflaBIeb21P3i73q636+16u96ut+vt+juvV2t/QITq/HBE1fN1ftxw+MHBQZyf\n", + "n+ff1ev1jEyMDhF5ANGbC8G9iFzwZHk/R4dl8zpXiZRRGpGL78E9I3ZwvSvaHL3CsXqJbN7v9+P4\n", + "+DgRqZOTkzg5OYlOp5P3dTlnibgYdSs5Fa5KAP0ADSovUEFzzJhv7odHz2eOyl9Ci0Cx+K75S8wf\n", + "//kzZAli90uctBJBIqp0tUz5Gd9zJOQIjfUllUqqGeTDuX/e1ZwA39scn9VqFbPZLNtGkKJiv7hR\n", + "KBG001tOi/C5Uyfl88rCDCNQ/J3HwJhANElvgP447cVe6/V6icKCGrvM2UhfCfXT0gKUmKtEHplf\n", + "oytGJRyVU/RQq9WyZYD5J/V6PQ/HdkrU6XhQLMYxnU7zeBAqW09PT/OePAtOFu9vvpWRGd4flA/k\n", + "kDEQXYNu8V3uCZ/I5f6MgfE6nek58Bw7feN5L/92tVrl8VF0f/dFA0SoCS5CgbdkYjlrityiE01V\n", + "ME/V5fLORLD3ywtd5H3Id5jTkmwPr2ixWFT0M4U8JSUiYptpYZ+5KzvPs36zDsZeGTn3+Fh75MDo\n", + "GegtYzDvzkiUES4+Q5eY5sGFHeVz3sfyVtpFo+geA+PAxrJXGT8Vty5MK3WG19JrZ/3mtK5pCeY5\n", + "M3ZzqKwv+L3f/Zk8ffOT/8MLgaP6KaLK27BBjIiKgel0OhUYM2I3CfB2bKCB050LjqgeFAycW1Yd\n", + "+Pe8D++LMDrdgECYTOhKMUOGFgR4PKR29vb2ctPxHoeHh9HtdmMwGORxD/1+P51DK1su4Gt3fmbe\n", + "ECIg8zJlxGfmCHEPBA3n16kENpBTcVwWTDs2QNBs/NJxZSy+v58LBF5+BoT7ktInpYtyNMRrgw4X\n", + "is9QeDhSXE6fMu67u7sKb8NKsuQKoERQGK5429vbVizBh3AVHf9h9O1ksZeczvX6mmjrNCX/NmTu\n", + "9eX7ZcGE95KfV3K0GEtEVNIlOAplhSbpIKeRS4fWijtiu9/m83mlw7TfCw4dh1bbyYzYVqdiBHG2\n", + "Tk5OknfJmiAbe3t70ev10jiWfXAwpCWBN6KaHi2JunzHqbmIqOgm84UidmkZ5NH7wuvpg3x5vg1Q\n", + "eTllw37kfjiIw+Ew01gm+k6n0xgOh0lPYF+wn9BVnh/0noMeOx4UGC2XyyTxezzWXXaGMZLs+9KR\n", + "Ilhxyhzj/fT0FMfHx2noeQ56mKIpdON8Pq84dawJ33N6nnEx9pIK4fQVOsp8L2wGwQx2xHw587NK\n", + "Hhx6sV6vP9OdOEqr1Sp7RlmfWM+UdADLnNtU4CTh1DlFT4BBmpgUdcS2KpE1MoeW5+E/MH92epGh\n", + "Mv3Id5HB0jcpeaTl9SqOFIrB3q4/Y+HttHwrJ3p4eBjHx8c5kdPpNAfMwqNkOJcuokrYI+r3RJUI\n", + "FJNO9YYjayt3Frd0FGkOyec8N6J6GCz/76gMQWi32zEYDJILQW4aB8oePQLKBkUZWWkbkXCE8RKf\n", + "w0aR79vg8T2+WxJOXQ1j5c9nRBUoVBs2bxLPm9eL55pbZQNbVuYYBZvP54kAMa9uGuiqOeaUcbjK\n", + "hujqJQVeGusSBSNyQ24wNETMNipGM3DAN5tNxXChDOBSlO9kx82KDkeWy9ElCt+RnflMrBtryBio\n", + "KmO+zdlxBa8rJrmnnT4jWciyo0iPg+/aebVj4/5xfO4xwpskUkYuCOJoOsr6ttvt/B5z73Mmedf5\n", + "fB7Hx8fPKuTm83kiM8gbetDcTz4DAWMP22Cw9+v1eiLHNvrw1Ox08xlrbqJxKQf+W/+u1WrF2dlZ\n", + "pRcV74osLhaLRPsYP/qXefMasiceHx8rhHKjjA7qeFf2DQ4t62tSN/NipGhvby8mk0k6zC60oAlt\n", + "xNapNtmc90YueR/zLZEh5NC/512M6ltfWrej890nq9SLRq/s2LAHy3YZETuHnwxNeSHDAB6WU/it\n", + "OB3sReYR3e49bsTcup95BGBwdTRzaGfHAaR1RhlcMW/fQikJgLH3Rj/xJb51vYojRQrK8CLOAwrD\n", + "jhQKpOwSHrEbJH2Ibm9vnx0GzN/b8FHeiUPHYZ4RUTH0LBZC6vQUxslwu2HIshEeqIU3dkQVkSgh\n", + "8dlsFrPZLKNcHDKeV8LEVnCMA+E3cR4hMSQKSsBGxGgYSgXdw6GwsrXX7k0fUT3YMqLaKblU9GXK\n", + "ibFx/5J8yf+bSItjiuIsz5djDkBH+Iy/x6Ep78n7oCCtvEBPTKwso31ko3x3fl8qAae5/OyISIXN\n", + "nNgQsZ5EipYtPxuDY6cWRYpi9Pjr9XqldLpMFaH8+/1+9Hq9fJ7nn4g5IrLAxIqb5xHcuJKG98Sp\n", + "BFFiznEmn56e8vDcx8fH6HQ6FZQPJInneYwgdXQrt+O6Wq2y0SXGnfk2quk0Ow0nI7YEaVAmPnPk\n", + "3Ov1KujB4eFh3N3dZbDIe4PSm7hsnYIBoyu6969TSHaEcKxLJNnz8i3ECv30D//wDxlIcb4fa06F\n", + "3Xw+z15bOKyQtUHleCYBEfLswBCd8NJei9hWi56cnDxrqExAVDqLrBE6zvoN42rkhcvBvasumRfL\n", + "rh3ziCqR2VmTcs96rdAfBG2mKHgty6pPfg8aD6rmTIEdJWcA2u12xV6bUM+cmIjv5/k+1us8z/Lo\n", + "LIWzG8iDn1eiTRG7fVGigJYZO9LlM2xj7GOUgUR5vXpDTsOLrug4PDysNJFjkah6s7I1d4NGiRGR\n", + "B+E6D2r4l/41RKgoWibN0W5p2Bzle8IjdgJi5WblWkZfhndLCBZFCZRa5v9LbgljtdOAk1GiYDy3\n", + "FHKcKMZQjt9jdprSOe0SIWBMzEPpPLF5S5jdskIEZ0eyREts9EAh3ZgyYufU1mq15Ok5VeQmjd7k\n", + "vA+yw5xylQqjTIUgVzb8yDAb10hZxK6CzakUfoeMgP6AmEREVnAig1burJODFz4Htkepl/LhVILR\n", + "I5BkIjnzH+2Mkjbgu/v7+zEajWKz2SRKZLlAVh4fHytNc5EjHPqyxBkdQosQzw0VZYzT69TpdOLo\n", + "6Cj6/X7SCcyLQk/ByXPTSebIFYqMA90C4meHAL31+PgY0+k0uVWknknPG80wVQC5cEAHgvISr4O/\n", + "tZFnznAGSK97r5WpXu7FvFv+G41GnJ2dRcSWJ9RutyvHQKH7Hh8fU9czJuQb59oojeWYvktO1fl7\n", + "6/U6kQR+h+OGDjbKGbFLNZPa4jOcZ3qb2YCjB9AXTsWi7325pxPPZJ+xXk5/od9LVA1g4FsIo9e6\n", + "RFwJFo1WoZP4jN6EEbsejugEUn0ROyeTVCJ/53fgOy/xmZC1MlAyqmZ0GVnBttmu4TSWVZsRO32C\n", + "3vcaYHvsK/gq5b68XsWRIlLyyyKEeLZGQVgEoHZ7vD4+BO/TpEujMm7Qxf1BXSzs3NvRhx2oiCr8\n", + "XUblLIpz+ihroit3cDbkSMTA8/b39zOdiDKz0ua+Nj78tIPGRi3hSZQFyjpilxJljCgej5t3i6j2\n", + "mmEM/J0Rx8VikeMoOVne/IbUuS//BoFgDdm0PmIj4nmDTMPDKHLWyLwFKx7Wq0yPls5TxC5d7b8x\n", + "sub0FH9jTgFyhBLge6yd0wEocZQgcmFIHQOBsrSTaeTBqdqISKcTFPju7q6ShmHdUESMH+4i7/ZS\n", + "6gCn3Kli1on5K+fX6S4jLqAbDiJKpMTGxdwyDOJoNMpxU6rf7Xbj48ePue9ms1l+RmoKBMVR+d7e\n", + "7mgbHB4rd4ISCMTlWXtHR0fR7XbzKBXemaNJ3KIhYpfa6/V6z6Jq5JuAwagDsvgS+kTaDcfXaV4b\n", + "1ZcCU/7tgIG5+fjxYzw8PMRkMsk14Ygg0pO8q/d6q9Wq7HenZF7ah9bhZDB8Tqgv97FCZ9B4mD3v\n", + "ZxOUkWYk4OIeDhSs25FJt5owOsYzvDciqvu8RAedtsaZdMBjNAfdZkqLnSPf3+vKu5Ryw/1s2/xO\n", + "6M5SPzDPJurzLp4/yyL7y8Vb/I2pIyWAYPv7UnoaPet7lrL0/0Kgyuut/cHb9Xa9XW/X2/V2vV1v\n", + "1995vQoiRdSNhxux8+SJSs2DMgrTbDZjNptV+Ex8D6jWnuRqta1EaLVa0W63s+IN6JBqC6eJeEci\n", + "b0c0RsmMcPCTvy3z4URQjMvvSTQBauBUA+9qr53vAXUbPSrz3eTS7amX3zW8yZwSBdj791hJGTnq\n", + "9/1KzpbhWSMSjMeImc+jMp9psVhUogh+wqugeZvvCdTsgoG9vd0p5D6Lje85Bed0AvczIuo14Tus\n", + "o+ebOWc+WRfuQXQGImkkK6J6dh7vY9JnCet7L1jOvPaOQP08p2Udwfoz/h5koV6vx3w+r9zT1atG\n", + "ijkuhHE5Ted7m0uETnCE67QUqcQypQ3fqWwCyzqR5kCfXF9fZ1UQ62V0DR6To2DGAZJepsBcNk+z\n", + "SGScDtLr9TrTkOahWMaMTIAar1arRAiM4h4fH2c0D8rPvdiDPId5ubu7i59//jkRI9MInOIvES7W\n", + "GFmzfkJGTk5OYjQaPePDwS1DVnkOa4TuYs5MqEfG0N2me3A00MPDQx58zjhcqWlOFrrFdBDrIjeT\n", + "NW8WJA1kyLYEdNkpTC70DjzUzWZX7UeazEiTdSlotCv4LG/oEfad541CGqNIETuqAP9vHeGWISWH\n", + "jndFr1pn8BxQvpJzauTfdt52zVXnrIPPRLScIofoe2d3/G9/h8/M5yrRqP8XOvUqjlREtS9HxA6C\n", + "dG7YJ6tjmBEuSpIhYnJEgxcRRwjFcH5+nlUflNzDJbETVCozbwzSaCxI6SzYcBreR/DNbbCBdkrI\n", + "m6fdbsdqtaocemwYsyQplkosYnc0jeF2ExlRHM4bG6b1JkWZojycu3Zqz+vM85yDt/HGCOFEbTab\n", + "SqFBrVarVNaU/CwUpufe6VycPjs9GGZIw76nFaONIunoEj5mDOU8lXPn9zcvC4XKOvozy5G5BIzD\n", + "KXGKESKe9+3y9xgbStXOcrmWJYfECg7Dz9w4RWlCPX3OaO9BKoN5I03HcSnu7owjxHqRTvERIHDO\n", + "ms1mpUs1c8062MnC0eK7yD69kNbrdeWEBMbulLDnhXdjbY+OjlJHRew6apdOtOeKquKSb4U+KI0q\n", + "fCIoC3YIeNfSCPN+dL72PmSfQQR3+op9XXJZuOysvxTwnZ6eZvXedDpNeePZ1ouWNfau0/YRUdnX\n", + "flZE5JmVDib9XVMwXI3FeNFRbm/B2HAYLIvI6XQ6rZTsI084NAcHB9HpdCq8NRwUeLp8bzgcZqq1\n", + "Xt+dp8p32NcOKk0xsb50/zVS9qUsW26cAuNijzL2krbAWpqu4HVFfsqiCJ7LfuR7OP+WQV+m7fgd\n", + "DFJgG2yD+Ftk34GfbZd5bsyRdUJ5vZojhQIzh6YctDcbCpfIi0E+PDzEzc1NLJfLODk5qZDUjIBw\n", + "nAqIlPuE+D24rIh9WZnxd3ZsbGQtiCi1knPF91CypXPGpnHU4Dm6v7+vKGkrTiIEHAcLDpwNR3tu\n", + "roizxN+VeXVHJnYWI3aKqlRe3rSr1Sq5IDRDvbu7i4eHh2cl0DgRcHe8WT1PZWTC5xg9rxPjs/PO\n", + "OqGIcGxMDvW8oHg8H1yes/JznAOeSwsA5vIlpW+Oj50eGzhImH4+37eSctNMoxWWS+btWygPChFn\n", + "ASfOCBCK/+DgICaTSdzd3cVms6kYE/rsOOhwBErFFc8teRwlWdZVbEZBPQ4bCxSqHQH4NSBwPiII\n", + "2ej3+xVC/d7etiEmfXsspwQyPiLHFWKME91hvcc4eV8739wDbs/x8XGukx1P6yz2EOthOeTdMZKO\n", + "5nE6/T6WF+aOvy2NFAgC+9vBVjleF1Ogf8rDlz2H7AEjciZS39/fVxwL/h4HxeiJuZvmMXpvlkES\n", + "pOnj4+OKrPOerDF7mHvSRoN38BjgJ47H41ittsTuk5OTiKg6X+xDEGjemywGQSpzaoQeveJed0bN\n", + "vYYgd0aMvd5Gs+xk2WHj37ZB7Fk7+tyTIK9Ef9n36CGADcue5cpZCtYfXWJdShaGgIL7uGnw/68c\n", + "KSJMR7sIJ8JhyNWKgAm08DuCt9PRarWS+NfpdKLT6VTKw70IpbfJhsHQlsiKoycvsqFKDE/EzpHi\n", + "dx5TGcWVqJqf53dhYRE4k5S5DFeWa0BF2mq1rVKhlxKC/1KqwlEFSoJ3L9MGRqv4LkalTOE5rUn0\n", + "w+UKmnq9ngfeopzYjE5TPj4+xnw+TyKz54D1JrVXEtuJ4hyd+DPkr0zbMX7ey0bR8+X3QE55P9Ai\n", + "y3OZ9nIbENYXcrRJno68mWPWAdlGzsoKUu5txcQYWd/5fJ7Po+qsXq8n8ZzP6GiNzJrETKoMOSNg\n", + "4p57e3sVON5pNubZCKoVMpVWbhkQEYk0gvZ6bozg8b6lYu52u9mfiXsPBoN8frfbzdYLPA/nkf1G\n", + "awhkEATRUT1/64CGq0SgV6tdbyDObavVahXjwBoyBigS3Pf+/j6urq7S0D49PVUQfN+n1CeeO+sL\n", + "f9ZsNmM6nVbWCeeQUnwbVQJg9ken03nWBw8kj88jIh1FZzDsDDNe94XiM9ae/9wShv1QOv7IVqvV\n", + "yoDdhHIj7g4wWCOj1A4MaZtB3y1kjc7x/X4/74cNQKaMRtqRBIHHvrbb7bxvq9VKXWPknbkh4C2z\n", + "DuhzvlfqRuaPueC92HNUNpZZg4idzsGx9zpxeV9gX+wQ2uHl3yU6xj7BL0HfRuyyDS/JfL7DNz/5\n", + "P7zgVdiZIOpwtFimvnBq7GFH7LqN4wjwbxaIA33tGXtTgIaVufLSEYjYRWZMtHO+CKEXiO87j196\n", + "2SgEQ5yGbMt0lh0polkcQvfJcjoNBM7RkJ3RWq0Wo9Eo70seuoyuKRu2YHkcZQqJ8TO/ID12bOwQ\n", + "AZ8breLvqWIqBbzT6VSUKrJgpWfHl02JQ1XKoQ2BS3lttMu14KfHUkatdkbLYMDzao4U70/AQJQe\n", + "sUOW2u12lu3zWYkUGpFB2dEry9GXUT07/YyRMVOF5L28Wq2Sm1NGqSBLyCNzCoLMvnLHaI+XPWpU\n", + "jd42/K3XDbSZ5pAOtsyNQnka6cABMeKH7DPPOP7oGoKyXq+XaJajZNZ8uVzGbDZLY9pqtRLB8Poh\n", + "M94vOFx85pSRKyZBWjD2Jd+UdAmHnXstZrNZjMfj+PTpU7x//z4/43slks5lXYBuY97QFRcXF/HL\n", + "L7/EZDKpIGt3d3eJbMJbjYhKaxrGUvIxSePhhPNZxI7n46o1Ak90vA9BtjPDOOxIGsVw8OVgCZ1s\n", + "dJW/Jw2LE03F4ksUg81mE4PBIPb39+P29jYzDxERV1dXcXBwEIvFIo6PjysBpNcKYIKAmPHbDs3n\n", + "85Q5pyvLVjvWOWUGh7kkOAeB5Hu2oQ7M+DcZJv/eGSrskd8FfYk+9t72XHh9uJfpEB57xG7/Gzlz\n", + "sGLH29erOFKUAFv4mVAm2oYPRWIHxz1hmBQWEWEk3WCinC9D/mXulsm0YeInC8IY/FlEtZeNvWWn\n", + "RkoHzZFQqbDKCMAOJhsGo8jfuVGjkb7SeLvkl4teKygaFFrEThGhbOy5R+xIzn4/xr5eryvlryaA\n", + "Gmms1+vpSBGlYkBwxnhPyKG8P99DiTKPjoQctSBvzAv/9tzZWbLxtRwyXygAjLHRLOYLhekNz/qx\n", + "yZk3lAVOhlO7oD5HR0e5RjZodl4x/FwQX9l3VjZeh729vZxT5BQ0wKmter0eZ2dnKRtloDMej+P+\n", + "/j76/X4lPWD5Ho1GGVCx9hg2ggK/hwOSRqNR4SSZY+GjLSwjpLRLw2jH0c5bt9uNfr+fjliv16ug\n", + "fZB6F4tFdDqdvA9pmIeHh0QHMIroJkrr2ZO8B3KCIbFu855oNBqp5O1A7O3tPTsiBONeBkSDwSDO\n", + "zs7i6uoqhsNhdLvddCTYY+zjUkdZNlgb65TNZtt5//T0tOJIU3hA/zJ3y0cn4IC4iS/B3cHBQTZh\n", + "Zt6sYwm6S/SDe5VG3UHAS4G+G8va0BIA8rfm8rF3Sb+zTpzNGLHricV7gkahb6fTacot5xYOh8O4\n", + "vr6OXq+XGRfGCMG+2+1Gq9XK3mQcm2QbwkVmAtsHCZ6/I5jFoXXwVdI/bDdJ6aOvcLJw8tEXTgki\n", + "I+wVOH3smdJhdxNuZK8MvngmOtGpuvV6XeFm2jllj/xviNRb+4O36+16u96ut+vterverr/zerUj\n", + "YpyrjagiPnzuPHqZV/e9QGWI5k24dXrFED4eJ6iT03gmpJE+chRC7t0oUsTz9ge+uIc9bv8/0VHJ\n", + "xwD98vw4mmg0GpUT440clZV6TicZDiU95tQTYyO68PeIIohATUB39Zyf91LDUxAER+AgPY5mI6pH\n", + "rHCRrpxOp8/I3bwzESbrybu4fNZRGd8zF6DkpvB+Xm8iT1IA7gzu9ycK87uSkqRCx6kII6Dm80VU\n", + "KxOdgoyI5Nu4oWYZXdfr9SxUMFfA6JWP1/A5ZUZBI3aVeYyRueB7e3t7cXx8nKgNa8EcLhaLPOTZ\n", + "8srflpwNokZS/uaXMDfMf5lqdFdzIlOj0SBUrD+f0VkdfpXPY9zb21YzzWazePfuXRZORET0er1M\n", + "7Ww2m0zpMEZQzvl8XiH/Ov2IfjKJud/vZyr4/v6+kjJiHGUqharAyWQS19fXFVnb29tLQvPNzU0c\n", + "Hx8ngR0OCUhQicow58yPOTqmFFxcXMT9/X1WBpJROD09TT4biBRpXloHkHVgjKQw4ROZqE3aeTab\n", + "Vc7RRKch204HIwesu2XKyCNyZ3tkGgGHi/P3Tota7/vs14gqknN0dJScsPv7+zg9Pc15ub29zcOh\n", + "n562x72QrWGMNHAFmTLCPZvNUtfw91ymOpTZFNJpjNk2x2uPjkM+jAwig9yj0WgkXWOz2VTmDR8B\n", + "moptt9+7TNuX2RxTQbBZ6Eae5+akoI6uAPbavHS9Wh8pJhdIDkUBdGiYz04GisWKDw4M3YZduYNB\n", + "YUIt/NzX/CU+8zvxDvwkzQDUWRLmMXwWRnLFVtrepOZ6OD/rXiLcwwLFu2AoyiNFSOuRZrLgYODg\n", + "jvEOjIs18HyzSXhHuGdcTqnZiXW6hE1Vcmj4W6d1MeQYPVI1EZFcFfd2spK0jJgL4TRR2d6CDe3/\n", + "XiJAlukLp/DI+Tt9h+FHFuxoNBqNyuHDJrlioG1UbYT5m5IXwLOXy2VWBdqpZR2RN74PP83Kn5QB\n", + "Bgpi9P7+fhrtw8PDJMTCLbFjfnFxkfLhvd1oNGI8HqdD7nQK6QOfVeegCGiesZE25bt7e3upFHFk\n", + "LANWsrxP6XSTGkPe6DtX6gVSU5yJN5lMKlxNUu3wR5zWZp65h51zZty5IgAAIABJREFU5gPnCqcY\n", + "5wkeE2ensb6sn3khXKSkN5tNFmREbB2+wWAQ5+fn8ec//zlub2/j06dP+TzmjHcxRcF6kfn1vmE+\n", + "e71ezk9E5AHBR0dH6dyXQSMBBE5DxNYoci/SUcw3jhzjs55Bbzt9Z2I478tewz459YMDx1jZa3Z4\n", + "uRfvjd7a29sVTEwmk9QTpOjNLdrf34/BYJD3gxR+enoa8/k8ZrNZchUPDw/TkTZxm0CDi/Sl9b+D\n", + "AeaeQNH/RhZxRlyggp1lvbx/0K/MMwGGKQwR1cKOl7horD29wSKi4oiyTgSVJYVms9mk00YKnjEw\n", + "V4+PjxUqA/OJ7fzuu+/ipetVHCmM4mQyqZC8yH1inGyEMDDk/b2BUaRE515ghMWC5av8bkS1HQGX\n", + "nSs7e5AhuZdJch6D+Tg4Jy+dJehoKGIX0bzkDaO4XqqE87g3m03lfLmI6tlJKBQT3BFilw0zfnPE\n", + "yKszBngnlN8aBWE88EScY4fcXvYCQ9HxO6MgzH2z2axwrzzv5irYOcVxRGF4fm3kjYQaGXELAeYH\n", + "zhBrwv0Zo422KxaJeOzYgNa57Ydl1GtiJM/IktElc8Qwshhjj3k+n+d5YrwbChoEEKVP9VrE7lgK\n", + "95vBYGDovbfZv6PRKLrdbnS73exFxcW6gpx5r3G5cMGE65ITVxp9B0LlfrPjYUIyjToxmsgtzzg+\n", + "Po5arRZfv35NI8hYceTQEcy7jRxOPe95d3eX+wgOVnle4Hg8jnfv3kW3283v3d/fV/af0WfmhKo8\n", + "Owv1+rby7J//+Z/znZFDxm7DbV1aoumuBqTQgmDQxSvIHA64nUzrByOEyM1kMsl97AADOUGnQKqP\n", + "iCw8cjDvve9WJF4bileoiOv3+xlEWCaMoETsAivkxXLIGm42m0pbHr6HE8R+LZ1veHfwj3gf9Lz1\n", + "TYnK8H3WhGc6qPa7urChtG0OwAmSbEtKuSt/Vxbi8DwCJYIM6yjujd7z941io7N4Ns9C97EPWTf2\n", + "Pwic19BOXXm9miMFzM3EEXljoL3R2EQIvZUNG6hETfie008mlDu6x5Ba+B2VOJ3GpmZRTCzEMcEg\n", + "sJBc3MPoD89zJFymCN0N3R42UYBhdkdXjIE5sxDzXgioFSH3NNnXwmgFbeIiY0dJ2Qnh/VlL3olx\n", + "OO3puXEaDfKjHeWIXeWXWxawVm4LgNFjzKQFXlonZMLpOUPzoHyeb77HvFkmUVCO1IwuUGGGo2mE\n", + "xA6BI33GjOK2Axqxq3h8enrKrtIREefn5xkhllE5zhxOoJE92hogo14nnK+Tk5Not9uVoGU2m8WX\n", + "L1/SKTTZejAYxGAwiNlslvc1wRljWDoeyIxlPiLSsVutVs+iahupTqeTMmw95GianzhSOJRHR0cx\n", + "GAwqyh0jNp/Pk1TLvqDP3Xq9TjSrdPoJdpx6IoKG6mA0qNPp5P1ns1mcnZ1V0sFG4O3Ez+fz7Pfl\n", + "c/UitqkmUmKnp6cxHo8rRh9HxwbFASYXDhjvY0OJw+t7kO6lp5gdAnQ21YRGemi/MRgMKtQE9k+t\n", + "VsuSft7PvbXKjtkQ2tF/TpfjALNn5vN5fs9NJ/lbX/69U6F21Ph/3un+/j7u7u4qjnCJ4PO+Tqnx\n", + "XfQBY/VnzE35GYE8Py0bUGYIwCzDpsmURS04gbxPidJbzxmpZkz1ej11tG2wD1dH5hiDnSD/P/vA\n", + "tBzLLTad5t4GAco1La9XcaTgZZToEIuL0WdybKwxWChMO0OlJ44gvAQxR0Tl78o0nqMrvhuxi7wR\n", + "rDJ3iuEHtvQCIIQ82/dGAEGK7JlzLxtyX077OOK384PRsfFjs7AeRiF4FgqKuUIpMV+eT1BFxmfn\n", + "zP8PemOHyBvBUSLRFuMwQsAY4SUYdcKI4kjRw4bne60pr+Yq00dWNI7mQJ4itkbIfDrQIKInlBCy\n", + "Y2eCjU0bh9IZZDwoPe8bFOxqtapEX+T4QUJc0eaO7ay/kRXkqByj0yk4OXyPeV8sFomQsE4Yebo+\n", + "TyaTHCM9fzBw+/v7le7OtC9g7v085hKn1Nwr5IP9Z5mi6SSIolOjGFEiUNYlYme84DzZWQDZcSNE\n", + "IwI2EsvlMt69e5f3vL29TfTKe5T3Qj/ZwSb9y5Ez4/G4QjFg/Pxng4i8vXv3LmazWQyHw3w2nEO6\n", + "j/O84XAY+/v78f79+0rQYVn0c1xJy/xw+agUOoX3+/18H+sCG/DpdJopQRA1HAjLxnw+j06nk+vl\n", + "lO90Oq0EgZZd0ousgYNkDCuUBHMVqR72XHu+cXrpeF6mz0Cbms1m6oTpdBrj8bgSYHDPdrsd3W43\n", + "BoNBIvLsrYhIDtR6vc4UZGn37NzyE3QXygR6jjUD7GDflylDrwVygY1wWs+UBv+t6R4EFryT9V63\n", + "262ker234fxhw6wT5vN5OuPouPIwZ9r9lClP3udb16s4UnjmHiQoTwm/R8SzyMAIkR2aMjoyIlMi\n", + "Ol4YOx08A6NneJl7WhE42vE72bGL2B3L4fE7SjM6g+MTUeUm+Ds8z4RSc6CAmf18O4i8z3Q6zZO2\n", + "jQ76dPsS1sRDd08jfm8nAqfDa+LowBvRzlnJaWA85cZg/HZczTGwk+s0Fs6YYWzek7/HCbFzimGB\n", + "01Gr1dJRQpEBR7vFQsQ2FYGicT4+IioGAHTNRtfBQnkRWSPbzB0ybc6aI3YMD6iKo0s7Guv1rplh\n", + "vV7tTO20gJEfDLs5Qhj+VquVTkNEJCkbuXl4eIivX7+mTADfk9Y0pxIn0YGGHSLGZaQ3YpeidBrR\n", + "QZtl0k42aSee69QexsmXCdaz2Syenp6y8zWoy97eloR/dnYW8/k8z7iL2BrEwWCQZxiSUo3YcdJs\n", + "OLz2ZdqjROWm02keWcKFjJJaxnBGRHz9+jU6nU6cnJxUUh5lMMyYXiKk8/ePj49JYqeRK4Yd3g/j\n", + "iIhMk3748CGfMZ/PKy1fHHARkDqjYCSe37t4gPfmHe/v7/NsRNYSR8sE74hdGgo7g/5kfDj6tHYw\n", + "R4iiBdBH1tD6g2DRuhOOjx1NIzbsXTew5ZmkzJkXy7cdIqNgOJfQR0hxsj7YIWy1u9MvFosciwPh\n", + "6XSa6DV/Z8eG/e9CAr8L7+jAkzYSs9ksgwZ09Hg8TpQPvqMDVZxd0ro8k33vwKC83tofvF1v19v1\n", + "dr1db9fb9Xb9nderIFI0net2u5WUAHAw5FQfd+F8v73okuhWpvJMGHYEDWzp/K0vf6+Exg37ObI1\n", + "98fRCZ+5SsH3NApH+uqltJzJ5L5HmT/mJ6kBR6VuWkeUDKfDc1Ov1xOVKvPz5OXLc8qYj4hdCtQo\n", + "ChGLIz+/s+/h6Jq5dKqC9eVepLbKiM5oHnNkNJGUi9HB9XpXAgvMy2dElLwPqQY4DSVqSGS2WCwy\n", + "2gbp4AK+BmEzodMIYhl5mi/C35lfYySiXq9XiJWr1SpLzS3Pnmfvs4hdStAkfaJSGoKC2O3t7cXl\n", + "5WVEbGW41+vlGji6hne1WCxiPB7HZDLJyhgaDzKuUgYh7ZeFIVzNZjPu7u5ynzBfpFhANEq0FfSK\n", + "dyyPweF+Lpgg9cPBvCAu3PPdu3dRq21PDzg8PMzP4YQxR+12O6uGTC7u9/uZxouIlBPWx80qQbxB\n", + "eYzG8f/NZjOGw2EeJ8M9QQ+QPeR7NBrFYDDIPVA2OGZOeHf4ZP4MXQE/kfUH4aCKyqg632u32/Hx\n", + "48eck19//TVub2/j8fExptNpHB0dJWGbPWsCOJf/TSf5Ml2KbrLe8xmJzWYzWq1WpZDIfCzzcthn\n", + "k8kkDzW2HLN2EfHsMxAwPydiu99/+umnaLVa8fnz52i1WpUO9XDdSH+RrWAtQKE3m20bD+tT0CGI\n", + "8MzNdDqt8EKhUzCnoMW8g9OMpPJB6vis2WwmcmS9zthNGuf9IiLT5mUxmmXYSBM2k7Y3/DS9hLnh\n", + "vpZR9pFtb3m9iiPV7/efEaVZeKcIUKJAm6WR9uW0idsfRFTLLF9yiMoc8ktkcH9mx8RpL94ThWGO\n", + "gR09vyvfsxPonK/5QEDI3li8e5m69P2YV48DJ2N/fz8VuVMzODMoD0iu5qGhaEziJu8MsdYVOHYG\n", + "XjJezKVz6lwoRhO8cXR5l9LJgqjLmpSlrqS3mNeI3WZ7fHxMhcQ68V4mW9o5wXFeLneHantD2zjb\n", + "8FnR8878HcrkpTlBLsw3tJwzJ/x0t/iDg4NMq6GIucy34DwvrxOOIDwUPiPlzVph2AgAlstdXyvP\n", + "AyX3h4eHcX5+nob98vIyvn79mkqYd2KdPEfmhjHvpSNpIm8p915j9h96xEax5P255Hy1WmUBw4cP\n", + "H/LZm80muYb1ej1OT08zvQkvg7PSHHyw3pzjt1qtMiVIwDkajZ5xNR2gMXe8M2kpAoYff/wxn3Nx\n", + "cRF7e3vJ+cEoRUSutx35cn5Jozw9PcXp6WklBch8Ybw9hxhSjJu5o+w/HF86dLOncdapqkOmcGbK\n", + "tBjrhMNYr+8O3iZdt7+/n0UB5f5GT9mQ8z4Onpm3xWIR0+k0gyh/pySMs2a8C845vEG/J7YR58z0\n", + "FOYNh8N6n98zH6bJIHukrk3mHo/HmX6MiMq5tegTU0NstyJ2nf/dl86yiW607ceeAU7wPeSB/VLa\n", + "NQ6C5vsELcynA3cHnoAG3NfFBHAgv3W9iiMFv8QbnFLE2WyWSrdsjbBcLp8hHSh3lByGkM8c1Vg5\n", + "IvA2qiYBskAIlhcfgw6HyGgQThjfc57fqJcFGI4P72CUy/wunmXBZxw2xtwfJwpCp4UfIiLfh2vD\n", + "WhjpqdfraRS9EZbLZSoK3gfjSgk2Df6IDNgwRlFwEsh7LxaLigNmlMToiT9DNphvVw/S98ib2orL\n", + "hwTjzOF4MBc8zwrGjhuInpVNyZGDn4ACRR7gTiBn7iVEWwSTwK0I7EDaocI4sf7srYht/5p2u51j\n", + "8D7EUUJe4YNFRFZM4jAZPSjXZr1ep5Nxf3+fDQRZXwyBW4CUvb84+mIymeSxK1w446ztZrOpkFVd\n", + "QUQ06R5TyD5G0bJBNGpdwT0ho242mzg+Ps53wvnCKWy1WhX+FEYCUrEDSNaQ9i8YxHK9MfCeAxqY\n", + "GsXEEJgTyQU/ptlsxvn5eczn8/j5558jIrInHLLkgojT09PKWYA2XlzD4TCdhaenpzg/P8/7Gm3o\n", + "9/s5pwQrIKB2KkAwyh5cyAqGcTweV46IabVa0el0cj+iX5lvI9F2bB4fH2MymWThio2py+XLAiRQ\n", + "Vs5/5F6MD7lkndFtIGd2Rrkn2Rre1foLvtx6vY4vX77E1dVVdDqddDJBKuEq2Qnhwqk3Lwv5ALFG\n", + "jvx71n+1WiVaOR6PMyDAiWK+W61WxbHCnkRE6mz+xs4g+9D6xM43z8D58fE8OFLYcfsK2AuDD7xX\n", + "6QCaU8n+/Nb1Ko4UG8PnDi2Xy1yYiK2nXSo3lGaZSkLh4927Uy+OgjdQxC464vtl2i9ih2SV8CJR\n", + "y0spKf/OhpaF4/dWmCWa4FRdSTT2GHCqcBBLlAujDOpgpI1IkPG5d1Cn00nFUaYMy54pEPj4Hqka\n", + "0CiUBukUjJbTRhhunBejNVyeozKdC9HRf/f09BSz2SydH883/2bdDdOXFWwPDw+pFIhkUTTInNea\n", + "En/elfsapmbjGz0ySdNKA0Iz8LmhaN6JMVlOnMqlWaMPgnZUaqSHMfV6vTg+Pq6k39mDdqK81/jJ\n", + "+to5pfM5KW5XUD49PeV+9/52ZGiSqsfeaDSyms3IImO0EbOSZq5x7P09HEIqPm34WDMcKt4VJ+T4\n", + "+DgPkWbv48RiOIjgGb8rOtFHjO/x8TH3khFnZMmHRrsTc4mMcpHq5Do7O4tff/01IiKur6+j2WzG\n", + "aDTKTvNl2icisk+c5Y13gjjO3zE31qOcWcczifR5X1fzGiVx81/k+x/+4R/iy5cvMZ1Oc/yz2Szl\n", + "iOIP3p1AG7mxjttsNnkfnDHvfewQOtepYhwk0CH2DM6ou4+zZgSi6FqjK65QLnWxEfzLy8u4vb2N\n", + "TqcT//iP/xgRW6f37u4uKy+dwbGzQoViGXwR0BN8+8Jhsm6bTqeZ9nexBPLd7XYzVYjjHLE7g9J0\n", + "GKfvmBPmyfckwMMOs/bOWrGmzkyVtAWvPTbQBQl8xnO/db2aI+XNErHjCtgLR4iZ1Iid124DTzXL\n", + "0dFRVjFE7BQf9/NCEa2+hEhF7Jyoer3aOJNFJ3KCE8JlR8e5WyNc/Nscl4hI6NwX0eFLjpc/Y+N5\n", + "DAgNyFmZ52V8KG82OPNDVdfj42Pc3Nzks1Fu9PIwT8ZIhisqUJ7T6TQjfkeXKGbQKTcJRHGVKQxH\n", + "k0YXGDu9glBELuPHEep0Ool2shb+Wz+PeSZlYNTCDpbljMtjMjISEdkHx+lkvk/FFvLksmvfG2eC\n", + "9QX1JQ3A+0VsjSkGmujOfAAcJDeAjNhVQlr5sYZHR0f5rowFBMyBCdWc5nvgyIzH46zi4TOca4xs\n", + "abjLd/Kc4FywtsgL1Wmnp6eZUuTIEpwdI7KmGDC20omwjKxW26o3o54475PJpIIcgsItl9u2A+X+\n", + "Z1zoqjIY4//tfDutz2XklPeBk+Z+Zg8PD4lQ2ZiQlqWS8PHxscLfwSEwWoMscuAs8miHEAe/5LlE\n", + "7OQdvXVwcFBJF8PZIhC7urrKzwgU+dzOGvdG97uFCVVim8321AY3ypzP5xUeJPdEN79UBet0J++P\n", + "PD09PcX19XU2Ae12u4niYuOGw2HyK603bONwtli3m5ub5Dk5A8G7EpxYr0ZEBpS1Wi3Tr7bTzWYz\n", + "UWKvE20aCAqcdvceKoNPbKhtiCsTcfSwX85QsW/YHw5oWXPGYn0CKu6/s1yw1wxKOEgmqCqvV3Gk\n", + "2IQWRoQDEmmpGMo2ByguTih3p2WXXfO3GDffs3RMXOrJ37CgRkEQRj7333sBrMxwEF4qZydyXi6X\n", + "KYR8RoqKVCeRdsSuf5QNq6Nu7gP6YljVJHLIo2yQ0og4ZcIYfLSE58bIAj2AIrZw/sePH19M3WL0\n", + "cEyIbCOqKSPmzQ4U788clGRc1qtsqVCm9vw9b1Dn7RuNRoWYW6ZoWJunp6d06rkvcDNRIo5KRCTS\n", + "an4RRoj3wTA5LYlcUTTg93FLhdlsFrPZLBEp0CBImXAXmJtWqxW9Xi96vV4FAUMuFotFpX8N74G8\n", + "MUfwgHDkut1uclYs+/v7+3k0zXg8TjmEQGtyr1NK7GnLCM4pv38J5YXgihEy34V7gGSyPhGRARtr\n", + "RCqbiz0FksTcgCQul8sYDAa5fyKqPZVAyMq+aaXTFvG8hYoRXkfZyL+dqna7nWmsxWKRzsL9/X1c\n", + "X19X+EBGCGazWfK5cEDQ36PR6FmvMuTs8vIyzs7OMt1p7hUBD7zEktOzXq8zZbi/v5/zxhwMBoNn\n", + "aMZoNEo6iA2p18IIr8ePM4hMIP+DwSB6vV7ynXD+uCfPQAcwPsYLFxBHLWKbCr29vY1arRYnJyfR\n", + "6/XyXY6OjnJPuK0Ka02gzx7FyY2IdMj5e/c0sywQiFgPky6mNUAJWIAgO7CHqmCagBFXUp7ePzwP\n", + "O+LsAt/D7uLEsLcJ4nge9obvkUWgeawDKZxI9jfvUrb7wcn0nL2Uzk5Z/OYnb9fb9Xa9XW/X2/V2\n", + "vV1v1/96vQoiFbFDb1zmTxoOUjQRBtE1HiIRc8Suyyu/A+aPqDZfK/Oe5hQAIePV4qkTdZdduM0d\n", + "cCrP0KMrGiKqh6Jyf5+CTarPUTZjBloEPnbFmzkEnk/fn6hof38/yd9EMUDOpF24iHhOT08rCOD9\n", + "/X3c3t7msRdOYQFBN5vNuLi4yFw68wB35P7+Pm5ubrLihkoi1sh8FhAJ5KNM1RC1MWaTjb22/D+y\n", + "x5zzfe65Xq8T+SSSK/lZJkA6SgE52N/fz7QiqBPRD5ENURzf46wx5tpcHJNejbKAtPG5D1IFxr67\n", + "u4vb29uYTqdxe3ub8rDZbOLu7i5arVYlgl6v1/Hhw4fkh7iBIBGlU8tccEQYt2WRKrFut5vRIvdg\n", + "fagUBJmM2O7tyWSSyJHTRUSJruRxeq8krnodifo3m012OvbeBSWjczhrSLoDBNQoJ6gDJH7uxXwj\n", + "w6ytkTMIwRzfwkW1WSlnXOZt+iqRca8VSDx7ZjweJ3K0Xq+zkzbNfE0S5mw7UNyIXWX1ZDLJcdJC\n", + "wBwxUqkUGjgbYESURqDMN6gnc2YE1BwZ5I55I4UDr4r5RieBZJti8O7du9xTf/vb3+Ly8jLRSLiC\n", + "ZA8Wi0UlXcj68LlTnEZWPHdwhU0hccYApPrg4KCS4kdekUPub2oAe4GWBdbtvJtToMwbmQlQS5/d\n", + "iv1hXaGC9Pv9Co2A9DjyBk8MvWAkz4R4tyKhjQiFCS4icxEUGR5XjjOf6GrTWdBp2HCnGXlfUCn2\n", + "CLLnOSyvV3GkDNFZ8WP8MTpOvwC5NpvNhFkjtpArsCGGpCSN45zYyUKYTGg1L8ZKyqkmFh5j7Od4\n", + "AUkZlL0nSKeZX2MHjs3B2MsqpJIcyLsDR5ojw7sgJFQMcT8UP0oPnsh8Pk/eDrC7HUNg6OFwWHFA\n", + "IXhzoOfp6WnOM1D/4eFhwtAUFxjqhwhqZwkeh40Pn8HD4vsoPhtzeGKG39nQ/I1TQFQXomic+qU9\n", + "gavbWEOgYZTYarU7nNaON8qV78Kp4H7O+TMe5MJwe8TufKgylcU7oPycMiH9sFwuK5VOEbuzJCm/\n", + "Nu+F1B6p2Ol0+ozX1Wq10jHFQMORcTDBuLjXbDaL//mf/4lPnz5VeB3mL5YOiA2LeYDMCzIC6Z65\n", + "6Xa7eU9aQJiTR0Uba2UHHNIzhtXrw96m+7kvnGd+z/dIAeOAOD1JdaCDv5JD5fSd+Zhlaq50fn/8\n", + "8cf45Zdf4pdffokffvghIiLXDb3h3kSs93g8juFwmPJrWkOZIqWCDQ7i9fV1DIfDuLq6yvf5/Plz\n", + "rFarXIf7+/uURThDh4eHcXl5WTla6OnpKf/daDRiMBhU9v5oNIp6fXtOG5w1xsH7LJfL6Ha7cXZ2\n", + "lu9Zq9Xi+vo6Wq1W9n6KiPjrX/8am80mixFM4KZikDS6U0a1Wi33m6t2mTMcdrh35nHyfdof8C4E\n", + "SRRbsN7YRJO4S04xuo3fHR4e5vdwyPr9fnQ6nQp3ydXMvLsLoFjDm5ubrNhmHPSXYqx0qOcYKZxS\n", + "+oIhPw5WsFURO1vIO9jusW/MozU/DOcQveiebcgd+5R7WuaojCyvVzsipiSZmaMB2dXcG7xqNjCL\n", + "3+12K1VEVrClsxRRRYbKxbJiRoFjcEy6NEnPRh/BZSGN2KDkMepsAr4HImXDx8W7sCnsIBKtosh4\n", + "FyrWut1uEqrhRUTszvADzfM5XggzKJ+JfnB9Wq1WnJ2dJZoQEelYrdfrPO/KjgbGdTabJaLFZzg6\n", + "VFawEak+eXp6ik6nE/1+Pw0NCh9jbyN0eHiY0bUbF/pdeK433tPTU9ze3maFGvwd5MgOrWUHJ5Uj\n", + "JFD0boAKFw1FZySBfzebzcoZdjaSbsFh2cCg2VlAMUBwNZJ5d3eXCALfN8o1Go3i4uIi59XGm3nm\n", + "M8Ywn8+j1+tVOCYl/xFZtVNLddvt7W1cXl7G999/n2sI4ReD7v1kbhTOsM9pA91lbzjwMRfJpd7c\n", + "l7/B4XXgB9dlMBhUIv29vb0MRHDwuRgz/DFkj+cgZ0Tkrk7ECS0vO03+6eulz9Af3W43fvjhh/j6\n", + "9WsF5YO4DErgyjT2Mghjp9NJPdzv95Pv1ev1KoRy3v/y8jKGw2H8/PPPFeeFvwP9M1KPk7xcLvNM\n", + "xojI/m8cIG10EINIQOq+aIvFIvl833//fXz+/Dnfj+qzZrMZHz9+rHA8r6+vM0C28xKxa0PR7XZj\n", + "Op1W+EpUTeOAuZgCfW3+qxFAG3DOlIuo9h5D/l0JisOGk27Ujf5ZzJ/RQPYUPM9Go1FBSGnLUga0\n", + "kOmR61arVRm/Hd3Dw8NEhLl3q9WKH3/8MatHI7boIIEo47NzhF7CmfJa2HcwKMHvcbDN/eUe6BLr\n", + "KObeRWXl9SqOFB4/qYKIXZrGREuUBZAnyAiebURktZ4hfSYOMi33QjlGVNM73vS8Cx47gmM4FAOO\n", + "0eciSjHCZGXGIpYwPc83cdROHY6Vn8U98chx4Bx5Imh2AlEoJktDHvQGKTe7WwKYqOd3Xa+3J7dz\n", + "OOT+frWBHmOgaswRTbPZzLSIoVrSCybSlmgdisXOCQoTAqMhbJNDnX5jDKB5QOtuD+BGfXYwOPvL\n", + "zrdLdjebTbb7oEqtTF8C+1vxMzZkHIjcc0GUWcob84Fzhwz3er04Pz/PoMCEzL29vWzCiWww9xSI\n", + "EFg0m7tDVnEuSYc2Go1ce6M9/OQ9HQT84Q9/iH/6p39KeUKZsUalM4mzZqTWjhSyj8zxmZ10fucW\n", + "BzwLeXUUjtNN9Rb6CyfPzifzTVoCh7Hb7eac4KyQYrdcszYgp95rrDFz4ZSJr9Lh4vr8+XP88Y9/\n", + "jEajEb/88ktEbJ26i4uLdOZB33kG+xAdQJuMiIiTk5NKisnoCo56u92OXq8X33//fTZJRO4JLF1B\n", + "e3l5mfNNmgd5I3im99Z8Ps/xk1qnrUZEpOOGLJycnMR3330XjUYjq91++umnqNfrcXJyksEn3+eM\n", + "SWTVpHfQu/39/TwzEaf6+vo65vN59vsiwEaeQP673W4iwKwXc469scNJ2pM0FX/Dd5F9uq1bt9Me\n", + "giABpMdpx8vLyyx0QhbRX4yVtUAnIefD4bBS5X1xcRGnp6dxfHxcQeS4SM0eHx9XwA90OM6d28qw\n", + "50tainVMxA6t5nc8m7Qun+Gs4jQZxTMq9q3rVRypn376KQ/AZHImk0luGLxKVwyB5BwcHGSVXsSu\n", + "EWLEzrDYKPgqnRUz+3EmuBDkiGr1HdEIC2whBeXiWf4en6HwXYEEYkZkAlQasSub9/f5HgqNyx2q\n", + "2bR2QBy1wB0gHWeB63a7cXx8nM6uOQDAtFTzMVesBc4xBtV5ZuYYZIbnkbZCeTtFAGepXq9nbxsj\n", + "K0QkODAuVQelLNM9Ebv0FhGiEQSMqnkGXkNXCNmpw5gy7+4UsmdeAAAgAElEQVSpwrrhDODEWN6I\n", + "wGq1Xcdslzrj+JuP4UojpxvgMhilNWxObx93eGaOQOGM6DAGUvAEF9zz7OwsOQ9GYJgjy5dTVMjJ\n", + "b37zmyynt8PrikxHmlRa4kSU6AdoIYaGCJzx48DwXSNk7Dnv/4hICgF71cYNjh9BQKvVyrUg2KEx\n", + "pR0+UHlKwc2vKZ0j6zPzRMrP+NyyZYcKR/ff/u3f4vz8PP70pz9FRMTf/va3jMxPTk6iXq/nfgI5\n", + "w7EldW+uar1ej8lkErPZLFNyjIMg+P3793F2dpb8Ghxz5s6ouRFy5h3ZgL+GY2I9jL5Arh2Ut1qt\n", + "dPqoRByNRilTpGVJGzK/2BuqzLx3I3aVsDihXBzBwjtafzebzTg7O4uLi4vodDqV+xoNLZ0DgkYo\n", + "Edy3lAF0nzuhl8BBibjCqYLX5s7upMDJZphislwu4+bmJn788ce4vr5OO/Tx48c4Pj6Oer2eus1Z\n", + "Ggc8FxcX+Tz6eZlS47lBxzBGxg4tASTL9JpyT5hSApIIV5U0PfNOFuZ3v/tdvHS9Wh8pBAoBRdkA\n", + "RcIZiKiSxolQmACUK0rdyA0RFBNuBMEGGLTIaRiUHRGqF8opBtIL3BPDY15FRKSBsZPgz8qGlb7Y\n", + "nBgxnodBAHKGm8R3UMxwGxiP35Vn9Xq9inMKFPvw8FCB1P1Ow+GwQthzygtugCMs5oBxGBUiAjFE\n", + "z2c4OiBzbg2AcmWjlRvPyrj8f55rpQj6CYfLaT8rDjapnXjWFwSl5AXZ8TRpnVQehvGlxoOklcqj\n", + "ZTilHmXk1IdRjLLHD+sVEc8CFu4LAsU92UMYKUjZzBv/Zu4dtPR6vUSEnUrEwdjb20s5A62A81ii\n", + "unwPeUPpGVUFLSOV7NQAwYAdDL43Go3i6Ogoer1e1Gq1CveGdzGHzbxKnndycpLcj4hdihxODo5I\n", + "xM7xQxat7EEjmLPyYr1BO/kuMmjUzwEXOoriHMZ3fHwcP/zwQyVAtL5g7kGWnOrAOWu32xmYcoHU\n", + "WuczfpOzkVXz22iJcXR0FJ1OJwMzsg04bEaVSXsh86vVqtIb6/Pnz/Hw8BCXl5fRarUSOcXxs5Na\n", + "oiAgzZYBvkOvNgfQIDgEJp5TAk/k3I45xhv5cUoNZJo97gIQv6s5nqwdzzcSbfQbcGEwGFQI3rPZ\n", + "LKbTaTYX5V4RkfQP+GHtdju72r979y7pGI+PjzEajZ6BDQ5Y0VEuggENs1OP3seOOZXnFKP5ik7r\n", + "4lw70+LCHSNnZVbkpeut/cHb9Xa9XW/X2/V2vV1v1995vVr7A/LXPiOnTKW57BhSecSu8iBiV2WE\n", + "Z+roixwqHnvptRslMcGZz0AJTAwnbQWSYfiXdykrhhgvkVeZ1omIZxEE98DrJgppNpsJp4Nq4D0b\n", + "kYrYdrgdj8eVqMrnBc1mszg4OIjz8/M4Pj7O+RmNRnF7e5tpv6urqxwHJeBPT09xfHxcicoobWZO\n", + "zEkDigd9Ia3EBSLJd3keZEo4KU4ZQfY36lKmec1ZKc8+g9zrFAroz3K5jPF4nKlkv2ez2cxKHSOP\n", + "pC+BsEEakVneGfny2XfwPfgPdIG0K3C+OXbA2jwbtAR5Iu9vLhrvCnRffg+5JkJzIzyiMlCr9Xqd\n", + "c8NZeCcnJ5n2dfqAdyp5hbVaLStHN5tNBf11I8Fyv4Aqcq8yLdZoNLJQAaTTvAkjJlTY8r1Go5G6\n", + "ibQE8xaxa1wIf433odksRFmjZ666fHp6ynmjaenBwUGlOMLvZX6m0Tn0RKlTQK2tm5za43c//fRT\n", + "3N7eVhoY+2Bi0IWI3eHV3BfU2e8DQtRobFs5ONUGmowcG6k1b9IUC/ZQt9vNfW/dyl5jTfiMOaYU\n", + "v9lsZuPUyWSSxHGQY6O/7AkoI6wheh1CvOeWfUl7D37H2Lm3ic58ZpsF6o48L5e7o5WwR8goVdDo\n", + "Nmcq4KchS65II3VHwYCzAOg2yPHmItdq22bLVEN67Z+enmIwGKRtwlZFbNPF7969yxMEsCnsGeTO\n", + "FYesL3YNuos75XPGK60xnE2JiCyEGI1GqSMajUbKMPdE9imS4HP7CmU7k5euV3GknNYxHO20gSFE\n", + "Jh4yMpsuYqekKB+1AuM5CJoNNFCzKwAQejYKn1nxY8yBVc1TYCyukDLXCRjbpFnehffEULp3FmlH\n", + "jL85G+ZWmQD59PQU4/E4SdGcgYfgkEOGq4QTELGtvpvP53F+fh79fj8FkrExJ+fn53F6eprjphIP\n", + "he9UKmNibsxboNKPdJuNScSuvBiombnlfSE/WnlHRCpmO2X+CX/AFTERO/gbUqmNM4YrYpePj9ga\n", + "WXqekNLs9Xr5txhSOA3wMCIibm9vM4WEQvUY4SqYtxMRWQlnA2p+IAaFTuSsPRwtZM18AO5FqiIi\n", + "KsrUMmtyLIaVdOfNzU32rfr06VOlKhM+G3NIOshEb+Zlvd6e3k7lqGXGnEg4HIbq4UAwPubG6wxH\n", + "h3lttVpZcUl6yOnC0pnlYo0wXE4FjEajuL+/j4uLi9QbdhA5YHc4HMbd3V38/ve/zznmvexc8NNp\n", + "X1+l4+cUph2AiIhff/21shakmajEYn3h0tGhfLVapT7ivlQK2wGJiOSp8ZnPW8Owsycs41Qzsn4O\n", + "rr3PXIwQEan3cMwbjUaSzd+9e5fONfLhAMs8QvY7Y8Bg8yz3WGK/8X52os0psj7abDZJQuff5hE2\n", + "m81nnEDWyUUxpMC8F1ln0ocGF/hbFzogJzinFH69e/cuIrb74vz8PHmfOFURW71/fX2dsr2/v5+6\n", + "7eHhIb58+RKfP3+O3/72t5WWGlQ3kvqM2AUWyB56db1ep32bTqdpo2q1WuVoNVLAFHfM5/PcH4Ax\n", + "jLOsji/9Bj4jBfpSej2/+81P/g8v8pauFrLQIAAm7bnizYtvZ8ZRe8QuakOoysi7JJv6+Y7WbUB4\n", + "X75vwhoT7aM8jEiZO+LokucQJfmAWQiuEdXjSzwvEZF9TJgXzoUyKdh8H8aHMbGRQqFdXV3luxkh\n", + "wUHBkHFPIiScO3MFUGxU5pTVfigj5huFxLuxdo+Pj1kRgwNNPh9SKhdzyvoSXeMIs0a0V+Az+A/N\n", + "ZjMmk0muhY8cQLFBMkU5mC8GGZ41RkGVJG6M983NTUZJdsBQligpomsCA+8HG0nmjEDCzhKRMEEL\n", + "ShqSPPJghIggBXmwIqLvDITddrudlTu3t7dZHYRM2JB6PxiNQ1lTseX9hDOCM4Excdm1uUIO3vg+\n", + "ssG8sm4YgYuLi3j//n06oKAjROwPDw/Z4BY940OEicprtVpWJF1eXmY0HLFrDsraXV1dxcXFRc4N\n", + "a8feL7lOPq7HqCqf2/HyxTEnrJsvdK3fjYOM2+12GtcSAaXJoVFLyyRkZZotRuzadCBXnU6n0rCS\n", + "Y4WWy2UliGJPE5QSaPC8h4eHSpDI3v/06VNcXV3Fjz/+mH9vJ4PgaTKZVCpPHUwQNDDfkJRxvspC\n", + "KS72hwPvo6OjdBr29/fzPV19yl5zxsSOEtkdZB99gHMLZ4h3KHsnOTihgq7Z3DY/paLz9PQ0UZ5m\n", + "s5nBTcS2Jxm2ECAE2UHP0yeuXF/QSc4UZD9RHW1nz/J0dnZWCdC40D3YDXNRsYMEciXflmpcOGLI\n", + "BUjd/8aRehVHqtfrZfUVAoeRR6ggUEZslTT9Rdg4DAohgnBtEqArrEqCNwtvhWxSLUqI71uwXWXm\n", + "ijZHT3yf55WOG85ExI5UawKuy/95BgbIZGM2L4icET7DxlbsEZGQKIRODBIXzsavv/76DMlbLpeZ\n", + "hjAigrMUEdmjyO0tVqtd1aBJpURyGFEjUihLkLjJZJLPoFM6UW7Z/NTpY1JmXKQFSf+xvm6QiLLE\n", + "sELCxvnwe/L3pBIwLEYzkGGIklyuvnt4eIjb29scI4qBtfeJ9LRJsJxZ3phn5p8xvkRCxjljD+Hc\n", + "4FRzT5dwu5JmPp9n5Vmj0YiLi4uMIC8vLxPZfHh4SKPJO7CnqMJCLjqdTnz58iVubm4SBfHl/cS7\n", + "IgPj8Tg7R5OO4sKhx8AYWSEAGAwG8fHjx6jX62l4Op1OBitfv37NMnq+NxgMot/v53p6bgkMv379\n", + "Gk9PT/Hb3/421wXjM5/PkyjNviC1amPhtWPOynSpf/rid3/5y1/i69evSX6PqBLmkTsCBc6WI5r3\n", + "gbPIHc7GbDaL8XiccorRvbm5Sb3utbSDeHJykg7/aDRK4i/Ov59HyfzR0VEiZr5nxO4sv48fP0bE\n", + "roUHAbD1ED33aFECshWx1QsnJyd5Xp4D7H6/nwcFWzZ5D/QsQSQXusAUBC47otgGf45MzufzyskD\n", + "EVEx+OhPNwYm1erKNr7X7XZzb3BuasRW3i4vL7MIxRmMDx8+5Fhubm7i8fEx3r9/HxFbBJB7zWaz\n", + "DCQiotLDirV030Gcrtvb23S6IrbOsPUgKDj/z1yCaPJ3puo4pcvzsPvoBFePImfful7FkcLbNC/J\n", + "PTrgrhius1Iw94R7kB4gguOeEbs2ARZENpOREITf1QFGXriXK8Kc0+edHHWXXi2esPPCKHtSNVQc\n", + "ROyiOJQNqE/E7qBcKhfN2Tk+Po5ut5tOG/NtYzqdTmM6nVacFuYXJKJUUEDFdujYUMw/EZs3v6tz\n", + "+En0hQNK0zrGG7FzMuGL0MuEd0Ehong830bpnKagfQYOE8aP77m7up1T+EY0uDMCRv8bokKUjbl1\n", + "pJ7NiWCN6cCMgkSWcFxecvpIkRDRW7nxfBSt03esNUqjjLZA20i7oKhRJn4PDJtThKSMkW+qfVwp\n", + "ZCcatKHZbMZ0Ok14/+LiImazWXY+dnNUno/zBKrG5yAoyCHOIWPHmWU9uZjHz58/Z4QKKkHAAc/D\n", + "UTl8OuTf1ZU2lvf39xUuI++F03RxcZF73zSFMpXotSJ1478xEv/SdXZ2Fn/+858rUTkBKXwXc0je\n", + "v3+fmYThcBjHx8eVSlgHHvV6vVLVh7NM1oCu8BE7ngxzY4dsMBgk3469ZNSNYA39D1JNzydoIEbW\n", + "/uM//iP+9re/JQJqFAhH6eDgIA9wdpNVgiiCVqNjFxcXGWAh74wd2ggUBKPmpMOQSXQC6+dWMdgg\n", + "Ag8jfebVEliwFiUPiipAjgdyS4mrq6u0ieaj/vrrr3F5eZn7xg4KegLbhTOGTLnNA9V/rP1sNsvK\n", + "SYKSiN1egydFo9SIHXcQvW9aDgEujp3Ts656pNLTHEdQbeaQMczn8+SGfet6tdQeL1miR6AWODFc\n", + "NCpE8ThfjIOCw2Pjzabi9ybkAY1yH6MpNr5lZIeQowAdXUfsjpkw9I0D4ny/eQ/mcTkqZ554ptMp\n", + "tdquLHM+n2fkHhHxu9/9Ls7OzlLZ3d3dxWKxSMV4cnKSKUQrOq8Jl9N+KFenVu30mBtg5Q5s71Qk\n", + "yoYGccDMTtE0m9vu68zL6elpKj7Wlw1vrgibCyccQxWxc0AgkptbZIgaJ9KRtZ0OOzVE509PTxkt\n", + "YVAiIlMUoI0YgIgd6RRehOfNJcOgB3aWcbQYn5EJ7k1EbzSWZ5lLxboh1/BIUHDwFnHI4b2wTqQv\n", + "acaKHHW73XRqHfn5e+xheDYRW+T64uIifvnllxiPx9mhPWLXTBNHj+eSTnRKlvVzKh1FaeSZ8eME\n", + "jMfjXD/WolarpfL/8OFDBf2Bs8i+9BqQ3jg4OIjvvvuuYoRYb+TGTq05ayXnECQLZMpGmJ9GHfle\n", + "rVaLDx8+xHfffRd/+tOfcl+s1+uM9klPMY5+v5+BAHqMwhLmFK4L+sIBH0R25NdkbNoGNBqNisGC\n", + "F8dVNlBdr9dxdXUV4/E4ut1uXF1d5d9++vSpksr/7//+74jYpqHa7XY6TJ5XN1TudrvRbrcrfZSQ\n", + "U5xijK6dwdlsVkH+4Sbyvm4Zgt5uNBo5d+xD7JMLNRzoghzbufIeNg/R6S36ZsGpfXx8TJtxd3eX\n", + "AUir1UqHGlm6uLhIp84ZjM1mk73a3r17lzy0iIirq6tETWu1WnKbkKkPHz6kvqGfGrJIsQPAirvT\n", + "w88iu8VagIb2er3UucwLndVxgh14LJfL1LHT6TQ2m02ll1/JTy2vt/YHb9fb9Xa9XW/X2/V2vV1/\n", + "5/VqVXv9fv8ZikAUQ8qh5OxERPKjiLJo3mkkxCiBkShHZvw/qIJTGE5dAJmaiM47A3OaswT5GmjU\n", + "sKKhSRNn+W6ZiuAivQWPjPE9PDxEr9eLwWAQs9ms0pQPGJr0C+gNUQrdyyFmkl5hfUjBEXkxX6CJ\n", + "vIcjOqBpyNucvxWxRU+ISIG/mQ84KXt7e9nh3pAr9wbeJzL59ddfk/sEWmLSN9wJkEevuSMyCP4R\n", + "WySj3W5nBF6v17NBJJC40w1EQrwTCBc8EsYBYkWq1VVdoJ6gjfBPIrYVlHAZIHkyb05xR+w4UxE7\n", + "zhPRoFMBEbt0KpEu72IEjlQLc+Mzp0B/TbilupKUmDkIFD+4fQZjIAWM7MJNAP3sdrt5aC3R83w+\n", + "TzlbrVYxHo/j69ev8eXLl4iIbMLpZo+G9tm3oGtGkyO2lUgcqsp+A9kGGQWZYQ1Bl7g33yNVwnuU\n", + "CCgoFrxEX6y7OYq+zDcyqlYWiXA5ffTp06f4z//8z/j69WtEbLtQU5FFusa6lEIH5PPk5CSfyfhd\n", + "Ecp8s+YgLFSbITfozX6/n5WvjAPSb71ez/eMqHY2J51DupRnn56eRr/fj9FolCm63/zmN3lP9Dry\n", + "FrFNRXGI88nJSaKxyB060aijK/u8xyMikRGqip0VsN0A6XXRCLaNLt9lk16eYbsVsTuuistI12g0\n", + "SltxfHxcscHwzricMmOcvJf5kegEF22QDm+328kZfHh4yGdHRLbccUW4Dzv+y1/+Eo+Pj/Hu3bsK\n", + "pxQ+LHrbPDeeR8aHTA4XSDq2hjHQtoH9ad4pTV+/lV6PeCVHCoIwXKKIHcHaUDSTymIDZXpiSF2g\n", + "IJz6QqHhSNmZgluBUTRUyb9R5O4zQ2oRCNgOj50gv1fEjgQXseNQmcM1HA7j9vY2jo6O4uzsrMIF\n", + "gW+B02LljXJ+9+5dDAaDLDnnMFIcxF6vVykzpSU+aUYrPgyQjygoOzDbGSyrGZrNZh4wbOPNvLqU\n", + "mDXkflSN2JFy6sVVJ9fX16nQmRN3jPYGY+28TuamADePx+NUDDiNjI9UAwaYiilklZw+z3AKezKZ\n", + "xGQyiffv3+ehruaXMHbS2nx2cHAQJycnCW2zlsiwKzLPzs4yJYqRwIA7XYwjAXfKF9/ZbDaZjsAI\n", + "8Ty3DWCPNhqNVHDIuVMGw+Ew96DT2jb+vCvfpwUBzvloNKpUxV1fX2e65/LyMn744YeUDVIbTj07\n", + "nWR+n7ll5h26fxjPpOoKjh1zM51On6XeGCOyzTjtNBLsNBqNbDOCc84zPAYrc5ws7lOm8JiH8t+M\n", + "t9lsxsnJSVZmXVxcRLvdjtvb27i9va0Y2f39/ZjNZsmFwfFjXKTfn56eKkUVvCdkdSgRDkx9TFOp\n", + "L1xp/C//8i8Vh+bo6Cg+fvwY4/E4uWLIHSn/6+vr+K//+q98HgUDi8UieaSlc0p/osVikfrUtgqe\n", + "JrIPb5WO3m7Pg2Pp9J5TsI1Go1K0ZMcV3cT9kQvmCeerPOYJ2UN/m1B+fHwc5+fnqVOto8zDxB6a\n", + "7oKsQlnwHnIHfMtNr9fLoB7Agz36888/Vzh64/E43+XLly9ZWdlut+PDhw/JdQOU4ExDgi3mhrQ0\n", + "h7M7ONpsNnlW4V//+teU/cFgkNV+OPTsLfMUqagtr1dxpMjvll4tXAKicxaDc6vgdNhbRGiILB3R\n", + "Ifw8y0LsEmYiDCMroAYvlT26Ms4KjHfDWDi/D1JhQ/GSMn16eqqcgk0+nzy0S5U5uBKSMgowIioV\n", + "SzhiJo1jmMy9MdHO5FAUE99jva6urrKiISIy0gS5MRF/MpmkU8icMd84RxDcjZwxTzQ75NkRu8rC\n", + "+/v7bNpnQ4sCKvlaJlkjP3wPQvPt7W3c3d1lg8GIyL4lJiszBhwX/m3kBJn6/PlzNn0zQsSYuU9E\n", + "VGQEZTkej/MMsIgtx6DValVIoW5iCzLGs8z3idg1nywDGivR5XKZUfnd3V1cX1+nvG42m6zOGY/H\n", + "iW5yXxdTLBaL+Otf/5rvyBgIjnDQzGlAXnD44Yt5fYfDYfzyyy9Z/l46y+7NZXlCJpALO5n7+/vR\n", + "6/Vivd6Wj1uhPj09VQoL2A8gIxgiE1kJPlyk4mIZgod+v18x3qvVtscUjkvJkzLS5gAUgjLyXiId\n", + "zHOj0Yjf//73cX19HRFb9BMngfdkPs3fw7Fzs1f+DWJhfXN7e5tFA3zuRoinp6fR7Xbj6Wnb+45x\n", + "wFEimIIvE7Fz3AheTEbGOR4Oh3F9fR2r1So+f/6c+4tiBypljQ7u7+/HH/7wh6jX68mVYX0jdsU/\n", + "oOARO87O3t5eHrXFPiQQsWNqp9aBi4P59Xqdfcl6vV5mFXgXZBi75vWnsMOOmREbkPQShUXGCRQN\n", + "WHDQNnbawQH6nMpTAsKIXQaDNg+Q1nkW3+cIM/Rwp9OJ7777Lm2BA2KyGlSOl4EQsjUajWK5XOY+\n", + "RPYbjUbc3t5WirOwQWQyptNpIpVfvnxJbuO//uu/xkvXqzhSGGorN2A1elmQzop4XhHiRfa/rTAi\n", + "qtEYRp1n4kRZsTh9BcRpUjn/Ngpl5wylhqE1ub1EVFarVTognU4nzs7O4unpKS4vL2M2m1VSMwg6\n", + "iBJCOhgMYrVaZentcDjMzQYi5qpDN8KL2HWqxng41eQ5Yw2Yb0iSpCzc0I4Ig/n0mWRuzIeBiNgR\n", + "JSFrU5USsUuXsoGdLgWaRolMJpOMMChHxyh44xNV2yEBirYThcPgA0kpjUZZo6hWq1Wl4Ruywbz1\n", + "er04ODjIChDkLGKrpLrdbnbh9Zwyf/f393F6ehrj8TgV0XA4jF6vF/1+P8meyAo/SX3a6WONTMJE\n", + "gbl1B8gYYyQQuLm5STQLgu9kMomjo6NMp9jQNBqNdISbzWZGft5POJcuCliv19nAD3njXZ6enuLq\n", + "6ip+/fXXNL6Qmnnm/v5+7sMyILLzaDSW7xE5+zMj2qPRKNFDLirPQFGcJiEQwhHBwUa2QQBBKCIi\n", + "x2wEzeR+UMCbm5tKew/3PeNykQ0FHfRp+vd///eIiPjzn/8c9/f38f79+6xAdGrdzjl72A1+F4tF\n", + "XFxcxN7eXlxdXVXSJpwIQWDrVjMYRQJXO0uQ6NHRrD+2gvHa8NnB/OMf/5jBW8SuSo6siPfFbDaL\n", + "er0ep6enqedcsdrpdOL6+jr76xmNbbVacXt7G4+PjzEYDDL4QHbH43FsNtsGnD6hgzYZ0FV43nA4\n", + "zDUsq2fZowTAzWYzyfPIGvOIw++ihVqtlojLarXKeSNd2Ov1YrPZVA6md7NN1sL91QhiIXsbBQLp\n", + "wvHD7rFP6MdmSgt945A1n6WIXf348WMS/HmXZrOZ6b6IXU/EiJ3TTqFVt9vNsYOaEVw53U/BgB3O\n", + "8noVR2o0GuVklGkTHBcizojIKoKyd0TEzilztRUbzCgEShBhxOiAjjl9BDLmlKCdOlAl7m+kh0ox\n", + "IjpHCfA6rMS5Hh8f4/r6OkajUQwGg/jw4UOOgQZ2bH6X82L0cTKZT3coJvdMaoL7YvAwinxGrvzw\n", + "8LAyT8w74yKv7Bw9qZiS74JTgbFjk3udWHfn//f392M0GqUid0oQ5OvhYXuwMohAxFb4z8/P8+gN\n", + "K2FgZqMXLlf2cUSkynhexBaVc1TI83C6eE/Sg4yfZqblkSVUQ/EujgQZEzC+2wpQsQTChpFkjPRK\n", + "YZ95/DjROOpOKcBls6xHbB2u9+/fZ7PW4XCYn83n80z9oNjMa6CSjxSIy9hJT/L/Tr+jwIbDYeVI\n", + "Kar8kBVX/vBdl6lTNcsaI+dl+tcVbziOlmF+T/NAo6TsQ9AVyxQO6GKxyCNKeA6OPfwbBxFHR0eJ\n", + "hP5/7Z3bT2PZ0cWXaWMa2/h+AWygQd1z0+RlpEjzNA9R/uZIUf6GSEmUzGS6e7qbuzE2Ngcb8AU7\n", + "D9avXMc9Tzx8LX3aS4pmJmBz9j5776pataq2NyaDwcA0Qt1uV/1+386Fp6cn5fN5NRoNc+wZsy+D\n", + "Zw/SY4keTugJaTnB2IfDoTG0s9lM5XLZfu6ZQh9YsjdoLMzvw7qhWUGz49cw84PzcXt7a/uRWwzG\n", + "40WDXpxHSbEeQVw+jWNCdSB7yTughUIhlkb1aT/YmGRy0SMtiiIbM+mgYrFoQS3znEqlTCPFmcLY\n", + "fcUx5yOfQz8E00c7EtYte4Bn8sFnIrFoAAsryhnP+/dOIMwkc9Pr9azSHUJDWuojsSFeO8j7A163\n", + "R2YJFsy/X9bEdDqN2SLWMA4NAZQ/izc2Nqwz+tPTU+yKGGwCJAu6Sc4yxlWpVGLNrjc2NhRFkW5u\n", + "bixwl6S9vb3PslKr+GKOFHlOf8UGBoiXhiMlLfqerN7qLcU95dXGljhZXpzOP3E8+JxPbXEg0pTO\n", + "pwYw+Gh9VoWqvHwOFBYbEdNkMjFD7e+J6vf7ur+/j/V/YnywB3jXUPGMhwjf66d4HqJrFqSfN3/I\n", + "ekeKUmUcH1/q64Wk5N854DFoLHif10+n06pUKhaBemeL78EZ8NojhMsYPH8Y4wASBUlLkSMCxX6/\n", + "H2OUeC6cDy/gZHz5fN7WWSaTMUMaRZEd3slkUvl83lgHjAA9oXzKyn8WJxvjKS30bL4Tt3fcYXJo\n", + "DUG5tLQwfHd3d7q4uLCDnO9kbBy2vmCAKBedQavVsvFXKhVlMpmYTocIkkN/Op2qXC5bBM+eoS8Z\n", + "zgfr4P7+3kTorH3ffyuKIpt33/bk9vbWUl69Xu+znmf05vHOFfOdSqW0u7urXC5ne9TvYd4Nh60v\n", + "RAB8xjsJXkbgtV44egcHB3Z3IoYtiiIlEglz6DudTswpIogcjUax9D3P9vj4GOsIzb749OmTOfTd\n", + "btfE2AQ5iURCh4eHtsZY+1yjkU6nY+lQuq/joNLzin2B0ebM8OkmdGX8fXpAScs+aQQ8RPjSIm3y\n", + "4sULFYtFY128EwLTSfoHNpbg4Pb21hjVarVq84Yjvds4flYAABpXSURBVCojuLy8VKVSMQbEBwqM\n", + "zeuEGD8sm9fq8jlK6nkXJycn+vjxo+3RSqUSS2Ph1LF/vH3yDBD7jRYFPoD2bDfnLnaBdw0DuLa2\n", + "FkuZkW2AdfdOCM4cbCw6QXp/ITHAxjGm9fV1W+f5fN6ehQantLhJJBK2Lkhdsjc8G4m8Zjpd3DTg\n", + "2ejxeKybmxtdX19bcMI53Gw2VS6XrR/dN998Y/vm9PRUNzc36na7xjwyPjRssMypVCqWpfAp/t9D\n", + "aH8QEBAQEBAQEPBMfBFGisgSz15apoyIeL2omiiBiNAzPXzOs0M+XUgEwb8TmZDaQH/gWS5y2TTm\n", + "8+JQIlHYJ88e8D1EKz5iI/r1FKFPtSDApE2+pzHxzCmt9VE3bA7RrNcekGZBFLqaZ26323YPmk8p\n", + "Ua7qU5Bem4KQ1bM4kqxBny8/ZbykJom+faqCVImvuOK7vfgZ9o3IgL9HOs6zVfP5XFEUxS7s9XMP\n", + "lcuaIKLhxnjP4nhNQyKRUKlUMrbOp6g8k0ZkzdqA7vaVekTXzGsURapUKrHOz2gWSKnQDkFaUOOU\n", + "aHe7XQ0GA0v7oVMj/env/4JV444wIjRpQWP7zxBtsmdYZ8Vi0VJCfr6ZcxgWaZkW4bn81Tlra2vW\n", + "yRwdG2uYVDjVUIVCIaZr8lE7TLAvXoGlbTQaFmWz3tifpCt888LVFCP7Ah2FL/HnPdF4sNVq2dzC\n", + "km5ubhrbBotyfn4uaVmZxtodDodWfp/JZFQsFjUYDCwdwfhgXa6urmxvsZ9I+VarVV1dXcWqDz2r\n", + "SVqeNcn4SI3V63U7hyaTiQqFgqV90MOwvmHuYWN99TSpTtJw6KukpS04PT3V5eWlVU9Jy6tAjo+P\n", + "bd/5DtbpdFrffvutcrmc7u7uLIVDSh0dW6PRsGqr6XSqVqulXq+n3d1da8DIGGBIYBR9yj2dTqvT\n", + "6RhzzPh6vZ5ub2+VTqfNDrG3T05OYvqaRqNhFyhvbGzEpABek3RxcaHxeKxisWjsmdfs+AKp8Xhs\n", + "ejJpUX3Z7/f19u1bTadT1Wo1NRoNSUu92uPjo7GDvvCB4hWfqeBzSAzQXPobQPh39LPsb9KjsLGk\n", + "8JjTfD6vp6cnE3/zOa5SWltbU7/fj2lqT09PrZ0KFYOcw71ez4oLuIMVZml7e1vv3r0zFnK1dQxn\n", + "P4wqa41Kep8hW0XC56P/r/CHP/xh7juKS/HOvb6qQVrePF0qleyaAg5pShlJAUBPSktdFNVgXliI\n", + "ocO5QTAnKdbrhJQXC4VUIY6d19r4sUAN+2oPxoTjxBxQiVUoFFQoFGJ6Hi9EXK2k8BUHOAYYCyp3\n", + "vHaMPjg8D/obRKS+vHY+X5TPYpg5UL2zhR7M38pN1RYb1lfYcXijWfFCVRYwug1f0dfpdKwvjK+M\n", + "89oSxsq88Tv0+2Fc/AwHGI0RhxsVHVT7+ENwfX1dg8HAel15fRhOFWlRUr9Q6rxn5hCaXJJpPxD6\n", + "stalxdUc3nm+u7uLafJwmK+urnR+fm4GAz0S2qDVi1RxJEajkY6Pj23d7O3tqV6vm0aCdA7PjbOO\n", + "QN47SzjfpDh8FRWaqcFgELsf7MWLF7aGWKf+3V9cXCiKIkvdMAacUu/o+3TLcDjU1dWVXr58qaOj\n", + "o5hg26exMZZ+TpELSPFu2uPx8hoJAhMOV+4lo/LHH9TVatXaXuBA4GSVSiWrTuNqDap2EeJj3Lmv\n", + "kDn1lc/VatXu70NTRnBRrVZjmlKq1Xgf3rn3GstEImHPyTlJawPmwwcuqwVEjB8ZA2lFr6nhwu52\n", + "u22OEHuxVqspkUiYpsj37aLgYWtrS+VyWY1Gw/7e4+Ojzs7O9P79e1UqFX399ddmvElNzedzC1p5\n", + "11EU6e7uzopkstls7Cqf4XCof/zjH2q1WlZJzbyVy2VLaW9ubprGdTgc2rUrs9nMzkVpmYJFD+xT\n", + "R/72hVwuFxObJ5NJczbb7bY2NjaUTqdj/dem06lVVfOM0kLE7SvLCYwl2XdSiOXtF1WO8/ncbNT7\n", + "9+/tc999951+/vlnnZ+f69WrVyYHmEwmVrFYrVZjmkNsGmelT7NeXV2ZNhDNH2NAZ8zZtrW1ZWlP\n", + "bFK9XtfNzY1++eUX2/dc+5RMJk1Ty3qChFkV1EsLG/LixQu122396U9/+vwCS30hRmptbc0Wva/4\n", + "Wl9fj/Ur8oyHL/30bAaHBRvcfweOEwI0aekI0HuD7/Flk2xuX0Hm8/ZeaLyqn2KBIub0wlm0PkQX\n", + "fCdOXDqdNgbJN5dDI5FMJnV3d2cGmJyyv27Fl3Hzt7i80Y+D/49oCPEq33tzc6Pb21tzGLy+SFoc\n", + "avl83iJDPnd8fKwoisxArGpO+BuUOktLUS0OnXeqiXIxGNLygKbBo2986ZvjTaeLcuZUKmVVSowB\n", + "bRxrw98Ej1OLRsUzefx//X5f8/nyMlA0DGhyJpOJNfXk/Xujg26En2HEiIo51HC40On4y3ARB6dS\n", + "KTUajZgmDQ0U7CG6BklWyQhz5LUwtVrN5gxhOIfpcDhUNptVFEX6+PGjXr58GdOlsI8ox/fsEUYf\n", + "FpDnxCHDEfHaCwpMBoOBGVPYK94xjrkXpjJvu7u71vx1Z2fHnBgcvnw+/5kDRrk9/02jWNYG0Tdl\n", + "8J5Rf3p60qtXr5RKpXR1dRWr6GT+0ZH4829nZ8cYG9hHSeawZTIZbW1txYpzuMQ5n8/bO2Psm5ub\n", + "+uMf/2hOt69ikpZnA/uR8U0mE9NEnp2dmZPC2KlalWSVxexJzksKMWhPwDhms5lVl/p1ivaRJrj+\n", + "XEAjx88RiEuyd3t+fq7T01P9+uuvtk8JKJvNpumT/HnCBbgEYN5phhm+vLy0fSVJ+/v7kmRViVzS\n", + "zXeyBrPZrAqFgmq1mj1Lo9GwSt9+vx/TjsFKYavY59ij+Xyu6+vrGFtDtfZgMFCn0zG2knfDfqvV\n", + "auakMEaCx2KxqFwuF6sQz2Qyarfbury8tHXGvPG7vrCJYI++VNgwX0jVbrf1888/K5FIaH9/X6lU\n", + "KuacszZWK1ZhqllfPhNBQOIzUfysXq+r2+3qw4cP5tijGbu/v9fXX39tLVXIPDHfZJl8wCgt+l35\n", + "c/f38EUcKV6sd5a8ANRHCR7Q8CxWaekskbrxgjWMCYccDSH5GVVLMFK8RDxvnomDQVpS6kRglO1K\n", + "MuMLwzSbzWKfI6UAo8VhQrNMIkSfaqI6hMh0MpnYRsRRQ8BNVAuurq40GAxULpftQPKVPbAgPL+f\n", + "c++g0UZAWkZK9OfxY+RAvr6+Nq8e8JzMi4/6+S5SDr6ij8ibCAm2h7mRllU6ns0gDeK7gnu2CoaG\n", + "6MynYPl9L+Zk3aZSKe3s7KhQKNidVdLSIYBBHA6Hlu6QluJvbj/P5/O2hjlcMHoIM/2cEmV6VgmB\n", + "Pv+sVCqWFoJRXF9f/6xhIVE3hg/hvCS7ccALSZlv3gtj9OwDQk0ON290cRx8xZhvnOqDFtLYkqwn\n", + "Tb1eV7lc1vHxsfWiqtfrxprgTOHA8s5SqZQxdDQ2lRbCcIKZ1QDOV1nCkHpDy7/Dhnr2m4o9qjc9\n", + "fOd932NqlWH1UTKXa1NE441JsVg0doGzjLU4GAz04cMHOxP93/BVU2trazGGiRYG9GvyDBWGnBYO\n", + "7C//7Gtra1ZtNhqNzEg9PDxY6s2LwKWFker1etrZ2dHu7m5M1sHav7i4ULvd1uHhYayaud/vx6oM\n", + "WVPMCeyXvzOR85ssw/v37038vbW1pUajYa0OfLuYx8dH5XI57e3t2VlzcHAgadE24uLiQgcHB/Zc\n", + "f/3rX+3db25uqlqtqlwuq1ar2edgx7BhVIIy9qenJ/373/9Wt9vVV199Zc7Z4+OjOVc4jY+Pj3rz\n", + "5k1sbp6ennR5eRlLpZKi7Xa76nQ6+uqrr+w5j4+PLcCjnx7I5XJKp9M6Pz+3NeADpVarZa0/fIFP\n", + "p9MxZom0N2xVpVIxSQupQtjITCajfr9ve2U8HltWhH2Gffad67e2tpTNZu08ffPmjZ0BOLG8y3w+\n", + "b5/DtsDCUpAgLc6LQqHwWR8+jy/iSElLw7BaTUeE6L0/r0WRZAyUpFhUwMHBYYdhJQLCuPjPScvI\n", + "1lfu+FSA/11K2HnOVCplC2NjY0O9Xk9RFJlh8uwBDgRXl3iWLZVKxQ5aTzn6hURuXIrrQGARfOqO\n", + "AwWD4Z0byvFvbm60v79vz8ff9NV62Ww21tuH3+PfMV48697enu7v79XtdmPMCvOcyWRMTyDFW/6T\n", + "5vOUMiwfhhNnAmPqy/R9+wMOKFJ0bAR6LvE8/A3WAhEO0aq/uBSnpVAoxFI7OBZoJXDQvd5HkqXD\n", + "RqORbWK0X8wpjirrTZKxlb4ykxQpTCjODHOKgUGz45me8Xis09NTiyz5WbfbVaVSsaaD3qmCydjc\n", + "3NSrV69ipeI4it4I+opc5pFUnq9mJXIkKmW+ifRpnVAul+1S4tFopHq9bqkftFnMDbokjGkymYyl\n", + "p5PJZKwa1AcgrEVYUNY3jiLVXL7FA3uPYI10DOPHMPr+PqwpHEbmh/3ty+ZJA/n9S4n34+OjisWi\n", + "ORn9fl9nZ2exNKgPaljz3lGSZC1SZrOZKpWK5vO5rW+MDAEk/+N7PfOKDsr/rFgs2lUng8HAzsft\n", + "7W2bS3SrrCmY0mw2qw8fPkiSVYNxsflsNrMGioyfliewO9PpVH//+99tHD/88ENMK8Waurq6UrFY\n", + "VLFY1DfffGPMBXNKehVHAaaD88obaJha9FS3t7eW5oLl2t3dNe3PbLbo1M/az+fzxhaxdxnP/f29\n", + "vQ+qoX/99Vf961//kiS9efNGe3t7lm73QeRgMLCbMzqdjtrtdkw2AAt8e3uru7s7c8B++eUXTSaL\n", + "ZrTdbteaFUvLimQyF94BOzw81Pb2tq6vr+1KMt/nrNlsmmNN5oWfkeYmJbxaOV6v11UqlfTbb79Z\n", + "Wvjdu3c6OjpSOp3WxcWFOp2OzTeMKHKN1bYzrP9EYtGTkO9EcuOD2FV8EY3Umzdv7I96r9azVJ4d\n", + "yWazajabajabdhXKKiNFPtl/bnNzM0bT+V4eHGb09PG0OX8TI8LhIC2vOaGkFO9dikcY5IN9SwGM\n", + "KekkL+QkDUa6yIvicQRJOWH0cbwwpOSbpeXhiWCYnileIEg39GKxqHK5bAc/hobfY76AT9PA4PA5\n", + "5nI2m8Uas2HwPdPCd2PQ6NQNCyjJ8tnj8ViVSiUmusTB4iDzuhxvCH27BsbkmcHZbBZrrocjiYbA\n", + "dzDmbzDnvj8LzifsTyaTsUODd8PcIZDnXfnrUNDZSDJDAgNA2llaOrw4qYPBwETMk8lEzWbTnHDK\n", + "haVFzn82m+nk5ESFQkHFYtHGkU6ndXR0ZEGIF2JDfTMOr4GDcUokEsZUcngzxxyI6+vrsdvacZIz\n", + "mUyssaJPAxLt8g4vLy+Vz+dVKpVMlI5j7PcbLC3sjbRwGCjEYJ/jMGD4WNe+mSNGiBQsncj9+ycl\n", + "6tPtOMY+bcm6YO1ykPvmqDC1fD6bzZp+6vr6WtVq1fYbjLUkffz4Uf1+X5VKxXRABJ6sJVh6f/6j\n", + "b/RzBDCQPgDxzhntOXq9nvWfYm2Q1vPCZu8s8844N3CW7u/vTRf38PCgdrtt5xeSBa+VI/2Gg8V7\n", + "297etu+czWb67rvvNBgM9N///tfmhGeCASSI5NnQ5uKcE4Qyhul0qlwup3q9rul0ao2BOUvp7l6p\n", + "VIxZgsWhaMQLuHk3tIB4//69sc3FYlHNZtMC0kKhoMfHx1ivLNjLFy9eGLsmLdiV+Xxua+ef//yn\n", + "rUlauLBPYCiZ70KhoGQyqX6/b20kpMX9hTBLPvCQZFf4UDCw2sKhWq3GdHO+8IFiGPYSNmhjY8Ma\n", + "vh4dHalWq9m8+X1Fip3zq1Ao6P7+XgcHB0qlUjo9Pf3MzpF9effunc13rVYzfe6PP/74u/m90P4g\n", + "ICAgICAgIOCZ+GKpPR/1A9gGSpuJaGi5f3h4aBGBb8znNRt48ZKMHYCN8lQeeWUvOvNVe6RQoBzx\n", + "2onI0WNR0isty/FzuVysek5adv1GaEyULS3ywVDl5H6JoHzFIZczetbJ642iKIoxPgjCqTxCayUt\n", + "rzuRljQqgl4odbQOiBn5XaI92ir4KMIzUC9fvoyJJ2FbEEaSvoI59NoRvyYon+U9ep0KrRRWq0Bh\n", + "fohMYG2kZSsGnseLi3lHjMVXdMG2sG589QxMBu+e7t6rVY+k9Gq1mr0rWC60G76qqdFoxNpf+Co6\n", + "UlCsL0+pUyk1Go2UzWZjFW++ioW55DlhsHhnPsXu0zXMtW86+fT0ZCJjr+fyjANj5Ge+mSzr2N/R\n", + "xz9hBoloi8WihsOhMUFeD8TckJaGWeTZ0UCORiO7fJWIljWQSCRUqVS0vb1tUXm32zX2qFarxdIU\n", + "rEvSML6CbW1tzS7D9oyetGAc2dPZbNZ0UcwvImXSf+g20JewFhEC8956vZ4mk4mq1aqlzhib36/s\n", + "E9Youin+vmfj8vn8ZzIBXyVJVV+pVDJmivfOheykvP0NE7DniURCJycnxpx+//33ur+/V6vVMlaN\n", + "ux0zmYwxmA8PD1ZJJi3L4/f39+09UdGYSqXUarUURZEymYwqlUosnba+vq5Wq2XXbXnRNZeHYzNW\n", + "dZwHBweaTqemS5IWtms8HhvjynnIvMCc3tzcqFQqxdJl7AW0WrQbqdVqenx81MXFhYnVacgrLbRO\n", + "19fXlmbE1krLNgYwvWRBpOXdjsxrJpOJMTU02iSteHZ2JmlRFLC3t6fvv//e9pIvwkBPxt737Ws6\n", + "nY7K5bKKxaJubm7MBlEhy92kPo3smdS3b9/GtIpktWazmYrFog4PD40dbLfbKpVKdu+fP4Npm0Cb\n", + "lL29PdtrnU4n1ij29/BFHCn0PF4czMv1OUsqRprNpnZ3d1WtVm2heR0Uh+Jq7x5+zu9jlKVlB2MO\n", + "AwyOtDhsqPJCk4Oh9v13cHa8PgD4tAv/jfKfNKJPM/qOsqSpJFnPHp+DZuzoiXheUiSMi3nx6VNA\n", + "moV0kn8en9pjzrxjiFPKeHylpbSk6P1GJP+NaI+KM0km2vYlyjwrjiTl8b7s2Au5MZReNM6cYcAw\n", + "3qQg0bj5d0cVG04oTiZrBiMZRZFGo1HMsHuRsNeU8IwYGsbAoVGpVLS/v6/xeGwpKl9FRtsI//x8\n", + "J3uI9UOKCoeX52Wt8E7b7bZevnypV69exQwiDgn7yd8diGH1zhxGyAv4STXxOa/V8gJ/aXkZKul8\n", + "r9sh2MBh8p/jviz0UxRvMP7NzU29fv3aCjF8FSHp+XQ6reFwqPl8bmuYzusIWqVlpWCz2bR0DC0r\n", + "/NrAseVZ/ZnB2m00GrHziTmjapYUGWufefC6KRBFUawTOs56oVDQTz/9ZOl8f0m0tLy5IZvNmjMl\n", + "LYwsvXS8/k1apso5f+hkzrPidBDclEolGz9BK+ezD5IfHh40HA5N3Hx9fW3iYAqESH1vb2/bM83n\n", + "c/X7fX369En/+c9/lMlk9Oc//1mS9O233+pvf/ubvdurqyt7lv39fRO8U8HH/F1fX6vX61ngQQWY\n", + "tDijRqORbm5uLDDlO0ulkg4ODpTL5ayS0t8GMJlMtL+/bxd38zPGiXgcHZYk7ezsmGHf2dlRs9mM\n", + "Vd1GUWTONSloNGKlUklRFOnt27f68OGDisWiOaC0wuh2u/rLX/6iy8vLWNsM0Ov1VCqVLA25vr6u\n", + "Xq9nleOz2Ux7e3uSZPo8HHgf4GF/0Ce/fv1ax8fHkqTffvtN+/v7pv3LZDIW0JBibbVadmOCdzLv\n", + "7u6so/unT5/sZ1QSl8tl9fv92B6tVCrWfoKqeR+UTyYTs0tessJND6tBvscXcaQwAD6CRI+Bx5/P\n", + "5+0FHx0dqVQqWdWbP/gwOl547V+i1wBgcKRlybkXY3v2yH+nd14kmcYDLYuvvmLRUEHkI3iqmWA6\n", + "vBeNsUBfgdHMZrNmFEejkW1saeFhJxIJE/H5y2Dp6USeH20KefT19XVjD+7u7jQcDs1xLRQKiqLI\n", + "hMVedOpF1Gg3mBsqZdDVJJNJE/pxsSq9YbiZW5IZNd+rZJV1KxaLarVaJnjk/cIgrYp42WgwEl4D\n", + "x5hon4DWSlocamhn6FPCoe/XmL8+iDFgfDDCvE/mBp1QOp02po/P9no90xkkk0ljOemngnbL9y3z\n", + "wmzGxvNQHcPfZQ74e+gO9/f3zdBJS90Za9M7WRSH4LzxvKxhHL7VfegLQFj/vsEtBpZ97VkO1jzP\n", + "7PuxPT0t7q/b2tqKNQCVZD2ZqIJj7nlWxjAajWJCUuZ3OBzq+Pg4psekMo3rb3BUWIu0i1htYYEm\n", + "slarWSNLH3TBcMFqegaPv1Mul62VA2ux3W7b3+eqDJ6F99bv91WtVmPsJ3osKX4mSkstkGd7JVnA\n", + "gGPD//gs+2w0GlkLBOaUwJnz2/dE4qwrlUqaz+dqNpuxYJerbjxjydpgDb5+/VrpdNrE3/P53Kq1\n", + "YLN5/lwup9FopNPTU9uLvmGptHBwGo2G5vO5vfv5fG6OPWcgWj5fsIF2lv2Lxomg0velQ7TuGW/W\n", + "fq1Ws7ONd4GTcXJyonq9bvde4qQwN9wZyN+cTqfmvO3s7GgwGKjdbhvb46uSh8Oh6Sa73a6tE/RT\n", + "0rKdBU7W0dGRstms2RyaB/OdvEscSeaNZsJeowiZgQOcTCb1ww8/6OzszMb/8PBgVc8EugQY+Xze\n", + "An2cTMbHuQNp4jWeBPIEXv4sqVarsV57v4cvIjYPCAgICAgICPj/gCA2DwgICAgICAh4JoIjFRAQ\n", + "EBAQEBDwTARHKiAgICAgICDgmQiOVEBAQEBAQEDAMxEcqYCAgICAgICAZyI4UgEBAQEBAQEBz0Rw\n", + "pAICAgICAgICnongSAUEBAQEBAQEPBPBkQoICAgICAgIeCaCIxUQEBAQEBAQ8EwERyogICAgICAg\n", + "4JkIjlRAQEBAQEBAwDMRHKmAgICAgICAgGciOFIBAQEBAQEBAc9EcKQCAgICAgICAp6J4EgFBAQE\n", + "BAQEBDwTwZEKCAgICAgICHgmgiMVEBAQEBAQEPBMBEcqICAgICAgIOCZCI5UQEBAQEBAQMAz8T90\n", + "n59+FodZjgAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "source": [ - "## Casting a Classifier into a Fully Convolutional Network\n", - "\n", - "Let's take the standard Caffe Reference ImageNet model \"CaffeNet\" and transform it into a fully convolutional net for efficient, dense inference on large inputs. This model generates a classification map that covers a given input size instead of a single classification. In particular a 8 $\\times$ 8 classification map on a 451 $\\times$ 451 input gives 64x the output in only 3x the time. The computation exploits a natural efficiency of convolutional network (convnet) structure by amortizing the computation of overlapping receptive fields.\n", - "\n", - "To do so we translate the `InnerProduct` matrix multiplication layers of CaffeNet into `Convolutional` layers. This is the only change: the other layer types are agnostic to spatial size. Convolution is translation-invariant, activations are elementwise operations, and so on. The `fc6` inner product when carried out as convolution by `fc6-conv` turns into a 6 \\times 6 filter with stride 1 on `pool5`. Back in image space this gives a classification for each 227 $\\times$ 227 box with stride 32 in pixels. Remember the equation for output map / receptive field size, output = (input - kernel_size) / stride + 1, and work out the indexing details for a clear understanding." - ] - }, + "output_type": "display_data" + } + ], + "source": [ + "# Load the net, list its data and params, and filter an example image.\n", + "caffe.set_mode_cpu()\n", + "net = caffe.Net('net_surgery/conv.prototxt', caffe.TEST)\n", + "print(\"blobs {}\\nparams {}\".format(net.blobs.keys(), net.params.keys()))\n", + "\n", + "# load image and prepare as a single input batch for Caffe\n", + "im = np.array(Image.open('images/cat_gray.jpg'))\n", + "plt.title(\"original image\")\n", + "plt.imshow(im)\n", + "plt.axis('off')\n", + "\n", + "im_input = im[np.newaxis, np.newaxis, :, :]\n", + "net.blobs['data'].reshape(*im_input.shape)\n", + "net.blobs['data'].data[...] = im_input" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The convolution weights are initialized from Gaussian noise while the biases are initialized to zero. These random filters give output somewhat like edge detections." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "!diff imagenet/bvlc_caffenet_full_conv.prototxt ../models/bvlc_reference_caffenet/deploy.prototxt" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAicAAACbCAYAAAC5xzv6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvVuMbVl2pvWvfb/FjkueW568VN5dXSUbl4sHbBBYbYRK\n", + "jRqEJW7qfkD90MItN4gGgQC3QHYJiwdejJFfcNvgRtBuaBAPyA9gt5FBcrnc1bbLVemqPFmZlZdz\n", + "TuaJc+KybxH7sniI8839rxFrx4lMU7mjKveQQhGx97rMNeeYY/zjH2POleV5ro1sZCMb2chGNrKR\n", + "qyKVdTdgIxvZyEY2spGNbMRlA042spGNbGQjG9nIlZINONnIRjaykY1sZCNXSjbgZCMb2chGNrKR\n", + "jVwp2YCTjWxkIxvZyEY2cqVkA042spGNbGQjG9nIlZJPDTjJsuyHsiz7x1mWHWVZ9jezLPuVLMt+\n", + "7vF3P5ll2TvrbuNGNvJxZKPbG/lBlY1uf3rlUwNOJP2Hkv6vPM/7eZ7/13me/0ye518uOzDLsrey\n", + "LPuL36uGZFn2lSzLXsmy7KUsy/4wfLeXZdn/mmXZ4HE7/s3vURv+8yzLfuOqXm8jH0m+X3T7Z7Ms\n", + "+2qWZZMsy37te9iGjW7/4MiV1+0syxpZlv3q4/sfZVn2tSzLvvQ9asOnRrc/TeDkM5K+ccljc0nZ\n", + "x7lJ9lgu+L4u6fk8z9+Q9EVJfxgO+W8kTSTdkPRXJP1KlmWf+zht2cinRr5fdPs9Sb8g6e98nPtv\n", + "5FMp3w+6XZP0XUn/bJ7nfUk/J+k3syz7zMdpy0YeS57nP/A/kn5b0kzSWNKRpFcl/bqkX3j8/U9K\n", + "eufx378haS5pJOlY0n/w+PN/StL/K+mRpH8s6Z+z6/9DSV+W9P88Pu+lC9ryBUm//fjv/1LSz9h3\n", + "XUknkl6xz/47Sb+44lqZzibCW5LuPz62H5/Jjn9L0k9J+tLj+5w+fsav2XP8oqTfl3Qo6X+TtPtx\n", + "r7f52ej2iuN+QdKvPeG5Nrr9Kf/5ftRtO/6PJP0rG93+c4z/uhvwCSr670j6a/b/r0n6+bIBlPQd\n", + "SX/R/n9G0gNJX3r8/z//+P+nTDnekvQXdMZG1Uru/289niDDxxPhkaTp40n3UGcRwhckDcN5f0vS\n", + "/77imf6apG9LekFnwOZ/kfTfX6CU6bkk/Wcca9//Q0nvSvqcpI6k/1nSb3zc621+NrqNbofjv6wn\n", + "g5ONbm9+vu90+/E5N3UGqF5b8Uwb3b7Ez6cprSOdp/wuSwH+VUn/R57nvyVJeZ7/n5K+KulffPx9\n", + "LunX8zz/Zp7nizzPZ/ECeZ7/ep7nuzqjA39c0j8h6ev5WS51L8/ztyX1dKb0LseStla0669I+q/y\n", + "PH8rz/OhpP9Y0r+RZdllxjXT+efPdaao38jzfCTpb0v61y6iO59wvY18cnLVdbtwyiXatdHtjSDf\n", + "N7r9OP3zPzy+7rdWtGuj25eQTxs4uYxRLJPPSPpXsyx7xI+kf1rSLTtmZdX44yLXgyzLDiT9hM6Q\n", + "7uuSfujx9f7dx4cOJPXD6ds6Ayhl8rQknxzf1Vn+8+blHqtU/Dm+K6ku6dqf43ob+WTkqut24bRL\n", + "tGuj2xtBvi90+zG4+A2d1Qz+7AXt2uj2JaS27gasWVYpffz8uzqjyf76x7iW8jx/KGkny7J/XdJP\n", + "5nn+M1mW/QNJv5zn+W/bod+SVMuy7JX8rPBKeozUV1z6fZ1Rg8jzOsvR3pf0rM4oPklSlmVVSdcv\n", + "0d7nw99TnVGhw495vY2sR66abl/qeiYb3d7IKrlyuv2YpfhVnenNX8rzfH7BPTe6fQn5tDEnWfh7\n", + "VQR3X9LL9v/flfSXsyz7F7Isq2ZZ1nq8xv6ZFddeJf+kpH/0+O8vKKxmeEzx/QNJP59lWSfLsn9G\n", + "0l/WGRovk/9R0r+XZdkLWZb1JP0Xkv6nPM8XOgM6rSzL/tJjqvHnJDXt3HuSXgjUXybpr2ZZ9hey\n", + "LOtI+nlJfz8/S05+nOtt5JOTK63b0plhzLKspbOgqJplWfOxsSyTjW5vBLnyui3pVyR9VtK/lOf5\n", + "yROut9HtS8inDZzk4e/4P/KLkn7uMXX3t/I8f1fSvyzpP5H0gc4Q+b+vomJfBoH+mKR/lGXZU5Jm\n", + "eZ4flhzzNyS1H9/n70r6t/M8/+aK6/0dnQGX/1vSmzor2PqbkvT42n9D0n+rs2KpgYrU399//Hs/\n", + "y7Kv2jP8hs4q4u9Kakj6d/4c19vIJyffD7r9t3Wmo/+RzuoBxpL+0xXX2+j2RpArrduPlwz/dZ2x\n", + "3PeyLDt+/LNqj6qNbl9CsscVuxvZiLIs+x2d0aCbfSg28gMlG93eyA+q/KDq9qeNOdnIk+XK0Xsb\n", + "2cj/T7LR7Y38oMoPnG5vwMlGomyotI38oMpGtzfygyo/cLq9SetsZCMb2chGNrKRKyVrWUr85S9/\n", + "OZekCIyyLEuf+Xfz+Vzz+VxZlomi4tlspkqlcu68LMs0ny9XcVWrVVUqFdXrdVWr1XTtxWKRrn1y\n", + "cqLpdKrT01Odnp5qPp+rUqmo0+mo3+8ryzLNZrN0D87ld6VSUa227Eramee5ptNpOrder6efarWq\n", + "PM81m83SPfM8T8/Eb4R7rRKes1KpFPpoNBrp8PBQh4eHGo1GmkwmkqRWq6V+v6+dnR11u13V63W1\n", + "Wi3V63VlWabFYpF+8jzXfD5Pz5HneXrGWq2m2WymyWSiyWSSnqNarardbqvVaqlWq6Wf2H+z2UyD\n", + "wUCDwUCnp6eqVCpqNBrq9/tqNBqF56ZPFotF6jPuxzP/0i/90lrpzV/+5V9+Itr39kapVCpPHOt4\n", + "jYuud9H5ktKceNI94/3iuWVz+Xsh3g7mELJYLAr9x/9IpVJJduSjSBwTtzVl7XKhjd622K4n3Q/5\n", + "2Z/92bXp9q/+6q/m2LQyvfPvsixTtVpN8x374cKx3pd+jfl8rsViURgvPwZ7Uq/Xk82bz+eaTqea\n", + "TqfJ5ktKfR6FNmHv8jxXs9lUrVZLdm48Hms2m6XjKpWKqtVqwZfQJv/b27xKoj9x27m3t6ednZ30\n", + "HHmeazKZJBt+enoqScln4TvcB/A37XBbmee5Wq1W8hvIZDLRdDot9L/7JMa13++n/qXfR6NRei7v\n", + "78ViUdCLarWa/pakn/7pny7tpLWAE1dIHsIH1X/TQThHHKJUBAeu6NVqNSkeA7JYLJIiRwDkk4iO\n", + "5LjJZKJKpaLZbJaMigMAfrvB4brT6VSTySQpXLVaLYAkFMCvw/O4cG2fqP4MgKdqtZqO5X7dblfT\n", + "6VTHx8eFezl4wtEvFgu1223V6/UCOKH/mcDcs1qtponLM/mz0GfxWfgNMGPSTafTdJ2Tk5PC9eKk\n", + "bzQaaVLw+6rIk8DCRd9F57nqWv4Zf18W2JSdf9G5ZQ6pXq8XxiuOzyq5LJC66LndgWHoIjBxo4qU\n", + "AZPLtCeCCZ8HZeevumbZXF91P5ePMq7fK8EeRr0ps9m1Wq0wZ7FLZcdK520ZgRzAbjqdnutvArvF\n", + "YqFGo5HscrvdVqdztq0HNoa//VkcmEhLH9BoNJL/wLbQ/2778RMuEZSUjRuflQE7+rjZPFvpe3p6\n", + "qmazmYJnAl138LPZTPV6PbWTfvdAzn0e7SSoZKzoW9oT/Ztfl/H0gBj/io9+EhB3gLdK1gZOVhkz\n", + "V1SUCCVzpFn2wN6pDlBwgigyqDse32g0JJ05xvl8npwm1+ZcQI63l78BOKenpwUk2W63VavVkqJE\n", + "R889eD4HMPzmud1ReLQSjW+WZUmpa7Wams1mgb0BOTP5K5WKTk5OzvV9jHrimM1mszQ5nOHiWb1f\n", + "Yl8xrovFIhmDarWqk5OTwiSj78oM+3Q6XRkdfdKyKk16Wad8GWCyShys87dfo8xYOuux6l7+OYbp\n", + "9PRUW1tbOjw8TON8ERtQdq3LHFfWB2VO0Z8FvYlOpOy8y/Y38yu2LwYL8RnLQJIf/yRgcxWASZmU\n", + "AVYPPNzxuO2SljrkOkp/wELX63U1Gg01Gg2dnJzo9PRUs9ksARJ3qOieO7xKpaLT09Nzjpd7u45I\n", + "Smxtp9PRcDhMPsCBQ5n9KdMld9jeXxEAcGxZH2APZ7OZxuNxsovYSreLbi+jTjMePkawHwBAAnhn\n", + "x+O8oG3z+TyBwQjEvH1+Lvf38XeGfpWsDZz4gJYZT0fdPKArFY4Qx9hoNAoUn6QU2U8mk5Q6kKRO\n", + "p6Otra10DgKFxjVRjizLEtXnk4BJ522ez+caj8c6ODjQu+++qzzPde3aNV2/fl27u7vn0iX+TGXU\n", + "cewvZy3cOPj1XHmhODudTkqz0KeuhDAPtMEpc48cmCTev0wg2A4HElGBXQBP3q/uaGIqD8PlkYBH\n", + "FFdB4qS+rJQ522j8Vzkqp7WlYpRYq9XOgcuyNrtReVLKIcsytVotjcdjtdttNZvNRAf/eaUsOl/V\n", + "5pjCicwg7fUo8qLrMqcjOPC+LRunVePs7Yu2bdVzl9nCqwBQyvTanRbHEM27vfbghPnbarVSSt0D\n", + "T/qZQKrVaqnT6Wgymej4+Lgw7gQ3BCcEYNgp/IPbGA/wuFej0VCn09He3p729va0u7uru3fv6lvf\n", + "+lYBxHiKxO1wTJdIRV2LrLrP5/l8nnwLwIE+nE6nqX9w6O7geVaCT+4V2X8HAbBSLm4jYGHo0zKW\n", + "CyAzHo/TfX3uR9CBXjAGjUaj1B9EuVLb18fJyISI1BPoF6Wez+caDAZqNBqpbgKFAlkS7ZFGWCwW\n", + "6vf7Ojk5SU6PHwbdmQRH85ERoO0MynQ61d27d3V8fKw7d+6o1Wrptdde087OTjrfjZ1UrKvxSYRE\n", + "J1+WYuI6brABE51OJ01CFB82yettOp1Oaluk3SKIoH8iwPJnojYIVio6UcaI7xnvmNPlbyYq+kBE\n", + "tSpCXaesAiqr2IB4jn+HnkfnBT3rn7luODApc3CrAoVVMpvNUkqtVqtpMBjorbfe0quvvprSPE8C\n", + "Q2XyJPamTFzPpdWgCp2LYCY+r9sc7AzzJ9okjnlSn5UBi4vGn+8Z2wgA1iVRT8qYImcxnBXlWBwZ\n", + "gQ/znDmM7s7n85TSkJapFmdxZ7NZsj1+H2cYCJy4p1RkNTwYqtfr2tra0u7urgaDga5du6Z+v6+v\n", + "fvWrOj09TYGXAxO3ac7oRJ3it/cZ/9NWB0C03dPtMWW/vb2tWq2m6XSqo6Mj1Wq1VHsSWQq/N+1E\n", + "t/BZHijzTA5u6DcPDGkn13Uf7deJ9gUfi/1eJWsBJ2URR9mAOgBAkRytukIvFosEOnB2gJp2u63h\n", + "cJgAyng8LkTmlUpF3W5XnU5H9Xo9gRMv4qxUKmo2m+doMB9Q/j88PNR8Ptd7772XFPj1119XpVLR\n", + "j/7oj6rVap1jI4j+YW98Mrlxc9Dlfed0JROW8+r1umq1WipO5RiM9sHBQUpB7e7upmO8FofnRdEA\n", + "gEyK2Fan1RlTV+qYMuK5pSU4WZXC4nz6bTwep/OugpQ5H5fLOOA47tF5oSuec45swpPuA7BBd570\n", + "LO5QpLMxxaB/61vf0o/8yI/o3r1758ahjBW8yDnH+z/pWdyOxGfxttBni8UyP17WRgciRJVlrN+T\n", + "2hgDDI6Nx7lee/uvCjApk7JncGePrXb7TP8zt3k2D0QAGpPJRNVqVVtbW0nvtra2ku12Z0ywhW5i\n", + "v6QlYI3sh7c7z3P1+33t7u7qzp076vV6Go1G2t3d1WuvvaY/+7M/03Q6PcfoxYJsrue/yySCOMTZ\n", + "FQcMkgoByNbWllqtllqtVlqEcHx8nOYzz4ofAQB6mguB8fB+cWDjwMnH1ot30XPaXMZ+wtjAiNVq\n", + "tQS6VsnarPmqCer/0wH+PYpdrVbVarWSg3MmAjbAacTt7W0dHBxoPB4rz3MNBgPl+VktCJG9MwMY\n", + "fgdHeb4szooUtg/u0dGRPvzwQ12/fr3Qtq997Wvq9/v63Oc+l5AmE9cLQF0hHAVHZfYJ6MoelcfT\n", + "IdKyGKler+v4+Dj9gIxZJZPnZ8VZAMHJZJKcGSxVZLicQncj5Mg6gjoHOzxPjGzoF66d52eV9JPJ\n", + "pJBvvQqyiv34KOITvuxaDhgwzBgmJj46EZ0wv8uKBS9qN846y7IEZmu1mkajkV599VX96Z/+qV54\n", + "4QWNx+NzLAXyUZ1tBFyrjnHdiM/qc4h+jaDM+9vBAde5KMXyUcbWxy2yZdgDTx84wL8K4kDK7ZMH\n", + "E94fMZCEiYYNKWOhOe/k5CQtSCAVlOd5Ykyk5Xh3u10tFot0DHaGa/mqFPwCz1Ov13Xjxg29++67\n", + "6vf76ZkePHigl19+WScnJ/r617+eGENJKYD1e5WB8LL+879dD8rAidtM2I56va5er5f+h0Vqt9vn\n", + "0usANoABLHNkEGMaKjInDsRoN230AFM6X/vJMVmWJQbfGaxVsjZwsspI8dBx6arTS16Y2uv1VKlU\n", + "CstxpSV9RwdDhTmDMhqNCoWwDBJ1DL6s2BXaC7OkInXGtZ3+ZnBarZZ+53d+R9vb27px40YadBSG\n", + "NsQIRFqmfWLNhRsCn3z+nSs9AmKdTqcaDoc6PDxUp9PRaDTScDhMFP3Ozk6KMukPnE+r1Up9FyMU\n", + "V2D6gHbHHG1kg5xyjODQQd14PNZwOLwy9SZl8iQW5Unn+AQuG/PIapQxIe6cy6K9J4m3oVar6fj4\n", + "OBW08dnJyYlee+013blzR7du3UqRZtRJb0vZfSKYiueW9eWqzz0d48EEn3n9lKfDykBVbIvfO0Z/\n", + "0dCXtdXHN9a5OO1+VdKVcT6uAiZxoYGk1M8EjNgRZ6W5hzu6xWKhg4ODlN7xAAfWhBWJsGHScixd\n", + "19BFZ2l4DtrMKh/sb7fb1f7+vl555RV98MEHOjo6KqT5ELdJDty2trZUqVRSAOX9dhkh0KDfZrNZ\n", + "WlgR9YVAsd1uK8uylLL3gBOGibmAzXCGJj6b+1//oZbRAX0ZuOY3qRxA6WX6YW1pnbLIAeXE+Xva\n", + "xsEJBbCgQtIxdLIPihubfr+vyWSiBw8eFFAvUTv0GPdm8HyZFuKpE58Ep6enGg6HiUrziKDVamk6\n", + "neoP//AP9VM/9VPn2JgITBBWDh0dHanRaKTalWgovD9daWjrycmJ6vV6YovI7boBBOgx2Q8PD9Ne\n", + "Lyg97WWyMOl9nBAin0j3emU99CMKHp2rK7IDwNFolIAg7MtVk4/D5jggpT8w5mV7zUhFJ4lOO+D1\n", + "65RR2xe11Z02UZh/x/UfPXqk3d3d0rlS1h/cNxbVMedie1a1z/UdXYxRnt8vgodY4M6xq+7nNmVV\n", + "SuxJUSHXdwaRz914XwVggkR2QzrvgMrASWREAa5ZliW75Owv18uys4J59AqbBLCsVCppXxIvJPW2\n", + "OcDzFIQX7WOXHWQ6ADo8PNQP//AP6/d+7/cKwTHX9lU93BeGoNlsqtPpaH9//9z2CNzHWTmENDwB\n", + "7uHh2bsGm81mYkAkpS0Y6NsI0PCVnkWgX13oE/ezPgdIoTN2+BS3KVy7bCybzWYqZ/Ag5KLAcq1L\n", + "iVehJx7cnbsPIP+jcKDySuVsVUpc0uQFkxQ8eWEQyBy2hOO5NgPEPWO+2qvOAREuXItamLfeekvv\n", + "vPOOXnrppcIyZ681QbIs02Qy0cHBQapYn06nunXr1rlVNyhEBGW+YinPc21tbaW86nA4lHRWdNbt\n", + "dgt0IaCIPCGrMlBO9nBptVrnDKwXvcYo3pUVwxLzm4yBF5pxzOnpqQaDQUoz4bivas3JR2FPykA7\n", + "fTmfz9P+ItFpAdiazWZhXwhnL8qcs9/Hj4/HLBYLNZtNjUajwjgxF/is0WjoO9/5jl599dW04V98\n", + "Nn9GB/+NRiPNhdimi8TBEPoSlyo6EPJVYJGd8H5dBS4uSvEgzPkI2Mv6N4I5b3ds/7olOmHXmfgc\n", + "HIPNpJ/ZyoDjDw8Pk+PmGH9e3wQNB+k2we8LK+sRvKTkVNEL199Op5PASWTJmUfb29u6fv267t+/\n", + "X7DRzqxH0Oo1H1tbW6XLoMv6F/vY6/XUarUkSe12W6PRSJ1OJ+ksAdpkMkmZBEAHARvp12azmZ6b\n", + "tK+3x5/BWVZp6fdIZVHbSb8yn/Cl/DgAAqh5H/sqrTJZqzWPhqfMCDnIkJSQNx2G8wbZbW1taW9v\n", + "L6FbV1KQGh2HAjlz4jUidKSnI/icamPoOtqJQfYVC6BZihdbrZa+8pWvpHbGCNcVnPMpaJrNZikF\n", + "s729nZzCRVEW4Obg4CBVd3e73QSMqtWz3Vy3t7fTzn/0qRfH8hyHh4eFfQdA0J7S8bFzOpDnYh8B\n", + "IgxQPUYBgAIThbHnc3ak9Wr8i4qrPilZxWRdFqCUHeOpEXbR9XtFiWm9+Pmqc5/UvhhdMlc85ZPn\n", + "uV566SUdHx8X5k+kvLlfTK3Ezy4q1uX7sr99eaWPCY7Ha9T8ntHJuETgclG7uGYZExjnt9uKSKl7\n", + "361TygJJt3s+z6MNkJbzE6aKbRxwjMfHxynY8Wt3Oh21Wi2dnp6mFIdUXDKLzYTNRTxlBiPMs/h4\n", + "++IDxNkZ2JMvfvGL+t3f/d0CsF0F5ofDoba2tpIPIvijPs4Z0LJgIcuytLqStpElaDabyR/AZE8m\n", + "k7RNBM/M3PQlvzGthb67/+Bzzxigf/gAgnEHNwQYgBDf0M6fId5/lVyNUNMEJXZnE42aU2mLxUKD\n", + "wUCj0Uiz2Swhyd3d3YQ6XZmOj48LkbbXr0Sa2Vf8OICIjIu0rDRnJ9ZoVFBQPj8+Ptaf/Mmf6Id/\n", + "+IcLhYw+mRBSOe+//356DlYE0RaYmbjXC0rHLrGj0UiDwUDtdlvHx8eJTen1enr++ecTc9JutxPQ\n", + "8sIqKEKvDi+bpB6JxsjW0f1wONTp6WlaLeVGmPF0YOaOmijJXwmwbomsR/xcejLl71EM53q06sAc\n", + "AbhBkT8JiFwkcQw5lw2x/BgvHsdYtdttPXr0SM8++2xiQlaxpW74ynS/DCz4/57Omk6nqQZqNBql\n", + "+3r/cB8cV7wHz8hcjP3ubeBzZ17KWBX01schGu04Xv78H3X8vhcSwQbithEpq2vydFWlUkl7Lrl9\n", + "9GthTyuVSmFvJt/XiPGmj5xhdJAEQKC9nuIAADjzTHs4D1A+GAz06quv6s0330w6X8ZM8kz7+/sp\n", + "JQ6r74XAnirx1D7PwHUbjYZ2d3dTkMozTadTHRwcJFs4HA4TewKj7PpJCkwqrsjxOci9OZ82tdvt\n", + "1D+AJHyu22KCXeyTL8xwpsTLA1bJWpcSl004qDaQ7Sr6KyqxVyk3m820vNTpYwbWV/I4OHFjxiAA\n", + "TkCMzgI4WvfNfvy+7mRQqkajoa2tLb3++uu6deuW+v1+ul803NKZcet0OnrqqafSUjqiDBRDWlJn\n", + "bEGPOFW3WCz04MEDnZycpM1wFouF7t27p1deeSXlKD3qJf+JEd3e3k60oufH3WH4+nX2hwE48R4d\n", + "H7/T09NEsUpKBV6+F4tPaqhPwIkX565TLkrp8PdFwEQq7o0AG8H5q4SUT5wzq0DRKsATgaY7UV/O\n", + "yLnOJjIWJycneumll/Tw4cNzqbYyRwujiLgD53tvY+wrImCCBQASbWw0Gjo6OirQ+R51e99Sl+Wp\n", + "hCjOEHrQMpvNEqiJ876MUYvpZ38mB5/rBiYuEUxI51dv8NsBXOxzfzaPvCWd00NAijN1HuC4TvC9\n", + "38tTOlzfA1Lvf+w97cGpSmfg9/nnn9fdu3cLjtl/JBVekwJrwfJZxhVg1Gq1CiUBrh/cd3t7OwVp\n", + "gJLpdKper1cAcWVsHs93cnKSGJdY08RvbDx6zSZwzI12u53OZ9556hI/DChxP8L96DPf22aVXLnt\n", + "66UiQHGH51GEG9o4URgkf3g6BJoVFgCwUMY2oJwMJk7RC2ERFMyLr/xYR7A+Ed9++2392I/9WFJo\n", + "ABGTxCu1O52OKpVK2s6Z1UZ8P5lMVK/XNR6P1ev1CuCD9h4cHKRnRrj3/v6+nn766TQGTq3TNz6x\n", + "3QBHQwwy5jsKcaFyffURE86NuqN1trEm1+lRASm2uNvvumQVY/Jxo98IMhyo+GcOImKUGKN6b5tT\n", + "u9L5FwF6VMw9ABOuV5JSpIkOHh8f69atW+eMbhlw8g3c+O3Ax9sICPD2NxqNwl4U7nRI/zEfvG/L\n", + "AIAHKPRFBEURKHoBL4yi93e0d6tW4bi9uqoSmWGeDefjDGZkFaRioSo/Dgax7+48qesjHYy4j6Bt\n", + "/oONQDexydPpNNXSRUDlLI37FnZFvn37tu7cuVNgDZwF85qmyWSSbC2+hPNgfTqdTgqsmSv1el3d\n", + "ble3b9/Ww4cP0xJpQMRisUjpbhdf0eR9DuD2eeNz3/2cAyfPKMzn81SM66wR/ppnp46x3W4XFq64\n", + "T8SGx/a7XLm0DsIDOzXkfzttRCdRiOObvDAIsTgny7ICzcY93Vj5oPG3G2RP/9Tr9UJxKYjfn4ff\n", + "LL2sVqv69re/rdu3b+vll19ONTAMphsBT62gVBhjVu7AZjBZAQNHR0caj8e6d+9eyr060oZmRbiH\n", + "52IdEKKYPE80PB7d+KQfj8eF/Uz8xVqknqD+nA2CeiUv7crtIPMqgJMyWQXGL5Pe4XykzJl6hBnv\n", + "W+YAy66HlLUHZ4tRpWao2+1qPB4n44ue0vann35a+/v72traKgCmMom0fAw+vO/cAWCsvQg49h9t\n", + "j8yaj4kDLP6OgRESGQ9vqwcnDq4cTHsA5e2MIOiqAZQYbTswkc4v+faatchaOePktRNeJ+Q6je45\n", + "W4E4YPe+5b5e4O/to/6j0WikGinpzC7B9jrIwOa88MILun//vg4ODs6x/FzfAwVYBHyXB7L4ljxf\n", + "7inVbDa1u7ur559/XoeHh2l5sLOZ9F2z2Ux+h89cnOHwANzrSdwX4GM4lwDR0zP0ny9p9g00fczo\n", + "ex8b/MOVBCceOV3EnjiSc5Tn1J2kROujBCA+SYU8FwrCeTi+sloFH7iYX3ZE7jQ6VB/sgkdSRAcY\n", + "yXa7ndIZ3/72t/VDP/RDkooRWKQ8QbTOklDVTVThWzqPRiPN53MdHR3p9ddfT0oDWHNWhWv6+MS/\n", + "HZzEfCbfuUGu1+upDZ5j9T5lzGjbYDAoGHtH+uRcPcp3pukqpHXKpAxQSE92Pm6I4rER2Di1G89d\n", + "1aYyBiMpQdUAAAAgAElEQVRKHAvGuFKpaDQapT6fz+cJqKCzTmdftE21t8FX7EjLZdHoBzaA4IDi\n", + "9gh+ot5GEH1Rf3hQ4Ncs+wyJKdnoqNwplPUvziPeOz7LuqQsRcX/rt8OJImSfb5zDvOYfndWzuc8\n", + "OuWpg9gfDkZivwFwPGrnOrPZLNUlwmjgNwicSMXQvsFgoCzL9OKLL6b3taGzrj/cx5lt6kHm87n2\n", + "9/fV7XZVrVbT3iWz2Uy9Xk97e3t68cUXdffuXXW73QKTT78yt2GkAQ8O+qL/igDK/Zr7VUBPzExE\n", + "NorrkIp33XYw6j7c5wHB9CpZ+4v/yiI7JKZAYuEZD45BJO/u1LMXQ8WqbCJul4gIIyXujhgDjBFm\n", + "mS+5716vp8FgUIg8fQK1221Np1O98847+vDDD7W7u5vaTsWztHQKTFhf3VKtni1T29nZSVvzHx8f\n", + "K89zPXr0SKenp/rGN76RlNHBCG1xqg0nAOJ1YIiB8NwvCsh5fAfz1W63NRgMCikemB6vIXHnw1h5\n", + "vtdRdqTLYc2uCnNykdO/bHrHDXd0WDGSLxO/x0XO5KJniMbeAwKPMom2+v1+Ai/V6tk+P+TLy+4f\n", + "GSUciUdfnqpxB0kRNE4h2hFsA33HRl2rntX7w+/v93XmA/12QB7lMixIZFw8TepA6KqwKBH8+f+u\n", + "n3yHfYm1fW4nqtVqAgkONKXivksXAcxoE/gd9Y3jvJ5jOBwWbJ37iUqlkuqouOZ8Ptf169eTrUfX\n", + "CL4Wi0XaJsHv529Pr1arqT5jOp2mgPrll19Ws9nU3bt3Cyt1XAf5jX8jpRkDFPwshcduR5xJIUMB\n", + "++gMPudFEBHBhjMiMDDebr837QJQrZK1bsLmNGyM5CJ1KC2LVBeLRVpKykP7Rl7QdSBSp8F8NYsb\n", + "D1dkAIpUpOgioHJkyvlON2NonXImpcNkbLVaGgwGeuONN/TZz362sKKHIk/qSxaLRYpUccSOoKG4\n", + "K5WK7t+/r4cPH+rtt99OBhXlYZK6YsGcOE3vRcAcByUZx8z3KaB+gD5sNpsaDAYFI+4Rtiu2KzXg\n", + "j/YRdaAL/HaEfhXE9Tu26bLARFrSomUOq0w8aoq6LRXBwJPa5OeQOiMf7oC+VqsVGJTZbKatrS0d\n", + "Hx+r0+no9PRUH374oW7cuJEcE2CWZ+FllDyDt6fMwWdZpt3dXR0cHBScSmy/Py+6VdZ/Hr0zTyI4\n", + "cFra+xsQ7f3vQUCZeFtjPU0ZEI39sA6JtvgiHYr97qwvgQnBCk5SWq6SJEjyKD8yBj4WHvn7/z5u\n", + "nOPpNlZl+UoZT7VUKmepaGwiQPzk5ESj0Uif//zn9eabb6bnunfvXmJ5YPPzfPmqFBy8B7oA7Ha7\n", + "rS9+8YvK81zD4TAxJqukVqulnWdJvWAn6QNP53hKB7DowTttJlB0hhq/6+Prfe/pe0/NegDt/hHm\n", + "ijm58hlXfvMJSYzkfEBQSJ8QGKL5fJ5e0+479oEevXN9MxxJBQcdGRE+j4Y8IvM4MSJFyXf8Pjk5\n", + "UafTObcklxc4feMb30jfZ1mmnZ0d9fv9VGtB5XSv11O32y0t4kUxxuOxPvzwQ925c6ewj4qkQkTo\n", + "tB3KNBgMEmJ3JgLwEAvSJKV0kjuvGDWBzmezWWFVldO49JWPlwMo/5GWS5yvyjJil4sAyqrPOM/1\n", + "CIYrpg1W3bNM3LhfxOqUtQ+DHR2In9/tdhMobbfbaVdh6PTnnnsuFW878OZ6MCtPYiCoc9nd3dWD\n", + "Bw9KgUlZH1FM6cxLdKb8dqAgFanwstSaf+cAIwIWF783ztCvWcYCXDXxKNiBoAc9/p33PfOdBQpc\n", + "z5lSaWmnfTxiH7s9iAFmBCnxtzPnvm0C1yWAOjk5KWzQSZp+b28v2avT09NUMEvw6YCYcwFlgB3p\n", + "jEF/6aWXCqlRB3VefO7MPas+T09PE+jzVZA8j+vofD5Xt9st2EzGIII0fGmWZYXNHdFZZ7kARowL\n", + "13f77cdh3y7S77W/ldjpprJjyj5zcACLQirFQQcTBcV3JOiV1g4wUEhvG2jPAYBPNraAZw8Vvuc8\n", + "tnBn4rVaLY1Go5RzbLVaevDggb7+9a+nDdB2d3fV6/XUbreTIsxmM127dk1bW1tqt9vq9XqSzsDI\n", + "1tZWymV+85vf1P3799Vut5OyQI26ktN/GODBYJB2t6W9zkr4JkYwI0xGJhrHepU2+xSwp8l4PE5M\n", + "CjseSsV9ZRws+q690pItisDEt4e+KrJKj1exKjGl4MeUGWHpyamiaLQv2+YyQx/vhaFZLBapQHZv\n", + "by/VGvV6veSEfI4DumDDKGr1wm8MPgWK3W5XzWZTH374YWqT0+QxWsaI+1b+0Un587pNkc7vRRJp\n", + "aY4p6zsvGr9IcHS0fVVNyrqZE6l8pViZDvtxCEtZ3f4QWbte+1g4MPE+8L7y+7ueRlDiwAldhZ3w\n", + "qJ40PIw2tvH09DTt8orNabVa6UWB7EUlKYEF7CXpTna13t7eTun8mzdv6vOf/7yOjo4KBcHurxys\n", + "xr+r1WoqpPUVb85wRh9G4O7jQ0Eyxx4fH6vRaGh7e7uQPpKWQI7+xwZ4MXwZ0wJj5u27qE5wrW8l\n", + "XmUsLzK2lUol0cV0pufb3LBG+imiT0eUfh6f8T8d65/TFpiAR48epTf7gmop2MMAAVLq9br6/X5a\n", + "CsY1j46OUq7ywYMHevDgQWIQyNEeHBykXRO3t7fT81+/fl2SdOfOHd2/f1/dbje10YEJEz72P0rG\n", + "ToP0qae3EGeh/D0PvnqJCnOcTa/X08HBgR49epQUlHvQTq7N2Hhxb3TMXggLEIzvi1i3lIGHyGJE\n", + "I48j9vyxg2K/9mVYkHj8ZQEN4gXftMVXnAAQK5WKHj16lPZtIFgYDoeFVCX39iDCgTBAHIDrugtw\n", + "R38jHc08jlE8+ua1BJ4CKBsjaclq+BzlnAhCaKuzQ2UMTexzZ6ViWkhaOqCLVjV8EhIZ7chWxb5z\n", + "ACcp7c+E7cLBe996MMkYx927nen2NFxkzOhDHyv0jF3EnSUhTeLMPLUg6OpoNNLOzo46nU56gSw6\n", + "OZvNUl0TOsdqUFI8BwcHGo/Hab+Rev3sbchHR0eF9jq45n/3QV6r4/0FUPEl0PSXrw7ylBrP6nOT\n", + "3ycnJxoMBtrZ2UnAif5kPBwwck3aHcGVA8wry5wgbpjjJEbhPXJgoOr1unZ3d1Wr1dIyWe9wp/Nw\n", + "bjhfN3w4uGh8+Jx2uLLQPo/W7969q8FgkJwpqSYcNxR2o9FIK3qgC3n3Qa/XS89AAZazP7Az77//\n", + "fkL2/X4/PQ/LbA8ODgrpK/rOWROcuhtxd4ZQmBRsuRIxoWNE7wW0gJc4eVDymHsFxERlZgLE8XGB\n", + "smd8r7qsmowOWkiHRAcaj7/oeh+1HWWO06Mfj+59LwV0r1ar6fr166kYG0cN5Y3RIjXDZmdOfTOv\n", + "/EVwXgzutDPHe+2VR8HofZkRjMEIDqqsb5yBuagfcTa+Gs1ZFq93KTPaZZ/Hvl+nRHbJ+5r/Oc7t\n", + "t5/PuOLcPOXs58OqYBcYW16p4e2QVKh3iixJDFCr1eUW8JVKJTlfzqemDmACi02qGyDSbDZ1fHys\n", + "nZ2dpMsAFrfZbGM/n8+1s7OTNjID9LRarXQe/YD+kGr3vsc2AERgaTxzEAGHVEwvwmDAeESw7+eR\n", + "joUB9Wu5T3Cd8Pussk+XWVl5JWpOLkrpeNrB0THROIM1Ho8L18IwudP1LXMXi0Vh+2R+s7wJRfbv\n", + "YtQonRklgAHtYldA0jYUUR0eHqpWq6U3THJtEDaK4G/JjHUfTPLBYJCQO9ElEUTsz7KoGwNAH52e\n", + "nqrX66VJwcukKpVKWjkU2Rb6wHO3cZyYaDBGe3t7CaBgtGNeP0YKMfqJUZIX+l5FuYgddFDi4kWZ\n", + "ZZFz2TVXOTc/J0bA3hb+xlnHdnlRrBt+xvDw8DBFkNKy4FBSMsLs3oxjYjwx1G64HRDx0kFJhcLa\n", + "OObxfwcyZRE+fRuZJSQypav6lmNX1YysoubLzr+qgm0pAx9Ska3wc/gO0Opg1HXJbbczJw5Q2fnb\n", + "ARu2OjpX7ulMMedi+6j/o8aCN8pLyxqn8Xic2Hr8xmg0Urvd1nA4TLuosq/U8fFx0mX07+HDh9rb\n", + "20uF4tPpVDdu3NBkMkkpTKkYEABMYD1gL7AJ7veYi7G2kj7gu7Ixc9uLuC6T3nLgF1nQMvvlvjKC\n", + "1jgPy+RK7hDrx0jFqI3vpOUab5TT9/Hw853aoqCTDkP5nSHxIs1IrcXrMYCgUBSY+1AIyq6trDBC\n", + "ydnvBDDjRaJOczabzYTqfe07hpsUEbvIes6btnt9DUoMWzOfz/XUU0+lGhcYJU/vuDEo22/AgUlZ\n", + "ZC6dpYF2dnbSpHIWqwykeiQR9aLsvldBLtJr5CL9jxP4spT+RY7T7xsdSAQpzlxR5MffjMd8Pk81\n", + "BLCDRJvHx8fJUPMZG0Wx/NLrBciBE7F2u920AohrA0x4TvonRuw8B6ADXY9sifetBygXjd2T+tf3\n", + "ybjseCDObn6ce3+vJQJS16OyzxH/HsaEwMf3hHL76nrI+fRrDMY8gCxzkFyHe5AC5Lvt7W09evSo\n", + "sI0COt7tdpPtARhMJpP0Zm4CLJ4DRoLXamAzAeXxeHSaa8d5Tjt4dtrNrq2NRkOHh4eFNCV9hs57\n", + "utT3j/Hr099ufwEWznhGm+TnRabQWZkyPWLMrhw4cbS2yhCUfe6Dx0N3Op0ETBx4+HVitL+KGfBc\n", + "XYww4yT0CB/jCZvB24aZeKenp5pMJglJ93q9lN6BOoQBAnF7kSnUHceDZllr74WEgCFHql5j48vE\n", + "PNed57meeeaZ1EcODKiDAD37mn3GwiPUaLwAN0TDtJH2eZ5eOq/ADtQ8Gohg9aoAlCcBE5eLnOFH\n", + "qTPw9GdkkWI/rWJMytpBv3e73VQsyPGMKztsbm1taTqdam9vTw8ePNDW1lZyJjgj0oaMv+95w28v\n", + "bGZextVKOKYItjjGI7dovMtSxfTLRWP3JNCJrn8UiYCwTJ7E2HwS4vMxMiPuhJ4UcErLvUwcmOBM\n", + "o47CcuCkfZmx1+hEhob7wS47WJCUmGI+w45mWZbS8u6U8zxP9YOj0Uj9fj8Fb7B9HvTyDNSxtNvt\n", + "xLAA9LHx+C/u7WlGZ9NY9gzYIPWOfXYg7rZdUtoXCB11QOW/y/rUt7BnjGKhuAf3PLsDTtcjZ7Iu\n", + "mk9r3SGWvy+KHpFIr/rDoTSkTzyq92ugiO6kWbZFDpJzy6Io/xsUy3UlJeWrVCoFxQe1eoFpp9PR\n", + "wcFBUhKuQ3SaZZlarVZSWgAF92S7eYw3IIt2xpwubfZUjkcs9XpdN2/eVKWyLKD1zY+IgJlI9B+5\n", + "T+7rrJKn43hOJrAj6viaAq7hNKRTvlCUPoGvGnsiXc75X/azy4g7Ywd68bplc6Psnm602JHY91Hw\n", + "czudjsbjcVrl8NRTT2kymaTjOA+WLIIHxg8g6rl2dNyXRbrBdMfouhVZIOYiALmsRiGCPBfXxY8C\n", + "Fvy6Zd+tEmc2r4I4o7cqOFh1jLS0Sxzrf2MvYhDoq0wcYPi13A54m3CcXvsmLW13v99P774hsHTW\n", + "jWCSth4fH2t3dzcxKg5GHJg6U0ib40v08DOkOZ3BJ/h1W0cKp9vtajKZ6ObNm2lxgfs7MgnOtrhP\n", + "i0xiBJ2eiikLCH1MnIkpAyc+Dv75YrHcr+vKMScurryeM3dlipM6Oi83RnyO4vi5rthScdc+BnQV\n", + "q4OCMtherYxzxjgTITIQAAVSM7Sh3++nzdV4LpSRiNKZCNDybDZLG8yRs5RUoBQpFAW00S9Ohzpw\n", + "6Pf7aWmyrzyAxYGy3traKuSMQfoRPfOdgzNH2/QvYxiBifc/Ch4NkhuIyBZcBYlRedn3Uvlqh3jM\n", + "k8Rzyu4sypzEk67rjpSxAhz4d6RtML5ZliWdGwwGBRaPa0GrMzdOT0/TCgNnyDD06KB/54aUom2u\n", + "T/uYG9S/wDgins7x/lgFTGJfP6nffNwvut5F3zmFv27mRDrPUMYoOR4XdTo6ObcV2DBnyNARt+Ow\n", + "LewT4sWZzoRxnAc12FRJqViVZb3UMXkAiW/wPakcsLhjH41GyQ9EIE/bKY7lM3SQ15BQaOsbEqLz\n", + "6DI+ZzKZ6M6dO2m7CPoWf+DbLPCiWOaAsx0+l7zvHdTgT+IGb5H5cAadcY/gB9DHWFw55kQqN45P\n", + "moD+MJFG9EIg74gIMDiOgZ/NZim/Tb2FVFQMJhMrZvJ8ufeGdAZ62u12KrCFVfD8M9flPQjSkmnx\n", + "iQWLsb29nZbfwWYAAlA8FJxzcBL0I5PXKVQMHudyzvb2dgIqcXI7kyIt30nkII22OzCK6R4mBYDJ\n", + "o5I4/vSxT4BoAHnusvqXqyBPmnzIk0BKvM5F142OzKPZeL/LCPrebrdTnRDX9b1tpGVQ4Pn3WKcC\n", + "YOUaRFC+2stX8qCnOHEAPufgvAHcvuSRa/imWFFgAr2fvEgWiYAt9vEqoyxdbNcu+i469XXKKtC8\n", + "irGMnzlQZpylYv0QOuLP6oGkM8ySUv0eQvDlRaWIA2VvB2kZbCvMntsdD5YJPvkcxh37SOEsjp5V\n", + "Pezc7bpCyh8gDQDHXvL3cDhMby5mKXS1WtV7772Xns/7jDlLX+ELR6NR2qoCJt99Zhwjntn3BJN0\n", + "jvWgn3xbB+ZkZGdYVu3nrZK1bsJWZpQR7+zIoETk5wgwrhpxY4rik3/DuVLkhLFzh+vsBfcmP8kx\n", + "AJ5ut5v+n06nqeDJ834MNNvv53me3lBcqVTS2zEpbEVhQdQs6WLlhLTcCt7TIEwWFNEn3WJxtmaf\n", + "5W/VajWxOBH88Vyj0Sg9U6fTSREAtTNuSJl4DkgiW+KTxkEef3uBWpZlhaVnPrb04WWBwDrko4KU\n", + "i/6O/0dAs4p5ig7uojZFJo/8uBcxSstISSpuWEa0yVyLbAS/iRTRHWfYMHCkDQGiq5yPAxOeHdbu\n", + "4OAgLRctEw9mmN+eNvQ2x7+9n1dJBDNl//t13J7F/ZvWLatYkzKWMDo7ByU+Z3H+XuDKddArB46S\n", + "ErssFdM53ja+A4QAJObzs51YDw4OUt+SivegFXDBWJAmRyepccQmHx0daXt7O92j0+no3r17un37\n", + "tqTlTso+T/EFgHgCxHgcz+8rO9l+wrePR2ByAFNem8jzMJ+kJfjzNqzyzz5OPqbMN77jGq7vHvyX\n", + "zWOXK8GcXIZFKUPTHq04nYdT90nhk4Gljy5eKOoTMHa8t9UroXd3d7W/v5/W4g+HQw2HwwQMKpVK\n", + "YkJms1kqlIKNYRBxuIAJIrvF4uz11ZPJpJAf5b0KPmkdXBEx+DMTvbIMjt1m2TAr9g1g7uTkJD2T\n", + "MyBMJp4hKqOnG8qYgXg8EzNuj8x5XCfWr1wF6tslPjPycYFU2XkOJi9ygKuu59fwaAn9yrIs0d4U\n", + "CqKPUjHF6uABnfS0ZbPZTICaSNJrqTqdzjnGArDCNXzpOfl2GEvmK20mMqVoHr33fsRIeqrzo4xN\n", + "1OmyICuOC32MREaG/igbq3VJBCDIRcA5SgwkY82Gz3G3Gc4Ee32a109wnrQEK86IwQB4vQV2BhBN\n", + "6poiWAJGQDOpCIJB7xsYPIpUt7e3dXR0pGvXrhXS+ZJS0Ij+NhqNtGzZ00gEtwSasB71el1f+cpX\n", + "Cr7OXwXgfVCtVtOKUPqY4NHbDyBxkOMAxD9jTDwQ8DQSx8Sx8jovr31cJWuvObms+ASWzqNjqfge\n", + "Af7ne1dEvvPqZ2m5ix4GxH/8etXq8i2a7hwZTF8JxL29AHc0GiUFJU/INsgc78W6FGxVq1U9fPgw\n", + "nVOr1Qq7DfqKCPoKpZ9MJundPc7gnJyc6KWXXtKNGze0WCxXUrix98nMe3RwLkx2B4kOXGKajGM8\n", + "okIwJvQV+9JgaLyv+Zxr+9heFYnMHvLnASurQMeqlIOfdxG48b99nKTiC+58fjgFj0Nx1gFwzByD\n", + "IcSQslvmfD5PdSc+rr5TbtRFj6K5J22nLVDisKGRoUA8beTR/GWkrP+ik/Bcvh8bGa0I+K4a6C4D\n", + "SB4suK2M33GuB3vSsnCeMfaaDw8U6UPArL9Kg3v5+EXWfDqdpqCPdna73WSjfFsIGAq/frPZTMzJ\n", + "0dGRut1ugUXMskxbW1uJbcnzs4JRtq5Hr7HnnItuVqvVVEDO/XkdCiuBTk9PC6uE6J+oY8wNB1je\n", + "3+6vmMdS0UZ7n8eUEcEqNoF7SCqAHnQ7gkjaGEFSlLWmdZ4k0ZnxmS9L5TOUyhEgiNdzaxxPkarn\n", + "p924cLwbLYwyaJQIbTabpSVdZR3uu6JS40I6qVarpRQOk4Tc4mQySe9zkM62t+cNlr46idoWVzzS\n", + "QJXK2S6I/X4/0aCAB87p9/uFCNwnNhMLNobPcABc0wuLnamJURH3ROgHJhy/OY7zPFqJxtrH/ipI\n", + "ZCSepO8XgZVVTvMiQOMGK9K1q9icVeLREzVKDgYd9PiSxvl8nhg+38tHUgF0Y8SZp1mWFXLavtTU\n", + "GQV36g6YYEwAUkTDHkFf5vk/Lrvl4NCDk7LUtB/jjCO/rwooQdxRrZprZdF2DBhdB9FTZ8M4x1N4\n", + "eZ6nFAVsHPrAvTy9g+33PVHYdZv3NO3t7Wk8Hms2myXWDp1DCLZYgXNycpKCRWqqnMVGz2u1WtrX\n", + "ylND/loHBxBcA+Z6OBymYI1AFtDCPiv4ntgXzvhwXR877ycPNPhfUiEdy+cOQtyX0E8OLl2HncXx\n", + "Y580v64cc+LG2HONvrTQaSgGzjvfd9tDKdyQSUpvNN7a2kosCPd3IEM7UEoUj/zlaDTSZDLRw4cP\n", + "U1vYbEdabjmM4Cyazaa2t7dTzcbOzk6qQwGhc42jo6N0HRArUaFTZIAVBx9Q8bQ7bnglLTezI/2E\n", + "0A++PDv++CSICk/7vT+YbL6XBeMYqWyPhnmmVVHRVTPkZRNv1YS8iFlZlapxwy0VV6gxHpHGXgWW\n", + "IgDieg5AB4NBum+lsqzLiECM/+fzedoskPomSYWiPwclTnsTSeJUInihnZ7W4xlhYnguj8ovAxbj\n", + "80Qm6knfl6Vo4jh6P3LN2P84m48DkL5X4kyGVEyroytebO/Pgi4CXklre2TPGNI3/uwU4XPt8Xhc\n", + "GNfI3viSWuwX86VWq6UFBzAdXA/QzDVhPL773e/qww8/TGDjpZdeSky7gwdPYfhnMB29Xk+DwSC9\n", + "c8fZM3SAII2XosKMw6awGg4d8XmIX4S98RoQZ+s8PeO2nLZEW+DpVOw540nw7eO4WCw0Ho+TL2Y8\n", + "8SOM50VyJcCJd4Qr+3g8LtQsRNoe6l9aTgBf5hqjO67Npmg46Nu3b6fB9UIg2sObd8fjsdrtdmFn\n", + "TElpTTsG1NMZPpnzPFe/30+vrH7mmWeS4X/77bfPpVycBfJ184AIPtva2kpLKh2hSkuAxhIz6gAA\n", + "B61WS71eL1GcPgYxveVOg+MYu0jX8n1kNHgmLzhD6HtnsRjDVqulra2tc3Qw4814XgVZ5VAu62i8\n", + "T70g8iLWJEayGC4MEQ47nkv/lZ3rKbSYI+Y6vuwR4+VV/b4HD0YaHZpMJmq324Xoy1NH/rlfP+qc\n", + "z3mYRNrBSjwPUlYBvstI7PdV59Ie/i7r5+iEow0k8Lgqeh2BWaTpoftd7zgPR+3Le+N4eGTO9+5g\n", + "2SyzVqvpvffeS9fzY/mbtDN2L8/zlKpZLJZbsnc6neQHsEfs6IrOHB8f6+7du2m7hfv37+uP//iP\n", + "9dprr6ler6etF2ifB7j1ej0x5dvb26mehQ0LY+EpOsGqzqOjI7Xb7UI9yuHhYSpQBwhhDwGFnoql\n", + "b5k3/rcHmnGOeHG6v7xzFUiNjDhz0Oc03w2HwwQIV8nawcmqaJJNa3BMdAAdSt7R99mIOXBfT01n\n", + "Yhhx0MPhUL1eLympOwOuNR6Pk5ITAbLja7VaTecDlDzSY2ICiNrttp555pn0Tp7r16/r2rVrmkwm\n", + "+s53vpNQLytnWKNOesXz5+QiDw8PUx945MizMglQVq4Jc0TKJ8/zlPd0gOMvIkRZMUDObnku08Gg\n", + "VCzQ4v84/u6AmQyMG5PQoxPuzTLuq2TEPyoQcXEn7RGNf+8GpUwwNN4nGPoYqbkzdEeBzsQVI+ga\n", + "bCJtxOiwm+y7776rF198UdevX9f+/n7STSJBzvWi2Pl8rna7XajLQhecKfE5DdChpspTIjgqvwfP\n", + "5IbYDbvLZYCLsyM+Vt6fMU3jUWaZHjgI59UA6xR3XogDAkCD70Lq5zmblWVZYkH4H/DiG08ylgBc\n", + "D1xY+cJxpLG9MJ9xrVQqaZ8plu26ffO+JcVMbcWNGzf01ltv6fbt23rjjTf03HPP6eHDh+r3+3r4\n", + "8KF6vV4BRJ2cnCQQ5Kzlzs6OHj16lEAMthpdRtc5j+fZ3d1N/cfxb775pnZ3dzUYDNTtdlMQQNvp\n", + "S57d7UkEc4xfzD4wPtw7BkfYBNh8AmBshjOoi8UilSLgQ1khe5GdvBLgRDpPZUMVoZDecZ5KIOXi\n", + "UT7OHHCQZVlSQOiuo6Oj9NnBwUFqA/uXgFIlJVTtkSPpHKebmSgOFKTlAKE8eZ7r1q1bunv3rp5+\n", + "+mm9++67eu655/T2228n2hBFopaFNtBPtVpNn/nMZ3R6eqqDg4OU+sG4O4iAYaIynPbwHhNyo3me\n", + "azAYaD4/2z3R33SJcXVQUubcpCUDwuf0mdfxOCDxFRmkthh3vvNxB7iyz8H+/r76/X4hPbdOicVf\n", + "UXj+mMZySjTWPMVjPOLw6BqDzrWjM3FnKZ1n9kif8T15dahmZ1PcKANWtra2dHx8rKefflrb29sa\n", + "DodpGSdOixefsVkVhpPrEyT0er1CatB1340gTs2fqdFopP0hKGCMYxMNLp99FHAZAUYZ4PAl2D5n\n", + "vJ8d4DN+6MBwOLwwwvwkxB0tvyOY4ofniCCS60hnzs8jZ9e76Fh5fk/N+EaRnEtRtYMeBzr4Ed+b\n", + "BL0m6CMAbLVa2tvbS6vLHjx4oPv376clvF/60pf0W7/1W3rxxRcLgB8g7Xat2Wzq61//evIXtVpN\n", + "O7tsnBgAACAASURBVDs7unbtWkGXnfEg6OY53WYSrPtKTEmp/ZGlcxbSg3fsjAeWUnFDRw9IPbD0\n", + "NB1tYMsBSeeuSWDMpnHb29sp6F0lawEnh4eH6Y29TmlJZw9OjhADy+C4USbXhXKhfOTDYDF8tUee\n", + "50nx/B6wGjgG1q+DtGkbqN5Xk3hBZ7PZTO1i0pAWIl+5u7uryWSip556Srdu3VKe5/rGN76hV199\n", + "NTEhGEicsG9RvL29reeee05PPfVU2iL84cOHOjg40DvvvJNYGi9clJQAGn06nU7V6XS0s7OT6l7o\n", + "P69TcSqdAkP6pSzKZMJzz0qlkgxGs9lMfQQAZCKgtFyHQjUHOCcnJ2l1Eud6cTFb+q9bYgSN4Mil\n", + "8++J8sjaDQmfx4nu7BjAZLFYLjnEgMT8sUf50SHyN4YLA+ibSmFAY5tY4k4kR8rxxRdf1B//8R/r\n", + "+eefT5sOOqMYgRjOodfr6eTkRKPRSLdu3Upvo+W5HESg4x7FM0/j/j7+3FzPo2g+9/SE9xvnlElZ\n", + "H0tKqV7GyW2e972L2x2PRNclOzs7CWhGUIJN9b6LKSv6nufyMWDuR+BAWkY606+jo6MEWEl90AYi\n", + "fVgWZ3F9/B1E4VjRl8VikcCyAxnY2Z2dnWSb3n777bQNA/bLyxB4Zkn65je/qdPTU/3ET/yE/t7f\n", + "+3u6detW6qNnn322MPeY217/B0hpNBr60z/907QCk5dy0q+k1bgOwV2/30/z2Df29BU39LkXtLo+\n", + "e/qH7/GdtN0XQdAmlj870Gb7C16HskrWAk4Gg4FOTk4K0bm0ZExgC6SlU3KEiZMEnKCY5Jw5l85j\n", + "kOmkavVsKTDvVvCqbpBirPp3qtKdPk7CC0zpcAykU8kffvihXnjhBd27d09PPfWUsizTF7/4xULa\n", + "hAnJczJxms2mrl27phdffFH37t3TM888oxs3bqT2fPDBBwkY0RaPEpm49OnNmzd148aNtINhr9cr\n", + "MBNeGAZoIZ3FVsxx1ZKnxqjNcYbLAYhTmp6qAhy6k6xWq0kvYIFY6QRrRL+tUzzyLUvXSOdXmrhE\n", + "x8k1/douXksiKekyRgrn65FPZAn8mk6FM6e4j7fHDSnXbrfbevrpp3Xnzh3t7e2pWj1b+s7qCF+m\n", + "7sCHe3o+/s0331Sj0UhzBeDuTtpXAEUn79vnOxPhgM/ZO4yug3f6M/a5j0MZAI2sGHOOKNiP9fnp\n", + "TjWCkcsyOd8rabVaqtfrOj4+PrdZI4GMs9e+ygqnzzi7HvEdNsOvQf/AbDiwdSAdGXW+YwxwwlKx\n", + "9kJa6rUDAvTy6OhI/X5fr7zyij744AM999xzOjk50Y0bN3Tnzh299tprGo1GhTe5+7Pmea7Dw0O9\n", + "++67unnzpn7zN39TjUZDOzs7SQ+w8bQNn0NJAv6KawLO8Ce+pBow4i+dBbQA5lh15N87MHFGPLKo\n", + "+AY+A0iyRQD3935mXBgTFkPwve+iHmUt4GQ4HCZFu379emHpFvtoOI3ra8Sl5YubcIiSEhrDsXGc\n", + "Kz3Rvnc+CuBK71G9O1sMPwrBdWLxEeyJ5y4p5vzggw/U7/d1eHiowWCQHOvt27fTLrXxWaWzAe71\n", + "enr55Zc1nU71kz/5k6pUKnrnnXdS5TdKAENBPzJhvU30zXA41OnpaaK9URb2MolAkLTLeDxOb+ck\n", + "5+n7VDDJPDVE7Q59DPihXUQibDaH4/IIObIJTAqe6SpJWR2B051OkyORSXSJDiqCFa4VDUMZMFnV\n", + "Vj/ewQ3O2hkEDBXOd3t7W2+88Yb29vaSsWcDtP39/TRHfG5xLwBvv9/XvXv31Gg09Nxzz+n+/ftp\n", + "jwneiuz9ik4Q1TGXmQ8+F2OqzOt6Yt+UgZgI5Lw/0EdPffnqOMCX0/dRygCPB2XrFBwPAaTXMuFU\n", + "HRB4wEefABKwCW5b6ZcsyxKIc9tdqVTSHh9E5d6HjD22wPXfN5ZE//J8udmls/bOumVZpsPDQ3U6\n", + "He3u7qZnPzk50ec+97kUMHmNIcEVYOrevXtpB1l05Pnnn9e3v/1tzefztPs2/s7BBH3sATzXp68J\n", + "ADkX2x/HzmsVve98paf7Bc6hPV73A6gA/JOF4NrOurhvl4rbgpQFWy5rASdEuFmWqdfrJVQuLfNm\n", + "vkTYKWyUeDKZJOcLymTSewEP/7M9MMp9eHhYeHcLRs4jQo9ypOWyYlJADDaoVVoCKUfznh7Jskxv\n", + "vPGG+v2+jo+PU3+88847kpTe7grFTd1JvX72cqi9vb20E+3W1pb+6I/+SC+++GIaZIpcSZ94eqTZ\n", + "bOro6KhQIU50QF9KS+p8PB4XwAypJgwudTA4Mq8bQNygwWp5HRB7A/AzHo/V6/VS9EKbvAiLZ/XU\n", + "0kepE/ikJLbJUxBScQlvrFPx1BDXKQM6fh83Ur40153mqjQGOhvb68CbucP/njqp1c5eJb+zs5Mi\n", + "OgD/cDgs1ELhgHz+MEcBQq1WS7u7u3r48GEynnEHWq878P7yfo4MqEfmHj171B6Bg+t0HBPEU20I\n", + "KVDf6BHH6mwWoCfeAwdVdu1PWtxGEpljRxz0uZ65TSA1ApChaDSu2PCUEA6+Xq/r2rVr6V4OSLEt\n", + "3D/+po85F7uCA+Y47DTPStuuX7+u8Xic3meDHt69ezc9J2CEZ6fG6tGjR9rd3dU777yja9eupdTP\n", + "7//+7+uFF17QYnFW18hqS1+4gH7GeU4hOS+ZrVQqhb+jfkYGhGt5RoD54+DOQYikQhDCcxIQYMPd\n", + "fpWlr2P9EZ+tkrWAE2coACpQtDj9GEWQi3bDyOez2UyPHj1KqM/BCdfFiI1Go7SMyZXcgQmgyGlt\n", + "lBCA4imjWENB2gRFc6qc9elHR0c6ODhIwGNnZyetNvDVOkQagK8HDx6o3W7r/fff1+3bt/XjP/7j\n", + "ev/991NOdjAYKMuyVOXtyyo9lZJlZ8W/g8EgLYEjvQMAo/LcJwoK6n0DuHQAwSTFMPlvV243OIwr\n", + "+wAgtN0NeJk+rTsvLxXTaDEi98/8WSJ7EqlnruHGir50sOZO39sirY5SympfPLWAcfJnwYFznLMD\n", + "fo0sy9JSSNKCFHsDdKncr1arOjo60tNPP63xeKxGo6G7d++eCy78uZi3MYVGP3hhtqcSor5EnXIw\n", + "EMeJzznfr+MADhDiu9cSnfLcTplHBsb70VMX6xJAgDtx1ynG3qNi9NidEscDcHwlJud7bU6tVtPe\n", + "3l4BTDrA9nbxP/3lNgv7AsPR6/VSG7HTjI8X2mIfSdfgY2Dy+v1+quPwFDXB3s7Ojj772c9qMBjo\n", + "+eefV7VaTanoz3/+8ymI4EdSAvn0G5/DzMCOHx8fazabpTovfAdsPMDcwTf+JAbf2GGvtyGAdH/o\n", + "LAzj5sCFQILxYX6UpSk9iC+TtYATBh7QgEL6qg06F4X0CIKHAmGChH0vD2db6CAKX0kr8T3O1pc6\n", + "+YRxx8jkigW7pKN8MnB9KN1a7WzXQFYKsawMNAy74bsK8pykTv7gD/5AL7/8csrns4x4f38/7emw\n", + "WJwVbXU6nbSMMoItwANMyt7eXlIi9nSRzvZQ2dnZKeRDmeBEyETFHhECcHxnV4CcGxlfukzbvDYF\n", + "J8bfkd5m/KKDX5d4e5yVkFYXyl4kXkgZNz6L1/I0hTs39Bew4QyUzxXO8+8jEHHn4REqlfcYSKem\n", + "qYHxqJe0j9PxN2/e1Lvvvps2BORzVv0Afn0Vnb9i3qM5jwi9H2BmGCdSiHGJpfdtGauBrAI6ztT4\n", + "MQ5guJ+nbiNIiX+vSzwFE/eNwcZKSzbTwYY7X5/XOEoK5r0ImFUcDnqd8fDI3NORzjL6XPE5OJ/P\n", + "UyCGnjrDg83BrhFwYl99bjx48EC7u7vpGjwLYz+fz/WZz3xG+/v7mk6XL4P9whe+oDzPE8AAiNE/\n", + "vAzQnw2bzbt4YJmcjeRZASj+PePEPRxs4acoMuY85pzbfknn5rKPNWPp9i8GWj4/VslawInvnueG\n", + "xYFJGXXqA056wEEOSND3+kCR3aFyHQAAhXh+X2lJZflqmZjPzLIsGVNpSdsSFUhKSNcpN/ZlQMko\n", + "ZKI/eDZPZQEa/uRP/kSdTke3bt1KTMP9+/dTbQsRG+DAl4L69UHGrIrgGTDcgDloWJxFrMZnHKEp\n", + "uf7JyUkyAgAsj064B32M+OR3xF3GZhHZew58neJRfFma6UnAxIEt/eJOCpr6IpqfsfHUgVO1fkx0\n", + "xDggDwrQZ8CGM13OdFYqZzsmV6vVtJLAa46cSYyMB/rNNuLsA1SpVBIAB+TTfoCGR2fohzNN6BI1\n", + "Aqy6q1arhSJqgIKPW4zI0X2eqQxExH6WlrUOOFokAs1o5CMYX5f4/MLmOiNEu2PahWfF/knLmkEc\n", + "PfVxbu+d0ZBUGNcY+EnLlEEMSr0WBpBB+3G0jCO+AYaClYGVytmGlzdv3iwEWKPRSN1uN6UrmXOw\n", + "4YzjdDrV7u6uJKXNMg8PD5MP8PS2z1X6LabK8jxPzA/PDcPTaDS0vb2d7uX1MzwrYzifzwt9IC33\n", + "BcLfuT1wEoH/GUfGlWs7uPG6k2q1mlhUGJpVsva3ErtSoFxMBI8u3EjCVETamS3pSWc4clxVVBYN\n", + "s1NdKLFHrtwrFvr48lnAENFfrKEhHzkYDJTnZxXdvV5P0nLrfSYTO2iiYL4Py3vvvZeQ9M2bN5Mj\n", + "kpZFuR6NlTl3BxEYhF6vlybmaDTS/fv3tb29XQAobiAc2HlkSyrMDZFTrCg3zoPr+P4X3tdetEVf\n", + "Y9x4tqsi0WHFtNSTGJRI9/s5MZ0jFd9p4oYsRiZlxsANl+sKgrF0YOtACbbOHQIggLdYR8AFa+JR\n", + "lxt01wFfAk/huzMS3NeBHM8VozYMa+w/N7re/3EMo5P2Yz1S538PqHxO+nX529Mg9DMOZN3g22l6\n", + "xt37SyruCM24eMqEMaNPsHXoj5/vTpPxhpGDVYhMatRtricVC5xdfxCCOWfZ8SXT6VR7e3uJvWZM\n", + "FotFes8PO2wDZggQfT76LtaAVH+1gz87eoHNi6k9mBJqFKln4d6wW9hfn9c8H3PV3xbOPKxUKikQ\n", + "8HStM1OrBEDjY4feeLqU41bJWsAJnc2EhGrG6WI8fJJiDCWd25QMFO+Rm6cPnC3BAHA/irToLCYV\n", + "9wdBOoKXllXgEZHSdugx2tjr9dK1BoOBjo+PE8KG/bh586Y6nY4ePnxYOBZAEukzwA8Tl36JhhUA\n", + "gALGaJBCVO/b7e1t7e3t6eDgQPP5PBXHQoU6TY0TAdy5UXDAhxFytgxWx8GJR0keaXp7eX6nES9C\n", + "4Z+UuBFELprIUSJbJJ1/s+0qwOKfScs3iK5ybPRbDAa4Btf2JbBu5AAtrEIBqABG/T1P0PEYdliQ\n", + "Xq9XqE3ytIu03IAMBsaZEGeDPKqkfRzvDp95QHvd4HqUGMfRDaz3v38fI0dnr6Rlca6PR9QNT/M4\n", + "UFo3g+JpLwcW0vll3P4bJ+6BCc/o6S4Hv4wNfcr40gb00VkWqViXJRXfVs33UnG3agIb9JR24qBP\n", + "T0+1t7eXtlngOo1GQ7dv39brr7+u/f39VPB6dHSkGzduqFo9qy1xANrpdDQYDBJL7bUd9BUCs+CB\n", + "M0wxesk2DrVaLe1Bc3BwUNjw0H0b+o3v9D5xPeWa3u/O6tCvzD/muzM+HhhH9tv16coxJzjLSL/i\n", + "nGIEIhVrD1xhMWieciCSosNw7K6UODnqPpgYbiS5L2jWQZTTrjAbOHDOZ4DzPE9AZDAY6IMPPijs\n", + "epjnuR49eqR79+7ps5/9rCQlULK9va379++nTa24P2iZ/SN8Z77FYlmvg1NwFoq+caBANIRytVqt\n", + "tEmb061MEKdtuT6GiB8fR0CTT1ZJ54wubfA+lnTu7zIHcVVkVdtWRQn+bBGARKcbrxmdm/c5feuG\n", + "J7anjKGJ90GnAKZHR0ep4I8NnlgOyXujYCJ4Jwg7DwOo0V/moVR8W3GsL0BnKVb06BtjylxyGpr/\n", + "eX6Oc3DtDnMVEPC8vDNXXM/ZFe8/Z8oceDqA9PtFVsyPW6fEqJ05T6rWAa7bRbcdnBtBh7O5UjHy\n", + "duZsNjtb/dRqtXR0dFQAks6GeK1RTEtij2EPSN/Qxvl8+cJKnmkwGBRqMQiMRqORXnvtNb3xxhtJ\n", + "927cuKFWq5U2t/SxJRUEsOd+tVotMYX0dSyYxm85AHAbycaLgBQfg8iWOwHA3OZ/dNnvKS2DEfoQ\n", + "8OH2nftFW+L1pD7O3HuVrAWc+EYukRKlvsNzmihZZFK8M1FAf5WzU74cB9BAIdjVj9xejJZQIpCu\n", + "TzofePLsvkS51Wqp1WppNBoltOr7L6BsTJZ3331X9Xo9FVgdHBwoz8+KpmiT/87zs132vEAQEMVq\n", + "IZ4dytInoeeH3TjPZrNEx+OQMA5EgyihOwJfigzoi5PAxwaaDxTN94A6Z4uYuF6z4LR9BD1XRdAh\n", + "f2Y+p71OPUcmQDq/gsMlRj5+fcakbHUF142fex9iqGOhYLVaTcvP2cyvWq3q3r176vf7Ojo6SjrJ\n", + "Pjq9Xi+9UG2xWKQ3rjLGtNXtwNbWVnp7baz5oo+IfD2v7oAOI+0sCc/moA1b43Pe+8aPpY9wys6y\n", + "uPGNQMZtEp9H4FlWa8GcW6fQZrd/6IKDQ0kFQMnYOVsCoAF0RLbUI3ie28fJAUbZnOA8Uv9ScYVX\n", + "s9ksFEKz1B0fwsaBW1tbGg6HevbZZzWdTgsgxdP0165d0/7+frKXnU4nvRIFPwbIcp8Vi2djKpvg\n", + "2hkKntltB8ujfUECfYY98eDE2RrYfx8vjvc+4/oRfNBeBzi0i/s7K+ZgO86XKGtjTtyxz+fzQtW2\n", + "VESKjpy9aphruJOD6pJUMEpc2wfG84uei445tYg2uS9g4OHDh2kSOfU4mUzU7XZ169YtvfHGG2mv\n", + "Ekn6zGc+k9iRbrebjPC9e/fS1sS1Wi1tXuXbM/tkd+fjL5Ki3UwI0jYYB/o3rohiZcVsNkvUom+l\n", + "7JMD5XblZFkdq3hwUp4C86JZ71s3Sp739PF0AyktAVkcs3VJdPKuz25M/bhoQCNo4btV0bl0nh5l\n", + "bDnGjRbihsIpeNJ3vlcJ+XY3thRwP3z4UJK0t7en09NTdTqdlDqpVCppTpIfJ5XnYBrwyfPgPHyT\n", + "LEmJCseAx1oOB9/SMmdf1keMh3/nDKC3hz6NEagzI+hxGfsbGZCY3vEINdbo+NxYl7hDon/c4fDs\n", + "/I/d9a0MfBx4Lq8n4hxsvbPP9CkLCLyuzZ2wdH7HX28XAIAl7thdtm9gkUKj0dD+/r4k6dGjR6rX\n", + "6wmQE6xRb+JgzVffUKOHTtRqNe3u7iaGnT4YjUYFfwg75G33ue86689JcI5fYe54Gh4g7zrqdjwC\n", + "brdBTg5gbxkzacnqe8rG/XScKzzXKlkLOHGnifHDwdCB0hJ9oYBS8eVkXiCJkSK941E4g+ab9XgE\n", + "JamwBS/3ccVgUBlY8ovNZjNVXAOQ+Pv09FT7+/vq9Xp6/vnndXh4qHq9rldffVX3798vOKlr166d\n", + "c2i8kA/Q4I45y7JElbfb7aSATFwHH4eHhwVFZsLwjBgC/uYdNlSTO4JfLBZpySh9xfcYLU/heH7S\n", + "iyDdALtyM76wWTESiCk9ZxWugpSxHU5rXnRsBB9lkWFkVFaJ1zfECB7x6IbrAVIYY/TGgTuAFkYE\n", + "VnBrayuttpGW0VG1Wk10tjMisB6ka6Ix9JUKDl4crMb+jfrggYszbG4cI5CINTrOfnkEHEEmx0WQ\n", + "HO/BuT4HYnqHc5wRWqe4vZCWO8A6ve/94cDP0+jOlKJTETjH1IuDE2dfsCWeUpCKK85YUFCr1dLL\n", + "Wre3twsBEuc1Gg0dHx+rXq8X3gR9+/Ztvf/++3r06FEBCACw0V1W4jA/RqNRWvlCehMg5PtgbW1t\n", + "JRYSVsmDLfeX0tJ/YbO5Hz6xWq0WXtsCWxkzD9gH37CR8cOHon8UIMcgC10ASPKeOXwRUsYyogOr\n", + "ZG37nPiD4vCgkF25XBkciNAhoFhp2bFujJwa9E3c3MgNh8M0CHQqiukGg1VC0lmn7uzsFKqc+Z3n\n", + "edrpFGaFHQ7v3r2rra0tLRaLtMxXUlJaUkHsporx95c8eRTi+wGs6ueYSqDGhueNNCAgBYDlG+/4\n", + "e3C8z1E6JqOn7ubzeWJAIgXuQJRaBCYxoIu2eWqOcUFHrgpzQt+5I+SZ6cMYNayKJDwalIqbfEXx\n", + "z9xISyqMb2QSYrqC6JT5546BOUg+3PPTpBiHw6GGw2GqLYFBAWiiP6Q7+S0pGVfvv/F4rH6/n95h\n", + "gpPziG1VSoZ2OTChH/jfdTCCOAdlZaxIHDdnbvyzOM5x/CJb48/gAGyd4u8gw+ETwDAenl5jLB18\n", + "8JuUr1TcFM/HCGE+sacN4JAxdb30FJCDKXSM4+PeSp1OJ62aIbj88MMPtbu7q62tLX3ta1/TrVu3\n", + "0rmw4pJSMMg29Owe3u1203j7bsjUB2IXqtWqhsNh6jMWaNB+T/14qs9tOyDX57mkBOzcVjtjg067\n", + "jvoSXx8Tgvsy4M1LCambgc1nVV7Ue59zF8lawInvM+Bpm0ajUaie9sLLsvfZkKP2yCvStC44CC+U\n", + "hZr2NeG+PTMKxKQAuaPcPMvJyUnaVZUUFe8LoYBrPB7rxo0b6e2tktJeEN1uN+Xnh8NhMug7Ozs6\n", + "Pj5OeVFpiWpB+L7k0tNhtElaGnAmOIjb2QsUDwTvyl6v19XpdAoOwDcwos/5ATgywbiH9yPiY0VE\n", + "Tr97FMwKEHcEPsGugrgRZkLzf5zYZcyJS3SAq6Jov04EM4ALqbgMNBoymDf0JdKwgHbmXHzeVqul\n", + "Dz74IL1SHjDqG3b5VvPT6TSlf3ye43iYn/V6PRXPkmZicyrmIYYvpgf4G/EAIj6jU/8OTOh3ZwEc\n", + "lHlfenTv4xL7mZo0HIuDHwf+Mehap9C/9A1stKf+vL0cTx9iE7Ar9JWkBGCRCMqjA/UFAdjCyWRy\n", + "Lk1HX1IDRSBHaob9R3hJJMCh1WolJvvOnTt69tlnNZ/PdXh4mBgVxo3/YZjRDYI66Txopm0wLfg8\n", + "Ns2MfYg9Rkcig0UfMReYK/Szv0gWYOh22hkVabnSxus8AdBxPJ3d8nHDtwBY6Qc+KwPpUdYCTqDZ\n", + "JKVcHyCFKB2D6KkWAIhU3OwKB+YdhtGMBt1pas7tdrvKsixVOns1P9dhMvlyL2n5ojxPGfkSNopT\n", + "JWl7ezvlOgEH0OC+pT4reaSzHVo93eXGAWPPM/veJExgULojXGdImDhcH6ViddBkMkm5WIq04hj6\n", + "WABkHGUTRftEig6AZ4IxidG8O3oU2yNZANdVkRgtSuep+yhlKZwYua86DvE+8VQEuhxpWfTMUznR\n", + "2fr3jJFveLhYLNKS806nk/LdUnEHVc5lHCeTSdqBk/s5a0nE65/hAHwjQHQJ48lz+1x3wwlL4cDN\n", + "wa6ncbxvPUjiHHeiDubKxgZg7sytAypnspxxuwriAQK1dLQTe1nGbkvFeitsss8NZ6h8IUQMeqRi\n", + "ioi0s9sQrjObzdLeH6xo9IAzyzJ1u109ePBAe3t7qlQq6R06bg9feeWVtIs2tXgAHXS92WwmsEKK\n", + "pl6vF5hfdM7rIt1e8a4hxNlhDyI9+HQd53t8J+3xNwAzv7wfuY6ngRijWMTq7XW2DIbTx9uZc/df\n", + "zNPoh8tkbe/WibQpoABE7lQW7ABRB+I5LxQZWhjUCPJkwJzKRcG9AIlIgJUmGHTPlznNCqhibxBW\n", + "6zDwi8WiMNC0FWfNJGYwKVyl2Orhw4fpGWBjuHae5+lzvx4/kbFwSjwiWJTIlYX7zefz1E84E4/W\n", + "PYqEzkVR6TeiXQdGPqG4BnsDuPPwqAFGiWdkEse6gXUJho+2EaWUAQOpCABo/yomxK/v/3Ms14hR\n", + "KDpW5ugwth7N+zWYCzgg3/PEi/Yo4KZNkWL3dgJoJKW5yT1dt5zFZM44W+JGjzw+OuL9A1PjdW2S\n", + "ClF8ZEK8HoR2O5DzovR4jKfDfIz82Jju4V5loOgqiI8Pv9FlZ00iw+ERt4N0T62hz85QY68BzFyH\n", + "H+wS4IAxZgxarZYGg0EK7tBdauV4v40Hj9h1d8osB+Y3vsB1GBsPoOR1Hw64uJ7Pf+pQXNccIPtq\n", + "Jvc9jIEHKwjLo6lpwUc4+0eb+d83yvQNNj3odFvk4A0ggg13sOl2niADPbiMfq91h1iPpjwv5XlE\n", + "R7t0nDtTouroYOkofz03n3M9nL60fK00gMVTFgy4p3VgGRaLRTKwvmLA8+DVajVRbTgBR6m+Ex/f\n", + "ocikijAAfn8iOc7BaDD4kcZG+RAHiLSZ+9Bfk8kk9QfGn70saI9PHNrRbDYLbxyFvvT35nik6Xl8\n", + "3/DLz3fnTQTtOdSrIPSDRxXO8pQdy3HovQMN71eu5UbGgbK0HGscLN+5YXO2yYtmnVlwY0X0NZ/P\n", + "NRgMUlQGeJWUisK97RhmB2c+T7y93g/+bMxXH3//m2LY0WhUqC1xI++6Tduk4kZRzsgSLETG1QOT\n", + "uKLHGVVPzfhY8T8GOqaEfJykYsooXueTllj7h02i/7yo3leHEPU7uyGp8L4lAlNsrgNP9MVX7bju\n", + "uG/w8SY9E+0S7aDGER3FefIc6CO6AJvr15OKWxugq7GepowlcJCBfnuQQiDpab+YHo6AnTQ/fQNo\n", + "gBViVZBvN+/Pw/3cV8KEO1sjLQNKxsrnegw0fK56DSHtXKlzH19dP754wV2WZYnmipMRxZSWyL0s\n", + "QqZjSItADeK8iJDcOLkT8S2Hm81mSrG4gfFIwRkRZx74n8EkDeWokgGMlcuR+WEQXRH9f8Rpc56R\n", + "6Nap1LhduAM5Z1K4FudT4EU/kB/mfUKeanOnkGXFF1kxfl5T5BEWz04/k7LCAMUlpYwN11238Ubc\n", + "kESn5SmasvZG50xfer846EXnoqDzzB1pmTLhezc+buydHWCZZdQbfmq1mvr9fgGUuPPl/1V95IDa\n", + "v3M99M/cGdIGdBDw7xGbp3hoB/dCP7FF3g5/YWUE3/7b03T8HR1QZFcisKKdPiel4ovVvN3raEGS\n", + "pgAAIABJREFUEuYfOoWjY+7hFLFxMaXIc7vN8fPdPsLUuf1H1+NCBwIplu3CqMR30jhw4l7MHfaK\n", + "4jgKZrvdbqon9OJenyN5nqe0oxfs4icc8MegDNvmPs1ZE0mpXoQ5SDtInTqL5Wwec6GMnfZaEvqF\n", + "a/OsnONMErruQNPtugP7arV6Ljhl7Dz4vojtXtsmbBhQImqMDBMZA+FpgIi+fVAADCBmIj6AB6DF\n", + "Iylyhp4CYrAoZGXwcdbSkipHwZm4IFSWXcEuOP3pyuD35TiUAQVjsnqE6cyPVKTOPZJ2cFWpVAoT\n", + "FmTNMzu4AszQZnKqCCkj+seNsOeJiaAcvHj6KU5OnsmL2zyCANjE/iPHexUAikfgGBFfpRP7wh2c\n", + "gxY3ZO6YHKwg8RjG1j/HaDImGChPM3r6h4jJ2+eGEPBf1k7GmPb6/PXjI0j36MxXDXCver2eVo24\n", + "rrdarcTuuX57ZB3bGZkVdC8CyAgm/VoYbx8bd8gRUHgwJC1XEjEHGLtVY79OcWYPXUJfcHxeS8PY\n", + "8DzuyLxQlN9uw6NDo3+4L6llUjXMCZhexJkIB03YUk89S8tdrLkvb8L2FSfoFHtKAQDKarK8VlIq\n", + "roZ0fVsF5F2/ou9zJsn/pw95fxvPCHhykIjQj/ge/57r8lzYA/wm53JdHyufzx50xA1IV8naCmLd\n", + "ueR5nhz6YrFIqNEpTwwSkmVZWmeP0vmD+rIwruP0oOfGJKVrcV+Mna8SKGMayiIbb6+DBaedI2vi\n", + "LIykhEZjJbz3gVNmOATahIPneXgmz5W6o/eoBkq7Uqmk1RL9fr/w9s08z1OKhvMYPxQYw4XS4yic\n", + "uYpLAgeDQRpfn/yc646ZtkoqGPh1igM1npHCT09XuQNy9sJZCeYGn3sfl9GhTqdKq2sjPJqi3zyF\n", + "Kp1/10aZvsc2u+PiHjgPJBpH12HqB4h8eU5nZnxHWHSGueoAnWvHokwXn2+AaS+gj88YgYrn8f0Z\n", + "GSPvQ9oQmRhnsSLLEHVlnRJTVWyoh91y5xMdkqTCSkJ0xAE0feHpIbf5zt5Jy8JQCmIJUNyeuZ9B\n", + "fBWig3P+Z+yxvXxPigib5n4gjqvrBXMqgk/XG19aTTvoczZDlIqr75xB4rquv6RiB4PBOcaDWjHv\n", + "a+y2tFzN5Asg0EkCU56XdlDX4sGur4p1RpB+ATCukrUtJfbohY4hx+1gwzsFhfV8l0d50nJDGAwc\n", + "gpIy4DG/V6vVNBgMCq95j4Yalod2OdvAPaRiLUe8B4ZVWg44QMKRsCNyd9DOyHBPJgvHMbH8PlzX\n", + "t12ODs8/Y4L5tsVUmvNMTh/6TpCMQzQuDv5wJEQlzgShA05h8uxMTO9n2uxGaF0SGQSPNBy4SOVv\n", + "UeUa8Vox4nc63A2Ui4N/9IiIDgDh0Zm329uBOEvAvQFA7jSkJSiBAfHAwJ895viZNwASoiyKILk3\n", + "x0Clk250IOXsm7fN54Pbm1g0uEqnIliIgQnX8HP9uh69u464M4y6sm7g7eOEbQag+J5Q7vwdHAOc\n", + "eU7pvL3kPogHMP45fzsTjaDPnlrxrd1h5Pk/6hU/vgmhrxQ8OTnR9vZ2wT5LZ2kuavF8rLmH2zi3\n", + "afV6Xd1uV4PBIPlFr3dy4O9MC3rt98MudDqdtGqIOj8YqzhPOY/+5B7uv7DVkgrZDQelPA/j6syS\n", + "B7xcz9N1q2Qt4ITB9j0TcD7tdjtF6OwqGY2Eb5kund811iMPp3opPHUWxB0dvwEwoMR6vZ4oMe5N\n", + "u9iYDeOGOHCJkZgrlztekCfRo2+6xoTjuVFEEDxGnEI1p1g5hr5zytqNdyw8zPOzzeQePnyoTqeT\n", + "HAHH0g6MPffxqJjP3KA46IvgSzqLWlBu0mZs1OW0phv46EjXJZHWjnSrR/YxdSAVNyh0NjBOYhya\n", + "j188zh1bo9FI+yq4XnhaLTpWxo/reg0Q18Wh8wzM6bgB0//X3rsst5UkWbsLAEmRBAHwJqWUWdWV\n", + "1tWTfv8n6KfoQVn34M+bUuIFd1IkAfwDnC/2t0PMLLNj5xQ0QJjJKInA3nHxcF++3MPDFSedP2SA\n", + "ZS/aawrz1O/3SxzbwGiz2bRqqyRt4MdaeK5gpkxPO/ZfP8PsksHFH7ErfrcdjtqLtJPh9ah13q6B\n", + "NwYeNhp9C8NVMyteU+bfOjtpwLMBODqM37umTdIYa2TIR2UpZlY7XDyXd3gPAhD4LH848eIj8bDZ\n", + "DlkQ0mB+fHmlHVL67nckKaXsOfbc7XZbzqVrkliOXhunGWhOoM5ms9Lvbre5kbjeJ3X4iDVljMwX\n", + "JIDzfBySS1JspfNvWCPbSDM/r7WdaHQvMoM3q1CfisEzB3ERTsAAsxHIjUAQ2TAUtzGFZMPJBJ2d\n", + "nZX8l36/Xyoh2vMyg2H2wErKeSwgYRKr8PD4ztPTU6mySAljPkfNEo4L2xOmP4yXOeBGTeaUeaDP\n", + "Dw8PBRB5bGYzrGxfXl5KP3w6iWqIZk34bg06WHMSz9wvmBfmAaXHJgNUoqyRAZR4zYLtutVMRu35\n", + "Whnz7yRfzXud52HPmTnCGwGovDZ+5Nx1CFCeNCs++vAa4PNaJm2AlDT33hj0o+A8J8iKn2slxak2\n", + "Pn9yclL2AUmAlrsk5Qh+rXx5fu1ho18Mcl+rgHl8fNyioL0W9kLt3Lj58wbodlK8tn6WDem3AL7R\n", + "WYBCQjM4R97vSZPDAYiBMcDJS/KV0TXQdTi4Ds8kzUlHDOlisSg6CSDFu10MkD2BXMDq8Zk6x8S2\n", + "ijASjjQ2BEMNMOD72AuD76enpzw8PBRZTtp6AXC22Wwyn89LH2zMnVeIDPH7N2/elL1hvXx0dJTR\n", + "aFTGAJAycDR7yPqxzn/E0hpw+N9mtW0b2aP/TK53VueEY08gK9e3cF0SAAAG6+npKdPpNOv1ulQs\n", + "ZaPUNSUwZISLzs7OSpYzjAqTzh+U1dHRUTmJwIQiyPZoLXQII5vYpdwpve1iQNQyeXl5KQAFRoLv\n", + "wcrwHkJOvIt5dFIXmw+BhP1J0nqH45ZG1QgUz5xOpzk/P28J2ePjY2azWZ6enjIcDnN+fp71et1K\n", + "nvXcYGS73W7rWB7CbwOCEUC54MXYCyGc5Qx5NvUuG2trg1MbLCsuFL2ZBeTc+TU1yIGVIV7Nv2tF\n", + "mDSxdeYfZez+ITNWenVYhL/zDgMiG56kfW8PFZOdkGgDTR/t/dkTwxDQDLapMkuf2Nf2DP13jwnZ\n", + "r6lz5srsJ+NzSJVx+99mof6o1QCIPtWsgvfOrpmTJEVP2dAAdCkmSbVVnEFARb/fLwwo+x02D6BS\n", + "s77r9bqUnTfbAEuctMOIhDCS9rUFNfBFv6NLkS2D6i9fvpRrRpbLZa6uropM8hnkhPpbNfOHTXO9\n", + "KOTW4aSk7dSwp7vdbgHHrgdk1sT7BjmCnTw5Ocl8Pi+OLxXHT05OMplMcnNz05qzpH3akJAnDBU6\n", + "hvA+TiLfc80YrrBIGt3FvDCPh4eHLSepbjsDJ574ZCsYGNnxeJzNZpPLy8si3NQxAG1x3Hc0GhXg\n", + "YqDB0baHh4c8Pj6Wd/GThQbM2Iv58uVLKXnsDYbi4nsg7ZeXpvy9lQiZ4wcHB+XoHUqOI7oGFe6P\n", + "6WcMCieGzs7OWhRqTf8yBhQlmdgYDJ6JoNTMkNfEXiVzBNC7u7vLr7/+mul0mm53W3wIBcM4UCIG\n", + "WoAK1gsFhDJxnxxSY3xsRjaRQeyu2x9R+vzbhgZAggwhn8yhPXkrINbQ+Sz1SYQ6xGAlyl4x2OTz\n", + "gBTLup9Jf/27mtIF9PtZHrdpaOaFOXD+FM9Ejvm+HRFocVdqNjjmfYy1VubIE+927ke32xydd3jC\n", + "xpN1dI6D2SSzZx6rw2ZmpAA2NnQY7F02+mWnxmDu5OSk6EHmnRwHHLGknXsDSLCjuNlsL5CELbPx\n", + "s2fPHwz+yclJzs/P8+nTp9Yx26Rx2JIU55c5RzfiGCFbHCN+fn4upzp7vV4rfGjGwCyecy+QRd/F\n", + "gzx6DyDvPAP9bfmAYa4TcutIgUMosNMAlZOTk1xdXSVJZrNZqVtkB9IOfpLC0iKP3l/IA7YQW8X8\n", + "AF49X0RLPFevtZ1whWx+aHl7cSic8XhcBskC4SENh8MMh8PWEd7VqrlLBmXJxXs8D8UEkkya0uos\n", + "MKeGxuNxJpNJoQWTtJAifcWzB+myeCjPpIkr1hvcFFfSgAH6b5qTRGDTlXjK9rIAPwgtxeWMuu2h\n", + "ooTdN97NZ0H7SQozcnx8nLdv36bb7eb29jY3Nzet9XXIis2MgDKPfKauycL6cImc69DYUHhc9jx2\n", + "2ezt160GkihaU7t16IJmNgQ5drGnOixDcwgCI85nbPBQTO67jSR9wuO0MeY7PplVZ+GbvXN+AuNE\n", + "OdrD5DPIH33BmD08PJS9S9+d7O3QsD3vmvVM2iEpzykOk/NsalYEQGSWqw4duBmk1YCtDg/VRmtX\n", + "DX2RNKG6pM2wOVmefY18T6fT3N3dFbYFAzUYDFqsno3ja/KNgfZckWuC00Qfa5as291eVUKpCYdf\n", + "er1eOQxh9psTm85XxBjzbOtwO5zot6QNPM0O8sz6WgSveT0OO5BmL+28UwWXiwTZU58/f87t7W26\n", + "3W2pfYAZc227UTvE2Ft0sKMF7NE3b95kMBgUAGXAn3wdOv0zhnFngcw6KZJNDyqHQkxSyqZbiK+v\n", + "r3N+ft6iwyeTSSsfBG+Iz2AUvdEx+izq8fFxCTsQwwQUWPGv19v7BObzeau0PIvFcSwotjphlf/D\n", + "IDmkwR/6zhxxN06tBJlPPsdcoezt7dGshO1N0hBmfgIUHh4eSp8uLi7y17/+Nf1+P9PpNLPZLN1u\n", + "t1C3vAcgAohbLBaZz+ctRsreODHT1WpVnlsjeoOUbwWYJG1vvQYMhAbxLpxMZm8cpW5g6rwaDJYr\n", + "nFo50uqN79CQmZmaQUNZ0+ekDRAwBniT3W63dd2D9xNj94kL9oUNM0oXAFMfc6bPprMJlRq48HuP\n", + "gfnzvvfnaGYjn56ecnp6WpISTbVbZ/Fun2pjvgzI6+e7ua9189h22XxhqHNBki04oKYUexjG2vkF\n", + "DpWdnp7m6uqqsBKsPaULADfowqRhnWqQjy6mUQeFPplhYAzIO8zYbDYrdznhdD48POTi4qKAT/ar\n", + "QxHdbrfkvbhMPEwQDig2xHuXk0113pMdSjMr7MWkCakh8wYz1jvuN3N/f3+fp6enDAaDXF9fp9PZ\n", + "5nWxh60XsFcHBwctsJM0ABBnEr3f6XQK6ERecLitr+wcvNZ2FtbxZgd0MLmj0agMCEOOUJHwZPT4\n", + "/Pyc33//PUnyl7/8pQgjSt7xTzMHbAh7qfwffSIhyRUQnaTFIq7X67LR7DX5hMFkMslqtc1AZzNZ\n", + "uSKwPMuCwTw4PJOkZexq0IJyt7CZ+UFIeL49EtOJvOf5+bnUSkHw/vrXv+bx8TH39/f56aefihJa\n", + "LBaFnnW+CRubSwl5tt+TbC88PDo6yu3tbbkIsd/vFwWDwtq1R1m31zxrxs66oBBZC5SUq7rWBjZp\n", + "19XguXg4VtoYdCt1+gZFmzQlyfnsa7kkSTs0MZ/Pi3d5cHDQOiHDM90Ps4T0l/+jnw41GiyjHLlo\n", + "jZMh9M2gFgVt1oI5qvd8zSYxDu+Hbreb2WyWwWBQQryLxSL9fr8YIxwI1sWAlHf/Eagw2GI9DF7M\n", + "JDhMtMtWM3cGl7PZrMiFQ8BJw1Cx9uSokMxeh/3MRtghxQ54jxAaShoGi/fBwjHXAN+kAcuup4Ms\n", + "wcqNRqOiE2FPfEKF77BnDIScFIr8O1xq+4EsJU3Yh/6anWD+HRZhHSzzjCFpcnHMIn769CmHh4cZ\n", + "jUa5vLwsfSbBl0rrOBrL5bLMk2WA9R0MBuWCWIAn+8x2nLlCJjzu19pOwAkCtlqtChVYK1KEyqEJ\n", + "FIizt1erVUHonHCBirWyQchNpTlWzqQjYBYSUDXvBlUT22SSqVdC4hdCMhwOC1PAM8zusMFchZZn\n", + "gtRr78tGi88yHtOKjq0naWWkW9hqmpaGEAKA5vN568TN8fFxfvzxxyTbGOZvv/1WhPPp6SlXV1dl\n", + "7lgLCgsx90bi3FA9GAwKQMMLYS7qPiavF9naRbNhdm6Bc4HwxGmAUtbfe8EsB+vld7mQFYaMdXdy\n", + "LH0hodEx8qShq53Ma08naY5v813H6tmL7FPT2O43cg9I4nkoXCrAoszYh0lal8CZ2fFeZfxmEpN2\n", + "PlXNsKArzMowXupXAJABSxzzr/UHCYZepzpU5PwiJxE7pOPvfwtyzdpyoZ4Ba7fbLbkmBlroHdab\n", + "BEiMf5KiQ2t2CF1qjxsmPGlYSEINOIVJU5CMPpo5MHimn91uN6PRqOQNPjw8lMv7aNPptLAB6Fdk\n", + "DPkzqERODLjq/WkHgn4jxzWg9sknjDzA2HmQvMtrQRgLFufNmzf59ddf8/LykvPz8/T7/cJU4SCZ\n", + "mWL8rjDr8Azrt1gs8ubNm8I+Yb9xYLBjzJEdhdfaTuA4tzGCtGoKuNfbZjo7KxvlhXCs1+tyKR1J\n", + "Pu/fv0+SknvCZUcusgMrYsYBAwLNt9lsyoLybgAQzInZGIQNYZzNZkX4QJyM8+joqJzdrz1eK05A\n", + "EoKIYDAn3vw1GjVt6dAAdKLDIg7dAFIQchtH/r1arXJ/f19O6qzX29ye//iP/8j19XW+fPlSlBdM\n", + "F54mG2g0GuXs7CzHx8cl1MNczmazkjeEkYNFcSjQuSrIyLcQ2sHjAVBZGRlwJmltUN/fYUVDjk7y\n", + "tdFiTu1d83dTxQ578T4rfZqVrZWjARaghH2C0UE2AVo29PboanbPgAJgYuVlT5HfMZeAAffdgAej\n", + "RJ/dH36SH2adYG8Vuv7s7KzsJxLsWSMrWIdoaWZJvL/QSzUL6BDft8CYJE3VUMoBMJ66fAMyzFyy\n", + "/y2PvV4v9/f3+eWXX3J7e5vk6zouHP81m5akZS+QQ/QXIWxkG5aGfpMAagCF/uUE6GazKZdYbjbb\n", + "2inoc4fhsQ3ezzgd3tPoXN5lwG9GPPn6vieHzniX9zfyyNzwfOsX7AN2z3P422+/5fPnz8WJAUSc\n", + "np629kXNShoE+bb5WrckjY5CHmx32PN/1HZ2K3Gvty2ty7XWGHbH1RgwE85mcAiDCbq+vs7T01MW\n", + "i0VeXl5ydnZWkPZ6vS7I3hQpiogFgNZKUsI4fM4erD176i8YEYI+UWCgd55PbNO0lgEAfQDcoJyd\n", + "L2Mq0nkbPMv0m2lNCzBKmz+vGXcAnecBpeDEsOFwmL///e/5+eefi5fJBqX5JAZCbqrdiL1mHmoP\n", + "OGkbU/q362aAmTS5B2xanyZB0bB2zrFgLK5uiaeE3LmxT6wETT/72TXbQvPvDRhNufNsji9D+fp7\n", + "zIPZSwClT9kAYpAlxgFwZ+/WHiJePPLCPrOSRkH6Ejnvj6R9/xF99r6xgl0ulzk7OyuyDQh7zcu0\n", + "o4EMADj4WXuRXgMzJX8UFtpFA5TZaQOU1Dk26BvkdrPZFF3A3HAP2nA4LMma7O/Dw8PixLK2lll0\n", + "GBVfsQvIDwYedp71n06nJXcCGYLNRM8AqqbTabEjgAYzNYzV7DaOJb/DtrA3vObsK8t2p7OtVYVM\n", + "ERKCkQNsmY1L2owke5F9jk0F1HBSdL1e5+PHj6VvsOlmZer5d4jGa4F981w6fIxMOILxz8D3zi7+\n", + "464RkBMUEAYbwQHJUonVnv/5+Xnm83kR5sPDw3z8+LHcJ3BxcVEW/e7uLsvlssU6bDabkuhFVna/\n", + "3y9on4kjsxtFCJq+vr7O5eVlxuNxQcmENJ6fn7NYLAoLZAqPvBkLq8M7pp0RRv6OssJztZCYQTGI\n", + "MVXufBo2kGPHfJ9/0z/Ago3F4+NjBoNBQc8kLt/d3eX29rZlBJ0M6vABf1B01L6ZzWYFwXvu2Mhc\n", + "9mZU/i0ocp9KcTjNRr6m8W2QDAIMUpJm7NPptMwH62pDyk+vVR3br8MRKG+MDUqfz/sIZNKEWBzf\n", + "BiQgVwaoVm44DYAnn/7BwCFrHovfjw6pCxvCaKJw/R2eZcXOvJOAiJya9qcfPJM1BmjWeVwAsz8K\n", + "bWH88JgNUh2O8nN33WysYH/pL/k4nHY5ONheBYL8JU1CJ04b84gskHBpRpTvO9Thk1rIFM+wswYL\n", + "3uv1slgscn5+3rIjyC3POzw8zN3dXQaDQZKUPCeO3yaNkTUjUQNZO1wG96xvzQwyN94fSQPuGRtH\n", + "fgmHmblzw04AqqbTaZJtjh85exTQJCxGBOPi4uKrkPNr4X7GzN4ghaHuk3WAdRnj/LN8k2RH4MQo\n", + "CiOXNPUCfNwLAANASJp4I4ILc0DZc46hgrwBLlZ4AAiy8k29omAQWhQ2i4nC5cw5qBMljEANBoNy\n", + "Xw+KHNSKQPM+/i9p0LJzD2xoWPQ6b8ZGxkLCGHq95g4SmCGAg5u/v9lsslwuy7Hqi4uLcpppPp+X\n", + "SrpJE/46OTkpNCog0JuW9TJK513O3jc74FCDWR7mraZAd9WIN9f5BEnjsZs9cX4Km5c1wUtjnQeD\n", + "QSaTSYslqVkyyzh5LA6JAUCsaGgYGrNryAo5FuRz4SFyooU9wx5gXIAOG3z+Tt9gUSyzjMWKnn4x\n", + "t4Q+GQP9JAm7VviM3z+9r/z/zCmspT1IanA4NEvzfPq9rC3zbwDH/zssVyfJ7rqx/0gypa6JQ1Do\n", + "QyeNouvt3OCAouc+f/5c1skhQcLGzA3OG4ADPeJwh+cRY0y4x3uE3BJYlcVikYuLiwJeuJuGd7KH\n", + "ALGMNWnCLWb/AJ8+Zo48GvAawPLv15ws7jECTDEOmllB9g1sBn3APmIDYKeYm8ViUcZEfx2OYy7Y\n", + "uwbiDpPa+Wftea5DYHX4s247ASdQegio2RAmhUVYLBa5u7trHY+lmbbiRMxf/vKXzGazIrg25mdn\n", + "Z0XhsCBfvnzJ/f19rq+vW/kB/LG3RCG1Xq+X4XDYyv6GmnQoaT6f5+LiIvf39y3602yACwQxNwYY\n", + "zIU3OayOF9YCwb95n71e2BqEq45b0oekEXjmC+YKAXcs+fDwMOPxuLzb9QscxkGh1YwPc9/tNsdS\n", + "HS7DiHiDwxpgqGp6fReNsJ6TW+u59Xw79GJwXDfWHY/VANeeNw1gnzRg3sCFviBTDkEkaa3dw8ND\n", + "YbRMzQJGkpTwDvvWILMGy8gVwAS2EoDCs63QfZzTuSkYBZwNF8xij9XhHBpj8RFYx9XZqzWb4vmo\n", + "PWav8WvsVG2IWHuPhfd5Lr6FxtyzF50/Y10MC83eRQ5xPliTfr+fN2/e5O7uLt3u9jRep9Mpzo/3\n", + "NMm0yOBgMMh4PC65SN4/nrNer1ee63oonU6nJPc7ZI9jQCI0uo5+Pz4+luex3sxF0oTlLeNmdy0n\n", + "yBQ63uCJ7zgM62P27HlaDebpB7reoK/f7xcbhO5lvs2UJ+2aNowvafJjzFbxfdbEibrYUsbBuF9j\n", + "f2g7AydsyvPz88xms21n/h+FQx4DKOzp6amEakCA/D+5JLPZLF++fMnFxUW+++67LJfLkg9CApNp\n", + "1IeHh5yenibJV7FzI0F7M0lKYixH4VxA7OzsrNRaIQnr8fExFxcXmc1mRcFyAyWVVZP2aSEzIRjp\n", + "+hSAE14t1LVSR+klTbKmvdTX8lVq5gR0nKQ1h0nKunCjJgq20+m0CuwBEO1tIKSMkXeDtE3D4o0A\n", + "Dm1YvBm/hcbcODZPA1glbQBgBozPGbihpNgbSVNDxrQp84BnV+cTmZ3hGZYbhyCs4E1jm85mz6Cw\n", + "GRN0OM4A64aCQjly4Rmy4P7ZmAP4kLV63JYHvFyHaWg1UDGDC/sKMDF97wYoYxyeMzsXnlOPC8Nj\n", + "x4N9w7o4n8PrtatG6BYHwd55khJi8/wyPwBr1pFTWRwl3mw2JTRuBhsmPWkcWnQn76yNtMOi6Abe\n", + "YzYNRw0QAjB9enoqpyt5hpOuT05OCpCuWbhku6dns1mRZxwtwpc03pc0Cf7IIQ4I3wM4sb8sP+6D\n", + "dTfAjn6iP1gDPzdp8gkBZ3Z+vC/tEPlyVpxXO0/YGu8Jvksf/6ztBJxwkgaQYu9ovW5yJJxklbRR\n", + "HII5m80KNTeZTPL4+JgffvihKE0mwFQYhjPZnhzivaakvdjEsvv9flFYRvYoQICTz9vD/mC8fUTO\n", + "tUxQ+owZxYZx5x3O43CyZdIkRdlj9700SQMueJa98JomtJJgY+E1Esqxt2RmA6FHCeC5G/igMLy+\n", + "9NEljzmeSpjEdCNzhwx8C835A/aW+Il8edz2zB3qcZVNA1XnkNgw2itPGian9ubdHLrAwzF4xcOv\n", + "k7JZF8CuT5+5qqaPA9dKCnYiaZJtzRog34At64zXGBEDhKQNAGn8nvmmD+wDlD/j90++X/+s38v/\n", + "A0CSpqAdY6XvHu9rOUe1Ad5FY10BZi8vL2XfY/yRac+Hx4ze22w2Bdz1er1SqZQwO7rRjpbnxbf3\n", + "mvVjLkmQpaJ4XZsHPYXugxkBMKHjFotF3r17V5zXJCVUUoe3GDtOnNkQ+s0e8lzUDsrBwUHJVcTA\n", + "W4/w3VqneA+gg3kG6QWLxaIFprFdyKLnBl0LQeC+Mv8AE+wnzigy0O/3c3p6mtlsVsZe5yH+Geje\n", + "CThxLJ4wAZckkafAImP0+ZwZFehD0DnCfXd3l+FwmG63W042+MiwjQKby4wFz+d5bCaOvjoHBZqT\n", + "CT87OysABAFAufN8WBAnlNWgiGfWeRQWJH7PRnVRMyvLfr+fpJ1RXytihNsCbzBB8hoesalBknYB\n", + "FPQRlgkQgkA6fOexf/nypYCMugLily9f8unTp3KHBgarXstdN9butTAGgAJjY48EEMZPK/I6ORLW\n", + "IGnnRtQGuDZqBgj8G8XjMtt1SMI5JrWxZB1IhERpYzgMovCskZvValVAO8rZ/UShO/GWd3N6ok64\n", + "dKsBcf2TseHIeJ55Xx0qqMGHGaV6TnkO/XutiBjfOz09LTF/+vCacd5VW61WxUAfHm4Lc3HJH+tL\n", + "f2E4yUfiz3q9LqcpMWrIAU6ic/KSRh8RjkAmYLpYD55F+fokBTh0u93y3KSdRA7YIW9fRaVLAAAg\n", + "AElEQVSQ/LzlcpnRaJTxeFyqqCIjTvB2CI69ioPq0EfNQvAcGiGjGihTm8ThSebF85O0i2qyD52Y\n", + "zZxjTxeLRetZ7DM32wLARLfbzbt370rkgfIPdtyxT+S8jMfjVt4g4O3P5HpnR4nPzs5aniBC5QJH\n", + "SVpn1KG8EKLXBsfmnk6nJanWCgVjTJ4KaDlpZ03jSSJkhBUQZJ9QsbFIGkWTpLVQ/JuNxLMcrzV4\n", + "wsCwqGxIxgFAQ/AQQgTE5/WTtMIsDl/VSNyNTUU2NmACkIbBOjs7a3kKrxno2gMCzMzn89zc3GQy\n", + "mWQwGOTt27ctg87zHh4eSoEk5+2wKf8ZTfivaA63Je1L7vhjEMXcWnGYQUIRO+RphgSP1qybjWzN\n", + "xKFAauCAkfV+sjGn8WzABuDUIIKGl83zUVTsQUAoa8j7DX4I57AHTPX7OC4nBRwOShovk797XIzH\n", + "x5qTJhfEAMXryZ6rGZmkCeUBfNgjNEJTPKvX65UrHTBQvpeL/u66kU9wcHBQQALXSiyXy+JUsF6M\n", + "gzXnfjGAHLoCxvrk5KTlqNTsFH9H58HYmWE22EM3oBORdwMgwCb6czgctsrmv7y8lCTZzWZTLv3j\n", + "vRhskkSZH4fqXGTOsuhkaN7P9+i7c7aQFduHmi1BHs24UweGvz89PWU0GrWAjAEeesOOMk65w0AA\n", + "abNXziVinpOUFAjGTB5M8ucJ3zsBJ46bY8Sh1pgE8kkQCo6o4i0xSCdFMll4ecQ5kzbNjQK3EFkx\n", + "W0GS/5A09xmQ6c1zCDEx4ShS2BZT9PaMTHMlTUVKKqryPhuTpO0Vm9qn7yhwV7O0ENoztsKm1cqQ\n", + "TbxerwtaPjw8zHA4zP39fUuRAIxQIqwV/w8bRe4AoKfe+KwL8dvhcJizs7NMp9NMp9PWJWM2LN9C\n", + "AwywLovFohwnN/NQU6pWXjXbhtz5CK5ZIzMSKGP/vVb2KD/+rzaYKGj3mXchmz6NQHM9B4wV/49M\n", + "1Bf2MR7mjv1cy6wT562MGYt/x1j+SJnbg7ODwd6xPDl2bwXtUBzjqZU788T3PM/M22QyycXFRTl+\n", + "axaH8e9avjudTs7Ozop+4WfNusIckDD/5s2bjEajVj0SA0N0tMEE82ZGPEmxB+iNuoYNewT5BDgg\n", + "Y4PBoAAn9hZsFiALMMAxdIe9AQ7IHseikWf0nJ0JH2YwE8begnVk7pK07APzw/o7NFSz3F4HLkxl\n", + "TxwfH+fTp09J2kd50VNm4n1K6e3btxkMBlkulxmPxyWPM2lCV+PxuLV29PXu7q7koBjcM78121u3\n", + "nYETJv3+/r5sRAwRwrbZbMrFb6enp3nz5k0mk0nu7u5yfn5ekB4CzHc5qcAkAkT4N6EgNk2v1yuX\n", + "VxEeccEhTiEYyd7c3JQNdH5+XsJI1DCBWeHZ9ma5KM//h2KDxcE7Sxoa38JnWh2aESBkqtGVZtlU\n", + "9kBgqSzkyddeJnkgLlPN/5kNYnPSJ451Pj4+5vb2tgjy27dvy2VTbM6Tk5OyzlwkhZLp9Xr529/+\n", + "VvqLEdxsNuWc/beQc+LcD+hTQhdJ+yivE1aTJg+oHoeVSb1OBqcoUmQV8OB+8dMXU9ahHFPWNuh4\n", + "W8gOBgejAIPhEJEZNN6LwjJrw15ARjE8VuTuZw2meQZgAaXLe0191+Fdym47ZICD4bmjOaeI9aQP\n", + "PqX12ndZAzNQh4dNHQvH4+vQ0i6bnbj379+Xu7Mw2knDGpKXARtoet9z4bW1E2l2CueP8hDsjeVy\n", + "WULJrl6L48g6I5voeeoy3d3dZbFY5Pn5OcPhsPTJIcPz8/PC/CWN00HIBFk/OTkptsvsGzowaVeD\n", + "TtosEM+mhgngjHlHLvj8a7JQs4PsMdh5bNvj42PG43GRW54L2HQOEbZrsVhkOp2WPKHRaFTqoWDv\n", + "CPlTvoO8xF9//bXcVJyk5F9anv6o7QScIKyr1So3Nzfpdrs5Pz8vCh1kbsqbDcDv7L3Y4wE5M+F1\n", + "vJaS9tfX160kURSnwyYk26LEQbnHx8e5uLgoAIWaKp50noERJ/sbpQ5qB4w4Ucgeq4+lMi7mg7Gh\n", + "aAFfvMcGkX8zn9CX9ljd/G824cHBQekPioey3gChmnrlrpz1el1qopydnRUwN5/PS80IQCDgjrAA\n", + "d16QYEWpacZX5wLssmHYam/BFK7zY+rEb8BeHa7EINZ5Nc5dQalDqWOUUU42AE5oNFOALFnRE66p\n", + "84ZgBBwqAlgk7evRWdc6Dp40OWhmkQyqHeJ1bROvOc830LYhpKEQ6Xev1yvhT37PT8uX2Zo6P8X7\n", + "0IUSAZP+nJ/N3GO07HHXa/zaWP6VDSPPvjQD4BMayEeSwhQDHgBvBpgwF/P5PMnXYUpygi4vL1ul\n", + "zm3MeRdyi6dPTuL9/X1eXl6KUeb76H/LIbrLOSDr9Trn5+eZTCY5OzvLbDbLcDgsa8iFgDC/fr7X\n", + "zkCf+at1ugEL+525Muv/mmFnHybJp0+fMp/PMx6Pc3p62tpbdujdJ+wbtogaXbbLyCpy7VweGBvW\n", + "F/v7/PycyWRSdAPOLev1R21ntxI7CzhpCrBxXw4NdIey5OdyucxgMCiIFKV+c3OT6+vrEsNk07AR\n", + "ENLJZJKrq6skKcKVpCjjTmdbVpubhLldeLPZJmadn58naWJvCDZ9ZtOS2Y7QJimnf0DfPDdplABC\n", + "TaKRKV7ewf85Ju4cEQtIHf5h0zmmbg8zaViTk5OT/Pjjj3n79m0BWgA2U4q8s/YSki0ABMD5lBDv\n", + "PzzcFgTC4LEZh8NhS6H0er2iGJKUo4UHBwdFwe2ysVY0jyVpjKOTHvl9/T0bYf6Nwsdw8516zS0v\n", + "i8Wi1B4w6wTIR+E5QY93+hZeg8A63o2TgOJhPC5G533quXGYludbQfNdxkr/6VM9B47R1wygmUEc\n", + "EHujzhlJ2vfiuLFXTNvzf95nNRPpUBZ70kDRoSj6+Boo/Vc3OyWcisTweK87/OCj/4wZ1gigcnh4\n", + "WMAEpwrRATwf58S5HehNGMKkSYq9uLhohd4xxBwdRkbQRewj9iFsg/MLyauhpD17AVlz3aikufaj\n", + "BhgwOOjL2sHk/8zA8lzn17mZNUEf9/v9UqV7Op2W+Tw6OipgBZl1/hhrRk0r+oCsYutgdxi3c34I\n", + "Y9MX5qcuKgkI/KO2E3CCB9Xr9TIajcqxMdcvcUweBWZPI2kqbcJCHB0d5fPnzzk6Osrl5WURIMeq\n", + "nc3NJK9WqyJ8gJ+Dg6ac8nK5bCVrsRimwDabTQEiSXN8kskHiXNMmveafkSgjYpZTN5pDwpa0zQ6\n", + "Y+Vn7SlaaQIMkvYJiZrKx+gz1qurq5Zw1rFDMt95LkJNOI21A4SRaMuJD9aYNfDmY62TFIbgNW9z\n", + "l405NPCiOXSDgVqtVq0Mf5RyHYNOXk/w9O+Yz5omJ7wENetEPj4LeHec36EgK0uHUuhTt9s+HQeA\n", + "4CfA254zMlon5nrMZiMwILA3KEf2t/vn/tKs7DebTTlCyvxYlmsQVQMUgIXBC+/lHQ7LmOVinvmO\n", + "AY0NkB2PXTYcxm63W8LUm82m0Po+8p40Ce+Mg3HDMFhnDofD9Pv9Uu8KUJA0BySo5sq6dzqdXF5e\n", + "Zj6fF1Z3vW5KqZOT4svreC4sM/NqJoI9RO4fn0U+ABDURzGw4BkOTfkdzAtHm9nvZoutk1erVetE\n", + "GvPL+F4D26wFNsBgnbHDgNA3l9BAXwEeASs+pZo0trMGFzj3SftaBuaYxGjWxvu8bjsBJyjPzWZb\n", + "6Y/YFpQhVI9DMi58wySRF4KBBzCAtEHhpnvX63VGo9FXSUqcxBkMBsUzXa1Wuby8LKd6iGWywCBv\n", + "b0gEpKZq6R/lglerpgAVVBuK0YKO0sZgma5mk+IFmxUxI4JCJ9kURYPRchjBSpgxUAbazUesMS5O\n", + "DgRU8Lmjo6OSfwKFyXhZb7wXQJ3Xj2fbwJFF7hyXXTcbWPeZubQXjGJjHn0S5bWNS3gGZez3Je3q\n", + "rrXn1ev1Sv0Gx7MpxW6PJmnAtRkTP5P3YGQZ7+3tbZG15OuifnXo0r+v6WszL1bGBtR4wyhe7xe/\n", + "L0nrPcx7XajL4MTPq2n4PwI9zImpfINVAzOU92vNc1yzartozq+pveCkAcGeb7Nm1imsF59D/gwa\n", + "0c8OH74G2M7OzsrhidVqVUo5rNfrcvO5nT3XvUoaxp7cEQNlmEROpKDLeQb949kGA8iwwcp6vS5F\n", + "QQHFZop5LzqZOUiaECHvrfdCDY7m83nRyci8WXk+x5idgM34GBd2ot4z2FucSdgXOxyev8fHxwJs\n", + "0S91+NptZzknLPZwOCxIdL1ujgQ6wZFFgFFhoyTNwBH04XDYin+aXvMCARaMcslwJmzDZ8mkH4/H\n", + "X93vw79Z1E6nk9FoVBK4eL69McANFF/SZj2S5iQP40aY7KXCSDB/VhA29DBTSb4CBt48tXGnL8Ph\n", + "sMSGARJQtKPRqCStcmytNjQ+6cDY2AAcC2eu+Q5KCc+FsZMke3R0VPJWxuNxWc9dt3qz4TGY+uYz\n", + "KHKzG/y/4+32tpmbOgznsJH7gPzzbIP81WpVvLg696WmlpN2PgBrTEPuXA7czgXf5Xm1MXKioOfH\n", + "/ajZBhRiv98vSa3Mr2lzGu/h/YASktNfAzTMtefQHmG9Dih6xoF3CWBxWOw1JsbhTjzvb4EVZN2f\n", + "n5/LHrSjyO9ms1krL4X9yzOQc7632WyK08c8OefOyf0YWwzlYrHIcDjM1dVVFotFbm5u0ul0cnp6\n", + "mru7u8KIo9ORJQNjwCZhIPaGk7DtdL3mCBtoGczbOUTu2MPj8bgAK/aiTx9Np9NSS4p38Szm0vuV\n", + "/sG2UHUZ1sesFnaHP8ik5ZXPG+h77wKccLQs28yRc2g4PYrtYy7+zKHc2cV/LN6bN29Khm/STkQj\n", + "DOCbi5O0QizE0lEc0IYog1pYHGbxM8ni/vnnn8sdMTAjxEY5XeLnI9CEpFg8qsk6y7nf75fjgsRv\n", + "TW/buJpm5N9JO3YNdQk9DeJO0jJ0zBkAEBDhvBPmx4aITTUajVoxcjaTGQ4E7zU6ns8CtuxtORRB\n", + "gSYAqr01GxVAIYDQRnHXDRlzSMBMSR0CsPKjsT/MvvB55sThEcB3kq++hwdIkUPytQCZBjVJE9ox\n", + "64NiJAaNguH5Tua2gYUxg2qu995rXh+KzeOm3DlAjX4hi1D+ptiZR4Mt5sXgy9dWeD7quamBxJ+F\n", + "W9A7jMf5RV5L//Tf2We851sAJ4Qe0L3j8bgwqhg79rqPoaOn7dXjYPIdEklxVJLmxIoveSSPjzWm\n", + "+FeSXFxclBwTnNwkBZiQm2ZjDONqJ9WeP418F4d8krRyMpJ2CfgkX4EfO9s4dIASf+f5+bnYRDOQ\n", + "SVqVs5Ft5BkZ73a7xS5RHZb+sS5mwWwja/adubEdOTra3kLtCwRZH+bODjDpDKwF9rpOB6jbTsAJ\n", + "AmyqExCC4TFlhgCAIFFuNYXr0zYsPr/j0j8W3HQehpOjw9PpNOPxuBxXNuJz38mbAM1zmgTlykZM\n", + "Gi/w5OSk1HbBsENDsmgIitkNhM+gxSEmFCDjZ1PDLPm6ANN1r8XYaZwmQkDn83lBwvTFng1eS705\n", + "raSZK5QSf7+8vCxIH7kAePBObqd2PhBskzf4LlsdzjGFn6QFXJB9mj0Pb1pkgVBikuKN4inVe8Js\n", + "Q6ezzaKnUJY/WxtYclFsUJFnswcvL+1TSabtMSpWUJ4fsyrev8yTQYGZFL5XG2z64T7YSEC3I6M1\n", + "yHsN/DI/Bkx/tNZ2evh/K3uvR31U3PNs5oY59X7dZXP/0XVmm+inwz0YUoeO0ck2dj/++GMxlA41\n", + "/PTTTyXxlpLxOC/dbnNBKO8HxJJcb0YLucGIUr12PB6X/CiHaJIGePtE283NTS4uLpK0QauZgtp2\n", + "AdjrOZhMJjk/Py/MkcEFwJ659zvMRNfRhfF4nN9//711whPHF0fJDiI6wpEK6w3mmjk8PT0tegTm\n", + "g/3oongAReacsJmZliStfVO3nYETBmGEy6QATpwYSWIqyZZ1YhAK5B//+MdXl/o9Pj7mw4cPef/+\n", + "fasPGEMUoMEMGyVJOZ3iWD7Ik8v9MNy+J8JGGg80aW7KTFIQLuOndbvdcsmUq+kh+PSFXA6O1bHJ\n", + "HPtkU5iWs6JOvmZqkq3S//vf/15OPzFvGBCE0LVZGCPALWkE0HONR09hH7MhSTuUR1iKTeZ7imC1\n", + "mOdvqaGYrCBrqtifsTJN2qEQvE3WGS/NNDdejJkp3luDHcCwlaa9Hj7HOry8vLSO8dJ3/0Qhwzii\n", + "CD02xod8Grj57/5JBdEaCKAjrDw99zyz9kx5BrUf2FMwsZbvOizk/eJ1qoEx64W8m9mxh8q7DHTM\n", + "TmIYd80KAkrJA3OIgpoX9JMxHhxsa5RQRgH9hRO5Xm9DzhRgZE8TipnNZi3g6DvXHMKGOTs7Oyt6\n", + "GO8eveokcbOHw+GwMCE0h1iQF3IDGevBwUE5lcK+TlJkyswZdgU54d0AMj6TNBcs1o5kt9tthcuS\n", + "tPQenzs5OSmXKGKD+v1+kSPWxc4ln7P+sGNbyzeRAW55RmZtp6w77GTyrDoZ/7W2E3BitAQaxrA/\n", + "PDxkPp+X41oGDPP5PI+Pj3n79m0ZGEg62RrmH374IYvFooCBwWCQTqfJA0EBEA7qdrvluPB6vU2W\n", + "Xa/Xubu7y9nZWU5PT3N7e9tCkWwO+nV6eloWfzabtSrgEgayUibL2wwLWel4rTYgKEkWlfnjWFjS\n", + "JDBipMjLQDBcPhhWwsJUhwoMvi4vL4uXwp0aCJtPQpGgyhzB1lCQablctvJKSF4jNmwDCUKvlbir\n", + "59JflIiPa++qOW6Ol+PTVIAJnzCycTQgMUPAnJi9SBrji+K3geP3BkJJkx+FrDhJLkmLGbM3Zwqb\n", + "Z7vZi/b72ItmA01z41wYxHk+/e71et1yHPwMK/LaY3YYhd/55EfSJFfWSe4GOjQDTFP3ngvCReQP\n", + "vRYGslfMO9z/Ogl+V409TCVvDh2sVquyJ22k0S8YW4f6ABaU7f+v//qv9Hq9vH//Pr1erzDLPv4O\n", + "UEu28sVRVY7K9nrbAmvD4fArJgJ2mTmFSZ5Op0madWXdyXHju4AR1pe9c3Z2Vu5xe3x8LGwNehEA\n", + "bCeAED9A2KEfxsb+pK/0n9AaMu1wC2P7+eef0+l0ynsHg0GxQWZbfDQc4GcdZGBkub+/v8/Z2Vlx\n", + "sK2DDfJ8mitJOZHJ8znl+WdH5Hd2KzEThGGjABf0fdJ4fklasUcm2YmuKIC//e1vpZLs77//XhgP\n", + "19ZImrAP7wdVQglOJpOStFQfhURw8BDxEBA6jFKS4lkAUAA1pjVrYIDQ2ICgtGAPMEpJY4AYj4ur\n", + "2Ztljgxc2CQYPDb0mzdvcnV1lfPz8yJUT09PmU6nBX2jbOy9stEYvw0fY+X/Dw621XWn02nr4igQ\n", + "PIALQ8lmfHp6+up69Tr5cVeNeSfsQWlrU6woBDMmNdPlcB7KfLFYZLPZFG8PltGJmskf5y7QJydo\n", + "WmFgWFy7woCmNsgoYmSBMZldYE/5HT6uD9BwX2t2ws/lXfz0HjYLQeO7BoJJWvkJyCw6Ablz43Nu\n", + "rwG2+v/sELwmy2ZpkubUi9fyNVCzi4ZM+oQJMu4+moWlKBe/96kPchoosOacBDN2yJBDEg4bdLvd\n", + "wmKQW9fpdArbi/OHc4t8oEMoJIksole95hhS5Isxc5CCPlAtFtZ7s9km8dvZJMfG+XXMpfWfnRUa\n", + "jik2yGtze3ubxWJRWJ7T09McHBwU/cqdSMy/dRIy6WRkQCE2zPkqjN25OmaMWGv2LPuL39e5LK+1\n", + "nR1vYNCc8mAxT09PW7dZMmlJWrfr0jBKeIDL5bIYBMI2KD8WwwlWKF0r8Tdv3pRLoJjg1WpVEL2Z\n", + "BaNYgBV1UQ4PDwvFRr//iMLFM4a6dOU9NrfpUnsFVmyAILM7q9WqVXYeJQmar9E3LMh3332X0WhU\n", + "gM90Oi2nZJKtgrcX7zFCx9M/0/HUlXDVUmKksAC+0RiF7qRO5pHnM5+7bsiaDSfr7Lo9fK6m+R32\n", + "qY0860fhMIy7jWzNNBkQ06c6edugo+4nzYra/alDSIyJfwPeUbaUG2eN6xAX7+D7Bi6uaUJugR0U\n", + "U8n2+gz2aDaA6A47DXWrGRqzWu67f+K9Mp9ea/4YjLJe3s8e2y6b8yVms1lWq+3Fosxdt9ttXfDG\n", + "/sUDR48DHLx/X15eyr09m832BBVJnITdAAacgHT46Pl5W6jt5uamgI2kCaPaLsDkuAQFoIFnJe3a\n", + "M96PrI3B8dNTc5ke80G4BFnBJgHOYJWYW8JOyL0rPHe73VKDq9vttu6Xo+G83N/fJ9kCr6urq6Kj\n", + "+/1+2TOuP4N8Ol0A+waAcp6cw2r0FZsDeATIuTI1wM9lOlxA77W2E3AC+Dg8PCxHiaGW8NrJ41iv\n", + "t/FCMsMRLhaNRcSTpJAN5YsREt+DwOZJmnPuKABO3rx7964V/+T39MPC+fLyUrLBWVhOSJCTwsaz\n", + "p5Y08c2aumRzgzCNNvmML9FC2aGA7R2b7cFDmE6nRch8OiPZbszT09NcX18XtI1SIDGN00sodYMQ\n", + "+uNcCCdS4snwXl8Uxtx6w9BH1itpjlrbc67DDLtoVmTOF3C+hQ2ywZyNEXNqehlGDuAOa3VyctIC\n", + "Ckk7J8JABGNtTxYlPBqNMpvNinzacLsvGCpCfVaivLs23Ky7nQGeC3BlXKbg8a6TNqBAwdpwm4F0\n", + "iInwCuMh7Ov+MBeMz3H518Ju/DTA8HgNQgwybYj8O3/PToWdn102mIJut1sMrQtKIluu8oqeRW9Z\n", + "PpOmiCT3p71586YAHwzxwcFBbm5uiuPK2tr7h/0jN5DwMmEHvk+1V9YZHYKuAiyQs8j77ehhqAEz\n", + "vjMIefa6scbOQ0Q3ADRcfI1cF/IpkW3kkXoutVF/enrK3d1dut3tCbR3797l+fk58/m8HB5g39dO\n", + "Me92agDrSmidEgSU9OckEPaSvjNfgEGckJOTk6KvsJlOaH6t7azOCZML9cZEoLgQMiaVBfHGTtpX\n", + "T+NZDYfDVmweqmu5XObs7Czv3r3LfD4vTAiKh4mlL1CEm80mt7e3mc/n+f7770tsdDweF8ADs0Ll\n", + "u9VqVSoeAlBYYECH47NsEDYB3wEEobQstD51YaXMhqUZRAFOjG4BQqzD8fFx3r9/3zp5tF6vCzCz\n", + "d4wn7FAW68Ia1YXaSGp23PXu7i7L5TL39/eF8YI94r4MU7vr9bqEAgE/NdW5iwZbBMuRpKXMknYd\n", + "DRtSGziavWg2N4ZqvV4XeXI5d472JQ1ITZq7adg/yBZrOh6Pyxoa7AAWHfo0M9Dtdlsgy8weDS+K\n", + "z6IY+cm7MHQ0lKi9M8+NqWaHKGFaANBeH3vdGFEfdTaAM71tI2yGw142fbYz4jli3uh/7bHyOdqf\n", + "nWb4Vzb0CuOHZWBvr9fbPD30X9IGacwfYQzGvtlsT4CgS5Ptnri4uChl7ZOtDl8ul+XaEDPi1kNJ\n", + "AzL7/X7+7d/+LUdHR/nll19aFaXn83lxdjH42CLnObKm6BkYAJhxHGISSPmugb3HnzRhS+fQWK7Z\n", + "E3VtE8CRGRl+9/PPP5fcSWp0Mac1W8uJPOfFuW/oGv+byIZPqCKzXNaKHDA3R0dHmUwmhVAgvAR4\n", + "NYPzWtv53TpJAzAwvMk2hENGcJ3tmzRHHK3goP2Ojo4yGo1asa9ff/01z8/POT8/z/Hxcd69e5f7\n", + "+/vWZU6wE/Ymid2t19sblP/7v/876/U6//7v/96qLeIy2NyiybhMVTMWUD4hGJA1G6Tb7ZakYFfk\n", + "IyZqpgCjD6gDgNCsZBEue8EWzMPDw1xeXubDhw+ty99IjCUkxvwAMhiDDTNKiA3OXDFOxgEljPH1\n", + "0eqnp6eMx+Ny/xDvOzk5yWg0SpIWw7XrVlPwKBEbHMBp0lDPNuT+vsMyAAZ74tx9Azvn8AnPNaC0\n", + "MUcOVqvt3VHj8bjE7k1Rw2aaAncYyt4+wMTG3UDHgCppco/s1RkcOB5vb9RHVpFF5M5MlNk8vs/p\n", + "DowLfXBoir7WjIXBsdcIT5zfYVgMZvAw+T3yzv5xmNlMlIHPrprXHXBiIJikhFfq8RPCQH48fozn\n", + "6elp5vN5AffT6bSE1mFAyO04OjrK7e1trq6uCoNjxmS5XObx8TE//fRTye/gRBA5RT4skDS62Sww\n", + "Hr9P6cCe83eSVNGTPAfnEjtl5xE7Q+4chp1TUMg/z/HJNqqi26j71KLBl0O1Blnsm263W5z92rFA\n", + "/ngm/aI/dSLrarUq4PDk5CQnJyd5+/ZtyXt5eXnJu3fvis53GsUftZ2AE5BajebcMFj21j15TDYL\n", + "mjR3ukAnUhr/+vo6s9ks0+m0CD6K03TzbDbLaDQqz4AJOTo6yvX1dY6PjzMej/Pysr38yuf4bZh5\n", + "JgbItPrLy0vrfpMkJXHK4SEWmL7gpaKoURCcQGKxXQ+AMYL0if3xXgML+nl0dJSLi4t0Op3iUbA5\n", + "8TApwYzw41WTQ0DfADHMyWq1at1jwsZwAi+XeZkd6vV6mUwmJeRgj4E+7Vp50wwA7H3UoAWAYhYF\n", + "IFJ/1h55kpZ8PTw8FOXtuUZWFotFicED3pAfU72Pj4+lEjIhSYAFMW76YWXm/rOPzNr4plbWDuNk\n", + "JsXxfa8lex85RGc41EQ/7N3jjda5Oy8vLxkMBgVA0U/mhWd5/g1yDJbYdw77OBxjZqXum/OmzKok\n", + "bQaNPrs/u2ibTVOdmfkw8EvSMjoAZYwuupKQu4GBQ3sYwfl8nl9++aXldBGe4B1c8GdWGtaZI/c/\n", + "//xzer1ezs/PW7VPyLuyDYJZRk+ZuQC4cFIJmYYp+vLlS7nFl+fU689ewy6ROEufHBZN2se3yWc0\n", + "s8F8/vbbb5nNZkUPECoCCJCrSWQC547nEqojnMX+5fsOowH+WU/6ip62PcFusK99ei35up5T3XYC\n", + "TqDqoeXxlOv4K4thpYbnDrVFAi3AgEUDZYJQR6NRzs/Pi0HnOCyeJyEFjudi1EiSfa8AACAASURB\n", + "VDHCnKO/vr4ux2lZNIBM0tBgIE5QMoiesSUpRoES2syDj6oRWnmtzgMLPZ/Py2YhMzxJy0ggHIvF\n", + "4quYpY3BcDjMxcVFnp+fc3d3Vyg6AACK5fn5uVScRUEAMnq9Xuv+IjxUxue4a5ISx3S4wmCU9bTB\n", + "R1mgEM3Q7LLVRq/Oi0iaUAVjxMB7szuUSaufiwH48uVLOZaNPNb5ESgW1hKamoZB4H0oe6+J85gY\n", + "h40Q8sizeYZzXKzgWNt6Hth7AHhCePTb4NR5AM4jqBvvYe5qw8gYUZzOQ2OsdijsMAGWeK4VukNA\n", + "rLG9U5prsfjk2bdSw4f5Zw/CZDIvjJN9jyyQP8J8wUJzZUCSMnfkhKD7zs7O8ssvv5TwCyG6+Xye\n", + "4XCYXq9XShCQIE4jwRZWdTab5ezsrADDpMlhYg0JL9nBShqn4fDwMPP5vMWmsD/QQThLXn+zpDBI\n", + "ZsmT9u3kyJOPGicNs22W5enpKWdnZ+Xfw+GwsHE4tOxZ1sqX35IzQ8KtIwWbzaY4F94HXnMDMOtg\n", + "gKYLxmGP0GN/BkySHYETFs+5A0mjuFhkKyGEg88lW6GeTqflCBkxZqO82WyWT58+5f/8n/+T//zP\n", + "/8xgMEiSkg9CbQMWltMp0It4p5PJpCw8TASTjWBMp9NCuVGrxUfKfLKChSPEg2GHhWGRYTEQ6IeH\n", + "h9bpn6enp5JgnLTvbUnaxdAAATaEzHfSCNSvv/5avO46zwBFwXq4P7PZrBgLvGLWimdYaQFubOz4\n", + "PJsAT9OeAs9DhpyAtutm78fy62ampO6z859gLZApswBWhm/evMnnz58zHA5byXvkohggeV4NCGBH\n", + "YK1sfGuPB8DPPgB80D9T9zBEZh2QsxrkGKQl7Vwd53y4/6aok6bsNrLGu0xV86euX0FfcDDMCnmO\n", + "6IvL3vPd5Ouj0PZ2a2+a+bIxNMjmd/9Mkf//3egreRW14U22sn93d9eqb9LpdHJ3d9cKpbhx9BZn\n", + "Eq/83/7t39Lr9fLbb7+1gB0s7ZcvX/L7778XJxOGhdMp19fXSVJYE8CzD19QhI2TjMlWtn17uoEF\n", + "zAL5LbAesNtcxcI1HEkK++95JFyEPq1BOo4tgIk9hq5w+MdMUK/Xy3Q6LeUwcNwdmfARbPQLDbBj\n", + "9tDF61wegs8zJphMA6mkyQO1LcDu2TF4re0EnKAg8Q4ZGIaTDiM8PpWB8OC9Y3CdK8LGMJvAGfea\n", + "OgedkqOC1+eMafcNj8FKmLL3bA4MAhSfE7WShskgPou3S3P45/HxsSBdh1VYWAwA36efbBrQLz/N\n", + "rPAulDaeMmvCpgKkEM5hrDBfjIHicgYkfgdUqzeikycxnklz4gPa0bkWPNPPr3+/q4airL0uy7Vz\n", + "JJg/fm9Dz3zAeNAMLJyMZ2aBuXXuBobVzbWGkGmHjQA5vIe+Wrm436zVH8mYDTTNjAb/9nN4lgEp\n", + "SX027H424+ffda6OmTr2OR4nc+4QE2EAJ63TT+bN4JG+oEu87vzdfTYw5xlej12HdZhj5/kxX2Y4\n", + "WS/rNeaNeTg7O8tgMGhd4wHgob158ya///57qXhKCIIkWfY8a4jsM5fUHDFgZ47RmQ6zoO8BMk9P\n", + "TyWPizUYDAYF2Jgt9EEKZIm9gt5lDgEe/BtnDp3qvetogNlAy5vvzQH4mZlyWQCHgp1AzN6DyQE8\n", + "mJUkB8YOCn1l7XBasZNms2z7cGjZnwDJuu0sIZYBseBJWh4iAm4lzWKzkCS1LZfLVu0EX5+OYA2H\n", + "wxJrRtFgqK1kOYLMYtugcLSZvtXJdCyUT98gvFRyRUAAGNDb9rq8oGZnmDMfPXbSI2NwXgm/h5JN\n", + "2hUtrdwpuFavFaj86OioVcb+5aW558LrlzT3HBl8mvaHSQHIOUGLGCjKgSQvh3KsAJnbb4E5Sdpl\n", + "59ncZgf8b7NC/p4NMvuD79vTwhvlmB8nmnyCyh4QILQGzEkb8PlEGSEay2gNqF8LW7E3bHQNGmx0\n", + "zaoYrKL42fc8g1AhPz2HNkTur3Ma6j+vGTAD/DqB0CDIFD5j593+Wcvua8+0DJutqEHlv7rBYKFv\n", + "2cMOH6LbACPPz8+tmlXodp9qZF0Ya6+3rVPy6dOnTCaTUjMK7x+QPhqNyj5I2ndKwerCohHyZD19\n", + "GMOna2CLkQHrddbg4GBb1Ozq6qrFHJjdQkbRs4CRJCVVgfnjj8NLDqHQN4dJkLenp6dysMJsnp1s\n", + "9q33Ms7u8fFxsZu9Xq8w+wAa9i9JrXwfe4uuwY4C6gGPdXjSziPMkZm3r2Tu/xPJ/X/RmIDlcpl+\n", + "v9/K+kaIEWRiYb5nxiyKQxCcrWazQ2Nx8Z+LABG/5D2155I0RpiFMRUHyHJcznF8H6mzx4miWa1W\n", + "GQwGhdZ04R17TbyTvmBQDKLot5WhPTOe5TCJQwUYeU4d4fGhaBxjxih1Op1y/wXvNYB0QhS/e3h4\n", + "yGKxKJsHBgYjxHFxnkdCMnRtnW+Dcf4WqO+kWQN757UhB2i+BkoMRGqalFNgBhmwgev1ulV+HaoZ\n", + "Ga1Bda0AUUT8zrKbtK9op5ltqWUNA2C2o2YV+J3XzvPEv82esHf4npNpeY/77eewj+p18hg9PkA9\n", + "78MI1ODRTKFPfBhcJE11VN7Dd2vWlHcz1po520VDhg4PD3N+fl6OndvIek7JY0AOanZzvd4eQSWU\n", + "zj4xE8GJD+Ydufzw4UOSdrI04IV5Y3+5sjiMOv3w7cIYSzONDvWgY8bjcVnPxWJR2GKMO/3CFsDu\n", + "eU+ORqNi7wyazUIbUPNMg2vmk8hC0gAAHMNOp1McN++bJAUwnpyclDGgS11LBTCHvUUHOyGWvUBY\n", + "zqFkAx3WnLnyd19rOwEnRmyfP38uA2JSXJqcxUgaJoEkK9PAj4+Pub+/z93dXf7nf/6nRUGb6mOR\n", + "6gRNK1Umn36xMIQsMC6msqG0UH7kU5jmRPgxyPaI+DtGwIiSRXYSMMJudsc0HQjdIMfeFwrRyJY8\n", + "Avrg3x0fHxcAmKS1Pg7T+eg34JECPKyvjbWBEkKMR0z/GDfJZKwHsuC8hG+hISvINKcEnMdRb0qU\n", + "kQ21P2MK2Zudz5lC5/c0e/O1ATbI43nIDN6P2UHWnLyOmhkwnc+znNthJsgGwMAaAIz3y3fZW2Zb\n", + "mFOHavkdzyX3hjE5Zm6QTD/tHGAU6JNZQAMgGxjez3gd1/f46U8N8vic5aAGW//qhuwlKXl7GPfD\n", + "w8Ny2zqshfPLjo+Pi3OIbjg6OipHgdEBTjDFsfEJM9bGsgTbwncAHcvlsoB5O4027qwh+nS9XhdH\n", + "mM+ancap4uQiSbe1zLHPqCHV7XZLDiIGnn4Q5vD9WDBUdnRfc5xJGyCEUx+N5hQR8mXG1s49dhEw\n", + "SZkH9CkX/LH/AVnYtOFw2JoH5hUiAAcTmeCzTrh/re3sVuIkBY3++uuvefv2bQuRJs1RVz6XbA3w\n", + "zc1NASgIyu3tbWazWWsToyAw7jAcfMY1P8wu1Emjjlvyf0m7ZPd6vS65MCwg5+2TJiHURsJ9eO2E\n", + "QdJmXQ4ODnJ2dlYUIEdrUcAYBdPTgBL+JM0dGY6R867BYFAMPXPBM3zMzMaI76L0B4NBAXLMOxsD\n", + "oOON5DDeYrEo68/vicnCFJCBT3P9lF03xkk7ODgo7B8G3UesARL2tg2yzD7Q6vCBQTC/N4PgdTZd\n", + "+xowtvJOvr7ML2m8OP+ecdMf11PAcJthcz/piz1MKztk38/i72aXaAZtBu7sP7xkgyje4X1P/7g1\n", + "m/U0kKidKOdg4EB5jeo9mDSshMMNfv8/8zD/FQ3n4ODgoLDdm82mhA87nU7Oz89bYAFHp9PpFA98\n", + "tVqVat528Lx/qTyaNGuIHfCRdkLjABzXg8LrX62aqztsGHu9XmHsefZgMCjHcXGIcIAIqWBQzXDX\n", + "joENOwmqgAcDm6R9bJxnWNaYe/YGMtLpdPLhw4dSHHS5XJY8HmSFAwqj0aicXEUXw5ZQ9DJJiSIc\n", + "HR2V5zhXZLPZtHSXw3JmSLDjHOZwHpz3q+3ga21nOScvLy8l+zlJxuNxRqNRUSaLxSLj8fgr42eg\n", + "kWwVKwlNFlyEm9LIbCAEwMmuCJ6peNA/DAt9cJKPY3mbzaZFa1HREM8hSXkmmwZDW7MVTpxz3slw\n", + "OEy32y2Cg8K2N+6Yueun1BsTQ290TF+vrq6SpChYNsXh4WEmk0lZQ/6fRKk3b96U43qOIaN4AGje\n", + "yDSU3GuGOUlr7VH4GNM/ovJ31Uzzkk/g/AvnDzFe+o7HxJpi1A2Ka+NrA8nvMbQGDcylEweRXX/W\n", + "1HLSPk3jMJQNrcfN352QSv/5jD04Pt/pdEqBK37PPgbM0l8Uqve9wbnZOPa5w3/Ik0Mu1McwhY7c\n", + "Q8PX4TbWyawp4Z26VoYdBIdCoMENRgziasC6i8baPT09Fb1G4cSLi4ui28ziWU7MxvlOGXSbHVDq\n", + "cfhwgkEPup938Xz0KBffUXTNBtDOnNkv1o/3WVeaLYZlTJpwEP2z04DMOPdmtVoVloE5RcbsEDAu\n", + "yxiOqI8Bv7y85Pz8vNQyQhe4+dAFz16tVplOp8WZvru7K6zRcDgsZS04rm1WxkeDCTeSc4IcW18B\n", + "YJO0dJLX44/aTsAJx9Gge05OTjKdTjOZTPL8vL1g7suXLyU0Y3TsBpK7vb1tAQrAg9kJKDDTw8lW\n", + "UbtGRK34fILFl0Xx+6RRzgizvUBaTdXzjF6v16Ie6SPAw/+G6kT5+bkWCAw9v6cvbMyTk5NcXFzk\n", + "06dPrRozX758yf39fYvGxkCgRKEh/S5/niNsoPlut5u3b98W+pF5hklwkiuGhDUDxDh8ZvapNqbf\n", + "Ajih/ygsFBj0qgFH0sgD6+gxYGQBZK7IiTGzwfNzUHR8x4rB1LhDQABHg2OaZRuQxRq4DLWBDcCY\n", + "33s/0GeHUBhPDdDpk0MLgC2zIwYOyI4ZIBtU1goFy1iQZYM2DI+TC5FLwgKcrMMwAZjsecIgsNeQ\n", + "AYdQzXDV87nL5vwO5KTT6ZTilDhRPkHFOlpeAHusB/Wf0C+Pj4+ZTqetMvgOsxB68y3v1puACRtj\n", + "5r4Ob6Dn0WOwCbWcueFMU6jQjBwAC9lF9jlhyf/zf87hsDwDWJgzfkfVXAMZ5ufx8bFUPsZZ9x1I\n", + "w+GwOMXUBasdysFg0Dr5R2gMJxWwZ/sKI2OWxfoY0I8tYS+9xhLXbSfgBOFhstjk0+m0RemjQJMG\n", + "ZTIB9eDW66bcsCvQvnnzJu/fvy+VR/0s3k8SJrRh3RAE0CNelz2zOnwzn89bXpE9fzYZYSjeDXXK\n", + "gidNTgCl7Dudbc7J4eFhPn78WASQd5v65vuuoGoQMRgMSr9RfvP5vFRThN2B1rZiYZ34DgLJuFer\n", + "Vdm4HIeG+bm9vW3FmJkPBBow4pwDxk1irpXPrhW3G/Rm0jYwyJqBCc0eZm2M+Ls3P7LvBDzmnO/A\n", + "KFhRYxzNeNhDA5g7pOKcDjyg2nDTLwCMmRrHvW2MDbT4ye+RMd7B/nKOCyymvXIciLu7u3z48KEV\n", + "+ttsNqXgFHJGHspyuSwKmdMlljH0jC+NYz9tNptMp9MkTeEvvEU8f8snesO5KayF6XEML47IrhNi\n", + "mX/6iaOSpDhXLnOetAvLGRADRizrOKo1s9HrbU9Jmv0yo4KMozu73W4xvkla8unQGWwuurHf75dS\n", + "B9gRnLzBYFBSCBgHxhog471pBytpnIx+v9/af3WBM5pzdmCCkGvfrMweuby8zP/+7/8WRodIQa/X\n", + "KzklPAdQslqtWiUqut1uxuNxYU8cwq+jDOxz9AlADOYsSZlfwm1mUrHVq9WqdZKpbju7lZhTB6Ax\n", + "BuBEqjqkwyQmTc4DwubENT5vhsG0k424gcN6vS5389CHpNl8LAxCYDaHeCSbBQYHhZWkJEg+PDxk\n", + "Npu1jnuS68HnWMzaG6QPVEa0wgclJ41woFjtQZIHwVFssxd4JDxzvV7nu+++K7cGI6BO2GVzLpfL\n", + "AmBQYNRGQeE7nGBPHmPrNTVdyvtIXrNnzTiceLirxlrZ+0GR8DszBQYezqEw+HXIBkXHXjFl6zwW\n", + "/pC8lrSP8CdNMSfTywZIhDRN69a1UljjpM0KIpckSdI/My98lvlgTgxOeJaPHpKXgqzwDE51AWLN\n", + "uPEOAAh7HObUoB4ZRTegdA3eAEckzDNX7pdlnXGwLg4TeU39e/d/12Ed+oUcms3wsWLGyHolaSVQ\n", + "+u8OY/Ms7pqB4WIu2Qsu2AlgA6zA6mK8zVpRD2S5XBYHkXcQgmXNALXIkp0BqodTMXw6nRYH0bko\n", + "6/W6nCRlXQ8PD0v+Gf1NUhxPnEY7D4TB6PPnz5/z448/lvfQ5/Pz81Y4HZYFUI0NY2/BXPd6vbJf\n", + "kNebm5skTZ0xWG+zYOgRKtQmyWQyKfk+7K1Op1NO0OKwAozqpN+67Yw5scLivhU2qBcYL4QFc0JO\n", + "TcXWIRdimy6PjsGz0fYEdTqdElNN0gIlzjWp7yZA8fF+cg36/X5B8aB01zhhfNBp3LvgvhntJk21\n", + "Qhrje3x8LDcwY/AYL2MzQOAkDV5esjUWVKxlUyDgMCnMNYARJYA3vF5vj7US+3XxovF4nOvr6zL/\n", + "9TFoh5KGw2G53t5AldM/yRaYUGDvWwAnSdtIO7Rg4GHvGAWfpDXW2kM3I8H3AA4opZp1oD+mjU2D\n", + "W76ReYNuvCYzmA6/8NN0Nv2Greh2uwWgAjwZj49U+h29Xq8Y+k6nU+6ccnVk56Qw32dnZ7m7u0uS\n", + "Vn0Le7x2KDgOyvcZP8bIFVEd6nJdGeaU7xh08EzXhEhSEiMdRuLd9op5758p8X9FGw6Hmc1mJUy5\n", + "2WxKkqvZMhto1gfd69Cs5dyfJYeCtaQmCrqcvVXX5EC/wDyjV/l/dDcgBEYXgE4fkNXlcllkpd/v\n", + "l/L5sDfkkgyHw1aelKteU0UWUNXr9UrBzrdv35YwIDbC+sEMFHqXMAxgZzqdlitZzs7OSv0Z9Kjl\n", + "E3uArvHlqpxuury8LDbr4OAg9/f3JVTnveB57/W2dwS9efOmBUjJZ+HvvHcwGLwKcl9rOwEnnz9/\n", + "Tr/fL2iPP6BaAwyDlKShrI12ASgsJhsCOtDPYlFhSEzvooiTtJQSRWhcCdbxThe/SppLr1DO5+fn\n", + "pdwyZ+5ns1kBEaenp2Ujfvz4sVCmLCZAwgmuxLjn83kmk0mZIwStjgEiEMfHxxmNRuW4GPPF3T3c\n", + "O3R2dlYE8Keffiq3FFMcDU8Vj9pJbvydPB+El9COAUntTQN+mCeML5s3acJIq9WqJHMxzl032Cd7\n", + "GVbYSfs4oA1RDVpQlvbqa1Dz9PRUkvKShir2RY3OR0raV7S79oYZMbMF9ioBI6w962+Wx8wO4MPH\n", + "3h2GYXzsQQx90lT9pLAiYT7mzewac8++ZmwYiX6/X/aPy3ATggWgmBkaDodFhwBuksZhcSVNAwh+\n", + "8hzXj2Bf2UGzoq91nR2UXTbWh3Lx3PtVh9/xnM0+ITsvLy9FVuv8FQ4KPD1t70FjvgAcAG+cV3IW\n", + "0Q/sDYq2wWZ0Op3i/QP2AA3kglCUkLmfzWaFJfnhhx+KnGIrGM98Ps90Ok2/3y/63g7acrlslX1w\n", + "QUTfccZ+MTto4Pb4+Jibm5tiG3HYnp6eyjFiElw7nW0+0+XlZcnhZG7Ze+hnbBB26NOnTzk8PMz3\n", + "33+fu7u7HB8fF0cVVopnUUmX577G0HNaDeaSz7FnHeJ6re2MORmPx0lSQMR4PC5F1rxRQXiOjZvG\n", + "ht5DWSXNLb945kwu8WQMt5Pb8ITYXH6uQydsQsCL2RnXRGHTQf8dHx/n48ePxXNC0blEMpsd4UZA\n", + "EQjmzoyFQRKgzciYhtBQcwCUfH19XWKNeCv2EjFyHz9+zPn5eZImj4XNxm3Px8fHuby8LEqm3+/n\n", + "l19+KYoVNgvwiFKj0qGPBvJ+EDveDO9PmvhunQS3y4YiQ/EmTQjSYQoa4AEZ9+ZmQ/Nv55JguAlz\n", + "EB6ELQAI1AnEVob2ZpN2QTbei8dXn1hg/9gr9NUIeMfsE+hf9iYyYYbH7JCBFP0E0Fg+aFDNPl2W\n", + "NLebG5TwDkAJ7Bs5KXyGXJSaZsewEqZFfxjAoFdQ6hh0M0WMDwfLYUz6jmLfNSuI8cTYj0ajYswZ\n", + "J/92bRIcDfQD7LLHjXMEeFssFnn//n055cKNu93uti4WenY+n7cYKBwjJ2EDihxKplihw5jonV6v\n", + "l6urq6KDAVKcvgLIEBq8ubnJxcVFK+zOn9PT0wIeAPuAIhwIZMrH570/Op1OPn/+nPF4XJ738PCQ\n", + "4XCY4XCYzWaTjx8/5t27d+U4NKCF/YYz++HDh9zf37dOz7BPqeHS7/cLwHt5eSml5X1IBObMR7sn\n", + "k0k6nW2CdK/Xy6dPn1q5nIzdJ19J6fijthNwMhgMSt7F09NTbm5uCvrlj+lr0DHAAAEETePZIHAk\n", + "cHKSxLUxKCDExPEs2BEjffrB7/HwQLPkzjjc4mS/zWaT+/v7Et4ALSYp5+kxNMvlMm/fvs3nz5/L\n", + "AkKJs4kAHpQPpnQx2esYqTpxkr4lWyF7//59AWPX19c5PT0tawCFCWLebDZ5+/ZtZrNZJpNJTk9P\n", + "yy3K1DsYDocFyXNjKP9OmsQwMvHxWBw2QkE5qZlj4N1ut8RPURjOjUEJ7pr6TtoFwjCSDnuhMPlc\n", + "HXKjAaIdiknSAiYAcudEGZSaIsZYOmQEPVwrGjMUzDnvR4adz4VhN8vJZ5zUx0kznu2wBrLGH/pn\n", + "8PRa+Mvz1u1uk60vLi6KHDnEQj4CMkSuCUaNPlIKoAa9zAWGxSd96I9ZKEIAyRbkkZPlOeCEBXOF\n", + "IXe4Gcp8l+3Tp0+FPUYfAdDQw4BadJ3HgV4y0HOeHpemrtfrsn7owX6/n/l8Xhi4pDkpCWvtyuDo\n", + "AoA/evng4KB1uzuAK0lhO9mz2AUDVBg/O8Xv378v8orMJimMG+9dLpelRIMdu6TJ2XM+DXOUJD/+\n", + "+GMrD/Ho6KgcTe52u7m+vi6y9+nTp7JGT09PJRyXbCMWRAfMmFIlFnZytVqVUNN0Om2dwOL3OBn3\n", + "9/fFeXz//n0JeY1Go9ze3rZyFZ0bhP3+M4dyJ+Dku+++K7TYr7/+WjqL0kgaj9LCTAO4cConScnb\n", + "ICSBkpvP50UR2asajUZJ2ln/UL/2+Jy7AbpF+AEdJH+SBwL9hbInDJI09CheII2wj+OMbHKus2aT\n", + "OyuevroUM58zAqdNJpP84x//KHkfk8mkABs2J8d9uYob2pnEKI4Ls2G92Z6envLx48eSCIuRhgHB\n", + "0Jo+RxmQCAf4OTg4KN5Bp9Mp8UpAJCeG2Ji7ThpMGjk1aE6aM/7IJYbNORxJmxVE9lA0DpMgQ47z\n", + "OhHbMV3nhdigO//EBQSde1IzBKbwUdJJu0gbYyC5EfBppwOljVK2PHNywgAC+XPisOccY0FxMIcc\n", + "iZGzHvZQ+Sz5AA6vAeBRog6T4iwBTviMw2f8ZDzkaBBenUwmLZ1E+BZmgXlCXnbdmAtqIpHUiPw6\n", + "FMnet4PnUzaEN9brdcbjcZHjs7OzfP78uYR/Tk9PMx6PWyA1SWGH6UfSsKxm28m9MPuHLHW73cIS\n", + "mLGm/0lzMs2hO4AHSfiLxSKnp6dFpwNIkVvrcoy6k2/Pz89LMbTXjPUvv/xS9udqtSoOdpISImQP\n", + "MKfsOeqHPT8/l9OhLy8vubi4KGF8n8Kibz6B9do9XHzeckG43Swm15sYXGNz7QS91nZWhA1BPDo6\n", + "ysXFRW5vb1sdRQmy4fGYLKQYxaSpEooX4qIxxMdM3dm7TBqBtQDxfxyrYvFJuqqpexI/AS0IOooL\n", + "dsBsAcoZANTtdkvlQk4S1OEBjJSFg8UG6fomTNPmg8Ego9GoeIar1aqAKTw1gEeSFoBIthvu8+fP\n", + "ubq6KgqVvBLi9ggx3hWKHqEEpGCcaYvFIhcXF0lSlHTSnNYidstJJYcn/hlF+K9qyAwN42dPHw/P\n", + "XrkTWVkXvGg2sY2ewyWsncEPtCxzxHdsKMy0AIJhEgz26pwXJ2w77OmTdvwfYzXLBYhHNvjpEAaG\n", + "hr4sl8uMRqNScdPzTZtMJrm4uCh7ybk4zJvDSfSJtcDR2Gw2OT09zWQyKdU1ofQZD/uZvzNG1pk5\n", + "A4DhicPOcPoBz3U2m5VcBOfcOMS1yzYYDAowpl/MDSCXELqdsSQlodWMUtLkFMGUJMnNzU0Bw0dH\n", + "R5nP562SDxjT2WxWTjlyMov5dWiEhHz2EuNItvoGubYjYUehrqjqPDj2HQw6DDi3KBP2ZI/A5qH/\n", + "2XOE0y2bBilHR0e5u7vLd99918rXSVLsEUCH7wFmcGpJnrXNcZ4abDe6wuweugDGmj7DRB4dHRXd\n", + "P5/PS07jeDzOu3fvWhV6Aeg885tLiP348WNRMHjNzupmEEwkE5Y0J17wPhDMJC0PxJOQpEXRouz4\n", + "O54TeSMu9wuNdnCwPY5GXJTEJP7/+Pi4MAoOQVlJIYwO19ze3rb62utt70R49+5dRqNRPnz4UKh8\n", + "DIKVHQ3l7rABPxk7Xs+HDx9KaAUBwRsEYZOEljTH9mArhsNhbm5uWsi609leioXxQTGAmA3WACn0\n", + "lY2aJPf39y1QyO9B/z7yZgDrmgq7bDXrUBvnpDmNkjTGFeBlWh+ZQZm8dk8GzwNY21t1sjYso3Mq\n", + "6BO5Tj5tZrmh1TkUdUiKPpghq8t3A9wdtqjngmdgAJLm8jV7sRg6gPxgMMh4PM7FxUUxaABjmFiO\n", + "c8IoEXIyo4G+waj1+/3MZrMis/SFNbChMmAz2+Kj2OghJ3QCqiwDzLe91102xojedM4HoMsAbrPZ\n", + "FIBJGBwASSjNdZTI5eBZSaM/ky34xOg6rw7bwXoljZPAmlBuALnjQAAev/P1zDwjH+PxOC8vL6Ua\n", + "K+NBFjnhOR6PW3dpJSmOw3Q6bbFi7DUcXeRms9km5cIU+7Z4HBWiA9ieTqdT7u6pWeRud5t35Rvl\n", + "YYmQL4clfaACZ55QO/ucd+Dk+D48F+D01SWbzSa3t7e5urpq1V75/vvv1OWGhQAAB0pJREFUX5W3\n", + "nYATx43tUUEvYby5cMjUdz35hDTY2CBFBDFJC2UmKQuOADrhFDorSVFahIpQEiBkP5cKfYeHhyVx\n", + "9MuXL61kOLyAwWCQ09PTfPjwoSR64Tk4J+Xy8rIIvFmE1WrVqvg3GAxyc3NTKGIy3AFyKF7m8/ff\n", + "fy+KmYRUo1o2MJRcst1A5+fneX7eVvDF2wQ9A/LwDii0hDJzKGKz2ZT5s5Ew0+R7G0DpTjhcr9et\n", + "BOdut1tYl103gwN7ZfbW+R39xyuELqY6Ixsb4A34cTIfQAjDh4G18nC4wkYWeWLdYFoM+vCE8fr6\n", + "/X7ranlACUod40GoDoWKh2baHcCdtG8ato7g+Un75l+AweXlZYmrQ7UnDciBYTKNj9FjfIC3yWRS\n", + "ZI81AHQD2jkh5fViHv1+jDN7xeARGWAPcdoCZy1pEvAnk0nryPQu2nw+L3OO7rSjQWgFXYisEVbB\n", + "aTk/Py96EvYoad9Sj1zBUqCTLy4uCvhwAiynYtBhsM/cNO8QJmEQ2DuSe7nUFF1yenqaT58+5d27\n", + "dyU/0CEtFymDaR8MBmWPAAR4H2kMLy/bAyA4pTA/7FHk6/T0tFWXi6qvJAkjQ5wGAnDAFpL3AThg\n", + "j7E35/N5FotFAfTMD3PEQQ7W4e7uriR0w5ACKNnH2DnmfDKZZLPZlr0YjUY5Pz//in0i4fa1thNw\n", + "cnV1VSaM4jhJQ7ViqJ2sljQhHbwLNq+pLZgTFtWeFsbw4OCgCG7SgBc2DcYaQ4+yxgvgvfQJQHJ3\n", + "d1c2MXFBAACb9OHhIYvFosTjfWw4Sen/8/NzPn782Ep2xQNFgfk+BeoDQCPzPd7NnxoYYFxgZCz4\n", + "rrY7n88zn89zcXFRjt8ZvEDrnZ+fp9fbFvIhhHN0dJTb29uyxtfX1616AEmK0XTYjjoUvV6v3POA\n", + "Yb25uSnH3fg89/7sutUhPQy+ATbKjo3uvAVySepYuZtzTvA0ydZH2fEee58wDSgj5ARP1EYXdi1J\n", + "Ab5JinfI3vLeSFJqLgCOXTDw/v6+gC4YIcsgbGmv1yvAnT3W6WwLOhmooexrFpS97QrK7I3n5+ec\n", + "nZ2VfIHRaFQ8Z/bAly9fSrgBDxanpPbGyX0ajUa5v79vlTj/8uVL2af0t9vtFiaQ5FrCITBT5N5g\n", + "/P+M/v5XNHTjwcH21CNrw3ohT9TaQP5IyiQnDpkGPAPcmDP2RX0a7fT0tIBIdD/rBWipLyZl3gk9\n", + "OS/GuYKwIVS3dn4VsgPwHI1GrRQAZIk54EQN4MRHj7FB3333Xfk8cmpW/fDwsFzpgj7GmYHlZP84\n", + "Xw02nWdiW9EvHz9+TK/Xy+XlZbrdbs7Pz8spOoOZ4+Pj/PLLL7m8vCxsliuXA3jQbTAqnz9/bpXb\n", + "4HQXoR1OZDqfaDKZfFvMCYlnKLD7+/s8Pz+3PB6ED48JQUSg7UmxaLVnjreBR8+kOp/CoRDeSzIX\n", + "iwyz4eqDgA6EebPZFBTpOKVDTHiBJBk6Ix0vL9l6f6enp1kul63jYHim9JvNnzQ5ISh2F2QzM5E0\n", + "FLNDKhgqnuXwEMfS+Dx06A8//FCOgHNyiPlmDh4fH/Pdd98VT4BTRskWyPB3DC1z6hg13/Emd0Ip\n", + "NQr+rBTyv7Ixz05GTRoQ7JguSof8KR/DZHwOESUN64IHBFMC24hS9f6pQ172dmAnqQ/B+mPweZeP\n", + "hLKPzF45yZCGbAHCkHufdKvDr8zXcrksoA2vEqAH43lwcFBAlStR8j3+wN5gbCaTSdlnzLlP+5HM\n", + "BwgnTOky5svlMrPZrCTX393dZTAYZDqdlpu5fS0GLOJ6vS61fyaTSVkrG3fndlgudtW8fpeXl2X9\n", + "fcqF36PHAQUYNWQQZhemD6AL6+cCk+RNwMSyXrwHMIcXTz/ZYzCEDnOik5ElwvROCH16esrV1VXZ\n", + "G5YT7wdYOGSfvtEIj3D6hfkARMPS+fQN7DQ6HrtBCM3MInIOuwxYBGytVqtSa4s9CghbLpf5/vvv\n", + "W3k6zMn19XU6nU7r9ul+v5+PHz+W00Aw5AbzgCaYxufn59ze3ubgYHsIBSLBl9f+Ues4Fr5v+7Zv\n", + "+7Zv+7Zv+7brtvuqVfu2b/u2b/u2b/u2b2p7cLJv+7Zv+7Zv+7Zv31Tbg5N927d927d927d9+6ba\n", + "Hpzs277t277t277t2zfV9uBk3/Zt3/Zt3/Zt376ptgcn+7Zv+7Zv+7Zv+/ZNtT042bd927d927d9\n", + "27dvqu3Byb7t277t277t2759U20PTvZt3/Zt3/Zt3/btm2p7cLJv+7Zv+7Zv+7Zv31Tbg5N927d9\n", + "27d927d9+6baHpzs277t277t277t2zfV9uBk3/Zt3/Zt3/Zt376ptgcn+7Zv+7Zv+7Zv+/ZNtT04\n", + "2bd927d927d927dvqu3Byb7t277t277t2759U20PTvZt3/Zt3/Zt3/btm2p7cLJv+7Zv+7Zv+7Zv\n", + "31Tbg5N927d927d927d9+6baHpzs277t277t277t2zfV/i+IAQDEy/wsagAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "diff: imagenet/bvlc_caffenet_full_conv.prototxt: No such file or directory\r\n" - ] - } - ], - "prompt_number": 6 - }, + "output_type": "display_data" + } + ], + "source": [ + "# helper show filter outputs\n", + "def show_filters(net):\n", + " net.forward()\n", + " plt.figure()\n", + " filt_min, filt_max = net.blobs['conv'].data.min(), net.blobs['conv'].data.max()\n", + " for i in range(3):\n", + " plt.subplot(1,4,i+2)\n", + " plt.title(\"filter #{} output\".format(i))\n", + " plt.imshow(net.blobs['conv'].data[0, i], vmin=filt_min, vmax=filt_max)\n", + " plt.tight_layout()\n", + " plt.axis('off')\n", + "\n", + "# filter the image with initial \n", + "show_filters(net)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Raising the bias of a filter will correspondingly raise its output:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The only differences needed in the architecture are to change the fully connected classifier inner product layers into convolutional layers with the right filter size -- 6 x 6, since the reference model classifiers take the 36 elements of `pool5` as input -- and stride 1 for dense classification. Note that the layers are renamed so that Caffe does not try to blindly load the old parameters when it maps layer names to the pretrained model." + "name": "stdout", + "output_type": "stream", + "text": [ + "pre-surgery output mean -12.93\n", + "post-surgery output mean -11.93\n" ] - }, + } + ], + "source": [ + "# pick first filter output\n", + "conv0 = net.blobs['conv'].data[0, 0]\n", + "print(\"pre-surgery output mean {:.2f}\".format(conv0.mean()))\n", + "# set first filter bias to 10\n", + "net.params['conv'][1].data[0] = 1.\n", + "net.forward()\n", + "print(\"post-surgery output mean {:.2f}\".format(conv0.mean()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Altering the filter weights is more exciting since we can assign any kernel like Gaussian blur, the Sobel operator for edges, and so on. The following surgery turns the 0th filter into a Gaussian blur and the 1st and 2nd filters into the horizontal and vertical gradient parts of the Sobel operator.\n", + "\n", + "See how the 0th output is blurred, the 1st picks up horizontal edges, and the 2nd picks up vertical edges." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "# Make sure that caffe is on the python path:\n", - "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", - "import sys\n", - "sys.path.insert(0, caffe_root + 'python')\n", - "\n", - "import caffe\n", - "\n", - "# Load the original network and extract the fully connected layers' parameters.\n", - "net = caffe.Net('../models/bvlc_reference_caffenet/deploy.prototxt', \n", - " '../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel', \n", - " caffe.TEST)\n", - "params = ['fc6', 'fc7', 'fc8']\n", - "# fc_params = {name: (weights, biases)}\n", - "fc_params = {pr: (net.params[pr][0].data, net.params[pr][1].data) for pr in params}\n", - "\n", - "for fc in params:\n", - " print '{} weights are {} dimensional and biases are {} dimensional'.format(fc, fc_params[fc][0].shape, fc_params[fc][1].shape)" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAicAAACbCAYAAAC5xzv6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvWuMbNl13/c/9eh6V7/uvT1zHzNDzgw5HNIWNInpMCEi\n", + "2wkCwYElBFASBTLg2DCM2LATSAkSJ5GlWDJi5EMAA0ngL/EjkQPFcuIQgREEcCIbAkJD9JhDgdJ4\n", + "yOFjHnfuq2/fflV1VXc9Tj7U/e3+1+pTfe+MqOkmWQtodHfVOfvsvfbaa/3XY++T5XmuJS1pSUta\n", + "0pKWtKTLQqWL7sCSlrSkJS1pSUtaktMSnCxpSUta0pKWtKRLRUtwsqQlLWlJS1rSki4VLcHJkpa0\n", + "pCUtaUlLulS0BCdLWtKSlrSkJS3pUtESnCxpSUta0pKWtKRLRT804CTLsk9nWfa1LMsOsiz7C1mW\n", + "/fUsy37+8Xd/KMuy9y+6j0ta0kehpWwv6QeVlrL9w0s/NOBE0n8q6f/N87yb5/l/l+f5n83z/K8U\n", + "XZhl2TtZlv2R36uOZFn2lSzLXsqy7JNZlv2z8N1GlmX/R5Zlvcf9+Pd+j/rwX2VZ9iuXtb0lfSj6\n", + "fpHtP59l2etZlg2zLPtbv4d9WMr2Dw5detnOsmwly7K/8fj5B1mWvZFl2Y//HvXhh0a2f5jAyfOS\n", + "3nzKa3NJ2Ud5SPaYzvm+Kum5PM+/JelfkPTPwiX/g6ShpGuSfkbSX8+y7NWP0pcl/dDQ94tsfyDp\n", + "lyX9zY/y/CX9UNL3g2xXJL0n6V/N87wr6ecl/VqWZc9/lL4s6THlef4D/yPp1yWNJQ0kHUh6WdLf\n", + "lvTLj7//Q5Lef/z3r0iaSDqSdCjpP3n8+b8k6cuSdiV9TdKPWfv/WNJfkfT/Pb7vk+f05Ucl/frj\n", + "v/8bSX/WvmtJOpb0kn32P0n6qwvayjRbCO9Iuv/42m4ck13/jqR/TdKPP37OyeMxvmHj+KuSflPS\n", + "vqQvSVr/qO0tf5ayveC6X5b0t54wrqVs/5D/fD/Ktl3/W5L+raVs/y7m/6I78DEK+j+S9Kfs/78l\n", + "6ZeKJlDSdyX9Efv/hqSHkn788f//+uP/N0043pH0Gc2iUZWC5//7jxdI//FC2JU0erzoHmnmIfyo\n", + "pH647+ck/Z8LxvSnJL0t6QXNgM3/Lul/Pkco07gk/SLX2vf/WNJtSa9Kakr63yT9ykdtb/mzlG1k\n", + "O1z/V/RkcLKU7eXP951sP75nSzNA9akFY1rK9lP8/DCldaSzIb+nDQH+cUn/V57n/7ck5Xn+/0h6\n", + "XdK/+fj7XNLfzvP8n+d5Ps3zfBwbyPP8b+d5vq5ZOPALkn5E0m/ns1zqRp7n70pqayb0ToeSOgv6\n", + "9TOS/ts8z9/J87wv6T+X9NNZlj3NvGY6O/5cM0F9M8/zI0l/SdK/c1648wntLenjo8su23O3PEW/\n", + "lrK9JOj7RrYfp3/+l8ftfnNBv5ay/RT0wwZOnkYpFtHzkv7tLMt2+ZH0r0h6xq5ZWDX+uMh1L8uy\n", + "PUn/smZI9y1Jn37c3n/0+NKepG64fVUzgFJEz0ryxfGeZvnPracbViH5ON6TVJV05XfR3pI+Hrrs\n", + "sj1321P0aynbS4K+L2T7Mbj4Fc1qBv/8Of1ayvZTUOWiO3DBtEjo4+fvaRYm+zMfoS3lef5I0lqW\n", + "Zf+upD+U5/mfzbLs70v67/M8/3W79JuSKlmWvZTPCq+kx0h9QdN3NAsNQs9plqO9L+mmZiE+SVKW\n", + "ZWVJV5+iv8+Fv0eahUL7H7G9JV0MXTbZfqr2jJayvaRFdOlk+3GU4m9oJjd/NM/zyTnPXMr2U9AP\n", + "W+QkC38v8uDuS3rR/v87kv5YlmX/RpZl5SzL6o/32N9Y0PYi+hclffXx3z+qsJvhcYjv70v6pSzL\n", + "mlmWfVHSH9MMjRfRr0r62SzLXsiyrC3pv5b0v+Z5PtUM6NSzLPujj0ONPy+pZvfek/RCCP1lkv54\n", + "lmWfybKsKemXJP29fJac/CjtLenjo0st29JMMWZZVtfMKSpnWVZ7rCyLaCnbS4IuvWxL+uuSXpH0\n", + "E3meHz+hvaVsPwX9sIGTPPwd/4f+qqSffxy6+7k8z29L+klJ/4WkB5oh8v9Y84L9NAj0NUlfzbJs\n", + "U9I4z/P9gmv+nKTG4+f8HUn/QZ7n/3xBe39TM+DyG5K+o1nB1l+QpMdt/zlJ/6NmxVI9zYf+/t7j\n", + "3ztZlr1uY/gVzSri70pakfQf/i7aW9LHR98Psv2XNJPR/0yzeoCBpP9yQXtL2V4SdKll+/GW4T+j\n", + "WZT7XpZlh49/Fp1RtZTtp6DsccXukpakLMv+kWZh0OU5FEv6gaKlbC/pB5V+UGX7hy1ysqQn06UL\n", + "7y1pSd8jWsr2kn5Q6QdOtpfgZEmRlqG0Jf2g0lK2l/SDSj9wsr1M6yxpSUta0pKWtKRLRReylfiX\n", + "f/mXPxQi+l4UEtvpeGfazbJMpVIp/Yam06kmk4nyPP/QfeBZ3uZ0Oj3TjyzLvifjK3o27VcqFVWr\n", + "VZXL5bm+TCaT9JPnuabTqabT6VxbRf0rlUpnriuVSiqXy+kexjkej1OfYr/4XS6XValU5u6jX4uI\n", + "ccT+/cW/+BcvNLz5l//yX84jbyAfX6lUSr+n06mazaam06mGw+Ecb5gX/5+/ua5cLhfyyuVtOp3O\n", + "zRs8529Jab6yLEvXweeiflerVY1Go9Q+c12tVueeNZ1O0zrgb6fJZKJqtTonUz6+eN9oNJIk9Xo9\n", + "VatV1Wq1M/KDXMGDRqOho6OjOf75syLf+Iz7K5XKXNv8TCaTuXmhvVKplHglSZVKRePxeE6XwDe/\n", + "P89znZycpHbK5bLK5bKyLNMv/uIvXphs/8Iv/EJOP73/UV9K8/qUuapUKmd4xby6jDk/aB9eO4/h\n", + "iaQk+ycnJ6l/9Xo9fRfn3NumH1wHv1038rxoI9w2xPXha3g6napcLs/pQO9TlJ1qtapGo5H0Af0Y\n", + "j8caj8eaTCaq1+uqVCo6OTnRysrKmfF4H+Ap+n1lZUXj8ViNRiPxjOuOj4/nxsrYfc6yLFOr1dLx\n", + "8bGGw2Fq9+TkRK1Wa279MD7ajDIwnU71S7/0S4Vy/X11zokb1g9LRQLuFBUjxMT4Z24wznse90fl\n", + "U/Sc7yXFcUZgsAgouJJY1EdfAJEHvlD9+vOMNb/9B+H2RSHNz5ErtUV9vSiKRpIx+f+TyWQOHAwG\n", + "A00mE9VqtWTEJpNJUgZx/viNMq3X6xqNRkmZwp88z5OBQElmWaaVlZX0MxwOdXJyMqfEHDi5UpdO\n", + "ZWA8HqtcLms0Gmk8Hqtarc6NnWdyL226IZCklZWVubl1OULxOQ8AHZubmyqVShoMBmnso9EoAWVA\n", + "eZZlGgwGid+AKJ+LaPjgQbVa1Xg81mg0OgNQHNRFw8146E/kp7cT9Uu9Xk/f05eLlu0iYCKdGr4I\n", + "lv0+QIobTV8PyGrUA7QPOT/8ueVyWePxOM2PdCqb8LEI6LAGef5kMlGj0dBgMJiTi2q1KumsfqQd\n", + "N7r+OeCBeV8EZGgzGm3nn+uOWq02txbH43EhiItrlzbQKycnJwmIwYNoY+Gp95U2mGvmAz4w//45\n", + "jo9/F/V7pO8bcBIN0Ye9F8TrCq+IXAjcO+e+85gZnxeVl3u3LsgfZhxPC8yiZ+jjdo86Kka/flHf\n", + "IjCIisXbLvL645giL3yeoKJ7fUFdtPKGFoFc/x/ejkajM3JG5AQlRGSiSKETLeDzer2uyWSi4+Pj\n", + "pLSyLEtG2b0YPPTj4+M5Beny796YG55KpaJOp5NADWDHjYwrT1fgrgD5PkZ9sixLAMLXkCtI/qb/\n", + "o9FIx8fHGo/HWllZSUo3rv0I8uCR95HvmE/4SkQD2UQRF4ESnkVECM/SjaGvEY8yMT50iBvdi6Ki\n", + "56PTisBIlFf/znkcwQ5tMf7xeKzhcJgAZwR7gADvAzxENlwXE+2jP/C/Wq2q3W7r0aNHajQa2t3d\n", + "1crKyplx+frjcwf19AmjHQGNrwPGALjwSJKP8/h4dmxKjHRCHkGBt75WHMg56GCN8dvnhGf5unA9\n", + "wryz/llj/iyupQ+sFXfYz7NnlwacROF3xc4gFqUTuDYqFtqBca7Mx+NxIUiJIaloYCJDI9JEyEij\n", + "YGCGw+HcuD6KMX1aYOJ88v6hUKEIYFjE5wlNVKLc6wClqC9xfn3huAHi99Mq4+hpXTRFUBdBm3TK\n", + "EwwoAMRD1e5t1ut1TadTHR0dzS1wT8dhaF2pYFS5ZjQazaVfUPjIBe3iKUbPB2OxtbWl27dv6w/8\n", + "gT+g/f19PXjwQL1e70xkwI2+K6ToxbkCc7BZJIfOH9YwkQ1JarVac6mQqDjpD8DQAXEE3bVaTZPJ\n", + "REdHR0k5cx26RFLqh4M5riPszbPwHh3ESPNpCj5nrhnbRdKiSKkbX8YICHMg6voB+RoOh8rzfA4E\n", + "wFt0AtEv0hu0U61WU7rD9UdMcbrM+Xc+nlqtlu7f3NzU7u7uGcAcwWSUG5d3f6ZHKhzIuEwCPhmL\n", + "r1kAMSDV1yL30Sb3+bwAvIbDYeI7AHllZSVFBI+Pj1OUMc414+M5AG70E5FeB94Q8o7Me8rX136h\n", + "zC385mOmIhAQ/3ePP97LZBV50QiagxSurVaraTF4LtGjDPGniOJCLJfLajabqtfr6nQ6arfbSaEt\n", + "mhDa+N1EiWJbruQJfcdxRJ48LUUvtIgWjdX5EOf2w3iJboAuC0CJER9XiDGU6/ld8skoGa7t9/ua\n", + "TCZqt9tqtVqqVqvp++Pj47k5PTk5SXJHRMO9UffQAM1e41BUW8GzWC8ffPCBrl69qq985Sv65je/\n", + "qS9+8Yu6du3amVqTouhJBOcobE9HkVuPawpyw4DiJ5oT8+WNRkOtVkvNZjOtP4xATEm44pekfr8/\n", + "xxf66j/0GyPK355Wqtfrc+Fs5ou2I3h13qCfAJ0XRRF0S2droKIT6Y6MO4fMJTJ6cnIyx5PRaJTk\n", + "Ns9z1Wo1VavVVA+Bxw7Ydu/d142DEgyvdLYmg3sajUbS1Z1OR1/72tfORJv9N8bYdVcEJi5j8X4c\n", + "lLgmWP84EZVKRbVabU7HAehYKw5OfL7grxNy6vchn57mYd5YU643fC24fuHZ/PYoD+OmRgadt4gu\n", + "DTiRnhxNcIEr8qgQfPecIPfeWShENxyY8ByUJMaiyKAvMuT0gZAcqHR1dXXOS3CKSvV7Qb74ouDy\n", + "G8ULP6LHUzSuou/8WfwuimB5lCXSkwBKfK6H7L8XgO57QUVK3EGiyyB9RvnU6/Ukk0QDfBH3+30d\n", + "HR1Jmnl7ROaoueAHZTQej3VycpI8G+TAUyYYAQpLiZ5BrjBRYleuXNEbb7yhwWCg8Xisv/bX/ppe\n", + "eumlBCji+GL0zuc2epIuY+5U+Lp3xc+1tVot3cvYAVrwxQ09hp9n1mo1NZtNtdttVavVVJToBcIo\n", + "ZXQLfXej616wh83RHcwv97txdwPjYAj+XyRF+ZXmo9YOYD0S5pE3vHSIQmj/DJk/PDxUpVJJha0r\n", + "KyspCh2vJfpImzyfuXbADbmHPx6Ptbm5qevXr+u73/2uBoOByuWyfuInfkKvv/66arVaKqZ2AOS0\n", + "qPAWPvG/f+eRFo+sMKaYCeDaRqMxB95wUJBVl1F3ODzSQYGy9xlZc7DhEZMIPH1uvZ9Q/Jy16jJ9\n", + "Xjbgcmj0xxQXatGPC0VEred53M4IhMsRYRQoyNFqUYgyeuz8T9iR9ih2JIISDWpEzx+Wbx8m2gAh\n", + "dB4yBKzxA7nXzfUOVNwbiF535A3t+e8i4/Mk8jmMsnFRFCNCEaw5Hx0YYticp+PxWMfHxwlgoAjI\n", + "w2MsG41G8iLxJD0SwU+WzarsW62Wut2ums1m8uxj/5ljB/yMYXd3Vzdu3NDq6qqm06l+3+/7ffrS\n", + "l76kP/yH/3AyvihYV7juVHgaxPkUDbb3Cz56SDiCXZdRrqfO4Pj4OAGabrc7F3mZTCYaDAbp+na7\n", + "nfjAs6h5iLIe++QGhz4xx0Qvfe59/Hjj0qkXGz3QiyDkx42RpxGgqIsjsMNALtKdrg/6/X7y8svl\n", + "shqNhiSlQk6cR7xxUm8RyDkQwIgzDgBSs9nU66+/rmazmcDh7du39VM/9VP6B//gH+jg4GBOn/Mc\n", + "N7RRlqX52g8fK3PqNinqDbcJDvzr9XqSWeTy+PhY9Xo9OS+kU+A1axKnh/56dMbnBZ5Hfcb10e6y\n", + "7rmOsdMmc0Yxb1wjRXTx2tyoyOC7Mo+KXZoPAxcpQSeE2ZkXQYkrPE/DeH+ipxf/RuH4fQhYvV5P\n", + "4UwoCsV5qaOnoZhWcP7ymY+3aBwOQiJf+HxRGm1R+4yhCJjEuYsetvOgSBaiorsoikrFveEIpJx3\n", + "Ll947fCeYkwACUoRXmH0SP8MBgMdHR0lEIMiajabKpVKKXrHNkIiK6whgI506ulzP+sNw9lsNjUc\n", + "DnXt2jX93b/7d/XKK69I0lz0kv56CNejKbVaTVtbW8n4eMrDr0X5OeCBx3iSfMe1k8lE+/v7CZzA\n", + "s16vlyJHRJgcPFCYzNiJLnnks16vq9FozIH5CK4whi4XGAieG9cl0QSPeF103Un0+KOedPAa16Lv\n", + "DvE0BPPleoBnYXxHo5FWV1fT+gHgABJLpVKqraIWwo2mry/66s8C5Gxubia559nValWDwUA//dM/\n", + "ra985SsJ+EvzoCMWlPo8ukGnHw5MIqCJvPAx8X8cBymmPJ/V7xwfH5/RMURamQ9sITyNO9ikU0Aa\n", + "+xejOi4bbjt8jdLfCNDPc6ovBThZ5Pm78EYD6r+5H6YvMs5efOio168vOhOkqL9Q7J8XcxVFQ6bT\n", + "acqNR8Md23aiXy5kTkWGOSL4WFfiHmbkhQtZfJ5714uiSBHMoNyLUm6+oGO0oYiKnn3e9R8nORhx\n", + "BYnMRa8u5rQdyFAr0W63VavVknL3KAnPbLfbyQhIOmMUXQFhGDHkHoHiGnb9uDKeTqdqNBqpPfo8\n", + "Go3U6/W0ubmpt99+W61Wa86ro09FnjJnlOzv76tSqWhzc/OMTEYD7V5qlmUJ8G9sbKjT6SSgUq/X\n", + "UxTp+Pg4pbyYBzeQHnXy3RE+f+5les4fuVtZWVGz2Uw7l2K0AWNADYWDGp5Tq9XmtpNfBsANFUVF\n", + "3MD4mof4HzkrlUpzdU5EUtx4uZywAwuj1m63UzsrKytz9Ti+o0qa9+5p1+Ud+apUKrp//746nc6c\n", + "HOT5bEfb9va2vvCFL+jRo0eprw4YptPpXB0YbTqY3d/fPwOYuJdxR7vCWSYUZUun9SKDwUDSaYSE\n", + "owQAL6R6vYgbOYvR6Qj0pZksu/MUASF6ivn3eUcH+v3IuQcHiDYuoksBTqLCks4KaYxWuHHy3KIr\n", + "GhdOCIYUGcMYFTmPzgMo0fhyPYKRZZmazebcuPyaSD5ejHxUAEX3OWDwugKvbfB2HNxFYLMoolEU\n", + "OYlgpSjSEZ/NvAAaYxGzp+BcqT9tNOnjpKKIjisCohNey+QG04EMhnd9fV3PPfecms1m2l3gSlmS\n", + "Njc3U/rQFZJ0qjC8NsXlMXqm/C8p9fXo6CidFwK4IT+PPO/v7+vGjRtpvD5Gl2FoOBwmQ0y0J9Zl\n", + "uZGPvPXoHbtE1tfXkwfpEaY8z5Ox43mHh4dJ7tmVw3W+U8Lnj3Sbg8Q8zzUYDHR4eKjj4+ME4rhf\n", + "Oq0Bcg8dAMpvQKQb/uhwXSQVOVJRZ3vdR9ThjJu0d5ZlOjw8TPdHvT+ZTNTv97W2tpZ4Q4oIAOAy\n", + "7ODaQQggyHUIstNoNPT222+nKBZpP3azVKtVPffcc/qH//AfJqDkZxHRF8YuSe12O60j0qb9fv9M\n", + "3QWG3deqpARSGeNkMtHBwUEaG2uS59Xr9bnUFnLpEZEYNUXv0CfmM25dz/N8Li0J/yPQKZVKyXl2\n", + "HsHvPM/TDi2cjfMcykuxlTh6youiAItQuv/2XOQiQ+/PiwDFnxc/9+cjFBEknNd3aDweq9VqpZB7\n", + "BGcuvNLZA3lA7+4lnOdhwRdH0R49YTzON/f4fMz+nRve6FGd5/XxvSuzIl65QYpeWgRFi4Ddx03O\n", + "M5SOg0+POERvie9dSeEZkbPtdrsajUbJc3J+oPQxbu4teorAFQrrhXoKvBuPCGRZlkLFHp3Jslk6\n", + "BS8P5fn2229ra2tL29vbSbF5JCE6C71eT61WS5J0eHioer2eUkgOLvhxvhEJIbSPfAPQWCNey9Hv\n", + "95Nn6NsqUZxxB0FMM/nfbgBcVo+Pj1MEBcPoUSd4xzM7nU5h5Pey1JxALs940IsKTn2dMy95ns+d\n", + "aAovqC+J5+VwiikGkfM8oqfutRCSEljwg78g11flcjlt0XcQSRQGh246nepP/sk/qTfffFMvvvhi\n", + "enae53Nrjn4dHx+r0+mo3++nPnvE0vvsa8r1qzsB7DZy5wJHoVKpaDQapXoOn6OjoyO12+20zqXT\n", + "g0U9Aun1Iq6fIHdeAEWAJo/++RogyhN1huuW85zLSwFOnIqUuit3yBWFpwq4Lxo9v9YFwZVffM6T\n", + "DF5RiLMokhDvkWYTtrq6qoODg4UAyckP7EII/EROH09E5d4/DJLn6KXZoqYvfj/fedqHau/oFRUB\n", + "PO5xPkVA50K/qN8u3P7b5+EygJMiQMtPTMXE8Cq8ByRg2LmeuokYnYNvk8lkziA6CPVnS6cnO7oH\n", + "CDDBu/J+UXTna4o+4TmenJxobW1NR0dHc+uQ53hdAu3WajUdHx9rZ2cnpTvoCxFCV6wnJydzx5QD\n", + "Jg4PD1UqlbS5uamNjQ1tb29re3tb7XZbm5ub6vV6yvM8GRwMheublZUVHR0dpV1LhMVjvz36w7gG\n", + "g4FOTk4SKHLDjHcP8EC5D4fDpLv29vbS9bF439fkRZGvX+SKOS46RIwx+LqF7254vSDZD1uDV6TB\n", + "AL4eWfNn8T/8d17SZ98t5LpwY2NDt2/fTp+z7pBlIl6NRkM7Ozv65Cc/mebR0zKu54jisc7ol9se\n", + "6RR8Ai7oe1zL5XJZ169f187OTroPYNtoNObAFHwk6kPdzu7u7plIU0xrQh7tBGQcHx8nvZ/neYqa\n", + "wudSaVb/w5le6BOADOOg/9JpmqqILkVMPBqiGEkpMj5FBiB62R7Gk86erOftegoogpain6J+F0Ub\n", + "ivrL/z7xT2NcY2QDwfCtwPw4cPBxudJnESBYLihxvN6Gh+r9uwhWPITqCtsNl/MvzouneWKKzucp\n", + "zstFUwSnkT8+fucByszlNM9noVDSESghH6sbQNINGHg3ENLZd+owN767LK43PGPkhvbH47GazWba\n", + "9bO5uZmA67vvvqutra1U7yGdPeMDD5pUI9dw/WAwUK/XU6/XS/NLvQcRD9cX6+vrunPnjt58800d\n", + "Hh6q2WxqMpnom9/8prrdblKmWZalrcMYBJQuqRUHdRGQ0YdYF3TlypXULsXHgCfWnusowObR0dHc\n", + "WR/uibo3epHkMu2AQJqvDfJ+xj57ZCtuKeb6aAN8h5U7O74d1q93z57/+XHD6ilLP5wQfeXgcTKZ\n", + "qNvt6uTkRD/+4z+uN998c64WC4BGP5FrT+MQgXFdiw6nloo23HGRpCtXrkiS7t27Nwf0X3rpJT18\n", + "+DCBEQextE27h4eH6nQ6CRz6kfxuT5gX17kArXq9Pgfo3dbx7PF4nNqG7x5BcSB5nhMvXZLIiRsc\n", + "F7SIvIvuO2+AcUFFA+gTEJ/H/7GPi/qyyMDGBRqNa7PZfOJOI0fbCHdE4TzbkWz0zN3wubH0diMV\n", + "8YB7/Hf8PipUlFKMiPl8u6cDwRsfcxHw8nm8aCoCovQ31kV5usFlIypkf0cHCtT5RtqFe5l/B5wo\n", + "Wv52Im3k/UFp4r36rjiupf4Cj5aQOy8AIySOjNHfLJs/HKpUOi3GzfPTY+lRaO6ds8MGg0PE5N69\n", + "e+m9NJ7b39raSpEZ2vFIBn3Gw4N/bsyguIUUXrTb7eRxHx0dndlN4YoanlDzwjjgp8s5vLloQpch\n", + "y16X4PojAm7IQXnRSx7hd9FnyEmUF+msjXBHwKMmvu7oFwe78T9zyX3UdlSr1XS4IeCfefUUo9ed\n", + "IGMHBwcpAkKUkAgCab1Go5E+J/qAnK2urqYic+l0DY/HYz148EC3b9/W1tZWeh59j4AtHtvPvDnQ\n", + "AGRlWZbW2HA4TGkjb8f1yHg8TnVwOADMkRd7e9TkPLue5vg8gfy4KHbQ/4/hzUURhuhFx+tccBdF\n", + "Qnhe/Oxpn+nPiQYnEn1ESD1SE+/zz2IUo8gwI2x4iVRzg+i5xqM90Vv035Gi0vH+RpDmz4g7oRZd\n", + "6/fQDwxJ0RwXzfdFURE/XVlHhRBD/ShPL3aNZwsURbJ8J4qkFF2Q5j3aWESMFwWwoJ/MPZES8vIo\n", + "XyIRXH/t2rUULaCY9N1339X169eTMiLiUBTZ41n0kVA6hxiylfrk5CQZ/0ajoVqtphdffFH3799P\n", + "0RdP22BAut1uMvxRHqfT6VxxHuOMCr5UKqX6BwzldDrb2dHv9zUYDBLYcZ6j1DmfAmo0Gtra2tLa\n", + "2loqfC7ayXNZIoLS4vOMfC7ROXENu2MU1yv6ynnvxsyNrl/DHBU5lTyfmhB/NxLAh2jgyclJ2t2F\n", + "Qa3Vamq1WslQA8i/+MUvpq3FXmvh43HekKJxsAT5Rg523NC/Gzdu6N69e+p2u6ltr9fAKfCXdhIx\n", + "ZfwOIvjOgRXXMQYH9dimSqUyd64S68Vf2On3eaG46zzn1dPQpQAn0uJiUunsdkvprPFeBEyiwERD\n", + "sGjhn2f4i54bjQi/mUxftDHF4Tt3/PtFPPDaDIQBpemFwBg5ThR0PsfoBc9GeJ4kQDFKVPSZG+Ii\n", + "MBQ/cwXlB4Dxcx74uCzgBIpKyOc78pbxudx4sZyDVk7KRIE5yPW0j3v3TnweUziS5jwi+sj25aOj\n", + "ozSGRqOhR48eaW1tLX0/GAzU7/c1HA5TcepwOEx1H3meJ0VH2x7hIzrj/SHqc3h4mIw/r2nHC3zh\n", + "hRf09ttvz+W9pdPIEGum1+vNnc7qz8GAeWjcQ9YeZfLDpsitRxBNG6SnmBs/R8bn1SNO/n4TX4dF\n", + "9XMfJ8UIUgQj/p3rJwfi6Jaow1jrtOv6gdRIUbqAtiNQihEvl2lfSxSUAkyGw6FWVlbU7/cTKK9U\n", + "Kur1ehrW5XRPAAAgAElEQVSPx+r1eumVBq+++qq63W46D8fXGvYFYz4ej1MxNPO+v7+f1oNHuxuN\n", + "hqrVqj71qU/pq1/9amE0xNO/nU5Hq6ur6dkxosV683QKbbL9mWsdaHhKmDVA/z3KRxlB1Fk8qyha\n", + "7wXn58n1haV1okAXUdFigGHREDpKQ8DPi0Kc542cZ+hoPz6b53vo3Ptb9Ey/p16vz70h1vt/Hm9c\n", + "qFDOCBJ5QhdCVwJOrhAZf1EfXHl4P4rADuPz633eI5/d03I++5xGHsQIwkWTh43jWKFoRH0OpdN3\n", + "s6AckS88Pdp2hVAqlVJOG2XiYXjuQem6d+XrhjHQNxQb6Uc/7Gk4HKbi0U6noyzL5nYkdDodHRwc\n", + "6ObNm9rb20uFrMgDyhjgjOIjIjOdTtVqtdLaAHwBuJ9//nn903/6T1Wr1eY8U49AuTy5EvXP+fGX\n", + "ybmsOf88rVMqlZJBc17FCEwEO8iqp46IclHwzPh9Li+aXM9KxccgeK2TdPY9Ng5IvSjSPfJYc+V1\n", + "Dp4yiMDat6BHpwj+kTqhn1evXtU3v/nNuWuQt0ajkXa7IHsrKys6OTnRzZs39frrr+uVV15JkRn6\n", + "Op1O0y4j1szBwUGK6CFDnEjsa3djY0ONRkNf+9rXEqDhmuiolEolra+vJ7mODhw8ZltzUVrXHSPA\n", + "NLt7aMPllXucXz6n2B8+90hUUTDgPBt3YRIfjfzTXO/RjKIohBuxmLeN0ZUPS4v6+jRj8IXi9/iE\n", + "8WIyogaOOPkMpO1eeARgLkQUKjqAKIpQOZgoSrcUXRvBm0c9YjqjKAR83o/zbRH4KeLxZaMir1I6\n", + "+xoEUgzRCPGel0qlks4PcCXgQNRBCafLesG1NF+g5usjAr8YwcJzRYkxL+TrO52O7ty5o4cPHyrP\n", + "85RH530kAOROp6P19fX0MsxGo6F2u53qaYoMMAa81WppdXVVrVZL165d05UrV/Tmm2+mAw09ZeMA\n", + "gXngDAsUfVTyzg8Hbhi8RqORdkWUSqW5tJmnn2I6A6OGJ03qRzrd3ux9JoLiHvNlASZRZqJzIJ11\n", + "OpFXZDjLsgQ0pfnDHpkTj/ph+Fjzrv/8OR4diA4S17mMcF7K1atX1ev1Utv0tdFoaDAYzPWl2+3q\n", + "6OgoFVr3ej3dvn07FYYfHBxoOp0mkMvrHTjLh0gKMsazWCdbW1tqNpv67ne/m6KIyA9zgKyUSqVU\n", + "d4Je8JOdnbd8RlqLqInz0qMZfjpyBCE+V/AaZwQeuwMSoya0g+1a9K456YLTOk9jUIquiUo1eub8\n", + "/jDg57xnezvntRk9iaJ7QKEOLpikWq2WlCCH8OCV4TUTpuP+IuNNuC8KUVFfI2iKAMOvj8oJcqGN\n", + "URVXIg4gFwGM+BNTI0XXuyK7aCrqY5GiLIrOOeDm1FX47qAAxeRnl/hceoE1oVeUoSs6nsmPH2jm\n", + "USjeNQMoIv+OsalWq+p2u3rhhRdUKpW0sbGhnZ2d9OK8d999V+vr66rValpdXU31FZubm+r3+2q1\n", + "WmkcACrm0iv9pRlg63a7+sY3vpFSqRh1D0W7LACQ4AWASzpNxWRZloADaVIHj4T02WHDlmbfHRdT\n", + "S3k+/wK/6XSainIxen4Sp89P1GexgPkiyKMmEfxFUFK0vvmMuSCKwXceMYopyxiB4bn+WTTi/I1+\n", + "cKeOZ+HAxSjXeDxWu91Wo9HQ/v6+JOnb3/62Op2O8jxXq9XSa6+9ps3NTeV5nuqgqBva3NzU/v5+\n", + "KqZFpgDJABgOC+x0Oup0Ovr2t7+dapMAx0RcfJ3zd6PRSLuKWO8uOzzHSww43A2ibZ9H+EBqxiOG\n", + "zLPz1aOtFHxzjTvQ7lx5Oq+ILsVunSdRFHoY5p8tMr5PIldiRSmMqCTOa+e8PdtS8YL2v3npFH0p\n", + "Mr6er0YxuwDW6/VU2R1DsHEcUal4SK5IEUTQwT2LFBY/GBGMnxe+RYMZjbYXv0U+LgJoF00xxege\n", + "u6Qzf0MoOQeB7u2xqJl/VwoOYmiLfvgr5d17gSIYcY8ryzKtrq6mLZ3SbE6oLyHkvbm5qbt376Yc\n", + "/bVr15JnmOe5PvjgA5VKJd25c0dra2upePbGjRuSlA4k9L4hL+wIWl1dVa/X03e+8x01Go1k3ON6\n", + "YPx4iHyPUXT+MX4Al/MhplggT29xwixGJAKkWO/AgVxe8Bwjix758fV9keQA2yMXvvadf1FnezE+\n", + "12JIoxfuhhPiHsjr+5AzqfgEW08B+W6cSqWi3d3duV1S3s7x8bH6/b6uXLmivb09ffrTn9adO3e0\n", + "sbGhjY0Ndbtd3b17N0U5Op2OJKWibV7pgLNA9IgDBt999139/t//+/XZz35W+/v7+u3f/u3EJ/gT\n", + "X5ToRa0e4QOgwBPptP4E2cahwWnwaCvpFwcTlUpFzWZTo9Eo7YLz4tsIVvmbscbyBtfPHpVdRJca\n", + "nBRFTfiMgrgYOSny0p8mQnMePcnoUSAUc6VuIPCKHWzgIbohkzS32GiL7wg9YvC5H3544dV5/Xc+\n", + "OblR8ghNETigr35t/OF6H3NRBKVojtyrWhQ18fFdBnAC8HAA4t9FEBG/q1QqqegOmUIxFM2r16AA\n", + "5LyCH9Dsnkw0HG4kAAO0t7m5qcFgkDw8j+Ksra1pNBrp7t27Oj4+1tramvr9fgIopCIBXOyGODw8\n", + "TFEKP1SLtM10OlW/358z1Ovr63r48KEePXqU1hmnbjIOz31zDbUIKFaIHD98oZAYHjH+uFOK+YC3\n", + "7Fhg3IAi6RRYk+9n94M/w4Fn9OrRK7EG5qLoSXo0ppil02hFr9dLL3b03VpehySdvpLB6xe8wJLr\n", + "mBtPdfqOFAfu6Arko1KpqNvtqt/v6/DwMNV3wX/08mQy0bPPPqt33nlHq6urOjo60gsvvKA8z/Wt\n", + "b31La2trarfbOjg4OFM3+PDhw7TLplKpaGtrS++8845Go5E2Nzd1eHiYouXb29sp8uL6nK3ObvO8\n", + "Pge+OPjx9c24PApCfYx0un3fnV/kEh3AuT882wt9mV946uvOHQB3uD0yC6hbRJcanCwihI3iokWe\n", + "qBv9mI7wlIrn1NwzeBpC+Xvoscjbkk4LIYuMludVvU8uOIyB0DRj95Coj4G2FxnvaNz9f8YCuXFz\n", + "QiFEfkWQyPjPi4JA/v2i6FURELkM4CT2MRoW5tprRTxaVS7PzsygfgGj6vJQFBL1iCKGlTbxihyo\n", + "uIfrbfs5G6VSKR0QRr0EtVGHh4c6ODhIAOT555/XN77xDT377LOpaHB/fz+BFHLrtVotHRrFzh5q\n", + "Vw4PD9Vut7WysqJGo6Ht7e3k5XEYGzwplU6L7QAWrAd2YLhOGAwGc++U8vCyA0PuZx2hwKX5NzTT\n", + "LnKLkfIcOoaWMHcE4w4KXVY8MoFR8JqAi6AYCZTmXwUSx1aka46OjhL4RI+5nHvxtztzGFl4ESMH\n", + "ADiXe/rkfefv1dXVFGV79OiROp1OknPp1Dms1+v64IMP9JnPfEbb29spRdlsNnX16lU9evRI6+vr\n", + "aZs9RbBZlqW6r8lkovX1dR0fH6dtyScnJ1pdXU1Ag+gNssXuIYA1AIL0Dueg+FooOgbAX9QHT5Fx\n", + "1+MAZ7dBzO3h4WFyQpgj7oenXjsVo2vu9PiaZE6/byInRUJ9HlCITD7vWhjn3ngRFQGUon55uyhy\n", + "R6zSfL7NF07c7iXNv2mVe/k+9qMI6eJlRPBQ5HHFyAb984Iq+PW0Bv+8KJePB4V8XjrN+1TUtivv\n", + "8+bmIol5iukT6XT+ixQyvMGz9+hBBGkxouVpBBSj70yJIXNASpFCl07fXgzguXr1qo6Pj1WtVlOq\n", + "h/6/8847KYqwu7ubvCvAjG9FrtVqGo1GarVaSW7xVvf29hL4wqvc2tqae9mYe4+sK093+Qv7PDXE\n", + "OSnw19Ok8N4jXyhzNwSACnd2uJYQONd64aJ0NprrwJ4x+Prjt6erLoq8765/FgGROE7677s3Yo2T\n", + "A2v0hPMBHeVOoPPR0zX87YA9ptmm02kCDb1eL8k7RdqVSkWdTkcPHz5M87q6uqp2u63d3V11Op0E\n", + "1G/cuJEOajs4ONDq6mra+n7r1i29++672tzc1IMHD3Tt2rUE1Pf29jSdTlO6Tzp1+Oijgw1qWIim\n", + "AlRcTohGcr3bJS8XiM6wyxipyvF4drpspVKZO5TR5QDe0lfa9+exzqNNOS9defGxQp01wNCTIhiA\n", + "E5Ss52+9zSjggIkIIiLQKeqj9yca/hhxWNQHNyr+zDi5Hg3xNj3MyWdFudaisRQBDj7zQr0oeEUU\n", + "+xUpGk7a8blyBF7khfnnEbhdRvJ8bJEc+DUoEul02y5Kg8XuEQ4PmfpcIRNe2Q8xr34GgRuXIs/F\n", + "PVN2VjSbTe3s7Gh/f1/3799PzxsOh+nY9itXrqjX66XCbtIYk8ns0Db30Djbh1DxcDjU3t6eqtWq\n", + "Wq1War/T6Wh7e1sHBwdz50YAmtABnFLpB5nBN2n+3VSSUj4fDxmZo4+ef3c9g7Hzc3jgIUXsXO/f\n", + "AcB8pxRtY5zj8xyEXzZy4xQ/j/pWOtXVXgTru5HifQCMWEuCIXf95GvDvXr0ImCS38PhMJ32Wi6X\n", + "tbOzo+l0muYOmTg5OVGn00kRvt3dXfX7fR0cHGhvb0+S9OjRI1WrVT169EiS5opTKTy9ffu29vb2\n", + "NBgMUj/yfHY6OClPf5N4BL6sb+QV4EFxroMaZBMggby6foGfDjb52yMn9MXfZeUAMkZzXQY8MglF\n", + "/fYk+34pwEmkCFDOIwcmfgCSg4kiAxoXhLe36NmLDDDPY4G4MXBh8Jw4HlNUPrEYzp/D2Lyv8f/Y\n", + "x9h+EViifxyh7AdGuSFzKuLfIkErAkdR4S+KvEQD7wAlem2XIYISCyJ90cNL9ySl+UiQdDqvflKo\n", + "e5duOB2cuGFDMXtEzdeKA1/IQS73EOUYDAZqt9tqtVqpgM6jHVevXtXdu3clSbdv3067UDjOmjoa\n", + "Uku9Xi8p2UajoTyfFRSym8W9YbZuNhqNubfTxl1vR0dHc4WBPhf0gR+iKOy8cb5JSkaAOYxpMD+N\n", + "NxpVThb1GgCMalxXDnJIJ/h8XBZ6UhTVDU0EGtEgeRTNgbBfx7XS+duNixzEGHWGpxhVQFKj0dDG\n", + "xoYePnwoSXOGn9cMfPDBB6rVajo5OdGLL76ow8NDHR0d6eWXX04vI5Rm9U+DwWCu8J8i6StXruiz\n", + "n/1s6kuWZSlaA6hGlrFjTkTvqtVqAjiM88qVK3PRR8bqLw2Evw7MPTLFevHaNJ9P6s2k+WitrzNf\n", + "i1Hn4VC4bMQIYRFdCnCyqIMx/LToWlfsi4x+UXvuSS0y4ovaKopU+IIqMqxMiEcOpPmdOd6eLzL/\n", + "7cas6CeOORqyRUrPt7vF02adT867+Hlsu8iLiv1b1O8iKrqWti8DOFkkr274fQHHcKqHoFEcnlbw\n", + "NICfVuoy4VuJoyfk6TWPBKysrKQQsXQaYeFtqZ1OJ9WPdLvd1FdqSO7cuZN2K2xtben9999PefjB\n", + "YJC2xWdZltJBHELlbzt2Rea7awiTk9JpNptz4X/4wuFw7iHjMbfbbdXr9RTVIdKysrKidrs9B/BQ\n", + "xvFlmvAR4wWvYkqGfpOi8iiK9xfZyPN87mVsDv5p4yIp6k3vu4OE6JnH610HFTmCRW2zJqRTwCnN\n", + "p4ijTme9RaCEnCFT3/nOd1IhN8+aTCapDqrb7aZC8Pv37+vVV1/V6uqq+v1+OlW2VCqlc3sAJBw6\n", + "mGWZer1eems1ckTqhQgOaRppvobGdQNpo9FopI2NDQ2HQ7VarbndY35elsuZF867I89n/qwYBYlz\n", + "hmx7eifaTuagSFd71OQ8AH4pwMmTyJHYede4sY8gJTIvKm5vI3q1/I6LIAIRb889hggmYhTEF/J5\n", + "nrA/w+sQioyhG+yivjoCXiRI8RkeOnUqmhtXsJFvRfNS5GktIh9TUQTlIqlIzqTzAbhTTKn5fbEu\n", + "ATmJ9/s9ePIxhcN8RkXB/XhqpdKsKHZ7e3vOgyLsjbePDOF9Pffcc5pOZ8fGk6bJ8zwdPe/e73Q6\n", + "TVuDvX2MXqUyO2GTQ+m8OPLKlSvKsixtoffCWEDG0dFRqhXAgFQqlXRwGump+J4d38kAEflxeXXg\n", + "yLZn37HjxJxyvobPq7c5nZ4e3oVBuGiKssX/nqIq0p2u2xi/R7ljhCTyIepVCH7HKJRHyxyUAzzg\n", + "JXNAZAIZ5kRVj7CwY21nZyc9KxpsUjakVJDvWq2mwWCQZIzD3dBbRTIiKTmJjJs0zv7+fvru6tWr\n", + "iZ9ZNr8zjD4SEUfeiorp0QFuC3CiIe+v82uRQ1bkhOV5nmpYnkSXApwUoadFnvR5SEsqTm3Edvx7\n", + "L9RZ9OxoJKLRdSF1Y74IGPiE8TmTR1/8gK0IvBAcF6oIYOKzPXriIWrGGt9YCbmH5+Mo+ryIV/Fv\n", + "H8+T5ioqq6L+xe8vA7msMseLgGzRPX4tcuLjdOXioVWXhQhaUNQo4ghivXjW2yiVSsl7ROlzD8Ye\n", + "gEI0gpf0cWAaY+BE2GazmeozJKWzF3hXDRS3le7v76edESjcfr+feEf+HrDhp2y61ww/SCG50gWA\n", + "+dpwj9ZTOniQXmTJdUS2mJOi9cIzfY0y15VKRRsbG+mguyfpvd9r8r7HtCXfF+nJeK80X3Pl/9N2\n", + "kV7wKBTy66k9AHXR+gGYeJu8o4niV98R5dvwXS+zc4waqGq1qvX19bkaD3bvcJZJtVrV/v6+Op1O\n", + "Aiu+TgHHRFLyPE/gGzmiiJgxX7lyRcPhUF/60pfmgCG8lJTOEcKWeGG7g7bo7ERn0mtOWEcAuuho\n", + "+y43lwGf/yzLks5wGSmiCwcnH8br/bALNHo9LrQ+oT5hRdcXUZHxBzV71XiRV+T38Bl98fwqffX+\n", + "RiUXoxBxbA4EihY+/TlvW5eHAKMR9H5HIOb9L5o7n59oCJy/RR4Vvy8jOIHiwuez8/rrCtXBb0yh\n", + "OT+j8kcJujx67Yo/w71Pwtm0hRG4c+dOUkhEU0gBofQIZ5dKJa2trSnLZgdDDYfD1DYeI6+Op5Cv\n", + "2Wxqd3d37oh6SekMCt5zkmVZMtal0unbjxkz/ZhOp+n9IKVSKaVviiJF0ingx/D5IYa+3Rd+Mh6P\n", + "/PB3rBPyNe6yEL1KijABZOVyOdXFeI3QRZHLFmMpchijA1PkuCxyBF0PO7D3M0gcvKG3nDzS4k6d\n", + "ryFOXyYt6O9GIm3EGEktOgDpdrtzZ5jUajX1+33t7++r1WqlNGCn09G9e/e0tbWlLMu0trY2B/4l\n", + "pTeC8xlgws8NAUhTd8U9bMOPgAfQk2VZqteaTCYpYuF89jcN+7zl+emuONfDrjd4lqegXbdEZ5k5\n", + "KJfLC51hp0tzfP33wsBEIy2dLRr16yJA4XdRX6Kxj8bBQYNXR7tn5BEXvyYqniJDVCqdHiBEWM2/\n", + "X/S3C1Y0anzuJxEWgTTaK/L0igxljI5EAx2ByiLQ6cCEvoHOPRR7Xr8/bloUOYqRr6ioHTRI86k2\n", + "vH7kIPK/KLzqgAMjGz0d/9+VjR/Pnuezw9ZQiLQ9HA7V7/dTGoU0iTQzYEdHR5Jminw8Hs+ladg2\n", + "6UWN1Wo15fAhL2hlCzOeV6lUSufBcFBUls2KLdkBBLDa29tL70/B0CMrfhgbz4L/yFUsfKWduDuK\n", + "NVpkLLx2yAsQpdOCR+aEtFOlUlG73Van01G9Xv/IMvm9IDfuyFuR/Bat7Sfpdl8bXOu1V65HPOoX\n", + "t5Tz7FjP52ke+iQpvbRRUjqXBH3o6wfwwk+n09Hu7q6Ojo706NGjJNt7e3sJxE4mE927d09XrlzR\n", + "ysqK9vf3leenKRb4SD+JtOX57K3fvV5Ph4eHCYB5lGc0Gumf/JN/os985jMJELBWkTnebwVgpzYG\n", + "XnkkyfV41E3Rlsb5cZvnTqTrY/RLPN6gCFw6Xbw2N4pCXIS0z7sv/j4v0lIUaYhebRHQiUY3evpu\n", + "IIuMlAOUGIY8bzwOap401gjSokHz36DY6OW4AvfURAQoi7wm+OS1M5GXsV0foytC/4mRFF8IlwGc\n", + "RPDqHpF70UXki93nF1lxBemK1tslUoCxo8gZ3rvH7/1AOaLAULC+RRelN52ebuekMBTDHD3Ou3fv\n", + "JtBAf/M8T9EJPNJOp5N2s3CCLCFy6kl4IRk596Ojo3QYFm1LSvIszYzOs88+qyzLEniCV74LAsXp\n", + "9QKctBvnkX77tmAP/wOq8jyfe3cL0SWAJrUp/X5fR0dHiedHR0fpjIzhcKher5f4d1HkhsrXLt/F\n", + "a6Ri3eBrHfl0EEIRqXR6CizgDrklYse8xfXFfMR0mzt3AGIOOotbzev1+txamUwmCbAfHh5qdXU1\n", + "RUNoYzqd6t69e6lwVZoVhz948EAHBwc6OTlRv9/X5uZm2rGEgUYesmwWcXz22WcTSCJFc3BwoE6n\n", + "k05lJr1TpEuJinhqBx4gqw7GpLM1Iu4cYEdcl8NLnksU1a/jXn/FCvqMeV1EF/pWYmkx4o50nkKP\n", + "vx3QuDEsui+GZYuiL0UUowLRc4+G3o2KG1JfgDHCEMfmExk9F7+Pv/1/9yai0iiKgEReLeJ/EfCI\n", + "zygCIQCcGB2J6aE4nqL5eRr5+bjIPUzp7M6LOLZYpOq8imHVmOpxkMi9fI6njcyhXOmT98HPBYke\n", + "U6VS0bVr1yTNe5ooGIwrO2kwuJz/8Nxzz6WTZAHCKODhcKjNzU2VSqW0DZOICHUuKL3BYKBut5sA\n", + "RKVSSR4m/UbxEvLmnJSjo6O5l5sRHaI4t2gNxiJJjzK5zLJrCIIv7AJizjC8Hl0imuURKQAa65Ww\n", + "/WWQb9c5UX/zO8pW0f3cxz3+Sgs8fOTdjR9RN4xp3HYNOHbdCu+Yfz6v1WrpLcPUiEiaq81gLkul\n", + "UtruTirlgw8+SLUTgM/r16/r8PAw1Zdcu3YtHW0/mUxUr9e1vr6ufr8/dzgiO8okpWfxpmLfYlyr\n", + "1bSxsSHpNGoEeYGuO3ExKoWti2Auzi19dpvG36xlj8byDJ4D6HHZcH1FuvQ8upD9aYuMb1yA0fDG\n", + "6xalH/z+okXtBiJWJBdRNCoeQZFODQDfETKL4+R7vDhfZCixaMiLnk/bHlpDKIv4WMRXAAJ9cvDi\n", + "fY33FfGzaJxQkbLyMfqiWAS0fK74zq8tuv+iKBp3yD0QDBJKx+fNlTz3uyLzKIl7J3yHwqZYD+PN\n", + "Z76LBBnAw/cIGm12u11tb2/r5OQkpUD6/f5cmofnjkYjvf/++2lNkU75g3/wD2p/f3/OwPD2bXbh\n", + "YIQBLRsbG8nT9cgMb3ClhgVetlotHR4eJi9zf39ftVpNh4eHqfDWPUw3bBgkpyIdw9p1WaN4Ns4h\n", + "7aInACruzQO82OETI4vU0fhbmi+SXK4jSHH9BQCl/66vkGu2k2dZNlfPAb94hhtBapXYAeYGlvbp\n", + "CwXWGEkcROaKLbzMzWAwSP2gTiPPZ+mSVquVonW8WfuFF17Qm2++qfX1dR0eHiYwSpqTNN7e3t5c\n", + "SqNer6fzUTxq4zxCrr32qtvtqlQq6eHDh4nHjDcWjkunwIx5ijbOdZHLrvPRwZzrHX+NhUe/IlAl\n", + "AuvyQ1v0+bxdaBe2eb7IM47fu9ItQuvS6YFW8RpHjUXPZiHBLPdwInlUxA2FKwz64OHEeI10CoZ8\n", + "uyKLxT07N+DufcOP6Mm5Eigyju6NuJeNgXSvMfY5RmnO84yehiLQKmrHPVT66HxljNHYXjS5B+9j\n", + "9PmM3mD0KF0GIyCMBtJBjD9rOp2mN6CywyXLsrl3vyB7pVIphYclpZ0Gw+FQb731VjrnhFoTFC9p\n", + "FvrIAX7PPfecbty4oYcPH+q73/2uvvGNb+iFF15Iio0UEUdxYxjYNVGr1dTr9RLA4pnc67spqF3h\n", + "SG/kmJ0VhNg93eK89uPUnefS6XkTTu5VuqKNkUnalWay6UYL75/5Y3uzyzP1BYPBYO61EhdNLqsx\n", + "FUy6RTqVraiTJKVI2erq6lxaQZrXbfDVgTRRil6vlw4g8+gAOp2oR7/fTwDHU4PT6VQHBwfpfBHA\n", + "IYcOEokYj8d69OiR+v1+SuXs7++rXC7r5ZdfVrVa1c7Ojvb29tI7dNABFDNzjgkRkclkkl7dcHR0\n", + "lNJ9nETrB6iNx2Otr69rNBqldtyZZA34sf5Eo1yvu+53W+k2gLVEhDOmZwDTfk8En6wJd3QoYve0\n", + "nUdgF9GFp3UWkRtl/ywqZj73ayA3EB4Oh9kIMALPAiCkG9Mwblhi7p8xxdSJF855uCvLsrSjgDyz\n", + "g4w4hggOPGRZlBbx+1iwRX8jSB7OPs/QL4qCFM3tIkBzXnSrKELk98fP/EVul+EsCF/I/O/E+NwT\n", + "iTzykCgy6n8zh4R28UJGo1GqV2BHAsaP9rmPMPF0Ok1pD+YCw7KysqLNzU2trq4mxUXhINcAGlut\n", + "lmq1mj73uc/pzp07ajQaun//froXWWs0GnO7glBSKHUMFtuE9/f3kzLloDTGgVIHxHBOCYdmoeyb\n", + "zWby9FZXV+dkiJRWkW5xAwtoIAXB5zzT15MbS/hD2og30cbIDb9rtZra7bakWb3Myy+/rI2NjXTw\n", + "3UVRlNEIqF238L0Db9cvEWi5gwVI5TN457qY9CGAD6BLtAO96G+hRk9Vq9W5N14jy76uPBp25coV\n", + "7ezs6BOf+IR6vZ4+9alP6Rvf+IbK5bLW1tb06NGj5AgAbjgYDd1KnwAApFw9YkEfkG+Koj0dBZh/\n", + "//339dJLL6larardbieeSfORPPhCNJ+2PZLC/+604Fy5HAOK3BnBVtE2KV23y8g2c0f92t7eXgKB\n", + "i+hCwEmR4StS0i700QieB1SikfY2PVLgxsB/IkCJz/britIWHup0bwEEXyrNdh/s7OzMHbftk180\n", + "Fv9uOBymfCmvn48RlsijojMuvEgsArHz5s/nJF4bn+s/MaLDuJ1XPm/xejcEjCeebnqRxCmoHs2L\n", + "88l4ve7AIyA+fjd20nxBG4rB594L96ir8LeB4rW7lxu3MuLhoHT5XzpNgfC8RqOhW7duaTAYpBTS\n", + "1eWWozkAACAASURBVKtX9Zu/+Zvqdrv62Z/9Wb300ktzR33neZ68SJQ4qYuvf/3runPnTjpR8733\n", + "3tPDhw81Ho9THt69MdYBRbHOt263q2eeeSalTkhJURMC7+gDPCiKpLrhdZ3gesRPVfb14S91Y9cR\n", + "xZy+tvkfoEbhY6PR0Orq6vdIQj8a4fG6M+E61XWke/VcBy8dpAIipeID2CSllFej0Zh7942ne4g0\n", + "+Bt8MepZlqV0DGeZlEqlBFDoL/2iAFtSSufcvXtX/X5fu7u7euedd/TZz35Wt27d0pe//GVtbW2p\n", + "Uqmo1+uluhWijr5u7969m87pqVar6na76VBBZJNzd+hLlmUpagJYLpfLevDggZ555hkdHBzMOTl+\n", + "ngm8jRFo191FTiQ6hO9ZHz43RP5xOtx2YM9wcAFBDv6IYh0eHs6lnSNdCDiho0UEo2LBpBtXX9Qx\n", + "QhCNZszZAk58u5g0D1CKDHUEQtHg0PYiTzmO2Y1OPHHSjb0/n/v6/f6Zo+Y5TTIaOG/LxwDqBdg4\n", + "aCkCX9E7iv3yZ3h0Jj7XFVpM08WIUXxOnN8I/CjqvEgql8spZOvbvaXT00UdjBbx3fmEsXOD554l\n", + "baPA2FYLCBkMBnOyg4fjBaHsfHAlBnDJ8zwpUn+Tb7PZTICQN6s+88wzOj4+1tramq5evapKpaI/\n", + "8Sf+hO7evZuOtncAhVfHmiRK8oUvfEH7+/va2dnR5z//eVUqlXRGCooTuUWWnQe1Wk0HBwf64IMP\n", + "5p7JmFHk8JmxU0+wsbGR7uF737YO3x2Elkqzw+oATfSVehj6j+GUZjtCeHa5XE4Rrkpl9qZb6hWe\n", + "pMQ/DiqXyyklEQE36xT947sQ4RFGyg02c+Db0Nm2iwzD24ODg2TAJaVIGH3w57tBBbR4Kh1wQ92f\n", + "R7/pO8/Z29vT0dGRDg4OEgjKskw/+qM/qvfff183btxIYJ/TY0nBoOPff/99lUolbW1taW9vT51O\n", + "R3fv3lWz2UyHuBH9oOAW/cFYJpOJ2u22vvOd7+jWrVspWgg/vS4E3npND/0CQLPuPFKOrongm7Xg\n", + "soDt8KiuR75cLkgTMT8UEhMhXEQXAk4IycYiNGle2KHzAEI0kE/y2iH3knwhFYGEJ4ET/03bEaQw\n", + "8Xip9Xo9CSDG4LxnQyhl0LkrvachN/Iu2M5zT034b36IVng43EFdEahhHh10+vxyfYygFCnCaLzp\n", + "cwRKF0Eo71arNZdvl+ZPW4zRIOYQUMA9Mc2H8uBZbiT5vbKykiI4XBcVNsDItxP6czwiQ4rIdxmg\n", + "zIiYbG9vq9FoaHd3VxsbG7p586Y+9alP6Sd/8ifTibDuIcInjHie59rd3dWP/MiP6Bd+4Re0tram\n", + "a9eu6Xd+53e0ubmZ+pRlWdoZ5Ip7OBym39PpVGtra3rmmWcknb4tGDDgRM0BkSQKcldXV5PhKJdn\n", + "u5+Itvi8MSfw1aOu/q6ca9euJWBC6J25xnnylEi9Xk/bq10uLooA1aQMIQC3e+YYxaLUDrKPbHn0\n", + "z42c1+T5EfJ8X6vV0n3+GgCvUUHOmTeOcPc0CQabSICkVHi7v7+vq1ev6uWXX9YnPvGJFBlYW1vT\n", + "r/3ar+nVV1/V3t5ekhGijAAnANeDBw/02c9+Vmtra6rVatrZ2dHLL7+st99+O609BxJem+G6dTAY\n", + "6NGjR0nHsq05rmXpFGQRpcLeElFFPt258dQ4fISXHs3zdDIv9kTuvQaFfnhJA5FcrjvPobwQcOIo\n", + "KxqU6B1LZw20G8sisFAEKiCPlETA4u0vut/BkxtgJiRGBNxAsKjJ2+N9TqfTM9Xn3g/+RvlKpyAF\n", + "9Oy5VhS+K083lBEYOKjwsXsEJQKMeEZEETDxZ/vc+vkQcQG68Szqh6faIsi6DOQL0M8BkDRn2N3A\n", + "8517FxhMN3Iuq26s/H0ylcrsxXwU4BF6paYEGXRvKqYiMESsQQAwnwOMiT5m2exgtK9+9av63Oc+\n", + "p+PjY929e1df/vKXNZlM9MUvfnEOVBNRINxeLpeTR/no0SP96T/9p9XtdnXz5k3duHEjhYoxJuPx\n", + "OIElFDMeLcrw4OBAWZalaxzExh1S8JC/8zxPdThEi1DqRFuZL0+ZwTvfygyf+/1+2kkkzYNqDLSf\n", + "tYGecYV/0cRYom6J6535jbIMePA1TjvutXOd83YwGKjT6cztsPG0EO0iC64TAEHU1rEeAJPIFsaS\n", + "qCPv2PnMZz6j3/qt39KVK1fUarW0u7urvb09vfDCC3rrrbfmrqUAHb22vb2dzjr56le/qkqlop/5\n", + "mZ/R0dGR1tbW9OKLL6b0vOvP6NgAxpvNZqpbgvy0VeQG+eRz5o417rwAPCDXRDWZM2p84CvtSzNA\n", + "SHppUaTbeY+M0J9LV3PiCtoNHxQBhhNGmO+iAV3049e7IS66zhXBouhJBEVF0RLvc8zTNhoNtVot\n", + "tVotdbvduaLB6Cnz2z1ljB6nCMJX0DPXR4ASxwQfPB8Z+VQEFiOoWZQGi6AoAotFcxR5Ge+Jvy9D\n", + "1EQ6relAMXi6iTnxhepzIJ3m2B1g+ntouA5gPx7PTl/Nsiy9XXc4HKZ1Eg1CBK/wlIgeJ1jyLC/i\n", + "4zpOaC2VSmq1WukkyldeeUW3b9/WBx98oJWVFX3iE59Qv9/XG2+8kUC17yqg/5x+ef36dVUqs1NR\n", + "S6WSfvVXfzWNtdPpqFwu6+rVq+kcFC/0ZXcOfKUNxoScEPGjfsGP//bCVebJj5B3J4C6EbxtT7Oy\n", + "y6Zarerw8DDN6XQ6VafTmZs7wJ0bcgdx7oFfJLnuQH6YS4pRMXTwOkbjvBAUEOnvbIoRKOk05b2+\n", + "vp54yxxxj58RQl9dL0SnCXANf7nHU6ij0UiDwUBra2va29vTzZs3UwSGqMIHH3yQdtAwlna7nVJF\n", + "yMB4PNbW1pYODw/VaDT0G7/xG2l3jgMwaVaTxPuopNPzdlg/8HB/f1+lUiltmXYg69FInAoveGW8\n", + "RYdvOliWlNaVz/1wOFS3203rAWDNsxx8+NjclhGpOk+2L3y3ThGwgKKH7/fG6ARGgLbckHG/X7co\n", + "2uIKoogWgZUiY4txhmJOD6+YsXnY08eIssqy03QB+X5vw0ODvhDjGBkn18Y3c7o34REmH4vzMwLM\n", + "RQAu8nERuHAwtAgUxrm4TGkdV6DwzV8CB4+lU3lDyfMOGa9NGI/H6Z0apNR8Kx4RGVITyBkKwz0x\n", + "FJbXXOX56fHXblgIiXe7XW1sbKQtuVyLES6VZrUupH3YuXP//n0dHBzo4OBA6+vraRzULjhwqFQq\n", + "euWVV5Ky/vSnP62f+7mfU6vV0sbGhvI8V7/fT4daAeAwGC4X8IVDqwAxLtP+t9cjsEuIufGws+fd\n", + "Jc0ZNue3R2HW1tYkKdU9jMenL3gD7MV172tWUoqAXSRh8OKpuA4IkQkIAAKA8HXLbhTakE6PfyCF\n", + "AH/ZPs7ntOeyGx0cwAuf+9t6qe1gXBBRkzzPU1qUF0hmWZZASLPZ1P7+vo6Pj3X16lXdu3dP7XY7\n", + "pQi5ZjAY6ObNm2lXCjuujo+Ptbe3p+eeey69t4o1h/H3LcPIICkl5JJ0lNsfSXO7kTyq59GWmA7H\n", + "vnikgwgLgN7TRx6RxDlhTXqBPVE/LyFgbTxpt86FbG9wYXZwIRWnUvzaaIRcoRaFw3ieRwYcYXM/\n", + "//tvfy59g6JhdIpgxz8n1Otj9+vcmDivWGws6hhOxpsFyLinHBdq5J3zyHlJn/2ApNivyBvnl8+H\n", + "3+/9iLyP/HV+xnqUIn5fNLHoUSrwEgXjvJROFbLz0UPinF7JwWe+u4t7UAK+o4a8MvxFMaNg3Et0\n", + "kIhXiMFgyx+RChQfHv/Kyor29vbSoWoUndJfFBDvFsnzPBXt+vba8Xisr3/967p165aeffZZvfHG\n", + "G8qyTDdv3lSWzcLj/X4/RW6QdwoVY3gfJQ94gue9Xi+dGkuhKnPjRjKerYKihgA4eZ4nrxbD5DUX\n", + "w+Fwbr3DDzcCzE+RAr8sKcto1D0lEl8LIJ3qAebD66QAWhg9drBISsXZpBYoBKUWSNLc26aJaHGQ\n", + "mhcYs67QlR71idFExuf9Hw6HqV+sPa5fXV3VaDTS/fv3dePGjQRue71ekmfk5vOf/7x+53d+J9Vd\n", + "7e3tpcje7du35wrDXRfQDv2GH51OJ70UE74y3nq9rv39fTUajZQ29XXucsZ8+P2ARUC02848nx0M\n", + "B588Pcuac2AjaU7efX55zqUDJ1Jx9CMCk0UARTobSXGv2g1nBAfx+ecZRf8+euuxX0zsovbdCHmF\n", + "OH30RbIIWPE94TtHu5LmlKf3tQhgRT575Xusy0Gp+pgiqOK6+H302ov6tyiysug5Rfy/LOAEQxSV\n", + "AEbSgQFGKPadOcXb46Am0gl4kM5jP6eEfhBiBZAAPh3wkqN3BUnaiXQK52+gcDFGKJe1tbUEiCiQ\n", + "Iy+ObJ6cnKQCT/rhnrg0MwD3799PRmZzc1N3797Vzs6OxuOxut2uqtWqDg4OtLq6qnK5nA4rc8Pu\n", + "awaPF7DHCZ0ArY2NjdR3UqQu/36qLqeKOo8ARn7GA1ECgIqnIfzcCfhC5MYLS+kD25AvWr4BWZLm\n", + "TkL1vro8QQ5+Me7oE04lpn2ihsg9ckk7yBtpjlqtluQt1re4MfY5ybIsgWYKszHyDk7L5XIC21k2\n", + "ezdUo9FQu93Wo0ePEnBoNBpzu3OyLEt9Aij1ej09++yzc0C41+vpwYMHiTfoBUk6Ojqa2x02GAwk\n", + "aW69Az4AJA8fPtTW1lYC3f1+P8klER3uRW6RV0Anc0f0TzotjKUvjJE17E6yrz1kwKOTkfe+1oro\n", + "Qs9EdjAS0yKLrpfmd3cUGT43aNFTj8/2vxelIGK73nb0PB1sgOr9b1CpA5GYgor9W8QD90YweB4i\n", + "9nsieIpteqjWx8BzvLgzth+f5UayaK7iffH+2M84x0VANgKfiyIMkEcq3Fh5TQOeH+SREOl094F0\n", + "asTY/st2YPiLt040Y21tLSncKLcobZQnoXSPnHnf8/z0BE1PWUizmifSLSidWq2W8snT6TQpsPfe\n", + "e087OztzhhsvejKZHURYKpV0//59jcdj3blzR6PRSFtbW3OGnXfssDuC8UenBD5xjDnPrFar6vV6\n", + "Go1GOjw8TMWIDqaQdULn/M0c+xrx4kCiAQBGalGYQ+acwkP3XH2N8DlA4KJ360jzp0zHrefwnnlw\n", + "HnGvpCRrfuYIJxLHHYsQOg2Qxv1cB8h3HnkE2OucMLYAE4iCbdp0PU0dyLVr17Szs6Nut5te5Ac/\n", + "OOPEoy/0o9VqqVKpJDDFYYmeKgEcIKPwlIMHIecncwCYYf3BJwChn3nCGof38MKjX0QlkU/nr9eV\n", + "QMyfrweXDcCNg9jj4+O5iGehvD1BHn9PKIKBaJSlxSdr+j1+LwrfDRn/S2fPzeAzD+35c4oiDG4g\n", + "+RvwEfvroCgaHdC/gwIWNcLECYg+0TH1BYp1JRB544s0GqnIV69hoX0vmoogg7E7+CoCCQ58Yj+K\n", + "8u3R83LlF2VkEUi6KPK59ggBxh1eOpjwNKc0v0WY00TdCMRthxHEcr4JCoXIgAMTftNnvHdfMw5O\n", + "fYfZ6uqqarVa+syff+XKleTJ5Xmua9euqdvtqtvtpvfroGwPDg5S+ocQ+GQy0fr6evIYV1dX07t4\n", + "UNzscsPDKzr3xQFiuVyeAyikhg4ODtI5Fr1eb24tuC4BaHndBHNBBAFQ5uvK61WIlrILyIGOA/9o\n", + "EKTT9MdFEoALWfXjzeOaRVb523WXdFoQ6cXARKiQ66J6IIwi/PHICjKFfOX56TkckK/JPM/TTjHa\n", + "xKhHp7LZbKrVaqX05cnJiTY2NlSv1/XOO+/o4OAgGVvmql6vq1arpTOp/KwS1hkAGwBLZJLoKGDG\n", + "gbdH3ugv0bnt7e0E8IlMUFDtUSFPFSF/yLM7h0ShmG90lad8yuVy2okGj7PsNPrFmnSHgbXpEc8i\n", + "ulBwEv/2/xdFDRaBGSh62UUGyw2iT0Q02N5+UVTC23bDzGLkB6PvR1cz0b5rAgXNhDko8LSL99FB\n", + "wXnRhUXA5LxrvY9utCIoWwQknzR3RXNWNI5F1/P3eW1/3OSgkb4x33gpKOqihelz77wgCoK8EnGI\n", + "xpkdJsfHxyqXyyml4Uo78s5BET/SqTePEWZXzdramtrttgaDQTr1stlsajgcpkLB1dXV9C6Td955\n", + "R/V6Xa+99po2NjZ0fHysl19+WS+88IJu3ryZABTKinqZtbU1bW9va3t7O0Vt9vf39eDBA/V6PR0c\n", + "HCTDRpQGoOCHTVG854dw1ev19PqIRQ4RXiKesSt2+MghiPCN9eLgUTo9CI4CXgwZax4gidKPBdWx\n", + "GPcyECDBAbbXc3i0wmVKmt8KD5BzB9OBN/z0KAPy7R46upPdI/THHTRpPmKLbuVlf/TF3yjtu7B4\n", + "jw7plFarpXv37iUZYS2QbmQsgCtOSiZKd3x8nI679xNi4ZHLlO+KcvvlBh9ZdBnzKK2DRa4nzeOR\n", + "DYrvoxPqgJR1QDveLvPt10P020FsEV2aF//x2XlGtIhcwbqHXWQ0i+5zI78I+LAwPFIRDXtM6/Dj\n", + "nqJ7Q9wbIzlsDUNgYsTEyQGC9yn2M0Y9nD+umP160HgRD4uiFbFvMSJ13j1P+r9IJrzP8fOLpEWg\n", + "2MPYfO+7qvgM7wKljpLw8zWk+ZQPyh+P09MKcdcVis5DrgAn5ozryuVy2iq8s7Oj/f19SUpbeYkA\n", + "rK6u6uWXX9aDBw+U57m+/e1vp+3Mk8lEzz33nL71rW/p5ZdfTuHsb33rW1pbW9Pdu3fTZ+12O8nM\n", + "ycnJXFSFAkmeT7/39/fT+3IIbVPfE8PPFG8CArxQrwhoO7/9HkAfR537gWFRDkg9SUovaEPXRD2B\n", + "IWRsGIfLkNJxsI3xOj4+TsXNDtx8Z1qRc+fn5Xh9CfqRa2kHOSMFRH3QxsbGnE6lD/F5UX+4LiyV\n", + "Skn+RqOR1tfX1e/31ev1tLGxIUkJLB8cHGhra0uj0SgVnlJHxcF9zzzzjCaTiXZ3d1PfSKtwsNut\n", + "W7dS3+JWYKLngGG3BfDAZYe1y/hpy9Ml7oSjJwDLtVpt7kRXaRbZjzVyABN3ZCLYi5Et6dQWwV/X\n", + "MzGKHulCwEmRQfTw9CKDyWf+A4OYsCiQRdEE/o/P9O9if4uAUxH684XihY9uqPH2JM15Bb5gYjuQ\n", + "g5W4ldH/9ol/GtBXFEWJ+eQoSEVeuIM0R/j+3NjHJ4GQ2OcIxi4LMJGU5ts9NmkeMHq0y5WyKx3p\n", + "bK1Qls3v9qJd2nDgQl4ejw4P39v1Cn28H9rZ3NzU/v6+7ty5o2vXriVFCgC4c+eOXnvtNb3xxhv6\n", + "+te/rldffVVvvfWWhsOhXnvttXTcerVa1b1795Rlmd566y11Oh2trKzo4cOHqe+3bt2aiwAR/uYs\n", + "BWTp0aNHSZFSdHjt2rW0gwhjh1cbPTzAP8bCdzehsPFeAQWsvTzP0xZPzrHx+gqAJP1gHh1oYBhI\n", + "72AQfAt/rNnwGoSLJE9Jx7SXgwIP5QPo/PA66dQpg//u+aMPPUIlnUZpANfw0wG1A37klD4Actrt\n", + "dkqbS0rR7Dyfpe92d3e1tramlZUV3b9/X594fDLs7u6ubt26pXv37qX+MJ5Op6N3331X165dS7uK\n", + "SIOgo0kbAX7oE7JCGoa/PfqDrJHmQV49mg1fWfukGeEV7yfyKCrPJ2pCX4hKYadcN7FT1O0TfOC5\n", + "DjK53+uE4AfzvIgu9E1pRcAgGqhoEBd5/xFYnBchiIwtMqTenwhuojcQEaR7pY463bMo8tIgFh1K\n", + "kv45avYIhxs7FxYMkIeuiwxgHKPzOqJ0+kL78KDICHt7Hkk5b079Pgd0RQBx0TxdJPli8/mm6DJG\n", + "k1CazK90GhXxPLqf2OgF1Q54pfmXruGBsQXTyb105Mp3CLz33nvqdrtaW1tLioXajWvXrunrX/+6\n", + "7t+/r+eff17ValXf/va30yFqHgafTqfpUKkHDx6kMDYnG2dZpnfffVfT6TS93A3ZR8FLSt83Go20\n", + "qybLsuTV0kciLByyhUJtNptzfKNGgAgPfPSdUF7ULJ2+9dm3ZxKZAgj6mqTfkubOy3Dj6anbmH7L\n", + "sizVtJznYX4chOfrY4R30UsHYAFIWMsAOOkUxGC0OU9DOjVcRAzdiaHoU1KKRhAlc6NLv3zbcaVS\n", + "SeuQ97v4561WS71eT71eT61WK23ZBQwTMcGQE+kj8kI9EXUy1E71ej3V6/W5HU9e8Mzc03fO5aHe\n", + "BLlG1hyYOUCD74ABwEi9Xp97NxWggahJ3NLtYA9g5CDddY/rNPjEGqZ/bjOYF+532Yl0ITUnUTlL\n", + "OmPwIrhwigDGFT5tFRkyro0/tFlkjKMhh+neTwcWcYyek/VQM4uVPngVP9cXhZr5P47XozhusF0o\n", + "fPyxTedV5J/fuwhcxL45f523DnCKIh8YBTfWkeL8F8nIRZEfxOVy4SctSqdnYpASQB7gLwvcZYT2\n", + "uV86lVsvAIV31F5IszmlvgH+OQji2RTOkjNniyx9H41G2t3d1Y0bNxKwWFtbSwCFKAsRm1KppO3t\n", + "bZVKJV2/fl2f/OQn1e12tbOzk57Xbrd15cqVOcDCy+6Ojo4S4Njd3dX29nZS0rw4DIPjWzU50K7Z\n", + "bKZcvUc5ABrk5sfj2VuP3QtEscLnlZUVdbvdM/LN2sV4u3PghpJIAd/7WiUS5A6GR2MumhiLH2YG\n", + "QKGmjrEjL4BpN26+K8yjwPz2KLHrEk8JwBdkkigIsu3nbLhOxMAD8PkNCD46OlK73dbKyooePXqU\n", + "1uCdO3f0uc99LoEGTitmnLVaTc8//7wODg4SeNnY2NBkMntpo+tnJ4C8p6IAXgA/PwfH02XOH0+/\n", + "kM5FJr1wtshuoosB+YA/TwOTYiNqCT/9O58PACVRGfrru6YASF4oHenCwEn0umP0IhrEaIDc8Ppn\n", + "izzo+Bn/u1HwNrxNro+G3z93kBO/p6+gzAhsYuErCzrLTo+ALgIqtB9DrFLx7qTz+BB56IspRoqK\n", + "gF0R7+IcxmfEn8hnb8v5ViQTlwWgsBg9PE9/PUTqcy2djVJxvXvNXgNUJH8AEPeuJpNJUt4oC+4n\n", + "VEze/ejoKMmTK/XpdFYQ2+v10q6b0Wikg4ODVOD67rvv6sd+7Mf04MGDlP44OTlRq9XSzZs3kxJD\n", + "WX7605/WeDxO2yzpKx46L74bDodaWVnRO++8o2q1quvXr6ter8/VA0hKQKrVas05AM5vQs6dTkfN\n", + "ZlOdTidt4fQXo8EHxs468nSMFyCyG8o9YCcv3GQLqr8XBqPZ6/Xm0m+SUvsXXXdCesBTZkQ8Iuh2\n", + "z9r1CH+ztRxjS7QKcr0ToyHSKbhjcwHANBpUogkeZUCWHcADxh2McvDhgwcP9PnPf17vv/++Dg4O\n", + "1G63dXh4mPrCSbCs452dHbXb7QR0m81memkhMsbhboPBIB13j8zDH+ehR5yQazfqHu3AnkinQJDo\n", + "G/qDrcIANGpPkNF4pL5H4P3ZtOF1UpKSY4b9Qpd4DZFft4guNK0jnU2FFIGLaASh6HkX3Uu78Xlu\n", + "UBGAWLlf9LzIzCJjEfviUaHYTjTCDiaYXD6PQGPRGN17jtd7CqYIREWQFnOb7g1G3kSe+P9F4LKI\n", + "HLBG4AHfiiJiRc+9CPKwLZ4Zn7HwUai+w0M6BQyM3UFYBL1ed5Rl2ZynBSAiWkPBnhdnAmbyfBby\n", + "brfbSd4wCP4ulN3d3RRNaTQaWltbS4a8Uqnok5/8pN566y21Wi1JSodWYcw5sGpvby+FzzmYyj0t\n", + "DufK81mNx82bN5XnuW7dupVy6BToMt+8MdhfUIjMwg838AAePoOXeZ6nz1HWzIvXj8E/Qu7OS//e\n", + "gSNeMsWGjUZjzsCR3nD9wmfu/FwUMT4MbbPZ1O7uriaTSTK2AAB3Lly/OQhlfTA/1NV4vYIXyyIf\n", + "pCIAu34oIPd7xJaoG9GReGR6r9fT6upqAg8uO91uV9evX9frr7+uzc3NZCdqtVrauTYajdTpdNJn\n", + "vJm72+2m55DWAbCsrq6m+gwHah51lU51MM4qtSDOt2gjkElpJoOkdpFBP5rC01r+Ek2iL/5s/o58\n", + "BXSwpgAqpIt4jgceOFeFsSyiCwEnLrzRYC36P6YHitpzA+jILxpd/9tzZjCRRebXu6JyilEfnr3o\n", + "efS3yLh7H5g0XuoWx+5GKoaJ4zVuvIvGswgocE9MuUVFWRQtiW27kfW+0G78PLbp/Y5g9TKAEgjv\n", + "xFNjeBvR2OCFFoX7fSeOG74YLVpUf4JMssMExUfkhGvK5dk5BZwbwlwTfalUKnr48KFarVbanTEe\n", + "z47glmZzsL+/n5Q7yp/zINjNUiqVUuHq3t5eWmMocA8Ru2L0k1f5nDNcMGhZlun9999Xq9VKBZjO\n", + "D5S5F3PSFp4vY+33+3NKnDHCMzxT+MBz3HMtcq6YY+aD+XMPlvs468T10Hm5+Y+LSqVSihKQ2pBO\n", + "gbinsL1wm7nkb9IhXn+CjDPPyCkRphj1y/M8ySM7XphjjONoNErvInPZZn739vbSCwXRo6TmpFkU\n", + "5OHDhymK0mq1EmDHIGMvABt+/o6nVvwsF9fx6ADWsUeeiAQSyfNiY+e9R2C95kOayR4OhKSUNoLX\n", + "rmtcB/CZp+Qc0DBn8MzBpV+P49Hv97W+vq7hcJjkgfsXytvvQlY/MhUZzUUGx41ykQfu3skibz5G\n", + "QaIxxpC4AfVajUUGPeZNFxn6ImO96O84rvOASex/jLoUUeRFUUSDtoqKaV3oY3olzkWRko7GtQhY\n", + "LAJuPp+Lnn/RRLgfZeMH6rlXh7LNstnx6ngZzmPpFHy6N+TFlkQe/FwMvJ2joyNJp2emoCxJY0gz\n", + "Q7i6ulrYxng8Tgeh8fbswWCQ+thqtVQqlbSxsZE8RT/Hh5B5tVpNxtzXOZEXjLenMzD2nNyJwe73\n", + "+wl84IH3+31dv349bWv1gjyIiIgrc4CTg5XV1dW5VC/f4Z1Sy+Lbhz1a5lG/LMsSUIu7QtwbAAYo\n", + "7AAAIABJREFU9TVDv2q12tycX3RaR1J6VwtGJctmLyItSvGSAgKUObBmXaBjIt8isPHdOdPpNAFl\n", + "gAzRAuaQPhDF43/qjySlU5Rpv9frJf6vra2p2Wzq6tWreumll9KBa0RepNOXMZIW5D1NpJccgLis\n", + "ui3waI5Hnfg7y7IEgHxt+DX+tvIsy9K5Jg6GJaWieNqFJ8gx/eB+L4D2aIp0GjX09CU6wUEgn7Oe\n", + "ACrww0FWEV0IOIkph1j0xzXS2foEpyIjFkHGk6ICRQaU5/v9RZ5LBCb+u+hZ/rtoTP4MB0VFbSwC\n", + "You+d+8uRje87diWgzS+cwR/HiApAg1F9SI+bzyzaN6LAGgc40VTlmUp3OzFjMhVuTw7O8TD/75Q\n", + "4a0reRSqe0gocLb3ugI4OTlJkQ08FVIGeHL0BSPgZ09Mp6dvhh0Oh+r1ejo8PEwnq0pKCh3jDYjw\n", + "uhiveSqVZmdU+Iv7JKXj5ZEHV+IoP89Rk/LxWpBms6kHDx4k4w94ATSQHqDmhBx/v9/X3t5eeg7p\n", + "L3jqc0rI3Ne8A3XqCeCfRxFQ8hiTuEUZoObgCR3JQVoX/VZir3/gRFN4gU5gfbpxdeAhnaYekHe8\n", + "a9aHnx7Kc5EhUooeGaMfGGn6R7qNPjvIHwwG6dC+0WiktbW1BLqGw6Fu376d0ofb29va29ubS82S\n", + "LpGU2jk8PExABdDmYIQUiMsVET36jPz6+if1g0FHFj2tgxwS0YB/jBee7+/vp3uQPyKktEekEp3A\n", + "+Ogvcx3nm4JYIj6eegKQF4GR80D3pTi+XjoNh3tEYhEokeYjAEWGrCgKUtRGvM4X0aJoS4w+xHHF\n", + "Z/j9iwBVfG6MEjgIgBZFLuL951FRVKfoe55X1GYR8Ip9j58XtXFeXwAvtOd8izy7SMLwSUrhfwAL\n", + "yoI6DK+LQP75mwWPMpA0p2ylU6+Hdvmp1+vprAaPfG1sbMzVEPlbVv14aun0QCe2HKLUPRwb+e+h\n", + "atr0KA/RkcFgoP+fuTf5cezKrr0XyWB07IOMNlNKlUqlaqBCGTDgkQHP/Wd74omBMuxB+ZWsLlUZ\n", + "TbJvoyX5BoHf5uLJy5D8fX5iHiCRDDb3nnuavddeuzmj0ShiCGhYmzQPNuU6k8lkLVgcC+/4+Fi9\n", + "Xi/AHOsJhfHw8BCsD5/n83m1Wi1Jq+A8gMTh4WFcy8fRgwJhcxgzZ46k1fpnTSC4vaGwuAdji0JF\n", + "8bpS20bDWkZRUumUZ3Z2A4XEbzzmQFqPDWGePBbLlSX3llYuRMAbSg9Xxv7+viaTSawr7geQZ8+5\n", + "+yKXy2k0GgWo5ViGx8dH9Xq9iK9xcIjidlkM40OfYTyYe/rq9WBYX8TNYEjQl0qlEicMO5ijOdPE\n", + "enZw7q5JScGKsBYdLACaiQ1z4AngdtcboMVBu7tz0iMfGD93r/6UbtoKOEmVHILNFVT6vzf/zEHE\n", + "S1a7C9KUufHPGDjeS5VrFhuQ1c8s0OCbzNkC71f6e4/z8Pc2ARPGNwUE0odsVFZ/NzFVLmhdgW0C\n", + "kll9TYGEf+6BdOn4+fyk453O6bYbyg0hvlyujlfH/wvA4NmJd/DxcBfL4+PqoD8EI58DEvL5VaZO\n", + "ur4J8ET4Iyyl1YnGgBHmAtqcPZDLrU6mdsDkz+JWFPPrbgsEHsoYgMF16BtWIn0mkyIriJW6I5PJ\n", + "JFgVaT3Wi+d2qhoLnZRR3GCwF54i6+sL4Y4y9rWZpnpS2TRVxsRHOE3O3KEQuBfg7CXf/C/RGEP6\n", + "xenOxFGkDCeK2fc8gMtZPMBZypZIq/N8pBVjwTUA4tLq0EjWGSn0WP6S1jJg/CA87uuyB8DFeUvE\n", + "Tjkr4bEwLuNYn647iPl4enoKJZ3P54PBGY1Gajaba8xJsVjUeDyO1HWPXUFm8F1nVFOXzGg0CuAL\n", + "S+L9dgDHXJFiz5r273h8FK5ongXWE3DHMyM/YBg9g+ejc+uk9HyqeFzo+nd+juWdotms+6TC25Wg\n", + "o9OfUrbuisoCO+lr74d/tokleokNyAIP6TNvep32IwsAZvWH72aBrJeYlyyAuIld8fd8nPn9x8SS\n", + "bGoACJQ9EfNOiUsrIcx6g6VAWaYK390+KDvuh8UE2wCgwcqfTqcaj8eSVtYLlWNx43At7uunrqKo\n", + "AQkIO6wlL6DlwbfME8Cf/gBQDg8P43mxWnHV8Ky4XnZ2dkKJu3uK2BqEPS4S3DRQ8KwbwNTBwYHO\n", + "zs6iT41GI1KRPXiRceZvdzXQRwCdAzKeEQsZRQf4pM8IdxSBU91eQ2WbDSCWz+ejgFmlUolzZgAc\n", + "AGeAKM9DUTAHGYAamlvorG/XDcw54MAzZSaTSSh3H0t+h8xHqTp75syctIqTYL0UCs8p5Nzz4uJi\n", + "rd+AI1jAQqEQrkpnlqgVwrosFouq1Wo6PDzUzc1NxMiQir+3txdrm/GRVnVEvM/S+qnR9I/ibzA0\n", + "qcx3A9kZGElrzC1j6IfRMlfMJ0CJMeYaboAwD27kblxzP7Em/580t6T4m0WYBVyyXmf97da2X9ut\n", + "RGc/+JxreZ98caZKwH/n101bVt+z/mfTOKOQXncTm5EFsHzBpfdPQUDWOPr1oORcaTl4S3/j/c+6\n", + "V/rsWe87K/QSSEr7+jE0D34jvZU5JqVPWs9QQng4IHFr210HLvA44E9a1VdxYeDWFNk0KGqsI3eB\n", + "ACCcDuZ5SB10Xz5pv+wbshrI2pHW9xUgi+dgHOinsya4mebzuer1umazma6urqKuCoqIANbhcKhG\n", + "oxGZN57x4YwHio+YGRRrsViMs3xQgF5BF3CUji3P4LUhHLxx/g4AhDGWVhY62VKz2SysUUAM13zJ\n", + "wvwlGqnoxeLz4XWVSiVYN8AHqeq+flm7gBtpvQK2xwYxb6wJ1jzzARCEgcDlxfWp+gsL6LLQgZID\n", + "F4AA/fJ96fE+xCJRGBDwSlYagePISWqdpHFPMBeSwlio1+uxhufzeZTYf3h4UKvV0ng8XmMq0Rce\n", + "lMp93XXDXidwHVDsYM/dvO5q4TNpxZB7are0iqNZLBaxXx2YkFoMKHMXrj/PprY1HtyVT2o9Zylh\n", + "/74DD77vf6ef+e9fUmRusUOp+mLdxHRsUtIvsSe0NGjQX/8UqyJ9ePgfLXX90K8sl1ZW2/ScPgbp\n", + "PPjrLPCQ9uelMdoEUP3vrHWz7caGhgJFGd/e3oYVtFyuAj9Rlu4q8FN1CeREqSFkvWiTAxLKtkvr\n", + "gZy1Wk3SiuEYj8drNSZgbRB60opKRymQXSOtZyW5MkAhE/CKNQ2ocVcG/XFB+vS0OjYeS24wGGh3\n", + "d1etViviVvDR397eajweh5VJ312RueXo7M3BwYGq1apms1kcWsjY7e/v6+TkJCzCNEWZeBPWs48Z\n", + "jBWAhf6yPrwyJooO5Z5awwCUbYNvntULiaEMPZ7DlZuPcy6XC9cLay0N9JRWAaCMG4yMMykOaN+/\n", + "fx8W/t3dXTApLldh/dIUWGkVh+EuPNYpAJF/0+lUlUol+spawvVIv7yysq83gsu5N4cEEtcC4HPg\n", + "TnVlaRXcTuN77gp0Q8PZIq6Xy+XCJUW2mjN9ktYMEH7DNbPACf1iLJwB4/eMP3sDY+yjc+tIHyqW\n", + "1DJnUJ3BiE7nV/UbpOwsnU33c6o2tczT32UBJv+XAh4WCIvFFby0bv2Aov0zX1AODPzv9Dn4m2fk\n", + "/7SPaXsJMKXf82fyZ8U1gND3PvJbv5d/7myA9yUFWg4Ys4BIuo623dh40ipgFVbDA12d3i+Xy9rf\n", + "31+by+Pj47DolstluD588+MuYs+gAD3YjT2CBZPP51Wv13V0dBQAAEWLkIEpwY+MgnH/MusVgQ+1\n", + "ns/nVa1W4364JbgP15cUp7/mcrkopIaiRvkVCoW1k18RgFDi0PmM1d3dnabTaYAg1uVsNltLZ1ws\n", + "nv3xw+EwzlHBiiRYl3vjxqBc/v7+fgRJMjeHh4cxplDby+Vz0TJn0zxYlvcAZvQZZoBr4QbcZkMJ\n", + "+TMAHt0N6e95kDVriJRd1idMG2MPGzeZTLS7uxvuEq7hLAhrQVK4XtyFwP8AS1gZroU8Zn48Xfz2\n", + "9jbqmsxmM9VqtbXUc+K4iFdhbNx95UybtHKNEfwLG+Muv1wuF8xUuVwOoAWAQ9axjp1tdXkLs+PB\n", + "sdVqVeVyWTs7z4UAqTcEY4gx7nuE78KmetCyH/EAU4hr05kcgEoul4vxQ056OEfatl7nxBWLDzIL\n", + "MDpqljoC3N/Lsuidrvq5bAv394Hz97MYHQcHLH5vfn9pHemyQbJYEb+Hf5YFirKUcwr+NrFR3vz7\n", + "6YL3e6NgiAPgmfy7znLxfroYmesU+Ph3/yfM17YbFp+07uZCoUnPwg8LjEBMhGy/39d4PNZgMAih\n", + "4Osd4Uw2gLTKwimXy3F4Ht/xgl5YpLlcTuVyOeYR0OMBbLy+vb2NsuowBgCAu7u7ACLSSsiTPQE4\n", + "g+nxuV8sFlGFFUbm4eFBo9EoBGqpVFrz1x8eHgaQuLu703A4DEt+Op0GzY9gvr29DZDEmAAosBQZ\n", + "fxQMmR29Xk+dTmctVRsXHQoHyp/7UGSO/Y6bgrEB0BUKhVA8KHYUHn0jZkFaFcfaZgNMMxcAMBg8\n", + "YqpwdeTz+QiMfHp6iqw1AlJTme9xG4VCQdVqVaPRKFxqKHCPNeL+yOpyuaxerxfgA8sedxpGgbMJ\n", + "yCzXLbe3t6pWq5rP56G4vZIr5ev9AEoYQBgz9hAgBODOXALac7nnDCTWPrKCQwTZR1RcZX0yBqT8\n", + "+zixXhkv3F2ML+7PyWQSQJjvpG5pADYAmjFAntDHdE3QH5gy/macAEwvta27dbKsYbfU/bssBGi3\n", + "9OGcypM+BDvcw0FGqvAc0HgGBS0LRKT995YK5JRd2PS79Nop25PF6PhzpOzDTynudFz8dQowuB7B\n", + "USxA/34WQHGLKes+6ZgwB+n9/VofAyDxhoBwZi/1CzslDoBA8VWr1agrgvDyKH/Gm2BWFDtjlBVw\n", + "6+uGoFHcCE5jexGr/f19nZ6eRoE15oLiVADSyWSi+/v7KMmO5eXCFUYHVxcCjLEBVBCfsbe3p3K5\n", + "rOl0GuOay+U0mUw0nU5jrBqNRghTt9x5dgJsPY7FXWcI45OTE5XLZTUajbV6Jf1+X2/fvl1jiljb\n", + "gJ/FYhHKhJORSf3E2nTA5+MFsGdsCVgEOCGH2DPbbE7T0x83DB00My5ulN3c3MTYeFo9Lh9A9P39\n", + "ver1uqSVe8FlJmvIZQzVR4k3ccaGFFnkBkyA6wiYQgANwez0odFoBAjzAGfAF4CKPe2l3TnYEuVM\n", + "qq60yuzzNQyYwkB29xMy0d0n3Je1kuoI12G4VfL5vE5PT1UoFMJlCmjCYFoul5G2D2CiX2msi68F\n", + "mBK+6/FkkgJkuR7f1LbGnDiISAEASsfRrLsBeM8VtrtJUFjug+N6qQLmft7c3eA0bKoMAVH+LP4M\n", + "fi3+d0bIAYa7aJyByWIN/Hc/xX6kbM+m7/2UayR1LfEbp/bSACpvKTPibqAUoKRAzN1fad8/toai\n", + "4ZmcKl0un+MnOKnUhaxbk61WKwq1LRYLnZychC/b/b2cnYPF5cKA77A3EJy5XC6qspJNAljxfUGR\n", + "suFwqLu7O/V6vQA+ngqLsD4+Pg7XTaVSCeGFtcSaIKCS+UegTqfTYBdwZeAGQBATNwIA7PV6wYrQ\n", + "f7fUAGMp3Y8y4r3BYKDpdBq0+uPjYwQlUlr89PQ0ADiAApk0n8+jUirsC1k/HiiLBQ/zhKsJoJey\n", + "ZC7PXqK/f4kG8PSaPMzVdDoN0HF3d7fG2mF9o3QZw2KxGIXKYOVYr71eL76DbGEcWS809s5isYg+\n", + "EvPhwbIuS0i1Zd1QGNCDw2G9Go1GsIQYZO5mkhRsDXuJfYSRwHqAQZJWMVuwLtJKX7VarbWYNEnB\n", + "OPl9AFOpPoNdYtzYr+z9arWqYrGoZrMZaxBQ5wY/BgHHQtAH1qnHmrjLGjYQIJS6NJ0B26SbpC2e\n", + "SpxlAaOUvHgT38lyl9DYyExyymQgQPy+mxgUvx+fu4/Tr526irKek/tLilgE+pyOg/fNr+n9yrqX\n", + "K32u7ddxZiW9Jm0TUPPrZzFaKCyEC9Y4NN+mMWH8stxtbiWlACUFsh9bc8oWAY5lxGYlBsKBKwod\n", + "xYrg4RTg5XJVV8BZK0lrygAlTiwKa8796whXMnjq9XooGoQM4AnLE9cRgnt/f1/ValXdbleSAsRU\n", + "q9UIQPVAX2ciid3w4DhcAZ5pgNKn5gjrDvdMpVJZqyuBMiC+wKlqru3gjXXtpxBDxS+XSx0fH+v6\n", + "+loPDw+6ublRrVYLWVCr1aL+CjQ24wr48PTsnZ0d1et11ev1OC6AgnQeU+JAhDX0kuz7pRoMhwev\n", + "Qs9j/RIvAguCPCYeCLAuKbKscrmc+v3+mrzwefLMGg/8hlGRFPE5pMiXSiU9Pj6fms0+Ys0AXgCu\n", + "ZJAAgmezmQ4PDyOeazqdajqdxtENhUIhGC5nMwGze3t7qlara/sNgIZLw10szkYAEABCDkxdhzib\n", + "5EYAspPYD5ieQuH51Gba999/H2D7/PxcvV4vZA4l+B0wTSaTNTCVxtFwPhhMZ71eD3aFfzxjuv8+\n", + "upgTZyakbIDiAZ8pcHBgkQIMBCuTl7oUHGBkMSnuz/TvbYoNcWXqin3T+7RNrIYDiixmI4vBSa+Z\n", + "Ah3+dyYqfZaXmv+WMfK+k/aGEOZzFHN6H1feqeDl9yhhXwc/t7/bbAAQBxnu6kGhSiultb+/r/F4\n", + "HODAi6b1+32NRiO9e/cu3B77+/sqlUoqlUoR4IblDWjBx00DfKBAPcvm8fFRBwcHoVBQnG7lknp8\n", + "dHQUKY+9Xk/NZnOtqNZgMIh55zmxUB0AeCwI848/3dcO7g+Uy3w+j0BEYnWg4FH6WO8oRQQ/v6dh\n", + "CAGMJEVcC5b0xcWFrq6uNJvNIoBwNBqp3+8HRQ27Ij0rOQA7c+nF67g/YA/WivWAZSyt19vYNlOI\n", + "QnbGCEW1u7urbrcbVXV9/t2t4sYZsSleG0ZaGSkEJbMeYUX8pG1JEbd0c3Ojp6enCGz2M2ZYv9J6\n", + "bInHZtRqtcj6urm5UbPZjBRcaZV6D4MJs8iegpmgSu1wOIx1AehBUcPa4ErCJQgrg2JnvKgoDVAD\n", + "XDGOyBH3JuC+Amzn8/lYazs7O/ruu+90cnIS690BCACOvjN/fqAgWXXs+3w+r+FwGPf3lG3PCPI5\n", + "duMpq22NOZE+jBFJmQQam8KVslveuBec9ubzTQyJsyNpQyj4tdLrORuT9peWukq4JwLKn2mTANp0\n", + "ff9+FhDx36eAJgVNDubS8fA++7ylsSBewdSfy+fX5yAFW8wFffHfpi69tM+bwNo2WrlcjgwWBCpW\n", + "ITVBqtVqHByGICIAEKvR008nk0mACOIVZrNZWN1kq6AomS/PQOC7TvO6ewNlAfXLScNOJc/nc717\n", + "9y4sP5SR08YpcEW4QUUzTwhnLFisbk/XJWaAbB2EMBYqboT5/PmYgE6no93dXdVqtaDlPWbDrX5p\n", + "VcsBa3Q2m0WmD8BisVjo7OxMNzc3Go/HmkwmUdiKuBVpdUbJ0dFRBLrihnK27P7+XuPxOMbEA27z\n", + "+XyUMncrFRZxm42MFeYLZg3wAHMhrWf49fv9UNrI1FwuFwHH7IvUoPI4oVxudeAewB+5wO9gLwCc\n", + "zrK5CwGZAQsDGJ5MJrHOyMrZ399Xr9cLWcTcwEoUCoVw0wCG+/1+BP8yBnd3dyqVSnHfNHaHGCWC\n", + "tcfjcTzLdDoN8MPYALqlVXqwZ/NIq9g3+u01Sbj3zc2Nzs7OIi5rMBjEYYhkFHHtyWQiaZ39Bxgy\n", + "PzwDwNLdbABG1jLz89K63mpAbKrwXeFI2ZZ9VmwKD5wqxzR2IY0RSZU4wtzjPiR9oBxRygixFORk\n", + "KX36nuWuyuoL13CA48+Ttqy4l5TxyGJ2sgBJVtv0HQcXFAVDaKTMU3qvTa+zxiHrs/TvbVPfkkLp\n", + "k32C0sJyQVjhu8XKf3p6Uq1WC8DgAaWNRkONRkO1Wk2np6e6vb2NeBC+JymUJamtrHtAO1kBh4eH\n", + "axYwwIUMoZOTkwAT0qpSpGcx1Go11Wo1jUYjjUajuObh4eGaJQigwEoCIOVyuQA5WKhkIHlwYC6X\n", + "i3RTrx0DLV6tVmOdHxwchGJ5enqKwEqUQUohU8iOrAsKahGo6GD+/PxcNzc3Go1GETtALAJ7i+wm\n", + "B98wUICop6cnHR8fBw3u6a3Q+ihl4hq2nakjKZ4P0OVp68ViMdwizKOzErj0CBjO5/MR8H14eKjz\n", + "83NNp9M1Iw3glrKmKDbkNXEsFLNzxpU1hMXfbrcjQHW5XAazAQswHo91cHCgRqOh0Wik9+/f6/T0\n", + "NIAKDAAybjwe6/7+PornwVZ4TBSGHM8E2GRMYIAc5NIXd415PB/K3uOZGBPe9zLxHtvmOmg+n+vq\n", + "6kpnZ2cqFArhQvWibXyXeXSASdo06xTAB7hEHqfuOgczL63trZ1K7HQQEwhtlrIkWTEjbBYHBkwO\n", + "EdcpU8G1/T5ueWe5k3jtFC2WsQt4acW40Hjtz8HzZ73vv3+J/UhBRtqcbUktEu73c9kGB5D8nQJL\n", + "HzOC0diAKWhyEJHVjzRWI2W80r/T8dl2Y+0RzMfrnZ3VCcLSqjIqqbIAFT5zQeDFw66urlSpVFSp\n", + "VHRycrIWqMh18PljfeFSqtVqa64RFAXXAFAAQqDIEUSHh4dhKQ6HQw2Hwyi/PRqN4nuwOE7rOjD1\n", + "NYFARAjDmiCApQ8VEkBnPB7HAXQoluVyGSmSlFZ3xsT34HK5VKlU0uvXryO1m6BhSuvTp0KhoN/8\n", + "5jeh6FA2rH0swDStns9gip6enjQej6OOhfvykV8wUlyDGKJtNj+SgPmVFHEYruQlRYAz1jVrFEWJ\n", + "e0ZSBMd2Op3YB4xj6pZfLpeRDcTaxjWX6gyYM2KhDg8PA6C78sYIYMz7/b5KpZJms5n6/b5OT0/X\n", + "apB4n2DQlsvlWir009OTTk5OIn6ENe8l7l0/sOb9sE2MGUAY7zljwe+llWz2SqywQ9PpNLKGptNp\n", + "PPt8Ple73Q55UCqVwh3k3gPPusHFiosLtokMO/qF/CMTj/ly3fBS22q2jrQ5hsStCd+8zh64sGJA\n", + "2ESpAuVeaT/82t78b++jpLVJ4/O0H/Q9vc7PaZv68tK1NgEWf52CI373U/1iHF2Q5nKrACfG2AHF\n", + "JgDkc/ISg+ULOAU4WWzPz1nsv0RD8QNkR6NRFBtLgyQXi0UEVgJgGGOYCMD3zs6OLi8vI9sHUOjp\n", + "h55xgiA7OjqKuWE9ovQxCnZ3d3V0dKTXr1+rXC5rPB6v+ej7/b6k573Vbre1s7Oj8/NzdTqdtbLm\n", + "pEgi8D0DhfXgQm9n57meSLlcjvRqrC83LhCCWJtYyKVSKbJ6Dg8PI27HC6dJ625MX3P0rd1uB0DC\n", + "VYEl2Gq1dHBwoNPT03DbdDodzWazsG7Z62k8A6CCPQGzAGtCf1Do9I2AXgcD226kkgKAUYB+VAHx\n", + "DAQKo7gYG5iFYrEY7k+qrnrWUi6XWzt8zo0g5n00GkXMCnPpzDigfrlcnTkFqwhIgiEAGBDbQiA1\n", + "jNf+/n64YUulUrgfmWdcs/xP3weDQewvZ+QlrYFs1nmlUgmw5YYz7mAK0/Gs3lzHIX8BtGQHMgfz\n", + "+epgy8PDw3AX49bCFUvDYHD3HZ/73vKUZGnlsnE9gaHxc2T11mJO6Jy7AFIkyUQ6s+KfO5jxhydz\n", + "wT/jXm7lS1oTGlluDmcMvB9Ob6V0Gc/nz5HlcshiAbieAx1p/SyWrOukCt5f+3ilcTQ/p3mfUtCH\n", + "EHbFyn3cb5+2rDlM2Zm0r+n3eM5N8TLbaARDEvMgac26xipB2HKo3f7+viqVSlwHoYTi39vb09nZ\n", + "WYw97AjWDu9zz16vF2nGzEs+vwoKdX8+1DQCClcJ/mUvtFapVPT4+KirqytdXFysxRT0er3wOSN0\n", + "eVbALWwNbq7j42NNp9NgZaDQU0DjLGW1Wg3l7dT83t6erq6uQgG51c7+cZct4wXIub6+DkubAEZA\n", + "FgDm9vZWp6en4cbE/YJbGSXHa/fdM5/MAVYmJey5N/LKD7KDVdtWI/CTDJh0D6JQUdhkzCwWizWg\n", + "C8Phhsx3330Xqa0EiM/ncw2Hww9kDe6Vg4ODNbeJz7G7OZHbMIIwJMvlUu12W7VaLWKtSqWSbm5u\n", + "IpUXEPX9998rn8/r5uYmMlJg49hL6Jvlchnpx9VqNZQx96SPsO+s6WKxqOFwGN+TFOzrbDbT0dFR\n", + "6B0MH28pI0gNFhpxJRgmXjSPuJB2ux3zgsyg0Sf0H2AsZXl5VuQxe4igYFhJD5DfuOb+P67V/1+N\n", + "BQcac79Z6mNMFVjWQLjCZDBoKevCNfmuKzgHCDRX6lhxaR9o7mNN75VOBH3yZ0/vze83fe6MT/o6\n", + "67cOVLKYpU2NOUndYPx+U7wL92RcHISlr1PQkQXYXgJnP4cB+iUaAimfz8dBYAhjWhpLAH2bz+fX\n", + "SmLDfuBmKZfLkcHC+sP/DWhAaRYKBfV6vUj5Zey4N6CE115NFgHi6xsrVFpR0g8PDzo9PVW321Wh\n", + "8FzVc7FYqNlsqtfrrVVlhTFyhoHYA863IXMHYITVS1+xIEejUQQn4h4AFJJ5ICnqlbgxQmPt3t7e\n", + "xomwjUYjxj6XywVo8tIGrLVqtSpJUUOF+UW4M9Yu41BK7hZmrlAU7r4hm2PbwbDSqvbNcrmMmi68\n", + "v1gsAhACQgHCPD/zj9uAAFbcb+VyOcZ0Z2cnWDAHGpLWzrdhrtwo9MBZwDcgG6AprVwOgC32ArV1\n", + "Dg8PAxywrk9PT4M18/oixWIxjI6DgwNdXV1FcGylUlk7HZyS9awFCjE+Pj6GEVAqlTQej6P6MLFR\n", + "3BPdxfi7HkHewHLs7OyEsfD09BR1TmAqXRcDIKRn8OLxMakeBqQw/riT2Y/5fD4AkOtP1yWuf7Pa\n", + "VsCJA4Y0/iKNN/GWZWmnQpff8+AgO+lDhSmtKlT6595SpekDysR68/vR3ywl7Ao76/mDW9nQAAAg\n", + "AElEQVSyhGlWS4HIS6/T936uQvcxcICSRZungOKn7uNzlLJN/h02hLT5UMOPAZxQnAyKGSAhrao8\n", + "kh3CuKEI3bJZLBbhTsnn81GqHTcBcRUwBE6XkvYJPetl6z3+gmqs3P/29jZqTvh5KcvlKsaDfUYt\n", + "CIIBPdiVzB/SKgkKdcODfuMuwLqVVkrZ/dXcj8A9Mpomk0kAAmJ63KID3LDn+Iwx3tnZiQqgjAVB\n", + "xjwzAMGtQU+9Zh4BMhgngBqvTSEpsnlwH+zs7ETNGJ4XCh7Fj3LfVuM5sOR5ZndnIBsZAz89GmXK\n", + "39fX12q1WuGmGA6H4QYjaNtTZgnqdiYG5cfe9zAAmBdq07A+fC1Iz2sAlgewm8vlIq240Wio3W7H\n", + "+nj16lW4aLmuV8SFMcMooC/oOhgNwADsHzVvAOLsXZhBlxWSIijZdYUbPbCr7p4qFAoB1mnuQgJM\n", + "elFGD7xl7QM+PF4OGcG1GS+CpYl9ISiW/eHxMWnbGnPiSsxdIh7TkC46ab0UOJPg3+MafId/afxH\n", + "qjy9OTPAPwaU+6TX8gXi7h4HTy/52TYxKylT8VJLwY2zPlnX3XTvrOv6tZ1id6Di4+LzmMXw+Liw\n", + "CdwiSGOFENbp+POdnxqbX6rhz0WJkqWwWCzCGpJWligxG+VyOVJqpVXAN8IWoYxfnO9LK6HE2GC5\n", + "4hvHwuS+xFfk8/moh1IsFlWv16OYGvcDNCLEPQDQBae0yjRAKHY6HdXr9TUrj/7i2vDgOxQ+Cg6/\n", + "OKyNW+XdbjeEP2OJT97dtIwL93d5gJ+fIlRY1s5kMF5ck9+STutWJcoUNqtYLOr09FTSqlDY9fV1\n", + "KB7fl51ORycnJ3r//n0oJZgwYgO22fzcIU9vJh7D9yTfA5yyXjgc0vc88w/jSNYPFrhnllDozEug\n", + "S+sy9+DgIOrfOPPg4A45AggmPdzlGSxFu91Ws9nU/f19VCTu9/ux/wgy9/kk9orrs5ZQzM7wM8/o\n", + "s8PDw4jLce8CwJk16UYi/7OPdnaej0mgH5xFRWA8wB+d5CQB1+CejAX7kixDXJsYP8TveE0fjIub\n", + "m5voB/MNm/WSQbm1mJM0kAzBmga0+nedqXD6yq1oz/ZwMJA1CJtcEln9ZQLT6wKsfHO6/y9Vxs7S\n", + "pACB9/k7BThZQjYFSemz+r1dsfv7P/X8PAfPynUQHg5OfFxShmMTI8K4QkO6PzpVMOn4+3h/DA2B\n", + "RL8PDw8jU4D6ByhBT/ldLp991QhmSkZzPgxCAqsGBY+QcaGAi2M6na5Zk/QL0IQFisChgBrBf5LC\n", + "3eNCzFlHZ0G4TqFQCD85+xbQhKWFYeGl2zn0D+XnhaoQvrA3zWYzrgUgoEAdY+/rM907PAOZM3t7\n", + "e3GgG0CDOapUKlH0rlQqSVK4tegrcQfEAJFxc3Nzo3fv3uny8lI//PCD7u7uIn6kXq9rf38/Yg16\n", + "vV5kP/kYe6G2bTVYscPDw1iPBPUSVwPbRio8MTbEHLi7EtcCTCHl/lHiyHXmHjcRABW2AuCOwscF\n", + "huJ3Vsf1ibt42Fs8F7KN92azmWazmY6PjzWZTHR8fKzFYqGjo6NwMXqqdKPRiNTxQuH5ZOu0lgtu\n", + "U+Qj4AP3JQwe4yqt13hxQznLbYlrCMDMOiVdn/nwWE7XN8hlxphxhP3hc4+fkrQGwIjl2t/fjwwh\n", + "5hhm8iWDfavl63lA90PzubQKQnWB6ErLgUUWg+LXdbDD36mLZhMYSAEIgtIXd9YC8b44EEgVtH/u\n", + "/dv0efos9DEFKllAZxNweak5s+XWBe+l90xdPz4ffo6Fu+AQfq5Q/FousDb1+WNgT9iUtVotrH+o\n", + "byq7OvPQbDbDZQENzriSscN3AW8IGhiGXG6Vosj8UrgNgUCUPcFqHniZz+ejLsvt7a329/fVaDTW\n", + "4lVQADAjZAwBFIbDoer1etQBWS6XAX5ggLrd7loRKmf1KEzn4wi9vVwuI3DYs3CwwLCqOYBP0pqf\n", + "X1qtDYQna3WxWGgwGOjh4SFiGRDAFFAj/oXnqtfrcaowMqbVaukPf/hDBC7O53ONRqMoZNfv9/Xj\n", + "jz+q1+sF4CN1tlqt6vLyUu12W+12O/bCYvGcccG9ttkIcsXNJK0OoUTRu7zF/UOslLtBmKNcblWA\n", + "DyXs4BDXBNflmAHuhbvC5QigGpnlgdmcrkuwMy7AfH5VCwS20M+HAUjAamL9z2YzHRwcaDQaqVwu\n", + "xzEQMJMAq8lkEvdz45uGrIS94Tlx8VF1OmX9XD8CQFi/BOSyVyhS6CnTjDXzcn9/H6wpoI9qyQTz\n", + "M1/EscC0kGnkzOPXX3+t4+PjMLCYZ+YQlmfjmvvfX8Y/3Vwp0lk6zmAyeU5rO13kFfNSq8iBQKqQ\n", + "nf52sOEgCMrRQYffnwXCwBLkBrJ0xOl9cX9g2md/nQVMsoBP+ltpvUaGC+D0en6dn2pp35mTlJpO\n", + "WSF/HhdeCBL3xSL8fbwZYzYcBbLcr5zO6bYbFs9i8RxAh6Bwf720iiPBZUHxMqx1D8J0NwiBbbwP\n", + "Pcrrg4MD9fv9KOXOukSQME4cm+4WH4Dg5uZGR0dHITCxdAjgw3WSy+WimuXBwYG63a4ajUYISkkR\n", + "JHd/f69qtRr3WiwW4RqRtMYMMBbEFJDV4zEguLiq1WqwHygSrzXhbiesa99fy+VSn376aQAUhCvZ\n", + "Rygq+ozywJ2B0L2+vtY333wTypI6NFSTHY/HqtfroQhvb2+jGNhy+XyOz2AwiL4j8xaLVdDzNptn\n", + "iuzu7ur9+/d6/fp1GG2uZDgPyt1S0spVyZ5HNqXBtMgAXDPScyAse6VWq625/AgyzefzGgwG0Q9n\n", + "27kmv+V7xGF4GvRyuQyQvr+/H5VU2Uf0m7lvNpv65ptvdHZ2FnILlxJgmj3hx0fgDkLf4M6RVgdm\n", + "3t3dqVKprAHy1IPAPfkbdpT1RGaTFxcEgPs1AGH0zfuKTGNM8vnnEgMAGK5BWQCO6vj222+1s7MT\n", + "xewwYvw8q01ta+AEAYHQppOe1SB9GKvBd7MUubsA/DPpw5RghLazACmY4btu+TMJULgOQLyxgNOF\n", + "lLb02j/X+k/7mgVwnDFJFXcW+7SpIeRTMOL0Yso6pffgOg4IpXU3TfoZwjllqPwZfU4+BubEQdx0\n", + "Ol1LpcPSL5VKQeX70ewoIKwyBMZyuYyaJQh9ytYzPgjrQqGgZrOpfr8fcSfD4TBiVVB2i8UimA6s\n", + "KazHnZ0dtdvtAERuXcLUULW1Wq2q3+/Hcy6Xyyhc1W63I5ZAUliDCORGoxGBvr5e3Vr19TYYDNZ8\n", + "8oAtTrf13wAgAFyMVSrEp9Op/vM//zPWcqVSCQFcrVbX4gOQLWQKUTQLvzsgA1CFC8c/90qg/X5/\n", + "zbWHmyCXew5O9HohR0dHv+Qy/qBR7wPXijPZ/E1AqbSqiwIwATwiD1xBUmUX5gpggouDNfn27Vt9\n", + "8sknwUgShE2sA4odoMF9YDYWi+e6QtKq0qqn4cNQ5HK5AB7sj4eHhwBkvV4vlD/rtV6vazKZRMaR\n", + "pKggm+4h1h5AGcaPezvDgovPDdrlchnB48wB44keQ74gi3AxszfSEAWuSeVjjCxncdGHsKcE8MJ0\n", + "cZ3Dw8NgbnE940ZirwKAmLOsttWAWP4hUFKXgH/XrWRpZQXR3NJ2JZoFZJyN8Ws5SHJ2xBkZX1R+\n", + "H9+wriz9WVIAxLU8L9yfmetmgZYUfHn/0s9dIPgc/Fxlzqby1L0UlHDNtH/e99SNln7XY4vSefeG\n", + "svONxXxtu7E5sRIkhQBeLp/rD/C+pMhSgfkoFothJUrPzwjVSultDtiisBQsIsqQrB4UI6m9pGfu\n", + "7DwfKEh/cEEQr0EtDqhed2EiWGBwmEcCNu/u7lSr1TSdTsOHz/4ikJEGNcxa4jVgi7VArA0CDkuX\n", + "2AOvnYKlxxxIq5Nccem45f7rX/86XCmwP5Iik8iZPvYBLrFcblVTA0AjKZ6T4l+sZ34DU1AulyO7\n", + "C/DEHACAyOaAcdtWA2zwXF6/hXFgbGHZmFPfwz5/Hk9xc3MT68xrdHjGCsCW/tzc3IQ7j2wXzjbq\n", + "9XrhinIwj5uk1WqFiwLZ74wsCpcCf/P5XCcnJ5pOp+HeIgi03+8HKMNw9aBPZ5Wo0QIAd73D/mbO\n", + "PY6MuA/Gmf66/vH/CfJlHeFOJ5CY37u7ibgxZ2gB1Bg36AHXdQ5YyV4i/RkjHpDnpRKQd5vaVg/+\n", + "k7TGYEgfnh+TKuAUZCBkstwt/hsaQt1ZE0lrwpc+eLS4uywAH1ngwMFV+s+BA8/uzEUW48M903+p\n", + "Yua19yvr2ik78XObK/7U5w8CBiHzHbd6HYT6c6Vj5N9HKaSMTdY1/ydg6/9lIxiQvkNNo+xIU/Wx\n", + "4IhxgAbCAeEB1Y8w9dLwbpGjkIlfkVZr59WrVyHIpedTcQeDQWRPYPEhuNxnj0JmfAEY0M4ooMFg\n", + "EEqEg9QI5iRyH7CBhYg17a5arn14eBisCs1ZDBTcYrEIqh6GD6sv3eOpLPjb3/4Wlm+hUNDJyYlO\n", + "T0/XXEMoLa9+ydwR0OsAiz55bASKgecEgKHIYbMAhhR8k/STgYO/VAOM4PKAbfC96jE6HuMEGwFD\n", + "5W5a3FiAXSxyxo+6NScnJ2HgoGx7vd6aq4IUYAf3vq88VsUrGvuhlPShVqupWCyq2+1qMpkEW+Lp\n", + "uE9PTwFW6C9rgvWSMtej0WjNPcPzo/xd7klai0NzPUffkROMw+PjY5zf5HK10WisudbpFwwv1wYg\n", + "OcuTpm17kVMYzFwuF3PF34wV90X2URQuLSbnbSsr3gUzDwztJX1odTMZKUDwICGaT6Jfi/eyfiMp\n", + "QE0qBHyROFXIc2SBkPTa6Wf+/K6gsxiILDdJyrD4okmv5X3w/joI/Cmg4vEhWWAoBRwpCPN7ZzEu\n", + "m1xDKMgUsLq/OmVRtt08IA+h46mg1OgoFArxXTJNACJkCBC8R4Go8Xi8llGCUPB/HPXuAuz29laD\n", + "wUDNZnNN6J+ensZhf9KKISOmBLbHmZLJZBL0d+qnptrmaDQKQc6zko2FUmYuy+VyWN4oddYbIMuf\n", + "k/vCNAGaUAoE5iH8vVaGGxCsZ0+rpBLrYDBQv9/X3/72N3W73agMSjVcwKa0MjA8UwX3F8oB9mRT\n", + "qXeeCcbED3sjSJR1vq3GesbSJbaAZ+RzACdrfjAYxNohoBmXg/Q8fmRD+fWYM8aGeKD0b4JtuRaV\n", + "VtNqvMR0cE3WH3EsXJv5lBQxFa9fv1apVFK73dbR0VEcE8EzEPtCn2DDPBjbAdR8Pg/mhnXD/WFS\n", + "2X++dgEQACze93FCjwH8fC8wRj62MGEOGj1+krmAHQG4AaQxmthr3ieeiecjoBZmiHttaltx69AY\n", + "cG+pUnUl7r/jM/6xoJyF8e9nKX82FQuGzYdA8cUEgEoVa9p3LE/pw7LqHheR9TxZ72cpewc0KRjb\n", + "NIap8v+5TAP3YB7S+XDWIgWQWc/gzJNfw8fvJYDnAiprPLbdoO0BGghcfL7SszAjtY6qkCh4LDgE\n", + "G/+7heZjARvglpOn8y6Xy6g1sb+/H0IRv/KbN280HA7jaPhGoxFuFKhlD1ymmqunOXJPQIUH2tE3\n", + "gn3dtYL/G9DPZ25NEZ/j6bX8lvidbrerX/3qV3GGiI8Zc4Hy5PestcFgoLOzsygshsAmXgda2un3\n", + "fD4fisXpbJhExgwXM2wP90bOwB7QcOF5PBtjtG1W0BUmlq9b4SgaWDK+T0CzK02ChpkrAsYZA9ht\n", + "nhngjkuBAGXYht3d3Si9zlxdX1/rzZs30adGoxF9ocEMMl+4OCWtncHT6XTimXG/cShmt9uNzDyu\n", + "ybPhBsMgwB0mPQf4NpvNOCfKjT/pue7NmzdvdHl5Gc8qKfa2tJK9i8Ui9hDrhWBtWE836LzyMKUO\n", + "PFUckAcjybh7yARMaKFQCPY1NRB5loODA43H45hTCklS6mBT2+rBfw4ooJC8ucUOCOG7bHoXWKll\n", + "nrp9UuXHd3jPfdQe7Eo/HQihGFIA4nSZswqbmJWUIXpJyaaAImWMfKz8mt4v/5f2fdM9nZ3wBZgF\n", + "Jl5ik9L7cg3/XRZTxOc01oF/n+fednOLjIOwUOL4xVH8XscD4QDVj5Xn1pnXG6FWiVcYJVMGId1q\n", + "tXR2dqYvvvgisngIQAWE397ehvukVCpFJolbw2REAJxIBcflgv99Op0GGCDd2EGBzzkWrbQKlE4F\n", + "7c7OTpQSdzD79PQUQcOz2SyybebzeVSklVaH0mFY+BwBkM7PzzWfz9VoNFStVoMRYe2hXGB1UGQO\n", + "ynyPM1ekIrsrjWdjjnyto9Bhb7i/P/c2G2NQLpeDhSBo11kCl6EoYjJxcElStt6tddgHfo8iWy6X\n", + "UXUYxoCxef/+vXZ3d1Wv19VsNjUajdayyjgzygsDSgpWAVCFQQkDgKW/WKwOzzs4ONDt7a0eHh70\n", + "7t27tRg85h+w6mAY+QnTAKPEOVR3d3ehrImpYT/3+/0oYoisA0x5zA9Aw8FAr9dTq9VaY7Jo9I1Y\n", + "kuVyFe/F/f2ZMCrQA/SBE8HZS8h25kDSWlzNcrmM88OoZ/TS2t5aQKy31AJOYwiyPk/f5/8UkPji\n", + "y2IZ/LvO4nhglCvh9DXXkFYAIVXim57TNyefu9spvY//1lt6Dd5z4JAFRNJrp83dKVzPwRx/p/dK\n", + "+5mCEx83roew8Of0+ffxcJCYPvfH0BBO4/E4/NZsRKwSBCBWZblclrQKzgaceKbL3/3d36lQKMTJ\n", + "wFiOg8FA7969Uy6XCzAEa0J/qtVqWPC9Xk+S4vvSOgtJH1EmKFmyD3jP0yA5NJDnXi6Xa4oL1nF3\n", + "dzdAGMGf3N+BLPvAA3BdydH/YrEYVUW9FDfZSxgZKErW1Ww20/v379VoNLS7u6tutxtjx72RAfTD\n", + "gzs9+JN94EIcgQ8j4IwI+yVlx3iNhc71PSB5Ww0lg9vK00xZJ4yBpwVLK8DCOHrlUa7nAJaiXe12\n", + "W2dnZ3Fd9grjTAG7k5MTSYpA2vl8HooXF9xsNotAXGmVPdTr9VSv19eU8N7eXhypQAYOIGmxeC4R\n", + "gDHB86XMhJ+fA+PkMUyPj4969+5duMekldxwhp7vL5fLyIaCuQAguvwnEwc56UGurGncOP4ZrBHP\n", + "wDrH/ULfYLEmk4lyuZzq9bokRYwZMSVkatFv2CbG2NmzTW2rbh0pm/Z3xZYCj/S3qUDDqvNYBfdl\n", + "S+spwalyS+/rVlaqPCWtKckUWGSBCr8vCPalfvj9U3bFFTXP5a/93mlf0mfIYlByudxaRDv9SZmP\n", + "LPbCv+Nj6s+JcuFzR/9ZIMfvkQIlf55tNq/DQq0Q6FwKauF7JVASdwaCQ1oVYOPsmPv7e3399dex\n", + "VohFYbypXAp1DWDwuBO+32g0tFgs4tqSgrKFMmd9jUYj3d3dqdFoqNlsBuhxgMj/uVwu6pnAbGJl\n", + "QzFzP7IoHLR4MDBKnswfPzgQBc/4YdFKq7NbsJIZjzSwtlKpqNls6vr6ei0bqtFoSNIHz+fWqwMd\n", + "VzbuapzPnzOg6C8yCFACO+W+fGdWuB7MGHEV22qpocG6Zd0ABjHyYEMAgrh4pBWDxPyWSiV9++23\n", + "a0wV1jfX4iA9Ulr5h/wsFp9PEB4MBjo/P9fd3V24DTzFmPUFI0gcFUGgzLfvHwA3VYmZ0/l8HjFT\n", + "GBOAy1RnuBuL1PDZbBaMI24e2CMv+4+MA3ABInDBIPfo2w8//KA3b95Ef9jT7AN31bpBzjjB9HgG\n", + "EtemfguAnnpKzt4AUGFrYHy5Pr93eZDVPgpwIq3T+iwIpzRd4XsQTcouULnSYxMQPlkK0wWCtAqo\n", + "hbb2Q4/cbeD39UlOmQlXpOn73g8sTPrpz5QqbK6Z+il9nHjtQMw3tTMpm1gHru2shlf4pPk9eN/H\n", + "m/fSDYvicPeZsyNZTIz/7QDJx3SbDYsJ94yzSoABXB8Ezs3n80gfdmsd6hXQ/d///d8aDAZqtVpq\n", + "NptRhyNNnweoLJfLtawEhAyFne7v7yPlEEsWAYSVhr+43W6vgSlcq1j1rMeUGSBFkbgJUkM9JVLS\n", + "GlDy9Nzb29sI8JW0JgMeHh50f38fwg5g6AYDAtD3TqFQiGqZBE0Wi8W4n7vPABWAKBSD19IAnLBP\n", + "6Etawh2WCreeM4jufvJgSErE89ttNTKwYDZgTIrFYsQhsa4A03t7e6rX65HCzrNC6e/t7WkwGGg4\n", + "HEbJ/+FwGPVDzs7O1gKxl8tlKGPiue7v7zUcDlWpVDSfz6Omz+7ubqSvshZZ4wBRMn6YO+YZ5sVT\n", + "9InLcLa7UqloMBhEufpGo6HxeBylAxgH4mJwJ+HOgaFhrVGUkb3schX2ETewA2FJ8WzUYEEuLJfL\n", + "yMxjLyAvCE5ljJ2VonEvntuBXKvVCtACq4ZRgEyBFYKB4bkZ75faVmNOUJ4IFDa/B/c53cz7rlSz\n", + "2AwEv3+WZWUDYFLLm3t7rAnXcEvI3RJQnL6oUrZDygYa3I/fg0AdwKRjkQKllGHKAjZ+nbRPKUAB\n", + "lDhtjb/XY3183NLX6dz4M6VMjbNPqWsuZWf4Ox2Lj4E5QXFj2VD0qVwuB42NJSkpAmWxPBC8jLW0\n", + "cgl88cUX+qd/+ie1Wq1gndK9IX3oBhuNRiHU6AM1RlDOpVIp4iPYF36mC/2Bzsdq9APTEGTua5dW\n", + "h4nhk0epsdddQLJm+A1ABmUNa8Hz7OzsBC3PIWysVUBduo4AB3yOZT4cDvX+/fu1UgPOGhIvwFgB\n", + "anzNwtweHByo0Wjo4OAgik+5C8QZE54ZS5lsCL5Lhtc2G3NJGjGHWKLkAFUen4b8QGEBaN09BoAc\n", + "j8dxBhVxGJIiriOfz6+tH2dEAIK1Wi3S9QkAx/AkuBlQCeCRFO5HQClj77rBi6Q9PT2fA8XexV2H\n", + "OwcmVFpl72GU1Go1LZfLyE5yBtNZG9Y6ip97M+YeR8Jev729jfHl3nt7exqNRhqPx2sg3wEO93AZ\n", + "y+f8o+4R8+s6mO8CUJDN6RlgxKwhI16qcSJtsUJs2lLGBBTH9936z7qWC+RNqYcpc5AiT3/tSJL+\n", + "+b0duW5iJFIXS3rPTfd2Ab0JRDjY4O9NIAHFkY41/cpS6ghJrHi+70rQ3VFZ983yJzq4yOqj59an\n", + "v0+BKb97if35pRtMEBtVenYh5PP5UDKkCyOAKJzm7AfMQD6fjwqiHORVq9Ui8HN3dzdYF8YHC2s+\n", + "n8c9Eeqz2UyTyUTFYlEnJyfhIvI+cw8AELUKoO9hflACnp0EW7JcLsMq9cqQktasWd8THrTnmTaA\n", + "EFxhZCM4g0rQYy73XHmWYEiYDE9zxF/vIJIU6dPT03hO3zdY1MwPgtWtbGQN4BNFSd+k1UGDrFmY\n", + "KtaOK3Dq1my7AJukYCoAbACxQqGg0WgUh9tJK/eJB3HDbsGEuUzmkMTLy0uVy+VgJAj4Rg4/Pj5q\n", + "Op3GuLgrHUCDAmZvoNilZ6DDWVGsPW+AnkqlotFo9IHRw/ol7qPb7QazeHFxoU6nE+AXdoA1zLrz\n", + "1HjcvHwPVxagB3ewsyAOcL0YmqSQCa9evdLDw4Pq9bra7XbEvnm6PnKWv53h5zmdQaVfuVxOo9Fo\n", + "7dRo9qob6R4wXigU1tKikTUYKZvaVsCJU92eNphaOG5ZeCaKNwSbMzAgM2cJuD4I0ZV1lssFwcWE\n", + "uOXvAIrN4ddz5erfow8pU5P1PCnocIDm4+hj569TMObf8f5kuZ0khYJxdM3fWYDP++8AhPt5H5jP\n", + "lLZkE6bsioMwd/850k/B2bYaQhyFlcutykBjZeNOAajwTNCiKF18ygiVSqWidrsd6YcINeJVptOp\n", + "ZrNZBKzSB5QFJyNLz2xMr9eLVMJaraa3b9+GO9PvjRCjj3t7e2o0GppOp0FLQ1F7jQ4XuoCKUqmk\n", + "2Wy2JpTc0sSqRYCxdgigRQ5AkXNtBGGx+Hz+DrFSBEH6PgUEHB0dxfoiawmmxNlPAgelFbhBuDN/\n", + "KCHcMMQNADYoh88hfmQg4UbiRGbO7Lm7uwsFSbbXNhvZIex9mCDfo8wxQALlieJCkfEe4zgYDAIM\n", + "E4tD7AZjBAPpLnh3Ly8Wi3DjLJfLMBL6/X4Ec3M0AfEcAHECl5k31loa9+LPiFtHUuwT2BxcOs4i\n", + "ciwBOgXQ0ev14m8H0hgZPCfj5rE9DiQkRYD3bDbT6empJpOJptNpAJPHx0c1Go1YkzT2jfede7Af\n", + "ceEir5En7KXHx8co1AazA4BkXUsKA5R1/ZJrZ2tunSxLN3XneAqSlJ2OmwIaJpSFxaRDO0orq9QX\n", + "dupy4H4eCOclqlOAwYZyxsSpOleeKRhAADtLQz8dIHh/N7l1vG/+dxZQ8XFM54HFJWltTL0/L82D\n", + "P5/f0/vA/LoQwFqHkuQfY+kuH4998Ptss6X0rJdBZ85gQO7v76OgExYkjAc0KoAGCrjZbK4FVO7s\n", + "7Oj4+DjAy8nJSaSkLpfLOCCPOAbp2SKq1WqhdDudjmazmf7+7/9ep6enkhQH4S2XS02n0wAaktaE\n", + "v1dS3d3djZNoHZTzDDBApVIp1pfT/J76m84lhekQdMSI+FrwmhUEJKNAnZ6/vr4O5URm0/39fZwg\n", + "LSmYKAdAsEjul0cws1cbjUb4/AGDjFen09FkMlG73dYPP/ygm5ubADjL5VIXFxeRtYWSZPzciNtG\n", + "c+UKeOT8J0+zBsCg7JkbD2yVFPIXRUgaMHvk5OQk7tHv9yNuBVBEbAYMBNf04PJGo6GzszPd3NwE\n", + "68aa4eDFYrEYgbOk5zso9Mwfz4LjPY8hgSnkvB5irWAVJUXfWB/cI00GgC3K5/NrtXZYt6QYs/7f\n", + "vn2rcrkc6485c28DzJW0SntOQYfrHrwH6EsAp7vkDg8PI5vPjUx+A4PGXDJ+7KWX2tYDYqV1Bc/f\n", + "WEIo7ZRRSH/rn6EIXGm5j5fBk7QWDOQUs8eSLBaLUCAoTfzCLhxTHzLK260wru39T10h/vtNgbbp\n", + "ePnfLBJvzuakLEvaAIaS1hYb4CFlgXxRpyAl7TPvZ8WKOABjvLi/F6XyZ/Q5/RyrqEwAACAASURB\n", + "VBgaQtAtSmha1rIfxrdYLMKKZtNiSSEYeebpdKpKpRJVRaXnYk0eT1KpVPT69euwgNg7AAesQs73\n", + "GI1Gms/n+rd/+ze9fftWrVYrghiXy2UIc5QlWS+j0Sj6xj5YLpdRsRPhyjryIk6e5SEpmA2eQ9Ka\n", + "0PQ4BrKYqEnB7wFIAB9PkXT25/b2Vl9++WXsS2o11Gq1tb0H2EEoSwqZ4srX05v9cEGYK8YDpbBc\n", + "LoN+LxQKEWB4fHwcmUknJydRTp9x8WJt22oem8A8eXXjyWQSrB2yCzAD8GROPU4BGcxRCADL29tb\n", + "XV5eBpswHA51fn6uxeK55DqnHy8Wq9NwYV92dnYic6fT6UTgLWufjDkPfJVWp3sDtnDJYThIKxdi\n", + "pVKJWj7D4TDqlPhZP8g6YrSY93w+H8yaH8iH7PD1BIDCPeJndbn8ZU4oXEiWHP1y17yzI8SFuIz3\n", + "fcB3mR/YUUA54JQA8FKpFDVdYFZJX/bzqkgj39S25tZJUWKqJFOF5cI+pft5L8vNgXBDODoq5XO+\n", + "m2Y98D36SzomQt+VK6xJFhhx4f0SMKFPaVxH6pZxgJYq5tTl4d93MJU11twb4IVic6Tsvlq/L8/v\n", + "1/F54vv010FICnjS3/nYpCAn7f+2G9So+1NRjDQsQBgqgC3CCKBBsKHvFwJZOVTv4uJCP/74YwSG\n", + "cvZHLpeLIEPiXUhJxYLB572/v69araa//vWvenh40KtXr0Joe+wHghOhh9Chb25tMf9+ABlMEmX5\n", + "3f/te4rXuJeGw6GKxWKkXQLipBXoeXh4CKscEOWsp6Qo1MYhh7hqqtVqGB300ZkVSWtF87xuBGBP\n", + "UsTsMDfMe7PZDEEMMMNifnx8VLvdDmVJo6YMwv0l+vuXau6WSCl/FA8xNrBqzpowFx4gDMMA4ISJ\n", + "ePfunY6Pj1Uul2OvkJ1TLBZ1dXWlzz77TKPRKNyTBwcHsRboxzfffKOjoyPV6/VIG9/Z2QlwjkzL\n", + "5XJrqffSSuawTlHSkgJMeTgBVYNxpXjQKsqfZAqehzgUSeFWxJgAiDBuKHJiQZiTXq+nh4cH/frX\n", + "v5akSDtnj7L+eTaMHi80yrOXSqUIdmYfOiD36/ncSor94fLMA969xIe7tja1rYATj1lwt430YexE\n", + "2nm3/gEkDiiklQJDuXJNj/zmunzuAiOrD1zfB9s3nP9L4zKklaWfXjtlNHjt/lkfFwcojpb5LIsV\n", + "SZmctPlvEBhejMp/x/3cveJ98ziStK9Z/UrBafrddG2kQMTB6ccAUsiAkVYCjHXAmsEiQzg4XYq1\n", + "DgXNepNW51DxvAiDf/iHf9C3334bawX2hriP/f19tdvt6ANpxFg91WpVo9FIX331lSaTSQAXrBv3\n", + "pTsd3el01hQx9wYc3d3dqV6vhxXK3iKNFoYFS4zxk1br7Pr6WoeHh6FsfJ7z+dUhnyg7LGqAgLRa\n", + "Q/V6PWIXyAyhIit9H4/Hse889Zc9uVgsdHR0FGCDeg9Y7cgQD5hlvljr9C39HsD/+vr6A1Z229k6\n", + "WM7u7pBWGUbS8/4kGBnAiRuPViwW1+q/YDzO5/NYl1jyFBvM5XKqVCrB2BUKhWCWYMlIb0UGeTB1\n", + "v9/X0dFRlIt3txtgCAMAdpKibbTpdBrA9fHxUbVaLeaQe9J3QHy1Wv1g7SCzWS97e3sRsOqynmdi\n", + "LzqYcR3FPFxcXEQsDwHysFoewwJwwPDwSs0eX8j3MCJcD7ph7gwZsh/WB1bIwwHQ+ezdl0D31tw6\n", + "rpDTDroASj9LlZFPkvvOpJWljtU1m83WAAq/ow/4wX2g+S6L0pUv12BSPYDJla0H1aaKmXu5snfa\n", + "k+s7cHFQlLp2fJy8L6nV4wvRf8OiSZWA3yMrONnnk9+81LcUWPn7/tqBj49ZulY+BmAirTIVcONg\n", + "FXq2B0KWAD7qkMzn8zgojTWA0EIw4mKk5kSlUgnL0dNeiRNZLpex7huNRvyWWAq3YJ6enkKgeuEs\n", + "qmQCljjQz0915R9pls1mM6xhd025yxBAAUNBPQj6PR6Pw4XFfsAy5jfOWCLM3UXg1vpyudRgMNDe\n", + "3p7evn0bzwvVT1o1QngymQQIYYwKhULEijjgJAbC4wPcTZWyOPyPq8MpdbdWGZeX6O9fonlGEuyF\n", + "9GGdKQ/+Rp7ALnn59ul0GinxMFme9XF2dqbLy0t9//33+sMf/hDKejgcRqBzv9+PIE/mjXk+Pj5W\n", + "t9uNOiScVox75u7uTq1WS8ViUYPBIIwFAHValp/4kZ2d5xL+nU4n0oKR+yhk4pd4z90bkuJ+HiQK\n", + "kIIxlZ7XBuDfD8xzoxcWBObPARB9J86DfUUBRMYMdvPu7m6NDeL5keNe/t/dQ4AtXnvJiZSNcp3v\n", + "+iurbTWVOO1klqWPJe9AwMGHsyBck8b3sLj8unw3CwSlLhkUSpYSTJVmyoakuehZLhl3ofj104Da\n", + "9L5Zr1M2w/uVunTSZ0mf09Ex1/ZFL62Qu89VKoD9dTrXzrD42Gf1LWu8/Rk/hgYTQJYMdC4Cgvk8\n", + "ODgIIeEguFarhfJlrIlNAIBAmcOQcGw8wrFYLEYMBW4Ip7xxOcGsPD4+hvuHPmDdsAb9YDXYl93d\n", + "3cgIABgREMghfJ5iK2nt3g60F4tFZKwQZEs2gINo3D3ud6cRoOllvlP5AmAisBU3F+ABMElBNgfz\n", + "7rYBlHjsDPE4ABoUghtCKDNiUrBqeTaCLAF6Xjxrm40xdMXD2ABGYMjcmPO4E9YfqfXT6TSClmlk\n", + "rJ2cnOgvf/mLPv/8cw0Gg2BKAKgAQQAl65Vr4WKh4i8MJaAfxqJSqURtksViVT2ZfcFz5HK5qOpK\n", + "1hmZVqQvs748sJc96QatuwF9f8CYeI0jGCtn3Uh9z+VyUXeGmDIYP0AB8ge3J64xlynEaaUl7N2F\n", + "xdi7XGI9s6c9xsxjFmFX+NsNe97Pals9Wyd1M3hHnW2Q1svEuxXGIKZWPs2pJqevsHpSRQfVlDIa\n", + "Wb4xBxdZz8f9s1xOL4GiLFfGJjdJlmLeBBCymn+eplFm3YuNml7XmSaumwI2bz6H6Xh43IGDniwX\n", + "ltOKH0PL5XKxHrHEsFDoJzQtQsozCRC4WGBUfETIuNI7PDxUu93WZDKJVMydnR31+/2ImyAqHoVB\n", + "lL+7GZ+enuJ8mvl8rm63G25OrCVSKBlnCrsdHh6GYELwLpfPgbSUt2aOUP4If2mVxlgoPJcTh93x\n", + "eizOjiG8YUYADSgoQI1n6cCccP4HLMty+Vw9ExCHAmUPnJ2dhZLyNObJZLJWAyiXy8V3OIeF50yz\n", + "NVCeADpJEaPBWHgV3k8++WTNRbWt5q6c8XisVqsVGTweuIucxB2I0nTrmvFwA8hjrSSp2+3Ge5Ji\n", + "TCljj2vNg289jgWrHTnvQAP2Z39/P5g0ZwkADfSL9UWwa7vd1ps3b2J9AiDQHfyeNSCt5BX1der1\n", + "+hojAWjGYGDfkUmEnvOq5YwxDCZyBzlDBV5q5mAsAQAB+IBl1j2y3DPj+B5yDCOFNQ4D+fDwEMxq\n", + "vV5fS8VmDIil8RiezDX3v7qCf2ZzS4iFwyJPLX1HY5uYDoQKloyDFb+uRyg79eXg4yUg4e+7snUA\n", + "kirnVKikDI5b05uAht/H2Q+/p7NLKaBI3TJcK32mFHS4Ukj/9nv6WKRuIxfgjDnuN2ennFlKI8bT\n", + "Z0sb8/sSRfhLNVKDl8ulTk5OIsuF01yXy2X47vnuzs7Omi+ZeYWCXi6fT/OsVCpBhUvPTAHpgq1W\n", + "KwA8qcRck+A5XE4oU0/hhomBPgcIEKToaxZKGmHkYJ/r+lkkzmTQAEWwTAi6fr8fghlqXVrNMeuf\n", + "eANeu08fEMffDw8POj09VaHwXDDMLe9+v698Ph/z46npnmGD779YLIZ1fXt7G8IfC90L4j09PcX7\n", + "WL8on1wut+ayIn6BGBgYgX6//1HEnJB2TtExrG4HA5wbhQVfKpWCYcLiBhzAXuCCgSGDWfnxxx8l\n", + "KdJmHx8fY23A8mG4IMMBGswf4+3uBcAPgah+QCBz6udUSSt3hvScHUcc1Wg0itfu/gBosl48nmw+\n", + "n+v4+FjD4TCYjWKxGOX5YafcZeiBtZ5qn8vl1kAzz0Z/ACH8TlIYTV5iA0bFgSLvM/e+L/gtHgnk\n", + "N6wfhR/ZkzA+/AZg6s+V1baWrUNzP5srMGc0UvbBGRQmAgHPJk6DT5kIBitVtJI+uDdUHL9P2QpX\n", + "JA5EssCAN79+Cgb4P1W07qvz370EZvg7BRlZjetmATLeTzNm6AfzkMac8L9fE+WRgke/Xhrz4iDH\n", + "7+Eg7aee75dquGVgDs7OzjQYDGLzkx1DWiJBd8PhMKwNrJz5fB6xEIvFQtfX1yG0GQeEEkAH2tTn\n", + "xil4fPsIUKx1qF5OFiYWAncR/u9cbpWBg58bxcp9AFP0kd+j/H09Eo9AITKAAGm1uVwuMiuYX0/r\n", + "T/ekgxQ+29nZ0XA4XEt/JnaAOg24lKQVEKJ+htd7aLfba0fcf/bZZ+G3x0XEPFCKHaFOfBGuJ/r6\n", + "/v37CMSsVqs6OTmJQE9Sc7ddhI2A0Lu7Ox0dHenq6ipOA6YUe6/XizXi2Uh+2JzLBVwjHhyK24R1\n", + "hysBmc9rP4IgNVRTgwi5AVPO/AAYyQZCFmXJF+YKhvL+/j7AGcwKlXwdWFA75+HhIcA2fzebzTBS\n", + "YD9IPwYMejyKr/Xl8jl+6vj4OM7+kVbsN3FvPC9yGMOEa7ZarQBGHu/FuFLbhfguZ7WRE4AXdDUg\n", + "RVoFTLOnXFf81HlRW8vWcWsY5eSxFY5E0996EBwPDHp2IcX3+U0KBrLYAulDhsHZD+9TChLS5/D4\n", + "DPrpit37t6ltYosAW95PR/DOmKTXyWqwTk5p8n2eAYbKr+mAwp89C8il7EYW0PIYnZ8aDxr9+xjA\n", + "iWddoHio0FgoFNYOOcPtsru7GyWn/bTixWKhwWCgwWCwxl543Q6sb66PYPCsKwJEocQXi0UcVIZV\n", + "iiIlkI/vEMCIAQGzgtDEIkqLHfIdLESEmbRiwjAqsHrz+byazeaav19a+bxRIIC2LOPB3WduXVar\n", + "1TigjmsOh0PlcquTtzncLZ9/Ls3ebrdjfBHUrVYrFCjZQdyb+AOuT+EwytWnqdPSs1X+5Zdfxu+4\n", + "brFYjBRn5nybDWANqD4+Po60dWIwCKYkboffeQwKTGIu95ytxfrB8nYA7ewX4ABWgXF0d7K7X1D+\n", + "1CFxtxTzQHo7MWGNRkO1Wi3WA6DdS9ATCE7NFGJbeCae1dk3+uSGA/EruEyIP4PFRJbTd1fqPHOj\n", + "0VCn04lzoVibjB+yvFarBeuEnK9Wq5pMJlFN2TNnYDYkhSsOo/L+/j7cZ8wFz89cOpDyjCBneLje\n", + "S4zg1tw6CA4HEbyPUk8VkTMKDgRSl0oW6+DXTpWk/85dLH7frGfwZ+G1AwN3cfjvHJh4SxmTlPUg\n", + "0MrdIj5G/pzpNfxeKR3K93wD8x5CgeYpgmnfHYCkzFQWWPG+p39vcuP8FJjcdsMK6vf7kQmAlUDt\n", + "ABQNUf2eaocAl56FBMoxBbesK1wPUMa8pqIq/l1YBizIRqOhwWAQ1CruDoQUKdEUasOg8NRDt1K9\n", + "SN5yuYx6LIAeZ994Bn4rrRgkzisBDOEGgbImawn2hH75tTillt/c39+r2+2qXq+H6ymfz4cwR5mg\n", + "SFjz5XI5DocrFotqt9sajUaqVqs6Pj7WcrlUv9+P8a3X6yGkPXsCgMYc+pEDXKPT6YSV7ZYpv3uJ\n", + "/v4lGrJhPn8u0e9W/9nZ2RqT4NY+INeroXrqPGvC63Z4wTZnWlGIHjuIvHalDQsAkGJ9AmaQLaz1\n", + "5XJ16jPuEGS41xshoBe2P5fLrWWBejgBwGY6nWo+n+vk5ESTyUT1el2j0Shcgyh7AtUBTAAW2EMv\n", + "4Y98KBaLajaburm50fn5+VosCvoRo8VdNhgrBNYyVgAvWD1YRsbOSx8g173AG1lJqV5hTny8/bON\n", + "a+5/ae3+jxodoqOgY6yolyxhV7QsSqeM3JriO6BQvzcD48qXhY6wywIqm9gWWrpZfqo548H10zgO\n", + "n0T6lvbBn+ElZe1WRlb/WMg8twcN+xi7a8ybsyHuF5YUwWObruNrIWV9sp4hZcE+hkZAJ6yAB+7h\n", + "XsDC5JmdYfNCR9DXgA2CMKXneep2uwECcDMwf9DI+MYp3EQdBAI1UQR8lz0oKRgKFAtgqFAoRF8Q\n", + "SlDfMBewQghMF1wONsiawIXi1D1KbrlcrlXrRBhK64HVBEdKq+BAB0Kz2Swsxf39fTWbzRgPWCdc\n", + "KChEAlLv7u50cXERgpx4nEajoXa7HQATBU0ALm4Zd/WgINyNhBLhux7UuO1gWBrujJ2d52J+9Xo9\n", + "1mlqOLH33W2PnPOgaOYPNwQFxFiX7qLzOCNcQLjYiFnxfQRw93omHjuBjGbNHR4eajweS1oFLqOU\n", + "naFfLp/T3DE4nDWXVqwj7KjLtUKhEDVZWAMYAs4+k3EDK0l/KUro8nMymcSeRxawRpfLZRyWiAwA\n", + "JPJ99iUxQwTtHh0dBTsE4wXoB0jDliA3nG1nHQNy3BD9OXFUW8vWSRed/4/iSRVQqkxZKM6+AAy8\n", + "pdZ/VsuiiPl70yCm13Sr3wGT38Of2Tcw10uZFq7LMzhIyWImuM5LLp0UoPhnWKr+fK5I0+ulTEgK\n", + "rFDSCGTeS4sJcd2UMXFryIGLA6ZNjNk2Wq/XW2O2UEgwENStALQBRhCazmBxwBifQxmzdk5OTuJ7\n", + "7AEUHkKLM3Tm87mOjo6iCJWXxnYBjFsHwPT4+BjxGg8PD2q1WmsBh7gzyJaoVqtrdTnu7u7Cp43A\n", + "hb0gEM/ZFFxCs9kslJOnetJP4kQIGkawTyYT/f73v9cPP/wQSow9hZAvFouq1+u6vb1Vu93W7u7u\n", + "WqAxwl+Srq6uVCqVVKlUdHl5KUnhbjs5OdH+/r7evHkTIMfL/hPUiuJDmJN1wZziwoLmLxQKQcEP\n", + "h8Ngd7bZvMgce/Dp6UkHBwehHFlLgErWHd8FOOMKkRSH8rnimkwmobxgIJhfDmj0wxy5HjIFAIjC\n", + "BAzzPfoGWIf1GQwGIWM5+RtgTUwjawPXBsXaWF/EbC0Wi7Vqube3txEXwvOVSqUwWtwgZE17Zl6t\n", + "VtOf//xn/fM///NaNeFcLqfPP/9c7XZb5+fnMd6Hh4fqdrtxWOjnn38ewdWwg5QCIPYHME2to8vL\n", + "y2AYiT2BGfYwCcAdTAqynjk/ODiIU6YxNnZ2diLAelPb6qnEtCzl5/9L6wBhkzJKYxj4TpblneUa\n", + "8H6gbLNYFwdE6XX5rVuR3j+UtYMUaf3QQwdnfo20ZkrWOG1yl6TNGZI0IJVN71aFWxlZY+h/O8DC\n", + "opa0ViMhC0ikNF8KPpzt4l5pHMO2G8Iml8sFQ8IYYEGgJBG+7trweBEsLNaSp5i6tUN6LPPmcS8e\n", + "JDscDlWr1bS7uxspiqw7ikQVCoVw95AGncvlAuSkwITfE3w3GAzU7XbDUj47O9OrV6/07t27YHBQ\n", + "Fh7Y6lajjxFKJ5fLheLGmnSFzm+Ojo70/ffffwD6+R/XTrfbjbNvCoXneidYhC5r3rx5o/v7ew0G\n", + "A5VKJZVKJXU6HX366acaj8d6+/ZtxLQQi4DlS6Ay92csOWsHFgHQVq1WQ1HPZjP1ej198sknkYm1\n", + "zYZsfHp6CmXMmKcup8ViETVf/ERaruPGBkGfXAOWke+5oZTLrbJTkEUO5mEGiH9h70haS0vf2dmJ\n", + "tHKKs0mrUgmz2UzHx8fBOEgK5o+znUjxf3x8DPbSi6DBRsIgIJs4gwfXln8OaCI+DEAIW1KpVAJw\n", + "YESUSqUoFog7i2DqV69eqd/vRyl91iVz51lKrpPG47EKhULIClytHk8DaCNry3UlZQf8qAr2Li4j\n", + "YrGQJ1ltK+AkK+7DLe9UmWaxAKkyZBFmgQ7uKX2Ydst7/n8KnJxRcfbCrfn0d/7dtG+u+P2+WNz+\n", + "/RQEpQwFr3k+rIV0fLwx9vh1vQ+MlbNbXrUwZU1S3yKbzClePnMLPQU3jqi9j1lAMp3HFJBtsx0d\n", + "HWk8HmswGITCdqHg6w7Wg/GhUiYC9OnpKYSB09x7e3sRLzEcDiNldzQaqVKpRC0T9+mjCFG0lUpF\n", + "j4+PkQo7Ho8D1FSrVdVqNZ2dnQWFjyXocyophBBWEC4ghGe73dZf//pXXVxc6Msvv9RisYgDz7D+\n", + "oMBZgzANWHEECRP/QcMq9do73333nY6OjiQpDv1zS53rN5tN3d3d6eTkRJeXl5GBBLVNBsTNzU24\n", + "XCaTibrdbox3qVQKN950OtW3336r169fx5hTeK9QeM4MIYC02Wzq7OwshPZwOAxlDnja29vT73//\n", + "+yi2BVjbVgOIeDwMY+4ucNxjACxcKq68WNvuKuHvarUa7gP2ByySZ/nhpvHD8nBTEKcBIwIIhj3x\n", + "Gh2sO+aYf6RzM8/OuuDS8ZgmSQH6fbxINfbzcCRFsC5MJowa+8zl2tPTcyXj6+trDYfDqNHDs0uK\n", + "DC/W2/v37yOQ3c8kIr4M9olaJ9PpNOKoCJAfjUY6PT2NoorVajX0kdc9caa3VqutBcvyTMwba5tr\n", + "eJp22rYCTlKa3xVsVpDoJqXjIMVBhLQOaNx6BxQ4LeX+u9Rd4BZilgvBWQxX8B67wqbyw5Q84Dd1\n", + "J2UxNamLxccMheHtpdgT/I1c29kIZ48YQ4+udjDibhbQONd3PzrXg4KV1ovscQ2fM5/PFJBuYkg+\n", + "BnDS6/XCioaNcJ8rQph4Dg/ckxSvsQTxgTM+BLrOZjPV63XV63VdXV1FiifpuMRJEMSHAPQKrtIq\n", + "ELVSqQSAQshDaxP0JyliTVLgWq/Xw7pE4RwcHKher6vRaGg0Gumvf/1rHCdPaiL7CuAD2wPgefv2\n", + "7VrMCowSgcO+NnBd4c6iSBgKBcVVrVY1nU5DaOOeQaGR8nt/f683b95oNBrp6elJvV5PhUJB4/E4\n", + "qPJOpxNj9Omnn0atDVwzuHdS9x3P0u12Va1WQ8AjE+/v73V9fR2gctvZOoeHh+Gy5EgF9rC0OoDR\n", + "DSVpxQjjXkFJA3B2d3cjBkhSuPsA6ovFcw2fXq8XMUH5/HN1WeSpx+DBWHAGD/dmfPleuVxWr9cL\n", + "1xsxFcQtwQgQFE0GjPcdNwgKHtnJ3BLU2u12Y33xTNSD2dvbU6lUisJl8/l8rToxcrXT6ejo6CjO\n", + "H2ItMZ6j0UjHx8cBPur1ui4vL6O+j8e7nZ+fx2GhBOQ703V+fq52u629vT1dXV2pXq+vMVboacax\n", + "0+lEgC/PhPwH3HmsD2Powc1ZbWs8OANGJ1HYTtdlWcbOBmQpb67t10FIMNn8HmXBAvB/ruydyXBw\n", + "k7o6UpDiAMcngb+dqXF/XKqsX+qLK35Xzi8BEw7mInCLDIPFYhF0o48/izIN1iTYy5+dZ8ByT8EE\n", + "8+3X8YBQd004NZ8FTHh2B3cfQ/OUSihwrHFfC6PRKPzADr6wcDgYz4NLAYrlclmDwUC3t7c6OzvT\n", + "n/70p/ju7e1tlLQHbLhf/+npKep7IHQXi0WcRZLP59XpdMLXTroshZlarZZarZZ+85vf6Kuvvopq\n", + "maPRKGjx2Wymq6uroJwBDAAyZ/d4Pmjsg4MDNRqNteDfQqEQTIVboG4wTCYT/fjjj8rlnl0nw+Ew\n", + "hPrFxYUkRQbT4eGhzs7O9P79e3377bcBAPr9vqRVTZL/+I//CN95rVYLmfX5558H68VaPjg40Bdf\n", + "fKHf/e53uri40NnZWSjw2Wym9+/f6+bmRt9//30E4ZLRdX19HbVWcHdgFQMMt90I1iX+AorejRNn\n", + "irCK2cueKeUxKVTVxdKeTCY6OjqKa/7444+6uLiI2kFY5s4w4jJjHj1biv56HCCFEXERSgogT5+l\n", + "Z4aD+Ke7u7tIdYcRefv2rY6Pj6OEPXPHeOHKBATxOQBcUmTqeFq165G3b98ql8vFsRKMYaPR0HQ6\n", + "1XQ61W9+8xstFgtVKpUANhcXF+p2uyFDOYOo3++vudGkZ7kLY+W6kdL2zDdsO2wSbEmn09HT01P8\n", + "3gvmET/j7BGuXN/LadsKc8LgwhI4kyF9mJYqfRgMK61b/XyH67pVz2/9tVv6fi2aU/BZwa300/vN\n", + "e/4cXhjOn8mZGpRGCsx4rrRvrqjpVxovs8kd4jEv6XP461Tx81tnmWBIfEN5vrz7MRFU6cZzMEJD\n", + "WfvvU7eS9x8q8mMAJ/1+P9wSrVYrzt8gMBMhvVyul3KHlfJzeTz1bnd3V69fv9a7d+8ivbHRaCiX\n", + "y4XCI5J+MBjo4OBA+/v7kVUBhYy7wdcY1iL+9cfHR7169SrcL4+PjwEKYDRms1lkTsAOMIdQ3vyT\n", + "pC+++EK9Xi/YNAQejAZKBGZjMBiEUnMWkNoh9N3X+unpqf7xH/9Rf/nLX0Lh5fN59fv9YCg+/fTT\n", + "OHSRM1twnR0cHKhSqYTVPRqNwn1GX87Pz+OZ8MMfHByo1+uFUH779m3EC2EF39zcxLx9+eWX6nQ6\n", + "YZWyfofDYViv1BSBweGe22wAWlfw7H9iJCStzbu0XpSSNePZHZ6BtVgsQtFjYR8cHOj6+nqtjIHH\n", + "mQCaYFIA2/l8PpSfByJLK6UMI4ALSFply8xmM3U6ndiTXq2ZPsDUcQ8qJj88PB+0ScAswbLj8Vj3\n", + "9/dxDZhIDAFYT3ednZ2dqd1uq9lsBqNUqVTimAqP/bm8vNTR0VGwIrBOvIdby41swC9Gw2g0iirR\n", + "uNVcxzw9PQWI9/pInIPkxlej0Yj78Jywj8zXprYV5gRKlsnG7eJgwpVk6m7xQD4EEA/N4nVWw906\n", + "0oq54PceMCd9eGZOmu3D7/htGoeSgiC/b8rKpIrd36Nxf/8/C3hgtbiPL6s5WwGC5fspG7XJtYSw\n", + "Tt1NMCxc1+fTx8/nweeGuAqeFWoQJUSgJtaGuxheWui/VGs0Gnr9+nX4wweDQXzGeCKgsaAAIxRc\n", + "g+YGoBA09+c//zmCSbGAfvjhh0g1Zu5JYSRmBaq8UHiuQAvzUa1Wg+2YsFi22wAADWlJREFUTqca\n", + "jUbqdru6v7/X+/fv1ev14gyYq6srdbtd9fv9oLMlBQWOi4U5gCXis36/r6en5zN8EIaTySQoYGqb\n", + "0DzgD5eKp0f63mdtjUYj/eu//qsKhUIAEtYLFvl//dd/RezE8fFxKH+Yi1/96leRXYCV7qmo7XZb\n", + "3377rTqdjhaLhcbjsa6ursKydBcQMT29Xk9fffVVgM93796p0+moUHg+4RiL9/j4WL/97W/1pz/9\n", + "Sa1WS+fn58EGVCqVX2T9vtS80qikqGPjChUlCShg78IKAGSJayBWCtnBKdsYraenp+p2u3GWEi49\n", + "gi6x7mHscGfSl2q1GvLm4eEhWGHqhgDUAdcwPtwP0AMrub+/r5ubmxiTu7u7AAnIfACcMzruOiHm\n", + "A7fi3t6e3r9/v1b7xWXew8ODLi4uAtTQb+5RrVZDhpAJyDEKBIkTmFooFIIxRXeRNbS3t6fhcBhh\n", + "CG5ISCsjHYaT6rLz+TyK8h0eHmo2m0XW0mAwiGBz9AxxJx9lhVi3zKVVFTnpw+DUTZS9MyQpFeaM\n", + "Qvrbl6zrrDgNp23dFZMKRmdiUus+VfDeP6xjty5YmMTl8Gz8QwGkFfZApi81V+ZZAMb77KDQWR7G\n", + "OWVbUsBIywJLPm9cw/uV3tvfp39Z7227Ufthd3c3UoclBQPBZ71eT5LCYsrlclG6HgFaLpcjFTeX\n", + "y+n169fa39/XZDJRr9fTfD7X6elpVOiEyWKs/QTS09PTAAfEddzf36vZbIbVCM0Ne+FxApSX393d\n", + "jb+hwWFTiAOAHeJZvXR9pVKJyqCk0GJBISjJoEBIk/rrtD1z7UC92Wzqm2++Ub1ej4yG6+vrKKB1\n", + "eHioi4uLqJJLHIefZfMv//Iv+uMf/6hqtao//vGPury81O3trY6Pj6NIG4qFsZzP5xFrQ0zE7e2t\n", + "ptOp+v2+Wq2W3r17F0phMBjoV7/6lRaLhU5PTzWfz9VsNiPgcTabxanVpHW+lNXwSzRfCyhGGDkP\n", + "ZoeFICbCrWZiDPxMG2JYUK65XC6YM9Z6tVoNQCEpXIAEzRLbRRCzr5t+v69KpRKsBHFHFEr0gwM9\n", + "xdtdant7e3GIXj7/XFARUFutVgNk4eKCrUQu+fpZLJ6L+1G8j/TltL4Q7Goul9P79+/12WefRVow\n", + "z0BtFFL1cZUtl88l+bne3t6e3r59q4uLC7VaLV1eXkbRNggCmD5pVWPGSQJJwfDiqvHxA7jc3Nyo\n", + "XC6HO5tn8Zon6C3A5Ka2FXDi6ZNMgFvgmwJbXaG628PjFVIAkbZNjEIamOMLRVov+OYUV+qC2hTg\n", + "432C+oMuywJSLAQWT/rsLAgUkt8ndev46zQQlbHPcofR3K3Ftdi86fy5cnTwkZV1lILB1DUF4Evj\n", + "bAAsCIO03P42G1aUpFCKT09PoUQRsKenp8ECuD8WxqFWq+nm5kaVSkWlUilcEWSfIHyI2O92u0Hx\n", + "Ytl4ZkSn09Hr168j/gWLsl6vR+VTBLRXpnSL99NPP9XXX38dwj6fX52PQiT/eDyO4nD7+/uhyNk7\n", + "xNFMJhN9+umnEYfgRdY8HsOVEJYj5bax0HnObrerP/3pT+Fa29nZ0fn5eVTwvL+/V6fTUaVSWStY\n", + "12g01O/3Va/X9dVXX8UcYOFyCrFnrXlmBcIXt9rt7a3q9bomk4larVYoDdjixWKhXq8XVvWrV6/i\n", + "mVAsxMWwZrrd7tbWtLQ68wVGgrmRFFa2pKgxgkzCzSIp3BiAbsAL9UBcxrIfxuNxVEmGxaAWEwpU\n", + "UoBC9hQn5Z6cnES2WS73nCZLphouV0AzbjT6y29wb1IBuNls6ttvv430+sfHR71//z4y9WC8GCti\n", + "cAB0gKSHhwcdHx+H0k5dH7Crr1+/1mg00sHBQZSdpz4ILKYXg0MWIxOurq6igCCxIP1+X9VqVf1+\n", + "X+Vyee0cH68l49eFQYRZcQAHI8O65VTp4+Pj6AcpzsTLHR0d6fr6euOa2wo4cWbALWRJHwCTLPbB\n", + "FbLTjJ5RwwZJGQAHAmm8iLtiUjeBMwNpbItfA2Xgv3Ol72NAcJQzJ/6cAJAUfEirA57obxpM68+N\n", + "EseqRXk6IOTaXkCM/noKn7uN/He8lz5nyibx/fR5s+aZ7/m8YKGgHF0QfgzghAP4cK84W4JVKK3O\n", + "rECY4uJxVowsGQIEPf0WAUVWEAF6i8UiWA9Ja/e/ublRqVRaYzzI5EHxelYPcRdv374NVxCR/Chn\n", + "r34qPR98+Ic//EGFQkHff/+97u7u1G63w8J6fHzU8fFxpNyizKi4ijXtacOdTidSJXHpQcGfnJyE\n", + "P75YLOry8jLie7gmbq5erxeWLe6mYrEYfcFaB0y12+1gL/Grt9ttffLJJ/EsuVxOx8fHkp73xr//\n", + "+7/r/Px8jRFjHlAkJycnAXZms5n+z//5P9rZ2VG/31cu91wS/Xe/+52Gw6G+++47lUol/fa3v/1l\n", + "FvCGhiyBoveyALhy2ZMEyuKuIw3XwbKf3IzCZf0SQ/H4+BhxPShygCfxSpzwS00RScGAPDw8BPAh\n", + "rklaxUIAvKlSzN7EpdTv99VsNiN+YzKZRDGxcrkc1xyPx2q1WgHW5/PnQnC3t7dhfIzHYz09PUUK\n", + "OewDWTycrQTr9vDwoM8++0zfffedarVaGBMpkEHmjkajuAbjQNwIGTXHx8fBXj0+PqrdbqvVaqnd\n", + "bqter6vX6wUAy+efT+qm0ByB7GQuSc8kA/Ep6DBcRLjGOp1OABp0C0zv9fW1Wq3WxjW3tYBYaaUU\n", + "WQy8RkE58EibB2O6i4j//Tog9JRtcSYCpYqC5n3/nMWIsqehnL1YlIMgSWufp0yI99vZF5Svu3/8\n", + "u84s0CevnAiwQUg6COS5UpDg93A3C699Q3g/nd1wYOMti0lJmTKfo/Q56QuWhYM67/s2mxcNKxSe\n", + "T/2EhaCeAIGqOzs7QQ/DMmDJSSsQR0YN1gen1+Jnr1QqYT2NRiNJq7gurBssc9wXgChX3jAmrNX7\n", + "+3udnZ3p/Pw8zn85ODhQq9WKYmOklxLV//j4+H/bu5ue1LUoDMDvFTgqWFMkCEIwAXVi/P9Dh/4I\n", + "YqiJaEqjhWoVP1J7BifvctN7z/S6B+8zMTEqUNu9115rf+Dq6srKFWVZYjQabax+mM1m1kkxc1KW\n", + "pS2p5cTEVqtlO4hGUWSTFFlX5zVI09TmCARBgDzP7fnmCJAd1tfX10aa/uTkBNPpFLVazZZis2yR\n", + "5zm63S6GwyHiOLZM0/HxMZIkAQDEcYzVaoU8z1Gv13FxcWGBCBtvNso8ZPHm5gZ5nuPw8BDNZhOT\n", + "yQQAMB6PrTFfLpdI0xSDwQDb29v/2uPl/8bMFu9rlm3YTjCY5QRPPgPsiHivMhhlW8XSAveX4fPM\n", + "ElG9XsfDwwPOzs4se+Q+829vb9ah8vX5/2WwzeDFfYbSNMXe3h7CMMR8Psf+/j6SJLFdVtmOMRAr\n", + "isLue95HRVHYEngeHMh7lJu1MUhmWxzHMXZ2duz1mVXjnBVmjhgcu2VeTrTn5+Z9zdVILy8vNieH\n", + "g471em2bnTEw6HQ6GweSdrtdCzr4laWp5XKJwWBgc6QYJHFwxLYoTVPMZjOcn5/j+fnZ2nVm/5gt\n", + "zfPcdqvlBnJ/86OnSXHU687cdoMNtyNzsyBu4OGO8quBDP++W4JxV5fw9/l9t9ThcrMQ7ByrnTw7\n", + "SzewYWdZ7XyrWYIqN+gCNiebVssg7nt0rx8/t3sNq+UaVzWoqAZs7s9Ur4v7XqrZE14XBojV12dq\n", + "1v271WyTG6Qx6OJruV99CE6YIfj4+LDDvjhSAb63Pg/D0HYK5ZJDjhIB2Kiv2Wyi0+nYrq08iTQI\n", + "AmRZhjAMbT4IJ1YyK8Dab1EU9j5YvgG+Z9qz7MFOhUE4/2+slXMZJScsukuD2aE3Gg30+31kWWaT\n", + "dFmmKYoCcRyj3W7bKO3u7s5q54vFAo3Gn8PMtra2EEURgO8SJ1dAMbOSZRmSJMFyucTR0RHKskQc\n", + "xzZ/jW0FU+gsD7y/v2OxWNiW5aPRCFEU4devPycEJ0mCwWCAy8tLALBSQL1eR7vdxnQ6xWq1Qq/X\n", + "w+npqa3E6ff7uL6+xnA4tH0mmPpvtVq4vb3FZDJBu90GANuwi/uZcE5LrVazn+H15qFvP4VbnvOz\n", + "cGUR2wTOdeA2/rwX+Bn5DLME4GYBWBbic+IGLNyXZz6f22ohzm1ie8jyEjtkZlYY1PF7LK8wU8Hs\n", + "DOdBuFkaljFZVuPnYhmZmbMgCGxSLU8qZtnIDeA4x6LX61l5lgNR7jDLVUYciLJcyu9z1Q8DRban\n", + "HARwPhcACwhZvmIWpt/v2yq0x8dHHBwc4P7+Hru7u7ZUmXufrNdrdDodO/n46enJBjd85jnp+PPz\n", + "E+Px2PaKeX193TgLrNFoWNvIoNTdb+m//PO3DlJERETkJ/z8YSQiIiIiDgUnIiIi4hUFJyIiIuIV\n", + "BSciIiLiFQUnIiIi4hUFJyIiIuIVBSciIiLiFQUnIiIi4hUFJyIiIuIVBSciIiLiFQUnIiIi4hUF\n", + "JyIiIuIVBSciIiLiFQUnIiIi4hUFJyIiIuIVBSciIiLiFQUnIiIi4hUFJyIiIuIVBSciIiLiFQUn\n", + "IiIi4pXfPRZNtgyLF3IAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "fc6 weights are (4096, 9216) dimensional and biases are (4096,) dimensional\n", - "fc7 weights are (4096, 4096) dimensional and biases are (4096,) dimensional\n", - "fc8 weights are (1000, 4096) dimensional and biases are (1000,) dimensional\n" - ] - } - ], - "prompt_number": 7 - }, + "output_type": "display_data" + } + ], + "source": [ + "ksize = net.params['conv'][0].data.shape[2:]\n", + "# make Gaussian blur\n", + "sigma = 1.\n", + "y, x = np.mgrid[-ksize[0]//2 + 1:ksize[0]//2 + 1, -ksize[1]//2 + 1:ksize[1]//2 + 1]\n", + "g = np.exp(-((x**2 + y**2)/(2.0*sigma**2)))\n", + "gaussian = (g / g.sum()).astype(np.float32)\n", + "net.params['conv'][0].data[0] = gaussian\n", + "# make Sobel operator for edge detection\n", + "net.params['conv'][0].data[1:] = 0.\n", + "sobel = np.array((-1, -2, -1, 0, 0, 0, 1, 2, 1), dtype=np.float32).reshape((3,3))\n", + "net.params['conv'][0].data[1, 0, 1:-1, 1:-1] = sobel # horizontal\n", + "net.params['conv'][0].data[2, 0, 1:-1, 1:-1] = sobel.T # vertical\n", + "show_filters(net)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With net surgery, parameters can be transplanted across nets, regularized by custom per-parameter operations, and transformed according to your schemes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Casting a Classifier into a Fully Convolutional Network\n", + "\n", + "Let's take the standard Caffe Reference ImageNet model \"CaffeNet\" and transform it into a fully convolutional net for efficient, dense inference on large inputs. This model generates a classification map that covers a given input size instead of a single classification. In particular a 8 $\\times$ 8 classification map on a 451 $\\times$ 451 input gives 64x the output in only 3x the time. The computation exploits a natural efficiency of convolutional network (convnet) structure by amortizing the computation of overlapping receptive fields.\n", + "\n", + "To do so we translate the `InnerProduct` matrix multiplication layers of CaffeNet into `Convolutional` layers. This is the only change: the other layer types are agnostic to spatial size. Convolution is translation-invariant, activations are elementwise operations, and so on. The `fc6` inner product when carried out as convolution by `fc6-conv` turns into a 6 \\times 6 filter with stride 1 on `pool5`. Back in image space this gives a classification for each 227 $\\times$ 227 box with stride 32 in pixels. Remember the equation for output map / receptive field size, output = (input - kernel_size) / stride + 1, and work out the indexing details for a clear understanding." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Consider the shapes of the inner product parameters. The weight dimensions are the output and input sizes while the bias dimension is the output size." + "name": "stdout", + "output_type": "stream", + "text": [ + "diff: imagenet/bvlc_caffenet_full_conv.prototxt: No such file or directory\r\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "# Load the fully convolutional network to transplant the parameters.\n", - "net_full_conv = caffe.Net('net_surgery/bvlc_caffenet_full_conv.prototxt', \n", - " '../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel',\n", - " caffe.TEST)\n", - "params_full_conv = ['fc6-conv', 'fc7-conv', 'fc8-conv']\n", - "# conv_params = {name: (weights, biases)}\n", - "conv_params = {pr: (net_full_conv.params[pr][0].data, net_full_conv.params[pr][1].data) for pr in params_full_conv}\n", - "\n", - "for conv in params_full_conv:\n", - " print '{} weights are {} dimensional and biases are {} dimensional'.format(conv, conv_params[conv][0].shape, conv_params[conv][1].shape)" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "fc6-conv weights are (4096, 256, 6, 6) dimensional and biases are (4096,) dimensional\n", - "fc7-conv weights are (4096, 4096, 1, 1) dimensional and biases are (4096,) dimensional\n", - "fc8-conv weights are (1000, 4096, 1, 1) dimensional and biases are (1000,) dimensional\n" - ] - } - ], - "prompt_number": 8 - }, + } + ], + "source": [ + "!diff imagenet/bvlc_caffenet_full_conv.prototxt ../models/bvlc_reference_caffenet/deploy.prototxt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The only differences needed in the architecture are to change the fully connected classifier inner product layers into convolutional layers with the right filter size -- 6 x 6, since the reference model classifiers take the 36 elements of `pool5` as input -- and stride 1 for dense classification. Note that the layers are renamed so that Caffe does not try to blindly load the old parameters when it maps layer names to the pretrained model." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The convolution weights are arranged in output $\\times$ input $\\times$ height $\\times$ width dimensions. To map the inner product weights to convolution filters, we could roll the flat inner product vectors into channel $\\times$ height $\\times$ width filter matrices, but actually these are identical in memory (as row major arrays) so we can assign them directly.\n", - "\n", - "The biases are identical to those of the inner product.\n", - "\n", - "Let's transplant!" + "name": "stdout", + "output_type": "stream", + "text": [ + "fc6 weights are (4096, 9216) dimensional and biases are (4096,) dimensional\n", + "fc7 weights are (4096, 4096) dimensional and biases are (4096,) dimensional\n", + "fc8 weights are (1000, 4096) dimensional and biases are (1000,) dimensional\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "for pr, pr_conv in zip(params, params_full_conv):\n", - " conv_params[pr_conv][0].flat = fc_params[pr][0].flat # flat unrolls the arrays\n", - " conv_params[pr_conv][1][...] = fc_params[pr][1]" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 9 - }, + } + ], + "source": [ + "# Make sure that caffe is on the python path:\n", + "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", + "import sys\n", + "sys.path.insert(0, caffe_root + 'python')\n", + "\n", + "import caffe\n", + "\n", + "# Load the original network and extract the fully connected layers' parameters.\n", + "net = caffe.Net('../models/bvlc_reference_caffenet/deploy.prototxt', \n", + " '../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel', \n", + " caffe.TEST)\n", + "params = ['fc6', 'fc7', 'fc8']\n", + "# fc_params = {name: (weights, biases)}\n", + "fc_params = {pr: (net.params[pr][0].data, net.params[pr][1].data) for pr in params}\n", + "\n", + "for fc in params:\n", + " print '{} weights are {} dimensional and biases are {} dimensional'.format(fc, fc_params[fc][0].shape, fc_params[fc][1].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Consider the shapes of the inner product parameters. The weight dimensions are the output and input sizes while the bias dimension is the output size." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, save the new model weights." + "name": "stdout", + "output_type": "stream", + "text": [ + "fc6-conv weights are (4096, 256, 6, 6) dimensional and biases are (4096,) dimensional\n", + "fc7-conv weights are (4096, 4096, 1, 1) dimensional and biases are (4096,) dimensional\n", + "fc8-conv weights are (1000, 4096, 1, 1) dimensional and biases are (1000,) dimensional\n" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "net_full_conv.save('net_surgery/bvlc_caffenet_full_conv.caffemodel')" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 10 - }, + } + ], + "source": [ + "# Load the fully convolutional network to transplant the parameters.\n", + "net_full_conv = caffe.Net('net_surgery/bvlc_caffenet_full_conv.prototxt', \n", + " '../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel',\n", + " caffe.TEST)\n", + "params_full_conv = ['fc6-conv', 'fc7-conv', 'fc8-conv']\n", + "# conv_params = {name: (weights, biases)}\n", + "conv_params = {pr: (net_full_conv.params[pr][0].data, net_full_conv.params[pr][1].data) for pr in params_full_conv}\n", + "\n", + "for conv in params_full_conv:\n", + " print '{} weights are {} dimensional and biases are {} dimensional'.format(conv, conv_params[conv][0].shape, conv_params[conv][1].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The convolution weights are arranged in output $\\times$ input $\\times$ height $\\times$ width dimensions. To map the inner product weights to convolution filters, we could roll the flat inner product vectors into channel $\\times$ height $\\times$ width filter matrices, but actually these are identical in memory (as row major arrays) so we can assign them directly.\n", + "\n", + "The biases are identical to those of the inner product.\n", + "\n", + "Let's transplant!" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "for pr, pr_conv in zip(params, params_full_conv):\n", + " conv_params[pr_conv][0].flat = fc_params[pr][0].flat # flat unrolls the arrays\n", + " conv_params[pr_conv][1][...] = fc_params[pr][1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, save the new model weights." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "net_full_conv.save('net_surgery/bvlc_caffenet_full_conv.caffemodel')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To conclude, let's make a classification map from the example cat image and visualize the confidence of \"tiger cat\" as a probability heatmap. This gives an 8-by-8 prediction on overlapping regions of the 451 $\\times$ 451 input." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To conclude, let's make a classification map from the example cat image and visualize the confidence of \"tiger cat\" as a probability heatmap. This gives an 8-by-8 prediction on overlapping regions of the 451 $\\times$ 451 input." + "name": "stdout", + "output_type": "stream", + "text": [ + "[[282 282 281 281 281 281 277 282]\n", + " [281 283 283 281 281 281 281 282]\n", + " [283 283 283 283 283 283 287 282]\n", + " [283 283 283 281 283 283 283 259]\n", + " [283 283 283 283 283 283 283 259]\n", + " [283 283 283 283 283 283 259 259]\n", + " [283 283 283 283 259 259 259 277]\n", + " [335 335 283 259 263 263 263 277]]\n" ] }, { - "cell_type": "code", - "collapsed": true, - "input": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "\n", - "# load input and configure preprocessing\n", - "im = caffe.io.load_image('images/cat.jpg')\n", - "transformer = caffe.io.Transformer({'data': net_full_conv.blobs['data'].data.shape})\n", - "transformer.set_mean('data', np.load('../python/caffe/imagenet/ilsvrc_2012_mean.npy').mean(1).mean(1))\n", - "transformer.set_transpose('data', (2,0,1))\n", - "transformer.set_channel_swap('data', (2,1,0))\n", - "transformer.set_raw_scale('data', 255.0)\n", - "# make classification map by forward and print prediction indices at each location\n", - "out = net_full_conv.forward_all(data=np.asarray([transformer.preprocess('data', im)]))\n", - "print out['prob'][0].argmax(axis=0)\n", - "# show net input and confidence map (probability of the top prediction at each location)\n", - "plt.subplot(1, 2, 1)\n", - "plt.imshow(transformer.deprocess('data', net_full_conv.blobs['data'].data[0]))\n", - "plt.subplot(1, 2, 2)\n", - "plt.imshow(out['prob'][0,281])" - ], - "language": "python", + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "[[282 282 281 281 281 281 277 282]\n", - " [281 283 283 281 281 281 281 282]\n", - " [283 283 283 283 283 283 287 282]\n", - " [283 283 283 281 283 283 283 259]\n", - " [283 283 283 283 283 283 283 259]\n", - " [283 283 283 283 283 283 259 259]\n", - " [283 283 283 283 259 259 259 277]\n", - " [335 335 283 259 263 263 263 277]]\n" - ] - }, - { - "metadata": {}, - "output_type": "pyout", - "prompt_number": 11, - "text": [ - "" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAXMAAAC5CAYAAADavt/0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nA43ph1xlbAoPAAAAAElFTkSuQmCC\n", - "text": [ - "" - ] - } - ], - "prompt_number": 11 + "output_type": "execute_result" }, { - "cell_type": "markdown", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAXMAAAC5CAYAAADavt/0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvWnMbWl23/Vbz7T3PtM73aHGrqrurrbdbbttuulYVhqT\n", + "gcgycQwIGVlYFiCQhSCRAUu2IyHExxAhWSIKcsRoRSJBfLAi5AgMIU4CiWxIYqc73XZPRVXXcOu+\n", + "953OtPczLT48b7dN1O6qxHVz7e7z+/See/Z99nnPfe561l7Df4mqcuDAgQMHfn9jnvQHOHDgwIED\n", + "v3sOxvzAgQMHvgE4GPMDBw4c+AbgYMwPHDhw4BuAgzE/cODAgW8ADsb8wIEDB74BeCzGXES+X0Q+\n", + "KyKfE5Gfehz3OHDgwIEDv4W813XmImKB3wD+KPA68KvAj6jqZ97TGx04cODAga/yODzzTwCfV9VX\n", + "VDUBfwn4ocdwnwMHDhw4cMvjMObPAq/9ttdfvv2zAwcOHDjwmHgcxvygD3DgwIED/5Rxj2HN14Hn\n", + "f9vr52ne+VcRkYPBP/BYUVV5Evc97O0Dj5vfaW8/DmP+fwMvi8iLwBvAvwb8yD960dPf889gMO3Z\n", + "wCjGG7QX1IM4gxGhqiJiEFMINdMZIe935H3ECRgpqCkoiqpiUgUUjGCtRUSotVJrJidlt1NSugEs\n", + "xhi2byaWzw7YXlgOM+YLz2J2zKyb4Z1jHEfOLy94eH4BCMMM7GBx3qA2Y5zFONCijGOmZAUpCFBq\n", + "pVah1szqeGC2MtRJmR5Zbq4i41bJSTHGMF2NPPOtc3zvEWvJ2aLVUKtBFFQV1YK9/X1s8IgD64Qa\n", + "KkpGfaWkSiqFGoWyVXStCLC6f8S954/50Hc/z73nnmV5Z4Hzls1mw9tvvcErX3yDh2894pW//oDh\n", + "2TnbhxNmctSaMQiOijWK85XQO5wFJ+0zxpTJxdAd9/izwN17c/ysYK0jJxi3mcu3R3YXyngZmTax\n", + "rest4iriwBnLyQt3+MC3PM9v/p3P8x3/wrcwTYnz1895+PoFXgQ1ghqotQKGUguhh5mtuOAIXQUs\n", + "IPy1v/Cbj2Fbv3t++Id/+Ou+/6lPfYpv//Zvf8d17t69+47X/Mqv/Aqf+MQn3vG6H/qhd05b/fzP\n", + "/zw/9mM/9o7XffCDH3zHa372Z3+Wn/iJn3jH6y4vL9/xmp/7uZ/jx3/8x9/xOoBf+IVf+Lrv//Iv\n", + "/zLf933f967W+qVf+qWv+/5rr73G888//3Wv+Qpf+tKXvu77m82GxWLxjus8ePDgd3zvPTfmqppF\n", + "5N8H/hfa/67/+mtVsli5jfCIIKIoFVUB45rxEgGpGGPbBzWCFWGxGtA+cLO+xqpSKxgxxJpbfEcV\n", + "LQKqON+MOlSMqfTDiNoeTQVnLGIi3nswlZgifoI9O5wK2VpSSogIq6M5OSeWqx58QZwSKVQBtUqt\n", + "GRcsWjIUoYpB1YKOrFaeo/tbqnSIeqaq7DaVkgzWGayR26/BtN8FEHGUmhEsIgDtUCsoYdGjoiCK\n", + "mgLGYL1CqLi5IkmpYyEboVgLO8fFo0v8mSNZwQwGO/dIFYyxqAW/Uvyo2F45fb6naGH3+oQ3gnMG\n", + "q5ngPc4YnBSMCtYKuRScM4g35FQwpVBToVbBSDtgfTB0vSW6hHUVqF/dA2IF7yzzbmC1OKLrB4IP\n", + "HB0ds9tu2Q0di9WcqoVaK6qZUoVCRXMmRcu2E7pswLcDepi/1zv6wIHfHzwOzxxV/avAX/161xhv\n", + "0aqogGIRCoJQVBERVBUrjpQzM2dxttI7Q60RkcIw88QxIhVyyph2XxADBapCpmCMQcXRzZSjowDG\n", + "sL0ZyVHZPkq4AM1/hf2UyGWHsY7ZfMD2hpNhgbVHiBiyTkSNxLpDCqhJZAtiLMQC1qElgSjOVUzX\n", + "0d2PDKce3SnXo7BPE0LFOoOxig2CiJC0YtVg0fawYhxFBWpBMAiF0DmcETKgCrV4XNnBzFLMhErF\n", + "DoI6wRmD6SCZyiCeo9MFpWbiOLE53xBLZXP5iPXVmpyu6GYV1yvhbmERlY7A9jziLVh1WGswGtFi\n", + "ECeots0zJaWaQph5LIZJMr3pySkDQh4rVjzGZ5SKmAzVoFWRJJjOYhfhq09n1js67yhDR7+cEbY7\n", + "8tgO+lIMIhWyImLbvimCCWCtoeulHc4HDnwT8liM+btCoBq5zcDehhlFUASp7bE6N4tFTIXBCkJB\n", + "gVoLaYrUknDWEmYdu92eqgpqUKNUMpotnRe6vtLNPMuzGasjTy7Ko4eRMgmut8SoWBVUKzllilZE\n", + "DH0fmM07jDFYa5ninov9I0wVSAYlItZhXKVWgzUV7S0qMD+Z03fK++4McASP5JLVdsXDPAGCCPhg\n", + "sFaZn4XmgVdBjKVYEOMgtsOIWvHBIEZQzYhx1KqIFDRZyiYjnUE8MGS8GIorlB3Y5OkXHgZhSpWr\n", + "yw16fsPF+Zr99hz8SLEJFzJ3PtIR5tDdUbwVclbMFqQCVERamEPEkWLBqqfWQqmC2J7l2YzF3GOs\n", + "IghxqoxjZLPJpCkiGIxxVNHbEFih7JWyKoTeYZ3wvo88hwSPLwXvDLNZz75mam0HbvPQlZQStRR8\n", + "aJ9TzMBsPsf7J7el3y337t17z9Z69tn3rlDsox/96Hu21vd8z/e8Z2t97GMfe8/WeuGFF96ztVar\n", + "1Xu2Vgjhd73GE9v5VhyqGWMMSRWVSikZqR1GDDVXrAqCRWtkjyEMilQl50wpFS0VrMEFx+n8lKuL\n", + "G1KKgFDVgShjivQnM/yicrSA49MeGxxh2OGs5fpiIt/sMcYg6qilkFLz0AsDIh3GCVUnqikYa6gx\n", + "MdWJSW4IdU5vA84pyVvUKt3Ms5jB0dnAP/ttH+F8+xZ3ujt86vwKTR3iMkEc1uptvFdQgWocWVyL\n", + "96sgXtCoCAqYduY5jxGYxh0yQSqKDmC6FmZxwaALcNViUYoU+sUMYxLjuOHBw8T64Y7t248oLtLP\n", + "Cgwb8gxOP9SRdc+wEqKFcGmQWDFVKFOkytDCYbVCgTFWijp0Jkjn6JxnOczBF/b7PdhE11kmImNp\n", + "YZWcKrXqba6k7YV9zhgrIMLT33KXlCcymbHuESKqGbRAVsiZFEdyrNTJQhb6IeC9IziPd/ax7lsR\n", + "+X7gZ2khxP9KVf/MP+4aB2P+j8fHP/7x92ytF1988T1b6+jo6D1b6/e1MVdVrLGU2sIrBsGIJedC\n", + "Ni3UQKmoFKRC2k5siyA1oTmSU8JQ29+UwtB3DM+c8uh6y2azQycBqxh1bDd7Fkcr7GDpF5750ZL5\n", + "6oT9/g3GGJmvjsmpUEplGiP7fcLulSxK6IQQAiKVsYys95fs40RmxPeCtS1ujRpMZ6imYoJhNu/5\n", + "nhe/lSN/n3/3j/8kf/vv/R+sv/Q/8WgO67qjWnDOIaI4X8g1YJylH3rEQsnajCgVQdBSMM5DqaRc\n", + "sDmAVNQKOSayGjCKhoLrCmIVMxN832F6pdrKzc3I9uaKR6+vsVHp+ogLFqrBaWXoF5g+sWZL0Up3\n", + "BuMuY64CBYuUiHeOXKTZ1ipkKRytThhCTymFKUaCNRhjWvzfecLSMZsiV+sbKpWqisuGTMXOPNYL\n", + "u7RnO22RfcZ7Ty4JzbcJcBFyqeRcQAw+BFQTtQpKwrkZw9BjTUuAPi5uu5v/HL+tu1lE/sqhu/nA\n", + "7wWemDGvNA8aFDGGioGiWNviqaRMAUQrVSoinu31FsqeNG6ASt8ZhsHhXQ9iCH3HU13P9dAxjiNX\n", + "m4laM2lSri5HnnrfDNcJR7NTzHJgfN5g5SHee6YpsdmM1EfCuLlknBzGCo92kYX1FAO7ccc+ZvZp\n", + "fxvr7rHWY51BxFGL0puAx7GczdnulT/+iR/k+guv873f8oeQ7tvYvvqn+Zz1rKcrTAsqgfUYFXxv\n", + "mS0ctbZvJ08FRKAAtwa+ilIqqFEwhhozUgyahWwyMhdAcN5iqYgWnAuMaQe7yvlbG/YPY4uBG6WU\n", + "DFV5+vh93Dk9wc48b9RXGMcrfDAkDFEyWg1ilUrCucA0ZWoRUipcXWyYnwzU6igUjPGoEYrpqBpx\n", + "RtFQMcHhbQCrFAOzIdAvAqG3LRGuEKfYnrxyJpYJlYL1jhQzIhXNFckgYvFBSDninGWxmDPvbfP6\n", + "Hx9f7W4GEJGvdDcfjPmBJ84TM+ZSFRVt//G1NrMmUGMBUUouOBXEpmaUbg1YTQI44n6iTpk+FOZz\n", + "xTlLk5nJdL1HELwTdrvEOI5sb/acvzVy5+4xetoRwqw97npHjLHFYM8rm+sNKSW2+4ldvsbkxEIE\n", + "cY4coRiwPuCD4vr2TGFsRZTbckhPqpljf8SJnvDrf+tvc3P+AHHCR77z4/zMT/7n/Cd/9mf43AWI\n", + "te3pxLYY8mI1ox8CKWa0Vvaqt0ldoaZMLrQKH+dQa6i1VQGBoeSC5hZeqVVRlRbr9xYjmYphTJG4\n", + "GTHFUHImRc+0zZzcPeXe0XM8+/Tz2M4iainxdd68fpNynJG1QWzFiLA8mmOXjgG4fG3PtANjDSlN\n", + "LIMHDCllKhWt5TYkBhaDteCXLfzVGUNYuHYoBsF6ZUwbyujw3lOrUmrLYeQYAUvXOSKZnEdUlJKF\n", + "2bBkPp8xny+YBUeO+XFu26/V3fwHHucNDxx4tzy5bFFJqLW0gjvBqFC0Ai0RaSg4cVhjMOa2TDE7\n", + "sq9EIi5ZJCZ2u5FlmjXj7xwI7XDQRNWKdY7QdaSUub6cGHeGFJUuwHy5YJ4n2BZC77m63IC0KpiS\n", + "JorCMBN8V2+NmSPngNaKOI/3ihiBWlvBnSglR0LXk/Ke7376O3n0a/8Q38+ZdwOf/X9+lR/86T9H\n", + "Sn+SMBvAteIbKaAWul7AZQLCGAUwGK1ULRQFi6BiKa2UvoV2xJPqRDUeam6lgcW0Wm7rEIFcEik7\n", + "0l7R6Kk6UqtBkyEnxVXD7OiI+WKF8cJyfsrRfMPN8ZZ6ueZmscPtPFaEcGSZny1IVTFhRn17i6On\n", + "kFEVxrwjiuCdx1iLxbVSSpcwTvChPYmIE1xooSkR15KhGTCFWpVaC8E5sJmorX+gZEOtFmPAZ08m\n", + "Ybww6wJWDcEHRB5rr9C7cvs/9alPffXne/fuvacx8gPfXMQYiTG+q2ufnDGvGcRSpMW9KxFTDUkz\n", + "zkJwCjoSPFgPBovthJwNLhrGKoxF2F5FLswNUi39ImOtxVRFSqHGQsotPCEus9vtePRwzbPPVGqs\n", + "LBdHpGMl5RHjA+Jyq2HWyt17K6Tbc3wi2LlSipDUNi/TWWzvGfoOY1vZ4LTPVBTjPFITi7JCrze4\n", + "rmPoO0BZnt7jH/7FP8Nf+rm/xvf/5B+iGKGKEqeKN4YuCMYaCo6cb24972a5BUvRSlVBChTbnmZU\n", + "AGORotSk6OjJU6F0CefbwSYVSorN221dSIgYUs7ECfpwxJ2zezz33HNsxjX78YybmxuWyy1H7zvi\n", + "jf3bXHxhTT/v6JceNxhWqyNWdyKLM8fmagTjSbrHpEoGYpxweJRCqe1gNcHgnGAcOO9wwbdyRdeS\n", + "P1VbYrVVK02UMaGlYD04K+ziCDjsVyp7KvSD5+zsmNVqhnO21dw/Pt6xuxl4Vw1BBw68G0II/7/k\n", + "6Ha7/R2vfXIx85RBLRXbaocVqihOlOAqnVeMhy4IzjZPVFSheqaxIyAYI0zrxPpmonLFfBNah2Jn\n", + "yLmSs1JiJmvGWoeYwlsPL3nmrUvs0wus3eI6h+06ttsbprhDidy/v8LayvJsRlgWJt3jgydmENdq\n", + "2YMPGGvpuo7gAr3fMu0mjKm4rBzNe24entP5GUYqRiymZG7qwPWX/y6f/MC38n+dfwESJN3R9wHj\n", + "KgZHLIUSa+tsNRZRqKqE3vPMM0/x1oMH7HZbEItoRqQlP41aarG4CSgeVaXeVv20sFZlfuTJ1jHe\n", + "RNKYGWqHdZ75YoUag/vq7zVwtFhRpHLn2US9UnS/RzvHsOjpVoG5n2GGgJt35F2iACZknLXkDLUU\n", + "6BRvelwQfMiUVMHS6v+rRcSgKNMmoqKEmUOAuB/JcUJSpuTW/Wo9FNOcADGVzlnOzo5YrVYMQw/W\n", + "tPUfH++qu/nAgSfBk6tmqRVyppaKWIsaizEF68BowQUIoTIbHM4ZQLHib2PT7tbDM0QXWd8kNtcT\n", + "NSvx0R7rhdC12rdaMniLDQklsr2GT3/uM5ycnPAwXbE4XqApsltvKRl8B8enCzqv+Hkmm20LWyCI\n", + "MRipVIFMoqPHuYCIYdZ3zIZmgJfO8cE7z5FfiQzHAzWNmOBQEeI0svn0b/Azf/K/5F/+T/8wMXhc\n", + "MayGHmOEmoUYEzlWqCDavFBjhHtP3eXO3WOeun/GF175Eg/evrh97hf0tktUkpJGMLsO6xJqCyIR\n", + "wdLPA3fvnRL3HW9/+Zy3395gZnB2dgcqpNIe6a5vLsh5x2oxZ6uR+0/fI75duX5zT14X7P3AbD6A\n", + "s9xddFxd7lhfbyklotVhRNBSsUDv5y1x6QLHqwDO4kQopXJ9ecN6MyKikJRxP5Gl4BDiLmOKorWg\n", + "WimSwRuMozVdUZkNMxbHgTBz+L4DI5S4f3x79l12Nx848CR4YsbclKZfYu1XGoUUNYAWnC94I/gA\n", + "3hWsLxjjMCimGuzCs3WAqzgbqEwM8xOCc+zGxMO3r4lrwFSMEexQEPFY40ET2/2eXVrjcOzHDbv1\n", + "FZvdGiOW2SIwzD3DUDBB2UZBEGpsIQ/jhJoqacpElwhTjwkZ2xmGWYcw8ezpKXfK81T/BqKCsZ5h\n", + "eUTcXGEqbEXJn/s1nrfHfCFu6X2rU7dGSEUZp4zxYKppnrVahlXgzumKWedZLgbG+BTnDy8p6jCS\n", + "2ncnSlWPTBUtLQlqb8uu++BYLu/w1J2nWPhjNk8/w+de/QKzU8/Z/adACtNuz8XFFW+9+YCb3Tmr\n", + "+QnOCRPK6Z0j1o8u2F5s2G6OCGPCL2HoAovjQNHIzdUepFXZ9J0juIDSId4RjG+JAeG2+UkJ907p\n", + "hh1XVxtKzZRcyfuIxsK0jzjN9J2wWPR0/RysMKbUmsW8cPfoDvefuks/C1jXEqulPtYE6Lvqbj5w\n", + "4Enw5GLmClag5Nza4GtFrFC0oMpt7bmCqcitfgt6G/P10ElL7hU1zBZ3GYYFs9kMb3pOTx/yud/8\n", + "InlXUTFgKsWBmQxVhPmsZz2+zZ3lHaa6Z8qRNE5oNfjOYAdzW/pnGXOhqCVmi6ug2u4bY2GT13jp\n", + "8LYDMZSS6OcdN48uKekGEY9oa/nZ3WywoWec9sxqYfvoDX7qR/40f+rP/yRuPuCsAwzGtQoe1zVv\n", + "u0aFquzHiWE2Y5gFQh94+pkTXntjzvmDK1CPaV8PSivnlNw6I0PXPm/nLad3Vzz37HOcnJxx/eCa\n", + "cGzJLuONJcXIozf3vPXm69xcPuR6d0GeCst+RTKVyWQyhjoaHrxyRb+a0816MGBdYJh59ntH3GVS\n", + "rhjJGBMwtWBtQKV10dr2r0qtlVIqi8VANZWHFxeUXKmxMO4m0r7SB0vvLN4tuH/nHvPFjKnsidM1\n", + "Yg1DF+iHHj/zGG/J45YxPz7P/MCB38s8QWNeqUURNdQ6UkWwxpEnpXihdIlqleybYFapE025BFDw\n", + "YglDILuMdXOOV6esliusCbjOk3LhzVffYooRcRatQk2GMLccHc8ZmchmR0wT1ELOlRgjxllKVSCz\n", + "3+8Yd4liLLUaHJ5SKjWCE89uiqxvdnjx+FCxYtnvM8/YpwkV/Lwj54oYYbfboGPg6adO2U8Tj87f\n", + "5qOf+D4++f5P8A+2X8B4xTlDHismFBxKqQ4yaDGUmLjYrHnq3nOEmWXcVJ5+7g7VavNoS6JGSBVy\n", + "ghRbW79qxYhBpeDVcud9d1nOZ7gQiDaxmgWeCTOuLrdsdxt2l1dcnp+zK2vWmw359FlInl2ZULGk\n", + "KbE/j1yf7+kXjuJ6fAC8UC2kW2EcY7rWH+CESsGZgSlljAjeW0CxpnWCzmaBUz3m4uqKNCXqBDaD\n", + "N47QzTk7vk8XFlgJHM1XzO4+w1jXWCksjga64FAtxBQp7zLzf+DANxpPLmb+FcEl6q0nbimxIAbi\n", + "pEyjwTrFdJXswRghaWsW4VbO1ztBcHReODqac+fuXazxWB/YryO73YbdbgQFpVI0kZJhOTvheNkS\n", + "k/v9yH5XIFd2+x2hs+x3GbHbZuCzRdVRi0XwxF1EFYrRVnanypgjPnYEP7Cwx9y/8zK8HolR6Pqe\n", + "WpX5fM7q7B67zQ29D1xfXvDF//2v8B/9O/8h/8Ff+GmSm1rFeJ5wvQHNpH37blTAiONLr7/Ciy+e\n", + "tQNGCt3ScsesMMaS4khVZbct7LeRXblpf/dWuKyUStd3+HnHYjkjRGHVH/Hhco9n4oydFP7f6S3+\n", + "uwe/RoqJEjPRRG52F/g6UERIktgXRafCl3/jTfpjxyCV+aqn1fc70uQg5qZKiZBrZZx2bPJESorm\n", + "QugDi1mgc5YpRay1zAdHSUt21xM6ZfKYmZKlFkE0INrhTEfvPEpL+voQyLliyagqcUrE8WDMD3xz\n", + "8gTb+cttw4vHUFsiVE0ro1OhDJmcwEYlmYoNIDiK5qaqiMWIQ8ShBoZFz/JkQQg9+5QZlgOL5RIx\n", + "TQCkCsQ0MQxzpMzw5gjRTE6P2F5PbG+2pP0ExuCcJcdIzg4VzzRB2kVEM3Uq9F0HHlRbq791nq4/\n", + "InSn9HpEX+6R6hprCqVmnBnY7jfkiytyGrnRkTurI/YpEt7e0psN2nWkPJJ0RKRJvpavaklWhoXQ\n", + "dYFXH77G2ckx3sHR2QI7twTnCf6p25K+wtXlhqttzzpdAptWd38r6bu9uGKohg+/scC9Hbm6fJXP\n", + "WIvUxLd910d55tWBq+rYlALGcb2/gTQy3Sj7apj2rZlre17ZXkdMB5WmsVNzi1dbY1GthG7AiGBn\n", + "c3KEm/WOqWQuby7YJcu9u3fxvaOMBecsvQvMfMdms4Fo2ZuR8zd3HM12eAkMDpIprXzRgTphuxnJ\n", + "3lJK4uZyw3b7eGPmBw78XuWJSswZo9SSbzW75VaeTykqxKSYMWG9xxulSquCEGmlaxhDTc1jx0ir\n", + "mNARYwPOg+scznlC6NpjvbOsd4aT1Sk1CXnblA/31y0uvd+OaCmkpOypWOfJsVKyJcVK3NIagpxn\n", + "s53wnSC9aRozt1oky+EI63oWXYeyYRoz2UaGobbSOWcY5ieQR9I0Erzh9S/9Xf7Ih/8o//MX/yZj\n", + "Sa2ccl+Jm8J4AxVhNnhc77C+cPXoEiMwW3gWbsbJ6Qm5ZAyW3g/YI8swX9DfePobyz5BqiNSK2Wa\n", + "0HXlfa9nysNXicXgwpycEpoyn/u1z/Kddz/Mr169QlVHKqklnL0g3lJMJlfQJKgUNtdruuMlk1Gc\n", + "GEquaLVNz9w6+sXAarG81dypLE9mnD+6wOwzxkGVieXpXcbNRNyOTXjMwTB07NNIRZm217z95pcx\n", + "FGJcEDphftzh+ogTxUhlt5vaQbXZsd2OT3JLA/DJT37yPVnnC1/4wnuyDsDV1dV7ttbp6el7ttZL\n", + "L730nq0FcH5+/p6t9fnPf/49W+vdNv68E/9Uh1P846AIYpp8bEvdtUYYK4U6VZKBFEpr0lFuq1cM\n", + "znr01mutmpn5OSJKrhPjuCWXiawTSsZbh/MerDDvZ3R9jxRP3CrjLnFznllfXZGnTEHREUgKXqA0\n", + "TzRHJU+QciXFiJiKDwOmKlorU2wyvcYFFrMT9g+ukN1ErULQgkigimNzc8Pp8phdjMyCBevxYc6/\n", + "9L1/jL/xpf+Tqwj7zch+W9lvlZIqNvQU07pAq1imXDi/OOcsz/FWWHQrrHXspoxzinGGfnDc6+8S\n", + "OsPDR5Gr7Z7OzrBm4NvfEI5zItkeCZ5geiiRuN9wtdtQUsGXQtKCLRZNlegjxRowrkn05kqYWYy2\n", + "A4JgMC6QKmhuE6I63xFmPf1sBhR6ZxDjWNzruLi8IseEw1NJdDOHFM/65gY0Y13Lk4TO4zrDZnfD\n", + "5z9/w7AKHB+vOEsL5suOOHX4rnW77raR7XpL3h8SoAe+OXly2iy3E3QUEClN8U8VY2yrXKlCqUJO\n", + "hXE0hKJkJ+AsWEUdhOAxpiCqVC3s91uSj1yvL7i6ecB+v8aZBWib5OO84/rmguViyWadMN6xudmS\n", + "UmEay22oQClScf52wMWopLGQpkzVinOG0Jk2vmwspD6iIuxD4PLqkiO3pE89qBKnDH1ls73Cd3PO\n", + "7jxNzCN+CGzHDfEiUqaRk8//fV7uPsBn3vpV4tZQYkRLAflK4tZTklBtRyqJdLNn1c+pkzJuI1PK\n", + "bGNElzNk2aY1GRQjlvt3n2Ffthz3Z/zznPGMOeImb+ntDGsD1jhqyfSzjpBG7vcrKg5RS9aKKRYJ\n", + "0kbT0UYhaYFuFrC9Ilaa+qMRco4YCTjvsbaNuCsmMswHOuPIonhZ4DpHLhNpn5AEg5vzKEWqKazO\n", + "ujb8winDzOKcIeVCmipKYbO7Ydg5xGaETC8dpSTimMil9RscOPDNyJPTMze302P+ke5r1TYEAVEk\n", + "V1JyZDI1O4xX1CneWyyeJJEQDFkTN/sr1C9gB/v9DTFuSbWVG1o3x0hrF5/yyG7a3Hq9le00UvaZ\n", + "XDK2WLBtis5+bI1NOSk55ta4UgpGWtGk1Saxm2NkihMOx0PewEzCxxbfyk2aSFOb/rM6OWPcrVmb\n", + "wNHZPY5PT7i5eJtxfc6wOCVvEz/6J/4N/vJ//LdYzRZsRpB+B7G1A4lCHgt5vyNNe2qKzBc9Z8tT\n", + "pu3Idp/4wmtv0s8sJ2dLju8cs1rMsGpIJfH86lleckd81+l3sN9eM3NzbOiwxmGswbm+jbQbE8/e\n", + "fz+7X29PNLHGplVTmvSsOJqSThVs57C9w3qPrQasRbUpH1oxIJUp75mSxUyGsPIEH4il0AffFBe9\n", + "hyxIqsyWA7OjnnE3MnOFMGvt+VpaYnPaT1AtIqU9Gflwqz1jMDhKuiGnCuV3rwt94MDvR55c0xC0\n", + "JhenaDK/FTen1Zhzq9mSUmkj4UqGDCUEiiqehNiOUkA1M047ylXCGU+piWEW6OaWvImkbDDVotag\n", + "OfHw4k0kKCqFcb8lj2PzRLPAVFBxjFMEdZTaDh2RipiKSGnDmo3BuExR2G0Labwgb5V5GuiOPUUC\n", + "xhbyuGOVply1AAAgAElEQVS9vqEAc2d48OABcZrwpuK6gQcP3mIcL/iu+8/y7afP8xuPXicEh3U9\n", + "mERMlZInxm3Gux5jlG5u2Kw3aLKMWtGqXL19wRS3bE6PePvNt3jppZeoBjotnIVjfvSpP8jN+gpj\n", + "O/phTjWewXvEAnmkjBlnHPMwYxEWFANjviFKoro23i0sCvtQKc7RHVtC72+rhG6nIZmAOIezFuc8\n", + "vQ3ETWWzPmc265nPFswGSzQDcdxjaiJqZNqO5DrhByFVpTcWOkvNLbzlS8XMeozO8KFQa8QYxVgl\n", + "pZFaLIXAfjexPyRAD3yT8gT1zNsUewu3nYvNm5PbSexVviIwJeTSNEaktvhozoWZOFansFh61NBa\n", + "4FPF2YgxjtVyzjQW1mlHzolCATVtRGiaiGmkilJVm2pfNkgBiqFqRZMlpYqUgjrFhtqGH0imUCjW\n", + "olKhNjGoaW9ZT1u6E9jvtjiEJC0RaNzA2ck9osILz99lt9+z3W+Qkig5M4Qz4sUF/94P/9v82f/x\n", + "z/PWuCbRBL2u1iNxLMy7gdO7S1x/TayVPCX2aU/d0xKgUiFXLh5ew5VjZpa4heUD/ogf/Y6Pc755\n", + "hNWmIFmNbx21Yql5QtQQuo4+TUzjjsWwIuuIStd0bWhPPyVZjPf4U0NYCNUIEtpAjrhLLOwCNUrw\n", + "nuVyRZHCfrvHmMDVw5HF3OG6wLIb2BmDlh1pyjgfqL7gvKOfGdRbSi5MO5jGxH4smGro+5bwns1a\n", + "jqSURAiekjN5LNRJmabHqs1y4MDvWZ5caaK06UJNgISW/9Q23LhSEdMqRbjtGCyqTRmQTCmWYSmE\n", + "LnB2eowIrDcbgNY09JVJ7ctAHTO7bSZVJaepraMVNS2xqgC21a6nUpDqMFqxpTKlBKXivcfYirG5\n", + "iTlZQ9GCcc0Q+t5TimEct9T1RC4VrYJiqKrEGCkF5ssVDx68zTSueekDH+ThW68yLBc8urrkbH3E\n", + "yx/7A7w4W9E7T5HCjd/R24EH0yXPP3uH0V5wcrpgo2t2NxO7eEnaBIpmck2I0MZBj4V0tSbfRP7N\n", + "H/pB/DZRaNrpVS2LoVWwlJKQmls5pjGIs0QnLO6ckKaRsq/sNyOaU5MyMIJxyvFywbB0mK4Zc2ol\n", + "BEeH42g2Z9YfkV1iTBPDbCCnSpoS66sNp/0puWT6oSOOE6Hz1FQRbZvAWEGrZbsfyUlJ+4mahBIr\n", + "voc+dDjf1Beda7NQ06RNhrh0VN09tj0rIv8N8C8Cb6vqdzy2Gx048E/AE+wAbYMVWvu5Ymit9vW2\n", + "J11ra5YRade12nIDVdsw5L4nhA4xhvmsw1jL9fUNIq32O+fMEAamPkGc0KmQNREzGCq+s1Aqwd0e\n", + "GlZw3hNLpaR2f8nSkn42I0bwg6UGcCHjvLk9ZhQjhiIViuXZe0/T9zMu315T04Q1luXxGWE+xwfP\n", + "6f07PHgj8ulf+/soGWeVxczz6PqGu3HLR+7e530pc391wt/44mf40FHHpybDVXzEC0/Nee6Z5/jS\n", + "zWehGHbbPXmXMaFiDISuY7ed6HTGEOFf/94/gouJbRwRcYT5jH6+JE0T3a06oqb23brOotuKdIan\n", + "Tp/mYrdGnLIeR7bpEoMFDG5Q3EwwvUFsIZsmNXzs55x2A7N+hnOtbFSppDhRSm3H9jRRpja4ousC\n", + "i8UKTbeKibf/7nlS4rQnx0TceqZtJe4y89Wcvhe8N2htyeFaKzXDtB9Z30zs9hV1jzXM8t8C/wXw\n", + "84/zJgcO/JPw5Dxz4Ldc8qbDUm6n4yja9K9v29Fb9NygtbaKkzYxFME1I6/mdpivp7MdNUPNipE2\n", + "JFiMQV2hxISKoVZIU8YHwXnB945aDLkUrIFYaxv8gEU7xYUm1sUg2FDb0OCQqVgY25AHSRC6wKo/\n", + "wTiDoBQMq6Mj+vkRPnRcXV2RcmS5WLG+Ouel97+fz3zmHxD6BVUr4+U5n/zgyzy43nDsLOPd55i8\n", + "5fn+iHPd0R05Xrj3ItXu6cY3GesxD9aP2I4TT89nJCwPs/JMWPCvfvx7+ehzL7G5ugYRrLGI75hi\n", + "ZN71eGcoKSICwXt2+zWd73CrJbN4hiLE3Y5gBrxsyVOk5IL3Htu3XEISQeIOj6VzrVSxVbSAcYW8\n", + "n4hxpNTMbr9BUYo1LM4G3MyyWh3h1FF2kNcRSyCnG0oGEd/Et8jYbqCbO5wXrCsYZ4BKViHHQi5Q\n", + "s6HoSJibx7dnVf/mrfztgQO/53iCHaBCkWbGkeahG2kmsCVAv3JhS4i26WlC1owgPHp4zb27M1Ly\n", + "BN/i2Z117VgoisNjS25ecynkkkm3E+G9WFJO2CxUZ5FesKJMouBashNpioPVCSYoYQnGQ7WK9K1Z\n", + "RUQoMVCjRbXwwnNPcbI8olRHzi28cnn+iGm/4cWXXiYMHc/de47f/PRnMc7x6pff4N5z72fpEq7v\n", + "CBjmyzPuZ4jjjo+9+AJZhJqU6xTx88CdxV3yzZYXTp+i3O/4crdg3I3MuxnGDfydz32eT9x5jj/8\n", + "ke/ien2Bn80Y1zuG4yXDMGs5gJSompGi5JrZx4xxQswJMBwv5xAz/dUaa8OtTjrtew0W60urKU9A\n", + "TiiF6DKp20MS1BamHLmZLoj5mjxW9mPk0eacXR15n3sW41vdv/eWzndtdqcYqIY8RfZjRFxgtupx\n", + "KjifcN424TUytdo2yDop+3FLjC05bb19Ulv6wIEnyhNsGmrW+ithleajl1uFRGmva21zP2tLfOWq\n", + "GNOmtU9j4fJyRzdzBO+wnSd4j1Ylp+bLN4ldQ+c7YlGoCe8szt5qbmtCq1BKgeox4XaEnTMw1jbw\n", + "ISi4NtjBWI/6iliwOGLKOOnIBp5/5g7P3L2HMxVvHNY7TBTG7Z79+pppv2V5csZ+v+N6uyaNW9DC\n", + "h7/zO8lXb5J2G/bba6xp5ZkpV+7fPSPXgpPASUkYKg7lu4+e59IPfO7BQ77t5CnsMkEYuN5HPvrc\n", + "ff6Vj/8x6rhjv5+oueB9U3XUWkGVoesoeaLU29r52++61NrCQeqxzuKCx7n2XVkxiCj2dphEG3zR\n", + "GpvUwtZFgilkK+T9xCau2cYdWjMlCzVX9nHk3D3i/v071FiZ9olh6OmHpgmfU6bWdnBrbUJc1nms\n", + "LfjgMU4x5nawhdYmX5BaPM55A0no5/7JbelbfvEXf/GrP7/88su8/PLLT/DTHPj9zHq9Zr1ev6tr\n", + "39GYf62kj4icAn8ZeAF4BfhhVb26fe9ngH+LNlP+T6nq//q1120iUKqKoUmiqmlGvNbaHtURklS0\n", + "tjn2apRSBaltcOZrr15TTaaqcrQIDNaTcxsibIwFVWoBsHhjW3ghBOb9gGplO67bMOdscNbQ+0CU\n", + "TMrAREtymtvhFs5SXMYYRcggDqk9McPgPR944f08e3KPo9WAicLTzz/LG69liusInWd5NGe73fDZ\n", + "T3+GP/jPfZLPfvrXoez4/Kf+Ht/1bS8x9D3T1Rpbt3TzGV/60is8/cwzxJjY18r65oJ7p6fMjzru\n", + "18SLd7+FYwZeu3yL02GJdp7dSeBZt2S1KFy9fYHmdghaaTNQVZWhm0PJ1FoYpw3iPON+YjZvQmHJ\n", + "RkJncZ2lm3uOFwsqRzzcRrwIVWDMCRsL+WZCRZiHjvW0xVeH2jVFCpFCLZmSWyVSKRWNwuZqy/n5\n", + "FcvlMfubLVKVaRyxJjT5g1RbD4Cx7bO7Shc8zoH3BmtNm06kELwjThljPP1QICzx3ZMX2vqBH/iB\n", + "J/0RDnyDsFwuWS6XX3391ltv/Y7XvhvP/GslfX4a+CVV/c9E5KduX/+0iHyYNkrrw7RJ5v+biHxI\n", + "Vb9mvZhIG+LcRpoF5LZ+W1QpVVFuJVwNZCquGrJmjG3VMDEWHj3csOh886xnM+IUqdU2ZcNSsFrp\n", + "HFQxGO/ou8DMdnQhUEUo5abVkIshm4JxhfncUVKmFIeIYkwF7ZCYKLYgxVN9RUWwtdANc56+c8Ti\n", + "ZEVyCc2KEVgsl3zxy79BHNccn54yLOZ86EMv85lPf5rTu3dZBDiee8acePD515ktPcuuxztHP1/x\n", + "aLOj7HdcXl2Sa221+VbZTRP9ouel9z3P2ekxr375FZ45u8ubF2v6O3fQ4nBujh33iHdt5Jz36JSI\n", + "cUO/mFOqwZqezc0GMZk4OVzX8+buglIStoP5vGOxmrMbO2bDEuYTeW8pgKYmk2aDQ6uScuEygYaM\n", + "CwlsxXolRaEUocQ2o9SUxKtffJXlbIVm4eZyhymV/X7TSlMtiBX6rsdgEWrLlUhoM1FvK55aDkVA\n", + "K2IyxQp9b7B29i629IED33i8ozH/HZI+fwL4vtuf/3vgr9MM+g8B/4Pq/8fem/7alt53Xp9nXtMe\n", + "znDHGm6Vy44dD22bzJ3QoiGgRrSEFAGiBShITV40gqCWQLxA4g2oheg3/AMRYpAQYQpE3YLutJIm\n", + "Ucc2bsdxbJeryi5XuaruPXc40x7W8Iy8WKcqgcTB7VT1DfH5Svecfc7ZWmvfc579W7/1e75DCcAb\n", + "QohvAj8OfO67HBslFFy5BM4jhjS/YfM8ly5FIoogZzH7Y4t5NCOFhJLpLz3bpaeIiCyF5P08Yomz\n", + "ShA5b/6pPHd1lTF0dYs2mgOuNs/SRPABKRMg5mLSFIJXjMWTsmDYZYzVIBRBClQ1Qgk4bchqQC8k\n", + "dinx20DnGqp1hRSW+4sHeN8z9QMpZU6ePGZhHT/0mY9y8eornG4vqfcFbRsuLy+IdpwVn3k2kFJW\n", + "opQhiEzKUIpivTzkO995g8bU1G3LUbfi8vIMKzTPfuhFHj16RAgR17aEUlDFotBoFLZZEoc9KUR2\n", + "+x3j2GPcvJGsjeM7FydcpHP2456UJ4wtNJ3l4kJSroqykJkoI/IqqENKhYyKZDy6KJAK0iyoKiVR\n", + "ooIiyTkggHHneevbb1JCwjpLDondbkMucY75A3IOV/NxiVGKECNFZKyes0198MiiiGU2IzPOIq5G\n", + "MB8UhBD/3dW6PxJCvAX8x6WU//IDO+E1rvGPgO93Zn6rlPKufddD4NbV47v8Pwv328wd+h/GleJT\n", + "5PKepH8OhZg7dinnxBySJpOuPL1n+qIoBZULMSfiJNid9xAkqR9QzqKFolCIeaCU2TNdKcHkA845\n", + "nDM4ZyiuZcyBizNPCoVUEqbJCJFRToMZEd5BP2+IhkEjlUeYgCgSbQvWZkyViER82HIwLaEKnJ5u\n", + "2G08U7+hZEm9PGbvt6yXjtZZXvvC51neWFIPYWa9LBpi2iJMxfbyjJAi9XLFc0c3uTzdUleOxxdn\n", + "+OQRRXBy/zv8xE/+ed566ztUVYXEUjvNNO4QpczjJj9QVR1SGrSpZmEWAtsuyDnhrCP4kTAF6OYx\n", + "0+uvv84TcYbSkiH2hOSRKBbNkt5GvJ9IWlNQGF0wWYEX5BzRUoKGGGa+UQ4RJoHMEpJg3puUlATb\n", + "3cDp+RlOzOOUadox+YEsQFkFZDRz159SIqUMRiLSVXZszsiSEcVQciKLjJHmXZrUB4JSynV48zX+\n", + "1OJPvAFaSilCiD/uLfRH/+yqKBcpoEhI5SqkYuYn5wRFFkRJiKAwenZINBrmSN/CVTonpw/3hF4z\n", + "dJK6yVSVRmlFFABpns0LgRSCcZpYdBlhJK2s2FU1Wk8MlxNjyFSiYGwmkZBaIMdCHt7lk8NYEq6S\n", + "CKnQKhBK5sBZtuMZrTa8sH6W7ZMnPHr7EbvdQImRYb9nHC557oW7xOjZ+ku0hKU54rXtJTZlbty4\n", + "Rxs35AyPHz9ktboBRTKkgLGWpq6onKGu15ydPeb41i36aeTy8pLdfsdifYCTkml7yeb8AmNaZDEI\n", + "ocg54v0c6pytJhZFu1wxTHsQZbbnRbC4ccT/9etfQnaKuqlJbkI7yRRHYvbUdYM3mT4ElCxYYaiu\n", + "2CMxR3IEIwTSFYScBVlON/gU0RSKkuQExhpa1xJ2E4GCUhDjSIgRpRS5JIxWiJzIcV5BIUZEkRSV\n", + "SSW9F7ghESDnBiDnjNIfXGd+jWv8acb3W8wfCiFul1JOhBB3gEdX338HeO4PPO/Zq+/9IVzcvwQE\n", + "FLCNw9QzCyFfRetoCSJpkogUIRBJgpSUlFBKEMu8sUbO5CEwpEjMjlICOYFzBVSmMBfeUmaVod/3\n", + "5NUaiUAJRV1pnLP0QhC2mZQCzVJT1EyflBSKnzfcpuxBaIIq2CSQosIiCVIQ/AUh3GHq9yzqJafm\n", + "gsfvvHo1909sNxu0vMu23yHCHi3hc5/7LT716U/Tn2/46tc+x4v3XiKHAWSiCIFtHNvLPTlM+Elg\n", + "rGHTb9DG0hysyWLutMdpovaBoC2XTx6jnGGKA9ZV7EaPoqBzJluJVhWCic3ZjrZpOL84o23XjKHH\n", + "VjXvvPaYndxjGkV3w1EtJbYzhCljZUPfjyQhkAqMTLSmgDBsp4EpztRSgwYlMaUiEmeVgM6YYphK\n", + "QAmFKpLoZ9FUjIVhjIQYMKaglEJETchpDmm+8rzPSaKkIqWrIPAiyEQuTkYu39wjr0Ktr3GNH0R8\n", + "v23M/wb8/NXjnwd+5Q98/18VQlghxIvAR4Av/FEHWN9dsH5mwfpOR7UwvCcjEgCzOAhRKFlCyoiU\n", + "ETmjEIgiUDNzkBLT7OwXBGGX6DeJ/Tax30f8qEiToHggCMKYSQlCeFf6XjBCY4RECkGYAn4r6C8z\n", + "434ihgIkcsxXFD9Ju9B0rcLZCqtmlktJgr3PmElze3GMVJH1esHy4AAfPEoqtDHsdjvG7TlKGHbb\n", + "CyiZ3/nyl7jYbzk4us3p2flMuxxmp8D95cBmvyflSLiS3z98+BCpJEVoHpycsO+3tG1DLpkYI916\n", + "xbjZIUshxJH1wRIpLdvNgEgVl/ffZvfoCTpH+n2Psy2jH7l98zaqa3j7ySXbx3OB3Dy8ZLOZ4+eq\n", + "yuJMzZ2jO0xjZAoeY0GIidoWKmswolyFhcwxfCpnKlFhdY0zDikztXVz3JuPiChIQTGOCT8mZBLI\n", + "olEoUinIAt5HYsxwdUEOKc0boRkEBorm5r0jXvrJYz75s8/zmX/u3ve5pK9xjf9/43uhJr676XP8\n", + "7qYP8J8BvyyE+KtcURMBSilfF0L8MvB1IAL/dpkNVv4QCrMl7cyJEAgpKHFmiIAkhXkzslx1Wu/R\n", + "FaMkqTILjXJB5pmTHFMg5ky+OnhJkGuwlfx9LruQRC9Jscz0RS2wyuKkpq4cVWXph8zUJwgCIQNa\n", + "SaQVlKJwnaRZGKSWaFWwtcPWGVVJ+rGwLz3TzRGRC34c0XWFULPXTE6eYRzQJbPdnXLz+Dbn5/c5\n", + "bhas1musBp8tIRZQmmHa89bbr7Jc36BzsDnbsj44QElF1bZMY8/l6YOZIonCth1KSk4fP2F5sGCI\n", + "iqpp8WOkaY/oFpo4bZHaQolMXrC93HFweMBmd0Fda07DiJAJZy3aitnAKhQudzuWbYtVULkKKzXD\n", + "lQFYrQTZeqSKqJwQelbnGglO1ShpyGiy0UgfmaZIjHHOek2C4DMhjSgBunZoqZFFXPncS2pniGmm\n", + "mxqnr9bBfA4pDELC5eNLKIK2m1fTNa7xg4jvhc3y3TZ9fva7PP9vAH/jezl5ARSKrGZGgpDlXXX/\n", + "ux+ujjl37EJIMrNIJCcBUaCKZsoTqkhKTKQBhpgRncUIyFIj1FWwMQnl5sCHMAVk0Egk1jiOVmvO\n", + "z3fsNxMhgKg0VTPz1YXLQMbUEmkKSmeMTTS1w7QZYWenxCF7tvs9cb+lqmcDrKquWK5qku8xorDb\n", + "7ehqxaOTt3nm7rOM2y3FR7CKrr3D5cWbHN24hVGWB/ff5vadhmG3IYSJRw+fcHzrBg9PHrBuF5w8\n", + "uM+tOy+CqRhGD2HCykLvM1XbzZz6gwMuTneMu0zse6TwpDCx3Q8cHd5ic3pGTCMhZ37rt/4+9cJh\n", + "xWwvW4qiRME4DQgdWeqbOCuxqmLfj2wfRepnBTZNGAu+JHLJWFvhsqYSmpwKgjmwW4iMUgqZIfae\n", + "GApj70EWmoUlF0ixoKydXTKlwFlFLQo+RKY4Z40qaWc2U8pIpTg4OkCpgJIOIZ6+Be4fFA39SfC9\n", + "ikW+F1xeXr5vx/rqV7/6vh3rwYMH79uxAL5L7/h94f18be/n7/+74Sm7JkISQC5IBEXNRlo5ZdJ7\n", + "z7xyVkSQYkZq5uqOuGKsxHkDFTXznaeMKQo/gbMFVQo6z/PVuaNWpBSJsZBTwlUGbRWCmtVyxfbx\n", + "I0IpSCdwtZtZFHJ2HBRzagYlC4SyyFqhHKAiVlgOaNnvdoybS/wUqauKVAmk8FSHDVJGCh6fJc40\n", + "7Pc7lssDtv2eo+M79OM5xi6onES4itW4ZQwJnyMZwebynOM7dzl9+3XknReoq4aq6ajbA/rpglQg\n", + "hjmQYz88wrgLDqnQRjDtAv1uRyIggsfHCFIwklgerFC24u3tlrqarYYhk0RBFIEQiTFJ9lwikmFV\n", + "WbYbw0UfaLYGrcBqjbVi5t7HecM5CIlM891XDPPdUCnzPkkIHu/nODxBQSgHZb5byzlfpU5FtOa9\n", + "jFW4unOhUMocISjQKKVxlZ03xMVTTUK8xjWeGp5iMS9XDoiaLBPEmc1SeFeuPV9h5zf1/LUQkPPs\n", + "2xJzpCDnwGHmhBtKQaPJvpBtJASDniI4QUETk0ApBcx2AClFpKjJUSGFxFpHu9TspoBUAqkEOUMO\n", + "iSwLJUpSgpwEky9IEa6YLR3TbsOrm9e4197BCY11iTZLVs0RMXi2u3NSkjRtg9UVi+WK1eKQNO1Y\n", + "dQd4HzHasrl8AtQYXbNarYlhD2XujlXV8ej+CbZtWR4fcn62plus6fsBowTb3ZbKtuz8iCqBdnmD\n", + "4LeMfWG76ZliIA8TMUds25BEoD06wFYas1ziG8ntW7fZbp8QQ8Yz56CmWMgq0HNOW61ZHiq6nSAV\n", + "TUgKj0Z5ha6vWEZ5LtyUERE1oghCzkzTNDNq/Py3N0Ix+h7X6j+g2oUY4xxFBzgnkCohKkGRYLMj\n", + "54hzljAmhFBYqxCyMHkwWnz3RXeNa/wZxlP1ZskIREmzmo9ZhSmuAiNkEVcFXF45IxaKuJL/C4ks\n", + "cu6aAZCg5tR4nxJCFUxSTFNAazlHx6mEdVeba1HgS8RPCVKPEHNIhkZQ1RU+J0hzN0mcuc0pCeIo\n", + "mcIsU2+ipe8zdVchlSAVy4aefugRSrGoairb4P0WazUxRfw0cbi6xfZyw2qxQOIJpdA1a5qjG0yX\n", + "D+mqjpBGbh8s2TKho2K/Gbi4uOCHf/izvPrK7/Ezf+FnoWRu377Ldrshjj0hekxdsx3OiT4gmwNO\n", + "Ly44vtHiqgZpPMfr27zzyjcxbU3O8+9Zi0xXN/zek0e8fPYKqlZ06nDumvc7tI5EaVAls/UTnfW0\n", + "jWK10jy+zEypEHJGIqnRlJKIJNIUScUTxkBOc/h2ygmjBKRy1X3PF26BIJSApKC0nT3rZcBqR73Q\n", + "OJtRyuGsgOyQai7YZQFd113F2imEkFcX62tc4wcPT5WUKxG/zxcWAqETvDtguRIQSSlARKTK75lw\n", + "5fxuEZ/zMaUq2KqgXJkDh7NA29n9cBgCk0/4KSPkHGYw+2vPkXSbzY5pyuz3PSFklNTMIxwog8Dv\n", + "M1MPaYRpFxg3iXGT2Z4H9heR3TYx7DJ5MHRuha0cdV1jlCbngFGGlNKcvtN1DH3kzu3niKHQtSs+\n", + "/vFP8eTshLt37xCLxocJU6/oug5KRsoOKQvt4oC2bbn7/Ieo2262GRAGbRwYg65W+HH+fzmzYL/b\n", + "YYwgxMg4bGk6hzECYQ1nTx5TSqLfXGKcY337Fq+cvYXXAeMa0IoiBcrZWYGbwShHi8LoiKsC3Vph\n", + "qkKRkXGMc6ZnyPPehZ+To6YxMewGNpc7dhcbxt1E9DMjpZQ0K0zNfKelVEFZiaslbatoF5b1UYWr\n", + "A+1CUNWSZiGpF4a2M7hKsFrVWCNQVaZZGA5u1DSr6878Gj+YeIoWuOVqUxKUnh0RBSBkIReBLAJK\n", + "Qcjy3px77tTnW/HEzBsXMqKMRpmMk5HoM04bjJvVJv02Y6Qia5hSpMoWskAKjRKGcexJk2CaBqZx\n", + "P2/CpitPkRwRk0AISBoUmZIEOQp8KGyfJLROVHWhVh2VrGi7Q+Swo5SErQyxj8QQqauaplkyek/T\n", + "NRwcHrNarUEann/pY3zx81/kxq0V/aMRy+FsAFYstZ3VnMM4sNlteeaZe5iq4uLsnXlerCP16hid\n", + "Rt7Z71BCIaXHOYdEEvxIKYKj2wc8euOMzfacupL4aaKylu2jE7p/9l/g7d/7W4isZnfFNPvKK52R\n", + "xuKTx6ERImGUQsV+7o5VISrJJMGRMb4QzEwdLUkSpjw7WJZCTAmnLSKBkYpiJabMNrZFZbquoesM\n", + "zgmsmQNGtJJoLRFkwJOCIqSJLOdgCqkL6Nm7HpGJJZJK+uMX3jWu8WcUT60zL2kenSCYrWZV+f2o\n", + "ilJAFIQUaAPGKKw1V9FizOpRId9TL7YLiTHgGo2SBu0SVS1wTkEupJBm462Yrtz3NClFlssF6/WK\n", + "i+0F+8stIYQ54m3MpK2g7AQxFHKQaAHrlcE5NY94JkH/uHD+zsT2NBIn+PSNjyLDQD9uKCKj5TwK\n", + "ss4ilcGHgBQgqiW2XXC53fHqN77C2aMTnnnuBX7tN36dJB26bohZUDWOnA1n5+fce+6HyHnmko/j\n", + "SCkNWcJ6cYPDG7e4uLikkokY92g1R6vttqfst2e4WpH9wMXZI6bdFpTDDzuQkmefvYdeHCGiYjvs\n", + "6YceHzzDNCKAPvmrsZPAFoMWiVTilUAnozQIImPwM5tllOAN3gtSkEihAEXjOhrTzN70uVBbQ20y\n", + "ba1YrWua2tBUDmcNRjlkkRQPaZJEn9BYnJ59XKYpMQxhfr1jTwgj/bBl3++ZfPjA1qwQ4jkhxK8L\n", + "Ib4mhPiqEOIXP7CTXeMa/4h4ap25YKYaCpmvnPDkrNgsCkS+UhkWFitDjorgM1rPAqGSr5SiQlF1\n", + "sFg5zi8DSkVMLUEIrIUwe8BSCoScqEpE6oCQEWNa1l1FWdVs+55HDx6iXCFPfvbqiwmUREmJFJn1\n", + "DUx/IjEAACAASURBVEO1iNSLBbtTwfZih99E6soSleT20YIcJcFPWG3Q0nF5ekoIsx9MVdd471HC\n", + "Mm4u+NK3v807b53wnXdOiD5x6+Zv89P/1M/y8PEFK6XZb3eM48Sqrjg8XKGM4M7t27SrI6QRhGI4\n", + "vzjhY596kTRN5BjRKnO8PCJFxeVuQ+ssGMO0n4hTZIw7Fsc1Qhpu3V3SHqzRFUDkzTff5uzynP3l\n", + "lhQ8VgtEbcllB0nT+5HaVYiS0cphrUBUEl3EbE8cExlDZv4sUiKjUUIgmSmFRRSUnC/IdWuRWWMr\n", + "w1QiOQXiIOiqg9m6OCZ8mC+8gYAKnl0vudwmzvc7gvdoZRBKIaREykzbVjT1B+pnHoC/Xkr5shCi\n", + "A/6hEOLvllJe/iBPeo1rfC94imMW5u4OgZBAmcMRZgikTNR1R7cQ5GTYbnfYpIk5gypYofCTpzt0\n", + "1F3mcueRahYJJS8QOmJEmSPjckEWiTEWZSYymkV3wHK1oGtramsZ04YxnqMryCiUEQTkHPzsBKtn\n", + "BetVy+5UkoZC9AqtLKvqiCwD/S7y+OItDo6eQ0vH2fkTQr+nbVtyKWTfUxvLlCUPnox8+2Tg62+c\n", + "07bHfOvh63ztrXOE+QKrO7dZbT3LznD74CaTv8QohTOWUEAbS1KKMSZM3WLqms2TR9y+fcyYC1ZX\n", + "7PuBQzWbku03l5RqwJmKo5tHqGy4f/8xybQsDhYEDDlcMEw9+7Md425EmZliWMjMHxM+Q4gjUneI\n", + "NMvztVZIK1CVnlOLUpij9kqAcrUnIgVSSYydPWKEsOQ8kUukriTWZsiFKQikVMQY0KJm2sPQB/wY\n", + "WC8DsfT03rDdeDabhLpSwQoKj8/OmKae5YGj69oPcM2WE+Dk6vFOCPEys7ncdTG/xlPH0xuzFK5S\n", + "ZWbDLBBz5idXc3KjaLqBeqFp1gphFaYGYwXWKqrKoI3ANhLpIqqefVRMJZCygNW42rI8NkiTkGSE\n", + "zQhd8HGLTxNNW7FYrXjmuTs88/xNbFeoDwT1KnPzw4I7H5HcfNFx9JxjeVNiXcLUBbfUVIeCG8/d\n", + "4PD2khs3jqGDumkZQmIIeza7S3q/53Jzzsmj13nw5re4/+bLlHHLzXuf4rTP3L73Mf76f/SfcPve\n", + "j9Pdfo5f/fUv0rUrXvrQR9mkQiqBNHlyhLqtaJoWt1igzIptSNx65gUePtmiukO6Wx/m4MZzuGaN\n", + "vOLhay1pGk1lFU1bce+5Y4a0o6oNt28foESgbiVEwcmjx+xPd4gouLm6zc31XfSVyCeL2SelFEOh\n", + "UFVzrqpUAqFn62JjJULKmbXi0+ycqCNCBJTKQMFaTSkTMQr6foeQI4lxvttKIIpEBYUOmrpUKCnw\n", + "fWLyA0VItNpjZCD0e/w+ESePypo7Bze5d/vD7Dbw5GL8x7J+r2yhPwt8/h/LCa9xjf8PPFVqokAi\n", + "ZHmPepjzTE8suWCMxtiAqebuUCuF0LNLohCSLMXMzpAzP7lpKnyMSFVQpuCqubjXqwJhzug0misB\n", + "S2C/mQAwTqOsZH1wyPngSN6j15p2UcjK0o8JbWpMNZB8wDQdevLoArqG5bomqUKYdsSYUEaSUsAo\n", + "zRA80zQRfWSzH1kdLnj2pU/xe2/3VOsFv/mbv8NfevCQ3335y+B33Di8RRozw+QRORNjxgfPrVvH\n", + "dE1HVTuKWZJT4BOf+AQP33yDy7MzXKtZr45xpsG0EVlusdme46eBAmilqLsFRle89JEPcf/Nd1Bq\n", + "9hpfLI44+84blNHTqArrLE4ZFlXDflqwLwOlgBEOLQuyFJQxs6DHaLQps5d8nv9uhVnipfWsDZBa\n", + "zX47JWCUReVCibOMH5XnvZGi8FPA4BmyQtkaZxtsHJl8IgSPkhMpRXLhalzlOOw6rFC01YpaV3Su\n", + "4c3zNz/4lTuPWP5H4N8rpez+3z9/7bXX3nt8eHjI0dHRB/6arvFnE8MwMAzD9/TcpzczlwXkPEN9\n", + "d7yilJo7dQWmEigrkMbPGZRWYFxFCuGKmjirNp0DY+fZ+uP9Hi38nFWJZLmQIDUpjchc4axGC5hC\n", + "ZH/6kHvP3+Ho5hFSypm6V0kaUyM6S7t0uGrJdjdQRMFWI2TLZAeyKzircI2gsZbJjmhqkvLENJL3\n", + "I+M04oxh22+RxbE4avnYJ3+U+uhZfvf/+NscH3c8PH3Ev/VX/xrKSv7mf/43+V//+/+Btx4+4p90\n", + "Fu80phhk44l+RNuK7Cz1Yk1Ie377N/4eb72x4fHZEyoyTRv5+J97iU9+8rPk0sD2DJEK6+UxiYBV\n", + "ljFusFXL8y89wzQFchFUqwVvvvk6n7r3MT73yjeoXUulDV1jaahJacl53qHyQMFBsbP2VoCWCSUN\n", + "oObov5JIRWC0QaqEzHP82xxMUagbGHeJEAOJkRAFlZ2pj8NlYBCJZ247pBVokVnUjogm5YGSHaJE\n", + "pIiUFJAYrIwcrI5Z1YfkAqvlIXVt+F1e++OW3p9s3QphgP8J+G9LKb/yRz3nOvPzGu8X6rqmruv3\n", + "vj4/P/+uz31qxfzmnYazs2FmtMgrKiIzZdHognURYzSuBiESbTu7E+q2wXuPlIrtpqC0x1qHJGOc\n", + "JHmJNRIhPNlUVG1GW02lW7S0KBmJvnD+YOLRozNu3tlDkWgtaOoOFyxK1KwXFaqai9boRwyWojMq\n", + "FZSdMJXCmoJwYCporzY493FCJY9VmnGaCDGhhESaBbZZsugafBg4eRgIQcwOgjny5/6Jz/LFz30R\n", + "GZ9giqTf7UnrI6qqRtYVi/Ux1eoIDygheO31ntf7yHMf+Qz7y0te/drLNO6SxfId1ouaqu7mqDgE\n", + "hsK+P2PZHSG1xo8TSmba5QpVN/yD3/ttvv3Wm9w9vMOTzQnGLbBO0RXD1BtU1FSqhZSwUlK7hoVN\n", + "KLnDpJn/n8WcBqWFQSlJUye0TIyDR1ChBagyYFRi8hFtLSEktMzkNLNicnL46ABBYh7xLGyDLy1C\n", + "9ahSqJSirgO1AKH37Mf73Dq6hZwcojbcEOsPbM2K2c/hl4Cvl1L+iw/sRNe4xveBpzYzv3XrJkdH\n", + "7Wy8VOBdvw1BYbGsuHFjQWUdUhaUKtRdwVYZ12TapWOx6FisLFW1QBsBQiB1IaPp1hbjLLJI6lqy\n", + "PnTYOqIriLFQpowymfOHPScnJ1xcPpqtZN2C2lmcW6JlgzKGwogU6mojz6BRNK1m2TUYbSjSY/Q8\n", + "6z+oOiolcUhyyYRhS1N1rA8WHB0uaaxCpolPfuyjPHv3eQ5aSQqeGCb+w1/8a3zrtW9AKkgjWC8X\n", + "ZBUIKWCqFm0NarVAS8eXP/cNXrnY8wv/zi/ya7/1Ff6Xv/V3+PjP/Bjf2GlyXlMwswpUaiBhbYPV\n", + "DTFGnFA4K+mahvXqgPMnZ7xx/1VuH92iqizdomb0Txj9ntrOkvulckgm6txhjKZpHXfvHPPx5z9C\n", + "69azJW3M1LqiUi3domHR1CxqTW1riKBFQcmAtRU3Dw5YOIcUiSL3ZCJV3dDWx+z3ge04h4MoEzE6\n", + "s+hWtHWLkAXlMstO0q4VdS2wVeJbD76CdJmcB6z7QNksPw3868BfFEL8ztW/v/RBnvAa1/he8dQ6\n", + "84ODlraqeb28wZPHe+awIomrLE0XqVuFM7M/SikDTbNgFwNVbfE+YlVmIRuqOqCNZRz6WRGpE21r\n", + "QQ5oA0p1WFdISgKBfjfMxQdNTIVxFyBFJr9DGD139bJGC4vOBsUJqMLCLRmypzBhbcWqPiCNFm0K\n", + "Wk9IZiHSOASKH8k+EjNUtkYZy+VmxyuvfImXdM1PfeJ5/tNf+mX+mb/407z88jdZHSz5zGc+y3/z\n", + "X//P/OU//y9DAKMN1gj82ROqm88QU0ZEjVOO3/jCV7hz6xb/0l/5BYb9jt3mlNe+9TovfviTiO55\n", + "LPcZ/Ejoe1arAzKZAvjQE0KLUgYpE+29j3H68AGNMjS3V5xf7NHNim1+CLKnMhlnDUJHEBVOKBZV\n", + "RdUaOtfhuiXLgwUPn5zx6OFjFtbQNWvapaaULSJJor8kjbPLYSoB5yQq16TSIOQeazNTibSdRcSG\n", + "9eqIfurZRU/jwNYCZQq2lrM2WCuObuhZ6eoKmoqkCg8u3uR4fUjK/Qe2Zkspv8VTVk1f4xrfDU+t\n", + "mK+7jugEQzhm8JFhIyhMFEZcbWma2TQpCD17ZauEGgQhDnAVAt3UlqYGZxTJO870lhw1tpKU7JAW\n", + "rBA0rmVkYgg7Yu4Jk6Xkkefv3sVlS0mJFKB2hpQTMvdQWpQaaCvJ6CFHkNIgSqZSFeuqJasKY0Aq\n", + "Schb9sOGKmnksEcrS9Jqnh2XQJ4mii5882tfoD6+w7//b/wc/9Wv/Cqf+sxHGS96fv1//z/5d//N\n", + "n6O1mu3mMbURKGvoDtYoaXBVja4b7n/1Tf7OF77IT/74j7C7eDgHQZ8/4qd+5Ee5fedDvP7OW7RH\n", + "O95+9XfQtePi4oIXP/RRLraPWS2P6Ydzbty4OxP9nUGWyIdv3uWN0xNuHt1i2hum6QwpQQqN1QGn\n", + "KiqnERmECiyWNVV7TJcs7XAIpmNRdaSpp7KOdpFIpaWkicsLR4iZaTdyeKuwWtVMynK8foExHRHV\n", + "G1zEDU1zQBxgvezohOPNh2+AtNh1oqo1rlbEHNCqxlIjxYqcJZpu9upJI6VMFK4VoNf4wcRTK+au\n", + "UmhVaDtD22mII/v9TEusW4F1nqoS9JeeuqooaqKIQko13o9EFTk8XKCNZdGtEUi2yx2ncY8xcwqN\n", + "tBlNhVIOa6EPp+gqoUzi8HjB+mBJSZkkRiqtMVoSQiamCR/3ODFH1GmTISiEsDiTsVpRm4osa5xd\n", + "kuVjfBJs44RTFmsdQz9g644cC75MTOPIZnvGxz9+g0ZmvvP2N/jX/vmfmROBkiD+01vGfWIYMxdn\n", + "D5iMQq0aVnWFFwXhE+LJCSdPzlCq5vDoGGsUOXh+7l/5Kzz/4rOk4lm4hhd/+Bn6J69z/8Hb+NJz\n", + "cvKAtm3Zbs9plwtSyXRVA+NE3j6hqRx1lXkUnqCMoC0dRe9o2jXrKy947QS6gJQDPlccryqKXmMu\n", + "BnwyVHJB9hZBxlWRlHp8XzAqIbMkhow2hcyeu3c+hUZRpprl4hYh9KR8TtPVZHYoA8uFYkobsgCh\n", + "PUp52qXEDxIpJ8gDUqxnewUpUEiK8NTNtTfLNX4w8dSKuRSRIDOucrSdRBQ9Gy4JiSgjyEyREm2a\n", + "OShBBZrO0G8nvI+MKVK3kuWhwlQVK9Fy6yiR8n3qNlFEjyxH1HpBSCMFxWKxIIYti8PCvZvPY51F\n", + "icK+97TNksSIEBNDv8HompB6IGKkJMmMVYbKgTWSLDLaKGrTUuxE3gdMcYyTRwtJRHNwsEThsCIi\n", + "lGLzZMfDh29xQyheOlgSxOzF/vHPfIr733mLh2+8yjuP3+LG4Q8hSqGuDP1+ZFVPhJSIMVE3lh9+\n", + "4S4Rz2c+8XE+98Uv8/jkm/zYj/4Fmrbjo/fuUh8sef6lD7MdtiipGIctWkvatkZri59G5PEhOQyk\n", + "YaRbrDj2NzE5cx5GRLBEt2LR3ODgqOLh+XfIGKbtFmMjRQpKtWC5WJAZuYFFlsDU7/FjAenRMlKU\n", + "pTKOysKoa0qZZm65vI8WL9A0HdJMNE3Ffjui3ewiqRIcLisutiOIRBEOsLRtwuiEsZnsJTkFsk8o\n", + "E1CiRjIRy/UU5Bo/mHhqxTykgXHqESJSN4I4FdrWkMuEMRKlZq5yZRVCFUoWWKfwg8SYRNGKnAMh\n", + "eEBQV45bt55n0R6R9RuUolCyQ8oWXyTjtEUZT91K6grW3RKpBrRr8MNAY5coJRn8E8Z0QZ1aNpsJ\n", + "1EAOFdY2IBJSFIwqyJKwTqKNQ6oDhBMcHd3B5UzY7GkXgVIEpq64ODshTz0Hh0fU7QH7aUsXaiqx\n", + "5+j4Ng9e/Qq77SUxDtSu8PD+m9y5c5NHb++puwXy/BSpDb4/w1R3+Q9+4S/zS7/89/ipn/4xXnjp\n", + "Fs8982E22wvW+5FnP/sc0/YNchg4PDjidLNnHD3tyiB1g5AapRXSLCmP38EAd82CannM65sTQiOJ\n", + "MiKaIw6WN7Gmw1UNb73zMlY7dttTUjKkpJmip20awjBwdGg5ixbSOSVOGD0QZY+rC3UrGQaL0gUh\n", + "EyGeYu2KVDzeP6btKhp7wDjM7KScPMZYVk1NCBfovKRxHdYcQThHuj2eQg4RISW5RLSKkA2iXFvg\n", + "XuMHE0+tmPfDJfvpEqE0TQM5OGoTMe4Q7UaUHRBa4mpNChasIDMhpcJYjSwWa+b8T8QcH1a5ioVb\n", + "44VhH75B626TkfTTSMieKQqqRqOpcN1jvNdsLs8hZ6ysQM92u0papBLEFJGAjxNKWaxpcZWgspoi\n", + "IkbPdxOowAP/Dba7S55Rd9AxEEPCWss0DmQMRSgenDxGKmi7Q4QynF5ecrHbk/2AwLDf7Nj5wsX2\n", + "lJtHNyhtjRQK70f8xSVn5zvuPjNi3B1+/l/8LG/eH/jK+Rq76fns7UN+/Cc+TT1e8tZrX+Xi4hKh\n", + "LYuVxWjP5eUZXVcjVYdUhrI+oGwfkaOnNYreVFTtAUZc0MojdmLLsruJUZqD9W3OH53Qp1NClvhh\n", + "iyeh/Z6SEipfMHiFVY5iWrb9OVZNKG1oOiDVTNMZMUpCiOzSOePwNs5VaFNom4qsEkYvyamg5BE+\n", + "PqatD+n9JUoJpFBo0WBUJqWAUgktWko2mDSQgqeuFsTx6aeAvl+xaovF4n05DvC++rzfu/f+hWb/\n", + "cbzp7wef//z7J8g9OTl534612/0hbdn7jqdWzKdpJDNCKlhjcJXE1g1GW5yJWAwiBipaQlGgIOsJ\n", + "4wIxaoyU1E0FAkLa44dvc2P1I1gcXX2TdH6BkjVGKQafUDoi0ohUEik86MTYP2Cc9kjRIXVE6Qpt\n", + "E00ryGJEFMPoBWlMGAWrZYUYJ+rKMYUzfJk3Wg09UgqcrdhPAzZHiHMYRZhGLnfnuKrm+eef48nj\n", + "J5ydnnJ+esYLH3qJySeOD28y7C9IRChwcHiTdnkXciAWRX95wXZzRt119OenrG7d4N6P/gziH/x9\n", + "XnrhkywOj1gfdGzOT/mHf/fXSP1Ad7AkxoQWgsWy5fRiR9M0UBIHd+6BnS1ynZLEXFg0HbeZndy3\n", + "YmQhF2zHM+4e3aPuOj790Z/hm298nvPdY0b/DtP2Q8j1ElMkIdaI7NFoKAfYzrDtXwMZMcrQLBLH\n", + "YcVuSJSUGUNAiz0gUVpBVjhnibkhZYHUiVY+h5Q9wt3AGojJMwWPDwMxBYzuEMkgRIWsA33uKWJE\n", + "q+ZpLelrXOOp4inGxgFItARkoW01hgqjJaZyUMIcMQYIYygloqVEqoy2ic41LJyhiMI4PqE2R/TT\n", + "Q3T9LEaC1oYx7FBKgInY4q6KhSfR4/PEYnkHRGCcLjEKsvQsmmNyeYiiYkwjMRqymhPhU8wY2ZHi\n", + "nqrSpHJJCTsQE3VpWVVrtFToEtluHxCGkc1FT4iBEuCtb72OVIp+v2PXB1586UPce+4OzimeZE/T\n", + "RoYycXjzGZrlISkEtJEkAmV3gZQaKT2rpmb/xivcPuqYpsDDb3+Zt78xYbWiajqenD9A95CpsG3N\n", + "o0ePoRTOTk6495GPIg4PYL8hl0KYBnLwVM6xkJqhtIxJMurCfveI/aLjWByij+7SD5/A1hO7+E38\n", + "7hTrHEVacmnwuzOEvzH7uKuGTj/L5fQWuXhKtrSdQrJiCAHvN5hWzZF0ITFNPUquKGJEihY/RW4c\n", + "tvT7fnZljJcgFVPOxBTIscK6A6RJJF9ANCB6NttHrJrnn9aSvsY1niqeHpvFVBgkQkVyziThca5G\n", + "a4GQhpQsOZer8GaNcgKtK5QYMarGGIvWFUVuKezxCcKkZl53gJgz07RFKYgx4eyCXKCEQsgj1rRo\n", + "IVgf3eTB42+QxSXQopTDWEHyPQWNFookKpRKTGPAmRqEAenJKRHjAEiCz0wmgBCU7On3I9N+zzBM\n", + "FG2onGNPprYGkSW6XaHrQ/ZJc/K45/atFwjuki/92ud48s7L3P+a4/kXP4lt1rQHN3HNEW2d0WrJ\n", + "fvOY6vmP8PhLLyOtpnhPUzlO3nkH6wTt8piqrtntdmhabhyt8DFSYqLplqRhjx52kKFtWvbbCxyZ\n", + "ThtyCEhZYaeJLGqenH6Zo8VtKnFIVTWsOSD3Nwn9Ewa7wgpPCJGkMpv+DTpzE6EUOSW0aAiMsyLU\n", + "dSTfs91PKNlhdY0UhlIKu/0pUnaQO1IvUUXiB4+1ljwZkoc+epKYQHugINQaUQy59Axjf0Vf7dlM\n", + "rzytJX2NazxVPLVibmyFwKK0x8c9U8ngPFJpyIWSAwKHFHr2OC+FgsVYgUgdlbEok0FmpH031WbL\n", + "dn+C0GsoE1OaEOM8AhFR0Jo1wlj2+y2qWAoRZQztQrPzG5wtc06ltCinKaMkaovKc2pRyp7oIyoV\n", + "hErEVCAn9vs9Y+6JSXNoVySVaBer2X9GOVIR9P2Wul1wvu+xpuPjn/40BzduoZ3m2Rc/RtVUxHce\n", + "8OwLH+I3f/Xr/MSnbvLmK7/Dzbsv8ODBt7j97A9ha8HBukFbSXV8zDOf/kne+fqXWa4XxGlg3bWE\n", + "DALJPkS6w5tM00RVLSn7LbazsyLTtpQnJ6QwMI4Di3pOvV9rwzhOLIqmq44I5ZSTOPLm219jUT1D\n", + "8IkYJbrUDLsdyk54uUNh2W335HLKxXTBWi9QFsomQp55+MpZmmUilBU5RtqmYZriXJCBaRwQosxe\n", + "6qLm7PRtlgcLfLwgy4hMs++LSA7jFIKANjUxjnPEHx5TSRAfXDjFNa7xpxlPrZhroUA6hACjIyp6\n", + "Yh5x1vB/s/dmMbel+XnX7x3XtMdvPGOdquqq6m7b7cR2xwkRgcTECkJOyBVESDgi3KBcwBUi5o6b\n", + "CHGDhJBAkBvCRUQgggARIQkOKDZOHMvtod3uqbq6qs45dYZv2NOa3pGLddzpeOiuNn36ROnvJy3p\n", + "095rr7Wl793vfvf/ff7PU5g1/TggpcCPHhjJIWNNSRBTlmfOCiE90giUVrghgRjw6YphUMDkihhi\n", + "QIaGsrCkGChMg5SOruupqoDImdXijIvLRySOyEkhlUJLQTKCEDKlVSAc47CnS46qrCjGTIgJIzI5\n", + "Q0gte/chjZCU5bThOT++xe3X1pTVjKZesR899157E10oVk2BNYphGHn0fEc3POfu65/gR/9wxVc/\n", + "/2UuNh9x+2TOL3zuIX/oj/4Ey9Ml9x+csd8dmN1/B/QdzK0z9Be/yuX1BUpkQjUjHHZ0uy1nD94i\n", + "Ks1sdkSKgUoVVJXBzSx22BOcZ+j7yRdcKXwIJJGZaUvwA5u+wyhHaSyb4Uvs2itwDcaClDU5dfTb\n", + "R0itydkyuAMGS1EKIpcUpsCWEt8KggdyR8oDdW3wftpoRgRillirGcYDSo6EtGCMmbKyDO4CKWcY\n", + "u0DIwK57is4KAaQ0fQF470k4hLBoaZHypmnohu9PXtlkPmm1BVJpfMws6xl92GNtQWVmCBlJYkNO\n", + "EH3EyBVGT5O9zAKtLTJDTAEjSpQKuHFgHA2FPeDHSM6J6CUhjbTRUxQrfDwgVWDsJH14xok9Z12/\n", + "xVAp9oc91lQIkREiYbRhkB6lzbQST5mu3eFDTyMEkmIKuxAD5JGkPXbVcFbdp7JP+Mqv/xJPP3zE\n", + "/bc/wdXmORcX1/za53+J+XzFj/7Yj3Hn5ITF/JSybnj79h3arsMWlp/8s3+WX/yf/grbq5Gf/NM/\n", + "zZAuePDgLuUnPoHe9iS1QjXn+Kv3ORjN9eUjaC+p56fY2QKODWk8sN/vCfMFhbUUtsBYTe4DY+zJ\n", + "WWKLhsPmCToHEJObocgSGWApJKmQHLLCFbBvd8goUdEiRcPQP0X5Eec9QgiCj+ScUaohFz1RHSiK\n", + "BYdeIoLB6IJ+vCZnhbYJYsCNLaYsEKkgiQ0xOIyeQ1K4w4iRFaYSVLYgREdt75Dlc0LydO6C2t4m\n", + "JkuKEaUTwUPCvrQxK4Qogf8HmITv8Ddzzj/z0m54ww3fAd92MhdC3Af+KnDGFNH53+Sc/wshxBHw\n", + "PwAPgK8D/0bOefPiNT8D/AUgAv9+zvnv/PbrWltOqgZtUMoSwogXCq3mCBSFbRidAzFQ2obSLrCV\n", + "RWtDLzNKgHcO5zVWzrBa4NWO4D2X189AQsiZ6DPeRZLShHg5BSkYCURyVhi1IKUDVbFks9uTUaRo\n", + "QB6IcTL+knIyq9qxJyUPWRJiREvD6LdUleWTb/4oh6uK4TpxefiI5BLLW29hxMiv/8qvcue1u/zw\n", + "Z/8YX/3yuxzfvs3y+Jwvfu2rzOdbiArz7ld47f6bDIcD61v3mX/iRxiurymPSm7P7xB85gv/+PPo\n", + "ouL2/RXzlLDVnHVd8bUgMM0JV0OPdD0iJPqyIRM5u3MPKwTbzSVv/MBnCYsCuekIpsENI94HrJrk\n", + "i0SQZUkpE30YISVquaILiZSvyFkT4hItK0JI+LTHjx3BKZLUWCGJLZw0DbbaIfXIub1FtzV4p5Fi\n", + "wRCuyDhiMHQuUylBYwXG1FOotwRtDFloRudRtiJFQ06JkJ4TfUTZRPCZgStSWlIWS8gQ8jCV5F4S\n", + "OedBCPEncs6dEEIDPyeE+BdfeLbccMMr5eOszH/X3EPg3wH+bs75PxNC/EfAXwL+khDiB4B/E/gB\n", + "4C7w94QQ7+Sc/ykBsNE1WfYoHZCiptAVQz+ihcZai4tTCSQ5gZQzlLYoJZgXjsyenASHgySEgmjt\n", + "FLQsDhwGz0g3lWxMSc6C0Qu6MWGDnNLfEbiQSVHw/PIRt8/eJsbMqjjDhRaXA1mG35LcIHJC5gIt\n", + "R2yRSHKPkhbouXPrExy2l1xuHlLK1zArhdsLApFyvuLyo8f8sZ/4U/z9n/27fOU3/wr/1r/3F/k/\n", + "/vb/ydc/eMgf+fHPcrQ+Yb8bWCzmfPj+B3gfCYcPmJ/dw9Qrnm9a5rMlF7sN83nNGMGNI6nbkIzg\n", + "7O3P8Cml8NtrfPLIGHj88AOunz/h+PiYdncB9YJbr91HCI/dedxuj3d7unZHMT8nFxJx2E6ek7zd\n", + "vQAAIABJREFU5TLTaIlCsY+SBsOzXKFGza694nhxgvCZZXGLznkQHp8Dw9DhMYg+UZY1s8UcoTK4\n", + "TFlUSGp8nxjdBdaC0ooYPCFMKVNaSdCZupgjo6XvAloUXF0/JlC/sAIYSTli5YxKL3HhCqUkRtdE\n", + "p9Amkbz7bn02fldyzr/l5GUBBVy91BvecMPH5NtO5r9H7uFd4M8A//KL0/474P9mmtD/deCv5Zw9\n", + "8HUhxFeBHwf+4TdfVyg9deslkFqirYbdZtqws5GUPCIWxNwjpcDayfcj6wIzOzDuHTFlhs4y2kxR\n", + "CJQUSFnRKEXvRrKMpMA0QYYwrbpFYvAZN2YUFVLC1e6rlHKB1gtSXLDvR6Tp0XYkIYnREoJHCk1T\n", + "zmlmx2R1xXL2Cb7y3q9wa7WmLE9JOeByz6I+Z6WPMcqQgufDhx/wyU99ioTi7/3vfxNtTvjxP/Qj\n", + "FHWFCyO9a9k93E6hGwHGYeRLv/yr3H3wGtfbLV9jpFAe5I5bd17n3JbE0KOSQSzX3HrwKZ49fkj3\n", + "0XsMuy3HpytkcCAz1xdbxDHce/0tRNkQ+x3F6Zr2/SuG/YZs95SuQpsSYabSlROCIA6IMCK9YJZW\n", + "XIw79ocPWJQRjKQ0pwgsMT7Emkv2bUsUidLO2G08hW44OQuE4JBIZDJU6pyZibj8HsZoZnWF1Bql\n", + "4otQkkBIG2pdMG9WkC1ZRvb7D7F1h9JQ2hlalwgpKNQRkBDSIZREOE9WL3cDVAghgV8GPgH8Vznn\n", + "L7zUG95ww8fkOzKy+G25h+c556cvnnoKnL/4+w7w8Jte9pBp8v9tF4uQBSGBQCOlxdo1resZxj05\n", + "Z2LypAAuOsZxQAqDRL/Qm0eUFvgUCWFyU8xkkBayxuoCrQRSTvFoOWcgkHJmGDyH/cgwDgQHfddB\n", + "rtBak5PGj5ExOCBATnifiBGktpTaorXj/OjTfPDwS2hZklPA+xalLZEdu/4JIY+89967yGxAzVDF\n", + "jM3zh1TljH/7p/8CX/rSl/jw/Uf86q9+nsNhh7WG4D2PP3rEe1/9ClppLp8+pS5LYhCUzYx6vkap\n", + "kovLZwTnCb4nuBEJNCfHLI5us5wtkEmzWCwJIVHYTFkVU85qIcjVnHa7wQ09ViuS84SxI7o9pIAP\n", + "PdJqpFAU0lKLgjLXpChw3nI47CFP4csxRkQyCNLkKS8zIbQMXaTvPH0/acj7bkRIhdElhZ6hVUPK\n", + "ibK0iBeB3inlKbuVDmOgrmbMZ3MKOaOQK2QyyJwJsUcpi1KgtCclT06Brj/QtdekOH4nQ/o7Juec\n", + "cs5/ELgH/EtCiD/+28/ZbrffOIbhe5NJesM/n3jv6bruG8e34mNvgL4osfwNptzD/RS6MpFzzmIy\n", + "JP+9+B3P/e2/8Y/RWhOi44f+wAPe+qEHHM3O+Wizx+VrVJoRosOFESk3k2OfnlPqhJEGp93UJGMk\n", + "/TBi/RaEpLKa0Wmk0JOcMY/kDELGqVsQQQwjQz+QgqEqAtZrBr/B6hJTCGZVw8ZJYk5oAzEkBjcy\n", + "+kQzW1JYy777MnVxzKE/sO87BjGwSmvq4pST0/tcPnrCanWEP0QWR8e0+2vWZ69xdOtN/tv/+r/k\n", + "zU9/kqHfU1iFIHFx+YRf+9zneeetTzObNVTHZwwu8oXPf4HXX7/LmAqOTwrKeUE9L2n7jkU949CN\n", + "HK4vif2eduy4/enP8vXP/X0unz2hLA0xGVar21T33sY/fRcdIuP2wGG3JfueujAIIZG6RAoQUuMO\n", + "W2wKpPFAlJneO2RskSgO+xYhNPPZKVLUdK0gGoXSieQCCINWJ8yK27huzzg+wQ9PmRcrpLAooYgh\n", + "oa3EVgW596TcoZQlpUnRNPgdi/Ub6FTRl9DtHdFP/0stAylfgTgmxsw4JD744nO+9htXeD/A98ho\n", + "K+e8FUL8LeCzTL9Kv8FyufyevIcb/vnHGIMx/yRw5VstDj7WZP5NuYf//TflHj4VQtzKOT8RQtwG\n", + "nr14/BFw/5tefu/FY/8UP/LHTyhtwW645uxIoVWJKWtkqhnHPVqBD4kYIj4dGA3oUWIKhbKT2kTJ\n", + "RF1ZxjgSc6DUkiwzIQaE1ggRyEmSsybFgegTxihgKtskn0FkNts9IQ0YUVDpYwprsGkGaYc2AaJC\n", + "kklhJGSHSxklMyiHlHBwGypW9OaSpV6xufqI+WLN5vkeIypySCzXpwQX2e+2/Kmf+ld5/Ojp1FFq\n", + "DNfXVyilefONexQ2cXz/NqWeGmrGYc0HH77P2z/0Q8SYaduW9WpFURQILSnLil5KHn30NXSCz//8\n", + "Fzm6dcKDz/wBDo8/4M7rn2R97x3i/orU3Gb30Zfo2y1aakKevmO990jrKbUlC6gXDd4bblcWediy\n", + "p+DarNhpGBMM454YHTlpDu0W6i2mEAiZII1UtWTXXrPUkpQzQnfs+w+p7F2G0CKkIOcEMlKWNVIp\n", + "cnIo6wheYK1ms33E0eIeKI9UAu8Eh25AhzQ1iZXPiAjwd3njU2fcecvS9x3Rl/y/f+vxxxnW3zFC\n", + "iBMg5Jw3QogK+EngP3kpN7vhhu+Qb7uM+Ra5h/8r8Odf/P3ngf/lmx7/c0IIK4R4A3gb+MXfcWOR\n", + "SXlkXs/ZtdeUxQJbNlhT4X0gREdKAYMhB0Hbt/Rji3Oe4ANudCidKMoMMuBSAikJYcT5EYRESkWl\n", + "T1iVpyyLezR6jnDT495lBBYtZ8zqOW07cLW/QFqPKkZyTqSoUaLCWk2IPaEV9NuA77e4cUSryV4g\n", + "5ohSls49x42ZUpa0mwvu37pPYdQUjSc0RydHhJj4+X/wCwz9gPM9T589QWtN3/domYlppCklSmdW\n", + "s5Lz20veeft1RrdhtZpTVxXDMBBDoNvvMU1JSgMnJ69ztFxy79YxYuyI3vH2v/AnObn3AHl2glo/\n", + "YNQK25zRXT0l9heUtpgyV41Ba0Xf98SU8D4CGtcPNFlxbCpKsUBZQ1ll+mFLjJG222ELMzVfSSiN\n", + "QqiWEK9QNpGZJIsgMXqkHR8x5gtC7IkxAwKR5qh0hJKzyTRLLdjvRoah42LzPiHvyThAEqMi9BI3\n", + "QnvwxCCJIdJ1B2II+HBgdPvf72fh43Ab+FkhxK8wlRr/t5zz//Uyb3jDDR+Xj7My/63cw18TQnzu\n", + "xWM/A/ynwF8XQvy7vJAmAuScvyCE+OvAF4AA/MWc8+8osyit0CqRsiTFGVkKRNYoKfCDJxOIWaG1\n", + "wDvFOIwIu0UcMnUaCM4hpUQYS+oGfB+I0pCJU61YSCp9wjBoNJGiGEk4xqRQuZic+NIMLSyFUlBU\n", + "9F1kv99SzgvK1uIjpJCRClLy3L/zGZx7ipVrfLpE5B4lA9YYUg6889of5vqjxwxSUKpznj57jMyW\n", + "YtZQ1w3ee954/RPcuXOH3W7HxeVHCCHphwM5C1IeSNEhRKAwmqOzBePYs17fxczmzJolTdMwX66w\n", + "ViK1QY4Hjt94i+7h18EesX38LovidcqmRCRN9dqnyD4RUo9NmaI5Zn1yj93VQ3wYsEWBVBpjLGVR\n", + "AoJ2mBqhlLGoJBiGkXFMLGbnDCmw2z5lHGeM7oAuHQKmPRAySieyPND2gr4FoQ9IpnKVG7a0+0zZ\n", + "SBCRGDusytOvr5hJckSlGTkYnHeMzmELEKJkGB1CVpP9cQikBLtuZF5lQh5Ad6QUgJeXAZpz/nXg\n", + "R1/aDW644f8HH0fN8q1yD//k7/Gavwz85W91XR8FRtWkmJFJoKUlpTi170dJ1BmtSmJMhCwwtmEc\n", + "WwQjIgnAMpmeSzKJofcUyuBCi1BAVohU0DQzunhAG0HEIgA/JKwVhAGMqDlaHLFvN+zDgXEYqSrJ\n", + "vKl5cjlS6QVKeRaLFc8uPmBZLzCqAhGQKVJlQZPfQuSKh1//ImVR0uUDJ0efYnj/Q7rkyFpyOAy0\n", + "3TVam2mjNSeEkBhjGEdHVTbILAk+EFNgcJHt7hoh4OTsLuvzO+jCUhaWopwTskMqCcUcFSJls0QI\n", + "kHc/jY6BZn0LkRLh+TPM3fvIrUfuWt794j9iVlrG0SGlQFlNTJkYE0pp+mEAIckhYLWh8x6k4qie\n", + "E1VHDImqathuL0gkQufJhSRZTRIj5IZhDMRhQ0wj67VB6QR6T0wZHzPKl6QskHKHVDsIkbEfCTpi\n", + "5JY8CsgWpStCmhRFQhqULEB6cpRkYLPtiXGPUhGpPMErkn9lfXA33PBKeWUjX8lE30WUUuQM3a4l\n", + "5kmjrNoZznV4HFYarKhRWiO1YQyB4VAgVaRsJDFGfMhsDx11UyBlJsaBoYdlWUDQHNqRohjQZURo\n", + "PzkwaoPQipQsVjZY5TA60nYtzRysLCgLi0grcr4mxB60ROsKhMSqY8a4Y2HvgoDbpz/A5bMvUY0C\n", + "PZzz5GsfoBDMmob5cokLidt3jhFC4pzj8vISRCanhLISKacvtz7uud5cYZSmrCqkzOjCIKXCaoOU\n", + "GiEFRhVkkUlRI2OPPX2APrTohSW1W0bXUTSnqNUZ8cmXSboits+4fes2Tz74GmVZkMgIIRBC4Jyb\n", + "4uGUREpJlBIdBad1QYh7LtOeGDw+HljOz/D9no+ef4QyHTpopMxIHRFY3KBI2SGEZr93LEQF4oDW\n", + "K/o2kGNFNVMIIn1/jRaGJAJWNuQ8kJMneMOsLhAoYnRY62jHjIoGqQpyigTv6YeBsupQUTG0Nbx6\n", + "O/MbbnglvLLJfF2dMaiETJHdMHC5efxC7uYRuaGwEKMDDbW05GRRRhNSC9EgxOSqKKRBK41AobTC\n", + "qojpIA6JcQwsmorlcsU4XGK1Ycg9wY+IrAhxJKXEZrOlampgD1Gw3e45PXqdxTwhXElQk1qjLmvQ\n", + "keAFpalQSDRLFtWazaPHzOwRLgXOTtd0Tzt8ijjnuXp+QTmfsd8HmmbGbrcDwOjJmyalhNISoS2L\n", + "ukDlTFNVxBxoFie4lOnHESEF4zgihMCUhjA60A1KJnSM0MzI4zNkveDw/ldAlVi3J519EvneP6Kf\n", + "rdj+xs8hRMI5hy4LfICZMQgFmclvxiqDVImcJV0/+bMsy5q4eQgiYeya9cyw2e65OrQUMaOUxccR\n", + "IcYpPEQpUgKRZkSnyXkkxoTVmr4PZJlRUiNFRKgSLRR10dB2F8TUUdfltDkqMzkOxNyTc2YYph6F\n", + "LJi+2ERAyEAaC3IoyPEmNu6G709e2cg3VCzLM1IWFMbw9OJ9Nt1DQkiUZsWqvMfZ8nWshnLmsFag\n", + "pEHJRJYJIRtELlFCgEjUsxqix5hIXRX4EBhdACL1TFLYAiGmlXxInpgg+8Dl1XNikBy6jtJamvkx\n", + "47BA65Kz4zcABzljjMKWBmMkQllyBmuOqMoTiuqYpDNu7DFxhFaR8tRyLjKEGOm7gRAmvXtKCaUU\n", + "QghyhqqqMMZQlhVVuaRZHVMuT1ge32W2OmN08YWroCDnTNd3DJ0jDgPD0JNGBykRxp7+omd78ZjZ\n", + "fE6VA5mEvPoqYz/CsGcXIkenayLTrwIkU5KRiyhtKZvZpJSRGh8CxhS4FNj2e2RODENPzhpyRCLJ\n", + "0aCocGNNiIaYFAiPzJ5aL4ljxeWzRGxL4pAolCClSPCJvsuEEDFGIk0gpQHve0LaYapIU88gKVKa\n", + "zLWasiZ4zaHPdEPG6oqyNCjRsFq8QVWeYMxNOMUN35+8ssk8pIiSlqJcIJKgqY/YH64RoqMplgQ/\n", + "OSMqIcniElVcMboDKQfQnkRk9AkpFLNyhpaKUhlEFtPmphQ4v32hYQZVSqQQGLmgtDWFVRSFJocB\n", + "ox1aOIy2lHbN8fIB1hxTmxOivCbEHT612EqSUQglp6SklJB6xtj1yOwQfiCOGe9alFSkMND3B2Ca\n", + "wK+urhiG4Ru18pTSJJFMmcJWlGWFtVOTUMyS7aFlu93SdR3jOLLZbBiGnvZwIAMuQh4O9LsDXTuw\n", + "v7okSYlqe8TiHN91sGhI0mKrms3D9zk9u8XF80uKogAh0FIiyCgpCCGSfCaGgDGG+foIIRUxw3p1\n", + "RIoZPzoOhwt2/SWyGDhaawor0Ri0rJEyIZPCyhnJWdxQk/yC611mGBVJRAqrUUpSFACBffchPl1z\n", + "vb+iHQekiRSFBDESYph+rWlFWUiq0hOiJ0dL9Bo/ZqrilKwMy9kZ8+ZG433D9yevMNA5YSXEkFGi\n", + "pC5KhmGJj5FDd01dNoQph4AQHda0KBswo8XTE7xGCUuIisJOdd6+T5gYGF0CBS62dH5DZRoQgbKa\n", + "kYaRM2NpD442RSyGPF5DWeOd5s6916iKkn13jRINpmzYXF1ibUIXkWE/MjqHEoFcW/r+mtLUKCvw\n", + "bqTKFnKe4tDCSBghScO8qBik5Orqapoo57OpaSoENpsN8/lyKp9YCw6kkDjnUWqkruopQzAm5Kwm\n", + "JdhuN9P7fPYRq7O7RNdhNDgMhYRn736e88UctetxfUuSitW8pB8dZWVJCYIPSKlJOVMYjdEKJTPa\n", + "GJIAkTNl02DjyOHxR+QccJ3j8dW7WGOADmU9Si2x0jBmBbmikJbsSlwvGcf+hV7esVppCmvRxiKV\n", + "QctIyokhXNN76A8GkRJN9U+Sg9qDYnSBWVUQRKQuJVJa2p3CSE30AyJXVHZFAAIv15vl4/Ddyo68\n", + "vLz8rlwHmCIDv0tUVfVdu9Z3Ky/1t3j27Nm3P+ljcnX13bPd8f7l++y/ssm8d8+oytUUnlwmcg6c\n", + "r25xfXhK7wLO75AWmrokp4IQHGVZ4bJjHCNZbVDpCC2rydcjS4bekVG4YSQEgy0io+9QWaKUIBIo\n", + "yxqEJ4VEjBnhBVEMCBSZxKyuqYoGFxwCQRFPWViBH97jEPeQNIfWI8UAtsB1T1iUK8qypFCO+eyc\n", + "HC2KCDIzq2dkW0DMSClRSpFSImeB95Hlcon3nqIwVFU9+dCYqWGoLiuWq9W0+WnsFLKBQAootEGk\n", + "wHy+YPADxvccNldk7wlaMjx5l8fjGefDJebeG/jYs/OZcb9DGzkpX6Sc3AjDNNhihLIsMVkhqwKQ\n", + "2LihEBJrS8YAgxRUakY7XFHbjNaGqtAoWeJdh5AVfkzoUCKyIOWOEBxKKFKIFHVJlJGisJA0WRVc\n", + "7yRJ9Hg3ZcEiAn5oGYYdh93UF7DZRNbrmihH6jqRhgofHIYjZNbI7InCk+RNOMUN35+8sjLLYXzG\n", + "OOzRsmG3vyCFgJGKUlpiHGiHDSEMSCzkFZIlQjmUDS9WkRKjBVooclIIKqIQ9H0meEdyCZUbok+0\n", + "7YFu3NENLSkFRFqDtiTtUAXsx4RLI7aS7LpLQgBlDNebZ6hUoZLh4Bb0PXTDQNt1jC7g0xYpB4a+\n", + "w2JYlifEMEL0jH2HmvrjsVYjlGa1WFKW9sUE7qiqAudGZrM56/UapRTWWubzBdYWlGVJ0zTUdUVV\n", + "F9RVRVkWrFZLpABNmgI3hIQYsELQP/sS3gea0/vUp8cENzJ+7TdwlxcUJnF8dkyKAiE0+UUNXghB\n", + "CB5lLdLUZKOIo2PY7RjGQFPWfOrsDT5z+oOs5BrnI5U9xsgGKzUpRVLwSCwhOqQY8akj5oEYw+SZ\n", + "IxI5Z3rXEn1Pzh2FVZAMUBKGGikMs6rCao2LnkN7jQsdPjpUnqPyOU31AJEMzSy/UL5IgpOM447E\n", + "FiHCqxrSN9zwSnllk/k4Kno3TE03RcXBP2fXXWLLBbWdUYiSIhlkNhjd4J1g6AJJHJjNFIWp6HxL\n", + "58ULP5CK3gl8zoxjnjTHTjPT53RuoO1Htt2OlAMxJlKqSAR8bolqai8Pfs+jx+/RjR3DuOfJ5W/S\n", + "5z2BPYUq0OqUnAuqas5idTJtAspIbSWFMIwxgBBYI9HCIIUE5fDBo01BcJGmaV6EOEx182EYODo6\n", + "pmkajLEsFguWyxVVVVLXNU3TsFqtSSlR1yVVWU1yRiUJfiSnkfawYf/8Qw6bJ1SzI1qXWaws/cMv\n", + "cbh4DBL8cI01K9yw4/btuxijKasaLyGQMbokJ8847nDDgMiZommo50sgc/A9lcicL1fMixmFKWjq\n", + "M+ryDm03MroRckFOCp9HhtjTdR1aSyKJbAZ6d8AnR+96nN8R04CSsLT3EWFFJStqs6As5wxDIsSA\n", + "i5Ex9tRVRX8AFVeEkMliT1Fpcta0B08/DlMqVbpZmd/w/ckrm8xVsad1zxlDj1GWMQ54RgbvULmh\n", + "eWHMFNpIHAUql/ggGHuB0Zp5vWa9vEM/PEVLS9PMUGJO8BCTQaaIlmekJCjNMX0/pQ5tdlf4MDJ0\n", + "U0BzlOGFkgJk1hRa4n2P8z3b/j2e7n6ZNj2bYtB0whaR5dpitGZWNQgGlBix2SKSIoSRvmvRlWS1\n", + "PqYsaqqyoa4MKU97BKenpy/KLZnTk3O0NpRFTVlWzOfLb9Q3F8vFi/r6nPPzWxhb4GPADQO+7ygK\n", + "i1aSHHo2F4/oN89xQ0cWOy6fXyK1RC5WbLdbZvMVfXdFTop9e6CsGqqqokAiU8LHEWKitnN0WaFM\n", + "Tc4SKTIzW/HayTGiUGy7A4dwjdSS9foep+u3+OF3fopV/YPkqKjNbYYw9QREIRl6wXDIGK1JMnHo\n", + "Pe3YMfiWbfsEFx05VKg0J0tDQuHGxNinySVTJJQSDGNHqZe4PkI4meIGbUYg6Hs4bEeyAyVeXgfo\n", + "DTf8s8wrq5lnRkJoaccrpJrc+vbdASUENs/RcobMEXe4IAwF8/UMkRy2qPFOcLw84nx9i97d52r3\n", + "LhlHXdZcXO9Qac6isIzdNaZYYJSG1BDdji73RPGYQzfifUKbnqqYMatWCD9iTCDHHiMrUk6I3EMS\n", + "JDWnEGuETrh0TcUSIzJd6PB2wd7v0C5wtLpNERua9ZJu3yL0gC0X9D5QlCXHx6fs9xuEUJyfn2N0\n", + "MXnRBKjrCq0nL5emaUCISUoZJsuA0hqCj+zGHjcc2F/uifsrTFNTmcyYEjkllmXF5uIZsh9Yv30L\n", + "u0k8fPgh50crDruIUXpS02SPKaYUH2KcJIOEacMYIERyCpRVxdX1BQs7Z1lVqEMmBkfXD9y5/w4P\n", + "7n6aW0fP+fDZEU+vv8zobtP555R1QRg0KVn6Q089t1RVjaXA9zt6OWnPiQ5rNGUx6d5DFORcQ9Yo\n", + "lXGuY8tTvEsIPMiI1gKpAqaIBDI+wHa/4fTo9Zc6boUQCvgl4GHO+U+/1JvdcMN3wCtbmUspGeKO\n", + "Xf+cIbRkCVFkrg9PEVlydnSfVXPOzgMUiFBx+/gtrD4mh4YQE01dsqxOqMolhTKUBVhtmBU1RsL2\n", + "4n367oBQkvOjO4hsEUrRDVcIlVGyIqcarStyBpQmpoGYO7QSvHn+rxBCJkbNOB6IyZHZItgi2ZHT\n", + "gIuO1reMwWNkxW57YPQju+sNUkJVlSQSVVVxdLSmbVv6vufBa69T2MlD/ezsDCkzy+W02SmEoGlm\n", + "CCG/0fo/jiPBeYQAlTPdboPbPsMdrtg9fUS/n3TgspC0uz3zWc2tB/cZdwd6N7CY1XRdO72fHEgC\n", + "2sOBoe8JIaCUQSoLCIauxfmBnNJkpxAipa04PjrBKkN0jhh7nl9+hFaak9NjfvwP/hgnxyuEcNiy\n", + "Qss5xhiqQjKvS2o9ZXWWuWaml6zMOTkavEsoqTlaLybjLy/oekhpgUgFRhXEOJLoyHJDCIHRO1JO\n", + "ZKboOm0SznuUiuy7r77sofsfMPkOfSvL5xtu+J7zCnXmCp8cXXjKvn9CSiO6iEjrqErN2eltzm+/\n", + "RlPPGGKLyBUiW+bNKdrWfPjofS62Fy9kiglkj9QH5tWc+bxCK4cQkcvr50gKZmbN3aN3kHGJUTV1\n", + "XVAXlugs2+sW7xJQkUXmcvtl6rLi3q03acwD3BgZxhGpYNmcU4gFOb8IZ7CSy27H9fgR+9hO8WdC\n", + "kFLi+fOP2G0vUVpRlPZFt+ckE8tZ4tzUEWqtJeWIkhol7YsgDUFV1YgM+90U1tH3Pe2hRYpAe/mM\n", + "w9UTri+fUBWGan6KqRt812NFRMXM5vo5dVHQ7w+MXUs/uBe5q5oQM9Mic1KyuOBRymJsQ1E12KpB\n", + "KEsQGo9EyZKtcwxa0HvPZnNJzh3vfvgP2e4umDUNb7/5gygaYtpTlwadNVYbqsrQlAu0kFhqGBQ2\n", + "zyjDAuEsZVmhSzBFQYqG0AUqPWNZ3mJdvc7p8g209qTUkeWWKA7EKMhoQkx470hEhFFYG1/amBVC\n", + "3AP+NeCvAOLbnH7DDd9TXt3KPBVIMgSP8y0xDUBCG48yEWs1R+sjbNNQNoE+bthteiQFOiuSMHzh\n", + "vZ/j0bNfRxAZ3BZjBbdunzOrTvAIhJLEsaWQhpQis3pJqWsK2ZCBnAM5KMYh411i9IkUM/vhCdpK\n", + "Kltze/1Zcqjou5HoMwRLyhVSzEEI5vOau6enrOx95nLNfL5CSoOxllt3H9AsTol5UtQAOOe4fese\n", + "MXqGoSfGSEqJ+WzJ84tnDEOPcw7vPdZO1rjTRN4xDCPGZLa7LfP1GmMNq6NbdKOnWi0RerLHvXr+\n", + "hN3+CbOyZL+5Yr1c4NxkKVyXc4SySD2FUsQQURKqwk5NVDmSsoAsUVpTVQvK1THVcsbx8hbnJ29y\n", + "tpiTGMgy8OjZe3zhvV/kqx/+Ko2cM1sek8JApQxVXaFziUwag6Exc642T+h9h46GW8V9TC7xIVGX\n", + "S1IUeN+Tg6bb7PBuwKiKs6O3OFt8CmUUQQS0hnpWMgyB4GEcPcpmlEoI81KH9H8O/IfcOMDc8M8g\n", + "r2wyt2JBoWqkfuEB0gZi8IgXpZbej8SUaeolUsOuvWR/uMYNnhQhB/BxRxi3HPpniNhwfvo282aF\n", + "1gKsRZeCwiouth/h04gLPUZrNAoCGKMxKiJyouv3CD19Rl10XGyeopSFLDlZPSDmERlhdAdkhhw1\n", + "Ri8orGRW1+ScsErT9h1d1yKN5b33v0ZZ1hRlgbGGrt9jjcaamrbbU1UVbdsSQkBKRYqJmDxt22KM\n", + "YbPZ0HUdUkq8c+TkuXj2mPKFCsb5ESkU0Xu6riUliZCK2XJJDtB1HSpB13fMFgs6NyC0JCTIMeBj\n", + "ImVB8CP7/Z7t9SXRj0iREClBUZCtJPQdYezQEpRUoDKZjPcOhOALv/k5ujFCCtw/fgMmjwlCAAAg\n", + "AElEQVQfBM18gS4MQQ7E7BAqIynRlWbMgSwypSk5qtfMyjVGlBhq/JBJXhHdyL67JsjJXXI5f5PK\n", + "HqPEFFEXQyAGOUXO5Txp08MUmPEyEEL8FPAs5/w5vs2qPMb4jSOlm3n/ht8/KSVCCN84vhWvbDIv\n", + "OKNWJ/ihwLtEcILdxpG84tn+Me144PHFh1S1IeWBftgypAPX2w1aLhiHKwxryNOm4P3br/Pm3c9w\n", + "5/wBBz/ikkcvC5p1pPVb9uMFl/sniBwxKWNSRCpB1j3WTi6MOW0IeaQ0xyQ5MMaEFJJVfU6t7vH0\n", + "4hH73QV99xxyhDinLs5IemAQB3LyxOgp64qL5x+hlODLX/48w34PUnJoO9548w3KqkApxXK5JMaI\n", + "tZayLNhsNpTl9Jx80S2qlJrCqGPEDyN9u8fvr7BWU9gGqSWg2D7/CNduqNcn+P2W1eoIVKZqLO04\n", + "0MznrFfHpBgxRpNzRiqJEBkpBCm+sBbICbIgEXHbDbnr0RK67RXD1RWLouD89C5alTjfMw4j7fCU\n", + "rz/+In1IvPPgR/jkG3+C0tzmnTf/CMdHdymakjZcYEtJlrAZ9qCgsIb1fMV6vkC8kJLmYOj2HiVr\n", + "Dl3P+4/eZUyaWXmbu+sfZWHuIbLm0Pb0w4YYHdqAVAIhFDnalzVk/yjwZ4QQ7wF/DfgJIcRf/d1O\n", + "VEp945Dyxvjrht8/Uk77Zr91fMtzv0fv6Xcg8oKU5qRYEcaSsZO4Fq6fJ/re8+HTX2fTfkjXbXHR\n", + "M6bI9vAMGQ1hsDTFLSpdEpJmuTilqdYcr844Xt5GSIWWDTJbslkgdeIwXLFpL2nbPZ6A0DVlOePs\n", + "+Daq9BgrCB6kKClNxdht2R0uqGcNOWvurD+DMceT85/UjONzNEfUxetkVaN1phdTLmmKmbFrOT+/\n", + "zdHREUJknj95zOn6lJyh7w809ZzNZoMQAmtL2nZ44XVuqKqpq1VrTYoRP47sN9dT4k7MjDkx7K5B\n", + "CEJyiHSgmS3xoedw/ZQoLd4HYsjknDg5OqE9DJRljU+w71qCd4RxAATtGDBGE7wnuoG+3xN9RGsL\n", + "pQapWR/dxY8d7fU1plyzWCwRXpBTIPrIP/j5/5nnmyeENPLpN36Yo9WbNPUxb73+Y5yf3GYxP6IN\n", + "HdrMaMqCp/0VwxjwOJI/4NNIZjIgWx8dc7L+AY7nn2Z/2PPkySNc1yJINMUxMpZEp8hJInUg4xDC\n", + "I03mJS3MyTn/xznn+znnN4A/B/xszvmnX87dbrjhO+eVTeZ9H6jKGcvZEa4zyGRxo2bop9b+Rxfv\n", + "cnn4kI37Iv24JYZEJiLNVI4pzRpBxdHqwbRSdyN953j67BKjJcfLOcezY1b1kpP1Gq0zMTo8PV3o\n", + "6XNHGjNGNTQzizYFMUhmsmFVntEeLgjjNSLvQUSsaThdf5IQSpANQp5OP+99Q6PvUpQ1STl2fosQ\n", + "nrOzW1xf7TBqxocffB1b2Bf68UzXdTx/foG1lqIoKcuSEDxVXXE4HF4oWDJVU7PZbtEvfFP80KJk\n", + "ZOhbYkr0Y0tOClOv6MeBLAKlEizPTqCyLFZr3BAZhumLIqeEVpr18Qn9GLne9+hy+lLLGWxdImyF\n", + "EAqpFFIr0uiJYSTGQGUthbBUpuTurXOOV0csdQVKYIj87C/8j2z2GxbVkgf3HuDbiCoM9fwUW2qs\n", + "Vfg0lVj+P/berMeWLD3Pe9YQc+whd04nzzlV1dVd1d2kSYomRdm0RIm0LAK+sOwbD/CNLnznP2D5\n", + "D8iA/4Bh+IoQDAGCIdoCfGGRht2WmzIpm02y1VPNdaY8Oe0p5jX6Yh8SbbPJ7ha7dEh0PkAiA7Ej\n", + "YgGZa3+x4ovve98xOJ75Lb0bGdxIP3b0pkfmCWen77I4WnF68phEL7B2y7r7mG1/hVeQZUdYZ0my\n", + "HCWzP1r9BgzR/Sub0vfVLPf8ueK1BfNmu2FRHHG8qFnU6SFdEqCsSiQpeZETfECIQKIUZaFZLo55\n", + "evcd9vYGGydmVY0Mkln9gCeXT/nN3/p1Pn7yB4TY4BOHSgSJTtBCUZcZVTlHqBwTPMZ2DM4zToZM\n", + "VBjXIEJKP/UgAlJFxvGavrsk9Fu0DAQjWS6+SFF8gfniEVd3z7m6eULfOZAFg5goypooEjyCo6MV\n", + "L68+wLsGHQUhHnLMiMB68xKlFMfHJwA4ZwivcqzTNGGNIREK4QNt16ATzeXVC8zYI7zH2wktC+Bw\n", + "c6vnC/Jiho+CYA11XjBNE3mZE5RgMB37tsM4R79vKaqSqihYbw/CX6vTc+rlQ4oqoSgrRJIyDSMx\n", + "gG17unFi01t2zQ3Nbk9dzTm7WKLKGViBo+Du5RW/9bX/jX3T4yaHLiRXm0uKWcby9A2klCRxROcD\n", + "Mh3pxw19GDDOYLqBfbsjyTXVckFRzdn3a+q0Zlas2LV79v01LvTEYHBGo/yco/IhuZzjncQNKWH6\n", + "7Kd0jPErMca//ZkPdM89PwSvrWlIRHGoFS9OWR3vGKeRFEmVZaR5RhgNOp2RqTmNNWilcM5S1hVW\n", + "3DHLF1g7IZXHO8vd7pZd+4KiUDw4epu+nUB6YtCHR3AhqHMN6mBZNowtWboHmxPjhHY5/djSj46J\n", + "PTqL3G4+QMkZaVKy3n1CsDWZyiiygkLVLGrPpy8+YDm/YFbknM6OwWbYqWe92XNUH7NaLhAyBQH7\n", + "7Ybt7R1BK/IsJ4RA1/as12tWqyVpluK9PbT5W0dnerIso2l2yDyh0AX77R3CTZSZRMoEaw+iVVpG\n", + "lExJT1YE29L3PUIryDQn84dcPf+Ui7MH3G02LOoZu2YHwPHxMUk83NWd61Ayw8mArkoylRKmgegD\n", + "U7PlqK5IhCJxEZDEPKAyQ+wlbrR4H/l/fv+rLGcnPFid0fsOaQzjDqpsxdHynIYNk9kz+IBKAplW\n", + "iGlARUeZKYJwKOkBQ4iW7f6W+VFCnip8dPg4YK1DxCVhkBgdQUB0GWMniPqzK028554/z7w+oa3m\n", + "Uy5fbPBeoXTN0XJBXZRk2QwhDlZhxhlCzICK29sBYxwET51qrBuZYsfN7gVtt4OQMHYGXOT8+A3+\n", + "xi/8p1zfTdysd3z64pbru0uyNOF4seRoccZ8CfMqkBc90zBhfMpgJ3rbcbNf0w8TIRE05pbWtHRN\n", + "w93mBfv9jvXtHW2/Zp7UpPqI6+srjA/EWBKUpxnuyNICIaGcrajqOev1M+zQsVguyZWmns0I4bDq\n", + "VkqgtCBJDp2f2+2aptvjnKOY1fjJsds1ZLnE+YAWka7rSbMEKROm0eC9R+clxlmi0CRFztiNTP1A\n", + "s2u5ePwuzTCxWC5p+gbcxGxeMnQdR0dHBKUOphtKo5MCbMRlCfLRQ9TqhHRW8/T2im7siCZhnCaU\n", + "FGRlgrOOwUXadkSh+T9++3/ho8v3sOOeenlMXq4QISf1RyiT46YZfR8YjMd4S5ACEwMqVRjTMdoN\n", + "Xkbm5YrT1RHjtGNwLT4qhmkCJSlUwjhZumFCB42fAlMvaLf32Y97fjx5bcF8OZ8jYosdJYv6TY6q\n", + "Yx6dnFLIyKp6RHAZkxmx1iCUwobAvm+xYcCMB02Otu242nxEPzbU5QnEAjM5ThZfwkwjP/H458jz\n", + "GdFJoq+ZjKd41R1al4KssszmnrKscdYc1BeVpe9HgsvxzpFmMDqDC45m13D38pLnN+9zc/chOY6F\n", + "TOiHgX17Q5KXJNkSKzPQEnTGy6sn7JuW46PHtO2Wq5fPXpUbHQSh0lSTpinDMBBC+CNPTji093dt\n", + "e6jA0XB9c8M09uw2a2JUmMljraWsC6TMAUGR5wQi+13H6vSMtKhxpmfYXpPVM4a+Y7FcYaPixcuX\n", + "aKG4Xd8gpEblKaosIJFEJRH7hrjdo7DUWc67bz1kVZ6S5Ss0pyg1YzZbsDjK2O1u6DvDsBuo0pSP\n", + "nn+D0U0EZ6nzHEIgBkUkw1tNDOWhQUpbRjfRu5EgPFpG+nHNvn+OkAPHq5w8tyRKAZYQxEFoTEpk\n", + "4okYopQQC4iWNFOva0rfc89r5bUF8/myRhYWT8c4OOpqgQQWs3MyPQeRs2tb2vGORa05PSkJwbDf\n", + "Duxaw3bXgZCMdmC3vyHBkec5u13k8urbNP0W53rKDOpFBlIiDDS7Dm9HcIoYPTLRPHr0eZROEHLC\n", + "jAdl83FscYODqEjTCRcldaKZZyAj7NuOm6tPCK4n4CFabtefIqSmPlpiR8ftzXNOTx7ivCFGQ1kV\n", + "VNWhq3NWzymrHOct1jqG4WALF0IgSTLGccQ7jzc9Wnpc21JkOYnQJGWNkgprJ4oyw3mJcQYfHZMZ\n", + "ETJlvlxyd3fHNHbMV8e4NMWPDcY6dtsdq+UR9WLJECLeetxk8SEQzQSyIEqNzBJie4e3jnR+jJgC\n", + "75wseTCboUWOcnPOTt/m4uKCxWmFUIqTk3OO6hPmecnLqytkSJkGhw4eFwa8CKRZTpVUlJkmkxWz\n", + "uaaelcToDl6ipuPm7mM6d4MuBIvlA+bLJVW+QCEJwaC1RWtHmhdIIUAY0pmmWLx+c4p77nkdvLac\n", + "edAJJ8fHbHZrJqeQ81NGEUiDJwP6bsILxTgZlsuRNy9KtoWk38EwdeQk4AR1fnpozEkjRVEwtpKv\n", + "/s5XODk9Ic0DuYbjxcFrcjf2iFbj3EheOYryiNn8DfI058uf/3n+72/+7wgSkgSS1CPkHJ1EYhhB\n", + "GOqy4qhSLDhiDBnNtGN0gUwFlPS83H1KNTuljBXTdMvF6UP6fiC4ESHmXD5/gk7uOLt4m8Ia1us1\n", + "x6sTpJQYHwjhUCIYfCDPS5x1ZDKhGbdgR2i3xCTHdD3l6SkhRIwxZLmmyA5130pqlFa0TU9RzhB4\n", + "ttstVZHhjSN4j3EjKnqkSJjVOfiR6AM6nRFxxOgRWkMxA5WjgiVYS7o8ZXf7gjJPEX1kMX+LZb5E\n", + "n0fW7Q0b3fPw/HNkWYUxI/10ySfPfp8qnyGFQ0pPXiQY16OTQGTE0VHlFd54Ji9QSYYPllzD1K0R\n", + "ZUKqZkghKbMVRIvxHVFZZtLShR2jCcyyCqSnrH507jz33PMXidcWzMuyJApHMw1MnWVRLbAY3OTp\n", + "GYgiJbrI1DmsbcnzOUdlTRUVPY7JWcZ+pC7PyKQkTQWPT89ZZoKPPvqQp09uWZ1Jjo9T5lVK9ClG\n", + "S+6aFi0EBkWWZ1xdP+PR2SNibJiVC5x0qKwhLwTBHRzmbQgIBU6MCErm1YqT5Iypu+Hj5x9Qleog\n", + "gKUmds0T8uqLFCczNs0e8OybAeg5OzshSyom05Nnj5nP5kgpKYoCszN4J5B5Ql2VCH9YZacJuLEl\n", + "15Ht0LEqSkQ1R7iA1uJQi+48MRUkukQpQdM05EVKkS/YbjcUuaZvenSao/ICaSSb3RaUIEZNVc+R\n", + "WhCFAJUjgiBIDTGCMvhmT4yeAsHRyUOePn+ODYLJBfCKMj/ltK7I3okIPyJiBVgQnslMdH2HcwN1\n", + "nWOMZxpHgoBgHKnrSMaEIDR5ek5eBpyfwI5EobnZr5n5llX2JsYPqNRRxhMMd4zGE6ykTAs0Oc55\n", + "Jvf6V+be/2hewn6/jr8fht/93d/9kV3ra1/72o/sWj9q/jBF+aPgoJH0F4c/Nc0ihMiFEL8thPg9\n", + "IcQ3hRD/1av9KyHEbwgh3hNC/BMhxPK7zvkvhRDvCyG+LYT41T/p2jmWRbpkkZ+TqYgWEm0CVZaT\n", + "ak2dJCREtBeYJkPFJYKEUsMs08wqDQqULHn7jX+LYBXzRc0bjx7xM1/+BdApfSuxRqFVitYpgoSi\n", + "1AQtMK7m5m5kvd/z5PLrrDfPmKeKsi6Y1Uck+qArbk1gGix53dGFls14h/WGKgsUKkEFRaZyJBKp\n", + "crr2hilOzFYrjO2w3iC1R0hD2+y5ur6hKmd47xBC8OzZM/q+J8ZIlhWM03RoHKpnByu6PCdJEvbN\n", + "lsXqjGGwzGc1xluUTCiLGQDjOEKMtN1AmmdkacXV1cGLsp8ceVURMHRty3a7xRpLu75jGvZ03ZrZ\n", + "8QVCa/w4wbIikiJ0CkWOms+YvORyf8XYtCyqORGFnw4t62MfWZ2+TZYKvFzjxXO8vKaoAlnZkRcZ\n", + "/eTZtZZ2GhkGh3cJUOCMABKM9QcvUr1gPjtF6Tn9CF0fMK6n6y4Zp5dIkZPqc2R4g5PFuyRJwTQp\n", + "pFTEKBibz6wD9J57/lzzp67MY4yjEOJXYoy9EEID/6cQ4q8Bfxv4jRjjfy2E+C+Avwv8XSHETwL/\n", + "MfCTwCPgN4UQX4wx/jGBijqVFIVGiYBQOV3bM/aGqAbqcs58ucRKA2FAiwJrcqIQdFNDVitEVKRZ\n", + "ZF7mrx7RPcq2LBYXFMmKo5cz+u4O0xbc+sis1GQhoRM7MpkTY4qZBM527PsPKFRBLgqy5BgRC6IP\n", + "jHZHkiSU5emh/nu+oe894/rbGB+QUYFSzKpjlHCMcodMZ+ztNekEZJJp11LVx7T9HiUyiqoAIt55\n", + "rm9eUlYliIiSMA4N1gUytSDTiiDiwZIuLciWxwTnyPOMvh9IEoUPHust+axiGAzt0FHkGmsCu3F/\n", + "0EQH+rZFRIn3UM9qtuOEEa+qX4xlVmeYsUU/fAgx4AeHPDkh2B758o5oRnRRcBHPuY0bapdT5S8Y\n", + "x47NYPHeEJVHxhTXdUzBQKzwk+Xs+BhnBXOTY6yFwVAFiQsBLw1JkjKODZtmIJEnnK48IVjG0TFF\n", + "Q1lm6DTBMpHJh5T6Td48/yLjquPZ5QecloEp3aBUgjGBTXcfzO/58eT7vgCNMfavNlNAARsOwfzX\n", + "Xu3/NeA/eLX97wP/IMZoY4yfAB8Af+V7XjcEmt0NUvlXQlp7nry84ur6jt61IC2pztBFTj/uGMcJ\n", + "pUo6M3G9tew7MD7j6dUHbJtLurbD+Y522tJ0az7/4ILTozOmaWLoe4TNyHRCCrgwYIynLo85rj5P\n", + "oY/QgIwOH9cEJtpmpGsNSuY4K8jTisenJywWc9LsmHby3PQ9vkhQWUImFMoNxNhxe/sMT8RHhUoK\n", + "RIzM6iXDuOX05BTrD23rf/g4XpU1RVng7EQqIwSDGRuyRJJISLTEBU/X9/hwWNG3bc8wjoQQGMeR\n", + "qsjJ05ymaVFKveoqdWw2G2azGS9fPMGMDS+evyArUqy1SJ2SFBlBCcahRQ4GLUDpSNzdEXY9ZAnI\n", + "BJTm5e6aXEmib6nSCZt8yN3uG+yGb9OuG/rbGZvbhLtrz83VjmiXTINAKk9WGnzoSKVCaU+SjCQq\n", + "oINj6EecL3l0+pc4Pf5ZrJc09payFhwtJEWSEEbBsjpnUZzy+Oxd7BBpui0yHQhMCOkpq5S6mv9L\n", + "fRHuuecvOt83Zy6EkMDvAl8A/psY4zeEEOcxxqtXh1wB56+2HwL/13ed/ozDCv2PMcaUu6tLdFFx\n", + "NF+x2XrWTaQb13htqKoMhEIqGAbBuvmEL7z1JZanb7De3OBjxn67JpUjlzffIShD0zuMeUK/V5RJ\n", + "wenROXfS46PFhAkVC2SAVEW6yZKmOXWeU+c1m923maIhkynB90ilaXaOOvEsVkt6e02RK+aLU2RV\n", + "0OwtfWwQRaB1G8ZxwqQeySU+KdmZW46KI+bzE6x1vHz+hEcP3+H2bsPnv/RlpBCslqfMF3M2myu8\n", + "DaQqIa0O/5I0FbS3axKpuGtuiVHjw0SiMsqypMhSnDE45w6ljq9MLfLskMIpq4y2bfHOcX19xYPz\n", + "x2x3WzKt2G+29F2LmSR1PUeKjKJcQrREWQAp+BF9dIp40RIXCxLjWa3Oubn5lM53qLSj3TynHywi\n", + "rsil5G4zsNl6lBJIJLc3WxI1J7F7rLuBtMBMEUGOk4YwOZpQEaXgeP6YL3zup3nn7bd4fPIlPl3+\n", + "c26uv4r1OaPNOT1+gxeXT/jcX/5FqiTnwdEF33yvJdAgdY91FhsFaX7fNHTPjyc/yMo8xBh/FngM\n", + "/HUhxK/8/z6P/Ok6Fd/zsxaHSSqCdDxYvs3p4jFSOaJXbO76g8Sra0icJlcnmKGgabYURcHDs3cI\n", + "qidN58zUnMAeokCKFC80+2HPaCNFekpVn5AWc6QusEHgRQ4cNEzHYcA6i5IFSXaMTkq0PCLVR0gZ\n", + "kUKTkDJsBdNWsl13ODEhdECmltlMkmYGY3uuh1u6YYsPlijvaJqXr6zZcsZxIC8ymrbj9PSU3d0d\n", + "eEeSwDB2zOo5hZaMQ0PEMKsy2v2WrlmjhEDGESUMaTrj9u6Ou/X1IWUhJfaV2cQ4jK90XQ5qfbtt\n", + "Q5ZkzGYVWgS6fkeWJOy6icEY0qwAIEmTQ0lkkkGUkBeQp8hiSdi0+EwQxwHcRDe1SJ1wefcBSufI\n", + "bs7TT3v6vTpIz8qJJDlU4pTlDJ0kdO3EZtvQdgHrDU71uNJyMa946/SCVVWQMSPENU9e/B5X1zco\n", + "Ldg3W4SNFDLyePkupaqoy5yvf/gVggocH81YzTMUCVoUDF3Hvtkz2e0PNPH/ZRFCfCKE+AMhxNeE\n", + "EL/zmQ52zz0/BD9wNUuMcSeE+J+BnweuhBAPYowvhRAXwPWrw54Db3zXaY9f7ftj/PZX3idP5php\n", + "QvzcHcw8i0WKaUELgQw5WeqR1vLg+JS6fIPN+D5FMaNUFzzfv0eaWGblCRJP1P5QZ97cEuIr9wCZ\n", + "kZIgk4rBjGQqp8ofsG+f4OkZzMTm+Q0XR4+JQVPmR2g5Y3KOurxgt/uAbX/HMj+nsxLb7/HG4pKR\n", + "yQrOT96mLAs++eQbZHJO144oFSlqQVJNOGHo7j4i0wUIwWKxZLtd8+47b/P82VPKxRLfN2zHnrpM\n", + "qQrN2DV80m45P14xJhGhInkxYxgnyjJBMgcChIDOMqQ61MtHAbPFgk+fPeHB8RExKpyPlNXs0B0a\n", + "QArBos6ZppTb62dUqaZrt9SzGUIKQhQIAlRzEHMkLxFjTkg1od9xtbtj6wekWiBjIFFLBvMpVbJA\n", + "o6nSgk57hBbkaUYljnBiYHI13bSHxHFaPODfeOttHpxVXO17Pr5uudze0N7dsW3uiGywoeE7z36L\n", + "i/mMk0wz2mvK/CFZ2fHs8kM+fPpXCGMDWmGd4cX7Lc8+2OKjJIofXQXIn0AEfjnGuP6sB7rnnh+G\n", + "71fNcvKHlSpCiAL4W8DXgH8M/J1Xh/0d4H98tf2Pgf9ECJEKId4G3gW+5+rlF//WY/7Nv/kFfvnf\n", + "/df5t3/lb6ISwdFpYH7sAEfwAtNIlCwp05TT5ZLz5RtcXz9BxsiXL/4aVSnQcjxUfOgCKVKiP6ww\n", + "+2mLCI5cLRFBIIMkmg68ZLV4kzSpQAxYE3FecrvbIMmp8xWRhlTUvPvWL5CXJbt4wzB07HeGrnXc\n", + "3t6wvr0Gd/Am/Zkv/CKzVBMmz+464EZPVD17d0OxWKGznOXynIjnc5/7HJeXTzk+eczN9TPssKPM\n", + "JG4aaZsdZZEhvKfvtiQU9H2HsZblckGWJehEIqUkOMN+e8vY7djt9ugkZ7SBs7MLbm5uSZKEbuwZ\n", + "pgmd5Fze3WJlYDSert1wcnKKzjO8DwTvkd4gMMTZMX6I+H6H0AUxSkQcUHnBO4/eAVmS6zc5W7zF\n", + "oj5Gq5zN/pb1bsPgLLM8ZV4IssSTSMGquuBk9pPM1BkPZMW7eck8AdN17LZ7rtZXdJs7Uhuodc7g\n", + "XrJv70hUznpcczvtUaVEyZbgJk7mS/7gW1/lvauPKOrHLOt3uHh8wi//jS/x13/p8/z8X/+eWb0f\n", + "NfeWcff8ueP7rcwvgF97lTeXwN+PMf6vQoivAf9QCPGfAZ8A/xFAjPGbQoh/yMHw1gH/efwTijXX\n", + "t3fkqWBZPuTN8y/z1sU1m83vUAWNSTN6Y5Fpgczm7NuWxWqFQCNlwmgMZpzI9QIXLXjHZAJJGqnS\n", + "ilHtDsYTsUfJcKjGIBDZovQxeV7xbvk237j8lCTLCTHBOkkzWhbVQJYIEBNSzDl/8A4vn3+LNDQE\n", + "k5HrE7we6doN337/D/jpn/h5vJqoU40fU0yIRJsd2sqdBAvWWGQiqOdHh5eTRUXT3PH4rTe5ub4k\n", + "2W/ph4HlrMANPVUmGdsWhEfJhE3ToJKSYEemcTwYiSaa2XwFMaJFJIgAeIa24eHjN+m6w3vrbt8g\n", + "lWJWz9he3SGSgLUT1mqScs7i+ORgHl3NEUISEMiqRHYW129QyxNoGsbNJVfNlixqiBB8JEkFqVJs\n", + "mitud56izJnVEF0ORU6DpCpXpFPGw+N3Kc0HNI3l9977mNFHnjYdbdgzLxIezBXFyjGanmlyCFfg\n", + "/cimmXh44kiTQIqlC7C7e87R6jHFbIkdJdpLGB1WGEad/wi+Fn8qkUOVlgf+2xjjf/dZD3jPPT8I\n", + "36808evAz32P/Wvg3/kTzvl7wN/7fgNLKozpkUWkqmqk0AiRkEiN1inL1SPa7mCF5pRk6vfYyZIW\n", + "OevdBkVOKhb0/hlh0kQELljybM5RlrENl0y2x7sUEonCIULG5O6oxZLj4zeo11v2ZkRIiZYLrm6v\n", + "WGQFeZGx3X/CYlahUTw8+gle3H2F4/KYqjyn8ze4cE2/XvPkybdI3/wCCIGSCcINmK4k2ADsae2C\n", + "VAryMqefRqarK4Zhx9HinKfPn3NxdsLL50/IspwYM0bTk1U11jpCPFSunByf4Z2hmtVM1mHGgSxJ\n", + "sMFTFYfyQmcswXu0VDTdIV++3x7yzirTpHmGlxE3TAipQEryPMObEXV8jkoSXAQlNVhBKOdIYcE6\n", + "xPKU9sn7XK1v+ejqBe9d3fFTb7/JZAfSzBOiw40BZx1tHyhyULoi1Ybe3lFlp7jeEoWgdY6rbYNT\n", + "KV5qFBIhICsiUgXGYWLoIt5rXJBECm5uPyJdnSEJeBPx1tA0t2hK2mHDXEISAqPwJHH5/aben5W/\n", + "GmO8FEKcAr8hhPh2jPGffvcB320V991aO/fc88MSY/yBm5demzZLlc/xNsULxba54Xb3IU1jCUlC\n", + "PT9HyJFymaA0SFHRj5a72yuaQRGRZIliWb+J7RVydDg30po78kzyuTc/hzeOl3cfsBu36DSSZJ4p\n", + "Svqp5aZ5RphyHh6/RSo6QvAcLc7x3nO9bdi2O7wf+PjJV4gIyuyUB4/+Kt2+Y08GwLgAACAASURB\n", + "VD6fU89OcF7gRsvtzR3vvfxd1lwyO4a60khyhm6k9dd4NmR5ydAb9u2OfduQZjXlvGQxW+CdYL/f\n", + "cXZ+jlSaNM2IMlLVBVmWMZvPqWdH5EWFj5osL6nmK6JOMCGyaSaskPT9oSM2Ks28WiJ1QqlSxv4l\n", + "0XRIIcmKGXW9ZL46IRz+sBSpRkaPHSZkPkeIFD/uQVhEWUFaEqcNpz/1l9l2e9778Ftcb/4Fv/f+\n", + "P+PFzXOsG9CFZX5UkeucQs9RaoYfJZ4G55+wMx/RuJ6trtlEReMlXipcsKQa0lLQKcmmH7m53HPz\n", + "4pZ+PeKninEU7Pd37JqnuCmQG42zA8ZseXb9TfrxhihaTDXilEGkn23XXozx8tXvG+DX+R6lt1LK\n", + "P/q5D+T3/FkQQvx/5tOfxmsL5tZOKCUxZuR685z17SVKZ+z9xF7dEvIt7fSSIAxCeYie3jQ4uyXK\n", + "HVY0RDyz+k0UjrJyWD/S2VsWy1MeHL8LQYD3jP2E9QFZjpikZxgaPrn9Dt34jDxN6c0tMfYs5iU3\n", + "m5dcXu3Y7HtGY/n2x7+DU5GsekR5+nl8IkhJGbtIN0RwGdqc4myGLAPJkaeoL5iJt7G+wbhD52cI\n", + "BiUiZVlytDqirudMbiTEkfl8jhSCKBSTjQyTp2l7usnSND3GdiitCTEyOUte1NTVMbPlGSqf0XYG\n", + "i8KQ0E8T682WYAxGRo5OHzJfniCkRGmF856xH5EonPGgcqTQxNEgvSAIgZq/gdjfICmI6Qwax/Th\n", + "N/j8xZfpgiV6uO7uWHdwfvzTvHn+s7z71pf53MOf5q2HP8VJUpGGwH4baJqGfnqGLhOsqNl2HX1v\n", + "2TcGJSuKvCZKQQSGfmS/G5gmRxAOISB4yWY/crW27NxEGw15polOYaYJfGBynt4LjBAUdfOZzVkh\n", + "RCmEmL3aroBfBb7+mQ14zz0/BK9Nm6Xb34Je4oLn8uqaRAiq8phdt8a5Pa25IQ0PcDHiwgiq5MHZ\n", + "Qzq/R8qa0R8c5o/rx+yixcdbEnLaYU3QE2dnp7xYf5NoI007sQgZoSrQWNKs4NnVhyyKHIRCSEWU\n", + "hovztzhdRD78+D10NqMfNqQ0fPDsn/Nw8TPM8oTz1UPWdzv8lBCMYb1tOD5Z4EIk5hYnJrJa4UKE\n", + "yeGkQyaRpuvIyxrnDE8+fcrzZ08oypy9t5yfXjCMIwCLRY2zIzKryPDoVEOIjKMjTRIW82O8kKis\n", + "RAiF8iO1THCmZ7IG4SQ2GkwSSZMUyHAcKlmcc2y214TBIpUnzObo4KjTlOrhW8QsQYSDJjyzC3x7\n", + "hZzNEQ8uuHz2MXfjHo9HJhUIR1GckicleaopkuSgFmksy6Xi08vvYPqRKTOkcSLGlmmsDgG7H8gL\n", + "zypPyKscMYVXDVCCVEMsJWmVESxEC7e7HTF2HHmJt54YKqSLpC5idh3XvcRJT3WmKOafaZ35OfDr\n", + "r1bbGvjvY4z/5LMc8J57flBeXzDfNaiyQK00m90LkqTgLH/MMN6B2pH5Gd1uR6GWZIs547hHhznz\n", + "VODdSFHUOK+RMXCz3pFXHi89sjJcrr8JPiNNI84YwjijjR7tIUmX6LKmzHu0kljTIvMBKRVpXlBl\n", + "mkePTnnx/A4TFcfVCWHa853nX+VULVlUF3iTMKkRmSis7Vmvn5EvxKEVv1zRTh/T2ZQkS6jKHi8m\n", + "nLVMg0IjmS1WEEbGYUBpuNtuOFbH5HlBURS4JEEIaPY7hM7QQpJlCmTCMAxkOifqhBhAKsdmu6dr\n", + "tpweLdjv7yi1QJqUXMdDA48U7Pd7lNaM/UhCQlHnxBgwbsJaR9OsWVRLYi3x+0tUqRH1Ejvu0VNA\n", + "FSXP3r+lSGruts8Bg0HQq5zhpWe1yEhUzbysEa5Hy4lEeRTxIBrmdoxG4iO4wWCVwDpL9JJxmOid\n", + "JTrI9ZIsTZjchHeC7WakaSPLVc44eMxgSFTOMo0sVc9tC9d3nsUDxTzXxGn6zOZsjPFj4Gc/swHu\n", + "uefPwGsL5jJX+Gi5fHFF8ILR3ZCqkixPUFlOkBKxiEyTZNe0SDGQaInpU4y3SNXhPQxmz6Z7SW0h\n", + "yTweyXr/AkVFxKCzAWdnOCkI3hC6FOIeERVWJExC0myfMqtz2mcdF/MHvHVxwWy+4l98+E2IkmV1\n", + "zt1H38SeV4ymYz9sODlOYCUJXaBaPsC5PXY/kBVz5nXF85efILsKIS45lSVlesQ07dmv18z7iTSN\n", + "r/w/A6uTE4QQbLc7Ts4fEmQgEpFphkcio8J6T1FVKOsRSUqaFnTdhLGR9eaWTMGTp09ZLmeoPDm8\n", + "1M0SovMgFEppnn70bWbzFUV6UGZM0gIlPEFCkhY4M+A//BbpW2/jmg26qtHaErodHz79FCN6erFl\n", + "NGuwBUJ1qGgYxh1958hLzW6dcJyXeBlIUkWzH5mJDBlGlJSUuqZPW6KI9F1HqhOCF/RNZOzhqJIU\n", + "IqW1EzEcGqCyLIPgGYYR02fE3DE7Elg7MtxGgrCoIiEEQzskr2tK33PPa+W1BfNsUaFsxvHyIVIn\n", + "fHp3SZ2uyLM51gV0luBsz8v1R+zGipPlkt44zHhoOE3agx9kWUhUIjDeEE2KlIK+ddR14PjoiG5r\n", + "UXnChCYKg1CRIlW0zQAiI00Ux/oxcVyy6TZ8uH+fx4++xF96tOL67iWZSkjSkvnxKU5Zrm4+oekH\n", + "klSQF55kVbAqj2m3kjAZZF/g9hWL5Cd5evcROpNUxUgJmHEgSQuII1pXWONJkgTnLG3bsjo6x3iQ\n", + "UeOdI0kzohAInaITgVQ5OpMImYFOSVOJcxv6fmTAM00TWV6gZMAwQqxYzWc0TcM4jATnKfKErJgh\n", + "M025PCZJNLOTBxTVgqg1Ion46yckjz9HHG4Q+QnS70gzxWbzlGV+Qls9Y7OFKi2QUTEMBePUIBXM\n", + "ZjUDAouBKPGjZkSRLmucCMRXkgn5IlKkmhg0UuekiWA/NhgNqZBEn+CDpSgLQgw4GzEe3ASzWWQU\n", + "hnbwtN4yP8opUnuQ17X3Lxzv+fHktQXzKp8TtSJPJciUaeeYnQuUmnO7u2NWBLqhJykkIU5M8pBA\n", + "dQLavWe4ukEKSVJ4gnSkmSChxDHy8rbhNAiWVc7ZaU2avkOZ5jy9+RZVrsBEprbHu8NqV0+QF59j\n", + "kT3ik91XsVNKmmoenp7TOYPSmrzO0IlARIEYBal6CO4SkQhQE3USKY4e8Oxmz9h3FNUZJ4sL/NCj\n", + "coHHk0rFOOzxdqSoj5mcZ3V8xtXVC07OLqgXC6ZhZFHXhBDph55ZmeF9RGnF6AM6Kw83AAsueIRS\n", + "qCTDjj1VuWQaGzJKkjRhbHvi7IgYLXjLxaO3kBKqIiHEwLC+Qh8tMWNDnuVMw0R1dAz9lrBfE6oF\n", + "/tnvo+ojpnZk1zQU+ozj5QWIHu8tWuasRM1m15AmKSLNWbctQhjKPCGRBcEJ3JiBaonRkCYjZZUi\n", + "ZSDPZgeRsCSjbSb6PpKqhHmSsZ9G8mTFbHnMMF3j7IidFFHCzky8uLaQ5eRzSFVg6MC/vil9zz2v\n", + "ldc48xURz25omcYNq6NzsrQAOZIlKW23J0lShDZEPOO4YV6cUFc5SvdkyQwzeoapxWGJviYKy0V9\n", + "wr/3q/8hZZ2zbl+g9cSj88+hkop/+tsTH3z4dQiODI3z0HYdp+kxQgyY2DBL5uTZChFmFNJy3TZU\n", + "RxlnJ1/AuGt6uyEmCRKN6JZ45WiTW1Yqo1ys2FjB9fNrvLyjKEqyrCC4HJVoRJIx9AMxBHwwyKD5\n", + "8OP3OTo6YZo83kW8dEzWgAg4H9h3E2VZkacpMYA1gUQrpqnHGMs0OVyQPH32jHfe/gLWWEY14sYd\n", + "3hiUCvS7O4iK5dHiUPoYI0RIyxxPgpQKR0a1OsJ3O+R8jjAD6ugtxMLzP/2jf8Rl9xH7bkNEYKUm\n", + "nV8TpiO0LBC6pDcVUmTYyePs4aYrBSRFQaITfLQMdiKfSVZHJ6hZgReQJhmPHr5LkZ5ihq9wfbkH\n", + "BdZbpmFgXmVoUtpO0HeRRKbEGGg7h8dzVDrmicCOEYLmIOx5zz0/fry2YD4OLcFL6kVNUhsYHCIK\n", + "QrDMqoKt39G6G5TKyFJNKj1ajZwefQklX9LpDjMWZL5i32wZpw7nc7TMOZudki8SHD3XN8+55IoQ\n", + "M54/v2W3NzAGTpOUbX+LX+bspxHlPmRIAqZp2d3dMq8CZ8u3+eDFP6M3AxcnX2S93zCGK2woyMqI\n", + "pj6o9U2CKwUP7J6z8xwhjpnaW6RUSGa4GBBKE0VE6xyRRG6fP+Ps4Vu0Tc/iWCOFZrPbkeY5xEhd\n", + "15jRUpYlfTdS1wusd2R5hnOBvu+RUjFNhs32hqIseHH5glkaGLc31HlONDs2MpKWGaujFSFahmHA\n", + "+5QqLxAyR+cKpWcM3R60JNf6IGxTzohmg5qfcHS24je/8g/YTDsm+5KuG3j7i6dQe+KYoIqCYpjh\n", + "nMMER9f1eCEhSqpZQpqkdMPEMPUs6opidYZSKWbaIrVkvniT6AQXp49p+/eZjCXRKUrk7Pe3CAp8\n", + "jEQvkamCCH3r0CqlLCRSCVIpSVXOYO6D+T0/nry+nLkQGCMZxxGtHbiRTbslyoTjkxllVjE1LfhA\n", + "qhV+mBjTjnldM7k5l+uPkDGHuEQpgSClLEs+efKCX/sf/j71yYzFbEE3XtMOVwzbwE2z4ez4hLLW\n", + "BDMxTRE/tYTB84VViZUJd3LBi6fvUc/+NR6cHjFPa6beIlUgxMDYTwgKjB1xWoHy6LxAGMHWWXKV\n", + "oArQusZMIy4acgWDH1HB402HGTxFOWOzvkZKjfee9d2afhz44pe+yNX1FUodFBG994QAZjKEEIgx\n", + "ZZoM1jqE8IzjwGRH7GSYFSVFpRk3e8rZDDHNURrqcsH6+gqpBDrRYDOkP2jgHB8/RvoBnVbQNoSj\n", + "GQRJdI5Ypahxy4sXVzRbw93aYqNhtThnHt7EpH+ALa9hqkmynCgNU9fTTi0yKqZB4k2FzSRD19K5\n", + "hizLGcaBIPa4cIN1PV9/r+PR6U8ymDvKKiUUCqJlMop2P6DlIWBnSUkiFV3n6ftAkjjSNMdrQ54X\n", + "jENP13zmQlvflx+V3diP0rbsL5oF2p8HfpQNX/8qmsdeWzCvS8GIYLe/5M1HX+Tl9TOsteyGPUoZ\n", + "lIpgJIMxSD8RRo0NA5vTK8y0P1Sz0DINPSos0CqSVTNknPGdjz9h/bsbfumXfpbFbEFvJGkpObI5\n", + "pRQEKaGqmMeUqMCnYDNFmqXkFnrXsGnWfP7sjAfLR3xw/R369inSQR5WOOd4cPQWWb3ibvOEIghs\n", + "qdhtb7kxd+RVTaYUk4QgDKMdGFNDGR3BDgQXCEJhjadeLJn65qA5M/Y8f/oMnWiuhETrlGEc0DrF\n", + "GEuMkcvLlxRFQd/3JEnCbrcjenB2YnF+Riot1CW5zvERYvRMU0OSaK5fvke9OMHrnGmQyLBkamdk\n", + "1RlN21AXCbqJiHqOWh4RXeTl+x/zye1ToisQtmdeFLx18RCFpGktWW6J7CjKithD8HtEEEy9xw4W\n", + "MUV8ZfHOgIRxWtO5lihbUqVIY2C7uWKePub49CHb7jssVgrweFcwNB1KWNT/y96bxdq2pfddv9HN\n", + "fq52d2effbpbdetW7zhuExuch7wQkfCCAi/IIrwhIBICxUSCNyLIAxCekECKIkTAAQnEQ4QAS7YV\n", + "B6fsclW5XL63bn/6vc/uVjP7ORoe1vZVxS7KVaaury3v38tZa+251tj7aKxvjPmN//f9SYijBBdr\n", + "mn6N1Jr5zIOxeATbqqbvDcjbnPktfzb5xGa+lrsy1TzSGFGymD7kyfNvkkk4e/mKOM3pWo+KNF3n\n", + "kMHjreH09AVFMUGPnijy9L5Fygl+6HH9gIoTjo7uECcZr148Y/GZEgZFiCLiaYWvR0ahiFxElpdo\n", + "ZamlZetG5DDg05RYONbtmm2zIc8SkGu8vGJvfh/nI6SSxElMFJUMzRWh3zCEhqbbUG02SF9xcnDI\n", + "B5ct1jmO70yQTmKDJE5KXHdN13dkxa7l7eAsUsVkacbjx0947bXXuLy8IssyDosjjImomwYpJV3f\n", + "07QtXduSpinee7y3xGmC946quWBSTmitZzlZcH3+kjgZieOY6XRvd2iZZGit6J1ExgUynSDbS7yX\n", + "yChCZCnepMhR8M6Tx1TXHf1YkeaaR4/uo5XgnQ/fwieBvX2Jjq8gaAIjfrCY3qONZhgFkTIYpZEi\n", + "gBKMotlVscaBNDIYEdMGR1HGeN9z5zhn2z8m1nPi1LLYjxnbgAgQa8U29OAscQqmzLGu2xlkaE2i\n", + "MqLydgd6y59NPrFgbmvP6CyXlxfMJp9ie33NLEtI04inlx4dYo4XE7JFRpSmrNcXbFcX9OECaQe8\n", + "0yjrsK1kCDUhCMbBIsWASmIO9vfRwWIbyb3l67y4fMFmK7hzcB/COeVsRRokr4ZX5Dk43WNUiQwZ\n", + "61XLph157/QJKpbcf/SQKHZY/wR0gfeSqh3oKsX66pLMSPJFQ9ELVBIxSxOIRuKoZXtu0MJQTEq8\n", + "Gnbqk0jincX5kTiJyIs5V+tLQlIymczxUnDx6pLDQ4WSO+OJKIoIITAMA03TYMfxJpA79K4F1a43\n", + "eZwggkArRTMMu26Tcmd+vVje3x0W2wGC5+69R6TTA0ZriZMEhUckBSGKEaPDVyPfeP9D3j37GgHY\n", + "ti2R0ZxfXRM2Dtopa1VTLmuMrAg+xriROIoYrSXKoCwycq24ajrQkthH9JuIPPV4FLKAg4MF2/YD\n", + "FrM7OB9TtxlPHr8kVxmFgSEonDTEdiQ1hotYoXRE3w708UBaahIj8aFhe/0H7GZvueXPBJ9YMD/f\n", + "rBEoQhh45+3fYHA1ZZ6jQoxRKVEUUajAJFfEWYGwirGGzeYSqQeIOlAxY7DU65pJPifJJPP5kg8+\n", + "fIfZYs6yXFDZDlNDcAqjInRUsFq9jTAVeZKRKo83ZyQ6Io6gHzSZueDCWd59ecZsep/5coKUjjKf\n", + "8d673yTLFBfX19S9Yy4OmZgpvfQcHEw4fWmwTtA6TVrmzPXAy/qUJJ+TxzHYgThJaOuaWEcYAb7f\n", + "oAOsry+I05LttSRgqesaQvioyU7f94ibsvy6rhmHkc1mg3WegKcoJsRipG7XLCZ32W6usMIzKyfE\n", + "MsZkKUU0wVrPdDrZ6cuzBRerFbFRZJMZQkeIfIIdPZcvHmPtiPMxl9eXfPq1Y7QSbFY1s3RG5Rqu\n", + "XjniLBBPK6Sx+MTRd9D0u+rTOAiGqkF5iyoEkSiJ9BR7vWa97bGzgSZao5TBDS9YzqfcmR+SDAWr\n", + "iwsmkwVxOUcEGNY1V3VFZiNWmy06DxSTgCJgm45upQnX2Sc1pW+55RPlEwvmPREMDUIN2LHBaMW6\n", + "bRiDoh8cYazpgqK96sjHDi0zBJrQlmzOO6K0YAwjyiiyuWZot0QqJdYpJycnfPjsfertFUmS4rzj\n", + "/smnKItHfPrR5zj7ypt86xvnbKbPmCxi+nSfQnikkaz9NbnU5GJgZVuuqnNG13N8cMLB8if40b/8\n", + "1/nNt/4xz1/8En3vIHakpDSjR+jA0f4hV+sVm8qhdcL+QtF3gWaoSbUiS3KaTYdWCmEHxOgQzlHE\n", + "GV5KZsuCdVWxnOyC7OXVFVEcU223GB2zrTcIIej7jr5v8bZDYCmzFO9GrHDEImK73SIFjM2WIdJo\n", + "bdBKE8UpSS4IdqeM6YaGavuK8vABQimCiQlBo4eWD86f8a0n34DIUM4Kyizi4uwVzgq61NA7Dy6i\n", + "q3vSvCJNYBOBkQHf7n4nOQRkUESRxEcabVKi0TEO0PU9UhWs64p267j3yGP9hpO9fe4dlnzptc+R\n", + "7e8RxZar6zXvv/8By3xGf14RpS2TzLBZrdk0I2OvEBvFUZp/rPP2xqzlvwO+wK63+d8IIfz6937X\n", + "Lbd8/Hxyp0ViiUgzgt0pWKIsxdcdVTOCU2wZuXxRka8MyzuBLOsZnN1VFQ4JXe8IkSDNPEIKetOh\n", + "shUmHpmqPRTvc3F+TeASrRLuH6Z84bN/kUkxQQZDbFK++a1rPv9wyvxwwYXdsrd/gpQCN1ZM8wc0\n", + "7bsY5RiGns11x+XsFX/hx36Oo8Ofp21qvvLbv8ZlX7F/0CC6CZfDisP5kjSOWdc9UR8T6RgXHALw\n", + "kaTfdMgAcZpSJBOq7ZoQLJPcMDrFxEiILLFqWZQRm9UFQkUYbShLydD3SClpmhqlBd5bhFAEtzOE\n", + "1q5jvXqF9zMODpaEsDs4Dd5igkcKQRZnuCjgvcWHiCyd0rYNyXyBKEtsvSFSMf/st3+L9foCgefB\n", + "/SWjdLz1wVPcWHJwoBgRJBk0a0WcefK8IzJgHBwtJ6jBE+yACIE4kXgMclSIrmEyj4n1jMtNy3gW\n", + "sw0V225FMcScXZxzkD6gHh3t5hVFHrNYHDGd3OXyckUnvsZR+jp91bA6FTRXklikpEaRlXPgzY9z\n", + "5v494B+HEP5VIYQGPt7V45Zbvk8+OZ15PTKbTBkGgZEtkckwxRQte5zzFHZkS8z1ao31DXuHChki\n", + "MIG+t+TaMjqFwzMqT1EaBllxsX4LM5xwZ+8BVfUm1+cOKTrefOd3+OyjHyGOYlAjD04WbF90uK5n\n", + "L2ie1JqklBzuP+D85W9QyJL97BHz6YRX2zOquufXf+tXMTrjU/de42D/AfeO3+X0+RUuDEzzY17V\n", + "G+p2S9M6pBSgDZebFolCxTWrBibeU5qESVEw9BvSLEcpSRxp1OgRviHXLZvrDXUfYW1g0DEyOLx1\n", + "1E0NgHUdwxjoRosioLVHigrnR4auYn5yF6MTetNCcNhxYLu5QCeGyOXM50uUTri8WpMmKVmkQCq8\n", + "d0Qy5v233iKWEbkWFKUhFoqXlxVWGJS0CBmjXEBqgTaWph2Rgp31nDZICUbHRE7hGfFBQW/wsSLf\n", + "P6BMY5pxZHN9RTbTHO4tKA80OsSEvsSbh5xf9Kzfu6ZcOh6+5jk8OOBYFZTZIZICN8R8+e7ILM3J\n", + "spw0itBa8d/+/V/5WOasEGIK/AshhJ8HCCFYYP2xDHbLLT8gn1gwH901Zxc1tmkZx5bFvkcoRd9Y\n", + "UDFhcJRE+CJhGAeqVUuexqRJiXcVOlfMEsPmvKUbBvq0J9jAQI1y53iVE5t4p5oRnqbZ8o33vsKd\n", + "zT26cU2u5xztLRBOUg3X7AXIo30e3P08q+ff5NXpKdl8n9kkpogKtr3FaM3/8av/M/iBz75+l8Xy\n", + "iGrbYN2IEXBv/0tIzinMyNg7rtsGoTxhbGmtRasAskQJtfPdlJKqqjg5ucfLF0/Zn0/JE4Uu75Cm\n", + "HW8/eYKvFd0AVgSqTU0cxyil6Lpd/jyEgIkVy9mURFouN69I4pz19QVGatJyinKWoW+Rg2Jzcckk\n", + "n6BEwAdPlme0TcMkWyCiCDlarp6+5Otvvs1X3/k1pguwoef0wwaXxszKJWVccLx/B+Ele8cHIGCw\n", + "I3cPDsijJXlc0DUj5+dPQAryLOd6dY0xMZPpnPlkSpxEhCCpNzXj0BGlGbOlwY0KERRxnFAkOSEE\n", + "xjDigiOLc/JZip0PdH1Pmkwo4xKRCMZhJDIR3n+sapZHwLkQ4u8DPwJ8FfibIYTm4xz0llu+Hz65\n", + "oiEtuK4rVpcbNAItL/FSIKTAiQhawRgkKpG7Ev4wYrRldCNFNqEoDYXRJMUrxkvBeuUZ+oEodozd\n", + "OaPo0FpRzlKGZkuWG56ePuZyfYr3DbUzGCkI3tLZiCjuOdy7y/HyhDeDJkci2kBbO9Iyw40tbW1Z\n", + "TnJOX17y/OV7nNx5gyw1hKFFRQOSOVKsSLzEjReUU9isKryUdDWEsOXOcon0Chc8bVMxnc45PX2J\n", + "CG4nvzMZWZmhVcz+4pCXlxu22w6VJHRtR6UkZTHBOcvOmhX2lksmWUpdXZIVGcQBjQU3oqXGO4cg\n", + "4MeRwa1ot1fIgyP60TFaTxRplIkQWoFQfPD+Bww+8PDgdbqwZRwh3u8wcYydG5blHpN8wmQyZ3+5\n", + "RAqFlIFJPiXKNLNyhnOWD58WGCNJopSu65FaMp9NcYMHLTBKM84GmqamLOYUkxQ3SpzvcM6SJDFp\n", + "WtB76NoaNw7Y0ZEkBUlaEMUxSRwxDgNd1zCOI0nysXqAanY2iv9OCOE3hBD/FfALwH/ynRf9/gKd\n", + "W7ehW/6o/CC2cZ9YMC8nBUEHGGc0m4aqtowOIh0whUYJSVAwX+YoExi3nrHZ0rmWPH+ADBO6MTBR\n", + "nvv7kt9+GuMHTWUbxlYy+i1FkjFbGMQcismcn/nJf4lf/covUW1iosgzyaeYwXJ+vWF6pMgzyfq6\n", + "obpqIfYs5lOmxZyRa2aFoSgSnp9/wKwoqFdXVPkpeRIxdoHN9hkqKskmJ4z+BVEUcbgouRIFT16t\n", + "maYFyuYIbxB6Zzgxn+6hlKDyjv3lkiwpiFJz09MlxgtJO1heXW4Jg0UbAwSGOEHpBILDGEWsY86v\n", + "TtFK0/cjRZrvrN+waO8x+ZQOCONAHCfgBmSwpFHGiIGhR2U5XhqE9aTTJYvBw8mXWOxN2V8ec3V2\n", + "Th8c221FHAnaukUZRb/dsNjbI0sKEIHM5MQmoR23PLp7l36wxFGEdRYpFV3X4qylzAqkUhitiZOY\n", + "JM1I0hTvLH3ryPKc4D29HRjGEaUEWid474mimDiO8N4x9CMhOJQSoMDzsVaAPgOehRB+4+b5/8Iu\n", + "mP9z3AbvW35Y/H4P2e/0l/39fGLBXDiJkoY80Wiv2fQdRkGaRUQxJJMUKQRD31Ove9za4hlRWlNV\n", + "H9A2SzITYbUg6A11K8hCwiJfcmU7Rueo/QDKURYj9x494M995kd5/OQxX391ho8MeZ7R25r19YiM\n", + "LJdXT3l6fsplf8VUzmjqDdYFAi33D+8xPzjk7Opd9g5Sxr6g70/JsteI51OabUPfr9nbO8EPNVoK\n", + "lDB42yOD5WBaIIaCWKfkWc7YbqmrLc717O3tI/yA1hFZkiOlJBBIkphJWVIWW07PL5iYBd57JuUc\n", + "k6YI71FS4IaOtukxsSMv5kgG0DHDMLLZXrIXG7K8JDYxaZqyd3hENDugNLqqXgAAIABJREFUbsB2\n", + "NYv5dOe4JAJh8BhtyCKNnM+Yl0sUgcOjA8pygrUWrTWXlxdsNhuur6/ZrLdIGYiimNlsijGGrtvl\n", + "9kPwdH1304ogYO2IlIJhGJBKkec56STFAzY4xn7XpTKKIrZNjRACYwxRFCGlxDlH37eMY78z/zYG\n", + "GSeUN56mf5hP4v8fQginQoinQojPhBDeZmdq/q2PbcBbbvkB+OSkiU2LDz0iRKADkZBIBVGqsENN\n", + "LyASiusXLU/O1izKgjSR2MSx3WzZrteU6YwsUmR7CcuDlvY6oOMJOgHVb3GjZLvq0Uby2r3PkZYl\n", + "1q1x9Aw+RUUGO/PEY4LzcH5V040XqIlnYCBIyXZ4Tj0E/AB1fcmkzNBKYNMYhMZ7hSdG+Ix2NWKO\n", + "NWV0jA4LosGwiJbMDzOKJGLQYISiqSuU79GpIY9nxEawWm85vjPF2hGlA2PvwI9kSUyWxIzjQF1X\n", + "xHFClCRMspzReYTvuT67ZH86RceKsamYz0pErlHDgJDQNQ3FdIbSknw+JZ8tCAiC7dE4PBavHaFt\n", + "qFYdfd/jXGBvecDl5RXjODCbTWjbljTNePDgAXFsuHv3mKbpuLq6QsrAOI689947lGWJMTuTCO8t\n", + "Su2aXymlKYoCpRQhBLTWH7UmCAi01gghGIeBYewRWiOUpu9avLW40YIQ6DhCCBiHjrapUPEu0GdJ\n", + "uqs0/Xj5d4H/QQgRAe8B/+bHPeAtt3w/fHLl/C4mZI6h7aiua5I0YbPu6CsPwhElFY0KJCIn8RGE\n", + "gEXhRosYwdmEy65iJRSHY8pkHtPpmihJKG3OZrVGKtAyR0jPJCl4+vQxZ6u3UNKzrTqkiTjZf8ho\n", + "HhO6EadGlBNk8ynr1TULjpDE5D5BhCnG7XE3SxnDiDGaJEqQ1hCrkiF1DPM1qkvIKOmTHonm5O6n\n", + "MFKzqTecnp4j8hgrBzbrLYvpguAFKs6wHqQSDENPbCRNvUFHMWm06/meZzmbzRopoWkauqYlTmKK\n", + "JGYymyBkYOx7cANVdcn+7ACpY4zRu3a6dmBSThgGi4pTvId1XRH7gLA9YXlEOLvm+fMP2VZ2Zyk3\n", + "9Fg3ghRUVY31jknf81ZbIaQgyxIImqapGUdLnme0bXvTPE1TliVZliGEYDabfHRgG0UxbdvuPEmv\n", + "r6mbmuADeVHu0jAhsNluyLKc4zvHRFm2W1TsSJqmmGAQQDt0aGVQIXD6/Bl1XZOm6cc6b0MI3wB+\n", + "4mMd5JZb/gh8cuYUE0UfT0nihhdPV8TakAjJer1FKcW0zBACdKI4OlnQD47KbtkrU6yGetuhdUQ/\n", + "9FxeDXghySe7isokiqhWHSLSlJFnkd7hg+ffQvmSzaonySXrq2sev3jJp+MHBKeI0wX72QE6naOV\n", + "wmaQmCkaRVRqZosDpNY01YbSRPjRs73eUBQp6TSiTDXDmNB3HYGAkBJCYL1a7W79hSDPU4wxeB+R\n", + "FXsE70mimA8+eJ+9xYzBWqrNNVrMMEpircf7QJJq3NjjrUNLSZZNSBNDCJ6m2rJdnXJnb5+h2yKD\n", + "RxDR91umkxnee4pyikQQlCbLM1ScEkTCcq6xtiWez/EhIRRHPL/8Oh9+8DYHBwc0TUuSpjtFSlRC\n", + "BFmcUDcViYkRGKSSHB0d0Q093nkmkwlVVX20M6/rXbql6zp0ZGibljzLODi8Q7WtkDqQpDFnZ2c0\n", + "XU2S5SAEry7Omc8dZVnQVBWnp6coE7G3t0ee7XLraZpgjN4tEIkhTmZ4/7EaOt9yy59YPjlpoteM\n", + "nWVSBr7wxWO++ZvXLBeG6MQgBgitZbpYomJBc9VSVS3SejJv8EWAkFCtepxXjMbRdYG95YRJNucL\n", + "91/jL7zxIxgdMQbHdJaTFYpVHfiR+3+JMjdEIiXRmuViyZce/DSpUZRlgbcwDD1j37EdOrDgvWMc\n", + "WqQVZHmMiWPOXp3jhdhJ4YQgBM/qJnCP40g39CymM7q+x0uBDND1A0JKTJTj+xHvKy6uLohis9tR\n", + "BsMwdPgAUkUoBKJ3aKmJtEFqxWy+JEtjlNoFscv6GUIE6rqmyDPKNCaMA8Eroiii7Rqq1RWzxR4E\n", + "jxKBkCWE4ph4mRHhIS6QQjCOF+zvL5B8mkAgBFAqQimFkz3aGuTUMInmJNpQ1zVSQZ6kaG3w3tP2\n", + "PQdHR8ymM9arFW3X0jYNp69e4b1nuVygIkVR5sxmM4ax5+LynEk7wboBqQKb7Zq22WCU4oV3hODJ\n", + "spjJfEaSaLquRmtF17YIIZjOFuRZyjCMNM34SU3pW275RPm+grkQQgG/ye4k/68KIRbALwIPgA+B\n", + "vx5CWN1c+x8BfwNwwL8XQvg/v9tnnj4/JSkduJyjoynn97YEJDayHGYZSmuurjckaYrsepLeIdOI\n", + "bqwxIiLNot0OeNshMku6N+WLd36Kh/deJ89ykjRmudhDCokgYN3IPGm4V2SMzoMKTIspxmiUVvRd\n", + "RxSlRJFmtI662mL6nZWa9W4XoLuGOI4Z2p0DfJ5nRNrQNA1JktD3PY+fPaUoCmazGU6A0IokTolM\n", + "TD7ZyYzGvscJy9jXuL7GOY8Umm11RZ4XWA/TIuN6swHAO49SgSTNkFHC+fkFgwuUeYq1I5O4wDmL\n", + "syNDL8ijhKA9bd+ilcEkKUoqotiQ5zNENsFve8RiD0kEAsDxwTvvcb2uqKoNAcd8vkeRpzjnGK3k\n", + "5dUlJyohzfTOws4Yuq6jLEvOzs85OztjsphxePcOIgSMMaR5iptNidOEEAJpmpJmMS+fP8eYCG0U\n", + "Sgr29hYIYLSWse85PrqDd4E03aWK1qsVl5fnDMNAmqSYKCKMFhNFAKw3G5zzH7c08ZZb/sTy/e7M\n", + "/ybwu0B58/wXgP8rhPB3hRB/6+b5LwghPg/8a8DngbvA/31z8v8H9DS5yphmESYzSBfx5T/3ab75\n", + "7feJrWLQA/eXE6Q0uLaBhaCYFFifkuQF+5M5B3uHoKBuO0bbY7Ti+PgBUaaw9DS9RW12u+qymCOF\n", + "YL5Y0LUR9XqFQODdgBeOLCmRaYaUOxmQVoLl3h7r1TWTyZTLyyuePnvGwcE+683mow6GAXZ53CTF\n", + "eY+JIk5O7pKmKX0/cPrqjHv3HjCbLHHWY51jGDp63+MdrDdrYhnIsgJjIpIIvB3QRjGOA1prQj8g\n", + "pWIcPUU2R+mEdvC8OnvJJi24e5gSXI2Rjmk+Z311wfwoo2rWWKPIpwV22C0+WhuivSVjMOjlQ2jX\n", + "kEYQJEIKDu/eJyjJi+cfcH15yTvvvs98PiEyMdO8IC4Krtan6MqQ58WuJsA62qYhS1O+9MUvMjpL\n", + "33Y8Oz0jyzKyPGXoB7RW5FmOHUf6qqHtO5x3hHqkrRukVvR9T5QkaKm4d3yX0Tq88yACy71DUJK6\n", + "rhidYzKbk98EcmkUOkkQUmAi80f+Mtxyy59m/tBgLoQ4Af4K8J8C//7Ny38N+Lmbx/8A+GV2Af1f\n", + "Af7HEMIIfCiEeBf4SeAPNCLSkSM3C4wZeXXZsr835Xh+yNOnL5AyRcklD/dTgotJ8gKpUoxJiOMc\n", + "KSBLExbLfUZruTg/53J1hvcjXXOjyxSCvqkRUjJJMtI8J4kURmUksWEYRrquwwXJYB0hQNeNWGfJ\n", + "85J2W7FabxiGgclkxny+ICtyiixjW1d457B2ZPSBbhh2O848w9qOYWjZbhuKYsJssk+apmzWK5QU\n", + "VNuKartmbAfSbMo8T4mUpm073OiJpMTZQB9GggsI4YhMYDqfkmYL3n7/A4be8elPvcb11SWr65r9\n", + "Ymet5+xInuV0o0OJgBtHvB9R2hClMVFkEHGJzA6gu2Tz7Ixock1y+ACCZnHygNnRMY+ffZtxcGhT\n", + "k6QZq+srvHc0Zy8QUhBHKbP5HOctWZJydvqcKErIsgylFHleEBvJ2Lc8OT9FCEFRFDTVFqUkl1eX\n", + "u/8vm6KFxHoHg2cyW5BlGVLKmwWx36VumgYhFVJJ7uwfEicp5XQCAvq+R0pDFGWIxMCto84tf0b5\n", + "fnbm/yXwHwKT73jtMIRwdvP4DDi8eXzMPx+4n7Hbof8BqnbLrJa0Q0+9rgg2MM3nzLKeNx58mcXy\n", + "mMLkaBPI0gLnHYP1RLFgGEYEAmsbvLMURYyODhmGgaqqiKKIpm2RwROs42i6wEhFLBVJkaFkhJQ9\n", + "WmuUUFR1Q13XlIvZRyL9YehRSjGfz7m6ukbJQLfZUHct4UbDP3YDWkukUNTbCk+g7Sqc9YBEaklR\n", + "lECg67qbQ0GBVBJrHWWeUbc1RAn7ywlNtUFqjx17MhXhlSQSEi0VUu7SGnXd0tQ9r16d0/ctyzKj\n", + "7TqyuMA6MErSdy2zyQSjY6wTxEaSpgV5URD2DnEvniOzKb/97pt85t5DksVdRGQI7HL1r9/7HMbv\n", + "cuJZYpjlE642aw4P74KA1fqKNElompq+H8nznNVqzfX1isPDA373d9/k4uoVh4f7LOZLDvYPePud\n", + "t/Desre3B+za+VbVhmk5JU1yRudo2w6lFEop6rreadDTFGUMWu4WB7yjbxuGrkMIQZZl9KLHjz10\n", + "Cik+Pp3598sPS+v+w7R6+2EWMv1JtqD7Yf6dvyep/WHwvYp9flif8z2DuRDiXwZehRC+JoT4S9/t\n", + "mhBCEOJ7inu/689iPSUIT191jG3LZTWw98ZD3vjUfU72HwCewe4KSJwfgYDSisjEpGmGMQbrLATB\n", + "Ym9GbCK6vmVbVVRVRdu2JElC0zScXrziUAlUbKDTWDd+JJNbbVcM48j1+optvaEsS4LddRqsqhrr\n", + "LH3f4pxnCBbLrn/2pChQQhBFGu/BOkccJbR9RpTEXFysmE53OXkfPEIIoigiigybjcWYmL7fkErD\n", + "wWLJdnNNHhdkuWazOmea3mfd1hgdE8c5ZZKw3taUeYmShrZtUSpQZDFFGpEWBU21QsWCSO8mtA8W\n", + "Sbgp1hnQOsaPCn14QnN2yvbqGndyD8JICAl4h1eC6cFdhm9/k65v6HrHvXsPme3t0dTVTk54BV3X\n", + "M5nOmRRTtFEcH9/FWov3ji996UtsNteIINk72MO6EaVjnn74gjQt+OxnPgNSsF6vubpaM19o5rPZ\n", + "TTfIBufcR8VCUkmG0aPSlCTftQno2oY0TRmGge22IoojlBLYMPJdMnq33PJngj9sZ/4Xgb8mhPgr\n", + "QAJMhBD/PXAmhDi6qYi7A7y6uf45cO873n9y89of4K03zzFhTRAje4cZh4tDxGg4PDxA6UDT9Bht\n", + "doHIO+xo0VGMiTTGmN0XHkGapeAtVTMwjiPL+YK+78myBKM01juuVyvatmU+n6O1IopipJREUcRq\n", + "syaWO2VI0zSEEDg7PUUbQ2DXP0VKuXuf1MTBgYDUaIQyNzt4g8ChleTk8JiqqSgmJUcH93DecnV5\n", + "QVEU9MOAtRYTJfRdQ55NWOQxbd/grcUav6uwlJp+6AnOIyO5e4/WbDdXrNdr2n6g71tSLfnSawvi\n", + "2NA3G1w/sh1G9mYl69WK+XROW23ZPzpCCo2e3AUjsFdX2LGhbRs22zVHbkAI8M4ihWDv5B6Hxyf0\n", + "T97j4mLNs2dP2JstOTw85Fu/8y1UgLHrmR3dwclA27bk+e7MwTlJluXkeYJzjuPjE/q+Z1LOmS2W\n", + "fPvtN6n7lk89/BTHR/fIsyl931JVFXmef1TpGUUR3ns2my3L/X3qbU0Sx6zXG7x3GBPTtjsrvV/6\n", + "lV/l//nK14kis8ux33LLn0G+ZzAPIfxt4G8DCCF+DvgPQgj/hhDi7wI/D/znN//+bzdv+d+BfyiE\n", + "+C/YpVdeB77y3T774NOCqU9Rg6QsZ+h8RplkDLZD9AJjFElyU8JNwNyUtjs3ArvS8DhOsdZSVRtM\n", + "HO1y4OOAHQfiOKYsS6LKoPLAMI40TY21ljzPGceRKIpYr3cHmmVZ4vG7cedzttstZbE7mJRS3BSj\n", + "+F2pfQj0/YjWu0VFKUldt4zjwPtPPqRtGtLpjKZtcN7dHKTO6LuWy8tLZtMJx5/6NCd3lmRJSpLG\n", + "vPzwd6hfvSA4h1QprbVExtD2PUkWI6RiGBu00URYlEw4mOeYKKJvamy9Zrm/oN62yChDS0XQGXmZ\n", + "MdjAfHlESA2SfUxZc/r0CT/+4z/N8+fvcv3qJcsHS6RWdOfPSA4eUs73WH/ztyjLKVkWc359wenV\n", + "OWkWk8S7BXWwu6KirmkZXvRoLXnw4DVWqxV932FMxDe+8Q329/eZLxe89vAhi1lJ2zYs5nOk3O2+\n", + "Q3AkSYLWmjiJGMZh12vFyhvJpkdLqKoNUsLV1Zo4jhnHESklP/vTP8mPfunznJ29ZBwtf++/+Qc/\n", + "hK/GLbf86eIH1Zn/XsrkPwP+kRDi3+JGmggQQvhdIcQ/Yqd8scC/Hf4/EmzeKlRuGHxHPXoOohyh\n", + "5U0Xv51Vmve74CmFYDopyPN8VyEZxx/toqWUZFm2U0aEQD8OEAJxkhBpw3ldk0cxeZrupIKw20Ha\n", + "AXxgMimJ4xjnPGWckqcpnkBZ3qEsJzvHHimYz+eMY0/f9ygh6PuR69UVfdviBfQ9JIkiSEmcpwTv\n", + "2Gw2pGnK1eUV42Cpmi1CeyIjOVjO6UcYfMf92T6f+/M/x+rijGfvvk19/ZyhrklMhI4MwQswMVGc\n", + "cxhHCAl9X7M3yzFCoGRMMpvTjxE626OcP0SlCbEC27e7Hbp1lMkE7wXj9orl/gEvnz+n7zrGvgM8\n", + "CEH94pL44AF5Pufw8ICqasiykg/e/xDrR47v3CMy6saLtEYaQ5oWLOZLhsGy3W4wRrFcnvDkyfvs\n", + "7+8OgN9+802qZsOnHj7ijdc/w7vvvcu5e4XREWmaMo4O7wNRrLH9iJUO7xxVtWVSTNCR2Uk4pSBJ\n", + "NRcX54QQKMuSx48/wLqdlHI2m/0Rvga33PKnn+87mIcQfgX4lZvHV+yaDH236/4O8Hf+sM+bRkv6\n", + "2uEAFadoJdDakKU5xmjyPP/odjsEdxPAa4wxCCEoyxJrHVIqIKEbetqhBx92QX8c2VYbFpMpzo6k\n", + "ecZiucR7z9XFKybFPrPJDJNESKVp+w7b7UrRFQJnR1ary5vbfsX5+cWuWCUyNFXNarXaybOV5MWL\n", + "F2TZhNUmMJ/PEUIhgG11hZL7OOd5/vQdeu8xUcqdgwNW6zX3Hz2kLGbEScLV9RnXFy/4whe+iDc/\n", + "xre+/lVcv2G0Oxmj84Khd+TzGC0U5WxCpiS1dUyLknxxwMHRPbTSPHjwgOlsTr3ZkhU5GQ7bbAlK\n", + "I6Vn3DY8u7hkbLe8OD3ns1+wBCTV2WPmJzMEAq1GPv3oU1xcX6CV4qd+/Mf55X/ya4AnzSaI4HDj\n", + "SNtb7t69Q1VVlOUUHwbmiz2ePXvO9eqag4NjlNKkWUpWJHzrrTe5c3KXOEq4eHVOkgV0pPDB8vTZ\n", + "c6pqy/2Hj9ibL+m6Yafy8Q6ld3cDhN87A3BY70hGy/0HjzDaEN8sxB8XQog3gP/pO156DfiPQwj/\n", + "9cc26C23fJ98YhWgn/2xL/PWm29y8eqcxSQCJZnNZ8wmC9IswVqLUgJjdk2VtNZovft1x3GnoGi7\n", + "jtm8oGs6ijxns92gI03fddi2ZX9vgQ/Qti2r7RVaBiwCpQ13Dg9JspwgoCinXJyfESJDnuc473He\n", + "c319zTiOhGBxbrfTbvqOqqmJpaYd+p1+fOjxUY80MVVVfXS3sK22SKE5v3jF4/c/ZLaccfd+wWK5\n", + "5Gh/ycHRCVEUoYBuLFFBcvrsW8wPHnF4chchH9FWWz547y2azlJ3DeNV2Jldi5x8f4/ZfMFy74DP\n", + "fvZz9P1AtVmhjMHEMXE+Mp0vCPMluh8gbABF0Boxej58+oTV9TUheMS44eLsBc1kwuHCsjef8Pid\n", + "bxJFu51zmsT8zM/8LF/72lcYBsukSImMYbNZEUWa/YN9zi+es16vefHiKRcXl6TJhNPTF4QQmM2n\n", + "rFZX7O0t+cVf/EU+97nPUzcNg+0Zx5Y0y5mUe9w5ekQ2KTi/uGB/b07wAR8Ce3tLhJC7Xj7dwP2D\n", + "uwitUEpjlMK5XXDPbrTnHwchhG8DPwogds3knwP/68c24C23/AB8YsHciIT7Jw8YnCWJCu6dnLB/\n", + "cIciT0jilL5vCSEghGBvbw/nHN77jwwIhmG4yV/vjJg3mw3jMCIMREoh0l2Ofb3dcnx8BwKM3vH2\n", + "229xeOcuNjgOjg6oqi2Xl6fYocOGQBwnrC6vGYaeKIro+xHnRoZhIEkShJLMZjO89WyaijzJef48\n", + "UJQTjImomhaA7XbL9fWaatvw/pP3efzhYxbbAz73+S+TJCnWw2Z1wWKxx3J/D+8HkgcPOX33q1w8\n", + "+4B0NkdEBclkQpxNcPYJzllC2MkcizwjSnIcAqUUTdPS1B15UbKta6wP3Dm5C8UEGRSYKYQFQXii\n", + "ZMrZ6Vd58t5zQPDhh08ZrefZ0ydMZiXj+hWbas1kMmfbbLHWsq0H7hwfUNdfpG0rlvNdOmN5cMjT\n", + "ly949PAR773f0zQN5+cXNE1HZFK+9vWv8tqj13n06FNcXp4Tgufk5GR3N5PmDG2HHQJluWQyKdHa\n", + "kJiIh/cf3LS7dUxn0xupqWMxWVLO2QV5AXmaU7c7BdM0L1B/fNLEvwy8F0J4+sc14C23fC8+sWA+\n", + "9JZ5sc/DezH7asLDk9fIEoUfPaYwBL8rygnwkVytKIqbsvmBEHrKsmAcBpqm2h16mgg3DvRdx2df\n", + "f51Xr15x994Jp6dnfOFzXyBNYg4Pj3j/6ZNd06e25dnzJwxDR6QSnp8+486dOyD4qMdKmiaMo8SY\n", + "Xdm+8IFuUyGjiOVswcuXp+R5SZblWLuT1HnnGUfLbDbDxBFf/tKX2V8cMPQ9680FVbXFaM1ZXe36\n", + "cd9IY/PZknXdc3j8iOXxXZyy9K1EqIIQHAJFuLljODm+R5rkfOb1N+i6gb4bQQiSJMVozdGdI7TQ\n", + "BASCGEQA4RFBErIpv/xrv8xgBwzw9d/+TZ6+eJc3PvNFZtMpV5sNv/rr/4Sf+6mfZT5fsFwu+Wdf\n", + "+adY+yH3773GaqW5OD/n3r37HN45Js4zvva1bzCZlMyme3St5+zsbcaxJ00zlNKcn58jiIgiRZaV\n", + "PLz3iP3DO4zBgXUYs7sDGMaeJElYr654/ORD9vYPWB68wfj8JderC9brNQd7B3jn0LFBxQGjDZGJ\n", + "qKqaovxes+6Hyr8O/MM/ttFuueUP4RML5i8uXjJJU3SSUCQT8jhitCPeOfpm53XprWX0DmstIgSU\n", + "UmitsdbuJIkBxmHEjY6x6/HjTgGyf7zEB0GaZ1SbDYvFHBNr1tWG7XrF/mRKU7d06Rbbj2hpEAKK\n", + "YkLTdDjnPiryURrqeiCKIiaTKVfWYaKYvh9o6pr5fI6UgaZtGQPIsJNLbuqGut5SypIiS3n48IS2\n", + "bZlOSuwYsDbgrEVpjQi7tgNRnjGZ3yEuFwgdU6Rz6vYKEWms9dRNzTCOxHFE19dE0e4g2HvP6EZM\n", + "pLF2pGsbgoNqdU4WxQjtAI24yScnScZP/tS/yNOn7xLC7m+7c3SfPM8Yx5FyUvDnv/zjqDjG+YH3\n", + "3n+bSTmnLAuc80zKCRLPwcEd3nzrTQ4PDpjPp1RVhdaag4M9NpsNIXju33/A4eEhxkTM5wvm8xlX\n", + "V1e7gi0l6Zue6XSCkprHTz5EysDh4RH1tmGzqfjMG18gjJ4sT7hcQd20mPX1rpgoaJq+pm07vPOc\n", + "nT3nnXevP/a5e9PL/K8Cf+u7/fw7Czt+v1PMLbf8IPyeqcv3wycWzN/+9jfBC+7dOeTktUPW22uk\n", + "UBwcHpCk8UfXlXEMN6oW5xwaj/SedrNh6DvGwZKkGU0IHB8fs1gsSJKED588Js0zlosl4zjStu2N\n", + "iYLeBeu25eLykmEYEEJ8lMbp+548zxFil7rZbDZkac44Oq6uzkiShDRN6Loe6yyR2vUUaeqGOM0p\n", + "JxlSG/bzhLLLuLy4wrmd0iZJEtp2p6ku8pw4NozDQB12Pp5KGu698WUcBhnHeLFbuJwXvDxd07Yd\n", + "m82WNE05OzslyzKMiYDAaEeUhDgyPHjwgGa9ZrG/T4hTBAHXrpBpgUAihOT47glDv0EIwfHxMWma\n", + "UZYTNpsNruk4WOxhreXs4gznHJHJePnyJcvlEuk922bg2++/xXSWE8SuU2GapkRRxDAM/MRP/OSN\n", + "5LMAwP2/7Z3Zj2T3Vcc/v7tW3dqrq7urt9k9nvEksRN7Ria2WSIICUJxhJBYJAiLeEICCSlA8g+A\n", + "eIEnXoAgCCgPBIjCIhRHSUQestnj8T6x25merbuqu6tru/v24+HWOBNrxp7p7ukyk/uRSn37Vtf5\n", + "favu6VO/+1vOSVJmZmYYj8dvXVtNU6nVqgxHQ5BQLlf4waU3uHptjWatjqpm1Y/eeO1FKqUaVaPI\n", + "wN1ird9jdXWVSqXM0tJSVii6WsU0ixyuz3MAfBx4Tkq5dasn72W1o5wfL97uS3F8+7KIUxwzB88P\n", + "Cd2EkT/g8rrggaMnUDUFTc0KHgBYho7j+QS+j23bk8nIFM/zME2TUqXMcDBCUxRM08DzXDqdTtY7\n", + "ktmbX19fR1UUkjgmSiN0zcQPfLzAzcbFw2xduhIq+J5LpWxQr2XZ91qtJkEQ0els0GrN0el22BkM\n", + "GQ2G1Go1fM8nmJRA6212iaVAVRWazSaOk62+yXZGplnKgEqFRE6WAY7HjC2L2WPH6ff7zLdnUY0i\n", + "BbPA2uUrtGZmiMKQ3nBAEPqkabamXVVVFDXLStjr92g2GhiaQZpAd3ObRrPF0HFozNZBMZBpgmJO\n", + "kiMCnmczHG9SNAuoujZ5ny1c18V1fUAyGF6jXq9nm52CkCROKBaL+L4PEp564km+9dy38dyISz+4\n", + "ysLCIsvLy3S7XaRM8XyfIImpNxpEYdb7H49Hk9wtJYbDIY7jYDsOxaKJqqoMB0Pac4u49piR41Aq\n", + "N1ldvUTgj9jRbWqNKqVKGdsb8/DDH8Qwsk1lqqoRxwlJKigUD2Sr+a8BXziIhnJy7pSpBfOlY3P4\n", + "ToqmlnBdhzBIOXnsBJ7r4LnZEIIEOusbuFEAKZP6kWBZFuXyHIaIn/ryAAAQTUlEQVSuU65U0DWd\n", + "8XiE49j4fsCZM+9nbI+JPJ9Ll9YoFEyEqpJEEbquE4URqqKSpNFkvbRLr9ejUCyxsrKM7/v4foTr\n", + "+Kz21qg1G5QLNaIoQjcMqrUGpaKF7TrMzc1hlUvEcYzr2lzvbJJKiRTQmmvhuh5RFDEaDLEsC9/3\n", + "uXr5KvVqBW80oF6vI1DZ2e5hlbI85cNxnygMGQ6HDIYDNrodwiDCskpomoppGszPzeH5HiN7QKFQ\n", + "QDcMSlaJjY1rFM0iw3gHoVVIhY8iVNIYUEARUCgUePPiRY4cPU5rdhaEpLvZpV6ro2lZAYuZ1jy+\n", + "Z7O1vUWaSsIoJApC0hSWVlY4/+xzNGdmqJebPProWfo7A8rlCorQuXZtHV3XsWoV7PH4ra33QmS3\n", + "jWEYvnX76Hs+l9cuE8Uxs60WjuNjmCZRLJip12lU62z3NpiprFCrFVD1mPZCm9HAwfFHFMwixWKB\n", + "UqlMoVjGtu176rdCiBLZ5Ofv3dOGcnLukqkF80pjHtWIsCIdmUKxoGGPxygCTNNgY+Mavp/lSGk0\n", + "myiKwLJKQLZb0DB0FKnx/R+8TqVQpl6vIaXk5MlTvPzSy5CGGKUiiBTP9yhYRWIhEanEKhWQEnTd\n", + "IgxjZmdn8TyXwIvpbW3TG/RpNRsULRPDNImDgEsb67TqdQ4fXpnUyAxoV+aoVMqoqqBYK2PrGkIq\n", + "9Ho95mdmiKMEvZQNDzWrVcaOjUAhSGLOv3A+u5uolFHVV+h0NihUSoDEsX0Mq8irL13kjUurPP/d\n", + "7+GHPsVSgYKqE0QRcaIQRgGL7WV6wz6WVcAPFSTgBQ7zK8skSoDqxUjNAD8CvYSUkIYjCkWLMPTY\n", + "3lzHKlZQBMQli1qtzE6vR63epFKpTm7zBK1mE7NYxB6NcG0PpZXt3kzigAsXzlOtNfCDrBTc4tIc\n", + "pmkgZTZm7DjO5M4ky+1yo2RcqZQVqMiGSvS3vlhnZmYYDseUrTpxGmPbPp3NZxFxyvr6Omfe9wHc\n", + "0YjWbJvR0GZrawtVVVnvXOfw4SP31G+llA7QuqeN5OTsAjGNDGhCCPnrv3WOOFAwU4tapY4hVI4c\n", + "OUKtVidNJGHkoSoG1Vo5mwxNU6IopNmsE4Yho5HNwvwsb169zqHFRUql4mQseQuhqoydIWkQYJUq\n", + "BH6QFaFQNQajHQwj2/ofBgnVWok0kdl4tOMxM9OiWquyfv06J06coN/rkQYuaAVG9gjT1FEUBd8P\n", + "aLWaWEUTz/MxTRPTsIiiGMdxuHR5jUYjS7RVq2WFmp2xS9Es4EYeg8GQi6+/ThBFPHD0JL7jc2hl\n", + "hSQRhNLHMAq88eqrXLl+BUjRFIVCvYIqwSwUUUVKpdygUW9hWAWKps7h5RUura1x9rGzLLTnGY6z\n", + "sflCscjqm5eYaTZYOn2WqL9Gb2MTNwhIZIKhF2m3l3DtEY5nUy5ZmJbFdrdLo9ZAKApB6ANwfX2d\n", + "2XYbkSRZeb96C103GI16uI6DlJI0TWk0GkjIvqAVhY2NDRzHfmvuoFyuUKtVcV3vrQRbpVKJIPCp\n", + "VLJ6od3ONjKN8UOfcq2GORmyGjsuIo7RdJPxeEynu87Zs2fZ6Q/Z2enxsV/+XaSUU5l1FELI/cq2\n", + "l2dNvHvu96yJcRzf1renFsyf+PAySlmnpJY4MnMEqQgeOnmaWrVKYTKGmuVfMTANC9e1ieIQyyqw\n", + "szMgjmMajSalkkUSRkRpjKpmvWBF0ehtbRGmAZVyGU3TaDab9HZ2svqecYTvRVzd6PK+UycRQuC6\n", + "Lv3hiAceOMlmr4euawgE1VoJXdMomgU2utvs9Dcpl0tUihalcpkkjvGikG63y3BnxPHjR1hcXKTT\n", + "6XL58hqVSiXTaZm8/NJFHjv7CK5jkwpBzaowdl2e+cY3WVhYYLjTx9R00BWGg/FkJ2uY5Q23ijQq\n", + "dWzbxvbGRJHCznaH2E9RNEGpVkcVKnPNeY6dPEx7rsX1a1ewSmVURScII0bjHk9/8pewhzaKIjBV\n", + "hUSCF0SYpskLL1/ksUfeTxC6jEYjFEXFdWxKeoEwjpiZbzMej5Fpwvxim+2tbdoLi+hatkN17dIl\n", + "PNvBdmy2elscOnSEGxkgVlff5PTpU5P0CUU2NjbY2Njg0Ucfpd/vZ/lywoTvnn+eB08cQdN0zFIx\n", + "e860SOIE1x4TBB6u5/HG62u05mY4d+4cxaLF6xe/j2oqVCs1zn7kk+/pYH5j/8S7cSf/m3dq607b\n", + "O2hdd8Ld2Hq3v7sbW+92HW+kG7kT3i2Y36mtdwrmUxtm6Yx8KkmAXjEpFgosrqxQq9ao12okMpsw\n", + "NAwDVdVw3DGappKkWR7whYV5rl/fwHWzWpB6sUBZs+j3tomiBEVRaM5WUYQOStY7XFtbo9lsUq1W\n", + "s4k4xeDl197kkfedIUli5ubmiJIU13WoVirU6w3SNCGIPApGdmfQmq2zuDRLr9djq9OlaFkYZoGR\n", + "69Cen0dTFBYWFhkOhzSaNZrND9LpdEiSBNt2SCe92UZzBtu22e5vUSqV6G4OePrjH8H3fQqWheeF\n", + "jIZOVtezXsUej+lv73DixFFc1yNMYjwvRIgH6A9GjMdjqtUqg+EYL7K5fOUS29tbWeKwYonZ2SZL\n", + "y4ewqgViL6A4ySgZeC6abrAwM4OMY5752jf40MMPEsdxVj/U89FUHS8MWFxZ5vKVKyDANExs28EL\n", + "PF568QLD4ZiHzpzGtm38MKHWbFGp1mkvLOB6DvZ4xJkzD7G1leVT2dxc5djRk/hewuW1q7Rm6nQ6\n", + "HYLQ55mv/y8njq5gj12UQZ9XXn2NuYUFDFNH07J0woZV4tyHH6fVbNDv91ldXWV5eQWhSpLkvV/Q\n", + "eVqBLre1v7buJpi/G/vRqZ5aMFeVENcXzFgpC4eWWWgtULQMUCRKIhCqQhgGFIsF0jRhMBiyON9m\n", + "Z9gnTWFubi7LkpjEpK5Lb5xlP1RFQprGCFEiCD2iKKVolTHMYpYbfVJ0IvBDojAk9G0GdpZKtVAo\n", + "ZDlhNB1JSCpjqrUqoZ+tnCloBltbXUzTZLY9T384pGgWUVMFTQiqlSqbm13m5udQFEkSZ9WLymUN\n", + "xwmYW2ijmwYCQalUojXTwHF9VF0nihKsUgXbGRL4KSoppXKRoqHT9z0KBR3f9wgDD1XTKBRUoiDk\n", + "A6dOopsFVE3FHu9g6EVs16WgFzh06DCNRoPu5iZJGHH+Wy9w6vQZlg6fIRluo2s6iq7juR6qIjB0\n", + "gziIaLVmJ2lrJVHgougmq2++iSJMlg4fpt/bZGfgoBsmiply4vQh4jjh2PFjrHc7HDp8mI3L6wxG\n", + "faLAp92eYzzOvpw0TePkyQfZ2dlmcWmWzc0tLjx/geZMnbE9RqYpa1ev8cgHHkamKYmiU6nUmGvN\n", + "E4cenc51Qt+FJMAPPYqWSV3WKFgGWzs7iPdAcYqcnGkwtWBeqht4TsLDDz7MkYUVUpEwGAwAMDQN\n", + "FEEcx9mSQUUllZLVtUsUzCz3hqZLhKJmOa8HfVqtVvZ6TUchJU2zhEzlSo0gCJBSEoYhCTqqVCmV\n", + "KkipsLJyiLLrkKYSzTBxHAdVNybFETRMM0HTtEl5MoV2u43vB1QqFUghDLJVHp4/5tDKCmPbpmCa\n", + "WUEGM8WyClne9GGfU6dOQypJNUGqSBzXBQG6pjE33ybwszXv1YrgytoVZtrzrF+9RhAEHD9+nCDM\n", + "inVomkarXmdpaZFr16/gOEMSoFQos7K08lZecMuyGI1GLC0s0tnc4MFTZ5hdWMbtbaGbBaIoQAlT\n", + "LKuIYugohk51ps5oOMLzXLa3t4l9h3KjxcJCm972Dooe4acRzXoVRSTYtouqgBemdNcuc3j5KDLV\n", + "WD60TLezwcrKUa5fvcLs3Dw/8XgTz/NIZczy8iGee/Y5Hjt3jv/8n//micefZH7hGEXrOaqlGrVq\n", + "i/F4xJFDx9jobtBolOl0xmi6he0FjIYOplWlVqtRa7Wp1aoI3UDbx3HOnJz/T0xtzPzAG835sWKa\n", + "Y+bTaDfnx4f31ARoTk5OTs7+kg8w5uTk5NwH5ME8Jycn5z7gwIO5EOJjQoiLQog3hBC3zDq3T+18\n", + "TgjRFUK8dNO5phDiGSHE60KIrwgh6jc995mJpotCiI/uo44VIcTXhRCvCCFeFkL8wTS0CCEKQojv\n", + "CCEuCCFeFUL82TR0TOyqQojnhRD/MS0N02K//P9W/r0HW7f00V3auqWf7VHfj/jLHuysCSFenNi6\n", + "ZW3iu7BVF0J8UQjx2uR9Pr5LOw9O9Nx4DHf9+ctJGa6DeAAqsAocgSyVNnD6HrX1FFlVmJduOvcX\n", + "wB9Pjv8E+PPJ8UMTLfpE2yqg7JOONvDI5LgMfB84PSUt1uSnBnwbeHJKOv4I+Gfgy9O6LtN47Kf/\n", + "38q/99tH99PP9tNf9mDnEtDcp2v5D8Dv3PQ+a/tgUwE2gJXdvP6ge+bngFUp5ZqUMiKrp/j0vWhI\n", + "SvlN4O3JrT9BdhGY/Pzk5Php4AtSykhKuUb2D3dun3R0pJQXJsc28BqwNCUt7uTQIAss/YPWIYRY\n", + "Bn4B+Ft+mMjxwD+LKbFv/n8b/94Vt/HRxT3Ye7uf7ezW1m38ZS/s2YYQogY8JaX8HICUMpZSDves\n", + "bI/Vqw46mC8BNwu9Njl3UMxLKbuT4y5wI/n14kTLPdUlhDhC1pv6zjS0CCEUIcSFSXtfl1K+MgUd\n", + "fwl8Grh5f/NUr8sBMm3/f1fe5qO7tfF2P3t1D5Ju5S+7RQJfFUI8K4TYS9bLo8CWEOLvhRDnhRB/\n", + "I4Sw9kHfnqpXHXQwf8+sg5TZfc076dlXrUKIMvCvwB9KKcc3P3dQWqSUqZTyEWAZ+EkhxM8cpA4h\n", + "xC8Cm1LK57lND+mgr8sB857WPvHRL5L56K5zCd/Cz356l3re1V/ukieklB8kKy7y+0KIp3ZpRwM+\n", + "BPy1lPJDgAP86V6EiR9Wr/qX3do46GB+HVi56fcVfrTnda/pCiHaAEKIBWDzNrqWJ+f2BSGEThbI\n", + "Py+l/NI0tQBMbgn/C3j0gHV8GPiEEOISWXGHjwghPn/AGqbJtP3/ttzko/90k4/uiZv87LFdmriV\n", + "v/zjHvRsTH5uAf/O7ofsrgHXpJTfm/z+RbLgvhfesXrVnXDQwfxZ4AEhxJHJN9GvAF8+wPa/DHxq\n", + "cvwp4Es3nf9VIYQhhDgKPADsabb7BkIIAfwd8KqU8q+mpUUI0bqxSkQIUQR+Dnj+IHVIKT8rpVyR\n", + "Uh4lu6X8mpTyNw5Sw5SZtv/fknfw0d3Yup2f3TW38Zff3KUuSwhRmRyXgI8Cu1oJJKXsAFeFECcn\n", + "p34WeGU3tm5i79Wr9mNm9y5nbD9ONlu+CnzmHrbzBWAdCMnGKX8baAJfBV4HvgLUb/r7z040XQR+\n", + "fh91PEk23neBzKmfBz520FqA9wPnJzpeBD49OX/gn8nE9k/xw9UsU9Ewjcd++f9N/h3c8O/99tH9\n", + "9LP99Jddvv7oRNMF4OW9xh7gYeB7wAvAv7GH1SxACdgGKnvRlG/nz8nJybkPyHeA5uTk5NwH5ME8\n", + "Jycn5z4gD+Y5OTk59wF5MM/Jycm5D8iDeU5OTs59QB7Mc3Jycu4D8mCek5OTcx+QB/OcnJyc+4D/\n", + "A43ph1xlbAoPAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "source": [ - "The classifications include various cats -- 282 = tiger cat, 281 = tabby, 283 = persian -- and foxes and other mammals.\n", - "\n", - "In this way the fully connected layers can be extracted as dense features across an image (see `net_full_conv.blobs['fc6'].data` for instance), which is perhaps more useful than the classification map itself.\n", - "\n", - "Note that this model isn't totally appropriate for sliding-window detection since it was trained for whole-image classification. Nevertheless it can work just fine. Sliding-window training and finetuning can be done by defining a sliding-window ground truth and loss such that a loss map is made for every location and solving as usual. (This is an exercise for the reader.)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "*A thank you to Rowland Depp for first suggesting this trick.*" - ] + "output_type": "display_data" } ], - "metadata": {} + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# load input and configure preprocessing\n", + "im = caffe.io.load_image('images/cat.jpg')\n", + "transformer = caffe.io.Transformer({'data': net_full_conv.blobs['data'].data.shape})\n", + "transformer.set_mean('data', np.load('../python/caffe/imagenet/ilsvrc_2012_mean.npy').mean(1).mean(1))\n", + "transformer.set_transpose('data', (2,0,1))\n", + "transformer.set_channel_swap('data', (2,1,0))\n", + "transformer.set_raw_scale('data', 255.0)\n", + "# make classification map by forward and print prediction indices at each location\n", + "out = net_full_conv.forward_all(data=np.asarray([transformer.preprocess('data', im)]))\n", + "print out['prob'][0].argmax(axis=0)\n", + "# show net input and confidence map (probability of the top prediction at each location)\n", + "plt.subplot(1, 2, 1)\n", + "plt.imshow(transformer.deprocess('data', net_full_conv.blobs['data'].data[0]))\n", + "plt.subplot(1, 2, 2)\n", + "plt.imshow(out['prob'][0,281])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The classifications include various cats -- 282 = tiger cat, 281 = tabby, 283 = persian -- and foxes and other mammals.\n", + "\n", + "In this way the fully connected layers can be extracted as dense features across an image (see `net_full_conv.blobs['fc6'].data` for instance), which is perhaps more useful than the classification map itself.\n", + "\n", + "Note that this model isn't totally appropriate for sliding-window detection since it was trained for whole-image classification. Nevertheless it can work just fine. Sliding-window training and finetuning can be done by defining a sliding-window ground truth and loss such that a loss map is made for every location and solving as usual. (This is an exercise for the reader.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*A thank you to Rowland Depp for first suggesting this trick.*" + ] } - ] -} \ No newline at end of file + ], + "metadata": { + "description": "How to do net surgery and manually change model parameters, making a fully-convolutional classifier for dense feature extraction.", + "example_name": "Editing model parameters", + "include_in_docs": true, + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + }, + "priority": 5 + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/siamese/mnist_siamese.ipynb b/examples/siamese/mnist_siamese.ipynb index 8e076663ca6..11cae120db2 100644 --- a/examples/siamese/mnist_siamese.ipynb +++ b/examples/siamese/mnist_siamese.ipynb @@ -1,154 +1,1909 @@ { - "metadata": { - "description": "Extracting features and plotting the Siamese network embedding.", - "example_name": "Siamese network embedding", - "include_in_docs": true, - "priority": 6, - "signature": "sha256:845bb18929f96543ba2611eb5eca744fd98939cbef876df6bc319c29f616fc64" - }, - "nbformat": 3, - "nbformat_minor": 0, - "worksheets": [ + "cells": [ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Setup\n", - "\n", - "Import Caffe and the usual modules." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "\n", - "# Make sure that caffe is on the python path:\n", - "caffe_root = '../../' # this file is expected to be in {caffe_root}/examples/siamese\n", - "import sys\n", - "sys.path.insert(0, caffe_root + 'python')\n", - "\n", - "import caffe" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 1 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load the trained net\n", - "\n", - "Load the model definition and weights and set to CPU mode TEST phase computation with input scaling." - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "MODEL_FILE = 'mnist_siamese.prototxt'\n", - "# decrease if you want to preview during training\n", - "PRETRAINED_FILE = 'mnist_siamese_iter_50000.caffemodel' \n", - "caffe.set_mode_cpu()\n", - "net = caffe.Net(MODEL_FILE, PRETRAINED_FILE, caffe.TEST)" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 2 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load some MNIST test data" - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "TEST_DATA_FILE = '../../data/mnist/t10k-images-idx3-ubyte'\n", - "TEST_LABEL_FILE = '../../data/mnist/t10k-labels-idx1-ubyte'\n", - "n = 10000\n", - "\n", - "with open(TEST_DATA_FILE, 'rb') as f:\n", - " f.read(16) # skip the header\n", - " raw_data = np.fromstring(f.read(n * 28*28), dtype=np.uint8)\n", - "\n", - "with open(TEST_LABEL_FILE, 'rb') as f:\n", - " f.read(8) # skip the header\n", - " labels = np.fromstring(f.read(n), dtype=np.uint8)" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 3 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generate the Siamese features" - ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "# reshape and preprocess\n", - "caffe_in = raw_data.reshape(n, 1, 28, 28) * 0.00390625 # manually scale data instead of using `caffe.io.Transformer`\n", - "out = net.forward_all(data=caffe_in)" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 4 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualize the learned Siamese embedding" - ] - }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setup\n", + "\n", + "Import Caffe and the usual modules." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Make sure that caffe is on the python path:\n", + "caffe_root = '../../' # this file is expected to be in {caffe_root}/examples/siamese\n", + "import sys\n", + "sys.path.insert(0, caffe_root + 'python')\n", + "\n", + "import caffe" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the trained net\n", + "\n", + "Load the model definition and weights and set to CPU mode TEST phase computation with input scaling." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "MODEL_FILE = 'mnist_siamese.prototxt'\n", + "# decrease if you want to preview during training\n", + "PRETRAINED_FILE = 'mnist_siamese_iter_50000.caffemodel' \n", + "caffe.set_mode_cpu()\n", + "net = caffe.Net(MODEL_FILE, PRETRAINED_FILE, caffe.TEST)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load some MNIST test data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "TEST_DATA_FILE = '../../data/mnist/t10k-images-idx3-ubyte'\n", + "TEST_LABEL_FILE = '../../data/mnist/t10k-labels-idx1-ubyte'\n", + "n = 10000\n", + "\n", + "with open(TEST_DATA_FILE, 'rb') as f:\n", + " f.read(16) # skip the header\n", + " raw_data = np.fromstring(f.read(n * 28*28), dtype=np.uint8)\n", + "\n", + "with open(TEST_LABEL_FILE, 'rb') as f:\n", + " f.read(8) # skip the header\n", + " labels = np.fromstring(f.read(n), dtype=np.uint8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the Siamese features" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# reshape and preprocess\n", + "caffe_in = raw_data.reshape(n, 1, 28, 28) * 0.00390625 # manually scale data instead of using `caffe.io.Transformer`\n", + "out = net.forward_all(data=caffe_in)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the learned Siamese embedding" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ { - "cell_type": "code", - "collapsed": false, - "input": [ - "feat = out['feat']\n", - "f = plt.figure(figsize=(16,9))\n", - "c = ['#ff0000', '#ffff00', '#00ff00', '#00ffff', '#0000ff', \n", - " '#ff00ff', '#990000', '#999900', '#009900', '#009999']\n", - "for i in range(10):\n", - " plt.plot(feat[labels==i,0].flatten(), feat[labels==i,1].flatten(), '.', c=c[i])\n", - "plt.legend(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'])\n", - "plt.grid()\n", - "plt.show()" - ], - "language": "python", + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAA54AAAIXCAYAAAD0R4FDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXtwXOWZr/usvurWUktqGdmxaawEHEMuthGXITiIyMaJ\n", + "wbEMFmCTDMkkoyqSyTnZMwdqpmYyzEyS2ruKue2ZqSTHO/vYGQbhCxdjwI637ViWMEEEMJhgB4MB\n", + "gSRLsizJkiypuyX1+WP1Wlp971YvSd3y+1S5rF69Lt/6+lOrf/2+v/dVgsEggiAIgiAIgiAIgjBT\n", + "WOZ6AIIgCIIgCIIgCML8RoSnIAiCIAiCIAiCMKOI8BQEQRAEQRAEQRBmFBGegiAIgiAIgiAIwowi\n", + "wlMQBEEQBEEQBEGYUUR4CoIgCIIgCIIgCDNKRsJTUZQ8RVFaFUV5U1GUU4qi/HezBiYIgiAIgiAI\n", + "giDMD5RM+3gqilIQDAZHFEWxAS8B/08wGHzJlNEJgiAIgiAIgiAIOU/GqbbBYHAk9KMDsAJ9mZ5T\n", + "EARBEARBEARBmD9kLDwVRbEoivIm0A0cDQaDpzIfliAIgiAIgiAIgjBfMCPiORkMBlcAi4EvK4pS\n", + "k/GoBEEQBEEQBEEQhHmDzawTBYPBi4qivAhUA03adkVRMjORCoIgCIIgCIIgCFlNMBhUEj2fkfBU\n", + "FMUDjAeDwQFFUfKBtcDfxxhEJpcRhDC+9a1vsWPHjrkehjCPkDUlmImsJ8FsZE0JZiNrSjAbRUmo\n", + "OYHMI54LgV8pimJBTdt9PBgMHsnwnIIgCIIgCIIgCMI8IiPhGQwG3wZWmTQWQUiJq666aq6HIMwz\n", + "ZE0JZiLrSTAbWVOC2ciaEuaCjIsLCcJsU1NTM9dDEOYZsqYEM5H1JJiNrCnBbGRNCXOBCE9BEARB\n", + "EARBEARhRjGtqq0gCIIgCIIgCIIQTSrFd3KF6RaOVWa64qyiKEGpaisIgiAIgiAIwuWKoijzotNH\n", + "vPsIbU+oriXVVhAEQRAEQRAEQZhRRHgKOUdTU9NcD0GYZ8iaEsxE1pNgNrKmBLORNSXMBSI8BUEQ\n", + "BEEQBEEQhBlFPJ6CIAiCIAiCIAgziHg8JeIpCIIgCIIgCIJwWdPX18emTZsoKiriqquu4sknnzT9\n", + "GiI8hZxDfAmC2ciaEsxE1pNgNrKmBLORNSVE8v3vf5+8vDx6enp44okneOihhzh16pSp1xDhKQiC\n", + "IAiCIAiCcJly6dIlnnnmGX784x9TUFDAl770JTZu3Mjjjz9u6nXE4ykIgiAIgiAIgjCDJPV4NjTA\n", + "mTNQUACNjeB2p3eBDI4/ceIEt956K5cuXdK3/fM//zNNTU3s27cvpfsQj6cgCIIgCIIgCEK2c+YM\n", + "HDsGBw6oInIWjx8eHqa4uDhsm8vlYmhoKP1xJECEp5BziC9BMBtZU4KZyHoSzEbWlGA2sqaykIIC\n", + "9f/qati2bVaPLyoqYnBwMGzbxYsXcblc6Y8jASI8BUEQBEEQBEEQ5pLGRqivh0OH0k+zzfD4a665\n", + "hvHxcd5//31921tvvcXnPve59MeRAPF4CoIgCIIgCIIgzCDZ3sdzy5YtKIrCL3/5S9544w3uuusu\n", + "fvvb37J8+fKw/cTjKQiCIAiCIAiCIEyLn/3sZ4yOjrJgwQK+8Y1v8Itf/CJKdGaKCE8h5xBfgmA2\n", + "sqYEM5H1JJiNrCnBbGRNCZGUlpby7LPPMjw8zEcffcT9999v+jVEeAqCIAiCIAiCIAgzing8BUEQ\n", + "BEEQBEEQZpBs93iming8BUEQBEEQBEEQhKxFhKeQc4gvQTAbWVOCmch6EsxG1pRgNrKmhLlAhKcg\n", + "CIIgCIIgCIIwo4jHUxAEQRAEQRAEYQYRj6dEPAVBEARBEARBEIQZRoSnkHOIL0EwG1lTgpnIehLM\n", + "RtaUYDaypoS5QISnIAiCIAiCIAiCMKOIx1MQBEEQBEEQBGEGyWaP53/8x3+wY8cOfv/737Nlyxa2\n", + "b98ed99MPJ62zIcqCIIgCIIgCIIg5CKf+tSn+NGPfsTBgwcZHR2dsetIqq2Qc4gvQTAbWVOCmch6\n", + "EsxG1pRgNrKmBCObNm1i48aNlJeXz+h1RHgKgiAIgiAIgiDMKQ1ADbAeGJiD45nxVGDxeAqCIAiC\n", + "IAiCIMwgyT2eNcCx0M/1wO40r5Dp8fCjH/2I9vZ28XgKgiAIgiBoNDc3MDBwBputgNraRpxO91wP\n", + "SRAEIQMKQv9XA9vm4PiZj3hKqq2Qc4gvQTAbWVOCmch6mh0GBs7Q1XWM9vYDtLQ0zPVwZhRZU4LZ\n", + "yJrKRhpRI5WHgOl8kZbp8WrUciaRiKcgCIIgCDmHzaZ+u+/xVLN69fS+3RcEQcge3EwnPdaM4ycm\n", + "JggEAoyPjzMxMYHP58Nms2G1WjMYTzTi8RQEQRAEIefw+QZoaWlg9eptkmYrCELWk819PP/u7/6O\n", + "f/iHf4ja9rd/+7dR+2bi8RThKQiCIAiCIAiCMINks/BMh0yEp3g8hZxDfAmC2ciaEswkcj01Nzew\n", + "b18N+/evx+ebXon7TMmGMQjTR96jBLORNSXMBSI8BUEQBGEGyYYiONkwBkEQBOHyRlJtBUEQBGEG\n", + "2b9/Pe3tB/B4qrnzzkNz4kfMhjEIgiBczkiqrQhPQRAEQZhRsqEITjaMQRAE4XJGhKek2go5iPgS\n", + "BLORNSWYSeR6cjrdrFmze04FnxljEJ/o3CHvUYLZyJoS5gLp4ykIgiAIOUZzcwMDA2ew2QqorW2c\n", + "FVGr+UQBWloaWLMmk35zU8zFvQiCIAizj6TaCoIgCEKOsW9fjS4Cq6rqTROBiUjHJ5qOmJyLexEE\n", + "QZhtJNVWUm0FQRAEIeew2QoA8HiqWb16W9hzM5USW1vbSFVVfUrFidKpopvoXgRBEIT5gwhPIecQ\n", + "X4JgNrKmBDOZjfWUSATOVOuUdHyi6YjJdATt5Yq8RwlmI2tKmAtEeAqCIAhCDmCMZAJxRWA2RBDz\n", + "8ytwOj0pCclsKL4kCIJwOeP3+/nOd77DVVddRXFxMStXruTXv/616dcRj6cgCIJw2ZMLBW5S9UJm\n", + "Q+sU8W0KgiCEk80ez5GRER577DG+/e1vc+WVV/Liiy+yZcsW3n77bbxeb9i+mXg8paqtIAiCcNkz\n", + "UxVbzSTVSKYWQYyFWQI72XmyIeqqkQtfKgiCIMwlBQUFPProo/rjO++8k6VLl/LGG29ECc9MkFRb\n", + "IecQX4JgNrKmBDOF0kytJzO8kGb5P5OdJ5t8mzPleZ1N5D1KMBtZU9lHAw3UUMN61jNA+oXhMj3e\n", + "SHd3N2fOnOG6667L6DyRSMRTEARBuOyprW2c8/TUZLS2PsLISA9HjmxNO3KnRf36+98BUhPYiSKF\n", + "yYR6oqhrJuza9VlGRrqwWOzcffdruFzJv4nPpuirIAhCPM5whmOomTcNNLCb9N5DMz1eIxAI8MAD\n", + "D/Ctb32La665ZlrniId4PAVBEAQhy4gl+tLxTUYef/BgnX5sYeFiNm9+O6lwTXS9ufKRbt/uJhC4\n", + "CKj38cADnyQ9Jhs8r4IgCMk8nutZzwEOUE01hziEm/TerzI9HmBycpKtW7cyPDzMc889h9VqTfk+\n", + "xOMpCIIgCFlMvKhiLM9prMhdqscbj001/TVRpHCmIprJsFjsAFitBXz96y/F3U+bl6GhsxQWenE4\n", + "imdriIIgCNOikUYaaGAb26YlGjM9PhgM8p3vfIfz58+zf//+mKIzU8TjKeQc4ksQzEbWlADh7Up8\n", + "vun7Y9JZT/H8h4ODZ0M/WRkd7cHnG4jpm4x3fKRonI7nMpt8mhp33/0ahYWLuffeUwnTbLV5uXSp\n", + "nZ6e4znt7wR5jxLMR9ZU9uHGzW52T0s0mnH8Qw89xB/+8Af27duH0+mc1jmSIcJTEARBuGxIJC7n\n", + "ogiNJjDt9mJuuukxffvkpD/00wTnzh2jpaUhZr/LeFHJSNE4nV6Z2dhf0+Xy8sADnyT1dmrzYreX\n", + "AOLvFARBSERbWxvbtm3jrbfeorKyEpfLhcvl4sknnzT1OuLxFARBEC4bEvkW9+9fT3v7gbTSUdNF\n", + "SwEdHDxLMBhgdLQXmIgaz44dZfj9/YAqnrZu/SjmeDL1L2baaiRbW5Vo83LTTY/R2vqw+DsFQZhz\n", + "srmPZzpk4vEU4SkIgiBcNiQSl7NRhMYofI1YLA48nhtwOIqprW3k0KF6OjsPY7eXsGTJ1xgZOYfN\n", + "VsDg4HuMjp5PqaprKqIwlhBvbm6gre15JiZ8eDzXs3btnrjzkU7BI0EQhMsZEZ6SaivkIOJLEMxG\n", + "1tTlQyLfolmppYnW01QK6FSxG4fDTVnZyjAv4tq1e6iqqmfr1o84d65JTwEeHPyIQOAiPl8vu3Zd\n", + "E9eP2tzcwNmzu5OmDsdK1R0YOMPoaBd+fz+dnYdpaWngf/0vB9u2KWzbZuHcuZcSHp8uZnlr5zPy\n", + "HiWYjawpYS4Q4SkIgiBcNqQjLmdCEGnCd/Pmk3i9G/F669iy5UPy8soAVcBZrfns3r2c9vbDHDpU\n", + "z8TEmOEM4/pPk5P+uKJyYOCM3nYELHz88UF+9asKhobawu7twoW3cDrLcTiifaMAZWUrWL16G8Fg\n", + "ILQlyPPP36afIxAYJD+/krVrn5q2YJ8Lb60gCIIw+0iqrSAIgpDVzJWPcDbTSI8efZCPP96Px7OC\n", + "CxdOMjbWoz+nKHaD8FOxWBxMTvqx20vYvPktPeVWm6uenleYnPShKDYsljwmJoaBqd6XsVJ+tXv0\n", + "+QZoavo2EKSmZgdOp5tt2yyA+rd8w4YWFi681bT5mQ1vrSAIwlwjqbbSx1MQBEHIcmL1tJwNUk0j\n", + "zUQYa8f29Z3E7++no+MwimIP20cVnQqa8AO1yTdAIHCRZ56ppqLiBmprG8PmSj12XK+Qa7UWYLE4\n", + "2L7dzfj4SNg1HI5SrNZ89u2riXkfGzY08/zzt7FhwzEWLrw1rflJRm1t44x7awVBEIS5RyKeQs7R\n", + "1NRETU3NXA9DmEfImspuzI6IpSoUUy02ZIz8uVxL+eCDYlauXER+vprammpxH1BFnN1eyLlz0QWI\n", + "NCyWPK644ibOnTuGzVbE+LgazayqqsfvH6a9/YC+r93uprj40/T3/55Nm15l374vG1JwVRTFxt13\n", + "v87x4/+XPpaioqUUFV2ZcOyx5idbq9zmOvIeJZiNrKnZRyKe4vEUBEEQspxEBYESEc+jmaqnMFU/\n", + "qDHyV1CwiL6+t2hvP8DHHx9IubhPWdkKvN46Skuvpb//dNR+ZWVf4FOfWktBwSKuuqqOyclx8vMr\n", + "qai4PnSeIsbG+lm9+udhxwUCA1y48DqTkz5eeGGNIdJpwWp1AWpU9MUX12G1qpFWRbExPNyWdOxO\n", + "pxuHw83Bg3X6HItfUxAEQYiHRDwFQRCEeYkxmpifX8m9957G6XSbHkE1Rv6OHNmqn9vhcNPZeRib\n", + "rYgrrriZNWvUtiS7dn2WkZEuLBY7d911hBMnfqJHDR9/fCGjo11h53c4SrHZ8pmcHGdyMkAgMGzw\n", + "fNqwWCx6Oq3XW0db296oMRojo/HwejfS1fUyPt/5sGtv2fJBVERzaOgsExMBxsbC+5BqEdd05lai\n", + "pIIgXA5IxFOEpyAIgjBP0QSmhrF4jlmeQqNoys+v4OLFs1y48DplZV/Ebndx4cIJfL4LAOTlVeJw\n", + "uBgcfE8/vrBwMUuWfE0/R0/Pb/H7p19B1+vdSFvb88Ckvq2gYBFu97V0dh4O29fpLMfvv0gwOE5Z\n", + "2Qo2bDiqC2dQ27zcc8+bnDjxU318vb2vhxU+0tAEKpD23EovUEEQLgdEeIrwFHIQ8SUIZiNran7i\n", + "8w2we/dyRke7oiJwZkXZjKLJ6fTg8/Xy7ruwbJn6fH5+ZVgEU1FsBINTLVEWLryNiYlxenqOT/Mu\n", + "w1Er4E6iRSGt1gIqK2/hy1/+Jbt3f5aJiTHsdheVlas5f/41XUTabIWhCrg2PJ5V2GyF9Pf/ntHR\n", + "84yPXzKMObzIkXbNpUvvYWTk3LTmczaq2uZ6VFXeowSzkTU1+2S78PzGN77BkSNHuHTpEh6Ph+98\n", + "5zv89V//ddR+4vEUBEEQhAicTjf33ns6pj/ULC+i0d/p8awIe87hKGXhwhq9Sm1Z2QocjpKwfc6d\n", + "O0ZPz8sJrpDen2k1BVcVnYpiZ2JihI6Ow7S2Poz2OSEQGAJgcnKqRcv4+BiBwEV8vgt0dBzmllv+\n", + "ldHR8wQCF8OEcqTotNuLuf/+9xgZOTft+dQ8vKWl14b5Rc1EvKeCIAiJ+au/+is+/PBDBgcHOXDg\n", + "AP/+7//Or3/9a1OvIcJTyDnkGzrBbGRNzV/iFQjKtBWIVrgoGAxQVOTFanUCasXZZcvUyOaGDU2M\n", + "jJzT/ZiXLn1CWdnnKChYRH5+ZehMViLF3BQKxpRZu70ktC05ijLVLc1ud3HTTY8xOTmmb+vtfQOP\n", + "Ry1MVFa2ImJ+guzbdysWiyqYrdYCnE4PAOXlK1myZD1LlqynqMhLWdnnaWl5SN83cj7jFXgyor1G\n", + "Q0PJCxpNF7Nav8wV8h4lmI2sKSGS6667jry8PP2xzWZjwYIFpl5DhKcgCIJw2THdSrkaWgSto+Mw\n", + "gcAluruP09FxGLu9EFArxf6f/1NHX99J/Rif7wLnzh2jouIGios/Hdo6keAqU4JUUewsWfI1Uv2z\n", + "HQyO64I3EBjihRduD3ve41nF2rV7qKqqZ8OGo9x99+toolZRrIyP+5icDKAoDurqfsv9979HUdFS\n", + "rNYC+vpO4vNdxO8fpLv7OO3tB7DbizKOLM+kOMz09RYEQZhpGoAaYD0wnZyPTI8H+N73vkdhYSHX\n", + "XXcdf/M3f8OqVaumeabYiMdTyDnElyCYjawpIV2MvkSn001Hx2G9ku3Ro4f50peqsVqddHdHezeX\n", + "LFnPhQsnGRlpT+laDoebxYu/yocfPm2oZps6dnsJZWWf08eiKHYqKm7k/PlXCAaDKIqVu+9+DYej\n", + "hH37bqWg4FOcP9+qH+90VlBRUY3fPxjTi5rIm5mOfzPdok/NzQ20tT3PxIQPj+d61q7dM29FpbxH\n", + "CWYja2r2SebxrAG0Ds71QLpl1jI9XiMYDHLs2DE2b97M/v37ufHGG8Oez8TjaUv0pCAIgiBc7kRW\n", + "rh0aasNqteP1bqSmZgcwVckV4N1367jzzr0cObI15vk6OtQWK6mgKDbKy79IZ+dvpiU6QSEYnKSn\n", + "51VA9Z0WF18TJiCDwUmefnolDz54gQce+IT9+9eHHe/znae9/QB5eZVEUlCwKGHRptraRp55ZhVW\n", + "q5MjR7YmLOyjpdymysDAGb1wU2fnYVpaGnA43DldREgQhMuXgtD/1cB0cj4yPV5DURRqamqor6/n\n", + "ySefjBKemSART0EQBEEwoImnwcGzuFxe+vtP4ff3A1rVWFUAxmr9YRReq1f/nGefvZmxsa6oa4Rj\n", + "BSawWBx6P04zyMtbwPj4GOPjg/p1Fiy4md7e15ic9EWPwppPefkqbLZ8rFYH3d2t+P1qKxiHo5R7\n", + "7jnBM8/coPf5dDjcbNnyYZi4i9UaxbitqGgpRUVXRgnDVKrORu5jbP2itYM5eLBOWrMIgpCVJIt4\n", + "DqCmy24DpvOVWabHR/Ld736XyspKfvKTn4Rtl6q2giAIgmASmi9xZKSd7u7juugEdNEZz4do9DS2\n", + "tj7Mffed1gvzxGPDhiZcrqVYrXkJ90uXsbEeg+i0UF6+gp6e4zFFJ8DExCg9Pcfp7DxMd/crKIr6\n", + "+cFicVBScg0tLQ9RXv5FQBOib6ZUtMm4raBgUUzPZype0Mh9amsb8Xrr8Ho3smHDUZxOd84XERLm\n", + "K2a474T5jhs1PXa6ojGT48+fP8/OnTu5dOkSExMTHDx4kD179rBx48ZpjiY2IjyFnKOpqWmuhyDM\n", + "M2RNXd5EVl7VxIvdXhy1b1nZCrzeurh+RZutgHffnRI+TqebioobEl7/nXf+jcLCKwkEBhPulxmT\n", + "9PefSnlvv78Pn68Xi8VJeflKzp9v1YsIuVxLKS29lpaWh6Iq1cYq4mPc5nCocxopDCMFo/aaPPHE\n", + "EvbuvZX9+9dHVc51Ot2sW/cs69btjXmt+ZRmK+9Ruc4ZVPfdAVQROvfImhKMKIrCL37xCxYvXkx5\n", + "eTk/+tGPePzxx7nhhsR/v9JFPJ6CIAhCzpFKamaqaJE0QI+ktbQ0cNNNj7F793ImJkax211UVq7m\n", + "K195Iupakem1p08/SGmpl4MH6/Rte/fezOhoFzZbEePjw/qximJncPBjhobOTnv8qRLej1NDTfMF\n", + "sNkKGR+/hN3uMvT69DE01AaA0+lhdPQ8Pt8AQ0MfAvDMM6soLAxPnXU43Pq9a55YTVhqcxtZQChy\n", + "u/E1uXRJLcLk9dZRVLQUiyW+XzRdn6ggzA5mue8EYWbweDyz8mVERh5PRVGWAP8JLECt+74tGAz+\n", + "W8Q+4vEUBEEQTCWWl3C6JKq8unfvrXohHqfTQ0XFDdTWNtLa+oguNgOBQb1irOZh7Os7qafoVlXV\n", + "Y7Xm8/HHBwgEBuOmuloszrjPzSRWax6LF3+VW275V1pbH+ammx4LE8oVFdczOPghPt+AIXUXbLYi\n", + "JiZ8evqx11vHunXPhr02TmeF7gnNy6vkvvtOh81dvC8NtNfEbi8hELiovzbi4RRyE7Pdd0Iukszj\n", + "mSvMZVXbAPDfgsHgm4qiFAGvK4pyKBgMns7wvIIgCIIQFzO9fPn5FTidnpgCSEsNtdmK8Pl6dX/h\n", + "yEiPLoDy8yv1sVgsTn07qGJ1eLiTgYFTYV7RWMy86JyKbhqpqLiJmprtYdHCe+89zeOPVzI+Psy5\n", + "c8dwOsvDRCcQFrkF9MJIxtfG4XDT2XkYgLGxrqi5i1eJ1hh1bm19GKs1n927lzM21guoKc/i4RRy\n", + "B819l000AM8DPuB6YA8iioWZJiOPZzAY7AoGg2+Gfh4GTgOLzBiYIMRDfAmC2ciayj3M9PINDbXh\n", + "8/XS0XE4qrCNdp0rrrgZmBK6mrjS2qIoioOLF9/j4sU/8O67YLUWkpe3AL9/iJ6e44aquOr3vQ6H\n", + "O2nRIQ2bzWV4pKAKyPQxFt8x0tV1TL9vzVt55MhWrNb8qasqqV/T+NqsXbtHb8MSOXfaY2PRoJ07\n", + "r9HbuaxZsxuXy8uaNbsZGmpjdLRLTxd2ua6aVx7OZMh7lGA2TU2vAl1AP3CYbPGeCvMb0zyeiqJc\n", + "BawEWhPvKQiCIAiZYaaXL1H0VLuOzzcQ5kHMz69AUWyMjw/rkb9AQI34KYqViYlLTExcirpWMDiO\n", + "zVaA232d7pNMRFnZ9fT1nTCegVhRy1Tw+S7E3K4oNnp732T7dneowJGaQuVweEJjWMG6dXtpbX2Y\n", + "jo7f4PNdwGrNZ9Gi22lvP6Sn2p4//zt8voGo1+a++06HzV2kn9Mo4rWeoTt3XkNFRbUeATV6YMvK\n", + "vkBNzfZpzYEgCBpOw88rEe+pMBuY0sczlGbbBPwkGAzujXgu+OCDD3LVVVcB4Ha7WbFiBTU1NcDU\n", + "t3jyWB7LY3ksj+XxXDz+oz9aQUtLA5OTf4zDURT1vMXSyMDAGVpb3yE/v5JVq5YQCAzS3Kz6Opct\n", + "A4B331X//+IXFzA21kNX1zWMjHRSVTWsP2+x5HH11T4gqO8febz2+IMPigkEBuM+b9bjlSsXMTLS\n", + "zbvvToQ9399/EzZbHn/2Z2rV2KamJkZGuujvf5ivf/0lXn/9Q158cS1XXz2un2/Rotv4i79omtb8\n", + "/+53Z+ntfYNlyyzAZNj59u69lZYWdb7vuGMj69btzZr1I4/ny+O7gHZqahYBjTQ1vZll44v1+B+p\n", + "qRkGCmhq+h4Q/f4V//ELwP+gpqYC2J4j95vbj2+//fZ54/E8evQob775JgMDamXzjz76iF/96ldJ\n", + "PZ4ZC09FUezAC8CBYDD4rzGel+JCgiAIQk7S3NzA2bO7CQQuhm3Pz69kdLQLh6OU0tJr9eJCpaWf\n", + "Z3z8UiiaacHjqaav74Tuf0wVq1Ut6mP0i84csb2fDkcpixevY2TkXNxCQGqU9GJofzdbtnw47RRY\n", + "n2+AnTuv0YsRORylbNnyAU6nO2EBqHQwsxqyMF9oQG13chI17RSgnuzzZMaiBrVNC+TOmC9fpLhQ\n", + "hh5PRe0u/b+BU7FEpyDMBNq3SIJgFrKmhHgMDJzRhZXmz/R4qqmre4Wqqnq2bPmAr371BbzeOgoL\n", + "r2R0tIfXXvsALSW2t7cVu10VN1N9QRP+XQZgYmKYrq7mNEdr0ceYHrFTd/3+fj74YLfuv2xq+nbU\n", + "PgsWqD3eHA4399zzZlwhF9krNRZq2q2W/qdQXFzFkSNb8fkGTPP0Gv2kkX7ebEbeo2YSrcemJjpz\n", + "qeXJ9Nu0TG9NNaCK3fWolXoFIT0yEp7Al4BvALcrinIi9O+rJoxLEARBEOYEo0gaHHwPUEXnXXcd\n", + "1cWPVvTG6XTjdLpZt+5ZJif9jI11R51vwYJqqqrq2bz5JFVV9TgcpWHPxxeL6XwzbmHLlg/Iz1+Q\n", + "xjGxiBTFxsfh42lubiAQGAWsTE5O8Mwz1XrPz0hSFXyFhV79Wr29r+v7a77RTCOUZlZDFuYLmnhb\n", + "AdQBh8id6q6NqJHO2RqzJtIPIMWIhOlgiscz4QUk1VYQBEGYYcxMoQzvQ1luKMqjsHDhl7njjr0x\n", + "z//LXzqjUmq1VNzh4TYKC704HMV0d78clbprJP1+nqrodLm8YX1H06WsbAWjo12MjnZFPWe3u9i8\n", + "+W1OnPgpbW3P4/P1MTk5QWS0tLBwMQ888EnU8ammyk7171T9rZmm1kYSWSRKEOa+x6aW6luAKiTN\n", + "HoOZ51+PKjqryS2Bnh1Iqm3mEU9BEARBmBOMkcm+vlOmpVAao2Iez0rDM0HOnTsW9/zGViWKYiMv\n", + "bwElJdfQ3X2cS5fa6ek5Tnv7AaxWZ8zjVSw4naWk2jJFUWxcdVUdR48+yP7967HZ8pMfFPGn32Yr\n", + "ZMmS9ZSXf0Hvk2l8DiAQGKK19WEGBs4wOtoVEtjhotNqLeDrX38p5hXVXqkVOByJP6hqKbVadDhS\n", + "dKaSspsIsyKnwnxC67E5V2vCGEW8mvTTWJOlv5oZpZztCKswF7z33nvk5eXxzW9+0/Rzi/AUcg7x\n", + "ughmI2u1e9m8AAAgAElEQVQqNzGmbw4Oqu02pptCaRQ0q1f/XBc9a9bsQVEc+n6lpZ9n9eptMQVQ\n", + "RUU1AO+/n0cwOM7YWA+9vW8AasQQ1JYhbvdyLJZ44nMyFHFM1jJFFbb33/8+Y2MX9Hm4cOFE2Hhj\n", + "oSjhf/rHxy/R0XGE999v1Ptkqvs59HtSW530Y7Xaw46120vYsKGFwsLF3HvvKVwuL7FQe6Wep7Mz\n", + "vFdq5DxqwtCYymwkVz2amZJb71HiA0wP7QurIqCX9AWiUViuInruY/tAp7em5lqkC7PB97//fW68\n", + "8UbUUj7mYlofT0EQBEGYTYyRybVrn6K19eGUUygjU3M1QQPQ2vpwWB/KpUvv5sMPn8HhKOarX30e\n", + "p9Mdtn9LSwMOh5tAYJS8vEqCwT79WK3HpcXixOFw4PerIlEtCK+hkJ6fE0AVti+//H9H9MGM3avT\n", + "iCoup65ptRYwMTESYz8/Docbp9ODz9dLR8dhFMXOpz61FovFjsVip6ZmB06nmwce+CRhunM8b2Xk\n", + "PCbrzTpdj6ZUs51NNCEEqoCajUqrM52uaiaRY20MbesHDqMKxHxUAXkW8ALFxL8vTVh6gAuA1h94\n", + "OXDacP65SiUWcomdO3dSWlrKtddey/vvv2/6+SXiKeQcWk8kQTCLy3VNZZq2ONcYK52eOPFTRkZ6\n", + "9Cqoye4tMnKWSNCMjJwjGPTj8/XS2vowEC2ABgbO0NNznLGxLq65ZjLqej5fLxbLlNjUBGnoERZL\n", + "4ihlOMY/3Qr5+RVYLE7Gx0dTOtpmK+aee97EYsnH4SiLm57rcJRSU7ODioobwsbd3/8OX/vai+Tn\n", + "L+DgwTp9jo1zunPnNWFzH68qbbpCcrrVbXM9Uppb71HTr7Q6fXKp6M3zTI3128AjQE/oOa24UVto\n", + "n3bgOInvS0t/tQCDhu1doWNiRymj15REqueahgaoqYH162FgGi9BpscPDg7y6KOP8i//8i8z5kUV\n", + "4SkIwmVBQ3MzNfv2sX7/fgZ86RRumb9k84fxVNtvaOmYkfeiPf7v7eXcuPP/jXrdjYLHas3H7x/E\n", + "as1DUay6eI21ryaOIgWQcR+HowQARbGiJRaVl69k06ZXyM+vDJ3VmMJkxWo1ir/o9Can04PDUUpe\n", + "3gKuuOKPQtvK6e5+mfffbwwVI0qWnhu6mtVJUdGVLFhwI35/X8woqcNRyj33nMDpdFNb2xj2XHn5\n", + "CiC+eFcjr+fD1lWkt1J7fScnA3i9dSkLyel6NKWa7WwyFz7AuRC706EBVRBq+JkSzYcBO+qcafej\n", + "fVlVAjwWca7PAg6gAlW49kc8n+5c5JJ4n5+cOQPHjsGBA6qInO3jf/SjH/Hd736XRYsWzUiaLYjw\n", + "FHKQ3PK6CNnCmYEBjnV1caC9nYaWlrDnLtc1lc0fxtMVxUbRMzY25UXss32ak75S/XXXBE8wGMDr\n", + "3ciddx5iaKiNnp7jTEyMcf58a9Q1a2sbcbmWYrU6dVEaKYCMQrSi4j8oLFxMeXk1oHomh4ba2Lfv\n", + "1lC7kMjU2gm9yq0qQKMLC/l8vfj9/YyN9dDd/dvQtgHGxnrCfJnxcDrLDec6T1PTt8KKIRlRFDsV\n", + "FdfrAtrpdLNw4W2A6nHNy/Owb18N/f3vAFPrR5uDBQtu1rdbrfkxv0DQXt/OzsNYrfYZT301qw/o\n", + "XJFb71Fz4QPMlaI3ZyIe24ktmrX7WRV6fBG4nfCIZBcQQH2POUb4e8oiEs9FA01NK0jFCyrMHgWh\n", + "l6C6GrZN4yXI5Pg333yTI0eO8MMf/hBAIp6CIAiZUGBTI0/VHg/bVq+e49FkB9n8YTxSFCeLgKq+\n", + "vQrGx4fp7DyMzVZIVVU9i69QP7hpr7smeDo6DmO1OsKilXZ7cdg1NZxON+Pjo3R3q1Vpn3zy01Hj\n", + "MArRgoJKHnjgE/LyykL3UoTf38elS+309rYS6ee0Wl36ddUiRPGFpM1WBGipvKlFODdsaGFiIhCx\n", + "VdFf/8g+osFggI6O8CJAd9yxl6qqejyelXz00XN0dR3D5+ulsHCxvn60OVi7do++roaG2vQvEHbv\n", + "Xq7P2Wx/6SHVbLMZM1I8s7nojfH+jN7uzwE7mBKZF4Ey1C+mqlAjnGWhfatRxaQxImk81xeAL4V+\n", + "XgGsQU3bjTWnDaHrvhU617LQPrki3ucvjY1QXw+HDoF7Gi9BJscfO3aMjz76iCuvvJKFCxfyT//0\n", + "Tzz99NNUV1enP5AESB9PQRBynobmZs4MDFBgs9FYW4vbGV0xdMDno6GlhW2rV8d8XsguIvstGntr\n", + "VlXVxyxCE6tXZOTrHmsf7Vo33fRYVIEirShNd/fxqMhiVVU9Doc7btEa7bw+X79emEf1dlpRRaON\n", + "goIrmJjw4/cPUFl5C11dL0f4P9V9S0quxe2+hkBAFdbxsNmKGB8fDtvmci1laOjDsG2LFq1h7do9\n", + "UXOrEa9/ZuS+DkcZ99zzBi6XV5+roaGzFBZ6GR5uY3x8GL9/6oOv9tql0k9TCgLlItMp8lPDVDGi\n", + "emanGNFsUsPU/S1AFZG/B5agFg2qQPV0vkT4l0mLgHdQo56LgNcAX+iYk6F9bkEVmk+EHmtFhOoM\n", + "16xELTKkvRbG8WjMx3nPPrK5j+fo6ChDQ0OAGu38x3/8Rz766CN+8YtfUF5eHrZvJn08RXgKgpDz\n", + "1Ozbx7Eu1TdTX1XF7jVr5nhEgtnEEoyRpCJmUtnHSKTQsttdBAJD+jgOHqxLKIibmxvo6zvF4OBZ\n", + "Cgs/xYULrwNgsThYuPDLnDt3nMnJ5EWBvN6NrFu3F59vgJ07r8bn68VudxMIDGH8sLpkyXo++WR/\n", + "xNFWYkVHi4qupKhoKRaLnXPnjhEMBrBa81m06Ha+8pUnosS3zVbA5GQgSvhaLE6++c2usLmIRaLX\n", + "LhapfNkQOb54AtW4T35+BUNDbSJoZ4Qa0heR61Ejb9XkVrQtmcjWnn8FVTBqeFCLAPlDj50Rz2tY\n", + "UFusjBCdBVEJ3IEqWGNdX5tTDeNrEfncCuBojPELZpPNwjOSv//7v+fs2bP853/+Z9RzmQhPSbUV\n", + "co7c8roIs0GmabSyprKfVNKCW1sfCatsG4t0Uy61lNCyshV4vXVs3vx23KJCWsqocT0Zq90ODJwK\n", + "bbUyOemno+NwSqLTYrHT3/8O27e72bnzaiorvxxKK76EUVDa7S5uvfVnRBcnMorOqeeGhz/WfZYO\n", + "RwlWawF2exHd3b/l8OF6fQ6Nflu7vYiqqvowz+jkpI9du5brVXvt9pLQ/2rqcnn5St1Pm2zejSnV\n", + "2vmSpeOm4gc27vPxxweytqhWPHLnPWo6PsFcTfE0FuOpRE2LXctUaqtWvdYoKq2ovTr9hm2xfz/V\n", + "lPpBYqfedwFPEr8YUGNoTBD9WjQCG2lqugnYiIhOIRaPPvpoTNGZKSI8BUHIeRpra6mvquLQnXdK\n", + "Gu08JRXBmG5Boli+0chtmuAtL/8CPl8/LS0PhUVLkwliTZg6nR6Dl3IixjYj4cWFNm16jdHR8wQC\n", + "F/H5emlrexaf73xESi4EAkO0tj4c8oFGoyhqlDUWPl8vExOjjI2dx+/vD/N4GsV1Tc121qzZzd13\n", + "v47FMvW7NjbWpYvSzZvfCv1/kqqqeu666zesW7c3JbEfKXIjizrFIhW/qHGf8vIvJt1fmC7TEZHZ\n", + "7M+MJJZf04YqLrU+nNp7T6woZnSrpaltVuBOwr2bidB+/2NVvHUDrtDYPkT1jxqf2wv8D9TU30Re\n", + "0Jo4zwnC9JBUW0EQBGFekEo6LkylXfb1ncTvV1sQaKmc8dI7jdudzgoqKqqTpmka02xdLi/nz7cC\n", + "4HCoVWLHxnrp7j6u719evpKioisZH79ER8dhLBY7mza9Rnn5F/jVryrw+XrDzq+l/Uam/2qpuEYs\n", + "lnzuu+80DkcJO3deg893Puz5SG+oxeLA47kBh6OY1at/zvPP305BwSIcjmL9vn2+AXbtWs7YWJd+\n", + "7dbWRzLyZUa+hslSmSH9FGsgrXRr4XLls6iRxTHUdNQy4HWmem6WoqbJjjDVP9OKWn12D6oAj+/H\n", + "VlkGdAJDMZ6zMyUujdiIjoIuCe3rA64PXf8qpgTnYuCTGOeqIX5qdKLnhOmQS6m2iRCPpyAIOUMq\n", + "hYCE7CJXiryk6t+M9G0aRdMHHzyF399PeflKyso+r3sBNW+jUaAl8h1GXic/v5LR0S69P6bL5dVF\n", + "liY4a2p2hBU7Mt7H0FAbu3YtY3LSp+9/yy3/kxdeuJ28vAUMDbWxadMruFxehobaeO65W1AUK4HA\n", + "CH5/H1dccQvFxZ9maKiN/v538Pl6sVjs3Hnnb3jnnX9jbKxf927a7SWUlHw2VIFXjcwGgxNRIj3W\n", + "nCfzZSZbS5HnS/XLhFjkyroVspEG4P8jtcrRsTzUTtRIZjD0L955FFRBG91LN1pg5qOmMmuCNNYx\n", + "GvWoKbS9ofFVAx2AF7U4keYJTeSvzVXvbfYiwlNSbYUcJHe8LkIsEvXTnCuycU01NDdTs28f6/fv\n", + "Z8AXK2Vr9kg3hXWuSNW/Genb1CvgDpzRxVVR0ZVhrUD6+k7i9W7Ue1Rq/UJjpX9q68mY3llX9wpV\n", + "VfVs2fIBLpcXmErTjUxFjXUfJ078FIejBEWx43AU43CUcPTog/h8A5w/38rYWBetrQ8D4HJ5+cY3\n", + "OnC5qvD7LwBBuruP09b2ot4GxWJxct9977Fw4a16CxSvdyNebx1bt36kt4IBi95DVLuXyFYzxrEm\n", + "S3uNtZaM6c1A3P6o6QrHXFm3qZCN71HzD2Nq6SkSi04tHd5D7PRZH1M9NhOdJxjneIiOavpRxWYX\n", + "iUXnClRP52uokc5qoBVoB46jeULVNZUoNTpXvbdCNiPCUxCEWUX6aaZGNgn02e65ONNoYmbDhqOs\n", + "W/dsTNFUU7NDfwwwNtaD1eoItSCZ6heaSNDU1jbici3l0qVPePrplfh8/WHPp1PoaGDgDGNjPQSD\n", + "Ac6dO8b77z9JV9exuIJQTfM9GXYOi2XKOzo56dOFqjaWdev2sm7ds7S2PkIgMIii2NE+FCuKjSVL\n", + "1idNYfb7B8nLq2Tt2qcSel6N400kEDPpvznf1q0w0xiLBZ1Nsm9F6N9FIvvypk9/jG2xgkbJoq/F\n", + "qKL5C6i+zYeAt5nqBVoS+t9YbCiRvzaXvLdCriCptoIgzCrSTzM11u/fz4H2dqo9njkvmpRuC5Jc\n", + "ITIVE6a8f62tj9DXd4re3t8xOekPS/VMJ/0zMq03WXpuvPRQ7ZqRlJWtwO/vZ3x8lMnJABUV11NQ\n", + "sIiPPnqOQGCqoEh5+UruuONZdu1azuTkKIpix+NZhdNZFtVeJF5bFK2lS7wxx/LMRhJrLaXrzU01\n", + "dXa+rlshVRK1O9GeO8tU+mkA1ZPpCe0T7pMOJ57/ci7ZiFo0qIZwb+Y21Pt9DHg49Fh+H+YCSbUV\n", + "4SkIgpCViECfeeL5EZubGzh7drcu3AoLF7N589u6eElH0BgFY3n5Su666zcpC9W8vEruu++07vts\n", + "avo23d0vMzbWE+YLjRSKTqdHLy5kt5ewaNHt1NRsp7X1Ec6e3UUgMBh2TaezQi825HRWAMGo4kQA\n", + "Xm8d69Y9m3DMkH6/zul4c5MJeCPi9cxmkvXCzIQawgWY23CtQdS0UyN1qIKyM8ZzELuoT7bgQo1u\n", + "/hR4CjWKWgTcjFpoSNZ8NiDCU1JthRxEvC5CLDLxRJq5pszyZrqdTnavWSOic4YwpqKWla0IS8Uc\n", + "GDiji06HozRMdELy9E9tPWmpp07nApYsWZ9UdAIR6b1d7Nz5Gd37uG7ds9x337u4XEux2QqYmPBH\n", + "HVNevhKPZ4Vh7G/p6cTqfamiU2vjYrMVhQlRn++87gEFtXKudt6amu0Jx2zs19na+khUq5p4pOvN\n", + "TTd1dj54Pefv3z1jeqtZr43m1Xwn9FhLLTVe69XQcy7DPsWoFWtfi3FOK9kpOrXWK0Oo0cwzTKXu\n", + "DhPe3iWc+bumhGxGhKcgCPOCbPFEZss4hMQYCwmNjHSGPacJHK0C7XQjZAMDZ+jpOY7P14PdXpjS\n", + "eWprG0PeShWf7wLt7QfYufMaXYAWFl5Jd/dxfXswGGDJkvV4vXXcdddvWLNmj17IaP/+dWzf7uZX\n", + "v6pACX0P7XCUcvfdr+N0ehgfH2ZyMvwLEoejlPvuezfUi/NtvQBSvPFrntmyss/j8w1w5MhW+vtP\n", + "ZdxTNd510i00NJ+8nqnMU26hfWli9B1miiYwe1GL62jFcbRrFTGVJrsaNRp6LfBc6LhYXximUt12\n", + "JlmAGnE14gZuC/2szZ92j8UR2wUhO5BUW0EQ5gXZ4onMlnEIiYn0TBYVLaWo6EpstgJWr/45ra0P\n", + "Z+wNnG4rkBdfXEtHx2G9P2dkCxe/f5j29gMptXbZvt2tR28VxU5eXjl1da+EtXMxoig27r//fb3y\n", + "bjoYU2Gt1nwmJkax24vZvPlk0vNNN402FeaT13Mm52luGECNyJnpO4zXBkS7Vj9qJND4fA1TabnZ\n", + "SDmq8OwOPbYCbwBXEj5/2j2KnzMbyfZU25qaGlpbW7GFikAuXryY06dPR+0nHk9BEC57ssUTmS3j\n", + "EBLj8w2wa9dyxsa68HiqsVic9PSovi6zPtD7fAM888wqCgoWYbcXR/kLY3kPm5sb6O8/RW/vG5SU\n", + "XMvISAelpcs4d+6YLmBBLYKk9d50Oj1YLFYmJvxUVFzPmjV7aG19hIGBM3R3v0wwGECtkhkMuz/j\n", + "HIDqB928+a24IjFyvNo1tMdHjmzVhbaiWDl/vjXl+cykX+flhMyTRiJvaDIxG/l8A1O+yGxm6ndY\n", + "ZSmq8JwJf6wwE2S78Lz99tv55je/yZ/8yZ8k3E88nsJlhfgShFhk4onMZE1FejrFm5kbOJ1u7rvv\n", + "tJ666XCoqWlmpGNq68npdIelxUamnMbyHqpi8TgTE6P09b3O2FgXfX2/Jz+/kuLiz3DwYB1Hjmxl\n", + "9eptrF2rptS63csYHe3G7++no0Nt8aKdOxgMYLXmsXDhl6PuT5sDr3cjRUVeyso+R0vLQ3FTOCPH\n", + "G/k4PBW2LK35zKRfpxGzUlGzqY8uTK0ps+YpOzH20Uz22kV6Q43HQuI2IMY2IQ2hn7NddFoJF502\n", + "1F6eifyxiedTPksJsZhpYRyZMC4IgnDZ8Y9vvcXfDQ5SYLPRWFsbJRobmps5MzAQ8/nn29roGh0F\n", + "4NtNTTy7bt2sjj1byYVKolpRG1A/0E8nHVO7z8HBs7hcXuz2Ymy27+nPJ/IXDg6qvQLt9mJuuumx\n", + "iN6bFmASq7UQn09tFt/RcUSvPtvS0oDD4ebcuRbGxqYq0JaXr2T16m0cObJVv64xShp5f1r/TmMK\n", + "Z0tLQ8wIZeS97Nnz+bDxZzKfxmMj5zadNaSJ4UT3kQqaVxugoaWF3WvWTOs8ZhNrnsxhJqvLpoom\n", + "JrXxJLrPSG9oXZJjY7VPaQSeR+3Fma0UovbfXAK0GrYXMSUmS4nt40xnPoWsINNfQxN+jf/qr/6K\n", + "v/zLv2TZsmX89Kc/5bbbbkt+UBpIqq0gCFlJPLGXSATGe17bdnZwEK/LRbHdHnZszb59+ofM+qoq\n", + "dq9ZE3aewUCA492qt6YyP5/T996rH1u2Ywf9frW66JVFRfgnJvBNTHC9x8OetWsv28inUcg4nRVU\n", + "VFRnrQBNF6Mg+tfea/loLIgDP9/lf1PAaFhqqeYvtFrzw3plOp1unnvuVrq7p9J7R0Z6ovpn5uUt\n", + "YGysB4+nGofDTWfnYTyeakpLr43q1VlQsIj6+nf09iuJhF+kqDOmyRqjacb9Ir2vkeM3QxAZr+f3\n", + "D6ad/qylojqdHkpKluFwRKc4p8L892pHfkI1Crd65kakxPNmQvR4tW1aumyyY3cQ3XfTgxo1zObP\n", + "qG7gj4C3UNu8aCxArcBbCpxAFdORaHPiAZYxJbZz/z04V0maaltDZr+GGR7/6quvct111+FwOHjy\n", + "ySf5sz/7M958802qqqrC9pNUW0EQ5h3xqsMat6965pmodLhYx2nb2kdGON7dHXXOgpCRvtrjYdvq\n", + "1VHnOTs41W6ia3Q07NjrPWqz8UKrlUG/n67RUfr9fg53dl7WVW216JjNVoTPd35GWllkklaZybHG\n", + "FNOPfXbeYxnv8Hn+i29ERTa1CNXQUFtUWq3dHp7eq82Z3V6ib9+06VU9tVJLrb3zzkMMDbWFic7y\n", + "8pW66DReN57oPHt2d4I02aljjPfa2vpw2Dkjx28GxutpEeF0zq/dR0nJMnp6Yqc4p0JjbS31VVXz\n", + "VHRCdKpq8uqyxt+Zo0cfnIHquo2on5YjhWOs8WrpsjeHfn4VVWjFEp27iRadCmrV27kUnZH3GOvz\n", + "+gDqPY8ZtpWg3m898AGxRSdMzacVtS/pAeBb0x+uMPNkWuQ5w+NvvPFGCgsLsdvt/PEf/zFf+tKX\n", + "2L9//zQGEh8RnkLOIb6E+UmkpyqWGIRwkbiooCBKZGrPF9ls9Pt8YefSKHU4ws75PZst6kOm8Tqv\n", + "1NVRmZ8fczx71q7F43RyaWKCgVDkE2BFWVnYfmbMyVwxnXFoAmDBgpuBmWllkUl/xkyONaacXll5\n", + "AwCryor5G+8wd955iN/+9s2Ex2jzECn2tMebN79FX1U9P7/zEPe5vFSHxJ5RTE61fHGn3CPUeO/G\n", + "PqVaBDOWUE2UKjwTfkPj9TZteiXt82v3kalnd7a92sm+CDH/717kJ9REok8l7AuXj/fPQG/UR1Cj\n", + "eFuZSiON15NTows1VfYCcDLG2OOl0mZDlDPydS6JeKwJ0ULDz6XA14AHUft0JkIT537DtilxK5+l\n", + "spDkv4Yze/wsIMJTEISsIDJSGS/iYNxebFf7HRrFYGNtLR6nk+HxcQ53dOjnyrdaAbApCk0bNoSd\n", + "s8jhiPqQabyO1+Xi9L33xhyP2+nkhooKAFaWl7OksJBypxNPSKiaNSfLd+9OKPpmUqROpzepJgCM\n", + "UTqz02wz6c+YybFGwbX7jjupr6riyIZN1K2Ln9IZS6RFij3tscvl5ddrdnPY6Y5bNkQ735YtH/K1\n", + "r704rb6Wxj6l8YSPcdw/aD0Ztsa08ba2PmJa9Cs/vwKnswKHw43DURI3apuMXCvCk8kXIdMj8hOq\n", + "seBObIy/Mx7PCv1n875QioxqGrdF9uTU0HreFgAvhY5bCJQBawmPFEZ+5E2YETgHXIp4HDRsv4B6\n", + "/xtQ5ydRUaFIrg/9vxLYnvkwhZkj+a/hjB1/8eJFDh48yNjYGOPj4zzxxBO0tLTw1a9+dZqDiY14\n", + "PAVByAqm46mK17ok1rlu3buX4z09wJSPM1WS+UoHfD5WPf00iwoKODUwoHs+66uqcDsc+rEV+fm0\n", + "DQ3FPU+8OdGIHHeYD9Xvj7q/ZONOlWz1u2XSn9Hs3o6ZFlOKPH5TSHTGcqxlSqx7T6U/ZCwvdKrH\n", + "psr861OZGpm1SZmdwkDGdQOxi1VlRiyfZiLvJkAbcCuq6Pwp6qduY4RT80LagMnQv2zAguq97Elx\n", + "/xLgI8K9uA7gBuJ7N7V1YUctRrQ9xj7CbJLN7VR6e3tZv349f/jDH7BarSxfvpwf//jH1NbWRu2b\n", + "icdTqtoKgjCrxBNDjbW1afW/NJ4nkljnKnY4gOhU2VTGF6/CpXHfRQUFuvAzXqfu4EH9WKfFgm9S\n", + "/eCTSgXcxtpalu/eTdfoaMxxG8dVmZcXdX9mVeZM97WZLTKp8JnKsemIyUyrqUYe/98cbm4bOMNy\n", + "WwH5tY2Q5MN9OmONde+pRIDjpb9nEj2OxMxz5RLTraqsMjvVSyPXjXlfChgFUh3hAqmR+D05teM+\n", + "jyrMzhAuOhXgfOjncZPGahZfBl5JY/8bUe9fS5EuBa5B9W5C7NfduC48qCnMUlxIiI3H4+HVV1+d\n", + "8etIqq2Qc4gvIbeJl7aZyFMVK4001nm0/bYeORIlkhIVCzGuqcjzNjQ3c7KvD4Ayh4NjnZ2U7djB\n", + "2hde4FR/f1QBohVlZdR5vfp1jB/W8w0iOZXvPB9pbeXTxcVU5ufzVIwKuWE+1E2b4vpUPU4nncPD\n", + "007DNb422eI7nQ1STX80tkEpL1/J5OQfJ9w3VlpqpOAaHThDadcxulJMvcw0VTOV1NR4v0NmprXm\n", + "WoqsWSQqBgXJ/u5lWpFkrtEE0mFU8Wmcg8jcQWNvylPELpCkESQ7vJyxOA7Ee/+0od5fsWGbdm9a\n", + "ivQHqOnEMPW6R/bt1I4pQk1VDk/Nlc9SwlwgEU9BEGaMWNHDWFGTRC1QItuZLN+1i9P33ZewEi3A\n", + "oscfZ1VFhd465ZHWVnpGRth65EjCtNMwsXbpEofb2/XUWUVR6BlTPUOHOzv1gkMepxOvywWKwt51\n", + "69SfQxijhfWHDnG4s5MVZWXsqKlJOn/GHqE/fPnlqAhpZCQyMhJrt1rZ6PXSOzqqR2Mz7Uk4nSiq\n", + "WSm/s02q0beBgTP4/WoD+qKiK3E4ihLuGysyGhnxSjfyl2mkMJUIsHGNpXusmeMQIkkUFcwFEgln\n", + "YxpxBfAcU1HNyhjHLUctOFQNvBbjWjayI/oZWWW3HNXHaWyPshZVjK9AbQcDU0Icol/3yMi39nx/\n", + "6Dy5+sWEMJ8Qj6cgCDNGLE9YLF9mrP2M2yrz83UBBqrQW+HxUGizsaOmRj9PpCdSo76qip6RkZj+\n", + "tEi08XVeuqSLXVAFrtvh4HCn2kttRVkZe9et4/bnn+fC2BiD4+Nxz20UgpFjbmhu5vm2NrX3Z0UF\n", + "ewxRX2OP0I1eL3sTpOYm8nsO+/2meTSn4/eM5w1Mh0w9lNMhVR9oOv68VPdN14Nqhmc1kzmei9fH\n", + "bF/t5RRhnXuMgvLnwMPEFs41TImpCqZSZzWBZjzus8A51IJCdwH7yA6RCWqCoZUpwWlFFYKtwBdQ\n", + "xxo5BwOk94WC5octQm0zsyd0XLrnEWaKbPZ4poP08RQEISuJFZWMlVIba7+odiYhD2ORzUavz8fh\n", + "jg4cVmtUOq22n1bxVotcvtPfrx+vtVmJhTY+7fhyp5NyhwO3w8Evb7uNOq+XjV4vRzds4KcnTtDn\n", + "8ySAV+QAACAASURBVOmiM7JNi4YWJTSOWUtZfeqDD6Z6f3Z0cPXOnXoaq9YjNJUIaay+o9p8mtmT\n", + "cDrniucNTIfZr/qZPP1RI5300FT3TfXaxv0dDjcHD9ZNu7rsXLWnmS7Ga+7ceU3a9z0XY85+ItM1\n", + "ZwpjBduHiV+K0xgN/WLoZ2NU0HhcFzCI2j7kWbJHdK5FjWYaP48XAi6migVF3gukX6K0EdXLOYwa\n", + "4dTWdKalUgXBPCTVVsg5mpqaqEkhTVGYe2IVpdEic2eHhvAWFlLscFDicFDhdOIOFQAyHptvtfLg\n", + "0aN8rqyMm+12vU1KpIjRzvu58nJustn4n7fcwsOtrWGRSwvox3/xqadY6nJRYLPxPZuNu+64I+bY\n", + "O4eHOd7Tw+HOTh5ubQ1Ldz0zMMDFwFTK1BNf+UpMMZYsLVijMCSqNX/pnrVrUy7qY7zGU2vX8nBr\n", + "K9tWr+aR1ta4RZimQ7x0y0SYUZwom4vORKaHJnqPmslU0kwLHM1Vexoj6UQhtWvabEX4fOd1AZnq\n", + "fWfzmorErL97yed3dgoVpe5LNaaTamPKR43o+VBbhWiRPWNrlQDR6azTwYIqwl+I87xWNTeSItQ2\n", + "KM2oVXcJjVvrqTmIKg4row+dNm7UKrdaFeDEa1o+SwlzgaTaCjmHvFnmNsa0Sw2P00lvKAIZmYoZ\n", + "maa5bfXqmCImXjqnMTX0/YsXGQgJxXKnkwuha942NETTX/wFn921i66REcYmJii22xkPBrEoChd8\n", + "PpwWC5PBIEHgS5WV7L3jDrYeORKW2msFbq2sjPIyxkov1sa1oqyMRYWFOCyWMFGdbnQyXmsZM9Jc\n", + "s4FEqaTZljI5V+9RqabxxpuveHOcyvymkuqbynnSaaeiXXNsrJ/OzsNptyIxu6XOTGLWmko+v8na\n", + "l5hFvPTPVFrD1DAljkEttrObqdYqt4Yem9U6xYNanCcSK3AWeDBiPEa0scGUZ9MFDMXZJ5J0W+Wk\n", + "nlYrn6VmH0m1FeEpCMIsowmuErudi4GA6p10OuMKLm3/IpuNm6+4gkUFBTF7YUbut2fNGh5pbeVU\n", + "Xx9nBwd5ZdMmvtvczOGODlaWl9M9MkLn6CjFdjsnN2/G63Lh3r49LIKpoQBWRWHc8F5W5/VS7HDw\n", + "n++9p2+zMPVRR+vhqfs3PR72rF3LzXv30jUygs1i4aYFC8KipPHEoxnznaqYzcVCQJdr78dIjELq\n", + "B0533I+r6c5XuvvHE5jJztPc3MAHHzyF399PeflK7rrrN7Pmb71cSP7lhFl+wOn2Fq1hSsTFE2Sa\n", + "OAa1sutypnpZPkJ0L89MsKPeQ+T5lNC1J1E9mu8DHRH7lKJWn53ybDawijMsoIATNOLHnVTg15B8\n", + "PoRcQYSneDwFQZhlNI/gW5s3617BPWvWxPUNNtbW4nE69Wjgk++/H7MdS0V+PjZF0fdraGnhzMAA\n", + "x3t66Bob4+HWVv06v7nrLpYWq6XqBwMBlu3aRdmOHYyMx/YEBSFMdAI0nzvHzrNnw7ZpolNLqT0z\n", + "MDDl3+zspKGlha6RES4GAlwI+VS3Hjmi+01j+V8zbV+SriczXrubbCaXUiZnEqMv1Oigi3Qvpjtf\n", + "Q0PqOrfbS7jppseS7h/PO5nsupHVgdPxt6bjh72cSe4xTtS+JB3PZ6IVqBHr3Mkq3NagptCuBzai\n", + "OsaOh67zbcJ7edpRo4vTQUvbDRAtOhcBt6D6NvtR7zNWRHQQ+AxqJBbAzRmu5BitHMBPA4tJHlU2\n", + "o1XObPl2BSE5IjyFnEN6T+U2mrjyuly6yErUw9PtdHJDRYX+OBASgJq404TZ821tujjUivyE9dC0\n", + "Wqk7eJDhUJXYtiE11ckK+E6fpt/vJxAM4rRYuL68POl99Pn9+CfDU7lcdjvrlyzh2tJS6g4e1Asa\n", + "gVogaNvq1dgt6tuuBfBPTnKgvZ2rd+5kyX/9F7c+91yUwMxUCCaa21iYUQhotsm23o+pvEfN9EfB\n", + "RB9X052vwkIvAIHARVpbH066fzyBmey6xuNqanYkvc7lhFl/96JFerKVmIqAjEUqginWubU+lbEE\n", + "mbHf5+9Q/ZLGL+N+DbwV+tkOrCLc95kMLVCzErgt9LM1Yp+VwDuE99gsI7yQkXbNCVRxugxtbgtC\n", + "46jGwza8wFYSvwMkmg8jiV7H2K+hfJYS5gIRnoIgZDUNzc0MBgI4QoJtZXk5VxYW4rRY2HrkCPva\n", + "2jjW1aW3HSl1ODhxzz24nU4q8vPxhITt2YsXdQG36umnGQztPxFxva8tWcKCUH/OVLEp6geWodA4\n", + "24aGONbVRa/Px6KCAr0Krtvp5LW772ZxYSGrFy7Uj+31+WgfGeF4d/eUEH3iCW7du1cXr5p4ziT6\n", + "mQpmVsCdLcyKeM1mXGC6H+dTJdHH1XTny+FQP2SnGiGNJzCTXTfbvkC4PEi2EqcbcYu3Ao2/ZZpA\n", + "M547UQVWbSxFqG1VDgDG96gxpn5zi1FblfQBi1EjlLEwCkstq+VK1KimhymB+TnUCrS/CY2tMfR4\n", + "I2qqr/aXpIQp0arhQ5vbRhqpp55DLMOtR2qvJv67TqoVaRO9jmZETYXLhZ07d7J8+XKKior4zGc+\n", + "w0svvWTq+cXjKQhCVhHpMVy+e7few3NRQQHv1NdTd/CgXjDHrih6FNSCWjRoPBjkeo+H0YkJvaJt\n", + "ZV4eXWNjVHs8OC0Wvc+l2+HQxd/K8nJ+c9ddACzftYuusTF9XEU2G8MxUnEVpj6uACxwOvmCx8Ph\n", + "jg48TifLSkoodjioyM8P86YCNLS0cKi9nQG/Xz++0Grl0kS4HF5cWMjbmzeH3XesQkHZVmQn16hh\n", + "9txUs1XCxQw0D6XVms/QUFvY+pI1l+skW4lm94CsYeq3rA5VfCY7dwPwPDCKKjSXh85RDTyFWuG2\n", + "K3SuAKqYLEZNg60GrkUtAvQuagQyiCrGalArzx4L7T/I1DxobU5AFa5vJxijNodam5cS4AHgCKro\n", + "jDW3xp6bw6FtmbzrJHodpY9ntpDtHs9Dhw7xp3/6p+zevZsbb7yRc+fOEQwGWbRoUdh+4vEUBGHe\n", + "EJla6jOIsPFQaqvWp7LYbufGBQv05yeB8z6f7qk09rOsWbRI7ek5MsKr59Um5FbgKwsXsqykhDyr\n", + "FYfFwuefeoq7Dhzgc+XlrF+yhCWh6Gq8N8vIt94en49jnZ2sX7IEi6JwvKeHA+3tvBCKzGr3paXA\n", + "VhvSiAHyQqmuJaE+otUeD29v3ozb6UyaBit9CTNjNuMCqSbQZQNapHJoqC1qfcmay3WSrcRMekAm\n", + "83BuT/HcZ1CF5UXU1iWnUYXhIdT+l6dD97AqtP8EqujUPJRtqD7QXuBroe2ngBeBvaFjTxI+D8Zx\n", + "JhKdMDWHH4TG4w6du4v4c6sdc7PhOpm86yR6HaWPp5Aajz76KI8++ig33ngjAAsXLowSnZkiwlPI\n", + "OcSXML+JFFfXG4RZz9gYDS0teF1qwYjBQID3Ll5kQV4eoApRjRVlZbxSV6enjZ4bGaHX56NzZESP\n", + "kE4A+z7+mOMtLYxNTNB6/jztly6pfTs7Oii026lyufBNTjIYp/BQLALBIEc6OsI8oFq01ON00jk8\n", + "rKfL7omIWg4FAtR5vWHFl7SUV2Ma7COtrVFpt5pHbo/zh/zDpftZv38/Dx49OuPpufMFs8RgKu9R\n", + "ufhRMJZ383Iq7NTc3MC+fTXs378eny+zZOx0zzVzf/fMWomxRKYx/XMVU4WBNpLeb1mkP7MHNbr5\n", + "CLAQqEIVlu8a9lnJlGDUisAVAz8DPkEViDB1/17C5yGdd4N4c5hobrXn9qRxnemMIT7yWSr7aG5o\n", + "YF9NDfvXr8c3kP57TCbHT0xM8Prrr9PT08PVV1/NkiVL+MEPfsCYIfPLDER4CoKQVUR6DPesWUNl\n", + "yHOpidG24WF9/56xMW654grqq6o4uXkzdV6v7qnUChjdvHcvL4VSVItCwhbUiGdktVoNh8XCsc5O\n", + "PVU35j5K/IwS3+QkYwax6p+cxGGxMD45qUdBtchnucFL6Z+cxG618tMTJ+gZGYlb9dYYGb5m507W\n", + "79/P9at3UFVVj8+9mpbuXg60t3Pg449zrkrtXHGyuYFv7KvhZROERTLMFDGxMd+xGsuDORu+zJmf\n", + "q9QwRnd37rw6o/HMv0hxLI+hMWqopbQeRjUopLNWGlHFqpbdokUH/ws1qtgPdDK1ziuZ8mLClMgc\n", + "BD6L2ucz2e/FbH01lItfQQkzxcCZM3QdO0b7gQO0NKT/vpDJ8d3d3QQCAZ5++mleeukl3nzzTU6c\n", + "OMFPfvKTtMeRCBGeQs4hDY/nB/HahERWYXU7nZy+994wMeotLNT3L3U42F5Tg9vh4Oa9ezl27hyX\n", + "DL04G5qbef/iRb30Q5HdrotTlxYhXbYsanzjk5P0jI3pwjRSYlqBP6qsxB5HfHqcTr2Crba/f3KS\n", + "gdDYtCq3AK/ffTfO0L42ReHQJ5+w++xZXTBeHRKWxnnSIsNFNhvnfT4OtLfzg9aTrFmzmyK7GgGu\n", + "9nj4YqhC70xUqc201Uu2YZYYSOU9amDgDI91LeGH7ctZvftnMzB/5pcvilUcaDZamWSLSNOiuzZb\n", + "ET5fb0bjSTdSnP1/92IlqmtRw2tRi/xopOtxc6OmxL5LeHQwuueyyirChZyxAu0YpFTUZ/6T/Wvq\n", + "8sNWEHpfqK5m9bb0M0gyOT4/9AX/D37wA6644grKy8v58z//c/bv35/2OBIhwlMQhDkhnTYhRjHa\n", + "0NzMqVAKiRX4QkhYRfbM/OLTT1Ozbx9PffCBLjqtwCt1dTy7bh17162jwJCaG8lkxOMg6OLQqihM\n", + "AMfOnWPt4sUsLiykZcMGFhcWcrfXi8fp5ILPx1Ao4mlTFL0qr8ZVLpcurr0uF13f/CaeUGGkgUCA\n", + "iwbx3BsSlvcePqxvq8jPp8Lp1M9rFJbGqPGetWtnrEptLvb8TMRspo3abAV0s4D3WMbvRj0zMH/Z\n", + "Vckyk6il8XWxWvPnLPqpRXevuOJmfTzTXSfzr4JvrNRULZrXxlS7kRJgxzSvERkd1ASlhfB+nY4Y\n", + "Y6s0XB/Uoj69qAJ0OdHiM52MAemTKZhDbWMjVfX13HnoEE53+u8LmRxfWlrK4sWL075mukhVWyHn\n", + "aGpqkm/q5gHr9+/nQHs71R5PWqKoZt8+vbKrxtL/n723D2/ivNNGb1lf/rZsy8QhBgU3hKYfCU7c\n", + "0ha81tZOKSbUboKSJu1F0rO1djdtt/tuN+w53bNnu233fa/T9Lq63Z7Tbjh9NyRN/YKTNIEU3BQT\n", + "/FGSOk1DIF+NuyTQGjDGIGHjD9mY3/lj5hk9Gs1IM9JIlsxzc+nCmo9nnueZkTT33L/f/SstRXhu\n", + "TimpAsS7zTptNmxZuRI9IyOYW1iAx+3G9SUl+N2FC8A772iqnjxYmZaHhoYQmp1F7+nTcX0PDgyg\n", + "+/jxGNIIALVFRTg/O6vkljptNtx7ww0xLrcetxsrfvYzjExNAZBupdTk111QgNkvfSluHpjrrVli\n", + "uXv3+zE9PYqCAifuvPMVlJX5lHVqd+FjQ1+Ncy9N9RzmKph7a1PTjrTIgJHvqEgkjKbuH+G3M15l\n", + "/rTmOHXklpPl3r1+jI5KLqH19QG0thp37+TPy/PPd6TcjlWw6joxg/z+3VO7vvoSb24YJyGFzf4a\n", + "wJcghfE2IDbMFpA+B29ByvV8HsB3IIXn9nLbqB1l/TDucW1m29xBfl9T+Ylcd7X953/+Z/T09GDf\n", + "vn1wOBz4zGc+g09+8pP4l3/5l5jt0nG1dSRaKSAgIGA1GKFx2u1o9/mw0+83RViKOdfXi/Pzkro4\n", + "Oxtn/sN/JfJlWGZkl9zzkQguGAxvdNhs6ONyRsORCIKDg9jR1KSosMPhMI5duBBHOovtdvymowM3\n", + "7NqlLFtWVIQ9J04o2960ezfevuce+EpKFOKpJp0A8PJnPxs3D+mQvunpUczPXwQA7N27AZ///J+U\n", + "dUzNBKSyL1+YHlZu+AcHg2ht7UZXS0vMPKihJq+5TkxZ2Gi2jvWru78eM38spBSIznHqkNShXDkH\n", + "6ajJ/HnJBTMjq66TIIIYxjCKUYwudMGTAw8IMoMuZOYhiA+SURAgmfSojxGEFHJ+DBLRBCTS2Q3p\n", + "wcxNkHJEtaICzEQM5FZ0gYBAqvinf/onjI+P48Ybb0RhYSHuuece/OM//qOlxxCKp4CAQFbBK3Va\n", + "tSjVUN84f+3FF9Hzxz/iA5WVqHS7cW52VjEAsgMokOt68ornNYWFIADnZmeVZWpFlEeVy4Wpy5cR\n", + "4Vxp230+PLtxY1x/tg8NYec77yhqJoPDZsNlIqnkS02NUlP05qoqjE5PY0zlFBeor8dLZ88qxPOD\n", + "Hg9WV1Tg6zffjNv378dQR4cSVgwgjvxqzZWaZKjX79lVh0hkHHZ7Me6++60YxVOtZr548LMYGemB\n", + "19toODzQ7LnOZaRD4NjtbzGkW3C9mdu/v830HCdDrpwDq1TCxVAbMwU//OiXlbIAAujOE6Usf+BH\n", + "VIkE4mtcakUFsE+rE0AJpLDgZNdZutEFRr8hjG4nkKvIdcXTKITiKSAgkJPQullPVotSDbXyNjY9\n", + "jXORCPpHRxGor1dKqNhtNiwQYYEIdSUluMjlWJ7VsAP3ut04F4koyimP8NxcnOI4cOYM2vbvx8Tc\n", + "HA6PjSn9+cXJk3GkE4i65U7Mz6P39GksKyyEr7QUZQ4H3lIprWwu7ujpUYjnDRUVeGbjRgDAzF/8\n", + "Rcz2/Lzy749duKCEGwcHB+NIhnou/+edr2Dv3g04cM0j+Omhoyh2vKmcJ7Wa2dLSZfqG3+y5zmWo\n", + "584MgWM2P4B066hHL1KZ42TIlXNglUqYTVU60yiWlbJGNGLHoiplmSY0VrQf28bAwHYDYelMiVwL\n", + "4HpIdUP57VjOKA/+0xow2FetdszA6DeE0e0EBHIXwlxIIO8gak/lD7TMZ9TlUpJBfeN8fGICgFSz\n", + "8+F165T2/vzaa5XtXt+6NaaGpvqLrqG6Gr+9804E6utxdOtWOP7wB2WdQ8elNjQ3h56REYV0Mlfa\n", + "uYUFze3VGJudxclLl3B4bEwhpaUOB9pWrFDmotzlUsZQ4XLpOsby83pTdzfeunAB/aOjCumskOdG\n", + "DfXclZX58PnP/wknpi/HnSe1u3Aq7qVmz3UuwwyBU39HGQ3Ey4RD7FI6B0sNXehCAAEcwIGkYbaZ\n", + "/d1L7ICcfjkbKxyWY9sw5nTMDI8OAXgGxkjkYoTNGj2mke2MGx2JeymBxYAgngICAhmD1s26mtAk\n", + "A3Nv9cikzFcmuRdOzM/joaEhpb0nb78dq0pL4S4owH0HD+JDVVVKG7x6aYNEwD6xZw/6T5/Gjbt3\n", + "4zJHUi8TaeZXqnHswgXUPP44ktHOKpfaYVEKCQaAS5cvo/fUKVyUCWNXSwtWlZXBbbfjuZMnFTJ4\n", + "689/HkNCi7lapKMzMwqhLLFLLV+U50YN9dwx6JEqM+VStLY1e65zGekQODOl6K1GqueAkY3v7m/D\n", + "7ZFw3vh15krNTyPwwINudOdAbmdiQpN+ORsryFxsG8ZyfVOpkbkYn1ajxzSynfVllAQErITI8RQQ\n", + "EMgYtPIQjUIrfDRQX49LsvKoZarD57PVFhVhdGYG5U4nJubnUepw4JLKgCgTYLmdDO0+H4bOnsWo\n", + "HO5rB1DucsU48BYVFOCjy5bh+MQEJubnMcGF/jZUV6PY4VDyWGvcbtzi9eLY+fMYm51Fo9eLp26/\n", + "XXLbjUTQe+oUGr1eXJybw9jMDJwFBXjlzjvhKyvTdaHVO09m8gNzJZdQwBrwLrSv1Afw/7V254Vf\n", + "ZzruuVcvEucopp97bIXDcmwbkcj9GBzsQVPTLXC7n0yj3aUG5iCszmcVyAWIHE+heAoICGQQ6She\n", + "LJyUEbRGrxdFdjsm5uZQW1iIp26/Pa5dXrn7TUcHAvX1OLZ1KwL19fjYsmUx25Y6MpPi/ufLl6NI\n", + "Vh6dNhtGp6bwoepqtK1YAXdBARaAGNIJQKoJOjqKkenpGNIJSPMwJIf3ljgcOCeTy49fc42i8G7Y\n", + "swcDZ87gt2NjWFZYiBvKy/HuxAQuzs9jPBLBhr17AeirdnrnyUx4KdvW63bj9NSUIZVUIHfBFKWQ\n", + "txFPNO3IG7/OXHC9XSykrvYmVgbN1xxVh3smat9oaGhsG273SbS2noPb3Quh7PFYzPgKAYHkEIqn\n", + "QN5B1J66OsDUuYbqalyIRFBXUoK3QiGFtBXZ7bjV60W506kY4oQjEdz6859jeXExyp1O1BQVKbUy\n", + "f9zUhBt37cKc/H10+3XXoffUKcnZ1kAdTyP4QEUFGpctw7PvvRdX3qXa7cbFubkYNRSQyKmWOREg\n", + "helqGR1Vu914v8cTMx88vG43xmXSZwdw/N57lTBbI1BK3hQUoNTpxKMGSt4w1fT01JSizl6tyudS\n", + "+I5i7rE3N+3AV9weU1rVwEDQwnqk5pCK620+lDUxck3ljtrrR+ZrYAplL10she+pfINQPIWrrYCA\n", + "QI6Cd1XteP55JYyTgZUnAYA1u3fjnXvuwfahIVyYncV7k5MApLDUczIB+8jPfx5D4EocDlQ4nQir\n", + "FMZUUVtUhMMdHVj+xBNKrVAe5zn1rwBS3qmroADuggLM64QAT12+rJtvysYOQAknBqTQ3OrCQvSe\n", + "OgWnzaaE2ZoB7+AaqK/H9qGhpKVEmGratn8/gFiV1EgpksUkKwLx4N1jzdIXa+uRmkMqrrfDGFbK\n", + "mgQRzNuyJrmj9maqBibvbPtjAA/B+tqgySBKmggIpAMRaiuQdxBP6K4O8OGfLIyz2u1WnpbZuW3H\n", + "ZmcRHBzEcydPKqVRKpxO3CLXvSyVQ1SZ2thQXY1ylytKOtNUO20A3r77bmwfGtIknWowMrlw5YpS\n", + "8oX1k2FtVRWucE8UPXLZGK/bjQV5+YcrK9Hu8+HY1q1o9/nQ4fPhhTvuwJOtrQjU12Ns27aY2p9G\n", + "oQ6x1XIn1oNWOK+R/dM3MEkPVprSsO+ofDK6sRKJCJBxz03rEEQQfvjRhjaENY6aO2VN9GHkd898\n", + "SGymYCbc08y2vHHOhwD8CsBqACfT6axJLB3zHnEvJbAYEMRTQEAg58HIjMNmA6NpFTIRA4AyhwMP\n", + "r1uHCEf67HJZlA6fT8nvLLHbsaywEM986lM4KauiPHgyW66TA1pss6FtxYqYZZUuF+7o6cFT775r\n", + "eEwFQIwj7u3XXYc3AgF0+Hxo9/lwaMsWlHB9KHO54HW7cZkIYTm8tnj6GIILP8C3XvkNwpGIMv7t\n", + "Q0MYm57GfQcPKnmWZhxq1eTRTK6nVr6okf0XW62xjPgGg4DfD7S1ITz+VrTNbwWzy7YWEYkI0GLc\n", + "tjNFswc9CGoc1UxZk1xGJsrxpAYzbrJmtuXV0QIAFwGMA9iA7D3SyGa5lcV4TCMgkFmIHE+BvIPI\n", + "S8gv8GGWfM6lXshlonb+8/e/V8ia02ZDicOhqJZetxsEKaSVd7AN1NdjR1MTan/6U0TksikdPh9e\n", + "OXcOI9PTUmOqHM+bystxXWkpek+fjutHAYCm2lq8eu4cJg3W8DSClSUlmLtyBZGFBdxWU4PlxcXY\n", + "e/IkwnNzuLmqCmUOh1JDFAAKMYfr8Qd4cBG/wcch6a5A24oVmJqfj3OY5V1na9xuNNbUxJyDROGw\n", + "6bgTG90/ldw8K5G+c6cMvx99/f3wA9j/r7UY8Y7Ce74Rm799AO4Zj7k0tiWIxcjMa0MbetCDRjTm\n", + "Lbm8un739MJZeWfb1QDGMTBgRzjcCIdjGC0tIUhfL5n8kFnh0GsUfqSW/2oMV9c1lRvI5RzP0tJS\n", + "2Lg65jMzM3jwwQfx7//+73HbihxPAQGBnMVzJ09idGYGAFDtcuG8rNYFBwcV4xkjOYDD4XCMQjhP\n", + "hGmZXJY6HIqZTl1JCd5fUYHe06cVh9X7Dh7EHFers+/MmYR9/v3EBMpdLk3jnytAXL6pHZJ6yXI3\n", + "U8HU5ctKHmjvqVOocbsVZfOtCxdQLtcDXVtVhT9NTeF8BPg9PogyzICRTgB47fx53CLXMOUVRqY6\n", + "srBjFvbKzgGf18kvB6IqZqowsn8quXlWoqWlyxriWywrIo2NaPnSUxg89hCa9u2QSGe+WMNaAD3q\n", + "0IXs3bazPjixB+3oxE78W16SzqsPTBcHpLPIvhc83N+vANiAcPg6jI5KNYkHB4HW1kx/yPg+ZBrZ\n", + "VFcFrnZcunRJ+Xtqagq1tbW4++67LT+OUDwFBAQsg5pAbh8ailEplxUWKrUn+RxAIzUgmcstj2q3\n", + "Gxtqa/Hbc+dwenoa5U4njm3digqXC7c+/TTOz87GucuqcXNVFd4OhXSdZY2gyuXCBQ13WQZXQUEM\n", + "8dXcxmZTHHdtALR6U1dSgte3bsV9Bw+iZ2QEN7ou4rrq1Th0RlJCCwsK8Pt77kGFy6UojMwYyGm3\n", + "o8ThwNT8PHpPn445B+/fvRv/dfEiFgB8yOPBYHt7QmXTyIOCqxbhsBRuu2MH4JFJTjZFEg0shnGT\n", + "H/FaTbZtWbT6IKCP3DH4Mq6LRyMVGrB580q43TsTbp8vGAgGER5+C47i42jp+g3cHt9id0nAAuSy\n", + "4snjsccew7e//W3813/9l+Z6oXgKCAjkBNSq2dj0tEI6PS4XXv7sZ/HQ0FBcyKVWDqCa3DCXW75c\n", + "x/lIBIdHRxXToIn5edy4ezeG77kHK0tL8Z78BM9hs8WVMWGoKynBssJCzbBaI3DYbLipshKHz55F\n", + "id2OKY3wW5fNBp6Waimpc9x7rZ6udk3hmyVP4sWDP0OV629Q43ZjZfVN+ElzMx789a/x2vnzeLG9\n", + "XXGw1VIyA/X12On3x4W9jnLn6cLcXFIiqT7PHpdLEFEGjwfoVlGcbIokGlgMl1ktrUZPx7IKauJU\n", + "LBMnoRcZw2/Dz6FM/lwfHPwi2lqfWaSeGNfFLYtUyDGEh4cx2n8YADAYfAit6u8UgSWJdB/+WPXw\n", + "6LHHHsO2bdtS2jcZhLmQQN6hr69vsbsgoAM1gWTvK10uvHbXXfCVlcUZzwCxZjbbh4bg37sXMEr3\n", + "VgAAIABJREFUT737ruKEeuOuXbjv4EHsaGrCLz79aRTZJRsgO4DxSEQJSQWAuStXsGHv3phjr7/m\n", + "GmV9md0ec2xXQQEK/vCHpGMrQNRZlsdlIrw6Pg4boEk6AeCSarndFv9AkPWKN00qtNlwXXExql0u\n", + "FNFFjI0dxv8YqcYz7x3HuUgEvadP46GhIezbtAmnvvCFmLIpzEzozVAIQPScaJn/zMr9KwDQs2lT\n", + "0rlIx/X2akCufUcthnGTlldppgMH1QZR6j4EB4Lw7/WjbX8bwnnmMpyNa2rCIYX6v+cFnmhaTFXG\n", + "uOHQ4hoqZc78xyGH7HsbG9G0IzOf2Vz7nhJI3+TOCpO8kydPYmBgAPfff39K+yeDIJ4CAgKWQe2G\n", + "yt6/e++9CWtJ8mSIkZiQTCbVOYketxu3yiVCGJ1rqK6GUyZzxXY7fv2ZzyjHri4sxJHxcYk4ulyw\n", + "q4hnKBLBb8+di+vT8uJiLCssVN5fAXRrfi5cuaKpUlbJeZnqZc6C+K/eBUjq69GtW9G2YgWK7Hbc\n", + "4vVi+vJlnJ+bw7H55XgCX8AFx/swTRI5rXS5dF1i2TyORyKoKymJIfVqZ9u1ck7oFQDfOXJEsz0g\n", + "Smbnr1xBh8+XkuutQPZRVFQDt9ub1ZtzLepgpnBGKlATbHUfhsPD6B/tR89ID4KLULJnMZCslAyP\n", + "11puwyv1wMDmtfiRe2fGerR0nFqfQ9Sj+QFLW27p6kJ9IIDNBw7A7Vk6Sq5AYqT7kNCKh4w//elP\n", + "0dTUBJ8vM+HdIsdTQEBgUcBCaY9PTsJXUoKTly7BV1aGd8JhjEciWFtVhevLynBJzklkxPHVu+7C\n", + "Xw8OomdkBCV2O0qcTrz82c8CADbs3YsN11yDM9PTStjn9V1dSm1PPahDcddWVeHQli0AgJt278bo\n", + "7KyyzobYUigFAApU+zttNthtNly+cgV8hul1xcWYnJuLyTtlDrylDgc+ds01eFIm4HzeKwDcVl2J\n", + "/7P0GXzl3Cacmp6Bw2bD7+68U7dOJ8uJ5XM59XJptbbVgt7+6breZgq5k7O2uNi716+E2tbXBxbV\n", + "xCmTSOaM3La/DT0jPWj0NuLA5gPwXAXXgx9+9MsBzgEE0J0gwDmMMIIIYgd2ZNCEyY/sZ95mKru4\n", + "CkBI/rsDwGKFJgvkC5LleKbr7m6FO/yNN96Ib3zjG3jggQd0t0knx1MQTwEBgZQQDALDw5KJZ1dX\n", + "1Ecl6X4y4Tx24YKiaqrBTHQ8bjfCkQhqHn9cIXZs3epduxQnW54EqcnRk6ramg3V1Tg1NYUxjkzW\n", + "FBbiHPfeV1qK60tLcXxyEtcVFWFofFxZV2a3JyyjoudsawdQ6nQqJNhhs+FTdXX40YYNuGX347h4\n", + "RVIx7/TV4emNbQoZbKiuxsrSUuz0++Fxu7Fhzx4lx1XPiAnQJoN6BJPflpkRaeVrGiWouQKjhGup\n", + "E1TLSsXkOcKRMIKDQexo2nFVkE4gF0vJpFtQJxUS6UdmyO7tAHoBNAB4wWBfBK5m5Lq50IsvvohP\n", + "fepTOHv2LEpKSnS3E+ZCAlcVRO2p3MDwMNAv/5YHg/F+Knrgy6sAUk7jxfl5lDudmJifR6nDgfd7\n", + "PPjaiy/iVyMjiCwsKMVCWBitx+3GR2pqFBLEh3eysE+v243TnD04Q3VhIZ751Kfw0WeewdjsLNZW\n", + "VeHs0aPAihUAJHLI18EcmZqK2Z+RTlZChY2hwGZDaG5Ot5zKAqCQzgqnE0e3blXCj9/nGMOrc9fB\n", + "h/cwef4U/Hsv4w8XL6La7Ua1262QTgAol3NA2bjVynG5y6UQRjUpZQZNjIxqudMmKqui3j/XYTTs\n", + "yGrzHfYdlcj9NxnZtZIMLyUDlnS0K4/bg+48VXuN/e7Fz04XurKgYppBugV1UrGoylR28ZNYVLvq\n", + "NCHupQTUePzxx3HXXXclJJ3pQuR4CggIpASuXCHMeB9EOLXQXVCAgc98BoH6ehzbuhVetxuXLl9G\n", + "76lT6PnjHzE6M4PQ3BzmiVBot+Otu+/Gvx45ouQZ+kpL4S4owH0HDyo5i10tLVhVWoq5hQUcHhuL\n", + "O37vqVN4aGgI79xzDwL19Ti0ZQvGOCJ8aX4eFxOURgGAQrsdf37ddQAkc6L3V1QoNUWdNptiFGTX\n", + "2f/Ply+PyXn9B+9ruA2v4NtVAzi2UI/+0VGcnpnBedlAqObxx1H4k5/gY888g3kitHP5lYwojkxN\n", + "4fDYWEKDH4/bDY/LhY7nn0fb/v1468KFOFOgRPmaamMilvOpzhnNFbS0dKG+PpBU5cuU+U4i06Vk\n", + "JhBWmEQwLK4Bi7VgtKMH0i1/MqgzCpdShmE84mfHAw+60Z0C6czUTBk3DtJGKiQyU9nF6Y5FQCC3\n", + "8B//8R947LHHMnoMoXgK5B3EE7rcQFdXfLlCPfDKz83V1eg/cwYAELlyBd85ckRR1XgV0+NyKSVO\n", + "Gqqr8cIdd8Qpcl63WyGXK372M9htNjgLCvC+8vJoKRVIamOFy4Xw3BwavV4U2e3oeP55hWTZ1qwB\n", + "5LARp82GIocD8/PzUt1LjTqgQx0dWFlaiuDgIPpPn44JxeXLpGgF5DZ6vXhUdQ0/X/IVzLtfxRNF\n", + "dyBy6ULcPpeJcJkIQ7IJUm1RkbKOjYEpx8kMfvj5q5XNk7xuNwZOn0bVzp24uboa7T5fjMpqpC2m\n", + "juZSjU9GuJLBakWQfUclIvHJyO5iONFaiUxl1ZmlHWp9bAyZLemSKah/97QVcSuVvUwXv0n1CklF\n", + "MV3kekY5CnEvJbAYEIqngMASwGIoT6xcoZHcTl758bhcCnFS35DzrrhP3n472n0+dPh8CukEYm/m\n", + "XbJDrdNmw/Tly7g4P4/xSASvnT8PQFIjFyDVxQzPzaG2qAgHNm/GycnJGCXKKxMwO4Cbq6owkcSM\n", + "aMsvf4mburvROzKCC6r5ZuVQtNTO5cXFmrmRxydncCxSiV+dGoVLdry9uaoK7T4fHBqlV0ZnZhQF\n", + "jc3Z0a1bYxyF9a6J4xMTAKSQ3ec3b0agvh5rKipwdnYWobk59J85A5fdbogwahGrfCytkilFUO3y\n", + "zCOZGmtUreWRS+VCzCqTRmFWu1JTsePy+woAD1vYr+xBUiLD4ac0FHErlb3MFb+RnHZ3og39CJt2\n", + "hBUqo4BAPkMQT4G8g6g9FY9cv9nnCcpOvx9v33235g05H8rpcbvx7MaNeGbjxpht+Jv5VXK46jyR\n", + "kltpB/DyZz+LQH09PlJTE1PmpMBmiyn/wfJAJ994A4CkUL4qk1YboKl2AsDpqSklDJiZHhXb7VhW\n", + "WKiEDm+49lrpmNx+H6mp0SxpwvpT6nCg4Gwlqv/kw7KfbsHOdRtjapDyGJueRjgSwfahIYxNT+Ov\n", + "VbmXz508qVwTD/T1KUT0kkyqJ+bn0fqLX+DS3ByKHNHgl4bqasMlUbSIlSitEv2O0qqZypCM7KZC\n", + "hnOpXEimaItZ2qGmYj4AXxgI4i/2+vGz/W2I5Ek9z+jvnkTpHQ7JTTVWEbeSlGWu+M0whtGPee6h\n", + "REIvEoEMQdxLCSwGBPEUEEiAYBDw+4G2NiCcw/cnuX6zryYoiW7Ik4HflxntMNgAvHrXXfh/3nwT\n", + "Y9PTeIc7aYUFBXixvT2mP2sqKnB4bCyGYJLqfy3wdJQplNMLCxibncV3jhzBsfPnldqh7Eu21OHA\n", + "Dz7xCc2HBF0tLUp+62jFGZw/a0fvXjeCQeDZjRtjQmsZ+kdHERwc1H3owCuxg2fO4Kl330X/6KhS\n", + "i5Svj1rqdGqqy8mgdR4TqXwCEjIVoVAsh+c2ehuxY5HDczNds9Mo1FSsHMCy8DDWjPbDa0H+rFUY\n", + "GAhi714/9uuQ4e/he3I9zjcRBtDSshb19R0ZdCnOnLJYLD+WkB5KfBjAo5YfwzyWdvavgECuQJRT\n", + "ERBIAL8/6twaCBh3bs02crWOYqYRjkRwU3c3RmdmUOly4chdd8FXVhZTUqW2qAgFNhtebG+PMfQB\n", + "ouVB1lZV4Y1QKKYWp91mw4LGdxdzs61wOrG+tha/PnNGqcvptNlw7w034Gd/+INmfqdDru8ZuXIF\n", + "dgAbamvx7MaN2D40hKfefRehuTmUhasx+c074P3LIaxpCqO80IF3Ll7Eu5OTMW1VOJ04cd99uO/g\n", + "Qc0SJ5WPPqqQTB7q+qj5UhplKUGvHmq6SKVciFamXabyM5P3JYhhDKMYxehCV0ZcWMMAfrS/Dd4c\n", + "Ky+TrPRPbD3OOnTjdeRruKlUL/SL2AGCBzuRG+PwI/v1RQWuNuR6ORWjEHU8BQQyhLY2oKdHcm49\n", + "cMB4rUqB5EhmQmPUpMZMvcpE+wZ6e9F76hQKIJHOPRs34rO/+hUiV2ILpNx+3XXwuN3K8Woeewzj\n", + "kQhsAG71evHuxIRufVItOGSCy74l3QUFKL1Qg4WaEMLzc8o2PCkuANB07bV49lOfkuZK46HD7b/4\n", + "BXpPn0a5w4GJy5fj6oHqPawIDgzg5ZO/hX1hAh77AubLb0Wps9BSo6BUa8DmMsyYKuVSPVQ/4m+3\n", + "tZZlpy88uQqgO0NHNlNkPVskPFmt1dyrx7nUkG590Vhk4yGKQP5BEE9BPAXyENmsPRUOG3duFTCH\n", + "ZKrPtT/9qVLvs8PnwzMbNxpum5GqIrsdJycnY8gATxBqiopwcnISM2+9he4vfxk37NqlEDxXQQH+\n", + "7Npr4SoowMFTpxC5cgVlTide5+pvAsDJyUls2LsX1xUXK66zDOu83hjHW0AijXq1PrXQ6PXivclJ\n", + "nJdDMvn6oYnUMjYHD69bh4eGhgyr4fx5KcUELqE86bHMIt1IArWj51eHji26ky4/b82Tk+j7+td1\n", + "t82lCAWt221rb8GNIYggnsJTCCGEBjTgBbyQlZv1ZMTSj+yQ8GRk+Bd9v8Dj/sdzqB7nUgMrtmNN\n", + "Tc5sPURJB6KOZ/YhiKfI8RQQSAgzzq0C2tDLZ0uWl8rX+zT7Nc1yD9XutUCsEVPPH/+I/tFRvHzu\n", + "HB4aGoKdc5Cdu3IFvadOocTpRGNNDQBgcn4eDw0NxRxr4/79mJybw6sywWyorka1ywUAGBofh1Nu\n", + "0wbA43Jpkk69L2Lmgvu7O+9Esd2OMrtdIZ0Omw0Pr1uXdA58ZWWm8mkVoyNM4gqkcVS5XDg9NZVW\n", + "TiJ/HTgrpDbM1oBlUNe4zAVzLf56/vsPfzjhtunkOFsNrVxMftn2LDlmD2MYIUiGOSuxMmvkKpn7\n", + "rtUmSXqZhMnMpEpRmmI9TgFjsDanNZrH2ogdFrsCCwjkM9Imnjab7T9tNttZm832uhUdEhBIBvGE\n", + "LreQzChFjxQkM6G5zesFIOUkVrhcMccwas6iRW75ZbdUV0t/r1+PHU1NWCu/Z/C4XNjR1KSYGGmR\n", + "5NHpaVycn8c8EWwAqt1uNMh997rduLm6Gu6CArx21134+LJlAKIlVz7k8WB5cTE6fL64osoN1dV4\n", + "MxCAx+2Gr6wMH6mpwSRHxi8TxZFgK9DV0oI7fXXwuRYwDanMzNTlyzh89ix6RkbwRZNOiOxcMXOj\n", + "npERlP7lIAKB1MPX1TUu2Tm9wXEeW2d/uChOpfz1fIccAp0LSGaZonW7zS/LFqnnb9R3YmfGjhN/\n", + "XMjHjRJLfs5+DGtNklItM5Pq755UusSPNrQhLExzsoYudCGAQE6HRYt7KYHFgBWK56MAPm1BOwIC\n", + "AnmIZDemespmMtXnydtvR6C+Hoe2bIlRLmsefxyPvvOO8n71rl26BFSL3Kprha4qLYW7oAAffuop\n", + "/F5lXfyJa66R8jiLilDjdsMjK5k8nLKrbQEkZbb39GmUOp0I1NejwGbD78bHEblyBf/8yitKO2u9\n", + "XrT7fBhsb8epL3wB5yMRxSm3wunUdJdl88jqelrlYKwm8R63G09vbMPKZR9SjsOXW0mmPqvbY9cH\n", + "y3ttqK7Goy1NSiRBKg6v6hqXXS0tWO8+iS9f/jbCp/cuilNpLqmYPNKtp5kJx2yteqOJbtQz6Teq\n", + "VnyDkEg3m7NGAJcsOA4bw5vye+urY2pDKl3Sjx70IGhpRVUjiD1zi0WCkzkGZwIeeIRCLZB3GBkZ\n", + "wZYtW1BdXY1rr70WX/3qV7GwoGWVmDrSJp5ENAjI8TECAlmAqD2VW0h2Y5pqeQ3+Rp4dowCS0sfy\n", + "MO0AxuWSIFpKnBYZUNcKXVlaisODgxiZmsJFzgV2bVUVfvbJTwKQ8jjPRSLoPX06jly/cuedqCsp\n", + "wTK55Em504lCux1j09MxJU2Ia6f/zBm47Pa42peVLhc2rViBUCSC+w4ejCFibB7/63Ofs7RcCV/v\n", + "c83u3cox+fPWyKnPO5M8JecfRGzZ/d/htseuX1laGtNvvQcXiQipOizR43bjGzVHUIwZVV3DxUEu\n", + "fUelGyqayuc3GVHUqjea6EY9XfKcCEzd3S73+SkAF+V1dgDjFh2XjWEcQB3iFdRkc5bqNbW4IZ+x\n", + "Zy4bJFiL3KpD8wUk5NL3lEBu4G/+5m/g9Xpx5swZvPbaa+jv78ePfvQjS48hcjwFBATSQrIbUyuU\n", + "IHaMSlUbBVxOJq/E6ZEWreWM9LHw17VVVejw+XBoy5Y4YqhFrn1lZfjT5z+P95VLJjwT8/PoPXUK\n", + "/aOjCkEusdsxdfmyoo6q22Hje/fee3FmelohYjdxRNBszqZ6rHpzwufSjs3OKuSPHW/70BBmLl9G\n", + "bWEhnt24Melx2Vz58B7umn0Yf+3YhdrCQmXcjLiy/rwZCmnOidkQT7UKKiAh3XqaqXx+k+ZNquqN\n", + "apEutmwFgKPysrXInErI+syeolcCqJH/rgDwcJrt8w8AtAqhZIpcL27IZ+xjj2yQYC1yqw7NF+Ah\n", + "6pcKRPHmm2/innvugcvlwjXXXINPf/rTePPNN5PvaALqtKKM4IEHHsD1118PAPB4PFi7dq0SW86e\n", + "uIj34r2Z9wy50p9cfX/HD36AkUuXsLyhAV0tLXjtpZcycjzmdmpm/+DAAF4eHITbbsfz/+2/weN2\n", + "J9ze43Jh2cmTOH/xIrBmDRq9Xhz/7W+l2pcf/CB+8IlPKNsPT0xIDqPvvIOOt99WHEZfHhzE0QsX\n", + "gDVrEBwcxIMOBxbeeQc1N98Me0EB6J13UHD+PB79u7+L6U9XSwuCg4O4+Prr8H/ve3Hz2VVQgLdC\n", + "IeCdd/C+8nKsamxE76lTKHv3XUxdvoypG29E76lTWB8Oo9lux7P33x833u7WVvT19WHmrbeAqioA\n", + "wOjRo+g4d07pv5n5HQ6H0S9bxwZdLoxNT8e8Z8dbdeYMQnJu6w1nzmCb/F3N2nv58GEclc2V7t+x\n", + "A9+87TZ0FRRgOBzGzFtv4Z9uvVXJaezr68ODDgcmC0/hrtkfYGJ0BYqvvw9v33M7goOD2HblCl57\n", + "6aW4/tXdeisObN4cc30WOxzAO+/gxooK7Lj//qTjdbs9cDgexEsvvZYznz+t998DcMnvRzGAB/v6\n", + "UJqF43dnuP0uvx/DAGb6+vBPAIrl9Tf29WGbtEPs9i1dCA4Gse3KNrz20msY9vsl/8++PnQA6JPb\n", + "62ff9/L+JX19+IKB+VP35w4D4ymWj38DgA/6/dgJoKmvD6MALvr9eEg+Xqrz1QWgo68Pfw/Ak+D4\n", + "NwLYobHe7/encf67TffXmvcPApiG3/8sAA8e7HsQ05jGs/5n4YEnI8efwQzgl8jttr5t6EMfWlq6\n", + "MDgYxJUr23L++yGb76VlL8PvPyr/3QHgmznTv6X6PhGCA0EMh4dR7ChGV0uX4XrMVu2/ceNGdHV1\n", + "obm5GRcuXEBPTw++853vaG7b19eH1157DWE5RenEiROGjmFJORWbzXY9gOeIKM7KT5RTERBYPGSq\n", + "UL0VMNs3fvu6khK8vnUr7vjlL3H47Nm4NvTqJGot59tl0OsPv+2q0lKsLC1FscOBifl5pR9Omw2f\n", + "uOYaVLrdODczg8NjYwCkMNp37703qXIUjkRw0+7dGJ2djet/OrUi7zt4UHNOwpEIHujrgw3Ao35/\n", + "XJusHa97Cmsq9qPc5cTE/Jdw+Oy47lwZqZOYrJalVsmR4MAAnjt5EpGFBdxWU4MnczCnMhn8yE55\n", + "jiCsqz/Jt1UD4KSqXT+iY6oF8BsADwEoUm27XadPiUq6MNgB/DmAGQCH5WXq+WP9PIaocml0jrWK\n", + "aWSzrIy1xTz0YOVVkZsIy7mkouyMUSxG8aSrF8nKqfj3+tE/KpfhqQ+gu9XcL0S6+1+4cAGtra14\n", + "/fXXsbCwgAceeAD/+Z//GbedKKcicFXByFMjAQks7NE75cXp/7sJbW1SbdJcgFnTEn7717duhcft\n", + "1nWbVYf/srDO+StX0OHzxRAdpqwlcq5lOD45CUAKy11WVKSEgh6fmFC2mSdC/+gonHY7jly4oCzf\n", + "u3Ejtg8NJTXS8bjdePueezTDl82En6rnQC8k2uN249mNG/GMThgt229NxX4cHutFz0gPjk/8Xneu\n", + "3r97N67pegb3ntqM0Tl7XHt6/dOaB3WI53A4jNGZGYTm5tB76tSilU5JhkTfUVaX59CDlaGbfFv/\n", + "S6PdYm7bUUiksxsS6eS3fQJh5f1qXFEC+7qgXdKllmt3AUAvgOPyey+A04gNEFSHy5bDeIislruv\n", + "Vr9SgRFTnWTFPKz53ctktmxuQJj6GId0TVl1lQtYAXUaQjb3JyJs3LgRgUAA09PTGB8fx4ULF/AP\n", + "//APpvuRCGkTT5vN9r8AvAjgRpvN9iebzfbF9LslICBgBRTSsH8zDve60dMDBDN0vxEMShFxK74x\n", + "gA0/T+5S2tXSojjKqo109LZP5FDLq2I3dXejd2QEgQMHEI5EFAOd3tOnQUAMmelqaUHz8uVoW7Ei\n", + "zrlWnRfpKykBAFycn8fL584BkBTO64qL4SqIfp2W2O0IRSKwc08E733hhRgjnwcS3Ejq5dWZIese\n", + "eSw3dXejaudOBA4cUNRDM06yrC/lLkbMG/Gbji/pkkZWXmY8EsGGvXtNjzERijl33YbqastcVrOJ\n", + "bN3mpUtwg5CUzDYATm45s98qhUTwwogliV5I1KYKUi4j34c57pZjHAW4Sd5fi3RtB/A+1bFdkAio\n", + "TT72YWgTYHaUCfnYibLX+HGqt7GqsuPiOsvyyNxjD2scaxOdDYHMwNr6pQLpoaulC4H6AA5sPmA6\n", + "TDbd/cfHx/G73/0OX/nKV+B0OlFVVYUHHngA+/fvN92PRLAk1DbhAUSorYDAoqOtDejpARobU6+d\n", + "mAx+P9DfD+Dv9gJrjIXQZiIUWB06G6ivR+/IiFLOo8PnwzMbNxrqi3rZpbk5qQ6lw4FLly/HtbG8\n", + "uBiRhQWcl8mcDZLpUbHdjrfuvhsNTz+dtB+AfkitVvip2bnwuFzoPn5ccfA1Ou/hSBjBwSB2NO1I\n", + "+INW89hjGI9ElDH7ysqStm0UycKC9TAwEEQ4PAyHoxgtLV15bT5kNFgy1dBNrXDVlQDOQCKdHkjl\n", + "RdjVz0JZ2fFOIxoKC0gOrsxMx4tXcR63xhyvBhINqgHwKwARALchNqQWkEinG8Ckqr+VAKoBnIMU\n", + "jgsALM7ADomo8v1Uw4/Mhz63oQ096EEjGhe5rmPmAnr98KNfnskAAuhOaSb9yE4guoDA4iBZqO1i\n", + "gohQV1eHr33ta/j617+OyclJfPGLX0RJSQmeeOKJmG1FqK2AgEBCdHUBgUB6pDOZSnb8EwPA3+2F\n", + "faW2S6kWMlEjkFfF1lZVYUdTE26TzXEaqqvxKGeskKwv6mVMYf3YNdco+5VxIbpvBgL4aE2Nso4g\n", + "fcm+1NEBX1mZoX4A+iG1TMXseP75mPOgd2605mI4HFZIZ6XLZXjePW4Pulu7kz5FZeVlrCadUh8S\n", + "hwXrYSmVUzAaLJmqjqEOV22E5CzLlE47oqSzElHdjB3vJNfWhxDr4Po7vA/FGIND9qAuhUQYewDs\n", + "hxSmG0JsSG0DgHa5DTXp9AA4IrdxERLhnOL6toEbA+snr6ndD4lgA8Ycc1PV46xwlrWmFmXm1C1r\n", + "HGuzFYguICCghs1mw89//nM899xz8Hq9WL16NdxuN77//e9behxBPAXyDiLH0zw8HqC7Oz2lM1l+\n", + "oa8xDKwZxUJRBHUlJYbq/tUUFcWFt6aLrpYWdPh8aOdKojzZ2opAfT1euOMOzT7d8YMfYGJ+HrVF\n", + "RXjq9tt1Q3m3f9WNse+0Ajta0bbchw6fD5tXrIBXrgnK9mHlQwDgCoDvHDkCAEn7wZCIkGudB71z\n", + "ozUXfM3QI3fdZbk5DysvYzXpTAfZLqeQye+oTN+aHx8YAPbuRdn+/VgRicAN4B3umA3y35WQSJ+6\n", + "FuUE9/4GROtjtgGoQAXKsQyXIT0QvyRv9yFIxI+hDMAnIKmg1QB2Ikp8AWAZAB8kFbQBwLS8vBjA\n", + "y5C0sncBPItoWDNfp5PPV2UE+3qNsfghke4Ncv/fQmoZklbkHQ4Ovqz78MSaMNf0YE3ZFpFvmE2I\n", + "eykBNdatW4fBwUGEQiGcO3cOu3btQg33MN0KZKWcioCAQP4jmTpZXhhdb7TY/MnJSZyLRNB7+jSC\n", + "g4OWhNp63O64EFaWT8iDD2f90+Qk3pBdaR8aGlK2Ve83PCyHE8ONVbcUYWVjGMcuXIgxu+lubcXb\n", + "99wT40zL5otXLFkY7fahIQyHwzg+MQFfWRnKnU78uKkJDw0NaYbUJlJmSx0OhCIRhCMR6Vgac8FK\n", + "w+iF65pxzs0XsHIKiVx28wVdsDZYUh266wuHMTI6ikkAhYODOCxf/3UAPgBJiWTOtT5VO92IEs9K\n", + "AI8C6EA0ePJWSOqkGhcADEIiquchKZuD8ra98n6MpJZCIpf3c+0yPA/gZkQDNIMAxgDcB+B38t88\n", + "GJllobor5DGVy+Ngob4j8v8sjzUR6TcSCp2Kt6zdLn0OtR6esBxSqe1gimGuZnoZv46R6/TAFFkB\n", + "AYGlCpHjKSAgYAjJ8gvN5h8CyUtqWA1Gqo5PTmIiEsGEnKdZW1SE0ZmZpP3gc2Xd/8deHB6P5k/y\n", + "+wYHBvBWKITjExP4jRxmy6DOGx2bnjZczgXQnudwJILVu3ZhXA6zTSdfVi/vNhiUiHfnNT18AAAg\n", + "AElEQVRxsRS6nYk8YYHsw4/YrLpL3GfSs3kzet1updDCTZDCYQGJUD4D7ZxQJ4A/QCJxrFhDKaLk\n", + "kUcxJCXxXwE8BmBOXs7yM9cCKEFsvqcbUiQBr4Kytj4CiRz75HZZn1i+NSAppXcPBLEsPIw5RzEe\n", + "a+nCpOqBRK081gpIYbyNkNTSh5CY9PuRPEvRyDZqJCpRlJkc0kS9TLRucRBEEMMYRjGK0YUu4Wor\n", + "kJPI5RxPMxA5ngICArow42Cqub/sVnvfZ93Y0ajvQpqKS6le2ZNU+5oMLCR1ZGpKIZ2VLhd+09GR\n", + "sLSHUo7lr/aj/d4IDhyIKrxrq6riSrQMh8M4fPYsRmdm8NDQUExbasWSvTdSzgXQnmeP242PyOEw\n", + "6ebL6inbTO3NpDPyUkC++XKqQ3f5z+STbjcCkJROnnQCURKnzgmtBHAXJEWyDcCPIRFFLdIJSGZC\n", + "HwOwG1HSCURNgV5HfGhWBPGks0DuYz8khfIw16dSxN7stAKoCw9jzWg/PjzSg8/JoavMnKgBkqIb\n", + "AHAU0eBPH5JnSBoJhU4lXNrt9qC1tRtDQ9vjcj2tCXM108vcy8XMHedgAQGBRBDEUyDvIPISzMFM\n", + "7UfN/TNIONQkKt2+JgMjVRUyybMDcNvtuOMHP8CluTnd/Vi/ekdH4PrfBuHxRG/QD23ZgmdUNTr/\n", + "INf1rHA68fC6dTFtsf0+UFmJjuefxzwRfKWluMnjicsxNQOj5WkSkfvgwIBmrisgKZ2ApPbuyI17\n", + "zZzEMID+vr6crJSoJsUsJ7MWkprnAbDd7cZYayvuk889MwziSacTwDhiS600QHK//QCkkFeWC7kG\n", + "ElHUw4Lc9kSC9YMAEj5Ch6SAHtFYboNEehmRXQvgZwA+Luf9vudtxM+bdsDBbbMSUZJphGzyMJKl\n", + "mEomI/vd0zLKykztykS9zJ1cTJbf+ibeBKBtbpQLObC5CHEvJbAYEMRTQGCJI13n2GwSjuOTkm+l\n", + "FmEzAz1yxUjf0a1b4XW7pZvemRm8EQolJLtac5iINEcWpFvYi/PzcYon2+/k5KREZk+dwtT8PIbO\n", + "ndNUSOPGJivQbW1AmLuH8rjdWFlaisNjYwnHwvdz9a5dMXOkp9QGg8DEBFBbCzz1lAiz5aG+1qys\n", + "n2n1LbLaEXcYkjI4CimEVGsbIKpvARLN8CBaQ9MFYBWAU4iWUuHDW62IW7iCqMKqhwpVP/n+AlF3\n", + "3EOQjIZ+2NKFN+oD+H83H8B5t0dx6m2U2/IjtXNgxDc2HW/Z7BllJepl7tR+ZErnOMZRhzpN1Tdf\n", + "1VBBmAWWIgTxFMg7+BOUoRCIhzqc1fT+cimWD/z3AXQMZC4MFgB8JSUAtAmbGTz32yi5+uLB2HIk\n", + "3a2t8JWVKaGpFU4nsGZNQmJuZA55ctpQXa38rdcmv/1arzfp9gyJFGi+zaKnmzQJKm9ENB6JxJDU\n", + "RGG2hw8Do6PAQw9BgINape8CEPD7U9aCjJZLSQVqUqx+H0S0vEgVgAH5/2lI5kLV8rbjsvMt9u/H\n", + "85EILkAy7lFXtk01k6k0hX0uIlpKhUcIQCEkYjwA4IOQwnp73R78sLVbye30QCKmByApvJk6B6mC\n", + "/e61tHShvj6AzZsP5L1RFo9USRZfxuV1vK6p+lpT6iX9vppFpgmzuJcSWAwIcyEBgTxHtkxf9Exn\n", + "rIQRsyEjrqtV/7wfoetGgPe8aD+5Gc926ZshPbxuna6DrBnwpj8Akhotmd2egTc4Utdl5dvs2OiW\n", + "HXilBwfd3bHbhCIR9J46FTPXauMiNtdvHnVg/HgRSq+fxMdudeDJjUvD7dYKWG2Qxcx4mKGPlR9n\n", + "Fl7LzHHY+yJIZIs3CHIglkjy5jzYu1d6CgEA9fWAxd8FyxDvQJsMMf0zCVYahrn0ZvIcLDYGBoII\n", + "h4fhcBSjpaUrZ8irH37FmTeAgGGH3DDCCCKIHdihG2psZJts9NUsMmMaJbCYEOZCgngK5CH6+vrE\n", + "kzoOfj80CYbVyIYDrRFnXCME+Pb2CHqvGcTaN5twaJ87KRnPp2sqHJYeNuzYkfghQyKCCsTPtRah\n", + "5+caBCXRrsPniyvTcrVC65pN53pSk0OjYKGzxyGZ9MwDuA3AckikMlHpDj/iS5PwKIAU7qpg/35g\n", + "ZATweoHNmwELvwtskGp4HtZZH9eXNFEHycCInxc1ITdT9sQKaBUyseo7au9eP0ZHpbNdXx9Aa+vi\n", + "O9IC2SFZVjnfZosQahFmK9178+l3b6lAEE8RaisgkPfIVg5muiG7RmDEGddIzuqTj7kRCLcaIp35\n", + "Bo9HeriQbFwsRFqLdALGjJ3YXAOIcXex+mcz027GmUQqbs4J20Nq2XMsRHcEkloYglQDczeiYaMP\n", + "aOzHh9d+GJIDrRpxRK+lRVI6LSadgHRt6ZFOzb4YAH+jUw5JUQWksU4AWA2JYDKwc7BYIbeZDLfO\n", + "Xo6oOWTGmTcWRkJXjYTRZqOvgLZplJnwW5EjKpCLEIqngECew6gClktIJzw4lXqhAsmhpWiHIxHc\n", + "1N2N0ZkZlDmdmJyfx9qqKhzassXSuc9GGPdSBVPH3oTkNFuOqENsFaTcR+bWympv8vAjqnZ2ILY0\n", + "ihFUAbhgttMyqgGcT3HfVOCEVOrlT5CU4SkAk/K6Onk5j8UKuc3kcRPVAzUKI6pbLtbVNKJUZiuM\n", + "NlWYUVtzfSxXI3Jd8Xz77bfx5S9/Ga+++ipqamrw8MMPo6OjI247EWorICCQV8hUeLCR/M+rCWbm\n", + "Q4/QW50Lq4VMhnFrhS0m3SdPrqMgJGXuovy+DsCvAfwtJOVwHFH10APgPcSPX01yApCUUjuihFUP\n", + "tZAUSLP5mJmGOj+VwQ7JuIjNlwtSWHIxgLcQzfFk14wTQAmAnchunmeq4dbZghFCs5ikR4/0Gsn1\n", + "zPW8SjP5qrk+lqsRuUw8L1++jA984AN48MEH8bWvfQ19fX3YsmULjhw5gtWrV8dsK4inwFWFxcxL\n", + "yJcb0lSQ7tjM7J8s/zBVpKKcBYPAyy/3YflyvyXmTGbmIdG26ZyP4MAAnjt5EudmZhTykMtKohbp\n", + "teqz5kdU0QsAhm5/01Vgs/Ud5Ud0bJUA3kUsUWGkUm2ew4PPZ/wVogpkCRKXErHJLyvzLdOBHUAZ\n", + "JDJ5AMBnEBs+q0YFgF8AuBcSWefnxg/9a4aRmuP4B/hwO8rhQBekEi1mH3CYQS7l4xkhNItJetIh\n", + "vVYbES0G2DXqhBMlKMFO7NQcSy5dU1cLcpl4vvHGG/j4xz+OyclJZdnGjRuxbt06fOtb34rZVuR4\n", + "CghkCVp5cEsF/Nhu/f6gZikOo/snm5tk+YepIpWapcPDwNGj2uVJUsFzJ08q83DL008nzF1MNGda\n", + "64zmQg6HwxjlSGely5VSDddsQStP0qrPWip1NdOtfZstsLExYqn+KHVBIk7vAvhXaNem5PMZRyGZ\n", + "Es0jef1KQmZIZ8I7FhXs3N8FkPo8BuD/AnB9kvYvAvh3AJsAfAxSyPB1ADYA+I28TTmAh1X7sxy7\n", + "ERThMBwxNVHVeZmsJusKud1M1GZdDBjJccxkHuTAQBB79/qxf38bIpH4GU2nfIpWXmW+gV2jveiF\n", + "Cy7dsXwP3xM5oDmGdP0OrPZLuHLlCt5444202+HhSL6JgEBuIZNP6JLlHubLDalR8ON1/lV0bO4n\n", + "m5RQ2GDQWCismblhBjnpgil7kYUF3Ob14ifNzYbCQXk1zVnRAsBvmTlTZCEaoDg1P68oZ8HBwTjl\n", + "LNGcaa1jZEyvPfW+AOBxuXDkrrvyTp3XmxuzSmgXzIctdrW0pJVHbPV3lDpcmKlrTki1J3dCe2yM\n", + "VAJRYgQAtwJYKbdXA4l0vmlpj1PH5weCWBYexpyjGP+zpQszCfIQ+VBgngTbECXlgERK/wySey1T\n", + "dB2QSOXHIBFuQMptPc3tNyGvfxvR+WWkphxOTCD6QOM+eT3/gIOf8xH5fxYebRaZ+N1LJQwdiJKz\n", + "dLdJFeHwsOLMOzgYjHPm7UJXTqmWeqG/mcqDNUq8L/kvKcpwEEGRA5oDMPobn4n916xZg2XLluHh\n", + "hx/G3/7t3+LQoUMYGBjAJz/5SVN9SAaheAoIcBgelnIP9dQvI86uwSBMqYVmt7cS/HhLdkXHVu6U\n", + "xmaUjAWDwMT3W1B7qh5Pbcic660aTNkLzc2h9/RpPDQ0ZMhhlFfTSv9y0FL19baaGgBAQ3U1Gqqr\n", + "AeiT8a6WFqwqK4Pbbsd9Bw/GPKFUX2vBIHDsdxIZa6hMTO67WlrQ7vOhw+fDe/feC19ZWfoDyzL0\n", + "PmtmldBUXGKtdqpNB0FIxJJ3pmWEphdSaKne2Jji1gbgD/Iy5urK2ntc/nscUrhtJcypjkk7zzpg\n", + "8LttWXgYa0b78eGRHnxhsNPwodgcVAM4B0m1vQ4SOW+CZKr0UW77ywAeAsBrAuxxTTm3bBSxzrJM\n", + "yTuGDyGAqPkPU5d5MyBGfp1cu2oFdTFh1j03V1xSkznz5ppqqedEa8ah1gyMqs3pKMMCmUG64kY6\n", + "+zudTjz77LPYt28frr32Wnz/+9/H3Xffjbq6OtP9SAgiyuhLOoSAgHU4dOhQxtretIkIIGpsJAqF\n", + "UmujuVlqAyAKBKzf3gqsWUNUUUHkdMaOt7NT6k9rK1FHh/E5WIwxEBFt2reP8MgjhEceobVPPkmh\n", + "2VlT+zU+/TSFZmctvaZCs7MUOHCAQrOzMX/roXnPHmUMgQMH9LdrJkLRLKHzALXfa2yci4nO/n5q\n", + "3rOHNu3bZ/i8GIH63OUirLyemin2R7WDiDbJfzcSEfuIdsrbbuKW8fs6ub9dlPzHu8DANklfzdHv\n", + "BQSM7fOVfZvokUdA//vTjVQ0GzJ8LJc8xnKd9W3yvNSq5q6Vm5/b5PVHNbZLBSEiChDROq4fqX49\n", + "Gr2mtK4DPWhdR4nQTM0E+V8g5ZGkhk7qpFqqpUqqpE2zzbTvQAfNzsb3upM6qZmaaRNtolDKZ858\n", + "3xIdcxNtIhCokRpj1ustzxaeO/QcBSiwKMe+WpGMExm5Z8jk/mp8/OMfpx07dsQt1xuHvDwxL0y2\n", + "QbovQTwFzIARn02b9ElPJolnKCQRp1RJJ5F58mp2eyNzlAwVFdEbwsLCaDupEkgrCHsqCM3OUscv\n", + "f0ntv/xl0i9angidmJiI+XLe/G//lhGSpHX8uieeoPXPPKMcyyiRWqw5ThXJCHWqxNTqH9ZMwMrv\n", + "KEYOQEQfJokgMELDXwbN3HYBjX3NEMsGIjpBREXcstVEVJVgH82XfM2ikQghY/sUzYao80DAFOks\n", + "0VhWqnrvlOfjBDd3nUS0jOIJK1uvnmMz6O/vpD17mmnfvk30GXks6ZBYo9dUMxknuUbG2N/ZSXua\n", + "m2nfpk30mVBr1oiSmszxpDcR8V0McpzsmCEKaRI8veXZQibvpQS0keuc6NixYzQzM0NTU1P08MMP\n", + "U319Pc3NzcVtlw7xFK62AjmFTJXZyCbM1tU0u70Vc1RTA4yPS7mdb70F+GRLx1TdZtOtJZpOXU+j\n", + "SORUmo06kvwxGAL19djR1GQonzDf6rUmK5EiancaQxjAFyGZ+eyEflitVu3HMICbIIWLNgA4Bcl8\n", + "pxGSMc+QTltVANZBqs/JtukA8AqiuYqGO5+huiCrAcwCmIY0N6yWaDGkkik3IZpfyWMVovmtE4iW\n", + "m2EwUzszUY7k3r1+JQ+xrj6Ana3dWSmPYnUN0L1+P0blH5y6QAd2djtjciczlaeodqa9hEvoQQ8A\n", + "oAENeAEv5IybrihbImAUuexqCwDbt2/HT37yE8zPz+PP/uzP8MMf/hD19fVx26XjaivMhQRyCsVy\n", + "UoxVRi9WwwhBSmaco9WGGfJoxRy98gqwYQPw619HSScg9UeL3AwEgwgPD8NRXIyWri645ZV682GW\n", + "SLJcU7ZvJh44mDXyydTxK5xOXJyfV47F8gmTwSpDJjNIp6RJMoOepWbUlQqMmLt4IOUnJgMzUSqC\n", + "RBKZcdD75PXPQCohwnggb4YzD+Ao19YFSOSlVn7vALBvIIgr4WHAUQy0dAEq058KROtjxnQ+Q9fs\n", + "JIA1iCeX0/LrEwC8kHJXSwFcgjRWN7dPLbffhwHUQyL3Rkuj6Bk2dSE2D7GlaQfazA8xJfOfVMy0\n", + "EsEh/+B4GxvRsuNRtKlaZXmKUn9TM6jRIq9a+YcP4AHYYMOjeDSG3PH7/xg/xkN4KGvGQgMDQXwp\n", + "PIENjlp8qeUpeFSfi1SJeaL9MkX2BQS++93v4rvf/W5mD5JMEk33hRyXlQVyC0ZCXQ3nuqQZkqre\n", + "v7MzNkQ11VxGo+Gsev1PNkdWhOKqsae5mR4B6BGADnCd5seyalX0uOvXm5unbISRbnvhBfLu3Emt\n", + "v/hFXJjmc88/n/HwTRYiqg7zzWUYzT9NBfkQMpsqMhEWaRR8m16N9jtJCqG1ycvXUzTPkX9VkhSW\n", + "WsOW7WkmPALpdSCQ2RsHAy87Nwb1y8uNq4Niw2v5vMYT8vp2Sh62rEanPEcgKTR5vWqf2dkQHTgQ\n", + "0MxD5NtoJv18TL4fzYsUFjkbCtGBQIBmdb6YrchT1ApVNROGyu9fS7VZDV3ds6eZHnkE9MgjoP9x\n", + "YFVcrmeyMFy9/NBE+1kVTixCbbOPpcKJ9MYBA6G2QvEUyClYqeqkq6Kp9x8bAy7Kj/QrK1NXG5Mp\n", + "lkwtPHYMCIXi+59sjsyM26iixT/1buI6zY/F7Y4et7Y28RjV0FNarcTJyUmMRyLoPXUqzma81OVC\n", + "d4YLafPKZr6ElWZSlTSq9OYjvnf0KL45MZH0c5WsxqhRxYvfjjmoNsrb96rafwLADLfvYQBc0IOC\n", + "myGpmI2Q1E/ICh68jYCGk2i2saCxzAWgFZLyykJonQBehhRiex+AH0Nys2WKoJaabKT26zCk8iuA\n", + "pHTOqfZxuz1xZT602mCKabTMSvRsFmMPACcaAfx9wpYyB7fHg9YEPyJWlC7RUjfNlGMpVs4YMIpR\n", + "3IpbsRIrs6II8sr2k03uOPVXzzmWqZYv4SXMyVfPA3gAz+LZmDFpOc7mixutUGYFNJGMmab7whJh\n", + "9wL5h3RVNPX+7H1lJdGJE6n3S0ux5FVKXi1Mpf9mxm1U0dJ76s2PhT/uiRPpmzRZjXxwQ801LGVV\n", + "MpMw+rlKZu7STMYUUX67Dq5NdfudFP8jXUX6TrBs33YiqpwNSUqnCdMfvZfX5PZOInJTcqfdFfJc\n", + "uIkI/Z2SSrtvU0yfjehDRkx31I6wqZgR8W1sI6Z+vkQhqiAiUIjuT8vgKF9gVN3UUgc7qZPW03py\n", + "kUtRXtfTeksUQSPglW0t9VdvbGqzJBCogzqU9Wy/bbQtbsyLbUpkFEaU2cVwIV5MLBVOpDcOCFdb\n", + "gaWIRKGk/Lp0yY+aIOqFuFoR2sqHrNbWSv83NBC1t5tv04wzr5VkzApH4EziaiNRmQi5FjAGs58r\n", + "PYdfo+Uu1NutIaIKkgge/4ysmWJ/oGsonnR6KEoO11M0DJQd40OUfqmVExRbYiTRS8uxFiSF2fLr\n", + "Kik23JUPDXbIocGJ5tFMGRKi9F1v1W00c30P0C6d3prtZXaRaRKhRWT4ZXVURyHSJoCZ6iPf3gk6\n", + "oUsI1cdlfSyjMgKBGqhBcz9+fF7y5hVBMxKGfbWR06XCiQTxFFhSSHbDfMsth3TzB9X5k9m4+bai\n", + "huViqYWMjG37q1nNedKbv6VGapZirsti1Va1ApmqAZotJMoZ1qy3qaOQbiOJALZSYpqhJkGSXia9\n", + "3BRV09RKo149z+UUS+K88rIquS/JSKNe7iXkNowS1zqK5p8yglxBUk1Ovn9OksgsI8d2IknpfARU\n", + "8XQjHZ0NJSWJzVx7i/FxiT48mKcQ3U/q3krfUc20uL1MjEyVMmHEw0veOCJjRmXMRB+NtqfejvUx\n", + "EVnlx1dKpaYJWjLCls7vnhEyaESZtYqc5guWCicSxFNgSSHZDfNHP3pIN5RUHWaq15aVxKmuTmq/\n", + "oiL1ENxU1EIrSaHePJldnq/IBvHMNplKJ9Q8o301INpk0tQoG0h0PTVTPHXQU0i1ttWCekrVBJN/\n", + "z0hhMRHVkvYPdztFiZC6HiYS7Gflq5QkMrmN/oZq6AVqpm3UQRHlkmH9YyZIJI9dMUOaDdHyAwEK\n", + "ceY+iS49I+pyJvXGZAqqdE0Z1cAlZFspStVoKFk/tVRNBrNhp6yPXvLSelqf9twYHXOqc8PG10rJ\n", + "a6iqCRr/3k1uqqRKaqVWZX/+e8rstVJLtUrbfIiwWVhFTvMFS4UTCeIpsGTQ2SnlULJQU60b5lBI\n", + "clBdvz654yu7+fZ6Y7dXh7amQz7NOrjyY02H/FpJCvVIitnlVoLNT12d9rnOZWidW6vJVDJyyH8W\n", + "zBLJjBK/ZkrKpqwKAefHrafqZxta1EEvDNwozeCJYDtJRMxNRI90Er3STHRwE1FFSFILB0lSEk+Q\n", + "KjRVfn2AYnMW1Y635RR1ia3Q2N/Kl5eIKuklAlUoN9OM/LUSkY+IlpFEPpkqzBNmtVLczLXNu/yy\n", + "9tqTzLPW/gzZCYI1F+CbbaUo1dxDvX4mUjrT7WO6eaCsb63USh3Uodsvre06qZNqqTaOCKr30cvr\n", + "1COJalLN5o1XS/XGq3UOEpHRSqpUtm+ndtPzZwb5ktNqBJDKDi+Jl974SBBPgXwCT5raE3yXGSVX\n", + "7OZbTQ4ZcbJCtUuVhKWrGlpJCvUUV7PL04GarPHzk+ghQS6G/WqdW6vNjcyQQ7NEku/rthdesEb9\n", + "ZHfmTH5LwKasysflx13zjQM5odKboQ5Gt2VlPUCkaA8hInqjObpiVyCeMG2i+B/t5Rp94NcvI+lU\n", + "GlU97RQlgmZuHopj3u9SSAc3pDhll82VVhkZfrz8pdess60WEj0I4NtZRbmRiWm1UpQpBVWvn4mU\n", + "TjN91iJ56c5NqiG26mVa+ydrW289I2jLaJmyfjktV9RSEGgtrY0ZbyJyn6gfrM0SKtEkzwJXJwTx\n", + "FMg7GCFNhw4dMk2u1NuHQlETn3RVu1RJGOtTaSlRa6t1JkK5bvKjBzVZY/NTXp74IYEVYb9Wh9pq\n", + "XZ9Wmht19vdT5aOPEh55hNY++WTSNs2SXr6vlqmfzRT9ZaijrNyR8+Nu/cxsxlV6hmznDC8naVqd\n", + "JOVfKoRHZkpHGiXFk6mVRBJ5XE8SkXRSlOydoHj1jpFHkJRf2UzxP/YOjWXLKaqOnlCts9EsNdM2\n", + "aqMILdPYl4XMNtA8tdP9tI1m455b8GosPzY9gqhF5M0Er4ZIIpW86ZJWO+qanlYglWvKaqUoEwoq\n", + "c6WtpVo6EWOFZX2NUL7f6c5Nsr5pETrmUMuW8USQJ/VaYbXJ1vNQq5HbaBtVUzUto2Uxc3zo0KGE\n", + "5D7RGEMUihnHKoqvYZoqlpKZ0NUGQTwF8g4x4YE6StahQ4dMkyut7a3Mq0wFoZAUAsyTJr79bdsy\n", + "q+Rl+lhac5Vo/rQeDgQCUt5soocEVoT9Wk0UMkn+OzuJKr4VJYMdv/xl8v6kQXotU2rNpafpwkzY\n", + "MD/ubD6QySTx1Arp1AqZDRApTGtjKJ4INXPbekgKzT2qsS7AvS8hiey1EsWUKymYDSnmP4ykrqX4\n", + "0xxLTs8RaB+10/0UIkmpdXLr2yiWJPJ9Ys8tQnK/2XIWJJOuqpzoxpfvRy23H9+O3qXe2d9JzXua\n", + "adO+TTG5p0aQCwZomVBQK+Qwai0yawVxZn0G6TvHpoJkfdMidPyy5bSc2qldU11cSSuphmpilER+\n", + "fTu1Jzw2I6aM1Oo9MDh06FBScmnE+MjqEjZLyUzoaoMgngJ5DSuULKthdZ/UxkR8+2pSajX4Yzkc\n", + "1h9La64SzV8iYpDquqWI5mYifEUig5XfzXxNUsuUWjNsIAHy3XgoHXRSbF6lYk4kv2fr1IRHTYQ6\n", + "KRqey5ckYURKnSd5gmKdaJ1EMeVKquRyJSBJqewg7dMcDc+9rGzfQRFlPVMwtUirHpnTCjNOF4lu\n", + "fNXhyTz5ZNC71Gu5Oes4kCM/aiaQSQW1kipTbncNraEKqiA3uWkdrYvLjWyn9pg8zGwoalqETs/Y\n", + "qJM6FZWygRpiSFwN1VAd1ZGHPIbIs5aCbIRcbqNtVERFZCc7VVN1nPqsFbLMXw9WPpRYSmZCVxsE\n", + "8RTIa2TDwMYsrO6TXu5pY6MUfssfy+pcRj7Ul/WhslK77TVrJHLs9Rp37tWaq1w8p/mGTZuIUDRL\n", + "ldsP0Imz+VdqJF1YnSubVZhwoNEsu0LRH9dKbjkLAV1HEhFSf0TVRIjPz1TnSbL9a7hlAYoNtwWR\n", + "Uq6k8ulGWj4bilmnNu5hY1Arsw00HzMNfD/V++qRueX0JoGICmiKmmnO8G2qun3+fSttTXCjHp/f\n", + "apRCVspzhqcbqd2k4rkUwQhGJVXS5+hzKZNBXjXlCZtWW2qVdRWtSmj0YwTJzIDYNowQrqN1MQ82\n", + "1GqmVgkVfr3WMdl7PszWTFixOiS5juoSrs+EOp2JtgSyC0E8BfIaekqWkZAjK0iaVhtWq2t64aXq\n", + "v4ni1dB0CShzB/Z4KEZ15cHmgFdE6+o0m9Ns34rwZiuRKHx7sZAwdFSDfSz2HC42rMyVzRQObT6k\n", + "TTCbyTBb0dpUq4SI2aY7KT5nU4tIsWN5SSKMcbU5Z0PkPBCgdbMh8nDLeUKs7lOd/HeZfNxEl7DR\n", + "8Syj/QSKxGxrhN+r2+ffd1Ak4Y0vTz55FTnZMVtnQ4QDAVo7a/6WOhdCba0AT5j4GpbphFeyXMMC\n", + "KogjbImMeyqpMkZdNHJsLZKpV1qE35Y/Dtte7T7LHnSoS6gwoszWa4Uoq4lhIzXSalpNFVRBXvIq\n", + "Cibfp+cOPaf0lQ9JLqIi3XxbPoTX7DwZhcjxzF8I4imwqMiE22hnJ9EttxxK2GZnp0Si1CGd6v4k\n", + "6x/LKwSIOkzGcBkdu1ESwZeZKSmJH1uq4Mms1hj59QBRcXHqtUpzAXqhvmkV0k6z5mXC0NFmMi+r\n", + "5BhSmZ9s1zxNB1p9PXTLIe3zZiLPVbPsCulHKxttupmiXfNQVE1UEyl2LK380ZGHiMoAACAASURB\n", + "VOUk5VOq19nl9tnx1X0yYrpjwvyYiIgq6Sg3ngUKkf7HJlbVjG3fbAqy+lzoHTPRPmawqA/HEhAB\n", + "syRBTTD1XFXNtHuCTlAd1dFROhpD2LQUa15lPUEnEuaA8n1gxkBaiqLazIft5yKXsryQChUSyfrJ\n", + "k1E3uWPIHq+Qsu218j0d5IgZRwM1KLmjPDllCmYM8T4UDW8OUYjaqI2W0/I40snWd1AHraSVhuqf\n", + "pvMgQeR45i8E8RRYVGQiR9NIm+rcRUaU1PtqtcUTRp68Jirtkmo/9aBZA5Jrb9kySilcVasupjqc\n", + "Vw2myN58M9Hy5eZIZy6WOclEqG+6OYcJQ0ctMuRZTKQyP2b3yU4NRW1o9tWMraoOkm1qNBRVDS3V\n", + "lDncaoXpMpWSKZ5a7rFriaiaoj/8Xnk/deivVq4pPwaiWALnovhanGq00pxCOvWOw8Aru2rzonRI\n", + "YaJj5iPU5yURETBLEtT5e1omPKm0yyNRqCaf09hMUn3NNmrTrMXJ96GGapS/Wf9ZG1VURUwJ3Ebb\n", + "NEN/WY4mPx6e9IKiYb8ucpGNbMpyJzljyGAxFcfsx8ZaSqVUTuVKrquTnAQCFVOxEsrMO9GCQD7y\n", + "pfXggEj74YNenqaRBwp8qLEo1ZJfEMRTwDDSJQla+6dyk5+sH0ba1KvRqS5fokW6tAje2rXax0rk\n", + "Csv306xjrBZp5dv73OeIamrMl2BRq5eMUCdSXNMJ68zEg4d0kYkw1XRzDhOGjqZ7N5wDSGV+zO7T\n", + "TNEfHe1LLQE1TZO1avY1C+etmZKNWRtaXUvUlpbi2UHxZJU3JFJvz9pMpBJqGRsZGZ/WeEJEVEpn\n", + "qZyOkZdephMUJqJYIyKTzxKTIh8/qnqXfjPFzn0isxezRjBqUqi3v5F2UwnJTJQLqQbfB94p1kc+\n", + "Wk/rY9oopuK4ZexfBVVoqrAhCilht2pnWPU/plh2UqcSUsz+HZX9qBnR5P8xJZUnjDypraZq5W+9\n", + "kijJSrlokVE98q+neKvzY3mCLFTP/IEgngKGkS5J0NrfTBgpI2Zqsx01QiGi5uZDScNXtcpvhEJE\n", + "bne0/ba2+NItzEm2sVFS99T95/vKiClAVF0d22+WP7l+fTRE1ujcataA5OaSn+tVq4yTWtYuU3L1\n", + "yLtVSmU+GQmlE8aWDzmHhpEB6TCV+TG7T3K1qZl0aUyCVUawbXaWag4coNbZWeXY/PVk1ZSq27FS\n", + "YePb2qY6DlM8+Vc7xU8bI16tqm35nE+94yZqJ9XxVdARpd06OkxEiV1zGbKlnps9jjWhtrFHbSbt\n", + "S199bRlREFNVpfT2N2uIo2cmxKBFOJMRW74PvFKqVjS1SCMjdw5y0FE6SttoG3nJG6fgrabV5CAH\n", + "VVN1TK6o+l8zNccpxOyfi1xxKij710ZtRBRLolkb7zv0vhgiqVcShe9XG7XFnRczDx8SKd78MYWz\n", + "bX5CEE8Bw0iXJKSzP0+kEtVrZND7AeYJkxZpJIolgcuWRUknH1ZbV6d/bC3VUC/8Vb0tv05PLd22\n", + "TSKrtbXaYa18rmdDQzxRT0Qa+bqYeg8E9PJj9eY5lfzVXAzBXSrGHWmjmdIiYYuF5GpTApqWJoNr\n", + "pvgp468nrfWpQN1OojEnIzVsfR1JqmUrSWQypHEcXvF8pJPot81Ec5uItoa0yeoJig1p1TJCYghR\n", + "fG4pwzaSnHWThdrqwUsvE4iomN5QFE8jqmQzZecjYPY41nxHxR7VgojwjCKZoqnl/qqnjqkJG58L\n", + "aaYP6vzKNmqjEIWojuoIBCqjMmqjthjn2lW0Ks4MiLVrJ7uynFcs+fxQfj92HPZPrX6q/7Gc0/W0\n", + "ngqpkNbROmqlVmqndnru0HMxhFhLzeykTnKQI649fk7MPHwwqngLZ9v8hCCeAoaRbghiOvvzpJWR\n", + "IrPhqUTGVFsWXquX66lXTkTdV74EidNJtG5dPFlk27rdRHa7pIqy9bxxEa+WJqvdyfe1vT2e8GvN\n", + "gVZupxFizeZCTRQzoY4L5AgskNE6+zupeU8zbdq3iUI5UzIiwa10mnfZyaYs1SlNR+FspsSkhl+v\n", + "3k59HPa+gYhe53aMBKLTpj5eiIgc3LI6jfEw6E1/sjEkwwkKUx0dVkinUWjNs7UqqNTaJpkYZzcn\n", + "NHZ0uUIw9ZAsz1Pt/qquj8mDN99hobJGQnTVfVDnZTrIQV7y0m10WwyBZCGsaiXRTnZqpVbNsFpG\n", + "QhuoQXH8VZNBfj8b2RQFlyew7F8Jlegei82nlprJclfVbrwVVJFQpUwFIQrRKlpF62k91VGd4fMi\n", + "kJsQxFPAFLKlRKmJUGur5Kj6/7P39tFtnfed55cEQIgvIgG+GaYp03QiK87YLhmxcRLGBVpT9ZB2\n", + "Q9QTbhRvDtOzO+DO+GS3ezqxN+2cnHZ3JzOd05w5090507VmWuXNTCNbtWVFVhwqAWlVSezaieg0\n", + "Tc02Cd3IDi1LASVLFqm33/7x4Ln3dx889w24AEHpfnFwSAD3Pm/3Eryf+3vjffqBE9VNtrvbHrCm\n", + "pwUoSoshj8eMREQ7dq61vMRJX5/YJxol2rlTP1a5bXu7+bksRcItrxxg5batraIPdR5yrHKOY2MC\n", + "QCWoc1dhO8ur05rK9pNJfVKmwUFz7F5iX8uN0w21QarkSrR4dZ7+XFrUKnwMNDV37d9ZcFsyr0u6\n", + "g4g6SCTmWSZ/Fk5VXmG4XbOd2o/ltabhHJmxk8PFt3NkgmezzXwqnYNfGMxRjlL0DCVpkcYc6n3q\n", + "1pmPfZD+xndcoVWitQJ10BQdq/Hldb2jplVO7pa6six2rqJEVgsaB6cttMUWdnKUM8Cui7polEap\n", + "j/oMCyCPlYxTvATu+qiPClSgVmot+ayXeg04VD/roi4jk67MbCuTC6ngK/tZpMWShETy92ZqJgnJ\n", + "cj0lXPJ9pFsuXx8JprzWqpxrO7VrM+C6ycmKHBTQhtoYheAZypdqZYnSgZBal9IJTqTLkQQcDnES\n", + "ZnXzUN1IJyfFe6OjJoyqlkL+Pi83wvuQ2wwNEW3fLl5HoybEShjkpUhUy6vbU42b5fGl2ax1TVVX\n", + "YTXZkpNVV2e55seCz7urSw+XbueRrg+nRE1uCuKGSehqWyrfJU3SRASi8U+NEx4DjewfKbF4Vlom\n", + "pT6tqaUq53zqIPMfZz85g5cbdLnhxTQJwE2TSBTk2bKnaTjNxj2peW+i+F6l5UqsylGaxXB6+Xcl\n", + "Lm7zYp+FHHX7OI94wqMOepFQdJss7+K4PBt4kN9R1aiTWI02ndwtdfGdTmVUuHTwJsFMxmCqtTJ5\n", + "Eh75kG6ujdRIR+loSYxmL/XSNE1r3WFvpBstLqx8DLo+4xSnJmqidmov2UeCqlyTIRqiPuoz4JBb\n", + "Y2Xm4DSlCXlrO5PFv2AO/Ha1Vvm4kpT0lH3WLrGT7E/OLcxmu3kVgmcoX1KtadWyfKpJbrjbqkyW\n", + "o7OCSt1/f74EODmkcndYbjXk0NTQIPrnYOlmKZQxoXwO0aj5+cSEFWwleO3eTdTUZLWmTk+XwmUk\n", + "Yl0Xaf3UwTefu87lVo13la693JLpVRwUda7GKlw6jcWLi29PjzO4Ou1b7g2TEDxL5VbSpAQii9fT\n", + "hQ8VaOrQlPaCvtLSM+kD6U1hTS3nfOomAUQNB9KUPjROy2sFW/BKk/lPtpv8u4Dy/acc3ucgqiYd\n", + "ktJhlO69YG1taRqnQ8U+/sGjFXicUNyn9cCvOZ5HulI1PcQvbv6ygqQn/lciRzn6lfyvBAZ1Xlwl\n", + "/VqUy3W/LBdYdfGdWcqWuIryWEVuIdVlgOXj5/ORYMXhaIRGLEAnrZLSkikfavkS+eD9N1ADdVAH\n", + "baEtFkiVbekAVffopE5KUYp2027LPvL3IRoy1qOf+i3geQfdYXymAr9aa5UDorpuXs8RuYbcqrtI\n", + "i2E2202uEDxDeZIEA+m26ZZZtlKpSW54WRPed0+PsN7dcIMAJlk+RAXCoSErpHIrI39K+JKApz77\n", + "+pwthdzKJ8eeSJifxWJWILzrLrJk2AWIBgZKrbT8GY8TLS7qkwBxF2UJpXfcYXUB1kFzLCZeT06W\n", + "tuX35oLsx67+p7Qg83hXL2DIYdWttqjTvqHrbnByK2lSApEerqcrLT0zfsjemrrZtUxETQyse+am\n", + "tBf93LW1lfQA6SY7m5v6fpq1H7PpS3fYvaCVDmy8w8540VX1m1TwGMNZoAJN0icpS+s05nIepal0\n", + "rmas6yWapE/W1BrjDRQFHHiJk/OSMTRNzueWCozlZiH1A6y8z920m3qox6ih6VbeQ3Ufla9VeBqm\n", + "Yct8JHgu0iIN0iDdTXcbkKmrwzlKo0ZioBEasWSb3UpbCSRcX50y2Eq42027tS68bg872OU1O3ny\n", + "I7kOHdRB3dRNy7RsWWvuwtxCLcYa8DWV6+YkHmcrEzvZxdCGVs/NqRA8Q3mSCga1uJC3y0Db3+8M\n", + "h3x8w8MmTKkgpSsdooIuf27daoISB/GJiVKrKAcoO5fZjg4TlDlk8kRCdk/pdjw9LQBOQjd3r5XP\n", + "aNRaz1ONd9WNWXfM/Wp6WvTR12e9MaC7aeHlfOLg7DdRVTVqc4Yimv72v6KeL/wBjR38iPbivByI\n", + "rLT0TGGtQFNzemvqtSAJ1m37RwhrBeIX/RLKeC3KXtIDpJq11mtCH/m+tG52s77k064vvwCZZm3K\n", + "OaYWcoQDacKhcZp0PMaV2U/dzqPqW2z9yRsomhfwbiBX6sJaesRM9+K/ozH6qOF+qoMR2ZbqFuvF\n", + "msnnprNU2s2Rw5WsoamDYNmmCmO91EtZytIyLVOWsrSNtlEXddEYjRlWOL59IzVa3FwlfPI6nFto\n", + "i+Xz7bS95Jg0UAMdpaOONTtBoAQlSkq/RClqicm0e/BtZNKhDuqwwCa3uLZRm8XS2kiNlmRFco7d\n", + "1G1Zg17qpQmaoCxlPQGi7hxRz+0CFaiHelzPYT83Wpz2DxMZBasQPEN5kgoGlV7I+3Wt5ODDwYW7\n", + "mwIi4c7YGNFXv5ovGZ/anlPpkELB6iKrjkNtSyYS4k/pNlsoEDU22kMkB92hIevvW7aY20nQ5i6s\n", + "3OVUQqZTP+rYec1SmUjJ7pjbaccOAdHd3VYXXdXqLJ929VPrHQyr4mpbq4KAVZKbW+umqF/q9RgE\n", + "fKzKPZ8kEI0VoZODT5pKAXCZ3DPCqnDnRXz/ePHnMJklV/hy8XIrU5r97frVwV2SnXPZDXSl3kjI\n", + "1Gmapqkj3+FoAaosTi5N6hET7sXfJh7PqloNdTDsBKc62SX90W3PIcWp/iQvEaJmgVVBTq4Rt0Dq\n", + "4jl1D2nhbKZmCyzJ9VHrfcpHH/UZc0lSsiRuUyYDUh8TNKGN8XR6SIuwtt186fbqGsmkQj3Uo3VP\n", + "5sfJDuacIM8LjOrPWO83Wtz2D116g1MInqE8iYNBEIla/LpW6oCoq0s802lhdeSWwnQ6b2yfywnY\n", + "kVCmZlq1m48EwK1bS8fB4xjHxkSpFCfLJM9qC5ggOjJC9O53C3huahIutHKtp6etUN3dLdyFJeTy\n", + "DLfqUwXdri4zjlXOq61NzHvbNvH52Jg1aY9TLU8utb6pepz4c3jYe7v1pqqAZ5rKu+rfQPG/l7ED\n", + "G+fWWmkSIkNp8nYMvG7nUZWeTzrwkaA2RNaEQDrJbTuoFO68iEOhDm7TZC6Xrg6nl/Q5qnV1nIjS\n", + "RYvv8DXoSl2J0pQ2IMEN4JZpuYw4Of0RUwHALulMyVjJhC83gLCOwhk4OKTw39X9dGNQXWr5Y4AG\n", + "tO9voS22FsYRGimJ53QCOG5BnKAJCxyrbrcS8Pg+7dRO0zTtyeIpH13UZbS1lbZaYlJBKAHPOMUt\n", + "a5egBO2m3bYArbrX2sGcX3dqNZOvDlzlMZdj8+viXa5reChnheB5naoSeKzUBZPI2ZrG3Vh1yYMk\n", + "mHHL5+CgADcJXdLaqI4XEJDqZT6yn927hWWRu6uqMaLSisctjq2t5u+qW/CuXWLMo6PWz+Jxsw8e\n", + "98nHp1p8nZ6plFhDvk82ax27zuXW6diq544uIy+RtSxNY6NYQ79Ji+pVgUFPADUx7RTYGBXxv5fJ\n", + "j2+cW2ulSYgMeT0GVTxWfuRkePVjhZPb6qDRi9z6cgPTAhENkrCG2rn7SqXJvGCYvMZdqcuV34tk\n", + "/xfV+iOuWqOcsszq+raDU/tRuLevQkgHdVAjNRourHZjkBZS3cMteY+M2ZSPPurTutHaPSZowoCv\n", + "O+nOEjjWWVjjFLdAZoYyWiufXZIk1TUYhBLA1Y1TxEJP0gANUC/1auuDykeEIkZMqLruXiyYO2iH\n", + "Ja6UyD0+d4qmLHC6SIu+zjE/51oo/wrB8zpVJfDoN75TB7mFggleKvx6HZtdCQ91X9XyFo1a3ULt\n", + "5qMrxdLTY45XxprGYsKimUoJi2U2K+JKeQIcaTWV26sJhXTjdsvIq85Hvnay0Kpt8EQ9/Kkrp6Jb\n", + "D+mq3N9fCpU6V9tqluCpVY1ZogChp4r+euWO0WuN1f3dRJecaKHKqjQJkSGHY2CB9zfX6sK3Mk3m\n", + "P896NpJ7ObXTVHpBoJtTnTB/XcvvRfJGXlTbZUStVkZeDkZbaIt2DPI9p0y2TnCluuumKKUtkWIH\n", + "gKq1NUYxo80RGjFKnzg9uHuu20Pn+ttIjTRKozRBE7SNtlGCEhSnuJHwCCQAWMZMqvGlTo9+6rdd\n", + "d50FU4pbUmUbOkhV3+MAnaUshaofheB5naqS5EB+4/HsQFJ9X016Yzc2nUVUhbFbbskbbqNjY9ZY\n", + "RvlsahJWOZ5hlccrqu6zlpIun12g9v/zAOFThwjNayVgytu99VZzv8ZGAae5nD45UiRC9OCDYtzS\n", + "gtvWJqy0HNp57Ke0Yk5Oip/Ly6VQrx4zNVEPh+CODr1lUgVJt5I68pg4lXwJUkFY4p3EXSMDg54q\n", + "ynGMDmYzt3WUSaOOJ8gXAQVtga1F/GhgNxg08utqKw9ZNxE9liN6KU10kR+/HST8ZruJyqjXbtuf\n", + "032FSsNeJVC2kzNYVvH+zDUlr+dUPSRN8Rvnqe7j1aJaoILFKigtnnaSVs8EJShWfIBEmREeCykB\n", + "UwU3O/AqcWH18YhQRBu32U3dBlRL2L2b7naF50ZqpJ2009aKa4nVzcOSEMnro4EajLE1U7MFKFUr\n", + "ppObrXQJb6EWow27mwb8PQ7Fk0b1YH/nUajqKATP61S1TOYiLYPt7VagUeGXX/D299uPTXdhXChY\n", + "YzwTibzFCiohTn3ybLRqoh4VVmXG2JERotH95gUpZuZKwJRbILn7bSoloFOXBddprKmUdT343HTW\n", + "Sb5GsZjVTVin6Wmxfr299u6w8ngNDYmSLzy+VNZWVa3adsmbpIK0UlY70zK/qNsMSXMcx5gmW2h0\n", + "W0d5bh2S+3s0Q1UT4qqlat5g8AueaTIP2Xf4ix4SBNfO3uvXNlF2f3Yo4GUbJ1Xq7hvKKq/nlO5C\n", + "v9YX417jPMsBVBVCOPQN0mDJPHn2U1kGhGd3lRlxJQQ5xYKqjxjFaJEWPVsivTyaqIkiFHF0//UT\n", + "58kfUYoSj4m9LX9bSVkVdXu1LzU77gRZ45tUK6bOgimPSZrS1Ed9JZZQN8kbCLwuqe7c8xLfHIJq\n", + "sArBM1SJOAzwZDPlXsyrsZh2yWu8goPcTrW4qVZPCXdDQ86gJy2R6ns33mju19oqxj0wIPqMf1pc\n", + "kOIP9hsWTwmYXV1m7c7hYaLOTvG7jIHUuaByi6f8XE0cxK1Pcq5NTcIyK9fAa6kU9XjzBEHcasuP\n", + "Pb9ZwefQ1GQdqx9rY5BWys2QGddOtXQTJiJH30XtOjLT1keLrtmZIaJ1tww2vMtNYCVWFeQNhkou\n", + "XnhdziEqWjpBRG1k/idtKv5sIcPiWYlF0ot767M5onya6K/HiVY34d/d9SrdhX6tM3h6jfO0SwIk\n", + "S5o4/U3JvzkJjLrstmofur4SlLB8Zgd1W2mr4b56F91l1KEkElmHvbjx3k63G5ZT7iLcRm10E92k\n", + "rdnpFGPpNOZO6ix5f5EWiciE92ma1pZsAYFaqVW7bk41W3OUM/aXllCdBdPufPT6PerkSu43vrnW\n", + "fxvXukLwvMYUdMZZDjBBJBLS1XCU4+Yur06ySy40OmpNMCQ/y2ZNEFSf0WhpLCWHQPW9hobi781r\n", + "hNycxc1WPrnltbdXuNbyGEhdtlf5HB01gXx5WV96ZMcOMwsuz5Y7NWU9dk6lUqRLcTxutcjyOXML\n", + "sHrs5RySSatLMre+ejkXg7JS1hzcAlY5AF7RnP36LqbJ+MZezxLNDfqP79wMVuJqyrx4eYy66W99\n", + "wWCazH+YWSLz+I2RSYeLJCydy/r9/H59ezlFLlXSQagNU7nlKao9Bp34uHbTbouVz62WIweGOMVp\n", + "mZapn/oNWEtT2gJJEgxjFKOdtNN3vOdO2kljNEZt1Ebt1G6bEMfp0U/9xto8SA9aPnMaj5OFM0KR\n", + "kqyzcYqXWDKTlDSATgKeXRxnX/Eh2weZGWydYjb5OqiWULvjbgekTtZrJzD1G98cZrcNViF4XmMK\n", + "woKkSzwjy4b4gQopbkFRy5DoMs+qQGpnfbUDWgGfeQMsl5f1CXTk0y7Jj/rkrrR2z85OPeRGIgJI\n", + "l5fF2FU3XgNoYU1gpFqfcjnrfrIdCW7crXlx0Yz7VI8Rt3Cq41ePPYdCp/jaZNK+jqfduejXSml3\n", + "3lU7vpOoSuVUiioHwGsxZ0Oq+StNIXD4lLx4aaOXxNLl856Xztb66EKH1UrKIy2pL1Y7608AtVOD\n", + "LpWbW8hR+kCaxg+NVy2zbrnW8Uq+o+o1g6ddDc8kJS11Op0sWxxOucVTwouEJLs4TJ1lz+sjTnEL\n", + "3PJEPeqjkRrpFrrFiH90cnH1+miiJtt27GC1mZrNmNK8eE+1qk7SpGUtpTtyP/Vb4lHVGwJeIY5b\n", + "XPnfAt/fzXodlHWyXv82NqtC8LzGFIQFSU08wy1fEorsLJde2tZZ0uzGzS+u1f14vUtptRwelsCU\n", + "N7aVgCQBk1tDYzEzGQ+3/KnPeNw6ltZWe0up01PWueT7NjSYbXO4jcfFdmNjRNu3C1jkgAoQ3XST\n", + "sEr39YljwqGXx4WqwKZLtgSIJEb82KtQaBdfq8tQXI2YSzvYqnZ8J1F1wbMcN+FazNmQCjjXcppR\n", + "N1Ipk2TkxcsYXSQQ0W35vOfdp0nkDBrz16Utl1YKY2kSh7+jQHSsmsGZsqMKbnAE0IS1vQNpwmMg\n", + "PAaamqvOXZdyL56r+R1ViYKKkZPQIWFqjMYoS9mSNmV/YzRm1NFU64xKoORutNK9VloH26iNeqlX\n", + "a62MUMSSTMjJ4ihrcd5MN9PddHdJ6RW7h86t1u8jRjHP/ekerfnWklIuHdRhWctGatTGmyYpabFE\n", + "pihFHdRBvdTrOWZT/Vtwqs3Kz5GNtE7KucqbIyGwWhWC5zWmasS5cSul1apoXvT6sYCqF8xObrY6\n", + "66uM7ezvFz85xE1OijZ5TOfNN5tWuslJqyvs6GhpzCJA1NxcCqLqvioE8ufWraVxlg0NZkZbbnHs\n", + "7RXuqlu2mLGSvAao3bOx0d6FmMOZ2t/UlNU9VkKo6o7r5dhJ2QFpENZML/1v5vjOcrWhc/brqltN\n", + "FSlq4fdzdGB/mg4dGqe1MixREsYW0+RMKm6fu6icpauwS9/tuYFpze47BNCR1ya8wvj4oXHCY6CR\n", + "/SNVs3jWw8VzkAoqmYuEDrckQ7y/ARowwG+apmmURqmXektAkceaLtOyxY13kiZLMtruol1G7GiE\n", + "InSUjlIzNTtCHG/TS6mVXbSrpOSJ7M8NNu0+S1DCyFIr20lS0tbau4t2WWC9gzos2WVV4JTQnqSk\n", + "BS5VeFePm90xd/pb8JLddiPkNtfrXSF4hnKVvMBV3VV55lmvbn86yFT3zeXE5zJpjcy0qovt5E8O\n", + "I3KsQ0PW7WWtTZ45trvbhMTOTgGt6bR1XFu3ijHoINzumc2WWhYnJ52TC3mBWgmd/LVdPOrOnVYw\n", + "lzGYHOCcss7anQvqtkFY33TngQqi1yNghnJRmohAdOD30vTYY6DHHgPNlWGJKjZDh9xIxQPJ6CCm\n", + "2ol+gmwvTc5gWrP7DkpH5bi5eh1rmrzBfWGtQFNzU1WDTqL6uHgmKt9SqR4nGVfZTu2eLF1uoCph\n", + "JE7xklhK/rnqjilBUX1Id1g+bxnbKOMWVbfdSZo0YkaXaZlylNOWPOHxjzImsp3ataDHYbid2mmU\n", + "Rn0nE2qmZlqkRUsdS/mIUpSWaZluoBuM9/qoT5tAiEPsIi1SlrJGsiR+XkhraDM10wRNWBJF8WzB\n", + "PMZ0iIZKXGjtjjn/W9gs2WX5uSLPn1CmQvAM5VncXXVkxBpzqVoj7axWOriQYDQ0pLc+qjAr4xgl\n", + "nG3daq1zSUR08GC+JK6Uw58OIKUFlYMjt3BKd9JUyjpGaaWMxcz95fqoVtOJCefkQl6fst22Nqul\n", + "1OnJYzCle+wNN5juvF7Knehg0E9iKCc5ldepegxjUU61Ju+/P1+7BEZBB6ZdyypS1KF/O06PPQba\n", + "v3+kLIunhLFMgWjdiVQ8kEyaSiFGfc+PW2TQoOfWXr16UlfTzbVe5+xHQbvaluvyqx4nr2VQpCSo\n", + "cusaV4EKNEiDFqthP/VbXGylCy6HUB4Tyl1sG6mRuqhLmwhI1oAsUMFw2+2kThqlUQsAuSUPmqRJ\n", + "C/DJtviji7pogiboZrpZC7FOjwZqoDjFLVlpB2jAso1M5sMhM0tZ57HnRdvSZTRHOQtETtCEAd9S\n", + "TomJ+qhPC5perPzViN+shgpUoEma1LqBhwrBM5RP2ZXU6OwU4MFdOHWw4AQX2ayAGLWOZTQqXEol\n", + "HOksnmpf/B/w9LR1295eot27rRldOzsFhMnX0u1UQm4kYoW7m282614++KAA7rEx03o4Pa1P4HPz\n", + "zdbsu8mktV272Evd0642qe7Z11cKS2pSJd3xUuFPB4O8nWw2mHNLPVeCKOvjRbpakxK229rytQPh\n", + "NJWSy/WqHFHu0wuU/twBGj9QekNAUtTamwWam5sqCzpZM74uE+wscDqIHj3k7QAAIABJREFUUd+r\n", + "13g8ovrypOby4+bq995Nvc7Zj4I+p8p1+VWPk992dKCqWrs4hEQoQsu0bHlPlvUoUIHaqM2oNxml\n", + "KKUpTYu0WBL72ERNNE7jtkmLnFx9dXU6pWVStsNBbIImaJImSwC0h3psrY8gZzdaPm8islg9pbWT\n", + "iCwW06N0VDt2Dp58rmqCJ102WTWBkwRVuQ47aIcxhjvoDuM4qVZ+bjHldVT9nI+bxUp6PSkEz1Bl\n", + "S2c11JX/4HKCC25RtXtyWJTupmqGXFU6CypPVARYLZuAsIoS6SFXzaLL40mlFVdXN7S93bqfdFWW\n", + "1uLhYQGuXuAzEjH3c4sLvfNO/dpwF9xEQr+Nenx0LrUcgCfss6P7lt1NjmpCn67WpHr+1CSZz7Vg\n", + "fglKaaL075XeEKgHqZYdCaJjh8Zpcq1Aa4x+VgtWsAmN2v7lx801TaX3bsKLUH+yc3N0q5+pHiev\n", + "7pK6ups6i+IgDRpwFqUoLdKixT1WhUK1lIgENOn6CrK6uU7SpKOrswS1buo2Mrn2UE8JFMYoRgM0\n", + "YFhH5RyGadhYwz7qc6yLyduyi/lUH73UWwK6EmrHabwkvvVBerAkVvNd9C7L6wQlLC65shyNnAfv\n", + "SwJvK7VSL/XSIi1a1pMfjz7qsz3/dJZYWW7GqzaLlfR6UgieoRzllPBFjf30Gy8o2+AZUe3KfKiA\n", + "q3uqQCLHLuM3pWtuR4cVJoaHhUVQvr7rLnP80uKpWg7V9zmQ2MVwdnaaUBmJiO102WNVS2ZLS2lb\n", + "N91kurcuLpbG4N5xh4BAmWxJJ7l9ImG6yMr4Wul+qx5PXYwlT3DELZ5uyYL8fK4r7eKkcmtc6mpN\n", + "StgeGtKXpqmKrgXzi07l0NY40finijcE9u33Vwe0ynSnWnZKXEHTVEo/RTl8VKvhbwqpoOI5CRCV\n", + "3rtxvwgNV9xOfO14rKTfi3m7Y6C6cKqAYRe3mRWVbUsghceT2sV28mytchsJk17qQKqWPd2Dx2hO\n", + "0IS2NIx8SCBspEZby6Yue+xtdFvJ9iKD9pjxuo3aXMfKH1nKGvsnKFFiUZYPtV+ZpImveYpSlpsV\n", + "MlFTC7U4xvzKY65aTP3oWkvUdS0oBM9QjvJiaao04Qvvo7dXD209Pc5JeWS9Tql8Pm/ZXiYq4hbN\n", + "yUmigQERI8nb2rLFBGHuOsz7UPeRGWbHxqwQK2HXzhoZi5mlUCQkqZlqJyas69LWZh3X4CAZWXud\n", + "YFOFMbdyKV6ti9xia9eWHCMHQbdzS3XD9nOOBWkhlet08GC+soY2mcqFd0elyZ22VBWICh9fo6lD\n", + "c/6gs9z+fEi17JS4gjpYrt+fz9NjOaKX0kQXbTinysPfFFJBJU3e1kR378b9ItRr6/Upe1fbyoHa\n", + "LlYyKBDgbqEJSpS067WMBgcsCbbLtEx91Ee7aJelvAqfx27aTXGKW9xQdVDNb4RIiynfp5VaDRhT\n", + "Y0kbqIESlKCx4oNDle7RT/1a0OSPCEVojMYsfycyoQ2PNZT9eQHQERoxMgAn82Z2WhUE+WOYhi3J\n", + "h1RrKwfRbbSNGqiBOqjDsdyIPOYyYZGbpd2pjRA660cheIZyVC1qBaoZVgcG9Flao1EBoNJNVk3c\n", + "E4uZLrf33583XEnV7Vpbze2cYFYHwm1tzlZZoNRtV93faV9dW6OjYrzcNZaXs+HuuzrAk+JuzNKV\n", + "WEq1DutA0k5eMt3yMcpasBLQ29v1SYn8nnuVWEid2pL7u8VPVQXUypRTkiSvqop7cz+Jb/12Io9l\n", + "3CpTNV2WlWv53EKORp8apdQXU7R8tjg5B8v1wXye/jZNjpxT9vADNNw5NVUL11UVMio5pO4XoZvb\n", + "x93+OypNlQB1jnI0SqOUohQt03JFF/N2+3JQSVLSk8VRF3/pBsV8X/67as2TtSpV8e04FHLLX5ay\n", + "Rrvc6sgf0vq5TMvaDLQRilCi+ODv30V3GRDHXXNl1lme0Ib/fUqwlmP+Z/TPjBjXrbSVQKA76U4D\n", + "Ho155k0An6Zp6qEeSlHKaOcOuoPaqM2SXVhdyxEaMSC9gzrobrrb8rkb4OvcrYN2mw3d8GunEDxD\n", + "Oapa5Sv4RbrqzukGg5OTArDuvlufYEdNgmP3bG52r4M5MWGN19QBMf/8rrtM6NHFecZiRNu2lcKw\n", + "7iktofK1Gv8qY0TtAC+Vsh43vladnfbWx74+/y6lbqVP5Bj5vDlI68BGdcN2Go9aq3RyMjgrvFfo\n", + "0u1TVRh1IAJdkiS/qspNp1Fyvv5V51QpQFXgsszhfXptrXQYaSICUe4TOUr/cZqSe5P+M666cE7Z\n", + "wy+OrUzO8NxU0BeCumRNKmRU1wv9WvVxrwyoaxEnJwGNw5TXWo9c8nxRrWNu+6oJdiZoQruPLhFP\n", + "kpKOCYl0YCmz5eYoZ8l2207tJdbCFmqhJCWpl3ot4M8trmlKl8xL5xrLQVW1KHJglWNoozbDKqlr\n", + "L0tZC3T3UZ+xRsM0TDfTzTRKoxYrKV+PIRpyBXw1gZO0yAYJimEsaO0UgmcoV1Vy8Wy3r5P1TS03\n", + "woFJJhLigMVrXnZ0WEHHCRL5Mx4XsZLc4ifb0sVY2j1lzVEny6bdGPizrc1aN3RkRGTilfvyhEo6\n", + "wNNBkw6ypQVX164fOYEaL7fC4VBak2UJHlnOxo87rq5/Wau0EpUDXbp9qmI1lEqTLRHokiT5VVVu\n", + "OvktIKm+rqE4vPfMzZUOoziX9B+mDeD0mnHV0DQR9RDRGAXLOgEa7pyaCjp+qprlUjazKrfGVAbU\n", + "tYiTU2FKV0rFCQ6cst6q2VgHabBkPXm5FAlDuv4KVLBYOhuowYDBQRrUxocWqGCJJ+XWVBXmeqnX\n", + "YiUdpmHbcjRqjKm6JnbZanlyI905pQNMXvJElnqR5wNfD2n1tLMkt1EbpSltZPX1k2DKzkIdBCgG\n", + "dY6HllN3heAZylWVXDzb7cutXTIhjYTUsTErnMm4Re7CKsGVgyJAdPSoaOs3fzNvAGlbG9GuXaIN\n", + "HhspP+eJfiQ8yJqXuZyZPdfrs6fHCsPlPmVdTHnxr8v4K7Pocuux3E6FSDUL7siINe6Vj1l3nNXE\n", + "QxxInECNnwMSNmUG36kp5/I4XgFQPW6VSgddbq62un2q6qruQAS6JEl1IbfrX+mK20HCFXcDPR/H\n", + "/2MR3v94P33kzbXSYRTnMn5AxHUOPzlMk9+Y9Ayd+Xy+emAdoOHOqamg46f8lEvxKruSN26f1ZO8\n", + "XmRXq0RPLePknGp+6uBAVzNSVxfSLjkR70Odp6wnyhMVEZnJiiIUMepmEjkfJ9l/kpKWtnRw2Eu9\n", + "NEET2lqk3HrL4yZlXCfXNE1b2o1SlCZowhXcLLGcebNfuT67aTf1UI+tJbSbug3wkm0N0ZAFvu3O\n", + "Y96WUwbboG+GBHWOh5ZTd4XgGcpVlVw82+2rS0ijA5TOTtMKpsueq0JLf79oK5nMW96XcMsBZedO\n", + "676yFidPzuPkshuJlJY+0Vk6t261utfq3HXtnhzK1f10WXQl+HAglxAnwYjDrNyupcVshx8rDrXq\n", + "WnM4dbKOqTG8dnDGgdgui66dBb1aLuFc5VzUyXGtTVNgMXdm47T5vAJzRJQioiQR9ZFwvR0nyn2z\n", + "6Nb62UNUaF4zQczrHKuQjLQwtkZTuTkqNK/RlRTRJws28LVWoMHHB2n0qVFfAJPP5zd7SGHg8lMu\n", + "xaucrKibxcLq9SK7nmvDepXdXNU4UyldPKEav0lkBQuv62kHqMu0TP3Ub4zDzkrHrV+qO6uUTACk\n", + "1vPk/cnYSgl63FU1RSlLXCcXX5sYxSzrxqF6N+22WOm4C246X+rCy/uXVkv5Hk9eJMcst/Gy7l6P\n", + "Tb0mDQqz6LorBM9Qrqrkot5uX/n+9LQ+IYwOLHt7S2MPuWtpczPRrbfau7K2t4u+BgZEuxzOeNZZ\n", + "Hhtp57KrezY2Wi2IgJkJ160+KX9yy6N0Q+Zw2d5uhWM5RlnjNBo1LcpuNwuWlwWsLy/rjxXvl89h\n", + "aKi03XKhUAfEdqqq62o1lSbzG28zjTsoSTBMkva/QPrfspjU3Jx/EEuT4/qWZdmSUGjXLoPd9P4y\n", + "AaZGNw9yCzlKfSlFyb1JGjs4VtfWvaDlZEWthoWVKyi3u6AusjeDG6DdXDnsyBIqRMxiuADCAVD7\n", + "oXYaW9NnSpXz5zDkJAlnOrdfLg54TdSktQS6Wb84vKnQorbDrbsyVlQnbmXdTbspRSkjHpUn+OG1\n", + "Qb1Y6Xj/smaodDWWyZB02YW9nMf1CpRetdnHXwuF4HkdqxqJT3Rt2vWjJoTRlcxQwU9CIXfL3bVL\n", + "JMRZXnbPOCthUP4uE+nwGpgc+NRapX7cbrkLL3ct5gApLbtyTCMjJlwNDQkwT6XMz3nNTSk5RhV6\n", + "m5rKi9fkUq2V2awJvepx1UGhn/PB73g2OnOsL13vlq00lX7zbyVjTcY/W3Rr/cx+KrxrrXSN3Cya\n", + "6voq25dl2SqQsM7aHTc2p/HPVRdgvMgJrvn8a2LdCzKrboXusE5WVDcLayV95xZy1HGgg3AIhLX6\n", + "cLvbrG6AOcpZ4gg5bBkxhgfM8xtz+vnp5u8E405uv1x2pVzsXGT7qd82FlRN8qOzpMo42K20tcRa\n", + "yeWUtZdDrt/yOGqmXrk2vA9etiaEsFBcIXhex+Kg4FSGo9w2JXzYWan4+3YJYXSxjWrWWt6macXM\n", + "a2GQu8LyupyFgtVS2tVlXYvpafdMtPLz4WFrQqQtW0wglv0nkyJZkEy6s7hoQje3BqsgzRMxqQDH\n", + "3X6bm/Xr41fcWukGml6T61RitayFS62dKnJj24xusQ4yMr7+x0NUGFtzBwwJhkNEtI2IukiAyaTY\n", + "r/CRolvrhzTQSaS3aHK4WSaiQTJcd9XsuY6WLe7+y5P85IrtpEhf+kXOqY2oMF6gqUP+XEQt51MA\n", + "oOYE13L+eAw09MRQ9eE4TaXHq9ymNtAdtpK++b7JuWRNLr5131EcrCqpv1lLOSUK0pU56aZuAfiP\n", + "gbAfNLSmz5Sqy4qqxobabe/FSqeurwqSdkl7dHNWt+fxjhyI3ayVunjQLuqiu+luT+Vx8vl8ydjs\n", + "rLN8vexci0OFCsHzOpZdGQ5dVlIvUJrLmZY9HrtpZ6Xi8Za7d9v3weFzZEQAmewnEhFWQGnZW14W\n", + "VsydO/M0OSmArq9PWEWzWSuQybnK+cnkRRxOJZDrLJa6pyxxYrd9U5MA3HTaWiNUTbCki6lU3VtV\n", + "gJP1TQETouWaB2HddgNNr8l1amG1rIY1//7787Wt01lSJ7Ly2pxBjSe9X3GNdQOMaSLqJgF2HApT\n", + "JECrQFZwVNdXZzFOs3bUDLiKpdLRssX34/NQ21dVIJGRVreNB5C0QIJbXzopfTjBdWGtQNlvZH0l\n", + "P6pIQWbVrUbCIY8up5X0LfdN7k/S8tpyTRIZ6cCTw8skTXqGgY10y1Utk3aJeaSWaZn61vpo19wu\n", + "mlyzd6F1sgB2U3eJFVIHZE7r4uZmaUna4wGA5fZ8bNM0bWw7TMMW2JVtcYsqh9Q+6qMsZT1bconE\n", + "OaUeDx5vyy2uEjaDLnUS6tpSCJ7XsXidRGkpdMtK6rWkBbfM2dVjtLPs2dV0lFDD+1EhkqgUOvjr\n", + "rVutcKa2199vjTXVZVyVTw56gABgOUfdGNXEQ9yCqovllJAcjQpwVt2UJdxKIFVhV0Kwn2PoJC+g\n", + "6XTcnN7zIj8wGcR8a9Gmc4dkgZEganP6FV/zSwwYxz9nZnwtNK+5A0ba3NeAQj+gp7MYq3DDXy9r\n", + "ti+ZXLHPbtZvJ5nwO6a0r5MdYDnNxU87TlL68J2YpwoJmQwFaOGvSsIhjy6n5SaOkvvycfuxngYF\n", + "fQu5HH0unaRPjYM+VNBbAe3k1y21XDnVyrSzHPppy06yj67iQ8YmSpfZDuowSoNwleOuLMfVR33U\n", + "RV2UprSREEgFYF35EA6KquWSx6vqLKrywbPe+k2Ao27P++HjaaZmGqVRRytyqFAheF7n4hfTjY2i\n", + "3Ih6Ye+3pIUfeFXjPLnLLb/o1SUh4jGN3Bqo9sVfSxfYSERYQ/m4ZfkRnuSmv9+Ev2TSatFdXrbC\n", + "I3evVcu/qJ8DJuzzsfM15GCbNXMplMxxYMBqsQUEYPNYULdj6AXq/ABjNSyOfsCvGlbVmseXKjBi\n", + "V5uzGmstxdf8ZQmMbUSF8TWaOjRHhTfXvAGGCoW62Ek3+FJBSYUbJ9jRQVYzmf+FeologIja2XsD\n", + "ZFpp7eZn16dfkCy2Y2T39WLVrtSqmCbPcFxNRt0I+bnwDsrV14/1tBy40elAOk2PAfQYQIemsu47\n", + "8PFq1iiocXHp2iw3QYuf8emgTs5X1qmULq5cXhMO2Y2LAxt3fx6mYduER9zyKQG5kRpL5qrW2eQP\n", + "NS7Wz/qq2/NzQ433tINoVZsh0VWo6igEz+tcdllbufVwdFRY33RQyuW1pIadu2gsZoUl/hmHsMlJ\n", + "0c/u3QK2GhoEaHV3i/cEHOaNUizcmru4aGZx5ePm7XOo0Vk8uSVRth2JmCDc2ioAVk1Y1Nlp/t7R\n", + "oc/iyteQWzClRVRCBp8THyOPU/Va7kRda/XGQDlQE3R7RP7ArxqxoAcP5stus6x5K1BjV5uzmpZY\n", + "vuary2R1LZVusl7E56LGTkqqGSOirEObHBQnfE6EW1nl9VeEvddHVhBLUkmcqC95sPhp3SL9WLUr\n", + "tSr6ANc0lb8U9Si7JC66i+CgXH2dLLcq2JdbkkE9pw6Nj9NjAO0fGaE1n19cOjipRqmIctq0O17l\n", + "tCX34eAnrXgt1FIClxxUB2nQm8u24mLLkxDp3J91MZU6SAYJ92PVQrqbdlOMYsY2uhqfXqX7nuLn\n", + "Bo/3lMDrBNFSXm4ShHB6baom4AngnwP4ewD/AOD/0Hxek8mGKhWPn5SWR7vkMJVc3NqBgLywjUbJ\n", + "yACrfjYyYnV/dRqbaVXMWyyAHBZ1cotD5TUmZabZZFJAX1+fgHJ1LBMT1qy1sg6nhE439fUR4RML\n", + "1PjoAUrvP0TT/2rNYh2Wc3JbJy/ycmPAz3EPuj2i6sCkH1WSXKhWcOhpbXyYr0rW3K3EiBellf3V\n", + "13aKsu36HLbTzY+XcZGGn67i6xYSACznllReczDjbVdYm1V3PtlZtasiH+B6rSdldroIroarb2n/\n", + "1j+Bci1+6jm1VijQ3NSUb+hUxcuQ2NWM5NtxUHCDh3Lmane8ymlLdxPibrqb4hSnRVos2Z7DrddY\n", + "SdmHjIF0S/LES8d0UqexdqpF0y7mla9PH/VVBG1e/u+p8yvHfVenaljY60HXO1BXHTwBRAD8I4Bb\n", + "AMQAHAdwu7JNjaYbSienOoryolYHparKseo4WRv5Ra9T4hqd+6pfCLODGt3aqMDLE+2o4KnOT+c2\n", + "a6fRUSL8nmkB6fmDOQtgy3jS5WUzhnZsrLTWqU7qsXK7MeAXZCttb8cOcc51d3uD9JqpTJ/Darrp\n", + "+gbyNOlBz8vcCmRaD9vI2Q3VTk6xmbwtOZ5+EtZHCZ7NpM8yK/fpoNL5yXjN4WIfO0iUc2kgoqNs\n", + "blNkAuUYGVl3DaVZ29z6202B+KHaWbX9qBoXNZUaV+tdG130vd7B3isA6LarBjx4OV7l/h24jZeD\n", + "arnnjRsg8xhJPhavgFeOO3Ct5eUmwUb/XVZL1ypQe1UtwPODAL7BXn8GwGeUbWoy2VD+5QSlqoK2\n", + "jnkdm3Q1veMO6ziDiEnUvc8hU8ZSTk9by5lw91jd9p7X5VPCAtL1+f3UceOacROAW1jVONaentK4\n", + "2HITRvEEUEHEEXo9Jqplt26UJj20uWijrbUWVZoQp0DeXW51MMspxqlkCR+PfG5h2+na5vskbfok\n", + "ssKpen7xNtR14GsnYbbNYXsnVSlwkl/UDC4MBp5JNcjsrG5tldNXOcBRroUxCOUWcjR6IE2pQ+O0\n", + "vEE1YN1kV4/Si6trNeDBy/Eq9+Lez3irdd5Ii+hW2lrW2vnJWstVb5a4jfy7rKauVaD2qlqA50cB\n", + "/Df2+hMA/l9lm5pMNlT1ZFdKxYt0F+V+QFC3v3QP8dqOHYjp3i8UrPGa3d2lGWUjEWuNUO72K8HQ\n", + "ixV28uNrlD00R723rFksqSqs8wRJvB87uNTBvpPF2glUq5HcRlquW1ocQL3GGU/y+Xz9mya8yM58\n", + "5WZ55Ovs1eU2zbbpodJjxT8fJGs9TQl2EhKdQHmw+FpmqG0iors1/UnJ7aSbrZd1ILKunfxdzX7r\n", + "8bzM/0q+PGB1kcUV8MCokRhn8PFgIDTIuppubZXT12axJsiL/OSBZGDrWVGtYQepAODH1XWj4KFa\n", + "1shaqBzXVa5y5647rtU6p65n1cM5tpGqBXj+ixA8rz05gRsvpVKu/ICgTvLL0ms7bjGeaj1MCUZq\n", + "iRTVBVeulQRTvr1d+Red1ERDKmzL19y9WP4us/W6lTThayLrl8oxlZOxuBItLwtLp1N913Ktj+WC\n", + "cj6fv7Z9DnmtTTvAky6lu4koVnyvtXQfucYvSsCzswr2F99rJwGK/L9HlES22UVyB2WeCKi/uJ98\n", + "LV3bORAuFrfT3dTwe4zV7dM2c1WUf3++KjcxLK6ALDHO6FOjtoDjx7IYZF1Nt7bK6WuzWBOMi/xD\n", + "CGw97//P91e9VijR5ljjal3clxPHWkvxGpt+3Wx1xzUEz1BBywt4RlGZXgewjb3eBuCEutHv/M7v\n", + "4JZbbgEAJBIJDA0NIZPJAADm5+cBIHxdR69ffBFYXBSvs9l5XLgAABmMjAD/8l/OY37euv3nPw+c\n", + "O5dBSwvw8MPzaGsTn8/MAC++OI94HHjuuQwSCbE9b296WrQ3O5vBK68AwDze9S5gzx7n8c7MwNj+\n", + "3e+2bq+2DwBtbRns2QMcP262Nzsr5vfpTwOJRAZLS8DCgvi8vz+D97wHOHJEtL+6msGpU6X9vfji\n", + "PAoF0d/amv7zxUXx+cyMWB91PoODQKGQwdCQWN/jx4F9+6zz3bcvg9VVc7wf/nAG27cDp07N48gR\n", + "4PbbM/jxj835qfu3tIjXt902j6YmYGHBPL6f/rR+fQDgwgXxemQkg+ZmYGio9Hjqjo/b65//PINM\n", + "xlzvmZkM9u1j2xfHO3/bPDANZOCtfS/r7fj64Xng+Mb8/dn9vQBAZjYDLAHzP5oHUkBmWwaYBeaP\n", + "zwOfBzLnMkBLcfz/n/K6Dci8lgFOAfNH5oEskJkv9l88vpm24ueH54EOIHOp+Pn5eeAIkLktA4wA\n", + "81fmcf+3gP9wJYMLAA5F59HaUDw+I8D89DwwX5zfADB/Yh44C2S+X2wPxf4uZ4CTwPz/Ng/8EZB5\n", + "VJlfKgNkgfn/eR74v1n7fzgPfJydD9+ZB4aAzD9lgEKx/XeAzM9t1vv4PPAwkEl4PD7q9nK9RjLA\n", + "Hof9n8sAM8X1CPB8Oj5/HA/jYSQyCczeO4vsf8ni07d8Gv/18n8FANy2chumb5mG1Pz8PF489iIW\n", + "exYBANn/ksUf7fwj2/Yfjj6Md95+B09/8mkk4omKxsvHl4gnfH+uHd/8w3gH7+DpzNNIIIEH/vQB\n", + "nDh3An3DfZi9dxbHv3u8ovUN6nVLpgUA8K7ou5B6O4Wvf/LrFa/nucFzWFhYAADMNM1g39i+qoz/\n", + "YTyMv8/8PeKI4775+/BZfBYPZB6oyno9MP8ATuAE+jJ9mMUsjs97P377YD//2cwslrCEC/MXfI3/\n", + "xfkXsYhFIAPMYAYPzz+MF/EiFjPFv5/5LP4I9n8/1X7Nx/cIHsHD8w973n8Ws8jOZ/FpfBqJjPh7\n", + "k9tsxPHbLK8/j8/jXOYcWtCCh+cfRhva6mp8G/36+PHjWF1dBQAsLy/Dk9zI1OkJIArgJxDJhZoQ\n", + "Jheqa3m1BqkWsELBTHDjx1XT7n03i5xM0OPVPVS1wpYbc8fnPT0t5ptKCQtdoSD6UZP76NxgeXkU\n", + "Ly7K09PCdVa1XHodr594TjcLp9N+QVs/ZR3V9naNy22Z1sea1+MMUI7rm6bSb+ApzWd2mWSl9bGD\n", + "rJZAnUup6gbbyNrrptJxgIjiZO/Wyi2iTez3rWwfp/mp54Ic3xBZraHlWBj9unRXySpeqWe5U3bW\n", + "IK2YGyl1jXILOer4i47AXFmDVDUscrU8jrVyafbaj1+rY5AxoPVkAa6nsRBtHtf3SnQ9zDFIodqu\n", + "tqIPjAN4FSK77e9rPq/JZEO5y2/SGa+lMry6sjpJt61dn/l83ti+u1sAYn8/0Q03CNDzC3C6eftd\n", + "K7eSME4uyuUCHS+X4we01ONb7g2JSsVrlNrN26/rbLk3HerB5chxfSXE6WIinTLJyiyucj8OdFwc\n", + "qKRbboqs9TBBlrInV9X/BmoiomkSQNpAJmguklnqhO/jND+nscr9hsi5Tqid0uS8LnZyIcWS88ll\n", + "e2MYCwvUfeAAjR86FFjJlWqUDAkyCZFXpUm5v8JiRKN7orR8Vr3zUXtVc10OPnew6qVfpGoFOF77\n", + "8XvxH2QM6DRNUzd10xiNbQjsceguNy7UTpX+36s3EK6Groc5BqmagKdrByF41o0qAQenfe0son4g\n", + "wKmkitpnPp8vyXprF4NZrvyulZ/xV9qXW79+VckNiUrkZd7ViDHVqR7A03F9JWwtU6nFTbXC8ddp\n", + "sn4jDyv75sia9Ee3j58nLz2ia2eSSpMXDZKZ/dYu5tNOfK7lmA3LTSiVJkdgLTmfXLY3jMMHzBJL\n", + "U3NzPgZUW7klBqoGgJXcXylaAIO2eFYy9iCTM6kK4jvKq+WwVglSvPbj9+I/yPFvtMWrmv1Xek5d\n", + "D4l0roc5BqkQPENZVAk4uO0rLW/cVdar7KxaXsar1iJ1c2v1YkHL5axutuXK63pvdDmOoC2ZXq2U\n", + "fo6vtGwHmV3XrxznVY30v5UqRwIo+TdykpivIlktoSBhjZTutPIz1erZSPpv+1b2+6Cmb5CwSr6b\n", + "vW4hyv1POUr/XprGPzVOhY9r1q7Ex5L0gJlm7Xq9PlOh3av8AqvL9nIYY4dEiaWR/fsDs3hWQxL6\n", + "2v68jca+PlYCaNUAsJL7K2sFSn0pZet+Wi5AljN22Vf3F7rr2q2gjvvyAAAgAElEQVR5oyHKTm5A\n", + "vJEX/xtt8apV/0ElUaqnZEyhaq8QPEP5VrnXz2pmVrUdv+U8/MLL7t2irElvrwmLuja8WND8lBfR\n", + "9VGPDGKnHTtEjGVTE9HiYjBtBmml1Fm21ay8VRWDnPudXIMtaYPnaloKRjdWV8ulGguqPmVWWB7/\n", + "KZ8xm33k+2omWv7cWfpe+vfYhf4fTJWuGR+nXQwrkb+SMZXKL7B63L6wtkZTc3PeoXODvmwKawUD\n", + "svAYqPsL3RbAq1U8opMbMQfI1FzK80Wwl7GrF9e8r/6v9FdtzpVakmsNUV7HW69ATLTxFq9a9R/U\n", + "MajnYxmq+grBM5RvlQsNMsZxaEgfI+k3RtRpe517iG573Xt2JVT4dZuf8iJe+3XSRoIqtxT393vb\n", + "x6l+aipFFI1az4UgxI+Jl9hQv7J1OUqT8W224BRPaxngJT0YBakdJCyS3STKn6TJamGcIhPEtpIV\n", + "DGMkypvE2fYgUfYEJJIB9RHRDcU202zbDjKhspUsMZ8EEvGcaSqFVYfn+P9avND/zAgVmgti7BwW\n", + "1VqadoBpB3dpqv7xUFQz1+1a+aJrxK2eqoXQa1ypDkyCctM1XHH3g7Dm7SI4t5Cj0adHKfWllGPM\n", + "qHpxXQvQzufzWmus03qpgFxriPJqPd5oq6IfXUsWPf49FdQx2EzHMlTwCsEzlG+V63apuk2q7bjF\n", + "iPqJj9Rd1Om2172n9qW7bnNyAfUyLz9rmMtZ4a/G145GzdKWFu9uxXZu1Xwty3G5dpJbVt5K4d0W\n", + "FMaJcp9YoPQfHqCx/Ydo8uNrNjGYfICkB6NKxWFTwqSEPf6tK/uVILZc/KnW0lSfSSJKlL6f+0SO\n", + "0v+m6ArbXCiFTd1ThVqQ6aIrf24RPwvNBZrKTYm2ZQxqmu2XJfsYVjdxd2M1vrWKqhl4bmAaZwmX\n", + "Y18fc3S7dZIOTPSwkqPcQorSB5I0fshbH4W1AqXmUoQ194tgCW/JvcmyQKkaCZxU5fN5LeA6wZ0K\n", + "yLVOCuUVyDfaquhH1bLobQTQ8u+poI7BZjqWoYJXCJ6hfCuoeEO1Hb/tBrG9nxjCcpMIeenXq5tx\n", + "Mul9vkFZSZeXhaXTTywrd6vu7S0Fbrc420qlW/OqGX4KROk/9pnwxa8bpk7c4icz03Lgk7DZQtY4\n", + "zRgJC+E02397cRs7F9lGTbvsaXGFzU25f+tr2qBeInpQmUNv8WcrCVDtJDPBUVDwnmb93czW5Fq5\n", + "JtroAHEqdbv1E9OpAxM9rKQpfcBfIqHcQo5GD4xS6lCKltecv+A4vEnX4dGnRm0BTXdxXQuo0wGu\n", + "E9ypgFzN5Edex7vZVS2LXuiiGupaUAieoTa1JFz191cvsUwtrtvsoIjX+ezo8Ad/G+hhZ7hV6yzF\n", + "ulqntZCvGwg+Y/7Giwlf2v79fhr7iI3FM2ilyfwWVWtnthDRUTLjMKUraqvDPk5POyAtPsc/pbjC\n", + "Slj1Yvm0eyaLY9eNc5Lc4d3rMeS1RLk1N7yuC1TluprqwEQPK+M0fgjFPoY99SETD+ExUPYbzu4X\n", + "cvxDTwxR9htZGn1q1Deg1RrqpJzgTgXka6Wm60aqWha90EU11LWgEDxDbapEN6pU100JOUG6sflZ\n", + "n3LX0g6K+PyyWX/tO4FWtY95oVBe/VA3VTJuXzcQ0lQCIE7nVGFtjXr+YI7QvFZ90JdAJYFshEyw\n", + "vItE7KV6g0JC2phmnwDA0+IKK9/XWTXVZ5fN+xI6mRvsFfb5+i4P65Rm7dkdjxyJOFW1/6BdoDVy\n", + "+47aiDqY1ZQKP8HPr0CFtUmamst6bo+7zU5+Y1I7rtxCjlJfSlHHX3RQ7xd7jbhOP4DmlNE2yHUo\n", + "9/+epQ7k2vI1Z4GsZ/lxn90IF9V6KCMW6tpSCJ6hNtQy5iY30JBw1d5uhZxKvyx5v06JatTxlbuW\n", + "dlCkwqOf9p1AqxbHvFJLsVvG4VSqijdKNG6cJeeUYlHzHUrnN5Oq3J4nCOov7jtNRD0koHPUoU1u\n", + "JSyQqItZ9W94h2cXETVr3lsujjdtvn+RbfNCn4f18uKKy9o3ni3kvIYBye07aqOsYxWDkMe7Q3x+\n", + "asbbcsfhd5+xg2OGFdMuHlJ1sfWbHEltU81oG+RxLvf/XujCuXGq97UPwTNU0ArBM9RG5p5wlRsg\n", + "SbhZXg7WHVYFHC8ZbFMp08U0qLV0S8hUrur5mEs5ZRyu+o0SLzGYaTK/xabKAG1lf1cQ5durQKV+\n", + "5tRmjgTsRYioSbOf16edRdOre61drU+QAGIex9lGtFps9++aiVYlmNrNL03Copu1WUsp2b583knW\n", + "Mi/VOL883nDYKJdHJxCyAzvL+2PmnbrcZwdtQdAp463bOMoZu3UiRJQmKnykQFOH9PGQ3V/opt4v\n", + "9lJ0T9Roc/hJby68qhxjLFl/o0/bx4zaTiUAi+lmceGsZXKdEst3FfrOUY6SlCQQaJiG63rtQ4UK\n", + "SiF4hqqH3BO26u8nw6LpJ76xUnEwc4JaFYSy2equZbUSO9Wj7DIOB+XCW7G7caXJbdT90+QMPHL7\n", + "ISoFKhWgkpo2e0hYSNupgm9r0ma1tTy3FPuy+zzio68kWeB4rYFoldeS1a2Z2zpyFUjEi06QGTda\n", + "rYzDUh7Ht1FJV5wgyQ7sLLGSf9hr/IGm99vHQaoZb9X+dONwgyxP9TUXcpT+v1gGZuUYFNYKNPj4\n", + "ILX/ebvF0tn35b6yj4VjjKWmPz+WzyAsppsly2gtrYMllu8q9M3bnKTJQNoMFareFYLnJtBmjsGs\n", + "VOXWY6zUPcQrmFUrlnHTKsCT1e4YBAXNft2NS84pL1ZRJ+uWun8ReH7aTXS/LlGWU38FMl1Wo0S0\n", + "WOy7Eoum3dMtdjPoPtX++LHSQaJXcLQ7Nl6OayUqji9/Wz64Pvy6bTtIgpAuY6sd2FliJQ9OGH+g\n", + "fPvpb09rodEOynTvu0GWE+DpyqGk/lOKCm+WQi1PHITHQJ17Ox2tkeVaHXVjSu5N+or/5Gt88LmD\n", + "nvv2q3qoTVlLy6x6rlej71pbmss5hqGrbaigFYLnJlA9x2BWW+W6hNbyy3IzWA+rpRLO3ICTNeiE\n", + "Tka7yj/pss6pNOmBSaci8By+gSgPokMgyjuV98iRcElNkojt5HU7p5S+y4VI3fZbfe7j9PRi/eSu\n", + "u3eQOyR6BUe+Pj1UuxIqxfHlD+aDazNN3s8zL83ZAJ4d2OliJdXty3HhVVWO+7EO7nQxm3x8qS8K\n", + "C27HX3TQxLMTNPq0CaKpL6U8W4LtxiLnqcaPJvcmjeRFXtvla1zN/3v1EItYS8useq5Xo+9aW5rL\n", + "OYYheIYKWl7As0FsVz01NDRQtfvYzJqYAA4fBkZGgLk5IJHY6BHVTqurwMwMsGePOe+ZGWBpCWhp\n", + "AWZn62M96nFMQclpbpkMsLAgfp+aAvadq/3JWjKGfd72051blnaRwQJEw1OYwj54bJhrAsBhACMA\n", + "5gB4WI5XOoG7CuL3q11A4+niB1PF/ZcAtAA4C+CYTSMdAKIATtt8Xom6fLTbDOCC5v1WAE0ACprP\n", + "OgH80qa9LIA8gHMAGgH8VnEsLQBm4Wl9Dclj01ZsDxBrXMZh3nCVcZ7pNPP8DJZWl/Cjwo9wav0U\n", + "RrpHMHf/HBJx5wZX11cxc3QGe+7ZY9lWttcSbcEluoQjrx+xtDmDGSxhCa888woKK+JkmLp1Comm\n", + "hLHf7L2zRpt2/fD+Dr52EL9c/yVaIi24ePUi1q6s4SquGtsMdw3j9fOv4+TaSWMsj77wKJ786ZMo\n", + "XCxgqHMIT9/3NB554RGjn4lnJ3D4xGGjjalbp7BvzDxR5Odu65V5JoOFFfGd0hPvAYFwav0U2qJt\n", + "aIm24MXffhEDWwd8t+tX/Ljw9XXSBCZwGIcxghHMYQ6Jck+yUBum8BiGqgc1NDSAiBoctwnBc2Pl\n", + "doF8valc0Kim6nFMQclpbiU3RVD7kzWQGzMzMIGuCDCB/JNeLba9B95gYAa4+gTQuApcvhOI3gDg\n", + "CARQvBfAAQBnitumAKwo+0cBXGavGwA4fbW2A0gC6AbwsofxyT6uuLQLCDD8VQAv2HweA3CpuN1V\n", + "m224hgF8G2KsV4rv8flxaHwPxNqsARiCgFkVTOWxKcBc4wqgbUPl9zyzEQej/tZ+/PCjP6wIdnh7\n", + "kwOTaIo0Yc89e/DoC49iaXUJr0RfQeHeAvAtACeAtmgbPnDDB3Dh0gUcOynuqkjI8wJLN375Rqxc\n", + "UP8ohKINUdzUehP6W/rRHG1GW6wNezN78egLj2LfT/bhzCXxh5UdyOKp+56y7Lu6vorb992OlQsr\n", + "WgjkQPzoC4/i4GsHsX5lHTt7duKJsSeMbbc9vg0nzp9ABBFcKZ7ETY1NuHj1omWuunaDgk7AelzU\n", + "Pu20ilXMYAZ7sCcElk2q8BiGqgd5Ac9orQYTSq9E4toCmUrV0iJ+jowIvtFpfn4emUymrsa0WeU0\n", + "t9lZlTNrf7KWjsGjOGxy6+EMgH3ALGYt/6TLOqcS8GdBWxLQCQDRdwHYC+B9AOIADsKEziSA7wF4\n", + "P4CTEBBHsEKnnbWR63xxv9d8jPGy+yYABEy+aPNZFAI6ATEXaUHdCuBtzfYpCOhMQIDqFQjo7IGY\n", + "fweACIAMxPH8BcQxBUzwLR5XQ/LY6KBNcyMiaAX6HeXzPLODuJao+GMPysLG2/tC5gtGe0urSwb4\n", + "4CjQ2dyJsw1nce7yORx5/QhSW1LGfnvu2VOyz7bHtyHSEEGsMYaXHnzJsBKuX1m39M8BrzXailRz\n", + "ygK0ibiwrEroTDYlsTezt2QeiXgCP/4ffoyZozNojjQj+1wWLdEW9DT34LW3X7Os49LqkgG/R14/\n", + "gtSXU2iJtmBn907c1HwTTpw/YYxppHsEiaYEjrxxxDJXqUdfeBQn3zmJh771kCfLpO6c0h1rflzU\n", + "Pu2UQKI8r49QdaNyjmGtr6VChQLEv/lQoepGs7PC8lZPbsf1OKag5DQ3eVNkQ+Y8MwNkMkg8NIF9\n", + "e1b9j2EJwAKEi+JPiu+NQAAIzH/SNbkzPAMBTT9i49gL4FEIt9NjMN1SkwB+AGAAwKsQlr5mlAKh\n", + "A3Q+jxk8gwyevTKB9bdXncfW5XkWpeJWUf6fhI/1fRAutJMAfojSW52tAO5gr18CsAXAcQDbi++d\n", + "gbCayeO5pvTJjqtFM8W+zynv83NjRrOf2szzM8g8k8HEsxNYXXdZzzqQhLjDJw5j5qg5wdl7ZzF1\n", + "61Rgbp127UnwaY22one9F9vPbsdlEidFsimJ7/3290r247DUiEacuXQGp9ZPYcfXdhhrvrN7JwCg\n", + "PdaOba3bMNQ1ZPR55tIZHD993GhDAtdP3hZ//A1owK1tt+Khbz2kPYaJeAL7xvbhmye+aazdV//x\n", + "q8bvt++7Havrq8Y4AWHBXb+6jsLFAo68cQSvnRN3eIY6h5AdyGLu/jk8sesJ2zW3O06A93NO10bQ\n", + "xzlUqFChglToahuqItVr/ONGjKte12JTqlL/Zh4X9ySAR1Cxq6Krpczu8wxQDCcF+iEALKG83wRh\n", + "ERwG8ITSdg+AU96H+QwyWCk2fCumMOZ0F1x139VJ59LLXWgjxedFzb6TAJ4u/i6tkmcg5neO9Z0C\n", + "8GNY582PYQKmy+zNAJ6CWK8tEJbXAZQqA3N9uauuz5jJclwXN1J+YwdlLGYLWjCL2YpvxqyuryL1\n", + "5RTWrwoLZe+WXpxcO4lkUxL39d+HX7zzC8f4zu1/uR2n1s0TXq453yb7XNa0qgJoibTgu9nv4t/9\n", + "4N/h+KnjOHnhJNaurCHWGMO5y9Y7D3ZxpjPPz2Dvq3sNSFY1desUmiPNOPTaIUQaI7g9eTsWfiHG\n", + "oIsddZN6nKSLcku0BWcvncWxN63uyDpJ996OWAcWP7poiSENFSpUqFordLUNVXUtLZl8MDNTP27D\n", + "GzGuel2LcrThEO3Vv9luoLOwulgGcSykpQwode10+lwaSVTQke8nAdwG4TZ6RNP2SwA+DOAd2Cfm\n", + "keoComdbgEtAN0Zwj9YUyOTFtTai2Y7HbV4BZj4+g6XeJbRcbMHsn88icSEhrJl/yrbj7sRnlTZW\n", + "YM5bAnwMwmIpvSPl8cxCgPDZ4vN3YcItl1zfNgiL8irE2qvnhovKcV3cSM3eO+srdnAJS0airRnM\n", + "+HbXs3P3XL8owPPq1avIDmSxN7PXAowzR2e0APjSgy9hx9d2YP3qumXNpVUSsFoyCYR4JI6Opg7s\n", + "G9uHxN6E4V4r4TfaEMVluoxGNOKZ5WfQ1NCEt68Iv+/eL/Ui3ZfGhcsXLNB5V+ddWHlnBSfXTqIt\n", + "2obCWgFvXHkDpy8K3/Erp6+gd0svRnpG8PhvPI5HX3gUR39xFLd+9daS+M+SNcMMzt57FqmjKTx5\n", + "z5OGG69cm+ZIMwCgI9aBP7n7T2zXfqB1ACfOn8CZS2fwyAuP1P1NkVChQoUKXW1DVaSNiH+cn593\n", + "3WYjxnUtxYJKiD58WLBdzeXVv9luoBI2PQKzl3PKApC641v8/MdtwFRBJA4DIEBnClbonIGAphSE\n", + "a21n8X0OSVL3QcRGcuiM2YzxNHBvxyxu7ZzC/ZhDPAhXYg9wunTDEhZ2LODwnYcx84nicTgPYWmW\n", + "4uNXEw51AXgDwhr5dxAAfwRinglYj2eLsq/dvdVZiGRF52ACPeD73CjHddHT+RSAnp+ZwTOZDJ6d\n", + "mMB68YSTgOZlrDPPz+CVZ14BngWG1oewx+1GhUY6d0/pFgsApy6eQiwS08Yf6vb93A8+h46mDsQa\n", + "YmiNtRrtvOdr70FibwI9X+zBDVtuAABQ0RRfuFjAh5/5MAAg1mj944g1xvDygy8j2hDFVVzF+tV1\n", + "AzoBGBl5v3/q+wBE7Oium3Zh4bcW8OrHXkVPvEfEp75xBD85K4C3LdqG0xdP4+TaSbTGWi3xn4WL\n", + "BRx5/Qhmjs7YuswuYQnH4sew0rSCkedGMPHsBGKRmLE2dyXvAgADKAH9OdXe1G7s0xxp3lQu4aE2\n", + "XrX6ngoViisEz1AVqZ7iH4thgZiYAP7sz2o/rmqsBZ/Tag2vJTYcohMJzCT2IZNNOM+9lgPVAaTy\n", + "eb4H+OA54MkjjIN1oLMEEdu5AgFnKiTdBgFhq8VtzsCqXcWx3Fd8zeArfiqBsXP7vEGnCm3N7ruU\n", + "KAa0bCkCxekR7PlK8Ti0ohSipSKa947BNibXolkAvcXfh2FaRFUlIDLvOrVlJxmXOwEkLngHuVpr\n", + "dWkJKwsLOHH4MI6WcYdoaXVJlDo5Adxy9Jay3GxVmJx5fgYXrlxAU0OT5X1AQPzg1kHEI3E89K2H\n", + "DEhUEw2dXDuJS3QJC79YMIB05Z0VI/bzbwt/CwCINIgTqSXSgr/+yF8DAF568CXEG+MARFbZ93W+\n", + "D5954TPoaOqwnUNXvAvRBuEAdgVX8N03v4tbZm9B6sspIyvtUOcQvpcV8akS+BrRiJMXTmJ1fdWw\n", + "wgJAW6wNf3L3n1jAevtfbjegsKV496RttQ2nVk7h8InDaI22Gjc4Ord0lqyLTvymyGtvv2YbMxoq\n", + "VKhQ9aIwxjPUNaNrsezJRs2pHsr8eJp7PQyUqaT8y6PQx32qcYYfgACuyxDAdr64XQrCUsjjJ+8A\n", + "cBSlcaKq+iGAVZdJlisGkTm2ubitHeQPF+dxDNa4zwZgdcsqZj4xgz3P7UHijoRwG5bZbFMAfhPA\n", + "4zBLpXQW57gOsQZvFJ/txbn9Ozi7wrqVGOHuum0QcOrn9MhAHx9aZ3p2YgInDh9G98gI7p+bQ9zn\n", + "30AQtSTVsiBOZVtmnp8pKW8Si8QsbsG8ruZQ5xDyv5XHoy88asRfNjc2Y3zbOI6uHMVtidvws7d/\n", + "hu9MfscS3yjH9Ma5N4xMtxPbJnDk9SMGSBprsG0CL731Ek6unQQg3FuJCGcvn7Vs1xXvwvt73o/Z\n", + "e2fxwDceMGIwARGHyfuS73135bs48c4JNKLRqDea2pLC9z72PTwSfwTHnj2GN068gY7uDizev4iB\n", + "+IB2Tb1IdyzLqekZKlSoUOXKS4xnaPEMdc1ow610VdBGzWlDM9oW5WnuNRqoV8tzidVbzaAqLWmX\n", + "IBLixAE8BJHBVrq08uviFQhw4vp7CBhahel2OgTTXRcQcaM/hD7hj6pLEMmLfg576ERxLj+E+K/B\n", + "/3NQ0Sr43/Yh8U/F2M73K3P4GkzoBARM//PiPN4LM/PsWQjodHOFdXOXlevO3XX9yM2tuk507+ws\n", + "bp2aKgs6Z56fwdmLZ5HaksKTu54sG0pU115uAVVrherKm6jW5J7mHnTFu9C7pRdP3/e04cYq4y9/\n", + "/aZfx+n103hr/S0ce/MYzl48i1958lfQ80VR/gQwS5W8euZVAMI19uLVi/i1G3/NMvYHtj2A85fO\n", + "45frph/4aGoUTZGmknmeXj+NwycO47a/vA2vrr5qvD/cNYw99+wxrKD8PQnDV5lv+craCn59/6/j\n", + "5DMncf7qeWAAOHP/GTwSFy61M8/PIPtcFucuqumYnaVzCXfKnBsqVKhQG6EQPENtOtnFJdST229Q\n", + "uhbn5FW1nLtbrIvXmNcSDlYB5iBMIHodpnspF0FkuZX7vU/5/HJx/9sB/BkEvOVhlhkBgGcgYKsd\n", + "ztK5vOqULG4rkwJdcdhuD4R1N1V8bwQi+yxXG4TFcw9EnVFpXIoCsMulwtxfHQEZqBwc3dyqXVSr\n", + "2Kl4IoGxfft8QycgoOTYyWNYWVvBB576gOe4QKdSHyrMPvrCo5ZtJZQmm5L4wb/4QQnsvudr78Hj\n", + "//A4Tq+L+EkZ3yj3645348z6GfyoIGoTjXSPYO3ymuGC+6EDHwIAfOUfvoKFlQWcWj+FKKJGDdFX\n", + "Tr2CRJPZ5wsnX8DCyoIBta2RVly8ehHfeuBb2rk3ohFvrb+FU+un0NTQhIltE/j2A99GIp7A7L2z\n", + "mByYRHYga7zXHms32o01xIw2fn7+51hYWcCZN84AJ4Gt2Io/KZ74drDodk7pYnvLSYy12coHhSpf\n", + "YYxnqI1QCJ6hrhnVg5UuaF2Lc/Kqepp72ZbnWQCDMC2bvP6mtHB2wATEhuL7FyHgKV58fwJmXKPU\n", + "CoB3AXgOouYl/zZPQ2TCLcBZV2CfnEeqCSLm1KF2qDH2H8BMBvRjmPAmYy3vhEgkJGNZ+wAssjYu\n", + "w5qQCDCB80l4r79ZITj6TUBUkfwAdYDiNSlX1lYMyJHgse0r2/DhAx8uTYyjAaOZ52dw45dvxF/8\n", + "/V8YMPvIC49Ytn3fX70PZy+dRXOkGdGGKIb3D2PX13dZ2l55ZwVXinc1Yo0xS2zo1K1T2NGxA8dO\n", + "HsOp9VPob+3H3P1zlvM30hDBjV++EReumCfrFXaX5OS6KLMCCJfa9ybfC0CAIQCcv3IeR14/gt9/\n", + "8feNGFUubrm8SBfx49UfI/tcFhPPTgAAnr7vaTx131MG/M3eO4vueDfOXzmPS3TJaMNSsuUC8PbX\n", + "3sbvrv+u5bi4waIXQCwnMVZoJQ0VKlQ1FYJnqE2nTCaz0UMI5UMblSDJj9zOKd/WVwkTD0HAlbRs\n", + "xjXbnoGAxH4A0hNwBCKm8hgEoLVCuON2KvtegbAWnoIZFwoIq+QxuGekbURpjU6md1reAW0hEbN5\n", + "yaWt4zDrac5AWGSPQABgd/F5A8S8pC7AClvDELGmGZggJt1mJUR7sWJK+M2i5kAH+PyOUt2xayBp\n", + "mWxqLE0AJMHjxDsncOzNYyUAwsGoOdJsAOfKBRMak01J7Llnj2XbvpY+HHvzGC5cuYC31t8S2V/f\n", + "OILbv3a7AU4y2VAEEbz02y8ZcYrS9bQ5JrJfNaIRFy5fwL8++q/REhF9vLfjvbh49SJWLqxY5krK\n", + "CX71qoDHM5fO4Kdv/xTRhijOXzlv2eb7p76P4e5hy3vSeik11DmEvpY+R0hLxBP41Z5fLXm/OdKM\n", + "ni095htrQMNRQdCz985isG0Q8UaRgEmujTynJHA++dMnXQHRT4Zjqc1WPihU+QqvpUJthELwDBUq\n", + "VFW14aVZApCr9VW1WnGY4Flaf0Oz7wgElL0LZu3KOZhWUAlaCQB3F98zKjAXL6ob1oBDZ0yw9epC\n", + "Kw04sr1GGBaky42XEb0YRcPZhtI22TUzUBzrv4EJeEsQFtkCBHwegYDjIxButnblYG6GcL3lICYN\n", + "c8MAJuHdirkBQFeWNiCeVLrZXrx60bAcqjGajcXLg6HOIQuA8My0B187aAFOAEg0JQw3Wm5xk+Cm\n", + "AtzK2gre/dV3Y+LZCXzrgW+hv7UfP/n4T3BX111GMiIJWPNvzAMQVsPT66fxV8t/ZSQB2p7YjsK6\n", + "s4k/2hDFFTLH+sb5N6zWx6Le1/0+dMbFXZ7hrmFMDkzilY++gp64eeL/ePXHeOHkC8Y2KqRJQLx0\n", + "9RJ6twh3hc6mTsQaYnh/7/vxN7/9N8b7w93D2HuPSM+ciCdwc9vNOHayFPoB88ZA4aKYa9CAWI6V\n", + "NFSoUKG8KgTPUJtOYVzC5tJmSPpU8TnFIWc7gB8V3x8B8D2Ybp+/YPu0wwQpCVs8GY7OXbQHAlJH\n", + "UYTFIhTSL4G9OQFugD4GU01SJNUB4OViX6cB/BK4HL2M6NUomi4X3Q2TMGEzBtFPb/F9QFhdea1M\n", + "XmtzqPiU67EXwhUYEBl6e9lnX0ApiMl1+DaAp+Hd/XUDEwT5Op8qdQv2INUtk1u1fqPvNwx30dX1\n", + "VcM9VLqV3rL1FguAJOIJ3Nx6M469ecyAH0AA5cS2Cfzs4z8zkupIi9ujLzyKl0+9jFhDDHcm78S2\n", + "1m2W8Z2+KBL33HfoPvzwoz/EwNaBkgy4ACyQ2BJpMeCwPdaOP/3QnxrWTztdpssGJDei0QLMHTFR\n", + "biWCCL6z8h384NQPEG+M42dnf4bzl8+jo6kD8YjpsrB+dd0Yz9LqEm6ZvQVb/vsWfOCpD2Db49vw\n", + "tX/8GhZWFnDkjSP44A0fxNStU7g9ebtRJmb7X27H7cnbRUzo/d92jc2U55T8TAJxJYCoc9ctx0oa\n", + "anMqvJYKtREKwTNUqFBV1XWRIEle77ZBWPZOQbjOzkG4n15tJGsAACAASURBVMp4QbldEsI6+gKA\n", + "WyGyxQJWSNLFGX6z2PYCGFyeA+4olpQ5aTO+LRAlWwABmlH2WSuAu4p9PQogC0QuC/MmgYQl96cQ\n", + "FllAuNy+DNEXNzANsbHPinYwUGwfMC25CQBPQMDWUQgXYg5eKoiVG29ZA6ALRDWIJ1Xj9pzqP3L3\n", + "0JHuEezNlBZK5fAzsW0C2YEsXnvoNRwaP2QBFu4WKmtzHjt5DG9eeFM7zpW1Fdy+T7je8gy4XM2R\n", + "ZqSaU/jIwEcMt9qzl84i93zOErfqpq54l+W17OsKrmD10ipW1lawfnUdq5dWceT1I+j5Uk+JGy8g\n", + "gDXSEMGZS2ewfnUdL7z1Ak6cP2FYYiOI4Pyl89hzzx68du41Yz8JoAAMl2IJgX92z59Z6p3yGE55\n", + "7L79wLeNrL/lKoznDBUqVK0V1vEMFSpUIJqZEW61LS0CNq8pyJR1IdV6nFKyrqR0LZX1OdXttgNY\n", + "hrB2bocAT6l+CAB1WrdOWGEvfhW491PA4/9eLHgPBJhyNUMk+umAWftye3G7SHGsncV53Q7hIsvV\n", + "CGFl/SVEzOhWiHqfjTBddbdAWHPVsWdgrYcpS8z8BAJKXyv+bId+XUMFIqd6nbrP3OpIrq6v4n37\n", + "34e+lj60N7Xb1ojkNT25Yg0xI9mOTk0NTfhg6oMGmAFAAxoQa4zhgW0P4PT6abzyy1csFtcGNKCj\n", + "qQOrF70F9EYQwVVcLYkB9aNIQwTff/D7uPfr9+LUuvmHF22I4jJdNn4C+lqfANC7pRevfuxVZJ/L\n", + "Gms1desUTr5z0ngdb4yjJdqCnd078cSuJyx1USup0xlEHddQoUKFkvJSxzMEz1ChQgWiTEbEcgLC\n", + "wrlv34YOJ1hlYAUou7lJAJUxmaoSEMmEABGPuV78fQiiJIrbdd8uCLCVygJ4qvj7DIBXIJL8HAHw\n", + "H4q/fwfA5wB8BSKZTxTC4roKAdJyPFPF/dwy4U5AWDG/DeGaG4EA18sAdkJYMxNs28MwQTwLcx1V\n", + "Oa1rHer5mRmsLi0h2tKCe2dnyyppUitpQbJ4p2i1I4aZ/6UNe+7d6ws8bvzyjYYFMDuQxVP3PVWy\n", + "jQSboc4hvP7O63hr7S0Mdw2jPdaOhZUFNKDBFvzijXG0xdpwev205X0Oc3aKNkSRfyCPe79+Ly6S\n", + "l2K25Wvq1im8/NbL+OnbPy2ZT7IpicLFAhrRiGQ8iVhjTGs1HWwbxOrFVRQuFtAWbcMHej8ANABH\n", + "Xj+Ctmgbzl0+Z+lv35j4Q+Fgz9/3KrcbDKH0msEMlrCEFrRgFrNIhHfMQoUC4A08Q1fbUJtOYVxC\n", + "fWozxHLayfWc8hov6OY2KZPqtAB4EQLEbv4B0PoA8JBN2l+euOi/w6yJuRXAf2bbLUFYUNcB/D8A\n", + "DkHUCh0ofiYrTFwG8BaEy6yETjmvncXXt8NMVMRzwQxBWD9PQsRn9kFA51swrb3cY091d5Xr2K78\n", + "9BKHuUFlR+y0urSElYUFnDh8GEeVrFn19h2ljdsrZv1KPHME+74Q04KHU8mO9Svrxu928CjdQvO/\n", + "lcfSx5YsLqLd8W7LfhElI9b61XX8cv2Xlvca0egKnYCI5dz17C7c2XknGlzrBZWvtmgbCmsF/NO5\n", + "fwJQug7SIiuTIZ1eMyFajqs10orCesHY9tzlczjyhqg5mh3I4gM3FH3kXxWJnpojzcYxiUXEF0q5\n", + "CYbCeM7ytIQlLGABh3EYM3WducxZ9fY9Fer6UAieoUKFCkTXdCxnUPGCL0G41P4dRFzlUwAungCO\n", + "fRo4/Cngd/730n144qJHYMLh28XXEsh4QiP1GtQu9K0NAuTU2MvvAPgYTPiMQ9TzXAbwTHE8CxCu\n", + "ttxjskPpWwVxuY6vABh8Cbj9Y0DqeeDJM+7rapeldoOANFq809I9MoJ7NtudFsDTnSK1DieH0J3d\n", + "4kRsjbTi/OXzFjCVwPrQtx4yrGmJeAKJpgSyz2Xx0LcewlC3yDiVaEpgYtsEIg1W8GyLtpWAXKOP\n", + "S5a1K2t4+fTLIBCaI83oineVwK1Ue6wdu2/d7bntCCKINkQNSOSZcrk6Yh1GPdBGNOL9ve8HYJ3b\n", + "+SvnsXpp1RiH1Mn1k4hFYnhi7AlkB7IYvWEU+d/K45snvmkck6bGJl8ZaL3U/gzlrpbiF+oIRrCn\n", + "1pnLQoXa5ApdbUOFClXfulaDR2Xc6LGzwOXiBWf2ItDTZI2DfBUiHlO6q94J4ASEtfAVAJ+E6b7a\n", + "BFELlLu7AgLI/kcA34ewiHJ3WuniqsaxOrnFcm0BsAbhcvt9CKB2mq/Rfsafb7bqtivnl4E3N+iA\n", + "tb66iqMzM7hnz566crP1HPe3uir+tvbssfxN8f0v0SUcef0IRrpHEI/EcexNEZ+Yak7he9nvYeSv\n", + "RozYxsG2QVy4cgHr/z97bx8U13nne377HZoGGmhkhJBakkvWSyIZJBzJsRS1IyleEyd0XshcM3cs\n", + "u2rdU8luJffurrh3tu7O3Jqb3Joqp27NTO2uK9pkxEzingQpkWLZZhRhCSThGFu2XhxJMQ6KiRBC\n", + "vIgWIKBpoPePp5/T55w+p885/QIN+n1UlOjz8pznvAD97d/Ldy6MKKJCraVaami9tx5XR64KdaKd\n", + "dzsxFmENeRxmB3Y9sktS4+k0OzE5P8nWmxwIR+MRVy2SpeceWHUALftbJDWWRpBfG47NZMN2z3a8\n", + "N/SeIDJXOVcJ12ckPIIiWxHGImMoc5QhGo1ia9lW3Bi9gcHpQaHusqmrSXI/1//reiE66vf6UZ5f\n", + "Llkv3158/9NNzSUYIYQQQACHcZjSbAlCBNV4EgSx9FmuxaM+SIVdzSxwxqos+KrAPEB7AVxBPLLX\n", + "AGACTJC5Yt/z5fLLxIXfNcQbENWA1Wq6AaxEvLGQH0ygtsZe84ZCcmrBBCdvkpRM+InPtwHARB3Q\n", + "6gdcO4Bd24CjtuRRT7X6WTVB+pCSrriQi0O7xY7Dew6j8e1GtPa1Cts1rG/AxMwEWvtaYYYZZlNi\n", + "GqxcPF0bvYbh8DBcVheK7EWYmJkQur+uyFuBwel4W+byvHJE5iJCNJCLx+rSajgsDnQNdUGJUnsp\n", + "7s3cU1wnF6Al9hLcfP4m3A43Vr+2Gn0P+gxdKwB43P04yp3luDBwAdPz03BZXfjCyi/g/sz9BDFq\n", + "N9sxM89qTqsKqnDhqxdwqOuQpOmQ+Jq7HW7J/eDpySPhEaEWdGp2SthX3pTI4/DgifInBAFKzYQI\n", + "gsgmVONJLEuoLkGFQICJtDqVWsGlygIUjy7YMyVOC+X1ntVgQu+MlYmmnthy/qu7CMAFxL0++a2V\n", + "+1zuki2Xw1NVh8FqM/2Ii04g3ugIAKKIRz3rwbrt1iPuucnnfBqsxlN8XLXU1wR/ziDgeQqY2AG0\n", + "2aBZKqVWP7tQtikGUnoX/HeUaG5CGqBK3Z9WuqXYQ7LZ1yzUAAb3BVGRXyEZO7gvCKvJinnMSwTd\n", + "ttJtEo9JnrI7HB6G3WzHxOwE+if7BdFZbCvGFyu/KJnH0PQQ8iysoNlldQnj90/249bELdVLoSQ6\n", + "nWYnVuStSPD5HJ0ZxSP/8gieb3seY+Ex1TGTcSV0BW39bZienwbAajQvDl1EvjU/YdsnVzwJgF0/\n", + "7lfasr8FRfYiYbn4mgPx+5H3hzwMh4cxEh4RrmFbfxt6xnqEfQ/vOSxs77K6MBwelliliG10SHQS\n", + "9F6KWAxIeBLEciHWLAStrUyELheUikeXqsgW1ym6AKwD6xDLRV8AAH//yxNFxsBqOfl75howESj3\n", + "ueT1mWoCTCz8roHVl4q347Wj1QCaY+uOAzgBlvJ7AnHPzbOi/eXCT3yOm8FSgX1gtaCSebuBJz4T\n", + "n5PaZwpagq8JrNlRo8p6AyQVZWo1ppkYO11Ecwv+PLm40PJuVBMnbocbN751Q7KO120CgNPixIFV\n", + "B+D3+tHxlQ6Jx6RYzH5h5RcSjllkL0LrrVbJspqyGvgqfXCYHZianRKWD04PYnpuWtdlMcMME0yY\n", + "nJ/E4PSgYofbmegMfnHzF4IIlrPKuUry2mlOLJiWNzAanB5Ed6g7YS4wAWsK1sBhZv6cB88ehPMn\n", + "Tvym7zewmWz4yd6foKmrSfKc8PuxpWQLgNg1rPiC8P27X3tXck/49rwpkfgDCLVmQlT7SRDEQkGp\n", + "tgSxXKirY6KztnaZdvgRsVTTb3laqAssQjkFgGfjNYAJKJ6OagXrQMtTSL8X2/dxJNZwqiGuq3wV\n", + "TMCqWb1oWcHohZ8jx4N4aq88FVfPMX1IXsOptd4ASdNU00zpzWp9nYG58XRLj8ODje6NKLIp+3Dq\n", + "rRXtHe/F7td348JXL8Bb6FUcw2axocBagGJ7MXrGevDe4HuCj6fVZMUOzw5J6mx5Xjne/9r72HVi\n", + "l6L9iBVWzEK7u61RtKxaHGYHyvLK0D/Zn3ScbaXbUGgtTPDs5GOE59knTfLzqHRWYkPRBsXnRGx9\n", + "AkDTBsWIVQrVfhIEkQn0pNpaF2oyBEFkmWBQsVnIsmSpercEATwGZj/SBqAitpxH/Bpjr0sAtAP4\n", + "PuKirFe0XwDKDYHkt51HwgAmOpO9n3RrrBeT7LhBsEjnQOy83LE5K0U19RxTy8pGr9WNDsSRuYQ0\n", + "1SDSEuZJx04XA3ML7gsicD6A/gf9Qg1i4HxAEBvcn/S3X7qK33lGE9bL8RZ6cevP46mvYsE6FhkT\n", + "jtGwvgG9470JdY+z0Vl8OPwhAMBismAuOoeh6SEc6joksWyR7JNh0WmGOSFdWIlCWyEGJhOFsJx1\n", + "heswM5cYXXVZXZLorfw8qsuqcXXkKgDW4faVna8I65q6mjA4OYjGtxvRebcTDyIPcOKPJ3Dx6xex\n", + "rSyxoxePbuohlWdTdxMrgiAIEZRqSyw5qC5BBbebRf6Wu+gEMu7dsmDPlBtMICH2/7uQpqnytNWb\n", + "YN1hxTWNSgJLK/1TTZSla0GS7LhuADcQPy+tFGAttGo4y2NfGXjsk9bAqdWYKqD0PKVaXxc4dw6+\n", + "119H3VtvIRRW6eRqYG5ckHDrDrnY4P6k0Tujiuu1ONl7Ukjl/eT+J5IxuMApc5RJ9olEI6gqqMLT\n", + "K5+WbM8tW7LNPOZ1bTccHtbc1mayodnXjOC+IErtpZJ1E7MTmEPceoVbrQBAHvIwMz+DVQUstXcs\n", + "MoZDXYeE9e+df0+4rmORMcxhDpFoBDtP7ExIlRW/Pnj2oGYabSrPplbKNpFZAgjABx/qUIdQhnyj\n", + "6L0UsRhQxJMgiKUHF9nZJADgJFj95Q7oT2/VQh6dEp9GsgigUlSLC0sPgH4wISmOQKpFwsSRUB49\n", + "1WITmCCeRbzxUQ2Uo4zy80jnVmlFRZUiwRyDVjy6okRaUeZ0xlagOxRCxwCLsgXOn0fL/v2Gx1CC\n", + "Rz7lqZjcn/Q/fViNE8+uxU/2HTEklMVRytryWhTYCnB4z2E0dTVhLDKGivwKeF1ejAyNCNtZYMFE\n", + "ZAKRaAT13no0+5rhdrhRWVAJj8ODueicYCHisrowMTuRcFwxWimz2cICCy5+/aLQxddsSvxs3wIL\n", + "iu3FsJqsmJqbwswsi4xOYxptt9sSGjhxHBaHsPzKyBVEohGYYEKXvwvf7fyukCq74ecbJNer3FGO\n", + "ofAQAPXIdSrPZlYj+EQC3ehGR+yXdgABtCyUbxRBZBiKeBJLDp/Pt9hTIBaTdKN1Cig+U91g6aKj\n", + "iIuaTGAgOqW5H48GbgSrFZVHINWOlUp66gBYg6AoIAR9/gRpUx899ybT9y/ZuWSj4ZaOJkOZ/B3l\n", + "tLLPh2s9Hhzes8fw/mqNY9QazewLBrG+oQHfevMsfll33HAK5Y5yFqWsKavBa198DS37W9DU1YSW\n", + "nhZ03u3EwNQArt5j6aRWkxXFtmLMYQ6hmZDg28mP2Tvei+HwMEZnRuEwO7C6YDXyLdJusfJmP2ZI\n", + "bV1K7aUosZdItrEqfOZugSWhSVDCNiYLDqw6gJ3lOxPWmWBCz/M92Fa2TdLFVz7mPOZxb+YeBsPx\n", + "Jknm2FuxWk8t3vW/KzQT8p/yC/dt085N8Dg8cDvcOPPcGeRZ8nD5G5exrWxbQidbLjprPbV4vOxx\n", + "4ftMCkS9UVJqXJQZhG7VqMXhdGsKYtB7KWIxoOZCBEEsLXzIWDOZpIib5Ij9LnMRo41vUmkkVI54\n", + "kyBA2TfUB+17o2cbI8jORVJ79qMI3K+3Zbbh1gL7hobCYQTOn8fhPXvgdjgM778QjWPE1/zVPa/i\n", + "UNch5Fvy0Tvey2o9Z8aERjsl9hI8VvQYuoZZM6GK/ApJA6EyRxk+V/45BPcFE7xDxdE7Tt3qOpzu\n", + "Oy00K+LbiCOjJpgQRfx9yFv/01v4Hx/9D7TdbjN8rmL/Uo4JJkEEBs4FcOzmMYzOjMICiyS11hz7\n", + "x2s7rbDCbDLj7efexj9e+0dJ9HnlT1cK16XeW49QOKR6H3kjodHwKNput6G6tBprC9fiiO8Iuz86\n", + "mwxlA2pclBlCCCGAAA7jMNw5+4eIeNghH09iWUJ1CQ85GWwmw1F8poJg9h9+5LboBIx7WaYSdb0I\n", + "5v95AOyaKPmGiu9NPvT5eRpBKVoqOxdJ7dlfujJaCwxA17XO5O8ot8OBlv37UxKdANAzznwei23F\n", + "kmY1mSJwLoCWnhbhmh/qOoSW/S3oHe8VlnGvyRJ7CS594xJK81jtI4/wrchjBrEuqwsj4RG09rVi\n", + "+6+2Y2xmDHazXdiWR+84BZYCXB65LLx22Vxoe65NYicCQCI6ASbEju4/mlBrqoXL6sJoeBSv7nkV\n", + "DesbsKN0hzD+9y99HwB7/njEUZ5qO495mEzx92SzmMVMdAY/vPrDhOizOGX5VN8pXOy8CIBFkuWR\n", + "Sx69Prr/KBrWN+DsV87i+DPHBcsbpcj2QkEpuZnBDTda0JJR0UnvpYjFgGo8CYJYWqTZXVQ3bjDv\n", + "yoXEaP1gKvWGKdYowgvgtui1UtRUfG/8UK4jTef+6ahNlbzR3XcEqMvwQ5Ks5pRf2ykAp5CR55N3\n", + "mbU6ndgXDMJhUEB7C7zoe9CH+5H7gijUQq1jqdLy7lA37kfuA2DpqqPTowiFQ4LYLLIV4dSXT+H7\n", + "l74vRN3k9aUf/9nH2P7L7bgXvgcAqC6tRoGtQOiAazfbcX30OiwmC2wmG56qeApXR67i3sw9PJh8\n", + "IMx7IjKBr576KsJzYdybvqd6fo8WPYrvvfM9zEf1NRUqsBQgYolgYmYCbbfbsPZf16Iiv0LoUFtT\n", + "VoPLw5fhPuLG5OwkAPb89T3ow8DUgBBxLbIVYWvp1oTOvkopvjvKdwgR2em5afAGuLcf3E7YlpNq\n", + "HXE2UaslJgji4YRSbQmCIFIlVRGnhg/G0lCNbp/qPqmQjZRUHWMa8S/MOD6kdW2VhN3rPh8GYp61\n", + "6xsasN9gUy3u21nrqcWWki1C+msyCwy19Eil5Xx8cUOfhvUNEruWdYXrsKZgTdLjisf2e/0Iz4XR\n", + "2teq2EyoqqAKW0u2orWvFcW2YkH4AqxT7Ew00cpEjlLabqrUe+vR3t8umcfeir2YnpuW+JMC7Nyi\n", + "iOKdu+9gaHoIDrMDDosD4bkwqsuqUeooRXBfEACw+RebMTA9AJvJJqQSA5SyShBEbkKptgRBENlE\n", + "R6MZQxhNQ00lbTULqcoJBACMgfmUHkPmItM60lwXNbUwzWurZFHBu8x6amuxJwXPWnETGHH6azIL\n", + "DLX0SKXlfHzfSp9kndiupdJZqXlc8dhHfEeEcXetYCmzVhNL0HJanNj9yG6hQ+6+yn1Cs6CtJVuF\n", + "cZJRYi9JSNtNlc+6P4tmXzNsZptkecdAh+BPajOxdTazDXce3MHM3Aze/9r7aFjfAIfFgbHIGMLz\n", + "YXQNdQnXyO1w48af3UDD+gZs92yXzJ1SVgmCWKqQ8CSWHFSXQGSalJ+pTIs4o7WaRrfX2idTHWe7\n", + "wbrsDgA4pLGtEZRqU7PQ5ThlYte2/W/aUxLbSsKOd5n98unThtNsAakQ11tvp9axNLgvCJfVhe5Q\n", + "Nzb8fAN6x3vj9YUHjkr2EY+h5Bkq9yWUH1M+7gdf/wBVBVW4/q3ruDN5R+iQe37gvNCsZ33RetSu\n", + "YEa5ltg/JbaVbcOP9/5YELNizAbfFl0PXcf6f12Pje6NcJildbjcn3R7GROOkfkIuoa7JLWwvIZV\n", + "3NmWXyN+DW4/uA18zMR3+1fa0/5QhTrNEgC9lyIWB0q1JZYc7e3t1Aac0I8OL8eUn6lUusPmMj4k\n", + "pIp+5Qeb8Mf5AeTBhjf/8iIeWeHVHmchO7/6sDCpwwZI9XnKdppwJsZ3H3ELKaVVBVW49ee3Ujqu\n", + "Dz50nOsAQkCFtQI39t2QzClZbas4fdhtd6Otvw21nlqc/vJpAMBjP39MkkZbZCvCWGQMFpMFc1HW\n", + "Zdbj8OD+zH1JCmuRtQhOm1PSZVeMFVZB5Crh9/rxzt13MDg9CIDVqj6YfYCbYzcl3W1L7CW4+fxN\n", + "NHU14cQfT2A4PIzPrfgc7jy4g9UFq1FkL5KkJO/+9W50nusENmYmzZY6zRIAvZciMo+eVFsSngRB\n", + "LG98PublCLAOpwZr5B4qFATjZ/+bG9ceYULjC3er0PF/aQuNjAvyZLW0C2xv8rBT/s/lGA4Pw2lx\n", + "4vq3rsNb6FVtRpSM1edWo6+nj3nDIlEA8drWn/57YOyzHqza+oQwtljIAol2IVyY1pTVYI1rDfIt\n", + "+Wi52YL5mAGt0+LE5BxrAmSCCSX2EhTYCrDGtQbXRq8hNJMYBXRanHhixRPouNORYM8CANtKt6Hj\n", + "K+z3zOrXVmNqdgpuhxszczMYnx0XtjPBhO2l27HCuQJjkTFJoyFx3an4eoiFtpZvph4yPR5BEARA\n", + "wpMgCAKoqwNaWzPr5bhcURCMtf+tHB88MoxHB53oDFzXF/HMND6oRzWXWNQ53S61mSQVwdg73ovd\n", + "r+/Gha9egLeQPQvyCJrb7lYdlx/zyr0rgsDjEUDxdm/V1aGvtRX/8DcuXK+cEMbWE52TR1jF8xMj\n", + "blwkbo6khAUWFNmL8OQjT6JrsAsj4RGYYRbEbL23HivyV6A71I3Ou53CWEoilSP2MK0pq0GZo0wS\n", + "vXU73AicC+D6vevoGevBu197V7jm6bCoDbgIgli2UHMhYllCdQnLiIWozwsGNb0cl/UzZeQaK9RQ\n", + "vvmXF/GFu1UZFZ2Ga8yS1dKm4kmaZZI9T6Hubgx0dKCvtRXnA5noSJU6Ss2MtPAWenHrz29JBJC8\n", + "djTZuCd7T6JjoEMiOi9941KCAOK1rVXbWXMh7qEpfl7UniN5gymlhkNOixMWE6sBLbAWCEKx2FYM\n", + "v9ePYluxZPs5zGF0ZhRX710V6k0dlnhN5/DUMF7vfR0dAx3CWE6LE+e+ck6o4xRTXVqNd/3vot5b\n", + "D7/XjzPPnUmokwXYPeoc7MTAlQEc6ooXTBv5GZJvu9jenkRusKz/7hE5C/l4EgSxeIh9GbdfBNb8\n", + "H0lrMVPC7V6c9FodtaULgg7vy2SprI+s8OpLrzUypZgwAViapGYUa6G8WxeAdLvUZhK9zYa0kHs1\n", + "Jhs3PBcWvq90VuJawzVFAeRwu9Hyv7rxYLQfNpMNE7PMQ1P8vIifo+2/2o6p2SmE58LY4dmByoJK\n", + "wTrm1T2v4onjT2BomqWxVpdWo8BagM5BluZaYC3Ag9kHggj2Fnpx4M0Dgo+mmP4H/dj4i42oLqvG\n", + "nQd3hOWdg50SP06H2SGkIu+r3IfWvlbJOKMzozh49mBCVLhlf4skEm2zsI64RbYi9E/0o+6tOgT3\n", + "BQ39DOnZNpXoN0EQhFEo1ZYgiMVDXJ/neA7ofJMtXw61mLlSW6qnBtKHBW3Q8zDXmIVDIZwPBLDn\n", + "8GHNNFuxGPhfTpZj7kYvrE4nfvkfy9Ezpe3HqTXmq3texaGuQxlPueSpnPmW/ATfUC7oaspqcOa5\n", + "M0mPK0+RlT8v4ufIYXFI6iXlvqKH9xzGS+0vIYoomn3N2Hp0K/om+1BkK8L5r57H9y99XzLfV/e8\n", + "isd+/pguT1CA2arcenBLaLzk9/px/JnjwvXgnpwAS6t1WpyC8F3nWoc1rrjPqf+UXzjvem897BY7\n", + "+if6he0b1jdgYmZC8WdISUDq+XmjhkMEQaQL1XgSBJHbiOvzGpdZLebq1UBfH1BUBFy9CnhFaarJ\n", + "muVkGn6N8wH0qhwz0w16NM7vYasxSzWaJBYDT/WW44X/ziJ2/8/feXC1ZBiAMZEQOBdAS0+LII6y\n", + "LTCUxIyRey9vEtTsa5bsIx6r8e1GIapYYCnAg7kHAJTrR4FYp9i7cSHXsr8lYb6v7HwFW45uQWQu\n", + "Iul+y9lctBmjkVFYTVZ4XV78/v7vMRIeURTVoXAIL7a/CBNMOOI7Isy31lMLh9mhKSpX/2y1IJSv\n", + "fvMqiu3FitfRyDUXP5eRaARtt9seyg+DCILIDFTjSSxLqC5hGSGuz9NRi5ktsvJMcaE5NgYckplZ\n", + "8vTXVjCRlk34Ne5NcsxU/ECToXF+y73GTP48adVSqtXriVNWv/u7xwGwFN2KzdXCciMpst2hbkF0\n", + "lthLDO2bivejUsptsnsvPwb39txauhWhcAiNbzeq1nIG9wXh9/pR761HsZ3VZybzveTeouLaUfl8\n", + "vYVePOF5QlF0AsDGko248xd38GjRo+gc7MRIeARVBVWKkVy3w40Tz5zA8WeOY9eJXegc6ITdbMdP\n", + "9v4ERXapz6mSj6r7U/b/WGQMh7oOqV5HI9dc/FwWWAsUvVuJ5Qu9lyIWAxKeBEHkBrwWc6lHOjlF\n", + "7M0kamsBeS1fsmY52WIhG/QsxvnlMFq1lGrCVCxA6v/5KNY3NODLp0/jF88kNqExMg+1hj7JSKUR\n", + "kZKAMnIMLph6x3s1j+12uHH8meM48cwJrCtaBwCYjc7i+5e+rzo3j8MjqR1Vmq9SYyKA1Yke8R2R\n", + "bFPrqcVH3/xI81wHJgcwNjuGmfkZfPnfvpxwXCWhqLce18g1F4/Z7GvW/DAolQ8fCIIgxFCqLUEs\n", + "dXKliQ0hJRRi9+bw4cR7YtQCJBP3eCFtR5aYxUm2EOlmbQAAIABJREFU0UovTaXmNZX03XRSnNOp\n", + "yw0ggG50wwknggjCrfJQqB3D6LH1bq9nu1A4hJfaX8KD2Qf46N5H2Fq6FU6rU5L2K76uTV1NmlYy\n", + "79x9B5FoROKFqoXeYxjB6PNAdaAEQSSDajwJ4mEgV5rY5DpLWaDTPRbIJR/MTJGKIFxoEaCnTlBN\n", + "BPngQ0ese1UDGtCi0r1K7RjJmhUZGUc+32w0V0p2X8Tr8ix5+P23fp+SL+diCcCHuSkYQRDaUI0n\n", + "sSyhugQZMXsGxZROIk53NxNvra1MhIrI+WdqOd9jg16uRn0wzwUCeN3nw1t1dQiHFiY90OjzlErN\n", + "a6asUPSip05QLQ3WGcu9rkUtDifJvVY7hpGU22TjyOd7qOtQwnbidNKDZw9mpK5Vad2df3/HkOgU\n", + "P1MLfe85RlOnidwm5//uEcsS8vEkiKVOMKie0vmwI45y2pgfnm7xZrTzbDYjqnrvsWwOgSZ37gd5\n", + "9fiMijDqg8mFKgCcDwSwfwGjxdn0RpR7Zy4kSj6TyURQEEEEEMBhHFZNs00WyebHuzZ6TfNYWuit\n", + "twWAckc5hsKsk7Auv1kkvy+ZumeLde+5oCcIgkgVSrUlCCKz5FJKqzhF1e9n4lOvQPfBmLdlLqTD\n", + "yubgG2xZ9ClpYtDKxYgPJgC8VVeHvtZWeGpr8eXTpxc0NTeXa+LSEcXi8+I+k+mKoNd9PuEDgvUN\n", + "DZIPCMTHqyqo0tXARw0j9bZuuxtt/Zm3GMnmBxIEQRCLhZ5UW4p4EgSRWXhKK8BE6GKqHXGK6pEj\n", + "xkSw0c6suZAOK5uDs1FlSgEAJwGEAewAcBRAExbOW1RMEIYaETncbkNRy33BoCGhyslELelipUTq\n", + "QRzZ0xvN48i7oaoJJyMCK1kkW3w8w42NzgVwsvckwnNh7PDswNEDR5OeqziaCCArkcV0rj1BEMRS\n", + "hiKexJKjvb0dPp9vsadBqFFXx+ooa2sXxZNTQrLOsiIUnymjnVl1HiuryOagOiUf4tFcgEV0B2Es\n", + "wrvMSRaB04I/T+l0kVUjU9GydBrF6D0vIxHfZJHsdK6jeA565pEJ+D3qGe+Bt8CLInsRyveVo9fR\n", + "CyeciLwVQVtfGzwODza6N6LIVqR5L+nvHpFp6JkiMg1FPAmCWHhyqeaUe4OmtC+Mia90jpUpZHNQ\n", + "nZLYmrAaTFzHoqPkvckwWkuqRDZq4lKNlsktTdKpE9R7XkoRX7VIcrJIdjrXUezDWV1avSCRZ/E9\n", + "6nvQBwAoP1+Oof2sXrR+Xz0azjeg/0E/Ou92AqDIJ0EQDwcU8SQIgnjYCAF4CUAUQDOYyF6i3pvZ\n", + "slcxWkuaCfScS6qRSr2WJplEKVKZTiQ51Tm81P4SoogmTQtOF3EkOhKNoO12G2xmGyLzERTbilH9\n", + "zWp0FHagFrU4jdNww032JARBLCvIx5MgiMyRS02DlhpGO+QSulloIZNN9JxLqmmndahDK1olwidb\n", + "JEsHXsxmT3pINZVZqeHSn8b+hK7hLgCAf70ftv02SWffbKRiEwRBLBbk40ksS8h7apFI4oO5JAkE\n", + "WBfYujq0v/FGWvtDyx+SW4a0gonQ5YxBX850yURKbDLEvo56vRyN/o7ix/jbfdcwmZ/8XJJ5VCbz\n", + "LA0iiAY0ZF10Asm9PfcFg1jf0JCTohPQ50uqhLzhUsv+FpTmlQrLjuw5gha0SK69Ef9W+rtHZBp6\n", + "pojFgIQnQRD6yIWurZlELKR/+MP09tcS4kY75C4gRvSzLhZYZGdbyKQqRFI5xgePDOP4X1WlfC7c\n", + "s7SvtRXnZc+kG+4E4ZMtknXz5bWciyk6AwjABx/qUIeQ7NORVDsRB/cF0bC+QZIyq7SMIAjiYYaE\n", + "J7HkoC5si0QwyMwgF7tTbaYQCWnfiRNp7a8pxINgnWJ1+FQuNBkPZC+wyM62kElFiBj9HSU+xq+b\n", + "Pkr5XLId/dVLrguubnSjAx1oRSsCsk9HUp17U1cTBicH0fh2oxAZNxLR1IL+7hGZhp4pYjGgGk+C\n", + "IB5O0rU/yaB9SiYa5KRagptx9xuNJkXZagaUjHSOuRB1eJk6hpGGSJmyZVmKZKPe1Yh1DEEQxHKE\n", + "ajyJZQnVJRC6SZZH6nazL78f7Tt3Gs8z5V4lGRBOqimSBvJgU41cZjyQzW1oVMZKlg6aLdI5ZipR\n", + "K6O/ozIVGTMS/V2IFOJcJRv1rqmm6OqF/u4RmYaeKWIxIOFJEMTyYNM5wH0ZKH8f6L3PlmmpMb7+\n", + "vfcWtWGSaoqkATWZagluBvWzLvSmg6bS1CfdYz5MZFso5TJ6612NPIO5nl5MEASRC1CqLUEQywP3\n", + "ZeB+Nfu+6h3g1ue180i11i+QhYxqiqSBPNgMZv5mFb3poJlMXVwMT85ch6w8tKH0WYIgCP2QjydB\n", + "EA8P5e8Dw08AzmvA9SrAW6ytxrTW+3ws4giwfFS3e2G9TJeKmswCdW/VobWvFbWeWooiEYsCPYME\n", + "QRD6oRpPYllCdQmEIhcfY5HOr/7fwMF6Fi0EkueRxvJM2y9fVl7P81c9HqC/Hzh2bGG9TBc6DzaH\n", + "WMqpi/Q7anmQS88gPVNEpqFnilgMUhaeJpOpwWQyXTOZTHMmk2l7JidFEMRDRKaMJL3FLL32zg1t\n", + "caj3mLzzzsaNQGcnMDrKli8XL9McJp2GO+cCAbzu8+GtujqEM2JOSjyMZNIOhSAIgkgj1dZkMm0C\n", + "MA/gRwD+92g0+qHKdpRqSxBEHHndpN8fT2etqABu3EgvwqenLlKeQtuiUbvFx6ypAdasAZqbtee4\n", + "QPWhRBxum3Lv6lXMxD4kWN/QgP1a93eRWAxrmUUnAKAbzO81iJzztSUIgiBSQ0+qrTXVwaPR6O/5\n", + "QQiCWMIstEDinVr5sXk6KwAMDLBl6QiFYFC7LtJoC1i1MZNdO/l55qj4WYqoCTZum8LJ9S624vme\n", + "DwQUBfKy89vsBsBvUQDMeocgCIJ4KKAaT2LJQXUJKqSaspqqAWSy4x88qD4XuegLBlmkU7wsHfTU\n", + "RQaDwLp1gMMBNDai/Y03Uhsz2bVL1d+E0ETNl5PbppRWV8Pr9+PLp08vShRR7+8oPTYvy85vk3/O\n", + "VAuAfix0Q3/3iExDzxSxGCSNeJpMptMAKhRW/Z/RaPSk3oO8+OKLWLt2LQDA7XajuroaPp8PQPzB\n", + "p9f0Wu/ry5cv59R8cuZ1dzfaY9ETXyzCpmv/qSn4AKC2Fu0vvAC0t6d2/JMn0T4wwF6XlQEjI2gH\n", + "AL8fvth27e3twHe+A5/LBRw+LDT18X3pS0BrK9rn54ELF+B77rnsX681a4TrhclJ4LnnjI83NcVe\n", + "x8Rle3s78MMfwjcxAdhsaH/kEWB6Gr7GRiAYjJ9vLjwvS/g1F2wDjz2GtS+8AI71O9/B+OQkDp44\n", + "AYfbveDz+4fnnsNEXx8sDgeimzbhnStXYHE48B9PnVKcj575Tl2fAkqZ3+YL8y+gPdWfz1x5/R3A\n", + "5/IBh4H2yzkwH3pNrx/S15fp7xG9TvP15cuXEYoFFz799FPoIW07FZPJdBZU40kQi48Bz0cJmbLs\n", + "KC2NN99ZsQIYHIzPpakpeTqvz2es5jITpHq9xChdO/G5eDzA8DD7fqHO6yEgV305X/f5hNRZR3k5\n", + "wkNDANKrMyW/TYIgCGIpsJB2KlToSRCLDe/AalREpWrZEQgAK1cywXngALBtG1teXQ289550Llrp\n", + "vIuRlprq9RLDr11TU/xa/O53bF1tLbsW/HtKt9WNVldah9uN/S0tOSU6AWnqbNnjjwvfp1NnSp1V\n", + "CYIgiOVCOl1tvwbgHwF4ANwHcCkajT6rsB1FPImM0i5KNSMWGHEznbExZjHC8fsBm005cqoVXcxU\n", + "1DVF0nqmeOOg+/fjy6qqgI8+iq9fpPNaqogjh7nclVYOj8TOv/AC9u7enZNRWWJpQn/3iExDzxSR\n", + "abLd1fY4gOOp7k8QxBJg0ybg5k0gGgWeegqYnY2LzQpR+XdNDXDkiLq40uo0yyOHegkEgJMngXAY\n", + "2LEDOHpUeVx511mtlF+dh5YM0d0tFZ01NcCZM/Gxl4hoyiUSmu4EkLYFx0JYl/BIbHt7u/D9YqN1\n", + "3g+lpQtBEASxKKRd46l5AIp4EsTSxe2WiiqbDYhEWArppk3Ab34DWK0stdbrTdxfrNLKy4He3tRF\n", + "X7Joq1r9pLx2dHBQu5ZUw14moRx1IhbNdbuBz38eeO21hYtuZkCQsXGk53yuqWlRxUhCDacPcQuO\n", + "BqRkwZHrUdRkAvBcIIDekycxFw7Ds2MHDhw9qvueaJ13rl8XgiAIYmmQ1YgnQRDLlE2bmJ+mzQaY\n", + "RWXgBQXAgwfs+7VrgTt3gHv32Otdu4AbN9TtRuRs3qy8vRrydFZ5tFVWQye8ib92DfsAOHiNZWMj\n", + "20Ct5lJ+HAX/zcRyVI1objbJlCeizHM0NDio6S+pRTqRNIfbDbvbjVN+P9vfFoQD7rQsOPRYlywm\n", + "Sp6e/Breu3oVM7HGXf1tbYbuidZ5q61fdv6hBEEQxKKTqeZCBLFg8JbORJYYGGDCa3iY+VxWVgKr\n", + "V7PIJhBPq+UKjO+TrGmQ0jGMeIaK01lLSoB33wXq61ldqTitNYbg8zg8jPMOB3DsGNtGpaGQ8EzJ\n", + "j6PwRj1hiFSbM2WCTHkiytR0JkSamtdmSvu7AizSeRopR3X3BYNY39CwIN6een5HyRsoKV1zfg24\n", + "6ASYR6mRe6J13mrrl51/6BKH/u4RmYaeKWIxoIgnQTwsJEshFa/jAtPpZALP65Xml65ZExdxmzcz\n", + "EcnDf/JjBIPAI48AMzNsX7MZmJ833uWVC6OSEvb1+OMsInvxoqLgE97EA9gTDgOHDsXFoVKk6Ic/\n", + "BP7rfwWuXYsf59IlxbGNlqNK0EjjNUwQLNJ5GMqCTG8qrqwGd18wmHZjnHTFq2T/I4dTTyOOsRg1\n", + "l8mivvIIp9I159egrKYGzpUrYbbZ4GtuNhw9TnbeauudVnbsWk8tDu/JvQgxQRAEsQSJRqNZ/WKH\n", + "IIglzssvR6N790ajzz4bjY6OLvz+mWDv3miUtQmKRhsapOsqKuLrDhyIRquqotFPP42vf/ZZtq62\n", + "Vjr/0VE21ugoO8fi4sRjfPppNFpZGY3W1bHv+fZKbNzIxvB4pMfnx3nhhWjUYokfo6pKcZjp0dHo\n", + "6YqK6LTSnJWOI742VVXZu0fJ7kFWjheN/zZegMOJmR4djZ5uaIhOp3gt090/F/j13r3RHwHRHwHR\n", + "07L7/eazz0Z/BER/WVureo4LfQ06Xn45+uu9e6NvPvtsdODup9GG0w3R0emle/0JgiCIhSOm+ZLq\n", + "QmouRBB6SOgoYzByku7+mSCZpUlpKcDT+errgRMnpPvqsTsRn2NJCeuGqxWZkUcA166Np7pWVQG3\n", + "bqkfw2IBenpYRFYpksjnnP9ToNchjfqJmyZVVQFbt8avzZYt6k2Q9EQsk22jZSuTaeoAtIKl4hpN\n", + "U00zOqsW7XuYuqi+VVeHvtZWeGprE1JZExoo5QDUaIggCIJIFT3NhajGk1hyLEpdQmJHmYXd3wiB\n", + "ABNodXVMfHFU6hsBMEsSgHWrLS5O3F9cx6g2fk9P/PstW/TN6+RJJiRbW4GXXmLpswC7XhcuJO4j\n", + "PkZBQfx73hyntTVeO8rn3OtgDXhawVJPgYTjtH/nO/Fr09ubOFay48hJtk2ye5ANgki9NlLPuSZB\n", + "rcYz3drPdJDXVWYL/jtKrX7yXCCAU34/ZiYmMjrPdM9PnN5syc9fkGtF6IPq8YhMQ88UsRhQjSdB\n", + "6EHLhzLb+2uhZjUi7sra1MTsRBobEyNYR4/GooP5wK9/HY8GirvP8mNcvRqPjm7YADzxBBvP6wX6\n", + "+tjyzk7gsceY0ObHOnmS1YMCwIsvsqhqOByfwzvvAG+/DXz5y8Du3axT7vAw8w7l5yI+xtgY2+7W\n", + "reTCXqkBz8WLwO7dOLd7N0IHD+L61BSePHWKiYOkY+n4ACHZNmkViKaAG6l3uk3zwxK1Gs/F7C6r\n", + "1Dk2E8ijuBy1+kmteYjX/3zDBpQ/8QTyy8sx3tsriRTLj5vu+YnrTE/5/Vm5VgRBEMTDC6XaEsRy\n", + "QJyCWlERb/gjjqzJ033d7sRUSvE2HL6t2GZETkMD8NvfxkWh1RoXjGVlTNDydQBw4ABLq5WP6fEw\n", + "ISv36eSpu1u3xsfJywN+/3smRg8eZJG5xx9nIlosqkNgkc5LTwBDn8SbEnm9yqmFydKKldbJU1L5\n", + "ssWwV8kketKrk6CWSprNFFOtNN5kqa/pYDRFVWsefL3V5cJsLCrq8HgQHh6WHEN+3JmJiYydX7au\n", + "FUEQBLE8oVRbglguqKW3csTRqXffVU7nFG+Tn89EnzyVkm/DO9vyaNfJk3GBaLFIj81tR7ze+DIu\n", + "OgFgZEQqOgHWPVZsXQKwjrfDw2w+4pRaiwVob2fnIj7GF78Yf93bCwwNAW1tiWmhPOo39EncJmb3\n", + "bnaaPPrmcmHP6Ci7tsnsUZTWyVNSNexVFirdMxm65pCmTQyP9skFi9ryTKCVxptfXg6zw4GRK1cQ\n", + "XLcObxw4IJx/OvdFLYrLx3xt9Wqc2L1bGFuvxckju3YJ43qqqxOOwY/r8Hgw0d+P+UgEXr8/I0JR\n", + "j/1MLjzLBEEQxNKBhCex5Hgo6xK06u3EtYNer7JgEG/T2yv1q8zPB1auZFHLFSuADz4A1q1jPp6N\n", + "jUw8cubm4t8XF8dtR3p79Z1Lfj5Lq+Uit6aGRUXn59lru52dAxe/c3PA/v1MdOfns2W1tcBrr8XH\n", + "FAvm06dZRFX+Rnh6Ov691wtwAVBeDtfEBBxKolUPBlNSF7PGMZfmkA200njHe3sxHw4jGokgEgqh\n", + "v61NOP+k1yQAwAfWrElBX8lFGv8dxcd80NeHwc5OYWwuvruamhSFG1+//+hRYVzx91wI8uMWb9yI\n", + "wc5O9Le1wWKzZUTU6/mAYLk+R7nIQ/l3j8gq9EwRiwEJT4JYCmiJGz3RKfE2fDy7HZicBP7lX1h6\n", + "bijE6kD/6q+YX2dnJxO78nR5sxlwudjy2lomOsXRSCXsdpYGvHIlS4k9c4bNpayMiU++jcMBdHXF\n", + "o6ZmM4tmtrYykVtRARw7Jj3XYJCl6c7OsnNQEpGxiBEAdl5cANTWwp7s2mphsGHQYtY4pjqHpRLZ\n", + "0orS8fPm2AoLsfOVVyTrFK9JNxIbVIlQE2l8TFtxseLYWsJNPK7SMRxuN+xuN0LXrwNgfp/yuWfz\n", + "3uXCs0wQBEEsHajGkyAyRZr2E0nHtNlYF9fmZmlt4cmTrEHPjh3x2kaleciXfe97wC9+wYSaOILJ\n", + "sdlYNHN4mAm6SESaFnvlCvCFL0iXlZTEmw6p0dDAmgpFItLlK1YATz7Jjieu7RRjscTnqmRJw61K\n", + "ACYyz55VtjKRr1erZczG/URu2GgYncNSsNlIVt/J11lsNpjtdtz97W8xE3tW8yoq8Gc3bgCA+jVJ\n", + "0ZaGX+edr7yCrkOHEsbORB2l+N546+vxjMgK6VwggJ6WFkRiP6da986o1U0uPMsEQRBEbqCnxpOE\n", + "J0Fkimx4dSYbU94IaN06FqUUd53l+8jHOX8+3mE2GZWVbFwuBk0m4PJlYNs21txH3JVWiVWrWAQ1\n", + "EmFRzTNngPJyaQ0op6EBmJhg4pA3JyoqYo2GLBb2/eiougdmKMQsWaJRJtB37WLnyJsJFRdL12u9\n", + "Uc4F79UcIZcbzXCxdO/qVUFMygWWWhMejqaY5g2qDsO4LU0SMiHckt0b8XnDYkHl00/jwNGjqsda\n", + "Ch8wEARBELkJNRciliU5W5eQDa9OPdYeABN1lZVMKHHR6fEA/f0s0sd9K/k4WoKR87nPMcHHx/v8\n", + "54H//J+ZyBOnrirhcrHj8OjmypVM7D31FHv9mc+wSKd4XsEgE7o7drCU2vPnmVCdm2PnVVWlntLq\n", + "dgPHj7OIqtvNRKe4mZB8PSA0bWrfuTOxJnQhvVdzHD2NZhYLnq7KRadS2qfcnzIyNgaT3a66fQK8\n", + "QZXo1M8FAvjpypVoLi3Fm6ImRYD+31GZaLSU7N5IUovn5iQ1rUrkYursUknzzjY5+3ePWLLQM0Us\n", + "BiQ8CSJTGKz1S3vMYBCorwf8fhZJ5AKxpoYt37gxXqPpcknH2bFD/ZguV3wcHnHMz2ciko+3eTNQ\n", + "WJh87hMT0qZEnBMn2FwuXAA+/pgJzT/9CVi/nonRkRFW4zkwwIRvzEICRUVsH73Xlottp5PtpwRv\n", + "2vTee4k1odm4n6mi1dU4y8d0AFnrRJsuXCyVVlerdnQVi7Px3l7c7exEdGYGBVVVKYvpUHc3pgYG\n", + "MDM6itttbfjl9u2CQJqJWaAsBGLxKhdp+4JBOMrLhW3tJSVJBWUufsBADYwIgiCWD5RqSxALQZbq\n", + "BYVxe3pYWuuVK6xxT2kpizS2tbGI3ZYtrAGQ08kiiP/2b6xhj/xnc/VqlhobDrOmPkC826wSNhtb\n", + "z2svS0uBe/fY99XVzHtzbIy9NplYumttLYvO8vnIPTs54ppOjpGU195eFum8cIE1PlK6B7zuUy19\n", + "N1dYjLTfJZJqLE9XPRcIoPfkScyFw/Ds2JGQWpqptGE+DsCa+licTgzGnuNkaao8NXispweFXi9s\n", + "RUXYFwyiq6nJUH2lEkqpsnye9pISfOPSJRRqNQHLMXI5zZsgCIKIQzWeBJErZPpNPBdR4npOJXh9\n", + "43e/Gz++xxOPIsrhtZVGsNuBmRkm2jZuZOI3P599TUzEhaeY8nImfAGWUiuvNzWZWPMicQ1raSmL\n", + "tBYVGRPvSteK3wO1xkK5xmII5KUiymVI6hqRKAL11lUqNdoRL9vz6qt453vfA0wm+I4cwduNjboE\n", + "knx+fI6Tg4OK9ZVGGv6IRVrJli0Y7+2FxWaDtaAAvubmJSnatO6X0YZIBEEQRHYg4UksS9rb2+Hz\n", + "+RZ7GsaimJl+Ey9vLKQUHeRUVbH/+/qYaKupie9rVGh+5jMsPVa8j9vN0m7v31cWmXK2bWPCt7+f\n", + "RUDPnQP+5m+AN99kUVqLBfjwQ9Yo6cUX2TKbTdrx1oh4l18rhXvQ/txz8E1MZD4inSkWQyAvsihP\n", + "VVCII5Gl1dX4ytmzhsRIsmZFyZrvcIFkyc/HO1euoKayUlGwRiMR3G5rg62oCJGxMUGoqglXpWOq\n", + "XRuxSDvl9z8UjYIeloZIOfN3j1g20DNFZBo9wtO6UJMhiGUHrw8E2Bv0ZG94gkFjb+LVRC1ffu0a\n", + "e22N/Qi7XEwoOJ1MqPGGPvn5LNV00yb2emyMRSi9XuDWLePRzU8+SdwnFFKuOzSZElN5AVbTWVjI\n", + "hOf9+8AzzwA3brDvt2wBtm5lDYzKy+Pn1NwMNDay/fU0+xFfP17rWV0NrF0LHDmSeA/6+liklu+b\n", + "7TevRlOvuQfrQqJxzGxHmnhtH8BsTvQKin3BINpj3YvVonzJ5i4+LgDYioo0vT7F6b2IRnEvFELf\n", + "lSv45fbtcK1ZIxGx3vp6rG9okFisdDU1ITI2hvyKChw4dkwiVkdjP+viY6pdG17vmWyuelhKUcRc\n", + "bIhEEARBqBCNRrP6xQ5BEMuQZ5+NRoFotLY2Gh0dTVz/8svR6N69bDul9cnYu5eNDUSjDQ3xsUpK\n", + "4svlX3Z7/PuKimi0sjIa/fRTNp7JFF9nNkejFov6OJn4qqqKRgsLE5d7PNHoU09Fow6HdHlDQ+J5\n", + "l5dL14+Oxv/Xus7icerrlfczci8zjfz+LkF+vXdv9EdA9EdA9HQWzuHNZ5+N/giI/rK2Njpt8J50\n", + "vPxy9F8qKqJHSkqiJ/fvT9g/2dz5cX9kNidsMz06Gj3d0JB0PP71E5cr+k/FxZJlaueiNB/xsp9V\n", + "VUn203Nt1Oaqh2zf20ySznkSBEEQmSOm+ZLqQop4EkSqaEUx5RFRt1t/lKunh/1vsbBmP/39yg14\n", + "OG43iwTyZkI8lXTTJlY/KY48JmsWlAm4X+eGDcD4OFu2cyezU/ntbxPPw2pl5+nzxSO5tbVs/vx8\n", + "+DUWR72Uajd5tFJshaLHs9NoRDpdloFVS7YjTfuCwZRrMXnHWQCChYg4Ypps7vuCQfx8wwaEY3XQ\n", + "JosF06OjCIdCQkRRfswx/vPKMZsxK+psW1ZTA9eaNaoRWKX5iJd9+fRpSfOhPa++KkRL1a6NOPpp\n", + "lGSR3VQjofJ9M9FMCUjvPAmCIIgFRkuZpvsFingSGebs2bOLOwG9kUweReNRPnG0ct06NkZVFVsn\n", + "H+upp5SjmTU1iVFEkyka3bEjGt2/n0X3xOPYbOlFLs1m9XVWq/Jyj4fN4dNPpVHYhgb1iK04ullV\n", + "xfZXi3ByxFFDebRydJRdY6Vrq0DCM5VOtFoPWue2BMiFSFPHyy9Looo8OidELYHo0erqhDlqzV3Y\n", + "32JRjPyJI4L/XFER/dXOncLr/89uj/5vJpPw+qeVlZrXSGk+8mXZikJ2vPxy9Nd790bffPZZ4Vh6\n", + "IrtKc1AaS23fpRRVzQUW/e8eseygZ4rINNAR8SQfT4IwCo9ktrYmej+K4T6Q3E+TR+W4nUhHB6st\n", + "5N6Y4rG4JydnZoY1CTpzJl7XyYlGgQ8+YNHBq1eZr+fq1cxKhNd6pkqy6KhafejwMIt2fvvbrDMt\n", + "EI/sKfmHFhay2k6+3Ucfsagj//L7lf0redSwupptI24Y1NTEbF2Urq0WPGqq5x6nCo/eLnLtnNz3\n", + "0Qhi/8jFItTdjcj9+wCkHpX7gkF4/X546+sTmgudCwRwyu9P6rXJ/SxXPf00gMTI37gowjk9MICJ\n", + "3l5hDmU1NZIMg+INGzTPw+F2w+5245TfL9wL+fXNVoRZySdT7d5qzSGZ56Z8X6rNJAiCeAjRUqbp\n", + "foEinsRyQ289II+aiaOGxcUsMrl/P3vNay1raqLRF16IR9k+/ZRFL/Py4tvt3cu2KS6W7iv+2rEj\n", + "vQhnJr7E8yovj0b9/vh1euGFaLSsLDFa6vcrRwArKuLb1NdL1yWLGoqjoSUlxiKL6ey7hFCLFi4l\n", + "eGTySElJdIzXM2sgjrQ1ezyK0TmOOPInjuZCKrKxAAAgAElEQVSJI5z82Hw7cbRVHBXVinpqRQCz\n", + "FWE2UkurN1KsNJZ831yImBMEQRCZAzoinmSnQhBG0WszIbfxEOP3s26z3E+zvp6NK/f6fOQRVuPJ\n", + "sdniUUwlKxTuqcntVZLZrKSLy8W65g4Nsbns3s3sUTo6pNFJsfWJ0jXZto1FLXt7E+tfS0vjkWK/\n", + "Hzh+XN/cuH1NSQlw6RLr4quXdPZdQohtKOwlJXj+5s2Uo5eZ6IJqdIxzgQBGr1/HWE8P/O++i0KN\n", + "+yTuEhseHobV5RLqMPMrKvCtGzeSHlN8vfIrKjA1MAB7SQmqnnkGk3fuwOp0Ir+8HPd7ejD0/vuI\n", + "zsxI9tey+hB7cCbzAc0Ecj9SrXrRhRqLIAiCWLrosVOhVFtiydHe3r64E9CbJslTQS0W6fKaGmbp\n", + "8cQT7DVvgCNuOJOfz0TavXvSfbnoNJmUU13n59k6LjazJTpNJpY2+/77TFgODbH02lAIMIt+rRQU\n", + "MOHIhai8CQvA7FV6e5VTW/Pz2f+FhcDf/33ivoEAu07yVFye5nzzpi7hKDxTgQCznKmoWNaiE4in\n", + "PtpLSvCNS5fSEgrJUiy14Om+N48dSxgjWSpwqLsbdzs7MTUwgK5Dh3TPMTw8jIKqKjyya5ewbmpg\n", + "QHPe/HpZXS64N26Et74ez9+8ick7d4R5/+Ff/xWDnZ34/cwMnJWVMDscAKSWLGrw9F7eSCjVFGgl\n", + "5NdRfL9+vmEDpvmHOykgHqvr0KFFT79eriz63z1i2UHPFLEYkPAkiGzBxc+HH7JIJGfNGiZa+Xpe\n", + "myh+zYWYWh2lWhbB7Kz6OjW4f6URolE2v8ceA155Jd6xt6ODiWWnkwnuBw9Y7WkgEBd1YqxW4B/+\n", + "Qb3LKxfO4+PA976XOA+1etvYhwPnjL6B7+5mdaEDA4AOMbOU4ULn+Zs3NaOFWqRTr8eFC/e5FI/R\n", + "e/KkIGraX3oprWOKt//mRx9h/9GjyK+oUBxDSfDuCwbh8HgwOzGBOx0dGHjnHbzd2Agz94kFEI19\n", + "MFT82GNouHYN5bW1AIDI2JimOBbXVeoR8mqiXGm5fDx+LficeeffVKBaTYIgCEIvJDyJJYfP51vs\n", + "KeiDR0a3bQP27WPLeHRTvJ5HB8Sv+RvDmhqWbqqF1crScI1gsQD/7t8BzzxjbD8xMzMsxTYQYFYp\n", + "AItObt0aF40lJSxy2dKSKDxnZ5nAk4tw8fgck0L2hoYtid5InPBMLQObE72k2hxITZTxaJ3R8bhw\n", + "Ka2uhtfvl4wxFw7HN5R9oKJ1TPk85ds73G5868YNxTHUGu5Y8/KEbcJDQ+hrbYXN5YJJ9LPnrKzE\n", + "f+rqgsPtxnis6ZCtqAiwWJJ+CMLn+7PVqzES+zCotLpaVcypPdtKy+XicF8wKIhureMoXUsx6dx7\n", + "Qj9L5u8esWSgZ4pYDEh4EsRCoCasxIjTRouLgfJyoKwM2L6drd+4Mb5tYaF03y99KS6a9GC1srTX\n", + "O3dYdM8oXAQ6nUzw/tM/xUXi+DiL2ALxOsneXiDWfVQ4PpDo0Sm/NrwLLk9PlqNxXQ1HY/Tcp4cc\n", + "I11QAe3OuVy4fOXsWTxz/LhkDE/s/pdWV8NeXCwZR0s4y+fZ1dSEycFBvN3YKMzDSPfWc4EAwvIP\n", + "TiwWRCYmUPH5zwNgfp0N164J4/FIcmRsDLfb2pJ+CMLnO9nXh0hsfoVr10rm9otNm3DE7cY/l5eD\n", + "fwwjf7aV5q4mutU6/2pdSzG50N2YIAiCWBpQcyFiydHe3r60P6kLBFhKp7yRzsqVcRFYVgaMjLDv\n", + "6+uZTUplJYscfvIJS2HljYkA1njnvfeA/n59c9i5k0VSOzqAyUlj83e7gS9+EXjjDeDJJ5mwFL8h\n", + "t1qZcB4bAz7/eeDECaCxkaXDihsiVVXFrVPU0NvISYVwKITzgYBms5OMPFNq93UByUSTHy2MNsER\n", + "N+XRarAjR3z/Tvn9muOIz38+lkLK56lnf6Xj8vMTn4ccl9eLyIMHsNjtcK1bh99HIti5aRN6T57E\n", + "zOgoSqurke/x4LZoPvLrxq+rragIkbExxe2OuN2CfYyzshIVTz2FPYcPo6upKasNfhay8RGhzJL/\n", + "u0fkHPRMEZlGT3Mha7KVBEGkiZIY4XWJAItmrlnD1k9Px/fjzT6sVuBv/xb47nfj+4g72wIsZfbU\n", + "KUCclqhFV1d8fD3w7rglJezr+PF4nac8xXd2Ni6aOzqAF19k5x4IsPNqa2ORTj1RRR4JTREejVkQ\n", + "xPeVe4EuMDwyBQDnA4G0z11JyO4LBnWJeY44AmfJz8frPp9uYSy+f3qi1+Lz9/r9WN/QIMxTvr/8\n", + "3MTibV8wmHDtrCoZBVaXCzP372MmFqWc7O/HEIBP3ntP2KZw7Vr4jhwRrpv8WOLruvOVVwTh2NXU\n", + "hN6TJzEXDqN8xw6YYo3KLE4n6t95R4iois/7V088IdSWZgqj95wgCIIglKCIJ0Gkgt7oltg+pKGB\n", + "bXfsGBNgSnYoAEujjUYBbnBvtwNFRdIIZyawWlkHWpntAwAgL48dl0cyy8pYLWdzM7B2rTRt9sAB\n", + "do5K4wCsM+zatSy1d9Uqlnb77rvGO8bmQEQxKdyGRa+ozgKZjkylE63kGI1aJhvnl9u3w1lZCXtR\n", + "kaJwVTp/LjDvf/IJ5sNhWBwOFK5bh9Hr14WGRo7yckRnZ4XXJquV+Y2Zzfj6xYso27YN4VAIv9i8\n", + "GdOxrAT3Zz+LqTt3EOYfsqhhsaDy6adRUFmJ8d5eWJ1ODH/wAaZjNkkurxeutWsFOxa+zb5gUHK9\n", + "AGB1XR3uXb2Kr164IGkIxc9bbBGT6v0iCIIgiFTQE/Ek4UkQRuHRLC6+xD6VcrgY8XhY1HB4WJ/F\n", + "icnExCf/P1uYzcyCRUxBAUuhjUSknpvl5Uz4bdgQF8EWC/PztFji1i9btjB7laGh+DqxUAWSXzM1\n", + "5CI+195Up5kWrIaR9NlwKIRfxcSZTUWcGUGPkFWbn9Jy8XglW7ZIRJaeeWoJYaUU2Z84nZibmlId\n", + "UyzWABYRHf7wQ+HnwpKXhw1/8RcIdXfDbLPBYrfDbLPB19yMtxsb0dfaitLqajy4dStBhJosFkRj\n", + "P++O8nKEh4bYcptN6IDrKCsT9hNv4ygvR2RsDPOxTIbSbdvwlY4OxevEz3t6dFSSXkzRSYIgCGKh\n", + "IB9PYlmyKN5TgQCrwSwtlYpOi0XqUynfh3tCPvoocPductHpcsW/56JzxYr4cZKxebOx8+FjykWn\n", + "2Ry3QCkokK4bGmLndPEiqze129n53L/PRGdFBas17exkArW8nEVt+bUqLmb/p9oxNosdZzPyTOn1\n", + "dzWIWmMXpaY9DrcbBWvW4G5np2YnX62mP4C+jqVGuquKxxvv7ZWs1zMftXRbvu/bjY0J6aBzski8\n", + "ragIAJjHpsWC2ViKO++qW7Jli+TnwrNjB+5dv46Bjg70t7XBVlCAZ06cENJjC9etg62gQNJ1+Q9O\n", + "J1bX1WHl008L8y17/HHh+0dizYhKq6vhqalJ2MbqciE8NCSITgAoXLdOiOAq3ff9LS0oiHmH3v/D\n", + "H3C6oUFYr+fayklln6XCUjw38lwkMg09U8RiQMKTIPTQ3c0a/4yOSkXn3Fzcp1JpH+4JKar3SsBu\n", + "Z+mqzz0nXR6NxlNxuWC125VF6I0bxs7HYmHpu0C8ztPlkgrRU6ek+xQVMcHn9QK3bycK0127WO2n\n", + "282+HA62vLCQRX6vXEmvY+xD2nFWTWypCT69nXz1WM3o6Viqdryxnh4ATOjtfOWVhPHk++mZj5oQ\n", + "1uq6CgDmvDysrqvDN69exfqGBiY85+aA2VlY8vKErrrcAoVzt7MTY598IpkrFy7Htm7F1MgI7nZ2\n", + "Ijw8DJPdjrwVK+D7yU9QsGoVZqemkFdRgQPHjuHA0aMoXLcOD27dwr0rV5C3YgXcmzYhIttmfUMD\n", + "VuzaJZmDvaQEvuZmnAsE8HFzs6q36XhvL+bDYURCIfS3taFl82aEQyHdtkJiUtlnqbCcz40gCCKX\n", + "IeFJLDkWpQubuLHI1q2s02wsmpEQgeO2KNeuxZclS5edmWEi7s4d6fKaGvYlJhLRl6qrhLgJ0Nxc\n", + "vIGRy8UaBonSDYVtOEVFTDz6/ez/UChudQIwr1K53QmvQRsfZ+fn9TLBuHkzixwfOBBPT+U2Msmi\n", + "D1mKKAK57WemJrbUBJ9eX0XDVjMa8yvZsgUtmzejubQUbxw4gIJVqwAwK5GuQ4c0z0vPfMTCVRy1\n", + "ssSebaV9v/7BByioqsKf/f73ePbNN1Ho9WJ/SwssdjsAlg5b+vjjgs2KUhOhsscfl8yVC5cHfX2Y\n", + "FXV0js7MYHpwEJaf/xyh7m4MdnZiemAAXYcOCdHoqbt3MRMKYXpwELfffluyDbd8MQFwxLIdzHY7\n", + "ih97DG83NmL0+nUhRZcdUPp7RT73qYEBnA8EUrrXmXo+cpGleG65/DuKWJrQM0UsBlTjSRB6CIWA\n", + "l15ib/Sam5n4UavpE9cickwmZi3yySdArKmIhKoqZoUijjiaTCwyqdSAKBWS1Ys6HKwrrrzhkdnM\n", + "ROLFiyyiye1e/H4mNF98kY175EiiIFRqtiO/NuXl7HhcBOdi7WaOotcqJp39jdSXyu1G8isqMDUw\n", + "oLvekM/Hkp+vWvspns/M2BgGOzsBAN76eljs9qT7yml7/nl8+qtfwZKfL1iU8C645wMB/OnUKUFU\n", + "euvrkb9iBULd3Rjv6cHM+LiwjxJevx/DFy/iQV8fYLFg5e7d+NKJE0JNKMDSaedmZhCdmYGtuBjf\n", + "vHIFZw8elHTlvd3WJqk/zVuxQmhK5P7sZ1F//rzkHMOhENpfegl333kH04ODcHg8KN64Edb8fNhc\n", + "LviOHNH9rKT7fOUyy/ncCIIgFgtqLkQsS3Lee4oLLpcrMYro97N1cusTLvz0UlwMrF4N/O536c/X\n", + "bGbNhPr6WK3m+HjiNuvWAX/8Y/y11cpE5NGj6hFIJWHOrw3AoqAPHsS3V+sGuwDdbHP+mVokjHS1\n", + "5Y2DAFa7+MyJEyn5SSY7pnhdXkUFpmXCVu98zwUC6GlpkYhHuUB+48AB9Le1wVJQAEdxMaYGBxHV\n", + "8SFQ6bZtKPrBDzD5d38nCGM+nz2HD6P9xRcxcOFCQiOi9Q0NmJmYkDRzCq5dK5nj6ro6mO12IBqF\n", + "r7k5QZT3njyJ8L17sOTnwxzr3jscs06iLrdLG/odRWQaeqaITEM+ngRhlEyIHLlnJaekhKWsyhv6\n", + "FBayqKER4enzAR98YHxuQLyTLY+Azs+zWtSyMmXRWVLCmgmJhefsLDu3DRuAJ55QvlZKHpzBYDxy\n", + "zJsYVVczuxWlqCmQE/6YDytGUhL3BYOs5lAkivQKHXEk05wkbVY8nwPHjqHr0CFY8vNxyu9nkcjY\n", + "Bz1WlwufvvEGjhQXw2y34+sXL+LSD34giZZyQWcrLkbl008L0UA+F4vNBntpKWbu3cOk+AOSGLai\n", + "IkTGxmCy2WArKGAdb/PyMDkwgIvPP49NsVReACirqREE+DMnTkhEOgDAYkF4dBRf+PGPcfLpp2F2\n", + "OPB2YyPMIp9dW3Exwvfvw15UhPzycpzy+yWR3d6TJzEVy0iYjzVUMpnNqteSIAiCIBYaingShBgt\n", + "yw49wpRvY7MBV6+y1NqSEuDSJVbfqGTtoGRrokZNDXDmDGtGJIqoaKJlzbJiBZurON3W7QYuXwa+\n", + "/e14pJIjjlimkiKr134kB/wxH1YynY6rtq0kkrliBR558smEiB4AnD14EH9qbUXZ44/jwNGjCVFO\n", + "NQqqqjA9MiLYqpgdDsyHwzBZrfj6Bx+gbNs2YdufrlwpCDie2spFJsAEoMlqRelnPwtHSQmmh4Zw\n", + "N/ZzaLJaJVFRS34+rE4nympqhPny69qyeTOmBgYklivrGxowOTgonI/JaoXJbMbKvXsRmZwUIqgO\n", + "jwfhmKURj2Q2l5YKPqQAizq7N23C7bY2eKqrsV90fIIgCILINGSnQhBG0bLs4NG31lblTrYAcPIk\n", + "26atjY2zbh3ztvz2t1kjoXT53e9YZ13elZajZbnCRSfvNiumpoZ13m1oAP7wB9Y8ye9nUU6vl4ls\n", + "bu1iszEhnZfHXqdqb6K3WZBWN1u9zYkIw+jpamukQ6hWJ14ArDmP3a54zL7f/AbhoSH0t7Wh/cUX\n", + "AQDjse65ptjzb5P/XAB40Ncn8fLkNiXR2Vlc/Ou/lmwb5n60iDcVWl1XB0dZGfJWrEDxpk2YGRnB\n", + "QEcHbre14e4777CNzWaJ6LQVFqJ02zaER0bQ39YmOV+H241v3biB9Q0NEsuVPYcPS65FdHYW8zMz\n", + "cLjdsMfOy1NbC091tWQfACiPNfsy2Wywud3I93iYt+jwMG7Ljp8NlqJFCUEQBLGwkPAklhwZ8Z5S\n", + "Eyvl5eyLv+mVb6fHS1KcMtvWBty6xSKTra0sssnhvp1ud/JIpJxIBHjsMfZ/XR378npZ859kIq6m\n", + "hglKufCsq2Odeg8eZDWpxcXAiRNxaxQ+x48/ZgLwc59jacQjI6wpUrajkFoCVc+HARqQn1nqGEnH\n", + "TdaJ15KfD4BFFGGx4KcrV6K5tBQ/W7UKJ3bvxlt1dYLnJgDBN7Mg1j05OjeHgqoqwS7FKvbFTcLA\n", + "hQv42erV+PXu3Xht9WohTRUAzDYb9re0YPLOHYRHRjA9OIiJmN2Kp7YWc+Fw/GdXlLHwMYDI+Dju\n", + "XbkiLLv1m9/gzQMHEA6F8ItNm/AvK1bgj8ePY25qCt76eqG+dF8wiLyKivg1KyhAeHQUe159Veis\n", + "uz9muyKuSXVWVsJRXg6r04lIKITbbW2CpY3V5UJ4dFRTEKYjHsmiJLvQ7ygi09AzRSwGJDyJhxM1\n", + "sdLbCwwNxb055dvp8ZLkNiMFBSzCyaMgJSWsO2xVFbBzZ7zx0NSUMeFpNrNx29rYMVatYqK4s5P9\n", + "z43sucjlgvPMGSYoRbVnOH8eePNNdt5a4o0LQB5Rqq0FPvoo+6mvWhFNPR8GEFlDr31Lsm0dbjfK\n", + "tm8HAETu38fttjZMDQxgZnQUk/39GOzsRF9rq2CBUlZTA3tREV73+TD4298K40zevYtjjz+O6dFR\n", + "WJQi+3LMZoRHRjDZ14e7nZ2sC62IW7/5DX62apUkqln86KOCUNT6uXV/5jPC9/y82l98EZMDA4hG\n", + "IojOzuJuZ6ckwutwu7H6S1+CKXausw8e4HZbG7oOHYLd7cYpvx9vNzYK6c9cLPaePInw0JBQu2p1\n", + "ueDeuBGOsjLMTkzoinqmIx6XokUJQRAEsbBQjSfxcKJWNyhf3thovL6Q1y52djKLFIClwX74IfO7\n", + "lB/nD38wliJaUsIijnxOmzfHbU4A4K232PHffBP4/vcTayh7e4Hdu4ELF4Af/ICJ62vXgOFhfZ1l\n", + "X30VOHRIuzbTKGr1s1p1t3prRYkFwUjNpxjecMdTWwuH243b4sZcgGA5wjvl8hpJNRxlZZidnITZ\n", + "bsfc1JQkkmkpLMScqJGWvDZTC0teHsp27EDo+nVWV2mxKPrrmmw2qe8mgILVqzF5545wPJPVCmtB\n", + "AeYjEZisVljsdhQ9+iiGYt1oAcBeUoLnb97EKb8/oWuvvMbV5nLBZLMJ9Z6Ttgo4IwMoqanFV88k\n", + "/3BAfA/0fJAghixKCIIgHm7IToUg1FASK4EAcP060NMDvPsuE2Xi17GUPmFbuUjiy3p62La8FpPj\n", + "9bLurVy8Pf00a85z7x6Liqq8eVWkspKJRbebpc6Ka0erqlh6rx7Eoq6qSj2CqSX+MoHaMai5kCp6\n", + "RF6qQjDVfY1YsIgRCxcAaH/pJfS+8YaQMbC6rg7PvvmmsL28mY4SjrKyuG2JqGkW9xi1FBRgTqFj\n", + "rRgtUWp1OmEpKEB4aEjzHIF4Y6PkB403AjPZbPBs3w5HaSnmIxH0t7UJwrCrqQk3jx1LuA7cambE\n", + "VYsfThzDN3AIE/WHETyhz0uVxCNBEARhFGouRCxLMlKXoFQ32N3NopQDAyyiJ38tRilVly/r62P7\n", + "yQ3mx8fj+xw6BKxZw7rI8je1zzyj3PhHic99Lj73WG2cgOjNuSbiNNVkabPZSmcVp9HGbDQSjqEn\n", + "vTlNlmqti57UyHTSJ1PZVy3lUqt+UNzIyOF245njx7Eq5jFXVlODL772mmR7TyylvWjzZpjz82Er\n", + "KYGJP0MxTOKGW7GfM09tLfzvvov1DQ2oePJJzfOp2L0bXr9f+VwLC1GydWuC6PwYTLACLOXVHEub\n", + "NVmtmJdFQBWJRuGsrIS1oADRSARDXV1CqvH6hgaUbNmCU36/ougsq6nB12Ln9+6u07gHLy7VtuD/\n", + "bU7ebfh1nw9vNzYK9jTUJCi3WKq/o4jchZ4pYjEgH09i+WLUk1Murhobpa/FY167xl57PCyddvXq\n", + "eM2mEtXVbFve6VY8Pl//2mvA+vXafp5mM0u1fewxJlwnJ6Xr//qvWS2nEvJrwj1HtdJU9W5nBO7J\n", + "yQV6fT0TmPJjKPmBLkNSiS7qqatLp/YulX33BYOKUTMuYgHgfCCgGAnl12CspweFXi+s+fnw1tcr\n", + "WqscOHoUv9q+HfmlpZjo6UGEC7BYtNBRVobCdesQDoUQnZlBWU0NXGvWwNfcjK6mJtw5fx6zU1OK\n", + "6bBiBi5cQP6KFYp2RLPj47h39ariftHZWZjtdsyKfi8ki5yu9Plw97e/xXw4LEQ0g2vXSra529UF\n", + "a34+ImNjgr0LwDrorti1C9aCAsGP1O5242C/HzsrnPifjwXhFnmUyp8x8b0RW7Wo3SeCIAiCSAWK\n", + "eBJLDl8sCqIJtzVpbQVi1gtJkUfWlCJtPKo5PMxSUzduZNHNvj7lOk2Xi0Xztm1jTYQqKoBjx+Lj\n", + "+/1McJ09y5bxxkQAi2TyRkDV1ay2E2DdMzs6WG3o/fusu60YU5IsB3mkVq+lid7tdHIuEMDrLS14\n", + "6/59hAF2bs3NGT2GEczB4KJbQaQSXdTT2MdI8x+1fXmETc/14aJHvr0eEcuvAW/2c7utTdVaxeF2\n", + "o2DNGtzt7JTUbyIaRUFVFdybNmGoqwvRmRlYnU5YnU7MxbYLdXdjamAAkfv3EY1EYLLZhAilnOjs\n", + "LCb7+1UbCc2Ju+Da7XCUl2MjWKSTd9a1FRezDVQsjyxOJ8xWK/7s44+Fe9XV1CQRl6b8fMzEGiEJ\n", + "y2PjRcbHhSixWEwOd3bAM9CKq4cCkuurZmejZtVCLD66/+4RhE7omSIWAxKexPJFHDlMJsY4bjf7\n", + "8vuZWOTL+Gu5ncpHH8U7vPL/a2rYtqWl7PXEBOs829ubmLbrdjPLkhUr4sf48Y/Z93Y7E6ozM6ye\n", + "8+xZZpciPh/xG+Gysvjxi4rUu8DmSAfYUHc3Bu7fRx+A8zYbcOnSotZu5oIVRCrRRT0+m3q20dp3\n", + "vLfX0PVRup77gkEUrlsHi8OBtxsbFQUsvwbci9Ph8aC/owPNpaV4I2ZFwjkXCMQ72ooEXWl1Nb75\n", + "0UfCGJ7aWpTV1OBurDPuzyorMXL5srC9yWoVOsymhKgue35mBiaTSegkO3PvHqxOJ9ybNiG/ogJ5\n", + "/OdUPsTkJG63teGd//AfsL+lBV1NTehpaZH8jDsKCyXXxl5SgpW7d7Pr5nJhWmaXovQ8cXsVW1ER\n", + "dr7yirCt+MMJJasWgiAIgsgEJDyJJYfuugRe+1hYCPz93+vbRx4R1LJT4a+vXmX/nznDaiy5wCsu\n", + "Bl55Jf7a5WJpsuI33eJjHDrExGhBQXw9r+cMBuMNjsSi0+Vix+XHF1ujbN8uFaELUC+pB+FNcUkJ\n", + "9nzyibRxUwYw6kd4fWqKzWcRozzpRCazjVFRrLS9OEKpJmD5NeBenCazGdODg5gZHUW/zA4k1N0d\n", + "j3TOzcFst2N1XR2+cvas4IfpWrcOZocDoY8/Fvabm5oSLEdgMglzNYJadBQApgcHcZU3NAIwGw5j\n", + "qKsLUwMDmB4cTD5G7Oc61N0dnyOYsCzZvBkurxfuzZuRX1GBb1y6hC+dOAFHeTlmJyYSro/S81QY\n", + "+zmLjI2hS1S3Lq+vTfWDCiJ7UD0ekWnomSIWAxKexPJl3Tr2//h4YnMgNd5/n/1vtQL/5b9II4T/\n", + "f3v3HhzVeeZ5/PdKfdENqYUkLMsYGceY4AQb2fgaKGvWJo4xDp148SSe3eCdyqomrtp1qiZ4s5PL\n", + "TtXEtalJpWaSmirXpioLGSfEBmKIMSYuZK7GNg4bcBJDjA22bAxCCCSEuLRuZ/84fY5Ot7p1aZ1W\n", + "q8X3U0WZVp8+5+3Tr4Ueve/zPMXF9mqkN5fzqafsPMtFi+xcz8ceswM8J5A6d86+9tq1Uk2N/drm\n", + "ZmnOnNSrqM4P9c6W24YGafVq+++RiF0VN1l3t902xdmm6g1yz57NbGttlrk/FB87prDPQac09hXM\n", + "W7/3vZwHfZP5B/7kIGakwD5dED1SAOvcg2n19bp/3bqEQjzBioqE1yQHjAM9PTr9hz8knKts1iy1\n", + "7d3r5iwOYVmD21a9uyIKhv+ncUyro2kqVYeSPufK+fPVuGaNJM/Kb0WFVFCgvu5undy1S93Hj7tB\n", + "7Kb4DoiahQsl2avDF06ccD+T5Pm0u6lJHYcOSbILELGNFgAw0WingsllrAWBhpNJG46KCsn5QdRp\n", + "L+IU1YlGB9t91NZKhw8nfs2xYoUdDCZf2xlPWdlg8BoMSvfcYz+/Zs3gGJPbvXiLGrW326+74w57\n", + "+27y++vstAsPeSttLlwo3XSTvRrqx72d5MbTjxAj86Nlymg+k5eWLNGJ5mbJGLdCbe3nPqfPx4tn\n", + "PTd3rmKeVUTJbj9SXFOjstmz1b5//8itS5IU19YqMneuTib/f+2nggLNuPtuheO5nwWhkFsUSJJ2\n", + "rFypo88/r8LiYvUOs2I/bfZsldTVqevoUQ309bkBdn00qgc2bkw49tmrr3b7nia3pgEAYLxop4L8\n", + "k6pNSaa820qfeip93qOXU8ynpER67bXEFULvCktrq11YyGnf4OR4OquWqba0Ol/z5mr29trvNxRK\n", + "XcnVCTrXrUssatTWJr30Uupts5GIPffB4sIAACAASURBVA7JXjFdvtw+xrsFN/neetuaTIEWCpls\n", + "Wx3r9tx8Nt736qzIhaur1e1ZZRvJWFd1S+vqFK6pkQoKZPX1yerr08ldu7SnqUnhSERfefddlc2a\n", + "lbBt1ert1cUTJ9S2d2/KoNMEg27Rn1Rm3HmnHdiOJi98rJyV1IEBte3dq/Y//EHn3ntPJ3bs0HNz\n", + "5uh8S4sk6XxLiwZisZRBp/NeqxcuVO+FCzq1d68utbaqx3PsqddfV6yzM+Fz7otvJ5fktncZyZX0\n", + "/wQAIPtY8cTkMopVyp07d469Gltj4+DK5IoV6dtztLTY22Zfe21o3mFnp10IyFtFNhCwCwlt22Zv\n", + "d03VbiR5FVeS5s2zg1fJDg63b098nfc1XV32yqZkV389diz9sc5KZvKKqTT8vR3t/Zmidu7cqa5/\n", + "/MeMVvHy0XArlqNp6+KsXHbHA7zk84ylNUy6Y3c3NenounUJuY6SvSW1uqFB51taFCgpUW9Xl045\n", + "/384Cgrs6s/Ofx2FhTIFBWnbpwQjEVV+5jPqbmnRxZMn026TTSdQXq6+ri69K2muJBMKSZalUHm5\n", + "Ztx5p/p7euwVXA8TCLhbdwMlJaq+/XZ1vPPO0O3BhYUyxmjGnXeqqLpajWvW6NfXX+/28fS2QZHs\n", + "1dDLZ8+6969oxgxdbmtTVUODlm3fPqrgP9OVbfgvo3/3gGEwp+A3VjyRf7JV/Ga01Vzr66WPPx4a\n", + "dDY12dtq45UlXX199uqjN8cyWaoWJocP2yuR0ejQoDP5NfFKlKqsTF39NdUqcXIuZ1OTHcB627lk\n", + "cn+msPH0u8w3w73X0eTHOiuXIU/lWO95xpJjm+5Yb4GdYHm5CouLFaqsVMlVV+nc0aPua5xKrdMX\n", + "LNC1S5cqVFXlBptOFdnpN99sf72/P2XQaYJBFc2YoYJgUG179+ri8eNu0BmKRNxKsl4F4fCQr/Wd\n", + "P5/w2OrpkdXbq9iZMwqWlmrJ+vUKJ1W2teLXKSwpUaC0VK27dtkBZHzFtaCkxF7l7O+X1denU3v3\n", + "ui1mquO54NMXLNCX9+9XcW2tJPvzKKmrc+9fqLJSX3rrLV2/YsWog04p9TxhFRQAkCkCT0wuoyh+\n", + "k9Fv6JyA9qabEtujjJYT3J09a2+vdbbYSnaPzeEClVRBXSRir552dAwWJHI0NdlVciV7NbW+3g4Y\n", + "DxxIXf11NEHjkSND27l4TZJqt7nS2Ng4qavK+m249zqWADzTIkKjud75eEBpAgF9cc8e1dxxh3o6\n", + "OvRJc7O7yjp9wQJF33xT169YoYd37NCDW7YoGK9mHayo0EPNzfZzu3YpEP+6kyvqLSBk9fbqclub\n", + "Yt686Pi1p99yi6obGoaMO5hqu258d8/cFO+z4bvfVTgSUc0ddwx5TWFRkR49dEgD3qJF8XMNXLyY\n", + "UMzIWxhoSbz1ycM7dmhafb0ePXzY/Ty649t2TSCgh3fudAs2jWVup/p8J0ProSsRK1PwG3MKuUDg\n", + "iSuDE9AOl+c4HG+l2N5e+09dnb1quWPH8MFauqAuXT7rkSN2QCrZqx779qUNGHc3NenFri69XFur\n", + "WKqVzOTxpwtOJ0m121yazFVl/Zbuve5ualJvV5eKa2u1ZMOGEe9FuvOk69mZarUsXfBaGv8li9XX\n", + "pwM/+EHKticXT5xQqKJCoUhEr0SjennpUhVfc40kqffcOR34wQ/c8V08ccI+X3+/CouKFHT6YsYD\n", + "SG/epyksVKiyUlZfn1p37VIoEhmywhnztEwZjd899JB7fwuKitxczekLFug/nTypA08/LSctxRlL\n", + "MF58SIWFUiCggnBYJhRy72ny/Q9HIgpFIlo3b54uOO83fv9SGWn1MtXneyXtDAAA+Ct9MzJgkso4\n", + "L8G7ktjQMLYtpWvX2q/v6LDboYylUq4T1HnH4VSolYYGg94gMRIZvF6K8XYeOaLW+OrPnlWr0udg\n", + "OeNPlYMKcl3iOo8ccfMl9w03n1JIztUsnTXLzQ/c09Sk+9etc1fLvF9zgptkqbbxPj9vni47udGy\n", + "e2b+e02NpMEWJ0We7aaLf/Yzd1zeXM/+y5fVf/myJNnVZSMRxeKrqZIdnDqBZvXChWpcs0a/W7Zs\n", + "aC5pGk6Op1fJNdeo49ChIeeYdt11Ckci9tbiePAXKC7WNffdp3t+8hO9sHChm7s50Nen9n37Eu6f\n", + "974X19Tow9/+NiEvNlRZOSRAdF5z9o9/dHNEnfOl4r3G4mee0b5Vq9zKxGPJ50Xm+B4FvzGnkAsE\n", + "nrhyeFcSZ80aWwDmBI+pivZIY2sD46x0SnaF2uQA1hskOudOEzAG4tsRqysqtPhHPxp5/JOFn21z\n", + "4JvxrGYlB5WpzjXS+Xc3Nall82b1x2Kquvlm1Uejaly9WvueekqdR46o6rOfVcGtt+r0/v263Nbm\n", + "Vrt1FRaq4lOf0lV33qlQRYVeiUbV9sYbGujpGfY9hyIRdZ84oYJQSAM9PQpXV2tafb2MpPIbbtAr\n", + "0ag633039QmSCxilcXrfPhV6tvta/f12UBvv0+td0b18+rQ+2rJFH//udxrwFDgKlJWpr7tbgbIy\n", + "xTo6FOvsTLjv4ZqahKAzWFGhRw4cGBIMel8jjfx5e49P/oVEql8mAACQClVtceXIpK/naHmrwobD\n", + "dkB1223S+vVDr+PjOGKLFmnP3r1aLCk8nmq0Ex0IXuFVdCcrb59NJ9gb7UpWcu9USQk9O3c3Nanj\n", + "0CF1HT2q6JtvalpSvnKqKrZOJdXk6qrtBw+q6/333TzI5ODv+hUrdLGtLSG4SiUYiWggFlO/p9VI\n", + "6cyZKquvd1cmvVVnTTA4WJyooEChigrJGPWcPatQZaWqbr45ff/PggIFy8rUG+8TXDpzpv7jn/7k\n", + "3tdYZ6fWzZvn9tpMJVRZqd7ubncM4epq9Z4/b7eNKSxUqLxcPR0dCkUiuuqee/QffvWrlJ+b81lV\n", + "NTSobNYsNa5ZM+znm/zZeufGQG+vTjQ30zMXAK5wVLXFlWe4fpRr10qzZ9uBYXJBn/FyVisCASkW\n", + "G9ySmyqP1MdCPuHyct0vKTzaarTp7o+f/VNHgyq6WTHeiqPenL6xFpFJztVMzg90tvFeam3VvhT5\n", + "yt4qtlJiEZ3kvqFdx44NBp2SwtOnu3+fvmCBCouLddbZVl+Q+p+5wqIiTf/MZxKCTkn64muvuf00\n", + "vSuqocpK1d177+CBAwPq6ehQz9mzCpSUKHLTTTLBYPoemQMDbtAZLC/XF197LSFIC0cievTwYYWr\n", + "q1O+vKCkRD0dHW7QGSgrU6y9fbBXaX+/ejo6VFJXp69+8IEe3LLFDfjT5dUu275dD2zaNGKwmPzZ\n", + "eudGsKzsiinKBQAYHwJP5J2dO3emf3K4ACoSsbfY7t3rT4DlDeKeecYOJr2VLisqsl/IZ6xBbLr7\n", + "M9GB4CSrojvsnMojflYcHeu225GKM410Puf5YEWFrl26NKHtR9f778sEAurp7LQr2nq2n1bcdJO+\n", + "vH+/yurrFaqqUlF1tbqOHh3sb+kJSh2FJSV69C9/Sdkm5fUnnxxcjY2vooYqK/XIgQO6f/16t2WJ\n", + "iVe2DpaXq3L+fLXt3asTzc0a6O1Vmk25dpEgSb1dXUOC791NTVo3b5560vzCIOQUQSotlQoK1BcP\n", + "mANJ1XVrbr894TNINSfGUkhrd1OTXolG1dPd7X7N+1k2rl59xRTlyqWp8j0KkwdzCrlA4ImpJVUA\n", + "5Q0QnTYofgRYmzcPBnFPPmkHkwsX2s8VFtptVrJtrEFsugBzogNBquhmhZ8VR/1uLzPS+ZznH/vw\n", + "Q3e1znGprU1WX5+7+ljozYc8dUp7vvENlcycqZ4zZ3SiuVltb70labC/pVNwqHL+fJXU1enRQ4c0\n", + "rb7eLoI0c2biQIxxA9LC0lIVzZihRw4c0LT6endV8voVK1R9662S7CDSWSFNDgK9XwtFIiqOF0IK\n", + "VlRIhYXuSuSOlSt1dN06XWptdd9jcW2tTHy11gQCWvKb3yhcXa2+CxfsgDgefAfLyhSeMcN9v41r\n", + "1iRef5xzIlXgeiW1HgIA+IccT0wNTo5iMCiVlkpr1gwGNd58wuXLpVDIn+qu06cPFiuKRqWNG+3t\n", + "q3PmSPEqlJMufzFdcSRMCd4czYkOCLJZ3fQXNTWKtbersKREdY2NGujp0SfNzW6xHUl26yHLSsj3\n", + "rI9G9cDGjdqxcqU+2rpVVbfcoiXr1yeMzZs/agIBfeX997X/+9/Xe88+627nrV++XA9s2pTwPjve\n", + "eUex9nZ7a6wxQ3qASlLRjBn60ltvuVVgty5b5vYg9eaOhmtqEl5f1dCgZdu361f19erz5IRWzp+v\n", + "41u3uq8tLClR/Re/qAsff5wyd3Z3U5POxvNqvxR/bqyfU3J+J4EmACAVcjxx5XC2kDY324Gl94cj\n", + "7yrfmjX+rbTddpv934YGKV6ZUpGIdPvtg9cb6wrDcDmqfmClcUrLZS9Sv7b5pspJ/PL+/SqdOVOP\n", + "HjqkB7ds0f3r16ts9myZ+NbVwtLSwZzPeNBZvXChQuXlerGxUe/98peKnT6tE83N+vWcOQn5r95q\n", + "slZfn15/8kl7BdPzC9OBeF6lUwCpddcuxdrbVRAKyerrSxl0StJVd9+tA08/rYttbXr1scd05sCB\n", + "hGtJ9kpo1S23SBq6zbgwni9aWFKiqxYtUk9Xl4pqa7Vsxw73flw8edLNnX3h9tsT7lvnkSNq27tX\n", + "lz15tePN3QUAIFMEnsg7KfMShstRzNY20vXr7fNu3z60HUqm15voIj+QRK7LcEZbsCiTLZ3ec+9Y\n", + "uVIvNjbq2IYNQwKjafX1+puPP3ZX7F6JRtXT2ekWIwqWlrrnrJw/X/XRqB7atk3nW1rs1UxPxdue\n", + "9nY9W1en3y5apJeXLtXiZ56xV0vjBnp7E4JRSTr7xz+6Y3MLIBUWaqCnJyEnM1hRoaIZM/SupOC0\n", + "abrnJz9JCPRStXW56p57VFpXZ/cNNUb9nmO8AffFkyfdIPKdn/7UvR/OWANlZYqdPq3jW7dq3bx5\n", + "inV2ZtTSJlkuf5mBQXyPgt+YU8gF+nhiavD2vkz+ASlbPSzTnXc816PaKyaZ0fZpvG/t2jFv803o\n", + "QVldrZizRV3pA6NUPSiXbNig1598UjJGjatXu9d3giynb6Zj4NIlt13KvlWrFKqocAPIglBIjatX\n", + "6xc1NVJ8VfLC8eO6cPy4+3pv65SqhgZdbm9X78WLqm5oUO/581Jbm3rPn9e+VasSAr3zH3yg2Jkz\n", + "g9uCJX28dav794FYTCeam/X83Ln663ffdQNuSeqK9+wNlpfrTk/PXue+X+7o0InmZknSpdZW7Wlq\n", + "SvmZZPI5AQDgB3I8gVxK7p/pfM3vHMyJ7tOJKSObOX7ec4cjEX3S3Dykt2RyTuKG+fN14fhxBadN\n", + "U+3ixWl7VUqDOa8N3/2utj74oPp6etTjCW5DlZX66rFjal6xwr32su3bte+pp3Rs/fohFWZDkYiu\n", + "vvdet4CPE8C9Eo26wXBxba0utbYqXF0tU1CggZ4eFYRC+lK84NGLixbpC1u26KX77ksItJM5PUwd\n", + "v120yA2Wk59z3qvTB9Tbb7Nl82b1x2Kqvu22IfmtAAD4ZTQ5ngSeQC55Cx9lsxDRRF0HEy6bRX2k\n", + "7BYs8p5bUsrreIv/XL9ihbpPnHAL9JTNnq2yWbNG/d5jnZ16ft48XW5ttStPO/82FRTomr/6K3dL\n", + "qfeajlAkokcOHkwo3iPZ9//Yhg3q6eiQCQQUKClRYVGRps2erdP79rnHeYNF72tchYVupVonAPa+\n", + "n9H8AiD5s0p+H6kCVgAA/EBxIUxJ485LyHYBn7EYaWutX2NlC++w8jnXxc/enamMJ8dvpPxQ77nT\n", + "XSc5JzEUb3VSvXChSurqRvXedzc16dmrr9avr79elXPnKlxVZQd5AwP2n74+ffLqq0OuWdXQoGuX\n", + "LlV9NKqvfvCBDjz99JD303nkiBtAWn196u3q0tttbeqOt1iR7DYn3m3D3tdI0jVLluirR4+qfvly\n", + "1UejQ4JOyd4iO232bBWGw3r1sccU6+wccn+T76E3V7WwtFSxjo5h83QxeeXz9yhMTswp5AKBJ648\n", + "k6mAz0iFiPwa60T36byCjLb4Trb42bvTT94KsOMJipOrqnofe4PQ4d5755EjutTaqp6ODp3ctUsF\n", + "Tj9fr4GBIX0ql23frge3bNEDGzcqHIkkBPnP3XijXl661D2X0/tTkspvuEHRN99UWX29QlVVKqqu\n", + "du/Ji42Nat2zJ+HS4UhE0+rr9cCmTe61vMe/vHSpJKl01iyd2rvXvZ8j/dLhvrVrVR+NKlxVpf4L\n", + "F/RJc3NWfjkBAMBosNUWV56lS+1AbuHCkQOxXOdGjmWsyInkraATvZUxl707h+O9L04uZfL4xrtN\n", + "eLTv3dmmKtmrmJ/fuFH7Vq3S+Y8+GtwOW1CgqxcvVll9vY6tX6/+S5dkAgFd9bnP6YFNmxSORNzz\n", + "ePuHmkBA4enT9dC2bdr//e8nFDjy3oPi2lpZlqXLp04ljM0Eg/paW1vK8SfPrZ7ubvf6M+66S5J0\n", + "orl5xPxbenECALKNHE8glc7O0RfwyXVu5FjGipzgh/rUnPsSqqzUIwcODMmNlMYftI82cI11dmrn\n", + "448PqXob6+zUr2+4QT1nzrjHhquq7MqzHsW1tXr08GFJGlJB1nvMzM9/XudbWhQoKVFxTY1aNm9O\n", + "2FJrgkFZ8Z6gjof37NHVixalHHfy3JKk52680e0bWh+NqjAYHDHwnqy/nAAATB3keGJKGndegtPu\n", + "ZDQ/gOU6N3IsY0XGxjOnkreCwlZcU6NwTY2qb7tNoYqKlMckbxMe67bl0ea3hiMRFc+YobY339Sz\n", + "V12l1ZGIXlqyRJI04447Eo41hYVDXn+ptVXPz5snSbp/3TotWb9exbW1Q475aOtWte7apVe3btVH\n", + "W7cmBJ3B8nIVTZ8ev8jgv8vv/PSnacedPLfCkYhqFi6UZN+zxtWrR5V/Sy/O/Ec+HvzGnEIuZBx4\n", + "GmN+ZIw5bIx52xjzgjEm9U8WQD4jNxIj4If61M63tCh2+rRODJNXmBxYjbVQ0ljyW508z4GeHvWe\n", + "O+eO6761a1VQVGSfb9o0PbRtm0qvvVYmGJQCg62uL8d7Y0r2Z/7o4cOqX75cRTNmuGOouuUWSVLF\n", + "jTeq0MkjLbD/me3t6tKltjb7a/FdQN5xpwq6U80tftEBAMhXGW+1NcYskfSqZVkDxpgfSpJlWd9O\n", + "cRxbbQHgCpPJFuSxvmbHypX66OWXVb1ggUrq6txtrqm23XrzPCUpNH26KufNU7C8XKd//3u3p2Z9\n", + "NKpYR4e7BbggHNZALJZ2TOlawmxdtsxt+5JKSV2dVrzzjnu+Z6++WpdaWyXZ231r7rgjK+1xAADI\n", + "htFstQ0M9+RwLMva5nm4T9IjmZ4LADC13Ld27ajyCr15moufeUb7Vq1yXzNSDuf5lhbF2tv1SXOz\n", + "wjU1bu7jnqYm3b9u3ZBzv/7Nb2qgp0cFwaAut7frlBMYera+DvT0JKyklt9wg33+NO/BWZV0OH93\n", + "Ku4Wlpaq/8KFhNdMX7BAVTffrFeiUfe99cdi7vOxM2fcVV/6bgIApgq/cjz/VtLLPp0LGNao8hIm\n", + "U69OTHrkuvhvtFuQvdtr961alfCakbbenj96VJIUrKjQ9JtukpS4fbVl82b39a9/85t6YONGuz3K\n", + "pk1u+5NwdXVC4FkQDCZsZ7148qQb3I62FcnOnTvdc9TefXfCc6UzZ+rhHTt0vqUl4b1V33abJCkw\n", + "TIuYXLfuSWeyjmsq4XsU/MacQi4Mu+JpjNkmqTbFU/9gWdbm+DHfkdRjWdbadOd5/PHHdd1110mS\n", + "IpGIFixYoMbGRkmDE5/HPB7t44MHD458fLz/5U5JikbVGP/6ZBg/jyffY8dkGc+V9PjQpUuaLjvQ\n", + "Gvja17Rz5073+UOXLum0pM/Fg7Dk138Qiajj+HHNPXdOoUhE5++9V9d961tu4PpOd7d6Jc2VdHL3\n", + "bv3wzjt16/e+p88vW6b71q7Vv0WjajtzRjPi22yPlpbquq9/3Q2aveMLlJXp90ePauCll1T04ovq\n", + "PHJEhy5dcs/nfX+SHXgHnnhCA93dKvrzn3W5tVWtN96ou378Y/u5khK9KzsfdGU8wPy3aFTz/u7v\n", + "FHrhBS3+2c/0xsGDCe93z1tv6ezbb2uu7FXdwBNP5Pzzk6Su+C8I3pV0OBrV3/P9lsc8nvSPDyZ9\n", + "f8n1eHicf48PHjyozvgvGz/88EONxrjaqRhjHpf0XyXdZ1nW5TTHkOOJiUf/y7HJdb9SXLGGa/Ux\n", + "UhuQkXJCX1qyRCeamxO2u16/YoVC8UJGgZISDfT26kRzs0KVlZr5wAO6ePJkwtbeWGennpszx80B\n", + "LZs9WxeOH3fbotQvX64HNm3S85/+tC62tqogGNSX9+9PaB+T6n1k0uJksrbumazjAgBMnKz28TTG\n", + "fEHSjyXda1lW+zDHEXhi4tH/cmwaG3PbrxTwGEt/zuGCN+f5WEeHPmluVqCsTDPuukv9ly65+Z3e\n", + "XpivRKMp+4p6A6uCcDihaFB9NKoHNm7U6khEvefOSbK30/7Nxx/7ek9G835zZbKOCwAwcbIdeL4n\n", + "KSTpbPxLb1iW9USK4wg84audnq148MkVvkLMnJpcXmxsTBkAjiRdwBrr7NRzN97oFh8qrq3VpdbW\n", + "ISt06VbuvIHVq4895lbHnX7zzXp41y6FIxH9oqZGsfZ2FZaU6Oqf/1xLv/KVMY9zrMeM5/zIL3yP\n", + "gt+YU/DbaALPgkxPblnWHMuy6i3Laoj/GRJ0AsgT9CvFJDKW/pxe6YoRhSMR1Sxc6J4z+uabKXth\n", + "puuR6S2UdN/atapfvlz10agbdO5uatK0T31KBeGwom+8oZLaVKURRh7nWI8Zz/kBAJho48rxHNUF\n", + "WPEEAIxBpls3h8s1zOZ20LGu0CaPc99TTw1ZoRxP3iQ5lwCAiZbVFU8AALJhtK1YkqVbsRzPOVNJ\n", + "bh8y1hXa5HGmWqEc7r2MpLimRuHqagJOAMCkQuCJvOOUdAb8wpyaGvwMLoeTHCgmB4kjzafkcaYK\n", + "XMfzXs63tIy59ygmN75HwW/MKeQCgScAAGOQHCiON+Adz+rmaMYHAMBkQI4nAABjMNnbh0z28QEA\n", + "pp6stlMZwyAIPAEAAABgiqK4EKYk8hLgN+YU/MR8gt+YU/Abcwq5QOAJAAAAAMgqttoCAAAAADLG\n", + "VlsAAAAAQM4ReCLvkJcAvzGn4CfmE/zGnILfmFPIBQJPAAAAAEBWkeMJAAAAAMgYOZ4AAAAAgJwj\n", + "8ETeIS8BfmNOwU/MJ/iNOQW/MaeQCwSeAAAAAICsIscTAAAAAJAxcjwBAAAAADlH4Im8Q14C/Mac\n", + "gp+YT/Abcwp+Y04hFwg8AQAAAABZRY4nAAAAACBj5HgCAAAAAHKOwBN5h7wE+I05BT8xn+A35hT8\n", + "xpxCLhB4AgAAAACyihxPAAAAAEDGyPEEAAAAAOQcgSfyDnkJ8BtzCn5iPsFvzCn4jTmFXCDwBAAA\n", + "AABkFTmeAAAAAICMkeMJAAAAAMg5Ak/kHfIS4DfmFPzEfILfmFPwG3MKuUDgCQAAAADIKnI8AQAA\n", + "AAAZI8cTAAAAAJBzBJ7IO+QlwG/MKfiJ+QS/MafgN+YUcoHAEwAAAACQVeR4AgAAAAAyRo4nAAAA\n", + "ACDnCDyRd8hLgN+YU/AT8wl+Y07Bb8wp5AKBJwAAAAAgq8jxBAAAAABkjBxPAAAAAEDOEXgi75CX\n", + "AL8xp+An5hP8xpyC35hTyAUCTwAAAABAVpHjCQAAAADIGDmeAAAAAICcI/BE3iEvAX5jTsFPzCf4\n", + "jTkFvzGnkAsEngAAAACArCLHEwAAAACQMXI8AQAAAAA5R+CJvENeAvzGnIKfmE/wG3MKfmNOIRcI\n", + "PAEAAAAAWUWOJwAAAAAgY+R4AgAAAAByjsATeYe8BPiNOQU/MZ/gN+YU/MacQi4QeAIAAAAAsooc\n", + "TwAAAABAxsjxBAAAAADkHIEn8g55CfAbcwp+Yj7Bb8wp+I05hVwg8AQAAAAAZBU5ngAAAACAjJHj\n", + "CQAAAADIOQJP5B3yEuA35hT8xHyC35hT8BtzCrlA4AkAAAAAyCpyPAEAAAAAGSPHEwAAAACQcwSe\n", + "yDvkJcBvzCn4ifkEvzGn4DfmFHKBwBMAAAAAkFXkeAIAAAAAMkaOJwAAAAAg5wg8kXfIS4DfmFPw\n", + "E/MJfmNOwW/MKeQCgScAAAAAIKvI8QQAAAAAZIwcTwAAAABAzmUceBpj/skY87Yx5qAx5lVjzLV+\n", + "DgxIh7wE+I05BT8xn+A35hT8xpxCLoxnxfOfLcu6xbKsBZI2SfpfPo0JGNbBgwdzPQRMMcwp+In5\n", + "BL8xp+A35hRyIePA07Ks856HZZLaxz8cYGSdnZ25HgKmGOYU/MR8gt+YU/Abcwq5EBjPi40xT0v6\n", + "z5IuSrrLlxEBAAAAAKaUYVc8jTHbjDF/SvHnYUmyLOs7lmXNkrRG0r9MwHgBffjhh7keAqYY5hT8\n", + "xHyC35hT8BtzCrngSzsVY8wsSS9blvXZFM/RSwUAAAAAprCR2qlkvNXWGDPHsqz34g+XSzqQyQAA\n", + "AAAAAFNbxiuexpgNkuZK6pd0VNI3LMtq83FsAAAAAIApwJettgAAAAAApDOePp6jZoz5J2PM28aY\n", + "g8aYV40x107EdTE1GWN+ZIw5HJ9TLxhjKnI9JuQ3Y8wKY8w7xph+Y8ytuR4P8pcx5gvGmL8YY94z\n", + "xvyPXI8H+c0Y83+NMaeMMX/K9VgwNRhjrjXG7Ij/m/dnY8x/z/WYkL+MMUXGmH3xGO+QMeZ/D3v8\n", + "RKx4GmOmOX0/jTH/TdItlmV9PesXxpRkjFki6VXLsgaMMT+UJMuyvp3jYSGPGWM+LWlA0v+R9PeW\n", + "Zf0hx0NCHjLGFEp6V9L9kj6R9HtJX7Us63BOB4a8ZYxZLKlb0r9bljU/1+NB/jPG1EqqtSzroDGm\n", + "TNL/kxTl+xQyZYwpsSzrojEm47bo4wAAAphJREFUIOk1Sd+yLOu1VMdOyIqnE3TGlUlqn4jrYmqy\n", + "LGubZVkD8Yf7JM3M5XiQ/yzL+otlWUdyPQ7kvTskvW9Z1oeWZfVKek528T0gI5Zl7ZHUketxYOqw\n", + "LKvVsqyD8b93SzosqS63o0I+syzrYvyvIUmFks6mO3ZCAk9JMsY8bYz5SNJKST+cqOtiyvtbSS/n\n", + "ehAAIOkaSR97Hh+Pfw0AJh1jzHWSGmT/Eh/IiDGmwBhzUNIpSTssyzqU7tiM26mkuOg2SbUpnvoH\n", + "y7I2W5b1HUnfMcZ8W9K/SPovfl0bU89I8yl+zHck9ViWtXZCB4e8NJo5BYwT1foA5IX4NtsNkp6M\n", + "r3wCGYnvQlwQr7nyijGm0bKsnamO9S3wtCxrySgPXStWqDCCkeaTMeZxSUsl3TchA0LeG8P3KCBT\n", + "n0jyFs+7VvaqJwBMGsaYoKTfSPqlZVmbcj0eTA2WZZ0zxmyRtFDSzlTHTFRV2zmeh8slHZiI62Jq\n", + "MsZ8QdIqScsty7qc6/FgyjG5HgDy1n5Jc4wx1xljQpL+WtKLOR4TALiMMUbSzyUdsizrX3M9HuQ3\n", + "Y0y1MSYS/3uxpCUaJs6bqKq2GyTNldQv6aikb1iW1Zb1C2NKMsa8JzuB2UlefsOyrCdyOCTkOWPM\n", + "lyT9VFK1pHOSDliW9WBuR4V8ZIx5UNK/yi6w8HPLsoYtLQ8Mxxjza0n3SqqS1Cbp+5Zlrc7tqJDP\n", + "jDGLJO2W9EcNpgf8T8uyfpe7USFfGWPmS/qF7MXMAknPWpb1o7THT0TgCQAAAAC4ck1YVVsAAAAA\n", + "wJWJwBMAAAAAkFUEngAAAACArCLwBAAAAABkFYEnAAAAACCrCDwBAAAAAFlF4AkAAAAAyCoCTwAA\n", + "AABAVv1/lzHCzGUnjVoAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAA54AAAIXCAYAAAD0R4FDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABAVv1/lzHCzGUnjVoAAAAASUVORK5CYII=\n", - "text": [ - "" - ] - } - ], - "prompt_number": 5 + "output_type": "display_data" } ], - "metadata": {} + "source": [ + "feat = out['feat']\n", + "f = plt.figure(figsize=(16,9))\n", + "c = ['#ff0000', '#ffff00', '#00ff00', '#00ffff', '#0000ff', \n", + " '#ff00ff', '#990000', '#999900', '#009900', '#009999']\n", + "for i in range(10):\n", + " plt.plot(feat[labels==i,0].flatten(), feat[labels==i,1].flatten(), '.', c=c[i])\n", + "plt.legend(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'])\n", + "plt.grid()\n", + "plt.show()" + ] } - ] -} \ No newline at end of file + ], + "metadata": { + "description": "Extracting features and plotting the Siamese network embedding.", + "example_name": "Siamese network embedding", + "include_in_docs": true, + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + }, + "priority": 6 + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 7a8fcc763dc89e717a58319a77da9d9813a829c0 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Tue, 19 May 2015 22:41:50 -0700 Subject: [PATCH 018/331] avoid dangerous state in pooling layer CUDA kernels Previously, pointers were modified with the assumption that they would only be modified once. While this is true so far in practice, the introduction of CUDA_KERNEL_LOOP makes this a dangerous assumption. --- src/caffe/layers/pooling_layer.cu | 57 +++++++++++++++++-------------- 1 file changed, 32 insertions(+), 25 deletions(-) diff --git a/src/caffe/layers/pooling_layer.cu b/src/caffe/layers/pooling_layer.cu index d1d48501af3..a1080ebf33a 100644 --- a/src/caffe/layers/pooling_layer.cu +++ b/src/caffe/layers/pooling_layer.cu @@ -28,12 +28,13 @@ __global__ void MaxPoolForward(const int nthreads, const Dtype* bottom_data, wstart = max(wstart, 0); Dtype maxval = -FLT_MAX; int maxidx = -1; - bottom_data += (n * channels + c) * height * width; + const Dtype* const bottom_slice = + bottom_data + (n * channels + c) * height * width; for (int h = hstart; h < hend; ++h) { for (int w = wstart; w < wend; ++w) { - if (bottom_data[h * width + w] > maxval) { + if (bottom_slice[h * width + w] > maxval) { maxidx = h * width + w; - maxval = bottom_data[maxidx]; + maxval = bottom_slice[maxidx]; } } } @@ -67,10 +68,11 @@ __global__ void AvePoolForward(const int nthreads, const Dtype* bottom_data, hend = min(hend, height); wend = min(wend, width); Dtype aveval = 0; - bottom_data += (n * channels + c) * height * width; + const Dtype* const bottom_slice = + bottom_data + (n * channels + c) * height * width; for (int h = hstart; h < hend; ++h) { for (int w = wstart; w < wend; ++w) { - aveval += bottom_data[h * width + w]; + aveval += bottom_slice[h * width + w]; } } top_data[index] = aveval / pool_size; @@ -94,11 +96,12 @@ __global__ void StoPoolForwardTrain(const int nthreads, int wstart = pw * stride_w; int wend = min(wstart + kernel_w, width); Dtype cumsum = 0.; - bottom_data += (n * channels + c) * height * width; + const Dtype* const bottom_slice = + bottom_data + (n * channels + c) * height * width; // First pass: get sum for (int h = hstart; h < hend; ++h) { for (int w = wstart; w < wend; ++w) { - cumsum += bottom_data[h * width + w]; + cumsum += bottom_slice[h * width + w]; } } float thres = rand_idx[index] * cumsum; @@ -106,10 +109,10 @@ __global__ void StoPoolForwardTrain(const int nthreads, cumsum = 0; for (int h = hstart; h < hend; ++h) { for (int w = wstart; w < wend; ++w) { - cumsum += bottom_data[h * width + w]; + cumsum += bottom_slice[h * width + w]; if (cumsum >= thres) { rand_idx[index] = ((n * channels + c) * height + h) * width + w; - top_data[index] = bottom_data[h * width + w]; + top_data[index] = bottom_slice[h * width + w]; return; } } @@ -137,12 +140,13 @@ __global__ void StoPoolForwardTest(const int nthreads, // We set cumsum to be 0 to avoid divide-by-zero problems Dtype cumsum = FLT_MIN; Dtype cumvalues = 0.; - bottom_data += (n * channels + c) * height * width; + const Dtype* const bottom_slice = + bottom_data + (n * channels + c) * height * width; // First pass: get sum for (int h = hstart; h < hend; ++h) { for (int w = wstart; w < wend; ++w) { - cumsum += bottom_data[h * width + w]; - cumvalues += bottom_data[h * width + w] * bottom_data[h * width + w]; + cumsum += bottom_slice[h * width + w]; + cumvalues += bottom_slice[h * width + w] * bottom_slice[h * width + w]; } } top_data[index] = cumvalues / cumsum; @@ -231,22 +235,22 @@ __global__ void MaxPoolBackward(const int nthreads, const Dtype* top_diff, int pwend = min((w + pad_w) / stride_w + 1, pooled_width); Dtype gradient = 0; int offset = (n * channels + c) * pooled_height * pooled_width; - top_diff += offset; + const Dtype* const top_diff_slice = top_diff + offset; if (mask) { - mask += offset; + const int* const mask_slice = mask + offset; for (int ph = phstart; ph < phend; ++ph) { for (int pw = pwstart; pw < pwend; ++pw) { - if (mask[ph * pooled_width + pw] == h * width + w) { - gradient += top_diff[ph * pooled_width + pw]; + if (mask_slice[ph * pooled_width + pw] == h * width + w) { + gradient += top_diff_slice[ph * pooled_width + pw]; } } } } else { - top_mask += offset; + const Dtype* const top_mask_slice = top_mask + offset; for (int ph = phstart; ph < phend; ++ph) { for (int pw = pwstart; pw < pwend; ++pw) { - if (top_mask[ph * pooled_width + pw] == h * width + w) { - gradient += top_diff[ph * pooled_width + pw]; + if (top_mask_slice[ph * pooled_width + pw] == h * width + w) { + gradient += top_diff_slice[ph * pooled_width + pw]; } } } @@ -274,7 +278,8 @@ __global__ void AvePoolBackward(const int nthreads, const Dtype* top_diff, int pwstart = (w < kernel_w) ? 0 : (w - kernel_w) / stride_w + 1; int pwend = min(w / stride_w + 1, pooled_width); Dtype gradient = 0; - top_diff += (n * channels + c) * pooled_height * pooled_width; + const Dtype* const top_diff_slice = + top_diff + (n * channels + c) * pooled_height * pooled_width; for (int ph = phstart; ph < phend; ++ph) { for (int pw = pwstart; pw < pwend; ++pw) { // figure out the pooling size @@ -283,7 +288,7 @@ __global__ void AvePoolBackward(const int nthreads, const Dtype* top_diff, int hend = min(hstart + kernel_h, height + pad_h); int wend = min(wstart + kernel_w, width + pad_w); int pool_size = (hend - hstart) * (wend - wstart); - gradient += top_diff[ph * pooled_width + pw] / pool_size; + gradient += top_diff_slice[ph * pooled_width + pw] / pool_size; } } bottom_diff[index] = gradient; @@ -310,12 +315,14 @@ __global__ void StoPoolBackward(const int nthreads, int pwstart = (w < kernel_w) ? 0 : (w - kernel_w) / stride_w + 1; int pwend = min(w / stride_w + 1, pooled_width); Dtype gradient = 0; - rand_idx += (n * channels + c) * pooled_height * pooled_width; - top_diff += (n * channels + c) * pooled_height * pooled_width; + const Dtype* const rand_idx_slice = + rand_idx + (n * channels + c) * pooled_height * pooled_width; + const Dtype* const top_diff_slice = + top_diff + (n * channels + c) * pooled_height * pooled_width; for (int ph = phstart; ph < phend; ++ph) { for (int pw = pwstart; pw < pwend; ++pw) { - gradient += top_diff[ph * pooled_width + pw] * - (index == static_cast(rand_idx[ph * pooled_width + pw])); + gradient += top_diff_slice[ph * pooled_width + pw] * + (index == static_cast(rand_idx_slice[ph * pooled_width + pw])); } } bottom_diff[index] = gradient; From 44d35bd071517a6bab8f2d2d7fc3ddf2d5df9762 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Tue, 19 May 2015 22:52:12 -0700 Subject: [PATCH 019/331] avoid dangerous state in LRN layer CUDA kernels --- src/caffe/layers/lrn_layer.cu | 58 +++++++++++++++++++---------------- 1 file changed, 31 insertions(+), 27 deletions(-) diff --git a/src/caffe/layers/lrn_layer.cu b/src/caffe/layers/lrn_layer.cu index 24aa6a30130..e50ae8df83b 100644 --- a/src/caffe/layers/lrn_layer.cu +++ b/src/caffe/layers/lrn_layer.cu @@ -18,8 +18,8 @@ __global__ void LRNFillScale(const int nthreads, const Dtype* in, int n = index / width / height; int offset = (n * channels * height + h) * width + w; int step = height * width; - in += offset; - scale += offset; + const Dtype* const in_off = in + offset; + Dtype* const scale_off = scale + offset; int head = 0; int pre_pad = (size - 1) / 2; int post_pad = size - pre_pad - 1; @@ -27,24 +27,26 @@ __global__ void LRNFillScale(const int nthreads, const Dtype* in, // fill the scale at [n, :, h, w] // accumulate values while (head < post_pad && head < channels) { - accum_scale += in[head * step] * in[head * step]; + accum_scale += in_off[head * step] * in_off[head * step]; ++head; } // both add and subtract while (head < channels) { - accum_scale += in[head * step] * in[head * step]; + accum_scale += in_off[head * step] * in_off[head * step]; if (head - size >= 0) { - accum_scale -= in[(head - size) * step] * in[(head - size) * step]; + accum_scale -= in_off[(head - size) * step] + * in_off[(head - size) * step]; } - scale[(head - post_pad) * step] = k + accum_scale * alpha_over_size; + scale_off[(head - post_pad) * step] = k + accum_scale * alpha_over_size; ++head; } // subtract only while (head < channels + post_pad) { if (head - size >= 0) { - accum_scale -= in[(head - size) * step] * in[(head - size) * step]; + accum_scale -= in_off[(head - size) * step] + * in_off[(head - size) * step]; } - scale[(head - post_pad) * step] = k + accum_scale * alpha_over_size; + scale_off[(head - post_pad) * step] = k + accum_scale * alpha_over_size; ++head; } } @@ -131,43 +133,45 @@ __global__ void LRNComputeDiff(const int nthreads, const Dtype* bottom_data, int n = index / width / height; int offset = (n * channels * height + h) * width + w; int step = height * width; - bottom_data += offset; - top_data += offset; - scale += offset; - top_diff += offset; - bottom_diff += offset; + const Dtype* const bottom_off = bottom_data + offset; + const Dtype* const top_off = top_data + offset; + const Dtype* const scale_off = scale + offset; + const Dtype* const top_diff_off = top_diff + offset; + Dtype* const bottom_diff_off = bottom_diff + offset; int head = 0; int pre_pad = size - (size + 1) / 2; int post_pad = size - pre_pad - 1; Dtype accum_ratio = 0; // accumulate values while (head < post_pad && head < channels) { - accum_ratio += top_diff[head * step] * top_data[head * step] / - scale[head * step]; + accum_ratio += top_diff_off[head * step] * top_off[head * step] / + scale_off[head * step]; ++head; } // both add and subtract while (head < channels) { - accum_ratio += top_diff[head * step] * top_data[head * step] / - scale[head * step]; + accum_ratio += top_diff_off[head * step] * top_off[head * step] / + scale_off[head * step]; if (head - size >= 0) { - accum_ratio -= top_diff[(head - size) * step] * - top_data[(head - size) * step] / scale[(head - size) * step]; + accum_ratio -= top_diff_off[(head - size) * step] * + top_off[(head - size) * step] / scale_off[(head - size) * step]; } - bottom_diff[(head - post_pad) * step] = top_diff[(head - post_pad) * step] - * pow(scale[(head - post_pad) * step], negative_beta) - cache_ratio * - bottom_data[(head - post_pad) * step] * accum_ratio; + bottom_diff_off[(head - post_pad) * step] = + top_diff_off[(head - post_pad) * step] + * pow(scale_off[(head - post_pad) * step], negative_beta) + - cache_ratio * bottom_off[(head - post_pad) * step] * accum_ratio; ++head; } // subtract only while (head < channels + post_pad) { if (head - size >= 0) { - accum_ratio -= top_diff[(head - size) * step] * - top_data[(head - size) * step] / scale[(head - size) * step]; + accum_ratio -= top_diff_off[(head - size) * step] * + top_off[(head - size) * step] / scale_off[(head - size) * step]; } - bottom_diff[(head - post_pad) * step] = top_diff[(head - post_pad) * step] - * pow(scale[(head - post_pad) * step], negative_beta) - cache_ratio * - bottom_data[(head - post_pad) * step] * accum_ratio; + bottom_diff_off[(head - post_pad) * step] = + top_diff_off[(head - post_pad) * step] + * pow(scale_off[(head - post_pad) * step], negative_beta) + - cache_ratio * bottom_off[(head - post_pad) * step] * accum_ratio; ++head; } } From d73f02b5aa81ce6808cb204f2540f2f585450890 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Tue, 19 May 2015 22:59:23 -0700 Subject: [PATCH 020/331] more const in pooling layer CUDA kernels This treats pointer arguments in the same way as non-pointer arguments, and should help to avoid issues like the previous dangerous state issue. --- src/caffe/layers/pooling_layer.cu | 161 +++++++++++++++--------------- 1 file changed, 81 insertions(+), 80 deletions(-) diff --git a/src/caffe/layers/pooling_layer.cu b/src/caffe/layers/pooling_layer.cu index a1080ebf33a..ca4b13f7c41 100644 --- a/src/caffe/layers/pooling_layer.cu +++ b/src/caffe/layers/pooling_layer.cu @@ -9,21 +9,21 @@ namespace caffe { template -__global__ void MaxPoolForward(const int nthreads, const Dtype* bottom_data, - const int num, const int channels, const int height, - const int width, const int pooled_height, const int pooled_width, - const int kernel_h, const int kernel_w, const int stride_h, - const int stride_w, const int pad_h, const int pad_w, Dtype* top_data, - int* mask, Dtype* top_mask) { +__global__ void MaxPoolForward(const int nthreads, + const Dtype* const bottom_data, const int num, const int channels, + const int height, const int width, const int pooled_height, + const int pooled_width, const int kernel_h, const int kernel_w, + const int stride_h, const int stride_w, const int pad_h, const int pad_w, + Dtype* const top_data, int* mask, Dtype* top_mask) { CUDA_KERNEL_LOOP(index, nthreads) { - int pw = index % pooled_width; - int ph = (index / pooled_width) % pooled_height; - int c = (index / pooled_width / pooled_height) % channels; - int n = index / pooled_width / pooled_height / channels; + const int pw = index % pooled_width; + const int ph = (index / pooled_width) % pooled_height; + const int c = (index / pooled_width / pooled_height) % channels; + const int n = index / pooled_width / pooled_height / channels; int hstart = ph * stride_h - pad_h; int wstart = pw * stride_w - pad_w; - int hend = min(hstart + kernel_h, height); - int wend = min(wstart + kernel_w, width); + const int hend = min(hstart + kernel_h, height); + const int wend = min(wstart + kernel_w, width); hstart = max(hstart, 0); wstart = max(wstart, 0); Dtype maxval = -FLT_MAX; @@ -48,21 +48,22 @@ __global__ void MaxPoolForward(const int nthreads, const Dtype* bottom_data, } template -__global__ void AvePoolForward(const int nthreads, const Dtype* bottom_data, - const int num, const int channels, const int height, - const int width, const int pooled_height, const int pooled_width, - const int kernel_h, const int kernel_w, const int stride_h, - const int stride_w, const int pad_h, const int pad_w, Dtype* top_data) { +__global__ void AvePoolForward(const int nthreads, + const Dtype* const bottom_data, const int num, const int channels, + const int height, const int width, const int pooled_height, + const int pooled_width, const int kernel_h, const int kernel_w, + const int stride_h, const int stride_w, const int pad_h, const int pad_w, + Dtype* const top_data) { CUDA_KERNEL_LOOP(index, nthreads) { - int pw = index % pooled_width; - int ph = (index / pooled_width) % pooled_height; - int c = (index / pooled_width / pooled_height) % channels; - int n = index / pooled_width / pooled_height / channels; + const int pw = index % pooled_width; + const int ph = (index / pooled_width) % pooled_height; + const int c = (index / pooled_width / pooled_height) % channels; + const int n = index / pooled_width / pooled_height / channels; int hstart = ph * stride_h - pad_h; int wstart = pw * stride_w - pad_w; int hend = min(hstart + kernel_h, height + pad_h); int wend = min(wstart + kernel_w, width + pad_w); - int pool_size = (hend - hstart) * (wend - wstart); + const int pool_size = (hend - hstart) * (wend - wstart); hstart = max(hstart, 0); wstart = max(wstart, 0); hend = min(hend, height); @@ -81,20 +82,20 @@ __global__ void AvePoolForward(const int nthreads, const Dtype* bottom_data, template __global__ void StoPoolForwardTrain(const int nthreads, - const Dtype* bottom_data, + const Dtype* const bottom_data, const int num, const int channels, const int height, const int width, const int pooled_height, const int pooled_width, const int kernel_h, const int kernel_w, const int stride_h, - const int stride_w, Dtype* rand_idx, Dtype* top_data) { + const int stride_w, Dtype* const rand_idx, Dtype* const top_data) { CUDA_KERNEL_LOOP(index, nthreads) { - int pw = index % pooled_width; - int ph = (index / pooled_width) % pooled_height; - int c = (index / pooled_width / pooled_height) % channels; - int n = index / pooled_width / pooled_height / channels; - int hstart = ph * stride_h; - int hend = min(hstart + kernel_h, height); - int wstart = pw * stride_w; - int wend = min(wstart + kernel_w, width); + const int pw = index % pooled_width; + const int ph = (index / pooled_width) % pooled_height; + const int c = (index / pooled_width / pooled_height) % channels; + const int n = index / pooled_width / pooled_height / channels; + const int hstart = ph * stride_h; + const int hend = min(hstart + kernel_h, height); + const int wstart = pw * stride_w; + const int wend = min(wstart + kernel_w, width); Dtype cumsum = 0.; const Dtype* const bottom_slice = bottom_data + (n * channels + c) * height * width; @@ -104,7 +105,7 @@ __global__ void StoPoolForwardTrain(const int nthreads, cumsum += bottom_slice[h * width + w]; } } - float thres = rand_idx[index] * cumsum; + const float thres = rand_idx[index] * cumsum; // Second pass: get value, and set index. cumsum = 0; for (int h = hstart; h < hend; ++h) { @@ -123,20 +124,20 @@ __global__ void StoPoolForwardTrain(const int nthreads, template __global__ void StoPoolForwardTest(const int nthreads, - const Dtype* bottom_data, + const Dtype* const bottom_data, const int num, const int channels, const int height, const int width, const int pooled_height, const int pooled_width, const int kernel_h, const int kernel_w, const int stride_h, - const int stride_w, Dtype* top_data) { + const int stride_w, Dtype* const top_data) { CUDA_KERNEL_LOOP(index, nthreads) { - int pw = index % pooled_width; - int ph = (index / pooled_width) % pooled_height; - int c = (index / pooled_width / pooled_height) % channels; - int n = index / pooled_width / pooled_height / channels; - int hstart = ph * stride_h; - int hend = min(hstart + kernel_h, height); - int wstart = pw * stride_w; - int wend = min(wstart + kernel_w, width); + const int pw = index % pooled_width; + const int ph = (index / pooled_width) % pooled_height; + const int c = (index / pooled_width / pooled_height) % channels; + const int n = index / pooled_width / pooled_height / channels; + const int hstart = ph * stride_h; + const int hend = min(hstart + kernel_h, height); + const int wstart = pw * stride_w; + const int wend = min(wstart + kernel_w, width); // We set cumsum to be 0 to avoid divide-by-zero problems Dtype cumsum = FLT_MIN; Dtype cumvalues = 0.; @@ -214,27 +215,27 @@ void PoolingLayer::Forward_gpu(const vector*>& bottom, template -__global__ void MaxPoolBackward(const int nthreads, const Dtype* top_diff, - const int* mask, const Dtype* top_mask, const int num, const int channels, - const int height, const int width, const int pooled_height, - const int pooled_width, const int kernel_h, const int kernel_w, - const int stride_h, const int stride_w, const int pad_h, const int pad_w, - Dtype* bottom_diff) { +__global__ void MaxPoolBackward(const int nthreads, const Dtype* const top_diff, + const int* const mask, const Dtype* const top_mask, const int num, + const int channels, const int height, const int width, + const int pooled_height, const int pooled_width, const int kernel_h, + const int kernel_w, const int stride_h, const int stride_w, const int pad_h, + const int pad_w, Dtype* const bottom_diff) { CUDA_KERNEL_LOOP(index, nthreads) { // find out the local index // find out the local offset - int w = index % width; - int h = (index / width) % height; - int c = (index / width / height) % channels; - int n = index / width / height / channels; - int phstart = - (h + pad_h < kernel_h) ? 0 : (h + pad_h - kernel_h) / stride_h + 1; - int phend = min((h + pad_h) / stride_h + 1, pooled_height); - int pwstart = - (w + pad_w < kernel_w) ? 0 : (w + pad_w - kernel_w) / stride_w + 1; - int pwend = min((w + pad_w) / stride_w + 1, pooled_width); + const int w = index % width; + const int h = (index / width) % height; + const int c = (index / width / height) % channels; + const int n = index / width / height / channels; + const int phstart = + (h + pad_h < kernel_h) ? 0 : (h + pad_h - kernel_h) / stride_h + 1; + const int phend = min((h + pad_h) / stride_h + 1, pooled_height); + const int pwstart = + (w + pad_w < kernel_w) ? 0 : (w + pad_w - kernel_w) / stride_w + 1; + const int pwend = min((w + pad_w) / stride_w + 1, pooled_width); Dtype gradient = 0; - int offset = (n * channels + c) * pooled_height * pooled_width; + const int offset = (n * channels + c) * pooled_height * pooled_width; const Dtype* const top_diff_slice = top_diff + offset; if (mask) { const int* const mask_slice = mask + offset; @@ -260,23 +261,23 @@ __global__ void MaxPoolBackward(const int nthreads, const Dtype* top_diff, } template -__global__ void AvePoolBackward(const int nthreads, const Dtype* top_diff, +__global__ void AvePoolBackward(const int nthreads, const Dtype* const top_diff, const int num, const int channels, const int height, const int width, const int pooled_height, const int pooled_width, const int kernel_h, const int kernel_w, const int stride_h, const int stride_w, const int pad_h, const int pad_w, - Dtype* bottom_diff) { + Dtype* const bottom_diff) { CUDA_KERNEL_LOOP(index, nthreads) { // find out the local index // find out the local offset - int w = index % width + pad_w; - int h = (index / width) % height + pad_h; - int c = (index / width / height) % channels; - int n = index / width / height / channels; - int phstart = (h < kernel_h) ? 0 : (h - kernel_h) / stride_h + 1; - int phend = min(h / stride_h + 1, pooled_height); - int pwstart = (w < kernel_w) ? 0 : (w - kernel_w) / stride_w + 1; - int pwend = min(w / stride_w + 1, pooled_width); + const int w = index % width + pad_w; + const int h = (index / width) % height + pad_h; + const int c = (index / width / height) % channels; + const int n = index / width / height / channels; + const int phstart = (h < kernel_h) ? 0 : (h - kernel_h) / stride_h + 1; + const int phend = min(h / stride_h + 1, pooled_height); + const int pwstart = (w < kernel_w) ? 0 : (w - kernel_w) / stride_w + 1; + const int pwend = min(w / stride_w + 1, pooled_width); Dtype gradient = 0; const Dtype* const top_diff_slice = top_diff + (n * channels + c) * pooled_height * pooled_width; @@ -298,22 +299,22 @@ __global__ void AvePoolBackward(const int nthreads, const Dtype* top_diff, template __global__ void StoPoolBackward(const int nthreads, - const Dtype* rand_idx, const Dtype* top_diff, + const Dtype* const rand_idx, const Dtype* const top_diff, const int num, const int channels, const int height, const int width, const int pooled_height, const int pooled_width, const int kernel_h, const int kernel_w, const int stride_h, - const int stride_w, Dtype* bottom_diff) { + const int stride_w, Dtype* const bottom_diff) { CUDA_KERNEL_LOOP(index, nthreads) { // find out the local index // find out the local offset - int w = index % width; - int h = (index / width) % height; - int c = (index / width / height) % channels; - int n = index / width / height / channels; - int phstart = (h < kernel_h) ? 0 : (h - kernel_h) / stride_h + 1; - int phend = min(h / stride_h + 1, pooled_height); - int pwstart = (w < kernel_w) ? 0 : (w - kernel_w) / stride_w + 1; - int pwend = min(w / stride_w + 1, pooled_width); + const int w = index % width; + const int h = (index / width) % height; + const int c = (index / width / height) % channels; + const int n = index / width / height / channels; + const int phstart = (h < kernel_h) ? 0 : (h - kernel_h) / stride_h + 1; + const int phend = min(h / stride_h + 1, pooled_height); + const int pwstart = (w < kernel_w) ? 0 : (w - kernel_w) / stride_w + 1; + const int pwend = min(w / stride_w + 1, pooled_width); Dtype gradient = 0; const Dtype* const rand_idx_slice = rand_idx + (n * channels + c) * pooled_height * pooled_width; From 5a6b0d6883df97a8f329f5ba7615b0a74b6ea651 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Tue, 19 May 2015 22:59:27 -0700 Subject: [PATCH 021/331] more const in LRN layer CUDA kernels --- src/caffe/layers/lrn_layer.cu | 44 +++++++++++++++++------------------ 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/src/caffe/layers/lrn_layer.cu b/src/caffe/layers/lrn_layer.cu index e50ae8df83b..001b3c34ac1 100644 --- a/src/caffe/layers/lrn_layer.cu +++ b/src/caffe/layers/lrn_layer.cu @@ -7,22 +7,22 @@ namespace caffe { template -__global__ void LRNFillScale(const int nthreads, const Dtype* in, +__global__ void LRNFillScale(const int nthreads, const Dtype* const in, const int num, const int channels, const int height, const int width, const int size, const Dtype alpha_over_size, - const Dtype k, Dtype* scale) { + const Dtype k, Dtype* const scale) { CUDA_KERNEL_LOOP(index, nthreads) { // find out the local offset - int w = index % width; - int h = (index / width) % height; - int n = index / width / height; - int offset = (n * channels * height + h) * width + w; - int step = height * width; + const int w = index % width; + const int h = (index / width) % height; + const int n = index / width / height; + const int offset = (n * channels * height + h) * width + w; + const int step = height * width; const Dtype* const in_off = in + offset; Dtype* const scale_off = scale + offset; int head = 0; - int pre_pad = (size - 1) / 2; - int post_pad = size - pre_pad - 1; + const int pre_pad = (size - 1) / 2; + const int post_pad = size - pre_pad - 1; Dtype accum_scale = 0; // fill the scale at [n, :, h, w] // accumulate values @@ -70,8 +70,8 @@ void LRNLayer::Forward_gpu(const vector*>& bottom, // TODO: check if it would be faster to just put it into the previous kernel. template -__global__ void LRNComputeOutput(const int nthreads, const Dtype* in, - const Dtype* scale, const Dtype negative_beta, Dtype* out) { +__global__ void LRNComputeOutput(const int nthreads, const Dtype* const in, + const Dtype* const scale, const Dtype negative_beta, Dtype* const out) { CUDA_KERNEL_LOOP(index, nthreads) { out[index] = in[index] * pow(scale[index], negative_beta); } @@ -120,27 +120,27 @@ void LRNLayer::Backward_gpu(const vector*>& top, } template -__global__ void LRNComputeDiff(const int nthreads, const Dtype* bottom_data, - const Dtype* top_data, const Dtype* scale, const Dtype* top_diff, +__global__ void LRNComputeDiff(const int nthreads, + const Dtype* const bottom_data, const Dtype* const top_data, + const Dtype* const scale, const Dtype* const top_diff, const int num, const int channels, const int height, const int width, const int size, const Dtype negative_beta, - const Dtype cache_ratio, - Dtype* bottom_diff) { + const Dtype cache_ratio, Dtype* const bottom_diff) { CUDA_KERNEL_LOOP(index, nthreads) { // find out the local offset - int w = index % width; - int h = (index / width) % height; - int n = index / width / height; - int offset = (n * channels * height + h) * width + w; - int step = height * width; + const int w = index % width; + const int h = (index / width) % height; + const int n = index / width / height; + const int offset = (n * channels * height + h) * width + w; + const int step = height * width; const Dtype* const bottom_off = bottom_data + offset; const Dtype* const top_off = top_data + offset; const Dtype* const scale_off = scale + offset; const Dtype* const top_diff_off = top_diff + offset; Dtype* const bottom_diff_off = bottom_diff + offset; int head = 0; - int pre_pad = size - (size + 1) / 2; - int post_pad = size - pre_pad - 1; + const int pre_pad = size - (size + 1) / 2; + const int post_pad = size - pre_pad - 1; Dtype accum_ratio = 0; // accumulate values while (head < post_pad && head < channels) { From 74a8aefaf7082601ca611f12380386633b5ba643 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Ram=C3=ADrez?= Date: Thu, 21 May 2015 20:19:59 -0500 Subject: [PATCH 022/331] Update python/requirements.txt to have ipython>=3.0.0 --- python/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/requirements.txt b/python/requirements.txt index 7bc164a42b5..e0c86c7e51e 100644 --- a/python/requirements.txt +++ b/python/requirements.txt @@ -3,7 +3,7 @@ numpy>=1.7.1 scipy>=0.13.2 scikit-image>=0.9.3 matplotlib>=1.3.1 -ipython>=1.1.0 +ipython>=3.0.0 h5py>=2.2.0 leveldb>=0.191 networkx>=1.8.1 From 65af68d8914b6f509f776a9ffae785127c477fa7 Mon Sep 17 00:00:00 2001 From: Nick Carlevaris-Bianco Date: Mon, 16 Feb 2015 15:49:43 +1030 Subject: [PATCH 023/331] Added MSRAFiller, an Xavier-like filler designed for use with ReLUs ...instead of tanh. Based on paper: He et al, "Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification," 2015. - add VarianceNorm option to FillerParameters which allows one to normalize by fan_in, fan_out or their average. - update XavierFiller to use the VarianceNorm option (default behavior unchanged). - add tests for MSRAFiller and XavierFiller. --- include/caffe/filler.hpp | 68 +++++++++++++++++++---- src/caffe/proto/caffe.proto | 8 +++ src/caffe/test/test_filler.cpp | 98 ++++++++++++++++++++++++++++++++++ 3 files changed, 165 insertions(+), 9 deletions(-) diff --git a/include/caffe/filler.hpp b/include/caffe/filler.hpp index eebf565b1d5..0125b3093f2 100644 --- a/include/caffe/filler.hpp +++ b/include/caffe/filler.hpp @@ -127,17 +127,18 @@ class PositiveUnitballFiller : public Filler { }; /** - * @brief Fills a Blob with values @f$ x \sim U(-a, +a) @f$ where @f$ a @f$ - * is set inversely proportional to the number of incoming nodes. + * @brief Fills a Blob with values @f$ x \sim U(-a, +a) @f$ where @f$ a @f$ is + * set inversely proportional to number of incoming nodes, outgoing + * nodes, or their average. * * A Filler based on the paper [Bengio and Glorot 2010]: Understanding - * the difficulty of training deep feedforward neuralnetworks, but does not - * use the fan_out value. + * the difficulty of training deep feedforward neuralnetworks. * - * It fills the incoming matrix by randomly sampling uniform data from - * [-scale, scale] where scale = sqrt(3 / fan_in) where fan_in is the number - * of input nodes. You should make sure the input blob has shape (num, a, b, c) - * where a * b * c = fan_in. + * It fills the incoming matrix by randomly sampling uniform data from [-scale, + * scale] where scale = sqrt(3 / n) where n is the fan_in, fan_out, or their + * average, depending on the variance_norm option. You should make sure the + * input blob has shape (num, a, b, c) where a * b * c = fan_in and num * b * c + * = fan_out. Note that this is currently not the case for inner product layers. * * TODO(dox): make notation in above comment consistent with rest & use LaTeX. */ @@ -149,7 +150,16 @@ class XavierFiller : public Filler { virtual void Fill(Blob* blob) { CHECK(blob->count()); int fan_in = blob->count() / blob->num(); - Dtype scale = sqrt(Dtype(3) / fan_in); + int fan_out = blob->count() / blob->channels(); + Dtype n = fan_in; // default to fan_in + if (this->filler_param_.variance_norm() == + FillerParameter_VarianceNorm_AVERAGE) { + n = (fan_in + fan_out) / Dtype(2); + } else if (this->filler_param_.variance_norm() == + FillerParameter_VarianceNorm_FAN_OUT) { + n = fan_out; + } + Dtype scale = sqrt(Dtype(3) / n); caffe_rng_uniform(blob->count(), -scale, scale, blob->mutable_cpu_data()); CHECK_EQ(this->filler_param_.sparse(), -1) @@ -157,6 +167,44 @@ class XavierFiller : public Filler { } }; +/** + * @brief Fills a Blob with values @f$ x \sim N(0, \sigma^2) @f$ where + * @f$ \sigma^2 @f$ is set inversely proportional to number of incoming + * nodes, outgoing nodes, or their average. + * + * A Filler based on the paper [He, Zhang, Ren and Sun 2015]: Specifically + * accounts for ReLU nonlinearities. + * + * It fills the incoming matrix by randomly sampling Gaussian data with std = + * sqrt(2 / n) where n is the fan_in, fan_out, or their average, depending on + * the variance_norm option. You should make sure the input blob has shape (num, + * a, b, c) where a * b * c = fan_in and num * b * c = fan_out. Note that this + * is currently not the case for inner product layers. + */ +template +class MSRAFiller : public Filler { + public: + explicit MSRAFiller(const FillerParameter& param) + : Filler(param) {} + virtual void Fill(Blob* blob) { + CHECK(blob->count()); + int fan_in = blob->count() / blob->num(); + int fan_out = blob->count() / blob->channels(); + Dtype n = fan_in; // default to fan_in + if (this->filler_param_.variance_norm() == + FillerParameter_VarianceNorm_AVERAGE) { + n = (fan_in + fan_out) / Dtype(2); + } else if (this->filler_param_.variance_norm() == + FillerParameter_VarianceNorm_FAN_OUT) { + n = fan_out; + } + Dtype std = sqrt(Dtype(2) / n); + caffe_rng_gaussian(blob->count(), Dtype(0), std, + blob->mutable_cpu_data()); + CHECK_EQ(this->filler_param_.sparse(), -1) + << "Sparsity not supported by this Filler."; + } +}; /** * @brief Get a specific filler from the specification given in FillerParameter. @@ -177,6 +225,8 @@ Filler* GetFiller(const FillerParameter& param) { return new UniformFiller(param); } else if (type == "xavier") { return new XavierFiller(param); + } else if (type == "msra") { + return new MSRAFiller(param); } else { CHECK(false) << "Unknown filler name: " << param.type(); } diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 84b475ce3cd..f9d4d614d10 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -41,6 +41,14 @@ message FillerParameter { // The expected number of non-zero output weights for a given input in // Gaussian filler -- the default -1 means don't perform sparsification. optional int32 sparse = 7 [default = -1]; + // Normalize the filler variance by fan_in, fan_out, or their average. + // Applies to 'xavier' and 'msra' fillers. + enum VarianceNorm { + FAN_IN = 0; + FAN_OUT = 1; + AVERAGE = 2; + } + optional VarianceNorm variance_norm = 8 [default = FAN_IN]; } message NetParameter { diff --git a/src/caffe/test/test_filler.cpp b/src/caffe/test/test_filler.cpp index e04b0fd22af..728b8dc5f0d 100644 --- a/src/caffe/test/test_filler.cpp +++ b/src/caffe/test/test_filler.cpp @@ -142,4 +142,102 @@ TYPED_TEST(GaussianFillerTest, TestFill) { EXPECT_LE(var, target_var * 5.); } +template +class XavierFillerTest : public ::testing::Test { + protected: + XavierFillerTest() + : blob_(new Blob(1000, 2, 4, 5)), + filler_param_() { + } + virtual void test_params(FillerParameter_VarianceNorm variance_norm, + Dtype n) { + this->filler_param_.set_variance_norm(variance_norm); + this->filler_.reset(new XavierFiller(this->filler_param_)); + this->filler_->Fill(blob_); + EXPECT_TRUE(this->blob_); + const int count = this->blob_->count(); + const Dtype* data = this->blob_->cpu_data(); + Dtype mean = 0.; + Dtype ex2 = 0.; + for (int i = 0; i < count; ++i) { + mean += data[i]; + ex2 += data[i] * data[i]; + } + mean /= count; + ex2 /= count; + Dtype std = sqrt(ex2 - mean*mean); + Dtype target_std = sqrt(2.0 / n); + EXPECT_NEAR(mean, 0.0, 0.1); + EXPECT_NEAR(std, target_std, 0.1); + } + virtual ~XavierFillerTest() { delete blob_; } + Blob* const blob_; + FillerParameter filler_param_; + shared_ptr > filler_; +}; + +TYPED_TEST_CASE(XavierFillerTest, TestDtypes); + +TYPED_TEST(XavierFillerTest, TestFillFanIn) { + TypeParam n = 2*4*5; + this->test_params(FillerParameter_VarianceNorm_FAN_IN, n); +} +TYPED_TEST(XavierFillerTest, TestFillFanOut) { + TypeParam n = 1000*4*5; + this->test_params(FillerParameter_VarianceNorm_FAN_OUT, n); +} +TYPED_TEST(XavierFillerTest, TestFillAverage) { + TypeParam n = (2*4*5 + 1000*4*5) / 2.0; + this->test_params(FillerParameter_VarianceNorm_AVERAGE, n); +} + +template +class MSRAFillerTest : public ::testing::Test { + protected: + MSRAFillerTest() + : blob_(new Blob(1000, 2, 4, 5)), + filler_param_() { + } + virtual void test_params(FillerParameter_VarianceNorm variance_norm, + Dtype n) { + this->filler_param_.set_variance_norm(variance_norm); + this->filler_.reset(new MSRAFiller(this->filler_param_)); + this->filler_->Fill(blob_); + EXPECT_TRUE(this->blob_); + const int count = this->blob_->count(); + const Dtype* data = this->blob_->cpu_data(); + Dtype mean = 0.; + Dtype ex2 = 0.; + for (int i = 0; i < count; ++i) { + mean += data[i]; + ex2 += data[i] * data[i]; + } + mean /= count; + ex2 /= count; + Dtype std = sqrt(ex2 - mean*mean); + Dtype target_std = sqrt(2.0 / n); + EXPECT_NEAR(mean, 0.0, 0.1); + EXPECT_NEAR(std, target_std, 0.1); + } + virtual ~MSRAFillerTest() { delete blob_; } + Blob* const blob_; + FillerParameter filler_param_; + shared_ptr > filler_; +}; + +TYPED_TEST_CASE(MSRAFillerTest, TestDtypes); + +TYPED_TEST(MSRAFillerTest, TestFillFanIn) { + TypeParam n = 2*4*5; + this->test_params(FillerParameter_VarianceNorm_FAN_IN, n); +} +TYPED_TEST(MSRAFillerTest, TestFillFanOut) { + TypeParam n = 1000*4*5; + this->test_params(FillerParameter_VarianceNorm_FAN_OUT, n); +} +TYPED_TEST(MSRAFillerTest, TestFillAverage) { + TypeParam n = (2*4*5 + 1000*4*5) / 2.0; + this->test_params(FillerParameter_VarianceNorm_AVERAGE, n); +} + } // namespace caffe From 59de6c7190eb57bfa7511ede30c965c1d5963a06 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Tue, 26 May 2015 12:39:14 -0700 Subject: [PATCH 024/331] include comment on Saxe and sqrt(2) scaling factor although different and independent, the derivation of Saxe et al. with regards to the scaling factor might be of interest. --- include/caffe/filler.hpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/include/caffe/filler.hpp b/include/caffe/filler.hpp index 0125b3093f2..446f5b5c4eb 100644 --- a/include/caffe/filler.hpp +++ b/include/caffe/filler.hpp @@ -175,6 +175,9 @@ class XavierFiller : public Filler { * A Filler based on the paper [He, Zhang, Ren and Sun 2015]: Specifically * accounts for ReLU nonlinearities. * + * Aside: for another perspective on the scaling factor, see the derivation of + * [Saxe, McClelland, and Ganguli 2013 (v3)]. + * * It fills the incoming matrix by randomly sampling Gaussian data with std = * sqrt(2 / n) where n is the fan_in, fan_out, or their average, depending on * the variance_norm option. You should make sure the input blob has shape (num, From 9ea3da42fec3d1ec54de7ad064ae5070cdede524 Mon Sep 17 00:00:00 2001 From: Mohammad Norouzi Date: Tue, 26 May 2015 17:25:56 -0400 Subject: [PATCH 025/331] add leading zeros to keys in feature DB files --- tools/extract_features.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/extract_features.cpp b/tools/extract_features.cpp index 364c436dfd8..1ffbfbed08d 100644 --- a/tools/extract_features.cpp +++ b/tools/extract_features.cpp @@ -157,7 +157,7 @@ int feature_extraction_pipeline(int argc, char** argv) { for (int d = 0; d < dim_features; ++d) { datum.add_float_data(feature_blob_data[d]); } - int length = snprintf(key_str, kMaxKeyStrLength, "%d", + int length = snprintf(key_str, kMaxKeyStrLength, "%010d", image_indices[i]); string out; CHECK(datum.SerializeToString(&out)); From ca816676ac9caf28c8627980549a2e12aa529294 Mon Sep 17 00:00:00 2001 From: Cyprien Noel Date: Mon, 18 May 2015 18:30:00 -0700 Subject: [PATCH 026/331] Refactor solvers regularization and logging code --- include/caffe/solver.hpp | 12 +- src/caffe/solver.cpp | 500 ++++++++++++++++----------------------- 2 files changed, 214 insertions(+), 298 deletions(-) diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index 4dcdc3dc20b..c92067917c8 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -39,8 +39,8 @@ class Solver { int iter() { return iter_; } protected: - // Get the update value for the current iteration. - virtual void ComputeUpdateValue() = 0; + // Get and apply the update value for the current iteration. + virtual void MakeUpdate() = 0; // The Solver::Snapshot function implements the basic snapshotting utility // that stores the learned net. You should implement the SnapshotSolverState() // function that produces a SolverState protocol buffer that needs to be @@ -80,7 +80,9 @@ class SGDSolver : public Solver { protected: void PreSolve(); Dtype GetLearningRate(); - virtual void ComputeUpdateValue(); + virtual void MakeUpdate(); + virtual void Regularize(int param_id); + virtual void ComputeUpdateValue(int param_id, Dtype rate); virtual void ClipGradients(); virtual void SnapshotSolverState(SolverState * state); virtual void RestoreSolverState(const SolverState& state); @@ -102,7 +104,7 @@ class NesterovSolver : public SGDSolver { : SGDSolver(param_file) {} protected: - virtual void ComputeUpdateValue(); + virtual void ComputeUpdateValue(int param_id, Dtype rate); DISABLE_COPY_AND_ASSIGN(NesterovSolver); }; @@ -116,7 +118,7 @@ class AdaGradSolver : public SGDSolver { : SGDSolver(param_file) { constructor_sanity_check(); } protected: - virtual void ComputeUpdateValue(); + virtual void ComputeUpdateValue(int param_id, Dtype rate); void constructor_sanity_check() { CHECK_EQ(0, this->param_.momentum()) << "Momentum cannot be used with AdaGrad."; diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 877b19b86f8..88f6d314fc7 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -207,8 +207,7 @@ void Solver::Step(int iters) { } } } - ComputeUpdateValue(); - net_->Update(); + MakeUpdate(); // Increment the internal iter_ counter -- its value should always indicate // the number of times the weights have been updated. @@ -456,95 +455,118 @@ void SGDSolver::ClipGradients() { } template -void SGDSolver::ComputeUpdateValue() { - const vector > >& net_params = this->net_->params(); - const vector& net_params_lr = this->net_->params_lr(); - const vector& net_params_weight_decay = - this->net_->params_weight_decay(); - // get the learning rate +void SGDSolver::MakeUpdate() { Dtype rate = GetLearningRate(); if (this->param_.display() && this->iter_ % this->param_.display() == 0) { LOG(INFO) << "Iteration " << this->iter_ << ", lr = " << rate; } ClipGradients(); - Dtype momentum = this->param_.momentum(); + for (int param_id = 0; param_id < this->net_->params().size(); ++param_id) { + Regularize(param_id); + ComputeUpdateValue(param_id, rate); + } + this->net_->Update(); +} + +template +void SGDSolver::Regularize(int param_id) { + const vector > >& net_params = this->net_->params(); + const vector& net_params_weight_decay = + this->net_->params_weight_decay(); Dtype weight_decay = this->param_.weight_decay(); string regularization_type = this->param_.regularization_type(); switch (Caffe::mode()) { - case Caffe::CPU: - for (int param_id = 0; param_id < net_params.size(); ++param_id) { - // Compute the value to history, and then copy them to the blob's diff. - Dtype local_rate = rate * net_params_lr[param_id]; - Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; - - if (local_decay) { - if (regularization_type == "L2") { - // add weight decay - caffe_axpy(net_params[param_id]->count(), - local_decay, - net_params[param_id]->cpu_data(), - net_params[param_id]->mutable_cpu_diff()); - } else if (regularization_type == "L1") { - caffe_cpu_sign(net_params[param_id]->count(), - net_params[param_id]->cpu_data(), - temp_[param_id]->mutable_cpu_data()); - caffe_axpy(net_params[param_id]->count(), - local_decay, - temp_[param_id]->cpu_data(), - net_params[param_id]->mutable_cpu_diff()); - } else { - LOG(FATAL) << "Unknown regularization type: " << regularization_type; - } + case Caffe::CPU: { + Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; + if (local_decay) { + if (regularization_type == "L2") { + // add weight decay + caffe_axpy(net_params[param_id]->count(), + local_decay, + net_params[param_id]->cpu_data(), + net_params[param_id]->mutable_cpu_diff()); + } else if (regularization_type == "L1") { + caffe_cpu_sign(net_params[param_id]->count(), + net_params[param_id]->cpu_data(), + temp_[param_id]->mutable_cpu_data()); + caffe_axpy(net_params[param_id]->count(), + local_decay, + temp_[param_id]->cpu_data(), + net_params[param_id]->mutable_cpu_diff()); + } else { + LOG(FATAL) << "Unknown regularization type: " << regularization_type; } - - caffe_cpu_axpby(net_params[param_id]->count(), local_rate, - net_params[param_id]->cpu_diff(), momentum, - history_[param_id]->mutable_cpu_data()); - // copy - caffe_copy(net_params[param_id]->count(), - history_[param_id]->cpu_data(), - net_params[param_id]->mutable_cpu_diff()); } break; - case Caffe::GPU: + } + case Caffe::GPU: { #ifndef CPU_ONLY - for (int param_id = 0; param_id < net_params.size(); ++param_id) { - // Compute the value to history, and then copy them to the blob's diff. - Dtype local_rate = rate * net_params_lr[param_id]; - Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; - - if (local_decay) { - if (regularization_type == "L2") { - // add weight decay - caffe_gpu_axpy(net_params[param_id]->count(), - local_decay, - net_params[param_id]->gpu_data(), - net_params[param_id]->mutable_gpu_diff()); - } else if (regularization_type == "L1") { - caffe_gpu_sign(net_params[param_id]->count(), - net_params[param_id]->gpu_data(), - temp_[param_id]->mutable_gpu_data()); - caffe_gpu_axpy(net_params[param_id]->count(), - local_decay, - temp_[param_id]->gpu_data(), - net_params[param_id]->mutable_gpu_diff()); - } else { - LOG(FATAL) << "Unknown regularization type: " << regularization_type; - } + Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; + if (local_decay) { + if (regularization_type == "L2") { + // add weight decay + caffe_gpu_axpy(net_params[param_id]->count(), + local_decay, + net_params[param_id]->gpu_data(), + net_params[param_id]->mutable_gpu_diff()); + } else if (regularization_type == "L1") { + caffe_gpu_sign(net_params[param_id]->count(), + net_params[param_id]->gpu_data(), + temp_[param_id]->mutable_gpu_data()); + caffe_gpu_axpy(net_params[param_id]->count(), + local_decay, + temp_[param_id]->gpu_data(), + net_params[param_id]->mutable_gpu_diff()); + } else { + LOG(FATAL) << "Unknown regularization type: " << regularization_type; } - - caffe_gpu_axpby(net_params[param_id]->count(), local_rate, - net_params[param_id]->gpu_diff(), momentum, - history_[param_id]->mutable_gpu_data()); - // copy - caffe_copy(net_params[param_id]->count(), - history_[param_id]->gpu_data(), - net_params[param_id]->mutable_gpu_diff()); } #else NO_GPU; #endif break; + } + default: + LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode(); + } +} + +template +void SGDSolver::ComputeUpdateValue(int param_id, Dtype rate) { + const vector > >& net_params = this->net_->params(); + const vector& net_params_lr = this->net_->params_lr(); + Dtype momentum = this->param_.momentum(); + switch (Caffe::mode()) { + case Caffe::CPU: { + // Compute the value to history, and then copy them to the blob's diff. + Dtype local_rate = rate * net_params_lr[param_id]; + + caffe_cpu_axpby(net_params[param_id]->count(), local_rate, + net_params[param_id]->cpu_diff(), momentum, + history_[param_id]->mutable_cpu_data()); + // copy + caffe_copy(net_params[param_id]->count(), + history_[param_id]->cpu_data(), + net_params[param_id]->mutable_cpu_diff()); + break; + } + case Caffe::GPU: { +#ifndef CPU_ONLY + // Compute the value to history, and then copy them to the blob's diff. + Dtype local_rate = rate * net_params_lr[param_id]; + + caffe_gpu_axpby(net_params[param_id]->count(), local_rate, + net_params[param_id]->gpu_diff(), momentum, + history_[param_id]->mutable_gpu_data()); + // copy + caffe_copy(net_params[param_id]->count(), + history_[param_id]->gpu_data(), + net_params[param_id]->mutable_gpu_diff()); +#else + NO_GPU; +#endif + break; + } default: LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode(); } @@ -571,252 +593,144 @@ void SGDSolver::RestoreSolverState(const SolverState& state) { } template -void NesterovSolver::ComputeUpdateValue() { +void NesterovSolver::ComputeUpdateValue(int param_id, Dtype rate) { const vector > >& net_params = this->net_->params(); const vector& net_params_lr = this->net_->params_lr(); - const vector& net_params_weight_decay = - this->net_->params_weight_decay(); - // get the learning rate - Dtype rate = this->GetLearningRate(); - if (this->param_.display() && this->iter_ % this->param_.display() == 0) { - LOG(INFO) << "Iteration " << this->iter_ << ", lr = " << rate; - } - SGDSolver::ClipGradients(); Dtype momentum = this->param_.momentum(); - Dtype weight_decay = this->param_.weight_decay(); - string regularization_type = this->param_.regularization_type(); switch (Caffe::mode()) { - case Caffe::CPU: - for (int param_id = 0; param_id < net_params.size(); ++param_id) { - // save history momentum for stepping back - caffe_copy(net_params[param_id]->count(), - this->history_[param_id]->cpu_data(), - this->update_[param_id]->mutable_cpu_data()); - - Dtype local_rate = rate * net_params_lr[param_id]; - Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; - - if (local_decay) { - if (regularization_type == "L2") { - // add weight decay - caffe_axpy(net_params[param_id]->count(), - local_decay, - net_params[param_id]->cpu_data(), - net_params[param_id]->mutable_cpu_diff()); - } else if (regularization_type == "L1") { - caffe_cpu_sign(net_params[param_id]->count(), - net_params[param_id]->cpu_data(), - this->temp_[param_id]->mutable_cpu_data()); - caffe_axpy(net_params[param_id]->count(), - local_decay, - this->temp_[param_id]->cpu_data(), - net_params[param_id]->mutable_cpu_diff()); - } else { - LOG(FATAL) << "Unknown regularization type: " << regularization_type; - } - } - - // update history - caffe_cpu_axpby(net_params[param_id]->count(), local_rate, - net_params[param_id]->cpu_diff(), momentum, - this->history_[param_id]->mutable_cpu_data()); - - // compute udpate: step back then over step - caffe_cpu_axpby(net_params[param_id]->count(), Dtype(1) + momentum, - this->history_[param_id]->cpu_data(), -momentum, - this->update_[param_id]->mutable_cpu_data()); - - // copy - caffe_copy(net_params[param_id]->count(), - this->update_[param_id]->cpu_data(), - net_params[param_id]->mutable_cpu_diff()); - } + case Caffe::CPU: { + // save history momentum for stepping back + caffe_copy(net_params[param_id]->count(), + this->history_[param_id]->cpu_data(), + this->update_[param_id]->mutable_cpu_data()); + + Dtype local_rate = rate * net_params_lr[param_id]; + + // update history + caffe_cpu_axpby(net_params[param_id]->count(), local_rate, + net_params[param_id]->cpu_diff(), momentum, + this->history_[param_id]->mutable_cpu_data()); + + // compute update: step back then over step + caffe_cpu_axpby(net_params[param_id]->count(), Dtype(1) + momentum, + this->history_[param_id]->cpu_data(), -momentum, + this->update_[param_id]->mutable_cpu_data()); + + // copy + caffe_copy(net_params[param_id]->count(), + this->update_[param_id]->cpu_data(), + net_params[param_id]->mutable_cpu_diff()); break; - case Caffe::GPU: + } + case Caffe::GPU: { #ifndef CPU_ONLY - for (int param_id = 0; param_id < net_params.size(); ++param_id) { - // save history momentum for stepping back - caffe_copy(net_params[param_id]->count(), - this->history_[param_id]->gpu_data(), - this->update_[param_id]->mutable_gpu_data()); - - Dtype local_rate = rate * net_params_lr[param_id]; - Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; - - if (local_decay) { - if (regularization_type == "L2") { - // add weight decay - caffe_gpu_axpy(net_params[param_id]->count(), - local_decay, - net_params[param_id]->gpu_data(), - net_params[param_id]->mutable_gpu_diff()); - } else if (regularization_type == "L1") { - caffe_gpu_sign(net_params[param_id]->count(), - net_params[param_id]->gpu_data(), - this->temp_[param_id]->mutable_gpu_data()); - caffe_gpu_axpy(net_params[param_id]->count(), - local_decay, - this->temp_[param_id]->gpu_data(), - net_params[param_id]->mutable_gpu_diff()); - } else { - LOG(FATAL) << "Unknown regularization type: " << regularization_type; - } - } - - // update history - caffe_gpu_axpby(net_params[param_id]->count(), local_rate, - net_params[param_id]->gpu_diff(), momentum, - this->history_[param_id]->mutable_gpu_data()); - - // compute udpate: step back then over step - caffe_gpu_axpby(net_params[param_id]->count(), Dtype(1) + momentum, - this->history_[param_id]->gpu_data(), -momentum, - this->update_[param_id]->mutable_gpu_data()); - - // copy - caffe_copy(net_params[param_id]->count(), - this->update_[param_id]->gpu_data(), - net_params[param_id]->mutable_gpu_diff()); - } + // save history momentum for stepping back + caffe_copy(net_params[param_id]->count(), + this->history_[param_id]->gpu_data(), + this->update_[param_id]->mutable_gpu_data()); + + Dtype local_rate = rate * net_params_lr[param_id]; + + // update history + caffe_gpu_axpby(net_params[param_id]->count(), local_rate, + net_params[param_id]->gpu_diff(), momentum, + this->history_[param_id]->mutable_gpu_data()); + + // compute update: step back then over step + caffe_gpu_axpby(net_params[param_id]->count(), Dtype(1) + momentum, + this->history_[param_id]->gpu_data(), -momentum, + this->update_[param_id]->mutable_gpu_data()); + + // copy + caffe_copy(net_params[param_id]->count(), + this->update_[param_id]->gpu_data(), + net_params[param_id]->mutable_gpu_diff()); #else NO_GPU; #endif break; + } default: LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode(); } } template -void AdaGradSolver::ComputeUpdateValue() { +void AdaGradSolver::ComputeUpdateValue(int param_id, Dtype rate) { const vector > >& net_params = this->net_->params(); const vector& net_params_lr = this->net_->params_lr(); - const vector& net_params_weight_decay = - this->net_->params_weight_decay(); - // get the learning rate - Dtype rate = this->GetLearningRate(); Dtype delta = this->param_.delta(); - if (this->param_.display() && this->iter_ % this->param_.display() == 0) { - LOG(INFO) << "Iteration " << this->iter_ << ", lr = " << rate; - } - SGDSolver::ClipGradients(); - Dtype weight_decay = this->param_.weight_decay(); - string regularization_type = this->param_.regularization_type(); switch (Caffe::mode()) { - case Caffe::CPU: - for (int param_id = 0; param_id < net_params.size(); ++param_id) { - Dtype local_rate = rate * net_params_lr[param_id]; - Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; - - if (local_decay) { - if (regularization_type == "L2") { - // add weight decay - caffe_axpy(net_params[param_id]->count(), - local_decay, - net_params[param_id]->cpu_data(), - net_params[param_id]->mutable_cpu_diff()); - } else if (regularization_type == "L1") { - caffe_cpu_sign(net_params[param_id]->count(), - net_params[param_id]->cpu_data(), - this->temp_[param_id]->mutable_cpu_data()); - caffe_axpy(net_params[param_id]->count(), - local_decay, - this->temp_[param_id]->cpu_data(), - net_params[param_id]->mutable_cpu_diff()); - } else { - LOG(FATAL) << "Unknown regularization type: " << regularization_type; - } - } - - // compute square of gradient in update - caffe_powx(net_params[param_id]->count(), - net_params[param_id]->cpu_diff(), Dtype(2), - this->update_[param_id]->mutable_cpu_data()); - - // update history - caffe_add(net_params[param_id]->count(), - this->update_[param_id]->cpu_data(), - this->history_[param_id]->cpu_data(), - this->history_[param_id]->mutable_cpu_data()); - - // prepare update - caffe_powx(net_params[param_id]->count(), - this->history_[param_id]->cpu_data(), Dtype(0.5), - this->update_[param_id]->mutable_cpu_data()); - - caffe_add_scalar(net_params[param_id]->count(), - delta, this->update_[param_id]->mutable_cpu_data()); - - caffe_div(net_params[param_id]->count(), - net_params[param_id]->cpu_diff(), - this->update_[param_id]->cpu_data(), - this->update_[param_id]->mutable_cpu_data()); - - // scale and copy - caffe_cpu_axpby(net_params[param_id]->count(), local_rate, - this->update_[param_id]->cpu_data(), Dtype(0), - net_params[param_id]->mutable_cpu_diff()); - } + case Caffe::CPU: { + Dtype local_rate = rate * net_params_lr[param_id]; + + // compute square of gradient in update + caffe_powx(net_params[param_id]->count(), + net_params[param_id]->cpu_diff(), Dtype(2), + this->update_[param_id]->mutable_cpu_data()); + + // update history + caffe_add(net_params[param_id]->count(), + this->update_[param_id]->cpu_data(), + this->history_[param_id]->cpu_data(), + this->history_[param_id]->mutable_cpu_data()); + + // prepare update + caffe_powx(net_params[param_id]->count(), + this->history_[param_id]->cpu_data(), Dtype(0.5), + this->update_[param_id]->mutable_cpu_data()); + + caffe_add_scalar(net_params[param_id]->count(), + delta, this->update_[param_id]->mutable_cpu_data()); + + caffe_div(net_params[param_id]->count(), + net_params[param_id]->cpu_diff(), + this->update_[param_id]->cpu_data(), + this->update_[param_id]->mutable_cpu_data()); + + // scale and copy + caffe_cpu_axpby(net_params[param_id]->count(), local_rate, + this->update_[param_id]->cpu_data(), Dtype(0), + net_params[param_id]->mutable_cpu_diff()); break; - case Caffe::GPU: + } + case Caffe::GPU: { #ifndef CPU_ONLY - for (int param_id = 0; param_id < net_params.size(); ++param_id) { - Dtype local_rate = rate * net_params_lr[param_id]; - Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; - - if (local_decay) { - if (regularization_type == "L2") { - // add weight decay - caffe_gpu_axpy(net_params[param_id]->count(), - local_decay, - net_params[param_id]->gpu_data(), - net_params[param_id]->mutable_gpu_diff()); - } else if (regularization_type == "L1") { - caffe_gpu_sign(net_params[param_id]->count(), - net_params[param_id]->gpu_data(), - this->temp_[param_id]->mutable_gpu_data()); - caffe_gpu_axpy(net_params[param_id]->count(), - local_decay, - this->temp_[param_id]->gpu_data(), - net_params[param_id]->mutable_gpu_diff()); - } else { - LOG(FATAL) << "Unknown regularization type: " << regularization_type; - } - } - - // compute square of gradient in update - caffe_gpu_powx(net_params[param_id]->count(), - net_params[param_id]->gpu_diff(), Dtype(2), - this->update_[param_id]->mutable_gpu_data()); - - // update history - caffe_gpu_add(net_params[param_id]->count(), - this->update_[param_id]->gpu_data(), - this->history_[param_id]->gpu_data(), - this->history_[param_id]->mutable_gpu_data()); - - // prepare update - caffe_gpu_powx(net_params[param_id]->count(), - this->history_[param_id]->gpu_data(), Dtype(0.5), - this->update_[param_id]->mutable_gpu_data()); - - caffe_gpu_add_scalar(net_params[param_id]->count(), - delta, this->update_[param_id]->mutable_gpu_data()); - - caffe_gpu_div(net_params[param_id]->count(), - net_params[param_id]->gpu_diff(), - this->update_[param_id]->gpu_data(), - this->update_[param_id]->mutable_gpu_data()); - - // scale and copy - caffe_gpu_axpby(net_params[param_id]->count(), local_rate, - this->update_[param_id]->gpu_data(), Dtype(0), - net_params[param_id]->mutable_gpu_diff()); - } + Dtype local_rate = rate * net_params_lr[param_id]; + + // compute square of gradient in update + caffe_gpu_powx(net_params[param_id]->count(), + net_params[param_id]->gpu_diff(), Dtype(2), + this->update_[param_id]->mutable_gpu_data()); + + // update history + caffe_gpu_add(net_params[param_id]->count(), + this->update_[param_id]->gpu_data(), + this->history_[param_id]->gpu_data(), + this->history_[param_id]->mutable_gpu_data()); + + // prepare update + caffe_gpu_powx(net_params[param_id]->count(), + this->history_[param_id]->gpu_data(), Dtype(0.5), + this->update_[param_id]->mutable_gpu_data()); + + caffe_gpu_add_scalar(net_params[param_id]->count(), + delta, this->update_[param_id]->mutable_gpu_data()); + + caffe_gpu_div(net_params[param_id]->count(), + net_params[param_id]->gpu_diff(), + this->update_[param_id]->gpu_data(), + this->update_[param_id]->mutable_gpu_data()); + + // scale and copy + caffe_gpu_axpby(net_params[param_id]->count(), local_rate, + this->update_[param_id]->gpu_data(), Dtype(0), + net_params[param_id]->mutable_gpu_diff()); #else NO_GPU; #endif break; + } default: LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode(); } From a85f7f1955c434e46a39cbbc91df82601d5e9646 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Thu, 21 May 2015 16:34:43 -0700 Subject: [PATCH 027/331] deduplicate decay and local rate in solver updates --- src/caffe/solver.cpp | 23 +++++------------------ 1 file changed, 5 insertions(+), 18 deletions(-) diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 88f6d314fc7..6a0151837bb 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -475,9 +475,9 @@ void SGDSolver::Regularize(int param_id) { this->net_->params_weight_decay(); Dtype weight_decay = this->param_.weight_decay(); string regularization_type = this->param_.regularization_type(); + Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; switch (Caffe::mode()) { case Caffe::CPU: { - Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; if (local_decay) { if (regularization_type == "L2") { // add weight decay @@ -501,7 +501,6 @@ void SGDSolver::Regularize(int param_id) { } case Caffe::GPU: { #ifndef CPU_ONLY - Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; if (local_decay) { if (regularization_type == "L2") { // add weight decay @@ -536,15 +535,13 @@ void SGDSolver::ComputeUpdateValue(int param_id, Dtype rate) { const vector > >& net_params = this->net_->params(); const vector& net_params_lr = this->net_->params_lr(); Dtype momentum = this->param_.momentum(); + Dtype local_rate = rate * net_params_lr[param_id]; + // Compute the update to history, then copy it to the parameter diff. switch (Caffe::mode()) { case Caffe::CPU: { - // Compute the value to history, and then copy them to the blob's diff. - Dtype local_rate = rate * net_params_lr[param_id]; - caffe_cpu_axpby(net_params[param_id]->count(), local_rate, net_params[param_id]->cpu_diff(), momentum, history_[param_id]->mutable_cpu_data()); - // copy caffe_copy(net_params[param_id]->count(), history_[param_id]->cpu_data(), net_params[param_id]->mutable_cpu_diff()); @@ -552,13 +549,9 @@ void SGDSolver::ComputeUpdateValue(int param_id, Dtype rate) { } case Caffe::GPU: { #ifndef CPU_ONLY - // Compute the value to history, and then copy them to the blob's diff. - Dtype local_rate = rate * net_params_lr[param_id]; - caffe_gpu_axpby(net_params[param_id]->count(), local_rate, net_params[param_id]->gpu_diff(), momentum, history_[param_id]->mutable_gpu_data()); - // copy caffe_copy(net_params[param_id]->count(), history_[param_id]->gpu_data(), net_params[param_id]->mutable_gpu_diff()); @@ -597,6 +590,7 @@ void NesterovSolver::ComputeUpdateValue(int param_id, Dtype rate) { const vector > >& net_params = this->net_->params(); const vector& net_params_lr = this->net_->params_lr(); Dtype momentum = this->param_.momentum(); + Dtype local_rate = rate * net_params_lr[param_id]; switch (Caffe::mode()) { case Caffe::CPU: { // save history momentum for stepping back @@ -604,8 +598,6 @@ void NesterovSolver::ComputeUpdateValue(int param_id, Dtype rate) { this->history_[param_id]->cpu_data(), this->update_[param_id]->mutable_cpu_data()); - Dtype local_rate = rate * net_params_lr[param_id]; - // update history caffe_cpu_axpby(net_params[param_id]->count(), local_rate, net_params[param_id]->cpu_diff(), momentum, @@ -629,8 +621,6 @@ void NesterovSolver::ComputeUpdateValue(int param_id, Dtype rate) { this->history_[param_id]->gpu_data(), this->update_[param_id]->mutable_gpu_data()); - Dtype local_rate = rate * net_params_lr[param_id]; - // update history caffe_gpu_axpby(net_params[param_id]->count(), local_rate, net_params[param_id]->gpu_diff(), momentum, @@ -660,10 +650,9 @@ void AdaGradSolver::ComputeUpdateValue(int param_id, Dtype rate) { const vector > >& net_params = this->net_->params(); const vector& net_params_lr = this->net_->params_lr(); Dtype delta = this->param_.delta(); + Dtype local_rate = rate * net_params_lr[param_id]; switch (Caffe::mode()) { case Caffe::CPU: { - Dtype local_rate = rate * net_params_lr[param_id]; - // compute square of gradient in update caffe_powx(net_params[param_id]->count(), net_params[param_id]->cpu_diff(), Dtype(2), @@ -696,8 +685,6 @@ void AdaGradSolver::ComputeUpdateValue(int param_id, Dtype rate) { } case Caffe::GPU: { #ifndef CPU_ONLY - Dtype local_rate = rate * net_params_lr[param_id]; - // compute square of gradient in update caffe_gpu_powx(net_params[param_id]->count(), net_params[param_id]->gpu_diff(), Dtype(2), From e1cc9d3c78fb3a7cf779abf36c15dd0d38496d46 Mon Sep 17 00:00:00 2001 From: Mohammad Norouzi Date: Wed, 27 May 2015 10:33:19 -0400 Subject: [PATCH 028/331] fix the bug with db_type when the number of features to be extracted is larger than 1 --- tools/extract_features.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/extract_features.cpp b/tools/extract_features.cpp index 1ffbfbed08d..365dd495bbf 100644 --- a/tools/extract_features.cpp +++ b/tools/extract_features.cpp @@ -122,9 +122,10 @@ int feature_extraction_pipeline(int argc, char** argv) { std::vector > feature_dbs; std::vector > txns; + const char* db_type = argv[++arg_pos]; for (size_t i = 0; i < num_features; ++i) { LOG(INFO)<< "Opening dataset " << dataset_names[i]; - shared_ptr db(db::GetDB(argv[++arg_pos])); + shared_ptr db(db::GetDB(db_type)); db->Open(dataset_names.at(i), db::NEW); feature_dbs.push_back(db); shared_ptr txn(db->NewTransaction()); From 76db47e1de6159daa8e38b33d3930308e4078f66 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Wed, 27 May 2015 12:24:06 -0700 Subject: [PATCH 029/331] Solver::MakeUpdate() -> Solver::ApplyUpdate Designate `Solver::ApplyUpdate()` as the core method to compute and apply parameter updates given the current state of the Net. Make `Solver::ComputeUpdateValue()` a subordinate call overloaded by the `SGDSolver`s to take care of optimization algorithm details. --- include/caffe/solver.hpp | 8 ++++---- src/caffe/solver.cpp | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index c92067917c8..da1bab13663 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -11,7 +11,7 @@ namespace caffe { /** * @brief An interface for classes that perform optimization on Net%s. * - * Requires implementation of ComputeUpdateValue to compute a parameter update + * Requires implementation of ApplyUpdate to compute a parameter update * given the current state of the Net parameters. */ template @@ -39,8 +39,8 @@ class Solver { int iter() { return iter_; } protected: - // Get and apply the update value for the current iteration. - virtual void MakeUpdate() = 0; + // Make and apply the update value for the current iteration. + virtual void ApplyUpdate() = 0; // The Solver::Snapshot function implements the basic snapshotting utility // that stores the learned net. You should implement the SnapshotSolverState() // function that produces a SolverState protocol buffer that needs to be @@ -80,7 +80,7 @@ class SGDSolver : public Solver { protected: void PreSolve(); Dtype GetLearningRate(); - virtual void MakeUpdate(); + virtual void ApplyUpdate(); virtual void Regularize(int param_id); virtual void ComputeUpdateValue(int param_id, Dtype rate); virtual void ClipGradients(); diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 6a0151837bb..fa334edaa60 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -207,7 +207,7 @@ void Solver::Step(int iters) { } } } - MakeUpdate(); + ApplyUpdate(); // Increment the internal iter_ counter -- its value should always indicate // the number of times the weights have been updated. @@ -455,7 +455,7 @@ void SGDSolver::ClipGradients() { } template -void SGDSolver::MakeUpdate() { +void SGDSolver::ApplyUpdate() { Dtype rate = GetLearningRate(); if (this->param_.display() && this->iter_ % this->param_.display() == 0) { LOG(INFO) << "Iteration " << this->iter_ << ", lr = " << rate; From 41cf06cc6e40e1b41d04b5b26e19395611bdcf5d Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Mon, 11 Aug 2014 21:38:59 -0700 Subject: [PATCH 030/331] zero-init param diffs and accumulate gradients (With layers whose backward accumulates gradients), this effectively decouples the computational batch from the SGD minibatch. Each iteration accumulates gradients over iter_size batches, then parameters are updated. --- src/caffe/proto/caffe.proto | 4 +++- src/caffe/solver.cpp | 27 ++++++++++++++++++++++++++- 2 files changed, 29 insertions(+), 2 deletions(-) diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index c471fa0a93e..94836421a42 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -96,7 +96,7 @@ message NetParameter { // NOTE // Update the next available ID when you add a new SolverParameter field. // -// SolverParameter next available ID: 36 (last added: clip_gradients) +// SolverParameter next available ID: 37 (last added: iter_size) message SolverParameter { ////////////////////////////////////////////////////////////////////////////// // Specifying the train and test networks @@ -149,6 +149,8 @@ message SolverParameter { // Display the loss averaged over the last average_loss iterations optional int32 average_loss = 33 [default = 1]; optional int32 max_iter = 7; // the maximum number of iterations + // accumulate gradients over `iter_size` x `batch_size` instances + optional int32 iter_size = 36 [default = 1]; optional string lr_policy = 8; // The learning rate decay policy. optional float gamma = 9; // The parameter to compute the learning rate. optional float power = 10; // The parameter to compute the learning rate. diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index fa334edaa60..ad041b8f268 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -168,6 +168,25 @@ void Solver::Step(int iters) { Dtype smoothed_loss = 0; while (iter_ < stop_iter) { + // zero-init the params + for (int i = 0; i < net_->params().size(); ++i) { + shared_ptr > blob = net_->params()[i]; + switch(Caffe::mode()) { + case Caffe::CPU: + caffe_set(blob->count(), static_cast(0), + blob->mutable_cpu_diff()); + break; + case Caffe::GPU: +#ifndef CPU_ONLY + caffe_gpu_set(blob->count(), static_cast(0), + blob->mutable_gpu_diff()); +#else + NO_GPU; +#endif + break; + } + } + if (param_.test_interval() && iter_ % param_.test_interval() == 0 && (iter_ > 0 || param_.test_initialization())) { TestAll(); @@ -175,7 +194,13 @@ void Solver::Step(int iters) { const bool display = param_.display() && iter_ % param_.display() == 0; net_->set_debug_info(display && param_.debug_info()); - Dtype loss = net_->ForwardBackward(bottom_vec); + // accumulate the loss and gradient + Dtype loss = 0; + for (int i = 0; i < param_.iter_size(); ++i) { + loss += net_->ForwardBackward(bottom_vec); + } + loss /= param_.iter_size(); + // average the loss across iterations for smoothed reporting if (losses.size() < average_loss) { losses.push_back(loss); int size = losses.size(); From 539f8798233e25ac8110f545995f5b8f7340718f Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Tue, 30 Dec 2014 22:52:07 -0800 Subject: [PATCH 031/331] zero-init param diffs in gradient checker --- include/caffe/test/test_gradient_check_util.hpp | 7 +++++-- src/caffe/solver.cpp | 2 +- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/include/caffe/test/test_gradient_check_util.hpp b/include/caffe/test/test_gradient_check_util.hpp index 22937711b58..cc5dcbad0ee 100644 --- a/include/caffe/test/test_gradient_check_util.hpp +++ b/include/caffe/test/test_gradient_check_util.hpp @@ -80,11 +80,14 @@ void GradientChecker::CheckGradientSingle(Layer* layer, CHECK_EQ(top_count, bottom[blob_id]->count()); } } - // First, figure out what blobs we need to check against. + // First, figure out what blobs we need to check against, and zero init + // parameter blobs. vector*> blobs_to_check; vector propagate_down(bottom.size(), check_bottom < 0); for (int i = 0; i < layer->blobs().size(); ++i) { - blobs_to_check.push_back(layer->blobs()[i].get()); + Blob* blob = layer->blobs()[i].get(); + caffe_set(blob->count(), static_cast(0), blob->mutable_cpu_diff()); + blobs_to_check.push_back(blob); } if (check_bottom < 0) { for (int i = 0; i < bottom.size(); ++i) { diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index ad041b8f268..d104522002b 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -171,7 +171,7 @@ void Solver::Step(int iters) { // zero-init the params for (int i = 0; i < net_->params().size(); ++i) { shared_ptr > blob = net_->params()[i]; - switch(Caffe::mode()) { + switch (Caffe::mode()) { case Caffe::CPU: caffe_set(blob->count(), static_cast(0), blob->mutable_cpu_diff()); From 3262e464b06f1ecd8a04db1487cc5878c0cfd852 Mon Sep 17 00:00:00 2001 From: Sergio Date: Fri, 26 Sep 2014 23:03:26 -0700 Subject: [PATCH 032/331] accumulate gradients in inner product layer --- src/caffe/layers/inner_product_layer.cpp | 4 ++-- src/caffe/layers/inner_product_layer.cu | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/caffe/layers/inner_product_layer.cpp b/src/caffe/layers/inner_product_layer.cpp index 89e0c8fbad7..83c3235eb71 100644 --- a/src/caffe/layers/inner_product_layer.cpp +++ b/src/caffe/layers/inner_product_layer.cpp @@ -101,13 +101,13 @@ void InnerProductLayer::Backward_cpu(const vector*>& top, const Dtype* bottom_data = bottom[0]->cpu_data(); // Gradient with respect to weight caffe_cpu_gemm(CblasTrans, CblasNoTrans, N_, K_, M_, (Dtype)1., - top_diff, bottom_data, (Dtype)0., this->blobs_[0]->mutable_cpu_diff()); + top_diff, bottom_data, (Dtype)1., this->blobs_[0]->mutable_cpu_diff()); } if (bias_term_ && this->param_propagate_down_[1]) { const Dtype* top_diff = top[0]->cpu_diff(); // Gradient with respect to bias caffe_cpu_gemv(CblasTrans, M_, N_, (Dtype)1., top_diff, - bias_multiplier_.cpu_data(), (Dtype)0., + bias_multiplier_.cpu_data(), (Dtype)1., this->blobs_[1]->mutable_cpu_diff()); } if (propagate_down[0]) { diff --git a/src/caffe/layers/inner_product_layer.cu b/src/caffe/layers/inner_product_layer.cu index a9e1784a205..dd90cac12a8 100644 --- a/src/caffe/layers/inner_product_layer.cu +++ b/src/caffe/layers/inner_product_layer.cu @@ -33,13 +33,13 @@ void InnerProductLayer::Backward_gpu(const vector*>& top, const Dtype* bottom_data = bottom[0]->gpu_data(); // Gradient with respect to weight caffe_gpu_gemm(CblasTrans, CblasNoTrans, N_, K_, M_, (Dtype)1., - top_diff, bottom_data, (Dtype)0., this->blobs_[0]->mutable_gpu_diff()); + top_diff, bottom_data, (Dtype)1., this->blobs_[0]->mutable_gpu_diff()); } if (bias_term_ && this->param_propagate_down_[1]) { const Dtype* top_diff = top[0]->gpu_diff(); // Gradient with respect to bias caffe_gpu_gemv(CblasTrans, M_, N_, (Dtype)1., top_diff, - bias_multiplier_.gpu_data(), (Dtype)0., + bias_multiplier_.gpu_data(), (Dtype)1., this->blobs_[1]->mutable_gpu_diff()); } if (propagate_down[0]) { From 8cc9af01941cd8c7c32c664672e5f31106d2cc40 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Tue, 30 Dec 2014 22:29:35 -0800 Subject: [PATCH 033/331] accumulate gradients in (de)conv layers --- src/caffe/layers/conv_layer.cpp | 7 ------- src/caffe/layers/conv_layer.cu | 7 ------- src/caffe/layers/deconv_layer.cpp | 7 ------- src/caffe/layers/deconv_layer.cu | 7 ------- 4 files changed, 28 deletions(-) diff --git a/src/caffe/layers/conv_layer.cpp b/src/caffe/layers/conv_layer.cpp index c0c9f6f3371..928ef5ee468 100644 --- a/src/caffe/layers/conv_layer.cpp +++ b/src/caffe/layers/conv_layer.cpp @@ -39,13 +39,6 @@ void ConvolutionLayer::Backward_cpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { const Dtype* weight = this->blobs_[0]->cpu_data(); Dtype* weight_diff = this->blobs_[0]->mutable_cpu_diff(); - if (this->param_propagate_down_[0]) { - caffe_set(this->blobs_[0]->count(), Dtype(0), weight_diff); - } - if (this->bias_term_ && this->param_propagate_down_[1]) { - caffe_set(this->blobs_[1]->count(), Dtype(0), - this->blobs_[1]->mutable_cpu_diff()); - } for (int i = 0; i < top.size(); ++i) { const Dtype* top_diff = top[i]->cpu_diff(); const Dtype* bottom_data = bottom[i]->cpu_data(); diff --git a/src/caffe/layers/conv_layer.cu b/src/caffe/layers/conv_layer.cu index 3902fdf3930..b8a98ff7cc9 100644 --- a/src/caffe/layers/conv_layer.cu +++ b/src/caffe/layers/conv_layer.cu @@ -31,13 +31,6 @@ void ConvolutionLayer::Backward_gpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { const Dtype* weight = this->blobs_[0]->gpu_data(); Dtype* weight_diff = this->blobs_[0]->mutable_gpu_diff(); - if (this->param_propagate_down_[0]) { - caffe_gpu_set(this->blobs_[0]->count(), Dtype(0), weight_diff); - } - if (this->bias_term_ && this->param_propagate_down_[1]) { - caffe_gpu_set(this->blobs_[1]->count(), Dtype(0), - this->blobs_[1]->mutable_gpu_diff()); - } for (int i = 0; i < top.size(); ++i) { const Dtype* top_diff = top[i]->gpu_diff(); // Bias gradient, if necessary. diff --git a/src/caffe/layers/deconv_layer.cpp b/src/caffe/layers/deconv_layer.cpp index e6d65ab526b..a4612963b6b 100644 --- a/src/caffe/layers/deconv_layer.cpp +++ b/src/caffe/layers/deconv_layer.cpp @@ -39,13 +39,6 @@ void DeconvolutionLayer::Backward_cpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { const Dtype* weight = this->blobs_[0]->cpu_data(); Dtype* weight_diff = this->blobs_[0]->mutable_cpu_diff(); - if (this->param_propagate_down_[0]) { - caffe_set(this->blobs_[0]->count(), Dtype(0), weight_diff); - } - if (this->bias_term_ && this->param_propagate_down_[1]) { - caffe_set(this->blobs_[1]->count(), Dtype(0), - this->blobs_[1]->mutable_cpu_diff()); - } for (int i = 0; i < top.size(); ++i) { const Dtype* top_diff = top[i]->cpu_diff(); const Dtype* bottom_data = bottom[i]->cpu_data(); diff --git a/src/caffe/layers/deconv_layer.cu b/src/caffe/layers/deconv_layer.cu index 9198dd64c72..39bc4de8c66 100644 --- a/src/caffe/layers/deconv_layer.cu +++ b/src/caffe/layers/deconv_layer.cu @@ -31,13 +31,6 @@ void DeconvolutionLayer::Backward_gpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { const Dtype* weight = this->blobs_[0]->gpu_data(); Dtype* weight_diff = this->blobs_[0]->mutable_gpu_diff(); - if (this->param_propagate_down_[0]) { - caffe_gpu_set(this->blobs_[0]->count(), Dtype(0), weight_diff); - } - if (this->bias_term_ && this->param_propagate_down_[1]) { - caffe_gpu_set(this->blobs_[1]->count(), Dtype(0), - this->blobs_[1]->mutable_gpu_diff()); - } for (int i = 0; i < top.size(); ++i) { const Dtype* top_diff = top[i]->gpu_diff(); const Dtype* bottom_data = bottom[i]->gpu_data(); From 67b1ff3114320188b5046ff899d4fb0f87fd7b63 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Sat, 13 Sep 2014 17:41:59 -0700 Subject: [PATCH 034/331] accumulate gradients in cudnn conv layer --- src/caffe/layers/cudnn_conv_layer.cu | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index 4a1a4c4f4f2..b4e802e13d1 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -101,12 +101,10 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, if (this->param_propagate_down_[0]) { weight = this->blobs_[0]->gpu_data(); weight_diff = this->blobs_[0]->mutable_gpu_diff(); - caffe_gpu_set(this->blobs_[0]->count(), Dtype(0), weight_diff); } Dtype* bias_diff = NULL; if (this->bias_term_ && this->param_propagate_down_[1]) { bias_diff = this->blobs_[1]->mutable_gpu_diff(); - caffe_gpu_set(this->blobs_[1]->count(), Dtype(0), bias_diff); } for (int i = 0; i < top.size(); ++i) { const Dtype* top_diff = top[i]->gpu_diff(); From 55585f5bfab61328a61125b3d49627a69022d817 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Thu, 21 May 2015 17:06:42 -0700 Subject: [PATCH 035/331] adjust local learning rate and decay according to gradient accumulation Divide local rate by `iter_size` to normalize the gradient according to the full minibatch size and not only the computational batch size. Multiply the local decay by `iter_size` to counter the division of the local learning rate since the decay is multiplied by the rate in the update equation. --- src/caffe/solver.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index d104522002b..4c8fa25c955 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -488,7 +488,7 @@ void SGDSolver::ApplyUpdate() { ClipGradients(); for (int param_id = 0; param_id < this->net_->params().size(); ++param_id) { Regularize(param_id); - ComputeUpdateValue(param_id, rate); + ComputeUpdateValue(param_id, rate / this->param_.iter_size()); } this->net_->Update(); } @@ -500,7 +500,8 @@ void SGDSolver::Regularize(int param_id) { this->net_->params_weight_decay(); Dtype weight_decay = this->param_.weight_decay(); string regularization_type = this->param_.regularization_type(); - Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; + Dtype local_decay = weight_decay * net_params_weight_decay[param_id] + * this->param_.iter_size(); switch (Caffe::mode()) { case Caffe::CPU: { if (local_decay) { From adf31899fde826b98d64e4c344be1924bfa52b7e Mon Sep 17 00:00:00 2001 From: Martin Thoma Date: Wed, 27 May 2015 23:20:16 +0200 Subject: [PATCH 036/331] python/draw_net.py and python/caffe/draw.py: Simplified code; added more docstrings; adjusted code according to PEP8 --- python/caffe/draw.py | 163 +++++++++++++++++++++++++++---------------- python/draw_net.py | 13 ++-- 2 files changed, 109 insertions(+), 67 deletions(-) diff --git a/python/caffe/draw.py b/python/caffe/draw.py index 08b7c1de14b..834ea15ac9a 100644 --- a/python/caffe/draw.py +++ b/python/caffe/draw.py @@ -1,13 +1,15 @@ """ Caffe network visualization: draw the NetParameter protobuffer. -NOTE: this requires pydot>=1.0.2, which is not included in requirements.txt -since it requires graphviz and other prerequisites outside the scope of the -Caffe. + +.. note:: + + This requires pydot>=1.0.2, which is not included in requirements.txt since + it requires graphviz and other prerequisites outside the scope of the + Caffe. """ from caffe.proto import caffe_pb2 -from google.protobuf import text_format import pydot # Internal layer and blob styles. @@ -32,15 +34,15 @@ def get_pooling_types_dict(): return d -def determine_edge_label_by_layertype(layer, layertype): - """Define edge label based on layer type +def get_edge_label(layer): + """Define edge label based on layer type. """ - if layertype == 'Data': + if layer.type == 'Data': edge_label = 'Batch ' + str(layer.data_param.batch_size) - elif layertype == 'Convolution': + elif layer.type == 'Convolution': edge_label = str(layer.convolution_param.num_output) - elif layertype == 'InnerProduct': + elif layer.type == 'InnerProduct': edge_label = str(layer.inner_product_param.num_output) else: edge_label = '""' @@ -48,8 +50,19 @@ def determine_edge_label_by_layertype(layer, layertype): return edge_label -def determine_node_label_by_layertype(layer, layertype, rankdir): - """Define node label based on layer type +def get_layer_label(layer, rankdir): + """Define node label based on layer type. + + Parameters + ---------- + layer : ? + rankdir : {'LR', 'TB', 'BT'} + Direction of graph layout. + + Returns + ------- + string : + A label for the current layer """ if rankdir in ('TB', 'BT'): @@ -61,26 +74,26 @@ def determine_node_label_by_layertype(layer, layertype, rankdir): # horizontal space is not; separate words with newlines separator = '\n' - if layertype == 'Convolution': + if layer.type == 'Convolution': # Outer double quotes needed or else colon characters don't parse # properly node_label = '"%s%s(%s)%skernel size: %d%sstride: %d%spad: %d"' %\ (layer.name, separator, - layertype, + layer.type, separator, layer.convolution_param.kernel_size, separator, layer.convolution_param.stride, separator, layer.convolution_param.pad) - elif layertype == 'Pooling': + elif layer.type == 'Pooling': pooling_types_dict = get_pooling_types_dict() node_label = '"%s%s(%s %s)%skernel size: %d%sstride: %d%spad: %d"' %\ (layer.name, separator, pooling_types_dict[layer.pooling_param.pool], - layertype, + layer.type, separator, layer.pooling_param.kernel_size, separator, @@ -88,12 +101,12 @@ def determine_node_label_by_layertype(layer, layertype, rankdir): separator, layer.pooling_param.pad) else: - node_label = '"%s%s(%s)"' % (layer.name, separator, layertype) + node_label = '"%s%s(%s)"' % (layer.name, separator, layer.type) return node_label def choose_color_by_layertype(layertype): - """Define colors for nodes based on the layer type + """Define colors for nodes based on the layer type. """ color = '#6495ED' # Default if layertype == 'Convolution': @@ -106,48 +119,62 @@ def choose_color_by_layertype(layertype): def get_pydot_graph(caffe_net, rankdir, label_edges=True): - pydot_graph = pydot.Dot(caffe_net.name, graph_type='digraph', rankdir=rankdir) - pydot_nodes = {} - pydot_edges = [] - for layer in caffe_net.layer: - name = layer.name - layertype = layer.type - node_label = determine_node_label_by_layertype(layer, layertype, rankdir) - if (len(layer.bottom) == 1 and len(layer.top) == 1 and - layer.bottom[0] == layer.top[0]): - # We have an in-place neuron layer. - pydot_nodes[name + '_' + layertype] = pydot.Node( - node_label, **NEURON_LAYER_STYLE) - else: - layer_style = LAYER_STYLE_DEFAULT - layer_style['fillcolor'] = choose_color_by_layertype(layertype) - pydot_nodes[name + '_' + layertype] = pydot.Node( - node_label, **layer_style) - for bottom_blob in layer.bottom: - pydot_nodes[bottom_blob + '_blob'] = pydot.Node( - '%s' % (bottom_blob), **BLOB_STYLE) - edge_label = '""' - pydot_edges.append({'src': bottom_blob + '_blob', - 'dst': name + '_' + layertype, - 'label': edge_label}) - for top_blob in layer.top: - pydot_nodes[top_blob + '_blob'] = pydot.Node( - '%s' % (top_blob)) - if label_edges: - edge_label = determine_edge_label_by_layertype(layer, layertype) - else: - edge_label = '""' - pydot_edges.append({'src': name + '_' + layertype, - 'dst': top_blob + '_blob', - 'label': edge_label}) - # Now, add the nodes and edges to the graph. - for node in pydot_nodes.values(): - pydot_graph.add_node(node) - for edge in pydot_edges: - pydot_graph.add_edge( - pydot.Edge(pydot_nodes[edge['src']], pydot_nodes[edge['dst']], - label=edge['label'])) - return pydot_graph + """Create a data structure which represents the `caffe_net`. + + Parameters + ---------- + caffe_net : object + rankdir : {'LR', 'TB', 'BT'} + Direction of graph layout. + label_edges : boolean, optional + Label the edges (default is True). + + Returns + ------- + pydot graph object + """ + pydot_graph = pydot.Dot(caffe_net.name, + graph_type='digraph', + rankdir=rankdir) + pydot_nodes = {} + pydot_edges = [] + for layer in caffe_net.layer: + node_label = get_layer_label(layer, rankdir) + node_name = "%s_%s" % (layer.name, layer.type) + if (len(layer.bottom) == 1 and len(layer.top) == 1 and + layer.bottom[0] == layer.top[0]): + # We have an in-place neuron layer. + pydot_nodes[node_name] = pydot.Node(node_label, + **NEURON_LAYER_STYLE) + else: + layer_style = LAYER_STYLE_DEFAULT + layer_style['fillcolor'] = choose_color_by_layertype(layer.type) + pydot_nodes[node_name] = pydot.Node(node_label, **layer_style) + for bottom_blob in layer.bottom: + pydot_nodes[bottom_blob + '_blob'] = pydot.Node('%s' % bottom_blob, + **BLOB_STYLE) + edge_label = '""' + pydot_edges.append({'src': bottom_blob + '_blob', + 'dst': node_name, + 'label': edge_label}) + for top_blob in layer.top: + pydot_nodes[top_blob + '_blob'] = pydot.Node('%s' % (top_blob)) + if label_edges: + edge_label = get_edge_label(layer) + else: + edge_label = '""' + pydot_edges.append({'src': node_name, + 'dst': top_blob + '_blob', + 'label': edge_label}) + # Now, add the nodes and edges to the graph. + for node in pydot_nodes.values(): + pydot_graph.add_node(node) + for edge in pydot_edges: + pydot_graph.add_edge( + pydot.Edge(pydot_nodes[edge['src']], + pydot_nodes[edge['dst']], + label=edge['label'])) + return pydot_graph def draw_net(caffe_net, rankdir, ext='png'): @@ -156,8 +183,14 @@ def draw_net(caffe_net, rankdir, ext='png'): Parameters ---------- - caffe_net: a caffe.proto.caffe_pb2.NetParameter protocol buffer. - ext: the image extension. Default 'png'. + caffe_net : a caffe.proto.caffe_pb2.NetParameter protocol buffer. + ext : string, optional + The image extension (the default is 'png'). + + Returns + ------- + string : + Postscript representation of the graph. """ return get_pydot_graph(caffe_net, rankdir).create(format=ext) @@ -166,6 +199,14 @@ def draw_net_to_file(caffe_net, filename, rankdir='LR'): """Draws a caffe net, and saves it to file using the format given as the file extension. Use '.raw' to output raw text that you can manually feed to graphviz to draw graphs. + + Parameters + ---------- + caffe_net : a caffe.proto.caffe_pb2.NetParameter protocol buffer. + filename : string + The path to a file where the networks visualization will be stored. + rankdir : {'LR', 'TB', 'BT'} + Direction of graph layout. """ ext = filename[filename.rfind('.')+1:] with open(filename, 'wb') as fid: diff --git a/python/draw_net.py b/python/draw_net.py index 6320f775ef7..ec76a744da3 100755 --- a/python/draw_net.py +++ b/python/draw_net.py @@ -2,7 +2,7 @@ """ Draw a graph of the net architecture. """ -import argparse +from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter from google.protobuf import text_format import caffe @@ -14,7 +14,8 @@ def parse_args(): """Parse input arguments """ - parser = argparse.ArgumentParser(description='Draw a network graph') + parser = ArgumentParser(description=__doc__, + formatter_class=ArgumentDefaultsHelpFormatter) parser.add_argument('input_net_proto_file', help='Input network prototxt file') @@ -22,10 +23,10 @@ def parse_args(): help='Output image file') parser.add_argument('--rankdir', help=('One of TB (top-bottom, i.e., vertical), ' - 'RL (right-left, i.e., horizontal), or another' - 'valid dot option; see' - 'http://www.graphviz.org/doc/info/attrs.html#k:rankdir' - '(default: LR)'), + 'RL (right-left, i.e., horizontal), or another ' + 'valid dot option; see ' + 'http://www.graphviz.org/doc/info/' + 'attrs.html#k:rankdir'), default='LR') args = parser.parse_args() From 92ab737adad6d686ac75cdf934472f6a97b52fe7 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Thu, 21 May 2015 18:14:16 -0700 Subject: [PATCH 037/331] test equivalence of solving with accumulating gradients Compare the parameters after solving with a given batch size and the halved batch size + two iter accumulation of gradients equivalent. Note: the test net dummy data layer now makes constant data and random gaussian targets. This assures the standard and gradient accumulation cases check the same data. Otherwise the difference in batch sizes causes different orders of random number draws. --- src/caffe/test/test_gradient_based_solver.cpp | 82 ++++++++++++++++++- 1 file changed, 79 insertions(+), 3 deletions(-) diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index eb2569c04f2..c9135d64e70 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -23,7 +23,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { protected: GradientBasedSolverTest() : - seed_(1701), num_(5), channels_(3), height_(10), width_(10) {} + seed_(1701), num_(4), channels_(3), height_(10), width_(10) {} shared_ptr > solver_; int seed_; @@ -56,19 +56,21 @@ class GradientBasedSolverTest : public MultiDeviceTest { } void RunLeastSquaresSolver(const Dtype learning_rate, - const Dtype weight_decay, const Dtype momentum, const int num_iters) { + const Dtype weight_decay, const Dtype momentum, const int num_iters, + const int iter_size = 1) { ostringstream proto; proto << "max_iter: " << num_iters << " " "base_lr: " << learning_rate << " " "lr_policy: 'fixed' " + "iter_size: " << iter_size << " " "net_param { " " name: 'TestNetwork' " " layer { " " name: 'data' " " type: 'DummyData' " " dummy_data_param { " - " num: " << num_ << " " + " num: " << num_ / iter_size << " " " channels: " << channels_ << " " " height: " << height_ << " " " width: " << width_ << " " @@ -76,6 +78,10 @@ class GradientBasedSolverTest : public MultiDeviceTest { " height: 1 " " width: 1 " " data_filler { " + " type: 'constant' " + " value: 1.0 " + " } " + " data_filler { " " type: 'gaussian' " " std: 1.0 " " } " @@ -270,6 +276,45 @@ class GradientBasedSolverTest : public MultiDeviceTest { } } + void CheckAccumulation(const Dtype kLearningRate, const Dtype kWeightDecay, + const Dtype kMomentum, const int kNumIters, const int kIterSize) { + const double kPrecision = 1e-2; + const double kMinPrecision = 1e-7; + // Solve without accumulation and save parameters. + this->RunLeastSquaresSolver(kLearningRate, kWeightDecay, kMomentum, + kNumIters); + // Save parameters for comparison. + Net& net = *this->solver_->net(); + const vector > >& param_blobs = + net.layer_by_name("innerprod")->blobs(); + vector > > noaccum_params(param_blobs.size()); + for (int i = 0; i < param_blobs.size(); ++i) { + noaccum_params[i].reset(new Blob()); + noaccum_params[i]->CopyFrom(*param_blobs[i], false, true); + } + // Solve by equivalent accumulation of gradients over divided batches. + this->RunLeastSquaresSolver(kLearningRate, kWeightDecay, kMomentum, + kNumIters, kIterSize); + Net& net_accum = *this->solver_->net(); + const vector > >& accum_params = + net_accum.layer_by_name("innerprod")->blobs(); + // Compare accumulated parameters against no accumulation standard. + const int D = this->channels_ * this->height_ * this->width_; + for (int i = 0; i < D; ++i) { + const Dtype expected_param = noaccum_params[0]->cpu_data()[i]; + const Dtype accum_param = accum_params[0]->cpu_data()[i]; + const Dtype error_margin = std::max(kMinPrecision, kPrecision * + std::min(fabs(expected_param), fabs(accum_param))); + EXPECT_NEAR(expected_param, accum_param, error_margin); + } + ASSERT_EQ(1, accum_params[1]->count()); + const Dtype expected_bias = noaccum_params[1]->cpu_data()[0]; + const Dtype accum_bias = accum_params[1]->cpu_data()[0]; + const Dtype error_margin = std::max(kMinPrecision, kPrecision * + std::min(fabs(expected_bias), fabs(accum_bias))); + EXPECT_NEAR(expected_bias, accum_bias, error_margin); + } + // Test that the correct update is computed for a regularized least squares // problem: // @@ -372,6 +417,16 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverything) { } } +TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + const int kIterSize = 2; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); +} template class AdaGradSolverTest : public GradientBasedSolverTest { @@ -416,6 +471,16 @@ TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithEverything) { } } +TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.0; + const int kNumIters = 4; + const int kIterSize = 2; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); +} template class NesterovSolverTest : public GradientBasedSolverTest { @@ -482,4 +547,15 @@ TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithEverything) { } } +TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + const int kIterSize = 2; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); +} + } // namespace caffe From 0e7a0785db224aa7cf2bd925d8b7910bdc3f7a98 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Thu, 28 May 2015 12:43:29 -0700 Subject: [PATCH 038/331] directly normalize accumulated gradients `SGDSolver::Normalize()` normalizes accumulated gradients by scaling inversely to the accumulation as `1 / iter_size`. This fixes accumulation for AdaGrad and is more obvious than fooling with rates and decays in 55585f5. --- include/caffe/solver.hpp | 1 + src/caffe/solver.cpp | 32 +++++++++++++++++++++++++++++--- 2 files changed, 30 insertions(+), 3 deletions(-) diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index da1bab13663..c2ced487d6f 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -81,6 +81,7 @@ class SGDSolver : public Solver { void PreSolve(); Dtype GetLearningRate(); virtual void ApplyUpdate(); + virtual void Normalize(int param_id); virtual void Regularize(int param_id); virtual void ComputeUpdateValue(int param_id, Dtype rate); virtual void ClipGradients(); diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 4c8fa25c955..aabe0edec80 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -487,12 +487,39 @@ void SGDSolver::ApplyUpdate() { } ClipGradients(); for (int param_id = 0; param_id < this->net_->params().size(); ++param_id) { + Normalize(param_id); Regularize(param_id); - ComputeUpdateValue(param_id, rate / this->param_.iter_size()); + ComputeUpdateValue(param_id, rate); } this->net_->Update(); } +template +void SGDSolver::Normalize(int param_id) { + if (this->param_.iter_size() == 1) { return; } + // Scale gradient to counterbalance accumulation. + const vector > >& net_params = this->net_->params(); + const Dtype accum_normalization = Dtype(1.) / this->param_.iter_size(); + switch (Caffe::mode()) { + case Caffe::CPU: { + caffe_scal(net_params[param_id]->count(), accum_normalization, + net_params[param_id]->mutable_cpu_diff()); + break; + } + case Caffe::GPU: { +#ifndef CPU_ONLY + caffe_gpu_scal(net_params[param_id]->count(), accum_normalization, + net_params[param_id]->mutable_gpu_diff()); +#else + NO_GPU; +#endif + break; + } + default: + LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode(); + } +} + template void SGDSolver::Regularize(int param_id) { const vector > >& net_params = this->net_->params(); @@ -500,8 +527,7 @@ void SGDSolver::Regularize(int param_id) { this->net_->params_weight_decay(); Dtype weight_decay = this->param_.weight_decay(); string regularization_type = this->param_.regularization_type(); - Dtype local_decay = weight_decay * net_params_weight_decay[param_id] - * this->param_.iter_size(); + Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; switch (Caffe::mode()) { case Caffe::CPU: { if (local_decay) { From ee0c93137472981554ad30a766a1542cf155bf7b Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Fri, 22 May 2015 01:45:14 +0800 Subject: [PATCH 039/331] MatCaffe3 : a powerful matlab interface for caffe Added matcaffe3, a powerful matlab interface. To test it, run 'make mattest' --- Makefile | 22 +- matlab/+caffe/+test/test_net.m | 74 +++ matlab/+caffe/+test/test_solver.m | 43 ++ matlab/+caffe/Blob.m | 71 +++ matlab/+caffe/Layer.m | 32 ++ matlab/+caffe/Net.m | 133 ++++++ matlab/+caffe/Solver.m | 56 +++ matlab/+caffe/get_net.m | 37 ++ matlab/+caffe/get_solver.m | 11 + matlab/+caffe/io.m | 22 + matlab/+caffe/private/CHECK.m | 7 + matlab/+caffe/private/CHECK_FILE_EXIST.m | 7 + matlab/+caffe/private/caffe_.cpp | 546 +++++++++++++++++++++++ matlab/+caffe/private/is_valid_handle.m | 28 ++ matlab/+caffe/reset.m | 8 + matlab/+caffe/run_tests.m | 12 + matlab/+caffe/set_device.m | 11 + matlab/+caffe/set_mode_cpu.m | 7 + matlab/+caffe/set_mode_gpu.m | 7 + matlab/CMakeLists.txt | 8 + 20 files changed, 1141 insertions(+), 1 deletion(-) create mode 100644 matlab/+caffe/+test/test_net.m create mode 100644 matlab/+caffe/+test/test_solver.m create mode 100644 matlab/+caffe/Blob.m create mode 100644 matlab/+caffe/Layer.m create mode 100644 matlab/+caffe/Net.m create mode 100644 matlab/+caffe/Solver.m create mode 100644 matlab/+caffe/get_net.m create mode 100644 matlab/+caffe/get_solver.m create mode 100644 matlab/+caffe/io.m create mode 100644 matlab/+caffe/private/CHECK.m create mode 100644 matlab/+caffe/private/CHECK_FILE_EXIST.m create mode 100644 matlab/+caffe/private/caffe_.cpp create mode 100644 matlab/+caffe/private/is_valid_handle.m create mode 100644 matlab/+caffe/reset.m create mode 100644 matlab/+caffe/run_tests.m create mode 100644 matlab/+caffe/set_device.m create mode 100644 matlab/+caffe/set_mode_cpu.m create mode 100644 matlab/+caffe/set_mode_gpu.m diff --git a/Makefile b/Makefile index d2e5e5720ed..74b167763c3 100644 --- a/Makefile +++ b/Makefile @@ -66,6 +66,7 @@ NONGEN_CXX_SRCS := $(shell find \ include/$(PROJECT) \ python/$(PROJECT) \ matlab/$(PROJECT) \ + matlab/+$(PROJECT)/private \ examples \ tools \ -name "*.cpp" -or -name "*.hpp" -or -name "*.cu" -or -name "*.cuh") @@ -81,10 +82,13 @@ PY$(PROJECT)_SO := python/$(PROJECT)/_$(PROJECT).so PY$(PROJECT)_HXX := include/$(PROJECT)/python_layer.hpp # MAT$(PROJECT)_SRC is the matlab wrapper for $(PROJECT) MAT$(PROJECT)_SRC := matlab/$(PROJECT)/mat$(PROJECT).cpp +# MAT$(PROJECT)_PKG_SRC is the mex entrance point of matlab package for $(PROJECT) +MAT$(PROJECT)_PKG_SRC := matlab/+$(PROJECT)/private/$(PROJECT)_.cpp ifneq ($(MATLAB_DIR),) MAT_SO_EXT := $(shell $(MATLAB_DIR)/bin/mexext) endif MAT$(PROJECT)_SO := matlab/$(PROJECT)/$(PROJECT).$(MAT_SO_EXT) +MAT$(PROJECT)_PKG_SO := matlab/+$(PROJECT)/private/$(PROJECT)_.$(MAT_SO_EXT) ############################## # Derive generated files @@ -447,7 +451,7 @@ $(PY$(PROJECT)_SO): $(PY$(PROJECT)_SRC) $(PY$(PROJECT)_HXX) | $(DYNAMIC_NAME) mat$(PROJECT): mat -mat: $(MAT$(PROJECT)_SO) +mat: $(MAT$(PROJECT)_SO) $(MAT$(PROJECT)_PKG_SO) $(MAT$(PROJECT)_SO): $(MAT$(PROJECT)_SRC) $(STATIC_NAME) @ if [ -z "$(MATLAB_DIR)" ]; then \ @@ -460,6 +464,18 @@ $(MAT$(PROJECT)_SO): $(MAT$(PROJECT)_SRC) $(STATIC_NAME) CXX="$(CXX)" \ CXXFLAGS="\$$CXXFLAGS $(MATLAB_CXXFLAGS)" \ CXXLIBS="\$$CXXLIBS $(STATIC_LINK_COMMAND) $(LDFLAGS)" -output $@ + +$(MAT$(PROJECT)_PKG_SO): $(MAT$(PROJECT)_PKG_SRC) $(STATIC_NAME) + @ if [ -z "$(MATLAB_DIR)" ]; then \ + echo "MATLAB_DIR must be specified in $(CONFIG_FILE)" \ + "to build mat$(PROJECT)."; \ + exit 1; \ + fi + @ echo MEX $< + $(Q)$(MATLAB_DIR)/bin/mex $(MAT$(PROJECT)_PKG_SRC) \ + CXX="$(CXX)" \ + CXXFLAGS="\$$CXXFLAGS $(MATLAB_CXXFLAGS)" \ + CXXLIBS="\$$CXXLIBS $(STATIC_LINK_COMMAND) $(LDFLAGS)" -output $@ runtest: $(TEST_ALL_BIN) $(TOOL_BUILD_DIR)/caffe @@ -467,6 +483,9 @@ runtest: $(TEST_ALL_BIN) pytest: py cd python; python -m unittest discover -s caffe/test + +mattest: mat + cd matlab; $(MATLAB_DIR)/bin/matlab -nodisplay -r 'caffe.run_tests(), exit()' warn: $(EMPTY_WARN_REPORT) @@ -582,6 +601,7 @@ clean: @- $(RM) -rf $(DISTRIBUTE_DIR) @- $(RM) $(PY$(PROJECT)_SO) @- $(RM) $(MAT$(PROJECT)_SO) + @- $(RM) $(MAT$(PROJECT)_PKG_SO) supercleanfiles: $(eval SUPERCLEAN_FILES := $(strip \ diff --git a/matlab/+caffe/+test/test_net.m b/matlab/+caffe/+test/test_net.m new file mode 100644 index 00000000000..4958d50f9e3 --- /dev/null +++ b/matlab/+caffe/+test/test_net.m @@ -0,0 +1,74 @@ +classdef test_net < matlab.unittest.TestCase + + properties + num_output + model_file + net + end + + methods (Static) + function model_file = simple_net_file(num_output) + model_file = tempname(); + fid = fopen(model_file, 'w'); + fprintf(fid, [ ... + 'name: "testnet" force_backward: true\n' ... + 'layer { type: "DummyData" name: "data" top: "data" top: "label"\n' ... + 'dummy_data_param { num: 5 channels: 2 height: 3 width: 4\n' ... + ' num: 5 channels: 1 height: 1 width: 1\n' ... + ' data_filler { type: "gaussian" std: 1 }\n' ... + ' data_filler { type: "constant" } } }\n' ... + 'layer { type: "Convolution" name: "conv" bottom: "data" top: "conv"\n' ... + ' convolution_param { num_output: 11 kernel_size: 2 pad: 3\n' ... + ' weight_filler { type: "gaussian" std: 1 }\n' ... + ' bias_filler { type: "constant" value: 2 } }\n' ... + ' param { decay_mult: 1 } param { decay_mult: 0 }\n' ... + ' }\n' ... + 'layer { type: "InnerProduct" name: "ip" bottom: "conv" top: "ip"\n' ... + ' inner_product_param { num_output: ' num2str(num_output) ... + ' weight_filler { type: "gaussian" std: 2.5 }\n' ... + ' bias_filler { type: "constant" value: -3 } } }\n' ... + 'layer { type: "SoftmaxWithLoss" name: "loss" bottom: "ip" bottom: "label"\n' ... + ' top: "loss" }' ]); + fclose(fid); + end + end + methods + function self = test_net() + self.num_output = 13; + self.model_file = caffe.test.test_net.simple_net_file(self.num_output); + self.net = caffe.Net(self.model_file, 'train'); + % also make sure get_solver runs + caffe.get_net(self.model_file, 'train'); + + % fill in valid labels + self.net.blobs('label').set_data(randi( ... + self.num_output - 1, self.net.blobs('label').shape)); + + delete(self.model_file); + end + end + methods (Test) + function test_forward_backward(self) + self.net.forward_prefilled(); + self.net.backward_prefilled(); + end + function test_inputs_outputs(self) + self.verifyEqual(self.net.inputs, cell(0, 1)) + self.verifyEqual(self.net.outputs, {'loss'}); + end + function test_save_and_read(self) + weights_file = tempname(); + self.net.save(weights_file); + model_file2 = caffe.test.test_net.simple_net_file(self.num_output); + net2 = caffe.Net(model_file2, weights_file, 'train'); + delete(model_file2); + delete(weights_file); + for l = 1:length(self.net.layer_vec) + for i = 1:length(self.net.layer_vec(l).params) + self.verifyEqual(self.net.layer_vec(l).params(i).get_data(), ... + net2.layer_vec(l).params(i).get_data()); + end + end + end + end +end \ No newline at end of file diff --git a/matlab/+caffe/+test/test_solver.m b/matlab/+caffe/+test/test_solver.m new file mode 100644 index 00000000000..9774ec1d2fd --- /dev/null +++ b/matlab/+caffe/+test/test_solver.m @@ -0,0 +1,43 @@ +classdef test_solver < matlab.unittest.TestCase + + properties + num_output + solver + end + + methods + function self = test_solver() + self.num_output = 13; + model_file = caffe.test.test_net.simple_net_file(self.num_output); + solver_file = tempname(); + + fid = fopen(solver_file, 'w'); + fprintf(fid, [ ... + 'net: "' model_file '"\n' ... + 'test_iter: 10 test_interval: 10 base_lr: 0.01 momentum: 0.9\n' ... + 'weight_decay: 0.0005 lr_policy: "inv" gamma: 0.0001 power: 0.75\n' ... + 'display: 100 max_iter: 100 snapshot_after_train: false\n' ]); + fclose(fid); + + self.solver = caffe.Solver(solver_file); + % also make sure get_solver runs + caffe.get_solver(solver_file); + caffe.set_mode_cpu(); + % fill in valid labels + self.solver.net.blobs('label').set_data(randi( ... + self.num_output - 1, self.solver.net.blobs('label').shape)); + self.solver.test_nets(1).blobs('label').set_data(randi( ... + self.num_output - 1, self.solver.test_nets(1).blobs('label').shape)); + + delete(solver_file); + delete(model_file); + end + end + methods (Test) + function test_solve(self) + self.verifyEqual(self.solver.iter(), 0) + self.solver.solve() + self.verifyEqual(self.solver.iter(), 100) + end + end +end \ No newline at end of file diff --git a/matlab/+caffe/Blob.m b/matlab/+caffe/Blob.m new file mode 100644 index 00000000000..a6326d1a36c --- /dev/null +++ b/matlab/+caffe/Blob.m @@ -0,0 +1,71 @@ +classdef Blob < handle + % Wrapper class of caffe::Blob in matlab + + properties (Access = private) + hBlob_self + end + + methods + function self = Blob(hBlob_blob) + CHECK(is_valid_handle(hBlob_blob), 'invalid input handle'); + + % setup self handle and attributes + self.hBlob_self = hBlob_blob; + end + function shape = shape(self) + shape = caffe_('blob_get_shape', self.hBlob_self); + end + function reshape(self, shape) + shape = self.check_and_preprocess_shape(shape); + caffe_('blob_reshape', self.hBlob_self, shape); + end + function data = get_data(self) + data = caffe_('blob_get_data', self.hBlob_self); + end + function set_data(self, data) + data = self.check_and_preprocess_data(data); + caffe_('blob_set_data', self.hBlob_self, data); + end + function diff = get_diff(self) + diff = caffe_('blob_get_diff', self.hBlob_self); + end + function set_diff(self, diff) + diff = self.check_and_preprocess_data(diff); + caffe_('blob_set_diff', self.hBlob_self, diff); + end + end + + methods (Access = private) + function shape = check_and_preprocess_shape(~, shape) + CHECK(isempty(shape) || isnumeric(shape) && isrow(shape), ... + 'shape must be a integer row vector'); + shape = double(shape); + end + function data = check_and_preprocess_data(self, data) + CHECK(isnumeric(data), 'data or diff must be numeric types'); + self.check_data_size_matches(data) + data = single(data); + end + function check_data_size_matches(self, data) + % check whether size of data matches shape of this blob + % note: matlab arrays always have at least 2 dimensions. To compare + % shape between size of data and shape of this blob, extend shape of + % this blob to have at least 2 dimensions + data_size = size(data); + self_shape_extended = self.shape; + if isempty(self_shape_extended) + % target blob is a scalar (0 dim) + self_shape_extended = [1, 1]; + elseif isscalar(self_shape_extended) + % target blob is a vector (1 dim) + self_shape_extended = [self_shape_extended, 1]; + end + is_matched = (length(self_shape_extended) == length(data_size)) ... + && all(self_shape_extended == data_size); + CHECK(is_matched, ... + sprintf('%s, data size: [ %s], blob shape: [ %s]', ... + 'data size does not match blob shape', ... + sprintf('%d ', data_size), sprintf('%d ', self_shape_extended))); + end + end +end \ No newline at end of file diff --git a/matlab/+caffe/Layer.m b/matlab/+caffe/Layer.m new file mode 100644 index 00000000000..7587ed7ddf7 --- /dev/null +++ b/matlab/+caffe/Layer.m @@ -0,0 +1,32 @@ +classdef Layer < handle + % Wrapper class of caffe::Layer in matlab + + properties (Access = private) + hLayer_self + attributes + % attributes fields: + % hBlob_blobs + end + properties (SetAccess = private) + params + end + + methods + function self = Layer(hLayer_layer) + CHECK(is_valid_handle(hLayer_layer), 'invalid input handle'); + + % setup self handle and attributes + self.hLayer_self = hLayer_layer; + self.attributes = caffe_('layer_get_attr', self.hLayer_self); + + % setup weights + self.params = caffe.Blob.empty(); + for n = 1:length(self.attributes.hBlob_blobs) + self.params(n) = caffe.Blob(self.attributes.hBlob_blobs(n)); + end + end + function layer_type = type(self) + layer_type = caffe_('layer_get_type', self.hLayer_self); + end + end +end diff --git a/matlab/+caffe/Net.m b/matlab/+caffe/Net.m new file mode 100644 index 00000000000..5319634dc8b --- /dev/null +++ b/matlab/+caffe/Net.m @@ -0,0 +1,133 @@ +classdef Net < handle + % Wrapper class of caffe::Net in matlab + + properties (Access = private) + hNet_self + attributes + % attribute fields + % hLayer_layers + % hBlob_blobs + % input_blob_indices + % output_blob_indices + % layer_names + % blob_names + end + properties (SetAccess = private) + layer_vec + blob_vec + inputs + outputs + name2layer_index + name2blob_index + layer_names + blob_names + end + + methods + function self = Net(varargin) + % decide whether to construct a net from model_file or handle + if ~(nargin == 1 && isstruct(varargin{1})) + % construct a net from model_file + self = caffe.get_net(varargin{:}); + return + end + % construct a net from handle + hNet_net = varargin{1}; + CHECK(is_valid_handle(hNet_net), 'invalid input handle'); + + % setup self handle and attributes + self.hNet_self = hNet_net; + self.attributes = caffe_('net_get_attr', self.hNet_self); + + % setup layer_vec + self.layer_vec = caffe.Layer.empty(); + for n = 1:length(self.attributes.hLayer_layers) + self.layer_vec(n) = caffe.Layer(self.attributes.hLayer_layers(n)); + end + + % setup blob_vec + self.blob_vec = caffe.Blob.empty(); + for n = 1:length(self.attributes.hBlob_blobs); + self.blob_vec(n) = caffe.Blob(self.attributes.hBlob_blobs(n)); + end + + % setup input and output blob and their names + % note: add 1 to indices as matlab is 1-indexed while C++ is 0-indexed + self.inputs = ... + self.attributes.blob_names(self.attributes.input_blob_indices + 1); + self.outputs = ... + self.attributes.blob_names(self.attributes.output_blob_indices + 1); + + % create map objects to map from name to layers and blobs + self.name2layer_index = containers.Map(self.attributes.layer_names, ... + 1:length(self.attributes.layer_names)); + self.name2blob_index = containers.Map(self.attributes.blob_names, ... + 1:length(self.attributes.blob_names)); + + % expose layer_names and blob_names for public access + self.layer_names = self.attributes.layer_names; + self.blob_names = self.attributes.blob_names; + end + function layer = layers(self, layer_name) + CHECK(ischar(layer_name), 'layer_name must be a string'); + layer = self.layer_vec(self.name2layer_index(layer_name)); + end + function blob = blobs(self, blob_name) + CHECK(ischar(blob_name), 'blob_name must be a string'); + blob = self.blob_vec(self.name2blob_index(blob_name)); + end + function blob = params(self, layer_name, blob_index) + CHECK(ischar(layer_name), 'layer_name must be a string'); + CHECK(isscalar(blob_index), 'blob_index must be a scalar'); + blob = self.layer_vec(self.name2layer_index(layer_name)).params(blob_index); + end + function forward_prefilled(self) + caffe_('net_forward', self.hNet_self); + end + function backward_prefilled(self) + caffe_('net_backward', self.hNet_self); + end + function res = forward(self, input_data) + CHECK(iscell(input_data), 'input_data must be a cell array'); + CHECK(length(input_data) == length(self.inputs), ... + 'input data cell length must match input blob number'); + % copy data to input_blobs + for n = 1:length(self.inputs) + self.blobs(self.inputs{n}).set_data(input_data{n}); + end + self.forward_prefilled(); + % retrieve data from output_blobs + res = cell(length(self.outputs), 1); + for n = 1:length(self.outputs) + res{n} = self.blobs(self.outputs{n}).get_data(); + end + end + function res = backward(self, output_diff) + CHECK(iscell(output_diff), 'output_diff must be a cell array'); + CHECK(length(output_diff) == length(self.outputs), ... + 'output diff cell length must match output blob number'); + % copy diff to output_blobs + for n = 1:length(self.outputs) + self.blobs(self.outputs{n}).set_diff(output_diff{n}); + end + self.backward_prefilled(); + % retrieve diff from input_blobs + res = cell(length(self.inputs), 1); + for n = 1:length(self.inputs) + res{n} = self.blobs(self.inputs{n}).get_diff(); + end + end + function copy_from(self, weights_file) + CHECK(ischar(weights_file), 'weights_file must be a string'); + CHECK_FILE_EXIST(weights_file); + caffe_('net_copy_from', self.hNet_self, weights_file); + end + function reshape(self) + caffe_('net_reshape', self.hNet_self); + end + function save(self, weights_file) + CHECK(ischar(weights_file), 'weights_file must be a string'); + caffe_('net_save', self.hNet_self, weights_file); + end + end +end diff --git a/matlab/+caffe/Solver.m b/matlab/+caffe/Solver.m new file mode 100644 index 00000000000..80fa5394739 --- /dev/null +++ b/matlab/+caffe/Solver.m @@ -0,0 +1,56 @@ +classdef Solver < handle + % Wrapper class of caffe::SGDSolver in matlab + + properties (Access = private) + hSolver_self + attributes + % attribute fields + % hNet_net + % hNet_test_nets + end + properties (SetAccess = private) + net + test_nets + end + + methods + function self = Solver(varargin) + % decide whether to construct a solver from solver_file or handle + if ~(nargin == 1 && isstruct(varargin{1})) + % construct a solver from solver_file + self = caffe.get_solver(varargin{:}); + return + end + % construct a solver from handle + hSolver_solver = varargin{1}; + CHECK(is_valid_handle(hSolver_solver), 'invalid input handle'); + + % setup self handle and attributes + self.hSolver_self = hSolver_solver; + self.attributes = caffe_('solver_get_attr', self.hSolver_self); + + % setup net and test_nets + self.net = caffe.Net(self.attributes.hNet_net); + self.test_nets = caffe.Net.empty(); + for n = 1:length(self.attributes.hNet_test_nets) + self.test_nets(n) = caffe.Net(self.attributes.hNet_test_nets(n)); + end + end + function iter = iter(self) + iter = caffe_('solver_get_iter', self.hSolver_self); + end + function restore(self, snapshot_filename) + CHECK(ischar(snapshot_filename), 'snapshot_filename must be a string'); + CHECK_FILE_EXIST(snapshot_filename) + caffe_('solver_restore', self.hSolver_self, snapshot_filename); + end + function solve(self) + caffe_('solver_solve', self.hSolver_self); + end + function step(self, iters) + CHECK(isscalar(iters) && iters > 0, 'iters must be positive integer'); + iters = double(iters); + caffe_('solver_step', self.hSolver_self, iters); + end + end +end diff --git a/matlab/+caffe/get_net.m b/matlab/+caffe/get_net.m new file mode 100644 index 00000000000..04872b263c8 --- /dev/null +++ b/matlab/+caffe/get_net.m @@ -0,0 +1,37 @@ +function net = get_net(varargin) +% net = get_net(model_file, phase_name) or +% net = get_net(model_file, weights_file, phase_name) +% Construct a net from model_file, and load weights from weights_file +% phase_name can only be 'train' or 'test' + +CHECK(nargin == 2 || nargin == 3, ['usage: ' ... + 'net = get_net(model_file, phase_name) or ', ... + 'net = get_net(model_file, weights_file, phase_name)']); +if nargin == 3 + model_file = varargin{1}; + weights_file = varargin{2}; + phase_name = varargin{3}; +elseif nargin == 2 + model_file = varargin{1}; + phase_name = varargin{2}; +end + +CHECK(ischar(model_file), 'model_file must be a string'); +CHECK(ischar(phase_name), 'phase_name must be a string'); +CHECK_FILE_EXIST(model_file); +CHECK(strcmp(phase_name, 'train') || strcmp(phase_name, 'test'), ... + sprintf('phase_name can only be %strain%s or %stest%s', ... + char(39), char(39), char(39), char(39))); + +hNet = caffe_('get_net', model_file, phase_name); +net = caffe.Net(hNet); + +% load weights from weights_file +if nargin == 3 + CHECK(ischar(weights_file), 'weights_file must be a string'); + CHECK_FILE_EXIST(weights_file); + net.copy_from(weights_file); +end + +end + diff --git a/matlab/+caffe/get_solver.m b/matlab/+caffe/get_solver.m new file mode 100644 index 00000000000..855709c725e --- /dev/null +++ b/matlab/+caffe/get_solver.m @@ -0,0 +1,11 @@ +function solver = get_solver(solver_file) +% solver = get_solver(solver_file) +% Construct a Solver object from solver_file + +CHECK(ischar(solver_file), 'solver_file must be a string'); +CHECK_FILE_EXIST(solver_file); + +pSolver = caffe_('get_solver', solver_file); +solver = caffe.Solver(pSolver); + +end \ No newline at end of file diff --git a/matlab/+caffe/io.m b/matlab/+caffe/io.m new file mode 100644 index 00000000000..95d58909abd --- /dev/null +++ b/matlab/+caffe/io.m @@ -0,0 +1,22 @@ +classdef io + % a class for input and output functions + + methods (Static) + function im_data = load_image(im_file) + CHECK(ischar(im_file), 'im_file must be a string'); + CHECK_FILE_EXIST(im_file); + % load an image from disk into Caffe-supported data format + % switch channels from RGB to BGR, make width the fastest dimension, and + % convert to single + im = imread(im_file); + im_data = im(:, :, [3, 2, 1]); + im_data = permute(im_data, [2 1 3]); + im_data = single(im_data); + end + function mean_data = read_mean(mean_proto_file) + CHECK(ischar(mean_proto_file), 'im_file must be a string'); + CHECK_FILE_EXIST(mean_proto_file); + mean_data = caffe_('read_mean', mean_proto_file); + end + end +end \ No newline at end of file diff --git a/matlab/+caffe/private/CHECK.m b/matlab/+caffe/private/CHECK.m new file mode 100644 index 00000000000..1cf21032b36 --- /dev/null +++ b/matlab/+caffe/private/CHECK.m @@ -0,0 +1,7 @@ +function CHECK(expr, error_msg) + +if ~expr + error(error_msg); +end + +end \ No newline at end of file diff --git a/matlab/+caffe/private/CHECK_FILE_EXIST.m b/matlab/+caffe/private/CHECK_FILE_EXIST.m new file mode 100644 index 00000000000..1db464c8258 --- /dev/null +++ b/matlab/+caffe/private/CHECK_FILE_EXIST.m @@ -0,0 +1,7 @@ +function CHECK_FILE_EXIST(filename) + +if exist(filename, 'file') == 0 + error('%s does not exist', filename); +end + +end \ No newline at end of file diff --git a/matlab/+caffe/private/caffe_.cpp b/matlab/+caffe/private/caffe_.cpp new file mode 100644 index 00000000000..96a1920ac39 --- /dev/null +++ b/matlab/+caffe/private/caffe_.cpp @@ -0,0 +1,546 @@ +// +// caffe_.cpp provides wrappers of the caffe::Solver class, caffe::Net class, +// caffe::Layer class and caffe::Blob class and some caffe::Caffe functions, +// so that one could easily use Caffe from matlab. +// Note that for matlab, we will simply use float as the data type. + +// Internally, data is stored with dimensions reversed from Caffe's: +// e.g., if the Caffe blob axes are (num, channels, height, width), +// the matcaffe data is stored as (width, height, channels, num) +// where width is the fastest dimension. + +#include +#include +#include + +#include "mex.h" + +#include "caffe/caffe.hpp" + +#define MEX_ARGS int nlhs, mxArray **plhs, int nrhs, const mxArray **prhs + +using namespace caffe; // NOLINT(build/namespaces) + +// Do CHECK and throw a Mex error if check failsf +inline void mxCHECK(bool expr, const std::string &msg) { + if (!expr) { + LOG(ERROR) << msg; + mexErrMsgTxt(msg.c_str()); + } +} +inline void mxERROR(const std::string &msg) { mxCHECK(false, msg); } + +// Check if a file exists and can be opened +void mxCHECK_FILE_EXIST(const char* file) { + std::ifstream f(file); + if (!f.good()) { + f.close(); + mxERROR("Could not open file " + string(file)); + } + f.close(); +} + +// The pointers to caffe::Solver and caffe::Net instances +static vector > > solvers_; +static vector > > nets_; +static double init_key = static_cast(caffe_rng_rand()); + +/** ----------------------------------------------------------------- + ** data conversion functions + **/ +// Enum indicates which blob memory to use +enum WhichMemory { DATA, DIFF }; + +// Copy matlab array to Blob data or diff +static void mx_mat_to_blob(const mxArray* mx_mat, Blob* blob, + WhichMemory data_or_diff) { + mxCHECK(blob->count() == mxGetNumberOfElements(mx_mat), + "number of elements in target blob doesn't match that in input mxArray"); + const float* mat_mem_ptr = reinterpret_cast(mxGetData(mx_mat)); + float* blob_mem_ptr = NULL; + switch (Caffe::mode()) { + case Caffe::CPU: + blob_mem_ptr = (data_or_diff == DATA ? + blob->mutable_cpu_data() : blob->mutable_cpu_diff()); + break; + case Caffe::GPU: + blob_mem_ptr = (data_or_diff == DATA ? + blob->mutable_gpu_data() : blob->mutable_gpu_diff()); + break; + default: + mxERROR("Unknown Caffe mode"); + } + caffe_copy(blob->count(), mat_mem_ptr, blob_mem_ptr); +} + +// Copy Blob data or diff to matlab array +static mxArray* blob_to_mx_mat(const Blob* blob, + WhichMemory data_or_diff) { + const int num_axes = blob->num_axes(); + vector dims(num_axes); + for (int blob_axis = 0, mat_axis = num_axes - 1; blob_axis < num_axes; + ++blob_axis, --mat_axis) { + dims[mat_axis] = static_cast(blob->shape(blob_axis)); + } + // matlab array needs to have at least one dimension, convert scalar to 1-dim + if (num_axes == 0) { + dims.push_back(1); + } + mxArray* mx_mat = + mxCreateNumericArray(dims.size(), dims.data(), mxSINGLE_CLASS, mxREAL); + float* mat_mem_ptr = reinterpret_cast(mxGetData(mx_mat)); + const float* blob_mem_ptr = NULL; + switch (Caffe::mode()) { + case Caffe::CPU: + blob_mem_ptr = (data_or_diff == DATA ? blob->cpu_data() : blob->cpu_diff()); + break; + case Caffe::GPU: + blob_mem_ptr = (data_or_diff == DATA ? blob->gpu_data() : blob->gpu_diff()); + break; + default: + mxERROR("Unknown Caffe mode"); + } + caffe_copy(blob->count(), blob_mem_ptr, mat_mem_ptr); + return mx_mat; +} + +// convert vector to matlab vector +static mxArray* int_vec_to_mx_vec(const vector& int_vec) { + mxArray* mx_vec = mxCreateDoubleMatrix(int_vec.size(), 1, mxREAL); + double* vec_mem_ptr = mxGetPr(mx_vec); + for (int i = 0; i < int_vec.size(); i++) { + vec_mem_ptr[i] = int_vec[i]; + } + return mx_vec; +} + +// convert vector to matlab string cell vector +static mxArray* str_vec_to_mx_strcell(const vector& str_vec) { + mxArray* mx_strcell = mxCreateCellMatrix(str_vec.size(), 1); + for (int i = 0; i < str_vec.size(); i++) { + mxSetCell(mx_strcell, i, mxCreateString(str_vec[i].c_str())); + } + return mx_strcell; +} + +/** ----------------------------------------------------------------- + ** handle and pointer conversion functions + ** a handle is a struct array with the following fields + ** (uint64) ptr : the pointer to the C++ object + ** (double) init_key : caffe initialization key + **/ +// Convert a handle in matlab to a pointer in C++. Check if init_key matches +template +static T* handle_to_ptr(const mxArray* mx_handle) { + mxArray* mx_ptr = mxGetField(mx_handle, 0, "ptr"); + mxArray* mx_init_key = mxGetField(mx_handle, 0, "init_key"); + mxCHECK(mxIsUint64(mx_ptr), "pointer type must be uint64"); + mxCHECK(mxGetScalar(mx_init_key) == init_key, "incorrect handle init_key"); + return reinterpret_cast(*reinterpret_cast(mxGetData(mx_ptr))); +} + +// Create an empty handle struct array +template +static mxArray* create_handles(int ptr_num) { + const int handle_field_num = 2; + const char* handle_fields[handle_field_num] = { "ptr", "init_key" }; + return mxCreateStructMatrix(ptr_num, 1, handle_field_num, handle_fields); +} + +// Set up each handle in a handle struct array +template +static void setup_handle(const T* ptr, int index, mxArray* mx_handles) { + mxArray* mx_ptr = mxCreateNumericMatrix(1, 1, mxUINT64_CLASS, mxREAL); + *reinterpret_cast(mxGetData(mx_ptr)) = + reinterpret_cast(ptr); + mxSetField(mx_handles, index, "ptr", mx_ptr); + mxSetField(mx_handles, index, "init_key", mxCreateDoubleScalar(init_key)); +} + +// Convert a pointer in C++ to a handle in matlab +template +static mxArray* ptr_to_handle(const T* ptr) { + mxArray* mx_handle = create_handles(1); + setup_handle(ptr, 0, mx_handle); + return mx_handle; +} + +// Convert a vector of shared_ptr in C++ to handle struct array in matlab +template +static mxArray* ptr_vec_to_handles(const vector >& ptr_vec) { + mxArray* mx_handle = create_handles(ptr_vec.size()); + for (int i = 0; i < ptr_vec.size(); i++) { + setup_handle(ptr_vec[i].get(), i, mx_handle); + } + return mx_handle; +} + +/** ----------------------------------------------------------------- + ** matlab command functions: caffe_(api_command, arg1, arg2, ...) + **/ +// Usage: caffe_('get_solver', solver_file); +static void get_solver(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsChar(prhs[0]), + "Usage: caffe_('get_solver', solver_file)"); + const char* solver_file = mxArrayToString(prhs[0]); + mxCHECK_FILE_EXIST(solver_file); + shared_ptr > solver; + solver.reset(new caffe::SGDSolver(solver_file)); + solvers_.push_back(solver); + plhs[0] = ptr_to_handle >(solver.get()); +} + +// Usage: caffe_('solver_get_attr', hSolver) +static void solver_get_attr(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('solver_get_attr', hSolver)"); + Solver* solver = handle_to_ptr >(prhs[0]); + const int solver_attr_num = 2; + const char* solver_attrs[solver_attr_num] = { "hNet_net", "hNet_test_nets" }; + mxArray* mx_solver_attr = mxCreateStructMatrix(1, 1, solver_attr_num, + solver_attrs); + mxSetField(mx_solver_attr, 0, "hNet_net", + ptr_to_handle >(solver->net().get())); + mxSetField(mx_solver_attr, 0, "hNet_test_nets", + ptr_vec_to_handles >(solver->test_nets())); + plhs[0] = mx_solver_attr; +} + +// Usage: caffe_('solver_get_iter', hSolver) +static void solver_get_iter(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('solver_get_iter', hSolver)"); + Solver* solver = handle_to_ptr >(prhs[0]); + plhs[0] = mxCreateDoubleScalar(solver->iter()); +} + +// Usage: caffe_('solver_restore', hSolver, snapshot_file) +static void solver_restore(MEX_ARGS) { + mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsChar(prhs[1]), + "Usage: caffe_('solver_restore', hSolver, snapshot_file)"); + Solver* solver = handle_to_ptr >(prhs[0]); + const char* snapshot_file = mxArrayToString(prhs[1]); + mxCHECK_FILE_EXIST(snapshot_file); + solver->Restore(snapshot_file); +} + +// Usage: caffe_('solver_solve', hSolver) +static void solver_solve(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('solver_solve', hSolver)"); + Solver* solver = handle_to_ptr >(prhs[0]); + solver->Solve(); +} + +// Usage: caffe_('solver_solve', hSolver, iters) +static void solver_step(MEX_ARGS) { + mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsDouble(prhs[1]), + "Usage: caffe_('solver_solve', hSolver, iters)"); + Solver* solver = handle_to_ptr >(prhs[0]); + int iters = mxGetScalar(prhs[1]); + solver->Step(iters); +} + +// Usage: caffe_('get_net', model_file, phase_name) +static void get_net(MEX_ARGS) { + mxCHECK(nrhs == 2 && mxIsChar(prhs[0]) && mxIsChar(prhs[1]), + "Usage: caffe_('get_net', model_file, phase_name)"); + const char* model_file = mxArrayToString(prhs[0]); + mxCHECK_FILE_EXIST(model_file); + const char* phase_name = mxArrayToString(prhs[1]); + Phase phase; + if (strcmp(phase_name, "train") == 0) { + phase = TRAIN; + } else if (strcmp(phase_name, "test") == 0) { + phase = TEST; + } else { + mxERROR("Unknown phase."); + } + shared_ptr > net; + net.reset(new caffe::Net(model_file, phase)); + nets_.push_back(net); + plhs[0] = ptr_to_handle >(net.get()); +} + +// Usage: caffe_('net_get_attr', hNet) +static void net_get_attr(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('net_get_attr', hNet)"); + Net* net = handle_to_ptr >(prhs[0]); + const int net_attr_num = 6; + const char* net_attrs[net_attr_num] = { "hLayer_layers", "hBlob_blobs", + "input_blob_indices", "output_blob_indices", "layer_names", "blob_names"}; + mxArray* mx_net_attr = mxCreateStructMatrix(1, 1, net_attr_num, + net_attrs); + mxSetField(mx_net_attr, 0, "hLayer_layers", + ptr_vec_to_handles >(net->layers())); + mxSetField(mx_net_attr, 0, "hBlob_blobs", + ptr_vec_to_handles >(net->blobs())); + mxSetField(mx_net_attr, 0, "input_blob_indices", + int_vec_to_mx_vec(net->input_blob_indices())); + mxSetField(mx_net_attr, 0, "output_blob_indices", + int_vec_to_mx_vec(net->output_blob_indices())); + mxSetField(mx_net_attr, 0, "layer_names", + str_vec_to_mx_strcell(net->layer_names())); + mxSetField(mx_net_attr, 0, "blob_names", + str_vec_to_mx_strcell(net->blob_names())); + plhs[0] = mx_net_attr; +} + +// Usage: caffe_('net_forward', hNet) +static void net_forward(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('net_forward', hNet)"); + Net* net = handle_to_ptr >(prhs[0]); + net->ForwardPrefilled(); +} + +// Usage: caffe_('net_backward', hNet) +static void net_backward(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('net_backward', hNet)"); + Net* net = handle_to_ptr >(prhs[0]); + net->Backward(); +} + +// Usage: caffe_('net_copy_from', hNet, weights_file) +static void net_copy_from(MEX_ARGS) { + mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsChar(prhs[1]), + "Usage: caffe_('net_copy_from', hNet, weights_file)"); + Net* net = handle_to_ptr >(prhs[0]); + const char* weights_file = mxArrayToString(prhs[1]); + mxCHECK_FILE_EXIST(weights_file); + net->CopyTrainedLayersFrom(weights_file); +} + +// Usage: caffe_('net_reshape', hNet) +static void net_reshape(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('net_reshape', hNet)"); + Net* net = handle_to_ptr >(prhs[0]); + net->Reshape(); +} + +// Usage: caffe_('net_save', hNet, save_file) +static void net_save(MEX_ARGS) { + mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsChar(prhs[1]), + "Usage: caffe_('net_save', hNet, save_file)"); + Net* net = handle_to_ptr >(prhs[0]); + const char* weights_file = mxArrayToString(prhs[1]); + NetParameter net_param; + net->ToProto(&net_param, false); + WriteProtoToBinaryFile(net_param, weights_file); +} + +// Usage: caffe_('layer_get_attr', hLayer) +static void layer_get_attr(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('layer_get_attr', hLayer)"); + Layer* layer = handle_to_ptr >(prhs[0]); + const int layer_attr_num = 1; + const char* layer_attrs[layer_attr_num] = { "hBlob_blobs" }; + mxArray* mx_layer_attr = mxCreateStructMatrix(1, 1, layer_attr_num, + layer_attrs); + mxSetField(mx_layer_attr, 0, "hBlob_blobs", + ptr_vec_to_handles >(layer->blobs())); + plhs[0] = mx_layer_attr; +} + +// Usage: caffe_('layer_get_attr', hLayer) +static void layer_get_type(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('layer_get_attr', hLayer)"); + Layer* layer = handle_to_ptr >(prhs[0]); + plhs[0] = mxCreateString(layer->type()); +} + +// Usage: caffe_('blob_get_shape', hBlob) +static void blob_get_shape(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('blob_get_shape', hBlob)"); + Blob* blob = handle_to_ptr >(prhs[0]); + const int num_axes = blob->num_axes(); + mxArray* mx_shape = mxCreateDoubleMatrix(1, num_axes, mxREAL); + double* shape_mem_mtr = mxGetPr(mx_shape); + for (int blob_axis = 0, mat_axis = num_axes - 1; blob_axis < num_axes; + ++blob_axis, --mat_axis) { + shape_mem_mtr[mat_axis] = static_cast(blob->shape(blob_axis)); + } + plhs[0] = mx_shape; +} + +// Usage: caffe_('blob_reshape', hBlob, new_shape) +static void blob_reshape(MEX_ARGS) { + mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsDouble(prhs[1]), + "Usage: caffe_('blob_reshape', hBlob, new_shape)"); + Blob* blob = handle_to_ptr >(prhs[0]); + const mxArray* mx_shape = prhs[1]; + double* shape_mem_mtr = mxGetPr(mx_shape); + const int num_axes = mxGetNumberOfElements(mx_shape); + vector blob_shape(num_axes); + for (int blob_axis = 0, mat_axis = num_axes - 1; blob_axis < num_axes; + ++blob_axis, --mat_axis) { + blob_shape[blob_axis] = static_cast(shape_mem_mtr[mat_axis]); + } + blob->Reshape(blob_shape); +} + +// Usage: caffe_('blob_get_data', hBlob) +static void blob_get_data(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('blob_get_data', hBlob)"); + Blob* blob = handle_to_ptr >(prhs[0]); + plhs[0] = blob_to_mx_mat(blob, DATA); +} + +// Usage: caffe_('blob_set_data', hBlob, new_data) +static void blob_set_data(MEX_ARGS) { + mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsSingle(prhs[1]), + "Usage: caffe_('blob_set_data', hBlob, new_data)"); + Blob* blob = handle_to_ptr >(prhs[0]); + mx_mat_to_blob(prhs[1], blob, DATA); +} + +// Usage: caffe_('blob_get_diff', hBlob) +static void blob_get_diff(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), + "Usage: caffe_('blob_get_diff', hBlob)"); + Blob* blob = handle_to_ptr >(prhs[0]); + plhs[0] = blob_to_mx_mat(blob, DIFF); +} + +// Usage: caffe_('blob_set_diff', hBlob, new_diff) +static void blob_set_diff(MEX_ARGS) { + mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsSingle(prhs[1]), + "Usage: caffe_('blob_set_diff', hBlob, new_diff)"); + Blob* blob = handle_to_ptr >(prhs[0]); + mx_mat_to_blob(prhs[1], blob, DIFF); +} + +// Usage: caffe_('set_mode_cpu') +static void set_mode_cpu(MEX_ARGS) { + mxCHECK(nrhs == 0, "Usage: caffe_('set_mode_cpu')"); + Caffe::set_mode(Caffe::CPU); +} + +// Usage: caffe_('set_mode_gpu') +static void set_mode_gpu(MEX_ARGS) { + mxCHECK(nrhs == 0, "Usage: caffe_('set_mode_gpu')"); + Caffe::set_mode(Caffe::GPU); +} + +// Usage: caffe_('set_device', device_id) +static void set_device(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsDouble(prhs[0]), + "Usage: caffe_('set_device', device_id)"); + int device_id = static_cast(mxGetScalar(prhs[0])); + Caffe::SetDevice(device_id); +} + +// Usage: caffe_('get_init_key') +static void get_init_key(MEX_ARGS) { + mxCHECK(nrhs == 0, "Usage: caffe_('get_init_key')"); + plhs[0] = mxCreateDoubleScalar(init_key); +} + +// Usage: caffe_('reset') +static void reset(MEX_ARGS) { + mxCHECK(nrhs == 0, "Usage: caffe_('reset')"); + mexPrintf("cleared %d solvers and %d stand-alone nets\n", solvers_.size(), + nets_.size()); + solvers_.clear(); + nets_.clear(); + init_key = static_cast(caffe_rng_rand()); +} + +// Usage: caffe_('read_mean', mean_proto_file) +static void read_mean(MEX_ARGS) { + mxCHECK(nrhs == 1 && mxIsChar(prhs[0]), + "Usage: caffe_('read_mean', mean_proto_file)"); + const char* mean_proto_file = mxArrayToString(prhs[0]); + Blob data_mean; + mexPrintf("Loading mean file from: %s\n", mean_proto_file); + BlobProto blob_proto; + bool result = ReadProtoFromBinaryFile(mean_proto_file, &blob_proto); + mxCHECK(result, "Couldn't read the file"); + data_mean.FromProto(blob_proto); + mwSize dims[4] = {data_mean.width(), data_mean.height(), + data_mean.channels(), data_mean.num() }; + mxArray* mx_blob = mxCreateNumericArray(4, dims, mxSINGLE_CLASS, mxREAL); + float* data_ptr = reinterpret_cast(mxGetData(mx_blob)); + caffe_copy(data_mean.count(), data_mean.cpu_data(), data_ptr); + mexPrintf("Remember that Caffe saves in [width, height, channels]" + " format and channels are also BGR!\n"); + plhs[0] = mx_blob; +} + +/** ----------------------------------------------------------------- + ** Available commands. + **/ +struct handler_registry { + string cmd; + void (*func)(MEX_ARGS); +}; + +static handler_registry handlers[] = { + // Public API functions + { "get_solver", get_solver }, + { "solver_get_attr", solver_get_attr }, + { "solver_get_iter", solver_get_iter }, + { "solver_restore", solver_restore }, + { "solver_solve", solver_solve }, + { "solver_step", solver_step }, + { "get_net", get_net }, + { "net_get_attr", net_get_attr }, + { "net_forward", net_forward }, + { "net_backward", net_backward }, + { "net_copy_from", net_copy_from }, + { "net_reshape", net_reshape }, + { "net_save", net_save }, + { "layer_get_attr", layer_get_attr }, + { "layer_get_type", layer_get_type }, + { "blob_get_shape", blob_get_shape }, + { "blob_reshape", blob_reshape }, + { "blob_get_data", blob_get_data }, + { "blob_set_data", blob_set_data }, + { "blob_get_diff", blob_get_diff }, + { "blob_set_diff", blob_set_diff }, + { "set_mode_cpu", set_mode_cpu }, + { "set_mode_gpu", set_mode_gpu }, + { "set_device", set_device }, + { "get_init_key", get_init_key }, + { "reset", reset }, + { "read_mean", read_mean }, + // The end. + { "END", NULL }, +}; + +/** ----------------------------------------------------------------- + ** matlab entry point: caffe_(api_command, arg1, arg2, ...) + **/ +void mexFunction(MEX_ARGS) { + mexLock(); // Avoid clearing the mex file. + if (nrhs == 0) { + mxERROR("No API command given"); + return; + } + + { // Handle input command + char* cmd = mxArrayToString(prhs[0]); + bool dispatched = false; + // Dispatch to cmd handler + for (int i = 0; handlers[i].func != NULL; i++) { + if (handlers[i].cmd.compare(cmd) == 0) { + handlers[i].func(nlhs, plhs, nrhs-1, prhs+1); + dispatched = true; + break; + } + } + if (!dispatched) { + ostringstream error_msg; + error_msg << "Unknown command '" << cmd << "'"; + mxERROR(error_msg.str().c_str()); + } + mxFree(cmd); + } +} diff --git a/matlab/+caffe/private/is_valid_handle.m b/matlab/+caffe/private/is_valid_handle.m new file mode 100644 index 00000000000..f03469c4f86 --- /dev/null +++ b/matlab/+caffe/private/is_valid_handle.m @@ -0,0 +1,28 @@ +function valid = is_valid_handle(hObj) +% valid = is_valid_handle(hObj) or is_valid_handle('get_new_init_key') +% Check if a handle is valid (has the right data type and init_key matches) +% Use is_valid_handle('get_new_init_key') to get new init_key from C++; + +% a handle is a struct array with the following fields +% (uint64) ptr : the pointer to the C++ object +% (double) init_key : caffe initialization key + +persistent init_key; +if isempty(init_key) + init_key = caffe_('get_init_key'); +end + +% is_valid_handle('get_new_init_key') to get new init_key from C++; +if ischar(hObj) && strcmp(hObj, 'get_new_init_key') + init_key = caffe_('get_init_key'); + valid = true; + return +else + % check whether data types are correct and init_key matches + valid = isstruct(hObj) ... + && isscalar(hObj.ptr) && isa(hObj.ptr, 'uint64') ... + && isscalar(hObj.init_key) && isa(hObj.init_key, 'double') ... + && hObj.init_key == init_key; +end + +end \ No newline at end of file diff --git a/matlab/+caffe/reset.m b/matlab/+caffe/reset.m new file mode 100644 index 00000000000..2df812b3f1d --- /dev/null +++ b/matlab/+caffe/reset.m @@ -0,0 +1,8 @@ +function reset() +% reset() +% reset Caffe to initial status + +caffe_('reset'); +is_valid_handle('get_new_init_key'); + +end \ No newline at end of file diff --git a/matlab/+caffe/run_tests.m b/matlab/+caffe/run_tests.m new file mode 100644 index 00000000000..20834d497c2 --- /dev/null +++ b/matlab/+caffe/run_tests.m @@ -0,0 +1,12 @@ +function results = run_tests() +% results = run_tests() +% run all tests in this caffe matlab wrapper package + +caffe.reset(); +results = [... + run(caffe.test.test_net) ... + run(caffe.test.test_solver) + ]; +caffe.reset(); + +end \ No newline at end of file diff --git a/matlab/+caffe/set_device.m b/matlab/+caffe/set_device.m new file mode 100644 index 00000000000..43f00bddee6 --- /dev/null +++ b/matlab/+caffe/set_device.m @@ -0,0 +1,11 @@ +function set_device(device_id) +% set_device(device_id) +% set Caffe's GPU device ID + +CHECK(isscalar(device_id) && device_id >= 0, ... + 'device_id must be non-negative integer'); +device_id = double(device_id); + +caffe_('set_device', device_id); + +end \ No newline at end of file diff --git a/matlab/+caffe/set_mode_cpu.m b/matlab/+caffe/set_mode_cpu.m new file mode 100644 index 00000000000..8c0576ccbe4 --- /dev/null +++ b/matlab/+caffe/set_mode_cpu.m @@ -0,0 +1,7 @@ +function set_mode_cpu() +% set_mode_cpu() +% set Caffe to CPU mode + +caffe_('set_mode_cpu'); + +end \ No newline at end of file diff --git a/matlab/+caffe/set_mode_gpu.m b/matlab/+caffe/set_mode_gpu.m new file mode 100644 index 00000000000..ecd13b59bba --- /dev/null +++ b/matlab/+caffe/set_mode_gpu.m @@ -0,0 +1,7 @@ +function set_mode_gpu() +% set_mode_gpu() +% set Caffe to GPU mode + +caffe_('set_mode_gpu'); + +end \ No newline at end of file diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt index 791a4e70f43..63182abcc44 100644 --- a/matlab/CMakeLists.txt +++ b/matlab/CMakeLists.txt @@ -32,7 +32,9 @@ endfunction() # global settings file(GLOB Matlab_srcs caffe/matcaffe.cpp) +file(GLOB Matlab_pkg_srcs +caffe/private/caffe_.cpp) set(Matlab_caffe_mex ${PROJECT_SOURCE_DIR}/matlab/caffe/caffe.mex) +set(Matlab_caffe_pkg_mex ${PROJECT_SOURCE_DIR}/matlab/+caffe/private/caffe_.mex) caffe_get_current_cflags(cflags) caffe_parse_linker_libs(Caffe_LINKER_LIBS folders libflags macos_frameworks) @@ -50,9 +52,15 @@ if(build_using MATCHES "Matlab") ARGS -output ${Matlab_caffe_mex} ${Matlab_srcs} ${cflags} ${link_folders} ${libflags} DEPENDS caffe COMMENT "Building Matlab interface: ${Matlab_caffe_mex}" VERBATIM) add_custom_target(matlab ALL DEPENDS ${Matlab_caffe_mex} SOURCES ${Matlab_srcs}) + caffe_fetch_and_set_proper_mexext(Matlab_caffe_pkg_mex) + add_custom_command(OUTPUT ${Matlab_caffe_pkg_mex} COMMAND ${Matlab_mex} + ARGS -output ${Matlab_caffe_pkg_mex} ${Matlab_pkg_srcs} ${cflags} ${link_folders} ${libflags} + DEPENDS caffe COMMENT "Building Matlab interface: ${Matlab_caffe_pkg_mex}" VERBATIM) + add_custom_target(matlab ALL DEPENDS ${Matlab_caffe_pkg_mex} SOURCES ${Matlab_pkg_srcs}) elseif(build_using MATCHES "Octave") + # Note: Matlab Caffe package cannot be used in Octave, so we don't build it if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") set(libflags -Wl,-force_load,$ ${libflags}) elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") From a53df9892c49758bfee1de3455054dec9fc6dbdb Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Wed, 27 May 2015 12:37:20 +0800 Subject: [PATCH 040/331] Fix matlab tailing dimension 1 issue for shape match Matlab cannot have tailing dimension 1 for ndim > 2, so you cannot create 20 x 10 x 1 x 1 array in matlab as it becomes 20 x 10. Extend matlab arrays to have tailing dimension 1 during shape match. --- matlab/+caffe/+test/test_net.m | 2 +- matlab/+caffe/+test/test_solver.m | 2 +- matlab/+caffe/Blob.m | 15 ++++++++++----- matlab/+caffe/get_net.m | 1 - matlab/+caffe/get_solver.m | 2 +- matlab/+caffe/io.m | 2 +- matlab/+caffe/private/CHECK.m | 2 +- matlab/+caffe/private/CHECK_FILE_EXIST.m | 2 +- matlab/+caffe/private/is_valid_handle.m | 2 +- matlab/+caffe/reset.m | 2 +- matlab/+caffe/run_tests.m | 2 +- matlab/+caffe/set_device.m | 2 +- matlab/+caffe/set_mode_cpu.m | 2 +- matlab/+caffe/set_mode_gpu.m | 2 +- 14 files changed, 22 insertions(+), 18 deletions(-) diff --git a/matlab/+caffe/+test/test_net.m b/matlab/+caffe/+test/test_net.m index 4958d50f9e3..5d9ba000209 100644 --- a/matlab/+caffe/+test/test_net.m +++ b/matlab/+caffe/+test/test_net.m @@ -71,4 +71,4 @@ function test_save_and_read(self) end end end -end \ No newline at end of file +end diff --git a/matlab/+caffe/+test/test_solver.m b/matlab/+caffe/+test/test_solver.m index 9774ec1d2fd..682dad48a3b 100644 --- a/matlab/+caffe/+test/test_solver.m +++ b/matlab/+caffe/+test/test_solver.m @@ -40,4 +40,4 @@ function test_solve(self) self.verifyEqual(self.solver.iter(), 100) end end -end \ No newline at end of file +end diff --git a/matlab/+caffe/Blob.m b/matlab/+caffe/Blob.m index a6326d1a36c..f9b64096adc 100644 --- a/matlab/+caffe/Blob.m +++ b/matlab/+caffe/Blob.m @@ -51,7 +51,6 @@ function check_data_size_matches(self, data) % note: matlab arrays always have at least 2 dimensions. To compare % shape between size of data and shape of this blob, extend shape of % this blob to have at least 2 dimensions - data_size = size(data); self_shape_extended = self.shape; if isempty(self_shape_extended) % target blob is a scalar (0 dim) @@ -60,12 +59,18 @@ function check_data_size_matches(self, data) % target blob is a vector (1 dim) self_shape_extended = [self_shape_extended, 1]; end - is_matched = (length(self_shape_extended) == length(data_size)) ... - && all(self_shape_extended == data_size); + % also, matlab cannot have tailing dimension 1 for ndim > 2, so you + % cannot create 20 x 10 x 1 x 1 array in matlab as it becomes 20 x 10 + % extend matlab arrays to have tailing dimension 1 during shape match + data_size_extended = ... + [size(data), ones(1, length(self_shape_extended) - ndims(data))]; + is_matched = ... + (length(self_shape_extended) == length(data_size_extended)) ... + && all(self_shape_extended == data_size_extended); CHECK(is_matched, ... sprintf('%s, data size: [ %s], blob shape: [ %s]', ... 'data size does not match blob shape', ... - sprintf('%d ', data_size), sprintf('%d ', self_shape_extended))); + sprintf('%d ', data_size_extended), sprintf('%d ', self_shape_extended))); end end -end \ No newline at end of file +end diff --git a/matlab/+caffe/get_net.m b/matlab/+caffe/get_net.m index 04872b263c8..d60979d04b5 100644 --- a/matlab/+caffe/get_net.m +++ b/matlab/+caffe/get_net.m @@ -34,4 +34,3 @@ end end - diff --git a/matlab/+caffe/get_solver.m b/matlab/+caffe/get_solver.m index 855709c725e..30366d851e4 100644 --- a/matlab/+caffe/get_solver.m +++ b/matlab/+caffe/get_solver.m @@ -8,4 +8,4 @@ pSolver = caffe_('get_solver', solver_file); solver = caffe.Solver(pSolver); -end \ No newline at end of file +end diff --git a/matlab/+caffe/io.m b/matlab/+caffe/io.m index 95d58909abd..7fad9686ac1 100644 --- a/matlab/+caffe/io.m +++ b/matlab/+caffe/io.m @@ -19,4 +19,4 @@ mean_data = caffe_('read_mean', mean_proto_file); end end -end \ No newline at end of file +end diff --git a/matlab/+caffe/private/CHECK.m b/matlab/+caffe/private/CHECK.m index 1cf21032b36..21706549cfa 100644 --- a/matlab/+caffe/private/CHECK.m +++ b/matlab/+caffe/private/CHECK.m @@ -4,4 +4,4 @@ function CHECK(expr, error_msg) error(error_msg); end -end \ No newline at end of file +end diff --git a/matlab/+caffe/private/CHECK_FILE_EXIST.m b/matlab/+caffe/private/CHECK_FILE_EXIST.m index 1db464c8258..8c80fb8094f 100644 --- a/matlab/+caffe/private/CHECK_FILE_EXIST.m +++ b/matlab/+caffe/private/CHECK_FILE_EXIST.m @@ -4,4 +4,4 @@ function CHECK_FILE_EXIST(filename) error('%s does not exist', filename); end -end \ No newline at end of file +end diff --git a/matlab/+caffe/private/is_valid_handle.m b/matlab/+caffe/private/is_valid_handle.m index f03469c4f86..77abf21dd11 100644 --- a/matlab/+caffe/private/is_valid_handle.m +++ b/matlab/+caffe/private/is_valid_handle.m @@ -25,4 +25,4 @@ && hObj.init_key == init_key; end -end \ No newline at end of file +end diff --git a/matlab/+caffe/reset.m b/matlab/+caffe/reset.m index 2df812b3f1d..c1cfea41a76 100644 --- a/matlab/+caffe/reset.m +++ b/matlab/+caffe/reset.m @@ -5,4 +5,4 @@ function reset() caffe_('reset'); is_valid_handle('get_new_init_key'); -end \ No newline at end of file +end diff --git a/matlab/+caffe/run_tests.m b/matlab/+caffe/run_tests.m index 20834d497c2..fb1089c2d96 100644 --- a/matlab/+caffe/run_tests.m +++ b/matlab/+caffe/run_tests.m @@ -9,4 +9,4 @@ ]; caffe.reset(); -end \ No newline at end of file +end diff --git a/matlab/+caffe/set_device.m b/matlab/+caffe/set_device.m index 43f00bddee6..f94068cbe98 100644 --- a/matlab/+caffe/set_device.m +++ b/matlab/+caffe/set_device.m @@ -8,4 +8,4 @@ function set_device(device_id) caffe_('set_device', device_id); -end \ No newline at end of file +end diff --git a/matlab/+caffe/set_mode_cpu.m b/matlab/+caffe/set_mode_cpu.m index 8c0576ccbe4..a87e0e2852b 100644 --- a/matlab/+caffe/set_mode_cpu.m +++ b/matlab/+caffe/set_mode_cpu.m @@ -4,4 +4,4 @@ function set_mode_cpu() caffe_('set_mode_cpu'); -end \ No newline at end of file +end diff --git a/matlab/+caffe/set_mode_gpu.m b/matlab/+caffe/set_mode_gpu.m index ecd13b59bba..78e5f6773a1 100644 --- a/matlab/+caffe/set_mode_gpu.m +++ b/matlab/+caffe/set_mode_gpu.m @@ -4,4 +4,4 @@ function set_mode_gpu() caffe_('set_mode_gpu'); -end \ No newline at end of file +end From 9735f4b3b257379ac4e6c9d310aab32bfb198661 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Thu, 28 May 2015 13:40:26 +0800 Subject: [PATCH 041/331] Aesthetic changes on code style and some minor fix --- matlab/+caffe/Blob.m | 22 ++-- matlab/+caffe/Layer.m | 2 +- matlab/+caffe/Net.m | 10 +- matlab/+caffe/Solver.m | 2 +- matlab/+caffe/get_net.m | 3 +- matlab/+caffe/get_solver.m | 1 - matlab/+caffe/io.m | 15 ++- matlab/+caffe/private/caffe_.cpp | 154 ++++++++++++------------ matlab/+caffe/private/is_valid_handle.m | 1 - matlab/+caffe/run_tests.m | 8 +- 10 files changed, 113 insertions(+), 105 deletions(-) diff --git a/matlab/+caffe/Blob.m b/matlab/+caffe/Blob.m index f9b64096adc..e39f7ee3f20 100644 --- a/matlab/+caffe/Blob.m +++ b/matlab/+caffe/Blob.m @@ -7,9 +7,9 @@ methods function self = Blob(hBlob_blob) - CHECK(is_valid_handle(hBlob_blob), 'invalid input handle'); + CHECK(is_valid_handle(hBlob_blob), 'invalid Blob handle'); - % setup self handle and attributes + % setup self handle self.hBlob_self = hBlob_blob; end function shape = shape(self) @@ -37,14 +37,16 @@ function set_diff(self, diff) methods (Access = private) function shape = check_and_preprocess_shape(~, shape) - CHECK(isempty(shape) || isnumeric(shape) && isrow(shape), ... + CHECK(isempty(shape) || (isnumeric(shape) && isrow(shape)), ... 'shape must be a integer row vector'); shape = double(shape); end function data = check_and_preprocess_data(self, data) CHECK(isnumeric(data), 'data or diff must be numeric types'); - self.check_data_size_matches(data) - data = single(data); + self.check_data_size_matches(data); + if ~isa(data, 'single') + data = single(data); + end end function check_data_size_matches(self, data) % check whether size of data matches shape of this blob @@ -59,17 +61,17 @@ function check_data_size_matches(self, data) % target blob is a vector (1 dim) self_shape_extended = [self_shape_extended, 1]; end - % also, matlab cannot have tailing dimension 1 for ndim > 2, so you + % Also, matlab cannot have tailing dimension 1 for ndim > 2, so you % cannot create 20 x 10 x 1 x 1 array in matlab as it becomes 20 x 10 - % extend matlab arrays to have tailing dimension 1 during shape match + % Extend matlab arrays to have tailing dimension 1 during shape match data_size_extended = ... [size(data), ones(1, length(self_shape_extended) - ndims(data))]; is_matched = ... - (length(self_shape_extended) == length(data_size_extended)) ... + (length(self_shape_extended) == length(data_size_extended)) ... && all(self_shape_extended == data_size_extended); CHECK(is_matched, ... - sprintf('%s, data size: [ %s], blob shape: [ %s]', ... - 'data size does not match blob shape', ... + sprintf('%s, input data/diff size: [ %s] vs target blob shape: [ %s]', ... + 'input data/diff size does not match target blob shape', ... sprintf('%d ', data_size_extended), sprintf('%d ', self_shape_extended))); end end diff --git a/matlab/+caffe/Layer.m b/matlab/+caffe/Layer.m index 7587ed7ddf7..4c2023101a5 100644 --- a/matlab/+caffe/Layer.m +++ b/matlab/+caffe/Layer.m @@ -13,7 +13,7 @@ methods function self = Layer(hLayer_layer) - CHECK(is_valid_handle(hLayer_layer), 'invalid input handle'); + CHECK(is_valid_handle(hLayer_layer), 'invalid Layer handle'); % setup self handle and attributes self.hLayer_self = hLayer_layer; diff --git a/matlab/+caffe/Net.m b/matlab/+caffe/Net.m index 5319634dc8b..a6761060dfb 100644 --- a/matlab/+caffe/Net.m +++ b/matlab/+caffe/Net.m @@ -33,7 +33,7 @@ end % construct a net from handle hNet_net = varargin{1}; - CHECK(is_valid_handle(hNet_net), 'invalid input handle'); + CHECK(is_valid_handle(hNet_net), 'invalid Net handle'); % setup self handle and attributes self.hNet_self = hNet_net; @@ -64,7 +64,7 @@ self.name2blob_index = containers.Map(self.attributes.blob_names, ... 1:length(self.attributes.blob_names)); - % expose layer_names and blob_names for public access + % expose layer_names and blob_names for public read access self.layer_names = self.attributes.layer_names; self.blob_names = self.attributes.blob_names; end @@ -91,12 +91,12 @@ function backward_prefilled(self) CHECK(iscell(input_data), 'input_data must be a cell array'); CHECK(length(input_data) == length(self.inputs), ... 'input data cell length must match input blob number'); - % copy data to input_blobs + % copy data to input blobs for n = 1:length(self.inputs) self.blobs(self.inputs{n}).set_data(input_data{n}); end self.forward_prefilled(); - % retrieve data from output_blobs + % retrieve data from output blobs res = cell(length(self.outputs), 1); for n = 1:length(self.outputs) res{n} = self.blobs(self.outputs{n}).get_data(); @@ -106,7 +106,7 @@ function backward_prefilled(self) CHECK(iscell(output_diff), 'output_diff must be a cell array'); CHECK(length(output_diff) == length(self.outputs), ... 'output diff cell length must match output blob number'); - % copy diff to output_blobs + % copy diff to output blobs for n = 1:length(self.outputs) self.blobs(self.outputs{n}).set_diff(output_diff{n}); end diff --git a/matlab/+caffe/Solver.m b/matlab/+caffe/Solver.m index 80fa5394739..daaa8022b91 100644 --- a/matlab/+caffe/Solver.m +++ b/matlab/+caffe/Solver.m @@ -23,7 +23,7 @@ end % construct a solver from handle hSolver_solver = varargin{1}; - CHECK(is_valid_handle(hSolver_solver), 'invalid input handle'); + CHECK(is_valid_handle(hSolver_solver), 'invalid Solver handle'); % setup self handle and attributes self.hSolver_self = hSolver_solver; diff --git a/matlab/+caffe/get_net.m b/matlab/+caffe/get_net.m index d60979d04b5..4b5683eb82e 100644 --- a/matlab/+caffe/get_net.m +++ b/matlab/+caffe/get_net.m @@ -5,7 +5,7 @@ % phase_name can only be 'train' or 'test' CHECK(nargin == 2 || nargin == 3, ['usage: ' ... - 'net = get_net(model_file, phase_name) or ', ... + 'net = get_net(model_file, phase_name) or ' ... 'net = get_net(model_file, weights_file, phase_name)']); if nargin == 3 model_file = varargin{1}; @@ -23,6 +23,7 @@ sprintf('phase_name can only be %strain%s or %stest%s', ... char(39), char(39), char(39), char(39))); +% construct caffe net from model_file hNet = caffe_('get_net', model_file, phase_name); net = caffe.Net(hNet); diff --git a/matlab/+caffe/get_solver.m b/matlab/+caffe/get_solver.m index 30366d851e4..74d576eb31b 100644 --- a/matlab/+caffe/get_solver.m +++ b/matlab/+caffe/get_solver.m @@ -4,7 +4,6 @@ CHECK(ischar(solver_file), 'solver_file must be a string'); CHECK_FILE_EXIST(solver_file); - pSolver = caffe_('get_solver', solver_file); solver = caffe.Solver(pSolver); diff --git a/matlab/+caffe/io.m b/matlab/+caffe/io.m index 7fad9686ac1..7a30bfb5772 100644 --- a/matlab/+caffe/io.m +++ b/matlab/+caffe/io.m @@ -3,17 +3,20 @@ methods (Static) function im_data = load_image(im_file) + % im_data = load_image(im_file) + % load an image from disk into Caffe-supported data format + % switch channels from RGB to BGR, make width the fastest dimension + % and convert to single CHECK(ischar(im_file), 'im_file must be a string'); CHECK_FILE_EXIST(im_file); - % load an image from disk into Caffe-supported data format - % switch channels from RGB to BGR, make width the fastest dimension, and - % convert to single - im = imread(im_file); - im_data = im(:, :, [3, 2, 1]); - im_data = permute(im_data, [2 1 3]); + im_data = imread(im_file); + im_data = im_data(:, :, [3, 2, 1]); + im_data = permute(im_data, [2, 1, 3]); im_data = single(im_data); end function mean_data = read_mean(mean_proto_file) + % mean_data = read_mean(mean_proto_file) + % read image mean data from binaryproto file CHECK(ischar(mean_proto_file), 'im_file must be a string'); CHECK_FILE_EXIST(mean_proto_file); mean_data = caffe_('read_mean', mean_proto_file); diff --git a/matlab/+caffe/private/caffe_.cpp b/matlab/+caffe/private/caffe_.cpp index 96a1920ac39..4e0ebc1c00a 100644 --- a/matlab/+caffe/private/caffe_.cpp +++ b/matlab/+caffe/private/caffe_.cpp @@ -21,21 +21,22 @@ using namespace caffe; // NOLINT(build/namespaces) -// Do CHECK and throw a Mex error if check failsf -inline void mxCHECK(bool expr, const std::string &msg) { +// Do CHECK and throw a Mex error if check fails +inline void mxCHECK(bool expr, const char* msg) { if (!expr) { - LOG(ERROR) << msg; - mexErrMsgTxt(msg.c_str()); + mexErrMsgTxt(msg); } } -inline void mxERROR(const std::string &msg) { mxCHECK(false, msg); } +inline void mxERROR(const char* msg) { mexErrMsgTxt(msg); } // Check if a file exists and can be opened void mxCHECK_FILE_EXIST(const char* file) { std::ifstream f(file); if (!f.good()) { f.close(); - mxERROR("Could not open file " + string(file)); + std::string msg("Could not open file "); + msg += file; + mxERROR(msg.c_str()); } f.close(); } @@ -43,6 +44,7 @@ void mxCHECK_FILE_EXIST(const char* file) { // The pointers to caffe::Solver and caffe::Net instances static vector > > solvers_; static vector > > nets_; +// init_key is generated at the beginning and everytime you call reset static double init_key = static_cast(caffe_rng_rand()); /** ----------------------------------------------------------------- @@ -104,17 +106,17 @@ static mxArray* blob_to_mx_mat(const Blob* blob, return mx_mat; } -// convert vector to matlab vector +// Convert vector to matlab row vector static mxArray* int_vec_to_mx_vec(const vector& int_vec) { mxArray* mx_vec = mxCreateDoubleMatrix(int_vec.size(), 1, mxREAL); double* vec_mem_ptr = mxGetPr(mx_vec); for (int i = 0; i < int_vec.size(); i++) { - vec_mem_ptr[i] = int_vec[i]; + vec_mem_ptr[i] = static_cast(int_vec[i]); } return mx_vec; } -// convert vector to matlab string cell vector +// Convert vector to matlab cell vector of strings static mxArray* str_vec_to_mx_strcell(const vector& str_vec) { mxArray* mx_strcell = mxCreateCellMatrix(str_vec.size(), 1); for (int i = 0; i < str_vec.size(); i++) { @@ -135,44 +137,46 @@ static T* handle_to_ptr(const mxArray* mx_handle) { mxArray* mx_ptr = mxGetField(mx_handle, 0, "ptr"); mxArray* mx_init_key = mxGetField(mx_handle, 0, "init_key"); mxCHECK(mxIsUint64(mx_ptr), "pointer type must be uint64"); - mxCHECK(mxGetScalar(mx_init_key) == init_key, "incorrect handle init_key"); + mxCHECK(mxGetScalar(mx_init_key) == init_key, + "Could not convert handle to pointer due to invalid init_key. " + "The object might have been cleared."); return reinterpret_cast(*reinterpret_cast(mxGetData(mx_ptr))); } -// Create an empty handle struct array +// Create a handle struct vector, without setting up each handle in it template -static mxArray* create_handles(int ptr_num) { +static mxArray* create_handle_vec(int ptr_num) { const int handle_field_num = 2; const char* handle_fields[handle_field_num] = { "ptr", "init_key" }; return mxCreateStructMatrix(ptr_num, 1, handle_field_num, handle_fields); } -// Set up each handle in a handle struct array +// Set up a handle in a handle struct vector by its index template -static void setup_handle(const T* ptr, int index, mxArray* mx_handles) { +static void setup_handle(const T* ptr, int index, mxArray* mx_handle_vec) { mxArray* mx_ptr = mxCreateNumericMatrix(1, 1, mxUINT64_CLASS, mxREAL); *reinterpret_cast(mxGetData(mx_ptr)) = reinterpret_cast(ptr); - mxSetField(mx_handles, index, "ptr", mx_ptr); - mxSetField(mx_handles, index, "init_key", mxCreateDoubleScalar(init_key)); + mxSetField(mx_handle_vec, index, "ptr", mx_ptr); + mxSetField(mx_handle_vec, index, "init_key", mxCreateDoubleScalar(init_key)); } // Convert a pointer in C++ to a handle in matlab template static mxArray* ptr_to_handle(const T* ptr) { - mxArray* mx_handle = create_handles(1); + mxArray* mx_handle = create_handle_vec(1); setup_handle(ptr, 0, mx_handle); return mx_handle; } -// Convert a vector of shared_ptr in C++ to handle struct array in matlab +// Convert a vector of shared_ptr in C++ to handle struct vector template -static mxArray* ptr_vec_to_handles(const vector >& ptr_vec) { - mxArray* mx_handle = create_handles(ptr_vec.size()); +static mxArray* ptr_vec_to_handle_vec(const vector >& ptr_vec) { + mxArray* mx_handle_vec = create_handle_vec(ptr_vec.size()); for (int i = 0; i < ptr_vec.size(); i++) { - setup_handle(ptr_vec[i].get(), i, mx_handle); + setup_handle(ptr_vec[i].get(), i, mx_handle_vec); } - return mx_handle; + return mx_handle_vec; } /** ----------------------------------------------------------------- @@ -182,12 +186,12 @@ static mxArray* ptr_vec_to_handles(const vector >& ptr_vec) { static void get_solver(MEX_ARGS) { mxCHECK(nrhs == 1 && mxIsChar(prhs[0]), "Usage: caffe_('get_solver', solver_file)"); - const char* solver_file = mxArrayToString(prhs[0]); + char* solver_file = mxArrayToString(prhs[0]); mxCHECK_FILE_EXIST(solver_file); - shared_ptr > solver; - solver.reset(new caffe::SGDSolver(solver_file)); + shared_ptr > solver(new caffe::SGDSolver(solver_file)); solvers_.push_back(solver); plhs[0] = ptr_to_handle >(solver.get()); + mxFree(solver_file); } // Usage: caffe_('solver_get_attr', hSolver) @@ -202,7 +206,7 @@ static void solver_get_attr(MEX_ARGS) { mxSetField(mx_solver_attr, 0, "hNet_net", ptr_to_handle >(solver->net().get())); mxSetField(mx_solver_attr, 0, "hNet_test_nets", - ptr_vec_to_handles >(solver->test_nets())); + ptr_vec_to_handle_vec >(solver->test_nets())); plhs[0] = mx_solver_attr; } @@ -219,9 +223,10 @@ static void solver_restore(MEX_ARGS) { mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsChar(prhs[1]), "Usage: caffe_('solver_restore', hSolver, snapshot_file)"); Solver* solver = handle_to_ptr >(prhs[0]); - const char* snapshot_file = mxArrayToString(prhs[1]); + char* snapshot_file = mxArrayToString(prhs[1]); mxCHECK_FILE_EXIST(snapshot_file); solver->Restore(snapshot_file); + mxFree(snapshot_file); } // Usage: caffe_('solver_solve', hSolver) @@ -232,10 +237,10 @@ static void solver_solve(MEX_ARGS) { solver->Solve(); } -// Usage: caffe_('solver_solve', hSolver, iters) +// Usage: caffe_('solver_step', hSolver, iters) static void solver_step(MEX_ARGS) { mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsDouble(prhs[1]), - "Usage: caffe_('solver_solve', hSolver, iters)"); + "Usage: caffe_('solver_step', hSolver, iters)"); Solver* solver = handle_to_ptr >(prhs[0]); int iters = mxGetScalar(prhs[1]); solver->Step(iters); @@ -245,21 +250,22 @@ static void solver_step(MEX_ARGS) { static void get_net(MEX_ARGS) { mxCHECK(nrhs == 2 && mxIsChar(prhs[0]) && mxIsChar(prhs[1]), "Usage: caffe_('get_net', model_file, phase_name)"); - const char* model_file = mxArrayToString(prhs[0]); + char* model_file = mxArrayToString(prhs[0]); + char* phase_name = mxArrayToString(prhs[1]); mxCHECK_FILE_EXIST(model_file); - const char* phase_name = mxArrayToString(prhs[1]); Phase phase; if (strcmp(phase_name, "train") == 0) { phase = TRAIN; } else if (strcmp(phase_name, "test") == 0) { phase = TEST; } else { - mxERROR("Unknown phase."); + mxERROR("Unknown phase"); } - shared_ptr > net; - net.reset(new caffe::Net(model_file, phase)); + shared_ptr > net(new caffe::Net(model_file, phase)); nets_.push_back(net); plhs[0] = ptr_to_handle >(net.get()); + mxFree(model_file); + mxFree(phase_name); } // Usage: caffe_('net_get_attr', hNet) @@ -273,15 +279,15 @@ static void net_get_attr(MEX_ARGS) { mxArray* mx_net_attr = mxCreateStructMatrix(1, 1, net_attr_num, net_attrs); mxSetField(mx_net_attr, 0, "hLayer_layers", - ptr_vec_to_handles >(net->layers())); + ptr_vec_to_handle_vec >(net->layers())); mxSetField(mx_net_attr, 0, "hBlob_blobs", - ptr_vec_to_handles >(net->blobs())); + ptr_vec_to_handle_vec >(net->blobs())); mxSetField(mx_net_attr, 0, "input_blob_indices", int_vec_to_mx_vec(net->input_blob_indices())); mxSetField(mx_net_attr, 0, "output_blob_indices", int_vec_to_mx_vec(net->output_blob_indices())); mxSetField(mx_net_attr, 0, "layer_names", - str_vec_to_mx_strcell(net->layer_names())); + str_vec_to_mx_strcell(net->layer_names())); mxSetField(mx_net_attr, 0, "blob_names", str_vec_to_mx_strcell(net->blob_names())); plhs[0] = mx_net_attr; @@ -308,9 +314,10 @@ static void net_copy_from(MEX_ARGS) { mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsChar(prhs[1]), "Usage: caffe_('net_copy_from', hNet, weights_file)"); Net* net = handle_to_ptr >(prhs[0]); - const char* weights_file = mxArrayToString(prhs[1]); + char* weights_file = mxArrayToString(prhs[1]); mxCHECK_FILE_EXIST(weights_file); net->CopyTrainedLayersFrom(weights_file); + mxFree(weights_file); } // Usage: caffe_('net_reshape', hNet) @@ -326,10 +333,11 @@ static void net_save(MEX_ARGS) { mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsChar(prhs[1]), "Usage: caffe_('net_save', hNet, save_file)"); Net* net = handle_to_ptr >(prhs[0]); - const char* weights_file = mxArrayToString(prhs[1]); + char* weights_file = mxArrayToString(prhs[1]); NetParameter net_param; net->ToProto(&net_param, false); WriteProtoToBinaryFile(net_param, weights_file); + mxFree(weights_file); } // Usage: caffe_('layer_get_attr', hLayer) @@ -342,14 +350,14 @@ static void layer_get_attr(MEX_ARGS) { mxArray* mx_layer_attr = mxCreateStructMatrix(1, 1, layer_attr_num, layer_attrs); mxSetField(mx_layer_attr, 0, "hBlob_blobs", - ptr_vec_to_handles >(layer->blobs())); + ptr_vec_to_handle_vec >(layer->blobs())); plhs[0] = mx_layer_attr; } -// Usage: caffe_('layer_get_attr', hLayer) +// Usage: caffe_('layer_get_type', hLayer) static void layer_get_type(MEX_ARGS) { mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]), - "Usage: caffe_('layer_get_attr', hLayer)"); + "Usage: caffe_('layer_get_type', hLayer)"); Layer* layer = handle_to_ptr >(prhs[0]); plhs[0] = mxCreateString(layer->type()); } @@ -446,10 +454,12 @@ static void get_init_key(MEX_ARGS) { // Usage: caffe_('reset') static void reset(MEX_ARGS) { mxCHECK(nrhs == 0, "Usage: caffe_('reset')"); - mexPrintf("cleared %d solvers and %d stand-alone nets\n", solvers_.size(), - nets_.size()); + // Clear solvers and stand-alone nets + mexPrintf("Cleared %d solvers and %d stand-alone nets\n", + solvers_.size(), nets_.size()); solvers_.clear(); nets_.clear(); + // Generate new init_key, so that handles created before becomes invalid init_key = static_cast(caffe_rng_rand()); } @@ -457,21 +467,15 @@ static void reset(MEX_ARGS) { static void read_mean(MEX_ARGS) { mxCHECK(nrhs == 1 && mxIsChar(prhs[0]), "Usage: caffe_('read_mean', mean_proto_file)"); - const char* mean_proto_file = mxArrayToString(prhs[0]); + char* mean_proto_file = mxArrayToString(prhs[0]); + mxCHECK_FILE_EXIST(mean_proto_file); Blob data_mean; - mexPrintf("Loading mean file from: %s\n", mean_proto_file); BlobProto blob_proto; bool result = ReadProtoFromBinaryFile(mean_proto_file, &blob_proto); - mxCHECK(result, "Couldn't read the file"); + mxCHECK(result, "Could not read your mean file"); data_mean.FromProto(blob_proto); - mwSize dims[4] = {data_mean.width(), data_mean.height(), - data_mean.channels(), data_mean.num() }; - mxArray* mx_blob = mxCreateNumericArray(4, dims, mxSINGLE_CLASS, mxREAL); - float* data_ptr = reinterpret_cast(mxGetData(mx_blob)); - caffe_copy(data_mean.count(), data_mean.cpu_data(), data_ptr); - mexPrintf("Remember that Caffe saves in [width, height, channels]" - " format and channels are also BGR!\n"); - plhs[0] = mx_blob; + plhs[0] = blob_to_mx_mat(&data_mean, DATA); + mxFree(mean_proto_file); } /** ----------------------------------------------------------------- @@ -516,31 +520,27 @@ static handler_registry handlers[] = { }; /** ----------------------------------------------------------------- - ** matlab entry point: caffe_(api_command, arg1, arg2, ...) + ** matlab entry point. **/ +// Usage: caffe_(api_command, arg1, arg2, ...) void mexFunction(MEX_ARGS) { mexLock(); // Avoid clearing the mex file. - if (nrhs == 0) { - mxERROR("No API command given"); - return; - } - - { // Handle input command - char* cmd = mxArrayToString(prhs[0]); - bool dispatched = false; - // Dispatch to cmd handler - for (int i = 0; handlers[i].func != NULL; i++) { - if (handlers[i].cmd.compare(cmd) == 0) { - handlers[i].func(nlhs, plhs, nrhs-1, prhs+1); - dispatched = true; - break; - } - } - if (!dispatched) { - ostringstream error_msg; - error_msg << "Unknown command '" << cmd << "'"; - mxERROR(error_msg.str().c_str()); + mxCHECK(nrhs > 0, "Usage: caffe_(api_command, arg1, arg2, ...)"); + // Handle input command + char* cmd = mxArrayToString(prhs[0]); + bool dispatched = false; + // Dispatch to cmd handler + for (int i = 0; handlers[i].func != NULL; i++) { + if (handlers[i].cmd.compare(cmd) == 0) { + handlers[i].func(nlhs, plhs, nrhs-1, prhs+1); + dispatched = true; + break; } - mxFree(cmd); } + if (!dispatched) { + ostringstream error_msg; + error_msg << "Unknown command '" << cmd << "'"; + mxERROR(error_msg.str().c_str()); + } + mxFree(cmd); } diff --git a/matlab/+caffe/private/is_valid_handle.m b/matlab/+caffe/private/is_valid_handle.m index 77abf21dd11..a0648ecdf61 100644 --- a/matlab/+caffe/private/is_valid_handle.m +++ b/matlab/+caffe/private/is_valid_handle.m @@ -15,7 +15,6 @@ % is_valid_handle('get_new_init_key') to get new init_key from C++; if ischar(hObj) && strcmp(hObj, 'get_new_init_key') init_key = caffe_('get_init_key'); - valid = true; return else % check whether data types are correct and init_key matches diff --git a/matlab/+caffe/run_tests.m b/matlab/+caffe/run_tests.m index fb1089c2d96..afdd8f3309d 100644 --- a/matlab/+caffe/run_tests.m +++ b/matlab/+caffe/run_tests.m @@ -2,11 +2,15 @@ % results = run_tests() % run all tests in this caffe matlab wrapper package +% reset caffe before testing caffe.reset(); + +% put all test cases here results = [... run(caffe.test.test_net) ... - run(caffe.test.test_solver) - ]; + run(caffe.test.test_solver) ]; + +% reset caffe after testing caffe.reset(); end From 6af8efc0bf51d475077be146e5ab7b7899ad705d Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Thu, 28 May 2015 14:52:47 +0800 Subject: [PATCH 042/331] Add MatCaffe docs to docs/tutorial/interfaces.md --- docs/tutorial/interfaces.md | 209 +++++++++++++++++++++++++++++++++++- 1 file changed, 205 insertions(+), 4 deletions(-) diff --git a/docs/tutorial/interfaces.md b/docs/tutorial/interfaces.md index 17430b35c57..f824c7cc54b 100644 --- a/docs/tutorial/interfaces.md +++ b/docs/tutorial/interfaces.md @@ -67,10 +67,211 @@ Compile pycaffe by `make pycaffe`. The module dir caffe/python/caffe should be i ## MATLAB -The MATLAB interface -- matcaffe -- is the `caffe` mex and its helper m-files in caffe/matlab. Load models, do forward and backward, extract output and read-only model weights, and load the binaryproto format mean as a matrix. +The MATLAB interface -- matcaffe -- is a `caffe` package in caffe/matlab in which you can integrate Caffe in your Matlab code. -A MATLAB demo is in caffe/matlab/caffe/matcaffe_demo.m +In MatCaffe, you can -Note that MATLAB matrices and memory are in column-major layout counter to Caffe's row-major layout! Double-check your work accordingly. +* Creating multiple Nets in Matlab +* Do forward and backward computation +* Access any layer within a network, and any parameter blob in a layer +* Get and set data or diff to any blob within a network, not restricting to input blobs or output blobs +* Save a network's parameters to file, and load parameters from file +* Reshape a blob and reshape a network +* Edit network parameter and do network surgery +* Create multiple Solvers in Matlab for training +* Resume training from solver snapshots +* Access train net and test nets in a solver +* Run for a certain number of iterations and give back control to Matlab +* Intermingle arbitrary Matlab code to with gradient steps -Compile matcaffe by `make matcaffe`. +A MATLAB demo is in caffe/matlab/matcaffe_demo.m + +### Build MatCaffe + +Build MatCaffe with `make all matcaffe`. After that, you may test it using `make mattest`. + +Common issue: if you run into error messages `libstdc++.so.6:version 'GLIBCXX_3.4.15' not found` during `make mattest`, then it means that your Matlab's runtime libraries does not match your compile-time libraries. You may need to do the following before you start matlab: + + export LD_LIBRARY_PATH=/opt/intel/mkl/lib/intel64:/usr/local/cuda/lib64 + export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libstdc++.so.6 + +Or the equivalent based on where things are installed on your system, and do `make mattest` again to see if the issue is fixed. Note: this issue is sometimes more complicated since during its startup Matlab may overwrite your `LD_LIBRARY_PATH` environment variable. You can run `!ldd ./matlab/+caffe/private/caffe_.mexa64` in Matlab to see its runtime libraries, and preload your compile-time libraries by exporting them to your `LD_PRELOAD` environment variable. + +After successful building and testing, add this package to Matlab search PATH by starting `matlab` from caffe root folder and running the following commands in Matlab command window. + + addpath ./matlab + +You can save your Matlab search PATH by running `savepath` so that you don't have to run the command above again every time you use MatCaffe. + +### Use MatCaffe + +MatCaffe is very similar to PyCaffe in usage. + +Examples below shows detailed usages and assumes you have downloaded BVLC CaffeNet from [Model Zoo](http://caffe.berkeleyvision.org/model_zoo.html) and started `matlab` from caffe root folder. + + model = './models/bvlc_reference_caffenet/deploy.prototxt'; + weights = './models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'; + +#### Set mode and device + +**Mode and device should always be set BEFORE you create a net or a solver.** + +Use CPU: + + caffe.set_mode_cpu(); + +Use GPU and specify its gpu_id: + + caffe.set_mode_gpu(); + caffe.set_device(gpu_id); + +#### Create a network and access its layers and blobs + +Create a network: + + net = caffe.Net(model, weights, 'test'); % create net and load weights + +Or + + net = caffe.Net(model, 'test'); % create net but not load weights + net.copy_from(weights); % load weights + +which creates `net` object as + + Net with properties: + + layer_vec: [1x23 caffe.Layer] + blob_vec: [1x15 caffe.Blob] + inputs: {'data'} + outputs: {'prob'} + name2layer_index: [23x1 containers.Map] + name2blob_index: [15x1 containers.Map] + layer_names: {23x1 cell} + blob_names: {15x1 cell} + +The two `containers.Map` objects are useful to find the index of a layer or a blob by its name. + +You have access to every blob in this network. To fill blob 'data' with all ones: + + net.blobs('data').set_data(ones(net.blobs('data').shape)); + +To multiply all values in blob 'data' by 10: + + net.blobs('data').set_data(net.blobs('data').get_data() * 10); + +**Be aware that since Matlab is 1-indexed and column-major, the usual 4 blob dimensions in Matlab are `[width, height, channels, num]`, and `width` is the fastest dimension. Also be aware that images are in BGR channels.** Also, Caffe uses single-precision float data. If your data is not single, `set_data` will automatically convert it to single. + +You also have access to every layer, so you can do network surgery. For example, to multiply conv1 parameters by 10: + + net.params('conv1', 1).set_data(net.params('conv1', 1).get_data() * 10); % set weights + net.params('conv1', 2).set_data(net.params('conv1', 2).get_data() * 10); % set bias + +Alternatively, you can use + + net.layers('conv1').params(1).set_data(net.layers('conv1').params(1).get_data() * 10); + net.layers('conv1').params(2).set_data(net.layers('conv1').params(2).get_data() * 10); + +To save the network you just modified: + + net.save('my_net.caffemodel'); + +To get a layer's type (string): + + layer_type = net.layers('conv1').type; + +#### Forward and backward + +Forward pass can be done using `net.forward` or `net.forward_prefilled`. After creating some data for input blobs like `data = rand(net.blobs('data').shape);` you can run + + res = net.forward({data}); + prob = res{1}; + +Or + + net.blobs('data').set_data(data); + net.forward_prefilled(); + prob = net.blobs('prob').get_data(); + +Backward is similar using `net.backward` or `net.backward_prefilled` and replacing `get_data` and `set_data` with `get_diff` and `set_diff`. After creating some gradients for output blobs like `prob_diff = rand(net.blobs('prob').shape);` you can run + + res = net.backward({prob_diff}); + data_diff = res{1}; + +Or + + net.blobs('prob').set_diff(prob_diff); + net.backward_prefilled(); + data_diff = net.blobs('data').get_diff(); + +**However, the backward computation above doesn't get correct results, because Caffe decides that the network does not need backward computation. To get correct backward results, you need to set `'force_backward: true'` in your network prototxt.** + +After performing forward or backward pass, you can also get the data or diff in internal blobs. For example, to extract pool5 features after forward pass: + + pool5_feat = net.blobs('pool5').get_data(); + +#### Reshape + +Assume you want to run 1 image at a time instead of 10: + + net.blobs('data').reshape([227 227 3 1]); % reshape blob 'data' + net.reshape(); + +Then the whole network is reshaped, and now `net.blobs('prob').shape` should be `[1000 1]`; + +#### Training + +Assume you have created training and validation lmdbs following our [ImageNET Tutorial](http://caffe.berkeleyvision.org/gathered/examples/imagenet.html), to create a solver and train on ILSVRC 2012 classification dataset: + + solver = caffe.Solver('./models/bvlc_reference_caffenet/solver.prototxt'); + +which creates `solver` object as + + Solver with properties: + + net: [1x1 caffe.Net] + test_nets: [1x1 caffe.Net] + +To train: + + solver.solve(); + +Or train for only 1000 iterations (so that you can do something to its net before training more iterations) + + solver.step(1000); + +To get iteration number: + + iter = solver.iter(); + +To get its network: + + train_net = solver.net; + test_net = solver.test_nets(1); + +To resume from a snapshot "your_snapshot.solverstate": + + solver.restore('your_snapshot.solverstate'); + +#### Input and output + +`caffe.io` class provides basic input functions `load_image` and `read_mean`. For example, to read ILSVRC 2012 mean file (assume you have downloaded imagenet example auxiliary files by running `./data/ilsvrc12/get_ilsvrc_aux.sh`): + + mean_data = caffe.io.read_mean('./data/ilsvrc12/imagenet_mean.binaryproto'); + +To read Caffe's example image and resize to `[width, height]` and suppose we want `width = 256; height = 256;` + + im_data = caffe.io.load_image('./examples/images/cat.jpg'); + im_data = imresize(im_data, [width, height]); % resize using Matlab's imresize + +**Keep in mind that `width` is the fastest dimension and channels are BGR, which is different from the usual way that Matlab stores an image.** If you don't want to use `caffe.io.load_image` and prefer to load an image by yourself, you can do + + im_data = imread('./examples/images/cat.jpg'); % read image + im_data = im_data(:, :, [3, 2, 1]); % convert from RGB to BGR + im_data = permute(im_data, [2, 1, 3]); % permute width and height + im_data = single(im_data); % convert to single precision + +We do not provide extra functions for data output as Matlab itself is already quite powerful in output. + +#### Clear nets and solvers + +Call `caffe.reset()` to clear all solvers and stand-alone nets you have created. From d3d7d07be981ab046da99e1ad5d84217bf0ec4c3 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Thu, 28 May 2015 16:24:30 +0800 Subject: [PATCH 043/331] Clean up old matcaffe wrapper and rename caffe.reset to caffe.reset_all Remove old matlab wrapper but keep the classification demo and hdf5 demo Change 'caffe.reset()' to 'caffe.reset_all()' to avoid potential name conflict. Otherwise, Matlab R2015a complains: Warning: Function reset has the same name as a MATLAB builtin. We suggest you rename the function to avoid a potential name conflict. --- Makefile | 25 +- docs/tutorial/interfaces.md | 8 +- .../imagenet}/ilsvrc_2012_mean.mat | Bin matlab/+caffe/reset.m | 8 - matlab/+caffe/reset_all.m | 8 + matlab/+caffe/run_tests.m | 4 +- matlab/CMakeLists.txt | 12 +- matlab/caffe/matcaffe.cpp | 421 ------------------ matlab/caffe/matcaffe_batch.m | 75 ---- matlab/caffe/matcaffe_demo_vgg.m | 96 ---- matlab/caffe/matcaffe_demo_vgg_mean_pix.m | 102 ----- matlab/caffe/matcaffe_init.m | 41 -- matlab/caffe/prepare_batch.m | 41 -- matlab/caffe/print_cell.m | 42 -- matlab/caffe/read_cell.m | 21 - .../matcaffe_demo.m => classification_demo.m} | 64 ++- matlab/{caffe => }/hdf5creation/.gitignore | 0 matlab/{caffe => }/hdf5creation/demo.m | 0 matlab/{caffe => }/hdf5creation/store2hdf5.m | 0 19 files changed, 63 insertions(+), 905 deletions(-) rename matlab/{caffe => +caffe/imagenet}/ilsvrc_2012_mean.mat (100%) delete mode 100644 matlab/+caffe/reset.m create mode 100644 matlab/+caffe/reset_all.m delete mode 100644 matlab/caffe/matcaffe.cpp delete mode 100644 matlab/caffe/matcaffe_batch.m delete mode 100644 matlab/caffe/matcaffe_demo_vgg.m delete mode 100644 matlab/caffe/matcaffe_demo_vgg_mean_pix.m delete mode 100644 matlab/caffe/matcaffe_init.m delete mode 100644 matlab/caffe/prepare_batch.m delete mode 100644 matlab/caffe/print_cell.m delete mode 100644 matlab/caffe/read_cell.m rename matlab/{caffe/matcaffe_demo.m => classification_demo.m} (56%) rename matlab/{caffe => }/hdf5creation/.gitignore (100%) rename matlab/{caffe => }/hdf5creation/demo.m (100%) rename matlab/{caffe => }/hdf5creation/store2hdf5.m (100%) diff --git a/Makefile b/Makefile index 74b167763c3..3748b52ca47 100644 --- a/Makefile +++ b/Makefile @@ -65,7 +65,6 @@ NONGEN_CXX_SRCS := $(shell find \ src/$(PROJECT) \ include/$(PROJECT) \ python/$(PROJECT) \ - matlab/$(PROJECT) \ matlab/+$(PROJECT)/private \ examples \ tools \ @@ -80,15 +79,12 @@ NONEMPTY_LINT_REPORT := $(BUILD_DIR)/$(LINT_EXT) PY$(PROJECT)_SRC := python/$(PROJECT)/_$(PROJECT).cpp PY$(PROJECT)_SO := python/$(PROJECT)/_$(PROJECT).so PY$(PROJECT)_HXX := include/$(PROJECT)/python_layer.hpp -# MAT$(PROJECT)_SRC is the matlab wrapper for $(PROJECT) -MAT$(PROJECT)_SRC := matlab/$(PROJECT)/mat$(PROJECT).cpp -# MAT$(PROJECT)_PKG_SRC is the mex entrance point of matlab package for $(PROJECT) -MAT$(PROJECT)_PKG_SRC := matlab/+$(PROJECT)/private/$(PROJECT)_.cpp +# MAT$(PROJECT)_SRC is the mex entrance point of matlab package for $(PROJECT) +MAT$(PROJECT)_SRC := matlab/+$(PROJECT)/private/$(PROJECT)_.cpp ifneq ($(MATLAB_DIR),) MAT_SO_EXT := $(shell $(MATLAB_DIR)/bin/mexext) endif -MAT$(PROJECT)_SO := matlab/$(PROJECT)/$(PROJECT).$(MAT_SO_EXT) -MAT$(PROJECT)_PKG_SO := matlab/+$(PROJECT)/private/$(PROJECT)_.$(MAT_SO_EXT) +MAT$(PROJECT)_SO := matlab/+$(PROJECT)/private/$(PROJECT)_.$(MAT_SO_EXT) ############################## # Derive generated files @@ -451,7 +447,7 @@ $(PY$(PROJECT)_SO): $(PY$(PROJECT)_SRC) $(PY$(PROJECT)_HXX) | $(DYNAMIC_NAME) mat$(PROJECT): mat -mat: $(MAT$(PROJECT)_SO) $(MAT$(PROJECT)_PKG_SO) +mat: $(MAT$(PROJECT)_SO) $(MAT$(PROJECT)_SO): $(MAT$(PROJECT)_SRC) $(STATIC_NAME) @ if [ -z "$(MATLAB_DIR)" ]; then \ @@ -464,18 +460,6 @@ $(MAT$(PROJECT)_SO): $(MAT$(PROJECT)_SRC) $(STATIC_NAME) CXX="$(CXX)" \ CXXFLAGS="\$$CXXFLAGS $(MATLAB_CXXFLAGS)" \ CXXLIBS="\$$CXXLIBS $(STATIC_LINK_COMMAND) $(LDFLAGS)" -output $@ - -$(MAT$(PROJECT)_PKG_SO): $(MAT$(PROJECT)_PKG_SRC) $(STATIC_NAME) - @ if [ -z "$(MATLAB_DIR)" ]; then \ - echo "MATLAB_DIR must be specified in $(CONFIG_FILE)" \ - "to build mat$(PROJECT)."; \ - exit 1; \ - fi - @ echo MEX $< - $(Q)$(MATLAB_DIR)/bin/mex $(MAT$(PROJECT)_PKG_SRC) \ - CXX="$(CXX)" \ - CXXFLAGS="\$$CXXFLAGS $(MATLAB_CXXFLAGS)" \ - CXXLIBS="\$$CXXLIBS $(STATIC_LINK_COMMAND) $(LDFLAGS)" -output $@ runtest: $(TEST_ALL_BIN) $(TOOL_BUILD_DIR)/caffe @@ -601,7 +585,6 @@ clean: @- $(RM) -rf $(DISTRIBUTE_DIR) @- $(RM) $(PY$(PROJECT)_SO) @- $(RM) $(MAT$(PROJECT)_SO) - @- $(RM) $(MAT$(PROJECT)_PKG_SO) supercleanfiles: $(eval SUPERCLEAN_FILES := $(strip \ diff --git a/docs/tutorial/interfaces.md b/docs/tutorial/interfaces.md index f824c7cc54b..a57e17339b0 100644 --- a/docs/tutorial/interfaces.md +++ b/docs/tutorial/interfaces.md @@ -67,7 +67,7 @@ Compile pycaffe by `make pycaffe`. The module dir caffe/python/caffe should be i ## MATLAB -The MATLAB interface -- matcaffe -- is a `caffe` package in caffe/matlab in which you can integrate Caffe in your Matlab code. +The MATLAB interface -- matcaffe -- is the `caffe` package in caffe/matlab in which you can integrate Caffe in your Matlab code. In MatCaffe, you can @@ -84,7 +84,7 @@ In MatCaffe, you can * Run for a certain number of iterations and give back control to Matlab * Intermingle arbitrary Matlab code to with gradient steps -A MATLAB demo is in caffe/matlab/matcaffe_demo.m +An ILSVRC image classification demo is in caffe/matlab/classification_demo.m ### Build MatCaffe @@ -181,7 +181,7 @@ To get a layer's type (string): #### Forward and backward -Forward pass can be done using `net.forward` or `net.forward_prefilled`. After creating some data for input blobs like `data = rand(net.blobs('data').shape);` you can run +Forward pass can be done using `net.forward` or `net.forward_prefilled`. Function `net.forward` takes in a cell array of N-D arrays containing data of input blob(s) and outputs a cell array containing data from output blob(s). Function `net.forward_prefilled` uses existing data in input blob(s) during forward pass, takes no input and produces no output. After creating some data for input blobs like `data = rand(net.blobs('data').shape);` you can run res = net.forward({data}); prob = res{1}; @@ -274,4 +274,4 @@ We do not provide extra functions for data output as Matlab itself is already qu #### Clear nets and solvers -Call `caffe.reset()` to clear all solvers and stand-alone nets you have created. +Call `caffe.reset_all()` to clear all solvers and stand-alone nets you have created. diff --git a/matlab/caffe/ilsvrc_2012_mean.mat b/matlab/+caffe/imagenet/ilsvrc_2012_mean.mat similarity index 100% rename from matlab/caffe/ilsvrc_2012_mean.mat rename to matlab/+caffe/imagenet/ilsvrc_2012_mean.mat diff --git a/matlab/+caffe/reset.m b/matlab/+caffe/reset.m deleted file mode 100644 index c1cfea41a76..00000000000 --- a/matlab/+caffe/reset.m +++ /dev/null @@ -1,8 +0,0 @@ -function reset() -% reset() -% reset Caffe to initial status - -caffe_('reset'); -is_valid_handle('get_new_init_key'); - -end diff --git a/matlab/+caffe/reset_all.m b/matlab/+caffe/reset_all.m new file mode 100644 index 00000000000..a8b33dee8d5 --- /dev/null +++ b/matlab/+caffe/reset_all.m @@ -0,0 +1,8 @@ +function reset_all() +% reset_all() +% clear all solvers and stand-alone nets and reset Caffe to initial status + +caffe_('reset'); +is_valid_handle('get_new_init_key'); + +end diff --git a/matlab/+caffe/run_tests.m b/matlab/+caffe/run_tests.m index afdd8f3309d..8773c9f638b 100644 --- a/matlab/+caffe/run_tests.m +++ b/matlab/+caffe/run_tests.m @@ -3,7 +3,7 @@ % run all tests in this caffe matlab wrapper package % reset caffe before testing -caffe.reset(); +caffe.reset_all(); % put all test cases here results = [... @@ -11,6 +11,6 @@ run(caffe.test.test_solver) ]; % reset caffe after testing -caffe.reset(); +caffe.reset_all(); end diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt index 63182abcc44..4b0d549f07f 100644 --- a/matlab/CMakeLists.txt +++ b/matlab/CMakeLists.txt @@ -31,10 +31,8 @@ function(caffe_fetch_and_set_proper_mexext mexfile_variable) endfunction() # global settings -file(GLOB Matlab_srcs caffe/matcaffe.cpp) -file(GLOB Matlab_pkg_srcs +caffe/private/caffe_.cpp) -set(Matlab_caffe_mex ${PROJECT_SOURCE_DIR}/matlab/caffe/caffe.mex) -set(Matlab_caffe_pkg_mex ${PROJECT_SOURCE_DIR}/matlab/+caffe/private/caffe_.mex) +file(GLOB Matlab_srcs +caffe/private/caffe_.cpp) +set(Matlab_caffe_mex ${PROJECT_SOURCE_DIR}/matlab/+caffe/private/caffe_.mex) caffe_get_current_cflags(cflags) caffe_parse_linker_libs(Caffe_LINKER_LIBS folders libflags macos_frameworks) @@ -52,15 +50,9 @@ if(build_using MATCHES "Matlab") ARGS -output ${Matlab_caffe_mex} ${Matlab_srcs} ${cflags} ${link_folders} ${libflags} DEPENDS caffe COMMENT "Building Matlab interface: ${Matlab_caffe_mex}" VERBATIM) add_custom_target(matlab ALL DEPENDS ${Matlab_caffe_mex} SOURCES ${Matlab_srcs}) - caffe_fetch_and_set_proper_mexext(Matlab_caffe_pkg_mex) - add_custom_command(OUTPUT ${Matlab_caffe_pkg_mex} COMMAND ${Matlab_mex} - ARGS -output ${Matlab_caffe_pkg_mex} ${Matlab_pkg_srcs} ${cflags} ${link_folders} ${libflags} - DEPENDS caffe COMMENT "Building Matlab interface: ${Matlab_caffe_pkg_mex}" VERBATIM) - add_custom_target(matlab ALL DEPENDS ${Matlab_caffe_pkg_mex} SOURCES ${Matlab_pkg_srcs}) elseif(build_using MATCHES "Octave") - # Note: Matlab Caffe package cannot be used in Octave, so we don't build it if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") set(libflags -Wl,-force_load,$ ${libflags}) elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") diff --git a/matlab/caffe/matcaffe.cpp b/matlab/caffe/matcaffe.cpp deleted file mode 100644 index da37d920b20..00000000000 --- a/matlab/caffe/matcaffe.cpp +++ /dev/null @@ -1,421 +0,0 @@ -// -// matcaffe.cpp provides a wrapper of the caffe::Net class as well as some -// caffe::Caffe functions so that one could easily call it from matlab. -// Note that for matlab, we will simply use float as the data type. - -#include -#include -#include - -#include "mex.h" - -#include "caffe/caffe.hpp" - -#define MEX_ARGS int nlhs, mxArray **plhs, int nrhs, const mxArray **prhs - -// Log and throw a Mex error -inline void mex_error(const std::string &msg) { - LOG(ERROR) << msg; - mexErrMsgTxt(msg.c_str()); -} - -using namespace caffe; // NOLINT(build/namespaces) - -// The pointer to the internal caffe::Net instance -static shared_ptr > net_; -static int init_key = -2; - -// Five things to be aware of: -// caffe uses row-major order -// matlab uses column-major order -// caffe uses BGR color channel order -// matlab uses RGB color channel order -// images need to have the data mean subtracted -// -// Data coming in from matlab needs to be in the order -// [width, height, channels, images] -// where width is the fastest dimension. -// Here is the rough matlab for putting image data into the correct -// format: -// % convert from uint8 to single -// im = single(im); -// % reshape to a fixed size (e.g., 227x227) -// im = imresize(im, [IMAGE_DIM IMAGE_DIM], 'bilinear'); -// % permute from RGB to BGR and subtract the data mean (already in BGR) -// im = im(:,:,[3 2 1]) - data_mean; -// % flip width and height to make width the fastest dimension -// im = permute(im, [2 1 3]); -// -// If you have multiple images, cat them with cat(4, ...) -// -// The actual forward function. It takes in a cell array of 4-D arrays as -// input and outputs a cell array. - -static mxArray* do_forward(const mxArray* const bottom) { - const vector*>& input_blobs = net_->input_blobs(); - if (static_cast(mxGetDimensions(bottom)[0]) != - input_blobs.size()) { - mex_error("Invalid input size"); - } - for (unsigned int i = 0; i < input_blobs.size(); ++i) { - const mxArray* const elem = mxGetCell(bottom, i); - if (!mxIsSingle(elem)) { - mex_error("MatCaffe require single-precision float point data"); - } - if (mxGetNumberOfElements(elem) != input_blobs[i]->count()) { - std::string error_msg; - error_msg += "MatCaffe input size does not match the input size "; - error_msg += "of the network"; - mex_error(error_msg); - } - - const float* const data_ptr = - reinterpret_cast(mxGetPr(elem)); - switch (Caffe::mode()) { - case Caffe::CPU: - caffe_copy(input_blobs[i]->count(), data_ptr, - input_blobs[i]->mutable_cpu_data()); - break; - case Caffe::GPU: - caffe_copy(input_blobs[i]->count(), data_ptr, - input_blobs[i]->mutable_gpu_data()); - break; - default: - mex_error("Unknown Caffe mode"); - } // switch (Caffe::mode()) - } - const vector*>& output_blobs = net_->ForwardPrefilled(); - mxArray* mx_out = mxCreateCellMatrix(output_blobs.size(), 1); - for (unsigned int i = 0; i < output_blobs.size(); ++i) { - // internally data is stored as (width, height, channels, num) - // where width is the fastest dimension - mwSize dims[4] = {output_blobs[i]->width(), output_blobs[i]->height(), - output_blobs[i]->channels(), output_blobs[i]->num()}; - mxArray* mx_blob = mxCreateNumericArray(4, dims, mxSINGLE_CLASS, mxREAL); - mxSetCell(mx_out, i, mx_blob); - float* data_ptr = reinterpret_cast(mxGetPr(mx_blob)); - switch (Caffe::mode()) { - case Caffe::CPU: - caffe_copy(output_blobs[i]->count(), output_blobs[i]->cpu_data(), - data_ptr); - break; - case Caffe::GPU: - caffe_copy(output_blobs[i]->count(), output_blobs[i]->gpu_data(), - data_ptr); - break; - default: - mex_error("Unknown Caffe mode"); - } // switch (Caffe::mode()) - } - - return mx_out; -} - -static mxArray* do_backward(const mxArray* const top_diff) { - const vector*>& output_blobs = net_->output_blobs(); - const vector*>& input_blobs = net_->input_blobs(); - if (static_cast(mxGetDimensions(top_diff)[0]) != - output_blobs.size()) { - mex_error("Invalid input size"); - } - // First, copy the output diff - for (unsigned int i = 0; i < output_blobs.size(); ++i) { - const mxArray* const elem = mxGetCell(top_diff, i); - const float* const data_ptr = - reinterpret_cast(mxGetPr(elem)); - switch (Caffe::mode()) { - case Caffe::CPU: - caffe_copy(output_blobs[i]->count(), data_ptr, - output_blobs[i]->mutable_cpu_diff()); - break; - case Caffe::GPU: - caffe_copy(output_blobs[i]->count(), data_ptr, - output_blobs[i]->mutable_gpu_diff()); - break; - default: - mex_error("Unknown Caffe mode"); - } // switch (Caffe::mode()) - } - // LOG(INFO) << "Start"; - net_->Backward(); - // LOG(INFO) << "End"; - mxArray* mx_out = mxCreateCellMatrix(input_blobs.size(), 1); - for (unsigned int i = 0; i < input_blobs.size(); ++i) { - // internally data is stored as (width, height, channels, num) - // where width is the fastest dimension - mwSize dims[4] = {input_blobs[i]->width(), input_blobs[i]->height(), - input_blobs[i]->channels(), input_blobs[i]->num()}; - mxArray* mx_blob = mxCreateNumericArray(4, dims, mxSINGLE_CLASS, mxREAL); - mxSetCell(mx_out, i, mx_blob); - float* data_ptr = reinterpret_cast(mxGetPr(mx_blob)); - switch (Caffe::mode()) { - case Caffe::CPU: - caffe_copy(input_blobs[i]->count(), input_blobs[i]->cpu_diff(), data_ptr); - break; - case Caffe::GPU: - caffe_copy(input_blobs[i]->count(), input_blobs[i]->gpu_diff(), data_ptr); - break; - default: - mex_error("Unknown Caffe mode"); - } // switch (Caffe::mode()) - } - - return mx_out; -} - -static mxArray* do_get_weights() { - const vector > >& layers = net_->layers(); - const vector& layer_names = net_->layer_names(); - - // Step 1: count the number of layers with weights - int num_layers = 0; - { - string prev_layer_name = ""; - for (unsigned int i = 0; i < layers.size(); ++i) { - vector > >& layer_blobs = layers[i]->blobs(); - if (layer_blobs.size() == 0) { - continue; - } - if (layer_names[i] != prev_layer_name) { - prev_layer_name = layer_names[i]; - num_layers++; - } - } - } - - // Step 2: prepare output array of structures - mxArray* mx_layers; - { - const mwSize dims[2] = {num_layers, 1}; - const char* fnames[2] = {"weights", "layer_names"}; - mx_layers = mxCreateStructArray(2, dims, 2, fnames); - } - - // Step 3: copy weights into output - { - string prev_layer_name = ""; - int mx_layer_index = 0; - for (unsigned int i = 0; i < layers.size(); ++i) { - vector > >& layer_blobs = layers[i]->blobs(); - if (layer_blobs.size() == 0) { - continue; - } - - mxArray* mx_layer_cells = NULL; - if (layer_names[i] != prev_layer_name) { - prev_layer_name = layer_names[i]; - const mwSize dims[2] = {static_cast(layer_blobs.size()), 1}; - mx_layer_cells = mxCreateCellArray(2, dims); - mxSetField(mx_layers, mx_layer_index, "weights", mx_layer_cells); - mxSetField(mx_layers, mx_layer_index, "layer_names", - mxCreateString(layer_names[i].c_str())); - mx_layer_index++; - } - - for (unsigned int j = 0; j < layer_blobs.size(); ++j) { - // internally data is stored as (width, height, channels, num) - // where width is the fastest dimension - mwSize dims[4] = {layer_blobs[j]->width(), layer_blobs[j]->height(), - layer_blobs[j]->channels(), layer_blobs[j]->num()}; - - mxArray* mx_weights = - mxCreateNumericArray(4, dims, mxSINGLE_CLASS, mxREAL); - mxSetCell(mx_layer_cells, j, mx_weights); - float* weights_ptr = reinterpret_cast(mxGetPr(mx_weights)); - - switch (Caffe::mode()) { - case Caffe::CPU: - caffe_copy(layer_blobs[j]->count(), layer_blobs[j]->cpu_data(), - weights_ptr); - break; - case Caffe::GPU: - caffe_copy(layer_blobs[j]->count(), layer_blobs[j]->gpu_data(), - weights_ptr); - break; - default: - mex_error("Unknown Caffe mode"); - } - } - } - } - - return mx_layers; -} - -static void get_weights(MEX_ARGS) { - plhs[0] = do_get_weights(); -} - -static void set_mode_cpu(MEX_ARGS) { - Caffe::set_mode(Caffe::CPU); -} - -static void set_mode_gpu(MEX_ARGS) { - Caffe::set_mode(Caffe::GPU); -} - -static void set_device(MEX_ARGS) { - if (nrhs != 1) { - ostringstream error_msg; - error_msg << "Expected 1 argument, got " << nrhs; - mex_error(error_msg.str()); - } - - int device_id = static_cast(mxGetScalar(prhs[0])); - Caffe::SetDevice(device_id); -} - -static void get_init_key(MEX_ARGS) { - plhs[0] = mxCreateDoubleScalar(init_key); -} - -static void init(MEX_ARGS) { - if (nrhs != 3) { - ostringstream error_msg; - error_msg << "Expected 3 arguments, got " << nrhs; - mex_error(error_msg.str()); - } - - char* param_file = mxArrayToString(prhs[0]); - char* model_file = mxArrayToString(prhs[1]); - char* phase_name = mxArrayToString(prhs[2]); - - Phase phase; - if (strcmp(phase_name, "train") == 0) { - phase = TRAIN; - } else if (strcmp(phase_name, "test") == 0) { - phase = TEST; - } else { - mex_error("Unknown phase."); - } - - net_.reset(new Net(string(param_file), phase)); - net_->CopyTrainedLayersFrom(string(model_file)); - - mxFree(param_file); - mxFree(model_file); - mxFree(phase_name); - - init_key = random(); // NOLINT(caffe/random_fn) - - if (nlhs == 1) { - plhs[0] = mxCreateDoubleScalar(init_key); - } -} - -static void reset(MEX_ARGS) { - if (net_) { - net_.reset(); - init_key = -2; - LOG(INFO) << "Network reset, call init before use it again"; - } -} - -static void forward(MEX_ARGS) { - if (nrhs != 1) { - ostringstream error_msg; - error_msg << "Expected 1 argument, got " << nrhs; - mex_error(error_msg.str()); - } - - plhs[0] = do_forward(prhs[0]); -} - -static void backward(MEX_ARGS) { - if (nrhs != 1) { - ostringstream error_msg; - error_msg << "Expected 1 argument, got " << nrhs; - mex_error(error_msg.str()); - } - - plhs[0] = do_backward(prhs[0]); -} - -static void is_initialized(MEX_ARGS) { - if (!net_) { - plhs[0] = mxCreateDoubleScalar(0); - } else { - plhs[0] = mxCreateDoubleScalar(1); - } -} - -static void read_mean(MEX_ARGS) { - if (nrhs != 1) { - mexErrMsgTxt("Usage: caffe('read_mean', 'path_to_binary_mean_file'"); - return; - } - const string& mean_file = mxArrayToString(prhs[0]); - Blob data_mean; - LOG(INFO) << "Loading mean file from: " << mean_file; - BlobProto blob_proto; - bool result = ReadProtoFromBinaryFile(mean_file.c_str(), &blob_proto); - if (!result) { - mexErrMsgTxt("Couldn't read the file"); - return; - } - data_mean.FromProto(blob_proto); - mwSize dims[4] = {data_mean.width(), data_mean.height(), - data_mean.channels(), data_mean.num() }; - mxArray* mx_blob = mxCreateNumericArray(4, dims, mxSINGLE_CLASS, mxREAL); - float* data_ptr = reinterpret_cast(mxGetPr(mx_blob)); - caffe_copy(data_mean.count(), data_mean.cpu_data(), data_ptr); - mexWarnMsgTxt("Remember that Caffe saves in [width, height, channels]" - " format and channels are also BGR!"); - plhs[0] = mx_blob; -} - -/** ----------------------------------------------------------------- - ** Available commands. - **/ -struct handler_registry { - string cmd; - void (*func)(MEX_ARGS); -}; - -static handler_registry handlers[] = { - // Public API functions - { "forward", forward }, - { "backward", backward }, - { "init", init }, - { "is_initialized", is_initialized }, - { "set_mode_cpu", set_mode_cpu }, - { "set_mode_gpu", set_mode_gpu }, - { "set_device", set_device }, - { "get_weights", get_weights }, - { "get_init_key", get_init_key }, - { "reset", reset }, - { "read_mean", read_mean }, - // The end. - { "END", NULL }, -}; - - -/** ----------------------------------------------------------------- - ** matlab entry point: caffe(api_command, arg1, arg2, ...) - **/ -void mexFunction(MEX_ARGS) { - mexLock(); // Avoid clearing the mex file. - if (nrhs == 0) { - mex_error("No API command given"); - return; - } - - { // Handle input command - char *cmd = mxArrayToString(prhs[0]); - bool dispatched = false; - // Dispatch to cmd handler - for (int i = 0; handlers[i].func != NULL; i++) { - if (handlers[i].cmd.compare(cmd) == 0) { - handlers[i].func(nlhs, plhs, nrhs-1, prhs+1); - dispatched = true; - break; - } - } - if (!dispatched) { - ostringstream error_msg; - error_msg << "Unknown command '" << cmd << "'"; - mex_error(error_msg.str()); - } - mxFree(cmd); - } -} diff --git a/matlab/caffe/matcaffe_batch.m b/matlab/caffe/matcaffe_batch.m deleted file mode 100644 index f6d1aa83b84..00000000000 --- a/matlab/caffe/matcaffe_batch.m +++ /dev/null @@ -1,75 +0,0 @@ -function [scores,list_im] = matcaffe_batch(list_im, use_gpu) -% scores = matcaffe_batch(list_im, use_gpu) -% -% Demo of the matlab wrapper using the ILSVRC network. -% -% input -% list_im list of images files -% use_gpu 1 to use the GPU, 0 to use the CPU -% -% output -% scores 1000 x num_images ILSVRC output vector -% -% You may need to do the following before you start matlab: -% $ export LD_LIBRARY_PATH=/opt/intel/mkl/lib/intel64:/usr/local/cuda/lib64 -% $ export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libstdc++.so.6 -% Or the equivalent based on where things are installed on your system -% -% Usage: -% scores = matcaffe_batch({'peppers.png','onion.png'}); -% scores = matcaffe_batch('list_images.txt', 1); -if nargin < 1 - % For test purposes - list_im = {'peppers.png','onions.png'}; -end -if ischar(list_im) - %Assume it is a file contaning the list of images - filename = list_im; - list_im = read_cell(filename); -end -% Adjust the batch size and dim to match with models/bvlc_reference_caffenet/deploy.prototxt -batch_size = 10; -dim = 1000; -disp(list_im) -if mod(length(list_im),batch_size) - warning(['Assuming batches of ' num2str(batch_size) ' images rest will be filled with zeros']) -end - -% init caffe network (spews logging info) -if exist('use_gpu', 'var') - matcaffe_init(use_gpu); -else - matcaffe_init(); -end - -d = load('ilsvrc_2012_mean'); -IMAGE_MEAN = d.image_mean; - -% prepare input - -num_images = length(list_im); -scores = zeros(dim,num_images,'single'); -num_batches = ceil(length(list_im)/batch_size) -initic=tic; -for bb = 1 : num_batches - batchtic = tic; - range = 1+batch_size*(bb-1):min(num_images,batch_size * bb); - tic - input_data = prepare_batch(list_im(range),IMAGE_MEAN,batch_size); - toc, tic - fprintf('Batch %d out of %d %.2f%% Complete ETA %.2f seconds\n',... - bb,num_batches,bb/num_batches*100,toc(initic)/bb*(num_batches-bb)); - output_data = caffe('forward', {input_data}); - toc - output_data = squeeze(output_data{1}); - scores(:,range) = output_data(:,mod(range-1,batch_size)+1); - toc(batchtic) -end -toc(initic); - -if exist('filename', 'var') - save([filename '.probs.mat'],'list_im','scores','-v7.3'); -end - - - diff --git a/matlab/caffe/matcaffe_demo_vgg.m b/matlab/caffe/matcaffe_demo_vgg.m deleted file mode 100644 index 4e5a98eb5f4..00000000000 --- a/matlab/caffe/matcaffe_demo_vgg.m +++ /dev/null @@ -1,96 +0,0 @@ -function scores = matcaffe_demo_vgg(im, use_gpu, model_def_file, model_file, mean_file) -% scores = matcaffe_demo_vgg(im, use_gpu, model_def_file, model_file, mean_file) -% -% Demo of the matlab wrapper using the networks described in the BMVC-2014 paper "Return of the Devil in the Details: Delving Deep into Convolutional Nets" -% -% INPUT -% im - color image as uint8 HxWx3 -% use_gpu - 1 to use the GPU, 0 to use the CPU -% model_def_file - network configuration (.prototxt file) -% model_file - network weights (.caffemodel file) -% mean_file - mean BGR image as uint8 HxWx3 (.mat file) -% -% OUTPUT -% scores 1000-dimensional ILSVRC score vector -% -% EXAMPLE USAGE -% model_def_file = 'zoo/VGG_CNN_F_deploy.prototxt'; -% model_file = 'zoo/VGG_CNN_F.caffemodel'; -% mean_file = 'zoo/VGG_mean.mat'; -% use_gpu = true; -% im = imread('../../examples/images/cat.jpg'); -% scores = matcaffe_demo_vgg(im, use_gpu, model_def_file, model_file, mean_file); -% -% NOTES -% the image crops are prepared as described in the paper (the aspect ratio is preserved) -% -% PREREQUISITES -% You may need to do the following before you start matlab: -% $ export LD_LIBRARY_PATH=/opt/intel/mkl/lib/intel64:/usr/local/cuda/lib64 -% $ export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libstdc++.so.6 -% Or the equivalent based on where things are installed on your system - -% init caffe network (spews logging info) -matcaffe_init(use_gpu, model_def_file, model_file); - -% prepare oversampled input -% input_data is Height x Width x Channel x Num -tic; -input_data = {prepare_image(im, mean_file)}; -toc; - -% do forward pass to get scores -% scores are now Width x Height x Channels x Num -tic; -scores = caffe('forward', input_data); -toc; - -scores = scores{1}; -% size(scores) -scores = squeeze(scores); -% scores = mean(scores,2); - -% [~,maxlabel] = max(scores); - -% ------------------------------------------------------------------------ -function images = prepare_image(im, mean_file) -% ------------------------------------------------------------------------ -IMAGE_DIM = 256; -CROPPED_DIM = 224; - -d = load(mean_file); -IMAGE_MEAN = d.image_mean; - -% resize to fixed input size -im = single(im); - -if size(im, 1) < size(im, 2) - im = imresize(im, [IMAGE_DIM NaN]); -else - im = imresize(im, [NaN IMAGE_DIM]); -end - -% RGB -> BGR -im = im(:, :, [3 2 1]); - -% oversample (4 corners, center, and their x-axis flips) -images = zeros(CROPPED_DIM, CROPPED_DIM, 3, 10, 'single'); - -indices_y = [0 size(im,1)-CROPPED_DIM] + 1; -indices_x = [0 size(im,2)-CROPPED_DIM] + 1; -center_y = floor(indices_y(2) / 2)+1; -center_x = floor(indices_x(2) / 2)+1; - -curr = 1; -for i = indices_y - for j = indices_x - images(:, :, :, curr) = ... - permute(im(i:i+CROPPED_DIM-1, j:j+CROPPED_DIM-1, :)-IMAGE_MEAN, [2 1 3]); - images(:, :, :, curr+5) = images(end:-1:1, :, :, curr); - curr = curr + 1; - end -end -images(:,:,:,5) = ... - permute(im(center_y:center_y+CROPPED_DIM-1,center_x:center_x+CROPPED_DIM-1,:)-IMAGE_MEAN, ... - [2 1 3]); -images(:,:,:,10) = images(end:-1:1, :, :, curr); diff --git a/matlab/caffe/matcaffe_demo_vgg_mean_pix.m b/matlab/caffe/matcaffe_demo_vgg_mean_pix.m deleted file mode 100644 index 5f7898a7029..00000000000 --- a/matlab/caffe/matcaffe_demo_vgg_mean_pix.m +++ /dev/null @@ -1,102 +0,0 @@ -function scores = matcaffe_demo_vgg_mean_pix(im, use_gpu, model_def_file, model_file) -% scores = matcaffe_demo_vgg(im, use_gpu, model_def_file, model_file) -% -% Demo of the matlab wrapper based on the networks used for the "VGG" entry -% in the ILSVRC-2014 competition and described in the tech. report -% "Very Deep Convolutional Networks for Large-Scale Image Recognition" -% http://arxiv.org/abs/1409.1556/ -% -% INPUT -% im - color image as uint8 HxWx3 -% use_gpu - 1 to use the GPU, 0 to use the CPU -% model_def_file - network configuration (.prototxt file) -% model_file - network weights (.caffemodel file) -% -% OUTPUT -% scores 1000-dimensional ILSVRC score vector -% -% EXAMPLE USAGE -% model_def_file = 'zoo/deploy.prototxt'; -% model_file = 'zoo/model.caffemodel'; -% use_gpu = true; -% im = imread('../../examples/images/cat.jpg'); -% scores = matcaffe_demo_vgg(im, use_gpu, model_def_file, model_file); -% -% NOTES -% mean pixel subtraction is used instead of the mean image subtraction -% -% PREREQUISITES -% You may need to do the following before you start matlab: -% $ export LD_LIBRARY_PATH=/opt/intel/mkl/lib/intel64:/usr/local/cuda/lib64 -% $ export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libstdc++.so.6 -% Or the equivalent based on where things are installed on your system - -% init caffe network (spews logging info) -matcaffe_init(use_gpu, model_def_file, model_file); - -% mean BGR pixel -mean_pix = [103.939, 116.779, 123.68]; - -% prepare oversampled input -% input_data is Height x Width x Channel x Num -tic; -input_data = {prepare_image(im, mean_pix)}; -toc; - -% do forward pass to get scores -% scores are now Width x Height x Channels x Num -tic; -scores = caffe('forward', input_data); -toc; - -scores = scores{1}; -% size(scores) -scores = squeeze(scores); -% scores = mean(scores,2); - -% [~,maxlabel] = max(scores); - -% ------------------------------------------------------------------------ -function images = prepare_image(im, mean_pix) -% ------------------------------------------------------------------------ -IMAGE_DIM = 256; -CROPPED_DIM = 224; - -% resize to fixed input size -im = single(im); - -if size(im, 1) < size(im, 2) - im = imresize(im, [IMAGE_DIM NaN]); -else - im = imresize(im, [NaN IMAGE_DIM]); -end - -% RGB -> BGR -im = im(:, :, [3 2 1]); - -% oversample (4 corners, center, and their x-axis flips) -images = zeros(CROPPED_DIM, CROPPED_DIM, 3, 10, 'single'); - -indices_y = [0 size(im,1)-CROPPED_DIM] + 1; -indices_x = [0 size(im,2)-CROPPED_DIM] + 1; -center_y = floor(indices_y(2) / 2)+1; -center_x = floor(indices_x(2) / 2)+1; - -curr = 1; -for i = indices_y - for j = indices_x - images(:, :, :, curr) = ... - permute(im(i:i+CROPPED_DIM-1, j:j+CROPPED_DIM-1, :), [2 1 3]); - images(:, :, :, curr+5) = images(end:-1:1, :, :, curr); - curr = curr + 1; - end -end -images(:,:,:,5) = ... - permute(im(center_y:center_y+CROPPED_DIM-1,center_x:center_x+CROPPED_DIM-1,:), ... - [2 1 3]); -images(:,:,:,10) = images(end:-1:1, :, :, curr); - -% mean BGR pixel subtraction -for c = 1:3 - images(:, :, c, :) = images(:, :, c, :) - mean_pix(c); -end diff --git a/matlab/caffe/matcaffe_init.m b/matlab/caffe/matcaffe_init.m deleted file mode 100644 index 5d0a0a70bde..00000000000 --- a/matlab/caffe/matcaffe_init.m +++ /dev/null @@ -1,41 +0,0 @@ -function matcaffe_init(use_gpu, model_def_file, model_file) -% matcaffe_init(model_def_file, model_file, use_gpu) -% Initilize matcaffe wrapper - -if nargin < 1 - % By default use CPU - use_gpu = 0; -end -if nargin < 2 || isempty(model_def_file) - % By default use imagenet_deploy - model_def_file = '../../models/bvlc_reference_caffenet/deploy.prototxt'; -end -if nargin < 3 || isempty(model_file) - % By default use caffe reference model - model_file = '../../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'; -end - - -if caffe('is_initialized') == 0 - if exist(model_file, 'file') == 0 - % NOTE: you'll have to get the pre-trained ILSVRC network - error('You need a network model file'); - end - if ~exist(model_def_file,'file') - % NOTE: you'll have to get network definition - error('You need the network prototxt definition'); - end - % load network in TEST phase - caffe('init', model_def_file, model_file, 'test') -end -fprintf('Done with init\n'); - -% set to use GPU or CPU -if use_gpu - fprintf('Using GPU Mode\n'); - caffe('set_mode_gpu'); -else - fprintf('Using CPU Mode\n'); - caffe('set_mode_cpu'); -end -fprintf('Done with set_mode\n'); diff --git a/matlab/caffe/prepare_batch.m b/matlab/caffe/prepare_batch.m deleted file mode 100644 index 345c8eb5f0b..00000000000 --- a/matlab/caffe/prepare_batch.m +++ /dev/null @@ -1,41 +0,0 @@ -% ------------------------------------------------------------------------ -function images = prepare_batch(image_files,IMAGE_MEAN,batch_size) -% ------------------------------------------------------------------------ -if nargin < 2 - d = load('ilsvrc_2012_mean'); - IMAGE_MEAN = d.image_mean; -end -num_images = length(image_files); -if nargin < 3 - batch_size = num_images; -end - -IMAGE_DIM = 256; -CROPPED_DIM = 227; -indices = [0 IMAGE_DIM-CROPPED_DIM] + 1; -center = floor(indices(2) / 2)+1; - -num_images = length(image_files); -images = zeros(CROPPED_DIM,CROPPED_DIM,3,batch_size,'single'); - -parfor i=1:num_images - % read file - fprintf('%c Preparing %s\n',13,image_files{i}); - try - im = imread(image_files{i}); - % resize to fixed input size - im = single(im); - im = imresize(im, [IMAGE_DIM IMAGE_DIM], 'bilinear'); - % Transform GRAY to RGB - if size(im,3) == 1 - im = cat(3,im,im,im); - end - % permute from RGB to BGR (IMAGE_MEAN is already BGR) - im = im(:,:,[3 2 1]) - IMAGE_MEAN; - % Crop the center of the image - images(:,:,:,i) = permute(im(center:center+CROPPED_DIM-1,... - center:center+CROPPED_DIM-1,:),[2 1 3]); - catch - warning('Problems with file',image_files{i}); - end -end \ No newline at end of file diff --git a/matlab/caffe/print_cell.m b/matlab/caffe/print_cell.m deleted file mode 100644 index 864340d4be9..00000000000 --- a/matlab/caffe/print_cell.m +++ /dev/null @@ -1,42 +0,0 @@ -function res=print_cell(input,file,linesep,cellsep) -assert(iscell(input),'The input should be a cell') -if nargin < 4 - cellsep = '\t'; -end -if nargin < 3 - linesep = '\n'; -end -if exist('file','var') && ~isempty(file) - %% - fid = fopen(file,'w'); - for l=1:length(input) - if iscell(input{l}) - for i=1:length(input{l}) - fprintf(fid,['%s' cellsep],input{l}{i}); - end - fprintf(fid,linesep); - else - if size(input,2) > 1 - for i=1:size(input,2) - fprintf(fid,'%s ',input{l,i}); - end - fprintf(fid,linesep); - else - fprintf(fid,['%s' linesep],input{l}); - end - end - end - fclose(fid); -else - res = ''; - for l=1:length(input) - if iscell(input{l}) - for i=1:length(input{l}) - res = [res sprintf([cellsep{1} '%s' cellsep{2}],input{l}{i})]; - end - res = [res sprintf(linesep)]; - else - res = [res sprintf(['%s' linesep],input{l}(:))]; - end - end -end \ No newline at end of file diff --git a/matlab/caffe/read_cell.m b/matlab/caffe/read_cell.m deleted file mode 100644 index 19831167106..00000000000 --- a/matlab/caffe/read_cell.m +++ /dev/null @@ -1,21 +0,0 @@ -function res=read_cell(filename,linesep,cellsep) -if nargin < 2, linesep='\n'; end -if nargin < 3, cellsep = '\t'; end -if exist(filename,'file') - fid = fopen(filename); -else - % Assume that filename is either a file ide or a string - fid = filename; -end - -fileLines = textscan(fid,'%s','delimiter',linesep,'BufSize',100000); - -fileLines = fileLines{1}; - -if regexp(fileLines{1},cellsep,'once') - fileLines = regexprep(fileLines,['^' cellsep '|' cellsep '$'],''); - res = regexp(fileLines,cellsep,'split'); - res = cell2matcell(res); -else - res = fileLines; -end diff --git a/matlab/caffe/matcaffe_demo.m b/matlab/classification_demo.m similarity index 56% rename from matlab/caffe/matcaffe_demo.m rename to matlab/classification_demo.m index a931f910cbf..43a7bf62fdf 100644 --- a/matlab/caffe/matcaffe_demo.m +++ b/matlab/classification_demo.m @@ -1,7 +1,16 @@ -function [scores, maxlabel] = matcaffe_demo(im, use_gpu) -% scores = matcaffe_demo(im, use_gpu) +function [scores, maxlabel] = classification_demo(im, use_gpu) +% scores = classification_demo(im, use_gpu) % -% Demo of the matlab wrapper using the ILSVRC network. +% Image classification demo using BVLC CaffeNet. +% +% IMPORTANT: before you run this demo, you should download BVLC CaffeNet +% from Model Zoo (http://caffe.berkeleyvision.org/model_zoo.html) +% +% **************************************************************************** +% For detailed documentation and usage on Caffe's Matlab interface, please +% refer to Caffe Interface Tutorial at +% http://caffe.berkeleyvision.org/tutorial/interfaces.html#matlab +% **************************************************************************** % % input % im color image as uint8 HxWx3 @@ -16,8 +25,8 @@ % Or the equivalent based on where things are installed on your system % % Usage: -% im = imread('../../examples/images/cat.jpg'); -% scores = matcaffe_demo(im, 1); +% im = imread('../examples/images/cat.jpg'); +% scores = classification_demo(im, 1); % [score, class] = max(scores); % Five things to be aware of: % caffe uses row-major order @@ -26,7 +35,7 @@ % matlab uses RGB color channel order % images need to have the data mean subtracted -% Data coming in from matlab needs to be in the order +% Data coming in from matlab needs to be in the order % [width, height, channels, images] % where width is the fastest dimension. % Here is the rough matlab for putting image data into the correct @@ -42,20 +51,27 @@ % If you have multiple images, cat them with cat(4, ...) -% The actual forward function. It takes in a cell array of 4-D arrays as -% input and outputs a cell array. - - -% init caffe network (spews logging info) -if exist('use_gpu', 'var') - matcaffe_init(use_gpu); +% Set caffe mode +if exist('use_gpu', 'var') && use_gpu + caffe.set_mode_gpu(); + gpu_id = 0; % we will use the first gpu in this demo + caffe.set_device(gpu_id); else - matcaffe_init(); + caffe.set_mode_cpu(); end +% Initialize the network using BVLC CaffeNet for image classification +% Weights (parameter) file needs to be downloaded from Model Zoo. +model_dir = '../models/bvlc_reference_caffenet/'; +net_model = [model_dir 'deploy.prototxt']; +net_weights = [model_dir 'bvlc_reference_caffenet.caffemodel']; +phase = 'test'; +net = caffe.Net(net_model, net_weights, phase); + if nargin < 1 - % For demo purposes we will use the peppers image - im = imread('peppers.png'); + % For demo purposes we will use the cat image + fprintf('using ../examples/images/cat.jpg as input image\n'); + im = imread('../examples/images/cat.jpg'); end % prepare oversampled input @@ -67,7 +83,10 @@ % do forward pass to get scores % scores are now Width x Height x Channels x Num tic; -scores = caffe('forward', input_data); +% The net forward function. It takes in a cell array of N-D arrays +% (where N == 4 here) containing data of input blob(s) and outputs a cell +% array containing data from output blob(s) +scores = net.forward(input_data); toc; scores = scores{1}; @@ -77,10 +96,13 @@ [~,maxlabel] = max(scores); +% call caffe.reset_all() to reset caffe +caffe.reset_all(); + % ------------------------------------------------------------------------ function images = prepare_image(im) % ------------------------------------------------------------------------ -d = load('ilsvrc_2012_mean'); +d = load('+caffe/imagenet/ilsvrc_2012_mean.mat'); IMAGE_MEAN = d.image_mean; IMAGE_DIM = 256; CROPPED_DIM = 227; @@ -98,13 +120,13 @@ for i = indices for j = indices images(:, :, :, curr) = ... - permute(im(i:i+CROPPED_DIM-1, j:j+CROPPED_DIM-1, :), [2 1 3]); + permute(im(i:i+CROPPED_DIM-1, j:j+CROPPED_DIM-1, :), [2 1 3]); images(:, :, :, curr+5) = images(end:-1:1, :, :, curr); curr = curr + 1; end end center = floor(indices(2) / 2)+1; images(:,:,:,5) = ... - permute(im(center:center+CROPPED_DIM-1,center:center+CROPPED_DIM-1,:), ... - [2 1 3]); + permute(im(center:center+CROPPED_DIM-1,center:center+CROPPED_DIM-1,:), ... + [2 1 3]); images(:,:,:,10) = images(end:-1:1, :, :, curr); diff --git a/matlab/caffe/hdf5creation/.gitignore b/matlab/hdf5creation/.gitignore similarity index 100% rename from matlab/caffe/hdf5creation/.gitignore rename to matlab/hdf5creation/.gitignore diff --git a/matlab/caffe/hdf5creation/demo.m b/matlab/hdf5creation/demo.m similarity index 100% rename from matlab/caffe/hdf5creation/demo.m rename to matlab/hdf5creation/demo.m diff --git a/matlab/caffe/hdf5creation/store2hdf5.m b/matlab/hdf5creation/store2hdf5.m similarity index 100% rename from matlab/caffe/hdf5creation/store2hdf5.m rename to matlab/hdf5creation/store2hdf5.m From 0f13feef342fc59aa113bafb45041b35ff97b649 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Thu, 28 May 2015 18:33:54 +0800 Subject: [PATCH 044/331] Move demo to demo/ and check weights file existence Move all Matlab demo to caffe/matlab/demo. Since we want the user to add caffe/matlab to Matlab search PATH, we don't want to mess it up with too many files Check if CaffeNet is already downloaded in classification demo. --- docs/tutorial/interfaces.md | 10 +++++---- matlab/{ => demo}/classification_demo.m | 27 ++++++++++++++++++------- 2 files changed, 26 insertions(+), 11 deletions(-) rename matlab/{ => demo}/classification_demo.m (84%) diff --git a/docs/tutorial/interfaces.md b/docs/tutorial/interfaces.md index a57e17339b0..a59a410d964 100644 --- a/docs/tutorial/interfaces.md +++ b/docs/tutorial/interfaces.md @@ -84,18 +84,18 @@ In MatCaffe, you can * Run for a certain number of iterations and give back control to Matlab * Intermingle arbitrary Matlab code to with gradient steps -An ILSVRC image classification demo is in caffe/matlab/classification_demo.m +An ILSVRC image classification demo is in caffe/matlab/demo/classification_demo.m ### Build MatCaffe Build MatCaffe with `make all matcaffe`. After that, you may test it using `make mattest`. -Common issue: if you run into error messages `libstdc++.so.6:version 'GLIBCXX_3.4.15' not found` during `make mattest`, then it means that your Matlab's runtime libraries does not match your compile-time libraries. You may need to do the following before you start matlab: +Common issue: if you run into error messages like `libstdc++.so.6:version 'GLIBCXX_3.4.15' not found` during `make mattest`, then it usually means that your Matlab's runtime libraries do not match your compile-time libraries. You may need to do the following before you start Matlab: export LD_LIBRARY_PATH=/opt/intel/mkl/lib/intel64:/usr/local/cuda/lib64 export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libstdc++.so.6 -Or the equivalent based on where things are installed on your system, and do `make mattest` again to see if the issue is fixed. Note: this issue is sometimes more complicated since during its startup Matlab may overwrite your `LD_LIBRARY_PATH` environment variable. You can run `!ldd ./matlab/+caffe/private/caffe_.mexa64` in Matlab to see its runtime libraries, and preload your compile-time libraries by exporting them to your `LD_PRELOAD` environment variable. +Or the equivalent based on where things are installed on your system, and do `make mattest` again to see if the issue is fixed. Note: this issue is sometimes more complicated since during its startup Matlab may overwrite your `LD_LIBRARY_PATH` environment variable. You can run `!ldd ./matlab/+caffe/private/caffe_.mexa64` (the mex extension may differ on your system) in Matlab to see its runtime libraries, and preload your compile-time libraries by exporting them to your `LD_PRELOAD` environment variable. After successful building and testing, add this package to Matlab search PATH by starting `matlab` from caffe root folder and running the following commands in Matlab command window. @@ -270,7 +270,9 @@ To read Caffe's example image and resize to `[width, height]` and suppose we wan im_data = permute(im_data, [2, 1, 3]); % permute width and height im_data = single(im_data); % convert to single precision -We do not provide extra functions for data output as Matlab itself is already quite powerful in output. +Also, you may take a look at caffe/matlab/demo/classification_demo.m to see how to prepare input by taking crops from an image. + +We show in caffe/matlab/hdf5creation how to read and write HDF5 data with Matlab. We do not provide extra functions for data output as Matlab itself is already quite powerful in output. #### Clear nets and solvers diff --git a/matlab/classification_demo.m b/matlab/demo/classification_demo.m similarity index 84% rename from matlab/classification_demo.m rename to matlab/demo/classification_demo.m index 43a7bf62fdf..453582476be 100644 --- a/matlab/classification_demo.m +++ b/matlab/demo/classification_demo.m @@ -1,5 +1,5 @@ function [scores, maxlabel] = classification_demo(im, use_gpu) -% scores = classification_demo(im, use_gpu) +% [scores, maxlabel] = classification_demo(im, use_gpu) % % Image classification demo using BVLC CaffeNet. % @@ -18,6 +18,7 @@ % % output % scores 1000-dimensional ILSVRC score vector +% maxlabel the label of the highest score % % You may need to do the following before you start matlab: % $ export LD_LIBRARY_PATH=/opt/intel/mkl/lib/intel64:/usr/local/cuda-5.5/lib64 @@ -25,7 +26,7 @@ % Or the equivalent based on where things are installed on your system % % Usage: -% im = imread('../examples/images/cat.jpg'); +% im = imread('../../examples/images/cat.jpg'); % scores = classification_demo(im, 1); % [score, class] = max(scores); % Five things to be aware of: @@ -51,6 +52,13 @@ % If you have multiple images, cat them with cat(4, ...) +% Add caffe/matlab to you Matlab search PATH to use matcaffe +if exist('../+caffe', 'dir') + addpath('..'); +else + error('Please run this demo from caffe/matlab/demo'); +end + % Set caffe mode if exist('use_gpu', 'var') && use_gpu caffe.set_mode_gpu(); @@ -62,16 +70,21 @@ % Initialize the network using BVLC CaffeNet for image classification % Weights (parameter) file needs to be downloaded from Model Zoo. -model_dir = '../models/bvlc_reference_caffenet/'; +model_dir = '../../models/bvlc_reference_caffenet/'; net_model = [model_dir 'deploy.prototxt']; net_weights = [model_dir 'bvlc_reference_caffenet.caffemodel']; -phase = 'test'; +phase = 'test'; % run with phase test (so that dropout isn't applied) +if ~exist(net_weights, 'file') + error('Please download CaffeNet from Model Zoo before you run this demo'); +end + +% Initialize a network net = caffe.Net(net_model, net_weights, phase); if nargin < 1 % For demo purposes we will use the cat image - fprintf('using ../examples/images/cat.jpg as input image\n'); - im = imread('../examples/images/cat.jpg'); + fprintf('using caffe/examples/images/cat.jpg as input image\n'); + im = imread('../../examples/images/cat.jpg'); end % prepare oversampled input @@ -102,7 +115,7 @@ % ------------------------------------------------------------------------ function images = prepare_image(im) % ------------------------------------------------------------------------ -d = load('+caffe/imagenet/ilsvrc_2012_mean.mat'); +d = load('../+caffe/imagenet/ilsvrc_2012_mean.mat'); IMAGE_MEAN = d.image_mean; IMAGE_DIM = 256; CROPPED_DIM = 227; From 18adbb8d1a1be91598aa23bad6550eed954e32a9 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Fri, 29 May 2015 00:23:06 +0800 Subject: [PATCH 045/331] Fix automatic header file dependency for MatCaffe Automatic header file dependency was introduced in #1472, but not correctly applied to matcaffe. Fix it by moving ./caffe_.d to build/matlab/+caffe/private/caffe_.d and add it to DEPS --- Makefile | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 3748b52ca47..e4e66dfd138 100644 --- a/Makefile +++ b/Makefile @@ -118,7 +118,7 @@ GTEST_OBJ := $(addprefix $(BUILD_DIR)/, ${GTEST_SRC:.cpp=.o}) EXAMPLE_OBJS := $(addprefix $(BUILD_DIR)/, ${EXAMPLE_SRCS:.cpp=.o}) # Output files for automatic dependency generation DEPS := ${CXX_OBJS:.o=.d} ${CU_OBJS:.o=.d} ${TEST_CXX_OBJS:.o=.d} \ - ${TEST_CU_OBJS:.o=.d} + ${TEST_CU_OBJS:.o=.d} $(BUILD_DIR)/${MAT$(PROJECT)_SO:.$(MAT_SO_EXT)=.d} # tool, example, and test bins TOOL_BINS := ${TOOL_OBJS:.o=.bin} EXAMPLE_BINS := ${EXAMPLE_OBJS:.o=.bin} @@ -460,6 +460,9 @@ $(MAT$(PROJECT)_SO): $(MAT$(PROJECT)_SRC) $(STATIC_NAME) CXX="$(CXX)" \ CXXFLAGS="\$$CXXFLAGS $(MATLAB_CXXFLAGS)" \ CXXLIBS="\$$CXXLIBS $(STATIC_LINK_COMMAND) $(LDFLAGS)" -output $@ + @ if [ -f "$(PROJECT)_.d" ]; then \ + mv -f $(PROJECT)_.d $(BUILD_DIR)/${MAT$(PROJECT)_SO:.$(MAT_SO_EXT)=.d}; \ + fi runtest: $(TEST_ALL_BIN) $(TOOL_BUILD_DIR)/caffe From d07e5f796907a2bc048bdab3cdb4ace05fa60d7a Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Fri, 29 May 2015 07:50:23 +0800 Subject: [PATCH 046/331] More tests for Blob, Layer, copy_from and step, fix some typos More testes are added into test_net.m and test_solver.m --- docs/tutorial/interfaces.md | 4 ++-- matlab/+caffe/+test/test_net.m | 24 +++++++++++++++++++++++- matlab/+caffe/+test/test_solver.m | 2 ++ matlab/+caffe/Net.m | 2 +- matlab/+caffe/Solver.m | 2 +- matlab/+caffe/io.m | 2 +- matlab/+caffe/run_tests.m | 3 +++ 7 files changed, 33 insertions(+), 6 deletions(-) diff --git a/docs/tutorial/interfaces.md b/docs/tutorial/interfaces.md index a59a410d964..12963318485 100644 --- a/docs/tutorial/interfaces.md +++ b/docs/tutorial/interfaces.md @@ -82,9 +82,9 @@ In MatCaffe, you can * Resume training from solver snapshots * Access train net and test nets in a solver * Run for a certain number of iterations and give back control to Matlab -* Intermingle arbitrary Matlab code to with gradient steps +* Intermingle arbitrary Matlab code with gradient steps -An ILSVRC image classification demo is in caffe/matlab/demo/classification_demo.m +An ILSVRC image classification demo is in caffe/matlab/demo/classification_demo.m (you need to download BVLC CaffeNet from [Model Zoo](http://caffe.berkeleyvision.org/model_zoo.html) to run it). ### Build MatCaffe diff --git a/matlab/+caffe/+test/test_net.m b/matlab/+caffe/+test/test_net.m index 5d9ba000209..3dabe84d111 100644 --- a/matlab/+caffe/+test/test_net.m +++ b/matlab/+caffe/+test/test_net.m @@ -48,6 +48,24 @@ end end methods (Test) + function self = test_blob(self) + self.net.blobs('data').set_data(10 * ones(self.net.blobs('data').shape)); + self.verifyEqual(self.net.blobs('data').get_data(), ... + 10 * ones(self.net.blobs('data').shape, 'single')); + self.net.blobs('data').set_diff(-2 * ones(self.net.blobs('data').shape)); + self.verifyEqual(self.net.blobs('data').get_diff(), ... + -2 * ones(self.net.blobs('data').shape, 'single')); + original_shape = self.net.blobs('data').shape; + self.net.blobs('data').reshape([6 5 4 3 2 1]); + self.verifyEqual(self.net.blobs('data').shape, [6 5 4 3 2 1]); + self.net.blobs('data').reshape(original_shape); + self.net.reshape(); + end + function self = test_layer(self) + self.verifyEqual(self.net.params('conv', 1).shape, [2 2 2 11]); + self.verifyEqual(self.net.layers('conv').params(2).shape, 11); + self.verifyEqual(self.net.layers('conv').type(), 'Convolution'); + end function test_forward_backward(self) self.net.forward_prefilled(); self.net.backward_prefilled(); @@ -60,13 +78,17 @@ function test_save_and_read(self) weights_file = tempname(); self.net.save(weights_file); model_file2 = caffe.test.test_net.simple_net_file(self.num_output); - net2 = caffe.Net(model_file2, weights_file, 'train'); + net2 = caffe.Net(model_file2, 'train'); + net2.copy_from(weights_file); + net3 = caffe.Net(model_file2, weights_file, 'train'); delete(model_file2); delete(weights_file); for l = 1:length(self.net.layer_vec) for i = 1:length(self.net.layer_vec(l).params) self.verifyEqual(self.net.layer_vec(l).params(i).get_data(), ... net2.layer_vec(l).params(i).get_data()); + self.verifyEqual(self.net.layer_vec(l).params(i).get_data(), ... + net3.layer_vec(l).params(i).get_data()); end end end diff --git a/matlab/+caffe/+test/test_solver.m b/matlab/+caffe/+test/test_solver.m index 682dad48a3b..739258b0e85 100644 --- a/matlab/+caffe/+test/test_solver.m +++ b/matlab/+caffe/+test/test_solver.m @@ -36,6 +36,8 @@ methods (Test) function test_solve(self) self.verifyEqual(self.solver.iter(), 0) + self.solver.step(30); + self.verifyEqual(self.solver.iter(), 30) self.solver.solve() self.verifyEqual(self.solver.iter(), 100) end diff --git a/matlab/+caffe/Net.m b/matlab/+caffe/Net.m index a6761060dfb..e6295bba1a4 100644 --- a/matlab/+caffe/Net.m +++ b/matlab/+caffe/Net.m @@ -111,7 +111,7 @@ function backward_prefilled(self) self.blobs(self.outputs{n}).set_diff(output_diff{n}); end self.backward_prefilled(); - % retrieve diff from input_blobs + % retrieve diff from input blobs res = cell(length(self.inputs), 1); for n = 1:length(self.inputs) res{n} = self.blobs(self.inputs{n}).get_diff(); diff --git a/matlab/+caffe/Solver.m b/matlab/+caffe/Solver.m index daaa8022b91..f8bdc4e22b2 100644 --- a/matlab/+caffe/Solver.m +++ b/matlab/+caffe/Solver.m @@ -41,7 +41,7 @@ end function restore(self, snapshot_filename) CHECK(ischar(snapshot_filename), 'snapshot_filename must be a string'); - CHECK_FILE_EXIST(snapshot_filename) + CHECK_FILE_EXIST(snapshot_filename); caffe_('solver_restore', self.hSolver_self, snapshot_filename); end function solve(self) diff --git a/matlab/+caffe/io.m b/matlab/+caffe/io.m index 7a30bfb5772..c9e07aee9e8 100644 --- a/matlab/+caffe/io.m +++ b/matlab/+caffe/io.m @@ -17,7 +17,7 @@ function mean_data = read_mean(mean_proto_file) % mean_data = read_mean(mean_proto_file) % read image mean data from binaryproto file - CHECK(ischar(mean_proto_file), 'im_file must be a string'); + CHECK(ischar(mean_proto_file), 'mean_proto_file must be a string'); CHECK_FILE_EXIST(mean_proto_file); mean_data = caffe_('read_mean', mean_proto_file); end diff --git a/matlab/+caffe/run_tests.m b/matlab/+caffe/run_tests.m index 8773c9f638b..93896855ac2 100644 --- a/matlab/+caffe/run_tests.m +++ b/matlab/+caffe/run_tests.m @@ -2,6 +2,9 @@ % results = run_tests() % run all tests in this caffe matlab wrapper package +% use CPU for testing +caffe.set_mode_cpu(); + % reset caffe before testing caffe.reset_all(); From 2e03d89fd4578849d7793e166a1993ae521b6561 Mon Sep 17 00:00:00 2001 From: TorosFanny Date: Fri, 29 May 2015 21:19:56 -0700 Subject: [PATCH 047/331] [example] fix path for diff in net surgery --- examples/net_surgery.ipynb | 88 +++++++++++++++++++++++++++++++++++++- 1 file changed, 86 insertions(+), 2 deletions(-) diff --git a/examples/net_surgery.ipynb b/examples/net_surgery.ipynb index 1fb99bd3726..303c22ba3fd 100644 --- a/examples/net_surgery.ipynb +++ b/examples/net_surgery.ipynb @@ -5494,12 +5494,96 @@ "name": "stdout", "output_type": "stream", "text": [ - "diff: imagenet/bvlc_caffenet_full_conv.prototxt: No such file or directory\r\n" + "1,2c1\r\n", + "< # Fully convolutional network version of CaffeNet.\r\n", + "< name: \"CaffeNetConv\"\r\n", + "---\r\n", + "> name: \"CaffeNet\"\r\n", + "4c3\r\n", + "< input_dim: 1\r\n", + "---\r\n", + "> input_dim: 10\r\n", + "6,7c5,6\r\n", + "< input_dim: 451\r\n", + "< input_dim: 451\r\n", + "---\r\n", + "> input_dim: 227\r\n", + "> input_dim: 227\r\n", + "152,153c151,152\r\n", + "< name: \"fc6-conv\"\r\n", + "< type: \"Convolution\"\r\n", + "---\r\n", + "> name: \"fc6\"\r\n", + "> type: \"InnerProduct\"\r\n", + "155,156c154,155\r\n", + "< top: \"fc6-conv\"\r\n", + "< convolution_param {\r\n", + "---\r\n", + "> top: \"fc6\"\r\n", + "> inner_product_param {\r\n", + "158d156\r\n", + "< kernel_size: 6\r\n", + "164,165c162,163\r\n", + "< bottom: \"fc6-conv\"\r\n", + "< top: \"fc6-conv\"\r\n", + "---\r\n", + "> bottom: \"fc6\"\r\n", + "> top: \"fc6\"\r\n", + "170,171c168,169\r\n", + "< bottom: \"fc6-conv\"\r\n", + "< top: \"fc6-conv\"\r\n", + "---\r\n", + "> bottom: \"fc6\"\r\n", + "> top: \"fc6\"\r\n", + "177,181c175,179\r\n", + "< name: \"fc7-conv\"\r\n", + "< type: \"Convolution\"\r\n", + "< bottom: \"fc6-conv\"\r\n", + "< top: \"fc7-conv\"\r\n", + "< convolution_param {\r\n", + "---\r\n", + "> name: \"fc7\"\r\n", + "> type: \"InnerProduct\"\r\n", + "> bottom: \"fc6\"\r\n", + "> top: \"fc7\"\r\n", + "> inner_product_param {\r\n", + "183d180\r\n", + "< kernel_size: 1\r\n", + "189,190c186,187\r\n", + "< bottom: \"fc7-conv\"\r\n", + "< top: \"fc7-conv\"\r\n", + "---\r\n", + "> bottom: \"fc7\"\r\n", + "> top: \"fc7\"\r\n", + "195,196c192,193\r\n", + "< bottom: \"fc7-conv\"\r\n", + "< top: \"fc7-conv\"\r\n", + "---\r\n", + "> bottom: \"fc7\"\r\n", + "> top: \"fc7\"\r\n", + "202,206c199,203\r\n", + "< name: \"fc8-conv\"\r\n", + "< type: \"Convolution\"\r\n", + "< bottom: \"fc7-conv\"\r\n", + "< top: \"fc8-conv\"\r\n", + "< convolution_param {\r\n", + "---\r\n", + "> name: \"fc8\"\r\n", + "> type: \"InnerProduct\"\r\n", + "> bottom: \"fc7\"\r\n", + "> top: \"fc8\"\r\n", + "> inner_product_param {\r\n", + "208d204\r\n", + "< kernel_size: 1\r\n", + "214c210\r\n", + "< bottom: \"fc8-conv\"\r\n", + "---\r\n", + "> bottom: \"fc8\"\r\n" ] } ], "source": [ - "!diff imagenet/bvlc_caffenet_full_conv.prototxt ../models/bvlc_reference_caffenet/deploy.prototxt" + "!diff net_surgery/bvlc_caffenet_full_conv.prototxt ../models/bvlc_reference_caffenet/deploy.prototxt" ] }, { From 4874c01487f552dd4b16313d0a6723634f1912e5 Mon Sep 17 00:00:00 2001 From: Felix Abecassis Date: Fri, 29 May 2015 22:32:25 -0700 Subject: [PATCH 048/331] Add a simple C++ classification example Closes #2487 Example usage: ./build/examples/cpp_classification/classification.bin \ models/bvlc_reference_caffenet/deploy.prototxt \ models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel \ data/ilsvrc12/imagenet_mean.binaryproto \ data/ilsvrc12/synset_words.txt \ examples/images/cat.jpg --- .../cpp_classification/classification.cpp | 255 ++++++++++++++++++ examples/cpp_classification/readme.md | 77 ++++++ 2 files changed, 332 insertions(+) create mode 100644 examples/cpp_classification/classification.cpp create mode 100644 examples/cpp_classification/readme.md diff --git a/examples/cpp_classification/classification.cpp b/examples/cpp_classification/classification.cpp new file mode 100644 index 00000000000..1c6371e382b --- /dev/null +++ b/examples/cpp_classification/classification.cpp @@ -0,0 +1,255 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace caffe; // NOLINT(build/namespaces) +using std::string; + +/* Pair (label, confidence) representing a prediction. */ +typedef std::pair Prediction; + +class Classifier { + public: + Classifier(const string& model_file, + const string& trained_file, + const string& mean_file, + const string& label_file); + + std::vector Classify(const cv::Mat& img, int N = 5); + + private: + void SetMean(const string& mean_file); + + std::vector Predict(const cv::Mat& img); + + void WrapInputLayer(std::vector* input_channels); + + void Preprocess(const cv::Mat& img, + std::vector* input_channels); + + private: + shared_ptr > net_; + cv::Size input_geometry_; + int num_channels_; + cv::Mat mean_; + std::vector labels_; +}; + +Classifier::Classifier(const string& model_file, + const string& trained_file, + const string& mean_file, + const string& label_file) { +#ifdef CPU_ONLY + Caffe::set_mode(Caffe::CPU); +#else + Caffe::set_mode(Caffe::GPU); +#endif + + /* Load the network. */ + net_.reset(new Net(model_file, TEST)); + net_->CopyTrainedLayersFrom(trained_file); + + CHECK_EQ(net_->num_inputs(), 1) << "Network should have exactly one input."; + CHECK_EQ(net_->num_outputs(), 1) << "Network should have exactly one output."; + + Blob* input_layer = net_->input_blobs()[0]; + num_channels_ = input_layer->channels(); + CHECK(num_channels_ == 3 || num_channels_ == 1) + << "Input layer should have 1 or 3 channels."; + input_geometry_ = cv::Size(input_layer->width(), input_layer->height()); + + /* Load the binaryproto mean file. */ + SetMean(mean_file); + + /* Load labels. */ + std::ifstream labels(label_file.c_str()); + CHECK(labels) << "Unable to open labels file " << label_file; + string line; + while (std::getline(labels, line)) + labels_.push_back(string(line)); + + Blob* output_layer = net_->output_blobs()[0]; + CHECK_EQ(labels_.size(), output_layer->channels()) + << "Number of labels is different from the output layer dimension."; +} + +static bool PairCompare(const std::pair& lhs, + const std::pair& rhs) { + return lhs.first > rhs.first; +} + +/* Return the indices of the top N values of vector v. */ +static std::vector Argmax(const std::vector& v, int N) { + std::vector > pairs; + for (size_t i = 0; i < v.size(); ++i) + pairs.push_back(std::make_pair(v[i], i)); + std::partial_sort(pairs.begin(), pairs.begin() + N, pairs.end(), PairCompare); + + std::vector result; + for (int i = 0; i < N; ++i) + result.push_back(pairs[i].second); + return result; +} + +/* Return the top N predictions. */ +std::vector Classifier::Classify(const cv::Mat& img, int N) { + std::vector output = Predict(img); + + std::vector maxN = Argmax(output, N); + std::vector predictions; + for (int i = 0; i < N; ++i) { + int idx = maxN[i]; + predictions.push_back(std::make_pair(labels_[idx], output[idx])); + } + + return predictions; +} + +/* Load the mean file in binaryproto format. */ +void Classifier::SetMean(const string& mean_file) { + BlobProto blob_proto; + ReadProtoFromBinaryFileOrDie(mean_file.c_str(), &blob_proto); + + /* Convert from BlobProto to Blob */ + Blob mean_blob; + mean_blob.FromProto(blob_proto); + CHECK_EQ(mean_blob.channels(), num_channels_) + << "Number of channels of mean file doesn't match input layer."; + + /* The format of the mean file is planar 32-bit float BGR or grayscale. */ + std::vector channels; + float* data = mean_blob.mutable_cpu_data(); + for (int i = 0; i < num_channels_; ++i) { + /* Extract an individual channel. */ + cv::Mat channel(mean_blob.height(), mean_blob.width(), CV_32FC1, data); + channels.push_back(channel); + data += mean_blob.height() * mean_blob.width(); + } + + /* Merge the separate channels into a single image. */ + cv::Mat mean; + cv::merge(channels, mean); + + /* Compute the global mean pixel value and create a mean image + * filled with this value. */ + cv::Scalar channel_mean = cv::mean(mean); + mean_ = cv::Mat(input_geometry_, mean.type(), channel_mean); +} + +std::vector Classifier::Predict(const cv::Mat& img) { + Blob* input_layer = net_->input_blobs()[0]; + input_layer->Reshape(1, num_channels_, + input_geometry_.height, input_geometry_.width); + /* Forward dimension change to all layers. */ + net_->Reshape(); + + std::vector input_channels; + WrapInputLayer(&input_channels); + + Preprocess(img, &input_channels); + + net_->ForwardPrefilled(); + + /* Copy the output layer to a std::vector */ + Blob* output_layer = net_->output_blobs()[0]; + const float* begin = output_layer->cpu_data(); + const float* end = begin + output_layer->channels(); + return std::vector(begin, end); +} + +/* Wrap the input layer of the network in separate cv::Mat objects + * (one per channel). This way we save one memcpy operation and we + * don't need to rely on cudaMemcpy2D. The last preprocessing + * operation will write the separate channels directly to the input + * layer. */ +void Classifier::WrapInputLayer(std::vector* input_channels) { + Blob* input_layer = net_->input_blobs()[0]; + + int width = input_layer->width(); + int height = input_layer->height(); + float* input_data = input_layer->mutable_cpu_data(); + for (int i = 0; i < input_layer->channels(); ++i) { + cv::Mat channel(height, width, CV_32FC1, input_data); + input_channels->push_back(channel); + input_data += width * height; + } +} + +void Classifier::Preprocess(const cv::Mat& img, + std::vector* input_channels) { + /* Convert the input image to the input image format of the network. */ + cv::Mat sample; + if (img.channels() == 3 && num_channels_ == 1) + cv::cvtColor(img, sample, CV_BGR2GRAY); + else if (img.channels() == 4 && num_channels_ == 1) + cv::cvtColor(img, sample, CV_BGRA2GRAY); + else if (img.channels() == 4 && num_channels_ == 3) + cv::cvtColor(img, sample, CV_BGRA2BGR); + else if (img.channels() == 1 && num_channels_ == 3) + cv::cvtColor(img, sample, CV_GRAY2BGR); + else + sample = img; + + cv::Mat sample_resized; + if (sample.size() != input_geometry_) + cv::resize(sample, sample_resized, input_geometry_); + else + sample_resized = sample; + + cv::Mat sample_float; + if (num_channels_ == 3) + sample_resized.convertTo(sample_float, CV_32FC3); + else + sample_resized.convertTo(sample_float, CV_32FC1); + + cv::Mat sample_normalized; + cv::subtract(sample_float, mean_, sample_normalized); + + /* This operation will write the separate BGR planes directly to the + * input layer of the network because it is wrapped by the cv::Mat + * objects in input_channels. */ + cv::split(sample_normalized, *input_channels); + + CHECK(reinterpret_cast(input_channels->at(0).data) + == net_->input_blobs()[0]->cpu_data()) + << "Input channels are not wrapping the input layer of the network."; +} + +int main(int argc, char** argv) { + if (argc != 6) { + std::cerr << "Usage: " << argv[0] + << " deploy.prototxt network.caffemodel" + << " mean.binaryproto labels.txt img.jpg" << std::endl; + return 1; + } + + ::google::InitGoogleLogging(argv[0]); + + string model_file = argv[1]; + string trained_file = argv[2]; + string mean_file = argv[3]; + string label_file = argv[4]; + Classifier classifier(model_file, trained_file, mean_file, label_file); + + string file = argv[5]; + + std::cout << "---------- Prediction for " + << file << " ----------" << std::endl; + + cv::Mat img = cv::imread(file, -1); + CHECK(!img.empty()) << "Unable to decode image " << file; + std::vector predictions = classifier.Classify(img); + + /* Print the top N predictions. */ + for (size_t i = 0; i < predictions.size(); ++i) { + Prediction p = predictions[i]; + std::cout << std::fixed << std::setprecision(4) << p.second << " - \"" + << p.first << "\"" << std::endl; + } +} diff --git a/examples/cpp_classification/readme.md b/examples/cpp_classification/readme.md new file mode 100644 index 00000000000..a086db1a035 --- /dev/null +++ b/examples/cpp_classification/readme.md @@ -0,0 +1,77 @@ +--- +title: CaffeNet C++ Classification example +description: A simple example performing image classification using the low-level C++ API. +category: example +include_in_docs: true +priority: 10 +--- + +# Classifying ImageNet: using the C++ API + +Caffe, at its core, is written in C++. It is possible to use the C++ +API of Caffe to implement an image classification application similar +to the Python code presented in one of the Notebook example. To look +at a more general-purpose example of the Caffe C++ API, you should +study the source code of the command line tool `caffe` in `tools/caffe.cpp`. + +## Presentation + +A simple C++ code is proposed in +`examples/cpp_classification/classification.cpp`. For the sake of +simplicity, this example does not support oversampling of a single +sample nor batching of multiple independant samples. This example is +not trying to reach the maximum possible classification throughput on +a system, but special care was given to avoid unnecessary +pessimization while keeping the code readable. + +## Compiling + +The C++ example is built automatically when compiling Caffe. To +compile Caffe you should follow the documented instructions. The +classification example will be built as `examples/classification.bin` +in your build directory. + +## Usage + +To use the pre-trained CaffeNet model with the classification example, +you need to download it from the "Model Zoo" using the following +script: +``` +./scripts/download_model_binary.py models/bvlc_reference_caffenet +``` +The ImageNet labels file (also called the *synset file*) is also +required in order to map a prediction to the name of the class: +``` +./data/ilsvrc12/get_ilsvrc_aux.sh. +``` +Using the files that were downloaded, we can classify the provided cat +image (`examples/images/cat.jpg`) using this command: +``` +./build/examples/cpp_classification/classification.bin \ + models/bvlc_reference_caffenet/deploy.prototxt \ + models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel \ + data/ilsvrc12/imagenet_mean.binaryproto \ + data/ilsvrc12/synset_words.txt \ + examples/images/cat.jpg +``` +The output should look like this: +``` +---------- Prediction for examples/images/cat.jpg ---------- +0.3134 - "n02123045 tabby, tabby cat" +0.2380 - "n02123159 tiger cat" +0.1235 - "n02124075 Egyptian cat" +0.1003 - "n02119022 red fox, Vulpes vulpes" +0.0715 - "n02127052 lynx, catamount" +``` + +## Improving Performance + +To further improve performance, you will need to leverage the GPU +more, here are some guidelines: + +* Move the data on the GPU early and perform all preprocessing +operations there. +* If you have many images to classify simultaneously, you should use +batching (independent images are classified in a single forward pass). +* Use multiple classification threads to ensure the GPU is always fully +utilized and not waiting for an I/O blocked CPU thread. From 97b4c1453377e6257f6b5efc32e2d5bc472e9323 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Sat, 30 May 2015 09:37:32 +0800 Subject: [PATCH 049/331] Update ilsvrc_2012_mean.mat to W x H x C, update demo and add comments Update previously ilsvrc_2012_mean.mat stores 'image_mean' variable in H x W x C with BGR channels, which is inconsistent with Caffe's data format and inconsistent with caffe.io.read_mean(..). Replace 'image_mean' with 'mean_data' variable in W x H x C and update classification_demo.m. Also add some comments. --- matlab/+caffe/imagenet/ilsvrc_2012_mean.mat | Bin 786640 -> 606799 bytes matlab/+caffe/io.m | 10 ++- matlab/demo/classification_demo.m | 64 ++++++++++---------- 3 files changed, 42 insertions(+), 32 deletions(-) diff --git a/matlab/+caffe/imagenet/ilsvrc_2012_mean.mat b/matlab/+caffe/imagenet/ilsvrc_2012_mean.mat index f1da25c84a1a4bdd6d32aee386bcdbed48bba99c..21df3d39aaa3c43b9c2b41f88bd2e6f48585b8c5 100644 GIT binary patch literal 606799 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˪b7-cVoNW`;fpu&9WCL7Y&nA zp8uFoXQSLpqKevcQeFvXYnl~%m_!!6NNK0ADt^WQ=cwT=a1LL`i4BqfJ}U3MW(6JUQkcpI73L{@xGOfG6PQP!c)r&;8_pJ5NaDP zKC&^f2sri7H(XCh-}H1(R5|c7VS^oeF8KVjmB=&RSR3{gpEWnroX_!6Xa`k;uympf z<>U;J*M7pUcDc^bQVnyo4JjPUIL2j-c{c&eVtMZt`Q6wg5eCQdq&olF8u{N&Y)MI2 zb5|j%DpP9Qg7uO&n0T;;q%Wn-#Bia~24%-D*IoJJ4rl?RVgd0oY=1`^3X2t~nl6u}DpVr2^0$@`I=?u%9#)tht-5$%4WNbZj zQ##nr$8}Liy$Tx1o~0uBd>kb1(<2uFkoLd8wtC~^WYA;AyH`gozmpW5rI1Xybujt6 zv2CIYl09JUl?7}xKxuV$zcu$@cQT|bfnf|84`=$YIArPru&^J~b&1;t-| zOmn+Gp>gtv{38x&JAG-d?Zv=L6?|McD6;?gO)@#bYk_%InUyu=;XLk@7s{(rm4 zscS+3Aei!GH=7S{YLAd{nqm}6gon78%sQR{LC2)7Bj!|zo>6RTFv>M`fs(t;duMz( zvn)_!?_*oW6EKVHPE8|@x{>tW+vN`o>vnrbH?!nt|G9r#uVhGt+2m7^;%{`*5^$$R zG!_!g)3$}_QE8zwyS#0y<6PealLV*V02n~r;5!g{oUt`4q8uZ9cmKUxnY9##eKkPO zc<%cZxQQ3NOr8DVhH?4rqX8j-{wjv=Wv%x+Qx+_Ud}Dv+MQzs4o*aw+jJvtde<*j* z=D51}9J;-+2GHdM=5x#jhQpRQNZb@9mUwzc0|c7h@)eO5Vq3(Qk9)6u@=!r4-#MGX ziMJfZ7fCG3(=0d+q$0V_Ojca49m}=7Q-XFDYw;q-K-9aZkrf*J4KCls&e;4V*?%wc zt7n`EyhX(K<@Muvk1$Qw)#{+<{7(%LqMk(oX#Vpj;mtsN_AIDrW1>w7tJ zG?=_^JOS#4ntA?c3+6s*q&>8e<@5ll^QmBXL7cafA$!^dg(^%w&334>=)g)vJxP=F ze^pj>QXMgJN_70$v<3lVJDZw8Tlt%2JD! zc>2swI)j+z!MlW^Jc2#o5lbjZA+>)}uKe^7pAUb}3;gc9+SZ9hrPE;c>T5iQ#vhW{ z!inw1K_oNCU%UWAA287UcrO^oNn(|EX08#~&&5ai;^HK-4y(S@ZRP;m5g?JThi$l! z*my>Wc^{I60P|LX9dAgQ{^k5?`P*mt?R7JpVOFXv5te5S2JBsF@4uiLq!~_TPfysf zN+MDSCs2T~yJ@puRm4iUly#ON>fK__E7jdUagQAtFE<)w_nMvlWx$8wT;ujWgN4$- zX0Lm&6Szpp{ZAYD7yBwYlF&o*oKp}R76>*kA){3i8c61+3ejKQPgnLB!TI=ncUN&} zuZQnZp+a5A7Zb?srXRQ2ttF|>BZ^3Y-16~$1rtL;}Qn}hz1SV_&M+f9! zkI@I0#8k7asZRd<>~fgjv>|LhjpS81jlB=? z!{gH!KBKdC3lWUlpr?S{teY)08HHg@Si;>Z=bF{90N?A&2zWtBm`FT9+y3^Qp$87Z z`_!kwW#i75C!i)4}_o zl(+O^(afp2c*gTaU$xhc44Ea;;XP-~j;NMzf#2MUq+~O` zbQ7LNw^eMs4KRF9Cwr6S-MNOb3HTA5{h1B?bK~3XM&4mstBmDCgn>gy+W@z~Ul{6p z=WqYDuLC1z`})*e6NZEo1bJ@OS|v&F-A$ebzUr&4T(q5WTRAaWjhE&i1WMfPjL+Se zT0Oh7x+pr5IhW48rCC+do%4+t5aZ2JgRtnb2&;t0Oggqwnm2P_ujHrC)!ey2O1Ily zIUu*AF3d`$d!hbiS|C(tji5 zADX>;&6uu6mt8LP#W$`A(Er0u_BV*~Pk;1_3ymLFoaP2n^lVL{s#JS#^SvJ-ig zvLMLW9YE6G?0moXs)3gnz%2F32_Gt146C_1BfdRF*(i^p8k@u!NAI{jp1Fm4Fn^Zb zv`CbGmx$xZJs*BylTZV@$a`XI=z{#UCjl7#GsVx7hm%wMAO*f#Eq&SLCEagjY-JD^ zUH?7UpZ9&N+CBykPuQ7qZA}QUijTF1BJDOG0GQ8i4S~IVb&q9^i*Db=1Ro-{H}_=u z@EU`zy~-fGBU61f{t>jkhPA!h^~JoaL#^+Ud;@Uta(7?r_;wINaHjeUxl}*8nr%|F zY0_O1p8VYqaJ%as786*CMvr{a!DgS|LE---$dl@lfAiLy?44~LlS3E6(OgD(JNg|( zXoxnxjREIQmgR(;Dd_lp`DVk$*BiFfo*N{ESOkVgO-j)JB3(FWX|2OabJeM8OL6b+ z-L^HKgK3$$YMQys-|T2%bHxmR+4Pz?XyEm5|O}`M|=s!=x#d zNuXf|#>W7R`S>{3@}3?td3*I{Z95lkHdB9!ia0mF%Ms3UHW%?y zYpUMBu9~}_`ADsJ*m zPbQ~M2es9Bb&fpH0oKv7>ssErv2iC!>VOpjN023cHdWK}5$24F(7&!13L7AJtP1>m ztZ{$UIZ=UGuC})lwcs49+>(X)cvMwI<`(o9imb-8765;M?IxBsiKH+XK4;z)k5BPXFO`qvt z><$S7PTYuGd~NJ`vAa#m=biZ*6(f4PMYj>rhe|@!Av)I9%SPkhR*3s7bwf~58w%`G3PE)rq|sq*-~oamEY;Q1u8A}Qyj3DX9KB>!FOo$Hfm^4aH`Ree4L zW9}bH;`W=QK2bENCoW+)n>e0a<(*G#%=;x=7h;A}lX)W_$#8{i=A%M}JTM;M7|VJR zgOr#=z{r*_QrUhr=-<)7aMeLmEpVeZnds`$^HL z?yX?rS!gLiozK5o6GIE}SN`joxj%-A#(A&%S|6cXb!GNY@(z4a(4bkjJ*LkD5CcM=T|Ng)LLb>*%70bPc>wfTWq>|5 zoZ?c7p_5HBeJTiRFbMbIe*x38;oQ)XtcdN zoUgSq^^-y@-X9Q98rEQ;Pj@c`f4^5w+F`wnRZ#XANFZg1*S>)YV4C+}r zb7`M;XhfU=v&7lY`l#Ibe@P4Uy5(CQwouxf{pIijMBK~Oe_XaQJJZpw{|h5^G$$0Y z0HrV(|18$x9-g#f!ml9Iihhw(#&k!BFCoFDbR#LN_v-me3G%g-k_UGc5BDJ??#I!6 z9pQc04*Ft8|0$&-kF}PphfwUjferzg#w6bU)j0K%8FV{6tt*WE$jqSj{JJ0WE4HQ3 zbOz~nT^&1g*}z*L*@{UT$zL)J6RD7^&LN&6ue}#V`bUj zmof~jNWRo*f@P^YVV7DD`tEJtI;OEBJW{qHyIK}mVL`LGW(^P610N|#^Zd2ud%yke zp-eGVp5iLwyJ*JtN_+`@uAT{ECiQY+k2TeBwb$KaoWtit7W5d>f~!8#3eY`kW93QV zvHaWwDdnWDJhV;|nC+*7BG~%~!eYcSaIN`0*NV(}C?$J( zRJ?excMtPMVf8|wg(S9`-#j`^JyH267t{DDu?F&naG5#>*!Uz!MbUuw4pR06T;ZGI zI^UHT6=vVe@i9+398&y2oZ$NwCH+=ym+Y^+=O`7%_ZP(vzd!ni()*gSt7Q|Tn3th= zG(k^vA9?-AI(m-HL+g5m$*n&x>>)HByDA($owVQ=b zTh7R2m#CcATsq8k{Pqw0T^LU*+t0sF2S*$%(VKCgctx$EyPC4a&-}fs|L} z0jF7@Mt}1!6FxZuAcC~ERkd_6{=Jo@o)>32&r=PGRd-bI^kl>s%Lg`d@uh(jpogba zV)i`v$e)Cnu0sBDhaH?9=sRn7m$XhBhfdDD_g`8%2N?(p$^=q`=Ce26gx**Y3aU^z zAFXOEg64T`eTI7j+r8>#Gkg}@DmxoSCWr-qW__-fl$hGpzX`u}CvU@G)UUvdm#7c%t@5!!-;5O{?2Fa7tUWLkpxsTB1)G&vb-j7Wq!By5dZ-LHZzXZ$_Kp7&ZOm3r^gKgzJ=Ky~IoWj}^ zULN=+bR+XL<*u_!F9+Dw3@#*@V$`b|jlbjhZLsY2&41<{O#)asr@ppY1X&ITytLUt zXt~x$2-esq4%#tW8<1J_Q;?GHM)I@M?hIr2v-F<{?K*_lEPk*)qOdgj_F|SEpQ?qk zzbI37-lli`d3-2|LTfgu8pe%;OJvxZ3C^7Dvr5#PFvexJG_A6U)K)vdQ^;! zS+1a4@#fXO&Uu+~9)@kl8*%hRK9&{IE9-Fm2I5U;@)qLNd^gAN!D5YUjc*O%49sTrvky0|}NF-`Z|SuCYf+8=7a` zuTePUHWGECz)Wa1EI=s)U)y&MUEd@!sW#VI(6mVUR*2MaCu&g^YT3Vq2q!G~`h?Eu z6BqG@q?81Yzn^D>cyC0?Ean|S>UmTqzGMmaM}BfkBxx`gv@ew6U#qB7qK@N>RnEX| zr*yH6pwj9}ENbMb-D`7|Z!6eLJA@=qp~ron0~G`Y{@Y*8e;G^B+Id)&%HOC>%vq5S>2N=@X^?>Q6{vrPs%(JfUO*=&PAc9d zJ^e1)Y(CF&5e;3hYHG%_qMNAj>i6uoKxlarG8zSXn12x-GsabS-%F^Br41jndeq;rBmT z><+ao$~n+|JVSVgKd#s=VaEo%^e#DX`iv!hQ~8(kC(k;^1j$*l^Q`#n&fTXK#TrxT zFZ%{4><*GB6%)mX#UjTw<^c!291L7w?$HWbck!;S0n{BesZkpt8Go0s>1#H(Bz`-$ zpY{!mA1l}IX>CoW?( z#E}38Tw~7%czLh_n(0Rj*8$ToJGmWgAgnNhT;4P@?r3wE4q_ny>4uvA9`>TTiyun+ z!#l($t}4T^BPLFmv2ij(K^&7rK;dLsH}p>vRTJFZ&|Gq8zGDn^&T#&9UZ-4~XQnyM zcDL|mRXXY=JNJIr7VbGuunxDUNaIySHGK3tx#>!+LE6a1M}_kF(!nzl)dHNGOBBx4 zNv&W+uvt>o$%MM<6D@ZVPK?(^u()KPzcDe?>n$IbPUT2m$aW!OGBr4dQ09FHV8bq; z0pk~Sg(yBW*UJQ&daWV}9ft*#L>AW2G5CN8WG3~g%s##fq3r;A^)|Jq$p@1?BQ|8+yq0oJ*;%gaa4MW;!VXf!^Z`t0?vH zn*_V9cO)HhJpbx07s3T>a%XQwg?zsMB45?hZM+8|Qft09b?UN@66WIB;cj$K?3R3s z=iFaZR=InYmm+B_4dvW-^p5^bWJpWqh*^I5r0}s z8Qaj)g!PMNW#~%^+Sme?@Q!iIe#9VJlGi2+P*+ct8(0#Y$qxt;uW3Y8YGmiv4(OCu zusVmv$}I>Llx!-C;%_#4A;HcIwxAxj54<*R0G;x$j{m6CrpWqt)!PJ*p z+GdLO9pYUGb43ob_q*5P!^=Dq)rJnTrF1Kx0#ove_!%D-YE>A+pd@b+M1pSI911* z7W#w5On&P`Ue>#XN?%Ra-(z z($PyFla*y-_4YQ_-s%j+1*MvH=>>h!VaiZDkCzuZg`H)~--mKeX z*SyJHbHb@oCT-ltN8g*ZOvk2BZYTLetRshMa|-aGmElbi5ce1PENbL zg(R((?k?TLR_M%v+~aP>P4;r?))o+h4+j4;_Rd-nXCE2E-m+yF;KtrWdDkntM8%m= z=o5&)A^KOk^4Y0a{?{aVW8y=}_5}Q;`Z=>PTMtuc$-WCZe?9kdPI%E~64&C{=@p_k zZqXobc39IoxOWo~B1-3u@)(ep<`p^5Zh;4J8?~^Bk?k{PL4> zCxv23k-?~Lt(Mo(@x>m|2=ZR>z_$wRXG2kNw+ESzMd+%N@0ibJ}pOg>X5)xOl ztaqqloRmxSR9RrbnHO);;l?#$pG#XElB_12|QSD=gUZiO*WeHrlJ1%<71% zO;YV9ni*LO9~+t(U*kSKkh``&>VE)Ed(4q6{dXTAJyVWSl3vM8x?+f5*la*(95e$J zu!SbuGYx}v$+uMIxonacw<$V@=S7=_FcdgbOo7%j!DsU&_gHYnf z6s71GcMe7z%zQp4nB3v}mD{#M2(2bE%R#6LQUlb15{$S^w7Yrb7ma{22h5NA(L7Op z`UbCP9pinn;WVg%=KVXn9sml5?`A}+1ClN}2B=*FMl7~N`nI~w)pp7Sm8rP0X!1K2 zjp^9|hg?XQj`AHlqU_I-xvIokejte6Xa9~Q@nRb8hd;dx4j)JL4;cJgjt zt==z`-`*nPiI+Z);yy`y`QtBxOTvKC>pn=1sUmeiR#kG*ew4g8J(;;{a9dF6?_#9b z3_2`ESgF!V@2c~!mP|kMU1b!OA)j?KkHD@TL@*+kulU$o{WToxaq+FmQ`z?7TdLxe z&fQcQujW33L+mK_$e9h7T%i`IIKN{W5X20gFIT;rG@q53vQ7?spB2FdyB`D9%Pw=+ zqhI4K>gm;1nb)Pl|(pTZOzvmVC=s_&*SLuT>tx(F zD>K7~z60ugBd-naXO}QinPhIwzQk2pkO~&ooYl>Yom%);_?4Z`zuU^{X{>sNlwKqb zVi7AuBK=ICNV7O85V!F_z()9+2!=pcv1roHLD;>_(xiDe55w=jh)3Czv6?q*uzLi)wJm<6eK)V|6naMi&ifgSP+5q_q#(U{!eGHqgLbYjOBP%Zckr-J8I zb#+wSA)_16(I^`+fFB0achw}GV{I2NMIvXG-uK~DZxTMuuMv5eYiEIAYq**ZyVHZT z?+DdP$PV>)0mZXn`6|o4Z~6X(DD5`iCDv{K7?r2n`5~zKllI>F?zD|c%Ol5m?WZN$ z+iROFh+&<;SS!_rC|o*Jb%Kk5bt;LNR&bAF*`(kW%@TGKLVi)^NPgrrcm_38b+8+E zYJu}RykA%*=khg7Oy(`rkrA4n_Iz7Or|V~2M*O9`+OTes&10a~PY2Od)dCU;o6mYj zOILQ+*lRJy6y`SBTF1BLsR=v{Y#FLyrfxJ5g^=H>g<$-uVzFc)!hnt3V^9d8(_Uep zJ3vwNdXEw%q>DkkMS9dmNgf!)N+$P>F7B7v{70yZPbtd&7moLkT$<#>r>rzUqi6IWd zH^mFF)E5WXQZc@D{T;T@Hr;k5%3X48|9=}Vojay*ym3}J7SG=^! zrSxl}g@WS0;0_h(;w<58;MekEyemXNy3tm(b)@21B>lD7^`6a5fb;<3G!}avG>dqC z3V46Vkh0aiI^EaR7?Rk$C&<30ZJ9B2CCkfd+;Tq1d1rn=rAX_;Z4+VxJExKa zc(~IzpqYcY^qLcvR=iQfMzzaR<}lUV=&D8QZ#D$5B0j@kN&xf`2W-$dd zI5`gt6cgNfUypTwi;jq$&l{btDrU*Eg&Us2G%~)7`G!_cgj+3CqWthb!r$UuJ1Qc zdQg&ohwFq1Q)nWKD-J#rT*)88j!Oyo6`So7YR1UHYk@vFUzK?;a7?p4ZpTr$XXN*n z$1+HVo=$ICPTBN5RW=@AAe?0 znooQU5(Pgm#?$kgTN%kw0E9)MaEGn5z)?md;y|z_S4Hm{xBC=Q4oSk5-Zp(+RkS!Y zcdCi?@L;HAxbinaAP7vc!gEKvU@Y*y?;_Mxr1(>GuoO>fkoKI?Z{Es-?sP@wF9X+q zCU+u#M-?AF(*xR=f?;)5Vz*_~X9ta?nq>&;;s(*$zTbR;Q;#0w73u0d*Yfm@Lh(y{Dy7kyNRHNW z(26#-vwUO>zjpeNzV+N=g){lfu6@kbqjCxs{?XpOIzjcm*q3br{NEPEJEuN8bv92o zwc51ie8s*wO-Y6i7eDolMv!UUAb!`>8ziRAGV@D!WgwV^TWHuWKBf#!c3HcS?JR7* zFsEkvMM9)iYZZR4N-ARuK&)S(I9F)^Ytc zlDQ(PQsppda3JA)EZxXK(cmsc9w2JKZEPpt@e7{i#f<{ml47SeoPkjXuX!XPHAN;< ze@30i71*Na2-L`1*_M4%>gJpitkRVas@cMfQZbj!%E%9Fd!L|72&)NLdPMxFwG%#= zh=NGcRxsj*=o77oQfuGZC<*>FOzg_Pu`{tAUqqA&BRKfw?rrFaLC9T3r=CkAZKXi} z+KpvsGajKfJ5Alb%ZsZSMucuCel5|T=Y+&qYj@8&*#ilDcpv4Vp{1r%fh;~Jv4?sG^;*?r^u;2d$o<90~M>l3VtY| zYP2JKom(}qFUb}F-IMXb87n{u&F!?Est0O#*la`uSybET!N;>|B>;Y^&+v_lXXHWq zhD#MT@#Im@%DH>_>ipB3<9RH``x+>Lvm2GS=vQ zWuQgX%EObkaEi67`!Kv%0(7tU*DX$O!b)siV5)%|; z(AqC|U@qMjc(^{no))&;?!B_N4VU4QxI2G|IIK|+d5u`K=zCXA4D&qFYaExE+x>L4*O11((q@5oa{$Hrv$KO9WJf%Ns zU-18I`7wVZm!db@2UZT9*(KwIJ3ce+1Xz|2c!WK2jnKd!oqmiE<7DY_oW^s%^}3ICF?8aesG zZRIJ7g;lA+?fZEV+1CEZgXeHi-{?cn-DmE@CzFolSzp)zc%`?>XH#L#=9pNtR(5P` z^Uo0O=A-QmM?O6O-{XUzdp^@p(EA zpA5~iR0xQ4u>f9<cO=E@gX!~*mc?LzW?DxVn=-P_$^?0-0o}-_TdCYQscP+Z+obdDC$TJ$O9s)B z+jtb;F+e7|O?mGQCved!GnVxG)8}hcdlqw_NX*ku-LKq6gho1#rQ0Wz`L@yi&3=7D zZDJvHu4}oynhfivGUShf4Vp0JfA!+Svo59I zvd&^uynH+mPi?J!KZFc?DJBK&`!$580V*qR7Rl8v}X0fBfRfGq$UsnBYmGy;j-RBep6j?)S4IC11>} z5xAT``sb4HUo{zSsZn=o_p$O`<&_)yhemINlAP|p>0)T&!}jpB?tM<2r!aYF*vRVQ z7{~{_1_8^6-(|8Oo~DW!Lyee+*PhH5pIOcp2i zY5)P)L^H@Truewk3^NZN*PXieq~&{1ra_uKD-5Q%e01sAt0z7+Qsrmfp^$-pp|GhT z3kG^S-!Ayq4M0~GhUFCOS`xH$ZF(yNJOZWH(r^4uQt(ODT!wRPt7nT0av;~7TDsoF zT@_eZ;I_o}GN+t|{6)XcZ~bM&w#@s-+&*gQ4MzWdvms*ArIRdt^1S%ZbE2~TF3Bmo zg$GbKOT8JL>%t2MZ@#EYokdl2q^OM0r7#WA4E&+%`7QG(pFG@3 zupeS*nyT3m{TbOZ)ULzFgW9UNlkt|*P+40AZhp@Bnrla)OuSr7+aN07QqrCx~6O&c<1ht8bvu>J3mz4LRUCEw5?&PrS`Zy`-dWSu#C#8XGDMJC4czv|F21w^4ozjfrAM&?cmAQ^fe1{0udJO86yt*EYraG z3MI}e2CLLP`l)Th$b}jaq4d}IyQ=UK`Q-tIokA=PhW;Lw79Uom-NUqPxk;1yb?^$O z7PrmZ50>JdJWus?G1Gas*?7-HS^J-xU#@V#l<|IeA(?2f)y$igUh-lAz3h>a3ak)q* z;EP(k&`SC>%Hq>RhSp4H`7lE;>h<_vUEq5G@c){g0m>XW+3EGE*5@@6{!2(!=$Pu`6{vi_YE@-4<}tVpvI1Y1%D9DDlLZ7l zl=7o3KScbF>JvCshUBSsM3RB&WX6pz3rt6Qd)`t8dggO_9LL;lYD;{wJ2v3Ma7~^Z>+v(l|LPG3 z!Him9mM11=GDWCLa)C|`gc%+<7lv*RXg7@F6gjo|s3gGEU79GKoN%Boq^tUp;wq|2DPQSoe$Amg%RH!w1Bjugq;ZUt->7&W+fML7wc4 zc-RMJv!eCVgSsh;+>)Qb$jeaz55$VVNm88904l(%g(#%c=KbJ(LhZHV-BSnUTFa{u z4qz&5YAC;3i4BD1nOPs2hzrf%fI#yv`g`~Bl5^dDU`@G$KaFkC3tS;Gza~`OeaTl& zco9dz^J5iexO)|tjtnAocEIYnO~-m&ms%HGQ#J~aJ7}r zK9xogaq=sQq`IxN@|pHq<)nwm(FB~Z;Td9pp6+6CbiV30>PSjJi`gC@}9sNv}01L;|aEI*<_1_?Db0`o+ zKL`Ni{|YntLJXBUCw>!SA=#1}dih;%tc8-va!tLbzOCC9Ci-gGU&v+scO(b{1BC6KahnCO*~mC32MYz-Y_p#Db@AvG+h;Nm6bY4na@%E>nwu*f|(;CT-cU9PXgZrM1(f-j3 zJQ;<|?g;24rnbs?_^LE>moz8{mjcHpixxH!*a!;5% zy+x|@FxNmqqPfOQ)0h6u-!2U>%;3H)=6b~I{CORGkmct7|5Ag$mXntghgXs5Hm^WI^4g(}c|0Bms3>Py+SmO(h;xbbJu2_r*`bfgEpncV@SM1`Q^G(Z!>>akO z+lQ12lX8MF0X+fEW{+wkiUqzMEtV1O%>m4sgr+e^kN3&AXHQnjanfeTjES757xloZm;-x_xNkMu67-m_b`>=tHLVGo=FsM{%G7xr{fpU+@cO+qadC zImV%Gzx4B5Y^YMjMJfTbG9c3U&V);It969EtmrifX zM_7TY4Y!fiTKj$)Hfmd)-q~Tfn(Lih6r3c0*N7IBgWb05d0iUU?U~GQ>CjhK0>rbs zJNy8%f{VBs7BIgbO&HjJ`_B0XCz;|FaFHmdJ^8ocdy>|x$mF2+ZOVs!`)yj4)=cA% zm@ddJ-fuHSaVV4^_E_P$8J&XN;O>lzg|4)(fOPF?Z zR(@6Qtl-8N@ta#`=f6B<@+UNuKNJ{#gjvYGxM}rywzYc5qCrLs=D{CGJg#@~jS-rD za)JI_p|3oi|InU_#-0ftUsvJqDRq-wVVTkXgB*6+9gUwh5MzpM5V4AD5p)c99OMb( zAC%dUpsi&1ohS}?=YB}s%yoa}iUEnz`6N=xGVM;U%S>1J&YQ%GpPIxO95{}f1A65#_<&a!#*(Wn_*Z0D(mHQIb-tDqSE@Ns*(O{X8?^f6 zqR&OY`DI``bu@2fPPx^xD!aHw*#K+1j#6(wCkI28m#HYXZ*}~wwu~TazB-JHmD>EI z!~W)$bsCD01R9VV+VBh!NS?YRnRZH_6>e&=tpCc!JPT6WHp2RqX-$-;!ZR<0FK7T2 zyuZjk;7NdeM=z)Wo6dJ=|I{{73gj8>*~bSusqoR;30QW(wBqxW6Q7C_0rqNn3)B{_kn7UinXMia z@HMs&&#d5p#`$pR8NrD+fa>#&j<|tj2P&{fxtS&?HSHF~U^nfYjE-y=kacb_(hwZP zJ0{CEPW<^IHFU5jV2X!GB6oT%b3Pz1=+Hp^6#V{)%qo7^{^#px+6{>3PkZ<8sxpaV zXGo#qbf8h&Z=_?2b4D}6LsqfrIp9GIUTo=yMp&O6>5)VEhhh8RC8fEsaueIgwr%(e zIc88#pE;9Oox%k)biT&8oHMyHHAB-5WaB0;N0MV{kyt_wZeA z;{3qKwDM#QcvD+1{&YEx26V%%p5<>4hgwBf;~;8Q||R{!J%>zie| z1C#TNa|EXI`@dxP`?Sa||4GFZl*F2H>(_!xO9mO*vXtfiM}n{8zy zQeRgH<15q8jPPH`&or1M$sb2;}SV-k5LumM?cj0WQvAJrJ5=uhg}5lw(<^iVp(m-Uvc(2>#` z@0?CFY~-=$8=ZRIX=}@Wg%isgQcI5)(|Vi?Y;O{kOUUXbe%gBazE=F^9tJDEO~)u3 zalb7m)1P+OheT*$mAe(Hki4nX)Y^CAmEFY(<$f15J;Sz-}@cwINDkUAfg5tGOb4s6;&bN4p@3XE6F8|pNa8E++XN^NbD zkhXCFg1cvG(%3Y!`XrselK1fzBOBwiPt?d6_kLz{I&0|hubvzdK3=mX>XWi`%)$2s zS42^6?PS3($yt43aLGEz5RbB6klOpus|?m&#dSo*jUJEkQ;X-s>CfvKCRC))l(>7P zYL4E1;5bG7+DdFeLdh&MF4O5;4R^y*(Udw&@XW4KUz2s^o8VOJl(yw}%x+StZdK84 zMR;>_&%ndLYU;TJ}7+90gyl z3M~q@oG)y>1~gAm2lCNf2GPa{)#!1d4~9bESz2P@cVPRrE?(vetA5qpR>d31$-a#_ zrn|qSIu^x^C(MqPrw*+U#MiF=OA(4EN1*pZPnj(@HqlHIpi@+LM?o7JNPtHwDW7ml zI=+vp{+|RR({HPKk^NWizr#OrWZ&miG`p3da>8ExL<<9@N zU2b$P2nW@8AF9P1c55`4bthj4zLXkyG{O_+to|y-$u%uKF3ERCF&O2a+^qo`d0=4y zy2-aiC@a8=^eYFEJ1_HVWH{U^_c<~dL+&*E>zw5lc z(-sfOn6>Jv(xzfQD<$?R>G*TdE(nY~R_5T{;-YO3*Q_R1GD*ZqFlTb0rZmO0b)~6KIuPF~ z5H;KUH+QATH3&94#MPePSiX@%f^uzOvuhX^rEQ(xLer(PrD|vEi9BqTs#qD>N=)J6 z{E~H(x#FbFl=_lZyGOvzaEBb~OHC>yLnO^kxjtI{rWcG4rLUDUV4xc0q*}WkB&TW zZ*zLnx`|HyT2=#6!(|@WT~eYvQJK(LyG_W-c_>jlU&jJgnlx&6woz$LRyccB=&j%P zq7lCcvjeZx%IDhoUhW%BqI+xW99HD1E}PoR5$+8KVT@;R%}QpSmKtgBUT_{RdgP2& zfXb=%O`n4oG3=KHRdAHKHjRscSMosIbE=cvy1x_+!?^y9j5w)?v8681RH>^* z4n(Pyw|T^+c>MqilS*XTzx^6qZn080@g({SC1dsgL-yT$%_J`&u=n(6TP!3>OJ!!e z?^Y-SMr3X-_yR*g&>{G+?&9103W~sHXwyz7QG7-*((_=CP;ipY_t zaP@ee=v{Tq6*^~3H&1MeC^|S!^q`Yw4jS;i3=5JZ$ z-fgpRKfSX+W~D^$D{Dc1o2l1GHA`UxhbCS*oX-2Qon-9?J!Hu#++a-RCDSz)2Es+=-k}I^Ie5C%KIf(dQ={=q~))$iw1lbDjVh7;2Ae-#O zfcB&fKbcxs7^=|G{3Il&kJ*T^BhK%tDoZu-5m^S%jO8@3L^+GwcyP+Blwzo*I8m)5 z+_%B}o{evq-rYtGD3>)cwZ2}V>&vj}x=kO5?iT!lscRFyU3hDE%7ak5Rj^ES!NvPkQ?vT)KE3u%gkZH6@Vq4Y_*Q$T%heAQnq@s(VlSJ@*siU;w?D>D zbOA_S9e?WOb|v)&yhZlvRHnc6Qu{(Zktd{6cE?jhS`hJJ9!89n`@f4;BE$&ssJ6sa zV0-VeEK&M41vf%8lciv|XT=WI)a{a?@DisL;9VGjCMCsv@4Zka&0b4Fhh%q?&c6(C3+QngEq`I=vuvr||+;@>S1 zH8NAW*A*K&3Fk`2a{2g(g6X7afm+Q(ZZ2X;$lN2VG!G{O#>bV3pJkUFhNO`=ZJ1l7 zZoyhPv z3H)&#V2W-{lxu=))NM&-gh*!;omtnY+o;R1fjRJ-{%>Q(m7{3FOtF{NnHv*7 zSLvxsRRrSl=(tYkDF&Mp?IJ1vs0sh9$S6MddIldV=P@zW*n6k+W~ocma2ieHV*0#6I)ibX&*kB#tS zB1`+9_ReMcCnQ;qc-U%~TKWVJ^%fwL3Z0LXkvt<3Lww2aBhm86?(WZg!l zQX`2UH;E~6$y!oV^^GpKAm(b|zdn|x@gJ71BCZ|1Z;zObFHdGgYbqHsAZd%<|B4rj z+7fOp5Uq!8AF#iEBRQcd$ZPxz(fxomCWrU=%PkAdjV@wf8%&c9Ent|P09M1)tRlG9 z^iqQJDm>92FK3c=C6gBdMMtWVOUHwiq(*vvY%PG%pXa!o&9VRiO7RJe%Z!&(TC4(@%yZWb=fmO2!BAd;&*hY(#N(Rip zBjf+OUjk&55t%n}{vdINY-%&fr`>{=`EeN`_ae_<=U&icD-92PR|yS#*kFB~cpu7O zfCur=7QHBVB2FE}6Z9fChilU7smo-Hh+DqcKc`Giq&ghKK1)lyTC9XD_jng6I29)Nk!{K=P7a1PCxM}HcH!LoNO+8f0q7;r*3bpR%N z^;e$d1SRS}f7(Tkzl%UfNbkyOnI|W(*q+DrfdMhv&8l7c68#Et}pZ>IfJlYuQSc|1X*67 zg<%p>7s|L;vJpEBH1C|YPdWEF56)b@Tk|u2*Uy;qb-{C43uy5&+R?~4o$;b-ZI)d_ zmb$6rPzbM7C0#1ZxSo2gZU|PlM;{30FWHGYmk-SJQb{-KYVZKN3r##mI_>FwMc$mS zNDO>!W%MdZb9#--0}k+6o}h$8Wy@|M*O|stgigkI;dJ6zA3L;xcwVtWH!Jh7U>;*C zbypEXk1&-?Awz!k>g}J8XzW)NEw{D}3aC2rMtjDtvLQS(c6`52t&dhPEC+Gamr%}Zpt8P&bl-WZQ1H1=2ukj_lj9%jIIkui4gKNNgAz@8a zCTE}|^Vmb3*GSv-NiunwfmsF15vY<6Fg!-pRtS9?pAx#%Gdk9LPAKsdBR$jDf}3pJf z9`&eJyW04|#s*o1PK1K6*L7l>-{-aS{^O^=zjzb)UMPofwTtODJfq}Rohb^9IMZVa zHVd;>*qy#A)o2xSFxdkhUo7~BeH`bZDQdj}H1;5SaZdsmiqZVhvIk#<_8H$Qvj*82g;0=jV>gZI8@QnIc}HIPzw$G)o0gz zjK(aDs% zzH(qVK=DnFmx1m@tXP?LntBDrU_V><_u~S%+oyWrS67FxG9M~O(X!l9PcWAvtDn?D zn2UZzO3OiX{7E5IViNXK)3 zZbpl53bEqzulo80Z$$6~H`HtY#_Y~zgghh{33wzIV8wl z*W}h@_)Y)*a#J?x2xUfQg_n8+8J9u6bqVWhVrx&b)1-X^6Z6usLkBqlPls|Nhf3Pp zN)eY<7u1`7vz+t~b37Z&vZuKnb$LEmdMD!)3oqF6Ka@1 z_NKd|V9-R%l}b18ClaPW=bDbICzdO%>agUcM|_^ZH~>O0&!1ynQ3VYn?~ps`8I0ar zzB2#v+YlM-%*Fud&#&W;3cpkOa&Lqz24b7xzu^~#(lQ(2V{B4h4a-%K!JSjz zz`JaIcINyVo#WL95s{sP?Xnq(`tVWn+(=1)&H->}swVz{^44sY*+6M})G~b|T z$k`NEB9$g3yLL;YeTwE%$lLGd(^F3K+*}``(9j^Rsd+JMO@dfsW@sQq9=n&R5#FV( zT7f!jq06mKcm3bLDjC~|p1O0$PF!!uUR&3B0UK9aNn}#XfZh9!m&)4_`f`9}`?@V7 zqBTI-WVPTpNrgYJ)yURRv~eUe1HNshli-vzc^13UnB(vkn|Qun8x>n2TJdS*>BX(_ z8fu|q%53fe^992_(&xvA%W&(oT>>Wcv3UUn*Qr-_^}O^V1A<%{Q!vP6R#j-pZm2o~ zeEh_8a-;n#75mDl{J^czwUtD+Lp}Jr+DS82^}wxja${&xsm!&xbieQkesl} zGHJFd*e{it`-PvgeSNxdd7)$qA_mn}Ox|-Q%Q}7xB zv31tnSnUp;vt_jrWzNyz2!r*WN+Fh8A9|X;MVjJ$mDAuI8C^~{G)x9^^VIchLMAf# z9=`4#CQ?UVpfUhx(VM6Zm#ZWUPZA%gGt?a2)@x`=)SEk0(j!!YG2^aEL>n!^)bX18<5L}d;_&{CaqNSA8=`ati78;mH0q95 zyf!SO6Htn~wVb+0yH9zf>^Jx~pHeIAg#^issz90C@V>MTN;Y8m34K`ww_E5w;@oBYa z>o4s*SMF{-2aUP>&XJ-#TV$BDpV4O!(cIjis8-&FtTXpt!vxqs<^gHcafU8ye;o}v zD`ZR}?3{dIsc^v?5~`Kj3czE{OsVLYL1K@UT;{r2(;#ENl$ooT7{K`H~v_ zg}9|jOm^|7lfBz%edaf3`_$-VL=jnCSCXdc-prW0-hMb_fQZ!66Em)E!* z74XaN<}XOzS!F?F-Rmr}dNhYXNj?llms1ogi7A(^dtL1rbIe=9SV`}%&lYx#HOzX* ze+4$ip3qmMI%y^M3|tsES)d@qwtIxnCw5x!IHqjJO{pxg?m;C6(zv)GEo$bbwTy62 zMz;?1Q_qg&XW$QBqfhsi6 z=f&hj9(rzu0qL_0n=wLf6cmO-RF@!P!|QCUHSRWHeN8RRlf?MvMc6TWy5@(ekq((c zE}4R5eGI}StF^4hfXvJG&lEQR-sdY-uQ#ppW+u-78*)CKM|G@!cu{fCY|KGG+|k@k z)Zu=~P>ruQgmM=O-9WECT%CMq&M~2+`|DfE)Os@VoUDKyxOST0Th}{#IDf`_%hH=- zqQotH-L$^vAM!TWc-9!;0fU@wSP%G^onb-1b*@$nl4 zqbY;n0!~mHd@}N&u=k;JxS5-RN#v7x(F7TMY$y(a#CL0;p;|)jyM0 zUqZ+g)dc?7VDE-*0Nv2hjfRg>h_c0iLwBP)H_&p;3(J~QKLh~Eh@5stBFTU@zIp!2 zU_9P9@Vz40%*N=)E}_SuKw8uy+{Pnga38PpQ-~2sOq0j{O{nmufXWVHY;*SR{jme^ zlCv4#5pu}9W1#d$6c?j$!KTt;LfR1aF6nBV#j9Aw)(j6Z)5$~V#N4p~r=&h-vaCm> z2#^2Dw|CJdpV=rkH`fj?w)@mO$9|ro+cBPyB>SZBDE@(X36P~)6mTs#sy9@0L;n8| zWSN1B&$jzMCqFIeO@u&WDqf&XO0deo9*i8sY2I+q3;Jn;8Q{Rd2eU@q)lZXUzGsrvV~dm94Y zl&<}=GV9$k^y|9%b}v4198iWwDt^d1=RRK3NxICt$7~Io2{8TmCi-cWO$y8Qk9!$t z?zS7N+&?*+0gM!`dXqA!8>)XpU*7K)5XJG)*6pHbYJ>Y1%W-#!w>WkShgEqh=cNsv z)MX89tzBArYxtx5OAG0xvbAWXXmM;@DAk{h-Upb$S8qXlKYNTR=$QVM*NtpedNZYe z2jASvX@iutI|l5FjQW~*pYAveir{0P@JmO(6}y8-MY2YvJv@~$is7yqTd}gKvK1Ox z_utEz-M&_fE~95Ood^uUut)pGGmP%M`)9lS?A(*dyR}_xrgZvV4q|_KOSsHyN}y$} z`AXXTbk7@hNGY(RJN?)7bj%J$94N?VT9=tOy5Z{$8{`#WOVplZmb5s|WWY~u%`kG! zEMzuWd8Bw&jhHoRlS$3tYq;i6;+i)7PA~XUo87cSl_XwcXYJx$>(F0RstJiqiirwd zkz6x~(zMS1Sn+u0+n^FqrINlww7pF0S?Tj`OBI?tN3tIv9b&R>_s$Xe{4?olxZISL z9Ej_7hZL$NOBxv(l-8O`liLnSBNk3Hyc#k1?kaVqy{T&p-3_j@qXopCXqu2H-7JNk2v*xT0CZ>S*X zGY^vaA<~4U(3(#*oAl!fZvPgXp`V2Vk5Qyj=~8YrKU{qp z*;^|f4bFL*J_{v>tf^Qtonr-&CAg0WA50B5PbJK6wR-GR|F&rW@>tN_vuP1B@=?R` zYXjKgXQ|%foc%mcGJ$5^mOHiDH)mnjYxJ4_u|MpAXE4wRmYf-?cI$|Eh7CRsC+lzU$dWw4r^J1exRbqtpn;%s%R$CEe6q zZV`#y)d~sYn7{2q#RHEM2|u&t?mz3zWhlJ3c#!3--j+Y+8s=Q!oEJ_dbe=_zw(vJP z5G-;!Yw+xt&Q*ZS|Pz6>|XeV!r&6A=sGN6CgoKRHq+7p?b=N$`o5@$XHiZa3aLK7pq*M~Vw~i)oLufEVPnvID;Ahkpj>TRK zx%cmmJ>H?sM3+y^A21+sUTd3yf{lmLJT7!yg33A9uzAQ_h~2;6u_}`QNze7lZzrnM zZm^Cewe((*s47#I?J{DiZ)^U)Q~`e-_x&}+wAQapI+02q$gQvIr#VzP+nu2FroZ2O z+h7C7K~&v?ni!aXI#a`2Y~w(8i4;zJc|3Hg)KCqKACeM|T4Y#u7Z-9e!qwD9I+hqE)drbPIm%BJ=5GZ3>Ei9Jn7Ev^DJ5RX>S)knC>}FQhb!f|U#%XT_&a4KQe(2tTBlGaYHq749U#g9>EhKkMrX%l8m+LQVYE)%8MULp zmH1#TnqWze=%$YIckk!-qTtP{eX24j1^3FCjG_m}usoNFr{2f*1oZ8Tk05-4xO;oT zL6RLN?j8=u)n+2AvQO-5%b0LBT_>Ln18#X7dtw{T`pPr!IDxK8(n46{%Zz(5B|%&DkSAY~yaGQp>#(1XFxbEO zS-fSNh%E?P^(?`p_ilda^8eW*qBH-QcA9sb`FY=X*mH-GxhF=gQRd3>{dGatL<6b} zSQ}eGA{p5w&a)vQ$L}2qX%Lj$j>x7)ba*4fJh^YV`P84(|B(gbkqm7P{;mj}V@~u3 zd%AAV2KSmIz4m{d0}Vq|!q%{|6@k4ehYJUobhs~j6@^+G7^JHFR_3)JVk92l?u@QTVy`Y5(d+)8+(00M& z3V0`6^*qF6^EAD{sN9cS8Q=MaJhV`PI{UNYv}>Ss*;gmtA4g{QxWrre&qz~kcXdob z3u3W7(PF^6ho_k|p8k|DwrYVddd(q{gGFg#Kzj&VgUCpxZKqQj|F8k`E}6k|aU>o}WAoG+_l!8-m)BFS8g8e7&om-0zQ0WSsu!-*bK<|@ z!R+{LYVdzbiXb)fr?5H)uTM9OZ0APAM|sithW}iXlucIJ^jGMC%~( zDVI@>h)auz51w|Tl(wjM@JSeP)Kxn;=2K=B-q9Jao?%Vd|KE{yB>!H+MSWjt7#aPg zoWcTzab?Ip3>*!;z68D#mpmsloe6)7Y1UZ*OGU`9Y*jk?7bWS`j7w$c#j;MBkIS)i zpR}4QYb>!by}hhJZ>z$d&IvHYFH}f!qZ)>*!b5j^{A`#+uG%XYq?bZRoc@}o7VY2v zj7TEamTJFB)*Q9xq8(^&-+Jh#m35fLOp>HT=4t{Nb~D`bO7+<$RBXtqlD`Ey=vpl3 zZgg`6dz3KH-t#>NAP~9m4E$N_O1>T==+!AqMRQZ%^|C$U@-g(B+R?e8Z4H{ zf-t{?cR;(G8Ut=?!naQEoqlTRZXf=wA$lv_F~7lyj;afHDV7k9cU`#tn|THDL~gf; z0pC@K!3(keM1Vqy#&G5JNT2SS^xKM~UPmYz-C8kveeqelV@H%%@C0W=a(-<@X?4On z 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

  • 4o%wlywgLr#jd)(m^K9Jf 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

    xB4)1E^QceuT zf9!RztyOX`Gq$1C6?}UMEFDEN48Cqu(5e&|TSh#H18k^aNjUQDUU&v~s-QImenXegniY)Ay58t_V##oHr|?3ffY{QW9P1tR6YQR9C7QyV zV$AIb$0ER=56AlKHyQ;7qw!0?@0GV0z20H;5Bo%+b0gtiPU2Ri4kyMi@_RHn*~jUu4#3;4==`@? ztSZ5if!J;{wtZdFs<6NU9NrFhU*eCH9j$6pwswJ=e1FmxJLB6A@L~Rbtknyy!`U+U zea{T5jSJB9Xsgyst{=ZojrJl1D zA8yC*)P`}pS*OAr_M-iAq198clmqO2G1{sCxXT*J*}>6h+B?vSYiLM@?>Hwqk>+d8 z1AgXZBIf`jJF&qwauNRynuz_P@yQ*0)Qa5FAs&24+&qHTe@0HV>87Va7d^crr%N}T zyl$AM+0DowOL)4J-qX*nE05S;euAs7Te|u@i>sW+9X0;LQGs9K{zykLwH@Wl>ZrxF zkWMWO$tDV^)|+@8I2NzIZxYlaDx~@6Li!}Pqr|NowHx3l+geBQagMG(Cy)5l)zjv# zW{z`JYKyBZhf+#TAim?< zS@3k-8`GBj2SMb7`+tRo1At2s~1v(U91gR+GTkU-*9_<@GeH<7mp?oU7y* zt07aZHh{}FU?B+@=+>QB(}R2l9Z3h4yAwkepl9Q&TdgDpjU{hs{*_f*@c$4U$q7C# zqJv4X$@!021I_7z4jv_k`I2~Y9~>n{d+z7w-jo~gr84tUGQVwhG%JkQN4+T@=gY?X z2>Zrh*Su)eJH~%aZnT267P9Utv}_a{OQ--3u=`=g#Ii^8FNlZ4vLx`ZA=-DP4!EvM zT;;57xkFyg?$)sS0gmRPe;s%F15Wk>?`hD`<&yN@bVlN4L-e!?ed8D# zMPFUU1@LAW_WTAN?)(FJ931<1E*!$vyWnIP_8)@pS{~wF{}Na6*XF}k*D3Sy)o1&y zE>N=aU7g?eg}B>8tFK<-)7Mr{o?ErKZ`FX31AD|CUIHPBE^9J#n z(*HI(WZ`-uUn`UOs(crXxyD(}S>--%_2~txd(?k|y{`Y)jX&|zTI@>Mg1+oRJ1TRJ zTI11*S!fJ6_zo=3#ddFqYw5^AGn3z5mF~jHeNuJ^fPA)5p0zJ$&TqpL4E0CN3ZDrS^*ffJMTg>5d~v*5?MWby390q!kOn;oDJq|%)eRgyh;np( ztD}euj@o?aDoJfuwR({IFL(9sq^pW=Ts7kjP_VrxZ=$D9czYH`r%FBd)R6bzF!C3} z+rKqA-?N$Iw8W}H-17yoA{%ianz&dCoE|5i-vS<6lQ*3q)}H_yThQ`JaDBmKe1lD2 z!o7lUJ8~VGx)aQtM(^XT@;O$A@K2ru^cuhAxn*_i6}-T|t?}JpFwpUZ)!pR2HfQiv zG?lN*Ieb;h?W_35zIJE#mAVi<{>0ab0=`y<`TF!zU%B|MMj1#c^^vb;%wL$+*QSiV zQl;@F*6#?$)`FkO;K_dsN1wtY`bL7AFTqx?t6=i7)h}Qt)g|t52F`-dhG!WAo=1V% z2>ND$=Tl%j1^7uqTzN>W8jhAEpM>uG0+#6?1jZ(!Rng$B8uxF$<2^U((|?oiv$XS~ zdoyTfr#_B0F8Gz)lUQ||a%KrOqqL?hLN9w^$F;=2p^W_ity=}RUazvH5&G&F|}MPG4{FOLlx! zf%-hjzLGWeH6p@S)fT>THuKeic1&|$pLg_i zyq>Sbj9JTX3u#v^O@Aq0x2pL1xu&n~<$c}cyH+@TC44o=OUdPHVR8Kl8kqY zXVjD2uMv4$B=4buyr1Urz8YS^XlW`qbB*^t`E}2^o@x&Ew62V&O~pKAdm*NI#Vg>BmJ0sy7Y(_l{Sog$e3a zDWpZqL%MdAcfbdZl2mfkw-@u~!2MX(;62f@gsXn-$o&_)DtyA#Ux_`XE$?YwC-i8V zr&qC_9Js$P18>t$jk53 zW1>|&x<3z_tps~(uwO$sbPulAhGQ=%k??C;YF|U)W*j)ET+&w#{9nI@uZPts_;Wq& z-0gfc6rWSKqWs>+*Ua9&c6RYKsXM+O=4;(ZUuAyub$=9op5^Nl?Gcp1^sgA>>!*pn zrjG_A1AR@61Y_fUEgkFYbtmR_^%Xn7*ZkqWKI)6U@cXf$=nB6lW1m)(qTl%{*O_yG z#l_&Sel1@`z+zdj_pT0m@tu<2o^pr#V0kcDZ-+jO%j~NuIGg<$I>eX~m3>X2&Ly9i z3ogOvaq3}JeWl^9*UI{;!kBy2d`)EB6mS~`52kkN15)QU6EccDKV?FYZG zXWDMqjpA|tdDwO%Ha&`++@^4cb#F4KAp7iSo1&DfpmeO+YzW~`I(SK`4WY&p(XFZ^!4_tk{^ zRPNpb3%+q=Mlb=5gb9Fw0t47-$ogL&z5sqdQaujwwq@TBjbgxfH zzorXme5V9Owu{$}vhf-|C_yK(gmiXzNO6CJ)c1Z!I|?}3*TT`uX^yt-a`ekRM~e!O z1F%Ql7*}b@Ip(GGbb>cXwE>=ztmiEdLYI>9t}klzMFVnt-ZFir8#UfWUc zrT;E-l05~hH{tOeUo-f9_eFSk1ibG?v%ue)Q=IMp=QsiG{w1z)o;I9yGnkA5f18&0 zs!l0153S)Y9XPAY_<0A>2j;{b@->F<1nMb!IRhBK!2I6S@3z7baDICuy2O6pv)@Mg z?JBf~-+rX82kVVH>1!2tFHK#Jv&D0!D(8H)J&q=D&sE%`8udABH0uibfgR3ppBv0c z#&@&-pTos&^xed6D{c{oxqre9?)e|;!K<9G=diznJ8y^N*KwU9cpl0-C%N(dA zC0+JFKV}QGrAVME{Fbgzps)DeL7k89!dU{n4hx7IteZB_6xKbNI8gX&Ux(O#{bOHC zIPcO6CEJ1?~G1{jONE0^XtL4A zyaVPGFzWu+Q$*lt%{ubzfu7cu^VG4V$J?DZ`9H2U@GcK;;i@+AfAAwmX{I~!;qUN@ zj{YN_&)yMI7Gi%y?T|jZmY_o=5|pz@yv}5a*EjVNq$dfQ84*&<+>q?~kRHAcDNS)l z^@clYyUo#7_TAxPkTpsI>g(5JsNeNyx&wa%0=$tpa0xzb*>m_b>%>L`5xCWP3c(-vkP49q2RWG^W1XGSIoYfp*mh)TB(H^p%)fJhf2GcWI(7@d9lv9nzU^3_aoGn1+C3uBe9Cy%`jhYYu7RG64>Wfg zcbvrD^p*WSP^UqGQj8ANVF+jEJDN3r>x~U*x9K0KSF1q9S+ilAKpA=k3eneqIeSOJ z{YdsKCK;@@m#~%W1jlxfJ1Knc(YZC*-&15acS7x8F z>^Fn@4C~kB&KIda!aq^iEE2y|0t;!&vKQDWf^L*YW1`WQ>0qW7dK8Ji%|;UgV#PdS z$se1@1Bok@h&8>*9a7CC29YoPjUMbL=Xph*CG_9}-VcLP_`34iD$zf@k$9`6;BB^J z4!9poe%poImmFY8Cf*M>jOv{=%D>d8GH>R`eT)w9j?SF~U4Z}p0{{U3|0Gv+d=^I= zEDavCKybGrfdtn8gEb^bC>EUJPS6s976}xmK!8xJXmAZu+zIZGyzlAm-l0JgAn;8; z{&;?Sx3{;qxBJXIGr9Jf@R?vDYkd<{OPbKqnNV>Ceu*^jTRQ`u><0e4t)uS{9hCxg z`fBxI!UNr!i!wzyvSWc!}%E+ZXMRp(9*ED zgpMPFbnM%tV@{HeS@{htY-J$B9|j)mHE{NwfujvfB#h%4Hkw$hnaGsYLPSFgi@I5u zJ=;R^P7Bhq@Ycu1-4Zq)G_`T1uZ{CVZDd%$`|UPn{A=Sk-Nu+y8y(XNEG{e1Dp25T zs6gmYfp)V6Dyu`QF};jLbS;U{RuYTB`{oiy z+VR-{iO6me3;IZ8?8jr>{uF+>uDVC6R1MT;{U~jvsYXB8<-p zCP=J5EzyVVxZ4ty_-x5tiEWQ0Mm&-5=a^%cCH~|X`*x4VNfPCGJ&N<}dLZ$Q;m^53dB2a(3-kIp=S;`@vz*J|niq3D`TzYMGj2!}dn{4o zt;Cb}9G@()=#@mUDUoJLoO;gx<8{202(%?OypZ^+_)niC3b4O*io{X&FZ(L-M@EG} zwzv5H2_J=oREc)E6w>EbIFwUiEa&dS_m8`5-*Mf%-o(C%LZX4gf8jiPJQ9_;cgftV z8(jN7wlfmB4t}%NGk%9-bMc@1zm(X*IimQzbbL3GYkBGASgvy=zwe{Iue;3$o*}=H ziT%^rW@P_+?rlHrZ5EzgWu9lP{SrgCH+6ZwC00pXTg|b|iI-9Q#~~6YyYv6MNW2Z< zzBiHB$=rI9Pr^5oL{MIdIVl1?bb&2iflK$8hmQsB9TkX-6_~wVVBG?Nxx)qe4;C2O zNnlWbK*{0)!#~?NcHhSPgEp$|v2lEbjk?oq^y+A%L7f+!T0~js zQP;wrbQV@QCYJ0r(Q&Mao()Y@&talzs)1~K48-&`FgL(}D|GbRr(<#l9g7R=nD$&l z-CY{Kjn*(XRKw$UUOXS^#p8<}6g-@SGXErD?K2OGuJOXnr6InvhN){bIHrcTMRc6* ztz-8}9gQyN=#r*mOfv(qtC`44|_ zT?M!Y-?-KYURUONig0hf^7&fsWftziWA?x2+Sl+>&bz?ksppemFRI@qAj^H{vdJBT5xck zMEYonCaf3t2TH7AEm5_}-3=uslp=@uk@pKoWX&ky_gdgNW3v=^dxzX`nwTda)QAx{ z_=mvAwgOfVIe|GIkWpaGB^yN!+Zemm#`w)P(hsrmw5E+J*;xZ$TbQ-mLd94MQzlp_ zP|L#U6caN|6DQV~@EgziA7G-x4<^<EUrWrd?j+H9JnJRTX#nwld=G0I>+u-Yla{PwtBLcy#CZy9 z#x7#ozc}-QIQ*+2bAowRjF_0jT)H`$7+_A;CLXpjr}HpJLzw5uyiex+pf${?bqcFC zDJ4Kh4xoj3lDJY8NPQ-VL-gX3qC)?`v^X3 zf0plEA@(mQWW26$<37jUP{_ft?=BI84;2RU`GcFpXd=fk3YrSl-w?Y=3gtEO(o=;b zOCeP%>~|G5@VRLyOyHPRj>6S<3i}wP(iHA+TxUV9dPR==LToTL`8vpx!9mCm4otS& zQpp#J7|iJ4$7Fuzy+Upu2mfSuFfE;f+xZ;$vhVUw4gxbd*v$LToDS;cb+DInoXPKC zIs1Mpkzzn%Y^!o(jr=9$79M$RV+bND|RTbuu` zaSyURQpm^a9qensJKDLuM^1C zQ=oerfesY}T7I=L^}3BEInE#M@SVNX)iQX+@oR9ENc2D z8vI^*p+$S~tbiAB{XB?noP>@++)&%3>-P7TnuorYdhG=wK=XhaPV)kVjI z6*`;;I=bgEaBQ%FBD)MEKQ)lAh>6L)P4rqxetK*ofb~DMjfJ4m7W{Wu2)+B?+AXvz zYa<^uPLc68Qg+ywa?!?BLH=XiUt3-vt-inyy#!*12{c+HkZG&H(QD*NC9wCKKw?&j ziqv4a10?rRq9|+qj}s)cW#6@XJfjjd^fqEXhB|Q)YxrPSDqf9Xh+4r+{GiRP3CB~RT`-#i=TM8SAyHCWE5Al?hmZnSXF zx08cUVT^X{3wJP;_x0L1XdB8o+7mY|9b9bXu=YE6(c8hjo_sclIP32qKkvu$zWPu; z8{?pA1m7R);NRg6PW;aICOY`c`w=4@l;L&k5ccB64w^Pe_6zFiyeGi=Airv{_AwEmtz8F zJD5G+L1o^@&*Xd49Gqw0E3WG<*BHmPE!VJZn1hO3-y8nV7WU=mKc(-(f9mK!c6Km? zd*;V|ILiMYz&%^Ry=}ogyutWdk8@RV&?A8Bti*pRB8@A#h= zN$o#EAgHOp7(an*rj1bgfI_Ei1n#zReH<|X8yATG_r!m`gBGGUSST}s*a@_-`-O>C zCs_aInHbyM#DxqdGTboWyPY^3&f4#1;L3d+am#fibf<4Gpkts{Ly2t~)_2!1;jHCvfdXdBO;B93O8l_LdjGRfB7w$o~tX>=$<;DARUIe9iv7)YqPRli{qkqU!UB`jZ zI!5o&@!<7$5AblRfn_HR)XhTw-^zqO-9-3#6K_A5IMu*HwH_8`ET;cIV`2IW`kC@J zW{2Adq4p1D?eBlV#vx^6g|EPkq5`WL3;Y@(a5$PZf0Mvx@@C6KfefDowsAj$ib+&! zB=M;kd3dD6rOEV)D_P&^zuR5pzLTe;Sm*2hKrKkj&!^UFL2VdAykDSp?K+G)oada( zdaz|Jb>U8hv#iJKiSInGStCBMHnJu)_{thx)WPl|tX;*43F6w9`M0{MgH~YPF+Wc- zXG4BvZuVvFcXu#~dA*W2YsY+F#=Nh-(7{^bqA&4sHkSC@=^%-5ben@!Y!4oBP+-4< z?Wc)_yTspB2lvl#%wg8kL(J*3%;!rE%3X8tmNDol@p;ohdye&Ih(~;veQPua17C8j zDddee#HZ!p8)K}?mJ#xb7_@o)oH#Zdz{7f<PrM{*CRnhg{=5VwCGI`S^P~>$-zP?n687jb|VCWwV1@+^Yn( z^;dDfxTgcjGcGylDZ}QT-yh*%Fu7z2xg;yk<#Jo{40$zyyctNYjjQb-S2+hW${1=S)uclX{{Ibwr2r3Js~to{$OTpDH-^z$bge@@LN7S& z4fQ}0Ie_{yFa1Fx{XwNAj1dw(?ImV1Kf(I6mK@OKi@=Y>|HpI8?H$bNDFSl_3XEl* zyF~cSFKIb(Y&8s6NT*s0{ zIu<=+{A^$nbwD1j;q)5=J?fcAAqQZ;iO6J=c(sty)i-iK8fg|{{A>*S#YW{Q z8w=;!xO2e9xSKW-KJvPxz!rL>)KLQK$N>jp1&W>#7=M?3fWE4&uf*&c^j(bl-RaN% zkdWlzRn%qW&PWKJNvKPGkR}mLFQ2vAcYWWKemIop`D`kAoqn_`x&O>DYCP)fTe|vx zPOP9-ox_M_{kUDiK?Bz8xIoq-*6_8>nLDh-6Iq|Cux7qz%{s!`SYf<_8LVv!nTM@d z2P-Uh5WdF2X=41%3BGfTn)jrGQpEN01nS&G2fK*DJk0fm#KdbwToEhl(z$3ttbJoF zCGLVVyV#T0MFF|#k37gw9Oco5`bQJ{-! zwOvF8xTs#$MMOgv9V@yR%4b{H7saT>F$Jo-XyEUnd$5a-HC*iHSf8dY9yW6EXB`)3 z;G%MK7dd|6HyXPTeDbpqd^8~j3d_Se8i&Om0dCnKmz(pGG;kBBIF3> z)-FpTk~-kfCW#38f%D@e3JoLv=|%I^r1m8CH)f(!Y@1NnjvH4(p0NkqA6NtpF4315ReC^*N1tF8wq>qXnCUJQKX#pm)GR*(mp-qaBB zg_@$Rj!FDpKXOivqWu0)0~hH-f|Ct+{Y~^8Wg;xrgm`Eoo_?TufQ8Fp7Byw2oMQo(C=YMyz5xl@g&~_UU8+CU zNQC=S3p9|(Lf*YRQQ{c2*beeR*a?ZMJReB%KxT!L^mGPw+%$T;k>vBaeH1>@&+E&n z4YyMB9acC_&;E&?axT4ZFk>Gz{$Xl?>h!sN{aCLmIM_ih@M+?p8+GZ%E)Ir~6Lxi= zCTCla`n4PRAZ#+!&KA=u`!urN~9K~83 z#`=5xEp>Vp)>YQi|FF@DHS}-}7wNNn$IA+GLFfD~2IeDAy!azTAY z6tQ=`mWyL--;x`K5bypKTr?%dMiXlZ#G!}ddlUa7N)x-4T!dC;urGTV7x{_tP~tR! zoDsnO)0``sd~tvr(TQV^65}BpdxP`e;M_svjRhQcjn7Z;dojGO$Z^NW2P+u2$q`?R zxcHrXc9%SMg8wyOB7;}$W zGhX7!Qeu3n#G-I|eK7y%{bNc=WK0t%n=EkZBJ2Au=IK0Y*C7H&8VRH?D{$e1jc&wz zG`0R5dj8%0ZPaXLqYrW5$C|I-CeBw___>>f3Nc)s>tbj;*M{ALfHxA!1l zdJjqy`yZ<$p;k~Lrha>h(7uVV_9mjDUlMu@OTv{aNtmABgWeGyRKMXtatSY%4)dbx zzh0Eftf3|~#q&4~v&aS0Yw6G&H|Sv3LKj)pyC9cToBk{3RFoISXoe_Fwf*~o{vqfuzjdRr{5)BksrQo zqlUXg9dTVEEA_(0_Ywzv721|n7)6~IO5gC7e1D^nSNK=KkNi=TT5<&={E0g_#QpQRBDU5DeNPc+@n9e%X|!@pU6SaTA8}E zP7T(m#txFHTa#OpC+N@J9@NRyv!@1A8_?H3p&w6)qz53kyr8!jIEporeB;Ny;?dvz z_9w=rzo;wdIl2-bGpU&kYUUp69Mq&HX+!NC!~W~M?#*@^`DrTsdt=`JLo7X8&F|Bz z9OivZ@|VwCdYU;7YO%hS;vC6;(^qr8F&wAZme}KCCQw&VCtYHVj^sb44smd;Cw&QhRQ7NOn>uk!2-i-n^`3jOy&CtT zG}l{^{(}3Iz92DAPX7E^;k8F$5_MbdTlDp(6ngAY_(CtYi=GZ^6iU+9cU_|J*JyR?zdEch zB_#R~-{qKJRZj|p?iA>~P@v;zdirpI!c7GHOADOLDPX>`QSgS1(pznGnQ5acJ@3le zHr}PTp&1snhJ_3C_2ys;k3%i2EMZ~$7ZdWj3HKip-3OY;1rx=;8Yq2-_=z?!G~B@I zLI!qwbo>th0RR6an0K5FXCKAq84@Bo5hc21MOm^+bk0x7Dj@`6l_;x4Cu($}w?ywD zQC5i(tGCsATZHH=Vax4x=FYt5{p645^W436`aI{H@7XfzUZBt57a0Hf3k>!>$J)f_ z$Qbk-^NK%5j_c1*X#6uAtosa~y?TmHYoDTj%ct1ye1g#no*?HJPjK+YW4s#s7^=i$ zygvC4E}wai!wG4a{Wc9RyQRbBPe;DK8OZ)V195FKu{0$Up|TDf+U&p>+kyH+oN(N8 z;*$<8)L-X9u&f&u2f5MXu^Wdgc`$I12W6gm(5tZ*`KEd?*z_V#v=0jw`VhYELv(pR z77p?waL$j7Z~W-pI)GbK0*HAU!1y9T#0(4KR$>tU1cSI)B82keLU_I|gs8L-vK9*C z^`J2NZVzM1yD)a@24dP9C^ynT&Ep0hKQ^EhH{oh-;^xmLCjM?B!ENH-+!4I(9KrU< z5j;8)!RPNI*i+WR!3Gu@&9IPdriEU~7G|bc*!_`>D_`2k+1JL2X*M<{+vs-9#(2X< zt8ALoEvZR#j3!6oG+EqPlhg^C>>01g%q5z%S))m%oto_XQIACGEN^i65zCAjfxel}!Fw$*Yx0 z3T#x;cc+r_dz9omtfT?w?@lUN{+E(Y=akGprKI3BCB7R~TDhb?C()+a%lXIR2N_O5-((pQu%VTuDsU$a#Iq0&Ic_)URuaXHH`1cwmS(YoQ|ErS0yymgfl$;)|Wc4H^{f6;+eo!*( zJ0;n^<^45Na)I~#W3-aGRh8WNl-uW3qI4yr3{9rHG^zYrlbjDUS;w*Ps3ukZ(&XJn zO&+b##GaK1W(#W@IE?%7yp{*e#u1JX(mc` zGf}Cqi50I6e6rWT@M#8iH8SvHw1FYF!}x1?7&Ci?ajsezE#HOkY- zAbvj*MCXA)46GGI-(UdS_6N|oX8<)~0$BFIk8ErFm{r4%lMWxQuJggs$%pdPj_er< zhm(7JSXS7NuHF3Ta@>zZ6~Ot90o0ryz~R>c$R|N$^bDfkT0Rpyh+pGE7_d5o!~cZP ztYjF2+lFy`Z5Ustgt0%$z=2K%VwV{hbKO9$k4@aEW}@g=6F+V?G5NKLw1N@zq0Zk; zh~Utk2<|N~E5CJVmPWc^TTni}s;eOnteS)QcH&dZw2d#cH?_nKtSret?+B}rV%Wxr7JWfN*D zj(UryHWQRsUBJI>U~aKy66WSWwYq= z%g4GLETYTbMRob1f-a6&T}IW@rA~ca1~k*9bQ4{ioU@89tvl$_qP;GIyXmsOw=Nk! z=n}(`JV=)woPYUIm-Pd6**Apy4b$bqa9vD(|9Yq{od)QVliMZq)n!UgUEc5*1$yaH zyQ3~ajsk6TsTikAFP>{>OI@n)ygQofvbnJ?1$jLWcwI&fUEWsGrG9x`mX^|GKCgQW zum2uLGfkHq5hZ`Ql{|c_M1T07=e(n*Y)Mj5Em6twO-dHhKRPVpy-%mFj8)zX)@Ycgq%Cg(P5;-0HX^@*A!_u_XQ zG#OK06RDv|3g7K|O_T6-8!PtM827V{>78s8{oKX}xw#f@SeTkyQ@*yZJDT zy0>%sk=)LY9S8jw9`K{`Hvz0z6+pwZ0A`e;7mf>}(H}v4=?$V!^$yTn8nO`!e^&C|SX* zKC_s)MxC!?R)5R9yn9;7IA-f*=JBQXN}f~SV@-O6(&czQT~r}mmXy(DOG#>~sxE<= zx-4qJxs@(0<8>)TJv#d9(vy0vI*!_(sEcO`_nWHA*7>@un5|3GUv)`erpvN5y1ZCN z?fy>9{h>>vL|u+<)1}NoU25&r<-l&9XOAv-_R?GUxjsK1%VN%spLF?S484c`l7(K9gV))Q-m$3%J?R@B z<121Qk62I7ilR>(qmL~r%xll9%WPej6pPQvq2wHW;VFHgJfG2gGRJ$eOh58X_N__= zkbUO!nXa2aA04F47@}<4d|)AYk%b!FEnF;b zq3#D3j@;lH+ZI7^SOm)&krh6QV9f&)Da%dt=x$UD81R$IP+y zVeIQ2MxJ6}7%xJoyEBC9LqjN2JcNnwf>^hTdWZ{RvM+$+I|Hbk5WwS)190v4eK;4z)( z%6+dooG8=8g`^`c^dfJJpX0{4w{EoR?7^eoJQz{l3+FH|>b~)!NCO{+lU=sF^kG*= zKMJq)V-YjIc7p&`{SrW)TLD}s9mLY!LDV}GM2FNM(wl{_a#RRyZ-=lsUl?6Rgz?M9 zFs#%taug(I4Krag{%tX`SPv5|SD9%4!o-5C5yW+fpyQ7bk zYhl0`3s06?_=fMXvtglf9UB_G{vF@*fO9t5MQkLH7iUz{#1pGYS{qG$g)kz?fsQ(=eW;|KTGaSTCb$)4sOGI zzrr2ESQ*?QnRCDl0)RMPwdUDg)R<;HP=PX7KOe|x}VtlrK{-=)hg`oe7b#uFZ|BYmL> zN1YYATwbM14W73qeWBw*U8?`0%fGy)I~+&p1#$F(#v^zh^2CEq+@AMf(*yF-&tmHG zob|#Ipja?=0MY0kZ;j3Lr+?$mQU7%#; z3?(nvE1YD5GVR$}$OWHPQS#<9{+>n2*B(tqKiA|f-`l4rHQ9YglS1n?*~)iXhrWJ` zOxL5aCW9(z5?@%8ksoW)|EY~rXKloh2gb1XW#?M?^Fte>&so^K)xz7poNHLkYL1#=xu+2J*8XxYmU6YpXCk zMZ);-SqMLE4k4pM2w#>C;mDOBPRi~TqjhUH%A~sBo$5kD2^V6LotWCeiQ zSr<7_x}pP{mt>-3QU;2&OvjDp>F7Zo_ubaNvn#f^@YJ=nsYf9{nB|Mc==cA^(qOZ$*#xDQ<}_|UGDA2%2Kk$Tq;U(*0G zM+Y$BS^xvJASQGVqS{twz9)#-av{_nAHvQ*L#UNM41Zi0E%=;bAMtq=HW1ayK$Q&! z{zx{kDW8e`^-W}%X`=X56P@z1$20f0{T#s{zK;!0BFGkuV18{24SQQ?z>YWUf`x_T zy2DX6F2>s!%lF$oiCxfXqe%fxZboS`pou2IR%HBs?Cqm9sj!q@z@EAIAa&0S8BWe$ zK*k(pX;LO9`LiUo&-E71{(6^dZvofg^-)Sr%;&mXs^p{X^niWT{8=T7E-A^8s^mjv zTX{d3*GCWdNSD+3b$LWaZq2+mtC7(;>O+?#^7L4;_VLcTxTyJ;ypN-e@Xpsrw&tBGxMq0#I3pvqfR?f_s#xdC!p?|9%bfpUUY$6POW?B1K(2nmH77- zYW~?pW-#Y5H^~t6fhc}1#eJjq>k`lX1{~L=D48Li-cXTjkmXNZrf(u!&};URF{<

    H^-)t@e&jt$WpY79UBbNo zG;&Wu9(o0zi#xz)OAknX$&7zOKV>&+Mi2P#FC~R{EBRxYlF!KjGk&5k3|G>tyOQZ$ z*bC|^d0CN6z#dkf9?&jblOtrc*H<<9=By?!*a@Dj(xl=PO$HCr zFR4j^kd1v$*aXL_u}OY-J$^{H0Mw!Y{&^FCQ6Y$0^tt3) zL98tn!mh7EIJGo{EO$b1Mu!pZ6-J3eVH666vGhv=HOT#;-3D5}HV`grVnSyVJK6OQ zy*F{GLIi7>{iSC`@Zw+ut{2Syk1SMg%d8(q=1;P4^pS;od2Jjd)6E`X;{m(=ujKv( zUK>L{VJEE2j>vVeo9kf^^*>>(CV8p<0_!ySiMg>WS(8o=HSw|MC!3mln1hVZ?Dw#T z&TOG%@z+W=^iwj2+`ozX-@<;MYx95qqx*kurCuTDlWE;Al(gr%zCrzG%c@JsT;$&3 z)M^P`+D7a06}8Zk`CqOfdo**>O}+e1hFOT_ zzuv#`SmgCN%(0u&eBJy^;4WDB~yR&hN|4= z4)wl~{t?T4?sMcLKisDe)FxAuqW+7J33BmVA5;I0nfoP*BP0 zY)V|2nw&^w-m?c>BLl>3;rm^wN#akMtnS0_zR{#1dq5Q5|E^-}3AT+o_ibF?VIz7e zJ0W{O-7+>xQvZc6TKIK^h0ps~co=PAZWgYw%Mlb@AHj))2vqY3(z5XLX%h`5nuuy? zVt7^)-aG87%M1+ZXrM?g1G`hg*t8;y<_Teh%7?Lp4A5tJ2phVDuq<~7HSPvcW_A#3 z>IKn-3{ZJ<0Grwda9R(b=uYxKdHQpo4~5CshraURmB)*_i@jJ{-HSoDJt#5JgEs5| z;Zts8Ywt$6w=TS2;zGkp>;dwav?A3&$c0R;C2P=VQhphXb<*!hp82a#ASge{{(@Er|d-@6dr zG!En5*f28alasA5-qJU}9%EqM83Sd*2HM1$_@Ep4e=oD&Z(>mO2=ILbcj&|UsQ>nF z$YGyah^79=jkoaEUJGA5v2g2S8z-yVNE~J(d996<3+(@X8ofnqWbZG`taw89|K^M)RUT+kkNJNmz-_p;F0l8<*HCigE9Ort<~`S7?IC3PIb>0; z%~xxfTiXYkNXi$=s~}aqq68%wy_cIXm&7+SCQvco=

    +!f*tB>e?=6;mppD$ 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 GG{rag*62t8 literal 786640 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 ymKb&g#MbA9mVF z|Jpmr4&TU8-2XT3GO5}CG{6N-%J1cW@)AuhJ@V+%@D_`4vzoT>aLHBmSPRR?&zUzhmcRTn1 z)$sufCmZt_-ZPI_)diUI1Ai;A*=cq61(LxXiu1J|Fj` zXoEU2Ycq%61q+x=ZJuWT|H-EbcX~@^_WShl0A_&y?twY%{SQuo=bfe2*$Z;B-&ei^ zCx9D4(+B*RM`V8TW|V!;Z7`16fZl&K8?J8}`vWsY6L5yuGH?&-<3Bo>`k%fLL+fD_08tH$i#)lLP$K@AVNha{nmE(TAs zCwd=d|Fw4PPTvi>(92%d_sLZKg|9043M&>n@O8#}Tf?YnGw@-3Y1Fb7j{1ApQGdW{ z9H*JoAlRfY{8`3u|F87NNp&_m%e{&VcObaGO~`?O4?4Ajn=Yrgsk#Mu(cni{9moLW z{=do0OSe3{^bp?(f1@{8s<*ly@>a#3*&0R9U$&3j&m}p^0RK;B{|{Q0tw+DI6fqMF z0Q|4V>`Z-%$3>vs-1vK$Zh z=T8K@_z0C95TTLW{|j1$>sp6!#iWL*_X+U79$`vJAphe`sM1@({l)*sWp{`^HV;uj z`(QaP3RZErKefpKcE|rKANs%GJ!pS=-~j^nXV8fNIn)i%>PYgx(EndB^Oy4@Kkdi= z^LwVRM&6+R_a+1UgOA2q`lvOxzbtS37Y;Ccjq}$0-}HVonIAiNX&(B&<@@pf0smX> z4Clw(L&;@5)X~;mJLlr%hX2zbYxM>0!kDv$i{YkE}sDKX8#|6J87maF44w$2} z+Rld?TE7+bxM(SpmwCJ%(m+Ajc>X>vR4eyV~^p}~A+RU6;fcby#QaGoL z@BsP*{tp(la3WcB?ElTtr+j$9?$5n?SslJ!$*;I^6Auu)EcT5uD61jfe}%aLxRLXF z1kcaqXx_m9*VjW2_>b8*o*CZ;zyE9O0sHv=bo{_t;0p={=#d*dAeQV8aJ9E!>n|_Z zsK9O;-CDqXo&H~O3iEe+xVP2ly?OBePDj@lk485Xj;}K}yLa65sr!|D8ea#qW5<7d z1RgNo`ojsB&s(sEcc3i0zy$tY(JQ^(%pPU5ghv%ljFsd~7 zzrO7MDXSgTE|v^XG8@{wG^r2#-Cduv4ei^o2@nNaBsHP`cl@2G*b9lu=#wZfy9lg_e!gHIEntuZ)px%@|Gb#{Y8`I^eR=ntDG<_eMqO z(yvH-oFbKLQY3i=k@BVg-x(Fb-6Wj(G@N}dT+8tPDR(hUHSzywlMyPrbD`SV0S$0s zh*I(YSko*-)?V=b=i>p8oBRLWAk`g?1{nYUQjY?)cxWJaOMoU`#RIfSfKCVaOZ)Kt z#Q$%&r=J#^`)OxEKka?utBa$3bv>`I&YZ#juM7Ks1iRNoZ#6-Cv4Z-4blyupyL;(S zhNlXiqxO5@(-7tX-r=F+t;qkv!)eS~I6&zCw)nW|_$oI|Zp011-&LWj@c!i8UlZs8 z&)7wyYq;o%le0=LgBM=cS+mjq?M46dyRVb(;2T%&HU5zs`E)bs5c~f^2S+v7?x=J1 z9n~_3eRCT(z#c}`EM(N-*W95tI>--QT7@zW>f-|M2MlmfcYBp9f*#lehRqEybUFS% z{S7+Lep@UB@9*dA0Eg-MQ<(j`a0_G>j^qxQ!d>jY3?K(EfDs#QRgV5|2L{lM{lEQZ zcy$3bvO`yI#{PebUOQ$H`~GaWKnwqu|2=^>;B6iBcNO?HmyMD$!R@Kr2M+XjdU-Ds zn!gwSy9b_S5BSIaUxm8&qwZHR1MKImu;gBFf?44Q|4u`2z7O<&Gd@3gQws4}{*SvM z^F?XinhMS6`SAYMPQ#ygqm8U@(EA z_9`@=95(dW)ym-eagh4Yan#7!CT(#ssaH!U6}v{J6a2rS^#Ae2@%=pw2e6$hxUwtW z3T_&b!=0F$@fGyrKkV2c!T)BK^wLWBe}@Nq>k;?oL1<8H;h@)P1OKOOj&_6nFP*>~ zP$@?{UBLYoW-IAm7CM?Nbx6rnq1Bn1nv;Qw)blQjQRqH3I={yQX+<$~@9{{MXX z|NDFK+QI$*VI}x~-2aQMi_`mJaVq%|4e)q;0O1KwXp(f`r^qwxP&dN52+T87CC?r-@c zp~_!3RCD}7WVVI;&)Oks^*&f{C*l8@i1+X5Ae|W+B#)ng8h$ZQkzE3HECt`6qv(IC z2Pn=T?*BG_GTr?(<+Y#oO!1Rrwy&bk`D#A?-&wz?{j)yW){al8x8|N__8N!}P#V79 zR$%{a(f;87bA1;X06jdlfcZaTtA`pk@=!4}+?UwpTGVn!>*6K{^#4(Hng7xMg~0v2 z#@-k8+=c957nRL}55P-j?Osj>XdP$S`k)m%=%fq7@&7E~q_6ak*DFl=P5qbp?x=A_ zM~&a>sM#$Ybr1f}hqcU{z3`kUjuyxo|Br3tQH;i$p8d2kdupRIV1WJX)xSF4m3Ua* zga6Y3KATy0Fs*vrw!yh;!gnve*G`$#|Je@s-ct{csEZm-+{YiG|2s&%Y~ubm79a4Y zXn+3Ns9qGl8ub5YYTx!OJpcW0Y}ewuH5=J0-C0#$hz*#Fc1;OWVp-Y5jW zUOTjV%=5MWn*rGCyPgIM1mjENuWRtR#P`>M4|I10`{T#$<2|_b5+0Bv8NY#e2}Pk5 zNCp##Mn}xY^*0;?v;TCx5)Evb9k+|7yJE4WRz}SUPI)S3E%HnAFJ8gq9Xe_ZGa4()fO{=Upx0qHMe$ zy<5Qly^j7L{IA(}H*IBS{7{AbPwKy@Ihb-;FTH(){;wC@bM)s2eds@n(V_Or)?_e$ z!%lL4%yYD%W{yt4|A{rn`{#F-4zI~lZ}LBif&V?g|F`(24BaoCp^2B$b&30*vlITG zqtaCN2fp7|Q?;s9sw#Q0_b*9NPO%iNxSgzH6OtA1F-Zq+C#m<4B-Q?ysL3Z2^^5xN z@0g&+;Qz-;!2iMjr~ATq{iFYT*@OQtjZ^2MaSDA9tFNQT|1yhJIQU=HxiKnE{Rh3p z1AKb4Y>Gtd`!({vrbNl-Yor3Nm{t&8x;D0lEhU$52h_Wm~^q~&^pK$+stq+!2UUWb&gH&K3GlzEZO{Nmk^gha z8_b0JYqXbwkH7(>{+omU&)Hh<3;^pkgvz8s8 zL|wQ*+^`qj;+ADWUmI`Gti}dy00VHbvs2kq=-oHjX~{6~@78eOxra3htzbZF^ZPa~vCqDl0 zf7v0n@rLwZmUz$ppPa-@!HzMxBDe!TSFz4ueFNbiQva6Mz#zaUqO-sQOOW}~miNn? zo_~y+KljaGZX6dg@BufoW8b3ZFSFCdM|Rp1W+!{_(Yhn}z1m{H2MX`+&j!WGUXL&0 z|NosCpbI$5L9|wJ4l2_aALe!Vf1}6rZr~_4D?D2Anv}4f%y#@62ls==X@jO4e%GsG z`$t zt=BEG<<~Gr54i!hLHk$Gj2qxfvVVqV>w8?5YR${iKk9$}#!S`zm7%;_GSs+Ch5|3b z|LvNtdA4c#H8@RwKc|xGjs~zvs`^v^-4~MsME!qzn5?bS@Bsgkq-tlAw6j|he6mEH zXa8SUFHuEo6V!bg89;yIb&UN#auyjt<CKf`Js%RwEI<~(y%;SW z7o$rBsQ;JI+A|@4yTY8lVY>0@S!zXaqnt!mK)$sJM9{2r|=ebdS3(| zjHLhNfGoH}KF(2FU0Q=5Ff%~D&bIg#;+gXS4p10cfY*5Ivu6)w4shSaygwDZZwNfQ zcI*T7!R6@91-aF|;091V7;i87KZ}DZ*jwuYwY>)({{lX5sP&(`2h({6c7XHmX9lRq zesGz4-^>7JfA)dC>;Spx`I%sV=d_`9qb8c8K<*BAxIdg-jQ;1ejZXT& z`DItRO8-xw|F4`)j*%65A9nwBF?jxE!Eq>Ur(+%M)PF5Iz*BTkXOXf)Fjxz`SVOq~H>CgXcT~Sm{Q1np|33)c z7Q5UQTPM9_zFU6AS!J8y`|^ytFFCOL?zyUaZ#S(-aFf>>@?y>KkibjUY9`*Y70H=- z@1?}C;7`o|v-mp9;p?z*=WHG9n!~*x{m(@Fe{1LHhACSw=79^)|MRo|Cltt1gAx#=EDf!3;70f8qOgI#s3Gr0QHG*x#}g_`NBr>5;4l^O9Ao zK(bb${|o5N9*{u(=N`EK@c-OR2^zg1L7|25|9=biNB=ifiC2a9ar!+E{%=WefEVoj zGh-E4kqm%0F|wJ%><|9uY8$OQBcpXBGfH31M`_(KZUAYKiaQahGaVzkRYS4h`zjYI(s2d$^F>_5(40n1pGh#=fM77cB{Wq(EiP3{=d)uf2@F?o|6AF zr>n1=f582@?4v#dxdEhcdqICutFO0mXW;v}+Div2dGUMhsXtpi)xIG&KwA$b&A_*z zq=&|t+;tBwcV+Oucvm+yhyTBY{l84GtCF_h0SN!^yseAIE+YT09BQXISurR&E$5FSzms|A1WA>v_v6t|j9BKfMsr%N<7JJ$ItAY9D<;_{g?(uOM zoZrLf6Q1x6CE!;=?Z4o?S_Xa*1CC(<=dY|AGr%Wsz=C)nHnr2>F=&4F*=e*1|KHzm zp?Mph&NFB<_mcl3=`6#eu$L|l!QF~OaVb{3Q2b!U-QC^Y-QB%7#oZy<>?XU}Y}|e0 zt`zt8*Y|$NLoc_5mhAjz=FE{L9&i8(8r8kCk!%Kbfc(t<>{uhv{(kt1-$GmRR}Z*o zMw-k2e_ytoag|3=xEo8D-MHU8=?SL`O=pp2Zkl-?uXj9O+T5^eD)WEWNAUl9kp2A@ z{C^|ff0aCS*PZbx=rm3Hn5yr)Q&kQB z-zxSLeV>tn{v$=khsg>X2KVPiivu9m-?Sd|IdX7*iHEV zqvQ2k@py&bic{7Q=Kn%*GCYe_-^pkI=>PBV|2Pl+|GG$wMn2^B*AMTH6uTbmv&*Hu zU7m?iiar=6hXzrq5EZGB+ak#Y=l&lNp(E=el+iFkw`0OJ{8YFCyM*fw^}k_PnC?>l z$2~&Ti2gr>{I3Ewe7{D9sLGpQ4FUga0seRF-yq$i{$Jq#XSW9`a!sHbm&F6r5&u8> ze^jXe-GAV(+~j|({^2JR`+qe1fA17u)j5LprwQI4(RhDR|IQtJ)HoPD#vDAr@c(bZ z{eQqRFS*o#tKs6Q{%C*iJ9x_T0sOxa9x{KnsqAf=o(zZom!Evcr|xP6|G!BUIG@!2 zwngN>*R(1#%uU0txp7-_)8wyc{-0P>YJx>KYg)7{#;kc)%~~{o{9gz1Khc#Ogaa_M z1Mk3l7xesiPEB*s{btOb`S1fuFlil_bi2{?rwZHy-SMj2ZBzz4KwA-Vfc)^X00Y>L z1~3pFfE|vjo0Xmi?se~wK|3eW`v%hw>w^XU02_~l8+V?1*@P}&2E6&v;O6WA&Xv#z z!U6ae>8QnCj&gY7sKbZh-7bV1IEebA_G3F!r!DEtV1S$G&#$Q40iWUWfCEI($G6eX zk8%tAjhes6o>R}&isFl`QKKWXzdn1Y&tf0d>yG{x&Tr4vIXX5y zM=KlWkcF15(v!0_UA& zdk5`g&f2x`N0ho!|IWX02gr$3rBjjmy=|oS2f+I|6rls~{~Je!tLScg|9ge2R!*2U zZbA1`H%wD}L-l@js47+<|MzK#s?Uc5P&h;(r-PN)Iav0OL23y9H@!!YQt|!?2mk9v z{%1Fr06aqiw5oi7rdgQ%+5a1U@`HQer$hbx^gO{=o%Z``U?28?e|^Z2^iltoKHALw z|6`FiH&<`Pu>V)tf=@GAjaW3>?vp%Knfd=8_W!5jJ=BHz_qu0O*d+L!dEo$D#QS?A z-k&YpRob1o9}U>u&Q`^JbkoEuaDRG`4FyKr@HP2=(=6&-$D*ldfVMs~tJiF}WaZ5o z!ws?cA=t8cmgcP58zn~O3s@L?ay_k|tp1>dXe`EWK;%&Ito+#lxuF?HOu>8_iW zwkG%Y65Nkp(SqJ{$M@34%@vFY&1k=No~oCOmVAkq#?{9A*UwwsCUf^gf3iQxM`up^ z=pr1S7qxOUiVUC%gLCw~R1SAy=KtQ=dK#0ZPh-&lCufp%p9!9pp|#sG)azI9zia8r z*B1RB{NJg)()1xdRUbCv|5FYOz?r?D`~T_$^wK{p|W<7x({;b`=VZQu$@zf5oEI&=RSD<&mmdFH&xgBXnY7gf>(o z2hafbe>V7E^>8KP{nZxlk7A|C|A713YILZo6bO~+WC$G95Sb$3{q6`>nfk#B41xD^ zAV~F^2BGr`RP_8nbWQMnuLf`*4A9_D{@@+{dOyrxq;WoMIT&HR6^5_!NmaQ`Cs+`nW8*l$p$c?P)+fD>4Y zyI^hu-l6zpQU9O+#sg>ryt$cRe;vUA*r!eG0M%2db2zqPSK0Ls{Ld5o*kXF|XzC9P z(7g$syS4EIV^)6w4loqVt~OZSd*=P6d==%^x8nM1Inn>0K0zx02KebF_dzg$0C0dD zD_kFTgx%nW*XjR#->?I)2bBAYCV;O?yeqCXsek7GU%>rZ?Sl6U_Gff~4-m>-kT<}w zDmZ2bzUcq|T!i;W|DT)9L?#I?LLKga;=!R_yuNnYXH|7y7?1Ru8CK`tuLiG0?}-2V!&tIaVh&SF+#JG@-) zlj{b*WBpO~yV6#2LGgd!bKrm4T@#wxR5Zh;UiAOg_(wKp|96A`lTpfBKcC?-h5pA8 z|IZ&0K3cyD|Bss4TFL$Y5*a|}$K)uWLXKX(VD=vc2Ph*;so;MP>HpqqGL=#m4e%47nE5}@B}L;Vr>IXMc!1Z){_RQq+mlp#a}r*v zNos9KB!>wO5dI%$uO(>Izy!Sp|10%49zG%(zMye-So;s zSwp!2=J8O#4Vy0YwV}sA^UwUhXqmeXF#qSXSoIzch;vP?dY1;MjccSJ`%L*+NoPa2w4iyJ_RAhM-5xGEPnfb0lzr;od69Q^Zp>;RGf;zj?+ z#2ju?95;YsKjHt~GU~<*qgKEJn)i*m2hWb$PNvNqXY?S>`t%det3YzVsQ=U40jh(8 zogBqJ%pKroA+mwfoK)Boubk`L0rxv8Z9Y7jet3j21BCp-Jslj-;QGINyUs9wZ^dJa z{=bW_c;0}b)MfMb{5{pd14>YzA6~04_90d=K=&-~cUO!2^a9SdyLK1GwKd z?gWE9nFW{$-h%h_r|#Vf;x)hw(1Lm5?~;!C0`6bC5#ApB`d`O@HPHVZ&a!_ni?s6R zUCM<2Q`Si(!7KU>;ooHk}sJ8R-% zXFUe{YoCbsR}*v;OW2=+jS6J0`fZX)%bEYf-kZ?M;rV@r+y5IEts2Puf5Vko3+^x9 zvpc-s!DI0Kbivn=`Ty~GH|5l~%J-yI74d=D@rpN~7ds-e;`hTI=)B31_4JgTT-l4| zy;btHx0-?f_Xq!*pWvg=y=Z|-WvhKPc7M2k=lbO6UZETXy(Ir{Xtv_1{|Ym+R2%$1 z0shbPJem5qJ43%w|6QM@Yd}Zd00aL2!_$=a2ibq%{~lG*|2d_oF#6w+H_7UGJXytB zCaaHkk~Ysu(y-D=^g8gr35j4(`2Srb^K!HA{vwXX5>X_Gj1EP+h(R?hp5W72ZEzkB4Y;^AIrN zU_Ckv_rF%Kdie)w_m&_Ht%m=nXQ0NfWCzF>$oC^a%SKZBU;S0{y1(K_`Rm3vvcHe{ z$)Oz?Kq& z@o$K^5AH|(mv!)v=NX#{^Zm`pamNdWtmkR&I!pfF(N|WjSOxdL6*}-A+=ZXR0T|~7 zXVy(;>=yOs2JpNq9$@dyip4|f6gR+g=t;H~F{^o`t6JkR_3!U!fkIr=>7i`iZYFb^nm}WN%eRUE$ZQ!`-hE*k40_ z?}eMuAn^utX8uo#2OFgS_pa-tuFNd?x&L)O1((4M-cLGQhLUKWTY`1W!0(H<&jT!^ z1~-vWZMl_#{kMcKWekKfUB{>|GmY|aGLmhK=8yVse+8@s%=Iq#-@{`rdP)6n0GB;_ z)fGL0S*|9{eGYI~l$)Yax(07CX|MxwQz%b+CT39P5o4asi1NvMN!b)zSamPe9X>pk<{J6vzHQbyU0t)BoMC z$7w>}IPLivi%vUMC8x(Kt57T%D>3TXGe#BS+5LA$>nQc_9bnh29d;FLW!FQWC}pgS z(zLo!Iu#$OR;wfRs%E4HI!BN{AECbFe`dIat1bE8fn~#$b~j7~=7ni-@h}~{i|Q9^f_2I_NMG>&ne%Iq7Bc@Im>4McPXQ`-H$d%%2k4L7 z0qRcv=Wi4I;TZa9-#I_c2mfypPVZmst5fyC{{zWh+UBG34e|ap;r&0$8y{qE6%6rG z_#C`H%6q{}CHDjV??meV6Zl^dxSZe0c>I5^^RjU^&Hm}GZ@1j>?sM17TI7IwTeWnz zRWrJw1^dd}|H6$sottveBfe7q0awY4nT`ga1YCe1vmCF{PbP2&sEQvL+OnEkUFE~9 znH+=Wlaqs^Ht)0V)N-`#En=-E9UH9fuznT%dUF06W3ST)g4Qyny$20q?x6?Ebs~2k_7+ zT+>PQK9m2E4EHyH8{A{~zx&|Y?MHvVoB4kpJ9$4mf!aALjy~O*{Xd00U@AD^d1iq5 z>;hrn`@h2vt{wDRlbQ9a@U@w{;5smXSzrP6;rp$9j~*a5GelwjdA`onL)QnkSdU+` zQge7logDRs{=Z@=o`d|pNAG|S`f`f^qby$$%|bo;J^0^q{=E+|$LtHn|DV~vNKJz( z_e2A+h^&vx%s-*zAj18*-3xux9%qez>MZX#XZbcaDrh*s^GD-4DS#4R*(4e zUewh^g`T6sMEi52x2rs_xhjeMf7c$f(%&%uv;TWh|7-Z(zPjP2^4+bP^~?(H;4X_h zevo5qTJen;;Gl>ib+OXITO$Y+xKo2eV*|5l~`pH?UT<8HcIiu^yXG|d=?{x>^S z<*5IN>Zy88|6egW15Xm z;Q#tE|IZzY_s4f?pZX8$7pE~FV^!u}tiB9H|NkvUTTjMlT&Ebli^lh32mW7mqSZXa z4t8!=T3NfwnVI|NMkzo2f2C)nLgq!Pc9}@sB>y+}7dw=r=q_4>Rw-0sD)i@3*D)SNy>H1I%y^|4es! z{o88X_G{rcMD3qy&5Xf((XKb|!gS^iW)A1mXcBmbP6fdWN@E^i_b3>+U97|muxcj$ONMPw}xloi=BmsTc)KY zbV-*V{y)YkX|fkcQ?3W8y4o>S?E>NcvHy3@ZO$^W@Q_UF(T z&B?&~_awLfR?#Y)XxH~m%>K2|0NbKebl(5!|Gh_~jxLPUyo!;!>x%w|{LkPL5xVmr zT)C&<{Ym}j!TV>~=rG;>7^-z-|Lh?9Z%s}J+RPCBLiV2x{BOX4V9jYAtfKZHHQz`6 zXUib9^(FITDg1x>f5apDKK*~j4}bXW=zsh8YkLN~-;?-%{O+fIVch@M_~M)Ft9S8u zu5I+u?b>88Q2&2&{~K1-TdQ5Y{vW4VTFMJPt0%b+eDA3LtS97tOvVGC82leMn~qM# z+p#G5-v)P0T;Q(a@P8gt{|k;D&Y6fLY{H*MSF| zfEVx;qxw!~hHXtQI9j#}!Fbx9;l@49S&cj41;86{h&P}VejuYy;t8?=9n3JeaILuk z6f!7|UinKL^N1{MGxu-z~xwQWK@aSQkZeeI%DNBsza6Z{$;{tdi<_d04N zJvnO>b2ztvt}Xa$>h=wD!1!`-^9#_sbHOEk_nH|Aeh)Q1hFbRn>$}YRFrV7rQ-+@Ot(-@kX@7gY`9DjW256n_8Q{^q-L2jmt~tu{I--o<6~|AQ{vN8fWN<@W#n zkWuyE{&!`r`n(dab+ZXidwf{o{$KKU;U)(!Vm`r&x<|g7bzj6w9|6n-i zxzM5>#{VlTOMm{%*38~H`pNCTZ(O!2?9Wz*7TJpM%+irzS-J=Q-)cdo;@)I{|Kj~y zAw!GKr)yh{blIP#>B=B#|3|8p{*$V&EmO775B<-O6f%#K)pt*_#xzP+$>1aft;Pf3 zmn2!uVE;Q3l~W}V&+!B`8A%3!LxQGWidSNncQ0mnjEEB9*2;Y+k{e~Dyh}xDF52G~ z?EjVWkpFXm?4SN;UT8W$U)vCRK(@cwPc1}gf35Exs!RP(Apf^8 z_5bRHO+&f=Kgfd)(9vCgv;TiD1MUOjKQ7wyp9f7DyZ|#yaA?o~ z&o^m$U6V>j;{kBNsP){hy8nT9bzyb^4`-!-0bH7Z$4yK6TRE`qcLuq>GN}J9e6W`p zs2O-b)JJ1HL1vVICj(z5FZF+mJ>Ukn00%U*XTSnusjZ>Z*q0Lc>3+cXn>V1inOpx& z>iY=T-#YdIaKP?;cn{jpr>WoS?CvL-19CCb&jb%#53XMvY+%Ga{pS6WNBo92mz(RY~BPVeL+@D?Ge)r)1 zW;*L@CnMZZvOnxby=`Yw9*OrV$Xt~$_#-1H)~_2 zh84-wm?IhLT@xP==Kos#(pA+jO=l;h>2%RF9etik9#pF41*fPK{eK|-A3nF}|J?s> zMbZDy(EFPwsfh=;-&XMdu8FGXo`Bag{GWmeI`=YOlPAYZWw--Ai^FFR?QhjMd;?;& zV`{8^f&btBd5ngSjgjF^vN9Y5&FI?LIcZ3s4V?|!aTgcnz8@8k^MWK8$fP6fSvIF8WpO6^#6MYLo^ZnPrwg+ zzfYn4CHu!aGf3Z0gZ(uQ(nBvYKQ;xbF!w75AHwvzvpd#746}#moa|I0srsQ z(NA;f|4ml;>S=2cZDgaO79yNG~(%2Rp!}{ALASa@B9M@B#yGI#t9~1zx(S*J>B} z^>@+QsxGP-Y*NAfChZx67Z~^I{4V6yZvy|vzjjy$BmOYXcznSFehB|>inC78^Sbfb zZ<~tm4H(##qtwD=gSz*{6XbVhfFk$;GXs18Gpolv@W>Tze|wx%6fMn|;qU`$!3!$L z|ArS74j*6@vv-yw_57U7o%7V_60kVlfTk1J&-*bSG@y?&#}{IcZ%I$DLw|q5m!UB` z1M@*X{(2@jL7N(U)nupOttiIs(2n<`Y!_w>`u;w?T=+GOv%vf5|Hf_bkC-`b*~lXa zS*K#0WvGCU!T_T-Uu1qNXwu}VCP4&{Bk%0M4lat=0|p!FA_p{C6E1R}`R=MG zoz3cW6YgJSi&|{N(T0ww%bQ}va{4ACtEw<{Y3H(oJae28Sn3>6|!~5DNDDy zWND*UCK(c$dK{Objq@_Jrf`PFUQE}yX6ZU(OjAYtzxRG8|C{}PQUm-y-BVOyXo}Wk zC#(L!WL>UG28aRvANb#pGD)&=|NFE!QF-bA4X-EYaE}C~y+!+b9`Aqpf0>VQWc$U* zVJhBV;QwL&(EEGDYHJGG-#sxp)By~T{r~f!XeHN<))gVu}wp)dBAHMx%O&mb>- zaexcJ{+~6#6TOiqnGGIf#(Kz7*+UK{o2pO21EiKsHJSfg;P=+6rMp&!TXpml`#<>K zk-Yc-TiujG|tya=kJmcx}UmVMn=F` zyu!Ex-YQFG2zS81O!|8y*t-jPoA=NFTy@l?1Jv$(v;ph@Bk9$t-~i*8{VP;}w?|z^ zG5?$R+E@rr5&m~CzW&n-RAUynSAe-czoUNVEf`mszn8b*VN-lXJM+)?g4@s6%AtPNz12!Rqp1^ddeM;{vY^;xupjEAB-aztmFJ` zFi#(Yve|*M>o}_l+@B9e*^9iLW#-T7;7IaRFB>&A8~#sUlXe_6=~4v#fAw6HJrC`r zpNrNsz?*rMtE$A})6mJRJ%5`O<6zOA8SuEmEUE;*Bi}=C-hOz$;r~>8DEhx}J`>=> zf2G>AZ6BFY%{?_6{C_IA@)h{M?cx9T@8qModna&Q zf23+}82KOL>HR;FwVM5ZRMTYT^-7ZKrX;1+Oj3$xqHe57ggck063-G;d~kxce2VAK zJ6?bGj#vM@@p|$S{qNj3rLh0onE&VYi`9rPG1BE2o$VT<$Nz%=UyjzI*3n=KcFkOY z_is%*9xYMoH9ksz=8cl+d89(eN9tPcNO>^-kDU;~EEvIT6pn8gxj%USgx?R-jmcrm zR-tma7pl%fLUkf7L}lpzZ`y=t5A|PVL$G#~3)brwX#es4UQrhR?^l6pHH9y{|5Go+ z`|l11i2L88OaAmt?to-}g@ga4cf$KC##c=@;QiIuSNWK|sxI2e(WXxqc=H# z4(_V#$PEAuP_EysDiMkY@CG+slbb&0=S~b>yyUP&J4SN{%x#f}KfC04ZU8gM0^|m8 z9UZ^{c;=(0xataX=QVhMf4~ELjuv1+6>b3uspt%ooNB-Yj6nnN1P#DC_E&H~ zukuDsiK73%a8~6F&T29YE&y|H3b(H&)Il4tu!>*+Rk@1|g9p%?S^0Va-UK*v@mcs~ zaX)jr%q@+3;BNZs9f1Kfp!XNSTjw3`fCWDOHSYg+@ZI7rxONwQVa(?jrl8a9%luCL z=J}J{z~;>B^_cU^I_fHzKpT4e+%nWLv;HdP{1x>7yI_9vDlscGbJQUIx!$}XT_^GD zj%7vw^V>HM9su*jl(YOEkJ0{lp*>D>ly6b;eQU$_Wj^_n{(tO@lQ`hXCkO5?n%|&y z@E)e{wz2zndrj|;<*h5=tOb9-iI|Dz=en~jsq6tYxSh`b-|ep%x4%gAm9OwxF=lcH z>`2}3#s4!7{ckt2{|<8hPa&hF8@`PX%sN`mf?mV|M+z=SKYYLZ$ax!&?km`;0Tbba zMZ0SW{;*lO@QXk1q0Zer)f)W29KN!PDzRfe^w#69c>dh;(Gm900t@h<@ypV;xNNm- z1P2i8ua#4_66R*><}cZr|B(5=S(e@#@&6vc4&a@k+*9fQ@6rBlOIK1gIKWS+{r+jn zOhfy7fZIR%zrW!B4xEsp4cz~Bolcem_}}=DB#qik26$OCK-~Z9EJ{?Za*1lp{$Hmb zJHVTGEjkvjd+qW5FMtR5t2niS|9k60tSX$~2G}uHX&+t$7)1ozg`at&29h)y6K4^eT`Ra}V?>~H3rZN8) zw&49Wire2uFTKCwrF;Fn)G5E0Zrz5nh5qk%{M%05_mCC*uX$bee|NH-neWE7vuPT$ zUOe;v_5SWEMEw^)1L!v$A7JMH!ol2zwz%m+XX^j6MPc{=bv$Q5Q%G(sJ>+6EK5}>A zlP;vE)HJJDC>mgR=HJGF16H8^!2rsh#DjV$en9M`RU=LMg&FnxMCR1r!Ke$N1u`0S zk^1l34R7G8WZ1q#UP=10)EG4DQYO#SC(=k+HG>j9qNJMqJ&H#Qm!H-I<5r!xKk z?9HoUo%E{?b94x^ z1+#>tYm#y%CPCDv7m_t$K|NS|5kQHYisp6!HeR;2z!t+0Y_Lm#R#whd) z#nCx}ZT=Vp_h$$Hy?4kz4l$@@emK8v(EKeTFX0aSANHiV_3-^zZB+7WBYbE6Jg1CRiU&+yB6Z-lFIjVn4A9ca?{Td zS@QZlOVtdS3h0rkOn-9!X2bo-m7%0vc!1SU z*V5-{nnL}rew&KNVyZ^`j{j#Q_kZ+12kHO0|4!C>q5lm`Qo(ij|5i&V>;Q4)$9iV%tX5#(b?M#TGJBKL98}IM6!HOv#tonu^GJ}J(nC!2w zMsj~=1ZtK;po}-U0fPTMC;MX<*&hMF`zzAwhbE65fclTL_^RDpU+$B>csTgTVF}(J z@c-VLy_Go`O?FAJ83WvZ@V}9{ytL(or>dg=`&PR{FZFu+aRnN#orzE>Zu=~uL8FVF)mCWopOzCiE*|KSF(dhb}j+Of;dYy_XJ6#MLdH~=@U*v-y*+r?Qc%Fy@zrS^T%0-oXi2QD^!8h3y; z%*fUF>mT@n+1UXs^!xjG=pAy>z18T1=7FzuL{IZ88Q~S+3Fl+yPNu%CV0`zfRcf=u zes=TaXohBj1%d-)bFV)*9E=cL@G5nk*^xb=9Wy;&7aQ>R*T=tyue{6%UFz`jt-_+3a$MBlKTQVT6aR0na)Ga%f%f+;-@7(@$^QER|9_4f-vcy2 z%zQWL{~MYASK$fM0)0rtM>N2f;EQ#E{};jiZ$0@x-2d`E@mAN);QtSO$T#!R)jO81 z6V$)M9kf5~(lk6JRX)2@RT}=^VfO!b!&6ivCs_whF#9)7)(;c8KdX|os$!A`y~Ou# zN}^g7Nz{@n=>OpVEvNn$T#eVm?(yoCP3Gr`IL+%E$1W4A_xoeDrcJC;GpPO3F)E`N zeMpSfnZwa)-ymAY{q35&&MtdnyW06h>GO1Izc4!h`2T}p-2QV#>L=O18N<2#e+k#- z^XPvDg|pLv|6d4G`z~P`hWAgD_m|aIQ7e3ThkRAb z#@oBbM=MMFXgv3rAI$$l@Mg?(!~384e+>8kFONO78vOqn{QqZ;9%wL`|9|yRX)l|K zZ%6x!$IIz#ck*kv`3xlU1rFdY13Hk&R-I^ORh>*X=>+@#05{!&C+?DMk&XIq$L`p+ zIoWaCk&e6K0|F0lKo9r;cmce*?W$5s-~lmrzAx^o!xs2w@Blw|<}Ki}xz*LA)d#=< zdxKM#M5h)+ZuL2%PQYWe_u+G0$*AmqofX69{MZiefCI?5tPb`?5B!u!7Vs_nu=nDL zIn{tiEVqCPhc`?U~qss;PbcO2G*T}PM6+Ym3^StIBs?W@#yJ6et17HL*9c--hlng27CWNGw>(g zg7p5{UE%cdW?bW+o4b^`Ue$~?ebQ+?bOK8kD@_&-0G|9#tgs#&C`cHk@19*)WKJ7mqF zJ3DrP`xBqTe3Q6EJs{uPkgY-aa}-Yf|4se>$Nk;+Jxl)7|M5CmD)l5&NBU$cC^AFu zW@TvT&veC6|8MdCzV$Fop47jM`u{@xC)MU1!2jbD{GWi&$>37>|20q6N$!7+Taz@G z{eQ#rM6H~fs9}{7Rq{fDc63kBiHvx8(*GR>#%mz>-;MKe@Pgyi68?|Ry;$WRiU#OM zj9ea|{}~Ss_%T{NFGgz{`+rc1U0e2%`_a*^eDP6oSV;db9i>uEk=ijMQscn?mlz}P z5Fq=naD-~o|I^3g{|EnX%WXXW@%}!X7OKebRfYe&e~*MHg6u!vSg`;7!Ajx& zcNhNOxAj4I55ob1|I=|+pgt4~RJ(ftIyg8$S!92%yXr4D_&-;}{M2=qADS{hm5)dN zv&UCC&3)03`Y=2BXmdR@7(U)Qw!&M(YjT@K|95Kv-oF*RRMQ2|wsGWtvj3N{d8p-T zZn^aTHBmOX9>w3Sn+={X-|H7(0C<3xY2>b!DOP>lZq@vOR@Ee1$Bs#G3Wtgjr3v1Kz4+R@(?yJqH6=H5I>E{6LKH%>Rec0gZCe zlWO#(RPunXu&a*87qG2~&kI>qe1cvsgS-yIi=Aj7GZ0QdS+p|W==Ev%fCs~&;Tkdn(b$%?xoZp={q}opEoL^%hUvK0``#x z%q5{`;rY||Yox+o%7?E(J?HTPawywqh5bQrsghAzsI;(C+e150n`EwrLPpGr< z!XWr7w=>9_NCb`vc(Sf<}FQ2(6y|k;2%%}IeqR#}MdAiiBq(Jch z7JToHAJKoos1ji|C4Dd);tYA#Z>KIl&a6aq>@*XqRNBe03|2OZ+Eh? zx&I%wCF$MbB>h!1NyaOQa_yg}Mh=N&+a}1=ocn)lye=MP_iu&ww>?fr>HmQ};?(9- ztgeIqP3{_t|89(mpP}}_|H~yulR<{|r%ANBf&X>eg8x?w{QrWZ^k7Ytx|WEN5BT4l zDUtFmhX*kFzn25a|0vEa;CZ-WhJ5((`6`$OO@ z;r$sHti{~_|AhZ{#ftW4bCC8ngahOls5t7s&xZiDKNp}9T?4csncVM_{#w=9pWeak zZ>pb8m-N%$QN9X*|Ff`+uO^s$6axPDyb1Fc{eKnupKtX4voG-d9OET@^;Fy)vcJZ7 z>UAMc6?zTsw-)YiEBxHU$^Bhx(+D(Pf2X4XqW`C`_eH@0=*|t`*MoR~_M-O7S@q1_ zO@~&yDXAU)uz8pT-02%@E!r}aJdo-Z%?al-wbQJZ6Tt#&naS0|X96u?kwx%MI^a7U z!|nexwLjTK)<*czem1H0b&~?-m~^Kje4x)pRi*yJsQ0Wb@Aogo*5ePHG?bc2hz4N}_$srRdV zrL06dxX@9H_&G0n{C_##6E?Be^Dcz0?-c)fWP2hQr{r&E@&I6|KW?#IPu^2E{P0ObU)6G__G*; z_UD2#KI6`MQU%YHF-A?~_UD=bcbfWda>|4s2E70J{8>-u&zjrI`jW0no9QYC1G#^2 zG$+h9t5AelyW8_Uyk^l>cDm{CJF?Q;@JPe^ITzaBCGOe^{+C1lZ-xFh;FO1|xAj!< zP<*6TdZ{@*=IlK@fWiOvKS6`)h6hN0a)7R)?>U)`zBF4OBX|dHfcp>3R-G?dYJ4qA zWg9aG+|AVSE}24j9=4bTa&IwRnztPCi{OAJir6-{aBu=yuYR@{8fsa`=_YT zPx3#n;QiSwS(VWLl{lQFPj!=Y4gBxW*hCE~n5ciwC#XiB1pNvAH}6)wzJvcy$%s?A zf5`qA9jBOLaq_qb{!jf6`b756?HKL*iyh!Yw06CUR`)K^s-Ixjj$L+r>Sb5ow^5q8 z6%2s>-!LFj%{NDCa+OFedqw@vj*y`yIDlig@=wG2t6I2R;s1S^g!gA=sLEZy_Y?l# zwdfH23;*XuPx61s{)%M(_pBbQRxv>`k^Ps%{(lDie>nahwYmQnIUS%`-2#;G!C%ec z|NYgH`ybx_h1dIOc6C3M38wD1_{!YKSFO-pl*e~zdL19V_V?!3g9BXLTLFs1M zIT!Q7PYT^O{vX{Mcwi3;T5!ntJXHWw9(E}gq>Z0Cw0vi0;QBRw6d?0TDJ3!Mca6j$<=QkMDw7*eD zYx53#q1Q3%{&~t-HNgQU_j8sjbMQuRfW!=g?t~iT_cwQPu=45M@CEEh{glHOfH$DQ zd-8zktuMF*%-YDUZ3A2zdTz6p)E@iy0q%mgi<2WlU#=d+%`Osb&&N?2xB1@}zz9!* z{U7EINKa2%OD{hJr-z>xZ^M{f)cG-bK5vEdKJdTY><9d{$0_a$ydnSTjXO~L5BYW1 z#-cxX%dc69-@ggmzWVg~{$%^Gn^bT{ujEPAPl%JA)iNlqk3oyz{H)?lt96b0MiiQ# z9J0^AKJ45bff5Mpy0S_Gbp4dA0_gc9K~mz;E9A@`iKQeYxFDd%u$P2Jg%13;f^p;D7Jkb#bvx z--^;NZonO5hAf)yskPvLyQ_GsmjMni{{IDCm^}l0$4F{=YMsn@_UVcqA!iS(1i3kON5nU)U=V4R3;0Y);U`1_|083huWp zUS9R%RUjx%mM!T28^y^M6RTl+V|AfUtO|$4sL19Rt!f>kFDYbx9E;YE%F*g#vCBN) zu4z^6>i9HD1E!JxMgMPijqI;MaDVdg4qS_XZxo@EpTo(r3}^2RR~7od_t`LY#`|+- z0N$V5$o*&?ssL~L|Dq7ttA^QXyE9c=#ip8LbU^jA9j|5^5bQ*l3qxN`r8|5KofuUfqF(SyZ4D#89=20W(qaBmqu zd1=H0FOBU?23RVY4dDNix&Lou|F`jdEHD@TKmNa8tmyw2*vL4yX&`U?vHNVd)(@=DPMXb7L#{U-%(51fMM0uG7eEz2cIED_OUNwszGXKxHV^#xh0LPnw zFTaKN1Ku=wIyZopuJ}WtKfi$%eW8oo{&3NeuO(AnZ55YgHL1zxSboXpk(~_nFWRhJK_fm#?KD0 zoEmPhmtIdVU&>sc#x7vy$0bM5^7AJ2JILh zziBdPJJ?@JX>h-u&YHQB-3MNjD}OFWs`EyUqV~`7XBKVLxy~j{`kUE53EfXi7sah` zQC)DC74`6D2aDZ;HfumjvqrBnqj!P-kM^(o9Se6%GJkiuslgAvwpcZa-EZuCcjZmv z7Cak{IQ*aa;D3wScxtzYr}|D~|1adN(zm=-o&I0tA9esVfHlwpw_cX@|M&i`9@+ZM zIa|$lW$Sk9Z1TLaRB(Nk7X8RnvAvn(v}9`0Gv@zZ8LF5J_O~cqtqZ2>c83g1l^$i zcgDqoy~Zo2Q9PR4IGtP#_rGBrSq8C+r~Z9ga09T%kQ*GMT5ZVwN{!ZN>i;MAzsg~D zc`d^Ouz_7CjZrE$D@vmAU&b~o5}_0*9U?6mHK~{ z8ld3)0dn~*Km)`4^@i-74tJCm*0&Dxq7)kBZ|JySE4+_Hf zXQ{U~;?20r;-#rGymXxXKh;WZ6Zrq!ik>>k{XgTNhX(iX&}n!bb8a#NpaD3Q$EHa1 z-c!*4Hv83Go3i2mx>_}NGg|OgR<(&!NzuDcp_9Q@?SRFl5I ztkil|2%-AN031~ z8hzh{Y@K+TEtjj=dN~t5Ft@*h9^`&c$&zan-2auC`Umg7g$FZatCPWumab*P(sex( z?#~*$e~YB)#G_O-8Jw!_2`SpXJ4IW5O_40g=={+C)=1V1=OmSxME*yvB(*x9sA5gg z00t$f=JW)0uF8+W@oKR&UNIH90l3D=b7`ESf5rPhFjg-Qko)s{tg5)jXwA|X`L&Eu z2K~Rs4*dVCL~EFzT@9C_|EYin;G-zjnHr@xKO%MVWu$^9M5=S)NUfv)-|B()H~hbf zSHjg7?=Kg;zsqkA(;mEk_t`>aSQM(|RYO(EFGPRi{nepzh?c($)@J&D%aXzR_#jBn z$AJMB3{u7avj2JoYJGTsO6~|CH$6Zv%>HUb_TN43f6bZyYp?TDL;Amu*;kd8`|2?M zKexeMA8us+YDD&O7aE}Mv01w`G zoBB}ycc6)fGwuKbx*64$`X3D!=(!OM@P59g;RnDB;8V?6R|~?2 zp+34kg(GtSjC>JZfx`@X&=_2x*#C9_&rtS!ck2EjTA;m7x-`cL{+yF6>;OZ#2kzr5 zE-!b1OzwSw=<@vF{=WhXpoWK1=UtiipHtrhF2e2M#~=LMUzfS{@h0@A-Uram@!1Ek z%G%(4>@c-wGxvjQ)_h>Vw+CJmy?;H}-{qNPqVNWOu{neNFeCLvGrgUi$-{`>h)Fr{ zDP}WM70rjZo>Ic#PesNdYN}D=zE2?$HLvank{$0tEoa!Z4JZARZ^wzjmKB|3~3=lBD zXC27^7?!00AdyaCMreby#xLM=GJK1tv*N!nF7NfU3= z`@#R7rY5NQ(gaPam!L@hc&%I?uZDHwRl_?@Iosp(TiZCrQ~!_P{|s(}_fHVsfAs%m zJz}&dGg>3hMJxXIXw`_abCb1eS#`UNucF8-jncS$Q3`X6RGTG{c$!6OCjI}fvH1Uy z{j>QhzF!lsb57L zD(CS691o9#TT=HdxWH$517?|3w7MB@I&RHq0aE9s!%aH+)hLA;6>$eYtG(m`E+8MI5&2+X0A6t2Zai~VpM7ZGm;v5*qyB5c zg~`KBEDUWBGeBAHfftq-RB#YDKr{Su>u?|Z!5tt4-XCv3cW{8-yTIEQlNreV-Gn;4 z#4gYm9AIi`csQT918|=kWn*7w2B`1sC{HUlJ*fe)_ugnF^to4Eh+^@0Dtfss3) z8=N11=6v1`8+fAa16jib;2yABgcpX_TZhbYu*X8YImdgDQ9cQs!g{z0XLy&q$T9kt zx2UK=o~;bYM+EpY#7%vlfcT>41{(+8+Rha+&!4J9=yZ>REObtD>1m1X!zGO(*J+*JKm#X6bbKxOa^B+E% za02fC9Uraf?xR1tXK8r9Yz6+Etsc9<0lEDZE|jfn|70mww=B(Y$<(ponQEStp=%p6 z6i_ik!OzomvM>H0@oBocEKR+NrD^W9RDB$os=6QO`|STOTBm55ce08vOV-sYXaFrq zDz*aekCN>F)W5^PMD5L@{ud_TkC>pX^#4hV;&rrPytcUG{k(ZRr0S zlKtx&quHxtH1m%b6^)D5;oZ@i&HO(k#I6~e?J82wt_3fmw0<=H-(MrO6#ic(_rKBf z{}Gqa{SJsw6S99_oDSD>`hN-dKMTqJOX2>1Gc;7+cZTXJ*?*n^A?mn|{Et@L00V+G zd}}aRPp~S&{~tFiNS)#TJKP9VrBQ+Uf&MoJ{@)nz|9&a{+6Vr>8U5csseY>ax1Y+j z_R~bWuXbOKjGVOlI#!o z+jFV^&wD-esHcavr{GMnIt219Tqvsa}_gl|f^Y0km zquJ#A^6xO|3Om0yTt(`?5dWSJnv(B1mE9lCU&FijocS@saQBbmzY`I*7GCD=!JomS zkL&|2(E82fM#AntG}WkFElhBI$^GK?ccHF}7S3YsNB4K70NBfDv=|T2WjnyrqW<6T zJ<3~z@7H{b^4alm>B-xE%}v2IsQv5kJxZec#rrRRWt%Lg@&2vG?*Gt3Q@H=-^Yzp) zcx4L;cq{&zw??veK0gBg*72CCUH2p9;2^s$<_$$ed5n)|M$cZcWy& z^#6CYlV!D{{a>G?NoCLgnV9{@C*tRkAlsG%6>WnDKvKMZ*%7Z(ZQ}JJDh_`H=Km&f zTAUE8;X7h=rf#f02gm5IEip>!O#Wv^wC*24|Jy8DZIkf-IBM7I4t97e`2URK22d!9 zEX+uC!T)1JwMb3J|0|mNe|_%%z3+spC;Z>*#lp4Y3jV*{!!#)?RPC>a>dDYh)%rI? z74iSN0RI15Ot9LJ|23y+Fj>viJ@>z1=>JZ;2Xbo;)Z5a58ek02(K+b<^MC_Bg8w_l zUulK>(L%jm9@i{rg4Irv4_o4)gemHUa--H)f7xJU&DYdvO7r0{PJtAMG6uYJu7~pPK zT_5VIhU@^dL-7O#11LAf1@8tI<%6g0{Q^GlIul;g=vIrO4UQti228um8l$`i8kLtB z!09s@KyKdcU$Xli#TRrHb1-kfQl@`MIqLaD%}PR?+iEf5j^xFFIpzen)!#^A`NR{JQISXFBowbffk^ zEoJuK$1ZRiosTEECGU8D3K=w(yWbIb3|F=r)Zr4Eh7f~xapyeDj5BVKvmBUvcDp*O z*C)Jx8yMkpkeRZZx(6>g%XVIzRiEQ%Y$98YfH4@&&Y`B&iwD^p|9MK z9)bV=Lau}ZpRYClN76aR$DMXbME_`>s(;}ccdAbza!+&UiML&Ea)=}c{A_t)eBnIF9zDjAa@`+^Le_>!(XXVcZMS-SFhtoM>NYf7@N{ebg-CrS6GCh6^$M3ujqsMS3Z6`ct0XGwzg)=JPbn_c$B zcC9Oo_os!ve|o$c6^++V3);U$aq=r3r>?Kq{V$1Ck?OH(XNdtXjnTs*xHkAjtHK)a zzv}RRpG7Hg5Zs?!QM&$bq$0;e>SDP_jiLT?k756h{{Pc0G=M`m1M;E)1piB-|F8K4 z-@o&C01XLM)oy{J)e)mOc9`|8qtAMF@{4`WWU!0ybya@%pSu55TUfj+;?issHA!jEbfH zA1Ape{=SQL!fVS1A2@3h-p}TuSMFp3Txb5@f#!WQ`*1jccj=AOf0GNqoZRd_`@p^Q z0@Ts|4rqnp(&S+ekd^ztzCYeNSJ(-Fx&3>>Ne7s{;})a2r4Pu}1Mi)FVDcT=$x*kX znA3mKzxSt}OXj3znG3$Lx8F?7Z+i!C5G?-&c){>A{KI+M&RLP4-VFDZUk~X0i@qWs^%JvDJ7yz#|G^twG=rT!)Kz;dSzB)>Oape@|=IOyIp8eO@9ko8TvhRUyJbm zxds=k0yClQriTvGD-H?9J7%<(T=4&14*$0U9+T0Rm^16(JG&bX8v6fEjeTTk#E!2f zUVlqp>)9Ok|LFclywB8*Gw6bt4RUyr`_bQ_D)tN&*g+3aAVY;O!22QlV|z-Px-Cjm z<1eZD>u9Qa_f1vpFDbfpFh%#OrpWA{tSg(7HLXOl>N_XtIQReKVoCTQB+4-g4nWpK zHQ%40E)AIf!{PsLw`*%7_JH*N>t@0Ms1vW<0eJr|i__|caoU~`t6fK9(VW5qjEd3m zLoq5-Cq`raqt#$*w3f7v))XIVe?}DF$0+R#i&PT(|KH8Y0L1^_vTvMCg5>|2L$x0N-#*m;kgI6_C(-|B2I~a=pBec7Hct)GW&D5bje_J8 z8>mfZ19iC-{J#+H|M_VDD+XwDh`(+v^w+vV{yOUErqLuVUSN z)O0yG09Z`BH2D9E@c$}-J_`CkmK zd+0qppkTbf-+h4dag?9`SgQtBhZ7v`u4+5bg!FYMdzU?+54)mW%!+-$0qfum_7Mz# z9a5(`aLD_+DXxf{vZDo93Kw|9IJ0J!=FY)${@WUp8VokcRM@1O?4(nUp#@+@JK<$`jdS2!OZ0=?@Z)ZaCZ`m+-0TbMHF46a#`F%nKd3BNLV0in`uk%g zoK%!rFVLCHKJNOWoF}vSvt@>J#?WKG`*$a*kz3_s|gC^GJ3d%b5Sc{RSl&w7ZgvK6P@D^I8{G1NSfTk^a9P zXXg_9K7-hyv?T9$5nSshX#ex!_etN?VZTXLf=xQx)vRnM%vu=Bj+UQQ^doc}HSqk{ zVUgnv7{F9_UC4CTz5#eZd&2+WPWTz?p-$61_1WR6mfP@=flu=GANv0W_)L4?Guso~ znfbo}_}{p}c+h?Y-^==1qeh_t>W%Mz32*?g|Bov&Wvs|-aLS>cji`TD?*AF={@EPORV-gTyPP-;9LpI{B2JC0 zu{ymnR@17+s+lLc-?=d=S15+e$!HZ>5v^-wqE+Vx`2VOVO)ng!IWFt~!2hp+|ApfJ zSqcCDruoSMg8%#a&u|444Oj8YWPkM!(>wHkdCrDv82*3d?IGI1{4eysk>U7%bN{d5 z{=WnMcLe?4WB5NK=>IQl!~3I5pq|tJ|DG1W-yNVGWUwTab*Em1zD(t7} z4}8g9^OYeddw_rO0GvqwRfPGU{{I{tK!5ldTc3Mt5VP95ir!jh#Jg!a{=bcw;gaG1 z9P)%G?WsIDJhg)!FFQQXS6~1iL#*)f`T38r>Qi>B9-{?6h8Jk7cJ9gs2DsZ~QKv27 z0KM>vF2M{C!yWS2O@)?|2iVe0t$)$~bH8-lX4dyUyj{So{VpbLT*2=750gq~gNNef zs#b?x@w)||ZU`@!p7q^5qt-8jzut{|EGPN(?k?JX15PVkfJuE_^rJl9_HbT~TMe3V z&7hFYcmq!`$iFQQ^*^PkK@)yD!{KpOg}dm3j>4UX6EI}}UK*{)%Vr`IQwELjH>gBDb|Rf!lyip* zzSl0QMXyw)4xZnO(EeEQSFh`;Rm}dY@3I2~Z~4@R`TscDzjzZ~03kEA3I7 z#!igW$Wn32OZ~52##264>FzOlxip5{qZqKCXnordt&{ZsISo;YpB<%(#qj|Nid6j- zk?<+N0Br327e}alnFx)-|9jDba9yYtt`-l%G#mbJGy4CVH$wG#P$+p2A)0g+4q)#P z9U%WZ_z1m!t6;5w|Cg~hNK4y*0h0eS=x87wTY+Gk`2YPCpcYjFRE+$eAM^atnEJ~a zNc}JIQ{l>Z0QmT-9Xo)}Z~(gDy$}os=tm7OK+a_I4x1u7*z`{r`M;~k|EYx*Al6H} zcYy)o1F$*^9`4||kJfvlTldtgI1e?22iOxG;EWvbJ?~rP#U5}^ZL8M618jMpJpeqQ z`89dqh>yN((W#{tb?s)+B5;5uA#Pd(kNo32H$7?Urnzv-nqP-!Ivr22I%XB(wYTtu zNqOO*7+Rb3{u_P(FX0330Rw;w5LVJvw}bHkLK8e`sZm2af@QG_n8PmMJ##?4S=@6S zn0L_xHTyy4eE{`vi(TMx=76aN?V$&_+r^-4RnWtK#W%;Bz1d@DEj{Z@ZY0{EKf%$d zvEAV7_bT&w>h6sdKA;<#fM<9G9Ocg5?xga6^Xn|Iz(1*P?(c;>o#_R_sO$Bu*xOOt z?tjqZH)n@fkGkh$r`m(z*LBk0EyyApO7A}kzR?W02Fsn~w3b@mKu@s+9r6);{hqLc zG~x3fM1PP4o)TZno?h@2=u>90?^{dlkM!s3W1d-AA8Z4@PxX0dAW!rE1^4sFiq^NG zi%u~6559~(iu}Y2-|+wGYt+*NM&*k)>I$=e^^I^W-QZZ#``3o|Tl_9wtZ1@!_BNx{ zVgCO@ZtEnn++U*Iu8gPq5sONFVy}btZ_NjEA4Bnjh7UStzK5zsc<9?$vj0Be8MDSq zU9)+s=2mZYse;EOesfnF_^3Pkzx$_s$bg^^@OS75T%UO@Uu%CAJb&J1D&$e7s*wBF zC3mJ~?R4lvWru3tBJ;0%hT4Uvt2x}C-TBfr`e2$G)Moc@PSxaDsajV&Rj*#9=-7-D zUHz1-sk@VPyfYeL2iZSolQg0b|p`;YkOY1 z%07;l|0ukF(Ee9A7N?TE(Ek69RmBUjn$kU1x4zN)KaEk+^ccD3k5MaE^8Xe_<7W#F z!2ZAIGt{*(W+wM4kioeu*G3{yGuKMm0T zH2))1S@8epi~mP2{69Z{|G(SL(-8hI_}_u;L7GJV@12N1@{;aeo_EG=q!2vxk;srR{O%q#?4@mu2x@^`} zuqJa|&H`S0K@Uw@z6A}+0F&m!1zO?(7Z`73jIGlz~CV+dIsOEz)$=D)A7Lp2kg!+VA&LO@ZIPO;KqmNHlP(}f96C^=2d5X zWEXH~8a%;aXoPyOM{DbhKRy0o;B9R}xRYOSuRj2PKZ#C&{=CBqdiC*S2@M95>x+jd zef;P)PRiK@tu8p;DQ0;G@6YN)pU)k?h_m4tbzhuWp%-u86WLvp@Ecgou3;5t1%1W4 zHS`(Oe}6EC&sUi}{^cx40At{5*v;L)P4Ii>p`%|NgLk}L1`3v{&fDgU@+;shk_9y3sG)-ubrWJ7i9{Q7 z4o|_ZF9qx}-H+Feaq;raf&S-4oZ^SX>3-HYCESVCiIK4?TP#*{UGe_n{=ZcQ{jU}O zkH4d}qkgpP#waykKn6%{^gr&n?Em3(w&rJBHMb{TJ05Uj zJm@Vv)I7qf&WEf@90eb!s8#*k(1dTI{^<|xCEexWWzoGu7DY_8sAD^FV+-IN7ep_4 z*iEI!yXj^@uw`%h|6@GU*f-aMbIvYs$Z3;uOfso%eUs)oT-EX!XTTDARD9}^!L1(R z2~gm$QLm@t4GI?cXF+xYW;lSS(YGwY--=z}f@V7&{;9$Ii!31xB1vDy!m)09NKz`i)JWXBb@tMtw?xQ~G z0Zz>0Zl`vW+0#V~d+7TrpEun^9S;|_7gcDx;iNv_kOVna0tfodzVt* zd)Xr#=1kz%0SCYwsrz3~!5=L28?j)6x$rIJ>$u0=A42Vq*x{`4r|>cHAnW4|zDA|l z?{_lD0oUoyesB#Jg9c|9RH~v29=2rsY=b9dfcuw-?^k8GQ`68=K7jX|1%5T$stO0u zSK3|K;jr&ti4Ri%I*f|=vrIMX#Z|NN!2Rj^7o2Ul|JUJimVnoJ1Af=U1^7MYpzas5 z|3we_A1@@g-9vw_VD``Lr8RrK^r@`3ejoAH*;;Ua9-%j_?V}X>|6RL$G^L;qeHps` zmzmmL=(QGQf2~SEnVNh!Q`OsNYF~sy4JSBc{*2$(-VBYXnW3LI)3v;3x@IP(Y5(Rl z1yxSdk*BHfyzu_cm8yxC+5LA*(a4Boxo%8W0NTGn0ZDieB&k7-ByIG?^LJgMM$}1E zQQrhzoR*-c1+FAHCvL{a2hUX#bk_k5jczvFdy=Rz2|kP5ct0 z`PXBVI4eeja^wGdCt9I1qLsZyw6ZxxY3al$-DCeZ@nNL;jEq!~LXpbE|FbapAHl!F z)%Se3LPvzFbb)Yo5n(Dq|G)ALyFdK@I#T~3?EfZi57C#_AxcC4-*acM9^n7^B{WE5 zcLgac{=a`R|JPX`s6!R;0P_k^8S1|T_}@Qp07w0W{;!(5Z2C_Bf3KZQXA`^?dmO9=9bg3YZvz9YvJo91Jg%GY04Bld zGL7`qo&28UczG!224(;--_$6p24AvjG#J3?QdZ^&cXinhHavm;um#!R@fNwAvgi_f zK%Zt7q!4k{m=Nt%uoHh!<{(-e|9)Cb#`We5qE1PEOYlIJ!JuBf31;H3G7s^;`{pv?oVTr+AM|pNBwtX7gKJ5nfu8M?nwSO+RY*1Zo1OkqU#sI zbaK0^$TD}Wrv8nKtXlU4|F5|oY8d9Bwv#=z=DjCcE-(EoN%r3!Z@HuYFT(u4qzt;> zWj^}05%0er?48dz7u`{tZ;xX$X7pJbM`WW#rN=0>SvoCu$Rd`p8hO9{H&*V04;(8P{*6s3;w^?ywrj{ z&e=R(s$=q$%S!Y>HOT}5=k>WjuQ%93H*$do8m+p%n)>ey7XUqwgT3&oZSLyG8BmuV zz%|&S8YeB9Ivp)Qd$7Qw7L|{3)8RwpgTVz@QNT@mO*LPXMqDWG%6eYZDKI|Rx|<2(FNX^0ypRn z7j-O+XJAh5KwpE_fQ^-%X;8rq_ybWp8*w!=9Cf|pz zrPmQ>E%U(NI|k1W_7~sE;_1OW(`^a6&I`-{J_f~e)}?`cd>+lde-~aKcU|-|+yze> zdL*<{9roj);0^z`G@43!|4e^ZO|D^5(;0aE9))}L4j#&yRo6b;A8gK8n|4S!Vx@;D0}?nz715*B$6XmwBpjelJZs?WIoTyfyohx7O6R z={o$s3)R^@tsvcL13sX+d^B>710TsuWsT2N-mpxap!ct}0L^dNObtQzyR<#te-YsR z^QnDy|0B2K`^)Zs6}$i8)6>`;ko|i)RXgGS4|$iOGuzPq*Go}zQ?l00Pgbv@WPhOj z+llvocxk+U9waJudZM;fUltKP)wI1Yu;s1B}FxX#< z5UpnZ|4;w>wZ;GRKS?`+RHQo@;Ozf=cL%C*-9R<;2~d;O0kSp?P)P2{>@P)YVXWjzqqy7s&g?a?4;f$ zz#pjp5d*;}_*#A*hT~`CT%i7Av%>GK$wTiylbI&v82KJ%b^z@CmQ_dR*PodmPSn;% z=>F_3GQyRpG!VW2X`|}<8Rb+3-rst3|DpIRR3qnS7QA21Tle>He}AvZCOPt^5oB2)JZE z$Gq`TgJ;4$V*zveHQGo2uz$MeXH%h-?Ek>}tJ&fDa0VE_{`$|&RCIB;e~%p6+1;Vx z!5O+eHv{eg^?y1YPt$Zw2})C=#c8s@{U3NE6&-7;Y}r$l>sX53)k)DLW3oI}B?$(OuDsdoT6UfMFXsPdrQ+4y z9H-F}cG1G)dF7LCv(_&+B{hRYxP@9nEF`A-fb7c>kGa;UDZ4pn-AP&K;~ zqT16!G`?hrTrULU9l|+~1s(9+AO&&%@Awv|dsnFaK7sm{6rceI+5eFN?wut-Md1J~ z>F2LAKjHr0_fzd&ep=!1)$bd=@>uMvE@gZ*;<=Cdtn`tiCU{H$zRas_3PlI-3k)Ft zZn8i+cuPgSl_L}%0JK2Go8aY|iLU!R+>U^=D?Q?r<(Po2Xy*{uRLe7L(8Z z!mKHu%<9~UpUr*twdj6(Y=`$7M7ArrU%p0n89Q2a^)TN5Wjy4^Yhm^;58d6y>!b*; z7dT|4OL(it7H@KSZ7PlbPX@2IZq$D6$vzrI@433ALvH=h0CVrxK1Uz0JX6J6W$Ff* zf0foa6jQ*VjW;vkB4ps1mXxnFn4{q4e&nW}O7Q`N6&s=9=xX!vY;{{kuc zdODf^Q!@O7BrQ3Xq|aTGRPJk{-h=&b?vkj=X<+|5+5Lh2^>l;xyV5RW9lO#4<8^6! zyfT}R{hbh}R@=$_Li_VJDOQ)y#;R(MSdD%I=6@_kkB7$Sb5gWk9*b7lKGAaj6@?a@ z{r}J?t;^C@({JtI}+cZ6P?kI??^_)keqpM}{@;)M z-@OAvwH^F_^)d3l+5ctz4FCUpu+qBW{~wL-=Nh=b@PC)E|69M8{O@Lgs!9DX*cCv= zT>zO?{z^mx&*8TA=H zKtcFGli6+O$!b&@ulf97-six+_Ag@(NDmNPik={r-v1?8VeH60Z-58Hy;-uaL91)y zlK~%~YA8E^IA>jT#ZUXBGyZ7sZ0P@wb|ycVdpN8l_&c?^nlr#Dh2GzvodES6O3z-D znIMHuIpgJ6YoYj2g?dPM7hkR7C z3ui#GO|#C}^a3xCyPwbj!2`ZD$XojgdFv$if8RY`dfFZg;0rlmSMdRx=&7T%;Q_vZ z?|se#Z5$W?=f6FiEUu2e3HU4S@p;0Vn=|FKG2&7Cn0jA7H;lZP5gdsR%Ck z4o~1ac*-nw(>ibf|6gYPyk`a*!ymLIct9?)XFW}7y%%2aD0o5O0J9R|0bOy`fK{%l z(wCgDQm(oYL3aHuG(o(+OLjGKu7L->hxh)ki{75Z7i>9L0R8al0(gW(!I5#N-Y=3H zxQ)zU?*E41fw!oqUSI*+bHNjchhu9cH~az|+wIQ!3MTk$GC9Kic%ONoD0lPN@_30+ ztDV6Gyz-&Nr)IzYbdn$Uc+uBR`awTXFq0mi{oRrbcmZ$03hC+deZ*h%8yG)l$Z_ub zeSGX2zs46~m&X~CzZ3rb?a}n{Z<%K@ldOj0dj)>KH@!(3c_w^~|1?D7JDEJ6O?Vt! zH>jQ`_0MdR<0t(8s_3A`fO{N68wDQP;+>0pnT=-7XXf9}_lbUKYyozub6wTUhn$5R z>{)x_!OZtKAlam)%w7}z!k@|0ti7e&$W|xw6YRfXb&LM~n`}3`MTN-yvN$omw@R?pftSUg}w20l`^v%f%td^`Y{`h|VMfP`%B-MyZRNf8n{#zxgNs{y^d0s9nAi1qVzl--rpWHfNdj{HG3o;>k+CgJb*ui>&>Zf zoft+2Xtr>&MZ?r+NtkXH4O8M%`v0+^QZYOLOd&e81P)NH5Y2uPtXczt_02)u9}ZHn zc0ua;2Hr3DU-y=Qn*KRJcdrE~oeZ!u1p?I8mEGS+fBpNL4A2|!e<%5=863dV24Ah2 z?5pnu!2n!+)R7&)yvFE&;_(4FVUu@%`~Xs@ee&8S^+5+r|NqgM9nN|$&4dTomizxZ zT0p1io?71+93UDD@Q8;VQU51Od9a7I>NQxoRzyRn0HpHR@x@yu4xG9_K z;uHGTl}tgj!E0SLqdT)eL044^GXB3ez-d!{3!fJzt%w%5X9&OSbzsy4L0`tM4c}W^ba0rjzTVM~IN4MY7d(f-I zb_Mt2>$Y)zy#mh|7Do0#xIxvxINEUckC@AucgRI~T-g7A#v6gYs0VwJ%!5YxMH=;p zGc$1>IUmmOf525r_cE#FR+BQqP4ce6E@p{YyC$eH`Ov_sS$nN|2oEff{onUwbYUAkRgL37toXYbiF!2y0h z&_{8uHYt~b9dV|dnE6Ky%~TkAfWS-QqVNOwK-xU4)nyj!Rcz!iWRzwKA-@lVos8*6DN8|gwHBqaY zlKT}y-@iUVvBeW~1ML6M9J}gPv8#VXyqxyL>(4gvY8sF3cOSK{ICW2p)z~AkvUiJB z*LUQ8T!~R=KfM2wqcz}UwEpT5&3qB1%Lk+6-#tq9^hlN8NA6FzNVSFkyYXML|Iq)v z#{V<-Q+9td!!@)>xOP7cQ{ly7DpNHKf00mKWB$KbE>sPv|KA%!l!6D?D=XSRJOKPk z2kWl~K`J^qh}~6?&Kd*Nhz!u2<(LED0A5@kAfK86a&cz{m_i0%6@TVnKdl1;JX6C@ zZP)?U-{z}?KYVpRoj&XY_+Ni?KwyA}*v%|p2k zmx{dh)X0;b@>`7-NS->x3~=}cns0ajYya?2)lX=E?%@Xj9#o^PRS|{AgtWVp%Rol- zcy~Oy;R7V12{Pdeav1Npq2vRW!%Nm5P2edvt)9<506yS*_$Gs%nRRTrS%q7Z5s;Ia zz~7`f@KSS+!<)9MNfA-5DtFFRO?eIbx5KwGhpYN|kQI84`)vb!U~sN7&F~2L#QkTZ z7v>Bo%pBmK0Kv|}!)M_yJ@1H3nSZ*aEUU;()d z^a9+$KeuoOu!B3sy__+Ce9;bI0@Q2nmVCY%wONrFp+28);;g-OnHy^1&&S7h6~~Th$pEr8XoTZmF)IL@l@pR+QRu#gFd6ua(avPeEtBvz%#H1KQIUG{+s2% zEc%0AFt_}@6K`W`KR+`~MmD%lW#K$`#^VE>?_}=&HthVLIPgWThR%=L_uT|ng1!H{ ze6DKCxjA418OveJ{`6Fx!TyqNll7a*0}uNuydR%%v#!+OJl^IeC36mNUU$ORJsK?M z=O{Sd9_~8Z*QyC;m;nlS;Co3n4EO)GgPwA&>ZQHxj>=T>)(rZ|&ehrfog{DS7c)P- ze+aKTAMn3`aCAM?d-jf*n%pE)KXbzUbLUK0>d>qb`2IhF^E)&{J-()E_Q`a;Y7Pd# z?yvSLdjAUG|No}qIhv})V1G3(G5@zt(UP!aWvorsr1G2tV1M87{h3fMNei75HE2%6EJoiu$LLZ7xZmDr4dVV^lo6%OeR%(J|2GbeRNu{!I^HQ#V}C~I_{|8_ z9R>%0`hN)jZ_eOw)y^4Cwk!D`)4~*1B1{Dgp`6j7dY(HJ{zr&jt_qP)X|jM{1S{Xv zV4cbvOpaiXnvV!lE<6AN4S`y;kf&fEyZQiSSsWlg>i;_T|0OtpU#t47oEz95Ie^!x z|Eu@_ISDzyLaL0JmxHt-5c#^x_{c zoq-2@@;AHx`<|*Zk1U{;o_hJ+Lqi^*16blg9yGaN+2DV(2bg()EVzDF{PV49{2w3i zrn|P_6P>G>JNyTWil%@cUqlNu+aeP<;6QYNCm*m|Mi;ody_*(%0|R_y)+u^`hoj8; z2p(nUUOIl0*C;dU3wSD-$*$T6C-}kZMe;)D28(z8v2bcz>he{q-Aa#)}x;KlPv4kTZD~yZ^6l z8s6O^8{D5O^l=M^Iqe^#5lo*y9&Z_N_8nT^jGVt}nR5JeDBA2$Af7+HN;-7sR)%7z|NnUZ z{r0BoYzxkTh%|hr(zJ-({~>d#8jMR-(AN|dI+mi0mMM6&lle0n>_309e!rmqAI0v! zP?APk64i2HqJnCW|K*>c@D&M)%aNel_wf8@_dlt;UHj4gPF#-vSM_-PL;pWvE8M?! zXn-qYkWmnel_kJ84TQSwcW)aj#kuAce9{ceE>SR;cH*a*@ z@PEi{tit@3l?W zeF9m5^Z*reu@?vi2RqFf0553dI2W``^Z@0-1V51%97DaE$qWNO3)^T=!fb=i&GU)exIRjqeyK@KK&VJE_ zrzP<7YD=C8Ut6#JV3_yd`B3{AX`ENZUDQuzADqRC=6B~zv*yD4>HNX0=>y$V`L3I) zm9VHExNS{WbUzi`b#5ixu4H!&pKMiM6B)4df3c4})VQjr`Wz+urv}*nRs192k(|B+ z2Z-JB)}1zW=KhbO{vUs84FWGeZosS32?`Mokl{qv`2_lsn08Jw(WbboDb zCFyprB(2X1_y1pfzeXjhTz>MuJQ6f}7T(_}b~zoj>)mL(M&xA=@F1RShIrYk#A}p$ zoO-Q~(}R}q01{%gX;-Wow}{oegc#Wl#^5mq{uc)4XIHc`TSe=7bQB&7X#d(q!OxA< z+qIF3s2?fI54iu}e{;r1C^~BdcU!n_O$%3>()9o2eI?FYhujoPknwsFJ*L(2-WCyt54fFpQJU|Bf$|;Ah=A#1~G|xxX&|yRb;>~i*#(8Da zlk7ay|10W0Z*^}S2q6oYS*~msJORLU58d@t{0vW3s7p3@jE5fY@*szkY|xVMfupSo zWDmGyDSRMV^(YtTK(M>6UM44gCi?*9#=%A0m4PmJ7Q28#BQ08tH-IyIz<6-L+jGGI z+RzIy157r61MD{|qOV!AbDQn0tSsjBh=7EwR3?7zQHFu#Gty*4Jvck zpda)Bv!=rl=wr~iX7GcmQu{d#s!9LdmRVqw5nSM3?s@L!`OM}{`?;ez2P$j?o8#_& zumB&#OwZcU^4!dY9 z|JNRg%>HHIM2s`){#AUwT*3VuMj2|N_nA!J|H4)E3!}3_V^NRYUnwu%rq{ZF7sGhC zm;>Nseg%{HewobHyx@L=&~iV6_g}|d<+sxRN4o3uNbY_YtK8dq=-3qx4KC_QE@-ogG!Y zrY?@x!dmf)%8bKjGfu60kO7t+t2K9GReoBmhP;o_UHbpb@iBV#JzA3vM{8IIvVT8E zsTKRb-yNfLJT6jE=OfWTMru)UG632Ce_I!!pymsN=*q?i9^9E-YZxizXYiVJAm$egV3-Bsp;K7UBw5i zcy6*lTmw{hMu6rQ#1qWwuTAIx>X*k4&bdE04svF_%(}k{{W-e;=c0H}N3aXHYtm5mfo*%>7YH6$ zgdVo{ZFT|l0jUFAHMJ5?GP|x9Xo9vF`TOAq*W=zRKz2YfcmGTLZx6r&Sb$D=Fm+NB zUThI~!_3gVnWY1t7~q+pr{8N(@_Kdw!?<@F!L8^1Ek+%BeB=IqjaOJEdwAx8&GZDX z?^3t)1$7@etI!2z{PWD~&-gs=Uq8mYu$RyA@uHWVRggQr={dAT56~9y=MLN_tJ8`8 zK9CtBf(&nZ{SiOG0!niRH6X(eT(TN-N#4!y6>qZRe+teYjkgzA<`H`Sz3r*@In4Se z*z-Sj(GaxIVc;G+8ldl|2l~j|e~_Jj?cA>a%>Tam?ee*S=l7_1d{?CH@;VMM_chwx> zT8jRs#ndphWB#Aw8mb4(|2M(^k9&sb&hiiq!4p!jiV7cG{Rz8TkpA684cz~oP z1ZpK5fYZGLRrzOtA}&GFO*xPbBW0JGo%JEnNxU+AIX@5u$ciXRNT@N#Xe%KYW7U2sJj!3D~_#9i-u zxoc7}u%l!=fzH7vp|70P4s7W&`SQ2jbd6o$&&J?Q>2LsUvH#;fYS9KPIuG1HaKKwP z-~%n>3}9!~ts-;lfBS%^uByEPE@^p=N-?GH*^wDe%@Zdvy1wV;T$M? z8(ty3el~iE=O*?H^cL}9oD`_WzAD;gHVq*2-9KvSMutfdlk9hmSIgpgsGC z`F}!&W-N5*q_;y|U6}h1J2ZC;Ge9AS&b-LbhG7}1jpxVJ8|kXo2i;$48lKQ;8cXKS z+Gu=#_L2G9AXR^OrD*Ql6m7|uqA53%)j-J_{5nZDPb8_ol61ziODoe0)oI6&@b z0A6$dJ9-CcD?Z>4o&~Du(m>^?iXT8gfPU={(Dcsmf#UpC2`^y3CjR=8Ne0Mid;t6V z=|vvSfoHyoSmdkq^Z->ee8?v8kuRLgP4oaoyuttG+SIe4O%1}l6$y5e(8XI5`8l3u zo?AK=E?_w?^$7FSrF(b-a|W!fjy5oyOu$nf$_5AYacvKEiy#w>Gazmm_%NK{Ja~gN zba&U@IVj=6CJ+7af+_u+WSqYdmhpWd<|*kB|cv)}-)(FL}u##s=@{C^4zaEw{k z+nY765c5EgN%@!qc5O51<#2q0%9vCR9DCpcbS!_n>f#7jjcbZ$2xmYaGrX4z_=VyV z(0u?o7t}=fcRWI<5d--6Z|=;No2i${_~dkbUbt{1|_{P=*1y+1?<_k zvm>xhfG^OU{Xk>huVT<<&Vo;Q*uVe!&o2bdFtuBo^Wb+Zo*c{z-pubUsB14~`RhT> z^5-e)kCun`kA>6c^ZQ4=VXyy*dp{o;y~XhCD`LRo(V*%4J5K%SJ7yTPaRWIf7x|nI z9_HYE)4BU+HFeQt@V*c9F-tD|&)5G~qziudMqO@?Kl)T2`k#N8g=$7~7M6C^o=L7M zaLAS1BDjC0z*8omwLZu951!RzdVlLAvr01iZ{zIE+RRN=_x+dE=0>)iMcuZ80VLu3 z*V|p4&Vu87bJy0ba6L27e)T{LM*kmM+EeG@h*`ga6VLQg?ih3<=t%mor_HB2l=4|*twH@%=(fS`i_fsoFTfNg2wUfPn({v3m zrD*}!pSgG%xhD91jZ9TAy1#ZeQ}nH83g6FU)!dt`kmkus4nps<0nhJ-N$L-kV-|7>=xx$NKxAnU?3xH=xd-k}=4F;sEQLdil5k=LFOwQe6G zPdvaLoeox0G(ekEg0$#NkOqtj(zzn&fyeP;(N|MG_^A9nX0b6o+LPZ$C*5p{Uk_KKxlP++ z@B%sKtw8jE!`S1Nd*!7{i_rqK_EKeb0hP_3`oLMA&>1cud!MQoJ=BgK;6Zctfniql zq5kJ@ujt`j;b7JG*V4BRHT{2HP4@S$+Ri*%dy}g|XS-^0 zcRWMjxEuou=nw8S9gR@wG2DaT0j*0JH9p-%Qv;a=uDi%@2l}98=!KXC>VpZ?FO6Q- zVbB~e>XBai`dRLL&VUX(*tM-9Q)3P@0ocIpR_qMR(-%}^CNGWVHa~p>vq9f?==7=m zN6ZKlO!i0Uvu3jdqW>FVa6Oqvo@Hr~jw!`uJ!3 zk<|Snyb89#@8v8Smx+!!FSCAa_L}&5^&Ah5$@x|Gfs49^!Et(v-k1Mh@191Tn29&) zPNNQhhrWjIdxGBo>wH%-_gr<8^YUg56FG%w{;rvHD8Z!HXnrFnoAuy1+TZW&0Ghk0 z5%qr=Y-U4yd|TEt10d~JW5d6R34>F>blNZbVFj!vd z`4a!{-rfp+PA^##50K+FO>)@4>utKf2tF`={*@X#^mYqAKZ_lDJlvrMh1vVrGE{FH z+`lpzav;aIy~6$9J4LU-{uk~@*6=pT zT7vGc^sXc=YRv2(o2ae(6ZNcJqC7q%DA!GV|Hrcfd~er<%XST$YS)&sWPd-2*XMEZ zDo_F*P(YlvuZ`1!=5e|aAFENDV#&}!2OJoqasS}|+llPYm}t$~M*TOB*3|SURXHD} zM}J1C?vF@Syp8sEGCP1Wk-B4yknbvXfK?)t7C`Rr`fwF&7p{9gVY2TGQ()^bncs%W zj0foKp78%a=2Ogj+*#E*HRjd@G`+_Pe8pb_hWpE>B)MSjeu}{h=w1y!yOpf*Qi@N+aj>Hdw$cxPTQs zJ2h6@BApyp~a0z2Ukf-bO1lDiV|jLeBP@ckIHft&#yqVWhh zfk)sJ_JME$3#7a0(>*tpT+HjPHhBT5W=*|oR>&55fe~cU;SX>-!=$~pOuD_vq=YFZ zRsIhL`0A?Z9_#{6l4Y^fRcAY*6)1*x_!}d*9bSRwjoLe#vjA?u$?8V!DS`){gZ|kA zt;~J)=G);3&2r)FASaJL;94OU{qdPQH<3QTo4LS+IRI?n$#H|m(+eCO0|wvQplslB zE(`h$7Q@2{xmjWrDN0z2r*$3EAkpJ0~A&d0Ct`T5lPlwR!i zdKlDr02t(-e0)3^#{3)Yju;ewgSo@RIY3VmTh2wrn)5aPiRbY`{5+1}b$)}7aqrKe zuW13^zor*8KbPGnd(iXF_@&ba^#b#+58toPdH51=C)$-T=_q%9=M!M6!6rQ|X;u+> ztjQPf`$L1#zAoqRJU69-$4sh(c5{(MS?^mEo*fRyJa^81ca5uV)umll1>yZs7Vp2N z_wa+|{twszPxPawj!*H@34eT~29Pc9?EU{f^OvvLwC9seb-vgXvBak7AIR~A<}B|1gPo&DdybCG(5{%>>cNWHipq3}g`e^!GB=oK!vzrr=Q zH6GyLf2;O^0g?fj{d*{RZ1n!ULsjTUh%#=6Xw{$)4a**)&bNcfya?8X!og_ogLIJk zkF6Mlzh$7V?F*Dsd;EaY0yOMw06z5rIzSd^B3aZ{OjA9#^I8rB<4_D`F}-)2WM18&BDdI09Ong_h`r}I`aUQWyZ_0kb= zz1s>(0+J!yH>#*v~6RVExqxOeeHMg==9`E4; zySS^&0cHUFqr%t+?oYR%JHuCUo<)?4}vsX4O897tJEP z=sTE|4i-?(kD2un+Taav)_a?@4_;78BtD^cT@|>&RTGD!7jEvV9J$cB!Fen8!l){H zjaoQ|Ubr(mL1uwIh0zWt!jWMf82$)s09?=y?woNLe3~X?3Rb{Nfcy3$T!E}S?}Nbv zpTW65h+c3mJ;79iY7eEJ`;o6n{Z^(gxYwTEpf&YMT`%S7)RcaKk4@}Cjdy0h$lF$a z{l)tQcsqzcgEJ$(c|81mLG$tRp!Q2|M~`$9eIm90I{`g^c6OLGT(qbMXVh3YeXE#T z?z-q5d;SUZGcVb52D9&s0`ExQ#k^17|1;L84Ep|eJ;+d^H~RI6T;+7IKX8+|Gss$d zY?9-hN%57b|B-O7ssHl${T&DUTLvF%13!l)cs8ZcpBW#5)fRR~13=Cjc+Qq;%yv8J z>q4!%EwKN~9{L6T@Ai+UHofuG-u}$~FT7-Eg`dm=Z+J-XOLoIE4}oJAY9j-O?Ae5L z6?bH47Pa5Ii9;95I8?xn-iN)wi$628h4UfwSh_m*NLSkr_Y?VFG*Fs zI;nc$lcIvFnfn{0C^a})3)XS>mr7O}biX53C6T|KB!Blrwc47f9E}pSFD^mlE+r_4 z{(s$PJNipB|C8)`RNbyc!DN1|i)W__|KAiRf9n59X*2*~c>k}B)%7~D$_NGf1OL0+ zF-DKz|MWW)t(IN!|Nj=Hb@2bEq5t{&zx$v3uPMy`UaRvfCIcPZz#O?5EYphqHC3@f2Uw|UKOmY_<)>c2WY|v zxYz)=fbYowyc(!BGXpgWFVL#q0qV3NK#!|%4g~t^!XAHJL<{8eksSbe0IB!^g_dR( z2=Z0GYj}c;@>M?gz=1}*m^cH9vYSn#Kg)iWv$-d^VBi2-J>diH^Va@$WCMQnA`{e0 zou{(fX^J;sI$p2mJk=XMz}uRhIvGVa2(N>ZBk%@fANc75o)fK?_<;66*PXVPc-0FxD88_t26JIM`#8{kvXRil4V4}RGbPLF{T9$p6@e;K&IG=r*);5?Xu&&XJ^hbNIaFq@q{b9_H)y9K}J z%U^g8Qsdi~;zz{C&hh!BaFI72X4iNMUNZZ=Q!l{ynD;j)(_gUT|IvnBsN>B1`yax43Pb1140NOO|1wl|UV|eU;VJ_=|7V>{ zs(8Spl4IEeyJ5bbVpwFOnb3?=5^^aKB^A$@%*|U4@zb0~V%{p^>K9%>G{N z{TCG=^UIW?o}-!nzoYfLo~*>d=zcRN>&w+7h5wnPJl_-b`Z}K9gYf;zlBmDn{@tIE zpx(vE{td?W^N3rnc5ZcvidWWs@w(MHUPrUVE0O#Ez;u_^=VbqXBTl*d$7y@6IBj|n ztNugb0OyZYia7?a&=^&26r)-}(PWTBs}A#jC0CR(A0hj@OO#^J|0SP|R1Ek367oNa zJ;VP4{?Gd|Z~&sw{cgYm2c+65Qrr9mrB zkY|rhAa6Hb_a!+G+~{7}gC9IgcF0Ok^%_mRbnw)UQp^RvJn&NYP=Uwv0^F;=A45mH zjGfwK58YuV_?`NDPCqc<6SIC8vw(@a{W-OJk~#e}ej>Z+@2TN|)V2YvzC8WGU~2s? zXTxj$eq{mwzK&U*kGl$np>3R5i!*s@JiSb9p@Zb^|7RnpVj^+{60Plb?;fBFEoX2ivl@er??{o)l+E?$@Y@cx4Tx23d8UXf^j z!T;(NBmdJLE9c5srPhzt80P=hTVr&;eT;Udqy0nwJ7qw$lJmj?Aph?#{68w;|C7}Z z@85-yI$AoCJi`cO!vF79hX}Pz3Re|8z$|_6|9pr3=T4Zqj3WoUOqdiFs-S713M(3_ z`T-&O2?zL7tq`q%16XBiutM9y0mcXH7(Sp!2apGnF9_edKy8BqFc~kv*yI3ZClB~u zivTHefUX(+l?gwvtySOyMfs6^jUN!1AjXXNf`$8P44y#MYy0Y5w2u<@`Di43;2K$d zG#+l&dH7nNdNQxQajN=Fryh)V>NogYIly%DpLM9f-{iaf?$BS6cFlql`1?#a0nNY# zlWZzH!zM8Jx6{7L(?{3CK3cBsE5>o?ukm3v_Gn*Q+lz zYD9aq?7taxiv8An=7F5td*#8sP7g4s2z|htRD7?%1M)Es>^urD9-M3;eZbuADc!d^=iwEBxa}^Z{^>8gkdSh-a2aM~g&{ zQKGME-;{FCOd)Jp9|*SzYCtqbJ0?J8u6OIctH1t-vtCQa^Sh8)hDm0% zzY6#FvsqU=T6FI`8BXwipR>Dt&+c!3JUiS0?ET<+UV9DCYp9L?0~~NTVO_V`HJSRq z!Tdke;n0hEPWj#d|8GaVqXAlp?)Rnx->H$_sxd1~yH;}lN0IH}o31R({e>2$>rB&h z-F%y-{@{M8HOTvb^FMwaUf(rSwJa9AeOKA00ZnB zrJUsdZMzhyD+43dDt9EhYWDwA@&2wu{!eJQhSC40G{FNbmir$Mz)pC8)XyEJtan4T zXe>N{0-?%g3Q-(6!2VT2_??Ue&7u_F4?YEcmsAE zMD9~naGwM)0A_&P^KE2f*rZJ81egI%?Dx{+sa`4yFR&Hdkpl@arQs{)g8FbX&pnl8&A#)7!WCku$)S%TLz{QvY{$@TNvgd!ZKU+kgt)PL2k;OzB1bhV0y?iGf23pOwVT);~0R`p<4 z|AIN6Iv+wkd)xxIyG`ccGycts{2}VSu7Mt(GhlWkntkSa58l@fOyPtd_0Rhoq~KBb zPm&H+y{JcIbTK6~h6S-kw}d+Ne4PX#UHEa3l> z*TgySnt7%$y-$0C!r}VH?S&iVK=YpsoWI@wG8SiZW|o6j{h+-`)u))`X7;Zi%9%?2 z52WYXb_gv-f?1Jm(EYNb9m}r9*x0JCd#!4eiqAWH-5KdX9q5ls^QNd*?D#z>}PfRE4a}TqB zmn7A7Cu-l$MEp7uRW=TO~=T&fKJ zXXu|UO)TnCVo;o>ZH`l(8gVM)8>`A&Vs*Pltd2*+|Jxj+9}QwuEG}B9-2bcEMXMP6 zzvt(o)NN>#hLwoYTuY>C%m(|f!v4=MLh-BN0Je&dXKFaQu5hIf4OiXb;cD%T2hg%G zr8EfBhG=p?w!{BvO%5nNz@7Gns9?7cu=ik1JQu9@eaQpP#w_qCNEN2R1tHMw1Qwr3y;{r6}wGeKX2N^mb)Gm#@ie_YGqiPsW( zfqnGLo8ZgQ2RyAu|6C3oF?ia{f56%TJhYN~w-Wd6<-Oo-%mcp<;Vz~Zs0H` z0`%dz$=S%y-OQN~PtRVJ{-Dfv_yV8d?0*B}%j2PF-v5?=FI$ivgO7VjtsnUJKdlkE zq%8CqWj%DV4%i-N%zD1|Ab1I**-b|6gO>nrX;zenZhZ8RGpDEQ?XnxA$@5j#c@jf&Z;C=_1m^5n?I?LTA z)p&{T>UVa4V6JtSnYGh`Hv`yTwLkG}zDjmOR;%LJ*?f4+?ys1a?oY$(!2-8~882Wq z_y1LPzx4m@=mTGb+LgHn`9I8xVHKQed)g__l6Xwb#{+=cZwL3c0Q;U$sYt3BrK7#j`k-a~&K?!ibaT(Io@qVg$^hnj2_bEDjE=4)}rf7Yp6pg)to*6^&IG{r}#zG0I&oMrFLC z6^{OYLak_>iHSlh8>P4CfA--2_xFWJEgpaeF#4bLyAfJ9E<&A||2Mh96}c%~d+`8V zfd|m9yJ0FcB}{$j|65q8{gt6=*CbTS-~g>!6Qa80fNrGzU*iMTi~1i>C|H;82Pt(T z{eQ6_J$2#(0taX)Szrx5u=l$Ypkma2rWyen8bKZqen79$0(s&GmhXw5)-UqYD!9PU zzxuKVMF&JKK(q3`I%ma~X%pUz?a&4MLmuEYZ?&92Zew9@#f3XH>I6F+xEzV}0OR8w zdi%hkjm!W=n{md!wR4u()$A|0K>hIu&HO))@T(ih3WFP3BEL;zQ@r%y5nj=I@r)kj zrCL=u2j~HAo#FK~&Wg5zJefCS%U=Trm=50z9IylR-wh1v-U<9CCgMZKPWnSmbOMpQ zR!^AN&zkhJj|uN*_SK@)}A zgT4b?^CCHD^fehX8ptv?$l1l9!Q&0`JHX$A`9FVV|6kRp`;*a6vNx&s8t!C$lPc5u z_dQ4cy4|E_|C-eH53@2+|Mi~1!z@Ve4554y< zFO3`q2lP1EpPy~|z-!=-5c&Y_|9l4>c<1B)zX~4tPp4Lo_g2##;Qnw-7BN>&E}tgV zOjqyi>AJ8!9ZxcLe{IrrW~^wq|ivn_j_w=8*g%Ly|vqkH}Ct`uDqzqA3)jVodfoWFds%9m_m5iAqd^vr0$>4&`HgzR&g;4zzYETQ z(bPoac5sEOmKE@bmwL#>e6V!_clHc0MBY9c@xR=i-GlMs(iIxRl1G+<6$rd`u)}p_WViA85ukk27f6BKUc0! zWF0WGEL_CAzaC$o$DU}U=>fizg;XC;??G^(RvPrjNds9`czk3<+t-})a3Vg+;C^%2 zojxjM(wB*Nd(-!CHk!2f3%dUrX5AUj-sOT>S>E9J)zqS@+sJN7x9CAFGTrBs?;J?| z*Ywhw)n3Z$BLAhlP0Qxl^cT-{VktWrHFj-&Z6+o2ChLkc6)uscVIHY^H#=3UO5^qK ziPnEpiWap>(ZuLvFu7#qZwtGN4{#i%j-zxwF^zO{(PHyPdU`6zkzj?$u^WPd$@`@1MoIci5L zBsfAxwnWH){^t@N!1vFED{*|du4kkE;Q-d5{;#kD_$NJ7RnP!=lLMGHTd2O`1J-AH zi1t?w(V)0smE9Js8;yh6SqI5{GDw-)2H_ir{{I}<-;_X2Cl4SzCO|{B2IzF#0L5hZ zpC6cYj=z$t;|rAHr}T?(frt1}<75Mq3sR6=keqmel=)09%L5;U;|sd04xGS5Z%xIs zX?1UJoh{Dn28S~iKA>-3r*7upEC@jtblIUbv+xM0M@9fUpUuy~0^kI$ZfKW@9-z4m zF5o5`9DMQu>e}S-FFv7Qfkl`b9W%X@5q&`JPxyq1W}yth{5?ICcV8 z`WW%cF=|P6GHnvjyWGVyWVb=H;JC5Pbl>K<0^_ zTGNM|9PZc+)jjoC8?s?{d3F|#{Z8P=1#zUt!ffKHR zPsG1nrLOPI1*_+bcsPf1fjfQaO6CUc_3m5v8hgMI&Uoni5qg4i_;!QsXXT6u1bfWq zWR6Jjkelob&oQVGc)$BO zyMFqgRqRA!ILj@SoUwDBpuzk_HXG+} z`9l`fdu!2>=2kEWavegg3aQ|wEQ`T(;QkJ)1@2G%KYRlB3m(|_+2q7=|F>%FP^O&@ zHDG5va~Av&xFmJhDeYZ_?hn7&R&Sk({%@|2PLsV$x_)b&t~({ul|L>`(YM(5%}mo+ zaQ}T*Qq^-fS-;s*RsLm)?DJFf9_+7R5VgM|S=r(JY_h-S&L^A2n z{MJlVls9_6zY{dRCfq-`KgN@Ie}etLLi;!9O1uI`#H(2Ocx|(}G;5_xUpl*#`$wFv zQ~$ zM}_KcsZdpi2YeeZ&{Lh!1APnD*~h^eJtkQFa|i2hOOUdX2Rarl@PqI`6~qs`2wLE^ zp90k9Oo09z6CiWG0JU)XYr|H5rL^*g3*)b~FZ?uRnIAbDej4@=mEC!|sg2GyhI$?y}dA2`VS?ne26jZOk1jQ}S(laqcQf3;$#nEOLanv&71%GJ$UKF+Lf zNAYA!GHYsWvf9vP6m(jYxjO!Bv%qKWq2b`U+SSxcg8O$7e#ibcHhD7VS$sI>YlHo) z1Otl3BZ~d-$&<{7x$%=&gbw(VQw4{6%eWpd&=uqXpb4&V0uAqlH2G#tSC3410i~v? z?wvH%S)PU;XPT}Cr>YdV--u?Z>f^@i>p+S^y2AbYo~)Df{?U_?6;y@(-#1D7RwXHG zlO*MPpQvYt61AWw_#eB!BM%a^WlVy;7bf@D|K?tj*G zmjb7N|JQTjdkW|GOq_lVj*~TKoF=@C)ph3o97ST)#5YD)=EkU8r5KHLMr-=&Xk~96 zt+79%^zn3*0@?p%DFpsU{hO9Y>ca1lS{D+bmxm(Mx@&}LW{ps{C*kbn@Bt|puHHdm z>amR+fQDhJK@MQO>)ii?LbbafUf?f7)ObsXwssFu>z~1T@gf*(mMp*m^kRCD zE>;fG#JE89-3bq{Qy_bq06n`BfWHx*Ace^U3-MRaHU4Ui7GPUuxIi!cv~rc7+%5cc z`j@Y|+0g{z3-+XeuV$y=%Z4w&!O1?_SH?&E@C7Kk6x~K=Zw=x3GQ4!+I}9hdqf?a% zIQ11A@aQ3jiuB{0&j&Y{U0|-OcI|=#KBb+V>@B=PL*ay9u_^p7_&_afDp<}Y*FSg! zusd3|2wp&IFTKs|h3*Y*@OG0zTfrk9H1P zL3)4!>;o>CsQrs3y@D5%xt~dK%mG7x8u4#}8*m+6D`!B}kzigejQTwfd^hUC{*oSm zGvESeKm=#NQsx0)W`PZ#JazOvyEM)KU1K+RiJYvxaOXJ#3e8||*cm+$Je$87d+IWE zx!|XV+9$Io_y9jA4PFk93U21~bozc5K78@ibf|}hP}gmI=;JMTj?h00q}F5X)IR6L z18V*2I}eG^o%e~nBEIJ0Z+xx7?Dg31RRrUkH4Oa{wcma{v&vca{m(tM(MEo6jHhbm z|{~YxH^(}F_L;rt1U!2;5|5^9PYF;b&e~~fDv61{A zkjgp#L@W2sXuZP!XKnFlefEe_xoL0!>qlw)XK=qGU;y1Bwd-euZWtoa!{Gs3E<#m& z!WFzXTseA%YsZ%`%_j%ECq7_RD}*VNJyiD>h3Y0cfNS5;|H1>lKMO3dbqM->asXBb z%ho1XMKT6!FMeRB;Q@}z1`g;5RGwvlGT{lDB`!d|M+4Mvc!2i*KnqMJK%SZYGSdST zL=V{JID9~S!R~ZG6Y#}X@h|WOT;{7!@PXST;tR?y@b)AhZ7S-c&sXpS0=Inw7houS zpn~{=jh*9Eoa$2kf(Bj4MaSm=1#&B zSi>C7-2HHlr~1){FX_Pkpbfi3-d3(pzD`B*HES`8H}%w9{(WazX7nPSa`E;!y+g4A z@bmJ4F_tE?pb}X;Rp27=vCmpCXLN+a%UxfSN7#5zO@ye$lECz9-%B@f%@~ILkI%B`2N#(=&FT@2VIzkzHtk2}Z5oYLtcFLr9uYFVOj% zruM(@HK{>@367Up&K72sTw>PBE95b_$oZ{fk>aS_0#lQQmS?wNX7Rem3mB}cS%v(;k+$^ z=Eo~pE$RJ>G))d+Q)~!Nc(fe(K|JOWTn^IjeoTKlb?9!*QF8Yo*c=`1HZR5y1rw4eB@6WtgMU@~2 zfcyVC{J*$rF^cet)hUas5$-rCUyYVn}@4SDmg%BnEm_W1(-2R>mP@z)xuECZ5k>=T8KO^(*KVP(SpKg z0$v8|`@CR{X$TJZHb|xeLE73cNQ-lk3yvS?%@t^Y+68KAN&p!`cmegt6A(X;zL)&9 zeTu(A>-uZ?2R}WA3s?X>z-HkM_!Axg^`C#HFW&vWI-E-HzsE;c2Y>_Q_0f6ufGwEW z2BHaCQN~+}a>CPdYF{^}Hs^CH06x$JaDeTLd9K@{4f>8J$YZ=h(Sf#v6OgF_SRg)O zNq1~2z7m~qdz*3;z%MAtO9k$Fk$;AVR6Q^D@>UJETJ>`;K0)vTuQjpi_Gj{@f-QP_ z+MG0e)5^vyq}QU9IkrKzi$%maPs1=dG;D$>hS z$<*K4Gh}EThdaz{u#4LK-k+Tz`+^}o;S)4KUrhaPqd(Z*l|Rcwgjn4F#s;1KIPm7ni*<_f-s{0!~l zJynO=cV~mwPy>FGsQ)4OA5ArA%Nnx0ZX3w;H7Fl*&Mo@>80MbKQ`m{_z}x38Z=;z5 zsQ;OL;80Wlv7vCNi-GfV_vfEt)+V&qq^nf zoGH5c9Iek^$>=qcRXH?CH8*qr4@i=uNRl2>|BDvl`(GzfC(;sh`Y8B+-vq76i}v5w ztrvUUTHV^MBX8pI#ew(JG@d+Tmj>N((f_#AvLf1_m^f|TjqaycoQC9y)0_YL|7EeN zSd080=Km?%V-$q`_X7T3&G+N~-7i{m^GB;Q6v>&v|`?VBB@iuJlOvjfN0ig&}6g#|AGUy z#}AqYzlOmD?Ee5g0B3-ee6YIdzRGmgS5HUzYD*bkbz~Rl+<+FK8|T1h zH~=rbb!<0#+kxKT#^^VL+2ybc@EhvX(c(_Iq8<8p#i91|9IDmSp?9yy3w>%=;8tD- z1L1@6x@hs5UBDxog4hRy_GKn0Z__XEz){!m2%-n5MNj$oU%bKWRuyF*uyz8TVdMsM z%VyQ#5R3laV^PH^_|L%&s{0yWS~P-fmz#B{7g?fJ%&M5ptn$pVGq1u8W+xCahWWOJ zNtS%vci>%Jc>S0EkMlkgpNoEQhB*iF*Jd`(%J~pO29_6?z!ihq@5dX9Uf?;k^;<*E zgrWu&{{hE_N9$Cybs^{o;17PLA8;P#Okh4ZzL9&MTD`+v{X6GE&AH_5%;J2Q=qZ2x zK6E~s+?mwsvjw=oIJ6MYu@M$my{1y?A8z1Dj0n z)QUU?eW__sZO*1|4ZtzM_zQsX4?YBLaf>-W*q}RK;Wy-k*TdcKI~;xFYOwyp=z9%D z9ZiBC^&ejfjHJ*klfH3Y-py&&^}6J*fv0rXP6nIZ%q(Eh#I6>&cNX1x$^6gWzYTkT zkKv0#Epnj=r~l8e)S=e?4h2#F zbsjo3p|rQm+#}wd*aKWA7xWkWT`>Od)7kTn=HBm@rnVK+m=9BBKLgLdW2(%#QdQ6^ zMLYhc_A95z2i!k#U$QQ@OjfaXzBP>hq_6+6UE$rGErH3C(0`aJ%A-aCb0h& zjS}D!lJ|KD{C|>LUrV}`AsozaVZ8k7#cM>IORZ0m_ca_2U>TRn_~7}oB2H@>$LZMT zSlzu5t9K(~75p1}zN%=ai6@8bVO|9=PkFNXX7%(_T@ z=pL!u86wr-d4!hW0hClKLa|1A|JCpSn}w_S*D#%e1GsBCIACqE0AoUxawt?+hoA+{ z9jb14f%lveqN}CI1d0vT`~&y_4aN^RPq3!hf;4$UkY1t%DD^2&V=tozo&y$uAHYjI z!7net7l=Jzh7bO_iXL#_IDa**=&!!9e(Fm7`>gR(t=4`zfG@xTxInhSc!E^%l`#}O zAU(hw_`sDizzsCAvw;uT0S}i(=(v8qLeq5zkFeS71K@X-PGb*v6OZ6I4s-(S1pc+F zx0hW7wzC5mZr6sIcIm54M~!5}9JHzGG<@P4qZL3WeAR|m_-?X;2JxuKUI~rhd*;mk zi}9E3VAUo30=uVJ^!O6HK(N3b?JR1UkqjCW{Ivbxfy}JY%mI%}q7zJoABcvf1$)6G z^GsUU5v_1__`>kqTK=~exNMZqTJo(q1B~2_`x=ogP@FrF`*JDu(}g-(dC`F0+@MSS z@X3KY|E@7OS_OmFf)8wDS8z3rex9CSRT$aEd{M{|1%f4#H#3LF6=$ga z)xSsoUj+}az4%HeI~7$89uR$G;$o-%NlekSe^d2*c$!T8>HnLN@sSI?UwEpf?Mr30 zO4Wdj=zSlgXxCIQ|GX)hOYfh3DLcPf$%;wBEmL*4|8D%gR^j{6g8a`9E_qyW$vMiU+U3#y`^L$# zHcmI&ko}h_PAl%m>iOhY9Vi~FZ|wip?Tyi;?lB7Z6s=*mqV-@fKEU~+Rn9{G&+;g3 z#slnkJU~9-0cb}9G!PEZp@0Z&*&Lzrts}HCIUKHGxcZ<0=mZDg6+S>Wx8eiZ8Xv$+ zVfsN9(2V(^nvNIfV{`zUH<1O>Hbfgfk_CRB9pGGez%{`F;Q{0#6Xa&MAZ;uhq><=> zJK+iZvTdNszYfsJ(*epmg?%8|;9t-K<=*A5Q-AntdPaYZ^@9s^)K57^`k{aE(^K*R zrtiZWxIY-cH}?MzeH1v$N2Bm+?D3Nwz%y^vTjH%hyWkH{!drfDg5I2R$~+Q}=L$|O zdf%kS3eC65-j4exFZlsMa8S-zRDGdE1K|cW{nt$1H?@DjtelJB zs}F(~1SYuo7k&ZJytZ$c)NQ*-zj(cSH0Cv53=Q!+@UTFmCNK~DO)n7jmr-ND1iU#1 z{wQHo_%ArKA?ygA!<*w?Exruy{9NjbnoH`6*Esc8p_)PGs!(^F2_cu_Dmn#xe-$2QyV3KXM%UzJ(1#>={@IM$RLQ8bV128{ zGv_ad3we+};1U175d6JA2V zfAIb;(EGFDz9P&zyo+G_22hkq*ihNza|5$fOmvOzyY|~IYR%E1DN+b9KZqL`bZ8)B^!PJ zYBGRZg{k)EP)$Pz95XRgS=j-8rv8_~18mYUM1wQ33&0D+Fg{q1YJ&sB2dUY9G6BH= zGT{f%8ZPjHU4d|9@C5xHpxe&^baNej0NKFr-SB`8`Rm0%vH=S7fD5$Y92}r=eyUgk zJdliV_hDac?u|caL0^@?7bF&c@UIPhbPvxaAG^0o!`*1c{PvRP@B_MlD$n3{@H~#I z4<{(IQ*yxh+6W%dh1{T04i%;k?7|GNV+1A;M!QeI)M^{kN zpg;2)R5>f>MQ(!zey7iW2R6vrP?xh|=Nqv5MDBHJe10;T<5%;bpvltzYkW}~w4a|gCG zs!3P&p0m;QY~ZfH0@mj=D$`q|`sFt%Z+jD35R)FAr0+M7t(uo}v#VL53(#1eH0z`n z9P1Be@ME%>mNENZU=CpR_XPW&vVimVHa?E%wxWCUJi+0f-~oS&`M(Kx&T{7eFaBgf zfd6OzZ}(#*1GEHl{}}kcV1R|Pu{)lIkEGeDJXzTRzGja!h+KdpDY|nzRfP+rX?mVC z6;H+A<5{XEuI3Er!`%NPMYXP{==GEoxk{#}fiHZ&Ey;3sN+vrlNt;e5soeM^ji{Xj z7cWsyE+lH>tVCU|o~T+;2|BndK@IyQka3cr_*A!Ag8i54$N>z=jKuWP2;sD z5#Nu~F0~lr(!)yd|GnezJ|*{~X`Cv&i^X3E-S0TGKc!+-6#nmz9Wk;E0Rza07vS}1 zW#sJHZibU@)J!{j*>Kd>TTfG#tGrS3JHT1L*-K zZShm(uH*!w3AEx3){|Y}1RN=j{q#|3yumI^#UH4Nk5OW76{_cw2G~{MFQ?PV@p^)Wu5X zV$loaU5Or+d-DwEKv)C%=KT2L(+kYyZq4C~zwi_4?FLzy%mxKH6Dl1BV`oP2n9iIq z5zJtmL1Ba8+*7B=x^o}*KzB&p{@sDOTn4q{4j)y^pl$UGQZ;Iub0a&m{OH zcK0Ns-pvK?KLP*IXjI>1bWsIN>RcY3lz6+)q}KFAb?oG+eB~_U_f%+wS&94kojt+l z;~%pYl|k!2%%VCwEV^Q24gh=U1NL9`AUtgs-aj?)cb|Z-+Yx+!V(9~F+O%>6dhbg% zwRC|46t?TyJp2DY=jQz6e++Y|@)?Itvn##|2RO40EjfGSJiKo54`Fs3nIhw=R6UJP z)%HNJ{ul58>HABKPF2ye%msG5z1OGcX-m$5bg+Kz{(2*m0%RQ@pvJ`mw22v@8+w4|-TdWW zoSg75Kg~S?7l0X{Sbq2b5x!b*)mQ6A`|3u1UuE>h6J(u_^7Z#o)k5qA$q6}#heJm& zobKQN=jj1z;O)>7kN2fLohp&bspI5@{5s0rKNe1KHHUiQ5zxv=Uch?0?zgh5Zpr^? zguCMtkjC6tnAeXLPQasdFD-xKr3KsYl^V!ipqiILe^L8j0Vft(^%id6-+8R+nu=G* zHH(7gS>$TX9aYMr2CvLK-|Vipne~7(VDSK6&$aLm1ruBmW72Ri!GDjSah;BL5FCNk z@ZL}4Fv%KW)WH{cigRB+S_og58d}+p`xI>Ob5Z(&EJoFROI=17RL5Y@fTv`R(--u$ zg0J5;1XG>{d-{hFW#f+g~!mS2HqW= zjG6_fH~V5dQU5mT*e0XqKVaSm>nK6bpRXjI$;>`w{xs>~N_dhF!Tl5I`wOu*=}z9_ zO0xpE`@8$1ugHQAGrj+liQNBi{xSqG2jsGmS*b|1WnlD1?^g6GEGe|e(rwWbgFg4dTLK{a+Js9pC2{hK>MxkKFY-Rf4YmTn#W6|Y!d z@V}XGe@nz`x!I+iE7<+@g7;qt{*NI}0Xy0IccuUT7^?!uV^xg%|33HsG)IgYvi~d9 zlRh9PT%ZThS~3mn9}dv6f1`BeYLrHdiPAbSfWi@Y0Bnp@N(b_Q*a2jF8KDnjB2=kR zg!aZz`^Umnl^sC2Pt^W>JOJj0k!waSxL>GV;|2Bs3~)@IP&KoKXb*V+dFcV(W(&~{ z_JBQ31nU5vz-zt*sl>S;dCv<{o5t({U4dFiHt3S6fjV0&P;I^018&3$5R1Uwq zvf${<+I_MzPxIFC8huR|waJ-qhd!aI1>XGyu=z{W_#N;8dWMtq3Zr*|*&k#sI7aWz zUH+7_B7uKpfY^D)qL%wRQ7%JBoAuwvsDGJ zWX|t5-KfKx+3g=CxA!y{#w~h(3p+pXjj2EAVd~-O!JdEjB=#ZeO!9sSS32FK(nZZm zX=~PjO=$e+`7;D@MuMe`?2Pxqc=A0rp!s`(*VlLUEu6VECR^zntlIj~s^;yyRBVBl z#@_+^|BUV*47bm4n__pv?~39KhyU*!f)4bhT}{e3WF5g>fJVdv4&Za}zV*+YniA;L z6+3-ETV{fSDY{WTRa3X5D*HBeee+V4pQ@rZe^>%qjs$fWOx|~i1aL-r{_|k} zquid{^H{|jQ&plyt@rbR0!`QOL;M{7jEXw?mik{1~u!DN6(=0gkcJW>g8fd6b5 zNv*5d{XcwZGydipR3fB1@!D`z)SjVY<_f4`u#*q(PE=V6z1NpxOYSA$GzMmCt19*1E*qI4PJ99A?{47rdV+mmmI#Md;Sq3$=f7Mz zhZ498?%K(Q*<{yDULO^!+chtfT@~y$ZP~}{IGDFJ*acAkkJ$&*gBu(&n4Mr9?i=<2 zubzTCAK@)~sDKLS1io=s87=bK#9cKQoVqRq|hZ|7JYF10MLN7MMWgW!px;7Xg zn&I(oldeC78+aG*u)pblN1Ej147ki0&@T^veg{X!pL_o*bHH&U{{Pg`eD-J~>8HCJ z)#4B89-J_Qvp|*c8OUo?n@`j-Gk8Vzho&Hdrhv!wr%#w*0;7Kbe~2^SAL@B0=Rx}u zXz{7>MkhH3j-buqVK`t=ZvI~MJay0e%*^%QZS({I27L@R$TNa@;T>m7ZoJN!@xwbB zwV4@z`5^F%zwkijtO_|}RHyq!wK6fYaE=A07_~LGNm0x>_4}JNZ4No=r%akp-=F85 zNr}ux$9tIdW+{1#_syCa2X4yUKd~KN?95bK;9TGI!t)2br8`{gP4IpVkH~I|CC8}} zyMOxsC8xY}#^t5W6>Mt6b64V!P1gf>4&i#W9LaNi6D?>4cETMT`nd%>=ruS%cYGu^ zfdM>r>h>iknO{!*N=jBcxINv+rs@!VKqF@Udu3A9 zr`*~+6zxxGx9&y6%TE0d?iQ~uZ(S;P$E8{eU7Fg^C7*Y3+W7*{FY5np!#I^>{vUn` z|KG9f0m1(onPZe4{qMvsG0OKdT9!-EIy5XAUPZM2Mgx5QT$GlLU_j{9=&^jf@J{`>o+{w8FJMYq(+`h3V&H_JD8zFDHbm`HfHwAP?kK z1@?h{cmV7TQMKV@f|g+ph=2!hBUt4|;R{qG7_By$fbak^bRruFP4F!v^^Ye&p_+j@ zl1S~N2e`x@pg^4f6;AL+gXOP^ll^t2p}$P*0z3_Vy1fBTKs!Gjfe-lop|1j#`YM== zfSbuannw>%n>pZ5vYWf)@ljKF!ACg*+T!PMwyC#HW%pJt_#NGMIMrpKQ@si~l_9|) z3)+C%gB&tdc4+n+?)~R@!{ZMZHklcq1wL`v?C78H3_QpTFoQX=2_Di}=_xq_dhWqD zY#6&HxPeQ5&;x{_5k6^^b1u7q_IS`{z(>>oKX^YrA%F4cO)pS~{XikIMN`e%`^YRS zJ%IOEvpgG{6;ldc`@i%7|4<8_CfTWpQ)}@N9mkGfD112TIby z)TawZ#qKp~=5{i&nXmur2^I{Y&UzRX-IhLp`#6B}AS?BGDm&U^c5vxna+$vxlsTQ5 zfyeS#xCGR4(L}hqNd_(B%$UX7pMmrUoErmpe^VZH-mq`{3=fgd?@|fgF86(#reqzl zqgXwSGXNgXytVLn+3S_Pg7-1A%YXZfumsMkY$kmwfqoaxLxn#~$~4P_&pX`y)9gV* zn0LOz^A!P8virA+ubSNq_lPj%3BQvZL@`_Fy@7Qk~_lYP%cU%PDJe=X34twRGmB`dEB z_C%vLJ7r?;pNt=f7ntDDhsmnro1%@i>HFyePUcP3WLJtl-$CEM7>#fF6!rnh`gJT> zBS$4`TFGSXOHI=0lkj|oCFx%2B)y4-<9j7hp5T79swL`De1eKyO3>F4^!*hQboQ-V zy>7epZWjB$#%}${=+;w1y#AdVkGDmE0*yqyXE-qPell>hNr{za@bcs`uBJ}@J zWdCyi*W>;#n=4j%J!4dTQH+k@|GOCf&uyop6*ipypZk9g89?{(0I1tO3f)7L4w@p_ z`$np4W4wUT0Qnw^P`i;4I*$)Pm2h@{YncH$hU3Wy7WkZde@2)>YKBp>V1K7W$!`i( zrYdLwLqk+$KN`S^A*xpuKOi!}X59(aJ@x=Ut1<`p2FZ#iSfxLM6kH`p5B`Riv5e`Tlsv)KLQwc1Z#I^hdI53uM7b-x^4 zFgRfP5AwnMeaKoOD`*&+pt3&NnBuKD_sI*IjaMj~?kq*U!Ec`XOse5LD+(WJCIjow?>$EGq>REVdkLTi1-xcrB`uK>k!*0P$ zYd#LIo!7c+BzRym`rabE{xj0|#&Z8ZVJCRbB!6&0`wTSj?8cThGifY)vVSv^IS|2p z%1p4DJM}0%!P-OIzkArPa|YaBz;Fe6=_arqng+Sw-gW zf;{qYCV(ZD;XFwF&hCJ>%{e2AW&n5m!FGjhNqT}J`Y3j?KpP%o1x=};8@1GVoDSHL7JNu%Ao@!EUYCr8P`aaIO zfK+^wbAyZg&b&X-tmhlpm0W}8|BC%dPK$Q8V4q6wKXnUQzZdwgfw9DwwrXS_cK;jT zV0+;A{fZfY`~NUptyd?&0sZlIFKW}fp6mcl`&ICD=F%gBURy9Qg!oVie8w=^x8|N&k*u`*!RD% zQu}CXit=&v7FdkkI zv%rB*_{({qF<G8Bow{)fza$e|NLW#A|fyE9QQ70(0+JbaFMjfeH8r zv;-5Nr@a-<9rqG$3m8`r=RmcAa9m_oAe{H;&(w#@q|}FS1;GY8oHVKMa{A?-Xa*X> z6{t!Eb}p0le4-9H3!;MH(OHbzc#XPaKFDzZZ4otjZZm1*6;&r~S)2PLEqjqxN7tCnVX>@#%HOWbb(^sIE2~LGcl@@aj9Kh4}KHi8y z==(o#wpHN&PVHwO#5uSIKUFZ2B9ZJ(N?PzxWY;$YuN7vg%U~)I^!-~3!1Zr|&lh`_ z70g{#BhX}gg_{Xadl|d`W0&y!3};VM9nS9;VuR1=PONO|`D?0K5d=dFKlR~#I` z&h&ss;D&T);M7cXBa6X_g3tp$2!bE?a5-~hjk(aZCA|4)w5t?Drv5+1Ev_STDC(uA+(Sq2TV-5C4sBojXi9=ny<>I-5BTG#MaR}! z^!`r^yjHmD+-(tG@vwy3((fwXK?mWuFW?O5ioZSeu%&=m>pz-Q5o~a!gZpd_bNZ_3oDcNxo%nOX$!L*AQ_ExEAah2H9?TrUO!0|FQ_hn8D>)+;!Q0(V z-Jj*md1=&7ANq(;W(qf7_YG$ec*XR}%=4U4|8(UXn8?o!ruk(h8EMr1o0}$er{@pn zj60YgKQDTp-rczSr@)!!ci{VkGcW;9g(~POx>&SmGQMlv{U7N4J>P@-7b4%UEn2K; zc>SNYYHA4g|95(?CSHmHo1J^bOWESd{(--hV-mh!^#4bwfA5NR4VhwB&xg!-Y3zH^ zgS}r3|Hs>*XK=)d{OQzI&VUPe$P77!ZmdbN7IlT!eA1 zVuCijb?ed#w;peBD@SiQzrVS)Cm>#(4#ne%6|b4!==mSB?_ccF>$dR!vbgjoyT6sI z<8-;1gb8&q7poT8MI?1qh=D_;@84%}TIlS0EoCn*IOn zAT3!;|6e;uPWZsR?%@eY4{*I&Ah=+F23-o!hH-cURfZFo<}c@2e-)qYuN!s92#NR8 zmD_$ALssyHHh%h+m0rM153t%-YkT4qT#U0I)JK<@10GFB8-Q2%ql`Xy*rE^K?5!&O zz1179umx_sUY@`Y-s04nPIy0Mf*-&cFa#Xv^=OA0HXuVFlS92Y2SPpJ2*VdiYH3$7 zxFhCBGDL3KlxrEYz#lg4C~MP+L@#y_UaGpB?0^AY%2|_a(N9)A^@J0!*{aopta?(% zs)OLwTLZzYcn!ZkU?ImI42##cnc21}Gw$Xz`du5i*Cl4&&1U*)`~y0}8>olRO&NSI z^5A<(pM2vb_~03^v#re1o0*@%&)RYp4DL;j-IU&d89NjA?$ggk{q@SI-Eq`8y}?3% z{D--p4V(=ZpK;eeG~!1OR(BKaF}&kC=Z#u=id{YTdH0iG344wDe(-A$A`mnjeTB@T5z1(Q}f653VpzL_8i>%&)b26jxlTFd~ngNW;H-NbtMGe4|wTvem{HpJ*@=u>rMaU;`i4y zD_Vc<{^YUvee7b^dPv^qKUSSDfZn&Gm#%L{_w$k&fcd|4cYIzK;_X2F7f7<{A8=h4 z^`DpeKljeA3-tdDH=_Xxc4%K|C*H&C{OJwHclgf}(4pVHvcoTmu75r~z?>BAhv!qC z+HX(aKmGqmI>+!h5H1SWw!hl8jZ@pUZQI(~?sik#Hj+`22`A1tNwc-x@9ncc=9x5| zplPnoJ?GqzBrRK(B%ek}nxBFj9}g3Caz3%&Dp5HzCDOJeD9v^}zJ?|!U9ALd`0Uly z>t4-S;Z@VRc>RCn&R>W}RrVA2!#&zv*@G_84Q|5CpBdnPmEF1?=2Fhx?E43})UmKj zryWieI`32iu)mQFoEnYDcj1=l=IB;y-I? z_o`L&q#S6GCT;Si-{VU-A_yG8}iRNYw ze&COz^m-W@fQC`jnn=aK1MY9)+v_GHwJn4A;V+VRGII(^%qvZ3S)xd*K3|4^@q+cmh=q)$niB{0rO&UJ#-u zE$|5c6s$?$fYbKk4a%+1{8{k|g%fDoi!OKwdw^0wa=NYh-yN%-ue53+SYW4IR^_t= z%4dI|&JzF5;(>Tbq6=WZvv*&Be)Q+LIJ^KiTmX82ic|dM=;^QCMcD~4A65n@%C?(1 z0DkbYT4)A;nU&58NAR#&A=H)Pm3aGyN#mI{XB~hWJRQAxdz1PVLVxb%mf$(=iLQW~ zItUN(YTTtJ2ek3xA9~ZE*{ksoLo@iLhe4^p1&`)3DB?3cZ@ixt+=MT%l^a7-=!FOQ z>2yopUkV*;MzHWV^v!{A1I{uZkO!v!4R>Y*SlVo`LSil#IbdELUj>r~s%8gUqc8YH zJ~;LcZ2t8#v=(r2UV#O=sMF+v0>trrKl=UK%>3YW&v|5cLQG$KrYq;c4EXa{U*>vZ ze>gSX?%*|X;Ed#zn~C%aX?(RJzpqvm!l#?Bz5Wlj*Uwj5z%071W~TwSDLuV@7Gi&! z!Bj|2jG*y>~ml}chyh8m3-)jr?VfLEMmU5L8GUF_5E$ox?B9b zi2vHD(E63(J`>pAz}5J(!^8gWX8-bo=c-_St4+#s2M+-7{|b$n+oqVck(@o9{a^MR zXg%5ge>{QzH{8$uXaEA2`0It0+i_`#`3eEb*CasS{>N-M9<7KQ-Ci>O{cXABL(kv4 z^K-2Q@1N&p&vzZ3|7hwy`#z@!p6>;2de3FwUki`F*WC4`_E+AJpn=r>@n!M)fA3Z8 zD_%LKdG)lSSEm$~q>H9qFk~~UX%cIBN-RgVItrAn2``frxKf$HR`|$ih_tT@Y zOZi`*_rK~?;b;TEB)?hL2)kh0q1fN*Sub zc!c+!7oz;Fcm@l!(gW0+9jp;u(FbM2GdLhf-O&aupBkk8)xZVu2zh@%R<5V0a$MhXcTe1GE62fD-Hjro#m<4IWsI9MGVRzY3M` zS7I=pQGatw9DdOHP8Pi>V9_VEq>V1n|F1`1+LRs>e&Ea`lPuS{E4<7kZ$FcER%Qp4 ziTm@u)F&UKQm#WcJOur4Rik#W8;E<(-Kxi60-Frz3&FSsk`utWPUJ_^_QsFjDQ=8D zAm;aRYj_2`A#%Y==Ho5I%v^fr$(iuL{KJuVq9c3?pBNmi;c+zcUARTkWe*>B$5%nbyEh1*gBW=I zFSy-D4-)~mr)FJ0rJ~pOBktR=0~t)*r)DquG{H~Ln1}oep`j%9FRx@iVqTg;>_@y| z50K8NH${p2uJrn=&|wk#rvm5$&}D9?@2WKn?(aeNe}QQK;r{>ebqidH&tm}pKRGSx z)z+dy^m9ueTQmp$UyZi@8VdgR9Zp!IZ1@1x<({nIi)0Q^1GphSb|vDipQNKXpR0E6 z=bHX4Ntc-UeaJ)R%Qo1Gfo+o_Z#obvNJRPDM$3#U0$w!TAEf7IzB)RV%6qD44QXt056GAI68pK-e~Yo z?to5=rnkfo{3mw+ZgLZB20WlDQL?xq*&o9Jn2r}1JwV{E2z9*~0jD?u?@v4do^un3 zJz&Hnn=V(gY2cf1c~6JyuVH8b@CD0b57RVyfRFeB9D)y+XEZUxLm+uae*F!Vt^Uj?Y)KX5%q2Y_$E_x{A)ut)y-YX`W`P=8J8 z%MC$hf%I^LuH5I2Fgk%Q)Q(JTENJ?f1&nxw9b&fZWtRW{xFhn?q}0@%0Cvxs%Iw*U z`-1ERvL@53(xZ0YZPdHDMy2a-BI^YP<3#3|O(0~aB?O?|p0LQIr4tia% z?=${rh97fR1W%!>VB(X8u@eU)>{5$3Dvk$Uy8m#(HL-Z)hYdQ9goJF@f%o! z=ja0Z0dm3Y@$3_c(*n#1t2=?m^@nFq{ElkK#}dQA^_eZI!NaLQOjoCWujz}|2>nG# zFgjwsRux|@Zp_!{0$v9Oxvi(Ko{?9~L%4OqTwirR_m7WL`{_sa(d+y2y=;BP*NgDg z*H>T{;C%D5`sp%#%=8xMc}Jm*p3IE13w{3$>i#qG95c{*`k>zB`C0S=BU!?HbcDKp z2i)Y9L8EdRb*7S0F+JGzPcrJ^Ua;0cqi!&7707GSvyS+E?>4EAff?YNNtHX8<(_E< zYsB9H{=Wymrw!dKy0pup1P2_iLjKA;*k4=EvI}Gen8Y6N6a0|s^n+t7`0M(@L^WEK zgeMW2o`2cx5&J){BuQ)F_jOBBrnKmM3}}1c`5hSw*S{F^Ked1SnFI}@Cj7q=x8n4J`v0j_oaTT5+zXGDKRV!l+j9>%L#%2A#i;J47|n+VbR{L4 zphxum>)-)!4`4^0Xf@{^z^m1806Ro+Cnrid@dFCl5UI*=0S>bZ-0X2HIVzj>;Vq6#}g=PxF&HU?D)Abu$(ZZEEc8?%mJ&w0UFH3 z8=y(3(xl>6z{3zd00;O{Cq!dE2P+UxV9@$tWhMtaWDW@S1Zgl{;rqr0DY0shd{PCe zMW|IN_gR%@uvKTPTJ`2V{vddT>{y3aa2NcY%Ayx^1*p*O0KPVSud4I`AN{q2Uho9i zPlHYVa#91rDx(!52b2O69CDa>fch~CJm7y>EJ_;*9{_Dx;R$AKhHKU!H8m#|z3?UW zft&FQVi#4fwn;hArF2U&s?mKs1JDeuV;(5f)Tk%?K2QCOe;C+czQb@_*biizVc^~( z{NYLlUHQc>5Y5W~`~+56dD{o9a5uL`X7S9Pd|G2arK>>g1SecdY+WZGjC)CJCxWeo z!KEYqA|4Ri_o>mR;MWqHpLT*DZiRDm&{xH_F-I%~UtGuBunNrqd7{r8UsapS9iv5j zj(PM3%oUcg@Q-*T^XEUD1TTO8k&lVy<4>>WW0^x98~M7?^c)s)h86t|-^0eAzN(&< z8KwkxlBzJfH1VSk@zcGzX!_wmX8OlZBc9UxyYTb+&K!`PI$zVE^gZE9&B9y#I5WU~ ze3rw>2N{_48*z_;+CP>)YW^}bKc|=jg1OO_038NOdL z(Ep(4C=YfMlL`MXdVu!i@@LF;W3y5F>GQrVg98KxwDmjx_sjtaMt{vK;4fD_JUiQh z?O#Yz4TifX>H_x5qWK{RDYyaD?LwUT5&xU(#BoQR`Tr?*fELDTYl~P#r;SDLhzH2B8116| zXU!a=t`Xb=+=L%czi8#p5{by=8B*Mt}J7H^Lqc?U9d`n`6__?#2p+w`GVBXh(E&V{30B1v!Q4RPP9XP!9)SgZ zKp$v`vFhg$aKLd^9fBMDk-I@z!2*YKJ9P7iK#i)&?ZBS_dI{J2>8=3PM<4JV&Ud@d z)BzKFA^ZYXqZPE%BNoa6M}T@U{<=l)@eJtOm0prLAnkj20eA2XT?;>GFdUQmc+F-- zD->f=ujAaG0gK8th?>MKQ1mx?L2&9BSNWY?!JXl8_|>%{7tjk_|7cKWD|c+JaLa-n z!TAOB1KpT==>_&t3-cF-N0^qsBM0=mj}I;wnLqu&SZe62&VDM|3SSIx!o~%NG3M$J z9>ahA$0fQ!On#yNwuG}sBt|Ft;z4win7vHwp2e5&3jTW6z!b>`ey7kOUSwAAVMgEW zt9QHT>yObd&`%WI$W0?&bBr3_?j$^YUiak^&$qz$0>S=bdF{Vo0mzo=6xS_AtU*>)+6^F9f`Lhz5hfo zze_>?^+}bp8nvc6-oEYe`WR`{okd2?*@GvO2@W8;zp(u1v%z0SuR`|=|MwyD|C@4X zxJQ_^{2%zg5Ak(KK-*Q*qE7QI8g$p95nzC?D*0>aIPL(l2Nt~0-7bHPJ3$^uf)AE2 zQI|?4Y3)jQfa~G)&jafl2q&OMlCHi;RI|%?dM!fV+ZXIVH+Q}K6V&1$H+@GWsD3qY z|BqfJKBeaG_3GScc)sPl+WpI;NCW=4DmgV4?7trIpKh-M-k^gU84lg^+BM+19X%+#fAl}u zzr@3pjMtb2@ml)F129v(wm*u~fW>k8+BuG!g!qBs19EO>EF4#Kz=gO4gbuL4ejeNd znZP~py&s~r2QPr;Xo1S%2Qv9vlyW_b(#s`L>W(Mqk9XVzLJ!<+R-~pkh}51B5i;G1 zP){_$(dYp)|F+469w5U)8#AX(gEE2v&;z{rD_k$o1igS0eAXSNuk-)~!2*K{fd|Hd z|DC}bbWW(OjpzYB;tdWKSZQ{MrZ-_1@EuKnAy`v4g8^_a>`|>?wf+*M0Oo*t>w;uz z7o;m`$OZ6%9-gtP_Y7`_*07>KWIq5m@b2zF4J8K@t%7D4EMPADU@N?jMq{`k*gQZZ z(z6?2Cp;5=&|GrBhK~L^liy#l{7y{a_hu0~fjO+syxaxj#i8&;_1Qvohd~AzGd>Z`qI`px5`91!`JP-@N zg__sl0G>i~4O%hGAY(f?L{0G)DGpAM!l0Ay!Of%4$J{|vNDY0y4lN-ybst#aNghqW z32best&QLpR%VA-n!dXta|HRp#0-AsJ3aX)U)6r+%Z=Ut_&2+V-&zsm06Ta=67P@q z)e{?dzJs127`%WOe;UP1Kt5SdZU1wNFV$!CdTIPLF(0*?d1P}nKk6R)igw&Y?oK`$ z0MBs(wV#-8yMVgC7;Jw(ue%DiY36&U?jQWZt}j2ij=Ddtr9n-`8&raMsNZRWa);rw z>?S9Gn_ek^zOn({zP*i#pH2L4!GrapQ6>+4RXXrKxIcG^|EEh$+IWqhGyA{7)yyh6 zgq*w)|F5&$0dR5$tStPl5$L^`0SYF=+S;QdF*`=jxSs<6jjO=I|fj!95< z=KB1Kk*_SfAc(Q*~+8Rh1mUnaO;Z6t;OrP_1zi2kDO?K;r(1( zgXecomqwuZU*-nuzv5J-8BX=6=7gWj+s_>G+2~L%w15BRcPLAQU5Ad)1B|lkQ!TrS zf1vNT#4{VmE07x?Rno=l`bE5dW`qBA0|(557bqOyvfE?B-V$A4diDSon|^My>1tn_PNE5XjwbjBI6&!X+zH@DNDufxj}2jJx1Je*J3$5M z0oFeb)#PQN>eU`TKt}ihfg!qqHt@&55S1x{M^JLG_Mb%?h)-yG`hbMO_yoiSY5ozo z03+cCR|(QJd_q>j3rgU2=(BECh2j^wI5|)mt`PqVnFrVjIPiKY^&C#{4LsmB9jlX$s>dlVsNUi*QUfb7Ky? z`A7q^IutN#%?Fb<8L374xG%mI?J&JS7J7k_U(gIPx8AzU?8-dQi+X0I7x+;dT&oaw z$G^f4jHm7~_jV@_oFNbNAIq(qt_C%yCs<7$D4PSk@FTIzp8T*cJoyWLO2h7a^macv zb}?5k_0#={e#$Zejllpowf*qTqz0d(9^d@ai-RFd;O!}e|LYgd=l9d@l+@(RO#DaqP}0^`2#s<`&hjC z<}5(k>mg~Ip4C%U-Q9yDqc=d zoqLH|SS3kmsrlaug8}?ZlusO*o_&en5a@g=C&Gt@^J8Miw+U_EkOVa-0Pb(+p65-p zz015Z_QT(|j8_{SczivB>&wpX%2<5<>v)tUlSlpH-SWT0zHg>maZQ;4Qn~5VTuLNzC9l%1R;@GQm2Mi5B&A#{n{4Z7;UdAZ>=@=bm z1{l*69boDh^b2qR_e9GzDH@L^ZUX+xP4Kf(`gc0MfOrC?f(x+Za-=S!34Yju$L|P@ zGJ*q6h8I{XLIpqBG@jc4*O%MWrkza#(r_yzGF(Y`gA5)Qt}OV2-A^5^oj1ZXb4r*t zG6xjEALRC_P)!62d|0130A6rLLx^r~!XKbph@LP97(=-ie40A}@B)XU4ValFSdAm_ z3dJYn@4-Qew4%Jc9;UHLjFZJ>dpEI>)_dazGPqKCEOXkOG}xJ`;5x zzkmT?f(<(c=r}ro!C*njx6uc%CrZ(U`cR79U^06E@PHh9xFx}Eus*z!3SZEfL@{q( zH!Es|S+Tv%=x5D}&&}`ObFgWPNq&b+syox9?eqfOz^kvO$4@K{4KaJd;RoRgFw-7m zE?C$aJxf`m=A}03v&*2DVs6%*r9W|(+>CYa- zppU-{3L^GPG5eol=eLL2KWu|h$tR4eK@RQv8XT|yv0n}DFF)5r>i-h@|Dkr1X2a7w zAoLnb&GH`M|KTZK;At(gF~6ln2QV5Q;9u~7?w8?S+-QIG+U_r(ljuUm^8XC~Yu${YF;=|t-mIyuNkawV}hCuOwjUj3Cfw|)t0MX z{ks%T|BlT5718>C^ytzZk5>QVk$t&G`8#^lq?AW1-!bn$A?}&|C-!lx2%P_;FJ1cQ zj7!yfxzv)`KkhSrAMk#bY;Y?5FuebYIknk^*UvGB_D^?!lQ~o{9s57CUC};v)tzC- z@0DEer~iKzuOch|;{d+I1L$y2oIdP`gFhUnZH43X-VuujDLSAbv5G1js{zR|I&(Hg z-4?`f*CGb&Dn?W8L@WEQXtb8mx>+k)gFi+|*SQUhCuo~SQJR!03e9h%)}RUW=@hBr zxgvGM9ij2?f%C!#9>@&P>Ap>6cj6B=fcjt5rsb}1>O!~*|KS6)Ko|HeOg<08)Nv!4 zzz$)$nHhb+qfiyu5US^WLiL+l0j(24RPkB}`(iYLXoJ3d305hvz{st^vf~jju3WG_ zzYo%gYj_2t59;44NKdn&7ls=+_bNGHDSV(FR`MzSq0x9epAJ+Qejz`=1KZ^%2YkUh z7>;lg^dH;jb3cSx;3@Z^E|LR2gAs3-;jic9fOO!-v&jKJjN||`gAc)!doc?vPG!+v zH@C&%oBYw7cN)rl(Rz3Y<;6?%9dju)Y4<6#L+q%pqf>uGFK`piU{5dDRy4f9vqqVB zF&oS@s()Mf?bWGo`Hfoqf!nqT2F3d`2apTCQX7kH=jOmlg9?!g+~k2O;DvdL;y03s zJH@}y%M)wI=nWPTcU|cZ-q9aiBPRWLygdtc_&2e*-%oky84UZt4mbL#`3hot0X@YW zKUL;Yl1Dhbdye^VbIBP~XZY#pB0t^Ybq)XG^R480D>&Y9a>hw;eXt3?$9&!E%pQ-x z_{l}xKly3aZ}5oJ=yvH@N|gBz(`Z%?tg|&dXnLC6qtQf71M}F(P4yE7Rk%$~uz`X8 z##8BkMr9`#x*O9kbvLRtvETO+J3wEf=9-Nv{+!!vIZRsrKa;k!hKIetr26N{2NCoD z^k5g^0Bo2~|Gy2+20PmqKgkJA`F~po59l0zKvwE}PB?(={FO9^+wm*V12ps3;;HO- zdMBvj$VA<>CMsooqQ3j%<>$kGZ&jjZ3{1p-I#G+G6WD1bsM@>)9TGRaGbX?n_G;g8 zuS!n$s!t8C7H9LSz$=gH-}I;*bN}E89(`%Yjh|xRe-8Hj`2729cWYgLeEti8|FieM zao#24a2MPtffP{NMm^fW~Z#$73U2C*c4skEZ`e1K4?4oa%84bkJA)|L(-9=dM__1_LNW570Rp z4-oc%&gpo8F#~*0jMl+>(b~8fJ|H+?3G@J+&;(l!M`>99C@}IU1*eYEji-@nxrjYL z!$?gnj5ip3pxiSebh{khKwoV1^fonE3>ToSO&tnzGdMh4KaTu&EBIpr_5t(&|2z#- zXZC^bI)%x`z2Gl*Lp5zB`T%YP)I%TiDmg@5E{5n4IiN}75JkU79~>C0zL$gbb9}Jc zkOLmQ4$>HZc!BVP*Y^+7f{J(sWeQT&aH}f83z$R>xYo$3>Y4BjV<(V)EBt_Afhvtw zs7FR{0Sk8nZo?DYh+jxs_(DYjR1#cp(+%#5&-Yi`&diIA{526wV5G^SBR+72*HKfL zD+|`eOB7u2K(JZIPn%VLky+dD4>(nu-m@6D1zr>PHg*KJh<$bhkGq@TH=5+3elT`t%h%SAUB4j)h*{pBdq{pF01E^KkgdF7UfRcKCeG|B-Xj)63^d$2|_>eMdgt zCMU&L#jCfuLG!`%Q}>7OFqFL>&xXZ#_^fBQNi`6Ybzo%>XOeVpNtxMwPs0)JOWJuy6E8>{b#Bn>3;^_r9i>bbvW)8$65-$@nuB zG3zfhTRB#lRe}D$)-y1g4|oFL_4afE{?A9ydDF)YV87!9=N(1-Uzo_=za0Kh%PcyP zIzcsyC93B7L}lXPSe&SvqY~AwMWXuTNK}re-0MwBmiTx?Ny>NrP zTE)!2ArrWNghvf-d9-zvM=gf3^K0PI_6#0%h40t!A^tv_+-f<(4QJP_oZnqaZE@+| z2DrcAe&O`~4?Jl7Pr&$pCgA;9!=b;TF&j#UUez&nl@ zh0z0i7!d=$9-~j(1kJ@Bu;12bRUR0vJ7uEPhZ&&Su_*PM8l_NXfKtD>3Gg^l+14@# zbc~b%UyyWogQxh5eE>JY&*BR(f?Z&#ePDotxDm)Mz!VlP(>eS>7ldm?({M!+|6K#& z1+NQJI^w@=R&qdiC_PiCPE8EeVfKM}(uOM6(-3Xj9fHqnh`tvJ(Kv303vOVUCBZt< zE?Chy=>vke8*+gA;oJ?#*&e^JtZ)SFXanH}Wt(PItq$B1#V=$>Jbtei19c6*kc>?O z)utG`L2rQ88@VU=H#*Q!V1syvS$@$U`hgFF4NpQhnu|VQB0J(zuh0m93EJ2TT$v3f z&<~AC5j@4f1in552iODmY^qt6*hL4`z+XHQniOz>XC{+M95%_ikbbotI|7;1fSI6Q z1~BY!>e~b6-D~jN!MOeC2j2HKsvWUVj+kg!l3JM7sIy51ZSfkk<{|U*5rc*@H?Q4* zz7V{i_i*az0G```t<~mMVM&7~V`Gbx9 zT$rEQ@EpsZ>yabsMf<4^G2bv04niEf1oA}>4?Fu8^bTpzHe?{)`TTDB`eKE^ElL}7 zumQP8=pE?qE7ITh9nJGpZuXI<>aE~b%4+nHe7^<%X2u8aJA9kBcMw zy&D>;o<{i6%=|04?{}O$c-yFD@P3{pu}?`2zEa+#6Sdg;4K^uy4H)2QlXCl-v^*`m zA7+3%{mq&>o%^5L%_fnSwysGQ(m6N)^jk=$`tydL` zdo>DkG<8-Y}oC4qg2EYT}wI^2B!2nKHf)D&VhFfGY z=wR^zh6~(3J8#ni3}+4)4jX`>$pzGWRniZh~^&(U=O@y93u<7M$e1Tfol#ECCF=sel&EfiqKTtCMK#xCz1ELN5 zu_{bYnxGR-AEwdx1P;B%UT_}zAoc-^zyf9&;RLc1T!&ZKl7b=n_!3RPMdF{^fdMUp zwJ;-kVfevAb_Zz@w}We70xkrq@`6A;M=Mme z8r}iu1*f|Ml>SVBFc4AO*4%@HA95zaU+o_H>*r>AMD|8?tFj;D_vPQnKX{QvllQ_c z?L!`@Y*F_#=!qTNprQ86-fflz?a<22Dbu zMeoh?8gTh}5 z=;_lhVW&ZjzfY}C+Ry&NhZ+B*fg6Jc+4w$l-o-C1l)4{f(4J%iy)yWIDdN2~bsv3S z2e7{1)PDCWa^Vqr{ww4_qfuk*MkOYI1@JR!LEan(-)iMJG+2AM-FAgJ01iL}G+LL~ z0d8uC_s=kV0NB&kxP=!;GC8>@cfbep|Fhjfoq`L1_Hz-~&JG?cz1#^QhgVzgRlk1{ z6p|PJ?tOsS`(yC-YU$O7EMBl9kBT$% z-$&oKWRypZ>w2`9*#D5iqbG3v8lQ4&=2Ew&vGc!7?GMB2=c1nrPKir-@cY>d?q7@A z-}f$a|2n5i_QdzEHn%^1IMm#qdcT32UtJvPUXI(p@9ipg)vg-r?CLhyu2IG9x|>A2 zv;W_~{%=w1cn!b<{5T#!H@E|IeimGS`f=Kmk$oUK;5pm^n%ak(02O0ZF3u-ZK4N=W(H`6H_$rn z12ujcp}Y8l*KCJAFk=LG5Vt{g+tjwdO%ux4G(Ejd|FRFbwjNzz$8dO>;o2M!rdPYe zlpl|v(fEY^kGCsoNirIJ5Vd8%UoVU?n;C+}8h?R1c=?OBj3;O{M_!8Yr z0&_tmZ{G(WJWtG@z&mdrTtjMZD`K(FB67rZ;&;43kNdNC8%XSSqjt9?S1?1Y>P&CI zY(B7`K_R@~hxj&C=JPbb~dKD)*Gk&Abk)zqJT?Pqc@nvOsC?Ll@qF=h+?V{p9b=ZYWWPN<9jrvdnMOioa@*aTgD znV@XX(eVXR@0s@_XC`Px=>#>V=U+qJf4r6Z-J`tR4uRWW-m8Vw{msOF{@osRn~Sf1 z2e5wT{awURi(6U7xE0#WtsME?O67Lx$PJew)^g{kH@yFJE}e;RYTc4Tt2%Y;6PllU4*2Ih`Z!dI_+QEFzn$Ix&LwDo2HBOW1~UNupT!@;`&$*S zTdn@P0aW@$oDOgYr1so6Wow2PV2(J|3M2mU0eC$MAAp*%>Vg;GdK34+R>tT_KjQy? zF%o*<8^&n;+!w8}Bck=1J-{$D!JQ0II=wYY@8JV|#~aWbAE_Su*aN}`yvKc@<#7?p zbu2H8Zi{2LG?#wTK57`e)0fQDg;vduSq-ak)DouZy(X6*W@D>ZlSNOh3Urx~ztmgN5 zEc_ujt)nDu}-yvLr6c-%#wP>&d``xkux{dlc4{h2rq{SjyuYEJKTW>5a0$$huam|E z9zneO1%piz^PyfeP#)&}_Xh3%MLtQ5J}QM#1Hk&au>-X>C$_;orZ4;t>%YH)xIaox zIA&A^xYRRajm$mht3L3v$Ys)Pa^>o_CQY2iW2;Hi(El#>0|R(xQc@PPQWxj0BV2&h z-MI%s{73sT3;b(VulyDr?m+DayQy;xK2Qjle>fa3{@mIOc9YYq9p%~Q9Y|2($poD} zmZ1LI6I6Xv0=FpP_rC?>d+3#Q7rdTuMz`h=`^#FmWh>~`=ocISzy|>;xRo0b@B_-S7r00taGcw*_t6Zz+wZR!_Jeic3AxxMz4`!mgx!Ge zIc^Ql<<>YpBJTQV2te-2H2?nB3ZNu)6`c$tFes#a8`A(CTkq5Go z2mIFIIXVu`z$laIP~!?S8}y~#-O0lK@DuX@v0!{?R3`d@HV2KGw%Vwn^ae|((I*V% znc4XS@wC4doa4Og8nbZ6IE_&$J~L~71w)JlOSBTZfyAi+yzVaCBl1If;x(B+KYMCW zmh;r_)65CP_3eXT^9Q(Zv=#q?ZD91odq;A|E8f@g3^TLl>uV{lRTj(JziYH%ZK0^*T3pZdSSkB+vgMzCwaH|6ACc=VEcPIAe9-QmjVf1ze{G7(j_w6?+q-);=*RKP5&38^)+1 zegIJ+cmkd#{_zAk#ckj*cmiaKicn6%v#M-!M0K!`KVv+a9dy1Hl6- zqZ#tJ0@uCxD0OE5ASuge&|8|DgTg z0kQM}BLV}I`CNcHEn_b*fH{CX@ED)S!mj@~!_)TS838s}u?;vf`m&$&lc5jc2kj#l ztl-}8aBfdiZ%$NYPneAx#OMg0Gmrk-Y*yphX1PY2m6jSctbtjV$pzt`O)>&6EG5H@jl_f453G=UQ1~SGaLEZTHyPo4 zaVLXWVQwdIMSAOfdkL|gibp#)+=OI$dtP6ckAK6*HqOs|w8BQ!VTV7sgb_a= zqjpwD3(Y?NQZu7QwV}>;pr-S1^yf9B;rWhdueY4pPSHXA&;<>S?i3<(M=lAx?55|k@Xg2G>W z@jc;Y#}cnv_3$dRDzp9F&}B^gg%I`&~TdR7E)dCwidyMf2C?r$gN$ z9V&3rp;6=E|2A~!BG}&t2c91n@co`|SI-W1xl5x1@WiX^xp)gl%{=YvQpv}bpxTUe`g%`kWc7VeYVzg&}48DXhdVm&SYaVU`JGcja zE}A=%(Qp-_<<3tJfG^k!_JHTP54g8=l*(t1($%O)?L-&YXjG(9lxH8{B7% zhLeKS3!OmqIou9t9i-#<2Rj^AJiWOkglE8KS^0V1%5;D zi6_A!N@Ta~1m9k>0=#RCN#{nIGyu$SXH&RE#h4S|!5?BLmMzh!E^eb%`{PNyQWPgR>K#?`x6+h~YyS z>9^_AbN(dO-~8ugFp}Bg-_*qJZ}I`yT_tizTVlOvd1`kRbUNgiK75|ed);~l1UwFi>;||yd|CSfYtd#s{DU+!CW=+yr`6HAaQfGY>q8 zR)M|IYPULCEt>Oos%RaxMyVh-!t2fFR(Rbg%>V~{!W@vAIlu-d_-{DD&z^(--Hp)n zwGsN#F+!`#N67Woruy)LUahz3cMqH9=CWzi({KfC4%fT!%mCH!3&kgB6t~0Q?&Wsi zNPL3O2kZ}l3&cKP+Nw}(z&Cs_cwmoLA!>zh=1c$@n4z$xg+Frh+86Hg6oR~>F9TGz%VN{*2+%Gs+-_~3p-k6DsR8??p8 zrVe`Jbo8wBw1Ll=3nI}K+%zfg8DjsENtxGk_l6$$6>$(wPDtO$q!(ZZh4auy@bFE? zuJJiDKs2?J9(rytHw#YCbMt6&jhcJ`OnoO_MeNxR6Msv0kO#ouzSBF5A}*T|pP&00 z71Ryg;-4HruIR;FF^YaYgn2#B2zGQmc+D{8baKq(dH8dUhpR`9*|LeAgU_A349(6g zcA8sx-!7x_ZszOl!5e{I-%YPFo#(ZOxanasD%-!z3Nd_*2`nOh^`ZCg17=zW52iUh9`W#@UrO?@7YqYiP2?W%umAXff%I2zC!6t{#>a`g z`xkrKJL$k{sQJT)eMlnAX*zISh?q}%j)q`AK zognVZnLYY;(xbA>`W4#X=~Kp|eVNetymBkGubbNmZhAL(J|n^WTf4P@Jzo>*zCSbn zVS`IE|8}Vr9)HKU?=hU6e`aF8yNfyhpi`~qIaLh3--rB8)!^30A~Zig&+@?Yqr^b= z0Oj%gPU+B7JNG_M;`zbu&)U(>_h47E*YN(q{|>MH&jWlH8o*L-;?(8=alb82UHZnM zVWI#39IGaQv1-UYz?$3xA4B{%{rX4y8>5A5@dEA|BcHM{x{xA9`y=rJV+Kge9x!!v zyg{;q2il?(b%r?rP0-FxQA$yOeIVWd0f!^?U>H83#Uk}K8Bc%*+y}rX_*Fmrfr>}y z;XC?%!+-j~<|AzS3!k9V|FQ$T5UvgI0#D)-v=^_y^qw$n_6bvw(P7$M0gYfpD172j z{k0}kg*$Oav{(R7momL2+o*@cWB!XwapQtPT&Dx5Z20BN##sXqBD0ASzJn;0w=QijP=-JOrw; zC(IG3Y;cB8JPME*XiLEbGXAvaCcEac z^aER&Gf%=nJ-h_&0JUc{`{<@Paw{tspZRw?}NO)6|sJaXFIWeW-T$zbJTir#Rj8x@#jCDC>MzL zF65tKK5%)?k((}YQ~4xcgL;3_!3@FU2jAP-1o)6iZ~>|P&&gv)nfoj9Z>d$Bd*5|U z`bn-UJd|F5{FjG+cl$N?FH4-I@gk@VPy;f23DO+3PPE>{W60d$v+|`6RQ~w|JD9p8wDa zc6@O9_S5fg{Na`#H9rNje&8XuGOTc`0X_eec5Y=XL;wGqc!%S=DAuK>mtERT>=&Ml zzh@)-J_@=t@{5yM)2ZrP=>5U{wt)Nj!}*!|8rWb19Z-ecs)b|coPoLPiveCpaaUr4zO2Ou)w@=n)fd{ zK<b2c-u%I4BzKezf9J!UbR# z*qR<-Fr47i>;kvq4X_1|V6BVPhOYDh+zO3(AE7kQ-~+-5TE?w_BUK`_08T)jXzKoc zyuyar6ko-LH(uwKKrm>-# z(l``t8*@Q?h+dq5Be(|NkX|9GRvga&yu^#419^>|va>a++}mpt$Wqqrx00=*#K zA)(-cwaNx*;CuAKMyqPx=9bV-t9+OVVoF%~KfymRFpxX*%mC~NZw`S!TsKft&<|E; zN7xm7(6A5P(Ch#W!AH)TD?m%$fD8EhYtTvVkFUX3s2@8*=7J^ghUU-{luxwi-vD-n zr|=oyh9-@@VTp+rHSBEBLU1X+T-+h}PON+Iu81Yp?=lOVVQ!@_uq`(0@euA>u|sHG z->eUr_+3uR@9-D61IgUM1UJ}p1I-cn;KL?%3A@q6ufVsQ-k^3rxQ8uFx&?kyuGV`h;)fh&SOzjSK*r55#}NKyQANx=)-|1fN?;j(B>2 znVq+rlPf0j_9=RavCQx1uj7MEOwS>oB=RWA`(N{1n8#Y)|A5(Kp&uBfksLz)nP+1T z;rYECO$0gWJl{iS`hXN~&`WTO!*zchz5P3QyBWN?pWUm0sqyf9;Zb&fuz|xKEu-Jh$E;t!IyZbWdsGxo-xohH z{=eDrf$^;!=+^(*lLIQS-_HTp@10AzsrjYPx-^fQp2168`o*p0qv8IRz8=pE9IqaI<29j9yi)yO|Mx6Tli&bOAAuhbJHW-+<79}7)u}VF`nnuH zkXFq9U;vflVq}B|`~*LsE#2`2fD4$9Jz%I`wD$Q#s}8pahU1EQ8nD(^_Qwq3&ja;G1i$=h2EjU2$Q01>0 zinl(v0G>ey4u@#ZEN%#a2b?Gyq6_eZ+dK@`Zf=TaosM3(8GgcPg0%<#pw<`B3@pGq zs8bMn*&un@4^DPj)!{C?feq{k`dQVCS>RJTtG>mc9YR0YlzE`=$Uxnw6{sxP0+k~% zKvkFr@`DdHUl^d_tpe~e=l*y)^aSY2XJ6so&?aUBye2$&&P;)0{-HR2Lm8M2>=xYu zCrp14UEx7IMwVN&8lOs6N3f}y=u?;ver2%0+vRtZ`Cuf!qbBeIZD4-gXjbxAY8p9U zA9z7@DdvR#(YvxwbiXla2>rocewSO_GHKU2duyzsjL+!-Ei$O#YWv%9C}bG#-Oydaj}vuj|6*c1siU?z@<-(x(k6VG9%@H!&i zPv50KxKE$%OWn4jb>wx)yk^5Aum#>%{T@8tTjYsn%nbbfO&(ry%GDsSidgUn=93=O z`YRuaf9m~39tVj3$$Sqpi2t@3!28Jo8+dFi113Ta^EQGz*^XI%0A8&00j(#~4=@j9 z-A7)d2Pk+HatoGH9)na&n z^JD1!*#nH36Qktz|KWf?UD5gq7qI*)>i*DZZjD51z%O*bF;U6_AE+O?!0(Du|L>6+ zG;m?yom8E5joq%Udh(QJXYy2AK!8Uf`Y}JV7rv#g^eEzKwaHg>R77Z4OfKydb6N9;A8I z*$<=+QXg)NmOElqj>%TVHLx-da%=EwphmMNYymbn2d+TLet~*V9ypmhP_4lQ;veH7 zy)HmUCvZy&TwpCa!nSDwG$z(xYw?=PbRBOId}jwv@z;=^_>93J49J5I1-W3tM+>*= z@u<3GVTVF4*vL*AZ2I#MFoGr)g|j~XgZs?CCA6qB9*RA1s3Xk>VlY7MZ5k6)cpCg*rTY0_DH?T_LyEL(0pLxGJ z{eA`BUXlY(r2^!w+~EGD>GO$yC*PZa*bnRi=eIwz&@_{Z%;Dcf{M!%W&wQ4TIm+V! zdjdCqPoLC)9{n`(&3ggt~MYUT=10 z{Yz_HDn8StDlJ{=R@0?%MY!ut?f(ajZ-&cG^pj5c!1Zm{$cg6Msj4n&zL}lh6>fZO zcj(g`hkAB*aOcgTG+){E1+wqIVpk&EpB-K8x`y}9pv-m^A^w|F{|B@Gvy6ZP#QZ-z zWxVzh|Hi9vGOvoG7I6!pe4J{gj8kAxtiJCi2TVj0&^(rVx%dJk;sbJp+aMcbv>83X zNpQfWKce*)yTH8%qIG%(T;LYbno%lRB|k)|&Ru$d<>-O>;u8!GP&tYF08b*>r$=fj zKA}Y`M{3&72wf)!n07>HBsW8wHILASlo2`^Xp--4$*P=0j8}X zN*W)crSJszWeCw;?h1E45v=xLf)(il-scWh?vFvL#(r=rxZtR{LHaTZ?Erki6YK~Z z`&!j}zg0;ixGjdSa8@+LdD#;lbi)mJ94Pk=p63UuH(KJBB?46+9pRa00V;PEoNxiY zvfTr8uTy|L6~PDo7od;K1vSY7nJ=;{TvL0ZjUGnfqye}aGNz^4kV zpurVxk?r9&*#e8oje=L))uR2iExO9Qx{W>Jo401&q<^jS)T}0F%zOh->lI#`PDP;S??>GIh%|T4tsGBBqGf(LW?xIaR$E-kJXuKQ#+%hnO z#b9T|la;*SKLyMYtSvjSmc9;gM+|1E$iBSxo#OfDf_f~e3PLn5k^1f%8 znM3&dkvwV=zxjEz{{^;?7OaxTWqSP+#CiL#^ad%pv78YeKbWQX94oRCyL`^SdEE^j zyXXPJzQBv-{aNyH=Z~-doW5l_IUr*vuzqsD{ZU~5eD5pQfrad)f7uE?>SNO90PvA0 zzRwSEDA)^jsA|^xK0LE?G4;eRs0kcxdW0^2KIa*ihQiZ(Rn4RI?DDR6K)1(ZJ6^qQ zb8)9D$*qG1w@jDZvcu&wj%SzG)UCV~@$bs&R=Ur`c?5TRAEM!f*H`Bs?s%}{D~+yy zYB&6S>T=t!giD<=!u6-`&w0nm9t+HG1=_xGPMxaZ)S2{ffAIMnXTj&|qC;amh2imzRM%Vg) z0ip?9gEwHg$I%+OpW8rVqjiW~fDijXTU?avK2d7CHcFYn0?U3K5znx_&(H?#;eOaK=7Os5g}EW}-5jb>+!3le9nUcOfCJ!y%m0NNfL`dkPly&w z;;tC}LFc(G{@od@-{*qaGs6$SLuhnuW`SQpa8~F6t_SHioZ$lC0g|D{g?lS}-3B1Sjypb7VERVN-I! z$=ep){u{mVVGF*n7Oh}^u(Lau0oY+*@Pg8LEE@WS-(T{<7-rcg;M=#E6Sm=hbsWqf zBl+OyG(3w(>?G68nfe#iih*ohiF&8@wm+~aYvyF;_H;48bkfAQ$IQ1egz z!3W^(&vB~{*j_Jqe4Em_6@rFmtIZ`FF`sX{ON*)Zr51qmO=Q-`&(F7&OJ~ct)G)J4 zJ;C}GI@#|%#@CmgKjm_6dQ5}!-_^+ta{T_;_vL}>Z)WaagxAluvE2D0_Scqi=w?QT zJkPoFZM5s_ezgBn?V8dH4PXOy|7d?tc;hvm{a^Q;@me@OUQg=B>rK{pMW6xdh7U*t zx4_oVkK?XyoW@k(9>7~}0Ql4QpN`d)S+Sa;SnbUntEBiC{kVxHcqe+GQ89YcB!+u! z;DSNufX|}~o)fKl+z7~2E?Svi;|YR4ST1e_S-O6Sxvga8Q^s6b@4l`hdI^ZV7@3zMLDXMqNTxAbY4%u^X5i%x>^dh)!}- zs8>tw3bGpV8+{%q!_{06#8Mfoz05=Eg;W0eNKTzNC6fn%=-e}iAJ*WwHI6ZgB@fW%p1wQZ; zkI_@ynB5$JuUmks(HD$HTX>E6U?F_s{$PcbpP(;7W0-|JU;-!jhuwjj`CvhAW(4>| z>0|LChN~Wa4$R;X{Q-N#+i(nX55t$Vmqo{fPhmsyK{@!x^ahj31s@$|y)l_p6rAhD zH6Dk}TEq_A18$INj2S;vFoV`+b)-M=s|dbO4qj4ecuCpuFi8tePMj1>pr*#-X&OfS z-=`j5hFeD-*u9gT`wn7!4gO|p;ocE*S0=(yoCK~go!8DH&L;3SIbz8m>Um%IIPKZT zQLhJ*0|r#4-zZ70pihXP#*Zk>=OQl@;{9!j|J1x@UvY8;v0j&+pnp*`(|N!q(!q@+ zcPuMGufc0-)n=Bd00*!f-xq)Xi;r(J04)WNjpNBXJXc!C`~M-w+@qJd!;PS4e9y#s zMlX7c@6`KW;G(=8x89_N>_DQb!ozO_H`j+*p8mcXnw=q6-70v-tzE~_?cmj$iy6OO zLvlf3uzlu*&T;tkK10KE3;q61mmKhUY7Zmchr6_n=eNz61&IBwg8Q{#+I z?eW9U^MVsjA9&v+JU*EHOO$8!{|2|;O0B=^P=>!9`Zn94HT3=;@cZsu$f1nf{PFe2 z_xp}rsn&x5qWvku{x5SKyBef}56BJB49BVeV1OC919+kok1uh`?Tu4WbDXx&1B6YE z!_PO4y?>mRyolAiN3nY86ARa#T_AJ7{#>y-_%23g{ow*HV-MJqJkTOWDd7XiPTX@N zVBUJ}1C5MEvjQIgPQVgZls2Cx2fzzDOCL~(K49?cNG&=asdFpw31lx=s7fT7iwLcF z7NKGIg|+@aOJ^D0Wd3wvoWfz4AyD(iktxx*k}mSvX?>ndXn9uGubl;E^zE8J_t5YI}9(Oz4QjN1M#?`KBz=r zkRec0lQ{RE2Iw4G!h_5Td*U-}ZiA;l$pBrC^ViNN;Dh`9wV0g)InfhQUFmT(e-+Q= zj~Bk5a>n2@1WvH)ke{;BBaEXixWoMLa0NebWIts?XIRIF9W{m^b3>rlMjw~>&$L?2j&W4Yl#01-kMBb{D8h;Lp`vuruY{ycZ}q` zEd3R%ojSpnI-zF_yrfX@fdFcJAD+KKUqGE*jX3*RGt@axe?guY#yy#PmrcYzbwlgF z@adWlR!2Ta;;b&seS43$vT}wew!$}&nxP(7SMtP+`qUQRzvg4bMVh9BTydXGL}n1je8e6JDwj8T8^nxA#S-_$9$$Oo6$ z75wb29$U~5CXgHMkr&3lRVMJs{145l4mW2ZXM6gD1ht<|k3SxtzA?l){GC-56I2RJ ze+9VStXJ_$I!5dt2GiTbnLiuPzJBBbG`t^c$19}<^F3nzOqO`HwVGAJ2$zpD{|7k# zyyI~D4w~t;%&Ik-&vi4aY$dZQGw+`tYEl|?f1kbV`C81bKlr|(wM^QW-K5RQ#QNJf zrNR3@zduf0r^dQI@72^ZH#iF0my7Ipv5rgBRYWg zTMU{q4NmZH2CcylXuKy@@h@Xl|75JTEXEJGC%7QKpuc~MQ8(g${b97gvzQ0M3Czo$ z@IfEp05A{u9ePz!Q-gwlq?I zDpC_OMe6sk2)(!xp=0wS)TIq`!NL*pqYgO8?f}cGa3%g8t}(xcD~>&))n0{Z%=$1z zvrE`c9nkwnD7u+YZ9NmJ@6$tdjtvg$ON1(`3lC9pfPsFX*&?ukPV5)1%zW?*JOSnd zm*EQ&%i!;3~>_y4jaldhde z$FQesBsBzQ^X)Fw23_$+>JE<3j=Vs>kW73B5cfXh1S{uxNJV@-^S{;ElIVTt6LxaW z|5BPhfaeQPAB+PNSoa0~A$a0rK7Lf0@5^h>|H_$OiXNgGd4L=e$M=0ik1&m&yNMi> zYZ>SNLFR?zrgqdSH_D?Q9tN(t*sNyM@6R$5<5j5r!Sa1-693f_RHI-5yU^(mIPVL- zptt9&zfH{drN*zyJnu7Hp0Z8J2XJ}r<;BN4KfIo=#B~B*K7MHV!1(`n!i*NvjF%=g zKlkI1iXK)8ntJgQC|iS`|JT}1rPW+=YKnP0R*2iX!m-9 z*8M>((17RI3pUXhi$5|LAf5mpXMh9H2fVEWFYsNA{Jdjy>ny(Db7IsLf3OZ{1BWvc zjP{AvSa?B==CCh}nP6-QZ~+ILpjYUEc10<6IC+4*VWGLBR3a`?QyxVsJAPrEIuZZn zBGvo@KA~uZXK!VHAl!gj{iZ3KG-JA|qcJB41bPoUW={6tTLXz3Dm3*#krl{`=$zTm3+>=oFL zW@vh_cHu{Q~F*`c-FEkUdCd6T8Of3FhG`V3`@Hm&^;l zR|r&Qa={f>fb8@JUI*a}GAn4^7ajqg!=K>~{r%HlAlP3`Z~Lp=VSi8JeF}Ucu*2}D^af|) z9IpjCz_TXzC|}(LKWtpfSNYH(hJqP59X`7G8a?X`W``GjWZez71q^Y(Odl;9vj^xSmU(N@2sm_Oz!}H~ z-@(tyQx}Zmnn@r1y12JaW%1UFoZh-ieQ<@`P{<6<7)1^Kmb&^C=lMVI5zcak(=T{a z2Ygz=eGz=VIpl~*Z$=1EY!Q{^0%t>Fv4i=s+FNh&q8d&Pdz`(>LS+E7(MQ zpDMv@lb)b+cIy00Xo53<4gLU2WCr12#!xvgeF|Swnb%$5>k3gnjBZZ7Ka9LG4yPEbG zsTB_&A)b1fb3S9dnz)(eC9$Uy4R1Ri=K0k51=-)#2R+{yy!_5B0OuRSPLH8xnW*=R ziaB3nUQ^DjJ!t$7G4I=W7Jr}hCY6|FQrUjY|MB{JkKS+Q2lPJ7{R64{cOJ#}cYT~p z@P4BP#;FJVpTp(j;BV0DN22{l126y$u(OX*zV(dSpWCPc@$CPF2YBc_`#?4`3xo^c z)ev4#A-qAr0b}q4%X%X@us4SzwF+*)>)#@k zh)(FSEdu-*&!C?i;SpRFBQ*Hma5W7Lm;a7%T^)yiaF1|#XAM^adV&0S2epDD@O@mE z#@1lB;CEsk%~1X$U;=;PAvPdXdCE{5WD3=pSUkk8h3Lj^Fhcl3Gi#9-z6GmvcrgAP z%mr2l!$%L+ReS|&7lJ>S&bc2Hq_ckqp)KNZw;;_Z9;7??3-+QXcyog}!FuL{lLEDK z2;Sp01NAjipoT^g_qW+SMjoiS1n$7^0ou|mKw+f<^znng-lj1x48wQye|QhVA(+72 zpfq!X+h7GvD*Nj_z9SVA{q!A;!KgicDnw0C1*~8ad&-RLrVDMz451W!L*|LCO}^~9 z@m0t_%nrBvswtR3hgo=6(OCT3SZTD8;RrnlF;rgAp zA407F59!z6ytSJ?A%9(VA&?7tkqgdb1Vi{p-ED!ZAN8Lv-#?GQ`_51Y93a+q(C_c2 ze_x2EVHW2)=kZ4B?@;o<$;relv6+h)H4vA1#n({>+$%=kP8?Sx?mKeM|KtNL%n5G+ zp3r#ahh5PKybDJ6905NGZsQMh5LbPe7x1`JBD`kmgn3!1JGgpKM+9@;U#vsVLZ2~& z?`Js+k16uCN=KXY>%Yw6W`W~@+vj2z-)ZXm;nV~%^W$|GEH72@%1C{m&KaNgJ>DGY z)a`J0FZr7F*U$cec(3?3GrW^#Jvz(oou4zlyTg*A^nhOA{3de2)F@qsA2^{vl%55m4?2Zjcv+;bcZ<}J zs^9~kBDD5xgsz-mchL92Us|C*XU{(k&Q1Syj0rEh* z8(@OW3fD~umOpypIn{%e?|YEi(ic=Z18-mjdcuL|3F@LR%oU`eX@N5OGcSNYbco)d zIK9E1X4C|w&>LrjQ^?GqJs3gl1Ne|H3Q)BH@CfJ+wxTnI&Z7c9R+KG^H8 z`>Wv=&Vy6f^S?Rb%MAX?MNJUv4K{G!Pn&P}>Eua29RV*WO??pk8~sC7c9xI}>QNWG zji47G9~`-cH_=Y80=x>FOeO~mK$nO%c?epBKfw)-lM{Ye(7V7rG=dv6q&`SE0S|E- zUIp|EZD&v)3}^lbmYA2THu=DtTriEg;5l`{%3v@-e|$8a(kGnv#(NB&@*1=WOW@PN zr#S;|aDFl$52QZmOuxX4;bSpx{1)**`Gr~KC-OlM_4`wD!eey$ci}7k%?|Z_aQ3;* zuIKFD#K-G6_sI*zIh*HD6HFP*JfbaUKRthC@<1=n^Rd+RKWB}Hm>)I>gM(~`FGP&5 z2frI0i8eYMe{gcaQTRz?E}=Psd(?$ou#4yCz&n}(zqlbiLzgV{EAS37h2SSVAK%qW z>>=4~QqpO&78Q%vxt8(r=?sn!cJJ3J9uK^DX0K>!=ja1)d*a=4&aA9^ z&05VFzj%#V(aiH|FEy+GGJ1V#{Kz51`v9{h67x|FsSRrIb@2Q5e`lA+N0XM@(DnG6 z)E&HUJsO{u==}B(`$f?DoUIBLkQc2_TAYdp#%Uj#zeGI$>N5LFn#|s>esS8;l6+8- z9iaICNtu+zBQyDoPgiht|pTpH?tCI)NI~&nnZ`#whK z8JIxgLFNG?BXpczz(x+3Vh-2X2jTb(;~z*ZP_<#Wd^6!80#D$bFS`T|fDeETrZouD z%e-M~83#w`CY-_Jp?Fk>>RM~^LjF+QX3yZ9XZVL~L`yh6L{l1sXe*qdS3hTkVZqvQ zi(NzP8YoU*aI_J6q8#)DV1(hXf)sWzNZ%I)=?j{|VPJ%@>>!+AW9N_`b-+3H5U#*; z99_|ip6n#UYh+38Ky5Lycf^aG#HZOu22L=a*}?3g)B`O7^b2)Ce1-sd9Lx{i_-pbF zf6d+Guj^y{^%t071eoFX68@S_E~x8ZPeCmEsb6wG;iuVrRjq zugnUZ@QfmT_1iP@!EH2%^a(|&5B4p`tBhXZH~NH471@1D9;lM;qb8|7niu1v20lJ& z^$-u73+y-9;iF;97#q?rd>BG)&>o)*<_c%ZqhBbF*I6EV2M6=TD0XWFFkiewKDdG= z;cs-dJHZ&i5g#&R=n4N|Ip7DJ@fXIMHD?6g{b=}(bu#N?JF~VlCr>cnzh1?xG9}DfPE$nU0~9Lu_omoM8Dt8q)v6<0hc5{!22`D$LaawIQhZ-dBXXh?GJW-^@(He zd7L)j{}Yx2JkVoQr`PQLxsLzOcKZJbXn^qoOsRw)*gHG`V-4WI20RlDvaL0!FnpkF zb39eJ)-h5w%S37m-XSfo(*taefJ+yF-Y`O@f_R9K2hKiahXC_|TJQu~^kT;#GlC88 z!u0za{DjE^erN}x+lA>2+JWoz1r6CRG8Ip;O4CB&)uJb^9I6k@3!Sf-4;~EBQRW0I z`l2Ul&hBBnMdH8-i^QQNW>)YB-oVqA!E%(QJ^&|lM1mDQ2-5r$>>^(lq(0<=eDDWC z;S)b)|G+ym#<^|=%Iip=zJL?d0xw)$Cr~+y1ZrT`Kw04ym!U3r%^cCNme?PK{t&!i zcN2WcnID|A;XQyKneiqw1Mq@{^Zm7dyuZc{@Rzj}-Xs?XhT;sSk!z8n>^mazW%D=$ql#)B-n{K}|5F9DL<$cprQL_e*BB z7)uX8T~LVr;N?y5{afJo=kY%~K#Y?U#w}u=M=#K<4>bTdVNf%)j@0g3b1-v6A6Orb zq1o`CFH&J*{0KEb_rvHK|D+e-O!qqUMlH6(L0-W*KN*eVJo3VN^vTEICQ=_9L4VY8 z7Fs3z3wpM~lgu2aj2Xe`7MWFv`u!qx{EZ7{c^@afx0%&-EB*Rk^!3c^jt<73gX{Jv zvknY|uiwS2DlLfnrg(R8ovB5yU)ij@@Oh2p>G$)RH6joEz8{?P9%9^NQa!YN<3dcj zNbJu$YLayk`GB)O(=ht~F4O_U{{Jd4_s?(A$j@l}jd6Gcp!cKxpL-xqqZY&|mioUh z@!zLPoPH4ht%&~t%mCBj0ac|An6T8S{)3GYT%d*D;r^KnI!+ys;TrqE=mD}!F|eP) zpmMeF2Fhkoedd7^;RIwn6|1qU;0BM2)sVLM1Qm|e%}+5Jm;fK}89Re_#;6Ql0sYYl z)hmN{7<i;=W8qhNe4~HmS@vuMGJ5ruA zkt&LJP=-N~Y6VB&BmKZS{6ktD<3clVWnhFZl;xftu6%yr0bqmE)`n{-eu5S760>Ed zM~Dtn{o7$0v=+V~bApfP2p7H!WxgJ&-na1+*+l$<5nh8g^agAozavDGUWBM3*g(>M78$LMb%x=;drF&x5;H~-TUxyJ|NaT%;GmDxd*GgyNyL3qCf;YkNJ$jl(5Z;&hv zf^?d>;W~WB7A6PE?hTjVG~S~d0@3ORs($}Kt)nh5=LpoY59}t74bWfU1qTiXXcTq9 zGVp>F^1#zV0m}WwUvJ0--qZy*FZt`*aer-J=dW9H;TsO~m$Mx^3*Z~RW{=@Z7qbKA z2^${bR|?0V5A%eYtNm1K8NI_W<_q2NEP-o~r8GF>2eb##zIsD#P>i|4tG)1$*P&IW zHYnW(Z{xdnU0Dp${6z=JXPk@#CoKtrZ2p4nMus z5j*%@B=f*$)cz023HO;39svv704BJUULS1WF<9V!@Blw>{EXGX{D}WOHu%TkaE;Ly zl)Hsz5NG@Ui0eFycsz;to`HUVJdl3?7(jP;$1TYhUEipBKRn0A;XSk%fAMMLfSPYa zP~pYrr2)iMe|qpa4a~Yf3Ev%R`IE%@$q8Wf^zU8A;Lp>;tnQrWP21D6cc#~;m+#XI z4Nn`e{8ngqiTN({^xtcn<*Z339YcS*6Z=s*3-_I0B>=XY9aDB() z@3(-N-w!bVTcb=mfZnHg58g{n6CNt;`r-PV1rOi^Jpaf6AD+i)>v`~i6`c7q;^Yes zxD*{w4|qT`zyWf8G3r{FQMXSRwQ8ABttT24*TSf;`HWinft{cpyuc$3dV1EN6Uz!mda`%88d`!+=mrdMh%b;2=7*{Qy5hgvhiX!xP<^2{ zsPUG0A$;O>oPF_#;Tg8wcqFvxBplg4DyzPO?XE3&{t$w+HH9_=OYT6qqaHLr^wQ6@Q>D zKyR@0BD%vv>?>SP9vBm#l_E#9570wu1CQHZN0a@PG1_0fm@n422wu2^-37C$7pM_> z)&Fm%up*zoK7D6)5Qm5HtN*SF%o(4q_e10Dr$_zZBDO=b2p_pT-sbzs3Ekl$K6>P< z;wP9p9%9b0k=!uWS2yVw3}6RO>*H^d*H=N`!40i&3&;uE9^rQmo_OUHxnUJp;wbzL zx_}=rYi!xrNB=Tch{(y#^lx~bC3n9dV%Kj1z`I1!1$k{M@UCk zG!Z?~2kxyl;VrTe&Eall0Sm$XhT=mo1fL}0zEN-V$MxRmuWo1%$PESYH0Y5D{qiw( zFa~?!#~-IEVD7o2O!zgMmFZWro)XVPsM!l~9m;3c6zcZYeC{K0JmiB(i|OHqbEY5t zWYXbpaCM1m2l4GqPw(}Px}CFrO)`ERv2b|!zJD>_^L}K~tOCM4KzRx&f{%lcjfI@hGW#oGk`;EW==RS>7J#c{1d-43G1{g5{{(t*8 zEv_7=NBPkK{ma?U9I)dXW`WcI!CQ#=@pyr?Gir7PqpsxOq8BiL2Tnp4JezqyeY8Pd zW8eulH)vcj_JpO!DkLse?uX0;(Fpl3ij}noJHuKFV18-od)WHwj}tX?#g`3ZWaS z>l3Nd@C4SNAHF*_Qpq(UH5TpACip^u_o)f?!xx$s!Jaexh2agpN(fia7w8B7##;;> z;i5k92C9U!mjZ9`kT4ZtR?uN#mr#JSl|ybH*C3+{R8YE^KT!bYUS`D&lsX?X7IrWU;|(TRq-BNJvdnPzzIg=L0fX1(MGXxk#;6tW zBbodTy)kt`g#fNA0UAq>a1s3Q<=_BKBoEAiXB1ZgpOSC*k}yxm_rhOA$pib)A=D-h zq>Y1f2d)dbePVn0_cu2&5&0fq7 znIROeh(})$W{$b(6W+n&jiTp&%bX5;VDVPwfGfZVm=&C-4k!gbU^B5_crwu{~)jcwjI5gqzdj*XH9A_=)7_HHFX>*I?gLMYM`vUTgJJ zb|nmCH`x?+B)QPd=3(A;z@$IX-cBQCmnE8Xk1H#)fr~ts^)2-~_a9G8%I-rQA8b-8 ze7zv}sd8M^UU#gjOs=P_NOHc=J?q@{z)9WMLe|nV1@PEfXh||?`ak{Vy4Gv|IrWN39_CVU_G7ypKIa~SlFnV>BRXPgI3TB z96L@;Kn+lHl0jX%urCyTaBOyiN>c~i_KMYy<9G(b4;(ZUZeVxz2H_d<@LP=91;nV) zRd@l+240Q+k0-dk9DHFo0uR_B(t1C8#Lx`292l+MjiNOS55WgugI@oGCx~XiH8M(T zYeZ>5t|-nUb_v`?CxCu1%gjg(03ZCfG5bZcqa~si*m(~<@#Y8xkBiW`))7iChu83z za5ceGD49IaiJimGx`%6b@o)`uhN(IjVeZq^0Mr8SM&mJpp6E!%FilPl)y+GhTDzM% zfO)~hfuSnY0$ve3qS5pQo6r|Nz;kTxnhh!O+#{ z5a|)Fv_N}=A3;O32OZ%Z*Nh5K1~5cF^1;a?0UEsqzQG@S%pQ}ERRi=Z{X(`+)Btb6 z3BV1qfg>*4>911ojw0A;P^mkQnK2G53jZ)24ziJ1f)}_UIHK1UxXH{E>W_hk+=2YS zOko241*hEf3Gk0>q4*fkC!9R)s}yR2mW$CaPw~}ldWALA1*hR0oXA0+z?{(uj#&AD zkNggSAM9ghFb_Q=_+d~FdWd>HYF*Gr2Y`#gcfne3EuW7jpSi)} zVct4Qe_#bCcvIF}>of6j8oXXV_<-l>1&)IiZbZL0@jon}S`B!{-|-Q0(*MWcEpiP% zWcvOuN6;10>rbTz*fAK7^oC%5b?^-<1rAt}=L^4)PeC+DJpTCZwY>2=orFL7)ROp} zHuqAV!$vh>zCM}wTMQ2OY&-q;R$_HOb@*YETJJPz;ck;wa#pY7dV8FBJ#EtWGvtZC zO>*=2Gr42lDQfu>_;zrvue)Yq-wwK+BPN|A))V>s8sdEeGyeOFsTr1{@#AOJ9Bon^ z@ctRh`|{Qzx0ErdN->j~=HoH5zr!v(zEaTo5dS88zk1(6^LsE(26zDfQ2!?k#{aWj z9DFVKL8Yk)GRC2SH=@5s69g7Gf_dOiEZ`(LKy9fBs-h467ax!qJV9O=G@6;f!IcJ8 zq7Ha69G!3*gZ7oiE1cP2?_~A_pcOX35As@vPuMK*L1qJy#pw~~1wMtxDC7os;3~X> z#>VI$ctW!afDxp!OPKjU+G%vdf1w?~Kcp^v!4`Rh4u)YdJ0GA5E$VS^n*k26>Ay+CLDneL%4P@ zD+t`ojPQ?e9fmuUGk3Teq9rJQ15FWnB0IB!tsTP@T0Tsf(G{MJfj@w@u-Dd5_92Dh zqa3QawL*1*U4-%Ii?)V_=sdndJ*Wu=%nFe=oWkAYfz8wedGH;1eFyFUc%gk+uzbM` zoBU3X(3lHOQA6}b#z*)P-wx7Tc*gJ62BEVJ(k}zpTUr~wQPv=Q;lT-*Be*XzOW1@T z!PG$YW0r8fO`w`n7aRmLIQJ3GA^72!*8v)O6VD=WgI5dT9S#b>lQ}@0E6_XS3DBx{ z=#QfOwc;K=CGe1kGF!Yc-Cq?(F;W_Q2-lz+ zSV7I_KC=AdqbcBqC7CH!8tkKD?a(e%;(2<4S>%A?p>U5M;$wpTHun}dN9*Aw{{?qw zDzyPP!O?c`4=a!-GJ9)~0ZiZtGy4l@0GJOPo(nHvGMv4R_?9rof0&L}5VOBr_wW?} z-|q38OR(fF6I>w;H$keBMS z4?P!rnb=uyX){r8H{@LINo;l{{;9{C^yge2Y?6t4Yo6~*pHOZ%u|5Sa-X+xWT&_P& zx-o;go*w@Ed}jFgcI4YZ&LD>rUTe~|H73m>=6}Ba)HL+{BjNf@M&mz$U7jQ80f_%S zaQ#+QChrjUw{nm}GQj!g?7sx}w_7ax{=fhe>HYID1IT?WPQPx5Q^cY;xhH}HcEbO! z6}-TT zxlo;25UK)w$N_aj6@l;2_a7mOilRSw7Q!r#{iN(Ao81pz^4jzUIYKnViQmBUVC6!0 zya>I~%Q^TGlLwsjgO!c`U<;mPW4{HdcNjInl^|W(7o=75&>!^+(yb2#)glx61bTyLa>4GaKI*jtT!49E5SZa@Gzs3|h1HlH_`G8l5ag|6%nK^q#Czj7 zv%&*-aWF?5JBOVqL*Wd-DcYX}%|0{3f0-3J{{a`I4oF%}4KU&@`(EG-(f=>~00tO^ zN6Bq`#jfI2NblcxB0YY6aKWyVFnfHmPA3@&O+kTNBsBdb!%<0`knSTx~1yI_mt8 z_i?g0!1MSSIr+JUNN~QeIA!vUQw6v`w>kIM9s=*@+|Rs%-QVP^r9*g6-I)J3;60XM z58yX^Kds)q98&E0@*h}l5)w$Z9b{NE)0{|JuKEM^1!R>2iww`i3{ z_=**bQlc$V56}?*)DQJyztEpU!2=sb>hFS)_=3Y5j)>5Y%lHa1E9^9u8lWCK$1+B! zd2G1$KM7ZNb`G_l8jeqNxH^;xmjPXI@z5|eycDJZoADi=h`z9Wn1-`^;Ov)BeM||} z(6{gg;0`?hBUCBO3~#ZEXlaD1|ygwy3rjyF`+r8CfIWzNEetNL{EZa1Xf_Kh$jL3 zqK|fV7=shcz89#<=L5Bkn!r4ReTHxj$8`w=qX$EzKd6!hzc3|0Bi{tbm)>B)(g1Bj zi*N;g!S9u*3E&#_|ALQkq`!7k56nN!9Pt3$qlN4_0V^oi(;po?`wj~Ft0(ni^pc(ORr3a`nj+p@Sz*2C6A7w`8p9If`S-y+j zzcm;@Gy4AGJ$`a|-)QW6yvgI(X@GZm&ok^l+`x>FT_zjYO**tGy?QgscGR0{}DX?|w>AUpR*@&;xed6RG);f=lV=hXcu#O#E`>Dyn;qT(d zbMQ7EoZS20B~~BDDVRF_Gk9GrXLj?Sd4zim_a1n625^>lBc|QKd>{1ux9I1e5ZAl6 z@_n|&Y3d#{z8k6giSa9o;r=cF^P|pp4~tXQUUB%2#_5-;@cv7J0Tf^l2r)m1n4e3% zpY;)YzlixF;QnW+_Y3tmDlg~#1~>o%xW0q`ZBH`jfsaAc@1OxXfIrYGJVNOGzZ3UY zD;m^-Szvy6!G+$S54sL77+&B;`u|R2*caR(mYLXpoPcSr7~KO0JWc(7WOIxHnFZXZ z{$HOz2JHi0A%5@xE>Z*RiB^dz(Ml3Cf#T6>i&mg}Xq0yT)C{hJD};8qB|O0n+1V!m zKOn@9-GZ0dE3!FKV@5}6XZuK1sseBDYlKe5vt!%~4*~c>?H5F7U=L;k)g#oK8DWYK zz5n@eW!(@C){NhHb9Rpx30K6YFtvFdrbfHNlx239_A?upQ47Dp{Adc96=pMr>iok{ z)i@BUjI%=F!G)@RdGNuac#fbgiVDJa@KT5_Zw4P66QX%w0_UrTprsGd8F)k!qJ!l{ z{D0ZPuEP1jIx;9&)zBNJQ3otzUa;V6kTw~Z7rqG6MzDcB8-moI_@C7duX6MT9Sa1h z!3VIy81#nB47Q!67Ff&d@XtWCqz*`GAE+lam>Xmclp_&5&=jD4-~$c!ffLdXbf18S zA@TpEMu3KZ4J?IY)Qq`7RpP%l9)|hB1|}@^SNS3SI?{$6=x_@D&Owdv!B3S!{NRQ9 zso*hk0P})jQ<)p|^V3*x!ZKz3Q~@2rqEx&}zy-$NhkHyf5VanEvp>-vbn?~C>UbW4 z4~}9^Fp~3s@hczwIOn6>JAL%qIv-V>2(OSnAWtFi0rBao-EV|*f^#7yb1h(XH3A95g%=moqCS-=cZWZ1` zqp9r$x2F>Qes;W$qp0n#v+raVd(8giaZmP?aMq8{%f}WkmG}3O?`bcE&hgTZg6ux8 z{YtC&o3A_`f9$meb^n_=7=7{16k>vTS@aJB-X{3#)i$bhBRqDAr||>u*`IEN8*S9_ z4PfrusH?Xc)&3wo_bFa;#;Ef6@qB}i+v+AC-!`fxv3cwc8r^F~y}ZoVUj>t=K96Qj zcMXiL0a*Ph{JS3!yW?iy<-zq2KcfMD-b2T--*+G}E`CNsqbip&qDwO3DQDDWyFpFD z4LTJChWE&zQb&2eD-0@1OyBHhP|$A%RbjSQm^pubb^ug_>r=p=9RQDFwUyYe^A~== z)bv~X67zMK{pXL>&JQvA6F;!BaDLjO0qV6iMw@1%0Um@GNPTp{cmk~d6s?|7(V7eo z_}mUO!R!ig_Ka3sSvbMW{Jc%n_4N5k|3qohnkaP}8>QL}qx1`VLw>hLs_%fru)BGoz(pU~Hw>*qMvH$*6AIyF9VUYv7&UY-b5v4Q)&4OfkS-~_=3 z=r$fYzpz- z4i929g@1m;TO=V!gZ$7CfB`Pq8l*8xgVc9MkluDgYgjc%*^9ETC^1l7ywDR~4%7j( z#r#*{dK_r3q6KAd!|U|((kXm>MIf7`Ih+NeL|0q?r?b}_{De<4Eah-C%_LR#y?)bzZ}f3 z+9GzL_w&&oobO9(v-1Qk!7CSh0AFvddjJ=Jvwgr^yvnHS7t`O5tpxVZyl+0U|Ew|W zL4E_L=N#PL|G@#=1h@a1fw~_tjUVFT>YpNGMC0;6C%1bu)EA@Z-N{bJ^ z(#%P(WNZ3LR}x<0|6$YZc$>!8PE)>FX$rlZrp~4`?J8oIvA125m)e!_tX=U@cK!w( z3TWie`@RlUn(5HYy$*f8?NFqj0}hQtZwos$w~15R+c{NxtW%jcIkoYUQycC(nJqZA z$mrBSk5g|mx)fQ&rDN4yx>Uo3SE)7Q(NMkIveOz;YUuj{@bbFk2vMG(y3-MovJa|sY{*tx3+QWLv5!*i#v7ft3xC0 z4sDBZC?Ucj!&8UeoN%c9VTZEp;`hhzvSmMq0^2&&t-3?KvpH19ZP(jqyGFmXE9-5$ zGXHJYjT3gATw~YzDRzzOVpo-_{2vvzt9L%TO8-ccJ1&h~R%x=HNmH*aY49r3lr%C; zD*JBUR|-N>0X=G%(rRGV4KEvv=RF@?I~wd<6mr= z{;yS@IIDbvt-Alvs&dDyy1By&FOh4$Reuh#GSjvyqPkTZ3R<<`qeZuk7G?FfDDs5` z48)=}+bpU-+oE3ME!x)C!vD2}y&x9#{hq1?87z9@NY$XQRJg~f%6KbP-p5i^eOW5L z2B|tVI91b{rK)_+RJ?{#RLzp2qkbv6eF|*xWnG=5 zPkod0s(zBzFQq!?CSrRzv}IV%x#m9+@<7k4d>^GK1@E(wRbVX~4tp;f3W-o!o5{bu}EA#aZyf z_r(K;T7DMi=Zof?l|_vD&B}b69``Oj*tfv93l{+6;{2PmJXTBazO-dbQ{kp|xgXm# z=#yR3>p3)hs6!#^_&P!c%qX=oP2(1UOaG>C~wlF5Mu88})GE z%k5%z;!^ehx$vHMX^Y9FC+}Svn#ry4W!#$5%+0y%mTQPxuV%VsSnXEwQn%Kvaq~Cm zR@iR0++2AMy0zzsTW|j7R;KH2l{)8E`VF^+UURF%1Gmobc=02*RzG&j@zf2E%B}M+ z+<39N<>TenLtnQV`MKrAQt(&&9lT>sKB>=W8KT>f=owbN_PDtsw{8+PuZB z*~{E&xzeqmxo&mu<<^O=Zn#+doVIT5s>^$=;Ff<8x2|XAJ=k2TX(XrklXsrFH24ZR zWrs`Sm$*2OT$ic-7 z+V^nkd_|`QFX(ca2rK!r>G`vsK*o&5? zqvO&vw^N#0wNKOiU(>X&KpOrhXOTYhIfD%|B$-g?U!hnqbxXzE)lAVpX0BJfF|1(9afm zJQnpKXPgPNsQEn$+G~rB@33gkbc<{~EV|dyqKf2;5t%HC_%~H|LQ?hDqg2J7OI4-= zsMG!;M@&rB$lj@VYNhJ*zvPEx@=d z<0Q?@nWWdr_+!7pEAJ%xZ}G^F9G56lFZSfrWIxsqc3{LLpqok1z;g+*ElE&=p?GaI zOVA{CV-3MyBRE5Xjs@eRgYItjO#JcD)~DBDKh8I^9>=1mL37g&E^h9zaOj($qt66a zk2(Cyqb8jMbN{KE`O=vA{P#HZdlIK@$JmoeuRfced2?Cx^J!?~;m3#UpspTDKU@Hx zJn-(L@LZeBPLsvYu4T&|a(O#+Hy39dXZVXzPEA|tRB2+}C&a1UoY{@}8@@xFS0v7x zZFZ^o8JE`Ga;b)avpcI>m&y^Vt=#e*P8<{8K5N~IKJ8YOTW%dD{?ZfNn)ca^|C&cl zN_ym|=FyG99(H?r*c_Bb_XnN#n_IW=RXQ-Ae#Qm;9c{wuHh=1`tw2iggTMx1r1 z=oW`cEOxL%!J!PD9hyx(C|%g0T%YY4VjzG>z(>rl1ySI#?@B%ZgK1e6eY--KJt; zHhDj>De9(8<&W4@bhb@)azXiaHvJ$MJg9DCmdfXUSe40SRgjle`yN;|iMSX*PE#tM=m(OB2_hqrRsW{R0Y*f)u$Y()NCm-#HXm|Yxde- zNYT{IDH^djMI$Gt=o+~osY(iZvlKZ$uWIg&u zO<+jU%X>-Md?rb?_a>?Rv?LYlnWT}ml9a-(oKMsX<*65DK1|e!C-S`SP#G1xLWp zSF$^&XB_@w_-7t7g5MZ);99Ig9cdcYp1+;%4!s!TRI3wCJ@IkkY3x*eYTx%wsGq6B z|DwLGK)kQ!TwmknUXXLT8s{N@_svGQwUTo)Cue9i&Szs7=Xw&CowzUL(WN>bwP^2A zD6zbDh)3QtJX*TaqnT?x+P>VQQd>OQwa24Hhdr9M%cIptJ?yve$oHg2vyOYz|A_pa>y%cIVdJSxl;NWLi3%%dw@xoUcJH!trYyGIMTpUUFV<3#F& zVB+4#&F)&aZl9ti+2>a4&D0vR+#2>f&y)Y!Q6rqm;l}Td-&?dxv2W>d9=a5K&ZVyO zD66KsG>Kj#whO=0<}Q^g;X*6nQss9}t)VWc{Me}*!3qzw>vaunnMEyICQL?LtQI6^!=+{z3g^}0V|dyDZ{uVRi!4FTQNy@*_D^YmZ&0;^bD8D2b-x0 zrX^~9$3!hJk%(7gf+{BCqZ^r^PH*wox}2c;Tj&=?C+PQ<32KYq)^#&`vTjiW9Ev9o z(KGao*E;mL?|z`wr(dXk-mL6Ps0C)2weL6fW|uK*X{ZTZE<8LqIdzvZi(_8@l)B(1 zJ;N6#b2WN~qch`F1g>m&Yq0a8%)e&X_2{}ohyQSDq_0yK>2+%~OEUQQVa-Ozs>rqe_k2(-n zSC)8mYrRKadp&ycKaV;Rqy6uBROkuueBYxVFF5~$Jc^I;uqV_52i~LWPLK9kr~!B` zM;PaHv_}s^J$S6}y;C^56Ui$^&gxW;!b~1@4fkkzghyR?ZLJVq$7|OFcr@vaM{}R@ zJ)e2>{W&qswSZi)iu|&e_Yy|#>ABgXVBX*8$sRrL?@@XmkKR&iRIbg}Rp9+sC9f3o zs3AFEi_MMisavP%H4a>HYZ>*;pWEGVV95dF+?v?jt%NG{Gllq_WN_<#f=f+9=o9D< zdeavLZ*Y-wTv{-OT7dXJU6(qlv}(3`Y*TDYo5IT5^sz9tLS~!ZSvdb=t?~=A zD%TCGQubRlc#%~n23fVOofSU=dWB--g9284&1zLkheg9fi2r96%{^mL>CG19oMlmu z0bmHtEt*l%qEp}oW55j_N2jv?j@W;m3a>jAU*}X!n4YS_-Ba}sxWTXrsoF;k(B@N$ z1{hLw=WYr*s}x<{mZFL?QdDDLiVlGr6swh@lliF=l9Lrg?C;n`Pp~jqS4Jo6PP1fv ztCp-I#gmogLy|hhff>9`Qp4Lx@~|uK`SK)9pPZyiosu-8LXvjV6CBNuq>C1IVn1Sc z)}cgp86_%_eVOsi616{nqLz>YV%!OOjOT8Cp9F>fFF~c3RS+9PNS8+V{R%DLXrARb4_t4o<58PgeF0YSSYs%xP13&+&!6e;<)4z|s z*{kr<8){MqX7Ahc!P9vOR?r&$47`|k(+&6m+I79MQ{JIY_2aC!a5hb)R!#SDX(WHU zQ>kUEQ_~h}M-4oTbAF*)Bk0dxKXog&kv`r*PoCYQIlp?;rmjbox_Oj;Br!eTqff+C zHO_0tBjS=;^ovu&$ zxfe*shb>*}vZSlvcj7p6x}N4t*JNIMp2rivkTnb`eQn;8Rfx)*P|Nr36YKYchvEy zE_IB4p?;w+_!#F_L*oAwI79_%fTRt?`fPfiQEsKQ;P=A$UzYmlQbsqtTbK6nyKH^e zrPsS%TD!s}KYqtY27xVt4R}>?>2m=WdJ3ofZBA7TcWU}wr{d2!HDsStj)hM3r3c9L z8#P%~r_7n1s`nXOhO@u_Wry;C2Y8k`RDOy>hlV@UriDY9D>#&t1+3O;*M~5>qKW;@ zf7^9yrCqHj*|lnb9WI7l(`wsQEt_2>IrsNIPSd;dX_~(~O{+NfCyz-}so&GIQ)$Z9 zC{0VsP#a`O(|DH+UvV28L2!VxHflH<{sP4Q0GkfBvFRvrpPrxiC+_pSv&t9_PWZ;E zU5~8zOjxyJtyMKAT2-fqRpr}Tm8A-?pWCWGzF4%+Y0-;F&ihvu4Zdknrc)L)u@-#D zEP6J~q7O|is!_(G1K(0LIX;#CELHA%sTy)IRZDiHD(_-y|EZ~3F(_4KIQRGFPgT1N zsmep#ZwyS)KaWyW_*9D0Hl|R6rl@h36t!&wZrCVAzvfHPTI&CLV1~sHB+HlBzcVZu zFNtK$YLu*Ig_E`Kmt@_vB*EoQlKK&= z3N8?LFHyg+N2f0FUvzAu+KN0-CQ;8mB`Ap;V8&~Ef|0uaT7oieO;ElW`095_(ATmF zYML=Y&rIyl!+UQDIbhnVc-aQWs|48LZ{&d0HqQSLFoD0#cwCyb0d1~7J;CanV2EyZ zW=EP-@fLhqaDpiEz@ff)?R>*a=K%4~+`KKb@OQoWyEz0t&)?!_u&X};!O=f~r&o0A zV14@B4sJM4;Bd>S?>X!IU%K(uBnEPLG@r9E8?kYrE&cR3Vx04{?=p|F5KrOM=)PXm z;Kba1J8|^MqX1%fWA1d#E0nIaWzywWE?u1pr{gW1u1pov)vsE*M%PN$nC9ua+aO*0 z>l5d7(v?;zT?v(m_2TJzL~iI$URY5+UF~_!%GY%)m980F>+1sw!c<>&4 zfuDUa$)h(3U;qY>dQm5Ad`X{A&5?tgH0U@r%5IN}(RcKtAL%`lo?wheTL(}Vv?fo~ zAYYUQOUTK;3+$phJ;0U#x3ZG|0xyFJY;xf4Y>N{(t-s7oPiIr4?M-NZr5O4c-#_U*C1@|NH;jtC%Bc9}-nbqXACQUklT7PBiy4!aDAY0B{i40vCfIxSC=c{)9Q?=<~e4_vS^b$`Az zRsU>LA?p3vuWict4>N(oHr-lc(}X{43h!;xoGQdT*x!*%HpO$+4`W_X%a=I;{r;}w zR{l1vdbfhu|HG;hovcc(M(>}UvmWekb^>wlZP7`3{bAJlmycT1d5uNJ`4*k0=a24e z(f$S&9jRbZ@oW}7HKxk^CRGJ*r)uu;RAt``<~KK0$A|E7`&8AcNzGp@Raw7K)7w%M z8A8n8Ptn-3DcZInMK9;2sQ1(qW$(}9+9|pP2KeGzvZk7nb@pYlvY$$(XHV9a;mNxF zTe6PrPrz>Mtcgil6wdu|lJZ<+Hzu*afY{ggB#ofqv!Bk>@J@>7K1l`ATd(P$r8RjPFLcavPuT2gp zkf3sQc4vSGjJ$*|*Zz1#E{s=^4tVdEjMr1038N4tn$0rM#zH`aK2AinHrS4|;p* z*`nZg&vv?Xj5>EGc=~+KdP{DP4p9%+=t93uyietvUqRfoy-bW>qt|}o(U5q0{BNA= z8PheCc()R(9c!j5lDJ;jC0)fj@o|4*nrm^-bXDw1PT;wG9nzWEr|Ws2bQSH#Yx<@u zir08Lr)wpzX~ySoHce;mMY=k)Ab0TC!Tn3)bTz7-t{>!yOyrbxzF>spfj+0{>%j!Rkpq0!cvN)`J;Fo}JE1&EsOM4Xvh*GW z`FCaGHSgW{%)9mZwOdc=c^V&es}g7bGiC*y2D#OQvwvz?w|f3UZ}8crM6*k816-- z!Krq%f_9bT%+FBVuBn{)EkCBQqbE)4ywlVa{NHP3n*N%brtCx0bedYfDCfQPyG@Of zY-;I8Z-0lre!oqU8|}s zv1-eBt4=Z_Tv6Yu8(@5YWU^`wai93sqP7>n_YPT@&lCI0xlaP)V@7zUnMGZzS>(!V z(FxA`CTXc~_)|6DWh&lvsVYF+Cvo1loRO;AJyZ3vQL5^cOx4z3Qk8D`Z$>!vCAB?x zU#@*A+P)=4B`1*&x`F+-NYT6M%mebKsE#dJ7wGp_JW7`Lp=9-3l1wg1Rzp$$*QXvR zovZ?%=;^`za=c2?a^?UnFVp{TPST$XmzA#dcfLR$O$_abB#zwR^PKTTsmXsWny$bq=_=7MT?SFl zcT89HUgt^IWx&>AKK69qm1zBWDcYZsKQnH%ZrLa=-@Szdtoajh{V3Rvv%#Xu{9; zW~HC!-p=SzzBkkWoc$+md-RO>H_-owZ189@_5b}D9&PJIf6@?~fIK&*s7Dhs({rS` z(IUAu0c>+Kb$`!eZhqHpU76ul-=S_5r|+Lsl3pOITkGkW@|awD09IP|yh{O_T-y2v zb$@@CygR$Ju$qfKG}K%4`!D^S?2~kA;eMyGuV(f)$*H#Bd`}uXb+Cw2zkK;Q*K@!{ zc4*uk=6}1n==0n5aOfHHzkF33YQmYHOs#)9(5@rb?K*pqx_^~j;}+PNUH%_Q=NupR z+C=f%w%c2qxAv)RJ2h@?+qUhdwrv}!vQ{=&rhLDB`^WFIN;YY_GjrygGxJ2S?=V8% zG!d%*%ca5ZT!P(z;sLmnk{#u8sPvp72)ca-*y{txWU&5gR_yR6d z>k~xS*@s})o-=khOS{%Ap~jD~YikF)+BLK*HQfHq+;(+_*XwArDVv$thTAU>#*aP( zr-$CRY>7>=y=)4h)}JnAQ?fkdg;eAOAKn1?y`A9vVTZu=tF3U7R!tm^#z(CWt7p{* zdi>+W{Q00ojU5*4cxzGI^A@?*SyThvFT*e%!}pJZ=i8BnJP;pD5MfsG=hSzw{7~oC@&e%p1$Za>M+I>6& z-~i78asp>Rk$)NVMpiWaAh0F4vt>o3aQ0jo?Q40 zoL|+Lx!ZgnzG&wYJh4k7)$C4`eh!4!LJzOcXZ+td^z(f7tyPF~FmS)7;NU@UY{Y!4 zWnkugyhaSIqs|v1rrv?;GvxE=A7Z`(F@L|dN4tslN*z6N_VX}*=fTGdzF+K-cQ$o@ zJaN9zqljhTfyo|)jUkrDffc5Blx31fPe*vPZ8Y&e*rPJU|EwV%Rqx|bssB7`O0G!I zlRlw?M;v6Wb^HvLifLtCasW7BLvCt+Mvr320m%~avwws2!2o?cF*;-8-|&KZPG3?E zoN|-=bz}>#FF-S#3+FfjEuce;(oy@fQ2P^Sjln}3t&8NrEb#t=?~xzRM{DUiyb5FR z4S@MA&7;+>9@q%nbQjFu-5sS@@1k`67BRmU9}#tb;|RO~)cpJ9@I;{bWrXYNXNqJl zI#P3XMrz#hNWC5#sWt7ZC{4rww563^&Ep>A1B=!DoHn(=A zbn7TO->Xj%3c(|kVheoU^a#}$9w95MgqJYc6hrxF8Sg1>Me39$0TAN ztpBVh7{8)Ruamiyz)PJEbLz`=ryj0%>eoE_`{8hV@cF$9J2f$jQ+LtxN*mDZ=;@n) z?;C;dEi)X7+smPeZHe`A7rad03 z2BPsdcx1(AYE=}xUgb4bT^|p(-`T2+)cS_Re4ZR=eaWrLO0CcH)S?ELESj^=qJs4K zjTTwt8)Z?>?iS^)MJ^!rN2IVQj@PWtugofa)2yuf&Ft7PtN(bjW(+m!S~s)SH$wBH z=C>r4hlad9{{~bmd zjYgFq4>Wp1|9{Y^Rm+X|KG6o?0FpH)_Td2w=f*QY4)DVVzB96an;ekzj6v6ykOS}v z^b4W>S0@kTGN>;&pawV~{v+c2QaJG(t|5EFRct+bxMr}!t5dkT{>vFWx8VbeFoVa; z+%QihzE)}%zL;Os_)#tR+!F`=*Mgh3#weWIW_x0^o?5vH++2)0Iy%0GJuM#nC_)_5 zrw^b8KcQylAV$NuJYzk2O`C$@_LEcMKTr(T6`jhdj_H1WeGxqr_bH zI$Sk8`dq-Hy5NArcXp1^R1bpR4`7Iu6%-P4W+iD?Y-@X_Xn(hN8|&rm?aK9zMVL~ z>z3;g(2YblL&*_%~9)`GfOwK8?`6QxRGRuRoM}KfD)@>qRJ4Ir@Mk z=sNg(UKm}<_0Xk+p)Ng~1`czf16lzpm0ImSCQqnkrTDmwHvqeFvII&>on&h7&k z{*fIYxLq?>Q`;BY6*|?fy`Ai8ON}o^FW(bCPmgrOe0;lxe6i^WF+T|HE(N$g(-fO_ z_eIO2r_Wv2rl`u?mbNj|ZqvJO#P>U^3WDuB!sTCFXT_&t<(xpPUcu!bgVQ@!7Qasx zt4bua>Z8Y^3TXP#cj@sDQrpq>Yfb?3qwB5dZ_z8T{-Wx{etrwPZY`RP->1xbvyNOa z>lF3=74^RQJhKw~XI3eEKerm1;YRTM!1J}lA2>3uSu@f6%e^w`8Jd5gP3p7!~z{I{(F>_O}dbbd#SeKjmH1A5-J@*R zJR0$UUi>TZ{nn#9pZPi`{k@AAwtIAo+hW{idkxm->qheRwsRh(JPEHyZnzujQQto~ zVmCi)hewsyd9-4cN3Hl-lV%hDWpn@?*A>@F%SI7yw>GQY8Xbrf(=4dcZUpxZvesQa!UFL@CPadN*w@AZre?l-x0s_2Pu zinv33@3N}YQnb8DR`u>~)hJ@#RM@JXaQO8TJl1a1sm^cg5q`mb0k1CiHRm7y` zX-#la;C$--Hxn@*W7JIi!_%&Fp7vqR;M#1|0&qagXru1p6Kn+zsKAx8A=sb*=k0<6 zW|IfHzGh$l1%r%x4NAJ%H!{&#lv z9SheQyhF9v)${2xp5c@DP^fXemc-~7T>a9V9(AhaQ5Uea1#BIcn5s(8Z3T}{rXEjO z4If8M&qGXBAvRYNudnWVH0?dTy@eQ$BrimJ@RPvZ#qwM-uPVp!DnGZ)b9vd*;Z^)3 z+)wJ&A+CPpfc<>m1cyg8!}%Fu#QFFo)70S*gswk^uVHc08()q8La}~{y*O1erWt{(LiG9_lx55`9|H3LL*6$ z0?!|MNtQ5tJSU=bdn;VuENc8c0QDw00`i_xvtmx=X*%mFNStH5Blt~SQkQ^u`m_&pz3KiA6$jW`~mbc-SsH3VGW zG(uym;NQ#*xBnZ@&Sx+^IR6P+-ka6LJe=O9ZZ1u)1h<#jMUHXlG4;OZEBgB@`1Dpg zwSeA!Yh$Mhl)~3XU%%oTe!NfkbFWbEL(%CLI^^yTuLr(gM9jO>qu(U}_xtR+flj~c zGG5*7#5_K|WE1V0)tQTUuUEycU~%w%4)Q=Ooct%7Hr%&qF8rOHKK}Vao4&%`=R~i| z2(JHJh?vi0Q&X^gPoq`MZ(0=%ci)nJKF$`ae$3-`7Wn(P(=wiRmjQ6}SxM2k)O* zZvqp+_xCfY1=s2>_Cs{{P|s&)qa?<5{Bu z+l`t95147HQFRA#23H99prcXc+Zz?XwvpZVM%_+@W@v@~e{N9ahs+Oz8uWatK`+n; zzYaFApU}X(8k}Ko@By<1H|iSXt6@;l^akyX;{44O=!0kjAKA4rFGsX8wt*Lqp!cm# z%u`cisIxWBdGy~Uj~1P#-hDBXP$dCFrioFQ+ic2u2<;WvVt?2#Whx*UK@%QNIuX6GGjM)x1u$K7V22S911O38r^1#SJTs_D;E%}|v zVPi^B`!jmfEH3#7{GakGdgWc}KDGaLD4O0XJOI{oK?Y-aGk&!LL+_I=UrvK)8lBObjB zBON;14s4G zSHig5ihgf`lc9VL6_3ykjsVdt3@#FA&)cspKP5KYa-?FPoK6?E}%}g5Al6qeo z?@u8Uek|fXiAn952Plc|p9TE?J<`a&8l#4BKjJlY|1!Mak-s>g#(MBRy+FE&%m?5P z4)mb@cYp&Bo`GWIjpXEop9cC5`U8AITR#}o`lLZA_VC;`gX(PLJYLT7G0iY&_9TNw zb3S)}azpR>U;|gU8ng(Pp$j{GsA-$e;>&9cW~Q!sE`pLFFZ;v13Tfbl+b6a=d6lXsd7zh9=erW)1H5W5$g8#^z53nXtAYc) z>fghw%^_ZPFneX{=T)h;X0M3t~pQnGg z3pUvL22K%7F#b5b!a+EGa={<&z&stS01imj$D=?yIDm%m58(g&>B0WQf2m0HeKT6+ zYrF~6|Cd|g{^kVQ7FI|N4Bog846?^Bn~9XFL0krQe~ zYag+1NQno4*`~vAeO0bRsTQ88ti*k4wEa24H<>d^HJBHS58lu4IFjAakt#R?%-=Us zhE|bs6^~T;^k4yc{gaP~`AcpcAoh*3+)C1e`AU2|D>J+0h>cL`&k?GGmfvPKew_&s zDjUK)V0j)hquCt|uhmPJio)q<-bU@8K#$+mrJ-$Hx{7cADm{MuB=G%Kr*hn8j%Tw| zu@jv-2d_7_AGII9{w?&o=@EEw>F;NP^Al`vsM83Cu2Js~689_fJM;o?-u!603c%%A zuG--T?b=9B-yFTJV-q`C8NQt?_uJ)21P4bRl?g8{3o| z-ac1qn^MQYoA1SQORXP%--_qfs?uTp3+_|r!%A88Cbv}`;#!r3m_G}L z*X*1{T{fWEEwiZbOpBflvEZvfr>}`e58ZAyHGW|Vi;VR1#Xg%=^ELY1TeEgtGwT`n zegN?vyVk7cbIp1_)~qJr``S&-nqR_<|JbZq`1hK`pxL`jiulUR-*e^wZ6dR8r1uF6-^4D^OY`*-xtikkG_9!YLk-2B^OZpZxi=f z!i@Ux#fY!gsMYX)r||(lIbqbGlYeu-;Vtw6^Z_Tq0o~yP8qg2y904EL#i*~~fHUNP zA6a=mJ&zO9Bg8lA0Q_LSXXpcu4O&fq@ac&`^Gh*B1uFv#p z;w-P$%5%)4==v zZpj=0nn&N?(b@~&m-QOBe;+ZwJX&8z;OA)z=C99;Pcbw;ynS=f_m|`C`F0~p^Wga> zO(*WVM`=A=->f20`bFJuWQErw_8Xj!lw&2ny-{#`VE#)bnXSOX|J;Rk|I)3z$K5)# znRuT}t*7p{!oMHDzZ>d_&=fSi-uU+>;@`_T4SkQAe;(gnk(3dtW_D@kRhNRtTpGEK zIlaLyjcDRhJ9NAa`O)=Lxzy0_q?cko?~Ic<1*e9C^*^_R->>V`xS~$oA@-fr{IHu2 z&JriyC&Ar!acEj~boyM({Kj{vgpE2++-JE3cemB9!{GcFIDBs%yPlMQ)5~PnSTy?C zc=A%7wc$Uvsq<=^c7X8*g75DW_jPK4`SUWbgD21a8~h%Q_I}T**T=#4cyqcipI2;x zRa1IfWowB?ue4Q3a#>ZDI$u2sZO&rRJ9_!_2Q2KDv*^%Ra6L8tNC%6qG_a@`HU3dX z_Q{NNC?hV(S+H?_V_9kVXL>CMVu zRzy6$#%WTqkIe8rGpQe3e#ukRc(l9<_;@3@_AD?doS3gL*u=T=#QPwV%24++Q1hL{ zenNWvJo%~jIZT|lYEr%wCap{cKR~TtVWpH9={oC;XCp~1; z-s47PBNzBKGE=+~U*KFk!V8URJ;SJw;YQT}2efQtRL1H?4Ivlgsl+T{8KZ6`Ginlk zfqB0&tGMU9Dt;P_e$cC_r>NJriG7}Hb(5OS{r-==`tsDPj@<9f{d+IS3D3N$7UtF6 z&tCO->(w`|nQy#!9Ejul{EQo3o#nlrpCrcjd%=!y0Asz(;Cq#B6yHCPeu12@sFhcq z#^8jCi9Fv)Rxk11a~YVypZ(U0N$$z6$;@_3F%ZzdA!!#w)Z1}^~d zpS(DIKx&Udf8kF?t9;ik`bZOUK#geaF9{EjI9k2Y_s3k1(zRnz`hvzc1FkQBmnglifX62*{GS6)L0ZI=uDC7<8~`29{%O$+?u!8&7Ly6d)?jYU(u}>#C|&Jem3TI zmR}+VEJ43#PQ$?*Z^B{`TJ{59?k8sYuQ8jqnLZzGZ*fnTmQ@Aw=XGgfA~=1QQ$^77 z_MiUC>Hjm7TYCJ274hulb!r`cy&c~j%8M`m8QOhfdVDLo{R;f}r}N_3NzQZl@b9A6 zPe8BVu+grh%;0?Og%_``T~)yN&r`zj`Kje$_;Ajn#pB0YJP!VD02rVrTz&`mJ$Srd z@OT@E`4m>Gem_QkKV{X8^;RvW&Tl2&|LJ6vwT)GW@a0^~hF>RF|r7G_Prc7X-1p9D($5TB>EH;`zzM8z!agH=TF?c+0F&SXv!MyJ4`nuBk5L(Rq7kk$ zDiVJH<|$?BhEHg)QN6ey-i5qS56z&aQJE_;S5yU0QCVh)@DN-kN8|@9WFtR3&tcS# zBu1q|JD8i(pyTDkRdX|aF?`!S;%~`O;_n@?83SjR-lr)ke7gACt6Sf^N|4m2OsRZY zoye!XnS7l8>tkoEPqotcbThF}V|cw6uWe80Q-uV4Z(5(0^ZY@sx!>szyu^D1eSz7l z!7i`%+ranah5m=V3g6^a>^iR=EcGfm`6uN#FMdg{vV%7of(>fcA~#gGTfzx$q7Rtg3N4}vujlt@NUFc_Up0zYhXW{u{#O`X zvnHDV?4f7@tztBf_#cyrnIz(W@FzSz_nB`x&TP|6dVv1XDnrk|qdGl7c4mL@_gur* z*X1xe-%9%Z@#y)~{ua#jF3yeShnGJSvs5#goo>ziPH*OTLz{#D>GyA-@jdzN*2foM z`_pc%Aoh>{M=ogZ)UJtG^*%NfpFaKlf>G4^woa9*;#62FE@tuOcpSQgZ^ulZ z@7V6p)G^HEwgUSXcPK3yURE@`9q@XM;Pt|{am|L~>tR$rfEen_t}=UA{K2m9{7p?k?mfGj|p+Jl>qV zXmu~n5YM~Jvdm;QhuU6;+J3JY^Epl6@~Yv{Er@=f7q1Sz{7&NiH1Tc&*H0$qt$6h! znbTVcf486dzIYWleHxq|9A5PhaC~=W`M92d?>Ba07YJUSJB{%0)HW%!4E4V#^L@m8 znXGVpKaI-DRXu@8_tE;75&H{y+%1Ya|B*ia19kd6x*zv@kPqS$|6O^`f61u4XV@ij z&!|I>i1%CI``grhctOWic)u&)`?KhQV1zeojp{s^n4U@Pr$^X3!l<|4g3x|O73)rK z!0j;}U!-?i0H2VTv;?p4Gkc!C4y0~@?r zzu2pc^cOisz!P@!>QQTY5_$t$N$@}(ueN6LYJ5EU1N4JDFX8y%E!?~4`{4rqV1O`s zfTwU8Q;Na|QvV;t^C%Je-!r_5`EKK5An#R#_nX%{MjDM2<~q?2z?)&Z$)u-B&3Ye4>z^`Iy*er z3p9Efv$|a(^@-SjSO{-l;z-V^X66E(Kletr22OM!$*(55MDn=JZ5&;+I_;JeVZ%_EV0OmMt8NN zMM=@<@>R2_eqr=_>ip&e^!3#G6=7y2dH{EK@-MF63U7C79K3vAYJDrbcwqV8g{k$# z{IA^j^pnH!5$~O%O}a;Y@A80Jeci;FJ|+csnY4SmNe5<_lxQN}JTQHQp7iT@c4jxG zXKz5<6XPq(lM^bF3rfHNqUBdENUu+=x8|bW!|N|f1y_*Fq!JExeYlz7wd39WX4HTm zX#E~yk3RoD;yr{|_fh}5(gUo0Y1D7x|1J1`^kck$#Qpk*><4+m_wzNQcz!d_eIXAx zo}m$t6H=Xm``e9gXthxV=?&VG4~lLA8!R06N_$Q!5X`E-Wdk+eAP4Q`nJgMI@{kou!n+wOW*iCl1q{$t=auTCwaUmy>JkOz|Y z@@g1(pk)oOMwA1u&<|`$1UC>34*)ON?lv6ZetiFE0!6?8UNFEPPvDv-_@ zI22%iS0pt*@gIJ#60`Vldljt2{!P2a6Zh4@`8S8!Wx%87Y=DO^ACKYna(_g#zhP6m zgY4SClQ*ME-&5}e7H}oI(!9;PrZM)*s5^)dJFabb9rJuzg5N4 z!|hS;8@er8aF_lb-~F?37R~LzynQ{3j#tKWPo1xpm*-NW)BS?8`)Jm-XXtap{QOPu z^DE8jG@sf(0G^H>{xP-QT9)UC^={v&%hdSAzu@VJ`+IM=?t{(I>GEtLR#&r^V-fuP z6qBY7F{ux=eRD(jJg|H{uzYMuVw>wzc4qbI-@heih9CZ}T}m$Ed?-BrS?YRuYWyJl z`-7v2buTp=UT>v|Uj7rD9r3$~9Pq(xR2y)9SL%I3Vz>&m{}a7`DqipQClBy^7M|Nh z9(X`**o+RakguOeu4v2SdVKBMS4Qd!)xdRqu~UbqE$L~kPl{hG_NPx zfIO;In3OejX#Ze^z5U-OnZozMs{1^ym(^b9BV&H3>6 z1(?O5-#-ZM?|`oVlzx9tdzVI);(lUwbTN;+=pwWBX!*IB!=Km9sW_FL%7b6m9boq6 zDgOIY4y|5*mOliqUI=r!^&D!K)1kUQ(d^&g**R+0YdHPQGvV~w;M1>c*KguJRSLT< z68E2P6XVD5;>^T{&#tZU@c7r@@jE23!DqwIzhRy>l>UAhIDRI4-hcG=t*QAn$pdJ1 zJMi6ije@%iL$`Zs(e-NSPcY*D*wly;|hEESnzaWiSeN*At379m5`u<0s8}}0a?KZPFr{Uy?`Id93 z(`fT;dZ5d1l{`xA*v+eM=mUoz?^&p#s;|K+v4JT~+EoohTkY1HHs z)NY>JNnDqIOPqrHCqCzU$q6RnbOb+dAg>MPXWM!GB+otJx!K&-;$oCCS6{Y5b~} z+OJ#j{2Kk6Jo1Yi;`OP3!>8)xh1zF*N)igT06WYDCnVm&YpaRckf~0{Fxg7wHe^3+}H#XPD&Gh5=q}Y7SN?>($|Zyea@6;E2F4 zXk_LHK5+F}umC=#8sq5u+tL%1!V8QB@C^Phg*iq$!2mhY|NrbCT7~ZaXLnfcO6(NM zNq-QC*7?uOIN!k6yA`aD&wq8NXcelB=PwVsAoD#tKj8H{3I<>YnggHDBjSHMJ3I_g z>^6NFsVoN~WuJ;YNpOzgvznQ6Z*c5ilraT*MS_;lz)`lJ*oIm*=o2LE1fA`+1{15To z68oVG*vHw2+ZI;ct6^20f5->KeWO^5?tiqXJp6sZi+FM1@^VZ=ucxmcU;po34Ffe^ zPWtu_cfQl3J)W<}ZGpYu`y)m@JVidBS077l zzIBFv{*qCzc%KpHjH(7EpUwCE+5yhzJ=R?KTdU{X|BL%mkx%}_aSM8d5=MSLx3Sdm zE%X$L=pkkVc^~elj9_ONIOACiT;gxyohvjB+64J(H(zs#c+Xgzzd=2`$2HI`!8SH{ zjFT-)+Dgv59nJ4Kg4}}^Sd19DH5yEx$&cU9uZQ!9^^JZx_WPMJ_bcO4zjDs-%fHai z?ijz~&-Al9jmN|MY8~QN$xeQ~AxDTDv9E+*3-kHGq<$43FN{g$*Ee!X1B*|qKG9!1 zqaV2FW3Mqiz^HiHzEAI;9q#`;+Fw$1zlDXs{>j*F z_=&xJm+|)QU{5fd{~kPkAi-X7aHS@YBA~g}*f4bY>o_|a3NM(%|$?S$(<>~o{ ztisn%?6+&fd{0@oPT=iX0pIuPafD3xc_Wz9e@)N-C2NG5_^9vUF7-dfZr=?qeVgXe zp%9lY)kf<}0rzKSZ}TnuJnPxDLF}ig$^M-jPCbu{&*zIn`|<6rI6#k&S3hq*hjz1T z?*$y+n$!+eGTAlegPn8#@af~#jT(lA-`=kN#D4Nb?B2njyY?QlHz#cPu5Bs^*7wyw z&o5|$Yp`j74IUqFUKl)nd3yUd!VY(9nFd=gyVXnOPi;M|5Yhr@IK5I0vRg7fDQ z_Y;WEad7NBziT=*e}Pfc>Ajb&HEQV^zL%UZlU_Z9_kFRN9(*xBXBmC}BKW=y8mjNiR>VfBeRK(2v~7 zV$uWZyqA2oBeO|s3NwquzkdmR&AM(Ty&h_k<}iCWlKms#pNsS~AGh+e@CIa<0|$SV z`rFN~JqP@{@{)T0)z5k8e%Y;lrF-L7u3LWnd(E#>++IBcJ~-~zuw8z67x@)7*RL+) z$s6Q^$ez5`%CEfOhEL#y{?+~JRNAk08U0!cHu#qwVzkT0OalDiU3kFbJ`G<84=@tm zkUX##uJL9Q`iinXrGPI?0zYVTdu4cyM)1(9k4NAHS5o^YdNm1e!ndwo#cPNMfgJXh zUSKX>CI2Un-d?5u-_5+jX!ZmU|HbMv2UrZABY{WJ?igKu&JMCe_>yk}zMu5;{`Z;hn}*kS%};jryd>V?{YNd2(({lgU9Ji5pFK(k zJ$U!;M=E4HS|6O>T;l%~xPJw8-x%XoTD*PNnCIDrzh@+~JVP71RVSNUuh95=y^m1Z zs}U;73{T~*aDP=J*v;(HF}S|RmzdLE?$UB%zZE{-YH0g+nb9raWLEE*Q^%?MgT^~` znO^_UAD$16f3t&Kn~xlLWbp9e<;gtAp&I!0&*gJySt9mz2iT#*JYEuf`lnW~Ux(dV zYnZ=%g{BujK685SZF+nP&3>&-iH6zquqD0zA8s$3O(TIL(Bt>xeq)R3pxZf8TJ)HD{|PQ{(knbT_;D_+ zHEYRKd^!El?Ha+||7%uu;(l&?e78Pg`4fEH9eDQR)UUm8@7vJUsqgEk@8!7~_Mz^# zMXRp^UzZO(j^6zob?{d_lj;!jW@_dDYPMdnj=qAXhY;1}2AlYe=p*N{;Ehg881E@c&>1*L8S0ut3d+Mm2p;%zs7;Al_er z0X%NrkNbIud-G3p!bI#A;Q9@IX_L#OY?Vwp3NQJ&f=NZ-Ebf(M_b7Sq-30K@Ot8-a zun+uZ;)^ErKgetXd2#{yF+RDa@@Mu3purtY=GX2$el>Ual`l^~kBSC3motFg6;P2P z0eZZE&j0Z1_%FXI`TW}Q*{>>3{rY^>uWXn3-fe!J*zMQAEq-lZOK&j6ueqcA3K{HI z@_v5xYUJ0Wvh)r4$s0Mi<>wjc4a&ZS`-58?x4@?xIdk@xO&UFctm3Gk&1j z_()&kI`>(Ut!vpUZ zlAQTyc>jU-IY(e~lzO81y=aN&KR825oL{R_%vJ~S^t@q* z`YE^8GQ*phd7ek`{bFwa0J#5=l^LG95i)FzkZo{;vQYc)KK^8nb z(fIESR<(OzRlluVL#-Ou&Z=|8ta!NL_I@y56Jb&7C-C*>E!u!~w|2HgZF+<8(e1Xt z;g5vNd*^_kf5VPEyg6;JFk1tcH*<=v11QWj!;Nf$oH%}r{`=YLT_IC(Jr9$@ z&?m1qs?b9EUt)Fi5Tg?I!beX$zi9^MuSRaD%|5;|M)gcQ=ffLz!lfUJBc!AW+ zDy3l#DI@h53|}YOFH^aI_Vo(jBMWHalz^5`2G;Lsy?J(+_OT@6#7>K#`wb`RE54!wbgXNy-K%cy|iE zq`_WxqTvZD>Qzs8fYv^C5In^Xw3qoqIKby!m=|uwUZ4Wp{s!aY|M_`|S>~GkWt^=D?z&(Dtj zN9cR-{R!r?tFuFdLecq+37O@)&)n`_cJEEc&(qbV_cdKQkPVLy{eG{f?BzMZJ}zQE zaVw{emB7c(zP<5A@cvbY7VL1y3Fg0mk1wpMLzOeq_oMCAe8CLf3AFolc5NDmcZb;j zQIgnC!rUGnp2H7p8oAS^CxdJ%)reVJcIXYu3fCXWTphlhSI5!mS6Ed9te>VayR-6I zH8#FgMtnLipILMfoIiIiUi^s`jSaD=ZgsT0oEF^%po+jY#@EHP^TB=9?NII0!+xgN1sgIKMMrdF8y z#QCj^_+%219|GuNG3?a9Hy7|4mvQmu{_)o(VO}pabvY|PvmoBQvebW( zKPti%7Ulg)!yj-zH_xrxeXI!)5-qV1+}~$w$3?YPQp_9hCxFFfpLS2LkGK zG$6x;fW$R&dq8_u2K0PYfOFCUsy02KyhF$dO#;eNKA?5rgLIk64=MPX1OZ)f`&G*V z7x*5&;GSP`PSP8I3+gO~N1#_oJH)S4-Tj(T%dZy&{Td&IH{g{|habTKpcy>cjW)R4 zr@>?J7j)z`a=^VAC~t4#5Gx`ojNJ#ZyEN&?Tu?d+-F6 zK8_B6Cop0N`+?dq2V9c-iI{D&u)pjcdq}ra`_cchp#K+a#4b|me;9j?j^l@R(f`-q zfe&z8G&7%gfc{~xIXllYJ&#ge{C@N1M`=U5D0M2uZr{Z0@ca;|O;_06h2CFza-`O^ zWRGW2=K6lPb?lK_{(WwZWj}X{k?iV6>q}SMtvt-}rZ$21uW*LX$_SP36T#UD5z3ez zzmE-W|0HK~u$yNQ^Lt~e;q%Mj($61G&aHFm?JnkZ*~4XGACHCDf1T8+pZIyI;o&{C z2A}>EJUkuPtKEQo+IV;kF1!9^m+rpJcG;%c^}Q#%^Q*FBzbI#G#KGhD5>5Y%O&wQr zI~b0yD*Qg4y^9HKs)DAs><)Xg@#ubG{%#w7yn+$JaV2_-a{N4g{^5$mIB~a^{4;0}xd9Ata|e1o_@pyf;O1q1-$zEh2MetH zh#%MuHwgZJ9}7m{-|i;o6)M79VL5h;!0r9l6|Qd}*EIA?diP+eF?tJ(zrX$fvc`@S_U@>UkxgJmCS2^#yb-aZrzg0X;Ma zIFmP^!*A#TUIditPC&-P0p(j8kY_|dUAqVLq(wlJzy{w-2UN9qK=<wg@_}B}YsP$1ac=1WtOoSIYv}#xfd4QP zFs&Oq2CL%-LIe2XXV32|^#0?_`qTeE8yTaF=zm}7|5M@r+0MQ*$6d|}+Kv7jM5B_V8UBirz1FbYy1-AGJT@XZC4_Iy8F}JN9}J|Lo+5!N+?w znL{Z)q2(Wf??cxg#2(!$HSIc))2<5%ndP&<<6p7q1{~j8{CnHr_@<>}cIOvyZzt9t zS@n1?bGFRdPiV{ReL1UkrnYJYJ-!ESugF2p%UNep1iaoy;(iF6-T-{~b{pK?BlLK@ zc@6R6+LqDpj{)x!^ULA#2T}9Cz~lRW!Bac%-(1IIvzE{0Tr|1i@YZ12TYSdv@>y?_ zogP0KzC7w+3WHJSsgKd8;N3Rifm;S zBItG8-&Ga8us(cVe`0(g{l*q%e)s>~0haF;|3+fJ+dF=D@c%<%e^wkc%M>OJ1p6mI z#|tGF9;Eh{Zo_V2V*kNZ^1yPFhHv8U1m+*`jOTvPE73=-%Ez8^{Ez+dM>Ow%N1`*F zN+$LitY=<cfG!-+8G3~`b;%)>1G<CC~Frz8bC$xh< zbdm>_E%vJq8p6D4e%$~EY={J6X0gZfm2Pb$v9e#p% zKJ|bLIC3Aa@*c0UF2^f098A#0ix&%#%&;?Q1t#D?3@9%{N!1rGP&u`gO(F%UW+jEt@ zet7*u@%!wk8m0F5eagAm){O~id_uU!GO{XM(wiZd0g zkDsS>DQZ8xe!^&*(y)Ky3w1vc9zF*<^^R9(7B?gF_;~kB&(Z6TS~YvVRhRJVE=9-B z%O0(J4m>;8nXzZq_UtS;K4xuC;nh1+!J?a)==r1AmGhYy8|wWC;y%GNv;G}`SC^Q7 zUB#@Q*_pFT$^I-4dvL&~8Sk!pz8{O;O`RV>eZN;54_r>X^^!rxg+>}Qo}HV)shrn0 zpS|1bzy@oGb8^M#0|w5&pl2YL6n}5f%P`LC`A9ARQ{*Hk?D=ibu?&Cl!Kd8t0x97l z3c)SVGuZjve-EPu&w?l1fM$3A-tPoh;Xd497&+n-xP^azgKzK*sn{cul|HB-dIojB z7JdH(IR2vJ(e*blTeJl(w&R48Jfx}UUbhQ!zF$xc>IId*d{EVM z2Q?}|5Y0NE(H{cJaW9d%EXKZYKl{Cz{h5A*-F_?a|MzCsPq}D?CWuyoH_Z9p;;h59@P6#@ zUfmEKkodQ=$M4Y-cJ}XJU;ill{^R`Z%u;2I_vU@o0K2;q{6A7&QGN%;#o4 z%bxtb?9j!}lLLN#=D#*&N6!ysMkm<|YX4@=#K5<=su{h15xl$!tons_C)06i{RViv zQDFOq?9VIBS(Hfl-^A(>SHUG^4&c0ZTFQ-4dGisaFo6lhjwE7eA%qskzK9!iS z$mcXV6l_ng+I|52Xj4AdrI?k=z#c8?-8B07g!I7AuP_&X2wrXtn)m`{W5yHj^v}1d z;ibt(ub&pIACDSJtRMPn&|B(y31Tsf9a-au^P=p=SbKy$*}Dx&L(G0%!VcZ(#Owrv z3J}w&`xum{qd^^7us?%qVFS+TtYlD3Xn_ zoA2K=gL!&#$eNwx4Y0vBazQ(Kg`5wW!v`DWC--az7wn_o*peJ?&mW#42Rpv_-EY-m z2T)Jqd=gq8|Gw|L$aUm^isU)}TXMyF=6UFKdj10QQ2R%~d32`lkKYPCvm1C|Fgz%A zKhs|J3|utn@I7=AIMdPmo&U@_q~ULW6kfF*dTQG(oLjrc!>bZY zm@gj0EO8g+3#+ql053p1{D8~h0IZ?xCtSi6!rlO8f#MVa|0iS~=qr28&anevC3%4P zpQFV8(>&bA``7#t`#v_J`%T94*MZr8djBHy{uOR>MhAQS_AX(*m->IbQj|t~gY$ob zpZ^$pec0)7qc!|Lv%QB?fdAqBE?#tN277!?_F;DqoZm%u_*l^U%<%n5jzp;S)Ce7G z6~Q@boWa65Y$H!|w$?_ME{=DpbPLYlEW#Xb0`_%+`|}X{N0&Rbdze$J8aS05u0Pbw z?9NHf)|$ten?vaLnc<0LAJ=7vommRb(1GKhK;1uqpYI(!-@b47c-|22#QxJM?9v== z)1hWI70m$0ho+w%tiS0H=V7hkER23u%|O%JRe(KuQ5KB>>%V6XZ^KlJMt1=NQ17p% zvFM!NthEL-`fGS_`HZ>eaaJZ8Uh_K4

    NACK3BI;GE(;#ZwC>wO~71{Zf276PSx3 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

    VT! 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≤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νwiM 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

    tAQRGZX>O^6M^MjTFU$_SiVZ*N(Zes48>M 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

    Hy95vw4^&?$udEB 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 diff --git a/matlab/+caffe/io.m b/matlab/+caffe/io.m index c9e07aee9e8..af8369ddfab 100644 --- a/matlab/+caffe/io.m +++ b/matlab/+caffe/io.m @@ -7,16 +7,24 @@ % load an image from disk into Caffe-supported data format % switch channels from RGB to BGR, make width the fastest dimension % and convert to single + % returns im_data in W x H x C. For colored images, C = 3 in BGR + % channels, and for grayscale images, C = 1 CHECK(ischar(im_file), 'im_file must be a string'); CHECK_FILE_EXIST(im_file); im_data = imread(im_file); - im_data = im_data(:, :, [3, 2, 1]); + % permute channels from RGB to BGR for colored images + if size(im_data, 3) == 3 + im_data = im_data(:, :, [3, 2, 1]); + end + % flip width and height to make width the fastest dimension im_data = permute(im_data, [2, 1, 3]); + % convert from uint8 to single im_data = single(im_data); end function mean_data = read_mean(mean_proto_file) % mean_data = read_mean(mean_proto_file) % read image mean data from binaryproto file + % returns mean_data in W x H x C with BGR channels CHECK(ischar(mean_proto_file), 'mean_proto_file must be a string'); CHECK_FILE_EXIST(mean_proto_file); mean_data = caffe_('read_mean', mean_proto_file); diff --git a/matlab/demo/classification_demo.m b/matlab/demo/classification_demo.m index 453582476be..2b60332970b 100644 --- a/matlab/demo/classification_demo.m +++ b/matlab/demo/classification_demo.m @@ -40,15 +40,17 @@ % [width, height, channels, images] % where width is the fastest dimension. % Here is the rough matlab for putting image data into the correct -% format: -% % convert from uint8 to single -% im = single(im); -% % reshape to a fixed size (e.g., 227x227) -% im = imresize(im, [IMAGE_DIM IMAGE_DIM], 'bilinear'); -% % permute from RGB to BGR and subtract the data mean (already in BGR) -% im = im(:,:,[3 2 1]) - data_mean; +% format in W x H x C with BGR channels: +% % permute channels from RGB to BGR +% im_data = im(:, :, [3, 2, 1]); % % flip width and height to make width the fastest dimension -% im = permute(im, [2 1 3]); +% im_data = permute(im_data, [2, 1, 3]); +% % convert from uint8 to single +% im_data = single(im_data); +% % reshape to a fixed size (e.g., 227x227). +% im_data = imresize(im_data, [IMAGE_DIM IMAGE_DIM], 'bilinear'); +% % subtract mean_data (already in W x H x C with BGR channels) +% im_data = im_data - mean_data; % If you have multiple images, cat them with cat(4, ...) @@ -94,7 +96,7 @@ toc; % do forward pass to get scores -% scores are now Width x Height x Channels x Num +% scores are now Channels x Num, where Channels == 1000 tic; % The net forward function. It takes in a cell array of N-D arrays % (where N == 4 here) containing data of input blob(s) and outputs a cell @@ -103,43 +105,43 @@ toc; scores = scores{1}; -size(scores) -scores = squeeze(scores); -scores = mean(scores,2); +scores = mean(scores, 2); % take average scores over 10 crops -[~,maxlabel] = max(scores); +[~, maxlabel] = max(scores); % call caffe.reset_all() to reset caffe caffe.reset_all(); % ------------------------------------------------------------------------ -function images = prepare_image(im) +function crops_data = prepare_image(im) % ------------------------------------------------------------------------ +% caffe/matlab/+caffe/imagenet/ilsvrc_2012_mean.mat contains mean_data that +% is already in W x H x C with BGR channels d = load('../+caffe/imagenet/ilsvrc_2012_mean.mat'); -IMAGE_MEAN = d.image_mean; +mean_data = d.mean_data; IMAGE_DIM = 256; CROPPED_DIM = 227; -% resize to fixed input size -im = single(im); -im = imresize(im, [IMAGE_DIM IMAGE_DIM], 'bilinear'); -% permute from RGB to BGR (IMAGE_MEAN is already BGR) -im = im(:,:,[3 2 1]) - IMAGE_MEAN; +% Convert an image returned by Matlab's imread to im_data in caffe's data +% format: W x H x C with BGR channels +im_data = im(:, :, [3, 2, 1]); % permute channels from RGB to BGR +im_data = permute(im_data, [2, 1, 3]); % flip width and height +im_data = single(im_data); % convert from uint8 to single +im_data = imresize(im_data, [IMAGE_DIM IMAGE_DIM], 'bilinear'); % resize im_data +im_data = im_data - mean_data; % subtract mean_data (already in W x H x C, BGR) % oversample (4 corners, center, and their x-axis flips) -images = zeros(CROPPED_DIM, CROPPED_DIM, 3, 10, 'single'); +crops_data = zeros(CROPPED_DIM, CROPPED_DIM, 3, 10, 'single'); indices = [0 IMAGE_DIM-CROPPED_DIM] + 1; -curr = 1; +n = 1; for i = indices for j = indices - images(:, :, :, curr) = ... - permute(im(i:i+CROPPED_DIM-1, j:j+CROPPED_DIM-1, :), [2 1 3]); - images(:, :, :, curr+5) = images(end:-1:1, :, :, curr); - curr = curr + 1; + crops_data(:, :, :, n) = im_data(i:i+CROPPED_DIM-1, j:j+CROPPED_DIM-1, :); + crops_data(:, :, :, n+5) = crops_data(end:-1:1, :, :, n); + n = n + 1; end end -center = floor(indices(2) / 2)+1; -images(:,:,:,5) = ... - permute(im(center:center+CROPPED_DIM-1,center:center+CROPPED_DIM-1,:), ... - [2 1 3]); -images(:,:,:,10) = images(end:-1:1, :, :, curr); +center = floor(indices(2) / 2) + 1; +crops_data(:,:,:,5) = ... + im_data(center:center+CROPPED_DIM-1,center:center+CROPPED_DIM-1,:); +crops_data(:,:,:,10) = crops_data(end:-1:1, :, :, 5); From 66583ec8a2c613fccd5037d0fd873ddd74c44864 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Fri, 29 May 2015 23:33:26 -0700 Subject: [PATCH 050/331] [travis] install lmdb through git mirror switch to github mirror of latest tag as tarball to fix stale url. --- scripts/travis/travis_install.sh | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/scripts/travis/travis_install.sh b/scripts/travis/travis_install.sh index 0e8c37861b0..b6e6f6ce821 100755 --- a/scripts/travis/travis_install.sh +++ b/scripts/travis/travis_install.sh @@ -47,12 +47,12 @@ if $WITH_CUDA; then fi # Install LMDB -LMDB_URL=ftp://ftp.openldap.org/pub/OpenLDAP/openldap-release/openldap-2.4.39.tgz -LMDB_FILE=/tmp/openldap.tgz +LMDB_URL=https://github.com/LMDB/lmdb/archive/LMDB_0.9.14.tar.gz +LMDB_FILE=/tmp/lmdb.tar.gz pushd . -curl $LMDB_URL -o $LMDB_FILE +wget $LMDB_URL -O $LMDB_FILE tar -C /tmp -xzvf $LMDB_FILE -cd /tmp/openldap*/libraries/liblmdb/ +cd /tmp/lmdb*/libraries/liblmdb/ $MAKE $MAKE install popd From a02a8ba0c252dfa41e80f8dcab071c3166ced7e3 Mon Sep 17 00:00:00 2001 From: Takuya Narihira Date: Thu, 26 Feb 2015 18:59:27 -0800 Subject: [PATCH 051/331] PReLU accumulates grad --- src/caffe/layers/prelu_layer.cpp | 1 - src/caffe/layers/prelu_layer.cu | 6 ++---- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/src/caffe/layers/prelu_layer.cpp b/src/caffe/layers/prelu_layer.cpp index 7a38f9fac80..81831755512 100644 --- a/src/caffe/layers/prelu_layer.cpp +++ b/src/caffe/layers/prelu_layer.cpp @@ -113,7 +113,6 @@ void PReLULayer::Backward_cpu(const vector*>& top, // keep top_diff unchanged. if (this->param_propagate_down_[0]) { Dtype* slope_diff = this->blobs_[0]->mutable_cpu_diff(); - caffe_set(this->blobs_[0]->count(), Dtype(0), slope_diff); for (int i = 0; i < count; ++i) { int c = (i / dim) % channels / div_factor; slope_diff[c] += top_diff[i] * bottom_data[i] * (bottom_data[i] <= 0); diff --git a/src/caffe/layers/prelu_layer.cu b/src/caffe/layers/prelu_layer.cu index dfa238d85bd..e1f20048f60 100644 --- a/src/caffe/layers/prelu_layer.cu +++ b/src/caffe/layers/prelu_layer.cu @@ -75,14 +75,12 @@ void PReLULayer::Backward_gpu(const vector*>& top, bottom_data = bottom_memory_.gpu_data(); } - // Propagte to param + // Propagate to param // Since to write bottom diff will affect top diff if top and bottom blobs // are identical (in-place computaion), we first compute param backward to // keep top_diff unchanged. if (this->param_propagate_down_[0]) { Dtype* slope_diff = this->blobs_[0]->mutable_gpu_diff(); - // slope_diff is set as 0, then accumulated over batches - caffe_gpu_set(this->blobs_[0]->count(), Dtype(0), slope_diff); int cdim = channels * dim; Dtype dsum = 0.; for (int n = 0; n < bottom[0]->num(); ++n) { @@ -106,7 +104,7 @@ void PReLULayer::Backward_gpu(const vector*>& top, } } if (channel_shared_) { - caffe_gpu_set(this->blobs_[0]->count(), Dtype(dsum), slope_diff); + caffe_gpu_add_scalar(this->blobs_[0]->count(), Dtype(dsum), slope_diff); } } // Propagate to bottom From 86758be9323a2bbefa751132dd58376e7667294d Mon Sep 17 00:00:00 2001 From: Kibum Bae Date: Tue, 2 Jun 2015 22:20:27 +0900 Subject: [PATCH 052/331] Remove unnecessary filler parameter in the sample model In bvlc_googlenet model, unnecessary filler parameters, 'std', were used for Xavier weight fillers. --- models/bvlc_googlenet/train_val.prototxt | 63 ------------------------ 1 file changed, 63 deletions(-) diff --git a/models/bvlc_googlenet/train_val.prototxt b/models/bvlc_googlenet/train_val.prototxt index 79ede2b9d9c..5dee3abe28f 100644 --- a/models/bvlc_googlenet/train_val.prototxt +++ b/models/bvlc_googlenet/train_val.prototxt @@ -61,7 +61,6 @@ layer { stride: 2 weight_filler { type: "xavier" - std: 0.1 } bias_filler { type: "constant" @@ -115,7 +114,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.1 } bias_filler { type: "constant" @@ -148,7 +146,6 @@ layer { kernel_size: 3 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -202,7 +199,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -234,7 +230,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.09 } bias_filler { type: "constant" @@ -267,7 +262,6 @@ layer { kernel_size: 3 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -299,7 +293,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.2 } bias_filler { type: "constant" @@ -332,7 +325,6 @@ layer { kernel_size: 5 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -376,7 +368,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.1 } bias_filler { type: "constant" @@ -417,7 +408,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -449,7 +439,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.09 } bias_filler { type: "constant" @@ -482,7 +471,6 @@ layer { kernel_size: 3 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -514,7 +502,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.2 } bias_filler { type: "constant" @@ -547,7 +534,6 @@ layer { kernel_size: 5 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -591,7 +577,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.1 } bias_filler { type: "constant" @@ -643,7 +628,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -675,7 +659,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.09 } bias_filler { type: "constant" @@ -708,7 +691,6 @@ layer { kernel_size: 3 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -740,7 +722,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.2 } bias_filler { type: "constant" @@ -773,7 +754,6 @@ layer { kernel_size: 5 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -817,7 +797,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.1 } bias_filler { type: "constant" @@ -869,7 +848,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.08 } bias_filler { type: "constant" @@ -900,7 +878,6 @@ layer { num_output: 1024 weight_filler { type: "xavier" - std: 0.02 } bias_filler { type: "constant" @@ -940,7 +917,6 @@ layer { num_output: 1000 weight_filler { type: "xavier" - std: 0.0009765625 } bias_filler { type: "constant" @@ -997,7 +973,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1029,7 +1004,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.09 } bias_filler { type: "constant" @@ -1062,7 +1036,6 @@ layer { kernel_size: 3 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1094,7 +1067,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.2 } bias_filler { type: "constant" @@ -1127,7 +1099,6 @@ layer { kernel_size: 5 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1171,7 +1142,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.1 } bias_filler { type: "constant" @@ -1212,7 +1182,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1244,7 +1213,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.09 } bias_filler { type: "constant" @@ -1277,7 +1245,6 @@ layer { kernel_size: 3 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1309,7 +1276,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.2 } bias_filler { type: "constant" @@ -1342,7 +1308,6 @@ layer { kernel_size: 5 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1386,7 +1351,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.1 } bias_filler { type: "constant" @@ -1427,7 +1391,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1459,7 +1422,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.09 } bias_filler { type: "constant" @@ -1492,7 +1454,6 @@ layer { kernel_size: 3 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1524,7 +1485,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.2 } bias_filler { type: "constant" @@ -1557,7 +1517,6 @@ layer { kernel_size: 5 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1601,7 +1560,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.1 } bias_filler { type: "constant" @@ -1653,7 +1611,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.08 } bias_filler { type: "constant" @@ -1684,7 +1641,6 @@ layer { num_output: 1024 weight_filler { type: "xavier" - std: 0.02 } bias_filler { type: "constant" @@ -1724,7 +1680,6 @@ layer { num_output: 1000 weight_filler { type: "xavier" - std: 0.0009765625 } bias_filler { type: "constant" @@ -1781,7 +1736,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1813,7 +1767,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.09 } bias_filler { type: "constant" @@ -1846,7 +1799,6 @@ layer { kernel_size: 3 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1878,7 +1830,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.2 } bias_filler { type: "constant" @@ -1911,7 +1862,6 @@ layer { kernel_size: 5 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -1955,7 +1905,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.1 } bias_filler { type: "constant" @@ -2007,7 +1956,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -2039,7 +1987,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.09 } bias_filler { type: "constant" @@ -2072,7 +2019,6 @@ layer { kernel_size: 3 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -2104,7 +2050,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.2 } bias_filler { type: "constant" @@ -2137,7 +2082,6 @@ layer { kernel_size: 5 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -2181,7 +2125,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.1 } bias_filler { type: "constant" @@ -2222,7 +2165,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -2254,7 +2196,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.09 } bias_filler { type: "constant" @@ -2287,7 +2228,6 @@ layer { kernel_size: 3 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -2319,7 +2259,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.2 } bias_filler { type: "constant" @@ -2352,7 +2291,6 @@ layer { kernel_size: 5 weight_filler { type: "xavier" - std: 0.03 } bias_filler { type: "constant" @@ -2396,7 +2334,6 @@ layer { kernel_size: 1 weight_filler { type: "xavier" - std: 0.1 } bias_filler { type: "constant" From 5bde20b1e9274b11b71e1c0970d4a22a5256b205 Mon Sep 17 00:00:00 2001 From: manuele Date: Fri, 29 May 2015 15:54:38 +0200 Subject: [PATCH 053/331] Filter Layer implemented --- include/caffe/common_layers.hpp | 63 +++++++++++++ src/caffe/layers/filter_layer.cpp | 128 +++++++++++++++++++++++++++ src/caffe/layers/filter_layer.cu | 70 +++++++++++++++ src/caffe/test/test_filter_layer.cpp | 128 +++++++++++++++++++++++++++ 4 files changed, 389 insertions(+) create mode 100644 src/caffe/layers/filter_layer.cpp create mode 100644 src/caffe/layers/filter_layer.cu create mode 100644 src/caffe/test/test_filter_layer.cpp diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index e6b42c14587..5d018e7389d 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -180,6 +180,69 @@ class EltwiseLayer : public Layer { bool stable_prod_grad_; }; +/** + * @brief Takes two+ Blobs, interprets last Blob as a selector and + * filter remaining Blobs accordingly with selector data (0 means that + * the corresponding item has to be filtered, non-zero means that corresponding + * item needs to stay). + */ +template +class FilterLayer : public Layer { + public: + explicit FilterLayer(const LayerParameter& param) + : Layer(param) {} + virtual void LayerSetUp(const vector*>& bottom, + const vector*>& top); + virtual void Reshape(const vector*>& bottom, + const vector*>& top); + + virtual inline const char* type() const { return "Filter"; } + virtual inline int MinBottomBlobs() const { return 2; } + virtual inline int MinTopBlobs() const { return 1; } + + protected: + /** + * @param bottom input Blob vector (length 2+) + * -# @f$ (N \times C \times H \times W) @f$ + * the inputs to be filtered @f$ x_1 @f$ + * -# ... + * -# @f$ (N \times C \times H \times W) @f$ + * the inputs to be filtered @f$ x_K @f$ + * -# @f$ (N \times 1 \times 1 \times 1) @f$ + * the selector blob + * @param top output Blob vector (length 1+) + * -# @f$ (S \times C \times H \times W) @f$ () + * the filtered output @f$ x_1 @f$ + * where S is the number of items + * that haven't been filtered + * @f$ (S \times C \times H \times W) @f$ + * the filtered output @f$ x_K @f$ + * where S is the number of items + * that haven't been filtered + */ + virtual void Forward_cpu(const vector*>& bottom, + const vector*>& top); + virtual void Forward_gpu(const vector*>& bottom, + const vector*>& top); + + /** + * @brief Computes the error gradient w.r.t. the forwarded inputs. + * + * @param top output Blob vector (length 1+), providing the error gradient with + * respect to the outputs + * @param propagate_down see Layer::Backward. + * @param bottom input Blob vector (length 2+), into which the top error + * gradient is copied + */ + virtual void Backward_cpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + virtual void Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + + bool first_reshape_; + vector indices_to_forward_; +}; + /** * @brief Reshapes the input Blob into flat vectors. * diff --git a/src/caffe/layers/filter_layer.cpp b/src/caffe/layers/filter_layer.cpp new file mode 100644 index 00000000000..d7fc59e0ebe --- /dev/null +++ b/src/caffe/layers/filter_layer.cpp @@ -0,0 +1,128 @@ +#include +#include + +#include "caffe/layer.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void FilterLayer::LayerSetUp(const vector*>& bottom, + const vector*>& top) { + CHECK_EQ(top.size(), bottom.size()-1) << + "Top.size() should be equal to bottom.size() - 1"; + first_reshape_ = true; +} + +template +void FilterLayer::Reshape(const vector*>& bottom, + const vector*>& top) { + // bottom[0...k-1] are the blobs to filter + // bottom[last] is the "selector_blob" + int selector_index = bottom.size() - 1; + for (int i = 1; i < bottom[selector_index]->num_axes(); ++i) { + CHECK_EQ(bottom[selector_index]->shape(i), 1) + << "Selector blob must have all shapes == 1 (except the first one)"; + } + for (int i = 0; i < bottom.size()-1; i++) { + CHECK_EQ(bottom[selector_index]->shape(0), bottom[i]->shape(0)) << + "Each bottom should have the same dimension as the selector blob"; + } + + const Dtype* bottom_data_selector = bottom[selector_index]->cpu_data(); + indices_to_forward_.clear(); + + // look for non-zero elements in bottom[0]. Items of each bottom that + // have the same index as the items in bottom[0] with value == non-zero + // will be forwarded + for (int item_id = 0; item_id < bottom[selector_index]->shape(0); ++item_id) { + // we don't need an offset because item size == 1 + const Dtype* tmp_data_selector = bottom_data_selector + item_id; + if (*tmp_data_selector) { + indices_to_forward_.push_back(item_id); + } + } + // only filtered items will be forwarded + int new_tops_num = indices_to_forward_.size(); + // init + if (first_reshape_) { + new_tops_num = bottom[0]->shape(0); + first_reshape_ = false; + } + for (int t = 0; t < top.size(); t++) { + int num_axes = bottom[t]->num_axes(); + vector shape_top(num_axes); + shape_top[0] = new_tops_num; + for (int ts = 1; ts < num_axes; ts++) + shape_top[ts] = bottom[t]->shape(ts); + top[t]->Reshape(shape_top); + } +} + +template +void FilterLayer::Forward_cpu(const vector*>& bottom, + const vector*>& top) { + int new_tops_num = indices_to_forward_.size(); + // forward all filtered items for all bottoms but the Selector (bottom[last]) + for (int t = 0; t < top.size(); t++) { + const Dtype* bottom_data = bottom[t]->cpu_data(); + Dtype* top_data = top[t]->mutable_cpu_data(); + int dim = bottom[t]->count() / bottom[t]->shape(0); + for (int n = 0; n < new_tops_num; n++) { + int data_offset_top = top[t]->offset(n); + int data_offset_bottom = bottom[t]->offset(indices_to_forward_[n]); + caffe_copy(dim, bottom_data + data_offset_bottom, + top_data + data_offset_top); + } + } +} + +template +void FilterLayer::Backward_cpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + if (propagate_down[bottom.size() - 1]) { + LOG(FATAL) << this->type() + << "Layer cannot backpropagate to filter index inputs"; + } + for (int i = 0; i < top.size(); i++) { + // bottom[last] is the selector and never needs backpropagation + // so we can iterate over top vector because top.size() == bottom.size() -1 + if (propagate_down[i]) { + const int dim = top[i]->count() / top[i]->shape(0); + int next_to_backward_offset = 0; + int batch_offset = 0; + int data_offset_bottom = 0; + int data_offset_top = 0; + for (int n = 0; n < bottom[i]->shape(0); n++) { + data_offset_bottom = bottom[i]->offset(n); + if (next_to_backward_offset >= indices_to_forward_.size()) { + // we already visited all items that were been forwarded, so + // just set to zero remaining ones + caffe_set(dim, Dtype(0), + bottom[i]->mutable_cpu_diff() + data_offset_bottom); + } else { + batch_offset = indices_to_forward_[next_to_backward_offset]; + if (n != batch_offset) { // this data was not been forwarded + caffe_set(dim, Dtype(0), + bottom[i]->mutable_cpu_diff() + data_offset_bottom); + } else { // this data was been forwarded + data_offset_top = top[i]->offset(next_to_backward_offset); + next_to_backward_offset++; // point to next forwarded item index + caffe_copy(dim, top[i]->mutable_cpu_diff() + data_offset_top, + bottom[i]->mutable_cpu_diff() + data_offset_bottom); + } + } + } + } + } +} + +#ifdef CPU_ONLY +STUB_GPU(FilterLayer); +#endif + +INSTANTIATE_CLASS(FilterLayer); +REGISTER_LAYER_CLASS(Filter); + +} // namespace caffe diff --git a/src/caffe/layers/filter_layer.cu b/src/caffe/layers/filter_layer.cu new file mode 100644 index 00000000000..4a9e674de1a --- /dev/null +++ b/src/caffe/layers/filter_layer.cu @@ -0,0 +1,70 @@ +#include + +#include "caffe/layer.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void FilterLayer::Forward_gpu(const vector*>& bottom, + const vector*>& top) { + int new_tops_num = indices_to_forward_.size(); + // forward all filtered items for all bottoms but the Selector (bottom[last]) + for (int t = 0; t < top.size(); t++) { + const Dtype* bottom_data = bottom[t]->gpu_data(); + Dtype* top_data = top[t]->mutable_gpu_data(); + int dim = bottom[t]->count() / bottom[t]->shape(0); + for (int n = 0; n < new_tops_num; n++) { + int data_offset_top = top[t]->offset(n); + int data_offset_bottom = bottom[t]->offset(indices_to_forward_[n]); + caffe_copy(dim, bottom_data + data_offset_bottom, + top_data + data_offset_top); + } + } +} + +template +void FilterLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + if (propagate_down[bottom.size() - 1]) { + LOG(FATAL) << this->type() + << "Layer cannot backpropagate to filter index inputs"; + } + for (int i = 0; i < top.size(); i++) { + // bottom[last] is the selector and never needs backpropagation + // so we can iterate over top vector because top.size() == bottom.size() -1 + if (propagate_down[i]) { + const int dim = top[i]->count() / top[i]->shape(0); + int next_to_backward_offset = 0; + int batch_offset = 0; + int data_offset_bottom = 0; + int data_offset_top = 0; + for (int n = 0; n < bottom[i]->shape(0); n++) { + if (next_to_backward_offset >= indices_to_forward_.size()) { + // we already visited all items that were been forwarded, so + // just set to zero remaining ones + data_offset_bottom = top[i]->offset(n); + caffe_set(dim, Dtype(0), + bottom[i]->mutable_gpu_diff() + data_offset_bottom); + } else { + batch_offset = indices_to_forward_[next_to_backward_offset]; + data_offset_bottom = top[i]->offset(n); + if (n != batch_offset) { // this data was not been forwarded + caffe_set(dim, Dtype(0), + bottom[i]->mutable_gpu_diff() + data_offset_bottom); + } else { // this data was been forwarded + data_offset_top = top[i]->offset(next_to_backward_offset); + next_to_backward_offset++; // point to next forwarded item index + caffe_copy(dim, top[i]->mutable_gpu_diff() + data_offset_top, + bottom[i]->mutable_gpu_diff() + data_offset_bottom); + } + } + } + } + } +} + +INSTANTIATE_LAYER_GPU_FUNCS(FilterLayer); + +} // namespace caffe diff --git a/src/caffe/test/test_filter_layer.cpp b/src/caffe/test/test_filter_layer.cpp new file mode 100644 index 00000000000..c641b6ef6e8 --- /dev/null +++ b/src/caffe/test/test_filter_layer.cpp @@ -0,0 +1,128 @@ +#include +#include +#include + +#include "gtest/gtest.h" + +#include "caffe/blob.hpp" +#include "caffe/common.hpp" +#include "caffe/filler.hpp" +#include "caffe/vision_layers.hpp" + +#include "caffe/test/test_caffe_main.hpp" +#include "caffe/test/test_gradient_check_util.hpp" + +namespace caffe { + +template +class FilterLayerTest : public MultiDeviceTest { + typedef typename TypeParam::Dtype Dtype; + + protected: + FilterLayerTest() + : blob_bottom_data_(new Blob(4, 3, 6, 4)), + blob_bottom_labels_(new Blob(4, 1, 1, 1)), + blob_bottom_selector_(new Blob(4, 1, 1, 1)), + blob_top_data_(new Blob()), + blob_top_labels_(new Blob()) {} + virtual void SetUp() { + // fill the values + Caffe::set_random_seed(1890); + FillerParameter filler_param; + GaussianFiller filler(filler_param); + // fill the selector blob + Dtype* bottom_data_selector_ = blob_bottom_selector_->mutable_cpu_data(); + bottom_data_selector_[0] = 0; + bottom_data_selector_[1] = 1; + bottom_data_selector_[2] = 1; + bottom_data_selector_[3] = 0; + // fill the other bottom blobs + filler.Fill(blob_bottom_data_); + for (int i = 0; i < blob_bottom_labels_->count(); ++i) { + blob_bottom_labels_->mutable_cpu_data()[i] = caffe_rng_rand() % 5; + } + blob_bottom_vec_.push_back(blob_bottom_data_); + blob_bottom_vec_.push_back(blob_bottom_labels_); + blob_bottom_vec_.push_back(blob_bottom_selector_); + blob_top_vec_.push_back(blob_top_data_); + blob_top_vec_.push_back(blob_top_labels_); + } + virtual ~FilterLayerTest() { + delete blob_bottom_data_; + delete blob_bottom_labels_; + delete blob_bottom_selector_; + delete blob_top_data_; + delete blob_top_labels_; + } + Blob* const blob_bottom_data_; + Blob* const blob_bottom_labels_; + Blob* const blob_bottom_selector_; + // blobs for the top of FilterLayer + Blob* const blob_top_data_; + Blob* const blob_top_labels_; + vector*> blob_bottom_vec_; + vector*> blob_top_vec_; +}; + +TYPED_TEST_CASE(FilterLayerTest, TestDtypesAndDevices); + +TYPED_TEST(FilterLayerTest, TestReshape) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + FilterLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Reshape(this->blob_bottom_vec_, this->blob_top_vec_); + // In the test first and last items should have been filtered + // so we just expect 2 remaining items + EXPECT_EQ(this->blob_top_data_->shape(0), 2); + EXPECT_EQ(this->blob_top_labels_->shape(0), 2); + EXPECT_GT(this->blob_bottom_data_->shape(0), + this->blob_top_data_->shape(0)); + EXPECT_GT(this->blob_bottom_labels_->shape(0), + this->blob_top_labels_->shape(0)); + for (int i = 1; i < this->blob_bottom_labels_->num_axes(); i++) { + EXPECT_EQ(this->blob_bottom_labels_->shape(i), + this->blob_top_labels_->shape(i)); + } +} + +TYPED_TEST(FilterLayerTest, TestForward) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + FilterLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Reshape(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + EXPECT_EQ(this->blob_top_labels_->data_at(0, 0, 0, 0), + this->blob_bottom_labels_->data_at(1, 0, 0, 0)); + EXPECT_EQ(this->blob_top_labels_->data_at(1, 0, 0, 0), + this->blob_bottom_labels_->data_at(2, 0, 0, 0)); + + int dim = this->blob_top_data_->count() / + this->blob_top_data_->shape(0); + const Dtype* top_data = this->blob_top_data_->cpu_data(); + const Dtype* bottom_data = this->blob_bottom_data_->cpu_data(); + // selector is 0 1 1 0, so we need to compare bottom(1,c,h,w) + // with top(0,c,h,w) and bottom(2,c,h,w) with top(1,c,h,w) + bottom_data += dim; // bottom(1,c,h,w) + for (size_t n = 0; n < dim; n++) + EXPECT_EQ(top_data[n], bottom_data[n]); + + bottom_data += dim; // bottom(2,c,h,w) + top_data += dim; // top(1,c,h,w) + for (size_t n = 0; n < dim; n++) + EXPECT_EQ(top_data[n], bottom_data[n]); +} + +TYPED_TEST(FilterLayerTest, TestGradient) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + FilterLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-3); + // check only input 0 (data) because labels and selector + // don't need backpropagation + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_, 0); +} + +} // namespace caffe From 0ccf336bfb19a82144d63399034cd886f02d8745 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Tue, 2 Jun 2015 18:21:15 -0700 Subject: [PATCH 054/331] FilterLayer cleanup and bugfix for GPU backward -caffe_set -> caffe_gpu_set (backward was segfaulting before) -remove uses of 'offset' (to support >4D blobs) -change var++ -> ++var (per Google style guide) -cleanup comments/whitespace --- include/caffe/common_layers.hpp | 6 +++--- src/caffe/layers/filter_layer.cpp | 25 ++++++++++++------------- src/caffe/layers/filter_layer.cu | 26 +++++++++++++------------- 3 files changed, 28 insertions(+), 29 deletions(-) diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index 5d018e7389d..3155b45bbbc 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -211,12 +211,12 @@ class FilterLayer : public Layer { * -# @f$ (N \times 1 \times 1 \times 1) @f$ * the selector blob * @param top output Blob vector (length 1+) - * -# @f$ (S \times C \times H \times W) @f$ () - * the filtered output @f$ x_1 @f$ + * -# @f$ (S \times C \times H \times W) @f$ () + * the filtered output @f$ x_1 @f$ * where S is the number of items * that haven't been filtered * @f$ (S \times C \times H \times W) @f$ - * the filtered output @f$ x_K @f$ + * the filtered output @f$ x_K @f$ * where S is the number of items * that haven't been filtered */ diff --git a/src/caffe/layers/filter_layer.cpp b/src/caffe/layers/filter_layer.cpp index d7fc59e0ebe..be1db32dbaa 100644 --- a/src/caffe/layers/filter_layer.cpp +++ b/src/caffe/layers/filter_layer.cpp @@ -10,8 +10,7 @@ namespace caffe { template void FilterLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { - CHECK_EQ(top.size(), bottom.size()-1) << - "Top.size() should be equal to bottom.size() - 1"; + CHECK_EQ(top.size(), bottom.size() - 1); first_reshape_ = true; } @@ -23,11 +22,11 @@ void FilterLayer::Reshape(const vector*>& bottom, int selector_index = bottom.size() - 1; for (int i = 1; i < bottom[selector_index]->num_axes(); ++i) { CHECK_EQ(bottom[selector_index]->shape(i), 1) - << "Selector blob must have all shapes == 1 (except the first one)"; + << "Selector blob dimensions must be singletons (1), except the first"; } - for (int i = 0; i < bottom.size()-1; i++) { + for (int i = 0; i < bottom.size() - 1; ++i) { CHECK_EQ(bottom[selector_index]->shape(0), bottom[i]->shape(0)) << - "Each bottom should have the same dimension as the selector blob"; + "Each bottom should have the same 0th dimension as the selector blob"; } const Dtype* bottom_data_selector = bottom[selector_index]->cpu_data(); @@ -50,11 +49,11 @@ void FilterLayer::Reshape(const vector*>& bottom, new_tops_num = bottom[0]->shape(0); first_reshape_ = false; } - for (int t = 0; t < top.size(); t++) { + for (int t = 0; t < top.size(); ++t) { int num_axes = bottom[t]->num_axes(); vector shape_top(num_axes); shape_top[0] = new_tops_num; - for (int ts = 1; ts < num_axes; ts++) + for (int ts = 1; ts < num_axes; ++ts) shape_top[ts] = bottom[t]->shape(ts); top[t]->Reshape(shape_top); } @@ -65,13 +64,13 @@ void FilterLayer::Forward_cpu(const vector*>& bottom, const vector*>& top) { int new_tops_num = indices_to_forward_.size(); // forward all filtered items for all bottoms but the Selector (bottom[last]) - for (int t = 0; t < top.size(); t++) { + for (int t = 0; t < top.size(); ++t) { const Dtype* bottom_data = bottom[t]->cpu_data(); Dtype* top_data = top[t]->mutable_cpu_data(); int dim = bottom[t]->count() / bottom[t]->shape(0); - for (int n = 0; n < new_tops_num; n++) { - int data_offset_top = top[t]->offset(n); - int data_offset_bottom = bottom[t]->offset(indices_to_forward_[n]); + for (int n = 0; n < new_tops_num; ++n) { + int data_offset_top = n * dim; + int data_offset_bottom = indices_to_forward_[n] * bottom[t]->count(1); caffe_copy(dim, bottom_data + data_offset_bottom, top_data + data_offset_top); } @@ -95,7 +94,7 @@ void FilterLayer::Backward_cpu(const vector*>& top, int data_offset_bottom = 0; int data_offset_top = 0; for (int n = 0; n < bottom[i]->shape(0); n++) { - data_offset_bottom = bottom[i]->offset(n); + data_offset_bottom = n * dim; if (next_to_backward_offset >= indices_to_forward_.size()) { // we already visited all items that were been forwarded, so // just set to zero remaining ones @@ -107,7 +106,7 @@ void FilterLayer::Backward_cpu(const vector*>& top, caffe_set(dim, Dtype(0), bottom[i]->mutable_cpu_diff() + data_offset_bottom); } else { // this data was been forwarded - data_offset_top = top[i]->offset(next_to_backward_offset); + data_offset_top = next_to_backward_offset * dim; next_to_backward_offset++; // point to next forwarded item index caffe_copy(dim, top[i]->mutable_cpu_diff() + data_offset_top, bottom[i]->mutable_cpu_diff() + data_offset_bottom); diff --git a/src/caffe/layers/filter_layer.cu b/src/caffe/layers/filter_layer.cu index 4a9e674de1a..cf929eeeadf 100644 --- a/src/caffe/layers/filter_layer.cu +++ b/src/caffe/layers/filter_layer.cu @@ -11,13 +11,13 @@ void FilterLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { int new_tops_num = indices_to_forward_.size(); // forward all filtered items for all bottoms but the Selector (bottom[last]) - for (int t = 0; t < top.size(); t++) { + for (int t = 0; t < top.size(); ++t) { const Dtype* bottom_data = bottom[t]->gpu_data(); Dtype* top_data = top[t]->mutable_gpu_data(); int dim = bottom[t]->count() / bottom[t]->shape(0); - for (int n = 0; n < new_tops_num; n++) { - int data_offset_top = top[t]->offset(n); - int data_offset_bottom = bottom[t]->offset(indices_to_forward_[n]); + for (int n = 0; n < new_tops_num; ++n) { + int data_offset_top = n * dim; + int data_offset_bottom = indices_to_forward_[n] * dim; caffe_copy(dim, bottom_data + data_offset_bottom, top_data + data_offset_top); } @@ -29,9 +29,9 @@ void FilterLayer::Backward_gpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { if (propagate_down[bottom.size() - 1]) { LOG(FATAL) << this->type() - << "Layer cannot backpropagate to filter index inputs"; + << "Layer cannot backpropagate to filter index inputs"; } - for (int i = 0; i < top.size(); i++) { + for (int i = 0; i < top.size(); ++i) { // bottom[last] is the selector and never needs backpropagation // so we can iterate over top vector because top.size() == bottom.size() -1 if (propagate_down[i]) { @@ -40,22 +40,22 @@ void FilterLayer::Backward_gpu(const vector*>& top, int batch_offset = 0; int data_offset_bottom = 0; int data_offset_top = 0; - for (int n = 0; n < bottom[i]->shape(0); n++) { + for (int n = 0; n < bottom[i]->shape(0); ++n) { if (next_to_backward_offset >= indices_to_forward_.size()) { // we already visited all items that were been forwarded, so // just set to zero remaining ones - data_offset_bottom = top[i]->offset(n); - caffe_set(dim, Dtype(0), + data_offset_bottom = n * dim; + caffe_gpu_set(dim, Dtype(0), bottom[i]->mutable_gpu_diff() + data_offset_bottom); } else { batch_offset = indices_to_forward_[next_to_backward_offset]; - data_offset_bottom = top[i]->offset(n); + data_offset_bottom = n * dim; if (n != batch_offset) { // this data was not been forwarded - caffe_set(dim, Dtype(0), + caffe_gpu_set(dim, Dtype(0), bottom[i]->mutable_gpu_diff() + data_offset_bottom); } else { // this data was been forwarded - data_offset_top = top[i]->offset(next_to_backward_offset); - next_to_backward_offset++; // point to next forwarded item index + data_offset_top = next_to_backward_offset * dim; + ++next_to_backward_offset; // point to next forwarded item index caffe_copy(dim, top[i]->mutable_gpu_diff() + data_offset_top, bottom[i]->mutable_gpu_diff() + data_offset_bottom); } From 8c72fe310977b217c47d8a505aafc5d57666a087 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Thu, 1 Jan 2015 23:07:44 -0800 Subject: [PATCH 055/331] Add LogLayer --- include/caffe/neuron_layers.hpp | 66 +++++++++++++ include/caffe/util/math_functions.hpp | 6 ++ include/caffe/util/mkl_alternate.hpp | 1 + src/caffe/layers/log_layer.cpp | 136 ++++++++++++++++++++++++++ src/caffe/proto/caffe.proto | 14 ++- src/caffe/test/test_neuron_layer.cpp | 125 +++++++++++++++++++++++ src/caffe/util/math_functions.cpp | 10 ++ src/caffe/util/math_functions.cu | 21 ++++ 8 files changed, 378 insertions(+), 1 deletion(-) create mode 100644 src/caffe/layers/log_layer.cpp diff --git a/include/caffe/neuron_layers.hpp b/include/caffe/neuron_layers.hpp index 9cf233f0eb3..c2e0774aaa2 100644 --- a/include/caffe/neuron_layers.hpp +++ b/include/caffe/neuron_layers.hpp @@ -267,6 +267,72 @@ class ExpLayer : public NeuronLayer { Dtype inner_scale_, outer_scale_; }; +/** + * @brief Computes @f$ y = log_{\gamma}(\alpha x + \beta) @f$, + * as specified by the scale @f$ \alpha @f$, shift @f$ \beta @f$, + * and base @f$ \gamma @f$. + */ +template +class LogLayer : public NeuronLayer { + public: + /** + * @param param provides LogParameter log_param, + * with LogLayer options: + * - scale (\b optional, default 1) the scale @f$ \alpha @f$ + * - shift (\b optional, default 0) the shift @f$ \beta @f$ + * - base (\b optional, default -1 for a value of @f$ e \approx 2.718 @f$) + * the base @f$ \gamma @f$ + */ + explicit LogLayer(const LayerParameter& param) + : NeuronLayer(param) {} + virtual void LayerSetUp(const vector*>& bottom, + const vector*>& top); + + virtual inline const char* type() const { return "Log"; } + + protected: + /** + * @param bottom input Blob vector (length 1) + * -# @f$ (N \times C \times H \times W) @f$ + * the inputs @f$ x @f$ + * @param top output Blob vector (length 1) + * -# @f$ (N \times C \times H \times W) @f$ + * the computed outputs @f$ + * y = log_{\gamma}(\alpha x + \beta) + * @f$ + */ + virtual void Forward_cpu(const vector*>& bottom, + const vector*>& top); + virtual void Forward_gpu(const vector*>& bottom, + const vector*>& top); + + /** + * @brief Computes the error gradient w.r.t. the exp inputs. + * + * @param top output Blob vector (length 1), providing the error gradient with + * respect to the outputs + * -# @f$ (N \times C \times H \times W) @f$ + * containing error gradients @f$ \frac{\partial E}{\partial y} @f$ + * with respect to computed outputs @f$ y @f$ + * @param propagate_down see Layer::Backward. + * @param bottom input Blob vector (length 1) + * -# @f$ (N \times C \times H \times W) @f$ + * the inputs @f$ x @f$; Backward fills their diff with + * gradients @f$ + * \frac{\partial E}{\partial x} = + * \frac{\partial E}{\partial y} y \alpha \log_e(gamma) + * @f$ if propagate_down[0] + */ + virtual void Backward_cpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + virtual void Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + + Dtype base_scale_; + Dtype input_scale_, input_shift_; + Dtype backward_num_scale_; +}; + /** * @brief Computes @f$ y = (\alpha x + \beta) ^ \gamma @f$, * as specified by the scale @f$ \alpha @f$, shift @f$ \beta @f$, diff --git a/include/caffe/util/math_functions.hpp b/include/caffe/util/math_functions.hpp index f43036fcebc..2cacd8e72cd 100644 --- a/include/caffe/util/math_functions.hpp +++ b/include/caffe/util/math_functions.hpp @@ -88,6 +88,9 @@ void caffe_rng_bernoulli(const int n, const Dtype p, unsigned int* r); template void caffe_exp(const int n, const Dtype* a, Dtype* y); +template +void caffe_log(const int n, const Dtype* a, Dtype* y); + template void caffe_abs(const int n, const Dtype* a, Dtype* y); @@ -203,6 +206,9 @@ void caffe_gpu_abs(const int n, const Dtype* a, Dtype* y); template void caffe_gpu_exp(const int n, const Dtype* a, Dtype* y); +template +void caffe_gpu_log(const int n, const Dtype* a, Dtype* y); + template void caffe_gpu_powx(const int n, const Dtype* a, const Dtype b, Dtype* y); diff --git a/include/caffe/util/mkl_alternate.hpp b/include/caffe/util/mkl_alternate.hpp index 32fdbf79932..3355b6658a3 100644 --- a/include/caffe/util/mkl_alternate.hpp +++ b/include/caffe/util/mkl_alternate.hpp @@ -33,6 +33,7 @@ extern "C" { DEFINE_VSL_UNARY_FUNC(Sqr, y[i] = a[i] * a[i]); DEFINE_VSL_UNARY_FUNC(Exp, y[i] = exp(a[i])); +DEFINE_VSL_UNARY_FUNC(Ln, y[i] = log(a[i])); DEFINE_VSL_UNARY_FUNC(Abs, y[i] = fabs(a[i])); // A simple way to define the vsl unary functions with singular parameter b. diff --git a/src/caffe/layers/log_layer.cpp b/src/caffe/layers/log_layer.cpp new file mode 100644 index 00000000000..45f73950d7e --- /dev/null +++ b/src/caffe/layers/log_layer.cpp @@ -0,0 +1,136 @@ +#include +#include + +#include "caffe/layer.hpp" +#include "caffe/neuron_layers.hpp" +#include "caffe/util/math_functions.hpp" + +namespace caffe { + +template +void LogLayer::LayerSetUp(const vector*>& bottom, + const vector*>& top) { + NeuronLayer::LayerSetUp(bottom, top); + const Dtype base = this->layer_param_.log_param().base(); + if (base != Dtype(-1)) { + CHECK_GT(base, 0) << "base must be strictly positive."; + } + // If base == -1, interpret the base as e and set log_base = 1 exactly. + // Otherwise, calculate its log explicitly. + const Dtype log_base = (base == Dtype(-1)) ? Dtype(1) : log(base); + CHECK(!isnan(log_base)) + << "NaN result: log(base) = log(" << base << ") = " << log_base; + CHECK(!isinf(log_base)) + << "Inf result: log(base) = log(" << base << ") = " << log_base; + base_scale_ = Dtype(1) / log_base; + CHECK(!isnan(base_scale_)) + << "NaN result: 1/log(base) = 1/log(" << base << ") = " << base_scale_; + CHECK(!isinf(base_scale_)) + << "Inf result: 1/log(base) = 1/log(" << base << ") = " << base_scale_; + input_scale_ = this->layer_param_.log_param().scale(); + input_shift_ = this->layer_param_.log_param().shift(); + backward_num_scale_ = input_scale_ / log_base; +} + +template +void LogLayer::Forward_cpu(const vector*>& bottom, + const vector*>& top) { + const int count = bottom[0]->count(); + const Dtype* bottom_data = bottom[0]->cpu_data(); + Dtype* top_data = top[0]->mutable_cpu_data(); + if (input_scale_ == Dtype(1) && input_shift_ == Dtype(0)) { + caffe_log(count, bottom_data, top_data); + } else { + caffe_copy(count, bottom_data, top_data); + if (input_scale_ != Dtype(1)) { + caffe_scal(count, input_scale_, top_data); + } + if (input_shift_ != Dtype(0)) { + caffe_add_scalar(count, input_shift_, top_data); + } + caffe_log(count, top_data, top_data); + } + if (base_scale_ != Dtype(1)) { + caffe_scal(count, base_scale_, top_data); + } +} + +template +void LogLayer::Backward_cpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + if (!propagate_down[0]) { return; } + const int count = bottom[0]->count(); + const Dtype* bottom_data = bottom[0]->cpu_data(); + const Dtype* top_diff = top[0]->cpu_diff(); + Dtype* bottom_diff = bottom[0]->mutable_cpu_diff(); + caffe_copy(count, bottom_data, bottom_diff); + if (input_scale_ != Dtype(1)) { + caffe_scal(count, input_scale_, bottom_diff); + } + if (input_shift_ != Dtype(0)) { + caffe_add_scalar(count, input_shift_, bottom_diff); + } + caffe_powx(count, bottom_diff, Dtype(-1), bottom_diff); + if (backward_num_scale_ != Dtype(1)) { + caffe_scal(count, backward_num_scale_, bottom_diff); + } + caffe_mul(count, top_diff, bottom_diff, bottom_diff); +} + +#ifdef CPU_ONLY +STUB_GPU(LogLayer); +#else + +template +void LogLayer::Forward_gpu(const vector*>& bottom, + const vector*>& top) { + const int count = bottom[0]->count(); + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* top_data = top[0]->mutable_gpu_data(); + if (input_scale_ == Dtype(1) && input_shift_ == Dtype(0)) { + caffe_gpu_log(count, bottom_data, top_data); + } else { + caffe_copy(count, bottom_data, top_data); + if (input_scale_ != Dtype(1)) { + caffe_gpu_scal(count, input_scale_, top_data); + } + if (input_shift_ != Dtype(0)) { + caffe_gpu_add_scalar(count, input_shift_, top_data); + } + caffe_gpu_log(count, top_data, top_data); + } + if (base_scale_ != Dtype(1)) { + caffe_gpu_scal(count, base_scale_, top_data); + } +} + +template +void LogLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + if (!propagate_down[0]) { return; } + const int count = bottom[0]->count(); + const Dtype* bottom_data = bottom[0]->gpu_data(); + const Dtype* top_diff = top[0]->gpu_diff(); + Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + caffe_copy(count, bottom_data, bottom_diff); + if (input_scale_ != Dtype(1)) { + caffe_gpu_scal(count, input_scale_, bottom_diff); + } + if (input_shift_ != Dtype(0)) { + caffe_gpu_add_scalar(count, input_shift_, bottom_diff); + } + caffe_gpu_powx(count, bottom_diff, Dtype(-1), bottom_diff); + if (backward_num_scale_ != Dtype(1)) { + caffe_gpu_scal(count, backward_num_scale_, bottom_diff); + } + caffe_gpu_mul(count, top_diff, bottom_diff, bottom_diff); +} + +INSTANTIATE_LAYER_GPU_FUNCS(LogLayer); + +#endif + +INSTANTIATE_CLASS(LogLayer); +REGISTER_LAYER_CLASS(Log); + +} // namespace caffe diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 94f713e3cb7..619642f2d32 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -269,7 +269,7 @@ message ParamSpec { // NOTE // Update the next available ID when you add a new LayerParameter field. // -// LayerParameter next available layer-specific ID: 134 (last added: reshape_param) +// LayerParameter next available layer-specific ID: 135 (last added: log_param) message LayerParameter { optional string name = 1; // the layer name optional string type = 2; // the layer type @@ -332,6 +332,7 @@ message LayerParameter { optional ImageDataParameter image_data_param = 115; optional InfogainLossParameter infogain_loss_param = 116; optional InnerProductParameter inner_product_param = 117; + optional LogParameter log_param = 134; optional LRNParameter lrn_param = 118; optional MemoryDataParameter memory_data_param = 119; optional MVNParameter mvn_param = 120; @@ -607,6 +608,17 @@ message InnerProductParameter { optional int32 axis = 5 [default = 1]; } +// Message that stores parameters used by LogLayer +message LogParameter { + // LogLayer computes outputs y = log_base(shift + scale * x), for base > 0. + // Or if base is set to the default (-1), base is set to e, + // so y = ln(shift + scale * x) = log_e(shift + scale * x) + optional float base = 1 [default = -1.0]; + optional float scale = 2 [default = 1.0]; + optional float shift = 3 [default = 0.0]; +} + +// Message that stores parameters used by LRNLayer message LRNParameter { optional uint32 local_size = 1 [default = 5]; optional float alpha = 2 [default = 1.]; diff --git a/src/caffe/test/test_neuron_layer.cpp b/src/caffe/test/test_neuron_layer.cpp index 37b54713b46..c6e4d27b903 100644 --- a/src/caffe/test/test_neuron_layer.cpp +++ b/src/caffe/test/test_neuron_layer.cpp @@ -117,6 +117,49 @@ class NeuronLayerTest : public MultiDeviceTest { + slope_data[c] * std::min(bottom_data[i], (Dtype)(0))); } } + + void LogBottomInit() { + FillerParameter filler_param; + GaussianFiller filler(filler_param); + filler.Fill(this->blob_bottom_); + Dtype* bottom_data = this->blob_bottom_->mutable_cpu_data(); + caffe_exp(this->blob_bottom_->count(), bottom_data, bottom_data); + } + + void TestLogForward(const float base, const float scale, const float shift) { + LogBottomInit(); + LayerParameter layer_param; + layer_param.mutable_log_param()->set_base(base); + layer_param.mutable_log_param()->set_scale(scale); + layer_param.mutable_log_param()->set_shift(shift); + LogLayer layer(layer_param); + layer.SetUp(blob_bottom_vec_, blob_top_vec_); + layer.Forward(blob_bottom_vec_, blob_top_vec_); + const Dtype kDelta = 2e-4; + const Dtype* bottom_data = blob_bottom_->cpu_data(); + const Dtype* top_data = blob_top_->cpu_data(); + for (int i = 0; i < blob_bottom_->count(); ++i) { + const Dtype bottom_val = bottom_data[i]; + const Dtype top_val = top_data[i]; + if (base == -1) { + EXPECT_NEAR(top_val, log(shift + scale * bottom_val), kDelta); + } else { + EXPECT_NEAR(top_val, log(shift + scale * bottom_val) / log(base), + kDelta); + } + } + } + + void TestLogGradient(const float base, const float scale, const float shift) { + LogBottomInit(); + LayerParameter layer_param; + layer_param.mutable_log_param()->set_base(base); + layer_param.mutable_log_param()->set_scale(scale); + layer_param.mutable_log_param()->set_shift(shift); + LogLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + checker.CheckGradientEltwise(&layer, blob_bottom_vec_, blob_top_vec_); + } }; TYPED_TEST_CASE(NeuronLayerTest, TestDtypesAndDevices); @@ -339,6 +382,88 @@ TYPED_TEST(NeuronLayerTest, TestExpGradientBase2Shift1Scale3) { this->TestExpGradient(kBase, kScale, kShift); } +TYPED_TEST(NeuronLayerTest, TestLogLayer) { + typedef typename TypeParam::Dtype Dtype; + // Test default base of "-1" -- should actually set base := e. + const Dtype kBase = -1; + const Dtype kScale = 1; + const Dtype kShift = 0; + this->TestLogForward(kBase, kScale, kShift); +} + +TYPED_TEST(NeuronLayerTest, TestLogGradient) { + typedef typename TypeParam::Dtype Dtype; + // Test default base of "-1" -- should actually set base := e. + const Dtype kBase = -1; + const Dtype kScale = 1; + const Dtype kShift = 0; + this->TestLogGradient(kBase, kScale, kShift); +} + +TYPED_TEST(NeuronLayerTest, TestLogLayerBase2) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kBase = 2; + const Dtype kScale = 1; + const Dtype kShift = 0; + this->TestLogForward(kBase, kScale, kShift); +} + +TYPED_TEST(NeuronLayerTest, TestLogGradientBase2) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kBase = 2; + const Dtype kScale = 1; + const Dtype kShift = 0; + this->TestLogGradient(kBase, kScale, kShift); +} + +TYPED_TEST(NeuronLayerTest, TestLogLayerBase2Shift1) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kBase = 2; + const Dtype kScale = 1; + const Dtype kShift = 1; + this->TestLogForward(kBase, kScale, kShift); +} + +TYPED_TEST(NeuronLayerTest, TestLogGradientBase2Shift1) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kBase = 2; + const Dtype kScale = 1; + const Dtype kShift = 1; + this->TestLogGradient(kBase, kScale, kShift); +} + +TYPED_TEST(NeuronLayerTest, TestLogLayerBase2Scale3) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kBase = 2; + const Dtype kScale = 3; + const Dtype kShift = 0; + this->TestLogForward(kBase, kScale, kShift); +} + +TYPED_TEST(NeuronLayerTest, TestLogGradientBase2Scale3) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kBase = 2; + const Dtype kScale = 3; + const Dtype kShift = 0; + this->TestLogGradient(kBase, kScale, kShift); +} + +TYPED_TEST(NeuronLayerTest, TestLogLayerBase2Shift1Scale3) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kBase = 2; + const Dtype kScale = 3; + const Dtype kShift = 1; + this->TestLogForward(kBase, kScale, kShift); +} + +TYPED_TEST(NeuronLayerTest, TestLogGradientBase2Shift1Scale3) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kBase = 2; + const Dtype kScale = 3; + const Dtype kShift = 1; + this->TestLogGradient(kBase, kScale, kShift); +} + TYPED_TEST(NeuronLayerTest, TestDropoutHalf) { const float kDropoutRatio = 0.5; this->TestDropoutForward(kDropoutRatio); diff --git a/src/caffe/util/math_functions.cpp b/src/caffe/util/math_functions.cpp index 13e17be582b..0aab6b17b85 100644 --- a/src/caffe/util/math_functions.cpp +++ b/src/caffe/util/math_functions.cpp @@ -206,6 +206,16 @@ void caffe_exp(const int n, const double* a, double* y) { vdExp(n, a, y); } +template <> +void caffe_log(const int n, const float* a, float* y) { + vsLn(n, a, y); +} + +template <> +void caffe_log(const int n, const double* a, double* y) { + vdLn(n, a, y); +} + template <> void caffe_abs(const int n, const float* a, float* y) { vsAbs(n, a, y); diff --git a/src/caffe/util/math_functions.cu b/src/caffe/util/math_functions.cu index 43e65eb9a69..2631a0740d6 100644 --- a/src/caffe/util/math_functions.cu +++ b/src/caffe/util/math_functions.cu @@ -324,6 +324,27 @@ void caffe_gpu_exp(const int N, const double* a, double* y) { N, a, y); } +template +__global__ void log_kernel(const int n, const Dtype* a, Dtype* y) { + CUDA_KERNEL_LOOP(index, n) { + y[index] = log(a[index]); + } +} + +template <> +void caffe_gpu_log(const int N, const float* a, float* y) { + // NOLINT_NEXT_LINE(whitespace/operators) + log_kernel<<>>( + N, a, y); +} + +template <> +void caffe_gpu_log(const int N, const double* a, double* y) { + // NOLINT_NEXT_LINE(whitespace/operators) + log_kernel<<>>( + N, a, y); +} + template __global__ void powx_kernel(const int n, const Dtype* a, const Dtype alpha, Dtype* y) { From eb442b9bc9ca206bd0606f259115f01b53144e7a Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Wed, 31 Dec 2014 18:02:12 -0800 Subject: [PATCH 056/331] FlattenLayer gets a FlattenParameter with an axis, end_axis --- src/caffe/layers/flatten_layer.cpp | 16 ++++++++-- src/caffe/proto/caffe.proto | 16 +++++++++- src/caffe/test/test_flatten_layer.cpp | 46 +++++++++++++++++++++++---- 3 files changed, 68 insertions(+), 10 deletions(-) diff --git a/src/caffe/layers/flatten_layer.cpp b/src/caffe/layers/flatten_layer.cpp index 745f271ea45..f7e5c9c2172 100644 --- a/src/caffe/layers/flatten_layer.cpp +++ b/src/caffe/layers/flatten_layer.cpp @@ -9,9 +9,19 @@ namespace caffe { template void FlattenLayer::Reshape(const vector*>& bottom, const vector*>& top) { - vector top_shape(2); - top_shape[0] = bottom[0]->num(); - top_shape[1] = bottom[0]->count() / bottom[0]->num(); + const int start_axis = bottom[0]->CanonicalAxisIndex( + this->layer_param_.flatten_param().axis()); + const int end_axis = bottom[0]->CanonicalAxisIndex( + this->layer_param_.flatten_param().end_axis()); + vector top_shape; + for (int i = 0; i < start_axis; ++i) { + top_shape.push_back(bottom[0]->shape(i)); + } + const int flattened_dim = bottom[0]->count(start_axis, end_axis + 1); + top_shape.push_back(flattened_dim); + for (int i = end_axis + 1; i < bottom[0]->num_axes(); ++i) { + top_shape.push_back(bottom[0]->shape(i)); + } top[0]->Reshape(top_shape); CHECK_EQ(top[0]->count(), bottom[0]->count()); } diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 619642f2d32..f79cf80cc05 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -269,7 +269,7 @@ message ParamSpec { // NOTE // Update the next available ID when you add a new LayerParameter field. // -// LayerParameter next available layer-specific ID: 135 (last added: log_param) +// LayerParameter next available layer-specific ID: 136 (last added: flatten_param) message LayerParameter { optional string name = 1; // the layer name optional string type = 2; // the layer type @@ -326,6 +326,7 @@ message LayerParameter { optional DummyDataParameter dummy_data_param = 109; optional EltwiseParameter eltwise_param = 110; optional ExpParameter exp_param = 111; + optional FlattenParameter flatten_param = 135; optional HDF5DataParameter hdf5_data_param = 112; optional HDF5OutputParameter hdf5_output_param = 113; optional HingeLossParameter hinge_loss_param = 114; @@ -533,6 +534,19 @@ message ExpParameter { optional float shift = 3 [default = 0.0]; } +/// Message that stores parameters used by FlattenLayer +message FlattenParameter { + // The first axis to flatten: all preceding axes are retained in the output. + // May be negative to index from the end (e.g., -1 for the last axis). + optional int32 axis = 1 [default = 1]; + + // The last axis to flatten: all following axes are retained in the output. + // May be negative to index from the end (e.g., the default -1 for the last + // axis). + optional int32 end_axis = 2 [default = -1]; +} + +// Message that stores parameters used by HDF5DataLayer message HDF5DataParameter { // Specify the data source. optional string source = 1; diff --git a/src/caffe/test/test_flatten_layer.cpp b/src/caffe/test/test_flatten_layer.cpp index 3042d293cf7..7b6757cba32 100644 --- a/src/caffe/test/test_flatten_layer.cpp +++ b/src/caffe/test/test_flatten_layer.cpp @@ -42,13 +42,48 @@ TYPED_TEST(FlattenLayerTest, TestSetup) { LayerParameter layer_param; FlattenLayer layer(layer_param); layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); - EXPECT_EQ(this->blob_top_->num(), 2); - EXPECT_EQ(this->blob_top_->channels(), 3 * 6 * 5); - EXPECT_EQ(this->blob_top_->height(), 1); - EXPECT_EQ(this->blob_top_->width(), 1); + ASSERT_EQ(this->blob_top_->num_axes(), 2); + EXPECT_EQ(this->blob_top_->shape(0), 2); + EXPECT_EQ(this->blob_top_->shape(1), 3 * 6 * 5); } -TYPED_TEST(FlattenLayerTest, Test) { +TYPED_TEST(FlattenLayerTest, TestSetupWithAxis) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + layer_param.mutable_flatten_param()->set_axis(2); + FlattenLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(this->blob_top_->num_axes(), 3); + EXPECT_EQ(this->blob_top_->shape(0), 2); + EXPECT_EQ(this->blob_top_->shape(1), 3); + EXPECT_EQ(this->blob_top_->shape(2), 6 * 5); +} + +TYPED_TEST(FlattenLayerTest, TestSetupWithEndAxis) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + layer_param.mutable_flatten_param()->set_end_axis(-2); + FlattenLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(this->blob_top_->num_axes(), 3); + EXPECT_EQ(this->blob_top_->shape(0), 2); + EXPECT_EQ(this->blob_top_->shape(1), 3 * 6); + EXPECT_EQ(this->blob_top_->shape(2), 5); +} + +TYPED_TEST(FlattenLayerTest, TestSetupWithStartAndEndAxis) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + layer_param.mutable_flatten_param()->set_axis(0); + layer_param.mutable_flatten_param()->set_end_axis(-2); + FlattenLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(this->blob_top_->num_axes(), 2); + EXPECT_EQ(this->blob_top_->shape(0), 2 * 3 * 6); + EXPECT_EQ(this->blob_top_->shape(1), 5); +} + +TYPED_TEST(FlattenLayerTest, TestForward) { typedef typename TypeParam::Dtype Dtype; LayerParameter layer_param; FlattenLayer layer(layer_param); @@ -71,5 +106,4 @@ TYPED_TEST(FlattenLayerTest, TestGradient) { this->blob_top_vec_); } - } // namespace caffe From 823d055bc927912528b0f53aa15fab6d988d4a4c Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Sun, 2 Nov 2014 17:21:37 -0800 Subject: [PATCH 057/331] Add ReductionLayer to reduce any number of "tail" axes to a scalar value Currently implements operations SUM, MEAN, ASUM (sum of absolute values), and SUMSQ (sum of squares) --- include/caffe/common_layers.hpp | 45 ++++ src/caffe/layers/reduction_layer.cpp | 132 +++++++++++ src/caffe/layers/reduction_layer.cu | 93 ++++++++ src/caffe/proto/caffe.proto | 33 ++- src/caffe/test/test_reduction_layer.cpp | 297 ++++++++++++++++++++++++ 5 files changed, 599 insertions(+), 1 deletion(-) create mode 100644 src/caffe/layers/reduction_layer.cpp create mode 100644 src/caffe/layers/reduction_layer.cu create mode 100644 src/caffe/test/test_reduction_layer.cpp diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index 3155b45bbbc..d2c0ce6d0c6 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -399,6 +399,51 @@ class ReshapeLayer : public Layer { int constant_count_; }; +/** + * @brief Compute "reductions" -- operations that return a scalar output Blob + * for an input Blob of arbitrary size, such as the sum, absolute sum, + * and sum of squares. + * + * TODO(dox): thorough documentation for Forward, Backward, and proto params. + */ +template +class ReductionLayer : public Layer { + public: + explicit ReductionLayer(const LayerParameter& param) + : Layer(param) {} + virtual void LayerSetUp(const vector*>& bottom, + const vector*>& top); + virtual void Reshape(const vector*>& bottom, + const vector*>& top); + + virtual inline const char* type() const { return "Reduction"; } + virtual inline int ExactNumBottomBlobs() const { return 1; } + virtual inline int ExactNumTopBlobs() const { return 1; } + + protected: + virtual void Forward_cpu(const vector*>& bottom, + const vector*>& top); + virtual void Forward_gpu(const vector*>& bottom, + const vector*>& top); + virtual void Backward_cpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + virtual void Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + + /// @brief the reduction operation performed by the layer + ReductionParameter_ReductionOp op_; + /// @brief a scalar coefficient applied to all outputs + Dtype coeff_; + /// @brief the index of the first input axis to reduce + int axis_; + /// @brief the number of reductions performed + int num_; + /// @brief the input size of each reduction + int dim_; + /// @brief a helper Blob used for summation (op_ == SUM) + Blob sum_multiplier_; +}; + /** * @brief Ignores bottom blobs while producing no top blobs. (This is useful * to suppress outputs during testing.) diff --git a/src/caffe/layers/reduction_layer.cpp b/src/caffe/layers/reduction_layer.cpp new file mode 100644 index 00000000000..8ae6329ebe4 --- /dev/null +++ b/src/caffe/layers/reduction_layer.cpp @@ -0,0 +1,132 @@ +#include +#include +#include + +#include "caffe/layer.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void ReductionLayer::LayerSetUp(const vector*>& bottom, + const vector*>& top) { + op_ = this->layer_param_.reduction_param().operation(); +} + +template +void ReductionLayer::Reshape(const vector*>& bottom, + const vector*>& top) { + axis_ = bottom[0]->CanonicalAxisIndex( + this->layer_param_.reduction_param().axis()); + // In the output, we'll keep all axes up to the reduction axis, but + // throw away any after that. + // Note: currently reducing along non-tail axes is not supported; otherwise, + // we'd need to also copy any axes following an "end_axis". + vector top_shape(bottom[0]->shape().begin(), + bottom[0]->shape().begin() + axis_); + top[0]->Reshape(top_shape); + num_ = bottom[0]->count(0, axis_); + dim_ = bottom[0]->count(axis_); + CHECK_EQ(num_, top[0]->count()); + if (op_ == ReductionParameter_ReductionOp_SUM || + op_ == ReductionParameter_ReductionOp_MEAN) { + vector sum_mult_shape(1, dim_); + sum_multiplier_.Reshape(sum_mult_shape); + caffe_set(dim_, Dtype(1), sum_multiplier_.mutable_cpu_data()); + } + coeff_ = this->layer_param().reduction_param().coeff(); + if (op_ == ReductionParameter_ReductionOp_MEAN) { + coeff_ /= dim_; + } +} + +template +void ReductionLayer::Forward_cpu( + const vector*>& bottom, const vector*>& top) { + const Dtype* bottom_data = bottom[0]->cpu_data(); + const Dtype* mult_data = NULL; + if (sum_multiplier_.count() > 0) { + mult_data = sum_multiplier_.cpu_data(); + } + Dtype* top_data = top[0]->mutable_cpu_data(); + for (int i = 0; i < num_; ++i) { + switch (op_) { + case ReductionParameter_ReductionOp_SUM: + case ReductionParameter_ReductionOp_MEAN: + *top_data = caffe_cpu_dot(dim_, mult_data, bottom_data); + break; + case ReductionParameter_ReductionOp_ASUM: + *top_data = caffe_cpu_asum(dim_, bottom_data); + break; + case ReductionParameter_ReductionOp_SUMSQ: + *top_data = caffe_cpu_dot(dim_, bottom_data, bottom_data); + break; + default: + LOG(FATAL) << "Unknown reduction op: " + << ReductionParameter_ReductionOp_Name(op_); + } + bottom_data += dim_; + ++top_data; + } + if (coeff_ != Dtype(1)) { + // Reset the top_data pointer. + top_data = top[0]->mutable_cpu_data(); + caffe_scal(num_, coeff_, top_data); + } +} + +template +void ReductionLayer::Backward_cpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + if (!propagate_down[0]) { return; } + // Get bottom_data, if needed. + const Dtype* bottom_data = NULL; + switch (op_) { + // Operations that don't need bottom_data + case ReductionParameter_ReductionOp_SUM: + case ReductionParameter_ReductionOp_MEAN: + break; + // Operations that need bottom_data + case ReductionParameter_ReductionOp_ASUM: + case ReductionParameter_ReductionOp_SUMSQ: + bottom_data = bottom[0]->cpu_data(); + break; + default: + LOG(FATAL) << "Unknown reduction op: " + << ReductionParameter_ReductionOp_Name(op_); + } + const Dtype* top_diff = top[0]->cpu_diff(); + Dtype* bottom_diff = bottom[0]->mutable_cpu_diff(); + for (int i = 0; i < num_; ++i) { + const Dtype bottom_coeff = (*top_diff) * coeff_; + switch (op_) { + case ReductionParameter_ReductionOp_SUM: + case ReductionParameter_ReductionOp_MEAN: + caffe_set(dim_, bottom_coeff, bottom_diff); + break; + case ReductionParameter_ReductionOp_ASUM: + caffe_cpu_sign(dim_, bottom_data, bottom_diff); + caffe_scal(dim_, bottom_coeff, bottom_diff); + break; + case ReductionParameter_ReductionOp_SUMSQ: + caffe_cpu_scale(dim_, 2 * bottom_coeff, bottom_data, bottom_diff); + break; + default: + LOG(FATAL) << "Unknown reduction op: " + << ReductionParameter_ReductionOp_Name(op_); + } + bottom_data += dim_; + bottom_diff += dim_; + ++top_diff; + } +} + +#ifdef CPU_ONLY +STUB_GPU(ReductionLayer); +#endif + +INSTANTIATE_CLASS(ReductionLayer); +REGISTER_LAYER_CLASS(Reduction); + +} // namespace caffe diff --git a/src/caffe/layers/reduction_layer.cu b/src/caffe/layers/reduction_layer.cu new file mode 100644 index 00000000000..2dbd3bc9f94 --- /dev/null +++ b/src/caffe/layers/reduction_layer.cu @@ -0,0 +1,93 @@ +#include +#include + +#include "caffe/layer.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void ReductionLayer::Forward_gpu( + const vector*>& bottom, const vector*>& top) { + const Dtype* bottom_data = bottom[0]->gpu_data(); + const Dtype* mult_data = NULL; + if (sum_multiplier_.count() > 0) { + mult_data = sum_multiplier_.gpu_data(); + } + Dtype* top_data = top[0]->mutable_cpu_data(); + for (int i = 0; i < num_; ++i) { + switch (op_) { + case ReductionParameter_ReductionOp_SUM: + case ReductionParameter_ReductionOp_MEAN: + caffe_gpu_dot(dim_, mult_data, bottom_data, top_data); + break; + case ReductionParameter_ReductionOp_ASUM: + caffe_gpu_asum(dim_, bottom_data, top_data); + break; + case ReductionParameter_ReductionOp_SUMSQ: + caffe_gpu_dot(dim_, bottom_data, bottom_data, top_data); + break; + default: + LOG(FATAL) << "Unknown reduction op: " + << ReductionParameter_ReductionOp_Name(op_); + } + bottom_data += dim_; + ++top_data; + } + if (coeff_ != Dtype(1)) { + // Reset the top_data pointer. + top_data = top[0]->mutable_gpu_data(); + caffe_gpu_scal(num_, coeff_, top_data); + } +} + +template +void ReductionLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + if (!propagate_down[0]) { return; } + // Get bottom_data, if needed. + const Dtype* bottom_data = NULL; + switch (op_) { + // Operations that don't need bottom_data + case ReductionParameter_ReductionOp_SUM: + case ReductionParameter_ReductionOp_MEAN: + break; + // Operations that need bottom_data + case ReductionParameter_ReductionOp_ASUM: + case ReductionParameter_ReductionOp_SUMSQ: + bottom_data = bottom[0]->gpu_data(); + break; + default: + LOG(FATAL) << "Unknown reduction op: " + << ReductionParameter_ReductionOp_Name(op_); + } + const Dtype* top_diff = top[0]->cpu_diff(); + Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + for (int i = 0; i < num_; ++i) { + const Dtype bottom_coeff = (*top_diff) * coeff_; + switch (op_) { + case ReductionParameter_ReductionOp_SUM: + case ReductionParameter_ReductionOp_MEAN: + caffe_gpu_set(dim_, bottom_coeff, bottom_diff); + break; + case ReductionParameter_ReductionOp_ASUM: + caffe_gpu_sign(dim_, bottom_data, bottom_diff); + caffe_gpu_scal(dim_, bottom_coeff, bottom_diff); + break; + case ReductionParameter_ReductionOp_SUMSQ: + caffe_gpu_scale(dim_, 2 * bottom_coeff, bottom_data, bottom_diff); + break; + default: + LOG(FATAL) << "Unknown reduction op: " + << ReductionParameter_ReductionOp_Name(op_); + } + bottom_data += dim_; + bottom_diff += dim_; + ++top_diff; + } +} + +INSTANTIATE_LAYER_GPU_FUNCS(ReductionLayer); + +} // namespace caffe diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index f79cf80cc05..81a8c69d88e 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -269,7 +269,7 @@ message ParamSpec { // NOTE // Update the next available ID when you add a new LayerParameter field. // -// LayerParameter next available layer-specific ID: 136 (last added: flatten_param) +// LayerParameter next available layer-specific ID: 137 (last added: reduction_param) message LayerParameter { optional string name = 1; // the layer name optional string type = 2; // the layer type @@ -341,6 +341,7 @@ message LayerParameter { optional PowerParameter power_param = 122; optional PReLUParameter prelu_param = 131; optional PythonParameter python_param = 130; + optional ReductionParameter reduction_param = 136; optional ReLUParameter relu_param = 123; optional ReshapeParameter reshape_param = 133; optional SigmoidParameter sigmoid_param = 124; @@ -704,6 +705,36 @@ message PythonParameter { optional string layer = 2; } +// Message that stores parameters used by ReductionLayer +message ReductionParameter { + enum ReductionOp { + SUM = 1; + ASUM = 2; + SUMSQ = 3; + MEAN = 4; + } + + optional ReductionOp operation = 1 [default = SUM]; // reduction operation + + // The first axis to reduce to a scalar -- may be negative to index from the + // end (e.g., -1 for the last axis). + // (Currently, only reduction along ALL "tail" axes is supported; reduction + // of axis M through N, where N < num_axes - 1, is unsupported.) + // Suppose we have an n-axis bottom Blob with shape: + // (d0, d1, d2, ..., d(m-1), dm, d(m+1), ..., d(n-1)). + // If axis == m, the output Blob will have shape + // (d0, d1, d2, ..., d(m-1)), + // and the ReductionOp operation is performed (d0 * d1 * d2 * ... * d(m-1)) + // times, each including (dm * d(m+1) * ... * d(n-1)) individual data. + // If axis == 0 (the default), the output Blob always has the empty shape + // (count 1), performing reduction across the entire input -- + // often useful for creating new loss functions. + optional int32 axis = 2 [default = 0]; + + optional float coeff = 3 [default = 1.0]; // coefficient for output +} + +// Message that stores parameters used by ReLULayer message ReLUParameter { // Allow non-zero slope for negative inputs to speed up optimization // Described in: diff --git a/src/caffe/test/test_reduction_layer.cpp b/src/caffe/test/test_reduction_layer.cpp new file mode 100644 index 00000000000..f568a18089a --- /dev/null +++ b/src/caffe/test/test_reduction_layer.cpp @@ -0,0 +1,297 @@ +#include +#include + +#include "gtest/gtest.h" + +#include "caffe/blob.hpp" +#include "caffe/common.hpp" +#include "caffe/filler.hpp" +#include "caffe/vision_layers.hpp" + +#include "caffe/test/test_caffe_main.hpp" +#include "caffe/test/test_gradient_check_util.hpp" + +namespace caffe { + +template +class ReductionLayerTest : public MultiDeviceTest { + typedef typename TypeParam::Dtype Dtype; + + protected: + ReductionLayerTest() + : blob_bottom_(new Blob(2, 3, 4, 5)), + blob_top_(new Blob()) { + // fill the values + Caffe::set_random_seed(1701); + FillerParameter filler_param; + UniformFiller filler(filler_param); + filler.Fill(this->blob_bottom_); + blob_bottom_vec_.push_back(blob_bottom_); + blob_top_vec_.push_back(blob_top_); + } + virtual ~ReductionLayerTest() { + delete blob_bottom_; + delete blob_top_; + } + + void TestForward(ReductionParameter_ReductionOp op, + float coeff = 1, int axis = 0) { + LayerParameter layer_param; + ReductionParameter* reduction_param = layer_param.mutable_reduction_param(); + reduction_param->set_operation(op); + if (coeff != 1.0) { reduction_param->set_coeff(coeff); } + if (axis != 0) { reduction_param->set_axis(axis); } + shared_ptr > layer( + new ReductionLayer(layer_param)); + layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer->Forward(this->blob_bottom_vec_, this->blob_top_vec_); + const Dtype* in_data = this->blob_bottom_->cpu_data(); + const int num = this->blob_bottom_->count(0, axis); + const int dim = this->blob_bottom_->count(axis); + for (int n = 0; n < num; ++n) { + Dtype expected_result = 0; + for (int d = 0; d < dim; ++d) { + switch (op) { + case ReductionParameter_ReductionOp_SUM: + expected_result += *in_data; + break; + case ReductionParameter_ReductionOp_MEAN: + expected_result += *in_data / dim; + break; + case ReductionParameter_ReductionOp_ASUM: + expected_result += fabs(*in_data); + break; + case ReductionParameter_ReductionOp_SUMSQ: + expected_result += (*in_data) * (*in_data); + break; + default: + LOG(FATAL) << "Unknown reduction op: " + << ReductionParameter_ReductionOp_Name(op); + } + ++in_data; + } + expected_result *= coeff; + const Dtype computed_result = this->blob_top_->cpu_data()[n]; + EXPECT_FLOAT_EQ(expected_result, computed_result) + << "Incorrect result computed with op " + << ReductionParameter_ReductionOp_Name(op) << ", coeff " << coeff; + } + } + + void TestGradient(ReductionParameter_ReductionOp op, + float coeff = 1, int axis = 0) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + ReductionParameter* reduction_param = layer_param.mutable_reduction_param(); + reduction_param->set_operation(op); + reduction_param->set_coeff(coeff); + reduction_param->set_axis(axis); + ReductionLayer layer(layer_param); + GradientChecker checker(1e-2, 2e-3); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); + } + + Blob* const blob_bottom_; + Blob* const blob_top_; + vector*> blob_bottom_vec_; + vector*> blob_top_vec_; +}; + +TYPED_TEST_CASE(ReductionLayerTest, TestDtypesAndDevices); + +TYPED_TEST(ReductionLayerTest, TestSetUp) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + shared_ptr > layer( + new ReductionLayer(layer_param)); + layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(this->blob_top_->num_axes(), 0); +} + +TYPED_TEST(ReductionLayerTest, TestSetUpWithAxis1) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + layer_param.mutable_reduction_param()->set_axis(1); + shared_ptr > layer( + new ReductionLayer(layer_param)); + layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(this->blob_top_->num_axes(), 1); + EXPECT_EQ(this->blob_top_->shape(0), 2); +} + +TYPED_TEST(ReductionLayerTest, TestSetUpWithAxis2) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + layer_param.mutable_reduction_param()->set_axis(2); + shared_ptr > layer( + new ReductionLayer(layer_param)); + layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(this->blob_top_->num_axes(), 2); + EXPECT_EQ(this->blob_top_->shape(0), 2); + EXPECT_EQ(this->blob_top_->shape(1), 3); +} + +TYPED_TEST(ReductionLayerTest, TestSum) { + const ReductionParameter_ReductionOp kOp = ReductionParameter_ReductionOp_SUM; + this->TestForward(kOp); +} + +TYPED_TEST(ReductionLayerTest, TestSumCoeff) { + const ReductionParameter_ReductionOp kOp = ReductionParameter_ReductionOp_SUM; + const float kCoeff = 2.3; + this->TestForward(kOp, kCoeff); +} + +TYPED_TEST(ReductionLayerTest, TestSumCoeffAxis1) { + const ReductionParameter_ReductionOp kOp = ReductionParameter_ReductionOp_SUM; + const float kCoeff = 2.3; + const int kAxis = 1; + this->TestForward(kOp, kCoeff, kAxis); +} + +TYPED_TEST(ReductionLayerTest, TestSumGradient) { + const ReductionParameter_ReductionOp kOp = ReductionParameter_ReductionOp_SUM; + this->TestGradient(kOp); +} + +TYPED_TEST(ReductionLayerTest, TestSumCoeffGradient) { + const ReductionParameter_ReductionOp kOp = ReductionParameter_ReductionOp_SUM; + const float kCoeff = 2.3; + this->TestGradient(kOp, kCoeff); +} + +TYPED_TEST(ReductionLayerTest, TestSumCoeffAxis1Gradient) { + const ReductionParameter_ReductionOp kOp = ReductionParameter_ReductionOp_SUM; + const float kCoeff = 2.3; + const int kAxis = 1; + this->TestGradient(kOp, kCoeff, kAxis); +} + +TYPED_TEST(ReductionLayerTest, TestMean) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_MEAN; + this->TestForward(kOp); +} + +TYPED_TEST(ReductionLayerTest, TestMeanCoeff) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_MEAN; + const float kCoeff = 2.3; + this->TestForward(kOp, kCoeff); +} + +TYPED_TEST(ReductionLayerTest, TestMeanCoeffAxis1) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_MEAN; + const float kCoeff = 2.3; + const int kAxis = 1; + this->TestForward(kOp, kCoeff, kAxis); +} + +TYPED_TEST(ReductionLayerTest, TestMeanGradient) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_MEAN; + this->TestGradient(kOp); +} + +TYPED_TEST(ReductionLayerTest, TestMeanCoeffGradient) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_MEAN; + const float kCoeff = 2.3; + this->TestGradient(kOp, kCoeff); +} + +TYPED_TEST(ReductionLayerTest, TestMeanCoeffGradientAxis1) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_MEAN; + const float kCoeff = 2.3; + const int kAxis = 1; + this->TestGradient(kOp, kCoeff, kAxis); +} + +TYPED_TEST(ReductionLayerTest, TestAbsSum) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_ASUM; + this->TestForward(kOp); +} + +TYPED_TEST(ReductionLayerTest, TestAbsSumCoeff) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_ASUM; + const float kCoeff = 2.3; + this->TestForward(kOp, kCoeff); +} + +TYPED_TEST(ReductionLayerTest, TestAbsSumCoeffAxis1) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_ASUM; + const float kCoeff = 2.3; + const int kAxis = 1; + this->TestForward(kOp, kCoeff, kAxis); +} + +TYPED_TEST(ReductionLayerTest, TestAbsSumGradient) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_ASUM; + this->TestGradient(kOp); +} + +TYPED_TEST(ReductionLayerTest, TestAbsSumCoeffGradient) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_ASUM; + const float kCoeff = 2.3; + this->TestGradient(kOp, kCoeff); +} + +TYPED_TEST(ReductionLayerTest, TestAbsSumCoeffAxis1Gradient) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_ASUM; + const float kCoeff = 2.3; + const int kAxis = 1; + this->TestGradient(kOp, kCoeff, kAxis); +} + +TYPED_TEST(ReductionLayerTest, TestSumOfSquares) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_SUMSQ; + this->TestForward(kOp); +} + +TYPED_TEST(ReductionLayerTest, TestSumOfSquaresCoeff) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_SUMSQ; + const float kCoeff = 2.3; + this->TestForward(kOp, kCoeff); +} + +TYPED_TEST(ReductionLayerTest, TestSumOfSquaresCoeffAxis1) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_SUMSQ; + const float kCoeff = 2.3; + const int kAxis = 1; + this->TestForward(kOp, kCoeff, kAxis); +} + +TYPED_TEST(ReductionLayerTest, TestSumOfSquaresGradient) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_SUMSQ; + this->TestGradient(kOp); +} + +TYPED_TEST(ReductionLayerTest, TestSumOfSquaresCoeffGradient) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_SUMSQ; + const float kCoeff = 2.3; + this->TestGradient(kOp, kCoeff); +} + +TYPED_TEST(ReductionLayerTest, TestSumOfSquaresCoeffAxis1Gradient) { + const ReductionParameter_ReductionOp kOp = + ReductionParameter_ReductionOp_SUMSQ; + const float kCoeff = 2.3; + const int kAxis = 1; + this->TestGradient(kOp, kCoeff, kAxis); +} + +} // namespace caffe From 72d70892ad489815589b8e680813c350610b3f2a Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Wed, 3 Jun 2015 10:46:53 -0700 Subject: [PATCH 058/331] [bug] fix double instantiation of GPU methods in LogLayer --- src/caffe/layers/log_layer.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/caffe/layers/log_layer.cpp b/src/caffe/layers/log_layer.cpp index 45f73950d7e..1e86a751e9e 100644 --- a/src/caffe/layers/log_layer.cpp +++ b/src/caffe/layers/log_layer.cpp @@ -126,8 +126,6 @@ void LogLayer::Backward_gpu(const vector*>& top, caffe_gpu_mul(count, top_diff, bottom_diff, bottom_diff); } -INSTANTIATE_LAYER_GPU_FUNCS(LogLayer); - #endif INSTANTIATE_CLASS(LogLayer); From f8efc628dfb6cd979f3aeb798099dcbb6f119694 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Malte=20St=C3=A6r=20Nissen?= Date: Thu, 4 Jun 2015 11:13:45 +0200 Subject: [PATCH 059/331] LogLayer gpu functionality moved to .cu file --- src/caffe/layers/log_layer.cpp | 47 ---------------------------- src/caffe/layers/log_layer.cu | 57 ++++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 47 deletions(-) create mode 100644 src/caffe/layers/log_layer.cu diff --git a/src/caffe/layers/log_layer.cpp b/src/caffe/layers/log_layer.cpp index 1e86a751e9e..55a227f6226 100644 --- a/src/caffe/layers/log_layer.cpp +++ b/src/caffe/layers/log_layer.cpp @@ -79,53 +79,6 @@ void LogLayer::Backward_cpu(const vector*>& top, #ifdef CPU_ONLY STUB_GPU(LogLayer); -#else - -template -void LogLayer::Forward_gpu(const vector*>& bottom, - const vector*>& top) { - const int count = bottom[0]->count(); - const Dtype* bottom_data = bottom[0]->gpu_data(); - Dtype* top_data = top[0]->mutable_gpu_data(); - if (input_scale_ == Dtype(1) && input_shift_ == Dtype(0)) { - caffe_gpu_log(count, bottom_data, top_data); - } else { - caffe_copy(count, bottom_data, top_data); - if (input_scale_ != Dtype(1)) { - caffe_gpu_scal(count, input_scale_, top_data); - } - if (input_shift_ != Dtype(0)) { - caffe_gpu_add_scalar(count, input_shift_, top_data); - } - caffe_gpu_log(count, top_data, top_data); - } - if (base_scale_ != Dtype(1)) { - caffe_gpu_scal(count, base_scale_, top_data); - } -} - -template -void LogLayer::Backward_gpu(const vector*>& top, - const vector& propagate_down, const vector*>& bottom) { - if (!propagate_down[0]) { return; } - const int count = bottom[0]->count(); - const Dtype* bottom_data = bottom[0]->gpu_data(); - const Dtype* top_diff = top[0]->gpu_diff(); - Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - caffe_copy(count, bottom_data, bottom_diff); - if (input_scale_ != Dtype(1)) { - caffe_gpu_scal(count, input_scale_, bottom_diff); - } - if (input_shift_ != Dtype(0)) { - caffe_gpu_add_scalar(count, input_shift_, bottom_diff); - } - caffe_gpu_powx(count, bottom_diff, Dtype(-1), bottom_diff); - if (backward_num_scale_ != Dtype(1)) { - caffe_gpu_scal(count, backward_num_scale_, bottom_diff); - } - caffe_gpu_mul(count, top_diff, bottom_diff, bottom_diff); -} - #endif INSTANTIATE_CLASS(LogLayer); diff --git a/src/caffe/layers/log_layer.cu b/src/caffe/layers/log_layer.cu new file mode 100644 index 00000000000..847c86cd10c --- /dev/null +++ b/src/caffe/layers/log_layer.cu @@ -0,0 +1,57 @@ +#include +#include + +#include "caffe/layer.hpp" +#include "caffe/neuron_layers.hpp" +#include "caffe/util/math_functions.hpp" + +namespace caffe { + +template +void LogLayer::Forward_gpu(const vector*>& bottom, + const vector*>& top) { + const int count = bottom[0]->count(); + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* top_data = top[0]->mutable_gpu_data(); + if (input_scale_ == Dtype(1) && input_shift_ == Dtype(0)) { + caffe_gpu_log(count, bottom_data, top_data); + } else { + caffe_copy(count, bottom_data, top_data); + if (input_scale_ != Dtype(1)) { + caffe_gpu_scal(count, input_scale_, top_data); + } + if (input_shift_ != Dtype(0)) { + caffe_gpu_add_scalar(count, input_shift_, top_data); + } + caffe_gpu_log(count, top_data, top_data); + } + if (base_scale_ != Dtype(1)) { + caffe_gpu_scal(count, base_scale_, top_data); + } +} + +template +void LogLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + if (!propagate_down[0]) { return; } + const int count = bottom[0]->count(); + const Dtype* bottom_data = bottom[0]->gpu_data(); + const Dtype* top_diff = top[0]->gpu_diff(); + Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + caffe_copy(count, bottom_data, bottom_diff); + if (input_scale_ != Dtype(1)) { + caffe_gpu_scal(count, input_scale_, bottom_diff); + } + if (input_shift_ != Dtype(0)) { + caffe_gpu_add_scalar(count, input_shift_, bottom_diff); + } + caffe_gpu_powx(count, bottom_diff, Dtype(-1), bottom_diff); + if (backward_num_scale_ != Dtype(1)) { + caffe_gpu_scal(count, backward_num_scale_, bottom_diff); + } + caffe_gpu_mul(count, top_diff, bottom_diff, bottom_diff); +} + +INSTANTIATE_LAYER_GPU_FUNCS(LogLayer); + +} // namespace caffe From eeb428e38029003572ca52182e11e62ab33e4e50 Mon Sep 17 00:00:00 2001 From: Sergio Guadarrama Date: Mon, 30 Mar 2015 17:29:50 -0700 Subject: [PATCH 060/331] Split db.hpp into leveldb_db.hpp and lmdb_db.hpp --- include/caffe/util/db.hpp | 136 ------------------------------ include/caffe/util/db_leveldb.hpp | 73 ++++++++++++++++ include/caffe/util/db_lmdb.hpp | 91 ++++++++++++++++++++ src/caffe/util/db.cpp | 57 +------------ src/caffe/util/db_leveldb.cpp | 21 +++++ src/caffe/util/db_lmdb.cpp | 51 +++++++++++ 6 files changed, 238 insertions(+), 191 deletions(-) create mode 100644 include/caffe/util/db_leveldb.hpp create mode 100644 include/caffe/util/db_lmdb.hpp create mode 100644 src/caffe/util/db_leveldb.cpp create mode 100644 src/caffe/util/db_lmdb.cpp diff --git a/include/caffe/util/db.hpp b/include/caffe/util/db.hpp index afdb8d2c4f8..59ec3d390ba 100644 --- a/include/caffe/util/db.hpp +++ b/include/caffe/util/db.hpp @@ -3,10 +3,6 @@ #include -#include "leveldb/db.h" -#include "leveldb/write_batch.h" -#include "lmdb.h" - #include "caffe/common.hpp" #include "caffe/proto/caffe.pb.h" @@ -49,138 +45,6 @@ class DB { DISABLE_COPY_AND_ASSIGN(DB); }; -class LevelDBCursor : public Cursor { - public: - explicit LevelDBCursor(leveldb::Iterator* iter) - : iter_(iter) { SeekToFirst(); } - ~LevelDBCursor() { delete iter_; } - virtual void SeekToFirst() { iter_->SeekToFirst(); } - virtual void Next() { iter_->Next(); } - virtual string key() { return iter_->key().ToString(); } - virtual string value() { return iter_->value().ToString(); } - virtual bool valid() { return iter_->Valid(); } - - private: - leveldb::Iterator* iter_; -}; - -class LevelDBTransaction : public Transaction { - public: - explicit LevelDBTransaction(leveldb::DB* db) : db_(db) { CHECK_NOTNULL(db_); } - virtual void Put(const string& key, const string& value) { - batch_.Put(key, value); - } - virtual void Commit() { - leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch_); - CHECK(status.ok()) << "Failed to write batch to leveldb " - << std::endl << status.ToString(); - } - - private: - leveldb::DB* db_; - leveldb::WriteBatch batch_; - - DISABLE_COPY_AND_ASSIGN(LevelDBTransaction); -}; - -class LevelDB : public DB { - public: - LevelDB() : db_(NULL) { } - virtual ~LevelDB() { Close(); } - virtual void Open(const string& source, Mode mode); - virtual void Close() { - if (db_ != NULL) { - delete db_; - db_ = NULL; - } - } - virtual LevelDBCursor* NewCursor() { - return new LevelDBCursor(db_->NewIterator(leveldb::ReadOptions())); - } - virtual LevelDBTransaction* NewTransaction() { - return new LevelDBTransaction(db_); - } - - private: - leveldb::DB* db_; -}; - -inline void MDB_CHECK(int mdb_status) { - CHECK_EQ(mdb_status, MDB_SUCCESS) << mdb_strerror(mdb_status); -} - -class LMDBCursor : public Cursor { - public: - explicit LMDBCursor(MDB_txn* mdb_txn, MDB_cursor* mdb_cursor) - : mdb_txn_(mdb_txn), mdb_cursor_(mdb_cursor), valid_(false) { - SeekToFirst(); - } - virtual ~LMDBCursor() { - mdb_cursor_close(mdb_cursor_); - mdb_txn_abort(mdb_txn_); - } - virtual void SeekToFirst() { Seek(MDB_FIRST); } - virtual void Next() { Seek(MDB_NEXT); } - virtual string key() { - return string(static_cast(mdb_key_.mv_data), mdb_key_.mv_size); - } - virtual string value() { - return string(static_cast(mdb_value_.mv_data), - mdb_value_.mv_size); - } - virtual bool valid() { return valid_; } - - private: - void Seek(MDB_cursor_op op) { - int mdb_status = mdb_cursor_get(mdb_cursor_, &mdb_key_, &mdb_value_, op); - if (mdb_status == MDB_NOTFOUND) { - valid_ = false; - } else { - MDB_CHECK(mdb_status); - valid_ = true; - } - } - - MDB_txn* mdb_txn_; - MDB_cursor* mdb_cursor_; - MDB_val mdb_key_, mdb_value_; - bool valid_; -}; - -class LMDBTransaction : public Transaction { - public: - explicit LMDBTransaction(MDB_dbi* mdb_dbi, MDB_txn* mdb_txn) - : mdb_dbi_(mdb_dbi), mdb_txn_(mdb_txn) { } - virtual void Put(const string& key, const string& value); - virtual void Commit() { MDB_CHECK(mdb_txn_commit(mdb_txn_)); } - - private: - MDB_dbi* mdb_dbi_; - MDB_txn* mdb_txn_; - - DISABLE_COPY_AND_ASSIGN(LMDBTransaction); -}; - -class LMDB : public DB { - public: - LMDB() : mdb_env_(NULL) { } - virtual ~LMDB() { Close(); } - virtual void Open(const string& source, Mode mode); - virtual void Close() { - if (mdb_env_ != NULL) { - mdb_dbi_close(mdb_env_, mdb_dbi_); - mdb_env_close(mdb_env_); - mdb_env_ = NULL; - } - } - virtual LMDBCursor* NewCursor(); - virtual LMDBTransaction* NewTransaction(); - - private: - MDB_env* mdb_env_; - MDB_dbi mdb_dbi_; -}; - DB* GetDB(DataParameter::DB backend); DB* GetDB(const string& backend); diff --git a/include/caffe/util/db_leveldb.hpp b/include/caffe/util/db_leveldb.hpp new file mode 100644 index 00000000000..10623554b67 --- /dev/null +++ b/include/caffe/util/db_leveldb.hpp @@ -0,0 +1,73 @@ +#ifndef CAFFE_UTIL_DB_LEVELDB_HPP +#define CAFFE_UTIL_DB_LEVELDB_HPP + +#include + +#include "leveldb/db.h" +#include "leveldb/write_batch.h" + +#include "caffe/util/db.hpp" + +namespace caffe { namespace db { + +class LevelDBCursor : public Cursor { + public: + explicit LevelDBCursor(leveldb::Iterator* iter) + : iter_(iter) { SeekToFirst(); } + ~LevelDBCursor() { delete iter_; } + virtual void SeekToFirst() { iter_->SeekToFirst(); } + virtual void Next() { iter_->Next(); } + virtual string key() { return iter_->key().ToString(); } + virtual string value() { return iter_->value().ToString(); } + virtual bool valid() { return iter_->Valid(); } + + private: + leveldb::Iterator* iter_; +}; + +class LevelDBTransaction : public Transaction { + public: + explicit LevelDBTransaction(leveldb::DB* db) : db_(db) { CHECK_NOTNULL(db_); } + virtual void Put(const string& key, const string& value) { + batch_.Put(key, value); + } + virtual void Commit() { + leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch_); + CHECK(status.ok()) << "Failed to write batch to leveldb " + << std::endl << status.ToString(); + } + + private: + leveldb::DB* db_; + leveldb::WriteBatch batch_; + + DISABLE_COPY_AND_ASSIGN(LevelDBTransaction); +}; + +class LevelDB : public DB { + public: + LevelDB() : db_(NULL) { } + virtual ~LevelDB() { Close(); } + virtual void Open(const string& source, Mode mode); + virtual void Close() { + if (db_ != NULL) { + delete db_; + db_ = NULL; + } + } + virtual LevelDBCursor* NewCursor() { + return new LevelDBCursor(db_->NewIterator(leveldb::ReadOptions())); + } + virtual LevelDBTransaction* NewTransaction() { + return new LevelDBTransaction(db_); + } + + private: + leveldb::DB* db_; +}; + + +} // namespace db +} // namespace caffe + +#endif // CAFFE_UTIL_DB_LEVELDB_HPP diff --git a/include/caffe/util/db_lmdb.hpp b/include/caffe/util/db_lmdb.hpp new file mode 100644 index 00000000000..cc7c90afc4c --- /dev/null +++ b/include/caffe/util/db_lmdb.hpp @@ -0,0 +1,91 @@ +#ifndef CAFFE_UTIL_DB_LMDB_HPP +#define CAFFE_UTIL_DB_LMDB_HPP + +#include + +#include "lmdb.h" + +#include "caffe/util/db.hpp" + +namespace caffe { namespace db { + +inline void MDB_CHECK(int mdb_status) { + CHECK_EQ(mdb_status, MDB_SUCCESS) << mdb_strerror(mdb_status); +} + +class LMDBCursor : public Cursor { + public: + explicit LMDBCursor(MDB_txn* mdb_txn, MDB_cursor* mdb_cursor) + : mdb_txn_(mdb_txn), mdb_cursor_(mdb_cursor), valid_(false) { + SeekToFirst(); + } + virtual ~LMDBCursor() { + mdb_cursor_close(mdb_cursor_); + mdb_txn_abort(mdb_txn_); + } + virtual void SeekToFirst() { Seek(MDB_FIRST); } + virtual void Next() { Seek(MDB_NEXT); } + virtual string key() { + return string(static_cast(mdb_key_.mv_data), mdb_key_.mv_size); + } + virtual string value() { + return string(static_cast(mdb_value_.mv_data), + mdb_value_.mv_size); + } + virtual bool valid() { return valid_; } + + private: + void Seek(MDB_cursor_op op) { + int mdb_status = mdb_cursor_get(mdb_cursor_, &mdb_key_, &mdb_value_, op); + if (mdb_status == MDB_NOTFOUND) { + valid_ = false; + } else { + MDB_CHECK(mdb_status); + valid_ = true; + } + } + + MDB_txn* mdb_txn_; + MDB_cursor* mdb_cursor_; + MDB_val mdb_key_, mdb_value_; + bool valid_; +}; + +class LMDBTransaction : public Transaction { + public: + explicit LMDBTransaction(MDB_dbi* mdb_dbi, MDB_txn* mdb_txn) + : mdb_dbi_(mdb_dbi), mdb_txn_(mdb_txn) { } + virtual void Put(const string& key, const string& value); + virtual void Commit() { MDB_CHECK(mdb_txn_commit(mdb_txn_)); } + + private: + MDB_dbi* mdb_dbi_; + MDB_txn* mdb_txn_; + + DISABLE_COPY_AND_ASSIGN(LMDBTransaction); +}; + +class LMDB : public DB { + public: + LMDB() : mdb_env_(NULL) { } + virtual ~LMDB() { Close(); } + virtual void Open(const string& source, Mode mode); + virtual void Close() { + if (mdb_env_ != NULL) { + mdb_dbi_close(mdb_env_, mdb_dbi_); + mdb_env_close(mdb_env_); + mdb_env_ = NULL; + } + } + virtual LMDBCursor* NewCursor(); + virtual LMDBTransaction* NewTransaction(); + + private: + MDB_env* mdb_env_; + MDB_dbi mdb_dbi_; +}; + +} // namespace db +} // namespace caffe + +#endif // CAFFE_UTIL_DB_LMDB_HPP diff --git a/src/caffe/util/db.cpp b/src/caffe/util/db.cpp index 7f7018107ec..f55420e9840 100644 --- a/src/caffe/util/db.cpp +++ b/src/caffe/util/db.cpp @@ -1,64 +1,11 @@ #include "caffe/util/db.hpp" +#include "caffe/util/db_leveldb.hpp" +#include "caffe/util/db_lmdb.hpp" -#include #include namespace caffe { namespace db { -const size_t LMDB_MAP_SIZE = 1099511627776; // 1 TB - -void LevelDB::Open(const string& source, Mode mode) { - leveldb::Options options; - options.block_size = 65536; - options.write_buffer_size = 268435456; - options.max_open_files = 100; - options.error_if_exists = mode == NEW; - options.create_if_missing = mode != READ; - leveldb::Status status = leveldb::DB::Open(options, source, &db_); - CHECK(status.ok()) << "Failed to open leveldb " << source - << std::endl << status.ToString(); - LOG(INFO) << "Opened leveldb " << source; -} - -void LMDB::Open(const string& source, Mode mode) { - MDB_CHECK(mdb_env_create(&mdb_env_)); - MDB_CHECK(mdb_env_set_mapsize(mdb_env_, LMDB_MAP_SIZE)); - if (mode == NEW) { - CHECK_EQ(mkdir(source.c_str(), 0744), 0) << "mkdir " << source << "failed"; - } - int flags = 0; - if (mode == READ) { - flags = MDB_RDONLY | MDB_NOTLS; - } - MDB_CHECK(mdb_env_open(mdb_env_, source.c_str(), flags, 0664)); - LOG(INFO) << "Opened lmdb " << source; -} - -LMDBCursor* LMDB::NewCursor() { - MDB_txn* mdb_txn; - MDB_cursor* mdb_cursor; - MDB_CHECK(mdb_txn_begin(mdb_env_, NULL, MDB_RDONLY, &mdb_txn)); - MDB_CHECK(mdb_dbi_open(mdb_txn, NULL, 0, &mdb_dbi_)); - MDB_CHECK(mdb_cursor_open(mdb_txn, mdb_dbi_, &mdb_cursor)); - return new LMDBCursor(mdb_txn, mdb_cursor); -} - -LMDBTransaction* LMDB::NewTransaction() { - MDB_txn* mdb_txn; - MDB_CHECK(mdb_txn_begin(mdb_env_, NULL, 0, &mdb_txn)); - MDB_CHECK(mdb_dbi_open(mdb_txn, NULL, 0, &mdb_dbi_)); - return new LMDBTransaction(&mdb_dbi_, mdb_txn); -} - -void LMDBTransaction::Put(const string& key, const string& value) { - MDB_val mdb_key, mdb_value; - mdb_key.mv_data = const_cast(key.data()); - mdb_key.mv_size = key.size(); - mdb_value.mv_data = const_cast(value.data()); - mdb_value.mv_size = value.size(); - MDB_CHECK(mdb_put(mdb_txn_, *mdb_dbi_, &mdb_key, &mdb_value, 0)); -} - DB* GetDB(DataParameter::DB backend) { switch (backend) { case DataParameter_DB_LEVELDB: diff --git a/src/caffe/util/db_leveldb.cpp b/src/caffe/util/db_leveldb.cpp new file mode 100644 index 00000000000..06c46627d31 --- /dev/null +++ b/src/caffe/util/db_leveldb.cpp @@ -0,0 +1,21 @@ +#include "caffe/util/db_leveldb.hpp" + +#include + +namespace caffe { namespace db { + +void LevelDB::Open(const string& source, Mode mode) { + leveldb::Options options; + options.block_size = 65536; + options.write_buffer_size = 268435456; + options.max_open_files = 100; + options.error_if_exists = mode == NEW; + options.create_if_missing = mode != READ; + leveldb::Status status = leveldb::DB::Open(options, source, &db_); + CHECK(status.ok()) << "Failed to open leveldb " << source + << std::endl << status.ToString(); + LOG(INFO) << "Opened leveldb " << source; +} + +} // namespace db +} // namespace caffe diff --git a/src/caffe/util/db_lmdb.cpp b/src/caffe/util/db_lmdb.cpp new file mode 100644 index 00000000000..a054b796806 --- /dev/null +++ b/src/caffe/util/db_lmdb.cpp @@ -0,0 +1,51 @@ +#include "caffe/util/db_lmdb.hpp" + +#include + +#include + +namespace caffe { namespace db { + +const size_t LMDB_MAP_SIZE = 1099511627776; // 1 TB + +void LMDB::Open(const string& source, Mode mode) { + MDB_CHECK(mdb_env_create(&mdb_env_)); + MDB_CHECK(mdb_env_set_mapsize(mdb_env_, LMDB_MAP_SIZE)); + if (mode == NEW) { + CHECK_EQ(mkdir(source.c_str(), 0744), 0) << "mkdir " << source << "failed"; + } + int flags = 0; + if (mode == READ) { + flags = MDB_RDONLY | MDB_NOTLS; + } + MDB_CHECK(mdb_env_open(mdb_env_, source.c_str(), flags, 0664)); + LOG(INFO) << "Opened lmdb " << source; +} + +LMDBCursor* LMDB::NewCursor() { + MDB_txn* mdb_txn; + MDB_cursor* mdb_cursor; + MDB_CHECK(mdb_txn_begin(mdb_env_, NULL, MDB_RDONLY, &mdb_txn)); + MDB_CHECK(mdb_dbi_open(mdb_txn, NULL, 0, &mdb_dbi_)); + MDB_CHECK(mdb_cursor_open(mdb_txn, mdb_dbi_, &mdb_cursor)); + return new LMDBCursor(mdb_txn, mdb_cursor); +} + +LMDBTransaction* LMDB::NewTransaction() { + MDB_txn* mdb_txn; + MDB_CHECK(mdb_txn_begin(mdb_env_, NULL, 0, &mdb_txn)); + MDB_CHECK(mdb_dbi_open(mdb_txn, NULL, 0, &mdb_dbi_)); + return new LMDBTransaction(&mdb_dbi_, mdb_txn); +} + +void LMDBTransaction::Put(const string& key, const string& value) { + MDB_val mdb_key, mdb_value; + mdb_key.mv_data = const_cast(key.data()); + mdb_key.mv_size = key.size(); + mdb_value.mv_data = const_cast(value.data()); + mdb_value.mv_size = value.size(); + MDB_CHECK(mdb_put(mdb_txn_, *mdb_dbi_, &mdb_key, &mdb_value, 0)); +} + +} // namespace db +} // namespace caffe From cdab89a2109956c3514d881c5456522e4181066f Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Tue, 9 Jun 2015 10:45:16 -0700 Subject: [PATCH 061/331] Small platform-specific bugfix for draw.py Close #2376 On Gentoo and CentOS (and others?), you get this error: Warning: /tmp/tmpjqPQBC:6: string ran past end of line --- python/caffe/draw.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/caffe/draw.py b/python/caffe/draw.py index 834ea15ac9a..324929deca4 100644 --- a/python/caffe/draw.py +++ b/python/caffe/draw.py @@ -72,7 +72,7 @@ def get_layer_label(layer, rankdir): else: # If graph orientation is horizontal, vertical space is free and # horizontal space is not; separate words with newlines - separator = '\n' + separator = '\\n' if layer.type == 'Convolution': # Outer double quotes needed or else colon characters don't parse From 543afd36b769675b6de113b3903aaa9866d517d0 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Wed, 10 Jun 2015 17:43:30 -0400 Subject: [PATCH 062/331] [docs] drop out-of-date reference to dev branch --- docs/tutorial/layers.md | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/docs/tutorial/layers.md b/docs/tutorial/layers.md index ff2ee491244..806374e3f93 100644 --- a/docs/tutorial/layers.md +++ b/docs/tutorial/layers.md @@ -5,9 +5,7 @@ title: Layer Catalogue To create a Caffe model you need to define the model architecture in a protocol buffer definition file (prototxt). -Caffe layers and their parameters are defined in the protocol buffer definitions for the project in [caffe.proto](https://github.com/BVLC/caffe/blob/master/src/caffe/proto/caffe.proto). The latest definitions are in the [dev caffe.proto](https://github.com/BVLC/caffe/blob/dev/src/caffe/proto/caffe.proto). - -TODO complete list of layers linking to headings +Caffe layers and their parameters are defined in the protocol buffer definitions for the project in [caffe.proto](https://github.com/BVLC/caffe/blob/master/src/caffe/proto/caffe.proto). ### Vision Layers @@ -507,7 +505,7 @@ The `Slice` layer is a utility layer that slices an input layer to multiple outp } } -`axis` indicates the target axis; `slice_point` indicates indexes in the selected dimension (the number of indices must be equal to the number of top blobs minus one). +`axis` indicates the target axis; `slice_point` indicates indexes in the selected dimension (the number of indices must be equal to the number of top blobs minus one). #### Elementwise Operations From d512d0c5c5efc276db7c864b6b5b6da41824cd88 Mon Sep 17 00:00:00 2001 From: Aaron Schumacher Date: Mon, 15 Jun 2015 19:53:05 -0400 Subject: [PATCH 063/331] typo: "a fixed steps" to "at fixed steps" fixing in the correct place as per @shelhamer's advice from #2602 --- examples/mnist/readme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/mnist/readme.md b/examples/mnist/readme.md index 269e53ab9b9..413d4a1f40b 100644 --- a/examples/mnist/readme.md +++ b/examples/mnist/readme.md @@ -283,5 +283,5 @@ and you will be using CPU for training. Isn't that easy? MNIST is a small dataset, so training with GPU does not really introduce too much benefit due to communication overheads. On larger datasets with more complex models, such as ImageNet, the computation speed difference will be more significant. -### How to reduce the learning rate a fixed steps? +### How to reduce the learning rate at fixed steps? Look at lenet_multistep_solver.prototxt From 94a5be14cb7775ba0567348631baa6d595ddf568 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Tue, 16 Jun 2015 09:12:32 -0700 Subject: [PATCH 064/331] Fix HTML display for docs Doesn't change display in Markdown --- docs/development.md | 33 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/docs/development.md b/docs/development.md index ccb6a29701d..107c2c3b281 100644 --- a/docs/development.md +++ b/docs/development.md @@ -62,28 +62,25 @@ The following is a poetic presentation of the protocol in code form. #### [Shelhamer's](https://github.com/shelhamer) “life of a branch in four acts” Make the `feature` branch off of the latest `bvlc/master` -``` -git checkout master -git pull upstream master -git checkout -b feature -# do your work, make commits -``` + + git checkout master + git pull upstream master + git checkout -b feature + # do your work, make commits Prepare to merge by rebasing your branch on the latest `bvlc/master` -``` -# make sure master is fresh -git checkout master -git pull upstream master -# rebase your branch on the tip of master -git checkout feature -git rebase master -``` + + # make sure master is fresh + git checkout master + git pull upstream master + # rebase your branch on the tip of master + git checkout feature + git rebase master Push your branch to pull request it into `BVLC/caffe:master` -``` -git push origin feature -# ...make pull request to master... -``` + + git push origin feature + # ...make pull request to master... Now make a pull request! You can do this from the command line (`git pull-request -b master`) if you install [hub](https://github.com/github/hub). Hub has many other magical uses. From 98fb438c0d14f279d434719abd3e79b7f9d231ae Mon Sep 17 00:00:00 2001 From: Dylan Paiton Date: Tue, 16 Jun 2015 17:57:07 -0700 Subject: [PATCH 065/331] fixed two bugs with prototext format The first bug was in InitUnsharedWeightsNet. Proto var was of type ostringstream, which converted the bool bias_term into an int. I wrote an inline conditional to convert the term into a string. This allows backwards compatibility with earlier prototext versions (e.g. version 2.3.0 on Redhat was failing without this). The second bug was in the syntax for repeated bool parameters, assigned to the propagate_down parameter. The style used for e.g. propagate_down: [true,true] does not work with earlier prototext versions (failed with version 2.3.0 on Redhat). New syntax works for all versions. --- src/caffe/test/test_net.cpp | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/caffe/test/test_net.cpp b/src/caffe/test/test_net.cpp index 782a96bc9b6..56959f4793b 100644 --- a/src/caffe/test/test_net.cpp +++ b/src/caffe/test/test_net.cpp @@ -288,6 +288,7 @@ class NetTest : public MultiDeviceTest { const bool force_backward = false, const bool bias_term = false, const Dtype blobs_lr_w1 = 1, const Dtype blobs_lr_b1 = 2, const Dtype blobs_lr_w2 = 1, const Dtype blobs_lr_b2 = 2) { + string bias_str = bias_term ? "true ":"false "; ostringstream proto; proto << "name: 'UnsharedWeightsNetwork' "; if (force_backward) { @@ -314,7 +315,7 @@ class NetTest : public MultiDeviceTest { " type: 'InnerProduct' " " inner_product_param { " " num_output: 10 " - " bias_term: " << bias_term << + " bias_term: " << bias_str << " weight_filler { " " type: 'gaussian' " " std: 10 " @@ -340,7 +341,7 @@ class NetTest : public MultiDeviceTest { " type: 'InnerProduct' " " inner_product_param { " " num_output: 10 " - " bias_term: " << bias_term << + " bias_term: " << bias_str << " weight_filler { " " type: 'gaussian' " " std: 10 " @@ -699,9 +700,11 @@ class NetTest : public MultiDeviceTest { " bottom: 'innerproduct' " " bottom: 'label_argmax' "; if (test_skip_true) - proto += " propagate_down: [true, false] "; + proto += " propagate_down: true " + " propagate_down: false "; else - proto += " propagate_down: [true, true] "; + proto += " propagate_down: true " + " propagate_down: true "; proto += " top: 'cross_entropy_loss' " " type: 'SigmoidCrossEntropyLoss' " From e342e155c41887379f3088e3e5b42b2a776d0b87 Mon Sep 17 00:00:00 2001 From: Manuel Date: Mon, 22 Jun 2015 11:49:45 +0200 Subject: [PATCH 066/331] Update parse_log.py Correct parsing (exponential notation learning rates were not being interpreted correctly) --- tools/extra/parse_log.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/extra/parse_log.py b/tools/extra/parse_log.py index 09ea216ced3..48f9bee0b49 100755 --- a/tools/extra/parse_log.py +++ b/tools/extra/parse_log.py @@ -28,7 +28,7 @@ def parse_log(path_to_log): regex_iteration = re.compile('Iteration (\d+)') regex_train_output = re.compile('Train net output #(\d+): (\S+) = ([\.\deE+-]+)') regex_test_output = re.compile('Test net output #(\d+): (\S+) = ([\.\deE+-]+)') - regex_learning_rate = re.compile('lr = ([\.\d]+)') + regex_learning_rate = re.compile('lr = ([-+]?[0-9]*\.?[0-9]+([eE]?[-+]?[0-9]+)?)') # Pick out lines of interest iteration = -1 From d2acfedb9256bb5b12614348e932ec448cdf60c9 Mon Sep 17 00:00:00 2001 From: berleon Date: Mon, 22 Jun 2015 14:41:59 +0200 Subject: [PATCH 067/331] fixed _force_color check, fixes #2635 --- src/caffe/data_transformer.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/caffe/data_transformer.cpp b/src/caffe/data_transformer.cpp index 6f75bdb3852..22633922a01 100644 --- a/src/caffe/data_transformer.cpp +++ b/src/caffe/data_transformer.cpp @@ -127,7 +127,7 @@ void DataTransformer::Transform(const Datum& datum, Blob* transformed_blob) { // If datum is encoded, decoded and transform the cv::image. if (datum.encoded()) { - CHECK(!param_.force_color() && !param_.force_gray()) + CHECK(!(param_.force_color() && param_.force_gray())) << "cannot set both force_color and force_gray"; cv::Mat cv_img; if (param_.force_color() || param_.force_gray()) { @@ -430,7 +430,7 @@ void DataTransformer::Transform(Blob* input_blob, template vector DataTransformer::InferBlobShape(const Datum& datum) { if (datum.encoded()) { - CHECK(!param_.force_color() && !param_.force_gray()) + CHECK(!(param_.force_color() && param_.force_gray())) << "cannot set both force_color and force_gray"; cv::Mat cv_img; if (param_.force_color() || param_.force_gray()) { From ba8899301ee5033a30eecd7726fb898279db3032 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Tue, 23 Jun 2015 09:59:22 -0700 Subject: [PATCH 068/331] copyright 2015 --- LICENSE | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/LICENSE b/LICENSE index efcc5c5b6b0..d69d16f5bc7 100644 --- a/LICENSE +++ b/LICENSE @@ -1,11 +1,11 @@ COPYRIGHT All contributions by the University of California: -Copyright (c) 2014, The Regents of the University of California (Regents) +Copyright (c) 2014, 2015, The Regents of the University of California (Regents) All rights reserved. All other contributions: -Copyright (c) 2014, the respective contributors +Copyright (c) 2014, 2015, the respective contributors All rights reserved. Caffe uses a shared copyright model: each contributor holds copyright over From c23722302e1306ace7bce9e9469304ce040aabf2 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 15 Jan 2015 01:27:42 -0800 Subject: [PATCH 069/331] [pycaffe] basic net specification --- python/caffe/__init__.py | 1 + python/caffe/net_spec.py | 203 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 204 insertions(+) create mode 100644 python/caffe/net_spec.py diff --git a/python/caffe/__init__.py b/python/caffe/__init__.py index fbe7112e868..1b2da510a90 100644 --- a/python/caffe/__init__.py +++ b/python/caffe/__init__.py @@ -4,3 +4,4 @@ from .classifier import Classifier from .detector import Detector from . import io +from .net_spec import layers, params, NetSpec, to_proto diff --git a/python/caffe/net_spec.py b/python/caffe/net_spec.py new file mode 100644 index 00000000000..f54328d56f1 --- /dev/null +++ b/python/caffe/net_spec.py @@ -0,0 +1,203 @@ +"""Python net specification. + +This module provides a way to write nets directly in Python, using a natural, +functional style. See examples/python_nets/caffenet.py for an example. + +Currently this works as a thin wrapper around the Python protobuf interface, +with layers and parameters automatically generated for the "layers" and +"params" pseudo-modules, which are actually objects using __getattr__ magic +to generate protobuf messages. + +Note that when using to_proto or Top.to_proto, names of intermediate blobs will +be automatically generated. To explicitly specify blob names, use the NetSpec +class -- assign to its attributes directly to name layers, and call +NetSpec.to_proto to serialize all assigned layers. + +This interface is expected to continue to evolve as Caffe gains new capabilities +for specifying nets. In particular, the automatically generated layer names +are not guaranteed to be forward-compatible. +""" + +from collections import OrderedDict + +from .proto import caffe_pb2 +from google import protobuf + + +def param_name_dict(): + """Find out the correspondence between layer names and parameter names.""" + + layer = caffe_pb2.LayerParameter() + # get all parameter names (typically underscore case) and corresponding + # type names (typically camel case), which contain the layer names + # (note that not all parameters correspond to layers, but we'll ignore that) + param_names = [s for s in dir(layer) if s.endswith('_param')] + param_type_names = [type(getattr(layer, s)).__name__ for s in param_names] + # strip the final '_param' or 'Parameter' + param_names = [s[:-len('_param')] for s in param_names] + param_type_names = [s[:-len('Parameter')] for s in param_type_names] + return dict(zip(param_type_names, param_names)) + + +def to_proto(*tops): + """Generate a NetParameter that contains all layers needed to compute + all arguments.""" + + if not isinstance(tops, tuple): + tops = (tops,) + layers = OrderedDict() + autonames = {} + for top in tops: + top.fn._to_proto(layers, {}, autonames) + net = caffe_pb2.NetParameter() + net.layer.extend(layers.values()) + return net + + +def assign_proto(proto, name, val): + """Assign a Python object to a protobuf message, based on the Python + type (in recursive fashion). Lists become repeated fields/messages, dicts + become messages, and other types are assigned directly.""" + + if isinstance(val, list): + if isinstance(val[0], dict): + for item in val: + proto_item = getattr(proto, name).add() + for k, v in item.iteritems(): + assign_proto(proto_item, k, v) + else: + getattr(proto, name).extend(val) + elif isinstance(val, dict): + for k, v in val.iteritems(): + assign_proto(getattr(proto, name), k, v) + else: + setattr(proto, name, val) + + +class Top(object): + """A Top specifies a single output blob (which could be one of several + produced by a layer.)""" + + def __init__(self, fn, n): + self.fn = fn + self.n = n + + def to_proto(self): + """Generate a NetParameter that contains all layers needed to compute + this top.""" + + return to_proto(self) + + +class Function(object): + """A Function specifies a layer, its parameters, and its inputs (which + are Tops from other layers).""" + + def __init__(self, type_name, inputs, params): + self.type_name = type_name + self.inputs = inputs + self.params = params + self.ntop = self.params.get('ntop', 1) + # use del to make sure kwargs are not double-processed as layer params + if 'ntop' in self.params: + del self.params['ntop'] + self.in_place = self.params.get('in_place', False) + if 'in_place' in self.params: + del self.params['in_place'] + self.tops = tuple(Top(self, n) for n in range(self.ntop)) + + def _get_name(self, top, names, autonames): + if top not in names: + n = autonames.setdefault(top.fn.type_name, 1) + autonames[top.fn.type_name] += 1 + names[top] = top.fn.type_name + str(n) + return names[top] + + def _to_proto(self, layers, names, autonames): + if self in layers: + return + bottom_names = [] + for inp in self.inputs: + inp.fn._to_proto(layers, names, autonames) + bottom_names.append(layers[inp.fn].top[inp.n]) + layer = caffe_pb2.LayerParameter() + layer.type = self.type_name + layer.bottom.extend(bottom_names) + + if self.in_place: + layer.top.extend(layer.bottom) + else: + for top in self.tops: + layer.top.append(self._get_name(top, names, autonames)) + layer.name = self._get_name(self.tops[0], names, autonames) + + for k, v in self.params.iteritems(): + # special case to handle generic *params + if k.endswith('param'): + assign_proto(layer, k, v) + else: + try: + assign_proto(getattr(layer, + _param_names[self.type_name] + '_param'), k, v) + except (AttributeError, KeyError): + assign_proto(layer, k, v) + + layers[self] = layer + + +class NetSpec(object): + """A NetSpec contains a set of Tops (assigned directly as attributes). + Calling NetSpec.to_proto generates a NetParameter containing all of the + layers needed to produce all of the assigned Tops, using the assigned + names.""" + + def __init__(self): + super(NetSpec, self).__setattr__('tops', OrderedDict()) + + def __setattr__(self, name, value): + self.tops[name] = value + + def __getattr__(self, name): + return self.tops[name] + + def to_proto(self): + names = {v: k for k, v in self.tops.iteritems()} + autonames = {} + layers = OrderedDict() + for name, top in self.tops.iteritems(): + top.fn._to_proto(layers, names, autonames) + net = caffe_pb2.NetParameter() + net.layer.extend(layers.values()) + return net + + +class Layers(object): + """A Layers object is a pseudo-module which generates functions that specify + layers; e.g., Layers().Convolution(bottom, kernel_size=3) will produce a Top + specifying a 3x3 convolution applied to bottom.""" + + def __getattr__(self, name): + def layer_fn(*args, **kwargs): + fn = Function(name, args, kwargs) + if fn.ntop == 1: + return fn.tops[0] + else: + return fn.tops + return layer_fn + + +class Parameters(object): + """A Parameters object is a pseudo-module which generates constants used + in layer parameters; e.g., Parameters().Pooling.MAX is the value used + to specify max pooling.""" + + def __getattr__(self, name): + class Param: + def __getattr__(self, param_name): + return getattr(getattr(caffe_pb2, name + 'Parameter'), param_name) + return Param() + + +_param_names = param_name_dict() +layers = Layers() +params = Parameters() From ad2e7f467d610d21c22d40f37a5a137ef9939a2b Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Mon, 9 Mar 2015 17:43:53 -0700 Subject: [PATCH 070/331] [examples] caffenet python spec --- examples/pycaffe/caffenet.py | 54 ++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 examples/pycaffe/caffenet.py diff --git a/examples/pycaffe/caffenet.py b/examples/pycaffe/caffenet.py new file mode 100644 index 00000000000..f9801d7cbb8 --- /dev/null +++ b/examples/pycaffe/caffenet.py @@ -0,0 +1,54 @@ +from caffe import layers as L, params as P, to_proto +from caffe.proto import caffe_pb2 + +# helper function for common structures + +def conv_relu(bottom, ks, nout, stride=1, pad=0, group=1): + conv = L.Convolution(bottom, kernel_size=ks, stride=stride, + num_output=nout, pad=pad, group=group) + return conv, L.ReLU(conv, in_place=True) + +def fc_relu(bottom, nout): + fc = L.InnerProduct(bottom, num_output=nout) + return fc, L.ReLU(fc, in_place=True) + +def max_pool(bottom, ks, stride=1): + return L.Pooling(bottom, pool=P.Pooling.MAX, kernel_size=ks, stride=stride) + +def caffenet(lmdb, batch_size=256, include_acc=False): + data, label = L.Data(source=lmdb, backend=P.Data.LMDB, batch_size=batch_size, ntop=2, + transform_param=dict(crop_size=227, mean_value=[104, 117, 123], mirror=True)) + + # the net itself + conv1, relu1 = conv_relu(data, 11, 96, stride=4) + pool1 = max_pool(relu1, 3, stride=2) + norm1 = L.LRN(pool1, local_size=5, alpha=1e-4, beta=0.75) + conv2, relu2 = conv_relu(norm1, 5, 256, pad=2, group=2) + pool2 = max_pool(relu2, 3, stride=2) + norm2 = L.LRN(pool2, local_size=5, alpha=1e-4, beta=0.75) + conv3, relu3 = conv_relu(norm2, 3, 384, pad=1) + conv4, relu4 = conv_relu(relu3, 3, 384, pad=1, group=2) + conv5, relu5 = conv_relu(relu4, 3, 256, pad=1, group=2) + pool5 = max_pool(relu5, 3, stride=2) + fc6, relu6 = fc_relu(pool5, 4096) + drop6 = L.Dropout(relu6, in_place=True) + fc7, relu7 = fc_relu(drop6, 4096) + drop7 = L.Dropout(relu7, in_place=True) + fc8 = L.InnerProduct(drop7, num_output=1000) + loss = L.SoftmaxWithLoss(fc8, label) + + if include_acc: + acc = L.Accuracy(fc8, label) + return to_proto(loss, acc) + else: + return to_proto(loss) + +def make_net(): + with open('train.prototxt', 'w') as f: + print >>f, caffenet('/path/to/caffe-train-lmdb') + + with open('test.prototxt', 'w') as f: + print >>f, caffenet('/path/to/caffe-val-lmdb', batch_size=50, include_acc=True) + +if __name__ == '__main__': + make_net() From 1cdad89d8c0e1b31b5509f91b932ee3a2d376fd3 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 18 Jun 2015 13:25:08 -0700 Subject: [PATCH 071/331] [pytest] minimal testing of net specification --- python/caffe/test/test_net_spec.py | 67 ++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 python/caffe/test/test_net_spec.py diff --git a/python/caffe/test/test_net_spec.py b/python/caffe/test/test_net_spec.py new file mode 100644 index 00000000000..65b73b96f73 --- /dev/null +++ b/python/caffe/test/test_net_spec.py @@ -0,0 +1,67 @@ +import unittest +import tempfile +import caffe +from caffe import layers as L +from caffe import params as P + +def lenet(batch_size): + n = caffe.NetSpec() + n.data, n.label = L.DummyData(shape=[dict(dim=[batch_size, 1, 28, 28]), + dict(dim=[batch_size, 1, 1, 1])], + transform_param=dict(scale=1./255), ntop=2) + n.conv1 = L.Convolution(n.data, kernel_size=5, num_output=20, + weight_filler=dict(type='xavier')) + n.pool1 = L.Pooling(n.conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX) + n.conv2 = L.Convolution(n.pool1, kernel_size=5, num_output=50, + weight_filler=dict(type='xavier')) + n.pool2 = L.Pooling(n.conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX) + n.ip1 = L.InnerProduct(n.pool2, num_output=500, + weight_filler=dict(type='xavier')) + n.relu1 = L.ReLU(n.ip1, in_place=True) + n.ip2 = L.InnerProduct(n.relu1, num_output=10, + weight_filler=dict(type='xavier')) + n.loss = L.SoftmaxWithLoss(n.ip2, n.label) + return n.to_proto() + +def anon_lenet(batch_size): + data, label = L.DummyData(shape=[dict(dim=[batch_size, 1, 28, 28]), + dict(dim=[batch_size, 1, 1, 1])], + transform_param=dict(scale=1./255), ntop=2) + conv1 = L.Convolution(data, kernel_size=5, num_output=20, + weight_filler=dict(type='xavier')) + pool1 = L.Pooling(conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX) + conv2 = L.Convolution(pool1, kernel_size=5, num_output=50, + weight_filler=dict(type='xavier')) + pool2 = L.Pooling(conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX) + ip1 = L.InnerProduct(pool2, num_output=500, + weight_filler=dict(type='xavier')) + relu1 = L.ReLU(ip1, in_place=True) + ip2 = L.InnerProduct(relu1, num_output=10, + weight_filler=dict(type='xavier')) + loss = L.SoftmaxWithLoss(ip2, label) + return loss.to_proto() + +class TestNetSpec(unittest.TestCase): + def load_net(self, net_proto): + f = tempfile.NamedTemporaryFile(delete=False) + f.write(str(net_proto)) + f.close() + return caffe.Net(f.name, caffe.TEST) + + def test_lenet(self): + """Construct and build the Caffe version of LeNet.""" + + net_proto = lenet(50) + # check that relu is in-place + self.assertEqual(net_proto.layer[6].bottom, + net_proto.layer[6].top) + net = self.load_net(net_proto) + # check that all layers are present + self.assertEqual(len(net.layers), 9) + + # now the check the version with automatically-generated layer names + net_proto = anon_lenet(50) + self.assertEqual(net_proto.layer[6].bottom, + net_proto.layer[6].top) + net = self.load_net(net_proto) + self.assertEqual(len(net.layers), 9) From ccda10250d8adeee82cdc577204069b79a9d7d6f Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 12 Mar 2015 01:03:51 -0700 Subject: [PATCH 072/331] [examples] draft Python solving example --- examples/python_solving.ipynb | 5148 +++++++++++++++++++++++++++++++++ 1 file changed, 5148 insertions(+) create mode 100644 examples/python_solving.ipynb diff --git a/examples/python_solving.ipynb b/examples/python_solving.ipynb new file mode 100644 index 00000000000..de6c40196ad --- /dev/null +++ b/examples/python_solving.ipynb @@ -0,0 +1,5148 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Python solving with LeNet\n", + "\n", + "In this example, we'll explore learning with Caffe in Python, using the fully-exposed `Solver` interface." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import os\n", + "os.chdir('..')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, './python')\n", + "import caffe\n", + "\n", + "from pylab import *\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll be running the provided LeNet example (make sure you've downloaded the data and created the databases, as below)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading...\n", + "--2015-03-12 11:54:02-- http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", + "Resolving yann.lecun.com... 128.122.47.89\n", + "Connecting to yann.lecun.com|128.122.47.89|:80... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 9912422 (9.5M) [application/x-gzip]\n", + "Saving to: 'train-images-idx3-ubyte.gz'\n", + "\n", + "train-images-idx3-u 100%[=====================>] 9.45M 194KB/s in 51s \n", + "\n", + "2015-03-12 11:54:54 (188 KB/s) - 'train-images-idx3-ubyte.gz' saved [9912422/9912422]\n", + "\n", + "--2015-03-12 11:54:54-- http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", + "Resolving yann.lecun.com... 128.122.47.89\n", + "Connecting to yann.lecun.com|128.122.47.89|:80... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 28881 (28K) [application/x-gzip]\n", + "Saving to: 'train-labels-idx1-ubyte.gz'\n", + "\n", + "train-labels-idx1-u 100%[=====================>] 28.20K 104KB/s in 0.3s \n", + "\n", + "2015-03-12 11:54:55 (104 KB/s) - 'train-labels-idx1-ubyte.gz' saved [28881/28881]\n", + "\n", + "--2015-03-12 11:54:55-- http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", + "Resolving yann.lecun.com... 128.122.47.89\n", + "Connecting to yann.lecun.com|128.122.47.89|:80... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 1648877 (1.6M) [application/x-gzip]\n", + "Saving to: 't10k-images-idx3-ubyte.gz'\n", + "\n", + "t10k-images-idx3-ub 100%[=====================>] 1.57M 224KB/s in 9.2s \n", + "\n", + "2015-03-12 11:55:04 (176 KB/s) - 't10k-images-idx3-ubyte.gz' saved [1648877/1648877]\n", + "\n", + "--2015-03-12 11:55:04-- http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", + "Resolving yann.lecun.com... 128.122.47.89\n", + "Connecting to yann.lecun.com|128.122.47.89|:80... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 4542 (4.4K) [application/x-gzip]\n", + "Saving to: 't10k-labels-idx1-ubyte.gz'\n", + "\n", + "t10k-labels-idx1-ub 100%[=====================>] 4.44K --.-KB/s in 0.09s \n", + "\n", + "2015-03-12 11:55:04 (50.0 KB/s) - 't10k-labels-idx1-ubyte.gz' saved [4542/4542]\n", + "\n", + "Unzipping...\n", + "train-images-idx3-ubyte already exists -- do you wish to overwrite (y or n)? ^Ctrain-labels-idx1-ubyte already exists -- do you wish to overwrite (y or n)? \n", + "\tnot overwriting\n", + "t10k-images-idx3-ubyte already exists -- do you wish to overwrite (y or n)? Creating lmdb...\n", + "Done.\n" + ] + } + ], + "source": [ + "!data/mnist/get_mnist.sh\n", + "!examples/mnist/create_mnist.sh" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need two external files to help out:\n", + "* the solver prototxt, defining the learning parameters\n", + "* the net prototxt, defining the architecture and train/test data\n", + "\n", + "Here are the learning parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# The train/test net protocol buffer definition\r\n", + "net: \"examples/mnist/lenet_train_test.prototxt\"\r\n", + "# test_iter specifies how many forward passes the test should carry out.\r\n", + "# In the case of MNIST, we have test batch size 100 and 100 test iterations,\r\n", + "# covering the full 10,000 testing images.\r\n", + "test_iter: 100\r\n", + "# Carry out testing every 500 training iterations.\r\n", + "test_interval: 500\r\n", + "# The base learning rate, momentum and the weight decay of the network.\r\n", + "base_lr: 0.01\r\n", + "momentum: 0.9\r\n", + "weight_decay: 0.0005\r\n", + "# The learning rate policy\r\n", + "lr_policy: \"inv\"\r\n", + "gamma: 0.0001\r\n", + "power: 0.75\r\n", + "# Display every 100 iterations\r\n", + "display: 100\r\n", + "# The maximum number of iterations\r\n", + "max_iter: 10000\r\n", + "# snapshot intermediate results\r\n", + "snapshot: 5000\r\n", + "snapshot_prefix: \"examples/mnist/lenet\"\r\n", + "# solver mode: CPU or GPU\r\n", + "solver_mode: GPU\r\n" + ] + } + ], + "source": [ + "!cat examples/mnist/lenet_solver.prototxt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And here is the version of LeNet we'll be using. In future version of Caffe, networks can be defined directly in Python (see [PR #2086](https://github.com/BVLC/caffe/pull/2086)).\n", + "\n", + "This network expects to read from pregenerated LMDBs, but reading directly from `ndarray`s is also possible using `MemoryDataLayer`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "name: \"LeNet\"\r\n", + "layer {\r\n", + " name: \"mnist\"\r\n", + " type: \"Data\"\r\n", + " top: \"data\"\r\n", + " top: \"label\"\r\n", + " include {\r\n", + " phase: TRAIN\r\n", + " }\r\n", + " transform_param {\r\n", + " scale: 0.00390625\r\n", + " }\r\n", + " data_param {\r\n", + " source: \"examples/mnist/mnist_train_lmdb\"\r\n", + " batch_size: 64\r\n", + " backend: LMDB\r\n", + " }\r\n", + "}\r\n", + "layer {\r\n", + " name: \"mnist\"\r\n", + " type: \"Data\"\r\n", + " top: \"data\"\r\n", + " top: \"label\"\r\n", + " include {\r\n", + " phase: TEST\r\n", + " }\r\n", + " transform_param {\r\n", + " scale: 0.00390625\r\n", + " }\r\n", + " data_param {\r\n", + " source: \"examples/mnist/mnist_test_lmdb\"\r\n", + " batch_size: 100\r\n", + " backend: LMDB\r\n", + " }\r\n", + "}\r\n", + "layer {\r\n", + " name: \"conv1\"\r\n", + " type: \"Convolution\"\r\n", + " bottom: \"data\"\r\n", + " top: \"conv1\"\r\n", + " param {\r\n", + " lr_mult: 1\r\n", + " }\r\n", + " param {\r\n", + " lr_mult: 2\r\n", + " }\r\n", + " convolution_param {\r\n", + " num_output: 20\r\n", + " kernel_size: 5\r\n", + " stride: 1\r\n", + " weight_filler {\r\n", + " type: \"xavier\"\r\n", + " }\r\n", + " bias_filler {\r\n", + " type: \"constant\"\r\n", + " }\r\n", + " }\r\n", + "}\r\n", + "layer {\r\n", + " name: \"pool1\"\r\n", + " type: \"Pooling\"\r\n", + " bottom: \"conv1\"\r\n", + " top: \"pool1\"\r\n", + " pooling_param {\r\n", + " pool: MAX\r\n", + " kernel_size: 2\r\n", + " stride: 2\r\n", + " }\r\n", + "}\r\n", + "layer {\r\n", + " name: \"conv2\"\r\n", + " type: \"Convolution\"\r\n", + " bottom: \"pool1\"\r\n", + " top: \"conv2\"\r\n", + " param {\r\n", + " lr_mult: 1\r\n", + " }\r\n", + " param {\r\n", + " lr_mult: 2\r\n", + " }\r\n", + " convolution_param {\r\n", + " num_output: 50\r\n", + " kernel_size: 5\r\n", + " stride: 1\r\n", + " weight_filler {\r\n", + " type: \"xavier\"\r\n", + " }\r\n", + " bias_filler {\r\n", + " type: \"constant\"\r\n", + " }\r\n", + " }\r\n", + "}\r\n", + "layer {\r\n", + " name: \"pool2\"\r\n", + " type: \"Pooling\"\r\n", + " bottom: \"conv2\"\r\n", + " top: \"pool2\"\r\n", + " pooling_param {\r\n", + " pool: MAX\r\n", + " kernel_size: 2\r\n", + " stride: 2\r\n", + " }\r\n", + "}\r\n", + "layer {\r\n", + " name: \"ip1\"\r\n", + " type: \"InnerProduct\"\r\n", + " bottom: \"pool2\"\r\n", + " top: \"ip1\"\r\n", + " param {\r\n", + " lr_mult: 1\r\n", + " }\r\n", + " param {\r\n", + " lr_mult: 2\r\n", + " }\r\n", + " inner_product_param {\r\n", + " num_output: 500\r\n", + " weight_filler {\r\n", + " type: \"xavier\"\r\n", + " }\r\n", + " bias_filler {\r\n", + " type: \"constant\"\r\n", + " }\r\n", + " }\r\n", + "}\r\n", + "layer {\r\n", + " name: \"relu1\"\r\n", + " type: \"ReLU\"\r\n", + " bottom: \"ip1\"\r\n", + " top: \"ip1\"\r\n", + "}\r\n", + "layer {\r\n", + " name: \"ip2\"\r\n", + " type: \"InnerProduct\"\r\n", + " bottom: \"ip1\"\r\n", + " top: \"ip2\"\r\n", + " param {\r\n", + " lr_mult: 1\r\n", + " }\r\n", + " param {\r\n", + " lr_mult: 2\r\n", + " }\r", + "\r\n", + " inner_product_param {\r\n", + " num_output: 10\r\n", + " weight_filler {\r\n", + " type: \"xavier\"\r\n", + " }\r\n", + " bias_filler {\r\n", + " type: \"constant\"\r\n", + " }\r\n", + " }\r\n", + "}\r\n", + "layer {\r\n", + " name: \"accuracy\"\r\n", + " type: \"Accuracy\"\r\n", + " bottom: \"ip2\"\r\n", + " bottom: \"label\"\r\n", + " top: \"accuracy\"\r\n", + " include {\r\n", + " phase: TEST\r\n", + " }\r\n", + "}\r\n", + "layer {\r\n", + " name: \"loss\"\r\n", + " type: \"SoftmaxWithLoss\"\r\n", + " bottom: \"ip2\"\r\n", + " bottom: \"label\"\r\n", + " top: \"loss\"\r\n", + "}\r\n" + ] + } + ], + "source": [ + "!cat examples/mnist/lenet_train_test.prototxt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's pick a device and load the solver. We'll use SGD (with momentum), but Adagrad and Nesterov's accelerated gradient are also available." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "caffe.set_device(0)\n", + "caffe.set_mode_gpu()\n", + "solver = caffe.SGDSolver('examples/mnist/lenet_solver.prototxt')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get an idea of the architecture of our net, we can check the dimensions of the intermediate features (blobs) and parameters (these will also be useful to refer to when manipulating data later)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('data', (64, 1, 28, 28)),\n", + " ('label', (64,)),\n", + " ('conv1', (64, 20, 24, 24)),\n", + " ('pool1', (64, 20, 12, 12)),\n", + " ('conv2', (64, 50, 8, 8)),\n", + " ('pool2', (64, 50, 4, 4)),\n", + " ('ip1', (64, 500)),\n", + " ('ip2', (64, 10)),\n", + " ('loss', ())]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# each output is (batch size, feature dim, spatial dim)\n", + "[(k, v.data.shape) for k, v in solver.net.blobs.items()]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('conv1', (20, 1, 5, 5)),\n", + " ('conv2', (50, 20, 5, 5)),\n", + " ('ip1', (500, 800)),\n", + " ('ip2', (10, 500))]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# just print the weight sizes (not biases)\n", + "[(k, v[0].data.shape) for k, v in solver.net.params.items()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before taking off, let's check that everything is loaded as we expect. We'll run a forward pass on the train and test nets and check that they contain our data." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'accuracy': array(0.07000000029802322, dtype=float32),\n", + " 'loss': array(2.375746726989746, dtype=float32)}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "solver.net.forward() # train net\n", + "solver.test_nets[0].forward() # test net (there can be more than one)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 5. 0. 4. 1. 9. 2. 1. 3.]\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAWwAAABKCAYAAACfHW4mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztvXlQW1me5/s5EhJaECAJhEBgdrMbDNjgtNNOp7d02pk1\n", + "mVlZW1dWd0XH9ERMzxIzEzE1M3/M1HvzIt68iZjpF9HRPdFvpqeqZ6ajJyozy5VbpZ1e0k4n6R0w\n", + "JBizrwIJxCYJgQTc9wfcW+D0KiOwK+8ngkBcJN2jo3N/95zf+f5+PyFJEioqKioqzz6arW6AioqK\n", + "isrjoRpsFRUVlecE1WCrqKioPCeoBltFRUXlOUE12CoqKirPCarBVlFRUXlOiNpgCyFeEUJ0CCG6\n", + "hBA/28hGqaioqKh8ExGNDlsIoQXuAoeBEeAG8ENJku5sbPNUVFRUVGSinWHvBrolSeqXJCkC/G/g\n", + "OxvXLBUVFRWVe4nWYLuAoTV/D68eU1FRUVGJEXFRvu6RfhQhhBrzrqKiohIFkiSJ+x2PdoY9AmSt\n", + "+TuLlVm2ioqKikqMiNZg3wQKhRA5Qgg98H3gw41rloqKiorKvUTlEpEkaVEI8Y+AM4AW+GtVIaKi\n", + "oqISW6KS9SkvFqIfmAWWgIgkSbvX/O9b7cPWaDRotVr0ej06nQ6tVkskEiEcDhOJRFheXkZNbaui\n", + "8js0Gg3x8fHEx8ej1WpZXl5mfn6ehYUFlpeXt7p5m8qDfNjRbjoq7wu8JEnS5FO+z+8dVquVnJwc\n", + "amtrqaqqwuFw0NLSwq1bt2hpaWFsbIxwOLzVzVRReWZITk7m2LFj7Nmzh/z8fLxeL2fOnOHs2bPM\n", + "zMywuLi41U3ccp7WYAPc906wUQgh0Gq1aLVa5Vh8fDwulwuj0UhcXBwmkwm3243P5yM/P5+MjAyS\n", + "k5NZXl7G4/EwMDBAf38/8/PzsWwqAFqtloSEBGpqanjppZeoqqqitLQUu91OdnY227ZtIz09nVOn\n", + "TjExMRHz9jwNcXFxWK1WCgoKsNvtNDU1MTExwcLCwlY3DYPBQHZ2Nrm5uTidToQQdHV10dHRwfT0\n", + "tHpxPwKNRkNcXBxarZakpCSSkpLQ6/WMj4/j9Xo3fUar1+txOBwcOHCAgwcPkpubi8/nw+Px0NjY\n", + "SDAYfCa+0/j4eAwGA0IIEhISSE1NZfv27RiNxge+JhKJMDExQVdXF/39/U/Vtxsxwz4nhFgC/kqS\n", + "pP8a7RsJ8Tu7r9FoEEIoxtpoNGIwGJT/22w2jh49isPhwGw2k56ezrlz52hqauLHP/4xL7/8MiUl\n", + "JYTDYb744gtOnTrF+++/H3ODLYQgPj6ebdu28dprr/GTn/wEo9GIRrOyt1tZWUlxcTElJSVcvnwZ\n", + "n8/31G4R+b2BDb/IDAYDBQUFvPPOO1RVVfHzn/+cW7dubbnB1mg0JCcnc/jwYb773e+yf/9+NBoN\n", + "v/jFL/jLv/xL2tvbn4mL+1lDvqY0Gg0GgwGj0YjRaKSoqIiioiISExO5fv06DQ0Nm+6GMJlMZGRk\n", + "UF1djcvlQqvVkpqaSnp6Oqmpqbjd7k1ry72s7Ter1UpqaiparZbs7Gzq6ur46U9/Slpa2gOvZb/f\n", + "z61bt/jlL3/J6OjoU/Xt0xrsvZIkjQohUoGzQogOSZIuP+mbaLVaEhMT0ev1GAwGXC4XLpcLh8OB\n", + "wWAgNzeX7Oxs5fk6nY60tDTi4+MRQhCJRFhcXKS4uJgDBw7gdDrx+/14PB46Ozvp7e3dFCNjs9ko\n", + "Li7mhz/8Ifv371fuxIuLi4TDYZaXl5XPKs8gJicno/Znx8fHk5mZSWJiIktLS3R1dREKhTbs8+h0\n", + "OrKyVtSbQ0NDRCKRDXvvpyE7O5v6+npOnDjB9u3bkSRJ3RN4DEwmE+np6ezevZv8/HxcLhdpaWlY\n", + "rVYsFgtxcXHk5eVhtVo5d+4cU1NTm9a2hYUFfD4f3d3dOBwOZdw9CyQmJpKenk55eTk7duygoKAA\n", + "jUaD3W7H5XKRlJSEJEkPHH8Gg4HS0lJOnDgBwPnz5xkfH4/qenoqgy1J0ujq73EhxClWQtafyGAb\n", + "DAYcDgd1dXXY7XZlxiwb7Pj4eLKyssjMzLzv6/1+P7dv3yYcDmMwGPB6vYyPjzM7O8vo6CjXr1+P\n", + "qcGWl5Zms5nKykoOHjzIoUOHyMrKIi4uDkmSCIVCTExMMDw8jMvlUlYIRqOR1tZWBgcHo2pffHy8\n", + "4gIKh8MMDw9vqMHW6/U4nU5MJhORSARJktathLaK1NRUSkpKKCkpwW63b1m7ZPeX3W7HZrORmJiI\n", + "2WwmPj4eAI/Hw+joKOFwGKPRiE6nU8bmRn5PDyM+Ph6LxYLT6SQnJ4fi4mLq6urIzc3F4XBgsViU\n", + "VZrsYgyFQrS2tjI3N7dpq6lIJILf72dkZISZmZlnymBnZWWxd+9e9u7dS1lZmdI2eYUihHjoZCEu\n", + "Lo7U1FRqa2sJh8N0dnYSCAQ212ALIUyAVpIkvxDCDBwF/o8nfZ/k5GR27tzJz372M7Zv3664PuQL\n", + "8GEXoiRJzMzMcPr0afr7+wmHw5w7d45AIMDMzAyBQACPx8PExETMZl/yRZubm8uJEyd4++23SU1N\n", + "RafTKc8JBAJ0d3fz4YcfcvDgQd58803+9E//lJKSEt59910++OCDqA12Xl4excXFhEIhLl26tGGf\n", + "SwhBXFwcNpuN1NRUYGXgPQuYTCasVquiJtgq9Ho927Zto66ujrq6OkpLS8nOzlb66+zZs3z66adM\n", + "TU2Rnp5OYmIiX375Je3t7YyMjGxKGy0WC9u3b+fVV1/lwIEDVFZWEh8fj0ajYWlpCZ/PRzAYBMDl\n", + "cpGZmUltbS3Z2dmbul+xuLjI3Nwck5OTzM3Nbco5H5eKigrefvttqqursVgsUU8OsrOzWV5e5vTp\n", + "07jdbmZnZ5/4PR55BQoh/jtwAvBKklSxeswGfADsEkKEWYly/J+SJH32pA0IhUJMTU0xNzenuAzu\n", + "RzgcxuPxEAwG0Wg0uFwudDod09PT3Lhxg+7ubpaWlgAUF8Ti4iLz8/MxXSrv3LmTl19+merqakpL\n", + "S7HZbGi12nVfanJyMi6XC5PJxOTkJH19fbhcLqxWKxkZGeuM+5NgMpmoqanBbrfT2dm5UR8JWFn5\n", + "OJ1O9uzZg8VioaWlBbfbjd/v39DzPAnyaqu+vp69e/eSkJCA3++nv7+fjz/+mMuXL2+a6yYzM5Md\n", + "O3Zw4sQJSktLcblcJCcnEwqF6OnpwWg0kpubyzvvvKPMsJeWlkhISCAcDsfUYOt0Oux2Oy+88ALV\n", + "1dWUlZUpm7OysZ6bm6Ovr49f/epXeL1e0tPT+ZM/+RNSU1OxWCxYLBb0en3M2ni/NicmJpKRkUFS\n", + "UtKmnfdxGB8fp7e3l4qKCoQQLC8vMzc3R29vLwMDA8q1LtsZu91Oeno6GRkZymoLUPzgT7MafJwp\n", + "0y+APwf+x5pj/wr4SJKkF1dzYVslSfq/o2lAKBRifHyc9vZ2jEYjKSkphEKhdTO7hYUFPB4Ply5d\n", + "wuPxoNVqKSoqwul04vF46Ovro7+/P5rTR41Go8FkMrFjxw5OnjxJRUUFZrOZpaUl/H4/fr+fxcVF\n", + "MjIyFN98OBymv7+f1tZW7HY7RqORxMTEdRuHT4JerycrK2vdhuxG4XK5qKmpoaioCK/Xi9vtZmpq\n", + "ass2HI1GI06nk/3797Nnzx4KCgqIj49neHiY69ev8+tf/5re3l5CoVDMNhzlTXD5ez9x4gTHjh0j\n", + "OTmZ+fl5hoaG6OrqYmhoiISEBEpLSyktLSUxMZG4uDimpqYYHBzEYrHEpH0yiYmJbN++nRMnTlBX\n", + "V0dOTo6y37O8vMzCwgJ3797l0qVLfPTRR0xPT1NWVsaPf/xj4uLiMBgMGAyGTV1RyW7FtLQ0EhIS\n", + "lOPx8fEkJiZiMpmYn5/fks3k4eFhrly5QnJyMjabjeXlZQKBAO3t7XR2dn7DJZKWlkZxcTFHjx4l\n", + "NTVV6cdgMIjX62V6ejrq6+iR34gkSZeFEDn3HH4dOLD6+G+Ai6wY8ScmEokwOjrKhx9+iNvtJjMz\n", + "k8HBQV588UUOHz4MwPT0NC0tLfzFX/wF3d3daDQasrKy2LdvH+np6ZvmD1yLXq8nMzNT8aXKvqxw\n", + "OExfXx8tLS3Mzs7y/e9/H5PJhM/nY3BwkGAwSDgcZteuXcru89PccWPlu62pqeHtt9/GarXS29vL\n", + "xMTEliov7HY71dXVvPPOO5SVlSkbup2dnZw/f57BwUH8fn9MV1NCCEVOeOTIEb73ve9hsVhwu900\n", + "Nzfz4Ycf0tjYyPDwMDqdjrfeeos/+IM/oLy8nISEBCKRCENDQzHfzHO5XNTV1XHgwAEyMzPXrfgW\n", + "Fxfx+Xx8+umn/M3f/A1utxuz2RzT9jwOcXFxGI1GrFYrJpNJOW6z2cjJyWFoaIj5+fmo3AhPS09P\n", + "D2NjYzQ0NKDT6ZAkicXFRaanp+/bHqPRSGlpKYWFhVgsFuUGNDIyQlNTE11dXVGPgWhvoWmSJHlW\n", + "H3uAtCjfB0mSmJub4/bt24yPj5OUlITP52NxcRG73U5RURHd3d1cunRJ2ZCQlRcLCwskJCQwPT0d\n", + "7emjIjExkcLCQn7wgx9w4MABTCYTQgi8Xi9tbW28//77TE1NYbVa+eyzzxgfH6epqYmWlhYWFhbQ\n", + "aDSEQiEcDofi9/T7/czMzDxRG9LT0xW9+UZjMplISkpCq9Xi9Xrp7u7eUjnftm3b2L17N9nZ2Vgs\n", + "FhYXFxkdHaWxsZEbN24QCARirhJxuVxUVVVx8uRJ9uzZQ3x8PAMDA5w9e5bTp0/T0dGhaJhzcnIo\n", + "KCggOzsbvV5PKBRibGyMmzdvMjQ09OiTPQWZmZlUVlaSlJREXFycsurz+XwMDAxw8eJFLl26pARv\n", + "ORwOUlJStnSPYn5+Hq/XS3NzMw6HA6vVCkBxcTGvvvoq8/PzhMPhLTHYi4uL+P1+wuGwshpeXl4m\n", + "Eonc1/2WkpKCy+UiISFhXZ8Gg0F8Ph9zc3NRT36e+huSJEl62jB02afn9XqJi4tjYWFBuThycnII\n", + "BoPKBohsnGZmZp7IwG0EGo1GcUPs2rWLkydPsm3bNkUJ0tfXx5UrVzh9+jSwYmR8Ph/9/f3cuXOH\n", + "ubk5lpaWsFqtLCwskJycTH5+Pjt27GBiYuKJPo/NZiM3N5fk5GQCgcCGfUZ5s9FkMpGQkIBGo2Fq\n", + "aoqhoaEticyU3RB5eXns3r0bm82muBdu377N7du3Y+4O0+l0OBwOdu/ezbFjx/jOd76DXq9ncHCQ\n", + "q1evcvr0ac6fP6+Mz5SUFGpra6moqMDpdALgdru5ffs2ra2teL3emLZXdnu43W68Xi+zs7N4vV6G\n", + "h4fp6Ojg7NmzDA0NKZt7stJlKzdw5eCSL7/8koKCAsrLywHIyMhAo9Fw+/Zt2tratqRtkiSxtLT0\n", + "yM3QuLg4xR1VWVmJ1Wpdtz81Pj5Od3c3c3NzUU8uojXYHiGEU5KkMSFEOrAhI3BxcZHFxUUkSSIS\n", + "iSgbhrm5udTV1XHp0iUmJye3TG8bFxdHSkoK1dXVHDx4kJSUFMWfNTMzQ2trKzdv3mR6eppAIMDY\n", + "2BharXadDht+tzmh1WqxWq289NJLDA0Ncffu3cdui9PppKSkBIvFsqEuIY1GQ0JCAjabTTGOoVCI\n", + "2dlZZVN3M9FoNJjNZoqKiti1axd6vZ6FhQXGxsY4e/YsHR0dMW9DUlKSYqj379+PyWSitbWV8+fP\n", + "895779Hd3b1uczsxMZGXX36Z4uJi5T2am5s5deoUbrc75iuVxsZGAoEA/f39zMzM0NXVxdjYGJOT\n", + "k8zMzHxjhhcfH09CQsKWGmyA2dlZzp07R11dHa+//vqWtiUajEYjVVVVyj5LcnLyuj5ta2vjzJkz\n", + "T7VxH63B/hD4Q+D/Wf39m6hbsIa1hri7u5vPP/+cvLw8MjMzKS8vZ/v27QQCAXw+30ac7olYG113\n", + "+PBhdu7ciU6no7m5mStXruB2u+nr66O3t5f5+fkHLpdkZJ+irHVOTEx8ovYkJSXhdDrR6/UEAoEN\n", + "8zHLxqayshKTyaSsZEKh0KbfKI1GIxkZGRw5coT6+nqMRiPLy8sMDAzQ0NDArVu3GBsbi2kb8vLy\n", + "qK+v5/XXX6eyspK4uDj6+/u5dOkSH3/8Md3d3coyPS4uDrvdTnFxMTk5OSQlJREMBmltbeXSpUs0\n", + "NTVtiutmenqajo4OQqEQoVCIyclJgsGgMi7vxWq1kpmZGbVaaaNYXl5W9nieBb3/4yAH9pWUlFBW\n", + "VkZxcTF5eXnrxACLi4tMTk4qGvynmfg8jqzv71jZYEwRQgwB/xb4D8CvhBB/DPQD34u6BQ9gYGAA\n", + "SZIoLi7m2LFj5OTkUF9fz9LSkuJPDQQCioY01siG9fDhw7zwwgs4HA7FH3jq1CmGh4eVL+JRsjJ5\n", + "V1mW+awNtnhcjEYjSUlJaDQaZmZmGB0djUrOJrtAjEajoic/fvw4FRUVaDQa+vr6njqcNloSExMp\n", + "KirizTffpLKyUlmWtre3c/HiRbq6umLmFpO/m5KSEk6cOMHevXsxGAyMjo7y5Zdfcv78ea5du0Yk\n", + "EkGr1WKxWEhPT6e4uJj6+nqcTieSJOF2uzl79ixXrlxhcHAwJm29l3A4zMTExDdy1ZjNZqxW6zc2\n", + "urOyssjKykKv1xMOhwkEAgQCgWcmOdlWG28562ZCQgImk2ndtZqYmMiePXvYv38/u3btwm63K9LJ\n", + "5eVlpqenlT2gwcFBlpaWnuqG/Tgz7BArOa/vrtFh/xwoBsaBVKAeOB11K+7D0tISHo+Hd999F6vV\n", + "yne/+13eeustysrK6OjoYHBwkJs3b9La2ropMz/Z3yz7JcfHx/nlL3/JhQsX6OjoWDe4H3UHldu7\n", + "Ue2emppieHg4qgtMp9ORnJxMSUkJO3fupLa2lj179pCWlqYsUVtaWgiFQptusJ1OJ+Xl5eTm5pKY\n", + "mMjCwgLd3d189dVXfPnllxvqu78XWRFSXFzMnj17MJvNjIyM8NVXX/FXf/VXdHR0KNGfssvmJz/5\n", + "CdXV1WRnZ2Oz2ZSVwKeffrrhOvloKCgoUAJn1hrByspK0tPT0el0+Hw+urq66OrqYnJy65Jwrg31\n", + "3uqUA2azmYyMDHbt2kVJScm6KEyz2UxZWRkpKSmYTCa0Wq1irOfn57l+/Trnzp3j9u3b3L17Vxkz\n", + "0RKtDlsC/rMkSf856jM/AkmSmJ+fp6enhy+++AKHw0FlZSU1NTXk5eUxOTlJamoqer2e/v5+Zmdn\n", + "YzojKC4u5tChQ6SlpREKheju7ub69ev09PQ8cWTWWjlfLGcPCQkJmM1mhBBYrVZF+y3PqLdt20ZC\n", + "QgJGo5HU1FSSkpKUwAmdTsf8/DydnZ14PJ5NNdbx8fFkZGSwd+9eDh06hN1uJxgM0tvbywcffMBX\n", + "X33F+Ph4TGWGQgjlZuZwOIiLi6O9vZ3Tp08zPDyshBrLaRTy8/PZu3cvLpdL0VkPDQ0pqpBY3lwe\n", + "1H6tVovZbCY1NZXS0lL27NmjuHXWjruUlBQcDgeRSITGxkY++eQTPB7PluWO2WoDLSNvItbX13Pg\n", + "wAFKSkqUgDcZnU63TmstE4lEGBkZ4caNG5w9e5bR0dENkZ1Gq8OGGKdVhZWZ6szMDNeuXVOSJhUV\n", + "FVFWVqYsUeLi4rh48SI9PT2Mj49veBIgOal6RUUFBw8exGKxMDg4yJ07d+jt7Y1aUigba3mD9UmN\n", + "z9oZSHJyMjk5OUxMTKwzDGlpaYpKISsri9zcXEWqZzab2bFjBwaDgUgkQiAQYHh4GK/Xy/z8PAkJ\n", + "CYrSYDNlkxqNhqSkJOrr6zl8+DB79+5Fr9czMDBAW1sbH330EV1dXTFfrssuEZ1Oh06nQwjBxMQE\n", + "breb7OxsSkpKqK2tpby8nMzMTOx2O3q9XskfI/vam5qaNnXDdm1wT1paGunp6Wzfvp1jx45RVVVF\n", + "VlYW4XAYnU63LpJxcXGRqakpOjo6uHLlyqb42h/2GZ4FtFotdrudffv28aMf/YiUlJT7+vnvjXQE\n", + "FJ324OCg4sLdiEnP08j6/rEQ4ies1Hf8F5IkxeyqHhkZ4fPPP2diYoIjR45w6NAh8vPzKSsrw2Kx\n", + "YLPZOHfuHNeuXWN2dnZDZ14Gg4GSkhKKi4uVMPLR0VHa29ufKl2rbHBlSeOT+mJlHagkSezcuRO7\n", + "3c7IyMg6BUJaWhppaWkIIdYZk6mpKSYmJmhubmZ0dJShoSF6enrweDzYbDby8/OxWq1EIhG8Xu+m\n", + "hqObzWYKCgr46U9/SlVVlbJ8n5ubY3x8nOnp6U3Jay4HR4RCIYLBIGazmePHj1NdXY0kSRiNRiwW\n", + "CyaTiaWlJYLBIKFQSPFxBoNB+vv7n3qcPAnyTSYlJYWysjLeeecdCgsLsdlsyuRGzg/vcDjYtm2b\n", + "cjOClZtlZmYmFRUV+Hy+dcqmzeRZmWGv5WEr4vsdMxqNlJSUUFVVxa1bt+js7NyQHCnRGuz/Avyf\n", + "q4//PfCfgD9+6tY8gPn5ecbGxhTx/MTEBJWVlVRVVZGXl8fBgwfR6/UYjUYuXLiwoTNCrVZLcnIy\n", + "ycnJGI1GFhYW6Ovro7W19YnkdPLFlJWVRXV1NUajkZmZGSUoqKen54na1dPTw7lz59Dr9WRkZCi5\n", + "P9ZeYLKOemxsjOnpaWZmZhSjJxtt+cfj8Si+OoPBoAQLxDLU+37IyZSKioqw2WzK8YGBAW7evMns\n", + "7OymGBFZy9zS0sKZM2fYv38/KSkppKSkEAwGlfwSQ0ND+Hw+NBoNNTU15ObmAigh6pt1s5N97mlp\n", + "aezdu5fDhw9z4MABFhYWGBkZwePx4PF48Hq9zMzMsHfvXpKSkrBarYqLxGAwUF5eztzcHD6fj/b2\n", + "diYmJjY9de1awyhJkpJOOdYh/feytLTE1NQUN27cICEhgaKiIsLhMFNTU+v6RG6rnOsmJyeH9PR0\n", + "LBYLSUlJ6zIiPi3RFuFVdNdCiP8GfLQhrXkIi4uLirD+zp077Nixgz/6oz8iPz9fEaknJSXR2tqK\n", + "3+/fsCWorKKQfVRzc3NRzZzkrH61tbUcO3aMhIQE3G43N27c4MyZM/T19T1Ru9rb2xkbGyMQCFBe\n", + "Xk5GRsZ9nxcIBGhubmZwcJCRkRFFdng/8vLyqK2txW63Ew6HY+4nXou8lC8qKuLFF1/EbDavW4V0\n", + "dHTw1VdfbZoqSJIkFhYWuHr1KouLi9hsNvLy8pTIzzt37tDU1MRXX32Fz+fD6XTicDjIyMhACEFb\n", + "W9umJt03Go04HA5qamp46623eO2114hEIpw/f55PPvmEO3fu0N3djc/nIy0tDbvdzu7du5Vc6rLa\n", + "Rb5RjoyMIEkS7e3tBAIBJT4CVgxZrG+aa5VU8fHxFBQU4HQ6lcjNzbiByDbn/Pnz3L17l7q6OiUQ\n", + "7n6bh0lJSezbt4+TJ08qrsiNJiqDLYRIl3NhA28ArRvXpIcTiUTw+XzcvHmTgwcPsry8rCwD5Wou\n", + "fr8/JvpceZk8Nzf3RH5JOUDmwIEDvP766+zbt4+lpSVu377NxYsXlVD8J8Xv93Px4kVu3rz5QFmg\n", + "HJYcCoVYWFh4qO/X4XAoSZXkJFWbladFp9PhdDrZvn07hYWFyucJhUJ0dHTQ2dm5qTcQmcnJSa5e\n", + "vYrb7VZSEMjSt9nZWaanp7HZbLhcLoqKikhNTWV6elrRPscaeeVWXl7OoUOHOHr0KEVFRczPz9PV\n", + "1UVDQwMXLlxQxlh2djZ/+Id/yMsvv4zT6USj0dDW1sbdu3eV79/hcPCjH/2IyspKbt26xZdffonX\n", + "61XGzuTkZMwVJGtnsEajkfLycoqLi3E4HFEn/4+Wubk5BgcHmZmZIRKJPFAx5fF4mJ2dJT8/nxdf\n", + "fDEmbXmowRZCZLHio7YBWiHEFPAvgKNCiBOAHpgB9sakdWuQZ6ipqamkpKQoqRjXbt7Jy9hYfZny\n", + "zu/ExMRjnUPW52ZlZVFeXs7x48fZvn07k5OTXLlyhcuXL9Pc3Bz1Bo+cOGujMBgMJCYmotVqcbvd\n", + "fP3115tmsJOSkjh+/DgvvPCCIjGT/cC//e1vuX379qb5gteysLDA+Pg44+PjD3yO3W7HYrGQmJhI\n", + "fHw8CwsLdHV1PfQ1G4EQApPJRGFhIS+//DKvvPIK5eXlTE1NKTlWGhoaGBkZUaqevPDCC0qBjenp\n", + "adra2mhoaKCtrQ2Hw6EkM3M6nRQWFpKamorL5VIyzM3Pz3P58mUaGhpi9rm8Xi89PT24XC4l57lc\n", + "W7SsrEzRv28Wi4uLijb9Uc97Wtneo3jUDDsCHJMkqVkIkQDcAq6wosH+95Ik/cfV9Kp/TJTZ+h6F\n", + "RqNRVA05OTns3LlT8V2XlJQoviG/38/Q0BDd3d0xu/vLOuDHuRDlG4zsYz98+DA1NTUMDQ3x2Wef\n", + "8ed//ueblsQ+GkZHR+no6Ng0I2mz2XjnnXeorKxUIsQmJiZoamriV7/61RP7+DeTezej5ubm+Prr\n", + "r2P+/Wq1WlJSUnjllVd47bXXqKmpIRAIcP36dT744AOuX7/O5OSkUpno5MmTvPbaa2RmZuL3+2lr\n", + "a+MXv/gF165dY3h4WJF6yhLA3bt3K/p8rVar5KSfnZ2NqcHu7+/nxo0bSpEKmezsbGpqamhtbY15\n", + "Eig5b/Xj+u/lyVl5eTnp6ekxa9dDDbYkSWPA2OrjgBDiDuBiA9OrPgydTofNZqOsrIzq6molGZRc\n", + "tkrehFheXiYUCim+642+w8kXpLw0e5C/eC2FhYXs2bOHI0eOUFRURHJyMnfv3uXjjz/mo48+2pLw\n", + "+mcZ+aa8VmrW09NDQ0MDk5OTz3RR3bGxMTo7O2NeLONe8vLyePHFFzlx4gT5+fl4vV4++eQTLl26\n", + "xJ07d0hNTaW+vp7S0lIqKiooKCggISGBS5cucfPmTRobG2lra2N8fFyJexgeHmZmZoaOjg6amprY\n", + "vXs35eXlmM1mJicn+fTTT7l8+YnLtj4Rfr8fr9e7JTpw2cWUnp6O1WplYGCAYDD4SPdnTk4OdXV1\n", + "vP322+zcuTNm7XtsH/aqFnsncI0NTK96n/Og1+uxWq24XC5KS0upra1l586d5Ofnk5ycrMzAQqEQ\n", + "brdb0egd8pInAAAMP0lEQVReu3YtprvyOp1OadOOHTvweDyKy8BisZCSkqLUpayoqGDXrl3s2LGD\n", + "+Ph4vF4v165d48qVK7S3t8esjRtFfHw8ZrN5w3a3H0ZmZiZVVVVKon/Z6Lndbtra2ggEAlsiL3tc\n", + "tFrtN6oMbQaFhYUcPnyY4uJiEhIS8Hg8LC0tkZqaSnV1Nbm5uUpF9JycHPx+Px0dHZw+fZobN27Q\n", + "29u7boN+bfENuYTV2NgYd+/eVVRNX3zxRcw3U2V33JEjR0hOTlZu4ikpKYrkdHJycsO1+GazWcm/\n", + "LReeuDftxFq0Wi0GgwGr1Up9fT3Hjx9n9+7dpKSkKC7apaWlDdXgP5bBXnWHvA/809Uajsr/NiK9\n", + "6roGrUYX7dixg/379/PKK68oaUTXnBMAn89HS0sLv/71r2loaIhZ+K+sVpCXPfX19QQCAT7//HPF\n", + "h1xYWEh9fT27du0iJyeH1NRUDAYDExMT9Pb2cvv2bS5cuEBvb29M2riRCCGUG9Bm5EjetWsX3/ve\n", + "97DZbOvkXJOTkwwMDDwzOS0eRFpaGkVFRd8I+Y41JSUlHDp0SEkclpiYyEsvvcSBAwcwm804nU4l\n", + "0EOSJG7cuMH777/Pb37zG7xe7yNXA0NDQwwNDXH+/PmYf5a19PT0oNFoeOutt0hLS1PcIgUFBQC8\n", + "9957Si7vjSQlJYWamhreeOMN6urqWFpa4tatW4yPj983w2J8fDypqans3LmTkydP8uqrr2I0GpXQ\n", + "9HA4zMLCwjqFzdPyOMmfdKwY6/8pSZKclW9D06vKkVlyxN7Ro0fZsWMH+fn5OJ3OdRUx5Iv45s2b\n", + "NDc3097ezvDwcMw3eGSEEOTn52MymaioqGBmZgZJksjKylLkUiaTiWAwSF9fH93d3comzejo6KYX\n", + "W4iGtfrSWBogOay3sLBQUacsLS0xOzur5I72+/3P9OwafjczW7s62Azm5+fx+/0kJCSg0+mU7Iaw\n", + "sgHW1dWF2+1mcHCQnp4e7ty5Q0dHx6bnkY+GSCSi+MvXhoLHsn+rqqr4wQ9+QGVlJQ6Hg0AgwMGD\n", + "B8nJyblv0EtGRgYFBQUUFRWRl5en3LDHx8fp6+ujqamJzz77bEOLfzxKJSKAvwbaJUn6f9f866nT\n", + "q8r6ZqfTSVZWFikpKaSnp1NYWMiRI0fYtm2bMnMIhUL4fD7Gxsbo7u6mra2Nq1evKtWnY/klyuHx\n", + "U1NTzM7OYjabsdvtJCcnk52drWzKyVnQFhYWlJl/Y2PjuiRVzxNGo/Eb+Xw3Grkqe0ZGBhkZGcTF\n", + "xSnRlZ999hmtra3Mz88/8wZbzncu64Y3i97eXi5evEhhYSFWqxW9Xq+EmMt+9f7+fgYGBujq6lJS\n", + "Fzzr/QkrN6O7d+9SVFREdna2cjyW13pGRgYVFRVkZmYqs/p9+/ZRXl5+X3+60+lk27ZtpKWlodFo\n", + "mJ+fZ3p6Wkm53NjYSHt7+4aKIB41w94L/BhoEUI0rR7712xAelWNRoPRaGT//v288cYbSnSQXHV8\n", + "re9UNoC//e1vuX79Ol1dXYRCoU0R0IfDYQYGBuju7mZ4eFgJnpDdI3K9NiEEoVAIr9fLlStXePfd\n", + "dzlz5gzLy8vPxQVyL3a7nW3btsW0crY8BuQq3RqNBr/fz+DgIB988AGdnZ1bUjThSZmYmKCvr49I\n", + "JBLzVclaLl68SEdHB7W1tYoEb3Z2llu3btHY2Ijf71dkrrLa4VkM+74fwWCQq1evUlFRwe7du7ek\n", + "DWazmRdeeOGB/abRaJSfYDCIx+OhqamJ9957j9OnTzM/P7/h4/dRBnsAuAQ4WMnQ9/9JknQ62vSq\n", + "er1eqWNYWlqKy+WioqKC4uJiLBYLRqNRMRDy0ri1tZXLly9z9epVenp68Hq9BIPBTQuXXVpaYnp6\n", + "mosXLzI3N0d9fT21tbVs375duTCDwSAtLS3KMr6zs5Ourq4trYH4NMhGZzM2HO81cPJmTSQSeS6M\n", + "NaxUShkeHmZsbIzU1FS0Wi02mw2z2bwh+SMehFx559q1a3R0dGAwGNblwl5rqJ835BiDkZERxsfH\n", + "v1FuKxY0Njbyt3/7t9TX11NWVkZWVtZ9V5iLi4vMzs6ysLBAKBRScgutvfbn5uZi0vePo8P+Z2t1\n", + "2EKIs0SZXlUOMT148CAHDx7E5XIpqo+FhQVmZ2eVemc+n0+pkdjQ0EBLS4uy7NxMZMmgLH8aGxtj\n", + "fHyc4eFhJWBndnaW69evc+PGDdra2p55GdqDCIVCzMzMbJqhXCvHDAQCz0T17miQV1Z37tzB4XAo\n", + "ebTdbjeBQCBmxR/kgg4DAwMb/t5bjRwW3tzcTFpampIpz+12Rx0Z/CjkLJATExNKErm0tDQMBgPL\n", + "y8uKgmZqaoqBgQFmZ2eZmZlhcHCQ1tZW2traYi5HjFaHDVGkV5V1zLt27aKyslJxfcgbDHfu3KGn\n", + "p4elpSWuX7/OlStXmJ6eJhQKxTyC6FHMz88rd/sLFy6scxXIO8LhcFiZ1TyPjI2N0dHREbOw2ntZ\n", + "XFzE6/XS399Pf38/hYWFm3LeWOD3+zl//jxOp5N9+/Zx/PhxJYmS2+1+5pUuzxqyL/43v/kNZ86c\n", + "UQJZZOlhLIzi9PS0El0rV4h54403cLlcLC4u8vXXXys/jY2NSi4fOcJxM679aHTYV1nxbT9xetVA\n", + "IEBDQwMej4cPP/xQOS5/CT6fj6mpKSRJYnR0VCl79Sws6eQ8InIukd9HBgYG+OSTTxgaGlJULrGM\n", + "KJPdXhcuXGB0dBSr1apUGrq3vNWzztzcHM3NzZSVlZGfn09ubi779+8nGAxy+vRpxsfHnxsXz7PC\n", + "8vIyc3Nzm3a9yRMv2TjPzs7S1taGxWJZNy7Hx8fxeDwEg8FND+4Rj2MMV90hF4H/S5Kk3wghHKz4\n", + "r2ElvWq6JEl/fM9rtt7KqqhsEnKhi6NHj/Lmm29SV1fH/Pw8TU1N/Nmf/ZmyUa6i8jhIknRfD8aT\n", + "6LD/l6zD3or0qioqzzJy4jE5s93ExAT79u2jqqqK9PR0RkZGVIOt8tREpcPeyvSqKirPKnKV7I6O\n", + "Dk6dOkVraysGg4He3l7VWKtsCA91iQgh9gFfAC2sKEMA/g3wQ6Bq9Vgf8A/W5BaRX6u6RFRUVFSi\n", + "4EEukcfyYUeDarBVVFRUomPTDbaKioqKysYS+1A2FRUVFZUNQTXYKioqKs8JMTPYQohXhBAdQoiu\n", + "1TJiKqsIIfqFEC1CiCYhxPXVYzYhxFkhRKcQ4jMhRPKj3uf3ESHEfxdCeIQQrWuOPbBvhBD/enWM\n", + "dQghjm5Nq7eGB/TVz4UQw6tjq0kIcXzN/76VfSWEyBJCfC6EaBNCfC2E+Cerx5+/cSVnotrIH0AL\n", + "dAM5gA5oBkpica7n8YcVZY3tnmP/EfiXq49/BvyHrW7nFvXNi6xE1LY+qm+A0tWxpVsda92AZqs/\n", + "wxb31b8D/vl9nvut7SvACVStPk4A7gIlz+O4itUMezfQLUlSvyRJEeB/A9+J0bmeV+7dBX6dlfqY\n", + "rP7+e5vbnGcDSZIuA1P3HH5Q33wH+DtJkiKSJPWzcmFtTS7OLeABfQX3z/Pzre0rSZLGJElqXn0c\n", + "ANbWpn2uxlWsDLYLGFrz9zC/SxqlsqJfPyeEuCmE+Purx2JWJ/P3gAf1TQYrY0tGHWcr/GMhxG0h\n", + "xF+vWearfcVj16Z9ZvsqVgZb1Qo+nL2SJO0EjgN/KoRYlx5PWlmXqX14Hx6jb77t/fZfgFxWAttG\n", + "gf/0kOd+q/rq3tq0a//3vIyrWBnsESBrzd9ZrL9jfauRVsP6JUkaB06xstzyCCGcsBL6z1PWyfw9\n", + "40F9c+84y1w99q1FkiSvtArw3/jdUv5b3VcPq027+v/nYlzFymDfBAqFEDlCCD3wfVbqQH7rEUKY\n", + "hBCW1cdm4CgruVjkOpkQZZ3M32Me1DcfAj8QQuiFELlAIXB9C9r3zLBqeGTW5vn51vbVY9Smhedk\n", + "XD12PuwnQZKkRSHEPwLOsKIY+WtJku7E4lzPIWnAqdWyWHHA30qS9JkQ4iZPWSfz9wEhxN8BB4AU\n", + "IcQQ8G95QA1RSZLahRC/AtqBReAfrs4svxXcp6/+HfCSEGJdnh/41vfVE9WmfZb7Sg1NV1FRUXlO\n", + "UCMdVVRUVJ4TVIOtoqKi8pygGmwVFRWV5wTVYKuoqKg8J6gGW0VFReU5QTXYKioqKs8JqsFWUVFR\n", + "eU5QDbaKiorKc8L/DzAr6bE92WeRAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# we use a little trick to tile the first eight images\n", + "imshow(solver.net.blobs['data'].data[:8, 0].transpose(1, 0, 2).reshape(28, 8*28), cmap='gray')\n", + "print solver.net.blobs['label'].data[:8]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 7. 2. 1. 0. 4. 1. 4. 9.]\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAWwAAABKCAYAAACfHW4mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnWlwXNd153+3V3RjaaDR2Bs7sRMgQIKgKAokuIgUpcg2\n", + "q+QljstO4kpS9iQzlUlqMpkPSWZSlclM1SSTmg+umrI9ZWdGViS5ZMuyJVIUSJEUwA0QSew7QKCx\n", + "Aw2ggd4bbz4A7wncRABEo4Ho/apYbLzeTt9+fd695/7POUKSJFRUVFRUdj6aSBugoqKiorI+VIet\n", + "oqKisktQHbaKiorKLkF12CoqKiq7BNVhq6ioqOwSVIetoqKiskvYtMMWQrwkhOgUQvQIIf5iK41S\n", + "UVFRUXkUsRkdthBCC3QBpwAHcAv4bUmSOrbWPBUVFRUVmc3OsGuAXkmSBiVJCgBvAF/eOrNUVFRU\n", + "VB5msw47Axhe8/fI6jEVFRUVlTCh2+TznhpHEUKoOe8qKioqm0CSJPG445udYTuAzDV/Z7Iyy1ZR\n", + "UVFRCRObddi3gQIhRI4QwgB8HXh368xSUVFRUXmYTYVEJEkKCiH+GDgPaIEffdEUIlFRUeTm5mI2\n", + "mzEYDMTGxpKUlITVagVgYmKC0dFR5ubmGB8fZ3p6OsIWq6io7HY2JetTnizEILAAhICAJEk1a+77\n", + "VxvDNhqNpKWl8Vu/9VukpKQQHR2N3W6noqKCoqIiAD799FMaGxvp6enh2rVrNDc3s7y8HGHLn4xG\n", + "o8FkMmE0GvF6vfj9foLBYMTsEUKg1+sxGo3o9XoAgsEgHo+HQCAQMbtUVLaDJ8WwN7vpqLwuUCdJ\n", + "0uwzvs6u4tChQ7z66qscPXqU+Ph4dDodUVFRxMbGIl8Ac3NziYmJobS0FLfbTX9/PwsLCxF1gk9C\n", + "r9djtVp57bXXqK2t5fz58zQ0NNDV1RURe4QQGAwGqqurOXbsGPv378fv99PV1cXbb7/N4OAgS0tL\n", + "EbFNRSWSPKvDBnjsleBfI9HR0ZSVlXHmzBnOnDlDXl4eJpOJUCiE2+1mdnaW4eFhTCYTCQkJZGdn\n", + "k5CQQHl5OXfu3KGtrW3HOuzU1FSqqqo4cuQIra2tmM3miNmj0Wgwm81UVFTw6quvUlZWRiAQwG63\n", + "09HRgcvlipjD1mq1xMbGsmfPHhITE2lsbGRhYeGpz4uNjSU6Ohq3271jVgl6vZ7ExESKiopITU2l\n", + "p6eH4eFhpqen2Y7GJjqdDovFQllZGQCzs7OMjo6yuLiI3+9f9+totVqMRiMWiwW3243L5drRq9ln\n", + "4VlriUjARSHEbSHEH2yFQTsVIQSJiYl885vf5Ctf+QplZWVERUURDAZZWlrC4XBw+/ZtLly4QGNj\n", + "IyMjI2i1WqxWK8XFxezbtw+TyRTpj/FY9Ho9GRkZWCwWgsEgTqcTt9sdMXt0Oh0JCQmUlpZSXV2N\n", + "yWTCYrGQl5dHeXk5KSkpEbPNYDBgt9v5+te/zp//+Z+v25aUlBRKS0tJT08nJiYmzFauD5PJxN69\n", + "e/n+97/PP/7jP/LVr36VPXv2oNFoECL887Do6GgKCgr43ve+xx/+4R/y8ssvk5WVteHfSVRUFMnJ\n", + "yezbt4/MzEy0Wm1Y7RdCoNPp0Ov16PX6bRkrmWedYR+RJGlMCJEEfCiE6JQk6epWGLbTSEhIoKCg\n", + "gKqqKtLT0wkEAkxPT1NfX8/ly5eZnZ1lenoal8uF2Wzmtddew2KxkJycjMFgwGw2o9HszFpber1e\n", + "cSTz8/O0tLQwOjoaEVuMRiOZmZl84xvfoLq6OiI2fB5RUVEUFhaSlpa2IceQnp7O4cOHEUJw5coV\n", + "rly5EmZLPx+j0UhGRgavvfYalZWVxMfH85WvfIWRkRGamprCOkPVaDRERUXxyiuv8I1vfIOysjIc\n", + "DgdDQ0MsLCyse7Kg0WgwGo289NJLfOlLXyIlJYVf/epXTE5OMjs7G5bVrF6vx2azcfToUbKysvD5\n", + "fLz11ltMTExsy6z+mRy2JEljq/9PCSHeYSVlfV0OW46bJicnY7FY8Pv9hEIh/H4/09PTeDwe/H4/\n", + "Xq93RyxvYmJiSEtLIz09Hb1ez/j4OFevXuXdd9/l0qVLir1arZasrCy8Xq+yrPR4PMzPzxMKhSL8\n", + "KR7FaDSSlJREeXk5UVFRDAwM4HA4cLlc22qHwWBQxresrIxTp06Rl5f3wGPkmXdmZiYzMzMsLS3h\n", + "crm2bTUghMBkMlFcXExaWtqGLsA6nY74+Hjy8vIYHBxEq9WyvLy8LaGHxxEbG0tOTg7V1dXY7Xa0\n", + "Wi1xcXFERUWF1SatVovFYqG8vJxTp05x5MgRnE4n9+/fp6uri/n5+XWHi4xGI4WFhdTW1lJXV8fY\n", + "2BhCiLD4C9lR5+TkUFZWxsmTJ8nOzmZmZoaPPvqI6enpne2whRBmQCtJkksIEQ2cBv7zep9vMpmo\n", + "qKigrq6O8vJynE4nXq+XmZkZrl27hsPhYHZ2lomJiQ3Fs8KFyWQiLi4OrVaLy+WitbWVH/zgB7S2\n", + "tj4Qw4yPj+fYsWMcOHCAlJQUdDodY2NjdHR04PV6I/gJHo/FYmHPnj3U1dXhcrn49NNPIxIOiYmJ\n", + "4YUXXuDw4cPs37+f0tJSoqOjH3iM0WgkLy+PpaUlrFYrQ0NDdHV1cf/+/W2xUQiB2WympKSE1NRU\n", + "pqam1v1cp9PJxMQE1dXVJCQkYDAY8Pl8EXPYNpuNPXv2kJSUhMlkYn5+njt37jA4OEgwGAybXUaj\n", + "kaysLH73d3+X2tpalpeXuXnzJj/72c94//33N+T04uLiOHXqFAcOHECj0fD+++/T2NgYFgmt2Wxm\n", + "//79nDt3jtOnT2Oz2TAYDHR1dREXF4dOp9uWfYmnOmwhxI+BV4BJSZLKV49ZgV8CB4UQflayHP9Z\n", + "kqQL631ji8XCK6+8wuHDh0lPT1dm2D6fj0OHDrGwsMD8/DwOhwOfz7eu1wyFQiwuLtLR0UF7ezsT\n", + "ExNbNohjY2NcvnwZj8eDRqNhfHyc3t5ePB7PA48zm81UVlaSlZWlLJklSYrYD/NpxMbGKtLEnp4e\n", + "7t69+8hn2g7i4+N59dVX2bdvH1arFaPR+Mhj5Jir3W7nueeeY3x8nA8++IALFy4wOTkZ9h9MUlIS\n", + "JSUlFBYW4nK5aGpqWvfFTa/XExsbS2pqKgkJCej1+ohMRIQQaLVaSktLOXHiBLGxsQC43W6am5u5\n", + "f/9+WM9VeZVRWlpKUlISMzMzfPjhh7S3t2/YWefn53Py5EliYmJoamqisbGR4eHhpz95g5hMJrKz\n", + "szl37hyHDx8mMTFRiV3Hx8fz5S9/Gb1ez+3bt8MeEVjPDPv/AP8L+OmaY/8R+JUkSbWrtbATJEn6\n", + "rxt5Y1lnGwgEmJ+fx+v1KvK4goIC5Qcr3xcKhTAYDA/EDGVHGAwGlY2ShYUFrly5gt/v39Dy6mks\n", + "LCzQ3d2txKr8fj8ej+eBLychIYH8/HxKSkpISUlBkiRcLhfz8/O4XK4dGRJJTU2lqKgInU7H6Ogo\n", + "XV1d274SSE9Pp7q6moMHD5KTk/NYhyGHD6xWK0lJSQghmJ+fB8Dn8/HBBx8wOxsedakccy0tLaW2\n", + "thabzUZTUxMNDQ0sLi6u6zXi4uJIT0/HarViNpvRarVhsfVpaDQaYmNjlf0Ys9mMJEm43W7u3buH\n", + "w+EIy/vKG3WpqakUFhaSnp7O0tIS9+7do7m5ed17JvJ3UVJSwvHjx6moqGB0dJTm5ma6u7txOp1b\n", + "bntycjLl5eUcOnSIvLw8jEajco7GxcVx/PhxJEkiOjqawcFBxsfHmZubC8uF76kOW5Kkq0KInIcO\n", + "fwk4tnr7J8BlVpz4unE6nbz11ls0NzcTHx/P2NgYsbGxZGRkkJ2dTWFhIbm5uWRmZipSKKvVqiRR\n", + "AIrjdLlcmEwmoqOjkSQJv9/PxMQE7e3tWxqLlRUUwGNnzYWFhZw8eVLRYPv9fu7fv09vby/379/f\n", + "EaGdhykqKqK2tpZgMIjD4WBkZGTb7XzhhRf47ne/i81me+Imnt/vZ2lpCZ/PR0xMDBaLBavVyquv\n", + "vkp2djZNTU1hc9iy7PHFF1/ka1/7GsFgkKamJj766KN1n19ybD4qKiosNq4X+bPk5OSQkZGBRqNR\n", + "HHZnZyfj4+NheV+NRkNMTAz5+fmUl5djMplobGzkjTfeYHh4eN3nnGz/K6+8wne+8x1sNhu3bt2i\n", + "paVlSydoayksLOT48eOKgGAtJpOJffv2kZ+fz+nTp3n33Xc5f/48TU1NYQktbTaGnSJJ0sTq7Qlg\n", + "wzorr9dLR0cHDocDo9HI4uIiBoOBmJgYYmNjSU5OVjah5BlqZmbmA0vlYDCI1+tlamqKuro6Tp8+\n", + "jdFoJBAIhE2L+bjXjIqKIjMzk+PHj3PmzBkSExMJBoPKkv3evXsPbELuBGQ9cWZmJllZWXg8Hrxe\n", + "77baKW807tmzB7vdjl6vf+RC6Ha76ejooK+vD4fDgcfjITU1VZkhxsTEYLPZqKmpwev1MjQ0tOV2\n", + "xsbGUldXR0VFBcvLy/ziF7+gsbGRxcXFp55jspIhIyOD/Pz8iDtsk8lEWVkZGRkZyix/cnKS3t5e\n", + "lpaWwract1gsnD59mpdeeon9+/ezsLBAS0sLzc3NuN3udZ9zBoOBnJwccnJyiImJoa2tjYaGBpqb\n", + "m7dcm6/VaomJiaGkpISamhpiYmKUFbPb7cZqtWKz2dDr9cTFxZGdnc3JkycZGRmhvb2dpaWlLV9V\n", + "P3PijCRJ0mbS0AOBABMTE0xMTDz2frk+R2pqKi6XC5fLRUZGxgMOOxQKEQgE8Pv92O12Tpw4wfLy\n", + "MhMTExu6aj8rRqNRcSAVFRVotVqmpqbo6enh8uXL9PT07LhwiDxTkWOqcrLCdiX26HQ6rFYrhw8f\n", + "Zu/evSQmJqLVapEkieXlZQKBAIuLi4yMjPDhhx9y79497t+/j8/nIyMjg+rqanJycjCZTMTExFBX\n", + "V8fS0hJerxen00kgENiSC4/ZbMZut1NbW0tOTg5Op5OLFy/S3t6+rrEyGAxkZ2eTnZ1NYmIii4uL\n", + "uN3uiJ0PUVFRFBcXk5qaCqysFIeGhhTHGS5MJhOVlZVUVVWRlZVFd3c3Q0ND6155ajQaLBYLOTk5\n", + "HDx4kNzcXPx+Px9//DENDQ1huVDrdDqSkpLIy8tT3q+jo4O2tjbcbjd5eXmUlJRgs9mUXIGKigqq\n", + "q6tpa2tTkry28iK4WYc9IYRIlSRpXAiRBkxumUWrBAIB5ubmlA8sSRJLS0uPLJmjo6PZt28faWlp\n", + "iiKjra1tWzfP5GQK2ekIIRgZGeHmzZu0tbVtSE2wXciKi6SkJEKhkBJu2C7MZjP5+fl8+9vfprKy\n", + "koSEBGXGJ4ee2tvbaWxs5O2332ZkZASPx4MkSYyNjbG8vMzZs2dJTExUNrCNRiMajUbRxW+Fw7bb\n", + "7dTU1Ciz+cHBQQYHB9cdK42NjeXkyZMUFRXh9Xrp6+tjbGwsYnJVo9FIbm4uiYmJSJJEKBSipaWF\n", + "8+fPrytj81mR95xkvXUoFHrq9yTvd1VUVChZxrm5uYyNjfHmm29y9+7dsNgq5yfIobqhoSHeeOMN\n", + "3nzzTbRaLXv37qW2tpazZ8+Sm5tLfHw8sbGxnDhxAq1Wyz/90z/R19e3pXtCm3XY7wLfAf7b6v+/\n", + "2DKLVpFPprUzkYdnJQaDAZvNxssvv0xFRQVut5urV69y79495ubmtmW2WFlZSV1dHXV1deTn5+P1\n", + "eunv76e+vp4PP/yQmZmZHTe7hs9ORovFwtLSEtevX2dgYGDb3l+r1WI2m0lPTyc+Pl7ZNJ6dnaW3\n", + "t5cLFy7Q3t5Of38/Q0NDD4QfnE4nfX19XL16FaPRSFlZGQkJCdTU1BAMBunr68Pj8WzJEtlut1NZ\n", + "WYnNZmNkZITbt2+vW1NvMplIS0vj0KFDZGVlKRviXV1dYZXOPYn4+HhycnIoLCzEZrMp+z3j4+P0\n", + "9/eHfUUqf1551fHiiy8SHR2Nz+djaGiIkZFHS+onJCSQmppKeno6VVVVHDhwgNzcXBYXF+ns7GRy\n", + "cjJsEzM5nKXX65XfSEtLCxMTE2g0GuViIyte4uPjEUIQFRVFdHS0ohDbStYj6/sZKxuMNiHEMPBX\n", + "wN8DbwohvgsMAl/bUqvWSXx8PIWFhZw4cYK8vDwmJye5ceMGPT09YZ8tyvKoqqoqvvrVr1JSUoLZ\n", + "bGZ2dpbr169z6dIlbt++vSM3Gg0GA/Hx8eTn52OxWJiZmaGhoWFbHbY8flFRUUrs2uPx0NfXR319\n", + "Pa+//jpDQ0OPnZ34fD4mJia4cuUKdrtdiQ3n5eURCoVISkrakgJRGo2G9PR0SktLldl1Q0PDul9X\n", + "zo7du3cvVquV4eFhrl27Rm9vb0Rm11arlT179pCZmUlsbCx+v5/JyUnGx8fDtmErEwqFmJ2dxeVy\n", + "odFolBCmvPJoaWmhvb39keelpaWRl5dHfn4+2dnZJCUlEQgEaG1t5ebNm2GtKaPVaklISMBsNisX\n", + "FXnlFgqFGB8fJyoqSlGASZKEEAKv18vCwgJ+v3/Lv+f1zLA9rNS87lqjw/4boBiYApKA54APttSy\n", + "dZCfn88LL7xASkoKGo0Gl8vFxMTEuqVWz4KcGZaRkaHEUuWNxgsXLtDa2hqWL2wrsFqtlJSU8Pzz\n", + "z2OxWOjp6VF065HC7/cr8eq33noLh8PxuRc7j8dDe3s77e3tiu794R38Z0EuN5uSkqK8dl9fH9ev\n", + "X1+3k8jNzeXw4cMkJSUpn6+rqytiITKr1aps7gIsLi7S2NhIf39/2N/b5XJx7do1cnNzKS4uJi4u\n", + "DpvNhsViQZIkiouLHztTNhgMGI1GDAYDBoOBYDDI7OwsN27c4IMPPghrGMdsNlNVVYXdblcyXJub\n", + "mx8Iwcjh0ISEBOXYzMwMQ0NDuFyuLV/lb1aHLQH/IEnSP2ypNetErjJ28OBB6urqsFgstLa28v77\n", + "79Pd3b0tsTiLxcLLL79MTU2NUmLV4XBw9+5durq6mJmZ2ZHOGlYSQIqKisjIyCAQCDA2NobT6dzW\n", + "GLaMEAIhBE6nk9dff52LFy8yMDCA2+3+3PFbXl5W5J5+v1+Z3URHR1NTU8PU1NQzaXJl3XBcXBzR\n", + "0dEMDAxw//79DZ1bCQkJyo99bm6OsbExXC5XxCr1yfasdXzbtbLy+Xz09vby61//mqmpKdLS0khN\n", + "TSUjI4OioiIsFgsajYbBwcEHVlVy8tuLL76I2WxmaWmJkZERent7GRwcDOsKNhAIMDo6yvz8PHl5\n", + "eeTk5JCZmUlqaioWi4WUlBT27dtHRkYGOp0Ov9+PwWAgKSmJwsJCUlJSFEXJVrFZHTZEsKyq0Wgk\n", + "Pz+fAwcOUFVVRTAY5ObNm7z99tv09/eHfbNRlqOdO3eOAwcOYDAY8Pv9dHd309DQwNjYWESyBddL\n", + "UlISe/bswWKxMDg4qGzobecFRq4fLm/Syrr8jo71NS6SS7CazWZls1GOHxYWFnLr1q1ntlGj0aDT\n", + "6RQlhdPpRKPRPHWchBBoNBoSEhJIS0tDr9czPz/P2NhYRJy1XF88NTWV3NxcDAYDgUCA2dlZ7ty5\n", + "89jY8VYTDAaZmpri4sWL3Lx5E7vdTkFBAfv27SMQCGA0GpmYmODmzZsPaNu7u7uRJInq6mri4uJY\n", + "WFigra2NgYEBJXEqXHg8Hu7du8ehQ4c4ePAgdrudsrIyJicnSU9Pp6SkhL1792KxWJiensbtdmO3\n", + "20lNTWX//v0UFxczMzOzvQ77c/gTIcS3Wenv+GeSJM1tkU1PRZYmpaWlEQgE6Ovro7Ozk6GhoW2J\n", + "GaelpVFZWUl+fj7x8fH4fD76+/v5+OOP+fDDD7dlhv8sWCwWRVXjcDhoaWnZ9gtMXl4ezz33HGaz\n", + "eVNFkEwmE6WlpZSUlJCeno5Op2N5eZn5+XkuXLiwbsf/JCRJwufzMT09zdTUFDabDZvNhtlsfurs\n", + "f22SSEVFBSaTienpaQYGBiKyp2E0GsnJyaGqqorKykplprq0tITT6dzW715Wf3k8HkVJ9dZbbyGE\n", + "UPIn1m7o6nQ6SkpKkCSJ+fl5Ojs7eeedd2hpaQm7rV6vl97eXhwOB6FQiOTkZF577TVefPFFDAYD\n", + "JpMJjUaDw+Hgo48+oq+vj9///d+noKCApKQkamtrGR8f39J0+c067B8A/2X19t8C/wP47pZY9BQ0\n", + "Gg3R0dEUFxeTkpKixMba2trWlcjwLMgzleLiYmpra0lOTsZoNOJyuRgZGVEq3e3EJgXw2a53amoq\n", + "drsdj8dDb29vRBy23FJtI4kkGo0Gg8FAdHQ0OTk51NXVUVxcTFRUFBqNRsl6HRsbe+aLpqygmJub\n", + "Y25ujoyMDA4fPozT6aSjo+ORWZNOp1OaFMTExJCQkEBVVRVxcXHAZ5makVAMyVUOExMTFSWD0+lk\n", + "eHh42zXhy8vLD+jsnxbPr6ioUDIje3t7qa+vp7W1lZmZmbDbGgqFmJmZoampifr6eg4fPqyEcQCl\n", + "qFt9fT3Xrl1jfn6eAwcOKCuriooKmpublZozWzHOm23Cq+iuhRA/BH71zJasE5PJRHJyMsXFxSQk\n", + "JDA1NUV9fT1dXV1hX9LrdDoSExOprKzkhRdeIC4ujlAoxMLCAn19fVtabCocyPZnZWWRlpaG0+mk\n", + "t7eXnp6ebbdFDss8rsjTk9DpdNhsNrKysqiqqlLUQbDy45IbHm/Fj0PWC8/OzjI+Pk5eXh61tbWk\n", + "pqZy8eLFR+LjcpgsOTkZm81GUlIS2dnZyspBrj0TiWxXrVZLfHw8ZrNZkZqNjY3R2dm5IytIwmeT\n", + "o71793L8+HGio6Pp7Oykvr6eycnJbVmpLC8v4/V6uXHjBhqNBpvNRmFhIdHR0SwvL9Pe3s57773H\n", + "z3/+c8bHx4mPj+f27dtkZ2eTnp5OXl4eBQUFZGRkMDg4GDmHLYRIk2thA+eA8K9PViksLOTUqVMU\n", + "FRXh9/tpb2+nu7t7W664sbGxHD16lJqaGjIzMzEYDIyMjHDjxg3efffdZ16Ghxuz2Ux1dTWFhYWK\n", + "7eGWc20lchJKXV2dUsfZaDQqiRj19fW8++67W7qP0dbWxi9/+UsASkpKlLTux62iQqGQIlW0WCwP\n", + "dJYZGhri9u3bEWltJpcyzsjIUJxQV1fXhhQv243ZbKa0tJTnn3+e/fv3o9PpcLvdTw1HhQNZLhwV\n", + "FaXowL1eL5cuXXog18LlcvHRRx8pq5m8vDwOHDjAyMgI//Iv/7IlF8fPddhCiExWYtRWQCuEcAJ/\n", + "BpwWQrwCGIB54MgzW/IU5ALihw4d4uTJkyQmJnLnzh0++eQTJiYmtkXhEBMTw9GjR9m7d69Sq7mz\n", + "s5MPPviA1tbWHe/85IQFudrd3Nzcjv3BPkxBQQEHDx7k2LFj1NTUUFhYqNzn9/uZmpri3r17NDY2\n", + "4nQ6tywsNT4+zo0bNwiFQpSXl5Ofn09MTMwj1fZkna7X6yU2NpYDBw6Qk5OjrCAWFhaYmJjY9pCI\n", + "wWAgMTGRqqoqMjMzFccyNDREd3f3jp1hR0VFUVZWRkFBAXFxcQwPD3P//n2mpqa2PeTo8XgYHR3l\n", + "ypUrjIyMkJaWhs/no7Ozk8HBQaUMglzsraWlhZKSErKzs8nNzaWqqorz589vyXn5tBl2ADgjSdId\n", + "IUQM0AQ0sqLB/ltJkv77annV77LBan0bQS4cX15eTl1dHbW1tSwtLdHS0sKlS5e2rTtKTEwMhw8f\n", + "fqATSmtrK7/5zW9wOp2EQqFHUucfXgKvvV+WtOl0usc+LxAIbG0dgtWQiLykW1xcjIiUby3y55bH\n", + "QR4Lg8HwQG/Buro6fud3foe0tDRsNtsDr+H3+xkeHqavr2/LmxksLi7S09NDT08P9fX12O12UlJS\n", + "HqgaCSs641u3bik1b77//e9z9uxZrFYr8FnsdrtDImazWdkkT09Px+fz4XQ6GR0djVgbuPUQFRVF\n", + "UVERKSkpeDweWltb6ezsZGxs7OlPDgOysODzNOtyGG1oaIg7d+5w9OhRJVnJZrMxNjb2zDkin+uw\n", + "JUkaB8ZXby8KITqADLagvOpGMBgMpKenc+7cOSorK5WrW1tbW8TLlsoVBoPB4CNXz+XlZXw+n5IF\n", + "JW+ayT92efZTU1OjFJKHlS/e6XRy6dIlZmZmtmxGIdcRTktLUxJPIvUDkC9W8j85McFoNGK1Wjl7\n", + "9iwZGRlKQ9aMjAylWuPDddFnZ2f58Y9/TENDQ1htnpubw+fzMTIy8kh7sEAgoIRhgsGg0sJMxmKx\n", + "KF1qtnOfIzExUZnpCyHweDy0tbXtaGcNnynBbDYbMzMzShG13cDIyAjXr1+npqaGgwcPkpGRwdGj\n", + "R3G73c9c92TdMexVLXYVcIMtKK+6gfdlz549nDhxQskam5qa4pNPPqG9vT3iErri4mLOnTv32Nia\n", + "z+fD4XCwuLhIMBjEaDSSkpKizBD1ej0JCQns37//gXinJElKEfS7d+9uiVONjo4mJSWFzMxMLBYL\n", + "ExMTjziV7UTOBpO7r8TFxXHmzBlmZmaIj4/nxIkTpKWlKSoS2bE/XH51dnaWzs7ODRXB3yw+n29d\n", + "KxI5TrzWMcsz7O1GLj+r1+sJBoPMzc1x8+bNsFS32yoSExPZs2cP2dnZREdHMz4+Tmtr646/yMi4\n", + "XC4GBga4evUqKSkpVFVVcfz4cRwOh9KlarPnwroc9mo45OfAv1vt4ajct9nyqut8XzQaDbW1tfzR\n", + "H/0ReXl5uN1u+vv7+c1vfvPY2gPbwVqHcerUKU6dOvXYxy0sLHD9+nUcDgderxeLxcK+ffsoKyt7\n", + "6uvKnZ+Xlpa2xGHLPfxsNtuGlBnhor+/n8bGRvLz8zGbzVitVn7v937vEYf8cAhBPtHl4z09PRuq\n", + "77EdPLx6gJUfcbiaA3wesgxSlj3KNVj6+vq23Zb1kpeXx5EjR0hNTUWn0ynZjXNz25bq8UxIksTC\n", + "wgKXL1+mrKyM559/nlOnTtHV1cUnn3zy1LILn8d6ij/pWXHW/yxJklyVL+zlVWFFjiTXP5BrINy9\n", + "e5d33nmH/v7+bf+RejweOjo6SExMVLSYn4e8O19QUEAoFEKv1xMfHw981vJKdjyjo6MMDQ0pTYcX\n", + "FhZoamovsU04AAAJfUlEQVRicnJrhjY9PZ29e/diNpuZn5+nv7+frq6usDQsXQ9yGv9LL71EfHz8\n", + "ui4ioVAIt9utdNm+ePEibW1t9PX1hT3rbSPI3+va7zdSzStSUlKUlntut1uZBOxk+enapKq1Dax1\n", + "Oh0Gg4GoqCi8Xm9EmkWvFzmt/ZNPPsFut3Ps2DHKy8s5e/Ysv/jFLza9Af00lYgAfgS0S5L0P9fc\n", + "FfbyqnK9kMOHD1NWVobRaGRgYIDGxkauXr26bVrMtbhcLi5dugSsCPof3ig0Go1ER0djtVrR6XRK\n", + "k4D5+XmlVsfY2Bj3799XwhHyEtvhcDAwMMD4+Dh+v1+JlT6rQ5VXKRkZGZSWlmIymZiYmKCrq4vR\n", + "0dGIhkQ6Ojq4fv06brdbqS3x8GbeWnw+H93d3XR0dHDnzh3Onz+vdKHZSQ5IHnP5/IjEZqNsh6y7\n", + "NxgMzM3Nsbi4qPRI3alYrVbF5oWFBZxOJ4mJidhsNpKTk5Ekid7e3h29SpDzM1paWkhNTaW0tJSs\n", + "rCyOHj1KY2Mjc3Nzm7rgPG2GfQT4FnBPCPHp6rG/ZBvKq5rNZgoKCvje977H/v37mZ+f57333lPq\n", + "JEciHjgzM8NPfvIT+vr6eP7555U6GDJyd4rnnntOyXADGBwc5Pbt28qGk8vl4ubNmwwODir68YdV\n", + "BPLs7Fk/p1z83W63K1mBDoeDe/fusbS0FLGZn9vtpq+vj5/+9Kfs37+f5557jjNnzjxQ9exhFhYW\n", + "+Oijj3jvvfe4deuWUlN6J7Veg8/GXO6gEwgEtt1ByuVrY2NjSUxMRKfTKR2agsHgji1M9jCSJBEV\n", + "FUVVVRV79+6lsrISh8PBm2++uaMdtszQ0BA3btzglVdeobKyksrKSjIzM3E4HGFx2EPAx0AyKxX6\n", + "/rckSR9sR3nVnJwcnn/+eaV32/j4OL29vYyPj0dsdiBrLdva2pienn4gRgkrO9txcXGPNOucmZlh\n", + "ampK6TIi64ZdLlfYdbBrW24tLCzQ0dHBtWvX+OSTTyIa95XrX3d3dzM7O0t3dze9vb2Ul5dTVFRE\n", + "dnY2c3Nz9Pf3097ejtvtxuVycePGjW1t/7YZzGYz+/fvJy0tjcnJSW7evBmRpCpJkpibm2N0dJS0\n", + "tDSWlpa2VHW0HWRnZysJK4uLiwwODvLxxx/vGsWI1+tlYGCAH/7wh3zrW9+iurqaY8eOMTMzs6lw\n", + "53p02H+6VocthPiQMJZXlTuRyFlOSUlJSjnIqampbal1/TQ+rxflTiQUCjE4OMiVK1eUrjzd3d0R\n", + "DyMEg0Gmp6eZnp5maGiI0dFRenp62LdvH4WFhUxPT9PR0UFzczOLi4sEAgGmpqZ2/OaTrHdfWFjg\n", + "3r17vP/++3R1dW2rDfLKY3h4mObmZmw2G+Pj40xOTu54hz09PU1fXx9msxmtVqusVuSs4oaGhl2j\n", + "GJHP8YsXL1JWVkZVVRUHDx6kra2N5uZmfD7fhlY7m9VhQ5jKqxoMBnJzczl06BBHjhxRMgpVNofc\n", + "HaO+vp6GhgZFG75VTWq3CjldemBggF//+tdK9b1AIPBAAlEoFNrxy3k5kaepqYmPP/6Yu3fvRuQi\n", + "s7y8TGtrK8FgEK1Wq9i1k1cnAHfu3OGNN97A7/fj9XppbW3l8uXLjIyMMD8/z9LS0o6/6KxF7lE6\n", + "ODjI8PAw+fn5SlLQ6Ojohr6Pzeiwr7MS2w5LeVW5SajdbicuLg6tVqvsbns8nl31Re0kPB7Pjq7R\n", + "Lcd6Iz3r3wpmZ2d54403WFxc5P79+8zNzUXsc7lcLrq7u3nrrbdYXl5mdnZ2R6srYKUcQENDA9PT\n", + "08rKemhoSHHUO/2C/TiWl5e5desWFouF73znO5hMJmw224bFExvRYb/Nig57UQgRtvKqOp2O5ORk\n", + "pTGr3Gm6qamJqampHT87UFFZqyaKNPJ+SaTakm0Gl8uFy+XaFZuKG6Grqwufz0deXh7Dw8ObWuFu\n", + "RIf9f2Ud9naVV5XbV73zzju8/vrrjI6O7uhZooqKisqTCAQCDA0N8Xd/93cEAoEHZL3rRXyel1/V\n", + "Yf8EmJEk6U/XHFfKqwoh/hQ4KEnSNx967qYCpGazmaKiIkpKSrDb7czPz/Ppp59y9+5dpXefioqK\n", + "yr9mJEl67B7h0xz2C8AV4B4ryhCA/wT8NlC5emwA+KM1tUXk56qeVUVFRWUTbMphPwuqw1ZRUVHZ\n", + "HNvusFVUVFRUthbN0x+ioqKiorITUB22ioqKyi4hbA5bCPGSEKJTCNGz2kZMZRUhxKAQ4p4Q4lMh\n", + "xM3VY1YhxIdCiG4hxAUhRHyk7YwEQogfCyEmhBAta449cWyEEH+5eo51CiFOR8bqyPCEsfobIcTI\n", + "6rn1qRDi7Jr7vpBjJYTIFEJcEkK0CSFahRD/dvX47juvHq7duxX/AC3QC+QAeuAOUBKO99qN/1hR\n", + "1lgfOvbfgf+wevsvgL+PtJ0RGptaVjJqW542NkDp6rmlXz3XegFNpD9DhMfqr4F//5jHfmHHCkgF\n", + "KldvxwBdQMluPK/CNcOuAXolSRqUJCkAvAF8OUzvtVt5eBf4S6xo3ln9/yvba87OQJKkq4DzocNP\n", + "GpsvAz+TJCkgSdIgKz+smu2wcyfwhLGCx9f5+cKOlSRJ45Ik3Vm9vQis7U27q86rcDnsDGB4zd8j\n", + "fFY0SmVFv35RCHFbCPEHq8e2rU/mLuRJY5POyrklo55nK/yJEOKuEOJHa5b56lix7t60O3aswuWw\n", + "Va3g53NEkqQq4Czwb4QQtWvvlFbWZeoYPoZ1jM0Xfdx+AOSyktg2xkqdnyfxhRqrh3vTrr1vt5xX\n", + "4XLYDiBzzd+ZPHjF+kIjrab1S5I0BbzDynJrQgiRCiup/4SpT+Yu5Ulj8/B5Zl899oVFkqRJaRXg\n", + "h3y2lP9Cj9Xn9aZdvX9XnFfhcti3gQIhRI4QwgB8nZU+kF94hBBmIUTs6u1o4DTQwmd9MiFMfTJ3\n", + "MU8am3eBbwghDEKIXKAAuBkB+3YMq45H5hwr5xZ8gcdqHb1pYZecV+uuh70RJEkKCiH+GDjPimLk\n", + "R5IkbX+PpJ1JCvDOamsxHfD/JEm6IIS4TZj7ZO4GhBA/A44BNiHEMPBXPKGHqCRJ7UKIN4F2IAh8\n", + "f3Vm+YXgMWP110CdEOKBOj/whR+rDfWm3cljpaamq6ioqOwS1ExHFRUVlV2C6rBVVFRUdgmqw1ZR\n", + "UVHZJagOW0VFRWWXoDpsFRUVlV2C6rBVVFRUdgmqw1ZRUVHZJagOW0VFRWWX8P8BCxPUWfGXxrcA\n", + "AAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "imshow(solver.test_nets[0].blobs['data'].data[:8, 0].transpose(1, 0, 2).reshape(28, 8*28), cmap='gray')\n", + "print solver.test_nets[0].blobs['label'].data[:8]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Both train and test nets seem to be loading data, and to have correct labels.\n", + "\n", + "Let's take one step of (minibatch) SGD and see what happens." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "solver.step(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Do we have gradients propagating through our filters? Let's see the updates to the first layer, shown here as a $4 \\times 5$ grid of $5 \\times 5$ filters." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAATQAAAD7CAYAAADkSGhKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztvV2sb0tW3TfX2fvce9tOAxcRXUOLNA04tIksgfhQJCeC\n", + "liILy5IdHrDFS3hwIgslThTlwfjFdpKHxJGMkGwJReFDGFk4liI+8mDHuOUo8EAAicSdxIZY3S3R\n", + "DnQjpSF033vO2XuflYd75r5jjz3GnLP+++yPe/hPaWnVqrVWrapZVb8aVWvt/972fY+jHe1oR3sV\n", + "7NF9Z+BoRzva0V6WHYF2tKMd7ZWxI9COdrSjvTJ2BNrRjna0V8aOQDva0Y72ytgRaEc72tFeGTu9\n", + "rYS3bTt+D3K0ox3tVmzf903FHwy0bdu+KyJ+KCJOIuJH9n3/G3zNxz72sWv3fepTn4qv//qvj23b\n", + "Ytu2ePTokQ1fXFxcbufn59fCGHdxcRH7vsfz589j3/crYbXP7eLiogxHRHzJl3xJfOmXfumVvQp/\n", + "/OMfj+/+7u++lg93nOXMjY8xLv0C/rfhbdvi5OQkHj16FCcnJ2V427Z4++23r2zvvPPOtbi33347\n", + "fumXfim+5Vu+JR4/fjza9n2/Vkeq3tLXWEbcc1j5qdomeTg/P78sn2onalvJA9cv1quKc+2Gt4iI\n", + "09NT6X+O/9mf/dn4nu/5nrLPYZh9oHyScenD8/PzODs7uwy7rfMtbmw/+ZM/abl00JRz27aTiPjb\n", + "EfFdEfGNEfG927b9sUPSOtrR3o+Gg8h920PKy33boWto3x4R/2Lf90/v+34WEX8vIv7sy8vW0Y72\n", + "sO0h/YXNQ8rLfduhQPtQRPwmHH/mRVxrb7755oGPfPj20Y9+9L6zcKv21ltv3XcWbtW+6qu+anzt\n", + "Q1JF07x84zd+4y3n5P7t0DW00ZDwqU996jL85ptvxptvvhlf/uVfHhF6bQTDuGX8UgZfjFpqz2sQ\n", + "yqpnq7WM58+fxzd8wzfYNQ+XvlsLw/twX/kh1144j7k+lXt8VsarjfP/1ltvXUmTt4uLiytrRmq9\n", + "Etcp1bO4HXAclnO6dWXL8n3oQx+69BHWGbfHR48eXVnzc21W1Q/WI+5d+5yWT5WX4z760Y9eW7/N\n", + "tUBsZ1Ubd77k9dDJNi3fb//2b8dnP/tZ2+7RDgXav4yIr4bjr453VdoV+9qv/dprN3bw6ra8D62C\n", + "V+5XIKaeh40xzS1g8nMxfQ6rDoANnZ/J1zhTMOM85LFqiNWCNL94QZgh1FYaepZRwavzF5bXdUJX\n", + "RlVHmBcEzwRmmE4HuKqupwDjuu4W7zNvCDPe8/NXFvBXYDaF3VtvvXVldvCJT3zC+vNQoP1qRPzR\n", + "bdu+JiL+n4j48xHxvXxRNVIdCjKnaNIqiFWNxOVTHVcjF+eDw5hO1egZnEqxVIZKQ70pwrxUqqka\n", + "SZ1Cu7i4uHx2pq3eavKzGCZqn2HOi4rLDqreXmPZXB0hyDgv6g30VKnh81gNYr0pgKl2yxBQAw62\n", + "TwUxB1Sn/tifXL/V5qBWQXtqBwFt3/fzbdv+o4j4n+LdzzZ+dN/3f8bXqQrtYDUBmUrbAaSCWAWy\n", + "CTjR8VmpHWzUKO6M84cdt3tOBzIEATfOSsV0o3b6wAHNPYvLVIUnQMMOO1EBytjXCgAV1DDvrr7U\n", + "s7s2i2Wc1IlSaVwWBbgKjBXMDlFpHOYBZ2oHf4e27/s/iIh/sHqfm0JM1VkFAQUyPlYdlPPH4OBn\n", + "VkpFdcSuc3K8Gr0VxCrAucavTI2cKxtCDDcGGoOM1VI1iPC57HQKaNgpEdiq06gOg0q8y0fXZlVZ\n", + "Mu3KHMBUG1aK2qkgzEsCLMM8aKlBGwdvNwiuLDPwXpVzxW7tLwUi5gptCrWJTUDmYMb5djDDdLki\n", + "cw1CdQSnOLsGjx1LdbLKDzwi8/mIGDW8DuKszvIZSpFVSlDVg4rb9/0K1BJorDAYdA4MFdjQ8Jl5\n", + "PIEa141qU67+JoPKFGrcDrA86Dvls6lC47qeLGlUdbNidw40jL9NuHUgcw0Y4ysF5Tp3NtYObNXI\n", + "j8/h4ynYsIFmA1YwiIgWMl0n2rbtEmYXFxfX8qDSV1NOZQ5qDDLeZ9nxWtVRq07TtTWsS/5rDtdW\n", + "uQ6xPBjX+R3zzerGqTNWYzjgcbx7XqXGKpBVL2U6lbZi967QVFwHshXFxlaBTqWtGqaq3KywfMOX\n", + "HV2BrQOzG7FXVBo2dsxPPh/TUNMH1dAyXaWCGGZpFcQmQEPj6VIFtFSN6DM1qLmBDX2o2kSeq9bP\n", + "8toKbK7cHYC7QdWpITYHsSr9iVqb1rkq22SwcXarQFN2iDrjezkccdj3Oyv5VKYqPA1ff6sGnhuP\n", + "zJy+imO1qPyC9yJ09n2/piYOUWiYZqWeu46wAjQsY5ZbgQ3VGfuj2/Nz2MdYZzcdhCuoTUCW7a2b\n", + "vrFCU748BGiszKqwAtwU2it27wptFWyuYSjrYFY1Yj5miLjKRuP1Fix/Ai/Tw4aFecO4Ttmp8is/\n", + "YnzEYWtoDDX3/E4xHAI09AWWBcMINfSnyiOny4B0z8d8TOCOz6zy1YFFteMJzLJ9YlvrIOfqS00n\n", + "uxcFKwMmlmHF7m0NTSmgm0AtTZG9or6DGsOAr1cwwykXj7z7vl+ZfiqF6Z7hGn0HE6XkVJm6j065\n", + "8yDMcFqn8s+dwYXZB843abg+piDGeevA5M4pqLHyUu1XHXdlcm12opang0f6hcs4hYsDVbfneybP\n", + "dG2/slsF2uPHj6/FpTrhvYpLZ6cjTk5OLsN8T1YWTkHwmWlqRFbhNP7ZHRz1Mz1uMJgW7hUEVKUx\n", + "DJ3SZeN7VBrqGgXQqnEpqLl8cadSQOO0q3JhHP/cTT4P1W/lCzYGmIIZPr9qY6vKkM+tbm5KiB86\n", + "818BdHlx6moKsQpqrpw3tVsF2uuvv34tjhdRu99mmlRcwi7i6hu8TtU5lYj7R48eXf621OnpqYUa\n", + "K7SJKRXH57mTuT1aplOpD36GSkP5HgePjMOy8BSmgxkDTflBxbm/Q3T+OiTMz1eg4zjcY7gqizpe\n", + "GVgSXNkGXf/K45OTk8t7XTji+trqykez1abKoXwxab9stwq0N95441ocT3u6LcJ3rmqK5KZXq/lA\n", + "oOGPIjqVhnFT6xRY1znRVlTF1Jz/Mx8KZBjv9hzHz6yOI/SX+66MlT8d0BXAJv7lDuoGrirOwUuB\n", + "TYFMtX0EbcIL0+Y8IchW1NcUalx2NB6YpnbnCo0d7SoA1QkCKx1yenp6TVpXla6MRzE19T05ObkC\n", + "M7wG83eoQjtEgVXxER6mk8bRqQEHNnyGqjMHMTViq3K4MvHHtXh9NRBM/axgVrUpdU7BKvfdOXct\n", + "A81NOdUAnTDjPT+fwXVTiPGU0/kr7cEpNAe03KtGpYCGHQNBdnJyEhcXF5dra3idSitt3/drEHNb\n", + "Ai2hVk05uXNj2ZQ5Balgz7aiAKfPVUBZ3dSUc6LSlELg4wxzu1BbpdKqNpjPUb7hwcfVgYNaBSf2\n", + "N6bTxVUQ4+MKoJx3BtmhMMO6PqSfrNidTznTumkUNhp2SEItVVNCLa9VP/FS5QPhxfuTk5Nyyon5\n", + "W1Voas0Q86WUa6UAMHyIslNpdsDqbDLVrKYgXdkYblzWSpF1Ko0h1qk1Fa6Ul1NhU+gw0PCvNdyA\n", + "jqqsShPTVWC7qVJjv7u6XbU7V2hpKx1LOSThktvz51cXrPnrePVMluFuQ6DxlJPzuGr5fKxQrGie\n", + "3qpOhJ0a46d+dkqt6mgriq3bp9+mcED/ZB07hcfXKx9zx+p8pkA3gc/KptJwYQWz3GO58x6EGYMN\n", + "rQLZTaedytcY5waZzu5FoSnnqfPZYHlLRYaA4Y0VWgUzhlrCK6eaOOXMZx6i0LjcqSZd5XIelQrh\n", + "dLnTVx20aiyqI+agMVVsCmoObA7IKpx+wY6hQKDKWsFMTTsne1du9p8CvYpXZaiO0w/897SqfhXM\n", + "nL/3/eoPdFYgWwUc+9v1gVW7F4U2HYkjri94XlxcxOnp6RWoue/TJtNNnnIyxPJfgXVraFn5q6ZU\n", + "hsqfsmpgwMYxUR0qzaozplWAW1FplRpxQGOYOeCnqQEDw85HU5hVagsBxjBT55w5JZX5R5ip9pjP\n", + "YZjhMcbfRIV1QFPfC7I9eIWmRlIXF3H1WxgHs1xHU28pubGigmGYoUJDkKFiwzW0Q6ecqmNxB+D8\n", + "oZ8UONjH3fSpU2cVzCqI8c/TuCmmAxqWx8VxvVYwUkrAwUxNvV1cBR3nww7oE6ApU7MRN7gyuBzM\n", + "Ml2l0CaKrdvUDzhE+EFnaneu0BhebkTDCua5O8NMTTlXGjvehzDLzT2L83noZxtKiakOi/Bg9aUG\n", + "hA5qmE5lVd1EvKfS8DjDU3VWDWqqXOkvla/K1yqOAVeBTIWVnzqQVXEV0FR9rbY7zJuDWYRfQ6um\n", + "mxPA4cCIPlTTzQcFtNdee+1aXDX6q4agAOZAhi8Hqm3fd6vMWKXxVJOnmxFXR8g07Cg4pVTwzuv5\n", + "PoRtpoMfk6q9S6dSNeoYTTUq7tQIFVZxkw5dQUwdO1+rz3G6MnO5HVgVPLNeVPkzHiGpYNVBGcvK\n", + "sOVz6HMF5Qpiqn2qX9CoIKfqlwctHpzYuI5W7F6AxgVUkjsd320IpefPr/69p4PHvu+X6gvVGEOs\n", + "+qAW00J1EnFV+anGyR2Op8lOcebzco+wZKhiepw2K8IKCAqsSvlyh0WFtgK0yhTo1YDE9ag6SBU3\n", + "hSqXh48zn1hH+ExeouABCcvNYa5nrB/VJnMQV6IhN+w7WZbqLwS6nweq+mClltXx1O4caF3jxpFt\n", + "oszwGKGmnJiGQGOQKai5dbkJzLgSFVwcwHifeUdVwAown8vPUtDKNB2sVN6wHMqvfNyN2gy0qkNz\n", + "flXbUPWo0qjSn8A1QgNNbexTBpnzo8uz8oeqEyUSGGbZVzKv2f8YaAys6lMOBzE21d5U/Ird+a9t\n", + "qAbAcelUBzIHtgnMsuNXIFPTzUqZRLzXuBFmOPXC5zuYdXDL56EactNZ1Vi6BuSm6NU9XLdoE5jl\n", + "lmlyXalGzvVevcxJoKn0V+JUvOrw3MkrvytTMJuGXbvMa7A9MszcDEfBzJVV9esJ2NjHDxZoTqFN\n", + "tm3bWpApqE0dyAv/lVqL0CO7WgvIDpeNh011TAc2dY0Clxp9p6PfBH6s0JQ/eMrJU5pqasZTMW7I\n", + "Lj+45KCmm1mfqzZRcVlGVDQ89UqI8Jf7zlBhO3+oY85XpoX7tEyfwYZCAmdJqm9OVGkFs+lg++CA\n", + "phTahOzZALo1Mwzznz8pQwepkdxNOSs4csNRFcrPV6BSEHNrI5x2BTQut+oQTpmpDeHtfIF1zWCr\n", + "gIbAdEqFfeSmmzhAqby5OOUv50Ps/PjbYzkgu6/1ne8qmHVgUwBLv2Jc1geCLcvBYOuWDCZwu8n0\n", + "88EBzSk0nIdjI0CYVW83EWaszvgNjmoAOOWcrKNxY1EwyTCvQaiKnIBDga6DGMa7jsj7lekpNzDX\n", + "QLEjTUd49A3mC8uA/piunz1+/Phah+a8s9KeQASBxj+kiIqMv9rvlNTqkgEPdK5tIMhyQ5DhcZYl\n", + "6xIHpW7ftX22yr88K5jYvSg01QgYZhFhFZmabmZcmpO5OTJN1RlPY3kE5HNcofx8VWkTleaAhmHu\n", + "mPhs3KuwakhOoeEzKli4Bq4gh3lRKrDKmwObUmjOf1imqp4U0LAdM8iUOZ9VEK/ywmDB9HgQUf7j\n", + "+OxbXGeTY947sCmQqbb44BUaftHPYW4ITpG5dTTnNOUgnnIqwGXnULI7jRsOSveqIg9RaV1ndEDD\n", + "Zyvj/FSAU8+ZqINuzSXzkdM1Hgyc75w6QwWu8uXiFDTYJ3nMIOg6o1JnLi8OYCoccf0/eymfY3+r\n", + "tixXpfRcHbtzziZQW7E7V2jsPPcmKCLktMKpNhzl0ZyEVY3fKbVsvBF68Xu6dnCoOlPqqNqv2L7v\n", + "1zqjAqtrXAruU4gpoDHMuB4rZebW0VY6pasLVU/Z8auBU/lLbXxf1z5y7+oijxNkuKzjBk6OwzQn\n", + "A8Jky7K5/ftSoZ2fn9tRja9V6kxNN7Fy0UE5cqEijAgLMPWBLapGp46y4eCr8K5jVvByqgmfOw2z\n", + "VUq2g1uWzT2TR+sVoClVUKlFhpqqSwaaWyZQQOs6fbYnVkurnVDlx4GU47BNoLrlQSWhptJRx1gG\n", + "BpgKczn4GmcTqK3YrQKNF+iVceGx00w6OsItLR2B6g/X7iI80HDtLMNoKO2xMTmJjeFKAbk93pPp\n", + "4XNVw+OwOkZT6qAaLZWKUo26moIocOEIzr7oXgDwSx7cVH7cGtCkzWHby8H5/Pz88roMd5uqg4iQ\n", + "z3XwcVDDuuAXbti/Kniqul2Nq8o4HdxX7FaBpqaB6VgcNbq/5Feg4M6eU8NJ54zwQOPvmRjKSpHg\n", + "i4OJyqpAgXu2aYPicHVO+bcaZbsRl69RCkude/ToUVknDK/XXnvtyvb666/L8CEKbQKzhAF+MnR6\n", + "ehrn5+eX+5yN4D43Psa4BPxUtZ+dncXZ2dk1wDHc8Fi1Ndf+usFR1Xdl27aVMy+eha3YnQOt+lsw\n", + "BTr1JixtQvJseJzOtPNUKhM7fUJtKuc7qHF4MiIeCjenMNW0onpupwJREaRqxhFaqS2nwBhobqvW\n", + "0BTcpjBjoDHMTk9Pl0GGbd49U7WrZ8+eXZkmZtlwuaQDGs6OXF86ZPrIexYh7oUfnluxWwWaenWN\n", + "4Kpg5hbZ09g5DhQ52rFCUOBym+q4DDE3XVHTgw5qWb7KOqiswM3BTD1r+lyuq7T0FU4z03fd1DHP\n", + "IawUwKZAU1sFMo5HaKRKS7itAEwptClU1fQQ32hiP6iApgDXtUG0akaktsknWQ8OaCsKjUcohBo3\n", + "OgUzfNOpgIZKLdVA91EmKzTu2Ag1BzQ3TZioNbYKHocArVIqFeCm+UpjUKu0+fuxhBEqMg4zwFS4\n", + "AxrXp4OIiuO2iyBz200VmsoX+jfbeK7t8bkp0Fw77OLUoM2DegUv9WnWij0IhVatqSHU2NBheZ6n\n", + "Mrz4mecqiDHsWB1W05Su4TmITa2D2CFAU52b0632lbFKRmWG+cj6UBBTCqyDXIbxw1oHMTx2g5A6\n", + "3nf/m/uT9WGn1BTQujf7qMwSrjwNxfJWIEM/YD1mOmqA4jQ6Zam+JXXfma7YvSu0TrF1LwWy4NhR\n", + "UAVgBWVDiajfcnYvBbopSzW6K6hheSaAU1BSYXc97yfK7NB9lk2F0ZRC69bGlJLjOAZaF+6AhuFq\n", + "UK7a9MqUswNa+jOfcX5+HmdnZ5ftGEGUg7lTahXI+DquRwez6Ufx1fkVu3WgMWjUOlkFM4ZaGjtO\n", + "PY/DqOQ6kOWW96itmxqoqaVTaAwyDCslVKlGvqeLm0LNpTdRbq5sGVbTTX5ryW8vJ5sDmtsfCrTJ\n", + "vgNZbgw0BTPs7AyzbM/YNxBoPJDmXkGLlTXXKcarKWbmVX0cP4HagwKam3IyyCZTzg5qeawUEwIo\n", + "K6ADGTo/4nrHzwXhDmyqcziwZRmcKaU6gVAV5xSwi6vyxseus6gwTznVZxm44bXqJQK+YFA+cP6p\n", + "AMbhrHsenLmNu7ZdTTldp+fjbduuwOzs7CyePXt2eQ0CyQENy41h3hByVf2nn3iNGvfd9PNBAs1N\n", + "ORWwDgEZKzQ1lVBwS6C5dTSecjp1hmBLqKkKUaNWBbNuyunKp6ZReaz2XTp8vktLpd0p0tzcG06E\n", + "2BtvvHENaJN9l0eV3wpouVdAc9sEZHlu3/dWxWQ4Ii5h9uzZsyufuvD00QGtCrsZRJpSbTyIK9Hg\n", + "FKc6XrF7VWhKpalp6ARqaa5z4/G2XX8poEaT3BBeDDHed0qN8z2ddk6tUlZq323uGZM9myp3hruP\n", + "ZxlqfK0Lq0Vllb+MU+ByUMu2oDY+N1VnPOWcLJifnZ3F06dP4+nTp5flr9bQsgx4jPWDYbVVkOHr\n", + "GGZZJ5Pp9IMDWvVSoBvFqhcCaTidzAYW0S8AV1NOBTUFtBWYOVVWjX5O1q9seJ/bHwq1ztLPWRYe\n", + "uTmMDd7BLIGWa2iTD6NzyonlrvJcAc0pNAUwBTsEWfWJB045J99oPX369HJ9EYGmZi9ZxgpuSlkj\n", + "WPDlmrJDFNr7AmgqM9kQMPOq46RTLi6u/j0mOpnPVeqM1R2ez8bGcfi1N26sGHE04oaQxnnKRp73\n", + "q/xxY8JOxNapqc7UqJqNML98Pz09lR0W6wbzxg272twaJl+H/mJfZj2y37s2gccKXi6soFWpNgcv\n", + "pdAm32elQnv77bfjnXfeiSdPnsSzZ88uoZl1kf7NX7+pBtTpOdXOuD+pvpDnp+3iQQFNFRyBljBT\n", + "0wIlcxFgDDWemqJzleF51QGws7qGyBBiNcY+UB0QYcDp8YYNNMMI1UPVFHdUNbJeXFzE48ePZSfl\n", + "/GG6k7WgR48eXfvlYO7AbpBQgxKaUte45zhuc6odopLp1s7YV7xXcQi0TqVFRHzxi1+Md955J54+\n", + "fRrPnj2Ls7Ozy3SyvZycnFwBWrefQAytGlyUgHAzGBW3Yneu0LJQDmaqATmYKaXGjTSfyQDAvGTl\n", + "oxzHZ3KDxLSVinKVoVQF5tv5ENNGVYf7VBc3UWoVzFTHQ5Bx48X0VEfkOIaZUmgOarwWlJZTt26Z\n", + "gweY6YYgzXY0hVoVxgHfDQQI+gQaKzQEGio0rnN37FSbM27bOMBwX2SAVeEVuzeFNoVZBTKGWnZ4\n", + "hheqMOz0rNC4c6RD3WjOU06uCDU6KYWGPnG+yHxkGbk8U4WmrlEDiIKaAj1O8VTn4LTcN0nqfzs4\n", + "oGFZnBLHwWkyzcMOqHyv4ldU2cq1EXEFWhXctm2Ld95554pCw2URHFTw13sn7YTLjvXK1/KMh9Wy\n", + "m446mOF+xe5FobkOPIWXKmQ2MG5waDi1Q6ghDFwl4vW553twquDyyY04fcFpYrpYsazqMLxifD1D\n", + "jaGTfxOJdZRhNxJvm/7PXazCMn331tmps3yOqmfsIOonfNzP+6Qv0CcuPAEYKy91D8dHRAsyBP2T\n", + "J08u33LilJPh2P3DGK479oXa47XTZRwGlgs/OKA5hRZxde0n99hJlNLhBs0KTTV2dx/mYTodc8cZ\n", + "VqNMpSiwQVeAqbZD181U+ZRCyxcBao1JjcRYVqXQ+APL3KNCc1PObDvcgSKu/qep9EvG8Usd3M7O\n", + "zq4cY/qTzlwBrAIaq30MR6wptGfPnl1uWR415cS2xoOoO66UGdc3Dy64jMPLOdyOOK4SBZXduUJD\n", + "c3Dq1jPwepWeAhZDoBqdOG4KFwXiNCXLuWE7yPNIxeVx6mVqDmZZD/lxajbKSi1hGd10U33EfBOF\n", + "hhDDNpTX5hf0ueFX9RzHfqnCDDReZ1RA4/pW4QgPNKXQGMrqhyJRoalnq61qL1wHWBc4uKj20PWf\n", + "m7Tpg4G2bdunI+L/i4iLiDjb9/3bxTXX7lOQy4KwFO+AhvezWlCjjusMqmIxjlUCqwWGgeuACmid\n", + "QnOjGXZevu8Q1aagjN/gKbizob/dWpzb8K8DnDpT/sSwahsRcalcco9h3D979kzejz5CU9BSL0+4\n", + "nrst4vqUU4EsFRquCWIY6+z09PSybSiFyO2ep/ETw7aNyqzqy5NtxW6i0PaI+M593/9fd4GCV5I6\n", + "4mqnzXis/GrK6RrvlQwCyBxgqrWMjOO3c9lQ8qWGAppSVZgn18jRlELj8uB1hxqmg52lUqvKz3kP\n", + "d7oKbN1/3ML7XR3inm3f9yvAynUm3jJ+xTqI8acYDl4cp9Syg1pCo4Mj9jNu5wi6LFemq/zp/Ixh\n", + "HFir9ur69qFt+qZTzvKJTqFlgdGZE6q7NNlQWbEqyk1VbPVNEP9NYDaQDG/bJqdHTqHlcaXQMG1W\n", + "ZTcZxZQppclQq5RZpWbVC4Hqby8dzLpBguMi3u2cCbRcOMcFdI7De5XhuQ5iCmhdfjugqWP0iRrw\n", + "sd7US4nMIxorNGwDzkfcVtDUscsrh1fspgrtH2/bdhER/+2+7/8dX6AUGo9ECj4YtwKyTB+VQkIj\n", + "RyeVF2yAasO1BweYbrqZz1NK1Kk0VmjoI/WM1QagAJ35S/U5UWa84XqJgxpPNd36GUMt8+LUDSuN\n", + "fd+vqDB8I5jhJ0+eXIZZaVRhBS5uSwpoXfoR0ULMxalZAh6rwVv1MVZZnE+uA1cudZzmZlurfR7t\n", + "JkD7E/u+/9a2bf9qRPz8tm3/fN/3X8ALfviHf/gy/K3f+q3xbd/2bTaxSjLn+SpcNY7bMoYJT926\n", + "vVIfTtGlqlSK0i1Aoy86daDuU35EkDo1l1u3bua+SaummROoqvIqhVTdg+l34ao9qLwrKLgp2mRj\n", + "c4CPuP6L0WqJhWcNE/8cCjX2m4r7/Oc/H5///Oft/WgHA23f9996sf+dbdt+OiK+PSKuAO37v//7\n", + "3b0WXO78ypZpqP2qucbjRg/u8NzxceNfRXAwS6DhqN9BrfIBd2xWitWCMPtDqQYGmvugVr3NVDBT\n", + "sO/MtQesOweHCjSZVg4wahaCaacCWhmgnV87JeZmBPh89xLDwc3ldQr6lyE0PvjBD8YHP/jBy+NP\n", + "f/rT9tqDgLZt2x+KiJN9339/27Y/HBF/MiL+c75OFeBlw2s60jblOXhUdB2NO7ybMlTrIQwYbITc\n", + "KLlhTmCW++5NHJaJy4ZTVE474ytF5qaXbgrfQU0NkFWdc3k6kOHxJH1U1phHDnOeV2HGZcJ0M86B\n", + "y4FtBV5TqK1cewgAD1Vob0XET79w1GlE/N193//RSgIMoNvY8FnKVAepRu2J3J8omGyg/DMq3CBR\n", + "oUWEBNlNppx57KYbym8KZqjI8LosI74IqH57rgLZIVaVw9UXn1NAR2B36aG/8F4MK3BM1sdyq8rO\n", + "ea+g5oDm8l2Fu+NKgLi2OrGDgLbv+6ci4psOvFdm2EHJqQanzJzT8tiZU16HdCinzjpl4qYM+QZK\n", + "KTIHOSxv12C4EVc+5fJV0FB/EVBNQ5UaWVVnKuzqZzpAcXoqzqWb4J/URe7VQFhtK2njwOXWzzqg\n", + "db6enHPtTMWv2K3+pUCVGTdSdYBb2aZ5qUC2OgVVaSiY8R9fc1oM9YhaofG51UZeQU35yk3T8Jz6\n", + "VEMBzq150pDzAAAgAElEQVSfKeWa4WnbmpiqSwUr9YxUSDm1VDBD8OO9bp/prgBNDWJOIDh4KaXu\n", + "/Nr1r+7eauvaYGW3CjRnLxNaquAd3CL89zoqbqIS1L1uuummWZwGN9TbUGgRcQ1kK9NO54sEWvdW\n", + "s1o/m/oey8JxVaeo0sew8wFDiqG27+/9/eLKABMxBxrCHevdAayK43MTUXAI9By8XHjF7hxokwp9\n", + "WWBbtakS66YnPEqraSeun+V1SqFhI+0U2uSlgIpz62fqXqU++RwqEzXVrKacTp1NppyuvK6OVJ1V\n", + "96hncbtVIONpYdf2sT1MgMYgw/xVU0sHkQomq1Bzxw6uKn8rdi8KLe1lQKy7vzJu1BznYIbXTqab\n", + "SqEl0CqVkPnPDzM7kOHf8K0oAjdi4nVZtuxwDC4se17D5e3W0rgjK9BPoIb+U23A1TGCZ8VwwR83\n", + "XmN0UFO+VnB3QMt7FTizTrltVIpcDYjKt12cO3Yg615MTOxe1tC6yn0ZGz9rArcJzCZqATtI7tUa\n", + "WjfNSTDksVszU59toP/dfuJzVTbcZydCkGXnmr4M4G/xGGRuMKk6DBvHuXpVdeGsarsc565X4fTr\n", + "BGo49eUyYntAoLkXbe6lUOeDKk7VUQUx9fnIit3blDPDKzBzFVE1ps5UQ55MOdVepcsKjdfPuhEw\n", + "927xv/qpGpWOiqs6osufUh8Jsgy7NbTJTwRVynVi03Zwk+cgVCs4dSBT5xS43BpjfgOY63eYFraZ\n", + "/J+f0419WZkbXNQxA636hZIHDzQeWfEYpyyduQ7bTSfcQra6BxvMy9yqf6/WNYRDOgnvK8ixL26S\n", + "BzXddH+rmd+wTZUx1ncVXoEUt0tnmAe+jtvvBG4V0BBkrFwzrH5kcyII3HVuEOj65RRqKk9q+okv\n", + "uKZ2579Yi42MGyyGq2s4bdcZecGa06/m7rhVa0Dql1cnf7fIb6iygqup1Oq0aAV4ri7UcyZAi4hr\n", + "qlT5UC3+q3w4FYztyYWrNLpOzM/D8qlzyl/OV5XvEFgrb3yVuprCrLLq/AR+3f1ue1BAUzZthLng\n", + "7GBXpc/KDC3TnW6oNLq9+40vt36UZVYNSylZLufEVNocl2lNpn1KcfCegbbymQaWTe2xnfAA4FRZ\n", + "1/mxw+M5TmO1PtRAMIEalpXVWAczVTbXxro8cJrV86b38HUuPw/ypYBzfDeCOrU2eR5DkdWNguYU\n", + "aCtQm3xEGjGT/FyGSedh657BPndrNxOg5Z4/V0HAcRjflKo88Z6h5kBXqUzXsZVvsQ7yngmA+f4p\n", + "ULqBZQK2KdDwHg5X6d80nq9R24NSaFUjc3F5X+67CnQdExen87p8FoKsg9u+72OQqUXw6i1f5ku9\n", + "NsfyVY2384vrQLjx1Jy/ncNwplPtM8wKjFWZmnJyPXIY41bajzMHeGUKbHjOPRchyM/EY/ahSmdS\n", + "HpUmtqtJ/anjlbgqHvM02Vbs1qec1eg6Gdmqht49My3fAmHFKXgpqDHQVtRZtxge8d6/pcNF0cwH\n", + "l2U6QrO5kS/D2FHzOQkazrcayV3c9LMDNd3s6tQNlApylZJRA0nn1wnY1BRxqs4y75g+9wnMx1R9\n", + "dgMQxyl/TeIOTYfr4sG95XTKwU0HUF259bMq3TzHKpCvyfMMMAW6BNqqOpv8kCHnC2HWNdrKuMwO\n", + "ZjxiY2dUb2UTwuoZKqw6d/fh7KpVMOPrFFjYRyvP4bRdWfHaKdQyXc4Dh1fUpyrjpB4nxy6uu0aV\n", + "X73AmNq9vhSI0KNRhqdqhAs9UXROleFxOrQC2BRqTqGlOsN8JewQ6od0+GqkxvJVU05+2aF87hq7\n", + "qsNqU2m5cnH7Ue0IB7apf9h4UMS4qr2yAsWydVA7xBy8VoC28qxD0nD3uXy+rxSauobDPMJNOraD\n", + "I4azEzuIOaAdAjVWOm76hsYg4/KvAq5qMNzQlUpLmL322muX6XH66tip66o+Wc24dDnsBkg3C3C+\n", + "qUw9g88jzFiFOoBOoObyVuVZ1Xdnq8rrEFWGcR3U3hcKLa2CG087Jx1YdXw8xmsQZAwx3lfQ6qBW\n", + "vRhwHUMpi6oDuTSqUY+hjekpmOWmzDXYClauTFXHVaos03Hhzj8Yzvam2iXmC+FUKc7uT5SmUOOy\n", + "V36q0j1U/XHaKtzlqUqrGmwfvEKLuD6CZ5xq8NWmKmk6vWGQMdwYaNVLALXwX31MWim0VI/cWbBs\n", + "K77mtLtRkKGG081UaKouq2dOzzGounuUYlIwWgW/GzzUs9Wz3MsPfh4eu3N8jfMFxzlAOOv66jS8\n", + "as4fkzwru5df21DTik6BVCMgynp1jWrUOBInzNR+qtCqzzPcx6RYefinWW7kV/5jP6r4qkNUAwL6\n", + "NvPeAUflZ9L4EWb8jKpjq/y78kzyXHXsKg01O2A/KhU5hRvfc1fmBgq+ZiVPrs1Nru3sXn8+KKJW\n", + "Fgyuk5OTa1OlLLBad3IKBxVahrkz4acT0ynk5Gt49VV8BTGn0NSgUCmvyr8VPN0zlE1URAe6TrE4\n", + "AGCZOFwNelPrBldVVy4/Km1WmZ2SRlPxDrBV+bryd9YNNnnMfWHSd6d2bz/B7YwbAMMs906eVwBg\n", + "B+EUQ4VRoU2mkKenpxJeqG44HwgzBzYui/LxtAOwcsCOVI2SnN608a7EVWVw5arKmHXIalN9I9bZ\n", + "Crw6cLDPWf1kGdUH1spnzhercFgFHse5AYrjOoA9WKApq0aTPI+dncHgRmX+KHKyV52Hp4IJtO4v\n", + "BVCRTVUaQpQ3t47G/kqfVSoG78M0MX7SGScdaQoyd+90Y1ONH6HmQFZ1GtepJnBTYRx0OT32CXZ+\n", + "vAYHXfZZlT9sc1OrQO3ai2p7LBYmAJu0R2UPYspZVTRWBkMNKwc/RsX7VTjCT89UXKfMGF6rU04H\n", + "sNURa9rxWRFUnXyijKrReGLse1bguKFqcSqH49366ooicT5SPnMDUAVO9odq2wpmXVqcV6zXzrqy\n", + "KR9W/QmfqwaYlcHG2b0CTXUuPo+L5Qkz/GI9C736erdyOB9Xa2e8xykmh/klRjbUKcyqslTgUYqW\n", + "/aeew/dNIbYCM86n+rtWDme+HcS4Uyj/V75V/nG+cvCaHLtzWVb1nKpOOK0JZKu6mpS7Gvxcu8T7\n", + "KqitwiziAa2h8QiEHR3fOCLM8j4HNPV8JYd5z3HuJYBSawixCmZYvhUZrkZEDE8UmoqbAHPqP+f7\n", + "Kg9KiXGY/7rBKR/22wRkzi8cVve59Bywur3yTVVHna9vAogKOHgu8zFR2Zyvlwm1e/03dhHzKacy\n", + "HrmmqmHSCTE8faPZKTPuWFwGLK+DnPITl8EBzfl6mn4FfXVuxVTDd98FZvrZLlipcbtxbzldWdkU\n", + "eKZgU2l04SxT7nHti6+pBq2bwEG1P/Qf+zTvwa8HnOLO+zqQvW+AxsaVhBWClckgvLi4uLwGpyOu\n", + "43XgcuHuT5j4pYB6w6k2Na1YgZmDmCsr+s5BgBuQGwg6uLlBKs+r53TqjIEWcfVnorg8CTTVATuo\n", + "KYgpX3WdrgOYywsq0U6h5fXdc6cvBRzMqjfGeB+DjX9JRpX/kHVOZQ9mypmGBcD1MzyPMFPfpbmO\n", + "7ZRLl99KoXGcg1c3Gk2nn5VNYTaJ69JdgdvqMxhg/OdamG8e5PI5lZqofNrBrQPbpL4m96AvqnQ7\n", + "Razura53AwNDTL3gQqAhyPIc5ncKsgcFtM4mmVUwy039TWI1demA5vKoppYOblUD4OOIvuF2naSC\n", + "+MT3rlEpqyDmjrmxV+bqTgEt699BzSkJjJ/4aAqzialBrBrYsvzuGa6eDx0QJ/l1M5CIq7/th30U\n", + "84pTzkMHhMru/R8NdyNkFj6vzzh0spqisOzlc86UE7Pi3FoZx7nO9LIqsbqGy+dGOjUKr+blEBXs\n", + "ylMNSE5xcxqu46n6UYONghcfO78cAjd1vworq/xQ+YTv4TDf3y2dINDwefySbvVj2kOhdqtAc59S\n", + "uExmw2ansgyOuL4gzPIW34zyx4lpqtO5uK6jqkY4Ac+qujpEgXX76tMT/CuHag2mis9nVWFXBqUS\n", + "Ivw/YFFlwT+wVz/tpMrJkK/K5IDLcahOuIPv+3tvbvd9l/9wFxVr1WbwGVm2fb/+hUBXj9XsQk05\n", + "2T8VlNRUtGoLU7tzoClocbyCWlpWVIZxuqbkLd6fafMz0Sqg8TUKDlyJE7hVtgo7NJUXtU3/BtWN\n", + "vurZfG4FatjJGWR5HYKo+gWUR48eyX8t6D63ibj+qQLmiesl87miVqtvzPIZ7p/udiBj+Od16nMn\n", + "NtUn3ayDz3F9Y92pc7dld/5SwEErooYdGq8zsJPwbQr+BQE6uFJnCnKuIhQs+FkrtgIwlXfMl9u4\n", + "w1afpDDUUkl0f2fI0J9ATeUf00BlwwpNAQuBhlDD67mszndVXTHU+Bjbo1Iv6jkKZqtgw36C5zjs\n", + "4lybUWHMS/dc9B22FWWrfehBKLSqcaOK4ntYzvOzHWSw0aV10reDmmuYbpTCMk8ApgBeNWh+fjXK\n", + "rryp7f62UOV7VZ1xfbMqR3XQgQ2nnJ1CY6Bx3WKZMK8KYlhnEVfbI5bftU835URIKigwzLBMrmzd\n", + "+cnAyPmrBgTV75QdIgjuBWguow5mVbyCnbKLi4tr97OphriilKYj+yTdQ5Wayk+3DtJ9JMz342/G\n", + "uQGCy9JBjfPNxssLKt+svh4/fiwVmltDc9OySqHxwNq1HezsWH7es0JLiLk3+lzn6SPl22pT13Cc\n", + "O2bgVjBzvrmp3QvQlKP5GgxzxavR3QFKVdoqSCby/pDRpHr+TU2V26kvt0Cu3tyqKTwPLFVduLBT\n", + "vnyc1zOIGFYJsekaGk45K59ieXiv4KammxXI0tx0k9WZUrcMNKWoOsWl1JvKLwI4Xz7wgFcptCru\n", + "ELuXD2txHSSNG4tyojvONPGZKbcd1DifFby44bjO1418zhws1Uh8iGJUiozVWfd3qTglS393gwXX\n", + "YwU1lXc3kDmFVq2l4VtOtYbG5XP54rI4kKk935flUuVOgCmVhipIQS3ivWk69gH2H0OMw5ymMq4f\n", + "XJqo+vDUz6t2rwpNQcIVXMUrhzGEGGrKnMpTkHN56yCmnu3SnECru4ZVFMPMTTMZduot5wTUrFww\n", + "XkFN5V3FY6dxIMN/6nJyciKnnK7s6FcEj2qrK/sK4GqAPeRlAKfHi/OZB/fmksOcJ2d5rmoreO0h\n", + "g/PU7hxoPHJEzD/ZqCQwO4nXXColgeYUGp7DZ3NenFRXz3HP7vIztUqhTTY1Pc08rcLtEKXGfsQO\n", + "qcCspp0JtO7FQJZP1Tvmm8PcdvFcpdQ6c0BzcGOfYd7w2d16KoOuU5tYL9mvWe0p/02tm92w3fmU\n", + "kz94VZKYjRu2goYif6eYpopsooYczCYVUim1Lm5FNTplo+DgGnqmo1SvUslOjTmQTaY3ldpU4Ko+\n", + "quWptYKEUmx8rlJ1PP3q6i77hlJqlcJRvubnOoipOs+0VD9Q4J8oNLz3ZauziHuacqZhA0K4sUTn\n", + "+xkc2YgyHTcFVKOFgtjKtmrcUdRx97wpcBXMnEpzjXplodiN3nkNhvmcM/WcTm06qE3+G1e2IVd3\n", + "DiQIL7WksnKMbRmhhnGcDzVTUH5066gqrMpcbR3IXJlfJthuFWhf+MIXrsWpuXu1j6i/ncHOgV9X\n", + "54bHapGVGw/HRbz7xun8/DzOzs6urM88fvw4nj17duXYKTQFApU3t52fn19uZ2dnV445Dl+QcHlO\n", + "T08vy39ycnLZAauRGuN4sbrac7k7pd2F2X9YLvTf2dnZ5X3Pnz+PZ8+exdOnT+PZs2eX4TzOcG7T\n", + "gSQHXBwwlCJ2HbuzCl4MAAeO6QCOAK/U1IpvpqBSdY0D8CrsbhVoX/ziF6/FdY0Az+X1kz03bJTp\n", + "eJzhSUXkPkFxenp6CQ+cxuB+mt/sbBXQOO78/Pwa3PA4w65s6YOE2snJSVxcXJTrKLxNfMxAu+mG\n", + "g1uagtmjR4/i/Pz8Sie5uLiQIFMwQ6Bh/bu9K99E1XbHDmj87MoYauw7tSHcuj6C57tpsQKTGqiU\n", + "P1fsXoCWe0fnStW4OHZqtZCqPvGo9qenp5fqLGHm1mlUGVW+EWisMJziQagpBZdh11Bxw+lWpZAZ\n", + "cM6v6rupqqN3YX4mD3BZPww09Pm+v/s3jAmwCmRPnz6NJ0+eXKl3Ntcpu23SFlTZcn+o+lF5dvBS\n", + "17iwinOfk1TKsvPh+0Khpa3ASt3Hx+xMtUdHp3WNd9ve+zUKhJn75sk1XAe0FVVZTaMx7CCW53nd\n", + "zCkLddwNFAy0DpAc3vfrf66DLyGwfpRK4/aACq0C25MnT+Lp06dte1Vx1eDMx9N7HFBuahWQ8jj9\n", + "X12v7q8UpetzlZ8enEJTa2hpqxmd3FPJdDw3TTvj+Cdp+M9scL8CtMxT9UfIEyXkfpEBF7kRZrl3\n", + "i/6VyuDGW4URVNMNvwXLvPEghJ2ep7gZn9u2bRZiSq3xM6oB19WvO7+yVSBYBRv7Tk0Xc7BioLI/\n", + "8ZjPdVCr8q6UGSrzqd0q0N5+++1rcVXhJgWvbDqapE2nA+5LevV2rUqPw07ZVKrHQURNp7OR4uI/\n", + "Qg2BNvED57nbVy8b1Ju1hNnJycnlMyedDK9R9X52dmYVGkPN1VV1PN1jh1XhPK7aNxvCb3I9Q5Fh\n", + "xvmuIMbpVBDjOPaJ2l76lHPbth+LiD8dEZ/b9/2Pv4j78oj47yPiwxHx6Yj4c/u+/6663yk05ZAK\n", + "PHifS28azlH7RVlGm/tOS736r0ZrDis4VaqHlaaLi7j6aQPDhV8EoLFS5WP3TJVHhhX6DKe+CV2E\n", + "GT7bNWyGGT8/VRsDrFpHU+3CqVj2TxXmtNwe2ydbFV+Jg+6Y1zvxWZO+mmmoWUKlyFz8FPDKOoX2\n", + "4xHxtyLi70DcD0TEz+/7/t9s2/aXXxz/gLpZraEpOeq2vB7v5bQOtWq9iM+pTqnUxQRoeMwwUIBQ\n", + "jaNSngy0LE917MxBpNp4ylsp2mz8CbM0VIO5Z6hVgEeA7/s+nnI+efKkBQ+H2Vwc3qsGm/RX7qv0\n", + "qviVesQw5pGhOgFa1Q4qsGVZ7kSh7fv+C9u2fQ1F/5mI+I4X4Z+IiP85FoHWdVxWG05p8bmI+dqH\n", + "W5hWcW6tR8VXAHNAm6gvLr/yK1qnBHC/4mc36Kjt0aNHct0xwzyiY30h0DqFhjBQamPyUiC3qv75\n", + "3ApU8F5uO+wzBIp6joIOqjQnApQg4PQ5rmoHXA+HrJ+p/oF1fhdraG/t+/7ZF+HPRsRb7kIFtG79\n", + "x0nWbnSI6N8mVSNltU1UziFAw/J0G5qCNYYRBkpx8rECk8qb8n8VPjk5ufx+7/T0NC4uLi7Dz5+/\n", + "+z0cl0/VkRvh+Xlq4Nr3fQQyBbRuIHPmOm7ey9PxDCPUWC1xmfi4y4fqM9gGVVudCgknTFz7QZ+4\n", + "PfeXqd3opcC+7/u2bVYTqjW0fde/xum2vKfrRBF+4VXFVdNGNYpyGi6O89FVUlc2BbMVcE+2riHm\n", + "hvWBexWXQEuQJcyyXhFmakDKju/WY1Qe0Edpz58/H/2FAAKt+rMghJFq2+44BxlMM+Hl1g9dh17t\n", + "5Awx9qOCpCvHRKFVMyxXFic6Vu0QoH1227Y/su/7b2/b9pUR8Tl34ac+9anL8Jd92ZfFm2++GRHz\n", + "zodTDTdiKOMK4YbhwmjuWal8cFTjac5068riynEI1Nx5VW434jqgVQ2+q99cvEeAdW98Vzp0pt/9\n", + "sxFUea4zKhBw/SgF0vmhq5PKHNAVqFSeVFilP9m7gVHlj4+r7cmTJ5cfPXd2CNB+LiK+LyL+xov9\n", + "z7gLv+7rvu5aXI5SaJORudsynW56Va2N4TXVOokaiatOy6YqlMNKmbGvJtDCOD6fxwhpLpeCG/vB\n", + "df5M270By2Ouc3UPQm+l03dtpquHVQA4VeHaXKX4876qHbp8qPhpHKafexfOfddn+Xkrg+4HPvCB\n", + "+MAHPnCZxu/93u/ZPHefbfxUvPsC4Cu2bfvNiPirEfFfR8Tf37btL8SLzzaK+6/FserCUQTXFxzt\n", + "XZwCiTuerJm5hsSjuBqFGYYINgRH1UEq6POxaxh4Hcepa7A+lI/541XcqzgHtJtuq0BzqqHqaF39\n", + "uHh3rNodD57c9qo8YDusbMVXDpoYVj6sgKbSqZ4/EQSVdW85v9ec+ncmiavMsDOyUhhm3BDxbRbH\n", + "c2OcqLQKYApm3JhUOK/LfOY9XDZObwqflVFNpe2ey2B2jZWnnHwtx60AzSkzpdS4HJWpzsb5ZX9M\n", + "0698qvYVyBTUVsq5ku9Vm8yQVtbPqv5WiYmJ3epfCqgMZYdXSgBh5hzFU5TsNBH1t2V83L21VE7l\n", + "ylGdGCGO9/LbOqfuVsHlzrk64HPody4r14ObcmKYVc+h4HLTTVZoXaN36l6VAf3ojpUPea/C3YyA\n", + "w+55XLbqfOWnqi2r56zCrIMa5ktt6YPs21O7VaA5hcYwy3gOY+PH9ZNMA8MRawqtGhmV9FfSG+NV\n", + "RfM0MzdMcwXCHdwwnq1q9AwzLKcCkvKHCiug3VSdofLtysZlUHWEaXQgc8/qBhYeMFcG0cnzVf0p\n", + "0FY+Uu2cj93gwMd8zuUr217lt27AYrsXhRbRvzWJiLLRZ2GR4B2YGGZVHG6uUt3G5eU8Mtgy3uXH\n", + "5YvvO6QBpJ+5vrA+eLo3gRkq1inMeLRfWUOrVMwEZhjuoOVM1QXWabXUwfGdufzjsWonClgqHp/h\n", + "xIarL9cXMH8oStRxXvdS19BualVmKgemqYbstggNhclxp9I4b9VIxYZ5q6CHjdqN6FOorfrc3aeU\n", + "8gRmmO7q9LKaauaGflW+5ny4jubUA8c5n1bwmgBt5UVUdTzJG8a5+xFu1QzEDT5qwKjaPKszFV61\n", + "O1doaRPyukbuKv4QmLkGyKNHGisXVaFYdkyj6kyc/0eP9P/EnEANrZtCuPIqmE2Bhj5YVWfdVLR6\n", + "KTCBcuV/5d+JdQPlBGgMN8ynGlSV311/cG2Z0+jOK5Wr1HU1Y8HncPtVcat2bwoNM+vCDmQYznv2\n", + "/bD1qEPA5jq7Ug8OFuwLzof66wUHMDW6pamRFs+h39gY2uqzDQ7jcdZVN+1cVWuuwVdlmCjpQzqQ\n", + "qw+1bDBRZi4fqJ7Yz6ocrg1WVim/apCrgFblE8ukQJb1vWL3sobGGXf7fX/vz6RytO9G6ENAVm1o\n", + "VaVmPjk/+HazGr3USM7/kaiCmAI85jnDvGeVpsrKwJ7ALPOxqs5UZ1FLD/gM9jnnxymHDggdZPiZ\n", + "CmbdEkIFOFZpTj1VfcENzKy2lVXtVvWFiY+xHAgz9mPag19Dc4pChbPxpiJDZYaQS2gcCi0HB+Xo\n", + "Ls8dSFemHgi2lXxHxLXGNJk2KFXE26o5ECil6PJXdRIGqAKs6sBcJ9X/I+2mhxXAKrDxOUxLlYMH\n", + "HPavA1vlH1UvHbiqQWql7lResZxdXpXdKtDUH/BGeBDwMW4JswQYT2WY9BPwrB5zJ1Bl4s7Bv2jb\n", + "/ept12mmQGM1xR0b9/wv8fC/SCmgqZFUwb9TlWyV2uOyKFPxbn2T6wr/a9cK2BhEVZwDnAJbVb5D\n", + "wIbXq8EDfVQpZQe2VXhNbAJgtntZQ5t2So5DB/K6TFWxk70Lc547CdwBi+HG62TqVz7UdET5hztD\n", + "qlgFNVRhE5Ax0Nwzq3xVndVZpTT5OnXsplfoVwYaq+MJ0BhiLn6yn/iEfY3H3X1uuqj2nRpTAwYD\n", + "zcFtAqvV9vIgppwOZjiNZIAp5zpTTlmFHeZBNby8xv08t1Nq2GkU4FzH6YDB0h0bn/rXeAiySq2x\n", + "P7i+8dwk/1PjDjLZR1z/ljHrimGWezflnwCN20sFOwe03BR0nF+wDarzGL8CtcnG+VMQq+Jett0b\n", + "0CYNISuDQaIWkCNm37ZxXjhcqbMMZx6yfNv23sezago5mWJ2MFuBGjfi9ANDzf139kqhYV6yjpWv\n", + "OuCqOujqC887BcDhbsrpFFr1T11wU+2ja9cKbG6QcH7iczcZHCZTzSnYuI643jisynIT2D0IoFUd\n", + "E+FRSePV0VvBbBLGjoxpYoOcgEytma1Obyq/pV8qlTb5T+z8j4wzffyFVQYowmIKNrRuJHdTGt4i\n", + "rq6hcTvEOspf0nX1oerKDX5u7wYmFceKbBX8k2uVzw6BGfu3A1pn2GZXQB3xgICmKjWdjFBDgPHI\n", + "EnG9klwc5qc65vjMQz4Xj7dtG6+hrb5Vm/gL/YYwS1PqTMHM/Zf28/Pzyxc92FF52lPlk++tbFJ/\n", + "qj2oDuoUWvdSwClnBNqkLXWDEPop2xlCDdNSA8hkoFC+fBkgq+rG1enEDlFr9wK0idpAUCTUXEW4\n", + "SqquqSp+OipgniLiUrlM1Jlbr3Ewcz5zAwE3bvaHmmaqdTOGGvrIwaxTlSs+VlbVrTrGZQmsu9zw\n", + "Z8IrkHHcahm6Ns91hlBTKtB19km+nM8OWTtTCrjK323anX+2Me2UWGnTqYWqnOzcfK6zSqlVCrBb\n", + "P+MXAgpcLm6qbnMAYKWLMHv+/Pl4monxXI849XZ1rPI/8XVlbtBynXOi0FJxrwBtpSMrqLt2zyDD\n", + "/oCDlvOf82nVnyZraA58K3Cd9sFD7F6nnGpBVAEt9y4cEbIysOLxxcGqQ12DUfmZrp11n2c4dTZR\n", + "apVC42mnWz9jmOU+y87TbQWL6dpfZZ36Vh0R4xLeVR4ZaN3bZwU03qs4p1QrdZZ7hhf3j6kqY5+q\n", + "9egOaCr+EJv0w9XB7t6A5jopryVErL+e5w0bDMahVY5FQKgREu+dfKqB36AxtLq9g5oCGhv6ZAIv\n", + "95azGplvAi/l9+68mvq4doCGMEPgTYGWs49qoFVAQx9VYYYYhlUbxPSdr9QAt+LDKl6BlRXsav07\n", + "BVzZva+hVeGI2avfbIjZUV3nUcrFmasIBVq0So2p6YvzQQWwzMcEFGokdrBSDdeNoiovnGel0jrV\n", + "xs9w5anUmlp2UHnHukCgTaGm8qPiuP0otaXiUJ25MPuqavfKXxOfKkjjcycq0Z1T0FJCYWp3DrQJ\n", + "zFHsffIAACAASURBVBBoEdcLVsl6dR2CzKk/dqKrqKrTbdsmFZmC2sQHVYevKptHUP6QlqHmRlrV\n", + "4Z3aZPXiAO6OFcjZv1XHUnXvQMz5wI7r8qfyptqBGghdO1KDU5oCWPYJDDsYoB+wLVcwU8b55LxM\n", + "oLOiHF3c1O71pUDXsdEqYEVc/e1xhhw2Vp4qroDMjah47KaZ1YuADmbsP+UDhLaaFjiYKahhudJn\n", + "WZfd36OuQE1tE6hhnTk1wYbl4cV/vA/z4OpK1UsFMpUP14YyTgHMxXXG/aTzl1NhmTfMCwPzEHuZ\n", + "UHtwa2gOaGlVg+XzKPnR+ZXzVAU50KhGXn220XXeDm4TX+C0i2GllJlaNMdyp9/yOEGd26ScDmoO\n", + "cJNyV/ByHVZBDWEdEdfqxtUTm1KSfE7d7+rZKTSnjqbhbkrJ+XbTyfTdpC5U3ARgh0DtXqecFcxW\n", + "CuKcwRs+B8GlYMaViXmr9thR3d513BWlphRl7p06UzC7uLi4hCBPOTM/eDz5xRAFt6k6m8CM4dF1\n", + "qjT2czUldXXe1Qem485xXly6Dma8x/aqBmQ1vVTTTuczFdcBkUE4UXA3mWqmPZgp5yGNBk1J6dz4\n", + "TWfVUSZTFqe0JirEvQzoNmeqEXWv3hluTs1gp8njyZTT+WIKNyyzAkMFMRfPKqmaPUw3Nc1U9TJN\n", + "G2cmE4i58ipQderM5ZvLxgN99WzcK8hOB6wVexBTTne8YmrURsnOYMvr0tGqonCvgLaqQCaKpAPa\n", + "ZGrRAYzj8H4FNYzHKWe1fqbW0Sq4VQOagxrXt4MblqdqW+7ZlYJS/lfnq+eo9DuIdWtoyj/qU4tO\n", + "4WIf4Dh8jtp3ImEKtRW79882XEOeAg0bXjoxK1+BjDsJg8vFKZipRfBKueExj8iTRt6NhEqhVWto\n", + "+G1Z5Vc094azUmlq6/ylAMI2gRiWp2pfGMdlV+2GO6rrmCoPKk+sTCOuQ43jGHDqmVNlVpkqs2uT\n", + "DDKGmlJgLxNq9/6nTw5mXJhJ4fKNFQONGwan5RRalWelRtwnGW5/qCJw0w0cifmFQPWWUz2f85LH\n", + "k09SlHKtVJpTrc7UNGc6dUr/4+I6xqGfqzAfd4BwIHObA5gK80e4K1Dr1JmLY7Cp5yDUKnuZUHtQ\n", + "f/qkRipXINW4El4INvUxYl6rGqRqEB3I8AcCu/KpeHwG+2jSabghdd+h8VblhwHdqbPu041DpuFc\n", + "zkOPsd0kFLDTTWcFqj4mHW8ygGUeKoBxOI1nIqzg+MWP8leXfw4j4KYqUIFKAfIQexBTzgoA6n51\n", + "jA0zGyduatpZORbTzLCCGq4nMdC6DdPtwpw314AqmLmPbNFf6RMsK5d7+mGtm2ZWoHM+Yus6pgMZ\n", + "txX2pWsL6nh6Dp/vQMYbK7QMK7C5vuLKWMGn85uLi+hfzHHeXJ4ng7ize59yVoBzjuNjHHUnWyWN\n", + "VQVP14ROT0+vlRGPJ+fc9Q5m2YhwBK5eAPDGv3HGQN+22c+Kr6gzrPNDppu8nyoOBTW+rkrfpVuZ\n", + "A0LXDxzI8JjzjQMSP9uVL/2Ae84r5tmdw7S4bWa6Cniu7/GgM7UHo9C66UbeWx1PJS8qnq6DRMQ1\n", + "JaLWyyKu/kGxe26lALFBYaVivrpPMp4/f/dngc7Ozq5sGad+8wzzo/JYwUxNww+ZTlbm6tHBbKo4\n", + "VBx3KJeHlTaGxysDGOeVB2P+yBah1u0RMAy1vK7Lo/Mdw6yK67ZVuzeFNoWaul8Zkx6Nj3HtwTVa\n", + "DFeqQ8ER03AQZpC5sBr1uulkB7Ozs7Mrv7bB9YJ5RSW18v0Z+mkKspUGfAjMuB6cgnGdyXW4Cdj4\n", + "mcofDhTOuB2rwRnPMRCxbeELBjzPeXXH+RwHrQnM3DUrdu9TzgpseI8zVEfZiboG7V5xpykAVmrD\n", + "3VdZBzIMMzR5GsnHDDRWZvwTQelznspgfUymnM5P3RpZlm2q2NAXHWSUQsI64D1O4fFZ7vl43g1G\n", + "nSJzcWg8sPGm4MaqjPOn4ObagAOxU2gTkPG5Bw+06ZTTHat7K0uAOqAh/JRV6q9Tkez8SQfFezuo\n", + "YaWrb8oQUApi1cZA4zxOp5RuSl6ptM5H3aDjIIZxTiU7dZT38pQMn90NmvgspXYw7PLBafCxg3gF\n", + "Nwd8Fa7yV/WBVTXWhVfswUw51XFnarTd96t/bMzX5CjcpcPH3cgecf21+dSUElOwQ/XAMEPlpRRa\n", + "pdYSRvxa3yk0p9YqJctwU75GY2XFDbvrkOqeqdpwnz+o56rnqPqtwKXyg/eqwY2hpnzAIMMwplv5\n", + "zQGsAtpkw7as9u87oDHEDgEaG8PMPZc/oHSNyz2jC6tnV3nOa1YVWoKNFVcHMd4YZvhst+hfvRjo\n", + "XgR0wGegs08yvlIpqixcJ5M1W1Qqqt6c4fU8QFRQVfdz+XEAdGWfgIzLwWFVZ5XaPhRoCmr8FxJT\n", + "e1C/tjFpYM7ctcr57k+h3Eg5qaC8TlkHuwnUMh2ebrIyOz8/j2fPno3fcPJaHD8T66b6NEOBbTq6\n", + "c+fH8jqfHFoXVSfF9upAhmmrZ6jrJxCbtnsGvYOYO1f5huOnQOM3rVOgMcDU8aqwuReF1ikzBZTO\n", + "1Ii2bduVf+yRmxt9+DoEYOV87kxsruF38HJAVVCr1BlDjeGW/yAEy4W+cAqtevur6nFloEKYsapg\n", + "v1Z79CO3jSybA5qCGqeNdcb1hufcwKnisNycb36GArkCHN7T+R/PTwUIP7sbeNTnRip+0vfRHsQa\n", + "WuWkiSmgcANBVYYNtXrLilDkzyMyXjV2lT/2gVIfeK0CnoIZAq0CWfem0zUg7PQVxNwnLarzYr04\n", + "f7GPGGorakCBTdV5Ao0VPOeT01Rgc8du4OQ41V44XXx+BTFWbi5/HFf1T46r6kSdm3xPmduKPcj/\n", + "KeDeckb0n2K4joN/hJ0VP6msvDcXz/O7rcwLdpTsCFhu1Rhd4+TzbuTj9bMJ1Lp/IKx+F407ewcx\n", + "3juYcbgyBQ3uKNUezUEMyxdx9ct8lXflJ2cK4A70lX/UwOnaB0MNwabSc+FJH8F67pRZxk9Bln1u\n", + "xR60QuPOj9aNNmrUS6gx0Fw47zs/P78GWW7wWGn8BTfmaarI+Bw+kzc35axeBKi1M6Vy3RtOBzme\n", + "crr6UfE4OCi/4HXdxnXCz1RwU/Fs6jmuPCq+g5l7bvWMiSJS/cUNOLl38HIDf5eHjFPgUnHbdv2L\n", + "hM5uFWioZtKmDUlVWnW8ImGnQMtwp2z4lyvy7QwuxHLnVmV1fsjzJycn8fjxYwuf3PgPx/MP6B8/\n", + "fhyPHz+O1157Lc7OzuLZs2dxcXERr7/+erzxxhvxxhtvxOuvvx6vv/56vPbaa1f+fyiCRXUWVMis\n", + "lic2VSfccTgPyjeYv2wDbgBz3/apMOZtUpcM/GyHXM6M64CD+xxUHCTyeBWsXdvE+zug4oCvwIXH\n", + "GLditwo0/DtBtGmHjph9JsFTsU7WZkNiNaGOs5G7f8bL61BpKPuxLBN4OcirDsvpoZpKkJ2dncXj\n", + "x4/j7OzsEmao4hJguE/4JdDY1+hzhMxqA+R2MQ1PVBp2IARy1XF5fbLaVD1WdcsqNv+qJTc8drBx\n", + "7YVfUqm+wOWfgMzVj4qb1knm18GMwbZi96LQuj0XQoHMAY1hpuAWESXM+Fw1WvOfHylpj41UNZ7p\n", + "9Pv09FQCDfOPbyNRmakXBPk3nanaUME9fvz48n61pqnU2cTUNI39xeEKaFUYn+cGQ47jlz/VPvOz\n", + "Ah2conNeXHldu0Dl3KnVrg06wCkfVn1wuk1g9uAUWgW0KozHK87sRinsfB3IGGjqZ3cU1DDvWSmq\n", + "bK5xVntu/Hye1dn5+Xk8fvz4yvqaWkvDf0uHEFRTTuwYqhNhnaAqQuM4pTZd++B20bUNbB+TTu8W\n", + "p1U812UHtFRguLas6lT5A+uY223XN9jHEwA7UE6gOblPwYynm/wVwcTuZcq5YgpcGM8jswKYA5rb\n", + "8qPQ3E+nIDwN4YpEc1Bz63ichlNmZ2dncXJyIv8kisPn5+eXqqH6syb1QgT9jj5162dOISmFguEK\n", + "cnx/9bzVNVZ3jOEpzFChcZtQv3KcdeLaCrdVZQ4EK3muxIESC1PIqTU0N9188AqNrRvBHbhUnHKq\n", + "CkdcBxqubzx/fvW/7bjpZaXQsAGiVQ2+2rhi1X0JIFaP3XS5mnojcNPXqCIYbAo8E+WA5Zrs1T3O\n", + "Mm+TOuzakGpHEzioX4HJjpzhrGen0lRd8/OxbUyVWAU093JBqdYJ1LBP5XPcdPOlK7Rt234sIv50\n", + "RHxu3/c//iLur0fEvx8Rv/Pisr+y7/s/VPcrhdbByu27uKkcTjDwAm06Wik11xkwPsMRV79Hy3SF\n", + "b0cgU7+9hvclkFKVnZ6elgpSlQXzk2EVxzDD+kDFgmms1KnLQ7WvwpjHLLdSqXisVLXrnGpQcnBA\n", + "CKo8JxR4aQH9ks9wCprzUK3HurxivIO+a1dd/8PyVQC7TYX24xHxtyLi72D7iIgf3Pf9B7vEnUJz\n", + "DWZ6rrpuskW8C1ulyhAkOJqo0UntsxKy4vi5EX6hV0Esw9iB1EitgOVGVT6X/uN9FZeG8Oa4Sf1h\n", + "+h1QJ+fQT5gfBBr/GRiGu8GVwwoMCh6uY+J5hhqDXq2TVj/npLYunwxh9Vafw5j/Cmo4Rc30Hcxu\n", + "RaHt+/4L27Z9jaqHSeJOoa1ufF933MVn5SHUEGgIM6wsBQkVxnsqdcYNyamzXCdBeGA+XV5Wtmxo\n", + "1bHq3Gmo0HDKMq0/9k2GVRyH8XlKrbFCS4jlH/E/e/bsMuzKp8zBQIGC17rwHLYZNwCqtsFQm/6d\n", + "7VTNqQEAjzO9BBxDjMMJard+dhcKzdlf2rbt34uIX42I/2zf999VFymF1knSVbh1HUadi3hvyplQ\n", + "U3DD4woUeA6nD65x5r6DGQMNOy5+RFkBivcqbvKiA5UcggLrFTsx1/dk8OnAhWG3Kdv3q/84BiH2\n", + "9OnTK3s0BqsKd1DIPU/tWXVx3VXthT/LYbjxhvEqbyouQZXwz09/clPLIEqJObihEnP7l67QjP1w\n", + "RPwXL8L/ZUT8zYj4C+rCCdC6fdcRlHJwcbnPUYAB9vz580tQoEpbUTpqpFVQU42aQYbHWclTn3WD\n", + "A553n3Scn59fNqi8Phsu1ykqpApoVf0dAjPulOhjzANPORNiT58+jSdPnlyGq2dO8zAFmhrEqvbi\n", + "FBr/K8XqGEHU7bNdpHrltok+xnav2iHu0SedSrt1hbbv++fA0T8SEf+ju/YXf/EXL8Mf/vCH48Mf\n", + "/vBlobADqA6S+5UO0e0naeMIgfe4BobH27ZdGRmx4XE8TwPcdJMbjwM05hv96pQwrtOoZ+OUGztb\n", + "lhd9gaZG1Gn94f1ZBva5Akm1j4jS1wwkfJZ6Lse5Z3McT/fUtuI3N5gqnzrf5jU4EGe8GshdnXGe\n", + "c+9mBm5G4dL+5Cc/GZ/85Cfl89iWgbZt21fu+/5bLw6/OyI+4a792Mc+di2OiYtrLzjCO4dF+IrG\n", + "810Yjx3Uqg6Hyi7zzQDjKYFb25gs7PIzca/OcX6xvAzHjMsy4JS7a8CVVc/Dazi+6vQOIi4uIuSA\n", + "otaW1ADVqbNDoFYBzvnRgSyVzGQmgX7Gfsd9LwfG6odAHYhUHiuQdWDb9z0+8pGPxEc+8pHLvH/8\n", + "4x+3ba77bOOnIuI7IuIrtm37zYj4axHxndu2fVO8+7bzUxHxF939OAWobBVkGHYqje9zxy7NKdQw\n", + "vX3fr0l8XsNw/99TyXlu9ApmHdSUmnKjN96foEZlVvl0JY793pmDh1NADKj8qwmnlqffdPG5DmC4\n", + "V/XroKn81MGsAhu36U6NZlh9t6jS5XxWAMNPPBz0bjKIdm85v1dE/9g0cfcVM6R/WQkINXVdBTIe\n", + "farnRVxdwOzSZVOAQOP1i27Btpt6ThSaAhjvcZqh9tgh9/3qb2phPfLAgXsckNjXVZ2wkkP/VjDr\n", + "1I9TaJVSVs+tADdVZ6qO8Rouv2vjGXYwY7DxvVw3rk0j0BJqCkiqDzGg3Me46nruz6tQu/MfeETL\n", + "AnWjFF6P9ymnHmIKZpUyw7JxY2CYOZA5oKm1s3xWBTO3R58qmKFxR536C+P4One/2yuoYd468Cto\n", + "OHWm1jUnEFNAm8DN1a9TSexvhMG2bRJsTqG5fuL6WkSMFZrqj0qZuY9wVV++FYV2U3MKTYGJK3Zy\n", + "T6Wk0Ko0qw1Vj1I+qvErhTZVZy6M6acfcP0OjxlmnF8FM9VJ1WjOynbiNwfPbgReAQpv7LsOYhjX\n", + "PQ/zdZMpZzXtdH7iqWYHM7wnw6ou+FlpCSAHNTWgMcwmf1Xg0jkEaneu0BzEOpDxvWpTaajOy9e7\n", + "TokdO+/NvWrE2XDdtPOQt51uyhlx9WfHHcz42DVoVmYOeGqqwIMK+nXSgSq4TQBWDQgMNAYY36Oe\n", + "WcF1OuV0002l0tA/ql0izBJkWc8MNoZapY55n+mp/z2xAjUFNn6Wev77RqFF+DeLqnJXaI73YWfi\n", + "Tob3s/JAmGVYNWjVQPn7H/fGcwoyBBqrsCyDO5fx1YDBZVKQ5nie9mAe0NcVzLhusU5c3ipAuLeX\n", + "lUJTYJuoQuenCm7qhY8DpvMR95EEA/vCQcf1HTzm560oLB7oFMzyF164nlm4qPDE7k2hITAmSk2l\n", + "g5VWWXasSgUi1DD9zKdSLKpDqU81JiptMhVhFYbqyyk0BrzaWC0zLJ3aS7+zauxUmTrn1BnnW0FN\n", + "wWwVaJXvHXg6VcZ792JgotDQr7g2GvGucGCIdVCbbNWCPqbLeVUwY7Ddlt25QkOgufUeZ10FKHBh\n", + "HCsB7Hi8VwvrmCZ3KFZi6vONCczUlMQptAnMXIfk8qQ/EuDsIwU+TG/1uU41YJ5yr1RRpdAYcOpb\n", + "QHX/yhraRJVVitJBcgI1rjucdjLcGDBOTamw25RKy7xW9yigqfJUx53duUI7OTm5BFrVAdGcVFad\n", + "Ig1hpUCXafG1mI5SaNyYp0qsAxo3fAU0zBOrIjUVdT51UOO6Q5+goua/seMpwkojxMFI5YkhVoHN\n", + "vXCZ1s1UoSmgdXCrBrCufhhAbAiy/JO+SqHhlJBhx3HqeKL6HMxyPU5BnPsp9sup3SrQlLmpBVfo\n", + "ZLRX8HMNw3WyaefjZ7qONAHXStlU+RR8GfgqzNdWvsjnoDqrppEYTgBiXPqM78s4BsDKVpka8Co4\n", + "VecrU+d5RsD5QcWFz8ABfzLYcdlYram6c0qsiqsU3bQtsvrn8MSvld0q0NRocshUIysNw6hE8LxK\n", + "w6WrIIqmIKaUgYIaN76VzlGZ8t2kcU6VLZY7w5W6dR1Fpel8jP6t1rTwepUPB4nJGlLlb/aL6rxK\n", + "MWeY2yD7Kmctz58/v6YUKwWYYVzLQj9yvGt36Ifpx68OZNVgWdWli8P2V4Ev7VaBpgqHTmGrRmEF\n", + "NRxVseK6fTX6dnEdyKqFX8zHy7AKZpM1E9UA1ajpAOL2FSDwOayMcJrYrTepZzLUcK/UxiSf7O/M\n", + "O3ayNAUyhA6mwfnGJZgVpYqqlweF09PTK33t0aNHcrlAtSH1+2Yr7Qjr2MVVEOPzuK/szhXaiiMQ\n", + "XBXIJg5wcZ1yqq4/BGw3tUnjqhZ0p8qka0SHAM11Suxw03Um9gf7JtseAk3BzAE9zzHgGWps+KKG\n", + "4zjfCS81nUR/VWF8joJZpdIqmCXQpltlrp9NgbZi96LQOpA5ZaZA5hSaC3fOco7vVJqaLlUj7SGm\n", + "RvfJm6yq8TllW4UVEDqgJViUPx3QOnXC5UCQoU2BXsE78+lApp7JbQZVGqaFqgwHvkld4H34lp2h\n", + "xH5XvlODoRos+HhlkOyUmAqv2L2toXEYTQEkr+c4TBfv5/Sq9CcKDZ+LUKs+F+imTIdapdJW30Y5\n", + "cw0un4954b0CBXZw7uwINPQt+rvyHfoAwZHW+aLz9SrMVBrpB04P83xIG8nrs/3lP4vOD1jRF91A\n", + "wCqNp8mqjp1oUXlUxxPIrdi9TznZKtgoiCknqDSnz1DwUflw083VKdOqVaOkA1kHtYl/0I9Vw3Yq\n", + "kEGGCjvbSbcY7jokgib3WeZ8brV+NoUUg0nlw20K4u6ceqYCSKaByuy111678qdKrNA4bdV+1L1V\n", + "HjAtNgWy9y3QHL3dKF5BpANc58ybmHv2BGgdLKemOpACmVJrDmqY7grgV4CWHZahlnsEqoLXxHf4\n", + "PAWHyRu6ie+5/Hhe1SdDTvmZ4/j+agDLe/G/3eN/sXJraNVz+KWA8rHyTefLapBUEHuQQJu+FFBw\n", + "YzXW2epUYNph2MmT9TO8jjvpTaxSWdwgJ8pMjfbKP7xYvTJSI8gYaqwQD4W/GzgRaBOoZZ5WnuOu\n", + "y3xjOJ8x2Vd1h+cSaI8fP47XXnstnj17Fq+//vq1v7vsYOZeCjhzdeKEhYO3g9j7BmhcIWzVaPay\n", + "1I5KeyUf1TpaNVV6GVBLcyCrppuukziQqbJ2EFNAy2dkHhBm+371O8JJA8f8Ytp4jHFOwSpTHX6l\n", + "ThTIlI+75yq1rfYRcQmz119//VKdIczwGei/SRty+VSqdUWl4bEKc9zU7n3KqUbICmhOufGzJs7l\n", + "Y+VAfjZ3cJ52OiC8LKgpeChoMbzU2iVDQJWZy9pBzAGNweZUEtaNgkAFM47PsAI95035eVoXCoL4\n", + "fJXHLl0FF/XCZ9u2S5jlf2dyUKtUFabPCg1936WF1gmQDmIPDmjVW84J0dPQEZNRw8VV6VYd+ibb\n", + "TYw7jOqILs75Wd3n8qlebkyApsqg1MCqL1R+lX+4nbj1xQ6sqxDCAZkH5i5driMFL/Umctu2K/+C\n", + "sPoRRsyLalO5xzpyZVLl7toe2m3ALOKeFdq08NNOWj3TGYOMFVW1uO+eM60I1ThUA6s6n7uneiaf\n", + "XwE0rqN1Pt+2q/9LtLp2BR6ZZ9y7uIiwCgc7vpqiVc9VxmrMwYPvUXHVP7ZmoCmIKTXaPbcqa3V/\n", + "1nOnhKfPuok9OKBNIafSqp7Jxg5UHZenW0oycz7U81RlVfIfO4UaOR3UDzGnTHktMDf1PPfshNjz\n", + "59f/76Ma1dkPbJXScKM8qg0HBfy9rso/mIdVlViVheM4vwpu+J3Y5AcYq+d2ZZ7k261Tdn1z9fmd\n", + "PYgPazuArYJv2jkc1Nybyu57KDdC87OcbFf57Xx1iLpRxkBwvsi88BtPlXe0hFlurgyu7Byn8ovH\n", + "eM10+pZAc3U17eirMFPHDDF3XJXvZbWRSX4RYh3MVoC1CrcH8VJAAYnP87Vdp55WQoR/+aDeXLqp\n", + "JueDwaYAWuWPR3zXUA8x1+EmUOO8Vulw+Sb+wzRdHOZR5fcQoOWmfIE+c4MUl8fZZOBFxaOmxU6h\n", + "VSqpy5cqtxMKrp4cSKvnHjJ4VHbnCi3CQ0qdw3sqWwWaMgW06Z8wuU7pKsZ1bs5vdhzXQA5Va0pJ\n", + "sg+UPzBvHO7KoZ5XDU4ursqnUmpOjamN7+X0GGQrg4rzm2qr6qevK6BVCm01ny7vXZ+t1OFNnz+1\n", + "e1FouZ+OyJNNPc81GuzMqoO49TP1gayCS4Yno7lbo1F+qxrVIcZQcxDj9bTumVju3CqFy9dO6roC\n", + "GqpJTHuq0JTywzJwvlVZqrgunHllqHUKrfsXcZVV6qgbaNi/Ge76Z/fsQ1TavSm0lb26fwK1ahR0\n", + "NlFoXX5YUU0rBu9dLfPLGgE7hZYL/FPjBu/UmeuIrnOoAQiP8Vnc0SrF1k1juWzu2J2bgs3BjPcR\n", + "vUKr8rlqVV2twOzQKWVnd67QML6q5Go0wGunQFPn3Gjf/YF5N+WsIDZRKgy1QwC+apynaso5TWPf\n", + "r/93r7yuKpvqGNxJsD7SZxnH57uXARjulF9V/64+pnHojxWgqZcG6DN+RlV/KtzV02RQWrGbqLR7\n", + "m3JOwgpIFdgOeQYaj/bupQB3TFeJXcVyx8b0lN8mUDvEKlXCU/CVNBMsCbOJwlUd0o38OAXGPZcH\n", + "061gxvlU01dlboDu9i6O88T/Bs4pNPfz2Tcd9DCPbtCpYDaB28tSbPcy5Yyo1RMeVwBznXoFYmkT\n", + "hXbI284Vy3sU2KpG05VtYg5q6rONSVoIkmrKXsFMTRMZaAwzLAuqw4lKQ4XG+a3gxvWgAFZBTLVt\n", + "BzEHNPXXAVOYcN0pY5C5wYfr9JBndecqu5cppzs3gZwDm7pnWoHVmlE31eR8uMa9kie8plJtXI5D\n", + "TMl71YkrP7EppcPG/lIdxa175f34bHxGqsKMr6awnHaWCdcKVZtS6nxyjGlUQOsgjL5gkCmoOVP1\n", + "g/WG5eU4Lg+nkeewPXHb5raG97q2U9m9/hu7yjGT0aXqMHnexXf/6JennsrhkzxnA8vKzGPMP6bp\n", + "AFM1PBWn1jfQVgFZjdxO9Uw/PcC3c5XKcIadhtUbl1cpqK5TsQ86FcPHHdBW88ftgdtBNYCw8QCO\n", + "/9Mz4r3BgWGv1JkDtdq7/Hbl6OzeFVpV0YcsMk6ozr+Q4X6YsVJoburExwpifG3GuY6lRjZVbj7G\n", + "BoeqRXV4lU4HUFXGDlpqradaN1Mdhf2u1ACWsbpf2QRmzn/KLy4P08Hd5c2BrjLVjhhq2TfyegZZ\n", + "hif15KB2W3bnCi1ibfGU6c9pRNRqwnXK7ueyK5BVjcY1ZqWU3JTJjcRsDmwJM/RTjrB5DXb4qjyd\n", + "GsFyMdQm31GptZ8pzDg/CmBqAFkpJ567KdS4HK5NTwaabnP5cWkwzNTgp0Cm+udqeHI8tXubcqpK\n", + "5rgVdTYdVSOu/ruvQ6CmynTIhus0Kq9qIX2iztBwqoDHVWfslJkre7fgXqmzQxazGcpq7/LqoFHB\n", + "i/fqOVUbzjjOE4e7/CkYVe2kgoMCWvYPBTJ80eL8OYVV1/+7vCu7N4XWQcwds2GDckqKw1xx/HnG\n", + "5Bu0Q+DG61jZOBxAMC+q3CrO5QtBpqxSuSpOla1bQ+v2Vf1zfOV/hk0FxcoXbu9s2qbVPeq4gxoO\n", + "hittk9PClyAKaAgyVe9dmVw+qnperbO0e1tDy/PTglUVzeBSx7x1Cq16s1eVJc+rineNAhuNgsxm\n", + "mgAABi5JREFUmwZwWfG462iZH1UWbuCTtLm+1HRzFWrVwnI3+vOg5tKYdJAJzFilKZt2UBenAIig\n", + "rtp8lR9VBoZarp+pAeEm5VL5UUpPDW5Tu5cppxt1p5uzCmAOFNU/B3bfnrnG48qEMGOV5pRQ9/3X\n", + "ikLDEdbde0i6mfahUFNTzkwT9xxWecCBBMPqWlfuycDQwczVf5f/Lo8IM86HG2y78qh+gfnnwcH1\n", + "V8zzxIcR9f9MwCnugweaMgUtXJSsYNZN19TxZA1tRaFxJ0LVgBXOYONrVP55xFTl72CDU9tOaVaG\n", + "97g6U+tnk7ed6scVJx0dzymQKR9zOg4EE7VW5Wc6EKs8VflksHXt1OVDwcw9zw02Kk1lKj/uLTf2\n", + "DRYAnT0IheakpnJaN8IqeCnFM/kOzX2LpoDAo1rVANz0U5VFKTQHJIzntFdANr3Wwaz7ut2Fb2qq\n", + "Q7p2VJU7w9M9PqfaVsrQ5TNNzSBUei5NhFm2M9d2u3OcN3esYIZtIctySJt4MGtoVSNweyXDHdTU\n", + "92WVSlMgWymz26OkzvTRsCwMY2WuEbsBY1WlVaN+7vmTiwpaVdiVR8VPVEHVmSfAWFFoTmGtAq3K\n", + "WzWIcR/o0lR9hc/f1H9V2A1y27Zd+5GAFXswbzlV58PrVRhNqRqGmXq7qdQap7HaYLAxMMgw7Bq7\n", + "K0ueq8rPPu5Attpgqmeswow39BvnUcVjPipbVT0qXu1deq59r5hTm5wHtbnyTNraar44LX628xu+\n", + "hMAfBkCoHWJr/578aEc72tEesN050D7zmc/c9SPvzH7913/9vrNwq/Zrv/Zr952FW7Xf//3fv+8s\n", + "3Kr98i//8n1n4dbtCLSXaL/xG79x31m4VXvVgfaFL3zhvrNwq/Yrv/IrN05jZYlidTnjZdhxynm0\n", + "ox1tbC/j5cZt2hFoRzva0V4Z226Lotu23T2ej3a0o/2BsH3f5Xz21oB2tKMd7Wh3bccp59GOdrRX\n", + "xo5AO9rRjvbK2J0Bbdu279q27Z9v2/Z/b9v2l+/quXdl27Z9etu2f7pt269t2/a+/+Bn27Yf27bt\n", + "s9u2fQLivnzbtp/ftu03tm37R9u2fdl95vEmZsr317dt+8yLOvy1bdu+6z7zeKht2/bV27b9k23b\n", + "/s9t2/6Pbdv+4xfxr0z9ObsToG3bdhIRfzsivisivjEivnfbtj92F8++Q9sj4jv3ff/mfd+//b4z\n", + "8xLsx+Pd+kL7gYj4+X3f//WI+PiL4/erqfLtEfGDL+rwm/d9/4f3kK+XYWcR8Z/u+/5vRMS/GRH/\n", + "4Yv+9irVn7S7UmjfHhH/Yt/3T+/7fhYRfy8i/uwdPfsu7e6/JLwl2/f9FyLi8xT9ZyLiJ16EfyIi\n", + "/t07zdRLNFO+iFegDvd9/+193/+3F+EvRMQ/i4gPxStUf87uCmgfiojfhOPPvIh7lWyPiH+8bduv\n", + "btv2H9x3Zm7J3tr3/bMvwp+NiLfuMzO3ZH9p27b/fdu2H30VpmTbtn1NRHxzRPyv8Qeg/u4KaH8Q\n", + "vg35E/u+f3NE/Kl4V+L/2/edodu0/d3vfV61ev3hiPhIRHxTRPxWRPzN+83OzWzbtn8lIv6HiPhP\n", + "9n2/8oeqr2j93RnQ/mVEfDUcf3W8q9JeGdv3/bde7H8nIn463p1mv2r22W3b/khExLZtXxkRn7vn\n", + "/LxU2/f9c/sLi4gfifdxHW7b9jjehdlP7vv+My+iX+n6i7g7oP1qRPzRbdu+Ztu21yLiz0fEz93R\n", + "s2/dtm37Q9u2ffBF+A9HxJ+MiE/Ud70v7eci4vtehL8vIn6muPZ9Zy86edp3x/u0Drd3/yr8RyPi\n", + "/9r3/Yfg1CtdfxF3+JcC27b9qYj4oYg4iYgf3ff9v7qTB9+Bbdv2kXhXlUW8+6OZf/f9Xr5t234q\n", + "Ir4jIr4i3l1v+asR8bMR8fcj4l+LiE9HxJ/b9/137yuPNzFRvr8WEd8Z704394j4VET8RVhzet/Y\n", + "tm3/VkT8LxHxT+O9aeVfiYhfjlek/pwd//TpaEc72itjx78UONrRjvbK2BFoRzva0V4ZOwLtaEc7\n", + "2itjR6Ad7WhHe2XsCLSjHe1or4wdgXa0ox3tlbEj0I52tKO9MnYE2tGOdrRXxv5/B3a4grwG0zQA\n", + "AAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "imshow(solver.net.params['conv1'][0].diff[:, 0].reshape(4, 5, 5, 5)\n", + " .transpose(0, 2, 1, 3).reshape(4*5, 5*5), cmap='gray')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Something is happening. Let's run the net for a while, keeping track of a few things as it goes.\n", + "Note that this process will be the same as if training through the `caffe` binary. In particular:\n", + "* logging will continue to happen as normal\n", + "* snapshots will be taken at the interval specified in the solver prototxt (here, every 5000 iterations)\n", + "* testing will happen at the interval specified (here, every 500 iterations)\n", + "\n", + "Since we have control of the loop in Python, we're free to compute additional things as we go, as we show below. We can do many other things as well, for example:\n", + "* write a custom stopping criterion\n", + "* change the solving process by updating the net in the loop" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 13 s, sys: 134 ms, total: 13.1 s\n", + "Wall time: 13 s\n" + ] + } + ], + "source": [ + "%%time\n", + "niter = 200\n", + "# losses will also be stored in the log\n", + "train_loss = zeros(niter)\n", + "output = zeros((niter, 8, 10))\n", + "\n", + "# the main solver loop\n", + "for it in range(niter):\n", + " solver.step(1) # SGD by Caffe\n", + " \n", + " # store the train loss\n", + " train_loss[it] = solver.net.blobs['loss'].data\n", + " \n", + " # store the output on the first test batch\n", + " # (start at conv1 to avoid loading new data)\n", + " solver.test_nets[0].forward(start='conv1')\n", + " output[it] = solver.test_nets[0].blobs['ip2'].data[:8]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot the train loss. (Normally we should plot the test loss as well, but we're only testing every 500 iterations, and loss drops very quickly for this example.)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEPCAYAAACp/QjLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXncXGV5978XOyEJkIVsBMIuYZFoi6ioqS0tYMUVkde9\n", + "1q1ara+teyttfVvf2ipq0aJVXrAuRSyKFRRUYnFjDYFA2IRASCAhCQQCRAJe7x/XfZ45c+bM8jzP\n", + "nGfmmfl9P5/nM8/MnDnnmjPn3L/7Wu77NndHCCGEyLNDrw0QQgjRf0gchBBCNCBxEEII0YDEQQgh\n", + "RAMSByGEEA1IHIQQQjRQmTiY2UIzu9zMbjKzlWb27pJtlprZFjNbnv4+WpU9QgghOmenCve9HXiv\n", + "u19vZlOBa83sMndfVdjup+5+SoV2CCGEGCWVeQ7ufr+7X5/+3wqsAuaXbGpV2SCEEGJsTEjOwcwW\n", + "AUuAKwtvOfAcM1thZheb2eKJsEcIIURrqgwrAZBCShcA70keRJ7rgIXu/piZnQR8Bzi0apuEEEK0\n", + "xqqcW8nMdgb+G7jE3c/sYPu7gGe6++bC65oASgghxoC7jyl0X5nnYGYGfBm4uZkwmNkcYIO7u5kd\n", + "S4jV5rJtx/oFRSNmdoa7n9FrOwYBncvuovPZXcbTsa4yrPRc4LXADWa2PL32YWA/AHc/G3gl8A4z\n", + "exJ4DHh1hfYIIYTokMrEwd1/RpuEt7ufBZxVlQ1CCCHGhkZIDyfLem3AALGs1wYMGMt6bYAIKk1I\n", + "dwszc+UchBBidIyn7ZTnIIQQogGJgxBCiAYkDkIIIRqQOAghhGhA4iCEEKKBSSMOZpq9VQghJopJ\n", + "Iw7Anr02QAghhoXJJA7zem2AEEIMCxIHIYQQDUgchBBCNDCZxGFurw0QQohhYTKJgzwHIYSYICQO\n", + "QgghGpA4CCGEaGBSiYMZ082Y32tDhBBi0Jk06zmAPwE8DFzrzom9tkkIIfqdYVnP4ZPAnwBH9doQ\n", + "IYQYdCaN5+DuluZXehjYz50He22XEEL0M8PiOeCOAzcBR/TaFiGEGGQmlTgkJA5CCFExk1EcVgJH\n", + "9toIIYQYZCajOMhzEEKIipmM4iDPQQghKmYyisN9wM5m7NNrQ4QQYlCZdOKQKpZWotCSEEJUxqQT\n", + "h8Q1wHN6bYQQQgwqk1UcfgCc1GsjhBBiUJlUI6Rrz9kN2AAscmdz7ywTQoj+ZWhGSGe4sw24Ajih\n", + "17YIIcQgMinFIXEJCi0JIUQlTHpxMNPa0kII0W0mrTi482vgi8CNZpzea3uEEGKQmJQJ6fr3WAJc\n", + "RiSnt06sZUII0b8MXUI6jzvLgcuJhYCEEEJ0gcrEwcwWmtnlZnaTma00s3c32e6zZna7ma0wsyVj\n", + "PNw/A+81Y6exWyyEECKjSs9hO/Bedz8COA54p5kdnt/AzE4GDnb3Q4C3Al8Yy4HcuRJYC5wyPpOF\n", + "EEJAheLg7ve7+/Xp/63AKmB+YbNTgHPTNlcCe5nZnDEe8kvAG8b4WSGEEDkmJOdgZouAJcCVhbcW\n", + "AGtyz+8F9h3jYf4LeIEZs8b4eSGEEInKY/RmNhW4AHhP8iAaNik8Ly2fMrMzck+Xufuyug85j5hx\n", + "MXAqYwxPCSHEZMbMlgJLu7KvKktZzWxn4L+BS9z9zJL3/41o6L+Znt8CvMDd1xe266gcy4yTgY+6\n", + "a8ZWIYToy1JWMzPgy8DNZcKQuAh4fdr+OOChojCMksuAo82YPo59CCHE0FNlWOm5wGuBG8xseXrt\n", + "w8B+AO5+trtfbGYnm9kdwKPAm8ZzQHe2m/EAMAt4eDz7EkKIYWbSj5Bu3JargXe6c1XFZgkhRF/T\n", + "l2GlHrIJVLEkhBDjYRDFYSMws9dGCCHEZGZQxUGegxBCjINBFIdNyHMQQohxMYjiIM9BCCHGySCK\n", + "gxLSQggxTgZRHJSQFkKIcTKo4iDPQQghxsEgioPCSkIIMU4GVRxmmjXM9iqEEKJDBk4c3NkGPAFM\n", + "67UtQggxWRk4cUgoKS2EEONgkMVBeQchhBgjgyoOSkoLIcQ4GFRxUFhJCCHGwSCLwywz/tiMw3tt\n", + "jBBCTDYGVRw2AQcA5wIn9tgWIYSYdAyqOGwE3gJMBeb02BYhhJh0DKo4bAJ2AT4N7NNjW4QQYtIx\n", + "qOJwFfBe4OdIHIQQYtQMpDi4c5c7nwM2IHEQQohRM5DikEPiIIQQY2AoxEGT8AkhxOgYaHFw51HA\n", + "gT16bYsQQkwmBlocEgotCSHEKJE4CCGEaGBYxEED4YQQYhQMgzisR56DEEKMimEQB4WVhBBilEgc\n", + "hBBCNCBxEEII0YDEQQghRAMSByGEEA1IHIQQQjQwDOKwEZhhxo69NkQIISYLlYqDmX3FzNab2Y1N\n", + "3l9qZlvMbHn6+2i3bXDnSWAV8Mpu71sIIQaVqj2Hc2i/hvNP3X1J+vt4RXb8KfBZM+ZXtH8hhBgo\n", + "KhUHd78CeLDNZpVPp+3OVcAXgDOrPpYQQgwCvc45OPAcM1thZheb2eIKj/Vp4EQzpld4DCGEGAh6\n", + "LQ7XAQvd/enA54DvVHUgd7YAPwNOquoYQggxKOzUbgMzmwo87u5PmdlhwGHAJe6+fbwHd/dHcv9f\n", + "YmafN7MZ7r65xI4zck+XufuyMRzyQuBlwH+O4bNCCNHXmNlSYGlX9uXu7Q52HXA8sDfwc+Bq4Al3\n", + "f01HBzBbBHzP3Y8qeW8OsMHd3cyOBc5390Ul27m7jzs3YcYc4FZgrjvbxrs/IYToZ8bTdrb1HAgB\n", + "eczM3gx83t3/ycxWdGjYN4AXALPMbA3wMWBnAHc/mygvfYeZPQk8Brx6LF+iU9xZb8aNwAuBi6s8\n", + "lhBCTGY6EQfM7NnAa4A3p5c6ylW4++lt3j8LOKuTfXWRXwBHI3EQQoimdNLI/wXwIeBCd7/JzA4C\n", + "Lq/WrEpZBxrvIIQQrWibc6jb2GwHYKq7P1ydSaXH7UrOIfbFqcBp7hoxLYQYbMbTdrb1HMzsG2Y2\n", + "3cz2AFYCq8zs/WM5WJ+wDljQayOEEKKf6SSstDh5Ci8FLgEWAa+r0qiKWYvCSkII0ZJOxGEnM9uZ\n", + "EIfvpfENncei+o/7gLlm7GCGmTGt1wYJIUS/0Yk4nA2sBqYC/5PGLWypzqRqcec3wCPATGKwyBU9\n", + "NUgIIfqQUSWkAczMgJ26MUJ6FMfsWkI69scNRGjshcCngP3cWdOt/QshRD9QdUJ6LzP7tJlda2bX\n", + "Av8MTBnLwfqILCl9BLANzbckhBB1dBJW+grwMHAq8CoiJHNOlUZNAFlS+gjgXODk3pojhBD9RScj\n", + "pA9y95fnnp/R6fQZfUzmOSwG3ghcZcauKR8hhBBDTyeew+Nm9rzsiZkdT8yDNJlZBxwLPO7OrcQy\n", + "osf31iQhhOgfOvEc3g6cZ2Z7pucPAm+ozqQJYR1RqfTL9PxXwDHAj3tlkBBC9BNtxcHdrweONrPp\n", + "6fmETp1REeuIpPpN6fkjwB69M0cIIfqLpuJgZu/LPfXc6wa4u3+qSsMqZm16zMRhKzCjR7YIIUTf\n", + "0cpzmMbkHgndig3Ab6mJw6PAfr0zRwgh+oum4uDuZ0ygHROKO0+acR5wQ3rpURRWEkKIETpa7GcQ\n", + "cedNuadbkTgIIcQIHa3oNgQ8SswdJYQQAolDhsJKQgiRo21Yycx2A15BrOOQbe/u/ncV2jXRSByE\n", + "ECJHJzmH7wIPAdcSk9QNIso5CCFEjk7EYYG7/1HllvQW5RyEECJHJzmHX5jZ0ZVb0lsUVhJCiBxt\n", + "F/sxs1XAwcBdMDJrqbv7hAlGtxf7adw/uwBb3dmlqmMIIcREM562s5Ow0sAvhOPOE2k96V3ceaLX\n", + "9gghRK9pNbfS9DTJ3iBMtNcJWWhJ4iCEGHpaeQ7fAF4EXEf5HEsHVGJR78jE4cFeGyKEEL2m1dxK\n", + "L0qPiybMmt6yFdjDjN2BZ7vzk14bJIQQvaKjuZXMbG/gEGC37DV3/5+qjOoRWTnrs4HPEetLCyHE\n", + "UNLJCOm3AO8GFgLLgeOIFdReWK1pE04WVpoFzOuxLUII0VM6GefwHmK95dXu/nvAEmBLpVb1hmyU\n", + "9Gxg7xReEkKIoaQTcdjm7o9DzLPk7rcAh1VrVk/Iwkqz0nN5D0KIoaWTnMO9KefwHeAyM3sQWF2p\n", + "Vb0hH1aCEIc7e2eOEEL0jrbi4O4vTf+eYWbLgOnAD6o0qkfkw0q/Beb31hwhhOgdLcXBzHYCVrr7\n", + "0wDcfdlEGNUj8p7D7UgchBBDTMucg7s/CdxqZvtPkD29JMs5zCbWllbOQQgxtHSSkJ4B3GRmPzGz\n", + "76W/izrZuZl9xczWm9mNLbb5rJndbmYrzGxJp4ZXQN5zuAF5DkKIIaaThPRHgeKsfq2ncq1xDjGg\n", + "7LyyN83sZOBgdz/EzJ4FfIEYR9ELtlKrVroRWNojO4QQoud04jm8yN2X5f+AkzvZubtfQeu5ik4B\n", + "zk3bXgnsZWZzOtl3BTwKzAW2A79GYSUhxBDTiTicUPJaR+LQAQuANbnn9wL7dmnfo+VRYp3sB4D7\n", + "SGEls86mGBFCiEGiqTiY2TtSruAwM7sx97eaiMl3i7GGrLrNVmB/YCOwGdjdjD2B1WYs7JFNQgjR\n", + "E1r1ir8OXAJ8AvgAtUb8EXff1KXjr4W6hnff9FoDZnZG7umyCspqHwX2BDa642bcB7yN8G72pd7D\n", + "EUKIvsPMltKlfGmrKbu3EHMovbobB2rCRcC7gG+a2XHAQ+6+vok9Z1RoB4Q4QHgOAOuA9xFLo+5T\n", + "8bGFEGLcpE7zsuy5mX1srPuqNJ5uZt8AXgDMMrM1wMeAnQHc/Wx3v9jMTjazO4jG+U1V2tOGrenx\n", + "gfR4HzFt938RYx+EEGJoqFQc3P30DrZ5V5U2jIKi57AG+BqxTKo8ByHEUKFKnBpFcfhb4EngLcB+\n", + "PbFICCF6RCelrMNCJg4PALjzkDtb03N5DkKIoULikHDnKWAbNc8hYwMSByHEkCFxqOdRGsXhAZSQ\n", + "FkIMGRKHev6GxgV+5DkIIYYOc+/VgOTOMTN39+JI6gk6NrsQZa67uvds9LYQQoya8bSd8hza4M4T\n", + "wGPAXr22RQghJgqJQ2cotCSEGCokDp2hpLQQYqiQOHSGPAchxFAhceiMDchzEEIMERKHztAoaSHE\n", + "UCFx6AyFlYQQQ4XEoTOUkBZCDBUSh86Q5yCEGCokDp1xC3CUGc/vxcHN2NeMZ/bi2EKI4UTi0AHu\n", + "rAVOBy4w46gemPBi4L09OK4QYkiROHSIOz8C/ho4sweHn4Km7xBCTCASh9HxFeAAM443Y54Zp07Q\n", + "cSUOQogJRcuEjgJ3tpvxD8A/A3OA3YBvTcChJQ5CiAlFnsPoOQ/YGfhHYG8zpkzAMacAe0/AcYQQ\n", + "ApA4jBp3nnDnme58EVgNHDABh90DeQ5CiAlE4jA+7gQOnIDjTAGmpIWHhhIz9jDjs722Q4hhQeIw\n", + "Pu5kYjyHLHS15wQcq1+ZD7ym10YIMSxIHMbHRHoOMNyhpenA7r02QohhQeIwPiZaHIY5KT0N2M2M\n", + "nqwlLsSwIXEYHxMlDnsAmxhuz2EaYDC8eRchJhKJw/i4ixgUV3VvdgqwjuEWh+npUaElISYAicM4\n", + "cOcR4FFiQFyVSBzCcwCJgxATgsRh/NxFi9CSGdPM+Mg4vYspwFokDiBxEGJCkDiMn3Z5h2cDHwee\n", + "N45jZJ7DMCeks7DSbj21QoghQeIwfm4HFrd4/xiiYf/AWHZuxo7ArsD9yHMAeQ4iYcZ7zNij13YM\n", + "KhKH8fN94BUtwkZLgL8FjjHj6DHsf3fgceBBhkQczJhpxoWFlyUOoshfAYf02ohBReIwfq4iZrdd\n", + "0uT9JcCvgH8HXjuG/U8BHmOIxIEYDf17hdckDj3GDDPjL3ptR46pwMxeGzGoSBzGiTsOfJNYKa4O\n", + "M6YC+wGriMT1WKqaphAVUQ8xPOIwFdgzhdQypgNPoZxDL9kT+LRZ73+D5KlLHCpE4tAdvgG82qzh\n", + "fB4F3OzOdmIQ21gu5MxzGCZxyLyEvQqvPcAk8xzMeP4AjeqelR77YY6v3YAdkThURqXiYGYnmtkt\n", + "Zna7mTUkZM1sqZltMbPl6e+jVdpTFe6sJBrvYkXSEmB5+n+s4rAHNXEYlmqlqekx/32nAeuZROKQ\n", + "ROFi4PBe2zJWzHiWGe9MT2enx364DrNrZEZPrRhgKhMHM9sR+FfgRKKa53QzK7tJfuruS9Lfx6uy\n", + "ZwL4f8AbC691Qxx64jn0uLebeQ75Rmg6sIFJJA7E99iDyZ00PR744/R/Jg794MFm4iDPoSKq9ByO\n", + "Be5w99Xuvp2Iy7+kZLtBcbn/A3hpyjNgxq5EUvWa9P4mam55KWbsV/JyJg7bAJuIeK8ZuwNrzErz\n", + "KDubcWjFJpT1CidjWGlBeqz6fFXJAmBu+j+7fvvBc8g6EEMnDmYT852rFIcFwJrc83up3SwZDjzH\n", + "zFaY2cVm1mq8QF/jznrgf4BT00tnADcCV6fnDwLTC0nWEcyYD9xuxrzCW1OAR1Piu6X3YMbhZrx6\n", + "zF+ixknAZuBfSvb3fOCyij2LMs9hGuE59DwZOgrmp8fJLA77Uiuk6EfPYRjDSjeZjfwWlbFThfv2\n", + "Dra5Dljo7o+Z2UnAd2hyI5nZGbmny9x92bgt7D7nEA3qMcBpwNGpUcedp8zYQjR4G0s+uy8x4+i7\n", + "gI/kXs88B6iVs97f5PgvI8IA3xzn93gVcBZRYfX3hf3NISqwjgJuGOdxmlGXc0heGIQ4TjbP4T76\n", + "RBzM+AjwNXdWj+JjC4B9UqemnzyHqcR9MapedOp87eLO3ZVYVTHpd5hDeHMPNL5vS4Gl3ThWleKw\n", + "FliYe76Q8B5GcPdHcv9fYmafN7MZ7r65uDN3P6MqQ7vIRcQ5fRrwcnc2FN7P8g5l4jAPuAl4qxn/\n", + "4M6j6fW8OLRLSh8D4+tRpBGnJxIiNTXZlWef9HgK1YnDNGLgX/ZdpwOPpNcq7zF1kfnAMhrHbDRg\n", + "xpuBr7vzeIX2vBRYAaMWh6wqaDbhvTV4DmbMAA5yH/GUq2YqcDejDyu9PX3mXV23aGLIzn1piDp1\n", + "mpdlz83sY2M9UJVhpWuAQ8xskZntQvSkL8pvYGZzzMzS/8cCViYMkwV3fuvOBe583J1flGzSKu8w\n", + "D/gFcAX1ie2sWgnCY2hV+TJucQBeBFzpzsZ0vLmFEt05wE+AF4/zOK2YRoQkZ+SeP0yIw2TzHK4m\n", + "xmxMb7PtJ4hORZVMZxS9/vS7zwN+Tfzus4jpYsrCSicQMwFMFNMIcRhtWGkujeHtyUT2+1XeSapM\n", + "HNz9SUKdfwjcDPynu68ys7eZ2dvSZq8EbjSz64EzoSvx8n6mVcXSXCIEcT71Pc2853Am8BGzxgVv\n", + "UiJ8f8Z/0ZxAEnF3tgFbCzbvA3wbOLQkP9ItpgL3ULsRplHzHCZbzuFeokFtWrFkxs5Ewzu32TZd\n", + "YhqjyxfMJkR5NWHbbOK7lAnMdGgtgGa8tmQs0FjJrpG9RrnPuUQId7KSiWHL4pZuUOk4B3e/xN0P\n", + "c/eD3f0f02tnu/vZ6f+z3P1Idz/G3Z/j7r+q0p4+oJU4zCPE4VbqY9TZCGncWUbcnG/J3jRjakoO\n", + "H0UkwHc0G1lWdCzMI266jHXUh5b2IUKGPwBe3mwnqarpuDHakHkOxbDSNiaf57AWuI0Q07PNeH3J\n", + "dpmgV70uyDRGly/Yl7B/Pe09hz1pMTjOjL2Br9K97ziVCLM+2uq4JcxjcovD5PccRCkbaS0O9xM3\n", + "38G53lDecwD4ENStD/FN4C+IkNL1RJKq9MIxY4oZn8wleMuYTX2i6z5qVTcQ4rAe+AzwwVT2WsZx\n", + "wCVmY8prtfIcJpM4zCfE9Tbg9cBbgcNKtptbeOw66Xqayug8hwWE53M/nXkOrRrpY9Jjt8owpxFe\n", + "7eZR7nMuMKfM+54kDIbnIBpo6zm4j1zwWTK/ThzcWQ7sTK0hOYqYnfJZtBEH4JPAe6mV25axD9Ql\n", + "0u+j0XPY4M6viLxSNnoWM/6PGe9IT/clGqJntzhWM4rx5EmXc0iNcRYqvI1I8v+c8hj5nMJjFZSN\n", + "Om9H5vmsJyrUdiN+lzKBaRdWyiam7FajNpXoMGyiw7xD6lDNSZ+pKiRaNTOALchzGDjaJaTvS//f\n", + "Sq2HmU9IZ9wCHJZ67XOIcNJraSEOZpxMJJvfTH2DvpsZ1+dCUUXPoSyslInHR4D3m42MS3gJIVYQ\n", + "4rA9HbNoyxFmHFl8PcdU6sNKk9FzmA1scec3wC8JD+8syjsHc4DfUG3OIWu4RxtWyjyHI4nrt9ns\n", + "wNOJcTzN2pRnEOXt3fIcphKew2hmHtibuJfuoMtJ6dQxemY399mEvYnOhjyHAaP0Qk431D7Uxi/c\n", + "Rk0cimElCPF4GnAwsRLd3xPlhjfQ3HP4IOE1fA1YYMYz0usnAU8HFiaB2JG46TJGPIdU5mrUciA3\n", + "E1OWvzglp48gkuIQDcuFlIgDIVBvL3k9Yxr1YaV8zmG3ZMufVpgQ7wZZrxt3bnPndJqHFecSZcxd\n", + "9xzMRn6PsskM25F9h0wcHiDEoVlYyaDp4jtLgGvpXqM2lrDSXOK73Ev38w5LiQGiVTMDicNA0qyX\n", + "Mwt42J0n0vN8UrpMHG4hxOMw4FZ3fgYc7s7DlIhD6tkvAX7ozpPAv8HIvPxZhdiC9LkHsoF7iXzO\n", + "IQsp5d8/nxg090JCqLIpQDJxmJNroDIWAgeVnIeMaYTHsnuq5CkLK72TELZ+ZT5JHHI0C4HMIcYf\n", + "dFUczFgEXJmeTgOeYOwJ6dmEuG0hSnOLI+Qzz6Qh75A6HQcQMwh0M6yUeQ6dlrNmeb21dF8cZjAx\n", + "EyxmnoPCSgNGnTiY8SIzXkMtNp1R9BwepZ4s7HRo2hZ3bknvlXkOLwCudh8Rmc8DLzTjRUQs/Iek\n", + "kbDQMHAvH1Yqe/+7ROnty4GvAPunhmMBEZ++BDi58JmFhNczghkfNOPDuWVRszUs9qY8rDQTJsSN\n", + "HysLiHOXp1nnYC4hDt0OKy0CZifPdDoRqhtrQhqi47Cd+B2mFbbds/CY52iiQ7OO7oaVspzDaDyH\n", + "+xil52DGdDOua7PZTFovF9wtRjyHqifHlDhMLCNhhTQu4YvA+6jPN0B7zyELK42IQ44NNIrDCcBl\n", + "2RN3HiJ63t8mkqQ3kPMcCp/NJ6TnUBAHd7YQIzJfnvYH0QBl8epfAr9T2Oe+wKJCJdNr0neaSm0u\n", + "qSyEkR8hPVnEocxzaBYCmUOMBZrW5Sqa/Yh7fBqNoboRUt7pvJLPZ57DRuC31Eb2l83xNZ3w7sqS\n", + "0tnsxCM5t9Qxevoov0+eseQcxhpWWgAsafbbpEZ6BrB4AmYz3pu4J5+gUaC7isRhYtkEzEwX0PuB\n", + "nxEx+mdSLw6riXDM7pQnpO8iGp+n0ygOZZ5DnTgAuPNdoqf/BaIBaOY53AfMSzaXvQ/wn8QNdyvh\n", + "LRxILYdyI9SSz0kQsv3sl147OG2zgNpND9GYZp7Dw6ScQ5qZdlfgqLGUyprxdbPKQ1JZCCPPVmDn\n", + "kpl1sx7tRmrTk3SDrOJtJrVQ3ZSSc3YQ8DqzWq8/hSJ3IJLqTxHXVdZxaCYOayj3HJ5H5BvyOZc3\n", + "E4Ngx0o+59BpWCkTh9GGlWYXHstseZxIuO9jsZxqVVMTzSA6TQ9Qcd5B4jCBpMqVJ4jpzN8J/CVw\n", + "KfAmcg1JuhnvIkbVNngOybW/i6gdv7VwmDpxMGNfosFZXtgOd/7Mne9RmzG3wXNIoahtRCPdShxe\n", + "kHr79xBltVkI4ibgiFwVy7x0jFuohZZeRkwbMp9aCAniJphBY1hpZtrHGkpc+SZTn+d5erKxSmYQ\n", + "nYER0vkpi5HPIeL699PdvEMmDjOo9ey30NiAH5geD8i9lpVWZ/ml+6l5DmVJ6enEdVS3bzMOIzon\n", + "36C+Wm8/CjF6Mz5mxv/q5IsxtrBSJthlM0Rnxy+7dtoNUpyZ7LiZuB7fSqzvUgV7E4K4kYrzDhKH\n", + "iWcT8D3gf7uzhlgp7GDqPQeIeZZOpjysBNG4bqExDFT0HH4PuDwJTjOynlSzxj8LLZW+785T7tyZ\n", + "nt4NPJc0yWIKYW0m4t8QDdYaopwwLw5nEeKQ3fRQa4T2pFEcNhG90brQkhlzgduajRJPHtAB1Epu\n", + "qyKzsUhdaCmFKqanbdczhryDGTuYcYoZf114ayHRm80E9mHKG/YDC49Q62Vn3E/tt6/zHFKeaApx\n", + "HRXDSn8PfMqdB4kGLROH/WlM4B5O5zPYdhxWMuM9ZuxD7TutI7zh4vT5byQ6bkWy+6mZVzeD+F1X\n", + "Ed/hzTSGUruFPIcB5j7gPHfOTc9/QNzARXH4AvAOUgy+ZD+3ArcVKoegURyOJ3rlrcjCSmU5h8zm\n", + "TBzWt9lXnTgkVlI//uFeQhwOsljH4nCismnndJx8WOklRNhjRaq0+i1xk5eKA+Ft7Ur5TQ7R+9sN\n", + "Wo6zaEvqZbYKHWQNRpFiY7YP4WX9lrF7Dt8m1g/5cCFktR8Rdsx7X2UhoQOJcRYNnkPu+buA/07/\n", + "FwUma6gfgrrQ1LOJ6++z6aWNRFh1D0JEDiycw5l04AUkgd+DuC/ygpO9v4vZyOp1AH8N/BkpfJc8\n", + "+AfJNfbJjn2hobIO2nsO2W99M/CKbD8tZg8YE2l/OxCdRXkOA8jJRL4BAHceIKqF6nIH7lxL3Jy7\n", + "EmGdIlcTYwyKbCFKQLMpMo4nchutuJ+40ObR3HPYn+aeRZ570rb5ZGw+75B5Dr8mPIc3At9KZbxr\n", + "iZ5j3nM4FXhL6nlCeA8LaC4OmTdyfBP7DiRCbPuN9eZNobozaD2QqpnnUAwrZSElqM1hNBpbphBh\n", + "m+MJwc2H2RYSVVD5sFIzz+HnNHoOI+Lgzh25areiwOxJXHcjCWmLxWi+CbwzN/38FkJIDiQ6Eeuo\n", + "L2nuSBwIL2Vb8obLGsmjgXNT7H9msultxO+VeUP3FI49n5huf1HJ8WYT4tnMc8h+61VESfd/EPdz\n", + "t6uX9gYeTB3CBlHsNhKHCcadzamXmH/tpDQtRpGzgMeL26fPfNu9cU76/IVjMcf+Qtqsu5ByA5uI\n", + "3n2Z5/B14B+Im66dOGSLqHTiORwK/CnwpfTeOqJEN/MclgOfcOf7uX1tS/vIxGFx+p4ZBxGLSD2v\n", + "iX0HEl4InNAgAAAUlUlEQVTX7Yz95s3yFfNbbNPMcyhWLOXDN9kcRqPhd4GVqeG+njSHUUoo70yc\n", + "5ywhnXkOZeLwI+rFoSyhnlEcJV2Wz/gqsT7FhdlG6TreTFQv3UMtDJPRqTjkixa20jjZ5Czi/M8h\n", + "rrHriTDsNGqCfTnwh7nPZB7DopLjzU62duI5AJxHdIi6HbrMX1MPEGXK7zbjTV0+DiBx6HfOBz46\n", + "hs9loaXnEGszPNnBZ9bSxHNIjfPriOulWJ5ZpJk4lHkOTyMalWyd7bXptUfScb/tzocK+x/xHNI8\n", + "VD8g1grJOJi4OY9rEvY5kBisN56bN5ttttRzKLj/RYphpXF5DtR7hitgpDw0O8+Zp5KJQ13DnsvB\n", + "/JgWnkOBosDUiUMq034BNORASPY8g7hOysShk97wiDikzlAx/p79fyTR2bgN+Fdgfa6j9d/Uj95f\n", + "RDTui0qON5u4htuJw73AS91ZSXTIju7gu4yGLBkN0QF8ITGFzd+Z1a0B0xUkDn2MO79x51Nj+OgD\n", + "hAv8XNqHlDKyRr/Mc8CdS4F90iJArbgfeJJ6cVhF5Bd2Ia0ImEIN9wFfyuVNip5DGY9T8xwAzgXe\n", + "kHv/IGJU8FrKb84DiUqvvGCNlmcRPdFmYaUZwOaSfBC0DyuN1nPIi8P11MRhP0IcslLPrAEvNuxz\n", + "CdFYScTJ81VlzTyHZuKQhZX2B+5u0inZSIjDPURjfDiMLAW7B008B6tfMzkrY83vM/9+Jg5HkGYR\n", + "IHJa+cGYvwAOyE3Bsgj4KTH+pjhWYR+i6q5lWMkdTyXiUJ3nkIVXHyCS3n8J/AHw6VSM0TUkDoPJ\n", + "j4iFgV5MxJI7YS3wWC4+3EBZeKtkm6dgZN2J7LVthECcTDTsa9Jbfw4jiXkIcdiHWs6hjEwcsh7U\n", + "pcQNnY0oP5gIpVxBeWjpAMbhOaTpPJ5BrHfeLKw0k/KQEuTCSikU8lpqU1xkY0Q6tWVHYtbbbNXB\n", + "FcDTU+O2kGiAW3oO6Xh3prDU5tx3auU5FJcALoaVFtF8KdJNRFgp8xyy0N5MmqwJnTyRu3KD5vIV\n", + "bdDoOcxOto+IQ1qlcUW2QRKuS6kJxv7E+XuSxrBbp55Dnhtp4zmYcYIZ57TapkDec1gO/DPwH+7c\n", + "SghtV9cqlzgMIO58gqgQmUet4WnHWpp4DWM4/gnuDQ3L+4DPUbtxs7BRvgeYeS+txCGfc8hu8q8B\n", + "r0+5hx3SexcBf1FSt94yrGTGc9t8vaOIhm8VrT2HsmQ01IeVPkX09rO4/J3EzKZls+qebsYfFF4+\n", + "ggiVbICR4obHCK8hCytlYpQXh3zjd1A6bnb8TJyK1Up5bqF+SdO8OEyntThspLb+8yrgaclbmZle\n", + "27VkJPLLCa8iKzLI5xyyfRY9h2XUwkrFsUAZ36cWWspsvptcaCkJ7Sxaew5l4rCWGPDYKkx4HKMb\n", + "5T/iObhzjzt/lfNO76S+2mzcSBwGFHf+DZjt3rKhzbOW9snm8dhzOZEf2NAiB5LNRdQurFSsBDqX\n", + "yIkcCtyR3PvvEwL5EzPON+NnZiPluvcSveq6tZ3NmAX8zKzl/EPHEYK7jrF5DpuAGanM80TgHdkN\n", + "nh6vI9dgmLGjGZ8jFlf6v4V9PZ9Gz3AFkZTOi0OrsFImlhDhtgOTd7Q3NA0h3gtMzZ2nPamFldp5\n", + "Dtk+70lTr2wlhGhmeq9sipHXE9fOc9LzYlipWL49iwgRHZG+3x1NbLmEmGNsCikUluxelNtmL0Jw\n", + "11Kbp6pIQ2Va+i1HOiDpdyyOvVlMnO9Op9zIew5FRoTdjD8x4yUd7rMpEocBppMwUI5riBuwSv4S\n", + "RhYDKqMTz+Hx9DhyM7pzA3HTvJlcQ+DOp4EPEz3Em4BvEfmOp9LN+2vqyxmzsEWrHtix1HIaI55D\n", + "Kpv829TrbeU5ZI3fa4h8y8OF94vluacQPebDCFHJD656BWm97xwriCKGE6gXh5ZhpfR/1vvMxl6U\n", + "DpxM5y6/5show0pOLbS4mmiYswa2bs2TVDb8DGIFxEwc2oWVZiX7Hk/fozRUmvJn1xChpYWUi0M2\n", + "U/ET6ZhlU3U0q0y7gZp3eho0zF+1mPCIZqWBjL8yqwvXYcYf5gbrzW9yHEjCnv7/Y2i52mNHSBwE\n", + "AO6sdOdvKj7GljRdRzOyMEY7zwEaG99ziWlIfl045vlpwOF7iUbvztzb+VHaUFvKspU4PINowNcR\n", + "62Jkvb7fAf6G8F6aNRaZ3fsQ8wr9Z8n711AvDn8CfCaN8/gSUa+fNZpHE73fPJ9Lfx8gpsjO5qfK\n", + "GtSi53AYNUG9lRDIVsnojHxoaTr14xwW0dpzuC83Pf3d1ItDNlBuRzP+hJic8tuE6E1LgyY7CStt\n", + "JPIEzUJKGRcQua+H3HmcJuKQ/l9PeWip2e+dzzv8LrkwZqqkO4Q4jwekv2dBrTrPjIOIMVBvSOGp\n", + "l8FIwrtIPqx0NG3K1ztB4iD6hnRzPkhnnkPxZvx6eiwNIaSE62nEWhYZRc/hmHT8EXEw41Qzlpsx\n", + "NZWoHkI0OlmPP5sZ843p8RCaD4DL7J5FeDBltl5LmnohVdIcTzRgEBMlvjKFv04DLkyjffPfc507\n", + "57nzNXe25abYzgaNjXgOqYE6EkYStZcS060sonm+IeMWamWomefwOIw0equbfG4jEdLLKIpDlpP5\n", + "I8LruxT4cPJWfkl4D52ElTYS3mJxYsoi/0Wc46wE+26iautPU3nobGrh1g0UktKpc9As3JPPax1D\n", + "LWQH0cu/n7iWDiR+h6uA06y2/slriPDYx4G/A76Wptwp4860/6mEh9EslNYxVc0cKMRYWU3zXjdE\n", + "Qvrh1OiN4M56Mz4D/KrZB9Oo82tzL91B9OgyjiHmvToAwIyPEGWyTxFlwZuJypffpPcz7+E3RGP9\n", + "baJhnEGuWqtgwzYzHqPca4AQrCwp/Trgv7KkvTv3m/F5Itm6AzQOgmzCZhiZVmMTMXPoDoTXsC4L\n", + "bbmz0YwVRKPUznNYleyDJA7uuBlbiFBJs2lWfkS9cNxNNKBbicZ3BrUE+vfdOTO37c+J3vM86kOg\n", + "I2Gl9L2ysN6naNMBdmeDGT+l5h2sJnJBxyab/onWnsN0YqDqdhpZSQzS3Im4th6hNghzMVFhdBdx\n", + "vRkhBD8BPm7G64nf4XXAu4m8S6tKtnXpe/8OsKrDsU0tkecg+o0TqPVky3icJr1yd97nPjJKtRNG\n", + "PAeLOYkOJgZHZZ7DqUSp6flEj/oZ1M9uu5bopb042fwj2nsOEA3AN5t8BycELFvW9d8Lm3yUiF3v\n", + "SjQmnbAZRgRgE9HYHUltnYU8303fpxPPIR9Wyjyph4kxDmVjPHDncXduzL1U5jnMSvu+pfDxZYQ4\n", + "XEnMPZaRDyvtBWx1Z7s7d7tzV5vvARGGy8TmVsJDO5oYYf771IvDfIv1orOGumkIMRWD3E8MVnuc\n", + "6LhkeZqiOBxJeDr/SIT2ziME42qi0u/UkgrA/LF+S5zLU+hCSAkkDqLPcI/BRC02aSoOYyCfc1hM\n", + "9PZvIQZH7U7kD24gGqWlNDam64ik9NuBc9LnM8+hqffjzotbhAcgBrWdCLzOnV8WPuvu/BNwSLOE\n", + "cQmbqQ/V/YRo9JqJw460F4c7iPElO1OrVoLIPazu0C5oTEhnaz48jfBORnDnV8De7nyoUIWXDytl\n", + "IaWOcedC9xhv4M5j7rwjlQVfQJTRZuKwgZhT669gZGK/VsUHENfP64iS5XwSfzEhBpk4HEFMg/Iw\n", + "sfztC4gxDO7OeveRSQ9bcSfwUqgT3zEjcRCTjW6KwxqiPHF3wu1fQdysi4je261pAN8viZ7d82j0\n", + "HP6YuOHPpyYO7TyHdpwBHOnOj5ptMMpKtE1QVxX1Y6I32yAOKQ9yM23EIYXW1hDimvccRisOzXIO\n", + "ZZ5Ddtwim4my5J0Ygzi04ALCe8jE4XrCw/jf1IoGWpUtQzTUL6dRHI4gzvOdRCfkUJIYurOWuB4/\n", + "MUp7M6GR5yCGkm10SRxSz/tu4oZaAlyf4vuPEuWN16btthFVRIuJmzxjLRF6+kyqvrmXSE7mR3CP\n", + "xS5v4z2NlqLncDkxRqLMc4DofRaroMpYSYSgimGl1Z0aljyA3xCNZiYOhxKNcrvp4bN9PEVUYc2g\n", + "u+JwJSGA2SDD77lzGpH7yEqKOxGHKeTEISWNs0qlu4ky2rVem/U2m6DziZL9tSKrxOuKOCghLSYb\n", + "q+lup+YOohf4KiLUAtEDO5UYeJZxOTC/EM5YRzSGX4TozZtxJ9ErHLM4VMBmcovwuPOAGauJQZIN\n", + "DbB7eTK9hPcTIap51MThCjoflZ9xN9FT3kSI6+8A141SILPQUtfEISXYT6Kx8ucmIqQ2lRgUubLF\n", + "brKGejnR6TiMKLn+QXYtpcKGm7pg8l3EINOuDGaVOIhJhXt5Incc/JoYefx995Gb/C5CLPKVTedT\n", + "m/Qs48fAKwsD2W4HDkxluf3CRhrnC/oxtRDHmHDndjN+jwh/ZDPpfnIMu8rEIVv+cmdKQkptyNY3\n", + "6KbngHtjo+3OE2bcRBQovAIapjXJcwcxBufXxOC/3YgxKKfmtskmghwvvwT+pQv7ASQOQtxBVLjk\n", + "p5e+C9hOzj13ZxWNCdLNwGWF/d1OdUtEjpVzoGFho8/TfK6gjkk5ileOczd3k8qTzUZChqMVh8xz\n", + "aLaaYbe5hlgH/iH35ramktI3Zs/NuA14olBocBnUFx6MBXfWEaW3XUHiIIad7wBrUhIw4y6icqQs\n", + "+dmO2+mvkFK2jvdDhdfuoAsDpbrE3dTySA8SPexVzTcvJR9WGu1nx8K1RJnx347yc98iylNHcOfv\n", + "umVUN5E4iKHGnXuoH7ELkYxtV8rZjKupD0eJ9qymNsvuU2ZsZvSewxpiZbdd6WJYqQXZAlUXtNyq\n", + "gHvD5Il9i7l3syiiGszM3b3TmQuFEJMIM/YGnucekwiasZgY5dtx45RmPP0+MT7gePeRNS4qIZXN\n", + "/jlwZpcry7rKeNpOiYMQYiBI1UOfAd6fRoIPPRIHIYQQDYyn7dQgOCGEEA1UKg5mdqKZ3WJmt5vZ\n", + "B5ps89n0/gozW1KlPUIIITqjMnEwsx2BfyUmEFsMnG5mhxe2ORk42N0PAd5K/UyLoiLMbGmvbRgU\n", + "dC67i85n/1Cl53AscIe7r3b37cQUxcV1TU8hRg/i7lcCe5lZqwW5RXdY2msDBoilvTZgwFjaawNE\n", + "UKU4LIC6aYnvJbfmbott9q3QJiGEEB1QpTh0WgZVzKT3f/mUEEIMOFWOkF5LTEWbsZDwDFpts296\n", + "rQEzk2h0ETP7WK9tGBR0LruLzmd/UKU4XAMcYmaLiKmNTwNOL2xzEbEO7jfN7DjgIXcvmUJYYxyE\n", + "EGIiqUwc3P1JM3sX8ENi2cEvu/sqM3tbev9sd7/YzE42szuIuc7fVJU9QgghOmdSjJAWQggxsfT1\n", + "COlOBtGJ1pjZajO7wcyWm9lV6bUZZnaZmd1mZpea2V69trNfMbOvmNl6M7sx91rT82dmH0rX6y1m\n", + "9oe9sbo/aXIuzzCze9P1udzMTsq9p3PZAjNbaGaXm9lNZrbSzN6dXu/K9dm34tDJIDrREQ4sdfcl\n", + "7n5seu2DwGXufiixItgHe2Zd/3MOcQ3mKT1/ZraYyK0tTp/5vJn17T3WA8rOpQOfStfnEne/BHQu\n", + "O2Q78F53P4JYrvSdqY3syvXZzye7k0F0ojOKCf2RwYfp8aUTa87kwd2voHF50Gbn7yXAN9x9u7uv\n", + "JhbTORYBND2X0Hh9gs5lW9z9fne/Pv2/lVjkaAFduj77WRw6GUQn2uPAj8zsGjN7S3ptTq4qbD2g\n", + "Uemjo9n5m099ubau2c748zS32pdzIRCdy1GQqkKXAFfSpeuzn8VBmfLu8Fx3XwKcRLidz8u/6VGR\n", + "oHM9Rjo4fzq3rfkCcABwDLH63r+02FbnsgQzmwp8G3iPuz+Sf28812c/i0Mng+hEG9z9vvT4AHAh\n", + "4UauN7O5AGY2D9jQOwsnJc3OX8eDOkXg7hs8QazJnIU5dC47wMx2JoThq+7+nfRyV67PfhaHkUF0\n", + "ZrYLkUi5qMc2TSrMbIqZTUv/70GssXsjcR7fkDZ7A/Cd8j2IJjQ7fxcBrzazXczsAOAQ4Koe2Ddp\n", + "SI1XxsuI6xN0LttiZgZ8GbjZ3c/MvdWV67PKEdLjotkguh6bNdmYA1wY1xA7AV9z90vN7BrgfDN7\n", + "M7G4+6t6Z2J/Y2bfINYlnmVma4C/AT5Byflz95vN7HzgZuBJ4M9cA4lGKDmXHwOWmtkxRHjjLiAb\n", + "JKtz2Z7nAq8FbjCz5em1D9Gl61OD4IQQQjTQz2ElIYQQPULiIIQQogGJgxBCiAYkDkIIIRqQOAgh\n", + "hGhA4iCEEKIBiYMYKszs5+lxfzMrrkw43n1/uOxYQkxGNM5BDCVmthR4n7u/eBSf2cndn2zx/iPu\n", + "Pq0b9gnRa+Q5iKHCzLamfz8BPC8tMPMeM9vBzD5pZlelGULfmrZfamZXmNl3gZXpte+kWW5XZjPd\n", + "mtkngN3T/r6aP5YFnzSzGy0WXnpVbt/LzOxbZrbKzP5jYs+GEM3p2+kzhKiIzFX+APCXmeeQxOAh\n", + "dz/WzHYFfmZml6ZtlwBHuPvd6fmb3P1BM9sduMrMLnD3D5rZO9MMuMVjvRx4OnA0MBu42sz+J713\n", + "DLH4yn3Az83sue6ucJToOfIcxLBSXGDmD4HXpzlqfgXMAA5O712VEwaA95jZ9cAviVkuD2lzrOOB\n", + "r6fJRzcAPwV+lxCPq9x9XZrj5npg0Ti+kxBdQ56DEDXe5e6X5V9IuYlHC89/HzjO3beZ2eXAbm32\n", + "6zSKUeZV/Cb32lPonhR9gjwHMaw8AuSTxz8E/szMdgIws0PNbErJ56YDDyZheBqxdm/G9uzzBa4A\n", + "Tkt5jdnA84mpksuWxxSiL1AvRQwbWY99BfBUCg+dA3yWCOlcl+bJ30CsL1BcSesHwNvN7GbgViK0\n", + "lPFFYvrka939ddnn3P1CM3t2OqYDf+XuG9Ji8MVyQZUPir5ApaxCCCEaUFhJCCFEAxIHIYQQDUgc\n", + "hBBCNCBxEEII0YDEQQghRAMSByGEEA1IHIQQQjQgcRBCCNHA/webgPPorxOoYAAAAABJRU5ErkJg\n", + "gg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(arange(niter), train_loss)\n", + "xlabel('iteration')\n", + "ylabel('train loss')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It seems to have dropped quickly and coverged (except for stochasticity); hooray!\n", + "\n", + "Since we saved the results on the first test batch, we can watch how our prediction scores evolved. We'll plot time on the $x$ axis and each possible label on the $y$, with lightness indicating confidence." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAFZtJREFUeJztnVtsY8d5x//f4Z2H94skaiXvemUbsAsD9otbwA2ahyCw\n", + "USBpXxoYKFD0EvShN7QPddyHJo9pgAZF+1CgiB30hqRFCxfpQ1vbRQukD724sGOnaydZY8XVihJF\n", + "iXfykDwipw/kNzuHklbiRRRJzQ8Y8OgsdXYk/vXNN9988w0JIaDRjIJx1R3QLB5aNJqR0aLRjIwW\n", + "jWZktGg0I6NFoxmZsUVDRC8R0cdE9CMienWandLMNzROnIaIXAB+AOAzAHYB/A+AV4QQH023e5p5\n", + "ZFxL8wKAu0KIbSGEDeDbAD4/vW5p5hn3mN93A8CO8vUDAD+uvoGIdKh5wRFC0Gn3x7U0WhDXmHFF\n", + "swtgU/l6E31ro7kGjCuadwE8SUS3iMgL4AsAvjO9bmnmmbF8GiHEMRH9OoB/AeAC8LqeOV0fxppy\n", + "X+jB2hFeeKbtCGuuMVo0mpHRotGMjBaNZmS0aDQjo0WjGRktGs3IaNFoRkaLRjMyWjSakdGi0YzM\n", + "uElYAAAi2gZQBdAFYAshXphGpzTzzUSiQT8Z69NCiOI0OqNZDKYxPJ26EqpZXiYVjQDwDhG9S0Rf\n", + "nEaHNPPPpMPTi0KIPSJKA3ibiD4WQnx3Gh3TzC8TWRohxN7gtQDgTfS3tmiWnEl2WAaJKDy4NgF8\n", + "FsCH0+qYZn6ZZHhaBfAmEfFz/loI8dZUeqWZaxYyR9gwDBARiEheq/eY0342IQSEEOj1evJafR9f\n", + "D79eR87KEZ7UEZ45hmHA5/PB6/XC6/XC5/PB7/fD7/fL+71ez9FUAfR6PbTbbdk6nY58D7+/2+2i\n", + "2+3Ka42ThRSN1+tFKBSSLRKJyBYIBNDtdnF8fOz48NmidLtd1Go11Ot11Go1NBqNE++3bVs2LZqT\n", + "LJxoiAg+nw+hUAjxeBzxeBzpdBqpVAqpVAqRSASdTkd+6MfHxw6LY9s2isUiisUifD4f3G63QyS2\n", + "bYOIpMA0J1k40RiGAb/fj0gkgmQyidXVVWQyGaytrWFtbQ2xWAydTkc227YdQ5Vt2wiHwwgGg3I4\n", + "U9/f6XRgWZZsbvfV/IrUIVX1wYaH26vwuRZONC6XC6ZpIplMYmNjAxsbG9LKsKVhC8Ov6i/7+PgY\n", + "wWAQ8XgcKysrqFarDstk2zaazSYsy0Kz2USr1Zr5zzjsk7VaLViWJV/55+I2a+EspGhCoRBSqRQ2\n", + "Nzdx69YtxGIxxGIxRKNRmKZ5wpFVZ0m9Xg/xeBzNZhONRgOWZTkExqLhZlnWzH9G9rG41Wo1lMtl\n", + "2ZrNJtrttnyvFs05GIbhsDSPP/44QqEQTNNEKBSC3+8/MZ0eNucsDvUvlj8oVTQsqlnDfWMLeHh4\n", + "iHw+D4/Hg16vJ8MK3W4XnU5n5v1bSNH4fD6Ew2HpBPOU2+/3w+v1noi78C/5rFe2Sr1eD8fHxw4r\n", + "02w2Hc9Sv28aqP1jbNuW4YB2u41IJCIF0263Hf7ZNPtyURZONDxlzufzyGazMAwDgUBANq/XK4cn\n", + "FoPL5XI0t9sNt9strw3DgGEYcLlcMlDo9XpBRHC73Sd8DH4/t1E4zbFVA5SGYZwYLrvdLlqtFlqt\n", + "lhyWhBBot9taNBeBRVMoFLC9vQ3bthEMBmXj2RCb9263C6/XC4/HI199Pp+cOfG1eo+I4PV64Xa7\n", + "4ff7Hf5Ft9t1CO6is6vhAKMq7GFBs8VT36OK5vj4GO12G7VabWTRToOFFE29Xkc+n4dhGGg0GggG\n", + "gzBNE6Zpwuv1yl9wq9WCbduO4cvv9ztEFgwGZZBQCOH48PhaFWGn05HRaBbheZzmU6nN7XbD4/HI\n", + "V36vao3UCHar1UK9XkexWJxP0RDRGwB+GsCBEOLZwb0EgL8BcBPANoCfE0KUL7GfEhbN4eEhjo+P\n", + "Ua1WpWBYNOrsx7ZtBAKBU0XCjWM77GSy1fF4PPB4PNJJBh4KgIezi4pmuPH/xT4NWzW/339iDc22\n", + "bTQaDdTrdTQaDZTLZWlV53V4+iaAPwHwF8q9LwF4WwjxtUHh6S8N2qXDUV3LsmAYBrrdLprNJur1\n", + "Ovx+P9xuN9rttsOU8/oUi0H1gQKBAMLhMEKhkHzlD499JI6PcKxk+PvPY3g2xw4uW65oNCrjTMlk\n", + "Eh6Px7Egy8MVW5l2uy19nbkM7gkhvktEt4Zufw7ATw2u/xzAv2NGoun1euh0Omg2m/Ja9VdcLpdj\n", + "Ot3tdh2mn9+r+jfBYFBao+FXv9/vsFzNZhOmaTos13l/7cPRXFXU7XYbmUwGt27dgmEYCIfDICK4\n", + "XC4YhiG/7yzRXAXj+jSrQoj84DqPfm7NTGBLw3+xPPvhXzJbH3W9SZ3p8PtU53PYGWZRmKaJQCDg\n", + "GBoajYZjaDNN80KiUfujRnhbrRa2trZgGAZCoRAymYx0rvm57DgPi0ZdUpglEzvCQggxy/p6LBrb\n", + "tqfyPPYnuHk8HhkoZPHU63XHqng4HHYMaeehCkZdFmDhCCEQj8dx48YNdDod+Hw+EJGcjrNg2u22\n", + "jB91Op0rWUIAxhdNnojWhBD7RJQBcDDNTs0S1TFlc99ut6Uvoa5F8QfVbrfhcrkuvBI+PDzxB81T\n", + "fHUBlf0Znmp3Oh3UajVUKhUUi0UUCgWUSiXU63V0Op2FEs13APwCgD8YvP7D1Hp0BfR6PQAPBdRq\n", + "taRgWq2WdFjb7Ta63S7a7bacOnOw7VEMz5zUBDKObpumCb/fL0WjLm3w2tPR0REKhQKKxSLq9bqM\n", + "Ds+ai0y5v4W+05sioh0Avw/gqwD+loh+GYMp92V28rIZjomw49lqteByuRxBNp6xqBZnlP8HAEKh\n", + "kHTCI5GIw9K43W45NLGjzKJRLY1lWVK8s+Yis6dXzvinz0y5L1fGcF4Kx2TOYtJZi8fjQTQaRSAQ\n", + "QCwWQyQScVgaFm273Ua9Xke1WpWiOTw8RKVSkYHBubQ0mskZToAPh8NIpVLY2NjA5uYmNjc3kUql\n", + "YJomDMNAq9VCtVrF0dERjo6OkMvlcHR0hFqtJpdGeIZ4FWjRzAB1uu9yuRyieeKJJ5DJZJBOpxEK\n", + "hWAYBjqdDqrVKg4ODrC7u4tcLofDw0MpGrYwV7VTQotmBnCwjqf1nETGokkkEjKBTBVNoVDAzs6O\n", + "tDQ8Y+Kptk73XGJYNByRVi3N1taWdIy9Xq8UDa/k7+zsYG9vzyGaq05416KZARyL4SjyysoK4vG4\n", + "XGDlPB52gDkJSw0AztN2Gi2aGcD7tJLJJJLJJNLp9Kmi4ak8x4RarZZMbmcLMw87PrVoZgAH8FKp\n", + "FDKZDFZWVhCLxRAKhaRo1BgR5+6oa1RXuao9jC7UOAN4eEomk1hfXz8xPPECpbqafZalmQe0pbkE\n", + "htNBE4kE0uk01tfXsbm5idXVVcRiMZlw1Ww2UalUUK1WUalUcPfuXezs7KBQKKBer0vRXNUC5Ymf\n", + "76o7sIyo6RZ+vx+JRAIrKyvIZDLY3NxEMpmUEWEigmVZODw8xN7eHnK5HO7fv4+dnR0Zm+HF0nkZ\n", + "nrRoLgEWDaegDosmHA4jEAhIS8OiyWazuHv3LnK5HPb39x2W5iojwMOMmyP8FQC/AqAweNtrQoh/\n", + "vqxOLhqc72uaJqLRqBTN+vo6HnvsMRmP4ZROVTR37txBoVCQuylrtdq5a2Gz5iKO8DcBvDR0TwD4\n", + "uhDi+UHTglFg0fCGvmg0KlexOU+n3W7LJPFyuYxKpSJbvV6X24XnYTgaZtwcYUDXDz4Tj8eDQCAg\n", + "K1vwKjZbGDXtodVqnRAO58pwWuu8McmU+zeI6HtE9DoRxabWoyXA7XbLXQ6JRAKRSERuOeH0TU57\n", + "GBZMtVpFo9FAq9WaW0szrmj+FMDjAJ4DsAfgD6fWoyWARROJRORi5GmiUYcnFs4iiGas2ZMQQuYE\n", + "E9E3APzj1Hq0gAwXFPB6vQgGg9Kn4dkSR35brRYqlQry+Tzy+Tz29vZQKpXQbDYdaQ/zKBhgTEsz\n", + "SCZnfha6frBjcxuLhi1NJBKRG/lYNOVyWRYx2NvbQ7FYlHu55lkwwHg5wl8G8Gkieg79WdQ9AL96\n", + "qb2cc4bL0w6Lhi3NsGj29/cdouGikfNejnbcHOE3LqEvCw0Lx+VynTk8qaLh4SmbzeLo6EhWuLrK\n", + "jLyLoiPCU4CXC3hv9+rqKpLJpBSMz+eT23G73a7D+eUAHtfSm3fBAFo0U8Hn8yEajSIajSIWi8mc\n", + "X05/APor2JZlodvtOgJ5alxmXmdLw2jRTAHev7SysiJL1HKiVTgcdmyntSzrxBSbZ03ztlxwFlo0\n", + "U4BFk06nsbm56RANF0vi2Mtpywbq9lptaZYUtWCA2+1GKpXC2toaNjY2cPPmTayuriIajUpfhh3f\n", + "g4MD5PN57O/vy12S87R6fVG0aMbA4/FIx9fv98u0hxs3buCxxx5DPB5HJBKRh3s0m01HXGZ/fx/l\n", + "chmWZS2EZRlGi2YMPB6PnFKHw2Gk02mHpeFKWlx6rdlsolQqYX9/H/fv33dYGi2aawAROVaxuVx+\n", + "JpORogEe7g8fFk02m0WxWESlUtGiWWY4cMdRX66Yzgd5rK+vI5VKIRwOw+v1yqJLnP5wVlxmUWZL\n", + "w2jRXAAWy/BebD6bYWNjA4lEQtbfOz4+hmVZsuxaqVRyzJjmfRX7PLRoLoAqGN5Wm06n5bZarsoZ\n", + "DAZl6oNlWbJEiCoa1cospaUhok30S8GuoL84+WdCiD++yjrCVwFbGq7JFwqFpGiefPJJWZuPdxdw\n", + "QaRarSYPJFOFw/UC5301+yzOS42wAfy2EOLHAPwEgF8joqfxsI7wUwD+FTMqB3sVGIaBYDAoT315\n", + "4okncPPmTWQyGXm+lN/vl7kynJFXLBaRz+exs7ODfD4v82WGK48uIo+0NEKIfQD7g+s6EX0E4Aau\n", + "sI7wrFATq8LhMNbW1qTje/v2bayvryMej8ttKABknbxKpYLDw0Pkcjlsb29jb28P5XJZVvJcdC7s\n", + "0wySy58H8F+4wjrCs0AVDNf3XVtbw9bWFra2tuTRh4lEAn6/33FgarfblbVldnd3sb29jcPDQxSL\n", + "xYWdYg9zIdEQUQjA3wP4LSFEbejs65nWEZ41bGlWV1extbWFZ599Vq5o8y5J3szGvky1WnVYmlqt\n", + "Jhcsr4VoiMiDvmD+UgjBpV+Xpo7waagVzrkMPgfy0um0LG/P+5hs25b7sCuVCnK5HA4ODhxBPE59\n", + "WAYe6QhT36S8DuCOEOKPlH/iOsLAEtQRHsYwDFmylY/64SrmoVBICobLwVqWhVKphFwuh08++QQP\n", + "HjzAwcGBXF+66rMMps15luZFAD8P4AMiem9w7zUsWR1hFXV6zSe2qKIJh8OOk+mAvmiKxSJyuRzu\n", + "3buH3d1dHBwcSCvDDvIiz5hUzps9/QfOtkZLU0d4GA7ieb1eh2hYOOqyAnDS0hQKBbkf27KspREL\n", + "oyPCgGMzPi8TxONxxGIxJBIJrK+vI5FIwDRNuN3uE4e/7+/vy8YxmVqtJh3kZRIMoEUDwLlM4PV6\n", + "ZcUqzpG5ffs2VldXYZomgL5lUbfRZrNZ7O7uIp/PyyqcfKrdMnLtRTO8RBAIBJBIJHDjxg0Zl+Hc\n", + "X9M0IYSQwxHvkLx//76cMR0dHcnV7UXZXTAq1140AKRo2IdJJBLY2NjAU089hWeeecZxRibw0PHd\n", + "3d1FNpvF/fv3HZaGh6RFS+O8KNdeNLwjkkURi8Uc50mmUqkTJ+PycYjlclmeisK7CjhJfBktDKNF\n", + "Mzgdl8uCpNNppFIpuWeJj9PhYwwByMgvlwrhEmc8HC2zYAAtGgAn6/yyaEzTlEE8jhADD0XTaDTk\n", + "ZjdOqroOXHvRsKXhqlVra2uO3ZF8niTHZLiq+GmWRotmiVFPzOUttYlEAqurqzLfV82TUVETxvkc\n", + "g2WL+J7HtRMNn47Lzq1aspWTxJPJpCxBrznJtRQNb3ZTa8ik02kZzOOFSZ/Pd9XdnUvOW+XeJKJ/\n", + "I6L/I6LvE9FvDu5/hYgeENF7gzZcMnau4ZKtoVAI0WhUnoxy2nYUzUnOszScI/z+IBHrf4nobTys\n", + "I/z1S+/hlOHhSRVNJBKRp9aGQiGHzwM4T9NlX0Y9R/I6TLNVxs0RBha0jrA6PLFoQqEQAoGAPEZH\n", + "nV4DkALhbSfqARfqscvXRTgXLtSo5Aj/5+DWwtYR5pKtLBr1eGMWjTrNVs9g4qSqTqcjE6sWfXfB\n", + "qFxINIOh6e/QzxGuY4HrCKuWxjRNRCKRUy0Ni4aHJj4nWxXNdZtqM6PkCP8V5wgveh1h9SBSn88H\n", + "j8cDt9stxcIi6PV6cneB2tRzsnk1+6oOVr8KzttheWqOMBFlhBB7gy+Xqo4wO7sshE6n4yhGxBvg\n", + "+DymZrO5dDnA5zFOjvDvAXhlmesId7tdeSRgs9lEoVBANpvFvXv3cO/ePRwdHcmm1svTlgaPzBH+\n", + "p8vpznzAorEsC/V6HQcHB8hms/joo49w584deRgpny953abd1y4iDDhTG0qlkoz+ulwu2LaNZrMp\n", + "W61WQzabxc7ODnZ3d7G3t+eYfl+XRUqVaycarudbKpXkRrdGo4HDw0Ps7u4iHo87zmKyLAsPHjzA\n", + "gwcPUC6Xr+2MSYUu6wef1626XMlKTd9cW1uT602maTpWrzudDkqlEkqlEorFIsrlsiMus8x+jBDi\n", + "1ADutRMNT7d5w5tt244NcG632yEINbDHDXhY73eZrY0WjWZkzhLNJMcRaq4pWjSakbm04UmzvGhL\n", + "oxkZLRrNyFyqaIjoJSL6mIh+RESvTuF520T0wSDF9L/H+P43iChPRB8q9xJE9DYR/ZCI3holN+iM\n", + "542dCvuI9Nqx+nhp6bq8ZjLtBsAF4C6AWwA8AN4H8PSEz7wHIDHB938K/USyD5V7XwPwu4PrVwF8\n", + "dcLnfRnA74zZvzUAzw2uQwB+AODpcfv4iOeN3UchxKVamhcA3BVCbAshbADfBvD5KTx37DRTIcR3\n", + "AZSGbn8O/bK2GLz+zITPA8bsoxBiXwjx/uC6DkAtwTtyHx/xvLH7CFzu8HQDwI7y9QM87PC4CADv\n", + "ENG7RPTFCZ/FXEZ524lTYaddgnea6bqXKZrLmMu/KIR4HsDL6FdP/9Q0Hy76dnzSfk+cCjtcgnfS\n", + "Pk47XfcyRbMLYFP5ehN9azM2YpAtKIQoAHgT/SFwUvJEtAb0MxIxYXlbIcSBGADgG6P28VEleMfp\n", + "41npupP08TJF8y6AJ4noFhF5AXwB/VKyY0FEQSIKD65NAJ/FdNJMp1redvChMiOlwk67BO+j0nXH\n", + "7SOAy5s9DTz2l9H32O8CeG3CZz2O/gzsfQDfH+d5AL4FIAegg76/9YsAEgDeAfBDAG8BiE3wvF9C\n", + "/9SaDwB8b/Dhro7wvJ8E0Bv8jO8N2kvj9vGM5708SR+FEHoZQTM6OiKsGRktGs3IaNFoRkaLRjMy\n", + "WjSakdGi0YyMFo1mZLRoNCPz/yU19i71FpCwAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEj9JREFUeJzt3X2QXXV9x/HPJ5vdZBNCd0g2S4HY0BZakglPFQbwkWo7\n", + "1FG0rRUpVWo7djpqpVQdkZn2r3a0Mh2p47QzFuoDPrVFQZkWhFaKgJXwkCcSINCREhQICQ8SYzab\n", + "5Ns/7t2wbrLZ892T395z4P2ayXDPud/9nd/e3zlnv5xz7u/riBAAAABmbk6vOwAAANB2JFQAAAA1\n", + "kVABAADUREIFAABQEwkVAABATSRUAAAANc3t5cZtM2cDAABojYjwwdYXTahsnyfpSkl9kq6KiL+d\n", + "HHPRRRcd8HPr16/XySefPLmtQr3MacK8XZnPIvu5HY7Pee3atTr11FNrt1NCZvxKxe7Zs6dy7N69\n", + "eyvHzp2bO5z7+/sPWLdu3TqdcsopB6wfGBgo0o/M/jY6Olo5dteuXZVjs/GZ8cvE7tu3r3LsVJ/x\n", + "5s2bdeKJJx6wPjN+CxcurBw7ODhYOXb+/PmVYzP70Jw55W60ZPbPsbGxyrG7d+8+YN3dd9+tM844\n", + "o1a72fjM/plpN3Peyuz32b+/Jdq+4YYbpnyv2J5ou0/SZySdJ2mFpAttn1RqewAAAL1S8hmqMyU9\n", + "EhGPRsSYpK9JemvB7QEAAPREyYTqWElbJiw/3l03rZGRkSIdwuw4+uije90FzBDHXrstXry4113A\n", + "DB1zzDG97gJqKplQzfhhI07q7UZC1V6MXbuRULXXscdWut6ABiv5UPoPJS2bsLxMnatUP2P9+vX7\n", + "X4+MjJBMAQCARti2bZu2b99eKbZkQnWPpBNsL5f0I0kXSLpwctDkb/MBAAA0wZIlS7RkyZL9y5s3\n", + "b54ytlhCFRF7bH9A0rfVmTbh6oh4oNT2AAAAeqXoPFQRcaOkG0tuAwAAoNd6OlO6VH1StsyEXplJ\n", + "xbKaMLFnRra/mfjMpGmlJnrLxGY1YaxLTbwnlZsoM9OPTGxmksWSEwBmZPpRcvLipvSjqnnz5lWO\n", + "7evrS7Wd+f0y561Sk7iW/HvWhLEuabbzBmr5AQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANRE\n", + "QgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQEwkVAABATT2v5bdz585KcZl6TdnaTiXbLiFT\n", + "BypTXyrbdimZ+lJVa0HOpO1MbBP2oezYlaq5l9nn2vYZZ9ueO7fMKTZ7XGfiS9Wk2717d5HY7GeR\n", + "qdmWGevMuSgTm92HBgYGisRm+lHquM7WHixRy++RRx6Z8r2iV6hsL7N9q+2Ntu+3/cGS2wMAAOiF\n", + "0leoxiRdGhFrbR8h6V7bt0TEA4W3CwAAMGuKXqGKiCcjYm339Q5JD0g6puQ2AQAAZtusPZRue7mk\n", + "0yTdNVvbBAAAmA2zklB1b/ddK+mS7pUqAACAl4zi3/Kz3S/p65K+FBHXT35/06ZN+18PDw9reHi4\n", + "dJcAAACmtX37dj3zzDOVYosmVO58x/FqSZsi4sqDxaxYsaJkFwAAAGZk8eLFWrx48f7lnk2bIOlV\n", + "kv5A0rm213T/nVd4mwAAALOq6BWqiLhDzMYOAABe4kh2AAAAaup56ZmFCxdWistMIZ+JzcZnSiI0\n", + "QbY0S6YMQH9/f+XYUmULsmUZSpWHaEIfsv3NxJcq+1LqMy5ZmiUjU9pjcHCwcuyiRYtS/ci0Xapc\n", + "Tqbky09/+tMisVKuXE4mNrMvL1iwoHJsZh+ScuflTJ8z41eq1FGmBJYkjY6OVo6tOtY33njjlO9x\n", + "hQoAAKAmEioAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYS\n", + "KgAAgJp6XnqmatmATDmSbDmLTNuZshoZmfI3pUonZGX6nClbkFFyrJvQbqYsQ7YsUiY+04/MmGTK\n", + "nJQqiSLljpPM55YtlVFVdn/L9DlzrJbahzKx8+bNqxwr5fajzPk+sw9l9ovsPlTynF9CqbJWUrlz\n", + "0ZRtTPWG7d+VFJIOduRGRHyjygZs90m6R9LjEfGWGfUSAACgwQ6Vkr1FnYRqKpUSKkmXSNokKVfN\n", + "EwAAoCWmTKgi4g/rNm77OElvkvQ3kv6ibnsAAABNNO0NRttH277a9k3d5RW2/7hi+5+S9BFJ7bqp\n", + "CwAAkFDlia3PS7pZ0jHd5YclXTrdD9l+s6StEbFGB38OCwAA4CWhymPtSyLiX2xfJkkRMWa7ylcw\n", + "zpF0vu03SZov6UjbX4yId08M2rhx4/7Xw8PDWrp0afXeAwAAFPLcc8/p+eefrxRbJaHaYXvx+ILt\n", + "syRN23pEXC7p8u7PvE7ShycnU5K0cuXKSh0FAACYTUNDQxoaGtq/vGXLliljqyRUH5J0g6RftP09\n", + "ScOS3j6DflWftAgAAKBFpk2oIuJe26+V9CvqPAv1UESkZhqLiNsk3TazLgIAADTbtAmV7UFJ75P0\n", + "anWuMt1u+x8jYlfpzgEAALRBlVt+X5T0Y0mfVucK1e9LukbS7xXsFwAAQGtUSahWRsSKCcvfsb3p\n", + "cHWgak2qJtSNk5pRm6tU3bg2ytT8knL7Ual9LtNuphZVtq7h4OBg5dj+/v5U21WVqgW3a1fuAnqp\n", + "c8bAwEDl2Pnz51eOzY51Jr5UbdNMbMm6jRmZunhV69JK0s6dOyvHjo6OVo6V8jU9q8qcAzL7fal2\n", + "pdwxVbUm5B133DHle1WOsvtsnz2+0P2W372VtgwAAPAycKjiyBsmxNxpe4s6z1C9QtJDs9A3AACA\n", + "VpiuODIAAACmcajiyI9OXLa9VJ0ZzwEAADBBleLI59t+WNIP1JlL6lFJNxbuFwAAQGtUeSj9ryWd\n", + "LWlzRBwv6Q2S7iraKwAAgBapklCNRcQ2SXNs90XErZJeWbhfAAAArVFlso9nbS+SdLukL9veKmlH\n", + "2W4BAAC0R5UrVG+TtFPSpZJukvSI+AYgAADAflWKI49fjdor6fNFewMAANBCh5rYc4c6E3keTETE\n", + "kYejA5lyBKVkSoFkShGUKnOS6UNTlOpztt1MiZFMqZNMbKZ8UabdbPmUUmVtMvty5vfLlODIlojK\n", + "lKopNSYlxzozJqX2z4xMf7NKlnOqqtQxIuXGr1TJrFKyZdcy8YdjrA81D9URdRu3PSTpKkkr1UnO\n", + "/igivl+3XQAAgCYpXYHy7yX9R0S83fZcSQsLbw8AAGDWFUuobP+cpNdExMWSFBF7JD1fansAAAC9\n", + "UuYGccfxkp62/Tnb99n+J9sLCm4PAACgJ0omVHMlnS7pHyLidEk/kXRZwe0BAAD0RMlnqB6X9HhE\n", + "3N1dvlYHSag2bNiw//XSpUs1MjJSsEsAAADV7Nu3r/I3HIslVBHxpO0ttk+MiM2S3ihp4+S4VatW\n", + "leoCAADAjE2eTuFQ01iU/pbfn6lTrmZA0v9Kek/h7QEAAMy6oglVRKyTdEbJbQAAAPRayYfSAQAA\n", + "XhZK3/KbVtXSM02Y9l7KlcopVeIgE9vf3185Vsr9fgMDA0X6MW/evMqx8+fPrxwrletz5nPL7MuZ\n", + "sZ47N3c4Zz6LBQuqz3hyxBHViywMDQ1Vjl20aFHl2Ex/JWlwcLBybKacRanzVrYER6kSKpl+ZGIz\n", + "x1P2HFfqmMocT5nfLzvWGZn9s21larKq9vlQf5+4QgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIF\n", + "AABQEwkVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAAQE09Lz2zZ8+eSnH79u2r3GZ22vtMfCa2\n", + "VFmGUrFSubIMpconlBzrTKmFjMznlonNluDIyHwWVY/pbGzmHNCUkkSljpHsfp/57Eq1Ozo6WiR2\n", + "bGyscqwk7d69u3JsZv8stV9k9s1sfOZ8n9k/M+eLzPhlxq5kP6ZS9AqV7Y/Z3mh7g+2v2K5epA0A\n", + "AKAliiVUtpdLeq+k0yNilaQ+Se8stT0AAIBeKXnL78eSxiQtsL1X0gJJPyy4PQAAgJ4odoUqIp6R\n", + "9HeSHpP0I0nPRcR/ltoeAABAr5S85fdLkv5c0nJJx0g6wvZFpbYHAADQKyVv+b1S0vciYrsk2f6G\n", + "pHMkfXli0IYNG/a/Xrp0qUZGRgp2CQAAoJqnn35a27ZtqxRbMqF6UNJf2h6UtEvSGyWtnhy0atWq\n", + "gl0AAACYmeHhYQ0PD+9ffvDBB6eMLfkM1TpJX5R0j6T13dWfLbU9AACAXik6sWdEfFLSJ0tuAwAA\n", + "oNcoPQMAAFATCRUAAEBNPa/lV7U+UF9fX+U2M/WJMn1oY2y25ldGqX6U7HOpWoWl6nhl2s0cI9m2\n", + "M0rV3cx8btlafgsWLCjSdqY+2M6dOyvH7tixo3Jsth+ZMcnUjRsaGqocu3Dhwsqxmf1Cyh0npepu\n", + "Zs6d2b9npepuNkH2HFdirK+77rop3+MKFQAAQE0kVAAAADWRUAEAANREQgUAAFATCRUAAEBNJFQA\n", + "AAA1NTKheuqpp3rdBdTwxBNP9LoLmKHHHnus111ADYxfe23evLnXXUBNjUyotm7d2usuoIYnn3yy\n", + "113ADPEHud0Yv/YioWq/RiZUAAAAbUJCBQAAUJNLlvmYduN27zYOAACQFBEHrR3U04QKAADgpYBb\n", + "fgAAADWRUAEAANTUuITK9nm2H7T9sO2P9ro/mJrtf7b9lO0NE9YdZfsW25tt32x7qJd9xNRsL7N9\n", + "q+2Ntu+3/cHuesaw4WzPt32X7bW2N9n+eHc9Y9citvtsr7F9Q3eZ8WuxRiVUtvskfUbSeZJWSLrQ\n", + "9km97RUO4XPqjNVEl0m6JSJOlPRf3WU005ikSyNipaSzJL2/e7wxhg0XEbsknRsRp0o6WdK5tl8t\n", + "xq5tLpG0SdL4w8yMX4s1KqGSdKakRyLi0YgYk/Q1SW/tcZ8whYi4XdKzk1afL+kL3ddfkPS2We0U\n", + "KouIJyNibff1DkkPSDpWjGErRMTO7ssBSX3qHIuMXUvYPk7SmyRdJWn8W2OMX4s1LaE6VtKWCcuP\n", + "d9ehPUYiYrx20FOSRnrZGVRje7mk0yTdJcawFWzPsb1WnTG6NSI2irFrk09J+oikfRPWMX4t1rSE\n", + "ijkcXkKiMycHY9pwto+Q9HVJl0TECxPfYwybKyL2dW/5HSfptbbPnfQ+Y9dQtt8saWtErNGLV6d+\n", + "BuPXPk1LqH4oadmE5WXqXKVCezxl+2hJsv3zkijM2GC2+9VJpq6JiOu7qxnDFomI5yX9u6RfE2PX\n", + "FudIOt/2DyR9VdKv275GjF+rNS2hukfSCbaX2x6QdIGkb/W4T8j5lqSLu68vlnT9IWLRQ7Yt6WpJ\n", + "myLiyglvMYYNZ3vJ+DfAbA9K+g1Ja8TYtUJEXB4RyyLieEnvlPSdiHiXGL9Wa9xM6bZ/S9KV6jxk\n", + "eXVEfLzHXcIUbH9V0uskLVHnfv9fSfqmpH+V9ApJj0p6R0Q816s+Ymrdb4V9V9J6vXhr4WOSVosx\n", + "bDTbq9R5aHlO9981EXGF7aPE2LWK7ddJ+lBEnM/4tVvjEioAAIC2adotPwAAgNYhoQIAAKiJhAoA\n", + "AKAmEioAAICaSKgAAABqIqECAACoiYQKQM/ZvrP731+wfeFhbvvyg20LAA4n5qEC0Bi2X6/OJIdv\n", + "SfzM3IjYc4j3X4iIRYejfwAwFa5QAeg52zu6Lz8h6TW219i+xPYc21fYXm17ne0/6ca/3vbttr8p\n", + "6f7uuutt32P7ftvv7a77hKTBbnvXTNyWO66wvcH2etvvmND2f9v+N9sP2P7S7H4aANpobq87AAB6\n", + "sfTNRyV9ePwKVTeBei4izrQ9T9Idtm/uxp4maWVE/F93+T0R8Wy3tt1q29dGxGW23x8Rpx1kW78j\n", + "6RRJJ0salnS37e923ztV0gpJT0i60/arIoJbhQCmxBUqAE3iScu/KendttdI+r6koyT9cve91ROS\n", + "KUm6xPZaSf8jaZmkE6bZ1qslfSU6tkq6TdIZ6iRcqyPiR9F5JmKtpOU1ficALwNcoQLQdB+IiFsm\n", + "rug+a/WTSctvkHRWROyyfauk+dO0GzowgRu/ejU6Yd1eca4EMA2uUAFokhckTXyA/NuS3md7riTZ\n", + "PtH2goP83JGSnu0mU78q6awJ742N//wkt0u6oPuc1rCk10parQOTLACYFv/XBaAJxq8MrZO0t3vr\n", + "7nOSPq3O7bb7bFvSVkm/3Y2f+BXlmyT9qe1Nkh5S57bfuM9KWm/73oh41/jPRcR1ts/ubjMkfSQi\n", + "tto+aVLbOsgyAPwMpk0AAACoiVt+AAAANZFQAQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANRE\n", + "QgUAAFATCRUAAEBN/w/rm9is+RzYUQAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAGPlJREFUeJztXUlsbNlZ/v6a53myy37Pft1B6kiRkk1YJFGyiKKOkJKw\n", + "IYqEFAWEWDAJFjRhQWAXIhEhWCAg6SgMSkCgoICESAeBaBYMjbrTHUgP7nbZZbuq7JrnW9NhUfWf\n", + "Pve6bNfk91zl+0lHVa7yuz717lf//59/JCEETJiYB5YnvQET6weTNCbmhkkaE3PDJI2JuWGSxsTc\n", + "MEljYm4sTBoiepaIXieit4jouVVuysTdBi3ipyEiK4A3AHwcwCmA/wbwOSHEj1a7PRN3EYtKmg8C\n", + "OBBCZIQQfQDfBvDp1W3LxF2GbcF/lwaQVX4+AfDj6i8QkelqXnMIIWja64tKGpMQ9xiLkuYUwK7y\n", + "8y7G0sbEPcCipHkJwHuIaI+IHAA+C+C7q9uWibuMhWwaIcSAiH4RwD8BsAL4unlyuj9Y6Mg904VN\n", + "Q3jtsWpD2MQ9hkkaE3PDJI2JubGoc2+tYbVa5bJYLCDSq24ikq/zc3UZMRwOMRqN5ONoNIIQAkII\n", + "+bP6/rrj3pHGYrHA7XbD7XbD4/HA7XZLcgBjwthsNt1yOp1wuVxwOp1wOp2XrtnpdHSr3+/rlqZp\n", + "6Ha7cq17Xva9Iw0RweVyIRQKIRwOIxgM6iSLxWKR5HA4HHC5XPD5fPD5fPD7/fB6vZeuWavVUK1W\n", + "UavVUKvV0Ol00O125WO9Xkej0cBoNIKmaSZp1g1EBLfbjVAohGQyiXg8riOM1WqVEsjj8cDj8SAc\n", + "DiMSiSAcDiMcDl+65vn5Oc7Pz3FxcYHz83M0m03dstlsEEKg2+0+gU+8emw8aVjdWK1W2Gw2uFwu\n", + "RKNRJJNJpNNpbG1t6ewVJo3H44HX64XX60U0GkUkEkEsFkMkErn0N1hiBQIBeL1e1Ot1KV3q9Tos\n", + "FgsGgwFarRasVisASGmzjlJn40ljsVjg8/kQCAQQCAQQCoWQTqexvb2N7e1tJBIJnaRh9eRyueTy\n", + "+/3weDxSYhjhcDjg9/sxGAxARPD7/QgEAlLSEBF6vR6azSaq1Sp6vZ7OeF433AvS+P1+pFIpuba2\n", + "tpBMJrG1tYVYLCYNYSaOzWaD3W6Xy+Vywe12w263T/0bDocDPp8PFosFLpcLrVZLt1jKVCoVuFwu\n", + "AEC/38dgMJAnrXXCxpPGarXC5/MhkUhgf38fe3t7SCaTSCQSSCQSiEajAKA7PbHEISLd8fw6ScOE\n", + "CQQCaLfb6HQ6usdKpYJCoQCXy4XhcCiP4+uIpUhDRBkAdQBDAH0hxAdXsallwDea7Rifz4d4PI7t\n", + "7W08fPgQTz31FKLRKKLRKGKxGEKh0KVrsI+FCcLSoN/vo9fr6QjGy263S/K43W7dEbtUKiGfzyMU\n", + "CsHn80EIASLCaDRCr9d7rP8/q8CykkYA+JgQoryKzawCrI7YholEInjqqafw4MEDqY4CgYC0UaZh\n", + "OBzKNRgMJFl6vR76/b40mHk5HA65nE4nLBYL7Ha7JIfX60UoFEIkEkEikYDdbketVsNwOESn07mX\n", + "6mlqJPRJwWq1wu/3I5lMIpVKYXt7G7u7uzrSsHNvGmlYbahEabfbuqXaO3a7XZ6y2Ihmuwh41xAP\n", + "BoPy1AZAEsbojV4HrELSfJ+IhgD+WAjxpyvY01Jg0qRSKTx69Aj7+/vS+E2lUojFYroj+DQMh0Pp\n", + "ye10OqjVaqjX66jVamg0GtL5xw5APjU5HA65B7aN7Ha7jjSJRAL9fl86/e4jaT4khMgRURzAC0T0\n", + "uhDixVVsbB4YbQu/3494PI7d3V08evRI2i/RaBSBQEBnr7AKUtXRNCO2Wq3KR/U47nK5MBgMpJTh\n", + "UxT7h9iZyMf+cDiMer1+paRbByy1ayFEbvJ4QUTfwbi05bGSRo0V2e126YsJh8PS4A0EAvImCSEu\n", + "2SvsjOPFBiyHARqNhlzNZlNnwzgcDjx48EAayHw0Z0nGxFGP8izppgU/1wELk4aIPACsQogGEXkB\n", + "fALA76xsZ7PvQ3p6nU4n/H4/gsGgjjRGG2Y4HEp7pdPpoFAoIJfLIZfLoVAoQNM0uZg86lJvvt1u\n", + "R7/fBxHJkIPL5YLD4dBJGzaeVcKogdJ1wjKSJgngO5MPbQPwl0KI761kV3OAVZLT6YTX651KGr7B\n", + "qqRhwjSbTeTzebzzzjs4ODjA4eGhJJR6YlIf1bQKfnS73QiHw0ilUlL18d9T/T2qpFlHwgBLkEYI\n", + "cQjg/Svcy0LgG+JwOKTtwBFpPnarGA6H6Ha7aDabaDQaqFarODs7QyaTwVtvvYU33nhDqi1+ZHXG\n", + "bn9VYlitVmxtbaFWq6HVaqHX60m1pTrvVN+PalOtI9bTEjNAtRccDoe0KfibrN70Xq+Hi4sLGZEu\n", + "FArIZDI4OztDpVKBpmnSMOZHNakKAFwulwxqejweeSoLBoPwer1SPXFwko3rRqOBcrmMer2OdruN\n", + "fr+/luRZe9Ko9gKTRrUbWB2xaul0Ori4uMDx8TGOjo6QzWZRKBRwfn6OarWKbrd7KdNOlQ5EBKfT\n", + "KR2HrJKi0SiCwSA8Hg+cTqeOuP1+H51OB/V6HaVSCbVazSTNk4YxyGi0GdiGYbV0cXGBbDaLN998\n", + "E2+//bYujYEz64xqRL25TqcTwWAQ8XhcBkFVSWM8HV0ladYxhABsCGmMMBq67MntdDqoVqvI5/PI\n", + "ZrM4PDzEwcHBJaP3OrCkYV9QOp1GIpFAJBJBIBCAy+XSBTx5P5qmodVqoV6vo9VqSTVoSponACEE\n", + "er2eTHCyWq3wer2wWq3QNA35fF4XPGw0Gjg8PEQul0OtVpNE4cjzLHA4HDKelEgkEA6H4fV6ZcBy\n", + "XU9Fs2LtScPGbbvdlnaIxWJBr9dDtVpFOByWUoTDAoVCAYVCQZKGDeV5SRMOhyVpfD4fnE6nzju9\n", + "qVh70rCk4aTtTqcDTdNQq9WQz+fh9XplVcBgMECv19N5eHu9ngxSzkoaDlKGQiHE43GEQiGdpGFs\n", + "KnE2gjRMCmBsFHO8iE8xxlQH47oJarWC1WqF2+2G3+9HKBRCLBaTUW72Aqt5OMC7dVHGta5Ye9IY\n", + "oaY2ENGlG6b6bGaRLFzy4na7pX+Gj9gc03I6nfLEBOASOflkxks1hNcRG0caYHzT+BtvtVqvrHic\n", + "VR1xGmcoFEIoFLrkl2GHIqsm9YivaZo80vMyT093DEwM9uayXWH0uczqymdJEwwGkUgkZHKXMXpu\n", + "s9l0pNE0De12Wx6z1cU+mo2VNET0PICfAHAuhHjf5LUIgL8C8BBABsBPCSGqt7jPubCszaDmALMN\n", + "Ew6HkUwm8eDBA0kav98vy3rZ5mEbi31EXHXJ0qbZbELTtLlU5F3DLAkd3wDwrOG13wDwghDixwD8\n", + "8+TnjQBHzT0ejy5Fc2trCw8ePMDe3h5SqRTC4bAkDAAp3fr9PprNJkqlEs7OznB4eIjT01OUSiVZ\n", + "zmKMZa0bbiTNJBOvYnj5UwC+OXn+TQCfWfG+niiYNIFAQKZobm9vY2dnB3t7e9ja2kIoFILb7ZYq\n", + "iY1sLopTSXN2diZJY+wssY5Y1KZJCiEKk+cFjHNrNgKqpOH0zEQiga2tLezu7uLhw4fyJMUhAyYB\n", + "n5aMpCkUCiiXyzrSrCthgBUYwkIIsWn99YzqKZFIIJVKIZ1OY3d3V1fGy3aMGklvNBoolUrI5XI4\n", + "OjpCpVKRke1N6FGzKGkKRJQSQuSJaAvA+So39aRhs9l0SV2qL2Zamma/39eV4RaLRZRKJZmI3mw2\n", + "0e121/aIbcSimc3fBfD5yfPPA/i71WznyYNPTE6nEx6PRxb/M2mmxZY49lWtVmXLkXK5jHK5rCPN\n", + "TRH0dcEsR+5vAfgogBgRZQH8FoAvA/hrIvpZTI7ct7nJxw3ufjWNNNNiSyxpqtUqLi4udJJGDYpu\n", + "iqS5kTRCiM9d8dbHV7yXJwZVehhVE/eccblcsNvtl5yFQghomoZmsymL/Jk03B1r3W0YIzbOIzwv\n", + "LBYLvF4vfD4fvF4vAoEAdnZ2sLOzg3Q6jZ2dHcTjcQQCAdlvj9MsOOXi7OwMJycnyGazOD4+Ri6X\n", + "Q7VaRafTecKf7nZw70nDTYg4RMDHa7WfTSgUQjAY1JGm1WrJOBKT5ujoCJlMRqqmdSzunwX3njRc\n", + "oJ9MJmX/mng8LlcsFpNRbqfTKfN3WB1VKhXkcjmcnJzg+PgYmUwGzWYTrVZrY3rsGXHvSUNEOtI8\n", + "88wzusaMoVDoUs4v2zDlcllWZ56eniKbzSKTyehqw01JsyEwtn/lTp5cnakavmqYABgbwK1WC+Vy\n", + "WSao5/P5qR7fTSQMcA9Jo9ZJqZWZbAxzr2DVL2PMw2Epk8/ncXR0hEKhgGq1qvP4btqJScW9Iw0A\n", + "XXEdd/JU68D5NZY0akkux5bK5bIME1SrVUka1RdjSpoNglpcZ1RPgUBAV3jHpBFCyMR0VT0dHx+j\n", + "3W7L7hLr2OJ1Xtw70vBpibuPx2Ix2fHT7/frsvBYNTFReLHjrtFooNPpyNqpTVZJKu4tabhjOefI\n", + "JBIJ+P1+KV3U05LaOLpSqch67GazKQdocHLVfcC9JA03cnz06BGefvppJJNJnaQxpj2wpKlUKjg/\n", + "P5eShgOR69x9fBHcGOUmoueJqEBErymv/TYRnRDRy5NlTAe9s2APMJPmve99L/b39yVpuIHAdX6Z\n", + "YrEoScPFeaZ60uMbAP4QwJ8prwkAXxVCfPVWdrVCcCYeG7dsz3BogPNljP1kePV6PZRKJRQKBZye\n", + "niKTyciS3k2Y3bQIZolyv0hEe1PeWouaUzV9k0f2qFNTfD6frgkRVxNwv712u41isYhcLic9vqye\n", + "NjVMcBOWaS/5S0T0AyL6OhFd7hV/R8D9fbn2OhqNSknj9/ulpOEmRMC7/WTY+C0Wi8jn8zIomc/n\n", + "TdIsgD8CsI9xz70cgN9b2Y5WDCaNmvMbiUQQCoWkpFHVE/tjuAESJ1YxaTKZjEmaRf6REOJcTADg\n", + "axj3D74zUPv28lidSCSCVCqly4/hagJj+iaXorTbbdkUiUtsuZfNulcULIOFSDNJJmf8JIDXrvrd\n", + "x41psSWfz4doNCrLUBKJhAwXTCMNG8CsorgJtUqY+3JSmoZFcoS/BOBjRPR+jE9RhwB+/lZ3OSfU\n", + "vr089S0ajcrhGolEQkoalSw8TodrsdX2a6qU2fTY0k1YNEf4+VvYy8rAHl1VPUWjUaRSKezu7sr+\n", + "wty5ygi1Z1+r1dL5Yu6LA+86bJxHmCe8caOhSCSCZDIph5aqbVtVw5frsDVNk4bv6ekpjo+PpV9G\n", + "07Qn/fHuBDaWNOpQLm7ZypPdeOQOH7FZqrA6KhQKODs7QzabxdHRkfQA39fTkhEbRxqehMJzt9Pp\n", + "tI40fr9f16aenXncR6ZSqeikjJrza0qaMTaONDzcgkmzs7Mj1RN34VT7z6jH61qthmKxeEnSzNOf\n", + "7z5g40mTTqd1dUvGGUtCCLTbbZTLZZyenuLk5ASnp6coFotoNBrQNG0jmiuuEhtLGm53tr29LSUM\n", + "jwtUwaQpFos4OTnBwcEB8vm8rp/MOo9Dvg1sHGm4R54qaTidc9owdq4uKJVKyGazePvtt2WyFZOG\n", + "f++++mWM2DjSTFNP6jAvI0aj0SVJwy3xWTWZZNFj40hjHP13VU8ZFWq7WFZH6nXmhbGLqPF1da/G\n", + "x2l7NL7PSe88jGzezuiDwUA3cnFeL/fGkWYRGIm27AQ4lk6q8cxE5Ef+u4C+eG+aNFTfs1gssnKC\n", + "Uztmmbqrfg4+KdZqNVSrVWiaduWYomkwSQPoCGO323U3fBHSGFukTbsZqlRhMnC87Kr9sYoNBAKI\n", + "xWJybPQ0A98IdQ+1Wg2FQkEeAtRU1aUlDRHtYpzmmcA4OPknQog/uOt9hOcB37yrJM0isFgs0qdz\n", + "07dXJcxVA1HV92w2GwKBgJw1lU6nZTeL66Duo1gsAgA6nQ7K5bJsiTJrXO0mSdMH8KtCiFeIyAfg\n", + "f4joBQBfwLiP8FeI6DmM+wivZS9hbgCQSCSwv78vh3NwWcoiDj11PLPq52EJpKoaridXl1FFqZLG\n", + "ZrPJ8AhXUcwraZxOp2zD3263YbfbdTOxbvrM15JGCJEHkJ88bxLRjwCkMe4j/NHJr30TwL9iTUlj\n", + "sVgQDAaxs7MDIQT8fr9uassiUe1WqyVDD9xwWh2mygRgEng8HtlUyefzTSWNurh8mGc1zGLTAO8S\n", + "x263S2L3ej3Y7XbZVZ2/LNdhZptmklz+AQD/iQ3qI8ykEULA5/Nhe3tbZ88s4tRjA5MfeQ4CSzA+\n", + "1bENpQ7rCIVCl+waVYXyOETumaM2wJ4FQgg4HA6dRGVJxnXqN2Em0kxU098C+BUhREPVueveR5gN\n", + "S6/Xi1QqdamnzCJ2TalUQrFYlIu/0dxn2DgOOhKJyAZK8Xh8KmmMezb2Mr4J6udg9aSWE3N7/llc\n", + "DLNk7tkxJsyfCyG49eud7SPMUWt1YLs6RXeaKL/q9WX2AEBmDvLNMUoa3lcwGJRNlILBoLxxsxLW\n", + "OABNtZ+mqddKpYJGo6HLSLy4uEChUJgpkn/T6YkAfB3A/wkhfl95i/sI/y7uWB9h/ta0222Z6sBi\n", + "nMfs3Da4zkoIAZvNdq1Nw4NauSeO2j1UfWRMIxJ/SbhzhSpFeFSjilqthlwuh/PzcznymcdGd7vd\n", + "G0c/3/Q/+CEAPw3gVSJ6efLaF3GH+wirtde1Wg3lchmBQECWsjwO8IxLm80Gt9t9abqdUb04HA6Z\n", + "GMYOQP4ss6jKwWCAdrsth5DxOGleRmnTaDSk6lSHy08j2DTcdHr6d1xdsXAn+wgzadjrWalUdLVP\n", + "jwNceOd2uy85zVSPMHDZyGXSGH1F15GH50vV63UpOZrNplzG0xDP+ORmTOrgsqVJs44YjUZyPkE2\n", + "m4XNZpP/KSy+543VGI+8qqNtmrrjagiGmsTV7/flqeyq0xkP5+DfV22Uab/PRX28+LjPk+2MpNE0\n", + "TQ4s47a23DLlXpJmOByi0Wggn88DGH+rUqmUPALHYjEAl4OF10FtIMB+lXlsJJZ86k1k+2aaocrk\n", + "ZjWjHtmntcrvdru6pktcPcHORePfYMnEf4ftISb0Tdg40oxGIzQaDRCRTgyzyK7X67q29rOQhj21\n", + "LpdLGoyj0UjaLDeBc5B5L3xiYUPVCN4nLyYBd0o3SgOOWvP7KsGmNVtiSaZ6vudpzLRxpBkOh1Id\n", + "XVxcwO12y65VXGY7D2mISEoWj8cDj8eD0WgkbZZZwJ20yuUyzs/PL0kC47ebc5VLpRLK5bKs8rzK\n", + "sFVTO4z20LQY2lW/M6szc+NIo9YxAeMbxmOQiQiaps1NGvXI7na7Ua1WUS6XUSwWEQ6Hb7wGO/t4\n", + "QguThSWD8aayq4CXao91u90nnnq6caQxQgiBTqeDarUKItIZwrOqJ0524mMx57Hw400wDnNnHwqr\n", + "BSNYIqqlMzz+5y5kEW48aUajkSRKr9dDrVYDMJsBzL9nTE1Q7ZtZ0hLUCDL36OM1LWeHKz15qW3z\n", + "7wLotph7V+JRaq7MoumbRnVmPILfBGNqxFXOO4aaBDbNTnlcEEJM/WZtPGlMLI6rSLNM+zQT9xQm\n", + "aUzMjWtJQ0S7RPQvRPS/RPRDIvrlyetr20fYxPK41qYhohSAlJojDOAzGEe1G+KaPsKmTbP+uMqm\n", + "WTRHGFiTPsImVo+ZbRolR/g/Ji+tRR9hE6vHTKSZqKa/wThHuIk16iNsYvW40U8zyRH+BwD/aEj5\n", + "5Pf3APy9EOJ9htdNm2bNsZCf5qocYbrDfYRN3D5uOj19GMC/AXgV47JcAPhNAJ/DWDXJPsJKHRT/\n", + "W1PSrDnMMIKJuWGGEUysDCZpTMwNkzQm5oZJGhNzwySNiblhksbE3DBJY2Ju3JqfxsTmwpQ0JuaG\n", + "SRoTc+NWSUNEzxLR60T01qQL6LLXyxDRq5MU0/9a4N8/T0QFInpNeS1CRC8Q0ZtE9L15coOuuN7C\n", + "qbDXpNcutMdbS9e9rq53mQXACuAAwB4AO4BXADyz5DUPAUSW+PcfwTiR7DXlta8A+PXJ8+cAfHnJ\n", + "630JwK8tuL8UgPdPnvsAvAHgmUX3eM31Ft6jEOJWJc0HARwIITJCiD6AbwP49Aquu3CaqRDiRQAV\n", + "w8ufwritLSaPn1nyesCCexRC5IUQr0yeNwGoLXjn3uM111t4j8Dtqqc0gKzy8wne3fCiEAC+T0Qv\n", + "EdHPLXktxm20t106FVZJr11JC95VpuveJmlu4yz/ISHEBwB8EsAvENFHVnlxMZbjy+576VRYMrTg\n", + "XXaPq07XvU3SnALYVX7exVjaLAwhRG7yeAHgOxirwGVRmJTqcEbiUu1thRDnYgIAX5t3j3RNC95F\n", + "9qhc7y/4esvu8TZJ8xKA9xDRHhE5AHwW41ayC4GIPETknzz3AvgEVpNmyu1tgRW0t10mFfaq9NpF\n", + "93hr6brLnGZmsN4/ibHFfgDgi0teax/jE9grAH64yPUAfAvAGYAexvbWFwBEAHwfwJsAvgcgtMT1\n", + "fgbjqTWvAvjB5OYm57jehwGMJp/x5cl6dtE9XnG9Ty6zRyGEGUYwMT9Mj7CJuWGSxsTcMEljYm6Y\n", + "pDExN0zSmJgbJmlMzA2TNCbmhkkaE3Pj/wFJ7Hv45ZreFAAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEvZJREFUeJzt3X2QXXV9x/HPJ5vnJ4RKtWrILg+2AQxi1cEHDATLEEfR\n", + "tlSlrYjt2OmolVJ1QGbafyyj1elIHaedsVIVRC1FCzotCk0gRq1EMCGEBB86hAcppIE8bzbZLN/+\n", + "ce+GZbObPd89+e25F96vGYZ77v3u7/zu/f3uvd+cc+7v64gQAAAAJm9a0x0AAADodiRUAAAANZFQ\n", + "AQAA1ERCBQAAUBMJFQAAQE0kVAAAADVNb3LntlmzAQAAdI2I8Fj3F02obF8g6RpJPZK+GBF/Nzrm\n", + "6quvPuzvVq5cqfPOO290W5n9pvqZWYurE9btyjy/adNyByGz8WO57bbbdP7559dup5tk5sXQ0FDl\n", + "2IMHD1aOnTVrVuVYSZo9e/Zh9916661asWLFYffPmTOnSD8y821gYKBybH9/f+VYSdq7d2/l2AMH\n", + "DlSOHRwcrBybmRfjvcZ33nmnzjnnnMPunzdvXuW2jz322MqxxxxzTOXYhQsXVo7NzKHp03NfYz09\n", + "PZVjM/Nz//79tWKvu+46XXLJJYfdv2/fvsrtSp0xPzOxnfCdKlX/Xr300kvHfazYKT/bPZI+L+kC\n", + "SadKutj2klL7AwAAaErJa6heK+mXEbElIgYlfUPS2wvuDwAAoBElE6qXSnpkxPaj7fsm1NfXV6RD\n", + "mBonnXRS013AJJ188slNdwE19Pb2Nt0FTNIZZ5zRdBdQU8mEatInRk888cSj2Q9MMRKq7nXKKac0\n", + "3QXUQELVvUioul/Ji9J/JWnRiO1Fah2lepaVK1ceut3X10cyBQAAOsLmzZv1wAMPVIotmVDdLekU\n", + "272SHpP0LkkXjw4a/Ws+AACATrBkyRItWfLM7+luueWWcWOLJVQRcdD2hyR9T61lE66NiM2l9gcA\n", + "ANCUoutQRcStkm4tuQ8AAICmNbpSuiQ9/fTTjbdZamGxUouRZmIzC6w9H5Ra1C+zuGBm0cLM3MzO\n", + "+8zilzt27Kgcm1mMNNPnzGucXdw3I9P2WIunjiczN7PPL7OA47Zt24rEZt5PmYVkZ8yYUTk224/M\n", + "/Cw177Of4Znnl5lHmc+iUt9n2e/qzOucWRB1PNTyAwAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIA\n", + "AKiJhAoAAKAmEioAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmhqv5bd///5KcTNnzqzcZiY2\n", + "G5+pJ5apqZSRqU+Ure+WqUeVqTGV6Uep2opSZ9TnK1WnLNNfqdw8ytTmKvW6ZWKl3GfAvHnzivQj\n", + "Mzez75FSNT1L1cWr+r0wGSXrPFaVmW+ZepDZ+MxczrSb+SwqVV81q+p33xVXXDHuY0WPUNleZPsO\n", + "2/fb3mj7wyX3BwAA0ITSR6gGJV0eEettz5d0j+3bI2Jz4f0CAABMmaJHqCLi8YhY3769R9JmSS8p\n", + "uU8AAICpNmUXpdvulXSmpLumap8AAABTYUoSqvbpvpskXdY+UgUAAPCcUfxXfrZnSPqmpK9GxM2j\n", + "H1+9evWh24sXL1Zvb2/pLgEAAExo9erVz8pTjqRoQuXW71OvlbQpIq4ZK2bZsmUluwAAADApy5Yt\n", + "e1ae8olPfGLc2NKn/N4g6Y8lnWt7Xfu/CwrvEwAAYEoVPUIVET8Qq7EDAIDnOJIdAACAmhovPbNg\n", + "wYJKcZlSC9lyK/39/ZVjS5ZFKaFkmYVSZVwypQiy5VYyr0epMgf79u2rHHvgwIEifZByzy8zJpnY\n", + "jEw5kscff7xY25nPl8z8nDt3buXYhQsXVo6VypXAyZS0GRwcrBy7a9euyrE7d+6sHJvtR6YUV6ZM\n", + "VKnyRVKunFOmz6XKh2Ve48zYZeOPRnkmjlABAADUREIFAABQEwkVAABATSRUAAAANZFQAQAA1ERC\n", + "BQAAUBMJFQAAQE0kVAAAADWRUAEAANREQgUAAFBT46VnduzYUSmuVBkQKVeOJBObWao/E5tZIj9b\n", + "hifTdia2VOmg7PPL9CPz/DLlEzLtZsrU7Nmzp3Jstu1MCZzMeyRTmiVbZqiUgYGByrGZkjaZz7js\n", + "52GpEhylyoZk3qczZ86sHCuVm0eZz6LMvMjMNyn3Omf6kfkMKPXdULL029Eo0zbuzLL9+5JC0lh7\n", + "iYj4VpUd2O6RdLekRyPibZPqJQAAQAc7Uqr+NrUSqvFUSqgkXSZpk6RqVZABAAC6zLgJVURcWrdx\n", + "2y+T9BZJV0v6q7rtAQAAdKIJT8TbfrHta21/t719qu0/rdj+ZyV9TFLuQhcAAIAuUuXKxi9Luk3S\n", + "S9rbv5B0+UR/ZPutkrZGxDqNfR0WAADAc0KVnzu8MCL+1faVkhQRg7ar/LTj9ZIutP0WSbMlLbR9\n", + "XURcMjJozZo1h26fcMIJWrx4cfXeAwAAFDI0NFT5F5xVEqo9tn9teMP2WZJ2TvRHEXGVpKvaf7NM\n", + "0kdHJ1OSdPbZZ1fqKAAAwFTq6elRT0/Poe0jLRVSJaH6iKTvSDrR9o8kHS/pokn0q9wCEgAAAA2a\n", + "MKGKiHtsv0nSb6p1LdTPIqL6ymGtNlZLWj25LgIAAHS2CRMq23MkfUDSG9U6yrTG9j9FRG75VgAA\n", + "gOeoKqf8rpO0S9Ln1DpC9YeSrpf0BwX7BQAA0DWqJFSnRcSpI7ZX2d50tDowa9aso9XUIUejJs/R\n", + "UKpGYKYWVbbmV6l6YpnYkRcATiQ71pm2S9WPzLQ7e/bsyrEzZsxI9WPOnDmVY+fNm1c5NjM/M3XH\n", + "MnXj9u7dWzlWytUey8i8xgsWVC8mka1Hl3mfZOqlZdrNzPvM88uOXam6ok899VTl2O3bt1eO3b17\n", + "d+VYKVf7L/PaZT47M+OXyQGydRszbVd9r1500fiXkFeZ4T+1/brhjfav/O6ptGcAAIDngSMVR75v\n", + "RMwPbT+i1jVUJ0j62RT0DQAAoCtMVBwZAAAAEzhSceQtI7dt/7paK54DAABghCrFkS+0/QtJD6q1\n", + "ltQWSbcW7hcAAEDXqHJR+t9Kep2kn0dEn6TzJN1VtFcAAABdpEpCNRgR2yRNs90TEXdIenXhfgEA\n", + "AHSNKotFbLe9QNIaSTfY3ippT9luAQAAdI8qR6jeIalf0uWSvivpl+IXgAAAAIdUKY48fDRqSNKX\n", + "i/YGAACgCx1pYc89ai3kOZaIiIVHowOZ5ey7TabEQSY2U64jW5qlVDmZUmV4ss+vVFmNUmNdqlyH\n", + "lCtrkyk9kykPUWoOZT9XSpVQybS7b9++In2QcnMjU+InU5qlVPmp7GuRKdGUed2OP/74yrHHHnts\n", + "5dj9+/dXjpVy8+jAgQOVY0vNi1Kfh9n4o1Fq7EjrUM2v27jtF0j6oqTT1ErO/iQifly3XQAAgE6S\n", + "+ydt3j9I+s+IuMj2dEnV/5kLAADQJYolVLaPkXR2RLxXkiLioKSdpfYHAADQlPonDcfXJ+n/bH/J\n", + "9k9t/7PtuQX3BwAA0IiSCdV0Sa+S9I8R8SpJeyVdWXB/AAAAjSh5DdWjkh6NiJ+0t2/SGAnVqlWr\n", + "Dt3u6+tTX19fwS4BAABUs3HjRm3cuLFSbLGEKiIet/2I7ZdHxM8lvVnS/aPjli9fXqoLAAAAk3b6\n", + "6afr9NNPP7R94403jhtb+ld+f6FWuZqZkv5H0vsK7w8AAGDKFU2oIuJeSa8puQ8AAICmlbwoHQAA\n", + "4Hmh9Cm/CVUtMTA0NFS5zcyy9yXbziypn+1zKZk+d2O7mbHOlGXIlHvYtWtX5di9e/dWju3v768c\n", + "K5UrO5GRKe1RqhRQ1sDAQOXY3bt3V47NzKFsOZLM+GVKW2Xazbz3siWlMkrNjVIlbUqWUSqlVJmh\n", + "7Gsx1aVnOEIFAABQEwkVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANRE\n", + "QgUAAFATCRUAAEBNjZeeqVqOIFOapWQZl8zy9JkSAKWWyM8up58piTBz5sxi/agqW0YiE58plZFp\n", + "N/O6zZ49u3JspvSFlJufpUr2lCpdMn/+/MqxkjR37tzKsZkxKfUeyX7GlSq3kulHqdI62dciW7an\n", + "qsycy8QuXLgw1Y9M/KxZsyrHZr4bMu/VzHhk5pCUK6NUtR8rVqwY97GiR6hsf9z2/bbvs/0129VH\n", + "DwAAoEsUS6hs90p6v6RXRcQrJPVIenep/QEAADSl5Cm/XZIGJc21PSRprqRfFdwfAABAI4odoYqI\n", + "pyT9vaSHJT0maUdE/Fep/QEAADSl5Cm/kyT9paReSS+RNN/2H5XaHwAAQFNKnvJ7taQfRcSTkmT7\n", + "W5JeL+mGkUGrVq06dLuvr099fX0FuwQAAFDNhg0btGHDhkqxJROqByT9te05kgYkvVnS2tFBy5cv\n", + "L9gFAACAyVm6dKmWLl16aPuGG24YN7bkNVT3SrpO0t2ShtO7L5TaHwAAQFOKLuwZEZ+W9OmS+wAA\n", + "AGgapWcAAABqIqECAACoqWtq+ZVUqj5fRqkac5m6alK5momZPmdiM7WapFyfO6H+WUa2v5l+DAwM\n", + "VI7t7++vHJupzZUZ6+z7NFOnLGPnzp2VY7dt21Y59sknn0z1Y8+ePZVjM2OdmXM9PT2VYzP1ErPz\n", + "PjM3SsWWVPLzs4TM65aZQ9n4bC3UsXCECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioA\n", + "AICaOjKhevDBB5vuAmp46KGHmu4CJumxxx5ruguoIbtMCjrHwYMHm+4CaurIhGrLli1NdwE1PPzw\n", + "w013AZNEQtXdOmFdIUxOJ6zJiHo6MqECAADoJiRUAAAANblUeY1KO7eb2zkAAEBSRIxZL6fRhAoA\n", + "AOC5gFN+AAAANZFQAQAA1NRxCZXtC2w/YPsXtq9ouj8Yn+1/sf2E7ftG3Hec7dtt/9z2bbZf0GQf\n", + "MT7bi2zfYft+2xttf7h9P2PY4WzPtn2X7fW2N9n+ZPt+xq6L2O6xvc72d9rbjF8X66iEynaPpM9L\n", + "ukDSqZIutr2k2V7hCL6k1liNdKWk2yPi5ZJWtrfRmQYlXR4Rp0k6S9IH2+83xrDDRcSApHMj4pWS\n", + "lko61/Ybxdh1m8skbZI0fDEz49fFOiqhkvRaSb+MiC0RMSjpG5Le3nCfMI6IWCNp+6i7L5T0lfbt\n", + "r0h6x5R2CpVFxOMRsb59e4+kzZJeKsawK0REf/vmTEk9ar0XGbsuYftlkt4i6YuShn81xvh1sU5L\n", + "qF4q6ZER24+270P3eFFEPNG+/YSkFzXZGVRju1fSmZLuEmPYFWxPs71erTG6IyLuF2PXTT4r6WOS\n", + "nh5xH+PXxTotoWINh+eQaK3JwZh2ONvzJX1T0mURsXvkY4xh54qIp9un/F4m6U22zx31OGPXoWy/\n", + "VdLWiFinZ45OPQvj1306LaH6laRFI7YXqXWUCt3jCdsvliTbvyFpa8P9wRHYnqFWMnV9RNzcvpsx\n", + "7CIRsVPSf0j6bTF23eL1ki60/aCkr0tabvt6MX5drdMSqrslnWK71/ZMSe+S9O2G+4Scb0t6b/v2\n", + "eyXdfIRYNMi2JV0raVNEXDPiIcaww9l+4fAvwGzPkfQ7ktaJsesKEXFVRCyKiD5J75a0KiLeI8av\n", + "q3XcSum2V0i6Rq2LLK+NiE823CWMw/bXJS2T9EK1zvf/jaRbJN0o6QRJWyS9MyJ2NNVHjK/9q7Dv\n", + "S9qgZ04tfFzSWjGGHc32K9S6aHla+7/rI+Izto8TY9dVbC+T9JGIuJDx624dl1ABAAB0m0475QcA\n", + "ANB1SKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAtA42z9s/3+x7YuPcttXjbUvADia\n", + "WIcKQMewfY5aixy+LfE30yPi4BEe3x0RC45G/wBgPByhAtA423vaNz8l6Wzb62xfZnua7c/YXmv7\n", + "Xtt/1o4/x/Ya27dI2ti+72bbd9veaPv97fs+JWlOu73rR+7LLZ+xfZ/tDbbfOaLtO23/m+3Ntr86\n", + "ta8GgG40vekOAICeKX1zhaSPDh+haidQOyLitbZnSfqB7dvasWdKOi0iHmpvvy8itrdr2621fVNE\n", + "XGn7gxFx5hj7+j1JZ0haKul4ST+x/f32Y6+UdKqk/5X0Q9tviAhOFQIYF0eoAHQSj9o+X9IlttdJ\n", + "+rGk4ySd3H5s7YhkSpIus71e0n9LWiTplAn29UZJX4uWrZJWS3qNWgnX2oh4LFrXRKyX1FvjOQF4\n", + "HuAIFYBO96GIuH3kHe1rrfaO2j5P0lkRMWD7DkmzJ2g3dHgCN3z0av+I+4bEZyWACXCECkAn2S1p\n", + "5AXk35P0AdvTJcn2y23PHePvFkra3k6mfkvSWSMeGxz++1HWSHpX+zqt4yW9SdJaHZ5kAcCE+FcX\n", + "gE4wfGToXklD7VN3X5L0ObVOt/3UtiVtlfS77fiRP1H+rqQ/t71J0s/UOu037AuSNti+JyLeM/x3\n", + "EfHvtl/X3mdI+lhEbLW9ZFTbGmMbAJ6FZRMAAABq4pQfAABATSRUAAAANZFQAQAA1ERCBQAAUBMJ\n", + "FQAAQE0kVAAAADWRUAEAANREQgUAAFDT/wNpIwQCSUJFIQAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEBVJREFUeJztnVuMJNdZx39f36d6+rI9O7PDrveSlQKysSX7xSA5EREK\n", + "0fqFwEsiS0hRgIgHboIHTHiJHyMkIsQLEoqNwkWJEMgoIAG2ERJBKIDROnYgjmPJK8/sXHd2unu6\n", + "p+99eOg+h+qanktX12Snqs5PKk13zXTpm93/fOec73zfd0QphcUyC4lHbYAlfFjRWGbGisYyM1Y0\n", + "lpmxorHMjBWNZWZ8i0ZE7ojIuyLyAxF5MUijLBcb8ROnEZEk8H3gk8B94L+AF5RS3wvWPMtFxK+n\n", + "eRZ4Xyl1TynVA74BfDo4sywXmZTPz10D1lzv14GfcP+AiNhQc8hRSsm0+349jRVEjPErmvvAddf7\n", + "64y8jSUG+BXNm8BHReSWiGSAzwLfDM4sy0XG15xGKdUXkV8D/glIAi/blVN88LXkPtOD7UQ49AQ9\n", + "EbbEGCsay8xY0VhmxorGMjNWNJaZsaKxzIwVjWVm/G5YWk5ARMwFkE6nzZVKpRgOhwwGA/r9PoPB\n", + "wLzXXy86VjTnQCKRIJlMkkwmSaVSlMtlKpWKuVqtFo1Gw1ytVmviGg6Hj/pXOBErmnMgkUgYz5LJ\n", + "ZFhZWeHWrVvcvHmTmzdvUqvV2N3dNdf+/j7VahWlFO12+1GbfypWNOeA9jDZbJZcLsfKygq3b9/m\n", + "qaee4sknn2RnZ4e1tTU+/PBDstks6XQapRSdTscMaReZuUQjIveAOjAAekqpZ4MwKuwkEgkymQy5\n", + "XA7HcahUKly9epXbt2/zxBNPUCqVEBE6nQ4HBwc0m03q9TqpVCr6omGUjPUJpdTDIIyJCslkknQ6\n", + "zcLCAouLiywsLJDJZEgmkwAMh0P6/T69Xo9Op0Ov16Pf7zMcDglDbX0QS+6L/6fxQyaZTJLJZE4U\n", + "zWAwoNfr0e126Xa7RjRhYF7RKOANEXlTRL4QhEFR4CyiOc7ThIF5h6fnlFKbIrIMvC4i7yqlvhWE\n", + "YWFGiyaXy02IJpFIoJQyXqbdbnN4eEir1aLX6zEYDKI/PCmlNsdfd4FXGZW2xB49EXZ7mnQ6TSKR\n", + "YDgc0ul0aDabVKtVHjx4QLVapdls0u12oy0aEXFEpDB+nQc+BbwTlGFhxj085fN5IxoRYTAY0O12\n", + "aTab1Go19vb2qNVqRjRhYJ7h6Qrw6niJmAL+Uin1WiBWhRzvnCaXyxnRuD1NrVbjwYMHNJtN+v0+\n", + "/X4/FJ7Gt2iUUh8ATwdoS2jRsRW93+QWTLlcxnEcUqmUCeC1Wi2azSYHBwfUarVQRIHd2IhwACQS\n", + "CVKplNlvKhaLVCoVVlZWuHr1KoVCgVQqRavVMtsGjUYjNHMYL1Y0AaCDeZlMhkwmQ6lUYmlpiStX\n", + "rnDt2jVEBKWU8TAPHz6k0WjQ6XQetem+sPk0AeBeYufzeUql0oSnKZVKJJNJ42m0aMLqaaxoAkB7\n", + "Gi2aQqHApUuXWFpaYmVlhcXFRUSEZrMZieHJiiYAdCqE3qDM5XJkMhkTmxkMBrRaLZMSsb+/H6q4\n", + "jBcrmgDQniabzeI4jokA68nxNNFoTxNGrGgCQHuabDbLwsICuVzO5MlME03YIsBerGgCQE+EHceh\n", + "UCjgOA7ZbNbkx/T7fVqtFvV6nb29PSsaC+RyOUqlEisrK9y4cYPl5WXy+TyJRMIE8w4PD01A7/Dw\n", + "kE6nQ7/ff9Sm+8KKJgCy2SzFYpGVlRUee+wxLl++PCEavZutE8kPDw/pdruh2dX2YoN7AZDNZimV\n", + "SiwvL3Pjxg2KxSKLi4skk8ljPY3OoQkjp3oaEXlFRLZF5B3XvYqIvC4i74nIayJSPl8zLx7u2qZc\n", + "LkexWGR5eZmrV69SqVRwHGfC02jh6JKVMHuaswxPfwrc8dz7XeB1pdSPAv88fh8b9F6TjgIvLCzg\n", + "OI4J7DmOM5F0pdM7dUGcvsIoGDiDaMaZePue2z8LfG38+mvAzwVs14XmONEsLi5SKBQmMvXcInFX\n", + "UiqlQisav3OaK0qp7fHrbUa5NbHBLRp3spX2NDphXCllcn+93iasgoEAJsJKKRW3/nq6GE4LxnEc\n", + "Mzzl83k6nc4RwXivMON3yb0tIqsAIvIjwE5wJl18UqmUSRovlUrk83lyuRyp1OhvUM9jdMWBu9A/\n", + "CvgVzTeBz41ffw7422DMufiIyIRoyuWySenUEWB3Vwi3aMI8JLk5y5L768C/Az8mImsi8nngy8DP\n", + "iMh7wE+P38cGr6dxiwame5qwT37dnDqnUUq9cMy3PhmwLaFBF/fn83nK5TL5fN7sNcHRYriwVVCe\n", + "ho0I+2BaiYq7grLT6VCv19nd3WV7e5udnR2TQB4FT2P3nnzg7gqhJ8Fe0dRqNdNSZHt7m2q1Grqq\n", + "g+OwovGBN71T1zVp0XS7XeNp1tbWIudp7PA0I3r1dNLw1G63jWjW19d58OCBFU3c0GmbqVSKdDpN\n", + "uVw2SeOrq6uUSiUymQyDwYBGo2GK4KrVKvv7+xwcHJgi/yhgRXMKIkIymSSbzZp2aLrSYHl5mdXV\n", + "VfL5/BHR1Ov1I6IJS9ntaVjRnAEdl9Gbkl5Pk0gkTHF/o9GgXq9PeBqdCmE9TYxwx2WKxeJETdPq\n", + "6qrJmdGX19P0er3Qp0O4saunM6A9TaFQoFwuUygUTEDP20Lk8PCQdrs9EdCLSiRYY0VzCiIy0XTx\n", + "0qVLFIvFIxUHw+GQbrdLq9U6IpqoCceK5gy4PY0WjTs+Yz2Nh2NyhF8SkXURuTu+vOmgkUJ7Gu/w\n", + "5N6kHAwGdDqdqaKJmnD85ggr4CtKqWfG1z8Gb9rFQC+5j+uhB9Dr9Tg8PDSdrXQxXK/Xi4xQ3PjN\n", + "EYYY9Q8+rcWrWzTestsoMs+c5tdF5Dsi8nLUS1i8u9reDcper2e6de7u7lKr1UxBXBTxK5o/Bj7C\n", + "qOfeJvAHgVl0ATlteNITYDs8nYBSakeNAb5KxPoH6/Oa3GUqOhpcKpVYWFiY6AbRaDSo1Wo8fPjQ\n", + "iEZXUUYRX6IZJ5Nrfp6I9Q/Wk1/dR08PS4VCgWKxSC6XM6LRVZP1ep39/X2zox3l4enUbYRxjvBP\n", + "AZdFZA34EvAJEXma0SrqA+BXztXKHzLTPI0Wje6fl0wmTQsR7Wm0aHSKZ1SHJ785wq+cgy0XAl2f\n", + "7fY0enjSonGfP9npdI4MT1HZYzoOu2E5hUwmw+LiotmgrFQqE1sHrVbLzGfa7TbNZpN2uz2xMRll\n", + "7DaCBxEhm82yuLhIpVLhypUrLC0tUSqVcBzHbBv0ej3T3Uo3KYpSbdNJWNF40G3qC4UCS0tLrK6u\n", + "srS0ZDxNOp0GmGiJ1mw2Q93ZalasaKZwkqfJZDLApGjcniYOWNFMwdvi1d2pUzOt7DbqcxmNFY0H\n", + "ETnSf0b3BNanrejJrj5uJ0yHlgaBFc0U3KLJZrNmn0lvG7i7W+ljBK1oYo7X06TTaVKp1FTRuIcm\n", + "K5qY4k7vdCdduROu+v0+7XabRqNBtVql0WjQbrft6inOpNNpHMcx5zZ5l9vu/Bl9BmWUNyi92Iiw\n", + "B+1pHMcx0WCdDqE9jRaNbluvl91xEc2JnkZErovIv4jI/4jId0XkN8b3I91HeJqn0Tk0gIkGa09T\n", + "r9cjVXZ7GqcNTz3gt5RSPw78JPCrIvI4Eesj7E2yyufz5ggefaLKtImwXnbbibALpdSWUuqt8esG\n", + "8D3gGhHqI6yHI90OTbeodx/2pRsA6DhN3DnznEZEbgHPAP9BxPoIu2u1S6WS6TquRaPza7SniTtn\n", + "Eo2ILAJ/A/ymUurA/RcX9j7C3m6duvGiWzTucxAsZ8vcSzMSzJ8rpXTr120RWVVKbYW9j/C01ZKu\n", + "oNSCUUqZeYtO8Ww2m+YonrAfkDErp62eBHgZ+F+l1B+6vhWpPsKZTMZ06tQ72nq15C651amd7h40\n", + "tVrNJGHFJbh3mqd5DvgF4G0RuTu+90VGfYP/SkR+CbgHfObcLDxndP6M4ziUy2UuX748kXAFGNHo\n", + "I3jcgqlWq3S7XVOGGwdOFI1S6t843htFoo+wFo0+hN0tGj08DYdDE5txexktnKiceXBWYhkRdk9o\n", + "dXtXLZpKpWKO35kWAa5WqxNDkq44iMNcRhNL0cBk1YHucqVFoyPAqVQKpZSpoNRlt97TbrVg4iKc\n", + "WIpGJ1q5RaNjNJcuXZrqaZrNpinw157GXQwXF8FAjEWjhTPN0+jewHoi3O12TYH/tFrtOAkGYioa\n", + "L1pAWkR6SBIRut0u1WqVvb09tre32dzcZG9vj0ajYQ4DixuxFI32Dvryns+klDKrJRFhZ2eHra0t\n", + "Njc3WV9fNzvbnU7nUf8qj4RYikbjFY1bOJp+v29OU9nY2OD+/fsmwBfVAv/TiK1o9LDijrG4S1L0\n", + "1el0jGg2Nze5f/8+vV7PXHEklqJxz0OGwyHNZpO9vT02NjZwHMcIRx/ytba2xtbWFvv7+zQajdgF\n", + "87zEUjQavRFZr9fZ2NggkUhwcHBghipdorK5ucnOzg4HBweR7NY5K7EVjf4PHwwG1Go1RIRms8nW\n", + "1taRw9f1lkGj0TClt3EVDICc9MuLyHXgz4AVRg2M/kQp9Uci8hLwy8Du+Ee/6G0LG5YcG50aoWub\n", + "3IeX6q/uOY7elIyDaJRSUxOIThPNKrCqlHprnIj134xSOz8DHCilvnLCZ6P/rxpxjhPNabvcW8DW\n", + "+HVDRHSOMMSoj7BlkjMnvbpyhL89vhWbPsKWSc4kmvHQ9NeMcoQbxKyPsGWSE+c0YHKE/x74B0/K\n", + "p/7+LeDvlFJPee7bOU3IOW5O4ytHOOp9hC0nc9rq6WPAvwJvM1pyA/we8AKjocn0EXbVQenPWk8T\n", + "cnwtuefBiib8+BqeLJZpWNFYZsaKxjIzVjSWmbGiscyMFY1lZqxoLDNzbnEaS3SxnsYyM1Y0lpk5\n", + "V9GIyB0ReVdEfiAiLwbwvHsi8raI3BWR//Tx+VdEZFtE3nHd893e9pjnvSQi62Mb74rInRmeF2gL\n", + "3hOe59tG4Gi1YVAXkATeB24BaeAt4PE5n/kBUJnj8x9nlEj2juve7wO/M379IvDlOZ/3JeC3fdq3\n", + "Cjw9fr0IfB943K+NJzzPt41KqXP1NM8C7yul7imlesA3gE8H8FzfaaZKqW8B+57bvtvbHvM88Gmj\n", + "CrgF7wnP820jnO/wdA1Yc71f5/8N9osC3hCRN0XkC3M+S3Me7W3nToUNugVvkOm65yma81jLP6eU\n", + "egZ4nlH39I8H+XA18uPz2j13Kqy3Be+8NgadrnueorkPXHe9v87I2/hGKbU5/roLvMpoCJyX7XGp\n", + "js5InKu9rVJqR40BvjqrjSe14PVjo+t5f6GfN6+N5ymaN4GPisgtEckAn2XUStYXIuKISGH8Og98\n", + "imDSTANtbztPKmzQLXjPLV13ntXMGWbvzzOasb/PqApznmd9hNEK7C3gu36eB3wd2AC6jOZbnwcq\n", + "wBvAe8BrQHmO5/0io4rUt4HvjP9zr8zwvI8Bw/HveHd83fFr4zHPe34eG5VSdhvBMjs2ImyZGSsa\n", + "y8xY0VhmxorGMjNWNJaZsaKxzIwVjWVmrGgsM/N/z4EQsKT2Kt0AAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEi1JREFUeJzt3X+wXGV9x/HPJze/bkKACSGbArE3bUPLzwhVBhBBqu1Q\n", + "RtC2VqRFqe3Y6ag1pcqIzLR/taOV6YiO085YKAr+aosWdVoQWilGrEQgufmFIXQM5UeTNDQJJCE3\n", + "N+HbP3ZvWC735p5vzn3u7ob3a4Zxz+73nufZ8zy7+XrO2efriBAAAACO3LROdwAAAKDXkVABAADU\n", + "REIFAABQEwkVAABATSRUAAAANZFQAQAA1DS9k43bZs0GAADQMyLCYz1fNKGyfZmkmyX1SbolIv5q\n", + "dMw111zzqr8bHBzUsmXLjrjd7NpaBw8erBz70ksvFYnN9CHz/jJ9yMaP1+dNmzZp6dKllWLHMjw8\n", + "XDk2+/4OHDhQpB/79+/veOxkeO6553TCCSe86vnp08t8VWTm8tDQUOXYF198MdWPffv2VY7NjElm\n", + "DmXmpj3m97kiYszXMuM3c+bMyrGzZs0qst9p08pdPCm19mLdf0f27NmjuXPnvur5zLyYjH6MJ3Pc\n", + "SsWWNN5narTDfbcUm7W2+yR9XtJlkk6XdLXt00q1BwAA0Ckl76E6T9ITEbE5IoYlfV3SOwq2BwAA\n", + "0BElE6qTJT3Vtv1067kJNRqNIh3C1Jg/f36nu4Aj1N/f3+kuAK9JM2bM6HQXUFPJhOqIL4wuWrRo\n", + "MvuBKTbWPTjoDXPmzOl0F1BD1ftA0H0y95ihO5W8Kf0ZSYvbthereZbqFQYHBw89bjQaJFMAAKAr\n", + "HDx4sPLN+yUTqoclLbU9IOlZSVdJunp0UJ1f8wEAAJTS19envr6+Q9uH+9VlsYQqIg7Y/rCk76q5\n", + "bMKtEfFYqfYAAAA6peg6VBFxt6S7S7YBAADQaR1dKV2SZs+eXSkuc7Nl9sbMTHxmwbn204QTySy8\n", + "VypWyvW5VGymz9lfxlSdb1LuF2+Z/Y61eN94Mu8vO9al5n2pz0jmGGfnRebYZfqcudE4E5vpg5Qb\n", + "61LHIjMmmc9IyXmfWfiy1IKvmdiSumGxzuxCzplFTqsuHLxkyZJxX6OWHwAAQE0kVAAAADWRUAEA\n", + "ANREQgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQEwkVAABATSRUAAAANZFQAQAA1NTxWn67\n", + "d++uFFeyfl02vqpMPaMDBw5Ujs3UMypZ+ygTm+lH5rhl31831B8sWbMto9RYZ3RDXbxsP2bNmlU5\n", + "ttR3S3beZ+rBlfpcZ77j9u7dWzk2OzczfS71GcnUu8zWpczM/VL1MUvVg8wcN6ncv8HjKXqGyvZi\n", + "2/fbXm97ne2PlGwPAACgE0qfoRqWdF1ErLZ9jKRHbN8XEY8VbhcAAGDKFD1DFRFbImJ16/FuSY9J\n", + "OqlkmwAAAFNtym5Ktz0g6RxJD01VmwAAAFNhShKq1uW+OyUtb52pAgAAOGoU/5Wf7RmSviHpyxFx\n", + "1+jX165de+jxwoUL1Wg0SncJAABgQps3b9aTTz5ZKbZoQmXbkm6VtCEibh4r5qyzzirZBQAAgCMy\n", + "MDCggYGBQ9srVqwYN7b0Jb83SbpG0qW2V7X+u6xwmwAAAFOq6BmqiPiBWI0dAAAc5Uh2AAAAaup4\n", + "6ZmqS99nlpDPliLIlGXIlnwoIXMsmrexlZEpA1CqvEC2NEvmeJQ6dpn5NhnlEMaTeX+lSvZkxjrz\n", + "2du1a1flWKlcaZbM+8uUAZk7d27l2Oy+M6V1MjLjlyldsm/fvlQ/Mt+fGZl5nxmPTKyUL89SVaky\n", + "Q5nx279/f+XY7L4z3wHj4QwVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEA\n", + "ANREQgUAAFATCRUAAEBNJFQAAAA1dbz0zN69eyvFlSwZkonvhmX9M7JleDIyS/Vnyj1kjkW2jESp\n", + "fpSKzZRayJbgGBoaqhybKSWRKRuSic2URMl+TjP9KFUOqNRxy+qG77hMGZf+/v5UPzKlXDLHOdPn\n", + "nTt3Vo7NfodnjnNm35nYUuXRSv7bPhmlxsadLbZ/S1JIGquViIhvVmnAdp+khyU9HRFXHFEvAQAA\n", + "utjh0u8r1EyoxlMpoZK0XNIGSfOqdgoAAKCXjJtQRcTv1d257VMkXS7pLyX9ad39AQAAdKMJL5bb\n", + "XmT7Vtv3tLZPt/0HFff/GUnXSypzgxAAAEAXqHL34Rcl3SvppNb2JknXTfRHtt8uaVtErNLY92EB\n", + "AAAcFar8hGFBRPyD7RskKSKGbVf5mcuFkq60fbmk2ZKOtX17RLyvPWjdunWHHi9cuFALFy6s3nsA\n", + "AIBCtm7dqm3btlWKrZJQ7bZ9wsiG7fMl7ZrojyLiRkk3tv7mEkkfG51MSdKZZ55ZqaMAAABTqdFo\n", + "qNFoHNpuPwk0WpWE6qOSviPp52z/UNKJkt51BP3KLRgEAADQIyZMqCLiEdsXS/pFNe+F2hgR1Vd0\n", + "bO7jAUkPHFkXAQAAutuECZXtfkkflHSRmmeZVtj+24jILcsMAABwlKpyye92Sc9L+pyaZ6h+R9Id\n", + "kn67YL8AAAB6RpWE6oyIOL1t+3u2N0xWB0rVjSqlVM29TB2ozDHLHt/JqGdUtx9TXX9pPJl6VKVq\n", + "Js6YMaNybMn6dZl+ZGTqD2bqGlatEXok+y5Vk67kWJesj1lVqZqp2c9epoZlZh7t2bOnyH6zNToz\n", + "c7lUzb1SdSmzNSwz9T9nzpyZ2vdYqszaR21fMLLR+pXfI7VbBgAAOEocrjjy2raYB20/peY9VK+T\n", + "tHEK+gYAANATJiqODAAAgAkcrjjy5vZt2wvVXPEcAAAAbaoUR77S9iZJP1VzLanNku4u3C8AAICe\n", + "UeWm9L+QdIGkxyNiiaS3SnqoaK8AAAB6SJWEajgitkuaZrsvIu6X9IbC/QIAAOgZVRZ12GF7nqQV\n", + "kr5ie5uk3WW7BQAA0DuqnKF6p6S9kq6TdI+kJ8QvAAEAAA6pUhx55GzUQUlfLNobAACAHnS4hT13\n", + "q7mQ51giIo6dlA5UXEq+VDkEqVxZhsx+Dxw4UKQPJY9bRqmSPVmZMhWlxrrUfMuW4cmUOsnEZvqR\n", + "GY/MZyQ730qV6yglO9aZUi4lj3NVpUpxZfddqnTQvHnzKsf29/dXjpWO7rmcLT2TGb/JKD1zuHWo\n", + "jqm7c9vHS7pF0hlqJme/HxE/qrtfAACAbpJL9/I+K+lfI+JdtqdLmlu4PQAAgClXLKGyfZykN0fE\n", + "tZIUEQck7SrVHgAAQKfkLj7nLJH0v7Zvs/2o7b+zPadgewAAAB1RMqGaLulcSX8TEedK2iPphoLt\n", + "AQAAdETJe6ielvR0RPy4tX2nxkioBgcHDz1uNBpatGhRwS4BAABUs337dm3fvr1SbLGEKiK22H7K\n", + "9qkR8bikt0laPzpu2bJlpboAAABwxBYsWKAFCxYc2t64ceO4saV/5ffHaparmSnpvyS9v3B7AAAA\n", + "U65oQhURg5LeWLINAACATit5UzoAAMBrQulLfhOqulx/qTIgUrlSGZll70vJlmXIHItSsaVKQ5SU\n", + "mRf79u2rHJspA5KJLSlTHiJTgmPWrFmVYzNlQKRcnzPfL0NDQ5VjS5WfksqVOyr1vZwtrVNKph+Z\n", + "OZeZbyWPRanxy/y7k3l/JcsMTcZx5gwVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAAQE0kVAAA\n", + "ADWRUAEAANREQgUAAFATCRUAAEBNJFQAAAA1dbz0zP79+yvFZcvJZGSW3y9VBiCzRH5m+f2SS/X3\n", + "YqmFzL5Lzbnjjz++cmzmGJcswzM8PFwkturnX8qV98nO+8z8zMQed9xxlWMz30PZMkOlSoxkxjpT\n", + "cikTm5kXJfdd6vswU3JJkmbOnFk5NtPnUiXaMnM5M3ZSbn5ORumuomeobH/C9nrba21/1XZuZgAA\n", + "APSAYgmV7QFJH5B0bkScJalP0ntKtQcAANApJS/5PS9pWNIc2wclzZH0TMH2AAAAOqLYGaqI+D9J\n", + "fy3pvyU9K2lnRPxbqfYAAAA6peQlv5+X9CeSBiSdJOkY279bqj0AAIBOKXnJ7w2SfhgRz0mS7W9K\n", + "ulDSV9qD1qxZc+hxo9FQo9Eo2CUAAIBqtm7dqm3btlWKLZlQ/UTSn9nul7RP0tskrRwddPbZZxfs\n", + "AgAAwJEZfaJn/fr148aWvIdqUNLtkh6WNHIa6gul2gMAAOiUogt7RsSnJX26ZBsAAACdRukZAACA\n", + "mkioAAAAaup4Lb+SNfqqytQoytYIq6pUra1snatStbkyfS51LErKzItS8y07NzPxmTpXmTmUmZ+Z\n", + "sc7USsvGZ45b5jOya9euyrEvvPBC5VhJGhoaqhybGb/MXM4c49mzZ1eOLTnvu6HGavb9lfqsZj5/\n", + "pb6Xs5/rUrVpx8MZKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioAAICaSKgAAABq6sqEauvWrZ3u\n", + "Ampg/HrXli1bOt0F1PD88893ugs4Qjt27Oh0F1BTVyZUVSs7ozuRUPUuEqreRkLVu0ioel9XJlQA\n", + "AAC9hIQKAACgJmfKfEx643bnGgcAAEiKiDFrLnU0oQIAADgacMkPAACgJhIqAACAmrouobJ9me2f\n", + "2N5k++Od7g/GZ/vvbW+1vbbtufm277P9uO17bR/fyT5ifLYX277f9nrb62x/pPU8Y9jlbM+2/ZDt\n", + "1bY32P5k63nGrofY7rO9yvZ3WtuMXw/rqoTKdp+kz0u6TNLpkq62fVpne4XDuE3NsWp3g6T7IuJU\n", + "Sf/e2kZ3GpZ0XUScIel8SR9qfd4Ywy4XEfskXRoRr5d0tqRLbV8kxq7XLJe0QdLIzcyMXw/rqoRK\n", + "0nmSnoiIzRExLOnrkt7R4T5hHBGxQtLo1eiulPSl1uMvSXrnlHYKlUXElohY3Xq8W9Jjkk4WY9gT\n", + "ImJv6+FMSX1qfhYZux5h+xRJl0u6RdLIr8YYvx7WbQnVyZKeatt+uvUcekcjIkaWSt8qqdHJzqAa\n", + "2wOSzpH0kBjDnmB7mu3Vao7R/RGxXoxdL/mMpOslvdT2HOPXw7otoWINh6NINNfkYEy7nO1jJH1D\n", + "0vKIeKH9Ncawe0XES61LfqdIutj2paNeZ+y6lO23S9oWEav08tmpV2D8ek+3JVTPSFrctr1YzbNU\n", + "6B1bbS+SJNs/I4nCjF3M9gw1k6k7IuKu1tOMYQ+JiF2S/kXSL4ux6xUXSrrS9k8lfU3Sr9i+Q4xf\n", + "T+u2hOphSUttD9ieKekqSd/ucJ+Q821J17YeXyvprsPEooNsW9KtkjZExM1tLzGGXc72gpFfgNnu\n", + "l/SrklaJsesJEXFjRCyOiCWS3iPpexHxXjF+Pa3rVkq3/euSblbzJstbI+KTHe4SxmH7a5IukbRA\n", + "zev9fy7pW5L+UdLrJG2W9O6I2NmpPmJ8rV+FfV/SGr18aeETklaKMexqts9S86blaa3/7oiIm2zP\n", + "F2PXU2xfIumjEXEl49fbui6hAgAA6DXddskPAACg55BQAQAA1ERCBQAAUBMJFQAAQE0kVAAAADWR\n", + "UAEAANREQgWg42w/2Prfn7V99STv+8ax2gKAycQ6VAC6hu23qLnI4RWJv5keEQcO8/oLETFvMvoH\n", + "AOPhDBWAjrO9u/XwU5LebHuV7eW2p9m+yfZK24O2/7AV/xbbK2x/S9K61nN32X7Y9jrbH2g99ylJ\n", + "/a393dHelptusr3W9hrb727b93/Y/ifbj9n+8tQeDQC9aHqnOwAAern0zcclfWzkDFUrgdoZEefZ\n", + "niXpB7bvbcWeI+mMiHiytf3+iNjRqm230vadEXGD7Q9FxDljtPWbkpZJOlvSiZJ+bPv7rddeL+l0\n", + "Sf8j6UHbb4oILhUCGBdnqAB0E4/a/jVJ77O9StKPJM2X9Aut11a2JVOStNz2akn/KWmxpKUTtHWR\n", + "pK9G0zZJD0h6o5oJ18qIeDaa90SsljRQ4z0BeA3gDBWAbvfhiLiv/YnWvVZ7Rm2/VdL5EbHP9v2S\n", + "Zk+w39CrE7iRs1dDbc8dFN+VACbAGSoA3eQFSe03kH9X0gdtT5ck26fanjPG3x0raUcrmfolSee3\n", + "vTY88vejrJB0Ves+rRMlXSxppV6dZAHAhPh/XQC6wciZoUFJB1uX7m6T9Dk1L7c9atuStkn6jVZ8\n", + "+0+U75H0R7Y3SNqo5mW/EV+QtMb2IxHx3pG/i4h/tn1Bq82QdH1EbLN92qh9a4xtAHgFlk0AAACo\n", + "iUt+AAAANZFQAQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANREQgUAAFATCRUAAEBN/w/tXPX4\n", + "8PPk+QAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAGlxJREFUeJztnVls49t93z+Hi7iJu0Rq44xm5l4bAVzAfnEfnKB5CIJr\n", + "FEjSlwYGChTpgj50Q/vQJH1o/JgGaFC0D0Xb2EE3JC1auEgKtLUNtIj70DYOfGNf9/pO7r3SSENR\n", + "JCVS3ClS5OmD+Ds+5FALN4nS/L/AwZ/L8Mwh/1/9zm8/SmuNAweTwHXfC3Dw8OCQxsHEcEjjYGI4\n", + "pHEwMRzSOJgYDmkcTIypSaOUek8p9SOl1J8opX55notysNxQ0/hplFJu4CPgZ4As8IfAV7TWH853\n", + "eQ6WEdNKmi8CH2ut97XWXeB3gZ+f37IcLDM8U35uGzi0nr8G/rT9D5RSjqv5gUNrrca9Pq2kcQjx\n", + "FmNa0mSBjPU8w6W0cfAWYFrSfBd4Vym1q5RaAX4R+L35LcvBMmMqnUZrfaGU+hvAfwfcwNccy+nt\n", + "wVQm960mdhThB495K8IO3mI4pHEwMRzSOJgYDmkcTAyHNA4mhkMaBxPDIY2DiTFtwPLRQ6kfuyjc\n", + "brcZHo8Hl8tlhtvtRmtNv99Ha43WmouLC3q9HhcXF1xcXJjXAR5DyZBDmjFQSpnhcrkIhUKsrq6a\n", + "q9/vJxAImKuQo9vtcnFxQbVaNaNSqdDr9ej1evT7fXq93n1/vZnhkGYMbMK43W5WV1dZW1szIxqN\n", + "Do3z83Pa7Tbn5+ecn5+Ty+XI5XIcHx/T6XTodDqGVA5pHimEMKOkyWQy7OzskEqlWF9fN6PZbNJo\n", + "NMw1Go3i9XrpdruUy2Uzb6/XQyn14LeomUijlNoHqkAP6GqtvziPRd03bCnj9XpZXV0lmUyyvb3N\n", + "8+fP2djYIJ1Os7GxQSqVotFo0Gg0qNfrNBoN+v0+zWaTcrnM6uqqIcrFxcV9f7W5YFZJo4Gf1lqX\n", + "5rGYZYBsTUKYlZUVQqEQsViMtbU1Njc3icfjrK6u4vV6gUtFeWVlhUAggFKKSCRCNBolHo+TSCRw\n", + "u90AXFxc0G63325JM8DYSOhDhi1lfD7fEGk2NjYIhUKEQiFWVlaAH5NGKYXH4yESiRCLxYjH4yST\n", + "SSNlWq3WPX+z+WAekubbSqke8M+11v9yDmu6d7hcLjweDx6PZ4g06+vrbG5u4vV68Xg8eL1etNa4\n", + "3W5DGJ/PZ0iTSCRIJpN0u13a7Ta1Wm3IlH+omJU0X9Ja55RS68C3lFI/0lp/Zx4Lu2vIzXS5XHi9\n", + "Xvx+P6urq0NSQ7abUYjSLPMEg0FjnofDYarVKj6fz2xTDx0zkUZrnRtci0qpb3BZ2vLgSCM3XaRF\n", + "NBo15nUqleLJkyckk0mCweB9L3UpMEuFZVApFR48DgE/C/xgXgu7S4i15PF4WFlZIRKJkE6n2d3d\n", + "5bOf/SyZTIa1tTUCgcCN87wNmEXSpIFvDH4oD/DvtNbfnMuq7hC2eS2kiUajbGxssLu7yzvvvMP6\n", + "+rojaSxMTRqt9R7w+Tmu5c5gb0di+cgIBoPGStrZ2WF3d5dwOGzCB9dBa/2GN1kUZjHffT6fiUfJ\n", + "Z0bHsuOt8wgrpfD7/UPxo2AwSDAYJBAIEA6Hef78Odvb26ytrREOhwkGg7dSZGV7sq2uaDRKu92m\n", + "2+3S7/dRStHpdExAs9fr0e12Tdyq2+0uPXHeOtK4XC78fv9Q7CgSiRAOhwmHw0SjUXZ2dgxpIpGI\n", + "kRK3tX7cbjd+v9+QxiaMx+Oh3W7T6XQ4Pz+n0+nQarVot9u0Wi263e6Cf4HZ8daRRiRNNBo1MSQx\n", + "p2VITEkkjWw1N5FGtqdRSWMTxufz0Wg0aLVatFotms3mg/MYv5WkCQQCxGIx0uk029vbJJNJMxKJ\n", + "hAkDRCKRqZRfj8eD3+8nHA5zfn4+5PsJhUJDcap6vW7CEeI1lhjVsuo4bx1pXC4XwWCQRCLBzs4O\n", + "z58/N9tTJBIxRJnGGSc6jdfrJRgMmq0mEAgQiUSGIuH2tVgscnx8jMfj4eLigvPz86FErmUjzltH\n", + "GvHYrq2tsbOzw4sXL4YSqvx+Pz6fD5/Ph8cz3c8jpAFYWVkxEkf0GNmW5BoOh3G73SY63mg0TG5O\n", + "r9dzSHPfkEy8ZDJpJI3EmcREttM7J4HoNEIar9dLKBQymXsiPYQ4ovyKGd5qtSiXy4YkvV6PTqez\n", + "iJ9hJrwVpLFzev1+P5FIhGQyycbGBpnMZceUWXJ4hSzy2O1243K5TBRcIP9GpIhk/ImEqdVqlMtl\n", + "4+tZ1sj4oyeN2+025nQ4HGZtbY3d3V3W19cJBoMmQcq+Tgo7sdxOMJdhk9Z2+glB4/E4Ozs79Pt9\n", + "/H4/2WyW168v2/3U6/WlSxF99KRxuVxEIhE2NjbY2Nhge3t7iDTAG8SZFFprkzg+bsj25/V6h+Jc\n", + "8jgejxvCJBIJVldX0VpTr9c5Pj6e908yMx49aUTSbG5u8uLFC54/f87Ozs5CJI3oLfJYrjKv6Ehi\n", + "govESSQSBAIBkskkmUwGr9drCLOM6RQ3kkYp9XXgzwIFrfWfGryWAP498BTYB/681vpsgeucCHLj\n", + "7Uy6dDrNs2fP+MxnPkMikTA3ahqMbj8SBpAhiq+tAPf7feDNNAyllEncEjSbTV6/fk0sFjPkWqbY\n", + "1G0kzW8D/xT419ZrvwJ8S2v9G4PG078yGPcOsV5kSxDfi9QtiQ9Git5GFeDb3JTRkhWxhGSIlSQj\n", + "EAiY+JbEuGT4/f43pJsksycSCTY3N/H5fEP/pxDwvnAjabTW31FK7Y68/HPAnxk8/lfA/2SJSOPx\n", + "eMwNiUajRgmWGyaksS0e+3oTzs/PqdVqVKtVarXakHe30WgMkebi4oJQKGQi5aurq8RiMWKxGAA+\n", + "n28saUKhkCGN2+2mWq0CLIUJPq1Ok9Za5weP81zm1iwFRNJIuqaEA0TSBAIBVlZW8Hq9M0maWq3G\n", + "yckJp6enVCoVU00pFZVSddnr9Yy3WdbSbrcBjPl/HWk2NjaMTtTpdJbCmppZEdZa62XpryfWiF12\n", + "kkgkiMViRCIRQ5rbShr7ua1TNJtNzs7OKBaL5HI5SqUS5XKZs7MzSqXSUAig1+sN5RnHYjG01kaP\n", + "6ff7byi7Xq+XcDhMMplka2vLzNVsNqlUKm+Y9XeNaUmTV0ptaK2PlVKbQGGei5oEdjWkOO+SySSb\n", + "m5vGxM5kMqRSKaLRKD6fzyiXkgw+CttcFq9st9s1JbavX78mm82aIduUbFm25WQPqUoIBoPEYjGa\n", + "zabZbkQ5drlc+Hw+otEo6XSaXq9nzHVZc61We8M5CHfXXGBa0vwe8BeBfzi4/ue5rWgKiN9D3PeJ\n", + "RILt7W2ePXvG06dPTapDJBK5NWnson47wFiv1zk8POT169fm2mw2h2JJNumk5qnT6dBut02saW1t\n", + "jUajQafTeSP1wufzEYvF6PV6ZiuV8IbL5aJUKpkGA7JGwV0Q5zYm9+9wqfSuKaUOgX8A/DrwH5RS\n", + "f5mByb3IRd6wvqFqSCHN1tYWL1684MWLF0MeYYley1/2KMTnIjda9JezszMzDg8POTg4MEMkkIxR\n", + "k1wkQqvVol6vk0gkODs7M5JGAqOjksbr9RKJRFhZWTEE11oby08IfdeR8NtYT1+54q2fmfNapoZd\n", + "SSCk2dzcZHd3l3fffdfk6MpfrO3HEdg3WdITRDKcnZ1xcnLCyckJxWLRkGV/f5+Dg4Mhb/A4JVXM\n", + "8kajgd/vJ5VKUalUqNfrnJ+fm3waIcbKygoej4dwOEy/3zfv2zpMr9ej0WiYP4C73KIehUfY7idj\n", + "u+ltolwnWUTEi95ydnZGuVw2yu3oNZ/PUyqVzFZ0k1IqZJJtpF6vUyqVyOfzHB4eEo/HjSS0Qw39\n", + "fh+Xy2WSxjY2Nsx36Ha71Ot1yuWykYzifV40cR4FaQRXVQLI86tCBKKgik6Sy+U4OjoyPWbEFyPX\n", + "s7MzKpUKzWbT3CghzzjITZXHtVqNUqnE8fGxybXp9XrGqSdrFZdAIBAgHo+brEORMqVSiUAgQKfT\n", + "Md/tunXMC4+GNKOSxiaN/d4o7OL8er1OpVIhl8uxt7fH3t4e+/v7Q7kvrVZryDsr29F1N8oOaF5c\n", + "XAyRRspihDB2/Euufr+fWCxmrp1Oh3K5TC6XIxAI0Gq1zP9xF3jwpBklwyhpxmXf2QFKiR1Jgb7c\n", + "jL29PT788EM++uijoe1rmmoB0XcEsj0FAgFDbOmBI+SziSPebVl7q9Uil8sRjUaNs1K2v7uo8nzw\n", + "pJkGtu+k0+lQLBYpFArk83mOj485ODigWCxSq9WGPLvzEvsi2arVqgl1yJZXrVYJBoNDmYTLVu77\n", + "1pHG9ptIzdHJyQnZbJbDw0MODw/J5XIUi0Xq9bqJWo9Ki1lgk8btdhOPxymXy1SrVer1OsDMecqL\n", + "xPKtaMGwTepWq0WtVqNYLJLNZvn000/59NNPjT+mVquZisd5KpjdbpdWq2WSyePxuJE0tVrNmN52\n", + "s6RlwltHGsCQptFoUKlUjKTZ29vj5cuXQ4ruIioeRdL0+32j1NqkEY/1ysrKlUQdp9zfFbkeJWmu\n", + "+yH7/T7VatW0bT06OmJ/f59sNku5XDalJrIl3ee6bVLYmYXSDmV9fZ1MJoPH4zHEsy26ReFRkgbe\n", + "tKoEWmuq1SpHR0e8fPmSTz75hGKxSLFYNKQR5XfRpBlH7nHrHk1JlVqqVCpFJpMxFmOn06FarS68\n", + "HvzRkWYcUewUCJE02WyWjz76iA8++MC0dG02myYz7i6cZLK2cWGN6ySNpFWkUikT5RbCXBWEnSem\n", + "zRH+KvBXgOLgn/2q1vq/LWqR02Lcnt/v96lUKoY077///ht5M/eJ20oaaWAgfqZqtUqhULiTRPTb\n", + "0PK3gfdGXtPAb2qtvzAY90YY+y9vfX2ddDpNPB4nFApda66K1LmPhCZJRw2HwyQSCZOcJRmG4rAT\n", + "AowmiYlUEasvl8tRLpdNWGPRuJE0+rJbZ3nMW0thB0pALxqNsr6+zsbGBolEglAoZFq2jhv3CSFN\n", + "JBIxlRE2aezk93HZhUKaQqHAwcEBR0dHQwHURWOWDfBvKqX+WCn1NaVUbG4rmhB2kyIhzW0kzX3C\n", + "6/UOkSYejw81V7pJ0pyfnxtJc3h4OESapZA0V+CfAc+47LmXA/7R3FY0Iez67IcmaSQPWCRNNBod\n", + "kjS2fnKdpMlms5yenppzGRa+/mk+pLU2OcFKqd8Cfn9uK5oQotNIInkymSQSiZhg4H2tScxgO4dZ\n", + "EqYSiQTr6+tsbW2RyWSMHhYIBMZaP6P6l/Tnk5jYXVp7MCVplFKbetB4Gvhz3GP/YHF2SasySWjy\n", + "+/33VtIqKaj2GQt2QlgymSSVSg2RRlIfrktBHW1ZctdkEUyTI/xrwE8rpT7PpRW1B/y1ha7yGowr\n", + "WRG94L4kjUgW+3wFaZYk1RLpdJqtrS2ePHliiH6dpLFrqUTS2Jl6d7n1Tpsj/PUFrGUqjEoaqdH2\n", + "+/33uj3ZSWB221nJYRZJ8+TJE6N/XRWctJPdbcKMugzuCstpXkwIW4cQPeI+I8M+n8+U4MqhGlJT\n", + "HolEePr0Kdvb24bgkkhuVxzYhGg0Gqauqlarsbe3Z3wzrVbLHHd4V7GyR0GaZYM4G9fW1ox1ZI9U\n", + "KkUqlSIWiw0RRgg/WmQnllKhUKBYLPLq1StjMUkZzLwTxa6DQ5oFQOqWUqmUOfPSHuFw2BztI6a1\n", + "LR1HKyQqlQr5fJ6DgwNevXrF0dERx8fHxjfT6XTmmiR2ExzSLAB2WW0mk2F7e5utrS0z7C5Y44KV\n", + "dsmLOPLy+Tz7+/u8fPmSQqFgEsXsLudLbXI7GIa0MBFFN5PJ8OTJEzY3N0mlUsTj8aH+xDdFovv9\n", + "viFMs9mkXq9TrVY5Ozvj9PSUs7Mz0zb2PlrGPkrS3LUSHAqFTFt88UrLibrJZJJoNGpaxN4GYikJ\n", + "aaSGXBoM1Ot1c0jHQ+oasdS46x8yFAqRSqXY3d1ld3fXHFsoZy2IlLltvq9IGrv+W6SNlPOKz8Yh\n", + "zQPF6uoqqVSKZ8+e8bnPfc7Ej+RUXemGPomksbcn2+QWSTNJE6Z541GSZpxyab832ilr9H3x3IoX\n", + "1/b9jJvz3Xff5Z133uHJkyek0+mhz/r9ftMu5LrSYBvtdptyuUw2m+Xo6IhXr15RKBRMKufS99x7\n", + "SBiXOjl6kyTsEAwGTWrC6Pv29hKLxYba3o+LZ0kDpc3NTRKJhCGJHW+ynXc3EafdbnNycsKrV694\n", + "+fIl2WyW4+Nj0zDpvvGoSDOK6yRNMBg0YQcbbrebra0ttre32d7efuMc7nGhCdvbG4lEhoKVoxHu\n", + "20gaKeA7ODjgww8/pFAomO1p6UmjlMpw2Qo2xWVw8l9orf+JeiB9hEcfy/PrJI3H4yGTyZgt5/nz\n", + "50NnXI6edwAYCSTkuGo9t7XqhDT7+/v88Ic/NH327tKBdx1ukjRd4O9ord9XSq0Cf6SU+hbwSyxJ\n", + "H2HpNNVoNCiXy5yenhKJRNBa4/V68fl8Q/9eKWVM5KdPn74xn9vtNrGh9fV10wBaAopXKbOjVQOy\n", + "tttgtHl1qVQyVpJ0qVgmXEsarfUxcDx4XFdKfQhss0R9hPv9Pu12m0qlQrFYJBaL0e12TUbf6Mlw\n", + "LpeLcDhMOp1Ga004HH7j/fX1ddPYUdIuRYkdR4TRagGYrMVsp9MxZTT1ep1isUi1Wh1qwrhMuLVO\n", + "oy4bUH8B+D8sUR/hUdKsrq6a9hx263iBUopwOIzWmlAoRDr946XLjbcj1NLv7jp9xCbMNJJG+gOX\n", + "SiVKpRLFYpFKpbK051neijSDrek/AX9ba12zfzyt77ePcL/fNx0YisXiUKdyaZpow+VyGT9KKpUa\n", + "ynyT66gCK1iUpOl2u9RqNU5PTzk+Pn74kkYp5eWSMP9Gay2tX5emj7DoNNJdSvrTSRPEi4uLIR+L\n", + "Umqom6bMYV9nWYsQxz7/abRFrH1I2Pn5OScnJ+TzeZP+IA2tm83mw5M06vJX/Rrw/7TW/9h6a2n6\n", + "CEtJqijCfr+f9fX1ofiMLTkWGZeSue1On5KmaSeDS4TabgApXc/L5TLFYvFO65gmxU2S5kvAXwC+\n", + "r5T63uC1X2WJ+gjLX269XjfnKJ2dnb0R1LvLjlKjOb2jkuX4+JijoyMz7IM55FqtVh8mabTW/4ur\n", + "a6OWoo+w1AFJzY/b7aZSqZgD06WrpuSvLHot9vYkEkZiSNI9NJ/Ps7e3x8cff8wnn3xCo9Ew/XCE\n", + "6DIeHGkeAuzOVoBptpjP58lms0YxtmNBtt9lnsnnIslsE3o0v7dWq5mO57lcjkKhQLvdNucvCFHs\n", + "U+mWDY+CNPJXrZSi1WpxenpKNpvF7/fT7XZNaqVc7bGIioXz83MqlQqlUonT01Ojq4jeIo0hT05O\n", + "3sjxtfsSLysePGkAE4+RDt9iRQE0Gg2i0agpsJcqTGnZMer8mwWyPQlp8vk8R0dHpmmSJIaLxKnX\n", + "66b+etTCWoby4avw4Eljm7WiT5RKJQBzOHoymTRVAc1mE8B0k1oEhDR2Vwdp15bL5Ux7NluyyHex\n", + "v9ey4sGTBob9LHa7VVGS7Vzber1uXpPsOEldsHv32qkQdinsOBMahmNP0skhl8uRz+cpFotmm5KT\n", + "5x4yHgVpbEiBfKvVAjBZ/XIqW6lUolarUalUKJfLpFIpkxAuB6OK4uz3+00vO/tgU/v8J5Fctjkv\n", + "JnUul+Pk5MSYz+M81A8Rj5Y0UnQmUqZarbKyskIgEBjK7C8UCibZSq4Sm5K2rEJC0UVEsRXnnA2l\n", + "FKenp0NDSLPoBop3hUdJGtlK2u320FGFkoAl5zcVCgXW1tZIp9NDTQ/FGSjnEYxKqnw+b0ahUDAK\n", + "sMB20tVqNeOjua/qgXnj0ZEGuNZctQ/VEgki3ctF75EjkMXiEokiQ6wgGaOQKgK52r2JHwMeJWmu\n", + "g2xfzWZzqG5aTpArFAqmikB0HPvMbTnexx4C27knyrb4YKRA35E0DxBiUQFmC2s2m5TLZQKBgOni\n", + "4PP5THqn3HyJHdlSRHJe7O1p9IhlGcvssJsE6jrmX5Mj/FVu6CN8nzk2N2FUzxmXCG6/P5rmYB+h\n", + "PI4IVzUaWmaH3ThorcdGeG8izQawYecIA7/AZVS7prX+zWs++3B+HQdjcRVpps0RhiXpI+zg7nHr\n", + "XAErR/h/D15aij7CDu4etyLNYGv6j1zmCNdZoj7CDu4e1+o0YHKE/wvwX0dSPuX9XeD39eCwDet1\n", + "R6d54LhKp7lW0lyVIzxIJhfcax9hB3ePm6ynnwT+APg+lyY3wN8HvsLl1mT6CFt1UPJZR9I8cExl\n", + "cs8ChzQPH1NtTw4cjINDGgcTwyGNg4nhkMbBxHBI42BiOKRxMDEc0jiYGAvz0zh4vHAkjYOJ4ZDG\n", + "wcRYKGmUUu8ppX6klPqTQRfQWefbV0p9Xyn1PaXU/53i819XSuWVUj+wXksopb6llHqplPrmJLlB\n", + "V8z3VaXU68Eav6eUem+C+TJKqf+hlPqhUuoDpdTfmmWN18w39RqB8fms8xiAG/gY2AW8wPvAT8w4\n", + "5x6QmOHzP8VlItkPrNd+A/h7g8e/DPz6jPP9GvB3p1zfBvD5weNV4CPgJ6Zd4zXzTb1GrfVCJc0X\n", + "gY+11vta6y7wu8DPz2HeqdNMtdbfAcojL/8cl21tGVx/Ycb5YMo1aq2PtdbvDx7XAbsF78RrvGa+\n", + "qdcIi92etoFD6/lrfrzgaaGBbyulvquU+qszziVYRHvbmVNh592Cd57puoskzSJs+S9prb8AfBn4\n", + "60qpn5rn5PpSjs+67plTYUdb8M66xnmn6y6SNFkgYz3PcCltpobWOje4FoFvcLkFzor8oFRHMhJn\n", + "am+rtS7oAYDfmnSN17XgnWaN1nz/VuabdY2LJM13gXeVUrtKqRXgF7lsJTsVlFJBpVR48DgE/Czz\n", + "STOV9rYwh/a2s6TC3qIF70RrXFi67izWzC209y9zqbF/zGUV5ixzPePSAnsf+GCa+YDfAY6ADpf6\n", + "1i8BCeDbwEvgm0Bshvn+EpcVqd8H/nhwc9MTzPeTQH/wHb83GO9Nu8Yr5vvyLGvUWjthBAeTw/EI\n", + "O5gYDmkcTAyHNA4mhkMaBxPDIY2DieGQxsHEcEjjYGI4pHEwMf4/w2zPGHuGeikAAAAASUVORK5C\n", + "YII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEo9JREFUeJzt3X2QXXV9x/HPJ5tks1lCM1SqhewmNEALCBUamSiJSJVK\n", + "GUHbWoFSpbZjp6NWSn3CzLR/tWJ1HKnjtDNU6gOitEWLOi0gRYpZbIjBhKcgj+YJCiktSJ4Twrd/\n", + "3Ju4LHuz57snvz33hvdrhuGec797fr89v3PufnPOub+vI0IAAACYvGlNdwAAAKDXkVABAADUREIF\n", + "AABQEwkVAABATSRUAAAANZFQAQAA1DS9ycZtM2cDAADoGRHh8dYXTahsnyPpSkl9kr4QEX8zNuaj\n", + "H/3oS35uZGRES5YsedG6adOqX0yzx/1dO8psu9R2M7F9fX2VY6dPzw1xJr5TP26++Wa95S1vedG6\n", + "Ur9fJjYbX2r8ssdnVQMDA7Xjr7vuOl144YUvWT84OFikHzNmzKgcu3v37sqxu3btqhwrSTt37qwc\n", + "+/zzz1eOzczz98ILL1SO7bSPr732Wl188cUvWT9nzpzK2547d26R2Ewf+vv7K8dmjiGp3Hm9Z8+e\n", + "yrHjHZ+f+MQntGzZspeszxybUu48yfQ5s93MObJ3797Ksdl5MzPnVNXY0047reN7xW752e6T9HlJ\n", + "50g6UdJFtk8o1R4AAEBTSj5DdbqkRyJiXUTskXSdpLcVbA8AAKARJROqoyVtHLW8qb1uQsPDw0U6\n", + "hKmxcOHCpruASXr1q1/ddBdQw8knn9x0FzBJS5cubboLqKlkQjXpB85JqHrbscce23QXMEkkVL3t\n", + "lFNOaboLmCQSqt5X8qH0xyUNjVoeUusq1YuMjIzsfz08PEwyBQAAusKqVau0atWqSrElE6pVko6z\n", + "vUDSE5IukHTR2KCx3+YDAADoBosWLdKiRYv2L1911VUdY4slVBHxvO0PSLpZrWkTro6IB0q1BwAA\n", + "0JSi81BFxI2SbizZBgAAQNManSk9o9REYVKZyb+k3CRkpSYAzE6Eltl3pcYkM9lcpg/Z+EyfS8Vm\n", + "JqjMTma5ffv2yrE7duyoHJuZiDATmznus8dFqfErda5mtiuVmzwx24+qMpN1lpqYWSr3t6HkZ3hG\n", + "qX2Xmby45PiV+hvcCbX8AAAAaiKhAgAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAm\n", + "EioAAICaSKgAAABqIqECAACoiYQKAACgpsZr+VWtP5ap95OpAyVJfX19RWIz9YwydYRK1RKTcjXQ\n", + "MrHdUANRyo1JZqynT69+KmViS9a5ytRMzMRmjs/MeGT2W2bsSvYj+1lUVWY8pHLnaqkanZm6lNna\n", + "rb1WqzB7DPX391eOnTVrVpF+ZD63MudeVon6n1dccUXH94peobI9ZPs22/fbvs/2B0u2BwAA0ITS\n", + "V6j2SLosItbYPkzSXbZviYgHCrcLAAAwZYpeoYqIJyNiTfv1VkkPSDqqZJsAAABTbcoeSre9QNKp\n", + "ku6cqjYBAACmwpQkVO3bfddLurR9pQoAAOCQUfxbfrZnSPqGpK9GxA1j31+xYsX+1/PmzdO8efNK\n", + "dwkAAGBC69ev14YNGyrFFk2o3Po+5NWS1kbElePFLF68uGQXAAAAJmX+/PmaP3/+/uWRkZGOsaVv\n", + "+Z0h6fclnWV7dfu/cwq3CQAAMKWKXqGKiBExGzsAADjEkewAAADU1HjpmapT32emkM+WC8iWcagq\n", + "WxalG2TKAGTKC5Qqt5ItzZL5/Urti4xS5YukXNmJTGzJ8asqU7pEyn0G7Ny5s3JspixKZh/PnTu3\n", + "cqyUK0eSGZNMSZvMPt66tfqXwTOxkrR79+7KsZk+Z8odlTr3JGnmzJmVYzOfy6VK9pQqXyTljs9s\n", + "CaPxcIUKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoA\n", + "AKAmEioAAICaGi89ky0TU0WmBICUm36/VCmQUtP6lyx/k5mqv8Q4S/nfLzN+3aBUSZRsfKYfpUoS\n", + "ZWKzMsfn9u3bK8dm9lvJczXTj1KlWTLlgDIlQzKlVqTc34fMsZz5PMyce5nxkHL7LrPtzHa7RWas\n", + "s3nDeDp+Qtn+HUkhaby/QBER36zSgO0+SaskbYqI8ybVSwAAgC52oH/ynadWQtVJpYRK0qWS1kqa\n", + "U7VTAAAAvaRjQhURf1B347bnSTpX0l9L+vO62wMAAOhGE94gtv0q21fbvqm9fKLtP6q4/c9K+oik\n", + "Mg/QAAAAdIEqT9x9SdJ3JR3VXn5Y0mUT/ZDtt0raHBGrNf5zWAAAAIeEKl+beUVE/JPtyyUpIvbY\n", + "rvK4/+slnW/7XEmzJB1u+ysR8e7RQXfcccf+10NDQxoeHq7eewAAgEK2bdumbdu2VYqtklBttf3z\n", + "+xZsL5b004l+KCKWSVrW/pkzJX14bDIlSWeccUaljgIAAEylwcFBDQ4O7l9++umnO8ZWSag+JOk7\n", + "kn7J9g8kHSnpHZPoV7lJVgAAABo0YUIVEXfZfoOkX1brWagHI6L6bG6tbdwu6fbJdREAAKC7TZhQ\n", + "2R6Q9D5JS9S6yrTc9t9HRG5aZgAAgENUlVt+X5H0nKTPqXWF6vckXSPpdwv2CwAAoGdUSahOiogT\n", + "Ry1/z/bag9WBqjW0StWC6xaZOkKZenTZ+kSZbc+YMSO17aoy9bOytflK1fLL1GHL9GHOnOoFBrK1\n", + "7jI10Pr7+4v0I1MfLLOPM3XjstvOnFOzZ8+uHHvYYYdVjs2OdalzKrMvMn0u9dlS0pYtW4rE7tix\n", + "I9WPUvUjM2OS+bwYGBioHDtr1qzKsaW2ffbZZ3d8r8pZ9iPbr9u30P6W312VWgYAAHgZOFBx5HtH\n", + "xdxhe6Naz1ANS3pwCvoGAADQEyYqjgwAAIAJHKg48rrRy7Z/Qa0ZzwEAADBKleLI59t+WNJP1JpL\n", + "ap2kGwv3CwAAoGdUeSj9ryS9TtJDEXGMpDdJurNorwAAAHpIlYRqT0Q8LWma7b6IuE3SosL9AgAA\n", + "6BlVJgZ5xvYcScslXWt7s6StZbsFAADQO6pcoXq7pO2SLpN0k6RHxDcAAQAA9qtSHHnf1ai9kr5U\n", + "tDcAAAA96EATe25VayLP8UREHH4wOpApf3EoK1UaIltqJVNKohvKWZQqJVNSptxDRmY8svGlSoxk\n", + "YjPlp7KfK3v37k3FV5UZ60w5kuwxlBm/TOmSzJhkjrdSsVK5Y7nUZ1G2fFimnFMmdvfu3ZVjM8dy\n", + "qWNIyo1JdtvjOdA8VNULS3Vge66kL0g6Sa3k7A8jYkXd7QIAAHSTXIXNvL+V9O8R8Q7b0yUNFm4P\n", + "AABgyhVLqGz/nKSlEXGJJEXE85J+Wqo9AACAptS/adjZMZL+x/YXbf/I9j/Ynl2wPQAAgEaUTKim\n", + "SzpN0t9FxGmStkm6vGB7AAAAjSj5DNUmSZsi4oft5es1TkK1fPny/a+Hh4c1f/78gl0CAACo5tFH\n", + "H9Vjjz1WKbZYQhURT9reaPv4iHhI0psl3T82bunSpaW6AAAAMGkLFy7UwoUL9y/feuutHWNLf8vv\n", + "T9UqVzNT0qOS3lO4PQAAgClXNKGKiLslvbZkGwAAAE0r+VA6AADAy0LpW34Tqjrde2Z6+kyslCvj\n", + "UKpsSEapki9SrhRBqTI1JUsRHIzyAuPJlC7ZsWNH5dhMGZBS5VOk3H7LlOsYGBioHNvf3185Nlt6\n", + "ZsaMGZVjM/t5586dlWNLlXzJKvlZW1XJ0jOlypFkjrnM8ZY5n7LxpUo/vVxxhQoAAKAmEioAAICa\n", + "SKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJoaLz1TtdxC\n", + "Ztr7bAmObig9kymHkC0nk5EpJ5MZk0yfS451ZtuZMjyZ2FKlITLlLLIyZVG2b99eOfa5556rHJsZ\n", + "60xJGylX1iazn0uNScnyWhmZMdm9e3eR2Oy+2LVrV+XYzO83a9asyrGZ4y17LGfiM8dnqfJhmc+W\n", + "zHFRetvjKXqFyvbHbd9v+17bX7Nd/SgCAADoEcUSKtsLJL1X0mkRcbKkPkkXlmoPAACgKSVv+T0n\n", + "aY+k2bb3Spot6fGC7QEAADSi2BWqiPg/SZ+RtEHSE5KejYj/KNUeAABAU0re8lso6c8kLZB0lKTD\n", + "bF9cqj0AAICmlLzlt0jSDyLifyXJ9jclvV7StaODRkZG9r8eHh7W8PBwwS4BAABUs3HjRm3atKlS\n", + "bMmE6seS/sL2gKSdkt4saeXYoCVLlhTsAgAAwOQMDQ1paGho//KKFSs6xpZ8hupuSV+RtErSPe3V\n", + "V5VqDwAAoClFJ/aMiE9J+lTJNgAAAJpG6RkAAICaSKgAAABqaryWX9UaU5lacCVrmpWso1dCyZpf\n", + "mTpX2Zp7VZX8/TJ1DWfOnFk5NlMTK9OHTKyUO5Yz287UxMrsi0x/M7XSpFz9s8xYZ/bFli1bisRm\n", + "+5E5VzPjlxmTwcHBIn0oue3s+VdV9m/Ojh07Ksdmj6OqStWmzY515lzNHBedcIUKAACgJhIqAACA\n", + "mkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJq6MqHasGFD011ADYxf71q3bl3TXUANTzzxRNNdwCSt\n", + "X7++6S6gpq5MqDZu3Nh0F1AD49e7+FDvbSRUvYtzr/d1ZUIFAADQS0ioAAAAanKmFMdBb9xurnEA\n", + "AICkiBi3Xk6jCRUAAMChgFt+AAAANZFQAQAA1NR1CZXtc2z/2PbDtj/WdH/Qme1/tP2U7XtHrTvC\n", + "9i22H7L9Xdtzm+wjOrM9ZPs22/fbvs/2B9vrGcMuZ3uW7Tttr7G91vYV7fWMXQ+x3Wd7te3vtJcZ\n", + "vx7WVQmV7T5Jn5d0jqQTJV1k+4Rme4UD+KJaYzXa5ZJuiYjjJd3aXkZ32iPpsog4SdJiSe9vn2+M\n", + "YZeLiJ2SzoqI10g6RdJZtpeIses1l0paK2nfw8yMXw/rqoRK0umSHomIdRGxR9J1kt7WcJ/QQUQs\n", + "l/TMmNXnS/py+/WXJb19SjuFyiLiyYhY0369VdIDko4WY9gTImJ7++VMSX1qnYuMXY+wPU/SuZK+\n", + "IGnft8YYvx7WbQnV0ZJGT7O9qb0OveOVEfFU+/VTkl7ZZGdQje0Fkk6VdKcYw55ge5rtNWqN0W0R\n", + "cb8Yu17yWUkfkfTCqHWMXw/rtoSKORwOIdGak4Mx7XK2D5P0DUmXRsSW0e8xht0rIl5o3/KbJ+kN\n", + "ts8a8z5j16Vsv1XS5ohYrZ9dnXoRxq/3dFtC9bikoVHLQ2pdpULveMr2qyTJ9i9K2txwf3AAtmeo\n", + "lUxdExE3tFczhj0kIn4q6d8k/ZoYu17xeknn2/6JpK9L+nXb14jx62ndllCtknSc7QW2Z0q6QNK3\n", + "G+4Tcr4t6ZL260sk3XCAWDTItiVdLWltRFw56i3GsMvZfsW+b4DZHpB0tqTVYux6QkQsi4ihiDhG\n", + "0oWSvhcR7xLj19O6bqZ0278p6Uq1HrK8OiKuaLhL6MD21yWdKekVat3v/0tJ35L0z5KGJa2T9M6I\n", + "eLapPqKz9rfCvi/pHv3s1sLHJa0UY9jVbJ+s1kPL09r/XRMRn7Z9hBi7nmL7TEkfiojzGb/e1nUJ\n", + "FQAAQK/ptlt+AAAAPYeECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioAjbN9R/v/821f\n", + "dJC3vWy8tgDgYGIeKgBdw/Yb1Zrk8LzEz0yPiOcP8P6WiJhzMPoHAJ1whQpA42xvbb/8pKSltlfb\n", + "vtT2NNuftr3S9t22/7gd/0bby21/S9J97XU32F5l+z7b722v+6Skgfb2rhndlls+bfte2/fYfueo\n", + "bf+n7X+x/YDtr07t3gDQi6Y33QEA0M9K33xM0of3XaFqJ1DPRsTptvsljdj+bjv2VEknRcT69vJ7\n", + "IuKZdm27lbavj4jLbb8/Ik4dp63flvSrkk6RdKSkH9r+fvu910g6UdJ/S7rD9hkRwa1CAB1xhQpA\n", + "N/GY5d+Q9G7bqyWtkHSEpGPb760clUxJ0qW210j6L0lDko6boK0lkr4WLZsl3S7ptWolXCsj4olo\n", + "PROxRtKCGr8TgJcBrlAB6HYfiIhbRq9oP2u1bczymyQtjoidtm+TNGuC7YZemsDtu3q1a9S6veKz\n", + "EsAEuEIFoJtskTT6AfKbJb3P9nRJsn287dnj/Nzhkp5pJ1O/ImnxqPf27Pv5MZZLuqD9nNaRkt4g\n", + "aaVemmQBwIT4VxeAbrDvytDdkva2b919UdLn1Lrd9iPblrRZ0m+140d/RfkmSX9ie62kB9W67bfP\n", + "VZLusX1XRLxr389FxL/afl27zZD0kYjYbPuEMdvWOMsA8CJMmwAAAFATt/wAAABqIqECAACoiYQK\n", + "AACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJr+H2eW+wXdCzz6AAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAFYRJREFUeJztnVuMZHldxz+/ut+7q+89072zs8Oa8EACL/gARB4IWWIi\n", + "+qIhMRpE44OiURMRHwSjD0gCMb4QlV2Dl4BGAwETFTAa8cHLml12UXbZTRimZ/tW3VXVdb//fej6\n", + "/ffUmeqeruq6nJo5n+Skbl2nf931rd//8rscMcbg4zMKgXkb4LN4+KLxGRlfND4j44vGZ2R80fiM\n", + "jC8an5EZWzQi8oyIvCIir4nIxyZplI+3kXH2aUQkCLwKvA94A/hv4EPGmO9O1jwfLzKup3kn8Lox\n", + "5q4xpg18Cfjg5Mzy8TKhMd93E9hzPL4P/LDzB0TE32pecIwxMuz5cT2NL4jHmHFF8waw63i8y7m3\n", + "8XkMGFc0zwNPi8iTIhIBfgr46uTM8vEyY81pjDEdEfll4J+AIPCsv3J6fBhryX2lE/sT4YVn0hNh\n", + "n8cYXzQ+I+OLxmdkfNH4jIwvGp+R8UXjMzK+aHxGxheNz8j4ovEZGV80PiPji8ZnZMZNwgJARO4C\n", + "JaALtI0x75yEUdNGROwRCAQIBoOEQiGCwSDBYJB2u02n07G3s7AnEAhYmwCMMWhc0H1/3lxLNJwn\n", + "Y73XGJOfhDGzQEQIhUL2CIfDLC0tkclkyGQyJBIJ8vm8PQqFwtRtCoVCRCIRwuEwkUiEXq9Ht9ul\n", + "2+3S6XTs416vR6/Xm7twrisagKGRUC8TDAaJRCLEYjHi8ThbW1tsb2+ztbXF6uoqd+/e5e7du7Tb\n", + "7ZmIJhgMWlsSiQTdbpd2u02r1aLVatFutxERK6B5MwlP800R6QJ/bIz50wnYNFXU00SjURKJBOl0\n", + "mu3tbe7cucNb3vIWbt68STwep91uk8/PxoGGQiFisRjpdJpMJkOn06Fer9NoNOywBXhCMHB90bzL\n", + "GHMgIuvAN0TkFWPMtyZh2DTRDymRSLC0tMT6+jo7Ozs89dRT3Lp1i0KhwBtvvEE8Hp+pPalUimw2\n", + "S6fTIRaLUa/Xqdfr1Go16vU6xhja7fZiD0/GmIP+bU5Evsx5aYunRSMihMNh4vE4mUyGbDZLJpMh\n", + "Ho8TDocfmJDOglAoZO1ZXV214tCjWCySz+cREZrN5tw9ztiiEZEEEDTGlEUkCbwf+N2JWTYlVDSJ\n", + "RMKKJpVKDYhm1sJxDk8rKysEg0G7Yur1euRyOUSERqNBsViciU2X2nuN924CX+7/Y0PAXxljvj4R\n", + "q6aIiBCJRB7wNIlEgkgkMnMvA4OeZmVlhVgsZrcCAoEA0WiUZrNJsVgkEJj/1trYojHGfB94+wRt\n", + "mQnDPE06nZ7r8BQIBAiHw8RiMZLJJMlkkmg0SjQaJRKJ0G63OT09JR6PW/vmOa+ZxJJ7IVARqKfR\n", + "SfDKygrpdJpYLEYoNJ9/R6/Xo91uU6/XqVQqBINBwuEwwWCQeDxOPB4nGo3a5wKBgB2+5iGe+fu6\n", + "GeAUTCAQIBKJkEwmB0QTj8fnJpput0ur1aJer1Mul2k0GvR6PTtsOUUTCoXm4g2dPBaiAQbCBupp\n", + "nMPTPD2NUzSVSoVGo0G32yUYDJJIJIZ6mnkK57EYnlQs7rnD0tIS2WzWzh0AG2+a5XZ9r9ej0+nQ\n", + "arVoNBq0220AuzWgoolEIlY0ML841CMvGp34RiIRIpEI6XSa5eVlG29Kp9MD3/RGo0GhUKBSqdgP\n", + "bxY2qqg1DhWNRu0GpIpGg6o6p5kXj41oNK6jgtEjnU5TLpft0HB2dkY+n6dardJqtWZmozPaHg6H\n", + "iUaj1uZhw1Ov1/PnNNPCKZpUKsXy8vKAp0mlUoRCIVqtFmdnZxwdHVlPM0vRiIgVzTBPo1Fw95xm\n", + "HjySnsa5WgoGg0SjURvXWVtbI5vNWi+j8SUdlg4ODsjn8zMdnnRY0mFUBaORb53P6Mpp3qunR040\n", + "KhQ94vE4a2tr3Lx5kxs3bnDjxg1u3rzJ0tISgUCAer3O2dkZJycn7O/vs7e3x9HREaVSiWazOROb\n", + "3bGn5eVlksmk3aH2Go+caODNfJlIJEIqlbKieeqpp3jiiSdYXV0lk8kQCASo1WpWNAcHB9y7d49i\n", + "sThX0SwtLQ2ENbzGIycazZfR+FI6nbapD3fu3OHOnTtWUCJiPU0ul7OeRlMRfE8znIeKRkSeA34U\n", + "ODbGvK3/3Arw18At4C7wk8aY+YdfeVM0zr2YtbU1bty4wa1bt7h9+7bNiGu1WpTLZQqFAicnJxwd\n", + "HbG/v29TK7vd7szsdQYsve5prrJ6+jPgGddzvwV8wxjzQ8A/9x97gkAgQDweJ5vNsr29ze7uLhsb\n", + "GywtLRGPxxERarUauVyOu3fv8sorr3Dv3j1yuRzVanUmubi6xNY8Zc0iTKVSAxP0cDi8mKLpZ+K5\n", + "E2V/DPhC//4XgB+fsF1jEwgESCQSZLNZtra22N3dZXNzk+XlZWKx2AOiefXVV7l37x4nJydUKhUr\n", + "mmkGA937Mrono6LR/J5QKORJ0Yw7p9k0xhz17x9xnlvjCS7zNE7RnJyc8IMf/IDXX3+d4+Nj62mm\n", + "LRgYXOEN8zSpVMq+7lxae0VA154IG2PMvPvrOf+poVCIZDLJysoKW1tb7Ozs2NVSLBYDsKK5d+8e\n", + "r732GuVymUqlYoenaaNeRvdldOdXE8vj8fhA6sMshDwK44rmSES2jDGHIrINHE/SqFHQIKSuiDKZ\n", + "DGtra6yurrK6uko2myWRSBAMBm0gslarUa1WqVQqNoTQarVmIhjAbjam02nS6fQDw6eWsGjwtFwu\n", + "U6vVbDBTa6LmlSs8rmi+Cvws8Af9269MzKIRERGi0ajNeFtZWWFtbc0KJ5vN2jyUbrdLo9EYEI2G\n", + "C1qt1sw+hEgkYld1a2trbG9vs7y8bCfqnU6HRqNBo9GgXq9TKpWoVqs0Gg06nc7Mo/BurrLk/iLw\n", + "I8CaiOwBvwN8CvgbEfkI/SX3NI28DM2h1bjS+vr6A55G/8FaT+QWjX5zZ+lpMpkMGxsb7OzssLm5\n", + "STabtcNnp9Oh2WxSrVYpl8vW0zSbTetpPC0aY8yHLnjpfRO2ZSw0fdMZW1LR6J6HfmtbrdYDgqlU\n", + "KjO31yma3d1dtra2hnqaSqVCsVjk7OzMJmepaOaZ7rnwO8LO4UlFs7S0NLCjqpt4xWKRk5MTTk9P\n", + "Zx6QdB7OVNONjQ1WVlasvQCtVotSqcTx8TGHh4ccHBxQKBSo1WpzFww8AqJxDk8qmuXl5YEdVf0Q\n", + "NL6kUexZpT44N/JCoZBdWq+urrKxsWFrr9TeZrPJ2dkZx8fH7O3tWZt1dTfvldTCi0Y9jVM0F3ka\n", + "FY16mlmLRld4bk/jDBsANJtNSqUSuVxuQDROTwN+uufYaKL4VUSTy+Xmmi+jnSqSyaSNM62vr5NM\n", + "Jm0+DbwpmuPjY+7fv8/R0RHFYvEB0cyLhRSNsymRe0c1nU7bb20wGKTX69FoNGwkex6eJhwOk0ql\n", + "yGQytuGAM5Kt6ZvaVkRXTaVSiWKxaPeSvFD8DwsoGmcpim7sOWM3GuzTD8MYQ6PRGJjT6A7wrDyN\n", + "esLV1VXW1tasaBKJhK3q1AZG3W7Xru6cotGVky+aMVHBuGM3usPq9DS6fHV6mmazaTf0ZoGKZmVl\n", + "he3t7Qc8DTDQxGiYp9FNPV80Y+IM+A3zNDrhVLevnkZFM2ucotna2npg3tVutwdKc1U0Z2dndo/G\n", + "SyykaODBWqFwOGyPXq9nd371n1+r1WbSdHEYaqOKW8tRtOhNBdNoNKhWqwOxMC94FjcLKZqLunNq\n", + "xn6z2aTRaNBsNsnn83blMas5jBv36slZwwRviqbZbNrApJdFs3B1T27BuNMMnJ5G0zjPzs6o1+tz\n", + "9zSaBuEsR3FGtTWYqiulWcXCRuWhohGR50TkSERedjz3SRG5LyIv9A93OujUcQpHd1rdoikWi+Ry\n", + "Oc94Gq1nusjTuIcnr0x83YybI2yAzxpj3tE//nHypg3HmZikyd9aOF+r1QbEod0h3AVnWqU4rUw4\n", + "Z7WkVndqDbmGOZLJpM0B7na7dmhyp0EspGguyBGGOfYPVtHo3oaKplqtWtE4A5mzFo27mF9Fk81m\n", + "B5bb0WjUikaX2qVSiUqlYocoL3KdOc1HReTbIvKsiCxPzKIrcJFo1NN0Oh0byEwmkyQSCWKx2AP1\n", + "0LP0NJrvo2XBzjCH29NoGsTCepoL+Bxwm/OeewfAZyZm0RVwDk9u0VSr1Qs9jWbwOSeh0+Ci4ckZ\n", + "hR8mmmq1+kDujBdFM9aS2xhjc4JF5PPA1yZm0dV+/4C30d1UTbbSzT3dC1lbW2NnZ4dqtWpLcfVo\n", + "NBoj/35n501nFwdnaENtiEQi3Lp1i42NDVtlMEyszhyZeac+PIyxRCMi29p4GvgJ4OXLfn6SGGNs\n", + "d0u3t2k2mzSbzYFWqvF4nPX1dWq1GsYYEokExWLRHuVyeWQbnBuJejjzZbTzg97evn2bjY0Nksnk\n", + "lf4+rzNOjvAngPeKyNs5X0V9H/jFqVrpQr+J6tqdQ1Sj0bB9eLWt6vr6Or1ej2g0yvLyMsfHx/YY\n", + "5/oH2gZED6dXcbYK0d+/vb3N5uYmqVRqaDvXhz32GuPmCD83BVuujDMJySka9TTdbteKJp1OY4yx\n", + "gllfX7dJT7qSGhWdXOttPB5/QEjOQ7tuJZPJC+dR7mHJy8JZyDCCE61jKhQKHB4eEo1G7Ra8czkL\n", + "5x4im80OTJSXl0df+KkX0Vv3cKSHvq6T8YtqszudzkDLk0KhQLVapdlselI8j4xo8vk8+/v7ADZq\n", + "LCL0ej27UtK5R6/Xs00bNzY2Rv6d6qH01jmncXazcovoopaz7XbbCv/o6IjT01PK5bInLp4xjIUX\n", + "jSYt6VVKNGajy15tCJBIJAZax2vfmnFzapzDiDMGNmz1pIK6aOXUarWoVCpWNMVi0fbH8T3NFFBP\n", + "o1n89XodYGAVo3MaTbtMp9PX6lnnvL6lc9dWz+eMgzmHpIt+n3qaYrHI8fEx5XLZFu/5opkCWjnZ\n", + "bDZtADOXy9lhqFqtks1mWVlZsVdccV7kdJyJsPYb1lu3PSpMvXUvz93icU7onc2vvXC9ymEsvGiA\n", + "gckuwMnJifVAp6enLC0tDbSBdX+Io2CMsZWZmmvsRvOA9dA6c80Jvui8zgucenmDb+FFo99SeLNd\n", + "fLfbtYLRchHtTp5OpwfmNpqjOwqFQmFgg9DNzs4OTzzxBLVajV6vRzabxRhDKBQikUgM9TTu6L1X\n", + "BQOPkGhUOCJiwwVa4pJKpQYO3VfRmNSo5HI5Tk5O7OHm6aeftoJRUapgLvs7VDBeXDE5WXjRwOBG\n", + "mN5XEWnE2zn3ce7WjuppjDEUi0UKhQKlUolarfbAz2jgVFM13IX7btzpoM45jRez9x4J0VyGUyyA\n", + "jSg7Y0ajUqlULs0EdMbDdOmse0fDcF8dxtnUyItD1SMvGsDmBmsVoztCPSrOi6wPw52yoambVxFN\n", + "IpGwO9Z6noUSjYjsAn8ObHAenPwTY8wfebmPsBvnnKfVag1MQsfdp3lY+oJbNM5mRMNw1m8lk0m7\n", + "E+z0kF7iYZ6mDfyaMeZFEUkB/yMi3wA+zHkf4U+LyMc47yPsmV7CbmYdBBx1JeTOQnTu1XiRS32z\n", + "MebQGPNi/34F+C5wEw/3EfYSV/Vk7moE55DmtaEJRpjTiMiTwDuA/8TDfYS9xrA+wG4xuYvltEbL\n", + "iysnuKJo+kPT3wG/aowpO/9oL/QRXgQuiz/p/MVZLAd4dlf4KsVyYc4F8xfGGG39eiQiW/3X59pH\n", + "eFG4bF7lruPy+q7wpaKR86/Fs8D/GWP+0PGS9hGGOfcRXgQWIRtvFB42PL0L+GngJRF5of/cx/FQ\n", + "H2Evc9HwsujiuVQ0xph/52Jv5Ik+wj6z57HYEZ41zs4WFyV7OYesRah1cuKLZko4W6G4xeMWipcn\n", + "vcNYuP40i8CwHjoX5dA4V0qLIhxfNFPiKp7GmT+zSMLxh6cpoBde1YbY6XSaWCxm+xprIFIPZ9t9\n", + "XzSPKe5unnrBDG1Rq4VxpVKJUqnE/v6+bWPvi+YxRa9/kM1m2dzctL2N9UJl1WqVQqFALpfj+PjY\n", + "XmWlXq/7onlc0foq9TTRaNRWZGrSe6FQ4ODggPv37w94Gq+mQzjxRTMDms2mjVp3Oh329/e5f/8+\n", + "e3t77O3tDVRV+p7mMUWzBOv1uq3Jdiab64W/9NAk9Uaj4YvmccXZQ0+vcZDP5+2Ry+XsfEavB67V\n", + "mgsvmktyhD8J/DyQ6//ox2fZFtbrqKdR0ZyenrK/v8/BwYGdv+TzeQqFAvl83g5d87xs8iiMmyOs\n", + "fYQ/O3ULF5BGo0GxWOTw8JBMJsPJyQlHR0ccHh5yeHg4sNyuVqsLIRQnD4tyHwKH/fsVEdEcYZhj\n", + "H2GvU6vVyOVyhMNh2u02pVKJQqFgD683l34Y4+QI/wfneTYfFZGfAZ4HfsOrJSzzoFqtcnx8TLPZ\n", + "pFAoDPQ4rtVqD62b8jpyFaX3h6Z/BX7fGPMVEdngzfnM7wHbxpiPuN6zeF+hCaGVm1rF6bxYvLMr\n", + "hNfrto0xQ0eTh4qmnyP898A/uFI+9fUnga8ZY97mev6xFc2jwkWiGStHuJ9Mrsy0j7DP/LnU04jI\n", + "u4F/A17ifMUE8NvAhzhvcW/7CDvqoPS9vqdZcMYensbFF83iM9bw5OMzDF80PiPji8ZnZHzR+IyM\n", + "LxqfkfFF4zMyvmh8RmZq+zQ+jy6+p/EZGV80PiMzVdGIyDMi8oqIvNbvAnrd890VkZdE5AUR+a8x\n", + "3v+ciByJyMuO51ZE5Bsi8j0R+foo1xi/4HyfFJH7fRtfEJFnRjjfroj8i4j8r4h8R0R+5To2XnK+\n", + "sW0Ehl/adxIHEAReB54EwsCLwFuvec7vAyvXeP97OE8ke9nx3KeB3+zf/xjwqWue7xPAr49p3xbw\n", + "9v79FPAq8NZxbbzkfGPbaIyZqqd5J/C6MeauMaYNfAn44ATOO3aaqTHmW0DB9fTY7W0vOB+MaaOZ\n", + "cAveS843to0w3eHpJrDneHyfNw0eFwN8U0SeF5FfuOa5lGm0t/2oiHxbRJ4dZbhzMukWvK503WvZ\n", + "OE3RTGMt/y5jzDuADwC/JCLvmeTJzbkfv67dnwNuc55vdAB8ZtQTuFvwXtfG/vn+tn++ynVtnKZo\n", + "3gB2HY93Ofc2Y2OMOejf5oAvcz4EXpeJtrc1xhybPsDnR7Vx0i14Hef7Sz3fdW2cpmieB54WkSdF\n", + "JAL8FOetZMdCRBIiku7fTwLvZzJpphNtb3udVNhJt+CdWrrudVYzV5i9f4DzGfvrnFdhXudctzlf\n", + "gb0IfGec8wFfBPaBFufzrQ8DK8A3ge8BXweWr3G+n+O8IvUl4Nv9D3dzhPO9G+j1/8YX+scz49p4\n", + "wfk+cB0bjTF+GMFndPwdYZ+R8UXjMzK+aHxGxheNz8j4ovEZGV80PiPji8ZnZHzR+IzM/wMn9Av6\n", + "T5UJ3wAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEqRJREFUeJzt3X+QXXV5x/HPJ5uE3SSAY6GxwUjYjWmE0QpFBomK1DSh\n", + "jqJtrUpbpdKx01ErpcqIzLR/tYOV6Ugdp52xUBREpVWLOEUSUilirIRAAvlBICC0oDVpS9AsSZYl\n", + "PP3j3g3LZm/2PDn57r0nvl8zDPec+9zv+d77Pffsk3PO/T6OCAEAAODwzeh2BwAAAJqOhAoAAKAm\n", + "EioAAICaSKgAAABqIqECAACoiYQKAACgppnd3Lht5mwAAACNERGebH3RhMr2+ZKultQn6ZqI+OuJ\n", + "MVdeeeVBr1uzZo2WL18+sa3MdlP9zMzFVWrerlLvb8aM3EnII9GPVatWaeXKlantTpdSY/38889X\n", + "jn322Wcrx+7fv79ybF9fX+VYSTrmmGMOWrd69WqtWLHioPX9/f2V2505s8xh5ZlnnikSK0nDw8OV\n", + "Y0dGRirHjo6OFontNNbr16/XmWeeedD6zPjNnTu3cuycOXOKtJvZh7LH+1Iy3+vJ9qHJ/u5J0p49\n", + "e1L9KLV/Ztp97rnnisRmjrPZ+KqxN954Y8fnil3ys90n6XOSzpd0qqQLbb+q1PYAAAC6peQ9VGdJ\n", + "eiQiHo+IUUlflfSOgtsDAADoipIJ1UmSnhi3/GR73ZQGBweLdAjTY2hoqNtdwGFi7JptwYIF3e4C\n", + "DhN/95qvZEJ12DcbsWM12+LFi7vdBRwmEqpmI6FqLv7uNV/Jm9J/JGnhuOWFap2lepE1a9YceDw4\n", + "OMhOBQAAesKOHTu0Y8eOSrElE6r1kl5pe5GkH0t6j6QLJwZN9qsGAACAbps/f77mz59/YHnTpk0d\n", + "Y4slVBHxnO2PSFql1rQJ10bEg6W2BwAA0C1F56GKiG9L+nbJbQAAAHRbV2dKl6TZs2dXistM0JWZ\n", + "DDEbX2KiMKncJJLZidBKTciWiS01gZyUm8iu1PvL9GHfvn2VY7MTAGYmv8xMfJnpx969eyvHZvbl\n", + "7H6ROQZk2s60W+oYkO1HRqmJjiebdLaT7ESymcmOs59zVSUnk868v8xkwJkJVDNjkulDyYmqj8S+\n", + "TC0/AACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioAAICa\n", + "SKgAAABqIqECAACoqeu1/Hbt2lUpbtasWZXbrFofcEymblSmH9m6Q1X1Ss2vUnXKStUHk3JjkqlH\n", + "ldkvStYpyyhVfzCzz2XqeGW+1yXru2X6kYnN1B3L1irM1ITMfK9L1aXM1HjM9EEqV7s1c9wqdWyR\n", + "cseXgYGByrGZfblkfb6MzJhU/U5dfPHFHZ8reobK9kLbd9jeYnuz7Y+W3B4AAEA3lD5DNSrp0ojY\n", + "aHuepHtt3x4RDxbeLgAAwLQpeoYqIn4SERvbj4clPShpQcltAgAATLdpuynd9iJJp0u6e7q2CQAA\n", + "MB2mJaFqX+77mqRL2meqAAAAjhrFf+Vne5akr0v6UkTcPPH5O++888Djk08+WYsWLSrdJQAAgClt\n", + "27ZN27ZtqxRbNKFy63fA10raGhFXTxZz7rnnluwCAADAYVm6dKmWLl16YPmWW27pGFv6kt8ySb8v\n", + "6TzbG9r/nV94mwAAANOq6BmqiPiemI0dAAAc5Uh2AAAAaup66Zn58+dXisuUAChZbiVTPqFUuZXs\n", + "+8so1Xap8gKZch1SbqxHRkYqx2bGr1Tpi2w5klL7XKnSQZn3lyldIuW+15l+ZPb7TMmQefPmVY7N\n", + "tp35TmX2i2effbZy7J49e4rESrnxy3xXM2Pd399fOTZbSi1T9iUTW6rUWKkSWFJunzsSf/s4QwUA\n", + "AFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQEwkVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAA\n", + "QE1dLz2ze/fuSnGZKfJnzsy9rczU/pl+lCq3kpEtzZJ5f5m2M2OSGY9MSY2SbWfazcSWKgOSjc+M\n", + "35w5cyrHHnvssUVis+U6Zs2aVTk2U84iU4Kj5H5fqnRQphxJqTIgAwMDlWOl3OecOYZnPotMaaRM\n", + "WSSpXCmXUqVnMp9x5u+TlDtuVY296aabOrfR6Qnbvy0pJE12RI+I+EaVjdvuk7Re0pMR8fYqrwEA\n", + "AGiSQ6Vkb1croeqkUkIl6RJJWyVV/+clAABAg3RMqCLiD+o2bvvlkt4q6a8k/Vnd9gAAAHrRlBcv\n", + "bb/M9rW2b2svn2r7Dyu2/xlJl0nK3dwBAADQIFXuBvuCpNWSFrSXt0u6dKoX2X6bpJ0RsUGT34cF\n", + "AABwVKhyW/sJEXGT7cslKSJGbVf5GcE5ki6w/VZJ/ZKOs319RLx/fNCaNWsOPB4cHNTg4GD13gMA\n", + "ABSydu1arV27tlJslYRq2PYvjC3YPlvST6d6UURcIemK9mvOlfTxicmUJC1fvrxSRwEAAKbTsmXL\n", + "tGzZsgPLV111VcfYKgnVxyR9S9Kg7e9LOlHSuw6jX9UnpgAAAGiQKROqiLjX9psk/bJa90I9FBHV\n", + "ZwNrtXGnpDsPr4sAAAC9bcqEyvaApA9JeoNaZ5nusv33EZGbvhUAAOAoVeWS3/WSfibps2qdofpd\n", + "STdI+p2C/QIAAGiMKgnVaRFx6rjl79jeesQ6ULF+TqY2UKaWUTY+049SMvXdsrX8miY7Hpn4TD2x\n", + "UnWuStVWlHJ1rjK17jL9yNR3y9Qdy9RKk/LHjKoyn1umJl3J73WpOmylYkvWsMzEVq1LK0nDw8OV\n", + "Y0dGRirHSrnvSUamfmR/f3/l2Mx+n6kTmm07Wx9zMlX22vtsv35sof0rv3trbxkAAOAocajiyJvG\n", + "xay1/YRa91C9QtJD09A3AACARpiqODIAAACmcKjiyI+PX7b9i2rNeA4AAIBxqhRHvsD2dkmPqTWX\n", + "1OOSvl24XwAAAI1R5ab0v5T0ekkPR8Qpkt4i6e6ivQIAAGiQKgnVaET8r6QZtvsi4g5JZxbuFwAA\n", + "QGNUmYhml+1jJd0l6UbbOyVVn0QDAADgKFflDNU7Je2RdKmk2yQ9In4BCAAAcECV4shjZ6P2S/pC\n", + "0d4AAAA00KEm9hxWayLPyUREHFemSx37U6ztTKmFUv3ohZI2UrnyEJnPrVQfpHKfc6mSNhnZzyJT\n", + "amHu3LmVYzPlVkqVlMqOc6YETqnjRabd7PvL7BuZzyJTcqmU7H5fquTSSSedlOpHVdmySJnxy7Sd\n", + "OW6VOs5mx7rU351ODjUP1by6jdt+iaRrJJ2mVnJ2cUT8oG67AAAAvaR6qn54/lbSrRHxLtszJVX/\n", + "Zy4AAEBDFEuobB8v6Y0RcZEkRcRzkn5aansAAADdUv+iYWenSPof29fZvs/2P9ieU3B7AAAAXVEy\n", + "oZop6QxJfxcRZ0h6RtLlBbcHAADQFSXvoXpS0pMRcU97+WuaJKFavXr1gcdDQ0MaGhoq2CUAAIBq\n", + "Hn74YW3fvr1SbLGEKiJ+YvsJ20si4mFJyyVtmRi3YsWKUl0AAAA4bEuWLNGSJUsOLN96660dY0v/\n", + "yu9P1CpXM1vSo5I+UHh7AAAA065oQhUR90t6XcltAAAAdFvJm9IBAAB+LpS+5DelqtO9Z6a9z5b2\n", + "KFUKJCMzRX7J6fRLlX3JxPb19VWOzZSRyPajVFmUvXv3Vo4tVUYi66mnnqocmynX0d/fXzk2Uyon\n", + "04ds25nPed++fUXazR6zeqUETlWZY0C2HFjmsxsdHS3Sj8xxa2BgoHKsJM2ZU312osz49UKZoV7H\n", + "GSoAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJpI\n", + "qAAAAGrqeumZErLlEDLxpcrUlCqJki0XUKpETEamz9n3lynvUSo2U3Zi9uzZlWOz45HZj0ZGRirH\n", + "7t69u3JsprRHZqwz5TekXAmcTGxm/EqVn8rGZ/bPzD6UKaOUKc+UPSZnygFl2s6UL8rsF9l9OVOq\n", + "JlOiKXN8yRwPM/tFJjYbnznGdVL0DJXtT9reYnuT7S/brr7HAQAANESxhMr2IkkflHRGRLxaUp+k\n", + "95baHgAAQLeUvOT3M0mjkubY3i9pjqQfFdweAABAVxQ7QxURT0n6G0n/JenHkp6OiDWltgcAANAt\n", + "JS/5DUn6U0mLJC2QNM/275XaHgAAQLeUvOR3pqTvR8T/SZLtb0g6R9KN44NWrVp14PHQ0JAWL15c\n", + "sEsAAADVPProo/rhD39YKbZkQrVN0p/bHpC0T9JySesmBq1cubJgFwAAAA7P0NCQhoaGDiyvWdP5\n", + "zqWS91DdL+l6SeslPdBe/flS2wMAAOiWohN7RsSnJX265DYAAAC6jdIzAAAANZFQAQAA1NT1Wn5H\n", + "on7ORCXrXGVqH2X7UULJuoaZek2ZdkvWVszUKcvUbCtVx6tUu1JuX+6F/SIzdnPnzq0cK0nHH398\n", + "5dh58+ZVjs18FsPDw5VjM/USpVzNxMx3KrPPZcbkuOOOqxybrWGZic/EZuqgZmTfX2afy/z9LXUM\n", + "z/6NyihVw7ITzlABAADUREIFAABQEwkVAABATSRUAAAANZFQAQAA1ERCBQAAUFNPJlRVCxGiNzF+\n", + "zbVly5ZudwE1bN68udtdwGG65557ut0F1NSTCdVjjz3W7S6gBhKq5tq6dWu3u4AaSKiai4Sq+Xoy\n", + "oQIAAGgSEioAAICaXHLa9yk3bndv4wAAAEkRMWlNm64mVAAAAEcDLvkBAADUREIFAABQU88lVLbP\n", + "t73N9nbbn+h2f9CZ7X+0vcP2pnHrXmr7dtsP215t+yXd7CM6s73Q9h22t9jebPuj7fWMYY+z3W/7\n", + "btsbbW+1fWV7PWPXILb7bG+w/a32MuPXYD2VUNnuk/Q5SedLOlXShbZf1d1e4RCuU2usxrtc0u0R\n", + "sUTSv7WX0ZtGJV0aEadJOlvSh9vfN8awx0XEPknnRcRrJb1G0nm23yDGrmkukbRV0tjNzIxfg/VU\n", + "QiXpLEmPRMTjETEq6auS3tHlPqGDiLhL0q4Jqy+Q9MX24y9Keue0dgqVRcRPImJj+/GwpAclnSTG\n", + "sBEiYk/74WxJfWp9Fxm7hrD9cklvlXSNpLFfjTF+DdZrCdVJkp4Yt/xkex2aY35E7Gg/3iFpfjc7\n", + "g2psL5J0uqS7xRg2gu0ZtjeqNUZ3RMQWMXZN8hlJl0l6ftw6xq/Bei2hYg6Ho0i05uRgTHuc7XmS\n", + "vi7pkojYPf45xrB3RcTz7Ut+L5f0JtvnTXiesetRtt8maWdEbNALZ6dehPFrnl5LqH4kaeG45YVq\n", + "naVCc+yw/TJJsv1LknZ2uT84BNuz1EqmboiIm9urGcMGiYifSvpXSb8qxq4pzpF0ge3HJH1F0q/Z\n", + "vkGMX6P1WkK1XtIrbS+yPVvSeyTd0uU+IecWSRe1H18k6eZDxKKLbFvStZK2RsTV455iDHuc7RPG\n", + "fgFme0DSr0vaIMauESLiiohYGBGnSHqvpO9ExPvE+DVaz82Ubvs3JF2t1k2W10bElV3uEjqw/RVJ\n", + "50o6Qa3r/X8h6ZuS/knSKyQ9LundEfF0t/qIztq/CvuupAf0wqWFT0paJ8awp9l+tVo3Lc9o/3dD\n", + "RFxl+6Vi7BrF9rmSPhYRFzB+zdZzCRUAAEDT9NolPwAAgMYhoQIAAKiJhAoAAKAmEioAAICaSKgA\n", + "AABqIqECAACoiYQKQNfZXtv+/8m2LzzCbV8x2bYA4EhiHioAPcP2m9Wa5PDtidfMjIjnDvH87og4\n", + "9kj0DwA64QwVgK6zPdx++ClJb7S9wfYltmfYvsr2Otv32/6jdvybbd9l+5uSNrfX3Wx7ve3Ntj/Y\n", + "XvcpSQPt9m4Yvy23XGV7k+0HbL97XNv/bvufbT9o+0vT+2kAaKKZ3e4AAOiF0jefkPTxsTNU7QTq\n", + "6Yg4y/Yxkr5ne3U79nRJp0XEf7aXPxARu9q17dbZ/lpEXG77wxFx+iTb+i1JvyLpNZJOlHSP7e+2\n", + "n3utpFMl/bektbaXRQSXCgF0xBkqAL3EE5ZXSHq/7Q2SfiDppZIWt59bNy6ZkqRLbG+U9B+SFkp6\n", + "5RTbeoOkL0fLTkl3SnqdWgnXuoj4cbTuidgoaVGN9wTg5wBnqAD0uo9ExO3jV7TvtXpmwvJbJJ0d\n", + "Efts3yGpf4p2QwcncGNnr0bGrdsvjpUApsAZKgC9ZLek8TeQr5L0IdszJcn2EttzJnndcZJ2tZOp\n", + "pZLOHvfc6NjrJ7hL0nva92mdKOlNktbp4CQLAKbEv7oA9IKxM0P3S9rfvnR3naTPqnW57T7blrRT\n", + "0m+248f/RPk2SX9se6ukh9S67Dfm85IesH1vRLxv7HUR8S+2X9/eZki6LCJ22n7VhLY1yTIAvAjT\n", + "JgAAANTEJT8AAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoKb/\n", + "B1nWRTATo8RuAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAES9JREFUeJztnVmMpNdVx3+nq6prX3qbnvG4x4tmsEYRkv1ikJyICIVo\n", + "/ELghcgSUmQC4gECgkiY8BIjeIiQEiFeIiA2CosSIZCjBAmwjQIYIRYjb4E4jqVZPNPdM91de9fe\n", + "fXmoOt/c/qZ6qaU9VfXdn/Sp9qvTM3+du5zlE2MMDscgzN1vAxzThxONY2CcaBwD40TjGBgnGsfA\n", + "ONE4BmZo0YjIFRF5V0R+KCLPjdMox2Qjw5zTiEgI+AHwCeAW8N/AM8aY74/XPMckMqyneRJ43xhz\n", + "zRjTBr4JfGp8ZjkmmfCQvzsPfGC9vgn8mP0FEXFHzVOOMUb6vT+sp3GCCDDDiuYWsGa9XqPrbRwB\n", + "YFjRvA5cEpGHRWQe+DTw7fGZ5ZhkhlrTGGM6IvKrwD8CIeAFt3MKDkNtuU80sFsITz3jXgg7AowT\n", + "jWNgnGgcA+NE4xgYJxrHwDjROAbGicYxME40joFxonEMjBONY2CcaBwDM2wSFgAicg0oA3tA2xjz\n", + "5DiMmnbm5uYQEe8xHA4TCoUIh8OEw2H29vYOXPv7+weuSS+VHkk0dJOxPm6MyY/DmFkhHA4zPz9P\n", + "NBplfn6eTCZDJpMhm82SyWSo1+tUq1Xvqtfr1Ot1Go0G9XrdG2dSxTOqaAD6RkKDTCQSIZFIkEgk\n", + "SKVSnD17lnPnznHu3DkeeOABisUiW1tb3Llzh62tLUqlEqVSCYBms8ne3h4AIjKRwhmHp3lVRPaA\n", + "PzbG/OkYbJp6wuEw8XicbDZLNptlbW2NixcvcunSJS5evMjt27e5ceMG169f97wRQKvVolKpTPwU\n", + "NaponjLGbIjICvCKiLxrjHltHIZNGyJ3HW40GiWVSrG4uMjKygpra2s8+uijPPbYY1y+fJnFxUVi\n", + "sRihUMj7bbvdplqteusgmNHpyRiz0XvcEpGX6Ja2BE40/oVvKpViZWWFBx98kAsXLrC2tsby8jKJ\n", + "RAIRIR6Ps7CwwPnz573fNJtNisUioVCITqcDzKBoRCQBhIwxFRFJAp8Efndslk0RKphQKEQoFCKd\n", + "Tnse5tKlS6yurrK0tEQymUREiMViLCwsICIkEglarRaFQoH19XVCoZC3lpnFNc0q8FLPlYaBvzLG\n", + "vDwWq6YMEfG21KFQiFQqxfLysica3TWpp1HRJBIJlpeXqVarrK+vk0qlPNFMqmBgBNEYY64Cj4/R\n", + "lqlFvUwkEmF+fp50Os3i4iKrq6usra0Rj8e9LbiIEIlECIVCxONxjDEsLi6SSqWIRqPedKXXJDKO\n", + "LXfgCYfDxGIx4vE4iUSCdDpNKpUiHo8TjUaJRCKEw2Hm5roH8O12m2azSbPZpNVqkc/nqVarNBoN\n", + "77DPGDN7nsZxl1AoRCwWI5VKkU6nyWQyJJPJvqLRnVKtVqNSqVCtVsnn81QqFU80xpiJ3nY70YyB\n", + "cDhMNBolmUySzWZJp9Mkk0kSiQTRaJRwOOwtlqHraXZ3dymVSuTzeU80erA3yYIBJ5qxoCfAmUyG\n", + "paUlcrmcNz3p+sVGPU2hUODOnTsHPI0tmEkVjhPNEOgCVR/j8Ti5XM5b+K6urpLL5YjFYn0Xs+pp\n", + "isWiJ5pqtUqz2Zx4wYATzdDYOxxbNA899NAB0fRDReP3NM1mc+KnJnCiGRoVzNzc3AHRXLhwgaWl\n", + "JbLZ7JGeplarHelpJhknmiFQseilwcmVlRXOnz/vbbmj0Wjf359keppknGiGQA/y9EqlUt52O5VK\n", + "ebsmewFsi6HdblOv1ymXyxQKBcrlMrVajXa77UQzq4RCIebn54nFYt5W2xaOpjvoVltRQahoKpUK\n", + "+XyecrlMvV53opll1NPEYjEv0coWjcag9FzGPt01xhwQTaFQoFqt0ul0vOSrSefYxHIReVFEbovI\n", + "O9Z7iyLyioi8JyIvi0judM2cLEKhENFolHg87k1JyWTSO9CLxWL3nM8YY7yc4Far5aV8lkolL4Qw\n", + "LZ7mJNUIfwZc8b3328ArxpgfAf6p9zoQiAjz8/MkEglyuRzLy8vkcjmSySTz8/OH7pYajQbVapVC\n", + "oUClUpmq6cjPsaLpZeIVfG//NPD13vOvAz8zZrsmGj0B1h1TNpslkUgQiUT6fn9vb+/AdGSvYaaR\n", + "Ydc0q8aY273nt+nm1gSGSCRCMpn0PM1xoul0Op6nKZVKVCqVqdot+Rm5WM50/+rp+8tHwPY0tmg0\n", + "QdyPvcXe2dmhVCoFUjS3ReQsgIicA+6Mz6TJR/NnUqkU2WyWVCp1IFEc7u6Y9vf3qdfrFItFNjY2\n", + "uH79Ouvr6xQKBer1eqBE823gM73nnwG+NR5zpgM7FUIXwbFYjHC4O9urYPRqNBoUCgU2Nze5evUq\n", + "Gxsb5PN5arXabIpGRL4B/DvwmIh8ICLPAl8CfkpE3gN+svc6MBzmaVQ0it/TbG5ucu3atan3NMcu\n", + "hI0xzxzy0SfGbMtEo1vpubk572BPRZNMJg8kW9lTkzHmgGhu3LhBsVj0ynFnUjQOvML9cDhMJBI5\n", + "UJetouk3PWlBv+YE64FerVaj1Wp5qZ3ThhPNMWjXh2g0SiwWIxaLeYLRS2NQtmjsLhC65a7Vap6H\n", + "UdFMI040J0DXMBqY9HeB0JCBf/e0v7/P3t7eAU+zu7tLvV73QgrO08wo9m7J9jB6+UMHtqfpdDr3\n", + "TE+tVus+/SXjwYnmBGiAUmua+uXL2LRaLXZ3d71ra2uLcrlMs9n8kC0/HZxojkHXNBqkPIloms2m\n", + "F2fK5/Nsb297OcDTOB35caI5AX5Po2W2R3maSqXC9vY2m5ubbG9vUy6XaTQaMyEa16jxBOiaxu9p\n", + "/Id5iopmZ2eHjY0NTzRuegoQmt6pSVcanFRP4w8baHBye3ub9fV1Nz0FDW0jctj0JCL3dOes1WqU\n", + "SiW2t7fv8TRONAHBnp76VRvYZzKacKWiWV9fp1gsep5mFhg2R/h5EbkpIm/0Ln866Eyh09NhC2Fb\n", + "NJ1O5x7RzJqnGTZH2ABfMcY80bv+Yfym3T/8XSByuRyLi4ssLy9z5swZFhYWvJxgOHiYpyfA/h40\n", + "nU6H/f39+/yXjYeTRLlfE5GH+3w0mW2aRsQfa0okEiwsLLC0tMTKygpnzpzxqg80vdPvafQUuNVq\n", + "0Ww2abfbU9FC5KSMsuX+nIi8JSIvzFoJix1rymaznmiO8jRaomILxhbNLHmaYUXzVeARuj33NoAv\n", + "j82i+4x6mn6iWVlZ8TpCDOJpAjc99cMY4+UEi8jXgO+MzaIJwG68qJdWTGrVJNxNzLKrDez7HUxr\n", + "4vhxDOVpesnkys8C7xz23WnE7gtspz30Ewzg7Ziq1aq3vW40Gl4T6VnjWE/TyxH+CWBZRD4Avgh8\n", + "XEQep7uLugr88qla+SFj9wXWy24/70+FUE8zK8VwxzFsjvCLp2DLxHCUpzms7NZf0F+v1+l0OjM5\n", + "PbkTYR92rXY2m2VpaYlMJuM1XYT+JSpaCLexscHOzo7XpGgWcaLpg7/sNpfLkUgk+uYAG2Oo1Wpe\n", + "gFJjTbMUNvDjRONDPY2KRgv8D9tia12THTbY2dmhXC7TarXc9BQUbNH0K/A/KkC5sbHhFfk7TzPD\n", + "2Pdr0vWMNpLudwLsjzHV63WvbX2pVGJ3d5dmsxncLXcQsO/VZAcq9c5wmnhlexq7ykBrmnZ3d72d\n", + "k4rGTU8ziHoYPY+xRaOeJhqNejfGAPrWM6loKpWKF2ua1mK44wi8aOCup9GOnVqjraKxpy/gnnom\n", + "u3pyGm5cOipONPSva9JEK7utqz5qDz1dw2gf4Far5W3FZ5nAi8Yf1dZ7NdldIGy0pau2qZ+FzlaD\n", + "EnjRQPcwzy679Zeo+IWjotEDPVs0QeDIKLeIrInId0Xkf0XkeyLya733Z6aPsO1ptLhfPY1WG/hR\n", + "0ZRKpXs8TRA4LjWiDfyGMeYjwI8DvyIil5mxPsK6e9Ibl9r5M3B44vjW1pZ3AjzLh3l+jhSNMWbT\n", + "GPNm73kV+D5wnhnrI9wvqm1HtP2pnPa9mm7dujVzFZTHceI1TS+5/AngP5mxPsL98mfsqcluG9Lp\n", + "dA7cdufmzZuUy+WZKlE5jhOJRkRSwN8Cv26MqfjuLGJEZGr/pex7N+kUdZin0QM9WzS3bt2i0Wh4\n", + "+cBB4CTFchG6gvkLY4y2fp2pPsKHbblDodCB9YwKQ0+B9STYLlMJAsftngR4Afg/Y8wfWh/NTB9h\n", + "ESESiRCPx8lkMiwsLHgtXu2wga5nGo3GgbIUDRfM+imwzXHT01PAzwNvi8gbvfe+QLdv8F+LyGeB\n", + "a8DPnZqFHwLatj6dTrOwsOCV3uo5jYrGLklptVqed1HRBIUjRWOM+TcO90Yz0Ue4n6dJp9MHWrz6\n", + "A5R+T2Nn8QWBQDc10jveanu0eDzu9QSORCKHntOod1EPo4IJimgCGUawA5D2+YzeLU4DlXadk783\n", + "sC2UIAkGAuxp7Juxa1qEFv1r7oz/HpR263p/crl+LwgE0tModgLWqJ4mSATa0yj2QleL9e1u4v6k\n", + "K7t1SBAJrKexpxT73gWVSsVLytLDOhWNZumpcIIqmsB6GkVF02w2+97wQkMI6oXspHEnmoDiF43e\n", + "/ti+S4rtafSzIIUN/AR+etrf3/dqsbe3t0mlUgAHKhQ0D7hSqRzoPeNEE0B0R1Sr1SgUCqyvrwN4\n", + "gtDPd3Z22NnZ8XrPaJDSiSZAGGMOpD3UajXy+TzGmANFbvqdYrHoXX7RBG27DceIRkTWgD8HztBt\n", + "YPQnxpg/EpHngV8Etnpf/cK0tYW1p6darQbg9ZgxxnjT09zcHJVKxUu0sstVnKfpj+YIv9lLxPof\n", + "EXmFu32Ev3LqFp4yWpKiTYja7bZXjTA3N+clXWkFpSZg7e7uTv3NvobluCj3JrDZe14VEc0Rhhnq\n", + "I6y7I+ge+hWLRcLhMJ1Ox0vj1POZRqPhTVNBFY2cdE7u5Qj/C/AR4PPAs0AJeB34vDGm6Pv+1Ez2\n", + "dufOUCjkNZfW+yCoB9JHO2uvXq/fb/NPDWNMX8dwItH0pqZ/Bn7fGPMtETnD3fXM7wHnjDGf9f1m\n", + "akRjR701VUK7SITD4XuClBpC0PSIWWVo0fRyhP8O+Htfyqd+/jDwHWPMj/renxrROPpzmGiGyhGe\n", + "9T7CjqM50tOIyEeBfwXeprtjAvgd4Bm6Le69PsJWHZT+1nmaKWekNc0wONFMP0NNTw5HP5xoHAPj\n", + "ROMYGCcax8A40TgGxonGMTBONI6BObVzGsfs4jyNY2CcaBwDc6qiEZErIvKuiPxQRJ4bw3jXRORt\n", + "EXlDRP5riN+/KCK3ReQd672h29seMt7zInKzZ+MbInJlgPHG2oL3iPGGthG499Z647qAEPA+8DAQ\n", + "Ad4ELo845lVgcYTff4xus8l3rPf+APit3vPngC+NON4Xgd8c0r6zwOO95yngB8DlYW08YryhbTTG\n", + "nKqneRJ43xhzzRjTBr4JfGoM4w6dZmqMeQ0o+N4eur3tIePBkDaaMbfgPWK8oW2E052ezgMfWK9v\n", + "ctfgYTHAqyLyuoj80ohjKafR3vZzIvKWiLwwbDf3cbfgtcb7j1FtPE3RnMZe/iljzBPA03S7p39s\n", + "nIObrh8f1e6vAo/QzTfaAL486AD+Fryj2tgb729641VHtfE0RXMLWLNer9H1NkNjjNnoPW4BL9Gd\n", + "AkdlrO1tjTF3TA/ga4PaOO4WvNZ4f6njjWrjaYrmdeCSiDwsIvPAp+m2kh0KEUmISLr3PAl8kvGk\n", + "mY61ve0oqbDjbsF7aum6o+xmTrB6f5ruiv19ulWYo4z1CN0d2JvA94YZD/gGsA606K63ngUWgVeB\n", + "94CXgdwI4/0C3YrUt4G3ev+5qwOM91Fgv/c3vtG7rgxr4yHjPT2KjcYYF0ZwDI47EXYMjBONY2Cc\n", + "aBwD40TjGBgnGsfAONE4BsaJxjEwTjSOgfl/g7yNWl4b+UcAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEnFJREFUeJzt3X2QXXV9x/HPJ5tkN0/EoQnZDSQNLVAeBjGpMoAIUm2H\n", + "MoK2tSJtFWzHTketKVVGZKb9qx2tTEfqOO2MhaLgU1u0qNOC0EoRYyVCNg8QHjvShDzSAiFLks0m\n", + "fPvHvRs2y272fHP2t/fe8H7NMNxz73d/53fP75zDl3PO/X0dEQIAAMDRm9bqDgAAAHQ6EioAAICa\n", + "SKgAAABqIqECAACoiYQKAACgJhIqAACAmqa3cuW2mbMBAAB0jIjwWO8XTahsXyrpJkldkm6OiL8a\n", + "HXPNNde85u/6+/u1fPnyo15vdm6tV1555ZiNzW6LgwcP1u7H448/rtNPP/2w9w4cOFCkD5l2s/FD\n", + "Q0OVYwcHByvH7t+/v0i7WfZrzwnPPfecFi5c+Jr3p08vc6rI7J/79u2rHLt3795UPzLxmfHLxGb2\n", + "t7HGTmpsz7E+mzFjRuW2u7u7K8f29PRUjp05c2bl2K6ursqx422L8ZSae7HuOW5gYEBz586tFDtZ\n", + "/WiX/+60ul2p+n708ssvj/tZsVt+trskfVHSpZLOlHSV7TNKrQ8AAKBVSj5Dda6kpyPimYgYkvRN\n", + "Se8uuD4AAICWKJlQnShp84jlZ5vvTai3t7dIhzA1FixY0Oou4CjNnj271V0AXpcyt0TRnkomVEd9\n", + "s7Ovr28y+4EpRkLVuebMmdPqLqCG7PNEaB8kVJ2v5EPpWyQtGbG8RI2rVIfp7+8/9Lq3t5dkCgAA\n", + "tIWDBw9W/mFAyYTqIUmn2l4maaukKyVdNTqozq/5AAAASunq6jrsV6dH+jVusYQqIg7Y/pik76sx\n", + "bcItEfFYqfUBAAC0StF5qCLiLkl3lVwHAABAq7V0pnRJmjVr1qS3OW1a7ln7zIOcmbYzk9NlJt4r\n", + "1W627cy2yPQjM4lk9vtlJiLMxGb240xsqe2WVeoYycRmxiO7LTL7fSY286BxqYkvpdz4ZbZdph+Z\n", + "djM/jsieAzLbIjOpZqkJX7OT+2a+XyY2M7FnKdk+ZCY5rbqdTznllHE/o5YfAABATSRUAAAANZFQ\n", + "AQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANREQgUAAFATCRUAAEBNJFQAAAA1kVABAADU1PJa\n", + "frt3764Ul6kDla3jVap2Vabu0NDQUOXYTH2pkrWPSvUjIorESuVqMWb2oZI12zIy45fZLzJjkhmP\n", + "zHYrWcOyu7u7cmymz5ntlhk7KVc7LtN2qX1o7969lWMz504p1+dM25lzXKn9Xsrtn5m6oqXOW6Xq\n", + "x0q5Yyq7H42l6BUq20ts32f7UduP2P54yfUBAAC0QukrVEOSro2ItbbnSnrY9r0R8Vjh9QIAAEyZ\n", + "oleoImJ7RKxtvh6Q9JikxSXXCQAAMNWm7KF028skLZf04FStEwAAYCpMSULVvN13h6SVzStVAAAA\n", + "x4ziv/KzPUPStyR9NSLuHP35unXrDr1etGiRent7S3cJAABgQps2bdKmTZsqxRZNqGxb0i2SNkbE\n", + "TWPFnHPOOSW7AAAAcFSWLl2qpUuXHlpetWrVuLGlb/m9VdLvSbrEdn/zn0sLrxMAAGBKFb1CFRE/\n", + "ErOxAwCAYxzJDgAAQE0tLz2Tmfq+qmy5lcHBwWJtt1rjMbYy8ZnYnp6eyrGlyhZIudIF2W3XaTKl\n", + "JDLHaclSElXt27cvFZ8pzVK1XJaUK0mU2cbz5s2rHJuNz5Y6qSpTBiRzTs6OdbZcVVWZckezZ8+u\n", + "HJs5d0rljr9M6aBMbObYy+wXUq6EUbac01i4QgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQ\n", + "EwkVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAAQE0tLz0zMDAw6W12YjmSTDmETPmbbJmFUm1n\n", + "SgBk2s1+v1LbuVRspixDtgRHZkwypSQy5Va6u7srx2ZKomT6IOXOGZNRomIsmT5nv18pmXNnZr/P\n", + "jEemjIuUK/GT2T9LbYuhoaHKsdm2M/tyJjZzni1Z4iuzH01GP8Y9Km3/lqSQNNZaIiK+XWUFtrsk\n", + "PSTp2Yi4/Kh6CQAA0MaO9L85l6uRUI2nUkIlaaWkjZJy1TwBAAA6xLgJVURcU7dx2ydJukzSX0r6\n", + "07rtAQAAtKMJb/ra7rV9i+27m8tn2v6Diu1/XtJ1kqrf1AUAAOgwVZ6i+7KkeyQtbi4/Jenaif7I\n", + "9rsk7YyIfo39HBYAAMAxocpPRRZExD/avl6SImLIdpWf/Fwg6Qrbl0nqkXSc7dsi4oMjgzZs2HDo\n", + "9QknnKBFixZV7z0AAEAhW7du1bZt2yrFVkmoBmz/3PCC7fMk7ZrojyLiBkk3NP/mYkmfHJ1MSdLZ\n", + "Z59dqaMAAABTafHixVq8ePGh5TVr1owbWyWh+oSk70n6Bds/lrRQ0nuPol+5CYMAAAA6xIQJVUQ8\n", + "bPsiSb+kxrNQT0REaqaxiLhf0v1H10UAAID2NmFCZXuWpI9IulCNq0wP2P67iMhNywwAAHCMqnLL\n", + "7zZJL0n6ghpXqH5H0u2SfrtgvwAAADpGlYTqrIg4c8TyD2xvnLQOFKhJla3JU6qWUKbdTB2oTE2z\n", + "TLtSrs/tsN1Kaof6ipnjIzvWM2bMKBKb+X6Dg4NFYnfv3l05VsrVS8vUNCtV1zB7jGTGpFStwozM\n", + "vpypdynlal5mtkVmn8vUsN2zZ0/lWKk99uV2iJVyx1QmdjxV9to1ts8fXmj+yu/h2msGAAA4Rhyp\n", + "OPKGETGrbG9W4xmqpZKemIK+AQAAdISJiiMDAABgAkcqjvzMyGXbJ6gx4zkAAABGqFIc+QrbT0n6\n", + "mRpzST0j6a7C/QIAAOgYVR5K/wtJ50t6MiJOlvQOSQ8W7RUAAEAHqZJQDUXE/0qaZrsrIu6T9ObC\n", + "/QIAAOgYVSZ1eMH2PEkPSPqa7Z2Sqk+iAQAAcIyrcoXqPZL2SLpW0t2Snha/AAQAADikSnHk4atR\n", + "ByV9uWhvAAAAOtCRJvYcUGMiz7FERBw3GR2oWkYlU9ojK1OWoVQJh0y72VILGSW3c1WlxkPKjUkm\n", + "NrPdDhw4UKTdbOmZrq6uyrGZ0jMZmW2R2e8z7Uq5sjalxq9dZL5fJjazf5YsgZUpX5I5RkqVzMqU\n", + "GsvKfL/MvpyJzZTKyR5Ppfbl8RxpHqq5dRu3/QZJN0s6S43k7Pcj4id12wUAAGgnk1+Z+HB/I+nf\n", + "IuK9tqdLmlN4fQAAAFOuWEJle76kt0XE1ZIUEQck7Sq1PgAAgFbJPXSRc7Kk52zfanuN7b+3Pbvg\n", + "+gAAAFqiZEI1XdIKSX8bESskvSzp+oLrAwAAaImSz1A9K+nZiPhpc/kOjZFQrVmz5tDrvr4+9fX1\n", + "FewSAABANbt27dKuXdWeViqWUEXEdtubbZ8WEU9KeqekR0fHrVixolQXAAAAjtr8+fM1f/78Q8ub\n", + "N28eN7b0r/z+WI1yNTMl/bekDxVeHwAAwJQrmlBFxDpJbym5DgAAgFYr+VA6AADA60LpW34TypbL\n", + "qCJTMkTKlS8pVUoiU7agVAmHbNul2s2UhihZbqXUfrFv377Kse1S5iSznbu7uyvHzplTfa7fnp6e\n", + "yrHZUjmZ8h6Z7VyqpE225FKpfblkmaiqSpV8ybad2Ycy+2epc7JUbr8o9d+okuf7qlatWjXuZ1yh\n", + "AgAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioAAICaSKgAAABqIqECAACoiYQK\n", + "AACgppaXnhkaGqoU1w7lYaTcNPmlptTPTKefLcuQKfuSKZ9QogRAaaVKZcydO7dybKacRcltXPU4\n", + "laT9+/cXaXdgYKBy7KxZsyrHSrmxzozJvHnzivQhW14rc07MxGbGL1Nyac+ePZVjMyV7sm1ntkXm\n", + "fJiJzZRcknKln0qV+crsn6XOLdm2M7HjKXqFyvanbT9qe4Ptr9uuPtIAAAAdolhCZXuZpA9LWhER\n", + "Z0vqkvT+UusDAABolZK3/F6SNCRptu2DkmZL2lJwfQAAAC1R7ApVRDwv6a8lbZK0VdKLEfHvpdYH\n", + "AADQKiVv+f2ipD+RtEzSYklzbf9uqfUBAAC0Sslbfm+W9OOI+D9Jsv1tSRdI+trIoP7+/kOve3t7\n", + "1dfXV7BLAAAA1Wzfvl3bt2+vFFsyoXpc0p/ZniVpn6R3Slo9Omj58uUFuwAAAHB0ent71dvbe2h5\n", + "/fr148aWfIZqnaTbJD0kabgHXyq1PgAAgFYpOrFnRHxO0udKrgMAAKDVKD0DAABQEwkVAABATS2v\n", + "5ZetNVdFpj5RVqaeUYnvlm03W48uUyspE5upiVWybmOm7cx2LlVHr1StrWx8ZjtnaquV2i8GBwcr\n", + "x0q52mqZMdm7d2/l2F27dlWOfemllyrHSrntka2NV1WmxlymFmN2v88cq6WO60ytu0wNRCk3fu1w\n", + "Ds/EZscjE5/ZP8fDFSoAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAamrLhGrbtm2t\n", + "7gJqYPw615YtW1rdBdTw/PPPt7oLOEo7duxodRdQU1smVFUrO6M9kVB1rq1bt7a6C6iBhKpz7dy5\n", + "s9VdQE1tmVABAAB0EhIqAACAmpwtTTKpK7dbt3IAAICkiBizLllLEyoAAIBjAbf8AAAAaiKhAgAA\n", + "qKntEirbl9p+3PZTtj/V6v5gfLb/wfYO2xtGvHe87XttP2n7HttvaGUfMT7bS2zfZ/tR24/Y/njz\n", + "fcawzdnusf2g7bW2N9r+TPN9xq6D2O6y3W/7e81lxq+DtVVCZbtL0hclXSrpTElX2T6jtb3CEdyq\n", + "xliNdL2keyPiNEn/0VxGexqSdG1EnCXpPEkfbR5vjGGbi4h9ki6JiDdJeqOkS2xfKMau06yUtFHS\n", + "8MPMjF8Ha6uEStK5kp6OiGciYkjSNyW9u8V9wjgi4gFJL4x6+wpJX2m+/oqk90xpp1BZRGyPiLXN\n", + "1wOSHpN0ohjDjhARe5ovZ0rqUuNYZOw6hO2TJF0m6WZJw78aY/w6WLslVCdK2jxi+dnme+gciyJi\n", + "uIbCDkmLWtkZVGN7maTlkh4UY9gRbE+zvVaNMbovIh4VY9dJPi/pOkmvjHiP8etg7ZZQMYfDMSQa\n", + "c3Iwpm3O9lxJ35K0MiJ2j/yMMWxfEfFK85bfSZIusn3JqM8ZuzZl+12SdkZEv169OnUYxq/ztFtC\n", + "tUXSkhHLS9S4SoXOscN2ryTZ7pNEgao2ZnuGGsnU7RFxZ/NtxrCDRMQuSf8q6ZfF2HWKCyRdYftn\n", + "kr4h6Vds3y7Gr6O1W0L1kKRTbS+zPVPSlZK+2+I+Iee7kq5uvr5a0p1HiEUL2bakWyRtjIibRnzE\n", + "GLY52wuGfwFme5akX5XUL8auI0TEDRGxJCJOlvR+ST+IiA+I8etobTdTuu1fl3STGg9Z3hIRn2lx\n", + "lzAO29+QdLGkBWrc7/9zSd+R9E+Slkp6RtL7IuLFVvUR42v+KuyHktbr1VsLn5a0WoxhW7N9thoP\n", + "LU9r/nN7RNxo+3gxdh3F9sWSPhERVzB+na3tEioAAIBO0263/AAAADoOCRUAAEBNJFQAAAA1kVAB\n", + "AADUREIFAABQEwkVAABATSRUAFrO9qrmv3/e9lWT3PYNY60LACYT81ABaBu2367GJIeXJ/5mekQc\n", + "OMLnuyNi3mT0DwDGwxUqAC1ne6D58rOS3ma73/ZK29Ns32h7te11tv+wGf922w/Y/o6kR5rv3Wn7\n", + "IduP2P5w873PSprVbO/2ketyw422N9heb/t9I9r+T9v/bPsx21+d2q0BoBNNb3UHAECvlr75lKRP\n", + "Dl+haiZQL0bEuba7Jf3I9j3N2OWSzoqI/2kufygiXmjWtltt+46IuN72RyNi+Rjr+k1J50h6o6SF\n", + "kn5q+4fNz94k6UxJ2yStsv3WiOBWIYBxcYUKQDvxqOVfk/RB2/2SfiLpeEmnND9bPSKZkqSVttdK\n", + "+i9JSySdOsG6LpT09WjYKel+SW9RI+FaHRFbo/FMxFpJy2p8JwCvA1yhAtDuPhYR9458o/ms1cuj\n", + "lt8h6byI2Gf7Pkk9E7Qbem0CN3z1anDEewfFuRLABLhCBaCd7JY08gHy70v6iO3pkmT7NNuzx/i7\n", + "4yS90EymTpd03ojPhob/fpQHJF3ZfE5roaSLJK3Wa5MsAJgQ/9cFoB0MXxlaJ+lg89bdrZK+oMbt\n", + "tjW2LWmnpN9oxo/8ifLdkv7I9kZJT6hx22/YlyStt/1wRHxg+O8i4l9sn99cZ0i6LiJ22j5jVNsa\n", + "YxkADsO0CQAAADVxyw8AAKAmEioAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKh\n", + "AgAAqOn/AVxVFcygFE4dAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAGNNJREFUeJztnVmM7Fldxz+na1+6qrqW7q5ebt+ZuTMDTEzgBU2AyAMh\n", + "Q0xAXyQkRoNofFA0SiLig6D4gCYQow9EZYlbQKOBgInKYETxwQUzw4CyzMxdeu/au/a1jw9dv8Op\n", + "ukvfWrvrzv+bnPyram7/51TVt37n9/ud3+97lNYaBw5GwdJlT8DB4sEhjYOR4ZDGwchwSONgZDik\n", + "cTAyHNI4GBljk0Yp9axS6rtKqZeUUh+c5qQcXG2ocfI0SikX8D3gbcAB8N/Ae7TW35nu9BxcRYxr\n", + "ad4IvKy1vq217gCfB941vWk5uMpwj/l3m8Ce9Xwf+GH7HyilnFTzgkNrre71+riWxiHEqxjjkuYA\n", + "2Laeb3NubRy8CjAuab4BPKmUuq6U8gLvBr40vWk5uMoYy6fRWneVUr8E/BPgAj7tRE6vHowVcj/U\n", + "jR1HeOExbUfYwasYDmkcjAyHNA5GhkMaByPDIY2DkeGQxsHIcEjjYGQ4pHEwMhzSOBgZDmkcjAyH\n", + "NA5GxrhFWAAopW4DZaAHdLTWb5zGpKYNpdTAY7fbjcvlMtezszO01macnZ0NDHkd4LLamIffg1KK\n", + "paUllFID87bnOitMRBrOi7HeqrUuTGMys4J8wEtLS7jdbiKRCMvLy0QiEUKhEN1ul06nY0az2aTR\n", + "aNBsNmk2m5ydndHr9cz1MuZvE8XtduPxeMzo9Xq0220zzs7OzN/OgkCTkgbgnjuhVwXyQbtcLlwu\n", + "Fz6fj5WVFdbX10mn0yQSCUOORqNBo9GgXC5zenpKuVwGoNPpoJSi0+lc6nuQ4fV6CQQCZnQ6Her1\n", + "OrVajV6vN3OrOA1L81WlVA/4Y631n05hTlOHUsosRz6fj3g8zvb2Nk888QRbW1tUq1UzKpUK2WwW\n", + "j8cDQLvdNkvDZViZ4fcgxA+FQoTDYZaXl2m1Wiil6PV6tFqtAeLMApOS5k1a6yOlVAp4Tin1Xa31\n", + "16cxsUkhX/TS0hI+n8/8KiORCOl0mu3tbR5//HF2dnY4PT01lqVUKqG1pt1uU61WzRcl/sNlvAeP\n", + "x4PP5zMjHA4TjUaJRqNEIhHq9TpKKbrdLvV63SylskxNm0ATkUZrfdS/ZpVSX+C8teXSSSNfsFIK\n", + "r9dLIpEglUqRSqVYXV1lZ2eH7e1tVldXiUQixlfpdrs0m03c7vOPRZ53Oh263e6ArzBLDPswy8vL\n", + "xONxEokEiUSCSCRCOBw2o1gs4vP50FpTr9cH3k+32536/MYmjVIqCLi01hWlVAh4O/DbU5vZmLA/\n", + "bDHliUSCnZ0dHnvsMa5du0YqlSKZTJJKpYhEIvR6PTqdDu12m3q9bpambrdLq9Wi2+2aX++83oPt\n", + "w4TDYdLpNNeuXePatWtEo1GCwSDBYJBAIMDJyQlnZ2fU63Xy+bx5L1rrmSxVk1iaNeALfRPqBv5K\n", + "a/2VqcxqQgyv/0KaZ555hqeffppQKEQwGCQUCuHz+cyH3Gq18Pv9d1kaCWXnRRpgwHlfXl5mfX2d\n", + "J598kte97nXEYrG7lqt6vU6xWOTg4IBGo2EIM4sldWzSaK1vAa+f4lwmgu3D2D5ANBollUoZx/ep\n", + "p54a+BVrrc1VTLodfrfb7bm/F3HavV4vXq/XRHs7Ozs89dRTRCIRQ6qlpSWq1SqRSIRAIIDH45m5\n", + "DzaNkPvSIR+QECYWi5mRSqXY2dkhlUoRDodxu920221DiGazyeHhIUdHR2bs7e2Ry+Wo1+uX8n68\n", + "Xi/Ly8tmbGxskEwmiUajBAIBAOr1ukkV7O7ucnx8TLFYpFar0Wq1aLfbM4uiFp409vrvcrnw+/2s\n", + "rKyQTqdJp9Nsbm5y/fp1VldXCYfDuFwuut2uCa9LpRJ7e3tm7O/vk8/nKRQKl0qaSCRinPeNjQ1S\n", + "qZTxZTqdDrVazcxTSFMoFKjVajSbTeOHOaS5D4bzMLFYjI2NDR5//HEee+wx1tbWjKVxuVx0Oh2q\n", + "1Sq5XI5MJsPu7i63bt3i1q1b3Llzx/yCm83mpbwfmzTb29tsbm4a0tjJvGw2y97e3j0tjR1yTxsL\n", + "Txo7te71evH7/cRiMeMDPPHEEyanEQqFWFpaotPpUKlUyOVyHBwcmA/+9u3b3Llz59Leh/ggfr+f\n", + "aDTK6uoqW1tbrK+vE4/HCYVCuN1uut2uSULu7u5ycHBANpulVCrRaDRm7octPGkAY2ECgYDxAyKR\n", + "yABZfD4fLpcLrTWNRoNiscjR0RG7u7tkMhlOT09ptVqXMn+JkmREo1ESiQRra2tsbW2RSCRMlFcs\n", + "FsnlcuRyObLZLNlslkKhQKVSodVqzWVDdeFJI7vWPp+PYDBoCBOJRIjFYkSjURNJyY62kOb4+Jjd\n", + "3V1yudylkkYceImWIpEIiUSC9fV1tra2CIVCZu+rVCoNECaTyVAoFKhWq2ZZmjUeOdLIfoxtaexf\n", + "ca/Xo9FoUCqVjKWpVqvGF7gM2GkC2eqIx+Osra2xubmJy+WiVqtRr9ep1+sDpMlmsxSLRVqtlkOa\n", + "izCcl/H7/YRCIWNlpPwhHA4P1Ma0Wi0qlQqFQoFMJsPh4eFAXmbe81dK4fF4CAQCZlsgHo+bjPXa\n", + "2ppJD7TbbbM85fN5MyqVCr1eb+YblYKFI81wAZLs+MqvU/ZmAoEAbrebs7MzY0mq1SrFYpG9vT2y\n", + "2SyVSoVOp2O2COZVYDXsw9h7Y6lUihs3brCxsWGSeN1u15Rs5PN5isUi1WrVhNZ2sdg8sHCkgcEU\n", + "u9frJRgM3pc0vV6PWq1GJpMhl8txfHxsknfVapVOpzP3D932YTweD/F4nM3NTbO3tLW1RTqdJhKJ\n", + "mLzSMGkqlQqNRmNgX2weVXuw4KSxfRkhjZ05tS1NNpvlzp077O7uGksjpLFLPecBl8s14MMIaW7c\n", + "uMFrXvMaEokEsVjsoUgjlhLmV4p6IWmUUp8BfgzIaK1/qP9aHPhrYAe4Dfyk1ro0w3na8xn40CVi\n", + "isViJBIJkskkkUgEv99vHF8hzd7eHq+88gonJyfk83lqtdpMSgcuwrAfFo/HSafTXL9+naefftps\n", + "d3g8HrTWtFotarUap6enA6Sxl6e5zv8h/s1ngWeHXvsN4Dmt9VPAP/efzwUul4tQKDSwCSklD5ub\n", + "m6ytrRGJRPB4PCaJd3p6SrFYJJ/Pm/C6Xq9fWvmmXX0nDnsoFCIQCOD1eg1RTk9POTk54fj4eOAq\n", + "zu+88jLDuNDSaK2/rpS6PvTyO4Ef7T/+M+BrzIk4LpeLcDhMMpk0db6bm5tmpFIpPB4PbrfbRB3D\n", + "pKlUKtTr9UuxMvCDZGQoFCIajRrS+P1+Q5pms2lCbJswJycnZo9pXiH2XfMf8+/WtNYn/ccnnNfW\n", + "zAVLS0uEQiGSySRbW1vs7OyYzcl0Os3KyoqpWJM9pmHSNJtNWq3WlbI0wWDQkKbVatFsNs28hTCZ\n", + "TIaTkxMT9Q13HswLEzvCWms9T309l8tFMBgkHo+zsbHBtWvXWFtbMyMSiVCpVIw1qVarpva3UCiQ\n", + "z+dNOeS8CsXt8k1gwBdbWVkhGo0SDofN8iSbpaVSiePj4wErc5klG4JxSXOilFrXWh8rpdJAZpqT\n", + "ehjcby2XCjuxNFI7Yye/Zh0p2Yk7ON+A9Pv9BAIB/H4/6+vrbGxsmJFOp4nH4wSDQZRSNJtNCoUC\n", + "BwcHvPLKK2Z/rFqtXmpHhGBc0nwJ+Bng9/rXL05tRmPCJoNdgSc1vhJlzCu0tpOQgUBgoDAsnU4P\n", + "kCaZTLKyskIgEEApRaPRoFAosL+/z0svvcTx8TH5fJ5qtXopy9EwHibk/hznTm9SKbUH/BbwMeBv\n", + "lFLvox9yz3KSF8EmgVgau1hcugmGk2AzlMMdKA4LBoOsrKyYJVTIsrm5ycbGhtnuENLYluall14i\n", + "n8+bRr6FsDRa6/fc5z+9bcpzGQvDhLFJIxZGliX5Iu3Hw71BYx5lNPDYrt+VFIHkYiQ1YFsbr9dr\n", + "+soBY2kODw+5efOm6fS8KljIjPCDIG2rwWDQEGdzc9NU6IdCobsa/GWHWGprR4Xb7R4YUuIgY9iH\n", + "SSaTpqhKEnh2z3ipVDIh9VU8N/2RI400yEmVnpj7s7MzU3RuR09SBVcul6lUKlSr1ZH/n+Lo2g6v\n", + "9CQFAgHTpCdDCsUk8yu+lyxBUrZ5WSH1RXgkSePxeAx5JFnmdrsJh8Osrq4asojagpQa5HI50yg3\n", + "CuxuRxk2MeLxOCsrK8TjceLxuMnHyIaldEVI9rpUKlGtVk3D21XDQpPG9kPksU0WwCwBktupVCrG\n", + "15EOysPDQ4LBoGmSGxVSIWhfZUi/tT2G+5FkiSyXy+RyuQFL45BmCrAr705OTvD7/abJX9LxduQC\n", + "5z5HIBCg1+uZTUwZIiNiF3OPCrEuouQgVxnBYBCfz2dIOexTCVkODw/Z39/n4ODAbBU4y9MUIDW+\n", + "QhrZLZZlwC7vhB8sV36/HzhvD7G/sF6vh8/nIxKJkEwmp+LT+Hy+u557vV4zJ0k+Si5JOiMODw+5\n", + "ffs2h4eHJsx2LM0UYJPG7XYbVYWVlRXq9Trtdtv8om31K2lZHc4Ka62JRCImcppG9CTDlmiTq1LK\n", + "kEb6x21Lc/v2bVP361iaKcEmjSTr4vE4q6urA2GqXd0nX6LP57srpyKY5y9aSCMbk8OkOT09NZGU\n", + "Q5opQGttPnCXy8Xp6SlHR0f4/X601hQKhbuWBilokqu9hMhyZQs02vp1D7MTbveGdzodEz3Jddjx\n", + "FcUq2VCVUL9Wq9FoNMwO/DxLUEfBQpKm0+kMZHaPjo6MoM/x8bHJj0iuRHIn8ppENJIIlP0qCcWl\n", + "CF2+yItQq9XMqFarA8m8cDh8T9KIFo7kh6RFRUgjKYGriIUkjRRPiTOptaZWq5HL5Uxtiq1BIzUr\n", + "y8vLRKNRo6MXCATu2naQGpxisUihUKBUuriKtVgsDowbN24AGDGiYdiWRso4qtXqAGnmXew+Csat\n", + "Ef4I8HNAtv/PPqS1/sdZTdKGkEaI02g0qNVqZLPZgYo4O8kmSbWVlRWSyaQJsWOxmLmnkEa09gqF\n", + "gil8ughS6yKj2+0SDodZX1+/55cupKnVapTLZcrl8l2kucp4GEvzWeCPgD+3XtPAJ7TWn5jJrEaA\n", + "XT8jkPyMvWlpZ1wlxD06OiIejw+Ev51Oh0KhYEaxWLxwDpLFlUL14T4qe9ui1+tRLBbJZDIcHByw\n", + "v7/P4eHhlc7LDGPcGmG4QvrBNnHEzzk7OxvY06lWq8anyeVy7O/vm/pc+wsV7ZpRfBopH202m/ds\n", + "vLPFoaWJP5PJsLe3x82bN029TL1ev5LL0TAm8Wner5T6ac4Pdv/AvFpYhmFr4dkRkERYEqHYCt92\n", + "8k0cYTuCkvzJKHkb29kdLvYSAovAtSQm9/f3uXXrFoVCwXRIPMqk+STwO/3HHwU+DrxvKjMaA+KT\n", + "CGRrwMa98jP306QbtbZmOCNsE1lEoWVTslarGUuzv7/PzZs3zeakhNlXHWORRmttvEOl1KeAL09t\n", + "RlPC8Bc+y1+waOTZOn8icQKYzgLZTRcRonK5bHSK5yk5OynGIo1SKi3C08BPAN+a3pQWDxKJSTnn\n", + "+vo6sVjM7He1Wi3TWSAbkrlcjnK5TLvdvqfzfJUxTo3wh4G3KqVez3kUdQv4hZnO8opDpGfX1ta4\n", + "fv36XaSxlbdu3rzJ4eGhUa2QRN6iEAbGrxH+zAzmsrCwLc21a9cGSCOVgyKiJBuSInkm0q2LhIXL\n", + "CF8FSBQme1m2AJF0eUrxl123I86w7C3NS4Ro2nBIMwakElCG1P6KTyNbGCJ1Mpw8XCT/5V5wSDMG\n", + "pHBdNP1swqytrZmWFBFVsjPTw201iwiHNCNCKgGDwSCxWMwsTba1sZOMYmnsDVFb8mwR4ZBmDAhp\n", + "RH3L1iqWsxds/0UOIZPd7GazOdOzC2YNhzRjQNQ4ZQd9eXnZlJMCRu5M9q+KxaI5uU52s+XYwEWE\n", + "Q5oxIDXHYmnsY3MAc3ZBuVweqMuRgivZ2LwsUaVJ4ZBmDIilGSaNfbiYCCtKeYWQxhaHhMs753sS\n", + "OKQZA/dankQY8uzsbKBYXPaZpFh8kfaY7oeHEWp0MITh5WmYNI1Gg9PTU7OTLQd2NJvNhbQsw3As\n", + "zYiwZemFNKKXN3z2QjabfSRJ80BLo5TaVkr9i1Lqf5VS31ZK/XL/9bhS6jml1PeVUl9RSsXmM92r\n", + "AQm57eXJ5/OxtLRkSHM/S/Mo4KLlqQP8qtb6GeBHgF9USr2WS9QRvgwISaLRqJE6k7OxRVzRbrlt\n", + "t9sm5BYFCBGKfhQszQOXJ631MXDcf1xVSn0H2OQSdYTnDfvQDulwECn9YDA4IE0iFYRSmyylptIu\n", + "vKh5mWE8tE/TLy5/A/CfXKKO8GVABAKkFSaVShGLxQiFQqZDU6Iiux5YSGOLRT7ylkaglAoDfwf8\n", + "ita6MtQDPVcd4XlDLM3y8jKJRIJ0Ok0ymSQWixEMBvF6vYYMdhmEbWmktfdRIAw8XOWeh3PC/IXW\n", + "WqRfL11HeJ4Q0iSTSaOZJ2G2FI7b8mfVatUcQGpbF1uE2h5298Ii5HAuip4U8Gng/7TWf2D9J9ER\n", + "hiuiIzwr2JYmmUySTqdJJBIsLy8bta1OpzOQAS6Xy3cd2GGfHS7FW16v12jXiGzK/TokrhIusjRv\n", + "An4KeFEp9Xz/tQ9xxXSEZw3xaRKJBBsbG/ckjew13Ys0tq6wLRUrQ0omhltxriouip7+nftboyuh\n", + "IzxriIafbWlERmTY0sjZmOVy2RzgJfcY1suxdXNEAWMRCANORvihIF+4dGfaywkMhtoirmjndoY1\n", + "cWSpEjLVajWjHnFVxRltOKSZATweD6FQyEjbh0KhgfPChyv75ORe6SO/6s6wQ5opYFjDzy4HbbVa\n", + "rKysmKMSk8mkadMVy+Tz+YyY0qPgCDsYESJ0LZZGaz1wiMbGxoZxnBuNhjm7qVqtksvlHNK8WuB2\n", + "u40sbSwWw+VyDTwXSxOJRPD5fCZ7LMJGktNxHOFXESSPI1YmFouZRF+9Xjc5GXF6S6US+XzejKOj\n", + "IwqFwiMvNeLAgtfrNYdjBIPBu9Q+7VNe6vW6kRqRowbl2OR6vX7lnWBwSDMVSAgeDAYHBBblKod1\n", + "5HK5AX2ag4MD9vb2zHmbV1WhfBgOaR4Cw+KNtg8ie0f2LrfdFNfpdMjlcmSzWTOOjo7IZDLm8Ay5\n", + "n11wfpXhkOYCiD6xHA/o9/tN6CyJOFusWvSBbW3hUqk0MMSXkWo+u+tyEeCQ5gIIafL5vJFGs4/V\n", + "cblcxuGVIb1OoitsC1MPX6Wib5FEAR5IGqXUNudSsKucCxj9idb6Dy9TR3je0FrTaDTI5/MAZimR\n", + "SCkQCBgtYDmh7uTkxJylfXx8bEQf5Tq8fC1aD9RFlkZqhF/oF2L9j1LqOa6QjvA8ID6NUopOpzNw\n", + "bpMcvWOPTCYzMERexK7esx3lRcO4NcJwhXSEZw0RrxanVyRERFpfcjKyTA0fKSj+yrwOk5811MNO\n", + "vl8j/K/AM8AHgPcCp9xHR/hRKgGVsyZlDJ8iJ5GP5GZsEsnxO3YYDpMd6TwvaK3vaRgeijT9pelr\n", + "wO9qrb+olFrlB/7MR4G01vp9Q39zdT+NEWGXMSil7jr4azgvYyug20vQIhDFxtik6dcI/z3wD0Ml\n", + "n/LfrwNflsM2rNcX45NxcF/cjzRj1Qj3i8kFr3od4VcbHmhplFJvBv4NeJHziAngN4H3AAM6wlYf\n", + "lPytY2kWHBP5NOPAIc3iY6zlyYGDe8EhjYOR4ZDGwchwSONgZDikcTAyHNI4GBkOaRyMjJnlaRw8\n", + "unAsjYOR4ZDGwciYKWmUUs8qpb6rlHpJKfXBKdzvtlLqRaXU80qp/xrj7z+jlDpRSn3Lem1sedv7\n", + "3O8jSqn9/hyfV0o9O8L9pirB+4D7jT1H4O7m9WkNwAW8DFwHPMALwGsnvOctID7B37+Fc7HJb1mv\n", + "/T7w6/3HHwQ+NuH9Pgz82pjzWwde338cBr4HvHbcOT7gfmPPUWs9U0vzRuBlrfVtrXUH+Dzwrinc\n", + "d+wyU63114Hi0Mvv5FzWlv71xye8H4w5R631sdb6hf7jKmBL8I48xwfcb+w5wmyXp01gz3q+zw8m\n", + "PC408FWl1DeUUj8/4b0Es5C3fb9S6ptKqU+Pq+Y+bQle637/MekcZ0maWcTyb9JavwF4B+fq6W+Z\n", + "5s31uR2fdN6fBB7jvN7oCPj4qDcYluCddI79+/1t/37VSec4S9IcANvW823Orc3Y0Fof9a9Z4Auc\n", + "L4GT4kQptQ6mInEieVutdUb3AXxq1Dk+SIJ3nDla9/tLud+kc5wlab4BPKmUuq6U8gLv5lxKdiwo\n", + "pYJKqeX+4xDwdqZTZjpVedtJSmGnLcE7s3LdSaKZh/De38G5x/4y512Yk9zrMc4jsBeAb49zP+Bz\n", + "wCHQ5tzfei8QB74KfB/4ChCb4H4/y3lH6ovAN/tf7toI93szcNZ/j8/3x7PjzvE+93vHJHPUWjvb\n", + "CA5Gh5MRdjAyHNI4GBkOaRyMDIc0DkaGQxoHI8MhjYOR4ZDGwchwSONgZPw/UDzRgG/E2K8AAAAA\n", + "SUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAExNJREFUeJzt3X+QXWV9x/HPJwm7m80PIj8qJBsb28YijNZYYYI/Q7Ud\n", + "6ija1qq0FWs7djpqSakyIjPtjDPtaHU6UsdpZ6zUH/irrVrUaUVpJQpICIH8AAIaO6QlWhIaYsLu\n", + "ZpNN+PaPexOXZTf7fHPy7L03vF8zDPfc+73PefY85577zTnnPl9HhAAAAHDi5nS6AwAAAL2OhAoA\n", + "AKAhEioAAICGSKgAAAAaIqECAABoiIQKAACgoXmdXLlt5mwAAAA9IyI81fNVEyrbl0q6TtJcSZ+I\n", + "iL+eHLN27dqnvG/9+vVavXr15LYq9VJ64oknimMz83bVis2oud2m6/OGDRt00UUXPem5I0eOFLeb\n", + "GY9Mu9n4w4cPF8eOj48Xx46NjVWJnTMnd8K5r6/vKc89+OCDOu+884piT0Y/MmO9b9++KrHZ+JGR\n", + "keLYAwcOFMeejLEeGxvTwMDAU57v7+8vbnvBggVVYufPn18cO29eR/+tf0zmuHzw4MHi2KnG+tFH\n", + "H9XZZ59dFHuy+nHo0KEqsZnjYa3vhmz8yfgOrnbJz/ZcSR+TdKmk8yVdbvu5tdYHAADQKTXvobpI\n", + "0g8jYkdEjEv6oqTXVVwfAABAR9RMqJZJenjC8s72czMaGhqq0iHMjmXLioYZXeiss87qdBfQQLdc\n", + "KkPe4OBgp7uAhmomVCd8QZKEqreRUPUuEqreRkLVuzL3o6E71fz0/UjS8gnLy9U6S/Uk69evP/Z4\n", + "aGiIZAoAAPScmgnVRkkrba+Q9GNJb5J0+eSgyb/mAwAA6DXVEqqIOGz7XZK+qda0CddHxAO11gcA\n", + "ANApVS+4R8Q3JH2j5joAAAA6reN3ME41Cd1UMhN0ZSZklHITEXbDZJ01+5CZZC0Tm5norVsm9szI\n", + "TKBaus9n281M6CdJe/bsKY4dHR0tju2GiUuz+30mfu7cucWxCxcuLI5dsmRJcWxW5jOV2c6ZfS5z\n", + "XK45CWjm78scLzL7UKbPmeOFlNvnMvty5liU+ftq9SGrdP/cuHHjtK9Ryw8AAKAhEioAAICGSKgA\n", + "AAAaIqECAABoiIQKAACgIRIqAACAhkioAAAAGiKhAgAAaIiECgAAoCESKgAAgIZIqAAAABrqeC2/\n", + "3bt3F8X19fUVt3naaael+pCJz8Rm6g5l6kBlamJla9dl2s7U5+uGun9Sbjtnxi9THyxT5yoT29/f\n", + "XxybbTuz3w8ODhbH1qoxl6kPJtWr5ZfZxpnP3qFDh4pjJenAgQNV2s7UYhwZGSmOLf1ekPLbotYx\n", + "LrMvZ/ah7PdZ5jiQqZmY+Q6udTzMqvW9Op2qZ6hsL7d9i+37bd9n+8qa6wMAAOiE2meoxiVdFRGb\n", + "bS+UdLftmyPigcrrBQAAmDVVz1BFxCMRsbn9eFjSA5KW1lwnAADAbJu1m9Jtr5C0StKds7VOAACA\n", + "2TArCVX7ct+XJK1tn6kCAAA4ZVT/lZ/t0yR9WdJnI+LGya9v2rTp2ONzzjlH5557bu0uAQAAzGhs\n", + "bKz416xVEyq3fnd+vaRtEXHdVDGrVq2q2QUAAIATMjAwoIGBgWPL+/btmza29iW/l0j6PUmX2N7U\n", + "/u/SyusEAACYVVXPUEXEbWI2dgAAcIoj2QEAAGio46Vnli4tm5YqM61/Zrr5bHymhEq2H6Vqlb6Q\n", + "cqUIMqVZapX3yZZlyGy7TGytMkO12s22nYnthu2WKXMi5UqoZEpUZPbPRYsWFceeccYZxbGStHDh\n", + "wuLYTImRzHE5s92Gh8t/DL5///7i2Gw/Msf7zHbLjHVm7LL9yHxWM9sis40zn72DBw8Wx0rS6Ojo\n", + "SW/76quvnvY1zlABAAA0REIFAADQEAkVAABAQyRUAAAADZFQAQAANERCBQAA0BAJFQAAQEMkVAAA\n", + "AA2RUAEAADREQgUAANCQa5VHKVq5HVdeeWVR7Jw55blfZjp9KVceolZZjYxapUuken9fpt1M6YRM\n", + "bDY+U7Ynsw/19/cXx2Zkyj1k4zOfv0ypjNNPP704dsmSJcWxAwMDxbFSbvwOHTpUHJv5jGT6nCkR\n", + "JeVKxNSKHR8fL47NHOMWL15cHCvlyr5kt3OpTLmVTKyU23a1YjPH+5qlxmoc720rIqb8YE/bgu3f\n", + "khSSpnpjRMRXClc+V9JGSTsj4rUl7wEAAOglx0vJXqtWQjWdooRK0lpJ2ySV/7MAAACgh0ybUEXE\n", + "7zdt3PaQpFdL+itJf9a0PQAAgG40440Rts+xfb3tm9rL59v+w8L2PyLpaknlF9oBAAB6TMmdpp+S\n", + "9C1JS9vL2yVdNdObbL9G0u6I2KSp78MCAAA4JZTc1n5WRPyT7WskKSLGbZf8POjFki6z/WpJA5IW\n", + "2/5MRFwxMWj9+vXHHg8NDWloaKi89wAAAJWsW7dO69atK4otSaiGbZ95dMH2akn7ZnpTRFwr6dr2\n", + "e14h6T2TkylJWr16dVFHAQAAZtOaNWu0Zs2aY8vvf//7p40tSajeLenrkn7O9vcknS3pDSfQr85N\n", + "eAUAAFDRjAlVRNxt++WSflGte6G+HxHlM7S12viOpO+cWBcBAAC624wJle35kt4h6aVqnWW61fbf\n", + "R0Ru+lYAAIBTVMklv89I2i/po2qdofodSTdI+u2K/QIAAOgZJQnVBRFx/oTlb9vedrI6UFrzJ1NH\n", + "6MiRI6k+ZONryNT8ytRVy9byq1V/sNf6IOXqlNXah2rVmZRyteMGBweLYx977LHi2IMHDxbHZmrB\n", + "jYyMFMdm285s50wtuEyNuUydSaneMSPTj1qxmc9pNj7zud6zZ09x7P79+4tjR0dHi2OlXK3JjFrH\n", + "i0zsggULimOz8Zl+TKfkU3aP7YuPLrR/5Xd34zUDAACcIo5XHPneCTG3235YrXuoniXp+7PQNwAA\n", + "gJ4wU3FkAAAAzOB4xZF3TFy2/TNqzXgOAACACUqKI19me7ukh9SaS2qHpG9U7hcAAEDPKLkp/S8l\n", + "XSzpBxHxbEmvlHRn1V4BAAD0kJKEajwi/k/SHNtzI+IWSS+q3C8AAICeUTLZx17biyTdKulztndL\n", + "Gq7bLQAAgN5Rcobq9ZJGJV0l6SZJPxS/AAQAADimpDjy0bNRRyR9qmpvAAAAetDxJvYcVmsiz6lE\n", + "RCw+GR0YG+t8jeVMWZtM2YJa7XaLWiViam63TCmJTGymdEkmNtOHzHaTcuU9+vv7i2Mz+0VmW2TK\n", + "1GTLb2RK1dQav8OHD1eJzcockzPbIiOzD2VLLmXKOfX19RXHZsr7ZGT35Ux8zf2oVGb8siWXMvGZ\n", + "/WLa9U33QkQsbNq47SWSPiHpArWSsz+IiPVN2wUAAOgmuXQv728l/XtEvMH2PEm5yoYAAAA9oFpC\n", + "Zft0SS+LiLdKUkQclrSv1voAAAA6pc5F35ZnS3rU9idt32P7H2wPVlwfAABAR9RMqOZJeqGkv4uI\n", + "F0oakXRNxfUBAAB0RM17qHZK2hkRd7WXv6QpEqq77rrr2OOlS5dq2bJlFbsEAABQ5vHHH9fwcNlc\n", + "5tUSqoh4xPbDtp8TET+Q9CpJ90+Ou/DCC2t1AQAA4IQtWrRIixYtOra8a9euaWNr/8rvT9QqV9Mn\n", + "6b8kva3y+gAAAGZd1YQqIrZI4hQUAAA4pdW8KR0AAOBpofYlvxkNDAwUxWVKOGTLkWRKdmSmyc+U\n", + "T8jEZqbTz5ZlqNV2JjZTAiBTEkXK/X2ZMcnsQ5kyJ5nSENnSM7XGZHCwfHaUZzzjGcWxE+9jmMn8\n", + "+fOLY7PxmWPR6OhocWxmrDN9yKp1rM3EZsq4ZI9xGZljQOYzkulztqRNZjvXKplVq0Rbzf2+tB9X\n", + "XHHFtK9xhgoAAKAhEioAAICGSKgAAAAaIqECAABoiIQKAACgIRIqAACAhkioAAAAGiKhAgAAaIiE\n", + "CgAAoCESKgAAgIY6XnomWy7jVJUtL1Aqu30z8bVK62RKHBw8eLA4VsqVLqhVgqNWGZe+vr7i2KxM\n", + "WZQ9e/YUxz7yyCNV+rB48eLiWElasGBBcWxmTDIlbWqWUMnIlGfK7PcHDhyoEpvZLyRpeHi4Stu1\n", + "9ouFCxcWx0q5Ek2lpd+kXJ8z221sbKxKu1Lu+yGzz02n6hkq2++zfb/te21/3nau8BoAAEAPqJZQ\n", + "2V4h6e2SXhgRz5M0V9Kba60PAACgU2pe8tsvaVzSoO0jkgYl/aji+gAAADqi2hmqiHhM0t9I+h9J\n", + "P5b0k4j4j1rrAwAA6JSal/x+XtKfSlohaamkhbZ/t9b6AAAAOqXmJb8XSfpeROyRJNtfkfRiSZ+b\n", + "GHTHHXccezw0NKTly5dX7BIAAECZ7du3a/v27UWxNROqByX9ue35ksYkvUrShslBF198ccUuAAAA\n", + "nJiVK1dq5cqVx5ZvuummaWNr3kO1RdJnJG2UtLX99MdrrQ8AAKBTqk7sGREfkvShmusAAADoNErP\n", + "AAAANERCBQAA0FDHa/mV1njL1D/L1I2TcjW0MjX3arWb/ftqqVV/sGYfMvXuMrG16nhl2s3EZuMz\n", + "+1ymvltm/DLjka3ld+aZZ1Zp+9ChQ8Wxe/fuLY7N1EuUcjXNMjUs+/vLq4llaswtWbKkODZ7DMjU\n", + "KszEZo73teqgSrnaeCMjI8WxmTp6mXqs2fp8GZl9I5NjTLu+xi0AAAA8zZFQAQAANERCBQAA0BAJ\n", + "FQAAQEMkVAAAAA2RUAEAADTUlQnVww8/3OkuoIGHHnqo013ACdqyZUunu4AG7rnnnk53ASfotttu\n", + "63QX0FBXJlQ7d+7sdBfQwI4dOzrdBZygrVu3zhyErrVp06ZOdwEn6Pbbb+90F9BQVyZUAAAAvYSE\n", + "CgAAoCFHROdWbndu5QAAAEkRMWU9oI4mVAAAAKcCLvkBAAA0REIFAADQUNclVLYvtf2g7e2239vp\n", + "/mB6tv/R9i7b90547gzbN9v+ge1v2V7SyT5ieraX277F9v2277N9Zft5xrDL2R6wfaftzba32f5A\n", + "+3nGrofYnmt7k+2vt5cZvx7WVQmV7bmSPibpUknnS7rc9nM72yscxyfVGquJrpF0c0Q8R9J/tpfR\n", + "ncYlXRURF0haLemd7c8bY9jlImJM0iUR8QJJz5d0ie2XirHrNWslbZN09GZmxq+HdVVCJekiST+M\n", + "iB0RMS7pi5Je1+E+YRoRcaukvZOevkzSp9uPPy3p9bPaKRSLiEciYnP78bCkByQtE2PYEyJitP2w\n", + "T9JctT6LjF2PsD0k6dWSPiHp6K/GGL8e1m0J1TJJE+vO7Gw/h97xzIjY1X68S9IzO9kZlLG9QtIq\n", + "SXeKMewJtufY3qzWGN0SEfeLseslH5F0taQnJjzH+PWwbkuomMPhFBKtOTkY0y5ne6GkL0taGxGP\n", + "T3yNMexeEfFE+5LfkKSX275k0uuMXZey/RpJuyNik356dupJGL/e020J1Y8kLZ+wvFyts1ToHbts\n", + "nyNJts+VtLvD/cFx2D5NrWTqhoi4sf00Y9hDImKfpH+T9Mti7HrFiyVdZvshSV+Q9Cu2bxDj19O6\n", + "LaHaKGml7RW2+yS9SdLXOtwn5HxN0lvbj98q6cbjxKKDbFvS9ZK2RcR1E15iDLuc7bOO/gLM9nxJ\n", + "vyppkxi7nhAR10bE8oh4tqQ3S/p2RLxFjF9P67qZ0m3/uqTr1LrJ8vqI+ECHu4Rp2P6CpFdIOkut\n", + "6/1/Iemrkv5Z0rMk7ZD0xoj4Saf6iOm1fxX2XUlb9dNLC++TtEGMYVez/Ty1blqe0/7vhoj4sO0z\n", + "xNj1FNuvkPTuiLiM8ettXZdQAQAA9Jpuu+QHAADQc0ioAAAAGiKhAgAAaIiECgAAoCESKgAAgIZI\n", + "qAAAABoioQLQcbZvb///Z21ffpLbvnaqdQHAycQ8VAC6hu01ak1y+NrEe+ZFxOHjvP54RCw6Gf0D\n", + "gOlwhgpAx9kebj/8oKSX2d5ke63tObY/bHuD7S22/6gdv8b2rba/Kum+9nM32t5o+z7bb28/90FJ\n", + "89vt3TBxXW75sO17bW+1/cYJba+z/S+2H7D92dndGgB60bxOdwAA9NPSN++V9J6jZ6jaCdRPIuIi\n", + "2/2SbrP9rXbsKkkXRMR/t5ffFhF727XtNtj+UkRcY/udEbFqinX9pqRfkvR8SWdLusv2d9uvvUDS\n", + "+ZL+V9Lttl8SEVwqBDAtzlAB6CaetPxrkq6wvUnSeklnSPqF9msbJiRTkrTW9mZJd0haLmnlDOt6\n", + "qaTPR8tuSd+RdKFaCdeGiPhxtO6J2CxpRYO/CcDTAGeoAHS7d0XEzROfaN9rNTJp+ZWSVkfEmO1b\n", + "JA3M0G7oqQnc0bNXByc8d0QcKwHMgDNUALrJ45Im3kD+TUnvsD1Pkmw/x/bgFO9bLGlvO5k6T9Lq\n", + "Ca+NH33/JLdKelP7Pq2zJb1c0gY9NckCgBnxry4A3eDomaEtko60L919UtJH1brcdo9tS9ot6Tfa\n", + "8RN/onyTpD+2vU3S99W67HfUxyVttX13RLzl6Psi4l9tX9xeZ0i6OiJ2237upLY1xTIAPAnTJgAA\n", + "ADTEJT8AAICGSKgAAAAaIqECAABoiIQKAACgIRIqAACAhkioAAAAGiKhAgAAaIiECgAAoKH/B5/L\n", + "COx3ba+AAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAGLBJREFUeJztnVtsY+tVx3+ft+/29i224yQzk+lp+9AHpNOX8lAq+lBV\n", + "p0Jq4YWqEgKVUvEABQESbXmgBV5KJSoED0ioLeKmFgQqKi/QVgKpPHA5qKcXzqVnTjOTjJ2L49jx\n", + "/f7xYK9vtj3JnLHjTOxk/6WtOJ5k5zv1v+tb31r/9d9Ka40LF7PAc9ULcLF6cEnjYma4pHExM1zS\n", + "uJgZLmlczAyXNC5mxtykUUq9oJR6VSn1ulLqk4tclIvlhpqnTqOUsoDXgPcBeeB/gI9orV9Z7PJc\n", + "LCPmjTTvAu5pre9rrXvAV4EPLW5ZLpYZ3jl/bwvYc3z/EPhx5w8opdxS84pDa63Oen/eSOMS4gZj\n", + "XtLkgduO728zijYubgDmJc2LwNuVUneVUn7gw8DXF7csF8uMuXIarXVfKfWrwL8CFvAl9+R0czDX\n", + "kfupbuwmwiuPRSfCLm4wXNK4mBkuaVzMDJc0LmaGSxoXM8MljYuZ4ZLGxcxwSeNiZrikcTEzXNK4\n", + "mBkuaVzMjHlFWAAope4DVWAA9LTW71rEolwsNy5EGkZirPdqrU8WsRgXq4FFbE9ndkJdXF9clDQa\n", + "+JZS6kWl1McXsSAXy4+Lbk/v1lrvK6UywDeVUq9qrb+9iIU9ayj1KGBaloXH48Hj8WBZlvl3+ZnB\n", + "YGCufr9/Jeu9SlyINFrr/fHXolLqa4xGW1aONEIIpRSWZREOh4lEIkQiEcLhMJZl4fV6sSwLy7I4\n", + "PT01V7VaRYRsN8XrZ27SKKXCgKW1rimlIsD7gd9b2MqeIZRSJrJ4vV5s22ZtbY21tTVSqRR+v99c\n", + "Pp+PQqFAoVBgOBxSq9WAEWGUUjeCOBeJNOvA18Yh2wv8rdb6GwtZ1TOGkEYiim3bZDIZtra22Nzc\n", + "JBQKmSsQCBAOhxkOh1SrVTweD8PhEHAjzZtCa70DPL/AtTwzeDwesx15PB4TQXw+H6FQiHQ6zcbG\n", + "Bnfu3OHOnTtmuwqHwwSDQdrtNuVymXw+j8fjmSDLTSDORRPhlYNSCr/fTyAQIBAIEAwGsW2baDSK\n", + "bdvEYjE2NjbY2Nhgc3OTXC5nfi4QCOD3+4lEIoRCIfx+v0mUh8Mhg8Hgiv/rng1uJGkCgcAESdLp\n", + "NOl0mrW1NfNVrmQyaaKQz+fDsiyi0aghjdc7+p9QcpqbgBtJGr/fTzQaJZVKsba2xq1bt9ja2mJr\n", + "a4uNjQ0TeeSSJFm2NSFNIBDAsiyGw+FEbnPdcWNII1HAsixCoRDxeHwid9ne3mZ7e5vbt2+brUu2\n", + "IyeGwyHRaNQcySORCJ1Oh06nAzCxRV3X/OZGkMZZrAsEAsTjcbLZrEl0c7kcmUyGWCxGMBjE5/Ph\n", + "9XrP3G6UUoRCIVKpFFtbW7ztbW8z9ZrT01OGwyHD4RCttfl63XDtSTN9nA4GgyQSCdbX17lz5w5v\n", + "fetbSSaTpFIpYrGY2XKEaGchHA6bba3VanFwcMDR0RHD4ZBWq2WqxcC1TI6vPWkAU7Tz+/0Eg0ET\n", + "aW7fvs1zzz1njtORSIRAIGCIdl5i64w0Wmt8Ph9aa1qtFicno4a/1vpaRhm4AaSR1oAQJhqNkkgk\n", + "yGQybG5ucvv2bbMdyVfBeR96KBQimUzS7/fx+XwMBgM6nQ71ep1yuUyn06Hb7dLr9UyVWK7rkCzf\n", + "CNJI4huPx8lkMmSzWRKJBOFw2ByjLct6qiOzUgqfz0ckEqHf7+PxeOh2u+Yovra2Rr1eN1etVqPd\n", + "bpur0+msfAX52pPG4/GYPCabzbKxsWFIEwqF8Hq9E8dpwZM+UCnwyfHd4/EQiURYW1tjc3OTk5MT\n", + "SqWS+epMlHu93sT9V5E4N4I0oVDIJL+3bt0im80Sj8cJh8OGNE7pw5tBIo3Ue4QwzWaTRqPBwcEB\n", + "hUKBg4MD03qQiFSv11eaMPAUpFFKfRn4KeBIa/1j4/dSwN8B28B94Ge11pVLXOfMEAJMk2Zra4t0\n", + "Ok08HjeRxonztg65n2xP0qcCiMViRlszGAxIpVKmACjbXq/Xo1armWKg3GsVifM0keYvgD8F/srx\n", + "3qeAb2qtPz82nv7U+LpyOGUOQhjbtkkmk2QyGdbX10kmk0SjUXw+HzApqhoMBqbWInUWIYkky+f9\n", + "TelDhcNhEokEnU4HrTX9fp9ms0m5XDYnrcFgsJKEgacgjdb620qpu1NvfxD4yfHrvwT+nSUhDTw6\n", + "YktdRk5M6XSa9fV1YrEYkUjEfID9fp9er0e326Xb7T5GoGAwaKQRTyKNvJbIJoQTwsjfFMIMh8OV\n", + "jDbz5jTrWuvD8etDRtqapYB8gFKXOSvSCAmckabb7dJqtWi32/R6PUOkwWCAbdtmWzrvb8KjynM4\n", + "HDaEiUQiVCoVDg8PDWn6/b4hzSoW/y6cCGut9bL561mWhc/nIxAIEAqFiEajxONx1tbWyGQyZiuR\n", + "JmO326XZbFKv12k0GqbG0u12TZ4ipAmFQhP5jTN3EkiuJEf9YrFIPp/Htm1CoZDJaVaRMDA/aQ6V\n", + "Ujmt9YFSagM4WuSiLgKlFF6v1yjsRPsiPSUhSr/fN1+Pjo4oFosUi0VKpZIhivxMKpUyHfFUKkUw\n", + "GDTRSk5GTiLKa5/Ph1KKeDxOLpfjueeeo9PpcHx8TKVSoVwuUy6XJ7arVdiq5iXN14FfAP5w/PWf\n", + "FraiC8JZAZYoEw6HCQQCppDX7/fpdrt0Oh2azSb7+/vs7u7y4MED8vn8RMMRMDob0dokEglzxePx\n", + "iQanHN8lKfZ4PMRiMXK5HO12G4/HQz6fJ5/Po7U2kW2Vos/THLm/wijpTSul9oDfBT4H/L1S6mOM\n", + "j9yXuchZcVakEdJIpOl0OjQaDU5PT9nf3+eNN97gtdde44033jD3ke0nk8lMXOvr67TbbWBU6JPo\n", + "IMdrIY5IQSXSeDweotEowWDQEKZYLJqItyri9Kc5PX3knH9634LXshBMRxqnNFMKedO9okKhwM7O\n", + "Dq+88govv/zyxJHd6/VSKpVMhVd6SwDBYJBYLGYIIomycyQGwLZt4FHPajAYUKvVODw8xOfz0ev1\n", + "VqovdS0rws4PbfrSWtNutzk9PeXo6Ij9/X1KpRK1Wo1ut2vuIQ3GwWBAu92mVqvh9XoZDodEIhFi\n", + "sRipVIpWqzVxWnPKPqdfO+s/sgU6r1XBtSQNPCLOdItgOBzSbrepVCocHR2Rz+cpFosTpJEPUP6f\n", + "L6SR343FYiSTSWq1Gs1m0xDmrEgx3eGeLh5Ok2cVcC1J4yTMWY3IVqtlIk0+n+f4+PjcSKO1Np1p\n", + "IU8qlSKbzVKv12m1WuZoL0nstMh8Oso4ibNqhIEbQhoncYQE1WqVYrHI/v4+Jycn1Ov1xyKNvBZZ\n", + "g9x7fX2dSqVCvV6n3W6buo6QYLrx+WaRxkmeVcC1I43ogG3bJpVKkclkTEdbElWfz0c4HCYej5NK\n", + "pcxJarp5eRamE23bts2R/jxNjiTezWaTWq1mIpS0LJz1mVUgzrWzT3OOqEjrQARXUksR0kgya9s2\n", + "wWDwqUgDk0d65wyU1GZg8sOXNkWz2aRardJoNAxppIC4KoU9uIakebNII6RyRppYLHamTOI8SKQJ\n", + "h8MTkea833+zSCMV4VUhzbXbnpwTlKlUymhnzoo08XjcFNjO62BP3xsmI41t26YG5Iw0TjgjTa1W\n", + "o9FomFxItqdVwrUjjSS6tVqNk5MTisUiXq/XkAQe/9BFfRcOh40fjfNyjuX6/X62t7dZX1/Htu0J\n", + "5Z9UdqeP+9LtTqVS9Ho96vU6p6enlEolIpEI7XbbJMnXoo2wapAWQb1e5+TkxESZeDxupgPOIo2T\n", + "OE4vGtmG5IpEIty9e5dsNott22bLk7+ttZ44sTlzLPn71WqVUqlkdD2A0Q6vQm5z7UijtTZa3HK5\n", + "TDQaNUP+EgWENDJS6yRMJBIxXWzpZMskg1zb29uGNF6vd6LWMhgMJpqVgCGNbJ3lcpnDw0NisZjx\n", + "upFIJeRZZsyrEf4s8EtAcfxjn9Za/8tlLXIWSKSR7SkYDJJOp2k2m+YDEUWfCK1s256wS3POaUej\n", + "UdPdzmQyrK2tkc1mzRiviKokNxEPPmfj0e/3G8LEYjFKpRKpVIp4PG5GYQaDwcSc1DJjXo2wBr6g\n", + "tf7CpazqAtBa0+v1aLVaVKtVwuEwtVpt4rQCj4gzGAzIZrO0Wi2jfXFqZSTSiAwiHo8TjUaxLItO\n", + "p0OlUqHRaBgBV71eNxYmcsm6JMqJhlgG9iSRlrHeZce8GmFYUv9g2Z6azSaWZREIBEyPqNPpGBWe\n", + "kMbj8ZDL5bAsC9u2zYco+Ywzp5FIJCKrTqdDv9/n+PjYXKVSiWw2Sy6XI5fLTRg8yu8JEcWiTeQa\n", + "Qtxlx0Vymk8opX6e0YPdf2tZRlickQZG1V8hjUQaIY3kNqJzyWazhmxnnZ6ETGItIuO3+/v7PHz4\n", + "kHw+z97eHnfv3qXb7eL1eo2pgAzVOWWg6XSaRqNhphUqlcq1Js2fAb8/fv0HwB8BH1vIii4IIQ2M\n", + "TiQej+ex7UmIIKSIRqNn5hHy3vQHWalU6Pf7Znva399nZ2eHe/fu8frrr9NqtYzhYy6Xm2g9OI//\n", + "mUyGfr9vuu7BYPD6kkZrbTTBSqkvAv+8sBUtAE6Vv3ywBwcH7OzsmGqx2KfJeO20cAoekUakofK1\n", + "WCxyfHxsvu7u7pLP5ymVSjQaDWq1mtEAHx8fG1WeRBnZGm3bpt1uk0gkzFpkAM/ZzFw2zEUapdSG\n", + "GE8DPwN8f3FLujjk6Asj0oikU2oi2WyWbDZr5rzPklAA5hgspzG59vf32d/fN6O3Qp6TkxMzmlut\n", + "Vg1pJNKEQqEJ8ti2Tb/fJx6Pm5qNTCv0+31DtmU7Tc2jEf4M8F6l1POMTlE7wC9f6ipngFOGIElx\n", + "pVKhUCiglKLT6ZiEMxKJkEgkzO86db1OiJRCEt3d3V329vbY3d3l4cOHxiFCGpFS8T05OeH4+Bif\n", + "z0cwGDTSC/leZKASaaT5KfUkGeRbNsyrEf7yJaxlYZgO6ZVKBY/HYyrF4vKQyWRMYuyMMtO1Eok0\n", + "x8fHFAoFHjx4wM7ODj/60Y/Y2dl5bKy3Xq9PRBqJKs46kWxDXq+XRCIxEWm63a4hzDLWba5dRXga\n", + "Em0ajYbZggqFgnG9krFb8QkOBAKPVXjz+TwPHz5kb2+PfD5PoVCYUPtNC6mcGmSZgJBBu0gkYo7Y\n", + "sj1KR15cLYLBIJXK6DAqIvZlwo0gjfMIrrXm4OCAQCAAQKvVeqz/5ExC+/0+e3t7Zjva29vj+PiY\n", + "crlMq9U6U3kneZTMWEm9SPQ3Mrgnx3jpyOdyOer1uulndbtdqtXq0jUxbwxpADNqK4SRXCWZTJor\n", + "Ho9PbDW9Xo+9vT0ePHjAgwcP2N3dNflLs9mc0AULhDTS0ZYoI+PB0j6Q0WFx0Go0Gmat3W6XWq12\n", + "rlnkVeLGkEb6Os1mE3iUp0gFN5PJmERWTi4inpIoc//+fXZ3d41BgKjuptFut+n3+9TrdSzLMltQ\n", + "IpEglUpNmAn4/X6zPckaJcIcHR25pLkqTOtvJSFWSpmI0m63jZzCaVDU7/cpFApmzEW0L0+qoUgS\n", + "K/UikXmWy2WKxeLE6clpLGDbNp1Ox0QikaBalrVUUws3gjTTcOY4MtctUoqzchoZ1G80GhPD+ufB\n", + "SVJxpWg0GoY0slXJKUlyHul4y0nKaYQ9PblwlbhxpHHmOFLCbzQaVCoV06CcHnBrNpu0Wi1jLC33\n", + "edKH5zQtkshWqVQoFotG0O4kjUg1gMdII/qcqyaL4MaSpt/vmyLfWW2E6dmnWQbbztoOncRMpVJm\n", + "zkoqxJKcS89KSON80suytBRuHGng2buJ93o908X2eDxG8F4qlSZ8+JRSxu7NacJkWRbNZtOc1q46\n", + "4txI0jxr9Ho9U1wcDAYkk8mJZ0qJvaxTvyMegZubm3i9XsrlsikcXnXEcUnzDCCRZjAY0Gq1SCQS\n", + "Ew8kSyaTRm8sxtYindjc3DTbo5giXTWeSBql1G1GMs8so+bkn2ut/0StgI/wMkEMH9vtNkopQxq5\n", + "pM0gNrXSSJXaUa/XM62JpScN0AN+Q2v9klIqCvyvUuqbwEdZUh/hZYTTNUIKjKenp+YkJbUaEYP5\n", + "/X5isZgRaUmJQH7nqo0DnkgarfUBcDB+XVdKvQJsseQ+wsuMadcKsXULh8PGJcvn8xmtjc/nMxXi\n", + "4+NjU0cSMl2FdOKpc5qxuPydwH+xxD7CywqndNRJGq21sVVrNpuGKDKIF4vFaLValEolIyTrdrtG\n", + "IHYVp6mnIs14a/pH4Ne11rUpSeTS+QgvM5yRBjDOWrlcziTL0mIQkVa9Xufg4IBEIkEkEqHVak3o\n", + "bZ41nka552NEmL/WWov169L6CK8CJCkWXY0o/A4PDzk4ODDP0pRLbPqz2Sybm5tYlmUmF8RMSfAs\n", + "os6bnZ4U8CXgZa31Hzv+aWl9hFcBIrmQmou0FwqFghltEZ9iEYbF43HW19fZ3t424zeDwWCiH/as\n", + "tqk3izTvBn4O+J5S6jvj9z7NkvsILzvEekRmt8U0Umzw5d/kFOX3+w1pxMZNCHNycjJhKXvlkUZr\n", + "/R+cb3y0lD7CqwAhi+hnJNLIeIvMfcfjcbTWE5EGMHKLUqlkrE7kOP8sNMVuRfgKML2VtNttYz/i\n", + "NFxKp9NGIyzmAVprI9ByRqYnicIWDZc0SwBpM5TLZfMshXQ6TbVapdlsmnHeaDRq+lCJRMI890Eq\n", + "zSKEdyPNDcB0QzORSFAul80MumxbYkAgNiUSaeRZCzKOc9lwSbMEENKIEUAymaRSqRjS+P1+YyIQ\n", + "CAQ4OTkxA3bhcNicoJ6VIZJLmiWAJMYSLZxu6rFYjPX1dRKJBMlk0kQbeVpeNptlMBiYKOVUF14W\n", + "XNIsAeS4LB92tVo1s1n9fp/T01Nu3bqFZVnGfcu2bTKZDLdu3QIetSdOT08vfb0uaZYAzsc6D4dD\n", + "arUaBwcH5hE/nU7HJMgbGxtm7CWdTlOv143tSbVaPdeWdpFwSbMEmJZOyFSlPBNKa21cupxd8HQ6\n", + "Ta/Xm2iAPgu9jUuaJYFTjC7uEiJ+Fy1xtVo1BgZyBM9kMqZuIyO/Z82XLxIuaZYQkhDLtEKr1TKe\n", + "N+KYpbUmGAySTCYnjuAinZBin3jcLBIuaZYQTp2MzF2JfUmlUjFqv2AwaOo2TjetdrtNp9O5NH+b\n", + "J26ASqnbSql/U0r9n1LqB0qpXxu//1ml1EOl1HfG1wsLX9kNhnzYkq9MR5pms2kijcyHT7tpybzU\n", + "ZRT75tUIL62P8HXA9LBdq9UyvoGJRIJut0s6nTZ5jbhPSOSRaU1R+C0a82qEYUl9hK8j2u02pVKJ\n", + "vb09AOOJLM6kcuqSSc1AIGD+/SoijYFDI/yfjHQ2S+kjfB0hpNH60cPfPR6PKfBNG2o7H1x/GaR5\n", + "qkP9eGv6B0Ya4TojH+G3AM8D+4x8hF1cEuTYvbe3x6uvvsq9e/coFArmGeESacTCxGkccCWRxqER\n", + "/hvRCOsl9xG+bpB6jViWHB0dUSgUWFtbIx6P02q1ODo6olKpPPaYw8uQScylEV52H+HrCKcnTrVa\n", + "pVAo4Pf7zfH66OiIYrHI4eGheU6mRKFFYx6N8O8AH1lWH+HrCCdhtNbUajUKhQKdTsc4oosxdrVa\n", + "NY+EluLgoqEuS+XlzkItFs7cxPmEGL/fP+Fw7nz21EWds7TWZyZELmlcnIvzSHP1FgQuVg4uaVzM\n", + "DJc0LmaGSxoXM8MljYuZ4ZLGxcy4tCO3i+sLN9K4mBkuaVzMjEsljVLqBaXUq0qp18cuoBe9332l\n", + "1PfGEtP/nuP3v6yUOlRKfd/xXkop9U2l1A+VUt9QSiWedI+nuN/cUtgnyGvnWuOlyXWdfv+LvAAL\n", + "uAfcBXzAS8A7LnjPHSB1gd9/DyMh2fcd730e+O3x608Cn7vg/T4D/Oac68sBz49fR4HXgHfMu8Yn\n", + "3G/uNWqtLzXSvAu4p7W+r7XuAV8FPrSA+86tKtJafxsoT739QUa2toy//vQF7wdzrlFrfaC1fmn8\n", + "ug44LXhnXuMT7jf3GuFyt6ctYM/x/UMeLXheaOBbSqkXlVIfv+C9BJdhb/sJpdR3lVJfmmW7c2LR\n", + "FrxTct0LrfEySXMZZ/l3a63fCXwA+BWl1HsWeXM9iuMXXfeFpbDTFrwXXeOi5bqXSZo8cNvx/W1G\n", + "0WZu6LFaUGtdBL7GaAu8KA6VUjkYKRK5oL2t1vpIjwF8cdY1PsmCd541nifXvcgaL5M0LwJvV0rd\n", + "VUr5gQ8zspKdC0qpsFLKHr+OAO9nMTJTsbeFBdjbjj9UwUxS2Kew4J1pjU+S6867RuDyTk/jjP0D\n", + "jDL2e8CnL3ivtzA6gb0E/GCe+wFfAQpAl1G+9VEgBXwL+CHwDSBxgfv9IqOn1nwP+O74w12f4X4/\n", + "AQzH/43fGV8vzLvGc+73gYusUWvtthFczA63IuxiZrikcTEzXNK4mBkuaVzMDJc0LmaGSxoXM8Ml\n", + "jYuZ4ZLGxcz4f041SDwzkyB1AAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAE5JJREFUeJzt3X+QXXV5x/HPh/zabH5sJFmwSsguqbb80IpVB4wKRNuh\n", + "jqJtrUpbtbZjp6NWStURmaF/taPVYUodp52hUn+gIq1a1Gn9QQkJGJAIJkBIVEAoQZsEQgKbhJBN\n", + "8vSPexOXZDf5Pjn57r03fb9mHO+597nnPLnfc88+nHPu93FECAAAAEfvhE4nAAAA0OsoqAAAABqi\n", + "oAIAAGiIggoAAKAhCioAAICGKKgAAAAamtrJjdtmzgYAANAzIsLjPV+1oLJ9oaSrJE2R9JmI+PuD\n", + "Y6644opD3rdixQqdd955B6+reLv79u1L5bl3794q6+6G2BNOyJ2EzKx7ojnMbr/9dp177rnPei7z\n", + "Ge/Zs6c4NrPebPzo6Ghx7O7du4tjn3766eLYXbt2FcdOnZr7Ok+bNu2Q59avX6/TTz/9kOf7+vqK\n", + "1ztlypTi2Mx4bN26tTh2y5YtxbHZdW/fvr04dufOncWxmf1iorEeHR0dd1xnzpxZvO6BgYHi2Llz\n", + "5xbHzp49uzg2sy9n/jZI+WNGqcx3dbyx3rx5s0466aRDnt+xY0cqj8yxqFZs5thZ83ifrQWaqnbJ\n", + "z/YUSZ+WdKGkMyRdbPvQIzUAAECPq3kP1SskPRARD0fEqKSvSHpTxe0BAAB0RM2C6vmSNoxZfrT9\n", + "3BEtWrSoSkKYHKecckqnU8BRWrBgQadTQAPZS/zoHrNmzep0Cmio5rfvqG84HxoaOoZpYLItXLiw\n", + "0yngKA0ODnY6BTSQuX8N3YWCqvfVvCn955LG/mVdqNZZqmdZsWLFgceLFi2imAIAAD2nZkF1p6QX\n", + "2B6S9AtJb5N08cFBB/+aDwAAoNdUK6giYo/t90v6rlrTJlwTEetrbQ8AAKBTqs5DFRHflvTtmtsA\n", + "AADotI7OlC6VTyKXmaCr5uRfkz1RWFPZfGt9zt0QW1NmcsFMbGaCvGeeeaY4VspNOpmZXHBkZKQ4\n", + "NpNzZrLH7K8V58+fXxxba6ynT59eHFtzwt5ak2pmbpjv7+8vjs18blIu58ykk7UmqMysV8rtG9nJ\n", + "gGvkkNkvJppMeiKZ/b50Ytbrrrtuwtf4jS0AAEBDFFQAAAANUVABAAA0REEFAADQEAUVAABAQxRU\n", + "AAAADVFQAQAANERBBQAA0BAFFQAAQEMUVAAAAA1RUAEAADTU8V5+GzduLIqbMWNG8TozsVKuF1Rm\n", + "3Zl+RpkeRbt37y6OzfSCk3J9ozJ92DJ51OqfJeU+51o9saZNm1Ycm5Hty9UNOff19RXHZvLN9rrL\n", + "7BeZ40UmNtPfLfu9zvRizBxfMseATO/Ibdu2Fcdm8pXqfc6ZY1FmX872Ksz0QczEzpw5szi21nc1\n", + "04dRyo11thfqeKqeobK90PbNtu+zvdb2B2puDwAAoBNqn6EalXRpRKyxPVvSXbZvjIj1lbcLAAAw\n", + "aaqeoYqIjRGxpv14u6T1kp5Xc5sAAACTbdJuSrc9JOlsSXdM1jYBAAAmw6QUVO3LfV+VdEn7TBUA\n", + "AMBxo/qv/GxPk/Q1SV+MiBsOfn3lypUHHi9cuFCnnnpq7ZQAAACOaNu2bcW/Oq1aULn1G8drJK2L\n", + "iKvGi1myZEnNFAAAAI7KvHnzNG/evAPLjzzyyISxtS/5LZH0x5IusL26/b8LK28TAABgUlU9QxUR\n", + "3xezsQMAgOMcxQ4AAEBDHW89M3fu3KK4TGuIzHTzUq4tQ6a9QCbnjMx6s1P1Z+Iz7QUybQumTJlS\n", + "HJttiZJZd62WCLX2i3379qXia+WR+dwysZl/38jISHGslDsGZI4vmf2z9FgoSYODg8WxkjRnzpzi\n", + "2FrtcjKtPbZs2VIlVpKefvrp4thdu3YVx2bGemBgoDg2s19IufZomWN45m9fph1Q5jPOtC+SpO3b\n", + "yycVKN0/b7nllglf4wwVAABAQxRUAAAADVFQAQAANERBBQAA0BAFFQAAQEMUVAAAAA1RUAEAADRE\n", + "QQUAANAQBRUAAEBDFFQAAAANdbz1TGnrgkyLisx0+lKuZUCmdUmtdiSZFhzZ1jOZzzmTc2ZMMrHZ\n", + "1jOZ+Fo5Z2IzrT0yLRykXCuQjNmzZxfHzps3rzj2xBNPLI7t6+srjpVy+0WmdUnmu5pp+ZJp5STl\n", + "9qNax6JMO5JMDpn9Qsq1cunv70+tu1Tmu5dpiyTlxnp0dLTKemu1MMv+ba/xt+Tqq6+eeHsTvWD7\n", + "9yWFpPE+mYiIr5ds3PYUSXdKejQi3ljyHgAAgF5yuPLtjWoVVBMpKqgkXSJpnaTy7pwAAAA9ZMKC\n", + "KiL+pOnKbZ8i6fWS/k7SXzddHwAAQDc64g0ztp9r+xrb32kvn2H7zwrX/w+SPiyp/EI7AABAjym5\n", + "A/lzkr4n6Xnt5fslXXqkN9l+g6TNEbFa49+HBQAAcFwouQV+QURcb/sySYqIUdt7Ct73SkkX2X69\n", + "pD5Jc21/ISLeOTZo+fLlBx4PDQ1paGioNHcAAIBqVq5cqdtuu60otqSg2m57/v4F2+dIevJIb4qI\n", + "yyVd3n7PeZI+dHAxJUnnn39+UaIAAACTacmSJVqyZMmB5SuvvHLC2JKC6oOSviXpNNu3SRqU9Jaj\n", + "yKt8YhEAAIAecsSCKiLusv0aSb+m1r1QP4mI8tnAWutYIWnF0aUIAADQ3Y5YUNmeKem9kl6l1lmm\n", + "W23/c0TkpmUGAAA4TpVc8vuCpKckfUqtM1R/KOlaSX9QMS8AAICeUVJQnRkRZ4xZXmZ73bFKoLR3\n", + "XK3+UlKur1KmR1EmNtMjMBOb6c2Xja+VR6b/UrZXYaYfVWY/yvTRy+Sc6Uk3a9as4lhJGhwcLI7N\n", + "9OfLjF+mL94TTzxRHLtt27biWCnX0ywzfpkxGRgYKI7N9jSr1aOz1jEg01tx48aNxbGStGHDhuLY\n", + "zH6xadOm4tjHHnusOPapp54qjpVyvf8yY13rWDRnTnkTlcxxSMr1bcyuezwle/iPbJ+7f6H9K7+7\n", + "Gm8ZAADgOHG45sj3jolZaXuDWvdQnSrpJ5OQGwAAQE84UnNkAAAAHMHhmiM/PHbZ9klqzXgOAACA\n", + "MUqaI19k+35JD6k1l9TDkr5dOS8AAICeUXJT+t9KOlfSTyNiWNJrJd1RNSsAAIAeUlJQjUbE45JO\n", + "sD0lIm6W9LLKeQEAAPSMkslMttqeI+lWSV+yvVnS9rppAQAA9I6SM1RvlrRT0qWSviPpAfELQAAA\n", + "gANKmiPvPxu1V9LnqmYDAADQgw43sed2tSbyHE9ERPmc7oeRbY3SaZmp+jOxe/bsKY7NtE/plhYV\n", + "tdabbT3TDTL/vkzri0wbF0navXt3cWwm5xkzZhTHZtr7ZHLItuHJtOvIfFe3by+/O+LJJ58sjs22\n", + "18rYuXNncWyttl0ZmfY3Um7/zLRbyeSRaXOS/RuZOeZnjgGZfW5kZKRKbKYlkZQbk8x+MZHDzUPV\n", + "uLGN7XmSPiPpTLWKsz+NiB80XS8AAEA3yZ2+yPtHSf8VEW+xPVVS7j8bAQAAekC1gsr2gKRXR8S7\n", + "JCki9kgqP6cNAADQI2rewDQs6THbn7X9I9v/Yru/4vYAAAA6omZBNVXSSyX9U0S8VNIOSZdV3B4A\n", + "AEBH1LyH6lFJj0bED9vLX9U4BdWyZcsOPB4eHtbw8HDFlAAAAMo8+OCD+tnPflYUW62gioiNtjfY\n", + "fmFE/FTS6yTdd3Dc0qVLa6UAAABw1BYvXqzFixcfWL7pppsmjK39K7+/VKtdzXRJD0p6d+XtAQAA\n", + "TLqqBVVE3C3p5TW3AQAA0Gm9NU05AABAF6p9ye+ISqd7r9WaJRufaX9RS6YVQeZzk3JT9df6LDKt\n", + "E7KtdTLtLzL7RaaFQ6bFSKadTKYNiFSvxU+mhcPAwEBxbKZdR39/boaWTIuRWq1ndu3aVRybPcZl\n", + "2obUOtbW2t+yrWcy687Ezpw5szg28x3JHuMy36nM+GX2i25pCVZrrCfCGSoAAICGKKgAAAAaoqAC\n", + "AABoiIIKAACgIQoqAACAhiioAAAAGqKgAgAAaIiCCgAAoCEKKgAAgIYoqAAAABrqeOuZ0nYZmSny\n", + "s20ZMi0RarVPyLSTqTmtf6aNw/Tp06usN/MZZ1pqSLl9Y3R0tMp658+fXxybaWeRGQ8ptx9l2trs\n", + "3LmzODbTbmVkZKQ4NvN9knKf3Zw5c4pjTz755OLYTM7Z/T4jk0dmv8/sF5mWS9nPYseOHVXWndkv\n", + "Mm2U5s2bVxwrSc95znOKY2fNmlUcm/mOZI6dmWNLZuyk3PEls39OpOoZKtsftX2f7Xttf9l2eQMj\n", + "AACAHlGtoLI9JOk9kl4aES+SNEXS22ttDwAAoFNqXvJ7StKopH7beyX1S/p5xe0BAAB0RLUzVBHx\n", + "hKQrJT0i6ReStkXEf9faHgAAQKfUvOS3WNJfSRqS9DxJs23/Ua3tAQAAdErNS34vk3RbRGyRJNtf\n", + "l/RKSV8aG7Rs2bIDj4eHhzU8PFwxJQAAgDJr167V2rVri2JrFlQ/lnSF7ZmSdkl6naRVBwctXbq0\n", + "YgoAAABH56yzztJZZ511YPn666+fMLbmPVR3S/qCpDsl3dN++upa2wMAAOiUqhN7RsQnJH2i5jYA\n", + "AAA6jdYzAAAADVFQAQAANNTxXn6lfdsyveAysVKud1Vm3bX689Xqi5fNIxOb7a9YKvvvy4xJpjdX\n", + "X19fldhML79MrCT19/en4kvt2bOnynozvcTmzp2bWvfg4GBx7MDAQHFsppfY448/Xhy7efPm4ths\n", + "HpnvamafO+2004pjFyxYUBw7bdq04lgptx9lYjN5ZI5D2b6UmbHO9MbL9OfLHAMy/RIzvTElaerU\n", + "8hIne/wcD2eoAAAAGqKgAgAAaIiCCgAAoCEKKgAAgIYoqAAAABqioAIAAGioKwuqhx56qNMpoIH7\n", + "77+/0yngKK1evbrTKaABxq93LV++vNMpoCEKKhxzDzzwQKdTwFFas2ZNp1NAAxRUvWvFihWdTgEN\n", + "dWVBBQAA0EsoqAAAABpytnXHMd243bmNAwAAJEXEuH3XOlpQAQAAHA+45AcAANAQBRUAAEBDXVdQ\n", + "2b7Q9o9t32/7I53OBxOz/a+2N9m+d8xzJ9q+0fZPbX/P9rxO5oiJ2V5o+2bb99lea/sD7ecZwy5n\n", + "u8/2HbbX2F5n+2Pt5xm7HmJ7iu3Vtr/VXmb8elhXFVS2p0j6tKQLJZ0h6WLbp3c2KxzGZ9Uaq7Eu\n", + "k3RjRLxQ0k3tZXSnUUmXRsSZks6R9L72940x7HIRsUvSBRHxEkkvlnSB7VeJses1l0haJ2n/zcyM\n", + "Xw/rqoJK0iskPRARD0fEqKSvSHpTh3PCBCLiVklbD3r6Ikmfbz/+vKQ3T2pSKBYRGyNiTfvxdknr\n", + "JT1fjGFPiIid7YfTJU1R67vI2PUI26dIer2kz0ja/6sxxq+HdVtB9XxJG8YsP9p+Dr3j5IjY1H68\n", + "SdLJnUwGZWwPSTpb0h1iDHuC7RNsr1FrjG6OiPvE2PWSf5D0YUn7xjzH+PWwbiuomMPhOBKtOTkY\n", + "0y5ne7akr0m6JCJGxr7GGHaviNjXvuR3iqTX2L7goNcZuy5l+w2SNkfEav3y7NSzMH69p9sKqp9L\n", + "WjhmeaFaZ6nQOzbZfq4k2f4VSZs7nA8Ow/Y0tYqpayPihvbTjGEPiYgnJf2npN8UY9crXinpItsP\n", + "SbpO0lLb14rx62ndVlDdKekFtodsT5f0Nknf7HBOyPmmpHe1H79L0g2HiUUH2bakaySti4irxrzE\n", + "GHY52wv2/wLM9kxJvyVptRi7nhARl0fEwogYlvR2Scsi4h1i/Hpa182Ubvt3JF2l1k2W10TExzqc\n", + "EiZg+zpJ50laoNb1/r+R9A1J/ybpVEkPS3prRGzrVI6YWPtXYbdIuke/vLTwUUmrxBh2NdsvUuum\n", + "5RPa/7s2Ij5p+0Qxdj3F9nmSPhgRFzF+va3rCioAAIBe022X/AAAAHoOBRUAAEBDFFQAAAANUVAB\n", + "AAA0REEFAADQEAUVAABAQxRUADrO9sr2/y+yffExXvfl420LAI4l5qEC0DVsn6/WJIdvTLxnakTs\n", + "OczrIxEx51jkBwAT4QwVgI6zvb398OOSXm17te1LbJ9g+5O2V9m+2/aft+PPt32r7W9IWtt+7gbb\n", + "d9pea/s97ec+Lmlme33Xjt2WWz5p+17b99h+65h1L7f977bX2/7i5H4aAHrR1E4nAAD6Zeubj0j6\n", + "0P4zVO0CaltEvML2DEnft/29duzZks6MiP9pL787Ira2e9utsv3ViLjM9vsi4uxxtvV7kn5D0osl\n", + "DUr6oe1b2q+9RNIZkv5X0krbSyKCS4UAJsQZKgDdxAct/7akd9peLekHkk6U9Kvt11aNKaYk6RLb\n", + "ayTdLmmhpBccYVuvkvTlaNksaYWkl6tVcK2KiF9E656INZKGGvybAPw/wBkqAN3u/RFx49gn2vda\n", + "7Tho+bWSzomIXbZvltR3hPWGDi3g9p+9embMc3vFsRLAEXCGCkA3GZE09gby70p6r+2pkmT7hbb7\n", + "x3nfXElb28XUr0s6Z8xro/vff5BbJb2tfZ/WoKTXSFqlQ4ssADgi/qsLQDfYf2bobkl725fuPivp\n", + "U2pdbvuRbUvaLOl32/Fjf6L8HUl/YXudpJ+oddlvv6sl3WP7roh4x/73RcR/2D63vc2Q9OGI2Gz7\n", + "9IPWrXGWAeBZmDYBAACgIS75AQAANERBBQAA0BAFFQAAQEMUVAAAAA1RUAEAADREQQUAANAQBRUA\n", + "AEBDFFQAAAAN/R9mVy2QoO8DbAAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i in range(8):\n", + " figure(figsize=(2, 2))\n", + " imshow(solver.test_nets[0].blobs['data'].data[i, 0], cmap='gray')\n", + " figure(figsize=(10, 2))\n", + " imshow(output[:50, i].T, interpolation='nearest', cmap='gray')\n", + " xlabel('iteration')\n", + " ylabel('label')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We started with little idea about any of these digits, and ended up with correct classifications for each. If you've been following along, you'll see the last digit is the most difficult, a slanted \"9\" that's (understandably) most confused with \"4\".\n", + "\n", + "Note that these are the \"raw\" output scores rather than the softmax-computed probability vectors. The latter, shown below, make it easier to see the confidence of our net (but harder to see the scores for less likely digits)." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAFZtJREFUeJztnVtsY8d5x//f4Z2H94skaiXvemUbsAsD9otbwA2ahyCw\n", + "USBpXxoYKFD0EvShN7QPddyHJo9pgAZF+1CgiB30hqRFCxfpQ1vbRQukD724sGOnaydZY8XVihJF\n", + "iXfykDwipw/kNzuHklbiRRRJzQ8Y8OgsdXYk/vXNN9988w0JIaDRjIJx1R3QLB5aNJqR0aLRjIwW\n", + "jWZktGg0I6NFoxmZsUVDRC8R0cdE9CMienWandLMNzROnIaIXAB+AOAzAHYB/A+AV4QQH023e5p5\n", + "ZFxL8wKAu0KIbSGEDeDbAD4/vW5p5hn3mN93A8CO8vUDAD+uvoGIdKh5wRFC0Gn3x7U0WhDXmHFF\n", + "swtgU/l6E31ro7kGjCuadwE8SUS3iMgL4AsAvjO9bmnmmbF8GiHEMRH9OoB/AeAC8LqeOV0fxppy\n", + "X+jB2hFeeKbtCGuuMVo0mpHRotGMjBaNZmS0aDQjo0WjGRktGs3IaNFoRkaLRjMyWjSakdGi0YzM\n", + "uElYAAAi2gZQBdAFYAshXphGpzTzzUSiQT8Z69NCiOI0OqNZDKYxPJ26EqpZXiYVjQDwDhG9S0Rf\n", + "nEaHNPPPpMPTi0KIPSJKA3ibiD4WQnx3Gh3TzC8TWRohxN7gtQDgTfS3tmiWnEl2WAaJKDy4NgF8\n", + "FsCH0+qYZn6ZZHhaBfAmEfFz/loI8dZUeqWZaxYyR9gwDBARiEheq/eY0342IQSEEOj1evJafR9f\n", + "D79eR87KEZ7UEZ45hmHA5/PB6/XC6/XC5/PB7/fD7/fL+71ez9FUAfR6PbTbbdk6nY58D7+/2+2i\n", + "2+3Ka42ThRSN1+tFKBSSLRKJyBYIBNDtdnF8fOz48NmidLtd1Go11Ot11Go1NBqNE++3bVs2LZqT\n", + "LJxoiAg+nw+hUAjxeBzxeBzpdBqpVAqpVAqRSASdTkd+6MfHxw6LY9s2isUiisUifD4f3G63QyS2\n", + "bYOIpMA0J1k40RiGAb/fj0gkgmQyidXVVWQyGaytrWFtbQ2xWAydTkc227YdQ5Vt2wiHwwgGg3I4\n", + "U9/f6XRgWZZsbvfV/IrUIVX1wYaH26vwuRZONC6XC6ZpIplMYmNjAxsbG9LKsKVhC8Ov6i/7+PgY\n", + "wWAQ8XgcKysrqFarDstk2zaazSYsy0Kz2USr1Zr5zzjsk7VaLViWJV/55+I2a+EspGhCoRBSqRQ2\n", + "Nzdx69YtxGIxxGIxRKNRmKZ5wpFVZ0m9Xg/xeBzNZhONRgOWZTkExqLhZlnWzH9G9rG41Wo1lMtl\n", + "2ZrNJtrttnyvFs05GIbhsDSPP/44QqEQTNNEKBSC3+8/MZ0eNucsDvUvlj8oVTQsqlnDfWMLeHh4\n", + "iHw+D4/Hg16vJ8MK3W4XnU5n5v1bSNH4fD6Ew2HpBPOU2+/3w+v1noi78C/5rFe2Sr1eD8fHxw4r\n", + "02w2Hc9Sv28aqP1jbNuW4YB2u41IJCIF0263Hf7ZNPtyURZONDxlzufzyGazMAwDgUBANq/XK4cn\n", + "FoPL5XI0t9sNt9strw3DgGEYcLlcMlDo9XpBRHC73Sd8DH4/t1E4zbFVA5SGYZwYLrvdLlqtFlqt\n", + "lhyWhBBot9taNBeBRVMoFLC9vQ3bthEMBmXj2RCb9263C6/XC4/HI199Pp+cOfG1eo+I4PV64Xa7\n", + "4ff7Hf5Ft9t1CO6is6vhAKMq7GFBs8VT36OK5vj4GO12G7VabWTRToOFFE29Xkc+n4dhGGg0GggG\n", + "gzBNE6Zpwuv1yl9wq9WCbduO4cvv9ztEFgwGZZBQCOH48PhaFWGn05HRaBbheZzmU6nN7XbD4/HI\n", + "V36vao3UCHar1UK9XkexWJxP0RDRGwB+GsCBEOLZwb0EgL8BcBPANoCfE0KUL7GfEhbN4eEhjo+P\n", + "Ua1WpWBYNOrsx7ZtBAKBU0XCjWM77GSy1fF4PPB4PNJJBh4KgIezi4pmuPH/xT4NWzW/339iDc22\n", + "bTQaDdTrdTQaDZTLZWlV53V4+iaAPwHwF8q9LwF4WwjxtUHh6S8N2qXDUV3LsmAYBrrdLprNJur1\n", + "Ovx+P9xuN9rttsOU8/oUi0H1gQKBAMLhMEKhkHzlD499JI6PcKxk+PvPY3g2xw4uW65oNCrjTMlk\n", + "Eh6Px7Egy8MVW5l2uy19nbkM7gkhvktEt4Zufw7ATw2u/xzAv2NGoun1euh0Omg2m/Ja9VdcLpdj\n", + "Ot3tdh2mn9+r+jfBYFBao+FXv9/vsFzNZhOmaTos13l/7cPRXFXU7XYbmUwGt27dgmEYCIfDICK4\n", + "XC4YhiG/7yzRXAXj+jSrQoj84DqPfm7NTGBLw3+xPPvhXzJbH3W9SZ3p8PtU53PYGWZRmKaJQCDg\n", + "GBoajYZjaDNN80KiUfujRnhbrRa2trZgGAZCoRAymYx0rvm57DgPi0ZdUpglEzvCQggxy/p6LBrb\n", + "tqfyPPYnuHk8HhkoZPHU63XHqng4HHYMaeehCkZdFmDhCCEQj8dx48YNdDod+Hw+EJGcjrNg2u22\n", + "jB91Op0rWUIAxhdNnojWhBD7RJQBcDDNTs0S1TFlc99ut6Uvoa5F8QfVbrfhcrkuvBI+PDzxB81T\n", + "fHUBlf0Znmp3Oh3UajVUKhUUi0UUCgWUSiXU63V0Op2FEs13APwCgD8YvP7D1Hp0BfR6PQAPBdRq\n", + "taRgWq2WdFjb7Ta63S7a7bacOnOw7VEMz5zUBDKObpumCb/fL0WjLm3w2tPR0REKhQKKxSLq9bqM\n", + "Ds+ai0y5v4W+05sioh0Avw/gqwD+loh+GYMp92V28rIZjomw49lqteByuRxBNp6xqBZnlP8HAEKh\n", + "kHTCI5GIw9K43W45NLGjzKJRLY1lWVK8s+Yis6dXzvinz0y5L1fGcF4Kx2TOYtJZi8fjQTQaRSAQ\n", + "QCwWQyQScVgaFm273Ua9Xke1WpWiOTw8RKVSkYHBubQ0mskZToAPh8NIpVLY2NjA5uYmNjc3kUql\n", + "YJomDMNAq9VCtVrF0dERjo6OkMvlcHR0hFqtJpdGeIZ4FWjRzAB1uu9yuRyieeKJJ5DJZJBOpxEK\n", + "hWAYBjqdDqrVKg4ODrC7u4tcLofDw0MpGrYwV7VTQotmBnCwjqf1nETGokkkEjKBTBVNoVDAzs6O\n", + "tDQ8Y+Kptk73XGJYNByRVi3N1taWdIy9Xq8UDa/k7+zsYG9vzyGaq05416KZARyL4SjyysoK4vG4\n", + "XGDlPB52gDkJSw0AztN2Gi2aGcD7tJLJJJLJJNLp9Kmi4ak8x4RarZZMbmcLMw87PrVoZgAH8FKp\n", + "FDKZDFZWVhCLxRAKhaRo1BgR5+6oa1RXuao9jC7UOAN4eEomk1hfXz8xPPECpbqafZalmQe0pbkE\n", + "htNBE4kE0uk01tfXsbm5idXVVcRiMZlw1Ww2UalUUK1WUalUcPfuXezs7KBQKKBer0vRXNUC5Ymf\n", + "76o7sIyo6RZ+vx+JRAIrKyvIZDLY3NxEMpmUEWEigmVZODw8xN7eHnK5HO7fv4+dnR0Zm+HF0nkZ\n", + "nrRoLgEWDaegDosmHA4jEAhIS8OiyWazuHv3LnK5HPb39x2W5iojwMOMmyP8FQC/AqAweNtrQoh/\n", + "vqxOLhqc72uaJqLRqBTN+vo6HnvsMRmP4ZROVTR37txBoVCQuylrtdq5a2Gz5iKO8DcBvDR0TwD4\n", + "uhDi+UHTglFg0fCGvmg0KlexOU+n3W7LJPFyuYxKpSJbvV6X24XnYTgaZtwcYUDXDz4Tj8eDQCAg\n", + "K1vwKjZbGDXtodVqnRAO58pwWuu8McmU+zeI6HtE9DoRxabWoyXA7XbLXQ6JRAKRSERuOeH0TU57\n", + "GBZMtVpFo9FAq9WaW0szrmj+FMDjAJ4DsAfgD6fWoyWARROJRORi5GmiUYcnFs4iiGas2ZMQQuYE\n", + "E9E3APzj1Hq0gAwXFPB6vQgGg9Kn4dkSR35brRYqlQry+Tzy+Tz29vZQKpXQbDYdaQ/zKBhgTEsz\n", + "SCZnfha6frBjcxuLhi1NJBKRG/lYNOVyWRYx2NvbQ7FYlHu55lkwwHg5wl8G8Gkieg79WdQ9AL96\n", + "qb2cc4bL0w6Lhi3NsGj29/cdouGikfNejnbcHOE3LqEvCw0Lx+VynTk8qaLh4SmbzeLo6EhWuLrK\n", + "jLyLoiPCU4CXC3hv9+rqKpLJpBSMz+eT23G73a7D+eUAHtfSm3fBAFo0U8Hn8yEajSIajSIWi8mc\n", + "X05/APor2JZlodvtOgJ5alxmXmdLw2jRTAHev7SysiJL1HKiVTgcdmyntSzrxBSbZ03ztlxwFlo0\n", + "U4BFk06nsbm56RANF0vi2Mtpywbq9lptaZYUtWCA2+1GKpXC2toaNjY2cPPmTayuriIajUpfhh3f\n", + "g4MD5PN57O/vy12S87R6fVG0aMbA4/FIx9fv98u0hxs3buCxxx5DPB5HJBKRh3s0m01HXGZ/fx/l\n", + "chmWZS2EZRlGi2YMPB6PnFKHw2Gk02mHpeFKWlx6rdlsolQqYX9/H/fv33dYGi2aawAROVaxuVx+\n", + "JpORogEe7g8fFk02m0WxWESlUtGiWWY4cMdRX66Yzgd5rK+vI5VKIRwOw+v1yqJLnP5wVlxmUWZL\n", + "w2jRXAAWy/BebD6bYWNjA4lEQtbfOz4+hmVZsuxaqVRyzJjmfRX7PLRoLoAqGN5Wm06n5bZarsoZ\n", + "DAZl6oNlWbJEiCoa1cospaUhok30S8GuoL84+WdCiD++yjrCVwFbGq7JFwqFpGiefPJJWZuPdxdw\n", + "QaRarSYPJFOFw/UC5301+yzOS42wAfy2EOLHAPwEgF8joqfxsI7wUwD+FTMqB3sVGIaBYDAoT315\n", + "4okncPPmTWQyGXm+lN/vl7kynJFXLBaRz+exs7ODfD4v82WGK48uIo+0NEKIfQD7g+s6EX0E4Aau\n", + "sI7wrFATq8LhMNbW1qTje/v2bayvryMej8ttKABknbxKpYLDw0Pkcjlsb29jb28P5XJZVvJcdC7s\n", + "0wySy58H8F+4wjrCs0AVDNf3XVtbw9bWFra2tuTRh4lEAn6/33FgarfblbVldnd3sb29jcPDQxSL\n", + "xYWdYg9zIdEQUQjA3wP4LSFEbejs65nWEZ41bGlWV1extbWFZ599Vq5o8y5J3szGvky1WnVYmlqt\n", + "Jhcsr4VoiMiDvmD+UgjBpV+Xpo7waagVzrkMPgfy0um0LG/P+5hs25b7sCuVCnK5HA4ODhxBPE59\n", + "WAYe6QhT36S8DuCOEOKPlH/iOsLAEtQRHsYwDFmylY/64SrmoVBICobLwVqWhVKphFwuh08++QQP\n", + "HjzAwcGBXF+66rMMps15luZFAD8P4AMiem9w7zUsWR1hFXV6zSe2qKIJh8OOk+mAvmiKxSJyuRzu\n", + "3buH3d1dHBwcSCvDDvIiz5hUzps9/QfOtkZLU0d4GA7ieb1eh2hYOOqyAnDS0hQKBbkf27KspREL\n", + "oyPCgGMzPi8TxONxxGIxJBIJrK+vI5FIwDRNuN3uE4e/7+/vy8YxmVqtJh3kZRIMoEUDwLlM4PV6\n", + "ZcUqzpG5ffs2VldXYZomgL5lUbfRZrNZ7O7uIp/PyyqcfKrdMnLtRTO8RBAIBJBIJHDjxg0Zl+Hc\n", + "X9M0IYSQwxHvkLx//76cMR0dHcnV7UXZXTAq1140AKRo2IdJJBLY2NjAU089hWeeecZxRibw0PHd\n", + "3d1FNpvF/fv3HZaGh6RFS+O8KNdeNLwjkkURi8Uc50mmUqkTJ+PycYjlclmeisK7CjhJfBktDKNF\n", + "Mzgdl8uCpNNppFIpuWeJj9PhYwwByMgvlwrhEmc8HC2zYAAtGgAn6/yyaEzTlEE8jhADD0XTaDTk\n", + "ZjdOqroOXHvRsKXhqlVra2uO3ZF8niTHZLiq+GmWRotmiVFPzOUttYlEAqurqzLfV82TUVETxvkc\n", + "g2WL+J7HtRMNn47Lzq1aspWTxJPJpCxBrznJtRQNb3ZTa8ik02kZzOOFSZ/Pd9XdnUvOW+XeJKJ/\n", + "I6L/I6LvE9FvDu5/hYgeENF7gzZcMnau4ZKtoVAI0WhUnoxy2nYUzUnOszScI/z+IBHrf4nobTys\n", + "I/z1S+/hlOHhSRVNJBKRp9aGQiGHzwM4T9NlX0Y9R/I6TLNVxs0RBha0jrA6PLFoQqEQAoGAPEZH\n", + "nV4DkALhbSfqARfqscvXRTgXLtSo5Aj/5+DWwtYR5pKtLBr1eGMWjTrNVs9g4qSqTqcjE6sWfXfB\n", + "qFxINIOh6e/QzxGuY4HrCKuWxjRNRCKRUy0Ni4aHJj4nWxXNdZtqM6PkCP8V5wgveh1h9SBSn88H\n", + "j8cDt9stxcIi6PV6cneB2tRzsnk1+6oOVr8KzttheWqOMBFlhBB7gy+Xqo4wO7sshE6n4yhGxBvg\n", + "+DymZrO5dDnA5zFOjvDvAXhlmesId7tdeSRgs9lEoVBANpvFvXv3cO/ePRwdHcmm1svTlgaPzBH+\n", + "p8vpznzAorEsC/V6HQcHB8hms/joo49w584deRgpny953abd1y4iDDhTG0qlkoz+ulwu2LaNZrMp\n", + "W61WQzabxc7ODnZ3d7G3t+eYfl+XRUqVaycarudbKpXkRrdGo4HDw0Ps7u4iHo87zmKyLAsPHjzA\n", + "gwcPUC6Xr+2MSYUu6wef1626XMlKTd9cW1uT602maTpWrzudDkqlEkqlEorFIsrlsiMus8x+jBDi\n", + "1ADutRMNT7d5w5tt244NcG632yEINbDHDXhY73eZrY0WjWZkzhLNJMcRaq4pWjSakbm04UmzvGhL\n", + "oxkZLRrNyFyqaIjoJSL6mIh+RESvTuF520T0wSDF9L/H+P43iChPRB8q9xJE9DYR/ZCI3holN+iM\n", + "542dCvuI9Nqx+nhp6bq8ZjLtBsAF4C6AWwA8AN4H8PSEz7wHIDHB938K/USyD5V7XwPwu4PrVwF8\n", + "dcLnfRnA74zZvzUAzw2uQwB+AODpcfv4iOeN3UchxKVamhcA3BVCbAshbADfBvD5KTx37DRTIcR3\n", + "AZSGbn8O/bK2GLz+zITPA8bsoxBiXwjx/uC6DkAtwTtyHx/xvLH7CFzu8HQDwI7y9QM87PC4CADv\n", + "ENG7RPTFCZ/FXEZ524lTYaddgnea6bqXKZrLmMu/KIR4HsDL6FdP/9Q0Hy76dnzSfk+cCjtcgnfS\n", + "Pk47XfcyRbMLYFP5ehN9azM2YpAtKIQoAHgT/SFwUvJEtAb0MxIxYXlbIcSBGADgG6P28VEleMfp\n", + "41npupP08TJF8y6AJ4noFhF5AXwB/VKyY0FEQSIKD65NAJ/FdNJMp1redvChMiOlwk67BO+j0nXH\n", + "7SOAy5s9DTz2l9H32O8CeG3CZz2O/gzsfQDfH+d5AL4FIAegg76/9YsAEgDeAfBDAG8BiE3wvF9C\n", + "/9SaDwB8b/Dhro7wvJ8E0Bv8jO8N2kvj9vGM5708SR+FEHoZQTM6OiKsGRktGs3IaNFoRkaLRjMy\n", + "WjSakdGi0YyMFo1mZLRoNCPz/yU19i71FpCwAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAD3dJREFUeJzt3X2wXVdZx/HvL/cmNwlJw6RtQCAYqqC0A1IEprxTQKcy\n", + "UHxBoCIgOjgOIBWR4WVG/9IBh3GoDKMzSOWlvKmABUZ5qVKhgDQU0teUN4dqC9IohrShTXrvzeMf\n", + "56S5vdzk7n139j3nXL6fmTs9e5911nruXud2nqy191qpKiRJkrRy60YdgCRJ0qQzoZIkSerIhEqS\n", + "JKkjEypJkqSOTKgkSZI6MqGSJEnqaHqUjSdxzQZJkjQxqipLne81oUpyHnARMAW8o6r+fHGZnTt3\n", + "/sjnDhw4wLZt2+5xbt265oNpyZK/63EdOXKkcdn5+flWdTfVZj2wNr9f22vRxvGuxe23387WrVvv\n", + "cW5ubq5xvbOzs72UbRtHm+9Fm7JtrPY6cUeOHFnyb62vOFwHT9Ja0duUX5Ip4G3AecCZwAVJHtpX\n", + "e5IkSaPS5z1UjwG+VVU3VdUs8EHg2T22J0mSNBJ9JlT3B25ecHzL8NyyZmZmeglIq2PDhg2jDkEr\n", + "1OcUsSStZX0mVCu+OWLjxo0nMw6tMhPiyWVCJUkr0+dN6d8BFt5xvpPBKNU9HDhw4O7XMzMzJlOS\n", + "JGni9JlQXQU8OMku4LvA84ALFhda/DSfJEnSpOktoaqquSSvAD7FYNmEi6vqxr7akyRJGpVe16Gq\n", + "qk8An+izDUmSpFEb6UrpAFNTU43KtVk4sc3ijdBusc42cYzDYohtF5xscy3aXOc29fbVH9Du2o3D\n", + "opPjEIMkaXnu5SdJktSRCZUkSVJHJlSSJEkdmVBJkiR1ZEIlSZLUkQmVJElSRyZUkiRJHZlQSZIk\n", + "dWRCJUmS1JEJlSRJUkcmVJIkSR2NfC+//fv3Nyo3Pd081A0bNrSKYWZmpnHZ9evXt6q7qTZ7tt11\n", + "1129lG0bR5JWdY+63rbG4ffrc+9B9wmUpJOn1xGqJDuTXJ7khiTXJ3lln+1JkiSNQt8jVLPAq6rq\n", + "6iRbgK8kuayqbuy5XUmSpFXT6whVVX2vqq4evj4I3Ajcr882JUmSVtuq3ZSeZBdwNnDlarUpSZK0\n", + "GlYloRpO930IuHA4UiVJkrRm9P6UX5L1wIeB91bVpYvfP3To0LFgpqdbPc0nSZI0DnrNXjJ4Pvxi\n", + "YG9VXbRUmY0bN/YZgiRJUu/6nvJ7PPCbwLlJ9gx/zuu5TUmSpFXV6whVVX0eV2OXJElrnMmOJElS\n", + "RyO/A/y0005rVG5+fr5xnW231GhTd5utXMZha4+226f0tQ3PunXNc/cjR440Ltum7wDm5uZ6iaOv\n", + "LXvalG17Lfq6zm3K9nWNtXJ9bY0krXWOUEmSJHVkQiVJktSRCZUkSVJHJlSSJEkdmVBJkiR1ZEIl\n", + "SZLUkQmVJElSRyZUkiRJHZlQSZIkdWRCJUmS1NHIt57Zv39/o3JttkOYmppqFcP0dPPL0KZsm20Z\n", + "+toGpE294xJHn1vP9BVHX1tw9PUdalu3fnz4vZBW5rjZQZJfAwpYKpOpqvpIkwaSTAFXAbdU1bNW\n", + "FKUkSdIYO9Fwy7MYJFTH0yihAi4E9gJbmwYlSZI0SY6bUFXVb3WtPMkDgGcAfwb8Ydf6JEmSxtGy\n", + "N6UnuW+Si5N8cnh8ZpLfaVj/W4DXAO1u7pAkSZogTZ7yexfwaeB+w+NvAq9a7kNJngnsq6o9LH0f\n", + "liRJ0prQJKE6rar+DpgHqKpZYK7B5x4HnJ/k28AHgKcmec/iQnfcccfdP7Ozsy1ClyRJGg9NEqqD\n", + "SU49epDkHODAch+qqjdU1c6qehDwfOAzVfWixeU2b95898/69evbxC5JkjQWmiyq9Grg48AZSb4I\n", + "nA48ZwVtubiJJElak9JkEbck08DPMLgX6uvDab/ujSe1ffv2pmUb19vnwp5t6nZhz5XV68KeK6vX\n", + "hT0lqX9VtWRCsmwmkWQT8DLgCQxGma5I8tdVdejkhihJkjSZmgzNvAe4DXgrgxGq3wAuAX69x7gk\n", + "SZImRpOE6qyqOnPB8WeS7D1ZATSdymszPTE31+QhxGP6erqwTcxtpjT71NcUU1/TeGt9yq9Pbb5z\n", + "k/j7SdJqavKU31eTPPbowfApv6/0F5IkSdJkOdHmyNctKPOFJDczuIfqgcDXVyE2SZKkibDc5siS\n", + "JElaxok2R75p4XGSHcDGvgOSJEmaNE02Rz4/yTeBbwOfBW4CPtFzXJIkSROjyU3pfwo8FvjGcBuZ\n", + "pwFX9hqVJEnSBGmSUM1W1f8C65JMVdXlwKN6jkuSJGliNFmHan+SrcAVwPuS7AMO9huWJEnS5Fh2\n", + "L78kW4A7GYxmvQA4BXhfVX2/c+NJnXrqqY3K9rmw4Djsw+bCnse4sOf4Weu/nyQ1teK9/Krq6GjU\n", + "PPCukxiTJEnSmnCihT0PMljIcylVVaecjABmZmYalWvzL+S2/5rua/RkHEZD2l6Lvuoeh2vctnyf\n", + "11mStLacaB2qLV0rT3Jv4B3AWQySs9+uqi91rVeSJGmcNLkpvYu/BP65qp6TZBq4V8/tSZIkrbre\n", + "Eqok24AnVtWLAapqDjjQV3uSJEmj0mQdqpV6EPA/Sd6Z5KtJ/ibJ5h7bkyRJGok+E6pp4JHAX1XV\n", + "I4EfAq/rsT1JkqSR6DOhugW4paq+PDz+EIME6x5uu+22u38OHz7cYziSJEn96O0eqqr6XpKbkzyk\n", + "qr4BPB24YXG5U045KasvSJIkjUzfT/n9PoPtajYA/wG8pOf2JEmSVl2vCVVVXQM8us82JEmSRq3P\n", + "e6gkSZJ+LPQ95bes9evXNyrX50a1bcpv2LChcdmpqanGZaenm3fFpk2bGpfdsqXdgvfbtm1rXHb7\n", + "9u2Ny55++umNy+7atatx2TPOOKNxWYAdO3Y0Lrt169bGZdt8L9o8fNHmu9n0b+moNt+jNvc63ute\n", + "zdfvbRPzunX++0/SaCVL7osMOEIlSZLUmQmVJElSRyZUkiRJHZlQSZIkdWRCJUmS1JEJlSRJUkcm\n", + "VJIkSR2ZUEmSJHVkQiVJktSRCZUkSVJHI9965s4772xUrs3WM23Kti3fdlubptpsq3Gipe9XM46+\n", + "tgK56667eikLMD8/30vZNt+LcenrNt/7vq6FJK0VvY5QJXl9khuSXJfk/Ulm+mxPkiRpFHpLqJLs\n", + "Al4KPLKqHgZMAc/vqz1JkqRR6XPK7zZgFticZB7YDHynx/YkSZJGorcRqqr6P+AvgP8Cvgv8oKr+\n", + "pa/2JEmSRqXPKb+fAv4A2AXcD9iS5AV9tSdJkjQqfd6U/ijgi1X1/aqaAz4CPG5xoYMHD9790/aJ\n", + "LUmSpHHQ5z1UXwP+OMkm4BDwdGD34kJbtmzpMQRJkqT+9XkP1TXAe4CrgGuHp9/eV3uSJEmjklEu\n", + "wpekduzY0aisC3se48KeKysLLuy5kAt7SlJ7VbXk/5jdekaSJKkjEypJkqSORr6X3/T0yQ+h7VRU\n", + "X9NcU1NTreJoqs000NzcXKu6+5panZ2dbVy2z2muNnW36b++6u0rBmjXf22mVtv0ddvpeUkaV45Q\n", + "SZIkdWRCJUmS1JEJlSRJUkcmVJIkSR2ZUEmSJHVkQiVJktTRWCZUhw8fHnUI6uDQoUOjDkEr1HaZ\n", + "DUnSgAmVTjr7b3K12WJGknTMWCZUkiRJk8SESpIkqaOMcmf4JG5LL0mSJkZVLbnP10gTKkmSpLXA\n", + "KT9JkqSOTKgkSZI6GruEKsl5Sb6W5JtJXjvqeHR8Sf42ya1JrltwbnuSy5J8I8mnk9x7lDHq+JLs\n", + "THJ5khuSXJ/klcPz9uGYS7IxyZVJrk6yN8kbh+ftuwmSZCrJniQfHx7bfxNsrBKqJFPA24DzgDOB\n", + "C5I8dLRR6QTeyaCvFnodcFlVPQT41+GxxtMs8KqqOgs4B3j58O/NPhxzVXUIOLeqHgE8HDg3yROw\n", + "7ybNhcBe4OjNzPbfBBurhAp4DPCtqrqpqmaBDwLPHnFMOo6qugLYv+j0+cC7h6/fDfzyqgalxqrq\n", + "e1V19fD1QeBG4P7YhxOhqu4YvtwATDH4W7TvJkSSBwDPAN4BHH1qzP6bYOOWUN0fuHnB8S3Dc5oc\n", + "96mqW4evbwXuM8pg1EySXcDZwJXYhxMhybokVzPoo8ur6gbsu0nyFuA1wJEF5+y/CTZuCZVrOKwh\n", + "NViTwz4dc0m2AB8GLqyq2xe+Zx+Or6o6MpzyewDwpCTnLnrfvhtTSZ4J7KuqPRwbnboH+2/yjFtC\n", + "9R1g54LjnQxGqTQ5bk1yX4AkPwHsG3E8OoEk6xkkU5dU1aXD0/bhBKmqA8A/AT+PfTcpHgecn+Tb\n", + "wAeApya5BPtvoo1bQnUV8OAku5JsAJ4HfGzEMamdjwEvHr5+MXDpCcpqhJIEuBjYW1UXLXjLPhxz\n", + "SU47+gRYkk3ALwB7sO8mQlW9oap2VtWDgOcDn6mqF2L/TbSxWyk9yS8BFzG4yfLiqnrjiEPScST5\n", + "APBk4DQG8/1/AnwU+HvggcBNwHOr6gejilHHN3wq7HPAtRybWng9sBv7cKwleRiDm5bXDX8uqao3\n", + "J9mOfTdRkjwZeHVVnW//TbaxS6gkSZImzbhN+UmSJE0cEypJkqSOTKgkSZI6MqGSJEnqyIRKkiSp\n", + "IxMqSZKkjkyoJI1cki8M//uTSS44yXW/Yam2JOlkch0qSWMjyVMYLHL4rBafma6quRO8f3tVbT0Z\n", + "8UnS8ThCJWnkkhwcvnwT8MQke5JcmGRdkjcn2Z3kmiS/Oyz/lCRXJPkocP3w3KVJrkpyfZKXDs+9\n", + "Cdg0rO+ShW1l4M1JrktybZLnLqj735L8Q5Ibk7x3da+GpEk0PeoAJIljW9+8FvijoyNUwwTqB1X1\n", + "mCQzwOeTfHpY9mzgrKr6z+HxS6pq/3Bvu91JPlRVr0vy8qo6e4m2fhX4OeDhwOnAl5N8bvjeI4Az\n", + "gf8GvpDk8VXlVKGk43KEStI4yaLjXwRelGQP8CVgO/DTw/d2L0imAC5McjXw78BO4MHLtPUE4P01\n", + "sA/4LPBoBgnX7qr6bg3uibga2NXhd5L0Y8ARKknj7hVVddnCE8N7rX646PhpwDlVdSjJ5cDGZeot\n", + "fjSBOzp6dXjBuXn8f6WkZThCJWmc3A4svIH8U8DLkkwDJHlIks1LfO4UYP8wmfpZ4JwF780e/fwi\n", + "VwDPG96ndTrwJGA3P5pkSdKy/FeXpHFwdGToGmB+OHX3TuCtDKbbvpokwD7gV4blFz6i/Eng95Ls\n", + "Bb7OYNrvqLcD1yb5SlW98Ojnquofkzx22GYBr6mqfUkeuqhuljiWpHtw2QRJkqSOnPKTJEnqyIRK\n", + "kiSpIxMqSZKkjkyoJEmSOjKhkiRJ6siESpIkqSMTKkmSpI5MqCRJkjr6f002U8GpKcFcAAAAAElF\n", + "TkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAGPlJREFUeJztXUlsbNlZ/v6a53myy37Pft1B6kiRkk1YJFGyiKKOkJKw\n", + "IYqEFAWEWDAJFjRhQWAXIhEhWCAg6SgMSkCgoICESAeBaBYMjbrTHUgP7nbZZbuq7JrnW9NhUfWf\n", + "Pve6bNfk91zl+0lHVa7yuz717lf//59/JCEETJiYB5YnvQET6weTNCbmhkkaE3PDJI2JuWGSxsTc\n", + "MEljYm4sTBoiepaIXieit4jouVVuysTdBi3ipyEiK4A3AHwcwCmA/wbwOSHEj1a7PRN3EYtKmg8C\n", + "OBBCZIQQfQDfBvDp1W3LxF2GbcF/lwaQVX4+AfDj6i8QkelqXnMIIWja64tKGpMQ9xiLkuYUwK7y\n", + "8y7G0sbEPcCipHkJwHuIaI+IHAA+C+C7q9uWibuMhWwaIcSAiH4RwD8BsAL4unlyuj9Y6Mg904VN\n", + "Q3jtsWpD2MQ9hkkaE3PDJI2JubGoc2+tYbVa5bJYLCDSq24ikq/zc3UZMRwOMRqN5ONoNIIQAkII\n", + "+bP6/rrj3pHGYrHA7XbD7XbD4/HA7XZLcgBjwthsNt1yOp1wuVxwOp1wOp2XrtnpdHSr3+/rlqZp\n", + "6Ha7cq17Xva9Iw0RweVyIRQKIRwOIxgM6iSLxWKR5HA4HHC5XPD5fPD5fPD7/fB6vZeuWavVUK1W\n", + "UavVUKvV0Ol00O125WO9Xkej0cBoNIKmaSZp1g1EBLfbjVAohGQyiXg8riOM1WqVEsjj8cDj8SAc\n", + "DiMSiSAcDiMcDl+65vn5Oc7Pz3FxcYHz83M0m03dstlsEEKg2+0+gU+8emw8aVjdWK1W2Gw2uFwu\n", + "RKNRJJNJpNNpbG1t6ewVJo3H44HX64XX60U0GkUkEkEsFkMkErn0N1hiBQIBeL1e1Ot1KV3q9Tos\n", + "FgsGgwFarRasVisASGmzjlJn40ljsVjg8/kQCAQQCAQQCoWQTqexvb2N7e1tJBIJnaRh9eRyueTy\n", + "+/3weDxSYhjhcDjg9/sxGAxARPD7/QgEAlLSEBF6vR6azSaq1Sp6vZ7OeF433AvS+P1+pFIpuba2\n", + "tpBMJrG1tYVYLCYNYSaOzWaD3W6Xy+Vywe12w263T/0bDocDPp8PFosFLpcLrVZLt1jKVCoVuFwu\n", + "AEC/38dgMJAnrXXCxpPGarXC5/MhkUhgf38fe3t7SCaTSCQSSCQSiEajAKA7PbHEISLd8fw6ScOE\n", + "CQQCaLfb6HQ6usdKpYJCoQCXy4XhcCiP4+uIpUhDRBkAdQBDAH0hxAdXsallwDea7Rifz4d4PI7t\n", + "7W08fPgQTz31FKLRKKLRKGKxGEKh0KVrsI+FCcLSoN/vo9fr6QjGy263S/K43W7dEbtUKiGfzyMU\n", + "CsHn80EIASLCaDRCr9d7rP8/q8CykkYA+JgQoryKzawCrI7YholEInjqqafw4MEDqY4CgYC0UaZh\n", + "OBzKNRgMJFl6vR76/b40mHk5HA65nE4nLBYL7Ha7JIfX60UoFEIkEkEikYDdbketVsNwOESn07mX\n", + "6mlqJPRJwWq1wu/3I5lMIpVKYXt7G7u7uzrSsHNvGmlYbahEabfbuqXaO3a7XZ6y2Ihmuwh41xAP\n", + "BoPy1AZAEsbojV4HrELSfJ+IhgD+WAjxpyvY01Jg0qRSKTx69Aj7+/vS+E2lUojFYroj+DQMh0Pp\n", + "ye10OqjVaqjX66jVamg0GtL5xw5APjU5HA65B7aN7Ha7jjSJRAL9fl86/e4jaT4khMgRURzAC0T0\n", + "uhDixVVsbB4YbQu/3494PI7d3V08evRI2i/RaBSBQEBnr7AKUtXRNCO2Wq3KR/U47nK5MBgMpJTh\n", + "UxT7h9iZyMf+cDiMer1+paRbByy1ayFEbvJ4QUTfwbi05bGSRo0V2e126YsJh8PS4A0EAvImCSEu\n", + "2SvsjOPFBiyHARqNhlzNZlNnwzgcDjx48EAayHw0Z0nGxFGP8izppgU/1wELk4aIPACsQogGEXkB\n", + "fALA76xsZ7PvQ3p6nU4n/H4/gsGgjjRGG2Y4HEp7pdPpoFAoIJfLIZfLoVAoQNM0uZg86lJvvt1u\n", + "R7/fBxHJkIPL5YLD4dBJGzaeVcKogdJ1wjKSJgngO5MPbQPwl0KI761kV3OAVZLT6YTX651KGr7B\n", + "qqRhwjSbTeTzebzzzjs4ODjA4eGhJJR6YlIf1bQKfnS73QiHw0ilUlL18d9T/T2qpFlHwgBLkEYI\n", + "cQjg/Svcy0LgG+JwOKTtwBFpPnarGA6H6Ha7aDabaDQaqFarODs7QyaTwVtvvYU33nhDqi1+ZHXG\n", + "bn9VYlitVmxtbaFWq6HVaqHX60m1pTrvVN+PalOtI9bTEjNAtRccDoe0KfibrN70Xq+Hi4sLGZEu\n", + "FArIZDI4OztDpVKBpmnSMOZHNakKAFwulwxqejweeSoLBoPwer1SPXFwko3rRqOBcrmMer2OdruN\n", + "fr+/luRZe9Ko9gKTRrUbWB2xaul0Ori4uMDx8TGOjo6QzWZRKBRwfn6OarWKbrd7KdNOlQ5EBKfT\n", + "KR2HrJKi0SiCwSA8Hg+cTqeOuP1+H51OB/V6HaVSCbVazSTNk4YxyGi0GdiGYbV0cXGBbDaLN998\n", + "E2+//bYujYEz64xqRL25TqcTwWAQ8XhcBkFVSWM8HV0ladYxhABsCGmMMBq67MntdDqoVqvI5/PI\n", + "ZrM4PDzEwcHBJaP3OrCkYV9QOp1GIpFAJBJBIBCAy+XSBTx5P5qmodVqoV6vo9VqSTVoSponACEE\n", + "er2eTHCyWq3wer2wWq3QNA35fF4XPGw0Gjg8PEQul0OtVpNE4cjzLHA4HDKelEgkEA6H4fV6ZcBy\n", + "XU9Fs2LtScPGbbvdlnaIxWJBr9dDtVpFOByWUoTDAoVCAYVCQZKGDeV5SRMOhyVpfD4fnE6nzju9\n", + "qVh70rCk4aTtTqcDTdNQq9WQz+fh9XplVcBgMECv19N5eHu9ngxSzkoaDlKGQiHE43GEQiGdpGFs\n", + "KnE2gjRMCmBsFHO8iE8xxlQH47oJarWC1WqF2+2G3+9HKBRCLBaTUW72Aqt5OMC7dVHGta5Ye9IY\n", + "oaY2ENGlG6b6bGaRLFzy4na7pX+Gj9gc03I6nfLEBOASOflkxks1hNcRG0caYHzT+BtvtVqvrHic\n", + "VR1xGmcoFEIoFLrkl2GHIqsm9YivaZo80vMyT093DEwM9uayXWH0uczqymdJEwwGkUgkZHKXMXpu\n", + "s9l0pNE0De12Wx6z1cU+mo2VNET0PICfAHAuhHjf5LUIgL8C8BBABsBPCSGqt7jPubCszaDmALMN\n", + "Ew6HkUwm8eDBA0kav98vy3rZ5mEbi31EXHXJ0qbZbELTtLlU5F3DLAkd3wDwrOG13wDwghDixwD8\n", + "8+TnjQBHzT0ejy5Fc2trCw8ePMDe3h5SqRTC4bAkDAAp3fr9PprNJkqlEs7OznB4eIjT01OUSiVZ\n", + "zmKMZa0bbiTNJBOvYnj5UwC+OXn+TQCfWfG+niiYNIFAQKZobm9vY2dnB3t7e9ja2kIoFILb7ZYq\n", + "iY1sLopTSXN2diZJY+wssY5Y1KZJCiEKk+cFjHNrNgKqpOH0zEQiga2tLezu7uLhw4fyJMUhAyYB\n", + "n5aMpCkUCiiXyzrSrCthgBUYwkIIsWn99YzqKZFIIJVKIZ1OY3d3V1fGy3aMGklvNBoolUrI5XI4\n", + "OjpCpVKRke1N6FGzKGkKRJQSQuSJaAvA+So39aRhs9l0SV2qL2Zamma/39eV4RaLRZRKJZmI3mw2\n", + "0e121/aIbcSimc3fBfD5yfPPA/i71WznyYNPTE6nEx6PRxb/M2mmxZY49lWtVmXLkXK5jHK5rCPN\n", + "TRH0dcEsR+5vAfgogBgRZQH8FoAvA/hrIvpZTI7ct7nJxw3ufjWNNNNiSyxpqtUqLi4udJJGDYpu\n", + "iqS5kTRCiM9d8dbHV7yXJwZVehhVE/eccblcsNvtl5yFQghomoZmsymL/Jk03B1r3W0YIzbOIzwv\n", + "LBYLvF4vfD4fvF4vAoEAdnZ2sLOzg3Q6jZ2dHcTjcQQCAdlvj9MsOOXi7OwMJycnyGazOD4+Ri6X\n", + "Q7VaRafTecKf7nZw70nDTYg4RMDHa7WfTSgUQjAY1JGm1WrJOBKT5ujoCJlMRqqmdSzunwX3njRc\n", + "oJ9MJmX/mng8LlcsFpNRbqfTKfN3WB1VKhXkcjmcnJzg+PgYmUwGzWYTrVZrY3rsGXHvSUNEOtI8\n", + "88wzusaMoVDoUs4v2zDlcllWZ56eniKbzSKTyehqw01JsyEwtn/lTp5cnakavmqYABgbwK1WC+Vy\n", + "WSao5/P5qR7fTSQMcA9Jo9ZJqZWZbAxzr2DVL2PMw2Epk8/ncXR0hEKhgGq1qvP4btqJScW9Iw0A\n", + "XXEdd/JU68D5NZY0akkux5bK5bIME1SrVUka1RdjSpoNglpcZ1RPgUBAV3jHpBFCyMR0VT0dHx+j\n", + "3W7L7hLr2OJ1Xtw70vBpibuPx2Ix2fHT7/frsvBYNTFReLHjrtFooNPpyNqpTVZJKu4tabhjOefI\n", + "JBIJ+P1+KV3U05LaOLpSqch67GazKQdocHLVfcC9JA03cnz06BGefvppJJNJnaQxpj2wpKlUKjg/\n", + "P5eShgOR69x9fBHcGOUmoueJqEBErymv/TYRnRDRy5NlTAe9s2APMJPmve99L/b39yVpuIHAdX6Z\n", + "YrEoScPFeaZ60uMbAP4QwJ8prwkAXxVCfPVWdrVCcCYeG7dsz3BogPNljP1kePV6PZRKJRQKBZye\n", + "niKTyciS3k2Y3bQIZolyv0hEe1PeWouaUzV9k0f2qFNTfD6frgkRVxNwv712u41isYhcLic9vqye\n", + "NjVMcBOWaS/5S0T0AyL6OhFd7hV/R8D9fbn2OhqNSknj9/ulpOEmRMC7/WTY+C0Wi8jn8zIomc/n\n", + "TdIsgD8CsI9xz70cgN9b2Y5WDCaNmvMbiUQQCoWkpFHVE/tjuAESJ1YxaTKZjEmaRf6REOJcTADg\n", + "axj3D74zUPv28lidSCSCVCqly4/hagJj+iaXorTbbdkUiUtsuZfNulcULIOFSDNJJmf8JIDXrvrd\n", + "x41psSWfz4doNCrLUBKJhAwXTCMNG8CsorgJtUqY+3JSmoZFcoS/BOBjRPR+jE9RhwB+/lZ3OSfU\n", + "vr089S0ajcrhGolEQkoalSw8TodrsdX2a6qU2fTY0k1YNEf4+VvYy8rAHl1VPUWjUaRSKezu7sr+\n", + "wty5ygi1Z1+r1dL5Yu6LA+86bJxHmCe8caOhSCSCZDIph5aqbVtVw5frsDVNk4bv6ekpjo+PpV9G\n", + "07Qn/fHuBDaWNOpQLm7ZypPdeOQOH7FZqrA6KhQKODs7QzabxdHRkfQA39fTkhEbRxqehMJzt9Pp\n", + "tI40fr9f16aenXncR6ZSqeikjJrza0qaMTaONDzcgkmzs7Mj1RN34VT7z6jH61qthmKxeEnSzNOf\n", + "7z5g40mTTqd1dUvGGUtCCLTbbZTLZZyenuLk5ASnp6coFotoNBrQNG0jmiuuEhtLGm53tr29LSUM\n", + "jwtUwaQpFos4OTnBwcEB8vm8rp/MOo9Dvg1sHGm4R54qaTidc9owdq4uKJVKyGazePvtt2WyFZOG\n", + "f++++mWM2DjSTFNP6jAvI0aj0SVJwy3xWTWZZNFj40hjHP13VU8ZFWq7WFZH6nXmhbGLqPF1da/G\n", + "x2l7NL7PSe88jGzezuiDwUA3cnFeL/fGkWYRGIm27AQ4lk6q8cxE5Ef+u4C+eG+aNFTfs1gssnKC\n", + "Uztmmbqrfg4+KdZqNVSrVWiaduWYomkwSQPoCGO323U3fBHSGFukTbsZqlRhMnC87Kr9sYoNBAKI\n", + "xWJybPQ0A98IdQ+1Wg2FQkEeAtRU1aUlDRHtYpzmmcA4OPknQog/uOt9hOcB37yrJM0isFgs0qdz\n", + "07dXJcxVA1HV92w2GwKBgJw1lU6nZTeL66Duo1gsAgA6nQ7K5bJsiTJrXO0mSdMH8KtCiFeIyAfg\n", + "f4joBQBfwLiP8FeI6DmM+wivZS9hbgCQSCSwv78vh3NwWcoiDj11PLPq52EJpKoaridXl1FFqZLG\n", + "ZrPJ8AhXUcwraZxOp2zD3263YbfbdTOxbvrM15JGCJEHkJ88bxLRjwCkMe4j/NHJr30TwL9iTUlj\n", + "sVgQDAaxs7MDIQT8fr9uassiUe1WqyVDD9xwWh2mygRgEng8HtlUyefzTSWNurh8mGc1zGLTAO8S\n", + "x263S2L3ej3Y7XbZVZ2/LNdhZptmklz+AQD/iQ3qI8ykEULA5/Nhe3tbZ88s4tRjA5MfeQ4CSzA+\n", + "1bENpQ7rCIVCl+waVYXyOETumaM2wJ4FQgg4HA6dRGVJxnXqN2Em0kxU098C+BUhREPVueveR5gN\n", + "S6/Xi1QqdamnzCJ2TalUQrFYlIu/0dxn2DgOOhKJyAZK8Xh8KmmMezb2Mr4J6udg9aSWE3N7/llc\n", + "DLNk7tkxJsyfCyG49eud7SPMUWt1YLs6RXeaKL/q9WX2AEBmDvLNMUoa3lcwGJRNlILBoLxxsxLW\n", + "OABNtZ+mqddKpYJGo6HLSLy4uEChUJgpkn/T6YkAfB3A/wkhfl95i/sI/y7uWB9h/ta0222Z6sBi\n", + "nMfs3Da4zkoIAZvNdq1Nw4NauSeO2j1UfWRMIxJ/SbhzhSpFeFSjilqthlwuh/PzcznymcdGd7vd\n", + "G0c/3/Q/+CEAPw3gVSJ6efLaF3GH+wirtde1Wg3lchmBQECWsjwO8IxLm80Gt9t9abqdUb04HA6Z\n", + "GMYOQP4ss6jKwWCAdrsth5DxOGleRmnTaDSk6lSHy08j2DTcdHr6d1xdsXAn+wgzadjrWalUdLVP\n", + "jwNceOd2uy85zVSPMHDZyGXSGH1F15GH50vV63UpOZrNplzG0xDP+ORmTOrgsqVJs44YjUZyPkE2\n", + "m4XNZpP/KSy+543VGI+8qqNtmrrjagiGmsTV7/flqeyq0xkP5+DfV22Uab/PRX28+LjPk+2MpNE0\n", + "TQ4s47a23DLlXpJmOByi0Wggn88DGH+rUqmUPALHYjEAl4OF10FtIMB+lXlsJJZ86k1k+2aaocrk\n", + "ZjWjHtmntcrvdru6pktcPcHORePfYMnEf4ftISb0Tdg40oxGIzQaDRCRTgyzyK7X67q29rOQhj21\n", + "LpdLGoyj0UjaLDeBc5B5L3xiYUPVCN4nLyYBd0o3SgOOWvP7KsGmNVtiSaZ6vudpzLRxpBkOh1Id\n", + "XVxcwO12y65VXGY7D2mISEoWj8cDj8eD0WgkbZZZwJ20yuUyzs/PL0kC47ebc5VLpRLK5bKs8rzK\n", + "sFVTO4z20LQY2lW/M6szc+NIo9YxAeMbxmOQiQiaps1NGvXI7na7Ua1WUS6XUSwWEQ6Hb7wGO/t4\n", + "QguThSWD8aayq4CXao91u90nnnq6caQxQgiBTqeDarUKItIZwrOqJ0524mMx57Hw400wDnNnHwqr\n", + "BSNYIqqlMzz+5y5kEW48aUajkSRKr9dDrVYDMJsBzL9nTE1Q7ZtZ0hLUCDL36OM1LWeHKz15qW3z\n", + "7wLotph7V+JRaq7MoumbRnVmPILfBGNqxFXOO4aaBDbNTnlcEEJM/WZtPGlMLI6rSLNM+zQT9xQm\n", + "aUzMjWtJQ0S7RPQvRPS/RPRDIvrlyetr20fYxPK41qYhohSAlJojDOAzGEe1G+KaPsKmTbP+uMqm\n", + "WTRHGFiTPsImVo+ZbRolR/g/Ji+tRR9hE6vHTKSZqKa/wThHuIk16iNsYvW40U8zyRH+BwD/aEj5\n", + "5Pf3APy9EOJ9htdNm2bNsZCf5qocYbrDfYRN3D5uOj19GMC/AXgV47JcAPhNAJ/DWDXJPsJKHRT/\n", + "W1PSrDnMMIKJuWGGEUysDCZpTMwNkzQm5oZJGhNzwySNiblhksbE3DBJY2Ju3JqfxsTmwpQ0JuaG\n", + "SRoTc+NWSUNEzxLR60T01qQL6LLXyxDRq5MU0/9a4N8/T0QFInpNeS1CRC8Q0ZtE9L15coOuuN7C\n", + "qbDXpNcutMdbS9e9rq53mQXACuAAwB4AO4BXADyz5DUPAUSW+PcfwTiR7DXlta8A+PXJ8+cAfHnJ\n", + "630JwK8tuL8UgPdPnvsAvAHgmUX3eM31Ft6jEOJWJc0HARwIITJCiD6AbwP49Aquu3CaqRDiRQAV\n", + "w8ufwritLSaPn1nyesCCexRC5IUQr0yeNwGoLXjn3uM111t4j8Dtqqc0gKzy8wne3fCiEAC+T0Qv\n", + "EdHPLXktxm20t106FVZJr11JC95VpuveJmlu4yz/ISHEBwB8EsAvENFHVnlxMZbjy+576VRYMrTg\n", + "XXaPq07XvU3SnALYVX7exVjaLAwhRG7yeAHgOxirwGVRmJTqcEbiUu1thRDnYgIAX5t3j3RNC95F\n", + "9qhc7y/4esvu8TZJ8xKA9xDRHhE5AHwW41ayC4GIPETknzz3AvgEVpNmyu1tgRW0t10mFfaq9NpF\n", + "93hr6brLnGZmsN4/ibHFfgDgi0teax/jE9grAH64yPUAfAvAGYAexvbWFwBEAHwfwJsAvgcgtMT1\n", + "fgbjqTWvAvjB5OYm57jehwGMJp/x5cl6dtE9XnG9Ty6zRyGEGUYwMT9Mj7CJuWGSxsTcMEljYm6Y\n", + "pDExN0zSmJgbJmlMzA2TNCbmhkkaE3Pj/wFJ7Hv45ZreFAAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEeFJREFUeJzt3X+QXWV9x/HPJ7vZ3WySjaQhWpKY8LvAYIUiA4ga1Hao\n", + "I2hbK9BWqe3Y6ag1pZYRmWn/YNrRynREx2lnLBQFK7ZFizotCC1EESsRSPgVhNAhLSGFkIbdbJL9\n", + "mXz7x70bLsv+eJ6cPHvvDe/XzE7uOfu953n2PGfvfnN+PF9HhAAAAHDo5jW7AwAAAO2OhAoAAKAi\n", + "EioAAICKSKgAAAAqIqECAACoiIQKAACgos5mNm6bORsAAEDbiAhPtb5oQmX7QknXSeqQdH1E/NXk\n", + "mFWrVr3qfQMDA1qyZMkr1nV0dCS3O29e3om3AwcOJMfu378/OTZnjq+c2JyfL2e/HUr8VHbt2qWl\n", + "S5e+Yl2p/ZYzdiW3nfPzDQ8PJ8eOjo4mx+Ye91ON9fDwsHp6epJip9PZmf6x0tXVlRy7d+/e5Nic\n", + "fSxJY2NjybE5x0WrzPNnT/n5P6Wc46i7uzs5tq+vLzl28ufH4dquVO5YHhwcTI598cUXX7Vuqr97\n", + "ktTf35+8XSnv2G+Fv2dHkmKX/Gx3SPqypAslnSrpMtunlGoPAACgWUreQ3W2pKcjYmtEjEn6pqT3\n", + "FWwPAACgKUomVCskPduwvK2+blY5p5HRehYsWNDsLuAQ5VziAHD48Hev/ZVMqA75IupU93CgfZBQ\n", + "tS8SKqA5+LvX/kp+ej4nqfGO81WqnaV6hYGBgYOvu7u7OagAAEDbKZlQPSDpRNtrJG2XdImkyyYH\n", + "TfVUAwAAQDspllBFxLjtT0j6vmrTJtwQEU+Uag8AAKBZit4wERG3S7q9ZBsAAADN5mZOwGU7VqxI\n", + "evCv6GSPOfE5saUm08uJzemDVG4/l5oMMff4LTUpas7N3Dl9GBoaSo4dGRlJjs2NHx8fT4490if1\n", + "a8efL6fPuZ8ZJeT0oWR/W2Gsc/vQCn0+0k03Uzq1/AAAACoioQIAAKiIhAoAAKAiEioAAICKSKgA\n", + "AAAqIqECAACoiIQKAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAAoKKixZFT7N27Nymup6cneZsL\n", + "Fy7M6sOSJUuSY/v6+pJjc/qcY8+ePcmxw8PDxba9b9++5NixsbHk2FI1AqW8+nzd3d3JsYsXL06O\n", + "XbZsWXJsTo3A/fv3J8dK0q5du5Jjd+7cmRybU/cv53fvuOOOS44966yzkmMlaeXKlcmxq1evTo7N\n", + "+SwaGBhIju3v70+OlaQdO3Ykx3Z1dSXH5tSlHBwcTI7dsmVLcmzOZ0uunN+ppUuXJseefvrpybHH\n", + "H398cqyU9zuV87nV29ubHLto0aLk2AULFiTH5hybUl6dx9QaiDMd80XPUNleZfse24/bfsz2J0u2\n", + "BwAA0Aylz1CNSboiIjbZXiTpQdt3RcQThdsFAACYM0XPUEXE8xGxqf56j6QnJB1Tsk0AAIC5Nmc3\n", + "pdteI+kMSffPVZsAAABzYU4SqvrlvlslraufqQIAADhiFH/Kz/Z8Sd+S9PWIuG3y94eGhl7uTGen\n", + "5s+fX7pLAAAAs1q/fr3Wr1+fFFs0oXLtmcUbJG2OiOumisl5ZBIAAGCurF27VmvXrj24fM0110wb\n", + "W/qS31sl/Y6kC2xvrH9dWLhNAACAOVX0DFVE/EjMxg4AAI5wJDsAAAAVOXW69SKN23HyyScnxeaU\n", + "AMgpfZG77ZwyB6X2bc52c6bel/JKSeT0I6dkQM6DCTnlYaS8ny+n7EvOvhgZGUmOHR0dLbJdKe/3\n", + "pFR5j5zjIudYTi1pNSFnP+fst5zjIufYzD3uc+5VzTnuc46LnH2cUzIr9/O+1OdyzvGZE5tzXEh5\n", + "P18rxOZoZr7SKCKmHEDOUAEAAFREQgUAAFARCRUAAEBFJFQAAAAVkVABAABUREIFAABQEQkVAABA\n", + "RSRUAAAAFZFQAQAAVERCBQAAUFHTS88sWbKkxHaLxqc6cOBAcmxO+Zuc7ebESnlT++duu0QfSh6/\n", + "rdCPVim1AAComa70zLRFm2z/hqSQNNUbIyK+ndKw7Q5JD0jaFhEXpbwHAACgncxUBfMi1RKq6SQl\n", + "VJLWSdosaXFqpwAAANrJtAlVRPxu1Y3bXinpPZL+UtKfVN0eAABAK5r1pnTbb7B9g+076sun2v79\n", + "xO1/QdKVksrcbAMAANACUp7y+6qkOyUdU1/eIumK2d5k+72SdkTERk19HxYAAMARISWhWhYR/yhp\n", + "vyRFxJik8YT3nSfpYtvPSLpF0jtt3zQ5aHh4+ODX+HjKZgEAAFpLSkK1x/bPTSzYPkfSwGxvioir\n", + "I2JVRBwr6VJJd0fEhyfH9fT0HPzq7JzpHnkAAIDWlJLBfErS9yQdZ/vHko6W9IFDaIsJdQAAwBEp\n", + "aWJP252STlbtXqgn65f9qjfOxJ4HMbHnofWBiT0BAHMpe2LPCbYXSPqYpPNVO8t0r+2/jYjhw9tF\n", + "AACA9pRyye8mSbslfUm1M1S/JelmSb9ZsF8AAABtIyWhOi0iTm1Yvtv25sPVge7u7sO1qYNKXcKT\n", + "8i7B5PSjo6MjOXb+/PlFYiVlPRiQ0+ecfdHT05Mcm/sgQ1dXV3LsvHnptcNznlDNie3r60uO7e3t\n", + "TY6VpNWrVyfHnnDCCcmxOWOydevW5Njt27cnx27cuDE5VpJ2796dHLt3796sbac66qijkmNzfkek\n", + "vON+dHQ0OTZnrHM+65cvX54cu2fPnuRYSRoaGkqO3bdvX3Lstm3bkmMHBweTY3NuB5HK3YpxpEv9\n", + "GzVTDpDyF+Mh2+c2NHqOpAeTWgYAAHgNmKk48qMNMffZfla1e6jeKOnJOegbAABAW5itODIAAABm\n", + "MVNx5K2Ny7aXS8q7cA8AAPAakFIc+WLbWyQ9I+kHkrZKur1wvwAAANpGyk3pfyHpXElP1cvIvEvS\n", + "/UV7BQAA0EZSEqqxiNgpaZ7tjoi4R9JZhfsFAADQNlImEXnJ9mJJ90r6B9s7JOVN/AEAAHAESzlD\n", + "9X5J+yRdIekOSU+LJwABAAAOmvUMVURMnI3aL+mrRXsDAADQhjzdNOq296g2kedUIiLSa2JM17gd\n", + "K1asqLqZV8kpGSLlTdVfKrZUSZvcfVFy2yX6kFtmKKfsS46c8hBjY2NFtpsrpyxRTtmQnO2WKjOU\n", + "W9Iqp3xJTuzIyEhybM5nQE7ZJylvP+f0Oef3KWf8ckrl5JbXyinRlBObUzpo586dybE5JW0kaWBg\n", + "IDk257OoVEmbnOM+V4kydBGhiJhywzPNQ7WoasO2XyfpekmnqZac/V5E/KTqdgEAAFpJXmXZfF+U\n", + "9G8R8QHbnZIWFm4PAABgzhVLqGwvkfS2iLhckiJiXFL6uUgAAIA2UeYmmJpjJb1o+0bbD9n+O9vp\n", + "F6QBAADaRMmEqlPSmZL+JiLOlLRX0lUF2wMAAGiKkvdQbZO0LSJ+Wl++VVMkVLt37z74uru7O/vp\n", + "HAAAgBJynkIsllBFxPO2n7V9UkQ8Jendkh6fHNfXV3n2BQAAgMNu8tQLMyVYpZ/y+yPVytV0Sfov\n", + "SR8p3B4AAMCcK5pQRcTDkt5Ssg0AAIBmK3lTOgAAwGtC6Ut+s0otG5BT4mB0dDSrDznbzikFUqr0\n", + "TMmp+kttu1XKFrRCmaFS+wIA8LKSfyunwhkqAACAikioAAAAKiKhAgAAqIiECgAAoCISKgAAgIpI\n", + "qAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqanrpmbGxsaS4UiVfcs2bl56DdnR0FNluZ2f6\n", + "sOVsV5J6enqSYxcuXJgc29XVlRybUwoo9fg5lG0PDw8X6UfOvsgZj5zjQsr7+fr7+5Njh4aGkmNL\n", + "lezJ2W+S1NvbmxWfKqfPOZ9xObFSa5SUyikJlvvz5ShVEiy1jJqUd3wuWrQoOTY3vlRJt5zPgJzY\n", + "3LJyJUq6zXRsFj1DZfszth+3/ajtb9juLtkeAABAMxRLqGyvkfRRSWdGxOmSOiRdWqo9AACAZil5\n", + "yW+3pDFJvbb3S+qV9FzB9gAAAJqi2BmqiNgl6a8l/Y+k7ZL6I+LfS7UHAADQLCUv+R0v6Y8lrZF0\n", + "jKRFtn+7VHsAAADNUvKm9LMk/Tgi/i8ixiV9W9J5k4N279598GtkZKRgdwAAANJFhA4cOHDwayYl\n", + "76H6maQ/s71A0rCkd0vaMDmor6+vYBcAAAAOjW3ZPrjclGkTIuJhSTdJekDSI/XVXynVHgAAQLMU\n", + "ndgzIj4v6fMl2wAAAGg2Ss8AAABUREIFAABQkUvVeEpq3I7ly5cnxTazn40ab06bTYk6QrmxuTWx\n", + "StVWK1WLMbduY6n93G59KL1tADhSRcSUiQBnqAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAq\n", + "IqECAACoqCUTqtHR0WZ3ARWMj483uwsAAMwpEiocdrlzXwEA0O5aMqECAABoJyRUAAAAFTW99EzT\n", + "GgcAAMg0XemZpiZUAAAARwIu+QEAAFREQgUAAFBRyyVUti+0/TPbW2x/utn9wfRs/73tF2w/2rBu\n", + "qe27bD9l+07br2tmHzE926ts32P7cduP2f5kfT1j2OJs99i+3/Ym25ttf7a+nrFrI7Y7bG+0/b36\n", + "MuPXxloqobLdIenLki6UdKqky2yf0txeYQY3qjZWja6SdFdEnCTpP+rLaE1jkq6IiNMknSPp4/Xf\n", + "N8awxUXEsKQLIuLNkt4k6QLb54uxazfrJG2WNHEzM+PXxloqoZJ0tqSnI2JrRIxJ+qak9zW5T5hG\n", + "RNwr6aVJqy+W9LX6669Jev+cdgrJIuL5iNhUf71H0hOSVogxbAsRsa/+sktSh2q/i4xdm7C9UtJ7\n", + "JF0vaeKpMcavjbVaQrVC0rMNy9vq69A+Xh8RL9RfvyDp9c3sDNLYXiPpDEn3izFsC7bn2d6k2hjd\n", + "ExGPi7FrJ1+QdKWkAw3rGL821moJFXM4HEGiNicHY9ribC+S9C1J6yJisPF7jGHriogD9Ut+KyW9\n", + "3fYFk77P2LUo2++VtCMiNurls1OvwPi1n1ZLqJ6TtKpheZVqZ6nQPl6w/QZJsv3zknY0uT+Yge35\n", + "qiVTN0fEbfXVjGEbiYgBSf8q6ZfE2LWL8yRdbPsZSbdIeqftm8X4tbVWS6gekHSi7TW2uyRdIum7\n", + "Te4T8nxX0uX115dLum2GWDSRbUu6QdLmiLiu4VuMYYuzvWziCTDbCyT9sqSNYuzaQkRcHRGrIuJY\n", + "SZdKujsiPiTGr6213Ezptn9V0nWq3WR5Q0R8tsldwjRs3yLpHZKWqXa9/88lfUfSP0l6o6Stkj4Y\n", + "Ef3N6iOmV38q7IeSHtHLlxY+I2mDGMOWZvt01W5anlf/ujkirrW9VIxdW7H9DkmfioiLGb/21nIJ\n", + "FQAAQLtptUt+AAAAbYeECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioATWf7vvq/q21f\n", + "dpi3ffVUbQHA4cQ8VABahu21qk1yeFHGezojYnyG7w9GxOLD0T8AmA5nqAA0ne099Zefk/Q22xtt\n", + "r7M9z/a1tjfYftj2H9Tj19q+1/Z3JD1WX3eb7QdsP2b7o/V1n5O0oL69mxvbcs21th+1/YjtDzZs\n", + "e73tf7b9hO2vz+3eANCOOpvdAQDQy6VvPi3pTyfOUNUTqP6IONt2t6Qf2b6zHnuGpNMi4r/ryx+J\n", + "iJfqte022L41Iq6y/fGIOGOKtn5d0i9KepOkoyX91PYP6997s6RTJf2vpPtsvzUiuFQIYFqcoQLQ\n", + "Sjxp+Vckfdj2Rkk/kbRU0gn1721oSKYkaZ3tTZL+U9IqSSfO0tb5kr4RNTsk/UDSW1RLuDZExPao\n", + "3ROxSdKaCj8TgNcAzlABaHWfiIi7GlfU77XaO2n5XZLOiYhh2/dI6pllu6FXJ3ATZ69GGtbtF5+V\n", + "AGbBGSoArWRQUuMN5N+X9DHbnZJk+yTbvVO8r0/SS/Vk6hckndPwvbGJ909yr6RL6vdpHS3p7ZI2\n", + "6NVJFgDMiv91AWgFE2eGHpa0v37p7kZJX1LtcttDti1ph6Rfq8c3PqJ8h6Q/tL1Z0pOqXfab8BVJ\n", + "j9h+MCI+NPG+iPgX2+fW2wxJV0bEDtunTNq2plgGgFdg2gQAAICKuOQHAABQEQkVAABARSRUAAAA\n", + "FZFQAQAAVERCBQAAUBEJFQAAQEUkVAAAABWRUAEAAFT0/9KDBwoLkjK0AAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEBVJREFUeJztnVuMJNdZx39f36d6+rI9O7PDrveSlQKysSX7xSA5EREK\n", + "0fqFwEsiS0hRgIgHboIHTHiJHyMkIsQLEoqNwkWJEMgoIAG2ERJBKIDROnYgjmPJK8/sXHd2unu6\n", + "p+99eOg+h+qanktX12Snqs5PKk13zXTpm93/fOec73zfd0QphcUyC4lHbYAlfFjRWGbGisYyM1Y0\n", + "lpmxorHMjBWNZWZ8i0ZE7ojIuyLyAxF5MUijLBcb8ROnEZEk8H3gk8B94L+AF5RS3wvWPMtFxK+n\n", + "eRZ4Xyl1TynVA74BfDo4sywXmZTPz10D1lzv14GfcP+AiNhQc8hRSsm0+349jRVEjPErmvvAddf7\n", + "64y8jSUG+BXNm8BHReSWiGSAzwLfDM4sy0XG15xGKdUXkV8D/glIAi/blVN88LXkPtOD7UQ49AQ9\n", + "EbbEGCsay8xY0VhmxorGMjNWNJaZsaKxzIwVjWVm/G5YWk5ARMwFkE6nzZVKpRgOhwwGA/r9PoPB\n", + "wLzXXy86VjTnQCKRIJlMkkwmSaVSlMtlKpWKuVqtFo1Gw1ytVmviGg6Hj/pXOBErmnMgkUgYz5LJ\n", + "ZFhZWeHWrVvcvHmTmzdvUqvV2N3dNdf+/j7VahWlFO12+1GbfypWNOeA9jDZbJZcLsfKygq3b9/m\n", + "qaee4sknn2RnZ4e1tTU+/PBDstks6XQapRSdTscMaReZuUQjIveAOjAAekqpZ4MwKuwkEgkymQy5\n", + "XA7HcahUKly9epXbt2/zxBNPUCqVEBE6nQ4HBwc0m03q9TqpVCr6omGUjPUJpdTDIIyJCslkknQ6\n", + "zcLCAouLiywsLJDJZEgmkwAMh0P6/T69Xo9Op0Ov16Pf7zMcDglDbX0QS+6L/6fxQyaZTJLJZE4U\n", + "zWAwoNfr0e126Xa7RjRhYF7RKOANEXlTRL4QhEFR4CyiOc7ThIF5h6fnlFKbIrIMvC4i7yqlvhWE\n", + "YWFGiyaXy02IJpFIoJQyXqbdbnN4eEir1aLX6zEYDKI/PCmlNsdfd4FXGZW2xB49EXZ7mnQ6TSKR\n", + "YDgc0ul0aDabVKtVHjx4QLVapdls0u12oy0aEXFEpDB+nQc+BbwTlGFhxj085fN5IxoRYTAY0O12\n", + "aTab1Go19vb2qNVqRjRhYJ7h6Qrw6niJmAL+Uin1WiBWhRzvnCaXyxnRuD1NrVbjwYMHNJtN+v0+\n", + "/X4/FJ7Gt2iUUh8ATwdoS2jRsRW93+QWTLlcxnEcUqmUCeC1Wi2azSYHBwfUarVQRIHd2IhwACQS\n", + "CVKplNlvKhaLVCoVVlZWuHr1KoVCgVQqRavVMtsGjUYjNHMYL1Y0AaCDeZlMhkwmQ6lUYmlpiStX\n", + "rnDt2jVEBKWU8TAPHz6k0WjQ6XQetem+sPk0AeBeYufzeUql0oSnKZVKJJNJ42m0aMLqaaxoAkB7\n", + "Gi2aQqHApUuXWFpaYmVlhcXFRUSEZrMZieHJiiYAdCqE3qDM5XJkMhkTmxkMBrRaLZMSsb+/H6q4\n", + "jBcrmgDQniabzeI4jokA68nxNNFoTxNGrGgCQHuabDbLwsICuVzO5MlME03YIsBerGgCQE+EHceh\n", + "UCjgOA7ZbNbkx/T7fVqtFvV6nb29PSsaC+RyOUqlEisrK9y4cYPl5WXy+TyJRMIE8w4PD01A7/Dw\n", + "kE6nQ7/ff9Sm+8KKJgCy2SzFYpGVlRUee+wxLl++PCEavZutE8kPDw/pdruh2dX2YoN7AZDNZimV\n", + "SiwvL3Pjxg2KxSKLi4skk8ljPY3OoQkjp3oaEXlFRLZF5B3XvYqIvC4i74nIayJSPl8zLx7u2qZc\n", + "LkexWGR5eZmrV69SqVRwHGfC02jh6JKVMHuaswxPfwrc8dz7XeB1pdSPAv88fh8b9F6TjgIvLCzg\n", + "OI4J7DmOM5F0pdM7dUGcvsIoGDiDaMaZePue2z8LfG38+mvAzwVs14XmONEsLi5SKBQmMvXcInFX\n", + "UiqlQisav3OaK0qp7fHrbUa5NbHBLRp3spX2NDphXCllcn+93iasgoEAJsJKKRW3/nq6GE4LxnEc\n", + "Mzzl83k6nc4RwXivMON3yb0tIqsAIvIjwE5wJl18UqmUSRovlUrk83lyuRyp1OhvUM9jdMWBu9A/\n", + "CvgVzTeBz41ffw7422DMufiIyIRoyuWySenUEWB3Vwi3aMI8JLk5y5L768C/Az8mImsi8nngy8DP\n", + "iMh7wE+P38cGr6dxiwame5qwT37dnDqnUUq9cMy3PhmwLaFBF/fn83nK5TL5fN7sNcHRYriwVVCe\n", + "ho0I+2BaiYq7grLT6VCv19nd3WV7e5udnR2TQB4FT2P3nnzg7gqhJ8Fe0dRqNdNSZHt7m2q1Grqq\n", + "g+OwovGBN71T1zVp0XS7XeNp1tbWIudp7PA0I3r1dNLw1G63jWjW19d58OCBFU3c0GmbqVSKdDpN\n", + "uVw2SeOrq6uUSiUymQyDwYBGo2GK4KrVKvv7+xwcHJgi/yhgRXMKIkIymSSbzZp2aLrSYHl5mdXV\n", + "VfL5/BHR1Ov1I6IJS9ntaVjRnAEdl9Gbkl5Pk0gkTHF/o9GgXq9PeBqdCmE9TYxwx2WKxeJETdPq\n", + "6qrJmdGX19P0er3Qp0O4saunM6A9TaFQoFwuUygUTEDP20Lk8PCQdrs9EdCLSiRYY0VzCiIy0XTx\n", + "0qVLFIvFIxUHw+GQbrdLq9U6IpqoCceK5gy4PY0WjTs+Yz2Nh2NyhF8SkXURuTu+vOmgkUJ7Gu/w\n", + "5N6kHAwGdDqdqaKJmnD85ggr4CtKqWfG1z8Gb9rFQC+5j+uhB9Dr9Tg8PDSdrXQxXK/Xi4xQ3PjN\n", + "EYYY9Q8+rcWrWzTestsoMs+c5tdF5Dsi8nLUS1i8u9reDcper2e6de7u7lKr1UxBXBTxK5o/Bj7C\n", + "qOfeJvAHgVl0ATlteNITYDs8nYBSakeNAb5KxPoH6/Oa3GUqOhpcKpVYWFiY6AbRaDSo1Wo8fPjQ\n", + "iEZXUUYRX6IZJ5Nrfp6I9Q/Wk1/dR08PS4VCgWKxSC6XM6LRVZP1ep39/X2zox3l4enUbYRxjvBP\n", + "AZdFZA34EvAJEXma0SrqA+BXztXKHzLTPI0Wje6fl0wmTQsR7Wm0aHSKZ1SHJ785wq+cgy0XAl2f\n", + "7fY0enjSonGfP9npdI4MT1HZYzoOu2E5hUwmw+LiotmgrFQqE1sHrVbLzGfa7TbNZpN2uz2xMRll\n", + "7DaCBxEhm82yuLhIpVLhypUrLC0tUSqVcBzHbBv0ej3T3Uo3KYpSbdNJWNF40G3qC4UCS0tLrK6u\n", + "srS0ZDxNOp0GmGiJ1mw2Q93ZalasaKZwkqfJZDLApGjcniYOWNFMwdvi1d2pUzOt7DbqcxmNFY0H\n", + "ETnSf0b3BNanrejJrj5uJ0yHlgaBFc0U3KLJZrNmn0lvG7i7W+ljBK1oYo7X06TTaVKp1FTRuIcm\n", + "K5qY4k7vdCdduROu+v0+7XabRqNBtVql0WjQbrft6inOpNNpHMcx5zZ5l9vu/Bl9BmWUNyi92Iiw\n", + "B+1pHMcx0WCdDqE9jRaNbluvl91xEc2JnkZErovIv4jI/4jId0XkN8b3I91HeJqn0Tk0gIkGa09T\n", + "r9cjVXZ7GqcNTz3gt5RSPw78JPCrIvI4Eesj7E2yyufz5ggefaLKtImwXnbbibALpdSWUuqt8esG\n", + "8D3gGhHqI6yHI90OTbeodx/2pRsA6DhN3DnznEZEbgHPAP9BxPoIu2u1S6WS6TquRaPza7SniTtn\n", + "Eo2ILAJ/A/ymUurA/RcX9j7C3m6duvGiWzTucxAsZ8vcSzMSzJ8rpXTr120RWVVKbYW9j/C01ZKu\n", + "oNSCUUqZeYtO8Ww2m+YonrAfkDErp62eBHgZ+F+l1B+6vhWpPsKZTMZ06tQ72nq15C651amd7h40\n", + "tVrNJGHFJbh3mqd5DvgF4G0RuTu+90VGfYP/SkR+CbgHfObcLDxndP6M4ziUy2UuX748kXAFGNHo\n", + "I3jcgqlWq3S7XVOGGwdOFI1S6t843htFoo+wFo0+hN0tGj08DYdDE5txexktnKiceXBWYhkRdk9o\n", + "dXtXLZpKpWKO35kWAa5WqxNDkq44iMNcRhNL0cBk1YHucqVFoyPAqVQKpZSpoNRlt97TbrVg4iKc\n", + "WIpGJ1q5RaNjNJcuXZrqaZrNpinw157GXQwXF8FAjEWjhTPN0+jewHoi3O12TYH/tFrtOAkGYioa\n", + "L1pAWkR6SBIRut0u1WqVvb09tre32dzcZG9vj0ajYQ4DixuxFI32Dvryns+klDKrJRFhZ2eHra0t\n", + "Njc3WV9fNzvbnU7nUf8qj4RYikbjFY1bOJp+v29OU9nY2OD+/fsmwBfVAv/TiK1o9LDijrG4S1L0\n", + "1el0jGg2Nze5f/8+vV7PXHEklqJxz0OGwyHNZpO9vT02NjZwHMcIRx/ytba2xtbWFvv7+zQajdgF\n", + "87zEUjQavRFZr9fZ2NggkUhwcHBghipdorK5ucnOzg4HBweR7NY5K7EVjf4PHwwG1Go1RIRms8nW\n", + "1taRw9f1lkGj0TClt3EVDICc9MuLyHXgz4AVRg2M/kQp9Uci8hLwy8Du+Ee/6G0LG5YcG50aoWub\n", + "3IeX6q/uOY7elIyDaJRSUxOIThPNKrCqlHprnIj134xSOz8DHCilvnLCZ6P/rxpxjhPNabvcW8DW\n", + "+HVDRHSOMMSoj7BlkjMnvbpyhL89vhWbPsKWSc4kmvHQ9NeMcoQbxKyPsGWSE+c0YHKE/x74B0/K\n", + "p/7+LeDvlFJPee7bOU3IOW5O4ytHOOp9hC0nc9rq6WPAvwJvM1pyA/we8AKjocn0EXbVQenPWk8T\n", + "cnwtuefBiib8+BqeLJZpWNFYZsaKxjIzVjSWmbGiscyMFY1lZqxoLDNzbnEaS3SxnsYyM1Y0lpk5\n", + "V9GIyB0ReVdEfiAiLwbwvHsi8raI3BWR//Tx+VdEZFtE3nHd893e9pjnvSQi62Mb74rInRmeF2gL\n", + "3hOe59tG4Gi1YVAXkATeB24BaeAt4PE5n/kBUJnj8x9nlEj2juve7wO/M379IvDlOZ/3JeC3fdq3\n", + "Cjw9fr0IfB943K+NJzzPt41KqXP1NM8C7yul7imlesA3gE8H8FzfaaZKqW8B+57bvtvbHvM88Gmj\n", + "CrgF7wnP820jnO/wdA1Yc71f5/8N9osC3hCRN0XkC3M+S3Me7W3nToUNugVvkOm65yma81jLP6eU\n", + "egZ4nlH39I8H+XA18uPz2j13Kqy3Be+8NgadrnueorkPXHe9v87I2/hGKbU5/roLvMpoCJyX7XGp\n", + "js5InKu9rVJqR40BvjqrjSe14PVjo+t5f6GfN6+N5ymaN4GPisgtEckAn2XUStYXIuKISGH8Og98\n", + "imDSTANtbztPKmzQLXjPLV13ntXMGWbvzzOasb/PqApznmd9hNEK7C3gu36eB3wd2AC6jOZbnwcq\n", + "wBvAe8BrQHmO5/0io4rUt4HvjP9zr8zwvI8Bw/HveHd83fFr4zHPe34eG5VSdhvBMjs2ImyZGSsa\n", + "y8xY0VhmxorGMjNWNJaZsaKxzIwVjWVmrGgsM/N/z4EQsKT2Kt0AAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAD2tJREFUeJzt3XuwnVdZx/HvLydJ25OEdmqxLRAMKijtgBSBKXcK6FQG\n", + "CioCVQHRwXEAqRUZLjP6lw4I41AZRmewlUsRUAELjHKpUqGANBSS3rk5VFuQxkuBXKbpOcnjH3sn\n", + "nB5Okv3mzTr73en3M7On+3332u9aZ699Tp6utd71pKqQJEnS0Vsz7QZIkiTNOgMqSZKkngyoJEmS\n", + "ejKgkiRJ6smASpIkqScDKkmSpJ7WTrPyJO7ZIEmSZkZVZaXzTQOqJOcDlwBzwKVV9afLy5x55pk/\n", + "9L6dO3eyadOmo653//79ncrv27evybVbXbdL2a77jB2LdiwuLrJ27T2/Wl3a0aosdP9utGqHJOn4\n", + "0mzKL8kc8DbgfOAs4MIkD21VnyRJ0rS0XEP1GOAbVXVrVS0A7wee3bA+SZKkqWgZUN0fuG3J8e3j\n", + "c0e0fv36Jg3S6lizxnsdJEn3Li3/5TvqRSUnnHDCsWyHVpkBlSTp3qblovRvAZuXHG9mNEp1Dzt3\n", + "7jz4fP369QZTkiRp5rQMqK4FHpxkC/Bt4PnAhcsL9bmbT5IkaQiaBVRVtZjkFcAnGG2bcFlV3dKq\n", + "PkmSpGlpug9VVX0M+FjLOiRJkqZtqjulA2zYsGGicl0WOnddFN3q2ieeeGKTspN+ZgDz8/MTl+3a\n", + "ji5lu6yN6/LznXzyyROXBTjjjDMmLrvSprOHcvrpp09c9pRTTpm47PINUo9VWYBkxc1+VzQ3N9ek\n", + "HV2u2+Xu35Y3RnT53LqUbfk3rotWP1+rsse7rpsGu8nw0Zn0czvc3zdvx5IkSerJgEqSJKknAypJ\n", + "kqSeDKgkSZJ6MqCSJEnqyYBKkiSpJwMqSZKkngyoJEmSejKgkiRJ6smASpIkqScDKkmSpJ4yzbw/\n", + "Seq0006bqGyX/GBdcn51Ld8qT9m+ffsmLruwsNCkLMDdd9/d5Npdfr4uZffv3z9xWeiW56rLtVv9\n", + "HnW5bsucX+YHa6/lZzyE76e0klnL21hVVNWKjW46QpVkc5KrktyU5MYkr2xZnyRJ0jR0S0/f3QJw\n", + "cVVtT7IR+FKSK6vqlsb1SpIkrZqmI1RV9Z2q2j5+vgu4BbhfyzolSZJW26otSk+yBTgHuGa16pQk\n", + "SVoNqxJQjaf7PgBcNB6pkiRJOm60XkNFknXAB4H3VNUVy1/fvXv3wefr1q3rfIeeJElSC13uZG0a\n", + "UGV0P+RlwM1VdclKZTZs2NCyCZIkSUdl+bYOhwuwWk/5PR74deC8JNvGj/Mb1ylJkrSqmo5QVdVn\n", + "cTd2SZJ0nDPYkSRJ6qn5ovQjmZ+fn6hcl4Vhi4uLndrQJd1Kq7Qos5gGpEs71qyZPHbvUrarVilw\n", + "unznulx3KN+LIaSHaJkKaCi/U5MaQn9At3bM2mc8FEPp61aOp++FI1SSJEk9GVBJkiT1ZEAlSZLU\n", + "kwGVJElSTwZUkiRJPRlQSZIk9WRAJUmS1JMBlSRJUk8GVJIkST0ZUEmSJPU09dQzu3btmqhcl+33\n", + "u27V3yotSpd2tEpH0iVdR9fyrVKBtEwxMoSfbyjpZDS7/F7ce9jXs+OQAVWSXwYKWCkqqKr60CQV\n", + "JJkDrgVur6pnHVUrJUmSBuxwI1TPYhRQHcpEARVwEXAzsGnSRkmSJM2SQwZUVfUbfS+e5AHAM4A/\n", + "AX6/7/UkSZKG6IgLgpKckeSyJB8fH5+V5LcmvP5bgFcD3RbySJIkzZBJVli/E/gkcL/x8deBi4/0\n", + "piTPBHZU1TZWXoclSZJ0XJgkoDqtqv4W2AdQVQvA4gTvexxwQZJvAu8Dnprk3csL7dmz5+BjYWGh\n", + "Q9MlSZKGYZKAaleSHzlwkORc4HtHelNVvb6qNlfVg4AXAJ+qqhctLzc/P3/wsW7dui5tlyRJGoRJ\n", + "9qF6FfBR4MeTfB64L/Dco6jLzTQkSdJxKZNsGpZkLfBTjNZCfXU87de/8qROPfXUSct2uW6ndrTa\n", + "rLPLhmxdNvZstTlly2u7sWf7spKk9qpqxUDgiCNUSU4CXgY8gdEo09VJ/rKq7jq2TZQkSZpNk0z5\n", + "vRv4PvBWRiNUvwpcDvxKw3ZJkiTNjEkCqrOr6qwlx59KcvOxakCX6bZWukztdJ1OnNTc3NzEZbss\n", + "3m/VXhjGNFeXqVKAxcVJblBtW7bllGYXrabRW03vDuVzk6SVTBLNfDnJYw8cjO/y+1K7JkmSJM2W\n", + "wyVHvmFJmc8luY3RGqoHAl9dhbZJkiTNhCMlR5YkSdIRHC458q1Lj5P8KHBi6wZJkiTNmkmSI1+Q\n", + "5OvAN4FPA7cCH2vcLkmSpJkxyaL0PwYeC3xtnEbmacA1TVslSZI0QyYJqBaq6n+ANUnmquoq4FGN\n", + "2yVJkjQzJtmH6s4km4Crgb9JsgPY1bZZkiRJs2OSEarnAHuAi4GPA9/AOwAlSZIOOuIIVVUdGI3a\n", + "B7yzaWskSZJm0OE29tzFaCPPlVRV3eeYNGDtJLOObXVJadEl1ckQ0mp0TcExhHQyLVOMzGKftLpu\n", + "y7RELZhORtKQHW4fqo19L57kFOBS4GxGwdlvVtUX+l5XkiRpSFoPD/058E9V9dwka4ENjeuTJEla\n", + "dc0CqiQnA0+sqhcDVNUi8L1W9UmSJE3LJHf5Ha0HAf+d5B1Jvpzkr5LMN6xPkiRpKloGVGuBRwJ/\n", + "UVWPBHYDr21YnyRJ0lS0DKhuB26vqi+Ojz/AKMC6h507dx587N27t2FzJEmS2mi2hqqqvpPktiQP\n", + "qaqvAU8HblpebtOmTa2aIEmStCpa3+X3u4zS1awH/h14SeP6JEmSVl3TgKqqrgMe3bIOSZKkaWu5\n", + "hkqSJOleYep5X+bnJ9tJYXFxceJrdkkP01KX1B5r1gwjth1CWpSWKVG6fDe6fOdalT3e06106euh\n", + "pMoZQpohScMzjH/FJUmSZpgBlSRJUk8GVJIkST0ZUEmSJPVkQCVJktSTAZUkSVJPBlSSJEk9GVBJ\n", + "kiT1ZEAlSZLUkwGVJElST1NPPbN79+6JyrVM99AqPUSr1DMt09TMzc1NXHbdunVNrtulP7qkcQG4\n", + "++67Jy67d+/eict26esun0VLXT7n/fv3T1y2S3qfVm1omaamVbqcoaSpGUo7pFnTdIQqyeuS3JTk\n", + "hiTvTXJCy/okSZKmoVlAlWQL8FLgkVX1MGAOeEGr+iRJkqal5ZTf94EFYD7JPmAe+FbD+iRJkqai\n", + "2QhVVf0f8GfAfwLfBr5bVf/cqj5JkqRpaTnl9xPA7wFbgPsBG5P8Wqv6JEmSpqXlovRHAZ+vqv+t\n", + "qkXgQ8DjlhfatWvXwUeXO7AkSZKGouUaqq8Af5jkJOAu4OnA1uWFNm7c2LAJkiRJ7bVcQ3Ud8G7g\n", + "WuD68em3t6pPkiRpWppu7FlVbwLe1LIOSZKkaTP1jCRJUk8GVJIkST1NPZdfl/xcrbTMjTepLvmz\n", + "uuRK6/r5drnTcs+ePROXbdXmLtfteu0uZVvlmpzFvGqt2ny8f26SZtv0IwlJkqQZZ0AlSZLUkwGV\n", + "JElSTwZUkiRJPRlQSZIk9WRAJUmS1NMgAyqTJM+2hYWFaTdBR8ntBiTp6AwyoPIf5Nm2uLg47Sbo\n", + "KBlQSdLRGWRAJUmSNEsMqCRJknrKNIf4kzi/IEmSZkZVZaXzUw2oJEmSjgdO+UmSJPVkQCVJktTT\n", + "4AKqJOcn+UqSryd5zbTbo0NL8tdJ7khyw5Jzpya5MsnXknwyySnTbKMOLcnmJFcluSnJjUleOT5v\n", + "Hw5ckhOTXJNke5Kbk7xhfN6+myFJ5pJsS/LR8bH9N8MGFVAlmQPeBpwPnAVcmOSh022VDuMdjPpq\n", + "qdcCV1bVQ4B/GR9rmBaAi6vqbOBc4OXj3zf7cOCq6i7gvKp6BPBw4LwkT8C+mzUXATcDBxYz238z\n", + "bFABFfAY4BtVdWtVLQDvB5495TbpEKrqauDOZacvAN41fv4u4Dmr2ihNrKq+U1Xbx893AbcA98c+\n", + "nAlVtWf8dD0wx+h30b6bEUkeADwDuBQ4cNeY/TfDhhZQ3R+4bcnx7eNzmh2nV9Ud4+d3AKdPszGa\n", + "TJItwDnANdiHMyHJmiTbGfXRVVV1E/bdLHkL8Gpg/5Jz9t8MG1pA5R4Ox5Ea7clhnw5cko3AB4GL\n", + "qmrn0tfsw+Gqqv3jKb8HAE9Kct6y1+27gUryTGBHVW3jB6NT92D/zZ6hBVTfAjYvOd7MaJRKs+OO\n", + "JGcAJDkT2DHl9ugwkqxjFExdXlVXjE/bhzOkqr4H/CPws9h3s+JxwAVJvgm8D3hqksux/2ba0AKq\n", + "a4EHJ9mSZD3wfOAjU26TuvkI8OLx8xcDVxymrKYoSYDLgJur6pIlL9mHA5fktAN3gCU5Cfg5YBv2\n", + "3UyoqtdX1eaqehDwAuBTVfVC7L+ZNrid0pP8AnAJo0WWl1XVG6bcJB1CkvcBTwZOYzTf/0fAh4G/\n", + "Ax4I3Ao8r6q+O6026tDGd4V9BrieH0wtvA7Yin04aEkexmjR8prx4/KqenOSU7HvZkqSJwOvqqoL\n", + "7L/ZNriASpIkadYMbcpPkiRp5hhQSZIk9WRAJUmS1JMBlSRJUk8GVJIkST0ZUEmSJPVkQCVp6pJ8\n", + "bvzfH0ty4TG+9utXqkuSjiX3oZI0GEmewmiTw2d1eM/aqlo8zOs7q2rTsWifJB2KI1SSpi7JrvHT\n", + "NwJPTLItyUVJ1iR5c5KtSa5L8tvj8k9JcnWSDwM3js9dkeTaJDcmeen43BuBk8bXu3xpXRl5c5Ib\n", + "klyf5HlLrv2vSf4+yS1J3rO6n4akWbR22g2QJH6Q+uY1wB8cGKEaB1DfrarHJDkB+GyST47LngOc\n", + "XVX/MT5+SVXdOc5ttzXJB6rqtUleXlXnrFDXLwE/AzwcuC/wxSSfGb/2COAs4L+AzyV5fFU5VSjp\n", + "kByhkjQkWXb888CLkmwDvgCcCvzk+LWtS4IpgIuSbAf+DdgMPPgIdT0BeG+N7AA+DTyaUcC1taq+\n", + "XaM1EduBLT1+Jkn3Ao5QSRq6V1TVlUtPjNda7V52/DTg3Kq6K8lVwIlHuG7xwwHcgdGrvUvO7cO/\n", + "lZKOwBEqSUOyE1i6gPwTwMuSrAVI8pAk8yu87z7AneNg6qeBc5e8tnDg/ctcDTx/vE7rvsCTgK38\n", + "cJAlSUfk/3VJGoIDI0PXAfvGU3fvAN7KaLrty0kC7AB+cVx+6S3KHwd+J8nNwFcZTfsd8Hbg+iRf\n", + "qqoXHnhfVf1DkseO6yzg1VW1I8lDl12bFY4l6R7cNkGSJKknp/wkSZJ6MqCSJEnqyYBKkiSpJwMq\n", + "SZKkngyoJEmSejKgkiRJ6smASpIkqScDKkmSpJ7+H8jVQl8390BQAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAGlxJREFUeJztnVls49t93z+Hi7iJu0Rq44xm5l4bAVzAfnEfnKB5CIJr\n", + "FEjSlwYGChTpgj50Q/vQJH1o/JgGaFC0D0Xb2EE3JC1auEgKtLUNtIj70DYOfGNf9/pO7r3SSENR\n", + "JCVS3ClS5OmD+Ds+5FALN4nS/L/AwZ/L8Mwh/1/9zm8/SmuNAweTwHXfC3Dw8OCQxsHEcEjjYGI4\n", + "pHEwMRzSOJgYDmkcTIypSaOUek8p9SOl1J8opX55notysNxQ0/hplFJu4CPgZ4As8IfAV7TWH853\n", + "eQ6WEdNKmi8CH2ut97XWXeB3gZ+f37IcLDM8U35uGzi0nr8G/rT9D5RSjqv5gUNrrca9Pq2kcQjx\n", + "FmNa0mSBjPU8w6W0cfAWYFrSfBd4Vym1q5RaAX4R+L35LcvBMmMqnUZrfaGU+hvAfwfcwNccy+nt\n", + "wVQm960mdhThB495K8IO3mI4pHEwMRzSOJgYDmkcTAyHNA4mhkMaBxPDIY2DiTFtwPLRQ6kfuyjc\n", + "brcZHo8Hl8tlhtvtRmtNv99Ha43WmouLC3q9HhcXF1xcXJjXAR5DyZBDmjFQSpnhcrkIhUKsrq6a\n", + "q9/vJxAImKuQo9vtcnFxQbVaNaNSqdDr9ej1evT7fXq93n1/vZnhkGYMbMK43W5WV1dZW1szIxqN\n", + "Do3z83Pa7Tbn5+ecn5+Ty+XI5XIcHx/T6XTodDqGVA5pHimEMKOkyWQy7OzskEqlWF9fN6PZbNJo\n", + "NMw1Go3i9XrpdruUy2Uzb6/XQyn14LeomUijlNoHqkAP6GqtvziPRd03bCnj9XpZXV0lmUyyvb3N\n", + "8+fP2djYIJ1Os7GxQSqVotFo0Gg0qNfrNBoN+v0+zWaTcrnM6uqqIcrFxcV9f7W5YFZJo4Gf1lqX\n", + "5rGYZYBsTUKYlZUVQqEQsViMtbU1Njc3icfjrK6u4vV6gUtFeWVlhUAggFKKSCRCNBolHo+TSCRw\n", + "u90AXFxc0G63325JM8DYSOhDhi1lfD7fEGk2NjYIhUKEQiFWVlaAH5NGKYXH4yESiRCLxYjH4yST\n", + "SSNlWq3WPX+z+WAekubbSqke8M+11v9yDmu6d7hcLjweDx6PZ4g06+vrbG5u4vV68Xg8eL1etNa4\n", + "3W5DGJ/PZ0iTSCRIJpN0u13a7Ta1Wm3IlH+omJU0X9Ja55RS68C3lFI/0lp/Zx4Lu2vIzXS5XHi9\n", + "Xvx+P6urq0NSQ7abUYjSLPMEg0FjnofDYarVKj6fz2xTDx0zkUZrnRtci0qpb3BZ2vLgSCM3XaRF\n", + "NBo15nUqleLJkyckk0mCweB9L3UpMEuFZVApFR48DgE/C/xgXgu7S4i15PF4WFlZIRKJkE6n2d3d\n", + "5bOf/SyZTIa1tTUCgcCN87wNmEXSpIFvDH4oD/DvtNbfnMuq7hC2eS2kiUajbGxssLu7yzvvvMP6\n", + "+rojaSxMTRqt9R7w+Tmu5c5gb0di+cgIBoPGStrZ2WF3d5dwOGzCB9dBa/2GN1kUZjHffT6fiUfJ\n", + "Z0bHsuOt8wgrpfD7/UPxo2AwSDAYJBAIEA6Hef78Odvb26ytrREOhwkGg7dSZGV7sq2uaDRKu92m\n", + "2+3S7/dRStHpdExAs9fr0e12Tdyq2+0uPXHeOtK4XC78fv9Q7CgSiRAOhwmHw0SjUXZ2dgxpIpGI\n", + "kRK3tX7cbjd+v9+QxiaMx+Oh3W7T6XQ4Pz+n0+nQarVot9u0Wi263e6Cf4HZ8daRRiRNNBo1MSQx\n", + "p2VITEkkjWw1N5FGtqdRSWMTxufz0Wg0aLVatFotms3mg/MYv5WkCQQCxGIx0uk029vbJJNJMxKJ\n", + "hAkDRCKRqZRfj8eD3+8nHA5zfn4+5PsJhUJDcap6vW7CEeI1lhjVsuo4bx1pXC4XwWCQRCLBzs4O\n", + "z58/N9tTJBIxRJnGGSc6jdfrJRgMmq0mEAgQiUSGIuH2tVgscnx8jMfj4eLigvPz86FErmUjzltH\n", + "GvHYrq2tsbOzw4sXL4YSqvx+Pz6fD5/Ph8cz3c8jpAFYWVkxEkf0GNmW5BoOh3G73SY63mg0TG5O\n", + "r9dzSHPfkEy8ZDJpJI3EmcREttM7J4HoNEIar9dLKBQymXsiPYQ4ovyKGd5qtSiXy4YkvV6PTqez\n", + "iJ9hJrwVpLFzev1+P5FIhGQyycbGBpnMZceUWXJ4hSzy2O1243K5TBRcIP9GpIhk/ImEqdVqlMtl\n", + "4+tZ1sj4oyeN2+025nQ4HGZtbY3d3V3W19cJBoMmQcq+Tgo7sdxOMJdhk9Z2+glB4/E4Ozs79Pt9\n", + "/H4/2WyW168v2/3U6/WlSxF99KRxuVxEIhE2NjbY2Nhge3t7iDTAG8SZFFprkzg+bsj25/V6h+Jc\n", + "8jgejxvCJBIJVldX0VpTr9c5Pj6e908yMx49aUTSbG5u8uLFC54/f87Ozs5CJI3oLfJYrjKv6Ehi\n", + "govESSQSBAIBkskkmUwGr9drCLOM6RQ3kkYp9XXgzwIFrfWfGryWAP498BTYB/681vpsgeucCHLj\n", + "7Uy6dDrNs2fP+MxnPkMikTA3ahqMbj8SBpAhiq+tAPf7feDNNAyllEncEjSbTV6/fk0sFjPkWqbY\n", + "1G0kzW8D/xT419ZrvwJ8S2v9G4PG078yGPcOsV5kSxDfi9QtiQ9Git5GFeDb3JTRkhWxhGSIlSQj\n", + "EAiY+JbEuGT4/f43pJsksycSCTY3N/H5fEP/pxDwvnAjabTW31FK7Y68/HPAnxk8/lfA/2SJSOPx\n", + "eMwNiUajRgmWGyaksS0e+3oTzs/PqdVqVKtVarXakHe30WgMkebi4oJQKGQi5aurq8RiMWKxGAA+\n", + "n28saUKhkCGN2+2mWq0CLIUJPq1Ok9Za5weP81zm1iwFRNJIuqaEA0TSBAIBVlZW8Hq9M0maWq3G\n", + "yckJp6enVCoVU00pFZVSddnr9Yy3WdbSbrcBjPl/HWk2NjaMTtTpdJbCmppZEdZa62XpryfWiF12\n", + "kkgkiMViRCIRQ5rbShr7ua1TNJtNzs7OKBaL5HI5SqUS5XKZs7MzSqXSUAig1+sN5RnHYjG01kaP\n", + "6ff7byi7Xq+XcDhMMplka2vLzNVsNqlUKm+Y9XeNaUmTV0ptaK2PlVKbQGGei5oEdjWkOO+SySSb\n", + "m5vGxM5kMqRSKaLRKD6fzyiXkgw+CttcFq9st9s1JbavX78mm82aIduUbFm25WQPqUoIBoPEYjGa\n", + "zabZbkQ5drlc+Hw+otEo6XSaXq9nzHVZc61We8M5CHfXXGBa0vwe8BeBfzi4/ue5rWgKiN9D3PeJ\n", + "RILt7W2ePXvG06dPTapDJBK5NWnson47wFiv1zk8POT169fm2mw2h2JJNumk5qnT6dBut02saW1t\n", + "jUajQafTeSP1wufzEYvF6PV6ZiuV8IbL5aJUKpkGA7JGwV0Q5zYm9+9wqfSuKaUOgX8A/DrwH5RS\n", + "f5mByb3IRd6wvqFqSCHN1tYWL1684MWLF0MeYYley1/2KMTnIjda9JezszMzDg8POTg4MEMkkIxR\n", + "k1wkQqvVol6vk0gkODs7M5JGAqOjksbr9RKJRFhZWTEE11oby08IfdeR8NtYT1+54q2fmfNapoZd\n", + "SSCk2dzcZHd3l3fffdfk6MpfrO3HEdg3WdITRDKcnZ1xcnLCyckJxWLRkGV/f5+Dg4Mhb/A4JVXM\n", + "8kajgd/vJ5VKUalUqNfrnJ+fm3waIcbKygoej4dwOEy/3zfv2zpMr9ej0WiYP4C73KIehUfY7idj\n", + "u+ltolwnWUTEi95ydnZGuVw2yu3oNZ/PUyqVzFZ0k1IqZJJtpF6vUyqVyOfzHB4eEo/HjSS0Qw39\n", + "fh+Xy2WSxjY2Nsx36Ha71Ot1yuWykYzifV40cR4FaQRXVQLI86tCBKKgik6Sy+U4OjoyPWbEFyPX\n", + "s7MzKpUKzWbT3CghzzjITZXHtVqNUqnE8fGxybXp9XrGqSdrFZdAIBAgHo+brEORMqVSiUAgQKfT\n", + "Md/tunXMC4+GNKOSxiaN/d4o7OL8er1OpVIhl8uxt7fH3t4e+/v7Q7kvrVZryDsr29F1N8oOaF5c\n", + "XAyRRspihDB2/Euufr+fWCxmrp1Oh3K5TC6XIxAI0Gq1zP9xF3jwpBklwyhpxmXf2QFKiR1Jgb7c\n", + "jL29PT788EM++uijoe1rmmoB0XcEsj0FAgFDbOmBI+SziSPebVl7q9Uil8sRjUaNs1K2v7uo8nzw\n", + "pJkGtu+k0+lQLBYpFArk83mOj485ODigWCxSq9WGPLvzEvsi2arVqgl1yJZXrVYJBoNDmYTLVu77\n", + "1pHG9ptIzdHJyQnZbJbDw0MODw/J5XIUi0Xq9bqJWo9Ki1lgk8btdhOPxymXy1SrVer1OsDMecqL\n", + "xPKtaMGwTepWq0WtVqNYLJLNZvn000/59NNPjT+mVquZisd5KpjdbpdWq2WSyePxuJE0tVrNmN52\n", + "s6RlwltHGsCQptFoUKlUjKTZ29vj5cuXQ4ruIioeRdL0+32j1NqkEY/1ysrKlUQdp9zfFbkeJWmu\n", + "+yH7/T7VatW0bT06OmJ/f59sNku5XDalJrIl3ee6bVLYmYXSDmV9fZ1MJoPH4zHEsy26ReFRkgbe\n", + "tKoEWmuq1SpHR0e8fPmSTz75hGKxSLFYNKQR5XfRpBlH7nHrHk1JlVqqVCpFJpMxFmOn06FarS68\n", + "HvzRkWYcUewUCJE02WyWjz76iA8++MC0dG02myYz7i6cZLK2cWGN6ySNpFWkUikT5RbCXBWEnSem\n", + "zRH+KvBXgOLgn/2q1vq/LWqR02Lcnt/v96lUKoY077///ht5M/eJ20oaaWAgfqZqtUqhULiTRPTb\n", + "0PK3gfdGXtPAb2qtvzAY90YY+y9vfX2ddDpNPB4nFApda66K1LmPhCZJRw2HwyQSCZOcJRmG4rAT\n", + "AowmiYlUEasvl8tRLpdNWGPRuJE0+rJbZ3nMW0thB0pALxqNsr6+zsbGBolEglAoZFq2jhv3CSFN\n", + "JBIxlRE2aezk93HZhUKaQqHAwcEBR0dHQwHURWOWDfBvKqX+WCn1NaVUbG4rmhB2kyIhzW0kzX3C\n", + "6/UOkSYejw81V7pJ0pyfnxtJc3h4OESapZA0V+CfAc+47LmXA/7R3FY0Iez67IcmaSQPWCRNNBod\n", + "kjS2fnKdpMlms5yenppzGRa+/mk+pLU2OcFKqd8Cfn9uK5oQotNIInkymSQSiZhg4H2tScxgO4dZ\n", + "EqYSiQTr6+tsbW2RyWSMHhYIBMZaP6P6l/Tnk5jYXVp7MCVplFKbetB4Gvhz3GP/YHF2SasySWjy\n", + "+/33VtIqKaj2GQt2QlgymSSVSg2RRlIfrktBHW1ZctdkEUyTI/xrwE8rpT7PpRW1B/y1ha7yGowr\n", + "WRG94L4kjUgW+3wFaZYk1RLpdJqtrS2ePHliiH6dpLFrqUTS2Jl6d7n1Tpsj/PUFrGUqjEoaqdH2\n", + "+/33uj3ZSWB221nJYRZJ8+TJE6N/XRWctJPdbcKMugzuCstpXkwIW4cQPeI+I8M+n8+U4MqhGlJT\n", + "HolEePr0Kdvb24bgkkhuVxzYhGg0Gqauqlarsbe3Z3wzrVbLHHd4V7GyR0GaZYM4G9fW1ox1ZI9U\n", + "KkUqlSIWiw0RRgg/WmQnllKhUKBYLPLq1StjMUkZzLwTxa6DQ5oFQOqWUqmUOfPSHuFw2BztI6a1\n", + "LR1HKyQqlQr5fJ6DgwNevXrF0dERx8fHxjfT6XTmmiR2ExzSLAB2WW0mk2F7e5utrS0z7C5Y44KV\n", + "dsmLOPLy+Tz7+/u8fPmSQqFgEsXsLudLbXI7GIa0MBFFN5PJ8OTJEzY3N0mlUsTj8aH+xDdFovv9\n", + "viFMs9mkXq9TrVY5Ozvj9PSUs7Mz0zb2PlrGPkrS3LUSHAqFTFt88UrLibrJZJJoNGpaxN4GYikJ\n", + "aaSGXBoM1Ot1c0jHQ+oasdS46x8yFAqRSqXY3d1ld3fXHFsoZy2IlLltvq9IGrv+W6SNlPOKz8Yh\n", + "zQPF6uoqqVSKZ8+e8bnPfc7Ej+RUXemGPomksbcn2+QWSTNJE6Z541GSZpxyab832ilr9H3x3IoX\n", + "1/b9jJvz3Xff5Z133uHJkyek0+mhz/r9ftMu5LrSYBvtdptyuUw2m+Xo6IhXr15RKBRMKufS99x7\n", + "SBiXOjl6kyTsEAwGTWrC6Pv29hKLxYba3o+LZ0kDpc3NTRKJhCGJHW+ynXc3EafdbnNycsKrV694\n", + "+fIl2WyW4+Nj0zDpvvGoSDOK6yRNMBg0YQcbbrebra0ttre32d7efuMc7nGhCdvbG4lEhoKVoxHu\n", + "20gaKeA7ODjgww8/pFAomO1p6UmjlMpw2Qo2xWVw8l9orf+JeiB9hEcfy/PrJI3H4yGTyZgt5/nz\n", + "50NnXI6edwAYCSTkuGo9t7XqhDT7+/v88Ic/NH327tKBdx1ukjRd4O9ord9XSq0Cf6SU+hbwSyxJ\n", + "H2HpNNVoNCiXy5yenhKJRNBa4/V68fl8Q/9eKWVM5KdPn74xn9vtNrGh9fV10wBaAopXKbOjVQOy\n", + "tttgtHl1qVQyVpJ0qVgmXEsarfUxcDx4XFdKfQhss0R9hPv9Pu12m0qlQrFYJBaL0e12TUbf6Mlw\n", + "LpeLcDhMOp1Ga004HH7j/fX1ddPYUdIuRYkdR4TRagGYrMVsp9MxZTT1ep1isUi1Wh1qwrhMuLVO\n", + "oy4bUH8B+D8sUR/hUdKsrq6a9hx263iBUopwOIzWmlAoRDr946XLjbcj1NLv7jp9xCbMNJJG+gOX\n", + "SiVKpRLFYpFKpbK051neijSDrek/AX9ba12zfzyt77ePcL/fNx0YisXiUKdyaZpow+VyGT9KKpUa\n", + "ynyT66gCK1iUpOl2u9RqNU5PTzk+Pn74kkYp5eWSMP9Gay2tX5emj7DoNNJdSvrTSRPEi4uLIR+L\n", + "Umqom6bMYV9nWYsQxz7/abRFrH1I2Pn5OScnJ+TzeZP+IA2tm83mw5M06vJX/Rrw/7TW/9h6a2n6\n", + "CEtJqijCfr+f9fX1ofiMLTkWGZeSue1On5KmaSeDS4TabgApXc/L5TLFYvFO65gmxU2S5kvAXwC+\n", + "r5T63uC1X2WJ+gjLX269XjfnKJ2dnb0R1LvLjlKjOb2jkuX4+JijoyMz7IM55FqtVh8mabTW/4ur\n", + "a6OWoo+w1AFJzY/b7aZSqZgD06WrpuSvLHot9vYkEkZiSNI9NJ/Ps7e3x8cff8wnn3xCo9Ew/XCE\n", + "6DIeHGkeAuzOVoBptpjP58lms0YxtmNBtt9lnsnnIslsE3o0v7dWq5mO57lcjkKhQLvdNucvCFHs\n", + "U+mWDY+CNPJXrZSi1WpxenpKNpvF7/fT7XZNaqVc7bGIioXz83MqlQqlUonT01Ojq4jeIo0hT05O\n", + "3sjxtfsSLysePGkAE4+RDt9iRQE0Gg2i0agpsJcqTGnZMer8mwWyPQlp8vk8R0dHpmmSJIaLxKnX\n", + "66b+etTCWoby4avw4Eljm7WiT5RKJQBzOHoymTRVAc1mE8B0k1oEhDR2Vwdp15bL5Ux7NluyyHex\n", + "v9ey4sGTBob9LHa7VVGS7Vzber1uXpPsOEldsHv32qkQdinsOBMahmNP0skhl8uRz+cpFotmm5KT\n", + "5x4yHgVpbEiBfKvVAjBZ/XIqW6lUolarUalUKJfLpFIpkxAuB6OK4uz3+00vO/tgU/v8J5Fctjkv\n", + "JnUul+Pk5MSYz+M81A8Rj5Y0UnQmUqZarbKyskIgEBjK7C8UCibZSq4Sm5K2rEJC0UVEsRXnnA2l\n", + "FKenp0NDSLPoBop3hUdJGtlK2u320FGFkoAl5zcVCgXW1tZIp9NDTQ/FGSjnEYxKqnw+b0ahUDAK\n", + "sMB20tVqNeOjua/qgXnj0ZEGuNZctQ/VEgki3ctF75EjkMXiEokiQ6wgGaOQKgK52r2JHwMeJWmu\n", + "g2xfzWZzqG5aTpArFAqmikB0HPvMbTnexx4C27knyrb4YKRA35E0DxBiUQFmC2s2m5TLZQKBgOni\n", + "4PP5THqn3HyJHdlSRHJe7O1p9IhlGcvssJsE6jrmX5Mj/FVu6CN8nzk2N2FUzxmXCG6/P5rmYB+h\n", + "PI4IVzUaWmaH3ThorcdGeG8izQawYecIA7/AZVS7prX+zWs++3B+HQdjcRVpps0RhiXpI+zg7nHr\n", + "XAErR/h/D15aij7CDu4etyLNYGv6j1zmCNdZoj7CDu4e1+o0YHKE/wvwX0dSPuX9XeD39eCwDet1\n", + "R6d54LhKp7lW0lyVIzxIJhfcax9hB3ePm6ynnwT+APg+lyY3wN8HvsLl1mT6CFt1UPJZR9I8cExl\n", + "cs8ChzQPH1NtTw4cjINDGgcTwyGNg4nhkMbBxHBI42BiOKRxMDEc0jiYGAvz0zh4vHAkjYOJ4ZDG\n", + "wcRYKGmUUu8ppX6klPqTQRfQWefbV0p9Xyn1PaXU/53i819XSuWVUj+wXksopb6llHqplPrmJLlB\n", + "V8z3VaXU68Eav6eUem+C+TJKqf+hlPqhUuoDpdTfmmWN18w39RqB8fms8xiAG/gY2AW8wPvAT8w4\n", + "5x6QmOHzP8VlItkPrNd+A/h7g8e/DPz6jPP9GvB3p1zfBvD5weNV4CPgJ6Zd4zXzTb1GrfVCJc0X\n", + "gY+11vta6y7wu8DPz2HeqdNMtdbfAcojL/8cl21tGVx/Ycb5YMo1aq2PtdbvDx7XAbsF78RrvGa+\n", + "qdcIi92etoFD6/lrfrzgaaGBbyulvquU+qszziVYRHvbmVNh592Cd57puoskzSJs+S9prb8AfBn4\n", + "60qpn5rn5PpSjs+67plTYUdb8M66xnmn6y6SNFkgYz3PcCltpobWOje4FoFvcLkFzor8oFRHMhJn\n", + "am+rtS7oAYDfmnSN17XgnWaN1nz/VuabdY2LJM13gXeVUrtKqRXgF7lsJTsVlFJBpVR48DgE/Czz\n", + "STOV9rYwh/a2s6TC3qIF70RrXFi67izWzC209y9zqbF/zGUV5ixzPePSAnsf+GCa+YDfAY6ADpf6\n", + "1i8BCeDbwEvgm0Bshvn+EpcVqd8H/nhwc9MTzPeTQH/wHb83GO9Nu8Yr5vvyLGvUWjthBAeTw/EI\n", + "O5gYDmkcTAyHNA4mhkMaBxPDIY2DieGQxsHEcEjjYGI4pHEwMf4/w2zPGHuGeikAAAAASUVORK5C\n", + "YII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEG1JREFUeJzt3XuQJWV5x/Hvb2d39u5yceMibIIBTcSSiKiFqyiooYil\n", + "aBKjkkSNSUml1EiIWipVSfFHoqasKLGspIpIvGDUJGpQK1EhCVEUZEW5LnhLSQISIRCU3XVvszz5\n", + "Y87CMMzsdG/Tc85Zvp+qqT3d5zn9vtPvnNln+u3zPqkqJEmSdOCWDLsDkiRJ486ESpIkqSMTKkmS\n", + "pI5MqCRJkjoyoZIkSerIhEqSJKmjpcNsPIlrNkiSpLFRVZlrf68JVZLTgfOBCeCDVfXns2OOOOKI\n", + "h7xu69atrF279kH7li9f3rjdFStWtOrnkiXNL9S1iW3T55UrVzaOXb9+fePYDRs2NI5te+zZY7TP\n", + "JZdcwmmnnfagfatWrWp83Dbnrc1xAQ499NDGsWvWrGkce8ghhzSOnZycbBw7NTXVOLbN2MHcP3Pv\n", + "fOc7Offccx+yf9myZY2POzEx0Ti2zfupzZp5bc4bwM6dOxvH7tixo3Hs1q1bG8du2bKlcexRRx01\n", + "5/4LLriAs8466yH7jznmmMbHXrduXePYNuOn/TvvvPM477zzht2NRdfmfd123cxdu3Y1jr3nnnsa\n", + "xR155JHzPtfbuyHJBPAB4HTgOODMJE/sqz1JkqRh6fPPi2cA36+qW6pqD/BJ4CU9tidJkjQUfSZU\n", + "RwK3zti+bbBvQW2mRDR62kwvaLScfPLJw+6COjjxxBOH3QUdoFNOOWXYXVBHfSZUB3zDeZt7aDR6\n", + "TKjGlwnVeDOhGl8mVOOvz5vSfwhsnLG9kemrVA8y86bNyclJkylJkjQSrrjiCq688spGsX0mVFcD\n", + "j09yNHA78ArgzNlB831STJIkaZg2bdrEpk2b7t9+73vfO29sbwlVVU0leSPwJaaXTbiwqm7uqz1J\n", + "kqRh6XUdqqr6AvCFPtuQJEkatqGulN7Gtm3bGsc2XaBrnzaLAO7du7dxbF8Llt133329HLftsdto\n", + "2w9JksaJy9xKkiR1ZEIlSZLUkQmVJElSRyZUkiRJHZlQSZIkdWRCJUmS1JEJlSRJUkcmVJIkSR2Z\n", + "UEmSJHVkQiVJktSRCZUkSVJHGWaNtSS1evXqRrGTk5ONj7tixYpW/Wjah7bHnpiYaBzbpkbgvffe\n", + "2zi2TQ1EgB07djSO3bNnT+PYvuoajmONwCVL+vk7pm0dxnE8d5I0bFWVufb3eoUqycYklyXZkuTG\n", + "JG/qsz1JkqRhWNrz8fcA51TVtUnWAN9McmlV3dxzu5IkSYum1ytUVfWjqrp28HgbcDPw2D7blCRJ\n", + "WmyLdlN6kqOBE4CrFqtNSZKkxbAoCdVguu9TwNmDK1WSJEkHjb7voSLJMuDTwMeq6uLZz+/evfv+\n", + "xxMTE60+GSdJkjQKek2okgS4ELipqs6fK6bNcgiSJEmjqO8pv2cBvw2cmuSawdfpPbcpSZK0qHq9\n", + "QlVVX8XV2CVJ0kHOZEeSJKmj3m9KX8i6desaxbUpq9GmJArAXXfd1Ti2TYmYtqVA+jhu2/IibeKn\n", + "b5Frpk25lXEsiTKOfdb4avPeA38+pcXgFSpJkqSOTKgkSZI6MqGSJEnqyIRKkiSpIxMqSZKkjkyo\n", + "JEmSOjKhkiRJ6siESpIkqSMTKkmSpI5MqCRJkjoaeumZpmViJiYmGh9z+fLlrfqwevXqxrFtSj60\n", + "KVPTplzO7t27ezkutOtzm3IWoxDb1iiU6xiVc6HR4lhLo2fehCrJrwMFzJVBVFV9pkkDSSaAq4Hb\n", + "qurFB9RLSZKkEba/K1QvZjqhmk+jhAo4G7gJWNu0U5IkSeNk3oSqqn6n68GTHAW8EPgz4I+6Hk+S\n", + "JGkULXhTepINSS5M8sXB9nFJfq/h8d8HvBW4r0MfJUmSRlqTT/l9GLgEeOxg+3vAOQu9KMmLgDur\n", + "6hrmvg9LkiTpoNAkoXp0Vf09sBegqvYAUw1etwk4I8kPgE8Az0vy0dlB27dvv/+rzafXJEmSRkWT\n", + "ZRO2JTl830aSk4CfLPSiqjoXOHfwmucCb6mqV8+Oa7NkgSRJ0ihqklC9Gfg88PNJrgDWAy87gLZc\n", + "OEWSJB2U0mSBuCRLgV9g+l6o7wym/bo3ntT69esbxbZZ2LNNLMDSpc3XN3VhzwdMTTWZ+Z3mwp79\n", + "92EU+itJB7uqmjMRWDCTSLISeD3wbKavMl2e5K+raufD20VJkqTx1OTSzEeBe4H3M32F6jeBi4Df\n", + "6LFfkiRJY2PBKb8kN1XVcQvtO6DGkzr00EMbxbaZzmgzLdf22H3FLlnSvE51m9i27ruv+ZJhbWL7\n", + "Om9tpijbHruv76+NNtPRbc9FX9/fKJy3tr8D2sS3ef+tWbOmcezxxx/fOPbuu+9uHAtw6623No7d\n", + "tm1b49g2Yy111fb/vsnJycaxhx12WKO422+/fd4pvya9+1aSZ+7bGHzK75uNWpYkSXoE2F9x5Btm\n", + "xHwtya1M30P1s8B3FqFvkiRJY2Gh4siSJElawP6KI98yczvJzwAr+u6QJEnSuGlSHPmMJN8DfgB8\n", + "GbgF+ELP/ZIkSRobTW5K/1PgmcB3q+pxwPOBq3rtlSRJ0hhpklDtqaq7gCVJJqrqMuBpPfdLkiRp\n", + "bDRZ5OaeJGuBy4G/S3In0HyhEkmSpINckytULwV+CpwDfBH4Pn4CUJIk6X4LXqGqqn1Xo/YCH+61\n", + "N5IkSWNo3tIzSbYxvZDnXKqqHtW58aSOPfbYRrETExONj9smFvort9JXWYY2y++PSgmOvs7F1NRU\n", + "q/gdO3b0cuzdu3c3jm1zLtqMx86d7eqVtylVMwqlZ/r62YT+fr+0KR3U5ly0Hes2P8t9lQOSDhbz\n", + "lZ7Z3zpUzYtQzSPJIcAHgScxnZz9blV9vetxJUmSRknzP58OzF8C/1JVL0uyFFjdc3uSJEmLrreE\n", + "Ksk64OSqeg1AVU0BP+mrPUmSpGFpd6NBO48D/jfJh5J8K8nfJFnVY3uSJElD0WdCtRR4KvBXVfVU\n", + "YDvw9h7bkyRJGoo+76G6Dbitqr4x2P4UcyRUd9999/2PV65cyapVXsSSJEnjpbeEqqp+lOTWJE+o\n", + "qu8CLwC2zI47/PDD++qCJEnSouj7U35/wHS5mkngP4HX9tyeJEnSous1oaqq64Cn99mGJEnSsPV5\n", + "U7okSdIjQt9TfgtasWJFo7g2pRa2b9/eqg979uxpHNtXWY022paTGQVtzkWbsiFtywy1KbfS5udi\n", + "165dvcT2VfJlHLU5F23fe23eU23Oc5vfW31+f5L65xUqSZKkjkyoJEmSOjKhkiRJ6siESpIkqSMT\n", + "KkmSpI5MqCRJkjoyoZIkSerIhEqSJKkjEypJkqSOTKgkSZI6GnrpmbvuuqtRXJsyIG1ioV05kr7K\n", + "Q7QpfdFXmYw++9HmXExNTTWObTN2bfsxCqVAxrHM0ChoOx5tf2c05fhJjxy9XqFK8o4kW5LckOTj\n", + "SZb32Z4kSdIw9JZQJTkaeB3w1Kp6MjABvLKv9iRJkoalzym/e4E9wKoke4FVwA97bE+SJGkoertC\n", + "VVX/B/wF8N/A7cCPq+pf+2pPkiRpWPqc8jsG+EPgaOCxwJokv9VXe5IkScPS503pTwOuqKq7q2oK\n", + "+AywaXbQ1q1b7//atWtXj92RJEnqR5/3UH0b+OMkK4GdwAuAzbOD1q5d22MXJEmS+tfnPVTXAR8F\n", + "rgauH+y+oK/2JEmShiV9LUjYqPGkNmzY0CjWhT0PLNaFPQ+8H+O2sOcw38uaW18LezrW0vBU1Zxv\n", + "bEvPSJIkdWRCJUmS1NHQa/k1vXS9bNmyxsdsEwuwZEnzvLKvKZi+ph3bfnKyzXRpmz63iW0zTdl2\n", + "6mMUpuZGZXrXaaMD0+b3xShMG0taHF6hkiRJ6siESpIkqSMTKkmSpI5MqCRJkjoyoZIkSerIhEqS\n", + "JKmjkUyodu/ePewuqIO2q5dLkjTuTKj0sGu7HpIkSeNuJBMqSZKkcWJCJUmS1FGGWe4gibUWJEnS\n", + "2KiqOWuCDTWhkiRJOhg45SdJktSRCZUkSVJHI5dQJTk9ybeTfC/J24bdH80vyd8muSPJDTP2HZbk\n", + "0iTfTXJJkkOG2UfNL8nGJJcl2ZLkxiRvGux3DEdckhVJrkpybZKbkrxrsN+xGyNJJpJck+Tzg23H\n", + "b4yNVEKVZAL4AHA6cBxwZpInDrdX2o8PMT1WM70duLSqngD822Bbo2kPcE5VPQk4CXjD4P3mGI64\n", + "qtoJnFpVTwGOB05N8mwcu3FzNnATsO9mZsdvjI1UQgU8A/h+Vd1SVXuATwIvGXKfNI+quhy4Z9bu\n", + "M4CPDB5/BHjponZKjVXVj6rq2sHjbcDNwJE4hmOhqn46eDgJTDD9XnTsxkSSo4AXAh8E9n1qzPEb\n", + "Y6OWUB0J3Dpj+7bBPo2Px1TVHYPHdwCPGWZn1EySo4ETgKtwDMdCkiVJrmV6jC6rqi04duPkfcBb\n", + "gZmlJRy/MTZqCZVrOBxEanpNDsd0xCVZA3waOLuqts58zjEcXVV132DK7yjgOUlOnfW8YzeikrwI\n", + "uLOqruGBq1MP4viNn1FLqH4IbJyxvZHpq1QaH3ck2QCQ5AjgziH3R/uRZBnTydRFVXXxYLdjOEaq\n", + "6ifAPwMn4tiNi03AGUl+AHwCeF6Si3D8xtqoJVRXA49PcnSSSeAVwOeG3Ce18zngNYPHrwEu3k+s\n", + "hihJgAuBm6rq/BlPOYYjLsmj930CLMlK4JeBa3DsxkJVnVtVG6vqccArgX+vqlfh+I21kVspPcmv\n", + "AOczfZPlhVX1riF3SfNI8gngucCjmZ7v/xPgs8A/AD8L3AK8vKp+PKw+an6DT4V9BbieB6YW3gFs\n", + "xjEcaUmezPRNy0sGXxdV1XuSHIZjN1aSPBd4c1Wd4fiNt5FLqCRJksbNqE35SZIkjR0TKkmSpI5M\n", + "qCRJkjoyoZIkSerIhEqSJKkjEypJkqSOTKgkDV2Srw3+/bkkZz7Mxz53rrYk6eHkOlSSRkaSU5he\n", + "5PDFLV6ztKqm9vP81qpa+3D0T5Lm4xUqSUOXZNvg4buBk5Nck+TsJEuSvCfJ5iTXJTlrEH9KksuT\n", + "fBa4cbDv4iRXJ7kxyesG+94NrBwc76KZbWXae5LckOT6JC+fcez/SPKPSW5O8rHFPRuSxtHSYXdA\n", + "knig9M3bgLfsu0I1SKB+XFXPSLIc+GqSSwaxJwBPqqr/Gmy/tqruGdS225zkU1X19iRvqKoT5mjr\n", + "14BfAo4H1gPfSPKVwXNPAY4D/gf4WpJnVZVThZLm5RUqSaMks7ZPA16d5Brg68BhwLGD5zbPSKYA\n", + "zk5yLXAlsBF4/AJtPRv4eE27E/gy8HSmE67NVXV7Td8TcS1wdIfvSdIjgFeoJI26N1bVpTN3DO61\n", + "2j5r+/nASVW1M8llwIoFjls8NIHbd/Vq14x9e/F3paQFeIVK0ijZCsy8gfxLwOuTLAVI8oQkq+Z4\n", + "3aOAewbJ1C8CJ814bs++189yOfCKwX1a64HnAJt5aJIlSQvyry5Jo2DflaHrgL2DqbsPAe9nerrt\n", + "W0kC3An86iB+5keUvwj8fpKbgO8wPe23zwXA9Um+WVWv2ve6qvqnJM8ctFnAW6vqziRPnHVs5tiW\n", + "pAdx2QRJkqSOnPKTJEnqyIRKkiSpIxMqSZKkjkyoJEmSOjKhkiRJ6siESpIkqSMTKkmSpI5MqCRJ\n", + "kjr6f12ScjOibt0UAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAFYRJREFUeJztnVuMZHldxz+/ut+7q+89072zs8Oa8EACL/gARB4IWWIi\n", + "+qIhMRpE44OiURMRHwSjD0gCMb4QlV2Dl4BGAwETFTAa8cHLml12UXbZTRimZ/tW3VXVdb//fej6\n", + "/ffUmeqeruq6nJo5n+Skbl2nf931rd//8rscMcbg4zMKgXkb4LN4+KLxGRlfND4j44vGZ2R80fiM\n", + "jC8an5EZWzQi8oyIvCIir4nIxyZplI+3kXH2aUQkCLwKvA94A/hv4EPGmO9O1jwfLzKup3kn8Lox\n", + "5q4xpg18Cfjg5Mzy8TKhMd93E9hzPL4P/LDzB0TE32pecIwxMuz5cT2NL4jHmHFF8waw63i8y7m3\n", + "8XkMGFc0zwNPi8iTIhIBfgr46uTM8vEyY81pjDEdEfll4J+AIPCsv3J6fBhryX2lE/sT4YVn0hNh\n", + "n8cYXzQ+I+OLxmdkfNH4jIwvGp+R8UXjMzK+aHxGxheNz8j4ovEZGV80PiPji8ZnZMZNwgJARO4C\n", + "JaALtI0x75yEUdNGROwRCAQIBoOEQiGCwSDBYJB2u02n07G3s7AnEAhYmwCMMWhc0H1/3lxLNJwn\n", + "Y73XGJOfhDGzQEQIhUL2CIfDLC0tkclkyGQyJBIJ8vm8PQqFwtRtCoVCRCIRwuEwkUiEXq9Ht9ul\n", + "2+3S6XTs416vR6/Xm7twrisagKGRUC8TDAaJRCLEYjHi8ThbW1tsb2+ztbXF6uoqd+/e5e7du7Tb\n", + "7ZmIJhgMWlsSiQTdbpd2u02r1aLVatFutxERK6B5MwlP800R6QJ/bIz50wnYNFXU00SjURKJBOl0\n", + "mu3tbe7cucNb3vIWbt68STwep91uk8/PxoGGQiFisRjpdJpMJkOn06Fer9NoNOywBXhCMHB90bzL\n", + "GHMgIuvAN0TkFWPMtyZh2DTRDymRSLC0tMT6+jo7Ozs89dRT3Lp1i0KhwBtvvEE8Hp+pPalUimw2\n", + "S6fTIRaLUa/Xqdfr1Go16vU6xhja7fZiD0/GmIP+bU5Evsx5aYunRSMihMNh4vE4mUyGbDZLJpMh\n", + "Ho8TDocfmJDOglAoZO1ZXV214tCjWCySz+cREZrN5tw9ztiiEZEEEDTGlEUkCbwf+N2JWTYlVDSJ\n", + "RMKKJpVKDYhm1sJxDk8rKysEg0G7Yur1euRyOUSERqNBsViciU2X2nuN924CX+7/Y0PAXxljvj4R\n", + "q6aIiBCJRB7wNIlEgkgkMnMvA4OeZmVlhVgsZrcCAoEA0WiUZrNJsVgkEJj/1trYojHGfB94+wRt\n", + "mQnDPE06nZ7r8BQIBAiHw8RiMZLJJMlkkmg0SjQaJRKJ0G63OT09JR6PW/vmOa+ZxJJ7IVARqKfR\n", + "SfDKygrpdJpYLEYoNJ9/R6/Xo91uU6/XqVQqBINBwuEwwWCQeDxOPB4nGo3a5wKBgB2+5iGe+fu6\n", + "GeAUTCAQIBKJkEwmB0QTj8fnJpput0ur1aJer1Mul2k0GvR6PTtsOUUTCoXm4g2dPBaiAQbCBupp\n", + "nMPTPD2NUzSVSoVGo0G32yUYDJJIJIZ6mnkK57EYnlQs7rnD0tIS2WzWzh0AG2+a5XZ9r9ej0+nQ\n", + "arVoNBq0220AuzWgoolEIlY0ML841CMvGp34RiIRIpEI6XSa5eVlG29Kp9MD3/RGo0GhUKBSqdgP\n", + "bxY2qqg1DhWNRu0GpIpGg6o6p5kXj41oNK6jgtEjnU5TLpft0HB2dkY+n6dardJqtWZmozPaHg6H\n", + "iUaj1uZhw1Ov1/PnNNPCKZpUKsXy8vKAp0mlUoRCIVqtFmdnZxwdHVlPM0vRiIgVzTBPo1Fw95xm\n", + "HjySnsa5WgoGg0SjURvXWVtbI5vNWi+j8SUdlg4ODsjn8zMdnnRY0mFUBaORb53P6Mpp3qunR040\n", + "KhQ94vE4a2tr3Lx5kxs3bnDjxg1u3rzJ0tISgUCAer3O2dkZJycn7O/vs7e3x9HREaVSiWazOROb\n", + "3bGn5eVlksmk3aH2Go+caODNfJlIJEIqlbKieeqpp3jiiSdYXV0lk8kQCASo1WpWNAcHB9y7d49i\n", + "sThX0SwtLQ2ENbzGIycazZfR+FI6nbapD3fu3OHOnTtWUCJiPU0ul7OeRlMRfE8znIeKRkSeA34U\n", + "ODbGvK3/3Arw18At4C7wk8aY+YdfeVM0zr2YtbU1bty4wa1bt7h9+7bNiGu1WpTLZQqFAicnJxwd\n", + "HbG/v29TK7vd7szsdQYsve5prrJ6+jPgGddzvwV8wxjzQ8A/9x97gkAgQDweJ5vNsr29ze7uLhsb\n", + "GywtLRGPxxERarUauVyOu3fv8sorr3Dv3j1yuRzVanUmubi6xNY8Zc0iTKVSAxP0cDi8mKLpZ+K5\n", + "E2V/DPhC//4XgB+fsF1jEwgESCQSZLNZtra22N3dZXNzk+XlZWKx2AOiefXVV7l37x4nJydUKhUr\n", + "mmkGA937Mrono6LR/J5QKORJ0Yw7p9k0xhz17x9xnlvjCS7zNE7RnJyc8IMf/IDXX3+d4+Nj62mm\n", + "LRgYXOEN8zSpVMq+7lxae0VA154IG2PMvPvrOf+poVCIZDLJysoKW1tb7Ozs2NVSLBYDsKK5d+8e\n", + "r732GuVymUqlYoenaaNeRvdldOdXE8vj8fhA6sMshDwK44rmSES2jDGHIrINHE/SqFHQIKSuiDKZ\n", + "DGtra6yurrK6uko2myWRSBAMBm0gslarUa1WqVQqNoTQarVmIhjAbjam02nS6fQDw6eWsGjwtFwu\n", + "U6vVbDBTa6LmlSs8rmi+Cvws8Af9269MzKIRERGi0ajNeFtZWWFtbc0KJ5vN2jyUbrdLo9EYEI2G\n", + "C1qt1sw+hEgkYld1a2trbG9vs7y8bCfqnU6HRqNBo9GgXq9TKpWoVqs0Gg06nc7Mo/BurrLk/iLw\n", + "I8CaiOwBvwN8CvgbEfkI/SX3NI28DM2h1bjS+vr6A55G/8FaT+QWjX5zZ+lpMpkMGxsb7OzssLm5\n", + "STabtcNnp9Oh2WxSrVYpl8vW0zSbTetpPC0aY8yHLnjpfRO2ZSw0fdMZW1LR6J6HfmtbrdYDgqlU\n", + "KjO31yma3d1dtra2hnqaSqVCsVjk7OzMJmepaOaZ7rnwO8LO4UlFs7S0NLCjqpt4xWKRk5MTTk9P\n", + "Zx6QdB7OVNONjQ1WVlasvQCtVotSqcTx8TGHh4ccHBxQKBSo1WpzFww8AqJxDk8qmuXl5YEdVf0Q\n", + "NL6kUexZpT44N/JCoZBdWq+urrKxsWFrr9TeZrPJ2dkZx8fH7O3tWZt1dTfvldTCi0Y9jVM0F3ka\n", + "FY16mlmLRld4bk/jDBsANJtNSqUSuVxuQDROTwN+uufYaKL4VUSTy+Xmmi+jnSqSyaSNM62vr5NM\n", + "Jm0+DbwpmuPjY+7fv8/R0RHFYvEB0cyLhRSNsymRe0c1nU7bb20wGKTX69FoNGwkex6eJhwOk0ql\n", + "yGQytuGAM5Kt6ZvaVkRXTaVSiWKxaPeSvFD8DwsoGmcpim7sOWM3GuzTD8MYQ6PRGJjT6A7wrDyN\n", + "esLV1VXW1tasaBKJhK3q1AZG3W7Xru6cotGVky+aMVHBuGM3usPq9DS6fHV6mmazaTf0ZoGKZmVl\n", + "he3t7Qc8DTDQxGiYp9FNPV80Y+IM+A3zNDrhVLevnkZFM2ucotna2npg3tVutwdKc1U0Z2dndo/G\n", + "SyykaODBWqFwOGyPXq9nd371n1+r1WbSdHEYaqOKW8tRtOhNBdNoNKhWqwOxMC94FjcLKZqLunNq\n", + "xn6z2aTRaNBsNsnn83blMas5jBv36slZwwRviqbZbNrApJdFs3B1T27BuNMMnJ5G0zjPzs6o1+tz\n", + "9zSaBuEsR3FGtTWYqiulWcXCRuWhohGR50TkSERedjz3SRG5LyIv9A93OujUcQpHd1rdoikWi+Ry\n", + "Oc94Gq1nusjTuIcnr0x83YybI2yAzxpj3tE//nHypg3HmZikyd9aOF+r1QbEod0h3AVnWqU4rUw4\n", + "Z7WkVndqDbmGOZLJpM0B7na7dmhyp0EspGguyBGGOfYPVtHo3oaKplqtWtE4A5mzFo27mF9Fk81m\n", + "B5bb0WjUikaX2qVSiUqlYocoL3KdOc1HReTbIvKsiCxPzKIrcJFo1NN0Oh0byEwmkyQSCWKx2AP1\n", + "0LP0NJrvo2XBzjCH29NoGsTCepoL+Bxwm/OeewfAZyZm0RVwDk9u0VSr1Qs9jWbwOSeh0+Ci4ckZ\n", + "hR8mmmq1+kDujBdFM9aS2xhjc4JF5PPA1yZm0dV+/4C30d1UTbbSzT3dC1lbW2NnZ4dqtWpLcfVo\n", + "NBoj/35n501nFwdnaENtiEQi3Lp1i42NDVtlMEyszhyZeac+PIyxRCMi29p4GvgJ4OXLfn6SGGNs\n", + "d0u3t2k2mzSbzYFWqvF4nPX1dWq1GsYYEokExWLRHuVyeWQbnBuJejjzZbTzg97evn2bjY0Nksnk\n", + "lf4+rzNOjvAngPeKyNs5X0V9H/jFqVrpQr+J6tqdQ1Sj0bB9eLWt6vr6Or1ej2g0yvLyMsfHx/YY\n", + "5/oH2gZED6dXcbYK0d+/vb3N5uYmqVRqaDvXhz32GuPmCD83BVuujDMJySka9TTdbteKJp1OY4yx\n", + "gllfX7dJT7qSGhWdXOttPB5/QEjOQ7tuJZPJC+dR7mHJy8JZyDCCE61jKhQKHB4eEo1G7Ra8czkL\n", + "5x4im80OTJSXl0df+KkX0Vv3cKSHvq6T8YtqszudzkDLk0KhQLVapdlselI8j4xo8vk8+/v7ADZq\n", + "LCL0ej27UtK5R6/Xs00bNzY2Rv6d6qH01jmncXazcovoopaz7XbbCv/o6IjT01PK5bInLp4xjIUX\n", + "jSYt6VVKNGajy15tCJBIJAZax2vfmnFzapzDiDMGNmz1pIK6aOXUarWoVCpWNMVi0fbH8T3NFFBP\n", + "o1n89XodYGAVo3MaTbtMp9PX6lnnvL6lc9dWz+eMgzmHpIt+n3qaYrHI8fEx5XLZFu/5opkCWjnZ\n", + "bDZtADOXy9lhqFqtks1mWVlZsVdccV7kdJyJsPYb1lu3PSpMvXUvz93icU7onc2vvXC9ymEsvGiA\n", + "gckuwMnJifVAp6enLC0tDbSBdX+Io2CMsZWZmmvsRvOA9dA6c80Jvui8zgucenmDb+FFo99SeLNd\n", + "fLfbtYLRchHtTp5OpwfmNpqjOwqFQmFgg9DNzs4OTzzxBLVajV6vRzabxRhDKBQikUgM9TTu6L1X\n", + "BQOPkGhUOCJiwwVa4pJKpQYO3VfRmNSo5HI5Tk5O7OHm6aeftoJRUapgLvs7VDBeXDE5WXjRwOBG\n", + "mN5XEWnE2zn3ce7WjuppjDEUi0UKhQKlUolarfbAz2jgVFM13IX7btzpoM45jRez9x4J0VyGUyyA\n", + "jSg7Y0ajUqlULs0EdMbDdOmse0fDcF8dxtnUyItD1SMvGsDmBmsVoztCPSrOi6wPw52yoambVxFN\n", + "IpGwO9Z6noUSjYjsAn8ObHAenPwTY8wfebmPsBvnnKfVag1MQsfdp3lY+oJbNM5mRMNw1m8lk0m7\n", + "E+z0kF7iYZ6mDfyaMeZFEUkB/yMi3wA+zHkf4U+LyMc47yPsmV7CbmYdBBx1JeTOQnTu1XiRS32z\n", + "MebQGPNi/34F+C5wEw/3EfYSV/Vk7moE55DmtaEJRpjTiMiTwDuA/8TDfYS9xrA+wG4xuYvltEbL\n", + "iysnuKJo+kPT3wG/aowpO/9oL/QRXgQuiz/p/MVZLAd4dlf4KsVyYc4F8xfGGG39eiQiW/3X59pH\n", + "eFG4bF7lruPy+q7wpaKR86/Fs8D/GWP+0PGS9hGGOfcRXgQWIRtvFB42PL0L+GngJRF5of/cx/FQ\n", + "H2Evc9HwsujiuVQ0xph/52Jv5Ik+wj6z57HYEZ41zs4WFyV7OYesRah1cuKLZko4W6G4xeMWipcn\n", + "vcNYuP40i8CwHjoX5dA4V0qLIhxfNFPiKp7GmT+zSMLxh6cpoBde1YbY6XSaWCxm+xprIFIPZ9t9\n", + "XzSPKe5unnrBDG1Rq4VxpVKJUqnE/v6+bWPvi+YxRa9/kM1m2dzctL2N9UJl1WqVQqFALpfj+PjY\n", + "XmWlXq/7onlc0foq9TTRaNRWZGrSe6FQ4ODggPv37w94Gq+mQzjxRTMDms2mjVp3Oh329/e5f/8+\n", + "e3t77O3tDVRV+p7mMUWzBOv1uq3Jdiab64W/9NAk9Uaj4YvmccXZQ0+vcZDP5+2Ry+XsfEavB67V\n", + "mgsvmktyhD8J/DyQ6//ox2fZFtbrqKdR0ZyenrK/v8/BwYGdv+TzeQqFAvl83g5d87xs8iiMmyOs\n", + "fYQ/O3ULF5BGo0GxWOTw8JBMJsPJyQlHR0ccHh5yeHg4sNyuVqsLIRQnD4tyHwKH/fsVEdEcYZhj\n", + "H2GvU6vVyOVyhMNh2u02pVKJQqFgD683l34Y4+QI/wfneTYfFZGfAZ4HfsOrJSzzoFqtcnx8TLPZ\n", + "pFAoDPQ4rtVqD62b8jpyFaX3h6Z/BX7fGPMVEdngzfnM7wHbxpiPuN6zeF+hCaGVm1rF6bxYvLMr\n", + "hNfrto0xQ0eTh4qmnyP898A/uFI+9fUnga8ZY97mev6xFc2jwkWiGStHuJ9Mrsy0j7DP/LnU04jI\n", + "u4F/A17ifMUE8NvAhzhvcW/7CDvqoPS9vqdZcMYensbFF83iM9bw5OMzDF80PiPji8ZnZHzR+IyM\n", + "LxqfkfFF4zMyvmh8RmZq+zQ+jy6+p/EZGV80PiMzVdGIyDMi8oqIvNbvAnrd890VkZdE5AUR+a8x\n", + "3v+ciByJyMuO51ZE5Bsi8j0R+foo1xi/4HyfFJH7fRtfEJFnRjjfroj8i4j8r4h8R0R+5To2XnK+\n", + "sW0Ehl/adxIHEAReB54EwsCLwFuvec7vAyvXeP97OE8ke9nx3KeB3+zf/xjwqWue7xPAr49p3xbw\n", + "9v79FPAq8NZxbbzkfGPbaIyZqqd5J/C6MeauMaYNfAn44ATOO3aaqTHmW0DB9fTY7W0vOB+MaaOZ\n", + "cAveS843to0w3eHpJrDneHyfNw0eFwN8U0SeF5FfuOa5lGm0t/2oiHxbRJ4dZbhzMukWvK503WvZ\n", + "OE3RTGMt/y5jzDuADwC/JCLvmeTJzbkfv67dnwNuc55vdAB8ZtQTuFvwXtfG/vn+tn++ynVtnKZo\n", + "3gB2HY93Ofc2Y2OMOejf5oAvcz4EXpeJtrc1xhybPsDnR7Vx0i14Hef7Sz3fdW2cpmieB54WkSdF\n", + "JAL8FOetZMdCRBIiku7fTwLvZzJpphNtb3udVNhJt+CdWrrudVYzV5i9f4DzGfvrnFdhXudctzlf\n", + "gb0IfGec8wFfBPaBFufzrQ8DK8A3ge8BXweWr3G+n+O8IvUl4Nv9D3dzhPO9G+j1/8YX+scz49p4\n", + "wfk+cB0bjTF+GMFndPwdYZ+R8UXjMzK+aHxGxheNz8j4ovEZGV80PiPji8ZnZHzR+IzM/wMn9Av6\n", + "T5UJ3wAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAENFJREFUeJzt3XuwXeVZx/Hf7+xzy4UDxESQkBrUoFxaC7YEKIViq4NM\n", + "oVVrKWqL1anjtLURW6aUGf1Lp7WMU1o6OlNBWqhtVVppOwoFLVJKbVIg4RbKxWmUexQhJ7dzcpI8\n", + "/rH3CZvDubxvVt6z9kq+n5lM9lr72et9937X3nmyLu/jiBAAAAD2X1/dHQAAAGg6EioAAICKSKgA\n", + "AAAqIqECAACoiIQKAACgIhIqAACAivrrbNw2czYAAIDGiAhPt75oQmX7PElXSWpJuiYi/mJqzLJl\n", + "y17xuu3bt2vRokUvW9dqtXLazern3r17k2Nz5u0qNcdXX1/6gcWcWCnvs5spdnR0VCMjIy9bl/MZ\n", + "7969u0hsbvyePXuKxOb0IWcfyt3vp9s39uzZM+13LWc/yulzqc8YAOZbsVN+tluSPivpPEknSrrY\n", + "9gml2gMAAKhLyWuoTpP0eERsiogJSV+R9LaC7QEAANSiZEK1XNITXctPdtbNaWBgoEiHMD+Ghobq\n", + "7gL2U+5pQwBAW8mEar8vIBocHDyQ/cA8I6Fqrtxr7gAAbSUvSn9K0oqu5RVqH6V6me3bt+97PDAw\n", + "QDIFAAAap2RCdbekVbZXSnpa0kWSLp4aNPVuPgAAgKYpllBFxG7bH5T0LbWnTbg2Ih4u1R4AAEBd\n", + "is5DFRE3S7q5ZBsAAAB1q3WmdElauHBhUlypiRNzt50TmzOZZanJRXO2mxvfC7G5k6eWmmy1iZgo\n", + "EwAOHG7pAQAAqIiECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqIqEC\n", + "AACoiIQKAACgIhIqAACAilxnbTPbsWjRoqTY/v70soNDQ0NZ/RgeHi4Sm9Pnvr703HZiYiI5Nreu\n", + "4fj4eHLsrl27kmNL1UvMrUdXan/PGT/btW9Xyts3Su1zpeo2lvxdKzUmJWt09gLqaPaenH05JzZH\n", + "qe9Ibnxq7N69exUR03a66BEq2yts3277IdsP2v5QyfYAAADqkH4IZf9MSLo0IjbYXizpHtu3RcTD\n", + "hdsFAACYN0WPUEXEsxGxofN4m6SHJR1Tsk0AAID5Nm8XpdteKekUSWvnq00AAID5MC8JVed0342S\n", + "1nSOVAEAABw0Sl9DJdsDkr4q6YsRcdPU57vvFGu1Wmq1WqW7BAAAMKeISL4DsGhC5fb9kNdK2hgR\n", + "V00XMzg4WLILAAAA+8X2y6Z2mG3KktKn/N4g6bclnWt7fefPeYXbBAAAmFdFj1BFxHfFbOwAAOAg\n", + "R7IDAABQUe2lZ04++eSk2JxyFrnlVnJKqJQqt1Kq7ETJqfpLlb8o2Yec+Jzxy9lur5QNKfXdp8QI\n", + "gINZLaVnAAAADgUkVAAAABWRUAEAAFREQgUAAFARCRUAAEBFJFQAAAAVkVABAABUREIFAABQEQkV\n", + "AABARSRUAAAAFdVeembp0qVJsf396XWch4eHs/qxcOHC5NgFCxYkx7ZareRYe9qZ7KeVM2Z9fXk5\n", + "8+DgYHJszvsbGRlJjj3yyCOTY48++ujkWElavnx5cuyyZcuKxC5ZsiQ5Nqf8zdatW5NjJWnbtm3J\n", + "sTljfcwxxxSJzdmHcr5PUt7n/PzzzyfH5nxuOft97m9cKTm/RePj48mxo6OjybG5n0XOvyU5csqS\n", + "5by/Z555Zn+6kyRn/MbGxpJjc/7dGRoaSo7NHeuc+NTv6qpVq2YsPTPjnmX71yWFpOleGBHxtZTG\n", + "bbck3S3pyYi4IOU1AAAATTJbqn6B2gnVTJISKklrJG2UdFhqpwAAAJpkxoQqIn6n6sZtHyvpfEl/\n", + "LumPq24PAACgF815otP20bavtX1LZ/lE27+XuP1PSbpM0t4KfQQAAOhpKVeOfV7SrZImrx59TNKl\n", + "c73I9lslbY6I9Zr+OiwAAICDQsrtDksj4u9tXy5JETFhe3fC686UdKHt8yUNSxqxfX1EvKc7aPv2\n", + "7fseDwwMZN1lBgAAUMratWu1du3apNiUhGqb7R+bXLB9uqQtc70oIq6QdEXnNedI+sjUZEqSFi1a\n", + "lNRRAACA+bR69WqtXr163/LVV189Y2xKQvVhSd+U9FO2vydpmaR37Ee/6pvwCgAAoKA5E6qIuMf2\n", + "2ZJ+Vu1roR6JiImcRiLiDkl37F8XAQAAetucCZXtBZLeL+kstY8y3Wn7ryMifdpUAACAg1jKKb/r\n", + "JY1K+ozaR6h+U9INkn6jYL8AAAAaIyWhOikiTuxa/rbtjQeqAyXu6supqSTl1SjKqX1Uqk5iTp2y\n", + "3Jpmpd7f3r3pU5Hl1FXbvTvlhtP923ZObM77y4nNkTvWpfajUmNdZ91RAAe33N/P6aTMQ3Wv7TO6\n", + "Gj1d0j2VWwYAADhIzFYc+YGumLtsP6H2NVSvkvTIPPQNAACgEeYqjgwAAIA5zFYceVP3su0fV3vG\n", + "cwAAAHRJKY58oe3HJP1I7bmkNkm6uXC/AAAAGiPlovQ/k3SGpEcj4jhJb5aUVtgGAADgEJCSUE1E\n", + "xP9K6rPdiojbJb2ucL8AAAAaI2UeqhdsHybpTkl/Z3uzpG1luwUAANAcKUeo3i5ph6RLJd0i6XFx\n", + "ByAAAMA+KcWRJ49G7ZH0+aK9AQAAaKDZJvbcpvZEntOJiBgp06XqSpbgyCl/UWq7JfX1pRy0bGu1\n", + "WkX6kPNZ5JQukaSJiYnk2JyyNqVic+Tu9/39KWf824aH02dMySk9s2PHjuTYnLHL/T71yvcvVdP6\n", + "m6uJv50HonQJmm22eagWV9247SMkXSPpJLWTs9+NiO9X3S4AAEAvSf8v6v75tKR/iYh32O6XtKhw\n", + "ewAAAPOuWEJl+3BJb4yISyQpInZL2lKqPQAAgLqkXzCT7zhJ/2P7Otv32v4b2wsLtgcAAFCLkglV\n", + "v6RTJf1VRJwqabukywu2BwAAUIuS11A9KenJiPhBZ/lGTZNQjY6O7ns8NDSkoaGhgl0CAABIk3MX\n", + "abGEKiKetf2E7eMj4lFJb5H00NS4kZGenX0BAAAcwqZOhzFbglX6Lr8/VLtczaCk/5T03sLtAQAA\n", + "zLuiCVVE3Cfp9SXbAAAAqFvJi9IBAAAOCaVP+c0ptXxJTomR3NIeOaUycmJz5JQtyCn5klNKJnfb\n", + "pUrP5Gw3t9xDzr4xPj6eHFuqhErO/pZbgiOnHzt37szadqpSZUN6pRxJjib2GS8pVZYs9zc8Z9tN\n", + "K5dTsqRUauxscRyhAgAAqIiECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgA\n", + "AAAqIqECAACoiIQKAACgotpLz/SCUuU9SpUiyNlubhmeUiVwcj7jnJIou3btSo6V8koY5cT2Qkmi\n", + "kmUkeuE7gkPHwb5f5Ly/3N+WUmVtcmJLvb9eKD0zm6JHqGx/zPZDth+w/SXbQyXbAwAAqEOxhMr2\n", + "Sknvk3RqRLxaUkvSu0q1BwAAUJeSp/xGJU1IWmh7j6SFkp4q2B4AAEAtih2hioj/k/SXkv5b0tOS\n", + "XoyIfy3VHgAAQF1KnvL7aUl/JGmlpGMkLbb9W6XaAwAAqEvJi9JfJ+l7EfF8ROyW9DVJZ04N2rJl\n", + "y74/Y2NjBbsDAABQRslrqH4o6U9sL5A0JuktktZNDTr88MMLdgEAAKC8ktdQ3Sfpekl3S7q/s/pz\n", + "pdoDAACoS9GJPSPik5I+WbINAACAulF6BgAAoCISKgAAgIpqr+W3Y8eOpLiSdcpyahSVqq1Wqu5f\n", + "bh2onPicOoGlaujlyvnsBgYGimw3J7a/P/0rumDBguRYSRoeHk6OzamvODo6mhw7Pj6eHJuzX+R8\n", + "p6W8sT7iiCOSY3O+IzmfW24Ny1Jy9uXBwcHk2JGRkeTYnH1IKlc7Luf9LV68ODn2qKOOSo6V8r4n\n", + "Oftnzm9RqT7k/A7lxqfuF5s2bZrxOY5QAQAAVERCBQAAUBEJFQAAQEUkVAAAABWRUAEAAFREQgUA\n", + "AFBRTyZUubdGorcwfs21c+fOuruACnJu80dvGRsbq7sLqIiECgcc49dc/Kg3GwlVc/Hda76eTKgA\n", + "AACahIQKAACgItd5iNg2x6cBAEBjRMS0NZdqTagAAAAOBpzyAwAAqIiECgAAoKKeS6hsn2f7h7Yf\n", + "s/3RuvuDmdn+W9vP2X6ga90S27fZftT2rbaPqLOPmJntFbZvt/2Q7Qdtf6iznjHscbaHba+1vcH2\n", + "Rtsf76xn7BrEdsv2etvf7Cwzfg3WUwmV7Zakz0o6T9KJki62fUK9vcIsrlN7rLpdLum2iDhe0r91\n", + "ltGbJiRdGhEnSTpd0gc63zfGsMdFxJikcyPitZJeI+lc22eJsWuaNZI2Spq8mJnxa7CeSqgknSbp\n", + "8YjYFBETkr4i6W019wkziIg7Jb0wZfWFkr7QefwFSW+f104hWUQ8GxEbOo+3SXpY0nIxho0QETs6\n", + "DwcltdT+LjJ2DWH7WEnnS7pG0uRdY4xfg/VaQrVc0hNdy0921qE5joqI5zqPn5N0VJ2dQRrbKyWd\n", + "ImmtGMNGsN1ne4PaY3R7RDwkxq5JPiXpMkl7u9Yxfg3WawkVczgcRKI9Jwdj2uNsL5b0VUlrImJr\n", + "93OMYe+KiL2dU37HSjrb9rlTnmfsepTtt0raHBHr9dLRqZdh/Jqn1xKqpySt6FpeofZRKjTHc7aP\n", + "liTbPyFpc839wSxsD6idTN0QETd1VjOGDRIRWyT9s6RfEGPXFGdKutD2jyR9WdIv2r5BjF+j9VpC\n", + "dbekVbZX2h6UdJGkb9TcJ+T5hqRLOo8vkXTTLLGokW1LulbSxoi4quspxrDH2V46eQeY7QWSfknS\n", + "ejF2jRARV0TEiog4TtK7JH07It4txq/Rem6mdNu/IukqtS+yvDYiPl5zlzAD21+WdI6kpWqf7/9T\n", + "SV+X9A+SXiVpk6R3RsSLdfURM+vcFfYdSffrpVMLH5O0ToxhT7P9arUvWu7r/LkhIq60vUSMXaPY\n", + "PkfShyPiQsav2XouoQIAAGiaXjvlBwAA0DgkVAAAABWRUAEAAFREQgUAAFARCRUAAEBFJFQAAAAV\n", + "kVABqJ3tuzp//6Ttiw/wtq+Yri0AOJCYhwpAz7D9JrUnObwg4zX9EbF7lue3RsRhB6J/ADATjlAB\n", + "qJ3tbZ2Hn5D0Rtvrba+x3Wf7StvrbN9n+/c78W+yfaftr0t6sLPuJtt3237Q9vs66z4haUFnezd0\n", + "t+W2K20/YPt+2+/s2va/2/5H2w/b/uL8fhoAmqi/7g4AgF4qffNRSR+ZPELVSaBejIjTbA9J+q7t\n", + "Wzuxp0g6KSL+q7P83oh4oVPbbp3tGyPictsfiIhTpmnr1yT9vKTXSFom6Qe2v9N57rWSTpT0jKS7\n", + "bL8hIjhVCGBGHKEC0Es8ZfmXJb3H9npJ35e0RNLPdJ5b15VMSdIa2xsk/YekFZJWzdHWWZK+FG2b\n", + "Jd0h6fVqJ1zrIuLpaF8TsUHSygrvCcAhgCNUAHrdByPitu4VnWuttk9ZfrOk0yNizPbtkobn2G7o\n", + "lQnc5NGr8a51e8RvJYA5cIQKQC/ZKqn7AvJvSXq/7X5Jsn287YXTvG5E0gudZOrnJJ3e9dzE5Oun\n", + "uFPSRZ3rtJZJOlvSOr0yyQKAOfG/LgC9YPLI0H2S9nRO3V0n6TNqn26717YlbZb0q5347luUb5H0\n", + "B7Y3SnpE7dN+kz4n6X7b90TEuydfFxH/ZPuMTpsh6bKI2Gz7hCnb1jTLAPAyTJsAAABQEaf8AAAA\n", + "KiKhAgAAqIiECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICK/h/BppqaWNmBIwAA\n", + "AABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAES9JREFUeJztnVmMpNdVx3+nq6prX3qbnvG4x4tmsEYRkv1ikJyICIVo\n", + "/ELghcgSUmQC4gECgkiY8BIjeIiQEiFeIiA2CosSIZCjBAmwjQIYIRYjb4E4jqVZPNPdM91de9fe\n", + "fXmoOt/c/qZ6qaU9VfXdn/Sp9qvTM3+du5zlE2MMDscgzN1vAxzThxONY2CcaBwD40TjGBgnGsfA\n", + "ONE4BmZo0YjIFRF5V0R+KCLPjdMox2Qjw5zTiEgI+AHwCeAW8N/AM8aY74/XPMckMqyneRJ43xhz\n", + "zRjTBr4JfGp8ZjkmmfCQvzsPfGC9vgn8mP0FEXFHzVOOMUb6vT+sp3GCCDDDiuYWsGa9XqPrbRwB\n", + "YFjRvA5cEpGHRWQe+DTw7fGZ5ZhkhlrTGGM6IvKrwD8CIeAFt3MKDkNtuU80sFsITz3jXgg7AowT\n", + "jWNgnGgcA+NE4xgYJxrHwDjROAbGicYxME40joFxonEMjBONY2CcaBwDM2wSFgAicg0oA3tA2xjz\n", + "5DiMmnbm5uYQEe8xHA4TCoUIh8OEw2H29vYOXPv7+weuSS+VHkk0dJOxPm6MyY/DmFkhHA4zPz9P\n", + "NBplfn6eTCZDJpMhm82SyWSo1+tUq1Xvqtfr1Ot1Go0G9XrdG2dSxTOqaAD6RkKDTCQSIZFIkEgk\n", + "SKVSnD17lnPnznHu3DkeeOABisUiW1tb3Llzh62tLUqlEqVSCYBms8ne3h4AIjKRwhmHp3lVRPaA\n", + "PzbG/OkYbJp6wuEw8XicbDZLNptlbW2NixcvcunSJS5evMjt27e5ceMG169f97wRQKvVolKpTPwU\n", + "NaponjLGbIjICvCKiLxrjHltHIZNGyJ3HW40GiWVSrG4uMjKygpra2s8+uijPPbYY1y+fJnFxUVi\n", + "sRihUMj7bbvdplqteusgmNHpyRiz0XvcEpGX6Ja2BE40/oVvKpViZWWFBx98kAsXLrC2tsby8jKJ\n", + "RAIRIR6Ps7CwwPnz573fNJtNisUioVCITqcDzKBoRCQBhIwxFRFJAp8Efndslk0RKphQKEQoFCKd\n", + "Tnse5tKlS6yurrK0tEQymUREiMViLCwsICIkEglarRaFQoH19XVCoZC3lpnFNc0q8FLPlYaBvzLG\n", + "vDwWq6YMEfG21KFQiFQqxfLysica3TWpp1HRJBIJlpeXqVarrK+vk0qlPNFMqmBgBNEYY64Cj4/R\n", + "lqlFvUwkEmF+fp50Os3i4iKrq6usra0Rj8e9LbiIEIlECIVCxONxjDEsLi6SSqWIRqPedKXXJDKO\n", + "LXfgCYfDxGIx4vE4iUSCdDpNKpUiHo8TjUaJRCKEw2Hm5roH8O12m2azSbPZpNVqkc/nqVarNBoN\n", + "77DPGDN7nsZxl1AoRCwWI5VKkU6nyWQyJJPJvqLRnVKtVqNSqVCtVsnn81QqFU80xpiJ3nY70YyB\n", + "cDhMNBolmUySzWZJp9Mkk0kSiQTRaJRwOOwtlqHraXZ3dymVSuTzeU80erA3yYIBJ5qxoCfAmUyG\n", + "paUlcrmcNz3p+sVGPU2hUODOnTsHPI0tmEkVjhPNEOgCVR/j8Ti5XM5b+K6urpLL5YjFYn0Xs+pp\n", + "isWiJ5pqtUqz2Zx4wYATzdDYOxxbNA899NAB0fRDReP3NM1mc+KnJnCiGRoVzNzc3AHRXLhwgaWl\n", + "JbLZ7JGeplarHelpJhknmiFQseilwcmVlRXOnz/vbbmj0Wjf359keppknGiGQA/y9EqlUt52O5VK\n", + "ebsmewFsi6HdblOv1ymXyxQKBcrlMrVajXa77UQzq4RCIebn54nFYt5W2xaOpjvoVltRQahoKpUK\n", + "+XyecrlMvV53opll1NPEYjEv0coWjcag9FzGPt01xhwQTaFQoFqt0ul0vOSrSefYxHIReVFEbovI\n", + "O9Z7iyLyioi8JyIvi0judM2cLEKhENFolHg87k1JyWTSO9CLxWL3nM8YY7yc4Far5aV8lkolL4Qw\n", + "LZ7mJNUIfwZc8b3328ArxpgfAf6p9zoQiAjz8/MkEglyuRzLy8vkcjmSySTz8/OH7pYajQbVapVC\n", + "oUClUpmq6cjPsaLpZeIVfG//NPD13vOvAz8zZrsmGj0B1h1TNpslkUgQiUT6fn9vb+/AdGSvYaaR\n", + "Ydc0q8aY273nt+nm1gSGSCRCMpn0PM1xoul0Op6nKZVKVCqVqdot+Rm5WM50/+rp+8tHwPY0tmg0\n", + "QdyPvcXe2dmhVCoFUjS3ReQsgIicA+6Mz6TJR/NnUqkU2WyWVCp1IFEc7u6Y9vf3qdfrFItFNjY2\n", + "uH79Ouvr6xQKBer1eqBE823gM73nnwG+NR5zpgM7FUIXwbFYjHC4O9urYPRqNBoUCgU2Nze5evUq\n", + "Gxsb5PN5arXabIpGRL4B/DvwmIh8ICLPAl8CfkpE3gN+svc6MBzmaVQ0it/TbG5ucu3atan3NMcu\n", + "hI0xzxzy0SfGbMtEo1vpubk572BPRZNMJg8kW9lTkzHmgGhu3LhBsVj0ynFnUjQOvML9cDhMJBI5\n", + "UJetouk3PWlBv+YE64FerVaj1Wp5qZ3ThhPNMWjXh2g0SiwWIxaLeYLRS2NQtmjsLhC65a7Vap6H\n", + "UdFMI040J0DXMBqY9HeB0JCBf/e0v7/P3t7eAU+zu7tLvV73QgrO08wo9m7J9jB6+UMHtqfpdDr3\n", + "TE+tVus+/SXjwYnmBGiAUmua+uXL2LRaLXZ3d71ra2uLcrlMs9n8kC0/HZxojkHXNBqkPIloms2m\n", + "F2fK5/Nsb297OcDTOB35caI5AX5Po2W2R3maSqXC9vY2m5ubbG9vUy6XaTQaMyEa16jxBOiaxu9p\n", + "/Id5iopmZ2eHjY0NTzRuegoQmt6pSVcanFRP4w8baHBye3ub9fV1Nz0FDW0jctj0JCL3dOes1WqU\n", + "SiW2t7fv8TRONAHBnp76VRvYZzKacKWiWV9fp1gsep5mFhg2R/h5EbkpIm/0Ln866Eyh09NhC2Fb\n", + "NJ1O5x7RzJqnGTZH2ABfMcY80bv+Yfym3T/8XSByuRyLi4ssLy9z5swZFhYWvJxgOHiYpyfA/h40\n", + "nU6H/f39+/yXjYeTRLlfE5GH+3w0mW2aRsQfa0okEiwsLLC0tMTKygpnzpzxqg80vdPvafQUuNVq\n", + "0Ww2abfbU9FC5KSMsuX+nIi8JSIvzFoJix1rymaznmiO8jRaomILxhbNLHmaYUXzVeARuj33NoAv\n", + "j82i+4x6mn6iWVlZ8TpCDOJpAjc99cMY4+UEi8jXgO+MzaIJwG68qJdWTGrVJNxNzLKrDez7HUxr\n", + "4vhxDOVpesnkys8C7xz23WnE7gtspz30Ewzg7Ziq1aq3vW40Gl4T6VnjWE/TyxH+CWBZRD4Avgh8\n", + "XEQep7uLugr88qla+SFj9wXWy24/70+FUE8zK8VwxzFsjvCLp2DLxHCUpzms7NZf0F+v1+l0OjM5\n", + "PbkTYR92rXY2m2VpaYlMJuM1XYT+JSpaCLexscHOzo7XpGgWcaLpg7/sNpfLkUgk+uYAG2Oo1Wpe\n", + "gFJjTbMUNvDjRONDPY2KRgv8D9tia12THTbY2dmhXC7TarXc9BQUbNH0K/A/KkC5sbHhFfk7TzPD\n", + "2Pdr0vWMNpLudwLsjzHV63WvbX2pVGJ3d5dmsxncLXcQsO/VZAcq9c5wmnhlexq7ykBrmnZ3d72d\n", + "k4rGTU8ziHoYPY+xRaOeJhqNejfGAPrWM6loKpWKF2ua1mK44wi8aOCup9GOnVqjraKxpy/gnnom\n", + "u3pyGm5cOipONPSva9JEK7utqz5qDz1dw2gf4Far5W3FZ5nAi8Yf1dZ7NdldIGy0pau2qZ+FzlaD\n", + "EnjRQPcwzy679Zeo+IWjotEDPVs0QeDIKLeIrInId0Xkf0XkeyLya733Z6aPsO1ptLhfPY1WG/hR\n", + "0ZRKpXs8TRA4LjWiDfyGMeYjwI8DvyIil5mxPsK6e9Ibl9r5M3B44vjW1pZ3AjzLh3l+jhSNMWbT\n", + "GPNm73kV+D5wnhnrI9wvqm1HtP2pnPa9mm7dujVzFZTHceI1TS+5/AngP5mxPsL98mfsqcluG9Lp\n", + "dA7cdufmzZuUy+WZKlE5jhOJRkRSwN8Cv26MqfjuLGJEZGr/pex7N+kUdZin0QM9WzS3bt2i0Wh4\n", + "+cBB4CTFchG6gvkLY4y2fp2pPsKHbblDodCB9YwKQ0+B9STYLlMJAsftngR4Afg/Y8wfWh/NTB9h\n", + "ESESiRCPx8lkMiwsLHgtXu2wga5nGo3GgbIUDRfM+imwzXHT01PAzwNvi8gbvfe+QLdv8F+LyGeB\n", + "a8DPnZqFHwLatj6dTrOwsOCV3uo5jYrGLklptVqed1HRBIUjRWOM+TcO90Yz0Ue4n6dJp9MHWrz6\n", + "A5R+T2Nn8QWBQDc10jveanu0eDzu9QSORCKHntOod1EPo4IJimgCGUawA5D2+YzeLU4DlXadk783\n", + "sC2UIAkGAuxp7Juxa1qEFv1r7oz/HpR263p/crl+LwgE0tModgLWqJ4mSATa0yj2QleL9e1u4v6k\n", + "K7t1SBAJrKexpxT73gWVSsVLytLDOhWNZumpcIIqmsB6GkVF02w2+97wQkMI6oXspHEnmoDiF43e\n", + "/ti+S4rtafSzIIUN/AR+etrf3/dqsbe3t0mlUgAHKhQ0D7hSqRzoPeNEE0B0R1Sr1SgUCqyvrwN4\n", + "gtDPd3Z22NnZ8XrPaJDSiSZAGGMOpD3UajXy+TzGmANFbvqdYrHoXX7RBG27DceIRkTWgD8HztBt\n", + "YPQnxpg/EpHngV8Etnpf/cK0tYW1p6darQbg9ZgxxnjT09zcHJVKxUu0sstVnKfpj+YIv9lLxPof\n", + "EXmFu32Ev3LqFp4yWpKiTYja7bZXjTA3N+clXWkFpSZg7e7uTv3NvobluCj3JrDZe14VEc0Rhhnq\n", + "I6y7I+ge+hWLRcLhMJ1Ox0vj1POZRqPhTVNBFY2cdE7u5Qj/C/AR4PPAs0AJeB34vDGm6Pv+1Ez2\n", + "dufOUCjkNZfW+yCoB9JHO2uvXq/fb/NPDWNMX8dwItH0pqZ/Bn7fGPMtETnD3fXM7wHnjDGf9f1m\n", + "akRjR701VUK7SITD4XuClBpC0PSIWWVo0fRyhP8O+Htfyqd+/jDwHWPMj/renxrROPpzmGiGyhGe\n", + "9T7CjqM50tOIyEeBfwXeprtjAvgd4Bm6Le69PsJWHZT+1nmaKWekNc0wONFMP0NNTw5HP5xoHAPj\n", + "ROMYGCcax8A40TgGxonGMTBONI6BObVzGsfs4jyNY2CcaBwDc6qiEZErIvKuiPxQRJ4bw3jXRORt\n", + "EXlDRP5riN+/KCK3ReQd672h29seMt7zInKzZ+MbInJlgPHG2oL3iPGGthG499Z647qAEPA+8DAQ\n", + "Ad4ELo845lVgcYTff4xus8l3rPf+APit3vPngC+NON4Xgd8c0r6zwOO95yngB8DlYW08YryhbTTG\n", + "nKqneRJ43xhzzRjTBr4JfGoM4w6dZmqMeQ0o+N4eur3tIePBkDaaMbfgPWK8oW2E052ezgMfWK9v\n", + "ctfgYTHAqyLyuoj80ohjKafR3vZzIvKWiLwwbDf3cbfgtcb7j1FtPE3RnMZe/iljzBPA03S7p39s\n", + "nIObrh8f1e6vAo/QzTfaAL486AD+Fryj2tgb729641VHtfE0RXMLWLNer9H1NkNjjNnoPW4BL9Gd\n", + "AkdlrO1tjTF3TA/ga4PaOO4WvNZ4f6njjWrjaYrmdeCSiDwsIvPAp+m2kh0KEUmISLr3PAl8kvGk\n", + "mY61ve0oqbDjbsF7aum6o+xmTrB6f5ruiv19ulWYo4z1CN0d2JvA94YZD/gGsA606K63ngUWgVeB\n", + "94CXgdwI4/0C3YrUt4G3ev+5qwOM91Fgv/c3vtG7rgxr4yHjPT2KjcYYF0ZwDI47EXYMjBONY2Cc\n", + "aBwD40TjGBgnGsfAONE4BsaJxjEwTjSOgfl/g7yNWl4b+UcAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAADzVJREFUeJzt3WuQZVdZh/HnP90zyYwTJkQwBBgcVNAkBRIEKtwJoBUp\n", + "CKgIiQqIFpYFSIxIcanST1oglEWkKK3CRC5BQAUMUCoQJUIAyRCYyW3CzSKagGS8DIEmmWF68vrh\n", + "nEk6zVz27j2rzzmd51fVNWef8561Vp/V3fXO3muvN1WFJEmSVm7dpAcgSZI060yoJEmSBjKhkiRJ\n", + "GsiESpIkaSATKkmSpIFMqCRJkgaan2TnSdyzQZIkzYyqyqGeb5pQJTkbuBCYAy6qqj9ZHnPyySf/\n", + "wPsWFhbYvHnzivu94447msUvLi42affAgQNN2u27z9ixaPvAgQPMzc2teBytYlcSL0lSF80u+SWZ\n", + "A94KnA2cBpyX5NRW/UmSJE1KyzVUjwG+VlU3VtV+4H3Asxv2J0mSNBEtE6oHADctOb55/NxRbdiw\n", + "ocmAtDqSQ15eliRpzWqZUK14sYoJ1Wxbt86bRyVJ9ywtF6V/A9i65Hgro7NUd7OwsHDn4w0bNphM\n", + "SZKkmdMyoboKeEiSbcA3gecD5y0PGnI3nyRJ0jRollBV1WKSlwMfY7RtwsVVdUOr/iRJkiYlk9yX\n", + "J0kdah+qodyH6i6T2IdqWmNXEi9J0lIT2dizi3vf+96d4pZvFHkkfe8y69P2/Hz3j2zjxo2dY084\n", + "4YTOsSeeeGLn2C1btnSOhX6XYPt8f5s2bWoyhpNOOqlzLMApp5zSObZPst/15xj6fRZ9FvhPy92V\n", + "rX5XW/4NaKXPOFrFQr//SLT67KZlTmbNLP6ncRbnuuvndqS/Q96OJUmSNJAJlSRJ0kAmVJIkSQOZ\n", + "UEmSJA1kQiVJkjSQCZUkSdJAJlSSJEkDmVBJkiQNZEIlSZI0kAmVJEnSQCZUkiRJA028OHLXGmjr\n", + "16/v3O5xxx3Xaxx94vu23VWf4si3335759h9+/b1Gkef+P3793eOXevFn/uYtXb7mpZxtNKqTtla\n", + "/9ykteJwxZGbnqFKsjXJ5UmuT3Jdkle07E+SJGkS5hu3vx+4oKp2JtkMfCHJZVV1Q+N+JUmSVk3T\n", + "M1RV9a2q2jl+vADcANy/ZZ+SJEmrbdUWpSfZBpwBXLlafUqSJK2GVUmoxpf73g+cPz5TJUmStGa0\n", + "XkNFkvXAB4B3V9Wly19fesfa/Px8r7v5JEmSpkHThCqj+4svBnZV1YWHitm4cWPLIUiSJDXX+pLf\n", + "44FfA85KsmP8dXbjPiVJklZV0zNUVfVp3I1dkiStcSY7kiRJA0289My2bds6xfYpGdInFmBxcbFz\n", + "7DSUUJmG8il92163bjpy91Zz3afdVvPXd65blVBppeVnsdZNw1w7JyszDXPX0iz+XEyk9IwkSdI9\n", + "gQmVJEnSQCZUkiRJA5lQSZIkDWRCJUmSNJAJlSRJ0kAmVJIkSQOZUEmSJA1kQiVJkjSQCZUkSdJA\n", + "TYsjd7Fnz55j3mbfMid94luVAehTjqRV+RvoVwagzzhalQ3pW7ZgWsq+TINZHLNWxrmeXc7d7Dhs\n", + "QpXkl4ACDpVBVFV9sEsHSeaAq4Cbq+pZKxqlJEnSFDvSGapnMUqoDqdTQgWcD+wCTug6KEmSpFly\n", + "2ISqqn59aONJHgg8A/hj4PeGtidJkjSNjrp4KMn9klyc5KPj49OS/GbH9t8MvArot5BHkiRphnRZ\n", + "jf0O4OPA/cfHXwUuONqbkjwT2F1VOzj0OixJkqQ1oUtCdZ+q+hvgAEBV7QcWO7zvccA5Sb4OvBd4\n", + "apJ3LQ/au3fvnV+Li12alSRJmi5dEqqFJD988CDJmcCtR3tTVb2uqrZW1YOBc4FPVNULl8cdf/zx\n", + "d37Nz098FwdJkqTeumQwrwQ+AvxYks8C9wWeu4K+3ExDkiStSemyaViSeeAnGa2F+vL4st/wzpPa\n", + "smXLsWjqbqZlY89Wm2S6sefKYsGNPSVJw1TVIROBo56hSrIReCnwBEZnma5I8hdVtffYDlGSJGk2\n", + "dbnk9y7gO8BbGJ2h+hXgEuCXG45LkiRpZnRJqE6vqtOWHH8iya5jNYC5ublOcX0utbWqt9dXn3Gs\n", + "X7++c+yGDRuajAH6Xbrqc/ms1aW2vneG9omflsuw06DV75SXVSWtFV0WD30xyWMPHozv8vtCuyFJ\n", + "kiTNliMVR752ScxnktzEaA3Vg4Avr8LYJEmSZsLRiiNLkiTpKI5UHPnGpcdJfgQ4vvWAJEmSZk2X\n", + "4sjnJPkq8HXgk8CNwD81HpckSdLM6LIo/Y+AxwJfGZeReRpwZdNRSZIkzZAuCdX+qvofYF2Suaq6\n", + "HHhU43FJkiTNjC77UO1JcgJwBfDXSXYDC22HJUmSNDu6nKF6DnAbcAHwUeBreAegJEnSnY56hqqq\n", + "Dp6NOgC8o+loJEmSZtCRNvZcYLSR56FUVd3rWAxg06ZNneJalqhoVWJkGkqX9P0sWpWemYZ2W7a9\n", + "1suirPXvT5KGOtI+VJuHNp7kROAi4HRGydlvVNXnhrYrSZI0TbosSh/iz4B/rKrnJpkHfqhxf5Ik\n", + "SauuWUKVZAvwxKp6EUBVLQK3tupPkiRpUrrc5bdSDwb+O8nbk3wxyV8m6bZgSpIkaYa0TKjmgUcC\n", + "f15VjwS+B7ymYX+SJEkT0TKhuhm4uao+Pz5+P6ME625uvfXWO7/27t3bcDiSJEltNFtDVVXfSnJT\n", + "kodW1VeApwPXL4/bsmVLqyFIkiStitZ3+f0Oo3I1G4B/B17cuD9JkqRV1zShqqqrgUe37EOSJGnS\n", + "Wq6hkiRJukdofcnv6AOY7zaExcXFzm32iYXpKPuSpHPs3Nxc59iWWpVm6fNZ9NVnrlv9zLUsrTNr\n", + "Ws71NFjr8yetFV3/Fh3pd9ozVJIkSQOZUEmSJA1kQiVJkjSQCZUkSdJAJlSSJEkDmVBJkiQNZEIl\n", + "SZI0kAmVJEnSQCZUkiRJA5lQSZIkDTTx0jO33357p7g+5Tr6xEK78hDr1nXPV1vF9v3eupYCAli/\n", + "fn3n2D5j7lMe5vvf/37nWIB9+/Z1ju3zc9Tn++tTbqVPbMsyJ63KDLWK7atVCZxpmT9JR3Ysfv+a\n", + "nqFK8tok1ye5Nsl7khzXsj9JkqRJaJZQJdkGvAR4ZFU9DJgDzm3VnyRJ0qS0vOT3HWA/sCnJAWAT\n", + "8I2G/UmSJE1EszNUVfV/wJ8C/wl8E/h2Vf1zq/4kSZImpeUlvx8HfhfYBtwf2JzkV1v1J0mSNCkt\n", + "F6U/CvhsVf1vVS0CHwQetzxoYWHhzq++d2xJkiRNg5ZrqL4E/EGSjcBe4OnA9uVBmzdvbjgESZKk\n", + "9lquoboaeBdwFXDN+Om3tepPkiRpUppu7FlVbwTe2LIPSZKkSbP0jCRJ0kAmVJIkSQNNvJZfV31q\n", + "pc3NzfVqexpqq7WK7VvXcO/evZ1jb7vtts6xferztYqFfp/HNMzfLJrF728WxyxpuniGSpIkaSAT\n", + "KkmSpIFMqCRJkgYyoZIkSRrIhEqSJGkgEypJkqSBpjKhskjybFtcXJz0ELRCbh8gSStjQqVjzoRK\n", + "knRPM5UJlSRJ0iwxoZIkSRook1wzkcQFG5IkaWZU1SFr0E00oZIkSVoLvOQnSZI0kAmVJEnSQFOX\n", + "UCU5O8mXknw1yasnPR4dXpK/SnJLkmuXPHdSksuSfCXJx5OcOMkx6vCSbE1yeZLrk1yX5BXj553D\n", + "KZfk+CRXJtmZZFeS14+fd+5mSJK5JDuSfGR87PzNsKlKqJLMAW8FzgZOA85LcupkR6UjeDujuVrq\n", + "NcBlVfVQ4F/Gx5pO+4ELqup04EzgZePfN+dwylXVXuCsqnoE8HDgrCRPwLmbNecDu4CDi5mdvxk2\n", + "VQkV8Bjga1V1Y1XtB94HPHvCY9JhVNUVwJ5lT58DvHP8+J3Ac1Z1UOqsqr5VVTvHjxeAG4AH4BzO\n", + "hKq6bfxwAzDH6HfRuZsRSR4IPAO4CDh415jzN8OmLaF6AHDTkuObx89pdpxcVbeMH98CnDzJwaib\n", + "JNuAM4ArcQ5nQpJ1SXYymqPLq+p6nLtZ8mbgVcAdS55z/mbYtCVU7uGwhtRoTw7ndMol2Qx8ADi/\n", + "qr679DXncHpV1R3jS34PBJ6U5Kxlrzt3UyrJM4HdVbWDu85O3Y3zN3umLaH6BrB1yfFWRmepNDtu\n", + "SXI/gCSnALsnPB4dQZL1jJKpS6rq0vHTzuEMqapbgX8AfgbnblY8DjgnydeB9wJPTXIJzt9Mm7aE\n", + "6irgIUm2JdkAPB/48ITHpH4+DLxo/PhFwKVHiNUEJQlwMbCrqi5c8pJzOOWS3OfgHWBJNgI/C+zA\n", + "uZsJVfW6qtpaVQ8GzgU+UVUvwPmbaVO3U3qSnwcuZLTI8uKqev2Eh6TDSPJe4MnAfRhd7/9D4EPA\n", + "3wIPAm4EnldV357UGHV447vCPgVcw12XFl4LbMc5nGpJHsZo0fK68dclVfWmJCfh3M2UJE8GXllV\n", + "5zh/s23qEipJkqRZM22X/CRJkmaOCZUkSdJAJlSSJEkDmVBJkiQNZEIlSZI0kAmVJEnSQCZUkiYu\n", + "yWfG//5okvOOcduvO1RfknQsuQ+VpKmR5CmMNjl8Vo/3zFfV4hFe/25VnXAsxidJh+MZKkkTl2Rh\n", + "/PANwBOT7EhyfpJ1Sd6UZHuSq5P81jj+KUmuSPIh4Lrxc5cmuSrJdUleMn7uDcDGcXuXLO0rI29K\n", + "cm2Sa5I8b0nb/5rk75LckOTdq/tpSJpF85MegCRxV+mbVwO/f/AM1TiB+nZVPSbJccCnk3x8HHsG\n", + "cHpV/cf4+MVVtWdc2257kvdX1WuSvKyqzjhEX78I/DTwcOC+wOeTfGr82iOA04D/Aj6T5PFV5aVC\n", + "SYflGSpJ0yTLjn8OeGGSHcDngJOAnxi/tn1JMgVwfpKdwL8BW4GHHKWvJwDvqZHdwCeBRzNKuLZX\n", + "1TdrtCZiJ7BtwPck6R7AM1SSpt3Lq+qypU+M11p9b9nx04Azq2pvksuB44/SbvGDCdzBs1f7ljx3\n", + "AP9WSjoKz1BJmibfBZYuIP8Y8NIk8wBJHppk0yHedy9gzziZ+ingzCWv7T/4/mWuAJ4/Xqd1X+BJ\n", + "wHZ+MMmSpKPyf12SpsHBM0NXAwfGl+7eDryF0eW2LyYJsBv4hXH80luUPwr8dpJdwJcZXfY76G3A\n", + "NUm+UFUvOPi+qvr7JI8d91nAq6pqd5JTl7XNIY4l6W7cNkGSJGkgL/lJkiQNZEIlSZI0kAmVJEnS\n", + "QCZUkiRJA5lQSZIkDWRCJUmSNJAJlSRJ0kAmVJIkSQP9P+KhTy08mN1cAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAGNNJREFUeJztnVmM7Fldxz+na1+6qrqW7q5ebt+ZuTMDTEzgBU2AyAMh\n", + "Q0xAXyQkRoNofFA0SiLig6D4gCYQow9EZYlbQKOBgInKYETxwQUzw4CyzMxdeu/au/a1jw9dv8Op\n", + "ukvfWrvrzv+bnPyram7/51TVt37n9/ud3+97lNYaBw5GwdJlT8DB4sEhjYOR4ZDGwchwSONgZDik\n", + "cTAyHNI4GBljk0Yp9axS6rtKqZeUUh+c5qQcXG2ocfI0SikX8D3gbcAB8N/Ae7TW35nu9BxcRYxr\n", + "ad4IvKy1vq217gCfB941vWk5uMpwj/l3m8Ce9Xwf+GH7HyilnFTzgkNrre71+riWxiHEqxjjkuYA\n", + "2Laeb3NubRy8CjAuab4BPKmUuq6U8gLvBr40vWk5uMoYy6fRWneVUr8E/BPgAj7tRE6vHowVcj/U\n", + "jR1HeOExbUfYwasYDmkcjAyHNA5GhkMaByPDIY2DkeGQxsHIcEjjYGQ4pHEwMhzSOBgZDmkcjAyH\n", + "NA5GxrhFWAAopW4DZaAHdLTWb5zGpKYNpdTAY7fbjcvlMtezszO01macnZ0NDHkd4LLamIffg1KK\n", + "paUllFID87bnOitMRBrOi7HeqrUuTGMys4J8wEtLS7jdbiKRCMvLy0QiEUKhEN1ul06nY0az2aTR\n", + "aNBsNmk2m5ydndHr9cz1MuZvE8XtduPxeMzo9Xq0220zzs7OzN/OgkCTkgbgnjuhVwXyQbtcLlwu\n", + "Fz6fj5WVFdbX10mn0yQSCUOORqNBo9GgXC5zenpKuVwGoNPpoJSi0+lc6nuQ4fV6CQQCZnQ6Her1\n", + "OrVajV6vN3OrOA1L81WlVA/4Y631n05hTlOHUsosRz6fj3g8zvb2Nk888QRbW1tUq1UzKpUK2WwW\n", + "j8cDQLvdNkvDZViZ4fcgxA+FQoTDYZaXl2m1Wiil6PV6tFqtAeLMApOS5k1a6yOlVAp4Tin1Xa31\n", + "16cxsUkhX/TS0hI+n8/8KiORCOl0mu3tbR5//HF2dnY4PT01lqVUKqG1pt1uU61WzRcl/sNlvAeP\n", + "x4PP5zMjHA4TjUaJRqNEIhHq9TpKKbrdLvV63SylskxNm0ATkUZrfdS/ZpVSX+C8teXSSSNfsFIK\n", + "r9dLIpEglUqRSqVYXV1lZ2eH7e1tVldXiUQixlfpdrs0m03c7vOPRZ53Oh263e6ArzBLDPswy8vL\n", + "xONxEokEiUSCSCRCOBw2o1gs4vP50FpTr9cH3k+32536/MYmjVIqCLi01hWlVAh4O/DbU5vZmLA/\n", + "bDHliUSCnZ0dHnvsMa5du0YqlSKZTJJKpYhEIvR6PTqdDu12m3q9bpambrdLq9Wi2+2aX++83oPt\n", + "w4TDYdLpNNeuXePatWtEo1GCwSDBYJBAIMDJyQlnZ2fU63Xy+bx5L1rrmSxVk1iaNeALfRPqBv5K\n", + "a/2VqcxqQgyv/0KaZ555hqeffppQKEQwGCQUCuHz+cyH3Gq18Pv9d1kaCWXnRRpgwHlfXl5mfX2d\n", + "J598kte97nXEYrG7lqt6vU6xWOTg4IBGo2EIM4sldWzSaK1vAa+f4lwmgu3D2D5ANBollUoZx/ep\n", + "p54a+BVrrc1VTLodfrfb7bm/F3HavV4vXq/XRHs7Ozs89dRTRCIRQ6qlpSWq1SqRSIRAIIDH45m5\n", + "DzaNkPvSIR+QECYWi5mRSqXY2dkhlUoRDodxu920221DiGazyeHhIUdHR2bs7e2Ry+Wo1+uX8n68\n", + "Xi/Ly8tmbGxskEwmiUajBAIBAOr1ukkV7O7ucnx8TLFYpFar0Wq1aLfbM4uiFp409vrvcrnw+/2s\n", + "rKyQTqdJp9Nsbm5y/fp1VldXCYfDuFwuut2uCa9LpRJ7e3tm7O/vk8/nKRQKl0qaSCRinPeNjQ1S\n", + "qZTxZTqdDrVazcxTSFMoFKjVajSbTeOHOaS5D4bzMLFYjI2NDR5//HEee+wx1tbWjKVxuVx0Oh2q\n", + "1Sq5XI5MJsPu7i63bt3i1q1b3Llzx/yCm83mpbwfmzTb29tsbm4a0tjJvGw2y97e3j0tjR1yTxsL\n", + "Txo7te71evH7/cRiMeMDPPHEEyanEQqFWFpaotPpUKlUyOVyHBwcmA/+9u3b3Llz59Leh/ggfr+f\n", + "aDTK6uoqW1tbrK+vE4/HCYVCuN1uut2uSULu7u5ycHBANpulVCrRaDRm7octPGkAY2ECgYDxAyKR\n", + "yABZfD4fLpcLrTWNRoNiscjR0RG7u7tkMhlOT09ptVqXMn+JkmREo1ESiQRra2tsbW2RSCRMlFcs\n", + "FsnlcuRyObLZLNlslkKhQKVSodVqzWVDdeFJI7vWPp+PYDBoCBOJRIjFYkSjURNJyY62kOb4+Jjd\n", + "3V1yudylkkYceImWIpEIiUSC9fV1tra2CIVCZu+rVCoNECaTyVAoFKhWq2ZZmjUeOdLIfoxtaexf\n", + "ca/Xo9FoUCqVjKWpVqvGF7gM2GkC2eqIx+Osra2xubmJy+WiVqtRr9ep1+sDpMlmsxSLRVqtlkOa\n", + "izCcl/H7/YRCIWNlpPwhHA4P1Ma0Wi0qlQqFQoFMJsPh4eFAXmbe81dK4fF4CAQCZlsgHo+bjPXa\n", + "2ppJD7TbbbM85fN5MyqVCr1eb+YblYKFI81wAZLs+MqvU/ZmAoEAbrebs7MzY0mq1SrFYpG9vT2y\n", + "2SyVSoVOp2O2COZVYDXsw9h7Y6lUihs3brCxsWGSeN1u15Rs5PN5isUi1WrVhNZ2sdg8sHCkgcEU\n", + "u9frJRgM3pc0vV6PWq1GJpMhl8txfHxsknfVapVOpzP3D932YTweD/F4nM3NTbO3tLW1RTqdJhKJ\n", + "mLzSMGkqlQqNRmNgX2weVXuw4KSxfRkhjZ05tS1NNpvlzp077O7uGksjpLFLPecBl8s14MMIaW7c\n", + "uMFrXvMaEokEsVjsoUgjlhLmV4p6IWmUUp8BfgzIaK1/qP9aHPhrYAe4Dfyk1ro0w3na8xn40CVi\n", + "isViJBIJkskkkUgEv99vHF8hzd7eHq+88gonJyfk83lqtdpMSgcuwrAfFo/HSafTXL9+naefftps\n", + "d3g8HrTWtFotarUap6enA6Sxl6e5zv8h/s1ngWeHXvsN4Dmt9VPAP/efzwUul4tQKDSwCSklD5ub\n", + "m6ytrRGJRPB4PCaJd3p6SrFYJJ/Pm/C6Xq9fWvmmXX0nDnsoFCIQCOD1eg1RTk9POTk54fj4eOAq\n", + "zu+88jLDuNDSaK2/rpS6PvTyO4Ef7T/+M+BrzIk4LpeLcDhMMpk0db6bm5tmpFIpPB4PbrfbRB3D\n", + "pKlUKtTr9UuxMvCDZGQoFCIajRrS+P1+Q5pms2lCbJswJycnZo9pXiH2XfMf8+/WtNYn/ccnnNfW\n", + "zAVLS0uEQiGSySRbW1vs7OyYzcl0Os3KyoqpWJM9pmHSNJtNWq3WlbI0wWDQkKbVatFsNs28hTCZ\n", + "TIaTkxMT9Q13HswLEzvCWms9T309l8tFMBgkHo+zsbHBtWvXWFtbMyMSiVCpVIw1qVarpva3UCiQ\n", + "z+dNOeS8CsXt8k1gwBdbWVkhGo0SDofN8iSbpaVSiePj4wErc5klG4JxSXOilFrXWh8rpdJAZpqT\n", + "ehjcby2XCjuxNFI7Yye/Zh0p2Yk7ON+A9Pv9BAIB/H4/6+vrbGxsmJFOp4nH4wSDQZRSNJtNCoUC\n", + "BwcHvPLKK2Z/rFqtXmpHhGBc0nwJ+Bng9/rXL05tRmPCJoNdgSc1vhJlzCu0tpOQgUBgoDAsnU4P\n", + "kCaZTLKyskIgEEApRaPRoFAosL+/z0svvcTx8TH5fJ5qtXopy9EwHibk/hznTm9SKbUH/BbwMeBv\n", + "lFLvox9yz3KSF8EmgVgau1hcugmGk2AzlMMdKA4LBoOsrKyYJVTIsrm5ycbGhtnuENLYluall14i\n", + "n8+bRr6FsDRa6/fc5z+9bcpzGQvDhLFJIxZGliX5Iu3Hw71BYx5lNPDYrt+VFIHkYiQ1YFsbr9dr\n", + "+soBY2kODw+5efOm6fS8KljIjPCDIG2rwWDQEGdzc9NU6IdCobsa/GWHWGprR4Xb7R4YUuIgY9iH\n", + "SSaTpqhKEnh2z3ipVDIh9VU8N/2RI400yEmVnpj7s7MzU3RuR09SBVcul6lUKlSr1ZH/n+Lo2g6v\n", + "9CQFAgHTpCdDCsUk8yu+lyxBUrZ5WSH1RXgkSePxeAx5JFnmdrsJh8Osrq4asojagpQa5HI50yg3\n", + "CuxuRxk2MeLxOCsrK8TjceLxuMnHyIaldEVI9rpUKlGtVk3D21XDQpPG9kPksU0WwCwBktupVCrG\n", + "15EOysPDQ4LBoGmSGxVSIWhfZUi/tT2G+5FkiSyXy+RyuQFL45BmCrAr705OTvD7/abJX9LxduQC\n", + "5z5HIBCg1+uZTUwZIiNiF3OPCrEuouQgVxnBYBCfz2dIOexTCVkODw/Z39/n4ODAbBU4y9MUIDW+\n", + "QhrZLZZlwC7vhB8sV36/HzhvD7G/sF6vh8/nIxKJkEwmp+LT+Hy+u557vV4zJ0k+Si5JOiMODw+5\n", + "ffs2h4eHJsx2LM0UYJPG7XYbVYWVlRXq9Trtdtv8om31K2lZHc4Ka62JRCImcppG9CTDlmiTq1LK\n", + "kEb6x21Lc/v2bVP361iaKcEmjSTr4vE4q6urA2GqXd0nX6LP57srpyKY5y9aSCMbk8OkOT09NZGU\n", + "Q5opQGttPnCXy8Xp6SlHR0f4/X601hQKhbuWBilokqu9hMhyZQs02vp1D7MTbveGdzodEz3Jddjx\n", + "FcUq2VCVUL9Wq9FoNMwO/DxLUEfBQpKm0+kMZHaPjo6MoM/x8bHJj0iuRHIn8ppENJIIlP0qCcWl\n", + "CF2+yItQq9XMqFarA8m8cDh8T9KIFo7kh6RFRUgjKYGriIUkjRRPiTOptaZWq5HL5Uxtiq1BIzUr\n", + "y8vLRKNRo6MXCATu2naQGpxisUihUKBUuriKtVgsDowbN24AGDGiYdiWRso4qtXqAGnmXew+Csat\n", + "Ef4I8HNAtv/PPqS1/sdZTdKGkEaI02g0qNVqZLPZgYo4O8kmSbWVlRWSyaQJsWOxmLmnkEa09gqF\n", + "gil8ughS6yKj2+0SDodZX1+/55cupKnVapTLZcrl8l2kucp4GEvzWeCPgD+3XtPAJ7TWn5jJrEaA\n", + "XT8jkPyMvWlpZ1wlxD06OiIejw+Ev51Oh0KhYEaxWLxwDpLFlUL14T4qe9ui1+tRLBbJZDIcHByw\n", + "v7/P4eHhlc7LDGPcGmG4QvrBNnHEzzk7OxvY06lWq8anyeVy7O/vm/pc+wsV7ZpRfBopH202m/ds\n", + "vLPFoaWJP5PJsLe3x82bN029TL1ev5LL0TAm8Wner5T6ac4Pdv/AvFpYhmFr4dkRkERYEqHYCt92\n", + "8k0cYTuCkvzJKHkb29kdLvYSAovAtSQm9/f3uXXrFoVCwXRIPMqk+STwO/3HHwU+DrxvKjMaA+KT\n", + "CGRrwMa98jP306QbtbZmOCNsE1lEoWVTslarGUuzv7/PzZs3zeakhNlXHWORRmttvEOl1KeAL09t\n", + "RlPC8Bc+y1+waOTZOn8icQKYzgLZTRcRonK5bHSK5yk5OynGIo1SKi3C08BPAN+a3pQWDxKJSTnn\n", + "+vo6sVjM7He1Wi3TWSAbkrlcjnK5TLvdvqfzfJUxTo3wh4G3KqVez3kUdQv4hZnO8opDpGfX1ta4\n", + "fv36XaSxlbdu3rzJ4eGhUa2QRN6iEAbGrxH+zAzmsrCwLc21a9cGSCOVgyKiJBuSInkm0q2LhIXL\n", + "CF8FSBQme1m2AJF0eUrxl123I86w7C3NS4Ro2nBIMwakElCG1P6KTyNbGCJ1Mpw8XCT/5V5wSDMG\n", + "pHBdNP1swqytrZmWFBFVsjPTw201iwiHNCNCKgGDwSCxWMwsTba1sZOMYmnsDVFb8mwR4ZBmDAhp\n", + "RH3L1iqWsxds/0UOIZPd7GazOdOzC2YNhzRjQNQ4ZQd9eXnZlJMCRu5M9q+KxaI5uU52s+XYwEWE\n", + "Q5oxIDXHYmnsY3MAc3ZBuVweqMuRgivZ2LwsUaVJ4ZBmDIilGSaNfbiYCCtKeYWQxhaHhMs753sS\n", + "OKQZA/dankQY8uzsbKBYXPaZpFh8kfaY7oeHEWp0MITh5WmYNI1Gg9PTU7OTLQd2NJvNhbQsw3As\n", + "zYiwZemFNKKXN3z2QjabfSRJ80BLo5TaVkr9i1Lqf5VS31ZK/XL/9bhS6jml1PeVUl9RSsXmM92r\n", + "AQm57eXJ5/OxtLRkSHM/S/Mo4KLlqQP8qtb6GeBHgF9USr2WS9QRvgwISaLRqJE6k7OxRVzRbrlt\n", + "t9sm5BYFCBGKfhQszQOXJ631MXDcf1xVSn0H2OQSdYTnDfvQDulwECn9YDA4IE0iFYRSmyylptIu\n", + "vKh5mWE8tE/TLy5/A/CfXKKO8GVABAKkFSaVShGLxQiFQqZDU6Iiux5YSGOLRT7ylkaglAoDfwf8\n", + "ita6MtQDPVcd4XlDLM3y8jKJRIJ0Ok0ymSQWixEMBvF6vYYMdhmEbWmktfdRIAw8XOWeh3PC/IXW\n", + "WqRfL11HeJ4Q0iSTSaOZJ2G2FI7b8mfVatUcQGpbF1uE2h5298Ii5HAuip4U8Gng/7TWf2D9J9ER\n", + "hiuiIzwr2JYmmUySTqdJJBIsLy8bta1OpzOQAS6Xy3cd2GGfHS7FW16v12jXiGzK/TokrhIusjRv\n", + "An4KeFEp9Xz/tQ9xxXSEZw3xaRKJBBsbG/ckjew13Ys0tq6wLRUrQ0omhltxriouip7+nftboyuh\n", + "IzxriIafbWlERmTY0sjZmOVy2RzgJfcY1suxdXNEAWMRCANORvihIF+4dGfaywkMhtoirmjndoY1\n", + "cWSpEjLVajWjHnFVxRltOKSZATweD6FQyEjbh0KhgfPChyv75ORe6SO/6s6wQ5opYFjDzy4HbbVa\n", + "rKysmKMSk8mkadMVy+Tz+YyY0qPgCDsYESJ0LZZGaz1wiMbGxoZxnBuNhjm7qVqtksvlHNK8WuB2\n", + "u40sbSwWw+VyDTwXSxOJRPD5fCZ7LMJGktNxHOFXESSPI1YmFouZRF+9Xjc5GXF6S6US+XzejKOj\n", + "IwqFwiMvNeLAgtfrNYdjBIPBu9Q+7VNe6vW6kRqRowbl2OR6vX7lnWBwSDMVSAgeDAYHBBblKod1\n", + "5HK5AX2ag4MD9vb2zHmbV1WhfBgOaR4Cw+KNtg8ie0f2LrfdFNfpdMjlcmSzWTOOjo7IZDLm8Ay5\n", + "n11wfpXhkOYCiD6xHA/o9/tN6CyJOFusWvSBbW3hUqk0MMSXkWo+u+tyEeCQ5gIIafL5vJFGs4/V\n", + "cblcxuGVIb1OoitsC1MPX6Wib5FEAR5IGqXUNudSsKucCxj9idb6Dy9TR3je0FrTaDTI5/MAZimR\n", + "SCkQCBgtYDmh7uTkxJylfXx8bEQf5Tq8fC1aD9RFlkZqhF/oF2L9j1LqOa6QjvA8ID6NUopOpzNw\n", + "bpMcvWOPTCYzMERexK7esx3lRcO4NcJwhXSEZw0RrxanVyRERFpfcjKyTA0fKSj+yrwOk5811MNO\n", + "vl8j/K/AM8AHgPcCp9xHR/hRKgGVsyZlDJ8iJ5GP5GZsEsnxO3YYDpMd6TwvaK3vaRgeijT9pelr\n", + "wO9qrb+olFrlB/7MR4G01vp9Q39zdT+NEWGXMSil7jr4azgvYyug20vQIhDFxtik6dcI/z3wD0Ml\n", + "n/LfrwNflsM2rNcX45NxcF/cjzRj1Qj3i8kFr3od4VcbHmhplFJvBv4NeJHziAngN4H3AAM6wlYf\n", + "lPytY2kWHBP5NOPAIc3iY6zlyYGDe8EhjYOR4ZDGwchwSONgZDikcTAyHNI4GBkOaRyMjJnlaRw8\n", + "unAsjYOR4ZDGwciYKWmUUs8qpb6rlHpJKfXBKdzvtlLqRaXU80qp/xrj7z+jlDpRSn3Lem1sedv7\n", + "3O8jSqn9/hyfV0o9O8L9pirB+4D7jT1H4O7m9WkNwAW8DFwHPMALwGsnvOctID7B37+Fc7HJb1mv\n", + "/T7w6/3HHwQ+NuH9Pgz82pjzWwde338cBr4HvHbcOT7gfmPPUWs9U0vzRuBlrfVtrXUH+Dzwrinc\n", + "d+wyU63114Hi0Mvv5FzWlv71xye8H4w5R631sdb6hf7jKmBL8I48xwfcb+w5wmyXp01gz3q+zw8m\n", + "PC408FWl1DeUUj8/4b0Es5C3fb9S6ptKqU+Pq+Y+bQle637/MekcZ0maWcTyb9JavwF4B+fq6W+Z\n", + "5s31uR2fdN6fBB7jvN7oCPj4qDcYluCddI79+/1t/37VSec4S9IcANvW823Orc3Y0Fof9a9Z4Auc\n", + "L4GT4kQptQ6mInEieVutdUb3AXxq1Dk+SIJ3nDla9/tLud+kc5wlab4BPKmUuq6U8gLv5lxKdiwo\n", + "pYJKqeX+4xDwdqZTZjpVedtJSmGnLcE7s3LdSaKZh/De38G5x/4y512Yk9zrMc4jsBeAb49zP+Bz\n", + "wCHQ5tzfei8QB74KfB/4ChCb4H4/y3lH6ovAN/tf7toI93szcNZ/j8/3x7PjzvE+93vHJHPUWjvb\n", + "CA5Gh5MRdjAyHNI4GBkOaRyMDIc0DkaGQxoHI8MhjYOR4ZDGwchwSONgZPw/UDzRgG/E2K8AAAAA\n", + "SUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEX5JREFUeJzt3X+QldV9x/HPh112FwQEqmj5YcEirTLxB00cNUbRpB3r\n", + "RE3bNMa2iU076XSSNNQmTowz7Ywz7SRNphObybQzqdZE0yRtSUqSaTXaVowxjQQF/AGiMqHlh0J/\n", + "AAsEll349o97F5d1lz2Hh7PPvfh+zTDe59nvPefsc5579+vz6+uIEAAAAE7chLoHAAAA0O5IqAAA\n", + "ACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAq6qyzc9s8swEAALSNiPBI64smVLavk3S3pA5J90TE\n", + "nw+PmT179uve19vbq2nTpg1vq9AopcOHDxeJzXnG15EjR5JjSzoZYz548KB6enqOWVdqG+dut5z4\n", + "nNic7VYqFgBQn2Kn/Gx3SPqCpOskXSDpFtvnl+oPAACgLiWvobpU0ssRsTki+iV9XdJNBfsDAACo\n", + "RcmEao6kLUOWtzbXjam7u7vIgDA+OjtrvTQPAIBxVzKhOuGLP0io2hsJFQDgjabkX75tkuYNWZ6n\n", + "xlGqY/T29h593d3dTTIFAADaTsmEarWk82zPl7Rd0s2SbhkeNPxuPgAAgHZTLKGKiAHbH5H0XTUe\n", + "m3BvRGwo1R8AAEBdil7sEhEPSnqwZB8AAAB1q/3q4alTpybF5Tzssb+//0SHc1LlPBhywoT0+wNK\n", + "PXBSKvcAzlZ5sGe7PSgz54G27fa7AcCphFp+AAAAFZFQAQAAVERCBQAAUBEJFQAAQEUkVAAAABWR\n", + "UAEAAFREQgUAAFARCRUAAEBFJFQAAAAVkVABAABUREIFAABQkeus/2U7pkyZkhTb2ZledrCrqytr\n", + "HN3d3cmxEydOzGo7VU5NukOHDhWJzY0fGBhIji1Vny+3ll+OdquNlzvedvv9AKAVRMSIRVaLHqGy\n", + "Pc/2o7aft/2c7Y+W7A8AAKAO6Yd9Tky/pNsiYq3tKZKesv1IRGwo3C8AAMC4KXqEKiJejYi1zdf7\n", + "JG2QNLtknwAAAONt3C5Ktz1f0iWSnhyvPgEAAMbDuCRUzdN9yyUtax6pAgAAOGWUvoZKtidK+oak\n", + "r0TEiuE/7+vrO/q6o6Mj624+AACAVlA0e7FtSfdKWh8Rd48Uk/PIAgAAgFZU+pTfWyX9lqRrbK9p\n", + "/ruucJ8AAADjqugRqoj4vngaOwAAOMWR7AAAAFRUe+mZiy++OCk2Z5w5JVEkqb+/Pzk2pzRLqbIo\n", + "OdtiwoS8nLlx2dvJl1MOKKe8T6lSQFLetsvZLw4cOJAcm7MvD73BI0VuWaJUOftQzmcv5/fLaVcq\n", + "W8IoVc7+1tHRkdV2zucvJzbnuyin/NTBgweTY3O/71uh5FLOZyT3Ozxn38iJzdluOZ+nUmXJpHJz\n", + "XUvpGQAAgDcCEioAAICKSKgAAAAqIqECAACoiIQKAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAA\n", + "oCISKgAAgIpqLz1z9tlnJ8XmPCI/txxJT09Pcmx3d3dybE55gVIlHHJ1dpapl52z3SZNmpQcO2XK\n", + "lKxxTJ06NTk2Z7/IaXfGjBnJsTt27EiO3bRpU3KsJG3bti05NmdfPuecc5JjFy9enBy7cOHC5Nje\n", + "3t7kWElav359cuzq1auTY6dPn54ce8MNNyTH3nTTTcmxUl75kpyyPbt3706O3bBhQ3JszjZOLV82\n", + "6Nxzz02OnTlzZnJsTkmpLVu2JMfmbDdJmjVrVnLs3Llzk2MnT56cHHvWWWclx6bmAJJ0+umnJ8dK\n", + "ed/hqWyPWnpm1L+etn9NUkga6Y0REd9M7LxD0mpJWyMi/RsDAACgTRzvcMQNaiRUo0lKqCQtk7Re\n", + "Uvr/wgMAALSRUROqiPjtqo3bnivpekl/JumPqrYHAADQisY8sW77bNv32n6ouXyB7d9NbP9zkm6X\n", + "dKTCGAEAAFpaypWKX5L0sKTZzeWXJN021ptsv1PSzohYo5GvwwIAADglpNzSdUZE/L3tOyQpIvpt\n", + "DyS87wpJN9q+XlKPpGm274+I9w8N2rt379HXXV1dWXeDAQAAlLJy5UqtXLkyKTYlodpn+6cGF2xf\n", + "JmnPWG+KiDsl3dl8z9WSPj48mZLybjcHAAAYL0uXLtXSpUuPLt91112jxqYkVB+T9B1J59r+gaQz\n", + "Jb37BMZV3wOvAAAAChozoYqIp2xfJenn1LgWamNEpD/5rdHGY5IeO7EhAgAAtLYxEyrbkyR9SNKV\n", + "ahxletz2X0fEwdKDAwAAaAcpp/zul9Qr6fNqHKH6DUkPSPr1guMCAABoG2PW8rO9PiIuGGvdCXVu\n", + "R04toVJy6ugdOZL+SK2cdnNqbeXE5tRgk8pti1LbbWAg5YbT1+TUQWyF2Nz5y5HTdm59zFR9fX3J\n", + "sTk15nL2t1aRMx+tsl+Uii31PZTbdp21blFdic9JRIxayy/lL/PTti8fXGje5ffUyRocAABAuzte\n", + "ceRnh8Q8YXuLGtdQnSNp4ziMDQAAoC2MVRwZAAAAYzheceTNQ5dtz1LjiecAAAAYIqU48o22X5L0\n", + "YzWeJbVZ0oOFxwUAANA2Ui5K/1NJl0t6MSIWSHq7pCeLjgoAAKCNpCRU/RHxP5Im2O6IiEclvbnw\n", + "uAAAANpGyoM9d9meKulxSX9ne6ekfWWHBQAA0D5SjlC9S9JPJN0m6SFJL4s7AAEAAI5KKY48eDTq\n", + "sKQvFR0NAABAGzregz33qfEgz5FEREw7GQM4eLD+Gss5pUBKlVAp1W5JpUo4lCw7UWo7t0JsSQcO\n", + "HKh7CKe8dtwvgFY23p+T4z2HakrVxm1Pl3SPpMVqJGe/ExE/rNouAABAK0m5KL2Kv5T0LxHxbtud\n", + "kk4r3B8AAMC4K5ZQ2T5d0tsi4lZJiogBSXtK9QcAAFCXlLv8TtQCSf9t+z7bT9v+G9uTC/YHAABQ\n", + "i5IJVaekJZL+KiKWSNov6Y6C/QEAANSiZEK1VdLWiPhRc3m5GgnWMfbv33/036FDhwoOBwAAoIxi\n", + "11BFxKu2t9heFBEvSnqHpOeHx512GtepAwCA9lb6Lr8/UKNcTZekTZI+ULg/AACAcVc0oYqIdZLe\n", + "UrIPAACAupW8hgoAAOANofQpvzH19PQkxQ0MDCS3mVuOJMeECek5qO0isR0dHcmxEydOTI7Nbbuz\n", + "M333yYnt7u5Ojs29Bi9n/nL2uX379o0d1LRz587k2JzSTDnjlfLKMuRst66uruTYqVOnFhlDbsmJ\n", + "UnOdU9Yq5zsg9zsup+1WKIGT8/vlboucOcn5/XK2cam/IycSn6oVymvl7m8l2j5eHEeoAAAAKiKh\n", + "AgAAqIiECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqIqECAACoyKVK\n", + "ByR1bsecOXOSYnPKC+SUFshtu5Scki85sbllCHJK1aSWDZLySi309fUlx+aUZslt+9ChQ8mxpUqM\n", + "5JTsydnGUl65lVKxOdutFT6nUrkSIzmf69zv7ZxxlCrxkzPXOftQyXIkrSD3O7xUabKcdkvNde7f\n", + "9oIlcEaclKJHqGx/0vbztp+1/VXb6UXaAAAA2kSxhMr2fEkflLQkIt4kqUPSe0v1BwAAUJf08wn5\n", + "eiX1S5ps+7CkyZK2FewPAACgFsWOUEXE/0n6C0n/JWm7pN0R8a+l+gMAAKhLyVN+PyvpDyXNlzRb\n", + "0hTbv1mqPwAAgLqUvCj9zZJ+EBH/GxEDkr4p6YrhQb29vUf/5dyBBQAA0CpKXkP1gqQ/tj1J0kFJ\n", + "75C0anjQtGnTCg4BAACgvJLXUK2TdL+k1ZKeaa7+Yqn+AAAA6lLyCJUi4jOSPlOyDwAAgLpRegYA\n", + "AKAiEioAAICKip7yS5FaNyqnpllOzaHctru6uoq0mzPmnHZL1jXMqfmVUxevZN3GnNpV3d3plZKm\n", + "T5+eHDtjxozk2AULFiTHXnjhhcmxkrRo0aLk2Jx6W5s3b06OfeGFF5JjX3nlleTYWbNmJcdK0pIl\n", + "S5Jjr7766uTYPXv2JMcuX748OXbFihXJsZK0b9++5Nicz1/OvnzRRRclx1577bXJsRs3bkyOlaSt\n", + "W7cmx+7evTs5Nqe26ezZs5NjFy5cmBwr5f1+mzZtSo7N2Yd27dpVJDa3dmvO353Uv2fbt28fvY3k\n", + "3gAAADAiEioAAICKSKgAAAAqIqECAACoiIQKAACgIhIqAACAiloyocq9NRKtpbe3t+4h4AStXbu2\n", + "7iGggpxb29Fach53gNbUkglVX19f3UNABXv37q17CDhB69atq3sIqGD//v11DwEniISq/bVkQgUA\n", + "ANBOSKgAAAAqckTU17ldX+cAAACZIsIjra81oQIAADgVcMoPAACgIhIqAACAilouobJ9ne0XbL9k\n", + "+xN1jwejs/23tnfYfnbIupm2H7H9ou2HbU+vc4wYne15th+1/bzt52x/tLmeOWxxtntsP2l7re31\n", + "tj/VXM/ctRHbHbbX2P5Oc5n5a2MtlVDZ7pD0BUnXSbpA0i22z693VDiO+9SYq6HukPRIRCyS9G/N\n", + "ZbSmfkm3RcRiSZdJ+nDz88YctriIOCjpmoi4WNKFkq6xfaWYu3azTNJ6SYMXMzN/baylEipJl0p6\n", + "OSI2R0S/pK9LuqnmMWEUEfG4pF3DVt8o6cvN11+W9K5xHRSSRcSrEbG2+XqfpA2S5og5bAsR8ZPm\n", + "yy5JHWp8Fpm7NmF7rqTrJd0jafCuMeavjbVaQjVH0pYhy1ub69A+zoqIHc3XOySdVedgkMb2fEmX\n", + "SHpSzGFbsD3B9lo15ujRiHhezF07+Zyk2yUdGbKO+WtjrZZQ8QyHU0g0nsnBnLY421MkfUPSsog4\n", + "pm4Qc9i6IuJI85TfXElX2b5m2M+ZuxZl+52SdkbEGr12dOoYzF/7abWEapukeUOW56lxlArtY4ft\n", + "syXJ9k9L2lnzeHActieqkUw9EBErmquZwzYSEXsk/bOkXxBz1y6ukHSj7R9L+pqka20/IOavrbVa\n", + "QrVa0nm259vuknSzpG/XPCbk+bakW5uvb5W04jixqJFtS7pX0vqIuHvIj5jDFmf7jME7wGxPkvSL\n", + "ktaIuWsLEXFnRMyLiAWS3ivp3yPifWL+2lrLPSnd9i9LuluNiyzvjYhP1TwkjML21yRdLekMNc73\n", + "/4mkb0n6B0nnSNos6T0RsbuuMWJ0zbvCvifpGb12auGTklaJOWxptt+kxkXLE5r/HoiIz9qeKeau\n", + "rdi+WtLHIuJG5q+9tVxCBQAA0G5a7ZQfAABA2yGhAgAAqIiECgAAoCISKgAAgIpIqAAAACoioQIA\n", + "AKiIhApA7Ww/0fzvz9i+5SS3fedIfQHAycRzqAC0DNtL1XjI4Q0Z7+mMiIHj/HxvREw9GeMDgNFw\n", + "hApA7Wzva778tKS32V5je5ntCbY/a3uV7XW2f68Zv9T247a/Jem55roVtlfbfs72B5vrPi1pUrO9\n", + "B4b25YbP2n7W9jO23zOk7ZW2/9H2BttfGd+tAaAdddY9AADQa6VvPiHp44NHqJoJ1O6IuNR2t6Tv\n", + "2364GXuJpMUR8Z/N5Q9ExK5mbbtVtpdHxB22PxwRl4zQ169KukjShZLOlPQj299r/uxiSRdIekXS\n", + "E7bfGhGcKgQwKo5QAWglHrb8S5Leb3uNpB9KmilpYfNnq4YkU5K0zPZaSf8haZ6k88bo60pJX42G\n", + "nZIek/QWNRKuVRGxPRrXRKyVNL/C7wTgDYAjVABa3Uci4pGhK5rXWu0ftvx2SZdFxEHbj0rqGaPd\n", + "0OsTuMGjV31D1h0W35UAxsARKgCtZK+koReQf1fSh2x3SpLtRbYnj/C+aZJ2NZOpn5d02ZCf9Q++\n", + "f5jHJd3cvE7rTElXSVql1ydZADAm/q8LQCsYPDK0TtLh5qm7+yR9Xo3TbU/btqSdkn6lGT/0FuWH\n", + "JP2+7fWSNqpx2m/QFyU9Y/upiHjf4Psi4p9sX97sMyTdHhE7bZ8/rG2NsAwAx+CxCQAAABVxyg8A\n", + "AKAiEioAAICKSKgAAAAqIqECAACoiIQKAACgIhIqAACAikioAAAAKiKhAgAAqOj/AWRdweAmqSyC\n", + "AAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAI0AAACPCAYAAADHlliuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAGLBJREFUeJztnVtsY+tVx3+ft+/29i224yQzk+lp+9AHpNOX8lAq+lBV\n", + "p0Jq4YWqEgKVUvEABQESbXmgBV5KJSoED0ioLeKmFgQqKi/QVgKpPHA5qKcXzqVnTjOTjJ2L49jx\n", + "/f7xYK9vtj3JnLHjTOxk/6WtOJ5k5zv1v+tb31r/9d9Ka40LF7PAc9ULcLF6cEnjYma4pHExM1zS\n", + "uJgZLmlczAyXNC5mxtykUUq9oJR6VSn1ulLqk4tclIvlhpqnTqOUsoDXgPcBeeB/gI9orV9Z7PJc\n", + "LCPmjTTvAu5pre9rrXvAV4EPLW5ZLpYZ3jl/bwvYc3z/EPhx5w8opdxS84pDa63Oen/eSOMS4gZj\n", + "XtLkgduO728zijYubgDmJc2LwNuVUneVUn7gw8DXF7csF8uMuXIarXVfKfWrwL8CFvAl9+R0czDX\n", + "kfupbuwmwiuPRSfCLm4wXNK4mBkuaVzMDJc0LmaGSxoXM8MljYuZ4ZLGxcxwSeNiZrikcTEzXNK4\n", + "mBkuaVzMjHlFWAAope4DVWAA9LTW71rEolwsNy5EGkZirPdqrU8WsRgXq4FFbE9ndkJdXF9clDQa\n", + "+JZS6kWl1McXsSAXy4+Lbk/v1lrvK6UywDeVUq9qrb+9iIU9ayj1KGBaloXH48Hj8WBZlvl3+ZnB\n", + "YGCufr9/Jeu9SlyINFrr/fHXolLqa4xGW1aONEIIpRSWZREOh4lEIkQiEcLhMJZl4fV6sSwLy7I4\n", + "PT01V7VaRYRsN8XrZ27SKKXCgKW1rimlIsD7gd9b2MqeIZRSJrJ4vV5s22ZtbY21tTVSqRR+v99c\n", + "Pp+PQqFAoVBgOBxSq9WAEWGUUjeCOBeJNOvA18Yh2wv8rdb6GwtZ1TOGkEYiim3bZDIZtra22Nzc\n", + "JBQKmSsQCBAOhxkOh1SrVTweD8PhEHAjzZtCa70DPL/AtTwzeDwesx15PB4TQXw+H6FQiHQ6zcbG\n", + "Bnfu3OHOnTtmuwqHwwSDQdrtNuVymXw+j8fjmSDLTSDORRPhlYNSCr/fTyAQIBAIEAwGsW2baDSK\n", + "bdvEYjE2NjbY2Nhgc3OTXC5nfi4QCOD3+4lEIoRCIfx+v0mUh8Mhg8Hgiv/rng1uJGkCgcAESdLp\n", + "NOl0mrW1NfNVrmQyaaKQz+fDsiyi0aghjdc7+p9QcpqbgBtJGr/fTzQaJZVKsba2xq1bt9ja2mJr\n", + "a4uNjQ0TeeSSJFm2NSFNIBDAsiyGw+FEbnPdcWNII1HAsixCoRDxeHwid9ne3mZ7e5vbt2+brUu2\n", + "IyeGwyHRaNQcySORCJ1Oh06nAzCxRV3X/OZGkMZZrAsEAsTjcbLZrEl0c7kcmUyGWCxGMBjE5/Ph\n", + "9XrP3G6UUoRCIVKpFFtbW7ztbW8z9ZrT01OGwyHD4RCttfl63XDtSTN9nA4GgyQSCdbX17lz5w5v\n", + "fetbSSaTpFIpYrGY2XKEaGchHA6bba3VanFwcMDR0RHD4ZBWq2WqxcC1TI6vPWkAU7Tz+/0Eg0ET\n", + "aW7fvs1zzz1njtORSIRAIGCIdl5i64w0Wmt8Ph9aa1qtFicno4a/1vpaRhm4AaSR1oAQJhqNkkgk\n", + "yGQybG5ucvv2bbMdyVfBeR96KBQimUzS7/fx+XwMBgM6nQ71ep1yuUyn06Hb7dLr9UyVWK7rkCzf\n", + "CNJI4huPx8lkMmSzWRKJBOFw2ByjLct6qiOzUgqfz0ckEqHf7+PxeOh2u+Yovra2Rr1eN1etVqPd\n", + "bpur0+msfAX52pPG4/GYPCabzbKxsWFIEwqF8Hq9E8dpwZM+UCnwyfHd4/EQiURYW1tjc3OTk5MT\n", + "SqWS+epMlHu93sT9V5E4N4I0oVDIJL+3bt0im80Sj8cJh8OGNE7pw5tBIo3Ue4QwzWaTRqPBwcEB\n", + "hUKBg4MD03qQiFSv11eaMPAUpFFKfRn4KeBIa/1j4/dSwN8B28B94Ge11pVLXOfMEAJMk2Zra4t0\n", + "Ok08HjeRxonztg65n2xP0qcCiMViRlszGAxIpVKmACjbXq/Xo1armWKg3GsVifM0keYvgD8F/srx\n", + "3qeAb2qtPz82nv7U+LpyOGUOQhjbtkkmk2QyGdbX10kmk0SjUXw+HzApqhoMBqbWInUWIYkky+f9\n", + "TelDhcNhEokEnU4HrTX9fp9ms0m5XDYnrcFgsJKEgacgjdb620qpu1NvfxD4yfHrvwT+nSUhDTw6\n", + "YktdRk5M6XSa9fV1YrEYkUjEfID9fp9er0e326Xb7T5GoGAwaKQRTyKNvJbIJoQTwsjfFMIMh8OV\n", + "jDbz5jTrWuvD8etDRtqapYB8gFKXOSvSCAmckabb7dJqtWi32/R6PUOkwWCAbdtmWzrvb8KjynM4\n", + "HDaEiUQiVCoVDg8PDWn6/b4hzSoW/y6cCGut9bL561mWhc/nIxAIEAqFiEajxONx1tbWyGQyZiuR\n", + "JmO326XZbFKv12k0GqbG0u12TZ4ipAmFQhP5jTN3EkiuJEf9YrFIPp/Htm1CoZDJaVaRMDA/aQ6V\n", + "Ujmt9YFSagM4WuSiLgKlFF6v1yjsRPsiPSUhSr/fN1+Pjo4oFosUi0VKpZIhivxMKpUyHfFUKkUw\n", + "GDTRSk5GTiLKa5/Ph1KKeDxOLpfjueeeo9PpcHx8TKVSoVwuUy6XJ7arVdiq5iXN14FfAP5w/PWf\n", + "FraiC8JZAZYoEw6HCQQCppDX7/fpdrt0Oh2azSb7+/vs7u7y4MED8vn8RMMRMDob0dokEglzxePx\n", + "iQanHN8lKfZ4PMRiMXK5HO12G4/HQz6fJ5/Po7U2kW2Vos/THLm/wijpTSul9oDfBT4H/L1S6mOM\n", + "j9yXuchZcVakEdJIpOl0OjQaDU5PT9nf3+eNN97gtdde44033jD3ke0nk8lMXOvr67TbbWBU6JPo\n", + "IMdrIY5IQSXSeDweotEowWDQEKZYLJqItyri9Kc5PX3knH9634LXshBMRxqnNFMKedO9okKhwM7O\n", + "Dq+88govv/zyxJHd6/VSKpVMhVd6SwDBYJBYLGYIIomycyQGwLZt4FHPajAYUKvVODw8xOfz0ev1\n", + "VqovdS0rws4PbfrSWtNutzk9PeXo6Ij9/X1KpRK1Wo1ut2vuIQ3GwWBAu92mVqvh9XoZDodEIhFi\n", + "sRipVIpWqzVxWnPKPqdfO+s/sgU6r1XBtSQNPCLOdItgOBzSbrepVCocHR2Rz+cpFosTpJEPUP6f\n", + "L6SR343FYiSTSWq1Gs1m0xDmrEgx3eGeLh5Ok2cVcC1J4yTMWY3IVqtlIk0+n+f4+PjcSKO1Np1p\n", + "IU8qlSKbzVKv12m1WuZoL0nstMh8Oso4ibNqhIEbQhoncYQE1WqVYrHI/v4+Jycn1Ov1xyKNvBZZ\n", + "g9x7fX2dSqVCvV6n3W6buo6QYLrx+WaRxkmeVcC1I43ogG3bJpVKkclkTEdbElWfz0c4HCYej5NK\n", + "pcxJarp5eRamE23bts2R/jxNjiTezWaTWq1mIpS0LJz1mVUgzrWzT3OOqEjrQARXUksR0kgya9s2\n", + "wWDwqUgDk0d65wyU1GZg8sOXNkWz2aRardJoNAxppIC4KoU9uIakebNII6RyRppYLHamTOI8SKQJ\n", + "h8MTkea833+zSCMV4VUhzbXbnpwTlKlUymhnzoo08XjcFNjO62BP3xsmI41t26YG5Iw0TjgjTa1W\n", + "o9FomFxItqdVwrUjjSS6tVqNk5MTisUiXq/XkAQe/9BFfRcOh40fjfNyjuX6/X62t7dZX1/Htu0J\n", + "5Z9UdqeP+9LtTqVS9Ho96vU6p6enlEolIpEI7XbbJMnXoo2wapAWQb1e5+TkxESZeDxupgPOIo2T\n", + "OE4vGtmG5IpEIty9e5dsNott22bLk7+ttZ44sTlzLPn71WqVUqlkdD2A0Q6vQm5z7UijtTZa3HK5\n", + "TDQaNUP+EgWENDJS6yRMJBIxXWzpZMskg1zb29uGNF6vd6LWMhgMJpqVgCGNbJ3lcpnDw0NisZjx\n", + "upFIJeRZZsyrEf4s8EtAcfxjn9Za/8tlLXIWSKSR7SkYDJJOp2k2m+YDEUWfCK1s256wS3POaUej\n", + "UdPdzmQyrK2tkc1mzRiviKokNxEPPmfj0e/3G8LEYjFKpRKpVIp4PG5GYQaDwcSc1DJjXo2wBr6g\n", + "tf7CpazqAtBa0+v1aLVaVKtVwuEwtVpt4rQCj4gzGAzIZrO0Wi2jfXFqZSTSiAwiHo8TjUaxLItO\n", + "p0OlUqHRaBgBV71eNxYmcsm6JMqJhlgG9iSRlrHeZce8GmFYUv9g2Z6azSaWZREIBEyPqNPpGBWe\n", + "kMbj8ZDL5bAsC9u2zYco+Ywzp5FIJCKrTqdDv9/n+PjYXKVSiWw2Sy6XI5fLTRg8yu8JEcWiTeQa\n", + "Qtxlx0Vymk8opX6e0YPdf2tZRlickQZG1V8hjUQaIY3kNqJzyWazhmxnnZ6ETGItIuO3+/v7PHz4\n", + "kHw+z97eHnfv3qXb7eL1eo2pgAzVOWWg6XSaRqNhphUqlcq1Js2fAb8/fv0HwB8BH1vIii4IIQ2M\n", + "TiQej+ex7UmIIKSIRqNn5hHy3vQHWalU6Pf7Znva399nZ2eHe/fu8frrr9NqtYzhYy6Xm2g9OI//\n", + "mUyGfr9vuu7BYPD6kkZrbTTBSqkvAv+8sBUtAE6Vv3ywBwcH7OzsmGqx2KfJeO20cAoekUakofK1\n", + "WCxyfHxsvu7u7pLP5ymVSjQaDWq1mtEAHx8fG1WeRBnZGm3bpt1uk0gkzFpkAM/ZzFw2zEUapdSG\n", + "GE8DPwN8f3FLujjk6Asj0oikU2oi2WyWbDZr5rzPklAA5hgspzG59vf32d/fN6O3Qp6TkxMzmlut\n", + "Vg1pJNKEQqEJ8ti2Tb/fJx6Pm5qNTCv0+31DtmU7Tc2jEf4M8F6l1POMTlE7wC9f6ipngFOGIElx\n", + "pVKhUCiglKLT6ZiEMxKJkEgkzO86db1OiJRCEt3d3V329vbY3d3l4cOHxiFCGpFS8T05OeH4+Bif\n", + "z0cwGDTSC/leZKASaaT5KfUkGeRbNsyrEf7yJaxlYZgO6ZVKBY/HYyrF4vKQyWRMYuyMMtO1Eok0\n", + "x8fHFAoFHjx4wM7ODj/60Y/Y2dl5bKy3Xq9PRBqJKs46kWxDXq+XRCIxEWm63a4hzDLWba5dRXga\n", + "Em0ajYbZggqFgnG9krFb8QkOBAKPVXjz+TwPHz5kb2+PfD5PoVCYUPtNC6mcGmSZgJBBu0gkYo7Y\n", + "sj1KR15cLYLBIJXK6DAqIvZlwo0gjfMIrrXm4OCAQCAAQKvVeqz/5ExC+/0+e3t7Zjva29vj+PiY\n", + "crlMq9U6U3kneZTMWEm9SPQ3Mrgnx3jpyOdyOer1uulndbtdqtXq0jUxbwxpADNqK4SRXCWZTJor\n", + "Ho9PbDW9Xo+9vT0ePHjAgwcP2N3dNflLs9mc0AULhDTS0ZYoI+PB0j6Q0WFx0Go0Gmat3W6XWq12\n", + "rlnkVeLGkEb6Os1mE3iUp0gFN5PJmERWTi4inpIoc//+fXZ3d41BgKjuptFut+n3+9TrdSzLMltQ\n", + "IpEglUpNmAn4/X6zPckaJcIcHR25pLkqTOtvJSFWSpmI0m63jZzCaVDU7/cpFApmzEW0L0+qoUgS\n", + "K/UikXmWy2WKxeLE6clpLGDbNp1Ox0QikaBalrVUUws3gjTTcOY4MtctUoqzchoZ1G80GhPD+ufB\n", + "SVJxpWg0GoY0slXJKUlyHul4y0nKaYQ9PblwlbhxpHHmOFLCbzQaVCoV06CcHnBrNpu0Wi1jLC33\n", + "edKH5zQtkshWqVQoFotG0O4kjUg1gMdII/qcqyaL4MaSpt/vmyLfWW2E6dmnWQbbztoOncRMpVJm\n", + "zkoqxJKcS89KSON80suytBRuHGng2buJ93o908X2eDxG8F4qlSZ8+JRSxu7NacJkWRbNZtOc1q46\n", + "4txI0jxr9Ho9U1wcDAYkk8mJZ0qJvaxTvyMegZubm3i9XsrlsikcXnXEcUnzDCCRZjAY0Gq1SCQS\n", + "Ew8kSyaTRm8sxtYindjc3DTbo5giXTWeSBql1G1GMs8so+bkn2ut/0StgI/wMkEMH9vtNkopQxq5\n", + "pM0gNrXSSJXaUa/XM62JpScN0AN+Q2v9klIqCvyvUuqbwEdZUh/hZYTTNUIKjKenp+YkJbUaEYP5\n", + "/X5isZgRaUmJQH7nqo0DnkgarfUBcDB+XVdKvQJsseQ+wsuMadcKsXULh8PGJcvn8xmtjc/nMxXi\n", + "4+NjU0cSMl2FdOKpc5qxuPydwH+xxD7CywqndNRJGq21sVVrNpuGKDKIF4vFaLValEolIyTrdrtG\n", + "IHYVp6mnIs14a/pH4Ne11rUpSeTS+QgvM5yRBjDOWrlcziTL0mIQkVa9Xufg4IBEIkEkEqHVak3o\n", + "bZ41nka552NEmL/WWov169L6CK8CJCkWXY0o/A4PDzk4ODDP0pRLbPqz2Sybm5tYlmUmF8RMSfAs\n", + "os6bnZ4U8CXgZa31Hzv+aWl9hFcBIrmQmou0FwqFghltEZ9iEYbF43HW19fZ3t424zeDwWCiH/as\n", + "tqk3izTvBn4O+J5S6jvj9z7NkvsILzvEekRmt8U0Umzw5d/kFOX3+w1pxMZNCHNycjJhKXvlkUZr\n", + "/R+cb3y0lD7CqwAhi+hnJNLIeIvMfcfjcbTWE5EGMHKLUqlkrE7kOP8sNMVuRfgKML2VtNttYz/i\n", + "NFxKp9NGIyzmAVprI9ByRqYnicIWDZc0SwBpM5TLZfMshXQ6TbVapdlsmnHeaDRq+lCJRMI890Eq\n", + "zSKEdyPNDcB0QzORSFAul80MumxbYkAgNiUSaeRZCzKOc9lwSbMEENKIEUAymaRSqRjS+P1+YyIQ\n", + "CAQ4OTkxA3bhcNicoJ6VIZJLmiWAJMYSLZxu6rFYjPX1dRKJBMlk0kQbeVpeNptlMBiYKOVUF14W\n", + "XNIsAeS4LB92tVo1s1n9fp/T01Nu3bqFZVnGfcu2bTKZDLdu3QIetSdOT08vfb0uaZYAzsc6D4dD\n", + "arUaBwcH5hE/nU7HJMgbGxtm7CWdTlOv143tSbVaPdeWdpFwSbMEmJZOyFSlPBNKa21cupxd8HQ6\n", + "Ta/Xm2iAPgu9jUuaJYFTjC7uEiJ+Fy1xtVo1BgZyBM9kMqZuIyO/Z82XLxIuaZYQkhDLtEKr1TKe\n", + "N+KYpbUmGAySTCYnjuAinZBin3jcLBIuaZYQTp2MzF2JfUmlUjFqv2AwaOo2TjetdrtNp9O5NH+b\n", + "J26ASqnbSql/U0r9n1LqB0qpXxu//1ml1EOl1HfG1wsLX9kNhnzYkq9MR5pms2kijcyHT7tpybzU\n", + "ZRT75tUIL62P8HXA9LBdq9UyvoGJRIJut0s6nTZ5jbhPSOSRaU1R+C0a82qEYUl9hK8j2u02pVKJ\n", + "vb09AOOJLM6kcuqSSc1AIGD+/SoijYFDI/yfjHQ2S+kjfB0hpNH60cPfPR6PKfBNG2o7H1x/GaR5\n", + "qkP9eGv6B0Ya4TojH+G3AM8D+4x8hF1cEuTYvbe3x6uvvsq9e/coFArmGeESacTCxGkccCWRxqER\n", + "/hvRCOsl9xG+bpB6jViWHB0dUSgUWFtbIx6P02q1ODo6olKpPPaYw8uQScylEV52H+HrCKcnTrVa\n", + "pVAo4Pf7zfH66OiIYrHI4eGheU6mRKFFYx6N8O8AH1lWH+HrCCdhtNbUajUKhQKdTsc4oosxdrVa\n", + "NY+EluLgoqEuS+XlzkItFs7cxPmEGL/fP+Fw7nz21EWds7TWZyZELmlcnIvzSHP1FgQuVg4uaVzM\n", + "DJc0LmaGSxoXM8MljYuZ4ZLGxcy4tCO3i+sLN9K4mBkuaVzMjEsljVLqBaXUq0qp18cuoBe9332l\n", + "1PfGEtP/nuP3v6yUOlRKfd/xXkop9U2l1A+VUt9QSiWedI+nuN/cUtgnyGvnWuOlyXWdfv+LvAAL\n", + "uAfcBXzAS8A7LnjPHSB1gd9/DyMh2fcd730e+O3x608Cn7vg/T4D/Oac68sBz49fR4HXgHfMu8Yn\n", + "3G/uNWqtLzXSvAu4p7W+r7XuAV8FPrSA+86tKtJafxsoT739QUa2toy//vQF7wdzrlFrfaC1fmn8\n", + "ug44LXhnXuMT7jf3GuFyt6ctYM/x/UMeLXheaOBbSqkXlVIfv+C9BJdhb/sJpdR3lVJfmmW7c2LR\n", + "FrxTct0LrfEySXMZZ/l3a63fCXwA+BWl1HsWeXM9iuMXXfeFpbDTFrwXXeOi5bqXSZo8cNvx/W1G\n", + "0WZu6LFaUGtdBL7GaAu8KA6VUjkYKRK5oL2t1vpIjwF8cdY1PsmCd541nifXvcgaL5M0LwJvV0rd\n", + "VUr5gQ8zspKdC0qpsFLKHr+OAO9nMTJTsbeFBdjbjj9UwUxS2Kew4J1pjU+S6867RuDyTk/jjP0D\n", + "jDL2e8CnL3ivtzA6gb0E/GCe+wFfAQpAl1G+9VEgBXwL+CHwDSBxgfv9IqOn1nwP+O74w12f4X4/\n", + "AQzH/43fGV8vzLvGc+73gYusUWvtthFczA63IuxiZrikcTEzXNK4mBkuaVzMDJc0LmaGSxoXM8Ml\n", + "jYuZ4ZLGxcz4f041SDwzkyB1AAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAEfRJREFUeJzt3X2w3NVdx/HPJ/fm5uaZPJFAckNAg4ZMK2ALhFJopDoI\n", + "hVatpVFbrE4dp62N2DKlzOhfOq1lHGinozMVpIU+oNBK21EoqEgpFdJAQoCkhGQIJkQSIzdpbsjD\n", + "TfL1j90Ly+U+nJMf5+5u8n7NZNjf7nd/5+zv/O7ul9/D+ToiBAAAgGM3rtkdAAAAaHckVAAAABWR\n", + "UAEAAFREQgUAAFARCRUAAEBFJFQAAAAVdTazcdvM2QAAANpGRHio54smVLYvk3SzpA5Jt0TEXw+O\n", + "mTt37hve19fXpylTpgxeV3K7uXNrHTlyJDn28OHDRfpx9OjR5NgcudsiJ3642EOHDqmrq+t1z+V8\n", + "vpzYZny+Vo0FADRPsVN+tjskfVnSZZLOkrTC9pJS7QEAADRLyWuozpO0KSK2RES/pDslvbdgewAA\n", + "AE1RMqGaL2lrw/K2+nOjGny6CO2lo6Oj2V0AAGBMlUyojvniDxKq9kZCBQA40ZS8KP1FST0Nyz2q\n", + "HaV6nb6+vlcfd3V1kUwBAIC2UzKhWi1pse1FkrZLulrSisFBg+/mAwAAaDfFEqqIOGz7E5J+oNq0\n", + "CbdGxIZS7QEAADRL0XmoIuJeSfeWbAMAAKDZmjpTuiTNmzcvKS5n8s3+/v6sPuTEl5rYM0fJCUNz\n", + "Pl/OdssZv5zY3M/XChNllhq/3G1RcgJVADjRUMsPAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAA\n", + "oCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqcjNrdNmO6dOnJ8VOmDAheb3d\n", + "3d1Z/Zg0aVKRdY8bl56v5tTQ27dvX3LsgQMHkmMlaf/+/cmxhw4dSo7N+Xwla8yV2t9tF4ktWbeR\n", + "Wn4AkC8ihvwSL3qEynaP7QdtP2P7adufLNkeAABAM3QWXn+/pGsjYq3tKZIet/1ARGwo3C4AAMCY\n", + "KXqEKiJeioi19cd9kjZIOrVkmwAAAGNtzC5Kt71I0jmSHhurNgEAAMbCmCRU9dN9d0taWT9SBQAA\n", + "cNwofQ2VbI+X9G1JX4+Iewa/3ngXWmdnpzo7i3cJAADgTVU0e3Ht/vBbJa2PiJuHismd4gAAAKDV\n", + "lD7l9w5Jvydpue019X+XFW4TAABgTBU9QhURPxKzsQMAgOMcyQ4AAEBFTS8909PTkxRbsgTHkSNH\n", + "kmNzSqjk9LlUbEk527mjoyM5NqdkT856c9ddqkRMzj6Us2/29/cnx+auO/dvKlXONs7pQ842zl13\n", + "KTn75vjx47PWnVO6q6urKzk2Zx/KKVWVUwKrFcaulZQqg1VKO/72NaX0DAAAwImAhAoAAKAiEioA\n", + "AICKSKgAAAAqIqECAACoiIQKAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAAoKKixZFTpJaIyCkx\n", + "klM6QZK6u7uTYzs7y2yyUqVLcuWUIsjpR852y4mdNGlScqwkTZ48OTk2Z7/Iic3p8/bt25Njt27d\n", + "mhwrSb29vcmxOWVtcj7fokWLkmPPPvvs5Nic8ZCkzZs3J8euW7cuOTan5EvO57v00kuTY6Vy5Y5e\n", + "fvnl5Nhnn302OXbjxo3JsYsXL06OlfL2uRkzZiTH7t27Nzk2Z397/vnnk2Olct9bOd8BU6dOTY6d\n", + "N29ecmzOeEh5n2/37t1JcTfddNOwrw37y2X7tySFpKF+YSMivpPSuO0OSaslbYuIK1PeAwAA0E5G\n", + "OhRwpWoJ1XCSEipJKyWtl5SesgIAALSRYROqiPj9qiu3vUDS5ZL+StKfVV0fAABAKxr1onTb82zf\n", + "avu++vJZtv8wcf03SbpO0tEKfQQAAGhpKXf5fVXS/ZJOrS8/J+na0d5k+z2SdkbEGg19HRYAAMBx\n", + "IeV2qtkR8Y+2r5ekiOi3nXLLyIWSrrJ9uaRuSdNs3x4RH24MarwzoqurK+uuGAAAgFK2bt2qbdu2\n", + "JcWmJFR9tmcNLNi+QNKe0d4UETdIuqH+nkskfXpwMiXl3V4JAAAwVnp6etTT0/Pq8qOPPjpsbEpC\n", + "9SlJ35d0hu0fS5oj6f3H0K/0iZYAAADayKgJVUQ8bvtiSb+g2rVQz0ZE+gxftXU8JOmhY+siAABA\n", + "axs1obI9UdLHJF2k2lGmh23/XUQcKN05AACAdpByyu92ST+T9CXVjlD9jqQ7JP12wX4BAAC0DY9W\n", + "Q872+og4a7TnjqlxOxYsWJAUm1Prbty4vJrPOevOkVMXr1StwvHjxyfH5vYjZzvnxObWYsyR04+c\n", + "mmYHDx5Mjs2piTVlypTk2NyxzqlreNpppyXH5ozfli1bisTm1jXcv39/cuzRo+nT6uWMydy5c5Nj\n", + "p02blhwr5dU0y/kbybkrO2e9OTUCd+3alRwrSX19fcmxOX/Xhw4dSo7N+c0p9ftUUs5vX6nfESmv\n", + "Lmzqb19fX58iYsgPmNK7J2wvG1io3+X3eFLLAAAAJ4CRiiM/1RDziO2tql1DtVBSetlwAACA49xo\n", + "xZEBAAAwipGKI29pXLZ9smozngMAAKBBSnHkq2w/J+l51eaS2iLp3sL9AgAAaBspF6X/paRlkjZG\n", + "xOmSLpX0WNFeAQAAtJGUhKo/InZJGme7IyIelPS2wv0CAABoGymTNPTanirpYUnfsL1TUvpEHgAA\n", + "AMe5lCNU75P0iqRrJd0naZO4AxAAAOBVKcWRB45GHZH01aK9AQAAaEPDlp6x3afaRJ5DiYjIq30w\n", + "dBuxcOHCpNiS09PnlJLIKUdSqmRAq0zVnxNbqs+5ny+nPESOw4cPF+lDzr6ZU+5ByisRM2vWrOTY\n", + "6dOnJ8fmbLcdO3Ykx/b29ibH5sbn9LlU+alcOf3I+Y7L2T9bpdxKzrpz/6ZK9KGV1l1CqW1cSkQM\n", + "W3pmpHmo0ouIDcP2SZJukbRUteTsDyLi0arrBQAAaCXphxiOzRcl/WtEvN92p6T0aqwAAABtolhC\n", + "ZXu6pHdGxDWSFBGHJe0p1R4AAECz5F2Akud0Sf9r+zbbT9j+e9uTCrYHAADQFCUTqk5J50r624g4\n", + "V9I+SdcXbA8AAKApSl5DtU3Stoj4SX35bg2RUO3evfvVx93d3erupv4yAABovpy7JoslVBHxku2t\n", + "ts+MiI2S3i3pmcFxJ510UqkuAAAAHLPB0zqMlGCVvsvvT1QrV9MlabOkjxRuDwAAYMwVTagi4klJ\n", + "by/ZBgAAQLOVvCgdAADghDBs6ZkxadyOpUuXJsUePHgweb39/f1Z/cgpJVGq1EKOnHIrueUscku5\n", + "pMrZFjl9yCl/kyunRMz+/fuTY/v6+kYPqsvZl3P3t1KlQHJKSZQqM5RbziLn87VC+al2VGpbtOM2\n", + "bpVyKzn9aIWSPSWlfr6RSs9whAoAAKAiEioAAICKSKgAAAAqIqECAACoiIQKAACgIhIqAACAikio\n", + "AAAAKiKhAgAAqIiECgAAoCISKgAAgIqKFkdOsW/fvqS4nPIwObFS+5WTKVUuQMor5TJx4sQi680p\n", + "t3LgwIHkWCmvnExOuaOcciRTp05Nju3q6kqOzS3Dk1Mu55VXXkmOzdnGOX97Odu4VAml3HVPmDAh\n", + "OXby5MnJsbmlPXJKUOXsRznftXv37k2Ozdk3c/ahY4kvoWR5rWnTpiXHLly4MDn2lFNOSY7N+V7u\n", + "7e1Njt25c2dyrFRmnxvpd6HoESrbn7X9jO2nbH/Tdvq3CwAAQJsollDZXiTpo5LOjYi3SOqQ9MFS\n", + "7QEAADRLyVN+P5PUL2mS7SOSJkl6sWB7AAAATVHsCFVEvCzpbyT9t6TtknZHxL+Vag8AAKBZSp7y\n", + "+zlJfyppkaRTJU2x/bul2gMAAGiWkqf83ibpxxHxf5Jk+zuSLpT0jcagxiv8u7u7s+4cAwAAKOXo\n", + "0aPJd4aWTKh+KunPbU+UdEDSuyWtGhw0Y8aMgl0AAAA4NuPGjXvdNBcjTd9S8hqqJyXdLmm1pHX1\n", + "p79Sqj0AAIBmKTqxZ0R8QdIXSrYBAADQbJSeAQAAqIiECgAAoKKm1/JLvXq+VC2qkuvOWW+p2k4l\n", + "61zlfL6c+m459cFy6rtJ0vjx45Njc2qrzZw5Mzk2p9bWySefnBw7f/785FhJmjVrVnLsCy+8kBy7\n", + "ffv25Nicfai7uzs5dsmSJcmxkrR8+fLk2PPPPz85dteuXcmxd955Z3LsXXfdlRwrSbt3706Ozfn7\n", + "mz17dnLssmXLkmOvuOKK5Ng9e/Ykx0p52yKnJl3Od8AZZ5yRHJtTb0/Kq3e3YcOG5NicfTmnDmpO\n", + "bM73RW78nDlzkuJWrFgx7GscoQIAAKiIhAoAAKAiEioAAICKSKgAAAAqIqECAACoiIQKAACgopZM\n", + "qHJuVUXr6evra3YXcIw2bdrU7C6ggpwpAdBaVq9e3ewuoCISKrzpSKja1+bNm5vdBVRAQtW+SKja\n", + "X0smVAAAAO2EhAoAAKAiR0TzGreb1zgAAECmiPBQzzc1oQIAADgecMoPAACgIhIqAACAilouobJ9\n", + "me2f2n7O9mea3R8Mz/Y/2N5h+6mG52bafsD2Rtv32z6pmX3E8Gz32H7Q9jO2n7b9yfrzjGGLs91t\n", + "+zHba22vt/25+vOMXRux3WF7je3v15cZvzbWUgmV7Q5JX5Z0maSzJK2wvaS5vcIIblNtrBpdL+mB\n", + "iDhT0r/Xl9Ga+iVdGxFLJV0g6eP1vzfGsMVFxAFJyyPibElvlbTc9kVi7NrNSknrJQ1czMz4tbGW\n", + "SqgknSdpU0RsiYh+SXdKem+T+4RhRMTDknoHPX2VpK/VH39N0vvGtFNIFhEvRcTa+uM+SRskzRdj\n", + "2BYi4pX6wy5JHar9LTJ2bcL2AkmXS7pF0sBdY4xfG2u1hGq+pK0Ny9vqz6F9zI2IHfXHOyTNbWZn\n", + "kMb2IknnSHpMjGFbsD3O9lrVxujBiHhGjF07uUnSdZKONjzH+LWxVkuomMPhOBK1OTkY0xZne4qk\n", + "b0taGRF7G19jDFtXRBytn/JbIOli28sHvc7YtSjb75G0MyLW6LWjU6/D+LWfVkuoXpTU07Dco9pR\n", + "KrSPHbbnSZLtUyTtbHJ/MALb41VLpu6IiHvqTzOGbSQi9kj6F0m/LMauXVwo6Srbz0v6lqRfsX2H\n", + "GL+21moJ1WpJi20vst0l6WpJ32tyn5Dne5KuqT++RtI9I8SiiWxb0q2S1kfEzQ0vMYYtzvbsgTvA\n", + "bE+U9KuS1oixawsRcUNE9ETE6ZI+KOk/IuJDYvzaWsvNlG771yXdrNpFlrdGxOea3CUMw/a3JF0i\n", + "abZq5/v/QtJ3Jf2TpIWStkj6QETsblYfMbz6XWE/lLROr51a+KykVWIMW5rtt6h20fK4+r87IuJG\n", + "2zPF2LUV25dI+lREXMX4tbeWS6gAAADaTaud8gMAAGg7JFQAAAAVkVABAABUREIFAABQEQkVAABA\n", + "RSRUAAAAFZFQAWg624/U/3ua7RVv8rpvGKotAHgzMQ8VgJZh+12qTXJ4ZcZ7OiPi8Aiv742IqW9G\n", + "/wBgOByhAtB0tvvqDz8v6Z2219heaXuc7Rttr7L9pO0/qse/y/bDtr8r6en6c/fYXm37adsfrT/3\n", + "eUkT6+u7o7Et19xo+ynb62x/oGHd/2n7LtsbbH99bLcGgHbU2ewOAIBeK33zGUmfHjhCVU+gdkfE\n", + "ebYnSPqR7fvrsedIWhoRL9SXPxIRvfXadqts3x0R19v+eEScM0RbvynplyS9VdIcST+x/cP6a2dL\n", + "OkvS/0h6xPY7IoJThQCGxREqAK3Eg5Z/TdKHba+R9KikmZJ+vv7aqoZkSpJW2l4r6b8k9UhaPEpb\n", + "F0n6ZtTslPSQpLerlnCtiojtUbsmYq2kRRU+E4ATAEeoALS6T0TEA41P1K+12jdo+VJJF0TEAdsP\n", + "SuoeZb2hNyZwA0evDjY8d0R8VwIYBUeoALSSvZIaLyD/gaSP2e6UJNtn2p40xPumSeqtJ1O/KOmC\n", + "htf6B94/yMOSrq5fpzVH0sWSVumNSRYAjIr/6wLQCgaODD0p6Uj91N1tkr6k2um2J2xb0k5Jv1GP\n", + "b7xF+T5Jf2x7vaRnVTvtN+ArktbZfjwiPjTwvoj4Z9vL6m2GpOsiYqftJYPWrSGWAeB1mDYBAACg\n", + "Ik75AQAAVERCBQAAUBEJFQAAQEUkVAAAABWRUAEAAFREQgUAAFARCRUAAEBFJFQAAAAV/T+uJdIF\n", + "H1NcrQAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i in range(8):\n", + " figure(figsize=(2, 2))\n", + " imshow(solver.test_nets[0].blobs['data'].data[i, 0], cmap='gray')\n", + " figure(figsize=(10, 2))\n", + " imshow(exp(output[:50, i].T) / exp(output[:50, i].T).sum(0), interpolation='nearest', cmap='gray')\n", + " xlabel('iteration')\n", + " ylabel('label')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From b8cc2974fc557fa163187e9ce0a879d0e13833b4 Mon Sep 17 00:00:00 2001 From: Yangqing Jia Date: Tue, 17 Mar 2015 10:50:42 -0700 Subject: [PATCH 073/331] [examples] flickr fine-tuning notebook --- .../Finetune with Flickr Style Data.ipynb | 951 ++++++++++++++++++ .../finetune_flickr_style/assemble_data.py | 8 + .../finetune_flickr_style/train_val.prototxt | 1 + 3 files changed, 960 insertions(+) create mode 100644 examples/Finetune with Flickr Style Data.ipynb diff --git a/examples/Finetune with Flickr Style Data.ipynb b/examples/Finetune with Flickr Style Data.ipynb new file mode 100644 index 00000000000..d8cfc7a3925 --- /dev/null +++ b/examples/Finetune with Flickr Style Data.ipynb @@ -0,0 +1,951 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Finetune a Pretrained Network with Flickr Style Data\n", + "\n", + "In this example, we'll explore a common approach that is particularly useful in real-world applications: take a pre-trained Caffe network, and finetune the last few layers using your custom data.\n", + "\n", + "The upside of such approach is that, since pre-trained networks are trained on a large set of images, the intermediate layers capture the \"semantics\" of the general visual appearance. Think of it as a very powerful feature that you can treat as a black box. On top of that, only a few layers will be needed to obtain a very good performance of the data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we will need to prepare the data. This involves the following parts:\n", + "(1) Get the ImageNet ilsvrc pretrained model with the provided shell scripts.\n", + "(2) Download a subset of the overall Flickr style dataset for this demo.\n", + "(3) Compile the downloaded Flickr dataset into a database that Caffe can then consume." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/jiayq/Research/caffe\n" + ] + } + ], + "source": [ + "import os\n", + "os.chdir('..')\n", + "import sys\n", + "sys.path.insert(0, './python')\n", + "print os.getcwd()\n", + "\n", + "import caffe\n", + "import numpy as np\n", + "from pylab import *\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading...\n", + "--2015-03-17 10:51:07-- http://dl.caffe.berkeleyvision.org/caffe_ilsvrc12.tar.gz\n", + "Resolving dl.caffe.berkeleyvision.org (dl.caffe.berkeleyvision.org)... 169.229.222.251\n", + "Connecting to dl.caffe.berkeleyvision.org (dl.caffe.berkeleyvision.org)|169.229.222.251|:80... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 17858008 (17M) [application/octet-stream]\n", + "Saving to: ‘caffe_ilsvrc12.tar.gz’\n", + "\n", + "100%[======================================>] 17,858,008 287KB/s in 55s \n", + "\n", + "2015-03-17 10:52:02 (318 KB/s) - ‘caffe_ilsvrc12.tar.gz’ saved [17858008/17858008]\n", + "\n", + "Unzipping...\n", + "Done.\n", + "Model already exists.\n", + "Downloading 2000 images with 3 workers...\n", + "Writing train/val for 1903 successfully downloaded images.\n" + ] + } + ], + "source": [ + "# This downloads the ilsvrc auxiliary data (mean file, etc),\n", + "# and a subset of 2000 images for the style recognition task.\n", + "\n", + "# You won't need to run this - we should have already created it for you.\n", + "!data/ilsvrc12/get_ilsvrc_aux.sh\n", + "!scripts/download_model_binary.py models/bvlc_reference_caffenet\n", + "!python examples/finetune_flickr_style/assemble_data.py \\\n", + " --workers=-1 --images=2000 --seed=1701 --label=5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's show what is the difference between the finetune network and the original caffe model." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1c1\r\n", + "< name: \"CaffeNet\"\r\n", + "---\r\n", + "> name: \"FlickrStyleCaffeNet\"\r\n", + "4c4\r\n", + "< type: \"Data\"\r\n", + "---\r\n", + "> type: \"ImageData\"\r\n", + "15,26c15,19\r\n", + "< # mean pixel / channel-wise mean instead of mean image\r\n", + "< # transform_param {\r\n", + "< # crop_size: 227\r\n", + "< # mean_value: 104\r\n", + "< # mean_value: 117\r\n", + "< # mean_value: 123\r\n", + "< # mirror: true\r\n", + "< # }\r\n", + "< data_param {\r\n", + "< source: \"examples/imagenet/ilsvrc12_train_lmdb\"\r\n", + "< batch_size: 256\r\n", + "< backend: LMDB\r\n", + "---\r\n", + "> image_data_param {\r\n", + "> source: \"data/flickr_style/train.txt\"\r\n", + "> batch_size: 50\r\n", + "> new_height: 256\r\n", + "> new_width: 256\r\n", + "31c24\r\n", + "< type: \"Data\"\r\n", + "---\r\n", + "> type: \"ImageData\"\r\n", + "42,51c35,36\r\n", + "< # mean pixel / channel-wise mean instead of mean image\r\n", + "< # transform_param {\r\n", + "< # crop_size: 227\r\n", + "< # mean_value: 104\r\n", + "< # mean_value: 117\r\n", + "< # mean_value: 123\r\n", + "< # mirror: true\r\n", + "< # }\r\n", + "< data_param {\r\n", + "< source: \"examples/imagenet/ilsvrc12_val_lmdb\"\r\n", + "---\r\n", + "> image_data_param {\r\n", + "> source: \"data/flickr_style/test.txt\"\r\n", + "53c38,39\r\n", + "< backend: LMDB\r\n", + "---\r\n", + "> new_height: 256\r\n", + "> new_width: 256\r\n", + "323a310\r\n", + "> # Note that lr_mult can be set to 0 to disable any fine-tuning of this, and any other, layer\r\n", + "360c347\r\n", + "< name: \"fc8\"\r\n", + "---\r\n", + "> name: \"fc8_flickr\"\r\n", + "363c350,351\r\n", + "< top: \"fc8\"\r\n", + "---\r\n", + "> top: \"fc8_flickr\"\r\n", + "> # lr_mult is set to higher than for other layers, because this layer is starting from random while the others are already trained\r\n", + "365c353\r\n", + "< lr_mult: 1\r\n", + "---\r\n", + "> lr_mult: 10\r\n", + "369c357\r\n", + "< lr_mult: 2\r\n", + "---\r\n", + "> lr_mult: 20\r\n", + "373c361\r\n", + "< num_output: 1000\r\n", + "---\r\n", + "> num_output: 20\r\n", + "384a373,379\r\n", + "> name: \"loss\"\r\n", + "> type: \"SoftmaxWithLoss\"\r\n", + "> bottom: \"fc8_flickr\"\r\n", + "> bottom: \"label\"\r\n", + "> top: \"loss\"\r\n", + "> }\r\n", + "> layer {\r\n", + "387c382\r\n", + "< bottom: \"fc8\"\r\n", + "---\r\n", + "> bottom: \"fc8_flickr\"\r\n", + "393,399d387\r\n", + "< }\r\n", + "< layer {\r\n", + "< name: \"loss\"\r\n", + "< type: \"SoftmaxWithLoss\"\r\n", + "< bottom: \"fc8\"\r\n", + "< bottom: \"label\"\r\n", + "< top: \"loss\"\r\n" + ] + } + ], + "source": [ + "!diff models/bvlc_reference_caffenet/train_val.prototxt models/finetune_flickr_style/train_val.prototxt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For your record, if you want to train the network in pure C++ tools, here is the command:\n", + "\n", + "\n", + "build/tools/caffe train \\\n", + " -solver models/finetune_flickr_style/solver.prototxt \\\n", + " -weights models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel \\\n", + " -gpu 0\n", + "\n", + "\n", + "However, we will train using Python in this example." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter 0, loss=3.786610, scratch_loss=3.163587\n", + "iter 10, loss=2.556661, scratch_loss=8.774073\n", + "iter 20, loss=2.035326, scratch_loss=2.266603\n", + "iter 30, loss=1.943101, scratch_loss=1.703273\n", + "iter 40, loss=1.982698, scratch_loss=1.831079\n", + "iter 50, loss=1.559268, scratch_loss=2.041238\n", + "iter 60, loss=1.464433, scratch_loss=1.836157\n", + "iter 70, loss=1.481868, scratch_loss=1.705826\n", + "iter 80, loss=1.394870, scratch_loss=1.695532\n", + "iter 90, loss=1.055422, scratch_loss=1.867379\n", + "iter 100, loss=1.407976, scratch_loss=1.881758\n", + "iter 110, loss=1.569579, scratch_loss=1.701803\n", + "iter 120, loss=0.951682, scratch_loss=1.764299\n", + "iter 130, loss=0.905122, scratch_loss=1.879305\n", + "iter 140, loss=1.020678, scratch_loss=1.746009\n", + "iter 150, loss=0.784985, scratch_loss=1.739624\n", + "iter 160, loss=0.911735, scratch_loss=1.673230\n", + "iter 170, loss=0.965255, scratch_loss=1.725484\n", + "iter 180, loss=1.028102, scratch_loss=1.676103\n", + "iter 190, loss=0.905020, scratch_loss=1.885763\n", + "done\n" + ] + } + ], + "source": [ + "niter = 200\n", + "# losses will also be stored in the log\n", + "train_loss = np.zeros(niter)\n", + "scratch_train_loss = np.zeros(niter)\n", + "\n", + "caffe.set_device(0)\n", + "caffe.set_mode_gpu()\n", + "# We create a solver that finetunes from a previously trained network.\n", + "solver = caffe.SGDSolver('models/finetune_flickr_style/solver.prototxt')\n", + "solver.net.copy_from('models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel')\n", + "# For reference, we also create a solver that does no finetuning.\n", + "scratch_solver = caffe.SGDSolver('models/finetune_flickr_style/solver.prototxt')\n", + "\n", + "# We run the solver for niter times, and record the training loss.\n", + "for it in range(niter):\n", + " solver.step(1) # SGD by Caffe\n", + " scratch_solver.step(1)\n", + " # store the train loss\n", + " train_loss[it] = solver.net.blobs['loss'].data\n", + " scratch_train_loss[it] = scratch_solver.net.blobs['loss'].data\n", + " if it % 10 == 0:\n", + " print 'iter %d, loss=%f, scratch_loss=%f' % (it, train_loss[it], scratch_train_loss[it])\n", + "print 'done'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's look at the training loss produced by the two training procedures respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEACAYAAABMEua6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XmYFNXVx/FvD8O+DYsCIgpiRAxE1LiiEY0LGvdEo3Eh\n", + "aoxZXkSTGJdouHE3CaAxica4IVETlATEJCohjkrcArIpohFBRFllUUAWmfv+ce4wPUP3dPV09XTT\n", + "/D7P089MV1dX3aquPnX6VNUtEBERERERERERERERERERERERERHZbjQBpgMTw3MHLArDpgODC9Ms\n", + "ERFJVh5xvGHAHKBteO6BkeEhIiJFoizCOLsCJwL3AYkwLJH0v4iIFIkoQX0UcCVQlTTMA0OBmcD9\n", + "QEX8TRMRkWxlCuonAcuwunlyZn430AsYACwGRuSldSIikpVMJZRbgPOBz4EWQDtgHHBB0jg9sQOo\n", + "/VO8/12gd86tFBHZscwD9sz3TI6k5uyXbknDrwAeTfMen9cW7VhcoRtQYlyhG1BiXKEbUGIaHDuj\n", + "nv0CltVXz+iXwL7h+Xzg0oY2QERE4pNNUK8MD7CSjIiIFJkoZ79IcagsdANKTGWhG1BiKgvdAGkc\n", + "qqmLiGSvwbFTmbqISAlRUBcRKSEK6iIiJaQwQd3RpiDzFREpcY0f1B2tsHPbRUQkZoXI1FsCnXE0\n", + "K8C8RURKWiGCenUwb1eAeYuIlDQFdRGRElLIoN6+APMWESlpytRFREqIgrqISAlR+UVEpIQoUxcR\n", + "KSGFCOrNw18FdRGRmEUN6k2wm09X386uIzAJeAd4FqjIYp4qv4iI5EnUoD4MmENNH79XY0F9L2By\n", + "eB6Vyi8iInkSJajvCpwI3IfdpxTgFGB0+H80cFoW81RQFxHJkyhBfRRwJVCVNKwLsDT8vzQ8j6oZ\n", + "sA6VX0REYpfpxtMnAcuwevqgNON46r/1kkv6vxIL6stRpi4iUm0Q6WNsVjIF9cOwUsuJQAssEI/B\n", + "svOuwBKgGxb403F1nu8NrEBBXUSkWiW1b949vKETylR+uRboAfQCzgb+DZwPPAkMCeMMAcZnMc/q\n", + "TF3lFxGRmGV7nnp1meU24FjslMajw/OoVH4REcmTTOWXZM+HB8BK4JgGzrM5Kr+IiORFoboJ+BQA\n", + "R4sCzF9EpGQVKqhvAj5B2bqISKwKGdTXoKAuIhKrQmfqOgNGRCRGhQ7qytRFRGJUqKC+ESu/KFMX\n", + "EYmRMnURkRKioC4iUkIKdeej6rNfVH4REYmRMnURkRKioC4iUkIKGdQ/BdoWYP4iIiWrkEF9A1Zf\n", + "FxGRmBTyPPUNoA69RETiVMhMfSMK6iIisSp0+UVBXUQkRlGCegvgVWAGMAe4NQx3wCLsptTTgcER\n", + "56mauohInkS589EG4ChgfRh/CnA4dmu7keGRjeqLj5Spi4jELGr5ZX342wxoAqwKzxMNmKdq6iIi\n", + "eRI1qJdh5ZelwHPAm2H4UGAmcD9QEXFaqqmLiORJ1BtPVwEDsL5angEGAXcDN4TXbwRGABeneK9L\n", + "+r8S1dRFROoaFB45a0j55HrgM+DXScN6AhOB/nXG9bXm4SgDtmCZfztgIU6deomI1FE7dmYhSvml\n", + "MzWllZbAsdjZLl2TxjkdmB1hWk2BTTg8qqmLiMQuSvmlGzAa2wGUAWOAycDDWEnGA/OBSyNMq7r0\n", + "AhbUm+Eow1GVZbtFRCSFKEF9NrB/iuEXNGB+NUHd4XEhsFt9XUREctTYV5QmZ+qgM2BERGLV2EG9\n", + "+sKjagrqIiIxKnSmroOlIiIxKnRQ17nqIiIxKoagrkxdRCQmhQjqG5OeK6iLiMSo0Jn6RlR+ERGJ\n", + "TaGDujJ1EZEYKaiLiJQQnacuIlJCCp2pq6YuIhKjQgd1ZeoiIjFSUBcRKSE6T11EpIQUOlNXTV1E\n", + "JEaFDurK1EVEYpQpqLcAXgVmAHOAW8PwjsAk4B3gWWpud5eJgrqISB5lCuobgKOw29Z9Kfx/OHA1\n", + "FtT3wm5td3XE+Smoi4jkUZTyy/rwtxnQBFgFnILdt5Tw97SI86t78ZFq6iIiMYoS1Muw8stS4Dng\n", + "TaBLeE742yXi/JSpi4jkUZQbT1dh5Zf2wDNYCSaZD4903Nb/ZtKLfZmf9JqCuogIDAqPnEUJ6tXW\n", + "AH8HDsCy867AEqAbsKye97mt/+3LvWx7nrrKLyKyo6sMj2rDGzqhTOWXztSc2dISOBaYDjwJDAnD\n", + "hwDjI85P9ygVEcmjTJl6N+xAaFl4jMHOdpkOjAUuBhYAZ0Wcn2rqIiJ5lCmozwb2TzF8JXBMA+an\n", + "oC4ikkfFcEWpauoiIjEpRFDfnPRcNXURkRgVQ6auoC4iEpPGDupNqZ2pK6iLiMSoGDJ11dRFRGJS\n", + "6ExdNXURkRgVQ1BvhiPRyO0QESlJhS2/OHx4rhKMiEgMCp2pg+rqIiKxKYagrrq6iEhMCn32C+i0\n", + "RhGR2BRDpq6gLiISk2IJ6qqpi4jEoBjKL6qpi4jEpFgydQV1EZEYRAnqPai54fQbwGVhuAMWYTfM\n", + "mA4Mrncqjibh75Y6r6j8IiISkyj3KN0MXAHMANoA04BJ2M2mR4ZHFKlKL2Dll5YRpyEiIvWIEtSX\n", + "hAfAWuAtoHt4ns3l/alKL2CBvmkW0xERkTSyran3BPYDXgnPhwIzgfupuUF1OgrqIiJ5lk1QbwM8\n", + "AQzDMva7gV7AAGAxMCLD+9OVXzaH10REJEdRyi9gmfQ44E/A+DBsWdLr9wET07zXATCC9pyWciey\n", + "CQV1EdmxDQqPnEUJ6gmsvDIHuCNpeDcsQwc4HZid5v0OgB/TGzg1xeubUflFRHZsleFRbXhDJxQl\n", + "qA8EzgNmYacuAlwLnIOVXjwwH7g0w3TSlV+UqYuIxCRKUJ9C6tr7P7OcV7oDpcrURURi0phXlNZ3\n", + "9osydRGRGDRmUK/v7Bdl6iIiMVCmLiJSQoohqCtTFxGJSTGUX5Spi4jERJm6iEgJKYagrkxdRCQm\n", + "xVJ+UaYuIhKDYsjU1aGXiEhMiiGoK1MXEYlJMZRflKmLiMREmbqISAkphqCuTF1EJCbFUH5Rpi4i\n", + "EhNl6iIiJaQYgroydRGRmEQJ6j2A54A3gTeAy8LwjsAk4B3gWaAiw3R09ouISJ5FCeqbgSuALwKH\n", + "AD8E+gJXY0F9L2ByeF4fdRMgIpJnUYL6EmBG+H8t8BbQHTgFGB2GjwZOyzAddeglIpJn2dbUewL7\n", + "Aa8CXYClYfjS8Lw+6npXRCTPsgnqbYBxwDDg0zqv+fCojzJ1EZE8K484XlMsoI8BxodhS4GuWHmm\n", + "G7AszXsdABM4gI4sSfG6MnUR2dENCo+cRQnqCeB+YA5wR9LwJ4EhwO3h7/ht3wpUB/VT6QvMYvI2\n", + "rytTF5EdXWV4VBve0AlFCeoDgfOAWcD0MOwa4DZgLHAxsAA4K8N0dPaLiEieRQnqU0hfez8mi3nV\n", + "X1N3JHAZ6/IiIlKPwvf94qgCqoAmjdgWEZGSVAzdBIDq6iIisSiWoK66uohIDApffjHK1EVEYqBM\n", + "XUSkhBRLUFemLiISg2IpvyhTFxGJgTJ1EZESUixBXZm6iEgMiqX8okxdRCQGytRFREpIsQR1Zeoi\n", + "IjEolvKLMnURkRgUU6auoC4ikqPGCeou9MDo2JJmjE2o/CIikrPGytTrK72AMnURkVhECeoPYPcj\n", + "nZ00zAGLsDshTQcGZ5hGfaUXUKYuIhKLKEH9QbYN2h4YCewXHk9nmEamoK5MXUQkBlGC+ovAqhTD\n", + "E1nMJ1P5RZm6iEgMcqmpDwVmAvcDFRnGjVJ+UaYuIpKjKDeeTuVu4Ibw/43ACODiNOM6RtGBfrQB\n", + "BgGVKcbRxUcisiMbFB45a2hQX5b0/33AxHrGdVxBX+B4/pMyoIMydRHZsVVSO+Ed3tAJNbT80i3p\n", + "/9OpfWZMKlEOlCpTFxHJUZRM/THgSKAz8AG2BxkEDMDOgpkPXJphGqqpi4g0gihB/ZwUwx7Icj5R\n", + "Lj5qneU0RUSkjsa6olSZuohIIyiWoK6auohIDIql7xdl6iIiMVCmLiJSQoolqCtTFxGJQbGUX5Sp\n", + "i4jEQJm6iEgJKZagrq53RURi0FhBvQ2wtp7X1fWuiEgMGiuotwfW1PO6MnURkRgUS1BXpi4iEoNi\n", + "CerK1EVEYlAsQV2ZuohIDIolqCtTFxGJQbEEdWXqIiIxKJagbpm6ozmOro3UJhGRkhMlqD8ALKX2\n", + "Les6ApOAd4BngYoM04iaqV8N/CFCm0REJIUoQf1BYHCdYVdjQX0vYHJ4Xp8omXor4HtA3whtEhGR\n", + "FKIE9ReBVXWGnQKMDv+PBk5L+25HUywLX1/PPDZhgX8esBtOB01FRBqioTX1LlhJhvC3Sz3jtgc+\n", + "weHrGae6X5iRwEKgdwPbJSKyQ4ty4+lMfHikNorr6UcZ4IDK8KhrAzAKeBK4EOgDvBVD20REtgeD\n", + "wqPR9KT2gdK5sPUslW7heSoex/44pkeek+NXuIw1ehGRUlZfZaNeDS2/PAkMCf8PAcbXM26mg6R1\n", + "vY1l6iIikqUoQf0x4CUs0H6AlUduA47FTmk8OjxPJ9ugPhfYO4vxRUQkiFJTPyfN8GMizqNhmboj\n", + "keHgqoiI1NEYV5RmG9RXYPWknXD0yE+TRERKU/EFdcvO3wZeBubrnHURkeiKL6ibEcA1wMdAp9hb\n", + "JCJSooozqDvG4RgLLAc656NRIiKlqDiDeg0FdRGRLBR7UF+BgrqISGQK6iIiJWR7COo7xdgWEZGS\n", + "tj0EdWXqIiIRKaiLiJSQxgjqzYF1DXyvzn4REclCYwT1NTn04aJMXUQkC40R1Jfk8F4FdRGRLGwP\n", + "QX0nHIm4GiMiUsqKO6g71mM9NraKrTUiIiWsMYL64hzfrxKMiEhEud54egHwCbAF2AwclGKcXMov\n", + "UHMGzPs5TkdEpOTlGtQ9dgfslfWMk2tQV6YuIhJRHOWXTAcxFdRFRBpJrkHdA/8CpgKXpBlHQV1E\n", + "pJHkWn4ZiB0I3QmYBMwFXqw1xu1cAKwPzyrDIxvq1EtESt2g8Cgqw4Ef1xnmcTn+GnB8H8c9OU1D\n", + "RGT70tCr8HMKuK2AtuH/1sBxwOxtxnJU5TAPgGVA1xynISKyQ8il/NIF+FvSdB4Bns25Rdt6C9gn\n", + "D9MVESk5+b783uc8D0dTrOvenXAN7u1RRGR70uDY2RhXlObGsRl4G2XrIiIZFX9QN7OALxW6ESIi\n", + "xW57CeqzUVAXEcmoEYK6j2Mes4D+OU/F0V3d+IpIKWuMTL1fDNOw8ksuAdnRDXgP+HYM7RERKUq5\n", + "XlEaxVexoJwFfy/wFiRGhQFLsaPBZ+G4HtiEnRHTArui9TXgLzjm1zPRoViXBr/EMQXH/7Jrk4hI\n", + "8WuEUxr9U5A4OYu3nA7cBnwOPA38BBIex2RgP+AiYBHQjnU7baHlyl0o2zKQqrJzWLP7fDrMP2eb\n", + "gO1og3UTfDAwGOun5ggcn+a8hCIi8cv9dPA88eBXg28Xnp4Mvks9o1eA/wD8V8B3AD8TvHUU5tgf\n", + "R6+kcfuBfx/8TwFovvpOBt62keGJj3HciAt3S3LsjOMuHI+H5wkc9+J4FkezMOxQHONwNIl5+UVE\n", + "GqLB3QQ0Rqb+ODAF+AswH7gDEteGl5sBD2BdDszGMug/QeKn4fW9sQ7CrgXOAaYD1wNnAr8C7sEy\n", + "973DtN9kl9f+w3cP7o11jrMBn+jA/KOWMeXqh3jvuJsBcJTzSfcXSFStpO3iM4DXsS4P7sQxMuel\n", + "dlQAXwMexTX8w4kwn5Y4Psvb9PPF1s/ZwB9qrR9H67xeYOboCkwAvo3jrTzO5zDgNRyf520eUuoa\n", + "nKk3RlA/HHgIeBI7g2UfYHegCngYaA+MA74MPACJ6XUmMQT4P+BO4FTgBOANG5aYCn4ydveldsCV\n", + "2Jd2Dy4+rB+Tbj+XDw8cwpYWfwrv/SMwEzifpmsPZsjRPahYsJjPW67k778fy7dO+hEJbgL2BF4A\n", + "JuD8TpSvr+K61vsBc7bW7e2g7ReBj3CsxLEz1gfOFmBiWMaf4rgX/DeAFyGxFEc7oAzHahxtsR3S\n", + "tLR95Nh8zgAuBm7C8VIY/mU8U0hwAY6xOPoD63C8l+VnVD9HR+x00iocL8Q0zYexZboDx3Vh2FBg\n", + "BJ91eICp3xvDEbe+gmNLmvcnsM97U9qdmqMlcC7QHJiK41UcfwjL0hU4DJfjrRYdzYEfAAuBf+NY\n", + "hePrwFjgUeygfFdgM45lOc7rCOB0bBtYmTQ8kTFxsPXVDcdHGcarwBKrx3AswrEX8Aku5+6zk+fR\n", + "EfgJcBeOxTiOB1bgmBbx/e1DmzItcwtgY52koRXwWayJlq3b3YH3cfjwa78qhnkUdVAvA/6LBcAv\n", + "YP3FXEdNV5NfhcT6dBOoM7kEFgTfhkQIgv5kbIfxLUg8Br4SW8mdsODqIPE/8LthO5GNwEvAr+g7\n", + "bgAH/fYpnhk1lSUDYP8/7sNXbppBxcLngcF49uGF6zbTZVZn9nx6MWVbOvJptxW0Xl5J+cb+QHds\n", + "p7QOaIntXLoCvwCeAF5kza4T+LjPxbRbtI5Oby/H+sypIsGHwC7UHASegHVR3B3ogd2+bzNwILaz\n", + "uA+4Kvy9hc0tpvHa0B4cdNcmmm6YAfTBDnyvDtP8GOsKeTnQBNtpNgdGUVXWitU9L6LD/MdJ+Bd4\n", + "7G+30Ou5jznkNwuB3YCmYR19BTgP24l2x7pXvgnrZK36s7gE6xp5QWhDJ+D3wEfY8YtdsAPbj2IH\n", + "tE8K6+dY7MD1S2F632T53hfw0QHj6P2vClov20zC/xm4N6yPHkAb4DDgcNiaBVcC44GncCwLX7ID\n", + "gAeBD0K7vh7a9MPQxkuBy7Bfe+8C3cIyl4Xleg+oXqd7YzuQRPh83gbmhXV5D/AplqAcDIwO6+sM\n", + "4MawzjqF9T8deDl8HvuGec3DfiHulDTvKizxeCvMu3tYh0eG9XV4WJYewBGhjU+F7WV/bFtaCryD\n", + "HXtqAnwXS6geBm4Ny/F5WOZ9QhuWYtvWh9i28gG2rbYIr60I71uHHet6BNtpHYJ9vyuwbbVjWCcT\n", + "se/GIGBOWJ/lwM9C23pjv96HAM2w7WgdsFdYxx8An2FxYxfgP2G9Xg/8L6yDZ4EBwI/CPP4ZluV4\n", + "4DTs+zMN+27tin3+C4G/Yzv39eEz3DUs89/CejwmLHszYC12UsZq7ISPWTiqQul2X+Dm8Jm8ht1X\n", + "4kIsDjwd1sOq0PbWWPybgOP9sHNri303mofXWwELcVtjQrEGdRLgTwAGQOJW8D/AgtMGYCAkVuQ4\n", + "izLg58BtkNgAvj32IX0EiVVZTCcBfAP4LTASGMGXHr6Gfn8eRvO1MxnzzABgC3tPWEC7RXuxucXr\n", + "TLv0Q9ovvIFhe36O7amrcJRtzbodRzPzvN+xrP9/+fDLPdnQoRnL+vUGv5ozz/oBMy5cztsnf4d9\n", + "ntiDAaM/Za9/zLV2s4g5Z5zG8n2O4LOOzzH9wtfZWLGRYXtMpsP8e/F8mUUHN+X+l/7Czm98g/0e\n", + "fInXLxnOZxUfc/R1/Rnw8FrKtnTBgkKFfQbMwCdaUFV2Jat6d2LmBR04dNR/aflxb5b1q+CzTmvo\n", + "+fxjwEKqyhIkqgaS4B3gNhzLcbTDJ0aBP54EO2PB5yMseL7L5817U77xbWyneQXQBs/feeXyvqzv\n", + "fDRH3rCc8k27Ayt4zt3J88P7cFWHG2i5+gxW9j6SyTe9yJtnfxULIDNpueJyhvZ5nFYrT8K+xPOx\n", + "L+E04Dkca3B0AE7EfoUdj+3IEmwpb4pv4ijfeH/InvbBvmS/wnFX+Gz2o6rsKsqq2oXl2EhNHbMP\n", + "PrEfCf8WtkNbE5a3DRYEe7K5ZQvWdvkrHRZcHj733bBkpRLHo+Hg/MFUXv8a3aZ7+jw1CAu6O2PB\n", + "YTMW2D7BAv2WMP9yLDj2Ad7EgtA6YCyOj8MvgSPD8JexndJp2I5hWmhnt/D+blhQnwD8C8+twMkk\n", + "KMcCehW281iL/Tq9BxiF7TB6Y79WE2GZ22FBpwL71XgUMBkLhPtjQe+VsCxdwmeyJoyzd5hGAhiH\n", + "YwKOS7BfUudh39fHsUD+Jhb8dsEC3VzsRjtHhLZeEpbtQmyHsQS4JbT/K9itNadiO7AyLAk4Iyzj\n", + "rUAv7Iy818P6uQTbtl7Hvv87Y8lLdVLVJix7h/C5dA/bSqswzr3YDuZcbIf0RyzBOxoL1t2w+058\n", + "Gj6zU8K62in8bYbFwvXh8QscEynuA6XbDOpo2bTvte1rxcDvBv5f4BeAXwb+wDB8v6QDvgeAvwj8\n", + "7eBng+8Ofjz4VeCngj80jHcg+MXgW4cDv78Avyf4n4BfCH5FGPadML9Lw/s6g18C/ofgfwf+AfBT\n", + "wD9D2cZ+HHPVY3SYNwt8kzC9e8DPD/NaDH5amGYH21n5L4B/DPwm8J+Cvwv8teAfttKQfwH8UvC9\n", + "wZ8F/nPwPhyovgL8hWFZF4eD0yPB3wr+1+C/B/6hMO1nwnq5D/zE8DlPBX8T+DfAnwr+kbCsb4I/\n", + "F3zfsB4eB38v+OZhHYwE/5TttH05+KZ1Pqdy+5Xm/wz+bso2fpv+f7qcnv/+K2zZDP6WWqM7mrL1\n", + "Ogd/HPhXwG+m+kB77WkPDOtgXPiFV/f13UOb37V1XOu1tvY5+h+BvzNsE3/IvN1tff+5WGKSBd8k\n", + "xfrpA/7gOuM8AH4u+K+FbaNNdvPZOt02uHzeuMYn7LHN8DLwDnzuFyI2lKM9js6hvNeQ97fF0Y/M\n", + "J2Xk71hcjoq2YZn5g8Cfn2GcBPg/gt8Ygm8X8N8MAfKH4e9Zad57pgXkrc97Y4H+IfB/BX9HnfHL\n", + "wY8Iwftp8Gm6TfBl4E8MAekT8OtCALqu9pfYd8LOTKoMgfg3Nk+/2IKBLwN/TAjQD1mQ9H1tvv56\n", + "8D8Df1V4/Wdh2S8B/wT4y0IAPxt8q7CebsR2HleCbwf+cGwH8TL2663ucjQNr40B/15Y7uqd5V7g\n", + "XwuP6gD6KPixYT59wS8Pf4eF8aaA/2XS53IqNTuU3knz7YDtdM4EPxz8Smzndz62M9gX/PNh2e8I\n", + "n0V/8L3COl4S1sFI8D8P6+tD8APr35YA/Dngt7B1J+B/ZI+tr+8J/vvYTrZ1GNYE/ARsJ7l7GNYT\n", + "/KKwnD3ANwvLMBn86dgOdlXYPpJuQ+mPDuupS9K21NzmAeCPB78e/G8zL0vGZT0e28EcXGd4P/DT\n", + "sR16nZ2Ovzy8Zzn4i9km8Pvm4B8M679ThvmfBv6M3JcjCt8afHmK4W3DNvvFVG/Ke7MaqGgbFh/f\n", + "DPyRdYZ9PQSsI1O/J+20OmIZ9GT7wHNuW+v6p+MfBh9KVv5ALDuP4QsbuX1PgH+RtF1J+N2wTPyI\n", + "EISXhiD8Cfj/2/ZLXeu9l4XANc0+B38k+NtC0EraIfqfYkF/cpj2SvC/SXq9A7YjegT7BTcrfBFD\n", + "duzvAv9OeO/vSZlF+rNC0B0SHg779TIUSx5agj80BKujQkD+Hfh52Cm+J4O/Gfvl+FAI4ivD/B4E\n", + "PwnbAXwU2vlemPbV2C+SadgvyVZ12tUH/Bxsx/4gtkMai/3K2j28tgn7RTMvrP9TwrLuYevRf4et\n", + "v65qTfuLod3fwHa8Z1Ozc0iAfym0fxmWGJ0N/v6wDr6DJQsz7bPwt2IBfTmW/PTFdkxjwnZ7MvaL\n", + "cUrYpkZhCdLhYV5XYInSCGzH++fwmS3Ggvve2C/mieB/y9YdJmCB93Lw/wX//TDsEFLuEHxZaN++\n", + "4XEUts2tCevyVGpt6/6esB6WYknDCeB3rX4x9XadWa41m8HAHVjd7j7g9jqvF21dSAB8P+DkcKwj\n", + "gR2buAMSaxpp/q2Ackh8ksX4rYF1mQ+u+3LsQN4jkKjntE/fFHBYHfZlrNa8CBIxJiQ+gR1H6ovV\n", + "ed/H6rK7UHOwcx5wOyQetCDFvVjtvDPwb+xg5BmQWB6muSt2Om8/4BL7zPyBWF13FST+EQLIfcCr\n", + "Nr1Uy+RbY/Xf3tgJB4vCetjT1ktiVFhHewBrIfEh+J9jp+zugZ2KvBt20PlZLCZchJ0wMAOrS6/A\n", + "Dni2xq7sToR29Q3jnRPaUAmMhsRSao5x7YIdUNwTGAeJiaHdrbBjX4dgB3c/DPO7x06i8CeFeSzE\n", + "jh3cidXuK2w5+A1W65+EHawcE5b7VOAg7GD+IuyY0UzsQP8I7IDooLBcN2PHO4aF6VbXyVeHZVwZ\n", + "3vvr8DndjNXmx4XXvosdsD0QOw7VBPv+PU2BYmcT7CBNT+yLMAP7kJLtAJl6oxlU6AaUmEGFbkCN\n", + "VL9UfFLN1fdPnQ3nrT29wH+tntfbgn8S/AHh+THwl+ewX0ZjwQ+u3X4IGfOZ2K+QxZaN55vvDv67\n", + "2PUw6cbptO269WeA/yf2y+WbScN3C78meoaMfAFWIjwGK411zNCeBHZsrvp4Vn0luYLEzkOxMwqq\n", + "XR0eyRTU4+MK3YAS4wrdgBLjoo3mK0I5pBF3UvmS7oBuPBNv6Btz6aWxO3YKUrVFYZiISBqJ1VbS\n", + "SWwsdEtyl/DxlunikUtQL7qFERHZ0aU4zSayD7GLFKr1wLL1ZPNQ8I/T8EI3oMRofcZL6zM+8wox\n", + "0/Iw457YVVGpDpSKiMh25ASsn4Z3gWsK3BYREREREclkMNYRz/+wiy4kewuwjp+mYxc8gPWANwnr\n", + "5e5Z7IIHSe0BrHOw2UnD6lt/12Db61zguEZq4/Yi1bp02DG06eFxQtJrWpf16wE8h3Ve9gbWYygU\n", + "8fYZ5aIkyWw+9iEn+yVQ3QHVVdht/yS1I7DbHyYHonTrbx9sO22Kbbfv0jg3Zd9epFqXw7Eub+vS\n", + "usysK9ZlMFgvkG9jMbJot88oFyVJZvOxvriTzcW6NQXbMOY2aou2Pz2pHYjSrb9rqP2L8mns8nOp\n", + "0ZNtg/qPU4yndZm98Vgf7rFsn/mI9rooKR4euynCVKzPZ7APfGn4fyk1G4BEk2797ULt03G1zUYz\n", + "FOvb5H5qSgVal9npif0KepWYts98BHWdlx6PgdiHfQJ2x5Yj6rzu0brORab1p3Vbv7uxG04MABZj\n", + "nV2lo3WZWhusc69h2E00kjV4+8xHUI9yUZJkVn3/zOXY3WUOwvbeXcPwbpDjfS93POnWX91tdtcw\n", + "TNJbRk24i3YpAAAA0klEQVTguQ/bPkHrMqqmWEAfg5VfIKbtMx9BfSp2O6qe2EVJ38S69JToWmHd\n", + "jYJ1V3ocVs98ErunI+Hv+G3fKvVIt/6eBM7Gttde2Pb72jbvlmTdkv4/nZp6u9ZlZgmsZDUH67q8\n", + "WlFvn7ooKTe9sKPdM7BTnqrXYUeszq5TGjN7DLv36CbsGM+F1L/+rsW217nY/U6lRt11eRF2D9BZ\n", + "WE19PLWP72hd1u9wrI/3GdScEjoYbZ8iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIikk//DzX8Jz0M\n", + "ra0pAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(np.vstack([train_loss, scratch_train_loss]).T)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice how the fine-tuning procedure produces a more smooth loss function change, and ends up at a better loss. A closer look at small values, clipping to avoid showing too large loss during training:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEACAYAAAC57G0KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXe4JGWV/z81Odw7OScmz5DzEEQYdJUgAioqqGsWTAs/\n", + "d1dXV11rjWvOAQMKiJhFRERQHBRRchgYZpicmByZfGemfn+c9731VnWlvre6+/blfJ7nPrdDdVV1\n", + "dfe3Tn3Pec8LiqIoiqIoiqIoiqIoiqIoiqIoiqIoiqIoiqIoiqIoz2t6Ao8Cv0t5/mvAYuBx4MR6\n", + "7ZSiKIqSTo+Cy10DLACChOcuBKYDM4ArgW+Xs2uKoihKZygi8BMQEf8+4CU8fzFwvbl9PzAEGF3K\n", + "3imKoigdpojAfxl4P3A45fnxwGrn/hrkpKAoiqI0kDyBvwjYiPjvSdG7Jf5ckpWjKIqi1JFeOc+f\n", + "iVgwFwL9gEHADcAbnWXWAhOd+xPMY3GWANM6vKeKoijPT5Yiec6acg7JVTQXAreb26cD/0x5fYDP\n", + "Snwmd3gPfAbgs6fDr+9e+I3egW6E3+gd6Gb4jd6BbkaHHZG8CD5tQ1eZ/9ci4n4hEqHvBt6S8fp+\n", + "wL4qt+nSBvTuxOsVRVGeN1Qj8PeYPxBhd3lvwXV0VuAPAr3w8fDV51cURcmiaB18WXRO4EXUDyED\n", + "r57vzGv0DnQj5jV6B7oZ8xq9A4pQb4HvA+zv5DrUphHmNXoHuhHzGr0D3Yx5jd4BRai3wO8vwVpR\n", + "gVcURSlAvQW+M/675SAq8IqiKLk0o8C3UX31j6IoyvOOZhV4jeAVRVFyUIFXFEXppjSjwKsHryiK\n", + "UoBmFHj14BVFUQrQrAKvEbyiKEoOKvCKoijdFBV4RVGUbkozCrwmWRVFUQrQjAKvSVZFUZQCNKvA\n", + "awSvKIqSgwq8oihKN6XeAr+3hHWoB68oilKAZo3g1YNXFEXJoVkFXiN4RVGUHFTgFUVRuikq8Iqi\n", + "KN2UZhT4g6gHryiKkkszCrxG8IqiKAUoIvD9gPuBx4AFwGcSlpkL7AAeNX8fSVmXCryiKEqdKGJ1\n", + "7APOBfaY5e8FzjL/Xe4BLi6wrs6iAq8oilKAohbNHvO/D9AT2JqwjFdgPdpsTFEUpU4UFfgeiEWz\n", + "AfgLYtW4BMCZwOPA7cBRKevRgU6Koih1oqhQHgZOAAYDf0Q893nO848AE5FI/wLgFmBmxVq+zpvN\n", + "85jXz6tYJp82YEAHXqcoitIMzDV/DeGjwH/mLLMcGBZ7LMBnVqe37vMBfD7X6fUoiqI0B0FHX1jE\n", + "ohkBDDG3+wMvQSplXEYTevBzzO0kn149eEVRlDpRxKIZC1yPnAx6ADcCfwauMs9fC1wGvAsR3z3A\n", + "5SnrUg9eURSlThQRyvnASQmPX+vc/qb5y0PLJBVFUeqEjmRVFEXpptRX4Od97EAJa1GBVxRFKUCd\n", + "Bd4vQ5i12ZiiKEoB6m3RlCHwGsEriqIUoN4C36eEdajAK4qiFEAjeEVRlG5KMwq8DnRSFEUpQDMK\n", + "vA50UhRFKUCzCrxG8IqiKDmowCuKonRTmrGKRj14RVGUAjRrBK8evKIoSg7NKvAawSuKouSgAq8o\n", + "itJNUYFXFEXppjSjwGuzMUVRlAI0YxWNRvCKoigFaMYIXgVeURSlAM9fgfd5HT6zO787iqIoXZN6\n", + "e9ldqdnYa4C+wMIS1qUoitLlaNYIvowTU39gUAnrURRF6ZI0o8AfAnrg43VyPSrwiqJ0a5qvisYn\n", + "oBybRgVeUZRuTZ7A9wPuBx4DFgCfSVnua8Bi4HHgxIz1lVX9UpbADy5hXxRFUbokeV72PuBcYI9Z\n", + "9l7gLPPfciEwHZgBnAZ8Gzg9ZX1lCXwZPrxG8IqidGuKWDR7zP8+QE9ga+z5i4Hrze37gSHA6JR1\n", + "lSnwatEoiqJkUETgeyAWzQbgL4hV4zIeWO3cXwNMSFmXCryiKEqdKGJzHAZOQPzqPwJzgXmxZeIV\n", + "LUHyqq44F/DNnXkJ6ylKWQKvHryiKF2Nueav01TjY+8Afg+cQlSY1wITnfsTzGMJ3PwA/NSvZgdT\n", + "6FzDMZ8eyCAnjeAVRelqzCOqsR/r6IryLJoRiKcOEvG+BHg0tsytwBvN7dOB7Yidk0RXsWj6mf8q\n", + "8IqidFvyBH4scDfiwd8P/A74M3CV+QO4HVgGLAGuBd6dsb6uIvD9geeA1hIGTCmKonRJ8myO+cBJ\n", + "CY9fG7v/3oLb62oC3xMYAOwuY6cURVG6Es3YbAw6P9CpP7AXuYIZjAq8oijdkGbsRQOdH+hkBX4H\n", + "6sMritJNqXcEX8aMTlCORbPX/KnAK4rSLWmCCD7wIIjvpwi8z0x8BnZgP6zA70QFXlGUbkoTCDxv\n", + "BT4Xe8x68D8AbuxAJYwr8DrYSVGUbkkzJFnHAFNij1kPfhzSKuFb+MwEluC3l29moR68oijdnmaI\n", + "4FuAUbHHrAc/FngZMnr2Z8Br8RleYJ1q0SiK0u1phgi+lWSBHw4cxudp4OUA+MwFXo/0p89CBV5R\n", + "lG5PM8zolBbBTwLWxR7/HvD2Ap68evCKonR7msGiaQWGQNDXeewg0uAsLvD3ICNTk0bfuqgHryhK\n", + "t6cZBL7F/B/pPNZGksD7HAbuAF6Ys061aBRF6fY0g8C3mv+uTZNm0QA8Apycs04VeEVRuj3NIPAt\n", + "SPvhuMAnWTQAD1OdwKsHryhKt6QZBL4VWEp0nteDyIQd6xOWXwAckTPCVT14RVG6Pc1SRbOUygge\n", + "kiJ4nzbgKWSawTTUolEUpdvTTBF8MYEXHiG7kkYFXlGUbk8XF/igNzIYayXVC3yWD28FXmd1UhSl\n", + "29LFBZ4WYBeSZI178G3AlpTXPUyRCN7nILCHsFJHURSl29AsAr+Rygh+PT5ByuueBGbhp7ZisBE8\n", + "wFZgWJX7pSiK0uWpt8ADQc8qFm5FbJQkgU+zZ8BnPxL1T0xZwhX4bajAK4rSDam3wB+gukoaG8Fv\n", + "AkbK5B9AnsATeGyftJ/KNsOWeAQ/tIp9UhRFaQrqLfDVTrVnInhvHyLIQ8zjS4G/Z7xuICvmTiPw\n", + "pqY8rxaNoijdnnq3C65W4G0ED6FNsw2fO5CeM2n0Y9s0j8O9poUFNxFU4BVF6fYUieAnAn9BBg89\n", + "CVydsMxcZFToo+bvIynr6mAED1T68Fn0Y9sUCHpMT3leBV5RlG5PkQi+DXgf8BgSUT8M3AU8HVvu\n", + "HuDiAuuqNoK3Ar+d0KLJox/bpwBBpQcvNe/xJOvIiuUURVGanCIR/HpE3EHskqeRuVDjFBks1JEI\n", + "3lo01fSNkQi+x6EjEp7rjcwEddDc1wheUZRuSbVJ1snAicD9sccD4EzgceB24KiU13ekisZG8Dmd\n", + "H4NpELzI3OnLrrHgHW7FZ0BsQTd6B62iURSlm1JNkrUF+CVwDWFUbXkE8er3ABcAtwAzK1fxn0Ph\n", + "d1cjfvo885dFK7DW3M7rG3MRcCpwN9CPoAcc7Lue3vsmIx0mLUkCrxG8oihdhbnmr9MUFfjewK+A\n", + "HyPiHec55/YfgG8hork1utgX1sAXrgPvoYLbdSP4PItmNCLeAP0AONCynt77pqICryhK8zCPaPD7\n", + "sY6uqIhF4wE/QETyKynLjCb04OeY21sTltuLFd9iuB583uQco511y/+9wzdQOdgpLvCVI1l9zq5i\n", + "HxVFUbokRQT+BcAbgHMJyyAvAK4yfwCXAfORZOxXgMtT1lWtwFcTwY8hHsHvHL+FfIGPRvBSZXM3\n", + "vrYRVhSluSli0dxL/ongm+Yvj32EIlyEaiN4O6pJBH7r9K1MvXtabLm4wO8BeuLTD5995rU9zbZ3\n", + "VrGviqIoXYp6tyrYS3UC31EPvi8A60/cQV4ELx0p3UqaFvNfWwgritLU1FvgbYQMBD3kL5OCEXzg\n", + "IaNcoxbNinOeA6bEJvSIR/AQtWlaY/8VRVGakkZG8O8lvaWBJV4HnxbBD0Hq66NJ1i0zbb94t859\n", + "OHI14OImWjWCVxSlW9BIgR+JiG0W8ZGsaR78GKSVQTSCD3r2A5YBblfJU5B2Cy5uBN8S+68oitKU\n", + "NNCioT+ZFTWBBwwkatEMcnrCu4wGVhAV+MDcX07Uhz+dypG46sEritLtaGQEPwCbDE1mALAPvENy\n", + "19sPHCb5pJAk8DaiDwVe2hbMRko9XdSDVxSl29HICH4A2TXxg4mOkIV0H340sEZuBr1IE3iZiHsB\n", + "fmaSVSN4RVG6BV05gp+KROUuaT78GGQOVrv+vkjitB9RgT8N+GfC6zXJqihKt6PRAp8Vwc8EFsUe\n", + "y4rgXYHvh4h2PII/jUr/HSoj+INoklVRlCan0RZNVgQ/C3gm9lhaLbwVeDtS1rVoVgBH4NMTSbAm\n", + "RfBukrUV6YGvEbyiKE1NF4vggzEQ2JLGWVRG8GY0a3AmBK93Hh+NiLIbwW8H+uGzB4nmvwhsQibs\n", + "jhOP4NehAt/98bkNn5MavRuKUisaIfBZEfxbgM+a2zNJj+AvQhqcWVyLph9RiwbEprkcuBQ/GArB\n", + "CbH1xgX+WVTgnw9MACY1eicUpVY0wqKxoptUBz8MmAtBbyTJujj2vO1HcyQywQimLj7LgwdphPZy\n", + "fFYDrwI+EVuvm2RtRSP45wsD0dm8lG5MNTM6lUHcookPWhoKjAAuBNaDFy9ntEnWIwl/mMOAPeDt\n", + "g8CtoglHtvrc5KxjitmGyw6g1fj0LUjv+9M68P6U5mIgOtmL0o1pdJI1KYLfDLyTSnsGRIhHIHPD\n", + "DoWgLzANaUdg1+9G8ElVOlORNgkhPoeQk8cQ1IOvPz5nxBrC1QsVeKVb0+gka9yDHwb8FjiPygQr\n", + "iAifBKxGfPLxiMDbxKnrwbu9aVwSIvhgCvtbDyBXBeV78D7vwa9qopPnG7dS2da5tsgJRS0apVvT\n", + "IIEPehHt/mgZBvwasW6SIvidwMnA04jIT6RS4JM8eJepwGDj81tezI6JA8z2a+HBf5JowzMlyiDq\n", + "H0n3QSZ20Qhe6bY0yqLpj8y+FI/ghwJPIuL+dMLrdyCR/0KkNcEERDitRRMvk4wJfNBqXr+JaCfL\n", + "I9gzogfyY28BNiIllj2rf4sxfPog1k/WbFTPX3z6ImJb70h6oPlfW4H3+R+d41dpFI2yaAYgAtw7\n", + "NunHMKRk8cXA3Qmvt1PopUXweR78FGTg0yaiPvwkdo/qQyjwO5Gp/AbSeex2hpSwru6IvVKqdyRd\n", + "H4GXwXXH1ngbipJIoyL4AcBuYD/tUXzQD+gtj3trwDuc8Ho7UYcV+Akke/B9kUZlPSFwo/ApSLS/\n", + "iagPP4ndo3pzYOAY5Ie/27y+DJtGBT4b23qiEQJ/kNpfOQwhf94DRakJ9Rb4/YiItyAR8n7CKHso\n", + "sBW8IOW1EEbw1qKZgQi16STJXsLqnP1UTvI9FRn0tJm4wO8bGrBv8AxgPz4HKU/gR5n/tbVofL6C\n", + "z/SabqM22GMcFVqfL+PX9KQ4EFhL7U8sg1GBVxpEnQXeCxDRHYaI8T5CH34oYqtksQG4HrztSAR/\n", + "JrAy7BnPXuQH1WYei0/ybSP4zbRH1kEPYAIH+6wDbxrhBCNlC3ytI/i5yPiAZiMtgn8ztbU2rMAP\n", + "KiXXko5G8ErDqHcED6HA7yFaF2/99wy8veC92dxZjVwJLHMW2IecKPaZ+25rBAgjeNeiGQNs41Df\n", + "DfRom0DtBL7WSdZWKgdwNQOVAu/TCxHGaTXc7kDkijBjMvdSGExzfi5KN6CIwE8E/gI8hVS4XJ2y\n", + "3NeQ1gKPAydmrG8vEtFYi8ZG8AUEPsImpBLHbR62l6jAxy2aKVRaNJOAVbQN2EDvvWMIBX4X5bQM\n", + "HoVEirWO4FtoTiFpBewYBIu9XWuB3020D1G5+PQ229EIXmkIRQS+DXgfcDRSEfAeKq2AC4HpiCd+\n", + "JfDtjPW5Al9lBO/iHUa897jADyEawRuBDzyiAm+TnyLwB1rW0WfXEMJZpMpMsj5DmVGiz634HBV7\n", + "tJkj+FVERdYKYj0E3u1DVDb26kQFXmkIRQR+PfCYub0LqWAZF1vmYuB6c/t+RGRHp6zPtWjcCL6I\n", + "Bx9nOdEBUVbg9zv37QlkPLATvOeIWjRHAKvY37oKL/CojUWzmHIj+DORuWUF8ZD707wCv5JKgW+j\n", + "fhF8rSpphiDf6fIF3uf4BrV3UJqIaj34yYj9Ep8VaTziiVvsIKQkSorgAXgtcEds3XEP3lo0bn/5\n", + "uEWzkj0jVpj7UYH3ORu/U8PoRyEnoXIE3qcVOX7u8bVWUjMKfCsi8K7IDgeeoLajf2tv0chnvgoY\n", + "YAa8lclfoCmrpqL4vAC/PU+llEw1At8C/BK4hlAEXeLRRFK5ow/XjIJ3vgCuH0bnPHjA2+xU0EBl\n", + "ktX14LMEfhXbplqrJx7BXwu8sbr9imAjeGPRBEMhSJp2sCiTzf/xzmP2SqMZBT4tgn8a6I+fOEVj\n", + "GZRv0fjMwo/kbQab9Zd7EpFjMpTKK+ly8fkMPkfUdBvwMeCCGm+j2ZgL+M5fhykq8L2BXwE/Bm5J\n", + "eH4t7f3ZAYku1yYs58NXF8F3NsCbnqHzEXycvciJqEgEP9L48iLwOyetoq1/wKHeeyC4nwMD9iEH\n", + "ehZwSif2KW7RfAB4byfWN9n8dwW+BThMcwq8nSKxp9OQzXYVXUbtbJoWyrdovgS8y7k/BBmct4Vy\n", + "bRr7Wxtb4jqTuAyYU+NtjMNWmvmcj8+Pary9ZmAedRR4D/gB0iP9KynL3EoY5Z6OtCHYkLKstWj2\n", + "0nkPPmndkFwm6czx6u0BDiE/cvHgYQN7hnusO2kUMIctM/sCLwRuQBqchfi8EZ9zcvfGZyByjNcQ\n", + "JlkH0bkf+xRkoJdr0bQiFll9knl+an6lIwxCRHAbodAOR0RxKWUJvM9v8Lkfv/3kWguLZizwcuf+\n", + "YOS3ULbA21moai3wo6htHgRE4G3Bw3S6g+3UhSgi8C8A3gCcCzxq/i4ArjJ/ALcj0dYSxNJ4d8b6\n", + "OlEHn0tc4F2LZibRFsSbgTchrYE3g7ePfUMOsWbOMUDA5tkDzHKfBPrgMw6CKRC8D7gEeEWB/RmJ\n", + "NC7bhTQvs2VznamomQzcS6VFswoYjE9PfMbiM6sT20jHZxqwypy8ymAQYoe5QisCv3fIszzxureX\n", + "tJ05SHXXJ839Wgj8GOA0/PYrqVpF8Fbga2fRyNXUIGop8D79kZO69eBHO7eVEigi8Pea5U5AEqwn\n", + "An9AhPxaZ7n3Imff44FHMtZXVh18ElbY3Sqa/qbPzTik6sayCfmxf7i9PcKBlv1snzId+B3rTuoL\n", + "3IPPEuBhJIo/BrjCrCse1V+W0DVwFLARn4BwusEBpCVcJcKcmfMepwB/B8Y7VRQtZv07kB/M24DP\n", + "56yno7wP6f44Pm/BgrQig40qI/h1J+0n8E7v9BZk4NRI4CYk4dmXqAffeYvGpwdikd2JlA1DNIIf\n", + "gU8rfimjcychwVQtI3grtCLwPqfgc37J27AnKLutMTS7wPtMq/HI6KpoxEjWvYio1yOCtx78dGAF\n", + "eG3OspuRRN6t7Y+0DdhDj4OLgX9y3/sPIF0tAR5CBN0OJhoHnGh+1JY3I2MEwGcKPp9GIpKN5vnt\n", + "iLAPxAq8j4fPGHN7LBJlnprzHicjA87cwUGtSBRsk8ezgLNL/6L5DAdeR6VF1BnSI/j1x+9k8KoB\n", + "qa8szhhgMz5tyIl9FOVH8MORE9UvkbJhkM95O/K5DEeCgx+WsK1JwD/pqMD73ImfW6E0Cjk2NoJ/\n", + "E/CRDm0vnXHIb9VaNKORq9B4G/FkREy72hiDXyFuR5egUa0KIBLBBz2QH/r2Tq47zYN3E6yWXwJX\n", + "R5qbPfL2B3j25B8gkf4UM5UfhBF8C96h4cgPawcysMtyDHC+sWGuBD4EvAMRFMzyQ5AI3lo0rwSe\n", + "MBGmjf7zIjw7WGstYRTdithArsAPQK66yuQqJMn+MOVH8JUC//BVGxixqDcf7ndS5hp8jsTPTEZN\n", + "IGxIt4HaCPwYs+7bgZeak+tgohbNacAJsUqbjjAJKVWuXuBlv86BioFycUYjn/MYI7inAmfgl1pS\n", + "Oh6YTzSCh/iUmul8AvmNZSMngrGxx67E5/KC2ymGXFFPA3MVLgFcIzS2nUZF8BCN4AcDu2Ilj51Z\n", + "d9yDTxB47/vgPRh56MkrXs6KF30B6Rk/2XnmYaSSZiADtgwiYCfwD2T6QFu2NhKpljkbeD3w/5CE\n", + "mxvBD8aN4GXu2UHmNecAfyVL4KW7Yk9ElNyxBi08c8Ex7G/dY/ZjFnICKzuSeBHwc+TkUmYEn2zR\n", + "bJnVl7s/BT0Ofif1h+IzCfgj8MGMvMB4wqqujVQKfBnVR2OA9fhsQj7rSYQRvBX40xHB72xlihX4\n", + "qAfv82EzTiKLyYjFNilnuVFIfmo1IljHAfcg02mWxThkEOUoI46jkeNV1KaZRLGGdJ8Evhx77KXA\n", + "ywpupyjDkat8a7O+G/h6yduoii4SwZdiz4CMfrQdKyG0aI4leY7XGN5hE9FLBB+yCujDyCdH0/os\n", + "HO69Ackz2MjyaKTK6LfAZ4Bt+HwV+B7hzFTWohEP3mcGkq/4DFKOdg7wDeSHlIZE7+LpRyP4zUdO\n", + "YecEz+zLAWTqw7n57zlOMB2Ci1OetIlqd9sdR37UUYtGHrNVNEN49K1wuHcvSI22fgZ8FUn+pwmn\n", + "G8FvRITECvx6oKWEevsxZl0gJ/qZRJOsU5GKreuRwoWOIRH4OGQgWH+TqLSVTZ9EKr+ysMn3vPr2\n", + "0cgVyVLgUqSI4ueE+YUyGIccq8OIMI4mGtHnMZFiAn8icKkUSrQzg/D3WxZWM+yV/RzKPSFWTVeJ\n", + "4E0v+M7iBYTll3Zb5yER8m1VrGgjMBACuZQWQX2a8Q9MonUtHBi4lajAH4P44rchl7I/Nq+7Er/d\n", + "c91BGMEPJuBK4EfATxDxmoDYH0PwU5N+k5GrCxDBsiLbwr7Bvdg1+iDSxuAZpJb2LGP/VIOtmori\n", + "MwC5OlhF9khlu7yHz//L2X4/4CA+Bwitkv5AgM8eYAhBD9hw3J8gYdo7+cHORMp3/066cI4nKvA2\n", + "gt+Fz2HkeM1OeW1RRhMK/DPIj9wmWTebfXsMiYLP6sR2xgBb8dmPzB1srQebAM1LSs8y+1Mkgt+I\n", + "CPzlwAOI/XR+ibmd8chVwkbkeB1Avt/5Ai/7MBaYYWxR+/gl+M6JXuywScCNiHVqE+LTgan4DMSn\n", + "F34pduYUJNCzAn+82cbE9JfUlkYKvFsHP4zO18C763ctmunAq8FLq8tPwAuQ0ZWTnQcXMnLhWFqf\n", + "hb3Dn0MixpNMxHksIvCPAb9DRDuORPBT/jSYt5/eG0nKfgefxYho3meSgE8iJwwhGlnOJmyP7Nok\n", + "rewb2oedEwDOABbhs9m8h/824hziMwyfeST3MulL5VSHIN7iMpOXSI/gw3Uei1wWZ1UFWXsGQotm\n", + "OOHJXqysNadvJlmAXwr82exTlsC7A+/iHjzIVVZnBT4ewc8gatH0QhKj9wGnd0IkZWCesI7QpnkZ\n", + "ctUmAu/zYvxEC2IW8Ceqi+CPAh7EZxUiyO9L+e6EyAn+jfjc3f5eff6V6KQ045DPZSPyfdlAmATP\n", + "Q050cizckuC3EA1Qjkc64X4FuBJpGTEO+d49hVwxvwK32KLjTEGmGp1kfnOzkIrDhiVdG23R2Ai+\n", + "LIsGogL/R+Bl4N3XgfUsJy7wQ5aJRfPcuD34bEB+0C9CBHk+PgE+F+MnjuKVJOvZnx7EU685wLfm\n", + "n4TfLtZfJzwpzMfaNOIpL8bnChN1vA34hVkuatHsG9KXHZN6IqJi7ajLzbqejIn8pYgllFRHbac8\n", + "jDMTES6IXj2E+MxFBNdDqm0gnsyL9vWx9gyEEby1Z8A2jlt48XMkC/B5SFkiiHCekeLVZ1k0IALf\n", + "2clSkgTeTbIC3G88+nXYk7jPEfi8NbImOQGfmvJe4gI/1kSwL0FGPc4xr/s08DN8Xh17/WzkmOUJ\n", + "vBvBA9h81WVID6g78bm8Pe/h0wefLzrC/y2kpHYGYcDyv8h32DKOMIK3Am+vsPKYiOQH5hO1aWYi\n", + "yWzLScAj+DyFHK85ZplnCK/CXw1MpPMziE1FKszWId/NVcDv6ZBVWg6NtmjK9uDt+o3Ae8+Cd1cH\n", + "17OCqMAvYvDqYQxZuZ9tU60F9Ankh2Qj+Cy2EzCZcQ/15OF3rGLTMWElhc8P8LnR3HuC8At7FXI5\n", + "/QkkytiKCBm4IhvQwv7BfdlxhBXmRWa9T+NzmVmn+8N6LXI5fJRZ7sv4nGGe6wv0NRHYacZm8Qh/\n", + "FCA/xBGRS2PhHCRaeQVycrnN2UY/fL6JXAXYKM5W0Nj3MwuxgawgDgWWs/IcDxgYsa5ExP4FOYlj\n", + "TribkBxEnLhFMx7wjDUEtRH4WYQCvxXJDdkmfXcTjnj9d+RKbrKxCr6LXKXdCKzF50Wx7bgC/yxi\n", + "U5yBHNf5yPflUrPc2cA3YvbDLLP9kWQ3QHMj+APIdwhzxfkCJPdxNfAFs/xM815ONrbI65Ay4zuQ\n", + "kt1JiChfatbjEVo0m5Dv/HqqE/hVuAIvVwpTgWMISy1PRK62QYoYXoicdBYjAn8WIsaLCU+6j5A/\n", + "HiUJO2PcM8CrkLkx/oJG8GV58O3r35e7VD7xROtCBq8ezJDl+9k805ZW/hTZ/x7IWTuL7cArWHn2\n", + "YQ60SgIxmfnAC02k+5/ID2U5cB3wFfz2Jm5rsD1Jgp5D2N8K2yfZKP2Z6Cr5FPB+E2WNQC7jbyYU\n", + "tdcgdgdYgReBuRH4b+QyNxR4mbN2I2FZm+UEpLXDd5GyzZ8RRvBfQiLpPxEOEnMj+CcRm+ZyohH8\n", + "MoKeQ5HIyI3iTwI24Ue6mFbaNKGQuBbNFMLoHcoTeGsDLkMEdh8+beZ4nWksDoDvAO9yhPDnwIeB\n", + "/0EEaho+s4GPY3vb+PTH53+B/yAcSGg9+H8lzDH9A/gi8BN8HgH+z6zb2n121PM6svMoNoJfAFzs\n", + "nAzB5wA+3wc+iHw3ILTiXgNchFiOW4G/IaJ6DmKDDMJvP/m14bOL8iL4SWYdiwlLhCWCF+y+uBH8\n", + "q5H8glSw+WaMi+Sy7Psdhs+/4XNmjjVlS5gXIyfwJ5DvbX98Po7fflVbN7pSBF8LD74zrCAq8Mvp\n", + "v6Uvw5YE8l4CAAAgAElEQVT2YNNRPSDw8IMH2TT748DtjvCmsQOPVp552V7ChGsS9yEi+CTiez6O\n", + "iOwyQnsGRAT74dPC4Z6DONAKOye0IhUJSyNr9HkQ+aJ9GPEo70AGbx2F1AePI7ys7cvwRYOQpN0J\n", + "iMhfgkQ97okjqVTyRORkshBJND9FKPDnm/dxD6HAhxG8HL9vIT2NogIv34/QJ/d5CXLCuD22/Xuo\n", + "jJZGALvx2793GxEhcAV+CXBEe0TrM8pYbcfgJonlBOnjcxuSQHetrDCCFzFchXzO9rX/dG4/gVxl\n", + "3YCIwNXImIi3A2/Ab3//vwJeYrbzDvPe/gWfm8zz65DP5kKkkgjE558M7VeE30Ui6COx/ZjkWK8k\n", + "LdEqkfBw5AR6CN9cJVUiJ10RvRmI9fMa82e/q39FriTmIlcOvzX7bO0ZkM9kLPEI3ueiCpvKb6+R\n", + "TxJ4K9z3Iy0j+pr3PN88fy8SAMxGRNg+/gvkcziOMEA42WzvUuT7cRZSAXUvSUUQcswmIrqxGAle\n", + "njDH2o7+/ia++c34fNp8JjWlUQJ/CClprJUHvz93qXxW4wqYz0F2TjzA4NUtbD6yLyIcJ/HNp9fh\n", + "868F1redgICFl+wgLJmsRCK+a5Af6ZvNYw8iCd02Z7kAEZGJQCsHBuxh6/QhSFI16f3L5bP4oD9G\n", + "IrOjzGNPId6tB/RlzjdGAzcglSz2B+l68BBPtPrt/vkS5Grg84iIzUD61ww023yYsPrITbKC5CF2\n", + "ExX4pcj3YyFwJD7nIVczPwY+GnuPdyEC6CYwXXsGxA7ogSvwcrxWmX29DhGJ9yIJ8++aZfojkd5J\n", + "Zj/fhox1sFPzDXb2G3OssgbufRWxsn5gIt2rgcvx220e8NmInOhfjNRUfxg/YgU+i1x5XGnWAWIJ\n", + "3I3YA+Cz22zrS8gIW5ufWUmSDy+e+jBgh7nyyGIT0oxwBPL9+DXy+3sZYdfZlchv/TLkBPxbxCJ8\n", + "KeFVlR0MGEbwcgX7O9xWwlIKuhax+KzALwOGm+9fVODlqmFJ+8ldjuc65HguNo9/ATmR2hPFWUjg\n", + "YDvIvhN4Jz6vRU4WUk1UOVhtHFLdtI/wd2JtrZvx+SByBXOpOUm9Hyrst9JplEWzx1Sq1MKD30U0\n", + "OusozxJPQm6eeZDAC9g2dSBh5n5G/IUpLGHXmF+wa9xzZAm8xWcTvnNVk3yFsBqYhBe00DZgNYf6\n", + "DccPknvQ+DyJz0VIzffvELE9EjiFBa96joN9DgFT6LNzAMfePASJpkGuKCYh5YvrnTWuIRrBnwA8\n", + "js9hfPaYyG8PchzfDswz70ESW9EaeLuPexB74UkIeiInBTudn7Vo3gP4+HzXicrt69cgP2C3vjna\n", + "ulrEfDuV35GnETvjRKTPz0sRkXilEfeLkO/oJfj8BBHcd5sIfxQ22g15BjeCr+Q2s73fmP26CZ+/\n", + "Jiz3W7NcGxKBuvwTeAc+v3fe3wKkgsb9vnwNOX6XIjYFJAm8zwuR79Qs0rvBussHZr2zCMX1p8Dd\n", + "7SccWeaviI+/ADkBLUM8arvfdjCgW0VzPvJZvt/Z4uVI6/KXYwVejvlfEB/dFfgXIVdI/xXb678h\n", + "0fRSs38fNFdMVuBfiBQ9HIcMGjuTMM9zGAmUliD2mYu1ZzDHZBtyjF1+jVypXYF8nlljXkqhV/4i\n", + "pbOX6IjTfsiHVpZFcxVhRNAZ1gGjRGjMCNvNR8GUeds43HsEoR88vdDafFbDus8hg5+yLJpqWAVM\n", + "wjs8kAODliAJSttLPW0/DptbG5DP/wIWXTSMMY8uZ9iyOZz96WNZd0IbN/55iVn+oBGQY2KiES+V\n", + "PIEwmeWyABH4j5r1bTBCPploktXu3yfMrWGE/XWswJ+BBCVXpL4/sQnOI6z6iEfwIIKSJPA2Sbjb\n", + "7MtGxMc+H/HKb2w/Bj4PI9VSL0c+h/Wx9S0m67shwvShjPdh+S3wOeRkEj3J+2wHvp+7BvG53xd7\n", + "dBWVA8OuQYT4U4Sim8ci5LdgxfVeKier/zPQw3z3DkBFZY/d1noTHLSZZT4IfBxJ9t+P5Bq+gZxs\n", + "bQQPEhlfguTybkc+y97Ah/ArbLy/Ia0k4sHBZvO5H4mcMFYjdfNP4EestgCfzwG34vMfzmcSCrzP\n", + "MnyOSgjK7kROOuORQObFJCFBw3FAL3weSFymII2I4HcTzppUgwjeWwvegfzlctfThuxT2Pt849E9\n", + "ONxzPWJFzEIun4tG8CCjWHfTHsEHMyCIfwGrYRVwBN6hfuxv3U7xBJWNrBYAc1h5ziA2z14B/Asn\n", + "X3sqf/50PIdxPVLP67KGqIC51QouC5BL+HnOY48g1lDconGxNeS2fHIJ8gO+qV2Ak7mTMGEMEs0/\n", + "HVsmSeB/AbwZv92XdR+3/vevY899HRGhy6gU+D9ACZNX+DyDnBx/3Ol1RYlG8FLlci5iiZxFkQhe\n", + "WIicKAYCzyIWYzxY+xHZs6K5Eby9fzYi1l8CvorPucgV9YfN9kYQFjbchpzUj0ZyDIeRWvTvJWzr\n", + "d9ikcyXzkbzXfiRH9Z+QmH+wNtkxzmMvJQwqiFht4WN7ERtxIFKXfyw+PfBpwbb3lqq3DUgO5YyK\n", + "dVRJIwR+CeGou1p48GXiRKmBx+IL+7J71OcIG3rdRnUCPxBJLtu+NKfSuYZgq4HZBD3bONzbViNU\n", + "0251AQGb2H7ECFaevRp4G2tPW8+zc6JXdjJYJd5J8I9I46zXI4mwkwknZ3d5ChE/t1XEw0jkewGV\n", + "wmiJCrwkLu8gtI7S+CvS6dMOEHsxEkG6bCAu8BKRJw1Q+w3yfb0rEskJv0I82clIVZK7viX4/Dxn\n", + "X4vh80l8x8oqh2eAc/BZhyRRvwlcj8+jiM2S9rnEWYRE1ItTbESMbdeW+JywCThIVOAfRgbrfQs5\n", + "ad+FVAbtRKLw9e2WmN/+/RqFtUXkKjFpX7bhp54sH0Kid7CN1pIEXt7nrdiuoVJ5cwESCOXxZSRP\n", + "tgX5fk9GbKT5+CxAclcvxedo/PbEeYdpgEXjBYRJiFp48GWyltCH78vu0Yf42tIbEJvleOTS+T0y\n", + "9Z+XV0UD4eAa21nyKGBEFa+Pswo4ikN99iNXRbZhU1EW0DZgGvQ4lycv38BLPvgMf/jaEoo0EpNL\n", + "2pcjCb3PIMfqqYQl70TK4cz7C17HwX6P0Gv/R5CywOtStjAEse3MnKmBh+9dVGC/9uAzD0lm3YNc\n", + "JcTHKGyE3KZcdn3r8fk1JESDctL5t0Lr6Wr4LMdnMPLbOwuxOKygvAcqxjiksRCpgInnB6rZlwNI\n", + "R1C30ukx89xB4H/w+S2hp30blRbnrUir4bzEcBYfc24/hGjSwynL3oqMgfkUkoi92Vhm2fj8HSnn\n", + "hbBy53LkiqUfYgmVpoWN8OBd7CTZgLc3c8nG8Cyhz2zE2Qsg2IyI4INIsmQUxS5pBxBG8EOQS8re\n", + "iGfZkQhNKj8O9t1uXr+X6iL4G/jrR1YD57LjCIDZbJn5O9mnoIc0X8tAErdzkRmvkqJ3G12Z6Dbw\n", + "gOv4/PrZfGjoVKI17HGGAtvlexEcIrS3inAd4jn3QhJ+8fexkequXl+dGp02MyKoa5HxCj9zHq+m\n", + "bfdSpCouPvai2n1Z4tz7LGHPJfu8K7TXEw74s9xA8bxB2j64JwcZUxFNnLv8FZiJz2eAt9Kx0apP\n", + "IJVyHjLKufTvWKMFfj/iZ+cNEmoUbiKxhTB3sBkR+/0Q2GHpRQTeRvDWohlBOFl2hsAHps+0tyT2\n", + "xGqgF20D2sy+7acagffZAh+yX+p+5gtma7v7UGQ8gVxWFmUI0Jf9Q4aknhCiy1qhsT58UYG/DZme\n", + "70pkPuE4d1BNi+DuKO5lIdG3Hb1Z1jqzW4tIDuax2GNrKJJwLr4Ph5Grk7Tn25A2EGcglks8z1OE\n", + "+UgO51O1+o41WuCtgHRFewZE4G0XQ1fgtxCKja2WKHKJaqPQHYiVMh6xNUYQnU4wznTgIQiGgxdG\n", + "GT578dlM28CDZt+2IcnOarAWlJ27tq/zv4wBYy525Gts0ojgPOCu2BVDksBnRfwh8uO7ASmxqxw9\n", + "6A46Usrga0iN+/MLnz8hgxI7yhPm/82ZS3WCRgu8HZDTlQXeCqDbnMp2agRJGs+AYJQ872VFmW6S\n", + "dRpS3bGO/GhyMOIlz6Hy0nQVBwYOR64Aqk2yQthZz3aQtALfj+w67o5gBd4ZCRh4SLLyGKKX5a7A\n", + "Gx++Kr6HlHYuy11S6Rw+32j0LjQpC4Gr8RNzV6XQ0OmkCAW+rBr4snE9eDeC/wdh2d9ipARsFdGG\n", + "Xkm4ZZIgJYR2vk4gOBeCb0LFYCVbV/yShHWuYv+gwOxbRwR+PDLwxAp8XOjLxPYud8XazlMbn43J\n", + "JllBAoDqJsb2WYxf6uQUilIuMsakpjM+NVjgvQDaJ3voirgevEwQAYD3JfBsc6d7kEusH5IfidsI\n", + "fjeSmLICb193PZIofX3sdXbO1RSBHwwdF/hxSKIsLuy1EPgki8ZOhhAfHGOSrEB586YqyvOKRkfw\n", + "ID5vVxX4bUAfCAYiApRgv3hrwfsAYrfk9ZM2EbwXIPbHU7QLfNAbEUAfGG6sC0sLUo54PASDIJjs\n", + "PL+AnRMOIxbNallHUM30c/EIvi9ykqmVwO8gGo1bgU+K4F2BH16D/SmJYC4E8aHritJwigj8dUiF\n", + "SHyEn2Uu8qN91PzFB8TksZ8uK/BeQNiTxrVoksjvLxNG8CADSZ5AErYjzDY2gLcLKb10I9pWZDDI\n", + "/cBNSMQto9x8ruX339og++btNcvMLfT2hKQI3vXky2QMctWSFMEbgQ+Og+A0ogJfVmuHWjGLsEOm\n", + "onQZigj8DwlHnqZxD1K9cSIy8W817KPrevAQ2jRukjWJ7eT7xG4t9xzwnib04N2JHLYQjVhtnfzP\n", + "kYkj/ka0D4xbR38nyVZOAkF/s09riQr8DmrnwecIPO9AapBPonkEfhD5J3dFqTtFBP5v5Atw9vyM\n", + "2XThCB6QCH4C+RH8NqqK4D23ImcE0hfEVuYkCfwu8L4L3sXIyMyxlc8Dlb1YshiHVPHspTKCr5VF\n", + "s4DoiXAScsViBb4F6b3yfcLS0U4IfHABBK/p2GsLowKvdEnK8OADpKXm40hzoKOyF6+gK3vwIAM4\n", + "ZlKORZM0GtMKvBvBu4lXCJOslvVEZ1Nyn38CGArBqRA8KP9TsZMu7CNaB19rgY9H8IsJBb5V7ntX\n", + "G7sKOhfBv4xwLEMHCb4KwSkZCxQU+MAzuRZFqQtl1ME/gvxI9yANd26B1PkMfef2PPP3FNmDfBrN\n", + "U0iviLWEM9AkUcSicT14i/XgJxEOfEiK4N1jtI7o1HSOReMdhuAupGnSDqS/9YMkcwLyvkzTt6AH\n", + "0BM5WeQIfNAfGAfe0oTnPgI8Ct7vncd6IyK4mEqBf5Qw59BK5ajezgj8dAo1zgouRN5P0mjIU5AT\n", + "00MpLx5UcP9eDrwBmfFIUdKYS0kTdZch8O6P8Q9I97e05mF+5UPe5SXsQy15EukZs4PCEXzQCpwH\n", + "3i9jyyRF8FbMj0BambqPWZIieGPRBL2obCvwA7Pfm4nPUdpO8E5kCr1LCLt69kUsMyv4HtKPvBW4\n", + "BTy3u93lSJ/3pPVfiAi2I/CMNvuzifYTYdADySX8lGgEX6bAzyD7c7O8CznuSQI/mOj0jXEGAQPl\n", + "JOZldU08nerLWGtEMB74EXgF8zVKHZlHtL32x5IXy6cMi2Y0oQc/x9zuypZLtSxGousRZAvFLkQU\n", + "eyOi9/OEy/qECN7bh4jqMaRbNPFmZOsILRrrzzu9LLy7wfsMYpsdTwXBSKQT5lngPUClwNsunwOR\n", + "hO0NVA7iOgU4GYI+sXV7yAlxdmz5MWa/nwMGmOM0knBSD1fg48e5gwIf9CGcWCRruUFI3iJei28Z\n", + "RL7AQ/4+npCxjXozGTjHzJyldFOKCPzNyPD4WUid9VuRWZOuMs9fhpRQPoY0se/qEXmVeG1IO4KT\n", + "yayi8QLCKH4s2F7WkR9QWkfELUgiN62KJsuDz+pE+SQwK8H3nQk87dgrNskaF/gWxI//CTDd2DKW\n", + "U5CTebyf/Xizv0kCv94cp21IFG9n5dlNNMlaVgQ/GfmO54nqhciAu7QTQZEI3i6XxYkF9qVejEA6\n", + "mY7PW1BpXooI/BVIMq4P8oO8DrjW/IFMFHAM8kM/E7plI6enENHOu9S3Aj8GmcWmjajfmlZquRnY\n", + "Ad4O535SmaRlIzI4qieZyV9vD+Ecmy4ziE6gnWTRWIHfJV0zWUj7HJJBb+Qz/wViO7gcjQQEk2W5\n", + "wINgAO0CD4StByZRKfBJFs1OYFBs8FcCwSwI3Fl2bJfPPFF9JfDL5OWCHmaf8gR+H5mJ1mAMYs8U\n", + "60Nfe+wV4tSG7oVSU7rCSNZmwDYDymtXayPTMUhC9k5kjkfCKDrRo91MGL1DmHi1xETcO4iI5EiS\n", + "LQ2Xx6mc3Hc62QK/39x3xVYmyxaOQko6/0TltGLHmGXXIA3VXo4kcl9NKPC2eVhSBJ8g8F6b2cc8\n", + "ob4GmYDBfZ9uAjeBoB8y3dtNKcu1ILbaQAiyLJxVZFfS2Dlru1IED/IZNSlBa6VFqLiowBfDzghU\n", + "NIIfi4iZa7VkDZRKEvi4RROPaq1NkzdZyBNU+vAzIDLBghX0flRaNPY9P0w4WvMUc/8ftEfwgY0E\n", + "j0ZOiAuRK4eLkNlvjias87e9ZY5A3vdu2VbQB/lOJs2pW8SmOQV4qWktYd9nnqhORI7/cpKj60HI\n", + "57qC9Ci+iMCfSPuE1HlXInXBzkHQzBH855EJM5QUVOCLYSP4aiyadUR7qNjZnJLYQih+kJxkjW97\n", + "HXIiyavPT4rgYxaNdwiZE7OVqMCnRfAnIwK/GBgMwReApRCcRSjwi5Crl/OA/0OiaTs9n73SOROZ\n", + "09RG8GZ7idMX5gh80Ae5enjUbNO+z8fIFviRSGXPrpTlBiMW0XISBT7oSTgaOOsEdAJSZrmfcMxB\n", + "DsGZMjF7TRhh9qeZBX4EkmdRUlCBL8ZSRLx35iznWjTVRPB3EJZIEn1d4JEdwSc95/IEcEIYNQYe\n", + "lR48hB5yggffvp7ZEPRFIuWHzAQd/0RaWXwU+F/EvrER/CVIInahVAu121NbEbE82rx+F3J8sq5G\n", + "8iL4o5GmaTcBl5rHpiMnuH4Z1SKjkJxGmsAPMttOEfj2Y5Qykjn4AAQ3IPOePpaxnSTegVwBdZJg\n", + "HAQ/jD04Ajm5NrPADyKcr0FJQAW+EN4h4Ajw8gQ+yaKxg3qSBjnZ9f8BvDucB3YDvUzVSh8gAC9u\n", + "WxSN4Fchn7Pt+TIa2A9evP3EPkRAUyJ4by9yovsRYWQMMi3eC5B5NCfL8t42ROBPB/6YEJFvRcT/\n", + "AVMmGovgE8kTeHPS4RbgZcYymoAI8x4kyk7CRvB75D0H8bEhORE8g8zzaSOZX4mI/5+QY1KNwA+m\n", + "nKTsNOBFscdGII3pml3gtQooAxX4wuSKO8iPfAIyGnQn0Qg+bfBX0rYCwkqaNAG3EfzRZI7U9AKk\n", + "quVM80BS9A6VAt8vYdvXI8nj48I2At4aqf7x2pAo3s4Yb+ez/GPCtrYhNs/d5n5Rgc9qg2yvKtYi\n", + "A6z+CvzDnBh3kS6UI4GN5ji5yV6LFfA0gbcngASBDzwkD/EJ8N5kkuPPZexLnEFVLJvFMCqP3Qhk\n", + "dO6AKttLOwSvgaDDg3BKYDAawWfS6Cn7uhvbgXNpr/cOXIG3UX1R7Gt3kCx66xEr4ngqPfY4/0Cq\n", + "XX5KZQWNZS+ZETyA94XszXg/geCn5s5mRNyT5qy0J7okgU+7GikSwRsbwntj7LmsqHkUYYLbLudO\n", + "VZhn0bgRfHz/hiO9mrYU3Jc4ZUXwRuADz7maGoFcuSxDovi8SdCTmE1jrwDMCGIlDY3gy2Ubklhc\n", + "Z+4/h/i/fQgTr0XJi+DXIf0qfiZRdCbVRPD7SPbgC2InzvYC8M4Hb3vCQtvMem1vF2uhDCLXogl6\n", + "Q/DC6FNBX+S4P57y2ixRNRE8kBxd2wh9GTAloQLGCvwOKi2amcAzMYuqGoHvQAQfeGZ+YJdhRAZ8\n", + "Bb3NercTCnxHGEVjBdYcn0BFPgUV+HLZjniCJlL3AsKSQHegTxFsLXyabbEOqXz5vwLrehg4ygw4\n", + "OopoiaQlx4MvlfnA58Okq3fIbHNUxvZsBH8m0jrBZRawwuQJkniO7Ah+k7mdJL4mgvd2IEI+KeH5\n", + "NA9+FtKNNL4vRUV7cMZ+p3ECMv7CxeaBBjn3t5qT8TLgwxA86ZS6FmUkNRf4oC8E8WOOU720CrVp\n", + "UlGBLxcbrbpCbq2WsVQXwdvXpUXRS4BTwVuZ8FwMby9Sy/8RxMq4K2GhIh58SXgrwItPcbcLOQnm\n", + "CfxMYFwskp5ItMw0TjURfHw5G8GDHMNjYs9nWTQmgi+8L3E6YtGMojLxaLuc2v0bgVwhgpwsb0Rs\n", + "snh7iTxGkp68roLAg+BbZtRwnIuB7yU8bu28NWiiNRUV+HKxlSmukFuhrjaCt7XwKVG0F4BXjW96\n", + "H/BfwOvB25zwfD0j+CR2IxU+RQS+D9FxAhOQH3oaeR68G8HHBdV68JAv8CkWTeF9cQj6EI4mroZh\n", + "yJy+vWKP2X2FsHII8B4F7ytIwtWdRAYIjs/pX19WBN8H6eaZNO/uJKJzH1jscV9LagQfTIfgyyXs\n", + "X9OiAl8uSRG8HexUbZJ1BVLeVlYUfT3wZvDuSXk+rw6+1uwmu9+PK/Agom6xLQ/ScEQ1OD4Uv8Aj\n", + "TDbGlmunSAS/g3QPflHssaIWjRVjs2zQD4I5BV43FBl7MNJ5bBhwmOQI3mLLbl1uoLLXkEtJEXz7\n", + "wK+kSHwicuKPY4/7symvAziWUsYR1IugT9mjnFXgy8UKfDyCtx58NRaNFZO8VgQF8R4D78aMBZIi\n", + "+HoLfFGLZjXRH3XBCD6YiozIfRaC1yKCvNc0U4Nki8ZGiiC5g2NTnt+JJPzMbyroiVQsxfMdRS2a\n", + "QUQ7XJ4FfKPA66wd44riMOT42JNGksDbyeVdxpJamhr0MOspI4K3J4k0gR+ZMFCtQATPaGBsF2kN\n", + "UYSfAi8uc4Uq8KXi2QqUuAc/DvmhVtMnfwFSGTKY+ohsgTLJmlJE4IchpYr3EBWDohH8eGTk7NVI\n", + "22vHqmhfLqmKxlo0TyPtl137wwiNdyj2etPjxouPXi4q8IMR0bXrG0axlsnWjhkTe2w5VUXwQW+z\n", + "XFqN/BBEP8oQ+LwIvgeV9o0V+KwIfjRh+W0zMBrpz1QaKvDl8xjRhN8WpHJlQ1hCWARvJyI+x1Ef\n", + "kXUtmhonWRMpIvCzkZPnUqqP4FsJ56C9B0k2jyZMsNrlMiJ4bzcSMU5Pfj7iw88iuRy1qEVjBX6g\n", + "iUCHUWxi76FI7X08gl9OdgQft2hGIlZPmsCPMvtXhkWTFcFPQD77uE1jrbO8CJ6M5w3BCAjeX2RH\n", + "a0wrJc/4pQJfOt4ZsSTmFnJHm6byJDJAqR4iu4+w2Zj14OsZwe9CJqDI8uB7I0nLNbR78IFH8SSr\n", + "qWTy1iG196cRjeDTqmjcgU9PErVpXIF3ffiTSB48VI1FsxX5PAaSGMEHM2RC8AhWzI24Bb3M9lZT\n", + "nQdvrwDSBH4kUqLYL6X6pRpsBB8T4sAm0x+nUviKRvBQmVuIcxLhBEaNZBAq8E3HVsLIs1rmI5ds\n", + "9RJ4j8Z68JAdwYMI/FrCH/VQoA28rBORFVUbwYNMRH4hlRF8UhWN26ZiPtFEa1oEfxrJk99UY9HY\n", + "UcwtyPvsa/rXW14NvCUmsEORNhFW3IaY9WwjP4If4/jVRQR+I2LtFeyOmUqaRTMOmbDlWSojeFfg\n", + "42WzljFkR/iWiUQngm8UrSQnlDuMCnzt2YJEntUkWC22D329LBoIBb4FaWWxL/UV5ZIj8F4bIiZx\n", + "gc+L3u06nQgeEIF/IZUevCO+QW/EqnJ99L8Ab4TALT10BX64EZvTkWZeSftStIpmp7O83Z5r07zM\n", + "7K87acdQJFdghcL2QNpJNIJ32yfgNH2zXndRgTeToXSKAWZdcYG3uZWNJAv8DjNr2R6SSyxHI+2j\n", + "8yL4icCQxs5PG1g7TCP4JsP+kDpq0UD9IngIBX4gFZN515S8CB4kEo1ZNLkJVohaNG4E34tsi6YV\n", + "SaDGJjTn18CPTeTsCvzfkcm7JyE+uDuJS3xf8nAjeFfgjUgHwxGr6A5kMhHLMKIRvBV4t1mbeyXj\n", + "4to0YxBhzRL4TSQ3aKuW/ki1UZrAbyDdg4f0KN0KfJEI3qNYjqNW9EW+jyrwTUZnBH4RcIj6RvD7\n", + "EIGnTtu1FBH4OxFfexvQx/QgKRLBuxaNjeBtH5wsiyZuz1g+iIjaN4kKzc+AVyFXBvennBw7K/BW\n", + "hM4D5iGN5E5yXpcTwbdXxyR9H+MC/wzZXTitwHc20WpbDrTGLKgJpAu8+9m4V3SGYABy5byIfIG3\n", + "wULSVUC9aEWCAhX4JsOWRnbAovH2IZNnJI08LRsngm+f4ale/juEAp+xTe9N4JlOne3JNSsCWcSS\n", + "rGCaoC0m06KpSLDa/WhD5po9lkiDNG+FWecHSbZnoOMWzVBE6KzAX4i0RXZm2gr6IqK2lNBiiUfw\n", + "Y5H2yAcTtukK/FhEHPMi+DIsmv5mPfFErxvBpyVZITnROho5iT1LMYtmF3Xx4YNzIXh7whODkEBl\n", + "eJlWkQp8zfH2IV/ejkTwAGeC91T+Yp3GNura7/yvZwS/Czmp7M9b0LAWEfeJFIvgRyJC4o5FeC1S\n", + "MmmJWzRpETymjPV84CpzQrTcTDhTVdq+dDSCd2vZz0FaMT8KnGg83KFIHmCz3A56UenBZ13xuGJo\n", + "I3gj8MEoCC6G4DizrTIjeCvwcaHOsmjiEXw8Sh9NmKDNiOADz2znCeoTwZ8PvCLhcTtOZiclnmhU\n", + "4OvDU0jrgQ5QMVCmVrgevP1f7wg+bT7WJGyTqaIevOnyGfHTH3VGsdrlbGuA/qRG8O2v3wXed2MP\n", + "/hwR5YcSXgAiZP0LlBZaAbP7NAzp/GiTgWMQW2MdYuNNQAR+q4nOtyFWTDyCzzpeSRaNjeDfAnwV\n", + "6QMH1GAAAA+pSURBVPH/r4Q9fMpKsu6l0mqxJ++kJKv72SRF8GOICHzqaNbBiDWynPpU0swmOo7C\n", + "Yq8Ek65WOkwRgb/ObHR+xjJfQy5NHyea8FEA8OaY2uuuTFzg91F/D76a7a0GvoWULOZd4dgTVVJi\n", + "Mb5cCwTjkUj4E+TPwxvD2wCMTS/b9A5TTBTdCH4EMkvYOsSiMRPBeG3mhGVtmmGEDe9s1GtEv73V\n", + "Q1YEv44w2o0L/Cgk5/A64MOEg8TKSrLuoVLgXQ9+VEykC0bw3nOIgKfZYvaEZ9t6FyC4AoK3FFu2\n", + "glnIvALxyZbsmJON1Fngf4hcVqRxIXJGmoHMz/ntEvZLqT9dIYKvZnufRwaBjQUvT7jtVVDeSdZa\n", + "NGcj1s1vSZ5yMIfcq64iNo0r8JMQAbItieOdSY1N0y7mEAq8FX0z5yxTyBb4sRC0ICeUtUQFfhOS\n", + "2N1s1r2Z8iyavUQi8WCoeXyD0wLErXIp4sFvcJ5Ps2nsCc82BTQEvSE4LeU1F5HdhC2FoDcyb/FW\n", + "wjmSLaZiq/4C/zfCqCCJi5FOhSCJpSGUXKyv1IUkga9nBL+a7KvEGN4W8J4s1v7BO4wIUd6J4ADy\n", + "m3gxcAd4Png/Kr5PhSki8G6S9QhCgbe/L1fgbQQ/lPC3up5Q4LeaSH8n0t8oTeBXIcHaBPP655BW\n", + "CT2Izl37SeQKYj/lWjRrCIXPjARu/3zj1kWRCN4eI8d6ClpMozmLjeBtU0DLFUhVVBInEu3WWZRp\n", + "yHt8ikqbxlo0SXZUhynDgx9P1NNza5SV5qHBEby3CLzLa7iBXeRG8F5gljsfCWxqRZFKGjeCPwIR\n", + "bivwSRF83KJZB1xCeHIAEcSjSRV4bwVykv0veX27ndSCiKstKb0DuXqCci2aRwDbEvlkc9/iCF/7\n", + "bE67nOeGx3rXp0XwZwA3Q3CKue9aNG6S9d3ymniuJBiA2CwjqJ5ZyBiFJVQKfE0smrIm3Y4nMNIS\n", + "Zb5ze575U7oGSR58PS2aWlNA4AH5kQ2nY5NQV7Mvtj99T2CE8e4NgUf4g7cWzRJCH90mEC3Lzfpm\n", + "EpbUfgnxys8lFPQdiOBnJaU/hgzY+rW5v5NwhKWdJCRAau0hnE8XCMZIGWvV2Ah+EdLbZjIi8Lc5\n", + "y2wA3mBE/GFkEJ6d//cgBBuR42Lfm3uMXAtnPCLmX4PgLETg/0okgg9OQk4IuxAhd8dKHGv21RH4\n", + "YLhcUeYyGxH4DSRH8DvluZsuIqqVHaaMCH4tUT9pgnksCd/5m1fCtpXyaHSZZK3ZRb5FY5f7Rzhf\n", + "bM32xUbwHwEWQXCy8/xAZDxCG+02ScSiiUXwXoBE8S+mPYL31oH3XvCGg2dH1O5Egq+ME513HxKh\n", + "2/Xb8sp4a2WLieCDEcDiYo3HKipaTATvBYjYnoNckTzsLPNl5Dt6A3Aplclv17/3iAq86yqMA36A\n", + "BLefJZxfwI3g3wV8h8p5B0DsmXm0WzTBVNIrpuJYgc+J4F9/iKhWdpgyBP5W4I3m9unIl3BD+uJK\n", + "F6XRSdZa80XggQLL7aK29gy0V8YERyC96T8K/B4COyeqWwJoT7JZHjyInTGL7HzZDnld7snrSuQK\n", + "AERIJyAnnKRJzW2SdRzhYLIMgnOBpbEqEptkBUluX4wItDMblncveNcAHwA+TaXAmwqcoAfyWe8l\n", + "LE1eTRiEjkME/zJz+3TkCshU0QSe2f5NJI6Q5URk/MFQc/U1ieKTisw27ynPoqmrB38zMp/nLORA\n", + "vRVprWnba96O1OcuAa5FvCul+Wh0krXGeDeClyV+lseR73Qt+SUiQrcBXwfv68B3EWGFaALRnmS3\n", + "EbVo4gL/qPmfNanMTvIHhQHeavCWOq+ZTnL0DmGS1Y6cnZa8WOBBcCqSuBxJ9KrfWjQgAn8p8ERs\n", + "AJnlp8ixSIrgxyFR+anA2c4Yh9VEI/hn5arGez0wCrwlhBbNWEQXV5Es8CcgfYx2IkntcYSdVzMI\n", + "PEIPfhkwNXa1Yz/zunvwVxRY5r2d3RGl4ViBP2D+/4RiEW83w3tHHbbxCwgeRKyAz5kHb0GO+b+T\n", + "H8EnCbxNSOZF8AUEPsJORLQ3pjxvk6w2cp+G2CwOwRnAL5DJtd8NvMcst9wsYJOsIDOZbSVqzzh4\n", + "hyD4b+CVsSfWIhbVmcCRsZO5W50Ta7TWPnfDDkSkT0GqdwIIYgIf9ELGXTyB5DpGOM+PIDsguhD5\n", + "jW02695KtEDFRvAbZF+De4DbwPt8xjpzKSvJqjQ/e4A7w5Ge3s0N3Ztuj7cCqVaxPIaMUp2GJBhX\n", + "mMddgd+FiOF4Km3QRUgUnCXwOwlP4EWxEXyawNsk6xhkYu+kCP4VyHia/zHidr5Z55/M804E7x2G\n", + "4I/Avem75P0WGaPgshYp3/z3hITnesR+6UtqJ03vMATbkaS0TbCvJVrvPlXW5T0HwSbkSsRW54wg\n", + "PGEZgqORmvmdwMeBi52R1EsI/X8Ip37cCcGxyPHcTidRgVcM3kGkQ6HSELzDEPwB8X+vIbxydgTe\n", + "OwyBLbGM93M/BMGrifjWFfyCyoq3PHYik5fcl/K8jeDHIJHt1IRlTgE+FxM390TgRvCA94Yq9xFk\n", + "1O3TyGjbGN4hCNYjNs1o0pPMW5GrgM+a+0mtE2zC2kbwrsDH+TRi9wTAq8D7h/PcY0gi+c/mvjN7\n", + "mreI7M+xMCrwitJ1uB34PvCwIwauBw8S1e1N9qe932ev3ita7eGyExHtW1Ket0nWMUh55anRp4Me\n", + "VFbELCWsd4dokrWDePdJI7TELpkgkfKJyACttKuYLUjE7kbwrsCPJ6wQ3EQo8KuoEPjgCOAsYFLK\n", + "yOYHkY6klppMj6nNxhSl63AXIpafCh9qH4Vrk6fb6Xhn0o6wE0kiZlk01oO/l0qLZhqwHTw3SbuU\n", + "aBWJm2TtBKniDiLwp5FdKrsV8clt9Jwl8JsRi2Y8cuUSj+CvAm7MaFvxENGTYUbn0o6jEbyidBm8\n", + "7RDMosLL5YeEwrKDUsSwMFZ00qporEXTExG6fhAMBs8miU+hMmG6FKki8YxtE7NoasIaign8fOdE\n", + "sQUYIJ1Fvb2ImD9jntts7o9DKg1tXXwPJNH7NqSnURrPIKNvR5hEr0bwitL98ZZVtkz2/s2pQW9E\n", + "BA/FkqzraC8BbOdkKgYCefYkNdqMTO0B1HJgGUgEfzLZAr+FyAjmyMQyUGnRzETeh2vR/AYpF/+U\n", + "8dJT8A4jlU8nm+RvD4rPhVAYjeAVpbnoagK/G6kHP4zs21LElrF1+acgycY4drDPHiSnUOu5f9cg\n", + "J6Isgf85MumMi51Yxs4Z61o0x5n12YQrSK+b4wq2bHgQsWkepmLu33LQCF5RmotF5Pe/L5M8i2Yv\n", + "EijayVSswJOSYLXY5ephz0BYjpgh8N594MXHfrg+fDyCn0BE4IPByEmk6Eh+K/A1sWdAI3hFaTK8\n", + "z9R5g1bgU+YF9g5BsI+w9HAJErWDzBGxOaURlxX4khKsuRQQ+ERsC4ReiM9uI3N7PJ4lrKiZBiyt\n", + "IhJ/CPg6MnitJgKvEbyiKFnsRKpgsgZI7SYUvkcIBT4pwWqxlTT1iuA3IvZLtQK/ALFiRgNbnD4+\n", + "9opmLaFFMx05wRVlhfl7IzWooAEVeEVRsllBtF47CXdS+ceAGWZWqFNI77S4AmldXEINfBG8Q0gf\n", + "nGoEGGSA15lE7RmQ8QkHkBPGViQPMbO69XsBMqjqXWgEryhK/fEC6eSYiRPBeweQhm2nIFUraRH8\n", + "SkTg62XRICNkvWqH/y9CLJRYBY4XIJH7s6as8jnkPS+tXEUmtyLHQiN4RVG6JHuIDv+/H4l6TyRd\n", + "4NcinvZg6mPRdBDvMBLFv5rKeS5WI2WhIGJ/OlVfIXi293sV01UWR5OsiqJ0FteDB/gn8L/IhNkp\n", + "zc+8gxCsQxKx9Ry41RHuAz4B3B17/EXg2ZPTZuS9VGsBUcvGfhrBK4rSWT4K/MW5/0+k93la9G5Z\n", + "iUyC0YUjeEAEvgcVEbzn7vdmxJNPm82uIajAK4rSSbx7pM1tO6uQiD6vudlK4Ei6fgT/IHCIbPHe\n", + "BCxLmaSkYajAK4pSMl6AzFD1x5wFm0Tgvd1IP6CsAWab6ZA9U1vUg1cUpQZ4Hyuw0EqkfryrWzQU\n", + "mOlrGdVPplJzVOAVRWkUK83/Lh7BF8G7ttF7kIRaNIqiNAor8E0QwTcnKvCKojQKO/1dN4jguyYq\n", + "8IqiNAhvH1JtowJfI4oK/PnAQmAx0ZngLXORmWYeNX8fKWPnFEXp9qxELZqG0hMp/5kM9EaaCR0Z\n", + "W2Yu0lMhi1o39H++MbfRO9CNmNvoHehmzC2+aPBxCM6o2Z50DzqsnUUi+DmIwK9AptX6KXBJwnJe\n", + "R3dC6RBzG70D3Yi5jd6Bbsbc4ot6/wPeP2q2J89zigj8eMJm+SBTX42PLRMgzYUeB24Hjipl7xRF\n", + "UZQOU6QOvsjlwSPARMRLuwC4BemNrCiKojSIIrbK6Ug7y/PN/Q8hE+x+NuM1y5H+yVudx5bQPlej\n", + "oiiKUhA7+1VN6GU2MBnoQ3KSdTThyWIO4tcriqIoTcAFyMwmS5AIHuAq8wfwHuBJRPzvQ6J+RVEU\n", + "RVEURVGalbyBUko2K4AnkEFkD5jHhgF3Ac8AdyLzRirJXAdsIDotWtbx+xDyXV0IvLRO+9gsJB1L\n", + "H6muswMdL3Ce02OZzURkspSnEBfkavN403w/iwyUUrJZjnzgLp8DPmBu/xfwf3Xdo+bihcj8oK4o\n", + "pR2/o5DvaG/kO7sEbenhknQsPwb8e8KyeizzGQOcYG63IFb4kTTR9/MM4A7n/gfNn1Kc5cDw2GML\n", + "keQ2yJdkYV33qPmYTFSU0o7fh4heZd6B5pTiTKZS4P8jYTk9ltVzC/AvlPT9rIfyFxkopWQTAH9C\n", + "pkCzEw+MRi6VMf9HJ7xOSSft+I1DvqMW/b4W49+QgY4/ILQT9FhWx2Tk6uh+Svp+1kPgtQdN53kB\n", + "8sFfgFQsvTD2fIAe586Qd/z02GbzbWAKYjWsA76Ysawey2RagF8B1wDPxZ7r8PezHgK/FkkkWCYS\n", + "PQMp+awz/zcBv0HGGmxALt0AxgIbG7BfzUza8Yt/XyeQPdmyIsfOitD3ke8n6LEsSm9E3G9ELBoo\n", + "6ftZD4F/CJhBOFDqteR3nlRCBgCt5vZAJGs+HzmGbzKPv4nwi6EUI+343QpcjnxXpyDf3QcqXq24\n", + "jHVuv4LQn9djmY+H2FoLgK84jzfV9zNpoJRSjClI1vwxpIzKHr9hiC+vZZL53Aw8i0yKvBp4C9nH\n", + "77+R7+pC4Ly67mnXJ34s3wrcgJTxPo4IkZsP0mOZzVlI65fHCMtMz0e/n4qiKIqiKIqiKIqiKIqi\n", + "KIqiKIqiKIqiKIqiKIqiKIqiKIqiKIqidBf+P41gkbjYnj6JAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(np.vstack([train_loss, scratch_train_loss]).clip(0, 4).T)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's take a look at the testing accuracy after running 200 iterations. Note that we are running a classification task of 5 classes, thus a chance accuracy is 20%. As we will reasonably expect, the finetuning result will be much better than the one from training from scratch. Let's see." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy for fine-tuning: 0.570000001788\n", + "Accuracy for training from scratch: 0.224000000954\n" + ] + } + ], + "source": [ + "test_iters = 10\n", + "accuracy = 0\n", + "scratch_accuracy = 0\n", + "for it in arange(test_iters):\n", + " solver.test_nets[0].forward()\n", + " accuracy += solver.test_nets[0].blobs['accuracy'].data\n", + " scratch_solver.test_nets[0].forward()\n", + " scratch_accuracy += scratch_solver.test_nets[0].blobs['accuracy'].data\n", + "accuracy /= test_iters\n", + "scratch_accuracy /= test_iters\n", + "print 'Accuracy for fine-tuning:', accuracy\n", + "print 'Accuracy for training from scratch:', scratch_accuracy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Huzzah! So we did finetuning and it is awesome. Let's take a look at what kind of results we are able to get with a longer, more complete run of the style recognition dataset. Note: the below URL might be occassionally down because it is run on a research machine.\n", + "\n", + "http://demo.vislab.berkeleyvision.org/" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/finetune_flickr_style/assemble_data.py b/examples/finetune_flickr_style/assemble_data.py index b4c995e8eae..09bfa2618a4 100755 --- a/examples/finetune_flickr_style/assemble_data.py +++ b/examples/finetune_flickr_style/assemble_data.py @@ -9,6 +9,7 @@ import argparse import numpy as np import pandas as pd +from skimage import io import multiprocessing # Flickr returns a special image if the request is unavailable. @@ -27,6 +28,7 @@ def download_image(args_tuple): urllib.urlretrieve(url, filename) with open(filename) as f: assert hashlib.sha1(f.read()).hexdigest() != MISSING_IMAGE_SHA1 + test_read_image = io.imread(filename) return True except KeyboardInterrupt: raise Exception() # multiprocessing doesn't catch keyboard exceptions @@ -48,6 +50,10 @@ def download_image(args_tuple): '-w', '--workers', type=int, default=-1, help="num workers used to download images. -x uses (all - x) cores [-1 default]." ) + parser.add_argument( + '-l', '--labels', type=int, default=0, + help="if set to a positive value, only sample images from the first number of labels." + ) args = parser.parse_args() np.random.seed(args.seed) @@ -56,6 +62,8 @@ def download_image(args_tuple): csv_filename = os.path.join(example_dirname, 'flickr_style.csv.gz') df = pd.read_csv(csv_filename, index_col=0, compression='gzip') df = df.iloc[np.random.permutation(df.shape[0])] + if args.labels > 0: + df = df.loc[df['label'] < args.labels] if args.images > 0 and args.images < df.shape[0]: df = df.iloc[:args.images] diff --git a/models/finetune_flickr_style/train_val.prototxt b/models/finetune_flickr_style/train_val.prototxt index aa9c73e17ce..848a426c914 100644 --- a/models/finetune_flickr_style/train_val.prototxt +++ b/models/finetune_flickr_style/train_val.prototxt @@ -374,6 +374,7 @@ layer { type: "SoftmaxWithLoss" bottom: "fc8_flickr" bottom: "label" + top: "loss" } layer { name: "accuracy" From a6cb8ec62cb6f92f48e8a19da3c71902d3282bfc Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Tue, 17 Mar 2015 19:01:02 -0700 Subject: [PATCH 074/331] [examples] sequence and revise notebooks - combine classification + filter visualization - order by classification, learning LeNet, brewing logreg, and fine-tuning to flickr style - improve flow of content in classification + filter visualization - include solver needed for learning LeNet - edit notebook descriptions for site catalogue --- examples/00-classification.ipynb | 13187 +++++++++++++++ ..._solving.ipynb => 01-learning-lenet.ipynb} | 4414 +++--- examples/02-brewing-logreg.ipynb | 5771 +++++++ examples/03-fine-tuning.ipynb | 947 ++ .../Finetune with Flickr Style Data.ipynb | 951 -- examples/classification.ipynb | 3342 ---- examples/detection.ipynb | 2 +- examples/filter_visualization.ipynb | 13214 ---------------- examples/hdf5_classification.ipynb | 6290 -------- .../nonlinear_auto_test.prototxt | 54 + .../nonlinear_auto_train.prototxt | 54 + .../nonlinear_solver.prototxt | 15 + ....prototxt => nonlinear_train_val.prototxt} | 10 +- examples/hdf5_classification/solver.prototxt | 5 +- examples/hdf5_classification/solver2.prototxt | 14 - .../hdf5_classification/train_val.prototxt | 7 +- examples/mnist/lenet_auto_solver.prototxt | 24 + examples/net_surgery.ipynb | 2 +- examples/siamese/mnist_siamese.ipynb | 2 +- 19 files changed, 22296 insertions(+), 26009 deletions(-) create mode 100644 examples/00-classification.ipynb rename examples/{python_solving.ipynb => 01-learning-lenet.ipynb} (53%) create mode 100644 examples/02-brewing-logreg.ipynb create mode 100644 examples/03-fine-tuning.ipynb delete mode 100644 examples/Finetune with Flickr Style Data.ipynb delete mode 100644 examples/classification.ipynb delete mode 100644 examples/filter_visualization.ipynb delete mode 100644 examples/hdf5_classification.ipynb create mode 100644 examples/hdf5_classification/nonlinear_auto_test.prototxt create mode 100644 examples/hdf5_classification/nonlinear_auto_train.prototxt create mode 100644 examples/hdf5_classification/nonlinear_solver.prototxt rename examples/hdf5_classification/{train_val2.prototxt => nonlinear_train_val.prototxt} (87%) delete mode 100644 examples/hdf5_classification/solver2.prototxt create mode 100644 examples/mnist/lenet_auto_solver.prototxt diff --git a/examples/00-classification.ipynb b/examples/00-classification.ipynb new file mode 100644 index 00000000000..46bbb193fe7 --- /dev/null +++ b/examples/00-classification.ipynb @@ -0,0 +1,13187 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Instant Recognition with Caffe\n", + "\n", + "In this example we'll classify an image with the bundled CaffeNet model based on the network architecture of Krizhevsky et al. for ImageNet. We'll compare CPU and GPU operation then reach into the model to inspect features and the output.\n", + "\n", + "(These feature visualizations follow the DeCAF visualizations originally by Yangqing Jia.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, import required modules, set plotting parameters, and run `./scripts/download_model_binary.py models/bvlc_reference_caffenet` to get the pretrained CaffeNet model if it hasn't already been fetched." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Make sure that caffe is on the python path:\n", + "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", + "import sys\n", + "sys.path.insert(0, caffe_root + 'python')\n", + "\n", + "import caffe\n", + "\n", + "plt.rcParams['figure.figsize'] = (10, 10)\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "import os\n", + "if not os.path.isfile(caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'):\n", + " print(\"Downloading pre-trained CaffeNet model...\")\n", + " !../scripts/download_model_binary.py ../models/bvlc_reference_caffenet" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set Caffe to CPU mode, load the net in the test phase for inference, and configure input preprocessing." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "caffe.set_mode_cpu()\n", + "net = caffe.Net(caffe_root + 'models/bvlc_reference_caffenet/deploy.prototxt',\n", + " caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel',\n", + " caffe.TEST)\n", + "\n", + "# input preprocessing: 'data' is the name of the input blob == net.inputs[0]\n", + "transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})\n", + "transformer.set_transpose('data', (2,0,1))\n", + "transformer.set_mean('data', np.load(caffe_root + 'python/caffe/imagenet/ilsvrc_2012_mean.npy').mean(1).mean(1)) # mean pixel\n", + "transformer.set_raw_scale('data', 255) # the reference model operates on images in [0,255] range instead of [0,1]\n", + "transformer.set_channel_swap('data', (2,1,0)) # the reference model has channels in BGR order instead of RGB" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start with a simple classification. We'll set a batch of 50 to demonstrate batch processing, even though we'll only be classifying one image. (Note that the batch size can also be changed on-the-fly.)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# set net to batch size of 50\n", + "net.blobs['data'].reshape(50,3,227,227)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Feed in the image (with some preprocessing) and classify with a forward pass." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is #281.\n" + ] + } + ], + "source": [ + "net.blobs['data'].data[...] = transformer.preprocess('data', caffe.io.load_image(caffe_root + 'examples/images/cat.jpg'))\n", + "out = net.forward()\n", + "print(\"Predicted class is #{}.\".format(out['prob'].argmax()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What did the input look like?" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvVmsbdt2HdRnvaq99ynuue/ed1/pV9i4iJPYDk5M4gQ7\n", + "sp0gSIICMiYSIQLxgfiAD0Dwg5QIIb744yeKkq/ABxLIwrISMDikwibGicv4xe/Z7913i3NPufde\n", + "xSz5GK2N3uady8/KVm5OYkb/OHudseaac4wxxxhzjtZbbz2bpsmSJUuWLFmyZMmS/eNb/qorkCxZ\n", + "smTJkiVL9s+rpRepZMmSJUuWLFmyO1p6kUqWLFmyZMmSJbujpRepZMmSJUuWLFmyO1p6kUqWLFmy\n", + "ZMmSJbujpRepZMmSJUuWLFmyO9pH8iKVZdkPZ1n2K1mW/VqWZf/pR3GNZMmSJUuWLFmyV23ZP2kd\n", + "qSzLCjP7VTP7QTN728x+xsx+dJqmX/4neqFkyZIlS5YsWbJXbB8FIvX7zOxL0zR9ZZqmzsz+qpn9\n", + "ax/BdZIlS5YsWbJkyV6pfRQvUm+Z2Vfl/19DWbJkyZIlS5Ys2e8oKz+Cc/62vsIsy1JemmTJkiVL\n", + "lizZPzc2TVN2rvyjeJF628w+Kf//pAVUambVxc6ay62ZmdWXO9vcvzIzs1E4W3keALNzb11Z4e3J\n", + "yiL8tvQjx2KanSMch98UZ06Yh++yTM6Lz7l5Wd/3oWwYYtnUn8Lxo1+/5PfT6Ocb8Vu8R1ZyS3q0\n", + "ezI/Xn/r1USdpJ/GcWSFF8eZnC9Hn5EXF39nZtMU6tt1XnY8hPr2Qx/LBrRLR9NkHcq8r4sidHJZ\n", + "1vby7YNdvrWO96JufNitVnU4DvekWa3id3VVhbJ17WV1+FyX1aKskHvdd6FO+9t9LHv+8mBmZi9v\n", + "bmLZ6Rjadjodw7UaP2/G8aTjJQv9M2pZMeAwvyf1KpynkhnG9o+j9yeqacdTOMcwnfx43K8x87FW\n", + "TKGtgw6NAfdz8ErlebhwkQ9SFv42lfcneyzPUNHe2zD04frsIzOztg3na09+XNdyPE12++7Btm+s\n", + "rapD2Wrl/VmuwvnqrXdKHudp+Nt3PrKmAceNfjyHvc61yPOczgDsMlA5n3Xcx1uRsc0yr3E/y8Lb\n", + "wGV0Kvy4gT+evMxPKKtXG647jX4+joVm42XNJtyf9S6Ube/5/dpdbMIxK++Tug7HDTIoiiL0RXmx\n", + "jmVVGc6zu/Q51uD7Qep+i/lxc3NrZmZP3n0av3v/nWdmZvbe157ai1+7tasvbC0/oF8LvXdYz3qv\n", + "Z9dyTZT7xMvKuJvQjhx9k2XaLq4rft4C85Rjycwsx1qfyzzNePMyeSZgTLRy/SwP/ZlV4bi89nat\n", + "LsIJq42feLUNn7c7v0/NCt9PfhzHna6x/TFcd//S59j187AGjIdw/ZtnBz/HKfx2kHPwmVkIPjEa\n", + "nydShjkmzbcC3ajPyd2j8Fy+euN+LPvgVx7b57/vM1ZjQeu4cJk/EyYZ6y8wdt771cexrLLQr/oq\n", + "wnk/FfKcyrhOyvOM9UNbtxu5JyuM9dzLiqJF+5ZrzWTyPMN8P7Z+/WEM53v5uLPrx+Fe5HVlb/+8\n", + "z4MP20fxIvWzZvaFLMs+Y2ZfN7N/08x+9MMHNVcXdvGJj30El0+WLFmyZMmSJbu7XTxq7OJRY2Zm\n", + "1cX2n+6L1DRNfZZl/6GZ/aSFvfxfTBF7yZIlS5YsWbLfifZRIFI2TdNPmNlPfKNjVlc7U6bUBNhT\n", + "1RgmHKBlWYQgBUbGAdnMtcUPctGc54gXWJxD3WNERSepaAWsWF0LPc6TictgwI+LM/ISuRwV25Wx\n", + "3gJPG1022ikfqq+ZZWiQlhHS1eb48Us3Jv1XhcCjFaDtSd0o8VrugoqnkWqOcEsOw2jltrBhGCNU\n", + "m4mriuehS41uQjO/13krx9M9uhI3FqD/KRcYGz8Zte4o1Pa0La8H94S4bPPoCRB3L13Acq3YZ7P+\n", + "BDwtJdNEyHoJ948Dz+vfZXAL5NqvqHsm49/d4YMcx8Huv6VLtarE3Yyx28KNK91vHdxsvSPh1sIF\n", + "2fntj27GPM+tvqgty/LojlE3QhzbOp/jmEDBpD7TM+Max49yHKH6PNe5w75eusfVxnx+/aKS/s/j\n", + "pPTz0s0jbqyCa5f4gOlaGUdxAVa4dzNaQCg7iaukexbOd7wJ7omX1+7aefh6aNfFlbvsNsHbZ6ut\n", + "u+w2cNltH+ykLLhsVuI+r9Zh3rWDXz+vwzihq+7UtvG72za4bO5PF1blpe3eXFt7G+q7f+H1HA7s\n", + "u1hkBdaTvtN7EsqyMwsV+78SNz77NctlDOMapXAlSMNVd1+BeZfJoIxjN9MxhjmJcV82MtYyXktc\n", + "q/icK90E9csmnc90I/r971u6++RZEMduKMtl/E0Z56RPykgZMDHUJZPJxqVF3Z10AVe1uODR3lpo\n", + "Dq9/7jWrm8oqnLeuffyxLuqyrA9hzNQy1iZQAMRTbgU9oLJQ5fQ36qMYt4zrZCv0CDYnr/zEOfp/\n", + "VDduzu/kWuXyWj2pEkrLqL7xOvLKlM2bq4tXdelk/5StufhI3teT/TNo9a767Q9K9jvCdm+uf/uD\n", + "kv2OsNc+ff+3P+j/x/bKnnBTXszIyUQCct3CkkOtiEBGwrQiB4UeHo7D30GIitylZni9ne2BCEgp\n", + "+MOdcK67hfC5EmL7Gjum063v6kh2nu2+sWMmUXw0bdfASkYjEDXNCJPYkfWyIyNyN7vYEiXRnZiZ\n", + "EzfNnDCoOzi+rI+jkyi5SxrNd6nTtNzpRcREkQOcWncu/HoiMpTJDu5Icr6SQ7Fbbr1dHU9cyHgC\n", + "cqHk5XEiefoYy0jQjURkQT8qnk+6rQRikUk/EX2sZAfHxuruZ8S1FCTh9ePObNJzcFfr05QIiwa+\n", + "xjkh03mcQJ6vhLy/CfesrBs/DghThWu0rZLISSyXHfSJbfFqxhs7Qx+4S9fxBNRzNvPQ7yC2T6Of\n", + "hAEykxJ2LZNf4QwgByt03XM3r8cRiZVpUscAFB4p8wq777yUOoFkPiNW457klZJ9UQ8h5Y817p0g\n", + "fPw8HmVO7DF2D+hsB3ps7MIP2vZeLOvuh3u8uhSU6j4QqavLWHZ5FdCpfOvnq0pwQHqFCYCSDOHC\n", + "+1shwu/CeS+EnL1fh7m7anydeP5BQK7aG1knunCefNA1AX0iaxfnWJxDsv5xLSilr7OItORyHNCP\n", + "2W8jduFlJGUL6t8BnStBzi91DWUdCyEx58vnCdfTIlc0KxxRCJpVVAzo8X6KgBWHhJCuR/R7rmu9\n", + "Pyi9nlh3lNjtiJ2gqfhNJqjb1YMwth4+8DHGwAdOHkUQix4IltzXI1DUeiszsA5trXIJHomPiTNl\n", + "57w5BQPQ/FoEx/NZYNcyUCfDdTN9TuA3xbqU32JM6uAp5fMZS7n2kiVLlixZsmTJ7mjpRSpZsmTJ\n", + "kiVLluyO9urIK1k2c9nlJACrfy7qHsnP6II7h7QpZk+i8hm3IG0GHJ4jO55hUVOraBqFnInK3Bfe\n", + "V9sF18rpRtxIdMfB3VjMCMO9fhWuEV0b6jKAuyFTNxbPK7/leeRVeYrupuX7M91yucCuBdwyVeVt\n", + "pe5NJ+4JQs+5wNjxEjNdMBTZsu6Ec4de9EkAwZ5Ooq2EIdvPXItwt8j1ed5eNYMwxlSDJmuPaGu4\n", + "1mrlbq+6gXugFngeLt1BIOOSAQgyhiZqQJn6cRYf3ANry3sdv5wN64KN8WvB9aXjuQZUvxEqYgO9\n", + "m0yDHODmjrJnMrG6nhpbSxL/jByKG1uKC4wM+VzhcZxmEDdKHgnlPJffG7pHZvPalm6UGKhiS5vk\n", + "nrA9lZJSS7oA0P8yhopySdgl8VzdfdRsU69sZnT3SfvZbnGLZh1cSzMfZPhzgms1H9xldrgG2T97\n", + "HsvGMtzkq0FuNq5bbb1SxRoaTCs/H3unkH7PDvO1s5TAjmaDOdlpAA7738uuqsCAv33sv715L7h7\n", + "skFc0BkDBcQtBddiEdcVXX857sUVWHBM+Jwoz7iAC2oWyXFxiGnwALX6uNbL/RpicIgXVnAt5+ru\n", + "4vnELce5Xei1MI5qcfe1iPiIwVYyYOIaKg07E08Ug4IKcYFGbS1Zfxswv+vtxstW4TP1+czMNuvg\n", + "0s3i8uN9yPVZ164S2k7rra+nw4nadkvX2kzmklp9+iz0hoVzScCQgQ5waP05MaCPy1L6n8EDM7oL\n", + "6iTrVB2DLfTZda6X3RIilSxZsmTJkiVLdkd7ZYhUkRc2DcsQTpUa4FtqMUNQ+L0QQFk2nnlrVJTm\n", + "Q+S1GYJgy3BV7oQVOSKhrcxlVxvr7CjJGsrDTeZk3/0xqGwP7VIJPIskW1HxRf0GbQR3RDP5gyVy\n", + "RmK17qZIUPad25KcOI+hRVv1rZ7H9U5snTqqnZ/ZpQuzlt8r6jCV87DSQSUkwLrsBf05TmFXq/ek\n", + "sbBzGmXnShLrOBtj4Te7C9+5V5AEIPqhhNlmzbhqr9+EwINON0TcQSlywuop2RztySTUmCHZhBBV\n", + "rsFjHASlwX0f9N5lYdzlog58CTXszT3fpY0gtmaDs415vQH36dj7eU8HhoErARzXnKkIA5HSsOqI\n", + "puk9WaIE/nU2Oyb8J//wQd7qMzIlWuSSIF7G8OhKUMeeqvxn0D/ujGfZBmK7ZWIxglr6n6r4gxxX\n", + "8t6KxITlod/HWa+gPxEUQIQoVDico2uPUrTBaWXusOtkTnS4x2XhaxIDIHqVZGD4N87XK4LZAEFa\n", + "C/qQL8PFG6wZU+F9TUTw8J7PyRLrnpKyiYSXGVF6Cc2vziBSGDOFwPkRYZfxxEsosXygTIJX3TKi\n", + "jUTJJdS+ZFCGQPId1vNxRizHeWXtivIvci2iU4WssVUTrt+d6BHw2h0PGK/5cvxrn0znsmIQOZZ6\n", + "EglralG7LymT4mthhbK8Ivonaz3mfyuSOA2CGNaCfrZELidFxFnfJZ6sS0F83gFW0jkZEflB0Ofo\n", + "EVk+YxWRc/q9lCErQ6UZDRIilSxZsmTJkiVL9tFYepFKlixZsmTJkiW7o706svk0RJeAmUXIfBCI\n", + "mWDaXB8qm39p6qpSbRcqC8slPgTPKZwYtahUiwLnK4XYTS9jIZBtXVLtXMnOwd2iCrwNCMB9hiSj\n", + "onBLz8IoiUdJqJupmJ+h1E7xuxkWuvjtQGgZeiIKD0fkVFybVYP2C4x/CddXq2rXexDQW1Elpzrv\n", + "oH0S/s4ctVEVewl7x2SYmbYB8GzpblQqoJeq4wR3QyXJXYuGV/arXEFUJ3aTuGeohD5KWQd9plzg\n", + "/p59nXsZE2hr8IDBZaAK+BPJoOz3Tnsn9Ke6NqMnVFyiUdG3keTGV+H76lLaT9e3aEVdF4TK4bIQ\n", + "xeSYMUDdWJFYL2OXlxACdtTlkhs6LKduVG0/N65ZNhbuHrA4r5cK9LP5H8nr/tOoWj6L6Mhm9Z15\n", + "DOHGmeR+FXA3Fbm7MSboyOXinumobqNq1yTqqrYR+1NcEAPmZwFtqUF9HND02u7cZbaFtlNR+73u\n", + "EbTRiSp5uQ/XOogLhuvd/saTex9vA5H9gITf3cmTfJuF8c9ADDOzHv2prt2hhrundBGszT2QnU9+\n", + "YHsDV6HohxUlXXqYL5p4G31dDBrEQbe49xMT2Oq9Y+CBlnF5lsdOdNXnVPgW1xqfE7p202W1lfuf\n", + "YT4NMp+oXzSKBtcIjkApdAdSKfoMpHN5JnGdVGI7PcazYCoU5qKjx7mQSwBCBmV7VYUfqIslYzfH\n", + "ul9x7siYzKC3NYg+KwMaaiWbT2E8qQuOuuTq7mNWhtLO3Ke4Jp2hG6gGIeOvVFkel52tCeh2iT+K\n", + "97iSAT2eCUZTS4hUsmTJkiVLlizZHe3Vkc2z+R405lDScGmWnfl9ppIAZ8imfGGeEctIwI4FZxCZ\n", + "cY5/hXPJmzl3Xxrqz6NV7ZobEa3nwB0md9Wy06VcQ+a7Be4qZ+1HG8bpTD1tUTRrIwl7LVSkq1m4\n", + "OpXNvahhuPTaz7G9wg5G3tZ7tOvmpSNSpxMUe0/aJxPKBPUYuOtcEosZRKBq11QdbmULUXOXakJK\n", + "xfdKlCcCqqGu/My/OoZuDmEnvu9uY1lO5GDQXSLIoZOwiKlirArYRD00nJpdwUAAIQdnZ8ihzEW4\n", + "2wrZH9u1R49cxXqoHpuZSx6Yma3Rjy8mRx8+1nyTmZl99cX74VyT7r5JRNeRhZ2u9CvVy2c7PaLN\n", + "M7ItCbi60+NvsdOW8ecq5hIuz4COmdr0ktjOwIpS5QfQt1nm96kE2sVfDoOiVUvCLnP95ZMQ1pHF\n", + "oBfpjojO6RQrl+HvzHGXraXfhwrtQgCMIt1ExHd+PNPyKHLLOXncC3KL3flw60T1AyQWDi8ddTqd\n", + "noW/bUCT2tGPzyM52vtmxZtW+b2mdIPGklCdoZE1oQd5uGpFfgF/i2yJVsSnxizbBMaJoiT4q+sk\n", + "0WwFWGfBDbEM4x6k9EJy/VUrrDUbQe6xdqisRkQ6ZQAQnBokr97pGD4fj94nx+Nc7XyuiLKsrwcR\n", + "zbRuwrX0GQMkaNLkmRnQXjltUVDZWxA+QDcFkSut08DsCOJ9ATrarCWLAjwWvRD14/2ZIUfnnvh4\n", + "dg5nvjJWSYMNeD4ZgHF+yNypiciZlBEBlwCM3/qyHzpjsmTJkiVLlixZsn8sSy9SyZIlS5YsWbJk\n", + "d7RX5trLimyGnEd1lnOaMTOb5N/5b+dkU5Lyzp1lCdTR7TXTswAsqrIvVEVVN55BvVp/OzFBrWCR\n", + "PSDVHgTQbKb7AXK0uqyg7bHfO7TO883hXhLlpYVwQSq0S2IrSZm5/ICeGJEOsRJk882FJEO9CBjo\n", + "Skjcfpxf6/oamjHXXvcWLr1WIOPjAf0DUrreLaqoqwv0HOwb3cLqgsX9r0QxeL0O/an3yV16gL1V\n", + "sRgkUw02IMdUx64r2yhRG24JdVXDzaWkWLrAMtyvTPqfSUgVzd6AHFoI2biGts7rD69i2Yr6PRei\n", + "twXXw+34Fa/7kW4+uGzEPdVFIra4sXG6QtzCMbez3hpqMM36Gvdipu1Tzn48Q+55b4blfFUlbLrj\n", + "dT7F02pARfRKLF2VXk11D9LdrEmboeIs7mby3tXdGbWtJLm5lUzMLi6TD9MNzCyD66fnyBJXTF6H\n", + "41f3fKAMOK8Gj3Q4x2HvxPLjMdxbzbbw8jrc/8PLZ34NJGYukGS2KySh7hTc3FkjbaXLtJRgB7jZ\n", + "JU7D6ns4Tu5/B7fl9KSX3zJ4B641dW0zA4Sf1jXjZs+OKCTkde94/aUbaRgkowLV83NSAbyvV9uw\n", + "hjRXvq6smKBbgk2cjK7XQrCRPhPwsW3FBd5zPFN3z9s65kt3c6R26PMn6mMJtQI8gmnv5yAZvGxc\n", + "R6qKauhC1Gdy92b5ysCgqHwWFoZgFwkoG0BYHyVQxx9aMp/o7ZP2tHhmjnFK6FoLzTh5no1wM+tc\n", + "Lxg0IOt5UfB55u2PSah17dA6n7GESCVLlixZsmTJkt3RXhkiNeRC3DWLW8JCURr8VaSBkaMzVXJK\n", + "B0hINJEAfUvN45s7fydvq9x9z9iufDX23UqPd89OwlVdUVrVVpeE8pjrLubQO0eEc8tB6L6850rc\n", + "p2PYYepOcxipdqs7NxdF8OYQ/Qj9dOplZ4JdpSrclqtQtlp7vzaQGNjthNiNn1S138+yQQ47c+Rk\n", + "XzCcXInqoR0jN72y1awBjw2yWyPJuJNdHWUShkFy8gHZUzkH3otCwpktjh2oEws5ejqzzaAavyqQ\n", + "t1Bb7zMncRdZaHcvCdgq7Eg1d1jcsjOvpOaGxHG17OpWl6FP1jJzqxVkKuS83/XF7zEzsw+OX41l\n", + "77wIYe2vr1+LZY9vQp/16P+xW+7WM7kW0TmdJgTdIuJkJloXsiNlnkj58cDzZdwFahAHyNGqWM2w\n", + "dpGWd4TjTADGbJfOmy3XYP6xidX2nScR1KyT6+NjJ+TgsSaCI1eHOrKqzUdlbZWpWFESQ/qpCGMx\n", + "HzH+BRErkMMuV6UPEK8Hyf95QKBE13lZC2Lz/rlLEpxeXIfvOp87xQqSBJQYEamRsQIyICHsOQDr\n", + "lcmuHujUai3XR469URDG8hbnuZWgoBNJ3pQrEPQBa9Ygj648qtgvA5Bq6X+CTqpKXqAjx8E7lE1b\n", + "I9jGZuhr+LyWm70G0jIVKn8S2t+evO+4yK1WlRSBlK+kePzt6CWZEdZPs/aZCTquaH05f9aZeYBW\n", + "KR6BU0+U3O/TZEESJtOceDHGZul9odr4IM/uzkiUlzytE8tEEoL5BOVZFNcOVdtnRg/8VfmJCS8F\n", + "qljPvJYaFEVCu+ZaLRlsJOsOg7B6OV+Vf+NXpYRIJUuWLFmyZMmS3dHSi1SyZMmSJUuWLNkd7RUq\n", + "m48fSjJM2WMpG+ZuDzNx953R1sjOUNDPiBiLns2SHDoI7FhNhPiWsONJiY1UrBYYmYTB6ZwLCoTe\n", + "GRF2YoLUpRZOLfBkcy/ArkqifgFV4q5TfRD25/JdmVBxVigRHnUU1d2MWkySZLeGa68WsvnuKrix\n", + "RB4l6o0M4ioaoEfTi6uOaus9DquF7R61gGpJfNnBtSBQeAeYl9+FNsLdIrB8eSZpZXRRAIoflZzZ\n", + "E7JWFXMoRg8KhaM9tbpqAwSvQQlZtom/iMYxgHrmKnsNkm/ZiO4V3KeTzNxPvv66mZndW/t9+vrT\n", + "r5mZ2R/9jj8Zy37j7Z8xM7Mv11+PZc/e/lJoI7SFykZ0X0YQq1Vbim48GbvUFtLpxLE9zAIAqOLt\n", + "x5HQHSF4JdZirmmfUCtmnrQ7XsE+bLP5NOUfOt5s6Ofn605yDiRrVtXxOVEd5yUBVtwjUVFaEj5H\n", + "+SoZE3T9FVopunLhYstK1UfDIStVlg5/1T03Yf3rxd29h87b6bmXtfvg5pt6J6AXTThuBc24TCgT\n", + "zNSQibstgws2r9UFhjaKZ4seyr73+1nvMO9ulgRsg7tt5tpCXepZ0Al1lNyGmNxdA0Wwxiq1AN93\n", + "0sbqIsyBuNaJPhTX8Jk+Vc9k0H6tqmFgj2avCDU8nWSc4Ny16FJNQ7gX7YEkag3BoLtT3Zi4J0qi\n", + "ZwYAeQCS2mJn5u4obvFxWrbx1IO2gLGoZG+6jwdxt3ONH4alGy87p98oz93o+lUGRMGAqrnuXDgM\n", + "93qm7E7CvqydJV174tonsVwuFoOxNFPDGb0xtYRIJUuWLFmyZMmS3dFeGSI1WT4j1vJtWXcQGQhz\n", + "MwVwEgtn8rTc1elOI7xhaqhpfKvl26q+GUeUyk/L3cRsRwo06ajhl0BfcqnTSMSil9BhKNXGCFbZ\n", + "mlf5Uk2VobO57GArKMbW9c6PQl6j21snkR6O4Vqt7BJIxou7Snlb5wZyf/Cd6cUYlLJ1F14j/LUU\n", + "JeYCiNWq3sayLZSXu+79WHaEsu2p905+sHsQroFdUC/E3n5kbiqv09QhJ9zB++lEdWiBxMa4Tfdr\n", + "Maw3E9SrqEhKx/UFVDq2Yee+P7iy+R5lp8HrlJ0Ja+cOJp+pkgcriyUBMtKlBaUdOV5lu1OjvgI+\n", + "2Q7t+eLFZ2LZw9feMjOz73jj22LZ937L95qZ2c//3N+JZT/3f/55MzP7rm/6ZjMz+3u/9Hb8rkA+\n", + "tZPmUATqUAgRNYvjWHKisYmZI1xTzOEliATaU2H3r4RV7qqHVtGnbPbXzIR5uxzrMwV09JkikjGf\n", + "JUPOhcRaor4z+Q0rFmWxfrJOjJizKhMQyeZCSiZneZIgB+62uQnW4IgMqKcGAFDZvpWMAadjGJ8H\n", + "kU55+TysCYfHHhRRYT2tFTklSgF0upIcfkRnS3l01OU9MzPbNj7/DfnybjNfkwjscm0yMys2WLvl\n", + "p1EK4BbBBrImEJ0aFBEDEXgGvuM/ipJnZ9AkSpbMwhTwHCkwJnMZr1Sb7+TElEmZLR450SQv4vNE\n", + "nzFERHLN5wfUp0LAQq/yN/RcLBU8ZpIgOdraSw69EuhXId4MPgK60e9Ji+fUoZV1F9IZo4UBq4Rt\n", + "IjfjSYnlJMq7RTmReUJL/JG5Oy4lfjjfSqJEyivnM17nesYAjOXzvxHUvYwoleQfxHl6IcoPs4wn\n", + "S0uIVLJkyZIlS5Ys2R0tvUglS5YsWbJkyZLd0V6dsnnXmb7HRU7mjJwa/qreUoRvFdm3M5pRxVKz\n", + "h1oU0esgUCyhxWymRXWGsI4uG8W1dwSkWQg8Sqh0bB3aHgEjF2j3eiPJWKGxUUrSYqqcZ4JZT/is\n", + "CTKvoM7aCCn7Bm6+VuDWA0iB9NRMM90rEPbEFbi/CQfef00I4FRAn0HGASrdiGsvh7L2G6/7ceyK\n", + "XIZdA7dgBl/FUXRXujb019E9a2YZ1JZbL+zhKugEgieJMhcC+g3u91pg+dJIygTZWNp/6F6amdmp\n", + "Vy2c8FlhZ2qQzDRbou6IuGViHk25n9SPwq0o1WWGc8zU+THs1luB1qGFs27ux7Lv/+IfDue71QTR\n", + "wS35Xd/zp2LZf3ATLvxTf+Mnzczszaun8bv3X5Cc7dfq8yPqpNfH+cVVbGeSUNOVXcjYabbV7HAV\n", + "bh64KKi0W0/YX+Y6fSUaaxH7VYMH4CoUN9rgcufhd0Iw7XlTpP/HSHYXtXHcz0ncyBNI5Jqg26By\n", + "Xq1m+v2hiTMF/HHeLrlWkQetJnU3dXDFZKLt1B/COL1+4W684+Nw746ibD0ykfdKaBF0pTHpgLrR\n", + "sD5tV04tuH/xyMzMNhtfJ/ImnLep3I3ybAhjay9jku5riUmxkgrgGAyjruHdkhw9UVldVawxd3Tu\n", + "ZtEt6NfixOslyOYA5ffNLrRHPZY5zquuXdZFA2XoxtN4qpFJmM8kIVdvW8cEADhdrlpIpHvIEPLP\n", + "Mv6wrjaitl9CfK6Ue02trmLmvqS225JgzcTcSqJnt7e9BzHEhMuzeC64NoWU74Fc8tzP6FL3cUJX\n", + "ch910SSICJSNcdDAJupdLTUQVcV81VC9XvoJ90d1Fsfk2kuWLFmyZMmSJfto7NUhUlk2Q5pc7fsb\n", + "K5tn8Tt51T0TmTjFUFdFs/Cmy7dgIZbm/kM5Ht+dkUnQPDwjZAfGXslp2DnLlmQAyZqXzzJ54waq\n", + "lMtuge3W3QJzA03yqs88bbWEye8Qat/WjsiU2Op02CUfTr5bZbtG6cybmwAhXV87+rW7xI60F5SK\n", + "irFK4s5fcv9LAAAgAElEQVSpgO753x49gpxDc+2XJRKI6za972A7oFPD9DKWEbDS+8rdz3iSewJ4\n", + "opV+2uM3B9m5GNTbiURMRyGx4362svsi2VPJliQ2ZqLsXaL9paoiEyVTQjnGBBGUfNCxjvMJJMoc\n", + "ig+2rk5+QP63N7Yf97a+GxC7r7z967Hs+btBEqHe+o7sh/7t/8LMzL7zO/9lMzP7r//Cv+91y4Fq\n", + "SlDEe8/fC/XU6UfgRObziAM0bJik1Hrt46SsMXYwN4dBSde2KDu3JkTUS4ti+LPbAORghgd9aCs5\n", + "Lad6RDzCSc6EcMdrynlj4VLiRYM3ZgrRsDwinAxrX651ubRsIJos69nhFMqOtyIJArRV5SQYnj7W\n", + "kgEAY5DobDNDC8K9u9o+jGWP7gGR2m1iWVaF821WnpWhB8J4+9IDUKwJ9TvVIjES0cyl+4GoUyHS\n", + "7hlQnUJI8eUGSLcEtrQ3uIYih3HdE5QY7b+9gRL5PSUsM2BCgy3m+TrNXJR7praOQaHK6jH/6kyp\n", + "H7IvKDopWgJSelYux99MQQP9P0OfkKexbJYyDSY5IZnxg+tqqDTmLnIoKkpM2Z22XZLiB0GEO0+i\n", + "5z8+k+2AQWgqJk5kN84xBXD5WwHJKjyL1ht/nvD+NI2o0mMtKmy5nihy2ZqjbecsIVLJkiVLlixZ\n", + "smR3tFeGSI39MM/MHHOjCfeBoc7yahp9nmdQIhW1GydKJ2g4NX47UixT0Cru+oSkURAtUfE/yjQI\n", + "IhL5CrrTG4m0CJrB9GPgILRSt1MW3uZXInQ5NrzGMtZVdz/cHHWCiPFNX0Ptm3GeE6yU0PQjOR2t\n", + "70IY1v3sifO8NhcBzbi8JzudCyIcvkvkznUjQnP374UwaeVjHA4QBEQfV4IWHZDPrDxobrSlcGmP\n", + "HVHnGyLrICaZi587R/vbyneEK/LQjJnZdWdG9UMdk/CpS7gsRT8LCXUnr22GpuKjCsJ1uF6807K1\n", + "4U53lHHaAUG4rJy4cYEcZ/ene7Hs5//e3zIzs9Pe0b810Mzb0/NY9hP//X9mZmZ/8E//R2Zm9mf+\n", + "7H8Zv/sL/+1/HK6/c/Tr6c1j1FN25Phbag69nOHP0nfoss3ax10dQ5HJPRM+0jleQgyX9qIo0qeo\n", + "Ar7X8GfyoQZFvcHXclkV5V4Vi3MQkZrtqVkn5c2wKqpmQtRdOZcRic8Wx3HsKPrplC4NNceapOK/\n", + "4BcOwpHsWyBcg+/IOe9mSwfmfYVNeCHAxNVrQa7kYu2I1GYVyu5dOEePqEfJRHxmdroMJ7q5FkmY\n", + "Q+BNVZeCXOwhRApBSuVDZZS60VB/IBi7S+Fobonm+/UPDyDd8MT7af8yNLIURKgASpND/mMQZIZ8\n", + "wRmqyXVFZDqitI0cyDrPtUQjnuRFlERAuzQ16ASkrTiH6uhag3W/Wgua2BD9Vo4mryl9TMqhtNvp\n", + "v+Tv6VybZr/T5uic4PNWxynnuziCYs7OYVg+4/hbXRPjOWRe0TtSC2+Y3Cgt2zQrnMN/y2tkCkll\n", + "OkGWlhCpZMmSJUuWLFmyO1p6kUqWLFmyZMmSJbujvTLXXj5kMyXakXmixBXFcOrMNISVpFypOpSl\n", + "B1WsjcLGCkECsiM8KSTeEsdpaGZBeHYW1U2fgcCocOn1pnni4CqT9pQjQjgBBZeCpx8PUD2/cf9U\n", + "RRVxCZcuQfKeKlFW9qt6RY19okRpqvjSnSQh7HDtVbW0iyrut17P62cIoX4o13oNauNHcaPB21cL\n", + "sW97CVdJKS4IunSoLJ+724fv+VnuIfl0d4wS636iOrXkdaKMtN7/1Toct9kKoZ9K0Tiv3v+xw5jQ\n", + "XGe4d4O4Gwq4pypxGU7wYxUCmVOxt9dxym7kZcUV2SGceNVc+vHds3D9zu/J7/rE95iZ2bO3XZW8\n", + "exYI+oVC2/Ulru/938IF9Pd//C+Zmdnv/3f/q/jdD//AnzAzsx//u/9bLCvXDL9XFyijMoQojnxq\n", + "o/Q/UzbWjbjKK6jSwwXQCOk5EoElKIMwfjEjbFOSQP1oqIckJXRvm7rRQimj35VEH68wLuukfoSe\n", + "65NQEDg+SskrN5xQP+f6Wz7ALVGIqw4SAwxN12ADsgEkMtwGuMP7k6wJR5BzT7JOwt09mvjA0Svd\n", + "3vuTAQA9pD4aCY5YgRewufIgkgevB9fvunE3GsnQvUg3HNvgArzcuLv5eBn6pJq8Tvk+BMG8ONyE\n", + "6++1w+iL8vpWcHeVPk2s3sGNI1SJqgtlm5205zb0ycsX7sbKseDXaKvm2uQzppC8dvtujzJ1rcEt\n", + "K6T4KF2T6TihW0zWThC/Yz5JlZqJ41WeXainkrN5ywrN0wkC+ihzt6CrUrKC8DkxyNiNBPQoEyHj\n", + "la5vWbvKuP7K8wcuu7EV+QuMRZVYGeg+10gQ5l0lFUOCCIYJ7w7S1zn6bLPy58kWbrxS7h1J6Roo\n", + "M8BtuZb15Hhcri1qCZFKlixZsmTJkiW7o70yRMrsNCOYxU2ivBlzV6MEdBLaRlPCGoS+5HTMBD1K\n", + "RnbuYkoSTGeZ4SGMJsy+CCbpboF5mEqF08ZF2diHt+NWUKfiQxIPSqbrgebkLz3M8jr2hVyrCd8X\n", + "ghyRqK8M2AiEtNJPH9o5aP9P2OKOQrbOgDAoD/awD+25ufYd5H4f6nRV+Y50IqFw9N3kxTp8P0g4\n", + "PXe9LYQzCxEaZU4uomWhUuHPoGKqaPjuwq+fQ/ahEWL7FjvRWhC+HIgUpSlGgR9jrr9ROxZhwEKs\n", + "jmH9tVyfIezSd7lR/E92PxQ9RBs0h1mOm9iPTvZ/HSTf6aWf483LsNP/ypd+MZbVGMer2vv/9hiQ\n", + "gJ2EqW+aEJ7+wfN3zczsnb/xP8XvfuzH/nMzM3v7K/9vLPtaGxCxSna1lDpQbmYEMWSQrTbYEUro\n", + "Ngm4bL+KenJeD73OdWqH+LUYLj3T/mQ9ZuoCmHdSkkWZBNz/mYAvjxRU+0ywx9n9KAmwEuqe9dyR\n", + "C8JEkVDVXAQiwWVH0YooiSLrZEcSr8pqAEWZ7aOZ6kxVImGDrqdAycaWRGDNjRgI3Zcia3LvXhh/\n", + "u42PqyMiP3pZfzfrLf7upAyIxOTzfo0cn0X3xMzMrkWRdwI6qONvtQvzrlr5OWrkH9VQ//VFqF8n\n", + "BPxyE77fXMq6cwPkrmdwjqIfkFqZhLBPCYO5SnQok3xtFPMsZI5H9Ecgxg7rQ07Su+QazBqKNIsg\n", + "LMZHJgRwik8Wpc4nRjvJ+geUSMn7bMY5hRFKkWS6hvcM9hFyOsZ9oQEjQKdUkDeLY8vLTh3z+qnE\n", + "BOYEhXYVkebaLST2Ckj8SjwiF7sw/vQ5QY+FkufLkhNP8kkW3xhzSohUsmTJkiVLlizZHS29SCVL\n", + "lixZsmTJkt3RXp2OVNfN4LQIJwq0P5CoqCqy/L1A0Tnh9kmPIyvTocWKej+AQpmjx8ysjGRjccVV\n", + "1OdYwqNFpu5GqO2qawNwY945tEgwlrU8ii+iO4TPJ8lDZSDiKRLfbcL3662T6Kh8XuRLyFhzDU09\n", + "NThIzlZ1cOYw82ux2Xqb9vvgZnrxwuH2p0/gMtq4jtFAXFhUeYs6nHzVeN3bTYBZ22sSYaVOqHsr\n", + "+fJaEGYLuXfbXajoVjSrqKy83Tlk32zhKlRCM90ozO8lbozszD4j9nWphEUSNr1ddB+XQlQnQbmQ\n", + "MTZAn4T5zcpK4exwjmMvisHwVX3qY98dy67fCbpQjfy2BGm/EMViKqXnhY/Jrg998hD50r7+lS/F\n", + "7y4/+6tmZvYjf+zPxbKf/iv/Sah3LgRg1PNGBioV2Eshm5P4qtC+pwmDe1C14EjO73ROwBWoWlAx\n", + "UEF/u9S2YTaERnSsBmYlOKNZFdcn8c8ObI9mQKBmjhBWoy6Vuu8ZT7P2PqFUTy2q3MxJRgLujNrA\n", + "YId+xjYP35meA/0v5x1Asp0k12TUL5u5auCC6aJCmLeroD6Pu/EauI83Wy+jEPSpc6rCugnfV7XP\n", + "ic1qjTaKLhvcna+9HsbkePS5dv32C9RDiMWoXr2WoBDM8Wbj47TEulNfyjw9hrm1v/F65nDl0SuZ\n", + "idspwxo2SmBFQde2rF0ci8OwdONmOk6Y61DmSQm3JbWSCqEi0I2VZbr+yBrD62N9ys+4pOaZQkgz\n", + "8TqdjqEvNBcrLxdpJPId1fEHdWOfCQBiftpeRcsw7Gpx9w/VMp8mn/xknuTyXGHUmmYbYQ7XC9EW\n", + "2yCjA92eZtJ36pXFRO3lfEpHOGcJkUqWLFmyZMmSJbujvTqy+WQ2yM6IJLJMEZSl6Gt8m9ZdQgwT\n", + "lV1V3JHJbwucu+Hb+kx1GfnqBK3grkJJ6cxxpfnvPEu17BxaSAIIUbQzhsQvVZR5vnYvpEOESx9e\n", + "ito4Qpy7gyBn2HXKJi0iG6rUzU1ETDWouQFJgJZw/bxEaGiuu+9wvufXN36t90PurDcevO6XgtRD\n", + "lkvdKbtQaR9j143vTkIsbU8B6cpUagD92UhY7/Z+2HVMQthcI3N7vZF8hgjd7wYnb1tUj0YWes2N\n", + "xb6Q3c+YEVVSqQvu/nQ8r3Gc7BzLUKYBEEOJfHbHUJZLWzmed5PvqjcgUTa1ZFBHuxWRYFiv7qOY\n", + "6XwUhC9OMrQ/k93tV37hp83M7Lv/yJ+NZd/2v37ezMx+uf3AT4EBVYn8BeWwNdegg3OCpsTd8TLX\n", + "XkeS7bn8m7nuqpWpze/D30GQpjWQqI8B6Qh1Cn323ntBsf3m5kX8biTCrXn1zqo4M9hDhUiwS9Zc\n", + "g1S2FqV0qu1r4EkFZM9z7gllHAEQcxFpICh6HBa+ZiNjF/O5l5D04w3Gnfy0xbpTrEO7dltHmquG\n", + "Ocx8TPJeKErIbA8qP9Lh3tal5DoDmjXM1liQjSHhcPXAj8/3gYje3QoBHUiIdKGtsf4pmtNskVdN\n", + "5nPDnHwqcdIElKqDUvmk4fpRkkP7Onxfq0eAwROaqiCiKoJSAVkvL7w/md2hQfu7M8Epo5DYYwCC\n", + "BMDEZ6J6aTBOFRGLY+cgkjS4nye5RpRRYLtniuXhWu1B+glS6Jke1y2RJt4JXXenmAJCEC4S9UcG\n", + "kWkAGNZwGWvrXZjrm60TyysikrXk32OOVbk+JSHGg6LUs6iVhSVEKlmyZMmSJUuW7I6WXqSSJUuW\n", + "LFmyZMnuaK9O2XwaZ2CZ670IPE4tFtUMIrFzRlR3CjqNhL1MIWNCmrhYKUlmK+gJVeILpDpqqWRD\n", + "ktJn3LMlKXSCHk0mpGS627IskNkyUfFuS+hYSbuo2XQ6irIukmsOoi0ywn2mOlb8rKQ8uhZIzu2V\n", + "sEovirgHo1bJzN0KGPfoBOjnz4K20DtP3o9lb7z+ppmZ3Y5O4mQyVOq+hDqAbN2ecF4/vuuWiWwz\n", + "3NeLKz/HFi6bXOD2ch1+W4oGzEQF/ExdUCQPU09kSSLOxWU8UuFX+qQmZC7QPl3Aeb6cYprcN+qd\n", + "1HTFCukVg2wjeiZrENofbi5i2e07QcV8Iy6TOO7EfZtRFVjGaQNtLxJM1zJfSqhdP//yz8WyP/0n\n", + "/j0zM/tv/sc/H8v2uGzWyljDPFoLsbiB21Dd8tEDgQ+daCzRtZLL/R9c7tzblS/heTajEmX3q/uh\n", + "z3Y7d6PstsEtfIEx+f7jx/G7998PivrdsBwTMxpstkyuyyNydcLhNJNMiRH3fZRAgR5RK5FSkKnb\n", + "gXpbkkjXGGzi11pvQrt1ngxd+Nzt/bcvq+Aiu3nulRq4v0bXFaLFtNlsZ20282Tpg6iY00V7Ovl5\n", + "j3DbayL3NbSfWl2n0J7mAcaLuFg6JCMeWnftDS1cgSdZ6++F39aN32sS+nWdnOiClHX6sA+/3d9C\n", + "C+skRGi0a+ZMpmtfE/nC9aQk/ujElr6rSuo4SZAVvq+3oR67Qsn+fNaouw9BRKO6xcO9oJs2lC2T\n", + "BrPOev0eNAO9x0PGayzXEJLMlaoT1z8RcutYvzMBTTp3OLV16YxakeVyXvF5tpPnyvYirJONBCBU\n", + "oO3kSi3BfR9Fq45eQ02M3EomiXOWEKlkyZIlS5YsWbI72quTPxjm4ZW5MYeQEszwnqchnHyblTD1\n", + "KYIKuiPFzqFcolncEZeSr47hjY2EZhcIw8xm8BPfiL3r4g5bw6TRnkJIjAe8sVcgnedCYixx/Kjy\n", + "C9iZ7oXEtwI5UjjMdntACO+tvuqH8zWCsJFIPIDsrMhID+SoNkfJCCYpiY/tn+QN/gRF2994/51Y\n", + "9uZr983M7Cgqwhm2uJlvJq3H9rwDAfpw3Pv1+7nqtJkjhpu193+DfFpV4f3EMF0NWz1N4dwKZnL3\n", + "EZuYKYKH3Z+oCJNsr2TPHmMhG2T3QxKjSmLwP6KTscI9KeulOjXVq7eVt3WbhV3Xg8aJ/UMWUJRR\n", + "dk0ZULpJ5k6N8zy79UCBqcOOHMc9ffrE6/bG58zM7PGv/T+x7Pt/OCBSf/F/+e9i2ddbxok7iZ+7\n", + "v5WEGhMI0PDrMc5jKMwLh5c7XF0nONlnsgb8WkFqIFE7IZteXAVF7VqI0muQaHebHeroJz4gdP/p\n", + "Y8n1OFGJXa4Vd+cqvxJlyWMZZUeUp2wnrBO1oJ7YJUNg3ErZQTvqoBE4CKJZK/oX7v+9tSegW9dB\n", + "jVymrr14NwR0fCV3JI6o6Po+dvUitXL/EormsiZQnkLRp7YN8/nmxsfaLcZd23muvTxfEsB7TFBK\n", + "iFzd9zYcX+K4k5+jP4VrDXsNngl1yjPvE/eBiJeg5P33McGcdCQiHw/ergPyAA4SxEN0RGVqSJgu\n", + "ZaEmclSvJAMCc8Yq6hnRMQY7ef9TVqQQqRW6R2oJFGE2gP3R5+TzZ1h4ZTpRnmIldeLzVCU2pjho\n", + "AyKpaw2DfCYhrI+QdalFJiXHOirKDTFAR7FcIoaz4AnmyY3jzn9xsQ6yGlsZp1f3Q3tK6aZqReka\n", + "WZPQ17P8p1RKF0L7OE+RsLCESCVLlixZsmTJkt3R0otUsmTJkiVLlizZHe2VufaKfJjB+ETxNPFi\n", + "JJjNMr8CFzyjhTEnoIJYpgRktLZkAkTlHBdUNhfCHKUzZu4ealDNlVw+fBzlqHppJJtBpfReEm+S\n", + "AN21klAScOJrV67jUsNloUkmL6fgRru9dp/Zs2cBRj8I3F0QWqX7QnmwJFGLxk8OCLTvlezKxLsC\n", + "RfdLDagbqHHXQuLkTR7sJEUg1B8CBH1qvb4kmythu4IbT3Vs6PlSYjFJ45m4TIx9O8mwH5kYGK41\n", + "IQITzs7FPRg9zzJ2OwYDrMXdBx0xdQHnuN/qbibZkxCzZd6GAvdie+WK0Z8fvjU05dorShdgLm5p\n", + "4z0TePo53CwPHn48lr18Flw6K7oHBOJ/cRu0ot543RPUvvi1nzUzs3/lu38olv3lv/sTZmZ2I/O0\n", + "gktFvJKeeFTcQvwJYydOQo6f4FqvNUEv5tgkUHt0Ac80c0L/7C587lzCBbAuvVIlPq/gCtX1597z\n", + "4O57+czdSCf0a6WJZ+HGKMU9NWByqVYcx7Fwgi0fSJSXxSjnWsRktLLWYf3R5OKcY3Xp4+TqXtDK\n", + "iq44M9uUwUVW5T7GHu3CcRtJZP3BixA00uxCfe8/eM2vheMKCcpgMFB38ACU6xtkQHj6MpY9gdv4\n", + "1Lm7b7MKAQCFEKoruJlbrhej3//dJtynw9rr28GlNLzw65dXCOhZP49lF8U91N3J9hN1uSQoIsoY\n", + "IbCHf83MctBHZq6eM16fki51cRXTzaVUCbreNfCo5v1hMmJdr/KlayvqU6krCt9r0t6HD8Nvb26c\n", + "PmFYsrv+jKtOyeYd3Jxw+46iYt4dWaa0BAQR1X7eCi7TtQQANAgAmK1d+NiqKjr7GwuwsFKiFtnF\n", + "hbuAL/F5I4m0qWKuGRCoX1nIGDuC+qKuRQ1QOGcJkUqWLFmyZMmSJbujvTqy+TjNCIuMgxaQJubT\n", + "U86ZIV+Uhl9SWXmGZmHbN2bLncM0Uh3dLYa4z1QVlirGM0VjvxiaoArYOF5zzWFn7S/fIlcwLeu0\n", + "AurS1KLOChJprYQ5lLUPOvltQBree9vJw0R9MhB8B1VdBvG+VwI8diFKDhypziz92tTczfuOaN+G\n", + "neB6e99/jJvbTpI7D4RGok99K7tFRn9LBSghkQvSVTTLe0dSZiZblxbjRNvN/GtDD9KvLcmhSliN\n", + "QhtCxOyQME3DiiuQnFVOIZL7Z8gJdoxQAs4rR5qYk/Ak5PA3Ph/Qgewf+O6bIdS6I2X4tQ5/qnhP\n", + "gjCOI4McgILI9voK5M133/cxtL0IUhd/7Pv/jVj2V//mj5uZ2U5Jsdi5a0h+zFkp/R9VsYH+FULE\n", + "L+NEEUQAE7DXUGuSbKWtVEruB58T9YrKxpWUISgBfXO58u9eexTQnMdPhYjdH/DXr8Vw/VkESBwL\n", + "S6mHOVGe6Phs8OIURDD1HMtxXaJfN2vf6V/dC0jPw/uvSdkDMzOrel/2X24CJJGvvPM2z8L3XR4a\n", + "eXnpO30iLL1kEWhP4fPx6HP3+bMw/18+1/UHUgtHR/iYi3ADsn9oOOYpmj3IGDoSwdZlHc+E9uiF\n", + "Lx6jXZJrsG5C/VaSlaBeIQBG7kmFtXUAmjL03tcN+m466FzjXw3hx3ouwVMT0UR9djEoSpBorkkl\n", + "M0tIW4uc43OZAWQmv4NKKXBGj4nmn+swaW5vJcgH407D/zlO24EyNYq+IyemJExYYe5W2rElpYP8\n", + "nqxWoS6XFw+9jZCp6UTi43B6id+iLX5WW+H5txEvRdNQ/kDznzIDiAaKAU0V2ZkOY6ztNXhCXBVn\n", + "LCFSyZIlS5YsWbJkd7T0IpUsWbJkyZIlS3ZHe3VJi3NPdmhmVlLFXI+ZbFkGSHNG2DxHwMtJivZf\n", + "E46vaupEiO4FCJOq7B0TpM7ceSQbqrYQVaw1kSx1ZNQtEb6vAG0q6Y1uLyVdNqsAVdbi2lvHMoeC\n", + "KxAVOyFFZoRRxbX4wTtBD2cPonI2g4xxXfUwsAmSDZSekkog880m1G+19bLDMVxrKpzsl8EtNwqJ\n", + "sGfSVpK9VWF2WN5XEpVVM2wi8j6Tmw5/WnFVHqFzM4r/mDpGPd29ct5yrHCMtB/1076jBtrpqARw\n", + "6rfI+bJlImNqlbiarihGgwC5k3t4/Ti056EQO9uRbjEhUcPdNXM3w31489IJuLvLAKnz9rcHJwe/\n", + "eBkS+JbiRv7ab/6KmZl9xxe+PZZ97+d+t5mZ/R+//HdiWUF9IHFB0R2VmbrgMe4ZsJH7/aoxT0+m\n", + "cw2/FXIoSaF5L4MXn0l6NvPEuKXA/esVyKZ054zuMt1CKfnNtzQZd9BK6zWzQPTjy73GmOlaCcqA\n", + "W2aY6WKFz+qWqhokXK/O7HPp2hNaBNeRShJZc524f99dJruHwd3XTL52lOvwOZegjGyNtQNj4mrr\n", + "c7iBu6eWwJ4BWQ6ePnEX6MubMI5ePn8Wy25uwrjbiyr56UAdOckUQIV+uDsHoQwMXEO0C9HX4+Dj\n", + "//ZZqFMl7s7Lh1xj9Lf4K86igYVU/RYaAZvdy7zuua5oTBTdc3ILy5wJz5XuwePUV4lnVwxi0gCs\n", + "8F2uCaLz5ThR8kK8Vgxo8b6+uIBrU/r4xQ1cdWeSmzPIaJBsIxkaXpvQTeJc8JqUeRhHTe1u3C10\n", + "ztYS5NLw2aZ9cvkA1VgSwfOciex9XK8wrhmcZGZGr+gk6/9EVXwZFMOwLOvVb3nGEiKVLFmyZMmS\n", + "JUt2R3t1iNSYz3Nu4Q12MN0ugFisqqMkKme6q6eKraidA+2ahMQ5MfwdJMJJEBwiUTPFWubrU5kA\n", + "7ghnMBnI24K0zOlwOComCsQOUkhvkWwru1CSHndbf4Nn6Oh67W/wZUGZgtnFzMyRtvCZu/6wSzwc\n", + "fLeeoS56TxhyOoiKPBs+IzFjh7XbOYlxAppw7H2HXyPUt5O3exJV2epBd7rY/SrRrwCJUXMf5SRb\n", + "C4l9ysNvVKZhADo1CNkx7kSJiArSWcYdluy+zowrkpdn0g34PMurxZxoghz1JXOnIdejKBYf9qG+\n", + "98z79ZOP3jIzs335ttQJBFiverzvikhyE3s8+X1vLgJK0e8hV7GS/I9tKFMEkWja4av/MJb9mT/+\n", + "75iZ2f/9D/6mV+CSYe2CJmEY6QY6yp5A6sAk2wAHWalSEzxeBiD5vOMk6BekPpRE++ImkJzffOiS\n", + "CAVDoivsuDWlFqRQ1hu/X/chBXErof6UUdFdco/+LyT/4BhhUkUYGGQi5GHOhmmJnFMmQ4NtOD4V\n", + "uaBC++q+79LvPYAqtaD0RIyz0RveAhXcARnYyhx6CCTw5pmkJ+B6JnkSW4TYH184+nk4hbJD57/N\n", + "8jAWBfS1i3UIUCnGcP1WxiuBQA026UlKF/R5APr5/Ilf6+r10MZC8m9mZfhNmTlyRUCswNzsNDSf\n", + "sgaKapSLIssmBm+oiwMIm4yT8Uye2IroEB5KrUgNUH4hE7SkrJnDUq6fzasbCrHGSUBHMVHZ3VHH\n", + "Aev+rXe7HfbhP1T9NhnXnJSjidROC6Rr7RVomvDMutz5/Fs3yCggayKDi8pSvR7ILYq+OY0+r/lO\n", + "oCryJVXMZf2ronSIjFM8NDXv7MBnizD1y+IbY04JkUqWLFmyZMmSJbujpRepZMmSJUuWLFmyO9qr\n", + "c+2ZmUky2DGSYgV2jfC9wKjRtbR0nY2KyxPbVLHnjurhVKyW71gVIfEq8ZVGYqeqmEf9HtWbImSv\n", + "6rAfOqwplxC/CezIBL21uACv7gd4vqnd3UMIdFB8nPo80p4T9V5A9iyFnEoXmLaL7ibtabrbVFul\n", + "rgIsfLl1yLZcL92idMF2QmI8HkFshPtIXYbUKmFiTTN3jykB+kQ3Sy5aH1m4hnjbbAB5fNBKRa0s\n", + "JIOW+0WPyqicy4GuGLmvcPeVZxKkqrYLlXpzVUqG2m9DfS5zl202BnfDpz7+RW/rLfSmhIg5oJ+o\n", + "nWKm93Hp2rt/X11bYezcHMKXh5euWfX6a4GofCuJZ1vcry//0i/Gst/1nX/OzMy2evNWAbKfcnEB\n", + "5XRtCLE5uu3hdhE3Cr8pxY3gxGMl5+L7M9tCHbvvPgmK3Z/95BteJbhZphPcE+JGy+ACKho/y/oS\n", + "CRxpDcwAACAASURBVLK3rq1ELaBJ5m4HV1kvbpkeY+10EDcaya6Fkl1ZB7hslVh9Rm8uBiyIjhnH\n", + "QqXEetABBhnQdHPclO6q/CTIwA9OYfx9YfvAz4GfHuU+tdCP+lVJrv4eEgl/sH8hdQ/fj0Ispzf2\n", + "0Iq7uYZ6OlwsR0lBQd0x1aLrmZVBXLtji/l343399J1AadhcScJvBCM04haamIQ8uthEH45aROIy\n", + "YpJp4WtHGscss8EZHSk+O9rOXVUZxsmYhXuiAVP0I1cy2Ks+rDsb1UwiZUCek6SeKImay0guz4LN\n", + "mmR/Wbv2YW0lfWGScT1hfg6SyL0jUX8rLtMi1I9BN2ZmWQx8UL250J4YdGCu/ch3BqVMZMhMrM/J\n", + "+J18pkt7rrcF+opELwwdE6irjlZy7SVLlixZsmTJkn0k9uoQqay3TJEm7uBnu6/qw7+Kb5CZENs8\n", + "0FIlg0HUFBJn34YdQQcl7KKr5LtwPs3NVgB9mHIlBzL8VpAL1ECjNeOuQ3bpUb0cb+utvPEzNFw5\n", + "pMzxVq0krBmhyLud59Aiya4VsifJrvuV73S2UNveHsKOc2/+HcRhZ2/r3P3oDpaKxpko8ZY5wvqF\n", + "xL3F7reqRGrAwg6rk91ni50r89X1J9nVYKfbC9JIoKWT8PO4c1BECnjGSfqkQ/9rDqcCatwjSe8S\n", + "Vk9Zg15C07nHUUSIfT2JYnkRj9Mwdexcc0WOmllZPjrS+PB+IFi+K8TeL25qXFPCxYEIjjJ5mH8t\n", + "k918D+TsZu/nW2Ecl8hdtjXfQb54AfkDkemgrEe9knDpX/wZMzP7k3/0X49lP/nLf8vMzNpGiPWo\n", + "cyXq8S3uI5XoNa9hiR1kp8ReIqwzZi2DPSSHIcihpSAnR5Cdf+Px12PZW3lAlih7of3F/F+bK1Fs\n", + "rxCwIHvQmjn0THewDMn3uh+wqz+eVBU8jO3bk8tODOiDyZgbU9aJCL4p0ohd9bRcT/uTz13+opS5\n", + "ex9r3MPOUZpPYE5sMYbaJz5fKR1xr9O4/jB2hsKlFn7+5hfMzOyRyJ883oe6TBJQ0gOl6o6Oel5j\n", + "PSsGyrrI+nuCXImgH0esSTOHBGREBkEYn3wtSLJcfczRxGKHPisk8GbAcwHPiXHSEyOIQObEkDNQ\n", + "Reo5LccTg5IyGf9cuyfJp8cgnw7n0zyMJ9zPW1n/ikOoy+3Rz7HbhDY0guqQWD0JwlYjeEmDkqg+\n", + "MPSS/w/3+DCFNSGSzqXdgwRRtAjUmG4d6dwDTT9ufEwSpaqEWB7XAM1oUjAnJZ7hsv41mH8a6xUJ\n", + "5fLsIoql/cnnz0GY9YcDA5XOPGN+C0uIVLJkyZIlS5Ys2R3tFXKk5jKbjoRkv+UxOBAfFLqaywqY\n", + "OTdJAvejENnYYgdZO4JBF2l3klxf5BkpSFMy+7SEWjN0flb1pX99AmITNynKRxqJYIivHm0tm2Wo\n", + "fS1CY8wXVbRe0T14Q4WEszNMlvyJQXdQzM0mdYric5Kbq8RulTmSzMwm5p8aVlIWPsvmN/qoBw2/\n", + "xi6iBW/keND8Rthpqk8/ylQovwznlxvFDYuimjFPU68IC+4xOTKSL4yilqPs/sjNmmV/B3KhaCr7\n", + "kRnHzTxkO5dQ37rZ4G9An1a58wemU+jjB2vPl9a3YefeDYLWYtelyGlJQVZpf5FB6mDw3RflAVa7\n", + "sEu/boWrgfMdRSbj9dceheMk/P/i7a+YmdmP/IE/Hsv++q/+VKhH4WNizCnm57/twQOJYJ7sNDkp\n", + "O7lf5DKcZAzlMf+cH7daA9UQhLmCsO3zWxeJ3O0LHI/xKmKFNe7TWkQdydHsBWmuc2aVlxx+4Gso\n", + "R2oENe148DF2fRPQwdXJ5/0B+fxOE3PSLfOqKfpIiQuVXxhx3U7m03MIse56n5SfeD/0yeaxXB/o\n", + "0NchqjmNS6RrEAmTT33y02Zm9pk33opln34cGvvs+v1YxjkxziYK8y8Kcge+UAaIqd1LXstjqPtR\n", + "BVEBGA2af5H5T2U48RLXgvBeYUx0M+kECKLyt4I0UzC478/xZwV9js8k+R6oSi7kXCJbhYwxCpEW\n", + "uHcHGS8lEBlFickv62VOGhDu8p7kFWROVB2TEXVRkVDkn5Rx12DtqnG/VDonynlIXkF253Dj7XpW\n", + "hPG8Kl3OpwQCXghyV2ZLNG/AOjblkJVRUeNhycft0MZB+KiUblGZohaekMOtSvJg3TvKcW0S5EyW\n", + "LFmyZMmSJftILL1IJUuWLFmyZMmS3dFemWsvmyewk3L/PAIqVHIiox5zDT+PxG490VKBm6Rw8sYU\n", + "nmWeuqaQEHZ8Pwq0S9VVde0UsdIzHHdx/QkQfIyq1TBw5vCTJsQgaA3NHQAxCgGyKOla01xrS/V0\n", + "yiTQfagK27xEKWTfCYWnVodJqOdu7fAsFeUHQT+HE1xm8qo+wgXYHjRPFfoYt+IkrrXudE6mIpSd\n", + "BEau4LI0zUmFjhzUU8TgAVFq73HfhyOI9a3eMLRPHMR0AczyJOLjLP8T4PHpTE4sdQFQlX5VgZwv\n", + "rjCqrl9diNTFBwiXlnPQjaMhvC3kHxrxAOZQNF5X7j7MQUbd7cL9PMi9ptr2cBIFflyrXnudruEe\n", + "/IS4pT918XEzM/uqefj7yyPJs6I2PzHXINw+GjBB124r5PRb1k2DPcL5VuJGLSAroTnkCrR/EAL2\n", + "fr9HPcJxlbiiGT1Cd7qZq/d3GihzJttBhbxfJPOa+X2/uBDFZBxXHbyN6y64YF7com90Uczogj/j\n", + "sxJi9QnZAFp1dz0J/fnmE6EKvPuemZk9kQAQur5zEKALkWk5Ia9cIY+Or/3GV8zM7LONE8u//bVv\n", + "NTOzX3jy6/7bnv2keRIZZCQrH2kOICxnpbox8UHqNIx8Tghhm659VYTB19cvnNh//00Q2pWp3lNR\n", + "HucYlSCCdXpGPsa6muliRxK7rL/IT6pjYl0z2EQCn+C2rCFD0OzdPXsNKZL26Pdr3dDtpfoLDLby\n", + "dfIS64gqwPdHStJoe0gz8RLeCyrrr2RhOWKdnubpPsJ5RZX+9mU47oXkxGNWjMn8ecI8fo1o17Av\n", + "yhou21lgEcapzBPKqvTyAKB7TtfkAzI6nMR9eoCcjLqKh9PSlauWEKlkyZIlS5YsWbI72isV5JyF\n", + "2sN081UwX5zm1WIWatmQcaenp+OudyaxgI8DoJNRRCUHvK0OsvvpT5A1cL525NPlsiPKYqirlkHq\n", + "YCaJwLfvbFHfcwhdg52w9tIEpGHM/A16GMLb+iAoGQmduYiKsk9IcKwq2WnFXaC81TP/nmxNSAZf\n", + "rXz3Wea4/gyRCn97eVdn2PfJI53tdAh1otDj2AqxFoTWQUmc2HX2s85jtnYvotJfd9L2AzmT3RcR\n", + "rpHIlIiaUuiymImqAiWTMuYQzCRMv6D4nu60WV0NMpgouhpQoloyoxP1OsrO7HQNMriclx8VfSiA\n", + "EvaySyWKkytPfWCmeRBsS98tt4cA/2hY8S0kBARUsBY3/vBlz//3g9/1w2Zm9pd++q/EsgqT4Sj1\n", + "pNhgR0TwKHIVmH/DXscELywCfsxPKXkqJ6BJha5wEL0sJf/Zs+cBMdti/q+3siYMJJE7+tasAmG/\n", + "lFxvnKDKP+aatVpptAXaKrjz5b1A8l9tvU43Ny9wOOaL9NehZzCAippinZIJUABFb5752PkE5til\n", + "kI1PGM9rQUIzIAYt8wXKEG4ajGvJf8lccG9/5aux7OE3B0TycHJi94Rx3086Uc/s9IEi5AiyUUSK\n", + "DPBMZFWYO66VORH1TWU9I0yla9ztbWjHWtBMX+NZICKtdkb8GO2RmBgrKWcjzSoR5LPeOiK8Joon\n", + "p6vRjhz9dXHf19rdPvz22fOnsezmGMbEKCj9hkiXgmkI9ig33taSujfXkruuX6KeMXcfPBaFjH8S\n", + "wDPxHOUQBM0kdyYFTm9uHRHk+VpBRBncsRLZn9VFaHezwXop3PyoO6RBDOh5DUDpIPCqnijmcVWR\n", + "6L6nJI+P8U6EXc9ZQqSSJUuWLFmyZMnuaOlFKlmyZMmSJUuW7I72anPt/Tbm3hsFSAH3ztx9Z/Jv\n", + "wUZ5VyS0WODEmvOJPG3VfYnEdiFgR7kb8S1mkdC91KDKhbxOhHiMriqFh+kyknYRThWIdaIbTfwt\n", + "VABXBeAe7pZW/G0dlMUHQMCqBJ/BB1Jq/j9qnIgrqiwA4xbibmP7hVnew0WjCszXyGu1v/a6H2/D\n", + "+fa3wd/Xd0tXlJI9e5DBpZrWQ0hmUgI23ZzyW+pSidxSJJcPIJh23dLVMFMnxr2oayGRMsee5tAC\n", + "jFyIYu+J1y+9AjVIrh38AlvBrDc4byHuLvrl2oP7R6mP0opvgYrlheS1mpBPaxS/3BFk68fvB72f\n", + "hw9cnZrny4SIuwPErvpQjx6F3HW/+Y++HMu+40d+IBz/v//lWLaHAvutaBBRjZ+57o6i40a5qaMQ\n", + "0JnrcJIAgAq58AbRvaGXdRQXDLMHHISBnHfhIiO0ikrR8crpipOAjRF6X6WMqwkXm41d5r8r/Z4w\n", + "2EO9+HSVFeJS5TpFF+zTp+rGx7wWN06dhd9uRJ+ngLbPZ194PV9Hn51kTeD6lIm7rcM4XoMUPcla\n", + "t0JftDIn6ipc94O9u2xes8+Gesg8KeAeGaTu5UCtPtGvg6tuD3droUroGdXR5bzoV9VWipkyhBTe\n", + "QLJ7RkoekOtQPTcVidqhb8pMyPExUEjciFGKSQMgQhvXlauoVzUJ0+JaY/+o+xBrcYUccoM8V+od\n", + "COiX3oabmzBmjyfXkWqgdzfJmkyX8k4Wzx7uzmYnOmLPEbwyaUYJ1oGabdJ+PB/V200NvlLcqFx2\n", + "Blmnnj59hr+Pve7b0P6re5694xJk9A3ypa5E27DtkK9U3LMZXZBy/R7jSTOAHKC83u6970ZQKXrR\n", + "kera5buFWkKkkiVLlixZsmTJ7mj/zCib8/9zwjhJ3LJbOaNizLfkeVbn8Hceps63fiqxyhkiYVBC\n", + "Q0FezU4SrszcXbr7oQK5MFt5PlVFp/wBdzVFoe+xS3Kcn0yJxaF++lbN63dStj+8wF/fJe6PgfjZ\n", + "YRc+yVt9US3zxZE8ryhZCYL6rSAiV/eCirEqFh9jeK4TJTtIIuz3BynDLhW3pmuV4EjFcGkrCavK\n", + "gMX9F/AvkudHlUQAoVxDfXsgIMylNGoUA0yJlSRv6k6LJEbltbZAIspa0EQc14lK7vEQEKGbJvTn\n", + "rpGw3hoSGr2GdVMuQHPoEcHwtt4w7FjGU808etJR94BAXVziHg6SwxIyAYVkhr9FffcHJ6f2uNYn\n", + "PvlGLMuevGNmZt/3LX8olv0Pf/+vm5nZSe7xcQ/18gNlMJa5ARVB6GL+uVgU+2TWT7gZqoAfAwA0\n", + "24BRdiG0+1R63zRABxWtGKIkh4RVo89OElbOe1EJsz8GwMzCyiHToGMcHxnE8fCBK9tPz8I5OlFi\n", + "3jbh3lUSkv57hjDvPl85wshLaF6x3Trs+kdZDEmUpjSHon8GNFHV3ikhkcs5NlUg6BdyPxlsoznU\n", + "qEQyk5jB9xEImoXVc52S83J8zB4JWDsEOSmRDSKr5UAMGV2LKQvDIBs97XAGsfbfSQ69ikijBK9w\n", + "kdM1Caz4WqU7KJ3D7Bz6TGBgi6KPQLUuBl9ruT5wXoV24HyC/jW78Jv9rc/nscTzQVDHBjkzux1z\n", + "A4pcA66ljzO2v6p0sIc/naCEnO+6xg+YJ6fOUaLjgeeLV/XjmfdWxkQFNFFV+bnGz2QNBkoc+W9P\n", + "6DNVlG9lvp2zhEglS5YsWbJkyZLd0dKLVLJkyZIlS5Ys2R3t1bn2sn5Guszi3yVhWF12hD1VHZnf\n", + "K9xLt1CWqY4QyoozbkSQ7mbJcAHjZpoglt8J3FyUS2Ij0fBBYFlqS5F0qtcnLK5aVAMTZM4Ui5HQ\n", + "U8St6KrQhL/H0zWOdxdci9/S7VaXDgVP05mhMC37PwdU3rWSeBbu0F4I8EU1LcroNuoFWiW5u+/p\n", + "spqpZoV/1dvGXKCSyDYrzrgM4jUFAu7oxhG4F3080Qc7k32iYr64PUDUrDLvL8LSowppkYBciasM\n", + "rr1SoPUeboTbl+E+7Qt3xdZrENsHcc9QbV/qdIsEoioL9tbHgzvo2QcffLhKVolm0X4f6vToDbjl\n", + "cj9vfXON9nkfHm6Dy7gTYvFqdT+05eg34Mnbv2lmZn/oD/6pWPZTP/+3zczsvVsfO0OLOQGS92lw\n", + "3aHS4PYVn0EZ3UxLJWz1oxO+14AKNq2TRKYjiPRTF+ZOJar3F5sL/EDuF7TFRnEZHXG+W9EsGyeQ\n", + "2GWsNdDvoZ5QOADjTwYv5wBdMIXM9e0muPFyWTzvQXvsM8P9WPadD78V9fDrH7swTi6392IZAzA2\n", + "u4tYxinDjAWTjAkqsWuC2lUd1pGVucvwsgznazKve8+MCpKqoEP7NXuD13mZjJlusUwzMDAZttzr\n", + "KXrR/LwF3O2bjRD7SSyX/qyoS2hLo3tOXesV66TPM5SpAjoVuzuhj5Q4T1N6P9UgpfNRMEhN+LnJ\n", + "fO0uQAEYJp1XYS2qG3F3877KmCzQ1rV5kMXNbZiD+UqoMtQbuwQRvhG6Q5XPjjEzq2oGW8WiqDZf\n", + "SsLxE6gVpbneGt3t7cndjR3c9uMEAr4MCa6nmtmhYMaEQd146P9OgzfgKpeAGhLLewl86Y6/tUvX\n", + "LCFSyZIlS5YsWbJkd7ZXm2vvTL66OfoR/o4S/jqdQUn8+OV74Vw9HGW4bqaEZby4DsoY7hDqWyix\n", + "DaiWhJByB6W7VCegC3JiJBHOQ0lDXZbtZ5z+Xt7MM24IJYY/R6jz8eg7kg477FaQo3E6zX47jLKD\n", + "6ahm6zsTqmPPqJ4DSfT+Bv/0RQid32xcATqqAyuxe4ICtpAIKTcxRvRNyJHsa7mvkYAut4mK7sOg\n", + "Oyh+kPs0cKchKCVbF3O+nVEil3FKxHSQ3RfzE06NSEIUrJMEL2D3o7kjOchHhNO/K4hkfwio0u/7\n", + "+Kf9+Jdh199JPUucoxN14A8+CMrHn/vsF2LZl7/0S2ZmtpK6ry4emJnZe+8EBOn+a2/G7z7+qc+E\n", + "Sz73fHkl0KFjochpqMvjl44mfR4E6fWL61j2ez733WZm9rM/9T/HsssmjLcDyNubynfmHSalBgz0\n", + "H5rDZj7vZ8kB0D2qlH8AEnvsHLktqGyPcfd8csXohx8LyM12pbt6jCFhoLcYTy9f+rh+/PTdcI7X\n", + "HP1Zb8Lk3V6KUjXIvjMFdAYUYGz2slsusVt/ffXA6wnU50c++bv9FAfsviXXWQ3UuZVsByvOWZlQ\n", + "VG2PgToy/6q4KAuJGnnYVpkjPUS916LUb4cnZjYndtOLMM1C7edBJrPwm+i6kDkZ0WHJyTdyTIgk\n", + "xgrBA5J/kU2cKdWT7A+UbBbWMlJ+RYIIxjPPIpt7P0IhEPlR1z+oyItSPEP2q6LB/0Vqg+uUtot9\n", + "MXq/FmWYV/1JPDd8FsljkjIdAjraZrtZ1Ok4hPtJ2QOqmZuZbUiOlztVAnWcpSTkGt8vCejqTaDc\n", + "jeZY9QUdCN7Kxxq9BNpPHiglmQpGPP9k7kaEXwJKYi7WQaWLEiKVLFmyZMmSJUv2kVh6kUqWLFmy\n", + "ZMmSJbujvTLX3jhNs7e4LJKtvYyEciUCZpFsqoDvElqlh0zPR0K3qFgszqvkwInwoBJBocSbiQsu\n", + "kuKFAEnPyyg89TKSlwETKmEZ3wnqbJMxaanAvkzkKgTMEuc5nfy4HsRuJfvVUNQ9gQA9CJkuz8Jv\n", + "VfWaCYJVR4Z6G6q3tT9c41pe+T5bkmj7EQrsoqPUQatooPtCXbED74lJ4VJbrKUrRF17VMBWTjL/\n", + "o2U8bbYcQ5bR3elFdCOqthETKDNRp/5WE4m2JybNVG0ZfBeT9npjN3AFrT/u4+R24v0XAjb0fjpx\n", + "mZ4QePDe++/EsvuvgYD+9Hksm/aB5H51P7iKVM/lK78elMpz7TAQ6rPCXVEvkPD09U84Yfnd94K7\n", + "962Vl/3ef+H3mpnZvf/rJ73uSNZ8ewx1qoUxX5XB7TSKe4peIZX7itpXqiyPITaob2GiLo8OKNzP\n", + "koRV/+ZEF/BG3AO4lBKG6dohEd3M7P13QvvbgxCwL0N7Xjzze3d1P7j+7omKM9vRZmeU5UHs3orf\n", + "44fuBWL5pegI3XbhvirdoapDX1caAIP7qATwOqrxox7t0o09CAG/XgUXVLZ3N+7zZ89wnGhLFetZ\n", + "u8zMsgGaRUKfoNs6BgwJPYLrWSb6bHlJHTlVRwfZWTym5Rr6UPLUW69DnZSonMNt2Y98XuiijGAT\n", + "0Ruzga44fXjhmqItWDHISAZvf4Iu3+T0DRK118UO7RKXHZXVMx8TQ0E3mmg7YSzWoqJOzaZWxhMp\n", + "Cp2Qskl5KUVvq0Lfdbhfwo23qlpqNkViuzzlSSKfRAOqQfaGScZJDr27opJ5mvN5gswaEsRAl940\n", + "eyajjXqzmSlDX3uYGFy0Ik/ou1vNwLHXNWNpCZFKlixZsmTJkiW7o70yRCrPM5ulMIuIgISLkhQ+\n", + "+yXDmhUliZ/khCwUSIbXZpGQHj2cXAnLINZJBbhxUQLyCCRGQ/eLMwrlE3PcgTE+NUJgO0OY4xv2\n", + "IEy4rqNisxImmVdJGXtAuCTXFcN+R5xjPzoyxLr3gn6ReJ0pERP9L1zLeNzN3pEO5poalWyP45TE\n", + "GOUJIpdQJauxq9T+BxKghO1sojq5H8cQ90wlMYxojh+XVSRbLqUOOCZVHZ9IoOawylfcJsuujqH2\n", + "vaCEHX7TiiQC1OizE8ixrV/rNZCSd5lvq29xr3NBpHrIKmheuQK7yeONE8BXV4/MzKxsnAB972FA\n", + "qVrsVl8KglWDCL6WecKwc5WwYFfsb5yUfoGdfibj6Yuf/WYzM/sDn/nWWPa3/9GvmJnZpgxt7CYf\n", + "k0RGWtlVdkBRs5myPBTrT0IAB4pSV05KXQFZymWO9ZBboGKyIn2UDul6l5+IqsyTBqBw7MQiqzCO\n", + "D89cfmQ8YDddiSQBVMZzkR9pauYEDNe6J+P6HsLEv+/hZ2PZJ5qQz+3FrV8rBxRTCiLF+UEUIJQB\n", + "TVGEBX1AorSuSTSVK2gxnhVNHDEmL3eea25bADGV8HPKOEyFI3cROWYmiMGR1rwiAVu8BJweua7J\n", + "yF154cEztkL/C0wfAxUE9eE0otehV7SEyJ2SqHMGwIhiOMZdI4gUn1mKSO1PgYDfjfrcCefZYJ6W\n", + "EoCxwnNilDIiVp1kJThiXKt0TgfCuMKuHMbMDWpm1lm4P0poz7lOYpA3IqvAnJSjZBbogToOMv8n\n", + "kvdFfiEGG2igWJQJ8jG53gH1RBerrMGEm5HLmjCi3b2s/1RgVzS77bieqZeAAUXqYTmTcUQsIVLJ\n", + "kiVLlixZsmR3tPQilSxZsmTJkiVLdkd7hUmLRcPHbM4KhpHQq2Q/emBGmzGQF7+NCuniPyR5nOj9\n", + "9KFfmJllqjtkdBkJ2TFWV8lx1CASuJ86QuKqqpH8tWnC8StJMrrekvTpNRojsVpcEVSFFdcCYW7t\n", + "BSbeVLIhv2fS3k7dM+2SsD3QFTmDUflXieokoDo83EMXppsR+vlBIwAoDER1XIFn2dui4UGNj5nn\n", + "lL4l8ZTStZDLEI+BBCqawhbR3SL3P8+pWaYaN9DgkgoUUW7d29qCAKsK7AaipPV+T1qQHLOqRfv8\n", + "+huoSO/37jI7nujmUH0a1C3XOQR3r5DCn18H188bb30ylj19EdyxFxdBFfuttzxB7gG6ZOva3WPv\n", + "Pwn6SGuB9ukCf/rU67l7MxCr9zfublqBNP4D3/uDseyX3v11M3MSdylulwFaNY3OIRDrb4/uHuq7\n", + "ZeLTBq6CuvbzXcJVWq/d3bA/kagMwq64HcgZUNXjGFiiOkqY9+oWpwu81+Oo6C7j/4DggnXlfdcg\n", + "IXAHV9jl5CTyP/KFbzczs0/kfk+e74MbRxNuF/BVKtk5Mq/FZUIysCZtbeg+wk1R9yBd8RpsUWGN\n", + "GUcfazUWMs2ewLqsRcfq2Ib7c9J5l1FbCn0t9IwMa5KuyUyGrMkZIJRvzT1xmUKNuyjcLXbC+QoZ\n", + "d0wcz0wYvQQWrNHvpST+pgusFL2z9Tr0BYn4Zr60dDpO4A5blaLsfWK2gyPO4fp8Gdxjtd7DfOla\n", + "7jGeVRavHFGXWQYIuNF6r2cD+sJQS9Je3JOcQUQzbUecX561TELdtn7eFkFGfSvuNqyPjXBFSEuY\n", + "0SywnlVoF+ermdmAyJJcAiYquplVFJ9zVxJpD0w0foYWosmlq+IbvyolRCpZsmTJkiVLluyO9uoQ\n", + "qWmcvUHH/FKy++EOc0l1tg+9rVId+uyF/CN3OjheScQWldX1twzXlLdvgg9yFK+r+f9IypuF1ZIM\n", + "hwYxp5KZ2cUu7DoaQakOCJ2e56tbtiuq81Z+PhJE52qvIJaCdLnpfLdwHMIuSQReIym7E6TJX72X\n", + "avNDITv3bImSxV/K7pf143EqEkzEMpPd50R0QlTpiSLOiOWsk4b1UqZgWu7cs0JbHox5BU1JjCDq\n", + "ag6zAW0tNCSZQRGyqylA2s801x5+0gL92e99t7rCQNG8hhzrmleSytM6d0iK3sjOedWEcOqbaw+1\n", + "/gyUz6m6fnPtyAiJuIeTX//yKoTp769dAXxVMazbx99+H65x/56TjW+fB2LtZz73LbHsX3ojkKb/\n", + "GpCuQoj1zB2mO/KXQKJOmq8RshONhL9vEepfr/18G1RlvfZxv7Egz3DE/TrunZxvyARw6Dyv4NDh\n", + "HgpySEJvL/eJaK4inJQaULL3/hiucfPYAzXyi1Cnp12QUPix3/+vxu8+kV/gWk7OpsRDKfti9oSu\n", + "XRwnTeMEbEqmrFaCkmIslkRkZ2tYuNe5rD81QtEPk/cTUbV3Dl5WAJ1pNFAnkpK9Tm0fZBQ8oEcD\n", + "cBj+LqrTmIsagLC6CH29uuf3vwQ6OYuIx2kUzeWadMBYK0v/QYH7WYuXYAWV7VrWX6J0kyCizPGm\n", + "aFa5CX3CDA+h3aGNDMM/7oVsD9XxWbaFnEEBIonSUBJFPRf4vlKUnkFJMu96SFIo6I3+ySNa1CqA\n", + "LgAAIABJREFUKe0amP9TPDLDcuwMLdEsQZ2BCHWCUuYIkNJnVw7EMOY6LfXZTSV+Vcyn/M1SkkH7\n", + "joFaiuYy7+sg6/n6UvQezlhCpJIlS5YsWbJkye5o6UUqWbJkyZIlS5bsjvbKXHvTNKOaR7eTJo2N\n", + "ySvP/F5dJq6pNDujmc3dHZG0fi7xMTWrZvDg8rwRFRSyJYtyKWNy01ySG+eAefNqCV1Sl6URcvgG\n", + "bolrIey2gEK17iVcBqq74VURCBiq5dSWGmuBXUGE1ySvA9sgvlVCxcMsaSzuk6oNn9Fg4r0YM4Xq\n", + "+WmcHWPm5HB1urncmLYLelPqMpyoQbPU1pKhE2WrCNnnlcDogOAnVYKGnorqzhjcDYXqgoGMqWLH\n", + "jBPoVMiKXdEzQav3TQGuZyEywge4SjIhYPc9yJYzxV4QRgfVVgruoKLyfnr2JLjb9lBCH0Wz7Aa6\n", + "UKpO/02f+SYzM/vggyex7NHDQFQvxS399GX47Wbrbjm6UV+TRMqvXwZF9W+Gj3OmY1YEHZ1Lca38\n", + "Wv84tHXtHXubhXv2svd7N0Gp/zNvfSyWvX/zG2Zm9gXRsXp2G9rx7PgUv4tf2QR9pH7y87YgAufD\n", + "kmysiaSjUrickLEOTAprZrZ/GlygjbpRngdV8B/5tu8yM7N/8WOuGcXsqv3JicBNA22lSd3tcLdK\n", + "poIKa4yqvVOVWssYqMIIAF2nuD7PKBiMCRG6xcVr4b6uL5wU/2gdxsKToyugN3BLdbpOgYDNca1u\n", + "fM7hQiZWDXLyJPpcq4rBBv7TaoM5OUsuznnvB1JvqMQ6XQmLfQW/4IW4R9fo/6rw+zrgXgzm9ykD\n", + "obodJLMDXMD6NORzqkPgw3Hvx6+oxK46ZnBzq7YXx4QJLeIIV7VJIvk8ZmCQOg2kJcSi+DwjEX8U\n", + "faoRz6SDqIOzTpPo4g247mkvyuYg72se96hoL1pZhuAdJ5Qvnz8zDUrU93SUpPHoz151vG6QWWPQ\n", + "9ZxuTFmLV0owWlpCpJIlS5YsWbJkye5orxCRymb50rJIAF6iSkqsjYCQvMIWgBgGQWl47kHenGNY\n", + "K8+ir8EMIdVrRaKoEAEJZ8xI0ZRpkPaQKC2tqbDrIWGzmCFIVMeWdmGHsdvuYtltFlCFw0F232y3\n", + "1IlkRyVbk/fYA+HoBJkwEHWnmeotSLRCdieY0s/QPNRXAJkCqFemEsAT26Why/wxCON+dNwZK7GV\n", + "SrVDp8gh/g46nrir9p3WRKXe0nfJOUiORCKVsB+BMxF9jmoCoqzMIALhsMdggxnCihPNkEse14eL\n", + "VXJPHj16HW0REjXQjBdPnezN8OxCd1BA7Mrad8mX9wJKwJxrZmYtAgkePAqyB7mQODfXgdj8/tu/\n", + "Gct++Zd+yczMPvs5R0m+9A9/IdQXKISZGaOPj72o5+Nak6i9f/rTnzEzsw+Q86/Yem6+h/cD0vVc\n", + "2nqzCuP/Ue5teL4O13hijtzeFOEaQ+bX+jjyCTYyxz/5emj36d2AAnUCYRwxnogCm5mNQKkOMk9q\n", + "5gQTNI/jfxRV7KmldIDMe+yEG0E9HuK3/9b3/EBow7UTtm+BuimxuUNOwEnqXoHYXQlywjGeC5pL\n", + "SYJJpFs8k8ESmSDqUQqJuiWJWkLYD20g7b/5+qdj2ftDQKKOgvBWGb0DgjAeSXbmeNF1nWH9Z8Lv\n", + "V4pSoS8ESKB3QBHWEX3SCu5N4vcOMgmqTr5Dv6+ljJIcxQwQRp5YQZ97ymQImsSsBIoIDpAEYA7V\n", + "bHBkZjzAIyB58KJMi1yrgjzJJMd17VK6xc7kGI1k7BkQiOcpxppK55yoVC9rcn8Mn0+3gnQdmadV\n", + "rgkpoLIR5JQqHZK7dfYcMTvrzdJH0jmy+Qko7nEv95rIlaBUU8lcg7Lwi7flnCVEKlmyZMmSJUuW\n", + "7I6WXqSSJUuWLFmyZMnuaK9W2fyMK+4M0jizzJ17UkolXC/JP6SYHa4RLxz+zIjYS30eJ5YLOTFe\n", + "d6mjNL8+3I0Ct/K4Ciq2M3JwNvszKyxMCaMgYooWCV2bpQikEKnXOkUXESF+ZZEzeadokUxwX03K\n", + "oWafZUt3q16LatNZ7pAoNUByucklXUlMBi3uzgH3opqxHukKE3ieirV6r+NfuU+E9oXDGBOz1kzQ\n", + "7N/lPK4U3Sm2QWBnXlZJ9AUTnvY6dkhUFtfeOCdRbleqBN3gWnKfpsWHONYKdUFcBqL29sLdbRTt\n", + "Pty6jtQa5FXqYr187m6kFdwjO3G3Udk6l349Au5/8dI1qBgoMYrL4gi31CDJjT/76M1w3fffNrM5\n", + "wfSTF6EN1+La3lMd/NL75CUGe7t5IGXQ4hF33+WDkLT5U48+5ccdA3n9Afpp6p7F7xrMl6P5PXnZ\n", + "B72nQdxDRyRLHmWcPtiF3zy/Fb0n0AxaSdr7YBvczJ8FYd/M7Ef/8A+bmVmH/hxaUZimpptoZlGX\n", + "KBNlZyaB1eWUI7GSAJgSPthB3C3M6BB/oK5AELBPknic61otCvhruKCna0m4i4CWjbhAe7jxKuEF\n", + "1AWU3aHjo3Ooh3t01KwM0DTSdmVol7I3XG9KA5DgKhMXdNTemmrUTYKCSDcRyghd65msa3mxxChG\n", + "LKStuLa7qK0k7mO65eHjurl2bbMyD/26lmCLsaAbX4N4wvebjY9dztm9eKn6I4jtku2h4LNlPLPu\n", + "0outMnbMoiBzYoi0EEnaDvrCpFpxGKfbjWog4q88O5hU+1wieWrgFfJMHHoq4J8Rl5RAHb5wZLKe\n", + "V5hbpSThLjUa5IwlRCpZsmTJkiVLluyO9krlD879Pzuzg5jhNMs0PI5RzZTSEaZ7htjMt1nN4Rfl\n", + "FxTBOfMpolPT8g1V35L5tRLqbxFqeXV/WJz2w/UIdQEiJSTirANyJ7/lDi5XWYFs+SZO4l0JlCwf\n", + "dBdKJVqtTPijCq++SdEbxR+JYu1Ite9z5H1R+2b4Me/TdAYRU2XzM+PEd4KKki2vRUQsE4SpoiRF\n", + "g2vJTj/DLmTKdKdLZquEEDOIQULCGf5bmOy+CE5IqO3/x96bxNqSZddhJ/rbvfb32VZWVlbHIlUs\n", + "UkXRNARDEiQBNmRZsOmZPTBgGzYEeGZ6JHhoTz2ybA80EAxZJmiIhA1IggSDIin2pWIWq5hVWdn/\n", + "/N3r322j8+CsdfaKfy9TxisSnzbOHuR/GffeiBMnTpyIs9baa1OMOp36W/HOrZetbb1fYak4tRxR\n", + "PCz1qnA6AkiExAttU4HafXdvH4RtV5cegTo/9chMLejHEqe6JxYGZ+fPnHPO/eDdd8K2r3zN13+7\n", + "wD6cc26CFeZyZehXnt3y7RXx9v79V5xzzj1414vY88qONUL6fSEo1dde9d8/vbBV+iuoU9keWp88\n", + "A2IyGVunrCFA328MObmVveScc25T+XYeHt0Jn5088s7i5d6tsO0TCIFXC0Oa5lh071W2X47rXtKv\n", + "l7CHuFeZ2/sXXvXX+9/++s+EbS8BlWyA4M3XYlcQrCAkrRz/5qXUS4PIXJNNmLyiAlzWx0xkPksp\n", + "8mZq/MAdGveJ3musGCAIRolzKPYMERmlfmyN5yaAXxW+8zYbm2NY/y9Y0sh+057zn9ynmDtStQ6h\n", + "eFmQlhrz1ODZEfpHk2zwBQj2k0FdV6LfUv+zY2KT1MsjmqJzJxJfMkE/NrDuaNR+ANdkde4/u5Ja\n", + "m8sa9RdTQ1+nM3/cXua1CpYRU7mf0inm2kbm6bVv+9VS+h9JA7kk5cyRDMKxMKjJim1aV5ZzUTES\n", + "/wlHixeZk0P5x21LDkX9O4xJPtcHTA+/o+MUu2ukrl6NGn+btVRFQDUCOvw75xyB1VIE8KPZZ2NO\n", + "EZGKESNGjBgxYsS4YbxQjdQQffH/Ds0Ptg05Qz07yTWnJYHqYYhSDG0/h8cYmO8FCEmOz1X9AHzh\n", + "G64ei+mX8kZMgEVWOuslDdb8W3C9r/WN/NvvRrj/Cu+5ikgRdSoH1ai3Uz37IHOQdH6sMDfsO7Va\n", + "oKZCuX+m8Mr7dpc8p59wzqX99vs4+6mT8+dve9EPBG4aK0ddLbLC/ErrKsJoL2m2V8ROEDmu0/NC\n", + "ES6glLn0EzVSXHzJKohgTid1uELm+iA1F/uQbmg4JiUlnLYXy2uzrqCdwUv3fRr+XmYrSA6xLLFV\n", + "fVF4JIQp0s7Z+dcrW1VewmByKanzL7/q0ZdTqZ2YQwdFLcXx66Yfeu/dHzrnnHt6YvYDNKnLUxtX\n", + "t+/7/Z6dSf097FcRkem+11qJb2KwfzhEbbZe0vo7pNA3YhL7yqHXTb10aJqiJTRHhdgKzIFIZaI5\n", + "67Biz1JDbrj6XT/2+3jWWn+9CuRuXYjR6CefOuece+323bBtg3p5h1ITcIVVbyFo5jOkX781szb9\n", + "zJveHPQrL78atq1XXod1ee1RsrFqxM49OqFmgSNcO0XuqOXTO6Jn3bUdpsOpIDdtQ5PGbUsamioO\n", + "xz/OWXRTNCQd6Ot6b3+wlGtS4F5IE0P4EtoJAOFpOq0rCEREXHppnZMM5kQgbZlYB1C3qGaSNfW1\n", + "gtzhGMvEX69RashMA1RNUZUeCHOb2n2d4/qsxWB23fjreb0xNLWtPdJTr8QmgQaXuHdSOYfFxu8j\n", + "FauHLPPjQ68hx0It2q882O4II5BQtyq1C4PmVKE7zGdEnwS55jVZiSEnnyepWAhUKe0/pO0BYJVa\n", + "eym1VHb4wEQlfE71W98n4uScabk2MiZpY6IezdS3lZWNnQKWEUmmzMVnvypFRCpGjBgxYsSIEeOG\n", + "EV+kYsSIESNGjBgxbhgvjNpLkuQ5vfa2OynhPBWREe/bZROggkHCuKkKhfkHxda50iMQwg3oPv67\n", + "S5Teb31PxeaGhssx8Pf5mYd2K4ETKZisJQ02nUFEKbstAGMmQjewTwbuuDjHxG23swXtptBphraV\n", + "Qg+sWwrQxfWYWmtJCS7ZFrU/aFgTULwTgqBdUldBIxRMw1Z3csLDhaQG05xcoNYU7tHJwAEZf2ud\n", + "rpzUolJ1TJP2O64KsZAg3Sj8SELKROjGLCEtazBy0ntBbSK3GIfxdGJUzcv3vZD5/i0vcp6kRoVU\n", + "Fe4Jccfuum16hmnNqysTdneoXddJ/1+ceDH43tFh2DYB3ZaBglxLbb4anb0UIeZmDWpB7rX3fvgD\n", + "55xzo7FRNkf7/hz3hZaioL1QF2P0dwlx9FLT2kFMsUagc869fM/XzlNLiBr0TCYXqkX7LsV+YDJC\n", + "CrX8NkMqdnr4Oeecc+935uJ+NPZt/+7DT8O2v/zVrzvnnHv46aOw7ZUHnubbnxnd+PGJF+WXQpnc\n", + "bXxbvnbfXOG/+YUv+3NYmk3Dcj2kjxaXRjfS6iATCpR/D4TlCWuY2dgpg/2ISCpgZ9E1eo/hPglW\n", + "JzqH8B7ezkqppQJCOfE0p2ioXRFEzHZP0D26EFd2UlApEmtyoewaUPY6r9PFO6sVFyA9qXQP2i7J\n", + "HjxtdQXv0T8LWCNUqZ1ECgqwEh6fdi5tbeff4J5Z1HZPLiFsbhO7Tn1L+wWRT2Ae472+WolgGnPB\n", + "eCI0OsZ1JXN3R2G10P0ODGUhaf0jiMHnWk8R40hr0nGeprJDn9NMUNGkANKs+kxkLc5EEpDYllzl\n", + "K5BeaKJYGix70E+aWIZr3MgYbmrSk/Y9jmeVe9DOo5GHV4kEFWHqXZaraH47IiIVI0aMGDFixIhx\n", + "w3hhiFTXdQOxucUuo8tu61NdkXQhJV5FlKwTJWnCFO/xrVbeVrlKa0R0GGroqflYqImnKximf/Zb\n", + "3xuibv5/rq/8KiHNbLXS4rPDIxWHw8BuZKvaEdCfTFZEAB8GK9JdAuwaXwxC8MGqkoakYkIG9EvR\n", + "J8pXC0HEiEjpSpNp0uvaBJhtx0rb2k6ahOIfuYYZEJlShNVNzRpW1qIEqbOy0LNrLasvB2QrkZUO\n", + "0SnaL3RqYZFBsKrIJUSsKtgMK8hWTFJxaw2qiqNPbh9Z6vLLt70h5Qyi8/3c0KK9iV9C5gu7Tpsr\n", + "fw4Hx/a9y/MztN3QF1pnlCrsxaovE5+EDz7wCMy9O/d9ExtDX770VS+E/vbT37fzR1OuFyaY3b86\n", + "cc4597N/+a+Hbd//1r90zjl3/9jO9ekzv4puDs1+obvybe6AtOxNbBn46aPH/pwFEeM9uxGx63Ti\n", + "7QQW13r+WKUursK2ycQL+jcy/vanGONI0x9398JnR0f++8m1iPNhtbAvyQ77WH0fSNun2DaVFPIN\n", + "kKafeOXLYVvhfPsWa7tPaCxYQ1isCOLiFAJ0sRWoYR0wGtmxiDoXIlROsE2NBldIPOgETaKJYob7\n", + "uRPomrU49fs5E2AKO/4aKGI5s2117bepUJ4GuJnUhNuH3Ubn/Lku5HrVTMBRRJa2DgJ+8xet1lDD\n", + "fmpxpGzJMMgxmCjBCWW+tnk663x/Nop0Z/689NnRoQWb3sZuS1sJeZ5RID1AxELpRvSJnBfrnp6c\n", + "Gkq5v+/vp7Hc6w1MYmuZu/mMy+Wxz2SoQoyQ+VrA8eqc1dYj+q2WNLTVUPbDhbFm+y0SWhIJIknz\n", + "S3l2BNBJUf/0eduLbfudISFE5FSRQ9QulGyX8dRfz83AdJZJSdamLIuIVIwYMWLEiBEjxp9KxBep\n", + "GDFixIgRI0aMG8YLFpurF8QOLyJ+LJAdnW1VHLZbgO73p0J1ije7IJgcNMhvy3Uv9KdSB3D8SPeb\n", + "7Gi767a3sU4QPDkuL0WcDF+WUmDHMtQ8EsVmBc8YwTFJKdaN0QMOFN3A2Z1UHh3Txf8pw7Y81Wvi\n", + "/9UaVvS0Uih4BMfsvBN4FnW1rjd2/OXSb2s6a2cfoFr0tfQl6c5EagJmBb2tpJ961jUUcSI9sAZC\n", + "eVLA8j14hSTB7V4dlnFcoUApgG9a5WxxXTP1QAJVKgLIEoLF4yOjgA4PPS01gwD9cGy01+Xc02fT\n", + "pfXr8S1PN6ln06SGE7aI3VPsT0fhCCLvfGLO0l+876lFWmVdnJ2Hz779rW/5Nt0yeq5eeJrjSNzR\n", + "Xz7w5/CvvvWbYdsRkgE++vC9sO3gyIuxr6XtLeiew32/j01tLZ6TPpTbiy7zV1Kvb7n0570Semy1\n", + "9H/rvXuNum5aYpKUGo+1t2di/9Gev04v3zW673LuReFffNX8tja4TvsTo7H2Zv58RpltOzv3v711\n", + "ZM7miUObxUenBd0zgXh4fmbnOp749l1dSE3Emd+WaP0xeFsJs+cyUG+N1PrjeO4a5UVI7aA2nPpD\n", + "QVJQiYs6JRCzPRPbpxPQk1firQRKmXUtnXNuuuf307fWT8sV607ivGSe4hTXLqU2HotIyoWtKe0Q\n", + "WoyO5ZqAwaQErdMW6kNibtgIPX/d+b5QsXlH93Jx5+5BC2pNxrZnXT2ZT0A3aUk4iuKTjnOIfB+n\n", + "uLw2yvrs1FP7B/s2roJXney3gRg+6W0+2YAOX6/Fx4teTULpkvrkZ53QmEGOod6CucpB+D3Sczp3\n", + "orKEjN1Qd1fm6SCz4VgQGQfn6UyfE+j/XNze+UKhvnQUu6fyMsAxniRK5+2SIWkbYsSIESNGjBgx\n", + "Ytwo/sw4m+8KE5sPNvp/Br/FG+wO74TBT1m7iW+/amFARERRMhxDgA4Ttss7aBreVsUBONT1E/uF\n", + "56wTEkE15ld+pXM9kXpVQIK6QQP8P2NxjKWgstb0eziaD1NYuYrjm7viFRAHysqgYJqoiJMLCAUH\n", + "IkKI8iqnjtF+m7qYE8XpN7qcIEpmLQ8tCqif1LXDakZNjEdAP9pKUp2xmluL261ds200McUqTR1z\n", + "6eKrAnResn6Q6kt3ZEU/+bk48KPNk6n10x7qZI2nHiXaiItzh/NZnpvY9fiOT7VPz61fK9gObB4/\n", + "C9suTh+jnYawZTjv4/uGsDz6yKMpb7z1Feecc/fvW625Mzia37lnLt6LK4+OiA7TJVjhr5fW9vLQ\n", + "72cjK+c5XNYXUtWdSQlHB15QPZ/L97Fanu6JsH5BZ3fbxzlW5I0KhuH2vRbB7OWV3/eBIIKPn6Ke\n", + "HlDVvcquDVf9x8eGvhVI4V6LJcMT9onMSRR+P92chW20gigl/XoxB0qhOl0Ie2ugmZUgiBucdzkS\n", + "F3MKimU+yZg8slb7EdzjYh1CtCmRpJQOCPgaqFYjlhhEBLSuJ1f1mSAYKzZJxh+tUHKxvyg3/u/x\n", + "xM5nuvF9V8MBXCs7EAmXrzsCUr3YH7Q76up1TInXuTtlnb7BJO+/h+HUyvzDY9WaMMMkFhmTecHn\n", + "lCAdBdE/OxSLDHTd9rzHhBmd/ynyVwTlGe77ydisRm7dIvpmx8pWOO9a51NYp6xsPPM5ocgRbQLc\n", + "889QZ8+4TITdHJOKXPEqDhA5jlN5FFmfqaDd35/sm3Tgzr/9rOdY7/v6uS1uqErHOZbyPA1jQu+J\n", + "drj35yMiUjFixIgRI0aMGDeM+CIVI0aMGDFixIhxw3ih1J5SIYQCBx5DyfN/mD+MCpCDy/jAlRzf\n", + "21FcOICASuOAYlKIkRq6TGHXIIpWKJbFJUUct6vwI0V0AU62qFHkdL0wKHIByFih6M55uL0TdWKK\n", + "4zetwviEp1Wwx76li7u6iKNN6s+Cfi+E2ivB6aiPCx11KylkS68Qk5A614798a/Vgfo5GFnd2ekV\n", + "leVKrW3TwfSgqeT8WdS37WScBCH59vqBBTcLEZ0mOfpf90HxvAhm02KNthuNREfrpFQfF/S7WLaU\n", + "oPbopiu1YN1i6Sm9eyMT8VIc/MpLL4Vtpyhke7ZnouTV0tMilycmSj7Y8xTR04efhG0FKK053LOv\n", + "5/b9I1BqzdKoxTFoMZNkO3dy5mnEo6lRUPSFaXNxyofYtxG3Z/YOxfOnpyZ2X8M/6u4DE9GencEB\n", + "PLNrPYNg/+rcaMGnJ34/B/tGd9AL5+JC3KZBR96FY/pc/LEurvyx9sdGBRagABpJiphh/LfqrLzw\n", + "v23EA+sLX37TN10SOi5FyM1gUkoO+m4lRab3Jn4sqGM+i7amOtUweaQyb6EE99pKxcuYH5UWrXE8\n", + "/quedRQd91L4O/CSwrc/XvuxOF/ZNSFlQt8r58TTTm7JvPT7G8Hja6FeUCEBRdzOoUDPxAMvC/O+\n", + "VnuAi7jM5ymLoMvxg0ccK2Doswbq9Uzo2YSjWAs/k1LqtkXZbafng39VbI5nB2UZvYjDWYFAx1Xb\n", + "+TH79NPHYRuLZXcb8fvCPdkLCZaiL9SrjcJzpeX4PGWR4yHVBcpY9OUh2UolOAk9wLZfOwZ90rPa\n", + "hSTvDDwPzSfNOfM7bOTZ0fR059c24XqKLsGee0pV2i/+30ZEpGLEiBEjRowYMW4YLwyRSvvnUKVu\n", + "h8As2B8oqkJnXa3/xJ3a/pOtP2z1w5XBIA0eO9EX7dAktQTYtV/8q2iKivHsGMMGD5zQsW1+aSuI\n", + "yQirn3R7VZV1AmskXOmLsJG1iQZ1tVhriCsT2UXCN3PbRnuEboB0+VBn8zEEuJrqHUAnLQmYMp3Y\n", + "Vh8bLsV61uuylRHTlDOnqwWuNGSVDPWmuo1nSEVOG0WzKMAXUf7aN5DCwmZjvdJxfyIYpbC8kZUu\n", + "b6Jgl+BccEUeIAdYYLXOhJ20lkhH+H4raeXnvi0P7pjYOwVytbwy5IRC4dmeITdPPv3YOefc9MDQ\n", + "LAq1jw5uWTvR5LNnvg7e0V37jOhUKnYVX/myrzX3+DvfDdv2Dj1ic/XQ6s8tYDUwGRt2lbdDpMM5\n", + "56Yzj5g8O/WIVK0raIzTp+dPwrb7t31fLKWuGftdHbiLsUfHFBCmncbezFCq+bVHjogIb9bWtnO0\n", + "qbpj13AEi4PTT83CocK9sFiJTQDqOn7uDbNJmO37cz0T1I0p22utdcfPAF1OR4b00Qk7lzkhhcdB\n", + "mkq1AYiys0pSuJHGnzaGyK1xvp0gAkQCa9gkZHJf82uKXNOVfirI3ROgmM+e2bUjcq1C/Q5i9LVc\n", + "T05ZnKenUsNxhfv6orbahMwG0vkvQDyCUrX5NhIf7GG01h3d03n/y36JJqsTOl23swFzsC1Ybhuy\n", + "HvLsAuqUynweBP3YRyt2DZwTc0H/e3z/6tL65GTkx+eg1h0ta9RrAU1RhGsNS5JWhNpMGght08oO\n", + "/KzbRkkHZuehnu12ApZeOzoc9DJPVOH5RHG6oE/hfHaghPrugL5T5ojXX1FHWqYME9okQWpHREQq\n", + "RowYMWLEiBHjhvEjIVJJkrzvnLt0/nWt7vv+m0mSHDvn/oFz7nXn3PvOuZ/v+/78j91JjBgxYsSI\n", + "ESPG/0fjR6X2eufcv9X3/als+wXn3D/p+/6/T5Lkv8b//8LWD9NkIHrbEoI7gzY7UeLxr6GGm8Li\n", + "bXHYwBfoOfuodEC/0XdEID6amO8oUKyur8GJVRx4g6Ntv+McuU3gdNISyyuDM5cTeLw0Ispfo51S\n", + "tDWtUFxU4Gnafgytuvxv29Cf294lQ7pvex+kL7XIJOkJLQZcwqtm4FQOam/SCGSMvzc4r07OlUkE\n", + "tfRTXtGdXKkN/28vAtCMXjUibE0a3yb1YElB7dkYEiEsqRKphpxVvP4qfsT5iwCX9N1Y/H4SUAvr\n", + "1gS4LIxMpiBrDLIvW/ydG7R/eYYit9dCz6zgNyWi8A705WYlBXdLT9HsHRp9dz73Pkd7KJp869Bo\n", + "rym2rVdGI37vt37LOefcV3/up8K2R7/52zg/8fuBQPnBqy+HbR99z9OBeSUeaLjf5ktPSyjFRAh+\n", + "uTRqkU7k9+4a3Xn11J9DK+N5DB+p46nRQh98/JFzzrmjO0Z3Hhx6Qf0nn3oBPv3PnHOuQfLA0S3r\n", + "r8ePfVHn9craVMF7qha6ocO4m0lx2xUE6MPirhjjQm1VY3+dFkg8qSrxcQM9k4pgN4NjvtJIvI1y\n", + "mX/yylOErfp44X4WpjDc25xiNAHI3KmFzIAoeFoZBXhy5vvp5PFJ2LYHik6a6Tag8tdCt5MqSgI9\n", + "JsJ+OPbXM2vw+hLrdC1aDAooF20BfZ4ycSAvgo+cFhcfJr5ovVrOcb0aVGGbJhu00KVkA4MwfCby\n", + "gUApqi8dHc0xNnIVZ1Mc3Sm1hn9Fl7JY+P6kd5r/qf/NRKjaJhSSt3mC414d7YNQG/25H/X0AAAg\n", + "AElEQVSaSFYMi2CX8uzsSbfL85d9MSxa77dtlKqn27jQbSsMxhIFpXvZB8eJJnb1HX0B3VYMEsBU\n", + "jhE+x/4GVZA/m7z7k6D2nhcD/Q3n3N/D33/POfc3/wSOESNGjBgxYsSI8Wcu/iQQqX+aJEnrnPsf\n", + "+77/n5xz9/q+Zx7mY+fcvV0/9C/UIvrSPSIoDh0IxvCWmMgbOdGBwYsmYofmO7yRdoOaRxD9Dd48\n", + "qcRTF2vf0j5R8RlWdfpy22+nzvbPNVCF4MFFW1JOL8+RVj8WlAyWCJuR/ZZmzHmh0BHTelUATbE9\n", + "ji+C0eCAPoCktr/HlUmzw6Yi1eNDjFhK6vQUH68EJSlQO69myq195Gq4HvdSL6lK+Duta+X/7dRF\n", + "nKctq+9wTWprZ7CMYAa32B+ElaMMIjqa5922YDJJJJUd6EzrDLmYYSXYSO3Ey41fMR6m3j27Pbfv\n", + "v3X/J5xzzl3NjRl//BDiXTmt+dz/ZiMoJcdTWyv653/05KmlSb/5xTfQXj8VnJw9DZ+lbh+nIucP\n", + "BOH844/t+FgJZ+JYvYLw+pP3Pgzb1p1fTU5yQWkgaJ7u+fP/RGrz5ejDrDIRPS/XRlb/G/RnImON\n", + "QnW9m2dAp06eGUpysOfRpmXtUS1FGl9+xaNp13ND5Gq48l9embCXLv9jqbXH3Swu7NpVQDrWgkgs\n", + "rv2+R5UJytdAaXk6/Y6KDd0OuwK1CSGa3+hKn+hLYceaAk26OLM+4T0wApq62Sha5rcN6qABRZzM\n", + "TGz+zre/75xz7uSJ7bed+HYWgkjWtCTJBQl2rJOJenWS7NJgzi6l1t9k6o+7FPQ5/LaROqUphNq9\n", + "IveE7uVrTEZy25YslrAkfY3mJeK2HtA0tz13ppK8VOYznJfc0A3rxPl+GjIyRMmFucH9WY1s/DFR\n", + "aHlhwv5q5M/1tLY5ZjQicrRdAWP4fCQ9gXtdHisZLXEE/Ql2BgNdO/tCWIqGLImcPy0ZtMZjTouD\n", + "Bm0T5qLbZpPcDrdzPsd21fXVdjJRTFHXbhe0JfGjvkj9XN/3nyZJcsc590+SJPmeftj3fZ8MKxTG\n", + "iBEjRowYMWL8/yZ+pBepvu8/xb9PkyT5JefcN51zj5Mkud/3/aMkSR44557s+u3FwyvHZUC1V4Yq\n", + "4DFixIgRI0aMGC8ynn1w4Z59AJPjPy1EKkmSiXMu6/v+KkmSqXPurzrn/lvn3D9yzv3Hzrn/Dv/+\n", + "H7t+f/TSLHhtOCeFfAdOqNu/I1Ta/muKCNp+d+yD0N3AdwKeSSpiDvCs+l0B2lR4MPnjXdGHqnhu\n", + "er5Qr8Coso8FYNmskYKKfN/sxXcEfFghLuYm9hZvKXAFLdx5lXYktDyA7MMpKN8KcawUg+0n/da5\n", + "pvh1pvAo8OBKPKhWJWkMii5FsA0KUIx93cZtU5AUPvYDcy96hdk55vQgqSUBIKVQEYcXwSqvk8Lu\n", + "BeFjgedZmDkXWjCls7nQCITD80xg9I2H2Rdox/3+dvhsBJFxuxC1Kw57LT5SLAYsbFeAomvZSK+y\n", + "2cwKE1/Ao+nuK68455w7mNnxnzzy4uxCxskY4+p7v/PbYds3/9Jfcs459we/9ZvWALiIn58YjfjG\n", + "57/q25FKIWVA+tcoEDxfmjh2NvF0Xyo8JsWmg0Ku6JNSEiAW2N9s3woeHxx4inAjY+wa1NoYHkhP\n", + "ICZ3zrm7D7wqoZeb8gIFipUeuMSxKqFRX/2cp0znl5KwjGtxeW7bCnhErYVuSSAeTygsz+36ty1d\n", + "9MUzC99rpZ9CEXZRkdc8j6WNiRJ04HhqtFCNttQN/ZTsFFKMcZ0SDlAsNzkyz7C3v/O2c865xysr\n", + "2rwY+/lsJEW7+xJtKfQaY9yD9lutbK5pWiR2SLWBkFAkU3JHXyK5JsWI1I59r8T4y0s1vMM/kEes\n", + "nRy/oQBeJyBKBtRvDu2Q+ZfsVS5+Xy0mnMHzjA1sSfHZteHX9LrmUMOPCkusYLKHnmso9C2U3WrJ\n", + "ShnyvY4JMNJ2No3Cek1AyOhLqFUk2ud+abRcMkhy2n52tpg7ckn8CMfbKdXBv516kZHak7neWiy/\n", + "haRGE4rw8Z3Xxu7Oa/7+TJPEvfNrD7cPjvhREKl7zrlfQoNz59zf7/v+HydJ8jvOuf8tSZL/xMH+\n", + "4Ec4RowYMWLEiBEjxp/ZuPGLVN/37znnvr5j+6lz7q/863cwfKsP6MeO+jZJv736/GN3uv3r7W8R\n", + "/doh4tQtHZCObuBqipWeIn187VcwjXXVdH/dEHXT2nihLXqCFKfObUWUQeTcDZy92Rhxu+1Yr0jf\n", + "voHwhEZJGnQQlufyfbZJzosojTjh1ljVBNW7M4QvlR7NsGIpClu5lBQUA65RcSYFtc1aUCr0maZ6\n", + "01ag3yGeV9SNgsZOheJhJYhrMhBH0kVdVka8ZAqTcZUo38t2IHLMdFbrjBoOzRuIZ+9NrYbefO6R\n", + "jgMIsZ1z7tnomXPOucW1iUivLvyqP+nFgZqgpyz1eP7nJ+ZW8uWXvuicc+7y1O9XUYWQhn9hNfx6\n", + "ODAr0vXr/+yfOuecu3XHkK4Sq//5yn6b5rQzsWtSw0V5A1uDXATTl5fezuFQ3LmZGv1MziFntYPa\n", + "xvMenM21dl4FMfj13MbuLaBUrLm3f2jWCHRPr2RlvMEx1Nl/Xfv9zaa2bQ6kay12HryeqaAJoa5Z\n", + "IvW/OqZ/+/Neyr3WIaEgE5QqwT5WKxPA7+15lCgT9KPvsR/R5LKdI3GqHgElo8i+kPz/EhYHi6X1\n", + "6/0RjiFzx8W5b8uzx89sG75XzawB1T6Q28qu3XTPHyOtMNfJnBju694E8yXad6H2H0Qk5LfMT5Gc\n", + "BFcACS4VYeZ4wny6kXm6bshIqLAZtgqCPqdAszRRJQdKnYpNTcMkJ3WKR5sLQtia7MPEKkEk+Vei\n", + "julAkxq1zsE8OZxjt60bVkioUIF10JqzNqGM174G0yHnyv3q8zwkBQn8xYQyBfjo1N6rJQTGZ4MJ\n", + "Wq2LBlYcYR/btf44d+RauzAjcrvtrK9tz7IdUJhEdDaPESNGjBgxYsS4YcQXqRgxYsSIESNGjBvG\n", + "Cyta3Lsh7UWXhAHE2W7DfvTv0IKCz1NmfhshQIVMKaje9pOg2F1Fbz2EhYocko7shdsLJRMV7n2u\n", + "QLL/Ec8LjrlC8RCKHNaTpI+JwJg1/ImEHtiQbhQvDtanVPbSXGm3PU5CJw/OFRCr7CQIBuX4TfB7\n", + "EQo0eCslz28awOK5I6XnP8z0+zjsZm2wa9Ztw9M06u1ExEyaM/hjOedSUnUDqhK/xTn0iQjGKdgU\n", + "LgB1V11RyjZAxpn4I4Wi1ap/B6VVCwVQw7OlWvgv3nvZXLTrZ16U3FV2XiXokVLEsezj9dIoYJ6P\n", + "QtJ9oIzs+HRAhobbffLhB+Gzu0ee5tLzv4KwvRJ6dgN67lgcwB9+4IXq1cQomIbeNpdG943LYdHo\n", + "XkTEvK9nMxOMr9ekQoQeRSHfXjyDSkcPJKHFSxxD7pNTFCZmkd/J1DyreDMsxPesxT27Xl2GbVMU\n", + "QV4IjZiBqqU43jnnlmFOsGm3xm+ykQmFq4rH9f1ajY3a3WCCUI+f5dxTWrleE1zXZmG0IMW79IJy\n", + "zrkp/m5r+x5pTrqtj2fWJw08rihwd865Atcwmdg5vP2eH0cXkpSS5f7v4trOf7YG3bJn93gPkfle\n", + "yeOKsB7nkDk7hwyU6npi89QJ6OhWvO1KFK1VWjYrcG1lPi8hnua0Wwy8oDDWBtqObRopVENoVICN\n", + "eV/pPsxTSouRZqxBd3YDF28fqWQApBm9oCSxCGNMn52sfNHJfE76brnQAsWUT9hvMwrKeyZqaVLS\n", + "9nOaD55WtBJBvL7D8HFgIr7jWZiC5suyHdhP2J3SraRWbRt/K+oBV5SkT7UB/p9ENC3dZ2uKIiIV\n", + "I0aMGDFixIhx03hhiJR/ed8WcDWDFHofg7Te4BhebG3bVX9vlytwQCEk5XRXkmS/QwBOEaOmlVKn\n", + "OHB25X4GIrV+eAT5KKBqmodqMsKwpVnT2dUuXThsp2//w/06ZyhKRtGdgmVYrfUiGGUf6konCAFb\n", + "RQ707Pg9pN9r/aOUqJOgSejIbEe/smP1GnY1Vp9LQd+Ifslo7nA+KpTf0Z1Bbx/E64W6Dvu/c3GR\n", + "z4lIibVvWCWKAL5C5yZapwsDr5YV5qYmSuT/fyTJAZN9L/y+eGZWbCOIjMciwC6BBCxEbExRZq65\n", + "6zn7SWuyYTwhYaAQpPHJs0fOOefefOONsO3dH/h6eSpApmD57e98J2x79WVvp3B8ZGjG4tqjOGtB\n", + "iWiF0UIUOxcheAW3b0WfriGszwo7frPxiMyeOItXQEmePDb0q5r4izeuzIF7PvdtOjrwfa2WLHRn\n", + "v742Yfsax8ok1bpEDUMdavsHRzj+J2Hb4bFH7OZiXZESCZW7ZwN06M69B84551pJIrjqidzZOJm3\n", + "i61tCZCOrrZjXUPsvr4SRAb3TiWu9Keo5zgG0laNDWk6O/Nj8ZWXHoRt4bgjO/7Jqb9OxWjbHzAV\n", + "hL1HIklbiVM93O7rmsJ62wfrDhZSQ28FofBsbNf1GmjevLWxNp971OXwWIT6EOBnTlzB0RWsdpHp\n", + "xIZkg0TOgU/RQV3T8JyyTQWdzQU5yXGwVuZz1kIkcrzRpCCMl1ST+WnrIvN08FoYtAnIlTrFB6sH\n", + "eQISuRbopgjWLpjDB89J/6/O9WEuHCA52zY16a7nZHC4GcBUaLv/31zmMGZKJQPkEN8ThqEBOnq9\n", + "MIuVIyTXqP2FXTNBAj9bax4RqRgxYsSIESNGjJvGC0OkfCjSg39lG1eirdb84S+FkCXAoeV6wsux\n", + "fs/yGvEdNRyj9mqbC91Vw2+AfvHvdlsjM+BWn3tt1c8C5zzYL9/C5c0Yr8taQ6tlAwYpsTkPIm0G\n", + "R0xKvxxAeNvfD9XXk61tsqhxNWpx1aJHYqp92umrPFAS1UiRt8a2UpCG0cj/vZrLCoppxVprjItO\n", + "lUhhNaH119jFkjkuCAQQJLkjign0SCPh2cGpK6qW5jT1sx8XLAqYiyFmWPVr+rv/m6jCyTOrdbdX\n", + "ekRmLDqjS5i06j1RICV9um/Hujjx31uuzOjx9h2PktSNVHpHPasGKfSF1iZEH37yidXLu3vvJbTz\n", + "Udh2uOcRi1Fp7ZzAfuDRJ4amvfbq55xzzj1V3Ro0L6ydpytD6vFOTs0kkxYat+6+GrZR87EWnc/Z\n", + "R6idJ2ezxop0IX3CVPsc4rfrhSFYBQbD6toMNDvUcxsJ+tEB/Rvt27YF+vXw+Dhse/rEX9vxyAbg\n", + "eN+jPhuxhJhO/SqZ2sDVxlClBNqgQmrNVSOvocpkBd02/vh9qmaO/rwnI2l70MjYMQrU4huX/nuK\n", + "YLDu3mhk12mJeezJD/4obGuSDfYhSA9Q2kysBlizs2jt3iGaOl/4e6KoZKwD9cpau9bUpuZiyJoD\n", + "EWlE38ZpbHFtKNU+EFudpqj1JAiTyjzNsp+9IChJvm21wDp5qeqW8EwYqU0J0S9BpFhXjjUMVefT\n", + "Y7LrW0WptrWcfD4oqtPgHlPkqoH5Zi/XmHqoPNXXA7IJufwfmofD1oNvA82Xa1LAzkPrtHJs9YLm\n", + "Z8X2s9Pq5G0/J2k+m8k++KytxTrk4syjz/qIrwG2lqJ5Dc9A6U/VVe6KiEjFiBEjRowYMWLcMOKL\n", + "VIwYMWLEiBEjxg3jxdkf9P1z7rDbKaQtIPtcxHmk3hRG5NvgTvuDHa6nu9Teu/7a5ZROOlBhRwp6\n", + "u53fF/ruOUoxUXFoRzhT4Hmcg/SS0XzKLaIzWkmr3zDVt5I02XAw0INCBVDQ2arbPBFgNfHmcQdW\n", + "D3R7FwqwprOufY3u5erAm/Ye7p2BbiiE4iCNclUYPLtBqrvSnW4DuFng2ZwuvnI+OVLRa6m/RR1r\n", + "TypQRLcpqM+8VBqPPLLUi0P/aLmuCr9Jpf9JB6glAQW1y47CZnNnvv3AU3Fnz4xuovO3dn9GEXmv\n", + "Y9If/0DE3msIbzOhtGk/cI2af6u10V45VLaaAPIR7BFef+11awAE2IeHZlPw/e96mucV+d6jR154\n", + "fXzbxOuLuae7qjHGQWfO4mtQcM1KUvORfl1dmf1ABSqkFpuMNSD96dRorDUcm5drE+XPQK1doYZe\n", + "o7XZYENASs4550oMmD4xB3haFyzXkkIPEfP5pQnVD/b3cV52jB4U0N5M6TaME1zkO7esTza4167O\n", + "RUR+Acd0oR9anH/bW9/1jadvG7vEbgMKspM6cUe3fY3BNcZEcynieA4FoT2Yiv8Pf+UXw7bRXd8/\n", + "lVB2CZI3dOwGZbfOHZBIrNe+n5pMrgn+HOXS/yktQYTaY03AQQ07f4zlue1vg6SNzNnY4XV3qLGn\n", + "UgAKqjvNLKJeWuwnOuxvJKL4IqVQXuxPeloiDHxn/Ge0BNJTgLQh1eoIuOxtoxYGFKDbjxeLbRqP\n", + "SvpcMo9YDaOV+55SBmO95JlMqYJaLeD7uXYearyWkqhTw2JIXfFZNSEZlg/x/wV9pzVUaSekyWMZ\n", + "KEW1S5igUoM6odOpP5M6qS3mYq0K4Fyk9mLEiBEjRowYMf5U4sWJzdNkIPDju+cu26tO0p8plBsU\n", + "304p9pPdp9vviHzBbkMa6nZ65WdVl9YYvBETTBsU2+vc88EFI9OFhymnNHqT7wdVvKJKWBGpJQNW\n", + "2q0K28MLtKAU2HeLlUEqb+HBCDGR1QoF+CJO5Opo0HcBahMRI1b2WpPJrAa2Vz9wAXDjsQmWmX5e\n", + "lYbSbK627R/YZ72sPrKKNfzUEoImlSpKHFpiqKlhyrxnsQRIsE0F+KwrV01NRJqWOP9CV5o1jm/9\n", + "Xi9hejilhYEhCKdMIZeuPofRoKb/clVVjMQ6oPbISS73TjX2f2/EJmGB1P4kWIhoxgbRAts0Qyq8\n", + "iuJfe+AF6M+eWl21L3zB1/DTel19TuNAE/vm1QTH9d87EmPKDz70CJYKuzeoMUi0wjnn9g48EtYs\n", + "DKUKSRmy+j4/98L3Oy+9HLalsDE4O/NjTE34WlyLtdRwu/Wyryeoaf2sTXcpgm0Kf0eVjYnFle/3\n", + "RCwpVjD2zKVOZYbVOW+T+caulwPCkWZ2XpOJX/Uv5tZOIkaZoN70RqxFbL8GAjkeG+pFlJT1D9va\n", + "vj/Z99enE6j54HWPYH3v/Xft8AAiio0Ii+l9uO1bHBJhnJM5niixGsiiLUcjTTbyf2dy7aqESJMg\n", + "ImjzamW/vV75Y+yrmSnQvBHQx0TRKkyiKzn/AshFLpM32ZEiU6uJcnDOzpmQXdmMJHTZjgSkMO/I\n", + "HIptRBeds1p3jTwT2s222JzIViZIPJ+nyUCojqQAID2K6oRrJywBr7HWlawkkcjOh6eo7BTarjgP\n", + "a/eFon9qtYD2CtLPX+ZSJ3N8y88TWS7IFcaWolk5UecBCPXZmFNEpGLEiBEjRowYMW4Y8UUqRowY\n", + "MWLEiBHjhvFCa+0NiTzAcwLZ7SxvQyfsRug+Ooar7wOdwtWBtWWtPQi7h1bog5btaq3+duC23VJE\n", + "ueP4KoB3w9+qZxXd2wdtIgU4gFF3uH1TvL7Dnz0RyJIsRw6uqBF4ugQ8vcOcd3iVWMJIKCP+rTRK\n", + "1kHsKdQOu0eFjcHuCx8mgvuPJl5QOh4bZbEqPH2yqQV3Jd1WWpuykmJHO1bb7qBb6ZUVYGGBuAM9\n", + "q9QylaVyDuwLQaeTioJh+V7CRAXxlgLNU9aAvYUKodh3sTTKiHXQOnWHZlKCHL8io9DLsdDbh4cm\n", + "1KXwnjX/3GBMrrFJaITMw96V1JA7haD6tdfeDNuuQbNNJ7OwbTb1fkerzdKOAYq2AVW3d2x15fZu\n", + "3fbHFHPsPdZBE8dqnngt/dpijaj1H9mPy6WorXtPVV2dwONp39pLD7RCKIkW41rrWhYj/5tM6sot\n", + "4azdi2dWj/at5XuTA3++19dG3yXO/51Vvr2jyd3wGWstqtNyB5GxeuZ0dAeX+oM97ndNNrheLLFf\n", + "63f6oa1qUGZCI0/2/LkmQlnlENE7pTtxT2alzp28x2VGCbsWr7yec6f/fynX5jrcQ5frs7Ct6vzx\n", + "WzmvEeaCQtoODXEQszvn3NU1KCuh4OkLlSCxJRMRO0XmhVwACq+1dmr4vvzNeVwdwAMdKG3nvV1j\n", + "PtXzCpU9ZLLpMBY1UamBZXmj1Ttwb7et0eIp6XaZJxxlKwNPQ4rNeSzFYLapQNKhKkFI0XdJsv1b\n", + "fcZw3wMKFNcnSA9kTgrUnuyXPoqDyh6siaou6iF3SsTz/fDf5/ezKyIiFSNGjBgxYsSIccN4YYhU\n", + "mqZDZ+9grP3Zb359QK623yoH6ActCZo/Pm0x2VFAZ9im7WPZNjl8cCBXZ3O8VTtd4beD7+t7bM+0\n", + "Vi2XhP/RdFWK3IdYHrY1svrAv3Qdd84cgCn6dYLgpFi5JFJfibtTRILo06BPHEXE9j2uJvT4TEVN\n", + "pP5R0vtVbIq1W6KV0SEK1GrtRQlbBb10GMWKCNL2QIWqKc5jYH/AlQiWvcmO1Uo7GEJcrYk7c0gd\n", + "N0SgRJu11F2SePSjleNfL/zK+irxq+rLlVkdpBCn92sRcfZsrqE6RYHkAbFpmBQQBXdqHQERsYiH\n", + "uYqkAL+QMTGuPHI1qgSlQf/kIuJvln6/H330Udh2fGsfxxKrBQjL50uxM4AVwQj9NBfB9Ouv+Xp9\n", + "V9d2rmdz//2FuI2PM2+ncLGRtHacK8XR/mT9NTk8NmH1D3/wQ/9R7Y87duZEnkEAnmSGtMwgbD84\n", + "MgTnI7i3FyIAZ0241craztV8ObL+XCHZIE1ElI1/RxNYgsggWq/gbC331ZOHj4Y/dIa+N4JSpHCx\n", + "XnUqLC5xjjJPEYkFcj25JX3CeVWQ4yuI149eMuTs8ArIldw8tKTQuYNu5600nmgLHeP1Btzgvltk\n", + "4vaebJ9DNfXH2F/ZPXGFZ4HOZ0xo2TTiwE3UeYMkEkEriHRXgmC1GONaL5Gu4GrT0hBNUZiq3bYp\n", + "6HB8oqkbsTVgcowbuIMPmRbnzEU9EZSsBxLVZ/qc8OOoEYQ7h2VFOrAn8v8wGUPrr3JMJImgxDss\n", + "IdKMNQTlWuNvTUpp2GaxRODn2XOsjj/HdGsb3wU0sYeIVa99QjujZvtdRK0buuhsHiNGjBgxYsSI\n", + "8acT8UUqRowYMWLEiBHjhvHifKQSNxC2BmBvyJnhqwrFYdug4DB/qtTStlM6aZ6wRaFACtZ30H07\n", + "KcCd3lL6vWTwj28zYUkevtv6/uBcWYxSBcA7DLeCs4h4WxEWTlqBoAFtbwDdFoLEtrBHH9Rsxv6U\n", + "nuzhaZULZMojtAKPbgAZ17VSe/g3Uch0KOhW2D0UvhRofTyBA7v4LREyV7E9hZ0DUa4jPLwtQA9f\n", + "EyqKLua6D8Ls6lNGprKR8ycsnqQKgYPubRTu9v3zyYUvzPvKwYPw2UG6h/MzaH8MH5e8ML+tPPef\n", + "5+LB1bYQO3dGbbFY8WJxFbat6dUFh+e2E9dtwv6dCaFTXP/J2Kito31P/ZyeWCHjEeirorDjL0C3\n", + "jSt1O/aduzj31Npkz2g00h2VFEM+PrzlnHPu8syKIV9BRN4PxK5+TMznWqDY040roRZXF34/r731\n", + "FeeccwdHt8NnOejuu/fvWZtAez19ZmLn/T1PwdUr87FaQTyulNUIVOliJX5PIex7t2/5MTBfwPdM\n", + "fNTy1PfnxcIow+mBP6/FpV0neuU5oTvXDYvxalYEky3Uldu3ZYb9VlO7hlNcu+nxrbDtOx+955xz\n", + "bil089GBHxONuMhTNqA0yiYYScl8/hyL0otkoEdR7XUn3la4h8pKcAEMhb2xSBWW/vOVqNfzwvt8\n", + "tUJ3tqDWMkzUw+oM/l+VEXTJdgJQKMwr80mHOTbV7zUsUKxzrP97jftVi/xaQWObvNm+AT3V8Vmj\n", + "InZQkNLBCT3LBmIRPguV7qJ/IaUl1il8Pqh1IyUouq3EuEsyoZv5zNIi8Eu2d9t3yvZlry4trqcm\n", + "EzGJp5DvcYypiLxtmQAhzzMWSFbx+o53AI2ISMWIESNGjBgxYtwwXhgi1fb9YFUfXL77bURKhWgB\n", + "Hhjk6YcPt77mBrXj/nghe7JLxMbVmraz33775kp4l3h+4HZOEWNYhenxuX/Ztm1iG1AttUnogzuu\n", + "LOVSCtvFfqHjCgtp0LU4bKdEsGxI0BU819Rg1jxyEt12Q5tmW8TXAJ1KZDUZUJqaFhIqjgQiJaJH\n", + "1ssrREQbCi+qi++aNaxEWEt0TlKC02BJgF3IaTHDfiOoml1/RaTgol3bftcQiI/UuoL7lWvScIUH\n", + "AehGEKE5hNUzcb2m/cHBnlkYjOEG3jSGtNQ4f3F/cO3C76/IzW27L4lI+P/fP7B6eWcnZziWoU9j\n", + "1KtqxEX58sr/fe+eoWn7e17QnVWGJvVQytciFC9x4EuME7pqO+fcBOn0z04NQatG/vjVANWi2NXG\n", + "7uXco0Pj3FzRX3nNt++9H/5R2DabetTl/v2X0F7r69VTb4lweGhia1qYaF23yzP/vdXS2lnivEcz\n", + "u06X5/68c0Ep12skVJTWzjPUzmswXqd7Jo6/RI3Bg0NDhJZA2LTW5RrC4strE2UTYU5lUKS4Zy8u\n", + "DU175cj3BVH6TC1B8NNLSQr59Xe/5Zxz7ry2RAmUv3TT3IT1HeCctdQk7IBSNjJPs3Ykk2205luB\n", + "Z0EtqEoNdKaUpJQRHm2ziV2n5RJC9Wt9TkCUr6nutM5gwsqgOgTuV7FfCck20qZgE1CLABzH0qIX\n", + "NWw/ekHE6PK9gnWFoiGh1Kk+J2gXIIlVRBiHT7xtUXZ47skxOAcVghxR5M35tJcKGD3Oq1cLAcyk\n", + "ihJWIySqyPOE8yjdxJ2z+6Nv5B5Ph0kxGhugrqVYsoxGo63vhdtD3zFoU6QO9HgmbSShYyEI8K6I\n", + "iFSMGDFixIgRI8YNI75IxYgRI0aMGDFi3DBeGLX3vHSLaGMmVEjb03diWxyswlI6m/aCmZqzuAh7\n", + "6e0UCh9v+y5l2bbAbCjOC5xh2Mb9qe+Gusza/oa/HMj70F4VlhMeVRfxpASMKj+nbIwAACAASURB\n", + "VJAxmc+Bj0a77fdEzxaeT73Ryw8qSJxoCYGqEyyhVXWdpbO7OpvndKDulO7yFIQYULtqRB8pwqkq\n", + "oiQ9qVAw2jw00tralqHgbmsMVBCxNmuliofjKZc+XAffFRl/HYWlKqL3bdrs2X6XY9AiMnbpfdVu\n", + "bFuOIrTGCip0ve2Ovn/saSZNCqCPjF5/FjLerI3aoX+WClAVDnfOub6xY92/9/Lgd74tEBuLA/jR\n", + "oacDHz36OGwjLP7n/vzPhG3nF74tqyujkeZLTzcegFLsSrmH8OfxsVFrZ8+8V1UjfcjTVrov6HPV\n", + "gwx/X14atXj3rR9zzjk3QTHmVCi7Db2ABv40BdptNF4HCmbvwOi2DS725akdq8NgXIgr+/7UC9m7\n", + "HYkqd+74/WmR2dmev651o8WtT5xzzj14xahVFpDWAsm8/+dXNiZmcFYfj6zfry/89Zkde1pSacQp\n", + "uvO751a0+v2lTzLoR3YO09ZTm/XaKJEM1ycR+pbcc6rFzSFkZq+r2DxDZkch36ZjfCZsTo7+LMf2\n", + "2+mB//typeJt/mV9XEMgXuDeSOSerMEBKrUbBpvQc6SbXC/yCVJvqkqABGAjbvdB+ZFsP//yvEBr\n", + "5ZmAZ00vO2ayUauVLbBNC7OHosEyxlskt5Tin1aOSrRl+/s5qFitIjFDIe9qrHOSP7HRSJ/J/nzk\n", + "0eHGU9+3Su3xGdTsmOt4nZTOY+JZN6iUwjlZfQkpit/2iizFvmssCRe7IiJSMWLEiBEjRowYN4wX\n", + "V2uv7bRcTkB6WkFyglPsQIA9tBBwTrRjosAzB1b5Xj9Ekwa1gUINOW0U3n5lJyYAV3fubUhkV00+\n", + "07jxD0nXTLbbFIR4svwK9fnkTZtohpZLIjqWy4o0OMpyVdHqKgxIizosMw241NX/tmCfmwYgXHjD\n", + "1zRVOCvLapqrTYoYtYbaEgK/VvKPrQ6XJiqED+1YRAllNVuvuEqTZqbDeoaars7VzEBEGlJo7Xsb\n", + "FLZbzeV6jrBKlvGUYXwmrV1QXrMRbAKO980degIn8FSVsBgf2ic97RFknBIl7eVk6ZA9FZuEzpa/\n", + "zjlZNfsjO+ecOzowsXON4xalrVbXQKzu3n81bHv8yCNHTx5/Grbdvu2dys8ey7VjO8P1tPFCZ2E9\n", + "V46Tr/7Y18O26zXrL9q4ov3CvZfvhG0lEJFUHIuPjr3dQVZCxC5j/TyFi7igdEUJBPFSXOxnHtWp\n", + "Rtav8xMvvC5LXSWjz2TsXkJYro76U+zv5MLXMJxMLAFgfe2tENLO+unolkeOJvt2/ORTqpLDJnd5\n", + "6dvUi7N93fj25WtJgMD9WcGKomQtPedcBvfq6xO7rsvNAqclyDVQnEbcqUPdQ0F4+b1B+j0TOjih\n", + "CNLBemm5jNMC92kp91qRo9Zg0clvccxc7A9KtlPd032bMwjKtTpCjnZ28qzh3K02MeFWVOQYCTiK\n", + "iDcr1F9U2xX2HUTfea5CaP93Kg/PlhC/JuqwUoPa76Q75k7Op3I+IySUKBNR4L4gEKcWNiR98lL7\n", + "H5/lBuuUSGwRXXdAhwY2Nei8Vp+nGFv5c6ySc86VWYl9ybluE0eBJcoK22812hbl83t5ouf/2a9K\n", + "EZGKESNGjBgxYsS4YcQXqRgxYsSIESNGjBvGi3M2d8lQMBvcvrcdXgcFctNt3wvSLAMBO+FYPUhP\n", + "v40dXlBkzHaYk6t3Bdukzq72220XVaXqWlOFo2nqmUXYWyBjCjHzbbolSVRY6P/txMeoIgQu0HaA\n", + "NElPiWRzAz+TXMT5DkWDlW41sbV9LZy30KiEp9XHiLRMI8LKNeiYBJ9pQd3l2v+dijqdDrupFvls\n", + "6eOliQL+30boyx4CZT2f4FsVRJTqoox+En8eY/TEd+XKt2U52i7GmfVKLYCC0KLN6O8EyQNVavRM\n", + "iWLBeW+C3Q1otFzAaMLOtYho6U6tQvFwnwi0P4PPEe+JRMTZLLzbbuyavPTK6/4zEXbSAfhIROE1\n", + "oPd3v/9u2HZ5ucR+7Ri8/kskIhxIQd8WClT1PWowZq+W5phNsbEWDa9APZLOcs65HBTAKy+/Hrbt\n", + "HXnaLAdlt1jYfq+W/rdVZtTm1ZX31jo6MrrNZf6aLa/tWNOZ75/LKxOlcyra1HY9R1OKeEVYCzqs\n", + "LEqcn4zXULTd7qHx1FOBWvB5Dpfz62s5PvyWJjPx9kKf1Uu7x8agCOfn/lynB+YjVqKywKN3fyNs\n", + "y8nj9DL/cXJtdZ7GR4P5nHO8k22Yp/shneOccwXvT5n/+PDQ+ZxzRiIJSEFYndq5Ntyf0JJkcmsW\n", + "vpVnCIu7t+pYzudDP3gC4UNxQMf8rBUgOD1kO5KXrL80AYjeVvb9PBSDl++RqtP5DM7zg0dcSlG+\n", + "UfXTib/+MhU4FFRwJWjRQrygmKCU5ZLYwMoOOyqLDAKyBD1Hzucbnbu0gLJzAy5ug2dnKYlSlFQ0\n", + "UvCZYnNNBGuDQF+T3PjcE0lB/tmYU0SkYsSIESNGjBgxbhgvDJHq+mSAyDDVX5EOIkEDE3O+kWfb\n", + "wlpdETCdvu0VOXpObD7Q8G4LwCm2Gwrh+C0Vhbut7/F/ugF0w4+AqjldLfl2UujnT6cdfOaciLJF\n", + "bMeFQC3HoqCyqGTlUgydbdeNrWoTpO7qqj5Ltx3b+5b7EMEoUR1B7tjvmaTQ0hV7LV0yn3skot1A\n", + "YCgriAYp9GmhfQjBpoiouzV9DRQ5xKZOxfMUj6oAFihNBYGhKBZTCFFXKxGx8xiyBGmABK1t8R9q\n", + "QaaCXDYV+lgEmEf7PrX81bH/98GhiaM7pI53khtMi4nZgTlhs4ZiIUvINb6XySqNyFVZ2DXhMOJ4\n", + "ykRYX448EpPvW/25NUSspaAP1ys/jpYPTYD8ysteeF5VJlT+9h++7Zxz7vDAxjhHG8eJitiZaj5A\n", + "3+A8fnDbUvKfPPS2C4ulIWcjCMvv3LofthHtPJR0fg5t9muRGTJUlP78NTV/Aqf0UhCka6AU1chS\n", + "pB998gm22bkugaIlkqaesZ5ia2Oirv1AWq58e8vK9kvn9enUrv9m5cX2dWvnf3HuLRF6WVWv5n6/\n", + "ubjN55hb9PhZBiQUyQnZyI6V0PleUv3nQNgU/aRDfaO13uj2LW0KlQXkGjcUdNP+pVZUA7Umexsn\n", + "RB8yTf9Xj5Xw4+05nvroRpiADGgyE0taQZVazImpoNTUqav9TeZ8+1Ybmbs4d7aKSA1rjTpnz6UJ\n", + "0vpzQXrCM0uraITmiWAcSQ4bsZoYwWpGH7IZnMdHExunk5L1PCV5oCDqR0setaQB+yDP36ShdYvU\n", + "VcX4aKR6g0OVBa1eEZ478ixgv/eBEZE+xLuAAqJ5T5se2UfP66oVOGC10Ctyv83EJF1EpGLEiBEj\n", + "RowYMf5UIr5IxYgRI0aMGDFi3DBeoI9UHwTGzpnbtnqRMNTHR4Wyti3Z+ozwae+2hXqEJZUeo7Op\n", + "ejaxeKZSQdxvKxRYE2BBETvjGFpcklReS7pHPqNz7EREf0nqofpaCgmzy9RHhN4/ev4JhOKlUHtk\n", + "LTpAzMuFmmz5E9fCzh36LpN+oqPyrFC4He6wSu3hJ6WIEovCw7jjymDkzdo7MC+vPD3QbAT2JY0r\n", + "vi+kgxUeZveTHsRW/496i9CzZlC0Em3D/04mQlnS9kdoZAqrV9fizpzQW0gEo3RFF01stY8xKc6+\n", + "y8TTPUeHb/r9N3asxdI7TNcLc8eeTjxVtl7a8Q/2PT10dnIatrX0kZHxPyKlI9eYruwU9tZr80da\n", + "rvw1ORTfqaNjT+1cnp2EbU8eeRrr9ORx2PZdePC89oUfD9u++KUvOuec+0e/8oth2099/RvOOed6\n", + "0GepHItO+OqYX4389xZLE2zfPvZ06MOP3w/bZjNPh1WV7s+Lscd7IpTHfb/GuVa5fuZ/2wm1PoYY\n", + "XinrezNPfX30/vfDtr2p38/p6bOwrQHdfbRvQnUKagtxdGebVvBR64TGGoOyrMWyfzLyY2JzIZ49\n", + "oHkv5PikOxPx0bq69ILyBw/Mv4xu6PdfYvHiWj7z7awK69fLS9+vq5VRiwv83Qq11KzhWJ4o7Yax\n", + "KPdYA1qOY1jnH4ekAJVl5LgntVIFP+9l+meiysDvyW0n/gRvM0gWapnrC0pGhNqjpKRXF+2WB1Zv\n", + "KT477KeUanRaSB3HrUDPJYOi0f57Ta8JOBCMS4HgPKUXkjST4v2RjScWZna5PgtY8FxobhZwhn28\n", + "7tcSxVRGARpNijtzXFepUpWYk4U647Mtlcl7qdUo3JCKTiDHWIm3GBNaErf9TFAB+grPGxXFF0ie\n", + "0CQPpWN3RUSkYsSIESNGjBgxbhgv0P5g+AZr4rVtYXEyeKveYR2wY39cHSSiQGMtviBUE4EhUY+R\n", + "IBI5LFibxo5lzte6gkQKp6BpJp4XlCLUzsNbuPR+iZpEebm9+p7b4tu1WB0msiIpKtokDDwJfCur\n", + "bfE80/rTwlYcNYTdvdSGYq3DfFDrjuegYsdtG98SK8eR1HWi2FyNuuvOp1Yvln5Vu9HlGrouL0VY\n", + "iFVtKfa4G6xgFU0L6cyagBAM6GUbmjfe839MDmT1h1XyeG8vbLt8ChG/WEes5v6atGI/UMA6QJX1\n", + "LWwSchGFvzrzlgEZVmSLjSENvCUquU4UnqrVxtPHvu5ZIcLyuoZQX0ShXNkWY/vtGlYURBWL3JCG\n", + "DRCRS2eoxnvv/JFzzrmTZ4ZIffTRQ/+9hdVwy3E+73xgAvSf/Tf/onPOuS998SfDtg8e+n2/9upX\n", + "fHvkZq+Qhz6qbAW9gIv5wcyuyekjf/zjY7MpSEKyh12T27e9aH65sj5mKvp43yNY19ci7Meqermw\n", + "LIISiNTt25YUsAHSdSj1uD555uvPjUfW1+OZb1+W2vkUQDbm0ndVwbR/oHSC9HabbWf9pfO/PT85\n", + "C9syIMGHt62fJmN//KuFIUd37nrhvd53B3seYasmftytL+1al3d9EsGHH38Sti1Qu/B6Lo7pQKQ2\n", + "0td0L8+VdcDqv0uk2kHPihKsdqDXBEk5gmp0mAvTROduCOUHNdkgFB9LZQHMidkO2x2quHtBOnqK\n", + "mLWGaUJxsiDnHe5ZqdTQ4bdqp0ObBk1KoRNAeHaktl9e9lwhIfTrwIk8Rw3TQhOVUCljKlUJMN+s\n", + "ekHYgabVYlNTovLCCPODojXMWGnVbR33riav8FrXglJmZBikn1Zrf/zF0s7n7Noj97Q92qxtrPFB\n", + "MRDAA6VSoT6d9dWFocJzqhrbHFsWrDJike1gyjQiIhUjRowYMWLEiHHDeKGGnIrWkMtUrpIIQyIp\n", + "6Ynlf8pv8X1Ff8BpDszfSJgTmRKzNqYuj6Radah1JzTrKuiKZEWCFUYvKBENvDpZ6WWhnh4N54yr\n", + "HUNTUU5E54Bq6uuBHqgZnINzVs07K+TtH0hcqmZyKXUzeDPXOnxAOAZcPc80UVSH2jNbQbDfE1lp\n", + "TSZY1Uo6+QS6lVyQkwqrlPXKr+qfnth+F1jhZmJ02cISopDVZzmDRmupOguajsr1J0onx0+Q6ju5\n", + "jZXJvhgdVv4cmo0da1NhXLntlY6unPegIcnEfLLAOD6emkZmL/coQQndymJjqEK+8td9XJhuh2Nt\n", + "PjfjyA6rynojyCnaMh6bwWWw7pBhworptFhYSh+usCJdiD7hYunP4YcPDaX57rteyzVfmiEkD/Hy\n", + "wvrk6h//qnPOub/21/5K2PaDH37gv/eqP69nT+3834DFweXCth1N94cn45xLgb5sNnbtDlEfsBRE\n", + "lPX89o4NTTrY9/3TApE7Ee3XhmaVAnRWE1p42Hmt1/5anD0xjdgMppaljP8N9ZWKnGBFnG8Mdiaa\n", + "WcNqY724DJ/xttfVdw1ErBor+kXd3LYOsm1FcwdrC1UtjWGtsKLObqMWMr6Pi5Eil/74iytDlbql\n", + "/1uvSdDwVNYnRFN0jqceJUGreqlrugE61Ij2Mu05n1Wyja6aar4L5EbQHP6tfo/m7DBkEJwzCwdl\n", + "P4hcZTKf1sF+Yds4We00+CxQ2oVIZJLxWHYoF0wlbRObpxrZYHsjWq4R0FEBuF3N+nMyAFjjVscY\n", + "rQDYTDU/roG613KjNLCkye2SONf5MTEZ6xzj5xFF/a6BSJ2f23Pv7KoetE1ZqiLFs1OQ/gWsY2iq\n", + "65xZ4ehzt8L8TxTWOedG0ClnMsay9LNflSIiFSNGjBgxYsSIccOIL1IxYsSIESNGjBg3jBdK7Q0C\n", + "qKCmpiafre+yn9LtVL5P4aGKMk0MDTGniPOYpj+eSJegAa3Ui6Kjdrc2LLQEFN804tgb6h8pteT/\n", + "ZcqpsAOunCKFdSSU1QjizJXUdQMqqW/AKbhH0V+bi7qI5DrUmCpYw0/E9kzxzgRGtzpNQvehe1Kp\n", + "4UcB/qCuHvp2KnW9KDYflYYt7009tVJ3EKdKXblV72HfRCwcClA1SSqQOZHasUDREFYrjRJSh4Vu\n", + "HYEWHB/7zw6ORAgMenR5pZA5KUOLHND23sRqko1BfZSlCZBb4OdPTow+6pkmjvT7XETMd+EsrnWm\n", + "lqBA59cmTm5B7fSC9x8eHuP7kqkAWma0tv3R7T4DBp8Ljdg1vu0fPTIq6A9QO280M8fyN/6ctzi4\n", + "uDK68cNP3nfOOffJufXU4ycQKBe/GrZ97Se+7JsGgWc1tv1uMMqXS6OMboGyyoTaZ/r7bKI15HAo\n", + "4TFS0KxHh1ITEDB/j2udy/W6vPB2EnSJds65EhIAdYxOIRk4vGUWAh2udSLC8hJU4fza+mkN0exU\n", + "XNGZFdFi/Ks7+br210KdoEdwHk+UWkJ9xMMD689nT/w2WkP48/dtun3H3N5LOPAHcbKI/euVP/57\n", + "H74Ttq2uUW3g2gTArN3YKrVWBv8VO1fMhbnaUjtQxOiHRKi4NRNLxNeAt3Mi8zlr1w2sS/CTQuwf\n", + "6IqdlpqAQldufEeF6KDKVNhOek7PNWlZqcHOivtTuQVF21rLjVKNoDWX5xqp/VYkGJSP1FKpgp9W\n", + "Qk/xgaO15grWP5XahaQI1X6AyV20mKFzu3POZTh+IzRii7bUcv5JENbL/IvLvpGO4l40eYsVN7qO\n", + "VjsitwD13IqzPqUXs8LGP+teLiTZooFUo2vsnqwWfr7RGp9Z9tmYU0SkYsSIESNGjBgxbhgvEJHq\n", + "naJS3Y6q1sHgTFYEthJQQ0jsQw20+FMVpVPX11NgKIjUyL+F5iIO5gKvEURqibpPSStiRyIyWn0b\n", + "qtBU01Sxwluv/ZtzroJ1pKmqwM2hJls+ln6as/6YrPRyih21T/CmLSuNDMJurkJGIk6lwDPUrbNT\n", + "GNTQS8vtWoeUqjZS1b7pPHKgwvIRTEfHUrurgNj2LiqTX6xMWHvpPsW5yvGxgi5ECNlBqFiqdUVF\n", + "EbsgnLigjRicZhP/+eTQ991IUK0Ey6lQ3d45l+PzVsT+Jf6c7ttKfzrxSNtIUIKs8Oddyzi5deyR\n", + "gOO9W9ivfX+DFW6WSro+6sWxbpxzYpgo438DRGK+tP6sgWbMUmtnQvE+xv1s//Xw2d0HHi363vvf\n", + "tnOdepTsDmrpOefcrVu+7V/66p8P2/7u//x3nXPOXZ9qmrzv49/7zrth21tffsu3A8jZj3/FDDwf\n", + "P/vIn7+guh3HvaC/RGfa2q7JnZe8oD+XuoIUNGul+XLPo1jtCihFLqgK0FkaUzrn3HzljzE9MBH/\n", + "Civio9fesm2XMEeVVXULOHklK+Iyx/kInF5gzBwd+ntI7RcyJpaI/QbH53RqiFwGePr9j56EbRSj\n", + "N1KTcg/mpNOJ7Y9jYgK4oBcLh/On/rxOzq1NNPVcX8tcg7ltb89QWp6P1j9dpdiP3s8UVDsm8dj4\n", + "p/tj24txak+rC2UY/L+5JIqQndApuWYmkYq9iUhxPtWkqFD3T55TZFPUEaBmXUF5ToSfiJkkkHW1\n", + "86FlB617VBzPR6KyNcGeR4T9TDyppmr06ce4ItzBzFqmc9akc/I8STu0pQYiJIjcCH2hdU057y9W\n", + "dq1rJK00lVgtEAFPFf3xn2fSx82aCLyfu/pGLCyQjJWW0tdMPBDq4PaxT6yYTm1MnuI+vb6WOpFI\n", + "slBzbjWW3hURkYoRI0aMGDFixLhhxBepGDFixIgRI0aMG8YLo/aStAnup86JV4eKs4O3lPwO/zMQ\n", + "APbd1jZCr4lAhhSlc1NZ2ulTRJxXUq8HNdFacTZfziliFhgT+2mFRmx7wsPiQYLdFMAMm0HNKQ8t\n", + "ZiKEpGfWWOrvbSBAbzcK9/Y4h+1tFMI7Z7Xjsp4u7nZ0MlCrC/XxAmUm/hzsMxV7sz7efG2CvSz1\n", + "MP5mpu64vgGF1JqrQFUQbr0lHj9n649wrkJjQcSaVQqZo07hnjirT+G3tBRRIuuajdXcBO0Ye/qg\n", + "F3d4ihdzETFXgKpruf5jiGjl0rm9fQ9ZT0ZGQfTA9s/mRrctGw9ZNx0dxoWeybeTGJpA99l5reDf\n", + "kopg9wJ0S9sZLbJBgsRqYTX5JqB2DkFFvvzmV8NnV4mn7M6FMji46+Hxd7//YdhWTrx4+7XPvRy2\n", + "vfPB+/5Y1+bj8o0f99TXD77znbDt44+98P4bL33OOWc12pxzbm/qx9B6bj5SHJPLldTLAi14JM7m\n", + "7J/J2Ghkh2ub79u2NSkiXLtKXJ9/7Me/7pxz7urc+uvy0l+7qzM7r8me//HVk0dhG6naTtz2i6nv\n", + "//tyP83RP9cLEaDDF4yXWIW1yQb+PDM7h8meF9SOJ3ZDV3Ci/vxbRkF+/AHaJ/Pu4aH/nOPPOeeS\n", + "jokvSA45MHH+2//yN5xzzj1+ZI71I+e/17bizo56blOpyTfKfZuYdOKcc+c1+s5JAgboMyoq1LOt\n", + "JO2mPkLZNmWXIismFxPADL5MuXqL4fM825ZlBBdxlZHwd5LEFMpjyvF7CvXVRpvPpEFVDiQlDWqC\n", + "Qr4QHO5lTmpYG07qZYKqbqTWaMP6q2qQlSCxYiD2p3+gtB3Cb33G1UhUYdNHIsQucV33pIZqj6SE\n", + "pTNvuQYdVYsofA35Sie+hDXGXyc4TwYPxOtrv7/M2bia4l6YVnZPkKrUmpD0+bonc/Irxw+cc859\n", + "+uxh2Ha6usD3RVKyo8avRkSkYsSIESNGjBgxbhgvDJHa2x+7K6lWHl7q1UWb6jwt9R2cTVXsx1o7\n", + "stKg2Lzb8VuKTgV9oHVAVuo2pFxqCTuuakv1GuCH9mfK1Ye8yYaUXH6vtvYyvbIQURurtGvqJZGz\n", + "VgrWccWSSp0+O76gNNhfSdsDreGEQ+S1nUQHJK6Q1GAu5tLBdcKKSGoznZ96EemtQxFKQzSaZbZK\n", + "4NJyRLuAkTihj/1KZ5UYSsFrl4tjdFUSYZN6SRDWFhNDGJYLiBgrO35C8TqQyFzUibw8tTjLN1jV\n", + "doWdKxEucXVwsz3f9kLGJH+7L+cf6uNx9anoK+wM6rX1IdPaKVx2zrkcKf6KXK1QoLEUxWRVesSm\n", + "baV23NijPscPPueccy6d3Q6fnXzs0Ze1rCDvwfbg48cfhG3/4n/5Peecc//rL/5y2HZ14VGkjdQO\n", + "PL30q8lXP/flsO0Rxskadg6KqtQr38dPRWz94JY/fqLuxJnfpoLQCdzjNxtDenKca1qYszwTGdjO\n", + "Bw8MVfv2b3r05f333gvbFkDHFpeyX6xcj24Z+vPFH/No1t27ZokQKgmMbIxVrV9FL9e2cqfKlfdu\n", + "KqvqFsiAuvPT4iGRdfGKqJbcp6+9cc8f69qSQurGjydNAOk4Z6C9SWN9/fEjf92/8tobtu3K7+MP\n", + "z98O26aV7+tSYNoK98JYkjdWEA+vGkGzAJ13SGIZIE24P1uxMGHtSnW6CUlGA5QI85mMkx5oTiY1\n", + "2bgjHitRACfkP+1gP+RgoT6i3s/cnyBSRJP0e7SOSGFXo8wJheJrQYkpsm/l/t8wJ0NtBWgnoc+z\n", + "3o+tZmMnuZz7sdNIlYODAz8+8nJ7rLFentpUjMi6lDZOVyFRQGwaIMbvhZ3hvJdqpyDJpAmVPQSl\n", + "TPivHWsKd/4iM/SpgsVLNqi1isSO18wm4cNTz4ScXlulgmqbxBhERKRixIgRI0aMGDFuGPFFKkaM\n", + "GDFixIgR44bxwqi98bh0fW/vcXO44qo4nF5ISuM1PZ1V1TF8W4DuQuHF7WMTxVXKiseiINE557KC\n", + "/iRK90EcKD1XAu7sBUZdr4eCUW0f3dvHQvGwkHBeDHBsHEs8TiAe78WfI6MruRQtprdOKn5PJSDz\n", + "0Rius4KFp4Dgu95otLRDkWGh0XJ0XiYUWIvr2IiI9erUi0fv3bkXttHTaAJ3an9yLODsz6ESIfoY\n", + "VEzdmbB3BMF6Is7GxP6nM3GRHnlouRQXb4r808zoow28lVjcNhMaLwF9shYfmxzUo3pbFfAvUbE5\n", + "P82G1TX9uQoEzWKh69b3+0qowDVuz24lPjpMrBgU4/b/dq3C/f576gpew4379ZdN0P8SRN4UmXfi\n", + "BH52+sw559zRLXO9XkBkvRLKroXr8MlTEyBz3P+tf//nw7b/6r/8T51zzv2d/+bvhG2PTj1VxILX\n", + "aa9eRNiXFuOu4Xcl1/oaxU3VsTiHP9ieiMcTFtIWATodqCnUfe+d74bPvvVtL4rPE6PnPnrC4s42\n", + "Tg4grN6IB9vZs//bOefcT//cT4Ztn3/jK/4UJCnAisGqKzTuZ2ybTo12WJSeAtNizLwX1+Jin+M+\n", + "KoXGDuLpQ7v/wjwlEoQa12B25BNAuoXdf7cPfVsqccC/uPZeVUd7Jvbv4emV5+rL549Rit9PhXm8\n", + "sErBboIitF2yxrHCR66pPQXatiLj4Jws3lp0D0+c8n2oKCH3M/s4k2cRHb1ZKWBYnQLjRYrsUr6R\n", + "y+M0DXO3UPBUqkiTgvRCxkSN42aQkRTSXxuUcdDH2roFFSfnWoMCa1vpf5xHXkoD4EAujz3XQd5x\n", + "Lff4bOZpa1J66SADjMWAbb8VKL1EqLV66cduL3Os4zVTX8bAPUoyFn4TClpLBY4SIvrEWXt7JECQ\n", + "knROaEyhQCtM2vrmcP/YP7MqmXfmqxP3WRERqRgxYsSIESNGjBvGC0OkmXyBIgAAIABJREFUyqoY\n", + "OEYTOZkvJA0XK/de3xf5JqyvkNyHuuOGumPibM20Uoj3ckVwsMIboAp4Te+lrtwYIua+FrF3zpR8\n", + "e0vmKqKT+mds3wJivk5qE2WhXp44DIf3XBGnApFayiqNtb5UbE+BouwuoE0d2pHKqjbnW71AbRXq\n", + "hCWCvmShhqCdF1e1raTfLrGIPTu1Om23r/xKeLZnK+cUQvI2ZBtorUW4SEv9s6IhwiDWFUBRJiLK\n", + "HMGpeS0rwmRNp+SwyXWsu0iUSAT4RCk1/dylqFcn1hFJSbd12+YwtrT+GesTlpI6fAyX8QwrrbnU\n", + "y5pghdWKsDqBAJtiSuecayAGbxpre9dv3yAPXnkJ5yUO0GOKSCHw1SSCsKq3bVe4Py8vTBzsEt/X\n", + "ej9xNf/eBx+FbV94601/zncNpTx7/L5zzmw/FBlIkAGSy5ioeS/IuVJsPx4b+nJw5EXz7cqE6rOR\n", + "F5l3E0N4uoVHSSskj7zz3ffDZx8+8cc670x0enTb73dyx4TlFxBbPz43AfqruD7ff9tsIqqRtxHY\n", + "37Nrt8F5VDKg2NtEq9Yyh8xgU1FLrb8FkN69PRPRZyknsm2EX5MXKtwzG1mlHx75dlZILHgkSOMf\n", + "/NCjdD/4+P2wrcCxDqd2/LOrU+xfEWH/dyHbKtx3lSAnayLbnNcEQCkTIBzqbM96fYKqFUDORzL/\n", + "jTGfJ87mnxa2M4X0MbuM87UyHZyntP4q0UEFaeiKXgnrkcEyRmtiEgnVpKScoviMtiaCiKMzarkn\n", + "aIniBOmmK7rOCbQQEGN117F2obokoC1ZIok6S1SAoJ2OtLdzZIlkW8prYg/UWe7HfSvJQz1Qx1TQ\n", + "px53QCnPs9nEn+PVlf93LElhLoN1jXyf2vlNa+jrIWqhNkt5yKd87tq2ae/Pux3ZPNF2UrN0R0RE\n", + "KkaMGDFixIgR44YRX6RixIgRI0aMGDFuGC+M2iuqbOD6WlSE5QweXy4JXyvdsE3tUQyoYjd+LZV3\n", + "RdJteyhUWowMMqXYcmhECyqmEn+iyh94I6JwFrkshKoko5MItEmKhNSK2LMEGrFQLi6hP4gIGynA\n", + "F7dbCq9TcWIdT0c4Z6MAWjrW4vtFZtBtAW+bQuk++o50QqMBlm9F2NyAjmrX0v+gaBbXBuOeo9Dp\n", + "dCricfhHbRp/LepWYOycAnCjPSjyThMREaKzpenBMb2VMZGhH+tW6V7C/XTHVzdduiiLOzW6IpXr\n", + "T7FrLoJZFzzKNCmAIlL7XouBXOG6j2sRzK7p2GxtanGNVURe5qQR5DrlM5yDbVssvFD34LZRMNOp\n", + "H5+jsf9+Lxj/wYHv9/O3zYl9Hw70I/HduUIfqzsyPeDe/cN/Fbb98i/9ij+GeABdwe9qChdzdYwm\n", + "FXR0YO0NInvp69XK04wH9+6HbUykUFoygx9TIjA+uZqHH3r67qMnRllegdq+84bt1218P/3u278W\n", + "Nr1239N9n/+GFVx+53d/3znn3EuvGI355Ikf93qPVxhQ66XdTxkE2jkoszRVesj/q5IB0jPqI1Tk\n", + "/v5XLx4yVFrtYAM/oolQxSw03IOy/Z3f/q3w2Ydn3gF6X4pBj+DjlQhl3cBRv5Hi2rzsfScFl3EZ\n", + "KxElp4kfpyMKtmWuYRJNplQY2pkpZY32Hci1pn/URoqAny5B/QrdSSF5jvtK3elp7a0F6rOOlKWI\n", + "6NHFlQi7ecs04gFF+/ZmrfMEEnog+k/lYZcGwbj14RiSkqa1Y/XwalIfQXo1NSLUp2wjlXmCkhuK\n", + "s51zboPi7/Olb1NV6QMY7ZZ7Nwf11kkh8QrHSMdWNDitLra+xwoUej1HGAxTVKyYyPwznvi/S6l2\n", + "wXn9/Npo6QoSkUmhugz8RqbuEfqzbmxMrvLPNpKKiFSMGDFixIgRI8YN44UhUqMqc6W8GU4TprDa\n", + "u90pXY8l1T+sxNSxtu+f32TiPRFFj+BAPZ36z8bTmfwAQkBJobQdiosy1IubSt6+WetJROlpvy3U\n", + "rVCTiCL6dWqrtcnMv6XnuSBIITXampRj1acC6D44kIvbK16mM4FpaC1R4N9a3GyDK7isVhquEiQl\n", + "nYid/pYr4dVGbCJY929j7by+8OjD1b6hjszJXm38Z2uxX2BqelFKvSQINjtJl82A+qWyrEiBJmRS\n", + "E7Dv5/itIEwlxNb4aSfu7BnEzoUggpvSt3Mk6d8pEIRuY6vEHrWjZOEahPq9oIlERBIIbCeS1kt0\n", + "MBOkYUlXfkEkFnPeJzZORxAlqyh+f4rzEYuJZ4+fOuece+1Lfn+blQ22B7e9TcLTJ0/Dtte/8Q3n\n", + "nHNvvvlK2Pbo172jdTG168QEhNffNETm13/tV51zzr3z/e+HbUGgCiSsFHXwEoLlzhlaQiAkE+SM\n", + "SLAsyN3xvr+fahlq2b7vk1atQzBO3vuhR1p+4w/eCZ998Rvenfy/+M/+dtj2D//3f+Gcc+6jf/4r\n", + "Ydsffvt7zjnn/oYgTV/75k8555z7g++YncKXv/o155y53jvn3OrK179rBJ4m2pcBfVmuzPU8H7Pa\n", + "gaKPfiz2krzSAf6ppFLABinx6go/BiI8k4FSYV5c4Bo+PLeEAaaaH4slxtmV39ZKpYgpLE6uGxPq\n", + "M02/FoQ7ATo0EqEwqwEQnUylZEBdewSjSg2lHAMtyAV9SiDU3htJFQGwHmlpNg3HG//3k1Or53h9\n", + "DUf/1t/rqaDUFawZyrHWRPV/q3ULmYBCkbMMSSFilZ5Q2LxR1IkWA2Qf7Psl5qtE2IwEqHIt9hs9\n", + "hmIq6BtRorYRm4AO7IzMZyOMhcxJ8gJYlwb2C3NFUDGvpDLX0JV+YDEEhC+RQolkHVqZ91oicYrm\n", + "oczEZOSPq4hYVtI6SK0uyD4Ywvzhkx8455z7/P0fs3PNmWwhlQUS3juCHMtzcVdERCpGjBgxYsSI\n", + "EeOGEV+kYsSIESNGjBgxbhgvjtobl25UqRCQhV/FiRi02Om5iZOvL+l3pO+AffhF2AJYuBJRXjWi\n", + "Z4SHB7VAbgZ6Ls2EdnH055DCvyN6UOn3II7LVexGUaz6k8CDCMK5TOBUsgK63xywrzprU+St3k70\n", + "8ciFWqCPUpqJPwf9UfBT9c7IE0DgudCTCR1+VZztz7UWKiLof1WUCSg0EWF1A/i6XonfFDxFNhCl\n", + "bsTjhSLbTGBfQsFrKdpcVYCitZB1DXhcHIMTuKfnqZLA/hqPQI/UQo+0DdsufQKxdyl0I8euOlZ3\n", + "4Jlyqc+cFv74nRTtLEhBAovvRLC/AT2jLvIs2tkJ3VfjWLMDoyyaQF9qcW3fvusr6+Nk6s/3t3/j\n", + "nznnnHvjrb8QPpuN/bn+3E8YFP7+U0+Bvf66UXtXl358fnpiws4H999yzjn3F75pzt6fPvRU3ZNH\n", + "j8K2n/6q95ZySIRI1J8HsPvKKRUAIayIg+k3UwqNQ+qrFVE0650WuRZo9eP4vY+9O/crn7eCyg8/\n", + "8ZTWf/63fyFs+/ihP8eTxybAX117WuD3fvfbYVsFJ+hjKdC8yeBj04iwl0kxItTtQL20ECCPZU4c\n", + "w5394sKoKPoYNZ2Nq5S1XZdCLYEC7Xu77ylkToWqKm77ws310vOit4/N2f3hqb/+Uls6eFatpJB2\n", + "gUSFbmnXJGeh78TGH72SnNBiZY1rDGlDLvRQBRptnNm4ZmHuiST7cP6rxNwtm/h7PB+ZpGO09n1b\n", + "je2ETs+8eP78wlPaA8qcxxLH+LLw12Sk5zCGsFu4ZfpXCbPlWriHcx5wzrmWjuqsWCBZHDmSksby\n", + "7Mgg3m/FRX6NuThLZa7ZwU5RllGOtFICimbLOGHVCLK3q8YkGGvcu6ulULsTyEiEbsvgmJ4KBZyH\n", + "Yu2SgANarhO6FzXl3f4hqG3JCuPtkWf67MJG4fvXoLSfXX0Str18C0XKE3nGIlEilWfheCIJKjsi\n", + "IlIxYsSIESNGjBg3jBeGSE0mo7CScM5WnyNNTU4gGJWU+BourquFrcitTtS2m3M1EqHgmHYGeAuW\n", + "t+UCb58bQVXCC3Gib7oQ0Qn6Q/fYRN6I+YZd17aayWg3ACF6IQjKBG/wWWrfT7GPpNfUYPybijgO\n", + "SxwV6jPVV12sua7hy/xoJCmdPQXr1v+s3aTi6BorEUWkuGDqBE2g83QmLsYzOpQLmrReQKiKlWkj\n", + "9QonM6BEA1sL1J/TellAH9TZPkv8SkxTh0sgERsRj6eoycTkAEW/aE2QOFmt4+9xaY65Ge0HnF2n\n", + "bsPajepe79vXdoowQYALCwlFCzrWsFrbCr5eMa3Z9kuXc01AmOLaFpmiHxCv9yJeh7M3x+TpyUPb\n", + "x8zv96/+RUOV/oe//w+cc87dv2+WAF/98S8555z7Uve5sO1zr73hnHPu08fW9j9824vMU2er2Z/6\n", + "hhdgNxB7zq/MiXyzgut4ZWOI91Ou/QqUcCrJI3Q53khiwajy56N1Kt/7nheg/l//3Avhv/zNn7Xj\n", + "ow7gr//m79ixgATX1yZi/eX/0wvP/8Of/5th208CpcuPrf/fe+LRrHv7b4RtF08/ds45tzg1UXaD\n", + "umIU3u8f3rbzx2r9YN/QRyInKkBnaPUIormF1M4kwj05sJR0B0fzDAkgI6l28DosJq4lXf8J5onZ\n", + "xJICHsOSIt/YPUHkXi1miHBrm1iLbQQ2YSyIVIq5WxNGUjhb5wK5VGAOxsJ69ECOSmkTrW2q2o5R\n", + "BITJf295ZahSj/t1LFUsaCcxFdQiAerS5jYm2b75pc0/wfZC5jhuKzDG+1TmxAlcvxNlbnBfp4aS\n", + "3R7567Rs3rfj9/48utzQVKLuY0HkeszPucydY9yDeyM/7y1bu4dPLvzYTQRBypioJIzIuOQzQeZp\n", + "zJ3KBLHahDrKT5AoFtDZXs6f9RLFziftORatX/d5zWpr09WVv3eqkY2JPoxTeXaUn/2qFBGpGDFi\n", + "xIgRI0aMG0Z8kYoRI0aMGDFixLhhvDixeZ67icCJOWi+RooBj8cebjs8MhpliWKdCu02G0KKWvDY\n", + "/9t2UtwS1Aq9LSYiBCY8ql4sFGqrizgLP+Yjo7aaBUTZ4mJNN3LVmlNQTd+XUiiLHLSTQsYF3H43\n", + "IhIkxDrPDJ513Wc5q4tTNiD6dIfrLKH1UhyGe1Cq69romYZ9nNn59wFmFQoUwuqpQKIHR56OKJSC\n", + "g7h+AcoiUWdx0FydMxqTlz2VSqZd5/u174xaYOKBaN0DfZyLAHUDioKO3upPZeyZHasEjTQSETMv\n", + "WSfC7g50swpQ6XKeSyFl8q01KJYL8bEadxB4rg1Gd6QlhbKdX/v9jSfWJlJfvRMaYQMB7Mpo0Ska\n", + "Pzv2hWo/fvft8NkGgt7Pf+FrYdt/9O/+deecc7/2W0Z3XUA8r6L4P/p9L7zeCAX0b/zE551zzv30\n", + "T/471s7OX+OL02fOOedW98T1GDdPJpRlijHeSJ8cQNi9Ecg+B/U2OzJajKUEVhf229Nr3/ZPLz2l\n", + "+DUZMPXSH38srs8N1p4qAfjiW/68/ta/9x+Ebe0SvmjiYj0HQ7S3b/Pe1af+/BcLozSpVFjAP2op\n", + "CQi3boMKkfukxvXshAIqQFFfXj4L20gHjqQYKwuXJ4NEEd/m5RyeTdKvvCabpSUA3Z8+cM45dy4C\n", + "ZAqLJ1JIuoXIXAUYGXyZdO6ccF7EDTgZKY3lI9d5LcP9L35LdFkvJzaf5aUfJ6z64JxzC3gvlbUk\n", + "71A2kXgfpYlWm4A4uxO3dbqoq7N2CsqqlQQkVtlQb6Uewu51bW3frH0PrXA99440OQb3uiQHpJgn\n", + "93AdnHOuwPywEro9KX2yx1KSHa4hrNYEmNnsDs7V2j5CH/DxUHX22QyVJ54uTsI2FjwuJHmqg2L8\n", + "/2HvzWIt27LsoLl2f5rbxI17o3vx2nwv26rKrKwmy64GG7sSYQT4p2whPvyBEBJ8I4wQfFrAB3wg\n", + "+DQyQhQ2BbIQIOMqCyyEq8msclZR2bzMl+9FvngR8SJeRNzmtLtdfKwx9xynblQmuigJFVrzJ27s\n", + "c87ea6+99tp7jTnmGPSIG7UPXUpkb8xZ3jMtIRxPaSSOXl08aCmOUtDSqxYXUTVwHzvSaux8GJOT\n", + "lJwykKLshxVtu0wb4oiIVIwYMWLEiBEjxhXjpSFSRZGMhGgR9pOisnYo4FaVNVPJ425ub+QXF2EF\n", + "wd51Sl4bPJEIsdIp8Wac5lxWCm+4BZG9UyXxMQE+rBKSjNTWsTrsOlvVdCi/3/HEciqxAGkGUnZX\n", + "BCnLbQVXosTVMWEOPoGbjSFSC6wEWX5Bbfcy8iQa3+b1e+x5pWX49AafgTC5ru1YKuuQ0kojxRs+\n", + "I2wp0JmjY1NA3tsLb/1tTWXSQMfyVomVVOoO5GpgqQd0BROrlZybkCp6p9IBTGxEp3giOytKp7xG\n", + "Juw7fD8j9EvXxDn1a4G2DFSSrboHFS2/BgmoQ0ukfI/fNnqNiUQ9FUUQafWNa7haGgF2ArK5Yw8t\n", + "IAxcOu2Bzi42dv6bdVh1bYE+3r37hu0DitEfvPfuuO3mnSB78Itf/sy4rYYP14KI4jmkCPaZKN6E\n", + "+/RiZSs9RdYcVvPble1jUqoPHSMiKACgFbyD/1ZPfaeq0Fs61gyq0OfPbTxfLJVYinJ9UvG/fhxQ\n", + "OkbEHCBR9aMTEfm7//3fFxGR5Zm1ff8onL+nwoap+l8awC7Xb4Ty682FqceP0gbqoUdzyBOozN+5\n", + "w8raI/w8bqtBFE8IYVM+s6c5doYyfk/HcCD0J6sLnIs1eAppgj2SjjltAtKxYE9QIDL7VFC07MKx\n", + "BnKPyPKAEjFyMe1036HfWcJGPdTYQ1UdCDwVUTQNkDsiEat7g3ckXTIJ+1ktDPVWeQpFVWqCG9Qn\n", + "0hPZevTkZGcLdHtCKOGAMZvRdUrxeUIIj8cY6zpVB2e8A8rehNLNJwGJSsSI7Qn6uGtI4gbFFnlB\n", + "xQt1kCKpu+fjtsn8FtrLsiNA7tHeVLpLn3FRgM6x9WDXeu5UkodMOVEUtFP4hbkw4fE8+nmqYSOh\n", + "9EO4xuxh6oFIDTVJLahiPvl0Fopw9zafToHsb7Yk+7MjmXM5IiIVI0aMGDFixIhxxXhpiJRzTpKd\n", + "EmZwiug76mrPuecKOVVf2pvu/l54I10uWVQLQnM7nnx4i9ZSS5I1UFv1hFAdLb9MqKxTEpVQoHbC\n", + "94cRsR5l/CqNICLSel1hhn+rCb/BwweNUCoTJ7XvHUIYramt/LluTvH9y+7bzBHq0PYE/ImUHK0L\n", + "mPMN7DSOPplM7Hvrra4g6JpAuDGj63T7JKx65nvkk4a3f+Z3uHGFU/yJc2bPKbomQFgGKhfuwOHa\n", + "KetGH6ckpjpe7xdIXCjSwOhjiv31xHNSAbuE9qtjzBNykQHhYDmPHgZZrrMc/cVKne6x+ib5hXG8\n", + "0hhW1HFCBD8rXSfx0Uz7mjwRBxXfo8EL7yxFPxriaB3P9nEutt+zJ0G40k9t9TtA6O7uTfPm6iCc\n", + "mGWGCNTPwqpvVti2xSKgHqtF4PL4YzsvFQ7dnxP3C/vdUDvVV1A5YOF0wnkfHlk7t+dh1X16bujD\n", + "DGN2jn+51P2VVwNX5HBunKKnz0I7c0Ja/v1/798WEZFf+MrPj9uObgUhzpSQy5O9sJ+Dm3bvTjZh\n", + "9d+tXrO2A4FdQtYgI1kD5Xy0La3IsR7mezIFSsXzyXjP0Jwk6O6ErrGgxD9pQz85+mxSBnTq2eZs\n", + "3FYDHZ9NDelIdf6jVtbgcmZTEs4E2jSdWp/0Wdi3oqUZ+aq5Pvy23ZL/HHbnaU5QNNuzJyGOVZJM\n", + "wwZop/qVioh4UZQarScARcdVy+Kj4NckuY3JTDlSxEPtB+W3EfcnUUkKRj0VuQn768gbbwqJj0Gs\n", + "/4sqoJqeuGw6Fw4kCeASlfgx9Kkq1ePW7sltHfhvs8mJtR2csAEeqzzXTyDTMdA42apki2P0CSiR\n", + "I6/L8XOSbsH12bLJrN99njL3Sa+dozlZqc4Z+UpqNoXFbxXF6unZ3bbK5bP99YTsvygiIhUjRowY\n", + "MWLEiHHFiC9SMWLEiBEjRowYV4yXltrrh2ZX4Vb9dQiK03QbK/aWgBR7IpuqKveUyNPbLaQGSDFV\n", + "EzS5KpATxJiAsMj+f61C4JwCdOoXZMevUIq67jktqErV9tOxtB77a1pKTwBtZiXiBCWnOUHBOYjF\n", + "B7WRuAeU0HaDkWgrEOpdatIFApi5gOeXUMoyQ13rlryhlKivMhQiIj1IfmT1JsUcaZTrtr+bNwPM\n", + "X3JJMI5HCgvSo8RWUwt5QWWoUDGWLam4I/nbUwM6H0i+aUYqxigZz0pLgWgakf2XNLs8ql7QmFRl\n", + "WyY96g9Kuk7qDZURKTRHakVTUSIiGWB2ykrJXjrBYZFupWvtke5MqPx6UGI9Kxvj/qgmlG7rLkPm\n", + "gjFZUEl6s9J0c/jexbmVMM/2QxqHy4pfuRZ+y2Xl08M3RESkzCkFfet1ERFZX9i1uzgNCsi9NwL4\n", + "4iKofReYDLqtjdf1Jvz2eP/VcVsiSjolYjEkFhKWhLgI43hv3/pEvR7X53af3LhxU0REfvWXg8fg\n", + "1/74vfGzo5PgF/ilL31u3PZ//s7viIjIllJLP/vlnxQRkddes3Zeuxb2u3xs/fnOn/tZERHJ9ywF\n", + "Wk/Ctd07tHbO1+H+dB5FNDTVdUgxnJ9bamd/P+yP/R/1fkqpAMJjLmyo7+ZIUQ5zu++ap4GA3CHt\n", + "fG1uabfFOqSFbu+Z/94E92xNfmkXmDuXRADvIBOQUlp4XoRzrSaWPi1g5HeahvFSe5rDRrcB26ay\n", + "Mkz2bseUto3TDvffhOgb0xl86oiArCl4jxRbRvO/Fj4wAtHj+I7mFVfAWSG1m71HSl+LXkSMSE+G\n", + "ElLADUI59kliUhMq+zLw+ffBjWBSmGL+MLpnsNo6nCrIPUHT/Al5/W1xD3rqd49Umu7XN/Zgy5Ee\n", + "26fnhPoktgM5YPgXHB8FVenOFBvuz4LnbqUKaA6OC7uQe+WiLD1+Tn3dgb7gHRcvIC1InoS911S5\n", + "zXttHVN7MWLEiBEjRowYP5Z4aYiUl2YHfepVLK+ht1D14UmMbJeXWi6fX/ptQb5uSpDk8lPnRmZx\n", + "+IyQBhUwZO21Aat0JrE5fSOnN2glebKvmm5jvyBdiQxa1tzz23r4rZbti4iUeFuu6E1fQIa+RkKD\n", + "kyqsGLetie+lRVgJux2yub6lwwU9tbJmRdByQjoGvRb0tq5c8I6ESzuc9/4rRmxV3628JGIhVsQs\n", + "07DFas6jDDYl+QenZHNCzlp4sg3kIN80kJMYSPwPpatpaW1v1dWbrmernnggBe/wGzE+uTTcyPt0\n", + "XnKZ2J+jzQmRx5Mk9HdBSOikDB06L8P1LFoiXWJJWp8aSrjJw+p0oHHS4++EVl/aZ/XGSvI3QHhY\n", + "zUGJ3EMNv7o98nBbBNTj7h0jQudYzRH/Xw4q+IrRqvb04w9FRGRxdjpuq9dYWTNxE9fk+nFAOJ4/\n", + "M8+5GycBdc1IaPHsaUBESI9XOiC7bcPyF+HaLU/t+O0mXNz6whAxgDnyV7/6cyIislo9GT979jDs\n", + "7ye/aFIPMy2Nrq1f33j9bRERefWuCSJ+973gofezb75ux7obrn9PAyWBdEhG404LBKaz8P2zhZ2X\n", + "yoMw2X4fY6yaGNI1YHymRIrPgdhmLMmB65l5ki5ZheueYTzN6boeQ65gNiGZGiBNjxePxm0qxNsT\n", + "iXoAYlCSdMSsDOOtKEk4EwUaEyBX9x98b/yshziv3jciIguImSbkU+qRneBSdwHqu2X/UwzkKRVv\n", + "6DjSJnFhwQoo8YrI6S7HfUXEag9ELnP0jIMkASNnGQqE8pKfHfoX5j86BUXVBxKaHoDw9t6QqwxI\n", + "d0/yAz289lRyQESkRAYmT2zuroDEtDU/u1BQBSSMBVwT9AlLx8yw31Vj95qChMlAKD0EWVniIskg\n", + "RdLbveshAK1eqB09V/UlxhPSmkCKgVUSVHbIUfVADkHadkfqAIU/lY2JgrIdL4qISMWIESNGjBgx\n", + "Ylwx4otUjBgxYsSIESPGFeOlpfayLJPt1lIWqg7btgYFqp8ek0hVCZtJzB4K6AytFoCvWcdGdT5U\n", + "TyMlcqx66eS0behAAE5ZT+KyPlGvpGR6LVU15J5UXN3oCQTPJVZ2Rw6ubQ2K9SWgyIxgTJyPJ3g+\n", + "A8y5NyNyHLa1YmTXiaZFAeOmzlJ7DWDfnFTEO0DFPenOZIA4C1Y2x2nskQJ9kYMASpBtOwRYuCNf\n", + "q4tVgG+nSAU64VRE+LvpDMb3Er7P6Va9JqxsrNezIVKwKrpzWiRBWi4ZlJxv16RQHSlOTyL315PX\n", + "VoLrmpCyr0LGBeWKE/SZ3xrcv+5ArATB0ZOxYn0BdXb2QUM7JxV7iAFa9zyew98L0rFxSYCqHSm7\n", + "r5YoHsD5FAsaQyD0OyFfQQzynnR0nj0Iaaya2lki3Ts/tFRhhT4551QVUqofYh8T0hG7WIbzqna8\n", + "GcP3y9Jg99PTMMb5flJSbE++gu99+/thf0RsTgak8pAe/lf/yi+Nn/3OH4WU0vtPjDB/81YgkaeJ\n", + "ka2dhPvp4X1TJ38DqaLPvmPfO3k9KKWvnlv6skfbzy6MPO6QyixQPEA2ZNLXSli2cXWxQEqH5sn5\n", + "LLRph5aA7pnmNnbyg9CmgYo3hjrMBRuo59drm6f3MtUdov6HKn5KxQ4+07Fr98lUqReUqqpQ+DAt\n", + "bZx45IBKFAqsLqw44JOn98N3KD2TYHw0VIDUogChoblL00HsCZlgPz2JAKbqseowhyWcigIRmQqg\n", + "tIiIFdtH/aiUlbS0eMXGaYmU3pTmbiW096AADJTGUl+5nojg620YOw0VhSgtpSCv0yQJ1zHJ7Vwr\n", + "1YDi8+ngqEF6f1o1VaKwgNX2vWjazb6u+ljsU6j+f5wm871ScNhjFmlJSqk6F1L6da3aZnatVYPQ\n", + "Ey9DSeQ9pfu0yIjfJ/QnJc2ngxYNUPFAGVN7MWLEiBEjRowYP554eYhUnklNpc4NVgZtb4iUrpJ5\n", + "RZArUY/416KefEz2VtI0ISdFqeR1LQ1mc77wj/O80gn7YJREka5V1+9lAAAgAElEQVRtY+qwma6+\n", + "iETqQBrOmEUKj7UKys5Mdncoe2dXcSUZbonYejwLKrZ9b6vkCh5eStITEWmxvwv2tUPfVVkg8XqS\n", + "i9DVx7Yxsq1yl1sm8eF7eUkq2lh95bT6yCqskp21abu9wP5s5VZDPXkPxPecVibpWABAw7RW9O+y\n", + "ijMzoJMsnHdPKraq2dARUTPBaioZ9NrQagm/ZURSy2mTnW2XCdhKBq+p/DnDKrKl8v9zlC5fLMO2\n", + "/cQIyzdA7M2o/n2zDm1i5DbPgQgQK1VXjFy8kIMU3G4I9cQqfrMJbTu6Zn1TgWy5Ig+91z/3BRER\n", + "+fiJoSo1VtrzPUI4t+E3q6Xd4ypJsKm5rBpoAmQwOvIwu30zjJ1JZfvd4P5kRRJVgx8IzVUC+idr\n", + "a6ci0e3aijK6OvRJNQ9I040TK+L4ItS7P/+moWTf+OPviojIw2d2Djeuh/tvRordn/5UIOj/xC/8\n", + "hJ3rk4A+rT/+zrjtDEjcZm33c4N5Yh/9P58TqluE/tlu7L6um3BfZTT/6ejMCH1KQQBOpnZPemVU\n", + "k1J5oqgz5BSa2hApVeVOqGBiWgSEr6AqhjLBdSTkYpOoTAyRovNQsj+h+WTA5D4BwuXu2I21hhL+\n", + "prb5V0HvtiNl6w4eko1dp5lKJxABW6fglgp/HOY714Xz3raMVsBZoDDCfIpswqaxe71uQn+WM5pr\n", + "ID/gOttfUYVt8zmT3cM5rmHyN3SEEmPed42hqg5I2EBSN76H1AQXoGCeSggSVBQpLaztHZ5305lJ\n", + "Ymj5fwUkeOgJQWs1S2D7nU7Cb5c0rgXFAJ5J+aMBJM3xngsE0D4H9fgUUhOEvnkg5vz88z3GMJH4\n", + "ezxrGhoThSr/D1RkNaqn83Pvh78qRUQqRowYMWLEiBHjihFfpGLEiBEjRowYMa4YLy21J7KrD1Q3\n", + "ahRIzEqk+zg9oSQ2T2m0HCTfjHWkAF9mRB5Xc+EKv2VDVyUbp5QzdEhL+R3NDDWZJDNaJdsRKVy1\n", + "lxJScdV0VAU12Zy8Y1UDqCcS5TAEGJMh69U2qA4XBZFdATfPpqStlQToeUhYAR2muUh7su6QEuDr\n", + "lg19NWVp8LzuY4ewB8jW5aQPhF13ncH4NZR9mdjZIc3nXYCqXWaEVdUKKnJL7WiWjwmYCo8L6Y2J\n", + "krdprdD1WtBACuRKNsXpMIl3/Lu2dJOSx3NK2TU4x4QIkD2KAhLmiSO1xzomagg8Qxqj7EmzBum7\n", + "uuOdYFxRHlHFgzeNweiqIrxYWf8PSLOwCfUeSMmzg9DHT08tjedA7D86tDH0T7/xT0VE5O13TFvp\n", + "9Hn43t5tS3eskWba0vEnSCktSFtmsw59ogrH08rOvyyCLlJLUvgp0pzUIzIgFVCvjZS8AHk7J7Jt\n", + "VkJZn6a9PU0R43rmpNj++hdDWu7jb/7xuO3P/8xbIiLiSIPNQZ388Mi27c+hAfXIlNI/+UEgu6+e\n", + "fDxu80jlZxM77z2YRXeNakHRuWKg5lTYsIGR7EBptKlqz1EBxnwCzaaTm7ZDHMsTAT5DvqtQZwkq\n", + "YtBULBtfzzGfHqwtPZWh3y+IAD7BNc4pVbWC4fG1uc1no6YfCor2p9bez33qZ0RE5OFj69ePP1ng\n", + "+zSvDM9w+paWbDHWZGYpICcoQHKXU4u1FhvxYxLjpW3oueJDH6Z0TTzmmK6zftVRm7HgHCgF5cSu\n", + "XTWDthNoJGsqTumghSYFU1DCv31nKSuljXSkAF4gfcq0gMqDvkLziRLUh4bmwnKG/WG8ZjauSgnj\n", + "yiX8nETKcno0busd7sn08jOxJ7pHooVaRClpkapVCbqMn12qc0bjSpXQCyrK2kArcSAdOzVons8s\n", + "pS8tNKhokunpHeRFERGpGDFixIgRI0aMK8ZLQ6ScuB3VbyU0d7TWHN/cWQl5VMemUmuU3efkoaMo\n", + "UkFkb32L1TLMhNS5HYjXPfnlpfBm8uzhA5ZrSh5GPtGVo71BZyB2D0TAyxWRwsqgpBWMEoU9ESG3\n", + "TVhpZc5If6tNKLGuDuwNOnkBwqSloBWps9bwnxtwDJaGEFXdJQ9BVYIloEU6LYlntW/0sU9YxVfV\n", + "461PPMruB2cIj1aVeqeEaduvIlJZZqtfXWG03tCXfCwiYK9DrMiYaw7CYEOkZC2jzb2qzpOEBiDD\n", + "qrT+H4sBcttHmqNcWQx96VxAmDytCBX1cNQnDsrLfavq6OTDpeRQWtUPQFW354YcoXJ/B6Vbr7GC\n", + "I68rLTHuG7p203C8Zou2Ca20Qbw/PTMissb3vv/N8e/PvhOQm6dPPhq33bgeVqLz0lCq80VYMR90\n", + "hFyN3Rjafu2moQ8TIGGOizh8+EFO6vgpxh+Xuut1bEiBusI4SompfnERiOdvvhF88tqNXcP5q0Gx\n", + "/OZbb43bFs8DyXlxYWTnk9ktERGpicT+6FkoIlgvTH6kfhrQCZZpaSEJ0VNRyHoREKsBLOr9uRGL\n", + "FeptSJ17vhfGWkPIaQN/ytmB/baaBYQvPTwZt3n1vyTUvVWftBr3JBXFeIyPfLD+30O/diXJH0CB\n", + "3IvdO1v9LdXJn6HPGn9r3DZNgfCAnL5nuxXpwvhwx1wUEu6FRf1d2+bC8eut9X/XQmKBkIsMyE5P\n", + "CNOgY8ar6r+hz+kAZIbOf8CYzKhQZj4J83NLY7Luw9ztB5ZEUEkcUhvHdVd+c0IyNV2rbgs2/zRt\n", + "2F+R83MK8g9EgFdle0eSPF2nckKUicEY25UTQJuAzAwpIWiYHxl974dwTZwnqxCv3oXWd4rO9yST\n", + "MehzyhPqjzlbW+RIjmDcH52/vTNw1iXFv/ScQj9ut4bSFTmyI1SMNXBW4AUREakYMWLEiBEjRowr\n", + "RnyRihEjRowYMWLEuGK8XLI5E8bUoJFSYZqVGwgzdC/YVhTQbNrRx1AjYVLgBvFcSdR+h2CoJsPU\n", + "Js0sUspkQArSE7Srx8oyhlZBVMwMRiyyAIFOMlW9ZhKnv7TfHgS7NOPvBbh5uTG9p/nkroiIbFvS\n", + "AJrgNzXtD+T6UT2djt8OgZTZU9ohJwPh8fjoCk53tp2S+Izs2AEW3yMVaQcCfL1lBd4F9hFSKs4Z\n", + "xJ+pZg2lGydlSPc0nUGxmo5Kd5R9CebV7w2Xh7tPdUyEExs4PaTXk/W21EiZxq46WCvEH7Yh3dfZ\n", + "tlb7luTLZknIW1zbC+eV1tRGjIm8NBh7u9D9ERETJqvLle24QaqoaS3ds49U2erUUnXNMhDFlZzK\n", + "yu5KBGfS5+G1kB555VUzMj48CNc1zwyKv3YcjrW8sBRki9ReTZmNFErJRamkV0sFdUi33Diy3M4a\n", + "6XZWlu6QMi4PjbBcQ8cqyYlYjHNsNkZKP5iHFEwKLbTNxoxS+3shfdmeW3roAO3NqLDj0YdBF2pC\n", + "6RFNh54cm5FwcnQd3/9g3FYgHV5N7RxnMB/eaHqS1OlXm3Cu6y3p82As5KT2voT213zfFMMd3AN4\n", + "nKYrXOOO9Ov0PsJ80VEa0Q2aRrLz1/RRRamgCe7dlkzQN9BqSgvrpxL32/nZvXFbfxDG1j7SwgV9\n", + "X5DlqjsbV3tIrWbkQLBqfxDOZWP91CHdnZU2JrpeKRVEC+hVKy60fbsl81x0naMiHlVi5ykhh4vA\n", + "huapHnSEmubJYSx4snOczaD3BlV+T7pT3RYUBDuU9FopkxHZGmnGjDQY21ZpKdZPDbSV8tTmaX3a\n", + "DeSAIA0U7VX3jRwj9iaYE4kWoNzxgfS5tECm7+z+Ux27igul1JWDaAnqHiCgQpSJkdj1+cBFYX2r\n", + "z3Mi0WMuaMiVIQUtZ13b8zSbQGeSjJx5vn1RREQqRowYMWLEiBHjivHSEKlhGHbqC5UIl+2UYWIF\n", + "SeTgNNPSSPJQwxt2yn49o9i1vSUrGVm36WpExPzSGMlQcMJTNzm8/bKK96CEOpJTyBXNIjQjw4oh\n", + "AQrC7fWQS2CkzWP50xIRz6HUdrW2VXIJBWxHqw/1KRwITVCieIcS8mFLK45UVb/t/BWR6jtGhLJL\n", + "23K81Q8ka5BPdHVMvlJQSs5phdn60IYGK8ze20qzyMLys99B/8Lxd7yuIMkg1E9asc0rTb3+RWKr\n", + "ZDeimFjVUKl3i7LylIoY1OvN0+pLkQ7ZKZfFapKU6sf9Enm8w+pomYTznlEBRIa/a+prVezebOza\n", + "9bUSJm1bC0J5S9fz+XlYCVYT6n+VBwDqwIjwDAjW+bmtIItpQEs6WkGvoHqcUwnx/U/Cb472DZG5\n", + "/RoU9XMr/7/3zVDGngG5ev7o/fGzJ/DOO//EyN5HJ3dERCQtDH3J4ZPVCyENeVix7meGSGTw7rrg\n", + "CgTMN+tVQJBmr7w+fuS3YVw/P7U2bbJwXkz2VpmAhhTbVSH94f0fjNsUHWRXgDzVQhHrz20Xvpeg\n", + "8KIi+Q8twJkSStmMBSBUko7P53NDujKU/fuV3WMD2sSuDM0KqBPGxpqQpl5JvNSHM5SzDyy1gKId\n", + "PT8REY85Ke05wxDatF0aeX+RhDGxnl7Dudh1TfHMyBJCtYBmpqX107AJY23bGfraAaWs14a+9Cpn\n", + "kxDC2akrghKrSWqiO8V5UaYD878nB4wEBSiDAVKjP6HzjLRc9pPVbbNZuHZdS560cOPoOHOC47KE\n", + "Q4FnDauNj0Rtep7VGLOJ2D2eYd73PWVCOvUdDNcioaKs9QLuFPvWr/qs63dI+UDT6Lmr2Qy2hRjU\n", + "Y5AI+OqnmiOr46lgRLMDO56E+C1ZSEqL7IBL2JMV2+hY6zoUilQlFXn8iDeliEjFiBEjRowYMWJc\n", + "MeKLVIwYMWLEiBEjxhXjJab22h1DxVy1gijtkiLdVZas9g1tI9YMgjptQXB/ghRZSuTZUUdC90Xw\n", + "pBvJ5mQyrNvYDFfNjdmhFsTKjHShkg30WRImwGNbrik+ShmmCme2l7b1LZO+F2i7QfsXy5AqOTgw\n", + "AqRrwvn3tD/N8jTNZYgzGVNABI8C2i0LIwCPotx0+jXSTZ7g6cypuaUdPwOhMSEdkxwE3R4pMNYO\n", + "6WSFzyg9gDQDp6BG82lKi/adXk9rp+vDOZZEom/VmDjRdKvtt0P6wpFmmSLKnAJ2WihABxuNkXvS\n", + "xUKKrqfUhkLPQx6uZ0rkaJXUcg2ltnHPZJSKqKFozFowJVShB043QNm7pLT0M5jA7sFwuKOChXNo\n", + "S12/dceOjzTKa6St9PpbnxIRkZWJQsk++uLhfdOWun03kIinB/a92V5I/X3z978uIiKffsXSgxX0\n", + "wR5/ZPpAH37rayIicrBnJOq922G/xczGf4GUYkZ6b1Ue+unaO9Z2AUVAoX2mFqjuUZbaeNn26jZg\n", + "Y/36jaBtxObO9+9/GHZPJO5ZhWKTytJtDdJhrOOkQ7sFifvsgtWx8R1Kt+m8l9J8NsMxHM2xHVL/\n", + "2YY0e5YhLdMRKbcDHWALI+uMxksiqplHKfAVzOVJW2gqOv7svPYxt093aBmhfQtyCtguQjru+SSk\n", + "WChjP2rmDeSAoSnbgdJIOe6j1lMBTBNSZG7NCuDQlmOx8UFdHnAvUMqyh+H4hvahfS0tK6DjN0Ts\n", + "VocKLt5QBe6E0odKW8jweOb7uoXGkvdcAIMUMOndqQOHo/E/mhtzQZNSDwZLgc9yJeBfNhKuNyDs\n", + "0/yv415TrCIiSabafvY93UdLVAV93nTkqNFA28llTAqHBpayKEiLUFNwNV+nTk3biQKBOdlxWhDP\n", + "DHU9EREZhlD4VPd2jUtKr78oIiIVI0aMGDFixIhxxXh5yuaJ3/ELy9R4jnigaaqqr0QExNvqQG+L\n", + "W7xMtuS1pn4+rJStq7i2Vc85LmlUbzQiFivCQqs1rWDfQa7QvsSx1II2mBAGvLdmqZLeaWWWqBI4\n", + "94mqydL591AMpmVaAwV0723l0kN+oKlZxTv83eO8+8b6UKUYPJ1DCUKnS3ilhfZ5vibhDX4YWIEa\n", + "RQGE3BQFVgesVI025VOUoVJZ8wTyA0yYVwJ+Rsq2uhDxL1CxTWil3yXan7SaT3TFgu/RaqXDas3R\n", + "uWo9QUorSO3PwfO6BGiWp/2haKJlArpTnzSMddpFqV6PCZWmTyAXsLVrp9dkS7oCI/GXULIGpeDL\n", + "FSk1F/C/Awow7BR7YKVNpdFf/HJQMT+8ZlIDHz8NROEpSVDnGDtf/MpXrJ24Jxsi6n/67XC8+x8+\n", + "EhGR3/2a+drdwO4+9baVOhdaRUKK/VugA2crI3bv4TxmM0K9QbzOyeswn2GMA7nx5Nc5uR1kRbJD\n", + "O/6jb/9h+B5JKJyfh9LpnMbE0Tzsd7kgFXMgEgNduxxIZEf3xGQaVr/VPpARVtYeScREgF6Ga9dQ\n", + "Wb0HijqlgpYEbXYkSZJiW00SDyn6R/u6Jb0Oj3Ha0z2UwVniOLNjPV2F/c1p/AsQjpYyB5ULCEfV\n", + "G5rSJGE+eX4avAmbwsZ1UQQkkm+hulEXCZ6nQSIfbP5t1kAfU0MpvM4jjJIBOemBCG6XJFeAPnb0\n", + "XFnD49I7O68CqLe6HoiIlJ3671nbx/mBMifqD+qADOUTKtjxOB8aQyq1U5WsIi44FqPZYUx25Gun\n", + "474jVnxbg2w+kE8hCmTUZWFI7FwVQb1YPBq3qa9mO9h8PhbgsFXGqGxOqQOdR6k/nRaK6f9pTG5r\n", + "II1CmRunSLNdJx27XBSRwB+W6sRGj1X+bU998aKIiFSMGDFixIgRI8YVI75IxYgRI0aMGDFiXDFe\n", + "WmovFSeO8nijCTBBnJqW8PS+l4IcxvCsonwD6aj0IDSXpGOSqsqumtf2RrBTEm9H5GBN8wxEDvYg\n", + "sRUVw6gAHCktNgCK7AluToGBqi6Vo1SknjbrSGmbkh3XYG0bERbTsJ9NbQq8pQ9k24E0S7LEgFER\n", + "kbZlQ8sA++4QDBNNI9gmJ5pSI+PPTNOI1neqc1RRP3UD9HEGS8tNoGlUg5Rbb8z4NYHKd0JmyEoA\n", + "T0hFfiSIU0MH/N0TBC+tarbYphzwuaZW287GRAMdqY72myN94cjE0uGadYTZa+ovYW0TVYWncarF\n", + "BS10XNa19U2O4oWisDHctqrObP2/0fHP55WFNFY1sXTbyXFQgD44MlJ2B50zl+uYsH1cuxmI30o6\n", + "FhHJAdn7nK4hVLnvP3ho38N998FDu57Hx4GUffe1T4/b9g5Dm979/j0REWlOrf/rZ0G/abGybSfX\n", + "wrh+9MSg9g8fPBARkS988Uvjtlv7oe3XrlvK7OZJaOfpUzISRur5+PgzaLiZJvs0pJEcGf9evxn6\n", + "/+F3fnfcdv/jUOyRUX7g8OZtERGZHdtvW6jNb0mVPIfa+PTA0od63yl5t6L5Z1TC5iIKpHa6rfXJ\n", + "ADpAN7HrVOBH/dbSLR7q2SsiTw+YFyb5ZS0iTS16Hv+jjBrpAuq8R+M/AfG375hEHI6VU7pXP930\n", + "IVWU9jaGz8/CHJcOlsbRzH9e2T2RiM5n9pxQA++e+qnDfZpRatX3moILY6NurW+ykZ7B8yQKZcT6\n", + "tYOKeUr3iU5ZRW8UjAapso6MxAcUGWmqzhOxPtfUNulIqX4Sz4ljF9P856Xb+b6ISI7rSV7t0rQw\n", + "HBZru05tKeb9ruPnio4J0mzrVcfJdqyFNEnKg3fAMUnvS8/H87MTqTo1VKZddOqsQSlTJZZzxrDX\n", + "QiZ6TjtQYFIqgFICuicKAKcDXxQRkYoRI0aMGDFixLhivDREKkuSkdQlItKMJF72Cwr/emdvuvom\n", + "mpGvUAWyt6dSfyMl29t/gb87lUFIab94W09oZaLq6Vzqru3bUfZGW9jDaNwNlSQnStr2l72JOsgE\n", + "0GmN5fSMCCma5EkmQBV1WyIWJm6DtjMiMuzsj+UnlPO4owQLNItVj5VQr0iOiEjqKuzPVm4blFh7\n", + "WqXrKqWcGAG0LALCMJ8EZOJJQyrSWKXkVH6usMtAK2IdMkzUdy/wWlTZAR5j+rnHOnigFawCATV5\n", + "M3UDxhP5FKZYVfU7noxY6RKaqKukjgoFlMS4lU9ERGSvMgRjo9eT/MrmUMyeyqvWJnjtrddGGF0u\n", + "w9/nq/Nx23v3g2L0wZn5Ss2A3OxdC4hISqXWzz4J38uo2CO/Hq4Xq9MnSs7M7LruHQY0p6jse0ps\n", + "/cFjQ6lyrJj/wld/VUREnj6wtnkf0IeB1N5X2/D3nbc+O277qV/+ydAO9t/cD319QnIK6Tz0bX/B\n", + "q88wtuoKcglT83pUKZY0MWL55HZAmpKHhlxNVqGvSyrK+ORBIL43G5J62MextnT94cVWE3m4ASq+\n", + "ByXyycxKr/tRasSaqeX0NRWPXLsezrWjQpVE3Q4GLjIJ5zgjrz+BivVYpt/yHMJEYXy9u0yYTlX+\n", + "gL6vJPa0sXtsCsmEPZJOSUEAH4BCrFsjMXeQghlIryBzkHpouVBiiuPbPaEuA11tyJHC03xWqhTe\n", + "qq9qzwiyeqLa8Sugijz/DRLua++pKEY9WUnipxYtMqHv4V91KvDkjajISEZI1zivU4bHYyLne2fA\n", + "MyEtOMWAZxHL2TQoSvB8jyOLo/sjhKbbhuPOp4S0gaifEik9QbFJXnBRUPhtltG81+C+d4YcKlFc\n", + "kz8NZVOmQN07Ote20aIIvnYoHiJJGK9+riwToZkDGrt9F8nmMWLEiBEjRowYP5Z4eYhUnu6IKiYK\n", + "iTD3R8UXqYS3x2o+J5Qkx0p3QyWsoycbleSOop9YTThPTvM+vIVzrlhzrymtFlIJ+yio57IcsgK0\n", + "SinK3XLNsB+sSLTtXFaPlQFztKpMkZ7L4o8DuVFrOx3lfvW8m5r8ksA1GvPHJCpY97qCIbdufK90\n", + "tlrtVdSNEDFFvTy1SYXztr2t5lPAjmVlK+wC3kkFViTzysQfn5xCzHFgpA8CdrSCSJRrRisIpys9\n", + "FhhV8UMqUx9XYlgR98TzUh5A2zGqFY6R0QDonMpp8OoLEhMDyxRcRh0VAKuAPtTEabt7J5TfV/3l\n", + "Uv/TZ5+M2z55EMQfVxfGkVM5kZM7t8dtOQQhT58aH+Hxx+G39z/8QERECkImSnz/5g2TOnh2rm2h\n", + "su40XM+7dw0l03t2dmzCmUf7J+GYnxjC0EISogdK8yv/3FfHz/6Xv/2tsP/e7uFSEUbyP1R0bN2Y\n", + "+Oebx6EtGfmvleBo3ZiY/18Pglk+AUepoHsdJeybpfXrxSeBD/XwkZ2DQKTw2ZN746b9WTjvas9W\n", + "2jmQ2Nk++dqpwDChCTnu4+0a/pMEE1cV5BLIrzEHInjjhl3rg2sBiSvJVzEB0tMuiYdWw0ON+DA1\n", + "EKkGCKenMTlymRyhejgd9kRNsDEh+YMUvJ4poU8CeYA5cVSWmJcSzKE5Hb9RoUlCSzz6jn01+w7c\n", + "H0LkFcVIaX/96EnKnC8IfELMU8V9ceDwD12vHp6QWU58MJVsoLmrgrAx+5mudQ5urU+qKoyTHsdn\n", + "VE9UnoefkxD/9NTXA54jDfPRcP2pql9E763EUEI3avzQNVY5mUzRL5LVQP9stnb9J0DdsorRL1xX\n", + "zoTgWrCfbZaqnx4hcRLGbAt0lGUllOcp9J6gSFtKnowpsgR0+JHD1Xc7T2r8S+8d7M/5goiIVIwY\n", + "MWLEiBEjxhUjvkjFiBEjRowYMWJcMV5eai8tdxTLc+CNLZHDlBTsyP9MvdYKIjsPLfzSaP9lCWVZ\n", + "gva8VwIyCGZCqb1a02OWstIUDJf/Ftlk5zMRkbK67E3kAT0mrLYtu+m+jmrNO3yWELF46OCNxfCk\n", + "g9cewZ796Bdm78VL+B9xSbJXRXNAwAxXKrGdrNZUsF0ckf31GA2nFgBtD5RaVd+7YYdsj+9nlu5x\n", + "KFN2gHiL3FIhXj32WBIDx2dlZyX+J5QCtXQj+SqpJALJIudI5WgqqmVyuN9iX5QKTNUvj9KYqTaT\n", + "VXQxnsXIrsoP7Uip+s3XvyAiIvtlSEX1a0vjPXw/pJH2p0QsVV4vndfsWiBIZ0RUv3kS+vi77743\n", + "bqubkMZ79OD+uO3n//xfEhGRT33uZ8J+Szv+o4/viYjImuQPXn8rSBd8790/GrdtL+CJ9n2Dwvdm\n", + "oS1HN+1aK2n+5k0jarcg8nuMnZuvvj5+9qWv/osiIvJH/+B/te+nIS1X7Ns+0mn47euUxkyRej19\n", + "ZqnlYYkULDG1c6TeSvU6LIwwP2ipe04eYkgFDiSd8hDk+Tu33xi3nT4Lqb+MpA6qLsw350sjO8+R\n", + "xlkTyV9lNA4ODkRE5IhSdm0d9jeh75+ehjTvdGZp2dlhSJF3e5xGAbH8gIp8ULLf9JdVrFuQwlka\n", + "IElDex0pPavsTLaTssG8Q5PyBPfnorbx1KoDAKXWJj5ckxYpm5pI3KIkbtriktCmbufZgXlFyO0B\n", + "aa6OfOWScT6jAgC0xfcqjcIuBinOmdTBIUkwmbFcALZNiOwMwnI5ORi3XYOH2/rMrkkLq44CJHZW\n", + "J2/QdvYrHYuMBtoHaCYNzfG5qCcsFepoui23e2KAyjyr1/fgvBSQNXEkvzC6WPT8TILXHaXMRveA\n", + "np0t4J1Ivx2gst4zzwYpxUyLA6jYq4aHonibu4Yx9Wv3bkFuGBoeacxux/8QUkgtp/N++KtSRKRi\n", + "xIgRI0aMGDGuGC8NkUqSVHJa6bleUQXyHPJaGkmSCBBzTGil0aBMkt8KEyWIezvG6F03qL8QyxqE\n", + "4zPSop54GRFbC6x0Ci4hxfpoyisSCCcyUdQ5JXtDQI/eqlu8ffOxHMr+EybMgwDb0wpOyeYNlek3\n", + "44qRloQQ7tRVmicqvCIdzGvcoO1tT4RFrCrSjM2J1MOI5Bw6FVrjt/rQ5uXaStyrEqWrWJGw/2AJ\n", + "IUpPsgIO184T2VUF5hRBCueo5Hka4krG32VbioiVS9e1IUgZSLwNrWD9uOqm1ffYECJAAmEbqE03\n", + "TgJ5fHbHUJfF8wv8ey98llj5/dFRQF1KGhMtyMHtYON6sh/6vZwZIvXd9wNRe0PigzdvBLL3r/yl\n", + "v2Lfe+97IiLyv/3WfyciIhWRzd8GSnVyfDJu+9rXf19EROZ7dvy3P/P5cCwa632Da0JjLEFPPXxo\n", + "RG1FBOoViLWEiE72A0q3yKxNr732hoiIHN42pGt+hLmAZHzNnhEAACAASURBVCUU7W3WNnbXS6BT\n", + "NJ9MQfJtm4Dq3GAPsWk4x5zkOvaOAtLz2Z/86XFbXuo9acc/uINr0dAqHWXsB6Xtr4dIZ0cSAyqT\n", + "sgUBf7uxMakFKzmR4g/3A1F+uk/oXwZiLRH15fyxiIhcLKiUG2gGixmnuO/2ylfC8RdGtt9i9V+S\n", + "+KUiViwTo8KJTEDvIfFQUIZhqqgDbVtI6J8MqPKqs3tonDMJ/c4SFdq1NinZOvXW1yq+6HsSc0bx\n", + "wtCxTIIiLGFcETAjmcrkkF7AGlIj6q8nIjI/AHJDc02egRTO0glaoDK1+2mrkqRAVXryH1VRYyEC\n", + "/Au0T8eMBXOk9Z7ICRFSgvwO+AOUyNEcrz6xYxEBPacTvEZMcpLpAPq37gxNnKnX3450DYqC2Lu0\n", + "00wAzSe1kschNUT38GYTxmRVXPYa5GKjNFcxTypKUOkIusj63uGFCqpoHn9RREQqRowYMWLEiBHj\n", + "ihFfpGLEiBEjRowYMa4YLy215xK3o2zeoyk5QXwNYHFW4M6V7EipHedB2OsMikuQZkoJMk6UPQ1y\n", + "YN9SegbHJWkn6ZE+yYgAPpLdSdm5g/ZSkhuMmaiHGqUb1P9K0e6eyIFNDdXfxKDoLlcdLWtTDki1\n", + "JsjS0mf2xQawaNM/tzaBZF+MpGxWVse/LRMMoXFD+HAFkmvGOiq16rjwb8O/nkiJqjarqtsiIgdz\n", + "kOdHxN7OqwTJPhWDzDukLCkDK71qGjmGjEGs7zlVrCkAgsW1nZoBovaqr1RJBOQkC9fYEbFddcw8\n", + "4eObLqSKfuoz/+y4bXEWtj14YATwvekBjoEiBmpbjZR1tya/SBBfSdpsLID4+KMPx2237rwlIiLH\n", + "1w1u//CD8Pn/8Bv/9bhtDj+vL37ll0N7jszz7bd/92siIrJ/YP2f5UFT6l/453913NY16gBAYxJp\n", + "vlsnRgp/9ix43G3WBpOPpPwtriGluxsQQKeH1iZXhDTfd98zX79XVkEz6c5NO9flMii6z+d2n16D\n", + "T+B0Rl6DiabqlZzMue1wrVvSB8qgi3XgTTPrFaRem+fk4Yc0Sss+bRifq6Wl1k6fhoKCemWk+Plc\n", + "C2XCtd6SOn2GduY0r+0dhTE0O7BxKkiVJ6SsXqOPJ5SCUrL3xcLuSYe0TA4qRM4+gBobS3cPbfh7\n", + "2PGQRJ9RCm4fGlgbmk/0srd038+RKlzh2rgNaXvhWKvG+lr6cN2nFRUFID3Dvp57VUhRb7ZUgAPS\n", + "eJ5S4RHmk6bROdTm8BrzyWRCXn+Y/1Y8Tgp8b8qaeYL9Wp+oywErgFcVFPCbcD5lZv2/2oTzHkhv\n", + "UBkyjuZ/TcHRNG1pRnqeKbWB96c6e0zoz5A/nOD+8509KPsGaT9OD6J4Y03FFucXGOsd6cKVSui3\n", + "Phan2lJUKIRioBzuCTm5KOg7AfvqpakWJXGhWGg7SSWKcuGzjLQCMXexVthub1yOiEjFiBEjRowY\n", + "MWJcMV4aItX6VDImgmn5Oa1Ix7dqJodhpVOQsnVegJS+tVVVD/Jml9qb7rjqBJrFSrBKYh8IQXIg\n", + "m7HXnKJjXBKrpaBZSqW2WXgTz+kctaw1UbTEFovSt1AsJpSuVQAtp7J6HDbh448lnqSOq07bJDHR\n", + "Dc+xD+yPESSsEltaLaqsAiuBK4g3EImy7i57GI3VpIS6qdp6QsjhJ1Av30OprycEKQM5sKDVmoDE\n", + "vOFrDRiRvRNVeZmRI0W7OiJqlmjTWP5K/arjr6DrP98Pq/80N1SlaQMZN89s9Xnz1mdEROR7H/zu\n", + "uG0PK+aKiixyKLqPvn7eVMcFq75pNqPvh3EyyY2A/RRq2299yvznnj0PhP7vvPddOx8QhV95xdTj\n", + "f/rnfklERL7+e78nIiKr1detvYeB+J6IlWv/yi/9ORERefzk43Hbk6dhXN0gNCsBmvDgowfjNi1n\n", + "XhIio6rcev8PdL+oTMTpx+bN1735qfA7UpZ/fh76rCOfxH0Ufjx+asc/OFBfQfvtrdtAc/bCtWPP\n", + "u8l+6HdH8KeuVoc9u9ZHuMc+pkV1uglI69mZtd1jKUy3kxzBu/CUFKjd6MoQxt1yYeM6K8JBJuS1\n", + "psh+QdIVHbzOHDkQFJBT4CV5+xzq5VT+30FiQQs7pLV+rYCwOCpKGHp43VFRRqtoDheg4Po01Cbt\n", + "2pyI4g2Q6xKK/vlg479uQr9yEUUroXihJL+2AVIvOfVT4gOamExoju3D/uixIy7RuaXGuZDUAea4\n", + "gdBnB8S83tg8sVrAxSGjYqdr8Ekk1HPolbxORHmozGc6r5M36DR/U0REts7uv6EPiGXBdhsg+1cl\n", + "FWrhOcXSMfo3E9X12bLjUyfa9nB/qAyGiEhSQjqkpUIN3MeziRXPrLpwL67WhrD2qG5KMnruonig\n", + "oHlPx7bDK8vO88+H8ZftmNJC4odQUlWAT9nrr1E/WXrHwLUdyLs3cRGRihEjRowYMWLE+LHEj3yR\n", + "cs79befcY+fc/0Xbjpxzv+mc+65z7h865w7ps3/XOfc959x3nHNfffFeY8SIESNGjBgx/uzH/5PU\n", + "3n8pIv+ZiPxXtO1vishveu//Y+fcv4P//03n3OdF5K+LyOdF5BUR+S3n3Kc959AQTgrpWJ9ohDZZ\n", + "CVyNJ4lYB6jWE7OsQKqkJFXsxTqkW1xiUH0BnYk0U3iW0j5IabF5pRqzDpQeEvzdkQT4qNjKBHho\n", + "QGWFbdM2q8YS8eCkBxTaNHxeaAXhzi8QZ5Ucui9twwahAeacEClvDQh45KkSEpqoGSylVrR/UtIM\n", + "aUHO3DX5hCp6Q+muGv1D7P0K+jmOyOMbXJ8ccG6ZGhF4NgmQbbOl1KaqnZO2TI0+SyuDh32iaUlq\n", + "J1JlTGJU09YCJEpOd6oWWUmpvQwpg5JSBvNZgNvdYOPvvff+UEREJmQa6zvA06Se33ukQ5AWzMh4\n", + "M9X7g/WZsPZZrqyI4O7d10RE5MMPf2DnivF5dGCGw5tNaN/n33lj3PZP/vE/EhGRHP20t2+Gvh4p\n", + "q1/7tb8+bvv1/zZMA7/4i78ybnsT6bbHD8w0uOtUW4eI8qmmrGxMqAK/jpfz56RZBAI0E2HPzsIY\n", + "PpkZ7D9orowY+D3mkRlpK11sQCItbd55+gRpwQ5p3CmbnId/PRd7ID3br0nZfhJ+e/z6G+O25w8D\n", + "sf9aa+O5XiClQWmhCca4o5T2dh3SVjXSc8yidZgLONMwK0LKzlWWgs2grdWvqQAG6UPWdtqADLxd\n", + "W6q8QJqjrmEondD4gwm3ozYlMCFPdsjBYR8FkbIHpAq3ZBqsnrYN67dh3E2GCu22se5w/2/Xdl8V\n", + "0MfrKD2pOls81rTwhCkVSRL6P/Hk3uA1fRXOMSMXDVWd30kZ4Xy2NE8VVfjt4oJSq3or0ByjBVWO\n", + "6A6p7OFfJX3bPTTNw3j2pKw+ZEpVIS0wzCNVab/tGi3AsmunrhRtexlTSXcI2KFPOugtzbgAB+T1\n", + "hLbpw6WtSVuxD/dCQvNpP+A5zQ4YY7qRNbhAy8G48pQyzsbnJKujq7k0pzHD/jYbe3ZsN+Ge7PlY\n", + "MMveYc+zwN0L4kciUt77/0NETv/E5n9JRP4O/v47IvJX8fe/LCK/7r1vvff3ROQ9Efn5H3WMGDFi\n", + "xIgRI0aMP4txVbL5Te/9Y/z9WES0xvmOiPwOfe8jCcjUpRiaVhrymstBABuIiDeK2JLc9lQVqBN7\n", + "q8yB/kwm5DUHouqqNmKbigEXXomShL5ATXYHpQIpct2asmyGVXXHyBH8slS5WEQkwakVOz5Noc2K\n", + "yDDBTVc/LaEPDQjoaU/vsfDf89QnCdRhB5JzUInyPLc+znyB4+f4186h1jLYHfAQpfYpE/u0rJmk\n", + "FtTDipCz9VK9C2k1jT7m0u0KpbBblGnnU0KEQPzPCWlscF1TXiVuce1IMTcBQT/ntUKqisW0IgTx\n", + "PIGXEysG68opJ7JnDrKvKrKH3Ybr//HZt+28qmtoE0kigCjriIDaN2ElXrqwv5yIsOpd2PRW6j2d\n", + "BFmDQyp1v/d+IJQPjbVzbw5iLSGYE5Rxv/ud74/bDg4DAlUCOTg/t/vq1/7a3xARkf/8v/hPx23/\n", + "+r/xb4mIyNd/+/fHbU+efkNERE5OjGz+9ttvi4jI44+t7R3Gybe+af2k6vUZ4NklIVITEEzf+onP\n", + "j9sWQHX6h9avb0LtvG/s3nm6CXICN28awnbrbvCs29uz8aSoo5KTO0IL1KcyeUEBhidEugFBvV/a\n", + "ue4fB5Lt3jVDpD74RpCTaE4NuTt7Hq7JvDKETTmzLRCpGdVaHB4F9PG1T/+EtRNIb7uwQoX+PIyr\n", + "hFS01yAPp4TIdFvIJFDxyBbyJDNFM+geLlBEkFREdk8UkSevS/TTllDqtgn9VHpGfYHwEXKfYsra\n", + "4Jow+m2q13YOWmyyXtM83YY+KQsrCtAMQ5qQn2kPBwpC80fIHsen6WqsCmG3Be/VxYJQ0jbcCwk9\n", + "ky7OUIBEiGiDoqiBimcqoOMFPElTytK0Kk3hKNOg835GUhvqisFpB/WaJU9WD/SNXS56IGxMsFaS\n", + "ucrZ1K21d38vjPV5anOiplsW9OzqgU5fkHWiIpsJ9WeiD0+xfurgbVnAa5OLiJSon6bsdbjd+UxE\n", + "pK4VVaOx3qraPEknYU4g4E78j8Cc/l+TzX0YUT+M0v7D6e4xYsSIESNGjBh/RuOqiNRj59wt7/3H\n", + "zrnbIqLmaQ9E5FX63l1suxS//VvvjiXqd986krc+O33R12LEiBEjRowYMf4/jQ/fXciH76rMxiWa\n", + "905c9UXqfxSRvyEi/xH+/fu0/b9xzv0nElJ674jI771oBz/3l98aiXsiIksQLMvS4LkG0PbgDAus\n", + "oJVRFIZ3K7Q8JbXxPRAvzzamGNwMAfpNQSxlgplC9jvaGYBxUyKsr9dId00ZxoXhMCnbOsCojlW0\n", + "FYLE9/LO4NQJSH81p8wAhedERFRlc5dY2zPAshWZG6shs6fzcSBxKgGvo8Ex+vmK0PcvG/9qapPT\n", + "km17mYDZKxmVIfhetT1s2wa/HUAKzVpLT5R5gMc9kVOVbF8RiX1ahmux7kxbRlMLA5sra5Mp3aH7\n", + "bqDOmxLE3OBaTCk9kCZQUSYS7bOLYBCck+HwEikDNi3tkdJYN0ZsTZEOzqCs3DQ2riYwXJ2Ulh6a\n", + "IKXy0YN747bZLIz1jFS8B6QMUkpLnj0PpN1qRkauVfjNEtpBX/rKXxg/+81/9A9EROQXfuHnxm2/\n", + "8Rt/V0REfuoLPzVuOzoOabz33/9g3Pbhh4Fsvd1aHkmJ4puVXadr89D2Aor5BbsYOCWAG4k6B8m8\n", + "pVTIvR/cExGR23eOx23Tadjfxdr6v1ViK+VqyiJc/9ksjLVyYmkfTaMUpO2mIlCLhZ1XC+VxR/PJ\n", + "2f2QPr0gZfHXvhCMjhePb4/bHt/7AxERef7M9KbKFBpIRThXylhLjmOsSe/q4GZYuyasmH2KuY5y\n", + "YC0I5S3dz6rp05BSeYnz7XHzZo5TS6FtGY2rUdyOim2UbE7TlKRIm7IDwBrzc+uoeATHQ8ZeBiLH\n", + "p5iTuK9VvXpFfT3TbaQKr+rhjgo62g7k9cbms0GNfDUVRgUrZaHnQCa2uE+5sELJ0GVqxQ6j9lJv\n", + "165tw3XvOtKPw/5SKJz3pCKu89pOunGcs+wcVO8wyyv6IoqHMkrBgqDO7iEJqB/9wGbZSIGD7pLs\n", + "6POFtqeFuRgoRSQtSSsSE39GyuJrDG7WgFJF+YxoMett0AqrlPpApu1KGeioX1WWLU0unz87hVRQ\n", + "VleD6rC/0Ka7bx/J3beVruDln/xPn8ifFj/yRco59+si8s+IyLFz7r6I/Aci8h+KyN9zzv1rInJP\n", + "RP6aiIj3/lvOub8nIt+SkJD+Nz0nk2PEiBEjRowYMf5/FD/yRcp7/6/8KR/95T/l+39LRP7Wj9pv\n", + "KwtpabWSjWRrWhnghXTTGmGtgDnTdPLOuE095FJaOc0UkVqaAmyP8tguQVkv+UDp6pO39Xgzdc7e\n", + "zBOUAjfkSZfqm35u3el1FbNDrAz/KpqUUHmllut6VnFX/jOXv8PPj7jW0qBMviS16w4rzJ5WKV5J\n", + "hiP6RO0FMuJ2vg8CLpXGqoRDyYq542rCzjUHUbutraFKBmdC/xZq7w795cUIuylWRlMitmYgirrc\n", + "VpUTXbk7Q3O8V7V1Wrmml0tie1zH8XsEyWnJ72pj53/rTkBfzs7MLy8HKXRLsgbq8dUnhr40HgRI\n", + "UsDOIImwxfdKKnVe4BrefuPNcduj+wH12Z8b+iIg7H9CxG71uDs9JfI21Kh7kh3R2o47d4OEwXJh\n", + "379Yh9XycW+I3DtvfVpERJ48sdXZxx+H1eKXv/zlS9uWS0M6dPzfuXNi24BiXDsM1y4jwvoFELTZ\n", + "zMbaIXzfVgsbEwtIKHz00aNx2+tvBVK+bMgncqIohd3PEyByut7rd0jk4Z6YnRiCtIXK943rdg4P\n", + "N2FF/sEP3h+37QNNOKlsQH39f/+fRUTkzc/+9Ljt2h3U4hApViDdUqAoQYnrIiIHx3dFROTw0K5/\n", + "vwzHb3qSbpgEUu7Zqc1/MyAxm42RslVRPCls3NHdLiK796u6QvA8mY1uD/bLTpETQhUqsObVc1NE\n", + "5AB+ogUhAgXmmBYPgKekhF2BZD1NWRIkHL+jAhxVqHcsp+PWaJNt2wCJVSKyiEgPAnZeKRF6/Gic\n", + "QwaakxOQoiualEt4WG7Ia24CNDMj6ZQRuSFl77oNKJ1H9qPgYhtVYqdron28s00nMiKMZyNiRsgh\n", + "kHC3U2QE1I8mqgF929cqYWJjrYZPbFPQ3K0+iTSf6uOH0bQU/rMdaVI0rRZl2Tw1wY/Ozu6LiEhV\n", + "2bPOY95lErnrw/xH4Oco+8BFYcNYZEUK/HgHGSg7lDK0+oKIyuYxYsSIESNGjBhXjPgiFSNGjBgx\n", + "YsSIccV4aabFfdeOWkcilr5KSR9DTTtdx0S0AJV6Z/CcmlUyG0uNfjMyvG3bc3ymWiREBNeUGiN4\n", + "IJszsbuFFk9LjDlVgB4IWveqCkvnqAaVg2oXJUzixtcLaoB6CxM83sE8MnMExePzZmNppLpTwiph\n", + "m4AvFYHvO8NYizT0YUuwr+tV2ZdUZIHV9mTkqXvZMXYctUpIlRx9nO9A2+F8aqjNdnStExfSRwUR\n", + "Jqea0vNMoofei+PUAoj1BC2rHotj11gcT/WufE9KyEC2pwfW3o8e/pGIiGSFpUeSIaS+BkotJmqW\n", + "TddOSflMdkyc6qeFcX1+atfkZz7/F0VE5NF9UyyfTQLxvGZ1XpC3b90ysueDj4JWUU4GneUkpLvn\n", + "ZLjbqGknUjsfvf+98bOv/PwviojIH/zBH9jxkR48ODAC+GuvBbLz979v+lTTabiPrx0a2XazUW0j\n", + "GycHMIFW0n+9tnF1fD2Mydnc2rvdhLTLfGqprcOjPZyzpfYuzmGkvGfXROkDe3T+ExQN6D2U0MXR\n", + "tN9iSelRpBafPbpn5wq9pQMqQGlOw9j9pLbzuXsztPnZh98ct+1fCym4azft2qUD1OhxbW7etNTi\n", + "/hG+d2Tfl61q5tic1Ov88PTxuO3Jo1AAsCHyto4/1rtrkOaqKpCOOT0ykpiZAoAUGN1sJagKPc0d\n", + "agyeEnm/UM0sSpWpgXKFx9MBURZ6pGcuNpTGQ1oqJ4P2FumhtKNCAVH3ClbWDsfqaT5p23D+KTT4\n", + "WNlcU8COiPWDFgORtqEKuPWOjo9r0veWWtaMmn+BjtKANN6GnlO1D2m/ji6KA3k84aIAKNAXVBSQ\n", + "qQkwFeoovYPTeD2KsvhecB5zcA66R09K7Gj7s3Mba0cHYU7oqVCshd4WaxV6pG8H4WtXXPpehuvu\n", + "s5DG9r096zLVO/N2//WtPuOp/7Nwr3t6TrVdmHdZq6yFVqP0pCTgSMztBRERqRgxYsSIESNGjCvG\n", + "S0Ok0kTEEcHL6Zu7Y6QhvCVOyMOnw5tmQ+WnOXzKBrHfFopIkU8cOHHSjorqLE2gXm/2BruBrIFn\n", + "SQKsqraJkQh1VZUQAd1LWPWlORPasSJSDztCulQSoWeyOY7ld8jmeDNnVEXPj1a/SihmFdsEKzZd\n", + "aOQJqf5qmX5Bpb4gduf55Td4ZvHpomcglKpD3yVCb/Uou3be0LRSDQVBJtxQWXtTh3O4EJOwqK6B\n", + "HJkT2TNXtWn2NVTCIBPgQVTnfk/VayqssFhqoYLnlWttNeKS0JaUVnUKuuWMfqX6EcsvwCeNVqm6\n", + "Oq/7sN8vvPkXx8++/V0ohlevjdu6bSB0tkSAP4Ky8CePjFh8fBSQkw1dEyWIbsh/7fpxIE0rWvTK\n", + "K3asH9wLxM43iOzeQ6n93g8Mfbp+/TrOy041xyq+76w/FemYV4YwrlGePoWsgbZbRGQFpK2aGPqk\n", + "91pP40/V2dlDbA0PxYzGs6JPRWEIo6JTGyBdAxFRJ0DV2hVJgUOJfn7DUKJPPgh+7q+8+qlx2xl0\n", + "Ovq1lbU3dVjpz28bmrS4OEU7rU3Xj8PnHRSuc5IayYBOdaRznM+uXWp7g/lnduOufQ/E/4tHpCyP\n", + "OSGbGqFZLSDUkzJjSQogwo7L1WtFxKidkDNhV4qRtM7ICTIMPJvNgdR7/HtIWYWnQIsykslpobK9\n", + "U5KPubDtGPUP466he0IclMKpUGjAnKmODsmOOwP+Jsa0umwMYnNXN6h0gvVrDeQwI/kBJe2z/ECO\n", + "QV4vw70xkNehonrdYPew67X/KSMy/nUZVeLiAUURk9T6uBmW+CX73gKJhHr4dkP3FeZfJow/O7sX\n", + "vk/PDn0mejE0S8dRS44CPdqXEHIomMcbJaB7KmJSXj0T21XihiR5hhbFBinNyZifeT4ZW0zPKUfH\n", + "e1FERCpGjBgxYsSIEeOKEV+kYsSIESNGjBgxrhgvLbXnpduRvVXYVeE/ESMg5hnBjnWA2+qWGbuA\n", + "R1kXSYnFlNoaQHJVJVRWfR6JbUS6TMEA3yEgI2XWEIypBsZDzTLe0AwhaLsfU3tI8RA5VNvCqUg/\n", + "4HNKWfQQ3xrYIFRhSTZcRt/1ZGRcVlCFz0Jfty2R85AqzYnEnuVLtJOIiEgPMTlPYVaGgpW825Ni\n", + "sAzhOrJmx2ggirRASer0GxCPMwKqV+vQzvm+HUth/oxMextVRaZr5xMllhsErjCvpgXXG/v+aydB\n", + "4+fs3Mje80OoIxNhulPiKaUFR9dq2jYSmimRoWax1+afFRGRDx789vhZBYPOtrHUpir6TkgxWYnn\n", + "16/ZNvVK5oKGAn07P7J06wIOoqdnIWV4+/Yb42enp6rfY2kEzUCcHJva+gV0nMrS9ruFPo+qJIuY\n", + "8n1LhqeaZmvqJfZv56DK/puNkb2vwwR4uzayqWpR3SKDYqcS+KQ3dnAQPt/ft3SLpvnnc2hs0T3U\n", + "4bNqn5TgoTFUZKYjNT0O5PDhk4fWzjfeEBGR03vfGrd5zGOZszF+gjZXpJWWoHimQHp0781PW5uW\n", + "IFFPyY0a81m7tfu0BIlfKC3UQNF+OrG2C1JENZkLJ5iDskTn0Ms0AiZHlyD7cnpq/A0Vj2ixi6cC\n", + "FJ1jyW96TK3pHHNO2l5qLjydsGI4NOsoPaRFLBvSEZtg/vNEAdnU4d6qiEucZVp4gPbSHJ7pM4um\n", + "vwyk9JbUybNMn1NGAVGF+umEi2KQRiPD3d6pKjjSXi1pTG1RAOCs2KVM1bGCSORINzJVQRvN2l4e\n", + "431gSgmKoXqi2aROje6R9iUCvGrFeep/fXbkPbcJzwlHY1c1w0g/UnB/5FTQNeDZqVplLHvVoPDA\n", + "U3sLrR1jvTM9LPWJpmo9aVbp0PaUKu/dD8ecIiIVI0aMGDFixIhxxXhpiFTbLSWhlVmHt+RJbqs/\n", + "feslrrWkWOlkVI6o6t2MEqg6qyeyb68lm3gj7sVWYYMP25hYmAhQMkLOPLpsS75WuZa9LkmBe66/\n", + "IXVYoFROSz5ppaNyCT6jMmCgGh2R2FVVgRYE0uMNu8+4rB+rQyrTVWmJ3AeCLaueuzSsyBvygVO1\n", + "9Z5Qwim8DhtCpLbwdVNUUURE+bFDclmBfEbFA/sgAG/asILJcpZ/CMenBZnUq7Dqm8xtRVqhFLsn\n", + "9GEFMqRvrE19ourthDCMRQPh+ydHhrR8/CSU089mdF3VL4tQrcGBFEq+hlpq7wbyesKKLHVG8m/r\n", + "cHKHt4A+bZ6Pn01BAPXsYejDtumeoSrPnwXEpqEbpcEqfo++9wxK4W1jfTzfCyvnYh3O8ezsyfjZ\n", + "rVsBudhuSWoBitHLlY0T9TrznlFSlTEmn0SMhaoioi72nWOV3lEfqqxAW9vxU4zxprNjnRzN8JmV\n", + "yZdAX4qJXeschQ0FwQ8qhZFNwjXJCK0oVZWcSKceBNhhZcruRyB0PyHF9A5E+aM3vjBuu3gYlM+T\n", + "jIotoNCcFJdL0kv1PLswRDA7DGR89p9brYCqeLtRVt8OCvjFnpH3S5S/z2Z2/NOnYeyw2rcqG3SY\n", + "pwpuG4ojCkKOFZ3K6P5T4nndWZ8MOEbbENKgx6T9tUDHLurwW54v0lYJ2zZ3laNjg107lf1Y0zjd\n", + "1iBbE5qmGYaWClXUg1XJ63Ra0o2+gkSiHi4jct0QrslQ2/E1I6HzJe+7Hwx1LiGd0AJpaqjYwUNq\n", + "waecacHzhLzxnH6e2Db9uyBESNXAO5oTmgGFUoWNJ49nocMztG/J11NlgijToPIPCc1dXlXxCSXv\n", + "0tD/BP6MTiWkZiE9fPTy/jLpe4uiJNbpyKfadiKxI3PUkEzFKH9BavvOX5Zf6OjeelFERCpGjBgx\n", + "YsSIEeOK8dIQqWFoR2RIRCTxWgZJ5frg3jAfZxQw6xhpwfcI4Snwqp94ysciD6w5Wv5+lqpY2uXV\n", + "Use5XyRaW3rT7gCZpIVtq7dOd0xnrV5vQNC4vHTQVT2hVFg5saxBiVx63TJKpuWnDN2BZ8BCbz7H\n", + "fsOxysJW5h36k1G9NFOndSprxuqU+7/RFRzx1sYSXltMy6CCeNTMsgQSgLaw/IHDCkv9+ML56H5t\n", + "VaGV40VF/K5NgfOi1V8f0Jme+iQHbyLHdV1vjXuQ66alyQAAIABJREFUgfOTkIO4A0qQZ8SvwwqO\n", + "lyVlrt6N1J8S0IFJeWPcNr8eUILHENCc0jms4THJPIsZEIGWynUz9OuKfL0SfC+hdt66FVC8B/dN\n", + "JuHps3CBPv/5z4mIyL17xgdTngsLWF5cKG+KPSR1RUyr2ibcE5MJiakCJepa4zeZ6GXYduOEUDWs\n", + "vg/nhqotFmHlzvepiiOqgKSIyEzbTOevIqHMUdM2l2O/E/qiHEmScFDkihRRpFnBf+8N4zJtH0Ie\n", + "ojCUbO9W8Adt1oY+zHFueUUiqZ0ivLhfCFWRGnzAmSGycwy8zcMPxm0V0J97f/iPx2237rwuIiLP\n", + "n5knmnJk8tzGnc43JfiSzIdqwBtzhIiorAR/b7VeXdrmFLkivokKwV6s7b5THZGJhP2uCS05BHK1\n", + "JKTzDG3KCCXScdVu7VjKh+LniSJCLWUY1E9U7yFWmhmQYcgZpkLzWqYjYa7vtrax60K/rje27fpx\n", + "OMeUELYewpWiaD7xYWvMu0Nvz7URCGM6mj472VcO++12JCmAEnWX51gCPSVP4X8HBMcP9uxqavjf\n", + "TgnpxTVmMVedID0b4Olzb2c+edHzfIrzAh+ZfPUa9EmzJakDZJtS0qRJVSSZRaIVzSMulyL2RU7n\n", + "w2jbCyIiUjFixIgRI0aMGFeM+CIVI0aMGDFixIhxxXhpqb28KkbStYhIAii03dq2CmmkvqfSXECG\n", + "xKGWZhMwSC5dVui/qoyouG7D35oB6xkKBSycEenSJ+q5Qw3Hb6ZU6i1pgN47wnYbqHgLpbsU0c5T\n", + "VRjn9kKugNJo6s1WEzlzq3WdDIWKKvAyZBtgTPauU3J5qZDxQKlVkGyXG8vFFRUUc4nE3um1oGNp\n", + "qa/3lpbT9CnLOajasSdV8AaSEfN5KNdua9vvViUZCPaugTdPibDpoF6dCo+dcI4deS05kOy9t9SK\n", + "oswH8FB78Nj82kqQ5zMiB49+fqTinEIBvWms/HlSBHXqnq6xpnRTKrLYA2l+swDplyD2Oe6JKn1l\n", + "3HbnZkgPPXzfSu21GiOhvp7B9+3i3M41Qarq5k0rf//owT0REXn6NKR7VKVcRGSJdNuKSNSqjs4l\n", + "5DoWWxr/mvpoqK69nOG8vV2TDvfsDMrmljqUUcOBvRn1GOz11oHEW5DadZqoJxyPcRR70LUrME7S\n", + "UYmbTku9M0mJWtQLtKSctcqa0LXLZlAg31jKanJ8J5zPhcmOtFBKV9KriEiB9KHuLd0nuYLTUAww\n", + "JE/HTR6l48XExmmzCL++ft3SyOcY2+w1pmk5TssqaXokT1N6TlXOd9J9TXNpm0NfF5RaVQJ6R7Iz\n", + "PVIqh3NKFeEaDyhJH0jF+/kKnowdpbFx2zfk/1aAKjCf2TzdNOEe2zY2npVYzs+YHMUQVk5P9AgU\n", + "kbREbB8wj/Y9p4z1X1bMRr8SfLFZq/+gXbsOKe0UOUVOuyotgot9Usy1Rcnfw31SXvYf7Acu/wdV\n", + "gtNtSOmnQoRy/CZBWszzPjCfqROFiMhsBheBzMZ63eE6kkq4pk3ZbaCDxIijeUJ9Ui3dR/2Kvmjp\n", + "mVCnmBP5vipRqMC+fl1oZ0cpYE2L9lx4lvDEcDkiIhUjRowYMWLEiHHFeGmIVFHuiaNSxqHRN077\n", + "TtuFN8iC3si3KI1dEGGzQqkxC8fpinlg8nQaUI8OXkKeypp7p2/TLIyH0vCdl1EtCbbvaZmkS9nr\n", + "Dt+mUnevIp6pks2J9OaVsEvtVZLzYKvaNUQqZ8dErFZRMXqD3oAA2BMpcQsy8kQF/xyjb7oKo5JP\n", + "EDBzEuT0WIk58hA0HyIqAMCmoiBETEmchMi0NUjxVdhvURKJEwKbO+X/WK2uN+TJiLZX5cG4rczC\n", + "qjMlRMI8/qjvgEgs67DCn5Ykl6BoSkbEeqz+JyWVy0JoNCVBuBxO5BURFpWUnYmt0pbPIDCKMnhf\n", + "2y05A9m2W9g5NFuMXRaEVZtEOtctkMWT64ZmPHwc3Nlfff2NcdvJSUAsnj0L0gjsq5dloW2MNFmJ\n", + "N8mPAE3d8Y5UnzIqddZig6Ky8+/gnaZoWkPEbnWu31BhgZL3J1NCtTDsG1p9TnNFfUm4FegIF29o\n", + "nzXwH0xL+36PMumMpC60DFto7tICjIT8P/tpGIslzUlr+OqVJEngl2FsbZaE5oJ4nkGstt0aOb+4\n", + "GaQW2ne/bvvYC9IZ9akVEQyrgD4lhbVzijHbNIycAGEgkUZF8bxTQUqSOlG5CkI6VEy0I/kN/ZvA\n", + "P9luIbBLBTi664T6Kcd5T4B6TwgQnOdh7KwIfVoNYV7rB7uu6r86m1CpPYpW6o3dz2fLcN8XhR1k\n", + "swj73ttHyT8j/ZCaYYRCxy7vV4WGeT5VX09PWYcORUM9ZQ5URqTH82QYGJkJ+yX91FEImed/JXun\n", + "lE3oW70m1Han52jf02cbeye2uMk87nW3kxHRIi5rUwHx2YrvJ8z/PRVF9Q5CvAnNcZgTevauxece\n", + "mSbmfmvRFouPdhgfFT+8R6FN29RtUahFwtEe2SRF8EREplN7trwoIiIVI0aMGDFixIhxxYgvUjFi\n", + "xIgRI0aMGFeMl5baS4ZMytTSXhn0ZhqCIgeo4iYErbfw1duQZs5qreq8nNpTZWnCAAHHj8rBhb1H\n", + "qup5yqIhKdRUE9OCUdhPCApVMnJHcLMkl2FxN/rYqece+wVeViJXZJUVc/W3DK1mKnfO8DjOoyO9\n", + "qUH1NpCym0xsvxXOYY80e7abcD5FQSlQ1UyhdFsL4idreygBcCBS5noTYNyDGXmddeG6a/omJ8Kk\n", + "9pyj80+60P+LtaVC8jzso6R06/4kpKyWiY2TFL6DQ84KxEg3qC4Mp1Y1BcjGTprGJSJmnmtRBJMT\n", + "Nd1n39uH9k+7NvLsmL7GveAojbhaoGCCSMTDNpzjtLIxOepikYp8jXxfR0Iumj5ZLCxVrKRwJR1z\n", + "2kvTA0omFrFUEI9JTdXspLtVn4hSS9o7nlLKxUTTfEgj02czVTanMaTFC44KAAqkwgaazvQcj44s\n", + "tann5ok8rD5mY3pma+dfgahcr8jXDymblIjtg6YnSYo5hcfdQPdpMcE92dj+elVRXpu20+L+/dD2\n", + "d4IuVXphKQtVvnd3TLMqffCHYV+ZtWmDPll+8MfjtvlRSClu1nRPIN2Zk96XjhmH+zklasUcRQGe\n", + "U3ZQ53c0/463EWlGVVCZ73ouSnDYB6vn43pryp6OX0KLadiyYnm41jx3pOiLnvShpuiTvaltew6n\n", + "hO3axniK+aHRwicujkDb1aNTxHxK+dmR457oaY5XFfEs5QIYeJe25AmKVF7Xql/e+JE9szbsSRt+\n", + "O9RMQFdfUSqKUW0nSje6F/yl2ot5xj6ZSIF1qlloY1i9bg8OrChmnAto7qygqdZS+r7eqscmUUXQ\n", + "9po8Fh2eN5aCpJQhnutcvKXpy4zm0wxjrd+QthRcLjoa0KoVKDsK+FFHKkaMGDFixIgR48cSLw2R\n", + "yiSTLDHSaa6Oz4Q+rfEG3xOJTN+0e0Juzi4CYZAWiZJl6qtk25TEqKvEg4qIxfDS2fZWfj3A9b4s\n", + "SQEc5OieZA2ykZxHxGa8YQ9Ukqlll2500qZIdsl8IkY63CVMNzufidhKyBGJsADJr6dVikoLtFi4\n", + "kTi5FJPQx0VFb+FtvnPMcOBwDh3Lk2OF33smz+NY5GGlFbbn5+YnV2AMtFgFduR/WEHFuCV59Ayr\n", + "yvOV7bfuwwntU6FAhRLyxBapsjmHijUpul9sAxKgXVySEm6HlVlGpEslYDZ0Xrq/nZXmSGgn/0Gs\n", + "yLakdqxFDjXGSYcSbRGR6RDO4aS0ld4pfPU8ESFbRcISKgkGyXvFaEquZGu7nioFUJH/nEZHK8dx\n", + "H8mL1l66+rUtJdABlinQ3zpav42eaapOXlgfFriH2Ydtgnbm3N5MXQnoXsvD38uloW+qvJxS/fkG\n", + "pHxF2HgMt1j1d8TsLYCYt4ScpxjYrM7c4+ZKSAG7A4m5Xds1Lk+C2ni+TwR83ccjkMdL6q8nwePP\n", + "k0xF26v8ApXkF4GAvmYRadx3N05MEuEMchMNIZF6nUr0ccJyBZhQWzZABXI0pXNNFSUmpX5VUeeB\n", + "0gBZYtQl1eMB4d/SXHOxCUVGFyvrwxRjrG3sHLIKxG7GXIBmsUp1irHYDnaOOebpDoUljOoMQJC4\n", + "1F7HGo+rflCUkqRTMMlwWf/Qhb8X53ah5nOgfiNyxKX5imqNm0bZn4QuyQgi03llZdiYESKbTxR9\n", + "IUcPv8W/tr8BqJsizZx9qeCTyYVCFZ6JPNcMnUon0PkA/RmzKiJSoECKpjhZg+yujhLsg6eJEEbQ\n", + "ypFkbp2izh5FeTxu28IzcKBrp/MeS7zsJIVeEBGRihEjRowYMWLEuGLEF6kYMWLEiBEjRowrxktL\n", + "7fVtKhmZFqdQjE0dQfZA9C82puKr5PE8M7j/fBXg7gWpKB/vB2XpggjtCXSGHIiNCUG2RaFK5ETi\n", + "g2lukhqxsURqifwRpQVk2VIKTM2FW9JgatXw1is8aXBuDqJmTrCnItwpexHjkmVEwFUSMYuvqrKz\n", + "Jx2dehvaMp+F82l6Sjv1AU5mjZdMoVrW7HB6nQyydsniT35NHK5tSnhzBkIfE5p9BrIvdJcGUsxN\n", + "kYrylJ9TpXpPxF7XqmYKQct5SKMVpKK+cYHEyxkrlypRH1pIhemFDP4ysTFNlDC7pu+Ff5PUSPR5\n", + "FvZTkOFxgzxLwUrx6JMMcHrRmxJzAvK4I9Xp2QypBdICSjH+2Aw1LzQ9QaRY5E8aMma+ffuWiIg8\n", + "g5HtrmYQUiGUitEUGGtLKRmdCegV0uYNpcU0fcipcj2ejjvVZAongetJJHavJGIa6/2YbrB+yjrV\n", + "4iHNml5TcBZqvrtE8cJ0aiT+Fn2XEhF1W0OzqKO5A6bSAx0rhQL6lojVzQUI6KQ35s/D3MVGvprd\n", + "zq+hDynd3GO/w7nNicU8pPnO3v3GuO3wOIy/+ralhS8eBCPl+b7Nia2/XDygqT1NleU0J+j0VFG6\n", + "VYn3XNijiuYpFQ+0UOwe2MkWYysjB4oeWlUe6/w1zQmTSbg+R/7WuO1RE/pweWFp7DJHX9Mc22Ou\n", + "6T2natF2SuOoHFOqNAZ2p9DUUmLFLkoV4cKaEvNTQlqBbtD72c613ipVwNqk7hpaCOAc0yjwDKH5\n", + "T9NtPHcOGLM9p6fUtF5Ib8lDg5HU+1W1vO9IKb/9E9eONBN1LvbOKBhpEtJnrCOoZsVcbJAgBZfT\n", + "w2vAeW/ofqpVNR1uA6w7plQZdnZIExSWsEF9EYp9ytRSe5oXTKlQR+eJ2lNRTvbDX5UiIhUjRowY\n", + "MWLEiHHFeGmI1LK5kFlpK6OhhxIqEcYHrHDKglYrgBNyQrPm07AiO1+Tsi+8k3r2zhvCKmoK1KHt\n", + "bFWhC7IdxdZUFcNNRV1AImcCeN1iVcOq4J2WBNubrqfVkcguEbvAiTNhcTqSk4lsDRJxRitI3e8O\n", + "AV1JwcQYdKkSm8P+JhNbVSiJkrnETgmAhJIlTv2iqPwfq548J1I6muJJAVmlC1hNYKixigQ53hGx\n", + "VMt5p5M5/SCskq4dkIRCq8raNk5KKCCzd6F34XxXWyalhr5osQqZlIf2fW0nLQg9ToxXP6Nic0rs\n", + "SFXJoH5SiY2eIDH1Eeuw4iu8oTXNJiAd6YS/r0rI1ok1EFb2euyUlEpK7Ur2Z0+uZ8+fo22QFSGv\n", + "RSXZtoTSViAPs4r1wUG4n9iTr4E/JKNPWjOf53xPQO1+REGoXBmoLssKrFG6zwTgCcrq11TWr/dx\n", + "RitJbd90xvMJ2gH5hZrQZy3XrwnpWp4G5G5+QnIB6PeOEPGigAL/0uaODB5uKakor6Aof/3VT9m2\n", + "p98L5zUHqrNvKKmqjSeE9LUo4Z8R0nTxLGybElG9h+zIxamttFUyZMdrD9cieSHDFkURrE6N884c\n", + "9WuvKtY2dnRuK3NSRYdMyIKuXYKiiR7ISUFzvToKdBckq7Je4hxs7lbFckbOtdR+IDQlxZxVTmxM\n", + "Kr6ghOac9tGrJA0zu90av7L+coPO5zzWw7mqv6CIyIC/HfnPLZdQ1C+B1uQ81yMjQKh2gSKngSYq\n", + "9aekW13S0bvQ5unNJtwTkwl54mGe6shRQOVu1MOvJKRpgr5jBXgBItRS6qZtkLkh9E0LtDyhT5qd\n", + "qUj+QB0/GmRV2MVhQNv4+acergUVlOXITtHtLFN4kraJzVM636WelPLziEjFiBEjRowYMWL8WCK+\n", + "SMWIESNGjBgxYlwxXlpqb1Ofy7owLRQlZzOJtAUpLU0NxlOSORs/7k9DOmbbWFpiC6JkQrBwg1RR\n", + "rurdHcOu4V82VOwU2ssJdlQCeEkGlfo+WrNBI9qesRgHzhHYImf6FPZkddwSmjop5dtUlblhaafR\n", + "LJgNgqFOTCQ+TT12mk7qLRXTAVpOmfQ6QsV2XhOQcXtSFt6HLsfQmgaXBwbOCLiy5xNKNyaq7YI2\n", + "CRHGM02jpoZPz+bhWJzu09TWTlpSFO4mZW9o22wXZ+O2EiTLHMfqyXg2LwPs25BmzAZpVobW9Tr6\n", + "wcbfegh9kc8NMk9HUialUaB3UysRlwxK97Lw282KtM1SjH8yKO2R5mHdp1wrFXbcPcNvKoK7Ly5C\n", + "6ulgP9wT5+d2LNWCYsJmiVRhy6rDSDcdHlpa9DEMkq9fNxNkTR+yFpWm3saUJRGRVVHf03jRlCGr\n", + "qGvxAhNQlQy/XLIq+WW9m65RXST0P+dxcT95Ni3GWNsuTYl8bxr6rqHUpuruFKSjNSrQ05RQNeE3\n", + "Tx58OG47xJhoNyjiWFnaIUVBS0aUhQukSpOBJhTMnVnPhRLoMzJyVfIwFw9oSm8kMbPCM65FQfOa\n", + "qoh7KmzQQgnW9tHCDt6faktV5J6gV9FB26iaUnoGbgtcAKGmtW1r/X+GvpsURgHQdPQgZBANY+6U\n", + "0meqZF5Cn4xuNfGagqZUnKaeuWAg16KA3rY1DbTy6DnRjel+ooWgoKFQXbyU5kscIyPT+AwE9J7m\n", + "/xKpr5wm4ARz4bKzOc4lSD2T3lONtNhqTYVCOO9MNeOIsuETnaetnWvo862WVGzQqrOGjbUS6euB\n", + "rqfSJ9i/3oyJQzu4ACDR8yctLIfn6IRSdlrI5mibG+DKUJG2l+xqy4mIJNmL0twWEZGKESNGjBgx\n", + "YsS4Yrw8+YOukw15TuUgpfqUa9PhtdXYKjnLAhIxNEQUx+rgeGa+WuebB+E4BPto2eUGyInv7C28\n", + "R+kq+0oNWpLfGdKgStRMtnYgG1a5bdt0WH0QYU2RKEXaGC1TwiADQl5Xn6yOjDLQhkh8Wv7NKyIt\n", + "Sa9p9Vf83+y9S68mWZYldI697Xveh1/3cI/IzMjMyqKq6C41AnqMEEJixJAZ/4ARo57xC3rCHCQm\n", + "/AQmzAC1oFvd0NQjs/IZERn+vM/vZW8zBntt2+umu7LQRSUX0tlSyG/Y9332OHbOMTtrrb022q6H\n", + "EL9zdm4taidlj65Lr5kF61qnkKwTsOpeUQ2rtoHYl1b4bYWVS8S2F/JvhGtlIWAPYftQGfp1dYl6\n", + "WYWtNFf4e1eZ27GiKFlkKEkEF/V1YdsegGYUuIaehOhpJu3kySaiw3V1NTm2T9IXi4X1P+/lt8ej\n", + "iY3LEit3as8JF1xCvJkO5KIP9/Zpadsy1HyaCNXRldNIx3K4j2NE4wli3yUhUkek/SsSxOJsRXAS\n", + "quEWqYv1wpC2w0H2cXbG9QexqqdyA9r/GTnU72n9LUbL9LpqFiJjRawu5c5ZX18tKSnhDz5zzq5b\n", + "x5BzzrVItVekbaKaWjWE7+uckK5ckIaEhK0HOKCvqK5gV+8ena9zzvW4J+29oVnqij68/rkd98ci\n", + "PPdHue5lave1PZd271/b/LdGu78jlHCFPnMglOzsTMbObk/O+ppkQ6v0dE67/9hWZK6nRwkAbpI5\n", + "s8jJFR6MwETJI4kKhB+lqeMEeJ7G8UuM/+/vbVx/u3/tnHPu1Fl1hGi2FSDBMJ4P3WDos1ohxGx1\n", + "kOh4IoYBSFSpVig0KaE4hPOUgOOBPvG1jqOKyAkRUQG+s+fJiP428m9Rd28AWupSQv/QxzIap7P/\n", + "eUK1a7WuHKG5E+5jRkzMvgYim1p7am7J2JMA3WEcKUpHsOqE5KV+JIajUZRw3jSPf3ZM10SdBde4\n", + "TaQtCEx1OWrmjRNYhZ7tD+TfKOKEAbXpsWvQ5+SSqiJojkVT0buA17qvtrcsC2LzECFChAgRIkSI\n", + "f5AIL1IhQoQIESJEiBBPjM9H7bnONY35PnWpwG1jb/BkCnFYSxSYioHjhL01BArMiQJbTELftCRA\n", + "HyHyvduJEFb9KpxzLgF8X5CLbAxh+0D03DgqBWLXMhcIJm8ddZRuCcaMMwha8bWUiux6wJ4J+WP0\n", + "8Ptg19UWQsGeKDsPeLwjH4+hg3id/GHU0VZdrx/5eWhBZWpXpXamR9Te9NG56/5aLoaLc6+JAokA\n", + "h3vCdgdAsCOg9dET7eC08LO1a6kC/E84MRfkCt6Bvi2JKiomoQCH2M6phNi8aaUvsrC5R/uoJ4xz\n", + "zp1qFYUTPQD/qGgiZ1+0z+7wYd42dkI9JSmJLdHH4km9UKxjbdfSh2MWRwJifyTiRzuV5I8Ue6UR\n", + "yW9mIWPrdDSqTCk9Fe+yiFfpUabbtF8PRHds4em133OBYDkXvk/696fE5nzcP/x+RX42KmhnHykt\n", + "8sp7UKH8pwo0O6IRlitpExVbFzSwU6hdmbJZreX7Dc0rutu+Yx8t9P8Ho5Y0UWS9vbDv3chcFJHb\n", + "dLd7L8dSEfutCdHjG1C2P3g5bzu+Ebpre/Vi3vbw+hs5T/KgG+DAXtVUgSFTXzDyQFNvr9lcjwq6\n", + "wjOK3eGX8Eo6kdxAfX48+ShFmjREZoETkiGYKoqRDKI04rOV+WhdI6Hj3Z314aYXWqqh+W+BRI3j\n", + "YPKREZxVQi7emgwQkXg/g/A8AgUY0ZzcAXuIqRh5rFRUY/ud6zMTVazFiidyQB/xbOnJb8vhukfQ\n", + "V1yMu9BKCER7deptl7I4HIk9lJSlonjKU3JjBwlKz+MeruhslYWPE52KqK09ntNVbW2tw6M6kSwF\n", + "gnr2hRtnHzmq3rBa4Xv0LICQfLXEvSEJxBG+WzyHRJhHo97uU4R7Nw3W19V7bKTxp/eEn+dTwrTh\n", + "xxEQqRAhQoQIESJEiCfGZ0OkpmFybWSrpWYQQWXe2upjXq1HJiI9nLBaKwy5mvDGHlFdpyKVFXFL\n", + "K7K+fezs3VIa+kKdYCcWQstqbexM2BxNuiK39/oZkSLH2BSrrqHld1W8McdaG4/S4NWVl5248bau\n", + "Kxk5J/n7UV0lqPL4nCYsJwZaaeghigwOu5RCOgKl6agOXgyB30Arg67X1RqtKnoVoJuIu2nEWZhT\n", + "/bWuGQGBrgXadAQiEFMadAShIJtjnyAizckVfxbF0srx7g7i+cT2lzogQpOtZhOIQU+t9BfP7rij\n", + "toWtYGqsyAdSUWalXFDLTvle24kEm0h/zjNCmBRNRSJAQuhPB5fxaTKkyQE5aHpe1UKUTkJ9r+nP\n", + "JPZu4J4+EcKpyJEhOLQy/oPvOGfITfzIWR92HoSSliVSjQnNUIH4o1qL+M0Kq1C2P9Dj3nirK6eO\n", + "8vp9PndGE/X8FksSwOOeFIRcj738ZgP7B7aQUCA2pWs9AM1LEk6/fvyv7Bh2Dh3NP/dvnHPOnRaG\n", + "SJ3j3O+9jZ09UKwV7DcSQtWGUdCX6GT3td6JeH1BVSFqpP9fPbNjvX/9FtdobZxnisgwSgA0G/eO\n", + "74kiR0Nn51THco1Jbn19itV+hFolU4SP7Bd0TqY+EWHuUkuEs7W1/8+Q0JNEZCsySA3NujaGowVK\n", + "Gw02/jMItcfexn+GOp5JwnYethfnTBAux5Vr4LE+jHDbJ6RrUBR1JJuASQXTdD8HxofwEyCgZvtD\n", + "KDnGPddkdZhjGdVLUOtzJJx2RKp/ElOty1H6ST+yeBtWA3TuWaG2C/7Rv86Z7UjdGPp6OqBSQM1J\n", + "CVo9g6wusJuusXNK1jK2Pbnyt0BTtQ1zSmxQe5qWkkjUidwT+qVAYE/zudqdjFR/Ua1teur3LfWZ\n", + "T0VApEKECBEiRIgQIZ4Y4UUqRIgQIUKECBHiifHZqL1oStxITqQVHIOLyCC2BNj67NLsnEsBCx4b\n", + "85bKIMb1JBhLAAuvqOCxUhuzFQoJsRPAmOyiPqqIz5GhBCi1iWDUVl3UqfBipi7WBI/2cPFWgSVT\n", + "kWpAzaJHN+i5sD+JnMswshAPkHFPIu5BKUiCZ3XfEBguC6NHRgilKxbnKmUUEfyMP8uU+DZQiyMZ\n", + "f2TwGTrtSewPF+Fo5EK6cs4NLjEnx2R1Ox9JbP3ug4ho1wsT23ZIQOhJRFg36uNkcLNSGh35gqmp\n", + "yQQvHKZCFRUfHtFo+Ju8cNQ9PopYgKn0CLlNq/N0RwU/0U4pKDPPxYiRqUAa8tm9mKmYCH29dsTt\n", + "oTDrRN+L4QDMVJ1SZVrwd722PqG0HBe0Ved/LsaqBVJZRJ7ChGXJAnhQZEzjqNhc/aSKwr6v7uVM\n", + "Iy61vYieUzH8OLDYV9p6Q9eT6CAjClJ/q0JVdtgevdJYJMSGKLhvmdqV6z4eiNpFn0moTfaD9LvD\n", + "b/6PeZt/9hWu1fr41gstXYOW3VAVAdUzrz5YEoPSkt3JxP6brVDfd/fmD/Ty65/JtncmXu9xb9kp\n", + "Xp2ltZniRyUDkDDCczL6QkJeO/FM31ACTkPtqNt6Fa9Tv4eLtUf7TyRE1oLHJfXrDeYx9pZ78yDt\n", + "M3JCEejzvCQaCXN2TxUNOsyBOhdnREWpO/04sgQD0gZKVJpQtHeg+X/Qou2k1FcajZNsZtE42r2n\n", + "fr2Ay/uxtuefFv71NCd1uE8ZeRs6PAvYbynLpE2mk427CvKJgtzeF+ifC/jdJXRPdMrqaV6b0BbD\n", + "xNQeKEi61iIX6nlB59kgaSEvjJYuMZ/sj5Kc4emZpDTfyNIGr8W4yQMO1UMmenZOqT7jOFUFtDA9\n", + "Tz09Az4VAZEKESJEiBAhQoR4Ynw2RCqOIxcYpJVtAAAgAElEQVQ5cqLFS2JHKZx9Km/1Kb1pqwNx\n", + "dbJUSx/LSmyiNPUFVt+eVphFj+NhZdpRym+sIm968ZzTdUlYWtfqNs5IE5AWEht6L6vPslzT9+DA\n", + "fSfXVcfs2Axh6cCICATLsb2tqzi3obf/VN+q6e1bNbN9SysyoGQjBOOeUnhTOMYeBxNsejg783XV\n", + "Xto6p3RQraE00spV60pxqmunteho9af17xTp4NWarla9NwRDV2JVbavvCKuJurX27HpxQ357+2be\n", + "toTz+Imc8rMCAsxO25rgH5wMC+ZVu80r0g3EsIM3RGICchHT/pCT4HJCHVV4Wqmth7d7kkGIzKnG\n", + "usI8VYT0YaUX0Tixc7b7rwL4aeJ+om2sSBd9BgSPESn9XFEQ56yu3mZjgmn9PKPxpwJQrutWFHDF\n", + "BjLELura17dbS0BRJIoRFP0tIyd1rX2MBbiP0S/5W46vqDKnmsdY/Q+NTQo5LBEqQlqrWu573Fs/\n", + "vb+WygprEsWfnX3hnHPuWNn33l4LcvInP/5y3nYAYppAvHtLCFLxDG1M1/rwQY51cWkr+LGW+WS5\n", + "sLE2YHIryBV+Rgfpvqt1Q6djkp3IgRbFj1ANuRc1JfY4uHcnZA/tMSfHZDGRlTI+IkK4FLlqMZ7v\n", + "BusvByCBntBfRanOCP08tNL/DjROEngGxNTH1DInJQF4W4l4v0XbeJrr+knr6tl19bjWuiU2BddY\n", + "k9VEW2tNOhqT+LvlMaYO+Uh2aQkNaTHvnEhYXSBh4DH4LclbMbEeamcRE36yiGROHJ3Np1oNI6Ua\n", + "q8oEKUiV55/oL/Ss0XHUkYdCguO3hAht1GqCIJ2+kf/JCaWKYVPRtsJIcK3BHNlIbUO1cyGsPxwa\n", + "+p78Wyy5Tq4ijARnuY+ZMEaxPhUBkQoRIkSIECFChHhihBepECFChAgRIkSIJ8Zno/a89y4i744B\n", + "BQ+rwSDGfBR4uhtT/qFzzrmYKItTL79ZJAbtnho4O5Mv0wixXRqvsA8WwgHGrlkwB2qHoe1YCymT\n", + "rwSEjx0VvNUCtTHDgxCPn18I7Hx7b/uoG/jTxESFJCrsM4izhGdR9cixWNouInhyHNQfJvtom0cx\n", + "5mkiGgki7yQ2KrLqBOLOiB7p8LdRJ85tCjluVVHR0l6/R/cYSnUVZ8tJ4H7O4mWmLOX80pgKZKJA\n", + "9fFkhUyLXKgfdgeuGhHZnpp3tm0SGqUbjRYexhWOIfBwEn88JLwnfzBQASysVBfnR4LFVvqkJxfj\n", + "GALMiHx08l767MwoEWWh1Bqf0sNeruGRZxqg7YG2ObRnRYh0UUDs6li8Ksc/wpWYPYaWKALMVNjx\n", + "KNd1e2siZvWMUj8n/puLFitVy7Sc/tYE8B/TcyyO1++zsF1pybK07ymNqKJz55yLIMC9u7O+8/y5\n", + "0G0qaFc3feeci3WuSVmIDQH6wDS+XNft69/N25T6ePvtr+dtV1/8COdux3j51TPnnHP390Y3X17I\n", + "tm/e/l5+RwWiT3t4FpGIebmW/v9wY8WQGwjUyUTcnR4wnoluy+EPFD2im0ABq2fWxHIDUCFEt+3g\n", + "aF8sbD7JU5wz7TfJ1EeIKBh07oETfzDfqtb32dpo5DiVPnFfWXudGpn/Puzsvja99GefcwUIOe6q\n", + "OLfrcZpkYA212sh92j2IZ+HtNUkwcrl3xZIKOSNB5Uie4eOo86l9rwa1Og3Wd7UwMTF1c6WIwctx\n", + "mW4/VJAP0DOxBqXsiZZWoX5FSVnpTJWR2/cASQkXIdb5iSpaaMWNCRQoe9Z16nY/Wr/SwvTef3xO\n", + "3NdOuJ6ifDZvy/XzntrJ6bPgEvviAu1yT1JKdmgrUIudzYke895APlI5+kdCc9ycIDLG9D0bg5+K\n", + "gEiFCBEiRIgQIUI8MT6f/YFzzsW2MkvxVtkP9qZZ1bIizmJO11afAEJaFP2gFUEKG4XEsYvr47pe\n", + "MR0/GtSuwPZR4VTSFaf6ApGiumpdp6JMsh9AqmtcEHKhbs9OVljr8ov5s/d3IopuOl5BPJdriAyl\n", + "G1K0SWpv1YcTxK60cBydigNJPFzJCifdyoqMndh7rMwY1dvtdzhfW5HFEFseJkN1nIryyYG7PUGA\n", + "2NGKJIMont7fta6VOtyyJUai+6OV1kKdvwk5cah151hE3cvxm8HsD9qDtCMjPInXFTlQleRjIfij\n", + "wmKwFYgpJTpC29GixjUQlE+MHEK8OZDFxziv3IB0cQ1FrJy4htlqI4LipCB3dKzmq5Mda3884vtX\n", + "87YU6eHqxO+cczcPWLkjKaDI7R6qyPsDpdorwrpYrGib7G+zNrFzDURkpHunDtFZZivizUb6ojqK\n", + "lyXZDyhKsbLVoDq1M0qmx2f0S4XnLGzW4mEJib0HrL5v3r/HuVFduRo1HAlpOe2kD5UZ2Z8gUSAr\n", + "bZl+/UbQkTU5QB+uxYG7vLCaeAe9T5Rq/nCS8yvUQuXycv4suhYk8Hi0eTLLZTUfE9I0oS/c3dn3\n", + "FNmrCBEtcC9KajtNBlBUbyC3d62NFpeUVo8mjnhdrmh6QvMv7klE1QZm13SyLpnnZ9w7AnXdCv3+\n", + "bGXI+fpujc9s7rzeS9IMC8U95k5HKNFqKeL9ZWb9uchknLw8E7uI6gub/373/c+dc4/F2TOCl1q/\n", + "ejhKf4qpKGaqtVvZKR4Iu6M2Hmpp4/xMvt9TEoOOJ0b1Na0/peeZx3Onb4kl8Vq7j5z9Md9OhHDN\n", + "iQQxnRN+O+K3NUHdKjKvCVZTVCclm4qZ4SH0sW3grF5S9RAn80hDFg/tqFUZ9BnKbv9y3CSlyh5I\n", + "PGvJwqBXJLCx/qfC94SE9VGhc7KNiSSy8/tUBEQqRIgQIUKECBHiifHZEKk8Kea3TOecm9RMkzQN\n", + "DeoZVb2tqmZpREwaBaAkTWv765CKzvXsIiBSKxh99cTBRkgXZ6M95c+rPR1rJW+pZW6rxAELFkbO\n", + "lCPvqZ7dYi2fp15WUHlsXP3ZVlap37/5BR0e10N5rRGMyLKMVhUHGCJ6Wn3BCiEnfYd3sF1AvcLM\n", + "26pO9VicBq2oy6P6e7FWC7cV5O4oq+Q0tm0VahNNxDMPSGuNS1ulRYlcT+wF/VhSDT3X6eqLdEOw\n", + "UJi8oS9qphmT1UKBWow7qnUYaZ+J2MwU5xnJvRnJQkPLxKWFHb9GzaeypLZWqwOCrjxQyo70ECl0\n", + "aC2tMCMHRAhWEyWhCoutIJKb2GwFTkB6VrQiVwPBjvru+YX0zzgx5CBBWvXD3lbTqivS2nGbjVkN\n", + "HI+EOup1oVHOz88/+oz1ZaqRYo1eDPPDPCczUays2XRTQxGxN2/2tBVaNkKa1CahpfGv55LQfmOg\n", + "jVfPTI/hsZ8SNfmayuYaD33laW+oZgadxZt339t5vpCxu78hk0y1GCCNyIRVb0soweVzucfvX9v+\n", + "FkCJNmoEzNojoNoPDzbW3nwPLdUzm5POzqR/7Mk4URHxlKb9CPf9WFH9OeiFRiAnMc0JM0r4SCOG\n", + "zwgRUdQlydgQUzV6hCbjb09rerVC0fNgBEd1c5zCX2DM5Nz/gGw2LWk0gVKf9tavzzbS/uul9YnL\n", + "i1fOOWMf7h9MexVDv/X65lfztg7Pp35kVAVaNmY9MqAqLev2Fvgt1TpErb0emtM0Z7sO7dekB0Rb\n", + "NB1ZAmEu6Oj5N0DXlpKdjZvblrSRhdZOpfp7QJN1hJH3qGs6GH1STVhFczyzJEC/WIeZ4Rh3+/fz\n", + "tjJRJoCskIAc5dAID9PHliz8TqDm2FnBNj0tfmv77WBdMtDcvU2EKVqUXM/3j78qBUQqRIgQIUKE\n", + "CBHiiRFepEKECBEiRIgQIZ4Yn8/Z3OUuoVR3FbMNk8HebhCosiLH0igV+K4juFf5Pq7/pLXWusYg\n", + "63Um8G2J1NwoNyFkDRpj35vArQEUWZAlwABX8CW5A2cbgTGblty2QSN0BC33oKrWqINVkOjSDQLf\n", + "P7/88bzp7iAurhPXdQJknJI7dgrX14isHhKI/GbKzrn5bt/fvHbOOXeR/8n8kQoFi5LSgBdCrRwq\n", + "a2utUxdRTbwBdFfLObyAWwcSm7tJa6IRtYfriJxCwWQ1AUHxNFGqK+jJcSL7CdhZRIQjPzv/M+ec\n", + "cw8ng4y7XijIkWDsvkNKbCzX1VBbl6AHB0eQOYTiTFk50IcT1ZWKQRWfiMZzo5wzOysvMqHtFEYv\n", + "PIt+5d96MMpqvZFrbclqQ8XBnq4/VXqG6E431wS0a1yv5RqVTmDaSYOtLn76U+kzTMUp3VBXdp4X\n", + "Fxc4N7vXmv5cUq0zpc9ZKK4xU0wkjtZzZ2pP6aaG6kROqdoUEGUBupGz+dNEqRLpawOJkxskcUyd\n", + "OdbvjjI/jK31id01zm/g/o++SyJyn6gol2xPIDbnlPDFSmibBhYTOc0hWpO0JEuIBFUEWBR+AmVR\n", + "kASgQL87EY2Xwkm/o7HboRZar21Hcgttd+5rWuOQHfPVHqKnc1LbDU8UjDpxeEqy+EOqdiQax892\n", + "BXZdS03iofPUpKGetmUgpu73Np88azXJgZMsZExebOV5saRkh3aQ+788WH+9xfjLqV7iZiV077G2\n", + "+SfFGE+JluuVxeL6o0hkUnkG06gZRP48T2R4ni1S228NEfdA86TWCeQKAPoXS0WUSvSUFDOgekWP\n", + "e8EVADSxqaDr71CAryBa8gDx+ETzf4/6rAON8VgTFSZKPJnbALYm/Px3Wi+VaXRQwKQY0N9Mj54/\n", + "mLu9PbuPlSR+5Zk995Mk2B+ECBEiRIgQIUL8g8RnQ6SWceFaesu7Q220jkwV51Ui1UbLR3lLnLiw\n", + "kC6EeKUDsRmVn5tNzFT0u1o9nz9KkfZ/VxP60aJeES9hOxhtOl4RweCTjOY61EmaKJ3/BoZ5m4WI\n", + "2aLYUm4VVZtIsJfAVqBPyawO+0sy22+MN/GSVxW4tSkBQmpIGGPF83BrAtfzCxEPj7mtjM5Xmhps\n", + "+73ef4/TtRXRAJsAruodebRJyu/qmkJrW9pGTnBZyvfYmE8FqJry6pxzmRpNHk0AvFk+x36tO1+s\n", + "5Hrai39v3vard/+T7HdiATxQGpy7JyGmApwpWUKMlSARbWXHTyEYHXoyGgT60lGdPi3k2JFSc1cJ\n", + "6rByso+O6nWtIJQcqMFUqH5/ZyjJOYTFI1cr13MjO4cjkKVXr17Z/kZdzcn3GNVR+4vnzy1d3wH1\n", + "ZEM+RSdevfpq3qbC1uETNarKglb4WqdrVESUqsAjyWG5tO8rYsm1sXogAquljSetk8Y2CYrc8W8T\n", + "IKIJjn9zZ4Lxdn/tnHMup1Tz9iD3f6D6Z1onLiOksQXSwfUPFcQ9OzNReHWSe1IQwjYAgSqvpA+f\n", + "yMLAAznU+pbOGfrpKIVbDQY9Hb9F//N08xT9OlDtSg+YRFHPhpJNFJFarm21nkMcnxAikaGGYk0J\n", + "ABmSYXJCTtTgtG0I9UXnVZuMlOwyGswJe0KOs8WAYxJqcCPHOpBxpxqRpmS++eHDL51zzr26+Np+\n", + "i+fE5bns78XWkj3aVsbru/1v520R8l44AUdRlSyxdho79ElChNSKJCNRetvATgHn2XlDlXIgiPFg\n", + "ba39KotpXKE+aUMG16mHmS2ZVMZ4xjAinMGkkgXd0wk2CRBs91QTNkKiDgvgPVD/jGxiPI5xR/Vc\n", + "R7ANBfUJjwQlKnE5z3vdAUgXPTqVnWHz3arV2qV2rWq705DYvVyCCSE2J4bYfQ9GyDnn0i3ZfXwi\n", + "AiIVIkSIECFChAjxxAgvUiFChAgRIkSIEE+Mz1hrb3SkDXPjqJC94XntJPRFmhg8PELYnJI/jjpL\n", + "R+Qsbp5BBrcWpXyeZQIjbgmyVcFsfkfuwIDs29E8i1a5eIV05E+k3hYl+U4MJzl+TNTKAGrl92+/\n", + "dc4598WVwaMFsMqIIN6uU2E9u/6CgiIvpAU8U3KiShP15+nstzWE2kqLHsgfZw16iL2oVIhaLK2t\n", + "FWI9DVZrbaYPPEHb8Cxy5KM19Oqsa21cV6Ab4A69LK1LenjgsD+UwrfDZJD1rhbx/OXmp/O2AnWX\n", + "LrdGY13v/tQ559z7/V/beUaPKa1FQWsLQNspUYsFPJ1aEtHG+HyivhvB0Tqi+1/VgMfJbX2De6b1\n", + "xc5X5g7eAk7PyR1/B2ftojAo/N17qSd4fm79uULtvKm1MfHsxZe4VuvPKWhpFV0eDkYjKI3DItoE\n", + "YmwWoCv1xsJu/S2L0nlsa+hxleJLs+Gj7+SUFKICdPZ702PsHozGUUF7T9RSg/Nrib7U3AYdE2sS\n", + "wr95K9fYU20uBwpwJMdyHX+nnsTGW2nXU2WU1QThfX2w+6/0fUqygHk+Q3utlnavb3ciD2jJxV6p\n", + "3QP5gxWg1lqiZ85Wck5Na9v2B5ljM5pPlV5X3y8W8ep97SmJIEZiS04u1h7SB3aqn/2QEkqeAUU5\n", + "kdv4TPdBYNy2LBmQ77XkI/cA8X49MQUOCoru3R5U9Zrq5D0goeDtrc0JF/AZ2+0l2eZyY2PyFeol\n", + "vrk3WcQHzOc9+SJqVYRHTvmgDB9JRYBlJJRsEClFqdc40hx+lP1uiMYce60rae1fgm7riFpvIOye\n", + "qLKB+m1xAYAY1RscSSBUetKjrXtKgMigH+F6dF6TLEiqolUsYpKFHDpIRRIWisNbkGQW6gep35tI\n", + "szN3cWpXlQA0jzwQ0RfZ2w2eUp7uk9YAjkcbT/f7v3V/LAIiFSJEiBAhQoQI8cT4bIiUc/1ct8k5\n", + "q8NFjghugPB8pDf9NEP6ubM3bY+370c10Zw667LaWt4wM9RV4lT/CMhAuTRUqTqKAH4isd/gZAXT\n", + "teYA3dRyrHzBLsqywvO0Ste09/f3gqB0ZPWwQoXz3FNaM+wR+s7EpgOqmke00j9HqrlrGaVDSvKj\n", + "quoQEaJtWko5PaAy/MurH83bRqzwFrkp+zRNtmsp1RXfi3gBo3YW5KysYvCBROFznTisvnNSx8e6\n", + "SiPBYAJlZ9PbivT+IALh5xc/o2tVEaW15+Xqz51zzu1rExRXSGQYNTmA2msWW07sDr/Bv4YqzJ/7\n", + "j5MdltTH1kB/BtOJz7UgFekcyEIghZ1CTJYQmq7P6epffiWWGR+uDSXMkTSwvbDV9AkWH1FGtaaO\n", + "SLWOPk4hTtBfl4SIqF3Fbkdu30D/Nhtzdu4hxuY0+fVaxsye0s/X6PeKZrEQXIXivKrU/ndo6o++\n", + "x8P/AejU5TkhfLMA3a7//l76vW/kpqj7u3POba/kt/sbS2FXQTlbGJxquWfnz6x2ZgNhe8Ju/7Og\n", + "mqxDUFu0L2xMrEsRmV+/l8+WW3ORXyBNP3NkiVCh1ibNCYoqLZd2T04Huf6InOU9EIOps3bPgdhr\n", + "V9iSYF+tS8qFoQ96TiPbXatAn1zRByAGjDDrPFYuCaWax538E9McrnPNlqxj1qg8sUhfz9u2QElb\n", + "QmkaFSxzQhNE4b/+xipKbFFRYL2BsJsE+x6C/u3KEjCWC2nju5vv5m1xCrE1oe8F2nUgOwO1CtdE\n", + "COfMnmAC+paxJcdezr3PqIZni8/JamMd6ZxNiUJ4jk2UlDBgHllR8oA+Fvi508OCZU58oXGaw4qh\n", + "Ohn6ul5KQoX3LNKWHV9s7BmzwNx5qAzh6wediwj11MQfjP/FkpNIgD5SAogiVj2xOSo2VxsO59wM\n", + "JRWE0nkwKwm3e8vVFT6OgEiFCBEiRIgQIUI8McKLVIgQIUKECBEixBPjs1F71Ti5iURnmVN42CDO\n", + "HqI3hlb7DsUTiZYa+o89Y/TPnqi1/QG+UF+C4qJ9LDKhHdYk9r3vBKrNSID9UIu3zJZE0ff3AhVe\n", + "RFd2PaAAmonEphAbKnJ9/fDr+bNoElF0lxiNZr5PdizVzp6fWZHNJBUYtTsSjdbI34fejl9hf0r7\n", + "LLitsePjiQS7cN3mpIActGg7GLTsIGL03ui+AdQDU7BxArqDPGD6PsMxVAhMlM1CYHFPUOx8LkQB\n", + "13Cj35FnzLoQmiVjv61IrvvF9h/P23739l/JeYCy7XsSIrcC2Y8xiUhBiw49CSvhmO2ouHKEv3Py\n", + "RUomFI2NjW4Za2mLFM7Gm40Jxh0g7o7Mxj1oue3a9tHgnAdy7E1T+fxwMgqqWGHbziD75Vb6+y1c\n", + "tNlj69WX4gvFLuL390J3Z+TFo4Lx49E4SxV7K03knHMlBPJv781HpkSFAIXbDwfrV2dn0hYPD0Yj\n", + "qrC7JyrkBJqBz1OTPFhYH4FaaNob218hxz+ijd+/M9p3rtk62f0f4MGzurDx10D4XZHfnQNFP7GP\n", + "DuaCBbmS7x+EMhgru56HVtr46koopsPJOkADevbZmUkLTqD2TkQ3qmxie2Zt0mmVgUfecvo/Nsa0\n", + "WHWHOaEiwXxZfuxs7kDLlzR3asWAnHzk5mORA/yIk4liGyceFM087REVp4W5PXkxrUApr87MFzC5\n", + "EX+okc5zgM8TF0F3mNsnb/f4F7/5N8455y4u0f9pH+el9MkNjeGilL9retY8BwUVl+TtpN5fPc1/\n", + "mgzCam/4KMUqT/F2r6tS7vXt3mj8dSHz/5JF7KDbtgX1v17+PpAoP8o+duxepHKNPRk56bw4Vuoj\n", + "Z/erw/joKAFA+9hm8/W8SannlKQFmf+BfEbJDsdK5ocDFRBXXz6d97kChlY+6Fp21sdnAyUxYEyk\n", + "Obuyqy+WXatKGnp68KXJH8ecAiIVIkSIECFChAjxxPhsiNSpHh/ZBRRwj26drWq1vs5IK0IVHrcN\n", + "r3TwPUoTTSFQ9FRXTe0Ujr2gSlltK0OUC3LLJaVaV0BLaFXbA/06kLN2hPfRQ2Vv2ioyVgQNJyj7\n", + "w7+exMldK8cgvbZrRhXg2pvxxeYnzjnnnl+9tC9CvP1AKuYjVsc91zACwjOiXtSG0upVCH5/oNpQ\n", + "l7JaOdR2rT1E2eyYrdYVKcFEFRCDiZa/iiwmib39q8h4mjRd1dq6LOHOTIJJFSN7xyid/ObUGCJQ\n", + "tZpYQMgJFIsp1WS8PPuhc865d3d/JfuorA0XTq6fmtDp2iMjF19NP04zW6VGENmmlFab6IqRHHhH\n", + "9IEJyF1dUx22Wq4rm6hPqtUCpfC+/l6Ems+vbEWuSE9Hx6ohLGdEZER6tAqWf/RDs5BYr2Ql3JGF\n", + "RgPH4O3GBNB2D+2cVPi5pOSNvmeX9/kM8FmHY1G6NsThObntK3IW0Yq0quS6rq4MEdb7mHkWYMO6\n", + "gNDUE9A5de+PyMV8PgahH2qXkRH63TjZ3/HINimo60e2Bg4JECeyLlhBFF1Rv5swjmq09UhOzGqn\n", + "caB6eXqvc0oKULF9S9/bvBSEZff2zbxNEdY0I+QK4uUBSBi7s+tfbH+h6GBLIuolENOUE0tiHc8k\n", + "NldHbbbCQVKMhzVKS22jY5fnGnVi57k+UeTsRELxWtqupjkmUwdyEmrfPwgi+JtvJeX9cmvC8qqW\n", + "c1qTJczPXv4j55xzb+++te81gqq8WBnCvMQ573d2PUMjc2tH6M9s7QMrHK41mKutB6XmVxBbn+U0\n", + "nztFBO08tws40DdkKwDLAq6AMWE8ayKMc84NqDwyo2qDtZeK+NlWoHd4/qSGPm9XMj6zyc4pBQNz\n", + "URrqpnVX++6X87Yax1AktK65YgISm2icaE/1NJ7VTmeifqLP4IHsFDKgecyEsD3FpyIgUiFChAgR\n", + "IkSIEE+M8CIVIkSIECFChAjxxPhs1N5D/didWWmPiNxxYxBd9yejm1T315E7bwpBY1ORAB0fx+Qj\n", + "0oIW+gaFKsvCfF9awOiTZ8dWiGjJCbkHLXDaG7S4hc/L/cOOfisCwJhcsU9H8TmJZ82n0R6T+9gJ\n", + "uunU2dug0J9+LV5IZUneTqCZDsef27Eg6KzJFVjtW9KVnJPvCOIu5bg9FVk+gdKrGoM1k1kcSv5Y\n", + "KorkgsvqVeUstEBsQ6LEHBD8CNE5WXe4fhQIPJpy2qb0oG1zcNkdSdj+UIlo+MXyJ/M2pWoigmnP\n", + "FkKR1vAROlYmRN6PAk+XJI5X190iNbGxh2B1HIxGLCKhA7LUWkALWPedbdNunBVCAdQPRsVocVX1\n", + "aZFjybm8fWOeNREg6/3B4P43b6WvrYmCe/5c/KbqgY6Ptnv5SlzPLy6soG4Ouuthx/5U0u5MmSq1\n", + "xh5QRaEePB9D4jvykXr5SmkT+L6QF4zSR3ys+3s5F6Zn9VhMCyrLMD7yllEFqp3T/kFo/kIpSPKs\n", + "c4mMk4zokQwTUEPUgu42y63z3t0IzXPx7AfzthiJBNWtCdojUJpcZaFuVAAr/y7XNtbvboXiYMfy\n", + "S9CDNzd3dp4q6KX55P6tOOCnRGN5FepSRoPexxE+PhkVLR9wTsx2pxDsc9FodZHuiW5JcB/ZF7Db\n", + "oVIFFaH3JNB3zrmcvL1ubmV8HsnbzWHuXhU2125XMj63J+u79U7bnatHYMxMdu6atPSb3/1r55xz\n", + "P3plc8jy+b8rX6fDv7j62jnn3L/z5T+dt/3d638p+4pMgH95Lue0Lo3aez9JP9lH1/O2w0nOc4lC\n", + "vhkJ0VUy4cj36IgEjZbm7kUsbZGQBCMFtffIVx1UYeRZ0K9UGX2zj/E92QdTux6Tdk6SgRqeacfO\n", + "rmvAPrLCJBBlJvPTMicJBMT2XW1JDuP0Pc4dyWZUIHrAfNp2nOyDRCXP0pIEnzFVL/vjhCo3Ki1o\n", + "N3n0j/QdH0VApEKECBEiRIgQIZ4Ynw2R6qvBdQt7481TFfZyqjtSLkd7M5ywghpHe9Pu2wTfp3RN\n", + "OLb62PbXIsXx9lZW68dnhj7oyoyFpSNWi+q06pxzLd7Se3qDP9Wywt4QwtbW8r0FbVvmstq/P/7e\n", + "OedcSSmfDtYI/UB13QpNdTdUQUVvF1tb6SyQknv3YCudb19/I/tjoT5E0V6tCWgFN+tECWk6QbCe\n", + "RHYNHWpXxZ21iTrvcq0pdQBWh3HnTFgb13bf6xau6CrOJtWjCgEnFmcD1fJ0/3OsznpOdccC81Sb\n", + "AH2xkuvYv6cVCYS0l6uv5Xyp/WvYX3CttxTt3xJypSn5iSM0J5JVV5YSwoe0+8EZ6pTDpqDqta6a\n", + "oZQZxLlpbELMHsLvlByjPdqkpL6mScmRNkoAACAASURBVBFnhHRUlay+jy2Jx3Efr56JUJ3T2gek\n", + "tUd0rEKrAhTWd3V16knYre7hvE0dq0caT5pIoUJ1Rp9MbE71L/E9tjrQFWZFVg8ex+qpdp+22Z4E\n", + "2Oo2f2whrKa1Zd/ie5RWXqHGXEaJGk4rFJAAN4Htw/2NOTavzy/xGSG36H8THUPd61XsyqjCEnYa\n", + "VUX11ypUIFjYPRkH2e+eaidu0Lc6sh+YgBgNhOapuFstKSqyZlD7g4RE9NpnJpq7O6DdGQnVG1h9\n", + "xJzqj/YcqI9NsSa0wEKA5skSVgPvrrk6AVAySmbIUSngbGVj5+5uj+sj1gF1JB+5YqOPTUgi+Otf\n", + "/O/zZ+drQVBXnhgBpMt/9cIcu3vYKVRHe07EiZzT1XNLCsm93JPv3vxfdnzMzw3qyo5k1xCjxl5m\n", + "t9W5XD6/bQ19W+F56ghV6jqtQMEiarm3LNNW5PyRxQVsURLcpySzzy420iZJTlVBgPDfnew+vQNK\n", + "W5aE0i0ECR9IAK/O7svM5q79UedOMEeOr0vtjNjCQF3Mra8pm+Cp2sZc4pH6bov9LKh24N/3ohQQ\n", + "qRAhQoQIESJEiCdGeJEKESJEiBAhQoR4Ynw2aq9tJldT8dbFmcCjw0QC9AhQXW/Q/qCnTMKywX3s\n", + "T9MCqu5JAKtFdcdeDvzuzpzFVwulFhnGF1qoG0mIB7qPofi6FVHcy2dGAY2dnGc1sQBXoEoPIXRE\n", + "8HieCSzqyWMjz9TjhNsE7tiJwagqfE3IgX2lHl0kLO4bFapmH12XFp4dBhZiCozak9Buwm/K1K5f\n", + "oeJuNLw5yURYGU3s9yHv7ewe7+Ga3EPsGlOyQd+pOzq5GMOJNy9I7IxLrBsuJCz/sGePOlt3LXm2\n", + "LGU/BWDc5MLg+ZtbOGHXVLR2o6JLO9QRlFlRkAvYiPMkUXSP2zOSsNSDxlDRq1JHzjk3RPDxooSB\n", + "Bv5lLbk9fwXvp4YomCUokLa1+//710IpPyNqYYF+rzQKu6NrIzK1ppSa+jk559xqJTTH48oCoHsf\n", + "ib2xj5QKyTZavSD+aB/aF3sSQi9BDx92JqxXOjAlymhEm+3IFX0Jv6WYlKUPEOifbWS/dUPzCpzC\n", + "B0oOULqdhe0ZkhzY72kFT6fD3rY93Il/04vn1sfu70QWUC6tQ5UoIFsheYVpPI0LKsY8U6Cl9T+l\n", + "Jc7OTBagrvSHk028BcZbRPRhhvud4j51PYmdUXmgJAG4+rMNNCfrfRyon6pqIo2NFktWcp4T+YLp\n", + "cFfK2vUkol7Iby+3lFjyXsbnWNuxUmTWJIUdawNn/9NAReiVKqakCPX50wLW33zzV/NnV/Cd+7M/\n", + "+ffnbX0m39+ujAr6YhLK6riw+adDofU0oULmuNdntSWvjFo0t8H8Q8LqGgJsrnYR+48TNe4bjA+a\n", + "k+JW28SOfzrJ9+Kc59MT9mdtPCfoIFPq/Oyr+bPNGmJ88kXU59P9kdz2MZ7fvrNEmZcX4i3V0bMr\n", + "UXkHib2LQvpxD6/EE1XscHjG8LNDs9JYljBhGyfFqLdczn5/SJSI6blD+RmfjIBIhQgRIkSIECFC\n", + "PDE+X629eud23lCVNRxgM3oz7rGqYHfk61t5q48GEmp7TRcm5ATIztDbikAd0kugEHd7c/j1EVYE\n", + "iX2/HeRtXV3HnXNuGHQFY+iTSvXu94Y0PFtrOjVBF50cN4MQMKIk4gXeuBcLW2nWqLlVNbbS2sGJ\n", + "ebuxc3q4l22nR26v8ta9opqALVZ4BWot9XT7kxQu7pSGvNvL23/TUL1ArOA6QuQ83vAbetNPBjmn\n", + "wtmKUN179Y3fOediiAI1NXUcGZGAwzG5I6c455zcvhP0mQMhR2MvK6GI6gk62DMkCSk1UR8wBjrI\n", + "yQ7brfSJHdkKjINcd56SsBL11/qBEyUgdhwIzZlE+Jon1naNl7YdsVwfSAh6AtJ5lpuIPYulfxSF\n", + "tVMPDwXPqy8gotfvrU/GmkhA3yuRcKD1r9h+QxGhga7r7k7Q1O3WRLyKel1e2j3R/TByo/srCOHi\n", + "Va9zn67hN1JtsARIByNtA5IROE1ff9PR9yasOnta4WtCQwWUpqRz20GU3jOqizpp7LbvCmkLRq52\n", + "J7l3nhDZJYTN+72hZNtncj9HWs0P6IMpxiTlWszJNm1rc4KiZHVt/TT2sq2lc1L0o1wZwn39TvpH\n", + "T3NMCwSsxH4nShhYlPJbnrs0dzxd8pyM33JeudekIK72AGH3SHYSuH6PcTIQgqzp79woBcZ/cqAk\n", + "Esx/ZW6p9lcXMmfuPSdKyHEjQuJrMCFacy0ipOff/u3/6pxzLiNh/49fiiVNFjEjsMHxDaW6gUC+\n", + "IZTGA0VNqOadB/qTAAbpSVitJA3ppd0ApMUTqngL5GogP5kN6hnGA83d+LfaW9/RPtPSdXuFZACr\n", + "L5eGoJ2dy7O7IzTXL+VefPv+m3nbopR5jMqPurudoOQZ1d9TN/yRksdSJG+MmE+GRwkz0neXC3vW\n", + "ePTPgd4JtLauJ/RxTmiiNlbEiuc95/845hQQqRAhQoQIESJEiCdGeJEKESJEiBAhQoR4Ynw2am9o\n", + "BjckBic3KNa6Xpt3xAhaKNkY7FsfBYI7HUkIB5+jvjfH5B7QfrEwqkDpAIVsJ/LJUPjex0QFQETK\n", + "QsQC1ELMbsfwOdmTA/vFhYjxppboRsCNKWjBjIr3JoDPM3L1jUqBT2/vrRjmm/F3cv0Md4Pm9OwO\n", + "PKHgaWLtlKAY5AhRaEKu6yoijEkcPSwH7JfoNvWdcXTvALP7xN7LaxQNjjIqDA2fnZREuWmkjuoQ\n", + "Ak5Eu8CxfejYM0yu25fkNg4qICJaal9JscxFZGLbEe0TM2Tdorht/gznYe2l9Mh6ZQ74Dv0qL8jZ\n", + "PJb9PVAh6xR+SwmJ8nW0MX1ZLIUC6A/w7iEoerURysjXlJSA/szO3h3U9vnC+s7ba4HMuT2rk+z7\n", + "8oq8ouA3paLsc3I2ryG2riqjdo8nULbkI8WCZg0VvnIRaqXoH/nTAFL/FBWowQL0Fq7fS/JAa5FQ\n", + "kMYsgFaxKRU3Bt2hfc4553IIqitQcUNNHjMqoqb+r07d6aMqr0hYIB+vSgvukrdainurlRicc24A\n", + "tZmQK7pSC+psT6yfO53k+Eei20dUY4hjuydKd3ZEWaVIZEioQPFMC57sexX8mO7uJdlmuzHaSYXS\n", + "JfEzKei+5dqK+w6j3JOBaLw8lXs2Uvt3EK9HrDVXUXClfcfO9wHPiWtKNnh9LfPu7mTzfwW5x5Rb\n", + "460gBo+Jptnv5Hv1kbya8CwY4EUYJ3b9NSjQv/nbfzlvy7yM06/Yxb6Ua+g6Oj4SJb4nsXUM6UWx\n", + "tP6cVzInDCf4s/XW13K0TUsVOCZ4Gk6x9SFN0Dm01k88GrlIqU8oBUsJLS0otRON3bQABQkadbU1\n", + "ylSd94/OkhgaSCuY2l2BvitzSl7A/ax7Sh6BB9qn5DPKKHNlgdjr89SovRyUZkuJKrXS/N6oVb0/\n", + "fqLniQ44Hqd/vGZxQKRChAgRIkSIECGeGp8NkVrk8VzLyznnqiPqar2kVP9E3gwPrb2tbvAi3FCa\n", + "uOop40duu/J5kRoitUAqaI9Vb7aly8fKKadVba11eGgFFSX6BktvxLGuyGx37+9/hf2ZKFfd2zVL\n", + "OyEhYAJUS11t5fvypl3RauH2XpySv5t+NW/blJLOPpI/rVoS8Iv0FMEpHiuTmBxzVcTJ6e8xbA8W\n", + "BQnWVdhMgvEJLubH2mp9pUDs+sFWiWg6V9W2SlHLAI+VS0/i4GiCJQXZL1QQCpedrX4ioGkTrb4f\n", + "DrJKnVIWJauI065HkTOH2n1sP9EDCYszW32t1hDbkmA1hTvw4f7tvO32VhIZTo3ZBKzXuE+EuuQZ\n", + "rg3dlLXxKl7Pc+4nKfZv6OcCVhd3VGttVESCjvXqFWrtnWyVWi7ktylSva+v39Fn0v9ubkywXiPF\n", + "/OUXlv6sIma2zlCEibfNqAPnX+D81Nagqig5BMhM39o+SiBhY2P9tIIT935vLvYb1JPMKXnl/Tu5\n", + "tnNa/WsiyRLfa47UX9HWbKugqfGcQq1zQkP1xxaoO7Yuqf4YxOuMhGdolIRQEu3tarWSUbr6WSnz\n", + "ybtr69cHuJdfnNl17Y/SJudnhvCfgHqORxLgYtzxPKFoYxnJvwdq1xRJBhEhommpx7X96uc93ae5\n", + "QAW5nUdA4kdCDvS3WgdyoAQQ/WWZW7tq8kJ0sOPrvRhimk9V0LymSglqHTBYv6uwnwnzf09VHLSi\n", + "wvv3lqj0b+P/Tc4j+0/mbWUrbZdSWv0ApCel8Xw4yJgtCXy5PHvlnHMuwRjSKgVynnKvi9jOqQM6\n", + "WrP9A9p6IjRrAPqUeGs7TS7iuTOBKHuge+Jz2VZosgElzKjFQBTZsQ6K8NLzJAVimsY8nwFhmwzN\n", + "7/BAzwiJ1i4wYk6MKIlJ+9BQ03MayQAFueJ3rRxjHG1b2ygibNsi1DZtaYz76Y/7HwREKkSIECFC\n", + "hAgR4onx2RCp1TJyzZF40UTedE9UL+vZlbymF95WVYuFfF5W9oY46ls3WQ1kQEy4cramWNYwPxzZ\n", + "mBErB+WMnXMuj2T11XR2npo5Hsecpg+NAmmEfAKOnvhYTWfVNHWujO6gORqohtzUYX/E3+4rWR22\n", + "vSEyh5O8aRdLO6eLpaxqho5QP9QE1NpdDa1W9I3bR6QfwgqTC18vwelzuqiDhiQhfZlW4s5y0oHB\n", + "fsKPtvzqYToXJ7CVIESoxQqLTVJ1BdF7u/4FVtATnbtqNI5kUukdVtopp8nKqmO/B4LVmR7CYWXM\n", + "5ncqr1qXVKEe6bqX56al+v7D75xzzh3IS7Gq1LjPjq+Z/cuFGo3aajFCu3akVdg9yAqWLTlKpNVr\n", + "jTTZn1xrS/qyM9RnvN8b6rI9EzSpPsoKsuLUbDQ7Z7AvgbRwNrAaRm42htx9/70gp9utwbSqUVyv\n", + "bNtsUwBkiu0X1OpjSXqcI1CdBVWa3wNF6sgSoGxhJ0Fp0iukot/dGepWYCwcoAeLSXuiyDUbKGqd\n", + "uK63dsqw/M/IpHLo5VrT2PrT+lzMB6uKtJyYO7gkZgp0bNI6fDSHdRBrXL0wPdLdh/c4JzZklT5x\n", + "f09WC4DMe0or73DvxvFjNDEFY5DRvKZyUU/oU4LHSEsocYwamxF1lBHzXkz6OjUljgayk4BGq0A9\n", + "u93BENQGfSgnVDnHsQgkcRkmLZ1f5IvoE4Tce8w7ntH5P9Tr0TyptSFZU/N3v/5b55xzZWnPqb/8\n", + "k/8A50v6XqBeA9U61FqDLddaBBJTwkx0vTINYgMLiZrQz7n+JF1/D4SJyxqq1pdrHQ419GBsnIrL\n", + "zak/t7CniBLVL5FdwKSf2bG0TqMns+yHndg/ZIXpMPV5yrUbHe5FP9oc50ZFuFFrl2xlMhi89oTI\n", + "6aMzelS7VWvy0W5bzJ09MRFogCGxQdnRc/RTERCpECFChAgRIkSIJ0Z4kQoRIkSIECFChHhifDZq\n", + "r8iWrm0o1d0JjHbzwSDziwuIs53B4zFSIqPIYLfNVqDd/Z1BwMlcL8popMnJ5zlcZNkdWN10u8Fg\n", + "fKc1tAhGVFF8WRC0nQvsmBAE3gEqLwhaVGHznHJM9MBDJdDhYrI6aJmKXckSQcXep8p+W6by+aIg\n", + "F2MIal89/w/nbX/zS0nZ/f0NhPCOaDTA2GRi7MpMxeZGo6xADzAVoJB9OpiwPhuEUoiJqswUMu05\n", + "UQCQLSDwaaRrBWTckOuyQvDHBxJxgw5cZEYZae24mtXbg9CifUtUDejA005g5KoxYa26Ig+RUXGa\n", + "rp5THSgVHmdEC19uhHr55ZvfzNsa0Awjwd1nSzj6g8bItkRjwcW/I2ftDu20KI1GU+uOxcrOKQMt\n", + "cE61xg5ID2+oJuFvfyH9eXUhdg7Prq7mz7Senh8p/Rqu2MeD9b/NWqgHFpaqAHy1tutRKj2l9HtN\n", + "sjBrEra1gNUAiXPv7uTcsw2leuM3vre+dvegzvoWHqLwLLE5YcAY70HtJWQhohQL2y+oLNs7u9cd\n", + "7CFiSmwpS2kTvtcqKF8s7d5pfbqJ8v8biG1XuZzn4d6owPVa6NnFmupVghY53HyYt6mFwIZoVJ0z\n", + "WIKwRCr6mNgYv7+R+96A7lmv7bOzjcxPzUg1GdH/UuprqlqIKaFoAgXHEgyv7ukx9WdYOyQ1EkCI\n", + "xp4mFXtbAoRWfuB5JUW/SknY36kVBSX5TOBUE7JT6R9Ad/WwMCDKdMQji61WIpzTX//8X8/bVON8\n", + "uTKbFBVWZ4Rf5Lg/TUM2NaqlaECtemsbtTYfPdG9rVJWNE+AAh6JgtViCBPP3XjuTSSm7tEmEdN3\n", + "oPZ60Lf9aDRuB6q4H6kmKtz+rzb2PHtzJ5Ysp4YkPUiKykjs7UFztgMnQ4EqxAMqp+vXhIaJ+pVe\n", + "f/koUURd8akCBKwW6obqBKr9RkKULvOBn4iASIUIESJEiBAhQjwxPhsilfjRrTN7Cz3sRQB6VZqw\n", + "7vpGVmKrta0gStQdy0nEnCOvNl2TdcGotdbsmDFS3FXk7Z2tqlukmMYZpzzqcW2lecRKW4Xbzjm3\n", + "PZMVWxETIpBqRXpbueqb9ghjypGsDq7vxKTt+TkhaBD7eVb2jurqyKsq+Xy9NEO4s6VU5F5khhL9\n", + "kz//j51zzt39CzVBM/SlUwNFQroGmNktyehRV7rLla2SaqBZRWaNfWy11tWjXHc534FrF8q5t50i\n", + "gmx+iNUXWU1EQC5HWq00sFNIva3INHU4IgG6CjBZFKtKejVLbcnora1E2L3orU+ooLgfDP0836BO\n", + "IgkmC4iMLxa2Iru9u5FzS6zdlxBAHyFE31AdtLyU63l4sGOphcYDCcavLuQYWq/ROecOR00ssOu5\n", + "+SBjjBGe7Vb6W4MkjwPV3NI7t1qSOD/62EJCEbnj0c5Ta/GxKFbT6tkkU0MFs/f3lGo/19Wza9B9\n", + "MEqp3ztSosqylG27e0Mur86l7a4PH6+IN7D42JHRowdKyDYlFUwSS8pXVyBkYvQTl8ip3jUQ8JhX\n", + "+kB9EkKzihRtBwR7Qe3fwEB2IPuDJRCui+dfztuOsCxgsa+KvLva+r+ijjmZJK7PZH8HWChUR2vr\n", + "xRK1TlnFDETckyXCfImECMVqJ0NjVzXbE5sTr+X4I2piblMTJ4/3er5kIXAv53mkftIDRe3JfqA/\n", + "SZvFSzu+1nYcSFC+WMrfN9cy/puGjJthCMuIvKqseduvf/UL2e8P7ZzOYbCr7eWccynYkWJl/elw\n", + "knkiQt8Zj5TEgHqtWl/TOef6DlYzZP5Zoy0iyhSagKq0EwvV9VlEdgoQ47Nxa6LzdCv3RPuhc861\n", + "PYxuiblQ54TF0vr1JZD9abTjqyk0Jy/oxNN3nAAhx4/Q1lybb7+D1QLbZEB4nkT2jqGCdp5PFHWc\n", + "uo8TCiLqkz3f709EQKRChAgRIkSIECGeGOFFKkSIECFChAgR4onx2ai9fde4ZUo0Rg9/ls6EsD3c\n", + "YYfeYLwkF3HecknUHiDNkqiVvcJ3tG21FAHw4SQUx76mmjut+m5Yk/hUXbzJxTVWKsrgwRNE8ynR\n", + "WCrA7qnWXgTPGoUO2TOrhhB6Qy7uk1MvFruGFB5IE9EoHUS8EVGQ68VL7IRgdMDCP3z+U+ecc796\n", + "89fzZyWojboyGN/BnXwkum0EFMreOpNXyJS9nfQd3a4xhbCUa4epQ+3tvVz3QMJOrcnGIkKn/lzk\n", + "OtvUcv2LzM6pBx2XpiT2hdi4I5hWIfKZCqD72rUqOiW6N1cnXDulPII/FFEwS1BGJa1VVOTZ0zWe\n", + "arnvP3j5I7mWxr6vsHdCzuq31wL7v7ig+n+gMT9cm7N6D+FpRKLMBbyqFkujew/wcstwQUyFqYh5\n", + "tTbBctMrZUDnCfEyexZdXJgYWkN9eZjaU/pWt0XExavLOYu9M4iXG+qn6n1Fw9RNEEMvye/r/QcR\n", + "Y19cmgD4/t03zjnnbg+yv4y+nyFRpSOKYe6TZK5VlNr/WZwLB2aqirCEK/ThYPRlAc+o6kT05aUc\n", + "b2zl3kVEBXW1tElB89QJiRfLrbX5FKtjOFFLz2X+2701V/zomZz7d7/9pZ3nUtpigfHaUrWB/U7u\n", + "sTriO+fcYoP2JBG7UjAj1Y5UR/NH4xlUaUzHmCCyj+G3xHNCiXnn1TOj+3bw7Lrd2fcaHHdJEpBd\n", + "r/591v5nJebTyebd5Ur28/Ag53sEJe+cc5Pek4nmP4y1ckP+WEhieHttdVKLXObdmJzdE/TTnJza\n", + "Rwiv7w5yrz0/pie5J+Ng8+qIhJ6RE6WU0qPsIY+Jd4hp/muQ7ED9eZgnaPYZHPVinXPOdeRj+OFG\n", + "ZClfPPvazmmSPlRQUtY5xlPdmbQj1vmRn1M495GTErwmecDHi+YfTTZhZ3WPOXlgSg5NEXlO3sL8\n", + "R5DSXA0hsnl/cmT09okIiFSIECFChAgRIsQT47MhUnH6uOL3JUTm97UhLVn5h79yboAojNEsXQiN\n", + "k70l93AqTZYmwC2A5viF/OCB6mqdOjmuJ9FZBrHfekFCwFK+14+2Ilan2gO5aPeDHGtsSGwO5+8Y\n", + "dZJ8ys0v2+4OtvrZYkWYk4VDies+kji1RcX6N2+s/tNf/FTOryc0T1P9FWlhd9oEqFK5slXVLETs\n", + "SFiMFUxP1eKnWOsfWdv1PVYJVGlcK20nVP9qqZXl4SK/e22V0RUl8uyYXsOdN6OVLsSrIyEHAxSL\n", + "EaVpq2P0kFOqMawtGqTwMtISQ+TuyfVXU8i5NtotHHvPnSFHHivnlDp5CsRspJXOAMTuYffaOefc\n", + "q/U/suNrunRpx7+8lJV4QX1iQP3B/cH6cwnn73Jp1iHzOpNWaQkqnKsVSUyCTUViuYbXGk7onlZ/\n", + "6k6uAnPnrMbeguraKcLkOSVd616ibVJCXw7kaD0fa9Q0aNuWAmlsycW8A7KX0XnmhZzL7tpQtw5j\n", + "dwtXdu5DisRwqnuK6gQTibj7QasC2DiZ0Wdy0dZdJylZQuDf1cbaSS0efvDlD51zzr1++/382QVQ\n", + "J0WGnHPu4kLa/VjZthbC6oZqFyoCfnZuiFz70GGboVndqPOZ/JYNYTQNfCInbm3hnmwK0kT63eM5\n", + "DnuiTQOSdybqYw72BzHEy9HaHMMzjJfdzlClczwo/uS5JXb8Bp/fO0IEce8eWkNzIqDIaqHjnHMj\n", + "KhmsIbK/ubX7dcK8p0kKzpkT+hk5kFuJR/ve7kHuz7MLSwrIYW0zknVDBhSzgKC+JXd2rwJ0asMY\n", + "/S+LOClI+n+Zco04CLUJTk8Wco1sAK/g0Eh2JhopnjsdoUpaJ/XdrVm9LHNpV651WCKxJuG6dep2\n", + "n9s8eToJShTzqWtNQMxdCaF6KeYwHpOKKkWPKnDI9Q+O7HQyZZ1o3k9h00JsxjjyyXwcAZEKESJE\n", + "iBAhQoR4YoQXqRAhQoQIESJEiCfGZ6P2+nF0nkSkUSFQ3CX56NS9+HjEVI1xhMs5iyhVFNqSYE0B\n", + "xQWJotV5OQPsPJAQsj0pxGeQcQx4siBs++VzoQDefTC6ScXDngrE1hCvpwsW7KnYElQUeXwkKLx4\n", + "aqgYqheqJqWCmlpcOSPH4BoC1Ie9/faXvxGX3RdXP5u3TepQHcn31afIOec8HMZz8tEaWhXs2XV1\n", + "8ODanUycmcz3keBu5VsnFsrL30VpNEIygYJ6JrD4/mhQ8G9f/518RkVO1avFj5wAIMfl4tJzsVg6\n", + "vooXmRb0sdBBEzywfWyw7wbC45xg5wIU6KknKgLQ+u2dib0ziFjZFXkCHRwTBO/RJ2/w203xav5s\n", + "CcoiItffE1yuh6PROBorEpH/6GsRtn73nYld61p+8+Lqx/O2M7iSf/+t0EdlbuemIt+IaJwB1M5i\n", + "QR5woBSL3GhEpQDY70kFrSMlCqjIfKb7iLPL4DPXVDVtk/3GfE7w9uEC5ftbmTv2g9H95xDAH7hA\n", + "q3+cPLIqqGg1DtF1LDSFO/nCvjc59Syj4tqgGZkqjiDyfeQLh+tlAX5Zwu/qWty715TEsIew/PLS\n", + "HOh3e6HCSpoTRvVPy1iALMfa763vXD0Tmq+pKckFDvG908QOmld7pfZstzoXexqn+htiip1PlAK1\n", + "H6co4D1V7EAtbdcrFUxUaAzBPvvzuQnFrWmcPgdVW+2I2kRSziK3+SebZMwUa6JlUV3hCOnHxQsa\n", + "rxCWZ5GJ7Z9fiYi/LO3Z5SL4GNFp1o3s7/0Ho2pfnElSEPeJUWUmHkXbKWGnR99lejxGu2bkLO7R\n", + "/hHJCGJQ4AXR5yO2+Z7mU8yTdW/UeoxXhcirsJ0TMKRNDjROe4wZPaZzzqUYnzn5LSbw0WJR+Bb9\n", + "/0BzXNPJeI4w/phujxNpk47oUQ/vN3Vkx5XJ9+m5m+OcNLHCOeeyTKsscL93fzQCIhUiRIgQIUKE\n", + "CPHE+HyIlPMupjfjCW/VGxKsnk6ymjw19mbcYoWZRibOTDxq/dCKsEZK7JKWRDFEfANqQ9W1rTSj\n", + "FKmxnb16qmA2KW1bAWfrNLIV6eEob7jVwd50G6x+mkcCTHlL9hkcuztarTpZzVAGsStL1LUjREpt\n", + "CthZelGIGPP4YKvKv/nlXznnnLsnF+dxgisxxO4xIUhpjmOk5OKL8+x7a6cHXNfaW/vvsSLOchIx\n", + "Z7AJGGg1CYShiG1FmKtrMVJuv3r50/mzm52kaXNNRE2dHulep5m6bdO9Vkdp+p6H8DIhsWELoaLW\n", + "euRabwvUU1vQSlctNhaU1q4lrtqIVr93gmw2KS/JdXVESCxEjnUvv31/fD1/duXF4qCYbPUbx6hN\n", + "d7IxkWLF/tUrc7b//ltBoqqjCatffSFo10Tn/ptfSd3FF8+/cs459/aDJSz86Z/9Y+ecczc3d/O2\n", + "50tpk9XKUBJFTmhRNyMsbUcuyuhv7ACtyNWMVtFKtwAiWB2sXdWepKBkCwektSWU8OJc2uy3v/79\n", + "vG2JFebZxsTLH64FJdCkhD63fq3JCW5k0ak64XPI/xWEyLSNzFOPTNxxjSkJWxugOSdCx/W6O7ht\n", + "92S/kahNBdmf5Kj1eaLxr8cdKfOikwAAIABJREFUqD3ne0KI3PUHQUIvL0yo/fvXgpgsUDtPk2mw\n", + "R7kUahMdYTHVupwGue+evE6m6WNh74hHkM/tnsxjUWu4nSyJwpXyfMif2fm2sOw4DFS7FbUwlzSe\n", + "73DZqSebklwQoZLy39ONtLsiSA1df+HlvsajXeuL5zKfZZQApclIIyW7ZJgLPrz/OztPVHko6Lcx\n", + "hNUdLAS4D2mfTOkeKsLLzI26mDtPzzMo1Advv9V6rmNOyRM63ZPbu6JeCRD+cfoYpVyQ1UKP/p/Q\n", + "XNMpclxQUg6uNSZMJ0KhwiKzcT+/qaA9PdUfXWNcn8hCpBtlLPQ0rhRpyyJGxOS4RcEJJXLcOLO2\n", + "41yIT0VApEKECBEiRIgQIZ4Y4UUqRIgQIUKECBHiifHZqL1piF1DPhULUGYdQXY5oPLfk2NzBHhy\n", + "saKCioAgu4n8hgBpDgStanHfIxzNR6JYlB7oyFCjaeC2vaCCmoAdSyq47CHALgaiFiGyq8lHRgWg\n", + "A/yUSPPmUlB765KKLIKCypKPRYwXS4PC9xD7xZ399mEvflTfdN/M27ICtNwWjtWFXf8AemJZGsQZ\n", + "QVDbVHaiR/jTHCYSYKIdh5ooGEC/q8Rg9A7eUru9eWV9cSXQetfiXKig5hdn4rfyzdvfzdsKiPIn\n", + "Elum8P0oS3I212SEgfzGFAJPycUXdKealvRc5BVdLKHi0hkoiGS0/ZbwVmoO5hh9Pwrd0JG3WAFf\n", + "ppwEoA40l2on33749fzR2WKD4xONDRftZLJtC9AC768/zNt0HK235hn0m2+Fxru8NLG5+rF49M0N\n", + "CdZvsL+CBNg5aMTX35tg9sc/+Qm+bxRgDtF6wkV7IUYdchIbg3pRCqQkYb0KwJcFeztJ/08Xdq+1\n", + "gO3uaIkiE4qVXp6ZA/b9g9yf83Pr49utiO2VAhtZHT2o79nHhXfrilz8S7lPczKHcy6Z6YOPf3s6\n", + "WR/XOa6mJJPVGoVcIahvSR6ggvKhI3oaXaxc233qkCgS0XhSWrQ/WX8+QD7REn11eQVRPpJXIvab\n", + "gzg4ZQ1CrPeQBMhIAJrIAVvdsfuEDAI1AaMksbm2DwT7MbnzjxCAZ1SxYrOVe/yBJAD3O+mL1+QZ\n", + "FWPuThz3HSSZ0G3PU+kTm6XM/9uTPX/yL+F2X9n496Xcdy5urVr/prEdq39fRgWidZ4+JSTBgFZA\n", + "aW/a7SzKnqhN1GV8pP6nhYfZnypGX+gnm5OVvps8+yTJ2M1o7MYqUZi0kLzd60WBhImWFNl4Fp4o\n", + "iSFXqrgxEblSlUn8cVJYTK70GSqfREjsOJ1srlEBPhtPabWL6JEoX64rjSl5CTd+onYatFgxvU/4\n", + "v+dVKSBSIUKECBEiRIgQT4zPhkilUelaEodtvpBVHdcB0hTPprbvVQ9IdV2YYE1F6x2J41K8YR8b\n", + "SuvF2+epgnNpTGmgeKuNJnrTh4v1uKV0eawwPb2tL4DsTJRqXwIlqWk10SAVszvKm271aLUkK5xn\n", + "Z+Z622HV6SNb1WWZnPMFraozuMdeEprVfwsH4MqO0aAZtV3p1NzqHKn+GYsDYRdB24ZRfnUgAWgC\n", + "4T2X1cohRvfOVtObDVyZD3ZOZa6rE7l+FsfGOM8NuXNr7cKMPCniRI5B2e/Ox1rry7YpItmSdnbA\n", + "yk0tFFiwXGOFk3qqYYj2LxNDBBPUbirXlpKuqOdxb9ef45zY2XectHYdrossQU6VoFpqw+GccwmE\n", + "xRMhpw9wTF6syH4A9+zm5nrepsJLdsqvvIyP9+8FffrJ1yT2v4MQm2tNql0BIS2ptjWt6lWMvttZ\n", + "P9G+y6CPoiS6cl8QMqEi2pr6RArRa92yhQHG5ES11rD695Fti7G073pDaVIgLB6iWBaC+z/4V64L\n", + "afWU6q2O7RlZDajLOVs9OKS4J5ldY4V+sqJ7dw3n9R98KQkA795ZG7ZIStguqf7hUbZNnqw20D1i\n", + "skS4vxfEbkVZAfVJvngk65DdTv5eIA2dEzDUMZ9yOOa6ehPXKUWrTSSi1hT/hFAC/dxPxBzMNfm0\n", + "5qAhAyp8b0mAHzu5F2c0TxyA+sf3dp8ar5bdJIrWCWIgsTX62xJJPAUjaJmiH9ZeMSx2Rsc2LTo+\n", + "bfxrvbaisP31rdyLmmxCOrXOSORaC6rhqo7y5P4z11r1nFiD5x8nCmldy4qYgxLX9ignAvcuYQd0\n", + "fCFfyh9ck1QrP3D92REd8ETP7lMrNW6XbB2yR1svbD6dqxdQklUSyXwSI8nsfGP96vYWcxwhUiVq\n", + "/HU02SdAotiVPwVj0lL/10oZzYkSxSJzrf9UBEQqRIgQIUKECBHiiRFepEKECBEiRIgQIZ4Yn4/a\n", + "y5w7T1hYLRDkIjfKboBT6yo3yqRLpDBiSl4QWpgwJm5pAfFakpMAGdRfCe+ghqBQLShKtShdBhix\n", + "P9GxEkDq5M6r+uSEIEP1anIJUXAQCO4hsKx78s6A23WWm9j36lyu++bBfEdG+GiV5CxdgDKJR3Jl\n", + "xjvyz3/zt/OWXSPQftsoZWoXuxzg58JFe5P00fedM1fiksS+6g8yUdHWHu7IrTdq4QCh+kgivu/e\n", + "irj6fC2eSU1jEL8KAQuiFgbQBxN5oeRw1OYil2Ov/iDWJnW7wzVyIWX4XQHFTkq7rxVovoicrVMI\n", + "fxee6CGInfvW2rP0cn921CdUUBlTIVWlTUYI2nPq/7u9iFzLwjxzFugf0cbapOrkunYHE3GqULkj\n", + "Z++vvhTarm5NqHk4gUb6gTjgv3tvgvVzdc8mIxulm78E7eScc2/fynlmlIChBXInssCOcYPYFVy9\n", + "3Mxuxo6l++sSg9jj2TGfPdBSfGb971RJm3S10chr+EediNpIcX6rpVAFHVMsEL3mRE9NmJOKzK6h\n", + "AX3TEgWl18pu51UtfSalQrJKo0zkSq0C/Q8f5F6wi7XDvFfROFng3Bui8YtS5q793u6/0rIfPlhS\n", + "hPr89FTwWb2ialClGd2vCuLh7dWP7OuYJyK6rh7eX1Fu439ay3mOAyW0KI1HiToOdKR66zmiJ0+3\n", + "0scfSJx/C6+8lqQdCxQ85j55wG+YbVXqfb02GqsFzaz9ar39gq4LyQ65tWs3yPFHohuVbh7JWy4H\n", + "3ZSmRIshKcp79qBC+4O+nugxrXQX+621M7VHVJz64xE9N2F+mnImq2XfbUXUqp47NdRqKfOSx8Nu\n", + "QfSkJj7UlVHQyvKdattvjvvYkwdWin7fkbO6Jp4UhSWKTO5xpYqONDMrPIvYHf0OrugRiegHPONS\n", + "eibr8HxU5eSoBceJ7vV/3EgqIFIhQoQIESJEiBBPjM+GSK0K78441R9p/SWJiO/2EOfRSjOHey4j\n", + "Ryqi61jshtUkZU7PtcBaCNobWoWNKnIn0aPWc/OjvdX3SNMvqCbZAUhHTr/NsPrrp4/f9BM4ZWct\n", + "iTghDo5Hqk0HMfyitDfz272sUpPejr9VkXNnbff8UmwFXpNTdZ+KG7IKEIeJ6hoekC46WFuXEKWS\n", + "h7RTF+fG2epbHZ0H/tqgLvL29r/bCfoxRLaaHMfH7vWpJ3tsoEqcFKC1lhyly6pjvaP0X00hZmfh\n", + "OdXfW79bxuoeLf1vvbKV0e5eExAIETtIe46EEiRwVu9GW7UosMeOvZk69lLtMA8rhEYtFmi1qoLV\n", + "dqKVHoT9fE8GIGwD2YmcdtKuV89tNa3ox7v3Zl3w8uUPnXPO3d5Iv1qTYF5X1RmtPlUoentjFhbv\n", + "bwTh+Mu//CfzNrVCONsQwjxpW9s1qmg1GoBMcNtgTE5cnQArTNK/zwbM48hoFlaptCLOkJRSUz1H\n", + "rRCglgQZOVxrfxoJVdPaiSnlpGeYx1jY2k8q7CekCc7TXFFhuRCxa1VZ3ykw7rROIafVN0DYuP6i\n", + "uoOPhNLvIEBfLmyM393JPVmSUP3uTu5jWZIA/UhO4s45T6n2GRILOhIx57kIcSdC36JM09UtJlgW\n", + "TCzehkB+2BnCEwP11twByrR3KzjwD/eWRHGrVSQiTlSC/QYxEjGE+iOhXwdca7GyNjnqXAT0I6UK\n", + "HIpwjbUdq4F7f8dWO4PWerMW0JqMbDSQ4lmQU6KCjpMJaBXXNVQhuic2I4F4vqH+F2mfoRswYYYe\n", + "aDw1SHgaCE07IpEl8oZEXoAo0XqWPK+2YB86qgrSzLYK9IoRaQUKSsqATdCJUP94kjZOW+vjlxup\n", + "ynC2kbqGx4P1UbXTOVbWJ9ZA7vvY2kQtRmKuv4ukhH6whjq1OOeIknyiP445BUQqRIgQIUKECBHi\n", + "iRFepEKECBEiRIgQIZ4Yn43aO9uULifYLwEXQrV4XRyrOM+gWPUPariQLf49HWjbJDBeQqJQP3tU\n", + "wZ+DnL1rQHt+YigWdBeBsX6S47edbcsh7Ly/Nrpjqd4qa4MR1b9iBH02TeZdUTcCu3dU5FXRTobR\n", + "VbBaZASjo8jiNNi1LiHsfHFFvlQfIMoEdM2u243SZyNxJp38XRC1pp5VMYmtHZzdk5jE5iqiJbG1\n", + "CiojFvGNcp/qWs5p8CQsxnt+7A12d7O3E9Gt6o8VPyIX5RJ69uCCiJCg7UKp4oVAwSU5Rg8D2ulI\n", + "PjY97tnuPX0PbtMkovQ4z4monQV8bh4J+tEXBwjrYxY1gpZ4f2POysUziD5HEqDG6i1j0Pp6LdfV\n", + "k2PvEcWlLy5NvH5/L6LMtkVB3zMWooJuI27h999LEeCffG1iY6UA37wxyvDVS6Fg7u9M2K50G7ES\n", + "s2dPAdqTvaCmXj226JzgxdZ01k86jInN2qD4mw9CI2/PzJ+mhch8opLD6pSeAO5nwbgmcTzyzAE9\n", + "kRFllGEe8VSgVWm5/d7G+AIJIgX5OFWzQNyucb+XpJCylOvJSGy9WAjN/+6tUfbVSY5VkLC7Bc2T\n", + "EN22RUH4a/rtei39aUdUiSZvRKCWIqI1VNA/kCxCPaPGrbW1mzDuKLFkQNvGK65uDaqIxl2sBZ+h\n", + "36goiWKAt09K1QHOFkqF2m53nez31fOX87bjd3KNJ3KlHwZp/weiMwel2Qf0VxpDfQMaq7bxd4Qv\n", + "XkTUoukcaE4ctT2NslqAUuw7u54sRRFezPue5BaaqDI11icLiMKZHuxVlE5Fi/V5l1Ki1IS5+0AJ\n", + "GCd49W0Km3dP6KczPUvzfw8ZRUelOvpJPbOs/60XmkRg4ZGMFNNvc1Bqq/LVvO0nX/2Fc865+3s5\n", + "jzyx6zrfyD4a8mWci6CTL+ACVTvYF039wzIaO6cO++tsWz/xvPhxBEQqRIgQIUKECBHiifHZEKnF\n", + "KnVJRymPeDPe39sKVkWBcWJvq5phP9Aq+XiSVd/1rYnNFGwanK1mngHF0ZfLid7M40hXlVRzZ5K3\n", + "2aphF1tBn1KqtZZnmqZ7mLftDoePzjPBiuGIt+BxspXJHVZdX35hq6VDJaiHuhk751yHFTS7iN/t\n", + "pc1Kzw7g8na+XZGLdSMr0mOlKaR2vg1W9ez6u0nl+wkhKF7rVbX22xHp33w9Qwc0idDEMpfVtCeE\n", + "qRtlP20tq/CIJOseyMFjBEtWjmNi1zpAFNpzCu+8ErZtKc49IpsGTTuPsNJeF2RJcSbbjrGtvqz+\n", + "mKEfR4hde1LFTlh9j4QmTECpGCVI0bYtkJaRVpou/tid93CUe50lhiqNQFGznByDgfSw2F0V2nHM\n", + "liCyvxw2EWVp/fqAPny1smu9OJPP90frp2cX4lifUFLI7IpMaJIiGy2n2mM1XQJN4nptkY7PT9Tf\n", + "jKmKgE+1Tqe1U4pkED5WC5uOzcb6n9p5zLX2KGGhrlEHjhaj5fJjB/6+kr/zzMba3P4FW0JIe263\n", + "ti2dhbdUlQHu9uqYfjzaWFsDwViROPrDeyRALOz4eh0VIS1LIKKrrf32Fi7qfN/1nsSKRBEipULl\n", + "lhiBAucZkWDeY+7sef7TumYtu23DaoCc3UdN2gAkX1xYAsTuVuaJ+52h/xUSetLUEhtcrUijHStx\n", + "GLuFIRf1IO2zPxFyDmQ7HaU9h5psHY5ynjXVK6wPcj9bQkmnUatSWJskmjyU2Xm2sKBJUpvj8gUS\n", + "GtCdm44qYGDu4moTLa7fJyQ2V3SesrJm93hCzhsga5qc4Jxz66Wgzefrr+dtL57JGO9GeU7dPPxy\n", + "/qxSNmVilgYME52nJlskZImj1h5UTtKV6J+rzPrpZikic9/L/Xrz3uafeyQxdb21U4T7PlH9P6/9\n", + "jxLACoyZviIrILX7oGlqIuf7T0VApEKECBEiRIgQIZ4Ynw2RitPIpaSRgmzHPezJLE4rnff2vTXe\n", + "IEfadoK+Y3ewt8Yab+fHxhAuX4Cjj2UfSUpcMdCEyVFtHqTJ152tCCtUkN8ujXsfsWRdLE0jcNcp\n", + "SmPnOVTy3noCH871ytQm4O2H387bVjkM5FJ709ZVd93wKlHezpv+u3lb26CuG6EvSyAWasJ3JF66\n", + "7mQf/ciIHFJtKQ1U0bGYVppqOlg31k5qphp7WyUXmewnSew+TVj11Vj1dt3t/JmCU91oy5Uo1j5B\n", + "WioseloykDtihRV5W5EugBxuz+0+nRq5xgmai4HOLYFxXTnYNejKqDrYvauRLtz0lNiMFflAtdsO\n", + "aONtZqt/rZOl5m/9RNfqdKVp3785iUapKG21lqdq9GnXWiLFPSLdTgp0ck9avgkI5NUz6c+Kwjjn\n", + "nAcykpCmJ0Vj14Q+rDaS/v7Dr0yP9+23v3POOXd5ZcjZw52sZguqJxij73RYkmaU1n/Yy+qzJFRH\n", + "tTQ5ua92GLsN9T9F5w4HQ6kjINvH04OdO2rnlYUiTbxax7Hyj41Gl1TXTVfV3WRLWEXfGtK+rJYX\n", + "2C9VlccYLMgKpoNx4nIl2+5u7Xzfw7ri6pm19cWFtPH+3u7rBrYTFWmfmiOQ+721k1pLkG+hy4Am\n", + "5qoboQ9TReQZfVNd28n22wNZTS6sRtkI5MoTwppuBW0ab23cR2qPoLYDdPztS5lDDt8YS6BWH/uT\n", + "ab/GGOafo30vL2U8PdTv7DyBiNcHns9USwT7gdb6624nfe3mgZBOPH9G0tdqkU/PDYt2WhP4lwB1\n", + "nqgmnxp8Tk7OTZ9Xzjk31lrXjzRleIwPDJ1iHqHsfwefUdcRStWizy7Ki3nbD1/9uXPOuednP5m3\n", + "bTdyDmdruZ9x+h/Nn/322//TOefcL17/i3lbqddD888Ea5+B2qRuoJuiZ5Eit18939A2ucc/+8Gf\n", + "yveJufhw8zu5rprGXyHfTzPSXDp97tp9aju1RCDkFIadOekgHdWx/FQERCpEiBAhQoQIEeKJ8fe+\n", + "SHnv/zvv/Tvv/f9N2/4b7/3vvff/Bv/9Z/TZP/Pe/9J7/3Pv/X/6D3XiIUKECBEiRIgQnzv+31B7\n", + "/71z7r91zv0PtG1yzv3zaZr+OX/Re/8Xzrn/wjn3F865L51z/7P3/k8ntiZGtF3rnDPIsgZVdKQa\n", + "UhlgwYigyAIC6IHccVclUsgnowVrpPY3PYmX38u+12uB1lkIpzWfGB31sERoO4PxD0jN9d4gc617\n", + "l5ED8dlWUjd3OxLPJxAx9vL9/YFSw0Fz7h4Mnk8uZRun36qIt26ZgpK229OxOrUuIFdeFbYmqbTd\n", + "o4xORUVJgD96+X5Ht2+AOHogm4QIIkJuu3ZUt22qiZZ87FQ+4RgpUpjvd2Q/EO0ffcc55zLQgwO1\n", + "yQBhZ5J+4n5OLOwEfXi0PpHCSbtBbSafGzycgRbNC6t/GA1Ke7BNBuhWbzTSNKo7sB1LHbJPfO6A\n", + "8QeIUhOy4h8H0B3kBH+sQeOmlhqcTEgXXtt5LkFZtRWlKddyfKXMnDNKT+FuFsxfbC9xDVSTElYA\n", + "ZUnjby3j47vvjFpWaqmj+m8LCMAPZAlwdfXMOefcHhTUVWljLc/hjk196LiX+7QhAXwGurdvTIC6\n", + "3Mp+Dzz1oMOzSbHW1lPH5p4sJFY4Bp/vAhQci821JhmP0/VyhWNRTcRKa+3ZtKt9guuaKaVwAhUX\n", + "c01Q/PtAzt7brbT1am19/R7nnLB8AML71dLu3cNOvpcSVaqVD5TaS4mKVYsHH9u2BGNoIvuTGHTw\n", + "SDYdE+jWiZJHpk7lFiSKVjE62snT9U8QuX8BR37nnDsi86aqLbHoWhN1WqNFR1iraBKFc87VsEc5\n", + "HFgoL+e5hiVKRPdaJSAt9ZMedeKiRyJq+TehSVFv8eHI1CrsXArru6OKx2GF0lKyT4a5dt9Swgrm\n", + "eLZfqNHuEdkfqMwiYVd0tTOgepIjXMkXNBZfvBAB+gZ95+7G6NFVKWPt+cbqb3YnmQs4UahFgkhE\n", + "NWFXa6GlM+o7N7dSZSGKje7Wuq+aeLNIbfyXeJ7dktXNhHnKx0ajT5A+DGS1MTuw03OvhyidyhQ+\n", + "qu36qfh7Ealpmv4X59zdJz76lLHCf+6c+x+naeqmafqdc+5Xzrl/+vcdI0SIECFChAgR4v+P8f9F\n", + "bP5fee//S+fcv3LO/dfT9P+w9x69tnRbltAMH9sed+1nnslHOtIoVVWNqhZ0aNGiyS9A4k/Qqx50\n", + "aYBogAQSvQIhUOELCSqzgDRkvsx85vP3u/6Y7cJH0Jhjxhwn7+WldKXkSqU1O/fc2HuHWbHWilhj\n", + "jjnGdCsin4jIP6fvfCeKTL0TvTQS0Wq9Nr8sQisGvOHHROI8Wys5sar8Pe5iDVJs+jP/LcjOA7lK\n", + "Y4EnaQZUKfaVWYLy44RkBVZ4S5/IhyfGm/7u1lep50ACVltHBNIMZF9apbzcfy8iLrCXEqpm797x\n", + "SKQ2rKCYbG9+gRJRCW8Hojy9Fp/MHZ3KxNdAffJEz62lFfSIN/Kejm9l8j0hAgmOz0JnI+4PCzda\n", + "8DYj78YLklMYDSXQFUaWEREc8gyr1FcmMkLUkATU6h7HpzJ5E1gcfZOkJpJJYnoNxOdGQ9popSmZ\n", + "eUP5thikdLaQSoC+ZSx/YE1GfbzHebLAatfrijmBCF/G0giJCfj5StvkJKraV9orlAmvlk5Anz2+\n", + "aKV1uNXfbLck3QBiZ4QV3/mZ+zrOS2g6X/M1tFJmEZG60X5akP+k+S/evn49b1tDOmCigoZ+9kTU\n", + "frei+9pAViChVX0D1Glc+PdMMDeh1bdVKjApNcOYbEi6owSyeAc0d7n01bKJasaE1kyzXyDJagCx\n", + "Seh75mu3JK+72f+PEI4YHel48DkuzfTvBXkcWmCxLC1JspgSxYIQBLsOkzcQEVkAsT1UTmzOQRpn\n", + "IWBXPYBYJh2/tz5Bfmmj/YA87CIgUlPkv44hcBrRY2cA8X4krzXjJ08oBBkJ1YuQYdhVjqqmyCxM\n", + "5F1qBUKHEwvCapsU4sjdq9c6T77dk3BjoW1SAEEn8FkiYIJT7G2YYp6850kIT75IGLnUf3vytavh\n", + "2dcO5PsKmYYRqHo/cL9G3yWyf4c+uaUMyzqF0DDxpW1O6EmmoGv1niQ0nk+VPqde3xA6DCS2iLXY\n", + "htH/HgUa3ZGEa/FMooSIpEAxi4UXakWFzvc8dy8xB3zx7M/mbZ9/9rn+gfl3TbI+Dy51H9c7KsCy\n", + "PkO+qoMhx9TXBiBSFbV/ApkkFni+J7b6nvhQsvl/KCI/FpE/EJHnIvLv/4rvvvt0DREiRIgQIUKE\n", + "+JcgPgiRmiYnI0VR9B+LyH+N/z4Tkc/pq59h2zvxf/zTF5KAZ/T5T87l6uHF+74WIkSIECFChAjx\n", + "/2u8/KqWl1+ZBNCvxoM+6EUqiqKn0zSZaMe/JSJW0fdfich/HkXRfyCa0vt1Efmj9+3jH/4bj2Qg\n", + "bziBN9LFpad2OsD+8eT45AIaPC1D0bgKJkxOgOWS0X9rartFAs+z0dMDGdSr05Y8f6Afkyz4e6q3\n", + "seuc2H5zp8S7qzOHLE2B9uHZT+Ztu05h5gO0rfLMYccSnmx55GmXAfokixUdHwTMmNKClqoYibA3\n", + "zuTheZNU2J8J65YdEQwj+FuR7pWlXWICLgcj++WextwdNWUU3YPAEZTa20G/59g4LH+21vaMkSox\n", + "pXERkSI2jR9/yR5awPiUsixAmBxJNOVUaUqjHT0FZl5/I5EtTcn+iIZiT6Um198uFw6tL6A9diSf\n", + "wg7nvl25AvMZFMDfvHVSsLVdXftvzafPdWGYxG+EdT/fDB5TA6UHMqQROlJx39/q8GzJgCxGiprt\n", + "FBflFtdIYxHRIo12vvUxuYcuU1Z4X18iLdjUTva8AaEzJx0tqzkpC+pjGMemLXU4eCrKSN6fPnSN\n", + "G0utjpRGbaBY3nZUWHLSPhYxUXr+17f5tUJFu/BxZUrtGXmY2fjrSQvJUpqswWW+im/e+DyxPdN+\n", + "nNI8ZartTOi2sJGzWvk4tZaLY9/WVEhVkLKzXevjKx+nd1Dl78kn9NRqGy9JM6eYfQeRsl3QZzMB\n", + "nBXz4Q7AKVsQwFNquxHpQOb/x0ij9BWlalE8I+bDRg+xCue7J8X26z0KdKgNKxQtHWtvky20pcrU\n", + "55PD3XN8n9JiCx0TOQpLmAifYUySBKF0qaWR/VqTHIRl8gQ17b2YdJQmjPuOiodMDd7oBpLTZ6Cq\n", + "5Kn39c8wPp+cecqyLPU+NXSeu5P2k2tKwd2CynCgdtpjPq8ofTp1uqPdzRciIkKXJc9e/pWIiNw0\n", + "X83bViieSdgTFP+Og88TyYR0P5G5Y2g/ff3sT+Ztb97+joiIFGeYLzunO6TofwMplrejzis5OWBI\n", + "b56onpY1j8OMnsUjKBif/9paPv81fR5PyUn+7H/xdPrfjL/1RSqKov9CRP41EXkQRdG3IvLvici/\n", + "HkXRH4iO9S9F5N8REZmm6adRFP2XIvJTUW+Of3d6H3EmRIgQIUKECBHiX4L4W1+kpmn6t9+z+T/5\n", + "Fd//xyLyj/+2/Tbt23ulwWmqb35MsCxQrtmf/G3VCJsFrWqOd5o9LNe+1E7gnTM0RBIDSjRgRZaR\n", + "C3SEV+woYW8k/e1m6UjDAkrc6YnUWQdd1RxOjj5cnf1IRERWpED99PJfERGRn3/3R7hmP1aWAhnI\n", + "yC8NJOeB/MdsOZeS1IItjtuayOP4Tdf76mNtq85OryGJiUTc62e80Kygup0SYTRFl0kIJVwvtJ7g\n", + "eHLpBis1jsVXzqZEsdsPKmzgAAAgAElEQVTzigSq3EYEp+WqoXoZlVqbYve+csJwZGTj3FcVW6zi\n", + "x87f42+BdpwtCPURve8m02Dl/SJeBs7+g1Omq5KmpnJ13ONV4SvddaFIQP7A0ZSb6++xY1/p9UBC\n", + "djvdttqQ6ndmbul+//MlVnqFr6qaSduiP5JiNtYvCyKgV5A9KEtfuW6xmu1wc4zgKyLy2WdKLP3+\n", + "u+/8+oEObB55G7a4F9XRV4nbM1w3KQKbJMREFQDVXq/j8lJJ7q9evZg/W0JW5OaGVK/RQStSMbY7\n", + "vKVijwHHyokAb+X8BSHMPcrpS8w7I3vooQ25PLk1BwQqSjgcgH7HhH6hP18+eDxve/lar21ByMnG\n", + "+il5/CVAlid5V2pEbNyTrMtyhbFLXxuBkh6OpOxtauxcZAKCeH2i8nso8BeQuKgO/phYr7TvsLOB\n", + "AScTKXAbGZm9E8XGJzkAmFJ9tnQkfq4QKfE9IiJnILEz+vgWMjJ96XPNeqUl+V1HzxioZ68KP9YE\n", + "nYKRqLx2L6K5vxIWgIvNUkZabA4jSQigJDk5SyzMUYMQ0RYK4AkV9Nwe9Xk2ZBjrjd/YbaLj5AeU\n", + "ufnNRyqFcn7h1x+hUOXlzucJk2zo6P7vUdBz2vvYNX/YnsbpRftL/e0OvoKEKn1//VPdR+vz2oj7\n", + "lOd+/TFI9BJ5QcuDjT47Tieau1AotSh9jP/86z/Vc3uAa2n9WWvXlRU+1xk/v6N+YkVjy9zvfwJP\n", + "1oiL3OyekSvGPQT2PRGUzUOECBEiRIgQIT4wwotUiBAhQoQIESLEB8ZHMy2OZSVN6wS3fIFU3EhK\n", + "zEjzrJYO2Z9vn4iISLl2yO5nIKWVa4KAM6RqKiKgIZNmukgTEas7pALZoNTSQkzEXMYKH04EWZei\n", + "eOPtzomlP3j0eyIiEhEp9tFWCxpvNwrd3oqbbKbQqUgzghMBhVeUbjDJXCYgT5NCxmzkG0FUygij\n", + "IiLxWXfvnEoi4pkppGRE+rN9NH6fFhuFRSNKd2XYz2pJCswgLKaxp3ZaQPrjwLpA+nkGCPhYe8ru\n", + "7HyBS/bvl9BH2YlDuyl0puLR4dntQmHuZe7XeHP3CxER6RO/nhbEwhpqyqaJJOKK+gmlNk0BnbXF\n", + "GriBPti4yWcDU+OE9HZ+9MlviYjIixe/mLedkA5NzPiW+yuGwtUDVoJGG5Z+DdWoqa8yccjcNKVO\n", + "ZFD76InC6BPpyLx+o+34+LGSxy8vPRVp5rqv3349b/ut3/5Hul8ilh9vFdJ/8MSPbwrMXUO6aLPh\n", + "sZ/72Tl0ZNAnWYl7De2an/3U9WQeX2mqbGJlcfSnntJdphi+WHifMPL48+c+7s6RDpz7GI3rAXoz\n", + "LZshg1qwpHlif9Dr2a49tWBGuynd/4cPde56+ewbPyfcivWazH0xP90i3bvd+H4t3behNOaXXygB\n", + "+JNPnvjhQVuYWj/+4Y1qek1EdrZ0aEdFCbNGGTgD67X39VmBndJtAiP1iEjRI3SOJkpjjkjfMAE9\n", + "zi21SarUoGPEMJ6XhadiMqS5P3vixeGvoRV1TYUilpV/TKn1qdXvNbXPHWZWvWv9ubNDCvwx7sm9\n", + "tFNm5+bXtTS9Q0r/ZBlMm4mAbirfOX2vzHXMdCOnpTEX1Xq/Vpl//xM8E55QG1qmOqY0egNdsubk\n", + "89n1nZHI/V7XKOgYqADG+nhJziNVg4IiHKOh58pMraA05g5pvqTxc1+X2j/ZFaJqdT4tSKtPoAe3\n", + "pXTvd880tZhWOp/3Gb07wO1kvXHJyhw6Yq/ffO/bcM9ypo9EZgLt597i/tgzQUSko+Ke90VApEKE\n", + "CBEiRIgQIT4wPh4iNT26V8LYpVB9rt8tMVxufLX26ZPfFBGRqvPvPbrQ1XTXfDlvS6GsfCCp8hhk\n", + "wxEr17b1N/PFGitXNtiJ3l1VLzb69r0glCqJ4CGVkCTAXlc9m/KR7w6r7hwq3iWRHuPRPLfImwnn\n", + "Odx7GUYJO8kElChX3pPaeQQ0pSBSZAsS6RLecQtCpDKoR7OHVDr/y6X+irqVC/dVstLtJTyXREQy\n", + "tN116/fJroeJ8j1U221l2NIqYLcH2T8njbFcz6+gFVmL1c92RarckyECvpp/VKoUxdudIwIy6Epr\n", + "ATmFA68+gaqMtKqOQbZuW19Btwdtn5dvnJT98ELb58nGPfESeAI+euDFC/s7/U21A2Gbrt9Qr2bt\n", + "fXgBD7esdFRhmIsCvO/mID6XF94m9Qmr1Nbv8ZPHivAsgeBldG++e6nI6dOnvvo3X8OavMkuUXZ9\n", + "IMJyBHSACyW6g7a1jUMRkb419Wq0NaGqBoR2JDVgStkjlTobUX5HJfHbjSFdhJJiPz0VFJyg7G6E\n", + "YvZGK3MjETv6NGEwttSGprKcE0rV4fxG8vWyEfvpZ+4Tt7u7xTX4/qxvGyLcEEpq6tnVnW/bALF6\n", + "89IR8bKEhyX5+u3BwJ1IxTk2XzGSoL5An00wd/B4NVRvovEnKHGfuAAEHmoRlZXHkJ8R8nqcQMqO\n", + "cpp3IaMwmer+5G3YQ8JlJF2X3/zJ74qIyJ988ct52w4If135/HOG+5ORU0IOkjH7fw4o0Hl1q+05\n", + "crHHQsddR84OaYExS2RzMUmW2MdEg7k1SZ0UvkQ7Rr2f09VGx1sf6zmtEn9OlkAET5XPE68hsZLf\n", + "+ZxwfdJzfnbwtn4OUv7xSOeO/Z1v/HmyWel+yg0h4TBj7TodlDX1//k5Vfs+zIGBvXNHEOuvLshR\n", + "BE1Laj5mKCFtxtIRuu/vb3XuXq2dbG9yIlnsz98RKFkae6GKQM4lpUxUFmv715O3Z9uZd6+fVB4t\n", + "RMQLYf5mBEQqRIgQIUKECBHiAyO8SIUIESJEiBAhQnxgfLTU3jQtJSXhk92two5F4ZBtV+nfT88d\n", + "Yrs417RI3jrstyw1fcGmoRlSNevU4cnlWmG8HMq2t6TcOhrcFztk3QP2PjFhGyS2hFNmMFfNKFVm\n", + "+i2pONzY1watQ7F38muYoLvUE7HZVMFZiqWCAm1MMLIRlbekNn7ozYyWCJgg8vcwGd5VpLFhXNue\n", + "tTNAjiQtkHpEW8Rssqowa0747MVDhaebtw6HHk/6d0Kpghxk02g2/vQ2fAPdnYdnnkY0aHlFmiGm\n", + "lFs1rmO1zD/BNRCMCx2Xy62TEt9+B0X7Se/XxT11fGh7UWoxgvZXTQR867HffOOkbIO7CzLhXaIv\n", + "JrH/1kSbY/QFK3oQcfLqQGasZvKcxn6eKe7PQDpiFdLWfe33M0e6kw0/J+xvD9JpRErkiyW+R2nk\n", + "O2g6/e7v/9687Y//9P8WEZEffuppTOv/Lesyoc0ePfB0Y4P0TQ+y88NL17g6nnQfmzWTrfUauQBh\n", + "udK2u772thsGI5t7yqQFodZUx0VE2pOeU7l4t7BhwDqzJG07y0qyzrBx3FsyQ02Q0hpJx62udexw\n", + "quzyoc5nxwORrbHrDvfOVMJFRAbMDyVpppnGTUpzUnVAmi32Noky09GjMW7XS5p6Jptkavflyts/\n", + "Rwo4JX2yWWOHiP3mFR8RLyEuzbSaHBhqTVslZJYenWv/mJbaF4ZnPq6OlaaHv3vjBQMTzoVJ1B2K\n", + "MgbSgOpSK0rw61+skQI6+tgZcC7Hk/b1itqrqJF2pfYyw9+EH6c9TIOJKG7z6anz585qo20S02/L\n", + "CQVNBZwViLA+9drGNzfeX57f6Pd6utf7k57TXe/zdJVo/4tIgX6NFPCWtPUuztE/SayxRgqwhRI4\n", + "NeF8TjGl0Qekx+qR0rKj9slj7UbSpVEUaDyZ+XhDWnFDo21yRGFNT+4Ulyslsbe1zzX1nMYnWgTm\n", + "sZGoAnYZNRVFjXgmxROlpanN3hcBkQoRIkSIECFChPjA+GiIVNM0syKsiIhgRd4Ssbs+mWIwrZJB\n", + "/O2FVj8g8Y0E5sQgZRapr9xNvdw8nJ48ctJnjbdfcsGaFU4H8rBrKn2rb+lN19TDyyWdE/692bnX\n", + "W4zjLrMrnLe/rR8hBdFMjn4lEd6wiRw3RPpWP4xOWJxifXM+WzkiVU66mrxuXvo54bddB/SLCJsT\n", + "yHxJ6avlCehTRuXyHf5uSFnWiN1rIjZvNvr3jwsnBb4F6shed6YbHaE0uMj8+0miiNT1nZMto1Gv\n", + "a7MiIiIYi9XJyd4DvKtWay9/TrByWueOSC0ea9s+++IP9fi0Wi6Wei7LpZPo+wRltTtvV1vBDqRA\n", + "/OyFEl8LQg4fXOm55CQxYaZdM7GXeyC8A/sTrf67Fa7PV2t5pufU0n3qB+0L7D+5yKDeTaiL+fN9\n", + "8kTRpBev/LoalP3HhH598vSHen3fO9L49KkWeySJj+fn3ysptCRl/0tIHfSE0tiYMTmPgSQMrG9c\n", + "XXq/OsBDL2UEBSvNR48cEashz9ARed3QlGHv25ZbRT06kGdzQlUyjPueUDVDrnIiWzdAAlMq6+6B\n", + "jrDXYY6iEFq4z7IjJSmwH251zmhAlM5i6utAlUYizBux/EiSBPEAUjSXtaNAZiQSr6Fu/CAw78AW\n", + "CBqjeim8CFMih1vbUQ2BJIZOU0n+/CchgkmpjTGRArsATYu2Ou7ih+7rePpr7Z+v6ftff6lyIjeE\n", + "YHx3rej0ckPXCqRrd3ICcgd/wjR3xMHU++0ecv+f8JDpO7+Jp6Op6NO1AokZJyroAQE+KvyZcARy\n", + "tky9AMX6xBKFDzwiDHS+IVTlFvepp+dUigKJiLYtMD4b3iMuo1yQJABU0Seau8yLco+xUzWEfqKP\n", + "sV9kCxQ1IbV7M/59/doRxuRK7+OqJoQVKFpEkgMdPDkjqI0PVKj2Gr6iLKvTDbrfvvUCiCX8B+OO\n", + "SPTotDfkU9q3es4P135P4oLvwrsREKkQIUKECBEiRIgPjPAiFSJEiBAhQoQI8YHx0VJ7Q9/dgwLL\n", + "zAiDRIREamMiFe8aWkh15fD8Hkq1NRF1swVMIyndsCg1tTKOetxmdNivWCu0OBHpsUAqRDi1BUj3\n", + "eHLC4B2UgNvB00gXSEckgzfxrKwK2HW9cEPTw1Gh6JHMIC210AkR9pACS3qHttdQcV+SufIWcPzu\n", + "uROwjTT/tn6G/bvG1QS49+yM0kOAQGtKAZoHdEw6KlMCjRFqz7FXAuCS1LbPkUa5uyZz48Hgc4XA\n", + "15SerBtNBb29dn2cNFaYvx38WElq5G2//9e3qinW0jk9uPgNEfFUnIjIdqlpvuHJPxARkV/81f81\n", + "f5YN1q4Oz/eJqfh6Ox2g/cQkxgg6Mm/evp63DTHMVcXJlmacbZJia0ottkiBkbSRdL2lVp2wPpqR\n", + "dUTmzmKmod4nOyMtU/qsR+rry6+/wkesZ4SCDSJ7JzCjvXnj6ZHPPtNigLHzMXkCifvs3NOi1otS\n", + "GveWW1jBvDci0ml3gKFo5tss7WR6XiKell4sPd1t6faIlNJHjONy4d8rQQa2dEZP+lRmoM2UgWav\n", + "fT0nFW/LlHIRhY0dVgw3M+IlEbVNM0moP5lZcAt3gKr2NGoOc/O8JG0rFDSUpffTznR0SBcvQhoj\n", + "zT3dUqMoISYKhBkOx3ZhlIo1de6xIWI92r0ntf9UTLOPUtWj9omJ0veWeoq3rlXWv9G0eALV/5hS\n", + "i49++++JiMiffO+aUSn0ob754q/mbTdQzL6lZ8JU63xXE3n8AJL/QKRoa6cCzTmNTDqGZhblZ20M\n", + "R7Qtwhw/UAowRvowS31OGqAKf6R0Ww2mvtU9daQwvoeO1oHSqA369T2ye4r2pzRWijETp97HM6R7\n", + "G9JbtCIw1k887nU/+1vt/5VnUaXHs2Ck/iexnjMbH8ct5i5ylri71c+zjfeJAdSPbGDyvh5wmvUO\n", + "vQ1vdt/jPLhQR69xTYT5KUHxRk66iCi2YbNyc9mISG19syGhq/dEQKRChAgRIkSIECE+MD6e/MHQ\n", + "yxj7KqCA2mxHC5hhAgGb1LbvoI68Jw+h49FW+P7jE6CTlo4R4S21AHGsIGmACqqnWeRNYnIBKcka\n", + "9EY2JGLnCWXaEykgl62u0lZcJgvfLUMBeBVoK82epRagKG4luiIiO7z913R887PLy9+et60LRQIe\n", + "kVL2L77SFd5gaE5GyupYhdY1kWMhRTFQaeiEFWlLy/S213vy0sEXWeWKSI3ka5ShaGC5YEq/Hs/a\n", + "kFfQhk4Nk6N0dwe9hhOtiABmzNIIIiId6nNfvCSieqLX+/jc26kXI8r/SEREHnzuK5PXUNG9Svka\n", + "9PyigZTF0WkbUvEtsDozJWYRkaHVbREp2tdAFtMlzoOIwLs7FEDkjqCkkd7XqSHCLPo4o5mpgJRO\n", + "K63DUfvWduXH70BaT9fa1jn1yQH3uCRErgKxtWByNIi/9YGQNvT1DfnEZRhvLRPlC702azru/6Z2\n", + "z75+I8rZ17xCxIq84zJ1oBQsidKBoL0k5Mq8KIultRf5xQGdyknCwjz09reEiOZYzZP/pBGws5RK\n", + "12NDs72frkAUH2k82z0rQcruyX+0yIE05X5OTfsu2XeyIg6SmBmALGfk/2eXNhBRd0DftvteEIJn\n", + "8hsjQxKYu7MLR5MnIM3Rwoni/VGJ4nHjaHqUYd9UABFfaUFDBNV/eetSBwmKAX7z89+Yt/0P/+c/\n", + "FxGRu9rHRDvgvpJ0y7fXisSPhHTUg6E0PiYilN+XC6jDT95eY2Pl+kRAN0Q4p6IokPHrg/cn846t\n", + "ckaucfzJz70XPRcD02IqNmghO9PR/TL0832uFBNhJam5HZSEUpokBH3vhCKovvVrrA769xFuExUV\n", + "MZiKeUzPmhJSQwRSSg9F/aH3flrheXNIKBMFNJ1lP0xGpgLqFNFzugI5n8Ds+dlumSkRkRHPsZGK\n", + "QqxQpCeNoQzFQFHuWSdJA9k8RIgQIUKECBHi7yTCi1SIECFChAgRIsQHxkdL7e3313K+dcXoxhDQ\n", + "yd/tBmB1rLd0u1Ni+YHI5gPg+XswOkiMnILaQ+17MIVXgvEroKJjTOkunEoUObRt5r4ppQVHCKRM\n", + "mcPdPVI2Y0bHAEFzNggliHO1VFIwK1bHnebKBjINLgpoW5HJYmO6GympWINE+PDyJ/O2r7/7C5yw\n", + "tudEBMcIBPyWIFuB7klSMj4LYnVCaSxohVSVp2C+fa3aLiOdZ4S/U4KqT42eezErNXu7JiBMbtau\n", + "dn13q2kRNo2doCPEei9Gym4pZfLNsz8XEZFF6f0uh0HoBBg7Xzs5egktkpbI2UluqvSkgI9r6IhY\n", + "Wx/1vm+IFDy2SBUQ2beJNC1qaST2PU2QUVuRGfMy0VQZE7YPvRJvp9FTJsOgv2lG0kyCBtC9VJkR\n", + "6mNtE1bstrTcy5euLfXDH2ra5c3Rt11c6pj54udfzds+faoabQWlkay/lQtSFkc6wlIQDNmPpvJP\n", + "WjgD2qlpfFyVgOon6msxNOBY78n0oBJKIyVo8ARzBx3KyfFkUN5CnyxekBn6aER1/+0sM0fpvsHG\n", + "Px3/NJkrgo+xCWmGHqTn8wsi7CNXklG6zVKwI811gxHliWx8ArE6L8mVYFb+p9+aUj5SYCM5MMzD\n", + "k1KGCf6OSFtvWlm/p9TSSue44db13iboTU0Ju0zotrhUAnL1wsn2/U7nxJHG+sWF7rdkCobdPWqT\n", + "Ear94+Bz/PlKC34WC7/HMead5QJ9iPpwd4IW2Ojb8lK/39CY6EGGHiKipZzmh8y8LSpA81j4PTED\n", + "8TIxjTOffxqooh+P3tcr+5zuyRLXUC642ED/XRApfLAULP22BwGeMoVi3aibNxI5He1q87XuV/fB\n", + "emMN5skbcoVoTbcw8mtM4R7Rkir9gFSqFZlMlNq0KWukedrMsI8nek7g/DhJd7L0KeknZgWeSQue\n", + "i4KyeYgQIUKECBEixN9JfDz5g26U08nJqal5rMWk2D1AYXfwt/XrO12R1PSWnmNVFRHSUAOl6anU\n", + "PY70TfgAYrlEvjKPRqiNT1QajpfUfnBELMZKZCZJisjlpa4Yb09e1v/gUq+HuK4ygjRq6FdGROz1\n", + "Us99aAj9KPF3QiReQ8noPAeooe+OrjZ+sVFEICNi3dVDvcZX11ouGt0jLKI0dPK2ttX6QKuVFCt3\n", + "JjHn8BU70Crp1VtILFDp/mqFVdz07mrC/Pwm8jRKoET/4MpX5Buspr/5/st5m5XLRiR10XcD9k+k\n", + "ZKx6vvz+T+ZN8VOU3ydKjk8G7y8bEKHPNy4hYGTnNHWUbAT6SFZXcnOr287P/HsRiO1t5dc4Qqk6\n", + "zrTtmt77pGBVxaslk0IY2cNs/oz6hJUd00pqANLB7gElELObG+1jFxdehvz6tfanH//YHQD+4i/+\n", + "TEREfud3nbD/5S8VfTzfOtl4hRL/mojl5h6wImXrxYysYKVJfaMHsTslREBmKRRSMQZinRJR3han\n", + "TOw24nnM6vGF/j3hWDmR6E35P2GkGwrLa7pWQ5qeffPVvO2Tz7U/NZUfvwTZtz7RPUZ5dsxFLhiL\n", + "6Yym+RjOMYYYkTWvO0ak7O/9wVW0J4yJ3Y0Tm5dLvf/LBUkiRCanAakVmmtaIKH5uaOksjBUiVbw\n", + "GMdJ79dv9fzxyufpfn+N/fl8KjYHAX2Pn7jX5qu/VF/Hiojdr251H4zSFigsici7dJrM/9LHZFnA\n", + "AYAQrgyT7BIEZwIQJUV/TSJHmgcQ28/PXMLhZq/q3fudFyWYKvrYUt9Ngdyw7AYKcGyO7+n77Un7\n", + "xoGKrczPktFU1FpIklNBE4jXlEyRDJIpXOzQ9u8iZwnQ0Rz7Y4AmRtYlK7lNgNKdSCYH/re7g5/7\n", + "ONr483ZaA7Fmk4O5GAIyOfdU9HEszjANmGPrlqR7UFDVEUqfgHifk0xCucS8m/q5jySt8L4IiFSI\n", + "ECFChAgRIsQHxkdDpKI4kdORBDEhCEZ6hJKkulpg3kRt5YqEEp1vdPXXib9V7yotex8Hz1uPgtUR\n", + "lhhjTytdLILYU6c8A6oU00oLH6edr+CWEVY19PZ/Ourx15ckiZDrKr3pzFfM35YziH8Wha/W38Jj\n", + "zkQQRUQmvDnTC/ksOni7/37e9vBSV0cji8lZDht+RXFM6BucrseOSuNrc5Vn3pr+m1ObFJH+Zlo6\n", + "0lGBN5bQNRrC1RPCaJygKIXgGon/bTZof1pCPXygiMntna9gDwfc14R4JgKBVeoTZa77y8i78dmr\n", + "vxYRkcutrlJK4j5Y6fTjS18RH6G70LLQIFCUmHkGWDK9JvFRUx0oFtTuB6w6sfqJSP4hQbsfar+v\n", + "C3NpJ6E7Q04y4vJEWFUPVNZryMnQUel6aStsE+Hzzyas8CoqdX9wqejc1198MW8rwPnjY1WVyQr4\n", + "ODEUsyOfuOXSOIcQySUH9w7XtWZBVCBMEy1JTUAv5lGBZmLuR47zjHg8Q85hwraE+Gsj2BQxLfVN\n", + "zHAa+Vh6jJdvCBFGP+Vl9c0RvnrUT2MgYcNI5f8YFCUQ0ZrEL9MZxSakZTSvNx/rtzc6d/D97Gvd\n", + "D89nhgCedlTqbWKmEGdltGy1An+FZCoKcF6i2O9TnGtn74/kNQqkIyLpinwLMU9CDhITjAQKUCxI\n", + "mgBjeLd3VG2P4+8J6avBKy1JuqJBv+8n5xIar7InRKoZ9DedyX8whAMOb1EQRxbnOVK5fn3UdkoI\n", + "EYvsmRX7/RSTPyDO6YDzO4K3Wbd+XwEqSt/791vIDqTUJ9tZJoC4X7jEhIR7O0hnNC3zm4CSUsYk\n", + "wnXn6AsZeZ3WJudzTzpI99dWhAihH1cVcxT13zL373XzGKP53BApjJeYMk3rxHhT1P5AdRtC805A\n", + "wtgT82yj7bOg4y8Kk1PxdwzOIrwvAiIVIkSIECFChAjxgRFepEKECBEiRIgQIT4wPlpqr8xjaUjG\n", + "3IioKZVGW4l/3zs8fXsHojSlm2KQjBeRw43xWmHJw/HZvM38tAymTOn7NVSh88SVmIcaEOfS4dG6\n", + "U6g6I2JrhPRZGrMkACB7IsVngHFTIwVTyq4DyZgh3h3Sg0VO3khIX7ASawrCcpc7sfPN3de4HieF\n", + "joC7sxxwJ0GXPWDUaXhXMXk4MtEO5desrDzp92K6nizB+RE8bMzyYWBoG+kmpAJjVpsHUXW1+LF/\n", + "H5Du4ydO9r1o9J69eOGkfCPb9pRaLJAWWKXe7ZtW2/2b7/9SRESeLN1/8Gxzhd95KqJFiXdLatN9\n", + "CRifSMwZjhuTsv7tnab5tiSnYYj1gP2mwmXVelzuV/tOS8dbuicZoGjqkpJlSNUwURqp7InSQlWl\n", + "6fUMqbWKyf5IN7965V6HBVKGHaso48BnZz52zMPtePD0vctTUKpELLWH9ByprreWliKvTatxyKms\n", + "e5Qe+yD/s8j+JaI+Ununyu+JXXcMdW6htG+av3u+lp7enTw9VEFWYGSvNaQgEpqnalOFJ2K3FbdM\n", + "xGlYgWRthQ2UnfRtdJ4nEI9j8no0RwGbV0VElkjjtnz9INsWCann416YE8Mk76Yx64ZSe3MqkI6P\n", + "1GKyonsHeZSE5sSp1HEcZ/7bAcVAKcZQ+4akEdD+d3siR486J2/Iw/CwU0rHiYodOjxPErpPluYe\n", + "SHanAZE/ncwHkjUx3vWfXOD5k9L8F6EAKE2IKoL+VN2TnbGL8DbuBW4Hkx5joDFpqUWW8LAU6EBU\n", + "DTOoqMnr0eaJgapiWozTuvPfWoZwYAeCSOfCHGnpKCNJEpP/oNMcB3MxoHOq9O+m9uMvOxSKTT5O\n", + "28Z8Kr2PSYd+Wuo9LOmWrOA80cee2rXn2Q0py5tn7NmG0ugpxmTm6dO+PuEa/BhV9atflQIiFSJE\n", + "iBAhQoQI8YHx0RCpRVlKS6slW3V1hFbEOL1Xr52wO8AZ20oURVz8MolJOK83US1ekaJ0H6tAFsab\n", + "FibWRmgF3uZtZS7iK8Ju8FVSXqioW1X5sQZbJbDQHVZdJioYExHxCCJeRyTO3VGve0WoyhKIxRi9\n", + "i/RERKzbVUrGLBJyuh7wpg2ickraDEaonZhYblILdA2jIRFcFQASZU7ExsiIf7RtxP3sCGHYV4oi\n", + "9VjVFYzSHUBwJBJrAXFAW7WLiDzcqjxCmvn3vn2hPnlHWpEZ2ZnJq2ugVHfXSp5+0zixe7PVVVhL\n", + "Hm4trrXv9vQ9rEdWq+AAACAASURBVKoW3v7FFuX01J+W8LNLiFDegVw9ogBBNr4ymnCt242jb/ud\n", + "IqwHQhPTVq8niUmkFqvvKCExRUNOU+qnuJ4GK9IDXdfF1RPsg+4X0Jcteei5JIQfqwDx3bz5RFxY\n", + "9XDwleODhw9FROSIJTT7gKUop+5IaiNBiTtVOkuMfjy+hwCe3OvjKGefvO0EbTElhup5f82w6q5q\n", + "v/8T+jCvtPfwGlwQ0rTfKxK3pAKACefEKMkScgsJwU6VeQICQYgYfUDcv349p2+/+mre9uiR9t3V\n", + "2vtOD4+7h48f029RqED3zu5BHL2LiPVAH8rU77/Am68nqYMI1z/GLjUQW1n73ufOtNSxG9OaPoqt\n", + "KEiPf3PniOjztzqvxSs/qSOQrloc/ewhSdA1LH+j7VSTJ+UCYsN9w/OkydToPmqaVw2lvD34/d+m\n", + "iuZ15KFpRUsjo08ziX7eJHWFohwak9Nozx0UO1DbZMm7YzhPDdX3/dq9Y0QyRxahn7hQQf9tyLx0\n", + "jBbYRrI/pR1L2zAlYnkD1JdqSOYiBhbJnqUeUn7tMDFZb5TOiOrNu96ROYo3FhtGn1FEQMLV5t3J\n", + "52SemFHOvnr23CfkahYfpQKE7t0xyBEQqRAhQoQIESJEiA+M8CIVIkSIECFChAjxgfHRUntxvpJ8\n", + "RXAeiIrxQJpJgNvy1NMdAhjx1bX7NR1bhXuXRBQ3r52EUkuzT97MIaVUADy0bnauBZMipdQSFrtA\n", + "6imJyetsj9Tj4NB+BLLb8R5krFCxeeeNk0PRC2jGVA2prePudKT701qWgeF2kEFJsFX6BVI7qcPt\n", + "lqookU5gFXUTUe4nUodGCm6KHOJN0Hg9aXaYplHUsoowFGs53ZKaZgqTN/V7h1tt4440PoZJv/fT\n", + "v/7LedsnUDn/0eeuInx+rpo9qzNX5TbNmIhg5AHpq6xwYq2pu2+gtj1rUolIg7TX7uAk9kN9wDX4\n", + "PVmb3HxCWjggG49Hb8/t2QOcB30P6bhhxD1piew8aFqmq70Pb0vVtDqSin21RyqAjj9stX+mQiq+\n", + "UEwuM/baMqJog//TPnrzZOTUQoJ/2cNO98GK6ZdXeu6stm06MtwlJtPxAbOTj9UCl09I48e0wpqW\n", + "tJVwLgn56pm2TkYkUsGYzVnbykj+IKLHTM6HttM0MtkchF1KBXQ4lumeiYjcQQOuIxX3zPy/jkTU\n", + "xjmPlIJOQAYuTEWcFLuP0KJarz2NNPRGWPfx/PLZtyIi8slnP/TvTXouXGywWsG7kfTrYqSNLKOb\n", + "URo9XekYKxak2I/+1FPK0pSwp7eu95Q80FRxSt6Zs5MBF/mAPJw0+tuzs4fzZzdf/ExERF7XPv+v\n", + "kDK8rXxMJKm2Ewnbz04JKaW7jQ4y3fOJQ7oX97imwooCE29RsD6f7q+mjp3he+zrZlnmiDxWGxR7\n", + "5FS8U5g/nc0rBHdE7yk2yCzdRlpIJaotMkrLm95gR1SRGHOsFUeIiLSNpQX9uDkKXiLM3ff8KvF8\n", + "rqiIwdgb7Oea4pxyIpbbdfTkCWlzRtsSeR9/piiUSsnDtkMKtqG5q4In7ETtZBp8Wcp3Ra+noblr\n", + "wPmNI7kcNIFsHiJEiBAhQoQI8XcSH89rL84kzn0Vkk1KQCwi39Yc9S34bEWrFdRYJnTqB7zVD2Ts\n", + "VsCzL8n8t22jZbIxSJwxv60nIIeT/15T61tqHztyNGIlOJCDeFuZYjOV9YNsN5JPVQp1VAOzOlL4\n", + "rktdOvVEIraF+EgKr1alGlGpfQSUboq41BQr7TW7yus1bnANNaEVZsDUEom8xsp4IHXmFCuniZCG\n", + "ywv1zmqpJNxKsltaJaxB/M+IbH5RKEoTtUZwdXLshJXw4e0v5m0v3mhZ88W5yxR8+lTv9cXSV4nH\n", + "p0/138rv53KDEloiAPc1VKHRx0pmgoIcuj/4SreDN9Rm48c/nZQMm5MqvslfpNR3DfUi5QTpWxBv\n", + "M6A6RGqcTlitUWl2ghL2Vexq6/te0Yfjye+JqdgvyEOqg4fZSP6DhtwMKGFfrchDDqTskVTcE6zm\n", + "Y1a2x4qckaZrKLoz2XtR6HGXRPbvgQj2psRM43oC0tWRz5UhRxMdKzZldUbOQPwdCbpNcc4joa6Z\n", + "eeuZX2fCsgpAxAl9OKGPZ4QSmfL4mpAuQ6JLKp1vgWy05L93dakIT137Niu46Aa7h36+Bc73QLIS\n", + "NtYePfI+ef1Kiyaa2vt/Ac/IjMrfnaDsDbpZ6PUaWrC9cG88a4uS7mENonJ5RkgftsXkLDAc1Cc1\n", + "/cRRsqnSOZms6ySNcY/HdwnLxcLmBEeJl0D1rpZP5m1jr+NqGFmdGh6CVNCSA2GPJkIfrMrGCkEm\n", + "knVA07EnpBXUNIRS2rw3Ursa2jqS1EA06G+7I/Vd+M4OqY1/ul8jpCEIabEinrRkD01DjqnU36QT\n", + "SkcErWphQbIrw6R9kbqOHHbws4QS/TjQsxOZjknIFWE070zfxxpI5O6O/Qfh7ECkcPPVGzo/RjFD\n", + "UiiOIW/CFs+nW5I6qIA0JyWhdCsds4uC7ufwLko+z8G0cSJ07H0REKkQIUKECBEiRIgPjPAiFSJE\n", + "iBAhQoQI8YHx0VJ703gfYp2QbmAALQV8XhARbwTc+/qG4DlAtlNKKQAjxSWk7XJUuDdByiAhsrkR\n", + "YSOShzbTximiYyEF2JFp7BCZZgip4wKr7EjFtTWNHqT7EjrWAXciycmMFgT8LPHrN2J5RqrsdtiW\n", + "oOW3t3qsltJy50ZQBcS7PXeCaXdUbH21eDBvSwDZ1q0bj+5PCs9fnnkKKAVhMxkcHm6QbkiJxGhQ\n", + "aV4SUdPMYkGEzTJPT3QgND45c3j+LYxJp45J5HrcjEjs59BeWpMCtqWAEjbXRDrOpGvyFZl8ZqaF\n", + "RdA6bs/FklJrd9o+U+Ztbcj7FHEfB3ma0kLrBciuMFfdUQHAza2SbVcN6U6tQewlBfr1Uq+1J30k\n", + "657M6y9yM4hlbZ1ZLExEROrKYff2Tnfy4PGn87YEmjkxFYAcYEz7eOX6RG9vNLV0du5pIdOD2lCq\n", + "zLJ2XW/aamT8jG0ppeBNvymjIgIjow+kN2WZFy5sMBPaOGMj1xzXA3I+keiPHXTXKD1TQ229o1yE\n", + "pRs5jWy0gIjmGCPvswJ+a98jQnuPdGsH/aqY0sM9HBCYAjChnZrWt11cPcTxfb8liLox90mMyYhM\n", + "4BsYAi83SI+SwvQAUamG9psuNWXIxsdLqIxz8YCZFk+kLWbm0+PNV74t0xRQglTp3Xffzp8lmONO\n", + "ZFDcDtqfFunlvG271jRfMzgpvYUGExdATCjGychtIJ5N7ZHuZUPlWXfL+3CE8dxQG/aVGUR7CirH\n", + "fMq6XDHSgmNPmAbmM8swRUJaeJhDMkpFDXCHKEufEzLToGKD7Pi+GbaIk8Yj0uWaTBX/6H38bq9/\n", + "n63NZNvHlZlwn0iDsEehyEycF2/jy60fv+2gN0YaZCPakc3N89yexXqMmu6h1Qdd71kdXq91s6Z5\n", + "osRzN6aUHVKwDRUADaDSRFS8ERMN530REKkQIUKECBEiRIgPjI8nfyDDrD4sIpKkuvoY37OqHIhY\n", + "VkEBuWEPIaw04slXkwkUaCciCmZ4Iz8cFK1ZlkTYxpKcXuAlKez8iLCLsvox8nOKQI5MC18RCBTF\n", + "mWxnpMS+gmLugdRk4cmUl1SaaWxzWn7ERsAkryNjQK4XvnI9P//RvV2IuCfU2bm29URE0POHimo8\n", + "+eR35m05Sse/f+Grup998ee4Ll9V9pBsmIiobWgfKzZPQMcGKnXNoRpvfNLVkkqDUSY8kor2cdLz\n", + "zEhZOQU5c6Ky2gkNH5Pa7QBSfkzl3BFIwSsgWGnNCrZYBdHqJ8LaYyBOukC9vN575ykXQG4W/sUG\n", + "/ncRldUu0ccWha6mB6rX3oPY/PotqY2jK6Q5raBxk5e5I4yGeo40JsSKFojsb6vv3kq9iWFqZOOB\n", + "ybH47es3r+dtj5+oiva333k/SdFno8RX7gNWujGpMhtgY63OCs9GrOYS6uNez6+JGCWAdyZLXeCW\n", + "5URUbkwVeUGIGLrHXK7PxN7epCHoZgPNJKDXPfaIgFxjjJ+OVKgCX8c1+Yk2uN8xoV4Fimb2O5VQ\n", + "OCOpgwr7ZV+7ttJ5JKf5LAXqxmX1BqzGREA2cJZX34YEHDGGstKPH6EtlkuSS0j07y7yOcGGTLwk\n", + "qYMa/fjoThXJ5a/hi545uPnFX4uIowp3pLD98rUWfhzQNiIiTayE/SXd6yTVcyqIbJzkup+2JvV8\n", + "oChUzyNFcn9+3B/fHRMJIZdGjh5pXLWQ1o4J/TB0MqICDFMsSQmlHiABNKF4ybIgIiJDDHXwwvvk\n", + "Bs+6YkHOEhkyLOT2YW4YC3IPKIGspSQT0gBN2+ckZ2Ek78ZcMUhWCOeb0Di1jM2C7r/A65MLNWL8\n", + "5kjzXov5ZmQpJEMuJ3MH8P5/Aorftt4my4127GXhfX2NsZDQc6puraCKZH+A0i7YFYH9Jt8TAZEK\n", + "ESJEiBAhQoT4wAgvUiFChAgRIkSIEB8YH49sHnX3NGN6YOXjSIISEBfZU7qhAfExJthtu9LUQkr6\n", + "QDNkS6RwU1adoLFkxFERkRwqsnlKsDeg0JHyc/2oEKRBxyIiJfSRcoZRQQZOEocsOyjGDoDCMzI+\n", + "NSJuOzlhc5jhS0/jzGrLlNrcbPRYv/3p78/b/v4f/EMREbl65GTft9eajjEl+IJ0t5peUxBPLyll\n", + "Vujfx4OnliwFutt5ysLkqzpqzwXSbDFpcRyRMmhJWysBfG+K9sfaIft+NG0rMoi2FCxBy6aiHlEa\n", + "yxSAS9I7erXX69gQAb0ApF0WmtobSB+nGVSr5tS5OnMEE9aI2s6KAUrxth4PuNeUgqkTbbOCtY2Q\n", + "W8mwv9XGz22NftpRas2U1xcb0keBPtNI+SYjnk4Ej0tmitWUKkY6rEfKggsbjGTdUWrrWNm98H28\n", + "Rpav6byvPziDjhcpxV9eaAqmbciYHNdvGmxVxUr8SMUfyQwX51kTYTlvdJxmIxeboE8QsTyC2vHp\n", + "xKroMDI2Q21SsTbyek/tmiTv+R766e6WU0B6/D2Nk8VcvMCGu3ptTPaekHqxNvnmW9dRs1Qlf9/G\n", + "JKdMZhVtylRb2jImVwYjXsdEFC6Q+kzy+3pOIk7OP5G2V4l+XV65Anm7g7ZaTanFFdJ3nBc3E/DC\n", + "NaA2T3R///S//e9EROS7u+fzZzuYitdETq5QPMP9agQBu6Xxl5UYf6RVF01QdqdCpaS3VK2eb03F\n", + "HqYfxZSNfnYH8ONbejQiCkbSGVGdUpAodklpWyxmrqzzVU9zaAFaQpYT2bvEbwumtmBc05jo0Z8j\n", + "Mqh+8EgdIh5c/GjedrZSna8k+n/8eppvcO7lO9d1anUs0qGkR6HEkBHZPjeyPaU20RcHclzu4O4Q\n", + "kyvJ3zTubhsy+UZxRkqUjQL6eauMxjq6eEPzqYhpMPqWGFpyKdFSyjUVd70nAiIVIkSIECFChAjx\n", + "gfHREKlxHO6ReMfRCGZE7IUP0KIkBXSQUbuJV7X4l94LaxgFFaVvy6GAu8RqnVfQp16/n9CKPJvL\n", + "VWmla6u/iN909a17s/SVTpIoijSM3/t5JlhFmjp0Tl53uO6MSG8nkFNb9rASRbOa0d/0DX242FzN\n", + "285xLldrLwmey+/3+tvbOycMN1j17A8kZwul7JsbR6QqKBYfaFVv6uAJrdLXkDiwkm8RkQbtNNzz\n", + "dUKJOwjbXf3Kj1/Yufn1N1jBsxL0EcTTsnTkLo/1+Nu1r5Jf7n+p103eeQ/WT3G+2k7jSKRLkGJH\n", + "VrbHJY50/8uVnmjJJcz4sxocObEq8pFKohN4C0ZYYZdEGL240v1G4oTN0x3OnfZrBPgkplWTIZeE\n", + "Po0gdsb0PbsVJvsRdTwl9Lhmv9a3L7UtHj91BMGUirdn3nZjZOOElPJR6j+PAxHpTBIDkgiM9ORA\n", + "RNgHrMPqd0HecDUKUAZCScyLbpp4rQjULeWiBFwpfstFLIZITQQ/nOCTN5BfWQXZgwMRy89Q4s3I\n", + "WYTf5FTR0kNuosh8W4JS6+qE0vCF9+vtpyq7cdqRYj8IvR2RbTMUbbQtl5DnuC5CX4Dw3WsnoLgm\n", + "TZIT0mG+ci15gg6t9t0tFYUUNmcTSj2hKCQiNEVwPyXzdkq3KsHyg5/8RERE/tk/+V/nz7pc56y7\n", + "xsfwHZwHciq2sEdLQ4VCl0D68pKKh0ymgBw1UhTAjIDas8yJ8HP/ZJkO9BP2mquAyGSTX2uGtmbk\n", + "eH4+kVL5gKzMCagWeyjG+H5EfpkFZCq4AGU06R7K5kQoaGJNlLNz7U8TSdcsIWfx+OqTedvrN69w\n", + "Lu+qrRtgFpMkSwQ06UDZjDVQnWpkdMkmVJYkQNah4GIwIPxou6b2NhlafJ+ySWa7yUirOR9GhDQV\n", + "QAKTkeYYawtG2Oh63xcBkQoRIkSIECFChPjACC9SIUKECBEiRIgQHxgfLbV3PO4lJXXuHOzIvnEI\n", + "bYX0UEV6SzFIgVnKZF+9DDNgFRGpkUeZhDQzkDbZQCl42Dmc3IJEHjFkCbg/Ix2nFBBjzKlFaEaZ\n", + "KaOISApC+f7kquB3B01B5VA2jijFYNxpku6Y1dFrSuPEgCUjegfe4Tq+I72nT2EMGpXeTi/fKgR+\n", + "BJx+IpPbZ8+U0Pp89Wze1rfarl9+49tu76B6vHYYOcOfGUHWRlS+I6LwEQrxXGSQAW5vQfBckrZV\n", + "j+81RMpfT3qw06236+0CZqiFk72vVvq98zNXas+fK2FyJPJ0B6i6gLbP0Ht7GWF8JBXrEanKrvd7\n", + "kpVISx59v3GONBJda2wkYjJy3mPfMUxAV6R7VoBEulyTZk2kaYaIlHat7xaUMhpwjJb6yYB+Okae\n", + "qphwnyw9wWkEwVjoak9ZGQTe1X6eXWMkbiJnIlOSJJza07bbn7ztNmc6ZjZIC7298ZRNCny+qb1P\n", + "2N8bGms7KGqzYr2l3rqGilfkPmFVxLWnhjk94+1qBNeY0i6Npdkp3X+qYZBLyvLHkx5/dc+VAVo8\n", + "pEtkmjasgdYhfT1AvbzYOGXANHbihNMoZrLq13XCPmJqEyN59w0Z5GIOyih9V2y0bVcYQyOZoUdg\n", + "5S4pjW50jOrVi3lbudb7GZdUUIQ0X0ZK7RPoE9FElAIQkE0+aXPplIVffvczERE50Fx/RHruEPm9\n", + "22NO/OHnvzZvW6EYKF158cpdD9PkiTXYNLUVoY3znByVMYcN9JxokYJryLS+xbhuKAXbNXBxIKL2\n", + "Gs+niDTARhDkm6ONV9+vOXWs15TGFN3W0LMzEksLkt6faJrtRGP3xSud9x9duFNDC43ArqdUNQyp\n", + "TyB59zQnF9Cxak9E9obafEMFACeksUdKI6eJ6TeStt/8nPCw7LqJndcVz8mYazMuNsGvqSjN+OzF\n", + "ggyXbdDQmLA5sKVnwTAxQf3dCIhUiBAhQoQIESLEB8ZHQ6T6rpvLIUVEsnlRRVIDIErGKb99wsOO\n", + "VrUdVE9PtRPbaqzcGvLriUHUNgXyReEr83qvq5SOymXT3Ei8RE4FmnG8R0oFmvWIvdb0TTjLSe12\n", + "gidbBCVwWoWOLc6NiMC2EE4TX/2lIKqXRKKzt+U//8ufzdu+faYlw+XaV1OGIm23WoYutNK83r3U\n", + "c7qmVRWUut/ckfwA/BEjWv6ul2vszttuAnITs9edveGTKnxjnmFAAs7PSJoAqGNE9+nUgkRLvmbX\n", + "13ru5cqv9dFG23NLyMXVRlear49eANCXUA8GwjNMvqodRiM4koo9uufIZGMQ31NCGHsgFjGhBAlW\n", + "SQWtvgwAOgEtGCuqq55XVVQujnLphKQeRlsRU0l4gpVYSmTzQ6vjIyU0o5gRVpMf8WNZAUhDfpHL\n", + "taIjd7eOHGW4P4c7WsFe6X52jfcdI9ve7n2cbkEKP2EbS5IYYbypqdgC18Xos7U7e6gZcsv+e/Y3\n", + "+28aGdb2wSrmhlb1hEga8XxP12DkbZZkMdmHs8de7JBjTpioeMTmm+2SEB4UdJQgT0/s9Yh5jRXb\n", + "D3eKdPd0rXOhDFs14HqSmBWb56POf1UoxlgusA9SjI9xvh39skffWTIhFwjrlLqciHkmjqSAPcGn\n", + "MCY0Zzxq237/Quew08nb/3CA6jah6TWcEhg1KDNFvR6uHWlZAP3rR0ezk1T7bJJQQUmtnxvJnL0x\n", + "M/QrllqY0HZtT/cV8xr7uR6PILaT/EBicgoNIVL2jENhQ0soveE0q5LkZ6yIhJRO2kE/H1hOR3Rb\n", + "RwUQ377QftpT4ZU97+rW+/jsiZqahAO7kqD/01ka6p4MrPYOAj65HYy4ZzxPFmif5N48CT8/qNzz\n", + "nGSALF+/qZ6klE2aYvM6JekczLsDFQBV8FasGv/tsiTE8j0REKkQIUKECBEiRIgPjPAiFSJEiBAh\n", + "QoQI8YHx0VJ7m2wjWepw2uwjyoTJRuHGlki8qyWIigQZHluQPUkxtzpp6mckCDZHms2A/YnUVGOQ\n", + "joeWNEYABUfMvzW9IyL29YMe4+0bN+O8utDvjQOrHSv0OwGLnITJsWYyS4aaohBkTFB4itRaWjg8\n", + "WsIssyai7F9/8YXu957elO77937/t/Ucz87nz/JMUzb7xpXFExh+lhUpccNlMyfIugGkXRakAJzr\n", + "5ylphiygWDsRBJuYGjwg3ib2az2Hsnofs2IwUjZHv9YTIOiKtG36XlMqq9yJrZebRyIi8vL2q3lb\n", + "VWka43hEepBMLuNe27gniDcGBp3TGiReKMl9TZpdHdIczcn7xCozXSS/79aN6pP24ZujQ/GuHszt\n", + "r40X07YJbTeRBpPprNWkbZUj3co+xvabGCmGmNKzg+lH0Q0bUij7Z56KurvVIoYtEfsjpNn2B09B\n", + "GGF0JEL7HkRxM0Pu6fgn/PbmxlMxZ2dn+B6b7Op5xpQKeJ8CuaX+Okr32+eWxuWUoX2f033v22bK\n", + "4i0bqc8q8kSsRd/paDznSDNklJcYQLLPoMXD6VZBMQIbulpa8u7ujX8N939z5gUYg/VnSu0skA5f\n", + "rzzdaRkqI73nRDfoMWfXpA5dgCrRE9l+lswb6BGzWdgJ+zakgCLSAHv2zbf6L/ShaLqQrsI8Tamd\n", + "HGrbLE/0g6c/EBGRVUH6XGjPqiYjYyveiTy1JZHOJ9YnitLn2gjPE+5XlvrtqV+ZGnzNKUA8Y6KR\n", + "2gnz/rRk/USbO0A7yDk9rfeu6sltYrBz9+81vY6rnCggtt+u8TF5vdffrrNP520b0CI2Wyf5n07Q\n", + "+0ug47YkzbpY592c0mhdCx2pvbtCxOZ2Qdpa5mwh0XsoHUTKH0BBqGoUZ9C9XiAFvaHsW77QL3RU\n", + "qGXUioq1zWz+bYiWgXuXRETp4ReT90RApEKECBEiRIgQIT4wPhoitUjjewuTbPZ18je/HUiXGZVL\n", + "Xm4VVZjWj+dtP//6T0VE5HTy1bytTk0GQUTkBYh1l1t9de1ppWd8VvbhMbXjqSRICp+3NZXJgwB3\n", + "uyACbqyrr6EjtVUgEWkB5dqTrww6rP6TiUqDeyVqJoQ+GBExWdDrN5pssfRtT57oCuPVS1cKtzLx\n", + "AaX7cU8efiBPW8mtiMgCqNcZEcDt+gu6Jx1WdR3JH8SR7jsjZXnjWCakCmxKAEOC689JYRYrmJTI\n", + "gXkJUnhENFmoQp9ab887rLoeJ96eZyslnue0xq1bRYwqrEiyxEvNF1jNbkpfrVnZb7r0c1qsFdmL\n", + "SYF/D1X0W0LJYlxsRirWx04/byANcEvl/6ZOnK/8vn5yqdfAqM4R++1bX1UXQESWtJoW3J9TTT5t\n", + "MxJgiBAhLebDRr6GtRV5ZIQcbrXNImKMvvxeUYWLSydb30CBPiPk6Hi0wgv9/3Lp53t9ravZntAK\n", + "K6euW78GQ1oz9v+q0McJETJ06PbOES6TDoisiISkCQxV4n0cDkZOJgRpbjNfka+A8Ew0x0xAuIuS\n", + "ikxmknVC39O/DXRnIm4DL0ouwLD7k9HYaTAntSS/UsD3LKOJt0ZJekrnvlhoP+7Q7iUVu0hmKC0p\n", + "m6NQ43zpxPJZ4iTi67+/DxGRBNfa3zrCcoLExdtXeu7ffvutXwPGWNvtaJve//NzR9g3kG6YxOez\n", + "5+hPh95R9yUAuyIliZ1Mx9HYg/RMCHI6mK8nzXVArpKRS+iBPpEqvynvRwSdjfDfiwhhjVAgEsNt\n", + "IMsYfURRCpHj68HI5uQrWKCvJT53xINeTx+xny18X4k83mMuXFHxzvocaDqkUBYrKsoCAb2pCEHq\n", + "4KHX+fGPexDwY/otiqcmgpjsanuaJ1sgSzbt8/hbLvW3OT1rGoznmFTM6yPalZ4dnTk5MEoG8nyZ\n", + "+8Arsl/9qhQQqRAhQoQIESJEiA+Mj4ZItXU7l5KKyLwk5dVfhDz/duUrHcuvjsIyAbr66HvPx67h\n", + "NSXMuUDZsQlYslhXB6GxjDy8THSP/f+s1tLKQEVEYogUNpR7PVVYOdJKM0KJawzhuAWV1Q44/kAc\n", + "DTtGQofvsFrrMl+RF+UC+/X2XAHF+MEPfzhve/1ay4mvX6qA5QWhWisI7B1oBTNNJhxKAn54m6fU\n", + "s/RYdWUpuXon9i+/q6Pt6IIGrNxqIGIH8nWrQU6LEkKw0D964vmUkNFo6LcVRBIrKvU3EG29duTo\n", + "tn+Nc7LVuver883FvXMUEUm3emHcJ7bn2j/jlL2+dDW9I+TOvA5l4nJ+vY+jQOhz8PtqonLx4Kv1\n", + "Ev2JS3gbeHztWLgWvJVi6cjFZgnkrPVh38HXy1CKYuFtM5p0AZEEQQeUgjhyVn7/yQ9+Mm+7g6zA\n", + "kby2BsC+y62jfoY6nYGvxyvTN28g/kr8neNRPz+/cO6P+cmtCBG5vdVz2m5d/qJ9D0fK5AzMY+90\n", + "clRvsdDjpum7CBrPU5MRLWilm4MvyD6Zo+hvnzx6NG+rgZyNwsitjsUNiKPHO0dQIvRFEsmY78+a\n", + "vD7tjBm5NDFjFpg0wdiI5BRaQ04xrzD6nUGmoSD0uW3AKaJ7N/MlafwJtk2EcE7ggb589Xze9tX3\n", + "Kk9ihzh1ErRs3AAAIABJREFUJE0A6RhGH8xj7fLKESnzXb07OHL1+qUKho781MOYjVd+PUlux4P4\n", + "Ld2bCXPY9B7h5mTkZwI+I6THxH5ZkDOHYCv3sdkTDvNuTPvogLB1hMjOnMvO2zrGnJySIG4JFL2v\n", + "fTw1xquKfEJfrrQdR6GxsMJcBOHWY+33y+a9YaTnGZDInLlf4AGaN56IzNzYiJ5dBc75QOLE9j0z\n", + "O01T2i+yWQO9T6Q2rmmetmTXROO0yIyHTM9p8x8lj800/dWYU0CkQoQIESJEiBAhPjDCi1SIECFC\n", + "hAgRIsQHxkdL7VXHXiIqq05R4tmSD5kR9e52XkJ+ttGy1mGkknj4aa1IEmC70t9ylea0Q+kyoL1C\n", + "iEy3Vcg6Kfyc1ufbd4+F0uEDnZOVnzeDE4V789Ob/BgpIO3WiLCEek+AfZvKocgs1eMOAwP5KLV+\n", + "j7IzqTnMqrx57g3w9ClUfkFw7ghiXeL7Ty48Ffj9NSD2ltXZ9VzWpZfG5rParRNQy7Xek1IoVQSS\n", + "5V3rqYp4/r7+1YlDzHb/WYk6w/0ZDgR3I99EmT15eY3SaUqtWYZuw2rTnaUx8J3E72uMNEKSecpo\n", + "JmVTqXcHuLmr/bpeIVVxIvKyZSMyKsnOc6j3w2Rxe+FplAjpvnVBREjISrCHVhKjPxGJtYXXW0Tp\n", + "hgXStgkR5Xsj+aM/URZVBqQRUkqBjyBgjpTaWCMFZV5aIq4EfCSyc29q8BOnOyD7ca+Pa7zBPfyN\n", + "y1/368J5FjTWl4ml1qnUHP20JlV0S8cxodxSKkYi5/R4hXHKaZcWKZX+PWr3/D0joEcjuTJYQu6e\n", + "1xhU2Ym8PGcK8dnm3NOY5nGYcMoax1hQUUIOqY2ey7ZxDC7TN5Xxs0tPC55fqIxFDmJ3RuRwS6Oy\n", + "rMMC93qiVMg8uRF9QZCyiSjdEiP1mFC6/X/+F38oIiIvbn+uuyjYRQCyGpSC/eFnmoq6f5+0/V+/\n", + "dkmI2AqEKAVvU1EVed/NURRQ5iaNQeXymM/vqeijL5QJl9DbPEH+o0hHFUQet2KQkojVlRVIYeyO\n", + "VGxUIgU79b6PCgVAZ+QiEU3of1TYYfdnRW4PG3zctz4mxljpDkXu3xvxrB6s7xLd4cVznTMToQII\n", + "pPkWdPtz/Lanc2pB3i+pnyTWP2ic2IOin+V/qP+je/SUxu5xD0eq1LBiDKagLDCfDkSpOGHuTAeS\n", + "/fCP3xsBkQoRIkSIECFChPjA+GiI1Klt771wlid7W/XVhwlMtiRhsFkqUfNEK82h1rfpIvffFlgx\n", + "ZVRqnFf6hmk+QBkRoS9ArFye+eqrQFn7RESz/Q5u4USsOx0ViYqorLODxxEjBx1KVpPZ84p8gFDC\n", + "ShaCkiRwcCdivZVhloQ0LbCq2ZGY436v57JZO5pi5eF5oWjSwAhGb35J/raejbrfQ0XebHApTxe+\n", + "gu1A2G6I7F9O5mtGhD0UBaSRv97XzRvsF+dGKwjzE4tYfHKEI33rDXXs4FZOq6RX8OKLqPw5RTsl\n", + "GZHy14pOZSXc0sXjdMT1TI40CSQZOhJa3R0hoEdl+kc4vWcssDqbJ/r3SojYXUZ6bjfUJzqgZX3s\n", + "fbLDynBROKpUNvBfWzgisztq39mTJMIZdr0g0dF81P0kuPKOVtBLoARd5fuNQMqfiGycoj37zttk\n", + "UepqtmdJDKAkDckvmBfiEWO9WJMwJFaYvA9DAu6hH+8Jk1Fh5MBQFJMBEfGSedtf17MkCsjx5INn\n", + "QqCMCCezXAGVWgPNulpTUQyUUBvylevRTwsapxH203R6/OboaMmFkezp+o08nhGxOIVg6oK1L9E/\n", + "CRCZkUAmql8+UrmPxZkKzCapX38LX8mJkM4M6GBOSONoJHZqu8kKJDpa/b/VuWN38G0Xl3rcn36t\n", + "447L+nuMCS72KJF2YHLwCf2pP1J/nkvt/Xt7lOSPMVWvGKE90+MniQvttjPSQ0hHZpdFIs0G3BAg\n", + "aDItY0pjB/cn7QjhwscxhDtzknDJgb63nc91pfnAHVnWRD+vqD83EJuelo4SZ4X2u5Q6RYWHEBdK\n", + "Zch6RECd+tYzEoKx/ua5e5gWOQo1mICPuTMn9G3CfJeSEHNi3o00x6XIClWYT1tq2BHoY80+uQug\n", + "tAu/hgKZgFRITBXSHfXR+25z0JvC4twsY/S+CIhUiBAhQoQIESLEB0Z4kQoRIkSIECFChPjA+HjK\n", + "5uVK2sEh65ujapEQh1FSkNL6yCG27579QkTu++pN0KyIB4JnRyNAkgYSCNURfpuSnkcKLZaSdiEg\n", + "4uZEdh5KhUJ78p/rUlOM9pTBbqfXdk/FODJlVxBMKWUlSIENBFn2ILayh535OsXka2QKzGfknffs\n", + "2Td6bpRavDhXONbIdhWRTmMoJUcNea3hXAZKrSQgzMf3CIPwQSIPJ+tZWekp2AypxDjmcwehGW2Y\n", + "khJwBL2tgqBwg6oXCevz6HF3RFiuoXz8feMFAGukhS/OnGyamKbOYLCzt/XmQlMcX3351/O2vNDU\n", + "Rk3pqR20ahpi+5uH4DZxYvsqW+HcyNcr1z62XCHt3Hm77vfQVmNhfeioTR2ltuA1tr4gEvtG2+nQ\n", + "err1pkNaOnUSqRHJC8hos2JwnJj/JOkuYdgtSxoTjW7cnnsKooOOWknETksHndhPEORuI1Qfbj2N\n", + "akLdTOw2AvhI4797jwZdi76dEom1QTqO032mKWXHYADf/NSYxG46UyMpUbfmNkDXaqm3nP0nYWJX\n", + "kaNBhrFQ3Bvjetzr1+r/uKLP6oP255wI4BM8wSIiWycg47IqtnFxo/foza03ntqLckuB6z2+u/VU\n", + "UAvidUE6ZqZZlC1IRd9oE6RZZX9PDal4o0/88U//wo+B1Od2o/PV82tXNq/32nafPHFfR1Pljigx\n", + "f4B+WZF7yrTAHMspoAG0kXpPjg4rpO9t/i19vCaFmbOR12MKWgBRQBr0iY5TdujQE+EXGeaMlvwP\n", + "Y/SdMjHdPZ9rlih8ySgVmYmmT3PyNTzuTAmc0l055l8aT5bGbEirbgvdsGbrc+w53EBS6OxdUXHA\n", + "Fqnoc+r/b15pP12tPbVbnulcyBp4Juk0UTv18FG93vs5dUe9ninR628bmkNQlFWsqP+DbsBSlT1S\n", + "rwOR0idoO1b+mBA5WJ/18xxYS/I9ERCpECFChAgRIkSID4yPhkg9vLqSl3smkcIbihzUzacqIr8m\n", + "83ViVrD56dRE4rzBW22aMgEUzummcEyE9R5v02/35OEl+nme+dt3BLfqLGdfJbyJd6SifAB5nlCf\n", + "DKTNMW7u/05cPTtb+PnOKsYDSR0AMSnp+CVWn0nmiNTpUt/Yb8h9+/T8OxEReXCh5MmCyHzXx1/i\n", + "RHy/Dx+qn+FycvTh/Ey3PXr0+byt+VZXDt++crLx6xe6n/3K5QQerfS4I3kXDpm22QlkvpLK6hdQ\n", + "7G3I1+046HUVTLaFO/0ipvuJVVdLxPa70w0+82OsoEb/8EKva7166te6ULmIz//e35+3/dnP/0cR\n", + "Ebm9++m8rTpCWZeQ09jKdIlYnkdW6u5tfIIkQITvbUpHH8zj60hkY1OCrlsqv0f/zxa+bYE10kBq\n", + "xxVWcQ2hGRnQ1ghoTkqIXH3a4xpopWdEaCo/L6HO3JCKdIxScFoQS5TruS+JAZ2ASLxeQDGZ+mth\n", + "XmOkhP3qoN6RPSFCIxBT9tozGQMjfes2FGqQT50pms9zApHI7e+JS9htNUuohhWNjOTTuVqj3Wme\n", + "yjDeaDqTGMdl1M3QLiPHtxVJaACROHXsF6jjviRibZwaIkWEXbR7S3IuE64npeIV8z2tgJJ0VPt9\n", + "rPT+FGfudTrLY8SEPs7HpUIRQ1NrLtRAnyQC+revv8CO9bem9C4iUgKJvCRfPQOCbgnNrE6Q84ip\n", + "eAFtUg8+T0RAicaOfAorQxPxvCjYfxHnQRImNX46EfyRIcPREgHdkLuCUNIYt53V00d0kAX680jj\n", + "b8T8nJIkSopjMKozVkBTSaZluYVMyZ7OHQUNJ/JYvcU8+snnTigfR507r/Ds2JCESmEekrEj/U8f\n", + "KJq/Pnsyb8vXevyYJoUK3n1v33h/3mNOuCxJqR5zx3dvdU6ayFdyvYUnIjlm2KvA/kiaOB3OmQvF\n", + "7jDWKBOwxRy7IJkMlrF4XwREKkSIECFChAgR4gMjvEiFCBEiRIgQIUJ8YHy01F6ZrCXJyeQXCsgR\n", + "ayuBUHxPMBckxigiFVf8O5CR4xFpuzhyGK8GjB9Ds6ii9MjrnUKAce/vlgvA7cXS92taLT0R2ydA\n", + "5RMr9qJpY07fAXrscUoxQ8HQ1lguCeIHFN4TOTPNYW7bOYxdLADBDn6tnz7W1Nvp4CmYA3Sevv3u\n", + "KxERuTh3fZSqU8i0JNPmq05TWz/6/PfnbUuQ7S+3brz6dvkS1+wpoxPg8Rc7v8dtoZpR2wuH2/Mt\n", + "9E5Oeq0dE7aRCiGBWWmndwmDqxxkSyIHxr22zxRzWlR/U9ekYgwy6t2Nblvkfg9/9Fiv8dMHbsb7\n", + "2af/qoiI/Df/0380b9vt/oVeA8HjAui/yv1+rjHaoolMg0F2tBTwGY3I7UbTniONiRZaMc3Jj5Wj\n", + "T56RYnEBsmVH2kInKDt3ZKQ7QasrR0pxIh0z6+sRkbj3O+1PZ2ek9o5xcqq9rxkZOSFS7AKFFz0N\n", + "6C1IrCv0f9a4GjF2Ot4vDKrvyMg3Q6quJtNwazJOma1XmqLn4okeaXMr6Lh+66noCJLlnMackMaI\n", + "ycjZCkCYgG+s/HtkV5hLn5NW1v5OUyZH0rE5O4N+V21kYzZIBgWAzLVtBhxIsyePIvpk/jF+S6rQ\n", + "jSmVU7sjldejn+Y5zXXQTOOU6cbSbJRanUAyjnrSEcIpV42nyv7oL/9YRES+ev5X87brg96DBmT/\n", + "hB5TT3+gc125eLew4PkLv3enBqbdOVElQK3g/md/ppQ+bpF6NCpIyk4EcG9I2W0htaIo72tZZFqF\n", + "5B6B9GE58vGtHxGmkVi6H+lxUkwfoEWW0VSTwtKB6dArpMozKtQZsR/TZxQR2e/1V9WBDOcz9N3M\n", + "0+yXmEejWK+/bz3dukn1OfL04Wd+AnCVL7b+TMgX9owjc/dJ/7668qKc5y80ff/Vl65LNSCV/vAh\n", + "dKRICyqHufjQULHRXueH/S0VheCdYOq9PbuD7ueqpPPE+0FGKdWG5pb3RUCkQoQIESJEiBAhPjA+\n", + "GiI1Tanksa9qu8yQJkd/RtG34C72FYxxEkvSKbAV21QTYa/XS6urnr6nb51tpW+pQ+RvsHcoFy32\n", + "5MOzhayAW13JcoVSfy5/xaoiolLjFiXhCREwE/gjtfCLSgj9MDWBBZVw2nKpSahcGES9fOP7PdWq\n", + "DrwkbyTBar4gEikqh2XAKvH1q9fzZ8a/zogc/ZNPQeIbffX1+RNFZyJa1a6gbMvl30sQX5+98NX8\n", + "Hqv/HxJv79McKutYuR2prDXGKmETe6lzDiSgP/hqaQDquFh6UcABdbUxefdlRsBOfFvfQyYDq49v\n", + "vvlq/uzxwx+LiMiPf/Sb87Ztoqvvf/QP/s1526nWlfDPv/7lvM3Uuw/k03UB0mpBxQtxc8J16woq\n", + "Kh1BO8f3stjvYYsxIROhBA3GDpV69yjUaKnYIQeKkRGhfAJR/AS/trRjErXek92tlyGbsjZ7g/WG\n", + "cDGajL57tvVzGowoSxIXKxy/r/S+LwhBtIX76fBi3rYE8bgjAvZgEgaMyAARa6h4pUR/YvJ0OxPK\n", + "7bekjg2ZAlZ9ntEfIrub711KqE4KNIcq4mcS8atX3/k54fpbUlHO0nPsV4+bE6oRRabYzlIbpixP\n", + "ytYoiWdJCPvbfBBFRHp4nHbUdgX2Z8UOTJguiw3Ow49vxP6BJFFim/dSQnqOyDokvvo/AFl98ebl\n", + "vG3APZuAQnz6xCfgYqGfRdT/3r7Q/b668bmjb7SPn5+7rEOawjuP8AMjiGcpqV1DNbyv9bhclJSu\n", + "rJ28ra2gJCGkK0PbXZFTxniyZwKNE6CZ9CiSFN6lMZTiR/KkjSNtz5T68IQ+XJKx3YR5P4v8Wm9A\n", + "vK4qmoDvgPpTAUIb6d8XhOYlqT4DGjw7jhXJKuB8X5GEwqLUdjfEVUQkOYw4T+8TSzw7SiooePJI\n", + "/V5XC0epvvxOCxBevNW54JycNQr0ses3fvy4Rb++Tel7yFyQU0SE6WlD3n3m6JBSHyvoefe+CIhU\n", + "iBAhQoQIESLEB0Z4kQoRIkSIECFChPjA+Gipvao6SEOkz6k3Q12H/UYjcRM511JbCb0DlrlC1Xni\n", + "aQSDo02fSkTEfCZTKJZPox/rAPi+opRBDciUSZzjbIxL6RExxVqH/yIoj9eNQ8YFUnQl0kg1K0bP\n", + "VEHaBig+LyllAG2VKfaU2anRFF0Wu7ZLV+n+jBwuIrJdKVT9plPS94mMQkcwuhsi8b18/UxERB6e\n", + "ubZSAnPdgUi8p5NC6qwYblodt28ojXILzR7S+0qRUiqhQfK68XvSv9V7sfjs03nbCmmJ252Tja0f\n", + "TbWf0zLX9EixcFK8pYP3x1fzNpP+qWDM25Ky+x//+f+ux889FfejH2pqk81IHz/8dRERuTu9mbe9\n", + "eq5poYYKELpJj5FRf1pAR+sGaSRT0xYR2SEX2xKN1I47kUFsDF2ahk5qOtkXWccHqY2CjHmhtt2B\n", + "vF+y6u9J79d26zC6EapjIRLrnNLxe22K2VnqMLqlAHjaSZCqGpDSX0TeNyxVxMUBloKKWAEfx2ju\n", + "FXuQejyiOml/YmVzS/1Zqm4cvW1apMp4XJvGU89KxyiA6Oi3C+j8tK2nm1rc457SMhXmuMtzT2Mc\n", + "oMe12ep4rXaexrYClZbU1kekwEgyaFbKTogwa/pQXBSzBW9hmHiOwzGg2VSxFpcp4ZOOj2U5E0oj\n", + "RRhYw5L0jrDf5898/KVIy68S0oXqdd7ZbmHQTan4FGnuA1E29uinw0Sk7N7up/f/weZpSkumiaZ7\n", + "zCBeRCRHmmdE8U5DxT7xTLPg+29EbL9W49hHlDIsVlCMJ21Dmwu439mjze7ISIR9S5/XlIK+WOtY\n", + "IwbArPZ+oJSxOWkMZELfoZ1WW0qLX+h8tzmj5xkKiZrazOj9uXLC3D2NPtZ3B22T650XAEx4Fl89\n", + "cArK06dQSr/yZ4c5dawX/r0ff/ZbIiLyAPpU0tPzF4Vfj0iD8fNzpEd/OG+S1VLnroTmjgKG2wUV\n", + "dOQomqC6J+mHTv7T/+wP5f8rAiIVIkSIECFChAjxgfHREKnD8VY6Klc/QEU5ppVJD3mCw9FXJBPI\n", + "w2vxN+LRSNu8IsFqksl2PRh9qZV1E8NvXVi5MKloo1y5IWJdhe/l5EmW4jpS8pqqjj3O148xiPlq\n", + "GVpG3ky1fjaxECvI20uSiYhLlISz/x0Ium9vv/ZzGrc4vrfJYqVv5OlOjzuSivkJZaBMdv/6G/Xr\n", + "e/zoR/O2N7eKfkVErH2zUwJgQeXfOa7t4ZXfpxuUc3PpcIzV/AZoRk5+eYejlRD7PlalrqCb3FGS\n", + "Qw2169HP3XwCDa0UEVmmKH/PvJErIJwNZAV6WoU8f/FcRET++//tn8zbfv2Zok+blV+DoaQmOSEi\n", + "crfTtstIAdtQDJbzWC+VbH+Bz5KYSKQoYpionwzoz6s19WusEtvJV7XW/4VI0ZLpMWhBLBMQwQXa\n", + "LiZ29AryCyTYLgWkBu6uHVXYQMKgIfmREn5dJXmtVbWiiAlJByRAzOyoERHhBxD2t2ufJ56/1P53\n", + "Ufh+7RIbUqw/AtU5O/N+cn0DQj8hElbWPAB9qCpGsvRGdUTAN3I6exJGuHdcpm6K7exJN2UmseDk\n", + "+RL7GTc+73VWqLKGYjn5mvWdzn+s4m7edKRSIEeUf7MqfQGZkIGKV6qT7u/80qVQUty7an/CdXl7\n", + "5UALuKw/ASLISE8EyYCEUPcaY+yvvv1y3vbFs5+LiEgzeH968FjvWQwSd0RZheag9+uGJCk63KeU\n", + "SMxxBKSbCNhzzUBLYwcIfL4g9wqkLjKgbi1BE/GAAgBSvS7RPwf2Wuyh4k2SCBXuSV/7/LM803uS\n", + "FexyAUV19I2YCPv5UsfkYslzIvwqF07YzlF4VJPa/u2djonuEcmf4NmVL3zsREBTC8qEZJAdERDf\n", + "MypAWhcoQCFJCkN9f/zUJzubkiZC82I8x6Le2/Mcsjyb3I9h3qYdELaBCPgZ1OvrE811KOzKcyKR\n", + "4/lcUjulkfm/MqaEvxkl5EnwPREQqRAhQoQIESJEiA+M8CIVIkSIECFChAjxgfHRUnvN0MhIxOZx\n", + "UiLo7Y1DwQNMGNuKzWhBFCdtk2Ewc2NKgQDl65nQDQ2OEe+PMaUCctPsIM2Y2lJFlEarDtD9IMKu\n", + "GYMyOrg0qJggyBwpyHSp+7ugtNve9GwGvyU30B1pWkojACnlY5ka/FA72blA/maMHDJtOyMKArql\n", + "tFeXK8QfC0P2+vfPv/6LedvWCHuUWjmeQHbPnKifJgrPr8igU6DoPJIC+w46Mudr6A7Ffk/uYDJ5\n", + "tf1k3vboqarn9nvXJznt9fjVyXVE7B6vF56ysAKEInMSY5yADIxu0lC/WiBVcLP3VMw/+0NNRTy+\n", + "8pTR00/0GFnikPH5JTRobj1lESHdEFNubQTZdLvS62p7V/NNkGamLJ4YT5T7/26qcc2kAbUAKZvU\n", + "+xu0bVVRuhnnVKTaJgOlEUdLRVN6yMZiRvf1LdTAWbNnAbXhOzKSLaCyzGrfBr2niaa9WEXdSLa3\n", + "JydsG2G9Ovp+O4yjhooNeozZuiUdNaSqlgsyLUY60s63JdPiHmlZTuMZKZ1TASkMxB9eenquNOY3\n", + "McBbkJYvL5xY3kNFuyVCfQmV+aG3/kLGw7gXCZmo1iCWcwFCj6KFA7W/mSDn525Gu4L57Ehm4Q3a\n", + "wI51Ovm4trZIU+/rVtATZ6RYbbvb+/Fffa99+0tQBkREvvjuF/rbwsdulmM+A8/hVPl17a/1XBIy\n", + "9y5jaGaxOjUoCo8fuGnuprT5Z94kC6Qxt1c+J9ipm6HzQMUJV0gVrxaeWisxdgpSm8+glXWiFOQt\n", + "5oJTRc4KUNRflt6eR7R3jYIC1gJcQBV8s/FU5AJzcZpyAQa05Zg+grFbU0GNqdgnCVEgQDxfrihX\n", + "DEV909hik2XTSiwojW/nxKbdI+az4V7xDGguRLMp0XbLzMfpBsVb5l7SUsoywfO3/H/Ze5NeWbY0\n", + "S2hb772f9vavy/cyX2RkZKeqbKBKwKDEEBjBBAkhZgxAjKj6AylAAjFgyqCEBFJJSAUTJBKJSWYV\n", + "JFCRVURGRrx4/bv9Ofc03rubmRuDvZZ9y697vigdCa4S7W9yzzV3N9t7297b7Fvf+tZ3bGPYxW8j\n", + "fcNBk7XgOYnnusZJvYik8ZogcMgCIhUsWLBgwYIFC3ZHe2eIVN1sXS7KqRlq3C3XRiy/ufF/b5bm\n", + "JUZ4M44q8RxBwFQ6GN8llSi5RXeZLuk29maa4820ye3d8qi/n+qdgDyYCiucKsqs2+Wcc1soTw96\n", + "Uv8MRPF+H3WgBP0pUBsuWatcgO/XVNJVNxvWepK0drRJU5KXQIm2saF5TAWm5zIcC2EaBNSmlhRu\n", + "pC43kXkwn337U38uId9VlUckclHlrknik1qDXZIHhRRdAm2bbtC2wryAU3iQ985M/uDRiSd0X3at\n", + "NlcKT7wn40nViVxqIq5Bdh9Iv5tqibb5/s+lhp3DGI8H5hFWS4+EffP1Z+2xOPWI2cmR1Zo6GXiv\n", + "6mqhqtggtq8snT0/8WO8rb2HWfRNxTmJZ2ijqJMD4ahqmydj1IbSWncrrJlKLh9DRmQ2k9qNQCK6\n", + "Pd/H4755uumWhE3r/wryIJEgIkzJPz01qYlvvvkSn9n1j3pjtN1+m6EWX5aBCNqza5VYn6kgDeCc\n", + "upupoSQLHFzObUzosCZC4l3OsRa21sflhmiOnzDbRlFyzEVpb6OZArCTYyQMDASRAaH56soQmS4Q\n", + "2W5qaMZ8yiQDScmPeA7f3k7H9pAUSMN6bigdf6s1FOlpb0RtenLl50e/a+1kzcp+z7z56ymSbOrd\n", + "5BznjOSeCEpGmDzqS/1FoPmLG0NYv3vmkzcSIeB/eM9XD1hFE/ktEm8w/2ZbQ3DGD0BiFxIx75PK\n", + "2TB1/mRsKCFRlL5UQBgioWLQt/7H+N62rU0oexiSLRIh+xdd//dQCOCsU6mVBV5f+HlyO721dmLO\n", + "FEKs5hQjMpWL6vZoONhpo3PO1YisNILqJCCHpxKlYVGE2UoU4LFQcolOcCwKIe9HQH2rkpJA8qwD\n", + "qiS5Bi1iXYicUQR9hlKWUMnziSTIFmOm1QMy1EIs8EzuClpEFLvTUakVPuvtObXB+ljLPrlFIoHW\n", + "k6QEkwC8O2jvIQuIVLBgwYIFCxYs2B0tvEgFCxYsWLBgwYLd0d5d0eKqdt2BwalVA2KlcJPLEuEh\n", + "USKtQCithChezaFiq+q8OF8m5PG8Sy0MFDQUYmkDslmvL3oWQ9+YRmDsLVV+JYxXQnumlhAYIfPe\n", + "SEJ7GaF9aNZIMcwCuGgnMzjzfOivO3mjxUg9PFqJxsUWOlJKwGsgiFQ3BuM2CO31QWzs9G2wYxCl\n", + "NYzZhe7GJ5/8yL4H8vwvvrPQ2nJKcqgoVnP8G1GgB6F3K9AqI0RzEHF7Q/v+ydFopx3OOVeh4PNm\n", + "IVokG3/9SoK7p6e+0LFq2xz3QABvLNxB0myS+faej0S7BMkQ86UR29mW7cbmyQW0jbpCwM1R8LIn\n", + "0HYJbbEis3myXjP0g4KaHSHHI2SdZhICx7g2tc2dfsffx6OhKdtfXvj7/nJi938UgcQshP4c86lA\n", + "weM0Fi0eJDGUooXFFZbLmhgj3HB9aWGsGqH3gWggxQiRdEUrqkDbW8Xswj5LYySRCMR/79SHRzal\n", + "kO1R8HgtxPoNkkyymc1xErAnlaktxywaXHI8tUAwiqELEZuhSi2azkLK05mS4vH9SCs1kDwuelMM\n", + "6Uj41q6P0JLsaxHUubtSsYBJFlshtvcRAinXSkFAceO1rb8I86lay3zqgvhfcl0JPQIk/liIxTHX\n", + "tTxwaO01AAAgAElEQVROYrB8GyHx8jenY5vjnNqb0kK1ozHDbX69LqZG91hC28/JHJ5M/bhr8IUK\n", + "/KqjRTV41RbqIPSbyz7RQZgnxfe0yDevoiHeAkVwi0zDc1DWlgQQ7mdM2HHOuQTn7gh5ngkPQyb2\n", + "SGiVYTQNe7HlmeiY5W0ClO2nJWJ7vdieSdxjdD6n0N7KJKGI4Xu3Qn82qphPwvZOLIy/tLaz4LzS\n", + "V0Ae1/sUYZ9opAJECm0rhu92imazjxLaZOWNrWQWbFs6gpCAEiZl2fdqhPc1pK2q/YcsIFLBggUL\n", + "FixYsGB3tHdHNt9UbqvyAyDMNoKqsK7ckRABF41/g14JKZoE9EpkqbcghyWqNou6Ti5ByrmksLP+\n", + "XdGTd0v8tJF6RRVI0Y0w5qqY5ExRYAcZL3KSJtxn/iWkDsT7d3iDzqSGXn8AD/KlvEEDJcjF+ymQ\n", + "Or4Sov5mScKkeC54c1/HOBabt1p0gQhk1q/xsfccf+sHv9cey/EGfzMzVOeLN548ma5srLfxvlcz\n", + "7ACdEPLyxYWXFmjrLsqQ9OFBTacm6zADsf7py6fW1wnSr7s2nVdAvUZ9I5vWOF8tc8wBbWEa8hmQ\n", + "LOecm8GDfX0l419C7Xkg9apwr2dzI5GPoPatJM4a9aE0JXe1xNhlGJvaUuNPx58455y7nPy0PZY4\n", + "JkCYp9vr+THOUpsT1zGIqlKAiwrAx8fWpvUMqtxAfbXWHz0yJYePocDdiIo5PbzLq2ftkRGQ2LNT\n", + "Qx8WSz9n+qKAn6B9KVAA9b7pOKbiVROcHI0M6ZrCw72Z2PynrEEylxpq8NJLTTIBIpBgLcZChG7v\n", + "8HafWN8VCQUHpOny4kV7aIQ0+UyIwkvUHytrVUwG6p1IncSYa9efdyUIbg/ny7U6QHvvhGyP9XRy\n", + "ZgkA3B/yjrWJ9fyqRtcOkiJAxO0IgsYkA1Wndqh/2awNVXIgqpdSbWI88HNioXUCQQrvyLp7cM9L\n", + "Fhwf+2O3F7b+iXTUghBM5kjKEJmCCAjDSlD/BeZCJQjr5MqjWdelyZQM0E7WmOz3Zb/AI0YTMHog\n", + "6vcEabpuZSdk7kJRey37Lu+TyvRkKStv4FkjQE9NWYuZEfBToH5ZZihlWzuy1ucp5k4h1Qsaf+8U\n", + "TYqxFjOpclDiWZ1w85JlmoJYHkm9umpD+REp1cFrSGJFgQWdyxzjGCsixXGs8JxUcjj7qihdDEkG\n", + "hSlTIHbCSW/rDypTPto/tBPtOmQBkQoWLFiwYMGCBbujhRepYMGCBQsWLFiwO9o7C+1tN6WrRYm4\n", + "ATxNrSPnnBtAs2MjWhB9hN7WohhLfZA0NvgtQyHNTkcIY4AeExYeTlUnw5uqvlYgNK8VigbZ2S2F\n", + "nEaCuMCjEUIvN5WpYq8AfS9w3UJVv6Fn45TsXF2hvRYym0+hyi7Q+oDnE2Xd2wiaGUKUJfFuDWK3\n", + "IOHO9UH6y+zd+vjch2Xef/SRnQNaHGdjCxn8ov4JzifaVlTWjTTch+K6ogG2WJLs6n+7TOyz7rH/\n", + "++Lqu/bYZOn1ia7WFkZqoOzdqw3aZog4X1m4Z4FioYn0san8Pbl/5n877li4N0n8b19cWMhkgASE\n", + "aGwh29USCRC1kK2hX9XpSmgNyQNupYU8CdX73/Y6clNAVB6P3m8PLfE9rTwcEfvf2rUYNi+FWJwh\n", + "9NCTEGgH8esCRPlupOrMvq/DnhQeBqFa1clfIfQyEA0qhkWU7BojHJMKjJ9Cj4e6O7GceIv1mqtm\n", + "DqoDFEKO7SPM1u9ZGGeO/WG5tPtP0nAthbFZeaAHDaRMCpoyjBTvkL29dSWJoC4RWpLvLWbQJ5OE\n", + "jgKq1Bruo3q2Vk9gHkmE8603FsbJNqQsqDo/Q3C2d1AXKpYQ2JMHXo9tcGTh1qjv71Nkw9T2O6Lq\n", + "tSTsdDISoKUYM9WhhbBL6kOa2dwxArbsXVgfXRn3Ldbu5NYneWwkFEqNIy08a4r6sv9jXun9n0x8\n", + "GH02sxAki1bP5xKWdEzUQdhNNJMYMlIVcYZ5d7SIsLdXstfx+VNJYgG3542GjvA5x2srGzULaGsS\n", + "FVW5qcnknHPRlu0UEjcI+qqinsb+c1Vv55qt5LlbMpSPcJuSvXn9WsjeJQsvyz1JMU8OEcV17GhV\n", + "rXqDu9pSWoGAY63n5dqJVe2dFU1iGZOECSUaFuT35Lca5ztgAZEKFixYsGDBggW7o70zRGq5rF13\n", + "YG+cNSSY9S00x5vuprL3vQgea6FkM3g4qZDjMhLrpIcNUCJ665W8LecgR68krf7mwnspV6Ki3INX\n", + "2xNiXVLj70Lq/yGdeiFk15nzHlEX3uIgF88ACEM9lzd9eL29gaSLLkCK1Zp48BJTedOeIk04qYVs\n", + "j+5uQFgUBQXnEtQQFE/z/Pihb6cgDddQAq9F/qEHr1vTxDd8w1dSYt97p7OtjeeyA6J46ceiLM2D\n", + "nd36c1yPDemZrvwYVpWpA2d9pGmLV0EF4norUgONP0+0tWtMVv4YidhFbIThCmrveUdSuJHY0Ahy\n", + "0s982xu5JxVkJNYyyJQa2AiJslyhJt2tH5N7x+IZoa5VWhj6kFGeohIPDmieXquIvUzAg+HD9tgY\n", + "yFIvtnnX9EDAjED6FHJ6gfl0e2Ooag8L6urWxv/0nkcnRZy49diXIkkQgaiqaEINr7dxqOEn3SKx\n", + "tRFyMFXxM0mrZ0q0KlA7x5p4dmwNUnotSS4j7BmsYTYSuQZ6vQoWUEV8K4klrHU37KkCORABQQ6o\n", + "kF7tJNQw1V72LiBmEdoeCYI2h5xFIQkDPIdmaBMJUKQnRX247tjU8wlmxolIx6AmWwM0ZTU3pK+D\n", + "ey0lRF0EVLeJJAEDyvpEgZyzpAUdz37fj5nWOru+9muSiFAkP+A+qdRfylT0eopS+T6ORdmcn9e1\n", + "QvHNzjWdc24JORsiSLFOK5giWK9f+/WhytpEVhVNqtv+a1WICt8XYneLOkFhWzrLPihAQrRkK/sK\n", + "j2mdPrYvlQ4RHdMkEybeKMrC9H/usdoHon5Natdv3D5yRXXwtUhtsN+1kO0PYT8ke1MaYac2Xr0/\n", + "hpRVcKV9j6T4HZTcUXbI7h1RKk2yqRudM/sWEKlgwYIFCxYsWLA72jtDpNZNvRM/ZXi9kVTjBG+4\n", + "WxG65Bu8aBS6Gh7reqNvjUCpxMXd4q2b8eC6suuvIUxWmgPl1jf43tKGaY3K5KkIR6a4bCyezhp/\n", + "bjfW0JqCZEjTrjsitAgvYW50CDe+B0RK+DDNEKn2EzkvxqSQWl95x3tkm6Wl5NOz7cCDrcXVWa/A\n", + "6SnsvA/PPTcntURw92bqz7corYbWcOiv++qVpRBnjX/Dj/sisAiUsC/e9Fnk+RrNBkib1JDbADlZ\n", + "SK3F1cKLKSZSk4+IZCOChA1rAYqrEAHNWC7FS177L3w9eeXPpQKG4NcVIr+RQRiucdYH1jrUeLyD\n", + "mGzUmJwBkTAV6Tw69WNy2oGHO5d5hXvS3UpVc/y9ySWFnzF98dKOztD/RgQ2E9/ORJb9Lbg8ERFG\n", + "uV+UK6iE+3Zz6z33oie1zsh9kHkaQ5LjaiKSAAe4JPTc10R1BBEiR6MulVMClFD4iEzP70v6eYY5\n", + "vtRK91vU5BTkrtn6+UdUSdOwiSBE4sFzyShIwRT7k3NDPyjjMLk1pCMFIp4J+tRD+nch6DRR1BxX\n", + "0fT3LXgwa+GIxODBJAITFUAfCrmfORGZSiQuwJchf9E54a1QHTkSBAH/Nl3hd2LeVTP7Hr+5WApM\n", + "Ca9eRVdbgVtBbogccm4kgv4T/bi5UT6ivymKSBFpUqHLipCpcHk6EFM1npWgqUDmFP7inFgsDJGc\n", + "Tv2mPR7bObSPNKIzmXBj2b56R6ZgV4hTJUHIeVJRUe6rVaXoL8SsBTlv0R+51i43DL9tOUIiponf\n", + "8HQbQZBKXLdOJCIA2ZdMhVtZkzGRY477pF1/i/MpD8odEPOl1UC9F9IXPuMz4YhVnKcHxkm5ZOy3\n", + "1klcr1XuZd8CIhUsWLBgwYIFC3ZHCy9SwYIFCxYsWLBgd7R3FtrrndY7hDnWhuv0NQ3Ww2lVZLDa\n", + "7cz/3REWOeG7UuQUZoCUNzOtteOhwhghiCw36I4k0q4ohpc5UvJXEkYBLJ8kAjGifVUt76UgJUc7\n", + "dcoAY+NrU4HCY9bak3pJBSDt0UjrQPnPF7n9tsl8SKHXtdDCEmGhy4sL6SNDFSTnW4ilqvbVaZn2\n", + "PRHF7m+/+9Y559zVrYX2GPqoJU14ATmH9VYgc7T9pLBwF5MLlrjXrbyEcy4rGIKUFPaUsgImdbCF\n", + "YvliYdDuHGT0rFLFXBB7pZ7gce5DoCmlAQobQ9a6yiTVfsvfRjon/FzQsFDchkUs3JKBbJ7K3Jkh\n", + "TX9bgLBby/2vEZ6pBdrHT+dbS2LgXOt1Nf0d0LrMpxVInktRyl46/B1TfsROu0XigfDF2zCbhhEj\n", + "kPFjDaPi86WESk+PPQFeicKU5KhrJkBIGBdruKpsrkcY1ziyhiYJ0+rtnvRBrJ9L+nvVknil/h7I\n", + "tiSAX0vIiIrRlGjwDfTX6net/8ORn4u3E6vJyBClDJNLWXdSkiJKhAx6Il1CuYEGVIRMQqEpQna1\n", + "9JVK3cOhkd05xsul7T+nrGuYSbIBwqe3QgpfIZTOGn95VzZq3p+BrROuq/rCJEmeP/f7w42EwErU\n", + "R6yl/wypNjuzAn/H+6RfhtRKkRBgaLORRKXnz33lAw0jbxFa1Lpy8xnbZ5N3Dn7F7a0PbWdy/yl1\n", + "UBQiU4P1NJG6lgwP6VxjuE+J0kmrSq7hvt5O21VWg2GpdGev2Q/FrVaqZ+GN4dNSQlYrkLKV7J0i\n", + "VN2VCgT8Da+v94tSI5Uk9qw6fp4cH5vUxhDP9qS2+TSd+jGeSViO/dXrdzA+DRJFlEbBubAjtcBk\n", + "DwnZkSA/k5qYDBHrPeG4RzKe9c783LeASAULFixYsGDBgt3R3hkilR3XzgmZrAA5uRZEqE69hycv\n", + "te7igh6MeR991iQSL6VaUsxMEBYQhfnTgdZLA/FcxRpZd28oIoWsQ6QCZluQnXMR2qMO31T4ciVE\n", + "6iJ4nCqWyTftpXhrN7feM0gaI+eV+b7QH+v6dWIbuy6EC5cz80xy1vOCN7NN7Voku+dyjpfX3sNM\n", + "MiMAv3rhPT0VumtV5RIb/xpIx+uJoVnnM+/FFqmdLwPZ8xJeQhJZX4/hOSqqkmz9PeynNimYztwp\n", + "DLnsFh4l6OdWw4sIQy4Cp0nskZtB359voEgX7sV6s5LvI11e0B+SEksZ6xHOEwkpug9PM5FaVzmL\n", + "qoNsn+fWNnrfcaoaHkj/VU+rIhFUPFLcnzK2MWGaeCNrgp4YESYd67ZOl3hmaeHHq981sn0JQvfR\n", + "2BCRCe57I0xpyh9o/ceGhG78fy1oWQwvUBNQGsf2itBuTKSpPeRK1pUTT7MCOhbtOJdIHgEiVIiA\n", + "aox5rYTdDpJXFnNDcDZLP3fzWEis2GSaUhAZrhMZ/wznLgV162GMXcF7LfOfySAqoIjR07pmp8P7\n", + "vl9Cei7nQFjum5guE1D6QtQGcO+aGshE1+5rtK+b6KIE9foyQ/Oupr7fXz77pj3G2zgc2fkK9E0J\n", + "9Q1uEJEJVWnpAZGOBU3vIdkllZMslh5VUlJ+i3BIXUESpTVNnzIBRDAUmUiwT+r6J2F+KvXvtvV+\n", + "TTiaErUJNqmcAJGzms/EWhE8PBNmEpEBYtYRBIfolJLiif42OwsAotOiXbJCQsNG6mkSla23zc7/\n", + "nXNuCfRrvjCkpx768/YHUv8Pki3aplcvfZLP1Y2huZRfODk1mY4Cz9YGQqPbUuY/pR7k+UsUV+Uf\n", + "iNJtpK9pG2ESiRuWE5S9uHvgPqoFRCpYsGDBggULFuyOFl6kggULFixYsGDB7mjvLLQXx7GLVHei\n", + "4yFAErydc67aeKiue2ThnkePPGT68lvRv4A68VC0WBYAhDcaFkAIKEOIQ0lvJOqqOnoMsu22MHB5\n", + "jdpoc4GME5C3Y1GWZe2wwTje++1q4dvUjQ2KXEPjSKSt3BI18W6nBgUP7wGqlBAkRYlLgSw7CP3c\n", + "P37QHuuCoE/iXCpaJAXG/f3H9+28gHhfv/zK2rTw11hOpU4h6uOdj+xaG4RWh0JsXS8BWfcFMm08\n", + "Gf3J0H+vX1jYj0TFnmiH1GhTJqEdDruKz5LQWpf2vRy/SRuJAYG0y1BgJiGDdjylhiPh80JCa8tb\n", + "H47abGyuXcxRf24o2l45tbLsGhlgbGp6qYoxCajVjjo4+iW12QhLq+7KQmpRtm1nOEIuQrg/bUN6\n", + "ou3GMGbPEgbqte/3WpSQT478PduUFp66vPShvb4kjzB82Ije0Xzhw01xRDLrvj5OLKrDjHJEKuON\n", + "NmcyT1Lc67LcJ90qAZX3pIPEgmMJT5JEvFPrDOO+XFoYYzH1YYn3H77XHru+8v3vdSUkgDCa1gls\n", + "a7JJUgpDn62atBDwK4Q0en2bVwwzqWL3lueTMGLe9UkekWoctUr2Nu557O83hbqTQu4hwlhNbCEb\n", + "+uPZUAjoHYTbciEsr1BtQSowULQ9k/BlgRA4538s6vB96BJFggGQKtHIlOAxneusydgcUAA/NCeo\n", + "jr6jIUR9JgkFbvCcUsV+3lc9L8Nyqt1EFXWdY1y7TLY5pI6eiv53D2vs5MRCYSPUU1xIXUFev5FE\n", + "Ge4ZSkAnAbsslSjv29JHWFbrzy5Xc5zfxikv/OdTIeBvlnP02faJGppuI1l3GZ5LqsVFKg2Tt7TW\n", + "IasH7JTDw/e3siY4FVTvq1X0lz1phXvSCM1BE4QOWUCkggULFixYsGDB7mjvDJGaT+OdNNhOzErb\n", + "gkhF/q22K6nB7z3yb91Xr8zTnE/9W+VoqG/p8BLE03FADFhrqBFPnwrAkRCwWy+tFLVtvBGXQhgk\n", + "764rXkIXnl7UERVlfg6ph9VCaJSRfav9C0TlUryqDVCqQd/eqsfwNI/Hp+2xM3iHP/rwV6Wdvj8k\n", + "TG6V4AjS62hoHmRv6Du2klpfP3gfSsAd8SAy//mgMC85AqGzI7X7qFR/JLW+iHqwrlpHEEGihFkh\n", + "iETJ6t+qTs0UdvOSSiCSC0n/Zs2uSMim9dZ7RxWItY3ca3qCmUht5F3fvh2vskWu2kMtIqKqxG17\n", + "m30viV6oep9EmjT9e7lS9Whvw8Fg71hL2BWi7JpV5cUj55/lIWI5iJqVzD+q929WRraew9N8/dok\n", + "MQYgL8cHVMGlO26Cmn2DAVK9BWnietmpq4WxK6VeHpeOku3pQe94qZjjqSjLD0d+LhZEa6Vt24bX\n", + "t+8vofa+Whvix3uspOAO+t80Nk9H8OYjUVZPWCdvp6KDPx8TQEpBqxKsxcVs2h6zJApbJ0QaM0l2\n", + "4Jx0gpI1me9/p2tINLfAGMhFJOvatV66VFtANYJSVMw7QHUe37daj1OiIzuIKKQrZJ4QbYza2myq\n", + "js7KFravR5AHKXTvAjqkc50yJaqAzevvoHlb1jr0/1epgUMSAryEVtEg6qGoClP8lai+Qt+WgiDf\n", + "Tjwi9Ob6CtdX+YUe+irVFoBwKnJHxGwwtL2Ba6KU6hE15om2c0x0SEjpHANWEVmtbQzXSOxYCdKU\n", + "pf7zTPaT+YH6e/wzlUyRXg+JHx1NsuEez7UjEYm2Tbb/8xpHR/ZMTLAWtCYnZRwUTWMygCa01UJu\n", + "P2QBkQoWLFiwYMGCBbujhRepYMGCBQsWLFiwO9o7C+1Nrxu3iQ0ezbdeg4MFYJ1zbtJ4EufoyZP2\n", + "2LDnm/zBxwbZffWZh0CrxuDJHsJ8GpboEzLEJSoRRVkCYs26ojECCDQqJdy2rPaOpdCnSiS0wMKo\n", + "mWjQOBCVyxKwvIQn8nq/yGd27NuXSOQmh2L14/HH7bGH5x8455w7PzJ9mH7XE4A7WiAU4YY+YW8n\n", + "WhxUYlc0Fd1Zie7HSebv05ORhRbbcwhRe4OxU6J4Do0e6in5H+EfQLG1hOcY5ewJYbnVlpHwyHIB\n", + "xW7hVyeOSrhyT0hAl3FPc4ZgCPGqYjiLoVpoo0I16rXA2FTHViXeIcZa9Z4OETtJqCWZUtWRqeei\n", + "3ycE3pMCvTXCXanevJj3U5TVM+rj2Nwterv91zBajTleJ6I2XvnxYQFk55y7vp2jTXafpghjnJ+Y\n", + "3leGEP18YXpDJO9z7JSwn/agRL+jzs77IxQAEMC3ElprC3lLQkWDOZaItgyLqq4QWllKdYQSYYSe\n", + "FOhttXVEs+js6D7aITp2mP+DrhRoxdhqOxOMiZLiN2w7lMiTrYS9ElZgUHV2//2+6OJFLG4rtIga\n", + "VQtSiVJsJ9jj+qJBhL8jx7bvqzpHQlgu537sXr2wAtUbjMVaikbHMcNoNsYZ7sVwqGscbcOaWE+W\n", + "8pn//subS+sXQjEffPhRe6yHvWYroT3urFuZ//yrrLRNUPQ/UCD5bYVv55zLcY+fvGfPqS5CaoUm\n", + "xaA/jcyJAdauhi8TcEVYMUIVyxmC6/TtodAd+r1ew5O3V/7ZGUsh8TYELeFmUgA6fWtTf+T3Ow3B\n", + "cX8uDxQUPgKxPYst3Mz1qY+/vNV2kvWE8VxLQkWJPbsR6ksmoV/nnKuWMv9W/hwL0TZsleJ1r8PY\n", + "zUTvazHnPi6UBtBLdkKQst8dsoBIBQsWLFiwYMGC3dHeGSJVuK7rx+bpL6eedNrt2hvkoOMJ07Nr\n", + "ITGeA5F6aJ4u30gnc6k/hzfRjXh/I7zpj0Esr5y95V7deA86FUmEFCTq1VZUh+HOdYdSpw5v9bOV\n", + "eKRMq8/tTb8L8lz/1Kttb8b2/TmUgPsjSZeGOnl/bOd4/+wT/GuI1IMzj0Rlkmocw3PdSk2uEunp\n", + "9D71jZu1BjWtuIL3rYTBtOe9n5549fROaqm11AUSpQq4VE/Wt3d6DqyTVCoRHB6WEoZJeowqafvA\n", + "/0ZrzdHDy2X8qYZbivczgxezRh06JXvTE1yJp0NyfCZeVYY04a6gRNEOy3n3fAcN81UV46eoHTgQ\n", + "MjmJ5UpAbdWZpU4iZRVymRNFvn/fuU7YbyVMb5HsoenqlBhoBGmYr7w6cRXbnOB96ktSxApp0oXM\n", + "CRJlicgpwZTef0/I4SRRbyVdOeLclX4Z6iFkY6TxD6RO3O10ht9C2V3myxUkDI6PrA8F1lUisM5k\n", + "6r93Kujb/MrvZyeCtMxu/LHTY0u2WOEeKxIfI9Xa6qrZmFCdXZHOAiRzRQTbWm+CXMRIRom7dn0H\n", + "tKtuBDlqPNmYazKJdb7wLxl/oL83t5aAcHmNGmYyn56++M45t1vrbjDwY1sLoZ7IBf9VRJj85+OR\n", + "RSQ4T5JYUbr67Qa31GGta9dKAsj3OI5cE6uVos/+LFrrb1CM9trJ/ed2ZpUd2M6iI3UV012kxTnn\n", + "hkCYmJyg7W0TYBTqQYLW9EbU9rEnF5KAkIEMLwCvi4DY6X7eov6CurX7BOekRF866EPv3KpIEAlU\n", + "hDsD0qN1Ojk/tpLQdH3tka2JzCfuccdYO1Sfd865LvZiVefnNWq5r3Mom68E4W9iKrXrPgHUX+op\n", + "fn+lvYBIBQsWLFiwYMGC3dnCi1SwYMGCBQsWLNgd7Z2F9jpp4XpSCLCE3s+gEMgaMF4tobVN6SG7\n", + "Y4H73//wsXPOuc+/fdoei0EsbhZSyHLlYfx7Zx4C7DkNT4EIqUVTgUAOxgZF9hDSa7ZS8HgLyDSX\n", + "EEyPYURT6j4a+5ACi4BWjYVxliBMrhcGOzoUQS0bC20+OfWhvdGRhSfIMS4TISyCKR6LLhdJmckc\n", + "RZ5FnToFnNkprA+MlHRFRTkCQX2ztnfwDcIoXSGbt2E5AUVrhBa3kYZPWTSS993OkaYM7e2/72sY\n", + "J231gfbVZyOBwDOEdKnE65zBvVdXPhTRFY2dASD2lRBBGbLaSr9IXtVC1tQ70gVGuDmJNSlhu/PZ\n", + "kdzXwchfP5O5ziKcO4RJ9GEkCQAnJz70Meib3lcC7R0l1jKUF0dQAhZybouKa3gE4dGVaPFUgMo7\n", + "Aq0zLNOV4sZ15dusyt41QoQ1tLh2wp/N7jWdMy201ULmOueOzgnq3sje0UWSQye1sAArHdcI6c9E\n", + "Cfr62hN2VYvo7AhEXAmZs6j07e2b9tgI5N1MQmBLjHumoTqsic3G9oLVAkrNCDN2JGS8pt6QxBp4\n", + "D0shAPcw7oVqjHX9/FC6QzZ65PuwEaIw9skYhbcbrQRALTYNtyNk/OCJKbv3oaP08ruv7af49+LC\n", + "iOJPn3mCuoYlqemVtrp3drFjzPFEQjsMs7+5eint9P+Mx0dyCGGcRMPHKGQtHZpOfcIH14Im7Bxj\n", + "faq2GxM7Gln/bxCWWkxE74skcgnBpwfI5qxaQHJ0vEN6RhWD1b5ivxYZNs02JUkjoeVGiivjWlrl\n", + "gjpKpST+cH9qC6jLnnDvnqeWCNd9J0HGrlXhHNJ/xBlz2SdInxgNbe+ifh4pCwN5JvVwLEsO4EIy\n", + "d6xSg+iiRfzH+kOyf0fCnVHz/cG9gEgFCxYsWLBgwYLd0d4ZIpXGmYtFRZxeep7ZW+gIb52bjTVz\n", + "tkRKuIAP3dy/LT86MrLn6wvvHTZCSqZq8py17vrmGZ8DaaoK8+pZzye+ryRO7wmp2nESQ4E726+1\n", + "VAh5lWq/fRBAc0EaKiBolaR/3048UfH1zSvrK34Ti+psTSXejdQEw/mUqFojJXsLT0MJlt2tb1NP\n", + "6pqxnfr2v954zyCR6xOl2vFg2hRm+94MKEJRmPcTQ6k8QdMVfaJXU5b7qaeFSA3QH1iLR04U6VYI\n", + "izT1fgcDP9/GY+/hJYVdvz+AhISMCdN1b+biwaOPlXhh9OAq8RJXG/ZfJCFIrEVKdCTeWgnF4K2o\n", + "XpNEqqR0eti9js3dQd+juX2p/2Wpy9YmemKcC7u1ufz3msquRVkBJwT0LpCOblfQVyAHVW33pEEh\n", + "yfnMUF/KRJRIyVbHrwOy52KtkhT+HyXsLqf+81zqTw5A8r5d2PVHSEmfSFLIHKToDATvkdThYmq+\n", + "evVbkLK1KkIf8gg6TzvjIZpra5IE2U2l54PsR2XIWR6BgM3vyaDkSKhIhIBMpEORm5bPmwphthCB\n", + "THUAACAASURBVOPnRCKo77bx9zuWNm0gwRFD7T/pG4mYay0SpM0B6Xv88a/btUDG3qxsnVwuLpxz\n", + "u7XW1qi12I2tnRvsXTfXfu0qgsR1tXxzYdfC9xXVyUGs/vAjq+wwX5HYb03PEXbodw25m898/1cr\n", + "P3cU1eIErA6guqWgRERJC9njibYS8XLOUJodOQXMOyp2q6wL93Otq9rW5tM5QXX8SORMDpDnD/02\n", + "SiixYvs+E16IoCuCx/1UE1W4d+sx9nE3oQfPWElAYf8fiio+ETPWQlWyeXsNeSbZXNCEKrxjyDO5\n", + "wfgksu8ymqBq++5AVEQtIFLBggULFixYsGB3tPAiFSxYsGDBggULdkd7Z6G91Wq6A9nmIBY2G9HY\n", + "gNp3LeGuxYQQqMGoPUDLqcDYPYToVnMjNvZzH8YZpR4yHPZFCRyw/1Zw3w4gwET1meJ9sjHhxkSK\n", + "WxJmV70RHmPhycHI4GTCnZuVhSJYoHchoQiyPFVZltDmji4USYnyPdoG5HUlBEa4fiWQ6QZFMJex\n", + "hPHQB4Ws+XcloY3yAIzLQr95roRyhCoBuyrEzZ820i/qPelYUzNGtWgO6cOwvx1RFmZYgOHGSODh\n", + "BBCvoONug3vSCNmYsLjSETnuqibFthxqE8dkraFAwO5K7GVEqdpRYsaakbZ3oB+jxUA30M86pJV1\n", + "aJ6wR9OphWcY0o1Fs2c8PH778m0RVlPHdq5A6E1R8jV0kdjesrJxzXOEbCQ5IM+wFoXZmkFlO5Z7\n", + "EmHO9kUVn6Tty9emVH1x6feHxdyP+w9+8Gn7GdXWZ1MLD6fOz6uzIwlP4y5r/1lIOJIttshZhNdC\n", + "Kxz/kyMLn5Ug4DPMu1waOThN9hMqSPKPZU32ELJ2QiKOEKqLhJYQgeR+/dxCZfOZH58BxmtgERYX\n", + "D/2eqXM94izXRAGEwz/49EftoadPv3XOOTcaWvh0hIQODXdzus+RFKCUAa7rupI9CRNKaRQrhNnm\n", + "Uxs7rvWVhOCqjMkLEipHWIzX0lDk5aUfJ93D2vUvg8J512yl4DJ6JsuvvUZe7Os4LbHva5Fzhps0\n", + "ZMb1qTQO7v86rn1QNDIJozG5ZWffBb6i56MxjHfoWaPHeF3VkeJepwXfOf81KagGfaSWsHiN36YD\n", + "JErVGgr090L3tbTHNqlOF8KI8t4RoZ07sn8tAV1oQb9ESep7Eakoit6Louh/jaLoL6Io+kkURf8B\n", + "jp9EUfTHURR9FkXR/xxF0ZH85u9FUfSLKIp+FkXRv/q9Vw8WLFiwYMGCBftrbL8MkSqdc/9R0zR/\n", + "HkXRwDn3f0VR9MfOuX/XOffHTdP8Z1EU/cfOub/rnPu7URT90Dn3bznnfuice+yc+1+iKPq1Rl+p\n", + "YdV246aSwj3KQRQXWYH5xL91L9eCvuBt9fl39lb74MED55xzvY6RXfsdIDyFvWl/8NDXYjo79XIJ\n", + "vZ4R23spUC15gaU6eKcw0h0Bq9VmP70zz204G+roikwA1VtZh2+ztj5wiLQOVAd1/x6k4q1WVOA+\n", + "RKwzo5ekqBMRI5LDt+LVxzjf6UjShfGmX0d2jgJeaiqIEE0zbROMXRSb50TCYrxDKAfqBmK1kqj5\n", + "/UZe90mypUqvP4dHPypBM+jp7HhkA38fdTre3voUd3p4WgdqDk9vLR5xRSKi9LsCGTyRe7et91Pd\n", + "6TlHcu9WmM+8h3ovSdSOBCWtW1K+1MEi0ik1DKloHGv6L1qtZFOOD+eJetW8RCbe9wboSJ7YeUv0\n", + "tZHxp7K9ElZJWq9LJVuznh3UvGWsmw3rdUldS6Q469xtEeFYPfIIbbcFTW++kfFsEUZc4oXUixtD\n", + "WXoja6iGnEgiqdZMIugIAT7v+Lm7nhtTOIqI0lr/CyrFi1I7EdMkJ0oqfcB1FdUkqqsLJR9DvfzU\n", + "UPeoAbH/1XP7Xt/vu4va5sTTCz8GH5z5fbUrqE7SP8cfzozSGeLBx/Dgh1L/8/H5Y/zUfsz5rgko\n", + "nFo51o6i/7cgag8GGiVADUMZV9afrCVRo9fz46o16drbGCvC0cH52EabkwvUfxsMbF4TuXnxwuQX\n", + "SCifLQzNpZzJQOQsRkO/355LAszlm9fOOefe4F8lVh8dAf2VPZSoj6JkXONVtY8054JIdlBJYKfG\n", + "JmqRbuQZx+nGfedQdYSdGp7YV7pSbYLX2FGqxz6tQu1VwmiCHeQdW6MWrUZu2BaVTuGYNbGgWjif\n", + "1u2L1r7/ijhxbHN5xml9zEP2vYhU0zQvm6b5c/w9c879pfMvSP+ac+7v42t/3zn3b+Dvf9059981\n", + "TVM2TfO1c+5z59zvf28LggULFixYsGDB/praPzfZPIqiD51zv+uc+9+dc/ebpmFO/ivn3H38/cg5\n", + "91R+9tT5F69gwYIFCxYsWLD/39k/F9kcYb3/3jn3HzZNM30L1msiZeju28HPoqbYEfRoWKw2E2Ix\n", + "NKMWQk5bQ1NGVbkvX/nwzIcfnrfHBgMP7XU7duz+mVfePR541edGmt2Ge7RAL8JHTSQkVjRPkNAW\n", + "gtRxITysRSNbWPRA8dqWPCltGkGLJhfCMLVAlBx8C90XPcZrKYmQxPcOQgYK584hVrKU0NLo2MPO\n", + "6Y4+yX4YpdU0iQQypy6HFKNs2rbbNWYgJVOpW/uQIixDrRPnLNynhF1C69ofEjCrStqUUIHcxiR5\n", + "S5VY1cnXIK+vVB8L3eqK6u2WhEmZ6QWIsgrBM0SjocW0ArSMqdPshKwA2cv4V1sWNxbCMuITg6El\n", + "L+RtWEjCLfhbIXiGAxgKSBLVfdlPYuBYN86uz9ueStHiMRW1JQHg5sbrop0fP2iPlSWI3xjD5dyI\n", + "3acDr7rdkTXE+ZwoYRTH8txCBkXq59O2vG6PURdIw5dMVCkTVBGQfYUhPS1Q3WDuFHJPGsQldKOj\n", + "3tG6trnep0ZZY9dgKDPuWkidys9crzqvm1ZZXPZJ3Lt792yvY6g6jUTZPEVou7CixbdXnmy/mkgI\n", + "smTBd39jVXcpajg/9NHByStrnX2RfSLCmkglLIpCFe2+js757yE81Bd19qwNWcs5sJ/UWxsnFuhe\n", + "yj7RCvXLb4fQiMozCcsizLg9sNe245pqKNB//8kTwwwuLlBweWFzl3N2LIrdo7HvWxQrLcBf9+bW\n", + "z+HqjSVHUNvudGz3kEWOtRjwBvNqvrBn52Ti11YntzBiivU/GqlW1m5fnbN1R+qFErvbxBqZky2N\n", + "Q8aaPVSyfYb5kR14xuxWWdjVr9qlICCxS/bpQ8rqbQhYn+cIh+s84T651ud5sk9lUfulL1JRFGXO\n", + "v0T9N03T/EMcfhVF0YOmaV5GUfTQOfcax585596Tnz/BsT37+ovbtszC0XHuhg8PfStYsGDBggUL\n", + "Fuz/W/uTf/Rn7k/+8f/hnHMuUXHOA/a9L1KRf9X7r51zP22a5r+Uj/5H59y/45z7T/HvP5Tj/20U\n", + "Rf+F8yG9X3XO/dmhc//O77znGkFLepn3llRFuEZqbiIkyhhN3q5UVsC/LS4n9tuTE0/QPj42ovbx\n", + "iMrnQGtKewslwS6Wa23pfQuCQJXpWAh7dMhSqTWX50QflBS6S2yrd1LYka4pnna348dkhwCPwnrL\n", + "2DyNAsQ6RW6IyKg3S+eARDz1KiYz//1vn1lklnXomKLsnKX1Ktm77YOq4+JtXr0aoh5KduaYkJSo\n", + "qbGXSE3XdtKurq7av8dQo1YvhJ8rIpSjjuNyKQgnajzSXYoTRXBIOhR1eCASaSaERcwZ9cg6XSJ3\n", + "ugChwC6oH72kVj3++LT9rARRVBGRGdK049hIrKy72BMSK+UZBBB0FQnwcp9ICuUxRTA5KDtJCZh/\n", + "G5EkSVA7byTJG0TTlDxuOcZ2nzoFVJGx/taVev9ck3YKqq1n6iC2a0yQPiYbyDxdAHVVz5UJIryv\n", + "WlfPJBysr2eP/FhvBBEcgnisxNrr25u9axUgry5lnY5ZvUEIzbxpDeaiol/teMm6Kjo471qIzYNf\n", + "cc45V9WS0EJl/SNDBHP89s2loR5fffOlc865Y8izpEIEb2+Gok+8r1IvcItxjaVO3z3U4nv29Iv2\n", + "2ArjeHn1uj3GtfDkyQe+HVJ/knXvFJG+xbrXemlMfGAyi3POnQDFUYSL+5nuE9xvKBeglRBaFXNN\n", + "4sGa0fs/QqKC7jWcuw8fPmqPUcV7PjdCP5fggwceXXj+3Ejs333nEwFKIYLnINEXqSYs+DZXsnbz\n", + "gnNM6griuorcd7CelbxOZGk+35dkIdLWFVkZPmN0nvJHssTaShmphngYTZHIwWK2+zzr9ewecioq\n", + "OZ577I5MA/bxXPbTASRDVo21k+f7w9/7XfeHv/e7vv9R5P7oP/+v3F9lvwyR+lvOuX/bOffPoij6\n", + "MY79Pefcf+Kc+wdRFP17zrmvnXP/pm9A89Moiv6Bc+6nzrnKOffvN80vqfYXLFiwYMGCBQv219S+\n", + "90WqaZo/cX81If3v/BW/+SPn3B/9sgv3B4lbTswLW2/gpS21CjMEOQWlaj1okUlIUJ8vE++nAz7A\n", + "QGqyRYiNUixS+RA5EIZG8jBbPsZOvToIV4rQWob4uqaa22f7sVVLpYzke/sCZjW4R5u1pnDuSxfQ\n", + "c+oKl+RQDaUe63QxDVyayzh7JZ7x7Y33UvVdmJ6gxr6JTu3wcVgt/ECa7EIkDphiSi9QzzsDqtYV\n", + "j5CehiJXSyANypupwM1RLtditt7rj3GJYvRFJCzwva0gko1jXTPhSJDzIehTBU+4EjSD7VMvLX4L\n", + "ucul5hN5CyogyLb0+uaRnRzf2+mDczZ3JxOr60XZgYF45G39q7ZavAiNwiOlDIlzzqUggvUFferk\n", + "Mf61ubYC5yVNFKXz80+9ZFIPrq6ucQ7zglvUQWro8XRafzABElzX+zyHXNbT1cR734rcTlD3j3yM\n", + "+gCnsJA+PLnn52Kvb3U9M6Av09s37THKaPREzJfCmrp2KSy7lHvcOcFvWBtxZe2doSlnp4a0V+A0\n", + "3RekI0qBJgmXz1X+WrOX37WHthDnPT6xOTGb+HV3S/mPhcgfjMBVES4r6wlWUv+NW2bjbE4cP7iP\n", + "axnqSomP0cBEOqdAH54/96yQjaBP3OOOjo0jRIT74pWhWgnWwlSQng2+dyz1FB3mUSUER9a/Wywo\n", + "1is1UVuJD02X9/+qrAIRqVTWs0my2PmG4EspSkKUrIs1PhQ+1MsXXrri22fGmFlsiHQZP+Z07OfH\n", + "mchfHEP09erK5in7kcgc5x67K/C5GzlQ+Y+8nWNS/7Wm+KnNCdbHHMr4r4EiLaWgIJ9ZusdPMCcZ\n", + "fTjE0apU/LoVpBZpIKBfk1tb4ytctz7Axyo3ilzvC+GqhRIxwYIFCxYsWLBgd7TwIhUsWLBgwYIF\n", + "C3ZHe2e19uo0crPGYNeYqatSQ6meeoit6Btkl6YeYksLSfXuIrQlCrAFINW6EQLaZjeFMhV4OgXp\n", + "MjlAOtwlIO8PWbeHsFxqbaeirCodtKEinDeRlEpCkUpEXhHS3wkZUtZAQhu4xm69NH+NTEnRESQh\n", + "AM/q93NAt3l/JN/fD1Uy/VXJlicnJ3vnY/RMQ2UtYVEU7W8ZPkGbVGphAMLksrbzbjf+xC052xlR\n", + "U0MmnAu7ZPvuTtucM0idcLKGjPg9hb3503qHnGnzjsZwg4aPDynwUiGeKv8adpzOfFhOpQ4SKBE3\n", + "IjUQQ1ahlLAUz6O1xqKYc8LucauADFK0Vhtg207PLTxAQuuob+GJ0yPf/8mlhRH7IAhvJWSVx0g2\n", + "WFh/1oDWG+fnfeyk/iTrL24Usvf/LiTcVaAtlLdwzuQ3VLF4A2h/I5IMXIskhdcq14G9o9+10HIX\n", + "CuzJTrjHt31Q2Dy5fuMTJY7fe9IeW839NXpCSmb4VO8dQ0Sdrg/pDDpCLWASgfRriBDQtrQ5GYFQ\n", + "3jTW9hjVG/KB/fbiGx8Oo+q2c86dnvvf3kx9aH8h4bFs4Y9lI6lXibakEsasb3z/k1MLNxWZv/5W\n", + "5v8UZOyupOTnp36MSemYL40IP5ujrqckFnCvZYKHc85lQ3++m4nJXzDyXm9FqR5JSysJS3Lhc/43\n", + "VxrG83+Px0aAJylbyc4MbWnyBmkp19eWKHNx4cNsx8d2vhHCV+NTHwJ9WNoYPnzo783r10ZAZw3B\n", + "I6lhmCYkjGtd0QbtUDkRjF1nX6ZHQ3tMpOrgOam0EMqzrCUBpcazQAnoNUOgssdS9qGSe9JsSOi3\n", + "e8K2v3njx05pHG1SjLLYsU70GNe/JjvN537PUvrGDHtmIgllfaFSHLKASAULFixYsGDBgt3R3hki\n", + "tZovdkSwSLqMCiHn4cW1EcLaoEG15oF55Gni33o1Jb+toC3k6U6+S+jeEVXj9QWFoVehxDaiCYp+\n", + "EeFRAGcBITRFGHg+XkPREnouuzXU6FWLtR/bWz1JeYoS8e9EUmLpWXf7rCto/V/P5nvXItlXPQir\n", + "dG7fpJjmoareOsY8ph5Bm3ZPoTshbBMdVPHL4WC/WjxrnM0ETeE4kvTpnHkxNzfm4b5N9tR6Xbw/\n", + "ev953unU+lpWrNO3ny58dGReItG5Ujy3Kcb9+NjPISVCX6MO4GopJN4NiN1982DnIAN3xPvbwBNT\n", + "suXVtUcJ3ntiY8d0ZqJ6m7WQnkHyPjs2YvWg79vZF1Sl2/fne/zBr7XHhvCOry6MFPv6q5/4/k9F\n", + "OmDoRSRX6EMh9QKnK3imUq/suG3LvnBmR1DKFEhD3dh9Itg8kNqZA3iaJKrWQlhtgIgcD61NGbzU\n", + "RDzdBOjgRurqjY79PL0Rsn9ZsyajzfFt3Ee/7Z4kQG4AoLvZyubL6Qnuu9TfKzLfB0Ua2PY4tfu0\n", + "Wl34PmwFYcWg3M6snT/89d9wzjn3zbc/d845txSkpYD8RjGSBAz2R/azyaVHDk6GRix3SKjJBX2i\n", + "AO3VxFCa41OPxI1Gx2i3zZc3QLqev7R5de/MI6aa2MCN7PTUrt/Kz8jexX2yK8+TakPRzQzXtzXB\n", + "v7XW6BmurzX52GZVbqHUxnpt49mipILmTzFnVliLWueNc/1MECzuT/lOoow/HxMctH26xx1KhuKx\n", + "XSFef28ZdVksbExaUZONJtEke+fIIRMT74g0A/2TSBDr2KqcEB+319d+T5zNbE+wWot2faKESuIn\n", + "yV/RrOtroK6y73bxnNT1pFIQhywgUsGCBQsWLFiwYHe08CIVLFiwYMGCBQt2R3tnob3NTematbzH\n", + "9QkdGoSWdj3st5bQ3hRE0SMn30sYshNSJuDbuFGiIJRVDyhlM7QWH6iDp1pIfYRPej2p61WQHGnn\n", + "pVaPhrYI3/L6h8J+qo5bo6/a3i0wa/3t5kBNrqg8cAys9Ahg7EpCqwyzdgTqZfhGIgHt+ZoD4zoc\n", + "GGTfanDFUpOM55UQDEmOrTa1qmiDKK9aQBnvz1ZJnBn+NRif59VrkbSt94QwNtWL9faT+K+wOz8e\n", + "DOy81EBaSl0rqvKyvpVzzkUxyeYWRqDOUwd9yITEHEGrqjuUUFBFBW6pCYh7pzA654zquExufVtu\n", + "h9YmhiqmMw9xJ1rzCqGCrZCze10fWlO9qQXCaJvKiL0dhM8ePPpIfuvH+Gxq15+h/l75yis2zzYW\n", + "YnIggDZbuylL9qfR0Brm80YI2ww4iN5NitDSUceIo3G8W2OxFNJxjcoH47Hd6yHCfIu5hTZ60KrL\n", + "RLOOStF5JmrzuO9FR8K9GM+OzCeqd0eVv8ZGdNc2qEl60h3KMYyT7B0Rwx0Sq09jP7fWS9MROgex\n", + "/OLyRXtsCpI51/C3X3/TfnZy32tVNaIEHTnq0kn9O94nSSxwR75fvZ61fYzQ933RO7rB/OAewwoP\n", + "zjn35vIv/WdCNq9rP4alkO2paabrn+E2TYBp9+ylavoh8QhjeHRuOk7VAcV0CzNJsgvuxbHoXV2h\n", + "rmEl6v2kFihV4QbhpmdPvcK8hkyPxv77D+59vHeO1xcX7bE3uJbSXVipQZ+TfN5p8hLXhFJVuj3S\n", + "MqC7JN+vE65TWX/48WpqIbMKNIPBwO4/6QhLCd9yzu5oKoKMzvW3kmQThiw1FEedK1WMf/XKE/T1\n", + "eXoEqsDRkd0nPrs13N49kFCkFhCpYMGCBQsWLFiwO9o7Q6SybscNG7s80+rrSIhwQJ0iIUynIGKm\n", + "8rZIJ1prLSWR/20W77998033ENFOvXoj3dl5iXQoiY2EXv0tPQwlqb2NiDXNPrFc01BbREr6RVKc\n", + "ol+t8y3jRISlbvbRtyXSO2fXhgwMWENPSJRjELUruT7lCZoDBOxqI5XW4bHyPvjvoXadpCnHJPm3\n", + "fTZPZ41xTcUzope8032qWCvZFtefTIxYTmIplYOdM8+FqFMt6Auvlcs8WcNzauRes56Wkt1zzM+5\n", + "kBgvQMDV37LtnGunQuymxeLv9PrDnb4459xqPUdfbK5vQejURIEaKf6TG0MkSN6kOneskhyUhJC2\n", + "3IAA3xFJgPORRxMSkQYhP3pyYbUbu7jXmgBwDPI0EZmLZ6/azy5eeSSkK1411VF2Kt1jnjS1XT8C\n", + "iiWOs2u2/vNZJXUKIZ1CQm8siHgX9bz6PZtXqxJSGyJ/EZe4n7Ke7z1+7M/fP7cGtEioradf+fgT\n", + "55xJuPgTYp+4RRJBX+QSMMfrqaF/RZ9VGex7CVPC5VoxFk0keyIRzqEgYt+gasMKpOjVixfyfazx\n", + "yObJFjNkJWttfOY9/G0mSAeaksaGyHzwwNffm8xsL1puWAHAX//+A0MLfvDJD5xzzv3885+2x4g6\n", + "PHr8QXssAtl6LUR5bo9a/7ADtEuRQyLcC6BpeS4I0gC1FtN9qZmRSEh0kDTBmqfOGeq7FIRxPCbC\n", + "K3IO+HsEQrl+RrX9r78zdfq/+Tf+hnPOucHQkNarK4/szme2J1vkxNrOfUdlEijjcHNjc+x24hGu\n", + "ckX5B0EVMSZNZPf69tpf//nz5+0xIty9uY0J26RJTkdUL28UdfRzskUEN/L8wfemt9Ze/m1337kK\n", + "UJdGEzqUDpEWrJGoUch6ktyOgxYQqWDBggULFixYsDtaeJEKFixYsGDBggW7o72z0N7p/fO22KZz\n", + "zs1ASpveWnjkzdr/naVS5BPwYSKsYKqXJkIiJMkwF2Vvhr6+L+y2q4TNosmiLfOWOrlzFmbZ0czA\n", + "uQ9pJjF8pQrbCbSwVOOj1aeSvlZQyt529kN2OwRwaKqsF1I0Em2KCz9Op6cWRqIuylz0ORbQMTk7\n", + "twKpLJZbCdny9WsfjunqeKLND+9bIVW2Ly2EgE5VboTWlAA/bBnoNv6ExXcI+G3BYxt/alr1pOAx\n", + "54SqV1MPheftdqxtb658KC4WwjJ1l1RbpgQUriHAFSBwTVTo5CDPiwI09dNWILYr7E/So6rdcww1\n", + "KaIlXjZSSDTz82kjmjU3Vz58shai5hxhjlMUjRXE3I1BbB30jRzNBIQTUTvvIAQ2krGmpktTW7jh\n", + "8rUPR8wQJnDOudOx//zemSc9P3xg4ZmXl/7v6SsLD2wb6K0J7E/CPsnhzjm3xbxqpDD4CqHnQkjZ\n", + "vGf8V8PYA4TZdV6lGNe8sL6OME59CRn8yic/9G2STA2GkbtCLB6f+LU1GAp5HKHKuufHvZBwP4nt\n", + "1bElVmyxdiRi5xrQEaJYYpsxzrO08X+GArY679eY4zOEzB7fM2Vt22KUbO5/e/XtZ+2xDpTlOw8e\n", + "u7ftVAjYU8T7MqkJW6BSBPfptayJx+/5/WQtqtfPXngS8cWFzZPjI7+36Z5MDTpNHuG+Qz0355w7\n", + "v+fvSXFgD69qT+jeoTZg2RUde3bMoX1GJW7nTHuu17M10Tkwx2Yz7BOFaUXRXr3ye20l4emf/exn\n", + "zrndkHlLlRBiu0MiS5ZLgeKNH1sWGffn9mO7WNqY3NyiuDD2vY17YOdAKDhP97X97t27b5fHvq/E\n", + "9pzPYqGUVNg79D6xCsi2ZuFnibWR2lLYuh6P/NpJZe9u1708dzMWrU/2Y3epVgWp95+3agGRChYs\n", + "WLBgwYIFu6O9M0SqSTP34L4hInO4wvU3lmo7eQmFV/E+RlBRdpJqG4Nkq+jDAKn4ihIwnZGok9ZB\n", + "Yj01JeySUF6W+6RwTVel13NIEkCvQe+jre8ln1FtvFwr0oJ2C9LDN+i1KFa3KJqQstdI9V8KAXpw\n", + "5j2tLsYhEhVppp92hMQ/W3qvJ7+VtGYgYupVkJT48FNTts4wjuMj86qI8KicQQEPOwZaRPKzN5Bj\n", + "naTkg7CriFSL8In3uTiAXBE5XIpS+NsKuDNRZyeqpYT9Cbz0SPLKqcY+FzStnELqQtCvNUjhkjnu\n", + "8o7/nPNU1eEPzSGilDvqzEDEqupWvkeyvR27mfr1dHVl/SkGfk7OU9/2YyGsnoD4nkhixRFQzMFo\n", + "vzaY26n15+9TKkrhrFdVLU3iYAkEdJr6e9Ibvm/nHaKu2tq83xzedCVk+xr+4HRpRPUV1sd6rbW2\n", + "gHpKO0mAbsdTXMsBUrOVxEvUQUnkfRBvHz2ydp7eg6yApKQTxezIeJKAq6hnguwKOsH9gV0/6vq/\n", + "88I8/QhrslxZEkEC4ruunVaeIjOE6/TU7wmf/eVP2mNXqAXH5In0se2JTGF3pSEYXB46d2ugPyc6\n", + "oFsS223fefrdF75tgojkXSq1A5ESRPbkBGiWwG9rzIWrq9ftsQSfawp/hj1enxNvLnxfN5KU8frC\n", + "d+jhQ49+CYe6lYZQFW2S3WdCmOf+SOVs55yrK3/9gdQzpSQC6wpqvykNcHNj56U6+mplaM2f/umf\n", + "Ouec+9GPftQeW1HZX87btqMRsn1BSQ6V3aHshLVzPKacDGR9Chv/i0vfh2FX0B/UwmUdVuecu8b+\n", + "H8mzu4falV2RxCDat5JEnQUkDqiwPha5AiK2a0HfciSoxPJQZBSrlmdCyhq3EnUqUEkjdfacag7I\n", + "IqkFRCpYsGDBggULFuyOFl6kggULFixYsGDB7mjvTtl807hSyOYDKPWenoqK7NaHGzTckkIdWInl\n", + "RyAWjsYGIw5BAM0PqFhb8eCdcsDOuV3F3gSK6cPhiRzbL8ZIUw2kQ7pQbxcmXovuUq/2lI7RhAAA\n", + "IABJREFU0GqnZxDrHDomSwltMhxYKmQLbD2RvkYIi/X7+7pUdUk1WzsHNZha6Nw5t1iwGLFBrNNL\n", + "Hz5Zr+yeZChCWlY2ng0IiI2M8RlInFpwkucZo8ht1BjEOkUh06JnZOcOQltKRFzjbw2Vaui1PR80\n", + "XRQWZ1Fhkvz1HvLeKRScA26PZerUCK1MhcTdRdhUFYBLQM9zUUDvIqRJDZpM7uEEoRWdayRWa2hv\n", + "gn7FUvA5z/xvL64s3DNFAdPJpYUKeggbEVrvdUXjCTo2mWgrUb06dhoeQ5FXCUFTvTgVzbBeCrX9\n", + "rc37zdSHviZIWFhM7Lwp9JOyxO5/E/txTYTYW2DupLcWMqwQItYixBz/11cWbrn/m540z7nRFS2y\n", + "DUK169JI5GOEwmIhojI8vJVw7zU02hoJ7cZgVM9EbX7DsLQQqjkHBgMkm4jGUZRRRVwSNrD+EmFs\n", + "JxH0eWSeFj0fDlzefN0ee/atp1IsZC9+CUJzVPt5N5O2zbAXdC4tjHoFfbSF6DNVEz/+3/z0x+2x\n", + "kyM/t+ZSoJgR2iy1MW6pD/jw9tbm6yn0qcZHFu78+GOv8l2JthcL1O4mFCU7/zpnCR0alqeOUoow\n", + "2nuPLdx8eenDh9fXtq64d+i+ZsV1bexOkFjwWkjxVwh3PXpo1/j000/9OaD3dnFhIcu8TVixflE9\n", + "/bPPjOxPustIlN0rhJYZHnTOudKxeoTtMYOhP19XiqDz2cmi4frkHJE8L/sUqxhoWLZE9E7pIwvQ\n", + "R5rE5k4XmlbjgT13Oz2/Trg/awUIavblkSibI7RbyzNhif1Z91OGbTuin9eG+6WP9YF3BbWASAUL\n", + "FixYsGDBgt3R3hkiFWeFqxt5g8QL39HA0nqrjX/Pa7ZG2Mydf9M9PzOy5wPUizqRtNou1IhT8dKJ\n", + "UvCFdCOEbZMksDdPEnu1XhO9pEPIhaauk9C4g5zg7ZxoVV/q9fF8et4IKcZaa3CFdH0lO7NDC0nh\n", + "7aNNnYG9adOLOQY5WOsbmTdh57135j3YzntGzryBevGXX33ZHstAznv64ll77Ae/+iv+tJLWS4Qj\n", + "TuwaX3zpz3OLmmuRU8I4FGb7NiYrIFgrSeufTEmoF0TsgEwAazEpAX259F4K75N+PzlAMMwpjyzD\n", + "HzOFWWQdupA4UAXyCK6OIoE9IJCcG6qYPxCSMY1t1z7Q+1IvlSjdrZDN6f3OZoacrYCYJd95L/lH\n", + "P/ptuZrv/0LQxzyLd87l++j78+TJk/ZYVQNNnVqyw8nYr9lI+v9m5dv3FITVx+8biZp1GlX0uwIi\n", + "1qSGnK2oQJ2K/EK7nmz9cW4NRYH69sbPZ6LeuSDdXRDqh0NDxCKMSST7Cj3cjhB2WTOyFESyB3R4\n", + "p9YbSMtbIcXTw+4gUaMRRMqhXp4SdlmcTJGWpmECiqRtYz7f3Bpy8u3Xfv09fylp+tf+nhWQRHhz\n", + "aZ999QXWq6iYm/yEzfVTJLZcvf62PbaZ+v6/urT9/OjI7/dZbm2fzv39fPLEo4VaMYBIj9bLJMLx\n", + "wQcfyPc8mjMUWYleKzWge4L/7UfyPCHZ/uUrjwSdn5jUB+u68V/nnCs3Ddq5ku9VaKet5xKRhdVK\n", + "E4oa9MGehTn203Psv7pfLBYT/GvPhDH2c6011wFKqSn83OO0JiJPHcvecXp6irZZO1mz8/ISchki\n", + "IXJ25r///LmprbPu6FIkFJggcHRka5fPnUY21AmQ5bEQ0DPWU+0A/VWkH3sn9yHnnBuiAoSS7Xnf\n", + "OV/9F3wftSYiZXxUlf5QDV61gEgFCxYsWLBgwYLd0cKLVLBgwYIFCxYs2B3tnYX2XFy6SojdW2g1\n", + "Fbnh+PdO/N9U/XbOuV7tIb6H90wx++yI+kjWnQbK29tUChknHu48wBM/aIRUVR+FoRolMxP2U7iT\n", + "nyss+3bR4q4Qy7cIRVGTxDlTpRWEtSXIa3FhqjxvNFQHku2TRzZOBbQ1bqFtcizK5hVCITdC2P3w\n", + "/Y98O6WvDx56leMjgUJvJh4C/frbr9tjzVvFeJ0zSPXlq5ftsRWg3wYEyCyxazUoPPvll1+0xx7i\n", + "+gz7OKfJA9Z9DXPRMpBxF0L2ZgiW33/zxkikfXy2lnGl6rMS0PtIbBgPDIpeLvy9u3pjulgVYOaB\n", + "fI+6KA0Uu1WJm3ZIC0uPMQS4FMIs1bY/Lj5uj50j3PLqpYVWNgg39BBmvhXV8eXKz49Yxprzeb0U\n", + "YjFg9nNRwCdhV8M9RONzUXbuAoL/7AsfFviVH/5L7WcF+lCIYnGW+fnfNBbG2/SQ2BBbv0i23coe\n", + "w9BXUagqvB8zrnEtGs1kk1yKJh+NfR9Pjk1Ha4OQwptLC3f1+3aPaR30Q8MtMcIsuhap8rzGHMpH\n", + "tv85h/WhxchZM1loCTH2iUZ9ZXy8EaLuj//inznnnLuVMEaDSgLdDfYwSQ5YlP57/Rd2T548eIQ+\n", + "WFiWhWFjUdv+5qkntv/0i5+3x/7wd/8m2r6vbcUxVN2n73AOJsI459zjxz6kfHwsyt4IaS5Ei2iC\n", + "MK7uDX/wB3+APraH2jDTCvf1s89+Yf0a+n4NB7b/ZSkL6to55gif305sP5lM/I1SBXImL2lhYpLr\n", + "eT/LjTwnt/vnoJ2eGC1m2PXhvqHM0xh7LFXXnXMuwyuAFiEnUV+fcUoad243tEqSvSqhc6/X5985\n", + "FPKHYxu7Y+hN/fj//MftMcoM6r7bSXyb+ggLNlJZg0kBel9TPAxWtSaP+RPrc3oB6oFScPjM0p14\n", + "KfPokAVEKliwYMGCBQsW7I72zhCpb7752t0/E3VYkO26HXurJDrV6ZtHPGz8m/ZY6n/1QNDdIcdB\n", + "2TsTAvAaSATfpnNRMaf3oSrW9FZ36rrhDVe9JCJS+kZM51CV0qnA2pAc6sx4XiWR16W/riINzQZv\n", + "+AK/8BenUn+Lsg+FqBhTHiAGCsLzO+dadHAkRNwUBNCN1Lpb3/gxLKVNBVJnf/WDD9tjM9SVWo/M\n", + "S+E4LqdCXoan0ev0d77j++i9hcHAvK/1moiMeUhpBiVo8T6WIEhnO8r2qKsmqrzRW8jZaCTzqkdZ\n", + "BztvF+jEWvq/BDl2sxL0BSTivqg4Jwm8dCEuLtGfCNefiYoxic0DqeE2xzGt/zWZ7HvaRClHfbs+\n", + "BLPdmUhc0NOsII3Rl5Tnck0irCjbY/qlMq83FeskirIwyNi1KHZTlT/JZEyATv3G7/4t/x1JeS5Q\n", + "z24g6vgkjy7lWhXboiRupO6XonZMtfueIMELJBtQ7Z+q4s45V6J2nxKGWWVAPXTOoY0cG5z4eZRt\n", + "rf8t8VVSqYmOsjacc1b3bAtUOZJ09RxK9K4RYjlS2GNJ//6+ZO33PrQKBL//B/+Kc865P//xP2qP\n", + "nQAdI1G/FPmVVllaJGEePHrPX18SS6j8TeK0c5YM9KMfWkJD1qbO6xzz9+nLrz7Duaw3I6Tm35f6\n", + "fzSVemCa/laQngFUtHvy7GiA8PzkJ/+sPXbvnieXnwD12XSs/0RYlOxNhOP99y3ZggR4RXNjJJvI\n", + "NtUmaPCaztl8oop4T5KSuCcVgioSwVKUiOhLJmgq0exMHvtEthSlmc/9+L94YVVGNqjJd//+/Z12\n", + "OOdcBTRnPjHU5vUrj2z/GqQcnHPuwTmiCZG+dlTov5H9iY4uRHanTDFoc0pY2BlGkGzZQe7xzKo3\n", + "QjYn1CUyPQn2qefPnlpfK7/uS9ljCk34OGABkQoWLFiwYMGCBbujhRepYMGCBQsWLFiwO9o7C+09\n", + "f37lyrlBcVnXQ6A9gRhJ3u2Kxsb9Iw+BVhLaqWoPXyphjDBep2vQMslzDK0oFEo4tdSKskAAh0LE\n", + "a3WBBDKO8/330QTwfZ5KcWW8txJ2rNYGO84mU/e2MdynWkRxq1ljY0JY9vHjx+0x9lX1fm7eeLh1\n", + "DDhXYU+G9I6lyCT1s16+NHI44VMtLsyx63b3w52vX5oCMuqo7sDthKBJCtW+vn1+55y7AWFUjzHc\n", + "sFrtQ/Aa2muJ0hKCcz0q0PfQZyNCU0dEQzvsl4YbnNsngDNEqOGO9XqJdsg8xcfUCtPrs6CmFrQ9\n", + "eUt3yreTBVpFgwvjqVpUHFuF5RkOLOL9NcS/EykyzfHcyn06gdp0LNe38bfQwhaE+jy36/cQqnnw\n", + "vtcd60j/O2h7I9sUSbGLjZD4oaidyH3aIHnl+lqSNxBa0zXBMeM4qIo2Qyoa9uCeoaGVDdbRtfx2\n", + "fM+vI93PCoQeEyHxdkBlUAX2Gve2Ay2yTMJDJJlvdxJ1UDEhFTX/tqiv6l3ho8Ta/of/wr/sP3MW\n", + "Kn712q/3bseHVDVkzDV+fm6hKN7jRNSxSTbWNZGiTQ/vW1juUGHusmIRYn+fdL0yYUATRs7PfVio\n", + "J2FpjrtSEL596nXu3hddsJuZ30/uPbBECZLtqwPagkxK0DXBdaWJKimqAXwgdIcG907XJDWgdE3S\n", + "ONaqhcX1x0Lxeg6lDFhSis0TXv/QtXYLoxc4r1EqXr5CuPVrn/ijFRjOEEZ9JUlELFZ8JiE7Jra8\n", + "emZ6U9wf+5JQsu34tl++sPNx7r56+cI5tzv+1FTTvZbPx75QGzhndPy5x91cWaJK1CY8yTMmk/eC\n", + "AxYQqWDBggULFixYsDvau5M/qDM3WRqZrECKp2Rfu5fwID943+oQPS48Oe/itdUfik5Qf0dqTRV4\n", + "Y+6LLLIRH/2b+Vq8b6pYD4XYPEFap2IP9E5VFbxCqre+EZcg75aSpkmFXiITW2UdwutJxVukxEGR\n", + "SA051C47EeToUF0/kmiVqE7Jggwo2VZqqFHW4NtvRYkYnvGNok+4ll6fqrDffGPkRBK/14K+sI7g\n", + "WsirRKfoEakHS1RtIp4+UTL9Homli4Upy29Qx1BJ2SWQi1zQBKbs3oDkrarT9D4VkaA3c3Nj12Jf\n", + "NV34CjXu1HNiW/TYC9Q1O8V4dofmLc2mvk1xLMhpzbkm6sxANTQjnoiVqvgeUuBv24L5p2r/RLUU\n", + "1eOcFaD14Dg9f+aV0kfi/dVAjmupP9cd+gSJfODblAqqcIvzjoaizoz7VQmCw7mjBPQS15jOra/z\n", + "Bdedqh37c3M+aR0woq7a/3aNC/qWQc5A0TyiLzNRdqfyeaRzFyTzuaiNFyDl50dAImRc3RbVGRq5\n", + "h0j1r2ub60m8r4pPYEWrB/z5n/+Zc85QIOecGwNN5TzRZA9KXCiJ3CoGaLUHIAHS1wpzayvX4jxW\n", + "2Zfrt5InFBHjtSai2E/kuJFrXUEpP5dnwr0HvgLGlexns7lfH0peJnLDa2lZU6p+71SgaMnh9qyx\n", + "uq7227Y/sk+MsN4VTSayzvWkex3XpM41zn89xt9om3j96UxRWqJvcg18rkr9x0d+j7984+fYRJTt\n", + "59inKkHpn2H9L5c2J3/nt3ySwWJpe9L02t+7kcg0EM0rBPWKUVHh5Ut/3ufPrV4hx4nIpHOG0mnk\n", + "5Azq9WupisGhPT61RIE+EiAauSe1C4hUsGDBggULFizY/yv2zhCp3nZXrC8Dz2UjbjW9yliaWUX+\n", + "N9e3Eo+GB3f/1N5IE9Zu0pJ08MQofqmVoU0SQcTyJObftgmohoqFLVinS9KU6Tmo50KUgMfI7XHO\n", + "uS7i1quVeRXNiiiNnYOejv6WMXyNm19DdDMSfg2F/linKM/N+2fbpoJgrOCRas25ycx/nsj1Wc9r\n", + "x0tCH2U4W09IPfwogTeNG6V8kA7GJJUK6ps1K60bR6JNhe4KSoC+ako0azwpmnN15ceJHm5RmIQE\n", + "PXGtubSAtziTY3O0RVOYOXbqTVOSQ9tUAM1grUEVEKSTqPefIq5ap3G5ECFWmHG5BBE4gPq1khRA\n", + "MI9FQmMFBGEky8DqVJZ7xxTh7UOyQZHj0cjzoJKddeXHJwXCUQiq+hc//UvnnHO/9Vu/2R5ra13K\n", + "2mVbJuJps9I70WfnnEuxFraSfm18ST9frm9sX/nkk0/wmXwf51BR2XvwhE/ObOyItGr6O2scrkS4\n", + "8D3Uh6tkoSwnfh33TzwiFam/C0RsK/tPlGCtpcb9OWi4UW9evWgPpYkfO+WSbkug+UATlfvy/vte\n", + "6kBFZbn/TKe2d7Du2Vb2nxnm6XQm/B7wNXdElzG3iQxVpSII++gvTYWTK1y/L2jap5/8yDnn3P/9\n", + "U5M6mIKbqjVZb258PzYbvyYfiagx90zdQ8ghVVSLPCRFkzeUH5B1Qv5TJXXiiCId4jkRfVHeFNc1\n", + "+aO+7f4aunfxuTMTftnx0RjX35dzuL2183F9PDz3Y1Gkdr+eQjqg3toAjFBDMZGox+eff+77Vdt+\n", + "3sn8HPv2qckPnAD1U+RuBgFW7qc//OGP9tqm6BstOqC+rTxcStvEEjlifdhC9thudx/hVQuIVLBg\n", + "wYIFCxYs2B0tvEgFCxYsWLBgwYLd0d5ZaO+oG7taQjy9MUJbQg6tHdTOC4MRCWkvhfuVZR4qvn9q\n", + "Kawk1tZbg0xXa9R1Y80plUsAVLtQIh7g1oXAniuEwJTETIJurAg8/qNhrCRhGMHDyCeiZtxpQ3ui\n", + "WA2i6kpI+SuELKYTgyx7gDQVxSQBXJXVCRGTKHgrdfV4LJYQA+vJLYSczH5puiyJf5u13RSSgdNs\n", + "v67ZoTpxtEPyB6dSh4yhL5IJ/THfPpUEYP23i9eWvbBCfbjTM5snw8ER+uXHaSA10jg/riVkynTy\n", + "RMI9lJ2YzZRY7OefhiCOoSi+ldgew1Ir9OHlpaThvpWa75yRw28PEPA13MDfKtmc5GH9Hv8egPSq\n", + "48/+aB/6IKCuVjYnmDyhyt5UQH751EihVE9fr63/bGevtx8yGQ39vZmLwjHnzkpCoAxBLkT+4gqh\n", + "bQ3Z1LhliYSbOJ4kFh91LF2aIY5S5vo1QrCzmY0r57CGWxg+11Tz6YzhYwlLMbQq5zvnfI+x70Wa\n", + "lIIKCMpZaBiyFEkWt2/cHpYSWmQ4TEm53Dv6mMMkWDtn82l3XyFR3/Zpzms9RlrE6enHcsx/T9fO\n", + "eMT77tsWSQ1V7iu6rzL0diuE/Rl+G8v3XoIA/fK1rTGe5wnU2Z1z7tNPf+Ccs8Qb3a/OsHfoPeQ9\n", + "1j5QuiGRWq+UlhnIPOGaaXb2hM3O+TSFn3uoPru4rnVMTLJl/7xdCbe9+M6Pic7dDZ6ZvZ4d+/LL\n", + "z3F9yLRI2OsIz926sfO2fZXvpQhBX0iomEvr137Nwvcxkqs2Eu7Mb/25nzx5f6cvzol0UanH9hOw\n", + "2hq3krxxAjqQUip4T6YrO9Y0+88ltYBIBQsWLFiwYMGC3dHeGSJ1/N6Zy4byBl1QVNHeoJmmuBFy\n", + "6rJk/Sf7XgVBPCV2b/DmXm0M4Xm7Jp6moc/xRnot6MsSHnQq6cJMl1YPgm+9mpLNNOpd4czezvdi\n", + "8ep4ulS8iiEIux2pF8i3av1eATGz169N/PLjjz1Rdi3IwTVIlEdAc779zqQODomVUUBzLojYKVGV\n", + "raJP9L6FWL2CcKiQWOnNKXJED5c1n5Qw+eKFJ8UOxDN6CJmGuXgQvI+KkjF5QQn1nCfPBCWht7dG\n", + "6vxyuV9D7VxI5CQeK3I4JTok8hf8HtPFnXNu2yZS6HyiN+XnRJsk4Zyboiahpisfoe6cVn+nEOZU\n", + "RF2JmB1JnTp6uM1OPUOQl3lM+kBCva6TDqQjyqUiCL4tMyH7soaVyglMgRh0+3ZPmEbPdXX5xtCC\n", + "9973SN+3334n3/fz/uqNIY231378n8p8JsKiXaXshSZqMAGFBHglUZeYL7quy9rPj8dPHsv3QFhV\n", + "QUDMe03UYIKKCuey313x3EmybYgqNOZpt3NHzltjT0x3hIH3Sbbcsx49fNAe++P/AZIlssc+xOcd\n", + "tKkQD/5tIrT2oRadAO4Puk8en3hki+nlzhnqtNbaiZW/aRTf1CSeFeRcColScH7oOd57D6T4vq2T\n", + "Lz/3tfs++dgQMQqrptG+cO9HH/nvxZGKP/pxWq8kUQkCjpu1ocQd1Ik8PTc0j2srFYmV9WI/oYdR\n", + "jy6kQBYH9rpDKLXKmtQHxET5+UQkOdjXRq7BPflIUP8jyB/0uhTJNZuDCK5IG/dVRZPbGSaSFMet\n", + "JI/NMd7v2cwI6GfnHuGeIoqi45+137f9p9MKfNo+bXumCqz6tivCylq0p0fW/7Wg3YcsIFLBggUL\n", + "FixYsGB3tPAiFSxYsGDBggULdkd7d2TzD09cJqS39Rp6QomExxiKawxaJRSZKhQIaFO1ndZtXT27\n", + "Zg8aPITq37yxmlusl6Uhmw4g7Uz0KQ7V6TPy6r4qtxIACSkSlo221q+vUMPo3n2D3TeAE5WwSih6\n", + "KeE2hrs0LPfFL/z5ZjMLld174Il1E6r5ythEIKwqZJ/iWrFA0fxRmu6HsTS0xjaPj/bHTuFmai/x\n", + "+1SJds654dD/No1EiRyhgC++/LI9RuJ5Lu0sQJ7uD0UVGm0v5xYCIAT+ArWWUgkF3X/g4eTzexae\n", + "I6FxPrcwWrcPbZexQdtxGzISHR1oVTHs4JxzNfRLloD4jwQed9RR0zAyQls6J/jbvtQ6TDGOqqMS\n", + "IbSoYQHqzFDHKxHdGwobX0odqsUS35d5wv4o2Xa58N+bL22cSGI9caLKj1AqVYSntxaeSBPf19fX\n", + "Fsar5/66L0Sf6s2V//wXP/tZe6ytayjJJgP0uyM1+cqaGmggrM8tZFRgPGutVwb15kHX7tPXb772\n", + "7S1s7NIl5rqExXgXd7S9QB8YSBhhtfHjOEpwTEJWDcjLkYSAoxrh2Y2NdQw9tEhFyxxClTMLQTHc\n", + "VnRtTKhpVmKPUT2fVasFZ31lsksmYdwx1kK1ldqNOJ8SlW1PthA0R4rJLqmEXT5BuC2V6gSsIlDI\n", + "84RciS+/tnDvPeyTqrZ9/9TvP6qB9fNf+L2F4SmtIcr9XFW0Fwhz37tv+wTDY6RnOGcEcCVKs2ad\n", + "hu9IfeDYaG3Iltohzx+GR3VeWRKF3RP+5r5QFRjuUv02PkeVKmPPGz/XNAFhPoc6e21zqJ+DliLJ\n", + "HvO579dclOJfXvrw3eWlhe/X0Bv7yU/+oj320Se/6pxz7h6I7Su5hwXoAXku9fqwTl+9tH3iNfYM\n", + "bfv/9mf/k3POuUeP7LnLcKN+L46+/1UpIFLBggULFixYsGB3tHeGSKVxx5ULeTOHR9rU0iR4i/1Y\n", + "yKnwOrZS14dvzoomkVg6kGrys5n/fA5ERj2TLby64UjVTIFI7aBK3qIDle6VWH6oqjm9BBKqx6K6\n", + "e4S336fPn7XH7p2wrpV5WqZAfdweI7L24oWRqEls7PTtLZ31AZnOrfWVkthfQ5XVcwxx0tj79gZk\n", + "T1VRZ7+VWMz0581rI+nRc8pyRfOSnc/Wcn0S4IlWOmdEzXsPTG04w/jUQgqeAelIhGxOQmda271r\n", + "Yn/uj554henLS/NgKDGgshIDeJh6T+j0HwmqQLK7qn2TZKxzoo/5mcGr6ktl+vv3qTpuKM1rtE+P\n", + "DUfe+1dEaAhErpFKAaenfs6UpZKC/d+sr0bitHPObZDyq3X1vvnGe463UuuMddoUuTlFCntXaud9\n", + "feW9z8ePrK5V68thjJXYPcU6nU+svTcXHh17+tzqOn7+lUdfhRPcevNKok6IoigBHQhfP/djOBCk\n", + "bzb3fby5NUQgy/x9f3NtxxwQkytZEwnmhPafSMNS0IcbrN1TkW65uPWfJ4nvfybob5RgXouy9PwK\n", + "dSJz+173DPteZt+rlx65W5ZGyv3NX/8N55xzP/6Lf9oee/zIz1Ny5xWtSECsVkSkB+iyHXPn3ApJ\n", + "PsuZoWTTKaRbpCbmaOj3QF1PXB99nC+SsAJRL/0+EwRUEoTI+oPHtk/0kACgCuj8ngJ3v//7v++c\n", + "s/qbXF/OmVK/ojVs7xtBjp5grWsNwQ0QQ1XgJoqk/WE/uBb0WaOJOjTuoXpeHlOUinN3p7IEzr2Q\n", + "MaEUgu4xHONDZHe2aSUo9fWNn2tZbtfaVH4sbi8tKSpGndAbkWk5RoLM7/z2b7fHWIM0Y5QqsblW\n", + "V6yNaM8fjjsRX+ecO0PVBk2eefTwEfpg31ujesbP/vLn7bFM+nvIAiIVLFiwYMGCBQt2RwsvUsGC\n", + "BQsWLFiwYHe0dxbau3zx2qUrg0cJH1dbIdFdergvPhIS8ZGH+GqBOEne05AJCbhbVUAH2W8O9fSe\n", + "kB5JfM+ExEldmDwzWI9aQEoYJAFZYXzCh0refgniG8nWIyEWzyceiuwIYY6EYhJh/TVAgBVo+erq\n", + "9V7/WXD08trCCFUNbS2QV++DfOmcczfQ4lHNqi5g9Kaj/d9XbGZbYiEWrqEiv5gb3M7xzoTsWyO8\n", + "SNVxDc9mmR+L+drCAxwz1VGifshECnRS7TgWsveSSsmaKIDQXgUy4UMpUGpK7DKvAHcr3M4wh97r\n", + "AuHLsYSKqcDOkIFzznXf6711Pg1ZUx/NzsuQ7tOnRs6MIpDSJQRC9Lrf1+KyCPd2bPxjd7ZzraMT\n", + "I/2uKj/vxkOb1w8eeKLq559/0R6j8vvnX37WHnvV86HCrYRl2bfJrYURGoSNN6geUMU2rxOqswsB\n", + "/eaN1xZTyJ7q5V0JwVArSonSHSQvOCG7MhzYzsmtFMjFXH/x0pSYmUSg5NM11r9WUejjutsL6/+r\n", + "C79OVVmZFIRtY7+dg2xbbf33NRRRYC2qttEXX/ow51Y69v6Hvk0PP/pBe2zDkFpla4yE6r/9L/7t\n", + "9hiLJM+QMKAFqjuF31dOpLg19eZS0dEqsSecnd5vj33yCTTonNkVQrU7Y4JwZIk9djQyesYzUB8S\n", + "2UNIxtaQVXfo+/UEIXvnnPvq81/4zyRUeYziug8fSYUF7PExtKVKGS+SzJUAzlCUVoDgXkz9Jeds\n", + "n3h9sV+9QEOlbTISPtNQJD/T0Bq12HT/OTvz7dRw1/JQIXXscRoy5Hl2VOlZgWGL56o8WDlf9NnJ\n", + "NjdKWEeYV+/nEGN3JNpepO00shdO8cyeYu/UQtbTqT92Jtpp7MNCwsjPoGz/sVzrww/93zpOVLTn\n", + "GDq3mwR1yAIiFSxYsGDBggULdkd7Z4jUm6+e76jJUp07Em95Xvq35Y6k9R6XHolW4Er0AAAVaUlE\n", + "QVRYC0ozJ/pTma/Tg8em8gd8YyYRty9EdHoQlSBNZ+eeMLhZ2dsv09UV/Wk/E/I2UaTJxMiGfOsn\n", + "me/m1j4jmvBAlLDnIA8rYXACku8hD2YltYGYarsWpe4cXvoERLxIlNCJVqiKcNHzb+mqrE1PQL0/\n", + "tl2RM3KcG/E/Hz323ulE+t3t+rbTg9F+Ueohtq+7Y0gdrMUjmYOUrvWieJ6ppHr34PVW4pH1gcBR\n", + "vXm9sfYyJfr65k17LALxV0nJQxAxte30JlXtOQLqmYra+1fffO2vBVXy83vmBZEIfXZPa5357z0R\n", + "Ze0LeLipsMKJmKr3Sa8/EeRwGft7xrn45ImlAadL1MHr2PVXQI4e3fvD9hjzPp69sEQJ1nG8vrU5\n", + "ydqVz1/Z93LM0xRrsxLW77NnHn16+MDaRA+2Eo94MGYNQxvrGGPx0Ycftsc2Sz9n1JtdsE7gBnIJ\n", + "pdSQQ1OuRX5hCc84kq1zOvXJIyo/UkLtv5a9I0n8vfg2sqSQFPeHc9g5575Dyv4p0unrcj+tXdPl\n", + "VyDKagLOEmrTw77KBPh2jnqCnLPKgzwJstjfkyzxe+1C9hDKVBBxds7QvELkP47iY/zW1t8hojZR\n", + "kgtBaXpAQsZIvPj5V1+3n62BumlSxuP7PnnhZmpSLwmGrJTKDkTzLi/tfg5Adk+lnirXEQMRcWLr\n", + "le3U/f/Npd8fBJBz//Sf/BPnnHPdgdZu9H+fn5v8AEnRinC/eOERUEqnPJD5f3JC6RCbE0z713qJ\n", + "PxMpENqnn37qnNtFrohI6T7Btmg05xgI5MWlb9tEqigQuUu7tq8kkALpSZ3A6crPmZ4mCqBqxWJq\n", + "8+n/ae9aYuO8rvN3ho8ZDofiQ5T40IukRUehZcduUqNwGiToInAWaZpN2gItsiiKAn2iqzabtstu\n", + "WnRRtJu6RVAUKQIUCbIpmrQo0rdVG3IcRVZsw6Le4lMkxfeQc7u458z5RiQdgbU4JnO+jUZ3hv9/\n", + "3//9z/nOd2x+WGAT4Grvd2/nvePeXQ8KqqlFfnXVf39e5RJGRt0ieetm/tvbN+7Vy9q1zqzKbkET\n", + "Z894UMxuz3tGWKQCgUAgEAgE9ok4SAUCgUAgEAjsE5IalG8P6KYi6bmLvajV2J6c/2lpkGvI5stz\n", + "QyP1kjM9WUU5kbTTib5sKjXdJcDddmVKkGo6R2YW340w3E2JGg1LpJlj/cVuPHNzsQtue3tTf+/X\n", + "Md0qc4Xx/Y283U5aTKbszCrCG2rubCE7srkFWAG4qu6AGpFy20v5e9M22m7QuMp1WqfkjGbuZTfe\n", + "prn2yI1lZs87d9xlM6jm9mKJiLLqqjPNKsCVoqWwk3S5rq7ChQXXGDG12XUiwFr9hKTabSxYbXhT\n", + "tW1aC6yLZYTWPO4LZLJe37CgBJ9D09PZtL9BbtSkbhxObmwuGCbRmouU3VILc3luPVC3y7mRs/Xv\n", + "LlzI5mkmmz5UwmaxQcclt2FycrJeZvO4o8PJ7kV1YwqROOdmsjtgeia7Oy4++3T9O9Od4Xlqis1G\n", + "cM3IfV2luWPtF0pQ2q6Ezfk5d8FY/czFk8TrZuZ7dnudPpXn1QaRws2PzElr797KZHwOSrAMAMs0\n", + "xjC3+JoGR6x6G7bUFWnzAAAeasLX2pbXc2omuzt4/ZtWV0fJ+//MYL6/UBt7j2dXTbFIwRvatuqW\n", + "zs0ub4MpO7O20rHu/P0IuTFblbBdof3P9p31FcoAofcoEFFddDwtqXqBNuUeDXawROUA6psc65gZ\n", + "OXdri6nlGRyoY/pE169fr5fV1666k6q7aPHNLboby1z6HADznl5vZMRdO6aozq49S9A8M+MBBbbf\n", + "dGm/87q+9OqlhjoCrg6/Tm7E8fG8jqbvu8tyq6Z7NwXAdKmLknWczN1m7eH15y44n0NGqG6lcbLk\n", + "66xjZa7nFqIA2L57vM+zDUwr5YPbaPctaP8/pMTHo+cyYfu//vvf6mXPXHwWAPA2uRiH1UW5RCry\n", + "tsZqtCYsGGdlzfuk05Il1/XZiLCua3x40AMb7Dly5Qeujj5ybmRHu0yVnonttk7YBQ0R/MznfxnJ\n", + "ODCPICxSgUAgEAgEAvtE08jmGxvb2OZcb/r200mWFiMsb9NbjZ2mh087EcyUdVl+oFPfdIuU/8rD\n", + "2fP1mBxq4JxLZnVqJ3VWqZMtWX4hf2a1cQvJ7O72cPKpKSfI8bUAJqC79auzW8PqKazaQmxrpABt\n", + "lpgCneqNeL617W9/5Up+c7K35LV1UvjVt76ODh8UU9g1RW4A6NBXgkZ1Xn2roJN+ScNJSx3+lmQE\n", + "eFbPNlVse4PgUG8LNWein70Zzc77G+m5c+cavgOAguaM29pmomz9y3qZ9bupCLe0eh8er/TsuK5Z\n", + "B6cp11uL1pP7xN7YurqoTqZ2/tCtWYPDeUwKLblPlpa8XaYyb3IduZ65rFRiEnm5oS1cZ5ZOWFhQ\n", + "+Qc45pWgOjg0oG3wNeGyFqQsrda/u3ddfsHCiVsoRNjmNhNLTan+2DGS+KjoZ8ntaiXFbgzV9FpO\n", + "tr17NxO1h8+SOrqu04War53Bk7k9HUTsN+mGGVI7FyO7HzfCun9XqAcM+HxdV6vXOlm/zDrY2+vW\n", + "7AcL2epVo79d1IwGnZWdEicNb8lqMS/pvsbj2qfZEM4QEbakef/WiTBdEF0ztHYsP107zZ3ezjzH\n", + "E+2xZvW2lSC0Ji3UvUhWjRXNtsAh5EZoJv47Hqpln9eTkaJ5jzF5lm19ANyddmvRSy+9BADomHXr\n", + "k1liWVn/ZH8ea+tzAEg1zedIeTKnv2eSNN7+wYFcFyORV8giODExAcCtIADw5pW3AABnznlY/f8q\n", + "2bxC+99HL+S/PX7cLVz3p/J8FiG1d732229nORG2tA0M5HnNVjV7Fn38J36yXrawkPcftrDWtP0r\n", + "1CdjoyMA3AoFuJwP56ns7ct1mp7KfdJGkkDmseG9486NHDDx1tWr3tbpXOfjRLbvUGs/7/uj5/P3\n", + "/NyzoBTbEyud3v8P5vJ1eV4Z8f40zatlteb3cw49PW90dXvdbf0lzl6yHWTzQCAQCAQCgSeCOEgF\n", + "AoFAIBAI7BNNI5s//dxxpJqbx0VdMYUC1yd//sjwWL1kYuJ5AMDogJMITR+ko+ymZSM2s7aKmUC7\n", + "K2YK9/ubaZfdGGaqZteS6We0ErHZCNALZDKtqKYKuwVXVrLJ0NxYTCK2+jIRs0V/x2VGFGaXgbn0\n", + "mGxtOlsFSnja35+JqkYovzHp7pnxj4zrvVgxNpuHG5JhKhG1SO2y/lmnZLibG7l+UnCTubnqykTA\n", + "XtUxSfpdC/V/qZjNvg8W3d1qmirbNE3qJl3xPjGya7XqZZ2qH8Zk4xZ189hYc0JfcxU/JMV0Wy9s\n", + "iq4nXCZ3b7HViNo7ie2slGxtrJvTKYjBNGPYPbythFXmPLYUzN3m5nlzVbIL8L4qdDNRc34+m+p7\n", + "+/McfvopX1cWvMAuEyOHtnEmYzWBb9KctG2lRmvM2l+i8V9SF7j19eqKzz9zY26s+Zisq7ZcH5Fj\n", + "jeS88IBI7KpFJEQV6FYNqkQug6ruD0V1VXD/13StbZIbr6Qk+35KMgzduzi5dVVd6jVaT0bUZaK4\n", + "7QlC42lzsUfHvYGCkCw4g1TsVWW92OUuoPu3JgEAJ044AbdHydttPV73lvXc/8yrTbbf7VJfS7jM\n", + "AQvtuk+xjo9RC1pZn0ivwzpGdVdh0V26q6r91qoJxx8suIq4uUC3aF1vKPHdXPwAsGR7MU3T2dlc\n", + "dmFivF72xuXsgqtS8MAzF3MiZ6lTS3y+dGkfz5O2nLlxR0b9OXVzMiv/pyrRLdRlOjbmLsDtlOdJ\n", + "kVxl6xqUNKPuOw7isfYPDnpWCpsfTPYfVBcgJ6E32kgH7Qmmy1SgdVKu5H5nt2hNN1zLCsGJp8dU\n", + "HZwzW2ypm5ldgJZIvpVU6c+cycFjNabv6JjduPEe3T/PGVuLvCYqmtFgjbJiGHjvNrqB3RNwagMH\n", + "5dhSfOcdz9QwNjaKj//054NsHggEAoFAIPBBo2lk8y2poq3o5zh76UlkalhdySfYgRNOGDs/mMPD\n", + "O3v8BGlvzkzYtM+rK07stTdhC6deJGK5WV2YMG4kU5Mt4LIyvf3NPshvTMtkYeqo5OuxsrlZndaU\n", + "nMlEYHtJ49DYJc1h1kFkQ8v1tEikdMv1tURvJBVVZ+3pcQKsnc7NmtJHpEcLZ+Y8cGbpaSCR63WN\n", + "YMrY3GBrTm7/9KyTsttVbZ6tTkWVe2hTYm25uDNf4SaFWlv/V8lyYBax1rYClalFjN4fVpd3KqAv\n", + "Ly/pv8t6T18SRjpksrHdi5WlrZ9YOmNBQ/y5rKpvU2xNLD7Sx4tENjclYlP9B4DNam7jGqlN26tz\n", + "w5u+mFK9vxGaRZKGE32aC8zIs9sNCr7S8A8AlJS8zW9g9bc6IptaTsoy5fozwyZLbJR1ntgbcank\n", + "V06qcbK+4n1yUsPVZylwo7NsZHvfE8zSw/ITPo7eoJKS5428y9ay0xrQwvPfAlZ6+3xcFxfzumLr\n", + "5+a2ElaprLahVtdWHxMjRVeo72ycbP4vLHj7zRLH+T9nlCg8TzkB76h0xNmzLmdR7s5Wim0ipW/W\n", + "cvuXl5y83KV7lwWRSI1lYnKdGnK4aZ/w+EubEpuXaU/UoIhOUrs2UvA2yVlcvZZD1sfO5/nP6++4\n", + "ykUcO+ZW2tn5vIbXN32fXlzLY/LUU+frZaPj+Xo3brxbL3vm4kUAbkEHgOmp3J+2J5RIkmZuMbef\n", + "pQ5aChpYU/L299oYkkXaSNkLJN1ga3aLLOGmrG2SLHNzbpEzSwyTzc3DwcFW1354BQDQ3+8WSctx\n", + "x3I2t+9nlW9WT+/uyHtCT9EJ3X29ud9XlvJ4zl25Uv/uwXye688+O1EvW1ZCf4n2rm4lbG+QnIj1\n", + "YzftyXdu385t7fZn8dxMHpNWfT7cuefW9xG1XLaR1Iqt+8FhD8qYVVJ6W8nn38mh/LuZWZepsLU4\n", + "NOR5V1k1fjc0zSK1tvz+LPjA0cG1dyabXYXAAeH1y1d/9I8CRwLf/Y//aXYVAgeES69dbnYVPtSI\n", + "g1TgieOH7042uwqBA8Lrb8RB6scF3/3PV5tdhcAB4dLrbzS7Ch9qNM21197ehkq3m+JNWXf1oR+w\n", + "JsazqXBs2MlhnUrALMBNsavqZqoSsdNIwQ1meSM2q6nY3FSAu2xYHdlccOWy19NwnVSkzR1YInO3\n", + "ud7aSFtns2qJeXNZe9HN82baZcJya5spm7sp1hSgWceooiTSjrKbR1dWzW3prtI6oVfdUv3s2lPS\n", + "bU+Pk3iNAM1k9zZtoxBhsKify6Uu+tvcnv7+EyiXO9HffwIlVWrv6fXfrRkpUc3+rPBbbt/Z71b3\n", + "At3f+ieRC2JJifLHju3UVuKAAla+BhoJmxZEwAEZ5pZixeCSEps5sKHzVK57Q/CAuiP62twtsal9\n", + "fLo/m6D7T3jSYhvjnh7/fUJV28DJdXNZR5nKdHmwVpnVb3HJibKf+MSLuT2aXLdNyO+nRHymV9aT\n", + "IROxtFPdDR3lMtrb29DZWa6TzdvJjeWuR69nS4vpw+T+LNKasOCN5VXv656U5+f6mrsHzFXK7m5z\n", + "y3FQgGml8Z5g6+3kgOlO+Z5gxOqhIXePzM7nNkySe0iSJqOmwI6i6jOxu/GUaj8xsdfc3K20xm2e\n", + "2p7U10e6Nzqe98iNt6EurRXqk+cuPpfr1ub3Wt/M/dhWIG0pva8FGwDuSku6n7KKvmU22Ja8s2wL\n", + "UFJdrCol/G7RVBXlCq1h/Xp21uefuS0r9LtRVfdvtb1zbWfA0NR93//eu55JyWMX3I3Zbi4gImoP\n", + "q/eqRlSBh+p6XCYKhtE8LPHt6po/V9Y21N1PQRSDJ7MLqEyE5V4l9G9tEAWgdWemCuuzB/PeJwMD\n", + "+Xr2POF92vaE8XEnzNt4Ne5ledxv3bxdL/nUp/Pz9Obtm369eXV30bPrWFd+njFVALVtYKuKDdUe\n", + "HBr2Oj3/sY8BAGZm3N1o7kmmERhthQOaLIFzCwUK9fbltTM/59SbSlde99Pq4uvu9efUptI8TlEW\n", + "i/ozgfb6IT1HlOm5n4wiQnu87Q/87DAKyF4IsnkgEAgEAoHAPtE0+YMDv2kgEAgEAoHAPrGX/EFT\n", + "DlKBQCAQCAQCRwHh2gsEAoFAIBDYJ+IgFQgEAoFAILBPNOUgJSIvi8g1EXlHRH6vGXUIPBmIyKSI\n", + "vCkil0Xkkpb1ich3RORtEfm2iPT8qOsEPnwQkb8WkSkR+T6V7Tm2IvIVXePXROSzzal1YD/YY6z/\n", + "SERu69q+LCKfo+9irA8pROSMiPyriPxARK6IyG9reaztx8SBH6REpAXAnwN4GcAEgF8UkY8edD0C\n", + "TwwJwGdSSi+klF7Ust8H8J2U0tMA/kX/Hzh8+BvkdcvYdWxFZALAzyOv8ZcB/IVw4sHAhx27jXUC\n", + "8Ke6tl9IKf0jEGN9BFAF8LsppWcA/BSA39Bncqztx0QzGv8igHdTSpMppSqAvwfwhSbUI/Dk8Ghk\n", + "w88C+Kp+/iqAnzvY6gQ+CKSU/h3Ao7kS9hrbLwD4WkqpmlKaBPAu8toPHALsMdbAzrUNxFgfaqSU\n", + "7qeU3tDPywDeAnAKsbYfG804SJ0CcIv+f1vLAkcDCcA/i8hrIvKrWjaQUrLkSFMABnb/08AhxF5j\n", + "O4y8tg2xzo8GfktEvicir5CrJ8b6iEBERgC8AOBVxNp+bDTjIBV6C0cbn0wpvQDgc8gm4k/xlynr\n", + "bcQcOIJ4jLGNcT/c+EsAowCeB3APwJ+8z29jrA8ZRKQC4B8A/E5K6SF/F2v7/dGMg9QdAGfo/2fQ\n", + "eLoNHGKklO7pvzMAvoFs8p0SkUEAEJEhANN7XyFwyLDX2D66zk9rWeCQIqU0nRQA/gruzomxPuQQ\n", + "kTbkQ9TfppS+qcWxth8TzThIvQZgXERGRKQdmbT2rSbUI/ABQ0TKItKlnzsBfBbA95HH98v6sy8D\n", + "+ObuVwgcQuw1tt8C8Asi0i4iowDGAVxqQv0CHxD0YWr4IvLaBmKsDzUkJ+R8BcDVlNKf0Vexth8T\n", + "B560OKW0JSK/CeCfALQAeCWl9NZB1yPwRDAA4BuaKLcVwN+llL4tIq8B+LqI/AqASQBfal4VA/uF\n", + "iHwNwKcB9IvILQB/AOCPscvYppSuisjXAVwFsAXg11OkUTg02GWs/xDAZ0TkeWQ3znUAvwbEWB8B\n", + "fBLALwF4U0Qua9lXEGv7sREpYgKBQCAQCAT2iR9r7YdAIBAIBAKB/w/iIBUIBAKBQCCwT8RBKhAI\n", + "BAKBQGCfiINUIBAIBAKBwD4RB6lAIBAIBAKBfSIOUoFAIBAIBAL7RBykAoFAIBAIBPaJOEgFAoFA\n", + "IBAI7BP/B0EEnTIvM42+AAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(transformer.deprocess('data', net.blobs['data'].data[0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Adorable, but was our classification correct?" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['n02123045 tabby, tabby cat' 'n02123159 tiger cat'\n", + " 'n02124075 Egyptian cat' 'n02119022 red fox, Vulpes vulpes'\n", + " 'n02127052 lynx, catamount']\n" + ] + } + ], + "source": [ + "# load labels\n", + "imagenet_labels_filename = caffe_root + 'data/ilsvrc12/synset_words.txt'\n", + "try:\n", + " labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\\t')\n", + "except:\n", + " !../data/ilsvrc12/get_ilsvrc_aux.sh\n", + " labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\\t')\n", + "\n", + "# sort top k predictions from softmax output\n", + "top_k = net.blobs['prob'].data[0].flatten().argsort()[-1:-6:-1]\n", + "print labels[top_k]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Indeed! But how long did it take?" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 loops, best of 3: 7.14 s per loop\n" + ] + } + ], + "source": [ + "# CPU mode\n", + "net.forward() # call once for allocation\n", + "%timeit net.forward()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's a while, even for a batch size of 50 images. Let's switch to GPU mode." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 loops, best of 3: 90.9 ms per loop\n" + ] + } + ], + "source": [ + "# GPU mode\n", + "caffe.set_device(0)\n", + "caffe.set_mode_gpu()\n", + "net.forward() # call once for allocation\n", + "%timeit net.forward()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Much better. Now let's look at the net in more detail.\n", + "\n", + "First, the layer features and their shapes (1 is the batch size, corresponding to the single input image in this example)." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('data', (50, 3, 227, 227)),\n", + " ('conv1', (50, 96, 55, 55)),\n", + " ('pool1', (50, 96, 27, 27)),\n", + " ('norm1', (50, 96, 27, 27)),\n", + " ('conv2', (50, 256, 27, 27)),\n", + " ('pool2', (50, 256, 13, 13)),\n", + " ('norm2', (50, 256, 13, 13)),\n", + " ('conv3', (50, 384, 13, 13)),\n", + " ('conv4', (50, 384, 13, 13)),\n", + " ('conv5', (50, 256, 13, 13)),\n", + " ('pool5', (50, 256, 6, 6)),\n", + " ('fc6', (50, 4096)),\n", + " ('fc7', (50, 4096)),\n", + " ('fc8', (50, 1000)),\n", + " ('prob', (50, 1000))]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[(k, v.data.shape) for k, v in net.blobs.items()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters and their shapes. The parameters are `net.params['name'][0]` while biases are `net.params['name'][1]`." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('conv1', (96, 3, 11, 11)),\n", + " ('conv2', (256, 48, 5, 5)),\n", + " ('conv3', (384, 256, 3, 3)),\n", + " ('conv4', (384, 192, 3, 3)),\n", + " ('conv5', (256, 192, 3, 3)),\n", + " ('fc6', (4096, 9216)),\n", + " ('fc7', (4096, 4096)),\n", + " ('fc8', (1000, 4096))]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[(k, v[0].data.shape) for k, v in net.params.items()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Helper functions for visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# take an array of shape (n, height, width) or (n, height, width, channels)\n", + "# and visualize each (height, width) thing in a grid of size approx. sqrt(n) by sqrt(n)\n", + "def vis_square(data, padsize=1, padval=0):\n", + " data -= data.min()\n", + " data /= data.max()\n", + " \n", + " # force the number of filters to be square\n", + " n = int(np.ceil(np.sqrt(data.shape[0])))\n", + " padding = ((0, n ** 2 - data.shape[0]), (0, padsize), (0, padsize)) + ((0, 0),) * (data.ndim - 3)\n", + " data = np.pad(data, padding, mode='constant', constant_values=(padval, padval))\n", + " \n", + " # tile the filters into an image\n", + " data = data.reshape((n, n) + data.shape[1:]).transpose((0, 2, 1, 3) + tuple(range(4, data.ndim + 1)))\n", + " data = data.reshape((n * data.shape[1], n * data.shape[3]) + data.shape[4:])\n", + " \n", + " plt.imshow(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The input image" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first layer filters, `conv1`" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJNCAYAAAARaCA+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXm0Ldld3/er6Qz33PneN8/9ul/PaqEJi5aEwBIoBBOS\n", + "GDteduKV2Am2sY0hSN0tqVFLtFoSYBniZHklXthh4diEtczCEASWkDViqSWhFlLP4+s3D/fd8dwz\n", + "1amq/NGNrf37ft+6h1LjK8z380+/vXufOnWqdu1T99Rnf3dUVZUJIYQQQog/HvFu74AQQgghxJ9G\n", + "dBMlhBBCCFED3UQJIYQQQtRAN1FCCCGEEDXQTZQQQgghRA10EyWEEEIIUYNX/CYqiqJ3RFH0ZBRF\n", + "z0RRdM8rvX0hhBBCiG8HolcyJyqKosTMnjKzt5nZeTP7spn9laqqnnjF3kQIIYQQ4tuAV/qXqDeY\n", + "2bNVVZ2uqio3s181s//qFX4PIYQQQohdJ32Ft3fIzM5+U/mcmX3nNzeIokgR6UIIIYT4U0NVVRGr\n", + "f6Vvoia6QXr3ve80M7PPfu737S1vvtuiRiv4/1GS4YbjBOuSsC7Ph9BmPCR1/UFYUWAb9hNdmob7\n", + "+Q8/+g+hzfvuvxdf6I7KYLsHTTa7XdzPsgjKUYqnq9FoBuVmqwVt4m86dr//+d+3u990tzWycFuR\n", + "Yf948MGHoO4n/86PBeXROIc2/R5+vigKtx+neI6jCI965vpG2mximwy3ZX5bpPv/3M/i53vgZ94X\n", + "lKuyhDYVVllVhCe5yP/jufvs5z9nb3nTm21cFP5lNh6Pw+3kuPFxjsc4jsMP5I+vmdkv/JN/DHX3\n", + "3XNfUE4z7FPkNFjDHffOwjy0mZ2fg7qhuyZXLpyHNhdPn4a67uZW+P4NPMe/9Mv/Kii/933v/w//\n", + "/synP2Xf/dbvsarEY27uWGXNBjTJWtjPms2wL2YpGZPGO5/jIRmThn5MMrMPPBD2xY985EFok0S4\n", + "D1nDXdsJGTfoNRMel4r0KSPj8Kg/MjOz3/nYx+y/+IEfsNFwBG3GJX413PeunwrKP/ezH4E2W64f\n", + "mJldu7wSlLfJ2LmwvAB1swthXbPdhjZJg3y+UXj++tt9aFMWeN1++EMfDMrvfOc7oU27hX2vkYV1\n", + "CTl/UfLSRfqJT/yevf3tb7OKXLS9Lo7Dve1tt994XhJyjqMo3Ief+yiOnffd926oi13/rHDTNtjC\n", + "8zc9PRWU5w/vhTbPfPVRqGsU4Rvc/pbXQ5uHv/jvoe7IoUNB+YH3fgB39Dq80jdR583syDeVj9hL\n", + "v0YFfPZzv29mZi+eOWMvvnjEjt906hXeDSGEEEKIP1le6Zuor5jZTVEUHTezC2b2l83sr/hGb3nz\n", + "3WZm9tnPmR07dvQV3gUhhBBCiD95XtGbqKqqxlEU/V0z+7dmlpjZL9GZeS//9Hns8OGX/j0If8qO\n", + "M/xpNOt0oG5qbjZsM4U/z47J4xj/k+bWygq0qcijQSOPcTyjEf6cv7W+GZQ3NzbwheTRQGcxfGSy\n", + "sGcPtJlyP0mzx5DxN83AvP3O221pecnyUfiT+5g8hmAU4/C4xORn5CZ5PJK6n6iz1hS0YQc4cY92\n", + "kwy3/Uc/bQdbcrNO43iyORT+8dZ4jPvEHoFV7uf8OPmPjwBO3njSslbDSvKYw9wjvrwYQxP/WNfM\n", + "zJuFk84Q6blHEUmMj2z8o0Izs0HiHmGQ8z47j49Q5pfCn+FT8lhu0MfHI333yIs9IvY0vukc33ji\n", + "BmvEsaVNPFdpI+xD/lGlGT8u/rFcd20V2nTX8doe5uF5L8hj3WiCMzgmj4zyCreVuzEvTvF1wxz7\n", + "md+HKMExKSZ1+eilx83Hjp+w4Si30QgfP+cjfD/YNnnEP+gRHcNtv0kevbY706QuHCtL8ohx0Mf3\n", + "g7Eyx+uYPc6DNmQmfEGu7ZF7fJ+QNsnLz8WOHTti4/HIEnLskhT7cOXckpK4CQlxHyqb4PuBdOHC\n", + "HbtWE7/Hm8uLUPfUF74WlL/z8GFo87rvfyvU/dJPfDgo3/Lqu6DNba9/LdQ9+YWvQt2kvNK/RFlV\n", + "Vb9jZr8zSdtjR4/s3Ei8opw8eXK3d+HPHMePH9/tXfgzx4kTJ3Z7F/7McfLGG3d7F/7MccMN6ue7\n", + "jRLLhRBCCCFqoJsoIYQQQogavOKP8yYhd898K/eM+5unh/8RZXEF6maXwmepC4cPQpuZfegRdeZm\n", + "gvL0LD4/3yK+Q06ez8PrtrahbrsXOh9N53KZmS0fwn3ffzyU7hfJtPLCuSPba5vQZpt4GuXYPRsn\n", + "7g/Duz9pE5/Fsy1V7jl7SVw15gf46dlEHbM4IV6Pi/SIiTfFaLmICOZ3pCl6WX4qfb9HogqId5Y7\n", + "v2IwIk4GcalS93Eq4ncwEvfCgrgq3v0xQy+EXaPzi0tQN7dnOSgvTh2ANoM++k5dFwOyOroEbTz9\n", + "LeznEfFQ+r1wSvVogMd8cwOvo7WVcEwYkKn1LFJhaja83qcX0QHpzM5AnSclsQQ56Z94reG2WKRJ\n", + "5fyqmLUh098L9ga+TYH7ie+Pddtk+vtwGDq0Mws4nk7NoHOZeB+PeExEhbPRdrjv1H+a4PJjcQJE\n", + "jzMfpZgSn7MClwm3nZJoBN+HRmPiGrKxhLh3nogMzqnrQ1fPYMTJq773jVC3dflaUP6N/+NXoM1H\n", + "P/urUPeV7/9UUP4XP/OL0OYDH/tnUPfEVx+BuknRL1FCCCGEEDXQTZQQQgghRA10EyWEEEIIUQPd\n", + "RAkhhBBC1GBXxPLMybtDJybmZB2p3ipKo1defDEot59+FtrsO3Ec6paPh/lUKZEQpzooeg4jFIo9\n", + "TK7beyxcl+fQTZjVdPgk5n3MTIf7sHX5KrS5cPpCUL52Bdv0iOw+dhanX4fweozdWnkpCborWTic\n", + "Oy4oRpqx5R19HQtrjInsmo9DETptTNbVp1xga0bCPVMSbDd24YWDAQnWJBROUh2PWJAfC+D0bSYL\n", + "S81csKR/fzOzQQ/3YcMF0q5cwokebB23WTcZYt9xXKHg4DHs+37dr5ysNwevIYL6oIt9v7cVrsc2\n", + "JEGeQ3L+EreW3NwCCuLTRHJeOrg/KM+Q101N7yyWM9+3rMjfwWW4n/6aNTOLYiJV+ykhTLwm/Swf\n", + "uu0T0TwnEyY8ox6O+yN23pOd1z7sTONkodLJ1z7U0sysYp/Py/vEK29kk4yfJMCVTaYpXDti3Kdu\n", + "PGWTAIxMpplqh9+9ZUkmkZAg1oJI8fA6ElQ6sz+cbNJdW4c2X/vsF6Duh/9muNDJw7/1KWjzz96H\n", + "a9f+vf8rXNPvR/7lq6DNv//Vfwt1N9+J7SZFv0QJIYQQQtRAN1FCCCGEEDXQTZQQQgghRA10EyWE\n", + "EEIIUYNdEcun5l2CrysPe7iqe9pAcW90Nmx3+cXT0Gb13Dmo23M6FL33kEUcW4uYDp40UUD37D+C\n", + "iyrvP37ItUG5Ni5RDDz7h08G5Se/hCtNnz991m0I92mKJLK3ZsJjXrEocIZL041IxG9Ck3JD+ZOJ\n", + "3mmEO5+mYbuEpfey3XQHwkvB18OvCJ9muPWKGPA+5Zu9W0JEz9gdTyaRshRlXxXRnHhkqhOKpf58\n", + "mpkNh3j9FU64vXrhArTpb6PE3Z4OV22fmcfranZpAeoOuMXJuxtr0MbTJJNBGo0W1C0shynq7Q6u\n", + "LJ+18VpvOfl7ag7fr0NWFeh0wm0xWbq/SZKjHTlZVaAk/cWvKsCc4JhM7ChcXWlkgkiM161P1I/I\n", + "FTkmEjduB48LSzpvOZF8ahrPX3MKz/vIrQ5QbOO2e+S7p3BGf0rGEnZteypyIbOwd3/cqdLt94Gs\n", + "2lDmuPHES/kZnk+2YkFFBHTYJfJZrl4KJ6Tc+DoUuD/z6x+Duke+GH7X/eiD74Q27/+bWPeOv/NX\n", + "g/Jfff+PQ5sv/j+/C3VvveFHoG5S9EuUEEIIIUQNdBMlhBBCCFED3UQJIYQQQtRgV5yo4TB8vtru\n", + "hAGHS4fQK5jfuwfqlg7sC8o+fNPMbIWsGr2xEgYFlmN89j93YD/UNWcxSM+zZz++rpGEz/DPfP1x\n", + "aPPcI49hnWu3uYpBZZ3FcJ+WjxyGNjNLGO7XcO5PTgIdGbF79h8TjylKSDhcMwyobDQwpJOFbfpV\n", + "x2PiRDEbKHb+AQvkZGRN51IM0JsYM8nEHYcsY6Gg+AFjF3KapMw5wXPjj0NEzgOj0XL7xVZeJ3Wl\n", + "CwHduHYN2lw6cwbqHn34y0F5fnkJ2py86w6o67RD32hhaS+08TTabahLptBtarq6mSXcp4yENU7P\n", + "zwXl9gy6ODH5u3TYDcM9r17EQNzVS5ehzsMCVVnfiFxfZ95UwdxCNwZExP0pSUjncBiGZCYsVNIH\n", + "VhL6JKyxJNJQy3l9M8RDazRxfCl8qDMZ93skZNVrg+lEwZoIu0YrErZZVGFdQRyl0o3DLCuZ7efI\n", + "vR/bp5j6ozuHbc7MzUHdxdOhk3zhLLqU3/X93w11X/zcw0H5wH/zQ9DmLX/+bqj7vV/6taB819ve\n", + "CG3mjn0F6rqXV6BuUvRLlBBCCCFEDXQTJYQQQghRA91ECSGEEELUQDdRQgghhBA12BWxfNAP5b2R\n", + "kw7ZitFMjt5/y6mgPH8A5dM9RLReOX8x3J8NDAk0tro1CRP0dK+tQt2L3wil0TNPPAltLjzzAtTF\n", + "LqDy4CkMBd1/PAzubJNgTSZse2Gz2tn7NDOzlhM2vaBuZpaPmOwadrU4RfGaiawgaJM27C+BOHVi\n", + "ORG2Gd5jZcJ9VaGwGbvP58NFX2pDhG3f1dnnY9aoEz0jEnDK8MGBbNudOTKBwu1nb7sLTTbJCu0X\n", + "Xgxl86cf+Qa0abYxGHFqPhTLGyTk0dMmMrifCGFm1uyE7WLShysi0m6uhTL9yvmz0Gb9Igria5fD\n", + "iSy9Lo4jSbTz5xuTsM0xkaP9oWJKcJnj67y4XhDpOSLhrOOhGzxIPy8mCNsc9DHoMiaTHNozYd/o\n", + "zJAxj2y/ux0Gmm53B9BmTI5Lw0vcRMpnE2w8LISUjc2FC0vNiZSfuX2qyPjGxlg/cWZIzgvr+wXp\n", + "Z55hjoGx+4+EE60unEGxvJngWHnyjpuC8gtk0sry4QNQt3Ex/P7dXsc+tXQMA7H7bvLHHwf9EiWE\n", + "EEIIUQPdRAkhhBBC1EA3UUIIIYQQNdBNlBBCCCFEDXZFLE+d8OZXNV9f2YDX9HoowM0vh0m1HSJV\n", + "zx1GiSxxYunWFUwrrXIiRzML0HH5zDmoW7sUiqV+lXUzs2O3nYK6fcdCaXx2P0ltTsP7YL+i+kt1\n", + "mATsb58nTeFttMJU6IwI1K0It+VflzaYeI339KkXKEnqNxM9CyeEZw2ULBle4izISugsAdqvfJ6P\n", + "SdI5EXXNbYt8FPqZvcjKpHxG6fYrIvJpmqHoPb0YXmvLhw5Cm7WrmGK+cXUtKF++gNfHwnM4aWTB\n", + "rRhAFqkH2iSdPKIvDM9pfx0ngwy2UZIddEOZvktE+u2NTXw3N1thahqTzv31wWDjBlOovQTsk7rN\n", + "zCrWh3M/wYeI5fT9XF8nkxzynIxBjn4fj3m7g+d0xk0gYOPGNpH311bC87xFzlWrhX0/c9I2m6zg\n", + "r2MGE7YrmFli5gdn1iR35yYl55iN6H48Tcm5ikjiPNt32KchivpJJ9z+3kP7oM3mFbyOiijsL/tu\n", + "XYY26SH8Prz6pa8H5f5lvLanFjFZPd/EvjAp+iVKCCGEEKIGuokSQgghhKiBbqKEEEIIIWqwK06U\n", + "f6bcdAGOLEBumzyzHA3CIK3pBXzW2Z7BZ+pxM3QSGjMkWLOHYYIRCV70sEC8pnMgOosL0GaBrG7f\n", + "mg1D5YZkNe/eRuiPsZXeE+bUeI9gwtvpxIVfklxUGuCYOK/Ae3Fm11k13q1ozj6flbjzZRWeh5L5\n", + "SISh88cqoqGwbY1d3/CO1EvbIt6COy4QLnodfNiedx2uT3jC2OuYY5KkobOzvH8/tOnfiB5KsxWG\n", + "65XE61m9ehXqGu3w/VpTOztDF57HwNrtTfQtes6FYR7TaIB+jneNmBvXaGJw58Ke8NouC/Ru+hME\n", + "+eZDDA4siTDjA1WZ28QcnsL1WX8NmZmRrE2rCv86bJRM4NQUhu8344I1zcxazpPynp8Z/77ogedG\n", + "zh9xQ1PnnTKfjMd7hjBtsSKf2Z/SnIwlmQsh5cog7pNvl5FxuEF81X6MvpMnTbFfD7fD8TQh257b\n", + "i9/b185dCsoXnsVg2xtvOYnbOho6V5dIiPU8cam6zZ0/3/XQL1FCCCGEEDXQTZQQQgghRA10EyWE\n", + "EEIIUQPdRAkhhBBC1GBXxHIrQhEwdsZdo0l2i5hzpRMa+0QmZKtPZz5MMEUZNGqQMDqyyrgnaaKo\n", + "12mHMl2zTUIBWyjcdZ3cPiJhZt58Tsmq5yyMEiXnycIaIydCF+R1BZHrR2519CjB40uDJp1lWTHT\n", + "mwQqeoF5ONx5UoCZ2diFbY5J6GpFPrMP6cwnfJ0Xy6sm9gN6Tt01wyYPMMbDcD8rEiAbxXj9pW71\n", + "9xYRfvcePgx13sHdWsMg3QEJiO07CTgjQqqHhV9WJOQxc8ducQnDPuMYJ3qYl/nJJAAW6po62Txi\n", + "1+MEQb7FCK//iPwd7Cc1sIkQfsw1Myvz8DywPYqpWR7WJbSf7/z3eoMEXbbbGEzqXezeNo7LLGzT\n", + "3HFot3DcZ6L1JEGak4yfKZlwM2RBqK6OTUjxAac+KNWMC/BV7IV03G8WoOzHKQbZTfjM7DssJqmg\n", + "iwf2BOXLlzAQ+8LpC1C353gYArxBXre1imPQJOPL9dAvUUIIIYQQNdBNlBBCCCFEDXQTJYQQQghR\n", + "A91ECSGEEELUYFfE8qrwyb9sdfKQmNzv+SRZluw6IIJh2fIyNsqESQMTkouKrYvttk1SYtPMCYxE\n", + "hB4Qab1wIiRLl/bSuF8x3oynZ/stsZRqRuYlWXJMoozIik5Mjom8yNzMLEpdE5bwS14YOfGSTDBg\n", + "+LRllr7MFNLIid0s9ddIWnfuX5eRS7LE8+f3gcmnDC+kGhHSWQJ03AqvhzjFzze7hDL20EnjUYLX\n", + "mheazcyGo1AIZ6K+58DxY1CXkYkeXh5utFEwTojMjzMf8NiNhiiy+y5UkM+bD/GYewqSWB4RK3fc\n", + "D+XdcYHbjmhiuZvwQ/YhJmNXmrg+G5Fk/gkS9ZtE1J+bxQkMDXf+8h4ez5icGy/TswkbNFXcfZxJ\n", + "JsAwWFp/RSbh+Mkt7Dslctc7O3YZuUbhu45d/2xlhQm+H6KYiOxu8ylJhB8NyIQpN9Fqcc88NBkM\n", + "sF+vroSTS6bnZ6FNTl7HrslJ0S9RQgghhBA10E2UEEIIIUQNdBMlhBBCCFGDiK9I/Sf4hhFLaxNC\n", + "CCGE+Pakuk4irn6JEkIIIYSogW6ihBBCCCFqoJsoIYQQQoga6CZKCCGEEKIGuxK2ec8D7wzK3jRn\n", + "K5NT/AuJJB9HZFtOD6OrXRP9PXaBcR9634egzX333Ytv51Z277SnoM3Zp16Auj1H9gbl1iy+7ur5\n", + "S0F5roVtIhImOnCrficRdoUPfuhBqPtffyr8fEWJ4YL5EIMtSx+SGWHoWtLA0EN/7FgwapMEuEVV\n", + "uA9xhfv0wff/DNS9+6fvD7dDgu763S7UNVzYHVuRfsxWbHdhe2VBwlppKGDYicsCwygf+vCHoe59\n", + "D3wgKOeDLWiTk5XWi1FYx8L3Gi0MqE18qGqCAYBRjK+DlD4Snvj+D9wXlH/yvndCm0aCxy5z13FG\n", + "AkDZCFS6QMWCHPOSZLqO3TmNfTilmZUkNPNDDz4QlN9z37uhTUbSIQfjMDiwMTsNbTaubUJd7EJH\n", + "j994EtpcevwpqFs9dyEoLx85DG1aczgu3f/enw7KP/1+HG+SGK8ZP6SzIN1yjONS6dqRnEmrYjw3\n", + "ib/W8GWWkn72wAPh+HL/Pe+FNhura1A3vW85KO85dgDaXHjhuaBc9HrQZmZhAeoGLvw2KUmItQ+H\n", + "NgxsfuhDH4Q27733Xfg6N5xFpO+PCjx/aRruQ4uEiSYkmDh13yvbm+vQpt/Fvt9sh2PQh37u56DN\n", + "9dAvUUIIIYQQNdBNlBBCCCFEDXQTJYQQQghRA91ECSGEEELUYFfE8gjMblckVrcXaf9oS64RtGDx\n", + "6H5VbiatMrxYyhgT2XRmai4ojza3oQ1b/X12756g3N1ACbF0K5gn8ygTDnMizrvPXE52CCxqhOJe\n", + "M0FhtDOPUnVjKqxrz+Drsia+LnYna7yNK9mPiQjtVwbPe/g6xqgftpuewVXAp/btg7qta+G56W6g\n", + "sD013YG6tBmK1nmO/Scf4grjjUb4uoTIoBQnUadTKB0zwb/fDf/eKke4T70eCvdNJ5tHEUqkcUZk\n", + "+sz3hUlWkcdOHJOJCIlrlhApuCSyq7/8ic9MJ6TAeIYDkJXewCWwOTIFmTDht84mAfS2sX/uWQ7H\n", + "qakOCv9rly5DXVWE77jgxGgzs60BjnmesZvsYmaWNPErquH6Z2sa2/h9MjMr8vBYlQW+35i8zner\n", + "yHcgM/5F42i0yfiW4/utu8lCB04egTbTy/NB+fyjV6DNVGcG6tpT4bjbW8drNiKTfuJ05+uPXA5W\n", + "uMk0VYnHvCL9s9kKr9tWE8ekYoTbGjjBfrCN/a4ii6akZPuTol+ihBBCCCFqoJsoIYQQQoga6CZK\n", + "CCGEEKIGu+JEwRNJ5zJRPYc6UX7D5ME086RcO3C0rrcT5Fmqh3lTHfcc+twz53DTJFBxel/43Pvi\n", + "8y9Cm9S9XauNHsNWF10qS8NTn07oRM3Mhs/ZkxY6JxlxajIXJugD7MzMRhsYjDZc3wjK/bUNbJOj\n", + "n+PDPSuWgkhouHDPq5evQZuZOXQNZpaWwv3cRtegIF5W5A5VShyQisT7DdxnbsQTSBlmVjlHISXn\n", + "KiZums8ArTLi9fVxP4fOUYhj9NfSEj0wH3KagCNFIGGmEfGPvFxElAy2KfMj12S+pVns3oCON2zs\n", + "gjZkLKMfL2yXE3mrIM7X4v4w3Dcivs610zh27T1yKChPL6GXeeU5vI48gy72qSLHcNb+IHRhWsTd\n", + "ykgQY+nOexnj2OVDZc3M8irsn3GJ26bn1NHo4LXWIMHLF596NiiPujhu7DtxPCivvHgG2qyvXIW6\n", + "xUNhEGqDfF/kxDXKqp1/b8nJGOsdMxbk2SYhvbMzoZ/Hju52j7iwzpkd9TGENJ0i308N7AuTol+i\n", + "hBBCCCFqoJsoIYQQQoga6CZKCCGEEKIGuokSQgghhKjBrojlYGRCZiZqZCUxKCOWPgevmzS408Ec\n", + "9QnkQbaydObC/K6SwLoDr7oR6qackL5+9gK02euCH2OyIj0LkGuCrzmZmFy41bwTdPtsvIki5MgF\n", + "Yg43Mexvaw0F+MFW2I64tZZMoZzZngtDMhsdDLpk+DC6NgmjvHYRg+22XbjmzNIctDEiL44GYchq\n", + "K8YJBi3y+WIXJjoiMihj7MI8E7JPWRNFz45b3b7XI6u/k+tjUIaC/XiEfYMFRlbuGs0muGZjEoLI\n", + "Ajj9ZJOYjCMp25aLE2TXVeUNfMPJJuxM5UT0xvdnYxm2S5Pw4h6QsNYYBwBbXF4MyutPoqy8ehbH\n", + "rjvf+Pqg3JzF/tongbgeFrbJRqXxdigLj8iEjfY0Xrc+UDEhk3nSBk5gGOfhNVqRyUPFBBMDygb2\n", + "l30nj0Ld1z/9cFA+/+gL0OZ1t4ffF0tHDkOby48/BXWDrXBiTnsax6kix+MyybyHfIyfzwfZsolP\n", + "LRIK2nACen8LJx1111ahbuj7BgkFbs1j38gUtimEEEII8Z8W3UQJIYQQQtRAN1FCCCGEEDXQTZQQ\n", + "QgghRA12RSwHF9JZa0weplIlJAiTNjTE3L0BseaoRzeB3MrEudFmKLutE0nuO04dg7r++mZYvoZp\n", + "3dM3nwrKOZF0C/JpYifcRhOIrWZmLXdyym0ikRPRs78R7ntvHSXyERFLIyc+T82jCDnthFgzTAKO\n", + "DGVJxtWL4QrqC4u47ZvuvBXqNlbDc7VKPl9F1jnvuWO13cWk86U9e6Auc2IwS8pn+ATfrIFDQJGg\n", + "ZBmloXA7NYPHc0SkeO9Zj0n6ekkStctxKISOJvh4bJ4Jm5ASp06mJ5HlMXld5T8fWZF+NMb09dIf\n", + "BCKtFyx6HHaAjVNkWy5uPXditJnZ9Pws1DXSsE9deOY0eT9kr5OjBwUelz4ZJxByzMe4rdLJwv4a\n", + "MjPrb25CnZfGWx0U4JstFMsjJ0ez1Q/YBCbP1haO33e9+iaom10OE98f+9SXoc2r3vbmoDx38BC0\n", + "WTlzFuoq1z8LMukgIdcDu448bIJG5r4PWySdPE3JKg3u+u+TY7dGEtn91ZCSc9yeRpG9YssWTIh+\n", + "iRJCCCGEqIFuooQQQgghaqCbKCGEEEKIGuyOE+XcInieTJ8v73y/R40l5jH5KtaGhnTuuAvWmcLn\n", + "rVfPnA+308SAw0M3HIe6Zz/zpaA8HqDbMLdvKXyvbVwJnS31HiXh8awKfDbO2LoaBk0O+ugj9LbQ\n", + "R8jdittVgudzamke6jpLoZM0NUuC0shK6PkwPFYFCV1jLO0N/aPHH/lDaPPik09D3avf8MagvHgS\n", + "w1N7FfodW93wWF0lHsPF8+ehbs/evUG50ZosLK4Yhccl7+Eq51mEw0KahQ5N0sBjbgnxzlz4a9HA\n", + "/Rz2MHi1cl4P81A8jYQMZ0Tl8IGxFdlvFqg4Hod1BRlxKuKFlN5TJP5hMcHnY64ok5RK72qRwNG5\n", + "ebzWxpuhj3ftLPa7hf3oCM4cCK+Zi1fRVTHivXnKAn2yiPgyFocfejzGcXHYx3DPsgpd1MYm+k/M\n", + "2Wl1wrokwz48idN27TIel3gaQ09f+33fFZR/7aF/Cm1Of+nRoHz8e14NbbIZ9N4S1/dKw2NuJfbh\n", + "JMNjBW1IcG/LhVg2SKhlQlzKfBh+j21cuwZtBtvoj07Nhf16eg4dWupETaAkXg/9EiWEEEIIUQPd\n", + "RAkhhBBC1EA3UUIIIYQQNdBNlBBCCCFEDXZFLPcuJLiRE7jg13nlRPhtTbqVSfIMSY6eXb0SCoV7\n", + "TxyBNlMkpPPs10OBeXqOiNf7QqnzmT+4gPtEgiZTZ8mPi8nCKDfXQzmTya4FEXxbbj9ZQOb08hLU\n", + "zcw5OZI7QMveAAAgAElEQVSsFD4gEmkxDoV3JvwyFp2w/Y6/9hehzSf+31+Hut/45/93UL75ltug\n", + "zeFbT0HdvlM3BOX9R3E19heeeAbqrp0LzzMLBWUU4/BYDbaIUVliXdv1/WgG5cwoQbE0Tl3oaYt0\n", + "GHJqxi54tSJBrLAZkqxbks9SuTf0ormZWVng68Z5WEd8bcsyJqmHrytJHy6GO38+FhxcsOuvCj9f\n", + "kpFJHG2coLF2Phyn+ls46WAvmQCTNMLPvHUNg2aTaufrb3YBReiYSP9+YlKR4/nrdXHCy3DoBfSd\n", + "A5zNzAoXHpqwcMgJvhtyEgr64nPPQt3tb31tUD74rz8ObR77XDjp6OhrMQB4ahq/LwZrK0F5roNi\n", + "+9YGjqdxsrN5ncR4XCL3BRGRb/JhHydD9a+F+7m2imK5kfMw675Xmh0cp7IMP3OfnJtJ0S9RQggh\n", + "hBA10E2UEEIIIUQNdBMlhBBCCFED3UQJIYQQQtRgV8RybyODbEYkvYqlbk+QIF5RedAnpjNpDjfO\n", + "pDjPaISCaG8QJqve/udux9et4SrVl144F5RPvf5V0KZwJnt/HdOf9xCJu/Sro0+Y2NpxAnN7HgXV\n", + "1mwH6pozoeSYtUlyLUm8HQ/C/dzcXIc2/S4m15ZOFo4TlAkZD3/sU0H5zX/xB6HN3//FB6Hu0//m\n", + "Y0H5q//fJ6HNlX/3Gaib+srXg/LJ19wBbY7dfBzqOm518rXzl6ANw0vAYyI097skQdzJ0GOSsJ1O\n", + "YYq5/yutIpMO4hj7gk/U9zIxg0/8YGJyWOdFczOzggjp5icnsFUN2BjhdoxJ6+ZTzQkVXUUB9z1y\n", + "nydtYN9nh/PahctBOWnh6xaP7Ie6vlu1YHMDx7JGc+fE6wZZySFm/cXP3iH72SCfuXBp3ew7hU1E\n", + "8GNJRGYPRczwd7RJyv8Lj+LqBzffcWdQvuvtfw7aPPLbvx+ULzyOgvr8PhTLz6yEwnZJ+n7awGM+\n", + "Knae+FCRa81PPBqPMF1+sIVj+upqOMlhlOOKE515TCNvTYffPVkHJ2yV5MsuH0osF0IIIYT4T0qt\n", + "m6goio5EUfSpKIoei6Lo0SiK/v7L9YtRFH0iiqKnoyj6eBRFeCsshBBCCPGfAXV/icrN7Ceqqrrd\n", + "zP6cmf1YFEW3mtm9ZvaJqqpOmdknXy4LIYQQQvxnRy0nqqqqS2Z26eV/d6MoesLMDpnZD5nZd7/c\n", + "7JfN7NNGbqQq/6DUpchx94jc7zlHgPlP9OG/ex0LsaN6xQQOVn+AAXVZJ/QBllzwpJnZmcfwmbZf\n", + "2f3QrTdAm7WrYQjZeIDPjttT6Jx0NzeDcmNCZ6izGAbixW10HSKyyvnIuTeDPh6nXhdD17or4fPy\n", + "UQ+D4DLyDL/h/aqYrFZO2LsvDNv8Z+/5OWjzxi+9Heq+70d/JCifevWd0ObFRx6Duuf/4PGg/PiX\n", + "vgxtLp07B3XH77g5KE8voB/AaLpQ13FCgiZz9HN6g/DcjEp0JKbGZNX4Zvh+SUquY+L1JP66jSf4\n", + "e4+oRjkJtjR3XflAQDOzkoRDFs5tGo1YSCfWeZWJOjUTdM+KHAPmSfkBrZHhNZpvoke47VymhYMY\n", + "fuuvfzOzTedzjnrovbSJ7+RhYY1s/PbjNfOYwJsys9SFLLJjR52oMnNl4qbFO0ul07MLUHf14nmo\n", + "O/vsc0H54B0noM2Lj4dtVsgYcXDuJqhrt0KHdTjAjpexgFPbuYMm5Is0dj7Z2Lu4xh1M364zi/1u\n", + "dhH759RcOA7GJAB4RL57RoNddKKiKDpuZt9hZg+b2b6qqv7ITrxsZvu+1e0LIYQQQnw78i3dREVR\n", + "NG1m/9rMfryqquB2snrpNr/euixCCCGEEN/m1I44iKIos5duoH6lqqrfeLn6chRF+6uquhRF0QEz\n", + "u8Je+/lPf+4//Pvo8aN29MTRurshhBBCCLEr1LqJil4KbfklM3u8qqpf+Kb/9Ztm9tfN7CMv//c3\n", + "yMvtTW99s6vRD1ZCCCGE+NNF3V+i7jazv2ZmX4+i6JGX6+4zsw+b2a9FUfQ3zOy0mf0l/vJQ+oPM\n", + "MyYTUqvb33wR4Y9K405Ip/dwWEklTgcTpuf3LAfljEirzz99FurmDoSS89QSJkZcfu502KaN4WI+\n", + "fM/MzHzgX2OyJ7sj5xwXm/h5bQMFcR9YlxORj63GXpXheZ/KsMu2SMhj6U58FU8wK8DM7vr+u4Py\n", + "oRuOQZvf+qe/CnVPPPxIUH6V285L2zoEdXf++e8KyidXUbJ88fGnoO78My8E5QXXV66HD9KLiURa\n", + "ZSiWj4ZuwgIJhxwN8bzHTuLOmtg/YaKJodgdk2vGkzDxmpx37wUzmZiGz7rrPyXychnh8SwsPAYJ\n", + "EenLfOf+yQ4ByTy12I2fMRm32ASNOA1f15nGyQpjIlV318NJKikNcNx54krFDjqrcgJ6FaE8XBER\n", + "uvQTkchxGdMg1LAYkWOQTDB8Zm0cpxpkEs6V0+F3wcJ+DDjdf+PBoDzcQpm/v4ljSeYmEJVj7AcF\n", + "C5+eZPyk11H4OiaWj8m478f0rIXjRnuaTGRxn2/Yw++Zfg+/s8Zs3yek7uy8z9v1faq31d4bIYQQ\n", + "Qog/JSixXAghhBCiBrqJEkIIIYSowa4sQOxD1fyz6pi4DUmMroF/YM6dJXzW6duxLTMm0d9L4orM\n", + "L4ehYN2ruODixrWrUHfwptDH2SaLG29uhh5Kq4PP3QcDfF7ub5+jCZ2hyi20mZCFN5nbUHk3hpzP\n", + "Btn3RjN0BqICj29JHDp/rqIJfDYzs8/8Xrhw8C2vwgWB/8cHfwrqTn/tiaB8+exlaPP0pRWoS1uh\n", + "zzFLFovee/wI1PWc7zCacAFNCDQkUk2VEOcjdYv2EoegIIuUQtYl8Z/SDJ2WyPUP5k158gHzGrCf\n", + "eaUlJx4MC830KhNbSNiPZWZmuXM+UhYcWk0SBsv+5iULs3tniISnjvvYX2I3BjSIX8k+Xzl0C/Sy\n", + "0MwJ/l73x+kl8PzFLpm0YoHK1HFxIcv0e4YFmrptERfuOqtfh+9HXtZoYRDqcDscr4d9HL9bc+FY\n", + "WeX4eYc94qa68MksQ1dtPMb3YwGxnph891VuvC5yHCPiGI9doxUuJBw38buhNY2OsF8EeTgk332E\n", + "Cb/++Gvrv1QIIYQQ4s8uuokSQgghhKiBbqKEEEIIIWqgmyghhBBCiBpEkwRIvqJvGLH4SyGEEEKI\n", + "b0+q68xu0S9RQgghhBA10E2UEEIIIUQNdBMlhBBCCFED3UQJIYQQQtRgVxLL73nXPUHZrxA/NYvp\n", + "pJ3paagrXRLvaIgrUufjEdT59PPRiCT6kpWsW60w3fWhBx+CNu95z3uhbuQSw6eXlqBNd+US1Pn0\n", + "1X3Hj0GbZ//wq0H54PET0CZJMRF65cyZoDy7D1cK/8ADD0DdPfeG546veo51SRImj0+xdPIWrmg+\n", + "HoXpxOx8jrYxmRf3Abv6R37+w1B33333BeW+W6HezGzxwD6om94fntPTTz0FbcZd7J97Dx4OyiVJ\n", + "Wh6TFel98m9i6Dw+9BB+vvvvvTfcDptY4qO5zSxyccsxacP6ArwO3w0ToY3lcCMf+siHgvI9P/G/\n", + "4rbJ68qxS1EmKfjFCPsZbo0kNJPjGaVh34tT7ItpE5Orf/6jHw3Kf//v/Ti+HzlQ/tywU5ykeCbS\n", + "RljX7mBiuR8Dzcxil2Y9HmFKdLOBn/md7/zpoHzfu98NbSLyAf1RZ/2nSfYzc6sf+IR2M7MrF3Cl\n", + "gY2V1aC8/+ABaDO7gCsNvMd9nod+/h9BmzH5zhp23WoEfRzf+tvdsA1ZsSAjaeid2YWwvIjfRUkT\n", + "j50PI7//Xbhqw/vux+++Vjs85hnpB2x1gKG7/gYktX2bJLIXbgwqxrjttIHfM3ESftf+wkd/Edpc\n", + "D/0SJYQQQghRA91ECSGEEELUQDdRQgghhBA12BUnqtkOn7keOnE0KBd99BHOPHsa6rbcs+NmB58B\n", + "t6bwuX7kjAv/3NbMbGF2DuoGvS7UeZIUn7MXzuNJG/jM2XsaZmaRcxvac7hP3Y3wuXBzCl0j5nyV\n", + "btVv5mkwmu3w2XFEVg8f93Gl7rVLK0H56gD3aWYeV+VeOhi6WguLC9CmIsdlexC6BsNuD9owOjOz\n", + "Qbns4zP1xz/7B1D3nT/0fUH5NW+9G9p8/rd+F+ouPH86KB86ehTaVBGuZJ+1Q89t4K6F6+H1mIq4\n", + "TWy5+dKJNd51ut7r4P1Zkxg/n3dhqnLnjN4RWyGetBs734IHDmNd2giPeZLiuMFcLu/6xRk6ikmy\n", + "8/VXEueMKHRWxeGnjoj7w857moXjUsbcrQRfV7ljRd6OemewHdIkIn0/cXnN+QjPe3+E13syHx73\n", + "uf17oM2ew4eh7plvPBaUzz3/ArRZ7u783VCV+AGTBD+fuWOckO+LRh5+1zGHLyqwD/s+xC7ZhJxj\n", + "I86lJx8TF9bVee/OzCwjPmDD+VyNJp7jrIHXUb8fumF5TpyoFI9nFNf/PUm/RAkhhBBC1EA3UUII\n", + "IYQQNdBNlBBCCCFEDXQTJYQQQghRg10Ry2Pnuz36xTAw8tL5i/Caxf3LUHfi9puC8rSTgs3MogrF\n", + "vdSFww1JONzFFy9AXVWg3OaJiQDrw0SbMx1s08XgsKQVSvEzCzPQZv1SGNLZIGL5cIjScTF0n2Vn\n", + "b9fMzFrNcJ9as/hZ0iYe85m9ofx9hRzfs889C3Wnn3o6KC8sYz84SGTsqcWwL7TaKC8y+nkoJp54\n", + "1Sloc+7xZ6Du3/2L3wzK/8OD/wDavPZ73wR1X/n4Z4Ly5voqtGFybWcpDPdjEwoYfltEa7WSOuNh\n", + "ZUmCJpn7nTjLmG3bS+tmZrEXWXf2Wq1BRGgmwEO4H2mTEvk7c4J4cwrFci91m5mlsF941Asi5Xpy\n", + "Ig/7QF4zM+8qJ2yYZ/a3Ow5pittukKDC0hnhETHEK2bAOxIWxEik8coJ0xUR7ocknLG7tuXaYNDl\n", + "Ta++E+pe/71vCcpPzOM4/OzXH4c6gMj8jRb2s+EwrCtzPO/jPPx821s4xsdkskLkxu+IXFhNIrKP\n", + "xxN8QbBr1H9mItJHJAzaf0fHTAaPcJ/8JJHYsB8YuUZjEj47KfolSgghhBCiBrqJEkIIIYSogW6i\n", + "hBBCCCFqoJsoIYQQQoga7IpYfvny1aA8vSdMqn7H274LXrO0by/UrV6+FpSvnUEhff0yirpXz4Xt\n", + "Nrub0GbvEXy//ccOQp0nivGQ+iTl6XmShr6JYnmnHcrCbSLOD5xQ2CTp62sbeAz8CuZRMoG5a2aD\n", + "9VBybHTYaumYEr/vljAJ+ObvRIFz5TyuoP7sV0Nh89Kz56HN048+CnULe0MBfW4ZVytnbK2tB+Xk\n", + "DhTL3/jD3wt1//y+XwjKX/z1T0Kbu//y90Hd/hPHgvJwC5OWxz0US7tXw3O6cBD7KyNx6eBjIvzS\n", + "hGsnbLKU75gkHXuxu2Kx1Ay3C/EEaehRhm2YOBs1w2uEpRVnZCJC6la3j4gIzXczrCxIijITxD1j\n", + "lr5MUpv9TjAlmB1PGBNIm6piEemujvSfCQLnLSJyb6uJE1cKv9oCOX9Fjv1s9WI4vqycw++L7soG\n", + "1L3qLd8ZlO94/euhDUuht3/5q2Ebcn3QNHKX4F0OUY72E0TG5PMaqfNp/f6cm5llZPJARD6ehx3z\n", + "wn28MUs19zPNzKyC71Fsw75nWm7lD3b9Myo20WJC9EuUEEIIIUQNdBMlhBBCCFED3UQJIYQQQtRg\n", + "V5yoY7ffGpSX9oa+ysYldHi+9vF/A3Xrzq2KyErhwwo9gsM3Hw/Kb/zhu6HNzPw81J1/9izUeSKy\n", + "jvvY7ddUB32LnIRt2sF9QdE7GWZm414YGJeSZ+wV80IK/+x4MjbXw9XK003sQmsX16Du6rmw7tAt\n", + "R6DNoRtPYN1NJ4Py6kX0GE5/43mo27gS+nL9PnpvjKE7Dy8+9Ry0eesPvwPqbvvuu4LyFz/2e9Dm\n", + "5jfcAXXT06EfV5G/azqzWLd+/kpQ3t5YhzaMyskpRYnXRxSjnzORE0U6kXdoIETT+DXjNz9JFmxM\n", + "rg/my8xMh302aWBQaZyREEvnvYzH6KqVYzye3gdiuZMxOeawHSIWUbfJBRwyT4sdl4b7fD4o9aV9\n", + "YOcqrCvGxI0hgZiefIjhl1lnGurm9iz4PYA2w+0+1OXu3DxPAjK/8bkvQN2m+555/Q++HdrcePOt\n", + "UOehR4CFs2Zh/4xIQGXpPjMLMy2Jv+aPMbuOfT8349ctbJuc99R5fH1UPq0iCbxlFR6XlFyPLEw0\n", + "dQHVzMVjn3niL0CCfokSQgghhKiBbqKEEEIIIWqgmyghhBBCiBroJkoIIYQQoga7IpZvXAil2Cc+\n", + "+6WgvHYRQxdnyMrZh0+FAY6LJ/ZDm5tehzLv/gNhaOaTX3kM2nzm33wa6kbbKD4C5LZ0XDqJm4Su\n", + "jchK3Ylb3ZqJgj50jQq/bNV4v60Jwgxf2li474MhCpzjHq68fuV0KISf/sbT0GbfDXj+Dt0ayub7\n", + "jh+CNjfcdRvUrV8NZdCNyyvQhrEwF04oeOLzX4U2PnzPzOwH/vZfDcr/+G/dD22efvgRqDt8ZyjO\n", + "r/Xx2LVJ3+8shfuZ9/E8MCo30aIqUQYt2YrtrnskRHaF0EXD/sgCHCOyun1UeQF+55DORgePEwsO\n", + "TRIv7qJIW7AQUrefMVl9viQCder2oUqYYryzeE2hoZnhfmYkkDMj8nCSuuNCZXfsG/4zs0DFfIT9\n", + "GiATg1YvXYK6YT8cK/cfPwxtDt94A9TdcGcof+85tA/afO2Tn4W6J7/6taCcFzh54HXf91ao87Cg\n", + "UjbqVu6csjBYHyLJxHI2g6F0+16M8bwU5PNVE9wqDIf4HWbu+ykrsN/R/Fb3RcoE8Thi10y4n1WE\n", + "+12Ray2aaOoKR79ECSGEEELUQDdRQgghhBA10E2UEEIIIUQNdBMlhBBCCFGD3RHLXQLsvkPhCvSv\n", + "fdsb4DWLh1ECzGbCpOEkRmnt7Deehbpfee//GZQvPP0itDn12juh7pY33A51HiblNt2q2AVpkxOv\n", + "LXGrxI9Jom+rFW6730PBmKYhO3mRpSEz5vcvh/s0IqnNAxQT2+3wXK25RHEzs3OPvAB1F544E5SX\n", + "Du+FNnuOH8D3mw/frzM7B20YSwfC7b/w2DPQ5pP/6jeh7r/7yR8Nyq//we+FNqcfw76498ZQio2J\n", + "mDzs4nlPndRcNScTk0GqJvIpW22+9BMWiBHL0qy9jM32ksq1XvQkcq3Hi9FmPNG78FIuEZoLUucF\n", + "31aG75dlO0vVPjX+pffDawZgvj+T8t1njskkgHSCYxUTKZ+NEpDITia3jEiatafRwH0akYTryy+E\n", + "48TVC7iKweYtp6DujjeF3yvf85f/a2hz6OQxqHv4tz8ZlM8/fxrafJ0knXtK0qcsIhOB3PWXkFUo\n", + "otSdU3auSBI4zCdiE5FIXTHBvCOWOO8T/POsCW3yHI9L7iYntNq4ykejid/3/nJnSfns2k4mGF+u\n", + "h36JEkIIIYSogW6ihBBCCCFqoJsoIYQQQoga7IoTdey2G4NyZylcqbs/GMJrHiWBmCsvXAjK577x\n", + "HLS5+NxZqLvx1bcE5R/94E9Cm+XDe6Du7Au4LYB4IZlzJ4ohfr6MOAqp81d63W1o05oNj11Ojl1K\n", + "7pUT73NM6ESVVfjcu9HB5/XZPK68Pn8wPJ4HR0ehzdbKBtRduxQGs442utDm8lN4XtpuH6YXZ6EN\n", + "ozcKj9+tr7sL2nzls+g/PPq5Lwfl7/jeu6HN6nkMkd1cWQ3KSUJWNC8wEK8sXPAjCYxkpFnoFiRE\n", + "02BhdF6TYguhG/FzvPBE/Se6qrrzc8jrPN6jMMOgSzMW5Ef8pwL3KXJ9Pyf5kWMSODjsh69jwYhl\n", + "NYF0QvyuhPhr3mVibVi2rg80zYmmRQ4nOCYF9Z92Hl9Yi9nFBahrOr/y4ot4/f/BpzA088XnQpfq\n", + "DW97K7Q5cvutUNeeD/fh0c/g9X/hueehzuP9IDOzgnUidz2k3n8ys8x5UuBImVlMrja/LeYHjUgw\n", + "atxgwasOMk75EOmcXR8DdKmyZjhOjYZT0IYFcCeuY4+Ib0U0NEtYx54Q/RIlhBBCCFED3UQJIYQQ\n", + "QtRAN1FCCCGEEDXQTZQQQgghRA12RSzf3FwPymdeCMMue+soD+fbKKS1nST36rtfA23+2rv/FtQd\n", + "vfNkUH76saegzWf/7aegrreBYjfsJ5FGUxe2OepiICYNVHOyW38T339qPhSmmbResNA1H8BXThD2\n", + "Z2bDfrgPgx6m4flVyM3MYifJt9ooCrb3z0PdoYVOUO6TY9frbuKOOkm2u7rzuTMz294OP8/yMk4w\n", + "OHbTSah79NOhbPodb38TtDlwM75u4KTjzgLKkiMiXvr+MmZBfoRGMzyeIxL8Oi7IauwQfomvY+qp\n", + "D35kQjMLZ5wg2xNgIYElkZwTFz6bMKm7REk2d+dqOMLzMiTXAwR+RuRIJTsPxQkJzaTt3CQVHxL6\n", + "UiU5Vi6YcJyzo47j28jJ0TkRqPlMhJCcnKsow88842TzqWkcSy667xQzs7NPPR2UP3H5CrS5/Y2v\n", + "h7qjp8Lr9shtt0CbSeYFsF5ckAkMGM5KJiu5kOVWB4/BuI/fBf56LMjsASq7T9A/Gw2c3JKPwu2z\n", + "a2Y8wDE9dWPeeIxjEpmDA8J96dNFX6qFGjYnZlL0S5QQQgghRA10EyWEEEIIUQPdRAkhhBBC1EA3\n", + "UUIIIYQQNdgVsXzQDYW3mU4ou+7bsw9eMz0/B3WdxVCmS6dxheizly9A3Sc++NtBeePyOrQ5cOgA\n", + "1B08dBDqPBERblMn3G0TEZolanvZbbCF0qqXLIcksbyK8bhkLScBTmZGWgbyIBOMUQYdjkIxsLe1\n", + "Bm1G/S2oi5Nw37M2fpZOA49dNZ4kRRlJ3MdZW8P9PHADpq1feC4UWc89ien5nXncz83RtaAcMQ+S\n", + "OLmVS5iPJ0iENjNrNMIk4JhI61XBxODStZlsRyt3PTDPsyKSc+QkXCafw3Zy7PtsBYGBW22+JCJt\n", + "nqPI6hOnx+Q4lUQUzlrumDMjdgKzNSWrGmREvPYrJLAUfC8YM8oSr5mSfGZ/bXlB3cwmEsvjGD/L\n", + "mEjq/V44SaTdbkGbozffAHVTM+H3zOrlFWjzwh9+A+o2nIB+4PgxaDO7tAR1Hn/NmpkVNMXc9T1y\n", + "0WRpOA5Pz+CElCHpU74vFETYHvVR9I5Jv/Z03PE1Mxu5iU7JAPtdbxvfr3KTWwryuj6ZaFG5CUtx\n", + "So4BSXdnE1AmRb9ECSGEEELUQDdRQgghhBA10E2UEEIIIUQNdsWJgmen7jntuMLnxJeunIe6wfnQ\n", + "ZRh1MVCxGuGz3IN79gflW267DdqQfErrb2MIqIdlHjZdUNlgC58BZyR8snJBZaMuvn/qfIvxCI9d\n", + "M8PT7I9KRfwHhl9tvmQr0ke4D6n3NNiq2RXuQ1GE/kpVkSA4EmLnAwbLyXIKLXGugXe5zMy2ifKx\n", + "5/DeoJyT1+XkuX7aCsPhRmQldBbE6l2KJJns76HEOW0x82wM369y1yTVXpgf585zQfoLe51XaCZZ\n", + "ZH1jBcMTfeiqmdmg13dNsL+ygMPIOTut6Wlok6QkaNYd47SJDs8kcaIFu0aZquIcmjjCc8xWsodd\n", + "IB5TTII7I+feMLepmsCJihIMa2Tnz7tF21s4Lran21B30LlMM3Po2W6trULdcDOsu3wa92luGR1a\n", + "hIQeE0/KH6pihO+XO6+PuVWsX/sA52KE482AOFEZjdINmZllTlR4TtvexTX+XdB3obXjnIQsb+K+\n", + "V3l4XCLy3ZeR689/P/1x0C9RQgghhBA10E2UEEIIIUQNdBMlhBBCCFED3UQJIYQQQtQgmkT4e0Xf\n", + "MKJKoxBCCCHEtyVVxROp9UuUEEIIIUQNdBMlhBBCCFED3UQJIYQQQtRAN1FCCCGEEDXYlcTyf/AT\n", + "PxbuRNYMynOLy/CauaVFqJuZXQgrSIzy1voG1A1dGurGNUypHbg2Zpi6+w//t38EbX787/5dqFva\n", + "vy8oz84vQJtRDxNZzz//fLif6+tk2weD8jRZTXxuGevWr14OyoP1a9DmZz/6i1B377vuDcosfTkl\n", + "q2s3XDJ32sRE4STDpGyLw2NekEj4gq0sn4ft8v4A2rz/p98Ddffee19QzkiiN7MLI1cbTxKxbWbV\n", + "BPMsSpLgX7q+WJKV3h968CNQ92P/8/8Svo4kHfdJYrH/NHOL89Bmfhmv0c7cbFBOyTkekZT9sVtV\n", + "Pc+xzQP3vzco33vfe6FNSlZsj126e9bGfYoicv5c1/Ppz2Y8wd+fmiIfQpuiwH7w4M+8Pyh/+Oc/\n", + "DG26qzi+rZy7GJRjN76amS0fPoz7GYXHqtHBVRSG3TWos3HYX0iouTEn92dc/3zPu+6BNlGKG8tc\n", + "6v5ggMdzRPpLw60KMdXBxPliiOPE1lp4jLM2pm43W3iM3//AB4LyfffdC20aUyw9O+yPTbKfLbcP\n", + "UYLjVH+An2U8DM/VmBynkqy24PvszzzwIWhzz333Q13lxmv2q00cYa3fhzHZpxE5773t8HubTZxr\n", + "tvCYT02Fx/zn/8n/TvaUo1+ihBBCCCFqoJsoIYQQQoga6CZKCCGEEKIGu+JEZWn4/LgzG/oVS/v2\n", + "wms607jidum8idUrK9Bm9fJlqFu/GrYbbOMq4H7FdjOzzvws1HmGfXSphqPw2XTaJKuVE9fHP/Md\n", + "9fAZd7MRPstNiMPDIsKGg3A/8wF6MIxiGO5TOcaVtEfEC+k7xyRrESeqgcel0XQuVQP9lUaGr6uy\n", + "8Pyl5WRdfeievbNn6t5/MsO/RqhTY7it1J0v5oBU5c7uzZgcc0Z3M/Q7+r1taJMT/6A9Fa7QnhDX\n", + "qD2D7kaz7V+H5y8f4zXD3KKdGGxvYSVz6MqwLiEOX0TOe1V4Dw23XRE3LYH+ieeTHU9PQY5J1ka/\n", + "w3ezPMfzycQ+74qZ4fvlxBmqxuH2m8QxG5c7u38RuUSbTXSNet1wvN7oYh+eW0bvdHlP+L3CfLKr\n", + "5xI7lkcAACAASURBVK/ifmXhvs8u4/dATrw+T498z1x68QzUbVwOv5+619BDG22G10yTeG/ze9FR\n", + "nFoIv0cbM+i9Nefw82Ut4qv6Ngme47HvQxWOb8wt9P06I85Zcwq/Q/zr8hF+Pxnpi8MJzt/10C9R\n", + "QgghhBA10E2UEEIIIUQNdBMlhBBCCFED3UQJIYQQQtRgV8TyaSeuzbmAyNkFDIfMhyh+rV0JAyIv\n", + "v3gO2lw6cxbqet3NoNwg8uIcCQ5kAYOe0RAlTu+xseDQQYpSbG8rrGPBoXEaSqsNIts1SaCbl0+9\n", + "pH89hi7AjQVdDono6YVU4t/amEjqXjlsEJGWCc3tTig076y1/tE+hJ+HSeRMRI592B0Rd5lsXrk9\n", + "S4hkCds2szIPD2A04Sfc7m64Mp6rNukv7ZmWK3egTZNNFnDBgXGC11qSYR+K87AvFMXO4aUks8+6\n", + "G3hddTfD678ggaM+rPXldwhKWYbnxQdBmpm1p8Nj1ewQITYj16h/d3IIGiTsNnGTYgYkdLEkwv2U\n", + "C9dsTeN1tb16Beqqwl8zeI6rCcJnfSCvmVlvGye8bG6G57S9gOPy0VMnoW6wGm7r3JPPQ5txiWPQ\n", + "oVuOB+UWGWMH2zg2e2689Raom92LwdKzS6H8HZPxptsNxfK1SzipamsFA5QH264vsKBLEu5r40km\n", + "euAY5CcrsGxhnNBAJuqwSTlkXEzS8FrL88nE8l6XTEqZEP0SJYQQQghRA91ECSGEEELUQDdRQggh\n", + "hBA10E2UEEIIIUQNdkcsnw/F6s50KJqPByi2XXUrk5uZnX7y6aB84XkUBTfWULhrO4FyahYl2ekl\n", + "lBVZnaciqcJeRGbC5pisSD3YDqXf/hYm3qYuDTltoISYNvA0+5TYgoimjM5suO9Dst9lQSRElwCd\n", + "M9mVSPnDXiiDDpwUbGbW20Cps+Vk8zQlKfGEwq1qzlYYZ4J4EYWfmUqPTKBMwm2lRCJNMlLnks7H\n", + "TAYleJG93UEJeIFMfFjauycod2ZmoA07xnEc7mdOhG0qcbuUdi56h5y4HcXdfIj9069GwJLyU7Ji\n", + "AUsM92TsGLju4leaNzPL853PX0lmY7SYWO7HgG183aCHwnZ7NhyHM7LafUWOS+6u20YHx9Nogr/X\n", + "x2SSyuraKtS1psPx+4Y78LynMfbrx7/4haB84TSmhd/6xjug7uCJQ0F5ewPH4aIgArPj2T98Civj\n", + "p6EqaoV9aOHIAWiz/4YjQXnxxiPQZunkYajrrYfj5yZZ5aNHktyH3Z1XtGBp/Z6CrQRQ4rWdu++Q\n", + "mBjp7Br1gehxxlaAwP2KyNg8KfolSgghhBCiBt/STVQURUkURY9EUfRbL5cXoyj6RBRFT0dR9PEo\n", + "inb+6UYIIYQQ4k8h3+ovUT9uZo/bfwyIuNfMPlFV1Skz++TLZSGEEEKI/+yo7URFUXTYzH7AzD5o\n", + "Zj/5cvUPmdl3v/zvXzazTxu5kcrS8Hn12K2gvHbpArzfc489CXXnng2fJ69fw3CxrInPTWfmQ59j\n", + "z9GD0GbvUXwOPTs3B3WeEVk1One+UUxC+liYWN+tVj7o43PpyD0rZr6Od0DMzCrzzslkTs28C4dj\n", + "q5ePR+g2jZwDNSSfZUCCH/suLHFMwtPYs/jEOUnsuDB8eGhS4Lkalfj5xlH4uhYJnowSslq5C6Ns\n", + "tNCpYSvZe6dtOEb3h7F8YH9Qbjcx4LA1jb5T29XFZNX43gCPSzIK++eItBkQr867hUPiNnkysk+t\n", + "KfQPp9z1z8JavcNnZtZz1+OIeEWjIfbPYT/s+yxAcpLu6ccRMzMW0emdRBasycYS7zaxUMk4xb+7\n", + "++7ztcn7JSmOQZ41Eg4ZZ3hgvAO1uIiBlV/4zU9D3dd//0tB+eR3YCDnnW9+Le6Y24UzT6N72yWe\n", + "FGyGeDfXiOt78fkwIPrqGQyR3tpYC8rekTQzm13G47L/5NGgvHz0ELSZW8YHSM02em4e/51iZlY4\n", + "36lk/ZwmcIYNS3I9lsSlqrzDSvpdSjxX5hJPyrfyS9Q/MrN3mtk3X7H7qqq6/PK/L5vZvm9h+0II\n", + "IYQQ37bUuomKougHzexKVVWPGF3gwqyqqsomX21DCCGEEOJPFXUf532Xmf1QFEU/YC/9ojwbRdGv\n", + "mNnlKIr2V1V1KYqiA2aGCy2Z2cd+67f+w79vOnXKbrvjzpq7IYQQQgixO9S6iaqq6t1m9m4zsyiK\n", + "vtvMfqqqqv8+iqKfNbO/bmYfefm/v8Fe/wN/4S/U21shhBBCiG8TXqmwzT96bPdhM/u1KIr+hpmd\n", + "NrO/xFuH4mN3fT0oXzp7Hl5y+RwGo/W23Wre0yiWLu1Hue7k7TcH5UM3omA4NY8S+ZhI40CFTzf9\n", + "qupMwCvJytJVEdax4MfMCYUVEfCYJOuDH9n7M1qw0jt+lpSI0D6osLeNEnnOAke9zEuCCgc9rIP3\n", + "ZwGgDNc3x2MUodmxiiJ/jklIZ0yC39ymmiTgsNPGOi+WN0sUxBknTp0Kym0ijOZjnCwwdGGXUYRD\n", + "BwvE7PbD81eN8diNqDQetivJefCceeo5qIvJCNdoh/3Th0yamZXsGnWTDnIyHoyHbKJF7trg5419\n", + "IiehIv0uJZNU/LYiEuAak8/nJ2202lPQhtX5z1eRay1tTxB2S+To4ydvhLo9+8MQyacefgLafPnj\n", + "n4G6hf3hmP49P/L90ObEbTdB3cO/+7mgfO5ZFL337NlZ/73pdfjE5S1/8R1Qt3wonOg0NYXX/7YL\n", + "v9y8gA991i9dhbprV0J5f5uMw8MhTjooJvh+YEHBHv99ZYZh1GYGAyP7XovJGFtOEIibEsGfTaKY\n", + "lG/5Jqqqqs+Y2Wde/veqmb3tW92mEEIIIcS3O0osF0IIIYSogW6ihBBCCCFqoJsoIYQQQogavFJi\n", + "+R+LgZPZNq+F6atrV1GSy4coD0/NhFLs4r4laHPsFpTGj58KZcXWLErkwz7Kn+sr61DnYYJomoXi\n", + "XDlGIbUgKb9Zw6VuEyHOC9NMoGbKqk8QJj48JXKr1DeIRD69iMez4+TdJEPRtCBCs09b9inuZmaD\n", + "LvaN3lY46WC4hQIlo3RieU7S15m7GMWFr4A2XuY3M2u2QiG8KEjifILHKrZwJzKyWjljYW8owCYp\n", + "nr+BS5c3MytcyjZLHu9tbELd+moosno528z4xAcnoGZEoPZskRULxjlex/6cMvGaXWtJIzxXvk+b\n", + "mXU6KOq3Gu78kc8yGuIx9zBpNmbSeLLzsYrIMfcTO3zyuRmfNOIHGD+JxIxPpvHMzC1A3fQM1p17\n", + "/IWg/IXf+Ti0SRIcY9/y34azwu/6njdCm6e/iitjPPy7nw/KjRRF74UDe6HO86WPfQrqRkTi9mnd\n", + "M4vYz1rzYap4ZxZT9ztNsmqCO+8FWy2ArAphxc5iOfsOKX1UJOl3LK3fr0LBVqWAbZtZ5cbFiIzD\n", + "7A1jMsZOin6JEkIIIYSogW6ihBBCCCFqoJsoIYQQQoga7IoT5cM111ZWgnI+wufE3n8yM5tdCp8L\n", + "Hzx+GNrsP4Z1rZlwFfduF32ZDedpmZmtXl2FOk/WxNDDLAvrBmQVd+aYtJxf0SSvg0fMLLSThUO6\n", + "ANCEpRISVi6GvlqSoZOxtYVuzNyePUF5wZXNzKZm8Lm+98na7tyZmQ1JAGd7K9xW0d/ZOTEzy9wq\n", + "9cUIn8Uzf827BqMcz2dCvKWxc4SY98I8t9LCfUgn8GDMzBpNF5YY4flrNnE/R+44bK1tQJvVFQz3\n", + "21wPr5mYeAwp8eOmpsL9zKZ2DhMtSdhnMcK6rWvhvve7W9Cmt4XunffcpkhAX3uaOFGzYZ/tzM1D\n", + "m0lWkWeOEqvzvuEkQZ5mZuU43BbzD9mmEud8FcSpYfvpabXx+t+8ip7bs197LHy/MY6Lb3jHm6Du\n", + "9d//5qC8TsbzT/6r34a6K2cvB+U3/ZcYhZhM7ezUnLz1FNT1iau5djF8v80XV6DNylNngzJz+DIS\n", + "0tlZcH1xAfticwoDVdO4Xv+ENiUZOwvctt9WRV4Xx8TZc85uSVyufIzbmiCj87rolyghhBBCiBro\n", + "JkoIIYQQoga6iRJCCCGEqIFuooQQQggharArYvkQJN9Q/mLBYSxIc3YhDGKbJpJcRILRer0wYGxj\n", + "FSXZ9asolg+IwOxhkmzkwr22N1FkHfZ3DhPtkBBEHy5WkTDDMZGcYR+JmMi4cvFSUM7JivQFCRP1\n", + "q3AzAXduGc/xzFwY3Nki0iMLsSzc+zXSycLUOu2wv4wLlFbHY7QQxy4olK06nuZ4uY2d5JgTKXdI\n", + "AvG85xknk8nD49ztp00mzvsgxkEP++uA9OFxHvbZhg+eNB4U6kNIm82dz1+TiN7TczgRYW5hMSgz\n", + "ETon4ZfFKDx2Q3IMctL3Y9cXyhG5Zsqdxd2I5B2yMNjE9QU2+SNtYF/0ryvGZNsxEZjdOfWBtWaT\n", + "/bVeEuH32gqOw2O3Xze/9lZoc9dbXg91uZsc8elf/wS0efoRDNt8zd2vC8r7ThyANisrl6HOE8/g\n", + "d9F+sq2bvuc7g3KrhQGnTfc9w67j3jp+z/jJUcM+iu0jMt7kQzw3HjqBoQzrKjrJYeew3djYhC0W\n", + "Ph1eowWbVEWuozidMG2aoF+ihBBCCCFqoJsoIYQQQoga6CZKCCGEEKIGuokSQgghhKjBrojllYsH\n", + "bbZDIbQVozycEbG04UTSOEP5LB+h6Nl1KbGrl65AGyaNxkTeg30iieXm0le7qyhLstTt1nQo2M+M\n", + "URovncjKUobTFgqNkC5LhFFG4lag9+9vZjbq434O3H5tXMZ063PPPAd1DSdQduZx8sDMIq703nFC\n", + "8dQ0CsaM1AmNjRQvEZ4c7SRcIi/6fm+GoveAJKvHhtJj6qRKlujL2NrwafJ43iuy89suhX44IKvP\n", + "E2Oz7VKTmVjOrpmWe12S7ixezy4uQl17CqXcKTdZoTM7C20yIl775P+cJKQPtvH6y0fhOfXXgplZ\n", + "f2vnSStGTnE+JJNG3ESWRgOPQUISqCPXz9g+DXooHadu+0lCtl3t3D9HfexTXhQ2M5teCMfFozcd\n", + "hTYJmUjyB//uy0H5G//+a9Dmlrtuh7obX3NbUN7q4ooM7PvCc+0iyufnT78Adf1BOKaWJRv33QQR\n", + "kszt5XMzs0Yn/G5tke+GlFxrabzzigFsDMr9JBUygSJNSBq5H3cjHANHZDUC31/I/B6LiNxeEgF9\n", + "UvRLlBBCCCFEDXQTJYQQQghRA91ECSGEEELUYFecqNh5Nd6TiNgzdRIYl7XDwMY4wmfAvS4+q964\n", + "turaEI+I3F42Jgj8yxoY+BdZuO/jAT7jzvvoNvgnt351djMMa0wb+Lw3iUhAXhZ6DN5ruB6dudAf\n", + "iWYwGNWHoJqZmQvgYyGdPeKFDZ0nUZBAvq114pi57ff76G4xGs6ra7dIGCVzm1wAJ3mET0PevFs0\n", + "bKB74D0tM7OqCs9pzDZO8EF6PiTUzMxIf4HATyIbtDvoMkZR2K+a5PNl5PP54L6SBIDCa8i2ezl+\n", + "vq0V50CuoJ9XEQ8tSsLP3GygT5KQgSNN3OdjDhhxlOD9I2wzHhFfxp2btMn8LuL1OS+EqDiWZXiO\n", + "m81wzCvGeG2XxG2CfTJsQ74KbO+B/UG51cEx6LnH0a983tUdOnoY2tz6mldB3cZm+P2wtrICbTrt\n", + "nb8b2m08dtPT2IeiyoWlkvPuSSI8xwUZg6oqHAdzch2XpG94H5CRkdBj/6qS+Z3EwYrcK8cFG7/x\n", + "/fw1kpIQYjY2T5g1TdEvUUIIIYQQNdBNlBBCCCFEDXQTJYQQQghRA91ECSGEEELUIGKrzf+JvmE0\n", + "oQErhBBCCPFtQFVVREnXL1FCCCGEELXQTZQQQgghRA10EyWEEEIIUQPdRAkhhBBC1GBXEsvf+573\n", + "BGWfTmyGiand9S2oGw/DFOPFg4egTcut2G5mtr25EZSHPVyVu8FWjXe7+eCDD0GTBx64H+q8j7ax\n", + "ge/HfPulPXuCcquNqeLXLoUrg29v40roUzO4Sr1fvbs/wNd95EMfhrqf/KmfCMosTbuVkVTqOLxf\n", + "j2J2/07SbONw+wlJpY8qPFeJe117CpPk/9ZP/CjUvetd7wrK21skzZ585oPHjwflqZkZaLO5tg51\n", + "w62wL2xewzTkfIjnpjUd9uvmNL7fQw89CHV/+3/6G0G5v70NbbY3sX/6hPmYnL+UJOq33HFnx6U5\n", + "RVKw3evSJvb9hz4YXn/33f8BaBORsSR18cQlS22nq7+HrytIo5gkJI9ztw8kMjkhx/ODH3hfUH7g\n", + "/vdBG5Y4n7jxlNmwBUmgrtyqAuzYxSlubZiHfWN9C8fqfh9XI/jlf/4vg/J999wDbSKSQm9u1YKE\n", + "fMK4gcdzdSVcqeLwTTdCmyvPncNtZeH220v4nVKSz/zgh382KL/nvndBm4qkkftUb3b+fKp5FWGi\n", + "f5yS8+cuo+YUjmVZG4954d7v3X8b++I973sP1BVuZYWogceuIuN35L6PWmM8vkY+c+mS20vyvRpV\n", + "+Dqf4P+hj/w8vt910C9RQgghhBA10E2UEEIIIUQNdBMlhBBCCFGDXXGixu75Y8Mt1Z2k6FakDazr\n", + "rYe+yiZZjb1JVpZvdkIfqLdNXJUhrhrdYM/nHUWBz6HXroUOVmceVx3fd+AA1EV5uA9Pfe0JaNN1\n", + "rsFNr74d2rSnOlC3eilcyZ6t6s7wK8Sz5NRxic+cc7eKO1uZnK2uPY7C/SLKiVXk/awMjx1bPZzR\n", + "aIb9bHN1hI3IOU7S8O+RtIl9hfky/vgVJToubAX1Zjt0htrT2Kco1EXzTejy726fSH+psK505z3P\n", + "8bqKx1iXlk1X3rl/lmw75LOMi7C/VAXxiogTWbrzUNLPS1wjV45J358k9Ji1iGKyn/5csc+X4Ovi\n", + "JOz7VUScGtKHE+eYxBnxbKoW1MG2iWvI3K04CvtwXuD1vzCFHuj5tefDfSKOaZLh9VGOwjEgJu5f\n", + "TvbTE5HfLCrmc7kq3vXd+5FLlr0scn2DjYtj8sLBCK8tDxkWwXeKyTGIidcXD8LvzCRCL7RKsL9U\n", + "7npgoz7zOcuo/u9J+iVKCCGEEKIGuokSQgghhKiBbqKEEEIIIWqgmyghhBBCiBrsilgO5pyTFX1A\n", + "n5lBwJqZ2UYRiuTbaxvQZm4vhrxN71sOyvkAJcTtdZTNJ7nl7HYxnHF6aT4oHz68H9qsnb8CdU//\n", + "4eNBuWzg6Xrd298clJttFOmf/erjUJcPBkF5bs8StKE4MTEjgqoRSa90wnRRoUzoxV0zszQObcUW\n", + "OQZM6fQy9mA0JK3I65zdPiYidJniOzac6D01jTJ/l4RYei942B9Am9EA65acAN+c2lncNcPAyCgh\n", + "nZqIl/64UDGZCMVwrbN9YjMK3Fn1QZCMioTo0SHOvR1/f1Lngvti0vGYCO0bRkQsT+g+hJRkAgWT\n", + "jmFTZNv0mvGuMr2Od5bpmw0UtjMiY+M+kQ9T4D5k7niuDTEw9ujSCajbunotKKdtvGYiMoFp6F63\n", + "PHUDtOkReR8hkjzrZzATgWzK9QU2LyE2MnnHlfMBHvOcfNcyadxTxXitRXF4jLOEHPP+NaiLx+H3\n", + "aMQuNtLP/DjFRgR2Hvzr/jjolyghhBBCiBroJkoIIYQQoga6iRJCCCGEqIFuooQQQggharArYnlV\n", + "OvnLSWslkV1n9ixAXePcxaB89cxlaDM9h6vGTy+F25qam4c23S2UFSdxB30aupnZnuXw/c4+8Ty0\n", + "Of/Ci1A3f3hPUD71htdAm9iJes/8wTegzXgTZffF/aFcX0wkRmK6fEYSk5mkF1VhVxsTCXhcEInb\n", + "CZRZguJnTLpx5ITmkojsjCoP3y8fopDOLprY9VlfNjOLiThb5GEacpdMaGBiuRetqdRN8EncTZJm\n", + "XxHxMkp8EjCe4wZJac+cqJu18PpIiHScujRiL8QzmCxdEBHaJ7IzKZdppn41Auaist0c+wGO9P04\n", + "2TnxuqzwDZlsnvidYAnN5EP7yR8JEZOZ/O3T1jOSJM3ezxMTeTgfk0kcrXDyTPcKTsqZWZqDuuFa\n", + "OA5W5Fy153GS0cWvPhqUb57H75RLJHUboKnY+PkK82MXtvErPsQRO76kvxRu20QitxGZwDCBeF1E\n", + "5Pp3YnlMJl6U22u4sYEbB6dwRYaC9mu3n9S4J8L9BBNXrod+iRJCCCGEqIFuooQQQgghaqCbKCGE\n", + "EEKIGuyKEzUehx5IFYW7kRM/Z3YRn0PvObo3KF94Dr2iKy+chbrFw4eCcnuR+FZNDPzMB+gWeaY7\n", + "GHZ56YUzQXljFZ8B77/tJNTtOXksKBcxuiNXnwk/X9VFh6dFVivv9ULnKyMhlowEnicz/wlf5x+p\n", + "R8TvyJjXA9siTgaLVHP+AQv3nISiwA+Tkefs/tN4F+h6dX4/WdhmQXyLrBme0ySd7Pw1XMCgDwk1\n", + "M2uSsNv2MPTVIhYcSBwFr4EkKR6DhAV+QofBJh7mDCUk7NM7X+UEeYcv7cLOvgULIfUBnBXztNgx\n", + "8G2Il1KQfS99UGlBvCni5/jtU0+SeEs+rBScrJc2hnWwHXxdTpyvLAv7ft5Ff7WxgG6TuT6ck/Db\n", + "pROHoe5L58NQ5w4JNK5IAC/CnLadryMWBuvHWOoxModu7Jyokl2z5HUTOFFVjL5jloaeVJqTMOEu\n", + "usxmYbuouQwtygS/1/ylFdEAXoRl5E6KfokSQgghhKiBbqKEEEIIIWqgmyghhBBCiBroJkoIIYQQ\n", + "oga7IpbHzuSsXLjXmASAJWTF5oM3hit1X3wOJfJzT52GuvWLl4LyNBHLm018v6IcQZ2nv7EFdYN+\n", + "PygvnzgCbVrLe6Aua4RBiEkXRc+NFy4E5Wvnz+G292Kg4sFTNwblhT1L0IbhRV0ftHe9Og8L5IuI\n", + "4Vu6EDQWPBcRsTxxAmxRThi26bbPHFkmUHs5OiYrmjOp2q/iPhphH2NiqQ+2TCYM25zqhH2BhVhW\n", + "RPAduWs0IfvEwlL9avMx2TYLcGTHeCdY4KAP1jRD+TSOUAZn++nPQ1Hh5+X+rd8vbMTez8NkcBYc\n", + "6MVyfw2Z8eMbJ+F+5Tm5rsjf3b6vR0ySn0DcZXmjBelTmdt+3sPJNEYmyjSnQ/F59fR5aHPna+6C\n", + "uu5WLyhXQxxLWD/zsEDHiJw/mL9A5PrYvHyOm6EBp66Kyeds/J7kaowTFO4zL3ZvXYI2VW8V6lL3\n", + "nVy1MWyzinA8rfw1STI0Kzo5ov7vSfolSgghhBCiBrqJEkIIIYSogW6ihBBCCCFqoJsoIYQQQoga\n", + "7IpY7uNB+068jlsojA36KNwuLIcp5kdvvQHaXD6NsvmlF8ME8eUjmFL7/7P35kG7ZHd93++c7n6W\n", + "933vOvtotJtBCyCHYjEklIJLJrjsAipOYZykQjmUnVRYIpBBMyONFrTMSEKKMEvFxAUFruBAERvj\n", + "KiqWTBlMygKBUQAhDRJCMxotc2e5c+99l2fpPufkj3uhdL6/79XbtCTeK/n7qVLp9pnT3ae7T/fT\n", + "7/N8zvfEzgt/zeb407XaeMnx1B23V8s7573EvbPj5e9uv5bkfvdfvMvV+eP/+DvV8pf/ja9xdb7m\n", + "2/6GK9s7d75a/v1//x5XhwNpyESWLOTdHKVclopLJyKHvjKwdHIipCds18hE2gL7azs/MzlLZMbd\n", + "ZZIyvl37vrHZ1P06k4R0EoLtkuPziERoM7MOhXQiu2MaupkZjvWIRIjFmQjMzFIPx0cGjfRbn2Ic\n", + "UG4d8ece61OJpIOjTNuSQQ4tOek9SKuxkH6QyP0AbfCp/yQNncIk+eNnn6eSPJG/nYhMLfnj20n7\n", + "cDj+2cmeG8zXLiDAx+TXOzhcubJzz6qfw08/QgbhkLT+FoT07b5PSG8aMhsBUNjsDuTB5Aa3UOkZ\n", + "Bw+wGkygbqAO6z9kY8d3M2vZ8a3rgVbDvk8nj3NyfKdqsXxofBr6sCWNghPBBuWwk4XP/b8I+iZK\n", + "CCGEEGICeokSQgghhJiAXqKEEEIIISZwIk5UA7PZry5drpbT0/WymdmpS2dc2e7pOtzrzJ23ujq3\n", + "Pvt2V/b0hXr7V558wtXpzvj9FeJAIO2Onz381Pk6SDMO/vfXJ9//EVf2gd98b7X8qY991NX55u/5\n", + "jmr5b37v/+DqPPbJx13Zu//pL1TLV0gdxphfjjHsz8xP/k5UKjqjOboi7DfugXkF+Ns4ayghgAvT\n", + "zrwT1S387/MGrkFP3J/NhoRRwnqLXe/GtS0J9wSXifkkDPSd5gvvgCxJG4rV7WQhnZkEI243te+0\n", + "OfL+E5PhSqqdsjHOAtM2WKgkButRn4R0mAh9j81sTx1B8KRYEGs3JlyUhiCyhsJqmUh1ZL1EQh1d\n", + "E9j9h/4fqROJd+a2TcpYbmef6362u+uDGC8/6QMc9+6oXdRLf+KDH9fEdzp9583V8hGpMyYclvUp\n", + "VuhcJhIO6frCSH8NHaxCHFPq+o0Io4zZ3/95famuE70rmvf8Z2Za1L7zwD4viAfauOMZ9+T/LLI2\n", + "9U2UEEIIIcQU9BIlhBBCCDEBvUQJIYQQQkxAL1FCCCGEEBM4EbF8d6cWc9e7tSB+cFDPmm1mdvGT\n", + "XhRcQEDlTbedc3XuesHdrmyzen+1fLR/ydU5TULXupYJmjXnQCI3Mzu8ULf90sf97OGXHvOS4+nb\n", + "a+Hub/3Aq1ydl/ztb6yW3/cb73V1/vU7ftqVNdtaAvzql73U1bF/+X+7IifOEpGWB7+hID7u/R1n\n", + "R4+BhDwaERrRzaTi5Yj9sVBQFlQIIvSwJW0iIiSKnt2CiOyd31+/rYM753MiuxO6WS2WL5ZELCfB\n", + "r01Xr9eSczBsfdjmCkT9QATRNPhz1W/r817C8dLzNnlptWNmMoi6fU9CQgcS/AidKpFA1UD09llb\n", + "P2YXDQtwPf7ZEsi91jKhGUT9ofhzl4ipyyRjJJM2+JBTlpB5/P2eSEhnR8Jg16u67+/C54eZ2eHF\n", + "fVfWna2fp3HmB9McPfaUKzt1Rx1MfLg6cHWaEeI8C9ZM5FzhJaUDbkaI7C6w1swJ6WxgAutnR5Wp\n", + "WAAAIABJREFU1hw/sKMt/j4yKMudP09hxw8MSKF+nrEA18gGWsDnCgtrZedl7MAjhr6JEkIIIYSY\n", + "gF6ihBBCCCEmoJcoIYQQQogJ6CVKCCGEEGICJyKWF6uFzOVeLbeu115QO7p0xZVdulBLgMtdL9fu\n", + "nb/Jl90CM0Qnv79+7VNp24UXGJHLF7yseOWpup2LHX/an/81X+HK7rz7OdXy8pabXZ1f+fGfq5Z/\n", + "+1/+mqtzmrT76//O366Wy/x4sfVazWpp/DzvsB7xFJn8jWIgT4QmwjaIujgz+vVAgZHNzo4p6mZm\n", + "h/u1bJqJSLslad2pr4+naYlYPvP9JUH6+Tr4wRiMDOnZKfnzGYnkjAIzE8sT84nhmmIi/NX9sVTx\n", + "gAV+48Bq689vP0JITyRdfsbalOFaEf92p/P9ZQ4i+Sz6OrEc/yhmEnAmKeM4ZiOwm42Ap5jdM4Xs\n", + "D73nltwzTBD3+/fHx4R7fF7Pd/25Gw788zuA/D3f80Lz4eN+ANNpmL1iu/UDCljKt9s/OT42EAEv\n", + "F90yBpYfu/dr24KNZ3aNmY094viiEbEcBiuEuf8sGqL/3C6Q5M7keprDj7MKZHJ+2Xo0Tn4c+iZK\n", + "CCGEEGICeokSQgghhJiAXqKEEEIIISZwIk4UBn7NwfnY2fO/mx7te+fjyhN1SObOKT8b9N6eDxM8\n", + "d/sd1fLmymVXZ+g3riyPCDgbBr/eLXfdWi3PSZDnQLyMC5+oAzgv/u4fuDoXH/1UtfzlX+ndqud+\n", + "xYtc2QEc36c+8rCrw8AgNhpmRoI0ne9E6qRMwgvhp/CGrJeJZ+N+QR+nhbjsUBZGOV/4stmsDqhk\n", + "LlUiv7tj5mELYZhmZi0JqNuCE9UEf+4YqU+fcdmMh2Y6dSOzRwcL7oNZ46mjwPpLXZaJO4IMW/+M\n", + "GIioleAiD70P++yiP745eD27M+9ydJ3vi3Pw3BZzEmY6ImyTuWos7BZvNXbPMAWkQCgnu1bcLQRf\n", + "jvTXdkRQcWJuY0ueE+ARWuc9wrz12yrgO3YkpPPgaf9ZsASnlN0zgQlyuH8SKsueE3mEn+OCO1nC\n", + "Mfm8IgaULyGbYu4U0tjKlaVQH3NmfZGdg4why35/rEW+y5JnEmsD2dZY9E2UEEIIIcQE9BIlhBBC\n", + "CDEBvUQJIYQQQkxAL1FCCCGEEBMIY0MIP2c7HJv8JoQQQghxA1AwAfQa+iZKCCGEEGICk1+iQghn\n", + "Qwi/FEL4YAjhAyGErw0hnA8hvDuE8KEQwrtCCGc/l40VQgghhLhR+Gy+ifpRM/vVUsoLzewrzOwh\n", + "M7vHzN5dSrnbzH7t2rIQQgghxBcdk5yoEMIZM3tfKeV5UP6Qmb20lHIhhHC7mf16KeUFUEdOlBBC\n", + "CCG+YLieEzU1sfy5ZvZECOFnzOwlZvYfzezlZnZbKeXCtToXzOw2tvI99766Wk65Tixtgk9/nWef\n", + "ohxjXcaSq7eFJcLWh12yPzed+QTo3Vwnst73tre7Ove+7gddGUbANmxGepY4C2nEDYltLbBeIe+o\n", + "kSTXDjC7NotsfdPr3+nKXnXvfdVySH7F1JLjg7azc5AGf41DV1+/YetTf/Pgr9WZc/UvyVcu+zTr\n", + "t731QVf2X7/iF6rlsvD7e+7sIVf2V7oPVsu35qdcnac3/nb4k+GFdTuLT7M+2/gU5XleV8uXyC/n\n", + "73zzq13Za++pr982+EdAJinROdXXJhSSvkz6Hs6qzr76xj5sZhZgjnYSMmxveNNbquU3/n1/PV18\n", + "t/l7pGG3Y/RtyvB4weRzM7NINlZc2jqZkZ6cu/t//DXV8n2v8c+WkP2JaaAs9L5NkawXIDG8IWnP\n", + "BZ8bZpZmddsH8qmSOn+u3vz6H6mWX3v/q1ydjvyRH2F2h46k2bN0cHwOZnIdMrkOqakPyG/ZbCDP\n", + "5je+8W3V8ite+XpXJ0TfdjazAdLiTA7kHmKfYVg2j/56tsWvtyj1/f/db/tJV+e1P/I/urKAH8lk\n", + "f7Ehsy3Euqwh/a6QEHw8DYVUyuS1J8OKb/jun/cbvw5Tf85rzewrzewnSylfaWaHBj/dlatfcelb\n", + "JyGEEEJ8UTL1m6iPm9nHSym/c235l8zsXjN7LIRweynlsRDCHWb2OFv5N3/zN/7838961rPtrmd+\n", + "ycRmCCGEEEKcDJNeoq69JD0aQri7lPIhM3uZmf3Rtf99p5m95dr//zJb/xu+4aXVcjp+7kYhhBBC\n", + "iBuKqd9EmZl9r5n9nyGEmZl9xMz+vpk1ZvaLIYTvMrOHzezb6Zrwu3MLM2C3xH+aBz9D9KypvZCe\n", + "uD9mS1dylPeq5RT8LOCFOANtJLPb43rkN/wAv5czB4ToB04E6YmD0cCs8TgTu5nZQByz4mYBJ/sf\n", + "QSEuQNMQB2uod5CYx0A8lAjb7+is52Smd3C1MpkhnpGgby4b71Ld0T7iyp7X/mm1PN94c+JT/d2u\n", + "7NHhOdVyRtnBzO7KH3dl59vauVoFf14YEVyRZu77fma/8kdwCzI5n3TMCG6LeVNktQn9MZB+EJg4\n", + "gbtq2LEwByPBMvFniLuBp47d7PSZ4CqR60KeU/gIaAdyDla+v3RQj3RFy5H4K/BXcJmTc0f8HLf/\n", + "7OsE9hc2OFEDu7fJczjjs4r018I+Q6CDBtKHyWPQ75/4cqzvD9A/2PMtQ50ZuS5dJp8X8FnQkc+L\n", + "lvT9OGIA2jbtubIA17QhTtSQib8Gz/lCvKlCrnuBE1rYB2v2rz3kI3I0k1+iSim/b2ZfTf7Ty6Y3\n", + "RwghhBDiCwMllgshhBBCTEAvUUIIIYQQE9BLlBBCCCHEBD4bsXwyTsJLtVjWBS+aLcLGle3YQbVM\n", + "MjOtLX49tPkOiJyZXEqY2TBC3mV+aAuCOAtYw1BCM+9GsoBKdA4zEQUDseYiypIjxEgzs9Cg9Egq\n", + "kcIMInLX+fNbiJA+X9YDAw4OfPBkYcI9tKGN48TrM3G/XrYLrs5N4aIri9BlH1s/19X5g6Ov8mVD\n", + "rRU+Y/Goq7Oc/Y4vg3ZGIoMyIvzdVEg/zzMvmyd4VOQtCfcjYnCLhjjZnxvkcLWhf2EiewCw4EIY\n", + "wBCI7Jpm/lgyBK/SOuQ6BDjmmHyb2uH4GzAwuZccXxzqkxc3/py3RwtXNjuC0GPSztIS+XsXg1hJ\n", + "aO4IczcmIg8PROIGWTiyJFYasorSMRvIQu4HfJ6xz5kRHXYg0jqbwGMLgyEyGRyBz/2WyNnsmR7h\n", + "82FO+uuMCf5jzOstecbiMRNBPNBz10Md8ownn6N5hFheSEA0G6AxFn0TJYQQQggxAb1ECSGEEEJM\n", + "QC9RQgghhBATOBEnyuB3bnQGtuZ/W2Vlc/j9ugv+t/hF8L/BbmCi26bxv62uzXsh63y8V0O9JQiH\n", + "Yz+/ssmFsYRNJJzg+MgczDYkEmaGE7yOdKIyeBlstYG4DQa+U+iIy0F8BHQiLj/ufaTTt553Zd28\n", + "vlb56PigVDOzvfbpavl8fNLVmZGgySe2d1bLf7j5Glfn99Zf78ouhGdXy8/rP+Lq7JDAT6cVjryA\n", + "EXyHQHyy0pDw2ba+NszACv0h2V+9faqvkDBBN7E22Z/fEHMGSaAieBmZhEOmPR/uu9mBcN8FcXhI\n", + "AGeAmYvbre/nzFvyG/fniWghblLiZvDPrfbIlzVX6smvw5aEEs78s6QrtZuayPPU2uOdPfYXvfOR\n", + "zCxAJ8rEccGA46tgPeJusnBP2BZzeEZkUdK40cb8dU/oRJF+3cB9y/bPHLoZlM2Ia8QmdEanlVF6\n", + "5kTVfWgY/Llr2OdTB/c/CQ7NxKEd9Rhk4aWkXWPRN1FCCCGEEBPQS5QQQgghxAT0EiWEEEIIMQG9\n", + "RAkhhBBCTOBExPIC724JhO1DO+vWudKec2WnygKWD1ydmXmhuMXAMfOBnEMmkjObRR2gXltAGZuJ\n", + "iV4CbJr68pCcQrOMgiELSjt+9vAxs5Cb+aAylmWYibC5WNTXOBH5vI1eaD66XF/T1aGXrJ//zC9z\n", + "ZWlbX/eD9TixfN7UQvFO9H0jDf62eXqoxfKHt893dfbDKVd2e/OJavn59mFX56b4tCvbhwuWgj93\n", + "jGZdH18kj4A433VlA8jmiYSXZtKvUXxmoXnsfnD1xtx7bKZ3dq+BSJ6Xa1enJ2J5f7ouWy3J/mZE\n", + "TO7rc7w48DfyzOZ+vREwnzmCdIxyv5lZTOTRDyJ56EmfItchwL0WB3Jv5+PvP9bORI3tuqwhA27o\n", + "Wq5w7ENvxGrsQQhksiKLsBzg3kpErm9ciK3fTkuCNPGzL5DPC/ZZZGQAiiORZwJsPjS+35XEBhTB\n", + "NSXhzEZCcjHstrAPNhZeSoJlx6JvooQQQgghJqCXKCGEEEKICeglSgghhBBiAnqJEkIIIYSYwImI\n", + "5RGkuFWphbSn7Ca3zlODL5tDkvNd5WFX5674CVe2AJF8t3iJlJmJiZrdAEvdPt4BtMCkQ7DyiA9n\n", + "2UYk17YkeRgrjhEHzbed+ZTdzEuyAeTPzQER/ve8yHrlqVqqPkPSye94zl2u7P/7d++p90/kzDGw\n", + "8HU28OGJdHu1fBD3XJ1bF4+4she176+Wv6z9PVen7a64soP4jHp58DI4YwbSb+p93y9bUraot1+I\n", + "fJ5IJnOG/oF92oxIsubvBzY4wu2f3Z5s9vmu7nt54ftiv/Cy+Xq3Llvv+aTlofX9LEJCeYQBMWZ8\n", + "sALCnhFUnI+4TFLpZ0yKhyR3OrWCPz7Ue6nUPebxQi4xzx2HwS3kmZtI8niEhOvCUrhZ46Hv8XTy\n", + "4/snu1YsB3zARzPZthsYROpEcjD42RtIHXqrjRl5RA7GDRrBB4KZFTKoIgeQ1Hu/8SaymTGgD5Nn\n", + "C50Zg7RrLPomSgghhBBiAnqJEkIIIYSYgF6ihBBCCCEmcCJO1CzULlMfl9Xypng35uPlGa4sQ4hd\n", + "2/rfSM8VH1S4LLUTNSveiRjI76Yb8y6DbxQrwt/U/e+7kfhWBXyOPPj13LaC/42bzoCNv4WPdKLw\n", + "tTuQmbSZV7Dd1Occ/YTrrYftfPaLv8TV2X/isit78uHahXv2C+72Gyc0eDqDv0WOkg/NvJJOV8vL\n", + "uO/qPHvugzS/qv1/6zrRe1OPN94HvJBvrZZX2beJEcFbalc+oLbtvKPQdHXfbxbeicrGAjjrfl2I\n", + "U5PT8b7amNnZM5NVmCcV63oDXnQzS8QZ6ru6rJ/59XriRLWh7uvDmuyvOf7+IwYI9V5yU5+soSPb\n", + "JgGjOdXtjHPvfDHHLC/BMSPP4RSPv8aRhQIzryei20S8F5axCP2DdTvmFvl+RbyeEcolc9pCYEGh\n", + "GM48Yj3WAPKIRVUs0xPli8YQEnum1zcgUxQLCbYeMgS/EuFqIGGbAfoeLpv5QE4zszCif14PfRMl\n", + "hBBCCDEBvUQJIYQQQkxAL1FCCCGEEBPQS5QQQgghxARORCy/eX6pWt7ta9F8n4Rvfarc4squpFq4\n", + "ZeFwgQjbAdLoUH69Wua31Y+QWwPZFsqRLDyNZUFGw3ayUEIQd8n+mTsYYFtMqKSA/MnWSmw2djAa\n", + "u85LyGnrRdbdvVpgnhOh+ZE/8sJ219bb7/Z8n2LMrRZuIxE2981L3Idhp1o+N/cDGp7XfdCV3dXV\n", + "Inkhgv+F4Pv+xXxbXTCMu34oqcbBC8YNkc1ns/r42P0RSKijT2P160V2z8B5QNmWwa4Vm5EeyzCc\n", + "8rqFkOZJvFYjnrBbr5CE2mGMmUxuZBbAm9DeJV0/Gwm7BcG+IcIve1BlkOmHBbn/iXCPsAE37M/8\n", + "DH0D+8rVQnpRq6WWDG7JZGAObosOphlz+7Ftk7a3GDRLNhVBtGYC/kDW7Jv6mm7JOcf9m5mVMUHT\n", + "LLASykryz/1h4wds5S10WtLRExmIEJu6X7fzjavTzI5cWdv5+2Es+iZKCCGEEGICeokSQgghhJiA\n", + "XqKEEEIIISaglyghhBBCiAmcUGL5YbW819aJ05lInWyW8ydDndp8Pjzl6nQkInUD2ypEct6QpOpM\n", + "UsxdHRY8DGIiE73ZhOJYkQmpBunEhYifCacFv04bxhBA5kuJ5CgTqdOJ5ESkZTOvz3dqkXx75dDV\n", + "ufzkRVd29tab692NTKRtIM12yD49/0o558qO4l61vBt9X2yClxcvhzrp/Enz2/5Yeb4re7KvB1Xs\n", + "setAyPNaEC+Dl/kbFrvfg3Df+vNiTNR1CfBEWiV9NmD/GBNZTu9PdkPW9ZpEEqF7f/+3m/qYU+tv\n", + "2tyTxHKQaZs1s6XJ+cQqRB5umFgOfR1nPjAzKy0RaRdwb5PnRiB/d+OMDMQdNiPnyhHHCdsZ+gt1\n", + "wVl3wQEFpG/Q4O+2PsmJnAM2gAGZsdRt8kwPBQcLkec3bIuNg2CDP4ah3nZPXgESOS/tmMR5In9j\n", + "GnlJpMOSew3F8rRdujpDIa8vDczIMHiJfEGS1UPy9caib6KEEEIIISaglyghhBBCiAnoJUoIIYQQ\n", + "YgIn4kStmvr3/0WsfYtbhsf9Sq1/37t5qAMNaSBf8a7Iuqu9kC354X3T+oS6zJwkgKop8Fs/m7k7\n", + "EElpgPDJMcGhkfx2XYhrlOE39RiZyODJXnJxdSI5lgAeA5+znmwLztXRlSu+DnFxds/XgZg5j3OG\n", + "GvQWyCXvsz9XeNZn5vc3kHN8AUIzHy3PdnU+0T/LbyvVrtjp9AnfUMIW+n5e+jA6NrM7ujch+/UC\n", + "8QgxAJMFI7KgVxpoeAxUR2RyDNwzZUv8p7W//+foXCXvkzEtK4IH0qz9/sJmxP1HgydJNaiXG+L+\n", + "kNshdxDyyDZOpE987hZ2/zfHO1Fsd8zEwfudPfepezeiDobRmvl+xcKSR3w0WEt6KOvl6HhRFRYu\n", + "ckkjwzbRByT3Iw1QHhF2ayzsGl0xFi7KnD1YbSAeUxm8R1ia+t7KgXhokQTNxnGfDwx9EyWEEEII\n", + "MQG9RAkhhBBCTEAvUUIIIYQQE9BLlBBCCCHEBE5ELL9stRQbwKSbNX5m+Xnad2WnQaIezItmPSnb\n", + "gqmXSWJdoTODj7AHSeBYUzCgksh1RJx34ZokVa4B4Y/OZE/EPdxWM+LQru7g+BnGmXiZBghBI2GN\n", + "AxF18bxsN77OfMdvq1vWYvDB0QFpqWcGxm1DhPRTwcvt6F2eLpd8FRI0d6Wcr5bXtufqLAcvR54f\n", + "HquW77RP+jYR+nk9Y3q2HV+JSfjQPZn3XVhwX64lTpbZx0T2gPfMCHM3kH7uxFYzCxAiOSNieSTZ\n", + "e3GoD7qdsZnlScPgmRCJJNuSNiA5suMjO4TzUNhza8SzhCVP4kCWaxWhEtkdewZhHRK22Takndgu\n", + "Uod50MS9Jm1gQjoOjvAbyjRlGRj88WG4r5lZLgmWfT/D5zwOwDGz69juOAjA12ADPUZkiXKxHEYL\n", + "sEtFRzmEugwHQpmZFXLucPNNJoOxejIwqJ3+KqRvooQQQgghJqCXKCGEEEKICeglSgghhBBiAnqJ\n", + "EkIIIYSYQBgz+/TndIdokQshhBBC3MAUN9LrKvomSgghhBBiAnqJEkIIIYSYgF6ihBBCCCEmcCJh\n", + "m/e89Xvqgm0dlhhJ8FxY+YCsdrWslpuDpa9z6Gdjtw3sj+WkdX6m5zKrZ66/9xde4ercd/8PkY3V\n", + "BBKe1jb+mEuG0DUS0rfFUEA2jXxLQvMiBJWRk/CWNz/gyl7/8lfXbSROXUvezVsMoxv8z8stSSrE\n", + "oLvE3vvZTPawTHLg7J5/8sO+7DX319sJLIiVBKNCqFwmddi2LNb9OpOgy1R8qFy0OnQ0mF/vrW96\n", + "kyv7odfdUy1jEOzVbfuywYUJkoBMV2IWoJSF2DYkDDJjKCBRKR/84bdUy699x3e4OjHtujKD54Zt\n", + "SeDoZuGKQqrvURrI2/jrUGZ1eHCY+WdLbH3A8P2v/qlq+TX3/KCrMw8+FbSzVbW8LCtfp/jQWrwK\n", + "pfHPzk0hgaoQaDwE9rHir/EPvfknq+VXPuCPj+aE4v7JdcjkueQejaTvN9m3fbhSP/d32tO+TRt/\n", + "v7/uba+rll9xzxtcHQx+NjNLVj8TjpL/7NvmuqwYCeR0JWYRnvsdee53LAAUQo//jze93NX5mX/4\n", + "Pa7MhV8Gf39kcm/jR8FA0n23JCR709bnZdX6czeQUNdtqOs9+GZ/ra6HvokSQgghhJiAXqKEEEII\n", + "ISaglyghhBBCiAnoJUoIIYQQYgInIpbjbOShq2UzlmkVBi+I5XVdjwnb1ntBNIJYymZCD9mLnoUa\n", + "6Liib4OThbMX6QqZBRxFyGj+HKR1LY0uThORLniRte3qY85MkiWUBs4VkboHInUmEAO7xu8vDWSW\n", + "ehSTmdDsPUg363ii2rMngswfiNRtROJsYBZ1djZx5vWr9er1YkOuMRHu3aTtadz1cw4n64vkVDUg\n", + "Y6JIf7Xs+HYyaZ10fbdiCMcfXyhkEMlABPFtXZaPvFheVqQs1dvHQQ9mZmHmJe4mwjGTP10TDvQg\n", + "bKOX5IvrCGYBylL22w4DG6wAx0OuMbvhM/R2HBQwFhxIY8bFcny+DOTZ1RLp2InziRxL78u6WH9e\n", + "tNnfo+uV/7xAZtFL1WzESw+fY53584Ii+UDuvYj9zswCXNNCtm2kLzYjLik5de76saht9nmf4fNi\n", + "IB2hJwMYNjBQZ0s+j5mQvqWDIcahb6KEEEIIISaglyghhBBCiAnoJUoIIYQQYgJ6iRJCCCGEmMCJ\n", + "iOXWQQo12GalEAEvkYRdENIDEb8LEfdKX8tn3Fn18qCR9FPXJpawCzIdFf6IirxY1iLplU9tXJ1h\n", + "U28rkmRXI+IlhraiwH09EkiAxGu1SI4ltccLjQ2RuAu852ffDawl1zhsMSl73PEZtAv3b2YWmFCc\n", + "6vVaJtcSh7OBBOjUkf1FMqjCxS+PFOdxLZYWTu6HCJ2YDcagnR83Rlcj9yj22RFiayTJzmVDHnGQ\n", + "Rh6Ozrgq/cEpVzaAkB7J4AibX/ZtAFE3Rj/Qw9qZLwPWwYvziTy8mlJvf0b6MEuJx0EV7Dkc2Xog\n", + "OTtB/erWSNmYOmwWA6hBEqhb8qxOff3wSEQsn5N7bQb9sz8kifNENkca8vCKTGiGNPnIHrKY6E+u\n", + "cU+OD+81dh9nco3LcPz1a0hfxIEkkQ1Iiayd8Pwm56DHQU5mtm3r87luvUTek1k9+ub4++966Jso\n", + "IYQQQogJ6CVKCCGEEGICeokSQgghhJjAyYRtNhjOBuGbbFZn8ntymNcBZ2lBgjWXxD/Y1mWBeRMt\n", + "mRmc/Abr6rDQSihDv8TMrJ2R39SHul0HT11xVebL+rfchhwK/bUeXp9Z8BwDf6smOpL1JJmtLMCD\n", + "WzBB6PgwurgmfoefyN7mELIWiEvFQFeLXXEWjOq8NxJm2LGAw77ui30hftDMuzADBhySUDlGhrZH\n", + "sj8WiBegw7CwTRak6ToaC1Qk95VzImjwI2y6950/9Cyktw5P3OzvuTqbKze7su22dhRj4wMWF2d8\n", + "O5seXMbs3UYXyEvoo3++MY9obXVnn5tfryFhwhF9R/Ioo0Ga4Hgyp2bcX+u+VibXHYNfmQdaiEPb\n", + "b+p7bT477bdN+lC/Xz9gmuTPZxvYtamZBX/d2WedRXSEfZ0ergMLo2RPL/SWIvGImZ87Bvbx6AJU\n", + "mW9FtpWgXk+8tw3x3o6cE0WuJwnbHBS2KYQQQgjxl4teooQQQgghJqCXKCGEEEKICeglSgghhBBi\n", + "AicilhcQy0uopcpEHNmWWI7o96Z06OqEgQSxgagXV14KLGzG7Y5I6se0ycysAek3E1GwJWF7B0/U\n", + "G1sf+Y2fvb1er93x2x42/lgKCMVM4GQEFK+JSF9av63VTn3u1uf9evsLcl6gXct9L4yeuug7DOSw\n", + "WjuMDNuMKFAT8ZqJrCCIx0QC+Q59EGOEW3BG+oaZD4NEj3xLxVIPXvdCZn8PpA04YKIlf38xAZZE\n", + "I/oaVK7FbZNNIyRsMxEJOPV12bD1YvnqYNeXrWohfb7w56Bb+mdQ7iGMkjyTxri820IejGHpijDM\n", + "d0X6YhNXfj1oA/sLO5lvQwIpt5BBDmMeLzTAlfUX2BYbdNCTZ17b1gM0FrMdV2e4tO/LDupnTrdz\n", + "3jdzOP6jdEZCVllAZYAA3ib4fo15zZEMDEqFtAn2NyNdKhr5vCBit6vDPvygnWxgwkDCp1Ek35AR\n", + "UytStu7qc7WKvk5pyf7GffxR9E2UEEIIIcQE9BIlhBBCCDEBvUQJIYQQQkxAL1FCCCGEEBM4GbEc\n", + "Z22GWc5pgikxLwOIyCX5d8JEhOKAKc0tSwsm60WSsg0QR85yqre/XHihsSGC6MHTIDkSCfH0TbVI\n", + "19sB2T9JygY5Gmf3vh4tbou0qTR+f2lZn4Mnz/iu99hZkgTc19u/zbxYvjwis83D4IVuZAovzoYe\n", + "yKzumaV8o6AZSUR68WXDwVP1aizxntwRcV6fq4YMTGBgyxsyoznVe0FcDeRWiERud0fDJHJijeNp\n", + "wMR0RiDZ/CWRRxyUpZ4kGA+sDGakJ4+NlMg5QGGaSLqRXAekRJ9cvyb9JWP6cuP7XSQJ6aXUUvyM\n", + "3NuJ9P0E5z2RwRjsuejrsMRydj/AxljCfuP7wqyt75l0QJLjD/x5yaV+NnfLW/0O9/2AAmRObppM\n", + "Ljs+q4ZCZj+AUQANmSViTZ77mGzOZs+gdxqLrwfc57rx9HrXJjJQZwtJ4yuSPL6a+WceJpZvOiKW\n", + "02koRg48IuibKCGEEEKICeglSgghhBBiAnqJEkIIIYSYwIk4URl+v8W8v8iCNclvxwP8nluMhJll\n", + "EsCJgYONd3EicSKoCIKQ3/BbmG16PvP+0/5F3/ajg3qm9TO3+HbO9+qTd3SZuDgsMBJ+O87kd3cG\n", + "eguZ/A7ekrIEZVfI7+AXSXjaDK7x2Za0MxAnCjY//q8FnEGd7Y+4GxDq1nc+rDHsnHVlEfpLpt6d\n", + "dzdKrveHAX3XA9UJFqzJHJMINylzVXjYJqxH3LTYsXsNm3S8k8EDY4lLCfdx0/p7pp35cx77up81\n", + "cxKo2q5dWdtiiiVzR45P+xvIfWzE2VvD8wwDVs3M0kACKmPtmCyKPweB3A/BRoRtUtPN8/gjAAAg\n", + "AElEQVQVoD4guR+gL0ZyDrrO+zL9lfra7Abvpq5IoLF1ddjtqb1bXJWDx57w6wEzcm8XFrYJx1zI\n", + "cxHd1MDuK/PnYINhqcxZYm7jiMuXGhakW+8vkX6A/pOZ2RE8E47m/lgOmRMFrmhPZLzAPLA87vOP\n", + "oW+ihBBCCCEmoJcoIYQQQogJ6CVKCCGEEGICeokSQgghhJjAiYjlKGiXBuVTIgoz2a2rBbGYvQjJ\n", + "vMSSQHYjomfZelkRAwcZgUQVtk29v+3aS4BXLvm2tzBL/N553yYMKt2siVgevIBXtvV6XMr15BGi\n", + "4JC8WBqH+piXa3+ezh75bTUgUC5WpJ0kLBFl2jGhb2ZEnCVSbs7+HGPAYSFhf2VxxpU1IMXSQRWd\n", + "H1CQwZwfI15fXbGuR7MvSYhkBpmX9fNRkOtQiFDsHPUR4nUk9zELPc1dfa+18yuuznKX9MVZfa1m\n", + "S7/t+a4fyBLnIJtHL6QXMjjC1WGCOAZrmlmyOdTx90ciM9mXVK83hJWr0yUi3OPlY64yexC7Ov6c\n", + "u2BkM8swsCOSoMSyJue4R8Hfn5ejjS97/t0vrpabA38smycuuDKkJUHBLf28qNtZ3Anmgr+rQ+6Z\n", + "ptR9GJ8jZiQc1syGEWHMA5G4E6w3kM2sSSDm0azui0wiPyQBw0cwiIt9trfk3LWfxfdJ+iZKCCGE\n", + "EGICk1+iQgj3hhD+KITwhyGEnw8hzEMI50MI7w4hfCiE8K4Qgh/TLYQQQgjxRcCkl6gQwnPM7B+Y\n", + "2VeWUr7czBoz+w4zu8fM3l1KudvMfu3ashBCCCHEFx1Tv4m6Yma9me2EEFoz2zGzT5rZt5jZz16r\n", + "87Nm9m2fdQuFEEIIIW5AJonlpZSLIYS3m9nHzGxlZv+mlPLuEMJtpZQ/M+wumNltfAu1vIcCXGAS\n", + "MBGfMwrpLZmBm0hrYV4LfpHJi0RIa/oRMi2R8kKpj3e9IoIhSW3tTtfbWp72296ua2l1WHtpjgSk\n", + "u2a2JEGcMWRM9Cbnjpyn+WFd7xaSPL5cHbmykOr1zuz7bc82rA31OR8bSIv+ZKHX0+8Pe8tA1svt\n", + "3JU10NcbMqiiRN83UK5lgigjgmSMffN6FDiBLOm8jEg/Zno4Czp34vqIWeQDEXet9YJ/nINYvrfv\n", + "6zREGk8wCKDx8nK34xPLA4jluSUzK5DUdEfyfSOQPlXg3A1GZmRoWMI1lI0U2VsY3MIToY8/vkSs\n", + "49CQQSpwfCzkf3tArl+3Vy1v/BgA2zv3TFd2dvfmavmj//5XXZ1dMlgAiVSc941vYKBFId91LODz\n", + "aSh+/yzgHm+2hAnmZpaJIB5HfN8ykGdQD/L+hnzOHHW+D+9D4vzRzPfhNfnMHBoccEOeU+QZayNn\n", + "7GBM/Tnv+Wb2cjN7jpndaWZ7IYT/vmrT1Tkgxg35EkIIIYT4AmNqxMFXmdl/KKU8ZWYWQvgXZvZ1\n", + "ZvZYCOH2UspjIYQ7zOxxtvJ7/tXv/fm/7/rSO+wZX3b7xGYIIYQQQpwMU1+iHjKz+0MISzNbm9nL\n", + "zOy9ZnZoZt9pZm+59v+/zFb+um/9ymp51OSUQgghhBA3EFOdqN8PIfycmf2uXZ0m/ffM7KfM7JSZ\n", + "/WII4bvM7GEz+3a+PngS6NCQ31ZZEBtmkLHfjqlJ0cBv+MR/IBNg20B+P0aYz5UgqDCRn1+bmW97\n", + "09S/3TKP4eiwDsRjDkEgv0NjeGmgM6h7MLcvZxas6c/B4rAumyW/vzM4272ZGQScdgNxMg7J8aFf\n", + "MTJsE72eSPyOTCQe1wKyHnOpcAb6wgJdyezoeIswr4gRCzpRxO9iG0PHi9Uh3mJpIBCXhW2S+xYd\n", + "rFHZnkSOYfd2aWtHKS6I/0gcpQJ9PTbErZiRkMcG9teQdjKxB+jMB10mEmzrLhX1QkhILnwcNOQh\n", + "GIlPgpcmZhKWPOKjpmR/kRviA/Y9eGfkedPEHVfWxd16O+ReO7d33pVd+tAfV8sHj33U1bn5y57h\n", + "ypCBPGMDC4iFS8qCSlt4vnTkBulZkKdrgN92Js+EllwHZEs+e7ZNvd6K1FkRb3ELQZpbEvZZiLuF\n", + "z6WGHF9L0oRnn4UTNTmxvJTyVjN7KxRftKvfSgkhhBBCfFGjxHIhhBBCiAnoJUoIIYQQYgJ6iRJC\n", + "CCGEmMBkJ+qzIYD56N7kSEoYC3DzgX8kGJEIm7Gt5bYyI1JZTyRgJv0CTI5MKNxSwZgEcM5qAa6Q\n", + "YMQ81G1vOl+nIWJyxhnNR4rJHTh5THpkcnQLoZm2JpIlaydK+cQ9j+RatdAG0n0oBYYiJCIhWvaN\n", + "KCAwRjIIgQ98gEEObLZ7ImwbhB6WkWLksIagWXKv5Z4EfsK9VmibfFHG606ucSDnqpnVZYmNxsB1\n", + "ohevY8fEeVjGESpmZr0XxDFwMLNBB0Q2bzrYVufvdTq4BSgDkbqDP2Y0ywORghM19WuZlweqHh9e\n", + "2JLgxzEDVyIJ8uw3/rw0oW5n23oBHuuYmaVV3XYWCry9dNGV7T/6aLW8d5MPh9y781ZXhrBBKi0N\n", + "xMRnM5GjoS8uyOChQp5duOmEI4XMrCWvBSWQ5yDQk/DLDYjl68Zfl03jgzS3VsvmmQxyYJ+H7t2C\n", + "dDs2fmlElu910TdRQgghhBAT0EuUEEIIIcQE9BIlhBBCCDEBvUQJIYQQQkwg0HTiz+cOmSEuhBBC\n", + "CHGDUnCqlWvomyghhBBCiAnoJUoIIYQQYgJ6iRJCCCGEmMCJhG3+t9/1r6rlnGEme/LLY9f6ULn5\n", + "bL9e7q6Q9Y5cWdPV22Kzo7fBB8Z1UPa6N77T1fn+t3ynK8OAQRbSF0jaJU5Azeo0wU3Z7mEBlTAj\n", + "fcg+zOzBV/8TV/Zjb39Vtbzu/Q6PNn6HmJm3WvvwtkRDLOvjG0iQJ9a5CqxHggr/6Y/56/eOBx+s\n", + "t8JmWSfBgU0Ht1JLguCwjpmlWNfLJHBwIDfEBsJSBxKQ+frv/z5X9vKXf3+13G/Wfn/Zh/s1MNP6\n", + "YmfX1dnZ3XNlS6i3s/DBeom0PUG78uDvx3tfc3+1/H3/6D5Xh90PfvJ3EppJUl0LXHemSLCu2DQY\n", + "/Oq33ZIV3/b2H6mW77v/J3ybkg+jjLh9MpM9m90+QlBoSv55enjlk67s4pOPVMur1WVXZ0au+z/7\n", + "v95bLT/wpn/g6uTG30cJw0Qx0NXMSiLBxKXuw6n3oZn9xj8HB3w2wnbMzNLg2/C//dgrquW3v+EH\n", + "fDtJIGYL129JEiO7FvsiqeM7ukE2syXyvEkkgBcDov/n+3/UVbnvvntc2WJWn6vNwaGr8+TK39t3\n", + "f+kLquXDjz7i6lzp/bNrdv6majniAZuZsRBS+JB80wNv8etdB30TJYQQQggxAb1ECSGEEEJMQC9R\n", + "QgghhBAT0EuUEEIIIcQETkQsTyDqDWlZLWc6e7jfTpdBUqOzZHvxcgazvTdMLI9E+Bsxk3VDZtNO\n", + "IAY2dCZ78j4L1WLxdQIIcSzKNBA502AG86aM6woof2+3/pxkJibC8TWkTU3DZg+HWblbf+7oBNyh\n", + "3l8gAwUY21Xdp6J5MTGQ61dy3fZAxNZAhNQC52Eg/QBFWjOz5MRyIlAS1oe1LLxdezmzJxI+SuNh\n", + "sXR12uiPedbVx9x2XuZtgj/mHuR2NugACUTOZtm+zrdl8jnpZylhn/LtjkTmxXs0kmscR2QQFyLg\n", + "l+SvOz4/6eAIMvABmx6i76/LxY4r29up+0YX/DN3vvTrIeTxRsfJuDueHR8+PM0swGAB9jnTk+eg\n", + "E8szeVbSZ17Nwdq3KZJ7Zg6bYu1cGPZFv78++/VSggE3ZEX2KAnkfCIDuUe38CzJre9Ttz/rVld2\n", + "9PhT1fKnHvUDGm7/6r/qyjKI5P3hU65OIQN8Qjv9+yR9EyWEEEIIMQG9RAkhhBBCTEAvUUIIIYQQ\n", + "E9BLlBBCCCHEBE5ELMek3wTp2ZlIbLF4+buAdkgl8saLs/NwAOt56TgSWZFJxg4i86FsmpkkS+Th\n", + "WEA6ZMI9booFbLNtgxzJZXBPP9Q7IF6rlUzkbzgvLZPIyfENKMkyeZiccywpI/9eGNa1WN6ywQpE\n", + "OraCCfBE5ifSakGxlMjKmRi3Ge3P471rMzPbrusE/6PDA1eHXAbrZiDOkx02RM7EpOpu7sVyljiP\n", + "wjQKo4xC+kFLBgGQNUfUIcfHJ3X360WQgMm56+Lx/ZP1c5SlzcwySPkl+Dr9iGcQ2Z3F4JPHT+3d\n", + "XC2f3j3t6rhEf0IkKepMGm/hemVyHdilGUYMDMjmxec+18dcBiImHz/myEL0aeiBrli3i81YgM/F\n", + "hqSaswEMW7jXevKcGsYb/hWb3n+O3vWM51XLD/3BB1ydM2SwQjmsn1Nnn3OXq9Ps+L546QMfqpZP\n", + "n/IDYLbk0cwE/7HomyghhBBCiAnoJUoIIYQQYgJ6iRJCCCGEmMCJOFENOEj4WzELrGta7zt17QaW\n", + "j1ydWbvvyhZNXS+SYM1AfgRmLoOrQ9yiCL9ps9DMSDywkrAOma3c5c6R2cvJLOex1OeczXrOSAmc\n", + "KCJO9MRfKXDMGQ/uOuDmUyIOAXEbEmx/IKGgdH+bVb1MfJKh98fc9HB8JHQ1MC8EyoqRkE4y03oD\n", + "fYp5aIwC/YyFnrJcvRZCM5njwrwC9FUSdXhIGV73Ec4Xm8m+sPsB9kcDMkmfQmePuWPM2cP9dWR/\n", + "Y/6abcl6ibShgQvIjoW6hW5/xF8zfx/NoFrbMI9whPNF/CByyL6dxBnK5PldQt0XWPxuIs/Boa+f\n", + "lXnwblMkfQ9hj6AmkP45ok6BG2LW+TrsntnA59N2IP2c9MYxnw6333azK3v8I49Uy09f8Q7m1/5X\n", + "L3Zl7/uVf1Mtd3fe4urkw0NX1ub6JMc94lv1/l1ijHN5PfRNlBBCCCHEBPQSJYQQQggxAb1ECSGE\n", + "EEJMQC9RQgghhBATOBGxHIVwDNsrJGBt3nkhbTGrZ6RfNFdcnWXj5bNZU8vDRkLeWLZYJIIm0hQf\n", + "1la2uH0msjJ5+PhGhYQSqZdBiQtqBcI2I2k3A2cUR1HZzCyQ4ECU6TPz+Iipi5Is86fZ7OH498GY\n", + "WcjNzDIExvGgQn9CC4qzRCyPPZPN6/OeWehi60VWPH9l5K28hIC62cwro0w2X+6cqpvUkH5Orl+/\n", + "hXudCJzD2gfipm0tf243PmzX7Z+UYX814zPeu22R9ZwUT54HNNsTn2+k8wdmUAORtIkeH4rlVJz3\n", + "23f3CKnTNLukYS3UYYHDI9IaSR12PgPck4Gcg8gEf+ghzAXPJHwyZxDLM3tWHj9whQYak+NLMECj\n", + "IYNwBmj8iljyhQ24gQcok8hZeGmiz9iaSAbcfPijtVj+X/zdv+PqPP7Hf+rKHvnjP6mWv/lv/nVX\n", + "56O/9duubLasn2+p89cqHRAhndQbi76JEkIIIYSYgF6ihBBCCCEmoJcoIYQQQogJ6CVKCCGEEGIC\n", + "JyKWtx2I3Q2kjEYv0qFEbma2012BZZJYjhK5mXVNLakGMgN2IhmtLFkZiSwB1vl2JLGYJCu7WdVJ\n", + "BG0s9SUMpN0NkSUNxHIr47pChihpdk6osImyIvFM2fEhgb33s/2RNceQh3rNgQw6YCLrYHU9lkBP\n", + "xyWker1ApM7AZrLHjbH4bMLe6TPVckMEeCZZtl09YCEysZz0hc1BPSBkQ65xv/bSOCbTY79jsMRy\n", + "JsnibASRdEa2nj88cj+SCPEWTlVHBeoRYjkpY33RjUcZyA1CjO2AK5J2RrJeDJi6T64Dm2kAYNeP\n", + "RWVHlLhJ12BtwANk57OQ2R1Sqo8v47NzJHTGC5Lyj7fIwIT0ppbd2cwRbBYDHDDRsH5AZf7j++cn\n", + "H/2EK3vxN3xdtby9dNnVee+vvsuVff1/8y3V8ubIf7Z/4sMfcWUv+aZvrNv02BOuzozNKsJmbhiJ\n", + "vokSQgghhJiAXqKEEEIIISaglyghhBBCiAmciBPVtHW4XgvzaTfRJ4fNO+9EYQBn2/jfTWPrZ2yO\n", + "EcpIoKLzA8wsNMefrtiTYETM6GPqD/ktPoAn1TG/w/2+69uYqe9Ur8eC2Rgd/HZM8iPNyKzjmJJJ\n", + "9QfiB7gwQaYVkLYX9MnGOlGwXmSOGekHLtCQhegRR6HB60fcAzpBPNRrWEgnYe/s6Wp5ufCznLcz\n", + "0ofhgLZrf19tjrx/uNoHJ2rl6/Qbf78H6ENj7j3mZGVyPvFM0duROCYYOBjI/mZz385Ti7psOSP3\n", + "Oo0KrcmJJdQSLwuuFQsOJYKXf+aRkMeS/XUvARwl9oAb8UkTaeAoc33qZdb3SdNd4K/hspkV6sLW\n", + "ZYmGbR4P68O0n0EPTSw0c6jbxJ9vxL3DTZGuEYv31zr2gQicvfUWVxYgBfRD73u/q/OSl369K1uc\n", + "q93N9/4//9bV+Sv/2UtcWYIDPHrqoqtz7ll3ubLDlQ/gHIu+iRJCCCGEmIBeooQQQgghJqCXKCGE\n", + "EEKICeglSgghhBBiAicilncgljcgJjKxfDE7cGVdrEXytvGhfSGSkDcI82RSJ84UbsbFVUc/d0Wt\n", + "1aJu2RKxNHmZN0DIGwZrmhnxSlm4IJmVG2dCb0ccm3mBOhKpMxOBGk9xIOuxmdcbkGJzT2RXFrZ3\n", + "vOdN2WIwIQmjDCSYDWVeds5pHiaeK3IOAhNg8byMDNtcLGuRfLl7ytfZ8bI5BqEemr8fMVjTzGx1\n", + "uF8tX7n4tF9vtXZlXVffD3PSTgcx8NmgA8wXZKeOOc64KeKH2017Xjq+86a67TsL3382W//Mc20i\n", + "+2NXvYBVzQIy2Zp4/9FzwMrgBLJnZzPmDiRBpYU+zyDck4rzZH8wiCOR0MVA+kuGE5ESu0ePP77t\n", + "QJ4JpB6K5D2R3XtoOx17QspaOFctCZpuycCgng5qgP2R5+JjDz9cLT/vxXe7Oom09P3/4T3V8nO/\n", + "9Hmuzt6tN7myh/6gFtfveMadrk5v4wKUx6JvooQQQgghJqCXKCGEEEKICeglSgghhBBiAnqJEkII\n", + "IYSYwImI5QtIFo+hTsHtohfE59FLq7OmljEjEcbYDO1IIbbkwFYbMZO1EUG8pEVd0C9cnSbt+fUg\n", + "/Tya37YzCtlM9uZThoNLbT9ebDUjqcljrG4zd+7YmWSJxbj5thsj13sZm8qnhC12IXZ4pJ0oY9JU\n", + "enp8mKLMhFhfhDJmGtHPzczarhafZws/EKKbeTl62NYDNJh0zAZebNd1QvkRiOZmZv3a3+/DrL5H\n", + "mrm/Z5CGpCo3TKA+dkv8WHCQw6kdfz/eetZL+c+8/dyx613a9zMyIIE938gxZ+gwTJZmj7IGBHRW\n", + "hw3+wHurIyeYjM/wbWIfR0QQHyDlO9JAdt+vt5A0njKb3YEl3NfnsyWDlRpybZA+kJkOyHOpz595\n", + "2cwsY6o52T27ftg3mLhPn85sFgpgfehnI7jpzjuq5YEc7yf/9BFXdiekis92/PV85MN/6vd3883V\n", + "ciSfF0eX/b3WtdNfhfRNlBBCCCHEBPQSJYQQQggxAb1ECSGEEEJM4EScqLatHYjG6uUZCc3sGu/s\n", + "NFb/Ns3cJh4hCYdNPCI2mzf//Rjq9GS9vn5XjdSb2vUbG2q/IpOwzQbayWZZt0BCSK0OOMwjwv6u\n", + "rojhkCyodMyGSLAe+b08g//A1abjPY3rrOjAEDvmk7DZ3zFglP7GzjblQkFJCCnpi5i8ODYrrkBo\n", + "Zr8h1514IakfPuOymVnJxBWBw+laf3zDmEDTEZ2qIaIWy5kMsK1C7n/mUrXQdur+MNcI6rWkUjPi\n", + "+Mips03x59y5haQOCxjGIuZbsecLPoeZ5xPJPeO2TZ5vmQRbYv9k4ZeFOFFpqJ0oFl7ckE+MWaif\n", + "lYX4o2O+jRjMu4aFnWN4nhX2DMJnAhHDAilroKWBhG0Gcg7KCOeybf1zCre0/6QP2z17/pwri4v6\n", + "M/JTH/+Eq7N7yn9mLqBs/+nLrs6889chjpH2roO+iRJCCCGEmIBeooQQQgghJqCXKCGEEEKICegl\n", + "SgghhBBiAicjlsda1JtBuGYTiLwYiBwZ64SxwCQ9JitikB6ROpngO2qm5+KFxhiWUOLrMGk8BhDg\n", + "ihf33AzYJBSNSfIxQtmIWcjNzBoQpiNJeSOTsVtCeZeG6PltoVieiUQ+kB1iaF6/JcI9YQ3NZCGW\n", + "iSSxtgHr+G03WMnMGeE0hJSF7UETWIgdY7uCQQbkOvStP1cYsro+OvTbJpJ609aC6M6p065OgPBd\n", + "M7MWwja7BQmaBSIR2yOT+eF8sgBJlMjNzLoGpVxfZ0XOwZMXa7n16NDf6+vN2pW5/c/9fTwk34YG\n", + "2kWfZSQN1h0zk9ZpYCQ8h8l63fFZjRZJXyzsmZdxYIBvUxrIczBhSCdpp/lBOP70kXPABn8ARwP5\n", + "uGWDmuBeHljYrhs44+uwQNwGrvuMDHJgA7ToDoBAHnoFHlRzEpo5kPv26MqlavkUkcjbuRfEDy7X\n", + "Yb6zzj83Ahn002/JdR+JvokSQgghhJiAXqKEEEIIISaglyghhBBCiAnoJUoIIYQQYgJh7Oz2n7Md\n", + "MvtbCCGEEOIGpRQ++krfRAkhhBBCTEAvUUIIIYQQE9BLlBBCCCHEBE4kbPPVP3R/tRy3dUBdIAFk\n", + "Nvc/R3Z31MF9w8wHnh2ufJDfgPsjaWYxkTA6CLJ88HVvdXXue8O9rgyy6CyT085m+DaY+ZydFpzl\n", + "vCEzfjfZBwDOoGw+rFyd+9/+Dlf2vT/x8rpNJISNzUxuUEarsLC9jMdDZisnM8TjlmLwQZ7v/L5/\n", + "7Mp++JV139zO/HrbOUnSXEAoaPR1WNZmhEsTN2Rm+Q0JjFvX9ULvN/7af/w6V/Z9D76xXg87p/kg\n", + "TzNzCaqBVGLHh/O4u6BbM+tIaGWBAD6SuWhvv/+Bavnlr/1BVyeQ+FIsYXWoKwrtbEiaYWQJhxBU\n", + "mgZ/PwbzZW97w09Uy6965WtGtTNDG1jM7ED+fs5wj8wbv+bZhb9+C+jr28H31ycPfcjiO97y+mr5\n", + "NT/kr19m4Z5t3RlI9i1dL6HSQkIlC4YQszKyXm78eu+8/x9Vy/fdex9pkyuygs998lnUww1xaeXb\n", + "tOoXrgz77Om5v/9Pk+fboq3r/fADb3B1HnjFD7iy9qBuw+Kyb9Ns35cVCJHt574v9qf9PbPZq+tt\n", + "F+RZPSOfIRDw/ZoH/Wff9dA3UUIIIYQQE9BLlBBCCCHEBPQSJYQQQggxAb1ECSGEEEJM4ETEcgNB\n", + "GzOsyspLZKX3cl3Yr2XFfMYLalT0zMdLzuaEZhv3ykkkwABlhcjfTJj20jaRZLHx5GAiOb4GhN/G\n", + "vGDIKIbHQiRLds4L7o8cCxHn8RREsp4xCRgldTozuWfb1edhvUPkxR0/4/dmD87fgsiLTMZe1/fC\n", + "4ogMaDgg1xS21RUyMIGAM62H7K97S+TvCH2WDSjAfm5mFgIOfGDiNVkPu3V7/M0XiBQcyU3rbhEm\n", + "95pvU9OAzE/6Hc5ab+ZF4dj4axVH9E+aU8xubtiUE6rNLJHjC3ADzohYvkPK8KxvkxfL12vfTCQS\n", + "Bb4hFydv6411DRmo07CLCn2YnBc6qAJOVWiIkE5WQ2Zk5EVPrPimhc+nlgz+wP2Tvp8P/TUecl1v\n", + "Q565K2K7B9bPsA3kGVTSslpOh6dcnf7SaVdWtvW28q7vG7m74tebHdQFC79eKl42J2NbRqNvooQQ\n", + "QgghJqCXKCGEEEKICeglSgghhBBiAnqJEkIIIYSYwImI5QHE4wDpq3njxa906M3EuFdLa3F36eq0\n", + "TDpEi2wg4h4TREfYZ4W8lzpxnkiAQyBSHsi8VD0dUNz1VZrgRegOjq9hceiEAAplIEngiUiyeFaY\n", + "RM7cxQjiZSDCP/PKUXhnrjujtLWIOCy9WL4968uOzkBq8w6T3X3RbFUfT75M0oLJel1f96E2jbuV\n", + "A/TFlgxyYIMx8H5A0fxaIdkhLFJzl1xTuH6jeidJqeaiN6xGtOAY2fmEpOzMBFX2jKhbH1haOL+7\n", + "Kwq7LmRASMLnKdsWkdRnoe7XZ8mgipt3/NY20IcvDr6d6/74/hkjGdBQ/LOrhYdHoqn7RKYPKLyT\n", + "a0X6kEFfoCnjIz4byHgN68gDu23qisuOyOdwread338iDb28rs8BS67vyWsBS71HshtiQNLXqXzu\n", + "ByKUXLchkwEwuG0zM3ws0Rk1XMl1ZtkYib6JEkIIIYSYgF6ihBBCCCEmoJcoIYQQQogJnIgTVWDG\n", + "a5yV24jHlA6Jf7Bfe1LxrA/yijv+N9gWwu4ykXEK+X0+M/kG12MzwkPREEgwGvktPqMTRX5Ub8HL\n", + "6Ei7u37l1xvqsqYcujoUPBjiHrCcO6wVSbYnyfGzGYRRxuTPHYsJLXhN25G/eXd1I/rOeyH9Kb/H\n", + "w7P1ddhf+v4aMADUzPZm9TWeZe8HtEe+DbM59OvNuLBUn9Lnq5QRIZLUISDrOUeI9Be6P2go8zvc\n", + "vjp/7nLvOxV6YUzTYp4UHjILzWSpfQXC/Ybs2xTJM8Fth5zzwJ436C2S8zsjN+BeV/tHtyx8vzvV\n", + "+f2tDuq2r9f+Wbbpjz8+IyGIDXEug6vn9xeIY4r9MxGHh3s9sH0WMEz8HCQR75R9XnRwnWeNPwen\n", + "5nUfOrNLPFTmmF2pt70aiKNE7tGePLsQosJZAL8rkj5le/uuqMl1u8rSO9FlceTL5uDQkQ8V5hYW\n", + "9qE1En0TJYQQQggxgc/4EhVC+OkQwoUQwh9+Wtn5EMK7QwgfCiG8K4Rw9tP+270hhA+HEB4KIXzT\n", + "57PhQgghhBAnyXHfRP2MmX0zlN1jZu8updxtZr92bdlCCC8ys79rZi+6ts5PhkAniRNCCCGE+ILn\n", + "M77klFJ+08yehuJvMbOfvfbvnzWzb7v27281s39eSulLKQ+b2Z+Y2dd87poqhBBCCHHjMEUsv62U\n", + "cuHavy+Y2W3X/n2nmf3Wp9X7uJk9g26hAWF6VjejmS/cKkzixFDOvPLSWpz5bQUncROjmUhyY2Za\n", + "Z6F5TvQkX9AxLRjl1kgM2LbUbZ/3PpxuufXi3iLVoh4KgNejATmzDCx0kQiwqQC9tQwAABowSURB\n", + "VD4vs63vevMDL3XODmpZOG79+WVO7nZWH0/eGRMXZ5ZRMPTdx7at39YaBPR1R6ROJpEOEODYEPFy\n", + "Rg4QhNvA0ksZqa7HpG4mIruZ7NmfX+T2wC7LhO1ChFvMox3zlXbPwlrJmsHdx8yIZYNNIDSXnAQa\n", + "/OrCdcm2R1w/JibTHcL915L7cdn658RNIP2eJSmveeuP+fJRfY9eXnnBf5OI6A2wkNdAQhbbUD/3\n", + "Wf9pyBMVz0Ji4axxTlpWXz8c9GDGA1SRRIKCB9ZfYPPE5bdT0MxzC3+8M5ZeDDfkk37MkW3I4B32\n", + "nECGjgymgbDicJYMYEIZ3MwyiOzDzD9zh13/rByWEJY88+0ml8EPRPoL8Fn93FauntnPtPfpLRNC\n", + "CCGEuIGZ8k3UhRDC7aWUx0IId5jZ49fKP2Fmz/y0enddK3P8xq//2z//97Of8zx7/h3PmtAMIYQQ\n", + "QoiTY8pL1K+Y2Xea2Vuu/f8vf1r5z4cQ3mFXf8b7EjN7L9vAS//Ll9UFZK48IYQQQogbmc/4EhVC\n", + "+Odm9lIzuzmE8KiZvcbMHjSzXwwhfJeZPWxm325mVkr5QAjhF83sA2Y2mNn/Usb8kCqEEEII8QXI\n", + "Z3yJKqX8vev8p5exwlLKm83szcftFGdkjpBYHpdeTOxO7fntGCQBr3yqabv0h9jAjNdMEE1EHsSZ\n", + "5RkNkRUTSI55lOzq04gjESg7EFJng09xnW0vubIWZPoS/TlnYNAxfU0evJjY9ZDMfehF0/nT3uKe\n", + "P7VTb2dDpEeSNhv2IHn87AFpqCdm2H4i14WkEzdQL26YMerlzwbqBXLuCjMhoQ+N/Xtlu67PS0v6\n", + "VMvES9h+ILPPh5bcH9AslvpPfGIfjD8i8JrZ7pkIxk4rZ0I8SyzHGQRow0kRpq2THfbp+MR5GmrO\n", + "ZgzAZZJOvtv6b//PzOu+0BDh/um1F6+f2K/v20sbfx+XePyPHonMyNCReybCc78h96NPNSezJjjh\n", + "/zrJ3JBCzwZesAB/JJNrlViCPzxLrqzYc78+vhm5HzsiS58FAX0zkJlASL/ux4xbmflr1cf6eZPJ\n", + "gJvsJxqxgn2BdJ+BbAvHLyTyLMvkYo0ZNHY9lOMkhBBCCDEBvUQJIYQQQkxAL1FCCCGEEBOYMjrv\n", + "sybD79wZwjdtRvwc4kkF+P3auQdmVjYsZBEOm87ifryjxMBj+7M1j4NmF4KvEonf0cBv/23xwWVN\n", + "8L97Y0DdmLA/Mx+aacRHcF6RmTWber3ugIRtPr10ZTuPnam3ve/r5Dlp+811wGjo/HlhRJhtPh4S\n", + "/+mKX2/Z1ccTSUgnBpWame2C47VY+f21XvWzsoW+wX78J2zWdUBdZu4feSoE8Edi469xO+ZvMjaD\n", + "OhWJXAuO3TRzlAJpJws9deuRfo2rsZBHkofrfTUakHm89MUCVZmfU8DhaaJfb4bPXDMrcN9ePvJ1\n", + "PnXZd+wnV/U9uUq+Ay3I/YDEhoRfEh+wuJNMnrnJBzE2DTi05GI1pA/j/gJ7xjOXCmCuUSH9rIfN\n", + "D4P/7MuH9ba2yX/OnZqTwFHw+pg3Nae34/HSF7nsLsQyd/66oNts5h3hRJwl995g/rHBWl1YIDYL\n", + "sh2JvokSQgghhJiAXqKEEEIIISaglyghhBBCiAnoJUoIIYQQYgInI5bnWiTzIWQkzKwjgij6mg0J\n", + "30JLj22LieUjZtdmFCIdojyIwvjVMtJOCBwL3ICvYBPoDDNvdcYE16A5fpb1qxurz10g4mcciIwN\n", + "YZvNlsjnR16gbPbrsM146bRvU0uE+zmESp4b9/dCswLRu/PhgoWI5THUwuQOCXmNZEb6xbZu1/zQ\n", + "768j56Xb1mXNMO76oSAaIgkqJKcqQgInDagkYYkoe7NQ2RHdmgYxunU6f87zQNqEy6RNVKSFevwZ\n", + "wdoJ67UkAJjJ0ViHBU/SgFEMzfTkwR/zYa77UJ9IsOahH9hxBH1vRsI9lyQY0bWJBE+yYOIEqaOB\n", + "yNGBDJhAoT8G386UvaCNgypYkGdiAxGAhrTTSMgqHt9ABo0cZHwmMMmaBeniZwobQMHCRI8X5xMJ\n", + "28XrMLBzTtoZITw0kbRdOigGP1vJ5xM7ks8ia1PfRAkhhBBCTEEvUUIIIYQQE9BLlBBCCCHEBE7E\n", + "iYro+mAYJPmdv5DfW8uAv92S3z9JoFpIGGLpIbmdY/L+rvN7a72xhv1eTyc8hd/wSbBegj0m4vCw\n", + "36FzW28rjZgg1MwsQBJjYSFz5PdrDEY1MlEz640Zkt9KNzJ0DSeLHfn3QgMTrM7JbLwsdLUBVyx3\n", + "zF8hE19u6r7Qbfz1a9beQ2k24ESQiYsZOzv1ejMSAMhyH/EssHDWhvhVfmJkEg5JHEEXTEh8R4R5\n", + "U4V4aBHvP+aFMQcEyugjgrlicN0zkytHzGDLJobu3TPQ3AUckt/fmihYQ1P3vcON73f7G+/eoZO0\n", + "23mv6Nzi+OtXiL2VyUMhGbSBTr7t24ldKpCAyjb69dC9wefy1SYwGxX2T647BqOambVwPGz+cXTF\n", + "Nsyb2vp2LsAHpqeOFY6ZYJmcF8xmZo99NtE1TgDOvCkW9OyeVDTglKw2bv52ir6JEkIIIYSYgF6i\n", + "hBBCCCEmoJcoIYQQQogJ6CVKCCGEEGICJyOWg0yHIX2BWN2RGZsw63cggXVUIsNZuUkVNjs6K3N1\n", + "qHwOx8dE2uJnt8YQQDaLuwvbZFZw48MaExh+mcx2T0FBfEQIm5mXI1PrRcx+d+XKmrN1smVo/HqF\n", + "9OJ07rDe/3IzopVmcVOfh5aJ0GhLmpltayG1RN/OriFhdNDXWQhpXJPgTgjpjL77cFDMJ1I+C9tE\n", + "QZzNhD6MSKOlAz2I/IliKW0UbofJp+SewXosbBMDgc182G5gA2CobQ7PG9KmRII0XZtYoCIT2aGQ\n", + "SfIDEag3EIi73/v9ZXKtFvP6eHZnvjPuzI4/vkIGpCT2EeXSUv1Jz4EI8HCdW3LO++Tb3uAzlQzU\n", + "GfN9BOsbMZJAzAbr+G1voAkDOXdYx8ysaY6X5NkTnQaFAjxvFCR5snV2/7vMzBH3lZkf9MM+s0sg\n", + "AxhGDOy4HvomSgghhBBiAnqJEkIIIYSYgF6ihBBCCCEmoJcoIYQQQogJnIhYbiCSRxT3iB/KUn6d\n", + "NEbX83ZdADE4sjR0IlqnEeJs6ogYDCJpYXIt8boLzPA9kERmTIlORKhkHnSB9+c8MrEc5c9IjoUl\n", + "UDu3dU5S1E97mXeItRDenfPtpCnRu3Uacdk78pUI7eb4vthl34ZtX7e9kGjehvRFFLQjkXmb5K+p\n", + "QUIx8dg5c7RWiVTNhE03GMO3k8nRES88TQI/vr9kNqgCII68DexY4J6hci0TUrGAybYszRo6Eb8/\n", + "jj8+J9ubWaFCLKTnkyTwnmyrh9EfAxGaZ36MirWxvu7Ljp3zEWIykY7Z8wwvDRtQwNLP3cAAsl4M\n", + "PsWcC9OwHut8rhIr9OcFJe5CEucb3Bgd38MGTNTbJh9XNiPtpAO7cG/N8ZI6HedFymJz/OAI/Ay7\n", + "WoYXmQyOICn/Y8dVMfRNlBBCCCHEBPQSJYQQQggxAb1ECSGEEEJMIPhZ1j/PO2QCghBCCCHEDUop\n", + "PFla30QJIYQQQkxAL1FCCCGEEBPQS5QQQgghxAT0EiWEEEIIMYETCdv87/7hg9XyTlOHte3O6oBF\n", + "M7MzO2tXttip12NhdJnMbo3paWx29D6xELTaK3v96x5wdb77jW90ZZiDmHGabjNLJIwuQcBZIcFh\n", + "PhSQBQe6IptBkCebKfx/f+V9ruy+V76yXo+ktSWyrb6vr+nte2dcnY/96Udc2S0venG1PDyx7+qs\n", + "9w9cWXPzTrVcsg/Re+AND7qyV99XHzOb8Tuxvz3gWuFs4lcL/e0WIRyuST41E0NXr1asF3viPD74\n", + "wBtc2f/01vr6YfCkGZ+kHiZ/t8gC60g/6zD7jmwbg0PNzN2jkaz4wJvr++/+V77K1WGhmREOJkUf\n", + "95ew4aQsLX2fGpb+2VVmEJ5IrlUm3eXHv+unfKEQ4oZC30QJIYQQQkxAL1FCCCGEEBPQS5QQQggh\n", + "xAT0EiWEEEIIMYETEcv3j+rlAhN17869ZbkgU0vPQAglrquticiKk2Kz2cOHRGaNzsfPtD4bvGwa\n", + "QUhPA9lOJGZpW1+enrzzopAaSRvbQtqU6rKGma2E0tZtWCx3XJ2Pfezjruy5L3hetbz/6EVXZ9P6\n", + "GdvP33Z7tfzQb33Q1Tn13FtdWbO3qJb7i35gAqOA4J+z70AFp4M3P4t7JlO/N8VL4xG3lbakUb4N\n", + "GeTkMvJWxpnPA5ntPhPRGgV4mt1LZ1qvaZhwzzYG/bEh7UTC4M9B6NnAkrpVkVTJC3+tQqwfXCGQ\n", + "+5hsC8X1ktkAEWbcCyFudPRNlBBCCCHEBPQSJYQQQggxAb1ECSGEEEJM4EScqNWmdhJ2unp5MfNy\n", + "09zrMtZa7REk4vUU4qYUEBcyCeSjYYkj3jkb4iT58EkSAEhkij5DO0lIJzazkGRN5mBEEEECcX8Y\n", + "HVyIp5/wbtPe+VOu7OxOXfaeh37b1XnRt36jKzt89PFq+dKFx1yd53/LX3NlD3/wQ9XyDrnGnOPr\n", + "xeD7Rsj1eg3pKi3KeGbWpVW1nAcS1kh1tfr6xW7k30NwHgrxejI5vgLrkQxSM6b6QR+OJMQ2sLDN\n", + "hE7U8bRr0s/3vbMX1vNquXSkTWcOfRmEACeWYtsQ7w3KUiQPM36RhRA3OPomSgghhBBiAnqJEkII\n", + "IYSYgF6ihBBCCCEmoJcoIYQQQogJnIhYPq9zEG0HlmdE9CzEWi0BAg6JDE48Vhea2RALmOQpmrO4\n", + "CR0RywsGd1LJ2YvdLei0hYjJKJJHsu2WZQJCWcdOFOEIklKbxczVueXOW1zZR37v/dXy7p03uTq3\n", + "PuMuV/brv/hz1fLz/vMvd3X66Nu+/7FaQD//wue6OozsZGFyzVkRBjgO/no22wO/3tGlug4R/BMJ\n", + "NC1xWS3nOO5Wxp6O/cDMLLEwUTgtTBCfkb43gwTcbvBSddwSsRtEazy/jNmKnIOLe66oXD5XL89Z\n", + "QC2R63fq69ec8W3KJFDVQ8JTR6wlhLjx0DdRQgghhBAT0EuUEEIIIcQE9BIlhBBCCDEBvUQJIYQQ\n", + "QkzgRMTyU3u1WLm7Uy+3wcuZmJhsZtaD/DkQ9zSzFHMnbDNplbxfEmncrUWk3AbE8kjaFLNvQ9P0\n", + "sB0iljewbSaWJyKtD/U5jiPV1nZWjwJY7sxdnace+aRfEdr5rC9/oavyJ+99nyub79Qi8jP+6gtc\n", + "nff8xm+5sttvu71aLs2YzGuzgGndbCwBSfSOIIS3uXd12o0Xy9Ph5Xq59aK+7ez69aBebr18zsB+\n", + "FlnKOEltb6GsI+stBn9eZnArd2sikW/8vYZ+f3Cp/564JdtZL13ZcFDL5pm1accnlrfbui8Ove9T\n", + "qffifIJU+ECeLc3YQH0hxA2FvokSQgghhJiAXqKEEEIIISaglyghhBBCiAmciBN1Zln7IzsYdkdm\n", + "R++JRxRK/Q5I1B8ampnAGyJZm5aI/zRCy3BtMnM6EG1US8IZcVtD8Z5NcrsjEs+IsM1IPB9G09b1\n", + "ji5d8XXIemfvurNafvzRx12dbr1xZc99yZdUyx97+OOuzhzDTM3s/B114OdjT1wgrfIEuDaF/J1R\n", + "CuloGKCYt65GZoGxc3CZdk+5OsPeGb+3pnbTcufdNAa6TMx/Yn0I15sTAbFd+y3NwHeaE28pk5DM\n", + "AEG61h4fYhnIc4N0DZJ1O+4cuI1tfbvjxjttGKCaI7vXFLcpxBci+iZKCCGEEGICeokSQgghhJiA\n", + "XqKEEEIIISaglyghhBBCiAmciFg+B0t1DpZzIhJ5Tl5XjhBiR4M1yWzsKHoHIpE6GdzMAhVQoU3E\n", + "D8U2dOYl2Tb7sriB46PBj/XiEPx5GqK/zBlWDFR29RQI6UQR28xs9/w5V/bkE09Xy13n23TLbbe4\n", + "sk9+/BPV8s7Ora7O2Zv9/vYvXaqWW3IOGAGsY+rbk2MOKAaTcM+MErmZpcXpus7OnqszzHxgZIbr\n", + "nEhYKyNCsCwLZ+3IphZweDRY049ysG4DYbBrf1663kvxGdpVRhxfmvnrknaJ7T7Uoael9YMAbHnk\n", + "24SHN5Bg1A0ZIALXigXbllZ/zwrxhYjuXCGEEEKICeglSgghhBBiAnqJEkIIIYSYgF6ihBBCCCEm\n", + "cCJiuU8IB7GcyK7FWZ1mHUSIZ5JYXIgZjFtiad2ZRZ2PcHe73oulMxDgG5Jm3SWfRj5H2Zy1E8oS\n", + "iVXfRD+zfN/Wl34gAj4Da3Vzv+2jlU8eR3n/9FkvUD9xwaeKL8/VCd4Rk6zN7GjfS8AL2H6M48Tr\n", + "grH35M+MTM4VitCJtLN0C1c2REgeb7x8ngMRmCEFOyR/zhkdXIdIwteZWI4J9w1ZL/gubAEGhIQN\n", + "OS/E68bE8simFQDy0m+onD5wZWle31ex8w3PSy+kpxkkj5P7sRTySB3qk8efNywFXwhxo6NvooQQ\n", + "QgghJqCXKCGEEEKICeglSgghhBBiAifjRGFIJjgYzH9igZgYPlmISxUzCbYDvyLTGdT9tlgbkHki\n", + "+4M2dCzgcCBl0K7ANC0IdRzIsYTogzwDhi62I7sC+EDU5CCpoLOudqfWq5Wr08y8XxUXddnqindc\n", + "ljs+rBHFu3RExBtCgFDOQtwmY2UNrEf6Sgks9BTKGu8/scDPCA5NGenUBLi30HUyM4uk7RFcsdL7\n", + "c5ASCa2F/jKw/bHbDzI5wwhnL839ORjO+H4WUu07pcb3jey7onOi0OU0M4ssERfOS2b9Z6STKIS4\n", + "sdA3UUIIIYQQE9BLlBBCCCHEBPQSJYQQQggxAb1ECSGEEEJM4ETEcidto1nOZHASIulmdichgYGs\n", + "h+53Q4IYifs96o2ThWZiM1mYIfFYrUFRl4X0gSDekVBCd57Mn+IwjA37wzYQCZmEnvZwXpbdrquT\n", + "Nv7c9ataAp4vfGBlIettt7VM344U59ELzlQQJ+cYqrFQ0MS2Bcth8McSiDReIIiVucoUN4jDV6HD\n", + "LCBEkvWWEhtXtsE+OyMDNkgjcKBDGXF8idTpF/58RrgfGmLXJ1KWoQuxgSYl+XOAjQ9k24E884QQ\n", + "Nz76JkoIIYQQYgJ6iRJCCCGEmIBeooQQQgghJqCXKCGEEEKICZyMWI5uKQipJXphk+X5BpBWA1Fi\n", + "M5GqG7BwWzYbO5HNx6Qmz7cb34ZQH1+bfIJ4m31ZA3Z7IOZ8wXNA2sgk5whqMDteRoA2sWTuIXnt\n", + "uF3WSdxp8CnR/eDP3fz0qXq9nijNgz93cV6nmBdmUDNAaM5E+S/sbw/oswNGbptZIXY0iuuRXOOG\n", + "tD1ETMEed/1wkAEbeIEJ22ZmyQ3+YH2RtBNOH7m1rTR+W0OBa0pjzaGN7ClB1ku4v+D7VGZ+OFyb\n", + "RGZWYINi/N+qZGBCHDuwQwhxI6FvooQQQgghJqCXKCGEEEKICeglSgghhBBiAqGwVMnP5w7DSHlD\n", + "CCGEEOIGoBQuReubKCGEEEKICeglSgghhBBiAnqJEkIIIYSYgF6ihBBCCCEmoJcoIYQQQogJ/KWP\n", + "zhNCCCGE+GJA30QJIYQQQkxAL1FCCCGEEBM4kZeoEMI3hxAeCiF8OITwypNowxc7IYRnhhD+XQjh\n", + "j0II7w8hfN+18vMhhHeHED4UQnhXCOHsSbf1i40QQhNCeF8I4V9fW9Y5/zwSQjgbQvilEMIHQwgf\n", + "CCF8rc7555cQwr3Xni1/GEL4+RDCXOf8c0sI4adDCBdCCH/4aWXXPcfXrsmHr322ftPJtPo/Pf7S\n", + "X6JCCI2Z/biZfbOZvcjM/l4I4YV/2e34T4DezL6/lPJiM/trZvbd187zPWb27lLK3Wb2a9eWxeeW\n", + "/9XMPmBmfyYc6px/fvlRM/vVUsoLzewrzOwh0zn//9u7nxCryjiM49+HbCA1BAmsdGKG0EUQ0RCi\n", + "UgjhwiLGVuXCkKLWBZHQLNq2Cl25URNxMSImOq4iaFEQlGIR+GdhOOgUMxOV/VvN4NPiPTLXwQtx\n", + "uOceuD6f1T3vORd+PJd73t+9973nNEbSCPAOMGb7aeABYDfJvNeOUubJTvfMWNJTwOuUOXUncFBS\n", + "fmnqgzZC3gxcsz1tewE4AexqoY6BZnvW9g/V43+AK8B6YBw4Vh12DHi1nQoHk6QNwMvAYeDObQKS\n", + "eUMkrQFesP0pgO1F23+SzJv0F+VD2kpJK4CVwC8k856y/TXwx7LhbhnvAiZtL9ieBq5R5tpoWBtN\n", + "1HrgZsf2TDUWDak+OT4LfAussz1X7ZoD1rVU1qDaD3wA3O4YS+bNGQV+lXRU0kVJhyStIpk3xvbv\n", + "wCfADUrzdMv2FyTzfuiW8eOUufSOzKt90kYTlWsq9JGk1cBnwLu2/+7c53J9i7wePSLpFWDe9vcs\n", + "fQt1l2TecyuAMeCg7THgX5b9jJTMe0vSk8B7wAhl8l4taU/nMcm8ef8j4+TfB200UT8Dwx3bw9zd\n", + "QUePSHqQ0kAdt32mGp6T9Gi1/zFgvq36BtA2YFzSdWASeFHScZJ5k2aAGdvnq+1TlKZqNpk35jng\n", + "G9u/2V4ETgNbSeb90O1csnxe3VCNRcPaaKIuABsljUgaoiyGm2qhjoEmScAR4LLtAx27poC91eO9\n", + "wJnlz416bE/YHrY9Sllo+6XtN0jmjbE9C9yUtKka2gFcAs6RzJtyFdgi6aHqPLOD8keKZN68bueS\n", + "KWC3pCFJo8BG4LsW6rvvtHLFckkvAQco/+o4Yvvjvhcx4CQ9D3wF/MjS17ofUt5YJ4EngGngNdu3\n", + "2qhxkEnaDrxve1zSWpJ5YyQ9Q1nIPwT8BLxJObck84ZI2keZxG8DF4G3gYdJ5j0jaRLYDjxCWf/0\n", + "EXCWLhlLmgDeAhYpyzc+b6Hs+05u+xIRERFRQ64jEREREVFDmqiIiIiIGtJERURERNSQJioiIiKi\n", + "hjRRERERETWkiYqIiIioIU1URERERA1poiIiIiJq+A8y9O8S/Rd3RQAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# the parameters are a list of [weights, biases]\n", + "filters = net.params['conv1'][0].data\n", + "vis_square(filters.transpose(0, 2, 3, 1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first layer output, `conv1` (rectified responses of the filters above, first 36 only)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvVusXed5HTrmuu/L2jdubpISSVEUTd0S3a0okpKYseoo\n", + "TRs7TWvFaRPXSYAA7UFeCuPkoUBjFMhL0gYI0IeDUyNoXMM5QgPLRhJfEje2oxhSoosp2TIlUVdS\n", + "JCVyk/u+122vdR6Wx7fH/Oe35lp7ywrd4B8vm1xrrjn/+/z/8X3f+JJer4eIiIiIiIiIiIido3C1\n", + "CxARERERERER8X8q4kYqIiIiIiIiImKXiBupiIiIiIiIiIhdIm6kIiIiIiIiIiJ2ibiRioiIiIiI\n", + "iIjYJeJGKiIiIiIiIiJil3hPNlJJkjycJMmpJEleTpLk/34vnhERERERERERcbWR/KB1pJIkKQJ4\n", + "EcBDAN4C8PcAPtbr9b73A31QRERERERERMRVxnvBSN0L4HSv13u91+u1AfwJgA+/B8+JiIiIiIiI\n", + "iLiqeC82UtcCOCP/P/v9zyIiIiIiIiIi/lGh9B7cc6itMEmSmJcmIiIiIiIi4v8Y9Hq9xPv8vdhI\n", + "vQXgkPz/EPqs1K5Rr9exvr4OAOh2u/b52NgYAKBYLAIA2u02ms3mju599OhRAMCZM2fQbrcBAEmS\n", + "2F99HlEoFDJlIcrlsl3jlSX8bZIk8PzUKpVK6rpOp5P7XKJYLGJra8v+z3uzTh4KhULm3nnP4HMA\n", + "pJ5FjI+P278bjcZI9xuGUik9VDudTuaayclJzM/PA+j3J9CvG/uVKBaL1i5armKxiG63m+oPPlef\n", + "V61WU7/VPuSzer2etSnbflAb8H58VrPZxN69ewFsj8+lpSVcvnwZwHabNhoNtFotAOl+YN/MzMwA\n", + "AB566CG77rHHHrN2mZubAwD7bnV11erhjUned2JiAvV6HQDw1ltvZa7j2G21Wm4bXHvttan7vfHG\n", + "G5l77N+/H9dddx0A4NSpUwCA5eXlzHUTExN2vxdffDF3nPO7iYkJrK2tAQCmpqYA9Oft4uJi6vof\n", + "+7Efs7H8jW98w8pP3HrrrQCAy5cv48KFCwDS7cbn/emf/ikA4Pd///fxrW99K1N+rm1EuVzOjFkP\n", + "Y2Nj2NzcBADcc889AICbbroJX/rSlwAgUx/Fj/zIj1j5v/3tbwPot1+IRx55xOZS+BdIry8cvxyL\n", + "4+PjtgZ683V6ehoAsHfvXpw+fTr1XZIkOHz4MIDtNVWv0fVHxxtxww03AACuXLkCoD92dI6wvGxn\n", + "jtPp6Wn7DTEzM4P9+/cD6M8RwB/32h+s2+bmZqpc+nzeGwD27NmTaQPFnj17rD/z1vRCoWCfe2uc\n", + "Pj/PP5ptqm3G+/xD5OctlUrumAmRJIn1HctaqVQy63He74HhdfpP/+k/4VOf+tTg8g4t6c7xFID3\n", + "JUlyBMA5AI8A+Nigi3XTAvQnHxc5YnV11RprcnISALC2tmaDlt/VajVb+DY2NjLPIHq9nk36V199\n", + "FUB/4LMxV1ZW7Drvt3mbAnYmJ7qiVqvZAOUzyuWyvZR04QsnX6FQsPJxYfEGSbhYeGB7sYyDNn15\n", + "0OdwQ6sbDNYvD9PT09bX3oZMX8KcVF6dWI8kSfD6668PLCevG9SHvV4vNTY6nY47mXWzpH+9+4Xf\n", + "exOX9eR9O52OvVy5aVpfX7dFPJwfikKhYJsDjqutrS2cP38+Uyb2FzFss6uLq/ci+dCHPgQAtql4\n", + "7rnnrM0PHDiQeW74wgK2N5OTk5NWT28DRezbtw8LCwu55SZmZ2cBwNYNYHseHj9+PLPxePLJJ/Eb\n", + "v/EbAICDBw8CAD7zmc/Y95cuXQIAvP322+7z2NZsg1/7tV/LbKT2799vbcm+rtVquS8Abq65dgHA\n", + "xYsXAQD/7t/9O3zve/24HtZHX/BEq9WyNTLvWW+88Yb9Nm+TCiAzR9fX121sc1PUarVsfLBf9+7d\n", + "ix/5kR8BAHznO98B0G87brC5KZqbm7PDhK6zHO98NwDAK6+8AgA4ceIEgH5f6juBcz08EDYaDdsE\n", + "sXxLS0uZw4mHmZkZayv+9vjx4zh7ts8jhM8HtufA9PQ0JiYmrN1CeJ958OZwsVjM1FPXVO86fjds\n", + "EzY5OYmpqSmsra1l1qU8EmLQdRw7WjbvMEv0er3Mu0PfnR75oGuwt3Z7a/Tv/M7v/MNupHq9XidJ\n", + "kv8LwFcAFAF8OkbsRURERERERPxjxHvBSKHX630JwJdGvDb1d21tzU4WZF6uXLliO0rueguFQsYM\n", + "tbGxYbtX3YGHJ8NqtWqnA54ClpeX7WTj/ZbQU5G3c+W/a7WanTCJRqNhn+npgydHMgidTsdONixL\n", + "sVi0k+MotP8geO0Wfg/0TwFh/byd/szMjLVHeOodhuXlZfeUy35XCpunDu8EwT73KHQtq8d6KUYx\n", + "a5ZKJfuez+12u0PvDfT7nIwpy7q5uWnl85gSMg0bGxuZE5/ej+zI7OysMUc8Pa+vr9upWOvKU7OW\n", + "neNyz549APrsEsvKcipTy2fdeeedxhw899xzqecA2yY0YHsO6zhmn5O56nQ6VicPXCMOHjw4stm4\n", + "VqsBABYWFsxcSCwtLbm/IdtExkRNLGQIh+E//+f/DAD4r//1vxpDQlPh9PS0sSfEDTfcgNdeew1A\n", + "mo1j+b1TPU/rY2NjOHSo71nx9NNPA+iPK5qKOZ4uXbpkfeitqcRrr72WYkrz4J3++e8333wTQN9c\n", + "ynnDMXn69Gl84hOfALDNSCnYPuPj49YGXEe3traM1eE45VgCgL/+678G0GfEWAZC60Pz8FtvvWUM\n", + "u4J9fttttwHor0mhKW5lZcXM5VwTz507Z2VWRopQBsjrV6JcLmfeJ6Nia2vL2pzP6HQ69pm6TYTP\n", + "mJyctHblX12DyUSNjY1ZXXR9DMfMsLnqre96j7CNht1vkOUhhFo/duOGEpXNIyIiIiIiIiJ2ifeE\n", + "kXq3CE/eR48etdMfT1S6i1YmItwBqz2XJ29lrnhKKBaLxgLwlK02VP69fPmynfTJILRarcx1S0tL\n", + "dsrhM9QnxLN5eydclnlra8t2zWQNNjY2Ug7PQP/UlufTMGy3zWd47I6yMfzLkxe/53f83julqs07\n", + "ZAt7vZ7LuLEu/K1ek+ffNT4+bs/gdXqq8RzzQwd0vW5ra8t8fHZ6QtRAALZvkiTmyMqTtLIlLKs6\n", + "8GvZOR+I1dVVGx+sz+rqqo1Bsp6rq6vueCNzxJP1xYsX7UTNv51Ox3yGyELNz88bg0QfGJYRgPnt\n", + "zM3NZcpcrVZtznHuN5tNd44cO3YMwDbbVq/XXRbDA+ff1NSU9SHXix/90R/FN7/5TQDpsUXfMpZr\n", + "ZWXF+ivPV03x1FNPAej76fz0T/80gG3/Jm+O3nrrrdbWTzzxhH3O8eY5Jd90000AgM9//vPuuCTD\n", + "yP5/9dVXbe6SgTl06JCVh2vhIP+vEOVyOePL4s3jJ5980v59++23A+izNgyCYP96dVRG58iRIwCA\n", + "119/PeXfBPTX1o9+9KMAgEcffRSAP3+OHTtmz6Gf2tjYmI1FtkutVrOxQ4br/vvvt+eRWVtfX8dD\n", + "Dz0EAPjCF74AIG1h8Xx9WPalpSXrG65TugYPW7dDX+PwN94ayXJ4/kghW6koFAo2f5RZHwWjBlIo\n", + "+KxKpZJhxXq9npXf8zsN/2qZFe86GOpd/fpdYljkAKFOleoIGDrLetDoKaU12fgeneq9UNWJnWYA\n", + "Drr9+/fboqQDlpPTu46dqYODKBQKNpn5Il9fX8+YN9V8yDIPckpUM1046XTDmEffe98Vi8VM1Ey3\n", + "27VNgTdAvfvkOZt3u91db156vV5mY6n0rQYFqHmEzw/7Zmtryy0D2yCPnm+1WvZbvS9fmlxIi8Wi\n", + "fbZv3z4AvsO1V45Wq2W/Yd0uXLhgY1bNHh44frgp2tzctOg5ls8zgz/99NO5UWLsX298jo2NpSIH\n", + "AX+DwTYG+i9foB9BNurLnuPgpZdeyozLhx9+2MqmmxfWmRvBdrttddnpC+Gxxx7Dv/k3/wYAcN99\n", + "9wEAXn755cx1TzzxhK1z3FgsLS1lTJ2VSsXWpX/yT/4JAOCLX/yi28bcnNPsB2Tb+MKFC1Yuzrev\n", + "fvWrbl24kSG2trbsfhwbly9fzpjVdc06efKkfcbNKdd6XVfYb7pWMnJwenraPThyA6X1D10Vrly5\n", + "YqY6mqM3NzftfjfeeCOA/hjgZpjQoIG77roLAPDMM89Y5CMPGK+88kpmM1IsFu37l156CUB/TWeb\n", + "33HHHQD60ZSs7zBncy+wxTvE5kVbD9rkeBHdo2ycCoVC5nmjzhmNJNcNaLghTJIkNyBs1AAarvmt\n", + "VsveA6O4a1h5R74yIiIiIiIiIiIihavKSClbNCq1pifzUUL2lX3wQiCHORZzd0paWU9F/O78+fN2\n", + "MuQJttvt2m9I7V64cCGzy26328Y+KKMTsg379u0zVoE75U6nY6Hf/M5zCAd8B7udhLvzL+/JHbye\n", + "4LRuHt3K+2lobUh3V6tVO8UolZ/HRPG55XI5Ez67ublpJz2Ol2GnorzTVrVatXZju0xNTVn58kLE\n", + "t7a23DbnaZOn7K2tLfuMJoVQ1mEQtM/ZfhcvXsxowHgh8cA2I6RtRFOdmnHJbLANzp49O5LkxcLC\n", + "gjn9skwzMzOuSTl0kK9UKlaWQWa1vFBpwusDzxEY2J7PygiwbXYqGfK3f/u3+MhHPgIA+PCH+1mz\n", + "vJBqdT7n/D527FiGkWq1WiaFwL/Hjx/H3//93wOAG06vshUcC9dccw2Afj9zrSJDNAg0FRLdbjdj\n", + "dpmcnMwwjPv27cvohjUaDevPQeH7rK+ur0DfpMz2Ck1jAPDP/tk/AwD82Z/9mY1ZMpiLi4umpUXo\n", + "+k52aWFhwcyQZNHUeV3nJhnG66+/3soeWji2traMiVLndDK6HF8f+tCH8PjjjwNISzCMCm3L0Cqj\n", + "70XVXGI/6Xs57BN1q1EmLGTFvN+q3piuleH7Qn+bN5eHOYfrs1T6Aej3Q+hIv1tERioiIiIiIiIi\n", + "Ype46s7m3IEOE84KWYVQwZvXh8yLCizyfu12231uKOY5OTmZy16oOGh4oq1UKnZvDa3W3TDLF7IZ\n", + "Kr7Jv4P8QN555x17HtA/hbKNBu3Uwzby1HBrtZqdgHiqLBQK1kZeSGqeDIEKLCo8X7WwLaenp42J\n", + "ZJlUfI/l8xgCb5yMCm88ec8YFDofwhMCrVardk+P0eHJdVSUSiUbEzztKis3TFSR7Kj6UpG50rpz\n", + "HKgzfB4jpXIZIevV7XYzAoCDGEiWi0zNxYsXXb+QneI73/mOK7dAVozlq1QqO2aiFC+88AIA4Gd+\n", + "5mcA9JkfT1GcYF/y7yCotAOZKG/+e5/R3+zGG29MBSMAfaZLfVSJPGFKzoepqSm7jp+tr69nBC/n\n", + "5+etTfX5/IxzfWVlJRUwBPTXhvAZOqc0cINjin1Zr9fx/PPPA9j2+bpy5Qruv/9+AMDXv/51AP22\n", + "D8ejSil4gTRkTnXtoc/VSy+9lApeCsF59Gd/9mfmn7ixsbFj1kTX9FF9hsLArPA+vMcoTNMg60j4\n", + "TlVfKn5Xq9UyzvCVSiVlHRlUH5Xx8Ngslk8ZPn5WLpdzxUgH4YdmI0VoI2iaFE4M3VBplBjvFTq3\n", + "FQoFaxguwjrRNLosfIF3Oh1TQ+YkVUdgLgT79u2zCZGn9VQqlUZSu9Z6EKoF4mkqKUU5qrnUm2iE\n", + "Z+ro9Xq55rG8VAiDTDGqTcR7hH3oaemoUyDLruk2VNNktykNvA08sD0GPf2nPPpdy8J2WVhYsPuF\n", + "Gjk7gaqYsww0ZRSLRSs/28fr3+PHj2dUwk+fPp1y9gWAD37wg1Z3mjKGOZ/qBpzl43y8ePFiKr0D\n", + "4I+XtbU1+57mqBBh+47a92+++aZFItLE2mw2bRPB9k2SZGTndg+f/exnAWw7mz/00EMWxciX/sTE\n", + "hL1Ah0Ukcs7RLHTttdeaZtSokVS8rtPp2KaFG0gv2g1IO/6H4HxcWlqyTRPb79KlS7Zp4bxeW1uz\n", + "fvLMRhpZzX9z/J08eRJ33nkngO3oyG63a+VjVN6RI0cy5vHZ2VnbEN18880A+mY6boIYCXnq1Knc\n", + "CE19N3CeeUEd3DA/+OCDZrLLQ6lUsrE47ADkwXvH6LrobYa8+RJ+NkibiX2igTdeijBNowb016zw\n", + "fTIokGYUdLvdjIlS33H6ng0P/6OkpfEQTXsREREREREREbvEVWekCG8n7FHo/MxTTS0UChkzju5O\n", + "lckJWQ/dMSszwNMJPyuVSvZvntYWFxfdUM0QehrPU0/XcnkOedzR6zMG6YfkIe+0rsygKo2PEh6r\n", + "yGMGarVaRuMJyA879cKAVZWY8Ji/vL7RPFOagzB8npoKtcz8TZhcWTFICoJtmsdEVavVVJABQQaB\n", + "rNbm5qblNWOI9VtvvWVmK20PMlZkBprNpjGwrEej0TCmhure8/PzpqfD++blwwO2Gcxz587Z6d47\n", + "YQ4LBKDZim0/yml5FKytrRnLRUbn7Nmz1v9kVnbDDChY5z/4gz8AAHzgAx+wfr3lllsAAO9///uN\n", + "4c5jpAqFgrFjf/d3fwegL4PA+ZCH/fv3p/S++CyaHMmyeFpje/bsyWiBKbSNaKa6++67AfRZo5AZ\n", + "0nGvDvKhk7beV7/jGCTrNTMzk0paDvSTOofPVfOcyhnQjKoJiDm+1arhZRrg3OT8mZqaypi8G42G\n", + "q5cVrk9JkqTm9ajQ9QtIB7nkMS67Ye7ZX8pQsr5bW1tmdmX7DXqHEBrE5Mn0hO8az6yvDv76nvUY\n", + "uN0yUCEiIxURERERERERsUv80DBSRK/Xyzg8euh0OrZ7VX8nj3XwwjL5W+52NzY2cp/LU1Oj0XBP\n", + "3zypKJviMTX8ntd74pBadlX8zhM1260fEMF2U2dDnobUKdhDHhOl34XCnc1mM1NudUpniHWn03Hb\n", + "nCHaykR54bteRvFQiqFaraaU6kNwbLRaLZcpZT1HdURmvRcXF3NPRXzu5OSk6wzN3+qYZbtx7Gj7\n", + "sF3q9bqNaZ4gV1ZWjGkg65okifnrkP147rnnLBfcqCc6tkun08llHPPGsfpwaJaA8Jph9/Hwzjvv\n", + "2Oma/ka1Wg3z8/NWbn42Cm699VZjPLz1hP5Qr732mrUN16SZmZmR2nVhYcFYJQqG3nPPPcYCsOze\n", + "uBnUPiwzxwSV3RXFYjEjYeDl6dNncFzdc889GXFLBZm4gwcPmp8W71uv1zMMca/Xy+Q+vPXWW229\n", + "YD3+5m/+JpPDs9PpuOOFZQhlaVj3QVhZWTHmknNrbGwsI0Px1FNP4Vd/9VcBbLfv+vp6ps+HzZVB\n", + "CB2y3y3CNlKJCNap0WhknlcsFjNCwPruIvtdLpdTAsBE6DfX6XQy78okSTLvJx2Hur6H2Qw8i4LK\n", + "OITZNPKQvNsX8G6QJEnuQ/PSgXgIX9BAvoKrF8nlUbBe4uGxsbFMmo9B4ET0zFeKYRGLQH8RGcUE\n", + "FCIcFMPwbqIXlFoNtZb03lQ+9pzIVXVewe/ZBrrRG7Z5CVP6dLvdkUyUGj3pbQxVk4VQ8/G7NQMB\n", + "2yalUqmUqxxOTExM4N577wWwPT7/9m//1r6nM/ni4uK7Wmhp1vacSfOgCWE9c0UYOTsKtG84Jnbz\n", + "MlGzAvGzP/uzALZNbM1m09VsC/HII4+YnpMX9ZaHWq2W0pQD/AwIR44csQ0KX8yLi4vWdtyIfPvb\n", + "3848Y2Jiwl7wGhHITTPnVGj+A3yduCRJRgpyueuuu2wTzo1Pp9PJRPKVSiX7TJO6sz/ZR3fffXdm\n", + "Y1av161uWn4eMDQNEZ+hL9dw/RkUccwE1DRzA9nN69TUlPWH3pfPpd6U10eDXB92uqZ77ztd2xRe\n", + "4JMHzhV+32g07NCnbakJjFkWL/lx6FZRLBYz60OpVMoklG42m+48zHv/7wZcz3u9ntvo0bQXERER\n", + "EREREbFL/NCZ9oDsbniYFpCay5SxANKSA3pK5YmAu96VlZWMac9jLQaFuqtiNNCnPD118jB0Wuum\n", + "91P5Bi2TXqf5rfSUMopqe4jQJNZqtdxEmCHdWigUrJ08ClbB7/XUSabJO/Fpe7AtlXHwmKgwx9/s\n", + "7GwuI+jl3yM8hpB11s9+UKceD15iUQ8czzMzM1ZfzxzK07HKJOym/JwHO2W01WFUT595iW4JNe0p\n", + "+6GOrqGcxk5yinkMGRk8MjV/93d/N1KdZ2Zmch2EPRZdvwvXDu+6c+fOWV62X/mVXwEA/PN//s+N\n", + "weF3HtbX1zOne2DbtKfzXPX3gMFj0VPADq/97ne/a8ELaqbTPI58Bp3+1XQX9q/qyREzMzOmjcXA\n", + "i3Pnztl96NT/4osvZuaIZlbgepEkSSpJMkGml1IWTzzxhDFRqn1FBl4tHhwblA/xxmSr1Uqts7vV\n", + "SNOMFMP0pEadz+HYLhQKGRO25owNAweA9PvCY5C9d5tnJg/fU91uN3dN88yMHkJ3lzxERioiIiIi\n", + "IiIiYpf4oWSkCJ5mPAc/PZ0qIxX65uiJSGUDwnDWsbEx2+3qjpUOcWRMNIzS2/XqKSvMb/T222+7\n", + "J4MwQ7pC/XU8BiRkiNT5blTHWIXu/vN24p70wjCfsVC9dmtrK5eJUlYu9D3Q8rHu4+PjdpLnSejy\n", + "5cuZ05eOp7wTWrlctrGgPjteGK0XKLBb6MkzFGH1yhj+hm2kbcs+IgsxPj5u/kh0eN3a2hqp/KNm\n", + "FQCyIqPNZtP8V7zwbK8fWOZyuZxRTy4Wi66Io34flrVUKtn48OQ0FHTUpy/LyZMnc4NgiJMnT5qy\n", + "vOewrcEOYZ0HKcSrvxzQZ2r4DKpma32G+ZlxvtKHsNlsZpiGTqdjZR3VJ1GDO8K53Gw2za+L9bl4\n", + "8aKxRfv27QPQXyvpkK/K5aGA4ne+8x0cP34cwHYWgDNnzti6TWZK2THOi1qtlpEy6fV6KSFooM+E\n", + "eexdmJPv2LFjJmdAqZAnnngisya1Wi37rfrRegriRMi87hSjWCe8Oexl2QCyrM4gFf3wnaAWE11r\n", + "Qn/iJEkyrOwgBilP5NoTINX75Al3qqL6MPxQb6QILxqv1+tlOnOYEzavUxrV6xw1VTE6SE1G6jgH\n", + "+AuL5xwKZDdXnU7H7u1J6nsvGI1YyDP97OSlPorjoT5bdTy8lxfB68bGxjIvrUEvX/5GowZDrRh9\n", + "mbGe3gvIcxQdtinROnJM6UbFi04ata3zzGkcV9VqNWPCGmQm4ljlON3Y2EilwAD6myaWmWaGer2e\n", + "2pSG5aNjrur0EN6iuX//fnfDwD5kO6qG2zBqnWVQDbdw3tZqtVTfePprYd2GJTpV0FGcppqpqamR\n", + "NlJPPPFEJiGugv05NTVlG0uNrqTGFx3BNcKV7bK4uGgveJZpz549dh86xc/MzGTSGGmUaqg7FILr\n", + "0iCV8xA6p7125jqgaYM0vQuQzlKg44RloHnw1VdfddPVhFGdxWLR5gPNl2NjYym9NCA9xnh4O3/+\n", + "vLWBt/5wfdF6c0OlQUyqjh+mhdI5zxf35uZm6p2wm4wHo0A3E6FbyKA1mm3E8acJgBXheqfvC90g\n", + "e3VjX3NdXl1dzZ233hrtZQFRhGRMkiSZjfQoiurRtBcRERERERERsUv80DBSnkOzMiKeUqmeaAA/\n", + "OfDExIT91jvhEN5nyjLo96o8C6TpT5ZvUM67kLlIksR2vHp9qJexG+fgQSyJ55w3qv5OWE/9N8uv\n", + "Ya88Tayvr2fMPNoupOKr1aqFLCvTF568PWmKvXv3ZhSX19fX7ZSrYbdhWypLMYwpCeu9tbWVcXL3\n", + "UKvVMqZCdbjXBM7sD57KKpWKm+ONbIbqoKj2FD9jW5Gt8E6AGl5Mk5EX/l6r1TIM2fT0tMtIsS11\n", + "bOed8NgWY2NjqfyBQP/0Pkg/igjV/3WucJ1YWVmxcoVh9yE4LpXNHhWqnA2kWWqWa2lpKXPPiYkJ\n", + "a3+O3dOnT7tmFCpks5+0X6iHdPjw4QwjpYzkqON9N87OeY7ALNOBAwesXfjZddddZ+s1v0uSxL6n\n", + "av91112XUgcPn8v+GxsbSzF+QH+shGNxY2PDWCo1GfO5NKG++OKLGWZVTalsWzrMA9trl2ZR0ByT\n", + "YT7Zzc1NYx8bjYZrXvxBIC8wYxDYvjreuBbR+f7ChQuppNH8HX/LNp2cnLS+ViY+NE3X6/WMXp++\n", + "4wblAORzw3dbpVLJ9KGadkPLUx4iIxURERERERERsUv80DBShObL82ztujtURXMg7S/BHaZmjNfT\n", + "Z3giKJfL9m/uqDX/kpYvZC5UOE1P4KF6tj6P8Bzk9BmeKrpeH568C4WCMRE8zYTwnPNGdTLMU49V\n", + "hDt9PXERBw4cMMbllVdeATDYQT5kQBqNhrUX21nZKLIZ9XrdHE4VXj/ksXHq9M0To+dboAgZyamp\n", + "qYxfnX7GE1qlUrF+5d96vW4nNJ5sDx8+bCdeMjVbW1s4cOAAgGzOMMBnoqgQXygUMj4jIZPB6+hr\n", + "xbbwoCHbesr2To7qBwWk/eJ4/SginWF4vILshAqbhrnAQrBfjx49CgB49tln7Tv1VfIQ+lL90i/9\n", + "Ev74j/84c13Iot5444347ne/C2C7/9WPSFlC5sajYKjnO+ixaMOc7BVsN64rXoCIQp3S1UcS8H39\n", + "lpaWTGaCdXvjjTcybKG2wdNPPw0AOH78uPUh+1yVsjnPb7rpppQfIdBvH/7m9ttvB9APEmC7kcFS\n", + "9ltZ4TBIaO/evRnWSxlHDbLhnGN9q9Wq9Z2npL2+vj6yjxoxqpVB17FBAtYsNxHeU31gv/a1rwHo\n", + "+7GF1+k6y3oq08S+8daIUXwTB8ETSG632y47Pmx8e7jqGykvUiEvzQs7c2xszCZlnuN4oVCwxuJf\n", + "L5JncnLSJjM3UAsLCynVX95PTQTAYCdATUUQ1tejC0OToULNArpQhZ/1ej1bMIaZQfIwzBlXkzSH\n", + "g7FarWY2Te12OzMhz58/b06jSpl7oPMtf3vp0iVrJ32WOibqX4UmtVTlXS8JdhjV0el0rL+HmVpD\n", + "E8HU1JSVlb8dHx+3zzh+5+bm7DccY+vr65m61Ot1e8nwBaNOujTtANuOs7y+3W7bBvT9738/gH5/\n", + "cCF74YWtMzCAAAAgAElEQVQXMvVhG2xsbFh0FTdAYUJYIK1pxesvXLhgdacpYGtrK6P/pg78fAl7\n", + "8/a6665LLdYcJ2EKE8BPVzTMXELVbI7TxcVF20CFytsKnQNst49//OPuRorgZu1jH/sYPvnJTwLY\n", + "Htuql8SFfmZmxkx7n/70p61MYXBAuVy2hMx6qBglCq9SqVgS5DyT7Pz8vD3XW9uGqdizvz7xiU8A\n", + "AP7oj/4os7nVTT3b46WXXrLDBDek7Ctg+5Dwta99zRT/meBZwY3or/7qr1ofcbzMzMzYhkfLxPcF\n", + "N0+DNME4H3Vd5/24SV1eXs5srsrlsvX1DTfcYIfNUTGqJpTngqIBN6OY/BqNRkYv6+zZs27S4nDc\n", + "eS4BGgmt6yfXQI2yHLWeO9W842E8mvYiIiIiIiIiIt5DXDVGijSt51genkQ3NzczzJXm9uFpxzMx\n", + "dbtdl1oluNu9cuWK7XLvv/9+AGnTnub/40lfWSBv1877qUZGaI7UUwBZg8XFxcyuvdVqZaj1ubk5\n", + "K4uq8A5zoM2D5/RPlMvllPI5/2p+Pi2LQh282U8zMzMpDSPAZx00+eWdd94JoH+y5v3ILiizEf5e\n", + "n+H1lTd2VFPE+82wkxq/Z7/VajU7rbGNdGxzLKqyNft3YWEho6V17tw5axfOlampKWNRlZH0WM6H\n", + "H34YAFInes+Ux/a97bbbAPRZGpaBZfJYWU0OTpZAmWSO8bNnz1q/0SwJZPtENZdUW0oZGLIOzDOn\n", + "faTzgePYM5dQ+VpZOeZTazabVsY8U4POAZb51KlTufnofv3Xfx0A8MADD2S+88wN11xzjbEdZJrG\n", + "xsYyz1haWjJdI7bB9ddfbwwOzVVeAEe73bZ65uV2u3LlSoZR4T2B9PjgZ14b/OVf/iWAvtk6dNZX\n", + "sD0mJiaMEdSsEiwrGe477rjDVM7JSOn6dtNNNwEAPve5z9lnOg489jlkUhYXFzNrtNaRzzt06BDO\n", + "nDkDIG1NYd94qvdnzpwx9tGDvh818CQsg16f52Q+bG0LE9rr2qbgeqLvCLJUaiYl68n1TtdyrgOa\n", + "pWRU+RIt5yjSCXrNTkyJkZGKiIiIiIiIiNglrhojtbS0lDqdcqepvgUqWhf6QwHIKJF7fi76G+6K\n", + "q9VqhmmoVCrmH0ImSv2SNOzfy7sUfqbMiuZ64wnYO8HryZrPVTaNpxzusi9fvpxhrnq9np1sPIVs\n", + "lVbw8sflnUQGhUmHubg8FAqFDFPlsR+qVM3r9+/fb34I6uybl59JRU5HsfEnSeK2pZaL140qvukF\n", + "TXAcsw82Nzct1J1/JycnbSzydDo3N2fty3Hi+cD1ej37rQr8sa1ZptnZWTutM3x8aWnJdcz/F//i\n", + "XwDYbtOnnnrK+oh+Tgqeyvft22f15Xhvt9v2DDITepLlOFxZWck4jlcqlUwAR3hqZHlYBmWhNJCB\n", + "5dF2JqPhKRnrSZWMn+f8nueQ/e///b/PqHArWL7QYRkA7rrrLjzzzDOpz1ZWVqzvVB6EzAvXorNn\n", + "z1oADXMGXnfddRkGod1uu8LH9F8i4+SxxqqKr/dgO5NNOX36tH3msYFklzY3N20+sl08hl2d5rlm\n", + "bm5u4hd+4RcAAJ///OcBAN/+9retfHxutVq1OUTn/gcffBCPP/44AFjo/pEjR4xl03qHDMf4+HhK\n", + "0ZxlUV8wPjcU9tR3ocfstVqtXIZO15hR1ju9Xv1dw3t4efqArNVB5wLn4B133GG5BNl3rVYrxYAC\n", + "/bmojv1AfyyGVqhBWTBUHJr18fKrsh9YN2WpdpKX1sNVdTbf3NzMTNxms5kxxemE1+/CCL1CoeBS\n", + "ySEGfRcmU221Whnp+vX1dZu86gzHRUtfxuGGoFgs2oDjS3NzczPjiKmbSX2Bc6Hgd56jN68F/KS7\n", + "HtUM7DxxrWp35Q1C1fPiosGJ1ul0rI1oXvKclpVC1xcntWTUCZN1ymsXrbcmpgzHRblcHin9zaAI\n", + "R0JNmmFbVavVjLbUpUuXbOPD+62srOSaajl2l5eX3Q1qiG63m3Hs5+KuOHr0qI3P559/3j7nhoFm\n", + "ZC+aVdM8cPO0sbFh9/MckPliW1lZsQ0N/+r91OFfN/B0Gta+ZPt79ePLct++ffYC89qPG5VarZaJ\n", + "slNwHu3ZsyeVgJfgxseL+Pvd3/1dAMBP/MRPZO7rbe4ajYZFr3FNWFpaMjOVziW2P++zsbGR2cgM\n", + "WwM02bgXrRmae/VgyDl633332SZDX76cAxwTs7OzNhboxKyuDDQV04QLbPfR2toannvuOQBpk00Y\n", + "tTc9PZ3Z+D7++OO4++67AWxHBhYKhZTyOZDuUzqMX7lyxYJmWMewnkB/DNBMzj7Sdxw3UKqKrvXb\n", + "KXSz4Y0jdR/xoAE5gJ92TbWx+H5kUucQXFP5br3uuutcdwTP7Sdcw/PSqoXwDj6hudqLLveiKENE\n", + "015ERERERERExC6R7DQk8Afy0CTpkR7O07rI0x5RM54654XyAoPMMGEeH1XA5o46PBEAfTaFJ2BV\n", + "3A0dBAdpcoQhooPMkSGq1arVzWPUBuXFy5NUGBa+zxNDeNII4Z1UwvIkSWKnP03i6d2TJ1o+d3Fx\n", + "0U4ZdEocxNCwD1kWr261Wi3zfalUyrBPyrJovdQpHEi3Cz9TRpKsjTrNaz4vPlcdLfV5QJ8BChlJ\n", + "YHv8jpo4mvIAx44dM4pdnarZ53S0PX/+vBueTPMR+yo0O7G+O2U6OecLhcKOtI6A/lgjq6SOrOwH\n", + "SjB4prNKpWJ14m+V/STrMDs7a/n38nDbbbeZWcNbvz760Y8CAB599NHMd7Ozs+Y0TzcDz/H18OHD\n", + "ls+Pc+GJJ56wenIuvP766+Ygz/Fcr9dtftHxeZBOVzi/C4WCMchkT0qlUkqTj9eH6/rk5KS1c57E\n", + "xqFDhzISFvV6PbP2as5AQiVA1KRIpo7WgG9961v2mSpwh1aNYrFoc1glRYgPfehDAICvfvWr9lme\n", + "CRdAhm2tVqvWvuzLPXv2WJ9oHb3sEu/GNMX7aBny8sRqrtq8546NjZnlQusxSu66YdD2Y5mVCR9V\n", + "rT3PMV/ZTLJhvV7PjbiIjFRERERERERExC5x1XykyEaF+Zu4+wO2d+HeyVbZD0+4U9VTPSdI7/QV\n", + "MkMrKyvmy8Dr9ZSs/lChXVVPC1p2MlFqV/eYofCzQSxEuLvXtvJ24zvZrXvMlzoD8h5hu1UqFWNI\n", + "lPkJT9XqUEi2anV1NSMoqGD7673oc+X1Q6lUyjgtNxqNjHK4d0rqdrvWx+o47gnAeiHLYRZxdeZV\n", + "5opl9vqDZV5dXXVZRc/Bn3ViuywtLRkTypO1KocThULB/ENYvjBXFtAf92zTPBXgnbJRgM/eeBhV\n", + "tVmvpT+Sl3er0+kY0zQoXBzot6XX1971HNNend73vvcB8EV/9+3bh5/+6Z8G4GdXIOr1upWZ/l/3\n", + "3HOPfcb5Ozs7a0woy/L222+b4zkZmkGMVNiPXvtsbW1lcp6qnIKud+H99u/fb8yWCqqSWVOGkN/z\n", + "s83NzYyf0/T0tK0T9EE6evSojeV/+S//JYC+1EY4vo8ePZpR9d/Y2MgNpCETdeLECZPJUL+iUDJG\n", + "Hcv5mfpPqv+c+tKG2AkLFUrFqL8h+0P735tfYZ47YLtf6/W6vRvoj6drA8tfqVSMNea9lT0OHfO1\n", + "zNpGoci21nFQu6hMDv+GY1F9yHbCnF01017e9+FCVSqVMo7bXrk9M1mxWMy81BV82TQaDWvU0Pw2\n", + "CKplw7IqHeyldPEc6DgAvUSQGlERpqEB0gtU+BvdlOZpwIS/YfnZDzoJWM9wUOq/BynHey9dLhSk\n", + "zMfHx+0ZXFBarda7UmkPodQ04fWNmkbDa3kfwJ+QmvxSTYChftFu0hF40IUyfMbly5czY3tra8s1\n", + "ndEJluaFM2fOZBamqakpe6HRLDRsrnjQdvQOBGw3NbVwLHppLTRhM68bHx/PbOAPHjxoi71uOlkH\n", + "r89VCyxvo0/Mz8/bxsJLqsvULl/5ylcy31UqFXzqU58CAPzv//2/AWzrKynuuOMOM4/RhHXLLbdY\n", + "+b75zW/ad+xrNWvS3Mc5+MILL7jrqvdyo2mPm8AkSUzpm5/V6/WMBtXU1JSNLa5dzWYzpXIPpE1o\n", + "HLOrq6tWPr6MNcOBzmma1vi+WFtbs+d6kaaem8A999wDYFvdXn/rzR11kCf27dtn7wl1/g/Xhs3N\n", + "zYxpdGZmxgIbvAjyQqGQ2Txo4MuoB5lRDgZarnK5nNl0qzmV0CToYRosxezsbCqJO9DvN85DTcnF\n", + "z9R5Pjzwa2LkPG3DUV0P6IAeTXsREREREREREe8Brqr8gTqK6ak3ZD1arVbK0ZF/Q5ZKw+m9Xbln\n", + "QuMu2tOYKZVKdsqiw22hUMiE6nqaJ7oDVrZHtayA/ikq3FF7bJCeFryQXi9RqLJQvJ+e2tSsGv5m\n", + "a2srZVrlb0Oa2nPI3trasjZiPwwyG/AZPLlMTEzYtUr5atsA/VMqn8vTpCat9mhqNePxPuwvPU2p\n", + "eThk8jS3k1LELL93oteysMy7YaK84AudD+F3Ot7DBM/e88kQANtO5KurqxkH26NHj9q11N8JnzcK\n", + "8jTVNNGu6gMRg07drBf79fDhw6ky8jdhcuxqtWrMDNcarbeajUJ4J9tLly4NTMANbCule2i1WiZN\n", + "QeZFQa2iRqNhbUOzZaFQsBB8hu9vbGy4ofNcO0KHW0W1WrU8fcqshYzu3NycMVFci/bu3WuMFO89\n", + "MTFh81XZm1AWRnWzNEMA60tT4LFjx4xl0zLRyZsyCaurq5n14oMf/KCxTR7TxO+q1ap9r2tNOG6v\n", + "XLmCBx98EABMi+rtt99OJQUH+msXmRld10PH916v58o8EJoFhBhk1uKzdX0n9H07KF+gXqfrCf9q\n", + "UmVNCh2ywTpX+Nvl5WXXbEjk5YJsNBqZdUfXaM136b2n1NGe14Vmw1FMfJGRioiIiIiIiIjYJX5o\n", + "fKRGtdMS6ueSZ7cuFotuuGiek66q+hJkumq1mu1yeQ/1BVCEDnvertizLeuuPS83l5cXLzwpeT5S\n", + "XngvoX5OO81rNAxhGPWgE9Bu4bUvkBY15fM9Z8pRpARqtZpd5/W5ym7wdL0b/65wPoyNjZnPGJm6\n", + "drudUvUH+v3HkyH/qjOzx+TwvgcPHrTTM9vghRdeMEVl+sXcfPPN9pn6fZCtoa/RP/TaogwifaXu\n", + "u+8+17+IZeUcaDab9hs6YVPcUzExMZFx0h02jtk3s7OzuWKeioceegjANhOmAo+f+MQnAPT9q0KV\n", + "+BMnTuBHf/RHAWznlHv99ddTztl58KRMyHCFAq7Adh/ffPPNxqRork/vt3mBAuqf6v3WYz0pzEu5\n", + "hGKxaGs055FKY9CvD9hmwFTpPpx7KpBMX7mNjY3cdZEs3rlz52weKnujATJAv73JimhwCttyYmLC\n", + "+prtVi6XM9kTvEAKjzHV3/4g1nd976iwdfierVQq9jwdY/wNmVNVVFeHfO99GOYqVUZKVc9DaaQk\n", + "SXKDCNTJnSzcIB+pq2ba40ZIVcSBtJaFbkD4mZqZCG5E1NncozDVIc9bMHhPVSzn73mdZxLRF6qa\n", + "WsIye/pA6+vrmSTDW1tbmfJ5E0Tvw+sbjYarOkzoQCa0XHmO6kmSZEyA2l/D9LDCyTzqJqpUKrlS\n", + "/lyMdLJwMnvOyIQujGy3Uqnkmpi8iD/PuZFtrt959wv7ptVqZfpVox6JZrNp45MLc7fbzaQSmpqa\n", + "yqi7q5OmPosvLW4gOp2OvXBpelANKX72/PPPu5vDkCbPyy6wGwzasISRv8D2WDt37pyb7YBl1UME\n", + "5zFflt6cW19fzwRIDBvH4TowCriJ03FAkx7vo33AuqkiPPWa1tbWXNNQXlkVYfYBbzOoa6A6bnNz\n", + "o5sTtqmXmUDTBoUm5XK5bC9aDW7g7/md5yYCbDvaM53X+fPn3SCJsD/VtJSnX6Vg2VWLkMEHrAuw\n", + "3b9ra2v2mb5j2JbeXPLeB95nnqld35+cr95a5MEL4Go2m5m10htLnouKaiR6ZIjOgTBpebfbTW1G\n", + "9fkh+Ly895QexndyyI+mvYiIiIiIiIiIXeKqMVLtdjulp0F4u+Jut5tJqlsoFDIUrNKjeQ5qmrjX\n", + "c8j1dJiUqclzqtWduncdT3d6HU8dqlnkhdOHzsYehem1qd7b06MCtk8o6mgdnjC8BJF6UvJoV0+X\n", + "Q8uS15ZkBlQlXM1uPL14pgI1YYXfd7vdjPaMnlJUHT10jNT2ZX+0Wi33xOj1g5cEO6y7MrWEnsrU\n", + "LEUmQMO8wzZQWlvbkffhZ+1229qU5kA9ufLfg0yVoUP7IEaKdQtzZep3vV4vw5x6NHy9XncdqXmf\n", + "119/3dpB5w/7m6ycBgSwfrOzsxlWpFAomPSDp3JNeFIsXvDEIFDCwAvVZ/m89lhfXzezEseCJoAe\n", + "Bs9NgvfJy/X21ltvuSrhHANkY1qtVq70B8fdrbfemgkS2LNnj7FhygqGTs4TExMZSwKwvS7xHgsL\n", + "C5lsAsp6kh3TcirT7eGOO+4A0E+SzPpznpHR3bNnjwUHsL3n5uZScj8sO+fS+Ph45p2mztJsAx3b\n", + "RKFQyORa1bUy710JIOM+4K1r+i5ShOuYZyHa3NxMsVP8Lly3dU3QNTjMzQukrSi8X+guo/dm3fJc\n", + "Q/IQGamIiIiIiIiIiF3iqsofqGyACm2qkxcR+uZ0u92Mc5veR/MCeacTIk9Ekp/r30G5eMJ6eKKP\n", + "WgZlOHhvz3lZn8FduNrXQ/mIzc1Nl6FRnyDNAE+Ev/HYJ62PnppCqYN6vZ5y4g1/o5+FjI+WOU8i\n", + "YHx83Mqvob1h+3rMWrvdzvSNsnNavlCdfHNzMyN/oRh28g9PbdVqNSMNMcjPge3BZ4SK2GGZlZUj\n", + "m6BCgGRjdE6FbNIg2YoQ6k+Y1wYTExN2evZ8bbwxkscyN5tN15eBz7hy5UrKYZ/gnKPMA8Ppge0w\n", + "f/oEKcbGxnKZGUKlXYidON+TVVLWi07SXp4x4vLly8ZyHD16FEA/dJ7sirJVnrAo66aMFP2cVB7D\n", + "A5koOutrrjwtJ8tChk6VzYm33nrL7sPAhgsXLmRkSzxxyHa7nesHw344c+ZMSpCZ9+M4Juul6xDH\n", + "kgoH61qiwRcsp1cW+iVyzS8UClYPKrpfuHDBnjE1NeWy1CyrvjvC4BplY/S34b8104g6brNttJ5c\n", + "A3n9IOuC907lfFb/aPW1ykPYBroec+x2Op2MhUWFij2mPC/4LM8hnbiqGykgW0jVceBi2Ol07DNt\n", + "yHATUSqVjELmIjGsY3RD4Dmgh2Y+jdAbFO0W1su7r6d3xIVjcXHRfs/yq9Oid+9hUX1Er9ezDQB/\n", + "G5ZN66Mol8u55hiW1VMJHqQSruXKQxiNtb6+njHFDqJgw+8HmdNC6Fj0IiSJWq2WMdl5UH0wtuPE\n", + "xEQmRUypVHKTbg9T9Qf6faTmVKA/NvjC0EWHCxrHoLbBqNFlhC5enLdeFOWBAwesLPoMlsuL3tV+\n", + "Dc3HgxxCOf81cEM3vnxJUt1bI/TytL7GxsZG0gAbdQOqYD3f9773uWXg/P/e974HoD/uwudcvHjR\n", + "zEZ0Nt/Y2LB2+83f/E0AwF/8xV+4G6k8c6Vq1nnrKhOKcwM1MzPjmpz5DDUFMvkyzXlLS0u2yeV4\n", + "v/HGGy2CjxFs+/bty5hMNXm96ldxc+jpCGqGCI4XbuDm5uaszOpIPcqa22g0bIxx/K2vr9vLXDME\n", + "cD4ywEPre+nSJXOS956na0KejpsSAmE6Nf2trgWcz4QeRPUdkvdcjYjnnOVaPsypW5/Bcaw6i6G5\n", + "z8OwZ2ikodcGwxBNexERERERERERu8RVZ6Q0Zw6QPk3wtJUkScbRulwuZyj/TqdjpyylTkM6eGNj\n", + "ww3RzGNMVDtIw0VZvlB5HcgyUUmSZOjPWq1m/+ZJTrWq+NyVlRXXxMF78/TmJQUFfPOI1pflIqPX\n", + "brftBOyxbEShUBhJNmBraytXKyyPtSuXy9Z3Htul4e15uluayypkqWZmZuzeynR69G44TrT+enoK\n", + "ofnceJ0X7qsBDXriDPMbang+y9ntdu3ebIv19fWM4nexWLT6khlaW1vbsaaMtrc6+/K78H5nzpxJ\n", + "hYGz7Kwb67GwsGDl433Hx8etbsNy+3k6Wcpc0CzKsqhzM5/hsU+XL1+2vHY/aHAOz8/P4/nnn898\n", + "HyZzD9uR37E/qbINbM8HmiuPHDlia6W2C/uBZl81H5O1abfbGUbq+PHjGVPz4cOH8dxzzwHoq4gD\n", + "wNe+9jX7nrIFBw4csLbneD906FBmbgzKe0nGRIOO2FYq2RDmUJ2ZmUklJiZ4HVkoj+lQU7aCrN3v\n", + "/d7vAQA++clPprJisHz8t2paMYsGP3vxxRdTjFVoNvSYaTU7sy0bjYb1vxdAxd80Go2U5BCvz2NX\n", + "2SflcjnjVuHJh6gcjb5ftAxh3fTd6jHRvF9e5odyueyyqJphRP/uFJGRioiIiIiIiIjYJa4aI8Ud\n", + "fSgeCGR32uqrEjrpAWnZAO5e+b06JWu4vMdchP5GGjbKnWqSJBmHdnXS1RBW3a3zHh6bEQpyNhoN\n", + "OxWpQz2fq/5C/EzDpT2Ww3OgVgFF/ob+FXqdij6Gqt8eg+E52qtjrMc+qWhhKOnQ7XatbdQJkicR\n", + "T4KB12lePXVKD8ug9VaE9fBU7JMksbbK88lTFkXrTsaE49TLKadgu9RqtZQUBsunDqC8b8j4tFot\n", + "q9swdodQPyxPIiQcVx6azWbmhK+OthqGHjKdg8a2+oSFYpmAf8pkH7788ssAgF/8xV80VoTXeyfx\n", + "brdrfReG3b9bsN8uXrw40j09aQRgey3gunjgwAFjRX77t38bAPDII4/gx3/8xwEAjz32mP2Wa5HX\n", + "h9dffz2AvvN6yNSdP3/exuU999wDoJ+rjn49ZKLuuOMOkwZgOy8sLFj5OI7feecd6//bb78dAHDy\n", + "5EnzpWIuvQsXLmTELRcWFowdI+MEbI9zSp80Go2M3EO1WrWxQ/Z2c3Mzs160Wi13rBGf+tSnAPR9\n", + "0f7pP/2nALbn7dTUlOXQU988MlE///M/DwD44he/aJ8VCoVMkEOpVMq8xzTXqsJzBOd1g1jxnaDd\n", + "bmf8w9QPa1iZuCaooLX3HsiDxxwqg8V1Ii/Prb7zR80ZClzljZRqQXFi6gYk3GAA2wuganHoyyt0\n", + "vtvY2HA3X2zgvE2O13H6YlMtqlBhut1up/R5+F34ktP6cdF5/fXXMy+3crls9+Zv9Rp1lgzbIrxP\n", + "aFrzBuDBgwetTzRZpdcm6qin9QWQcq7mb2mSuHz5coZu9xTVBwUChFAq2aN+veg+BV+MbOfl5eXM\n", + "C0XHkG40vQ1UuHhNTk5mXkCTk5O22OvEDU27pVIpk7xXx6Iquocbfb1WI43yFPAVGmHKsvB52s6c\n", + "r2zHQQEG4djWtvMihFS139tgeOZgTfaatynhs5955plUWg/Af8EA25uvYYEsedDsCexj9v+rr76a\n", + "a2IIFf1DsL1oOvuJn/gJPProo6nfPPbYY/jX//pfA0g7fdMsqFHSHDtcp7yoTJ0XnssAx9C3v/1t\n", + "U2jnJuLkyZN2vZqyaJZTp3hudulIT4dwYHvM1Go1G9v60gz1q6rVamZ+N5vNzHvHU9RfX1/PdW7m\n", + "Mz7zmc/gtttuAwAzcy4tLdn9mLZmeXnZ7vfFL34RAHDvvfdamp9ut5tJgq3EgSIkBOr1eqbvNGBA\n", + "xxHflepwzX+z/ZrNZoYkaLVamfedPs8z93njd9hmKaybukHoehaawXu9npuEmG3qmQy97AeDEE17\n", + "ERERERERERG7xFVjpBqNBiqVip361GGYO0tlongK445UTTFkNVRhmqfnZrOZMvMBaSreC+P3Eh0S\n", + "Xu42TbDI+3khwt1uNxMi3uv17DPS20eOHMk4FnrUqUId870To8cWab48thvpas3N5Tmq64k61FMp\n", + "lUpGnyu1zueRCvecr5V90n7ICzXWMF5PLyU8AanaOVmlsbGxVFkBX/kd8HM2qcmR0DGoz1Ksr6/n\n", + "SiaoZtAoEgt6SlaF9jCP5MTERO54UnDu8fpms5nLwI2aoyrPNOY57a+urrrh3jo2yF4w4a0+xwuK\n", + "YD1OnjzpOpHTAZzPvXjxohvwEGJQAm2C43R+ft5YgDzFckWeMrgy1yov8fDDDwMAvvzlLwPoj5Nn\n", + "nnkGwDYTfurUqUyZC4VCRn9HFbc96DzydN2YVJmM1F133WVlUedrMkP8LEkSM+3xtydOnMBf//Vf\n", + "A9hmut98802rE/PrTU9PZ/pN2Vs1D/I6b3yy3qVSKXfcst6f+9znTHKCZVlcXLTfcs5sbm7ivvvu\n", + "A7CdoPrZZ5+1+05OTmbcDwatAyFbtLy8bGsRn7e2tmZ9olYUT8uQUB27MMhFXQUU3ngK57Cu0eoc\n", + "HsLLytFsNm0u7cbEnpcP1HNfGITISEVERERERERE7BLJTtR2f2APTZKBD52bm7OTGXf/Bw8eTGUI\n", + "B/yccvV63T5TtoBCcTwReNATpDrwhUyD5jfK26nqLltPNqP4+pRKJQuFpb+GB8/nJmyX0N9obGws\n", + "4zDe6XTckz7t9zwJ6XWeD0UelCVTZ+m8E4H3G4VX5lGR91vPN0/LFJbFy6umuRG9OqofUei/pIxO\n", + "nqq3CgWqnxrLwhO6+s2RKVxYWLDTZ5hvTDE9PZ3yNwQGj136GHF+nDt3zr0ny0ofmEajkWnrYrGY\n", + "qfvW1lbGsVgDVpRpZN0nJiaMmfGYMt6vXC5bP2n/sp+oEv6d73wn49f3bnDs2DFjvehDM+xkzbVh\n", + "fX0948dVLpfxyCOPAADuvvtuAMCf//mfW1vT/2Z9fd38KikETCfwQaDidr1eN+aPY+vWW2/FCy+8\n", + "MPC37A8NNvjYxz4GoM/a0E+L91NJBgZjKCND5nxjY8PmGX87Pj6eWadarVZmLKrVQNljj70P/Wx1\n", + "7nnw3hH33nsvgD7TxHtr3VjmG264AcC2wj7QZy7Z5uGa/m7h5RFVRfBRmJlBmTx2Wgbtt1CkV32z\n", + "lArWkDUAACAASURBVLkKLQ6VSsXWOc6P9fV1W09UFkLLz9+GKutcU7//rnMb/aqZ9thp4YDTwcmK\n", + "vPLKKxnnws3NTVsI2FhKS7KhZ2ZmMhsopSa147xIvrDjVJY/T0K+1+u5CUA1Ok2v1ed2Oh3bQKmS\n", + "N8Eyr62tZTStGo2G3dujRwc5SHobijBtg24YvIgVzzzLttH2VedhQl+aYWJQb6Onfaj30OeF0P4K\n", + "qeSxsTH7rTpmhqmJPE0rz9k5rB8ROmRq5JC+6FUJmM8P69toNOx+el/dWITgAuOlFxkElnXY9WwX\n", + "Xjdo4WWb5iXx7fV6Kd0ioP+y4aGI9zhz5kyqXfiyZ9tfvnw5s4HSccwX/LXXXutuJLipUVN32K+D\n", + "0kuNCvb/qC8i1tdzhq9Wq3a4Usd9qqHTCf/FF1+0NqBLgYJryE033WQO3uyv+++/P+UgDgAvvPAC\n", + "jh8/DmA7ou6WW26xzRXbR9efz33ucwD6pkVNdAwA9913n5m4dF33DsV0Xn/qqacApFN2adYFL8It\n", + "TOatStlqDtMNlNZnEE6cOAEA+Ku/+ivbLNFxXNdlnVPsV667GuEYuh0A/c1VONd0rWSdarVaZmyt\n", + "ra1l0qjoBl6jnj3oWg+kXU90PoZtrq4n2oahyrq6MnjuN4TXh51Ox9pLs57oxiiEpyPl6VINQjTt\n", + "RURERERERETsEleNkdrc3Ewlq+RJeW1tzahz3W2TieIusdVqpUwW/I47Wj2RqrotkGYrPKfVYQ6t\n", + "XphnaLJTzRulLUOFWaWXeQ/VJeJJqFwuuznDeD+ewJQN0hOGsmNsQ5Zfdbp0Fx4ybnp6IhOlp3s9\n", + "qYeaV0obe2ZBNV2FpxOPGVKGS52g86AO1zTf6UmZbaAUMH/D65rNpssc5JnxFDzJsewrKyvuiUed\n", + "OFmW8CSlkh2esj5NT2NjY5kcVY1Gw56bd7puNBojMSVJkrgBBjsFWSgNwuC87fV6Nge4boQsHRlc\n", + "moq+8Y1vZJ4xNTVl45f3rlarbmg1oXUK835ubW1lTuijYnV11RikvAwCwPYa6THNhErKkD255ZZb\n", + "8KUvfcmeF4JMk5pndH3yysE12isf54Ka+vjcG2+80e5N05W6J9BJ/IknnsiEtc/OzmasC9dee20q\n", + "OTKwHcjEfwP9vvRkcPiZrpUhE1Eqlax/WfZh7gRad5ok+R7SscT7/czP/Ay+8pWvANhuD3Xr6HQ6\n", + "GR0pL1eih2EmaJV9CVn2SqWSSdLe7XatXTlnVPeN40DXSn0/hutNoVDIMGAeE6bWILUksKyjMrq8\n", + "x6233mpmcuY0VFmLURl7IDJSERERERERERG7xlV1NvcEKj2ntUHZxnl65QlDd5D8rtPp2PcaDj7K\n", + "rnhQCHNo9/Uc34Ft9oFlH9TWni8V4Tm20jm12+1mHB6HOZuPCq/unjCdh0H95fmghaxXtVrNdQb0\n", + "ckYRpVIp5ROxEwxymqcPDR1yn3vuuUybTkxM2IlWJRvYdxx/+/bts3qwbiGrGtaNYyhJkswYG7U/\n", + "rrnmmlSOSj5/FGfpUZ1NFxYWzCGbqtJvvPHGSL5Dc3NzmfYbVUJBoXIl/+E//AcAwH/5L/8lc522\n", + "B9s/SZIMCwj4TsP0eeFnS0tLxmzs9DQ7NTVlTAWZi0GMHtc0Mghe8MzU1BQ+8YlPANh2bn7hhRfw\n", + "v/7X/wKwffIGsnPv4MGDKV+wQTh69KjNZYqT6vqiwsIq9gmknaZDYU7Fddddl2GagO2AhgMHDgAA\n", + "nn76absP20PnFNtMndzVRydk3FSixnNy528PHDjgtn84Xm666aaM/xew7VDOIKpyuWzK8ZwDp0+f\n", + "xm/91m8BAP7wD//Qfpu3pqsCujKcnvjmTsG2mpiYsLbkXy0Ly+f5DhaLxZTQcghl7D3hYUKtEewn\n", + "tcSwvrxHtVrNCKOOKpdQr9exsrLyw+lsDqSpOG/DoHQ5X2hcZIrFok0YLggaxcbvSqWSbTw4gZMk\n", + "yZjvut1uKr0LkO5odYDm99pZHrUf0vz6suYET5LENkNsg0KhYPVUnSUOHqV0dxq5pok6WY9qtZrR\n", + "NdG6e8mGVeWW91Hzl+ofAX5CXI3aG2YaCTfX3sa30+nkvsD4jJmZGWsvtoVuvFi38fFxa2teNzc3\n", + "Z2OM9VFzqm52wo2Pardw06z9pqmOiDxT0aibjWKxaPXjc/UloqZRVT4G+u3s6RWF0NQpoXloEDin\n", + "19bWdrVxykOe1tO5c+ds08d1olqtWnk0yIJzUl/OfLFyk9BoNHL1d/KgLgqqneXN61FMGL1eD3fc\n", + "cQeA7ei+//7f/7sb/cv7MDpXN1HeJoJ49dVXM5/ppp4aeMViMfOy0ugp3UDdcsstALZNYm+88Ybp\n", + "erF8jz/+uNWDmye9Dw87Os/YtrVaLeMyAGzPe477ubk5m/Nadz3QAH0Hfa+PfvInfxIATNvq1KlT\n", + "tp6wjk899VSmD9vtth1A+N309LRtoK655ppMH9ZqNWtzlq/dbg9U5A+hkcNAv93C90ipVMoEB3mH\n", + "VO/9oyZvQt8BerD2Ds+ce/xudXU14+KxtbWVSZbtYWNjw4IXuNEcNdJwlLkdTXsREREREREREbvE\n", + "VWWk1BRD5kVZG80fRkZAmYtQ76fdbttJirtmDfMkdPfsUfceE0VsbW3ZtXoiCZmDyclJ2z3zVNbr\n", + "9ex5nklH2biQBUqSJHNqV3OEOk177A53/0tLSxl9Hi95sJ7glEZl+fWkGVK16hSorEzY1l7SUE+T\n", + "KawzrwvbY8+ePXYfrTvbkuNgaWkp0180rwBpRejwHmpK1QAJlllNBWE9hp0URzVHagJi9o2emtim\n", + "vN+VK1cyzECxWMywhr1eL6Pd4o1Tzww6NjZmbToqZZ7nlD5MGXwYSN/n3V/R6XTshK4ImS0dn2Qu\n", + "HnjgAUvKu1M0Go2MuvYNN9xgpkKVZOBJOo/p63Q6phzO+pw8edLGB+utwTAcx0BWwmJUnbg777wT\n", + "Tz75JIBtBunKlSsWJKQWh/vvvx8A8K1vfQtAnzkjE8V5WCwWzRmdfz/84Q/jC1/4AgDgq1/9KoC0\n", + "CZBrTbvdNhkM9p8GauTleCuXy651hGOb961WqyYboe8XMlE0QbbbbVtP1MQXjivNHUvcdtttqfx8\n", + "2k8sE8eMZrYImWaVhdHsCPp+BfpWEo4tdTr31OlDqJ6Trnt5jLrnaqOf5bkeaHJz7gP4t91uG3uX\n", + "p7au+QuHud8MQ2SkIiIiIiIiIiJ2iavGSNHpUBkQIO2rRNRqNTttqDMad80qaMhdPU904+Pjdp36\n", + "8qhcwCAME9rL26GrXwmfq74qeg+eKjQnWFiudrttLAF9Od555x1rK363tbWVCU0F0qqvLAPvs76+\n", + "bqcwzfTO8niZ3dW+7al6e+3G9lJmKmRpBqmsE16eO17v+XMUi0U3XD2EslC838bGRkYFXqF97CmQ\n", + "5wm2euCJ88iRI8YEcezqs+hfB/jjN8zgrj5r6gcY+sO12+2Ms77XB/oZ6zg9PW2//UEoLl9//fXm\n", + "+6DjzxsbXog+/X3UuVmvD9mwTqdjY4v53N54442Mf1in0zFRSPbNqD4pgxAq2x8+fNhYHWWk+Lw8\n", + "5nJubs58Qv/mb/4GgJ8hQPMWKsvKUz3HULfbHclHRP2m6GN2/PhxE+ekc/jKyooxUcQ777yDQ4cO\n", + "Adhm+TY3N/HhD38YAIyF+sIXvpBxXn/jjTdMZJTO3+pwzXmkcineGkJsbGzYOPaYfUpFFAoFk5fw\n", + "ZAjIiOzdu9fyPtLRX/1U+e5aXFzM+PK++eabKauLx5h61pZwfIwqyaHjQOdUqP4OpP1Dw3Ko/6yX\n", + "+5TQd0nIEiZJYu2vATKhGHa1WrXxyb4elgtS22dQ0JKWbxRctY0UB0uo96Hw1LN1AeSA9xYyNq6+\n", + "MFQDJHxBFIvFVMSVXh8iTD9QLpdzo8lUK4mdRBPk22+/bQvoMOdcXscXzPz8vLWN96L3kuq2Wi0b\n", + "hNqW3iaEbcgJdPfdd9vCrubN0BSr6VG0bt7ADDcbaj5UCpbjRDW5+JlSwOEk0JQ+XLQ0CTLrMWjT\n", + "7OkUhe2i5hlF3gbK29Rx4VhcXMxVmyZWV1eN0teNEtvDc9xUnRZPBX6niT95j0uXLo20cRxVBVwV\n", + "phVhxJLqPym8DALEgQMHXAd69iGdlgellAo1w5aWluzlzA3IKImNB2HPnj0ZM46WLw8//uM/buVn\n", + "9N6lS5dsI8PyvfTSS9aWur6yXW6//XYA/fEwSlLYixcvZlwttP24iSgWi/jFX/xFAMCjjz5q3zMx\n", + "Mftybm4uozRfr9ctSpC48cYb7d5cU1dWVszhndFxa2tr1n5c97wUW8vLy9b23DCfOXMmFTQD9Dec\n", + "4Qbq0KFDqaTLbBeOVba9biboUH/y5ElrN24Mz549a4cmL0lyqVRKmcIIfsb1ZG1tzVTnH3zwQQD9\n", + "jehf/dVfYRB0rHG8e/2vmoScA7yuVqtZu3kRePy3rheqqRjqNVYqFfu3uqV4EfhcO9jmvV7P2kVN\n", + "gByjXjYTwltfQkTTXkRERERERETELnHVdKSo/8Bdvac6SxQKBQvpfeaZZwCkT7Ya+snPvDw5pBw7\n", + "nU5GxVqpfT0x7CTEHNhmBkqlkp1Ylb0JHbM9LaBCoZBxGNZcRsouqaMw0N9ZK7Ommh78nr9R3Y1Q\n", + "VXl8fNxYDI8d8cD7djqdDJugST6VPQnNQOVyOaNbVC6Xje3QBLaER0N7oLnkwoULGSdD1UvymDz9\n", + "LM9EyH7TEGyFmmAH1cOrgzqHq+mRyJOPSJLEzLieA+eoeeI4f6rVakYq5ODBg1Zumj92IgkQJi3V\n", + "gAVibGws035JkqQkHfh79vU777yTGYsHDhyw8ntMLB2eL126lOt8yrofO3bM+oJ/R1Wd9vCRj3zE\n", + "2pKK5KPiT/7kT/CRj3wEwLapuNPp2L/p6E1n7UGg5k6pVLJTO9dSHUPKEHpzhXIA3/zmNwGkQ841\n", + "aXG4/qv5K09vCkAmx5/+lkxcs9k0CwdZo0Kh4M6lPO0wlvONN95wdcf4Gc10unby+UtLSym2i/cP\n", + "x6LO283NzYwW1Kgm9EEBPKFT/fj4eEYOQtkiSoYsLy+782ZUhHqCGjSjzvCj3ANIz3VgZyY59qea\n", + "ez0LFzXqBulIRUYqIiIiIiIiImKXuGo+UtVqNXVq40lkfHzcTgea2Z5MFDE1NWXOZXoKD/PqaQZy\n", + "DREl1E/Ey0AdolQqZfItaQ49ZcC8nTefp4yZx56Fp/mxsTF7rseS8cS0vr5uz9B2UaYkzGdUrVat\n", + "LjxRra+v286cTEmlUrFyqWxBeJqcnJzMyAWoH4aWP2TMPDar1+tlBEMVYQZ0IM3QsKzqtxJmAm82\n", + "m/ZvPZGG+b4qlYorCUC2ZhiDybJ6/j/KSKnDJsviqedz7OQFT1QqlYyfmObu0px7eYyethXbl6fB\n", + "er1uddupOGW1Wk3l2AP6jqOhOOj+/fszzJoqUQPpgA1+T5CVabVamYwACq4dR44cMV8bD6zvtdde\n", + "i+9973sA0sK9YR8Pk/ag78bS0lJKgXwn+Lmf+zlzztY5Rd8ezmmVP/DAsPtKpWI+O2SpTp06lWHc\n", + "tK3IXLz66qt49tlnU9cVi0Xrr8cffxxA2mH4gx/8IACk5CTYb8raPPzwwwCAL3/5y8ZEEfv27TNG\n", + "ioxQpVKxMUNhTJXI8HKRcs2p1+v2XN5jYmLC9bPjGsTxpWs+14Zut2tMFNv2hhtuyOSF7PV6KWYt\n", + "z++ODFeSJLY+sX91zKlkC+sSSugAvp+jBhTwPpqRILTo6P34LlemyWO99N3Mec/+WFlZyQQMtNvt\n", + "VK5IlsXLmxnmqlRZJbbRzMyMfU8GcRSr3VXbSHGh4+LBBXxjYyNjpuh0OpkXwZUrV0yrgw1ZKpVs\n", + "EaQTnyaPVLMA76cvPi8xbviy0UGpAyeMJtDBoWaz8H5zc3NWT9LBGsnH+7TbbRsIfJlo+ht17OT3\n", + "vB+Qfrmx3KEyOJAeNCH122w2TUeFbZ4kSebFuba2ZtdpfUMqulgsupsg9hP7Q81anLhK7epv2da6\n", + "oeBGj9FEN954Y8Zp1UvzUygUbFyGyuBAevEd1Uk7L+WQmky8AATtd6Dfptw4KNXONtDFxNuEhQvV\n", + "IOdqItQVA7bbeX19PTc6iJFL8/PzqXEJ9PuH9eAzVldXrVxcD1QPiy+OhYUFW0O0Lp7pgS++drtt\n", + "92S7eMrR3kZKgw30vvwtx8TevXttjhDDTA58UZ4+fXpkczpx9913A+jPHW5QqGyuDtBcH6+//npL\n", + "T8KxfdNNN9mGUCMJ2W4s/6FDhzKJk/VwwRfufffdZ2rSRKvVykTe/dZv/ZYpeHMDdfjwYdOg4j2m\n", + "p6fx8Y9/HADwP/7H/wCQdhhnn3obxHa7bXVSh/qTJ08CSJv2OBZ53ezsrNWd9w4VuwkeCDj+xsbG\n", + "bA33Nl6MLj179qy9s9gv6prhKdPv378/E4A0KNCD/cUyXHPNNVYnbvq8Q9TU1JS9B7h5bjQambro\n", + "hlEDL8L0bcVi0dYndUchlMTg55wXhULB2p1rm2r46VrpHWhHSYmlAVicv15UcIho2ouIiIiIiIiI\n", + "2CWumrP5wsIClpaWck0hZCHGxsYytObdd9+Np59+OvOb0FHwyJEjxkTkae5sbGxk5A8An14MHbOD\n", + "ugHoM008leRp30xMTOSaGd4t+Ew1k3ph74Q6ovP0NUxhmidfnooGhbjn6UN5jqp66g3bWvP0qYNy\n", + "WNZBCaVHhZdomVCanGOCiUdffvnld6WnxFM7x/358+fNcZYnw3a7badnPVHTzKvhw5pfCkgr3LMe\n", + "PAkryuWyfc8+nZyctPryWRsbG8Z2KDvxwAMPANhOZKume/7d2tqy8rG9VbWZa8SFCxfsN6o/x+ue\n", + "eOIJ0yMalnyXLBbHhppviA984AP4+te/nvpMy882GB8fz7BUx44dM0Ylb407ceKE9cOXv/zl3DLn\n", + "4Zd+6ZcA9E1j/+2//TcA2yfqpaWlTHLZW265xU7fXH9mZ2ftOh1PnHusr7oZkJkYGxsz5kJzn5E5\n", + "VLaTY5bXX7hwIeNQfscdd5j8QeiuAWxbHFZWVjK51iYnJ+0Z/M5bB+69915j4Nh/yqLwGadPnzZJ\n", + "CbapBjZ5yEtE/26Rl7R4fn7exhPXrJWVlZHKMTs7a+3GMbG1tWXriAZKhea7QUxYHvtEqHxQXkJj\n", + "BdeJ+fn5lLYkn8k1gd9NTEzYGCTbWywWrW68/vLlyxl5I5Y/OptHRERERERERLwHuGqMlPwbwPbO\n", + "cWtry3bFaq/kDl/z1hF0CiuVSmYH5YlT/RT4mZffystlF5Q581xFmM9N8+rpLjsU99KdN31HNjc3\n", + "3ROE55TuQa/zTi88CdLn5s0333SZjTAfWbFYNPaJ7To5OZkSuAP6tvZR1bzD5+opwWPO8iQCtO78\n", + "reZQ4zhZWVnJOIBOTU1ZW3k54HTsECzD3NycsTAasBCeGIflj+MY37dvH26++WYAwPPPPw+gf2qn\n", + "BAhPi1euXLHTOpmB8fFxG9OcC61WK5U5AOj3H5/HNiVzC2z7eoyPj2d8BWZmZqyvNacZnX51fJKR\n", + "UHYp9DtTBXmWqdvtuj4leej1epZnjozU0tKSmzstxNTUlH1/+PBhAH0/ktDHR520OT9qtVrGR256\n", + "etrqpNeH4/bEiRP4qZ/6KQDA7/zO79jnw8Z5iH/7b/8tgD6j89RTTw0s8zCwrTg/Bq01rLvKUChD\n", + "C6T9l+666y4AwLPPPptZk375l38Zn/3sZwHAGMUzZ87Y2OKc27t3r+XdU+hvQtDi0Gw2bW1Q6wZV\n", + "7L/73e9avUK2ZWFhIcN6AdssK/3oVOLFu45jUjNcsB0XFhasjzSgh58lSZLxv/LafBB4nWbZIDju\n", + "R12zPezfv9/GCts3SZLMONH1XaVnlIkG+u3iWX7yRH/z3o/VajW1/gP9ecl1Ud/VXlsOY6SuatLi\n", + "QqFgLzmNHGKD6CDhgOKg1Mpy8KpGkm6g2HFe1IOqq+ZtlvLSlWiaFL0u1LTSBJAKdqJGwnCTw9+e\n", + "P38+5aBO8MXI9hjkWKwO/BxI/Ds7O2u/V0o6fOl3u92MQ7JuOngPTSTJZ0xOTqY2WkC/3/gC4gKu\n", + "CsRehJ73gtF+COvumZI8rKysWH95m0rWo9frpVISsR7sLx2XnPSsx8zMjLUp+3BycjITAVcsFq09\n", + "uEE7evSomfZoTrty5Uqq34G+KYP1UAV2Ljy64eNcCTfMWg915lRdonBBbjab7tjOc2BnX5bL5czm\n", + "atAGIoys7Ha7qQ0r5xAPJUtLS/YC0ojJ0Myvmyz2jTqa837z8/P2IuN64plV1UxIExGAzEbgrbfe\n", + "cteWUTdQVO5mJBodzRWDNlGe2TrcSDWbTXfzzzmgCMfE2tqatT2jru+77z6LlmO7cRMF+M6+xPLy\n", + "sns4zdM0Yp9rUl2Fl8IkfPkvLy/b/NbycWx75kt9d4UBC4VCwfqN5nQ9xLAvX375ZTu4bmxsuJs0\n", + "VVrnvVlGrS+vY910k8t+27t3r208VQORz83baGn5VSeQbahtqnp0QH/usQw6JjnuuD5WKpVUgmV+\n", + "p+9/fhY6uTebTTPp8fCpavG6gQv7mm2Sh2jai4iIiIiIiIjYJd6VaS9JktcBrADYAtDu9Xr3Jkky\n", + "B+D/A3AdgNcBfLTX6y0Fv+sBaVVv7jTHx8ftBMVdZ6vVsut0VxwmYvWgitV6+hhmqgvBnXKv18s4\n", + "wWq+Ob0+PMkdPHjQduE8vbRaraHO3ESeojYRatWENHqtVrMyDMsHRo0T1v3MmTOpxJVAWseHp1Q9\n", + "3Su7E9KylUrFThv6G++k7OVdzHME1wSg4Qljamoq49y4ublpz+DppF6v27/JEIxqbur1elY3juOb\n", + "b77Zxiw/q1arKRMX0Jfs8PI98dlkXQY5ZIZje//+/TZ29NRM9oTtqM68CpaZp+xCoWDMMPHcc8+N\n", + "nAVgp+Bzp6amUqZ4oD+W2A4XLlxI5eAD+v3GEyXXlUqlYvfMUyBXcx9x7bXX2umfv1Wzj6rnEydO\n", + "nADQH7sMt9frqfD9p3/6pwBgTuo7wac//WkAwNe//nV85jOf2fHvQ6hej7Z1CI4xNW8PA5XIuY5d\n", + "unQpsxYN0twK10BlVkJTm2J6ejozl4FttpAMxttvv211JzunSeRpXtc8gPzs1KlT5jRP1k010tRc\n", + "yrVI8+p58NZ8tvnCwoI7Z8m4kM0Ctk2Xu0GokdfpdGztUL2scP57795Rc20CyLgjjLq+qFI622p8\n", + "fNx12eAz+F5bWloy5p/rXrFYxOnTp99TZ/MegA/0er07e73evd//7LcB/GWv1zsO4Gvf/39ERERE\n", + "RERExD86vFtG6jUA9/R6vUX57BSAn+r1em8nSbIfwNd7vd5Nwe96Gr4eIo+R4Hd6kqR9dWtrK6OU\n", + "XSwW3Z1s6JiWJIntvHkC89iHnSgWj+Iw6v12YmLCTt484Z46dSrDynjigEDaH4rtEfosAWlGQsNd\n", + "88rKk7xmQ2efqJDdqAKVeWHCKiypAoFA2u8nLw+e+lmNehLKg5cxfnx83MYEx6IKSvLUqQ6ZmuOL\n", + "p0r2ZaPRGIltVbAdkyRJ5WcE0n49bMc9e/ZknHQ9X5Px8XEbgyz79PS0/Zbii6+88oqb7y/MTq9O\n", + "/ZoRnvXkuFefFhVZzQuL9hz8B4GMpSo0hw7FhULBys+yFgoFYyoIZczZ5zovKQHx5JNPWvnV1+OX\n", + "f/mXAWwzpv/zf/7PkeowOztrLNAnP/lJAH1H+f/4H/8jAJ9xVh+jML/ZbsA+mpiYGHnOh3jggQeM\n", + "KVU2yZM9CKHrcV6+SWBbUoR+ajqWVH6Bc4/3q9VqNjYefPBBAMC3vvUte66WMy/cX1nyUJS0VCrZ\n", + "tWTQL1++bOu2ClVzDU+SxMYi1zZvHZ2cnMwEoCRJYmNV5+OoayTnDdne5eXllHh0CBWvDp3NAWTK\n", + "on2oczoUk56ZmUn5wQH9NYZrGa9bXFzMZVaHYZiz+bvdSL0KYBl9097/0+v1/t8kSa70er3Z73+f\n", + "ALjM/8vvekB/UudpN6k+UOhEPD09nTGxjaJcyvuNUu9Dhw7ZQqUvT40EAdJO8yzLIBMQBwLTKKjz\n", + "qW688qITFKH+0sTEhLVVqVSyMmpbhlFx4fdAegEYNVpQEepvTU5OGn2tuh/e4ptnwvQcwT3odWFa\n", + "AU1QnaelpdFunNiTk5PWRrxueXnZruNz3377bTM1UNX70qVLmQ3r2tqavfDU3MhNrs6PcJHWF/io\n", + "zsnEgw8+aGPmtddeA9B/+YftevfddxvVTUxPT9tvmVRX9dW81BCsx/z8vM2NUV+8o0bMNpvNkTdS\n", + "bF++BC9fvuxGZrFfOR8bjUaqLnw++1VfZJ45muPjnnvuAdA3AX70ox8FsO14/LnPfW6kOvzkT/6k\n", + "JQPmi/nnfu7nTI+KJkLd1GlbetptefCuZ58cOnTI5rem6vDWd69dvIMD56hmpAg1rWq1WirtDcvC\n", + "DYqHUSPdiGPHjpmyOMfs9PR0ZqM6Pj6eSjUCpNuea4i2hZZF3VuA7KYoXJv1/RleEz6HGPZeUR1E\n", + "lo9ruKqoh22n7xXeQ98/uiZw88eyDEuAPGoEK+9XKBQyUYC9Xs/mq268RiEQ+Pv3MmrvgV6vdz5J\n", + "kr0A/vL7bJQ+vKdSBxERERERERER/5jwrjZSvV7v/Pf/XkyS5PMA7gXwdpIk+3u93oUkSQ4AyB7z\n", + "sK1MnSRJiiEapkTN3WmhUHAdRcOQeQ2Z5K5TdV+4O9ZdMU+h58+ft92rJub1zGkhnTxIe4QnCDJR\n", + "8/PzVl+eEg4dOpTRRPEU2r220lOMR9n3er1cp1HtB4LP0HxKRL1et880hFXz8wF9swVPjGxzzSem\n", + "rBf7mH2kQQn8bHx8PGMiUiditsPhw4fNZMIyeWblqampVMJZoM9WhCHHg06xKhdAUAfHC4nX3F3h\n", + "qXLv3r0Z81Gn07HxtFsTCrCtkTQ2NmaZAcLk1IpqtZphIi5fvmzmFmWBvVMdf0MThZcIHEgHn4Nq\n", + "/gAAIABJREFUlgD9PuJcVtOOx07t1DQ1Pj5uY5HjwJurLAd/A/TrGJqS9DRO1Ot1M4nqGApV0aem\n", + "pswZ3ZMu8EDn9MOHDxsjpSYinszDZOLAtvL+q6++mumbYcEneUExFy9edJPQEsoqsD10XLEtvdyn\n", + "nqlOE8eHMiOnTp0ybS7KLqyurhozrAmhmYiZzuH1ej3D8qrVgLIFs7OzVg+at3Ve6njimnTvvX03\n", + "4ieffNLWBq4X1WrV6sv5ODk5mTLTh2NMEwVzPLfb7Ux76e+8vuGcVIVxWmI8tigsB5B+r5DNunLl\n", + "isuKhZYjTUZNJEmScTYfhmHWG2+/QEZaMz5wrpfLZWxubqLdbqc03jzs2tk8SZLxJEnq3//3BIAP\n", + "AXgewBcBfPz7l30cwGPe7/niLBaLro5NRERERERERMTVwNjYGObm5lCv14dupN4NI7UPwOe/f0Is\n", + "Afhsr9f7apIkTwF4NEmSX8f35Q+8H3PHy1MRd8WD2CgV/uPf0K5eKpUyDmXe/ZrNpm3e1CnNc3Qj\n", + "PCc+9bMJ/UPeeecdKx/DUM+ePZuxz1+6dCnjr3PmzBnbjbO+XkivxwBce+21rggiN67VatUNA1VR\n", + "NgBu9vlisZgRcdzc3Mx1tGff1Ov1lKJsWC7tJ57seMryQms3NjYyJyMVjyM0lFxD0/lb2s01XJ3Q\n", + "cG72mzpuq/M1fSK0bmxnsouvvPKK2/YE61soFKw8O1X3BtI+JfyrGdmBfjZ5jq08P6tqtWrlV2Yj\n", + "FEsEtv102OZevrbNzc0MY3L06FHrD/pr9Xq9jFp8+O/dotfrWV28kH1lT/g8jt1Op2Pfa54xZTGB\n", + "4ZkSyIrcfvvt5i81qnwA876FvmtAv1+4BupY01ybIdQHRsc0kGap2G/eOBkfH8+Uv1qtpoQ9eQ9+\n", + "xvabn583tkDnaCjg2+127TfKtvHfynR4QpXKRBEco2SNtc/V75VrHP3Yjhw5YuOc87ZWq9naoEE0\n", + "LMuTTz4JoP8+8OYPn8f+PX36NK655hoA/TntvQP4ztC5SYFQ9r8qeHNsTE9PZ/IleoLGlUrFzYPH\n", + "9x3Zp9nZWVuzdA3musj28xza1RFcLSOcU+xDDepR3+W8vQPX97GxMesTluXSpUvGduuc55jIk0YJ\n", + "cdVSxOzfv999eXlRcaq140VhDYtwCiPDjh49ags2v5udnXVTDOQ5JedhbGzMfqMLT6jgWi6XXafC\n", + "0MlZlajZ6aurq6loCCC7ufJSxPD3XIgvXryYKYPqfXAy0+EyhOd8PyhyJkToHFwul62edNZmItNh\n", + "KJfL1r6cVHnRoYPABa1UKllZQvXcYej1eraxYDt66S2A7TE97DARQueKLpChc2ipVEol9OQz8pw8\n", + "+dL8sR/7MdPMYTsOck6mng7HyfLyso01tmmv18skOi0Wi+6miWDdisXiDyxqL8T4+HjGGVjnHNFq\n", + "tczsyrotLi5ae/Eltrq6an2T186/8Ru/gZ//+Z8HAPyrf/WvAAx3qmXk2NGjR/HHf/zHqe/2799v\n", + "LwLPyZzrim5yWY9er2dl5mfr6+tWN03cTrCt3v/+99t6rol9PfNi6PCsSWZ1roYm5UHR0YSu8xzn\n", + "v/IrvwKgn2qJpmzP4foXfuEXAAB//ud/bv2rqU7Cd4u+kxRhmWdmZjKHJ89R3QuAOnLkiG2eSqWS\n", + "bVrYvnv37rX2CjeswLZrwcbGhrW/FzDAsaHuDXkHPn03eO9HzvXDhw/bRobXPfvss1YW9lGhUMi4\n", + "h8zMzNh1Ow2k8cbJIP0q1lcPQCwr5/LKygpefPHFmLQ4IiIiIiIiIuK9wFVNWqzObYTqPunuOWSd\n", + "1DmPUIqd3ynzpWY176TE79///vcD6O/8X375ZSsD0D/10GmRJ4PFxUVjEbxQTT0BjSJr4DmRjyrZ\n", + "oLnlgLQKLtDfXYc7/EqlYqc5MgOTk5MZBqJarVr5RzU5sd/q9XrmZK6MCtut3W67rI+qWwP9ccIT\n", + "Mh2VSZ2H4JggzbyxsWF1U6Vx/pt0r56O1TRK8NQ2NzdnbaQ5+W6//fZU2Z9//nk3UGEUqFmVp6jJ\n", + "ycmMvICe7tj3tVotE0RQrVbNIVaduXlK/OAHPwig3x9kb8laemOoVquZSYJh8Mpy8r7lcnnHDGEe\n", + "NJiEwSu7geqDeQ7t+hlZHY4n1Q9SFfjQDKFznuP4xIkTNo6+8Y1v7KjMGpTCspRKJbufnspDNntt\n", + "bS2j0+StL5pTj99760uSJMZw0y1AzXgsn8pkaEYEjhVdl/PYE2XJhjnJA/05yjbguNd1huajAwcO\n", + "pPI0Av22oplHncM5B7w8fBpgErovKCMVthmQtrB4OnuelUGTfo+yNg9j94jJyclUYmrWIxwrKomS\n", + "lyB7ZmbG2m1U5p0M1+TkpL3/uY4qy0TLycbGRoZRq1QqFmjDvlSLDv9Wq9WMM/zevXvxzjvvREYq\n", + "IiIiIiIiIuK9wFVjpK7GcyMiIiIiIiIidor3UpBz1wiVtIdtrEZx+p6amjJacTfpQHaayDgPk5OT\n", + "FoFCh8FRFYSBbbOmOp3v5PdESAOrM52nmq1OhKG2lJbHU0Vn+QY57oZ1m5qaMiduTV2hGjFEmIRS\n", + "ozrUjEvql/cdlFA6dM73dLM87N+/P2Ma8BwZPcdnLYvS997YpukidJ5X7Nmzx0wEOjZCk8ggZ95B\n", + "17OsYT1YTq0rzapJklhZRp17w9qcz2WKHS8YRO+zsbGxa9PeTjDqOvGDXE9GxaguAD+I5wBImeZD\n", + "M8kwlW29l85/3jccR6rX5T1DP+NYVidxLzIsfA8VCv8/e+/SY9mRXY3t+37kuzLrwSoWu5rsbrTU\n", + "bGnQgiYaGEJPDPiDPbM9+wB75oHH9sTQ0L/AQxseffA3MjwSLDVktCFIsNSAukWqKYqkim9WsYqs\n", + "ysrXfXuQXJHr7rMiTtybWUy2EGtSWeeeR7xOnIi11967WYlFyL/zeT5t1WQyqcy3rVarEvF7MplU\n", + "pB3tdrviUcnif563YbZSY/3b6v9Vseq70Gq1Kml2VN1i9c15nro2JkqvXZ8kfy0oKCgoKCgoKIji\n", + "2hgps/MVIXbmLNKEGI3jUeS4nR8eHlbcvFXckhhyVsutViuwMgCL6/D8n//850EkB/HtKowS6otr\n", + "1LXdbncpzxiQErKrmDzKlTe20seuCcwGhxfgXZt3y2dAiKliqSjHgpgw0o+Jfr9fCanR7XbDteh/\n", + "jvvF56WYKN4p++fmMjDcnnwPH3OLc4pBEDydTiv9+vTpU+k0ocqOiMxvv/125XcVEJd3dCg3JwcH\n", + "sDseDAZBsIvfWQSsWDf0Qey9UGymgmIQcpESlvM7oAS+KfCYXTWn3TrwjImZZnRzw3fU7ehz5ko1\n", + "1yCThS8z52fD+bGQLmaakVJzDsbGfD7P6jtmfji3pS+DYpoUixaLgaYYrlh5fLlSuAwbpUIP5Vxj\n", + "dl535Wi1Litbxwqp8czH/PuqLBg8xnLnmhiubSGFQeiDAY7H46UM8GarZWvGRxiT+unp6ZV4CbFp\n", + "CWXmlxkdgEXCw4cPQ8C2dZ6PeqSuvXXrVigDFp11HhtsOgPUyxOjOP257IWFMvPCUi304Kny6NEj\n", + "uWjyg5kDSvLz2VPFTJt+Xn311RBEj+GfMZ/Pk+MMk0RdX7K5qs77C8ACTnn/oF9ff/11GVBQfax9\n", + "v02n07DQQmwuDu6Xm1kAfcRjgz258M7hA8QLKbQLjw0fiyYGTsKtFiOYJ9ZBqm/UpJo70e7s7IR3\n", + "cdU4OLlQC71Y+Vb9QK7zQVGLTr94SZlh/LUcZyh1DNfg/eX3mNPH+GerRY76MPNCSn3M8e7xOOTy\n", + "+TZQ5kN13iq/p5Br7ostSlJAnVVAVrP6/o6do87jJM3K3KfKGtu8enB911n8FdNeQUFBQUFBQcGa\n", + "uDZGColo/apvNBpVdnC3bt2qiJwXi0XY3WIFeXh4GBiDq4pVo2j5GINjdhGThWPzrIOc8g+Hw9BW\n", + "OUyUhxIPM03tBeiNRiO0P2IjsUlJUbtKQI1I2WZVtnFra6uys1ksFoF14lg/PknqbDarMFwoZ6zu\n", + "bKpUOxDUSUWpV0AMmtgzWYSKMgOqz3Gs0+lU0guZaZG2Ys/A1v3sZz8zM51yiAEROcf+Qvs0m83K\n", + "Lvzo6Ci8j2DWGPjtxo0bgWXj2Gsp9pn7XJ23aq7O2A7dswTMhPI7kNqpYp56+vRpiFuDschm58sI\n", + "0VNMZ13096tCLtOUMjkyk5CqEwvM1TzmGQlO84Lzu91uOMZ9qeqB35n9UkJwtDM7nXA8N/6Xy6nG\n", + "a8y8nmK2cpHL+CjzVx1UeimVhogdklYd8zifx7V3Poo9r+5Zisn1/ZTT7oWRKigoKCgoKChYE9cq\n", + "Ns+Nrgp3c7Nl8R1yD4EFmEwmyaSL6+zUcoXEOee9+eabYZULhmA8HicjwaZwenq61DY54JU3CzH9\n", + "74vFIjAbHMnY69fMLiLP8nkAMwdgOVBmJW5MCdwZrVYrjAXFEmFMMKPCuxSvz1FMSKvVkm7KHsxS\n", + "8DhQmgy/k+J3IKXD+uqrr7J3pJ5ZYWeCv//7vzczsx/96Ef27rvvmpl+LxQjBXCbIJr5u+++GyIC\n", + "4x1UOrutra1KmAR2UeddIH7n/kW5mLWMhW2IIfabaodUWAt1Hx7PnDDbbHm8q/eQWcrUfKKer3bt\n", + "LxNKY+jHNjMqimnieykBeux8fz92IuH/m120R7fblWJjzz60Wq0kY8R1833J9eDrUqL5WJ3wDKUF\n", + "uyqkxm9dOBo/Bnlso83Z0SuFWN1S9U0xZnVtVTdHsFUmF9e2kMKLB3MFBsx0OpUfZIAHLUK9w5Rw\n", + "79690HFojLOzs2B+Sk0yMXG1/7jlLv4UptNpqO/9+/fN7Pwj4s2Rjx8/zurEVDJUs3OBMrCqqHYw\n", + "GMiFAD5knBmb+y4FnwBWUfoqWebm5mbluPK849Q6eBanXsAiiF9u5fGFReJsNgv9gPtxHSGgPjs7\n", + "C/dOLYp5IaUmJzgqqJQXk8mkYr6FedzDO0OosYQUJb5OABa7t27dSi7W+d4+FYZZVUB/eHhYGUNK\n", + "RLqxsREWUFw+/M3PSi1e1wH6OragUR88HOO2R10wng4ODpbGI4Bn5G7aUqJg9RGp88bKNYNcxpMv\n", + "ZdrLfV7M/KIWUAB7PaMflKccH1OCdtwHc8d8Pq/Eeot5TAJqUaQWdfyvX9hcFqoP2VPSz0+xMYnr\n", + "8a7wnKrm2RRy31k1tvlYrmC8zvlnnTmkmPYKCgoKCgoKCtbEtTFSSDCMFS2v7j2lPxgMwu+cUBAR\n", + "j+F2rZKkxlbFnh1RO/tOpxOei9XuzZs3w+46J1km4+HDh8EMxiJdPBvHcilFZu7AcG1vb4dVdkxo\n", + "7aFW4Jubm5WYTGYXK3g2t6SE8RyLRcU6qoslpMplpsX1e3t7gQ0BWxeLD+XFqAymdr0onccJxtDp\n", + "6Wk4T40jRir0xKp0dWznhDEP0zebwVDmX//618H8yewigPcM49Xs4j3jcY9YYP1+X5o9fb++ePFC\n", + "jkswZHi3jo+Pg3Cb74ExhHJtbGyslcXAQ7FKuVCmKe5L9Mfnn38e3lMO1eGZktzns3kJ7Xd4eBju\n", + "g/vW3S/lop67U1dsDDMDdeY5P/ZjcZP8e7tYLEL7pkyz0+m0whzF2Arch8uMY5hLZrNZYEVxXxUW\n", + "RNWdheNKElDnxr8quC35OcrUueq7hHbh8qVE4TGmLuebp8zqsTHkz1vHfLgKCiNVUFBQUFBQULAm\n", + "ro2Rgv4AK0LsnjgSNVaz+/v74TzsPnZ2dkIuOzAiL168CLsDsDXPnj0Lq1PsBieTydI1MaicSB9+\n", + "+GGINv2nf/qnZnauo/rzP//z2jqfnZ1VooDziniVwKMe2OE2m82gS0m54jNWWakrDZA61+fO4tAE\n", + "jFT0Z5zPfcish9/F8P1xn42NjbCL5HJ6FsBMh2/AMaUBYHZURf1W8L+z5g5jUWmfRqNRZcyA1TXT\n", + "u1iUvdvthjrx+/H7v//7Zmb2y1/+MlpeDuMBJop1UxgPzWZz6R02O2dCFBviGUwOIsqR2lPvA/p0\n", + "c3PzUu8NwGODI83nilb9DllpKW/evBneUw7jkFP+WD5H9D+PxXWZNX/vy17LGh8OB+BZKm4/Pl8J\n", + "89W1Xl+nMJlMpKZJMRy+/RaLRXh/eG5QuQC9A08sbEGKbeP/c31XDarKUGX1keDrxNdKl+aZZEau\n", + "Ni/mRKO+CbnjUjkx5QYCXQfXmrSYqURMruPxuNLpSLFithz76NNPPzWzi06cTCZhElQf/JQQuNls\n", + "Jj2VGPi4wAMqtRiLIbcTsRh69uxZZWJmYSSLIPGy15keYyY9PA9gbyKesM2WTbGpcpldmIbQfltb\n", + "W6Ht1AKEI2njA+ufb2b24x//2MzM3nnnnUqcITYBcvthsckLBR+FvdlshnGpxJ4suMRLuupHfT6f\n", + "BzMVTHDD4bDyETw9PZVmUD9h8OSlTJpcPowPtYAEZrNZZUJT9+UyYQx99dVXlXpwGg2+L8bBvXv3\n", + "zOy8bVOx0dhL7ao91XIjkdctsnyssC+//NJ+8pOfmJlO1eNjoDFUrDezqpeVOq/uA8n1yTWJ1N0L\n", + "91AmGG/uUSYZPs6LKxWfKQez2azihMEeelwW/9zRaCT7xNeNy8dIeSazyN1fe9kPfa7gOtcbj8/H\n", + "tzL17sUWUX6c85jFOB4Oh9nfVe/1OplMpIl91fbMdcIwK6a9goKCgoKCgoK1ca2MFP/LYQuwQ+Zd\n", + "ghcZxiKHr7o7xcp6c3Nz5WjkdStmv8OIrdDBokC8uLm5GcrF7uMwp6Ctms3mUmJnADt9ro9aXadE\n", + "jaPRSO6Qvasp7zoBzmvFv3mmj5kNvq9ns3q9nqSOmYkyW44Zlqoj3xvY3NysMJbz+TxpjgS4vqvS\n", + "7/P5PNDjqaTJ4/G4shtXO3klcmaGBc96+vSpvfXWW2Z2bqozWw4VgUjyx8fHUjAOcFnA3nFoBVVf\n", + "lBFicjbxg3G8c+eOvffee9H78Phbx+SxagTnXKgIztyWnoniOYLfs1w2QYmI1XkKOSb9y8Yv8vOA\n", + "am82f6l5hb8VPjRBbjJiNs9x5HLOxQegjOiPOhOv6o/Uecqsxoixe7lx5NTz2OnH7LwNchwKYt8I\n", + "zJVoIxa0K5Msvkntdls6J/lrV7HyqFANypkoJnTn5/I1q4z7wkgVFBQUFBQUFKyJa41srlaLzWYz\n", + "uG3j31arFfQcn3322UrPqBO8sfaGg26amd2+fTvoVlJBQmPAThSr3n6/H3QfnCcQO3Oczzn04Jq+\n", + "ublpb775ppldrNbff//9yjPb7XbYJcTqrVbrPqxBu92Weh/s4HyeKUaj0ahc+4Mf/KBSXmY60A+s\n", + "R0hF+jar6qXU7vTmzZuSaUQbctgCVRf0jdJmYZyMRqOVNRsMsIrof1UOFi+ntDQM9FW/3w9tyG2O\n", + "HRyez8/gZ6Wew+MB5cbYrruW74Hz0C+3bt1KhroA1mWUVr0ul8FSu1jOAqDu6xk/7i8+T4mDUwE5\n", + "+Ty1y/bXqrky9n7nMDTqucq6EBNk8/P439TzUvAOS5PJZIlRMTtvAx+SIHZffx4z00BsXvA6rHV1\n", + "aLlQlppVn8mOYf5+rHcGut1uJXyQYpqGw+FSAG2z5TyXl2GNVR2Vo0LdNXW4toVUjKpk4SnEyZub\n", + "m6GT8LFRph6YxsyWB4BaBN2+fdvMLibps7OzIOzGfbrdbjCxYUAsFhepU7C4m8/ncjLEMSwI/+RP\n", + "/iS8xH/3d39nZucLQ9QXH6Ber1dJn7G9vW0//OEPl57BE6ny0PLn5kCZJtR9UiaFyWRSufbRo0dB\n", + "SMzOA1gUoA34o8OpBnydNjY2wqKazQG+H77//e/LhRTKDaH36emp/NioMeqFveualwD0MUcY9s84\n", + "ODgIcb1YhJ+a7DGeub3xLjDdz4tnf4z7I/UxNrt4X3lhiHHJC1e0Fd4FJeRHfKo6rBNDKpbFIIV1\n", + "UlKgPzFX8Xks8Ee7YtGuTLxKNKsWIDEzjSqfWjTlmDVy5xJl9ufrvTlPlclflxJur/MB9PdbZVx4\n", + "cyV//FNzSKxdPPyieF0Ta2wxkWPGVddOJpNKLDi12VFeu8PhMLz3qW95nZeicpBJyU0YlxXxKxTT\n", + "XkFBQUFBQUHBmrhW0x4zKrwTAqsAsxqbDTgSut/RcowhrJBTAjOzCxZoOBwGJorDKWCXyKJjPA8r\n", + "6pOTk4rZ5eDgINwbzADXjV3AvSlO7UgPDw8rZs2Tk5PKNTHBcp2w0OfLi5kD0MYpYTT3KzCfzyti\n", + "84ODg0pUbe5XFhF6M0+KsmWwgFzFZEnFqqljmlIuwnVQlDnYol6vV2H8WBjL4z61g8bY5bpx//r8\n", + "gdPpNIxt/ywG9xHat9VqBeYVjNTx8bHdvXvXzC4YKc5RhnuoiOhHR0fhuGIsUmLdOtSxDnUCVQ8+\n", + "hyOMe3Z0f38/zGm8k1bPUHkL1XNxHjvr+LFTx2aoeE5156WgHFqUeY5NNykmR92Px8TLYBhWQWp8\n", + "ctwsZd6MhX7wx9YRm6eQ42gQK1ej0ahIBWJzkWfW2TrETJQPsRIrC5KkY95hWUXMDB2rh3JoUN+9\n", + "nDyHhZEqKCgoKCgoKFgT16qRMlveNZkti/2gQTo7OwurQg7i5XNx5bpMDgaDigZjNBot5SQDsPJG\n", + "GIJOpxOuxY6+3W6HMrNOywvL//qv/3qJZTOL6xK89ok1V971NAepnR7vWBXLwrsK1Fnpznhn4K9t\n", + "NpuV8AJ8D/RlDGhLlJ2vBcPBu3z019tvvx0i4IMRY6ZAue9yW3jbPwuoeRe1qssst7O/ZjQaVQTK\n", + "z58/D3o9hMFQ/c+Ccbw/29vbQSfGz8K7x+J1ZsDwr9dh8Q4NTAhrBxlgp1jTgL5m0a/aVfoMB+wA\n", + "kSswXgd1rIiCj3avWKCnT59WjrGwHOxTp9MJf6tAmww8jxksFQE9hVXHrJlmKVL6Gr/z52PM6KTa\n", + "WwXrrMOq7OIq8BqvmNBfaalS7Ili766LdVN14vkd4HAKXG41blPvugLmp1arFbKKfPjhh+H3XD1U\n", + "Thsq60KObu5aTXsMXlh5c8vZ2VnoHI6HgckLH5iTk5MlIa7Z+QSOa/FhSUU4j0EJ4vDh7na7lWTE\n", + "p6enYdLHZHd6epqk6oHhcBgWAij7ixcv5EJvHeSIDPll4MmcqVwcA5T3D5cf8Gl8+LzT01PplQYh\n", + "M65hkxP+ZpMTx99KxQdTC/hUNNwYFa8+CjmILaTZVGN2PtZyXmiV4DdGTWP84hm5XnbsmAHTrPI+\n", + "w7lmFw4X7JWpYgGlYpeNx2NpcrxKk4dHzrtiVv0QxD6qHmdnZxWzNUdmRp/zO6VMScrBRJnO/HUx\n", + "1HlM5ZrW1XW+PdiEzs/17acWUny/Oi/FqwRHRa9b+PhFf0xu4hdmvAi7TD2UeSvWr5ib67wJU+lb\n", + "uN/UOMLf+G5PJpPwTebnKUE5solwfbwpm+fyVTcJ647rYtorKCgoKCgoKFgT3xlGipESwvEKGDs4\n", + "/Ntutytiv1gMGrWiRqTsN954w8zOI2arWE0ezLao2DfYjff7fXv33XfNTJvGeEeCe+K8OjYCDMz+\n", + "/n4ogxLxxtgnlbMNz+Q2AsMA84xi93j3i2u3t7cDM8f388yG2UVMKZjims2mdA0HO+Hd6c3MXn31\n", + "VTMze/jwYaXter3eUj49My0sZ4aLQxNgp6SElrkmIG4DlUMPwJjY2dmpCPPVeWonXMfAQiDd6/WC\n", + "2ZB3aGpXqZi63FhrzOSaLUeOZnOeNw9Pp9OsZK8vE8r8rnb3fIzLz0mZzc7bHHMFx+RKMcR8b7wX\n", + "KtaaYgH4finGbB3niRSD5M/1z/NotVqyzACzx4o9yR0T6zJXahzG4mHlsB18LZ+vWPI6qPv4svB5\n", + "/FvKxMbXKgbWs108d7CFCN8nzDWxsntWPtZHXh7E7QYoluoyISA8CiNVUFBQUFBQULAmvpOM1LpY\n", + "Jc8eGAtonzhyOFbCsSjquBbggIeKAcNq/MmTJ8ldOzMIOavgRqMRRKb7+/tmdi46BXOhcncxoOvi\n", + "MoExYXaH9U5oY1zry2N2znBAZMzu9EpXpQTK2LGAkdrd3a2ETjBLu8ryfTnXGdeHr1W7GMUqqABw\n", + "3FZ1/eZDDphVo8UzE8Zs2yuvvGJmyznxfFlUvikuH4T3CO7p6wlwsDy0Jcp5dHRUYUBarVYyArna\n", + "wSuWlfPw4RkYa4eHh5VxPBwOo5HvPVLi3Tphb4q1YfYEv3Mfol8Hg0FoS3bfxr1VqAmA24pZVNR9\n", + "XWcHRiyMh7+3cpDg85R4nP+fcnZhYC5i1kaxBVcd+ToXKe1Mnc5JsUFKA5f7vFXO4WfGwPov/55y\n", + "P7BmEXMk5pjPPvtsSbcEeL2xsiT5v1N1UG3JZfX3Sr0r646H3+mFFD64MPesEpUWZiZ06rNnz+wv\n", + "//Ivl44p3Lx50/7dv/t3ZnYRfXk2m8mPG/Dpp5/W3pexymSIRVCdCRIDnhdXMAvwQiplZtra2qp4\n", + "CXHqFP+R4PPYIwzY3d0NbQO88cYbFXH0YDCoJGdutVrhhVBmMr6vvx+3Lybrs7Oz0EYo53w+ryyg\n", + "1IeAoZIcrwrV9s+fP7cHDx6Y2cVCSsXcYqj3Qi2kMCa47Dzxoe737983M7P33nuvYi7c3t6uLKSU\n", + "CTUXvGDlyOt+cj05OQmi1TqoflcmWTa/qvhGHiyMBnhRxLHXkCA6ZaY1W45HpZ7H90VZzfJjmilP\n", + "3ZhI25vsFDg9Ct6ZWFwktZBSH1Kc5xdUfJ5KC6WwTqy32H1QFv+R5jmJ66iE9EDKu48F7bkLxnUW\n", + "AiomV51J0SeWN7sYgyAgdnZ27A//8A/N7OL79PTp0zDfIMacmVUcgtRzX3311eAwBtN4nXlOLdbr\n", + "FrQeOXNXMe0VFBQUFBQUFKyJ32lGKmVKSKHRaFQYDrM8xujNN98M5/3VX/1VuA7MC1a4JycnYdWe\n", + "y0S9TKhVtXKZVuYsH1vI7ML0Y3bBdikTC8fG8VCxo95///0gyAVu375dYa7YdMcMDu4qJhMBAAAg\n", + "AElEQVT5zjvvhOf6+GK8m+QdFe7J4wpmJdxjY2OjIg42s0qEaYVWqyXZJs73Z3a+K1Ju/l6c2Wq1\n", + "ss1BAMq+tbUV6oRx0O/3KywAQ/UXzt/b26uYX3m3BwZrf38/nKfKp5w1ONaXGkd1IUVWjVuzikTA\n", + "bHkXWxf3CfFvWCSO67nuaC/lnMDPVbHAVi0zQzHX/pqYWc+b9pilYnmAn4tiIm0F9QzFAnms4xKf\n", + "WxYgxuj58qnwMLHzVmWk6kzUfB6banEsNZ/wfXPL8stf/jL6u5LO+PALZhffmufPn1eSzceSDqcE\n", + "91y+VBul3j2PwkgVFBQUFBQUFKyJ32lGSgG7e46a7MGrUOwCe72eFDSDpbh3756Zmf3DP/yDDIyJ\n", + "XTHvttbJTP+ywGwR2oj1K2plj90p/uV6Y8cc28VgR4D2Yx0W9B+s08GuYzQahV0HWJ633367cv9W\n", + "qyUj2SNwJ8rHZePoz16D0m63Kwwdh4AA+P98bx/cEteb6fxgDLAJvItKsUn8fL/zqgvF8N5775mZ\n", + "2SuvvFJpP6WlYhYs5UgRqxfGHfrjzp07lfeMtVRgQobDYRgzzJIopozHdkp/w/2BcqvAjrxTX1Vv\n", + "pPqN83DiPBaJ4xjad3d3N7DYeFd5V8zsE8q8SpYDLrfZRX0572edeN33Q6PRWMpiYLbMSKVEv8wW\n", + "1YXayGEaFOpYBRWdvC7PphLSKzG8Oo9/V2XA//G3CgcRK5dHnUs//uY2quv/VH/hGFtimKlV1/g8\n", + "nSofrr+PqifKlnJoqGOalPa2Dv/mFlJKtAjwAEXH4QPe6/Uq8Yhms1n4HdfGooun4rnUwaeDiZkq\n", + "VqXvY/CRxXnQcvoOTzVzGSG039zcTH5gldlDCWhRpuPj48qCYzQaVQb/97//ffvNb35TuY/yJgS4\n", + "3fwz1EszGAwqomq+B5vfFFXvP9aTyUR6KUI8jvQHX375pTR1YGypyYSP+Y+cqhsnFAbFzu8MFjvs\n", + "PYdFFYvcMV6+/vrryuR1eHgYhOB4b5QnqUrZwyYbhh9rPllq6oPB9VMTceqjn5rAUx5s/Hu73Q7v\n", + "nPpQQZj761//OhzjDYiK9Kw+GD7mmkooqz6uqXb08GOqLtJ3ykTF5r6UqUu16VWZ6fj9Td2TF1ne\n", + "I40Xk0pEDijzZsxElbqGn51rwlLjjuMwKe9fIDebhWpLfoafKxeLRUVqw04EyoOQr/UyCH6GQt0C\n", + "aS3B/spXFBQUFBQUFBQUmNnvCCO1vb0ddmOgC2OiOM8IdTqdEPUbu93T09PgRpnKw2Z2wVip8AJY\n", + "oe/v79dGaY1d2+12Q3RvPOvRo0eS+UL5YZYyu6gvu/EDygzC9wFisTtUHq/ULhYYDofS9d7vdnin\n", + "DBPr8+fPl9zFAew6wMopNgrXeygXdsXqecr5+Pi4wgLOZjPJtimRtBqjKXMvmLputysZBNyPTZSA\n", + "ElJzvkGP0WgUGDDg5OQkuOdD3H9wcBDGFP7tdruVsAuj0UiOc5QV4/nRo0ehnTnZtN/tct3YNOb7\n", + "rd1ur2VCV2J+gHfvPhxInbs1H1PZAvh3/7zf/va3lbLgmmazWTE9q919r9erMNo8ZlNmXz6mGHYV\n", + "G4l/U6Jvz4Qwc8HsDtfTg++bem6KTaljmoDYOX4un81mYeyo8AE8R6SE9Fw3P17UmPL/XzXW0qpm\n", + "Uu6v1HvG5cCcuVjkRUpXuSNVrLIYY5qKgK7GTkqQX8fexVAYqYKCgoKCgoKCNfE7wUj1+/3AwoC1\n", + "YRdhDqDoV+gsZFXanBSazWYycB6eG2O1lCsxmDWIeReLRdj9gYkZDAaSkfJB0HhlrVgefi7vSNUu\n", + "AbsCtKliRcyq9uXxeCx3u2rn6Hf/s9ks1B06ncFgUNlRDwaDEBKBmT//3N3dXdkXGBOsMVG7DJ/b\n", + "bTabJYPpMXLchpvN5lLgRNzPB/3s9/uVIJnj8VgyUYASSONfxeSMRqPwPjBz5cfW7u5ueAdwP6UD\n", + "jAm+0a8qij73S6r9WAyrBOHrINfNW/UXkBK3qnHCbKXSXymWVAU+VGJZL2L35atzhcd5eF5d7r7U\n", + "ferOVwyxYkWU/suzT3zey9RSqesx77BWyj9Pab5i8GOM5walkVJCdTU+VXlic7TSCa7CzJjFvztm\n", + "y98VLp//ruQ6G8Tg20ONNYa67ypj5ju9kELljo+PKyagg4ODIBiHMPbs7KzSIavEmoL49oc//KGZ\n", + "nccOeuutt8zsYnCw0BaINTgWf1gUzWaz8LGEuK7RuIiNwyLwlChQfUhxD6Z72bTHiyI/EXe73crH\n", + "dz6fL5kzUBZ/b7UoOz09rZhOYl4n/kPFdXvttdfMzOyjjz4K3ngACw+Bg4ODihkr5lGlYmh5cTiX\n", + "zydI9lBtnlr4YEPw4sWLyj35I8a/YSHIC2XfD3w+C8L9R7rVaoUxyOmSMFZx31ikdi/qn06noY3Q\n", + "l5yMmJ+L8nP50FapJNgcQRxjcjabSYE/93WK8gdik7Xqw9Sky/3hP+zcNw8ePDAznVRbtdE6UMme\n", + "UQaex7hNvYA6Nxq4ijCe+7FT1/DiVC1A6kTpVyVCT8HPmbw44Q2YlwKocaxiS/nFTu4CYNW+8/XJ\n", + "QU6MpU6nE37H/D0ajZLOUrzI9s4VdRuCmGNJDi47Xoppr6CgoKCgoKBgTVw7IwXWhnOyYQWK1ex4\n", + "PA47VbBPg8FgiYUxW46/oxgY7K7n87mkrvEMsBofffRRZfWcu0Pknbxa7eJZ29vbYcfCkaaxgsd9\n", + "vv76a/lsmMbAcLRarWRsn06nU2FjZrNZpYwqz5iKq6Ncq82qkb4nk4kM38AJaT3YjIf2Urst3EOZ\n", + "9TiaOO+e1H3QlooVUXVjtlNFf0+ZhXAetx/aZzKZLJmzAIxLDpOgWEOAd8qeqeEwCQhlofD111/L\n", + "fsNz1ZjEs9rtdvgdJr2NjY1K+3pWyUyLXPf29gJjxjv6uthtyoRRFyMI9/bxwWKOI3gu95dPAM5l\n", + "ffjwoZktm7KZZcN5uAe3fS7Tw2Xx4yQmslexz1S4gjqxeuy3XHZJsTbqeo7+zc/KNQGlGB2+X6q+\n", + "aFsVsiOWx06ZAFNmwboyMK4ipyDDf0+m02lybgN4jLETUIq55Pv4hNyrIMUGAzEWUJ1Xh8JIFRQU\n", + "FBQUFBSsiWtlpFh4Bkai1+tVtBbs+g2cnp7W5tgCFCOhtBTYKf/jP/6jmV1uZb+1tRV24eo+OHZ6\n", + "ehqYEDArw+EwsAA41mg0QvlQj16vF9qIhcq4Rj13a2tL5hlk7YTZcpBJFjymGCnenfi+2draqujV\n", + "er1eUsOGHcne3l6yLRH00efji0HtslkMr8S3vFNRZVYBOXG/27dvm9ky8wN2iRkJ1uEpRgp9o8IZ\n", + "4Hx2rsC/XFfWNngWha/Fb0dHR0lWJCUYZkYKUGzffD6vnMfXpoTlHKzVLB3WgJ+XgpobVD0Vg8Tv\n", + "jNITesZsPB5XtCDcD1wmxban6sd5y9TOOxVgMSc8hD/mHTNiYmc/TupYI3UtwAJ0Pj/X1V397c+r\n", + "Kx9rpVKi7pQYPgdXoftKtWUMSgdVl1PSQ+WWBGJhLYBVv8NqjKl71913Fa3ZtS2kms2m9Xq9SpqK\n", + "09PTZITcq4L35FosFtkRw1NCO5hdVN0YTN37Dx5PSmwawzXwYHv+/HnSG0t5TyivDrUYYih6VJkP\n", + "UgLqFy9eVIS7SvCtoJwIGMosiDJPp1Mp9lTicbQXv/R8H9zXv5ztdjv8riaW1Edd1WsymQTTLlPi\n", + "aD/Ul6OOA3UUO+4xnU4r9RiNRpV2iaVlUR/adSf62WwW3kPe9HjTWGzS5jHrY/twjKK6CdG/17km\n", + "QOWAosra7XYrTgF1805dvDNfN+VcoUwnLAQG6kTuPIekzEwpMx6b3bgNUuYetZnha1GPXJNn7gIu\n", + "FzyvKC8xBRXDSS3guF9zvoOxBVJOzCi1wIuZdlMLKN4Y4J7Km1TF/UqZ4vga9S0C1LXcLura1P1y\n", + "UEx7BQUFBQUFBQVr4toYKezEFLvjV5TdbndJjG6WTykOh8OKmYR3W0okWnc/mM4QioHj9OA+z549\n", + "S+40wXpsbm4GAT2XAfXl+E5gAbDi7/V64T54VizXn0okiXZRyXd5J6LYJ6azwZ4wM+TDVRwdHVV2\n", + "QcqE0el0lkwmqToBqaTJyq2dr+EdiYoOj2tYcI3o3xDDK8cGs4udNIe68G0wmUySZhRmx9C+aNNG\n", + "o1Fpm8lkIqOsA3XjHGXg91IxFygXx4XyDEi32802v/txsFgsKu0xGo1kOALeQXqTA7OFDMXkpGLZ\n", + "KCjhtsqHB3D+SoCZCG+mN7sw7Y/H41A+hH158uRJpYwxd3lfXy4zv2/KZJPj6h4z8cZYqdgxFWqF\n", + "6+AZCzaXpvor14y3DurM3P5bFRO2qzhS/FvKrKmYsFTMKDUXqWtjcdMAHhucqQDwmQH4+pRjSMyJ\n", + "KSWTARSLphwQlFRFHctBYaQKCgoKCgoKCtbEtTFS/X5/yR045ZbLub2wE55Op3LXh92aj9RtpsWj\n", + "uUwUcHJyEq5Fjjyzqpty3U4cO3ne0TO8PqzdbodngMHqdruBfUhl6479zs9CnTzDhefgmNphQBsF\n", + "PQ/vCNAOzWazwp6wfkllB2emxusbOOBhXRRmXJtifFS0cw4lwc/wfdbpdEJ7gZEwu2gXMEkxga+K\n", + "Xo1nKH2SdwKIQeVGU+NAaRrYpdtfM5vNkuOJGRaEN+E8gl5ErrCxsVFh1E5PT5fCfKAsPBa91k+9\n", + "3zGBstpxe7aw1+uFvlbl5zkJ17KGB/2Z0qpwm2Pczefz8B5ytoXcgIw5u2ylfVFMSAyqTn4e47EY\n", + "Y8/4fF92dnzx166qqX0ZzFSK+eF//XzGY5LZoJTmKlek78uz7rVKqM56Qu+sw3kw8S6YVa0Bqt04\n", + "JMqqfVMX6kC9HynWtW6eNbvGhdTOzo4dHx8nBdkAT6iYxHZ2dsLEgt9brdZSdHCz+gXNqmg2myHi\n", + "Np71+PHjyuS6TiJVhlpg+U4+OzurJC3m+FqKlmUoQbMyb6Fu6qPa7XalF5k3zymwaFWl02HvTbXQ\n", + "ZrG82TK9rBZN6gXCh284HFbG4mw2W5oAzM5TpqC+7BUFKFMXMBwOK/2q4uCYVYXlDNzj9u3bocy8\n", + "2MX7gEXiZDJJmj+U2aPOI009F0CfjsfjsLFhB4gf//jHZmb2zjvvVMqCZ7HQnydwbIxQt1jKoxSU\n", + "J5UysSlvQk6wzB85ZSpUqZxSZmg/0fMxNoOzeVN9ZFJxn9RCnkW/qs1z5rJms1k5T4212AdaLYL8\n", + "MbXYUAuumHlL4aoE57iXX2Dw5smXiZ9fJ/5OPZPBpmxV91wRvFrkpNqVI9uruVxFelfjiufUnG9I\n", + "rA6+nnw/JeBXzkSrPL+Y9goKCgoKCgoK1sS1MVKcEJbRaDSCe7/ajWO1qFiQ6XS6FA37KgCzB0Sf\n", + "N27cCGVAQlY2H8ZMYh5Yeff7/XC/uojaKbDbuDK/KVdTNkNgh8/snxdVb21tBSaCV/dgSFgYraDo\n", + "U880qThIKhq7Ss7L9wNUPB/uD5iKuO3Z/IK6oP2YUWLzlxIZ+/68devWUkRrs+W8hNx+nmlUrMve\n", + "3l6ITYU6qVAMzDTwOPDJkhkY70qwzjS+2uEq93zG97//fTPTjBSzCn5ny+xgnQOCmltUH3H5fWLl\n", + "mCu536GyCaPOycHfj0MnpHbqXGY2l6fMFUCdOTU3hhIzwH48sgmQy6DMborNULGnUuwTn5NryrtK\n", + "9kmBGXZ25MHfbKb37JkyAbL0Bf/PKUMqk4LqoxSU2a2O3eP5lcOtmMVDwfhvZV3oEYXUu6fqYVZl\n", + "gWMhRepQGKmCgoKCgoKCgjVxbYzU4eGhbWxsBME2VutHR0dZzEyuW3MM2J0qd2Cg0WiEXTCYi0aj\n", + "EdzZwc7EVtmplSxE4sfHx0GQe//+fTPTO3VGXR0Vi8DaIaWD8qv1wWBQYfdOTk4qq/7pdBraklkU\n", + "9A3vNNQx1B19PhqNKvWLBWxTeg7fFyxeV6JBfkaKQUQ5nz17VtGWLRaLpbARMbAGi8cu7nPnzh0z\n", + "M/viiy8q4nU11p88eVJhMXhMqGCZnCcQ9WUdoWpzP87q3i1mZxRz9Itf/MLMzP7gD/7AzMx+85vf\n", + "VM7pdruV92c8Hof5ggXXCnU6FLXr9P0ec/P2z4gJ2nN38oByQEg5SjBSfcJZCrhdlMbP/6bc1lV9\n", + "WSfGZVIsi2epVD66Otd+f34ML5uF8s9SWjTfd61Wa2UtbavVygoUyfMiwzth1LEsueXi++DeqPt4\n", + "PM7SKLdarcq7t04IAi5Tzjsf0455Z6ccDea1LaRGo5GNRqMw0XKcKCwEMGlubGyEidOnSWFsbm6G\n", + "a9Axjx8/Dg2S+jhA/M735g6uixgdq2MM/FLAC++VV14xM7M//uM/tn/5l38xMwtJWs0uPubodP4w\n", + "wyzRbDZD+ylPCdTLbLkN2Yxmdi6qxkvAJg+fTFXFxmGBMoNfMLPzfoX5lhPxoq1TCxtVDyV47ff7\n", + "S6YaD743Fi3qeSrGF8quKHQzq3isPX36tFInfumxoGJRemrCe/78eSWBsvJE4aTUPA7Q13gHeTJh\n", + "8xGQKx5mU6p6B1B3jPsHDx4EkyfAnppsfsUmJmby9AtLjv6uki6zuU8lYlVek2yWNztve7W5UaZE\n", + "fz/lPGFW7RuFuo+NMhWizGbaEcd7O6qo7b6seIZf/K0iqlbmOyUYXnVR/21Cvas8J3E7+jZaLBZy\n", + "sasi1tdBLVRznE3UoqNuUcJlTS04riKCeCy2FFDnpejrzrIPhbrvO6OY9goKCgoKCgoK1sS1Ji02\n", + "q8ZT6nQ6tr+/b2YXMaFOT0+DAL0u2jV2f9j57+/vV1zij4+Pw3m8a/c7ina7XTEHnZycJBPtArGd\n", + "HKASB7/11ltmdu7WztGrcb4X3/Num0XQinFSMZkYaAc87/PPP6+Ib/l31K3T6YQy8A4Y7Z9KxMrl\n", + "Y1G3Mi8BLNz0OyC1I5xMJrI9AG4LlWsP4LJD4K12fCqvHfebL+NisQjjHQzN/fv3Q5tz+Xx/LBaL\n", + "SjgFbmcwYjzW2ATJzCvup6Iwe3f/mPkAQN9PJpPwN7C5uRneHySZvn37dqUN2CwEppiZutjuXJkD\n", + "FXwU5tjOW5lg0G48DyjRqh/v3DfsYOCTqquYazEo1snPd41GI5wHlkw56yioOUzNbdxfHOvJm+fM\n", + "quzUfD6viKE55InK8Zfjkv9tQ4UKaLfbFTd65fwRw2XqlGs+VOJ2FR6D+yF1T8UGs7xCsWNKpuHH\n", + "Tiy2lAqD47/bsXAfntnm8q2SmLkwUgUFBQUFBQUFa+JaGSkVeXsymYRdKf41u9BJYAXZ6/Uq9vyj\n", + "o6Ok0JqDjGF3j5WtCrVwdnYWrsV9T05OJBOCnTfnw1s3KOijR48CI3X79u3wDDALSujNu1+1ggaj\n", + "x5HZgXa7vZS7CoBu6cMPPzSzc4YD7cTsCHYEKXav3+9XdugqOzjvUtQuQoU8AGJRaTmgqIcS+MbE\n", + "tLFjHHWaGRCM31SQUFWXjz/+OPzNjBMYLhybTqcVwTDrknhnpVz2lfhf1TGHpWLwe6aCyHo8evQo\n", + "sGcMH/7g5OQklNUH4wWUhsbvYnu9XqUvOJI6n885+8x0SBF+bkpzocIunJ2dVcZl7B7+Heh0Oknt\n", + "Jr+XOKbaX2ly1HOVzk6Vm9kWFcLAa3jUM9V7ycFBmQFkFit2v28LfhywO30qMKYPdQAoIX4KSkvF\n", + "LD+PbdVeqfx2zCqpnJb4FuF7l8uqxnLjpebcVLBRHicAtws/y89PrPVbhQW8toXUcDi0/f39MLlg\n", + "kRATrHlPvmazGSZTjuCs4BOxDofD0NCxFC0AOow/Xv63drsdyoKPXb/fz0pa3O12bW9vb+k3TsSJ\n", + "wcjJbTlBcm5U5y+//NLMlhdDQMxUg2sAfjF4MGJRxX3kJwVeNPEAxQKZP4hq4eHp21gUZjVBqUi7\n", + "AMevQh+jDxloZ6aruc04uWzsGYPBIEwyWNi+ePEi1F1FmmeoTQLGHcrHi3bc58aNGxVTspqAYp6w\n", + "7FgAeC8gs6pZrdlsVjYR0+nUdnd3zezCvNTpdOR7iL7m89G+d+/eNbNqm6A9UpM4L2i4H3w9uK+5\n", + "vVKUP8aO8oiNxT5jj1Cc5yd9vpYzF6Q+GGrhE1ssx8BerznJi7nMfC0/yy986tLQ1Amk+T7499tY\n", + "TKXM22yOUsJyJa73c6YXSKv3S22C/AJVxelScRxzFw5q3Me+RXgum9KV2W1VE6aKD8Xewqm+UWPH\n", + "l2dVFNNeQUFBQUFBQcGauDZGyu9A1WoWq9idnZ1K3Jj5fB52fWr3yeJKL1DlyLxq54Jd5WAwCPcB\n", + "28K7CaYAPZ0+n8+TeQRx3mAwCLtirI4///zzsDtNCdY50rg/bqbFsF78CyiRIdoNrBGzC7xz8Kaz\n", + "2WxWEfNzH7E7O8rFkb5Tu4QU1a12M7FQDB6xaNeePbl165Z99NFHS+ft7OwssQkATKOff/65meld\n", + "o9myE4TZsiCb2TmVQ8u/R4PBQLK3Htwu7Dig4K9nsbESfaLPOSZYKn8dx/9iUzXGG9qRBdKxnasK\n", + "t+DP5fKr90eJYfm9SLFAKTP+cDgM/Yrzu91uCHHCbIHfUTNr7MXLsboqti3lIh5jkFLxsvgeypFC\n", + "nacE43Vxjfy1gJoPlCj920BdGAf/LjC4zAA7hCwWi8r7qQT+ufKBVqtVYa44Qr8yg9WFQvHncYJv\n", + "duqoG7cp5AjAlfQgxj75erCJ1fdbCoWRKigoKCgoKChYE9cqNq/TJ2F1XRfFGGBRLQttoV/h4IVq\n", + "dwXdEv5tNpthRa3E0Cyq9KtYFd6AAXfvO3fuhHpCk/TkyZPKCr3VagV2BEFH79+/H9oGuqc7d+6E\n", + "Z7/33nvJMgDdbreywue2VHXnnT/KD7aLd9Qqhx8YE9bGcKBAr+Ng7Q63S45mgwXPKq8ew0doVznF\n", + "eKeJ83kXyG2EXIVgpDgsBPprY2MjlIcF1D7MBK5nKE3T8fHxUnBT3M9rKXg3y/2m2tSzrRwdn8/z\n", + "u7tY/jXf/tymKhwBjx28w2AF9/b2loLW+h06u9b7gJtmFyxcTDOSE0hQ7aY7nU5lzKqo/ePxONvN\n", + "2ge0rQMzUeoZXpcSYwWg4cS8wnVj+B08a3yUAJ2vyxVSqzJ7/U9u8ErFgq2q0fHP9VGzFTOlHCBU\n", + "GXw4BT8+9/b2Qt3V9yb1jJiTjWKacqPse8aM2Vnl+KCekRqfijGNISWaBxSbqcZijmbq2hZSfgJE\n", + "o3W73YpZiL2TMOkvFouKEHQwGIQPMhYYL168CB8WfEgPDw9D4+CY2cVAwMd9PB5niSCVFxBH1FbA\n", + "Qur27dv29ttvm9lFEmSzi4GFj/Ht27dDe+GlQZodswux89nZWZjklGj6yZMnFU+/s7Oz0L5s4lML\n", + "j1RiYpWskidzb2rggY37KTH3dDoNf/Nix0+EPIGyByH6GmMntpDy97tx40ZYjOBa1UcqdY7/218D\n", + "8EJKxdoBOIYSwMJt9lz1/X52dpZMDYG2Ojk5SabRqaO4vbdLt9utePKw4B4YjUaVKPDsRccmPbyj\n", + "uEesL/mD5idQZcaNTdAs7DZbTreizsM8oCLIpxK1+//7cVznWJJajClzSizhsRrH/iPNkfKBWNR7\n", + "tUhLmb9yBNyx4+q+CjlmxDrkmiOV156aF2ILTL7WX6ekFmpTr8yGjLrFi/8tBv8N3Nvbq2QL4bh+\n", + "LNfIMffVLXI57ZtPBM5IediWOFIFBQUFBQUFBd8yro2R2tzctF6vF1y0seNvt9uBreF8Uz42xWKx\n", + "CAxHKo5Up9MJrAK784PB4fg1HGoAz0gB13Y6ncAWYQcZE50iWjvq9umnn4Yyg+3hcApYFX/44Yfh\n", + "PI4nhGOIO6UoWzPtQs4rbuXiXhfXBPdQK3awTsx+eepXmZJiiZRTJifFnKFMm5uboSxKaM85Hjm6\n", + "utnyeEHfMAvIz1NhHBC5m9kK31Y8TvD8/f39pRhqXB+z5RheYGsePHgQng9TIsOLUVlwnTIBdLvd\n", + "Sr5JxY7x9Th/a2ursiPk+mLMHh0dZeegY8bKrMpIpUyO3A9KQO1Zz+l0WhGvc7vx/VJOIXUxppRJ\n", + "kZ0vzJbzgqlwH/wuY15S+RfVM1WIhdRuPMaq1ZmpAM+OqvAHKkRATJDtn6VMgKpMV8FM8f2azWZo\n", + "N2ZnPfPH5auLE5UKj6CsAvN5NR9hDL6NVMT6xWIR3geO25gy46LubHFi+DE1n89lPMTckAiYDzl+\n", + "nnLIUPdT8QmV41UdCiNVUFBQUFBQULAmro2Revr06dIqlv/Fbgw7PkTW9vCRmRViO0XsmrHD7fV6\n", + "Szot3D8VQA/MWbPZDLtrMGwx7QY0T9/73vfM7DyKNXadzJJhNwl9AjMAqk64B2tulIs9ymum2Sve\n", + "5XjXcK9rA7w+hHc2zEigLihXp9OpsGMciZwBBoL1Muxm748BJycnS3nNPFRwTdxjPB6HfuUgpriG\n", + "6+1zqJldjAVm+1A3pSEDsDtjjEajJS2T2XnYBTyD2yVHw8N6GMU8cvgQ3x+z2SxLK9dutyU7BvC1\n", + "nuFiBpOZM896eSgdkRLu+x01sx1cLp/fkN8Z3tmirEqXwno9FWzW91e32w3vs9qp4x5cV37PvK5L\n", + "uXQrp5m6CNd18EwTu9grMa/SSPH//Xnq/BhbkcNmXDY0gi+f0oHxcWamUkJ3r/nCNSlrQF19U1Hf\n", + "/XjxSGl9+fmexYxZK/x5nIOSx3uKoePfUuz4qsdWdWYK59ae8ZKAj5SPOn10dBQalTsW52HxcnR0\n", + "FBYMKnZMCkwlY8Jqt9vhYw3zW7vdDpMqR2F+5ZVXlsp8eHhYmZhjiw6kfGH6HfVQpiIMnNPT0+SL\n", + "j84+Pj6WHc8xiNTg9gsQM7PXX3/dzMw++OADM9NU7Ww2CyZWtBGL79l7z5vO+GOOMqlYRhwLzD/b\n", + "TMcHY9MIyscfdTYrmZ2bobBY4jGJ+/EH1XuGsicKR6n3wmieWFRsLuDs7Kwivmj2V+EAACAASURB\n", + "VOZ6AgcHB2EhVZciKOWJwgtg/3FQmxRlpsX1ZpZ0duDzeDGBscHehXhXPvnkk0odYqY/H+NNmTrU\n", + "woIXjKlJmql/ZWZWYE9EZRb0Hxa+Fy/QeRGMcnoxv5lVzMKLRTXNj1n146rMSBxvjM/z40nFh1Im\n", + "ttjmLmexxP2mTErqud82lAehL19sMQlwmynPcCC2qOeUOmZxc5+Pws/nqIjpKacJ/q7w2PHv+mAw\n", + "CPfkxPa4ht8Vv8DnMcZm+NxUNFxW/BtzkjC7eL/Vt9GjmPYKCgoKCgoKCtZE7VKr0Wj8r2b2n5nZ\n", + "48Vi8dNvjt0ws//DzL5nZg/N7L9cLBbPvvntfzSz/8bMZmb23y8Wi/9b3ffg4MDa7bZ98cUXZnax\n", + "+uv1ekthCszO82q99tpr5wX+ZnX429/+VuYeAyOQSpyoVqHPnz8Pu0/shPf398P1YDV2dnYCW/Dw\n", + "4UMzW3aJrwPYLlz75ZdfBraD3Tdh8sEKfWtrK5hTcEzlZONdMpuIWECvqFV1L4SQYLoVfYMyTKfT\n", + "ym6czWkq/x6HI+B+N9Nmlel0WjHlMLujKFj00enpqd27d8/MLISZ4PYA+LlsluSwDDH0er3wbG7H\n", + "lIs4t61nVL/66qtK/kXFJH755ZfZiVpTCYq5jjhPRfeugw8zETO/4V1SsW/4GvRDyozo4XeTZlWW\n", + "gENiABxiRZnBWWiPuSUVY4qZK95Rp+KDpVgUdX4saXFdKAQzHRaCx2uM7VD/9+crUbWKh5QSoMcE\n", + "46k4Umwa8wzXZc14uVAMXI7wncFmWuVYAHS73fCu4dul2CduI2a4cA3/5p1SWq3WUp48fz+WvigT\n", + "Me7jM0T4uvvk6yxoT7Ufh8HhdlOJ1v3fuWMix7SXw0j9b2b2n7pj/4OZ/cVisfiRmf3im/9bo9H4\n", + "fTP7r8zs97+55n9pNBqF9SooKCgoKCj4N4laRmqxWPy/jUbjgTv8n5vZf/LN3/+7mf0/dr6Y+i/M\n", + "7D8sFouJmT1sNBrvmdkfm9nf+vuOx+OlwJhY4Q6Hw7CKxe70s88+C7tAFueCscCOlfO08e41d1eC\n", + "50KT8dlnnwVmAEE9Nzc3w71ZP5HzjFu3boXyoT4cxgHsjWLaTk9Pl4TxOWCmQwlJ0W4xfQfvQAC/\n", + "44+5Pe/s7JjZclR6r+dg9kHtvNCm4/G4sgNi3ZTaMWCctNvtCpv0gx/8IER9T0WLbrfbcvcMsA4r\n", + "pfvh37w2i+/Luijo0aDH+/zzzyuZ1Fk/9eqrr5qZ2fvvvy8ZIZQL/aLa/vT0NDCOHFLEg7U+PO5x\n", + "DXSMHD6CoXIGAsymPHr0yMwuWObxeBzKF8sfh3syu5TSSLHeTeXQ89fyO6+ip/M9/LX8f8xdPGcp\n", + "V23WpfjycRgHRioXYIrdiYmDc+EZiZhYOCVAV+VjxkkFFvXn898pQfs6SM3zrL1VjFRKy6fuydaD\n", + "drtd+X08Hof3mJ/h9bp8DH3D+iVmnHzfcfBVfr7X1XEfcn95J6FYtoNUtH6+rwproFhoAGXh8CEq\n", + "3AefvwoLD6wrNr+9WCweffP3IzO7/c3fd2150fSJmd2TD263l8xkKPyLFy8qAtzd3d3g7cYxYTDI\n", + "MOGaVcW7N2/eDJM+04o5mM/nYXHzxhtvmNn5x/Nf//VfzWzZNJHzkh4cHNjf/u158yDG0DpYVVxv\n", + "tvziqphN/jwW36LNX3vttZCaA1D0/GAwkGl90Df8oefFEqBMLH5ws9iZP2JYNOGDd//+ffvVr361\n", + "dO17770XrucX0y9AWq1WxTNwY2OjshBkWluB2wgLE9yXr8PCiGM3ceR9tAFoch73/DeuVR5fapxy\n", + "xHmMd3aG8ItYHkO4H8eWwgIzltrJxz7jRZH6kLOTg/9wxMxOKfF3THzNHy0z/Z61Wq3wDB5rqcWL\n", + "ArefMon6j4NyvJlMJhVnHV+GWB1VdHKOv6M2T3VQEcZ9GVLiapSBy+nPU+Yjf5/YgtA/e52FVWrR\n", + "3u12K9H9+TxuW286VwmBWWzOpi6+r1rksJeoP0+Vgd8VL0DnMqjYWMoRgNveb8SUGZwXL6lFDpvL\n", + "MbfxN8SbIPl+dbHU1LFVzMKXNrstzp+SetK3Y5wuKCgoKCgoKPiWsS4j9ajRaNxZLBZfNBqNV8zs\n", + "8TfHPzWz+3Teq98cq+Do6CgI41qtVtid3rhxI6yQeXcCQTfvXr076HA4DKtm7KybzebKTBQDK3O4\n", + "zk+n02RsnBQ++eSTJXPMtwlFf7KI1+/WFFu1u7sbGCkOz4BdB5gS3h3zM9BfHGfIiyXNqmEDGNiJ\n", + "PH/+XO4YwKSg/DChmF2YnJ4+fVoxxTWbzYq5qtlsVsxQMdOH2lkCuAe7sHMCXW8W4l2REmTz7z4p\n", + "tIq8zQyHGn+oG8cgw66u2+1WxkIqvAZfW9dWKTNSjGLHvVfJg8X3NFs2Q/BvGFs8Fj1LqXbb3OfK\n", + "8YHHKccoA5R52TMvnFicnSxwDTO0PjMDm1PqIj3nsjQpdkeZ7Pg6z9DMZrMlM2nsWSr8gQovECtf\n", + "LsOQy1z5Np1MJvLdSNWpToCeastYuXwZYv2ryuXn3FgePCW18KwoM+sKii1KMY58nOcndU3KEYTb\n", + "1PeDMs+amf3Zn/1ZtB5m6zNS/5eZ/ftv/v73ZvZ/0vH/utFodBuNxvfN7Idm9v+pG2xubtpwOLRe\n", + "r5cVp6GgoKCgoKCg4NtG3UIqJ/zBf7BzYflBo9H42Mz+JzP7n83sPzYajf/Wvgl/YGa2WCz+qdFo\n", + "/Ecz+yczm5rZf7eILJsfPz4nsfwOo9VqhRAB0Eaw/oOREoICsWtzgXIhTENKe1GHlI5mFWD3dvfu\n", + "3YoOhtklDqbIK2+1WldaC3/vBw8e2G9+85ulYzdu3Ag7cxZ443lgM5Ruod1uV/qMA3cyMCaU+Jnr\n", + "4YcbhyNAoEJ2/QVYjMguwF7LxGUDG5QSGNdhPB6HfoIQnFkoNWa47CiPF7Hz3yqHFgP3uH37doWR\n", + "2traSoYd4KjIGC+KsWXdBvqIA7Sy9tHsvN6pkBc8xlO7XqU94eO8K/ZjgstQl3uOtSy41mv9Go1G\n", + "hS1oUFgLJYzm99LvnpWbuUJsTK4rvlb6L1X2GIuCtkf7sB5KMbp8P8/aKr2O/93fpw4xkXzsHDxL\n", + "MYopcf9lwf3A49MzfrFxj/kLv08mk2zWy48ptjgo3Ss/14c6aLVaMrMG1zNWlti7rxxMUnMzBxNe\n", + "p38aV9WpKz200fhO6qbUAsN/oNrtdvioo9NzzXW7u7sVT0Om5/GhZ/MlC2BxDUcxr4MXGTLYvKVM\n", + "EjjGL5wf6CwyZvOWf8HZ0wtQ5pu9vb3wDKaZ2SzH1/NzzS7Ekii7asuYOcinAzGrmnZUmfljjmdM\n", + "p9Ng6sRiTsWM4kUOFiKz2Sz0w8HBgZmdC7e9F1OsHj7hLR9jESmAttrf369sPLa3tyvjmydwvB+T\n", + "ySSYVZW3Hp7BaYHQjhwZHtja2lpamJvp2FD8/jBVrz7saryo8+oSqObG7vKIeQnlfrwAHsd+TLfb\n", + "7byUFu12xWN6Pq8mBVZQIufhcJj84HE7e5MOtylDtYt/Li+kVPmuCle9CEo9I7bhVot1IDUmuT14\n", + "Y+jNzLGFr89iUCd8BzqdTph3eA7xbcmbZ37X/YJrPp8HSQnPY6rOfrHOi0T+JqVSSvH50+kUdZSd\n", + "U2I8FRQUFBQUFBSsiX9z4iTv1t5oNLLDBaiVrRfu3rt3L6xylZmJ4dmMZ8+eBeE7wjlgR8/nv/ba\n", + "axW2gXcF64jdsZJnFkslccVqfTAYBEaD64nfseI/Ojqq7KCUyZDZEdRZMWrPnz+vxH3q9XqV/GHK\n", + "BNjpdAKboBwMVDJN3p2AieJdkaeO1Y40xuj5a3mXpXaVapwqsyXvLtWOSjFVKQG/FzEzzs7OKgwN\n", + "twGL3THGMF5UfC0exzzmPCM1Ho8rOcMYbE5hNgNscZ1I35eBwfm+lPBUxdABeN5JxZHiccCyBrPz\n", + "d8uPBdXXnBQYmE6nMqaZZ67YxFoXAd2zHarNYm2rGHH/3HXi9ii8TNbo27Tc1AnQGcp8lzJD8hhK\n", + "idL5HjlyFlW+2WwmrTX+3LOzM5m9QM1t/pvB7z7PFxhbyvSXCn2iGK6c8VkYqYKCgoKCgoKCNXFt\n", + "Gql1I4hCkLuzs1MJPDabzYKuQuWOS91vsVjI1TNWqhw4NPfeYJ1W1VIx6nZZPhhZv98P2pzhcGi/\n", + "/e1vzWxZ7Kv0Rp51UIxPt9utuFarMvJOXtnuX3/9dTMz++CDD8Ixtn2noo2rnE3AK6+8UmHr2KVf\n", + "QdnLmUn0TF5usD8WIEMnwJGD1bWqj7ld/HN7vd6SUDQF6L/QprD583MHg4HcyXH5UTcAOTA/+ugj\n", + "u3Pnjpld9NE777xTKQdHi0c7K4Epzw9czlQeP9ZIASqIo2JHYmPbg13wgdwQDMq1OsYqKlbJg/WJ\n", + "V4GYriw1T3P7ASnmah3x91Ug5nTgocIzKG3WdYIdEXL0cGZV/RWzNkCsjZS2FPdhZjVHN2VW/dbw\n", + "O5DSsfLcq8TrdW2hcm7mnA+WKqWRujbT3rp0LhYxuYsZswuhMjpwOp2GRQ4ilv/N3/yNXOigsfHb\n", + "KnFrEDEazzo6OgrJihXQwXt7e2FAYcEwGAwqguHDw8MwiPDvyclJsh7dbrcy+Xa73SVzBj+Dj5lp\n", + "8bp/WXgRpvpZiZExER8fH4eyYpHLfc0vixeH14XRYPrYU8mcsJejZ/u2ms1m2RHDPWIfJRXLBOdh\n", + "AbexsRHKgvNGo1GWJyh7KaLNNjc3K2lgZrOZXKB4syCXj9sAz8BCSmE6nYaxzddydHUA/cnxx3x9\n", + "fZumPJYA7isf24yfu1gsKoLX6XRaSZbN4L70Y4wX1+yUoDYbWEDhvWCxLEdUx9/syZcTp8uX1beL\n", + "aj/+yPnFpIrnVLeQUmNXbcauCrlCelWWnO9Vqj4vAywVQF/XPc97JqvfGOzNrBaWvNBPSQCUXAJj\n", + "dzQa1cZfQx19iqvT09NkahhvNufy+XriGamNVwzFtFdQUFBQUFBQsCb+TYnNm81m2MFh591ut8MK\n", + "lBPFYpWJfGCIaxUD7tvpdLJMdLu7u0sxdnCPFHXJ4luUi1f+/rmDwSCsxvEvRwtXK/WNjQ2Z/8jv\n", + "rvlappKxE4CpUzGDStDcarVCezDrcPfuXTPTpjrsWPgZyo1audjiWWzWw7Gzs7MlJspsuT+4/fyu\n", + "hKOd51LKKneb2t2zm68fJzHzpDJl+SjrfA6zdzDFIYHz7u5u5T3Y2tqq7OA42jmLxzGuEP+t0+lI\n", + "QbFiLLCbxdhgZoXrpsybPN7UvT2LulgsKu3LzBb3Z4rVSbGjZlWTZaPRqORi4x2/P9dMmzD5vj6G\n", + "0fb2djKyvBKR413mnIaKHU2xSWwqVkiFRFhFXL0ucnOoKYF8blnq5Bfq/5c1Gabc9/kZPqZZzHTm\n", + "y6PmJ3ZyUM41KeE4vwP4Xb3XXAbuB3wLVLJqFYPOfx89VCgZ73iVY4UqjFRBQUFBQUFBwZr4zjBS\n", + "WMX2+/2wAmTmQgHaIxagYpWLXdnz58/lilJFPIdOAyvSo6Mju3nzppmZ/ehHPzIzLaBVaDab8lxl\n", + "m/ZQGiIGi5ix0saOfm9vL5wXE7F6IasKdGhWDZlwdnYWjq2iUUOZVbgCCN65jxCEUvU/9DcvXryo\n", + "1F25l/f7/XAfpb9RQmfY4b/88kupaQEw/urYTJTv7OwsyXDxzs9Hu+bAeCpsBe+s/A6S87QBKopx\n", + "TE+khKooC+rG12O8xKIE+xAa0+k0SzTNO2u02Wg0WnqnUixhSuA9n88roVPG43FgmlC3s7Mz2Q8o\n", + "v2K9ePeeKw7mMWO2zAypIK1AjC33QVq5DZgNRpmZvQV4fCihcm7d1P3WBYvDc4Xsub/lskS52iil\n", + "MboMhsNh6Ae0fUzjo5wW1Hj3UFkH1L2YWVVzKr5LX3/9dSgrviWj0WgpHynKjvthbdBoNML45bqh\n", + "LVMZDliYr0KZ4H1jdmyVLCbX5rWHqKc+ZpDZctwlAIJxxCBqNBphwsYklhPpOwV07E9/+lMzM/ve\n", + "974XzB9/8Rd/YWZm//RP/xTO/8lPfhKuw0SFznry5In98z//86XKY3axuNva2gr1xGQ5n8/Dxwjt\n", + "wwNwOp2Gc/ll9yLuWFRan8Q3Nla88FTFkZpMJpIqRbthHLx48SIslmDe5DKz6Qf9xSJotD/MFbx4\n", + "UuYKpoVT1DQjRfnyJIa/eWHIUYRxrxR1zMlcPQ0du3ZVkyM2IoPBYGnRDKAP2bsPGxV4YPKmIfX8\n", + "Oi8w9pRRi1fltcftoj5que0BqJhrdUglSVWZEnDs5OSkkrCXI72zg4xavKSiOuO3nZ2dpcWtR64J\n", + "i82SLG7Hb1cVDypWvsucFyubb/t1Fk/f9jdUOfwAKmVSq9WqyAvWKT+Pk1QMNT7m50oeJ8q0j7F7\n", + "enqa/K4wfBovfi/qFkOp8vFcjjrHvPaKaa+goKCgoKCgYE18Z3Lt8eoTu06sNIfDYVglgmFJ0XhX\n", + "BU7imopi3m63A3UJU8Cnn366MtWtgJU6R8/GscViURF2+3xZfvdy586dkICZd65+Zc6RzRVS+c94\n", + "58Bu7SoHHHbouM98Pq/0La7z13qXed6NsUku5R7LZVVsB+6D35TrrGIG2AzFdHVOrCI2uzCjp6KE\n", + "4z6qjqo+qajX/X4/i4Xh8t2/f9/MzD7++GN5rhK+poTeDO/CrKJ2M3PKO2UVOZxNBV4sX5dvEphO\n", + "p0s5EWPnqzhddUjlS+M2YtZOxWvzDCKXkcM54LyYE4Q/ppgENpeuyuoo1LFPueyUP1/FglIxwVTd\n", + "Yma6Vet52fAI3mTX6/XCu51iXbms/H541nM0GslYSxgn7DjiE06PRqPw7cO71ev1ZG5PD3YS4zyc\n", + "KVOikjwoxxa2FHkLS25YCzynMFIFBQUFBQUFBS8B18ZIXcdzCwoKCgoKCgpWxXcysrn3BOLjOXRb\n", + "u92uiG/ZYwk043Q6jaag4OezODgV18VM05SgOFPpTfg+ucJOFZZ/lUVoSpioyuWvi523alwYhkrL\n", + "chVQdHsuBV8n+l4VbGZSqEsB4s3byquNY4alvN5iaUhygf5S8bAAdrhAWVSZYn2khOUAm7LVe6Xe\n", + "4VQ9FotqYtLLIjX2Yb6uS3K+Kl555ZVgikWfjMfjrPG+sbERxg6cTlSbbG9vVxxWUtKBdZD73tY5\n", + "KrB5a9WI3ylcZm5YZ06KObP47x2bJevqlxKHw7mC780SCtWWLOzmc8yW57RV3zOW86TiNabM4Hyf\n", + "q/q+1LVvMe0VFBQUFBQUFKyJ74zYPHJe5W8WwXko1091P3ZxxK6MXadZsJzDUtWxN7mRbNUqeh1m\n", + "ip+3Sr4g/zxfnthOypcnlwV68OBB2HV89dVXWeV7WVhFPJrj+lvHSAHNZrPCTvFYgxPDdDqVcbV8\n", + "rjXOv4dj3W43xLz65JNPsuqowPGfFJMGRkrl4WP43ax3kIidz+93LCq1anMcA7M1Ho8vxUhxHDez\n", + "NBtothz3Sd3L16WOAUEokPl8HsYExlC73U46iQCbm5vh/VZZBXC/7e3t8AyUU8Uxi7W7ik6dOk+h\n", + "jn3wZZ5MJtnXpMqSusdlWV5+nll9GAEuF7dp7tybig8G9Pv9cN46oYQwzj1LyojlxfRt3G63K/EB\n", + "J5NJdiR3D2bv+O9UH7KTRV3S4sJIFRQUFBQUFBSsie9MZHNenXoWJrZj9atxxUb1+/1KPipehaqV\n", + "ea6WIrULUJnh+X4+ujODtQAcKAyos9f7HdUq4Ijadbm6/PNi/4/hk08+CYxL3Q4yd4fpy6d0FasE\n", + "G1X3VzvWXM2YPzafz8PODeEcxuNxOIb8Z/fu3Qvjl3d6HPk6Vt/xeByYqJ///OdmZvaLX/wiWU5V\n", + "3zpWlBkwX052sfb3Y72jCg/BbXUZnSDnMvT1YHdwBurCuQBT840C7qGYJg4E68vrwXkNURaPfr+f\n", + "xUipMCMMlYNsVQYmNUfEwCyA7zcul5oH0H/dbjf0K2cNwO+5OdSY6fDu+dwWOYEoY4gxqx4cSkCd\n", + "y9YWjBO01fHx8ZKO2Ewzanx/sK3NZjO8x2zdUPUC46qihDNSrDH3ude3cXlZN4nzoItuNBoVFlW9\n", + "861WK9lPq+jirt20pz72l6HdU1GJVRJXfuFyPtadTqfyknKMEoZKEZGDZrMZ7scLKPUhiF0P+FQj\n", + "uagTdgK5JrF14q4wcsWDHGOH/02VK3VebiyTHNMeJwXlcqqPK37HJNZut8PYRllOT0+lIFfFB+Lf\n", + "zcx+8IMf2LvvvlupDy8szOKLBR9NmNsHC8JutxtSAAE3b96UKZDwoUrF2VLvgv9Y55pT/Yam2+3K\n", + "BQhSRKEdVk2NZHbRVgcHByGGG5ta/AdyHbMRMhuYXSy+LzOPssk4ZqLF72ZXLzY3WzbF4ll+jq5z\n", + "AgJyBeOXMTPyM3JjguVuDNaRa2DcbW1thbGtMhakon/HxiLqx2lmVAqwnM0Jz2P8XmMxh/OeP3+e\n", + "/Q3B+OUkzX7OMlv+hsfqWCKbFxQUFBQUFBS8RFy7aS/HnbXb7VZWjrPZbMkEB6REcnU5vlTkYM9w\n", + "xJgJ7wbKO5tVo7BzOet2plhdc85ClYx4VVyWyUldo55RtzvykZljdfNMg0rim1vOxWKR3YY57cBj\n", + "lqMTo3wQLas2mE6nFfd5NguxUwSuVzkDU6wmM6ugyTudjnynsPOGiP3p06ehrTjS/I0bN8zswpng\n", + "5OREhgPAtTyOVdR+lCsnyXEMKvlunUmZy+LnnbpxperGEcY9eL7LBUzkjx8/Dm3O4va6/JFm53X1\n", + "dYuxUZysGsiZExQztFgsJCOpWGWVQQBjEG2mHFcUG8UR7lMmHmZlkMPz2bNnFXMfX5saEzHHpZTI\n", + "fR2RPsr89ddfh3futddeM7NzdsfPE6enp5VxFzNheocSxY5NJhM556O9fG5TXGN23pZ45/Dv9vZ2\n", + "mIvq2EU1zn3dut1u5b1YLBYVWU7Od6MwUgUFBQUFBQUFa+LaGakUsIKM2WhTu0m1qsfquNPpLOV2\n", + "i53Hgjd1b6xceffk7+uRI0Ks22nwzgDn5QhMV4HSI8TKkHs/zybxTq8uxAKQ2qmrXd1sNqswjXU7\n", + "DCWSrRPZ57aH7/fT09MwJrDbXSwWMhidv1aJv80u6pdiHz7++OOgq4GOiVlZuMTfvXs33Bu7QR53\n", + "0Dvt7e2F3/Hc8XhcEUQfHx8HrRe/C3guxnG3263oHReLi9ySzGpdhc5zOBxK9sWHP2Ehcx2b5fH0\n", + "6dPAFmEcq/c2l8FuNBoVYfHJyclSbkpfjxTm83lo87oQFhirl0FKY2im28FraufzeWA2mZ1VY8Kz\n", + "3iqMgwIzhHgW61i5bCltZt0cktLwxsqn2kMB5ebyg1XE+1U3RtiZxH/vYt8L//4oRvLs7CwwQ5w/\n", + "1Z93eHgYzsM4PTo6qrQb9yu+Of1+vxJsdDweL33DgXUsOd/phVQKdfQo/+4XL3UTVZ23mvcCVOh0\n", + "OpVYVaPRqGJ6Ui8SJ2xEp3LsK5VQNNc7YhXkeCzGoCYAb567zP2UYJhjgbGHTuqDVycyzF0grfox\n", + "5/uifBAyb2xsLHm5qXJ5xExEZsvjlJOMIu4L38OPp88++yyMRSy8xuNxWOjxwgvX8GSozJR+4m42\n", + "m+Ea/ihyYmKz8z7F87BAu2w8H7TRxsZGEGkDg8Gg8mFkQX7quapcL168sDfeeMPMLsxPqt/qEs8C\n", + "7HWE+0ynU7n4SQnGFVIbvXa7vdY7bLZcX9xjMplUyle3oeL+gJm3znuOPfj8eap//fxilk5ozcl8\n", + "VR/G5nr/O4vJuU4pL2xeTOSI6ufzuVzEs/e8f27ddy9nflVzjNnF5gv/DofDpWTl+Nefx+8A/4vf\n", + "eQGMOmERdnJyEsqM2GyDwSC8m6hnjvd7Me0VFBQUFBQUFKyJ3xlGKpfCBHhlHRMQmqV3lZ1OR8aw\n", + "SAmjFQuQEqoyrc3P8Kv+GAOnXGH9jmod1LnoXoahUbs6ZdpLsUFcvpQpjlkqVTb1DDYFruqmnAvF\n", + "rAHMxjBy4q/4+5gtuyHzu6CuUe8KroV4+datW6G/wAawkL4uxo5/Ppsymc3yu+N2u52MLXMZKMZG\n", + "RQlX4SoUYmwwdsp14wkmQJhYY8yVj/5spuel3FAmOWwbIj2vg9w5hKUbdfcBeO5lpyS+Jx9TuerU\n", + "+/jixYvKvL6xsRHMm59//nk4F2wHh8lQDIx/RrPZrJiM/XlKaK9YSn8+f8d4fvQMGLNFfA+cxyE7\n", + "vMC+LlwOnERizJp3aKlzJmGWDOOdTbscV8/sfDyjHvwsHEN/PX/+PPShZ8SS5ak9o6CgoKCgoKCg\n", + "QOI7yUhx/jtAsQ/ehViFK+BjWFFPJpNKoEq1w5lMJuEaiNxUROB2ux1+TwUCrWM9OMhZStOQy9Rc\n", + "BquwT6uCdxPYqbC4Oof9Se3U/LUpRipXMH7VbQDM5/OKC26r1ZKswrrlio2Hzz77zMzM3nzzTTMz\n", + "e+utt8JvzBT6HfXjx48rO1cGa0eUSzdHFsYzPIPAkZzrRMHrRPAH8C6fnp4Gdgc70OPj4worNpvN\n", + "shgp5QjQaDTs008/NbPlfHkKdU4r/jmYL3q93tqBJznXGubgZrNZme/q5qfY88yW5+PUTj9Wh1R7\n", + "MDuigtzCkgC2Q92r1+sFFpLHrG+D8XgstUJ+/s8NBMrlXwdcFyW+VlYU9DHGgXpvFbM6m82CQwOz\n", + "Qax5xHn+ve52u+Fv1gEjfAfnf0wFCuVy+nGsvrOrYJ08g9/JhVSu14qKRwKwectTmLGIqwA+bOPx\n", + "eGliNzv/2OFvDMThcGiPHj2K3k/FrVG/1XnKKIGi/6DFPLnqoCJzr4pc8xcLZFNlrPPqyYVfqMbM\n", + "h0oY6T+kV7FI9fDRxEejUdJ8XOd96Bc+PCawcOVowh9//LGZmd2+fXtpYYFnqfcxlVIB9en1epX0\n", + "EmZVUS0LszGJ7e/vVzw6ladUqh1ywOMvFREev+V+7IbDYRDOq5Q5dR8JIbMcuQAAIABJREFU5bXp\n", + "0W63K+LbjY2NpFkEY2w4HMpn4AOJPlflbLVaK39sLvNxW9XbVjnjcEwj5cgBnJ6eho86nA/UfGF2\n", + "4fCQijsXS6uUmm9j9U1tXgD+3tV5QLIjk9lyX9dt1v3ffJ56R9DWynlmc3OzMo7r5nnlGZi6Jtcp\n", + "hdtYOa7FUEx7BQUFBQUFBQVr4jvJSAGpuBRM3zJrkGJUeOXtd5jz+TzsxpRbKO/y/OpaJQ+N1Scn\n", + "zkij0VhiwHC+Eigqk+c67M1VmK5yQxhwPXzushj7lFO+OrOmMinkiuZflmnP7GK8sfnYxyozuyg3\n", + "xm6uwwWLQzGOeYeGPjg8PKyINA8ODgKzgnelTgiK37e3t8MuNxWyQf329OlT293dXSpfzOHiMmE+\n", + "0L4cy0pBiXRT2N7eDu2mmI/UPXLjyKldNsc8UnHEWEzumUs2u6VyHk6n0yyzy1Uh992rSzzrWZle\n", + "r7cUggHngIlKhSjY3NysJDDmb5JyZmLRdio232VZb9wH37PFYiG/af79Y0tNnazCZ1To9/sVh5Zu\n", + "t5u0LuG5MfY1Jclg+Dmr1WpVhPucqzSVL3Nd82phpAoKCgoKCgoK1kTjZe60ow9tNFZ+6FW7nwPY\n", + "lTUajdqo2f75dWXKLXNKh8O6Hn8/tofHkBINfttQup9UQFG1I2SbvKqbbw8l5o8FhfPIDcXgr8Ez\n", + "1m1z5Qq9ublZybXHucJi90FZVNurY2on7TVcqv/U+9Pv98MuENHTFdsS6z9m1Mzi2kkWtyrNRgq8\n", + "m/Uam2azGTRlaOeYZszj9ddftw8++GDpmNJjjcfjyjjnflVtw27o6JO7d++a2UWkebOL0AkxnYtn\n", + "W1utVgg/gV17jDlX7vS5uEzuy3X1MLlMomKAVVneeOON8Ds0hrlsRqvVqrSf6o9YCIjcNkddODj0\n", + "qk4CKK/ZcqDQFKOmHML43eJ8tGb1ekGg0+kkgysraxXQbDYDQwdrz+HhoRwngLeIfDOGZKN/p017\n", + "qQ9kLngQKTOYijOCjuYJM+UxxS8BTxLqGnQi6jYejyvl4kWTii3C5fXPZbwMYfRloDwlmQbGOT5W\n", + "kJlecKkXlz/sZsuTIU8EOV6bdabFq1jcqwleLcJUst/RaJQV2T7mXKGO4T48eaJ8Klo895+PtXN2\n", + "dlah3WOLupQ5ty71x6rjnE0rKfMim/u9GacOdZ6k/L56L8bYWFTex4hOjwXQu+++G9rXywPqytdo\n", + "NIKZJTWmL7uZVc/2i6tchxAGR7b28yenA+E+ZO9Es/O28qJuXvigbd97772wyE6NPzVmcz0SVzEz\n", + "qfeHY/Oh7mzKVht3jBllkucFkN9MDIfDyrvB/aXKxWX3GyD+bnNKH8yBOE/FhOKYdrzwguQA1zSb\n", + "zcp3U8UWy+mHYtorKCgoKCgoKFgT32lGKraDM9O79sViUdnV1dGGvBPC3yo3mXKFVGyAWr3iPI5R\n", + "okwY/P8UdakiSCvzV4677FWijqHJEdorRoIZJHU/7oec3cOqIvac+6x7v1xzhYq/pOqr2KKtra2k\n", + "qaYuIrQqi2eVxuPx0jg3O2fMWHhupoWlzLakzD48B8TKl9v+uWyizw+ZG5qlLnxBig2MlQkMCMwz\n", + "zCqwmBj39vHJPNCHgHJo+bagzFWeMVHsDpvuVbgPBszM6MPxeBz69/bt22a2HKVcWRfYNKacLpjx\n", + "WQWXiSHFUFYcZab3fwOoH8do9O3KTA7a/uTkJLz3ADtwYKxxdgJOeOzrz+2skpvjd57veE7K+V6o\n", + "8T6fzyumR5VX0qMwUgUFBQUFBQUFa+I7zUgBzNDU6aZyVvacvZx3a1gh847aa2lYCMp6Er+jajab\n", + "FXdQ3sHwDtzvROsEnrxL9ozZugE5rwIxUauZ1oyxKJRt5Co6vQe3R12metYKxO63Cq7a8aFOf2d2\n", + "3n4Is8H56Dxms1lgLjDejo6OknoZ7NCVeF2FlOA+8s82u3C7ju3eWWuF67w2S2E2m1VYFLPVx3mO\n", + "kwaAsQPWri70A+AdAzx4F+3Zqfl8Hp6nhP0M9IMKkKn0XKwDzdGJfRvIdepQjJSyWsTqwWJ+/Ivv\n", + "ADNRfj5pNBqhP3BtjHHMmWu47VMa2FWgLBz8XniHG/7uKMsKjx3frszacFvjfVd1xxwzn88r47LZ\n", + "bFZCurDjCJfLv388D+Fd4TlLsU88t/pnLBbVoKo5uLaFlH8pUt4pSrSmJk8eHDxhoIGZKvYfDC5P\n", + "Ku7L2dlZZaCoTp/NZuHj5alMlIH/VXXhNphOpxUPiOl0emVJW68anpZXMUX4gwHTRF3UeUB9zNk8\n", + "i+euEjPKl53NbnwPtcjJSYJd552WElIPh8MwiagFFN8D56mEnQoweaj2WywWsm4+jsxisQh9iUWE\n", + "inPG75ky2XDcF9WWVxG/aJUFcMpLKAXlZctxtVRcH75WbSKU4B1RuOE5xkglvs41g5tVHWTqFqKr\n", + "Rt7n+irZAt/X33NnZycsIus8UvHeqIWDSjYPLBaLcBwmwOFwaF988YWsH66JYTqdJtuIx02Od7G/\n", + "Vi1AvPmz3W5X5s/t7e1KyqFmsxnefywiT05Okt7CdXX3YC9qniM5ZRqXyV8LpMzC7An9MjYOxbRX\n", + "UFBQUFBQULAmro2R8rt63oGpFTXALJWKq+R3T+zOmlrVLxYLe+2118zsYrf45ZdfVmJoLBaLIJzl\n", + "iM9eVDefzysr6E6nE+7HcWkUXe1XzSpOj0Kn0wn3Y/HfVZujcoXlgNrpzefzigA0xjh4VmQ4HIY2\n", + "5J1Fzi6jLqZMSoyuGBUuVwqLxULulP14V+UbjUZ27949M7OQ+JbZO443phLe4t5KgIwdvXIbXywW\n", + "oY9wj6Ojo4o7uBJ4qojQypStwL+l2L5VksKuAzw7J/edvw7vP+aLmzdv2vvvv790ngoBcePGjRAD\n", + "iqFYLJhxEY2bocbTqm3VarWkY0HKnOrnTLNluYQypwCpMaHKzmXhcqKsYOzY8SF2H7Nzdhbvg4r7\n", + "hbrt7OyEmF3rjD8/T62TbD5m6kwJrf31ZhflPzw8rEhFGo1GaDf8u7m5KR0f0K+QHmxvbwcWUI1n\n", + "BvoL71sscwnA1h4VjV1ZiFIAI2m2HKfN7Px9rENhpAoKCgoKCgoK1sS1aqTMlhkXM51ZWu2sY1B2\n", + "1FTUbAhjT05O7KOPPjIzC8xU7Fq4knOW8JworbxTAtitnVfUKg+WB7uSAszUqWBl6+x8FNbRG6n+\n", + "VDtp3x5KN7W9vS2Fv/7aGPvky5KbHZy1QCpMRiowJjONzLJ4XR8zq7zjAyOBHd/Z2Zlka1IMTsqV\n", + "lx0kGBjvyH3Hu3ZmAbzebTAYVFiU3N27Er7yc/k8BKV8GVj3XeF2RPnr6g7GcWdnJ0SCT2E4HIbx\n", + "wVoQpUtbF6wPqgtQDKgxpOY2ZiG8Y06sLB7sEMT3xzE1v6Sg5kyzi7o/fPjQzM61Uv69Zf0kQ83v\n", + "fg6J9ZHPCcvodrtJgXfKasCaW+VcBajxf3R0JL/X3oryxRdfVPTJXBYw3e12O8wxubpIjvzvtVTM\n", + "yvG8jL9ZcM8sK8oCYO7KYaOvNUVM7ke9zlOPB5tKB5ILb/a4c+dOUlB48+ZNMztPf6Geg47Dffkl\n", + "5Q7zH9dGo1FZEHJ0Wr7Ov8x8P+XtWGfW8s80y4/7VAffJyoGSG4f3rp1K0ySqQjZsdgzXsyrvPti\n", + "9cupuxKqq8Vav98PbaAmDNUG7L2VEqgr4Nrf+73fs7feemvpt9jYUOZI/65sbGxUBKhq8r958+ZS\n", + "GhOPlEei2cXGB2XxzgT4PSWGrUOd48CqaY0AtbBk/NEf/ZGZmT158iR8sAG1mdjb27P9/X0zO4+0\n", + "vQp6vd5a6UI8eIOWSuXDH2t8QJWnIdDpdJbiDAGpxPLsSebjkqkybW9vJz+SdQskdb7v99x3iucG\n", + "Hn+pxMlKQB1DasyiP1qtVtaiQc1jqu77+/uhvyBH4HmRY0txZHmz/AwCCuxFr9qFF1x+06EW/K1W\n", + "y0ajEfpSrniLaa+goKCgoKCgYE18p5MWq7w3HN0Zv6+6s+r3+xVBLt8PuxfVNopBePXVV+3Ro0dL\n", + "x1SyXGaUciMk1+2Oc0Xf69D7uaxTigVS91DR5DlMghIP+p1oLEyC2sH5Mqgdi2KhcneYsVhLYAu+\n", + "+uqraFnMLnaEgGIuY/3vTQQcGyW1q9vZ2QnszyeffFL5/dVXXzWzc3rex/qKRR2HqBrCUtVHm5ub\n", + "oe6op2JqdnZ2At2vxgvAbMFisQjmR1zLyAlREcNVO2sovPHGG2Zm9sEHH1Ses7W1VWHptre3w9jh\n", + "OEgKngGpY2NykctIcR9yXk3+l7GxsRHGBI83zAO4Rj2LGROc3+/3A4MNofRsNrOf/vSnZnbBgH78\n", + "8cdBMsAsfuqd4nG17jjJYcE9a6JCBXAoAYDbl3Pp1YVeSMGH52k0qvn36oC8eQcHB/bZZ5+Z2UVb\n", + "tlqtpHMAcFXMah3ApBVGqqCgoKCgoKDginFtjBTsu3Xi3FWgmIZ13KPZBRMrbuyOer1etng0R6cV\n", + "04kpm3Yq32BMZHgVgtPUbilW/jomClg14ByzeqnIzapMnAdLhTUA6gSbOQwcB+lkEbZ35eVygk05\n", + "Pj6uBILkZ/jI5Vy3mK5C1SOHoXnzzTft7bffXrp2c3NTRu5GuThw5N27d83Mwo7T7GJXjPuNx2Mp\n", + "4Ff1BHD+dDpd0jmoiOBA3fuYCsqY+s2sGnW81+uF57BeS2nAUv0AlmcwGFQYpJ2dndCv7F6uNEh4\n", + "Lpc/xbzngsf9qvM2a5CguWNmUjmEeE0LC9X5Oh+OZjqdhmdwNHj8jmM7OzuB4WBWE8wW+mgymWRl\n", + "YKiDCr7J3zA1P+bO6ZdhUVlHtCqDy9oi1Ye52QFydc6pPJ4Mr59cpV3qGKlrW0jFRHh1Ymj2FsDf\n", + "q35QY8CkDzFsXRRlPJ9pd0y4V0U3cn1TAjrALxyvYiHFZWEqv64sHv5jtLu7W4kvwiadWBnMzql6\n", + "NvOZ6dhMXMa6aMJqcZXy+PP3N1uOzKxiMgGpj2ev16vEVeEPIItqU/FovOefB6h1XhSxJ2pOWQHe\n", + "xGDCOj4+Du2BD/mzZ88qcYbYLJQSiSsan8e7EvjnYjgcysjhQN1CSt0v9cFQ7Qywqdd7FTFu3LgR\n", + "noG2HI/H4XqOcI9FqYq9ltrEqI0SLxrZQWNVzzF+hlqMqHHnFy+9Xi/LsUDVg02APIfkbu44dlvs\n", + "/Lo5hOuduzBbdU7n/lqVuKhzCMO7PhgMKlHpOZEx5urJZBLaGs/lse1TxcTKrJD7TVKbsDoU015B\n", + "QUFBQUFBwUvCtYrNWcSXcuOvQ51Zw6PODRlg0x5277lxSWJxiXz8DY5Ezc/1IujYbsHTwXwvFf5g\n", + "HdTtNFOmrrrdnY8YXLe7VGESUsyLMu3WsZ65O1LFhAGLxWLJrOCfq8ShsVgxZue7Nm/q6nQ6lRxa\n", + "eA7KYLbM5Kj348033zQzWwqHgDJ1u135rqTc0PGMbrcb+lP1Ebuo5wjaY/cBLsNIbWxsVHIUzmaz\n", + "yvuq3NAVVAJoBoTlPtK52bnbOO7NjgoenGeOQ6dgh4+xw+3C/ZUSJafA7BPH6/GC7Do3dIZqX3XM\n", + "s1Scw7PuveVxaRaPw8b1NDtnzlPzPs/lqZhWCqrMsfk2JTbnsqhvB8sa/L3ryuNZIu/gkQOYVc2q\n", + "czxn48i1LvH85OvE3wYgZnHAfILnqjUEvqOFkSooKCgoKCgoeAn4Toc/YHjmRQVJi7mrY9XJK2Gs\n", + "kLGzXVAwvxRb1el0wuoezz87O1tbH4B7mqU1WezWrrJX41m8Qp9OpxUGJFeXtkrgTl8Gfg7rhHJY\n", + "Ni4rzq9zj1e7qDqX5JQguy7IXZ3WCr95RorHp8p5V6dpwr15PHO/+2s58J3Kv+ehWJSNjY3AhKUC\n", + "aeI5/hl+N650Tu12O5Rf6YoUa8BMnWKQ+Fq/y1WBYJlNwHhi7Qa77OcwN71eT4q50ZbQSCFQIWMw\n", + "GITxgfbgNkP/dzqdoG/D+Z1OJzwX12xuboa/eY5BndBfMTZAsQ9+vK3DBLJWDvdmZwE1P+Swxe12\n", + "O7RRKuhnLlSYATXXLBbVPHfM3tWxcql5kdlnFTg4tw7MDPF3wpevbk5V5VP59+p0xv7erKlaN6vA\n", + "xsaGzN3KInj8hrbmeUDpEb+zYnOz/MjmsfNSgr1VY2SoZ9y4cSMMCk7squhqH0nXm9jwXG8qUBMC\n", + "e6esIixXdfKJH3NR1zephSMfV+fxS+rbTU1GCkrMG4stpcq86uIqtgAF/O/8DLVAwm+DwaBSj7p+\n", + "rfNm8xNBo9GQXlEAxzlLxQDiBVxq4c2pGDxl3+12wzHVVyjneDyujD/lLchpktiLlRN2+489LzZY\n", + "uO/Lz++wMilzGVKLNUbOZq3ZbIaFlkqdgYwKz549C22IBUi/3w/1xLXb29uh3bjsufGc/EeJExmj\n", + "HipdFSO1AFKib94EKvC7ivqiL5XTiZrL1LtSt9lJIWbOzZ1XUnNNq9WqfBN4/kmNT4Vmsxnai9vc\n", + "b3JizgapvsYY57LiWK/XC2MRz+KxzdlAfKwwRZ5wVHTuy9xNsYLqhyI2LygoKCgoKCh4SfidNe1x\n", + "lGO16lTxTZgtWjV+EZvffKTyRqOaGy8XKVZjFcRcXFPCxFXjjFymrMwWcV+m3PdTUCaiWHyjup2e\n", + "2bJZaB3zrAczUryz9ffjnSabYT1jqdhW1QZ1JtmU+ZBNSiyu9XGJ6pwJ+H1TZjJ1Ta7oNhXqgvsQ\n", + "sWVOT08rzFer1ZKhU1LMBp+z6lhQovo6KOYKdb9165aZLZsF0X6DwSCUH4xlu90O9+H5wJtqWJSM\n", + "Y71eL1zD0fNxHsYRZ4uIsU74zbcfMxyrRp+PzUk+PhSXNfeeyvSY6vtut1sxu6mo4qocitWMOSzx\n", + "POHL0+l0sh13AK4v2p+v9e3B56no80CMuWIWOHbtKvBR1ieTSbbFwZdpsbiI54V7jEajwkgVFBQU\n", + "FBQUFLwsfGcYqZSNV+3aE/cO15jV5z+qYyHWCTxpppmVmHBTIbUz44BiQEw07cNK1Om01mVgcuDb\n", + "koOqqp1LXW43IDeKfV3dVh0nqd+VK/4qeaFS4QK4/dQYA9RYY9YlpSdjhog1TziWM46ZJVXM1KpO\n", + "B3VsUIwFVFDvF+f5MrtcUF3F2ikGNnatch64fft2uI+Z2ePHjyvXsnMA6j6dTqUmS7GAKvCocswB\n", + "mB3xTF5dEEzliJI733LZUWZcW8fEpDSGMfD3Kad8q+otzfKDvuL6wWBQqSu3uXeK4r9z25fZOIW6\n", + "Onlm8NvIi9fr9SraYBWyIfZd4e+J2Xm/nJycJBmptjr4bYHNPalJPfaR9QNlsbgIZ88TZN3kC6iJ\n", + "JUdwzROBum+u4I29nhTN6yn2WJn8QsmXJzWQLrOAqnupvEiShaIKbIbA36kFJn/0+UXynhmx9ssd\n", + "J4B6SRk+cjiL67ntlbkKEw6beHCNSgECzOfzyiKM2wD/1pm0+XclRq7zMDQ7f5/QT2hzjtek2ozv\n", + "q96plMkLz+Tncd2VswEfYxNXDGyu5P5SJtvcVFIebHbjxQHaI9XmjUaj0kYxbzzlYabmhJzF32Kx\n", + "qMzhdfNLaiPHf3ObqjhNbHL09+DneS9FRt3chbrlOu2o8+okA778/tvk667iYHHdcs2j/P6gnrwB\n", + "z5kXY/EfeVGNZ/nvYa6DkUKjUY1FORqNKnGz1HyrTO1KHpQVc3Kt0hcUFBQUFBQUFFy/aY9dks3y\n", + "c1mtAuxEAPUMtXM1q4rcG41qJHKz1c0QoMsnk0ltCAO+ry8Tjsfchn2dYuXKjSzsd0sxcXjKZKoY\n", + "KcU+MZSzgUJqZ8lsh2czVxGb55g/WbSIvhmNRiu75bKpyu+MOKZZynQTo+eVGTwXPiZLLGwCcuyl\n", + "8icqbGxsJGMAKUZssVgs7a7N4nVKzQksXvUsy+7ubnhmaqe6jigd6PV6lQSrZ2dnoS3xfNXmvV7P\n", + "XnnlFTMze/ToUaWcbKb1dVPhQ+ocC9ScqUIT8FhU7vs5jHNdmzKzmxO6gEPZpCQGLwN+blXOOLGy\n", + "qDZX+Te57b3pdBUWCO3Kpkc1TmLl5DpxGZgBTslN6rKd+Ij1zI6mvsfNZrOSQD02XorYvKCgoKCg\n", + "oKDgJeHaGSkPDrCFsrFgXK1IlVCdd3S+jqxBYBturhBc1Cfrmtiq2K+o1U6XRZq55WPNQ274g5Tu\n", + "C+U1q9eOqTZXWhWF3NxzKbaO3am9uJWfy7vYHMZM3Yd1aWz3922uIrTH8j4qnVPqHVAMDcY4t4fS\n", + "m9Q5V6R0Z6k8Y2ZVPVe327UbN26YmdkXX3xROZ+REt9y3fi94MjYKWB+ULqjlCB/f3/fnj59mrz3\n", + "ugCLMhwOQ1uCyVOZDVSbt1otu3//vpmZHR4emtl5vj5cy0zNqg40ap5V7AjAbDWzCoByEqkLqLwO\n", + "e5oDtox4zRWH2qlrMz/+cufqWKgDxe5xm/r7x1hF3/7z+bzitDSbzSoRxheLxUqi/Muijn3Kxc7O\n", + "jpnZUtiPVEYSZsRU7ltYLGKM1LUtpCDa9OLXuo8rT/o51KSipvk561C6LJwzq/dEUC9DrmmHkTKD\n", + "xQZgaqJLLWhW8ZQEVD1TZY0t1NSC1qdbWSwWWYJnPJvvx5PWqnFrlFeHGjtK0MxRzHmRgJcev/FE\n", + "iHhI+Cgytre3K8dzk2XzpKmSKq8aKZnBGyFOvWB23lf37t0zs4vF1bNnzyr3UPUYDofhIxeLr+M3\n", + "YWb1sa7MdGRzZRLtdrsrfyRzgQXmfD4PDgqqbwAVSbvZbNrdu3fN7GJsP3z4MPyOiOmxJLyp90HF\n", + "quN3atX5IsdEzqiLMcflg6MH6jGZTJKykVScq5xymS2nhVKpSXixmCIE1CaAr0H5eCzmAnPmeDyW\n", + "30U1l/H7gOcCV+GFx45U65hWfVzHXM/gmPMCvDoxP0FCU0x7BQUFBQUFBQUvAdcW/oBFcR5Y8fIu\n", + "Qa18VX47z3bwLjUVZbUuh54qd67ZRTFECiyWU3mVlDs47zD8/RWdrlzhzUy6i6YEyikROf+eCimh\n", + "dmaxkAjK/TjFIrEJw9eD2Y7UDjdWPoCT3KZ2Unj+yclJYB2++uorMzs3fcF8c3BwYGZmT548CdeC\n", + "cVImwMPDwxBbCMLi6XQqWQXldODbj9vJC1/N8mP88JjFM8CEjEajEJH7Zz/7mZmZ/epXv5L3wQ6d\n", + "2w9MA9pC7SjNlusOkTYzX3589vv9pXya6t5m5+9ZiiUEciP0czgFzi2W6hs/73l4xpSBOYujU6tY\n", + "ZQpqxw+o0CMM9GWr1QosWp3Z3I+3VqslQxx40/10Ok06N6hsBnXmbX8t15PPS8kh1Pn8rnrHIWab\n", + "Yt8VJar3An+23qCvO51OJaxJs9mU9/PjJBXbzsM7pajQPrmOBWzeVjEU8S1st9uVECv9fr8SB43H\n", + "LFioFy9e2IsXL5bKnMNQFkaqoKCgoKCgoGBNXJtGChocZmHMzlfhuUzIusjdLeaiTmye2qnVsVl8\n", + "HsDskb/Ga5uURirVlqmdmWq3OjYGWGWH7sscy1Gm6pESKPP5/lpVj5hQ3fenunaxWNju7q6Zre76\n", + "v7e3F3ZUubs/sC7YTTFifeTbKqYZ8EztOq79GLNbW1sVfc6DBw+CgFuVnyNXY6estB6LxaISNsBM\n", + "BzD1u/Z+v5+dp9EHWlWoG++ss/T6z7Ozs+Q7xYEllTAWGjQwGs+ePatoqfr9fmhDHp8pZw0VEZzf\n", + "1ZQWiJmuy4QayNEbdbvdMKZRx+l0miVoV8gRgvOzzZbnH8/2pxxXzM4dGszOdWypoKaNxkXwVWZ8\n", + "0Ne5oVXQRrm5+RTqslTkXG+W/tYwUtkCNjc3JWOdE2Vd9TWsQd9JsTnEib4R1CS9s7MTJlicHxNa\n", + "KupPmQA9fXrZ9CLrIraQwuSPOsbKlorfEfPayxGCx7ywVkUqPhW3pVrwKbE50+OpCYqxqqBcTYY5\n", + "3ntmy6Yln7piNBrJ9vDlOzg4COY91JsTz6YwHA7Dh44jXKc873ITeHPZ6zYHZuft4hcdyqvI7EJU\n", + "j/PUJLqzsyMXpdzmfkzgmWbLphIf/TvmPanGwv/P3pvF2Jad52H/PnWGmm/Vne/tZrPZElsSSZG0\n", + "RFmCJYAx4AcDAWLkQbHzIBhwAgRIEAd5i/wSIgH0liDIgwMEsYMkD0JsBDCch1gOCMWKRFoGJTAi\n", + "uyVSIkX27eHe233nmusMeaj+Vn3n398a9qmqria5PqBxq88e1rz2+qfv90EOsc23RLgaDoehfljr\n", + "Mado9CtHhql+un379tz79vf3Q1343TjoY74cHR215jSnNeJy/UdzMBi0HIZjfYDgCphGmQW+K/jQ\n", + "BMTmWAnOS8hW+1jp3qrSM/HfXrjzf/v9VQmiqo/6/X4w7fH9KFclLefy/beIy43V1az8wBdbT547\n", + "bm1tLXw/cW5gMzwLLv7bEYuOBXNAdTavqKioqKioqDhnfGx4pFiS9KrumCTpT95sdlHajlxINNWv\n", + "9ay6nuq7RRi/WTOhTvyqvJS2hXlwfAirr0suTNQs3lepPsqZLdXpHyg1PQI5vhfWJKi5A5RqaLhO\n", + "vq7cp6zVwG+Q/BTr9GQyCSHs7777brgOR3VIWawZ8LxoDCW1M7q2VyFXBmumbty4YWZm77//fus+\n", + "Xt+K3gLvwW/cXl7/LP2ntBOKj8q3i6+xJjSlRRkMBkneN6bEwPtSzutmp+OEfmFNE98Dx36M55Mn\n", + "T6RZDpohaK6UqYPntlp7KIMZ37H2eH4qDSzGemdnJ7nvqCAghrI4+P0sZnryDvmxDAeLIqat9P3C\n", + "FpFSZvN+v59cs1grBwcHYayBR48eJekWWPvI2kmzk7ntTWfKqsGuJQC7nvj2lKCrWTbFJ4n6mLUd\n", + "6s3mNdnYz6tGqqKioqKioqLinHFp9AcefGpPSXo4CbPGh53mUgRhfJotcTyM+cOUnKBjrNgqpJMl\n", + "OA/W0KRyXTFlBKROFSKq2qekTrC58rMxzYuvq5JYlaZJUTr46/4paxVhAAAgAElEQVR97IyI/lBh\n", + "wmpcU+PAyDk5KsdyBdQfmpqNjY2gTVJzHA7jx8fHQRPF4cigTICUdXx8HMad533K4V6B/VxiZIBm\n", + "6XBwlauO1wr3mWdKZn9H1tChTVw+fKggbfv6et9C5TuSojfxUOOkHLx93+SIHVl6LwqvJt8N5WOo\n", + "6gIt1P7+fugvjNN0Ok2Sm/p68t+j0ajV3mfPnrV8X1gry3sXymP6GFWu3zvYoV3tbSmSS7P2XIk5\n", + "kZdqSEr8Jkt9W1dWVsLcVv2h6prTIHMwhGfj51yW2E8Gg0HQivJ69pQIMc2l92NV/Zjrj9icxrWu\n", + "/mu8n6B+KgCCNdNK251D1rTXNM0/NrN/28wezmazn//wt6+Y2X9oZtDN/4PZbPZ/fXjtN83s75nZ\n", + "xMz+/mw2+5finbPl5WUZocfqSl5A/uAzHo/lwaLETMGDft5Jkrl8tXGXRMyNRqMwiNwOqOyxoFSE\n", + "kwfK8czgvtyUaSiFXFRXSs2roCJ9YiZSLHBvUkC9zOZV9V3bqA5/sc3XH15ms1mrfr5eMcQS9qai\n", + "xXCAGI/HcqMrYYFfWloKbU59XEsjNXEvQyUj5XHzTuBmp/xaL168mOPBMZt3wp/NZuEwinKUA7li\n", + "p+/1TpP4LmLaWYQh3+xk3FBOKgqQU2ehLJW6o9/vBxMwm87QD9xXKagoUJS7vb0dIi+5z1S/4Rle\n", + "e11NyMoEpUyVzDuGcegqVCwCXtOLlqfWlD+ge+G03++HcUJ5h4eHrWTpw+FQCiqqX1EGC2h+rqyt\n", + "rYVnzqNflYDe7/dbplh23WCXDNzno/L4t4ODg1DnkoTWHudh2vufzexv+vea2X87m83+yof/4RD1\n", + "GTP722b2mQ+f+YdN01TzYUVFRUVFRcWPJbKmvdls9v82TfOquKROZn/LzH57Npsdm9kPmqb5CzP7\n", + "q2b2r/2NBwcHcyp9nCJzJ1zFM+FVinOVbJqW+WM2m4XTacrhLgelXVAM3ip3F0tq6ANc45MyaxIg\n", + "BbJkCAmD26ZO3KmcXSzB5dqpVNfMWmymTW0p+gV+lqE0USz5o+0cnKBU/968cHx8LOkUPJTpMdZP\n", + "at5Cakb5yuGRzX2o0+7ubmsMl5aWgsYC7WBzAGuwkLT23r174beS+c3jq8ASYsm6YU0y1uDa2low\n", + "H2Asm6YJ8xdjurm5GfqFmd4Rsg+W8q2trTkpG/3lGdAZo9Eo/I7xVbkHY1BaNox1zmEcwDyI8eYB\n", + "aq3k9ki0HVheXpaJlv27WRPKJjFv/mTzHKMk6CSmuUpB7eusifKaZh4fTkDs1zLnB1TO8GyiSmnH\n", + "+TfMA9B58NwFVMLw6XQaNIiqXGY+ByaTyVxSa/zGDPlmJrXbZqf9hfYylxrW0XA4DG3Cmtvd3W3l\n", + "0OSxVHk61dri76J/j5pfo9FIZvDA32pdKK0TnznA2YW28behy5ngLNqi/7Rpmv+vaZp/1DTN1oe/\n", + "3TWzt+met83spTOUUVFRUVFRUVHxscWizub/g5n9Vx/+/V+b2X9jZv9B5N6o2MGnRT5t+xMhh1ar\n", + "cNqcgyznl8L7UbayD+OEmyOKU6GfzNSu/JwAvHc8HgetE4d2e2brlZWVUD9IGE+ePJF0DyxNAMpx\n", + "W4UDK+R8vHz/K3JDDk1XfjIq/FRBadZ4HFIMxCxZl0gbsYABICdZQ4MIPwZ28AW4vawl9ZLUaDRq\n", + "5cva2dmZ8x/CNWii2I/ES7Mxeg6/BpSzPtNqqGdZC+l9EQeDgfRv8b4lMc0OJEesmffffz/8bXY6\n", + "P/g3D5UXbjgcSj8NvE8FqkCDcHh4mJ23HihL+aBweYqeIwX2kUJwQoxZH351GEtug9LkYb7HNBwK\n", + "eDfPF8U0z9pJs3lthpqn7H/onYgnk0nLx0u9I7a34/dFaEE4GArt8WPH/rPcXqVZQb/w+mcop3ZF\n", + "Ns3ZLnAPrqO9Ozs7YWxQh6Ojo7lgGbwX+xP73rKWFUj5XPJ+rDIq+N9iawy+wzzPsQYwx5guiR3L\n", + "oanFb0xbUuJXCix0kJrNZg/xd9M0/5OZ/Z8f/u87ZvYJuvXlD39rwU8wrrTvQJ5YypExFSHBm6FP\n", + "0uihzDilamgfoWU2n8oB71NQySDVPepj6J3wubzcYYGfVZFyXh2rnHQnk0lrwikTETsFcv3xvkU/\n", + "RHiPWZ5bJJVuJcaHVVqHFFRkG//mDxEIxOB68qED6uhHjx4F0wFMXpwKQzkjA8qJlQ8JbA7164UP\n", + "mABH1KggETZbAtgAnzx5kjRX5ZK4qrmTM89xklKU4Q8IXEaKE24wGHSev4CaQ6urq61DCwtAub7y\n", + "3FfsxM4HEM9zxQE8XIYf19zBQu2ZLGDiI8wcP6gL6scRqSrBOLsy4PDC95eOhxdE19bWwpxIRfmy\n", + "iZLv8eXGojJVXyozFAvc3sTKexavEb/vq/FiExb/hvmGA9XGxkY4kGM/4TmmonVL99TU94lN7Vir\n", + "4/FY7mk+5ZRZ26TKCa/VfOI9y6eQaZrGvvKVr0Traragaa9pmjv0v/+umX3rw7//uZn9naZphk3T\n", + "fMrMPm1m/0YWTARpFRUVFRUVFRUfF+CwvLS0lD1IZTVSTdP8tpl92cyuN01zz8z+SzP7t5qm+aKd\n", + "mO3+0sz+IzOz2Wz2ZtM0/8TM3jSzsZn9x7PIkTSltks5qEGKHY1G9uDBAzObD4X26tHpdJp0HlM8\n", + "MjHuoRhYWmSzYEloKPPDoL1sAlL5zQB2rlZO0zF+Ey9hxjQ5nPATbWL1ObeBcXR0JHO7eS1BzJk8\n", + "pdJX0m5KAmI1booviTVmShJV13hsUppLmKPYRK1M05DyXrx4IWkAMB5QR9+8edMePnw4V8bq6mro\n", + "59LQ5JhkFmvPdDptaSG571lDjP6H2ZqlR/zN46HajWvME8dmULWuIVmzRpqpDvz+w9ooNlf4fuB2\n", + "crLnRaHm7MbGRqgz5zcr4dBZX1+XWkwvjbNmSEElBS41cal9R3ELKfMhOwL7pN8q8TDvZzzf/dxf\n", + "WVlp7ZHswI16Md1DjnXcr5VY/le/3+aoYNR3j4NSgKWlpTBX0ZeDwaBFA3BwcDBnuvL14nHAHoR5\n", + "x47l7KrC31z86/u3q4bfA+1nM38uk4fZyRpAHZhT0VtToHUzOx131lylApFaZedumM1m/774+R8n\n", + "7v8tM/utbMkVFRUVFRUVFT/iuLRcez43F5MmKrZi5eCYcgZM2XD7/X5SWu+az4exCNlXimixKzwt\n", + "hNdsxca7pC9LQ7VVOUry7kLsmEKq7sp3jOt6lvmfegc717OG1TsyTqfT1nzf3NwM88eHHjOGw2GL\n", + "xoPntSJVTNWZNT7KRyrVVyqkm+cfsLq6Kh2QFWnqrVu3zMyC5hnlmGkS3vF4HJ5n7ZNfiysrKy3K\n", + "EbPTkHXURTlp8xiyRiKlRU9pxFWgyt27d8OYMW1BifPzF77whbCffP3rXzezeQ0iaynUeDKpJf5N\n", + "aRjw2+bmZtijU0EM0+l0zmkZdVFA/3LWBv8diOV4TPV56hoHyqj9LDUGm5ubc0EEHuzjhj5KEXjG\n", + "2ua15DmU7rPKKd1fN8uT13YlpzWbH2Mz7SutsLGxEb6bi/jNAqxhV75vsFjMIoScl3aQ8oPrk42a\n", + "zUdhvPTSS3jWzOaTufL9fmA3NzfDgKooIcXMy6pYpZYFUoM1GAxaPFccocNRG/4DNJvNWtxMR0dH\n", + "weyB33Z2dlpl+371iy7GzO3bwiYTFfGn1N4MFfHgN7BYXVJI8ZaoD3PMvNkVXcefnfW5f/x7VldX\n", + "w7zkaDb/br6PgWSk+OizozpHpHkzVOkBttfrhXYowSfXlypCj1PcmMXV9Pido1lTDqqz2SzMO7RT\n", + "mY82NzdlVCCeRRm5TRh9wOZ5ZQ4oZbvGAWNrays4+HaJkDMz+/KXv2z37983M7PvfOc74XcIeKhL\n", + "ju8qV2e1VwKpOcb7hVq3KgosB2UORn1w7ejoSCYPVsKdilj172VH7dy4+qCo0WjUWsvcLxxl7E13\n", + "/B6OiuX6qCTYuI7v6O7ubjiAqH7L9T3WCgvqXojhOcFpgUoOORzdy4d/vCeVTk0FsSnTo+LmYlcQ\n", + "djHJHaQq63hFRUVFRUVFxYK4NI2UWdxRlO4zM23u62IWglMZTsql7MOljs9mi5uIclqZlITQ6/WC\n", + "8z2kCq/N8BqpGH9QadmlKlOYSUodBXOSUFcNE0u7vtxYWG6JtqaUIZmd17nPSs24eAYS9e7ubitR\n", + "L2v77tw5CaR97733gvZBOeGyJFnaB6l+UZxAikMnprVFe1LzCnP86OgojKUyu7E5VbHss8TsTS+s\n", + "tVOJblNrYWVlpaVh4Pty8wrlYXx7vV4w5ZbucdBM/tIv/ZJ985vfNLNTsyDXRWkIzwJlZupqVslx\n", + "mqlrKU1nLr8ia4pVMInneGLzJjAYDMK4Yr1xrj0EUsTapfaQlAM10x9gTqyvr7cY+n05qD/aqfbg\n", + "VGAL7xPgrFNs7THtng/EWESrnYN/j3Iz4L2Bk3mrPsda4uCvx48fV41URUVFRUVFRcVF4FI1Uu43\n", + "M9POnDknYfav8mRaCsxhVSp553CWZyERoO7Ly8stgk8O6YQE9OLFi6DxAUnj8fFxqMv169ftjTfe\n", + "MLN5ibGELFP5Q3Fd2Vk35bzJ/VIiqTIhWte+ZDoIljRKnR9L7lOSrcrrx/56TBTox1A52l69ejX4\n", + "yHCILofCA379fv7zn7c/+ZM/MbP0nOR1pvxhuM5+rSjpUznGjkajlr8RS4upPmDHd4WXX37ZzE40\n", + "Uxzi7EkGp9NpkWZke3s7aBHYMVtpNwDM083NTRkMUILhcNjyLTk8PCymrgBeffVVMzvZJ7797W8v\n", + "VJdFwH4/GOvUN0VpY9j/T83FRQJ41HfCa15iztzKvzO1N3BQhNpH1TosddJm7Rie8VpS/nttbW2O\n", + "rBTv8O1UfoKbm5tyviu/P/YlQlmp/Rr72HQ6bZXBvmCchcS/j7/bvI9Cw8T5/9BvvB/4/WRjYyO0\n", + "AxaC9957T37HPrbO5p61FAMdWyyeJZwZaAEeaEze4XDYou2P8Rd5M0TMpIiFllKPLy0ttdKeDIfD\n", + "QF2P9z59+vRcItdiSEV4LMKNdBYn7tJEt6UH6NLNKFU/5eDPrOIlJgd1sFCHU1WX4XAYPhS8sd2+\n", + "fdvMLDgOMzgpKD4OzAmDuc9Orn4j5TqjTtvb2+EAB8Scg1MmInbwxAaKtvH6hilreXk5vIcd7/2h\n", + "mBOy4t/RaBTqv7+/L51gAY5EQ5+zEz7GHdfG47FMEcN9w3VZBNeuXZtL+bMo4ET8+PHj5OHvvMFz\n", + "SCVzTu25uP/u3buhDzBPlpeXW4fTWMBFCqVjlEsHwumAzBaL6AZ47S0SIY5nNzY2QvsgZMWEQJ8y\n", + "6fDwMPB0oQ5+7XsgGfrbb7/d2u9WVlZaAR6xyEbvMM7pgHh/xB6Da10O0ueN6mxeUVFRUVFRUXFB\n", + "+NiY9jiM00uTOf4iem8r9HJ9fT2cfHFSZu0T0FWVzvU7i3QSA7QJkIS89q0UXvLJaXRYgkupmlNt\n", + "jnE3qfuUJKISti6qCVPcSDENnG8vO0vmnCT9b4pHKgfloM8JaJVjty+fuaWYqwZtS0n0w+GwJVVy\n", + "2LBy5kyZPLjvsb6vXLkinVVZg8zlM3Jm1dls1jI98ztZ+5TSUKhxOA+ocm/cuBF+Y41AqZYX9yHY\n", + "QNHCxJ7z7+b9k7WPPpBiOByGcpmJ3L9PBRMpTejNmzdDeW+//baZnYwBJ6b25WIsc/2D9rC5XHEl\n", + "pSheuM6suSoJHGmaZo4brQs8ozrqkMqROhqNwnxHn7548SL0F5vBfMDG5uZm2GOYCR/rgC07ninf\n", + "t9ksPjalLh4l7gMxYA2z2b8rmHcS/FJVI1VRUVFRUVFRcc64VI3UyspKOJUq2zROtrdu3Qon6Xfe\n", + "ecfwLK4z4WZXfwUOiVS5jLzfVE7K4meVNiNni4/h1q1bQZLnOrHmzaytufIaKeX35duC57x/gfIZ\n", + "8kzqZt0kLyWdKIdN9ZyqC4BrzFQMKMlGjWu/3285eKo68/vYvwth++zrUUK0ef369SAtqnLRz4oV\n", + "neugNI05skFIs16L59/nMRwOW/5LXFc8yw7hHJLt/R/W1tbmSPxS4Dp7ot2PGkpTxuHxvl5XrlwJ\n", + "z4CuIEcLw8C74VP3wx/+UO5FXgujtGOj0aiVVy+nTU35YHaBn7OsbUnRdHBof9dvWYwGJQWVa4+D\n", + "Y3yeO567uL9p2nkTVQBUjBJBEXL6d5mdfmtWVlbCHsT1OQ8fP0BpGrlNi2iEYuWYdR/r5eVlSQcD\n", + "DRzOF+PxuJXPczqdhqCbj52zOf7GxgeOir29vXAYKE35kTJB8ULLoSTVyHQ6lapfQJWF+rEjNVBq\n", + "tuRy8O/q6mpQK6PuGxsbYdEsLS21IiBj7/UO3moz56Sc3Fcc4cXv8GUoB8uUGr10oeeCCFAvddBL\n", + "HeRKOa1UGUdHR+E+Ns8xSzfaBkZrVrWj7Zy41Sff5cgZddjg9pZyZPnoGfxulv+ooh3YlDi1Sw7o\n", + "K5jm9vb2Wu0cDofh0MnzhTfrs37QY+CIWi/85TijwEuzs7PT6v+1tbUwJ2DCWsRV4LXXXjOzk4MU\n", + "kNrHeO7gw7JIpgEOmvCHL3VQUYl9Y1DZLlKCAz6KzICdWsvXr18PeyVHlaYOsakIQrW/q+9P7ABX\n", + "ut+d1+G1K/jwiv5axL3FR/yp5OA5QHDgdG8Yk+Pj41ZyeGXGVQfaGKqzeUVFRUVFRUXFBeFSNVKx\n", + "ZMQ45Sp24q4n142NjXAvTDwq1xFDmQdi5iWzPOt56h1mbY1av98PUr3XAHE7FAOzr4PXminNELeB\n", + "1bJeMlL5oJRWic1uXG/FC8ImLrN5TYSSJhSURlLx0bATsTeTcbJKlKfmp2LN5X7mkH0/B5TmivuE\n", + "zbNKkvdSlll6DqZ4wI6Pj6X2QUncqTWX0sA8e/ZszgyJ+zA2nEPLawtj5q2Uc3uMciIFNT/Z4Rr1\n", + "Rl1Yy8tQfcTcOWbagX44HAYOOGhHSukLeC5CI/Xw4cMwZ0sdsXMaEJ8rjpn8OTAIaxh9pRyDlQko\n", + "Z7rHnOz1enOa3BiuXLkSHKS5LKX99vvA/v5+a+/g/JVYo8+ePZN7SAm4bYpuRtG/MFhj31V7ifK2\n", + "trbCPOF6Yww5wMQ7lue0lphXzH3ILide08x7Jc8J1naala8LBsZmNBoFUyf44rj/ct+aqpGqqKio\n", + "qKioqLggXJpGCtKUckYFcGLt9Xot/5vV1dVwaobkt7e3J6V2Ub5kwFbAaZylaK/Nun37djjdsw+H\n", + "so37DPPD4TBI/5wDyte/S25B4Nq1a8FBXUnqKf8g1rJw2H1XwktAOSPH2gRfG0gxMZ8C5fOEuvD4\n", + "KqJN71StnOs3NjZazvvr6+sy3Nn3C2tHcn4E/nrMyT2FUl8vtFtlOWctFBMQeuk553eI8RuNRpLq\n", + "wEPRJKgciTl00Uix3yLK6wqsZdZSMVs8NKAPHz5M1uPGjRtmdsKqXAL4zR0fH4d9Bz4j+/v7Yc6q\n", + "+cb0EH4NxAhoU+ubtQa+DweDQStk/7y+N0xzo96tNNKl7/XBM4qRnOcka11RLq8lr1nhOqk5ntMU\n", + "4n2rq6utdTMej6XmH+Vw2XgGWqimacL7umhFU3UFoMnb399v3QuNI+pqdrK2oFXMMabjGezLi8wx\n", + "vKPX64U2Ya1MJhN7/vz5x9PZfDAY2Gg0KmbzVZFS+Du10a6vrxexv167di1EzeTQdYNX4M2JD4xm\n", + "8cUPp2VM/BcvXsjkrQzvuB37mKc2S440xCaOSV6alFOZEWOm3VKoReyZ8sfjsWThTh0I+f24zoe7\n", + "1AGFWbgVd5cviz/+fPhTmy6nQPB1VylYUmDWccyhra2tFpu0StXS7/fnTCExrK6uhvvQ97EDiz88\n", + "x+rs1xxHPZYepGIfFgWMAzCZTFqJkTkaD2PNaZ64j3yaktXVVXv1w/Qub775ZrbuZmY/9VM/ZWYn\n", + "44aDKqcSSiWyLU1arExOAJt7OMIsZR5JRfTyh3QR9mplPgYwzhyRWHpIUOscY/WDH/ygcz1LEeOn\n", + "8nxUZ3U2L0m9w2uFDxveFMfmT/4mLRLM4++Dq8Du7q4cYwDzYGlpKbSNv/2Y+/j32bNnxfyM1bRX\n", + "UVFRUVFRUXFBuHT6A5Ww0yNmTqH3mdnJqXFRlS6/B/9yaGWsvNg1Nj3iVF6aJ2ptba1Yeso5vHuK\n", + "iJy2gqUUz6SttB3qN8WrxJo3Dk1WJlbFz+L7vJTPSznXc55GaAiOjo5k36j5xM7U3A/87+HhYfib\n", + "zbleo8JaFqUlYw1Caaixl/5zpkJ2wleaoVS5LOWlzHjcNvyNf6fT6Zxjr9nJ/FPrTGlU2ESlpHSv\n", + "8WuaJmnK42ATn2ONoXjiuMzU3opn79y5Y6+88oqZmX3ta1+L3s+ARur+/futRNYxZ/gUuJ9VoA9z\n", + "7OBfzjqBd/isEpPJJLlH8tpX2uVFM0ewRhxrdW9vrzXmisNtNBq1XBBU4A23g53wvZlxNBq11reZ\n", + "SZOc2rsAvnZR9AdLS0tzloNYvXIoHbeuPFaDwUA69p+FB8vv28fHx2HOoB37+/u2t7dXNVIVFRUV\n", + "FRUVFReBS9dIeWxvb4cTJvxwWGrHKZx9F1Jhp+zPwZK6l9Cn02nRyXY4HLYc30upDpaXl+ecUVF3\n", + "JdmqUz2egQ19NpsFrUguVLZUelFSgpKMUlrAGOmeChf2/gCxfEolzNwxpOg0GF4jpHy9mLGeCTL9\n", + "O2P+Ol6KjUmd/r4cqzy3wT87Ho+TjPq4NplMgvYBmg72CfL0AGbz4eBcL9zng0h8/jB+r68TO0Gb\n", + "zY85NFeHh4dzzNa+z72Ejfv8+lxZWWkRnjKp6nmwPzNAQHz9+vWwVlJ+N5zfDHQJ77///pnyfHoW\n", + "bs6rx4BWDv2jaGG435WGK0X0G4PXXE2nUxn4oHLZ4Tr8Sp88edIaw+3t7RAKn6tHyneU/SIV1NpT\n", + "WrmcJse3c3V1dU5rgvcqH8rU+1KBQzxeyrrABMToa9wXC7Lw9AelmQtms5mcO13pcjiADGPG5wvV\n", + "/zkfqUs7SDVNY2tra6ETeCNWETXKWZGdFM3mVck5x201iTDhcW1zczNMDjjhIkUN3zcajcKHB87Y\n", + "w+EwmDoW2ey8o513Ak4BG+2LFy9kqg9fhopYM9MOoiWO8U3ThLHhRJeeF+bg4CC5yaTMeHxYK40m\n", + "w4Jk7ivUnz/c+MjFTFXMVA74TXA2m81Fk3ZBjGdGpexRUUK+vRyNAzMez08Gxhwfz9LEvbmPEo+p\n", + "d7iOgQ9sZvFE2kCXqD023wPqg3FRwLwfDAbFATcpsOle8RCpj7RK0u2f5T6NfWDwLs+vFuu/EtNP\n", + "LILwPDEcDlvfC7UPMZ9YzgWhBCr1GH/UmbdJHRK5zlhLHHmrgiHUs6nE4115ExU++clPhu8X9oYH\n", + "Dx6EPffWrVtmdmLeRtnYE/b398OZYJGAJH/Qm0wmRe4+S0tLYd/kA9ru7m417VVUVFRUVFRUXAQu\n", + "TSN1GeVWVFRUVFRUVHRF1UhVVFRUVFRUVFwA+vlbLgbnEbpZQoz5UdjafXlmcaJK77yqHBmZXbdU\n", + "cxfri5SzeVc27PF4LNvlc3HFHNU5lxzgSeEUXUFu/Dgk3jN352gDFL0BO7YrB3XlO+ZDvzmg4eMA\n", + "lWfsPLXCZ11nJWOdq/MiufY+CpyHz9VHvY8BOYLXXDCLojwpoYU4q3N/1z6PBX0A8GnDPlFKJsl7\n", + "iHICX2Ru5Bz8gUXpI3I4771DgQPMVDtK/WJT45pbU1xurr2XdpA6D6gDlF+IpZw7w+Gws1Obmryp\n", + "D1Upu2tuE1Es4YuwrHN9/EbBUM6mfADxiR/N2gck5gABFD+Y6ktVF7zTbN6ZGzxIPJY+ujIW6QOw\n", + "E6aK+vIfjaZpiiNQzgO5Td9DRUJ2+RCUbPZn2VhjkTKKUfs88FF8CLiM0nRUKcT4mFQUbaw+qeux\n", + "+2N7UemBNbWXKfb0HF9TaYoqjiYrAQtvar9T7P5KcPTva5om2yaUm0rFxNF4qfrH6uDbxFGgXecl\n", + "l3WWg28qGlxxBzJSSdq537h/U99jfof/npXM9Wraq6ioqKioqKhYEB9rjVTqRMoJG5kHpeT0b9Y2\n", + "z0wmE/trf+2vmVk5w3CK44cleaWCXUTNmwpDVuDQboaSInyuMIbK7cSSng/BH41GrXD8Xq8X6AIQ\n", + "sruzsyM5nrwqN9a/Xtrc2toKYbYoA/Xh9rKJUrWX6TeUhkn1f4qn6bygpNgStXZMkxh7b+rvGFIc\n", + "WLn6ndd8L0UXbZTi/eraHzFtUkldSjWDF9H/KZQ8o7Ryk8kka07Hfb6sUvPmZz/7WXvjjTeidfG/\n", + "cxmlc405rVIYDoetPUGZS/ldShOSM2EBOV46XlO+/sxzyNe8dof7Eu1QWu/ceOXmMb8n1h61zpqm\n", + "aSXkZq1nqh9L7/O4dELOj4Kz5TyhBimGErUn868wuqrgYxu9V5k2TdOZ9ySVcPT27dt2//79ud9U\n", + "cllOiOtTz5jNmwI9Nwr3s7KXM8Ebxob9sOBDhcOd2pRY/Z1LaOuTpPIzqOtF+OuUrJUuZqtF/Spy\n", + "HyUgtvGpcs9jHzjvPudM8CxMlH7QzsOkV3qQWqRPz+N9OR8pBc8jxs+W7k2p+qnDS+6jXpqIHvVj\n", + "k91Z0tsoN43cs137XB3ccvOz67zb2NgI+yITaXuuOLV+lOlRQX1XYu9L+UPl5rbax/D7rEbtVVRU\n", + "VFRUVFScLy5dI1WCWOQIHIs5mWZp+gGFL33pS2Zm9qlPfcrMzP7pP/2nyftLIwdwUlen+6ZpJ1CN\n", + "tXcRh1F/Co9JZrgOExWb5lKSHif+VFId+mg0Gs2xnJvFpQ+UB8l1b29PslwDYJN/+vRpK+nu2tpa\n", + "aAtLkCr5cmmkpC9DSUpn0Y6ctzM0txd1Wl5ezjKLnwdKpFl1nfugVLov7fNY/6bSMqWcltWaGgwG\n", + "YU6UjmVpFG1X013s3vPSAvqyUmWotafWT66e3FcpB3RVVwdhQ/IAACAASURBVH6HH7dYn6WsC7w3\n", + "eXbymIk3Na9i7VEmtq5Q5apE4Apsfk2txRs3bpjZSQojNXal2r9SDbwPlCo1z5bu+fiOVo1URUVF\n", + "RUVFRcUF4NI1Ul25LnKcRimocFu0PycVAVtbWy0NR85BOucrBY0KqABy9eAcQLnxK5VelBYIUFql\n", + "1Dg0zSkdQI6GwksnPA4sPSFnE+dkBFhD5MeVc+hxmb6P+/1+K+xVSSycFDil/fyofaTUNSV9pvzd\n", + "cmXk7vcJqBepc9f9wEvqZ9FILerrwrkg+f7Us2dpOz+LZ1Kh7DkuqK5YRDuiND08F33fcxns31na\n", + "l0rz78s3O10jKFeN/Ww2a2nEVT/nKAy4bqlcpLxu1T7bVSPVxS/J79tcnn8+dg14/fXX7c///M9b\n", + "9/k+579TPrDT6TT41+byU5ZqclMciIycj9SlH6TOAs/x08XjnpMZ4lm8786dO2Z2MpHff//9TnXi\n", + "SeIH5datWyGqLBUlZ5YmIVMTn5Pw8iLuwoVhNv8xwYcRTuFcV2/eYsQyvJeQQg6Hw3Afmxd9VBw/\n", + "e/PmTTM7yTauPob+N054zO8via5ZWVlpmcTO27R3EUiRiCoC1dQHPmbK8mPexTH7PByoL+IgVQJu\n", + "OwdNqKTAKQdlVb9Sc98nPvEJMzO7d++ebNeiB6mcM+8iZqac2aukzihvaWlJHmr8fqGcjblcHqsS\n", + "c66ZJfdHRsn6Ufcxj91ZDlLq3fx8jnOr1MTmeQJjnIQlJtbScvk+Pg8o53o2L+NfX0c175DguZr2\n", + "KioqKioqKiouAB9rHimAT5MsOahTbKmGDRIkpA+z0xM0wjdjJ3SYvyAJjUajoGpMSTHPnz+Xp3+l\n", + "WfMqYlZrMz+UksYW4d1RPEhe6mQojVPKbMRO6SkTq5kVaYsGg4Ftbm6a2Ykmymw+JJnv8/VZXV2d\n", + "S0mDugDKGVL99lFwRyl0DWvngAaus5L4ffh5jvMGGI/HrXIX0SR1DbdfRKMeeyb17lz9gVh6JLP5\n", + "fitJu2J2Ol7Hx8dJ5/Xt7W0zO9FIee3DeZr1YuXnwP3n509OU5cKxR+Pxy0NF5uZmUdI1V+tf3wT\n", + "eN9QbU5polR7lVaI90z/nrPQZnikvpX4FilzqjJNmp3uh6j//v5+69s3Go3sc5/7nJmZ/fEf//Fc\n", + "mWZ5U7oqN/WdSq09NoOzGddrsyaTSWibytgRQ9VIVVRUVFRUVFQsiI+lj5SXOhRrqrovdq1UeoUj\n", + "m3cmz2E4HIaTMqSUXB6fnGPpIk63Zu02ltjTm6ZNMhrr8xTFAcqISRgpTQ8wHA6D5ko5L2OMptNp\n", + "eE+KLFH5Q7F2TJGDlmp8vMMot+cykxb7+ndJzlmKkmdKSfAYZ9F2sIbzLFjE4T6laV6E3NTXJUdX\n", + "8TM/8zNmZvad73zn3BL/lqDUXydXp/OgYuD+9rk+Y3VSNChdqWe6+vLMZrOWU3fsO6X6bREfqRQW\n", + "CXJgB3BfL6BL/6YoEUr7N9WO3F6k4LVyKR+pj6VpzzcwZi4rndSl5gCftHh7ezuY8RAtdnh4OBdh\n", + "hvqVJMccDodzKWkANQEUfb9XxaacNbugadqpUNQHod/vy3amIoZefvllMzN76623wmGTs3rjsATW\n", + "8/F4PJdCxpeBjfHq1ashEEBF9CmHdYwXRyTymPvFrBzLl5aWQjsU7wo4WS4Tfi7wIZZV2Jyc2UyP\n", + "uTKXLsISnDKJddlwPUod2rug6/vYbABwFKhC6kOvnLlLOXf83yVY5BCzaBmqvJhJqRQ+cpGji9V9\n", + "gJpfuWS5XaEc2zlijqHKU1GMpeBUV135FVW9uf6q7zxj/ZUrV0JaMCDWv6lAgNR3nq/zO3wZ6sC3\n", + "tLQkry80B4vvrKioqKioqKiomMPH0rQH4IR7cHCQzMGU48YpKYMlGJh7xuPxuToSdwnzLkGJ1H4W\n", + "NbCX9FSiy1woOTROrC1Cn7MDLT/nNSXKiXA6ndq1a9fMzOzRo0et8pmtF/ODnXX9nMlpWWD6nM1m\n", + "SWoHtPvo6OhSzEzqWf4bbWSTJ/ePCurwdYjl7rrovSQXOs0asK44C0VAjCE5RffBIfYpDQ2gAi4Y\n", + "523aK31H1/2ladq5Ps+yL6py+/1+a40qV4XRaBTGAfs/OzmnTGylCZRzdU6NeayM8zDtnWW9dskC\n", + "wXu92bxmlZnSlVUjZeosLZ/f5fd8tV+kAlEq/UFFRUVFRUVFxQXgY62ROgtyEpXSRJXCP8vSjjpF\n", + "l+YWyqHEgdJjUemllKU35t/CmhkPhGqDnNRMh7Uq3zHOq6eI81KEnMoOXkoEp7SeyvlSOY9+lMj5\n", + "m/Bvag0oUkBuUww5Cb0rZUPsntT1j1ojxaHT5+HYzXPIz7eYFhD3QYv+5MmThZxpU3VJYRGNVIn2\n", + "SWltcvdhD5lMJi2mefbrSbW71+vJoJlUO3LvO0/NFf+d63NcZ58h1uR4tnZFOVDqy7W8vNwipR2N\n", + "RsEHlff1Rb5jqWdLHfcBlRlE3e+JrVMaqR+Jg9RZJiOeNzudRKwmRwcOBgN5GCrlCkptPLmoCH/Q\n", + "6tLe3EQ/zwgPZvBOHSJi0YnY7NHPx8fHyUMpoMwaMVOHP1x98YtftG9+85vZtuU+0mwqLFmkbBI7\n", + "L3Q186X4utiRnscvVYY6uOYOa+fRjhy6Rkp2MWssGq3FayU1DrEDnP9gxD7c169fNzOzDz74oFUu\n", + "o5QhveQa4zz3F19+yUEl1t7SdD+l7UylEjnLfM6lEVL9m3KqLkVsDZRknzjr4dCbt1UWENV2Ntme\n", + "xx7SZR+opr2KioqKioqKigvCx5L+wCN2WlfmmVRoJcAOnvwOlRNJaT2UqU6dqFlSBpRU798XO+2r\n", + "Ol+kRtH3ZYxfxdc3lrAV7YS6V4UpK0nv8PCwRXGg+shzUpmVJ3GN9SNMJ0x1wFonX/Z5shF7lIx1\n", + "LKeYx/7+vjRhqLYBKeqLmDYrxYOTQ0rbxf/ftc9zqn+g1Mzjn/H1jJloAG/GW1tba1GxxOqpkm8r\n", + "U2yJBoEl9PMMijkrUg7ZMY0Tfs9ZFFgz6N/Ha1rNsdKEtx68RlNrledpLKfgomMRe87PE3Uf7++K\n", + "mZ2Z4Tm4xWzeJJeiDFJWlePjY3vppZfMzOydd94xs5O+xHVPb2FWnkFAaY3VfTFUjVRFRUVFRUVF\n", + "xYL4kfCRYqiTI07A7JeSklJjttGUozI0IkwwlrLDo46qbDObO72nHNW7SoHcNnaC7eIM6stL2fG5\n", + "/iktVKlmaGtrK5BzQtphzSBr5bw0NxgMWqSb169fD/4j3LZUm1h6KmHwVbhIZ/OzzAkg50Sey4eY\n", + "kvTPS3PR9T1d+rzUuT0Vqp9arzntDmNjY8PMzF68eGFm2gcl5pfCvntm3Zzmff1zFCBqzZyHj5Sa\n", + "nzlnc3VN1S/n13cW6pxFc212IbRVWKTPF9kzUvej3zDX1NxcW1ubo5XwQP8dHR0VfY85b6qq33lY\n", + "BWJng5yP1I+EaW9paUkekNDgrhOZHaQ5igEDxqpJDI5naDXTasPYhDI7+TD7gw0v8NgAeuSc15XJ\n", + "k6E2j5TDOPeVv+/4+Lil5uXxQGJh7j9VPvqI+xQHmhcvXtjVq1fn3sMHVvTRaDRqRYLEnELVAQm/\n", + "KQff3Af3oxRIcmYXv6EoU9Z4PG7dp9ob+zD7g+1sNpMfra7g912kKUkdLP0GzHtCyTvMbC5VTMmH\n", + "rtfrtczbOVcGLhdRrDhIcX1TXFWx+qdwloAfhq9LbN/zZlJ2ZWCOO/zG9UMQC+6L7bOl+6vaH/0a\n", + "4Pel9ujYQVT1R860V2L+ns3a0dZ8D+/fal0rlBw8vXkaZZR+t7mvfZncz7yn8f0MJRAq9yD1bVDv\n", + "86imvYqKioqKioqKBfGx00jFnGWVdMds02YnWg2YhXJaGyVpejX5tWvX5KnaM36Px+NwimWmXM/W\n", + "urKyEvLHlZrOFFL3lUiZqCtO+MpJm9lrGZ6zYzQahfewhAFzRU4TBckRGqd79+6FayyB4T3MI+VN\n", + "u3t7e3NqYP+Orv2sJDmF0WgUJN5FpPZSM1OJAzBLrixFp7SdqWTSrJXl62osu2qkclqSlPlDMa93\n", + "KS/VbymwxKq0t0pjDigncs4WkKKhiM3FVG7Hrg7+MXPaebJ6x+pSkm+UobRFwGAwkPyAfn8302ag\n", + "lEuGgsq6kVurKnBIwWtbYtdzv/k+4rri78lk0jmBsao/+nlzc9Pu378/91zKChID3s1uJKlnc33J\n", + "/88aP7zPW41KTOVVI1VRUVFRUVFRsSAuTSPFjmNm82HD6vTsT4X9fr8l+UIbZaYdKLls9h8xOzmR\n", + "Qsq9ffu2mVnrNI334aSKPHJN0wRNk5KE4OvD+eZYOimV7rwWgPuwVBswGAxafkSKRmFpaUnawb0f\n", + "VL/fb71vOBwGx1kG3nfz5k0zM3v48GG4hr5hJ2jWcN26dcvMtFZC2dp//ud/3szM/viP/zj8xlKl\n", + "l/AUESj3Lzugq4CBRVh6gZwmKncPQ0maMdy4ccPMTuc5+wmh3aurq3MSPKDmRipvYk77lGqn+i2l\n", + "+YlBzZ1U3sScDyL/f4kkv7m5GfpDzRdoZ7GX5NDr9eytt95q/b6o022sH73GJUceqZBzqvbvVPnc\n", + "co7+gKrf1atXg1Y7pwnBunj//ffDb8qfMAXsx4eHh1Fqg1j9Y+9b1KE/FnTk84PGmM1T2jWlLcJ+\n", + "sbe3Z1/60pfMzOwb3/hGKBPPpMirzdoa86OjoyQrei5ARt2n5p0PwlEWG49LO0j5DUwlLfQHKrO0\n", + "KlGxTisVtWJA7vV69vz5czM7HSTlgMoHDD64wZTF5jLUkQ9QmAi8KaU+eDzonC7C7KSv/AFqaWlp\n", + "jtreQ0U+TKfT5EbBY+X7gzd9xaHDgEM5DlD9fj+Y6t57771wHw6o/G6MCZtGfDnM1o1IPZTD7eDF\n", + "rA6g+KDxbzxG7FBsZvKgUYrcByj3ESn9eClTHCJRcZBiMxn+5bapwyTX0ydBVs6hvl7qeleoj0NO\n", + "OPHlxfiIupqcUnj69OlcInYPzPfBYGB37twxMwsHJcW5NpvNpOCU4gIDYtkH1Nj4fUftV2wm4d+A\n", + "XBCB/43NTKUO2cBkMmmZ8R4/fjwXROSBtFVPnz4N3wHeG1JBLGruxvooBiV08DMqeIH3O79u+dlY\n", + "n3suKwUVuaqeOTo6ClF4SCb/+PHjcIBS4H0iFT3JwmxKYEWdvJIG7WCliWqDmR43zIMUqmmvoqKi\n", + "oqKiomJBXCqPVI5ziVHK2aFCHNWJugSs0mN13+c//3kzO5V23nvvvaApSZ2sR6NReE+KKVepHBcF\n", + "+gHaBDPdhz7nnTrVs3pcqVjR96VJXNFXZvPmSm9CePXVV+3Ro0dz9x0cHARqBeU8ivYcHx+3+pol\n", + "OQbqj7mmzHh8X06T5KXEru/wdSu912sXYxQGygTktQ6bm5tBQmdH/xRKnUi7osTM4IMM1DOxgBYv\n", + "sSqnb+5L1uR0bTOvN6892dzcDDn0vv/975vZiTYXay1XRomZX9GbqPbmHMu5X0r6VJnxzmoWTAFa\n", + "8N3d3WLzK/aY1B6htDwciu+1x76uin4nZZLlUP0UN2BpIEBuLak6+3K4/gzu89Sz2Gdv3boV2o75\n", + "zmeDVC7F5eVlWU5JcABr6oEUA/6HfSZfXDVSFRUVFRUVFRUL4tKZzVMZuflU6U++7L/U1bmSn2Wp\n", + "Aidkzgl3Funah1aWsnubpR3LFS2EpzQA2CFaXcc7Svwq2PHYa7DMtNZQSY7sAwWtErQebAfH3Njc\n", + "3JRaEPSRcl5kf61FmZ7NtJOpXzPKdq98RkrLVWWUaqRimgZ1X1eH165l5JDSKvAa7eL3pMj0Uizh\n", + "XZn3uV7cdu/PE3NyVc6t0O5CslbldtGsd2XrVu3g8S0JGIjRpeTK84hpcGL38b4NxLQKJet7NBqF\n", + "50vnHb8j1X+p9yl/3Jh2CfVncku0TdUh5hPalQ6mVDOY8jHkoK5UVoSYVSNF/szvKN3T1FyMUaOk\n", + "NFKXdpDqatoAVPqOmKOoKDdaZq7zMQGbpgmDh9/YFMcOb6noBK67N5moRcX167IAlIrZQ5XHSEVK\n", + "5OrFmzqbLs3i0W54Bv3C0TMAmxl5c1BcMSnwOKRSEqj2ArxRpZitS6OO1PVcWglfHzOdKgMO5qpP\n", + "zfTGAudRmFdjkXxdscge4NvmHZC9ENY07aTayvF0Mpm0Pqpq/HOmk64fp+FwOMfjgzqVfHxj8O3I\n", + "1Tl18Io5pQMl+0sM6qO5SHtzH3MA+xgcyznAxb/Lv0+V5ctV0eBmZcKGOiizOW+RPuf6+UCg3GE8\n", + "F3ChoNrJaWC47iU4DxcB1Qc8n0uFyWraq6ioqKioqKi4IFy6aY9+C3/nJIEYtre37cmTJ2amHdnV\n", + "O1QeOUgV6+vrwfT07rvvhmcWkZrwnC+DzREsiXgJIqYxUqzD3G4vvbA0riTRnCSSUoXzO/AMm/tS\n", + "Kme+htBvSIysMeOce3gGpsLnz58ngxJSEhPzvfD8UH2UmkcclLCIlN4Vqi7e2Xh7ezvQczDvEH6D\n", + "SSlmBi2Z72oexMxCOc1w6lrO2bxrn3N5JWZcVcdSU0JME5ZCV7cFtY/GtB2pfQDIJUFWjtaldSy9\n", + "P+X+wfsnuzlwhgmzeWoPVS67KuA+1sTnqAvM5rXavK/lLBKlUGPYlYkc7ciZqHNaGw4ewL8pTf2r\n", + "r75qZidabXAMYu9VvIODwSDUORU0kUtkXNIX3J5YwAV+rxqpioqKioqKiopzxqVppDyTtDpZ5/yd\n", + "lERV4ry+CDMvsLKyEp5X2b/Z7l8iReb8k1JgaTEW8uz9l3J+BIyczxPgtUCKKC4mBfoQ4+Xl5VAe\n", + "2sKavFyuphIfKeXTNB6PpYM3oLQPKUn+LBqp2FxM+Qcp5MLgff/xeLDEmZJI2a8nxUSda1sKpfsA\n", + "+0F01RZ1QYnTcuw+gMemxPla+XjkwPenNFul/aueUf48OSfxknVWGsZv1s7/yX0FrSuTIuM3zs2J\n", + "31RGBq5zKqCGofbZlD+O0vz5b6T/fnGWDS5X+VCVrAHlE8hIje/S0lJrX5xMJsn5pvy1UhYALnsR\n", + "zXXOApO6P+cjdemmPTj+wSQXQ4kq8cN3z93H4AnNBx78pjYyqHzxvhiz6qLO8wyOQlNpGdi53Sy/\n", + "abOjLTv9lUQqmM2bCVFuaWSebxMfclXEBeq0trYWIvjU5oayBoNBMOlxYmQVTQiog0WO9yvFW5bq\n", + "x1Iz0yJmodRvakPm39A/4/FYpr8pmRvKRKXSS5ylHf46yldCEa8V3+e5jwOQE2hypskSTi6+j4NT\n", + "StdjV5NoblyVS0HKPKPMoBxVHOM/Yqj2qDbFTIrqw1d6EPVgjjQgJgSm2qHK43qqtuE39QFXB2BO\n", + "PM4HFvxdaiIsNSmm5iR/V3LfvZJ5HNtnSwXHkrndZT6pa9XZvKKioqKioqLignDpGimvEYhJRamw\n", + "TVzr9/st6bNUIkU5ZmnVOXMG5bQZ0IBAoxJzNk3RC/D7/Kk9p3bH+7k8Zn/OmcmUlK00UudBOaHq\n", + "lCpfqY1zzPHKQTXmeG42r1pPhckzUtqRUpy3+UutAdbA5JyNvckuxsPG7wZKuKC4vYtodlk75fnS\n", + "eN3ktNUljNs55+uudS412am68PxcxNyorqcCQpRTtcrNWRpYwGWeRyYHrntKE+JzZTJ4bivKm1z5\n", + "uTH0dUo9G9sHlOkuFyTk9yLWKjHQZk/JwWXErEGA2k+UNaCrw/1ZtPdqHs9ms7l5DnjNH/qqaqQq\n", + "KioqKioqKi4Al6aRAqMvQq+VMzT+VszRMUdr+M3gBK6cB/l6zgehq00Z7SjVguXoA7pK6N5B0Usv\n", + "Ob+fnHRcQlpo1ibxVDn0UB8z7bhf4nDNUM7rMZ8c74OWY8AGmIwypaVS/jylErqva5dnS1m7S8vg\n", + "/svRYSifhlI27hLkJP7ZbNbSSOXILbvmmYuxjiuNmp/bsVDtVJ/7cvi+Uu1YjGZE+UgBqg9SGqle\n", + "r5ekWFBQGmL2HSrxX1HXu2g4VblAaX7Xi1wDpSSoOT+x1BrOaSlLv4GeTiU2bl7j0+v1wrrFb+Px\n", + "OJSboj9g5Bj9U5YYnh+q3jkfqb768aPAZDKZSzaY2iC5I9m0A/BixodUOckBikmXWbbZVOhV171e\n", + "L0w2PHt4eNgadOW0aNaOolMO11x35fzNm5jfKHKTTqn5+fnURgKqfAabUzlizo9nbPLyR8bfp6BM\n", + "DoBqe+ygjMSacDYt3UBVVGlug+FyuzpaK8Ei9Wzq/pIySq+hTTwf/HjkTAD8rpL7SiJ6/fxM7QP8\n", + "HnbmTX3Ac/VMMdvzx58Fx5QzN7fHl60Ofwox4UTNHWUCAtTHnP8/lUomdSBAWzzUIdabmWOO4CXR\n", + "22zeUv1XevBRa4D38q6HXXbDSEXomZUFOcQOCf59LGRjf5xOp+E7xnNW7X1eaaH2aLWmptNpS1Hi\n", + "FQK+vrxWUZcU/1tM4D8PAc+smvYqKioqKioqKhbGpTqbQ51ndqpN4JPjogziDHWy/bAOc//GwpAX\n", + "Kc/spD0pLUvOhOXvW3SclBrYm92aRud0SvEQqbYpp3nuU6XhWlSlvr6+bjs7O3NtY01jqt9iZkbP\n", + "SszPsrYN0hprVAHux67O5qVmvJx6Xr23xNSR0wylnHnZzMTzwI/lWR2LFSUHwJJyyjzH6GrOz+XB\n", + "TOVu5Ptyc7wkIGSRvuzKHRczCwJqf+F3LcJ55d+XS6h+1j3SQ+1TKfNwqk8XCbtnqLaVmvZSZut+\n", + "vx/+LqXdYEtNKsiBn/PP8t8qiAj0LC9evJDfBgWlRfVaKoUcDQXqdHx8XJnNKyoqKioqKiouCpfm\n", + "IzUajezo6CicCOEkvrOzU+Qky06/THKHkygy1j948CA8w1KekqBSmih+ltmwcU35KEGaTJGqKWxt\n", + "bQVtSyo0maVjvsbEnh5N0wSNkbLFA2wvZ82UIrzEdSVdo0/7/X7r+mQyke9L+UmlGIiVdknNocFg\n", + "EK6z9iwlXfF9vh2s9WQtq0KJNinmIJ+aOymNSi5MXr1DIeVfw+3h/vFjGZMuS7UKuG8RrXFpgEnK\n", + "t6dLHymfMQB7wuHhoQy4UEz+ysn9LG0DuI3nQUOQ0oTkylX38x6nxn9RPzz+LZURIednF6McMYtb\n", + "I1KBLazFUePJ/4+5E7MCmJ34O3nteezbmtoX1Dcu519Z6hOKuR/z4fXPqkAFzKejoyMZgOCtLjFN\n", + "nLeseC24QtK01zTNJ8zsfzWzm2Y2M7P/cTab/fdN01w1s//dzD5pZj8ws39vNps9/fCZ3zSzv2dm\n", + "EzP7+7PZ7F+K987QKUgK7BlmGcPhcM58Y6aZq83mk9oCiyYIVVFgMXja+16vNxfBFbtvMpmEjy8O\n", + "CY8ePWq9P+Z8l5uofuJxBKQ6sPIhrMRMxshxLfmPkmIWZvD9KXNaKS8WsLKyEhYu6sIH89S71abE\n", + "UIEAHyW6REqVIJZ4GOhq6lBRO4u0Q0E5HpfWv9QxPlfX1LzjjyUfnpQw4efdWdJ35Ey7OWb1ksM3\n", + "m1NSQkIuuTUjZcZNoVRwiKGUUbsE7IKgkgN3EWj8QUDtL6urq61vlnof72P8TfLjoBQWi6Y0A/x7\n", + "cjyRi2Bra8vMTr8XpVH0MWAdLGraOzaz/3w2m33WzH7FzP6Tpml+zsz+CzP7v2ez2etm9tUP/9+a\n", + "pvmMmf1tM/uMmf1NM/uHTdNU82FFRUVFRUXFjyWSpr3ZbHbfzO5/+PdO0zR/amYvmdm/Y2Zf/vC2\n", + "/8XM/h87OUz9LTP77dlsdmxmP2ia5i/M7K+a2b/278Yp32sklLnq6OhIql69JNXv9+c0UWZxniYv\n", + "qUyn01AuUyywyVG1Af96aSl2slYmNNSBNVGvvfaamZndu3cv9AH6I+VIl5OcYqpmSAnQju3u7trt\n", + "27fNzOz+/ftmNp9PC+Uo9m/WZjG8FPb8+fPWuCp+mH6/39IWsYSuNFEpbZAaL2Um6fV6rf5i7jNG\n", + "yjRw3s6wKcSc60vzyPnfYuHqKak9pZE6D9ORR0r1HjPLlDiyljqql4JdD3hPUlrllElUteO85lbX\n", + "QAZVx9gaNovTvSitWGnf+3oplurYO2IaPAYHMeTmrw9YYe0Qa0ZTXG+KkifGX4a6Yv9R3ym2rKA8\n", + "3sNUH3BuVliNWLOm5p0aB/WtKsmosLy8HPpS7bdqPPDtWltbC0mqcT2W3UE53Ke+STEUa4uapnnV\n", + "zP6Kmf2hmd2azWZwPnpgZrc+/Puumb1Nj71tJwevioqKioqKioofOxQ5mzdNs25m/4eZ/Wez2eyF\n", + "kwZmDeXOE5DXptOpDCVm3xI+YSq/Ie/7oLQgLAEpXwQFfgbaFpxSZ7NZ62R7FpsxlwUp4OrVq/b9\n", + "739/7r7hcBjKTRGP8XuU8/dwOEza0HH6v379etBExe41m3c8VBQW3OeoN/s7QSoBWGoHxuPxnMO+\n", + "WdzmrSRfD1+mv19JKZiLjx49atFCNE0jNVH+fbiX/1VUAoycs24soICfifXVWYgnVUh8ah3mtBr+\n", + "eqmGRWkXzdJ55mL+XF4rUqo9izmYK39IBR/8oe5L+T12qV/OJycVdFKKnCYSzrzon729vdZezt+G\n", + "lAO9+oYcHBwUadFi15TmB3sG+kKVi9/NTveGXG5ONT+xvxwcHCQpaJjuRWmigP39/RblwNLSUus3\n", + "7g8ec+XH6jVvDOVny9dS+xLee3h4ODcXuJ5cbr/fn3vG7KSvMMeU1QJ9Oh6P5zRWeJ/fy0v2ouxB\n", + "qmmagZ0cov632Wz2zz78+UHTNLdns9n9pmnumNnDD39/x8w+QY+//OFvLcTMDRsbGyEiS5m84Ez+\n", + "5MmT8BubFHCIwLs5io0PEJ7OXjnaoZ5m2mTD8GznzGirNjyus1f3v/fee6FcvEMxJfMAoz37+/vJ\n", + "jY/7gN+Xcsa7fv26mZl98MEHychBVS/ue/yNPl9ZWQkqWF4sfnHGuMAUSj5+e3t7rXYo1nY+EPJ7\n", + "/WbJwKKOwR8Ucmk+Uoer2IGAPzK45qMKVWQLYxEOXgI1AQAAIABJREFUt5KPVuzw3/UQmSuTzeCp\n", + "iDsV6Vnq8Jprk4q88/2pXBnYGRn3s4DB7Smtc6ovFzG3+nkec+pPZUdQQS7qw8dgs5fZ/H6mDsWx\n", + "hM0p+H5eXV0Ne5Za39xGfyjh9qpUMspczhF4qX0vFxWJ8jhgAHUpneODwSDUC2Oyvb0tFRsl2Sly\n", + "Tt88h1JuGmwy9KbC2WzWYkofjUatuTWbnWYQ4NRNfEhEEMpXvvKVZL2Tpr3mpAX/yMzenM1m/x1d\n", + "+udm9nc//Pvvmtk/o9//TtM0w6ZpPmVmnzazf6PePRqNsh+dioqKioqKioqPGhyJmjtI5egPfs3M\n", + "fs/M/sROTXS/aSeHo39iZq9Ym/7gH9gJ/cHYTkyBvyPeGwpFRaGK29vbk6fsmzdvmpnZw4cnyi+W\n", + "gFKmrBg/R0olyepPr6VYXV0Nz0JaUIzaSoJksHTiVZdd1Om5ZJWscUFdWFLBs6quiqncq5pzDONq\n", + "bFDWaDRq5SNU87GLRqpEKmJNkwomYF4yxW9TkrhZheLHUKJVUGa8XFg70KX/+N2x96nryvl3kbDx\n", + "ruUyWEMDMA2J/93sbBqpHLpmNlBmHG6vql+p5nDRLBEx87HX+LAkz9qY1DqEu8Th4aFMQK/qojS6\n", + "3sx8XuPH5aacwxnMho16+rnKFDSpOcfrlt0dcO/GxkbQlLEWmrWYsfodHh7K+XnlyhUzs2ApYPAc\n", + "wr6Jco+OjlpjrbSUw+FQftsWXXtN07TmTGytpBJUK45JbxJP0R/kovZ+3+Jaq78Reea3zOy3Uu+t\n", + "qKioqKioqPhxwKXm2mNJXp0g4fdjdspknZMIcqR7+Bf3QetydHQUyi7RajBiUlsJgVksrLU0LFcB\n", + "Dt7Hx8ctp++Dg4Nk6ChLginqB/WOXHv9GCvNG7c99b5Yn5cEFMS0lN4pmOcn+4mhX3BNSXc8x1Ja\n", + "lJiPlNL4lPoRqfmu4J/N+WsxFtVwdGkH5gv+5bmp5sZsNpub56nyUuXm6s/lxRDrS3Z0NcvTGjDO\n", + "kyjSlxcrM6f15GspjRlri7xfipne//1Ycrm5fJe+LV2IZUsc2ku1vFxuTuui2lSa3zC3HlN7OaDG\n", + "mn/DvzmLCX9LFt0nMEfM0r50ZqdtZ79ir5U7y1qBhSWlkbq0g9Tm5qbt7Oy0HDJv3LhhH3zwgZnN\n", + "T3QVKeWdbnlyQ4XJ78599FMJO4HYwvARBuoQ1u/3sxE5McQmgu+Xu3fv2rvvvtt6Nx8csQjUR5r7\n", + "wB9KSutgZi3Geo46zCUhBRZh0s2ZR8y0KY6ZfplTC0EG/F6w5j59+jQ8D5U42ssbctePNYOfLXlP\n", + "7IAJgYHH/qJNRTxfcuzZvp7eWRRIvYf7vBSK8yjFpcTXU4fO2AFEsTqn9hj/Trwn9iz/xgfqXIBC\n", + "CZSzNO+FyvyVWsOpJOccNMHtx57EHD+pcevSJpThy+X9otSEXspwD1y9ejXsHTEHeeUY7aOZYwFI\n", + "3iG71+t1jsZU/Qvz7MHBQTSTAT+ztLTUcl5XGA6HUtgAuN1qbgOle6+ap9vb22Z2osSByS92kKqs\n", + "4xUVFRUVFRUVC+JSTXubm5stqgMGtBqHh4ctrZKSHNbW1sIJlFWY/lQay6sG5BzPSsDq4NIknqmE\n", + "vAq5vG8ctotyt7e356gjuL5mpydyla+KnddTTqFKFX7lypXgwMiSqNfasDO8krIAJSWytMP1KpGK\n", + "YnnQMCbsUO/ZepWaP2baS5nTUvflWLZzSAVk8Nh7fpjZTLM6q3mcmttdtQVdVPGsHfEaqZy5MqUB\n", + "8fXxSIWcx7SoJfQhMY6iUnOvrws73J9lDinHd9bk+HKbps3Q3mVcU1odtVem5p/SEJq1tYtq32Nt\n", + "G+8hft1ykA3AZjCeG9DkoKyUZQTP4v8VRQBr23E9p8nnDB54n9LU+4CgnPlfjRvazgEIfN+i87Jp\n", + "mmC2RF+qwCazdo5CFZwyI8oOdg/JOZtXjVRFRUVFRUVFxYK4NI2Ul+IX0fzAOU9poaBVappmjnHb\n", + "TNtmSyX+nESV0tSYzUtrZvN5i1TIrJKElU2YNQ78t3/PJz7xiZC/D+BwXH6fl6Rms5nUnigp3PtX\n", + "Kb8kLpedIZUGSUlBXsvC2qKU1LS9vR3qmtL+jUajMGcwt1ijx2MDyYbJVUv8dXK0Bv53Rkzz4ykv\n", + "VC6znLNsSoNUyqhuVuaDwijV3iqwJg9gCb0rC7NCr5fOVJ9a/7wGuF9yzs/AotrxLkEEi/Q5nvMa\n", + "jvF4XOSzyPNJ3c+0NCl/mFTIe6kfYKljeUxrCKRyb8bWT6nWlp3gVSg/3oM6sMZH+QsD6+vr4Vlm\n", + "M8fejH1WaZAWcebmtarGFZYLXONAKR7PnF9lSfnKQuBJjj+Wzub4G52gmMhZRQcHX+DZs2etgRsO\n", + "h61DiVmbq4qv8cbmFwZvmoodWZli1IQ4i7Oxr49/NzYePoTx/f7go1IDxKAOSF4VGtugPe9XrP4l\n", + "SaG5XakNKma2LL3PH8zYHMlt8JuI+kAeHx8n0ygwSsxkucNVVzPYWcx0MZRwwcScsM8D6iClVPtm\n", + "baGKgyFyzvzetGuWjjBUpnHPWefLVRFcpQeukg/LeQmObFLy+0nOcZvr6Q9QsYO+X6MsjKXM1zmo\n", + "vQZQB1FOBMxAm9C3y8vL4b5YABLuL90nvIlqEeTGH6bTo6OjKD+jr0tJv50VJXuGCp7iZxZxl6im\n", + "vYqKioqKioqKC0JR0uKLAMwwSmryuYkGg8FcqLmZ5rJgCQYakcePH4f3KS2GkmJybOH+ZMtSkQ/3\n", + "jr0HkgtrwlRfpHKj5ZzNY+rvVIguTHKTyURKhF6VvLm5GdTALEWrenknvqWlpaCJYlNgSupQWjSU\n", + "++TJk5akpCRgrlsqx5/CdDptSfzHx8d248YNMzN7//33w70lmhclyalgiFL6g5xTNGvJ1Pv8nOji\n", + "DJ8K2Vd1yWnbFqG/AHJmEk+7knM25/cxxw2QoiFImeI5oIWBNaJyKOZQwuSee1dXbaHSzinzC+8p\n", + "/Izfa/j/eV9hTZTZyRpUFoyU+TDFzaSg9kfWRrGW3O/hMfN511yAOY204l3ieefv4zWstKjs8oCg\n", + "L/5NzSelpfL38/VU24bDYStHbtPofLgppFwQ1Hocj8cLadGqRqqioqKioqKiYkFcmo8UyClLpPEP\n", + "nzEz7cgKTCYTu3btmpmdap/4XcyyC00PX/c+LaPRqCVRTKfpHHqR9rbqngJnqlZlqBxVgPf18rbi\n", + "mGajJCzbk336Z1lTV+KvoPwSOKRXSdZMhqnGwZfL7XjttdfM7ERrpJzMPQuzcpZlDQ1Lp0pCK/Fh\n", + "UNJY07TJZkufZV+VrlqHLv5LqTWgwosXYUz3z5b463gpWzna83UOXY9ReTCYIiJFLprzv0j5+imo\n", + "sPwuwQYeuTnW1fGZ38fO0IoC5u7du2Z26j/JYfeshfR+YipgxT+DsmJEmNymUgfpXIABA1oUvJfJ\n", + "S1V/c5CKn3+x9qYCkfh33rtK/JfUnNjc3Ez6eGGMDg4OpJO2xyKM/+pZjPn29nboN+zpqn9jGt1c\n", + "cBjwsXU2x4JPJUkERqNR6GBO36HU6QAPukrSC0BFzJEIfF11tNrgmTEW96cYizl6z0cVKWe5lKMs\n", + "t8Orlv2iW1tbC23h55leH+WpsUlt4pyaxh+CNjY2WoeXXq+dhNQs/ZFRdeJxT214X/rSl8zM7Bvf\n", + "+EaLh4YPILnIP7/Bq0MnHyJSG7f6LZaCoeTjpvr0vBzVU8/mHEsXTRURKxfwpkL1cclFIJrNJ9Dm\n", + "a4v2Zcx52e8dsegvv55LHXdjfGiqnucxJqq9ngeOr0+n7YwJ7LjNdVb1S9VZmd1SczyXNqYUymy1\n", + "SBLekghH/nswGMhsHD5ootfrzbnJmOnUOoxUCp5+vx/qlWInX1paavXDZDKRY6j6i81t/loKMbca\n", + "f+BeW1sL6yuXcaE6m1dUVFRUVFRUXBAunf5AoTRpcMp8hNP9aDQKJ2BoMXq9XjhxKxMPnmXTY1cT\n", + "i1mZVBLjUCmVkHKaAZZezHT+K66DkuquXr1qZieO+9w3+JdDePGv0iqlEgrnTIEYQ5TPrOhsWkQd\n", + "uM6oC+rJHCkAawbU/FN5qwA2u4DO4cWLF0nTXm58S3PTpTQ0/C6lxlfPlMw75bhr1l4jpQzduWs8\n", + "HsoBXTnVqncCMZOY1z6xZpDnnwoKKaWr8Lh69ao9fvy49fuiGincy4g9dx70E9xeXiOoR8q0r6hP\n", + "UnQo6+vr4XfsF9PpVH4nPOP3WehoYrQ6vqyYtsWXyzQYwMbGRmib0mAyu7rP6OCRqgP2xX6/H+YW\n", + "5y3kfb0L1tfXw7h3fbZ0bmMfwDP4F+1Qju/K4qH6R32buvBIVY1URUVFRUVFRcWCuHSNVMoHiB32\n", + "AGgXjo+Pw8kcVAfsWMpEkMDt27fNzOz+/futazF/HXWf8s1iaQN1UY67ngE7p3VTUA50rM1iB1nv\n", + "xBmzGaeIGtG/Dx48sOvXr5uZ2QcffBDuU3mv1H0eilFdtXMymSSdyAHWDLGE8df/+l83M7Pf/d3f\n", + "NTOzW7du2YMHD6LP5uqirvnxZH+dHG1AqY/KRbFdL6r9xHvM8g7NLD3j71x+sRLNtKcjKXHwZ3C5\n", + "vn3Kr0+RtHKbUuOqtFSx95Wy+yuUajMVus4nbm/JM7zmeaxgIWBNFPqA6Q1effVVMzP7wQ9+EK37\n", + "cDgM+0Qq71spq3zMMf8s9Bwl+OQnP2k//OEPW7+z9SFFDpwK3OgC1u4D29vbZnaq3VeZCHiPZvqF\n", + "3HpG23xdY9p2T+mhnu1CQKvG+mPrbK7MSx9ea3XC5uZmWBilrLX8fr8h9/v9cJ0XdcrBWzlzpxw3\n", + "Y4PpWZGbpmkdcphlmZmySw56PtLDH+ZUJIhybubDGBy8Hz16FA406I9nz57Jheb7nPtXqe/VRxOL\n", + "f3V1tfVBU1T+/X5fHoY8D0qs/9TGWPIxj3EGefUyXy9ddyqh8CIRcPi7NFFo6vDXBd5pVUVAKedQ\n", + "NU95zHk9cpTneR6k1Lpg3rSUqTVmtvSmdmbATznG+rqqd8fKVddzKU5KkYogi+1jgGL1VuablLDF\n", + "KYBy+2PJPB4Oh6EuJXxcMUCQPDg4CG1mdwdlBlcHb9X23OE1dcBLmSFXVlZaEb8sZEOgfvr0qUwp\n", + "5s2fsbqpoC8oAjBG6jufizQtBR/WPGcl77MsHFfTXkVFRUVFRUXFBeHSTXsXjdXV1eBApqSirsiZ\n", + "gBSUJJRyvFbPstaD35PTlKUkxpwGxjuMM5M6Tu2j0ShcV9obrosK70U/QAKJ8WahDE6Minrze722\n", + "a2trK7DipzQ6SgOiVNOz2Wwu0W3sfTEzU6lpLzU2rIlTUqfXcHKd0cYYR403xZXypsVMhamkxSmN\n", + "zmAwSOZaw7XZbDbn4K84e3K8NmYnfZWi3VB5E5V0XKI18s+WBtecF4UE3lVq6khRdrD2TmkT/Bjz\n", + "vON2+zyopdQjjK5aPAYzzafmCTuvq/3s5ZdfNrPT/fiDDz6QgTKq7mqvYWCvxPxsmibZb9x2zG3g\n", + "8PAwtAnrhy0K/N1RgSp4n6LSWcSM6F03RqPRXPAS/lXUQ8x9aDZPjcR7oLdgsCUpRUeCMqpGqqKi\n", + "oqKioqLiAnBpGqmmaez69etzucnM4jmRvLSxvb0dNA04zc5ms3CiLXEiPCv4ZOtJP2OOjF6KQd3N\n", + "5jOao50pPwZ1eo4xmyvtCNuCcSLnfHi+v1555RV76623ovVheI0b+0ukHDfZXwK+Tc+fP5/znTCb\n", + "l4BS7LSskWKkwtWVlk+FWytNAu5jegYFttN7cjuVWZ596ZTmQtVZ+RGxlJjShChfipQPSozGQ5Xh\n", + "51XOH4rfoaR7XD86OpJ+aSmfEa4r/lY+HspBWRG35vxwVF28tusse3LMD+sse19Ki1qyv5hpVvlF\n", + "HJ8ViznWHGsSFcGwQmlAgx8jpR1RvrecM461aNgf0Q5VvtfEYwyZrkDtCWfp31L4793S0pJcNyXf\n", + "YeVj+lGfS3KBAx9bZ3P8zfxGZvORbZyKwyfx5I+/2tDwDnZAzh2qPP8Kv7PrAMd4ZJRjNj+TKiOV\n", + "MoM/AvybP1jywaI06iR1UIkdfH1blpaWwsHoyZMn4XlEf/BvAKt7+VDlwYc2pepWHyp2UEfbPGv6\n", + "cDhs9U3OjMOHRP/B5fu4T0sPOan5ocpIcS6VzuNSE1DMednPHcWKzJFrbF5TdVWcZarPgaWlJckl\n", + "5N/Hqv/c5s8RSGhHirdIRdmq5NGcSDllEgNU1CuPQy4ReGkUaOoQpg5SpXMRyJnVOYrbP7+yshLm\n", + "ljrQ5pyTYxkhVB25/qPRKOlwjfKuXbsW5jbuH41GYaxVCjM8G0uXljq8MtdWLnrTP6++vWeBMuNz\n", + "/RW67nvspM8BNf6b3zRN65zQJRK2OptXVFRUVFRUVFwQLtW0t7GxITUMCiUhnRwKy85mylHUS4ax\n", + "k6mXEpQpjuvnHeQY7KjO74W2BVo3JXlx2HWpFMXtRDJnpQmLoZSJHFoHH/4aAzsUp8JdgY2NjfBu\n", + "SFvs+M5SDEJ0mUfMO6gyP5AKhVW/ATGWcL+OYs7mCqX515QTeewdMbDpy2szWePIfVqixVokF1wO\n", + "ql9827lc1eel5bFWpJTCIKUxi5n2uV5m887w3O6SxNMxVnQ/nrH8e+dBu8B9oShtWONrFk+q7Z2X\n", + "OQMDa3n8vt3v94socWJrKhVgwO1JfX/YyRl7MgekqGc8p6Gi2lhZWQnvY/cRnqfY2/Cbshrk5ux5\n", + "ocQFgAH+QaaIyAF9gG/gzs6O3L8wz3H/7u6u1Hap7zbexzQYVSNVUVFRUVFRUXFB6OdvuRjMZrNi\n", + "bZTSFvBpN5cfyP/O0qeSxtjm6qUxljA471zM9m9mduPGDTOzOTZtSFQvvfSSvfPOO3NlsB8J2vn8\n", + "+fM5R2bc5wnFWCrnOilJJafl45xZaKci00y9mzUE3hnx7t27SYZilmxQniqfJQzPEq38nJjck4MD\n", + "IOWwo7+XWJUvCMM7xav28LMsZQNKE8Zhvspvhslc/XgoiTTmrwXkfBRSWgol+aU0XDHtYoxWguvE\n", + "WmiFmFTs66jCxtV7mZlZvZufwdxRofpq/NmZu0RjENMqeXB+QB4vNXYp2oacw7rS1Pq5qOZVv9+X\n", + "GiHMS1xTzutra2tJjRS06isrK0F7x2s09Sx/c1LaZd4vUv6kDBVcASh/Iv4WMdTcUvunf9/S0lIo\n", + "M1dX/74YBVCJ5pe1o7wP+3nM9+Fbsra2FvZ39f3hvRrv4UwY6HP+hvhzBb/Ptz+FS3c2B5hJmyMy\n", + "zOKbhP/IKVWycjJjYFFtbGx0Mnt5eOfGfr8fVJc4MOaiZ5SjLQad1Z+8oPAMTyzFIwWTl4+SxP1+\n", + "HiinRd70U+kHYiZMQKWPQZ1XV1dbm8Pa2lp4ng93ajw/85nPmJnZm2++GX7zJkreGPnQDBMrnPFj\n", + "KWxSAQNAzLQXY/Tnupjpw0iKc4vHXEWflaZg8Zt10zRzpjXUXZnd/IdPsZibpbmAeKx8X/GcVGbn\n", + "nDmV67wo55D6iMTSweBgznVEuRCKYnxI3iE/hlIOKgUVfVh6aPZ7Kq+p1DeFI+CUAIc+43dwupcS\n", + "s3q/329F7fGYwc3h0aNH4TeOYEZfKq485inzaaG2t7dl0Iwvg02AmAe9Xq/lQuHNfVhf+G1rayvM\n", + "n67JwblsjhYHOEipa6Qnz0kv+KpDaY4Pj6/53/r9ftgLcDBbWVkJY5IKpOK5o8afUU17FRUVFRUV\n", + "FRUXhEvNtdc0TcvxUEkYMW6URcEn/dz7OL+Q2fzpmZ1cFeNyCpAuVldXJc+RQokzHzvkms0n3jSL\n", + "M1qX5DricFw2a8ZMIGY69F6FjauQVGj0+v1+kPRSzqFmJwmJzU7NqKxBUFQL0I7s7+93Vk2z83eJ\n", + "s7nSXCgnU9TbbF6SVhpar5nh8WctqdIqlXILpfJIppyX+T6+5jVSa2tr4T521vV7A/cVawVVrj3l\n", + "VJ8LB/cSugK3KTVG7ETOfQCpH9d8DkkgRffB8FoH1qJ2DUBQ9BGxfcw7Pl+7dk1qaFPUIzzv/DxW\n", + "2qeNjY1wnd0rvIbw2rVrc9omXxeV440tGOr7s7W1ZWZ678A8VhpsHnPWPvJ+jPJRP9RpPB7PUYRg\n", + "z+O6AqwpS9F9cHt9/s3cNxXtODw8bPVRjgtOIUVBxEFi6h2sdcdcxPeC5yE7jpfkllxZWQljwmuv\n", + "aqQqKioqKioqKi4Il+ojNRgMWidblipZW+QlIHXaXV5ebmmY2GmaNTmeQmA0GrVyqPX7/WKH+LOA\n", + "JRCU7x3f2WGU/VhYSjBr0z14jZRZW0pkRzxF4se2eUUKqnwevHTPkqMihVPz8Itf/KKZmX3zm99s\n", + "XWMJiLUsXpJnx90UXQCTvrLmjJ3R8ZvKGK4cPL10z7QL3D9KC5DqF9bG+PtibNIeSvJm8DzwY6lC\n", + "yVlbpLSGeN/y8nKQ6lUblZaH3/faa6+Zmdn3v//91vXd3d3wTpR3cHDQameMEqHUURjIabP9dWan\n", + "Vn5uLKGn/HgA5euV80+MOTLjPv9MbJ54R3rlm1ZKiRErw7dta2srrOtc/QCslSdPnkgtCupdOua5\n", + "wBsg5Qe4tLTU8q8ys5aGaDKZhLU3Ho9bOfF6vV7S3yxWb9QPc9D7JPN9MX+j0qwIvm1q3cUISjE2\n", + "CNba2dmRQRMliM2TUjqInEbqUg9SMW6PFHizK1HFm2nGWG82iE1o/yFlpBh3t7e3Q4QBf+TwN5tG\n", + "fP2xCM30QkyBnfnYdArV9LNnz2S/5SKtAH8Iyzkjpj7svOnz4kuZNXji+0OkYhuO1SkVyZlj1/UH\n", + "BWVO4cNVKbgPUh/1XOoXj7W1tVBXzD8+1AHD4TB8vFj48POF+0qNlTJ5Mv9ayvwN9fyLFy9a43D1\n", + "6tXwN+rOTP18AOX+85tl6Ydb3Rc7hKk54z+0KkODOrz4+gMYa47KTX0IUmZwbpvqKyD2fUAWAPQ9\n", + "m2IVUvM0Zt72/cL7BY8Vzxm8T32YS+qyuro6Z24zO1kLGEv01ePHj6X7AvqF2db9wXZtbS3UVXEC\n", + "Ytym0+lchDbqAEGED2Qq+qz0kHVe8GtgfX29ldCe65M7ZPu5nUslU+qqgPmyv7+fTLHGAVA7OzvV\n", + "tFdRUVFRUVFRcRG4NI3UZZRbUVFRUVFRUdEVVSNVUVFRUVFRUXEBuDRm867+IxeNLjnAPk7IOct5\n", + "h1LV78yayz4Zi+ZlYkI8zhW1KHq9XvCxYedQb99+9dVXg88Bcljt7u62yC85Y3gq5JedOeEbYTZP\n", + "4om24T1MgumfnU6nxU6tqi7oU/i7PX78uIgGpN/vB6dbzkEI/yaMjWIaVszrg8HAfuZnfsbMzF5+\n", + "+WUzM/sX/+JfJOuAcTk6Ogp+JKAW+c53vtO6fzQa2S/+4i+a2Slb/RtvvNG6bzAYhHc/f/486vRs\n", + "duqTwT5euRBsdb3UN/M8ocLL2Z9DBS/wuKXyjCmfsJS/Cd/Hflap8Hf21/I59NhXBu1YW1sLvmVY\n", + "M1wG/IVevHgR/kY7Dg4OQrABKE8ePnzY2i9iASvA3bt3Q7k+A8P169eD0zfue//998OcQP/dvHkz\n", + "7EXAyspKCCZA/37wwQctmhYOlOr1emF9sq+fJ4LO5Wnkvo/5iJmd9i/vF4ugxG9Jze2NjQ17/fXX\n", + "zez0G/Ld7343u1/nyjKbz8OX8kHmHIoxup1wb/LqjwjOY2PjxLgXGamXSsuyCEoPKKkPjEpJwu9m\n", + "B14sPr4fzvH4ME+n0xBtdJYDFKeZwdjyBo7642Dx6NEjycvjo2F4nih+LeZh8c6NzNOEPogtbp/A\n", + "OscczW3Dhw/JTe/duxfqjQ18OByGQ0SMj8jsJA0R7uONkdMxeKhsAMw3g+t/8Rd/ES2XwRGpqEtK\n", + "mFpZWQnzKsUgf3x8bJ/4xCeSZXterZiDt3JCVpsysz6bxaMs8YF99913zaxcWFNO7or7it+VYv82\n", + "m49iRl1SH6USZ/yS+1EXjPne3t4cU73ZCe/TD3/4w7l2XLlyZU5gMNNJafkghWcPDg7spZdemiuD\n", + "5z2vZd8HHBAAp27Ug5/lrAxo2+rqaqgD9kIV/MJ8XT4LgdlpoMfy8nLov1u3bsk1rpi5Iahgju/u\n", + "7rYi9FZXV8N1jjrEgQH99sorr9hbb73VKrcUar6rrAg4+OLb++LFC3vvvffMzEKk7t27d8M8UUBf\n", + "sJN7av2urq6GsUWaNkaXb3Q17VVUVFRUVFRULIgfC40UTp0x1u4SsJR9kap7qE4/Cn4qBmuXvKaE\n", + "+wwSEuddApqmCRIWtAW9Xi9IbjmqBqizUcaDBw/mJFW8z0u+MSkeUh0ktZjZDM+r62xeSGnPUKfD\n", + "w8MibhyuXy6pNqRXjMPu7m4oD1qNvb29oOVjMyL6lOFZ9j/3uc/Zn//5n7fuw3jB7MdQ0hjGvGma\n", + "IKUyKz9Mcffu3TOzeS0Am1XRLyl1+dLSUhjXlLZteXk58MyUQrGrKyqOpaWl1n6SM6EDg8EgaKK+\n", + "/OUvm5nZv/pX/6qofqqMXIJh5v2CNtNzVvEzMXb3VB2Yb8jPZTVfuFzUj59F3966daulaXj27FkY\n", + "109+8pNmZva9731Pvhta229961vhN2hKf/3Xf93MTjQOyDPK+e18/Zk9nf/FngVz07e//e3Wsy+9\n", + "9FLYC1E/hNozOBsEaxLxHm4bxgHfDQabdvlf/9165ZVXwr6NNbm3t2ef+9znzMzs7bffNrP5tYz7\n", + "rl69muTLgvbr+vXrc+OTgp87+/v7Yc2xCRgmUT9fYkBf7ezstDSCau9/8uRJmAueQoNRopmqGqmK\n", + "ioqKioqKigXxY6GRwkl1EQd2dr7zp/+L0EidJUfgeSDno4GTO5/gIY0xqRqgsp33+/2WVmk8Hsv8\n", + "V94mf3x8XJSvsNfrSX8troPZibMnysB9rLnEnFHSltm8ozjfHwM7pXtfANa2cf9yvQDOnWdm9tM/\n", + "/dOy//wcXVlZaflf5EhTVf9BooOjN96DerLfr1JHAAAgAElEQVSPiNmJZugXfuEXzMykTwXaMRqN\n", + "wrPKNws4ODiwv/zLvzSz+NiYnbAeq3nJdVaO0V57ynVhDaInoGUoRnal5S3VRClyRobKKqAIg5U/\n", + "FOdJxP0pdmrlD6X85lL1Y0DSv3HjRtA0YO4+evTIPvOZz5iZ2ZtvvhmueXJYs9N9QvlLqXKhpXr9\n", + "9deDRgraMXY2hoZyaWlJEpmiPARZsEYK77h9+3aYB6gz+1cB4/F4jkQWdUIfoZ8PDg5CvdScGAwG\n", + "LdJN1QdvvfVWS7v35MmT4Hv2K7/yK2Zm9tWvfrU1F9g/UWkusT/s7u6Gd6f8mGJA+9gSgjmLvKlX\n", + "r17N5loFSi0+PhNCSvudwo/MQarEI38Rx2aVZLT0sJOrk4raKmHePitSqnr+mONfs3lzkYc6XLHD\n", + "LcxLWMx7e3tzUSRmJ32Av9EH4/G4xSzPBwNskGx2Uak1GOhrTqeAe7FYRqORTC+EOmDzWllZCQsW\n", + "H/NYuVAN80EKYEZj9AH3Jd6tTGzYqF599dXWtaZpWocMju5D/z1+/DhsRip1hWIlR/JnPkixwz/a\n", + "iQ36xYsXoS74YDHw7J07d+Th22N3d1eaitFHKGtjY6MVFcVQewL3/fXr181s3nmY08t4R3X+mz9i\n", + "3nTAcxbjsb6+3mo7H4awLlQiXtUWnp8+bRH/xnXmCD1/gGa2e14fpR8vzDefksvsdI7hgG52ahba\n", + "398PkWoMfFQ5Yg7rD+vt8PAwOZ/+7M/+zMzMfuM3fsP+4A/+wMxO++iVV14JcxXzc21tLcxttPf2\n", + "7dthjqn9G+389re/bb/6q79qZma/+7u/a2Zm7733XlgjvC58X66trYV5gn754IMPwjjwOgQ4RRDm\n", + "7OHhoYyUVmsScwzRsFevXg3jr8Ya9bt69WrYT/ggjzWUivYejUahf/nQgrmIOq2urrbq8Pjx4xDp\n", + "+8orr5jZSSQfykNKsT/6oz8Kz2Dv7fV6UmBEO7APLIpq2quoqKioqKioWBA/chop4Lw4n/jU7N/J\n", + "ebwUmE/IOxb7v81OTuqcAPiikNLMTafTlvMzh29D+uTcaJD+j4+PWxqX2WwWJELWeimJGhKN4q1B\n", + "f6yvr7fMbrPZLNlfqOvW1laLDoAlSNRJSXcMXI/dh/IgxaytrYU2sSoc/QvNRb/fn/vb7KQv0Ocq\n", + "3D/lLKkwmUyChhBmhYcPH85pcFJAHZRzK+pycHAQHHw///nPm9mJBP7Vr341WS+zE2nbm40gTZvN\n", + "m3E8lpeX7VOf+pSZnYYr7+zsnCk8G+ZSpvZAHTgHnNLu4n6lQeI8eJjPMc2JD245OjoK/c9JWr15\n", + "eW9vr0WxwFJ3yjynJPSdnZ05p3WglLLBB+so7Q1rzLAfbGxsSG2B/421xvweTmBtdrLesA9Aq/m9\n", + "730vlOdzFnJZh4eHYd1De/aFL3whaKS+/vWvz5Vjdqq9feONN2TgA89vwDs37+7uBq0z1u0HH3yQ\n", + "XP8qifD6+nrLxDqdTuX+iXejbb1eL+zv0PzyPMb9rAVnHitokPBszBUBdCUYI9aWcWL7n/7pnzaz\n", + "eYoVOMHj3zt37oT6oy6vvfZamBM+sAp9hHb44Itf/uVfDvsJ6Bc4920MVSNVUVFRUVFRUbEgfmQ0\n", + "UheVwZodUT1xYyliEhskM5aAFnU2b5qm5fjKDvJdoPw+PDj0mzU+KFtJGwD3B6S6wWAQpENPfMk4\n", + "PDxssU6z3w80ISsrK0HCh0QDe7dHKUN76X2Q7hSJG8NrLsbjcWgTS8d37twxM005ASBEWb2fMRwO\n", + "gwQMqff+/fstR+EYOSR+g9R57do1SS/BxH54roQFudfrBX8YjNva2lrLH0LVj4lZoZHIUW4osPaE\n", + "xwbl5bTGfp5wv3AGAbwHkjyHqwOsbWUNEtYA6rS5uRn8jHK+L94fip/xJLtm8xK61wiur69LPzw1\n", + "d1Bn5fzP9BcAk0T6ftnc3GyVO51OW/5LN27caPVBr9drzYuvfe1r9su//MtmdkrPce/evZaDv3Iw\n", + "Z+280jhDK/jGG29IZ2XlAJ76xmAMmCoitlZ9YM5gMGhpBIfDYdCaKc0lfLIODw9b84OtFdDMrK2t\n", + "Ba0TtEHLy8thvJQVhwNV0Ief/vSnzexkTqDfoQ08PDwMmiiMudLK3b9/P9T5T//0T83s5NvgtY7c\n", + "XhW8gu/Z0dFRCHxAP6asUsCPzEHqosCHEoAd6HAQ6Mr7xNFTvLl2PaRxnXyalxz3UQwpZ3RMaOVs\n", + "OB6Pi53lvTo41n/elMAHTYwN1wULd2lpqVWXK1euhI2MNx7VR6oPMDbMw4PfeGPG4QF1zh3y2aHe\n", + "zwlOcaIOp1jEqcg1bs/y8nLrAMCmDvzL0ZEMtBN1uXnzpjQveEbgwWBQbH70bMxsRkTd1cdnf38/\n", + "bK5grl5EwOL0GGoe5NIk+fkU++D5tb6xsRHmN4+nj7xS/FXPnz+XUaCpVDfcBs+GPplMWuYl3p9Q\n", + "l52dnZbpMRbBiN95THydWdhBuVtbW60DyGw2a5nWJ5PJXDogs/loPG4vADPSvXv3wt8w3RwcHLQO\n", + "UsfHx2FuY+394R/+Yau9DHZ3UPMRa4r7Ee/mccN+goPGnTt3pAClgHnATO9o2+PHj8Oexn2j3DjQ\n", + "58zN6PfZ6XRqP/uzP2tm8+Y+z1/HDuMsdKB9WMvLy8v2cz/3c2Z2etD+/d///VBeal/htYh+3tvb\n", + "a63Rl156KSv4mp30H8bb7/MpVNNeRUVFRUVFRcWC+InXSHGeM2+KmU6nQYXJLME4rSvVP6QTzgXH\n", + "UoD/rYtGyauaSxm2GYtwbfkExCVQZg+PmFN6CoqmgeuXah9r9CCtsRqd2ZdRBqQcplDwbMLsRJ5y\n", + "ij8+Pm5pQra2tmT+LkD9psB8M5DWIeVtbm7OJX41y7PAY/zefffdlpnk137t18LfCE0vDf5gqgBI\n", + "/s+ePQtz2psgPPwcXJRORGUv8NoTxeAdy4OnOJl8H7OzOdMu+JyHXCZrTHwf8//naGGUycaP62w2\n", + "mwsEAXwiXqaK8c+bzbcb8xK/xfLF+XHk+7AuJ5NJSzug6EZiffE7v/M7c/9/584d++53v2tm8/MB\n", + "ARS/93u/Z2ZxlwFf16ZpZPugfUI77ty5ExyZWfPjc3cuYm3g7xM0jrPZTO4j0Bax9cCziCsz7uHh\n", + "Yeg3ftabxm/evNlK9sxgDTy0RdCmnQXD4bC1D7MWDZQYCr1er0VHUoKqkaqoqKioqKioWBA/sRop\n", + "76vCJ3nYaZeWllqEd6PRKDzLLLsqZB9gKd87XS7ifM4houeBpaWlOenF7KS9kE66Sv0xUkBI/JBS\n", + "ORM8sLGxEfzSmNlYOTLDSRv1e/bsmXTI92Hgw+FwjiTT7GRcMdYccu6Zb/f391uSYq/XK6Kz4BB2\n", + "3xd4TwwxB19PrspkqKBB+Pa3vy3Z4hFuraRG9AVrF+Az8PLLL9s3vvGNueulc+Tp06dBYkUfPHr0\n", + "KGgEQG+wu7sr6SdwH9ZNiSMowBonte48XQUzmyuqEPb1Sq1jaKsGg0HoV2gIVldXw7grx3n0a8z5\n", + "XmmaPBS7O7P7MyWHp3tgaoecBsyXwUCQiJpru7u7Sd9RzLvd3d2ieXblypWg7eC6QFsE52pebxij\n", + "w8PDzvsqNFavvPJKaz5ygAG0aZ/97GeDRgpg6gGMgW+rJ+xV2lHOYoA2feELXwikmykfLoWYdo+d\n", + "7s1O9hqME9r25MmTsEf79saQ8gVdXl5Ojj++YZubm618npPJJOwtgNJM5XxrY/iJPUjhw8OLxncc\n", + "R/Iop3RWxeN9rKb3m9t4PD7TAcrXcxHVr3pmMpkEcxAfMFPmAqXm55QkPuJveXk5TGosXDZhcOQI\n", + "PqBsasNHH6aO0WgUDldsMvF15ggO7nOvgo+lBsCzzNbsD1elZi1+Fs/s7u6G/sNGpMxuo9Eo6fTI\n", + "0WfgX0FZb7/9dhh3mJQ2NzdbUao8j1UdwCr8ta99LXww2JRdAk4Uyn3uI9fu3LkjD1K4nuMCU0Af\n", + "qRRBZu0oS2Xa4/uA6XQqOZsAZS4DlMmO+esUozofnlKO7yryivcib0qcTCaS00rBt0XVxazMUXdv\n", + "b6/FW7a2ttYyq7Pjs+ekY3z6058OBynsEXygwXvZfIwP+JUrV1ofWHaaZlMi+gYBMNvb2615per3\n", + "+PFje+2118zslAPr8PAwtAnt9X3nBS0eVwbGk7mWfIJizviQg+fB6vf7rf3y0aNHwVSPdjx79izs\n", + "N2Aif/78eVgr6rCbQr/fD4dJf5AzO93fnz171jK1P378OKT1AQP67u5uiOD05XC9SlxoqmmvoqKi\n", + "oqKiomJB/MRqpHDaVKo8r/I2O5UsYpom3Ku0RezkvIiD+EWB2+GlAtbecGg9s7mbzZurlJMeO2F7\n", + "9vfRaBRMW54d3UyreVWoMYf2erPn8vKyzBVYihQHDN63SAg+83GxucVsXrrnhNFKumdGZrMT6Rnq\n", + "dGXOgzP3w4cPQ9g42tjv94P06XMbmp2ao3Z2duY0iIDK4+dxeHg4Z073gKSpmNWbpmklc14EPLe5\n", + "b/y6Vtf87/h/Nv2bnbRN0RV4TKfTlvT89OnTlmaItQ+K6oClZx9QwNplfhbP8Lgpx3IPpX1itwV+\n", + "Bm3CXNve3m4xvB8dHbVy7fH44/6tra1WZgBlEsT85z5gYKwUJctgMAimOmi/edz4GwFtC/rsBz/4\n", + "gX32s5+du0/hwYMHgb6D4bMxMC2Bmd4POZuE2bxpD9e++93v2uuvv25mpwEes9ksrCXWtnsKGLWX\n", + "9/v9sI+gr5qmCeseLgW7u7tBK8b7ijKxog85hyuewTjt7OwE892Xv/xlMzvJq4d+YVcUjB2PP7RP\n", + "+G1jY6NFv8P8b948mELVSFVUVFRUVFRULIifWI2UlyAZSpvE17yEyVKAymXFObJKfAY+KihfCyVJ\n", + "saapq18Wh0T7Z4+OjoqctAeDQehzJWGy06+X2lV+M6Y/UI60AGvgFKt3VygNx8HBQfCxgIR25cqV\n", + "IN0hoGE4HCZJYZl9GH2Vyq/17NmzVt49pnGIsc7jPpTB0lqJky73Ha8Z/A3NhQprVxQlTdMspJ0q\n", + "IdpMXUO9uR1m833knzk4OGhJwMrpezKZSLZz71/HSAVDKN88BuYah37n6BTUWPvfeFyZlFI58Pt9\n", + "+P333w/aHThKHx8fzzmFm51qWBg8JxXdhyciZbA2lZnBAe6XX/3VXzUzs29961vhfXgGGrW9vb1W\n", + "Hfb29lrku0tLS629yo9Byq+Wg1g8qere3l4gIUUgj9np/EV+wIcPH4Yxwb5zcHDQ+mY1TdNy3J7N\n", + "ZqHfUX6v1wt9jPG6detWeB+usRaVrTyoA7R377zzTngGLOa3b98OxJ68d2Ec1DxFPx8dHbX6mNvR\n", + "BT+xBykAHT0cDueYhc3mzXj48E4mkzm6e7OTCe7VqXy4wmaYcxi+LJQejlj1q0xePhLObN5Z23/Y\n", + "S8tVG8hwOGw5dPJHOmVCnc1mreikfr8fNnO0I8b+fRZ4VbxZm8F9fX099CGb9hR4/qIdmGPqEMlM\n", + "5Di4cXoE5RjN/WF2Yp7BoY4PQ6qvvHMoOzmzqYCZpflf9IfZ/CGBHcIXOUiVzL3cPfzx8vON5yJz\n", + "QbG5zeykncpRXTkre2HNzIJJDGPIEYT8XmVm9BGksTWjDowxM2UOu7u7YW6zYKA+Xn5ucxRlisuP\n", + "2cDVQSq2lsxO5hinzMGziDrEmppMJuEQx2bI733ve2ZmIc3Im2++2QrgmM1moe2cFsr3/+Hh4dwY\n", + "lriF8PeJx807Z7MbBPqIk3QjmIMPZhwZjHdz5o+UoIeyHjx40Jpv4/E49AP69PHjxyHgQo0XTIbs\n", + "MoI95ObNm+E62tbr9cK+6BMVnweqaa+ioqKioqKiYkH8xGukgKZp5hLJmp2cXCHdQXWuzH7Mv8Iq\n", + "dB+GnJKEflTg28SaHPTV/v5+kF68psFMS8CQrI+Pj4N0mpJwu2iKMHaoC2vWGJxEtQSsLfIhszko\n", + "aQjlM2UD5kwXbQHU33iWuYDQB3fv3pXsv3gPpGzmPuIyfX1u3bolub6UNtFLuDFuGDZr4jm0g53O\n", + "U/xbMZRmFuDMB/jXP6toA7jeHLKvHO39fFPJjfG82TzrNDRRHMihtFl+3fJ8UXOL28iuCdxuD+XQ\n", + "7nF4eNjSsh4fH0vmbWiWoDl99uxZiypE5U97++23w37CWlnOPWc2r7lg4N3s3A3nanaKxlyEJobH\n", + "jU1ofv30+/3WdyVmqUCdd3d3O1kO+F8G2r61tdWiIbly5UqLnX4wGIT1ij44Pj4O7gi5tefnQmzf\n", + "Rl8zRyPqlTJpMncguxtgjmE8NjY2Ws7jXfPnplA1UhUVFRUVFRUVC+LHSiMVI9BLASdWPr0ruztL\n", + "ZV77MBgMWk6as9lszj5rdr422UURI85TSEmWHAasJAYvUQ8GgyAB4dqNGzdCCDEkx3ff/f/Ze9cY\n", + "ya7rXGydendXV08/prvnRU7zIXI0GvMhkZZsE5ZoUZJl2ZEDG7IDGP4TQAECJEZ+xTe/5AS+QQLF\n", + "iG0YAeToRwD7XkO+sfxQIJmSQFG2ZcqgKJImqSE1fI1myHn3o7q7urpe+VH8Vn1n7XVOVTcpkfTd\n", + "H0BMs6rOOft99vrW2t96zVUOn1Q8zpa9Vqul8umJDPuB5Syy6shAX1YqFa0HLByOIxhnoXkxG7YM\n", + "HHPniYky7Jja3t5WC55jOPA8xKdsbW2pRQYLvFQq6WeICXn55ZeDZ3pH+5eWllz1Yi/HHxgaj3Xh\n", + "9vNYOcsk8uGP/SBvDnBsjrcW8OEGlMsy0h5r1+l0VAzwySefDJ5nVcrHlbnf7+fGN40LqLfjjucZ\n", + "xw56a2SeEjkHhGOtRP/v7Ozo92AcspghjhlEffAZBHq9/uFYP2BhYSEILp+fn3efC7AshMfyIGgd\n", + "c6bRaOg65rEdLNlgJRgajYbOcY7Rwt/b29vuAYyDYn19XdcJPNdjBZkthnjoyZMnU+USGbaV7a+7\n", + "7rpL6/y9731P65QH9BEfhPFiPVlQ286Lra2tQNx40gwIc3Nzem+8mybJ//dvaiPFp4kmBU84Dmq0\n", + "wKKUJIkuQJxGAx3HC4xdbN4JG6lJXRme5lWxWAzcC16dOGiRTzFal92lS5eUIh4HLJzor7W1tSB4\n", + "UCSkyplW3+9pu0qlovXF5Nre3h67GOTdz+o0iYzoe5SVkxvzhtADFnv0x/b2ttx5550iMmoDXtSx\n", + "KHAiVqgec8BonmL5OH0vIEkSHQdwdezt7QVpl0Qk2IjWarUggWqz2Qw2vN1u1z15a8th6zKJkdDr\n", + "9YLAYzbW8C+7Tj01ZPRRkiS6geKTY3Zj1ul0gtQa3saFT/x5rsVx9fWSINt+73Q6gXuzXC67Lhr8\n", + "DmO83W5ruTgtlB3LfHCEy4yTYTiVNT09HZxm9AyXubk5bTcYE3fccYc89thjqd9xH0Fn6cUXX9TN\n", + "laeHxC9ktBU+W11d1Zc+xou3EW2321ouXNtoNHQTwXXCvLl06dJbfvAFcx2q4zjZNw6vvvqqbsLY\n", + "7W5P47366qtaT/S5t3bcdddd8vTTT6c+y8o0AfDaYQ10kXztJ8y97e1tHavYELbbbf0b/05yQCy6\n", + "9iIiIiIiIiIiDoh/U4zUJJpEWfA0iLJUffE9Wwh4tk3Iyn/nKT6Pe+6PA3nBo5ywF6jVakFOQXZ1\n", + "gb3Z3NwMAko9zY5Jy7e4uKhtzfmxcG9YO16ZRfKPd2f1Mcq8XyswizkSSefiAli7h5+PMnAgqJUS\n", + "qFarej+Us1gsqpWL75hpsHmzREbW+CuvvKKaMp5rAjn8zp07pwyDzetl64G6oV02NzcDZpDZT3aR\n", + "Y05hfHl9NTs7m/qcmWNcY5Xj2XXq5YwEut2uWtCee57HiXXZerndlpaW9H6exc31sEytV/dOp5OS\n", + "VkCZbJvv7u4G+ku27gCPI5E02+ate8DMzIy2h5cVgce4ZS9Z3Z9lA8Ac8DF5APX12vHo0aPKSIHJ\n", + "9lhLHuM33XSTiAxd2t/+9rdT9SgWiykGl8vNWFhY0KTMeP709LQ+hwP+7ZznccXl4vCQt/q9YDN5\n", + "fOhDHwpYuyxAHoFVwG35Njc33ZyWAMbk4uKifOITnxARkYcffjhVtkmw3/c+jxn7TmD2aT8epMhI\n", + "RUREREREREQcEP+mGKlJkZUrCrtnFljDbhff1Wo1d7dsjxWztcjsjFU7Z+D33W5Xn5f3rP3s2jlb\n", + "OqxNjkvB3/Atexakx6h1Op3gWrZYbfCqyCheYnd31931s0CcyND68axgZlzwDK9d7TO8/ufcTnk5\n", + "9DgOj+/hWfwWMzMzqtzN8OI8wPzh96VSSZaXl0VkxEgVi8UgFqBer+v3bHkh5oZjFDDO8btut6tx\n", + "IWfPng3Kcv/994vIkJHCZ7iHFxDqxa7VarVA7oDbkYVv87IP8H3ZiswL2GahSvShF2iNaznWzxPf\n", + "ZHFVOz4Hg0HAFl2/fl1OnjwpIsP4EZQF9+H+8ALa7SEXVnD2FNBR9nK5HATDe4HjPE84Dsy25aFD\n", + "h5SRAKampnR8Qomcn+fForJYL8BBxlZEst1ua8wavuOxhDHGcwIB0rfffnsQR8Ys6m233SYi6Rgo\n", + "/J6FYPHvHXfcEcQUcfthrB0/fjxgd2+99VYV7gSy1nLMzVqttm/F7UnfE2DPWJpiv0x8oVDQ2Mzn\n", + "n39eRNIxl1h/eP6gjV566SUdA5gDCwsLWl/L/L2VsAro3FaeAG4W3jUbKaunw+ki9gvvRI2X5iFL\n", + "sRgNi0A6TpKIa3kB4tNHWFA4USw6k6nfvJN+eZurrN+xy8NTAs8DTyrPZWf1l7xTbKxAy2lZ8OIG\n", + "td7tdnWRwf2yJrVNgjwOeNlMTU0FivWDwUAnLMbC7OxsKumyiJ+Co1qtTlwW7/QdFg9sVDudTvAM\n", + "DuYEvIW1VCrpZolfMnjx8ThBuz7++OMi4rseRUYpJBjomxMnToiIf7qPgXY5duyYvtw8wH155coV\n", + "HTv8crPuqOvXr+eqbPOmmTcbfKiCf8+fWWVp1MOqa7PrlIPO0f4Y49evX9eTUZ6aOTYRd955p/YJ\n", + "nsGbOi6nvQ+74myoAv/N65MXNM+wmwjWcwKuX7+uL1IG7ocxtLa2pi9ubHy2tra033lseGrceK4X\n", + "tIz6sLYUXuRPPPGEfPCDHxQRke9+97vBtRhjPO9Qvl6vF2wc9/b2gjJcu3ZNXYlw8bVarWBDfeLE\n", + "iWAjxesGNqRXrlzR57ZardyTkh4408Qkmknc3liTOBmxBx4veMYHPvABERmd1BMZvS+Wl5dTmRRE\n", + "RkYFo9VqqRaYd5CCgX7H+9gz6kRGY9Cu8yL5m81JXKrRtRcRERERERERcUC8axgpm9gza5c4CZ3J\n", + "1pj3Oz5SbF0AfA0rNNvcbcViMdCW6vf7akEybWiDOPnaSeExWGw1suVgj4vyNbCeSqWSWiWs5ot7\n", + "5lkpnIQS9eSgdNZwgnXA9C27IQFYh/fee6+IDK2fZ555RkTy+3xqakqfy25LrhPKbF07Ozs7Wgar\n", + "hyMyakfWrcnTemm1Wq6+FiwvWJ9ZQe6ezgsANsNjrkRGFje0Ud73vvepawIWfK1WywwaFxklZxVJ\n", + "590TkcDCFkmzKAjWhQslC7Da2fpmlszmLev3+25b8ZjAmGXG1GMOPZYoLzCeZQEsI9zv93Ucw9Ln\n", + "I+4Yz3x/HKTY2dkJysLWODPdtnx7e3vB0Xr+Da8Tdr54khztdjvID8n5/Li+npSJ5x5BG7A+Dxgp\n", + "SB1w+THPOHG3FyjPeSI50S0ApsfDX/3VX4mIyMc+9jH9DP1x5syZlO6XyHA824MlFy9elF/7tV8T\n", + "kREjtba2FryrLl68mNKoEkmvf9wPmMuDwSDQM8pSwAfYPcusaBaYkcRayesna9HZBMULCws6TlDm\n", + "er0eSAhcv35dbr31VhFJ9zXAYxfXjAsmx3MhydBsNt12QZgEWPRr165lZlXYLyIjFRERERERERFx\n", + "QLxrGClgXAzKfvMRWYFJkZE1ViwW1QqA37Xb7aasf5HhbttaXsViMffItBX1ZOxXONI+A/BYu2q1\n", + "6qr0WqbMi30SkSBQ3YtVq1arbnb2SY+pegHq6J8XXnhBRNLsDB/3thYGH00HC8BsB1t8HqvA/WnL\n", + "x3EHHDOWhWazGVjySZJoGWBReQHpWZakjcPj+ntMHb5vNBrKJoEhePHFF9VyhdTBa6+9ppY5S09Y\n", + "lsKz7HjcoN7jAkfRr4cOHQqCUjljva1jFvhYNscEeQHWzFjZ7/gzG1dVLBZTcZX4HeYUC4oiToP7\n", + "GG2OflhfX9ex6kkOjFNAB5MDRnlnZ2esQj6ehTqhP5mlYGbdHgAoFouusj3AOQFRfo4xssrTzGZw\n", + "8D/ayJvz6K96ve6+B1A+Zmfs+v+jH/0oYDA99Ho9je1hWRDLGvf7/YDVPnfunAZfM0uO77ktuI9t\n", + "jNSk74nt7W19Z2H8NZtNd63kMSMyXB/BnvFaaKUuWB7CYybx+9XVVZeJsl4D/jsvAP7UqVN6MAbM\n", + "78rKio4dT9EcORwbjYauuXhWs9lUEVRPODgL77qN1FuFvAWYI/m9gE0+/SOSPlGBzq5Wq64bD5g0\n", + "0SqX86DB9YxxAXveyR0+RedtkGww7zi6lE9mYNMKt9ba2lowcJeWlvR7XqjsKaasE3s2UHQcOMk0\n", + "2sBrN07cnPeCArLSWeClmqUOLjJsUz5NCtiXUpIkeh/WbgKwoM7OzroL3nvf+159noifFHZ6eloN\n", + "jLyTRN7m3tskemg2m0FyY3ZlWdexBbvYvVOWtmxeehSRUCm/UCgEc4Vd2Z5bht102AicOnVKRIan\n", + "I7HJQN/s7e3ptd6L1G4wUS60hz1Fy9dgTLB6vhdwD+zt7QXP5VAGvj/qCbBrl9W9bZsuLCzovGat\n", + "NHs45caNG4FLrFwuBxuphYUFdz4igP+zn/2siIh84QtfCMZBtVrVzQY2B567u9vtBkmLa7WaPPro\n", + "o1oukeE49Q73eGPDmy+8eTpoRgWR0VTQJMwAACAASURBVObm2LFjIjJ0q6KtWecKY4YDvNHW2HR4\n", + "B25ERuMX9VxYWND1A22Y9Q7DOEFqqo2NDW2jvI3M2bNnA+OEEzJ7RAnmSrPZ1DbFmKxWq0F2h0kQ\n", + "XXsREREREREREQfE285IHUQT6a2Ad7zcWgR7e3uB1cZHovFdsVh02Sc8g4MgrSzAuETLk7aLFyjL\n", + "YCqe89+hzCi3F1wPy2tvb89Vjs5TNMZOfzAYBPnv2GLmQEpYArCANjc3A1rXO6pdqVRy1eHzFM5F\n", + "wnaZ1BXZ6XTU8vGYRmtZi6QTosKiHsfk5el5od+np6f1edx+AGvoePWzBwK88bSzs6Nq6HkB8OMA\n", + "hq1SqQQUPI8r/Msq0ZgXbPGLhH3c6/WCXHGeS5v1lzB2yuVyELjP44qv9RJtexpKuB7uiNnZWa0T\n", + "9yv6DmOi3W6nGCHc12PCbDB8oVDQMvAYs8fyGWzJ2/uxfIR3DbC4uKjuYG63vNxlCDa+ceOGtinr\n", + "Q3mB7xatViuXTeB1yq4Tly9f1mewyw7wXLNgWzhnHJ6xvLys44AZJTyX3xt2XarX66m2ygsbYHbe\n", + "jjtmW9EfpVJJxxhc/PV6XTWgsDawThuY/UajoX3NYxZsK6Rspqam5L777hOR9HjnoHAR3y04Nzen\n", + "z8WzkiRxx6plH8+fP69sG+rGrKJ3cAzvolKppMzafhjAXEYqSZKbkiR5JEmSZ5MkeSZJkv/+jc8/\n", + "lyTJhSRJvv/Gf5+ka/5dkiQ/TJLkbJIkH5+4JBERERERERER7zKMY6Q6IvI/DAaDJ5MkmRGR7yVJ\n", + "8nURGYjIHwwGgz/gHydJclpEfkNETovIcRH5RpIkdwwGg0xFKxuQ+ZMGM06WaWJrluM0bCxAoVDQ\n", + "z7B7LpVKqeBMXGuDg1ll+c1gXEAcsw8ee2YtM0/9W8S36u3vSqWSG0xv2aJyuazt4O3+8+JpPOts\n", + "XD4/tqxtPVjsD/+yhc1xU7iG+83mrRKRgH30jvGPg6cIDyuQGUIOJma2Bv+ivWDRXbt2LQgOrtfr\n", + "GoiJYNgjR47Ij370o6BcsCr5WHgew+EB7JenXM6Mh6eAzTnIGDauzxsTPLa9PvQYVmZobDByuVzW\n", + "3+YxoqyAbgVBGfV6Xa1/yFV44qCon20Hu+54OSgrlUogNcEHR7g+NibMK3OxWFR2EmVheQCM2YWF\n", + "BQ0K9qRUPKYLDMHOzk4Q+D43NxewmZcuXdJ28/DXf/3XIjJkK6x444ULF2RlZUVERvONAYbDW5s2\n", + "NzcDxqrb7Srbzmsc5yUVGa4H9ncrKysqo+CB686MNGQeMJe73W4Ql9btdgPpmfn5eZ33YK48QdHt\n", + "7W2NZcLcZTFPrBdLS0vKBKFOW1tb2p953hbuU4w7y3ja36JMly5d0vKgvxYXF1PlB2wWjWazqW2F\n", + "oPNJYmxzV/PBYHBJRC698fdWkiQ/kOEGSUTEi9b+tIj8x8Fg0BGRV5IkOSciPy0imZkQ34pNxJuB\n", + "51r0FkMOXsXCw64HdDKfEPI2N3kaVD8JsLq6F6TNm4m8gNw8ZG3qbNA9qz8DpVIp2NCyi4X7CZME\n", + "LqKrV69ONJ48Fet6va5l4U0a+pUp4EndrXBT8ER8M65s3swDdjy12+3AvVWtVlPuWZHRIisyaj+m\n", + "7HFfb2wuLS25CzwWyEk3Unz60ZZ5enpaF1+81LlvMR6sCwf34T60GxB2f7CryJ7u89K8cLk9t1pe\n", + "EmwuH+qysbERJKPmhZ7/Rvn51JmdK9648uYtZxrwguzzQgW8E64rKyv68kVAs/cC8gwwHmNWK0kk\n", + "7Zq2z/XchP1+X1/gfArNtjPWDwv0ER/GsEaRh7W1NS0/b5Q8o8l+1u129WWOcb+9vR3opjFarVZw\n", + "ym5nZ0cNJKw/165dSynki/jzem1tzVUFt/O53+9rX6O+09PTwcGTGzdu6PzBpmRzc9NNNJ0HdlHm\n", + "rZ/YvM7Pz6cOI4gM1xBruG1vb2u7cjJ3jB12eY7DxMHmSZKsisi9MtoU/XdJkjyVJMkXkySZe+Oz\n", + "YyJygS67IKONV0RERERERETEvylM5F94w633n0Tkd95gpv4vEfmf3/j6fxGR/0NE/uuMy3NN70kY\n", + "jrca3lFnPjbMv7MUPCdTZVeAdQswTc7/2gDacTo4bxXytDi4/B5bA7DWSV6AOV/HweaWlvesXQ7c\n", + "hfuoWCwGTEmtVlMrHBbYuLHELKBNeJwVWJjncmaV/bz8h1xPG9zIbiGAXSJsDdqE1961lUpF2woW\n", + "GksieG0Eq3JmZkafjQBQz+LvdDpufizMlUkTn6LNOXEvwHMRbcDJclnviCl/Gxjt6fjwGPN0n7i/\n", + "rDXOh0O8+vGYwN9esDnaqNvtKkPCa0eWG0MknUvMm0OeHpr3G6/NvQMynuvePpefgTZbX1933UIA\n", + "3G/sJuOxb9mWmZmZoM0vX74csCw8L7i9bRLsrJxs+B0HKGMtyguh2N3d1XEH99rly5e17lxOL0je\n", + "urjX19dT+fLsIZN2u63PYTbIZm3gvzlDg21Lz006DpjDtVotcB/2ej0tM7cL2oM9E5O4z8YxUpiX\n", + "a2trOr/Qx7VaTcuCccWZS7z1P2t8uGUb94MkScoi8v+KyJ8NBoO/fqMSVwZvQET+bxm670RELorI\n", + "TXT5iTc+i4iIiIiIiIh41+Fzn/tc7ve5jFQy3P59UUSeGwwG/yd9fnQwGCBS9b8UESTh+lsR+Q9J\n", + "kvyBDF167xGRfzlQyd8kPCEuwDtazVacF+jqCXMyi8N+XAvvmrzjuz8OeHE/XhA0yscK6MyEsKUK\n", + "wJLitoLlA0vpIIcJbPZ3hneUmOFZLnyIwIM3Zjy5B1g0XtwWxz7k5SP02tErCzMirEqO59pM5lNT\n", + "U65yNMrFrAvqweMAz8C1XttmsXdcBpHxjBTLhzDLxt+JjFiKWq3mWq4cV2PZCWZPPDaBA6itsjl/\n", + "jzpxfzDr5bFZtm9ZUNRrG2a1MQbxLzMIbMlby9xjKb3DFXydJwvixYl6DCvA8USw5DmfHzNTHJco\n", + "kmakmBGxMTeHDx/W2D4OzLZziduAWSrEWiH2JSs21fvcO/DgXXfLLbeIyIjRZYkKvq9V+GfxX74f\n", + "rp2bm3PXE7BmXkA7wB4Y9OuhQ4eCgPnNzU33PjbOaW9vL2CuuKze2ovnX79+XdcvLhOC9FlMlmPj\n", + "RNKssTd/+DCO/Z5jm5lFw1jAd+vr626M5+c+9zn5vd/7veBzYJxr7+dE5LdE5OkkSb7/xmf/k4j8\n", + "V0mS3CNDt93LIvLfiIgMBoPnkiT5kog8JyJdEflvBz9pgag3MC7o2NsYWTdeqVQKNlJ88o41l+xA\n", + "ZV0aXqi8jZRdyDza9c3irVDhrlargc4QuyGwyLzZE5h5CWUnVU8/yLDz3GTe5ssu8MViURebrKTR\n", + "WfD6o91u64LGgZlYSJH086WXXgrKXi6XA2XzVqsVnD6tVCr6DIwNT2/KG4fVatV9meIa7xQew7r+\n", + "svS1AGz47MIqEh6KQBm8F4K32ckyjOz3/AK1Lie+J29AbKL1cSdreR2w5ffGlXe/TqcTuHG93/HL\n", + "lQ8l5Cn485zyXI/4HcYd9yFvKq0CNgNBzEtLS+7JOOue29raCtYLr/94jI0zXu17YDAYBJkrvOBq\n", + "kVFSbk7ijfbAtYuLi8FG6vDhw26KHVzj6WIdPXpUr8E48frQM4a2t7fVLYjNWL/f13HHp9iszh0O\n", + "OzAGg8FEh6Z6vZ5uwnhNwrxH/7K+GtDpdIJE0bZOFvyuxkaQ9QxRJ94s2ncL3Lp5GHdq7x/Fd/99\n", + "Neeafy8i/37skyMiIiIiIiIi3uV425XNJ8E49e+DwFMituxTqVTKTWTrWXxMnVtGwjs2zPpFbBl6\n", + "ukRvBuOSllrtJM+6aLfb7uce3W1ZCT5uza4J69LhwHIvv2Febjdcj3uLZCdu5nLhOk/Z3ru//R3n\n", + "qGJ4rh2rxeO5YgaDQcBm9Hq9gB3jduc25bZEPezx7Wq1Grgoe72e1jnPJZvljsQ1sPyyAJ0eT5/K\n", + "sr0iI1aOE4bjs36/n2KdPF0yywgdOXJEXVE8PjzXrm23brcb9LUnL8B9zXnuYO0yO5anPWXbRWQ0\n", + "Lr2gb/6tp3Pl3Y+lM6wKPP/NCcvzXCvsOkF9PQ0wTxYAbesFFvO44nyodi33+m8cU8wslCcHYRMo\n", + "Hz582J3zYGvATJ09e1b1jTj5toWXqJjZ1hs3bgTSEIPBIGAux7FC7B4GE8VMDauM4xmWJd7Z2UnJ\n", + "GRwU6P9Dhw4FOne7u7tB8LpIvqfJY6H5PQoW0GMkOYMADkFAF20Spi3m2ouIiIiIiIiIOCDeFYxU\n", + "r9fLDR73wOJ6eUfTPWkCPsJsY5/YmrDxThb2uczAeAKgQLPZVDE17PgnlYnIEs1ky9UKkyWUA9AL\n", + "8GaL2bJKHKTL9fB28VZQstPpBLFPnpBpu92euP5WhsLr/3a7rawILByOWeBxYMuSpUTvjTHrs2fR\n", + "QrR91tiBheTFpeC+zEiwMCMzm/jXsq3T09OBIGKn01Er24s38GJ9ON7JlsWL9UuSRANLPUYK1ifL\n", + "W3DAcJ7aPurPZS2Xy9qWsHAvXboUWK8cq8bz3/Y/x6DkiXXyOsEHB2ycFgcZ83pin+uNE643j3fL\n", + "eHQ6nYBB6PV6EwmKcqwKnre3txfESCVJoswLctOdOHFC/+a4Mlj6nvo4s164BmORGSl8NjMzEwRY\n", + "8/xEObmOHoPO662d39znaIN6ve7GcOGzhx56SESGjBQziCLpsYG/W62WnDhxQkRGYrkcXM2Covws\n", + "zCWM7atXryprizIvLCykDgOIpMcTs0p4Bsp1/fr1oD1arVZwCMMTV+b78FqEz8DCbW1taZ+A/eJD\n", + "CUCpVNI5ZyWIREb9/pnPfEa+9KUvBWWxv2Mw043xOamMi8i7ZCMl8tamkGH6ll0J1sVWLpddteNJ\n", + "FMvtvfH/4xZEAIObF+tJNhPjfsPuyjxadm5uTsvFv8NnPBgtfe7pSPX7fZ3Y3ovY2zh4yNMRmVR5\n", + "XUQCCltkRA2z3hUmttV/Ehn1TaFQcGl+u6nDi0EkvXmxG0x2sXB98DeuXVpa0mBTlLnRaOjzUCYe\n", + "7wic3Nvbc0/35QVEW6OCy8z1RH2yxnpeehyMg8OHDwcJkWdmZtwNnndghN1qWMRZvwZ1xgvUS0nh\n", + "Be622+2UsrhIerPhBbRzsmFrdPC6xn1utXZ4fWJ3uN2E8QuNNy8oH16UvV4vOAHJp22Bzc3NwJ3K\n", + "ZQCmpqYClwnPMU8PiV12vMHD/e0cf+qpp/SUFU4GeqfUOPWLd3gh6yQ3ymTngOcGzVqnnn32WRER\n", + "OXnypH5mswAcOnRIE/uyMYHnsmsJfdhut4NycR/itGC5XNY2we9v3LgREBG8MUPbd7tdnQe8acN4\n", + "8k7FoT3q9bp+zy40q7lWKBR03eTxiTYed9IZ97FzWmS0QT5//rx85CMfERGRb33rW8F9vMTTGNsr\n", + "Kys6bvGsSbQeo2svIiIiIiIiIuKAeNcwUoAXPJiHLFeAx6J4bhKm+XGt1WJhCYM8dx8zUnlUPD8P\n", + "u2xOguxhkoBVkeGu3mMdYLHgSOza2lpKfVvED+KcmZnRz3FfVtf2JBE40NqWxQsE9BLL8n3yAsvH\n", + "Ae6CYrEYqCEXCgUtP39mXTqsYu0dU0b5PJdCvV5XVuT8+fP6OX7LYwNtBYvTO5bbaDTUIoTV1mq1\n", + "1Frko9h5+dQ8cKJgT4aCGbc8XLw41Oj1jooD3rztdDruvPcS9gIeqzQYDJQpZSYKbYS2z2IG0b5g\n", + "MLNYG1smT2+qUqm4h1bsc5nJwZhgl4PnhsD8LRaLaoWzi8eyNXzIgZkpWycvyH1nZydgeprNprIr\n", + "CBngdnz++edFZHiMH6wI6ra2tqbMH+rRbDbV/QXGySvLoUOH9HtvHPGYRT3RBhxGAnC90M9ZbD76\n", + "7atfHR5sf/DBB+WRRx5J/ebq1avynve8R0TSjBT6hl2eeM7U1JT7TsFYfe6550QkrTeF+2xubqrb\n", + "FeN9fX3dDePAmoHxdNttt2k4At8XaxDG29bWloZL4B3S7/d1rqBfd3d3g2e0Wq2J5WomCfx+7LHH\n", + "5LOf/azWXUTkiSee0O9R9sXFxZQUgsiQBbRu/0nKFhmpiIiIiIiIiIgD4l3HSL1VMghePI+n+usp\n", + "W3sBpTYexrtHFmPiiVzaoPRxMWKTsjHValUtAVgYXCewBSIjJorVpm1Mk6c0PS44D+3hWReT9q/H\n", + "XHFcBbOKeRaFZ1myNW7bNUkSNx7KkySwwo3sk+cgTBsIymJ/rBJu47RYHJZZL5QFjNXm5qZ+j/46\n", + "dOhQwJ5mKcTbODFuU25b1NcGsVtgjCFO5KabbgoCz7e2tnSs4b5ZecC8OCMeY5Z9LpfLATvIkgi4\n", + "B8fc8Ry1EguNRkNZG2acvOPblj3Z29sLDnDwfAT4/8HUXLt2zZ0HHjtm61YsFnX+eyy/JxXBhw08\n", + "dgTtwYHtYEB5rfzwhz8sIiKPPvqoiAzjUhDrhz7vdDrKovFBEDuXT506Jc8880zqMx4n4/Kloa34\n", + "GrvWcruwEKgHxBaBAVlcXAyCyNvttitvgr8RG8jjr9/vB2OWc08CXA/OM4g+RFnW19e1rMxM4RnM\n", + "2GL9B3POfYN5WywWdbx5c8XLX8ksPtYK750KMFM47n34hS98QUREfv7nf15E0jGXqGOr1dL5ynFp\n", + "WX2bh3fdRuqthg1OFfGDy9h1571w7IvFc8mwNoqnl8PPejPJnK07Es9GWWzy26xy2DQVrGjNgdn7\n", + "VWEflxg5D7xx8IL5gTx3VaFQ0EmJsjQaDa0nv4A4uSx+j8nnBd4zcK1VRRYZ9dH169f1fliAeKOG\n", + "Ba3dbo89sYb/tydlKpWKLg68KGJh8cYL0Gg09BpPn4WBsk6a9ggvFii1M1ivLSsg24P9nE8OYmPJ\n", + "Lx8soN5JPpH8YHTUt9lsBqlpRMKXEr8I89JocNA36s7uKPTb1NRUSgMMn1lXnKd9l9V+PN7QLry5\n", + "sWVlQJcIAeEio5c02nZjY0NP8tnrRHxtKYbVp/N+v729LUePHhURcdXCgXq9HqzHWes7ME6Pzxpm\n", + "L7zwgrrVGBhPPOftuOLx4qVH2tjYCIw1Hu/2sIbIyI1+7NgxddmhrURG7eW5/bhux44dS5WVdRNR\n", + "j6w2wtjicAl7QIUPyPBmc7/vxW9/+9siMtxAYtMMA6JcLmtZ0Nbe5nQSRNdeRERERERERMQB8Z89\n", + "I4Xds5fYUUSCXTHrEnnsiL0v38PL65UkSaCAvB/3pXe819NOYUaNtVBE0ok1QcW32+0gcS1b22y1\n", + "WwvKOx5fqVSCY8/2b1zrudNsMP+kWk4eOKcU96EXKOyxbR7bxTIPgOeKYp0ckaHVhrJ4ViBbT7g3\n", + "yuQF8LM1xUyizdnFGll5OQH5CDMnh/UsQ095OQ/43h4Px3OtLITIaMyiHjZnmUW/31erH21TrVa1\n", + "zrDaPT2iRqMR9GGSJKkgfsC6MVlN3DtkkDcHeI567DjmtzcOmbnydK4YNkC9XC6npD/wGxtmwJkX\n", + "GPZYOcsQ3H777SIy7AO4dsGEMCPF9wVjwvWwffT6668Hh2HGsVpAtVoNdMdYK8+r4zhtIbi6zpw5\n", + "IyIizzzzjNtPYJA4FAG/48THGN+Li4suU4LrmYGzzOqRI0d0bcN68tprr2k9wUKVy+VAXoLfd6x6\n", + "D3YKbtzLly+nZD7we8voi4TvQx53AOtN4fmslJ/3jrzjjjuUeQOjfOnSpYCN5XUvT3ZhEkRGKiIi\n", + "IiIiIiLigHhbGaks1XFg0iP9b9VzbVZ1T0CTfcGeKjowLj9gnqW5H/FRbydt83ll3ZOvhUXtsTJ5\n", + "yua9Xi8l0SAytBwsm+U9n2OVWFjQswjHxSPtF+OYDABlQZwD+9VRt1qtpvcbdzwXfnpcy1Y29z/a\n", + "l9kEm/eN25StRpQZMUhHjx5NsVMi6aD0vJgmLy4mS6AO1ul+gzVrtVowjkulklqz+HdjY0OPWGOO\n", + "ZvUjB32j3F68E9iOra2tYP5xhgFc4yk4s6Akx0rZ9YulTnhNs8HeHOeCMk1NTekzuE/QNp6EAuej\n", + "s7/f29sL2Ha+LwKR19fX9Xc41s4MEgNyFmCkeC0Bm8LrIpiQpaUlvYbXLNumImGuzcuXLyvbhdir\n", + "rNyXFp5CO5eBBRkti58FFssF7NpXKBSCdfa+++6Txx9/XERG82h7e1vHN8uVMLD2Mhts59+lS5d0\n", + "HDPj5HkDbHB+tVoNGF2R0ZgCE18oFII1htvNi09kxtnWbXt7W8clZ7+YxOvAh2tYfsFeWywW5dSp\n", + "UyIyVKDH726++WYREXn11VfHPkvrMvEvfwwY1yhv9QYq77kckMkLoN1I8eaKKW9LF3rB654K9GAw\n", + "CGjetwq8qHqnIVgLitNwiKQXQaa97YamUqmk0hiIDCcyrmFXoaW4a7WaLlZ5weGDwcDdQOVR8B5s\n", + "ULdI2k1mXUkrKyvaLl7QKgI9NzY2XBVcm/yyUCjoNfwytm43kXDsM63Ni79tF35R4R6Li4sBJb65\n", + "ubnvl413AgfgBXe/Gyl2+3LiW7zMefHF/LInHQG8KPgatAM2Q9yWrCCOerErCdfghVGv14Mg3s3N\n", + "TXeT4QXLovz8DDt+vSTo3ulSdkfyy4Y1qoA8lWY+rMEB9KgD7oO6sauY4Z2AArBR4hOaGFd8+hDt\n", + "zfXgjQg2DuxGxOlPbKQ4XVEeeIzxPLJ1GwwGgcGXBbyEUceFhYWg77zDRDwX0Rb8Ir9w4UKQDJz7\n", + "H+3L9+ZxZV3U41T7MR93d3d1jqBuzWZTN1xYzzhIG/3VaDSCZMQMz0jjUBBcy6EFntFnDaBLly7p\n", + "+ECZ9vb2dBxjjVlbW9Nxgg3V7u6ujrG7775bRIaK+uMQXXsREREREREREQfEuy7Y/Mfl7uN72iOx\n", + "DA58Zgvdo0lt4Ka3mx7n3nyrwKrNsIZRLrbePVcSB5mi/VE3lj9g5g3XsMvGPvcg+RNZtsBah5VK\n", + "RZ/BOZ4sQ5MVWGj7h5XGvXEHiy5LeR0sBSxzZi5ZuZyTwaIe1rXDFjYsfy+IudPpuAcf7BF2du2g\n", + "zbLyBU7CmE5PTweM7jjwcWSrMM1/o51LpZIG5GeNnTzXRF4CcP4Mc2Bubk4tftaegVzDSy+9JCJD\n", + "FgxsjefC8FgMnme23biv8TdLHWCcevpUxWJR87wxo2EDkJmBQ/tw0mqA2Ts+VOK5mdD2zJjCFYv8\n", + "ZdzO6MNyuayuJzArrE4O1ujatWvalvfee6+IiDz88MPuuLV9zMH/DM5OIOIn2hZJayjl4f777xcR\n", + "ka985SsiMhwbVgJia2srkGeAMrlI2l3tjSfgyJEjgZQEy7PgeWtra4FMQrvd1ncC/r1y5Yo+G/IG\n", + "jUZDFeixHt5zzz3KcKFuc3NzymZhXLXbbW1LL+SB1z2wbWBCOfsI2n4wGGSueSIjxuz8+fNBQml2\n", + "HzNbhTphzB4/flzXCbQFxnAeIiMVEREREREREXFAvOsYqUmZqP3mEWOwAnJeUDr/3mOkOKccPrPl\n", + "/0mwUSLpuBVYB3ysFBYLB32zdSAyvi0n/R0siKxj9B64Dfke/N1+xEHRN4jn6Ha72kZ52eEZ4+Il\n", + "vBxvNl5iampKrUQb5Criq04zm2XH+WAwUEsU19y4cSNg5fBskVH7eeyo1xae1T49PR0wa1kHLmye\n", + "Po5PA5gJAbrdrrJULGQIRs2WB9/b+D8en56QJrC1taW/veOOO0RkKLDITJRImkXjnHE2XpLbwwuG\n", + "98YY7sGWOMaEN9Z7vV5gjaMuIqN24fp6defDDrYMLJ3BgIwF51y0/b+xsREofc/PzwfB11wmXkd5\n", + "7QDAmLAUjJV+4FyazC7bNjxx4oSWy5uHHiPCAAttc43ydxybxbGXGBN4vsiIiZqeng7KurW15UpO\n", + "oM5og5mZGW0vZsIwbtGX9XpdnwHpCS43WNcnn3wymHM8trntJz0cZNXT19bW9FrObQkWG2sNrxFg\n", + "ME+ePKl9jXpwP+B+fHAMbXH+/HntG1xrY9M8vOs2Um9GUXu/4NNTXgA6L4AYjLwJsy5CXlwxELxT\n", + "cpMii672wGW2i2Cv18vUmmHMzs7qAoe2HwwG+jLy3DPsNrDPYPqW28W2ES+aHOTunWxjbSyR9Okp\n", + "dp3g3t5LZ1KwCq+3YHgBwugvm6aHwWk5uG52MykyeuHwS8S+kK9du6aLA55fr9eD9B3e5j8r0bKd\n", + "e5yAmk+Neu3Cm3XAbuC8jRTfm09PYUMoErqw+D48VzAuUc92u633we+73a4u3C+88II+F33GJ/ns\n", + "y2Zubi4I8C0UCu7pUy8o3X7HmjzcLp6uEcaHp5CNTTv3tafTg+d6a0zWy9GmnJmeng4C83u9XnDy\n", + "7cqVK4FbaGdnR91LeKHdfvvt6sqCq1BktIZijG9vb2u/cV8CfHjGroXLy8u6JnCbTrrOwlWEecmn\n", + "6dg95502xXxEfy0sLKSSPdv5wGr8QLPZ1DGBTdqRI0d0LfIOzaCs7XbbTbrundK0J0I3Nzd1XMAV\n", + "xocrWLPOm9eYh9iEFwoFbS9O1m43/TMzM9peGAfNZlM3P3CNMpHAz7dl4QMm41JTMaJrLyIiIiIi\n", + "IiLigHjXMVKTHq1mS8PTfZoU2AHjfqVSKaDsWfuIv7M6PZ6r8M2wavsJ1mYL0ysru4ZEhkfmcawY\n", + "ePHFF10F57zEyvh9pVLR53q5/oBarRa4Hj11bQ/T09NaBraavSBegHNF2TYol8tq0fBx4Lzyezo4\n", + "DD4azPcVGWlVMSPFsMmIC4WCWot8nzz1X86fiDLwcXlYpHmU/GAwSB23x79gO2AhZmlqefPPSoSU\n", + "y2VXV42TM6PMfD+7PrDF6bnx8Pt77rlHnnzySRFJuz/smPaCrIvFovYDM1M2gTIfBMhjgbgd2CVr\n", + "rWc+wo5nVatVd43My7WHMu3u7gYHQvb29lymzDtQAHYE4/7YsWOB27pcLrttiPtxjkEofIOR4n7m\n", + "gyC8tgFoK06gDOStm7Vazf1+90LShgAAIABJREFUXP44EZGPfvSj6t7E79bW1rQMvP5gfnMwvm17\n", + "ZhK9+ciadmj7drut98GawDpSP/3TPy0iQzesZb1ZOsG6Xy280BmUEc89fPiwzjl8tra2FjC/rVZL\n", + "mTeMl0ajoeOSc5biGWCfOp2OzlcwR61WS/sbrs+lpaXAC1Qul90gfpswPks3jxEZqYiIiIiIiIiI\n", + "A+Jdx0gdBJ6acN7vPIuZg0RtPBQrfvO/HMSLfyfNwj4pbJmz5BTs8dcswPq8fv16rvo3KyrjGraY\n", + "YYWhfllMos0v6Fl8kwpyZtXNsyi8HIVe2WwsQBabaSUxRPy+tUrUDFhvXtZ2kZBZY1aAy+e1lR2z\n", + "m5ub2gZgRRuNhlqzEBT06ujVo1arucyAdw+vfFbFfDAYpARPLXAPKw4Jls07ds1B55YJfvLJJ4Pc\n", + "Y3wfIEvdGWOP40nQnzwv7Pjh8vF3VoqFRWRxP76WWQyPcbb344BxPHd6ejpgx6anp4N5NS5rA9gK\n", + "DljmgGZvbLG8hMhwHPzwhz9M/YalLXg9wThhBgesA1h1jx32sLu7q2sQM3Fot7zMBffff7/80R/9\n", + "kYiMxiHHLHHbe4c/MO8xL3d2djTuK0uQFZ+zsDDWbRyk2djYULbmiSeeEJHRQQkRX0Qa9+OYQAZn\n", + "/8DvbbaBTqcTxCoxG4kx3e12U3I6WfX14vWSJNH5inHAsWWIdyuXy6nYPZFh+3lrC4Dx5B1msXhX\n", + "b6Qm1ZTiRVdkvMvBS0bMJ5K8k1J2s+bpTXGZx53+mBQoFyZroVBwFah5McTAAHXZ6XR0YWKVY9DB\n", + "rD3ipQGxLodyuaz141M2aDe0Fbs/GTbg2dtcsUsR9SyXy7oI5QUUlkqlfSepHOcO9hJOZ514E/E3\n", + "B1jseIxhweOgeHZ9oi/xOy+YVESCl2ur1dIXE+5Rq9Vy3d9YgDhYHy8MDiz2AlaBXq/n9qvd7Lbb\n", + "7YDa39vbC+a8fcnj/7kf8lLrsPYM2pCTR9tysSGFlzTrNWGNKRQKQRJvPlzBYQG2Pfh0r2ek8Pyw\n", + "Gm6FQsF9Sdt1zDu5yG2JFx8HDON+WZsorAnsrrIB79VqVccoXDI7Ozs6H5Du5eWXX9ZNKe7BL2G0\n", + "/YsvvphyTYqkN3/4lzcveUbUtWvXgnGSJElwws3D+vq6Pg9t0Gw2dVNgT5yJjOY164TlaS4xeJOG\n", + "uh09elTbF2XudDqBltqJEyeCEIrbb79dXXloe2iS8f0ajYZ7otuelNzc3NTn4feLi4vB5o8TFKPt\n", + "K5VKsJnKMrKtgen9rtPp6OdsHK+uroqInzgdmOQgVnTtRUREREREREQcEMlPSsco9dAk+ck/dB9g\n", + "l4m1ZrM0VywjxYwJLPkkSYLguyRJApq0XC4HdDDnufMYs6zPcEwY1kKxWFTLJy/od3Z2Npf29IA2\n", + "qtfrAePm5f3j578Z3S/PXcHfvR1j3EtkLeIfSQdYxRhWM6z2c+fO6WcILL18+bJaVGCXsvoM1jD6\n", + "qNls6ljkoHOwYnmux3K5nGKiUC9YsWyRWhSLxSAY1t5bZMhu4HcIwt/a2kodBwd4jthkqpVKRdsE\n", + "92NVd2B5eVnLj7E4OzubYqeA48ePi4jIxYsXRUTkAx/4gDz77LOpujN4vNuganYd5rmPOSjdy92H\n", + "+jBbwGyFp/FjwcljWVGdpSREhtY9+h19vLKyou3Hbi0Lbmfgk5/8pHz1q18VEZEPfehDIjJkpLB2\n", + "YYxfu3YtYL2uXLmSyrwgMmQ92K0oks4Fx0HdaH9m5zmRNepjXcUsb4HA7FqtpgHcYKZ4nIHN39nZ\n", + "CdaprAMmnF3CModTU1O6FoANrlar+hmHZuAzTm59+vRpERE9ZMG5T7ncYAnB6GQl87WaVh5OnDih\n", + "7kqwX5ubm26eS8hfYG17q7w4BwHW88Fg4EaeR0YqIiIiIiIiIuKAeFfHSE0aQG3Bwnjsd7dCgWyh\n", + "sQ8Xu3W+1rsfxy0BLLCH6+zvut1uYH2OC1S39+Uyi/hMGizHYrEY+JnHsVEoM8fVWGG0LLDFzfFS\n", + "tvx5Ss/8nRf34TFcsOgOHTqkFhrHGNl4lHa7rfdG/Eyv11MrnOMv0JbjAhNh1aF8xWJR+4bbHM/j\n", + "eCOMdw48tkG69hqRIeuBPoEl7+VU9IT3qtWqtgEftWbGQiTNwHlMFPoNcXdcjxs3bgRxcTz3vPxg\n", + "zKrynLN5CFutVsACFotFbSPU48qVK0EMpcdGlUoltbjBRHzve9/T7/EsFjfktmZZAZEhS4H24rFt\n", + "2efd3V1XfNPOkWazqSwmWIper+fGWll2qlAoaN0x1ra2tnQsci49T7YFz8BYm5mZCQQxvTHGzCTK\n", + "fPLkyYBN57hMfMfxUCi7xwTzGEGZ7rvvPnn88cdFxM9biPtsbW0FivBcFoyDJ554IvAQMEPIc9+u\n", + "4Ts7O8GaZYP67bze3d3VcQK2q9Vq6TgGk3Tx4kUtL7NiYKL4fogZRF+XSqUgn18WPCbKxgReuHBB\n", + "64xxz2s0j0+wipPID7zdeNdtpLzNCxqaX2I8UK3bjTdDXnA40595GynWh+END/61NH6SJDqZeLLa\n", + "AF/+jJ8BYKL0+30tCwZguVwO9GsYXP43o6puT1lYWK0YViLn7zDBuY08CteqevPGkIP6UR5ejHAt\n", + "XsJJkijtjft4SWQZPDZQVg4wt1plHjigFODFkVOYwJ3FyUzxPVP2nIQYwCbRa0fv4ACn9LD1XV1d\n", + "1RQcrBCPsYU2vX79ult367Lb3NwMDmGw2jG7wzE++aWFazgJM48F6zJhV7an8eapxPOGht2BuD82\n", + "zXBNNBoN7Qduc08vCeBNp3cIxn42MzPjnny1m6GFhYXUqSn8Bu3Pcx7rgFWDFxmNk+np6eBQwmAw\n", + "CAyz69evq8sGL1Q+MOC5LdHOzzzzjH6G/n3xxRf1M09Z2rpXGXzq1csGAFQqlSABdbVaDU4zTk1N\n", + "BYHpPM7wPB5rHvDd1NRUsAHudrtBEL/NDOCttV6mCWxAMEduvvlm3QyNO73I+lxvFtVqNThI0W63\n", + "tXx8eMX+jjeR3pjx0hB5bc/6amhzHrtQ1OfTvlxWLlMeomsvIiIiIiIiIuKAeEcyUthFMsvDx/Lx\n", + "HXbcLC8AsASAVaL2ZA14x+qxRR6849usN2UZIWa9ePeM38GCLRQKgQuL78VUPK7hYEJ7P8Z+dKtg\n", + "gSIImvNb4bNarRbksmu324HW0d7enpv3CpZI3hHTer2u7cYWlbVi+Gg9uzKs25V1dfC7Q4cOabt5\n", + "SYE5eDQvf1wespLMosw40n3jxg1XG8tTd0d7oK/a7bY+h+uB75mRwP28cnl5E9HnrPEES+7y5csu\n", + "c2D1oTjnIurNFj9+l2XZ2/lo5xiYPATusgaQN/bx2fz8fOAi4gBllLVSqWgb8jF5y9BMT0/nZmHg\n", + "ethrWbuH549dsyqVSqBztrOzkzpWjvLZ+cXBzZ4OF9qfxx/GnXcgpNfr6bVgpDqdTkoXTGTIjoD1\n", + "QNvzuPFYV3zPblBee8Gscs44ACyZF/5x/fr1ICFtqVQKGIi5uTl3PCIYOg/b29uBy471kJg554wK\n", + "/B2Qx3Z57yn066SuuUnBivqecjzAc89bH9E3pVJJy4q24hypeSEsCwsLwd5ga2srODTDLn6EF6yv\n", + "r+s4y9NMnASRkYqIiIiIiIiIOCDeMYwUH/f3YnysSJqX98mLfRgMBrpb5/taS5YD0Md95sFjjmwA\n", + "d6VS0R03xxvYXTYzbJyvz1qaWdd6wnl5x+7r9bp+j3tzQDGsj1tvvVWZCPTD9vZ2wIA0m82JGBov\n", + "ZogFDxnW4vGkDmZmZrR92codp66ehVKpFFjyxWIxpciL+1vmhf9G+8zPz2sAM9qbA3cxJiqVilrt\n", + "3N6eKKDHEliGqVqtqvXHMSWwfL2+Qp+//vrrGmyMth0MBsqAgqXa3Nx0mS3O7Yd72ByUzHp5qu0A\n", + "M4RApVJJlR8sC1udHOsiMhyn9qj25uZmKv+dSHq8sPK+ZXw9scwsmRQ7X3nsoP28++3t7QW/4/aG\n", + "ijUfVLExXwzvMMn8/HxKPVwkHZuFNvAUpkX8mEvMFVbett8xQ4z+4xgZPnhjWWORUT+BjWTpA4xT\n", + "Wy+RYd8juBr35bHoxZhybBae84u/+IsiMmR+rPQDx7EybJ94BxKyxGsBVvCeFBhDt956q9aVleYx\n", + "jlAeb83ksZ0Xc8Uxxh7Q/1NTU8FYZbkPzOWZmZmUZAL+ZUVzPBdzGLkveR+Aeq+srOh7Ik+xfhK8\n", + "YzZS3qkzgDcMTG/bwcUuMS8wll86XvJgPIM1aDCZ806EsMuOT2PZEwutVks7HROET4ZxG3jB67jG\n", + "bgz5GQz+jBcenNziBKH4LSbOxsbGvjceHhCMLDKaOKiTR6d6myhPgdirL5eXDwfYlCVc3zx4pwB5\n", + "c41FM6vcABb4ubm54BBBr9dTtwMHluNFD+r80qVLEyepthuaQ4cOuZscLKp5tHaxWFQXBjZhjUZD\n", + "Fze8MG7cuOEGANuN6OHDh93AZwDjdGZmJphTu7u7gZHALhGR9AZKJL0g872xgUIfbm1t6X24zKzt\n", + "ZTEu4TiPGS6zSNrwsmOR/99LG8NAW2Kj0O12A3cLH5DAOG21WnLPPfeISFpHyJad55RXD6Ber7un\n", + "tmwfs/I+yj43N6dhAxy4bcHrAM8FtAt/xnpkIsO+soH5N27cUHc6gs45yN1zLSHp75e//GX9jNOt\n", + "YLx4Y5u1t/COAbL6nLW77DrW7XaDE5XjgDF79uxZPdXHOl1eAu1J0Gg0gsB3kbTaPMoMvPzyyyIy\n", + "HDt2I8MnG1mvC+OD56h1yXNbeorl3K/4GxvuQqGg4wiB6JOcGoyuvYiIiIiIiIiIA+JtZ6SwI+Td\n", + "tj1K7lHiTBmy5YrdJFuuVuqAdVoA3kWz28Wqk3tWaLVaVese9WAXBrNBNvC5VqsFbBcHNLPiq2Uk\n", + "SqVSYPXy31nJYzlo/K0ErKPp6Wm1HmHJczJdr1ysgzIp8wKgDUqlkt4bltza2tpEuZIWFxf1WpSd\n", + "DyCwxQ9MqrT7vve9T0SGFLpNiJolQQE2gVm8PCX6vEMR3W43YJ1OnTql1l0erb28vKxl8OQSXnjh\n", + "Bf0bbJB3JB1gBilP78dT7eYsALiHZUfQnnk56jgAmH+Pe7EcgMdE2bbma9EG4xiCU6dOiciQGbDh\n", + "CF4QuReAXi6Xte+YwcHYYVcg2o3V7MFEefnGPEYC7eK1yW233SZPP/10bp0BlB9MgueF8PqfgXnE\n", + "WRTAiLErmxkwlJ/HBNZ67i/rSeA1H23F4OTKVi6HxwrYz52dnSCon+vIqvc8N207TZqIOQuTBqHz\n", + "AS+R4TpgXbaLi4va5t///vdFJL2ueMH+eTI8vM7y2Eb7nz17NvN+s7OzKYZJZNjOGLfQ/Wo2m9r+\n", + "mFscMgI34iSIjFRERERERERExAHxtjNSVjAtS/XaZoLnvFUsSmiPQvLfvLO2ViVbtrhfpVJRZoOD\n", + "TS2yRDVtvBZbWZyhHRYIH8lndXWUhYU48SwryFir1dxcemATuJ7MenFsl4gfl1SpVNTqQLvs7Oxo\n", + "HAKsuixrHJagZxF6wagcX2WP2zYajSDQem1tTa2bvBiFTqcTBDV7cULePaampgIGYWZmJlBKFxkF\n", + "P7Iat2VSvNgqjvVDW83OzqpVx22Ux0R5sWiIY7r77rvlm9/8Zua1wMrKirIsPO7AajKLgbqgvt4Y\n", + "2t3dDQ5hiEgQ69Hv97WvObjaikdy5ngRP37HCoAyQ8OwAeisms1BsNa6ZkaK89J5TCiCm9mituKb\n", + "3Ea47/b2diDj0G63g2BklmxAu7HUgScRwAKWAPqQY8fygs1tzI9tF2Z5WDVdZMis5OUA9BTd+b6W\n", + "sTp06JDGgTIjhXGM+lYqFWUGH3vsMf2dnVO8nnnitcizKCIBY8pgqRAW5xTxMxPweGf1/x8XmPlh\n", + "Rs2uVV6A+/Xr14P8oK+//nou24216LXXXstdx5gZxJrAzwBwj83NzYCtK5fLWn4vborHH8YJ5tYk\n", + "OWff9o2UdWvxpskmDMb3IsNO9XSaLLyNGU8+T+0ck5lPYHnKxbZMXGZbJxHfHcmbMK6n3VyxO9JL\n", + "2MoLKgdaA9gUzM/Pp2hxkWEfeIMFEx+Dt9Pp6KKSN0EqlYo+I2+CLC4u6n3QrrVaTV9ovEFDnVBO\n", + "/mzSwEh+AeadhsFLvdFo6MKJ5/LEBXZ3d92XEU7AoK87nc5E7sB6vZ7SPxFJB0FOCq/tEUC5vb3t\n", + "vvwsbr/99iCVQ61Wc90KGLO4b9ZGyo6dWq2mYwzjq1Ao6LxBv5VKJbdO3ssXZdjd3U0p0Iv4c67X\n", + "6wU6WDxe7NrA4E0Z+ojT+OBluLe3p6cx84w6fh4r6nsniO2ptE6nk1LwFxkeVEC/Y1PNJ2Y5oBzj\n", + "nY0IL+Densby1g8Ob+C254TtIr5SOuon4hsbrJTvbUS9VE328MzCwoIGmzPy1hPPRYV2LJfLQbLk\n", + "LGCceGEOvG7zOLJj75577tHy4Lm7u7tBGEpWgmqbBLler+s13F+THMwRGc33kydPiojILbfc4rrg\n", + "bN0WFhYCo7jX6wXl5jCC/SJr7UQZOH0Y0hjhPcRprbIQXXsREREREREREQfE285IAewusUloWcLA\n", + "S1bLSYStG4+PUbK7zDI5rEGF75rNphsIaYMgmXJmNwRrMuH5lrJnTStm1LygdhvA6OlNeZaryIhV\n", + "Wl9fzw3yAwvH+aDygoc9jDsWDrDLiV0neB73NdoQ/9br9eBI97jgSe5ryxzMz8/r37Bcs/JOWTaL\n", + "8wh6rkl2++bJJOQdZZ4kYB6wwbIMVpWG5ZoXsL63t6dUPs+FPJkKz2pHmdrtdtBvtVotODrf7XaD\n", + "8VkulwOWK0mSlNVudYY8LTi+hseBJ3GC36H9WYWdNYOs+4kD2tk1YXXYPEuZA8uBwWCgbcg57exY\n", + "YXc//uXcklYewraLRaVScdkm2/9ePTyWaWpqSscHP8+uab1ez9XpAngOWvfh5uamrgXMxMG9yeA8\n", + "f4BluNhbwYHlFlmsMdgx5PPjOvEctQm3+XdcBuDJJ5+UO++8U0QkJUfC65JI+vCSp9eIMbm9vT0x\n", + "+5QHyLg88MAD8slPflJERlIHV65c0fUEn33kIx9Jvb9EhmsIxuyrr776pstUKBRSCZtF0sH8+Hdn\n", + "Z0fZbDBTYGRz7/+mSxgRERERERER8Z8pkrwYlh/bQ5NEHwrLguN6PHVyazV76uQeu8MxCHyM2lpA\n", + "HFvETI9lkDhgnJ9r78dxWBwgbwM3PVkALwZKJAxkbLfbau1wLAXHfSGWJUtIFM+FJe1ZifsF5wBk\n", + "pWe0AytHTxLfVKlUJma5AI5LsYrxnU4nldNJJDtXHq4BW9RutzMlCxiDwUDuvfdeERnGCoiIPPLI\n", + "I4FKNLOoNp7EwjKhHIPCshpZ0gB8D/b7e8GjYNNWVla0jTimCjFhzGyAKQFL4o0fZn4AT9qBP/OC\n", + "jYFyuZwKzOecfoAVt+12u0GQLweHs4K7F5cIcOyQvR8HqgOHDx8OVMmZbQEzkCVuaVWzGXlSASKj\n", + "vkFfc8A4ArNZFgVl4Tp4jCnaZ2Zmxo2Js4eIvDHBZeHnemUAvDHBjDPaIe8eN998s9YF/dbtdgPG\n", + "mccGYqpYDdx7Bt8jb6yNA+IsOQYTbXjs2DGN2WSW144FjrnEHGBx23cSwBrNzMxou+Z5GiqVinvQ\n", + "y2MGsQ6gb2ZnZ7UfxklJYA8yGAzciP+3bSP1djw3IiIiIiIiImK/yNtIRddeRERERERERMQB8bYF\n", + "m1tXEx/3z6McQcsdPnzYPYoOtxH0QaDea5+NZIYIpNzd3XVpW+vuy6INAZu/SmSUa+3SpUu5gcCe\n", + "/g6eX6vVUi4HkfFJeOfm5pS69lx7Xs6hLLciP5ev5WtYi8NS7+NcTuOQ57rwjmcznW6Dm9ltZANL\n", + "+VmFQkGvwXhBAOI48MECbjcvubHXj3BNYqxlBe5adw+7ivcrlyASqicXCgVtIz6qbYOVFxYWtCwY\n", + "v3ywgWn3vJxx+F25XNY24jLZXGAcXN3v93V+cY4y3MdzPfHz4VbwNMWQl6zVak10+OLmm292Dyt4\n", + "SWHtvO73+9oe7Lr67d/+bREZrU+PPPKI+2ybo7Df78sdd9whIqM28LR0Tp8+LQ888ICIiPzZn/2Z\n", + "iPgusaWlJV2rEDDsSVN4h0VarVYQpsHrAVyQCwsL2g/sSkQf4XcXLlxwDz584AMfEBGR733ve/pZ\n", + "nosY33W7XS03B6qjP6ADxjn5+F1i13eet3laWSKjfuMj+Xhuq9VKzXGRyXLA2Xvb+cg4SFgH60Ci\n", + "XT3JoTfjgeJ1dJL7cGgJfn+QtZAx7rmRkYqIiIiIiIiIOCDeMfIHXm4dL7fTuGzX2BUzIwTrCbvS\n", + "qakpZYk4wNIyXBwYa4N6RdK5sbAz5+eeOXNGRNLZ671jx7a+bDlzgDQslXFKq7hPVoD5OGsE8IRC\n", + "mTEQSVtcnvIw/z+YI68NPBzEmgET5Ymf5qkO8zVW9VwkbUV67Fge08iwwcZTU1M6ptEug8FAA1OP\n", + "HTsmIsNgSNvvbN1zwDXKgHF/5513KrPAAnle+1q2qN/vBxa/J3Z448YNN2jdYjAYaB9x+1q2qNvt\n", + "BuKlWWPXlldkNNc9tqJUKinbgPnf6XRUSPCuu+4SkTTjg4DXU6dOBeKWXBcwJZ/+9Kflj//4j4Nn\n", + "eyyMFQdGGUXS+dm+8Y1vpMo8Nzenz+Oj9fbQQq1W0zGWt3b0+3036NuiXq8HIoXMavPhDjA9Hutq\n", + "A+D576WlJS0zsLa2pmsIWLms+YY+gpfh2rVrOp44Q4QnXgygf1dXV+VjH/uYiIj86Z/+afA7rIWL\n", + "i4sqscDrKecCBbyDIygX5gIr108anM5ZEXjsW4mILJkc79CHFcZm1s5jenjs5M1Xr81ZiNYeviqV\n", + "SloWjEvODIL68jj23td8mMw+lwVIvcNnWXjbNlJWF4MHFiaLN4nhWuHTTnkvgqWlJR2gSELIKS6A\n", + "lZUV/czbJHinBfm0gH0RTE9Pa8diweANBJ4xPT2tHeclE8YzlpeXdZHh+uJlyYqwoL/HqexyW3mp\n", + "HOzvZmZmUikwRHxdIHtvlNnbrNm0HCL+RiXvVBefuLAbENb48dxjfF/vGQBvrixNLjJyDfDLf5KN\n", + "YKvV0kUSaQ+KxaK6j/DvTTfdpBtkzIFOp+POEQBj8oknntDP7rvvPhER+dd//Vc34e0kbldvUS+V\n", + "SjrOvZMwvLh66u6cCgnl4IVRxHc9cOoHlEMk7ca1i32329UXLMq6sbGhL+df+qVfEpFhu9mNx/PP\n", + "P6/1BPhUKV7gpVJJ2/rxxx9PPZufy/VjoG8wP5IkCebzqVOn5KMf/aiIiPz+7/9+cA/eqGCjlTcW\n", + "19bW5Ac/+EGqnB5WVlZcnStgUjcKK2FbraDnn39ePvGJT4jIaA6sra2lwi7yyvfwww+LiMhv/dZv\n", + "iYjI1772NR133C52TSiXy+7a9ZWvfCXzeeij119/Pbj22LFjOkd5/be/W11d1fmCdmFtw3Fg9xeP\n", + "fXwG8P289xgAY6dcLqd0l0SGcxXzDBvqubk5bcu8PmL9qjw3Y7/fD9aZrJPbdryx7uQ4gyUPnjZg\n", + "5m8numNERERERERERESAt42Rwq4Q7AmshX6/n+siyMuRVi6X5fTp0yIi8tRTT4nI0OqwO9Dl5WW1\n", + "cmDlMxuUpTaM8loXoMd03HTTTep+ZMscz+NgU8/qgGWO4NRms+k+B9YH2qVYLKqV4DFSY4PmSDfL\n", + "slNZytZ51isD7YHgzE6n4+rlgEFk5sK657xE0Qy2ZsCeIViT2VAeG3aceAmemUpm4BlcZqakRdIB\n", + "5mjLdrut4437ywamvvrqq3o9GFtWaEf5OEAV4441vDAv6vV64LZOkiQ34XAeut1ukKPqzJkzygKj\n", + "vseOHdP5zfMc/ZuXi9CzJO1cRVujDTinHN/7+9//vn4P4HuM00984hPypS99KXX/wWAQBKMvLy9r\n", + "3WEJP/fcc27+Rc+15iVgtQcG2NWBz9bW1gJ2jAH9shs3bkyUA+7y5cva73lW+OzsrKs27a1jNq/n\n", + "LbfcooHaaO9XX31VTpw4ISIjr4GIaFJtzPnjx4+n2FgLjDt2PSNo/pd/+Zflu9/9roiM+oDXUzCU\n", + "6+vr2odgQLiu3AdwBSOcY2FhIUiqvbS0pGX1QhoQvD49PT025CFPYdubG1gXa7WavhNQrq2trZTK\n", + "uUh6PfHmDMD9jDHujXURX0fMjhNey1kHEnOTPQqT5Codxzixi8+WZWpqKuXdmRRva4xUqVTSF4U3\n", + "MTAoRUYDgF9GNpXM3XffnaLR7e+sCCPfl0Xh+CQXBiAmJy92XhzB6uqqlgkLLm804HIal4ARExY+\n", + "96zBgVgv1K3ZbKpEfxbyXE4ck2V/z5+hzjwY+VSMfQbHm+EFz/2LU0UvvPBCbhJX/n+vHpwtHbBj\n", + "q16v66bK25jZeoukx0yej90D9z8mMcfA4GXIp5Q89xmnH7Hl8BY+jM9KpRK4ybz7c/3xktjc3HTj\n", + "EfHyh5jj+vq6ngTD5vjq1avBhnB7ezs4VVYsFrWs2GT3+/3g5V+pVLStMOY2NjZclzIW4YWFBR1v\n", + "3DaYXxy7g7/xss5zmzL6/b6e6sPL/OLFi/py4bHtAW0NtyCnLUEbLC8vy0MPPSQiozQlzz//vHz+\n", + "85/PLBc2DA8++GBwwq9er6dS16AeNpbpzJkzOn8QJ/ajH/0oSLfivZQYGLNcN6Q3OX/+vBvWYA20\n", + "YrGoZYEBzkYqh2TYteHs2bM697x+xfhsNBpBCAK7lLC+/Pqv/7rOC2y0bty4Ie973/tEROTZZ58V\n", + "kaHhcvz48eB5WCs5STfu7W1K5ubm9N77xe7urttfk24YvJPrFt77m9Mz5RnwpVIpeDf3+33tJ37X\n", + "oN85ybEVzeUwEs99yEa0dTPu14DUuh7oqoiIiIiIiIiIiLeXkeKAUgasSezQeTeN3eny8nJgxfCJ\n", + "JHZRwCq2aUv4Mz4Vx+z+hs6oAAAgAElEQVQD6FamVWE5ehYOLDrPqigUCgF9OzMzo8/jEzNWL0fE\n", + "t8LQfvtJ7OglTrbpODiFALNKsOrZlchuWcBaINPT01pP1I1ZEXZRjGNL7GdsfdrElP1+fyIro1Kp\n", + "uK5TD54FNwl7wWMdVu7Ozo5+jjF7++23q6XKOmB4bl6wdrVa1fbzUlYwI4XxjudXq1VtK/x7/Phx\n", + "tagxxprNpjKzmIPz8/PKymC+bm1tBX2ZpauDz5n9sqzC3t5ewBqXy+VUf3BALK7Fc8B69ft9+Zmf\n", + "+RkREfmHf/iHVBugfiLjk2ADhUJBmTk8d2NjQ8s9zq2GteI973mPiPiJdK9cuaJj+xd+4Re0fJ6W\n", + "HoDn3n///UFbegmgvVRMMzMz2q9oZ09HyzvdNS5IF/c7efKktjUYvUajoQHyWKNZl8tL6YE6Xrp0\n", + "KVjLz507Jz//8z8vIpJKwo13DYcYoJ3BJP7whz8Mxucrr7yiLkrWcoOuFsO2V7lc1ueCNWw2m3Lr\n", + "rbeGjfQGDh8+nHvi0juI4Wn9AeNSYvG9cO24EA7L7mSx9PZASKfTCcZKuVwO0r212+2g3/kkHycJ\n", + "tynPZmdnU9pyIsM2txqIe3t7+pldH3PrPvYXERERERERERERLt5WRspjGVgh1bNoEHzNbBRb42CE\n", + "YG3NzMwoy4IdPccBwFLvdrvuzhNMCVv3sEA8deA89Pt9rRtrrmDny9Y2PoMFVK/Xg914tVoNAvO9\n", + "ZKnjwIwUB1Lb/kGZRPzgapYIsNZI1tHV2267TUREHnvssdwy5kkYgLlsNpvahui3a9euBePIY7yK\n", + "xWIQGJllUXl12a9yL7Oj6Ff8W61WlZ3CWBuXVBMW5s7Ojl6DsW3jiADbljs7O9oGsOQuXryocwmM\n", + "yc7OjrK/aKPr168HQdilUkmf60lkoB8OHz6ssX5o2xdffNG1mj3VcQ+oW7PZVOsfbcosFdgHnkdg\n", + "1MYdtQfDVa1WdbyhPZrNpsZX4t4sscLAHEds1kc+8hENhkcbtdttZW0QZzkumTfWgWazqfXEXFhd\n", + "XVXmC33i3euxxx7T+yAg2+uDXq+nY4ZVpb1xh7KA0RkMBtp+CL5mVm7SoF+er946YfUERUZjmj0F\n", + "mGtgl2ZmZrTMYK6+/vWv6+8RL9hsNidaezudjr6DWOke7xN4PG677Tb5l3/5FxEZMmqcWcBiXFyp\n", + "ZXe8tY1Zb/u5SOjJ4O84kwPm2+7ubsAC8Xs2L1a30+nkZrPgoP88xoglcvLWUIyXarWq6+e4hPaM\n", + "d4wgJ9Dv94NAPJERzeotbgjWZOoXi1y5XA42G6yHBHhZ6WdnZwN31NzcXFCGSqWiL3OU89q1a+4J\n", + "Q5QLE3dmZiag/ovFYuAa9Cbo4cOHA9rYO1Fm4emkWKEzD953WUGG9hnz8/PahjwwbRDkPffco6dg\n", + "+OVrKWcObuXNHMZM3gkXPlgAZGWMz5vMvDhliZ/yv3yPvMnfbrcndjN6gGtqHLzDEl49MVahR1Wt\n", + "VtUFg7Zvt9tBnfj/8zaa165d0/GOhZc3O1iYq9Wqlhmbjqw0SbyhQVtyADrclN7mAS+0cX3ABho2\n", + "BR//+MdFROQ73/mOPg9lzgIHHIsMN1ww+rCe3Hbbbfo7BJuPSxFi1xqRkdG5vr6uaVRwmi0LeB7m\n", + "4zhDAvNyenpa+4fHFTZN/GJDuTAOuO3RjjxO8ftbbrlFN5iem5NTRX31q18VkfQJbASFw0g8evSo\n", + "loGN8gcffFBERiKt7FLCGsYnRIHZ2VmtJ4tJo41QPl5/8N2NGzdS75BJhCF5LWKCAXMR7ZokSSq9\n", + "i4i/8eW0LHwK2Yp+FgqFIM1Tr9fT9kCZyuVyMI6SJNH1Gvfb3t7ONRKy3ju4H+rOp71xjZeODmXe\n", + "3d2dWPw09ex9XxERERERERERESEi70BGqlAoKFUKq7FYLCoLxDt+6/bg3bSV22csLy+rtQEmiYMN\n", + "8Vm9XlcrB64HtiaAhYUF+Y3f+A0REfnDP/xDERnueu2uudFoBElvWfMEFiRb2Z5LBGA2ytOiyYJl\n", + "BwaDgT4bbAZbV7A02CL02Kk82nh1dVWtIW5rVjcWSQfps8WNdsJzp6enAwkD/juPjmX3J1gF7qu8\n", + "IE1m2zi40esf7+ivZanq9bo+zwsih1U2zo3DyEvO6t0bbT/pgYV2u619yBYznuslCsV8TJJE//ZY\n", + "DHYfeIcSPORZ6uxKQFlvueUWefrpp0XEZ7TA4HjMpUhae0pkOGdwDfp1ampK68kZCby2xnhi2QgA\n", + "9zt16pT80z/9k4iMGKxxQbBYxzY3N9WFhHu/8sor6iL80Ic+JCLZ7nWsDfYgQhbQl7u7uy6ja9cO\n", + "lEPE12zKc+1YRhvAu8ELQQCbura2pmMQKWAeffTRYEzU63V1NXIQO9of42FxcVF1sNDevJ7hQML0\n", + "9LSu3Xivzc/Pa1nRZnzY4ciRI5lp0Rgeg5QV9D/pemLBHgJe49DGzCTbNa1YLOo1aDfODILfs4TB\n", + "pGETXqaOrPIDaGsea+NSiXmIjFRERERERERExAHxjmOkisViYBmzrxVoNBq6c+SYEGuN864bx0v5\n", + "iCpbf1bc8uLFi65KNIDgy/vuu0+ZKCCLobDBt2xReWKJ+P38/LxaSmxhgIny2Ax8NwlsAslyuRzI\n", + "GjBDlBeU6O3kNzc33WBJWI6w9Fi0kOtp63f8+HENePZiffLiW7zcbPwstLMX6+UpoRcKhVx2wDua\n", + "jH+bzabGjLACu23DLOsRbcpsYF7sDOYH54LE2P7Upz6lZYGl/PLLLweq3YPBIDjAgWfz7/gQA/fN\n", + "JHIUi4uL2of4PTNEWfnDLDwmpN/va+wRmIFJVNMBy6j1+/2AaXrllVdUNgBjvNvt6ho0KfuHteCb\n", + "3/ymtgPHGnqSLQDmzNbWVsB2iIwSHf/mb/6miAwDvD2GDvUcx4jYsd3pdHQsIAZmY2NDxxMYiddf\n", + "fz0z4DgLqAeX95577tFyslSHBR8SQh8hqJt/j7ioSqUif//3fy8iozgnbm9mUW3ANV+DentJv7vd\n", + "rq5jHNML9mw/cZM2RiprbbJyQL1ebyIBTf4e448V3HGgwrvH3t7exEyYlbdhcAC8nf/FYjEIkOd3\n", + "D48ZzHtuW9t+kzBTyX5PG70VSJJkood6L2YMylKp5KYXyUshk0dhHzlyRAc4TzSrzDzuGd7vQele\n", + "vnxZJxhraHjAyQ1+6VgXx4kTJ3Tiexojx44d0xfFuMBUu5HyNgf1ej31UhNJB0ly0CInW0bZ8cLm\n", + "jQ/agwc02gsLiud2u+OOO3Qj5bk/vczygHeazKPEJz0ByfcDspI0T4JKpaLtiw0LB1+yC41TiOA7\n", + "tCmrBWN84DM+HZuHm2++WdsSbuP19fXcRR3BvEtLS0Hg7n6AeqLP9/b2UmroIum1odVqBW3OrgT8\n", + "e/z4cTlz5oyIiGYB4IMqHKDswaauqFar8pnPfEZERhuzL3/5y/r7n/u5nxOR4Sk1lA+bEh53WDu8\n", + "00XFYlHnEta9breb0jDKwvLysrYbXJA8rn/1V39VRIYv+u985zvB9XgGwM9izaK8TAkw6ra3tydy\n", + "Ua2urganohuNho53XgtxOhKbtRMnTqgbFDhz5owe6slLQVYqlfTkIDZSX/ziF7WvMba9OhSLRU11\n", + "g2fs7OxoG3BwNX6XdzJ0ZmYm6DeR/A1GFrxk9AeFlwUiC3Avox71ej11EERkOCY4TEJkWEdreO8n\n", + "ibMH65Ifd+KPgfV8MBi4jR5dexERERERERERB8Q7zrXnJaNNkkR3ttjVZwWg5mlPgb5lsBoz3Gy8\n", + "ewcDBoug1WrpMzhBJaxFG0wukqYNoRIN+rPX67lB5rBosCtn9gD16Xa7LhMF62lSzR2REQvDrgIb\n", + "KOpJK5TL5dSRWpE0S4C6cVlgQe7s7Ghbcg5FWOawMDlgE5bt2bNn1TqEdc1jB25Xz/qcVIZgXPJL\n", + "7x6TyE+MA9PfuDcHm+Nf1vViKQiPSfGCX22C4kKhoH0DVuT8+fMptkZkOD9sH7VaLb0G9+P281hD\n", + "ZjBtEL6nTjwYDA4UIGst9wsXLuhnmN/b29s6RuGm40wJDBtUOz09rawdpAIYmB98AAXr1+rqqj6X\n", + "rW3MG/yOFaZhWTebzYmkLryMCgzIH2SNXcwvdg96Af6W9WBdItTx5ptvnoiR6vf7KSYf9/eYUNQN\n", + "LD6zUQhkf/bZZ936Wddot9vV0A+4Plk9n8sOl+hf/MVfaL0xvzAHqtVqwKIMBgN9nnf4gI/uTypl\n", + "kgeut9XKs39bsJQAw7LenlwB6zoCWeMQY5tzvXpz3TJXnDOQy+xpXk2S8JjL4CnEZyEyUhERERER\n", + "ERERB8Q7jpHK8rPDKrIxEvZ32NmCyTl06JCyNt5RXNxva2tLrWvsti9dupSKR7D3gxW6tbXlWkq4\n", + "D+/CEWzKGentTpnF3jzGhEXL7LM4R944eEHQk/qMmSmx9+A+RPv1ej2NtWDW0IrQifhyFgAzkWg3\n", + "r63wLBZf5YBsL2bAMmoH8cfnqQ97GBdvgHHljS/Ocu+1AWdK93I/2qDvfr8fMKFTU1OBGv9gMAik\n", + "Cbx4DR7X+L5Sqeh9uC+ZiRIZWrPjjm9Pgl6vF4jz9ft9jU1hZgr1BPPiKZHzAQTua7Sbx3ogtqxQ\n", + "KOi4xH23t7cD9omBeZ0kiV6D53oxfNVqVeck2IxqtRrMTRYgRvmYaQR2d3e1T5ghtL8bDAaBhAWP\n", + "a1x75cqVieK6zp8/r7FKgMdmLC4u6ueQHhARjUFCXBTHE3KMJtqA2Vl7AKVarepcYvFkj1njjBoi\n", + "w3eDtyZYrwYD7bixsTERGzIOvCaMi6vyZA3sOlwoFCZiytrttpsHz1vXUee8Nddjn7IOdeXdJ+9Q\n", + "FLOotux5eMdspLzK4bNut6sULCYkBr5Imp61SWu9gHSRUQA4Tz5MMNZispuSjY0NTWsCNeNCoeC6\n", + "2OBOwaL9/ve/Xx5++OHgd7wZwf3ygnnx+/X19cA9g+sPirxNmJeUmMvJ3/NCAmBA8iT0NlJ2geLT\n", + "WnARcEoX70WLPvz0pz8tf/7nf556fqfTCXSzvA1N1ibLngz13NF8DZCXeNnC2/TjBYTPWq2W/g4v\n", + "tkqlom0+Lq0MgJd1u90ONi/ctnmL06SnfJiu58B3uxH0xj+r2e8HVr2YgfXh5ptvVrcmymiDU3Ev\n", + "fM7GGhSy4V5iYDwvLy8Hm6WrV69qO3BQN9YvPIu179And955Z5DguN1u6+ljjO2rV6/q6S/eNFn0\n", + "ej01DjkAHhsVPLdQKOSevGSDxY7jtbU1XRvyQgF2dnZ048gbL3u/QqEgq6urIjJaj7l+eevZ8vJy\n", + "4IoTGbW5NwcYOMnH18F4wLq8tbUVbOA4VVjW+wnAGHszmQ4Y4+bpJPOLTwbzOGKVc5HhWuRls/AO\n", + "0vA1IsNxx3pkIul+8PT/eL3N63dvjWZj6yDvz+jai4iIiIiIiIg4IN42RmqSI5QcaG2tSnYbYLde\n", + "qVRcK9wyCEeOHFGLD1bewsKCS9Xane2ZM2cCK5Atas5BZHf3HkVYq9UCK9XbvZfLZd09w9Kcnp52\n", + "LctxAbnWEuSdPH9n6z7O7ceyEGAJmZHiQEILWHD1ej3IPZilI2I/L5VKyszAOoW2jC2/dS/wWPTY\n", + "oDymicF9Z8e3p0uVBe93KCvaqlQqaV9zO8PyRX37/b66rdH27PLifuOcWPid119gFdhqRH3ZqvSU\n", + "jTHeJ3UjA4VCQYPDwR5NQrvnaeOgfGtra8pm456eO1QkncdPZKiUjmu5rFYWpNVqKcvCTDKHDaAs\n", + "tnzePL/llluCtYivAThnJLMsHiPEechEhmw/2BpcOzU1ldt3PAesC50VsDFO+v1+cOiE3W5YS9gL\n", + "gTF09epVl9WxOl0nT57UduXcd3aera6uButPu90O3g0sBYMxyfME5WP3K8ZIlhq7B3aXvhUHWZht\n", + "sVpL/X7f1WSy7j7+nTcOPD1Ehsf02Wv4WtS7XC7r78ble7RMU6lUCtYBdveiHvtdk4DISEVERERE\n", + "REREHBBve4wUx0mIpEX3OC7KWsWeomm5XE4pgYsMd7awHCDCx1YcYho2NjaC3ejdd98tTz31VOp+\n", + "ngVYr9eDGKnFxcUgQHFjY0OZEFgpu7u7uUfD8dyrV69qWbMs5Ulhgyn5WLbHhHAguydW6AmdeYAV\n", + "4QV6428OzOTgdDAQiNfwghbn5+e1vaCQ/s///M/6PVvgeaySF1/BZbbMRrlc1rrlBZtnHaTwjtmi\n", + "bt6BgHHK4BhbKHOj0dA+53GK8cQHDcAIwCLMsoLzBDZxv83NzYDd88ZGpVIJ2CyOh2JmDWM/Kyej\n", + "RaPRCAJjPQHVtbU1vQ9ijGq1mltPMCMIMD979qzm2uSAcDwDbbm1taWxShAH/ru/+ztto7yYNo91\n", + "yWL0PfaKYwFxLX4HBpOZf7BBu7u7QZ8Vi0WdjwyP4fKYaawXmDONRkPbEvO7Xq9ru3ntYuNURUbS\n", + "MpyD9Fd+5VdEZNh+lqXi36HPX3nlFWVbOY7Sy6wAeQSwVTwObS5XkXwmqlKp6PWQ0mk2m7oGbmxs\n", + "TMRmj/P0ePfg4Gr0F8csop+sEroFxjGkZzqdjvYrr2fWM9Hv911BTnsAhT9jNtPuA3hvMI5p8uqC\n", + "NRzzfJL4tLdtI4XO5o0CgM70Tgbwi8pqgGxvb+tpDbxMtre3Nejb2wQheJlfGKdOnRKREdXOf3vu\n", + "P+5IvJymp6cDHZoPf/jD8sUvflFEfHcaA53IulSTbKCKxWJK/d2DDdTzkrPyhORTOJgk2KhMTU3p\n", + "5OSgedY4ArAwMi1rky1PTU1p3dHmFy5cUL0VLLSe9tDGxoaWD+CDA/xSz1ts8DtuA3Z12Wur1arW\n", + "Ke+EGW8YvOTK3iKH3588eTJIsM0nPvFymp+f1xcE7u3No1tvvVVfBAxcgz6YmZnRlz4OTTz11FPa\n", + "1/ZEl20DW6dSqaSfeTS9F1DKKUc85PXlysrKRBupJEn0hY0x9tBDD6lGEMMaTTs7Oxpsjrq0220N\n", + "gmaFbtTp9OnTIjJsS8xT7g+rL9RsNoMDHP/4j//o1tmeqN3b23P11NB36Id6vR5c6+nicdJdIMtt\n", + "7a1tVul7bW0tODSzvb3tbpawyUC7zM3N6ZrPqb8AzJWshMwoC05TX7lyRdvXrjkioicJT58+nUpn\n", + "JTLcEGIM8Sk0L9uF7cvZ2Vld3/GOKRaLWn7PTeZtmt5MppJxyuHeZsQ7KOGlP+K115vH3meoCxMN\n", + "3qEVrx6AZzzz+8zqV/FBgP1o1kXXXkRERERERETEAfG2uva8Y4bT09Pu7tsGxu7s7ASMy+rqqu6G\n", + "J01q+uEPf1hERB599FH97KMf/aiIiPzJn/yJfublXANztbW1FSj4eqriTz/9dGDxszsFu/K5ublc\n", + "1wnqPTU1FVjbS0tLustmKjkviNxzBdTrdTdJMixCWGOzs7NBAK29xpabd/q4H5ijBx54QK1Hvgcs\n", + "OHbxgWkEQ7C3txe4AXgcsEVlxxhbd5yjDshTQ/dclF69WS2etYNs3j+RdNCtSNrKgxtCZMT8gZlq\n", + "NpsBW8RHxDEmmP2ARX/hwgUtHzMDf/M3f5OqT71eD47nc5+iTEmS6Odov/0Ec1qLMCv34Z133hl8\n", + "xgH5Njemt77U63VtQzDXp0+fVnaXmWjbx1NTU9quzPyAUWFGygbLHzt2zJ0rP/VTPyUiIu9973tF\n", + "RORrX/uajhm0edbRecwBsOOcFNhzUfM8B3ti8+sxVlZWgnl27NixlJSMyHCttusTtzMwGAx0fKIt\n", + "XnjhhRQTJTLMr4n7YRwxG+wpV3sSFox7771XREYZLjjXYB6z8vjjj+tn6EuPkavX64EW2ezsbCoY\n", + "XSTtbUB/eAeRfhxg7wHa0gvcZqbezmeeH5h7rVYrYJ+zgGv48IqVSWD3J2ezwGcYu8ViMQho58M1\n", + "vO/IW5fw/ElcqrmMVJIktSRJvpskyZNJkjyXJMn/+sbnC0mSfD1JkheSJHk4SZI5uubfJUnywyRJ\n", + "ziZJ8vGxJYiIiIiIiIiIeJcil5EaDAa7SZI8OBgMdpIkKYnIPyZJ8oCI/Bci8vXBYPC/J0nyP4rI\n", + "74rI7yZJclpEfkNETovIcRH5RpIkdwwGA3dLV6/XA6uq1WoFfl4WOmOLFFbMuXPnRGS4m/biV7xg\n", + "RVgRzER9+tOfFpERE8Xqv2xZIb4BljBnegfm5+d1l37XXXeJyNBPj90wLL7d3d3giHOz2Qys3hMn\n", + "TqjFByvGq1ev13MtVQ4etJabx6JwoG2er5jjB5jZ8srgxUtYq3Nubs4NfAdLwCwRYhjYOsRzf/Zn\n", + "f1ZExM1mX61Wg5gRL0A2S+QUFhLn57Lf8X04Nx7+xjg+fPhwEJBp/7bgnJA2houfB/T7fWWgMHbe\n", + "//73yxNPPCEiI1HaJEnc5yJWDcwfC+jh39nZ2SBout/va7kw3+bm5lLsmciwHcHGgXlcX18P2Lad\n", + "nZ0gm/zW1pY8//zzQZlRFrZOgaNHj6Zi5/B7a/2/9NJL2l4cUGzXmH6/r+wF7jE1NaXtyrE+GMdo\n", + "+0ajEeQyFBkxJD/4wQ/0MzCwXlwpA+MS6xTX1YsfQZzia6+9pu2KGCgvfvKHP/xhICJcq9VUzBPj\n", + "eXZ2NmDmt7e3dUxw3AzKjLWc2xl98MorrwRjO0kSN7cjgvofeeQRERmOO3gQEEt1+fJlueWWW0RE\n", + "VLSXgcNCvM4yuwhgLmflhgMrhnbudDp6TxaCxDsBbcHr9E033RR4KbLiobygfythIBLKvHAMkvcc\n", + "zqHIrDOA78cdhkF/ssq/d0gM643H2LLoKzDuufuVNthPRoWxrr3BYICdS0VEiiKyJsON1Iff+Pz/\n", + "EZFvyXAz9WkR+Y+DwaAjIq8kSXJORH5aRNxIPzsZ33ieLrpoyHK5HLz8Dx06FAws1v9gxWcbHMoB\n", + "r8CxY8d0EgPtdjug9mu1mnzwgx8UkXRyTMCqHouMqNrp6WkdRPwyzKMOvaSWPGBAieIeWYurN4g4\n", + "6a89OZg16FAOViAGxgU6om1Qfs9V881vflNpbh4f3skJm16hWCxqX3suIGBpaUlfcvbAwkHAiwlv\n", + "uPg0lH0G2urKlSu6UeHTbgDmAo8TjMVerxe48crlsr5wOQifKW6R4eKFIHKMGd7U4kV+7tw5bVO0\n", + "d7Va1Rekp1wPir3f7+vGAmXmccVzGn+jrVZWVnQDwOPKzvlCoeCuI9ikeYvh9PS0vlRxIMRzxa+v\n", + "rwdrB58mxPxpNBrBIZRWq6UbPLRzo9GQJ598UkSGrjqR4clgz42PjS8HdWP8YE0aB5RveXnZDRq3\n", + "Cb5fe+214GVUKBQC1+jOzk6w6Tx37lwqibPIsP0wZlg7DPeBi3p3dzdYe0+fPq0bTIwrb05vbm4G\n", + "oQmrq6vBRnlra0seeOABERF57rnnRGTo+vzLv/zL4J6YN3B5v/766+4hI6tPuLKyomscNlzXrl3T\n", + "zRrKxP1tE2DzZ4xms5kbuA94AdRZQeR57x12a3lJlyd1OaJeKPve3p72I6d9w9ieVGPL0z7jtSUv\n", + "BRhrTLHu47jf52FssHmSJIUkSZ4Ukcsi8shgMHhWRFYGgwEcv5dFZOWNv4+JCDvKL8iQmYqIiIiI\n", + "iIiI+DeHSRipvojckyTJIRH5+yRJHjTfD5IkyaMi3O9OnDjh7rxFRrth7Do9S6RSqejulbWNsMNk\n", + "VXSLQqEQuMVee+01ZbRw7cmTJwNL6aGHHtIcS8yAQaMKx6BhlYmMGJgkSQIJA89SYBVbfgaCR2Ft\n", + "93o9173k7dABtqhZn8MG/mfRmjgC7x1NZgvHWmteeXZ2dgK3EbcHrl1YWHCPb9u+qVarOlb4aLI9\n", + "asxB3Wx1YLx5cgGsE2XZK7aouA1gxfLBAnzP1DTqjvyPhw8fVpbIS9TK/cv5/vBZ1rxiXLx4UdkO\n", + "3G92dlbnBRiRBx98UO8HF+ru7m4gTdDtdoMg/aWlJZ0HuN/m5qaygB4biP5/7bXX1LWC+b25uan1\n", + "tUxcFjyGlvNlos1tQLDIkC20bFe32w3kRdg16VnF7OIHI4UxtrW1pesYjuC/9NJL8rd/+7epZ+A5\n", + "IvlaZRwCgHvceeedLiMFgJVbXV3VscgB6FYlutfruWwGWApmcjB20E9zc3M6pjHWjh49qp/BJffq\n", + "q69qGbz8hVg3dnd3dc4fO3ZM72vXs263K5///OdTn6GcjI9//OPyqU99SkREfud3fkdE0sHYfNjF\n", + "5mS8fPmyPPTQQ/o9/rUyOCIi9913n4ik55RdVzhp9vr6ustE5o3/cXPDBnP3+33trzx3WrVadTN5\n", + "eEr+HnPluRTBXLGepPf+8tyWNsefx6J512a94zw1/nGYWP5gMBhsiMj/JyIfEJHLSZIceaNwR0UE\n", + "s/SiiLCQz4k3PguwsbGR636JiIiIiIiIiHi78bnPfS73+yRvt5UkyWER6Q4Gg/UkSaZE5O9F5PdE\n", + "5BMicn0wGPxvSZL8rojMDQYDBJv/BxnGRR0XkW+IyO0D85AkSQZZRztrtVoQz8Hw4jS83Gg2lxqu\n", + "EUlbwAhYX1tb06Ow3/rWt4LnInDzxo0bgR/31KlTwWfMJCBmZVJF8qmpqaANWD07DzaQ1ubTy2p3\n", + "K8Fw6NAhlw0BIFvAli6zSx4jBQuI/eUIUIUVwAwC+nVpaUktMy8AlH/vWaLWwshiuCz4kAO3n2V8\n", + "mMnBGNvd3c31rXOwtmd5of1wv0KhoGOZA1TRl7hfqVRKBYWiDTzkMZceYI3//+19a4xkx3Xeqe6e\n", + "fs70PHZmX7O7XJJLLbWk6CUpiYQlRqEt0RIMWwoMWBEQQBCMOICTKH8CJArsKL+cwIAC/csfOYDk\n", + "JJSlBJYtBNaDBiWFMrQUJVJ8L2UuH7s7uzszO+/pme7p7psfvd/p71advtM7ojmmXR9AzLL79r1V\n", + "p07VrfPVeWxubmY6Ylr3Rdbpubm5wMLjGonom++bNAyszMdsKQPValXbCD322U2Rnr5Crrxm+FUH\n", + "dnZ2UoEieC4Af3LSvGAAACAASURBVKx7771XHn300dQz7rzzTl0fINNz584FzyoUCtpWMCmDkkz6\n", + "YP3MQrlc1nGA/JaWlrQv1jrG6wsHHoj0GGd/zTp58qQydNYYg31aXl4OMmAXCgVld62UB7v5O2Ic\n", + "8Pcb3/hGcM2HPvQhrYbAbcd7B395vb/rrrtEpH8aIRIyTj5wH2ZWfXmMjo6m/KnQd3zGMud3oMUW\n", + "+gzSzThS++DnAoPYLzCMYIDZHw5Eym7pBbKc5znJMVdj8DOlD2LYIH+LzfKTJd84tTAX9d2O9o6I\n", + "yJedcznpsVd/kiTJXznnnhaRrznnfkdEXheR377R0Redc18TkRdFpC0iv+dvogDkifA7WCgUMh3Z\n", + "0GF2DmXq2crmDGHxBMcEhFNgtVo1N1CYEHjxWs5w8/PzuunAxoBhHRWhzZwNF+3joz381tpE1Wo1\n", + "VSjcgzdRFhVcKpVUvuxEinGwojH836PPPjAhuJguw1JmLB5wyFxYWEg5OvN9RdIbKX8D3e129Xte\n", + "lPxJvrS0FCy6rDtAsVhUWfmT1eq3iD1OVsQMt9l35uUSB5y53HfW73Q6gQxarZa58OAzjorBb3/l\n", + "V35Fn4+SSNC/S5cu6b15Y+2XT7AiDvm41M+EzfdoNBqBw7WVAV0kjCAcBC6w6m+kG42GyoM3GBgH\n", + "Puq0jAm0B2vQwYMH9bc4yuT+YgO0tbUV6PbLL78sn/nMZ0TEPobEs06cOKEbmZ///OeZffextrYW\n", + "ROhdvXo1eIHxMR5nO+doTZHBmeEhZ8iMj8SwLs7Pz6cilkXSGx/oQbfbTZVHwWfYgFj6hPuMj4/r\n", + "b7Bpunz5sh6x8RzGnMLfy5cvm3M4a5PG0ZlwddjNadrXbUufNzY2UoSAFZU2bJ6m3Y6zBsE5F5SG\n", + "abVaqbIyIj35YQ5AVhxBbuk2roNOikiqQDZXscCzfOOQN9IwAtrtdrBOc1AKl6vKCjLyC3hnYbf0\n", + "B8+JyH3G50si8uEBv/lDEfnDXZ8cEREREREREfEOx75mNrcyV7NlytY2O5yKpOk77D6LxWIqmzPu\n", + "i10n74r90Mbt7W3T6gANDWfZ6elppbbZORSA1bi0tBSEg1vh73z0hN04HykxYI2DpWo0GsExCecl\n", + "4pBdqw2Q+fLyst4H1w3jsCzSsyr8+nHVanWoowSRPkvADCNkyPnB/OtFQouh3W6bDoJZjsBZ4GKa\n", + "0FUrj5B1fCgS6vTIyEiQrmJtbS11dOG3E7DCn7vdbnDMxOHgbEmCRreONOGUbGFqakpZFKS+uHbt\n", + "mhkmj/kD+bCugSnM5/OqlxyEgSMA6DZblOzgC8sdljoX2mXw2mIFNFisnX+cXigUNLM4nMRFJLBs\n", + "FxcXdS3A/GHGBGH87XY7YCo4y3VWNvHt7W2dF3ykZ+kdwGwG+glZOucCVoedyDFenK0ccrR0KEkS\n", + "fQaO53hOMysLNhtrej6fN6sJYLz4SJHzW4n0xshfq3Z2dtTxHAzRgQMHVLdwCnHPPffIs88+KyL9\n", + "9W5paUnuu+8+fZ5Ib/wgS8s9g+vlAZDbbqknLMYT+nXw4MGU/K36pZYeW9dYcwQytLLd8zqa5XiO\n", + "65rNpt4H485sMFgndtLHWFu5uQb11WJCrdMC6BOe32w2bzpL/M3knYq19iIiIiIiIiIi9oh9Y6R8\n", + "Rzpr14tdNCfkZH8S3y+h0WikUiGI9CxW7HxxHYeNw9LodDpBFOEv//IvaxZcKykcmKiRkRG1YthR\n", + "FL4RVjI37Oh3dnZ0Vw+rfHNz07QwsaOGXNhxHLIY5NAOa4mtI8sPirP0Wgydz2w1m80gozGHZ1ss\n", + "C1ffhjUBGY2OjgZV3Nl5nS16q05SluXF13GtJpG0jxS3z9dL9pviKvZ+Fm6RMHkkn/sDtVotlawQ\n", + "7c2qhs5hyH7CS5G+lchMHsYfn7F1hvFbWVkJ5Le0tCRPPvlkIAMre7rPDLAvjeWLxPUEwRZDjrVa\n", + "TX8LmY2OjgZZ0X34PkgifXmApbh48WKm3wMnPsWc9NcVtFGkp59oD9IpjI2NBQzIlStXggzOjUZD\n", + "1xEkxrScw51zmg2dgftY896SUVYWbq7kYNVBhb6PjY2ZCUzRN4uRwvhWKhUzrQ3G3ZIz+sZzFNfl\n", + "crlA7zhhKGqpWhUOeC4ys+PLeXR0VE6cOCEiNnvCrDqSjGKdmp+fV7mhj+yjC9RqtcAxutlsqo5t\n", + "bm4G/jyDfIx9Vt5y0mY/TGbErd/47BAcr/m33W7XjMLHM8CsFYtFHTt8V61WdX1Cup9ms5kKGOG/\n", + "DE7dg3cNr9vDpgXiIBXfp3WY05l920ihsX72Z5FwMu3s7KSiOfx7ZG3I2PkWi87ly5dTJVP4WSJ9\n", + "Kvmpp57SdmEicTkH3O/QoUOpDRTAznk+OM+Vv2FhhUQ7x8fHA0p9e3s7taCI9AafnX0BnhiQOR+t\n", + "WHm30D/evPgL7Pj4eKBofA2X6sDE4cy7/oax1WrpePLRGG9asmA5GQ5D0VqFLK3jP74/t8kvoC3S\n", + "33TyYuNT8IPKGnABaDwL94G8rbYMip7JOmqFXk1OTuoRFeexwiIHfVpaWgqihfhYCG0YJHe/MDKD\n", + "N+g+sgp5A77cRPpHRHgubxgA3vgA+XxegzesgALOMYVNA0db4nl4Ph9/wMiamZlRncDmz5Jbo9Ew\n", + "Ny+cEXsYwJBiOXGhYoy7dXyHY7V6vW7qO8DrhV8ZYmtrS59n6S/rhB8lyCWRWJ/9zQsDmyJLn958\n", + "803deKN9lowfeuihVKmeQWg0GvqewgZ8YWFB1zH00dpwbG9vB1ngFxYWdO7VarVgvgwytvwcb9bc\n", + "tNYJS+9yuZwpO3+zwZF8WCcKhUKQObzVagVr+Pr6ujn3shzpef3hQBsAbeAM7X5xeG6fVX3iLc1s\n", + "HhERERERERERYWPfGClYabDM2KnO37EyG2OFkDM4zFakt+vEjpKdK/3wcpH+7hW7Yw7BtQqLwkKw\n", + "MtdOT0+rZYFn8ZEI/nJWbO6bb41xO2G58O6ZrRX0Y1D9JlgssPAHOSpa1q5vFVUqlSB0l9uFfnJG\n", + "Y4bvLMljD/k550x61WcVrb7kcrngMz4Stahsv23+My2HdusoxGfHisVi6lhWpGedWmHo6NNuWXV9\n", + "ZqBarQaZqDc3NwMLMpfLBSzf8vKy/OQnPwn6y+Mgsre6hJiXa2trQ/8erAkfzVppEnj84Txsgetl\n", + "+qjX64FV3Gq11EkWz+W2Q/aHDx9OHeWgregzB81g7uFZMzMzqaAPkZ6e+KyFxcZxmpRhc4JZKSAs\n", + "BhvrnnVkY7EZR48e1bWB1wOr7pvl9OuH04uEx5XlctlkVjGeYL9WV1cz0wqwrHA/iyXCUfDPfvaz\n", + "VIWJQahWq/qe4uMmvw3sIM2Mrn8dZxC3+s0nCRwosVtGc8A/cuQ8bFgTBumTVX9vWOdsPzM/r3+c\n", + "OiFrnWBd9ddPfufz+8Rnx3ZjzIdJe6C/GfrKiIiIiIiIiIiIFPY1/cHU1FSm8x4sjdXV1ZQPkEiP\n", + "CfEZg1tuuUVDtAHLp4adOdmZD+G9sP7a7bbpsGllh/X9nJIkCVgUqy3tdlvP+DkZnW+NVatVvR+u\n", + "4wRwXGUbVi9bOPxsy6HUZz6cc+YZfJaPEjud+35ufs0ykbRVY2Wi383CgWWTlVTTQrVaDaxiZgbR\n", + "VsuHp1qtahvZJ8CyXnz/kFarFbCB+D0jSRK1mtlvAuMBOa+vrwc6xvfi8RvWSvVhWbgjIyM6vlxj\n", + "EM+zKsezzw365NdhE0n7R1ry91NKMPMjMlxdLMu/p9PpBHX3ms2mjjESOzJjBx06ePCgMhqcLBXy\n", + "gE9is9nUNQbXXbx4UfXEZ6sZ4+PjQRg96xzSGuxWPYF90NAuyJzvj/nYbrcDtoYTAQNzc3Op+qIi\n", + "PT1AP5mRQn/ZJ9R/BqcNwG+np6cDXdzc3NR3iBUybwHj3G639RmsN9DfLBbKcvTO5/MqN/6tny2e\n", + "ZYr3T71e1xMTngNZrEySJIGuWHUY2UeKx4HZySz4Y81BQr5flEg6SSjGBH3nNRryYzn6AVWDwKc8\n", + "kDnuMyjNgX9PdixnOd8MEwXs60aKX7gYiEajYeaUgtMdjofa7XagyHw8yA6NcACE0q2tranC8aYN\n", + "ixAXxPQ3SOzcxm3zF4xut5s5CdBvLvZq0fdYdKw8S1wwGIvDG2+8YSoSTzjrGM2XZalUCl7SfqQl\n", + "rgOy+rubkzhnevczJFvgMjrcFiwKTM/6L9esCFERO0IT+mKNUZIkpsz9o6Tt7W2VA+uV9fJHG3GP\n", + "SqWiG0t+4fkRkzeTuRhy5ogVtIVLLPgLLWfC9x3q/X/je7zor169muk0Dp2bnJzUucnHGpyTC8/i\n", + "TZqV+XzYYqXQXx4vzDvMOQbGfGVlRZ2L0WYuo8PRbljbsF40Gg39DcbaerENmj9oA9YTC7tFgeJF\n", + "xGsMnOyTJAnKQS0uLpqFhPEMqzwUwMYb+rmbAYQ18MKFC5n3HvbIGMewnU4nCKSo1+tamD0L1vqz\n", + "vr5ujgN00gomglHGBiR0id1JpqamhnJ65jZxFJuf94kd94F8Pq/rEjtwWwatX3ImSRJzDLOCRyxk\n", + "HatZAUHsvI4+Tk9Pa5vZfcU/yt7tneSvj5nt3vWKiIiIiIiIiIgIE/vKSOXzebXQEHZ76NAh00HQ\n", + "3xXv7OwENfSY1sZx2fz8fBDSWi6XdUdr5dNhC9ffSfNOGVbx1NSUmffFLx6bz+eDdAvlcjlVEBdt\n", + "gmUAWbCjOu/MYRnykSYsDes4jfvEx2m+pddut4cq7DsoxwY+5wzUgGVZwHIolUqmVec7VSZJEowN\n", + "U9B+wVOGZR1xNnm2rPy0ApaDeS6Xy2SCLLYKbTh27Fhm1nGAw8aZwcRv2HrC95AjF7yGnIvFYpCb\n", + "rdPppJzgRXZnuLhvFluA78ECfPCDH9Q2wDHcsj6t3GsMZj8s3bKyekMe1Wo10IHl5WX9nvsE2Vhj\n", + "yEe3WIPgnH7p0qWUIzGuR1+5SPhuR8kig+eZzwxa+K3f+i356le/GnyOPmF95DlguTTwHPTHzAom\n", + "sbJ6VyqVwHUjSZJUjiWRdE0+Xtcx1jgSK5fLZsoCf70Q6csc86NUKulneF+g1iSDTyF2c0S2WJn3\n", + "v//9IiLy/e9/P3VP/ttut9W5HUzU5OSkzoOlpSUz8z36wvpk5VDywTLnzODWfMe9rVp7e3UZ4Lbz\n", + "6UcW+9XpdPQ3vuM492O3422Ag3+4xqwViLYbIiMVEREREREREbFH7BsjlcvlZHp6OrBi4OjJuP/+\n", + "+9XJk5OvYXfKO1BYcJYTe1Y9vyRJhmJgRPpn3vBLeuWVV/Q7WLXMqsGSsEJY2W/GqkoOy7nVaulz\n", + "2crDPZmNYUc8C9i5z87OikgvfYPFSAFs7fifcVvAjm1ubgbh2Nw3zljvJ13b2toamHaA28CV6mFN\n", + "MDPB12elWADY14urjaNd+KxararVDIuFgxestmP8p6am1MKEPNivjwH5giVdWFgIWJHJyUnVZYw5\n", + "+4ll1ZZqt9tBMrp8Ph+wweVyWb8ftsI82Jlut6u/QZueeOIJvZ6d0v1+O+cC1ujUqVPKXKOd/lhC\n", + "vnfffbeI9OY61gL2c+P6fSK9ecb1wAA/LJ/ZCQ4fx/hj3lYqFWVccA/2VYI8ODOzBTyrUCiYaTL8\n", + "6g4Wrl27Jh//+MdFROTP//zP9XO/vman0wmscA5oYfhjMyhBJ+6NdZvX5TNnzoiIyPnz5/V+YJqc\n", + "c4H+VioVlS/W6s3NTZ1zzAD6zEq5XA7W4W63q2PN7x32c+W/3J9Bfn6QHypd/PSnP5VvfvObItJ/\n", + "/0xPT+t1YCELhUKwXi8vL+safeXKlYAl5NpzFpOD/nKgEvfdH+t8Pm8mPt7NlwhghhHP8NPL8GdW\n", + "2zn9gcV6ZbFs0A1OG8HvVp9VbLfbqjuDEiOLDOcjtW8bqW63a26aJiYmtFNI7//YY4/p95y9lhco\n", + "kd5gWY6afjSOSHhkc+zYsYEvNR9YNLCB4qMoP4OsiJ1jCKhUKsFm8s477wxyUxUKhWAiHT9+XCM9\n", + "rMlubXxarVaqwK1IT37WcRdvjPBbwCoKy/3cbcER6cnIP07lzQHDipDxj075mmGUX6S/UWG9wmTe\n", + "2NgIHDKPHDkSvFh4E2s913IoBYrFor7U8Xd5eVk3DGjXxMSEvli4LAxHnYqk8wNx2/EZxso5F2ya\n", + "ssoScT/5+JC/t6JwAKvc0Hve8x5tu1+gulqtqtMt2sllX/hYzZI5XthnzpzRf2Oz0el0NIM7lwPB\n", + "dfwihV5CzsePH9djdBhwp0+fVuds9G99fV3XHSBJEp1z/BLL2vByDi3ML2uucqFl/2Xz+OOPy+c+\n", + "9zkREXn66adFJO3IjLbMzs4GxuTS0lKw6cRzGCsrK0H08fz8vF5nGbZAvV7XPvELDTLnjP7QCW4n\n", + "NhuIlOM8cdjUr62tBQXIOfoM4NIpjGEjAn0j5uzZs1rwmqOtYYCiv2NjY4GeNhqNVCF7/2VfLBZT\n", + "2fpF0sEhWetOpVLRdwZkPygHlZ/hO5fLBYW7t7e3b7ooMMAG625O6X6hen7vcdReVl5A3zhmsKE0\n", + "TEFo/d2uV0RERERERERERJhww+y23vKHOpeIpMPpwQysrq4qJckW0Ic//GER6bNT4+PjugO2drG4\n", + "R7PZDKhJdoyENXP58mUtGorwV6s4K34v0rc6RkZGBu76RfpWkcXAHTp0KAhd5yMAn3EQ6TM/J06c\n", + "CCy9SqWSyiPlF7oVkSCcmS04foZPcXc6nSDfk3MulXMGf7OOz3Bdp9PR/Dxg4Lh2H2RgWYkWI8W6\n", + "nBUmzXrH1h/3Hf32mcu77rpLXnjhhYF94xwp1pGj76xq1X0T6R+FYNxZv/xxERF597vfLSI9OfrO\n", + "1UxrM6z8VT5yuVxQh9G6rlwu67hauVkAyyl5YmJC28d5mADO1O/PMz5q5RBn4MiRI8oW4eiuXq/L\n", + "+fPnRcTOX2YBDFi9XldGCkc1uVxOv4deXb9+XdcTzhWEOZfF0IyMjATH1t1u1zx+uP3220WkL+tB\n", + "rDru87u/+7siIvKlL30pONqZnZ1VBhRrxJUrV8w5AvD6ghQRfjoHxuHDh+Vd73qXiIj84Ac/EJEe\n", + "y+enHMjn86l8TyJ22o9CoaCfszsE2myx25DF6Oio6qLFxHAKENybZeAfZY2MjATP+/SnPy1f+cpX\n", + "UteJiMoAaz+7p0BvRkZGtKA19xnO9cOy7uVyWfUT/XjjjTeCIu2sd1ynz2c4rTWLs7VDLq1WKzON\n", + "QVZVCX7/WAw37lGpVFKMGu7nF0YfdHTnz7NB6WiwtiRJYgo9MlIREREREREREXvEvqY/4N0qdubl\n", + "cjmwWD/60Y/Kt771LRHp+3gMSnjpJ+RjBz5YpFeuXNHruP6eb3G1Wi2TQfDrlq2vr2f6pfghwD78\n", + "Hf/U1JRaDmy5cmZcfOeHg25tbWWGbVYqlcwMycC73vUuZYnYSd93iBwbGwuc6EdHR5W9QEjv3Nyc\n", + "WiqcZsD301ldXQ3SWvD9fYZIJG0RMos1CJz9F2NeKpVSMuS+oF0ig5OEwqJhywdtBbt0/fr1wLpi\n", + "HQY7OjMzo4wJxpqtdst6fvHFF/XfYEA46zjAejoMG83zjC1J3zeDZca12zCGYHws+a2srKi++ykD\n", + "RPoW6ejoaDDP/Dnr+2KBjRKx5yHax8w11onV1VW9P9gV6AO3td1u6+fox/Xr15U5wHhUq9WBTtmM\n", + "yclJ7R/kOoh98NngQYA8Hn/8cRERefDBB/XfwMbGRsDyWnX/BoF9xkRsNnhtbU2ZKMBKIpnP55VV\n", + "Yt84yNwKDOL6mX5gUa1W07kJ2TabTXMu+ckmB8kWz8vyXfvud7+rbDHPUcxlnpsYS2bneL0bJhiq\n", + "UCjoOstJK3ke+MB1PA7sJ4R3JeRmBU2xb95uvlJZQSvsj8VBSSI9XYSMOYG3VUsV7xCrrRgv9m3l\n", + "Nt+MbxSwrxspnqDHjh0TkTQ1jRcQNlEifdrz+eefT22MRGyHvKmpKaWr+Tv/BT4xMRHkI7GymE9P\n", + "T+vz+DurxAoX7BXpLcb+xmxxcTFYDK0jQI5wZCXHv/FbzgWDl4RIWE6FwXmGrMWD/+1PEquQKCso\n", + "57fBosXPgiw57wtT6iJp2VrKbWWgxT2YcgZWV1dT0Z8iPbmA/uZNgf9b3njz860gA9yH78dRXSLp\n", + "jQXubT3j4sWLehwA+fEmG99Z0T2DMAzFzrA2ZJyJHL9Hn5Ik0XmGZx09elSPjdCPF198MdgwlEql\n", + "IMpqeXk588hWxNZv/3h8dXXVNKTw8sUL69ChQ0GxcitnUaPRUD0+deqUfo55g+cXCoXgqH2QPvsF\n", + "zy3kcjm9d1YVAMbzzz8vImLmJBoZGdE1A47bpVIpZQwNAgfrQBa83vJ8Q98RTPS9731PbrnlFhHp\n", + "58Nrt9u6geIqEH7ZHc6oDZ0YGxtLBY+I2EERlgO5cy4w1nK5XOZmMmtjMDc3p3r10Y9+VER6myvL\n", + "2EW7EORz/fp1bQMfYQO1Wi0wGBuNRmaAD2SZz+e1DVbJM4DnMMOPSO12u4ELwF7gZ2Dnf1vtsyIN\n", + "2fEd39VqtSCjuXW/SqUSrIfDFGOOR3sREREREREREXvEvjJSIn3WhKlHWJ2+VSHSt6j834j02CdY\n", + "mLDU+B5WQUeE0+5Wfw3Wy+Li4lBFDZMkCZzS/XuK9Kxga8fvF7zd3t7WnbmVDwuOmYVCQWXATBHu\n", + "x8cbYG3YcrRYB8uaG9QfkfQOHhY8Z+kFxsbGtO98JIfncv/8TMVWfa5B2dN9dLvd4KiEnRsZsAJZ\n", + "5v7YsBO+laMM1tv09LQef4D1yOVyeu9bb71VRNLpAJiB4XxlIj3rCb/l7+CUytmCOeSb5cDI5/NB\n", + "PSp8jn4CHG4v0mN5/PsxG4j7zs3NBczG9PS0Xgd9aTabJruEduG51Wo10+k2l8upFc45nMAc8dzz\n", + "mQ3rKJBlwPMLLCBnrAdDw06znN5BZLATrN8Wi5mq1+uqixaLnQVrfuzs7GhKih/+8IfanzvuuENE\n", + "shmpJElSgTsi6TnKlQsgI+QGnJqaChz42+22rjsY662trVTuLpHeHDx58qSI9BlaZmStfkLXeK5i\n", + "nnU6nYAlLBQK5vwBOEUFvucgGugYn6xYQH9xOsPs52233aYpUQBOdWJV3ECf+AiTmTCficrlcgHT\n", + "xHOQs+xbwUnoOwdIWEw94OcaFOnL16p+4ZwzA198BozTs6Bv1hEfp55BP6138TCIjFRERERERERE\n", + "xB6xb4wU6jDBwsDuOZ/Pq6XAPhw4N+YwUd8Zme/Hlh52sbzD91MdWNXM2aLKYqGsbMe8A89KMsY7\n", + "YIQPVyqVwMI8ceKEOiuyw6pfC2zQjho7c2ZFgLGxscCvZnl5WZkNDhH2rf+skGhuD/trAdvb24HP\n", + "C59lMyz2xA/f5VpMkDnXNwSmpqYCNnNmZiYzczD0Y2NjQ//NDBsYQb6vn9Xb97fBNdBfrvNlsY7Q\n", + "WXbchoUJvyPnnMlO+EEJhUIh8HMSCf0BrNQT7NRvZSWG7FkPsnx9WB/ZSsVceu973ysiPYv4xz/+\n", + "sYj0fT1arVamFTk7O6u6xekoICN+nu+34pzT5+A7nsuw3tmHBkzjyZMndezwt9vtZjIbALO+lvM9\n", + "UK/XU87vNwOet8ywok/MAEO+Vi1S4PLly8rCANxmyODo0aPKbPF8y0pDwTUhITfMvWKxmClLzNX1\n", + "9fVAhhw0wffwWXfLz5LB10OWrJNZbCF0cmZmRucBO5uDOX3++eeDQB8rYITZs93qZPp15trtdrCe\n", + "M0uN79gvidks32ndYopZlrx2+OzUoBQEPvs0MjISsI5bW1tBG6rVasD+7uzs6HvTYqyAQRVCGPu2\n", + "kfLzxVgRRvxvfxJUq1XtPNOy/nUHDhwI8hKNj4+rssLp1HIi7XQ6OkhYsJaXl1NUrsjgFwYWpawC\n", + "rKyA2LDkcrkggogjPjjT8L333isiIufOndPvT5w4ISKSooL5pQSKGc+1NhHXr1/XY08eB39TWC6X\n", + "9d64R7lc1hc76HZr89dsNnWDxUcZ1hGsv2niYzjLMR5/i8ViMEmnp6eDl4FF6fMmgieh/8I9fPiw\n", + "eewBB1vc99q1a9o39Js3k7jv9va2LlrYXC8tLanOoj+nT5+Wn//85yKSPoZC1BSubzabgWNtVkkE\n", + "hmVADMpcnmUw3H///SLSe6EiIhE4efKkjg2Ow8rlssqNdRvAizmfz+sL3sLa2poeSXAEYZZDvn90\n", + "K9LfRLRaLX02FmGuRAA9OHPmTJALbGNjw9RfHyzHLAOuUqmo3LKOshlok0jf7YE369ioYoxPnjyp\n", + "G4HdnG45L51ITz6+LDkrNtY451wwHrOzs3pEiOeOj48H85sL6DL4nZAF/yh72Fx0FiYnJ3UcYFBZ\n", + "hZtFRDPrQ1YXLlxQp37OHQUXlWHbYblm8IbG0qesecvvQJaHL1dLN3jN57Jbvszb7Xbw+3K5rM+1\n", + "jPWsXHWlUknXO+wRNjc3VZZ4r73xxhuZGyhgGLnHo72IiIiIiIiIiD1iXxmp8fFxk5b3LYGJiYkU\n", + "lSuS3mVbdLmfBVakT2EePnxYn2s9n8NPsfPFddVqNZWvRCTtaIffrqysKCOUZRV1u10tcIn+vvTS\n", + "S/o9HxV97GMfExGRv/zLv9TPfAfkWq2mz2UWApYIMiEzWJbo78TERODcyLlCcO+dnZ2gf/V6XVkz\n", + "bpefwV2kbzGALdjc3Mysa5XlPGqh1WoFR8AWVbu8vBwUfi0Wi8oSscXspycoFApmRmk/WIJz2bBe\n", + "4jP0m1lKPvZivRTpFXsFw4BxWVxcVMaHHUetOl34HnJhtsA6IgeszPvVajVwLN7Z2dGxgWOxiARp\n", + "SziNA8ag1WoNFXbs5yLzHZ6TJEk5OoukjxestCu4jvUdunv48GFlCdHul19+WfuEZ/G4gYXc2trS\n", + "/mXl2hn2yGtmZkbHcNgs19BJ1nWMJRffBhYXF81KCFb6BMgI8jt06FAQin/58uVgvs7Ozgbz58qV\n", + "K6rvGAMegPCbHgAAIABJREFU50ceeURERL7zne/obzEGCwsLwbgNgl+v9ciRI3oEz0yEz2rzmo+/\n", + "o6OjwXtnfn5e74219+WXX1b5c/CUz65MT0+njvt9FItFnX9oa6vV0rmLtg5iNdEGdofAv9FmPhLN\n", + "Oiq0UgXx9XwU6F9nyXK3XFRZ71QrUCWXy+lahr/OOZUBH4da7jm7ITJSERERERERERF7xL6mP2B2\n", + "BztIK/EY/z92kCsrK6kaXCK93bPlEOnXJkOoLX/X6XTMhGJc/06kt8v3d9Tlcll38rBEqtWqMiFg\n", + "06zz3DvvvFMtILZi/fpWk5OTWmcQuOWWW4KwYeec7rhhObM8OEsw+s7sCHbhFhvAliSzRpaDInwj\n", + "/GcxuMYf10vKOpNm6z7rfgyfxWIrmcfft0BqtVrgX8f1F/36eoPAzukYV+hpo9HQvu/mt4RxggPq\n", + "pUuXAtaL2aKsbL2tVitIwsqOqtZv/cz63OZhfa5E+kwU7lcqlZRxsfwh2OfGh3POrMsHrK2tBb5K\n", + "o6Oj+jwr0zjmYbvd1vtxOhX2MwKgU7wOoH+Q+eTkZMAWLC0tZVrAYH5GRkYCdmVjY0MZpN0ypqPN\n", + "YJUsOVv32NjYUD2Hzi4sLKTWFpF0EAtkxU7W+O3a2pr2CeuixQY2m83Ab5Wz+3/ve98TkbS+Azxu\n", + "w6SqEZHAj45hnZxwAkoOvPAZpEqlot/Df845l2Ki8AywqFg7eR20fBDb7Xam/y0DY4K57pzTtQ26\n", + "4JwzmRx/7eYky1gbms1msM5ystSsDPL5fN50IvfHlZ/LTu4ICIHv09jYmPYNurW5uanP48zvWFOg\n", + "J1ZwzTDY142UNXA8wUHVbm5uyj333CMi/YVgZWVFhYkFYJBjH7LmwonPohx5I2XR6Fz2AuAs5VjQ\n", + "8P2JEyfUATULBw8e1M0QHN8tCrVWq+mkwXVvvPGGWZwTi5FfCFREUm1CW3lTakV8YHFxzgV5n6DE\n", + "jNXV1WBcBx3hQpF5IvkvTI7Q4ygqv83WBmxkZCTYdPFREo9/FnWNiVYoFHTc0c6trS2zuDTkyy8E\n", + "6Lf1IuPNDv6N9o2OjupYY/NULpd1k8aOuf5xlRV1xKUkeAwgU14UuaSGSDoDNmSbJEnKyMFneIHj\n", + "78LCguoxZGDl/yqXy/o92lev17UNVmSgiB0ZiWs5rxaATWmr1dIXHX8PnYAD/7lz58z8dtAPdqqG\n", + "PPD8mZkZXavQp2KxqPMZGyVeyHHfiYmJIAKWC/ZmlYUS6esMR0n786VarZpHYdBfPNfKfTc6Ohrk\n", + "SOPNFRui1ssfwQhYs6x1fHJyUnUCbRobG1M3Ap6/WUedWUXOl5aWguoT3FcOFsH3WHsPHDgQRAPz\n", + "sVWWY/Pq6moQSc7GuPVbK3cU/5tLRQ3jVG25SFgbUV7j+MjzZkurZG2yeCyx5nO5Ks4TlZUrioF2\n", + "WWs0wP31S8FlIR7tRURERERERETsEfvGSOVyOZmbm9OdJf/FDh9WydmzZ+Wpp54K7uEXKGZLkr+D\n", + "tcbsg/9bkb6FbB0lYHfPzA92yp1ORy0a3Pfll18OcgFZzEC9XtcdObfFzw/Du3arzQxY/3yECXCf\n", + "uDYVZ24XSR/FQX4zMzOBJcryQL23CxcuBNQ11wKzHG5hBeZyOTOPC5B1hNHtdgPn3Fwup1YMO2vj\n", + "nmyV+9bX6upqwHrNzMykss2jb8yeAhhr6ES5XNa24GiEWQVY8hzmjfutrKwMLPjLSJJEmSgcpzSb\n", + "Tb0P11L087UxJQ5ZDEp/ABlAjpOTkypzDrsGE7JbhQGMK889yBSy9/Of4RmsE1Z78Rmcpq1UFe95\n", + "z3vMzzGvIT/LIZu/BzY2NnTcwTAcPnxY2RP8PXz4sMrLYoNw32KxqGsCh3GDmclKf8D1N7l2G9qA\n", + "8Thw4IAZNOG3xUqX8vrrr+t6yPMC4GAhP7VLrVZTlwNeX/wjz2effTYIFHHOBTVIR0ZGVKZc4y+L\n", + "NUab/AAbwM+RxiwzAhysnF6NRkNPU5577rlUO0XSuRAhUxxRrayspK7loy2RtCx5zeQM/gDWAmSB\n", + "r1arOv9fe+01EUnn1cIYbm9vp+rz4TM/DQUzbwCnOrDqpgJ8fMjvcD42FOnJzaoFi/nPa5af3b3b\n", + "7Zq1L/15wXkHs9oc9GHXKyIiIiIiIiIiIkzsGyPF9XNE+hba1atXU+yESC90GtYLdvC1Wk1++tOf\n", + "pu7Ju3JYNidPnkz5xIj0dvb4nn1u/CzGpVJJrUrrzB5n2m+++abu4GHRTE1NaZ+w85+amlJLBqkM\n", + "nnnmGdO3h2uJifQcdP3klWxZwYpZWFgwmSg/1JVx4MCBgGniMFDIldkndloGYPW88sorQVoDDsGH\n", + "dceMFNdug8XAPi3QE26/5dPEgQciaUsdNcOuX79u1jrzE2Pu7OwEqRiazabJAlqWLPQDfhMsY4td\n", + "go5zxnI8/8CBAyprK40D5HLixAl9HrfJZ9YYmIuDklTiOXhGqVRKJQ8VGRxmDoYQcubs3hx67OvY\n", + "1NRUJhM1LIrFosrdcogH033o0CGTzYReIvHpgQMHVBezMqqzVQxcuHBBM+Dju2PHjul8tXxFmOWB\n", + "pQwZdTod1UVLnwAr0GNzczNgsdbX1zVE/9VXXw1+w/Xa/LZa1RHa7Xbg9yPSXxMgbz+Fi0hPx3yW\n", + "/9KlS0GAxOTkZOCrxL63nNjWT8Ug0l83rfUdsIJYONwfMvvBD36g38On7vz58+qXarGlzG5iDLk2\n", + "JCfk9NfuQe8NK1AI83O3dBAWLP8735nf0l3rM85OzwySJZthfbb8YJhut2sydYD1GXSs2WwOlXbF\n", + "x746mx86dEgVlKl/CAZUaavV0pcD/oJOFbGP4vxCliJ9p3N+wbCSWCUi/MgRq1iuRaG22+1UhlqR\n", + "NB380EMPiUgvJ5S/2PCLip22/SOF48eP63EF5+mxgIVna2sroKk3NzcDB9CdnZ1UlA6ej+M7Xvyw\n", + "MD7zzDP6GRYDtHlqairIZt/tdgP6vtls6rGXdUy2WxQOdAC6w5ORjy38l+qgI0PICH28evVqcO2g\n", + "rN6Wsz82S+jHwsJCkA1ZJL0xFkkfR1nHkpgPzz77rH6GxUGk31+03crkLtKnvbGYNJtNfQ6XvEGb\n", + "sTFYXV018834L1de6K0NKcALPmT/0EMP6TEEMv0nSZIZJMCO8VZuJ6wd58+fl9/4jd8QEZFvfvOb\n", + "2l+8JDGX5+fn5cEHHxQRkb/+67/W63xHW86hhbmwsbGh/+YSRrtF3AFY09D2CxcuaPuzNpvb29vB\n", + "GsnHJHiBz8/Pa5mXM2fOiEgviMHfMFobSNYlPmrhIuMiPb3jNUEkHRX3kY98REREvvvd76qMrJxV\n", + "Z8+eFRFJGdNWeRY+qkbfcV273TblBrn45bdE+kfyExMTehzJ5cUwDzl7v7U24Bk4eux0OhrlyO8h\n", + "zqhvHbtCNrzhhsytDRAbRfge9+BcSxivVqs1dHWDYYzd3crWcDutahZ+GRqe//xe9seQA3jQ33q9\n", + "ruPPOoP347vf/W4R6bsEZCEe7UVERERERERE7BFu2FDFt/ShziV+ngjQ/Pl8XneRsFyYavvgBz8o\n", + "IiJPPPGE1itC6PeRI0eC2m7tdlt3mNhls0WNHS6H8eN5g3bPsEqwu5+bm8ss6MnsAhgdWPn5fF6t\n", + "OS54iqMEMATOOf3+fe97n4iIPP3006mCniK93TMzesiSzuHHkAMXRPWtDi5qy8dlsFg5jcJdd90l\n", + "IiIvvPCCPgssAFi4Wq0WWKeDQrazQn6tTM9W2C0fUfjHWkzV82/9o12GVX8N/SgUCoHVmSSJsmKw\n", + "OtfW1gY6szIOHDgQMKF33nmnsiJ8vOGP2y233KLtt44r0N9SqZSZ7oOvH2aNYIfmXwSQKdffs46q\n", + "H374YRHp1Y6Evvz+7/9+oLPb29vKzPkO/CLpoJRf/dVfFZG+UzCzT08//bSI9NgF/IZzRllHp1gn\n", + "sDa8+uqryl5w/i3r+BifQfZHjhzRccf8f+WVV3T8reMxgOsWZtVVY/is9SDgvuVyOZVrTSRdzBlw\n", + "zuncxLrdbDYzmWbMo3a7nSriK5JmODHmU1NTQeAAX4c1uFqtplh0wK8gYJ1CiIi5Fv4i8N9Jg8B5\n", + "ybKOdAF2Use6Nz09reMEJnwQQ431C/rObBv0vlQqqXytHHR4v3e73dSJhEhvXP0alOy8zgWIsUZj\n", + "PS6Xy/qeyDqe/UUBRitJEjOvRmSkIiIiIiIiIiL2iH1jpPL5vBSLRXXI9hOZederlYC/58+flxMn\n", + "TohI36JeXl42a2f90i/9koiIZp1lCwMMB9fkwmetViuwyGZnZ9UihZ+GldzutttuUwaBWZQ/+IM/\n", + "EBGRL37xiyKSdhj92wDGF8zWoGf5vkqcYf69732viPQccy3mzaoB6FvoxWIxqGvUaDTUYmErjLPv\n", + "cpt8+BYch6ajkvrc3JwylxiP0dFR0/E0i5HyM81z+0RCay5JkiCjPt8H1tvExIR+xv588AFBmy12\n", + "rlarKduJe0AnhwEsTPS7Wq2mslH74DH1AymY6YTsT58+rewJ5vfXv/51vQ4+CJy1m5OIQmfx3Gaz\n", + "qXK22sl+EPiNc07nJmRVKpVMf5NPfvKTIiLyp3/6p/oZnIbhw7m9va1+YZz8E/Lwk3+K9NestbU1\n", + "lQ1kz07d8Euam5sLWMIjR47ob2699VZ9Pp5jpW5goO+QD1vvrKe+HjMzAGaD+4bvmFnH33q9Hvhh\n", + "jYyMKMPE7C7Wcsi0UCgEgQqtVkvlnMXEsM+iNW/x/Pvuuy/lII7rwahA3ry2cx1Y6IGli0gwyjVX\n", + "Mc9GR0f13/CzGh8fV4YL92Pf4CRJ1FcHDO2gpKN+SiGeN1kYGxsL0hBY6ySn7MH4Wu/KmwEn3USb\n", + "bxaY86dPn9bxRvuYgcf4ct84wSd0C33c3t7elZHaN2fzTqcjW1tbQY6nkZERHURQ9t1uV53C4DAu\n", + "0i84+uSTT+pvoej47cjIiFKvfuFJkfSxBn6bddQxMjISvKysIq7saM4Lzxe+8AURyXa0FUmXVBAZ\n", + "HNngO5EOOmLhzyza3t+sjI6O6vOYGrYmFiY239cqTAml5s0V7g15WEUteYPEmyd/ceAoNnYe9J3+\n", + "razoxWIxmLy8QeZFC7qFNrfbbTNHjTVe/rgPoqOtIwcfm5ubgdP8qVOntC1YhCuVio4NNgRra2s6\n", + "D6Dv6+vr5vGCn+28Vqvpb1hv8G842V+8eDEoa1QsFvW5586d08+xkMJIuXr1amZU3G7HIP4xskjf\n", + "cd85p07BaMu1a9fMscCLnecPFz0V6b3keJ7iuZAHH9NyWQwfHFmL3+Ll2el09MWNsVxdXTWdpSFD\n", + "jNvi4qL2nYsVY77gCNLajNXr9dRmSaT/YmF0u11dsyAfLh7LxqSV2dwvGM5rNM9BfwM1MjKixzwY\n", + "v2azqcYfjJNGoxG4BZw7dy4wICcmJlQOVlQcNnKLi4v6b2x8eMwxfw8fPqwbN9yXN154J42OjsqP\n", + "f/xjEUkHBADOuUA/ue9ccsjK8QSdwDHdxMSE3h/9nJubUz3OcgrfLYM4b8w5pxz+8nGgSG+8uMwO\n", + "gDWBoxj9dzgbNrjfG2+8ofqJz3gOQg+sEnV8b/y1gh18xKO9iIiIiIiIiIg9Yt8YqdHRUel0OrpT\n", + "5eK8sBiw2x4bG9NdMML8b7vtNqVFeRfrsw+D4IdHcrFcy7HYYnFgyW1tbekOmB0f/XBwDkdn+Lvs\n", + "Q4cOBXQxOyAzCwVLDlbP4uJiynEfYAvSt+LZksJ4MNPBcrBybGAc2ILjMHuRnpz94IFSqaTfo09Z\n", + "eY5E+ozf+vq69omLTWNcrZxBWRmw2XEbMrCy7PJ9OA+PRbP7ubt2s+SgH5/61KfUCkPQAef9wbiu\n", + "ra2pgz/mDBel/kXABYX9GlWc1wvXHThwQFkPyG18fFyZH8hia2sr0OPp6WllynDkNjs7q0dikAGz\n", + "QsMWoy2VSgELmCSJPg9pSAqFQip1hC8HfrYfCGAVWD106JDKg7/LyhgP9qtUKim7g3WHAzjYoraA\n", + "tQA6VCgUVPf4qMtPa2EFL6ysrATpaLi4NYOZKB9ZLP8999wT1EhkRhw6NDs7q2OJNBg7OztBtnOR\n", + "fn4wnFpYbWg2m6qDOC61iroz6wpW6NixY2YlDP8oEQ71In3Zj4yMKNuKPlp5uxhJkpg1SH2WivOh\n", + "YYxWV1eVyRvGOZ1RrVaDVDZcGQSy4bUNn5VKpUDH+Hv8HVSkHnMOf51z+lweS+uYHjphnaAwA++j\n", + "XC6nsr/7bR+EyEhFREREREREROwR++ZsLtKzmOADAFZhbm7uLXe+9v1hJiYmdNfOSRNxfoxdO1sA\n", + "7FiIpIpgGi5evKhWCTND/m+Xl5d1980MF9rHTpiWDwhndRfp7eQ5RBfXgEGq1+tq+WRVQ2fLwdKH\n", + "LAfPQZl0/TqDhUJBZcRWgp9dmf1vhgVXOce/2b8G8udK9L51J9L3R7F8ZdgR3fdvse6XJEmgE6VS\n", + "SbOrMxOK/g5TT1IkzTSyLoiI2S8LrA/svzDIsZ+f65zT3zAzgXkB3X7zzTeHZo6yANnffvvtQfLK\n", + "iYkJbddjjz2mLBYzZhhPrubuMyqlUkkd4xHezakqrKS/AMsD/T1z5ozJ1IJdQT+s1A5333233gfj\n", + "Pjk5Kffdd5+I9JOuXrt2TecPMx8A1ripqSnVfbBG7EuJNq2srATsOGd6ZobLr66Qtb6I9HWiXq/L\n", + "r/3ar6Xa/P3vf1/7izX46NGj6t+EQIRqtarrE2f+txgwBAkgLUSSJOZceuCBB0SkL1MrYbFIX3eQ\n", + "DuOHP/yhfscpefx1T6TPjjATY7XFR7FY1P5yzVB2/vfrwg0C1nD0w2dVhwHWrFqtFgQeWP62zFxb\n", + "64DF+DGgi3juoPQq6BvGbXp6Wk+VMM83NzdV1vi72wkB4++ss3mpVJL7779fnnjiiaGu52iJQajV\n", + "ajoo2HTkcrnAgW5tbc2kprnApQ8+asMgsdO5Hykh0h9gPIvbzorHDozoB2hFLOZc6sZSAPSbj+F2\n", + "UxQuAJlVNNLKGMsFQq2NlL8ZbrfbehRq0a3s+GjlhfIXNz6GgMw3NzfNPuNFgTEcdF9/g8TPyHLM\n", + "t44WRPryw4sgSZLM6CpELnW7XaWrrYWWn+/3t1Kp6GaC84RBB9HfhYUF3RQMa0zttlhbkbfY6LGR\n", + "go0tZ22GrBBZy8dlWED9QtgW8ByM+WuvvabPsaJ1gGazqUEpnLsNssnqe5IkgQzX19eDtapWq5kb\n", + "Hh+FQiE4tu52u6pnOAZaX1+XRx55RETsjRQfoeMFj42PVdHBORccPXJ+IFxXKBSCucIGFb6bnJxU\n", + "/eWNw7e//W0R6a+Hhw8f1jGxilwDloHNhcCBu+++29QVRC5yYIsVTGCtZ36VBwbcTbhcDcPXg0ql\n", + "EsxrLr7Nzs6YKxsbG0FRZO43F+L1KwckSWIGh2CusIHrF/ZdXV3VscF8HPZ4sFgsBkfjSZIE0bjs\n", + "ksFRgBzMw3Li9pXLZW0fnnH9+vU9lXnxn+HPwSzEo72IiIiIiIiIiD1i3xiper2eYqOs8HHAChXO\n", + "5XKaHwg780uXLunuOivL6ejoaGDJP/jgg2YosU8/3n777erQDgvi9OnTmkGcrV2/CKVIyHodPHhQ\n", + "28q0sF8bzS+87AO7Zt49s6Mly3c3ShX38QtTiqSPR/AXVgdnoh22PpPl+I77ceg05xISSY8hW3w+\n", + "M3D27Nng+JCPIbhN/vEEU+d4hpUzjOXI8s86ZsOzKpWK/p4dbqELSPexvr6udDz6yPWoYHFubW2Z\n", + "zpcAjx+YKzhXcr1G5LTZ2tpSXQSrkM/ng0zaYBvRLvQB17EzLfqB6yYnJ5UtxFiVy+WbPuL1n432\n", + "81ED+m4B8x86xkXGh60RhrnOLgOf+MQnRKSnJ6jjl4VqtRro7Orqqq6XLBc/KzqDC0v782xyclLZ\n", + "azCms7OzQQHg9fV1kynx5wozANCxxcXFVGCESPooG/NjdXU1YFsgB/xGpDdufh4uXuex9lvvi0ql\n", + "ojLFszqdjsmi+uviyZMndd0GI2UxphMTE6rH7ArAuQpFerKFGwHkeO3aNb0fyzsrv6KVsZ5Tz7Ce\n", + "+30ql8sm6wfg3VUqlfQ9YuVa4vc15M5BCdYR4l7mNcAy5L/cvkFsFNYoDmbz8+E1Go1UnkOR4eZ+\n", + "ZKQiIiIiIiIiIvaIfWOkOFxaxGaiGNg5co0qWLm88/Yd0iYmJtQ6sBwzcQZ9/Phx+dGPfpT6LfsC\n", + "sOWPHTqcSRGCbvVRpG+B1+v1wPJaXV01nbDBCKCtrVZLa1TBumPmgdMvgDFh1uD48eMi0qsLhb5k\n", + "7eCLxWIqySeAazk01HcoZGsaDMH29naQiG9iYiLIBM3tBzqdjt6Hq5cDPOZ++LGVPNBikHZ2dgIW\n", + "gOtCAc45tWzAYHB72VL/wAc+ICJpXzrICPe1/HW4XZZucdZuv2bg+Pi49sOq+8j9wW+ZiYJ8oTvs\n", + "A8eMra/bFpsr0vdL4WS3PpPI/oeQz8rKiv4GvmNs4YKZGB0dTaU8wXzmzMzoc1a2ZE7mC4sVfpY3\n", + "A8shFmsX/u6GBx54QBluME7lctmsp8d110TETHa5tLQU6Fm1Wg0c2peWloL6izMzM7pOg9Wu1Wqm\n", + "bgHsk8Y+jSI9Pcjy3UR/jx8/rn3BPVqtlsnMY40G8wM/O8bW1lYgv4cfflidzJk5wThhDeEAk6w0\n", + "LVeuXAl8faanp3VNYsY5K6CF13I+pYBuA8MGlhQKhSCU31p3JicntZ9gnJrNZibDzYDucLoUrNMY\n", + "G0s/x8bGVK4cNANdQGqKQqGg7cLYXL9+XX9jvccQAJPP55Xdw3pw9erVgJWzUoBwQupB2LeNVNZE\n", + "BLCQnTx50szx4i8inP0bC8HKyorpHAelxQvo61//enDN0aNHg/wmt956q+YwAQZFrmHjw0WJsYhw\n", + "Hg4oNSbf7OysKiDToFb5D79gsEh/M8EbA+uozd9QiaQLNvsRMnxPLp9gvaC4SDLgO4tacrOCCRqN\n", + "hvYJE3JjY8MMQLjnnntERHRTfPHixSCbNG8mcN/l5eVgM2CVVmg2m0rLA/l8PlWAE0BkD3SNgyGs\n", + "hQxtKRaL5oID4FmW8WHpei6X0/HiuYKXAW8+MNaQ6aDNB148uN8DDzygCxVeWFtbW5lFmtHfO+64\n", + "Q+WC9i8uLuqLwsqNNei+KDsD+SZJEpSL4LlgRVkBNxPVkwXM2wcffFCjxDirO4C16ODBg0GxcXZG\n", + "ZnDm7kHY2NgIdL/RaATHglxpAmBZQd/K5XLKuPKBl9PU1JSOsXXEg3vMzMzovWGkWGPORgr3B2sC\n", + "6wTWRcxHLrSLkmHXrl0L2lWtVoM5dO3atSCv3+joqLYBG1F+CXNGbX9dueWWW/S9grbkcjl9Bozn\n", + "XC6XWk/8Ntx5550qa2vew9jpdDrB9/l8Xo0crHGLi4umuwfeVX65MZF0FCh+axlVvJ5hY8KBPv7x\n", + "+87Ojq491sYYfcvn83ofzn2HMbGORkEqiPTHDrrY6XS0DbtFojLi0V5ERERERERExB6xb4yUT21i\n", + "lzo5Oak7UVhZFhs1PT0dZD5lqpNrGMHqhPWxtbWl12aFNjIb9eu//ut6P9+aHOTcBmsM7Fu5XA6o\n", + "39XVVbWo0I+LFy+mnFVFejtvUM64b6lUUiaKnZct6xTWTLVaVfkyI+UzQa1WKzgmY2YDO/lB2ZXx\n", + "Oeexsgr7ZlnSbHWifbCGSqVSUCsKfeG/nU7HzHVj5QXCv3dLtQFZgjHlmmLcx1OnTolI37pmax9t\n", + "qdfrQeZzSybFYlF/k3VEdfDgQWXM8Lw333xTdcwqsLpbf++++24R6Y9pq9VK1boSEfnWt74V/O74\n", + "8eNqOcIi3d7eVusYY/nqq68GjFC5XNbfcqZmWOuwIMfGxlJrCeYN5+7yx79Sqei8Z1bPP66xMpZb\n", + "sAIQGKgFOj8/r0eSfm47kb7unDt3Tq1sTqGC3zLzwvXlBiGXywVMQxbjybCYpJ2dncBav+uuu5Qd\n", + "47pvFqBHGN/5+XnVo6z8RoOcpzFveE6jfzgW5moRmBd81Idj+IsXLyqLwcflPgPKRe6Bbrerusp9\n", + "xxhinh85ckTzh1k1NSGXYrGobbECEJCuQ0RSNfdwipEly06nYzqbYy3gFCB+9nKLqeXPsF6Uy2U9\n", + "veEC6dAPzOVh06/wPLP6hjkwyJkdeue/W/32Q/6Yo8Mc7UVGKiIi4m8Fw/pwROyOYTc+EbvjrU74\n", + "HBGxb5nNYSFkZc3mM1RYY9iJcp0kDlfGjhWTxTrznZqaCqwlzpDLtaWQtRbtfPTRRzP7hqrjKysr\n", + "ej9rBwxwnTuAz9qxO2ZLw/J34uzdOPve2dnR82qwJ+wcDotqbGzMlJfvANjtdgOWamxsLOUoDvjO\n", + "yLVaLfDpOXHihLaPFzdOLieSTkrJ4e1oP7MBCOWHg2Sn0wksHs4YzIwA5M56B1mxLCAjrn3nMxfI\n", + "hMuo1+s6dpDZbkkuLWAMqtWqjit0w/IdYmYF8jl16pRau2A1JycnU07cIj02eFBGYUaxWFS5sX/S\n", + "2wFOl/HZz35WRESee+45ERF56aWXlLXhLNF+Og2R0IeOWVSM9djYWGY2aovpzPLDGgS0D+kvlpeX\n", + "lXUYZl0R6c8f51wms8a+Y/g3pzfxMTExoes1vh/kT+LXfdve3g6CNW4G7Hwv0psDvh/M9PS03hvX\n", + "3XbbbaaPKYBs6+fPnw+YKwsnT57U9Q760Gg0UnXmRHq6iXUvK8v/xMSEPg/XcQAM/xYyn5iYyNRF\n", + "gPXYSnZ8s6jVaqkaudAzzJ9h1gsfSKALHV9YWNBxwBiyTy0/E+w05lmz2QxSGHQ6HZUh2skBF1zT\n", + "EuOFPQLeIVmZzTUr79v5n4gkn//855OItwZRlm8doizfOkRZvnWIsnzrEGX51uEfkix72yV7TxOP\n", + "9iIiIiIiIiIi9oh9LVocEREREREREfFOQDLgaG9fNlIREREREREREX8fEI/2IiIiIiIiIiL2iLiR\n", + "ioihjjlwAAAEq0lEQVSIiIiIiIjYI972jZRz7qPOuZedcz93zv27t/v573Q45153zj3rnHvaOffk\n", + "jc+mnHPfdc694pz7jnNuuKJe/8DgnPvvzrlrzrnn6LOBsnPOfe6Gnr7snHtkf1r9dxMDZPmfnHOX\n", + "bujm0865j9F3UZYD4Jw77px73Dn3gnPueefcZ298HnXzJpEhy6ibNwnnXNk5d84594xz7kXn3H++\n", + "8XnUSw9vq4+Ucy4vIudF5MMicllEfiwin0qS5KW3rRHvcDjnXhOR+5MkWaLP/khEFpMk+aMbm9PJ\n", + "JEn+/b418u8onHMPiciGiHwlSZL33PjMlJ1z7oyI/C8ReZ+IzIrIYyLyriRJBieD+QeEAbL8vIis\n", + "J0nyX71roywz4Jw7LCKHkyR5xjk3KiI/EZFPiMhnJOrmTSFDlr8tUTdvGs65apIkDedcQUSeEJF/\n", + "KyK/KVEvU3i7Gan3i8jfJEnyepIkOyLyVRH5+Nvchr8P8CMHflNEvnzj31+W3sIR4SFJkv8nIn6K\n", + "6EGy+7iIPJokyU6SJK+LyN9IT38jZKAsRULdFImyzESSJFeTJHnmxr83ROQl6b2Iom7eJDJkKRJ1\n", + "86aRJAkyJRdFJC+9OR/10sPbvZGaFRFOx3tJ+koeMRwSEXnMOfeUc+6f3/jsUJIkKKJ2TUQO7U/T\n", + "3pEYJLuj0tNPIOrqcPjXzrmfOef+mCj/KMsh4Zw7KSL3isg5ibr5C4Fk+aMbH0XdvEk453LOuWek\n", + "p3+PJ0nygkS9DPB2b6RiroVfHB9IkuReEfmYiPzLG0csCmRg3ZeWvcMxhOyiXLPx30TkVhE5KyJX\n", + "ROQLGddGWXq4cRT1f0Tk3yRJkqq8GnXz5nBDlv9berLckKibe0KSJN0kSc6KyDER+UfOuYe976Ne\n", + "ytu/kbosIsfp/49LegcbsQuSJLly4++CiPyZ9KjTazd8A8Q5d0RE5vevhe84DJKdr6vHbnwWMQBJ\n", + "ksxTOYUvSZ/Wj7LcBc65Eeltov4kSZJv3Pg46uYeQLL8H5Bl1M1fDEmSrIrI/xWR+yXqZYC3eyP1\n", + "lIjc4Zw76ZwrisgnReQv3uY2vGPhnKs658Zu/LsmIo+IyHPSk+Gnb1z2aRH5hn2HCAODZPcXIvJP\n", + "nXNF59ytInKHiDy5D+17x+DGogr8E+nppkiUZSacc05E/lhEXkyS5Iv0VdTNm8QgWUbdvHk456Zx\n", + "BOqcq4jIR0TkaYl6GaDwdj4sSZK2c+5fici3pee49scxYu+mcEhE/qy3VkhBRP5nkiTfcc49JSJf\n", + "c879joi8Lr0IlQgPzrlHReRDIjLtnLsoIv9RRP6LGLJLkuRF59zXRORFEWmLyO8lsQyAwpDl50Xk\n", + "HzvnzkqPzn9NRP6FSJTlEPiAiPwzEXnWOff0jc8+J1E39wJLlv9BRD4VdfOmcUREvuycy0mPdPmT\n", + "JEn+6oZco14SYomYiIiIiIiIiIg9ImY2j4iIiIiIiIjYI+JGKiIiIiIiIiJij4gbqYiIiIiIiIiI\n", + "PSJupCIiIiIiIiIi9oi4kYqIiIiIiIiI2CPiRioiIiIiIiIiYo+IG6mIiIiIiIiIiD0ibqQiIiIi\n", + "IiIiIvaI/w/CAMCOMj3yxQAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['conv1'].data[0, :36]\n", + "vis_square(feat, padval=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second layer filters, `conv2`\n", + "\n", + "There are 256 filters, each of which has dimension 5 x 5 x 48. We show only the first 48 filters, with each channel shown separately, so that each filter is a row." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvWmsbldxv1nvOb7zgCc8GwMGMxkIMyKgRCgk/+RDuiMl\n", + "6UQBOg4eZQYj7GADRg42wthGcMEoHkCOlaB0R1GCWpGSNJmDiIAEOYAx4BHPxsb25frOZ+gPl2fv\n", + "9T57132dg92n8+/6fTnnPWe9a9eqVWvtVbVqmCwvL0ehUCgUCoVC4b+OudUmoFAoFAqFQuG/K+og\n", + "VSgUCoVCobBC1EGqUCgUCoVCYYWog1ShUCgUCoXCClEHqUKhUCgUCoUVog5ShUKhUCgUCivE03KQ\n", + "mkwm/2MymXx3MpncOplM3v90PKNQKBQKhUJhtTF5qvNITSaT+Yj4XkT8QkTcFxFfj4jfXl5evuUp\n", + "fVChUCgUCoXCKuPpsEi9NiJuW15evmt5eXl/RPwfEfG/PA3PKRQKhUKhUFhVPB0HqeMj4p7m870/\n", + "+VuhUCgUCoXC/1Q45Gnoc+Zd4WQyqbo0hUKhUCgU/ttgeXl5Mvb3p+MgdV9EnNh8PjEOWKWmcNxx\n", + "x8Wzn/3siIg44YQT4sQTT4w9e/ZERMTatWsjIuKTn/xkRESceeaZERGxtLQUERGLi4tx6KGHRkTE\n", + "3NwBo9onPvGJiIj4tV/7tYiIePzxxyMi4phjjjlAxIknTvVx1VVXRUTE2972tql29Pvoo49GRMTC\n", + "wkJERGzbti0iIt7+9rdHRMTOnTvjsMMOi4iIjRs3RkTE3r17IyLi2muvjYiIc845JyIidu/eHRER\n", + "8/PzERGxadOmiIhYs2bNFO3vec97IiLiiSeeiIiIQw45ZKrdli1bIiLiYx/7WEREvP/974/FxcUp\n", + "Ojdv3jz1TPqGFvqem5uLm266Kd785jd3PI2I+PSnPx0REe9973un+MX/4fdkMun4cu655079Db87\n", + "xstP5vP888+f4hf/53v8hJbzzjsvIiKe8YxnTH1vx44dEXFAXuj7wgsvnOrjxz/+8dQz4OmnPvWp\n", + "qXH62evWrZsaN3z84Ac/GBER+/fvn6Jl586d3Tz94R/+YUT084lcb9iwYeoZi4uL8dWvfjW+/vWv\n", + "R0TE+973vqlnAvjKuvj4xz8eEQfmPyJi37593TPWr18/9V348s53vnPq2fQJGC/jvOSSS6ZofvDB\n", + "B6fGsm/fvoiI+PznPx8RB+SLv/EdZGXnzp1TbZkjaGCOkDX4yPzDF8siaNfRb/3Wb0VExJFHHnnQ\n", + "vm+44YaIiHjDG94QP/uzP9vRwrpBTuDL5ZdfHhER7373uyMi4u677556DutucXExPvOZz0RExLve\n", + "9a6pPpAV+MJP5ujss8+e4h80w1fmlvYXXXTRVDv6n0wmg32RNcT+xjj52a7niH6/QM4B36f9lVde\n", + "OTXWI444oqPFvGTPZT9/+OGHI+KAbL3hDW+YWksR/Ryxjhj/rl27pvhH/4yV/WXz5s0d/ewV3ovY\n", + "u7Zv3959J6Jfa/D26quvjoiICy64YGr89J+tiw9/+MPd++GRRx6JiOGexH7x1re+NSIijj766Ijo\n", + "ZZW+eSa0wxf64znQTv9XXXVVt8/xDmG8zNHXvva1eMUrXtHxnPcizzSvvdedddZZU7T4nbW0tNS1\n", + "/e3f/u2IiHjWs54VERGHH354RPTvbN5lyBbtGRd9Amhjv/jd3/3diOjXETS364L9n/mHx7Sdm5uL\n", + "++67r1vnN910UxwMT8dB6t8j4vmTyeTZEXF/RPxvEfHbbnTCCSfEG9/4xogYboyFQqFQKBQKq4Xj\n", + "jz++Uwz+Xz9ILS8vL0wmk3dGxN9GxHxEfH4sYm/NmjXdaR9twSdwwKmYE/bCwkKnlXAKB3wXbYf/\n", + "8yxOnOCFL3xhREQcddRREdFrVN///vcjoj+5m5YdO3Z0fWJh4rTbjrGliZN2FikJrWg1jIFx0x+Y\n", + "m5sbWAHcB0DLQeN65JFHpqwS7ptnts9qfzL2iJ4nT/ZADG3wDU0DTdTzby0RLWoM0A19nn+DcaNZ\n", + "0o7PnlPkg++hgd15552DZ0AvYLytZaLlM+1/9KMfTbVDAzMtyNPi4mLXD234H2BubLHK+ILlgX6t\n", + "BXodrVmzpqMfntvC7HFCKzRlFiePibnhOS1fjj322Ig4sAlG9JY0tF3L9cLCQuzZs6ebG8bFs8wf\n", + "ZB2LNXKAjLb8pS+vd75jWmyx5lmeS/fD2NgvNm/e3NEDmD8s7+xrjGOW7PJ9yw+AZp47Pz+friHA\n", + "emcO6Htsn2sBX5h/LH6A72/cuLF7Ribn8Jxns4/y2XsRc8qzmVu/J8Bhhx3WteG7ln/A3oKVk2cg\n", + "wwb7oG8LPHdtXx4XP9esWdPNYUQ/j4899lhEDN/B5ift2z1prF1Eb4HinYRs8V7werFlljll3lu6\n", + "I/o5NE1zc3MD2WJc8IW+bImdhafDIhXLy8t/HRF/fbA2mPUKqwc21cLq4YQTTlhtEv5/DQ5chdVD\n", + "zcHqo+bgp8PTcpB6MnjmM5/ZnSyB774Bp8j2/tLaHMCPhtMrp1K0e34CrGGcYqEJ7Q6aQKtFc4rN\n", + "NEZotL9N6yMzBtpzWoY2W2J27do1OGEzHluk0Cz4+9zcXBx//PHdydsWBvjE2BirfWsONo5MC7SG\n", + "Zs3bWmCruUbEgOaWB8yXtRrzHvhZs7RotH9ohp9btmwZ9MVnW8VazQsLSksb47GFxnyG1t27d3da\n", + "KPPk+beM0h5+WQO7//77I6KXPcZtnxqwuLg4sAJapgBWPICsQZNph0bGYN63z6ENz+Azbbxv+CCL\n", + "dmzfQ8AzsR7YMtHuL/4uPLY/nvHDH/5wilbkIZNJW2aYsxb4RsIX1lRmBWCeobn1AWu/D/g7z9m1\n", + "a9fABxIgJ/iYchuQ7SPw0b6mtn4A5GX9+vUdDfDGcp7tC/DF7aHdVlLae8978MEHB5ZD9wHgHVZC\n", + "5goaPE768TPH/m4/Kz4z7qOPPnpqrKwXLDT2MfR7Bz741mVsP0V2sLwzXs8v8DPpi74ti9DgvW1p\n", + "aWlgvcz8LRlvds4wqkRMoVAoFAqFwgqxahapiP60hybKadCanC0X7anSp3q0MbQd+ylk1i5HjnGK\n", + "zXyHNm7c2GmvmSZtH5FZFilHGNn/y6fp9s6XPjNfMGvB8IHP5jnP8r3+fwWmqaW7Bf93dBqANt/P\n", + "ewwtrHllsGbJ50w7Zo5tkVlaWhr4j9hiZh8Gy4s1eL7HXGS+I/Pz84MoI/ME2ujblgjPyZg21/40\n", + "lpaWOu3V85TJYuZ3Yd76/16zLe3217OlKKOFcTqy0nyxr1nWrgX/81odk6G2b8u3tWM08TZaj7FY\n", + "fhk3ba1xZ35p0ML3+Z73ojELaOZPAw22Ym3dunW0Pc+2pS2zprf/p022br3XMEdjlvcWtuiY1rad\n", + "LamZlYP/OyLQtyim1Xv42A1J5o+XjdfvrmxtAq8LaPB7JGJo3QSWIeBnel1ke7V9x+bn5wfz4/cb\n", + "9DLe7LbJKItUoVAoFAqFwgrxlNfae1IPrYSchUKhUCgU/hshS8hZFqlCoVAoFAqFFWLVfKQ+9KEP\n", + "dT5ARJrhvc89K1l2ycqK38ZkMulybXD/+ZGPfCQiIt7xjndERH+/jN+Gc7OQNZXswNwJO7sqtFx/\n", + "/fUR0WeT3rx5c3eP6igbZ+QmOoH7WCKFuJ/+8Ic/HBF9ZmNHmhCJyJ0vGYLf//73D6Jr8LPiWTfe\n", + "eGNEHOB324d9wPhM32SHhW/O3s5z/uiP/qjLVGwfJ99Hk5GX+YTn8IfvwR+ySZOp+L777ouIfk6e\n", + "85zndM/5wAc+EBF9Bu82n01En+eFeb3mmmsios+yDa38RNaQTbLy0r+zNm/ZsqW742f+4TnPfuCB\n", + "B7q2EX36CTLVI4sAueIZ5F+hPdmHN2/e3EWRsR6gz3LOeJx1HFkmszGySDZmfA6hAf6QxfvCCy8c\n", + "+HYwB/TNGoUWaEAOoAU5gI+nn376VH/2lUEWP/vZzw6y7FvO+ens0I6wZJzg4osvjoiI3//93596\n", + "piNs9+/fH5/97Gen2iKvrD32OYBskcEdvhA5zHid8R3aHdU5Pz/fPZP1TOZpeOx8aMgo+xxzxHph\n", + "X0QW8Wciyz4Z37nh2LVrVzeP7F+sZ9Y/42Td2H/rc5/73FTf8JwoP8YI7bwvWNM7d+7s6EZ2yI/G\n", + "GmJvAawb5+HyOJF/eM5zwF/+5V9GxAEZQAbJB8W42QfYi3i3ME7a2XcMWni/OIcXc8Bcf/SjH+3W\n", + "M/PJHvvQQw9NPfMLX/hCRPTr375DznTOnFIJAX835qSVF+hGzu07BphX7//w2n6v0MK6g4/OU9n6\n", + "UiHnZ5xxRkT0vIPXjJdxQHuGskgVCoVCoVAorBCrZpHasGFD3HrrrRER8R//8R8RcSC3VETE61//\n", + "+qm2aMVoi29+85u7U+uXv/zlqbacQtFaOHmTR8l5oaxJOHO3o3E4uT744INx1113RUR/gnaSUUc+\n", + "nHrqqVN98n3A6RdLBf3RjzXZH//4xx1PXLcMix3gNE7tIJ4Fz9HUADRDi62HrW+doy6xAmU5meA5\n", + "8wotxx133NT3getgkY0eviNHEb32S1vXUHIkJNo+tH73u9+NiF47ph4kQIuCvySye/TRR+POO++c\n", + "aotF6Xvf+15E9Nraa17zmogYRuHB03vuuScieg32lFNOiYhepgFzs3Xr1q4v5NyZlpEdxsP/sXoY\n", + "1uLIdwUfnbtlMpkM8sA4EhbAc2T2Bz/4wdSzXvCCF0y1t5WI70HDWMQcfTkSyNYs5APrQJvXK6LP\n", + "p+X2aK7IINbGVrt2RFhb57IdD4BfyBF9QlO2pp3z7dBDDx1Yg+HVS1/60oiIeNOb3hQR/d77ne98\n", + "Z6o9fGONsmaRwSyyEpnduXNnt54d4Yc8IGPOnu29iP+/+MUvjojoSov9+7//e0T0VhUAHx544IGO\n", + "R6wVR2GxbphnngXtjsT1XsWcspf7HbBv376uDbKDNdDVAti7ac9e5mz7wFYz9puxrNzMD2uLNcV4\n", + "kWfDlt0s4pCxcWuAHMCnlnbn+sOihjxYXoCty1n29Kwyytzc3CDCDx7yTFfwmBW9CcoiVSgUCoVC\n", + "obBCrJpF6tFHH+1OoJzisY5Y2+VEjvZ/1113xb333hsRw9M3p31Owpx+OaU6O7jr9aCBoOXYgoHm\n", + "8uCDD3anWVfrBs5Rg9YylgU5otc4TzrppIjoNRK0RWv2z3jGMzoN47bbbpv6rjUpZ5Hl/2h/bo+2\n", + "7DqCrgLe/o5mAK/H2kb0c+D7aLRGWxiYA+bkm9/8ZkQMs9ZHDP2zrNXZAomG0mrSEb1PkHnOXCNn\n", + "rXZtTRrZwwqCZQGaLLu0dwZk/k79R9Bm+KYN47flBWsoNPIMPtt64mziyD08t6w//vjjHe9cp89W\n", + "IXiLNcy5ZmwlgzZrh6540LbN8mhZzpFBxvn1r389Ivq9xtqufUXYw+w70v6OjCE7WU1J1ia0QwP7\n", + "ojV1+/3xnF27dnX7H2D+seZgicD6abBfYCVBnphbr2nkhbW9bt26bi6wlADTyzhd9wxwq4BF6qtf\n", + "/WpE9NZ1rzto37lzZ7d3MA5bJFgH/B+as/qpz33ucyOi3x/vuOOOiOitxqxtsHbt2oF/LvPo2xF4\n", + "Zz/XLCs/8uOM+Yy57R9LIvLKnLR1CVu4/iV9tT6hLbyv8v2x/cL532xp8jua/d2+hq6QAcyvtrqB\n", + "9xDX7+MdlOVAy7BqB6mlpaVugbBIfegBDIrDwvr169MkhXx22nkmLStwyOTwss4KjjLpRx55ZPdC\n", + "YBLGSri0z7ajtzdGFiFCycHLNILDDz+8WxD8z4n3AAKEoFgo3Tffh49sMGMlaOjbz8ySvTEeXmJO\n", + "iulFyfUCm7+d9dtDALzFPA6PkSkvDMbDs5/3vOdFRM9HyyLj5tqF52zatGkwTjZ4Fx22TAJo43u8\n", + "YPzyBtC2b9++bj6zvtmcmU/Ggcx5U7cDqw8zXnetczHP5kXvgxQ8Q+Y4/DN3zAmwjLImXQzcv7dt\n", + "M0dVZAv+wPOs/JOTHzrpX8sXxu0ErIzfQE7YV2hvZ2zgQ2N2WIzoeftP//RPEdEfoHwt777ZL5BN\n", + "aM/4grKwfv36tOQHMoQyYgUse3n94z/+49T/WReWL553/PHHD65sDNr66i9z7YBG3AnYy1wEGGza\n", + "tGlQlDdL5sn8unCyDwQAmfVhaCyZNIoQz0TGZpXOgib6npVMlL2LvT27Mozo+eGrfoNnZnuy4Su/\n", + "1tXA77ksaTb7pPeiDHW1VygUCoVCobBCrJpFam5uLi2g6GsJl9ZotR2b9ThRurhqdqr3s50OwP1D\n", + "y4YNGzotPiuzYLOmna99teNQdLQATu5jJSJsSXDRSGCHXVvPsoKY0IQmiobS0u4SFrMc9bB2ZM/M\n", + "LFiYz32V2PKF+YTn1qwyjcRzlcmii5m2VibTDc9dMDQrnQMww9tpPyuF0Y4vuzbG8oK8YInKylYg\n", + "J/x0WhBbMFrN01YbWwzoK7PUZg7hdl7PClRHDMvTZLKIxYLrM/aYTF4A/WI1aK2DAPqy8jSZBdNu\n", + "CNl6gjb41RZ191UtFglft7sEELC1COtiZpGAj22BYej1uGnr8jqZFZA9iPGyf0B7doOxdu3agSya\n", + "fqfoyMqxAFvkXJjeWFpa6tr6u7YcuiQUa4pxZ+VtzM+xIA/kEvcRWzuzEjLsEw4g8fpnn4B//GTM\n", + "Y3tXViLK+wXjZL79vUy+PPaIoYWRPpgLLFDZushQFqlCoVAoFAqFFaJKxBQKhUKhUCjMQJWIKRQK\n", + "hUKhUHiKsWo+UmeeeeYgxJK7YKfxJ+V/G2JsHxXSyV9wwQVTfTrqjL5J+f6ud70rIvp7a0f34edw\n", + "9dVXR0TEOeecExEH7mG5XyeC4yUveUlE9CVfKBHhchzcO3N//KlPfSoioitvYV8Bvg8t1157bUQc\n", + "KBHgKCrupvkOpTCgG18Z/HDok/EyTtLsO4WD/RQ+9rGPdSn/ocH+BtxRUwqD0gb4YcAH+zwxp8yR\n", + "y7e04e/wkHFC98te9rKIiPjWt74VEb0/BaVQTjvttKlnE95MWDNzRVkO2uP/RNTk1q1bO3mgVAU8\n", + "ZD6zsGbknDIeTjWBTxFpQmhPCZq7776786dAxvgMLZT8IVoHwA/8CuAjpTDsz+fIQ8p4XHrppZ28\n", + "En7OPBK1dNlll0VEP0fwFjkhBQURVC4pBP/wx0BuWNvbtm3rSlt4XfCTaLU/+7M/i4i+XIXDvx1x\n", + "5v0CfkF7u46QFdaz03y4VBBlXBinS3wgP9AILYyVtYif1ze+8Y3ud8pmME7WL3PlCEH6piQO4yKa\n", + "GR8bxkJ79jrGtLCwMJB3yhW5/Aj0k8yRfcF7F7IKP7yH0T/vi4hhYlqXtqEUDmvMSV5JWUF7ymE5\n", + "xYcjyqDl/PPPH/Dc/riM06W26NNRn8wp8sKeztzg5wNft23b1vXN+B3NyjOhBTkHPJt1wRxcd911\n", + "U7QA7xebNm3q9i3aOsLc/lqME3nh76T2YL+AdpdmA/S/adOm7pm8Wz760Y9GxDBBMeNjHVHeKkNZ\n", + "pAqFQqFQKBRWiFXNI4UVgHIFX/ziFyNiGIXhAsQPPPBAd7J0MjYnXiR5I9YiNAzAyZNncOLmp33I\n", + "OBU/9thj8Ru/8RsRMcxB5bZE1WAVIQ8S+XMAGidag0vnOGpjeXm5Gy/J6WjjhGmOAEMThS/f+MY3\n", + "ptqjHZDL6ld/9Vcjoi+h0ubCcR4pR7Jk0UYA2qHt+c9//igt8Ovmm2+OiD6v1Mknn9y1ZT5ddgLr\n", + "B9obgFZkDn5g/fmrv/qrqfbwFVnE4rlz585BCRfn/7n99tsjotccmVeA5kk/jPfP//zPI6LX2AFa\n", + "1G233Rave93rIiLi53/+5yOizxcEGD/yT5JX+GOLDEAWKeOCNci0//CHP+wsA9DpPGGA+YeXv/AL\n", + "vxAREZ///Ocjotc0ATIODZQIotzJP/zDP3RtnVvIuWpMN3sQcoPFClnEOmZa6A++MafIcsRwHZBj\n", + "6ZZbbpl6JmCvQUZ5NhaGLOoPfqKpP+tZz4q/+Iu/mGoLvVhNWe/IEHsScB45xgWN5gtgX9i9e3e3\n", + "d1BcHNjC8vKXv3yKfpf9cvke1naWM63dX2gDXS6z4wSV0ITsuiwX6x6a4At89b67sLDQjRdZyRKJ\n", + "Opku42K8WckhSgq9+c1vjohepv/5n/+5a4v1i32Ad5VLpABHpTpSNuM58sR+ynpzlHjEMDrTUaiA\n", + "z06qSs439gVga3R7Q+JoQ9Ya7zXvg7ZoZiiLVKFQKBQKhcIKsWoWqWOOOaYr8/K1r30tIvoTqi1S\n", + "nIL5+cgjjwxKwQAsUZws0ZycgRg494Z9H3w65kS7a9euzo/mxBNPjIiIv/mbvxml2yVTOCH7dGy/\n", + "LDQQ+OSCmHNzc92JH62FcbpvNA+sN84H5AKYaCLOcMxYvvKVr3RtXSDWmoUtUtbqsHJkpTPoD0sH\n", + "c8VYWr8fjwc6XeIAOIvwt7/97Yjo5cdao3PXkNvq0UcfHVgvbZHhs/0NALxGrlwawbLIWJ7//Od3\n", + "PMXHyxZGaGA8tGe9OIMvz8bfyXwbs3jC+za7dcSw5BNaMdYfKhagYdtqzHxjNbGvTGvZcZkMWz+t\n", + "1TOfzmTsPDoG7fg/66nlCzTQNz/hqS1S9MEeBB9Y42jNoLWOR0T8/d//fUREvOIVrxhYgZwF25ZY\n", + "58uxfxZ7j3NdZbQ88MADg4LhwNUleBbf9R7tvZi1jTXB/cPHnTt3dn3yXc8/8oJssSYp7n3TTTdN\n", + "tYdP9u8as7hEHOAf8411IyuQDdgffFtiwHOqMTjfWCtf7H/QMusZyAlyjizCe68rZ1dHhnlPt3uA\n", + "88aBsYzs7bgYLz6GliPgPFqtf6/n33LOO4XxshfPQlmkCoVCoVAoFFaIVbNIPfbYY919tX2LOMUC\n", + "Tqicoo8//vju1Ok7bOBMrs68C1yDy1piVt/shBNOiC996UsR0fv0OCLKWXUpMMzf0RIBp2M0Fyw1\n", + "PuWDXbt2dRoD1g744npeaFK0Q4PC38gaKZ/RbP/u7/5u6u8+2UfkWbINrCBomsw3Vi/PqS0x8GXM\n", + "4mHt1RnKTZt9xqANP52sgPJYNntbXlwIFa0+swLRjvFhgcNnypoac3Hsscd2fTFPWe0s/Cno09E1\n", + "wAWhXTMLTR+0RWp5Nhqj/dJsveEZaOi2SCGr/B1LFvxp1zTjccZiF3gF0GDLBOPzOHkWcuAo2Fa+\n", + "nG2etnzXVj3a2RJtvx6AJQZ5Yd3ceuutAx4ybjKcY+Vir8kyekML6wN+en9hv4Wmo48+ehARDJhP\n", + "5BnfUdrZT4W+WU+usejqDvS7adOmbv/yrYDb2i+JZ/pdBA3wiz2LNe2s3BFDvzqseplfIjxmblyI\n", + "HbD+uRHBCu0xtH3AM/t4el90NnHGB22uh0o7xub3bPse5Xffgrh+peHqJOYPcDSgq120wKLMeoB3\n", + "yHdWo9Eoi1ShUCgUCoXCCrFqFqn9+/d3J0lOhZz+s9Ns+5NTq7V6W5TQ1lzXy/BpFeuPrQxgbm6u\n", + "65NTvf21fJp1HqTMzwBtgfbOOwU2bNjQ/c0WGJ/SrZGbf9a80BrttwXGKsxnd9u2djmyks9ZDTrP\n", + "HWMj0qbVppAR+4Bl1ct5tnOYOIcLcD3BVjv2fDIOeIcGBu8sH/DcPnS2DoG2Uj19YXHIfN5cnw65\n", + "Mc95li2ytia0f4c3rBmeYUsqz6IvtNhZPiG2dNnvp/3dedUctQqYd+YOWlpfyDHYAkO7ll+WV9aY\n", + "6xwCPmP9Q+Omb0ccMjb653t79+5NrZ2Mk33RtSMBc+GIXGBriq3Ra9euHVgDAfMOTbaWQJvB/DvP\n", + "nq1ALV+9H5ovjJv/O/rM1jR4jAw776D5tLS01MkIa5LPttQ64tQ8NS2+8eDZyG5r8bT/FM/C4ur9\n", + "HD5Aq2vXZvui55o12u51zovoCPzM34xn+jbAtMAP+oUPe/bsGcg5PITnzDv88W1IhrJIFQqFQqFQ\n", + "KKwQVWuvUCgUCoVCYQaq1l6hUCgUCoXCU4xV85E677zzuntZ5yHi/vkzn/lMRPS1efj7IYccMogQ\n", + "cq097mozX4as1pprqHEnTHZpahZF9He9jqagXh21tuyv42gzatDR3vfT3Am7Zh31rdrvOLcK2aKp\n", + "+8Z48OuCf9xPUyOK2mzwGZoZA/1cddVVg/kBzjBL3+985zsjoueffSkYL3WfGCf3265Vt2fPnkFd\n", + "Lvs4tXUaIyKuuOKKiBjWiALwhX6oh0YdJ9fDeuKJJzofCMZJ35lflcdJ+yzfGJ+hhbHOzc0N/AS4\n", + "42ddwENkyD4jPDOrzZb5ClA/693vfvfAz8S526jjR+0s+3F5nNQ3o+6fc6TZT+vKK6/sZGtW5A9r\n", + "lPls6zZG9H4a9MNe5Dpx7BftXnbppZdO0W2fF+cTY/7POOOMiOj5Bc/t++Jafq6Xtn79+u5vtEW2\n", + "7FMJ3cgBewv7qPc22rlOHHzkua1fHH+jrefIvm88k/lnnPap9R7GHMH31lfK/ojQwjjhsWsnEq3o\n", + "Om6OPIMvrll3xhlndDzOsoWzRqmd2ebBaj9bdlnTzg3GGPjeJz7xiXjPe94z9TfvF6w5anPCQ9aB\n", + "91PkiPcL/UMLc4sf7KZNmzq6aeu9xX1DC+39LncEqWu5usrHrl27Bu9c1jM0OOIPOWZPz1AWqUKh\n", + "UCgUCoUVYtUsUmvWrBlkHnX0Qds2otcq9u7d2510M83TGY6JBKG6M+AkzsmTzK9ktH3Zy1421b7N\n", + "6eHoAEcsOFLC43W0SRbFheblfDLLy8tdX/CME3eW0woQrYEW6Gg2TujwxRp7G1npquaONvGzrUEx\n", + "brS6rAaZs84jA632y3w6AhA5sBXDuUlsHTUt8Jv+0FxvvfXWrmaY+4YW5oa+HYUzxtuWJkeQte1p\n", + "Y60UwAfmBt6Rk8lZ8/0MZDvLtzY3NzeoKM98OsLLVk3mz5ZXAM95ptvbEtr+z2swyzkDnGU7q2xg\n", + "6xIRde0eAA1oxI7CdR0v/o9c8Azy7Lm+HWMZqw/qvYi5ceRoFpUM7cwdWj/ts1p77X7hmnoZyHnl\n", + "6gnAlllcuERSAAAgAElEQVRoIEKVPEpuPzc3N7Byem3ZWuh3kNeRI4ydtd7Rz/Pz84ObiyzPHnLu\n", + "aDyQRdYZyFUr2/DB0ZuuomFa4I9vVbK8g9BIHj7qLbZ1ZRkffGHes70ri85EJh3N7uhOsGfPnvTW\n", + "BHjeZ+VEBGWRKhQKhUKhUFghVs0itXv37oEvhevdgdYSFXFAm+ZE7ezArr+FZQYt0KddV4mn7ldW\n", + "Dwva1q9f352UnXMF8NmnYLRYa17QwHjxd4I/9ilZu3btQGtBg3SNMGs7PMtZwo3MR6rNyu48X87F\n", + "lNU35O+2aGW02EJnGlsa7KthGQLOfWQ+2YJlPz4yhU8mk4HF0ONmvqHXfcMHaIAmW0FAy1+P020N\n", + "fACBawqaj1nOs7a9LUTOEwQY31juobG+x57VYiz7cNanrYDOq+baW27PZyxVWEP43FoN7WfnCgVe\n", + "u/yd9s55Y+sZsK/Rli1bBpY0W+jQ4llLzlxPn7OyTQP7Q27cuLEbj7/rig0veclLpmggYz3w/LIv\n", + "+tYBtNZo3xpk68I0znoXmY/szd6jJ5PJwOqVzWObF6796fckcBZ/W51bvnkunF8rq1vX+iW3/WTv\n", + "OmjCosv32hsSrwvotD8r8Dvelk6/X72/tjcl5n3mz2l/z1koi1ShUCgUCoXCCrGqPlKZZuYTpk+L\n", + "W7Zs6TRoa6v4ftAnmjR/t4+UI0XwdUA7smWnPXk7+7H9Dawx0B7asrpPnLT5jNZr7WjHjh2DZ8I7\n", + "a7PWRNAQGLf9NezP5dN9a9mxJuTveo7sIzUry3br+xExtJK12pStW7agWcNwpXR47AzgwJYftKWj\n", + "jz46zZoL+I6tgsA+UtCELHqdtJadzK8CeP7RnFlH1khZN55TPpv2dqzW2s0H1zWjT+Y5qwrvDPdj\n", + "Y4aH9omxpdHtLUvMs2lBLpD/22+/fap9a5GyVY+fyGLm22H/Pme8Nu3wpY0gdAZvZ5t3VnjPP89m\n", + "nOaD+/cYInoZ8h7Fd+mTWwC+69qrjmJjvPZHAu1eZR/PzCJlntvfD2SVE5AfW7z37NkziE73nupx\n", + "ZhUhsooPIItmjRj6V9oqZIuz4UzumRWI57C3s7+07XkWz2a+4YtvHDKrkG80APLlDOl79+5NeWZL\n", + "m31lZ6EsUoVCoVAoFAorxKpZpNauXTvw9M/u432KXLdu3WiF64jhSRsNgWfZd8B3x9zfZ9pUG73m\n", + "O21rAozLp3nf2wPfdaNhMiZXop+fnx/UbXN0HcgiR+zbAKzt23+r1VBttXBeG2uBmZXHz/D/wcG0\n", + "S7QQ123LIgjtj2B/t8w6yk+sRYuLiwNrJ3AElOXGcJ4sR86YluXl5YFFLYs24plYWjN/nMy6Zmsj\n", + "mEwmA5653p37ck6btm7hWHueyRjHaIEnmb+IZWuWNdXr3/nroNWWijFaDPuOOc+YLbWZrxlo9wlb\n", + "jBy1iCXVUasgq0mZ+dLYx2xpaamjL/P1crSuLY/AtNki7Tlq29On6zu6L++P/gm8p3lvGpNd95FZ\n", + "OVgnjpj2s/3ZkcR8v+WLI2JnWbt8W2S5Ny1ek1iixtad59+WOs+/93JbDc1fZNQ+Zu2ZA/ida95l\n", + "a9coi1ShUCgUCoXCClG19gqFQqFQKBRmoGrtFQqFQqFQKDzFWDUfqQsuuGAQWeM6PVmtteXl5S7i\n", + "hbva66+/PiL6mlK+q3YklPvmDth5ZLj7veSSSyKir0G2d+/eQf4S10K76KKLpsbD/x0h4dpJ3Nva\n", + "Z4Q79Ouuuy4iIs4///w06sI14s4///xRftiPhZpS1FpynS9HWm3btm1Qa4+fzicFLdS3csZvR/Mx\n", + "R/DcERV8b35+vqud9K53vWuKTt/DA9cgs38XNLjWGnxBLtrIK8bpGpH2jYM/RM5Rr44aUfbbsV8W\n", + "Y21l3f5ljOeaa64ZpYXoGuQGXy/qW1EPzb4yfI+xtrRYlhxtC8+ZI/tU2QfKc+Q17bm9+uqrB7UT\n", + "bXF3LTTLrnnOZ2hhHWX5Z9asWTOotQiyqCtooR4mPGZ/8ZxSmw0+2v/tkEMO6eQBWWQNAeSWZzH/\n", + "1FqEFvvzOLoJ2WVNtzLuSN9PfOITU3xx3Uev/7aOY8TQ18654qCdfXRpaSmNvqPuI3yBd6aJ8cBH\n", + "6r65Lly2js4777yBTxDPgDbXt2PeM38/9lGvC9ei4+/XXnttt7c4Yti57a699tqI6OU88+f1O/rC\n", + "Cy+c+jv9t9GvXnOOlAT4KVFr8ayzzppqx/ecK8777liUZPZu8bsrq82YoSxShUKhUCgUCivEqlmk\n", + "2kgOTqDOswSch2nXrl2jVcYj+tOqNe7jjjsuIoYnTbQcawvkWbHVqY3uIdqECJgs4zI0uCbWWBbc\n", + "lgZ/39aBxcXFjifkgeLzUUcdNdUWPnHibq05Y307sy/zNRbNYsui8/xkmalp7/wpzmwOn+Abc8MY\n", + "zMf22XzHtdGAc3c5CiuLGLSmu3///jQLPjKG9moagCOrbHGx5tZGJNra5UzlzAEySwQo7RwR5rUI\n", + "7Xx2frW5ublBjpmsTlUmF878DSwnzhE2ljfHmmXmC4rsOO8cc5bVfUT+yU9HVvsxWbS12PPrcTrC\n", + "yvXuADQ407MtNxHDdU+uHvYuj9OWKK9pYyx3XJb/x9o/PHzuc5879Xe3935oq4dpXVxcHERu2bLi\n", + "vcefs+hF5oIKGM4/Btp3giPezEvm0Tm8svWUraM2Ss10wDvo57vekxg/4/H7I4sKBZn1qP2b5cM5\n", + "+jweWws5N/jZvB+goa0nm2UEQP5ZF1nUZoZVO0hF9AxhU3fJCGAz5H333dcxnXQFwMm93vjGN0ZE\n", + "v/HfcccdU+1dloFiiwiaC2Kyae/fv787vDgFAWBS2Cig//jjj4+IYep7h7MSTs/ifvaznz3Vfm5u\n", + "rjswcmCg+KwFwJuXrxm9edkE7CRy7Vhtqs7m0e3ZKBgDLyF/j5IQ/OR78KN9ebnkCxh7wUUMzb++\n", + "uvJLmmczRjbSrVu3Dg4vHh8/aec5Yj34oOjit6AN7WccyKIPRmx8yCIbJ0kNnRaE9vyEDxwY/OKd\n", + "n58fJGvNSicBxofsskatvHhTZ90dbJP2S4k15PB39h7mkTV76qmnRkSfoBcwZ8wR/GPdtS8Yv8Sz\n", + "cG3g4sx8D9qy1B2spwceeKD7n4sKM+/8PPnkkyOilymnKHCiQkoKZUmUmcu21BKy4pQJVhgpEcM8\n", + "/uAHP5hqbyWBOeLg5TlijHv37u3GlxUtdlkq9n2XdfE4ec8gm8y/193i4uJAkc5S8diVwwpDdoh1\n", + "CL+TzEb0cs74eG8ee+yxo306zQNyzfizQ7KvFa2At33wN4wc8MMlgpw+Bn7ATx9ePQc+RLbwnmWX\n", + "lzElbQx1tVcoFAqFQqGwQqyaRWphYWFQbsFlNwDaH1rCSSed1GkA1qT4OyVQjj766IjotZx77rln\n", + "qj3aLadbTqRoO7ZkWAtsv+vrDtqiMXHy5rtomqYF7Q9+oD2OFVxFU0AD5ZTvNPs2YZqnPsU7QSUW\n", + "jLGCu9awZ5lFram3pS0ihpqXr2fNR481op+3LPU/4HNbbDWi57UtL3aMR94OP/zwwdWLtV/mCM3L\n", + "1hEnebTzdabZz83NdbKXXTPDcxfxzq6NXJ4Iywvt3H5paWlw3Z4lQfW1CesDWiw3WVkX2rcWLBc+\n", + "dVFy98042Cfe9KY3Tf3/7rvvjjH4yuP++++PiOk17ethW9ZswYYf7IfWkrOSKFhgkJdnPvOZg32L\n", + "/2ENRw4c2ALguUtHuT8AX7F0bNmyZXClDeAL48HSnCW09fdf+cpXTo3Fe3prlXWyZ9M963rV1g5o\n", + "QeZ8A8BYwPz8/GAdQ1OWkNlO99m1qpMr2xrd9k8b76G+6gN2Q7F82Gps/tqy09LO3sP8I4u8k3xt\n", + "6PeCE9b6NsVBL/ycn59P9xb64D2XlfzJUBapQqFQKBQKhRVi1SxSi4uLg/B4TrmZEyoa/datWzst\n", + "LNMY+b99H3yq5xSMtoAlilOzrQatL4qdAG2B8P0z2h0nbp/yrTVAg0Ntwc6dOwdpGrKCjS6sjCY2\n", + "ZmFifO3/bclpi2A6JYIdfLMSMTyDcaPNeJw4ziMH8BHtr/WHssO2NSLz3A6JmY8RQNOnPRrM9u3b\n", + "B5Yx3+3bUdWFRF3M02U87PfV+gPZgdnzT5+2VECzrQFYFly+xU7nYHFxsXtG5kwKoBH5tpO6+WLf\n", + "D3zMsOy1WqPLkthHw7KIxc19UUjXBXTZL6AZn0r7+bV9ISOmwQ7dfLYFAlnLtGOe2Zb98fzb6uuS\n", + "KVmZFcZpfx7DKRh+/OMfD3wngZ8JT3mGZdS+VsgmBaPtU+Mxtr/bItXSG9GvNWiwtcPrnrGxjsZK\n", + "SrmodJayJiuYzLxnKQjY4+CfgxUieqsPbZy2wWvVfIKnyJjbwz/7ZyHr7Z5uHye+ax9Y4LI2LomT\n", + "WVNd/uyQQw4Z9M3/vM9xfsiKwBtlkSoUCoVCoVBYIapETKFQKBQKhcIMVImYQqFQKBQKhacYq+Yj\n", + "9e53v3tQZoH7VZfCoFxFe4fusilXXHFF12/EMHrHfhaknyd1vvPwOAkg6efPPPPMiDhwb0ufPMul\n", + "CignwDN9v4w18CMf+UhERJxzzjkR0d/9Qjt3yTynLSnh/ChO3kn5GVLhc79M39DG3ymFQXvutuEz\n", + "cwAt27ZtG6TZd3kN7qEpbcB82mfI47zhhhsiok/5D1/wHcIf7IknnujKLFAegr4crWUeulyBozj4\n", + "PqUTaM+Y2nb8Ds/PPffcqTa+b3eZFeaf9i4VAVw6ZefOnYPcLMwTJWIo+YG/hv20mKvPfe5zEdGX\n", + "/MAfhcg6/NPwCfnoRz8aEQfWHbyijRPnQQvy4vUPkEW3d84054y6/vrru7Ip/M/+eqxvyrggi14P\n", + "9rtgjij7BCw3+/bt62SL+bevkMsXMU72IuB1RHvKm5x++ukRMfTzmJub635nn6OEBz4+jJP8Qqzv\n", + "trRJxDD3EfsKc8pYzzjjjKl+22hXxuG9xYkp7RvLnk77LMIO2qC9XXfsuY4Mp1wNa860OvINnjP/\n", + "+FCxB+Hfg+zeeOONEXFgHdkHGDDuD3/4wxHRyyJwzq62FFJEP0dt3qyInvfIxXXXXdfxEL9deE3u\n", + "MXyJP//5z0fEcI0CeE3f8JH9gnUDH+Djxo0bu9JGvBfpI4uwZc3xzvX68ZqFL37vtu+ltrRZRP++\n", + "wE/L7yDmuUrEFAqFQqFQKDxNWNXM5o5SsgUD2GK1YcOGQdZn4HxBttSMZWSOGGpFttQYS0tLacbm\n", + "tk07niwqCTgrrMvdmJbl5eWB5cxRfMBlRmxZMhxR4/wgbWSNoylcZsV8gh/0kWXsBln2dTSx9u9o\n", + "Zc6TBVwKwZYneO78U26PRaaNCrRsOTs6spXxBTifVBYFB807duzoeORM/cByArBQWNv3Z2d+H8vH\n", + "ZasPNGSyiOWKvpHJLDrJkYNtNA7wGjKyYubAVpJsjpwR3xUDIvr5gWfeD7x3wSdbRW3BAuYXfN+3\n", + "b98gas9ynln3gOfSz/a+MVbFwGVjQJap2xYm004/rHGX0HH7J1veI2LI46zYOTx3lm34wZ7Ujgke\n", + "w/Msa3ZWCJtx20rqygnmZzsnzCP0Z/nzTEuGbI6c02psH6Ut69iWN/PFORB5RrYX+RaqvQGyLMJT\n", + "fjrC0ntXhrJIFQqFQqFQKKwQq5pHyrlMQJbxl9P0pk2bUu3F96L2L3Df9suyBmpNq81DYeuXc1S4\n", + "EKb/n/nMWJPPata19c3ch8fhHD8gK4hpWp1Ft6WdU76tP7bAACxQzvSbzalpcJ6ltn2WkdeFXYHr\n", + "ODJnY74eLSxH69atG2gvHic/Le/Ac2FLlDW11qfA2lyWeZpnQIt9A0Fm0QVjVkbnjslkkb7wL+FZ\n", + "tgYDa97OPt3CxVUzPyyPA75hocsKC7fjbWkY84NzcV37ujhTvS1Sbp/5ko1Z5b2GzBdbUixb/J2f\n", + "zk2UFdBu62xm8wnsv0Y7r1HvD/TrtQpa/tmabR7al9Z9ex05t5vn0PtrW5PVz8jqf7rOITR6jY7d\n", + "ULQ/27G6CLl9RrOqCUZWIYLvZ8Wh2znNLPKuNWnaLYuuFwts4fJZoIWrMdjS+GRRFqlCoVAoFAqF\n", + "FWLVLFKtRmPLRVYPjZP2E088MajHA+xXAjLLgrU+a8kHw1il77HP9ttwBAngRG5tN4veWlhY6E76\n", + "9GXt17TAY2d+zvKJQYsjJdoTu+mC7kyrt7bH953ZGbgdGogjCds2zsjcWjPHkPlG2MoEjfaNGcsm\n", + "bWtnlnXbtFsjzWSxfbb9sTK6banL6iLiY2bNLPM9Wrt27aBWWGapHKsI38LyklkRnBE9opcJW3Ey\n", + "TRnYCphFkjkKNPOha+mjrWvtuW/Lg/3aMgs2aGnOasS5ooF9J92XrUaZ9d1+oAsLC4M+gK2d9pmy\n", + "vNgf1n44RtvO2cJNi60j0OLoM0CUo3l/MFm3FQiYFvsAeY6ym4lZ/q4R/XvNPoCOygS25NmifTAr\n", + "YEtzNqdtX943sz3G783s3WX5an31Mn89W2Zpl1mkjbJIFQqFQqFQKKwQqxq1Z23XJ3FgL/82EsIa\n", + "oSvLO4IsixThxIxW4FOt+281rlmndEf0ZFWrfdJ2zSjTsry8PNDWZ0WqOKIh8wXIrErmr39vacj8\n", + "0lwpfJYfiy10B7PUMD7aWFuzpu4oRtOcaeq2viwtLaWWF+h0lEnmx2Z/NFsFPNbNmzfP5Ll9Wxyt\n", + "l/ml8T3XQxyruG6raBZtyWf7iGT5dmwddLReK/PZGsvWP33CD9plvmHeFw7mY8nvtpxkfknQ5tpq\n", + "mUXKloqDVao3X8CsKEfLTRbl51uF9v/eH7JI2cxH0pbabD8BLQ2ez8xqY3+bzPLmmxBbycyXubm5\n", + "Qc1U5z8D9lvye8P7nX3LHCHX8gWrnn0ksxsMz9GsSGPftnj9tXzJouzG6I4Y+kTNquXq90krf5kV\n", + "MMtpVrX2CoVCoVAoFJ5mVK29QqFQKBQKhRmoWnuFQqFQKBQKTzFWzUfqvPPOG+SbcZ0r6ttQx4d7\n", + "y8XFxe6uPqvLB7gD5Y64rREX0dcUIj+Ic9bwmXpYbW0m+w+5ptTZZ58dEb3/Dc+AFvp2jSDaZ/f2\n", + "1PI7//zzB//DwuhaWIwzy+wMn6idRG02RwW2EXIREZdddllX3zCLjOEztFx88cUR0fsbOCrniCOO\n", + "iIi+jpv5CN/h38LCQsdD6s/ZJ8IZmi+99NKI6OtVOSLEUV70Dy32c1laWur8h2hLHSfGad83/HKo\n", + "h0bfzr/jGlTUw2KOtm/fPshrw+ePfexjEdHLFshy9bgGoX2vkDfXT7z44osHEa/OzUJNScbZ+ni1\n", + "7aGNWmvUN8tq7PG9yy67rFufzvDO/LKmWEPIrv1QXEeTWpvUcbNctf5vzD99OzIIeJ+jb/sU8Zn2\n", + "7HVnnXVWRAwj8fbs2dP9zW3x14EmZ+KGL661Ce/plzlz3Tf4sXbt2oHcuy00mIesXfZoZLHd/yOG\n", + "PjLwsd0vkAPm3zzk3cL4aMez4Bdr9IMf/OBUO/sQMRbav/e97+14xfw40z1t3/GOd0z15dxdfJ+6\n", + "n/CRPFWmmX6uuuqqrtYiyGrosf9bFu0zxE/4SI1L+0i1/lvUK2Q+Dz300Kk2REQiL55/Rzu7Lh51\n", + "Qv0+an0oXWuR+SRK2f6byA97V4aySBUKhUKhUCisEKtmkdq7d+8gY63zKIExTdTReCCrnQccheNs\n", + "uY4YyrJ1t9/NMhUzPvp0dEJW34p+OBU/9NBDETGMGJlMJoNcGo6AadtGDCMAMyuSa3I5oqatj5dF\n", + "lQDPAc/EEoXWaz65f88FcjEWtWUN1HWd3N7Ra86ID+iP/7dWhiz/FePMtFfT4lp1tqaCdk7R5qDv\n", + "sMMOm2rLOOCDLZdZXpzMgmm+7N27t5sPR2NlWYJdv4/vZ7mrGBvtof3II48c9J1FujoizBFy8N77\n", + "hL/vXEZjdb8c4ej9wjzPaoQ5ehPw/6OOOioi+v3i3nvvHdTzdB6gLALKtDMnyKCjmoErCBwsSstR\n", + "zrYwm/fO3cUaziJI27Vrnhqu4+e9KKsE8aMf/Wjqs3OEgbYOJn1mtVady8r16rJ8fdCOdZF27bpw\n", + "Xixb9by3zMp5lu3RvKPo15adlhbm1XnEkDXgd5XfWVmkutfdunXr0goetlg/2fxRoCxShUKhUCgU\n", + "CivEqlmk1q9fP7BIoQ1YIxmrhp7VcXOeI7RWa8kAfxy0OvrjZO3TLpaYubm5QRX7TDNyllT7NAD7\n", + "I23dujUiek3DfFm/fv3gbjfL+uuq39bUshxYzoQ9ptk5y7OzILtvzzcaiPMQgaw+Ihpeq2XYz8b+\n", + "CKYfPrX+Vu1P59dyhnTkYffu3WnOKVsSs4zM7pNxwZ8sZ9jy8nI3TvtTAGve9jczTeYDc+CcXmD/\n", + "/v2djDhbsi1MPNsyZf8rj5P/28LXartZrSyP330zfvsAes3hf8IzDz/88IjoZb+1Nlju4cusmmL2\n", + "/ck0b1t0kJv169cPrB7O54N/SpZHzHPiNZplCIeWNtu+27KvwWusp5Yx4Lp/fM9+SoDvr1mzZuCf\n", + "luXRynKfMb/AVnSA5WUsp5H97rJcXNlNRTueFq54Ae28L9p1YWux17H3C+fsY3z0bfmy/5qrTrRj\n", + "QvbgLfIATb4VYl+0tQ9aLF+ZBXz9+vXpzQv8sdW4MpsXCoVCoVAoPM1YNYvU/v37B/eRWfVv+zns\n", + "378/zbTKydLRepygfVrlrpsTcxbl0T6b9tby3Nan2cwq4r4fffTRKVqAad+7d+8g03KWkT3L0Jq1\n", + "z3ynxiqLW3O2lSvzkbLPg2tNgawe3NjY3DcaUebbY18g+2OZFmvkbbb9zJ/C2lpWp83yg4UB/hzM\n", + "d8QZer2Gsoz+2fyP1VRsafdczM/PpxnZ3daWF2C/DeDs8/DBUU3tOLy3sP6zvm01pr3lBetzFhXY\n", + "ZsK2hcH+SFmtxazKQLYWsUqDhYWFVLYcAejahO7bGfwzKxNoo6mdFR1Ar32caO9s4rZAOoJ01n7a\n", + "jmdWHUfLrOcCWrwOvP7AM57xjEEkoGkCrYV5bBymlX55Nj+Zq5aPzsTvLOheo/CWn8xZti9aXrJq\n", + "Hm1ftv6ytuwj5Vqsma8c8K1Uu+7cFtiHMFtzGcoiVSgUCoVCobBCrJpFaqw211gkFG0jpk+92YnR\n", + "J2JH5WR3+z6Bc4J3Zeq2f2ucWSRDVt/O4K6Y9vbbcf/79+8faDFZLSn7FWFJyWpE0c5jsL9C2weY\n", + "VQsJWCviHt5WEGvDrho/VkuJvh3x8l/VAj02V2RvLZTW6lwjDFrsAwVcWxHNDTnI+LJ58+aBT1Pm\n", + "82CfkSwiyHNjvz5rk4cccsjgGchQVmvOspdZDegPvjkyteWjfRtMv2XR1d5t6c72IvtSjlWib3OM\n", + "tXRm68GatOfEVkNHuWJF27Vr10w5d/45gz7xT+HZY36J7ec2UmrWus+iMTPreFaz0uuitYzb2mWL\n", + "hNcDfPI8A9o58hbZtH/P+vXrB7XzxuqVtp+zyLrMvxM/X+AcaGN08Tmr++h3rq2H2Z7vPWwsKhTe\n", + "OYIYS5Qt71kUq9+PwPsJaG9wgK1ajjT2ODOURapQKBQKhUJhhahae4VCoVAoFAozULX2CoVCoVAo\n", + "FJ5irJqP1LnnnjvIveFcF9TxoX4W95aHH354d79KW+rbXXLJJRHR55jwnS13otRao29HPJApmpwX\n", + "V155ZUREnHbaaRFx4G75hBNOmHoW96+uKQQcEcgzqYdGjSDX/eMOmM/w5UMf+lAXdQjd+Gw885nP\n", + "jIi+Xhl1mRgXPCcvDnfm0PL2t789IoY5Ph555JGp53zxi1/s6M7yRvGZ+kau++YID+7tqZ1Fe9/D\n", + "t/0zn8wPssWzXdfvT//0TyMi4vTTT4+Insfw3r4V119/fUT0c+rorpZHyKLrPjqiDN4jW65Bxhjs\n", + "vwdfzj///Ig44EuFL4t9Glw7jT5ZP/zE5wnZfdvb3hYRQzmhf/hy3XXXRcSBuoL4dDkSiPlk/qGF\n", + "eYRWfx85P/PMM6f+zpqEBqJcb7zxxsGacy6urKYgPIePrGnmirpf8JwII/teLi4udnU5qfkG71gf\n", + "rFm+i2zRN2vU9S2hzfUT7b+2b9++Ad3IIuscv5q77757ihbaU9/Q+cmcbfvyyy+for39P/NC38g5\n", + "dNM3MmnfF+obIi/OkUf/rrdKjcu5ubmOZ54v6KbuJ9UjkDF4jqzxXmG/4O+0Y85Y48jAaaedNvAr\n", + "Y3ysvS984QsREYN6ePYJZZzeL+iHvEw8B/5u27Yt3vrWt07R7bqv7I833HBDRPQ1CB3FCB8ZE+8X\n", + "1pH3Kt4fGzdu7OQWuhnX0UcfHRH9HLhv6viZf46cZE0z/+xVbS5B79G8/5Fv+GIfWOYzw6odpJaW\n", + "lrqXMsLIguInsBPq7t27u4m3A56dhGE6G6PLuAA7OrKgsjQCrXMtzHcBUCbDyQ95lpO6OTmkFxxC\n", + "OUaPk7I5/J3xOFTavAbHHnvs1P/N1/awZOdfF93Mwrb9osic8RF+Dto+DLZ8YX7tLM/fs2RtzImd\n", + "Te1UDdhQeCnOz893B2uP047LLgAKXPSXeffLC7Q0Ogw/cwZlzfEzc8I+5phjpv7uUhGW9clkMggK\n", + "yNJVOITaSUJ9UGZ92SEYPtmRNmKY3NOOzcDKG3LAC8Y8dyi2Q/zb9eR170NXVgrDJYGyBK5Z8sC1\n", + "a9cO6LYzNPOXlR+ygzPfZ7yWXdZBGzDjg4D7dtJf+OU15wScVjAtZ6zN1tHbBW5NSxZCn6UkYT9x\n", + "gkvvL4ceeuhACWG+2jJbLY0uFZY5PDvgwf22a5r93HLBMzK+OBAsKxnjPastyxIxvUZZY/TBgdhp\n", + "MYADaVyOyPIFzT4MrV27NnU2d+odv8Nmoa72CoVCoVAoFFaIVbNIRQyvALKixZQQaMs4ZMne0LCc\n", + "8j1LOZCVHchKrbzwhS/snnviiSdGRG+S9OnV1hG01bEkZRER99xzzxRNpn3MCgAPXWQzC62nL5/u\n", + "XXVJDFoAACAASURBVOTWpTZc3Lblp0NcbZnKCkv7OjVLSMicuiSArxsi+ivNLMTe5Vp8lYO1i7my\n", + "FfDhhx+OiF7rRc42btw4KJtgLQ/NlGd5juAb/4dWeO91gTa1du3agaXAllfoRPsDTlkAuPpxORM+\n", + "U1KpBTKTWSCBr9s9HgNaLFes1Tb829coY6lTWngembNsXTB+h+wzt23/8Ah+QBvj5JoFQCsyl1nb\n", + "gUvwtPKXpW2Ah1wD2WoOXJaD/9uaAGx93rhxYxoqD22tpaCF5QVafQvh6xjQpmyxZS0r45UlHrVM\n", + "MqfQ7ELEtjJu2bJlUJQZuG+seu2eEtHLltcocpJZWVvrKPui053YegOcgsEWt2y/sLV5rBwasmWr\n", + "HuvBe5dvRXyz4zlFVp3iZ82aNQNZdOk0W3ezRNZGWaQKhUKhUCgUVohVs0ht3LhxUM6CkzRaIkBD\n", + "54S+sLCQFn7E94OTJKf2tthwi8xygXZg/wto27t3b/cdrBTWDPi7HZ8Zt7WXrBSISwCAxx9/vKMX\n", + "bSe7w+bkfdxxx0VExA9/+MOI6Hlufy0+owXYatjOkUs7uFRMpr167rKSD06W5oLUrWaHRYl557vM\n", + "o3nupHaMK6PFpYfo9/DDDx9oUqYXDQo+efzW/v1sa41tQjuewU/kF1iz4hlOvAjggx3e4aetI61P\n", + "nh1UrYnbf9HaoNvbggef0Ipb2YUuW+jg/ayEtU606DVnjdV+Xe0c4fPh8hPQ4mS/LpTdJrdsaQPM\n", + "jf0h9+/fP/gb1m7otGXZvpMOoIHHWaJKj/GJJ54YOOxncCCQZeuuu+6aonWsVFaLNuloVjDdnzP/\n", + "TrfHooulEv6wH5iWHTt2DIprZ+sCWfJ+1/p8jY2bPYg16iLfEf1+b7p5lvd/rx/TZCugE1lDG/tK\n", + "+95F1ux/x3cefPDBqb691lxA2/titnfPz88PeOi+nER3lux2ND6pVoVCoVAoFAqFAVbNItWeUDlR\n", + "cwc+q/zAZDLpTqe2MHGfbP+Z7G4XrdDagX0Kxujnu/bd8bgcnQRmlZ/ItGIwPz8/KKLLd/0saEVb\n", + "wWJjjaMdX0sTn235aseBZmDfN2uv9sugL+bXViM0b7dzeYaWPmSJ/6Fx2Y/JPiPQhBaYzb+tIkce\n", + "eeRAbl0ayOV1rO04gsbWlUwT37Bhw8Camfmd2FrksivAUWnWcu1r1tJm/wiP0xYIl3Exzxkna9tl\n", + "ndr2thghI44iAviO8D1HSmX+XfhzOI1E2z/0mRZ4ajm3BROe07ct1QArA9975JFHBv6UAD5gLR+L\n", + "wm0/Q2tWcgY4bcgznvGM1IcFuPwM1mS3px/2UxcKtjWFtbxv375B0XLPP+OynGQ+dfZj5FmZD+bu\n", + "3bu7Puz7ajlHpkzLWCmkFt6jsfi07yOn/7B/kmmxrLqUkt91meXKJYkihkXtXQrH43ShaL9vvKeP\n", + "FTOnfWYdd/murGh5hrJIFQqFQqFQKKwQVSKmUCgUCoVCYQaqREyhUCgUCoXCU4xV85G66KKLBj4E\n", + "9iX5+Mc/HhF9ivj2jtRRe5QToBSC71/9mRTxpML3Hbr9fUhXTymEvXv3dvfM7ptU+JQ2sM+Qc1Vd\n", + "ddVVETEsKcMYuZ+GNtqfddZZA58wR0JSIoS+M38baKGMx7nnnhsRQ38k+xRcfvnlXd/OTG6/qquv\n", + "vnqKL/CDiBJoghZKPjCnzqeCP8JkMul44vIDziPk0inmOXC0Ylb2p40QQW6RRUphOMO5/dighVI7\n", + "9lvx3EIL7ZeWlgZZnl02g7bILFF90Abt0OLSSbTDNwTfk3aO7OtgvwrKLLhEkOcIIIvwnH4cWYXc\n", + "ffrTn+7mH9g/z2WZaO8IU/vKILvIYrZPrF27ttu3sjIb9umgtAXrwj5CzhDu0kljY4UuZJH1jD8V\n", + "ewv+NMiF5dw+Z/DH5bA++MEPTtG4uLg4kFvKz1A6xzmb7CNHe2QROLrPJaXg+2QyGUSCel343cL/\n", + "7SNnvuBLwx6EnxZ+XND+oQ99qPPxYbzOgci7CL7AL/udMV76hnZnTHdOrE9+8pNd2RRHHcOXtm3L\n", + "Q/vOOnobWlzGx/m71qxZ05Xloa19gpFJy+4ZZ5wx9Wz6zvY6yvi4okS7R0O3S9vYZ4q5gpYMP9VB\n", + "ajKZ3BURP46IxYjYv7y8/NrJZHJ4RPyfEXFSRNwVEb+5vLw87vlYKBQKhUKh8N8YP61Fajkifn55\n", + "eblNl3xhRHxpeXn5islk8v6ffL7QX9yzZ88gC3OW08hRaw8++GB32rRlhc9ozuSkOPnkkyOij9IB\n", + "jk4jc60LooK2iKszrjpiw7WEnFvDuXscpdFmbG77A1u3bu1Ozvfdd9/Ud7J6hWhMzmRMxIyf5UgJ\n", + "5qgda5apHTjCx9EljPdZz3pWRAyjLZgTLFf/+q//GhERz372syMi4sUvfnHX1lYL11xzNJu1OH7y\n", + "PecoAfy/nUNbP3hWazmL6OteZTyHn0RWMceWXWjbvHlz14ZoQ88F833LLbdERM+Pl770pRExzGkE\n", + "DXfccUdE9Nn7TznllIgYyua6deu6eXUxcucoamtmRvTz6jxahiNvWU+t1uxaWdCSRQQ5CzJ56OjT\n", + "2cetBbO2xyJrbUkyvVm9Mv5OMVcsWM6v5+jXNk+V1xzjQKZ+8IMfRERfqYFnAVueiU7Lcv0xNiwd\n", + "CwsLHU+dcwirGP93niCvf2eC59nw3nsdNN53333dfscekkXtIVOME/45Hxv8IC8XNFBn0/3v3Llz\n", + "UBgY+ixbfHbU2QMPPBARwyoL3tPhM+utXdO0/da3vhUR/fvxda97XUQM15ytOV6zniPXJmQsY5HY\n", + "fl/cdtttU8901QTndHrRi140RQtrFjjqEdnev3//4GzhiFqvY1uPMzwVPlJ2vvrViLjxJ7/fGBH/\n", + "61PwjEKhUCgUCoX/z+GpsEj93WQyWYyIa5eXl6+PiKOXl5cf+sn/H4qIo7Mvc2olcy2fbWXiVMjP\n", + "DRs2DHyBAFo+J8vTTjstIvpTq61Gvpf/5je/GRHDjNiAz+vXr++0OmiwtcM5N17ykpdMfTYtfP/I\n", + "I4+MiP4EDu1jNYVuvfXWqe+gtWRVrp0N2TQA57Li9O98VBFD68esmnOMA83JleWdL+fb3/52RETc\n", + "f//9ERFx4403TrX/27/9266t86SggcNzW3UYD3yjvesjAucLav2AbNVx1uAXvOAFEdHzPMsL5Pxa\n", + "0Oz2bRZeLEbWsADr4nnPe15ERLzhDW+IiIjvfve7ETFcRzzrpJNOioiID3zgAxHRWz75XksLWify\n", + "ah9CgBaPjPIsaldmObCYi3vvvTci+jXb1sNz/jgsCvDHfOH/jOtlL3tZRPQWN88ptGFFg2bn22oB\n", + "3exzyLvb2mcI66GtQ4B+4CM0LS8vD2oEuuLD7/3e70VExM033xwREd///vdHx4msss9keadox9o/\n", + "5JBDOtmxnw1tnOkbmbKljv2C/zNe1qgt+3z/la98Zbd2kDlbgXk29DNHtlAD9gf6++Vf/uWI6Hlv\n", + "S93u3bsHuffgi/dNV8iwVdR7EeNn72ddjFUrYK/Fiv/rv/7rERHxla98JSIi7r777gHdEcM8abbg\n", + "AefM+853vhMR/Vy1a5q/sSZZQ1nOPsbBjcV//ud/RkS/dm3xhDb4c/vtt0fEgTVqqx5tXTsTerP6\n", + "n8ZPe5D62eXl5Qcmk8kzI+JLk8lkanddXl5erlQHhUKhUCgU/mfFT3WQWl5efuAnPx+eTCZ/GRGv\n", + "jYiHJpPJMcvLyw9OJpNjI+KHY9/9l3/5l+40uGXLljjmmGO6U621KVfPPuKII9K7y2OOOSYi+tMo\n", + "mgOnX9fxcfSS7699X4vWvX379q6t620BNAX6oM+vf/3rETG0AljbdX0ka16PPfZYp6XwE60my+CN\n", + "ZoL2wjOJiAP294H3Y7SghTjCh76tvXL6Z67gD1qRLW8vf/nLIyLiLW95S0T0mvq1114bEdPaEX37\n", + "J+PH3wAwDuaOOcMiYcsefLalYt++fQPNGx6+5jWviYiIO++8MyJ6WWT8AO0HXsM3/JRskWrr3qFp\n", + "2YcHMD604X/7t3+LiF5zxPcJUJMRfmB9xfrnzNl79+7ttNYsMzPweqCvrHYc/HANLeaulV3WMdZL\n", + "1gE02drFPvHqV796arzsGzfddNNUe1ueGBtjH8vizfign2fYL4W1ydw5A7w1b/Yi9jDWwSmnnNLt\n", + "AwB64TnWnS9/+csR0Wv7AMsNtPNs/E0ySx1je/zxxzs5Nxgn/LCvlK3GjJO5fdWrXhUR/frC4gDa\n", + "CFPkwJFzANlybVHamRb+jm8R/PnGN74REb2vFDj66KPTzOT2v0Ie4GVbNSFieHuAbLNv2g+w3cOR\n", + "c+bvr//6ryMi4qtf/WpE9PuCgdzwfcbn/QU+sD74Pz5nfqdHDK36fNd+TFj5eG/yf+8jAOurfU6P\n", + "PPLItF7hWET1Pffc08nPLKz4IDWZTDZGxPzy8vKOyWSyKSJ+MSL+ICL+r4j43yPi4z/5+cWx77/6\n", + "1a/uJsfOYoVCoVAoFAqrhRNPPLG7CkXxzPDTWKSOjoi//MkJ7pCI+MLy8vL/PZlM/j0i/mwymbwj\n", + "fpL+YOzLW7Zs6U7qnCzRSK3toiXw/x07dnSnVDRnwAmTn2hFjiZo6YjoT8XPf/7zp56Z1RSbTCbd\n", + "6ZwDoaOTsPo40gVLhCOfAFoA0V2u0QQWFha6NoBTvTUjtBf4AN/o2xYs57xijI6KjOhP8WgYWU0o\n", + "9834GRc0mC9oBd/73vciotfk0KKOOuqo+NKXvhQRvYygEdk6YmsHWpw1VqJyDNfLa+t9Wdu19Yrx\n", + "of27jhP/d/4d5/IC7RzRxrlYTDfaK+sCWkw7Fhl4T6Qkc4tfA1heXu7kGgsRMuL6Vq73Bu+xFtvy\n", + "iuwxRteWayOCHMnE3pIpba5nB39oZ4u0rYKseZ7bat7QxV6CXEO3/Wmg0dGPzJ33F/5uK/z9998/\n", + "mH/2OeaC8f3Mz/zMVF+mhf2Sn46KBYwfK/ohhxwyiNxy39DEnst4bcnC2oplhrnCEmVrGvxtoxfh\n", + "va3GtKVvorv5u99F0ML6YLzPec5zpsYGWnlj/ph3W2kcBQ7YF7wuWLOseaxnY7UcHSHHuE499dSI\n", + "GO4t7OWOZkN+HM3O/xk/fISG1oJp32G/Y22ph+fwh8NNex5o4XyDbX5C7/8gy2X3ZCu/rPggtby8\n", + "fGdE/MzI3x+NiF9Yab+FQqFQKBQK/11QtfYKhUKhUCgUZqBq7RUKhUKhUCg8xVi1Wntnn3324O7X\n", + "vjXUt6JOEHfLGzduHNTEohbSRRddFBHDzOS0516emkLUNyJiwlnWoZE6PmeddVZETGcVx2+C+2Da\n", + "Un+KPriHxX/B9aqoKUV/zirO/fOVV14ZEQdqbWV1ijxO+sY3Cr4RnQN/aE9NMWg2X7jvv/7667u6\n", + "TFg36ds10aiHxxzZhwSa6YdxMv+urdVm0/U4HeGFv4br1b3tbW+LiP6+nTmlnWszUifK9dP27NnT\n", + "/Q7d1HFyHTxAH1l9Q/t5MW74SK21Qw89dFAzi3llDb3//e+PiN43wrl4PP/UlHTeoDZ7dkRfs+o9\n", + "73nPwOeL77he5Zlnnjk1fkevmefUCQSuRoBMXn311R3drm+J7CBb8Jz2jhTCf4VnffSjH42IXr4c\n", + "GdVa9uE5e4t9/7I6fsiW/fBcAYC6X/ARtNFerlfKmsNnx/LrenXUIITH9jHk76wj6r6xR69bt67r\n", + "E14xn7R1dQrzkjmCj/Z/s/xcdtllEXGgvl3EAd8ZvkPbrAYhfjjOos3cuTan66B6bcPHiy66qPtf\n", + "67vVgnXBu8W54Jzxnr7ho/NL0Q7foW3btnXzSV/s545WZ47YW7zuac9+41qe7OGOQI/oeci7xXVw\n", + "vVZZF7xf4Af/93vG+67fowsLCx1v6Bsees3Rjn0BOc9QFqlCoVAoFAqFFWLVLFKTyaQ71XL645Ts\n", + "bKL8n9Pinj17BtYLgIZAtBEnYtpnEWX8nbwXRG05molT7lFHHTWI+DNcn4jvOpIMMH5oRvPKImUm\n", + "k0lHN5om2pm1FGhxZB0/M2uC26OZtLQwDveBxuE58rOxGqKx20LRRl1E9FpCVpMtoucZPEd2zBfG\n", + "yd/ps83Q3II5Ycz0v3v37sH80JYoJMuYI0h4lrPIO8s8wFJx7LHHdnRnqUSIZIF3yBh9mpdZBCZ/\n", + "dyTW3NxcZ+3if0S8mS+ed75HjhvTAp+yNdzOUVZlIIvWYTzwmshB5tfygiwi61gy+F47R4wbyyvP\n", + "wtplmpwFmv+7/qMBTccff3xEHJjbjOeuc+loPMO10tps+i0YG1aQHTt2dOvZ0WbQwE+itIjizCLr\n", + "HAXo/EMAPm7fvr1bx8iiZcc1OZ37zHua30XIDVF/Y7U5PW/0nfEQsGYd3QngE892BZCWdujlO7ZI\n", + "Z9HMttBlmc15Fv1AA/xq5zTLcZfVN6Uv18+kGoH3aD5DU/v+8fzbSshP9uhZEeigLFKFQqFQKBQK\n", + "K8SqWaTm5ua6k6jzSPkO2Xkn9uzZ050yne2XkzPWLnIOcdr1SZoTpzUtcnJktejWrFnT5S9Bk/LJ\n", + "2Ll90ALR1KyBME6f6skJNWbBct6sNovrGOjD1eCtHcEvtCJnWW5pyTKbW4sBmSWGv1uDBfAHayPy\n", + "4twtEf18Ih/QndXlQtuB12g7WZZtvocv0sLCQqqlOW8QspVZTewLMqsC+fbt2+O5z31uRPS8sWzR\n", + "NzzEGgQt5ostj7b0jFkZGSfWGdqi3QHmG36Rb825aAA0wHvyDjHW1oLlvQL5RV6dkdsZ8LEe0o/X\n", + "tH2vsNRAQysvtnY6o7l5aOsItDNOt3cNN56zZs2agWWS7/IMrIDwaSzzdETPB/ZRW5Hcrq09mVl1\n", + "4BHj4/9Y1JzDDblivNSLZD153UHL/Px8tz75m2XRfq7kEUN2oQnY58r5loylpaWOD/Ccz5ZzWySd\n", + "T8x7kbOxs5ZZT63s2s/KlibvRfYpazN+t/0Ayz8VJMYqZ/DMjIf2V6RPywlrObPC01+7f/o95zyC\n", + "rDVyVVleMpRFqlAoFAqFQmGFWDWL1Pr16wenYVuXAKfGtl4UliKfXn1v7JpTPpE6OsORAL6vRzt4\n", + "5JFHBpmK3TeneSLl+Mzp15oaz/SJ2/5K7VjpM8sSDjido1m2WW8jhpY3xsJp39XgWy3QEW7A4wPM\n", + "J+NhrujHtLv2HFYjtM3WBwEZyrQeW/Vc/R0tF4udtR1bPFuro8fPOF1xnGd5Ppkj18zi7+YnVqSH\n", + "H3544Itgvwrmm76cDdo8Z13ZeuoIMjA3Nzfww/IcANeOIzs/486y7MM35h0ZbMfKM5EJ16Gz7xDA\n", + "Ku7aeWN+iRFDy5c1/oie12jUaO1YIpw1m76QLSwzWbZ69iLvO5s2bRrwkGdBH+P1ngRscbDPSzZH\n", + "WEVammztYP55pmtyZlGctMfiwrqyLIK26kV2s+CoRWSw9fVqkWVpR97GrIzME20yCwrjbP0uI3Kr\n", + "F3zCigptY+8AWwxd0WKWj5R9A81zt+d5lpu2L1u74WV2a8C6wOKd+QNn/pCLi4uDvQieIktY0jg3\n", + "ZP7PRlmkCoVCoVAoFFaIVbNIzc/Pd6dBTuicZn3CHKs1xknRERHOp4PvyJglJWKYH6nNCxQx1ALb\n", + "vCrf//73I6LXGGy9cmQE9cnsnwAcEUK/zivSjtWRDGNREtDb9o2m4Ht7YCuTtaSxOk7OAzNWhTxi\n", + "Oq9HRM8f500BfIb3RHdh0WitksiKo+8YZxa1B80/+MEPIqK3xHiO7CPVWptcU445sOWN8WTRSfzf\n", + "Fh1btlq5wPKS+QJBG/PvWotuD1/gn+fIluC5ubmOh1g77DsHnB8L65/9T4DXPxo4NJmW9hmMO+vb\n", + "YI3CT1tm6Me54EAr6/zOMz1H7ts+hWjWjMFWI1v0sWBt3rw59dfk76whaLMF01YDLJisI9PiCMP5\n", + "+fmB5Rk4mhd/RO97psVzyp7k/aWdY3xdeMdkEX68B7CoYXn1uvBe5+jWsfcR9LL3OOIX2PICrY5C\n", + "A+xx8Ae/R+/Z7Xd9e8KasqXNkYVZ5HU7zoieH6xp+Nha9rznwkvWsd/RjAeamEvWf5afz1HPc3Nz\n", + "A55DA9Z0zgvQnUXKGmWRKhQKhUKhUFghqtZeoVAoFAqFwgxktfZW7WqPcggRvUkSYBYkFT7p6gnR\n", + "feCBBzqTJD8phUDJB5flcLj6ddddFxF9ing7yblsDWU5KD8Q0Zuk/Z1rr702IvoyC05AyLUKZkNK\n", + "IVAKxY7MgDGRlv/ss8/uzMW+/uJZn/vc56Z4SB/QigmTz9BCWn7ak8AR8zsh6B/4wAe6vl3ywVcU\n", + "lB8ghT/AeZCQape3oPwAcsEVSVvmgPIALptx8803R0TEySefHBERr3zlKyOinxv6Rra4yoJ/0ALP\n", + "KbUydmXk0iaU5WCe4TVXki5XAV983WZHUfpnDBs2bOjM3VzRYKK+/PLLp+gGvl7CyfKP//iPIyLi\n", + "tNNOm6KVK89XvOIVEdFfU7De3ve+93Xy6mt0zObQQskPxsmapB1XoJdccklE9OsCXuMIynOQxcsv\n", + "v7ybT5eRYJzIGH3Dc2SJOTHvKW9BSRE7J/P9Rx99tJMVysnAB3jI+ufnxRdf3PEwYrjukRvLImuU\n", + "vzP3O3fu7J7JPscabVPIRPRrCl5SOoP2dqGgHWHh7NHwkf343nvvHQQquFwNvGbN8V2X2mJOs2SY\n", + "zBHtoaVNf8C1OHJ76aWXRkTPc19lOSCEPd3t2bte8IIXRIuPfOQjERHxO7/zOx2P2VOQb4JmWJsu\n", + "+cK7q02xEhFxzTXXTPERvrFHsz9yHXvFFVd08wlw2H/9618fEf212h/8wR9M8RC4NAzycMMNN0RE\n", + "Xw7NqQq4ht+8eXMnW/QNb7kutpsKe7rf6XahgE/eR12abcOGDR1dyCJ7KH3DO/Y9rnopEZWhrvYK\n", + "hUKhUCgUVohVTcjJSRsnyZ/7uZ+LiOGJk1MuWsLNN98cv/iLvxgRvWOr0Z5CI/qTZuaYaEc+TqR2\n", + "CEZb2rNnT6cRvfzlL4+IodMrnzm9ozG87nWvi4ihI6OfzbMcHgomk0mqeXOSBg6JzUJNAXODNgwt\n", + "v/IrvxIRvbNqxLDoJNoL47eDpwtKo9W95jWviYg+HB44KeDtt98eERFvectbImJ67vxsvvNLv/RL\n", + "EdFbpoBDsWmPdcTyYkdwvr9hw4ZBqg14yN+Zkxe96EVTfAAOTSaY4aSTToqIoaM862RxcTFuu+22\n", + "iIh49atfHRFDDZn5d+Fnxmc5cPoA5uo5z3lORAwdPJ944olBAWysV1lyWLRVtOPf/M3fjIjhWkRm\n", + "oZ2xvupVr4qInp8Rw5B4eITFzikHXGbk1ltvjYjeSdkO/k6vYH62axRZwdoHLaeeeurUM4ETTCKD\n", + "WHbGyvJE9HPI/rJ169YB3ew13kP47BQF5h8/sUS1678Fc3nvvfd247RDvh35oWEshUREv6aRf94D\n", + "XougTbJ61113RUR074ssVN6O+21y0xbsE8g638f6Yyf8hYWFbl5uueWWiOjl/LWvfe1UWyxXLhU1\n", + "5rDd/p+/w1cstG0AEXTRl63jlpe2AHZEPyesI88p/bHv0h+W/lbunAwUuWfNOf0Fcs4eBU3QYvck\n", + "B2cxxr179w6CqtgP2mLbEf1ZJHs/GmWRKhQKhUKhUFghVjX9ASdLNC60AFuBXL5leXl5UJQW2DrS\n", + "au0RQ42M0yynV7Q7F9Y19u/f3526ObWijZlun945tWdlPPieE/GZlrVr13bjsaZkK4DDXF04OUuC\n", + "Sb+MFQvgWFI5l4bx34ETTTJeLJPmi0vIwD+sJGNWSbR5LDP0ifULOESdZ6FhYv0CLoMDn8aSArpv\n", + "+5t5nE6oZz89a7ttoVDkIEskagsUPIR+p9ZwcWY+U0JhrOyL01fwjKyYNZqn/VcyWTQtWMfa0H0n\n", + "b2XcWSoOh4NDG7JmvtBvlqiw3bv4Gxox8wlNWORm0eLUJR6rSwqNlXthHC78jSXBFgmnd/Ca9hy5\n", + "nMmWLVsGBY8B4/B8umAwsP+q90XPUWuR8D7n2w7kwalbgGlBZnnvwEcsmW0pFPp16o2sHA/w+8FF\n", + "fU07NCFffIam9tlt+p6I3m/PNxi20LCv0LflwSka4DNy1bbPyrTYZ87jtMUeGmeVWmr79xpCprye\n", + "oSFLnmqURapQKBQKhUJhhVg1i9Ti4mJ30iZ6BQtDlgQLze6UU07p7oUz7RX49Julwudk6qKe1kha\n", + "KxraHIUu7SPFKd3aO9F+1qRc5JPTPCdvW+q2bNmSljbINEYnw4TnttQ5coSf3/rWtyJi3L/Lifbs\n", + "RwN4li1s0I6WZNrR9vBzQtNtfZPMO2jBEmU/A2tqaIuZLMI3J0vdvn37wNoBDS4VkhUWduQlWqK1\n", + "PMDcr127trPKOcLH8J0/cmKrKX1j2USG4YvX0WQy6dq4xEmWSBReM6933nnnQWlxZB1z2rbPtHbz\n", + "Gnh/wD8v0469HlxgfIxuftLnHXfcERH9XAHWRRa1l5W3Yl9o/cPMw9aXr6Up2+dY/05umCUq5Hns\n", + "0ccff3xnec1KRzGf7G9ZKSQnqnTJLPOljf7Cv5A91/LvAsG22Gb+N/Aamhirad+8efPAssT6z5Lm\n", + "ukyZLTKmBX6wB4wlk2XevRdliapNiwtwe05p5zJvY8mnbb1in0MObDVinzdf4KvfM9DmW6m5ubnB\n", + "OLkNgwbmm/fck00PVRapQqFQKBQKhRVi1SxSrQaEdpMVObU/1ObNm1PfJfrw/7P2Ps3yLFto/P+I\n", + "YTFNn8ZdIsTakLV6nsn3XAjSaKMQ+A40+FTv6BR4aR8SYJ8KMFb2gT6z4sXuA03MpWQcrdGOs30O\n", + "lg9oaPkI3Y6m4hlZyRdb9DJ/E9qN+U5k82QZsy9c1rdLyZiPrYbmKBtbYOyv5AKxlt3M/4R+bZGY\n", + "m5vr5j/zWQFZCYis5Ic1c2Bfu/ZZLj9hSyzgmY70cV4h0zrmr2g47xHWHObT8p6VscEK4P3CI8QD\n", + "tAAAIABJREFUss5YxvY61hzjsf9dNk5byT23YCwaGroy+efZ9pHJrED+O/zLyrjMzc0NrJjmbeZj\n", + "i5x7XI5EZm6xqo4VubV/qiOLgS2MnsesmLPzjPGzXdMuWo6lmXHa2k07z53f1SArAzZWWBrewQfv\n", + "e1mRa/7vtZ29b8b8X7MbqWwdPFmURapQKBQKhUJhhagSMYVCoVAoFAozkJWIKYtUoVAoFAqFwgqx\n", + "aj5S73nPewY5WfjM3eYVV1wREREXXnhhREzfY/o+nbo81MLiPtnPIIqAGlRnnHHGVN++G+cem5p1\n", + "bf0s+1/wmbp81IjyHTn3tK4RBe2OAPKd7/XXXx8RB2oK+X4Y8CzqG7mmoCMgoPFTn/rUVHtHWHgM\n", + "n/3sZ7u2hn0bqBHHOJ01F1pcmw8+Gm0+GuimzpJzN9nPhhph9O2oHcN1H+1DMzc319HN/LjWWpZX\n", + "yjWifG/vqJ2PfexjU7S3NNvPcNu2baN8sZ8KtCAv1BTj/44YNV/e+c53dn9zbiX8KqhXBy2u4+Yo\n", + "LOo+uu4XQPYZ/7Zt27oagYb9MP7kT/4kInoe2g/DPkXZfkH71jeG9UyNMACd9vVAdi0vzmXHHDCn\n", + "XhdtdBJrg7bUK8z4gQ8N46Rvy67zbDGnrIsxfzXmF1k5/fTTI2Lof2O/Pmhv67JGDPcgxkA9PPg+\n", + "Nzc3WGvmIXLrPFKuF+r9xWN0tm6vu3a8tGG+WHPQYl85Ry1mNQizfG2f+tSnUh4aXs/Oq+j3LrS7\n", + "rixo3wG8F6nLh++f/TupBOB9zvLhqiS0px6uc+dF9HJO3U/WnP2ynBeOcWYoi1ShUCgUCoXCCrFq\n", + "FqmI/rSHZsHJ0adDV2RvPe99Auak7XwpjuICsyKqslP+8vLyQEvL8gIRVYFG4dwlwNE3WKagyVF/\n", + "Le2OpssqZPMM509ytEnGV743FqUEMqsO8HcdaWnrhzU4awstH62lmMdGFs2ZZWmHj8wRNM3Pzw+s\n", + "g5ahWXyxVou8O9O5aVxcXBxE42W5eFybMaPN43cEqfk2Fq3kcZkWW5SyqDPLnn+2/TvaNrMCAPiB\n", + "pZrPtgoZzsuU5fpq/2d/VO89WYRZVmUBWtkn4N/i4uIgw7a/O5b1eYxmR7061xmwZWtxcTGVRT5n\n", + "eYAcWWULntd99v3JZJJGaQF/N8vZBMwH36Z472qjWaGF71pW/B6hT0c3eizZ2mzH5vVvHlo+bKGj\n", + "vTPeu3+PxWu8pdO1WR3lbjjy3NYyP9tVTdratKbbcu334yyURapQKBQKhUJhhVg1i9TS0tIgH0T7\n", + "vxa21CwtLQ2yBQNqAmV5oKzV+6TNCTXTSFtfG/vJWLux7xR9WksGZKQlU7dP1GMZ3631ZbmYfI9u\n", + "jcNao2k+mAZijTt7hr+b5XaxFsAYfT8/ZjXMLAgZMh+QjC/OZN1qgabbflmWhyynFT+dTyzTntet\n", + "Wzd4ljUvz4G13mx+7UtzMEtNJtem2zX5Mo0SOHu/LVHt970e7CeRWbvtI+l9ALC/2PI7NqeZf4ll\n", + "zrR7/BmfsKIhi+1+lPHUWn1mYZ6VLTrbL1ofqWz9O9ed92D37e97b3dusINZoWflF/Te5bnILLeZ\n", + "1ShiaAV2tnBgK2eWww84y35mPW7ptDWQNp7/7N2c5XSzLxrrYsy6hLXUay2z2Gf1Hr2ugC2Yrc9p\n", + "ts+ZP9n6z1AWqUKhUCgUCoUVYtUsUm1V7Fm12cb8OTIrkCuNO7pmrEZY2871nty+vTs1XT7tOjLK\n", + "2qDbt/42Eb3m5Wy7oNXE+J8zEnucPvVn7T03pr09qWc+IBns6+R+DGdItsWm1aYclWgtLatBZw3M\n", + "c2faPUdjmc2tYVtm3T6jLfPXGovWcbQZwGphLTbzv3E2eWt5Wd23lp5ZWbOtaWaWF+bEmZ89t+2z\n", + "M1oyS11mTTRcGcD8aL9nS4T7MJxl33Udx/yvWtrbvXBWvbLMN8a024pqeXD7MfnwvpBF3WX7h/1W\n", + "LSfmS/vZlrdMFjPfKNNka5KrEIyN1RGDWd/O7G9LbDb/wOuiXQveM6Epm//MZ87vU9NuC6etjhG9\n", + "LGbvDY9zVpUBf5890JaupaWlwRzYYn0w366DoSxShUKhUCgUCivEqlmk5ufnB/fRsyKtWu3Ip3Xg\n", + "yCcj89dxdEpmNQItDdbWQOY7lI0TbQg/DFvbrAUsLCwMooUyi4FzE7neUTZOWyZAe7K3tpdFOhrm\n", + "W3Yv7/7Q0PnZapH2VXDfs/y1sjp3poUcKK3PXWYFtJxnWg59MTee/4NZD5z3JpN/WyoyHzjLhX0G\n", + "xiw/Hl/G8yy3zyx4TWa+Ey2d1krNeyzQtkxnkUO26HhMLS2ZRdLjB7bqgMx3Ctqximb9tn+z5QV5\n", + "sOXdUY72jXJ7+30tLS2l/lRYDDKfv1mWV8ti5lPZ+opluZYcpWnez7JMZjUcx9qa7iyCDHjODPfj\n", + "uWn5m/l6zapBa8t15jtmC6Yj8trnZFZw+5ABrOmZX57lxRapNoox86fKfOUs5xnKIlUoFAqFQqGw\n", + "QlStvUKhUCgUCoUZqFp7hUKhUCgUCk8xVs1H6pxzzunuT4844oiI6DOAc7/q+mb4BGzYsCEeeuih\n", + "iOh9GaiFRE0h55l69NFHI6K/C6UuE3V/uGclx8W3v/3tiIg4/PDDI6Kv+0b/a9as6XxaHnzwwam+\n", + "3da+DNDe1giL6OsbkUeE9tQe4u+0v+CCC7o7Xt8j85NaWNQUgufQbh8B6pu51h4+QY899thU/5/+\n", + "9KcHNcWyyAfoZj59503kh+uEQTtzTR4a5nTNmjXd/FOXKYvC4zP1qugbwBciS5g7ZNHtkY+HH364\n", + "o5u6TK6Fxf+p3wiYI2qQMReMc/v27VPfpzZfO1b+Z58W+GKewx94zjPdN7TDF3IXwce2vf1QLJOu\n", + "y8bf6XvHjh1Tf4fn1PFyNBNz1I717LPPnmoDHFV0zTXXRMSw7uNhhx0WEf2apm/zJcv8vGbNmm79\n", + "ew3h+0ieOPjl2nn2LWNOkUVoYb+gH/auhx9+ON0X4TXfuffee0f79hzBH+af/k0LYz3uuOPijjvu\n", + "iIh+LswX+63ZNwZ5gXa3Z10wJuQFGdiwYUPHc/ZQ00ItPPuvIS+ef/hiWfS7iz3g3HPP7dqwn/td\n", + "RFvohtdHHXVURETcd999EdHzHHmBj8gJezT7Sytfrm/JT+hmPPCFcUI7/PAcsY+yRgHPhpa5ubmu\n", + "LbXw4PXWrVsjIuKWW26Z+sx8XnTRRVPt2VfaviP6d/oFF1wwNSZXL4iIuOGGGyJiuJ6ZI+/RzH+G\n", + "skgVCoVCoVAorBCrmtnc2s5YXpiIYaTA/v3704igg2V3PVjfWY2dg2U2d1TKrCy5bp9lNnbEQJZl\n", + "O4vMOhgtjnTKIiStac/i4xjGcuu0380ixbK+nQNlLEIzixDLPrtveJ7lOJmVX2usT0fVZPXqsizC\n", + "Gc3tunDU4awswZlMZu3905FSbaWCLLqmbRuRr8WM545yGouUyiKCsohQa9po4AeLworII1Hb586S\n", + "xVn/d2RYJsuW1X379g0i4jLZY7yOUnRUV1a1wGPhuWvXrk3Xc7YPZvtFts9l66P9e/YM052t91lr\n", + "78nsN96vsvxHWV61WbmMHP06FhXuCFJbAbP3BfKR5Q8DGY2O4mv7yLKGZzms3CfIcn2N7QHZecGf\n", + "x6IND4aySBUKhUKhUCisEKtmkVq/fn13ssQXxP4XwJm9169fn2ojrvzMfWqWR8Y1x7hn5p7Wmhp+\n", + "CBs3buzo9n0qMI3W6t03PlBoAXxmDGM5gA6WWbmF65tlOVxAlvNqjI/WIGbl4LLVwH1mmveTsRri\n", + "L5HVObOGQXssE/bzMZ+YA/v3tLmcgPNcub6V4Zwt1pIPVnPMbU13lmdqVm4raLaG6rFu2LBhMK/4\n", + "MGVrznOSWY2cJdmZ4cesBllfhvuEp/hreZxZtmmvzYh+zXn+s1xcXv+uj+dnsP+ANsu+22ZrK6sp\n", + "Zn44q3y2jhjD+vXru98ti+yh0OI+szxSAFrtx2Ta27nPrMCWb2CLrftmbp25e6x/+vL8Wjad4Z19\n", + "P6s+4b2O/nkftf07+322poxZllmAnMBPnm3fsfZ/8Aq68Wez7GYVILL8c5nFr827CPz+h5YnO25Q\n", + "FqlCoVAoFAqFFWLVLFKLi4udpkUUS6bBcqpts0pnvjvWJG0d8YmUyA80S2ggasea2v333x8RB07T\n", + "aCXQb7rpG5qwdpF51VlTf/SjH0XEMArDUR7g8ccfT7OCe5zO2G0tJ7vrt+Y9dlK3BmDfJfPFfkWu\n", + "g5b5irgWlT9H9Lz1OLKsuVmmavrOwHN4NtrjWB+uczVGd8TQekY7vmcLHzTs379/4Ffnvl2DEmTr\n", + "gr8zLtPuelhj/OI7psVzxOeML4zJtI6N1bJkX5as7p0zeWdaLWsUHCyrv3lOG1vJAfscNMIXaLCm\n", + "Tnv7kO3cuXPAYyKFbZHAesEeZdr5CV8d/Qj4PjRF5DcM0AJsYcj4wjixIkCb99G2P78Hshpx5mG2\n", + "LuAXc8g7wBFkoJUB+1V6P8ciYx+fLGM9NDgCd0y+HEHL/HsfA17vnne/d5lr7+FjljreZ4C+23fr\n", + "2P/9OavZ6jls5zazAvo7Y/v5wVAWqUKhUCgUCoUVYtUsUmvWrBnUe8r8Nfz/+fn5mfWHsrpfs6I2\n", + "7EtijbT1b5hVG9D+FLOidtwebSe7v27r/blOV2ZhyjQK89N8yKI6ngyy6Cz71GT30mig9v8Zk5es\n", + "QnxGdxbdlNV3Mh+zGl0Rw4iXWf5I9suyP1bm3zKZTAbznq0hRwJllhfLIuPMKtC3a3KWv57nb1Zk\n", + "jP07wJiPRGaZncUXI+OLZfFg6yiTrQzmg9dF9qxZ+1BE78NinygsEtl3vZ/OwlhNu2zNZdbwbM91\n", + "hHU2B+0el+13bpvtm9m+6HEe7N3lPXRWxN+s9wSYtbe1tNh3KXtPZs/Mojcz2g8mL9BCn8hmZgUE\n", + "/w97bx5seVXdfa9zu+/tgUZo5maeJ0XAeSQxvknqLSsmMZXksZJSKQUhUYSKCJQS8iAEUHiVRKKI\n", + "hjwZXpKUScU8cdZgRA0OiYqRsRFknqG7aejuO5z3D/j8fvt8fr91z+WG1I3Pu79VXafvOfvs39pr\n", + "r73PXmuvIZvnDONquJZ9LNSnMkMtEVNRUVFRUVFRMQa1RExFRUVFRUVFxbOMJbvaO+200zqhkaTE\n", + "51qFciWkfMcMvWLFisZsx/XXBRdc0PRbghBRgPmQ9pQ2yBydXSKAdPXT09Md51/TQukUnAv53E7W\n", + "F110UUS0pRBsRrUjY1lqw6Zmrl4I44QW+qYP+sSsigMffVOuAPM7fKQ9/Lr44oubUgWZ461LfsBz\n", + "zKjwpXRUjWhT/ruMg5Mmrl69Os4///yIaEt+4PzKdyhDBF8uvPDCkb6ROcYHTfAF2l2CCD5OTU01\n", + "z3JpE6e78DUsZRmQc8rwMD7C3Pn+xRdf3OGL5x25+MAHPhARbSkE1hClUOBTJud2NvaVaVnGyaHy\n", + "DipwaQuX2bBDM+2ZU8BYkclSvpBb0pfwDDtuM873vOc9IzQa8Bz5gufwy1fAq1atanhOOSHG43mE\n", + "95SrgecOCAE8k/3ijDPOGOFH6azvvYL5R/ZwbHaJIGinRAhygizagd6lk2i30047NX3yHdqah048\n", + "7DmClmyOWKsf/OAHR9o//vjjnbQ28JTSOdDi0jnsRdAGH5FFxslcwkeXzinLeHmvZq3+/u//fkS0\n", + "c2RncadoQV74fWH+CW6ibBVzfdlll3X2OfgBbfCJ31yvOV/1A/jIXse6g8/M/apVq5rfImTFey40\n", + "8Qz2OdrTJ/wozwMR3f3F7hebNm1q/k9ZHvhilw5ogS/QnqFapCoqKioqKioqFokls0htv/32TWK2\n", + "733vexHRhsUecMABI23RDjgtLl++PHbZZZeI6Ia+OlyfEzGndDuAoiW6bMGPfvSjiIjYfffdR9qX\n", + "JSXok5NxFjLJ51gasI5Y43QyUTQWaCiLLgK0jjJRaEknQJtjvOZplvSO7xGy2pfy34kkQVY+hXYu\n", + "x8IY7NDsgrmmHS2o7Aseo1Ezn05iyDjh9a233jry/X322WekfZbQbdu2bU0fwONAc0ZuHnjggZHP\n", + "bTVjbqFp1113jT6sXr26+c5PfvKTiIg48MADR9q4+LAtEw5/hy/IE7zPfCrn5uYa+R2X/NXWPIrb\n", + "Mv8eJ5o5c8e8I5PlGmWc0ABPSVvgcQI+p2/kxg7tXld77rnnyFjKPQDeMf7bbrstIiL22muvkfcB\n", + "PGb8fP+mm26KiHauAPJlB/K5ublO4AZrDTrhNbLocbkgNBq6AyBAqfVHRFx77bWNDJruhx56KCLa\n", + "dcsag9deF053se+++0ZEyxfvO2VySMbBvDgJMs90YlX68DhdxBf+IGfm48zMTLP/O72N+VIm2I1o\n", + "ixUzZzwDsL7gM4WZb7zxxoiIOOSQQzp9IxeMl/dtaXR6IV6ZM4+TsUErtDFXZToOeMpcQNMtt9wS\n", + "EREHH3zwSN/+TUd2kRsKb7t/xsQY995773T9sy/OV35sPlSLVEVFRUVFRUXFIrFkFqkHH3wwDjvs\n", + "sIiIeO973xsREV/4whcioj2ZAk7BnGofeOCBRsNAIwRZKH1WKBVNi354Fq9oywCt6OGHH25O39be\n", + "TQtwuK8tGJzyrcFwqrc1ZevWrU2f0LX33ntHRDes2z5gz3ve8yIi4lvf+lZEdDU1NC20Y2i+8847\n", + "I6LVCiK6ye4c3u65gOdo4FgW4HlWzBP+4gtw6KGHRkSr4cKTss0ee+wRERGvetWrIqLV1gDjfulL\n", + "XxoREb/xG78RERFXXnllRET88Ic/HGlP/06SOhgMOv54aJzMI3RmYf8kpKOfI488MiKisb7ecccd\n", + "I+1LayxaHH2TJBbYJwLew/OsgCiWHb7PHDjh49zcXMdqiQyaL8jgEUccERERr33tayMi4p//+Z97\n", + "aWecWCKR3euuuy4iRpNksoZYt1g39ttvv4jI0zcgJy7LYYs37yNf0IqVqVx3rAss7K985SsjIuKa\n", + "a66JiK61C22ZfYXvYXGzxdv7D/LmuYlo55lnQANzsG7dupH2rEFkzr51WLIAcvKCF7wgIiJe8YpX\n", + "NPNjKwByv379+ohoLS/0gbwDFxRn3Px+2IJVphuAJ/Y7BcgLsmVLHH67gD3Y+25WiHfZsmXNXsk8\n", + "8gwnd2WdYEli/rG8lftcRHvDAQ2vfvWrI6Kdq9Ln1GXW4CG/Qb4dsaWKvvge+4Fpx3rO7dL1118f\n", + "EREvfvGLm7YuS2NfMJdcsz/i97///Yho5cRzBO2sdWjYZZddYv/99x9pizwgo7bAl7cd86FapCoq\n", + "KioqKioqFokls0itXr06Pv/5z0dEq4lnGiwnVjT0hx56aGxpC995ZonleDba0XOf+9yIaLUcWw3Q\n", + "mg444IC4/fbbIyIvVcDfLgAKfM8MjY6o4nRsbWe77bZr3kMDwGJkixR9cY8OL7FgoWEDtECsg7Tz\n", + "XXs5Po87Q+aH4lIqAA2Fzynf4yioiG70zXe/+92IaLVB08q8f+c734mIiN/6rd+KiIhjjz02IroW\n", + "LPt3gRUrVnQsKWg7PButDk3Sssgc0Q/yheaF7AG0yQ0bNjT04zdgfwpreWhaWJHMc5f38GufBdPJ\n", + "YR0JA9Cs0RRf//rXj9Buy5uLmmPpcCRWRLeYLLzmu7a82MKKZSor/YN80Y7++wrFsi/8+7//e0S0\n", + "828fOIBVHEsFPlXQlhWthQ88e3p6uuPbwT5x+OGHR0Q7/9DtiFnkB8sTfMhKrSBHyOELX/jCTskT\n", + "wDzj24M8sIdl1lRoMV+8juDf1q1bO1Zu3wLQh0u+uEwTYM6wgrBm2Q9s8dywYUOzt2K1ZN/zXsRe\n", + "Q59YXqGJ7wFuC26++eaIiPjsZz8bEe0c89sW0cqik9tCW1Y6Basf7bK9C1qYc3w14avLAvXRhCxm\n", + "ln1+g2644YaIaC1vLjnDXGCFZi947LHHOlZA+MC46JNnVh+pioqKioqKior/YiyZRWowGMTzn//8\n", + "iGi1IbT9rBQE3vnbb799qtVxendhW7Qc+xmhNfM9tAJOybYCoanMzc01J3+0XWtejk6wNcPjdDFG\n", + "tKnsfn9ubq6jIXOiNi1oc5zOrR17nNCMFsSpHw2u5DvPgueMq6+ERzlOvmeN2hqJIyrRaJmL0gcD\n", + "LYf5RItx7iaAtQf+/MM//MPI+9ZgATSXRUBtvWAemROXjDEtjNsymkU/0u9znvOcZj6ZJ/MwK9vi\n", + "yBngqB1HwtinYmJiopknZITv2toJb6Hxq1/9ajOOiK7lDXnhc2hwLrSI7tpCU2ZubGHAWsj4yz2m\n", + "HDdgTGiwWCbgVzlWeMt4nB/M65+5oU9ode42j5X9B1kty1cBF8BG44anWbkNaPLcWNaxLrEPlbcG\n", + "jk6zdZQ5Yg3aqoMVARpo5/JFoLTcZAWCgYv4wmv6dKQ0e43zb2WFpXfaaadGDmz18PyzV+Ezxnza\n", + "yg7gE5YrLFD81pXtXXSeeXQOL8B+8m//9m8R0e65jNfryHsU8oCclHPutcmz2FMz32LWFlblrMQQ\n", + "oH0ZBWvZclQqYJxZ2TKjWqQqKioqKioqKhaJWmuvoqKioqKiomIMaq29ioqKioqKiopnGUvmI/Wu\n", + "d72rU4vNNcmoKXXCCSdExGiUDnfV3Kd+4hOfiIi2/hCWNvp07h7q+LjuF3A9N2oKle3tE+Q6TtAC\n", + "iE7hHplxXnHFFRHR1hTi2c62y105dX9OPPHEji+Xc25Rf4r6dozf9c24T/7oRz8aEW0NMu646d95\n", + "Uy6//PKmXpGz/TpKkfmkphyw3wa0UJuL+ml8Dp/LaI1PfvKTEdHWfHIdPwMeUlPK2bN9/4680J57\n", + "d2jdtGlTM25qYcEX+yUg764pR3va8WzXiaM2H3M0Ozvb8AS/CtYHNaWQLWQOWXJdPGptwXP6w8eB\n", + "8SI3V1111QjtJf3OWQMPqSnnGpSAuTjvvPNG+oZfrlmJjF5xxRXNmoMfyBZ94r9F39ROZO7w12CO\n", + "2HOQXe8Xziq+bdu2Th03YH8a1/FiXTBO2tmPDXlh/hkj35uYmGieBS1ve9vbIqJdk9CNbCEPzD98\n", + "cV3QMjKw7N98f+yxx5r1mtVDdc05V6Ogvh08d8Qgz2KOoAW+LFu2rBNVxzPZ59gX7StlHynaU8fP\n", + "Ubt8j/0D+TrrrLMaXnmemIuyXmVJi2mCL6x//y4C+IQsX3nllc16znx/8DujpiS5He0TiEyyjqjN\n", + "6Jp19v/avHlzsxfBc1dCgCb45BqUrvdZ+itHtPsL68j+UMuWLWt4z3zye2E5hyZ+s/mNzlAtUhUV\n", + "FRUVFRUVi8SSWaTKKB+0nKy+DRonJ8zBYNBkKM08/N0nmpejsND2nMk4q8DO9weDwQg9fbSgzfC+\n", + "tbosagtaXQ27LzrFkX6c5q1x8Gw0JkcQOS+QLXnOz1NmT7ZWzt+2NLo9NDO/8NaRMozJ9aDov7R8\n", + "0YejNWmbZcJ3dXNrg6aFCBk0s1WrVnV4Dl3WEKHRuXt4NrSjDdEveWhAWXGecbgKPUC24AeRUERZ\n", + "WXZteSJzuuvclbTbAsX4srpvzL+zCjvXE/3aKmrLVER33SMzZU3EvnHyPUeEWXaRB+9J9OtoyYiu\n", + "JQKZyaJ2gfckR+3ZIsfanp6eTtezx0s0lqP2oA0+OIrTa5E55Hs77rhjb1RtRDtvjJe9yPnHDGgn\n", + "Kg/ruy0PZdUBxplZSvjblnxk1zyHr+QZZCxEzpHjCjz55JMNDaw5Xp1l2xZr+MKadTZ51ov5yffL\n", + "mpVek694xSsios21ZLptyWUuswhy2nud9UW9OVeXf2u8hqCdZzuS2HPEnNKuvDHyenZ+MeiFl76p\n", + "ylAtUhUVFRUVFRUVi8SSWaR23333Jvvp3/3d30VEW1OOmkGA0+ExxxwTERFvfvObm5o+f/ZnfzbS\n", + "Fu2HEyZaGqdZ5zBBs+JU63t7W8do9/DDDzc5p6hXhXYH6AtthRpKn/rUpyKia5HgtIx2hI8B4ye/\n", + "CHjyyScbTYI2Rx99dER0LSmcvMkwi7ZDTh9nwrZ1ECsROW76qnmX1ecjujWyABoHn1MXzZYpgMZJ\n", + "1vk3vOENERHx7W9/OyIirr766qYtGhH8IC9QFp1qbY68KeRBsQXLFeiZ04ceeqjJYA3gC7KKJkq+\n", + "GMO+ZWiiWL9c96nMDUUb5rOshViODxmCbmghWzhAfn7hF34hItrs43/xF38REd3s41NTUw39yBiW\n", + "A/vKIUPOyMz68fp3HirkBI279BFxjjLGYcsEYI3CB9YyGbrJfA9cHZ7++/KrwQ8y8VNVgBpqtjDa\n", + "WsL+SK4rXgH7Bf0hX+vXr+/Uq7PVD58pxkH+NPcNkBtk0PsF/IMPt9xyS1MVwRm52UtcsYFx2IrB\n", + "34yfum3Q+K//+q8j7dkDDj/88GZ+2COc/8o+QFiBkVGPk98L5pJcgtBIpnywww47NPsdn/3oRz+K\n", + "iO56tk+sfeO8p7MX2ZLPnlX6HvJbw/wfd9xxEdHKGFUGAPsl42UNwg9bPP1b5byNzo0X0fVLQv6z\n", + "+Wft0p4xZb/R0ALfZmdn03xi8AprJn/XWnsVFRUVFRUVFf/FWDKL1N13391oAWiBRx11VER0NRjq\n", + "wnE6vPrqq5tK8a6IjXZq7S7zebE1xZqYI4rKmkzQizZmaxdaIZrCtddeGxGt5uiMv7aOMDZOyX01\n", + "7ZwNltN7lpGVZ6Ld9fk8lX87AgstqLw7tv+E77D7KqKXz0ZLQgtyFAoaFv2gXX7605/u0OKaTq4R\n", + "aI0EGYS3hx56aES0/gi2pqFx8z3m9IknnkijZ+AhmimvtrzBr+yZtqqVkWlYcxinrTiOtkGmsOq5\n", + "gjrWHjRvomK/8pWvjDwbDAaDZpz4OEGLZQsLDX2g1TPP47RGtFv+to9MXx9ZW+YZzfsb3/hGRLQa\n", + "ta3MgLmyD1G5RrECIRdYoOBt5jtIH/DRVnXAGseqwD6z7777diwpjAM+XHPNNRHRWmC8MChjAAAg\n", + "AElEQVS9z/E3a4656bNIR7T7ImO+//77mz3GPm/0yeeOUrXPi+umYsmEBvOR34l77rmnkTXWg/2S\n", + "4Cn7G3sSa9O+YKxpnsF+Q/+2BM7OzjZ7Bc9iLrz+s3qAptVAXvidRDaxxkd0s6MTbctvjC3YztTO\n", + "HCLLniPG75udPn9A5t9ryL+fhqNZmQv/jtpPknUxNTXVsY77XMC6YRz2Bc1QLVIVFRUVFRUVFYvE\n", + "klmkIlrLkzUWTvCA0y6REhMTE536TJ/5zGcioj2Nor2gKXEitrULbY+TKhqro+EAp9/BYNCpHO22\n", + "nIQdPUCkhGF/LcYAjX110lwrzFFnwNou98t9FqaIbq1B5z7qs3i5D1umgCMG0dSznE+MCX8VNFAi\n", + "yUqLl+saOoLQmjSaCK9uZ82L9x3tuf3223fGz3eROcue5cWRYvAFa0A2R6UFC63O1ivGh4XOddBs\n", + "BWOe8fuCj7S3drx58+bmGWjraLvW6qGNvtDi+8ZT0g7NyLCjwSK6vlCOwrF11DXoXM/R42TeoYFX\n", + "9plS1l0P1Lm7LFuOYqJv+GefSvvOQPPc3FxqScFPh2cjW5bNbA6w1Jl273WrVq3qWDlAWRMwop2D\n", + "bG/hWaw91o2tSaAcOzzHWuP5B+6TWwPvXXyf3x3XRzTtpWWY3xhqzGZWIObfFhhHdVo+XAeznEOv\n", + "c76Lhc5WPdc3ZQ7YXywftIffyBPtSj7QR+Yj5ZsXPwP4twn4N5DvrVy5srOe4Sny699H+9RlqBap\n", + "ioqKioqKiopFotbaq6ioqKioqKgYg1prr6KioqKioqLiWcaS+Ui9853v7Nxt24ufOnGu4zQ7O9u5\n", + "/6TODjWCuNt0fS76pi6T61txf+u7bvLnUINqdna2uTd2Vmz6PuOMM0bed0QD9+uMk7o/wBnTGT+1\n", + "mc4444zmnhm6HYVAW9fOcu0pXml/yimnjLS33wavH/rQh5q2vqt29AQ1wqi15M+B64S5phhzU96Z\n", + "Qzd1uUwDtPE37akRxRzRt30p3B5aSt8C6PnjP/7jkbb0iR8Gcg8t1M6ivXluvtKesQ6Hww7d5fz0\n", + "0ZLlWYLnZ5555ggt9i2DJub0lFNO6dRvc3RmxvPMp4F1QX1D+7t5bi+55JJOHTfLLeP2unC2ffjo\n", + "NWo+ur7k5ORkMz+unebcU67jyPq3r5D98VzL0f2XfWe18Owr4zqO9O16Zt5fXN+s3Dc9Tuqy0ZY9\n", + "mu84Wg3aPUf2Z4O2PvnKMlPTFr7Qp32lvBd5nOYjr9QsLOst+vbHexHy4vXQJ+cR7fq3P6DXyYc/\n", + "/OFOfcs+uY1o59N1ImnndQLtZd3PiPb3CBlYvnx505a9hT6cNd2/F9neZZ9a+mcd0X9Zu5BnMJ+u\n", + "tefoW++jGapFqqKioqKioqJikVgyi9RwOOxoFpm/ljXy0grgaANr885tZA3FGVldqds0lf1bS7Nl\n", + "xXWKsvp32VgcpdCXR8aZlkGm/dg6No735ldfHSzaZNqf33c9xKx+EzD/0KqyqMAStnqYFsuJtaOs\n", + "b1s8yrpehvseB8+Vo1v62jlaNeO5I4GycZrn42S3pHOcPGQ0+nPD/OibG2vOWV3LjGbXi/S6svZv\n", + "q3TJl8zimtHv2qOe0yyPmOVqcnKy8x7Pcn1LRyGWfZTPthXY/Tv79NzcXFo7Fdiq68oIpt17crZH\n", + "l9bHbB903xnc3pF149Z2yYfMYlS27XtW9rnf9z5R0u42XoOmxdawcTXnbC1kj3Y28vL/XksL/f13\n", + "P6Yty7c1HA5TnmbPGCcfTbsFtaqoqKioqKioqOhgySxSpQ+Kc1ZYI7XmVeYwsZ+V87pwMuZ5bk8e\n", + "JvokNw15JTJapqenO9qsNQZbLYwss3GmWfRpXoyPV8ZnWly3KbOeGc5O3mfBMl220I3TGMa1t1bM\n", + "WG1VKf/vectykzAu5CWbQ0AuGPNxZmamk1tlnDacyYX7zvJrlXzzGsq0XWvUfRm5+2i15tZn8XAb\n", + "W2Qz2E8vs6ZkudHK961B23qR9Z1ZRy1HjNE538gJVO5rlh37bGTWEftE8Wp58n5R1mhzjjKPi+/Q\n", + "Lluj5oP5BMh1V/oxZmuRv9lrx+UPct1TeA/tmUWqfFZm9fb7C7Wu21cos0yVz7O107Q4lyGgz3Fz\n", + "lPlU9dE3bk3aVzDL2WTYMuW1HdHNn8Xey3eyfZL34ZPzkZkGclp5z+vrO0NmHTeqRaqioqKioqKi\n", + "YpFYMotUqflnlghgi08ZtefTOydI32H3WS8iuloQ2v9CfCTsR5JltrbVKPPX4W80UmumzmxbWgHG\n", + "jdOa1kLvvq019dFuLdfw+4zH/hnZfbXv2W2h6bsT9/gyPyNb2DLtH/Bs5rLUSD0/jrob5/OW+VLY\n", + "d8ZjHA6Hnei0bF6h35aoTKuz/4p9yEpaMkuLYd7CN9fBcvvMalDSYln0dzOLhNcosEaard2+igKZ\n", + "z0sm545yg+euZWna7ddpq3v5HtYcW/ky/8zMSmRaXAlgy5YtvXSU380s7lkGf1suPMegtGBnFnjD\n", + "spRZQd3O+8s4i3bZZpxPpbPHu6/MEtdnNXIUIq/ZurAlMruZ8bP5HnPv6Nfy/7ZM8l2sm8ARyY40\n", + "zqzGtqJNT093eJpF0vo3aRyW7CBVMtbm5cx82GeWzA4vFioY5bB2ihLa9En7+RhJW5tBTQubcxbO\n", + "DnxgyBxEy+dnYcnZJgZf7BybbRjZQuvDuB884IVg8292VZiVa+ij29/JfhB8ePW4fTjy5r2QA+lC\n", + "rxl9jbrQq8Bly5alfQJ4bqdhbyAZTVkB6pI2t83k3Ie9cT8QWQqLvgO8nz1OcaAPh2K7uLnbIy9e\n", + "syUtnhPvJVmJGL8/jnYfep988sk0CAd4v8icx59pwuaSVh9K3YarGf9YW254n8Maa3LcflHCSorf\n", + "t4zN57Bc9pPtH2B2djZVgAzez357Fur43HcgzRSjcQfp7Irb7X249Tosx8I8OgXPuIAg/774d9W0\n", + "9KU+yZQbH6Ce6UGqXu1VVFRUVFRUVCwStURMRUVFRUVFRcUY1BIxFRUVFRUVFRXPMpbMR+q0005L\n", + "HfSwkn3kIx+JiIi3v/3tI+2mp6c7d9OUTSjLZpSv3NXi0HrRRRdFRFuuhPtUEnTaZ4rU+ZQrWLly\n", + "Zefe3SUf3va2t0VE6+DJ5zj84iPw0Y9+tOFJRNfJmDtlp/E//fTTO/4Uvtt2OYGsNIjLFZDy3/yD\n", + "FnxKLr/88k45AWBrJ2n53/e+9430YVq4+6akxIknnjjyvuVlu+22a3jocdpPg2fRnhIBPNs8Z9yU\n", + "zkBe5vN7Qm5dlsN+e4zDJYJo5ySx0E4JGkoQTU5ONvQ7jcdll10WEW3JH/sA+W9k6+STTx7ph7mC\n", + "NtYJfHz3u9+d+oIg/9Dy1re+daSd/SpYH7SnvIUd3SlDAZ+uuOKKzvxkPGeOkC3TAu2EULvsk9d+\n", + "GUDBfJ500kkjfWUJN7NSGDzbaSRYF7S3/9umTZua8XpfpA37IOuDvYi+2efcnj0IntP++OOPj4hR\n", + "Px77JyIr9G05R8YYN3sX85+VzOF9+P6Wt7wlIkb3H/sElnJb0moHfuAyPsieAyTgD7SfdNJJneSt\n", + "/i1Czl0Ky+W8GA9zSjk0rx/4yPf+6I/+qFnPTtsBX57znOeM0EJ7+wraT8tleex7VwbOXHjhhRHR\n", + "8txlaux3xj7H3oWMel8BLs1F/9BS0g7dlPxxolmXI6PvDNUiVVFRUVFRUVGxSCyZRaqELRPjQm6H\n", + "w2HHagNsHXLZAVso7PGPppFFFJWa/7iSGFki0Sy02FELLtPg9tu2beto3C4BAtDieN9WrixKaaEJ\n", + "yfraZnzJCiZDk/txigInWS01DSfpy6xBgD6sxfWV/CjhJHHbtm3r8NAWCD73s0x7loB1vmhW5p3x\n", + "OEWE1wF/Z2H/9Mer56wPWYRnlvzVllo0zkwWLSd9/p22KHiexqU/MH/Grens+2Uf8NDf8Xr2XrRh\n", + "w4aI6CYWBLaylRa9LFLWVqIsQaPfJ2IYuepLxVK2m5ubizVr1vSOE2QWCa9/+GgrGpgvEhPesP9Z\n", + "tmxR5PMsgatpsrXQsr5ly5aOhanPQlL2yT6Q7af+m+9hPZ4vajGLCM32Fu+HIEthAh+coLVs78jB\n", + "7PfNtLPukYMsujGLQF2+fHmazsTrN0sOmqFapCoqKioqKioqFokltUjZD4lToHPVOKna7Oxs8x1r\n", + "3rbqcPeblROgRIxLJnBCzTT7bdu2Nd/Jck44X4a1n0wLsH/OfCUlOJ3z6vIJAA3BFoWsdA7aJLTw\n", + "6u/NR+e40zx8g3bfSwPPibWFvhIxwPfupgltH+3m4YcfHvnccwQf+3KGZdZLl/7IcpMwPmv7Tp4H\n", + "mKPhcJjmxwG29ti3Iyusm1ks5stbxWeWQZAV382sxtDukiP0U47F69UWyXFwbppx+djYX/qso7Y8\n", + "Wzu3vEC7Ew1m7XmmLbkTExMdPjDv5mVmRcyS5Ga0+O9t27Y11ilbM5wU0hYG0wLNzAVjs49c+eyI\n", + "p/jtvdbrmTVEXx5PNke2ttm6CrZu3drMj9eU16DnjByHmcXGZb+8T5R8t1+Wf2sXWrYLGr3f8Czm\n", + "3Oun5Lt9hKGBvTcr5p3R4r0pS645MTHRmR9b6pGlvvxX82GsRWowGPzpYDC4fzAY/LB4b6fBYPCl\n", + "wWBw82Aw+OJgMNix+OyswWBwy2AwuHEwGPzCgqioqKioqKioqPgpxELUtCsj4o8j4s+L986MiC8N\n", + "h8MPDAaDM57++8zBYHBkRPxmRBwZEXtFxJcHg8Ghw+Gwc6ybnp7u+EaATPPqK8Ngy4DLD6CdoBXY\n", + "IuFitT6Jcu8MykyvvtP3OHyP7qi9LC1/Vq7EmvrExEQzLkcy+ZS+cePGEVqz0h/Az7JPzXylMDKf\n", + "BeAs0sCFpoE1L2tXpbzYhwPtJPN5srboAqkeC/Jgi2WfVcgWhbJ8Rvk54FmmPfN7KjPdOwLW2qst\n", + "snzXvg0APtgfDQuMrQzl9y2/7tu+HbaWuG8X+53Pd2yctTfzkYC3Cy2g7bVpP8+yL/p2pKTnCKuG\n", + "9yJrzdlYSsuefWHcxvuj58hW4Iz3gOcx1uXLl6dZwrOKD6xF88W+YrZ4er/ouyGALv9e2IJvv8bM\n", + "Updl0zampqY6lnb2rcwC5QhDYFrY042+DOG2DGURpADabGHKstV7j+N3qM8HF567XFUWlQ1oh5xk\n", + "vpT2Ey79nrLfOVvFs/nPMNYiNRwOr4mIR/X26yPifz39//8VEb/y9P9/OSKuGg6H08Ph8PaIWB8R\n", + "L1kQJRUVFRUVFRUVP2VYrI/U7sPh8P6n/39/ROz+9P/3jIhri3Z3xVOWqQ6Gw2Fz+sv8nICLd05N\n", + "TaXRZI4E4ETtIpMATcRRHVn9vLLWlttaK3F+JGu9WX07jzeLnCh5kGmzwCdx7vhddDNr76i/8vPs\n", + "Djs7zWdWE99pA9+/83ep/QJb+5zDx9oxfOP9HXbYYeT9jC99xUr7oiojujXFMr8U52AZZx0p5Q0t\n", + "N4t8gpYsUsztmW/6hRasAl6zW7Zs6ayVrD6f8wDxeRZZ6XWVWY/K9+yvx/jH1S90/pssysnWpT7r\n", + "i+tY2prR5/NYjsc+VpYX+7mUFs1Mq7e1I4tO6rP+z0eLv1f6/5jHlvNxtda8l3vvysY4NzfXKQBv\n", + "WbRPDO2yKFXLxzh/0NWrV3d+S9gPvIaw4jA+rxPDFnr8N/ssdc7BNC4/lK2pyIktd8AFs73v9lmI\n", + "oS/zQzS8HjJrqq3FpTW1z5evj95niv901N7wKWrns3/VcjAVFRUVFRUV/0diQbX2BoPB/hHxv4fD\n", + "4VFP/31jRPzscDi8bzAYrIuIq4fD4eGDweDMiIjhcHjh0+0+HxHnDIfDb6m/eriqqKioqKio+KnB\n", + "s11r7x8j4s1P///NEfEPxfv/YzAYTA0GgwMi4pCI+PYin1FRUVFRUVFR8d8aYy8EB4PBVRHxMxGx\n", + "y2AwuDMifj8iLoyIvx0MBm+NiNsj4jciIobD4fWDweBvI+L6iJiJiN8ZJiav3/3d343HHnvsKSKe\n", + "vpfcddddI6K946QeDvWt8NafnZ3t+J9QC42aT/SFT8ftt98eEe2d6F/91V81dDw9zojo+soQpQUt\n", + "1FqKaKNJ8AeAFuoyUfeL8fE50RnQcuWVV0ZEW1PQeWQcFUidqHe84x0Nr/bbb7+IaH17eAa1k6Bl\n", + "zz33jIiIvfZ6ynXthhtuiIjWL8N1vPBL4G7c9/eXXHJJ07ejK533h5pizKfbcc/OK+3huX2HGOP0\n", + "9HTDQ9oyHubfuciohcX8E43GXN5zzz0R0foIMP/ULLPf27p16+Khhx6KiIjzzz9/pG/q0iEHDzzw\n", + "wMg4XA8PueIZjgZl/t/1rnc1/djPgPFaFsmbxrzCQ+aOGnTU2rKPCZFC8PHyyy+PiKdqVjkCLquF\n", + "Bt2O7GGc9EN9O+bUeamgCfm55JJLGp4zPuafvpEt+qa+mWuQ7bzzziPvs7+wLng2finsL6tWrWra\n", + "uo6f/ct4FnPkvhkDexlz5fpm9vOYmZnp1KtjPnk2r8gsf1NTDDm3Hyu8Zl9EFum/lAGva/jC/O+2\n", + "224jfSH3XnPU5oNWxskehhyxX1DjcNOmTc38sHfwG3LFFVeM0L3TTjtFRLsmkXOehbxQm82+NpZN\n", + "aD/55JMbPyxn++b1E5/4RES0NQLZixz1yiu0s1/QD79Z9ne8+OKLGx46P1YZ+RvR8pD5hw+sA/ZH\n", + "nuX6dvw+OAJ7zZo1ccEFF0REW2vPtRbtt8VvEeNELpAXxgm/kHXXTy3nEvqYT9OS+aGyRjOMPUgN\n", + "h8M3Jh/9X0n7P4yIPxzXb0VFRUVFRUXFTzuWNLP5AQccEBGtFnPjjTdGRNdznhMlGtkRRxzRaG3O\n", + "RI12++CDD0ZExJ133jnyPidSwCnYWWSzTOicUA866KDGsnDLLbdERKs5AufoGZeRFW3IkWRYm5x9\n", + "d2Jiohk/dGL9yKJI4AsaA1pelhGcZz/66FMZMPrq4VnLycYFnHME7QbNAhoBGghzhdzA77vuuqsz\n", + "TuYbftCnc6+U1ckjWosN7yMXBnN7yCGHNO85UopxlxnII1rt17TQ5x577DHyfebd7cvcV+vWrYuI\n", + "dj6d7RlgBd5ll10iImKfffaJiNaiApyNnzlCdk3LcDhs1uS4XDz8vf/++0dEO0eso4wvtoY6x1tE\n", + "N8KT9QHPs9w80HzQQQdFRMSRRx4ZERFf/vKXR9oj294f+nIXWe4Zh61AwBo2c4V11LSzT8APrM0b\n", + "NmzorAnovu+++0aejawZzmkGP7M6oY5ILfMneZ4cVYYlCjl3pCTtnLOL8XuvK6Me165dGxGtRfLu\n", + "u+8eacs+AQ22qmdzBK2sC+TL+8Xc3FzTB1ZCeOr93FY/W/8sT4xz7733johWbtirS2sTawpZ2Xff\n", + "fSOitZLdf//9UYJ27LHO8ZRlWXdOOOfpKwF9tCmj8kt4/hmLaxMCR3+W0fCeT3jKHgQP4UcWMWnU\n", + "WnsVFRUVFRUVFYvEklmkNm7c2FgWOM2jeVmD5bSLtWDvvfeOe++9t+mnry3v0w7LASdP4Ltit7fv\n", + "Ce3uvPPORqvHn8K+LJx+0ZzQRLOcJvDh6KOPHvk+mvjNN9880n44HDYnZuhGs/I4OZWj9btWoS11\n", + "aAG2jjkrbdm34SzKBtYCtMTMamANDVqhsbRKou2hpWA1RNtB4wBoJLfddltEtNqc62ABxoocIGfL\n", + "ly/vaNLQgB8a/HCNKY/z8MMPj4hW3pnb66+/vrf9gw8+2GitWDGyrL833XRTRLRrjWfYagCNzDf9\n", + "zpdlm7bwEPpYHwANFBqQVTR285FnMrf06/pYEa2mbH+RzELHWkQDZf3wausoNOLfg8Xj6quvjoiu\n", + "BSMiz4Ld17Zsj/WIceITBJyfDD6vWbOmMz/IM/KKRQKr4Pr160faw2O+x5wiJ55T+IKVZdOmTQ3P\n", + "s3ql9AlssQfI8ote9KKIaNeV14NpmZ6ebsaL5SW7kWD+4aX9MQG/TawH5ggZznKmRbQ865Pbkjbm\n", + "H9rZa5BpgKxz6wJfbEUux8FeybPtQwqQLW4kDjvssJHvsz6Ara2sC9eZjGh56L3atAL44nxc9G2e\n", + "u9oHcz87O9t5Fm35XbT1yzzPUC1SFRUVFRUVFRWLxJJZpFavXt1o6sARNgANhVPwF7/4xeYzrBhu\n", + "65N0FqXASfzAAw8c+Z4ztQI0j0cffbSxFOBnYGuHa6Q5A7EtOWj08MV1jayprVq1qvGLsPZnujm9\n", + "H3PMMRHRamDwxXfeaKJoGPDN9/0Ro7WM+saXZQenD/tWWSNBo4CGa6+9duR5fA5PIlotxhmIzRf7\n", + "3aBhog3asoemyjOvu+66iHhKg7GWznxbQ8pqyjHuz3/+802fEf08j2j5uttuuzXaPXRlVgCswKyl\n", + "PgtjOW6PwdGQZf/MB7KUWfXo2+u5jIAs4WzaWAOY05IW85jPvO4NfEHQuFmD1khZk1iH4QvPK62v\n", + "aOX2M8IKaJ7zXWQPa9G4LOWsm2uuuSYinhpzZpHGkoac49PjvcgWGfpztna3Zw1MTEw01ivv555P\n", + "5AS+ZBaKW2+9NSLaOUDWM1q22267xkLGOmVOAOPmdoG+keWswgN+Scw/68TWke22265j9eiT2/JZ\n", + "PNvZxTO/JPY4+8yVfGHc7HeuR2d5gQbk3DVZbcGC5zwbHz3WT2kJZPzMH8/OKj4gc/CLvqAxy4XJ\n", + "GMt6kZZF6Pa8e/8Yh2qRqqioqKioqKhYJJY0ao+TJSdn1/PJ2q9evTqNHrB1xDkqfHp1LS7fu2an\n", + "3bVr13a+k1XGRuNynSZrmq5/BTiR99X94zu2dpkWV8xGU7AWBFy/ifZZ3TfoKfsEWW4O+MKp3/mz\n", + "gPnM9/qsadDnaCr6tmxZPtA0XasNWANFk52bm+v4gtlHyJq4eQ7tWFldY9H9l1FRzFMWOen1Yi3Q\n", + "PHcNSmA5K+F8an3+ERFd/wyswfZ9ANDG+2jXfRE1jAft3JGz5iFWE88n7bP9xfyerwYdfHENTa9/\n", + "57JzHrbMgs37PGfFihWdvr13YOUwb02LLVPZHmdr5LZt2zr0u63rYmI9yiKlMkuOUVq22beyaGb7\n", + "xNiylLV3Pq75fPFsUcqiWR3dTXtHwwL45b3LeadK0Icjx5El4HXj3Hbj9nT6p11JC7zyGsssr/Cc\n", + "OXHtyqxOKPtQ+eysji/ywd5rGsehWqQqKioqKioqKhaJBdXae9YfWmvtVVRUVFRUVPwU4dmutVdR\n", + "UVFRUVFR8f97LJmP1CmnnNLcoWfZRqlZRm228v7aUQcXXnhhRLQ1fwDtnD2VWnvU8eF+ljt1Z3Z2\n", + "rb3ly5d37mzpg5pCZ555ZkR0895w7wrt1CCjPcAXhLtwxkDdn1NPPbXpyxmdXQuN+lO+2/adObTA\n", + "cz5njPjO8HrppZc2beEVbR2FQS0k5sh33dDsenjun/bQMDc316mFRt+8OoM5PPT820cCvp533nkR\n", + "EXHWWWf10rJ58+ZmnK5X5rxhrqGIbFEnDloc9cb7tKdO1MTERMfPkL+ZT2rK8bnroAFqbdG3a1oC\n", + "5Ih1d8oppzTjRJaQV9Ygdfze+973jjzbfne8UmvL9c0cDQofL7nkkqa+Xeb7xRx8/OMfHxmnLfOO\n", + "8qOmHPLlfEOMcfny5Z2akh5Xtv5d346+7X9Vrv+yPfvFE0880eHhOeecM9IHNDBO6Gec7BeOjLNP\n", + "JWOlfl5ZH9KRUF6jjngEjBe+MP/Il2lwbVbW9LJlyzrrAl65pqQj5Ly+2YtY/8BRX/49Kn/ngP2o\n", + "4PkJJ5zQ2zegH/iI7HrNA2T9Ax/4QLP+s76Zt/e///0REfHGN75xZDyO1qT9n//5n0dE97fLud9m\n", + "ZmZG6g+WbZyzjlfqpyK7wL5izP8f/MEfREQri2WdP8bCvFJrD1n0GcRzBO0ZqkWqoqKioqKiomKR\n", + "WDKL1GAwaE6StgYY1iqXL1/esTC4Lad057/xqd0REpxis+gUMDs724lM8HccITYuOsG1huBHlrul\n", + "fLZ55LbOOcMzHOUIHFno2lvl2KyNOXLOyKwh2Ry5H2u6fVm8zRdrjsAyiNab5ShxZE35PL9na5hr\n", + "QBmOthnHx/LZts5ktAD4kGWdtzXRubD6aOfZ9J3lBeNzZCjLZWZaLON90a/WmM3zLPLR7W0dzWjJ\n", + "2kV0ZcWWNEcEZVGfHrdp74sKy7LsZxF0Ge9pPy6PECitRVlEsCPkWJsZjZ5DR1SZ9+We5ug089zR\n", + "2Z6bLCu9I2+zjP/D4bAjYyCrPpBZ9rN2fO6bkXKvMw+9njNZzObZY8n2HdNY0sVvCTnwsv0R2cwq\n", + "W/TVoI3oRvlNTEykdRlN/7gcVUa1SFVUVFRUVFRULBJLapHyyTnTYDm5csJcvXp1pxI48J0/p1jy\n", + "Q1hjcDVzsiZn9/fl89B2eJb7pg9rYNYcAPlReMU/IavNFJFre9mp3lpcponaR8R3yGX/mQaZzSdz\n", + "YmthZqmyVpDRHNHlkbU688V+N8BzBZzDqqQt017sn2GfOZDxyxonKDVzy3FfLbyyj0wTN81em1lO\n", + "s5UrV6aWFvPFlqvMFwRklgfGUra3D5hz0Jg253izFSnjo2tVYsks2+PrYUur8wkB59GyVuz5Z29i\n", + "DGjqTzzxRIdu8mVlPm9ZpmrP1Ti+lJa6LHeXrdzQbb8aYCsjz2D/MB9Ly1YmO4B5Y3y+HcnWqMeW\n", + "3WRs27ats/Y8LoAsYWGBD1keKeYwy51XtvfvZGblBbYSew6zmx3/zZhKvsA7xskr+fayCg70RQUR\n", + "qm749wI4h9jmzZs7v2uZD232G51hSRNyesPw4ceACdPT0+mGzsBhNiVUfMByn4DND8ZmhUW3bNnS\n", + "HLr6rtwiukkgvaF6M/NmR/9Ojgampqaavr05m4dOMGeTqxepTde0d9LF8rvZNUqW1M5/O3Eh8Oad\n", + "HczK/3sDhU9ZYIOv/pyoE5CYjv4xS++www6p06wP2tlVlhOTcpBGLrKD2nA4bDngeHgAACAASURB\n", + "VOigT29G3jiRezZpy4vlxD9+fbR4nNlh1H35oJkdJH1V5ECJ8rsuK+G+AOudUikONuhLghvRygn9\n", + "912neLzzyW1E95AGP0sH7hIO/KC0zHA4TK92vSYzmbKS6OSJ2b5b7hsO+DDdmUtAluzRh53sWqpP\n", + "prN9zjQ64W7m2Ew7uw54vygdnBlXti4crGFZy662nQyU/stkur6S9cHBsmgFAzB3mSsIhyL+Zn2U\n", + "tNAn5diQaweEAYqbs2dZhk0j/fBaXv1lSbC99rLzRYZ6tVdRUVFRUVFRsUj8t3A2t1bkk7rbzczM\n", + "pCY3p+4fVyoBuPSDrwiMycnJTtkV921tzpqGNSkKpmKBAJg83f+yZcsas6UtL9n4Mt5mViBfjWVa\n", + "ZvmdLHU/sHOsw3fHaaS+Aivbm4bMsRu4/IpN95ZN/naR6ImJifR6JCtanV0bWDvKNK+ypJA16MzU\n", + "bo3LIeXAzui+yuy7IrcVIwuSyKwlmTndDqFG2T67/rMJH1j+0cRd8BRYXhysUVqNsquWzBpk64eL\n", + "oGelk/ocqG15tcUI7d7lfEy7i0D3XaeWNJQBMg4qAF7/dmi3nPuKk6tAW/pNS3nljZxnJcJ8tZtZ\n", + "6qCxLIRbjqXPmurAHpCVNrFFd1yQCpjv+s0BD6Y3s9R4rxoXMGUa+2hHrj3f2RU2FiVkls+zGwxf\n", + "R9Pv1NRU6mZgvmS/lxmqRaqioqKioqKiYpGoJWIqKioqKioqKsagloipqKioqKioqHiWsWQ+UpRP\n", + "iGjvpbnz5l6S8gOUTuB9/IIiIh544IGIaNPskx6e+1TuY7kL5a6fFP5Z6RSega8EKeJpPz093dyn\n", + "upQHbU03tHDnzyvlB1xmweAumNIJ7373u5t7dcZLpB9+CPCF8iP27XEEDKUTKLPAnMA32nGvfcEF\n", + "FzR0A9/Hl6UKItoSIXx+9913j4yB9n/5l385whdoZm743rJlyxpZcYkg5gjeQzfyR0kRQmWBI0k/\n", + "9rGPRUTE2WefHRHd6LeZmZmmb+afchL4vBFVZX8T5uitb33rCM32qaM95Q3gy+bNmxue2UcwK1dE\n", + "tBrzixzRN2Ucdt9994iI2GOPPSIi4v7774+INvSYcjhnnXVW0yeRjdAEb5Fzxrlu3bqR8Tqi1mWf\n", + "4B8yS0oTIoPOPffcOP7440fG6Wgz/GuYI8qPOLkr+wo+k+U4S1rtW/Tkk082a+htb3tbRLRy7jB2\n", + "ZPLcc88dGSc0Oz2E55/+7Xu1cuXKpi08L8umRLTRzIyT8TBOaEH22FecFJF1x75YRlTZb499C7lF\n", + "9rxPuNTS7/3e70UJ5Al5cAki9rrly5d3EqYyn8gWexHj45W58b7IOmIPgs+sC6I/KW9y+umnd8p3\n", + "sTbpm/JTrDlgnynauxSOfzfpn+dedNFFzXyy5vbZZ5+IiLjuuusiIuL222+PiIirrroqItryM/SF\n", + "/65/P9i7XDrnwQcfjIhRP0HKlUGL5RtfKPpm/pGt0tep5I9LBMFH5oi9euvWrR3ZYv2zRzu6G5mk\n", + "LE+GapGqqKioqKioqFgklswitXHjxuYUiIZOdFoWzcBperfddotbbrmlt1/nJMoKogLn7OF7nEzt\n", + "Q4ZWsGHDhuYz6M+iTXbZZZeIaE+3aOymhffpD82Lk7qjX7Zs2dL0OS7/iaOvnPvJgG/33XffSDss\n", + "E8xFRDcnif82X7KU/mjJ/hw+OKKiL/oJLRUNCp7R9/7779/bt/MAZdFJ5GuiXzTziG6OKmhxKZSs\n", + "XA3v8z0+R34MZPaRRx6J9evXR0TEXnvtFRGtxgmwICFbTpiXRYwdcMABEfHUmovoat5gOBw269nW\n", + "YFua4PWdd94ZEa1GCc2WF+YCixc0wJ9yTh3Jk0X6gVJbLV/Zc8r8NxHtOmPeoc2RtiW9jpDDypdZ\n", + "np2okrlhfwC870jC4XCY5kti3dI3OXr6kv2W7zsCddy+MTk52clFB8wP5syJNk0DfGPe4XlfNDNj\n", + "Zv6Y16wUij/P1j/Yd999I6KdY/YF9//44493ysjAQ99keF8oo3IjurKMJZZ15PVQysCuu+4aERHH\n", + "HnvsSJ9ZLi7PmfPTWXaZUyehdhm1iJZnLt/jvHKAucHCxOf0k+V6w7pYRpJ6PmmLBQ1a9t57795x\n", + "ZqgWqYqKioqKioqKRWLJLFJlZnBOgZx2ncGXE+XatWsj4qmTZZbnwflg6NvWL4BWb80T+ESKJr5l\n", + "y5bGUpCV/HABXOfysdYILZy8XQLBGsyOO+7YjMeWKWsvmQUiK17Lad+nfudNKd9ziZDsNM84sBIB\n", + "NM9bb7115H3ndnK5itISZN8mvoPGxHiMMit0RDdjNbCfC3K1Zs2aNJs82j9WHaxDWM0A68GZvhmv\n", + "ZRQLxYYNG1LrBMBSleVJsnWMtUa7m2++OSJazc0WjPvvv795D8sycmwLI7KJNQQZhuelD2T5LLR+\n", + "W19LC5Z94ZjvrPyOtX3Pr9eorUSugFCuO2TOFkZo9F5kK0hWSgk41xsYDoed+cSCgtXvrrvuioiW\n", + "T6VlNaKbPZ69yVnXgcuZTExMdKx7gPHTp318bJFk3dD+jjvuiIg8+zZrcmJiohlXX/HciHY/Z1zI\n", + "PXNjS81RRx0VES0focXrr6Qls7CZltLfshyfy9B4nMgXY+2rbnHwwQePvAfdfNcy5H3fvM4KybOG\n", + "nVOulBfnl4Ne5KKvgkdE6xPJuJ3JHTB3fcWi3Zbx05a9y7wch2qRqqioqKioqKhYJJbMIrXjjjs2\n", + "p1r7wPhEysn13nvvjYinTr+cmH1K55TqgqGckH3/mtV7yjK3lgWFXdMpO6VnVh+fdjlpW8vNMjtv\n", + "3ry5U2MtK0aMNuf6Tdl4aYcWwCmf15IWW6ScJTbzp2CuHAHn+UdrgH8uhFlqU3yGP4WjTMxDxoM1\n", + "yBF15qNr7YHp6emO5cXZg9F+7ccHbIlBQ+P7fiZj2X333TvRJrYYuEAoWh7asmvSsU6wGjEH8Kkv\n", + "gzj+c4wLut03NCJbrCPX6/I46df1HsuxZsXM+2QlopvZ2rQYjhy0rJfy4vnLiu8CxmFLXlZ9wJFF\n", + "0G5fqojWr8xRetk+x/6JZm5/J69prEZlJF62LwLaumap90msoFhR4B9y5TktrSLO5O81hPzDc+9Z\n", + "ph1a4SOv7N3+fVm1alVn3uE5fYG+7Pglzf69sG+hZbe0hME7ovP43cj8r/jblpmsULSLgmfFziPa\n", + "dUEbV7bwfNr6a4tbNqegpCHLVM7tCL5kWfWRDNUiVVFRUVFRUVGxSCyZRWr58uXN6Q/NxJW0AZaK\n", + "8jWrnWXtLKuxBKzB0h6NzLTQ/9zcXEeDyqw6rm6d1VpzDiCf8vtgTRoeuW/feZvX1qSwElqrxhpQ\n", + "at6uoO36ShnvXVvOfhaAZ5a1Fsv+Sxlw5BwaFXPgvtEk8XeDD5kfm/NplX5htoLYYpnNO7CfhS20\n", + "mR/fypUrO7ljrNX2WRLnowlLFMASY18isOOOO3YiIOGHeUi7TPO0BYsxoTVCA1aEcqzORWbfKNMC\n", + "ra61lsmua9BlmnlEV5u3JS3zqbP/WhY5Bq22Lk5OTqbWS0ebZtHJ0Eo77w/jrOuPP/54IyO2pDmP\n", + "nq3ptqbaQu+5tAUC6/uWLVs61g6vC88zNFiOgKOBfYtgPq5du7Zp69sP04I8m5bMv8+RcY7ILucE\n", + "i6QtkRnd9r11/U/TkvkW9kWom+f8nVmNPc/2IfSehp+bo8effPLJzrrg9w3ruGnxfpGhWqQqKioq\n", + "KioqKhaJWmuvoqKioqKiomIMaq29ioqKioqKiopnGUvmI0WdoIjuXbDrflGbp/RLcK4dauFQx8n3\n", + "0dz1cid6/vnnR0Rbx4n29tehvWu5lfeyzmlFHR/GmOWu4T6WOk7U5jOgjXtr+HLWWWc1dNq3B7ov\n", + "uuiiEbrdDnA/T222U089dYRG5zLh/UsvvbSpywScoZa/qYUEz11Dynfa1Amjvf0wSv8H+natPfvS\n", + "MW54Tt/2y3COHuTLNcjKKEjz8D3vec8InfZ9wBeI9tACjfYJgy/QQt2vmZmZzt0+QG7Nc9OCnwX1\n", + "EJlT+wjYpwZZPP300zu+Cs4tQ9/IFrCvm2ttmuf2T+P10ksvjXe84x0jfbiaAN+l7pdpAcwBfKFO\n", + "HHw0rdCwYsWKZpzUfLM/kSNr4SH7hdcY48Zf6eKLLx6h3f5tZR1Q9iLqjzmSjnGyt7gGoX1qXO/0\n", + "/e9//wjtpazb/yzb5yxjrhNJe+8r8Ml1//pqljJf5jnjzKK36ZvafPDcvlOuvQgfTz311E5kp/ci\n", + "1jNrzjnwAOuI+adeqH3E+uQLnjgyznuT5YW5w2cOX9ty/y/5wv5g37S1a9c2v0XQwvgcOcgzszp+\n", + "fO49m/6pn+i8ZFu3bm3eo75luYeWfHCkLOs/Q7VIVVRUVFRUVFQsEktmkSp9s8b5afXlPsoi2WxZ\n", + "chZVW4ey97PIqjL6xfX7MouJae3LrVH2nWUKN03btm1Ls+Rm+TKyvgxrUfOBZzkKI6PFVhHT5Gda\n", + "a7Jmmo21D5ncOOu8K40DW6KYs+np6c4cWNMyX9zeUYx+RhYVWv4/yznjPrLKAIb7NX/K/rNxGlmG\n", + "blsDjCxSroQju/iOM/MDNGzzPMsjZEs4n4+rzdbXVzaObPxZJJ75Pt/aXugc0c6Wmixa2nmDhsNh\n", + "Zw9238DWQ69/r3fLolFGpFne++TWdJftszXblzW7D7Ozsx2ejVvPtoZnEcT+/rgovz6Mqz7BM7kl\n", + "8jwDLFH+Perje/b7kK2hLIox2+uyWqyzs7OpdTj7jV4oqkWqoqKioqKiomKRWDKL1MTEROeEnllq\n", + "XFG6PIlnOUrcV19ujfJ95/qwn4L7n56e7mglzn+TZQ9mHNYwnOnVuT6cCXt2djat0m1kJ/Ess7mz\n", + "8WYaeglrUlktMJ/2rUln1b9tRbH/WzlOW7kyS5wrroNMc3d/Wa26so/MOpppu6WVq3ymczeVmr2f\n", + "ZViTzCyzIMt4nFmy5ubmOhbVzHpln6hMK8xom8865hxsnt9sPs0/vuf9xfPOenMun/L/C80L5PHb\n", + "GuT5p719ZPr6dg1OPnf+Hz97IdbQvu9t27YttVBnsuV1Dbz+yfHkSgegL5dexvPMIpXtd8515LVs\n", + "Wqanp1PrsN8fZy0ZlwtxvlxPmcWtbw8tx4F88Ntmq7lpyG5hStoZp/NHZtYxW6LH3TL5N7/cA7Lb\n", + "jiyze80jVVFRUVFRUVHxX4wls0hNTk52LBGZNm2ryWAw6GQwB5ykORGT5dbZUA2fdukny1y8ZcuW\n", + "jjYyTsOwv4a1F2eR9Zg81sFg0HnmuFO9NY/MFyDzpenTijIasjt6a0W2YLg/a4G+ty8zBPvZtjSY\n", + "/qw2XSaLmR/PqlWrOv5U1vrcp9tnY8j81co5Guf7ltVDzCyS5rmzrVuOBoNBWq8ys3Y6iinTTO2/\n", + "BvosWNZWnWnZ819WKijboYET/QqQNUf12I+zpCXz7emLtusbV7aekF38vEqa+uanfGUczOu49W+Y\n", + "RvorLTnO6O621BL0/u+16PUDzcyR+y/3esu515znyD6BmaWCfuFzVldw2bJlHdnKLHW2pLC/ZRUC\n", + "+DvL8F3Ki+lGdtwHyCLqMgtOto/2VRRgvpgL2jBOyy6Aj765MV8yWku/Zvc5zpduHKpFqqKioqKi\n", + "oqJikVgyi9TKlSs7J8rMa5/Tbulb5BM1sJ+SP8/uUx0xktU3K+uJWcO0tgMt9O3IoXG19pwvx3yZ\n", + "mppqTvfj6trZd8S5WLLoNDCu1tJ8yHxkMkue/3YEiev/lXNsHvFZVscJMK9oRZkfky0cpWxaVjKr\n", + "gPsCWE/tEzLf/NPeFtfMeuEIIP62Vg/oj7FlfkyTk5Od9WyrDch8vcbVtwPzRaVZw/Z8ZeufWlvM\n", + "QTb/lkX70pRjtcbNZ1kNPfYLtHrX/3NtNnIc2So2HA7T2nn2t+PV1nHvuSCzYNAe/s3NzXVqi5ru\n", + "zEJj+bBMU0sts6YxlyXt9g0z3ZapLFIuu2XIbjqmpqY6bfr8KUu4RmG2TzJ+51djHZY0eR3wjOwG\n", + "w7+HpsF8ZE5tyevzY0NG3Be+beOiE0FmBfT+WdKU+YZm67n6SFVUVFRUVFRU/Bej1tqrqKioqKio\n", + "qBiDWmuvoqKioqKiouJZxpL5SJ188slNvaZHH300Ikbv1yPaWmuun7Vq1apOFBm1kN73vvdFRBvJ\n", + "wt3tQw89FBERjz32WEREXHXVVRERcdJJJ0VEe4fL/Sp/c99MnagTTjih6RcfAOjFd4daSNROynJT\n", + "uaYgNYjs10N0CzRRg+i0007rRC/y3QcffHCEbmpKbdy4MSK6fltlvTL6jojYY489Rj6nZhn+Guec\n", + "c05ax80+DNRCguf2+WCOdt555xG+MP+O1kB+ItraVmefffYIH2655ZYR3uGHwjjf9KY3RUTrI+Uo\n", + "Ne766d9zij/Lbrvt1tDFOOELtCCTzMHuu+8eEW0dpxNPPHGERvgJn/AhoDYX9c2mpqaaNQS9yCK1\n", + "szxHjO+BBx4Y4SXjPOecc3pphj+sVWg/7bTTmvfok7XE+9BNDUJoYN6dL4n21P2CRngObfjMXHTR\n", + "RfH2t789IlqZY+3ss88+I/RTa5O+4Tnt7UPiup/wEd8j+n3kkUea9UktNMa1adOmkXHzvseJrLK/\n", + "2Ffqsssui4i2lh+0I38rV65seMR8soZY73vuuecILx9++OGRcSJbjBNe8wzG/fGPfzwiWtllHQ0G\n", + "g04kFzUI2ecsqwDfl/POOy8i2r3L8gFf4Cv7LrRPTk42+xUyAk9da5NxIbOsp912222kvWvK+TeM\n", + "McPHc889t5Ghu+++e+RZfJffOdcJhW+77rprRLTrn3Eef/zxI8+85557Rmjmt+9DH/pQM07k25GT\n", + "zCeySL065t/1/5gjyxd7HXMCn1asWBGf/OQnI6Ldcz3v/s1lj+b3wvmnGANyxLpDXhhbWavWtRZZ\n", + "o6xf5jGbowzVIlVRUVFRUVFRsUgsmUVqamoq7rzzzohoT+qvfvWrI6Ib5YMmUmYfP/zwwyMi4rvf\n", + "/e5IW07CWFI4xf7kJz+JiG50CloNkR5oLJz+Od0DTvkrV65sTry85xO282McdthhEfGU1lrS5HGi\n", + "1UHrzTffHBH9kVVoO5y6b7vttohorQAeJ5qZrVyOjIBvt99+e0REfOlLX4qIiKOOOioiIo488shO\n", + "W/qib0738Ac4/w193nHHHRHRWigA34dfz3ve8yKi5cfXvva1MNCwr7nmmohotVsskoA5Q1O5/vrr\n", + "IyLida97XUS0lj2AbN5///0REXH00UdHxFNyg+wB/sZiwJwgs44goR1ziRXoRS96UUS0cwHKjL/X\n", + "XnttRES84AUviIiIvfbaa6Sts+MfdNBBEdFq9/fdd99Ie2hlTl72speN0PaP//iPHVqcQ4b5LS2H\n", + "Ea0myXh4xm/+5m9GRDsHwBGHn/rUpyIimj3gkEMOado6utB12rB2lnRHtPJy7LHHRkQ7F6YFONrn\n", + "rrvuiojRdcezkVv2gRe/+MUR0ZUt5sYyyZ5kPtqKztzss88+HTmHXvqGtm9/+9sR0V2jrtaALGPh\n", + "2XvvvUfaw0eeu2bNmmbvZB8A7DW77LJLRLS8dyZq0+7s/OvXr4+Idr8EyNfGjRs7UWrsTaYFq8+P\n", + "f/zjkc/ZLwF84vfhwAMPjIiIz372syPvgxUrVjR0Q+9xxx0XEdHZL5x9nPXDGDxOaGGf4HcUGS7l\n", + "xRb25z//+RER8aMf/Sgiotk/AONg3TBHrHHmDsBzXuEnVrK+PFLspcxJFrXv3FfQdOihh448AzBG\n", + "+odvmzdvbngKmH/W2E033RQRrdx7/jMs2UFqxYoVzQJ7wxveEBHtxnLjjTeOtIWxbPaTk5OdEFqA\n", + "UHEw+vrXv948LyLiiCOOGGkPYx1qilCycQAEaYcddmj6YiK9iGwmZnxZ8VWH3EIbguaNdHZ2thnX\n", + "vffeGxHtxPMjA+iDBcW1EhuH++bZ8PyXf/mXI6I9oJaHQJt7WXS8Zj/q3jB+7ud+LiJaof7c5z4X\n", + "Ee3CYeOBn6961asiYlRe4Dkb+kte8pKIaH/gvvjFL47QwsJnbjggIl/wFbDwfCB9+OGHO6VtfP3D\n", + "nGRlaZCt8scoouU5V2bu/4knnmjGyasPo/Ca+eRHDtp8zcocwevvf//7EdHyp6/4L5sP68KbFmB+\n", + "uXblMLrvvvtGRMS//Mu/9H6PA9crX/nKiIh4/etfP/J+H+AZSpvXv69ob7jhhohorwKRJwAfmSPk\n", + "xlflEa1scOj+pV/6pYho5diHV/YPH16YS//AOIkk/T366KMNL4GTGbK/IceZ8sqPkFO3+Eed/lES\n", + "V69eHT/84Q8jolvCxrQgY3arAFb62JMZrw+BtL/nnnuaK0z2yazYMn1zQITnWXkbgDKAMsj4v/CF\n", + "L0TEU3KFnCOnrGd+tAHzD60/8zM/ExERn//850doAv7t+53f+Z2IaPfjco9mf4deFMyXvvSlEdHK\n", + "8Te+8Y2I6O5ByAPtPEcuJYTCQvvSyOCUG9l+COwqgrGA8dnY4cLJHOoeeeSRznyyxqCPK0pkjH1j\n", + "HOrVXkVFRUVFRUXFIrFkFqm5ubnm1Ip2c91110VE1+SJJsbJc/369Y22i2kVcEpHM+C7WAOyEiGc\n", + "qDktc4rNkoNNT0832jyakU+7NkljOeH6xVYgaGD8XBdgLbDWODk52dDDd+jTWqDLcaBZoQ1aw4QP\n", + "+++/f0REHHPMMRER8ZWvfKUzVjuZOxGpk6TCN6xEaFxYAQ4++OBe2vneD37wg4joWngiWm0MTRvL\n", + "GxoYFkvTznjRLOnH1lH4x5jQ3LZt29YxA9MnmiTmf8aZJfHDmgptWElsHS0tUs997nMjor2K4hoB\n", + "MBeM65vf/GZEtBq4r6Xh+QEHHBARrUVqv/32i4iWT2jew+GwWZPwzM6yANnBWoCMcYVt2bVcIYuM\n", + "9Tvf+U7T1skbnfwv4zn8wSrA1YWv3+zwDE1clZbXWDwT6xBtv/e97408Ezg4A/5gFfD+wr5g5+tH\n", + "Hnmkc81qR314zP6ZJc1lX7Elx3PEWHjOLrvs0tBlS6qvmdjXsex7X4QW9ihowrpo2aX/1atXN+Nl\n", + "j7YLA397ntknnByUv5GrL3/5yxER8ZrXvCYiuldBk5OTzXtYc7MCx3aepj0WGFswy9uRiHZPZ48u\n", + "k+eynlmLWJ6wjrHnAAcCMCf0Y9cR2nMLwV6ABay0BLs0GDx1YlHgxJ3QgrXIFqksAer09HTndy7b\n", + "F7Gmsq7HoVqkKioqKioqKioWiSWzSE1PTzcaGtqznSwBd958fuCBBza+K5nlhdMrDmnA97BoL75D\n", + "t+Ov+5+ZmWksBLYgAE7Y69atGxkH1rKsXAlasUP27UA6NzfXCQV1GDxwKRw0B0739pFx0UosOryP\n", + "w+yVV17ZKb+A5QieZmn50WqwMNA3tJkfWJfsrFzy3bTYvwJH9U9/+tMj44NWrD9ovXZOhn/IHa+r\n", + "V69u5hVAJxoVc4XcZMlwkUkXsbZ2zBhXrlzZWC+hG4sRfmb21+JvBwgA+kGDxfqHX4LXxdq1a5u1\n", + "gQwity4rYwdffEiQUdYLQPOGj1i86Bfn2i984QudArfIN5YX+zG6nAavWEfsKO3SEU43UvbPPKIF\n", + "4yuFtSsrX2Ua7YQMXN4Jfi9btqzjy8M47NCblS1hjthzoInv24LjMjgbN25s6LLFwPQj11g7swK6\n", + "rBvGiex6v4BPWFsiWrk3X3g28s56dpkj08yz8TFC3vx7tG3btma+aYMlNfNLxJrz13/91xHR8t58\n", + "ceqbW2+9NSLadVXeBMA71gP+pb79AfDL+ye/dbZ4upSMfXbLmwDGaTlHRr3n2nKHnCBXmTUdfmV+\n", + "XeV78BArF+cG+/dmqBapioqKioqKiopFopaIqaioqKioqKgYg1oipqKioqKioqLiWcaS+Ui9613v\n", + "6kRvcC/P35RCILcDWLlyZSc654ILLoiINuU796/2r+B7pJMnzT7tuJ/lbpw7VKfCX7FiRScZJvRT\n", + "ToBSBfjGOBeL0+xTOsP39M4XU5aI8N00fUI/qfApbWC+2f+GUjuUCKBfnsNdO/y9/PLLm7Ip0Gdf\n", + "McZNiQhKYeA7wrOd/4P28LEsgeHnUE6A+Tev+S7+B5RCoMwG7fzKs5Avxmr5KHO8XHHFFSN0A8Zp\n", + "Xwd4Tnt4zvhoD19cxieiGwnFeBknbekDup14j3VBGQ/zwb40lE44+eSTO9Fj9i+h7Tvf+c6RPi2L\n", + "PIPyNpR8APiWQDPr5cMf/nAj546uc6QQskXfXmPwhWfBR2j33JR/Mz8ubdKXWDiiLbPC+ncpGfpm\n", + "DbJfILv2tSr5zl4E3awx9w2Y/0zO+T7jplwJ8lXKR9Y344QPnhuX5aG8CbTgt4O8MP5PfOITEdHu\n", + "0TMzMx1Z4Tsf+9jHRmjxOGkPbR6n9xfv2WV5M3hlWYRXyBZ0Q4vLd3n/P/PMM6MPzBFj/chHPtLM\n", + "J7R4vwDsc6x/R9TBe/6Gj9AC3+ADtM/NzTU8IfGuy07RFt8uEu+eddZZI7TbZ5BnkXTZpbnKOeK7\n", + "7C3l73lE6xvm/HKs6QzVIlVRUVFRUVFRsUgsmUVqcnKyOVE6h4vzpXBqLk+kthwATsw+lbvMBODU\n", + "yimYZ0OboxPoZ9myZc2pHs3KtPh0zncZryNI6MeZv615gampqWY80OLTfdm2HD99enzAmrY1tHKs\n", + "1hDsd5flbvG4+NslImwt4Hl9tPB/lwgBWb4ca1wuqeLvu5jr1q1be0v4lLTwXVucAFpQxnvnHaLd\n", + "zMxM0xYZspwDl0Sgb/Pcc+m5cv8TExNNX4yP73gObJmzhm45t1XBc9wHPrOseP6JtGTvcZZ+r1Hz\n", + "wxG25RzZuuF5z9aJo7F43+OlX6/NmZmZDg+RTefkyXjoz12+xXNqS9VwOGzGZx6ahrKwbdmH4XVk\n", + "fs03DvcB6Mu3BMxvn5yX3/NtSt868jrOeI/8+7fH5YiA58B7Utnetyfmx4eztQAAIABJREFUi3no\n", + "0kqGx1lansrv25pe0sBrH7198HnB/DRtvJb7TJY93fNIO1vsMlSLVEVFRUVFRUXFIrGkFilgbcCa\n", + "uk/ek5OTadtMkyA7cFacl5xGnIqxTDh3T5kp2UVDXZeLMdIOnyCfekGWs8p35mBqaqrjP0GbPutV\n", + "2ZcLO86n1UV0NbGSL767Hgdo8x13dm9vq4LHVOZjYRzOm4V2l1k77FvkZwFrXHxv1apVnQzuztUD\n", + "D23JNJw3JuNrOVZbu7KcU7bqIZvOsWKNMst5VI41y1js+bR/iXmajddaMO3L95lP+jANtnYgF7T3\n", + "uLz3APtF0m9plYSu0oo9H+yPYouUrQPOylxq0Zm1wvNJO2eqNk3k6nH+NGCL3GAwSC2MnmdblrwX\n", + "2VoAj1k/pp05XLVqVcdXJ7uR8HftG+j2zpuF3JmWZcuWdfLpZdbyzAqa3UiAzMJf8tEWM+8t5jnj\n", + "Mf9s7QHwyVYj2pV1N+23DDLLm2ket3+6EgDy0pdfzfu/fYKrRaqioqKioqKi4r8YS5rZ3FFpmQbj\n", + "7NNzc3NpXZ6sfg+nUmtSttDYV8YofYqgi/ey+2Q/K/Ml8hgyawDYunVr6ndhiwrjZpyc5unbvlJZ\n", + "Nl2e56y0JbIM78AaJrQ4CgvYsmMLVml9gS7fozM+j9O0WH6seSEXtoiuXLkyzVTvyEH7MgCeZWsB\n", + "33MmZPg0GAzG+oJkWqtrTQLWouUrk8UtW7Y0PFmoRc3I2ntO4ZOj4CJaXmW+UVl9O685eG2LhP1Y\n", + "3G9pVYYunuHIscwi7TXK6zjfw1JuPE77GfIMW+JNC7Qj90RaeR3Bt9LnMLPyIfe2Emd7i/16Mt87\n", + "UFo8Lbe21GY+Q7ZUur2tYq4YAaanpzv7lv3wgG8N7L9o2h3lDGyNL/vKLFGeT8ui5d28J5rb1uW+\n", + "Pd1WPZ5FxLz3XOQFWh1Z6znC79E3HBs2bOjsc/alhjb/Xo5DtUhVVFRUVFRUVCwSS2qRstXAWjNw\n", + "Po1t27almrRzDHGKt9YDHLXhOj1Zjpa5ubmOP5Y1gyw6yX0BfGwYL1oPWmCfH4tzrzg6A9jiYm0o\n", + "q80FTZzu+yw75qExzs/EvgGm3eO2z0lpkXAOHmsYvld3fhxbOjNfE/sKTE9Pd+i0NcTPyny+zEfk\n", + "yLRYGy6/m0Wn2OKCDJovjnpz7qMs+qmkx1FlwHyxFcntsYZAsy2ZfVZikEWxArRgW8ft3wgsF1h0\n", + "PLcRrSbNuJBBWyIBn9tXyDmKAM82n2dnZzsRpPaJZF07cs7tPe5sreOXUkacwSNbUoH9kDJLHTx1\n", + "LdbMMuUal2WftupkUavAezpzYf/OzHdsxYoVndqZpgnY0mrfIM+pb3Ds31P2799Y1xg0LZlFN4vm\n", + "y6zOfZY91/u0L6GRWcEzn0rzpbx1yG5qkEX/vmV+WEa1SFVUVFRUVFRULBK11l5FRUVFRUVFxRjU\n", + "WnsVFRUVFRUVFc8ylsxH6pRTTkkz/AJqClGDrC9igLtN6jKV9cciuvktuC+ldpLrVWV+PtS3cv20\n", + "8jvQ5bam25l9XTvLfHEURlmDyr5PjlL54Ac/GBHRqUGW5dOib+rhZaD9Rz7ykaa2kfkBeCY8p46T\n", + "I0HsfwJfXCeuLxsxfVM7yTz339Qgy/jiZ7gelvk9MTHRzA81pTz/WZ4U2psWf898oX5aH/gONaKY\n", + "o8znAbim5Lj+4cupp57aods+D66dmK1/5IC++9Zc+X3aX3rppR1ZdFvodt2/+WQroru/OFqvXE9l\n", + "/cH5UK6hiHZd2NcFuE6ga7OV4LvUFEO2skg670WM0/43fqVOZN9YLbeMk76d68u5nuA5+6Kj3UwL\n", + "Yy3lJdt7WRfUoMuiU13L1bILnHcN2t/xjnekPqIgm6NMJj3OLAq8XBfZvujfor46niUsD8gi9fCy\n", + "fWViYiLOP//8iOjOZ8Yf12YErlLCXDBHZ599dtqe7/zP//k/IyL/jfb6Z01nqBapioqKioqKiopF\n", + "YsksUiWsLWZWofLEbUtD1pejjxaaX8fPmQ8+xfbRWz4r6zt7lnNzlO9nOZscdZNZ/bK+x0U79fXh\n", + "7NnZeMbVgRvHc2fn7kPG2ywKL/ue+WbLVak9OhJy3HfH0ZxpSW4/HA4785XJnl8Xstb8rPn6Lz9z\n", + "7ppxfWfIahNm/ZVtF7qnjFsf2bOy9bYYLDTDO5hvzfqzcTUHx/nKZtagxSCr45hVMLDMgnGRteVn\n", + "2Z6UzT80jdvT/XdfNGv2W2Vke1FGY2Z1XwjGtc36zvaNrJ5oX5Snxzlu73qmtGfR8WX+SZDxbtxe\n", + "bVSLVEVFRUVFRUXFIrFkFqnBYDBW0+77znyfR3RzdVhrsXac1QjKMiGX+VTmq3A9H532HQDOPmwf\n", + "kL7cQOOyaWe0mC+Zz0Q2htJyl2WXzzCupuI4LXAhfY/zkfIzs7//M/B4xllJrHna8pb5QJSymNGf\n", + "9Q2e6fzPN+eLzSuWwXy0haqvv3H0Z8i05QyZb135Xc975gNFPh2v+0xe5ls/z9Sqk83nOBoWgqw6\n", + "gn0/s3U+rsZcdotQzv24fW4hlpTyb1uest+X8vvj1mifv135d7an+9l96yLbazK+GOOswhlNfc93\n", + "/UvXLfR3yXnmvGRZ3jl+0+mXvFUzMzNj13fG03GoFqmKioqKioqKikXiv4WP1H/GSjDurnahyHxI\n", + "5rtTX6i2aytApmFYgx3nz9N3/57d7Wb8WCif5puTcb5g4/pcqL/GuLnp63Ocv9ZC/brcfx9tmV+a\n", + "6c58QUzTQp+9kDaZlSvzhRtnLXsmzxhnYR7H+3Fz1/feM7VIZjJsjdSyN59v1H/W2pnx0/31Wd8W\n", + "6vs2zufNr5ml5pnUVfQebTl5pnt3xpeS7sxSks3fOMtThmfi/5dZGBe6n46z/sz37IXudxmy2xRb\n", + "MP288v/2W86qiXgOx+1FtnSVz1mobC3ED7dEtUhVVFRUVFRUVCwSS2aRmpiYeMbWg/Lz7GTpE+S4\n", + "E6U1Ep/+/XmfJYZnZHlfxuXu8bPdPhtDyQN/Z1w047j2z8RSs1ALFMgiihZqDZovWsVa+jONEHPf\n", + "tkhkeXiGw2Gq3S40Imyc71iGZcuWdSK9Mo3Q2tq4qM2FanB9UXtZlXuPc6FzNJ/fRYaFytS4PQeY\n", + "X+ZTSVPmG/RMrSPZ/mKa5nsve+a4KD5bUXm17+h81uFxz8wivtzPOB8x0LeOMlrGyV5WU/LZkNHF\n", + "+jNm/VgGy2cv1hdoXLQjWKjvVPl/+0RlvHK9O/vBeo5cP6+0TC309gNka86oFqmKioqKioqKikWi\n", + "1tqrqKioqKioqBiDYa21V1FRUVFRUVHx7GLJfKTK2lyAu1Dev/zyyyOirfvDners7GwTJeD6ZtT8\n", + "efzxx0f6Wrt2bUREPPHEEyPtXVNs06ZNEdHmnthtt90ioq3NAy0zMzOdekzQT00pagQ5zwX3ydBO\n", + "nbiy7xKMgedRx+nUU09t7pehe8cdd4yINtfG+9///oiIOOOMM0b4smXLloiIWLdu3cj7ZR2/klae\n", + "7VxWl156aVMjDGT+OtRxoi4X+T640ya/SFb3y34ZJX9cUxB6oYEcPdBGjbDTTz89Ito58p0470M7\n", + "Y/W9/OTkZKe+oes4wcvnPOc5EdHy3LW27M9k3zmvi/I7jI/xXnTRRRHRyjk08oqcMwfQfuaZZ470\n", + "y7w7IqiscUhb1sEOO+wQEe2ao3YW9e3G+a1Qaw+eMyZocEbsD3/4w51aePAMeUfG4DnrwhE+0Mw6\n", + "gi+sC579yCOPRES7jqanpzty6/VuvxRkkf2CZ8Nz8ugwJq9Ry/rWrVub91z3ExrMO56BvEA78s+c\n", + "rlmzZoRf7KOso3K/4DvQgqxAN+NkXLvvvntERDz22GMR0a45ZNe087r99ttHRFv3rVwXfIf5Z89x\n", + "W/piHSC7zAHyguwiF/YN4nnUfTv55JMbXjn/EWCOWHPeD5kDXvl9QXbND74H/y+99NKmb2QPfjA3\n", + "lkXXffWaYy3CF/gI7Tx7jz32aJ7ndcF4XGvRfKE9NEMrfyM/n/zkJyMi4sQTT4yIrm/h448/3tB9\n", + "5ZVXRkR3j2Z8yAnPYO/KsGQHqbm5uY5TGAzlFXgDmp2dbQTcP65MDj9Sdo7kmYBn8/7GjRsjohV6\n", + "H/bKhQk9/DD6wORnjSvbwudOzMlY2TBKWmhLm8xp0I53CDrtzXNvzvyNIJabgQ9O48KYvXidmC9z\n", + "rmes8LVvrE4tQFsODNCf9Qkf2dQtXz6wlD/Q5iH0+UDE+DPHR/oEmcNjWdaIcfiHzn3QjoM3sOza\n", + "wRO+2FEUrFixonPgYzPKnOrhOZ+j7GQlZXzYYS7L9llwgPsC0FAeQspxmveMiUOAE1f2JeT0OKE7\n", + "O7S7ryy1ADT4B2ZycrKRd+D5skLkv3k2B4qHH3545BmWL/ZN+pmammr6YC81LaZ7nOM//EJ2s72O\n", + "g9js7OxYx2TPAe1RSBk3cALnzZs3j7zv/koH53GpeZA9eMl+wiE324uAD4vlXpfti7Tx3oX80J59\n", + "BdrMe9Yu/T366KMR0fKROYloZYTXhx56aGR8PAs4Ua1/w8wH+AUY2/Llyzvz798z9lT3MQ71aq+i\n", + "oqKioqKiYpFYMovU1NRUc7LcsGFDRLSnZGsknII5cZfWoCw9wa677hoRXTNgViKGkymnXGiBNsCp\n", + "eNOmTZ1rFFsSssKXaJ4+HXNCx5qG5pWZPkst0tdotjDYFM2VBOPMrGn0i+ZlzaUPDq33OF0gmnFk\n", + "iUrhhzX8+axjaDe0gX5kCWDlY+7uvffeiGi1JDQtAK3ICZrWihUrOtYuxonlgL95VqYdMQaXUrAs\n", + "lteR0AU940oEwdPMwgSfoMkWT1swZmZmOiHy0O91YVr4/I477uj93NeKtDefymejUZuHppv2jBf+\n", + "+RoWMJe0v++++yKi3Ud4jWh5inbLeob3Xks8ExqhGZ6j5QO+/+CDD0ZEaz3ZcccdO3sFz2TNsR6A\n", + "5cWyOy7hL1YE+n300UcbXtqSbqsocp3tc7Rj/La8WL522WWXhlZ4d//990dE19Jq0Bfj97qAj/Rr\n", + "/vRZX31dnNHAd30z4z3L7Zk7aLPFr/w/34EGXxsC7/+WTf+O0p45Ryax7Jdg3pAZ1hhz5N901jK0\n", + "2G3HFizG6n1j1apVHUuT9yy+k81nhmqRqqioqKioqKhYJJa0RAza7n777RcR7enPmjf39Gg2MzMz\n", + "HQdsgOWFU68tUtbE6If2nFhtNQGcnrds2dKxHPmUvueee0ZEV9vj9G4fKk7WnMDRrIA1mbm5uY7/\n", + "SEa3fWIYR5aQz4Uk7bRb9m/nWfuXjDvV2+/AFokDDjhghBZb0UoNBvrsyMgzrGEig0ceeWRERDz3\n", + "uc+NiFZ7xEIFsFDBn1LOzENbqGx5s7zQ3hpb1l9pBcksR2CnnXaKiK7lkvVijRTfBvsjAP89HA47\n", + "VgvWmuUfutFWkXf6xMpT9h3RdaZlrOWaps0DDzww8izWqjXSgw46aGS88Afrh9cofGb9eAwl35Eh\n", + "3sNKbhkFzAVj8LhtHUM+jjrqqJF+N27c2FlzBM3wTFtJsxJBbs+a9jpir2IvX7t2bbN2bEnjWfCD\n", + "vniGQTv4Yf+00goY0fJx+fLlzf+zBLP21+EV2r2O4HlWKNlYs2ZNQ0P5+xWRW8eZZzunl35GEe3c\n", + "0A4+sT7KsVp2vOa8Rm3Voi9+m72OXCCYdcLNRwnodTFiW3CBb5PgE7TYgsXc2DK1devWTt/jCocv\n", + "tEh3tUhVVFRUVFRUVCwSS2aR2rJlS8eXxqda4JP7ypUrO1FlAO2UkzCn1Uzzzsq6OGIGcHreeeed\n", + "G0uZ75sBWnEWteFnO5rLPkD2qVizZk1zirfvik/pjggCWeRDFq23kGKOCy306fFDs9vffvvtEdG1\n", + "joHyb/sZWbv3+Jkj/EvQ3GyxAfDRvnXD4bBjpcmKb2bjRGb5HhqXo/9AGXnp+cn8kDyvmcZli4Wt\n", + "i33zb23OkTAAixM8Z73beuB+kX/kwOHhEa3FINMsLefXX3/9CK3QkkXtATRbR572+es5kpg+LVuM\n", + "h+9Be7Z22RdtfV+2bFm6b8EXLFSZBduau63Otkjh34YFb+XKlR1rP8CiwP7pNZdFrdqSYSs7uPvu\n", + "u5v/Ww68LuC5LSnZunDEsX+rzPd77723s3/DuyzqjlfWYOZTy/fpl2fTvrRC2drHdx0RD5gjXh1R\n", + "Z1rgF3IFmKvSasz4WA/IB/Ppvi0P9n817TzTty6PP/54Z14dvZ75GI/DWIvUYDD408FgcP9gMPhh\n", + "8d4fDAaDuwaDwfee/vd/F5+dNRgMbhkMBjcOBoNfeEbUVFRUVFRUVFT8FGFsiZjBYPDqiHg8Iv58\n", + "OBwe9fR750TEpuFw+P+o7ZER8f9GxIsjYq+I+HJEHDocDufUrpaIqaioqKioqPipwaJLxAyHw2si\n", + "4tGej/o6/OWIuGo4HE4Ph8PbI2J9RLzkGdBZUVFRUVFRUfFTg/+Mj9Q7B4PBmyLiuxHxe8Ph8LGI\n", + "2DMiri3a3BVPWaY6ePvb3978n0go8kgQQUOK+JNOOikiWp+Rgw8+uLnzdfmJd7/73RHR9TOwz8cV\n", + "V1wx0jf39aS0546UfBgu+7Fq1arYa6+nhvbjH/84Itr74/POOy8i2lIoREzRHt8QchVRCoFU+Pa/\n", + "wO+JO2RKBJxyyinNuI4++uiIaCNk8Lcpy8mU4+T1Jz/5SUS099L0De2OmLzrrrsior2fLkvEODOx\n", + "/QUoEQEP+fzlL395RETceOONEdHKwWWXXTbSnjk57LDDRmh/4oknmrIplDbgrt5t8eWgb5er2Hvv\n", + "vUf4yP08fHnLW94SEa2MErV18803N+Ok/MBb3/rWiGjl4uCDD46IiJtuuikiWj8FaIHnzAVy4yhW\n", + "ZJ32y5cvb6INGSfzD19oi/wTpbh+/fqIaHn78Y9/PCJaPhIJRDQW7fHPKUtnILcHHnhgRLTrAr8Z\n", + "5Nzzz7rAtwUa6RvaQd/8M1ZkEd8HaHLJD9boCSecMELLPvvsExFt1Ba0fOxjHxtpT7/MEWPsK4Xh\n", + "HFOsf3xb2FugHT+cnXfeOSLaPcgliI4//vgRWpDFrVu3Nr5/zCflZ5AteH7nnXdGRLekEPsFa5kS\n", + "ONAOz5kj5hRa1q1b18ggvjCsf0p4IFv2kWGO2LtcUoRxupQO5Woo47Jt27Ymctp5jphPl6ui/T33\n", + "3DPyTNY/tCNPz3ve8yIi4j/+4z9GaCn3dHx6kC14CH8ohQTdLsPiihFeF/hp7b///hHR7kX089GP\n", + "frShG5k65JBDIqL1EWSP4XeR32f2fVcSwZcIWeR3lM+J4kQOB4NBw0Pvuewt0ODSWS5vZL9H3qe8\n", + "DWXinPl/+fLlzfjPPffciGjLDyFTzNF3v/vdkb5Z0xkWe5D6aESc+/T/3x8Rl0TEW5O2vdd4EBoR\n", + "ceihhzbMrKioqKioqKhYStx1112dVCwZFnWQGg6HD/D/wWDwiYj430//eXdE7FM03fvp9zp4+ctf\n", + "3mjqWIE4kdpLH+y7774R8dQJ9tZbb42IvEaYi/iicTriCw0KjcRaVJYJfccdd2y+y6ndtHBiRrNw\n", + "ThZHG9DeGc2zuoJzc3ONVkebLM8Hz4I/8C+LlETT5gSP1dC5OSLy+lWOmAPwEL6h/Tv3TznOiG5B\n", + "5r5oRs/jZz7zmYhorUL0ARxtQqQH3/fY4IPzE61cuTLlId+BD87UC1ybjHZosM7KXcqiI3ucg4px\n", + "8j5y4NxVAD4g/1hPHQULVqxY0bEsOMIRIJvwBRm21QAg98wdcmN+R3TXCtZNLC/Op8M4HBnJ36Yd\n", + "mstcRSXt5ZqGPkdIZvPvyLos6zRwxnCshI8//njnM/Yc12LMqjIgi8yVc7ZldQJ5feSRR9KoOqw5\n", + "rDEiuuCLaXfdP9Y76yLj4/bbb9+0dSFg4Ehp770GMohcsHfRv9fdxo0b070lq2fpSDnaO+IMfnnP\n", + "o59S1tnH+Q5WcX4v4C3g2bzP95krLHZuz/j5u68ObRb5zD7vdc3cMN8827cCwHwoI/K8t/i3hL7X\n", + "rFkThx9+eBxxxBEREXHttdfGfFhUHqnBYLCu+PNXI4KIvn+MiP8xGAymBoPBARFxSER8ezHPqKio\n", + "qKioqKj4746xFqnBYHBVRPxMROwyGAzujIhzIuJnB4PBMfHUtd1tEfH2iIjhcHj9YDD424i4PiJm\n", + "IuJ3hklY4Pbbb9/42/z93/99RET84i/+YkR0tV1Xhb/44oubU+hrX/ta09vbR5aLCY0En5hbbrkl\n", + "ItrTLtoyYDjXXXdd3HDDDRERcdxxx83bN/fQaAHHHHNMRHRzbnAyRyvCCsDJ3XXfVqxY0Tzzc5/7\n", + "XER078ABGgJ9wnvaWevlmV/84hcjIuL73/9+RET8+q//ekS01paIbm4Z193KLHVYoLjbfs1rXhMR\n", + "baZmwH072t+f/MmfjLR/yUvaeAZrbd/5zncior37ftnLXjbyOfLC/P/N3/xNREQce+yxEdH6HQBr\n", + "oiUfsyz73/jGN0ZoedOb3tRLK+OEb9dcc01EtH4bZHgHZZ4hfFvw8frZn/3ZkbZohtCNpe5XfuVX\n", + "IqJrecVCgd/aV77ylYiIeN3rXhcRbUZwsGzZssYn6pvf/GZERLz61a+OiO4aQj7wK8FfCVrwJQPw\n", + "EavK2WefHRFtFvqXvvSlI3REtDxj3qHJlQ2QY7Tdr371qxHxlLtBRFdTt9/Kt7/97ZEx4UsU0c4v\n", + "a+e2226LiIjXv/71I7QC5IfrBF6x2LO2gXPIYXVbuXJlx/KKls/6/9KXvhQRES984QsjomvBZpxo\n", + "8PAPWngFWFEY4y233NKsIdPiWwOsXOzpttTzN2vvBz/4QUS08mB5YZ+8++674+tf//pIG3zDgPN/\n", + "sVYPP/zwiOj+jtiic9VVV0XEqL9iiZ133rlZc+wt7Ln4tQLvLa5w4Xxszj6O7yT7Ysl3+uK36J/+\n", + "6Z8iovWz8zid04u+smzi/A6xp1999dUR0f7WlfLl2yH2Fp7BmgU8C5lDZtlvbE2FdvtgLVu2rFOp\n", + "ALq/9a1vRUTE1772tYhof+f6agX2YexBajgcvrHn7T+dp/0fRsQfLujpFRUVFRUVFRU/xVjSzOZY\n", + "ZH7t134tIlqtGS0fcLLk1Hzcccc1bfFRAWg7nMA5zdLOd9iOiECjd/03UN7XY92w9ua2aBScbjmR\n", + "+3RsvyxnabZlZ2ZmpvkOkUxZ1l++i+b4yle+cmT8aOQAzR3tCd7zar5DTzku+5sAngmPf/u3fzsi\n", + "Wj45Cy9aEJomkXPMMVpQ+Uw+e/Ob3zzyvrPkQys0/vzP/3xEtNqRaYGP9tfZbrvt0szjyPkb3/jG\n", + "kXG7Bhnyw+dEBPG35ausf4gG1VdnqxynaWGeLS/ML5YdonigxZGEc3NzjewRhYkGaR4ybiws0OLo\n", + "XcCcwetf/dVfHfm89DXB+uXakMyXLS+Mm7XGmkYePEfwCz5DM5atco3ybKwhWLnG1U5jnIyF8Vnz\n", + "/v/Ye9eYW8vq7nfM57DOLNfiqLgAAfEA1Wpt1HZr27Rvd/qlu2+/7N2DrSUK2MoqEFSgqIDCi0UM\n", + "Ym0ED0H7ptmJyU7eNk2a7jbdtam6baLiCVQOcmYBLl3KOj6HNfcH+N3zmr/7HmvyPpvmSZPx//Ks\n", + "Nec9r3tc4zrc1xj3GOPvuKWWo806pw3kZv2jp2xdYN3jgcz4M7kfHrkzzjij62cW82quPfrjucsY\n", + "0Y75Dr2Potdt27Z13hnaznTIeOPldJVwwLxnHV199dVTffA+eujQoW6e//Iv/3JE9LMUgZk+zC1o\n", + "T50zU//kT/5kqp12TNEJHnYy25g7jnmi31/96lcjYuKR5PloTw1jzfOBPcBct23b9I/YZ3ToZ4sr\n", + "/LsauWFmEGKlRqNRb49Gp+y1yEL/vC4yFNdeoVAoFAqFwhqxbh6p8XjcnTwz67+9NmJyEj3hhBO6\n", + "U7ctY07E/IbrsAp8inW2DZZpxinX1qTAGuXU6vfjnIQtkxm1AbLSDtYjVrDbH4/HnXxYsc7OA1xn\n", + "Dwwy2PLiOmT/xV/8xYiYeH9aa5o2sBz4Lf93tqE55PB6oEdbasjOX+YL82fI4kU+rkGWjA/PmS4Z\n", + "pxzX8T3zamlpqScH40acDVYOsS+ei+gR/TljKuPL2rt3b6dD2nTarrP6uI6xcHaa1yaWHNcPeVPp\n", + "P1Yr97JV57mG54qxsc7N14U3gLFoGebRkdca/bNHCthSba3YFow7f22Zt/MLHSELe0vmoTFrvfkB\n", + "vf7Rk70qo9GoN8+dbenfeo2Clls0YqIXZ5B6XbRt23vl2EB7KKxzx1w68zDjCV1ZWenF41huc7bS\n", + "T8bAemRvYj4hA7W+LPvS0lJ3D9cotPeKtojj4h4Zlysy48HFm4Lsrd7N2+eMaq9/5oOzwulLNl/4\n", + "nHXGPtLqhX6a3xJ4/zdPbsulGNGPTUYGxpI9/cCBA725gseZNti72FPsNc5QHqlCoVAoFAqFNWIm\n", + "195/yE2La69QKBQKhcJ/IqyZa69QKBQKhUKhMIx1i5G69NJLu/emvJ90bAQ8PvDngYWFhV5sy003\n", + "3RQRE34zxzL4ne6nP/3piJhwJzlTDtl4f3vttddGxISzauPGjd17YGcVXHPNNRER8e53v7snd8Tk\n", + "HTHvqakBBNcW3ztzkPvQ18suu6wXb+B39PBbwVcFXD/FXFuui+J2+f0tt9zSGx9A28gPdxZcS7Tp\n", + "/gH4jcz75ViypaWl7lo44mjLWUb8peaKed8c+0AfqHXl69sq7swxxodracs6dD/h2nKFa8D8gser\n", + "nS/c27GBGXcabTsWEL4y89tlQI/tejYXlsefMeJ7Zxrye4+p65UBPr/ppps6zi/AeHpvMY+X20I2\n", + "dA4fGuuItevYqvn5+Y5TjPF0zKP15DHiOv4S30IfsnXBXrW8vNwbzyuvvHKqf8jkfeC6666b6qf1\n", + "wV8+v+GGG6aub/vq+EvWBfMWeD/kd+Zmc90sxwzRfquXobjSiJyfCAkuAAAgAElEQVT3088iryP2\n", + "f68zZ9xx/dvf/vZ0D+Va+DA9d73fsWYZf/SIXrK4pRtvvLHrJ/ds4+kiJrqE9/OKK66YasPVx4nD\n", + "Yn55/Lm+nS88Q8m6NtMDQDbzvloWP099XvBcH41G3bVw7XnPddwq19PPDOWRKhQKhUKhUFgj1s0j\n", + "NRqNprIr2r8G17UnSz6zF8OeKp/qbZnye3Nu+Xet3BHPnKazCrwg80S4TgjI/s/vs/aH+pVdy735\n", + "nt85mwXY6rMFG9Eft6x//t7/d02v7HqAzO77sX47y4MH6JP1ktW6WVlZSbOq3K/MA+cxsVXsfrb/\n", + "z9aDwb2dZZWtC3sghu7N/+1pyWSxzrN7z/r/0LqwxT1rLtprZsvb84XrmB+Wre1L5oH2uLpt7z3Z\n", + "HM3m0YYNG3rz1tmazmLL9h7P3WxM0Vtr2Wfy+XP3M3sO8Lnr6h1rH/b4uu2hdRzR96YD6zUbm/b+\n", + "1qEzpoHnrvkfvRf7TYjXQzsXn+s6AFm9pQz2Pnr+tPuH90Hg/lp2P8My2S1Ttpbbazz3sqz9DOWR\n", + "KhQKhUKhUFgj1s0jFdF//5694/V1EXnNEWqN2OqzpQGwGh3HkNXLwBrasGFDalFm8Ik68yLxOfVD\n", + "HM/SwlYMcNv2tDl2KDvVZ16GVhaf4p+rRyqzbm2RDFk1bfvHsrwcK5XV7jIyj6T1CNq4PbfheIrM\n", + "yrEX1WOTxQYNeUeze7jNzPLm//6beSbG4/FMj2r2uXXs/9tLdCxPbmYJz9IHsDfQv7M+/LuhfnAP\n", + "x7wZjgHiL97yzGtsS340GqWxHvbmgczzDDIvAuDeXgPHkjdbe57n9oo6zs+6zzxVEbk3I6tJlXmN\n", + "XNvrWN6SdlyG2vS9Mg/trD39WM8Ar7lsXfu39tRkb0e8zo7lJXRNO9ewmuVVP9abmaHPs+8jco9k\n", + "9n2G8kgVCoVCoVAorBHrWtk8swafy/v6Wad7W7HOyvI9qcCK1UcmQfbuuJU9i6fh/5m1YthadL+H\n", + "LC9nsGQeE8fQzKomjFXoMRnqg709s/oJsliBzEOReSRa2T3uQ9ccSwZbXll8hysez83NpfM24yez\n", + "BYk31Ndl3tRWRnuzMkva/8/G39WCQRYz1f7fc2aWxynrr6+3zEOxRh43626Wx8Trwte7+rrXXStL\n", + "NnecKQUcr8j3mSfK86rltvS9vRdlPGUgiwWcNb+Q4fDhw+m+9z8bh+Jq3K6Y7jFqx2JWnKlje/wG\n", + "w/A8mvVWYnFxsecxckao5bbHPnvrkHHvDcVLzvIkzfLMHCsucejez2XdZZX8s0rlhpk0QBY7O+S5\n", + "n8XXNys2DJRHqlAoFAqFQmGNWNcYKVuPWeaRT7VthtCs98ZGdvL2yZRTreMa7LFo5X2u2QaZ58bv\n", + "dF135ljZbFlmmL+3jmd59rJMkFaWWdmLht/PW6YsFiqzJofunVl3s2IgZlnL1ltbv8mW06yMOMMe\n", + "hiweB7Qs6LMy3Wxxz8rCApn3aMgSzzxFWXaOPVb2PFh2z5NjeXrdz1n7QRYrk61p4L3pWGvSazCL\n", + "BXT/ZvHhuSZU2xaw5wxk8UrZ3M08WkPzIvOoZTGV2VhZ9swbZBnH43FvH5ilc3PvGW5nlud3YWHh\n", + "OekqIo8ZBL6X13QW/9Zek8UOHyv7tL139ny1xxMv01AmXlYfK9tzZ8UpeV0cKys6ey5mGdWzPLeg\n", + "PFKFQqFQKBQKa0Rx7RUKhUKhUCjMwDjh2lu3V3vvec97OvcZJQtcgsBl/FvqBF5r0AYl3KGIwW1I\n", + "0DiuRlyMn/nMZyKiT+Owb9++qXvxOeXqkeXIkSO9AnEEspvyw68ZkCVr2+m99JVDb0tv4VRp3JxP\n", + "P/30VNuU8OfeWcop9CPQMtAuAX1+7XjTTTd1bWevpPgNbdNPKHaQya8TLDuy8DvcyYcOHeroR0xV\n", + "YNc18+HGG2+ckgWgP9P0fPCDH4yIiIsvvnhKhqGimIw/VAV+lTOkw4gJFQrj7le79Je5jiybNm3q\n", + "9RO5aRuaBdpGD8wTgM6h2TDVg132yGLaj7bfXMv4m5aBVxTQM3FP0484kcCvvD784Q93/UQflA44\n", + "/vjjI2KSVMLeAi2H6ZgcAAsVDu1zT9oHKysrnU6giEJeqF64F3Po+uuvj4i+Dv26iT6Z3sbrZmFh\n", + "odOVKX/QMXIz/rPWP/rwaxiPf/v6kn6afop5y7Xbt2+fugf9pW3mC3P2pz/96dTvaCejw4qY6Bwd\n", + "QififdGv3ViD7C/o3M8VnmHot30G+FUkOmU90zZ6oc0XvehFU/qj35YdOByFPt94443dXHSAN/v6\n", + "C17wgojoU4S5cC//Z/5/9rOfnbqePjKvuG7Tpk0d/Yyfc1zjwtzei4CTu+inaZwsy+rqajdurCFf\n", + "axlMy5OhXu0VCoVCoVAorBHr5pE6cuRId4rHSsTCsJVnr8i9997bnZCzVElO2Fiie/bsiYi+Be4g\n", + "Ue7FSdTBZrR/+PDh+NGPfhQRk9PrySefPHWtA/J+8pOfdL9t2wKm7+D7zHuwcePG7t7ogdM5njXg\n", + "oNidO3dO9fvxxx+fup7+23KhndNOOy0Mp7hmAXvIams3S2e2F81euCFKCH6DFZdR4ThAk34zf5ib\n", + "gOuYu8yvE044oZsP7qeDjJFpx44dMQRkx+PifoN2/jC3+AxvB6ANLGb6x734634yj2bJ0qaa43lB\n", + "18w1t833eFy5R7b+0d/evXunvm9JTxk/1gVtMxaMF+Bz+o9syOwUdfQHGEPuw7xowXdek5bFxXKZ\n", + "J3x+4oknTl3P3GWOMjbbt2/v7RXezxgrjy+gLfTy1FNPTcnG/AEuB9EGertUCJ8fd9xxERFx+umn\n", + "R0TED3/4w8HrmQ8//vGPIyLiiSeemPr9CSecMCjLoUOHuv7RX68LywS87gG/dymGjN5kw4YN3WfI\n", + "gnze/xnnk046KSIizj333KnP6bf7yTxgDzjllFN6snANOmQ/dxA5cNC13x55jTJfmLM8b9FXq3fk\n", + "5jN+S/+yEkX2FiOLw5NY016TR48e7SWPmVKOvSXzOGcoj1ShUCgUCoXCGrFuHqlt27b1rHtO7D6R\n", + "clrGSjh8+HBnzdl7wUmSUymncizJzPLipE57nJYzL8DJJ5/c3ePBBx+c6gegf5yMuQene1tHfoeO\n", + "VZydjufm5rr+cJpvPWYtkBUdYmHaC2bwO6xF7ofl0crbkkpH9GOCAGOB5wIge0aFwvzAe8b9sEwj\n", + "+vEByIClYb0AxsReJYOxRF9Yfzt27JjSSSsf/cRLMKvAIh4WrH5k9+9avdNvrNIshRodMv4vfOEL\n", + "I2LiDQbIwJxGb8hgb9r27ds7XSPDLILboeKFEX2PhFOT7ckaSlF2XBFjk9GPZEVwM6+B95chfTPP\n", + "HdPlODPQltJo2+R6e0nwKrAvnHnmmRHxzNz32kIGPAWOBWUeAHteHOdny5750q5R5oG9V45fnVUM\n", + "0mn+zD17ESz76upqz+PiZ4tjoRwz5uvtdWV9eA8EmzZt6vTAtfTH+z9t0Pajjz4aEZP9zWOKbN7z\n", + "ua7dF13WgblE/y0L/WdenHXWWRER8dBDD0393rLQN55drIG2fZNO02/mg98y0bbjlnkm+bnI/2m3\n", + "3atanbRte43awzoL5ZEqFAqFQqFQWCPWzSN14MCB7mT5spe9LCImlqxPgZxEOeUuLCykcUb2/rgg\n", + "m0+vjstwuXlbR63lilxYXLYwOY3z154ay4LFYm8KMtoKWFlZ6Vm5WVyK44/4na094P9jUZgKoJUz\n", + "K6TmWLE2i6K9l9+dA8eK8Xcojs3WLZ5Lx1UBZKNN5iDWYOY1RCauf+SRR3oxMC7aZ4+TrSPm3pBV\n", + "297b7S8uLnbxM4438rX+3plS7ifxJ85m9NxdWlrqvqOtLM7Q8WiOU/CaRnb05piatn0XZLUHIbOk\n", + "AR5J9GTPG2OEhws90PfWm8a9acPeMVve9m4hG/e0p87xnci+urqa7mPO7mV9WOcusMhczQoVI0M7\n", + "p7NCovbMsB94TgJ7YvCe8nm2d23evLmLN7I3A9APxwxlVFP2VDkzdYjknrVpz5F16Di9733ve1My\n", + "e74gMzIxlnjo2jg55imyeM/1OrBMPE+RzfPLHlxkGSrgyrXI5FivbP1zb/fFb4J8feu5y4pgs88z\n", + "tzLPa4bySBUKhUKhUCisEevmkRqNRt1JkpM2J02fAk2guWPHjrREP9e6DP2sDBKfQJ31AtqTOPfA\n", + "42RZnOGAZZq9fzXxrD0cQ5lVtO134LZe/LljQjKdc5rHwzVEkTNEKt3+zWJlbA1k1AmA60zf0XrC\n", + "HDdDf7FeMjJSW9qmLwC0x/X83bNnTzqerqeTUZtgiWFpE8eUZT/S14WFhU4uLPCM2oR7OGMyyyAF\n", + "mVcVHDp0qGvD9X3skbTnra01E5HHJbQeuIjJemplNYk33+GJsteUMcq8xJ6LJsx1val2jNrxiZis\n", + "Ibw22Vzkd65t5Rg5e9/suWlhj7y9hda5ZcfDwOcZaW27pjNaJntDkDvTh2s2Od7JY8q+OxqNep6o\n", + "bG5lNcpmUSQx1+3BA4cPH+69UckyiB13BzJZAOuJdWFPb0Q+nvZUA2dtE5fq52smo+P92jHyM9eZ\n", + "00NvXto2/Gz3PkpfHFvcUssB+ofu8cB7Xc9CeaQKhUKhUCgU1oiiiCkUCoVCoVCYgYwipjxShUKh\n", + "UCgUCmvEusVIXX755b3aJM7agZvnD/7gDyJi8o55PB537y75DVxYV155ZUT0a3VwHfeEr+g973nP\n", + "1PXOwuD9PLxf8P6srq722uRdLDw+F154YURM3r8SZ+JK3uYgA67cba6td73rXT0ZzOP1gQ98ICIi\n", + "rrnmmojoxyM4ZgYOugsuuGBKFt6ZIwv3+8QnPhFXXHHF1GeAMeLvhz70oYiI+P3f//2I6Gcdua7I\n", + "X//1X0fEhD8R/To2YmVlpdMJfFWOWXH8DbxcjCvv1dGPY8qQHc4q9Ndm4nHtn/3Zn03p0NXnjdtu\n", + "uy0iJrxPzto03xV9pf35+flejBz9Zw1de+21EdHPmHJF/Ouuuy4iJuvC2Z4ef7j83vKWt3Tz2lX0\n", + "mfd33HHHVD+Bs3aQHe6siy66aOpzz0Xue9ttt3XjQ78c+8U96Cdzi3mSxUjBtfW+970vIvpxHPR1\n", + "fn6+myvmfeTezs6j7auvvjoiJtl37q/nYsbN2WbzwlfmeetYFmSE9w/eR8fnORaGfZcxYh6NRqNe\n", + "VtmnPvWpiIh4//vfHxHRqzpumVijV111VUT0Y0Rdd4h24X3btGlTJ4/nPXKzXzjGCyALeoQ/Ez06\n", + "PomxaLncHJfqfjD+PLsct+j4K66H39DxX9yP/3/0ox/tni1ZtqVl4Tnn2EqvUfgQ0UtbRTxiugaU\n", + "eT9de8txz+xdrIusthv/Z/zhRWUvb9vnnszz3/zN35zSmWOH+ZxnUYbySBUKhUKhUCisEevmkVpc\n", + "XOxVuOb051OyK1hv2bKlO6W7mrSzUVxPxnVEsP6oSWNeN/NbtfWXXCfFtTWQ17Vaspo21KOyZyer\n", + "x7K6utqzEFueqRboi8+591Dl2Yg+w7qzWtr27VFyzRrXKCGzzDWKqMnk6uJ4Im2Bct82w5J+0h8z\n", + "rztrg3HHkqLf/N7cavTNMm7ZsqV3LdyL1h33or/AnFK2NC17y/HIvZ0JA8zLxl97bA0+p3J+5lXb\n", + "vHlzJwNeHfppK5/P7Ymy5wUgK/PFmart9Z6DtjQzri3WKmsQD4W9B8wP9IFXhd+deuqp3bXcC3nN\n", + "Mej6N56DQ7WZWlgP9H1paamX4elaTWaAyNgHWLvm3nOWFxmUbbaWudEAdY7uu+++iJjsJawX2AIA\n", + "a83edOau9dO+AbCH0c8L+uV6YFkWnj2/zih0VuCBAwemsggj+l7A9tqIyZxyPbaWUzKin3HNHKT9\n", + "tq/s4+atdCV3YA5O72FZrachloG2b22//ExydrN/y/g7Kzx7dvn5urq62mub5zt7i88kMAHMQnmk\n", + "CoVCoVAoFNaIdfNItdxetqJtHXPS5tS4cePG7pTqa7FeXAU7s7g5DWMFcALHC2JrCrkPHTrUq2uR\n", + "8XiZzwlLwtYL97KlmTGLHz16tBdX4JgXwL2wBukvlqWzN+HtstXHSb3VJ207JsLeIAB/04tf/OIp\n", + "WbEk4C40HJ/jeiKtLFgjjmVyP201u7qwLVradaXfoezXc845Z6oNe7PM5g6sR3tZABb8ySef3OmQ\n", + "ftoasyfRtZxs1VPZnXa4PqvKvmvXrt4cZI3aO2oOSscnWpese7w9rq/UWt5mhHf1a1v1Xj/AngbA\n", + "+nnsscciYqIf+tTyyrF2XO/JMZKA/7tGFfq07PTbno02frP9LKJfN8u1vIArgmPJZ2M6FGOU1fqj\n", + "PprfAjiWFCAze5a9RV6jbSyavZ4Z+4TfXJivDTj+L/PYgH379vWqnjuW0P00o0X27HrRi140db0r\n", + "hbeeWrcJuCYbTzxW9uh7LrKncz3rzpXC27YyD5R1bk8tyLhZM6aN+fn5nrf753/+5yNi4gXle/bo\n", + "51rVoDxShUKhUCgUCmvEulY2d3wPJ/WM346T+Xg87k68rubLCZK/WAhYio4z4VTMO35O4lzvE2xr\n", + "TdqS9gnY8QSuip2x3BM746q8Q1VZs++sQ2dz2aLIqo+bWw+LvLUOsCis+4zf7uGHH46IPns9Xh4s\n", + "VcueYahasT1n5oEDzqR0Bqb16myUllvKbf/gBz+YugdtY2HZa8QczDJILQvtPProo52HiN+iS8B4\n", + "0QZzC69JxrVljj1kHIo1tGWczXOsVOYJ/XAGKbDeXBG7nS/Wlf9v69XjSL8yjzeeatpDz3hXW087\n", + "89teEXvNQOapQn/2Gtgz1zIJeHz4v70A/N86f/LJJyNisg/ye+aR911X7V9YWOjadn+Yc3i9mLPo\n", + "1jEvtLNr166ImIwJ86zVeduXxcXF3rrPeD89P7IK6KxZV+zOYjC3bt2aeua9r5kflfWUrU08dM4G\n", + "HIrXYt92NnMWI0dcr+eHPZmWxXuX48PaNp2Nnj0vmA9+HmbxWs7Abde25+K9994bEZP5jh5Y13hP\n", + "Z6E8UoVCoVAoFAprxLp5pFqL2TUqMi8QMSUrKyvpO1//hhNmls2Ehe0Yk8yCBaPRqFdrwqd0W21+\n", + "f2yvEdYOJ2pnJvpd8s6dO3vv7J2VAbAwaIO2bZkArHx7dOjzkF7Mr5SBfjqWCr04m8mZlLaOWu+Y\n", + "5cKaMa8f4HOsQcdbuD3iktBnWwPHlhTv2Znrjsfy+NN/e2Y8r0Ab3+YYFc9z+mevV2aBmxfM82uI\n", + "P89eQHPGGYwF3lG3CZABq9druZ1vztqdxd7u2CHzYHouO4uV+eD4lIi+l9Pck1lcFnpxtqbXKB4q\n", + "Z3kePXq053G2Xtx/ew3ZqxxLl3GQOV5rYWGhmw++J54oewPNjQboi/fFbN9tPXt+2+F90evEcUme\n", + "P5nnKYvB3Lp1a8+zzDVeF/S/rZcY0a/5BzKvqz02ERNduf+uKwbMyejnaMaf6bcz/G31yFzJYobd\n", + "tjNvXXcqe0a7j6urq6knjb9+thTXXqFQKBQKhcJ/MIprr1AoFAqFQmEGimuvUCgUCoVC4XnGusVI\n", + "vfe97+3eP/I+nnedxJTAzQTXEu8377///jjttNOm2jP/FJ42smmIvufdN1xIf/iHfxgRk3e41Krh\n", + "eu7J9fAbLS4udrE8bVxAxISvCK4t2ibuyPE1cErBFeSYKHMM0ddLL720y/B7xSteERGTd73oFI6o\n", + "888/PyIm9X+om3H//fdHxCR2Bu4k9Mi7cq5zNuNf/uVfxuWXXz4lH+/LXUfLvExk77361a+OiEmc\n", + "BhkmcC390R/9UURMYgfMobRhw4ZU566uzTtwX2/+PkCcAWP01re+dUoW2jt48GDXBm3DKUV8xnnn\n", + "nTfVb8YfTjn4rdA5c9AxIubD2rx5c69aOrE7cEpyLTom1ge9mIOQ69Ej8V6MMTIxpueff36nu1/6\n", + "pV+KiIgvf/nLU23Ab4ZemEvc2xlzzF3mIvd0BhKf33LLLd14OvaHeY/8cEq6bXOF8TvWnPkT0XOb\n", + "pWTeT/pPJW/2JO7FPIebE5lf+9rXRkTEN77xjYiYzFHaNx8i82Xjxo3dHoPc7FvojHuz7oH50Ji7\n", + "rFGynIhz/NznPhcRkz267St7NLpiLpo7k7WE/LTBuoAnlLnNHkesFf1nLsL9OTc311WmphYZ48Qa\n", + "evvb3x4Rkzn4C7/wCxER8W//9m9Tv4MPFa5F9iD0Q4Vs9u52D3Clccd2Mf7mQ3QNM8aKucsadTyv\n", + "Mwk//OEPd+PDnvPAAw9ERMTpp58eEZM9m+cc45/x2qEvxojraef1r399RER89atf7fp6++23R8SE\n", + "xxE4U9octDwv6Kdjic3Nad4/sG3btu63rCHmInWw+PuVr3wlIiZ7FGOUoTxShUKhUCgUCmvEunmk\n", + "2qqz/OXEnVUwbfnTsNoybh9O9a6D5OwUZ0a5nkxWfXjfvn29a51V4wquWYaQ+8nn6MH6aftoNm76\n", + "ndWR4vqM7RxgFfo6Vzpu23Rl+qwukDNj+P9QzZG2HbyFWKaPPPJIRExn7ZgTzJyBzmYCWJh4O/DY\n", + "2SLD4jIf2I9//OPe+BhZPRm3TTvmz/Pv2griWN6MM5aVr0V3szKIuCfeAmfMeR21Nc3w0uDNybgj\n", + "mUPOvvE6wtpHP4wV+mmvz7jSsmrHtIl3A/1guXr8nXHptd9awVlWkrkIAddxb2faZlxrrmZ/9OjR\n", + "3vjY+8c8B1kNPPQD0wG10TwXaRcZV1ZWemMBXOGb37K/e881e4DZC5yJS9/brGZ7yYEr4PtZ473I\n", + "zwv2oGxNLy8vd3tPy9Ma0a9/Rb9d4Z816D299YZHTMaUtYw3rZWXNlnPrFHr0HUY7RV3Rjr7rKvV\n", + "+3nTtuH54TEAbf3I9nvatiw+V7R7QFZNns/ZUzJuzgzlkSoUCoVCoVBYI9bNIzU/P9+dWr/1rW9F\n", + "RMQb3/jGiOhbpLYa9u7d250Y7Rmw9eJTvy01LBVO5GeccUZETKwGTu4Aa3Lfvn09T5Hfadtb5Arn\n", + "9tTQP36HTMSn2CIZj8e9GiWuvGtwPXEa9NOyY6k89NBDU/ceqlbsU74tAX/P52bapk6YK/y6hg0x\n", + "dMjezhd7Vlw91xYG1zPO6A8ZsvoqWGjwXR04cKDHEWZPEh6ITBbHHxDnxtjioQBDXpCsUjky0Aae\n", + "F8dMAfqXzdUhfjfu+bM/+7MREfG1r31t6l7AtdvuueeeiIh4yUteMnVv4PpBtIf+WlmYl4y79eC5\n", + "SBuMq9eNaxq5ho3jXdr5gtyOX3P9H8A6Zz2cffbZERHx9a9/vdf2kMx4BYY8o/SbOYVMeDHsBbB3\n", + "mBhMYkdcZd1r/Sc/+UlvrwV+m8Cc5f/2liEb4w/PITq3N6UdC1fazvoJXvOa10TExNOEvgDjzV6E\n", + "rOjcnuCtW7f2PMueBwAZrY/s7Qhzl6rczPUhFgeudQ0/16xq5Y7ovzXIvMbmiX3zm98cEZM5DXdn\n", + "xGSvccX+9o1TC+7pdcPnfkbTf+5jvbRw7ULm+V133TXV/1koj1ShUCgUCoXCGrGuXHt4kzjNO4YI\n", + "2BOzbdu27v2vLU5ndPFbTsY+lTrTLOMMAm2cg2MgDFdg9vtXe4Fc4ZcTu/nOwNGjR7s2sHIcEwS4\n", + "J/2zl8CWmd8zO16jtQL8zpt7ZZWq0SH6MMeePS/27BEzY1kjJhZkxlNoDjp79LConM0GGAsyjGj3\n", + "yJEjPe+FsxbxuDEX7Xlzf7HQGBvHArSxZXhxWBfm8fNc5LfWrdtmLbLOjsUogHzf/OY3I2Ji1Q9x\n", + "REZM1g3zgDllD4PjlYj34Xft3HW1c2Rij/Fewv/NuUZ/M0457umq9W37Gb9lVh2atukDmVWuiO++\n", + "MtfxhmzdurU3Ph5nr9mMr47+f+c734mI3ONtfs3t27d3/7YsznLmHo4hsuy0x9hYZsDYbNmypedZ\n", + "tReYNtEtmZV4UOw19PzBI82e5efFwYMHe17/7NmCPvwsYg3aU+MYXM/xdo+2dxvvL3uWPYyAcZ31\n", + "THaG+Xe/+92I6GfBRkyea9aDK9YDc1Qypshm2R2zy++2bt3ak5tr0I8ZPTIOWmPdDlIHDhzovS5C\n", + "MX6QMoFal3AW9GoqEE8Eu3YdsOkg0myyr66u9krX+9WOaRkYFBaUFwaDiQymcRnaYHgFZ1JST8bs\n", + "MJaV2bcrN3MvR/Q3VT8gsu+RnTYzlzcLB30cSy9+DeSNM0seoJ9sRr4nYD6gZ/5u27YtpV8g+NpU\n", + "N54vfkXjYEzLguwbNmzoHQD8SoLxo1+zCJEd+Oo+DR28fLDx2gKmYXHguzc7B8pyPfdrN1IHyZrG\n", + "KXvlaeqTtrRGC8bGD3W/2mj76deALvfg67nOhzuPUUYKPT8/35vnpghB7izA22PH4T+TxQ+viNyo\n", + "Q1fI5CQb70Xoj7nLGs1ekbKvzM3N9aitvIeavoeDog0qy8L1WRgCmJub6yU+eA0C03VZFq8LGyQm\n", + "Im8NDOax5zljZL2YSJj+ZhQ5loH5wuft62bTzpgIPSMtzozBLFwDvbf0QBlxNG0+/vjjU7/JnAFG\n", + "vdorFAqFQqFQWCOKIqZQKBQKhUJhBooiplAoFAqFQuF5xrrFSF1yySW9wEfe6fLO0yXi29L5LlYG\n", + "FQK0CQSB8n6Zd528E4V+4uKLL566jveuxF209BNt+0ePHu3e3fKemXezWQl/QP/oA7QMUK04uNBx\n", + "W8hy4YUXdvEAvJOmrAFpuZTChyKC9+4EbDuwHRqHd7zjHVP6Ih6FuA36fuutt3ZyO96AftIf5Ebn\n", + "gP45TfijH/1oRETs3r07IvqxZW2ROHSI3Lyrd2Ai/bQsyEywNoHhpgiCasEFC+fn57vxN82Oi9oB\n", + "5prpKriOoGqXxTAFTcRkPFzskGuRhbFwkT9kQefQmzgg1HGNUMq84x3v6HSM/I5VQC/o3PGMTrln\n", + "/V900UVTeqN9xqaVnX4ib1YwE8oHr1FTCjEn6aepM9pkA5+ThuwAACAASURBVPqMDqHC8BoDyMT1\n", + "H/zgByMiuuKq3NuxMFBhZPRGBw4c6FHbXH311RExWf+0yRrlL2PE+HMdsjNWplrh+jZInd/SD/YW\n", + "aFbYS4iRefDBB6fuwR7N/s+YcJ33MPTYzi/HwFjnrGf04qQKQD+RBThwmudIS0HleE3HwqEX5ovL\n", + "6iALMt52221T17M/oA/GgL3p1ltv7e1b/EU2dM7c8j7qWEL0Ce0Lz0XWA+22z2GeRaw5l1gg0Duj\n", + "QkIvzO1sj+Z6x8Xt27ev06mfLeiWPdcxYayLDOWRKhQKhUKhUFgj1s0jNTc3150OKcjnTBjgaP1H\n", + "HnmkO5XaysfKIXX4V37lVyJi4jVyOjOnYZ9yMxLb9nrkIhW+LckfMTkRu9SA0/eBiwNyQs8yZTZv\n", + "3tyluJLpiD6c5u9sC2TgHs7aQE9QZ6AfPm8zJTw+jKO9AgALFS/asUortDK7oCnttJY+/3Y/Z5Wz\n", + "ILMI3XsOAvefvr/gBS/olRxwgcFdu3ZN/T/LrLR3Cdmc/g62bt3aI+X1eKIPrFQIcSGhzahw6BP9\n", + "Zc26/U2bNnXjj7z2BgCXBXDWjceovUfEZL4w1kNF8zI9ZAX2GEcK0FKY17LQf6hSIH114cKIvmeW\n", + "Ncm8db+ZF6YnyTIlmV+seTw1GW1WxMTjxnzJ5hRzk/nOXxekNOjTvffe242T1z/jxl+yWiFG95g5\n", + "45I9y55bY25urtM5HljvofSLec54QiyelT9xqY6MImZlZaXniXJmcXttC3swM7oa5iT6RrY2/tm0\n", + "Oln2KnD2N3u1s7kBz13mtulbWtn5LYVVrR+XM+D/jA1zuC1r0AK9Mi/aAs5ZKQ57oP0cmYXySBUK\n", + "hUKhUCisEevmkVpYWOi8RhQ/I77HFganQ4qlHTx4sCs+Z48UlhKeKK6jjYzyhbiE73//+xExKVjm\n", + "0y4n1D179nSne07MFGcDrtmC5ZAV+/J7aCzUs846KyL6RRa3bNnSyf17v/d7ETEpbW/rBp1ixWB5\n", + "06ZrvaAX9EdxRdBavejElicWkU/1WAV8T2FWxsbWLpYHHj/K+FP0rfUaYEF5DrkYHsDjRn+wkvi9\n", + "ZWHs8HC2tAaZhYklhS7xHNgq9Bg5ZtCehtazyXhltXiQ7U1vetOULOjQsjMX0TmWWlY0d3Fxcape\n", + "Syu/de56OS7Q6La5tymFkLGt3WQ9MG9d/BMgG15jxsokrYA+4eGwJ7DdX/iOezBnXJgX2PuFd5z9\n", + "hf0RMF/wKtKH17zmNb29BY8Ba4d+3X333RHRX7v8nj3Idfssu+uXLS0t9doEjC97LBQnLooL+Jy5\n", + "es4550TEZAysNzwzR48e7TxLrFOPP/1g/Jgv7APsD8CeOWRhDKz3lZWVXjwav7XHCbldR4w2rc+2\n", + "+GnExGvkGmrIETHZM5jfzDHPc3sN8QKiRz8vGFM8tfaWtu3jIXLdK9eJMxhLxoaxzGTn2Ujfd+zY\n", + "0dsXHadpYnS/NchQHqlCoVAoFAqFNWLdPFIHDx7srDdO6qeeempE5BQBbTVeVwkGtvI51RPHZE8N\n", + "J2nHDrjqNsD62b9/f/cdVotjHpy1Muu0i0XBXzxYnJZtwRw4cKCzoLEsoHLwO297VrBes8rW9sg4\n", + "86SN+3KGg6scW4euTE1/bWn4eiw2rsOSbb2GzpAy7UT2jtxV6pkPWSwIIL7j6aef7umctunPnXfe\n", + "GRF51XXAnM0qfQPaaS14W/eWhcq9eF5NGAocr+Wq69bjeDzuUVxgebKWLIsplvhdRvlAe44lbPXD\n", + "vLQ3DEvca4j1zN6TUb+4fXui8Kq3XgPGkTmEde5sJWBaFn6HVzCLY6QPeMQ3btzY87zzW/ZBV5H2\n", + "vmlKLfaDLHbQ3pNt27b16FcA/8djwHhnNC7oFn2x5zGWzEnLcvjw4U5+V08HJhCn36zZjGoL/eHB\n", + "Yl4M0dZwbcYeAZyNip6Yk54vptixR7fVI+NCf/EwMb+tF5O5+xmczUVk5TreNrTPOsYbWVjHzDHv\n", + "d7SNzIwpHlrPL67nPjxHt2/f3rvWjBCuhu4xy1AeqUKhUCgUCoU1Yt08UktLS91p78wzz4yIiXWU\n", + "xTER1xGRW/N+/4ynxuSlgHtiYXKCzvjNODVv2bKlV9/JJ2ln/vG9a/i4T1g1/J4+DMUa0ZbjJBxP\n", + "Qf+xhltdtjICTv3EUGWeq/ZaX4PVYk8N32MN+R6OBcBSw/LkevrQtm9Lm3mArt1Px07xeywre0eQ\n", + "2V6FQ4cO9eRm/BxLx1yzLvk/831W5khbb6ytZ9X2x8AjZf6yjIPQJN4ea7C4uNi1hUeAfmRr1Zlu\n", + "GXecs0Ftsbdj5N+SfZdxrbm+nOsIeUzpE3sXnivaaS1vx6vZi+69hTlFv4ghov/um2MM2duw3Fuw\n", + "byET1/CbbI3StueyPVPIyFi88IUv7NWeA+b9cy0rj5HfWKAf5rKzpdt1cfbZZ0fEZAy85zpOz17O\n", + "TC9+k5Hx50X01wo6yojCaYPxNvE6sMff3qK2r8625DcZabE9ecwD4Llr4mzPj1Z2e+38NsBeYPqf\n", + "vS2yzs0P28ae2sPkPcVxqZW1VygUCoVCofAfjOLaKxQKhUKhUJiB4torFAqFQqFQeJ6xbjFSF1xw\n", + "QfduNKsnc8MNN0RExBVXXBER03WWeFfPe+A77rgjIiKuu+667pqIPnce///kJz851Tbf46Hj3TH/\n", + "hw/pd37ndzoZeS/OO3reC19zzTURMeFl4j2rY8CQ8bOf/ezU9X6fjwy8v4WD6Oqrr+4+cywQOuRa\n", + "eNxcT8cZJXBzoRdkdJVm/l5//fUpp6AB/xRtt/FFrWzmN4QnyllsbfYHnE/wj1l3jlej7fPPP39K\n", + "Rq7jPT79hAcNbiZne0RMdAVflfmtnI3HPZAFfiu/t2d9EBMA7xvzhTkQMYkfaMcnIuK9731vREzm\n", + "idcPa8t6BO09IiZ6/MxnPtP1lfHgHo4ng68Kvjpk9NiwRuHagzuL+WK+P/Rzww03dPxjHn/mt3nZ\n", + "aBs4fonYQvYX9OIaaS3PJHLDb2lmAmTweF544YVT96ZN4iDpL7ySb3vb26Y+Z89aWFjo+oHO2UvN\n", + "gUYWH/f6/Oc/PyU784QxdeZhyykXMRnTubm5XtYe/fR+4Xga5j1rzusfvdFH2mevg29xcXGxNz70\n", + "H65F5M5ih5CNffHaa6+d0gt7ufXDOrr88st7Vfb9bOJZBEcg/efeni+MJXs67aB7MlRZF9dee21v\n", + "X3R8IfdgnjNG5rM0WwXr6N3vfndETGJ0vT62bNnSXXvBBRdMyedMSGSEO4+56DqL6Md8eOyLjk0e\n", + "jUbdtZbbenFmMOOfoTxShUKhUCgUCmvEunmk9u/f31l71AfKajf55Do/P9+dHF1DhFMoJ0lOoFkW\n", + "E/fK6kU4a6et8IvFlbWBvGZMz+pCYS2ZS46+OvtjeXm5Z8XTpqsDYyHwvXnRLLstONchafWJXBnf\n", + "lGEONvpnLwLge48F7bT8ibagkYk2s1pf/EUfWWad9dv2xXPM3kJ7dSyLs908NuaJbCuI22J0jTJ7\n", + "LO1xySr+2juKfl2PZWVlpVe7K8tm5Z5Y822dl6Hr7dFztk6rd3tY7Q32HGL/cJ2kLHbUnyPDEK+g\n", + "a24xrngtzMpgbj2vWa9/Z22xX2zcuLE3V6yPWfujM28Zd+aN14U57bZt29bp2llVWZ055M/2EY+l\n", + "63SBlpOTdYwunRGObK6Xx1+Pt+c/MjBmQ3x59M/cklnWnvcqZPH19BOvEtc587SVN6sCbrk9vn5b\n", + "lNVjdK3EoSxfewlZ9222ZQva4C/9y2Qxhu5t2EOXcbNmKI9UoVAoFAqFwhqxbh6pvXv3didurBhb\n", + "wcAn19Fo1OMAAvzWnhROovZ2OU4DC8PvnUFrddtTZgvTp3FXrrU3DevJnGIZ19KOHTu6e9sDk9U/\n", + "Aa5o6+951232bmRrx4h7YRnYAjNsqc6qfcR15qKiffjAIibjh7x4O8ypB9rftm07Vg7QHnMWC/Wn\n", + "P/1pyhRvxnR79wBzmRgH1xXz+CP7oUOHUu4zYG+PLW3LjoeGOck8oKZZVq06oh8TZFCZHhkd12We\n", + "RMY049hrvW+ZRwpkFqatXJDpBQ8MGLK8XR/NHoms+jz9wYOZecfQB/tKqx/PW+I42SfsubenBv0h\n", + "I3+RxWub/aLlEaQ/3hd9T3u/vP+zHrgn1cQdSwTamoGuTeVrPTaZJx4w/q6FxVh5fj366KPdvkXl\n", + "edfFM8zOgMzZs8geLPrUshVkcgPPc+9N9h5mtb6Q1W8Rhp4FjnHyXAP+vo0FjOi/2UF/9rYOyWAP\n", + "o/udPZOM8kgVCoVCoVAorBHr5pE64YQTOp4yLFJnqwBOja3ng2vNEeb4C06anMRt7biiqfm8bA3i\n", + "kVhYWOhO1OYWs9ycmGd5JMwSz++RZej9O3I7K8nVY/GgZPEl7if/x5L1ab4dI1cN52/mHaNfjAmy\n", + "ZV5Aj6m9Dlh87W+x+viOzz238FQxrvzOmZIA/TFGrcfOcUm2yN0ve0u4jrFjXlmv7uuOHTs6Hbuy\n", + "O4BDzJ4F+m3Lm2wuxztlXuNNmzb15gH38rV4LaiCbA9cVtnYHsmhWBN7orynuG2us/fI2UnAXjHf\n", + "px1j9gfktpfI1i77IL/zGNoLSHvI0HqRWVMALyBtMB88D4CrSbsCflbFv43nY41kFblp27FO1gv7\n", + "quNvgPdFxmZpaambx+jSFbnpl/dPZ5wCez/QG3PSsrXzjX9nHkZkQZdmV/DvnM3pMWplRS5no7P2\n", + "7JF0FX6zLHhNc0/v6Y4jbj+zx8hZdoar8mcchl7L3Hs8HqfcvN5LnHU4C+WRKhQKhUKhUFgj1s0j\n", + "tWPHju7UyonbVjHghMqpecuWLallzGnU9YOybBwzRWfvfgHW9NatW3sZD1iEwLw99hJlnhfHc/F5\n", + "lrXTyu3YBsDp3RmG/M6WlPVmHqShscrisvy5M8HMSWYMZWe17Q69+3b/sMAz74jj9Bg75hOg/1jb\n", + "9GHjxo2p1866wir0GBHHgBVsr1imx61bt/Y8jZkXAH14jrlt1xuyN9WYm5vr5pgt71n95Ht0msVI\n", + "cL0ziI5l9bc1ZIZgTka8JK6BBGy5um5b66lhnJljIMsIo21kcYbokBcwYuIFwCNx5MiRnufFcWYg\n", + "iyVzPJd537x3OQ5qZWWlF1cD0O2sLF3grDTzImb7xtLSUm8tZdmJYGhODcHcgvzOnr3Nmzf3ajGx\n", + "p3hvsec5qzvWth0x0YMzDtsxQeeZN2+IO3Oov9matqwZj2z7b/dnlsfO6yZ7g2WZ2ozdbP9yLTt7\n", + "1WehPFKFQqFQKBQKa0Rx7RUKhUKhUCjMQHHtFQqFQqFQKDzPWLcYqcsuu6x7V8p7VWKMeI8JH9Ll\n", + "l18eEZP39k899VS8+MUvnmoP/iG40PyOlvgk3vXDtQMH0eOPPx4REWeeeebU73mPDY8T7W/cuLGL\n", + "O3BW1p//+Z9HxITzibgL4nRcw8WcYuiBWJI9e/ZExCRGBFkuvvjiLn6Gd/NkCN13330RMeHxg8fJ\n", + "NVsAcRbIAu8b9+R613z6+Mc/nnKKOe4GLiS4sx566KGIiDjvvPMiIuKee+6Zuh7eJ/iQiDVAH7zX\n", + "3rFjR9x4440REXHRRRdN6cExMsTh3HbbbRERHTcbY8H1ZCtSq4n5guzIQNbLyspKNxbmcbz//vsj\n", + "IuK1r31tRETcddddETGJnUEW5gvjTkygMw6RhTE97rjjepWluRZeNrgiv/SlL0VExG/8xm9ERMT3\n", + "v//9iJjEYSGL+RBZB86UgVfw8ssvH4wba/tpTjnmlrNfmVusf7j5XAEZvfC7j33sY91czLLL+D/6\n", + "oJ9ZTR5khGPt6quvnpKBNc18efrpp7v1yRpytp7lh68OPsRvfetbERFxxhlnREQ/ToPr0Qv6bWvg\n", + "mccR/k/W3Mte9rKImIyV5zl6ZF6hB+KX2NMYf9YRejh06FAvfsw6p23G2xmk7EXvf//7p2R0HKh5\n", + "QlkXJ554YjdvvSexR7P/O6bM8TWW5Qc/+EFERJxzzjkRMVk/7N2so7e97W1dv+in4xmZL/DbtewZ\n", + "EX0OUnSOHll3jM1ZZ501JdOHPvSh7tnCfGU8mZvmZmQ86b9jA5E929OZB+hjy5YtU8+tFsjNXorc\n", + "cO2xLzpWGH0gS7sXRUz2LK7bt29ft7cyz9G5q8SzpvhbXHuFQqFQKBQK/0FYN4/U/Px8ZzU9+eST\n", + "EdHPhAFYNFy3urqa1hxx1tVLX/rSiOiz3gMsETxcWFoPPvhgRPSrLCPLvn374tFHH42IvnUHsMh9\n", + "z4ybDouSUzCWDP12pszmzZu70/ib3vSmiIi49957I2J2JgweFeoo2WrmXs72Q6a27kiWGcVvZ2VM\n", + "ob/vfve7U/ewLFQ0ps+MDVZE2w+8HK7F5X66yrprVTnLgzFyJd/9+/f3xoe5hXcMKxDL+tRTT526\n", + "nvnC71rOsFZG0GYzUi+H8bTc9ly+8pWvjIiIL3/5yxExsQYB84e5h0zUfvLcXVlZ6axd5hp14py1\n", + "xhrjnowR+qEdkK2XoZpZrq7vLNWsRg3jigXNfmCPFnOZPr785S+PiMkcbGv3OPPVc8trlDbwKmJJ\n", + "I5NrGrkOz7e//e3u93gEAHIxjm94wxsiIuKf//mfB2Xhevp5yimnTP0/q2mGfp566qleljJABte8\n", + "y+J1mQ+MpecgbxNA66nAW2NuQcvNda33IqK/Ru0V4Q3Gv//7v0+1B7Zv397bM+lHlhGGp465yprO\n", + "MnFplz3g9NNPj4jpuci/2Xtcq8oV37nez7+s0jfzwlmg/G3bN6sG+wHw89I18ug313lPN8tHW/Hd\n", + "tf7oD3XWmAevetWrpu41C+WRKhQKhUKhUFgj1s0j1dZ0wELhZOpTIFYAFU1bq9LeC9rCysGy/PrX\n", + "vx4ReX2M0047LSImlqkr3AKs63vvvbc7zZu1ve1jxMRi4HtO+bZIuNfrXve6iIh44IEHpq7zaXpl\n", + "ZaXr56tf/eqIiPjKV74y1X9AG1i9yH7uuedGRN/CtOXG/x2/0/7WcQj833JjveBFw6rHGrTlTTu2\n", + "vBhrLLb2WiwN2srqgmAp8W4faxCr13qhfawcrKIXvOAFPa8f8v7Wb/3WlEyMjee5vaGuPm094nV4\n", + "/PHHZ3pe8Ob96q/+akT0OSVt7fI588R8f0O8X8iAXK4XBByPBhyXAuwV4ndDLPf2Xplr0xY1cwiL\n", + "lL0GT0RW08h9wXPXyspY0AZ/mVuMAcDzhId2KPapBWPAemDunnfeeb15iyfi7LPPjoiJ1f6d73wn\n", + "IiaxPoDv0QMyZ/xwjAXfLywsdHsz8gH0YM87a8nrAp2/5CUvmfqezzMv0/79+1PGBmDPCXx4tO11\n", + "gR7xGrJv0Efi2sDi4mInr+t+mQmDMaMt18nK+PBcC3GID5G9yF5jxtdeY3s7Abp1TBn/5zkEJ6dj\n", + "qiIm+zzPc+Ye+55rkgFzrGYwzyr6OO6443pyu1o6YC/O5ruxrgcpNmkedtngmUB28+bNPeoPwGTC\n", + "Fc0rLBYAbk/AJEVhvBrjwWFFtgXMhlyoQ2BzZ7IyIbxJIwuvDAkYd5AtOHz4cDfgX/ziFyNicvgi\n", + "4BCYToJNKSt22d6jBQukdb+6FL83Qv/frzj+9V//NSImurUs/J9D3K5duyJios+2fdpgbvlwnhVv\n", + "Q/ccAkypAvz6rU04sK5czPQLX/hCREw2a9PPmISV19IO9AftK0Bek7mApq9lw/inf/qniJhspD4g\n", + "cC8MDNP4GCsrK92cAujD488Y8ABgXDlI+OFFX0ziy//bNcp3pmVi3NxP08/w11Q6wNRU6Jt9hgNH\n", + "RL/YLQ8IF6IFftCSpJCRsxqveMUrIuIZ/XmvQAbG5G//9m8jok9mDNiLMVJYD8jufde/27lzZ+91\n", + "D3BRR8YvIwo2OTm/ZyxteKHX1vDIDgC0wZ5iouBsL0KWhx9+uOtvRH+/bPvDgz0rJIluXXjWFCqA\n", + "79nbcRp4jrfXoktk4dmSGdI2SB0w7z46LGHIOEI+G6OmcwOem+zppmcC/J/9gd9v3769dy16Yd2y\n", + "RrN+ZqhXe4VCoVAoFAprxLp5pI4cOdIrT8+J1K+lsGhaksbMq+OTN4GInDht7XKax8LwaylbXm2q\n", + "Jr9FFr+qsIXBX7wYtgLoH1YOejGRags+u/vuuyNiYkn5FM//CQBGBvprK8BWg2kI2lcYyIfOTBCb\n", + "BabyOoQxwtLIgqqxjtGj04Pbf9tCwiK3hcnnTsVnnO0F8qujNmjTbePdwP2PNw/PjS1HPHWmkMFi\n", + "ywJCt23b1htXW1KsKTwLeFCwTO0d82toe3T8um08HnfWHB4GfmOvjqlBaBOd+3pb5B7/1tWfvbpB\n", + "L9k8Rz/o2PMHeD7QV+Zuux852cKvOr230A/mpEtaZEkbXh/z8/O9AFwHnzPXsvF3sgmeTD637Ca3\n", + "3bRpUy9MAphOBJ1lnjcnlXhPcvttyAXfZd4uPmde4BXNyL/twTO5sZ8B7etbxgn5skQpvMt43P2a\n", + "GqAPPFEOym7XAnrgLQpzKqMIcmkiy26dc70paOij9672N97fLIuTbUxun4WhcH37TLfcXMP5wCEw\n", + "mefVKI9UoVAoFAqFwhpRFDGFQqFQKBQKM1AUMYVCoVAoFArPM9YtRmr37t29rATejZoi5vzzz4+I\n", + "yXvoNqWUNihVT/l53oU6IwgPHCXioXxwYUZnP3E9FDGbN2/uZVPxLhZaDmgWaNvxCNwL6gTK1QPi\n", + "HJwm/fGPfzwinimFT1wK7/qdzgt1CiX8iQUhRoL3z1x/3XXXRcSEloXvkdmxBp/4xCe6Ev5+V+2y\n", + "CJTw9xg5dR99QuMAXYFjItpCoOgQygenxruQHrKYfsa0LNwLehP043bbNkw/4fnhmEBoPKBOYdz9\n", + "Ph8gC1QI27dv7+RwDANto3PaRuceM/ToMfVY8n/W6LXXXttdS3yB40uuv/76iJjonO8dE+M1yrpw\n", + "bJTT3//iL/6iW3N8hh4cT4VeWM8u1eH0d+gqaN/rpo2NYS9yPxkjx/Ghww984AMREb1YM/YZ+sJ1\n", + "UMTQHmv76aef7u7JXuE1BNALcxedM8/RlzMwaQfqGehwaGfnzp09yi9kga4ki0ejv4wR+z9xgMiC\n", + "PrknFCToJWISp0hsINcynu973/siYrLeHY9H/z/4wQ9GxDOULxH9zDED2S+77LJuLFh7bemYVhb0\n", + "kmXpIQtjxPonlsop/C0FETrxHuu2mbvsXW6LsWIMkJ3nqJ8XzOXDhw93zyLaRm50yBh57/L6B4y/\n", + "KWJ41jmOc//+/d06RW6uRR/I7Ri5/18UMaPR6LTRaPT/jEaj74xGo2+PRqM/ffbz40ej0T+ORqPv\n", + "j0aj/3s0Gu1ofnPVaDS6ZzQafXc0Gv2vx7x7oVAoFAqFwn9izPJILUfEZePx+M7RaLQtIr46Go3+\n", + "MSLOj4h/HI/HN41Goysi4sqIuHI0Gp0bEf9HRJwbES+OiH8ajUYvG4/HvWIMR48e7Z0Yh2pwRPQz\n", + "BxYXF3tWHfCJ0taOT/mcajlJYw1kVBKtdWFr3pa162I4Hs2y872pJbLaPaurq73skSzbhM+dIZXR\n", + "FdjzkNHADCErzOnvLZsJMo1ZdWZaOdGZrTv/1hlVjJXroADXKWozSDKPnO9Ff114zlmOruXi+dPe\n", + "D3naNdKCuWQvsGsbAWeKzoqlPHDgQE/3rl0GGAN7x7I6SfSFecF9hormegw8/lkGIb/je9aHx8jr\n", + "wjQ+bZZfVnA0W8/uP3uT7wkYI8a2rX2V7a1ZTSe37cwyFzb1OrLsR48e7drI1hyw98+y4P1B1owU\n", + "HTAGzlxsv8s+Nzm3PXjMQe+3Ge3P008/3Sskia6yunDMG/SS7dHMTWdS2vPdwnuL38QYnh8mogYm\n", + "hXd2d3u9KaFmFR6l/6yHWfuiM3PBwsJCukeb4gnZnpc6UuPxeM94PL7z2X/vj4i745kD0v8WEZ97\n", + "9rLPRcR/ffbfvxUR/+d4PF4ej8cPRMS9EfH65yRJoVAoFAqFwn8yPOcYqdFo9JKIeG1EfCUiThmP\n", + "x088+9UTEXHKs/8+NSL+3+Znj8QzB68eNm3a1LMw+b9Px46lWVlZSYlMOd3ybpzaKtSJyqxBW4uc\n", + "rC1LS9dgyyerUeIaHFm9HL9/dpyHPTX79u3rWSucxm2NYQXwfh59YO1llbA5qfMX/bZ6971tWdoC\n", + "RZbMY2MvAO0zNhmJZfudLanMg+kYINebysYfGgfmyc6dO3s0C7zzpy1XIs5qsWANzbK8wZNPPtkj\n", + "trY3hLmH7vme8R+y3iOm11xE3ysAHnnkkZ5nwRaz2+R6t53FbyA78YtDVZNpuyUqbT/3+NvTypi4\n", + "Rhwg7sfxkb5Pe409Z1l8GjEurH/GFBky6iR70TZs2NCT23OK32QxM8xv5jvXM6b2SBCLCqPE8ccf\n", + "n1aepm6cx4K2/XlGODzEbOA+mbjWbVCzzyTN7HPWOX1xTCqye0238bz2RHld0JZrfrnyN2Cvoj4d\n", + "88Wenhauqp/RMmX/zzy7MIK4jh3zotULjA1Uk+c75J7lNfTzxXMRPXteLC8v9/YtqKHQsb28z7WO\n", + "1HM6SD37Wu//iohLxuPx060w4/F4PKOcweB3X/rSlzoFnHLKKR0VRaFQKBQKhcJ64oknnugF8GeY\n", + "eZAajUaL8cwh6r+Px+P/wT1Go9ELx+PxntFo9KKIePLZzx+NiPZEtOvZz3p4/etf31kHS0tLsbS0\n", + "1J0gfdr16Xk0Gg1WNW5/y/dYr1mMlGMAHKdktJlGyMO9MtJigEWRvSN3nJbfCfukvm3btp53a+i9\n", + "eNsfe3uw6oYqVbef26LTYToi+ta9K9dbFmCL3dfbO4ReXH25/cwegkwvrh4+y4KlPZMhLywspFXz\n", + "7VHM4hIYG7wezqiy16jNXGUcs8rTtoI9H7I4JmS3587z5bjjjuvmL3+zrEPgKsjZ+vfnGelxK6fl\n", + "4/OsCjLXO07D97DHk7+szVZ2r2frLvOkcB1ZvpnXqFq7aQAAIABJREFUyJXAW49XFtPmPSSLS2Ke\n", + "eL+gT0Ok1RETj/fhw4dTwle8FOZDHCKhjpisB9acuRYzz07ExOs5xMjQtslvHJ/q+WLvmO89FMdG\n", + "fxwDlcXrOMM8i3u0DOwBjFk7X7zn8l22F3Evrwv+7zGy5+5Yn8OqgD6QzR58y55lDmfnhSzud0g+\n", + "v01ZXFyM7du3x8tf/vKIiLjzzjsH+wdmZe2NIuIzEXHXeDz+aPPV30bEW5/991sj4n80n//OaDTa\n", + "MBqNzoyIcyLi348pQaFQKBQKhcJ/UszySP0vEfGWiPjmaDT6+rOfXRURH4qIz49Go7dFxAMR8b9H\n", + "RIzH47tGo9HnI+KuiFiJiD8ZJ6bR3Nxcd7o1b55PpH6POxqNerEJgJOy45FsibhtfmdrwVZjK4Pj\n", + "ELJsNGdMZTEvGd+V39uD1kLxKdwWg2NHzCXofmZ8Vo6xaJF5pHyt68ccqybPUL8dOzbkHXPbWVya\n", + "M+iwOGdlq/G7Nh7BcnJvz/NZcNzFrBipxcXFnhWaxRk5xiXLNsoyTTM+rDbm0V7MzMJ0tlmWtWvL\n", + "3DWf2rnrGDDXtrJVjz4yXWeeLXv+zEXZymmvnuOrsn4yt+wFA9ZX64X1+NjjMCsLN/MOZ3uYPZaH\n", + "Dx9OvUD23jF+5usDjrVyXSbD+8mQ/CCLmTRPouG1nu2LGzdu7I1/9jbF85nvs0w573HEBbvOXntN\n", + "Fr/qtnkWOf7V/KDAHi70MBRj5DpgeC75PMt2BcieeeqcWdqOsftpjyvwM2oWjnmQGo/H/xa51+q/\n", + "JL/5bxHx357T3QuFQqFQKBT+E6O49gqFQqFQKBRmoLj2CoVCoVAoFJ5nrBvX3iWXXNK9y6SWTVsH\n", + "JSLihhtuiIiICy64ICKmo/z9btOcYq7E6lggeJng/XHmA9knvMflerh5FhcXu3ofxGVQQwNenpbz\n", + "KaIfK0P/4Te76KKLpj7HW+iYIDiFdu/e3enMlZjpD5xCcKfRf3TuzDrLzueu8UE8w8c//vGOC8l1\n", + "j/x+mTGCg8zVZB1LZj40x7vBLbZhw4aOCwsuNFecdmVmdIhe6A9xBo7vgCfKHHR8v7S01I0XOkeH\n", + "ribsOCxkYS469sH8ZnDWcf3q6uoUp1XEZO7ceuutETHhqyL2gXFnXM21xjpyvAKycz1z96qrrurV\n", + "+XJMSMs/1rbNmsvmImOKvpzF0/KEca3jk9w2fIX001mqjoWCP5Hxd02btr4We4XnSlYnBx2+613v\n", + "mvqc69mD2F9uu+22KdkZe/R46NChrp/Mlbe85S1T9+Z7foOMt99+e0T056JjaxhrZPH+smPHjl6G\n", + "L/x9cMoxV70eGCvm4tvf/vYpGV0rjd996lOfiojJuhuqp0W/Wc/o3DW/HK/lfjIWroHk+fXHf/zH\n", + "vUxwzzG4WT1f0ItjDGnb3Hzs6eagu+WWWzouRO+L3MNyIwufm9OVezJG7OnuK/fbv39/jwuR/X/n\n", + "zp0RMZkP5olEdsfGOePe+67rr62srHTyIPd73/veqbZYD8jCOQA+zAzlkSoUCoVCoVBYI9bNI7Vh\n", + "w4YeV06W5eV6KSsrK2mFZVtctOkMIbdNe+Zoy2p3jEajmZxyzi4AWaVe18uxxW1ZWj04QyHLRnEV\n", + "ZJDp3F4x2m37lI3FrPg789Vlesmy+YY8X86ecr+zujDAmZO+3hlmrbWYcSdaP0M6bGU3x1bG0cb1\n", + "Bw8e7K2djHMukyHTuWv9ZFheXu5lgmXZhlh9eHK9D2T11dC5OReHKpvbU5TVE6Nfbjur+J/VqRrS\n", + "o9ex6wh5vri+1Kzq087UbDOPs2wj173KxspZj7Nq5Fnfhw4dSutf0abrjWX7CL/PZLYstNtykbJW\n", + "vCd5vbgmYJZxiNfHb0aGMo5Zz86sdj8zT1tWu82MGq6VOLT+vOc42xJkHv1sjDxnycQbygp0lia/\n", + "YV/I9OJneFYB3X1t974sCxOdz+KgzVAeqUKhUCgUCoU1Yt08UgsLC71TrGtWAJ9g21oWrufh2hKz\n", + "GLcdt8Tpl6rCPvW2XFzm5clYq7m366dkFXltkbhau2Vvv8ssKd5DZ7yGtl5cA8jxa+0Y2fPi/vhz\n", + "68lchLby7EWh8i8ytHPAuqVt19ECWHWMjeeNr3eNpLbmS1Zl3x7XzMoxa7s9UbamuH7btm3dNVld\n", + "FL43h2JmoRmMv2s4gbZPLQNBK6eRVW72fLFH1rFYbZ9bb0R7TVbZ3DGGjruwx9KVnj3GrScIWexB\n", + "c7+A49U87w3P9bZKdeYdRRbXCcIDB9xve+wz73Orv6wKuvdN7kWbsFEA68NeJnsN+f7QoUO9eEP3\n", + "i9/yvb3kmaeOdtGj68q1fUU3eLGyNcc8Zm3aQ5/t//yO+9CXdk1abvOdZswWjh3M+FO9LuzRPNY+\n", + "QxwSz6jsLYDHMHu7knnR5ubmUs+6PXPM2axWWe/3z+mqQqFQKBQKhUIP6+aRgl8vos8pl8XCcNo/\n", + "cuTIzArOfseZeYEcE+VsA3ukWvZ3Wxo+GbuyueNYfEp3TIE9N9n7+rYt+m0d+j09v82qSduit5ek\n", + "fafuuJRZ1WA9FraWsvE3L5wzs9p+2TJqKy63sJVnPr/Mm+Lqwxs2bJjJy+asJI+/vT6z9IqMmzZt\n", + "6s1FzxV7AcyQ7rbtJUA2zwfL0vY345Sz19RjYI+UM6Rc6brVexZXYg8CMKcaay7jLGQdWQ9DsWSO\n", + "/cpiJt1PV1XOLG/HxoDV1dWZcSbZXAWMJ/2zxZ5511rZM+8F/bTX2zEtbX8icg5G93+Im5JxsUcC\n", + "Wbw32wMPnGHIfOD3nssR/Yw3kMX30obvnXlTs9jaId5Hx9Nlnnd7ZvnecWqAmCjPXe95EX3vlfc3\n", + "jxHeM3v2maOeL/b8td5Fz9ssHpXPn2udzfJIFQqFQqFQKKwR6+aRak/XjmfJrm3jMjLL2J4CkLG5\n", + "2+IyB11mBbZxCBlHoGMXzLGUZe3ZwkDGoYwLe9wsA7BlAAM7MIeS43lsNVqOiNkxMUaWjWQrwN4U\n", + "e8faMXVb2fwwGCt7NLN4HXubFhYWerrnGmfTZPFaIKuBlMWatfVyHCtnWeypybzAgHYz7woYj8c9\n", + "3WVzxjFPLUdc+ztgazHLyGvbslcsi9fj/xlfl5FllA2tacd0gUznXIfOZ8V3As+rIdmZa7bqM1mG\n", + "dNt+PjT+rYyLi4vpWstqUtkLAhyf4/i0LL6z9dRmnHKW3+vC/fTatEfKz4s2LsdzxLJwnfcFx/0B\n", + "Z9bRHl7X1gNmT7S9o/aWuVZb9pwEXsPH2lf4zPWgzHcLPP7ePzIO2qHnUZZt6Odn5nnLUB6pQqFQ\n", + "KBQKhTWiuPYKhUKhUCgUZqC49gqFQqFQKBSeZ6xbjNS1117bZcD5Hb95v975zndGxPR7fkf6wylm\n", + "/iln+AB4v+AU8vt3vxs179toNOrFLvEbZKFtx3Y4BgCuNXh/HIfguJeWU8jZMo4XgMfLvH+ON2p5\n", + "mSIirrjiiqnrndUEbr755o7fLAP9ZjzRC6CGjWMB4ObietcuamNy6Kf5p9w/89txPXEFjL+zPs3l\n", + "6Pozq6ur3bjBV3XhhRdO9S+Lw4L3633ve19E9GOqnOVG+y0fmuMEkAUeL+Yt1/l65hjXs+acYeO1\n", + "ylzfvXt3ryab4ybo5+WXXz71OW0zBswXuLZaTsH2esep3XzzzT3uPMd0mA+R8besjvWAa4/2aY99\n", + "ps04zTgFHZ8E4HE7//zzI6Jfq82xUbR/9dVXR0Q/xqhdo+iQ8WeMvC48ntl+4SzIj3zkIxEx2S9a\n", + "Ljb6ST9om7nluCXLAr+Z+TA9pvwOLjdkmZubSzPbWP/wuDoz2GsUnXtdZPsuc/3iiy/u5muWxYoO\n", + "vS4cg0t/mS+eX64nhb5uueWWbjy9b3kNsf7Zuxy35n7ecccdXT9bGcmwb9cd3JnI7XH0+KJz82d6\n", + "LXtfZE1bz22Mmdt2vJX1ApdrhvJIFQqFQqFQKKwR65q1x6nYXiNnPlD5tM2C49/OtnEmiLMNMrj6\n", + "sE+7oD09u017vfh/lp1lSzOrpgvskVldXU3rgWRZNdZPlinhejvH4sPKMqKALQPaxgvCX7iWDGq9\n", + "uErxUKYUWTRtXaMhGTIZrTfrxRxSrdfA44ncZhZ3ZhBwlp69QQbt7t+/v1szruoLqBaNjGRtZhmh\n", + "Tz75ZET06ynZMwEOHTrUy8bxfAW0xbrOMumAM6LMg9nKnvWH32QceV4XrhINnEE3VMPJ/3Y2XVaL\n", + "yWvRHnrDlb3bzFv/5oc//OHUtYxR1namD2dBAjwQtHvkyJG0ev6sDErrxePujG2Pdfvmgv66GjrI\n", + "sludrQp+9KMfTf1/+/btETE8FyOmK8Z7f8gqvntOZnsX64c56EyzVr/InVV69zywd2sW117GrWcG\n", + "iLYN1yoDHhP+b17M7Pos07K9N+BZxG+YH357MAvrdpAajUY90k0Kb2UPmPaVh8sUgOxBwsB6wrAB\n", + "eBJnhwIWxsGDB3sEtkN9HPp/JosnTObab2V3UbLsQED5fbu6M0Jg7ulio0MP98zlmuGEE06IiMlB\n", + "w0UwDeaD03rRT0sRwmHF9BxZMcRsw8yuZ74hS0u544cucrUHnrY/GaWMX79lNA4nnnhiRDwzFmxk\n", + "2abLPEcf6D6bW/SF/tnQ8LrbuXNnJ4N1npEQuzhkJktG5uqHfNu2X9Fm1CZu24d099MPBg4LfjXY\n", + "fpa9ivLc2rVrV0RMHnqzUrA9XzzfWiAX4856zmhWOGgzZ138NHvA0OeTTjqp90oKsIdmpUaGSgi0\n", + "cBmZLKW9fcZkdDVQgVkvWTkZDk6MO9e7wC3YvHlz77VYRj/kOcqazcofoEdCZBgrz/32WlPgZOVS\n", + "0BPjyd7DPPBehB4x2Phr47Bt02vJr52BDTPGINO5X6W3z3Zf+6IXvSgiIh5//PGI6I+rD94Z6tVe\n", + "oVAoFAqFwhqxbh6pxx57rLMWbBVmRMGtlcxpMysk6dN9VpAto23xX9AGyNoNnL3as2XpEznAI+Pi\n", + "eWCI5JQTsz0GWWFO+u9+WxZO/XxuK7CV7ViFAIfAeGLF2LNgPfp1pYN28YRE9OkBMgJsgOXkVxaZ\n", + "xxOZmbvopSXhBqeeeuqUTBl5LbjvvvumZMa7lhWfpf9bt25NXxODk08+eUoG69gy4cF0Ab8sYHb7\n", + "9u09LybwvMWCtiU66/Urc/JYBT/bYOf23lmxX79etEfKv7MX7VgebHvk/Hoso7dywDPwPR566KEp\n", + "mbDcjx492mv7lFNOiYh+Acns1Z499YxZhgcffHCqvW3btqWUH/bIzSooigyZx81j9Nhjj3X/Nhmz\n", + "9eJwAj83fP1JJ50UEX1vyFCgf8Qzr1SH9syIvk7Zx9Chn0nZHt2+To0YnuvHH3/81HdOkLLcpk5x\n", + "HzxG6CUrZN3q0Z7KrMgx8J7l9WRZMhqsIY8UOrQ3dNabKaM8UoVCoVAoFAprxLp5pCL6AeFZiqWD\n", + "0jds2DCT+NeUGVnqsa39jCrDaE+qyJCVqs/oRjKvEeAEnlEKzM3N9d67O23f97JFYroVYD0cy7OT\n", + "ee/8vX9rCzQL8M9ILodoCDLi42xuZQTIWeC/41Ja6yijthmKWWi/B1nqbRZ0OhTf4JgGYFoFe1wy\n", + "guxsPj2XIMyM8sJzzzrPYh7s4RgiorUnwWNyLA9z+33mPbRHKiP3beG9KpMti+vMZAcew6NHj/bG\n", + "03F32X7gNr0usnH3mmxlyCiCHK+T9c/xOu6DMVTCJpvn7o+9hf6ez/ECeY/2XD98+HDvGZN5Xl0m\n", + "wcjGyGM1FNeTrd/M45LNk+y56z5YxlamLJA700u2VzkGCljGthSK70lsnM8JzzVJrZPxOV1VKBQK\n", + "hUKhUOihKGIKhUKhUCgUZqAoYgqFQqFQKBSeZ6xbjNTu3bt7dSR4B0qNns985jMRMSnjz3vLbdu2\n", + "9WprUH7+yiuvjIjJu07HX7gU/jve8Y6I6NdTclbLpz71qYiYpiswbQr9+PSnPx0Rk7L5fk/szDmX\n", + "q+d719kC1157bUQ8U2o/K+JGv00/QD+zehnQMkBX49ga10+6+eabe9QGwDEw0CbQtscGWYg7gMbh\n", + "oosumtKLMy2Wl5e7ftI2cBE3/poiCFn5i0zIAv0EfXUcwsGDB7v5DJ3I+9///im9eH6jW6hzmC+O\n", + "kXBGye233x4REe9+97u7dpz5SuwOtBzvete7ptr0vCHmAyoEaBw8Zz1GtH/llVf24iZckNHUKaY3\n", + "om2ymVhHUD44Xof/E+fw0Y9+NC699NKIyCmCAPPcsrifpqvgesdhtHFwUFUwV7K6YWRpMbcYT+I1\n", + "0HGbGRox2YvYLzz2rfy0DUUI+jAtE/245pprIiLiqquu6vrTts284nfMXfZR0MbK0M/Pfe5zU3LP\n", + "in2BCgU9Ahe05f/MXZ4XmzZt6sUyUWuJuUXb6NA6RxbmC88Xj4nrK7EfXXrppb0YL3TJvKWfplkx\n", + "TJ3jNep6e8j4iU98orf/Z0V+2aPZcx1D6thT5iJ6cRYga3nTpk0dLRN7rte/n73MLeYLOs5iDqFD\n", + "4vohuifGh/XMmmOeoBfmic8LGcojVSgUCoVCobBGrJtHamFhoWclcJJ25gNVdrGiNm/e3LPaAKd8\n", + "U1vY+wE41WJptZWqI3Liw6Wlpe60jSx4SoAzPPg7VJG5vadrOyG76/MsLy9PydP+1v10fQzq57i/\n", + "mSyMDb9r4YwO5M0qVbuGldvOquaahoHftdfThj1KWfVsZ8RRV4p55OrDjDXft9WHs4ww7gHtCm0w\n", + "r4Gz+1w/JaviPx6Pu/GlKrY9MKbO4f+0QZ0Zy04/gakf2uuRHw8Ef13Lx3MR+hLXAHM/naW5d+/e\n", + "qfZauZ1tmHmmXOPNnoas1pu9IczFdk0729DVpLN6ObSFXriX54vnB/vPaDTqtc3YMF9NtjwrO8nz\n", + "JssobImr6a91aLoSk1W7n6YesqcbfQL62GbSZnXlTJjMs4j+0hbge+ac6xgOrVFk4C9tZFl4zhzM\n", + "stP8XOAv6659HqFzU4PRP3vY7UUzu4ifi+gXvbDX0Veq9rdtcA9X/Pezy5mRrsZvWTKC9aGsPeqI\n", + "ITf7P3J778pQHqlCoVAoFAqFNWLdPFJ79+7tTn+cuDn9ZbxPnCZbj5RPr1jWVGbGAuGU7uvNHZXV\n", + "bAJPPPFERETs2bOna5uqrvZIufIsJ2m/w7bscNHxOyr1ulrs8vJyr1ZGpkNO2OYGe/GLXxwRfUsN\n", + "C8aWjPmO2rZmkTgDx1kBuOPskbDViBWBPtvr0RH3QA/I2/LyRUze4TOu6PG0006LiL6FSXvIytzc\n", + "u3dvb27hMWHu0RbzxVWV0a2rCmfWNN6iffv2df2mn/Yw2WNy5plnRsREH/Z2MjeR2WvQY7u8vNyb\n", + "1+jIOkcvzC1kytYR/WQO8/+hueh6SbP47aj4bg/sU089NfU5oI+MNfdhLFsPBh4lE+ayRu1hQKfo\n", + "hXujRzyzgMr53Jt589hjj/XWFvemDfrNuDMmlsX7Jv3z3LXnZnl5OeVlcywMfGfMk4xA1x59vM/2\n", + "pphIOGKyzu1hRmeMK2sOnXuMGFPmCbKhD+8BrbfYHmqv56yW4SzvqN8SsLbbvtqTyr6fVfxnPO3V\n", + "MecqQAY8UVx/1llnRcS0Zwdd+RlF/73+mavmTRzySEf0Pb7tfdxf5DbDATJ4Xmcoj1ShUCgUCoXC\n", + "GrFuHqnjjjuusyQ4aXP682kXKwDrct++fZ03K6uai0WJpWEOLsPs4FmlWmQ87bTTOv6qjGvPXjO8\n", + "Hshka4c+ccLGAn/00UcHZYno82whi3mc8FDQNqd7PA3IBPg/7eMlG6qaa0vL/8+yUGxpoj9bGOaa\n", + "Qq9Y7q1nD/lo27/NOOW4nvG1vgwsWcboyJEjaRVk2nKb/NbXZzFCWbX2bdu2df1gnOxhsneU/toT\n", + "53vSJ1cAHrImnVWJFWpZ+Jy/9jB6Hdkjh+z8vh1TZ9u5MrPnLx4X7uF4TY8/XjM+d5xHu47oF14g\n", + "dJ9l8TH38DQ5jskeDPZFOPfaDClfS/8Zi3vvvTcinvGsR/T3RceKsU/Qrvcue1GXlpZ6sZDAvI9e\n", + "m54vHgvHVnld4KkYjUbdb+ifvaOuls4Y0V/2GED/7fnHo+F18dOf/rT3POMe3s9pkzlo76/noueV\n", + "PXHtM4Dv7DlzrCdgbgGzS9izB+w9Zc9rx9S8hKwdjyvAy+UYSXvNgWMT24ryHgv6w77JPuo41Vko\n", + "j1ShUCgUCoXCGrGuHilne/k9LHAti6Wlpc6CsEfK3itOo5xafSLlpO7TbsYpxIm7zVICtjCxjOzd\n", + "yjiXsA44qXOKH4oFinjGunCGXOZB8ftl7p0xhvs9tms9tcis/wy2atE5Vp2tXSwr+uAxaseUfzuL\n", + "JPOOYYG4FhhjkXk8XXdm06ZNPQ8TVptrzaBzy+KsNVt9Wcbp3NxcJze6sizOYsUTQ/+cnZLFDvJ7\n", + "62VhYaHHrYdlaQuTNedMOrwaGR+a18EQ16D3FPOcec2ic+8PjssDrtnTZqn5emeZZZ5Z4AxD1+5x\n", + "hhj95/o2gzTLCHMcG/1mHQD3C70hi/cB1kvbx1nxpr4u42bM+M/YD+zxar2mmQcNmN9uqCZXC9f2\n", + "sx68ZldWVnoZjRnvK7Iwx/xczPTI9czlIQ+Wa3Zl8abA+mJuZc9Re7S4H3O2nbuWhTbZu7Lnhz1N\n", + "lgmYJ7Ddu7wG/Qxh7qA7e0czlEeqUCgUCoVCYY0orr1CoVAoFAqFGSiuvUKhUCgUCoXnGesWI/We\n", + "97yne5fJ+1O/M4YPZ/fu3RExneXh983w8sDLlVVH5XdwhJlrid8RS8A7cXPWbdiwoYtDcTwWcr/z\n", + "ne+MiH4cEvEo5lqDI4r2yCRw5gmcQpdddln3Xt3Zem4bvbjGht8vwxMGj5PjmBzH9slPfjKuvvrq\n", + "wX4CfoPO0YtjHJAdmeCUgg+J+Dfae+ELX9j1/QMf+MCU3PTfla75C+8Tsjv+wllOjD8cVIDMzaNH\n", + "j3Zzxrxs9JM5yHznXnAKwhPI9+jDtbDg8oNTqq1kzfymn+ZxZG6RVUP/yBiFO+v888+PiMm4M7+Y\n", + "kwBZdu/e3YuraitMR0R8+MMfjogJ7x+yOibQXGusf8cOMUbtXIevDJ0584nfonO4+cyIwN7kucv1\n", + "wHvWli1bOl6uK664YkoGZ52Zx9E8fs468l6HHs3dePTo0W6PQRa40JhbxMa4ojd7i/XoOkTeF7m+\n", + "jY1BN1zLemb9W4eOx+N6dM7Y0TfHlLb7YsQz+m5jGFtZmIvmCXW2svd05iKxUMTMkv1Klt8dd9wR\n", + "Ec/wyrlt1hJteL/wfu9sT+Yi17s6Pe3z+4985CMdFyJtOYMYXbIueF4wPxgj/o9ekMV8mObk3Lp1\n", + "a/dsYfwtL79hznnvciyYs/0Yf7ffxtSyvuknHJSsLWcGm5s1Q3mkCoVCoVAoFNaIdfNIRUT84Ac/\n", + "iIiJlYSl4QwCsrnOOeeciHimlgt1olyRl1M/Frf5i7Iqu5xeH3zwwYiYnFCpuguw5J588slOLk6x\n", + "zlxAFjwJWC/mLQLIhqeF03CW5ddmZeANwrNgviqzuNNfV0YHWZ2YIU4uWx9ZxhTwvc0P58q2zBP0\n", + "8jM/8zNTv3/88cd7bZsbDHj8s5o09mAAxo56QmCo3oirAFMPBavI/aRemGvetBxqLdrMQWcleq6w\n", + "Tl7+8pdHxMQDgSWdZeGcffbZETGxZNErsoLxeNzLmGPcrRvGhHF31pYz61zDBhmcldPek9+YG80e\n", + "WPTCunZFeLMPME9Yy+bHa693NhJWf1ajztlaXsv29LpmFvdu+d0AMrz61a+OiMk8+d73vjfVD8B4\n", + "O7uXfnu+oOd2rFzfCHAvdG7PflYXyGwVzB/XzOPztr4abXuP9noZ4i1swZyjYjf3+v73vz/Y1z17\n", + "9vQ8tMjkPdr7IM8wfue3LPbQ+C1Nm3HGPV/xildExGTeU0/MWb4Z7529wcD8sdybMW7XKN/5GZ1V\n", + "fHcmtvfoLOPQss7Pz/eeRbTNnmQuyqzupFEeqUKhUCgUCoU1Yt08Uk899VSvBoeri4NXvepVETHx\n", + "Ajz55JOdF8IxCpxCfRI2HxHgBM3JHEv7vPPOi4h+JdyWs85VXn3apYKvLQ8sKHtLiLfhFAzHHu3b\n", + "mtqxY0fnxcNrgwzZqd7WoGOfAH3DSuJ3Q3VZzCjuWAd7sdAHbVJd+SUveUlE9Mf/ta99bURM9IlM\n", + "eCWx9Nt+OMbBlZqBLXfXPLK1g2XHvdtaKBl3ItdSu+mlL33pMWXhd6627fFv477sDfS6+LVf+7Up\n", + "Gb74xS9GxMTjap3j/cXCRuff/e53p2QCq6ur3XxGR8wxrz3mFv3hd+jDtXiQDUvWzACt18CeV37r\n", + "ekgAq5h17pgQzwe8oshuvsBWFlvOrBPkNl+d+e3or71fAFnZR9uYNK/nN7/5zREx0e3nP//5qd96\n", + "n3OcntknvHc7xmTDhg3pXKQ/jnXhHh5/Kr2z1+HZRU/uK/OorbZvbwagH7TFXsXYtHtLxESPXP+F\n", + "L3whIvrV/MHy8nI3x3h+ZW8k+D/rHz68rMp+VpcKfbRr9A1veENETLycyM09mdeWhTnrZ13Gk4eH\n", + "Gz2y1w95atknXD/O+6L3cNdN877ouF7+v2PHjt6zyHUDGfes7liG8kgVCoVCoVAorBHr5pE66aST\n", + "uvfMnOYz3iesIuKXnnjiiUG29YjJSRmrhTaxamy9cPLmpPpzP/dzEdGv9As4LZ944omd3FgntnY4\n", + "5eKR4N5Yf/YCYLljSdDHrJr0pk2b4v7774+IiY5g/ranxdYwejPrNaBPwO+MW8v7f/b0Tj8efvjh\n", + "KVnwONnbgSx43bDMhjyY9AMr0DJmFb9t3TgOB2BxIRPzZDwe9/SABUU/me9YdbZ2uXdbPT9iYrF5\n", + "jBiDTZs2pdXAwSOPPBIRE08Uuuavx/uuu+6a+txcdY4FWVhY6MWCOL4G0H8yAC27vUCubM4azLyp\n", + "EZN9wFmmXnOMGZ4lV5H29Xz/wAMPRMRknjgg3WG3AAAgAElEQVQWp5U740H0fOFz+mX9OF6H33vN\n", + "79u3r6cTvNv/8A//MNUWvzUcU+qYqYyzso3n8pwCzGfHRNIfzwfGjjGCWzDzSIDV1dVOJ8xBrwt7\n", + "ElkPWRV6Yov+/u//fureeJk9pieccELn9UVnmScN3bH+WQfsWa6y7bgv+uLYzIiIb3zjGxER8bWv\n", + "fS0iJnrI3gLQtiu/I5O9qa5gjjdtCIw3/bLXy2PkjFq8fqwTe8ec7ZrNj/be5lp0hfNZKI9UoVAo\n", + "FAqFwhqxbh6pubm57nTrGk+Zhcrp8Pjjj08zwpx9gWeCz+3V4eSNRWVr2ifSNtbGlnaWEcbp3Rly\n", + "tnqc1eOTtu/34x//uNMNFoB579xP148ZysJrZff3Q1kbHoNZXHsGsQPO/ACMAdaCreP2fq5JhaWB\n", + "NeP+tLxcrQzA13MdMQVtzR+PpzO8mIvMTXswbQ3RL8c/WZb5+fkeZ5ytXTxSyIL8joWw7PaeOuYE\n", + "bNy4sbvWXotsPNu6cO5PC8c70Z7/tvKZG5I2HPOGrpHduveas9cIL4K56NprHRNlvkuApc4e5HH3\n", + "GNEuXgCuP3jwYG/vIDuPfjL+rpsG0LVrvWU8keZNbDPpshgmez2GxjNi4sHBI+W153XEXj4/P997\n", + "xjgWzHyYriPo9f/tb3976v9ktWYZqlu3bu0+cyaw41iR27Xg+OvrvV/y12MfEXH33XdHxKT/7EVD\n", + "10b0vUbU8ENfQ1nKEZP1kPH/RfTHyx5mt+09iOuy84I9Uvzu8OHDvWu95/jez/VtS3mkCoVCoVAo\n", + "FNaI4torFAqFQqFQmIHi2isUCoVCoVB4nrFuMVJ/+qd/2nvPzvt33rPC4wWnEO8vn3766S4Dinew\n", + "cEpxLe/qiTtydWC41uBxa/l4IibZfry3hg/rqquuiohnMmNom7gT3sUiC23zXpZ3/GSGcE+4s+B9\n", + "Mk8c4HN4oi699NJezJKrPcNXBdcSsvLum4xC+glfERxEhjnpPvaxj3U6b+u3tLIgI1xL5vFy1gnx\n", + "FeZOoj3qrLTcbIwn15ozzTVr0DnXO8uLv8jGXER2xo5YgocffribkzfccENEPDPHW1mIu3AGHLxP\n", + "novAcXrMRa7fv39/JydzEh3deOONETFZF44R4l78hVMK3kdnjiILf2+//faIeIZry3FFrhZMP+Hx\n", + "QxbiNdw2/WQueu5xHevp+uuv7+RmLjomht+wLhhPZKctx1bBKed1wZwkzu/QoUPd3GL8GQsyZF2r\n", + "in7CncfaZE2SIXj66adHxDS/YauXNtaIueZ9y3pwTB17C9x8yOhaccTKmJuTMT18+HAv/gq9ILf3\n", + "C/4iO+ufec4aRteOg/Rc37p1a69qOvc01x7PFtchYww+9KEPRcSE9412PLbM+Zaz0DGvjsdBL3AK\n", + "sl6IS6IPZHF6v2hjhyMmtRBPO+20iIi45pprejpHZ9n6Z54z7oyh6w8yv+CVRGZft3379m580Ln3\n", + "CcezIou5FgF7L5mU6BzOUtdZG4/H3b/h8UTuNr6wlY3ajqy5DOt2kFpeXu4UR/DgnXfeGRF5yjGK\n", + "2bNnTxd4R0cNNtDvfOc7ETFZfE6LdwCgN3UXzWxTTJmwDiYHTFoWBgGfTM4zzjhjsJ/0n4OXU3NB\n", + "GzjnoGkfwvz/N77xjRER8Td/8zcR0Q+qc3A2fbRMLbwouaevNbElcMAvyOh9TLwZMRlPNh/mCcH4\n", + "HJAB/WYuMlaUlXBxQC9OCrfec889aXFY6zajQnE6rykTMjLoAwcOdGuIgzLB5b7WAaoO+DUyMuSh\n", + "deTkiixg2yUnTBViWZgXbNIve9nLImKYIgRdu/TIK1/5yin5gfvvopg+eDpdGhlIyW5DJZzWTb85\n", + "GJlmCH3dd999ETEposgBnb4AZKV9HuabN2/uye216AeeqXFsWAKTFwM/oNv90fscoD/MA4zdjMaL\n", + "/vrgQEkSY2FhodMp44QugQ+1Tvd3MVkHI1sfQ3RY9AtdOp3fsKFIsWjv/8jI97/7u78bEZNnVlt+\n", + "wgHplMPIKH9cYNVUbF6jzCvuSR+4T1uCgP6jK/rJwcjPBRMmM5bsC5bdhT3bMZx1tti1a1dERHzz\n", + "m9+MiP7zP0O92isUCoVCoVBYI9bNI7Vly5bOO8Ap0GS9AKuJE/ndd9/d/ZYTNXApe9zEnER9qucE\n", + "zSn2da97XURMrOghclba+cpXvhIRE+v83HPPnbqWEzdeM79mMmz9YeW4PARYXl7uTuXoI6OlwWKg\n", + "qOlv//ZvR0TEa17zmojoW7tYAZzm6Ruft2OEXMiLzrMyD/YK2NPgYm8mwW1pWQwsKP7imckIVBl3\n", + "vASvf/3rI2IyF50uS7tQFFHQbteuXb1CksjNHHMJAVv16JR7ohfmj+cuety+fXt3D+S3R4q2sd6R\n", + "OytUaWJpPC4mSG2BpWkaFfoBXJDU3hDTbHBPdM/axLuApzeiT2wLJQb3siXNdfTXKeb2ApqQG1mG\n", + "+sI16Jy55+K4wJQ3rDWKZmKJA/TIvMCjv3fv3t5e5FITyII3z/sF/eQefM9+kMnCfY477rie9xf4\n", + "lZ9ly8ol8GrLJRjsfWvpofBEsz6ycjYAvTCPICO2LPyOfpuwG4xGo166vktnAOYFsrI3o8fMa0Sf\n", + "mIO8bfiXf/mXMFx6g7VlHdpbjEfKBazbfrYy8jv+tmPqucLzHxns9WPN8qxnr+aZ5X3Rexa/e+yx\n", + "x3p7DTqkLaixKLDqtwwZyiNVKBQKhUKhsEasm0dqfn6+Ox1S5IwTpC01Tuqcas8888zO+rd3B8uA\n", + "eAusOdqwBcLJGwveNDU+qbcWKfIji9vGUqBNB0naOrKFhrfJhffA/Px8z9vjwnkA3fLOGm8aMtib\n", + "gmWBNYB+7BWKmOgKixKZ+JvFa9E212VF3rgXlgz3QR8t7QvX0l/+0j97HEyUes8990REP1YO0H/a\n", + "Ze4uLy+nRK5Y8XhqHANlMO72qjpwug2I5Z2+44+AKU9ML2G6GnseLatjRzZs2NDdAy8u/bVV56KX\n", + "eI3oXzYPkBWvKmi9TMxFk2xnlrdj6RhXvAUZLQdrmDXN560H014+x51Yp/yfmCLmFnMxK3yL/tiP\n", + "HnjggZ4OPe+Rm/55/B0zxr5BOx5TJ2ksLCx03gjLgh7QtYsIZwVcTd90LE99xDOeHbxY6CYr9sj4\n", + "sVez9rJ+OqaW+WDZV1dXO3ldWNI653MIhfEau9+AdYQX+u/+7u8iIuLXf/3Xp2SMmIwn42fiaOvF\n", + "xPB4xeln5h1DH+wP6L2NY7RnHj3wG7ft5CuSLpCd+Q/oN7LjZVxdXZ2So72WsSHeDLkzmiOjPFKF\n", + "QqFQKBQKa8S6Zu1xMjWNi8Gpkfe0J5100iAlQ9sGf32Szt6/QyxJtlZWbr9NA8dybNPwW5guAWuY\n", + "/mRxKVhUWEUZgWbExErl1D1E4dJ+jpcAq95Zbr4ey8Wn/iFgOfJb+uMxcr+xBo5FQhuR67l9X+/U\n", + "YjwLpmkAWHX2QHEv65H2uR5y7I0bN6bZhlg39qxmsR1chyWKXjxGbao289fxWMDePPplSxX494y/\n", + "U+1bOLPTZN2G1wOwHj3eeFPoa3s94+cM2Ixsl34zVsjO/60Xk3ejj6G4N+Ya/XQKebYXMe54bLDY\n", + "nUHq9cX3O3fu7MX2oUNk4N6Z19D7iNdNllnHfZaWlrp+ep47jpExYxyz2DHLzPUZddKBAwc6by77\n", + "gNcQOnR/iOuzFzjzojumECwvL/eyb1taqRbIQCYw8VnsNd6L0DnzBL0QvzlUbNvxehk5N8Drj2eP\n", + "scjmC2PO2jSdV8Rk3EwNlZEQM5fZk2fR1ADaZ+/yWm77Q0wc+7kzYmehPFKFQqFQKBQKa0RRxBQK\n", + "hUKhUCjMQFHEFAqFQqFQKDzPWLcYqUsuuSR9D8n71ltvvTUiJtQJXDc3N9f9Fo8aVAVQfjgOhffL\n", + "vMumLD90Aq7k/dBDD0XE5B3qX/3VX01dPx6Pu3e1vE/nt9BmuLS9s1LojyliXCeFd8f0hdL5l1xy\n", + "SdcvX0vb0AlAEUA8gmt2IDsl/7keELfhOIabb7650wnI4gUYI/TimjyuJ9P2s72O9/r0ZWFhoUcn\n", + "YE+ra1FxPXPL39O2r4f2g+/barxcy7y13K6zxTt7rs/oitA5Y2BajqNHj3Zz0VloUJswt9qsqrZt\n", + "5gvXmzonq3wP7cPu3bu7+e3YF+JMrHPXA+N67ul+ohdn93H9TTfd1FG+oOtsjjHPadt7kGOJPBf5\n", + "/tRTT42ISezJgQMH4tOf/vTUtcBxOKZOMRWO4zb5/JOf/GRE9Glc2ngmryHvoYwR8Zv8lv0CWdCb\n", + "q4gz1nfccUf8f+2da7BmZ1Xn1z6nz+n0adOJhEBISNIhFy4BCh0GPljWTOkUhVWWjh+8UKUDFBpK\n", + "IyGWaIxUzIUEAxijSCo3MsiMM4yXKS0vpQNWUeqgXE0EEgIJ5kYMwcSG9PX0OTl7PnT/9vu8v/2u\n", + "Pl3HTp8R1r+q6/R5z36fvZ71XPaz1l5r/SMmVDttxi4ycC3z3DRLZGERU8ccvv322yPiEP1Q2w5x\n", + "OMie7eltvxxnhSzsc45nI8YHPUEp4rnoKv7ch3VBX1s4htT7hTMDvZdBh8Vex/Xeu5DtPe95z+hZ\n", + "5JpW7X4eMdnnHANIzBTfs16Qhb4xllu2bBnWHHRlvtaxUzxHkcV7lfck9EhfPSbz8/OD3Fxryifa\n", + "dtY+6yhDeaQKhUKhUCgUNohN80itra2NrL4sg8Iny/3794+qxYKWuDNiYkmRjZNlkJmclYwJV0Jt\n", + "5XcGR5Zd52y8LOPQdUI4DWMFHCmDwDx3mUeGv3O6RyZnp/h7jJE5m44GzjYxASpjaI4kf9+1jfi9\n", + "zcZwdlLGd2ZZ6B+WqetR+Xr/3LNnT1qR3dZuxkGYeaJ8L1+/srIy+o4rD7uOmj1SHv+MODuzkvu+\n", + "H3lSszpZXDerSn77fffTnGveF2bJ7zazmkPrZQC5nayO0Cx+M3uLM48t85jPyZSito1ltx5N6tzC\n", + "njnLlPGE8pN+mgHBaOek94xMJjxv7HPeB51x6fa8j7aef3tF/V10Zv0wtzyHPVeR2VmioP2+97ts\n", + "P3d9LHuR3R4y2evatu854jVk2Gtmz9R6Y8C9nYHbtuHahRnLAvdmfeB9917v6y1L3/cz10bEeG8F\n", + "2fWj647qqkKhUCgUCoXCCJvqkbL1nFkNPi3u379/ONX6NMpp1pVWOdW7IjMeJ+pI+F26udlof3l5\n", + "eVTF1XLakkJW11Vx21xHH7O6U0tLSyNdoVNbTsjKaZ7TfVZNFthSm4VZjOet3LZ23Q9X1/b19kg5\n", + "JqCVPfNuZv3jc9eosgcPMF88RgcOHBjVKWnfzbffzfqZVd+35xO0enTMm+eiq6nj7aCSczaGnru2\n", + "ksHS0tJwD7x41H1z2/ZqueJ35tnNxqTdA5jfjktzTEjWz/Xmrmt70Vdz11mu9h6uJwSYH8gK39ed\n", + "d9459blBO22cZ1ZHLqsG7jFCFj5nvhA76vGf5cHJPC6u2cbeaz6/rO3M2w7amFTz8Xk8kYUxgbct\n", + "W0eeR8w3PJGeX33fj7zd3oMBv3OdPZjeg10h3/HA7Vg4RtifZ/US6S9to2vPH+a/5wt7QHtfrznv\n", + "51lNO3tH8Qbam+x45zYG0223vIwRkzOIvWXroTxShUKhUCgUChvEpnmkWi4mWwuZFdCeHh1nA3ya\n", + "x+LGyrE3CAuLkzMnUk7o5kNqecKwQjJL2R4Jv3c2sorOzsYA+/btG1kfbSZbC/rB3zmZm/cMZBXA\n", + "Z1Ufzyr1Zlx7tvayGCCAF8DxXM6sa2UBGT+ZZXQ2Uza/iLXjPsj29NNPj+YKXi7uwd/5PHuX77iE\n", + "LPaljTHMsnGAM7vchsc7iynKYip27949iktzrIvhWJFsXTh2zJZ6K1ObJdT+xCq1pcm9M2+R55M5\n", + "PmGih4tyliU7q+p5xHi+swcxFnhqsor/fJ+xaj38WfV/V2S3xxEwzz0X6V/m2Wvni6vAA8aI9XD3\n", + "3XdHxGSvzngfszls0PelpaVBLnsS3U/6he75fT3vF8j2rq7rUm+P178z0ZmL9sgAe1FdKbyVyc8g\n", + "Z1R6/Tt21OwK1gPPV65jDHlGts9d2kZuczJaX4wFsrPvey4DZHTm3axYSmchOs7sSKwiLcojVSgU\n", + "CoVCobBBbJpHqu/7kcci4/Fyhknf96OMP5B5f2x5At+bkzrvfLO4lzbGK8tksozrZb6ZS+tIvGZ8\n", + "3+zVtlLaa9u2rA+fvJ1xxOl+VpwC1zgDZj3MshCO9Lm9JLM8WfbQefzXixFwPJLni9thniwvL4/a\n", + "tpXuuXa0YJ5lcSlra2uj7CuPJ7Jgnbm/hq1Ge38syyy+Q8f4GfZkZpmCRsYO38KeFnt3/V1z65mz\n", + "D5i7z7K0fV3PQ225s6w8Z3sCc3G288sehiwGzB4H4HF3/bgs/qudT5kH3rFwfCfjfbPOvc94TNv9\n", + "FT1k3lG+i1cE2dD5rJin9qfnl9dTuxdmHHLA8VzOTssyKz0XZ2XWZfui408tt59d9CHjXnQWPD9b\n", + "2R3HvN7+6H3kSGuu/bs9dV3XjdaQ+w2yjMAM5ZEqFAqFQqFQ2CCKa69QKBQKhUJhHRTXXqFQKBQK\n", + "hcIxxqbFSF1yySUjnjjzY8EpBI9PGzPE+2Ui+s0R54wgZyfRdsbN5ffSXA9n2cGDB4e/OdMHviLa\n", + "dkyEs4/e9773RcSE98f1eAAZJi1PGO98yT5AJr5rvjKyKNAb77CpzcH1yOL6IYD73XrrrXH55ZdH\n", + "xDir0PEn73rXu2a27Tg0Mj5uuummKdndbvu+Gy4kdO4qya4tAkcYPF7MD67nOuIUzEHlLMYTTjhh\n", + "+A5zhWuB46toA34zrueevp4xgw8PPS4tLY3iDOg/cwseP2fd8D2ymhgjdM711Efy/IJX7qd/+qeH\n", + "eDFnSO3atWtKL+bCYryZi8gEdxp6yeIdGbObb7556CfrPIsBYg3BKcj8cPwO33vPe94TEZP5hf64\n", + "N33uum7o59vf/vapNlzpnn2B8YQPjzXqODXuwXxBdsaijT1hbr373e+OiDHvI2vPsWBwkKFzMwI4\n", + "g87rDv1t2bJlGEf6iw6Ztx4j7kU/aZs16v2TOe7nBe0vLi4O37HcHv8sFsj8mchivbFmrZc3velN\n", + "oyxdx76yhmbpsL0H96SfjKnHxrFjN9xww8DLyB7Cuia2lvnOfsH6dwwp16F79mjvi85A37Zt24hr\n", + "j/0iq7bPfGG/sM79jIaD0s+j9nnr8bzooosiYlLDjExZxoxMWmTPUB6pQqFQKBQKhQ1i0zxSBw8e\n", + "HPG+YZEeiVOO72Y1J1xriDY5ibeVhyPGnGzOJLEnps1ys5fLnhW+y+nfJ29nbeAVQnZXcPUpf9++\n", + "fSPvjD1wwLWb8ALYogLIcNppp03J7nohbRtZhdksM4J7YAVkWV6MneuGoO/WM+X+813kNqccOmWs\n", + "sGKc3QbMI4eX8KSTThrp0BmVVIvm8yeeeGLm9fbkeU4C9LBjx47hHugaSwrYinNtIreNV+RrX/ta\n", + "REy8SngLzCuIDiIm89ZrC/A5Y8Jc5HO+D5hHeF5c463NyLJV7gwmy0J/0B99cD0c4Jp2rtnTzl1n\n", + "SLlmjfcW5p5/IpvXNGPgMZmbmxvVs0KHrqljqx2YbcKZVt5H6RP62LZt26ALZ8x5fjvzLcvazGR2\n", + "llfrXbLusorV6MUeLMviMUQvGSvH8vLysHZcsf3UU0+d+p05xDxnPLPMOtf4soe2BePltwbInVXN\n", + "z6rJOxOTdtGP+WHbMXINQ9e2yuoR+meWKem12/IMup/ck+ccle0Zq6OtcF4eqUKhUCgUCoUNYtM8\n", + "Uk8//fRw2lvPA8UJu62V5EqkwFYxnD9Y/3iHgBmn16s+3r6XtTXv75jXytaOLUysIn5yqkdme3ye\n", + "9axnjaq8OhYAICundK7HOsCqBTCy2/OAFdF6Uxzr4FiGrP4RcP0UeyRc48vtttYO38WjQrVk5lBW\n", + "/8h1oWxpWlbXYTpw4MDIaqM/WJi2ej3vGQs+Zy5n17c8b8jLuHiutN6K9rrMU4O+PF/Qh+fLCSec\n", + "MIpx8XfALI7EiMk8t4fBHkjXQGrnU1ajLVujrJ9nP/vZETHRKf3H4wjomytgz6qVxXjTlmsx2TsA\n", + "XFWa/rm+kr1CbZyWdYgstGGvRVYXiH1kvdpdrvHTzg979ZAFryn73CwvZ8R4r3I8kvc69Lq6ujry\n", + "THqe0xbf8duC7C0D4HrHNYKnn3560LV5TR0Dyxz0swvZMo+kY8aQvZXFjB/Im+1zrMVWlxHjZ5Tb\n", + "tzfVnsr2/7Rhz2T2RsJr2zF4IHsWzqpQ4Lci6N5vf9ZDeaQKhUKhUCgUNohN80ht3bp1dBKdVQU1\n", + "YlyFteu6tAoyp1euJcYDy9KnVywOWx7OIACcVFdWVkbxOOtVngVYA7byMqvhSBXDfSq3987wu3xX\n", + "dAZYT86M4X2/rcyIsZXqatuA7zqbESuGewBXmUUmfm9jkxx/gVcnyxDEenGMFG1aj1iJfv/e9/2o\n", + "bfpBm3zH/QV40dCX9ZB5EZjj7TVZ5WnmL9/FIvX1WMfAnhv00PbVXgx+2qtjDjlktscBIJs9MHyv\n", + "1aM9C85Ksg7RB2PD/kE7vt7WMXq1tzRiXHnf8VpZXApwfInHyJ4rsLq6mvI+Ois1YzZgjTFP7HW2\n", + "Z4ffmbP79+9P9y2udaYk88L98T5qfriMxWF1dXXkKcv4DumvM+sMZ1LSPrLQDti5c+fIG8i4eo2x\n", + "TpiTeOyy2CHWg/cuV4pv5WU9oHMzgQA8itzbP+2xwZNjD50rx0eMs1az7E3LYu48YJ1nleEXFhZG\n", + "4//P//zPU/1iDNiLHceaoTxShUKhUCgUChvEpnmk5ubmRrECnAIdC+CYm4WFhdTC8O+cTvFM2MJ0\n", + "7Ig55TJs3bp1OPH6nazbNps3p3bHa3E65gTOSTt7F7y0tDR8RkaYLQ7A+3g+dyyQrWNO4nzPXqFZ\n", + "cW3WfZZ949o0jvOyNY2euXf2fr5tC1nIwsCCcj8dC+F6U87acKZm65HwvLVlyHx3DTSDOeoYQs/J\n", + "Nu4L+Z3J437SFnNzliclYpJR5Hi9jCdu3759w7jZumVdA3TGPHcM0Kw4k1ZGczuytttrncmUZWHx\n", + "Oda996Qs+4372GPZts//PV+zbEbWmr0dGQedvYyt191tG7Piy1pkcxm4T8w/Z/lF5DFSs+ZQ2xaw\n", + "t93jb7AXtnKjQ3s7uZfnh+PyADIzVlyHbNb70tLS4Hmyh7GdtxFjD7U9UZlHEplY0/aSRkz2+2z/\n", + "y3j/HNebPR+9RzuzrpUle044yxVkbyQy2HvWjqn3JnTujErWfZZxbpRHqlAoFAqFQmGDKK69QqFQ\n", + "KBQKhXWQce1t2qu9Sy+9dBQYituRn5TZp+R/GwiIW5Q2oEKg/DzuPIIfCYbDrUyZfUrE8zmvG+yO\n", + "pnQ+lAILCwuDS93uYa6FrgZ3KNfj/uYnpfAp4+8AWBf/Qy8/93M/l7rJcYNef/31ETEp4Y+sLgeA\n", + "bpGdMvvAKau426+66qqB2iB7BcN4ovM3v/nNETEZE9zOgH5bdu7tgMb9+/cP1CZQhLjEhOkIrrnm\n", + "moiY0A/MSl9vsR5dRfsKCB0it93qDpr91V/91am2XfTTOmeuQynSvmaxS/3aa6+d6ifz25QY3Asq\n", + "HOgn/CrQ9CxXXHHF0L5TwJGL8aSfjBHz3MkXzEXGCFomu+r5neuvuuqq0V7BKxhc98z7D37wgxEx\n", + "2Vu89/h1QkZvQx/Q69zc3ED5gtxOADG11HXXXRcRYyokZPErn4zeyq8EI6b3iohxGQTPtXe84x0R\n", + "EXHZZZdNXe+wAvTL/EKPzOlt27aNXosxt5i3flXj127Iznxh3L2OkIX9oqV9YS5a98xF1qhLDQDu\n", + "Yeok9ML3kIF5dvXVV0fEoTFyCQD2Pfpx5ZVXRsRkz/W8dkFn+sl+4dfRfi37rne9a+hnW8S37Qfj\n", + "iyw8R10M1K9TTW/jV+ptwgG0LMwV1hh7S7ufR0zmC88LJ0ggO7+bxs2JFfPz84M8zK1sX2Ss0As6\n", + "z1Cv9gqFQqFQKBQ2iE0tyIk15yAzn6htJfR9nwamucDakYo3RkwsKE7oBAauF+A3Pz8/CkTNing6\n", + "QNmEyoATNNcRfM7J256bNujegcwOKnTRS/pHILCDR91/l0Fog2ptxa8H0zVkFCgGeuE+s7xxLlvh\n", + "ueMATxf7BMjm+WIvYet9s1fLwcDAHgTgoHt+x6uSFTZdWVkZBct6PF2Q0N5UzxfadnLBLFqeiEP6\n", + "9ppbbz64LIQD4Nu223vyO/Oh7avv7aD5tlRExHgssP6zJAzaQQaTY7fB5+jOBRWzhBD3AdibAkxL\n", + "gyxzc3Oj8QcusJmVYPBe5SD+9fa61dXVdJ7Tb6512Q/vcw74PVLCS/v3/fv3j/Yr68XlD+w9ss49\n", + "90xaPevNgMt08F3KPQAn4WSB4f49KwvRFvy0BzUj6QYO6Pfea9mc5JMRbrdtONEn2zccwO61l1HE\n", + "zCo2nD3/1+vfeiiPVKFQKBQKhcIGsWkeqfbU6dN/RrXRkvdysswsb6warN3s/TGgbTxSyGLy19Zr\n", + "ZovTqdAmnXWhQlsY9AlLxfE3s7wGfn8+q0hl2xbWC54ZEwEDk1zaG9BaO5bL3oqM8JJ7u/BcVtLC\n", + "VDktZRBAXq61Nev54lIDjpXIUvFnUaZklhQWt+emvZ0uXcCczIilTccQMdGN5cYS5SffoTxERqDL\n", + "9S5E6XW0srIy8qRlhKjZ/MhKVNhzndGWtPA4YRF7/F3s0mS0WZHZLAar9TIhN/11CQl7ARxbyL0z\n", + "75L1Sx+feOKJ0fibsoPvEK/jvcjlPawXg+va+9j7C6w7+osOM6Jgl5HxegDtvmsvb+YFdJHfjJaH\n", + "dthfkJl15DXdjoO9H96beFZ5f8uKQ7v4ruOdWj36LcB6FCieUy7BkxGo23NpKq32b455y2h87B2z\n", + "7FlZEOACsC3QoT2R6xFoG0f0SHVdd9CkT/0AACAASURBVGbXdR/tuu7urus+33XdJYc/v6rruq90\n", + "XXfn4X/f13zn8q7r7uu67t6u615zVFIUCoVCoVAo/BvEeh6plYj4ub7v7+q67tsi4jNd130kIvqI\n", + "+PW+73+9vbjrupdExI9GxEsi4oyI+Muu6y7o+350rFtYWBgVrHRGEDCJ465du9J4KhcQw2oxdQjA\n", + "QsGyuP/+++nLIQXodNwWMITY18W82j5GTE71Jmu17KYxwSJxITewd+/eUdaNs8kAv1Nok3s5RsDg\n", + "e+sRLrfy2bNoWUxPgHWHdZAVA8TCpfDgrKKIpkKgTVMWGI7Xoh1nbzpDBn0sLy+PvBemyKCftsSA\n", + "KQ3cTlbIbmFhYRRH5CKYWbxF5gXCW8Dn6Ad9zppfLk6YefUyQt2MtDYbM/clYmy9Q1rtuByAd9B0\n", + "G7OKGkZM9ODioczNdu/K4g4z6ih7pJgvnjeGZX3Oc54z8l7Yw+Z1b++OPRCODbIe0W+7r2QxUqZC\n", + "8T0d1+ixs1fI7TOPtmzZMvSbcTbZNvA9s33O1CnMG54Bnqtbt24dFZ41iTlwbCyFRbnOMvK5vWjo\n", + "o6WYQifIxzxm/O2pM3UQHjd7pgHzx5Q5Jhhv5WafIG6R/mZxz1nRZO9dmad6fn4+jdcD6Bi9ZB5Y\n", + "44geqb7vv9r3/V2H/78nIr4Qhw5IERGz8sV/MCI+1Pf9St/3D0bE/RHxqqOSpFAoFAqFQuHfGI46\n", + "Rqrrup0R8R0R8fGI+K6IeEvXdf8lIj4dET/f9/3XI+L0w38HX4nJwWv6xs2pMXsnCma9S3W8ETAh\n", + "Yha35Htx6sWycMl7Y35+fvS+eD2L0V6dLHbIlseRstk4MTvLJvOOuC1nTPie9irNIrnN3idntZks\n", + "C7rGQvWYesxc86O1bK07gLyWERmcKQRsqVt/rVWUyW2L2hkubst0LllWZJuJStt4bw1nz9g76jpB\n", + "wDQ+eLpm1RWyhZwR4jqmw8TRtuqd1ekM1FkWqDN2sgxCZ7l6rNxPxz06O6mV3d5ct5F52kycm8XI\n", + "AGRkHczNzaXE716/9iBksjj2JfOast8uLy+PdONrHX/lDEFjFlXYrOvbNe49N9tbPVZZViJt2ztC\n", + "u7OywrzWsrnljFD3wR4sj6nj2Nq3DNaZPVMZpZDftthrCjymXqtHok7i3nio3M/s+eJaeCCj9Vlc\n", + "XBxd6zVm4vWjjZE6qoPU4dd6fxARb+37fk/XdTdHxDWH//yOiLghIt6UfH3mDvaxj31sEPK0006L\n", + "5z//+UclcKFQKBQKhcIziUcffTT+6Z/+6aiuXZcipuu6hYj404j4877vf2PG33dGxJ/0ff+yrut+\n", + "KSKi7/vrD//tLyLiyr7vP6HvFEVMoVAoFAqFfzPIKGLWy9rrIuKOiLinPUR1Xfe85rIfiojPHf7/\n", + "H0fEj3Vdt9h13TkRcX5EfPJfI3ihUCgUCoXC/69Y79Xed0XEj0fEZ7uuu/PwZ78cEa/ruu4Vcei1\n", + "3QMR8eaIiL7v7+m67vci4p6IWI2In+kTl9cb3/jGUTyHq2nDWQa/UfsO1e9BzT/Ge9esPgS8P+a3\n", + "4p0x7RN3cNttt0XEhD9v+/btQ1ZEm7kVEfE7v/M7ETHm8XI9DD6Haw+uJd6301+yPLjPb/zGoTPt\n", + "JZdcMrxnJ5bHlcvhiHrDG94QEZM6Wa7Mzb3gIIJrCz0QG+NYgJtuumnEhWUORd5Rv/e9742ICUcU\n", + "uiauAlnoC7xf6AV9O4uj67qBO+snfuInpv7mTDDzIZo7K4tfgj8t40NbXFwc6ZC54hgwzwPahiPM\n", + "MUGu+WVutu3bt6d1ojxvgXnr0D1zC52TGYU+0QuyIctb3/rWUaYf+gCsUfPhZTFAN99889T1Hkv6\n", + "yhq45ZZbhn46I5Q5hvz0E64tV4l2zJy51gB7Vcu3yfibI9I1uej37bffHhETfkNnnNI2GaToxfsF\n", + "7Z5wwgkjTjG439AH65n+ck/2Reai9xPznXmut7ElrvNG2+ZORBbmFHqin+aUs+z0/wMf+EBETPPE\n", + "IYOrhbNfwLXKeLvSN7KwRzNfzCSBDHy/5XJlHOkf2efMHfN4Iqtr4XkfhYOObDfu7Xp7733ve0c8\n", + "roC2GWf6yXPUGaTOYmNMf/Inf3Kqj+izHSN04rbJfHQ8HnuXeQJZB+yLtAM3H2sUfbSZhrTN3OJa\n", + "dOhnL/1h78pwxINU3/f/N2Z7rf78CN95Z0S884h3LRQKhUKhUPgmwKZVNt+7d+9wCiSTKKu66iyE\n", + "1dXVwTp1tkHGf8fJ2JkSzi7gJJpF67cVX10VNeNx4ie8X7Y4M7iuivs6Nzc3ygTJqj7zOfoxX1XG\n", + "teYMI8amzU6xxZRlRgBnafATC8NWj3mtkOn000+faq/9G3PqzDPPjIhJPSHXhXJdIPd/vczDNqMk\n", + "q/PkOZfx1T3++OMRMZkfzJcs47D1hLoCvbMN7QVD1ixri7WGvrgXOjfaNetsLK8LxuLss8+OiMkY\n", + "0X/XNPMcdQ2kdoxc4d8ZXfZ6uRI+88ZeIMPVo2dl1qJrvMDI/dhjj0XEeK9Ch+gLmbLsP9cya7M9\n", + "vVfQJllYzlbO6k4B1l6WQUZ9OuoN7dixY5ABj4Nl8d5Ff61Le2T90y89CBBeWloa5iv3chaaueTc\n", + "pmXxc4f2Mv7Ehx56aPjswgsvjIiJt4Z6WsB117hHxvvp/RY9Z3ta+ze+C4uG939noSJTVkeM6/0m\n", + "Z1bmprMLW29uxHjvymqgoT/XBrPXvK3bZh2iO9a559Z6NeyGex7VVYVCoVAoFAqFETbNIzU/Px/P\n", + "fe5zI+JQ+YOIiC996UsRMea3o/LpAw88EBGHLJpXvvKVETHN+RYxOUm67gn3cB0RTrNYPZzQsZpt\n", + "qXF6Pv3004eTLtXQsagst2tTveAFL4iIsaXGCRurB8ttVl2QiEMeC6rgYs3T3zPOmC7fhVVMf7kX\n", + "FoYtTPSA5epKuK3es9pMs2rrRExqHTEW6JrfbZFgYX7xi1+MiIkn48UvfvHo/siFl2Pnzp0RMRkL\n", + "65x7oR/G9OGHH57qt4GsjO0pp5wyiuFxHBL9xBPrGmdY9cjM+kCPfB8g88LCwuDl4BrrEL3Qn698\n", + "5StTstjyxgPB3GbesI7MXH/aaacNujW3YGZJU/IES53v0xfAvfF2sD98+ctfDsMxPbZy7b1gHbCO\n", + "6B+yuZ+AsbNnqp2L7Cl4FpHlwQcfnLo3YL543TPXHFNqfkjm39zc3KiyPfdmjhFvSD8dE0b/HH/F\n", + "fmAvAOuAvp533nnDdz1O7KHolj0lqzuFHhhDxor2LUvLE+r9354UdIcHhbmXcbkyB3lW0TdYLrzv\n", + "Pv7444Nu2ffPPffciIj45Cen87DQLbLSr4ceeigixnOXdpkXyMLabucL1953330RcSi1P2Kyh6IH\n", + "y+LaVo5jAnzOWLFGPZfbtlwNP6uTxt7E9fZQZt5U72mLi4sjzxvznPmbMResh/JIFQqFQqFQKGwQ\n", + "m+aR2rp162BZZDxPgBM6VvJjjz02eBh8ksby5vRuziRbO1ggGceWPRJYT7t27RpO7VzrmCfk5rTO\n", + "qRevgU/1GQcXJ2/H6xw4cGDor9/tOubF79vdX9/TFaxtkbTIKhdnnEd47rIq3PYaEufAfGHM8Bq1\n", + "niD6iUVkndp6xRrC64WVbM4ly+6snq7rRjqkbawaewk8X/BAOYYss47avpobyuPkKvJYd7OY4iMm\n", + "esLDQL8feeSRmdfv2bNn5NVwrALgOtYwus8qPjMWeFOIZ5hVZR89uP98blnwXGaV/42sGrfjPlq5\n", + "mYvIOSu2q/3csSCu0g4YS8YGS71lXQB8l++wB+G9cTwNexX7i/fozLNDe60nxmOBN4x7cg/HKQHH\n", + "ovJ7Fr9y1llnRcQhvTBnnI0H2FPs7ci4FpGRdcGaRR9e4+ecc84wD/BiOdYPoHP2Na5jf7M3nb2H\n", + "PjJv6AM/IyY6Zi9FJn5msaMgi38FzF1XK/czsm0LXZkz1ePK/PdzYdb6b9t1RmXf9yMPI2D8+Q76\n", + "csxbhvJIFQqFQqFQKGwQm+aR2r59+3D64wSZZUpw2sUKiBjHDwDacC0b7pFxp5mxHmTZDHv27Bks\n", + "Ar+zdduuG2KrxW1zIvcp36fpr3/96yNvRWZRO17FtYr8nhk9YYFgFWE1tJad+ZeyjA5gfjMs14zv\n", + "C1nOP//8iJiMlbM7W3kZR2LHsCyIcchkw7pDNus84/3r+37kYeJ3vFxYOZklTZwF495yp0XkHGQL\n", + "CwspozwgHof5gjcwq+HEvLA3mHlgT93Kysogr7kBvaaYQ8wD4jXQC1Y+4J7mOUO2dj05K9HeHVvU\n", + "/J170gesf4+3YwozvrO233gauDazdn0vxxpm3GzcBw/fwsLCKJ7GNamcMZ1xy6E3zyvrkTWKHtq3\n", + "Bh5/exjttbDXCNnpE/MHfXkfIHbw5JNPHu7VZvK1cNa21737SZ+QFe+Xs2bBjh07hucD8xSvruVm\n", + "TPwWwPyxAJ3zd9a0M+fa/iM38VrrvQXxs8rZe8DPIdc1nAU/kzKWFdYibbP3MHezfdEe3a1bt6Z7\n", + "L3I6NuxoufbKI1UoFAqFQqGwQazLtfeM3LS49gqFQqFQKPwbwoa49gqFQqFQKBQKOTYtRurSSy8d\n", + "ZXWQ3dJyZ0VMOKjaeARXjTZ3HlkHXOdsPri24CtyfBbvSnmnDtcO3Ezbtm0b3qNyL2SBIwguLD73\n", + "u3/eYcNBZN4v3iE7RgaupYsvvnj0bt8VyeFxgn/KsVGu3XLTTTdFRAz8ecT30Fcy5nh/f+ONN8bP\n", + "/uzPRkSMMsccEwS/FRx6WeYgMnE93FyOwWprhdHPt7/97VPyEl9DPAZjxfi/8Y1vjIhJnBbxbFxH\n", + "RhR6Yb547LuuGz5jPK+66qqIGPMTOvYB2c21Z45Gvkf7jOlJJ5001K8hJsy8f7RtLkFnq9E23Fzm\n", + "YiT+BFkYy6uuumpUmZ64LDKCzLXnGlZe/7feemtETNY/cRfEShJ7xH1uuummEeebY5n4CacY+4Wz\n", + "MV19nvF//etfP3XdrDo5rM93vvOdU20Rb+K4E8YIvjJnMaEfPm953Nq/g5WVlUEuZIHfzCwJjoFE\n", + "Fta/9wvmJGudMUWPbYwYbfMd9mjmreMz21iW9nrWHO0xZ7kO3TOm7Bftd9qq720/kZt7E2fkmFn0\n", + "yJ7kyv8ZB+Hll18+yuj0/oXc9BN4v2P+Iwt7F/F97NXsdchyww03DPegP6wZc9BaFlfbRwb6C0+o\n", + "x9R7Xdd1w7z9qZ/6qan+MY7mWrUsGVsHeqV95q4r/j/99NODXHCtXnPNNRExeVYx/sSUsVbh2sxQ\n", + "HqlCoVAoFAqFDWJTK5tzqnWlWleIxkJts1wyNmrXUcLDYP4qYNZuvsep2F4krOG1tbXhxGuOJLdt\n", + "Ky6ryeQsJ9rD4rAlu7S0NPSXfnKSdlaFMzqwWoCzGamvw/c+//nPR8Qkg6LN8sl4zYAzH7D2GBMq\n", + "eVO5njozwBWM0R/WYFtlnTbxMFFFmv7iBQFY/bRB2/TTc9HZjIzZSSedlNaRog3GxPMd0B/mnD16\n", + "tsjwDj3vec8b5kFWm82eBVeodtYeY8TfaZ/6Q7P0QpvMDXTo7CR7rsiEQn/O9EEPeN1Yw85EavuB\n", + "DOarzPjquM5eYMvC+mGusz7MpNC2Qb+oDwScQebMIWc1eYz8eas/jz9zy8wEyJhlVnru4TV0hqpr\n", + "Y+3Zs2foj/tpb5+51LIq+6wfsluzOkJtbTfmSlYnjP2ANpCZuesYYvYm9MfzgEy8WRnKzqpEHxlH\n", + "HLpEJvZ/y8K+iSeKtwXmPYwYZ62jDz73c5Rx9PPPbzIAMvjZRl/a55G9uWZdWI9T0vMq40N1Dckt\n", + "W7aMnrk855iT7G9Uhz9alEeqUCgUCoVCYYPYNI/UqaeeOlhJ9957b0REvOhFL4qIvGYJXoalpaXh\n", + "Ha9Pr1jknLA5cbqCudu2JwprwWzhnMj37NkTd999d0RMTv62dvguljSneKwa83hxPbK8/OUvj4hx\n", + "DBZ46qmnBvmxTlxZFnBqp2YPMriys/sJN9M//MM/RMSkMu6s+iCuHWLeQ4D15qrQ8LpltUf4HFmJ\n", + "B2q9I4wvnqi77rorIiY1h+wdYWzo7yc+8YmImFhJrtbtmAvqyOzevXvkkULX9NM1yzx38W7QP+Ys\n", + "3kbLQr+ffPLJ+Pu///up/p933nlT1zKHkIWaXFivni9YqqwDdM+atUfi0UcfHf7mNeXxtBcHK5DP\n", + "bR3Tf+bspz71qYiY6K/lN3PcneMNXf+KNQfnGGMEr6PXKO0iK94RvE3tOmLNMU+Zk3CtGY5vBMjk\n", + "uWtPTltvKav2zFi89KUvnZLJ3m48OfaOI0NW0wi93HfffWlFdtpARjyrHjuAPvAaoD+45dw+7Zx4\n", + "4onDnERey826YB0gG/PecxGvErp+4QtfGBF5rac9e/aMKtDbWwq4p72otGmvoeM/P/OZz0TEuA5b\n", + "xGScmc/IhOfNnLX2vDKX7WkCrtfYjkHE9LPR8ZlcQ//81sgxop7bHn9zN7asFn6GfuELX4iIyV5t\n", + "PtS2OvyRUB6pQqFQKBQKhQ1i0zxSBw8eHLxKnH6dnQJcnfgb3/jG8JnfM3Pi9ntlx04ALEruzXtX\n", + "rF9bDZx22xgj3pNncjt+AM+C28bCsKeGuIRZHgyz1wPHSPBdZMCzxD19qr/zzjsjYmJpY8licbYW\n", + "huMpuAf9thfQcVrI7ng24Gq6tIvsracGCxRPA23itfAY0aZ5rOin9UJfGRv0vGvXrlHcEG0yRlhe\n", + "WOCGPU7OkMl4Ir/61a8O93rZy14WEWPvKDp1NegsLonfXREbC919XV5eHtYMOms9RS3wAqAX7oHX\n", + "0F4APDoPPfRQREwsVrxurTXtTGDaYj44zoh70t+MBw9gqeKFdnZw+z3uyfpln2DPsnVsyxwdey37\n", + "evMrLi8vj+YtcvPTmXKeLx4jV4D3GCFrW70947ez15/fzZEG8Ao4c9BrELTrxPPUexFjRH9pk/HN\n", + "+ELxYLCf2DvY3p9rkCVjqqB/zGH2ReaJ28Y7Rmwpc5D9pdU797LHiH3OsrDPMYbMLXt6ATIyd9HH\n", + "LK469ECb7F3ZePJMZ/0gmxkgAH1ztuOWLVtG44nu2EuZa8zzrBK6UR6pQqFQKBQKhQ1i0zxSrVfp\n", + "+c9/fkSMedIAp8L2fTendr9P5xTOKZe2sHp9IrUl4TorPlFjuSwuLg7xMZx8M56+jEPOstsqpL+c\n", + "wN3O2tracI+2nlHbH9+L/mCBcHp323gXOKFj5aCvWTx3fieNXiwLlrSz/fjcemH8HedjazNinIWC\n", + "RyrzdjIv+Iklko2dOR7tVZ0lNxYV8rquEMDT4gwi4PmFbIuLi4P3h+/Y88Ln5vFCFvoBsOKYg20m\n", + "1Kz2FxYWhn62MQkRYy+AsxMvuOCCiMh17ixOxog9oI3XymK91uO3pP/IlMVG2IpumeUjpmNHnJ3q\n", + "Nee9yJmUXOfYM4CezA+4bdu2kQ5bjtCIyTx2DTfLgsfC7XhM0cOsvc7XmluNuYTuMln4HC8C8D3b\n", + "GCNnPmbcaejDHGuWnXXBGs30APbv3z+MD/dg3tpT52eVYw399oV2aa/1vERMr1HWOZ9lWbqWxXu4\n", + "+TTdPjLyzHK9vfbe1kvGKZnVpuI67+n2Drexeta53w4x35G/lftIKIqYQqFQKBQKhXVQFDGFQqFQ\n", + "KBQKxxib9mrv6quvHlxwTgtt6UciJtQpbcl8Bzv+2q/9WkRM6CRwG7oAHS48KEKgE7CL20FzlJ+H\n", + "DuXEE08cXKm4GOkHbf/iL/5iREzcg7x2wJ1IP7keehPTEwCXt//5n//5QV6CJnGl4mo1FQpAH1yH\n", + "7imF/8M//MNT9yT40q8Cb7311pEO7fbmJ3JfccUVU587NZtxRhZK/rt4YvsaCzoBxh8dM/7cg/6a\n", + "ZoVXgNkr0euuuy4iIt7whjdMyc7rrC1btgz9Nl2NaSSYN8jGGF122WVT/WvT2SMmcxFaDsZodXV1\n", + "eLWHax1ZWBdQYWSvQein6YpMy4HOGQv6esUVVwzBscjN6zG+Sz+RBfgVGHqi7Te96U1TfWJs/bri\n", + "xhtvHNFDuDgorwluvvnmiJisf/YL1ijrg7nI/ILeBriI5NatW4d5y3giL207SBa9vO51r4uIcdAw\n", + "+jN1FhRUyNomY3j82bdayo6IyZziu+gFSiEC5WmP+U5/oc6BOoU+Pfnkk6PXaVCbIItpR9jDTG/F\n", + "fGnXWsRkTFnbyI5e9u/fP6w9lzNAL6x/EhpYawQ2cy/ahjoJ+LUSY8te95a3vGX0+hdZPM9Zcy76\n", + "y/cZM88X9EjihAOkr7322tGaQw9OPvFz1OUPnJyA7NC+uNAzMm3ZsmXYW5CF9esi2ugFiiDmi0Nf\n", + "GHf09IEPfCAiJs8LQN8OHDgwXPv+978/IibrmfAB+ofcHqMM5ZEqFAqFQqFQ2CA2tfwBFiunQFIQ\n", + "HcjGqZgT61NPPTUEhTko1IGXWDmcLB2gbHJi/o6F4qA8ZHv2s5893Bu5HRTLSbu10iImFoOpE+gn\n", + "Vo1L5rto2tra2qATLAHkd5Coi9ohe0adgWx8TnvcL0sLbvtnjxpw4KKDaR24zT3xXBAYfPbZZ0fE\n", + "9Jh6HBk/xsYlBugHHim+R3HQrFApsreUCNl4MhcZV5IUbGHRT9ph/pDm7OKQ9OXgwYMj74WDRx1s\n", + "TOE5ZHEgq1PqTYHiQPiDBw8O4+0iiL7Wn+PJwsL0GrWnCmtxVgB5Rq9C/5wkYavfpUa8vzim1POh\n", + "DWblb6xb99Nzy9Y//XTwMXBBQ2R+6KGHRp7HlrolYrIvkujjuci9HGxrImJAu/x99+7dI/JlwHgy\n", + "Jsxj5o33DZdq8F6U7TOrq6ujgrNeQ+iFv5sSJ0tOsn7sTW+v5zPGPyvdQ5v8Hb2Z5gZwT6fszyrg\n", + "7H3PSTkuOWCqJM/NrAiqr8vKQrTX0E+XZHE/XciTe7qAp98utfuN178L9SK/x2I9lEeqUCgUCoVC\n", + "YYPYNI/Uvn37RkSrWMkuWMjpsI1J8rt+X5udan3ydhEwvCFYLngD3P7y8vIoJigrc0Cb9rTYUrOH\n", + "xqS8s07TtsYyD5OL4NE/TuJuB6sPS8akyBlBccQ4vdtevSyGCivZxMIA2W39tpady1jQJl6hrOQE\n", + "euD76N6wpdrGVtlbYWoYk/jaSuT7eNywGh3vB9p0amLYuNZWGl4ee/+4zp4XW8Ws1YzMdHl5OSVX\n", + "trfDFBhY0PQv82CYYBrvUdtX5ESXljfLUs6Icu3ZNWlrGxsVMb0u7Ellf2NP8Ty3V4N7sx+aSJWx\n", + "Zr60hQ69V5gIG08Nc5ICvQY6R1bT+wCvyb179w7jm1E+oRdkygi0HTPIuGfrAr33fT98NytnA+wd\n", + "y7yeJrN30UzP3YMHD448L455BI4/Nem1dY7MLpY7y7PnuFKX+fH8d4yhCzp7H7W3iP2Iudvup3zX\n", + "ZNu+N0AvlsWxZG7fXvTFxcU0RtTzP5snGcojVSgUCoVCobBBbJpHKmKc7WbPk8Fp+JRTThlZIYDT\n", + "J224VH1W8p2TObK4uCTgvl/72teGtrMYBtMHYOXQD1sB/I5l6RL3tnbakzuWYkYn4kJzfo9uD4wt\n", + "EMd3tO/I/V7cbVgWW0P0Dz1mVDu2HpxxOKtfAI+LrUDaJIaK2Dja8RhldEZra2sjbwcyuNAi45YR\n", + "S5ucE5kdUwHm5+eH8WP+2qozXY8Lz3ldZIVasyJ4q6urg2eBtjM6CffPOrWnju8zb/CK2kPT9sOF\n", + "abNCss6owoJGpsxr6GzHWbEUjtd09pX3C9MPseaYu77eJOjM2eXl5ZTiBuBJ9XowGEsTStuD7XiU\n", + "7du3D/2xV89xKMjvuEPg7F6u91iD9i2Ds68ycl50jF7aDPEWjlfi+1nhxrm5ufTZ472Fv/sZ5DjF\n", + "7Pusi1myON7WcluH3ovsZfZeZ+ooP6va9l1oNCse6+tdDDR7vvB3x23NWqP0jzmK/DyLjrYgZ3mk\n", + "CoVCoVAoFDaITfVIcYq1t8An91k1LDgp+pTOSdt0E7Tptm2Rmuw0s9hWVlaGmIf1qA1o0+TLWWYN\n", + "9zT5pK2CtbW1oW1nbWWgLVsi1iMy4unAGsRaauMebP27zSzzIbMsbGkxRnyOBwsZ2zgGk8465i2L\n", + "7cqodrJ4H1MtLCwsjPrZUri0bWVzylY+HijumXmk+r4f5iJeDFuE9qQQ85LRMiALVqBrAnmezc3N\n", + "DTpjfExxAmzlEk+RxZn4nrTnjKm2DcubzUHTTziuwt4RfreH19e1f0OXJvHNvKPeu1hzs9Z/24eW\n", + "MsYeg8z7la1/2nR8SpbN5rW/bdu2EckwQFf2Ejo7D9iD75hU7xez+mk6GuA3GI7bdHyX6UdcC8l6\n", + "7Pt+FJ/FNfbU0g9+Ms+RzWvO8cCuq9WuI79xOdrnRBaDnF2fEUi3Y+T93rFSWeyYvWTZmuZ6e8QX\n", + "FhZSz5q9ZFkMdobySBUKhUKhUChsEMW1VygUCoVCobAOimuvUCgUCoVC4Rhj02Kk3vrWt47eeRvw\n", + "27zlLW+JiOl3xc5OMs8S70X5u98N33rrrREx4U7yO3Te0/L59ddfHxETHp/23bczmW677baImHDt\n", + "udq043iQBQ4i7unMQWSCg+iiiy4a4mb8jhegF3ToGAe/877hhhsiIufm8vvsO+64Y+BlcpwZPxln\n", + "+LjgtzLHlutt0U84qNo6ORHTXEtcC3cScSmuycLPD37wgxERcckll0TEJJ7A8QmMKTxRb3vb26au\n", + "Q5a9e/cO8RT0k/Fk3IhhcCwg85y56L/TF3QOlxt6jxjXZuJaxp/xJB7J9W/oDxxhF1100VQ76Bp9\n", + "EGN1++23R8QhbjbmCG0yN5ENvjr47Rx/wLpgjrEu4H0DfM/xjXfccccwz13TytfCEWd+M48/7ZiD\n", + "jHnEmLcxaNdee21ETPYK5M0ygeAIY245ptJ1cZCF+UL7yLJr165BHtYFOmSeIwvxSdyLvQu9uOab\n", + "Y0zgfbvyyisjYqLnAwcOjPZSrWEuGgAAHeZJREFUc+cxT5DbzwPmCzyhyO7YF/YLxpRnwMLCwtAW\n", + "44mu0At7kXkbHX/D+md+ITOZo/xOViC8gm9729tGMT6ugs+15qBz7Bvrg+vhoHSFe/rAfW655ZYR\n", + "1x5y009ibL0unGELzPvK3HXMEb9v27Zt2BfZc90WYFxpm+co/XHsKXpiXfAMMLvDtm3bhnFi3rIv\n", + "Ojaaec6+h14ylEeqUCgUCoVCYYPYNI/U6urqyCJxJgzAWsSSe/jhh4e6D8973vOmrnWmmK0583hx\n", + "8nSWVlYhPeMaihifrM2xx+/0B+8AQDbqpKznPWpP2FQ3pp/OZHGlaqweZDNc4wPLwlmR7d+cXeUx\n", + "cD/RB5WeL7jggpmym4vrwQcfjIhx7ZdWFrxc6AUeqp07d061jQXtrK0sOwn9YR22f88yo/CGMn/x\n", + "1GR1pNrsq4iJVeisvdYDiG5spQEsTmTBIj3zzDMjYpydxL25jv5eeOGFETHhaAMLCwsjDizXc3Hb\n", + "6APZmRfmQ3OdMmSZ1dfMW8HvzgjCijcHnb1pgDF11f5ZVZqz2l7MW2cn0g/676zUbL6gD37O2pvo\n", + "D9cwrugczkVgTjmvC2eY0kc8nWtra0M/XCWaNljX9qBYfvTF310x3WOKJ+Ib3/jGsL+x13rP9T18\n", + "b/fTnih4Vl/xildExOyMY7MrMO6upu3sXPT20EMPRcTYg2svqj2As3D33XdHxESXr371qyNiXF9r\n", + "1v4WkWc/ev9wrbBZcN0s+u22eI7gBc8YRAB6M3fr/Px8WhfQ2bfZ/p+hPFKFQqFQKBQKG8SmeaSe\n", + "9axnDZbWvffeGxERZ599dkRMexgiJl4FrJ2zzz578F7Yo2KeoawyK+DkjCxYLHiFbE23p9sHHngg\n", + "IiZVUW154WnBIjnjjDMiYmJx2sLAYuFkfv7550dExKOPPjqlBzA3NzfUD8K6NxM8wErhNE9b6MkV\n", + "nPk+MmGhnHfeeSPZXWvmSDx8bVuMJ94NLA6/22YsvvjFL0ZExIte9KKIiDjnnHMiYqLfiEn/sbTp\n", + "N9faIrWXBw4yPDieN65ThFV5//33j3i5Wg9qe21WuR+4kjN68XxBz9u3b48vf/nLETHx0Jo7j3Xx\n", + "j//4jxER8T3f8z1T92AeAXRK/1/72tdGxMSDhSXeykx/mVPo1nMRi5y1a743j5Hj0fBIsp5m1ddy\n", + "9fDMq2u+vxe+8IURMfFMMB8A+nI9Nsbs1FNPHclg7y5yZ54D12zLKn4jI3Oevu3evXu0Bhkvxv+l\n", + "L31pREzWM2PgtpHZNbts2TO//JYhYsyFRz+41pXNPXcZI1gHkJn91rySLaMAHmh0blnM1+a9x2uO\n", + "+UAVcdYFY+l1tHfv3mEtMa7IZK5F7sXebE+mPZh42Znb7DOzeGUZf9bQD/zAD0TEZN/nGQPQg2s4\n", + "sq9m/Km0jwyzmBYc44h+GAN7pF3Ti3tlPLGuacV8auP2gOOXaYszSMYTaZRHqlAoFAqFQmGD2DSP\n", + "1L59+war3+9AfcLE8sCK2rlz53D6xpoBruDKqZSTpasscx3Wgqsn2yPB9Vu3bh2sT3PjAXOP+ZTu\n", + "9/GOscJjg+fLPGF79+4dTuuc4rMTtOMnspgxQDtYclhD9Ln1BLpCbVvte1a/uB5LAY9UVh2Y6777\n", + "u787IiachZ///OcjYtoiNV8jnkvGwl49X8+9XD0d+N3//fffHxGHrEF79dADn2PlZFX5+d0eTq63\n", + "tdvOTTxuWKmtly5iYqUxnszv++67LyLGMRIveMELpmTB00VsiD01XdcN8tOWsw4tC/c499xzI2Ki\n", + "c3sN6CdzHI8kc7FdF+iK7zi+yl5jZ5rSL/Ri69hZrI7TavuKp8zZps6cA96baIu+eG3TV+ZoVkk+\n", + "YjIHv/M7vzMiJrFueCLs2benzp4G74tmWNiyZcswLhlfqTMpzRcK0DnrnnmCx99vDdDvjh07BnlZ\n", + "O9aNM+LMb+p4HMaUvYj9Ag+V9bJjx45hnjojzOuCfqNznknMWcvCGjdHK/1v9wDe9vg5gYfSOndm\n", + "Of10xhzwnsbf2Zvb671WkJt9w+vfHj2zMWRce/Yy+vnZ9g99eO/NOH2N8kgVCoVCoVAobBCb6pEy\n", + "RxveguydOifL+++/f8QcDziNY1Fw2uVU6/fSnF6xpMySnXGQHTx4cDjdOzYEcPI2n5Vr3ABbVrzX\n", + "5nO/Iz/55JMHa5QTtWPDLIuzGrOTt70L9JUxaL0pzs5zXIH7ye94JABxGq6z41owWKLcp42pM1M4\n", + "lhDxFY5j4npzCLqmEfDvzKtv//ZvH/Ub3SKfvZ2+nrmGB9IeHXskmBcHDhwYxinzApin0NaurTrP\n", + "/0ceeWRKdqPv+8Fq9Vz0GrIlST9Y/7Msx4jJvDBvYuuRzHi6zL0H7D1FL3gRvL+wnzj2albWnr1g\n", + "/I4XPdsvaIN7ZXPRHh1+Li4upnFptIknijVnzzT6QtfMG/rguCTvF33fD3uFvbrm2OQ7XJ9l+XJv\n", + "xijj8mtjpCyD15C/65gpy4LHAg8wc9bZzWBhYWH0GeOfeersJbdn0/10DNWsPZp+owf2UHs93U+u\n", + "N9+hY+RcG8uZu21fudaxXNnzg7b8/My4+bx/tNdncwUgE3sNeloP5ZEqFAqFQqFQ2CCKa69QKBQK\n", + "hUJhHRTXXqFQKBQKhcIxxqbFSF188cUjPjvex/JO+N3vfndETPhw2kwcv4OFOwdOId6nko1CjRre\n", + "Q8PjA6eQMwlcE4nrW24evkOcAXFWcArRNv3kvSvvsrkXPE7moOLevLfl3TGcVRdffPGIG8zxI+a3\n", + "4p7Iyvt6+guPE/0kvoOMGarsIuNtt9028Cw5C83xRozRZZddNnU9MQ/UzSLuAD0ii+M+iMnZs2fP\n", + "0E9zpxE/QAYkcwvuJHifXKsEvaBfOOvgieO9e5tpaO48dM41jD91cJAJvcDN5phAYgGor3TddddN\n", + "tf/UU08N2XiufwQXHpxi9I97u0YV4w+Pm6uTO6as5SB0fBZtIws6hMePOAx0jQysD/NhAfMFgt/6\n", + "rd8a8XhlFc3hWuN6x0Y4wwret5bfMGLM4Xjw4MFBJ17/zh7yfsHcoi2uQ4/E46EXOMjQd5vFR9wR\n", + "c9F8mMDVpZkvrFHH0JAVSuwI/GbmcpubmxvkRxb6aQ5S9hLHDJlr1TFVzrjzPtq22XK+RUz4Kr3n\n", + "OkuNPrifjCl7FfsKY4Aef+EXfmG4tzOn6T/rgvlivTiuB72wLpx5hkzEVP3mb/7mILfjF5lT3PP9\n", + "739/REy488zF6XhYuFmZX+YTZI0fOHBgtEcD2kY//N4+52a17XpR5lt1zOHc3NywBumn1zNrkuvY\n", + "m2655ZY4EsojVSgUCoVCobBBbJpH6oQTThjx22BpOJuFv3PCbqvwOguDk7Vr+HCqz7LTnL3j+jOg\n", + "zQbj1Jpx/3CtmaXpp9vOTuZ835kSi4uLo8xALAbX1zKcvWZvkqsyO6PSGYQReRVpW5rmPzMPFrVN\n", + "AHp0vS7Pi/ZvWIFY2syDLPPNbN/OtASuidVam86q4XfmiTO+snnurCasOuu85ZxjvLmX5TR3FDrl\n", + "pz0Vrk6O5cocnpWZiTVO5WZ7VgH9QEZ+4gXwGjVvHh4uZGwz6zwHgbOJADrmHpkHA2QxpfSpzWq0\n", + "p918ddaLM06Zq9kYOZuprfHjucLcor/OuvN8cZvMQT53Zq31Nj8/P6qflLXtzEfDWZ7mMDRaDwQ6\n", + "ZP17L7JOmYPr9ROZmIvIYj2urq6O3iigj2xvcdZdVrurvUfEpMYb7bfrgrXC84KsTT5vK/JH5Nmu\n", + "5l4EyGiGEHtLIybrG/nor984APrtzEj2pox9hHu2NQF9D2cKsm44Y2Rz0iiPVKFQKBQKhcIGsWke\n", + "qeXl5VElU+I8XMHZlt2jjz46fEa8icHJk9geTr0+YbpODCdpLA17dlqPBrWJqPqcVeTl9M71WC+8\n", + "jwV+T28PDVYhmJ+fH/RAtWe+C/cacKyLKxbbm0LtI3TOCd0esLZ/wO+ybQViURK/xjttdPsXf/EX\n", + "U9fbi3TPPfdMyfLyl798dG/6yzhS98UVvF01Gh43ONds9boOE/r5l3/5l5HF6JiYH/mRH4mIiI9+\n", + "9KMRMdYL13MPYoCQxZ5Pxmhubi4++clPRsQkFtBV1rHeiG15zWteExERn/rUp6ZkBMwT7knlZvRx\n", + "1llnjWR3DTbXoAG2brk3Y0RVcYCVyE/i9IjXaT0e9tK46r5rGrXei7af3MuVze1xYN6gp1aP9m7b\n", + "kvZ42lvkmEF76lhHzBdqfZ111lmjeW7vH5Wu/+7v/m6qv8B6NJ+fvQDM3dZr6O8As0zY0+zrWVf2\n", + "XOIltWeX3xcXF4c9Bt1m/WSOsm6ymlb2En7/939/RER8/OMfj4jxfrG2tjbIw7OE9Ww4lo49hjno\n", + "Zxd6Y05/9rOfjYiIF7/4xVN9i5jojjFhDjLfzW/rGFDXNsuYE+j/q1/96oiY8KO2b1MYCz7jHvbg\n", + "A3su7bnOvM+MNfvEgw8+OHpGO64MtgxzC66H8kgVCoVCoVAobBCb5pHaunXrcOLmdGsGZsCJE4/M\n", + "zp07B8va3hBOt5w8OVFSJdweKMApFg8GFodPsO2JnHtlvEz29mAdZVkqnObpJ/3GUplVZRvdwaGF\n", + "NZ/FSHCKR4ZZsU4RMcoGRB9c31o7tuqBLXHA+MJThxeIMXU76BnLDK8LFnirF8dyYHn5HT7gc8cn\n", + "MU9cyZvvo4fWUvPcYmzoFx6bz33ucxEx9uo4lgLgDbTsXDc/Pz+Kp7IObUG+8pWvjIiIv/mbv4mI\n", + "sXeU7/M566KNy2qxsrIyeNBok/HCgnQ/zQiArr2m0Stj5LnYepmyeELHtrRytzIiM/20F4i5bP43\n", + "1nbrPcX6N98YPzNPCuOKt4D+ZlW4aQ99nHLKKVNxpK3cZAC+6lWviojJXLRHAlkYU8d5eo6aT3DP\n", + "nj3DPc3LSH8YZ1es9tzy53gY8CJkXoaTTjpp8AI5Y85gbX3pS1+aatNvAVhH6B49fvrTn555fSsb\n", + "c4Q2PLeY5/ydMczi+9jb0C9zvq0uD/g/vKb8ZG+y3NzTeztjYQ+239zgiaL91kPO+JhthHt4/OkX\n", + "/fX+YNBXvteuecc8Mu68LWLN8abLHukMm3aQ2rt37zBIuPTbv7Ww63dhYWFY+CgXMEgMiqkt/MAA\n", + "bFIoku+7/TYIl6BaJp1dkgyaJx2bthcGsvtVoEsyzMLdd98dEZOAQzZ4wKT1QQPZvTHSDnrxq772\n", + "IeADk4PBDcYTPXzsYx+LiMli9GspB2mz0M4888yImH5dRxvcm/7aVQ14yHGPl7zkJREx2dQywmWT\n", + "Y8/NzY2u9WH1z/7szyJiojtvCP6cV8ZZ0D5junXr1njZy1421V8/SJEBXX34wx+OiImefAjkcx5W\n", + "9M0k1mDHjh1Tqc4R44BVYIJY2qQ/1gvXo3teY9MXjKSI/EGJ7nwwZs0xp5DVwbduB30x/rTb6oV9\n", + "DF16E/ehzqn37fi2sgH0zL7THsz9YPOhizVHf7zm0DWfmyDZ4087yPic5zxn6I8PjC5JwVy1boED\n", + "/5mTtJMdAr7+9a8PD8JZpNLtPV3Ggn54X6TfPPw/8pGPRMTkMGPaq5WVlWGc2UNp03OVOcS89oEi\n", + "o6dCpu/93u+duq7tK/s4hznWDM/DzPB2WQfr3tczFnZItAaGX6daH97nGBPmuYPVDSd5tc8yryHm\n", + "FM9y5GcMsgB/o17tFQqFQqFQKGwQRRFTKBQKhUKhsA6KIqZQKBQKhULhGGNTKWJ4b8p7Sd6N8g70\n", + "+uuvj4gxvcH8/PwQR0Ew5Ic+9KGImJTw512og4NNswL9AO9neZfOu1NkvOaaayJikqo/Nzc3ii9A\n", + "PqhtKLPPO1velTu24fd///en+pkV5rTsl1566egdLv3k81/5lV+Z0gufI4PjjmgbigjejfM99ML7\n", + "/Pe9731DyX8HkTIG6JC2oSvhHbcDm+n3tddeO/Sz7T9jxfv+r371q0NJAV9rGiL6C+UD40n/0J9T\n", + "1JElo0Jo5f7t3/7tKVnoJ/dGh8SGQG1gqh2nrBOHAC0D1Alt2y5Sx7XI4mB6ficoFLoKZLHOia1g\n", + "Xvzpn/5pRByiWkFurmVdoCNTeDhI2rEQUIpA42K9uK/XX3/9aPytH/rNGoUKx6n3rA9iPX73d383\n", + "IiY6z+b44uLiIDdzhX6ZnoM2oOWBIoY5Zz0yb66++uqp9kEbc4JOoJPx+GdB94y/ZWduE+dDO5al\n", + "LQrq2E7aZvyZz6ZnyuitZgUPt6Cv6HF5eXn4DvOV8YUihLnleC4SWpiLUMq8+c1vjohJELLLrXA9\n", + "6+6yyy4bxc6ia74D/ZjpzQC/I9sdd9wREZNnlwPAie/hPjfeeOPQT/TBvYmlY13/yZ/8SUSM91Hg\n", + "hIl3vOMdERFx+eWXT90Tmdv9lzVH2y6GafoZ9kU/0902v7One48mjnHLli1D27fddltETOaKE1mI\n", + "U+T8wNzNUB6pQqFQKBQKhQ1i0zxSa2trwwmUApxk2Dnzwdlqp59++nCydFo3p1NbAS7+CbCG7LHA\n", + "2nUGQXvC5h7IQFqu5cYKxrKkoKDT2V08EKuBwpwuVLq2tjbK/KOIn/sPnGGIZ4nMqbbtiHHRNGRu\n", + "M5BsUSCTs04Af3fBTqwAZ5BwLxcHBC4+GjHRHbKRueF0VvrnQnuUZnDBV1tN4PTTTx+8OsDUHswD\n", + "MsKyNF57AR5++OGIyDNUIyZWOpYlcyZrG/1ceOGFETHO2rLHhbmNF5C1CtosHuRGR1lKOLrH60OW\n", + "qte/vcTolfXQFs3zfHXquLP2TIXEGPG5M6U8p50m384Lr3/2CbwAHiPrnAwpU0UZptrat29fmhHI\n", + "NYwnxSHvuuuumbKga/TmMgruK7Kurq4ONCQuauhsTpO5u3SFiwkzD0jhZ96AliaI7zgDGphAGO8F\n", + "+4VLd5hQGi86RYG9LtpsXnSPLFnbgPnCmvPeZQ83MpHB7fIqbT8pyEoG7F//9V9PXecyH36b4j3a\n", + "zxt+R+Z272I92DPr54fh613mAFiP7dsU79umbeL5xl7uMcpQHqlCoVAoFAqFDWLTPFLbt28fvVfm\n", + "BO46Uj6hdl03WCOul+L6HyZ8zE67XIdFgrVrS512FxYWhrY4xdryNrUNtZ0cCwA4WaOPtuBixLhu\n", + "xvz8/IhOgOKW7if9wnoxPYc9e7bouY7PW2/IrOKM7Xcz0lpkpnYXsts75vbwSGHpPvXUUwNFimt2\n", + "AbxAruXjujguROd6TI6laa2frJCgC3Py0541e/YsS1aoc2lpaUQmmtXLQef2zNqKc+FN5t655547\n", + "df3f/u3fDn11PBWW93rkvBkxOMAqdh9NpDyrLRfotSx4Wkw/wk/r0X1wHaqWIgS5ucaeNVvSru1m\n", + "MtqMWNZ7Xd/3KV2V4+5YQ+sVKkYPeFy8Rh07s7q6OrTpvch1fjwfsvpzfM5axaPnvQsZlpeXB13z\n", + "Ha9/kzkzXygoSa06t809GW/Wxaw3AS4S63EDJmd3XTbrhc8Zd37aAxYx8SghHzXqoJOhEClwjSfX\n", + "hrMsGQ0YXtW2rqHjFb0XZV5fe2azmDnaRZ/tOrOcjo3i78idFaw2yiNVKBQKhUKhsEFsmkdq9+7d\n", + "o2wtV6E2sNieeOKJKc9QC1tBWAyZp4I2XT2dU7ItjDbmgjgDrFefpE3wiYWOd8wxVbae+Z3MRFvT\n", + "7f3w6nzmM5+JiLH1yrXoC53z7trWEf028eOsCsH0z++4M527+rwpEdarbI1XBW9h21f6acsDSzSr\n", + "Du2sxAsuuCAixpaXvYR8/8knn0zv6Tawdhw7gr5MXowsBjLPzc0N2VRY6ZnczCl0/olPfCIixvoC\n", + "XI8ngnuS1QROPPHEYVzpF2Nh0mnHUDGOGTkzfaE99gm+18rexse0v2c0RvYCcm/moL3MrqqM5c2c\n", + "bPcj00wRV4TcWRV22mZfYV147jrWBJx88smjtYc+WuL3iHGsJLCH1nuSx9Qej6WlpSFGxx4pU1/Z\n", + "i+oxok1TZUHSa68xY7S8vDzogXWRUX6Z+sYE08DxOXiX/+qv/ipmYe/evaNK7mbyACa5N9WLx9me\n", + "TWRlfrXeUce8EQNK/JX3C78FcTxbNqaOB53lXfRao+0so9RV502x5r2L8Xf888GDB0fPOXTIvXku\n", + "osMiLS4UCoVCoVB4hrFpHqldu3YN72lNVugYKU6L/NyzZ8/oPTtwLI/rCdmD5WwNZ5Rk7+sXFhZG\n", + "XjFbgY6n4R6ZF4h7+Z60a49Xa3E5xsEWo/u/srISjzzyyODJsKVmriETjM6Ca6o4tgUwNq574rpi\n", + "lh0ZsczsqWqvtSVtDxJwrSPX5fJYOFOk9fRkMXLcm78z/ieeeOKQwdn23/EJWdwT1tLc3NzI+vJc\n", + "9Hqxl9QeJvrn2m6OMWmv9zjhgfGaow3XnLFHDuAdyfgSW+sYa9XxKM6IBY8//niceeaZoxgye2SA\n", + "9QFmcbNZV96bvObs9WFN402xLLb624w5W/XmyrNHIYvv89jhZcr2G2JW9+3bN9oH3E/08dhjj8UZ\n", + "Z5wxtJkRTqNzsjxZu/YatbyJs4jeW3ic7QWyXpgf3l/43NmMJ5xwwmgPyjwveCD5nJ9+hoFMT64R\n", + "2Pbbc4Zn0iOPPDIVD2YvEHM545UF/N116lrZHQvn2Kf19uBsPlkGc75u2bIlnbfMIa9jr7kMm+aR\n", + "cppo4fijxmDzQWmDwuag1sDmg9eMhc0DCQ2FjaG49gqFQqFQKBTWQXHtFQqFQqFQKBxj1EGqUCgU\n", + "CoVCYYPYlFd7hUKhUCgUCt8MKI9UoVAoFAqFwgZRB6lCoVAoFAqFDeK4H6S6rntt13X3dl13X9d1\n", + "lx3v+3+rouu6B7uu+2zXdXd2XffJw589q+u6j3Rd96Wu6z7cdd3J67VTOHp0Xfdfu657vOu6zzWf\n", + "pTrvuu7yw+vi3q7rXrM5Un9zIRmDq7qu+8rhtXBn13Xf1/ytxuAYouu6M7uu+2jXdXd3Xff5rusu\n", + "Ofx5rYPjhCOMQa2DY4TjGiPVdd18RHwxIv5TRDwaEZ+KiNf1ff+F4ybEtyi6rnsgIv5d3/f/0nz2\n", + "7oh4ou/7dx8+1H573/e/tGlCfpOh67rvjog9EfHf+r5/2eHPZuq867qXRMT/jIh/HxFnRMRfRsQF\n", + "fd/P5m4pHBWSMbgyInb3ff/rurbG4Bij67rTIuK0vu/v6rru2yLiMxHxnyPijVHr4LjgCGPwI1Hr\n", + "4JjgeHukXhUR9/d9/2Df9ysR8b8i4gePswzfynANjB+IiA8e/v8H49DiKhwj9H3/NxGxSx9nOv/B\n", + "iPhQ3/crfd8/GBH3x6H1UvhXIBmDiPFaiKgxOObo+/6rfd/fdfj/eyLiC3Ho4Vzr4DjhCGMQUevg\n", + "mOB4H6TOiIi2lPBXYjKghWcWfUT8Zdd1n+667qcOf/bcvu8fP/z/xyPiubO/WjiGyHR+ehxaD6DW\n", + "xjOLt3Rd9w9d193RvFaqMXgG0XXdzoj4joj4RNQ62BQ0Y/Dxwx/VOjgGON4Hqaq1sHn4rr7vvyMi\n", + "vi8iLj78ymNAf+gdb43PccRR6LzG45nBzRFxTkS8IiIei4gbjnBtjcExwOFXSv87It7a9/3u9m+1\n", + "Do4PDo/BH8ShMdgTtQ6OGY73QerRiDiz+f3MmD75Fp4h9H3/2OGf/xwRfxiHXLWPH35/Hl3XPS8i\n", + "vrZ5En7LINO518bzD39WOMbo+/5r/WFExPtj8tqixuAZQNd1C3HoEPXf+77/o8Mf1zo4jmjG4HcY\n", + "g1oHxw7H+yD16Yg4v+u6nV3XLUbEj0bEHx9nGb7l0HXdUtd1Jx7+//aIeE1EfC4O6f71hy97fUT8\n", + "0ewWCscQmc7/OCJ+rOu6xa7rzomI8yPik5sg3zc9Dj+4wQ/FobUQUWNwzNF1XRcRd0TEPX3f/0bz\n", + "p1oHxwnZGNQ6OHbYcjxv1vf9atd1PxsR/yci5iPijsrYOy54bkT84aH1FFsi4n/0ff/hrus+HRG/\n", + "13XdmyLiwTiUxVE4Rui67kMR8R8i4tld1z0SEb8SEdfHDJ33fX9P13W/FxH3RMRqRPxMX7QD/2rM\n", + "GIMrI+I/dl33ijj0uuKBiHhzRI3BM4Tviogfj4jPdl135+HPLo9aB8cTs8bglyPidbUOjg2KIqZQ\n", + "KBQKhUJhg6jK5oVCoVAoFAobRB2kCoVCoVAoFDaIOkgVCoVCoVAobBB1kCoUCoVCoVDYIOogVSgU\n", + "CoVCobBB1EGqUCgUCoVCYYOog1ShUCgUCoXCBlEHqUKhUCgUCoUN4v8BaJ+sNGqpC6EAAAAASUVO\n", + "RK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "filters = net.params['conv2'][0].data\n", + "vis_square(filters[:48].reshape(48**2, 5, 5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second layer output, `conv2` (rectified, only the first 36 of 256 channels)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJNCAYAAAARaCA+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3VuMHdd97/l/SSSbZLN5b7LJ5k0kRTISJdMWJcuyjizL\n", + "ythGjNgxjBMYuSGTGQxwkMyDHWSceZjIQBBMBnCekpMXjwPDmOOZIIkNx4EhObElHkqmJFIiJd7v\n", + "tya7m5fmXbyIrHkQe+lXS13F6rXrtnd/P4Dhf3HXrqpdu3Z1af3X+q8ojmMDAADA+NxX9wEAAAC0\n", + "Ix6iAAAAAvAQBQAAEICHKAAAgAA8RAEAAATgIQoAACBA4Q9RURR9IYqivVEUHYii6H8revsAAABN\n", + "EBVZJyqKovvNbJ+ZPW9mA2b2ppl9PY7jPYXtBAAAoAGKbol6wswOxnF8NI7jW2b2/5rZlwveBwAA\n", + "QO0mFby9fjM7IcsnzeyTukIURZRIBwAAbSOO42isfy/6IarWB6Q1a9YkloeGhlx88eLF1Pf19PSM\n", + "uY19+/Yl1rty5UpLx7dixYrE8smTJ138/vvvp75v+fLlLj527Fjqevfff/+Y24uiMb/70s2fP9/F\n", + "/vmfNOnDS2/69Oku9tPL+r7bt2+n7mvu3Lljbu/ChQuJ9dK+wylTppjZB+dt0qRJNmPGjDHf09XV\n", + "lXjftGnTXKzXW9HnXD+Tmdm1a9cK3X670uulr68v8drly5ddvGDBAhfPmjUrsd57773n4v379+fa\n", + "78KFC108Z86cxGt79+7NtQ11330fJgX0d2xmduvWrVzbmDlzpou7u7tdfPr06cR6S5cudfGlS5dc\n", + "nHWPVP5vVI/3zp07ubaR9n4zs97eXhcPDg6mvm/27Nku9n/nSu/vek34v2Vd1vMyefLk1G3rPSnr\n", + "s+v9afHixYnXdu7cOeZ79Pv0v5u67ukTzV/8xV+Ymdm3v/3t1HWK7hP1pJm9EMfxF+4u/7mZ3Ynj\n", + "+K9lndIetPQPs1n2g0maefPmufjcuXMtH1Nd9Hst8wen58ss+R3oQ8VEEHLO/Rv0l770JRf/6Ec/\n", + "avmYfud3fsfF+h8FW7dubXnbWVatWuVi/WO3bdu2Qvej5/zxxx9PvKYPRyMjIy7WP5BmYf9x9IUv\n", + "fMHF+ofZzOzVV18d9/aqtG7dOheHPPAV/RDVRPrgpdeRWdjfFX3Q1msxL/+c8xBVjdHzHkVRaktU\n", + "0X2itprZg1EUrYiiaIqZ/baZ/aTgfQAAANSu0HReHMfvR1H0x2b2opndb2b/NyPzAABAJyq6T5TF\n", + "cfwzM/tZ0dsFAABoksIfouoUkqv2tXM/qKpo53u/w/P27durPpy25nca3r17d6Hb1879p06dKnTb\n", + "WW7cuOHioj9TGu0wbZbsb/av//qvLvb7uIQ4e/asi4u471QppB9UlnbqB6UDDIaHh1PXSxukMx5T\n", + "p051cUg/KLQHpn0BAAAIwEMUAABAgI5K5zWdXyfq6NGjtRxHiEWLFrlY67i8++67dRxO4y1ZsiSx\n", + "rDXBsvi1yfLQ7+PMmTOJ17773e+6+Lnnnhv3tkPl/bx56ZDutLIsfq0gTe8VnXLTUg1ZdYQmAq1J\n", + "pWkwv5RECE2JaWkGM7MdO3a4OG+pHq3r5pdnefTRR138q1/9Ktf2nn32WRf7pTLKLiOCZqAlCgAA\n", + "IAAPUQAAAAFI51WonUax+HTqCH8aiSb43Oc+5+L/+I//qGy/mh5Qfjor7xQVIfwUnrp69aqLW522\n", + "qAyf/exnXfzLX/4ydT1N1+iUPOrIkSOJZf295Z06JYtOC6KjD2/evNnyttuZTqOj11sRtNL39evX\n", + "E6+FzLah02atXr068Zp2TfD3lebll18e9zHg3oqYfSSEPwVRHrREAQAABOAhCgAAIAAPUQAAAAGi\n", + "kLxySzuMomp32CBV5nn1e+3EGb8/+clPJpZ37drl4rr6/uQ957/xG7/h4n/7t38r9ZhUWp+eOv3B\n", + "H/yBi7///e+P+/16zvXzmZlNmTLFxUVcE3mrXXc6/2+Glngo+p6Wp7SFz++nWESF+qr09fW5eHBw\n", + "0MX+Z+/Ee7rOfuFfR3X1Oxw971EUWRzHY550WqIAAAAC8BAFAAAQoJZ03mjzbxHDjjG2pqfznnzy\n", + "SRefOHHCxQMDA6nvCWnar1Lec66V6/20WhPLR4TQlEqZ6ZQqr3OtgK7XrG/u3LkuPn/+fKnHVAf/\n", + "t6ezGVy+fNnFRZQ7SEtv+bSauV/yo2mTyvsV7rXMh1Y512unU9N5msLTmRe0FEWdSOcBAACUhIco\n", + "AACAALWk8zZs2GBmZjt37ky8VlVV0rpo1Wqz4itXq7Q0hz9yRSvzVnktaAqgiSksHUmZ97oMSS3N\n", + "nDkzsazfx0SvhJ1H1ui8tPO3Zs2axPL+/ftz7Stroud2panlvBOi+/eJxx9/3MVvv/22i2/fvp1Y\n", + "T1NzFy9edHFWunflypUuPnv2bOK1IiY4LpKfplu2bJmLr1275mL//GWlKdPe0ynpvKaPeCWdBwAA\n", + "UBIeogAAAALwEAUAABBg0r1XKd7ChQvN7KOzrmuevBP5s8+X2ScqTVOq9zaxH5Sqqn+e369Dh8fr\n", + "d1XX96bHY9aMIfvz588f89/9GQG0T47G/n0nr6lTp44Zaz+2dlNEGYKRkREX+/2glPYJ1e/Q7xur\n", + "9G9Cd3d34rW8faLKLI2ydu1aF/t9erQMBv0bx9bEflDjRUsUAABAAB6iAAAAAtSSzhtNTXR6+s5H\n", + "ky7uRdNl999/f41H8gG/BEPedF6ZFcv9tM4oHUaedQyhMyXofrMq67eTvKnIrGtRU3NZqTO9/+Xt\n", + "ylBEtfGiU3haSmPfvn2Fbhvth5YoAACAADxEAQAABKglndeEET51uHLlSt2HgAbIO0Ft1kinquSt\n", + "Yu0rczRh3slJi04p6mirO3fupK7X9CrMKm8Xg6xrUe9rel4OHz4cfmA1yxp96U8ajomNligAAIAA\n", + "PEQBAAAE4CEKAAAgQFT08M977jCK4tEhsf6s3O2qp6cnsXz58uUx1/OHCZfZ50W/106Z8TsvrQxf\n", + "ZT+0djrnfvX8pvXXmzJlSmI5re9OE8659oEyS1bm3r9/v4tXrlyZWE+rhQ8NDZV0dMXz/2aUed61\n", + "rEQR1dWzfP7zn3fxiy++WOq+xqvKc44PjZ73KIosjuMxTzotUQAAAAF4iAIAAAhQSzqv0h1OUE1I\n", + "c1TpySefdPGuXbtcnJZaLUPR5/yzn/2si998883Ea01Lv5Xtvvs+/O89HUZf5XWulapXrVrl4qyq\n", + "2np8v//7v594bcuWLS7evHlzEYdYiaJTS7NmzUos6+TfWoU+9G+Vbn/OnDkuXrhwYWI9vW807ffV\n", + "lHSeptn1d1jVhO1VI50HAABQEh6iAAAAAtRSsRwf0MldL126VOORtJ81a9YklnUi0CpTeGX65S9/\n", + "6eLJkyfXeCT109SBP3KvKvp7Xbx4sYv9kXWPP/64i3/zN39zzPeYmf3iF78o+hAbxR8Bmlbpu+iJ\n", + "6L/yla8klvW3c+DAARe//vrrhe53Ishb4X4ioSUKAAAgAA9RAAAAAXiIAgAACECfqBrdunWr7kNo\n", + "vHnz5rm4t7fXxadPn06sV3S/ilZNnz49saxDtUNwrXxIq1hXSfti6TE89thjifWef/55F+vw+u9/\n", + "//uJ9d56662iD7FR/GHvrV7Dy5YtSyxrP1I9z2+//XZivWPHjrW0XyALLVEAAAABeIgCAAAIQDqv\n", + "Ru+9917dh9B4fX19Y/5709J3vo0bNyaWN23aVNOR1E/PxdatW4O2MXfu3KIOJ5hOLDx16lQX+yUX\n", + "RkZGXPzGG2+4+Ec/+lGJR9c8169fL3R7x48fT33twoULhe4LyIuWKAAAgAA8RAEAAASoJZ03Onli\n", + "1ZMfo/3oCBx/RF6TaWXkiW7//v0uXr9+feK1nTt35tqGXgd1TXY6PDzs4h07drjYT+dpGuull14q\n", + "9BhWrlzp4sOHDxe67Ynm/vvvTyzrJNdljoZdtGhRYrmd7mv4KFqiAAAAAvAQBQAAEICHKAAAgAC1\n", + "9IkaHSqsQ4EnIq2yq/n58+fP13E4jaTXSF19YUJU2c+hv78/9bWBgYHKjiON9mfK2wfKN23aNBdf\n", + "vny55WMKcebMGRfrZ3r44YcT682YMcPFN27cKPQYtMwCWrNq1arEsvbdK5pWW+f+3lloiQIAAAjA\n", + "QxQAAECAWtJ5/tDSiUorlmsKAB+6cuVK3YcQZPLkyYnlModMa8pz0qTOnIRgwYIFLq4rnac0Tadp\n", + "eTOz27dvV7Lfdqb3uyp/4/Pnz3dx3lkP/BRqSHX0rGrraG+0RAEAAATgIQoAACBALW3/Z8+erWO3\n", + "jdPT0+PiTmmmxwfKTN/5rl27Vtm+6tLkz3jz5s3E8tDQkIv1Nx6ahpw3b56LT506FbSNpglJ4c2Z\n", + "Myd1G3l/b1evXnVx3gngmVlj/Lq6ulzc6X/baIkCAAAIwEMUAABAAB6iAAAAAnTmeOg2sXTpUhcP\n", + "Dg66uF2H9aM8GzduTCxv3bq1piOpR5Nnuj948GBiWctbzJ0718WhfaL+03/6Ty7+8Y9/HLSNTlDE\n", + "DBd5+0Gp6dOnJ5bzlkaYyLQfmZY0KrP8R11oiQIAAAjAQxQAAEAA0nk10qZlTeehOH51fG1mvnPn\n", + "TtWHE2zq1KmFbs+vbN5Okzs3jZ9m0vRPyHldvnx5Yrm3tzfswCaQdevWudj/rWzfvn3c21u5cqWL\n", + "Q8tK6KTZ+p36Fc878d7vl/3oZLREAQAABOAhCgAAIADpvBrt37+/7kPoeO02GkQn2h0eHnbx5s2b\n", + "C92Pn2bq7u52sVZ1xviFTFCrvvrVryaWixiVpqIocnGV1bg1zakV6PXaM0umL48ePZq6vdWrV7v4\n", + "0qVLLt67d28rh2lmZjNnznTx4cOHg7ah3TWKOCY0Ey1RAAAAAXiIAgAACMBDFAAAQIBa+kSN5uTL\n", + "zsdr5WCNmzIjPLODw6f9oKq0YsUKF+/atauWY2jV/PnzE8s61F37FRXR5+u++z78788ihnMvWbLE\n", + "xbNnz0689s///M+5tqGfX+93frX3Mu87PT09LvY/x7lz58Z8j/99XL9+fcz1/LIcfqX4VmWVSQDS\n", + "0BIFAAAQgIcoAACAALWk86pKY2nT8kQetq2ToJ4/f77GI0FTtWsKT33ta19LLB85csTFRZeIKLra\n", + "/fr16118/PjxxGv+chqdGNev1J+Hlj4wy3+fnjdv3pjv8e81mo7TMgZnzpxJrJdWlqTsqvpaXmTT\n", + "pk3jfr+fvkwrdaHnyyxZ4iHvd43moCUKAAAgAA9RAAAAATqqYrmmrcySTdo3btxoefvLli1zcRHN\n", + "rppuvHz5csvbS5M22iXUY4895mKtymtmtnv37kL3BeTlp6MGBgZcXGU6P6QiuKbzfvrTnwbtt6ur\n", + "y8U6Oi/v7z+0m4XuK2syXa1YrhXGmyIkhaf8e2Eaf5Ri2qjFvDQ16n/XZf5dwQdoiQIAAAjAQxQA\n", + "AEAAHqIAAAACtH2fqGnTprm4r68v8ZrOxL18+XIXv/POO4n10ioOax8oM7MpU6aM+/h02Ks/LFor\n", + "DGufrSIqIKu8Fdr1fC1evDjx2qxZs8Z8bcuWLS0eXTM9/PDDLj527JiLr1y5UsfhBNN+gWlDx9uN\n", + "XovqxRdfTCwfPny4isP5iDVr1rh43759ud6zc+dOF+/duzdov1p1XssBaLX2MmT1g1JNmSmiLEX0\n", + "u82rv7/fxatWrXKx/zdGr6u0kgt10vIOdZUh0j6M/t+9PGiJAgAACMBDFAAAQICo6klwoyiKmXgX\n", + "AAC0gyiKLI7jaKzXaIkCAAAIwEMUAABAgFpG561bty7x/6O04rhWcT179mxiPR2BoKPfPvaxjyXW\n", + "e+WVV1wcMopMK3Obmc2ZM8fFWn1XRwiame3YscPFOkLIH3WnVYo11hELZsmJO7XKuT8qRkfhaNVj\n", + "v5IzyqFp6rrOuV6XZp05IkoncNV7gz96Vn8rOjJRJ+r16QjVKqtq6288dKJdvQ/dunWr5e2l8btj\n", + "pF3rWsncPyatrp53VJuOSDNLjsbetm1brm0UTY9paGgo8VqR5z3vOS+b3l8effRRFy9dujSx3vDw\n", + "sIt1dPPRo0fLOzgLmy0gS55t0BIFAAAQgIcoAACAADxEAQAABKilT9Ro36Ks/hva12HPnj2J9TS3\n", + "rtWL/Tzxrl27WjrO/fv3J5YfeeSRMY/Pn4X7xIkTubav1WRPnz7tYj+/PGPGjDFf0383q7ZiLrJl\n", + "9QcpU5V9oKqsNrx69ep77suvyH7+/Plx76foflBaRfy++5L/zar9JbU/qPYnGY/33nvPxQsXLnSx\n", + "31enaFrlWSv6Z1X3z3uv0r5izz33XOI1rcZfZZ8o3a/2zy2671kT6f1F++ROnTo1sZ7+RqusRF5H\n", + "+SRaogAAAALwEAUAABCglnTeaJOgP+Rf03HaTOpPqqipkYGBARfrhL5mZpcvX27pOP336/Hu3r17\n", + "zH8PpSlBv2SCNovrsO3e3t7EemkTs6J6VaXv6lRlM/3BgwfvuY6WIDH7aJq9DjqRtd99QdN2oSm8\n", + "NJrCKzu1fOrUqUK3pzQFqilKM7MjR46Utl+9B2ua1CyZNtZuGBONpvOy/lbq9eaXISnib2fdaIkC\n", + "AAAIwEMUAABAgFrSeaPNsP5oFa3+qmkrP02nzfQ6UqLsKq4HDhxwcZnNkDpSxyx5nrTZVD+72UfT\n", + "BUCrdEYAs+SsADojgE9H7mlqxJ99oEhaBdssmd7OqlJeJk1f+OnGrNFrRaoytVxE5XWlo74uXLiQ\n", + "eM3v9lCkIo59+fLlLtaq3Z3i+vXrY8YTDS1RAAAAAXiIAgAACFBLOm80JfXuu+8m/l2bUDW156cU\n", + "dLRJ1gSkRSszJaBF+VatWpV4TQsAagrg+PHjifX8gmeoj/9dlNncvWjRIhfnHS3k/6Y0VaJp4eef\n", + "fz6x3j/90z/l2r6mkKocxac0fabnv8qitGfOnHGx/3uti14vOsKqiEKFy5Ytc7EWEw2lXTn8FFta\n", + "oeUiPkcRKdBOTOHho2iJAgAACMBDFAAAQAAeogAAAALU0idqlD9hqJYQ0OH7WRVjdfi/X9m8nehk\n", + "wn75BK0+rBNA+iUOdFg56uVXiS6zT1RI1WR/uLjSayxvHyhfmSVA/Im3R/mVs3W4vQ6HX7BgQWK9\n", + "vBOG56WlFrRfUNY5r1LRVbb1PlT0JLx6HfmlbrRPlH7XE2G2ADQHLVEAAAABeIgCAAAIUGs6z6dD\n", + "j3fs2JG6XloKr52rpmoKRSdVNksOldVz5Jd0SEtzoHqtTn49EWmara+vL/GalkPJW+lbU0v6fZT9\n", + "3eh+y5ycN4um9ssuMaHdK/KWcdAZKbK+D72n+ff3kZERF+vkxCdPnsx1DE0RUp4h7/lD+WiJAgAA\n", + "CMBDFAAAQIBa0nmjTZF+M3Pe0XVp62ll73ajlY39UTxpzbX+en6lc9THnwxaRxmFjGDyJ1vViuNF\n", + "j7bKsmTJEhcXkTbRkWzDw8Njxu3GH3VcBx2t1kSafsv6O6ApuzfffDOxnk7wu27dOhe3WzpP09g6\n", + "EjvL5z73ORfrKEX/d6Pb0/uEf8/Q0cQTbXRjqyP8aYkCAAAIwEMUAABAAB6iAAAAAtSSOB8dpt/O\n", + "FcaLFjJM9dy5c4nliZbLbjItWVEEv2q/v1yVkP4m2ufD77OhJTvQmnnz5rlY+3lUKe/Qey3bkvV3\n", + "IOtzPP744y7Wkg7//u//fs/jrIL295s7d66L/f5IIfeKRx55xMXLli1zsfYhM0vOAvLOO++42O+H\n", + "pn87mvB3RK9ls+R1oNeV9tE0S57LrPIic+bMcbF+T4ODg+M+VlqiAAAAAvAQBQAAEKCWdN7ocG+/\n", + "qZb03vj4za7tPCwc7ae3t9fFWqLD14TrciIM4V6xYoWLNdWf9d0UTScj9st8aKol73eQNbmxLuf9\n", + "jM8884yLN23alOs9ofQzahkCP50X0pVDt6Ep8d27dyfWO3jwoIv37t077v1USc+RP9m0lvPRyvX6\n", + "+cZDy5BoKjgELVEAAAABeIgCAAAIUGtZW9J3xWrnCZhRjvXr17t4z549Li6iqnaVaaJWdWIKz5+k\n", + "WUdmaYX8Kumo0ax0Xl56T/Mn5926dauLt2/fnmt7O3fuHPcxhNLuKkXPKqCfXdOBhw4dKnQ/RZs5\n", + "c2ZiWa9TrbLvjx7MW8k9L53dpNWZTmiJAgAACMBDFAAAQAAeogAAAAI0e6pvjEvTZ25H9arsA1I3\n", + "LblgluwHpUOk81q0aFFiueh+La3y+xhdvHjRxXVVtNfh9lnV6HVYud//Rc2ePdvFfhVrLeMwMDCQ\n", + "6/jOnz+fa70iRFHkYv1uirBjxw4X+33Fmsz/rrVvZrv26aUlCgAAIAAPUQAAAAHI/zSQVlc2yz88\n", + "uxOHcQN5+de/Tk4aks5rWvrO1+rQ7DplpfCUpv38yXW1mnldEy5nKfN+3IQUnp7zGTNmJF7TdLKW\n", + "MiqitErTNO/KAwAAaAM8RAEAAASYMOm8rq4uF2eNGsmiE3xqc3RW5WZtcs7blBnaDNzOzftAXjrq\n", + "SfkzIGglZ00L+evVNZKt6dLOc5V0FJpfoV1HI4dUQ8f46WhJjX066Xinfze0RAEAAATgIQoAACAA\n", + "D1EAAAABJkyfqNB+UEqrzmp/iyw6DLTs4Z1nz54tdftob1OnTnVxu1YHNksf3u3PEH/y5EkX62/P\n", + "71uzbNkyF+/bt6+IQ6yFlnRYuXKli/2+ktu3b8+1PT3PftmVIuUt6eL3rQnpA5r1OSgRc29aKkT7\n", + "Fvq/yU7vB6VoiQIAAAjAQxQAAECACZPOK4KWNXj//fdT19OhwVU2EdMcjSwhKTwtDWJWTFq8LP71\n", + "n5Y+HxwcTCxrimfOnDkuvnLlSmI9Tc038TxoqmXt2rUu9qtJa9mVbdu25dp2mfeWvNv203ch5WOm\n", + "TJni4rxV04s2bdq0xHK7ltigpM4HaIkCAAAIwEMUAABAANJ543Dz5s1c62kKRJuqO3HyxSr19PS4\n", + "OO/oSIyfpreamLZavHjxmP/uVyLPe73oRMNZafqm0/Tjnj17XOyPRhwaGqrsmFql6Tf/+9WK2XlH\n", + "JteVwlNLly5NLO/fv7+mI0ERaIkCAAAIwEMUAABAAB6iAAAAAkRp1X9L22EUVbvDGugQ1rqGr+r3\n", + "2oTZ2CeCJp7zkGHgOpTf74dStOnTp7v44x//uIu1T4+Z2fnz58d8f9Y5176JWX275s6de8/9tDOt\n", + "VG/WerV6/29G2rXuV5BnSPwH/D5qfsmNseQ95yjW6HmPosjiOB7zpNMSBQAAEICHKAAAgACk80rQ\n", + "hKH4TUwtdTrO+b2tWLEisXz06NGWthdyzhctWpRY1pIOWu6AGQA+pKlRPx3Yrte6pq3N8qeu9Rpu\n", + "9frNi3RePUjnAQAAlISHKAAAgABULC+BTvhJZW1kWbBgQWJ59erVLt67d6+LO2XUWBHpD39C3fHS\n", + "lB3SacqoiZXrVUgXilmzZiWWR0ZGcr2vu7s7/4Gh49ESBQAAEICHKAAAgAA8RAEAAASgT1SG0Eq/\n", + "VZeNQPsaHh7OXMZHzZ8/P9e/37x508Uh1bL9itu6vVarfjfRwoULE8tDQ0Mtbc8vJVFmX7Qq+54e\n", + "O3Zs3O+ZN2+ei8+dO1fk4RRO+2m+//77idc6pW9mkWiJAgAACMBDFAAAQADSeRlCm+zzTChZBobe\n", + "IkvIxNg6Oa9ZWHO+bmPZsmWp62nqYOnSpYnXfvWrX7n4+PHjY77fH4avaQkdrn/x4sV7HPEH/IrW\n", + "Wqlay09kva/sCZyL1Gr6zqeV4Jso73Xgu3Llyrjf09vb6+ImpvOmTJniYv29+l1adL26/s41TfBD\n", + "VBRFR83skpndNrNbcRw/EUXRXDP7/8xsuZkdNbP/HMfxhQKOEwAAoFFaSefFZvZsHMcfj+P4ibv/\n", + "9i0z+3kcx2vM7D/uLgMAAHSc4AmIoyg6YmYb4zg+J/+218w+E8fxUBRFfWb2chzH67z3MXStJA89\n", + "9JCLd+3a5WImq6xG0RMQ+03pKm+qWZvfdXRZFh3ldvbs2dT1NH28fv36xGuHDh3KtY1WMelz9fJO\n", + "hhs6urnpNE1c1Wjasicg1tSrVn/XiafNzO6//34Xa4X3q1evFno8TVH2BMSxmf17FEVboyj6n+/+\n", + "28I4jkcT60NmtnDstwIAALS3VjqWfzqO49NRFPWa2c/vtkI5cRzHtDoBAIBOFfwQFcfx6bv/fyaK\n", + "oh+Z2RNmNhRFUV8cx4NRFC0yMyoHAgCAtvPCCy/cc52gPlFRFE03s/vjOL4cRVG3mb1kZt82s+fN\n", + "7Fwcx38dRdG3zGx2HMff8t5L61RJPvaxj7l4+/btLqavyIf0HJ08edLFfk5f+w/pb8T/vWj/Aa2K\n", + "rRWKzcw++clPjrkvv5/IG2+8kf0BYH19fS7WKthc59UI7Z8T0j+vCfz+fnrsR44ccfGtW7dKO4as\n", + "cz5nzhwX+5X5b9++XdoxFa2J10eePlGhLVELzexHd7/ISWb2/8Rx/FIURVvN7B+jKPoju1viIHD7\n", + "AAAAjRb0EBXH8REz2zDGv5+3D1qjAAAAOhoVyzvI4cOH6z6ExtGmbjOzJ5980sWaVjt69GhiPa3G\n", + "q5W0/ebyxYsXj7lff/Lan/3sZ/kOuGGeeuqpxPJrr71W05F8iErJ7akJKZq8VftXr17tYr9q/7Zt\n", + "21ysZRz8Cu3Xrl0LPs57WblypYv1M4VWYW+Cdqrur5g7DwAAIAAPUQAAAAFI53WQy5cvj/s9mu7S\n", + "ZuFTp04FHcP06dNdXGZzdl7+6Lf9+/e7WEfT6Eg9M7MLFz6c8rG/v9/F/mgXfxTeKD89mGb27Nmp\n", + "+y2CjuIJGYlbdvquadcLWqMVrUNHhuk1q/ekIq6PvBNv6+/SH7mrxxE640ertOtGu0547dNuE+2E\n", + "ligAAIAAPEQBAAAE4CEKAAAgQK19onp7exPLmq++cuVK1YdjZslceFb/FB3arnl7s+QM9lXy+9eM\n", + "mjFjhov986p9erQStF+lV3P/mnf3h/9q1VntV/X2228n1iu6708aLWlgZrZq1SoXa7+lhx9+OLFe\n", + "d3e3i1ddgqajAAAgAElEQVSsWOHi48ePJ9abP3/+mPv1Z7DX/lfah6GI86DlFHTbWdv3z4vO1v7K\n", + "K6+k7mvdunUu1s/oz2av/WF06Lff7yGkXIFeY6jfsmXLXKzX4qRJyT8vBw4ccLHfz0jpfUz7R2X1\n", + "iXrooYdcvHv37nsc8Qf8/oz629H7pN+vUu+nIf1Qi1ZmPyi9D5olf8tV3cP943jggQdcrH3wzJLX\n", + "1cGDB8s/MKMlCgAAIAgPUQAAAAGCJiBuaYdRFNc1LBQAAGA8siYgpiUKAAAgAA9RAAAAAWoZnacj\n", + "LlCcJUuWuPjEiRMuLuJ86wi1vNW41d/8zd8kll988cUx46ItXLgwsTw0NNTS9rIqjGuauuxrXCvN\n", + "62fcu3dvrvf39PQklkNGGRVRnbpVVZ5z/e51tGXWSLNOkTUiTUd26jXhT8Kt6+koTf83tWjRIhfr\n", + "aLDTp08n1tN96UjRBQsWJNZbs2aNi/W78ids18nFdb/6XZslz4Xyu6no+3TkuZ4H/5jOnj3r4o9/\n", + "/OMu/pd/+ZfEe/gbWo08XY9oiQIAAAjAQxQAAEAAHqIAAAAC1FqxHMV65JFHxv0erbidVaU3pB+U\n", + "+sY3vpFY/spXvpLrfdOnT3dxyCzufh8ora6s/RT86rt+P4i09bRvktI+FVnby8uvDK/9KPbv3z/u\n", + "7fmzBYT0iaqrH1RdtNr9u+++W+ORVC9rBgm9Dm7evOli/X2ZJfvxaNV5v4q93nv09zUwMJBYT/sP\n", + "Ke2/aZa8x2nla7+/S9r17P829HMcOXIkdXvaT0v7W/lVwPXz62dM63uFZqElCgAAIAAPUQAAAAFI\n", + "53WQRx99dNzvSWsSL9uPf/zjXOtpCm/jxo0u3r59e2I9nQQ6KzXlTyA8yh92vHz5chcfO3YsdXsj\n", + "IyNj/nur6TufP5nrjRs3WtqeP7wbH+VPdKwpWk1bTXSantK0lU/TXVqWQycPNjM7f/68izW156f9\n", + "0pw5cyaxrL9fnUDbX08njtf7Sda9QdOc/r1Aj13vs/49V/elv3M9D0XbsGFDYtm/nyI/WqIAAAAC\n", + "8BAFAAAQgHReB9Fm4Xbyx3/8xy7+27/929T1tm7dmvqapvA0DZM37eKnxzQFELK9Iugoo7ypDBTH\n", + "H63lj8zsdJrGuu++9P/eTqvk7o/OS6sw/sADDyTW01Fpmn6fN29eYj39Xeq+7ty5k1hv8+bNLtZ0\n", + "mX+/9I93lD/qTo9Jj10ro5uZvfHGG2Nuz6f71c+k5yiLfjf+Z89L9+WPzC5S0TNIFOHTn/60i0Pu\n", + "s7REAQAABOAhCgAAIAAPUQAAAAHoE9VB/FnTi6T9I1odXu/77ne/6+LvfOc7ide0X8qf/dmf5dqe\n", + "9lvyyz6888474z6+kH5QoRXLtbqy5udPnjw57mMogpaVMDPbu3evi7OqWCsdEt7T05N4befOnbm2\n", + "of1pqqqU7u+nzL4iTZT3d679eBYsWOBiv9yB/ga0f5lfakD7Kmk/KL/Mh1YzP336dOrxaRXwTZs2\n", + "ubi/vz+xnv729Nj9PlE6W0BIH6Yseq/xS2yk0X5Qs2bNSrym17D+XusqaVBlH6i8f7NeffXVlvZD\n", + "SxQAAEAAHqIAAAACkM7rIGlppyJSIUWn8JSmSb75zW+mrrdkyRIX501vhaTvipA3fec3v2tKIOsz\n", + "asojbWh2Ed56663Ect4h1EuXLnWxVp3Pqv6epQmTHYcOH59I+vr6XOxPBKzfoZYk8WcY0N+O/h78\n", + "iuC6rPe+RYsWJdbTdF7eibs1lbZ48eLEazpMX++Lp06dSqyn6SRNc/r3hrRZDzR1ntcXvvCFxLKW\n", + "P/jhD3847u3ltXbt2sSyfqf+eSmTTlj/yCOPuPjXf/3XE+v95V/+ZWH7pCUKAAAgAA9RAAAAAUjn\n", + "dRBtqlbajO6PcKmqErY/ciVkpFNdI9SKoOkBrcjsp0nzfsYyU3gqNIV14sSJXOvNnTvXxVEUufjc\n", + "uXNB+y1T2uTV+JDea/yK4JrS0u93cHAwdRtaEdy/Z+iIPL2P+SNjNcWj6S3/+HSUoKYHe3t7E+vp\n", + "iEG9r128eDGxnr6m17lPR1WHprtHbdmyJbGsKa0y7du3r5L93It2HXj99dddXOb9hJYoAACAADxE\n", + "AQAABOAhCgAAIAB9ojrI6tWr77lOEX2gNmzY4OK8lW8nWrVnrX5slszJnz9/vuXtVzXretG0f4pZ\n", + "sv+L36cE7UEr0mvfP/83kFa53v/etT+dVhXXPlVmZkePHnWx9oXJGlKvZVL8a9GvnD5K+0CZJT+j\n", + "9r/SCupmyf6n+hv1j0/7ArbK71PVah+rdqPfjfZrO3jwYGn7pCUKAAAgAA9RAAAAAUjndZCsYbRF\n", + "0hSeDtc3yz8pbV00jaDDnUNTSX5KYNTZs2eDtpdXO6XwlKZd0Bk0HaVpZv9eoBW4NTXnVzbXa0Qn\n", + "KvZLEoRM+KvVwjUdmMW/ZrUkgX52//PqxMV63/FL0aTde9LuLUgXMll8q2iJAgAACMBDFAAAQADS\n", + "eR0kbSJLTbllpdu0mfrSpUu59ll2+q7oiXZ1YkxN54XSyZ2LUNWoO39SVU2bkHLDeOiIX01b+akV\n", + "HSGl6W6/G4Leh/S6PHDgQGK94eHhcR/r0NBQrvX0d+2/R1/T0WD+qFsdkaufUd9jln4fIp3XHmiJ\n", + "AgAACMBDFAAAQAAeogAAAALQJ6qDpM1UnbffUt5+UFUqosJ6mjt37rjYHz6dt/+V9rFSfnXlvP03\n", + "tKKyVjYuup9SVlVnYDz0N6p9mHp7e1Pfo1XJ/SH/Wum7q6srdb0yaT9S/7enpRq0/5beT8ySfcIO\n", + "HTrkYv18Wfsq4vNqv6pO7Ouo59+snr9htEQBAAAE4CEKAAAgAOm8DuI3E7cjvwpxVZW5iyifoEKG\n", + "X5slh353YvM7Oo+m8zRN3N3dnVhPh/brsH6/hIBW+tY0u39vKDO9p2lEjc2S96SsmQ708+p58T+H\n", + "TtSs93AtFxHqueeec/Ebb7zh4tD7U9P45TFI5wEAALQJHqIAAAACtH/+B07RKak6ZKXvQiqqtxsd\n", + "3dQEOsGqWTLVApgl03k6EtgfrabpKU116aTAZsmK4Jp2qjK9rfv1ZyXQVKSOzvUrkff397tYz8WZ\n", + "M2cS6+nn199XERXLf/rTn7a8jTw0JWmWvG/4n7dIeSeRLhMtUQAAAAF4iAIAAAjAQxQAAEAA+kSh\n", + "bRTRD0qHF5dZPsGfmV2Xy6zCXjS/n8eNGzfGvQ397JMnT255e2gWLVGgfYn6+voS62m5Ah3K7/8O\n", + "/X54o/xrMW8f0Dlz5rh4ZGQk13uUX0pBj+P8+fOp79N+QkuXLnWxX+JAfwNaFsJfr8m0NMtEQ0sU\n", + "AABAAB6iAAAAApDO6yD+JLrjpUOQ0ybWbXfadL5x40YXb926tdD9+MO7/eUm0zTM4OBgy9vTz076\n", + "rvPcvn3bxfr9Hj9+PLGeprT0XqUT9ZolyyRomijvjAz+pLSaFtOJwf10oC5ryj20G4GmDlesWOFi\n", + "v3SBlgDwz0Wn8UshaPry2LFjVR9OIWiJAgAACMBDFAAAQADSeW3Mr6TrN5WOV6em8JRWBNYUno7g\n", + "MQsbxZNXlZXXQ1K0mk4B7iVttOnAwEBiWUey6XXpT/CrFbxDRn3529NlTS2njQI0S/4GQqv066hF\n", + "raw9b968xHp6/rQqu6Ye25mmcf2RmO2awlO0RAEAAATgIQoAACAAD1EAAAAB6BPVxnRosVl29Vxk\n", + "K7MPlK/sflAqpH8TfaIwHv59aJRfzkKXtQr4jBkzEutphXsta5C30r/2qfK3oXFvb29ivX379rk4\n", + "tB9UGu0f5pd+SLsf5P0dzp4928UXLlwIOLriaT80/Rxl32e1v9m5c+dK3dcoWqIAAAAC8BAFAAAQ\n", + "gHReB8k7ISeKo03pTVR0WgLwhdx3NOWWN8XjVyzX9J5OCuxXBNfXNPXob6/o+6cen6bZ8v4mtdxB\n", + "lqak8JSWj6iyq0RVKTxFSxQAAEAAHqIAAAACkM7rIH4F83akTe9mnT8h50TjV5PWSaC1KX7v3r2V\n", + "HVPT+NXzNa0zkSdw9q8dndRXz4uf0tF7iG7Dr1iu956iU3shafUmpuny8iuTdzJaogAAAALwEAUA\n", + "ABCAhygAAIAA9InqIJ3QX6Ld+kC1c7+FOnR3dyeWDx065OLBwcGqD6eR/KH3Tf9d5x2Kn5f2TdL7\n", + "gV/ZXM+TVsXOOp7Jkye7WKummyVLIzShXIxWbkd5tF9myN8fviUAAIAAPEQBAAAEIJ3Xxvwhuv4Q\n", + "YBRj2bJlLj579mzitaJTGc8884yLd+3a5eKyK/FqakRTbhcvXix0P0ySfW9nzpyp+xBqlZZS8Sfk\n", + "1arnmvryS0TopLR6nWdV0tZyMWkTLJetnbo26Dk2Sx775cuXqz6ccdm6dWtL76clCgAAIAAPUQAA\n", + "AAFI57Uxvwru8ePHazqSzqbn9fd+7/cSr506darQfW3atKnQ7eWlk6VOnTrVxUWn84BQ/mg6XdaR\n", + "dZp+NzPr7+938bRp01zsj6w9efLkmPu9dOlSYlnTe3fu3LnXYQfTdGUonSBd06H6ey+C391gyZIl\n", + "Lv7Upz7l4pdeeqnQ/TYBLVEAAAABeIgCAAAIwEMUAABAAPpEdRC/ou+oJgzXzWvmzJmJZb8/Qqt0\n", + "KK729+nr60usd/r0aRfrOfvBD36QWG/+/PmFHl8T1FWtWb/7rO99wYIFVRwO2oiWGvGH1OvvXKu/\n", + "L1y4MLGeli/RPj5+5fAi+iq1Sss4ZJVqqGtGBe1fltbXrFPQEgUAABCAhygAAIAApPM6iA7lVYsX\n", + "L3axpqnM8g911Yk7y2zOLjp950ur/B3a5OxXMM9D0wNFD5Hu6elJLF+/ft3Feb+3sr+DVver1zOq\n", + "0U6T4Q4MDCSW9d6ln8OvgK4lEzQ92MQuEFkpPIyPztDgl9HIo31+GQAAAA3CQxQAAEAA0nkdRJsl\n", + "1YkTJ8a9rVmzZiWWy6xcvWbNGhfv37+/tP00RdEpPK1KXPRoHE2FmDVjZFJdI44mMj9N3E6OHj1a\n", + "9yE0gt4ndJSiWX0jcpsgJIWnaIkCAAAIwEMUAABAAB6iAAAAAtAnqkKTJiVPt5YX0Grjfn46bYjt\n", + "hg0bEstFDv0usw+Ur8x+UH7Zh8HBQRfXNXRZZzjPW1ohq29SmX2EmtAHykefqOo1cZg/xoffTTlo\n", + "iQIAAAjAQxQAAECAWtJ5n/3sZ83M7Omnn078e29vr4s1nbRo0aLEelEUuViHi8dxnFhPJ97V9fxU\n", + "Vdq+jhw5klhPq8ROnz7dxf6kuX4l3FE6+a1/THPnznXx1KlTx3y/WTKt4084/Nxzz6W+ryw6bNYs\n", + "+Tn0WJctW5ZYTycJ3bp1q4unTZuWWE/LH2zbti31OPQ70NSDX7147dq1LtZ06qFDh1K3XYTnn3/e\n", + "xZrOO3z4cGK97du3u1greBedVlu3bl1iWUtavP7666nve+qpp1z82muvjXu//kTPeo1oevrdd99N\n", + "rKfD1OuqqD6RaeV71O+Tn/yki/U3tHnz5joOx774xS8mlleuXOniv/u7v0t932/91m+5WP/e6n2w\n", + "bPq3yf97kQctUQAAAAF4iAIAAAgQ+Smw0ncYRXHV+wQAAAgRRZHFcRyN9RotUQAAAAF4iAIAAAjA\n", + "QxQAAECAWkocaIkClEP7nWlpBb/y9fDw8JjvyUuHxpuZzZkzx8XLly938YkTJxLr+UP7R/llG3T7\n", + "Otu2X1ZCl/VzaFkKM7NTp06NuV+fllrQbfvD67WMhpZtaPo13tXVlbqsn8m/JvTza4mOUFoqRIfR\n", + "+/tNuzb135t+zptCz1PWbz5tPf89nPfy+edc7+nnz5+v+nAmjDx/E2mJAgAACMBDFAAAQAAmIJ4A\n", + "NFXjVwRvtdyE//758+e7WFM1aek7n1/tPa36+40bNxLLU6ZMcbE2b4c2desk0P6E0Kqnpydo+3Xz\n", + "z5+/XJVr166Vtm2tRKzfkz9jQd5JoNP4VfvzTvT6mc98xsVvvfWWizUtbBY2YXUWTenfvHnTxfob\n", + "8l9Ds/jdMlAfWqIAAAAC8BAFAAAQoJZ03qpVq8zM7Pjx44l/b3WSVR0ZZpacyPf06dMtbbud6YS8\n", + "fpN9q3QSX7PqJof1U2yattNRfGXzUy9oDr2/6HXvj+xsVd70nU7ObWb2yiuv5HpfWgrv0UcfTSy/\n", + "8847ubaXlqYjfdc+ND2t96Ay0+MYGy1RAAAAAXiIAgAACFBLOm/SpA92qwXDzMwGBwfHva1169a5\n", + "+MEHH0y8pim8iZzO0yZeP/3WKj81MjQ05OJDhw4Vui+1cePGxPLKlStdrGmNvXv3lnYMaB9aQPTc\n", + "uXO53qOj+8ySKcGDBw+O+xiyRoqOdnEwy/+7qTJtjWbRa1FTe6TzqkdLFAAAQAAeogAAAALwEAUA\n", + "ABCglj5Ro0Pu/Uq/2p8mbyVt7fPiDzUO6WPVznp7e8f8dy1xUPRklf73pH2udL9F0z5QZmZr1qxx\n", + "cd6h3loCQye/HQ//Gh6lfXDMyj0XuLesqvNpdHJus/R7kv9daz/NXbt25dpXSP/BvO/xS7/4k3Kj\n", + "/ehsEHpvue++ZLvIRO4LXBVaogAAAALwEAUAABCglnTeaFOkPzx+/fr1LtYmypdffjmxXlpzdDun\n", + "TLq7u13sV27PW0n4zJkzY/57FEXhB3YPmoIte1/9/f0u7uvrS7ymw9bzljUo4ljTtuGXYNi9e7eL\n", + "i6hyrhOQtlrpH2PLm+Jdvnx5YrnM30BeK1ascLFOYGxmtnnz5nFvT9NHqJ+mkPVe4H9P2t0gb2V9\n", + "jA8tUQAAAAF4iAIAAAhQSzpvtKrqnTt3Ev8+f/58Fy9atMjFGzZsSKynE3fqNvwRW6OV0c2aMUpB\n", + "P5NZsmL7rFmzXHzlypXEepqmO3Xq1Lj3q+kebfr1XytC3lGVeemkrZ/+9Kdd7I+I8lO+eYSM2PKl\n", + "pXx05F8ZSOGVQ1PG/ujetO4Chw8fLvWY0vhpxGPHjrlY0+xHjx4N2r5WxaYSdrPotagjoi9evJhY\n", + "z/9bguLREgUAABCAhygAAIAAPEQBAAAEqKVP1PHjx83so0P3d+7c6eIZM2a4uKurK7Ge35dq1Ouv\n", + "v17UIRZG+yAtXrw48ZoOOdVctt9X5+zZsy0dgw579auaa9+iffv2tbSfLNo/zSyZx8+ybNkyF2s1\n", + "3jfffDOxXt7K0Gn8Pkzat0v7H/nXXlq/Kr+adBFlDVA+7Zs4MDDQ8vYee+wxF2/btq3l7SntA+Ur\n", + "or+flkYYvWejGfT+pPdFv8+r9mvLe8/F+NASBQAAEICHKAAAgAC1pPPyVODWoZntPExTU0FFN+fn\n", + "pcPw/QmI/QkryxLalKwpCx2q7ZdSSCutMG3atMRyWpojdALiNCdPnix0eyjOE088kVg+ceKEi7Wy\n", + "fKg//MM/dHHeSdC/853vuPib3/xmy8eQl6Z7/JT22rVrXVxEahPF0Vk7tKuA322g6PsaPoqWKAAA\n", + "gAA8RAEAAASIiq4wfc8dRlG1O5yg9HttwoSoRfM/k47+q6uad6ef8yYKOef+JK2a4q3yfvhHf/RH\n", + "Ln744Ydd/I1vfCPX+3WSYbPwyuTj5Z8jrvXy+ed84cKFLh4eHq76cCaM0fMeRZHFcTzmhU5LFAAA\n", + "QAAeogAAAALwEAUAABCAPlEdqmn9c3p6ehLLOrT63Llz496eVlo3S37GuirzNu2cTwRNOOd+H6tr\n", + "166NuZ5e82b5Sr00EX2iquefc62sf+nSpaoPZ8KgTxQAAEBJeIgCAAAIUEvF8lbNmzfPxTqJ7+3b\n", + "t+s4HKR46qmnXLxgwYLEazqs/MUXXxz3tvmu0RR++k5nAdAJq/2UdkgaGzCrthQHstESBQAAEICH\n", + "KAAAgABtmc7rxGZwrT585syZxGtXr17NtY3u7u4iD6llmnLr7+9PvKZpjtWrV7v44MGDLe83LZ2C\n", + "iaWrq8vFN27cSF1PU81FVH9Ou+Y68b6FepDOaw5aogAAAALwEAUAABCAhygAAIAAVCxvoOXLlyeW\n", + "tTr32bNnXexXqp08ebKLtRpyEyoKa78nM7NPfOITY663bdu2xPKhQ4dKO6YQ2s/GLHmetS9ME875\n", + "RJBVsby3t9fFfj9DhKNiefX8cz5t2jQXX79+verDmTCoWA4AAFASHqIAAAAC1FLiYPHixWZmdurU\n", + "qTp233jHjh0Let+tW7cKPpLiHD9+PLH8yCOPuFgncJ0zZ05iPW221irndckaKo9mKbq8BaUz0BSU\n", + "OGgOWqIAAAAC8BAFAAAQoJZ0no5owsSgKTszs0mTPrz0hoaGXOyPxmtCCg/t6cqVK4Vur9NTeKPd\n", + "LEbR3aK56FbQHJktUVEUfS+KoqEoit6Vf5sbRdHPoyjaH0XRS1EUzZbX/jyKogNRFO2Nouh/KPPA\n", + "AQAA6nSvdN4/mNkXvH/7lpn9PI7jNWb2H3eXLYqih8zst83sobvv+a9RFJEuBAAAHSnzISeO4/9u\n", + "ZiPeP/+mmX3/bvx9M/vK3fjLZvbDOI5vxXF81MwOmtkTxR0qAABAc4T0iVoYx/FoJ5YhM1t4N15s\n", + "ZltkvZNm1j/WBm7fvh2wW7SzCxcuJJZPnDjh4pGRkTFjoBXab0Sr/vtlNHQWgE4xa9YsF1+8eDHX\n", + "e+gDBYxfS+m2+INiFVkFKyhmAQAAOlJIS9RQFEV9cRwPRlG0yMyG7/77gJktlfWW3P23j2DEFQAA\n", + "aLIXXnjhnuvccwLiKIpWmNm/xnH8yN3l/8vMzsVx/NdRFH3LzGbHcfytux3L/5t90A+q38z+3cxW\n", + "x94OoiiK58+fb2ad2YzeFFkTszbBmjVrXDx16lQX79mzJ7Fek6uw+5p+zjtR3nOur1HtuTVNmYBY\n", + "U7R6DO+//34dh1OqppzziSbPBMSZLVFRFP3QzD5jZvOjKDphZv+Hmf2fZvaPURT9kZkdNbP/fHdn\n", + "u6Mo+kcz221m75vZf/EfoAAAADpF5kNUHMdfT3np+ZT1/8rM/qrVgwIAAGi6WiqWV5XG0yrZ2vx5\n", + "9erVSvaPdJrC6+npcfGDDz6YWO/w4cMuvn79evkHdlfTJj7GvS1fvjyxrBN50yjeebSC/MyZM12c\n", + "dzQiUASKYQIAAATgIQoAACAAD1EAAAAB7lnioPAdRhGdE8YwadKkMWOz9L5Aq1atSiyPlo4wM9uy\n", + "5cPi8U0cDqt9GPr6+lys/djMkpXOr1y5Mua/m7U+rHnp0qWJZT2Offv25doGJQ6qxzlvjV7n165d\n", + "y/UehttXzz/n9913X+prKE6eEge0RAEAAATgIQoAACBALem80XRVXZVl/ZSRVr69fPlyZcexaNEi\n", + "F/f3fzhXc3d3d2K9/fv3u3hwcNDF/nenZQN0WH7Tm9vnzZvn4t7e3sRrXV1dLtZJi8+fP9/yfjX9\n", + "qcOlQ7dPaql6nPPq+fcd/c0yC0VxpkyZ4mKdTNuMa70qpPMAAABKwkMUAABAgFrSeU8//bSZmZ06\n", + "dSrxmo4O0aqzN2/eTKynaavZs2e7eGBgoNBjbWftlObQ0Yh+ijdk4lhN186ZMyfxml47IyMjLi4i\n", + "PdhO57xT6DnXKvNm1Va4n0j836HOMnDw4MGqD2dCYERkPUjnAQAAlISHKAAAgAA8RAEAAASYdO9V\n", + "ijdaoVqH+Jsl+8a8/fbbLt67d29ivatXr44Zoz1l5fe1L4D2f/Mrlk+ePNnFWVWY6TfXuZYvX55Y\n", + "zltpfsaMGS7WqvjIx+/bCkwktEQBAAAE4CEKAAAgQC3pvMOHD5tZMmVnxkSKE8nDDz/s4tu3b7t4\n", + "aGgosZ5OtKkVxvU9ZsnSCFRNnphCU/vtmsLTWQ7M6ktV5524GOhEtEQBAAAE4CEKAAAgQC0Vyyvd\n", + "4QSVt3q2Tr7sp8jKNGvWLBdrdfosS5cudfG5c+cSrzUhpUDF8upN5HOuowrNqktLUj27epzzelCx\n", + "HAAAoCQ8RAEAAATgIQoAACBALSUOUJ/RavGj5s2b52ItDeCXGiha3n5Q6vz58y5uQh8oM7Np06bV\n", + "fQhoGP1NPfjggy7esmVLy9vW661dSzMAnYSWKAAAgAA8RAEAAASoJZ032iT93nvvBb1fJ5u9detW\n", + "rvfoUH6tgu2bOXOmi/0h//o+3Z4//FRTVXmPL685c+a4WNMGYx3HKJ3oWSuFm5n19vaO+f6RkZHE\n", + "epreO3HihIv9UgNl0nNetqlTp7rYH0quFixYUMXhoI3obyIk5eYPX9ffZeg9M4TeX6r8nQPthJYo\n", + "AACAADxEAQAABKilYjkTDQMAgHZAxXIAAICC8RAFAAAQgIcoAACAALWUOBjvDNTTp09PLLdardrf\n", + "3q/92q+5uLu728UDAwOJ9U6dOuXikKHGTz/9dGJZSyYcP37cxQsXLkyst23bNhe///77Lp47d25i\n", + "vfnz57t43759LmbG72poXz/OeTWKOOc6lF9/10VXxQ+9j3V1dbl4ypQpLr58+XKu9+t7zMxu3rzp\n", + "4uXLl7vYr76/d+/eMbfn92nlWi+ff85nzZrl4kuXLuXahpbvyfsen15Leh11Cv83kOc3SksUAABA\n", + "AB6iAAAAArTFBMRFN6v729N0WV6rV6928cGDB3O9Z/PmzePej1myQrum83RCXrPmTMqLZArGzOzG\n", + "jRs1HcnEodX8zT5adT+NThKsv6+tW7cWc2B3hf4+tVK/dj3wf/96H9K0RFbXg+vXr7vYP39atX/S\n", + "pLb4UzFhaLeTvKm50BSemj17touHh4db3l7ThHTToSUKAAAgAA9RAAAAAWijDZQ3hRfi6NGjQe/T\n", + "pvk0fppJm/AHBwfHvU9Na5qZnT592sVXr151saYGzPIdaztbtWpVYlnTIfr9FtHEjg/4k2tryuPY\n", + "sWMu9kedbdmyxcU6IXfZnnzySRcfOHDAxf5kv5qa09f80cMqb1pCJxbX2Mxs48aNLq5y8m/cm38f\n", + "r8rnP/95F//gBz+obL8h3WdC6Ij53O8p4TgAAAA6Hg9RAAAAAXiIAgAACECfKI9WC/crh7/zzjst\n", + "bebKW4cAACAASURBVHvFihWJ5dC+T+Ol/ZH8Ph8nTpwY9/Y0P+0Ps9Z+UCpvHyj/HOn2m9h/SIf8\n", + "Kr8PmPZrWbx4sYu1fIVZcoi9VqS+c+dOS8c5Efh9ndatW+fir33tay7+yU9+klhPf9dnzpwp6eg+\n", + "SvsZZX2/Wq360KFDLe+3v7/fxVn9qvTewPXXLHV9H3WVutD+jmX2iQo5r7REAQAABOAhCgAAIEBH\n", + "pfNmzJiRWL5165aL81aMzhryqxM4pg07NkumZFRV6Tvfo48+6mKdmHg8dJJWrVRbdIot9BwtW7bM\n", + "xVpmwU+XaZrNT0XmoRN/mplduHBhzPX8/eq1o5N4+s3jWtVar1+q0d/b2bNnE8s6Q8CSJUtc3JTU\n", + "1KuvvpprPb2v6fWW9Tk0lemnlvW1N99808V+qtC//6E59N5Qpaz0b5H0GjX76N/Ysvi/lTxoiQIA\n", + "AAjAQxQAAECAjkrnXblypdTta+qqiSPF0mjaStNyZslzptVa/clImzbZ5Pr16xPLO3fuHHM9v9lb\n", + "02KacvMr1aalfzUVZ2YWRdGY6508eTKxrBWkdaSinw7U46iryb5KOkLt9u3bpe1Hq5KHNNn79Hsq\n", + "Oz2oI17z7kt/8/551deOHz/e4tGhDlqNP++1qPcqHfE5HocPHw5633g98sgjieW33nqrkv2GzKRB\n", + "SxQAAEAAHqIAAAAC8BAFAAAQoKP6RPn9eEZGRnK9T4c/+31Zmsyvlq3D/JUO+fcriq9du3bM9xQ9\n", + "pN7/bubOnevivFWYp0+f7uK0PlDjoX2O/L5OWnpAS1bkrWjtDwWuamhwuymzH5TKKp3x2GOPufjt\n", + "t992cVb/Er0Wy+6LGTK8O6sPY1XDxVEe7dOUt59caD8oVWa1cOWXK9I+pU1DSxQAAEAAHqIAAAAC\n", + "NCqdp014mnbK2wypKSKz/Om8VlN4Wr3crLqmR394fFr17LRJgc3CK5iPl/9d5P1uVN4Uo6Yo/f2k\n", + "pTlu3rw57uNBZ9B0ct7USNkpvDr4ZT70XGgpCtRv0aJFLtb0bNrfgHaX9TesbrREAQAABOAhCgAA\n", + "IECj0nnaRK6Vtf00Tlq6LO8or6IVkb5LGw2G8dMRdEzci3tpegqkq6vLxXknUg+RlcqsahQl8tHR\n", + "zk1Ptfb19bl4cHAw13v89N3FixcLPaYi0RIFAAAQgIcoAACAADxEAQAABGhUnyilwza1f5RZuSUE\n", + "tEyCznZeNvpBFafK702r3QNlyHtv6O/vd7EOgd+6dWvhx4R66d/EpvdXu379+rjf0/TPpGiJAgAA\n", + "CMBDFAAAQIDGpvNUlRNmVpkKqoqmKC9fvpx4TSfhDTFz5szE8qVLl1raXlNo9ebe3l4XDw0NJdZL\n", + "G16s7zHLP3GxouxFcVasWOHiEydOJF5reupAj09Tdv6k1lp1n9IenW3hwoUubnqJjpDja6cJ22mJ\n", + "AgAACMBDFAAAQIC2SOehNXlTlDqix0/zaXqgp6fHxX56sEyaIstKjy1YsMDFaRMO34umQP0Unjp2\n", + "7NiY/66TIJuZdXd3u/jo0aOp29MUXhRF9zrMtuOnP7Ua9+TJk12s58Gs9ZT+8ePHXZx3kuEm0kna\n", + "ffqbCEkfo33EcVz3IZSKdB4AAECH4yEKAAAgAA9RAAAAATqqT9T06dMTy9oPhT4C93b69Olc6xUx\n", + "fNqvQj/K7/ui32ne7zC0H5Q6e/ZsrvXS+i1p/zKzZF+grDIQ2kdIZy5vtRRFU/jlBHT2Ae0TpbPU\n", + "++uFXH9N7Ael/b40zqrwvH///lKPCe0h7/WsMyqcPHmyrMMpnP/3wS9L0iS0RAEAAATgIQoAACBA\n", + "o9J5GzdudHHIpJl+M3/eiQ+1OrWmEcqulK7DlTVdc+PGjdL2OWvWrMSypozKpGkqs2Rzrabs/Gbc\n", + "MtMXs2fPdvHUqVMTrw0ODubaRtpQY922WbLiuFZ5969ZXa8TSxz49PxpisL/7er10ynVuL/61a+6\n", + "WEtlvPnmm4n19Lx0+tB25JO3tExV9/eJjJYoAACAADxEAQAABGhUOi8khZdlypQpLs5K7WlzeZWT\n", + "HV+5cqWS/SxevNjFp06dqmSfZsl0pf9ZW03T+ek3TZHlHZ1X5sSdfipOr0VNX2oq2SyZytWRbFev\n", + "Xi36EBtHU1U6ma5ZZ4xOXLNmTWJ59+7dLt65c+e4t+dXdS9zkuqJkFpuJ363jDRVzihRpHb6vdMS\n", + "BQAAEICHKAAAgAA8RAEAAARoVJ+ovLQadFaV7bwlDjpdlf2gVNF9vrQvkVa3NiumSnmRsvo6aX+f\n", + "rFIIev3629P1yuzbVSUtXeD3eWunPhJp/N9hq78PnZHBrNzh7JRWaJaBgYG6DyGT3q9CZgvo6ekp\n", + "8nBKRUsUAABAAB6iAAAAArRlOi/vRLkTjT8BcxV0Yl2zj04w2+r2Vq9e7WJN477yyist7edeent7\n", + "XZw18bE/zHyU34StQ8T1e/K/M01TapP4ggULEutpqm/79u0uLnOYe9k0ZeRfR+38uUYVnd72J2lO\n", + "S+cV/RtF/ZpecqLVCb/9CdybjJYoAACAADxEAQAABGjLdF5eaSMEOrV5u46JWf00U95Uq040rFXi\n", + "/e9CK3UfPXrUxUWPFtKK4mbZKTyVlmby03RaUV0ruU+bNi2x3nvvvedi/T79tKGm8/S1Jqa99Lv2\n", + "R9mlVXL3z59+350yGjGEnq++vr7Ea/r7UHXd37KubbTmgQceqPsQSjU0NFT3IeRGSxQAAEAAHqIA\n", + "AAAC8BAFAAAQoKP7RKUNsyy6j4A/3LRdq/tqX7Gurq7Ea2n9c0LLTWg/qCwnT54M2v54aRXxIvgV\n", + "t7V/nvZryarMrdevf83qa7q9Jlbp19+H/5vUPlxZ/RbbtWK5lqwo4jPodToyMtLy9spEH6jyzJ07\n", + "t+5DKNWePXvqPoTcaIkCAAAIwEMUAABAgLZM5+kQ8aKrAIdo1/SdT1NGWeUSQobR+9WV01IR/sTC\n", + "daVxdPi4ft758+cn1ks7F/39/YllnYBY06H672bJ86IpT3/Iv6a+ml69OK1sg1l6JfdLly4l1tNS\n", + "F+2k6JITev01fRJalKedSgAov5RMWjeKpqeqFS1RAAAAAXiIAgAACNCW6bwmpPCawE+R+amhJsnb\n", + "PFtl+q67u9vFfrpocHBwzPecPXs2seyPrhs1a9as1PU0/eunrQ4fPuziy5cvu1gnRDZLpr78JvIm\n", + "81OPOgovbYaBdqbf9VNPPZV4Tb+3l19+Odf2dIaA3bt3t3ZwbaZTZ5oIsXnz5roPIUiV35nOEuHf\n", + "Z4tESxQAAEAAHqIAAAAC8BAFAAAQoC37RIXQvhh1lSTQ0gxmZqtWrXLxokWLXOwf369+9SsXa27X\n", + "7yfjL3eCMstZFJGfT6sQfv78+dT1tP+Vn6vXfm3aZ0bLIvjba3ofwazyBNr3qarq9HV57bXXEsvT\n", + "pk0b9zaaWOpB+//p8fnlSlqtYO7fPy9evNjS9trZzp076z6EIFX2idLfF32iAAAAGoaHKAAAgABR\n", + "1amtKIpy7TArjaOTL2rz4ERu3vXp99r0itYh/NICTZh4V8/5N77xjcRrWrrg9ddfd7HfvH3mzBkX\n", + "azrPn3BUK3/r76NTSgPk1enXeRGyykr09PS42E95pKVe/L8ZWioka6aDvHS2AD2mIrbdrvxzzrV+\n", + "b9oFInTmgNHzHkWRxXE85kmnJQoAACAAD1EAAAABGjs6L2vEkT/yCR9YuHBh5fv0qwjPmzfPxcPD\n", + "w7m2sXbtWhfv27cvdT0dfaiVm83Mdu3alWtfVdm7d29i+cCBAy5Oq4bu08k5L1y4kHhNR/F1ygTY\n", + "KId/fWhqo4iJXotOs+X9fTSdjk7U1JI/alFT8LNnz3ZxHffzpvAnevdnisij6Mm/09ASBQAAEICH\n", + "KAAAgAA8RAEAAARobImDdtLV1ZVY1v4qVdJZq7XcA8Nhq6G/pQcffDDx2sGDB6s+nAmhiSUO9H6g\n", + "xxRahkPLEFy+fDn8wArCcPt8tO+Txv7fCz1/WtpHS0z41fybcM6131JIn6UsGzduTCxv3bq10O3n\n", + "RYkDAACAkvAQBQAAEKCxJQ7aSV3pO1+ZkyzWRSuTN6EqeV7Tp09PLGvFcS3RoSlYs2TqRq8rvxK5\n", + "DpnW9IpWPPfNmTPHxX4JkVu3bqW+L41+Rh2abZZMX+i2s86LVmi/777kf9/pOcs7+WraOS+bfm9P\n", + "Pvmki7ds2ZLr/Z/4xCcSy365jIlES6j4v4GmlfbQSutmyXScTszsTyKtv2VN0+nvwZf2+6pSmedf\n", + "y7s0HS1RAAAAAXiIAgAACEA6D43ip3FCUniaAkibRPVedFJVv/k9j6VLlyaWp02b5mIdOblo0aLE\n", + "epruyvrs2uyv58xP6WqTu6YA/PU03ZWVntb047Jly1zspxS0WrCmK/x0nqYB9Rz5o480NZe3QnYT\n", + "ZjbIO5pOz9GSJUsSr7311luFHlNV/HRU2khKfz0doabXtn+NZaWu6+CnoPJef/o+/c3rPcinr/mz\n", + "GZRJ760PPPCAi8+dO5f6Hr1n+Oco7R6Xlcosgm6/1dQhLVEAAAABeIgCAAAIwEMUAABAgFoqljdt\n", + "aCoAAMBYqFgOAABQMB6iAAAAAtRS4mB02GqVaT0dZrlhw4bEa5s2bXJxb2+vi0OH0OowUN3Xtm3b\n", + "ch2fP/w8b+XldevWuXjPnj0u1krVK1euTH3/gQMHXBw60akO2df46NGjifXyDv999tlnXbxr1y4X\n", + "+9+NDlldsWJF6nojIyO59qvD7d97773U9XSIvm67rglCFyxYkFjW72DHjh2p79NJUUMq8PvD8v0J\n", + "U/NYu3ati/ft25e63jPPPOPiV155xcVNmJR1IvDv27NmzXKxlrDwy4to2Y+sYeV5K9Lnpb+BefPm\n", + "ufjIkSOJ9UJKmej2/Kr9eg8dHh4e97ZV1qTPaRMYmyX/Fuk2/HIRev/U2Qy0VEkWf+YFrd6u14R/\n", + "HvRvnT+LQh5+SRy/qn2r8jyj0BIFAAAQgIcoAACAALWk8+oYnffQQw+5WNNWviKq4H7xi190sVYi\n", + "zkrnZU0enLci7ac+9akx/z1rYldtXg1N4anTp0+PGYd6+eWXc62n6YH9+/e3vN+sFJ6qslpwHn46\n", + "T1ObWem8kBSepnFOnTo17vf7slJ4anBwsOV9oTh6zWn6x0+dDw0NuVir9petv7/fxTqheRETx+vn\n", + "8NPJVU2Yrn9PQ+/heWcBSOP//cr6e1akotN3IWiJAgAACMBDFAAAQIC2nIBYe/vnbYbUptW8qRpf\n", + "2qSFy5cvT6ynzbo//vGPg/al8jZZ/sM//IOLv/e977lYm7DPnj2beE+ro0ZQDR0taJZ+DfujHlev\n", + "Xl3aMVWZklFFpGtxb5qu1cmrfToyU6/TgYGBxHp6bYaMxMrLT2nr/U8/RxHdSjR96Y9Q078DZX5e\n", + "1IuWKAAAgAA8RAEAAATgIQoAACBAW/aJChmO2d3d7eK8w9K1PIFZsh9UT0+Pi//0T/80sd6f/Mmf\n", + "5Nr+U0895eLXXnst13ta5feJqmoY7kTj9yHxKwSPdxt+9ec0/jW7d+/ece8X1dPK0nm/67JpXyLt\n", + "D+rTe6Gu5/cRqqoPnV8N/dixYy7WvklFn2e/YnlaH1q/zEzeWRTQTLREAQAABOAhCgAAIECj0nlF\n", + "N2nrxL3+BKl5ZE2++KUvfcnFv/jFL8a9bbPiU3h+M/Eo/RxNqPDaFGWmUELSd6Hb0LSBXvNmZtu3\n", + "b2/5ONT69etdHDJRbOiEoZoa0glly6RD/M2SE3n7E2q3qikpPKUVxv0yLkqrU+sEuH4ZjlarYufl\n", + "d9eoalYBv7yIfqdaSZx7cGehJQoAACAAD1EAAAABoqonA46iqLId6uiSrFFo8+fPd7E/eq1d6ffa\n", + "1dXlYn/0VlVN7BOBnnN/MtIyaarLn1S11UlWn3nmmcTypk2bWtpeXppqNUueT/28586dG3OdMuj2\n", + "65hEvWp6/9SJrPfs2ZNY74EHHnCxpvP8dLR/7xl14sSJxHJVk9cWTf+OmCVT15rqy+omksa/3tKu\n", + "dT+dr6lM0ojjN3reoyiyOI7HPOm0RAEAAATgIQoAACAAD1EAAAABGlXioGhpQ/59ndIPKo1Wy/Wr\n", + "6uowbj0PRQzRnwiq7PuUpug+JNr/ZWBgINd7/PPQap+hadOmJZa10rQ/lLwqE6EflNK+Z371caXl\n", + "HrTchl8iQmeNmDdvnov9fjzt1CdKr3vtD2aWLBER0g8qhN/viX5Q5aMlCgAAIAAPUQAAAAHaIp3n\n", + "V8vVCSWV35z6qU99ysU6+eUbb7yRa7+a1jDLX6W4t7fXxWfOnMn1nrxWrVrl4kOHDo37/cPDw4ll\n", + "Te/ptpm49kNZlc3TUjz+EP3HH3/cxVu2bCnw6Iq3ePFiF+etqr9gwYLEsqYyQmj6rin0/tLE4yua\n", + "3iu0lIRPSxfkLfOh14dW8243Wtagr68v8ZpeI9o9oszUXlXV2TuVX6YiD1qiAAAAAvAQBQAAEKCW\n", + "dN5o82/eZs28ozX8Jvaf//zn4zswM/vc5z7n4rfeemvc7zcrPoWnzeIhKbws2vxLU/DYQiaH1SrO\n", + "Ztmjm5ombwpv8uTJLvYnBW41nddEEyGFl8ZPT6u0+7ifptP1dISlPxKzneh58UeDa/pXR0i30+jD\n", + "iSZkpD4tUQAAAAF4iAIAAAjAQxQAAECAzD5RURR9z8x+w8yG4zh+5O6/vWBm/5OZjXb8+d/jOP7Z\n", + "3df+3Mz+RzO7bWb/axzHL4213dG+FHn7RI2MjORarwg7d+7Mtd/169eP+Z4y5K2U3NXVVepxID+/\n", + "T9SOHTtqOpLyrFy50sWDg4M1HgnKtnTp0tTXtBK53tP9vk7af0jLIoT0OWwKPfYbN24kXksbLk+f\n", + "qM5yr5aofzCzL3j/FpvZ38Rx/PG7/xt9gHrIzH7bzB66+57/GkURLV0AAKAjZT7kxHH8381srOaY\n", + "saqofdnMfhjH8a04jo+a2UEze6LlIwQAAGig0BIHfxJF0e+b2VYz+2YcxxfMbLGZaSnmk2bWP9ab\n", + "33vvvcDdluPTn/60i1999dXU9XQYd1YKTyfh1KGtZfObk1Gfa9euJZY7cci/pnj2799f45GgbIcP\n", + "H059raenx8XaBWLq1KmJ9bQkhqb2quyuUTS9v+usGGbJdJ5/LtA5QtJtf29mD5jZBjM7bWbfyVh3\n", + "Yk17DgAAJoxxt0TFcewmVIqi6Ltm9q93FwfMTHsfLrn7bwAAAG3lhRdeuOc6436IiqJoURzHp+8u\n", + "/paZvXs3/omZ/bcoiv7GPkjjPWhm+Wb6rZg/ii0thaejTszMTp8+PeZ6fjVqRl/gwIEDdR9CKXRS\n", + "7unTp7vY/01dv369qkNCBbJGCOv9T9Nb/n1RlzXdrZPzmiW7Q1y9etXFd+7cGccRl0fTkhr7o831\n", + "XGg6z5+YOe/oa5TPrzo/+hD17W9/O/U99ypx8EMz+4yZzY+i6ISZ/YWZPRtF0Qb7IFV3xMz+FzOz\n", + "OI53R1H0j2a228zeN7P/EnN1AACADpX5EBXH8dfH+OfvZaz/V2b2V60eFAAAQNNRxwkAACBAaImD\n", + "xtC+GHmH+OddT0sfmJm99NKYBdjpA9Uw2pdN+1RUaXh4+N4rtaG+vj4X67B3v/8gfaImDq1Mrvdj\n", + "LWNgluzr1N//YfWbuXPnJtbTvkQnTpxw8cBAM8Yp6efSz57VZ0v7ffl9xfzSCKhPSL87WqIAAAAC\n", + "8BAFAAAQoO3Tef6QxFZ97GMfc/HLL79c6LZRjbpSeO3EL0mQN8W9Z88eF2sagorME5dWLNeUmz8p\n", + "9ZUrV8Z8z6xZsxLraTqviRNb66TDOgA9K4WtZQ38Egdob7REAQAABOAhCgAAIEDbp/OKnsx4x44d\n", + "hW4PaApNfedN382ePTuxfOHChTHXmzSp7W8lCKTXiKaqzp07l1hPl3UU1EMPPZRYT68lHbl37Nix\n", + "xHp11XLW1LWmIv2K5fqajuDWSv9m6b8ptAdaogAAAALwEAUAABCAhygAAIAAtXRkGM2bMz8xUJ1l\n", + "y5a5+OjRo7ne4w8/T+u/sWLFisTyzp07x3VsPq1obdacatX4qMmTJ7s4rXq5WbIEgFYinzdvXmK9\n", + "OXPmuFirnGdtry6XL192sV9uR/t9aUV/v0L7yMiIi4vu44vy0RIFAAAQgIcoAACAALWk80aHeFJZ\n", + "GqhO3omyNTWX9RudMWOGi/1h260ifdc+NAWllcj99FZaCtlPES9YsMDFmipcsmRJYr2DBw+O+1iL\n", + "oKUMzp8/72K/e4pOVKxVzjUFaEYKr93REgUAABCAhygAAIAAtaTzmpbG0xEgOvkl0EnypvN01NOZ\n", + "M2dS19MRdJrWMEuORmra7x3F0u9aR+f5Vex7e3tdrNeYprrMkteppgSbch3lTb8dOnSo5CNBE9AS\n", + "BQAAEICHKAAAgAA8RAEAAASYkFOv69BTM/pBYWLQCso+rUw+ODiYa3val6Wu4eao38WLF12sw/z9\n", + "yty6nl47fl8n7Qel/VVHZ7oAmoSWKAAAgAA8RAEAAASYMOk8nbzyxo0bNR4JJoLZs2cnltMm7q1S\n", + "Vjrv2rVrubahFaSvXLnS8jEpHR5PFef2odeBfm+3bt1KrJdWsXzq1KmJZf2tFF0JHygaLVEAAAAB\n", + "eIgCAAAIMGHSeVWm8HSkk45IKZqmKM3MvvzlL5e2L4yPn6JoOj/1kme9rFF8K1eudLGOvhoaGkp9\n", + "T94U3vr163Othw/o/cgs/z1JR8k98cQTqetpOi9rQt40Wr3cLJn200mHs9LRQF1oiQIAAAjAQxQA\n", + "AEAAHqIAAAACtH2fKJ0ZPGvG+Sr5Of7xWrFiRWJZ+xZk9WfYvXt3S/udCLSPxcmTJ0vbj85E3878\n", + "IeZppRD6+/sTy7/7u7/r4r//+78v9Jh27txZ6PY6kX5v/v1kz549LtbZGvyyHMuWLRsz9r3//vsu\n", + "1j5zfr9ALY+R1Qevp6fHxZcvX3Zx3kr6QJVoiQIAAAjAQxQAAECAtkjnPfPMM4llHQKrTdUjIyOJ\n", + "9bSZuUqt7jetsu+9pFXF1mb6JlTOrtKcOXMSyzr0Xodj563YnVfR26tL3s/hn2dNGdWVZp806cPb\n", + "W5n3guXLlyeWjx07Vtq+8tLfvKbEzJKV4XVSX7+EgKb6/G2oU6dOubiINHZWGQygaWiJAgAACMBD\n", + "FAAAQIAob1XZwnYYRW6Ha9euTbymzbjaRL5gwYLEeps3b3axHn+ro+JCPf3004nlLVu2uLiulKKe\n", + "l/vvv9/F/oiZTkk7NYGec02TtBv9vQ0PD+d6z9KlSxPLJ06cKPSY0mSd87lz57pYq6b7v8nbt2+P\n", + "e79azXsiVNJet26dizVVa9be13q78P9OT+RzriNPp0yZknhNf9v6u/R/4/o3Uf8G+n8fR2dRiKLI\n", + "4jge86TTEgUAABCAhygAAIAAPEQBAAAEqKXEwde//nUzMzty5Eji3/ft2+fipg/FX716tYu174VZ\n", + "ff2g0mhu2O8DpbnhkL4hGJtfJTq0bEWrdKj7o48+6uJNmzalvufKlSsu7urqSrx248aNMd+TNQS+\n", + "LlrComhF94PSfh5N7KdY1/UL+PT3UfRvxZ95IQ9aogAAAALwEAUAABCglnTeaCVcLQVQJx0mqVV6\n", + "s2gz4k9+8pPCj6kqmsJrekqhnWzYsCGxXFc6RNNOWlk6i6an/QrUaem8Jqbfy6xYrmnOtHMyHk3/\n", + "vdVVPqaJtOK7Don3Z8xA+zl06NC430NLFAAAQAAeogAAAALUks4bGBioY7eOX11Zm+YPHjyY+r5n\n", + "n33WxS+//HLqelpNVie8zdtU2NPTk1iuauRT01MK7STvpLtPPvlkYjktxe1P8Js3dZD32l64cKGL\n", + "tUp53vR2qDJTyDqCdu/evanraTpfK0NPnjw5sZ6mORcvXuzi7u7uxHppVd41vei/T/el1dDNzF59\n", + "9VUX6/fhz5Tw8Y9/3MW3bt1ysT9Kcffu3WMen39f1mts0aJFY77HrPjUZtPp9+h/V5h4uAIAAAAC\n", + "8BAFAAAQoLaHqIsXL9a1awBoKxNhkmOgHUX+7NCl7zCK4jiO7YUXXrAXXnih0n0D98J1iSbiukQT\n", + "TZTrMooii+M4Gus10nkAAAABeIgCAAAIUEs6r9IdAgAAtCAtnVf5QxQAAEAnIJ0HAP9/e3fvIlcZ\n", + "hmH8uomkUAQRIX4FTBHBVNkmjYipwqYx2vhRpRAR/KjVRi1ttBJtjJJCImkiacREK7uwEDQQgwZc\n", + "SCRsLPwDEngszrs4rjsiB2de2XP9mjnnPQfmGbjn4WHOzBlJGsEhSpIkaQSHKEmSpBG6DFFJVpNc\n", + "SfJzkjd61CABJFlP8kOSi0kutLV7k5xP8lOSc0nu6V2ndrYknybZSHJpZm1uDpO81frnlSRH+lSt\n", + "nW5OLt9Ncr31zItJjs4cm1wulz5EJdkFfAisAgeAF5I8tuw6pKaAw1W1UlWH2tqbwPmqehT4tu1L\n", + "i/QZQ0+ctW0OkxwAnmPon6vAR0m8qqBF2C6XBXzQeuZKVX0F081ljxd4CLhaVetVdQv4AjjWoQ5p\n", + "09afrj4FnGzbJ4Gnl1uOpqaqvgN+37I8L4fHgFNVdauq1oGrDH1V+k/NySX8vWfCRHPZY4h6CLg2\n", + "s3+9rUk9FPBNkrUkL7W1PVW10bY3gD19StPEzcvhgwx9c5M9VMv2epLvk5yYucw8yVz2GKK8MZX+\n", + "Tx6vqhXgKPBqkidmD9ZwIzUzq67+RQ7NqJblY2AfcBC4Abz/D+fu+Fz2GKJ+BfbO7O/lr9OrtDRV\n", + "daM9/gacYfj4eSPJ/QBJHgBu9qtQEzYvh1t76MNtTVq4qrpZDfAJf16ym2QuewxRa8D+JI8k2c3w\n", + "RbSzHerQxCW5M8ndbfsu4AhwiSGPx9tpx4Ev+1SoiZuXw7PA80l2J9kH7AcudKhPE9QG+k3PMPRM\n", + "mGgu71j2E1bV7SSvAV8Du4ATVfXjsuuQGL5jciYJDO+Fz6vqXJI14HSSF4F14Nl+JWoKkpwCE+Fx\n", + "pAAAAGlJREFUngTuS3INeBt4j21yWFWXk5wGLgO3gVfK/+/SAmyTy3eAw0kOMlyq+wV4GaabS/87\n", + "T5IkaYQdfw8HSZKkRXCIkiRJGsEhSpIkaQSHKEmSpBEcoiRJkkZwiJIkSRrBIUqSJGmEPwDOrQm6\n", + "MQ8HvQAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['conv2'].data[0, :36]\n", + "vis_square(feat, padval=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The third layer output, `conv3` (rectified, all 384 channels)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnWuwZVV1tt+tCGLQGENEuTaXbqDtbrq5NgEEFFGQaKRi\n", + "vlgVKxgvMWpiiKl8ookcYzTBsqiUGiSJxKh8CSZGUVNFQBAQL9BCS9PQdNMgGlBjLhoTNcZL9veD\n", + "fs46+z1n9Jxr7bXPPg3j+bPP3mfvdZlzzLnWeNcYYw6Gw6GSJEmSJEmS9jxq2geQJEmSJEmyq5I3\n", + "UkmSJEmSJB3JG6kkSZIkSZKO5I1UkiRJkiRJR/JGKkmSJEmSpCN5I5UkSZIkSdKRidxIDQaD5wwG\n", + "g62DwWD7YDD4v5PYR5IkSZIkybQZ9F1HajAYPFrSNklnSPqqpC9IetFwOLy71x0lSZIkSZJMmUko\n", + "UsdLunc4HH55OBz+UNIVkp4/gf0kSZIkSZJMlUncSO0n6YE57x/c8VmSJEmSJMnDit0msM3is8LB\n", + "YJDr0iRJkiRJssswHA4HC30+iRupr0o6YM77A/SQKjXC4x//eP34xz+WJD3ucY/THnvsoRUrVkiS\n", + "/uu//mv2O5L04he/WJK05557SpI2bNggSfr6178uSXrwwYc2/5M/+ZOSpN12e+i01q1bJ0mamZnZ\n", + "6QH/9E//tCTpp37qpyRJX/nKVyRJj3rUQ4LdU57ylJHPncHgoba98MILd7q/xz3ucZKk733veyOf\n", + "77vvvpKkb3/725Kk7373uzs9Xs7z/PPPlyS9613vkiQ9/elPlyT9+7//+8jx/+hHP5IkfelLX5Ik\n", + "fe1rX5Mk7bXXXpKk73//+3rMYx6j//7v/5YkHXbYYZKadnzsYx8rSfr5n//5nZ7fYx7zGEnSD3/4\n", + "w50ePzzpSU+SJH3zm99c8P/sh9dnP/vZkqQHHnhgZH+0/7Zt20Z+v8cee0iS/uM//mPk8/Xr10tq\n", + "+n358uWSpCc+8Ykj+4s44IADRn7/r//6r5Iae2W/9OO9995bdX6w2267affdd59nJ7WsWrVqdjtS\n", + "Yw8vfelLF9xf32Avr3/96xfcH+326Ec/WpL0L//yLyP/P/DAAyVJ//mf/ylpfv85tPcFF1ygiy66\n", + "SJJmbbktkQ1zTt///vclNed04403SpKuv/56Sc05rV27duT3t912W6fjgchWJsVS3d9ee+2lxz/+\n", + "8bNzf1uYa1/xildIkv7yL/9SUnMtqZ27HOYgjzlmDn7Tm94kSbr44oslNbY9KabVf1dccYWk5tp7\n", + "1FFHSWrm7r/5m7+RJL373e+W1FxbuRfgGssc8cIXvlCSdNBBB418n++99a1vlTS/3/bb76GHYF/9\n", + "6lc7nc/ee++tH/zgB7P9dOqpp86O9YWYxKO9WyUtHwwGywaDwe6S/o+kj/uXnvCEJ2ivvfbSXnvt\n", + "NTsRJkmSJEmSTJvdd9999u/TTz99p9/tXZEaDoc/GgwGr5F0taRHS7psoYy9r3/967N38U94whNG\n", + "/ocHjyeKgnLIIYdIkv7pn/5JUnN3Cl/+8pclNV4ld8UlUHjw5FEo7r777pHtRqBElECBcaXh3/7t\n", + "3yRJP/MzPyOprEj5/lAcUGTYPooEXhj7pz3/53/+Z3Yb9IXU9AfelN/to9yhoOGt8xopTM5cQ537\n", + "nu07N9xww7zj3hmRKrFp06aR97T3aaedtuDx/OAHP5DUtBFeDl4UKgXHhTdEO7q3ijIZ8aMf/WhW\n", + "RezCPffcI6kZB/RLW1wxjLxuh/YClL7vfOc7kqSnPvWpkmJFinaPjnvlypUj2/vWt741+z/Ouasi\n", + "FSkSP/ETPyGp6Wtg7lizZo2kRmnANuhHxtL//u//7nT/++yzj6RGZasdS9MGxQC1lvP47Gc/K0n6\n", + "53/+5wV/53NAiT322ENPeMITZvvc+8PhOL7xjW9Imj+3cI2h31Hj2S5PO0pEYwN1FZ785CdLatqJ\n", + "uZi5tGQfwNwyaWWrLdgr/c344DwZ61yjeEricE1jTmWs8wpRe3WdPxmnpTnamcSjPQ2Hw6skXbWz\n", + "7zzqUY8qTsjJ4sAFLUmSZCnT9gKXJIvBRG6kahgOh7NeG94X3glKCqC08MrzU+IQ7rvvPknN3Wuk\n", + "aERwl4vy5O9L4K2W8PN173muZ70z8F4c7uLxClCuUAQ81oSYM/dq7rzzTkmNN3HwwQeP/B/FAW8A\n", + "b4zPuaunf5j88BLuuusuSfO9VI4nUgX6uuHjuLEXtzfAO+U4+T7eFMcL7l2uXr1aUuOtc161Xue4\n", + "cJxd9+dqyN577y2piQmLQMkCtzvsK1IjopgywM4WUgtcDeuKKwze13DrrbeGxyI1yoHHfdEn3jau\n", + "nLgHvlThPJjDUNcjJQoiZzqasx71qEfp+9///ryYtQhvP+JC4aSTTlrwd1u2bJHU2DxzAWo0++Vp\n", + "Atck5jr2g/IEbI//M6dht6jjjA2uEcxRzC3YkSudtU9HJgVjH+WNccPczzWwBKo158V5+9Mr3x77\n", + "Lz3Vcbgmo2DSrrWKaS4RkyRJkiRJ0pGpKVIHHHDArMeM8sHd5/777y9JOuKIIyQ1Xg3KDd4KsShE\n", + "8HNXz108cPcfeXfc1aLokBVWgrvYSEnC2+CulvPjPdmJUTYfEAtGO0TB+dxNoxhwXigL7jW7UsFd\n", + "OO2It8jn4Hf70d0/mTAcL14b5+1EShscd9xxkqT7779fUqMQ4cXXgtfG7yMvif/jVdFetAf9i/eF\n", + "90w/0q+8bt++XVK98tgVV2XaKlJ4vx5nUKtE1cZkdVWPUAEWOq+uWVeOKyWR4lSKoUE5YAwzd2Fz\n", + "UUbipG0kom3iD0oNNo8qiw0xl0ftFClSjDlvH5Q6FC9sMsqo9rnJ7YOxybWBpxtsj+PgGsWY57jY\n", + "P+9RMvmdzy3M4Ywtrjke08c1DGUGJQsFlN8vlrpdy5FHHimpmau5Rh9++OGS5qvVEVw7GOv0O9c4\n", + "nhbRf8QB83SIax5zOP3O3M01gGsO/YXixffp9xKpSCVJkiRJknRkaorUd7/73VlvgefN3M1zl42X\n", + "wP/xevACPv3pT0tqvDfuYj3mpfS8FK+A11pK2WN4n9z94qm7IlKqF+R30X6X7HfrZELg5UQ1V2hf\n", + "7uLxHvG6uDvvmvXl+62NOSuBlz8307ANeDkQZXhx/Hh/tAeKIl4o3o/3I7+jfyLlbNIZOO614u3i\n", + "zfGe8+JzvGfshM+xQz8fvG9XMB1+z/fb1svyuJi5cS/YatsYiUmBp0uboKZGSgxzF7btCkpt5mQJ\n", + "+pq+oA2jWLAIbANVllcyoFG4yLhF8YEouyqas2hHFCnmrkiRio4XUInJdHXbYm7YunWrpPnxkkA/\n", + "8X2UDlf4+H0ptstr0JXiBmHaChXty1MdFCjaAfuohXhalC0/P66FjHvec+1l/8z52Df277UbufZh\n", + "V7UxXalIJUmSJEmSdGRqitS3v/3tWW8ELwvPlLtaPP7oLvvmm2+W1DxH9ro+0NZ743ioW8VdqysZ\n", + "tdvBc+eumrtmjx+IYkbYDjFGrrjhBXkNm1IMCgoWx0PsEnfnXRWfSeHZnSg5HLd7t6VK616J3KGd\n", + "sUvahfYu1Soiw6fk5U+6nf38OS/aDW+O8+F4UCmo24T9eQV5348rUq500R7YZ1tFCjWA7c7NrPGq\n", + "8pMGDzbyXJmLmENq56JI1aNStNdRou1Ldac8E5XvM1baZjx7Vh71tFACSu3TFtR2j1Ns+3vAdsis\n", + "5ThRgLBZbDV6CoHdMWZQNHxu8bhZ7KGv2L5oLoniHsfF25/z5VrENdNj3fhe6akO7e7KLvCeccC9\n", + "AnMadk1/ROUzXFH0bMkSqUglSZIkSZJ0ZGqK1J577jl79z93zT2pUWhqn/dyt4k31darAleKeA5P\n", + "Jkpb8DY4P/fOuGsvKUe+5p17L9yNo3yV6iJxfngFxG34eeJFo/iVjq9vbwdoN481w3uI9ht5wZ5B\n", + "FWWSuFLStlo2MXd4u+BeKt5WKWuxL/w8eI+9Yvcoliip2F1UG4j/u/3hJfM5rx4rVVpTD1zZmuul\n", + "1nqQ0HZ9SIdziI4dW3U1m8+9Jhu2HNk0MSbMcbQdtoMt83viEj0OkjhT+pw+JTusLbQfcwXnx3bb\n", + "qvkR2NKyZcsktY+79HbF9hnrrly44hfB+Xq2JXOMw3mgTPWlSEWZ6fSLX5O8nlntqhHgc6yvckG7\n", + "esZ97bXC63L577iG8jlzq8dKet2vaC73dqlVPFORSpIkSZIk6chUFSlfE467P+5a8bJKz9e5e+R3\n", + "kRews2ORmhgQ3pM50nXdLq/H5AoK/y/VuSIDAsUsUtzYjnvHeD8oMcQWse6RP1fm7t3XmovoW4ny\n", + "6sO+bhnHVcqyjBRNvEavV1b7+1pob69m7PaEF4yygv0tVpyPx+1w3rySaYV6E8Xv8LlneeJtY0du\n", + "V22VOLxUjm+uctg23mxcJaBUd4lz9DmMMeYZmxw/bR2pl2yXV+ZQn8OwIa+ng01625eyySLYDrbC\n", + "eqicV18V2tkOY5bzob5SCR/rtC/tHq2N6DUAGTO8xwY5Hq5lPrZ8TNN/tZXa2+LZn658YjeMqbaK\n", + "lMP5oYz6OqTE0DH3lrItfa7wuRN74Dw9+472xz6juQZl2ZXC2mtAKlJJkiRJkiQdmZoitddee816\n", + "A3hr3E16pkTkzXA37TVQvLJ5Ce5yiRvgOWrXuj7czRJrwvbdA+c9d+fsD6UIuCtGSSFmBWgHz3YE\n", + "7spRPmgfvAVfT4z2ZD+1XkrtCvcOz+89awzca8J7w35qM0DAszvZr3v/eO38P6rIHkH/Y0+RHbu3\n", + "OGklypUv7ILzw874HseHXdAufj70j6s8nBf7YXx4bFYt7Bcvcu76Yn3FmtRCG+KBe0Yntos66XGM\n", + "tCk2jc248gS0JSo1cwa/pw+wIeYC2oWYokj56BqnRx+S7eZjsy98jHh2Vqn/PQbMFUOOl7mPdmZu\n", + "4fc+d3I8PA1BGazNVuy6jihzJcpmlJVWWvOwLxiLzB3MKeyf+mLEjZYUKcYJ12bvP86bdqcdvfYi\n", + "cwbjxeccnvZ4jGLt06hUpJIkSZIkSToyNUXqyU9+8ry7QJQYvAuvcO6QhebeYNe6PHiHnlVXAk8b\n", + "orgI7oK9HhJeVZT54zFUvqI42yk9X3dvmLt4vFRfL8prcwDrGlGDhvP3DA28AjKNeO8VraMqxuDr\n", + "SnG+XtW2lMHD9/Bi8JL43dq1a0e+7+st1SpGtCvtVFqjblIVzSM4Pvrba+D48aCS0B6RasHnbi94\n", + "5/we757+QK3xNSIjOB7sgN8vtO+uuMqJJ+zZZ+vWrZPUjC0qZDMG+D1zGmuOAf9nbPA7bMz3x1jx\n", + "CuGMabYTVUantllEyVYjPDOZ9mqr4pbwONC2c/5nPvMZSdIZZ5whab6ixRztcZ+MZWwZuGah4nJc\n", + "vHoNOWzXswG7qtAeA+T2P24F/LZgf9g114g777xT0vx46BJ33HHHyOsJJ5wgSTrrrLMkzV+dwWvj\n", + "YS9ca7w9uHbR/h7HWlvjLhWpJEmSJEmSjkxNkfrmN785e7fO3St31Xgz0fNe7j75Ht4Aio17DQ7b\n", + "9btNvNBSFprXTXIPGk8ZL9WVIhQBvkf9pqgqsStymzdvltTcnXMepbvn22+/feS4UGaimKpICeSu\n", + "3zMyPPaG7MKTTz5ZUtNOeNMcTy20D+2F91Va241+xRvkd3iTUY0bvFCO22vERBBfgVeD1xmtk1Zb\n", + "P6kv3M5471WXUaZ83alIQfMMJ/BaLoCijPfIdiM75rgOPvhgSfNrIc09h3FhbLAP5hS3FfqONds8\n", + "kxQ1kznDlQ+273GREVF22qRquNWC6uxZg1u2bBn5HjEr2MTc+LYauEa8733v636wc8D2iIWiX9yG\n", + "Tz31VEnScccdJ6kZ0zfddJOkuNagx9jwu7ZKXW38ad8KYFs2bNggaX4F+Y997GOSxq/bdsstt0hq\n", + "FCmuUcxh2J33o7cb49ufivn7WqUwFakkSZIkSZKOTE2R+t73vjf73BNP1JWpUhbWF77whQW/R+zL\n", + "2WefLanxqD37C+8VDxivom3dJPe0vbaL4woEd8HEevndNXfPKEnRXTLZb7Qn54nXy/bYPvulSjDt\n", + "TnvwvNjjD9zr8Wq5vPoK7V1ryriCyPF7xgprI+J90P6eleaxYB4XgtdEe6FClLwTYnU4v8997nOS\n", + "5mf4RL9D8aIfPTaO2jyRV0rs3KGHHiqpqVjvWaye2eL9i33TTq5YlWKYfDyi0HF+tIOfX0lR9X7k\n", + "+3PX2jvyyCMlNWOZtuW7nBNzRKSSLV++XFKjKHhmLZCl5jaEzaLQeMYiqrQrNF4Hp6816mrxOQtV\n", + "meNhjqKPaVcfo/SpZy/yvSiGa7EhZqrEVVddNfLalbbqM0ofNl/KIus7S9JhPGGnPqeV4j377m/m\n", + "Kq+TxpyHPfpTC+zas/rIIvTtlkhFKkmSJEmSpCODxY7ql6TBYDCcmZlZ9P0mSZIkSZK0ZWZmRsPh\n", + "cMH00FSkkiRJkiRJOjK1GKnFUKTYx2KpX9Pa37XXXitpfuwR8RjEqPB8nlo0PE8nXoPn38SPkIHE\n", + "ds877zxJ0jve8Y4F9we+JiDP99mer1AfPVd/uPYfcQ+vetWrRvbn2aAloixAh3547WtfK0n65Cc/\n", + "KanJsOH/xK/Qr/vss8/IdoiL8HpdxP8Qo8V6ZtTlatueXdcdm5mZmY0jpI2JVyR2gpgjxsRdd901\n", + "si/iz7BhYpxokze/+c2SpHe+852z+1wM2M973/teSU2WH8fHWPa+OfbYYyU1WWm0D9BO/B5bOPfc\n", + "cyVJl156qaSmXtaBBx4oqcnKoj4Qx4HtElPFnELMCu1PzAr9Q1bcYrfnjTfeKKmJPWKOJH6PMcmc\n", + "ScYocZnE+WIfxNL5ahO/9Eu/JKlpl7e97W2SmrnXV/Wg3bZu3Spp/ligPZlLiavEzl/4whdKki65\n", + "5BJJTcwf/ev1yrADrhmeaeurG3j23fr16yVJf/AHfyCpGUe0E7GHGzduHDkPjpt2efDBB7UzGJfn\n", + "n3++pMW3l4hUpJIkSZIkSToyNUVqKUG1Ybwprxo8qZW5+wKvzusycfeO94A3SqYRXsDTnvY0SY0X\n", + "RTZklEVFNhveFttnO7QjXjBKBd4xypSvYwXjrkDeF5PKnJqbZTYXvFC8RbxH+suJlCjUBezCa/VQ\n", + "iwhvMqphFNXXcvBe8Z6pqeSV4msZZ5y95z3v6fzbGmhzX/NrsXCPvbQqQFR3CrzvGZMoUmTyeq0v\n", + "lCj2z6tniDLWPWuPDNtp1z0ia682m4ysrkg9Lo0ZMqR9TUagfclwjeZCjpc5nVevo+YZ21S253PG\n", + "Luo2ilPULyhgfJ85C0XKM4o5n02bNi24PV83s8S066VFpCKVJEmSJEnSkVSk1Nw1RzU4qIeEt7bU\n", + "IEYFBcq9DLwaFCHqAuH5E6+A94nXiHLitU/ce+M9x4GSwvb4HC/LvWQqiOPte3XoaTGpGj5RFWRX\n", + "G6JK9yVQomhP6k/BpBW/xa59tJgQNzatc0RZqF2VflxQOJgriIVCZWZsY7vYHMfp63B6DBtzFrDd\n", + "xZpro5psxPYwVnzMRMpIqXJ3SUGEtmM0Wq0D5YxrAUqT18Sj30oKIefHHFOrKEbjhePzNQkjuipS\n", + "K1askNSMG2LdePpUWoOyRCpSSZIkSZIkHdmlFKlJxSrhJURrttWuAD0tUHq4q/cqzniBKD9eAZ1M\n", + "H89wQllypY67ehQrfofX4zFZJe+S/eCdlCrLL1Vq15EiU6dE2xpvtRkwk475qz0/p23W4kLUZjJ2\n", + "hWPzavBtQfEoVYJ2FkuJApQLYomoms9xoB67LdH+ZGuhSPA9fu9zCyr2YhEpJcyhbW2xNPY9hqwv\n", + "ovMgOxUlsWtMmmdd0r/jVirn2lW7jmlXNZ3YNcYdCt64ShSkIpUkSZIkSdKRXUqRmnTWHM/Lufvm\n", + "7nXSMTu+Jlxbrwzlh/pPrqyhCPnacsQnROs/8bl7jb6itntZKB4oE1FWGNvluFDU2q4IP21QgHju\n", + "fs899+z0+5HySdwI3pnHp5TAiyamD/w98QLUwOkb7Lgt9Dvtg9fYJl5m0is1eEZkV3aVODJUTmKX\n", + "UCBQBiIlwZULVyn5v8fqtFXoJsWkssMmtbYg/cHcC7wfd21DfudPIxijJVDExr2WekxdLZ7NyLWr\n", + "r5i8VKSSJEmSJEk6MjVFarfddive9eOhc9eI8oHy4lV8xwVvkxXkuYudtCJFO3SND3AvI8pEca+i\n", + "FG+B1+39hJeDgkTtEbxXauxQBTlSpPCiUCDo76VarysC7zqq9O64PbkCirJE7JhnREVgP1QW5/so\n", + "nhApYn1R2w6OqxtLJXtzLq7mtoUxw1zDGPQxy5iqbUuPVyyBzXEc0X74HrblthlBbBQxKK6y8uoK\n", + "ysOdSSuR0TWV9kYtpl/bjjGuIcwptTFf2DNzuyuRUFKuus5djFt+z37OOeccSePXn0tFKkmSJEmS\n", + "pCNTU6RqnkHzXH3VqlUjv+laX6cECglKFwoJr5GyMm1q79KjGial8/MMJbxxvBu8WrxLnpvXxjqh\n", + "xLDdXc1LbeudeXuSWXPQQQeNfI4Xh2pRW2mc/nQvENpmodKfkULpLHbm1WIyrqKAjdNHzHGsXQeR\n", + "QhRlXLb11FEWSr+jr13F5rhdOWOVCI6PpwdAJWyUua6xSNTz4lrA+XBcUdzntJnUtQu8PV3pZK7m\n", + "tavq6zFHJagIH8E1oJQNW5vdF8H5Yi9Umh83hisVqSRJkiRJko4s6aw9vC8UIlaOnnRlZryZ6Lny\n", + "pDIvusLdfFvFjPMqeYXuheOF4tXQTr6ie/Qc3Ln//vslNcpHrfKyVGhbW4j1qgAvGgUPhQuvvm3t\n", + "FxQn2t9jpGq9YvoVFYHjiSqzPxIYd+wTy8QrY6mWKH6w63GV5lLi7IiJwibIruP32BgxUZGixvew\n", + "+a4ZnihjKAnsz219qbHYNfJoJ+Zm2qlrrBHH75nb44L9do2vLIHdYi/sz9cc7EoqUkmSJEmSJB1Z\n", + "0rfvKCw8F8Uzx4vzFcnHBS+Ru1XuUvGeiGvoqxpqX3T1RrlLb/vcHi8ERcqVKLaLUlaC9qS+0VJd\n", + "4bsv3BvkfIkbwd5QA4gH8TXzIugflFWv4VPrRXo2Yl/e567MuBmlzF1eM2vc2B76ijGJTfH5mjVr\n", + "JM1fzaAEipPbAMfpc0+kKKA2M6dj06y20BbOg1fU4EkpGn2x2BnJroB5pnTXpyzY1bgV/mHSFfs5\n", + "Xu4ZeOrBOBm3X1KRSpIkSZIk6ciSVqTI+Nh///1HPuduuu8quH73zt0q3tdSrGsjdb+bL/2OuAiP\n", + "6SEGB8XJFRa+f8ghh1QdBzVn1q5dK6l9RshSoTaWyWPZsGPsjFfiPWqrB9NfePtkz3n9Kep91SqR\n", + "9OdStf/FxKvEt4W+JHsPhaA2k5L9E9vhoHTheXtGKWOV15LKiErK9hibePgcdxT7w/45XzKHWY0B\n", + "lX9cJl3Rvi8mXcON/gL6ibneFST6p1aR4vhd8dxVIL4Te8m19pIkSZIkSabMklakwFexHzfCvhbu\n", + "upe6J46XynNfvN5SvEDJCyE2zZWrY489VlKjJKGgoIR4JXrqI3ktEeJFqC573HHHjWxvV6OrndBf\n", + "XquHDBMym0oqAvExePt4W+6lto1rQG2oVU2wA6hVP3YFiOnpaqP0DX3LXFabzYUtRIoUNojHzdzA\n", + "+1I9H4e5lxgSr+jOeUQ16lCZvb1QYXe1VQzGpVZd7orP1ajOPvZcWayF7bAf7HmxQE3viq8V2de9\n", + "RCpSSZIkSZIkHdklFCnn4IMPltTUH+Kumrv9vp677yrgNeIt9J254l7junXrJDUxUl5Hyb1rFCr3\n", + "hqkqy+fE9Fx//fWSpPPOO6+Pw180UH7axqzde++9kpp+9AwpvMdaRYf2xFtEqYK2leO96nYJlEpY\n", + "TCWKmI9JZX6OG+OCcsM6lF75u0Qp285jhSLlqi3YJDZOPGCpDhUquVekZk5xFZe5gv9z/MR+oYrW\n", + "KikoYuwHBW1aLPb+o7HXV2zTpLPtnHHbj7kPO+prnkhFKkmSJEmSpCNTU6SWLVs2mw1EFhPPK32F\n", + "Zu4eUZr4nXs1eKPRWl9RjRVgu57NRDbUuOv8TAqPXSH2iPbAK+F8S8+F+R3n7WvIbdmyRZL0xS9+\n", + "UVLTf9Th2nvvvSU17Rh53XfeeefI62LB+aBg9hWnQbuV4g+8rhPthnfP8dFvkQrC58TNsF3UgqjK\n", + "82tf+1pJ0kc+8hFJ8+NfUHyXL18uqYl5YpwxDhgvmzdvHnn9uZ/7OUmNXaBURplV2Bn793XA8Hq9\n", + "qjZQf0yafA0y1EPPZK2F47vvvvsk7TrZZj53+Bp8qNPeN9g0tskrNvHAAw+MfJ8xSVwltnfkkUdK\n", + "amzv2muv3enxcq1gbGDjbSvJj4tnIBMPeumll0pqlDbsgPdHHHGEpKY9PKMXtdnPq7bWXF/4eKN/\n", + "uQb7qiBtr6E+p/p4QSFlznBF2mPzsEfaDbtlDsaeiaWqVe9TkUqSJEmSJOnIYBoe0WAwGM7MzCz6\n", + "fpMkSZIkSdoyMzOj4XC4YMpzKlJJkiRJkiQdmVqM1OWXXz6bocHq8jyn5Dk8sTg8xzz00EMlNc/h\n", + "yejg+SjPNffbbz9J0tOe9jRJD91JLgbs5xOf+ISk+c9fyaaiUvvhhx8uaX4mCs+TqcJKrAjtwvP/\n", + "U089VZL0p3/6p5LiDB1qb/jK176WYe358Uq7lzJ3usJ+3vKWt0hq4iSIpSG+wuMCyBrjeTmxWsQO\n", + "8RycfkCVffnLXz6y3wiey9OvxHNs27ZNUn17sJ+3ve1tkuZnOzIuOH7+z/kRi8bxE3fD+PDtef8B\n", + "/UhsE9sljgPIgKJdb7311gXPa/369ZKk5zznOZKkN7/5zSPHSdwEx0e8ETWPPGaO/ua8XEWnH97w\n", + "hjfMxj4w1jy+iqw5xhrHSiwOY5GxxPcYMx57s9hzS9f9RdmMUabpuPtrC/u5/PLLJTU2CGRoExtE\n", + "xu8zn/lMSU1m6YYNGyQ1MUP0O3ZBXOFrXvOakf1OGvZz5ZVXSpJuv/12SY0dMbeRlcn5M2ffdddd\n", + "kubH/BDSw/x5AAAgAElEQVRTxdzGWDn//PMlSVdccYWkJuuSMcecQk1A2umzn/2spOYaxDWaduMa\n", + "xHggluuMM84YOc9JMXesS9Jf/dVfSWrOn2sdx8c1ljmO8+PaTBwo7XLbbbdJamKjmJvOPffcnR5X\n", + "KlJJkiRJkiQdmZoihdoiNRWYUZy4y+au2dd1wrvgrhEvC4Wl64rifbFp0yZJcQbR1q1bJZUzTyK2\n", + "b98uqVGkSrVi8MKj6sNtwXvBm4oUGPeWSuAF4S2Ar2xP5lS0VhzH43XGAO8crw/vsBavQH7HHXe0\n", + "+r0TVbWOsh05f8+ia8uaNWskNV7vWWedNbJdxhc1j17wghdIarLzNm7cKKnx/vEWf+EXfkFS4wW7\n", + "guRZo6gMeLcOmUu0k6snc9sPlfKGG26Q1HimZBPRdoCtsI/Pf/7zI+fC7xjLp59+uiRp1apVkrpX\n", + "iC6B8lVb8bxENBctdh0gx7PaGPsoC8xtrgjy1AHb4XrCeTL38D3mIObOaeFzNWPB1V3qb5XwjGPP\n", + "WOdaE0HmNZm6QHtjfxyP76+2Dhr9wSsZyRwvcz/j0a8pjE9XKr2umtclwz7YHvaOvdA+KLOcH0pW\n", + "7fmlIpUkSZIkSdKRqSlSg8Fg1hvBo0Zx4K519erVkpq7SbwJvA4ULO6aURq6rp9D7AleEUpZ2/WE\n", + "eE7NcbqXQDxG13WKvA7R0UcfLanxLiadiYn3HSlCUKtEAV5QtGYdz69LeG0ah365++67F/z/pKtj\n", + "98W4dc1QeFFwGTf0G14Zdvqxj31MUhPDhFeJl0iMU+1ajw7j7YQTThj5nO0RB7Oz9eLoO44FUCY8\n", + "nixSI/FQiRHxdSxhUmONvhm3kjpzGdsZdx3LvscGcz0wdukfFARX5rgm0E6+bihzLjEuKBBt5yQH\n", + "9ZU6WG23R9wuYxf74Tw5XmKmUNVRhek/5khqsN1zzz2S5q9zWYJ29TmXfuZ4OE9XpGpXLeD3UXtx\n", + "/lHtO/q5dj1T5iS2G43TaDzzdMuVuohUpJIkSZIkSToyNUXq0Y9+9LxYJ3+OiheJN0hshnsfviJ1\n", + "V08dL4u7epSXtsoR3gTPX7mr5+4fLwLvhrttYpjwhv25Ld/jbhnwtkreMc+h+R5eal9xGH3hK8w7\n", + "tNu4awpGsV2LrUT1dT4R7vUD54n3hr2hYuB1EycQxQtgV9gpqoKv8VeC+BG8Urxw2mVuXOVcFjq/\n", + "SNGJ2sJh7qGNOCdeDznkEElNWzGGaINx1xckbs1tsa2tMFcyp6EIdI3p6nts+JzlsTMR/n+UBWyW\n", + "TFpss6Sel2BsrFy5UlIzB7dVpFDafDUK8Ax2rh1cA70iviuMfq0qPf3g6Qb7Yb/Ev0ZPVQDFdlwY\n", + "8+w32p8rVp45zvn40ym/pnKvEPUD9lIbb52KVJIkSZIkSUempkjttddes94DXgP1gLjLxpt68MEH\n", + "JcUriHP3yd1017gC7vo5jq5Zbni9HK97f6VMCs9eo52iu+fazAJX8saF45zUdoFYHbwJ+qmtgsN2\n", + "6N9pZyxBdB4otagdXVWOSKlknOB1elZsbTwN/Y/3hzdH5pWvtUf/sl8+x7tk/2Tk+Nqbbu+oD1Kj\n", + "FBBHxT6IrSjZKmPOY6MYw67eetv1Bcfrqh7KQa3tY+Oe3RQRxaiUvt9VqfJ4VupDoaQwB5eeMnj7\n", + "ez/Rr7XZcA5zB+3ftXYeipLDWEeJ8bGJGst58L2SPRNHjCLFfhhjKEDEFPI58YrR9rnGMbYhWleT\n", + "70eZvK58+bWF9nAFDPujP6I5i3GAkoyCWVrntVZxTEUqSZIkSZKkI1NTpHbffffZWBjPRPDMgLm/\n", + "kRpvw1cUxxvlLrsteEccD3fHbb2uceMQqODMq5+P11l6uOFeEN4MXmcpK5NsUJ5vE9dC1hfKDl6O\n", + "e1VLhWgctCVS3hg3eHMov3hpbVUMxp9768RgEQPlXj3jjd+jSjDO6acou5C4obmfeZ9iO6V4QGzH\n", + "V08A5iCYVFwb23WlZVz1l7aN+tbPLwJlg7mJ9uL4aEcUtUixQ2UG4kdRJPzpQm38KzZMzBE20lWF\n", + "RqHBvrz+VS3MZdg+9kg7+DUG5Wauje8Mt3ufQ/w9Yx7Fq20Wno8P1GG3L2IO6b9S3HEUB+3ZuJwv\n", + "/YFdRtcIrgF9k4pUkiRJkiRJR6amSH3rW9+afU7J3SZ343hj3D1zF+veJHfTHkdQe/fu+HNfvKO2\n", + "tVc8xsfh+T81KvB2ovpHeJF8z+tI1UJ79x3PUYu3a5RJ414T60y5N+kKJRDP4N5V37FcuwqRMopd\n", + "+1p2beuw4Z0ybt2rxu4YF4zXqLaRe7N8n+1gP3j1c+3F4ybxUFEmXOXi/+wTBYBzGTf7zkHBqW1j\n", + "339thi0VwHnF9plzUP98LijNXUA7R6opNudKgX/fFT2Ok1gmfu8KUCk+k3bjd8yZXTO6UV5Kq0iU\n", + "iGJuvJYisUC0j2dqR3jskSt+ESU7Z7yUvhc9DfJ4yK64HbBdtzfqdXHtqIV5AruqHQ+pSCVJkiRJ\n", + "knRkaorUt7/97dm7bjxN7i65++VuMIpD8GrDXiW2Lb7eT5R1V4vXuAAUM2JHSpkk7lWTvdQWtoNX\n", + "MW4MTtt28fiHCPe6o/50bxS7ocpvFNOGAlOqVfNwBztAvfEV32vB691///0lNf0MHjeDGlOrrvj4\n", + "IU4CRXOuyoCqzBjjPXME50o2GKomygyvxHq4BzxuZexxVdFaj57jJmsLFdzXFHT6HhMcbxRT5Ofj\n", + "FcvBx3JJGcEGUaeZq7Zt21Zz2FOD8ye7b9zVCxiTjBnPiEepKz11oT05Hto/UqA8e682szyCcep2\n", + "4Iob3+uqfHFt4PjJPC6RilSSJEmSJElHpqZISY136JW7uUvGmyR2g7thVyi4+yQbqG1FZSBrkLvs\n", + "rkoUyg93x3j6eODc7XKcUSVvsvN4Ps5r1xgpPPiuMWRObfwI549XWqrBUutNRFWRo+PyjCWPn3ik\n", + "QSYN3qZnCNVW0cbbRa3xTCu8Xa/63baiPt6or8M2VwHjmBm7PlfwXcYc58aY5JXfe12lcSt7j7uK\n", + "QG3MC8fJ+RIbxRzbdW6DqF6QwxznNf4iZY/j5pX28v2Ujp/9oLzw6vbAHMs1ZqnA8dLftB/nXZst\n", + "yvc8hoj2rK0bxrXXsx/96Qj7of15j93VXjP8aQ52QNbdaaedJmm+AoVdcq3knqBU2d5jJZkbWX+3\n", + "RCpSSZIkSZIkHZmaIjUYDObFUnAXy10k3gKxQXgp7lWgIPE8mEyVrqBQcBfd9XmrxyVwV++V2Dnu\n", + "TZs2SWrOk/Pibpq7c7L3ukJsVlsvoSv0K+04buZGiSg70bMi8ZbGjXvZVcEOUWKJY0AJLq0QQDvj\n", + "5fIe+6J9vT/aqjIeH+Hjf6794oHj0Xu8I0oUc4yvDu8xVahtHPPq1atbHXvf1MZ/ct5eef3ee++V\n", + "VK9oRIpN7RjGtmhv2pcx508P+D/tTj/WrsEHKDm+Bhv9CktldQOHMdX2vB2vuRbNxSWFkePxNfE8\n", + "Rorfu2LY9hrj8crgWZPYMbGAKGSsXlE7t6NIoZ6jfHFtRqGKSEUqSZIkSZKkI1NTpIbD4ezdMl4C\n", + "z1/xRnwF7KiWBneP3FWyvdJdZIQrZW0VINb58ro6KCLE6nD37lmKfD9a6y+qN1VLbcXqcfHn5LXr\n", + "Q7Xdvns7rkR53At4PaOHC5wXdrR27doFv4d3SX8wvvgdSjBeIeOQWCcy29gfr6gB2L9704xPVJ5S\n", + "3BHb837i+FeuXDn7GcfMZxwrHiq2wVzj2+SYUJNdXavN4okYd33KWgUFBemOO+6Q1LTx9ddf32p/\n", + "eORbtmxp9TuH46b9OH+PD2WuxRYZu9gAykgpRoq5FSVyUpXiJwVjpmu8L3AtO/LIIyU110jal3Zi\n", + "TDLWuQb7cVCRnPb3rMJSv9T2X2TnnvHNPQR24+fB+UYwD0RzUG1m+8PrCpIkSZIkSbKITDVrj6qj\n", + "eCXcTXIXyV0xz83xiKloDniRbA8vk+qmUJtpgsJVG8vhNVJK3hveAPshBmqpPq/vSimLrq/tlzjh\n", + "hBMkSTfffPPI511XcO8bnut7fSSorWoMxxxzjKQmfuH4449f8Hsovnh1vHpVb9QAXw8MZfP2228f\n", + "2S7j9eijj5Y03+t3hau0hiLKF+OX+YL2OvbYY2e/yxziMUCMUWIsfO00wAP91Kc+JalRvfDMOdZz\n", + "zjlnwWMt4WuOlWJfXDEjZql2rkDVxpP3Nc6i1QEgakfOA6WvBDEsJ554oqRmDvcxTEyV1zVqW0+J\n", + "48RmplUzbq5tdmHcOcprBqLA0D6MZRQnsjv9//weu2NuqW1X7I85pJQlGSlWrmDSv9gNr77fqF4W\n", + "dsnajM6GDRskSWefffZOjzcVqSRJkiRJko5MVZFyTxjILDnwwAMlNV4hK1RH4PnefffdkqTnPe95\n", + "kprqts961rMkNV4ad8XcdXP3z92wrw3G3TxeaZR5UoLfo1z5c1juknm+vXXrVkmNd1hb+6MrZD1y\n", + "vn6Xv9jUKokO8R3j1v7pCt4TXiH24s/t+T9qg9ch49WVWAclyGO/8BqJ92F7ZImWxpXXisEOI1Xk\n", + "4x//uKRGkeL3fJ/+qF23jPPgODkfXqnSfdppp816lowtfuvxW3jc1ImhD4g/ZC7wmm9eoZlz41g4\n", + "N89kRH2jbxlb7tEztjkuzzLj+Olr3nP8vkpCaY04YsmijEjmwBUrVkiaXymdufr++++X1LQbts75\n", + "cHzMzdgy54dShcqIrXLcXmuwBP3OeXEeHmOzfv16SY0SQ/8w1zD3oWCi3HFcbJ9rDFmdHgcIXlOv\n", + "6+oStbF2KHlc6+hfrrmc95o1ayQ1qxps37595Pecp69egB3CIYccImn+mKdd2c7mzZsXPH76DTvg\n", + "d7Sjj4fSNYHtR5XbmQPHJRWpJEmSJEmSjgwmXdNnwZ0OBsOZmZlF32+SJEmSJElbZmZmNBwOBwv9\n", + "LxWpJEmSJEmSjkwtRmoxFCn2sVjq11LdH5kjxH945g7xG6iTvh4Xn//+7/++JOltb3ubpPqsRl85\n", + "3PF1lYhLufDCCyVJl1xyiaQ4e43aQb5eEpQyk8Dbk+Pg+Dm+KLssgvbleT3xMb/2a782sr9Jw37e\n", + "8pa3SJqfGUO8A/Ee2AtxDvyf99H6VcSGnX/++ZKkP/mTP5HUxEd4JhjtQfwN2/V6aR6r6LF7MzMz\n", + "s+cYZen46u7EqBBrROwPteCiODD28973vldSOX5tXNjf29/+dklN35WyuqIq/w5jhDZ+3eteJ0m6\n", + "/PLLJTWxUJOC82NuIUaMWCBswW3O41M9I5QYMI/1edGLXjSy30kzrWsD7Un9LmLWWK8SzjzzTEnS\n", + "8uXLJUk33nijpMauiY1i7DGu6I9XvepVI/udNLXt+bM/+7OSmtivT3/605KauZiMYLJPiX3zelel\n", + "/aQilSRJkiRJ0pGpZu0tNtQ+ISMED3vVqlWSGm/mr//6ryU1Cgd36e614d1eeeWVEz/2ceA8o7pL\n", + "ZFrceuutVdtru1ZaqQaMe9VtV3r3TCqH/mp73K7QoV7g1dVmA+K9kZHSdS3I008/XVL76tRO1J5k\n", + "Wt12222S5vdDqfYLeCZalDEDKFSR6gDYyc7qh/laYLQ1n6NwcIyeGYnHDai39LXXnUL5mrQiBbVZ\n", + "a1Bbh4ix4QrPpJWo6DhqK6lH54cNkU3IHORZXw93aE8yXqMsv2uuuUZSM5eiWKHIMo4Yq6Vai4wL\n", + "lF/G31FHHTXyPZQfFDPmCsYn/cdchFJcC7UDsQcy9n29W89qLV1znFSkkiRJkiRJOrJLKlIeU1ML\n", + "tUB4RVFCaeC5OnESxE143SgUnrYVp4G7cBQGaqvgNfSdSYlXgfKEd038AN5GrSLFdvBK+gYvBrxy\n", + "vIP3g5pALR2e69O/tSuB0+94W6gY1Hnad999JTXek8dkUXMHO8O7wRtm+7WgruDN8Tyfdnruc58r\n", + "SXrXu94lafxK8hxn21iwElHcEkRKFGAHO6udg23T9oxV2pC2wSP1PgK+h02xHbehUmXkcSnZfom2\n", + "nvWk1p7D5ksV2X39TJ4KtK23RP+yX/q5tPbawxXatRQvytqM2J1XBqc9Syp/VEGc7THH8HTI66Ax\n", + "7rBfj6ushe1Si5F2YA5vWzE/IhWpJEmSJEmSjuySilRfa6R5hXDiIfBauCsndoPIf7wjvN+2lcZ9\n", + "5WzPqGj7HLgE1Vt9ZexS1eOIWmWnK67IebVmB++H33lF/LZxHvQv2/MK9njt7u2jgOF1sX+PsUL5\n", + "rAVliNgo2uOUU04Z2W6tEoU644oT3ir/x/sstX8tXdc7w2tlvO0s5oo2x+NE5eI3KEusw8lYZ4x7\n", + "ZXP6mFeOBSYdG9VWUQLagawkz9JatmyZpPlqqis/tYoQ6jZjj7HC+qf0vStSvpag23C0X54mRDaF\n", + "rXhMWdtVKPqmq8I2Lm2vmdgdShSZy7R322sA7c41j/NHaXKlkLmXCunMTV0VJJ9DiPfs61qWilSS\n", + "JEmSJElHlrQihQKE1zKuUkNsD4oA6/lwt8tzdJ7PclfMXbOvm0UWoK9FVgsxRnjL7LfkbbUFL9C9\n", + "wXvuuafT9toqWONSq7TghdOOXWN8fM06Xomdo799nTW8HFQKjgevDu+461qJ2CFKEetV3XLLLa22\n", + "E7UL8Q54r9STOuKIIyQ15+UqRi0odW2zJ6kXhbpCOy9kF3icZB+5ooQnjELj58i+6CNUasaOx++h\n", + "uEyKrjE9tAOKnNfFYbulNdv8fCOI7zzmmGMkNe2JGh7NGaWx7ccN1I5jbKEk+vY8tmbaitRiK1EQ\n", + "tWMJroG0NxAvWsrk9bptfJ/jQRFCBUdx4prYV8weCjSKKXPxpz71qZH9diUVqSRJkiRJko4saUWK\n", + "u1LuIlGAuHusralCVpqvVM3dLnfFeJ98jvfiFb69npQfR+3K3Hi5bBclhXiD6667rub0qonqH+Hp\n", + "9x2btdjg/QDt2bbuE/EA9KN773hjqBkoRMRi4XWxP7xQttO1lg3e9/HHHy+p6S9UB167xtUAChte\n", + "Pt5iKauuhGdBRuPD/8/4oP1qFMqS6oUazCvxbV59njmINnUbmrTC4NvHs6/N7GWuZM7ysYBKv23b\n", + "tgV/X8qyA9rpgx/8YNX3a4ls2ZW1yCZcMelL5XewWdp1GmvY7ozoWlWCMc/TGp7G0O6RIoXixJyF\n", + "MogyibrN3MLcvX37dkmNnXPtHjfbkkrtHFdptY22pCKVJEmSJEnSkSWtSKEUkTVEdhuxKhs3bqza\n", + "DoqBV1n1uAn2xysxMB4f4d6QZxHVeiPubXJXTkZN33fNHu+AMoJXsKuDV4r3Q7/VKlGAd0k/unKJ\n", + "V4vCSQwf9oDXhjdHP+MNda3zRLVnvDns+sgjj5TUeH9U8x0XqgD3TUmp5XyIu0EdQglsg681Rx/R\n", + "dvQp+6Jv8LT7yhDuC+Yub0PaKKq3g0LncyAqP+rmtGJ42oIt1MZwQdd6RJ49xhhnzH3xi1+UVB/T\n", + "45X2a5W/ttBOHCc16Npy++23S5LOOOMMSU1WbFRLkfhj5lBiD10RY5xFcw1269mdXeHa3VcmMox1\n", + "IzUYDL4s6T8l/VjSD4fD4fGDweBJkj4k6SBJX5b0i8PhcOdrRCRJkiRJkuyCjKtIDSWdNhwO5wZP\n", + "vF7SJ4fD4dsHg8H/3fH+9WPtZMddLcoPd/O1K5v7c3avB8R28TZQgvBa3SvleygT/ty9pIB4BgXb\n", + "I7MA+lKiorpBtFvXLKylBv2EvRDj0xZUCV7xeulX+hs7wssjxs6rAXM82G3XrD3UFLxqFLFxY6KW\n", + "GqgjtDvtyPm2yWp1xQLFhbHvFZyjDNelAsqIry/ZNruJ88OWfM3BaRFVkHdqn0YQY4Ny0lV9J46U\n", + "scZTA5SStvbCXIJ9Yn+0v8/VfI/XtpnMZN2hAJXWv3RQcOgXxqTHe/rcx3hrqxwC/dX197XwlAs7\n", + "aRvj1ode5mf4PEnv3/H3+yX9fA/7SJIkSZIkWXL0oUhdOxgMfizpz4bD4V9I2mc4HH5jx/+/IWmf\n", + "Mfcxe1fLK3e9teB1EUeAZ8/dOl4F79mPP7elOirKB7/rmqHB82ueJ+M99V0tOaobhPdHu7TN6Fhq\n", + "eHbXuODl0994gVHldV7pTxRNvED6oWscCkqp18tiPIy7xt5SAaXJY6JQ/NpkXtHWvsaY15cqUVon\n", + "cLGgz33tulIsl8ft8YqqijI3bUWq7dxeYtxMU2Ds0u68bxtzxdzkawrSP/Snz9mM/bbnw/GxH9Rc\n", + "5rC2WYxkd6Koud1Fc28phs/x2n20lyuxfcHc0pVxb6ROGg6HXx8MBj8j6ZODwWDr3H8Oh8PhYDBY\n", + "WnmgSZIkSZIklbA8V8RYN1LD4fDrO17/dTAYfFTS8ZK+MRgMnjIcDv95MBg8VdLCYf0twKtsWxEZ\n", + "uGvm+SexR14Bm8wCvFT38LlrRTFiu229VPeCOR5ibajZMWl47jyp7KzFBm/Fn8u3VQw9JsrjElCq\n", + "eI8C5XEE/M7jJ7oqUihbeGeeLdg1JmypgTdKXAfeeJdxgXqH2outoy7zytimT5kLYKnUBXIbrIVY\n", + "FuYeVo3wytPTzlLsex1Pj1ftqijSbow56h0xd3fN1AZ+jzLoREqUx1369rlmuhLUVvlj+yiWXifK\n", + "98ecxDUWu6W9SnbG8dHeKIHTigc9/fTTZ2tRLUTnGKnBYPC4wWDw+B1//4SkMyVtlvRxSb+y42u/\n", + "IunKrvtIkiRJkiRZyoyjSO0j6aM7PJndJP2/4XB4zWAwuFXS3w4Gg5dqR/mDcQ+yqxIFUSYOVVZr\n", + "Y0v8rn5cJYeYJOpjcZe+WLVcSusk7arQrmQ4ta0ZgtfKdvCG8G7JJOF7HjtV6r+uNVFQScju9MyZ\n", + "h4uy6DGIKFRd5gH6zF/xeLER+ppK586kKmI7rjaixsGhhx4qqfH0PaaJOc7XAKTt2B5KFAoBv5t2\n", + "jFRUJ6srqJqo1ShxbSGz2WsJto1LZMxiT8wZPtfU4pm8Eb5aB9TOjVyjeEXB9Ww6jyelPzm/WkWJ\n", + "82FNTOy1L7vom843UsPh8H5Jaxf4/JuSzhjnoJIkSZIkSXYFlnRl864QD1HCK1iXPF7uxomJQQno\n", + "mkmAd4yXiHewdevW8DdJzGGHHSapUW7w7qjCS/XqEsQjYBduT/Q7sXXEzNV6p10VKY4H74z99h1X\n", + "AniTZHf2VdesFmIGa73uhcAD9jYiniyquDwtvIYZqjlg09gybeOvxH6hQKBkeYVzVGn2E8XodKVt\n", + "nOLJJ58sqZkbsTkUkFrVFdV29erVkpr+7lIdf+7xRHCeRx11lCRp06ZNC34vitGKahKWqB0TKI4e\n", + "Z1kLcwDtwHiJYp04T9R53tfaAUox18Zxn0pNmlxrL0mSJEmSpCNTVaTwlrj79LXuqCbLXTTeJTU3\n", + "uHvnLhlP/cQTTxzZD94ZK7x7HAJKEHftXlNixYoVkpr4Ae6y8f78uXNb8C67KhWcl3vVtTVH8Da8\n", + "6jNxGIvtDXi13BK0P/1x8MEHS2r6q1aJgnPOOUdSY5eoAF7zhXa7//77JTXtRgwV78kWxV6J2+gK\n", + "3i7eaF/rUDmuCiwWvh4cqlEX5Y0+jFStcZUoFI7Fije89dZbJc2PbWEMeH0pbBaVG8XpwAMPlDQ/\n", + "m6+vrCjmDiqA33nnnVW/ox199Yrly5dLapQmjhPbQKniqQHfx4b5PirnCSecIKlRsblGMGaJZULJ\n", + "uueee3Z63CtXrpQ0/xrjClOk0DEn0F/RGnZArBdzXCnel/bsutYg10T240qpw5yLvbXNBqVfPXvW\n", + "4emQK6rMzYwL2onxznZpd/of++N97XhIRSpJkiRJkqQjg2nURxkMBsOZmZlF32+SJEmSJElbZmZm\n", + "NBwOF1z0LxWpJEmSJEmSjkwtRmoxFCn28dGPflRSE1tCtt5JJ50kSdq8ebOk5rn1M57xDEnNc31q\n", + "iBAPQQYCsUPEZp1//vkj+yU+g+e1PJ+OanewrlBp3R+ex//iLz5UoouV0DkO4gB4DsxzfuInjj/+\n", + "+JH98EpcAPEkfJ9Yqxe84AWSpGuvvVZS0z4e00I7Et9A3ADP73kO7Stt88p+X/7yl0uavK1w3L/3\n", + "e7+3KPsD9uP7o914nr9q1SpJ0n777SdJuvrqq0e+T9wI/eDxKMQJXHDBBZKkyy67TFJjn8TG0R9k\n", + "I0ZxDR4Dhr3Qz8QyvfSlL13w/CbFzMzM2Psi5gJbjMZq1HeTgv1cddVVkpq+JlaGmJy/+7u/k9TM\n", + "cS972cskNbFC1113naQmZoTfMfaZ6/hddH7YlNsIY6mU5QYc5xvf+EZJ0hVXXCGpiXliP/QLtsUc\n", + "wdxK3KLbLjbK75iDzjvvPEnSpZdeKinOvGY/vkZeKXYH6KcLL7xQUnt7Yf/EnJVik6DWPrED2rF0\n", + "Xm43tDPn9xd/8ReSmhgpMp6ZyzzO0a8ZxCR57bjDDz9cUhPrx3lxvGT3EdvE+4suukhSMye+8pWv\n", + "lNTExvE5+ye7lbmWa77XZXNSkUqSJEmSJOnIw7KOlOMZEHgpZMB4JsPnP/95SfPX9ooqVkeeO3fF\n", + "vs5QRKRE4dXglXlmBooRXtWGDRskNd4e50sGycc//vEF94PSxd06dYpQ8lCk8DZr163Cq8Cr+spX\n", + "vjJyXA51nxaLWu95UtAutIdnkuGdUaMGr5R+p79oV19p3e2TfmNctM2o8ZXp6V+8Ra92vJSgbVDP\n", + "OGbGytq1D9UYRsVtWxV/0pAFR2YqSgyZo0Cf4knjcVO5/cgjj5TUZEaTvVR7vpHNtB1LPgcwh3m2\n", + "m6+D2helzOZoVQzwseaMG4NMdiHHWatI1XL00UdLapSikiJVyuD2NfJQryO74Jrm9cGwL36PfXqN\n", + "RZ6+cG0lu5Jrr19z//7v/17S/PVJyfZ85jOfOfI7nhKVSEUqSZIkSZKkI0takcL74rl9V6L6M5EX\n", + "0Xa1ebxbh7tqXnke3NarwmukSu+2bdtG/v+5z31O0nylqu26RBzXli1bJMUV1r0iO3fvPD93ryWK\n", + "PxBeDWgAACAASURBVPCaKvx+GpmkbSAWDa/LvR6v5VMC+8C7dW8fr4lYOLwk4gFQiPDOSrViJlUJ\n", + "HftbyooUtoWiA8w11IxjDCw1vF4U7xm7fI5N3HDDDQtuhz7yGnluO8Tnedydr2HXFff4161bJ0m6\n", + "++67JTX95YpErYrqqrxTW8ndt0PsDzFqt912W9V2IqL2jPqvLxiz1N1CwWQ88HSAa0wJroXYH3YV\n", + "XfOiSvXE7JUULa+pd8QRR0hq+gnFi2t5pOihznPt8npTHEdEKlJJkiRJkiQdWdKKFNV38aDxvtpW\n", + "qm67VldtFV6IYp+8Sq5nlJA1xWtUPRdFjrt7zgfIuOCuv2v1WrzD7du3S2q8Fa+cjfdEzJh7DcR6\n", + "RcoSygteMdshW22pK1J4K3g73v9RLF0EdhLZEfEixPThNWE3/D6K9/DK+3jTperJbaE/USqXAigO\n", + "jA1UvLPPPltSM8fw+Sc+8QlJ89XoviqYt117ziHGieNgLN53332S5sevRRATgu0QNxcpB14hmjmo\n", + "pPg4ntXnMVkoFD4W+D7787nDM575HnNjNDZKqjHnjX1wLcKuSk8tUAgjiHHzOYN4SOZij5tECWOu\n", + "j+aOkjrOtZT2I052zZo1ktqv++rr1vpaeyVoV88Mjn7PtYS5jO/R/7UxZdgTChd2Q8xkKlJJkiRJ\n", + "kiQTYkkrUnhftTU7IqK18Np6UxHRit18zt1ulO1EvAa1K66//voFt4didcghh4x8TgYOXhvKRVvw\n", + "5vDS8SY89gov5d5775XUeJl8r+Rtc5x837MAx127cNKgMPp6Xl4Xq5ZS7R0UJOJV8CLx3rHjCI9Z\n", + "m1T7em2fpYArLJ5BSwwIaiiKi9PXWnrYBipvtDZaBL/DVphjapUowOaYm7Ahj1lydR41vWucndu4\n", + "90+kgLBfVxjBM55LKm0tKB5sn+OvtYfSuqHR8RGHedZZZ0lq+utDH/qQpEaJKtkP+0c9J44SmOOJ\n", + "gfI17qJMchRah37CLts+HaFfGZ/YZ6QsUfeJfuGV8VC7lia/w26YM2vnslSkkiRJkiRJOrKkFSnq\n", + "GI1L9Jya58zcfUfKUolISSjVIMGrIzOjNhPFMzvYTskr5Tk/x+PfR/Gitgheqj9/p14RtK0dU4oh\n", + "alvXaLHxrDS8xa6U2g8vybPy8M5LCphnJk0qaw/vbynHuJEB+Z73vEdSo0CtX79eUuPBE0MUZRWN\n", + "C0pCqQ6R46vau5oeVRx3GNOoncyRxOQsFh7vCVEs2bh1pEoKUe1x1FKKkYqgFmA0V5ZqEoIrTE6U\n", + "HVeqF8Vx+dzFdnil3WqVIaCfaf9ozmL7XNP8uGozp4Hvc630+OCIVKSSJEmSJEk6sqQVqa64QhDd\n", + "DfP815WZ6Dm8w91q5HXgbU1agYmyGD32hniQKK4CL4JYLbIF3evtK7YsIqrtMun91kIsVN9ZbxEo\n", + "kF1r9rjXiL3WZtK0peTNLgVcaUJlPeOMMyQ1cYiTUqSA7ChWUygpH8wVXqcHahUp4ihZp5Hq+JNW\n", + "EzlelCGPQeG9x5W2VaLIaGUORNEgVqgW5njmRI8xKtF1rhpX5a6FpzKsv4odfvGLX5TUtJfHKDFH\n", + "R3ML/Uw/RtfgaE732npRLBj7Yb8cL9cyYtmI6eKV+F6H8U67RDGTTipSSZIkSZIkHVmSilT0XJq7\n", + "Se5ia7P5otih6PlprfeDVxV5D20zcmrhuTZwHnzumT1AteYoJgfvlN97TQ/A68XLaBvn0ZWlUjG7\n", + "1uuPoL2mBf3ZtgJ7LbVe3FJm0rZGnSCy5Gizkk15rAhzD7+nb/kefeyKAHMAlayZI/uKS41AeaB9\n", + "PYPU6xB5dqPPta5kuO15peq2sTo+V0arN0R0zfasnUvJ7usa30sFea/RyDWQWEHqfXlMko8T3vNa\n", + "smdikVz55drj9bu8/zh/7B5F058qca9Qqivl9lN7DU9FKkmSJEmSpCNTU6Qe+9jHhrFD0fNXFJdS\n", + "rIjfRUaR974ulcPdcLQiOl5J5D30vVI5Shz1i4C7aOICqE3iXlOpThFexC233CKped5M9V2gPd1b\n", + "dG+E4y15Je5F+P5gqcTecL4l+yj9vi21sXuOe/2uXrRVpEpe+aSyAicJFZ1p40nFj7GGGTXBqEhe\n", + "q27S9ygzeOi8Z+zQB9HcxPfdpmqPozb+00GNZe5w28QWfU5BCcFmmbOYY/gdyozXC4O2Y5W5lOPw\n", + "+E2Op+1Tj74Yd6xxLSUmilgw+pdYIep7+Zj3p0a0N+ddirmLjp92pR+jdsTeeeUahz1zbUGRio6H\n", + "/mWlAOY49lvKvkxFKkmSJEmSpCNTU6Se+MQnhsoSd5VefZfPuVuNPGKUGX+Pt8LvPdbFFZuoxonf\n", + "LXs1YOCuFu+L4/Xn+vzf4xscfudeIO3kK2+TVYbXyl01lcu3bds2sn+e5/vzdn8uzXFyHK5QtfVu\n", + "Pcaqa+2VxYJ+6Br/UFubxMGeUGZrM8pcwcIO29b/8t9H1Na4WUqgLhKHydjoGxQRxlBbhQQPGxvk\n", + "lTmIdQ7pc7IR3aOnbtaJJ54oqclSrO27ruowyh/78TnWbdUVBL5PO9BfKEfMeVFF6q5ZiYxZlA/W\n", + "2Cupw34t6pu+4nDJYF+3bp2kxl7op9r+dgWpFC8ZxayxWgcxW8Qj+/c9Zs4VSWKoIFL1sSvmAWop\n", + "Mq5K2ZepSCVJkiRJknRkaorUsmXL5lUf9efMPK/kuS3Pw8k0iPDIfOISqB3BfvAWuOukqi9339zV\n", + "clfN/lkbDy+I9w6KF3fF3NV63SevdVLijjvukNSsw8Tx4t2yHVc+aGf3trmL564cr7a0sjnnV6o+\n", + "i3cY/R8vg/93rZe02HT1brtmN6LceRYlCiPt56qCe63EC0wqDmhXAnXPs8KoodY39D1zQaR6Rxx0\n", + "0EGSmr5jTLMd99ijzEyUG7L0PCYEfOx2XSMQmGuYW1wxQGGK1F7OG/UdUL+Zo2vX2KuN9WLMEJsF\n", + "pd+R9bar8I//+I+Smmtm2xg47NPrbdFvvj23I/qP7XBtQSm66aabRr6PwoT9Yk+uiPk13O81+D7j\n", + "AiXXFd+IVKSSJEmSJEk6MjVFatu2bcXn8ShL3J3iPdXWjwJXDrgLxuvk+as/B0YZ4fv831dEj2rO\n", + "cBfOaxT70zbewL1GvKTbbrut1Xb4HV45Xmcp9gZFrTbGpqTAeExW2/6dFnhDeO20J5lYfVdgR4mi\n", + "PfGSiG9hzUbHvb5JVYZnHE27TlYNxLqsWLFCUqPmlurMdIUM2GOPPVZS00Zt49RQ1RmD9CXqMGOn\n", + "NLeyribfR4FAlX/Ws54lab6KPG5MDtlf4MpAKe4QRWPz5s2SGmWKubxtRmvt+fC9tmp527X9lhoc\n", + "P8odim0pG5S5CbvEvvgdNQ29/YmNOvTQQyU1cx7j1SuSo3x5LCB2gELFtbeksHGPwT0DWYvPec5z\n", + "dvq7VKSSJEmSJEk6MjVFas8995y9yyRWyesO4elzV8xdptfx4f9f+tKXRr4HkdeBN8Nzf56Poizg\n", + "7blC43V0arOnXHkitgVFiLtrzgcly+MePBOEdiQugN/hRXB+PK/nbpt4BLw5jo/Pwb3Stl70pNfv\n", + "mhbevtjZpM4Xbxi7xw7x7qYN573YayF2yYzCM0WJQuFpW9GceEIUIDxgPmdskgV0wgknSGoUIb7P\n", + "9/CAaUOPY/vMZz7T6vhKoEjtKiowcI1gzuxas+/MM88ceY+iwfZRyLyOEnM21yiUFs8mxA6mBfXK\n", + "AIWIay2xalzDmNu5JqC6sx3OG3tBCQLil3nKQL+wHeYItsN7zw5kLcgHHnhAUjNO/FpLvC/H7Zn5\n", + "XqEdBZQsReZs5nLGIf1XWwk/FakkSZIkSZKODKahFgwGg+HMzMyi7zdJkiRJkqQtMzMzGg6HC0rW\n", + "qUglSZIkSZJ0ZGoxUjMzM7N1oqK14bpC7Mgb3vCG2X11wdd5KsF+PvjBD0qSnv70p0tq4i94Ps3z\n", + "dp7v8/yX58bEb7B/zofnvWRAnHLKKSP7nRRkHL361a9elP0B+5n0/ogXeOMb3yhJeve73y2peW5P\n", + "Jolna4JnpETVqokTIIPkd37ndyRJb33rWyU1dsbzfPbvGTJkxFC/jGxN4mo4H2L9iIOgHa+55hpJ\n", + "0u233y5p/rpYp59+uqTG7q6++uqR/a9du1ZSM159xXjsl/ZcTHu5+OKLJTWxEJ69Q+yDZ+fwf7Lp\n", + "iAsk9oI4LL7/spe9bHafO4N4RzIrIxuqObe5r8R0eM07bIy+95gS5iC+H8WzsZ+3v/3tkpo+jeJN\n", + "X/ziF0uSXvnKV0qSfvd3f1eS9PnPf15Skx1JNhbHtXHjxpH9vfOd75TUtDsxK8QFbtq0aeS4yaai\n", + "36677jpJzZihHRhLxLws1twCvr81a9ZIamKwovhH2p05g+97FhrxvWS4v+QlL5EkffjDHx45Dr5P\n", + "DBgxSOyXazLZcXyfdsTuyG5lPP36r//6yPlNCr8WYZ+lWCbGxUknnSSpmRPJsKZWJfcinhlfOq9U\n", + "pJIkSZIkSToyNUVKmlwF676Ura7xYyhJKAMoTWR3oURxt89dPl4T3gVex1FHHSWpyQCZ9PpNzqRq\n", + "6/QNNUzaZhX69/FmUTNKKkJtFWy8RVesyN7EO8JLjNYLw57wHl1V4H1UmR7vM/LiyCgjqxW7w+vH\n", + "K0S14XjHXYk+Wk+rDb76O5794YcfPvJ/jhn4Pp4onj9tjefdNiORc1m9erWkpg1RViBa3T4C23Bb\n", + "Yu28fffdV5L0t3/7tyP/R23E896wYcPI/6N1IEv1llDhn//850tq5i5slPpZzI1kTTkoiZ415xXh\n", + "gUrcEaXVGaYFq1M4KKVd8X7i/Et1xbCjSE3nmuS0tdtx8WtR7VzB+OY83C5ot6510lKRSpIkSZIk\n", + "6chUFalpE61DNS54W/fff//I9vGqvLpqtOYZv8OLxqvAS05G8ZXgS0RVh/H2264zFYFShlLq1Ztd\n", + "eUKhXLlypSTprrvuktTYDzVSovMkDgY7ce/fa784XlvGV3QnnojjHFeJguXLl0tqVBvOF+U6UjHm\n", + "4h4qCovX+3Giz2lL1Omu6yTSh8ccc4ykJr6NzyOFIiJSiamrQztw/ihz/A7V0XGPvK06SCwJyhHK\n", + "2GGHHSap6cNovdRIEUDdH5eulcapN4XtM4Zc0avliCOOkDS/0jtqL9emtqtI+JzlSmpX++0LxhP1\n", + "0lDha5/++FqHzHG164Z6ewOKMbFUV111VdX2IBWpJEmSJEmSjjwiFSm8M+76UQr4HI+4a2wQXg8Z\n", + "JzyXbRtzRXwB3jReBTE1beF48DL7UlyWCq5IEQvE83GPE4i87VI8AXEeKE2luBm8ySj+AS+I/iE2\n", + "ifd4YWQ8YV94l8TM4ZVxfChGDmoI8SjYAcoPx+vqAN9jnERKLsfdFqoSn3baaSOff+ADH+i0Pak5\n", + "Zm+bWpgbaJtaz9dBcSI2i7izGpWtDdg+NkUf0g7YoKuI2NS4a8MRT4itkoGK0sLqE77GHkRjKYrd\n", + "aUvX+DviWplToliyWlCaHLLHUL7YTxSHybWB/vQK72SL9qVItc1kd4h98zXzavEK/F3Ho0MmNOOF\n", + "OTeKDXNSkUqSJEmSJOnII1KRwsv0GBPu2vG4u4KSxHNg9sfzYc/YicA7JD6A36OEtMXPl+3hJUTg\n", + "VS51UJJoL2qG8Bw+Uprw/sDjEVAo8aJRMvFa8PZRMNuu+4WXRf+gVnhsFIob+8frR8lhO56h4uBV\n", + "0u+cB/vn/GkXYrpQOTgOj/XCLqNswxJ43ShQKK99eJ20DTZfS0mdrMUzbr3+E3FvkVID9BV9hO2h\n", + "tKCY+BzBXMT5uxJGLTRX7FzxqIXjYw7Ddtg+tsvYLMFx0B+LvSIH6is128aN2fKxA74WXmku8X5x\n", + "xYk4x0gBa8u0103tuqZiCX9aUBtnC6lIJUmSJEmSdOQRqUhF4EWNW3uEu3a8Ra82TCZLyUvAO+U5\n", + "OTEveNcoX12prYnT1ot3fEX7SdUPQ5kBlBtqCBFn4fsv1Q7By6Mf6Ve8VPqlq7fkKgRepMdzsD+U\n", + "G5SyKPYqimEiY4p4Heze94dXjD3zPeIb3P48u7Qr/J5XFOJx6sPRxm1rjPWFnwsKC+dUazvEn2HL\n", + "fj6ujgIxIChf/J52iWKHuipSZLVho8Tq8L5W0WHO5BXlDLWV84jiPTl+lLGuGc8+1j2bs237RNlm\n", + "zGH0SymGzseG28O4damWGszpfYP6f/TRR3f6fSpSSZIkSZIkHVkSitSk6jm1xevXdAUviQwWlBhi\n", + "S2qfM/OcFgWAuAe8r3EVqVpKMVQlUD66xnZFoNS5okSNFuJS8Po84wNqvUlXDfgd+0EtaPt83e2e\n", + "OBe8Sa/jxGspdihqH1d2ovOPMqX4PmsQeszUuPbioCpE/VeDZ1pOC9rO1zesBUUEdRR1m+1FCgax\n", + "PU972tMkNXMSryhI9KUfb1fw9FGUqI2GSu11fYghQ7HieOg3nhbUZjuyPd9uW/gd7cXYQunrqkjR\n", + "b2wP5bL2/Jh7+J1nXdZmF9LOnrHL72uzHT3Gq+21FMUxylIcN6s0grmOeYL9RLFsTipSSZIkSZIk\n", + "HVkSitS0lSjoa40+vBYUA+ISUJJq98N2qGHiygfgnbaN0fF6RBG1tTRK9BWf4hlAvKLkkGVIZXn6\n", + "oTYmzL1PYD94aXiVURYoEB+CohLFctEP9AveLjFTteC9Yy8eL4OSSU0fj4Er2QPHz3Zd5WlbqymC\n", + "rEGOdxxFKlpVYLHBVsZZT1Car7BhQ1GdH2yWMYiyRSwO22FsQV9ZWtu3bx/ZL7E9bjvYLN/jKQHH\n", + "33YuQllBJfXzqc2WRAlj7uW1rT25kkV/0A4oQ9hr6bg4fo+5g9oMdJQXYoQ4LhTFWjw+2HH1Gntl\n", + "PVnGOufvqrifD3Yy7rj2emu0ZypSSZIkSZIkE2ZJKFLTgrthFIi+FCn3yH1lear81nrYK1askNRU\n", + "pEZ5gVKlafBK7rWK1Lh1tfomUt5cGeJ7tDdej9fxIm4DIuUKb4vt8j7KQiQeBW+YOA2PW3Dvh/3z\n", + "eW1MFODd1sYDeSYZXllJQSSGy9UMj7NpC+3D+ld9KJkoQF4zbLFB/et6TnjO2AiKRaS4OKiJHitE\n", + "vJuD6orNt80yBOYszp+YragdmJuYs3zNwCgOj//TDh6r42MCm2d7pX5hLBKT1DbDm/7jvLBH2hOl\n", + "i+PYsmWLpLjmH9tjzPk1oK067PWr2vYzxxNlQmM/tDvra65atUpSeQWCtvGnbeF828Z5piKVJEmS\n", + "JEnSkVSk1J8SBXhfPL9GeeJ5btvMA74feUttsx55Po/3gxcQtcOkqsnWUltHCC/xmc98pqT5yk+U\n", + "wULGEtCetLuvSeegGN5+++2Smowk+rsUZ0C/sl/aGzWA/dcqUnjjKHEeY+VeHUoZihL/L8UHcJzE\n", + "saB2jJu1R39zvn1m2tXGyU2KUsxLCa9jRB/T5p7ZCa4ouS2hIPgYwwbGjWNFeTjuuOMkNTFTDmPB\n", + "xyrHRwyNj1ng+GkXxhBZcD6XYbO1CiHtMG6tQa49jHn6g1fmaLLXopi6UsxZ26w5v1a1pdSOzKH0\n", + "A/G/KHPM4dE6t/50pO/xTPu3VYxTkUqSJEmSJOnII0qRwjvhLta9n1qvC28CT5xXwMsg4+Cee+6R\n", + "1D12hOyqDRs2SGq8sle+8pWSmiy10vNjzg+lDOWipPT0rdiVcG+07f6pTUOMEv1w3XXXLfh9Vwlo\n", + "J7x8jx0ClB68X/oXtaA24wUvi5pAeKMen+JeMP3uihP2wXpmfn4oUNgt3iDjwtd2dIUJ5YqYPeyd\n", + "34+rYNLO9FufilTfNa7GBdWTeDBsj7Hs9Ym2bdsmqVFSsBkUBI+rA8YUWXEen0nNOycae/RJredO\n", + "DMyaNWskNXGJXkcKm0eBwQYYW7XrOKKkoXhEGaZtlTZsn/Zsq4jQTx6X63Mzqjb9f+utty64PWoM\n", + "ck1iFQeoHTtt4yrHhfOnfzkPxift7BnNnlXaV4Yw+8Ge6Zfa7acilSRJkiRJ0pFHhCKFB85dJ94J\n", + "3kTb9Xt8fSW/a+W5tnt9Xj+oFq+l4VliUbxARJS5s1Q47LDDxvo93gs1Z7oqgcRllPrtjjvukNQo\n", + "SVRxxssqgX1ij65weq0gvHli3FyRIpsOZcjX20JJIh4BxQq75v9eGZ0YMK87hf1hl5xPVzy7NIqX\n", + "6AI2X5vpWoLtoDR430c1yYC5A6WFto3qOrktRkpFtB8Umlqi424bQ8L3r7rqKknS1VdfLWm+eknt\n", + "t65zJaBsuO34cdM/qLKMYX6PCsz/XTEjpubMM8+UJK1fv16SdN9990mab1+orRs3bpQ0f25nzmI/\n", + "1KAjxotVIqLz8diz2orr+++/v6TG7nw/feMxX74/lLmDDjpIUqPu+/n0XZuQfsusvSRJkiRJkkXi\n", + "EaFIcXfJ3SyeLkoFd/940jxfr82S8uymqD5UbRXdtvgagXi1eMt+F4+X6SvS+zpe4O8hyqwZF46r\n", + "LagBtAfnfeCBB0pqlK5apagEMVj0J++JXfra174mKV43ClCM8H5RfvASiXki/gHFiP16LBPvo5Xf\n", + "P/axj0mKvVUUIbbnVbF5xat2aqtP00545dhllHkGPo7aKKt9VzZHwWAOwHaJRcIWmWs4VmyCtqQN\n", + "8NQ5t9rKyiW61gVibuA8SuogfeOxRNRDQr2MzouYMVekmJuZo0pZc2vXrpXUZFBjSz73nnDCCZKa\n", + "rEKPwcKW6R+Om/PDhrEDxlxUWw6idSwZAyhQtD+KmCs3Xtm7awwgSuW4czjtgb1jD7Qb7cl72hs1\n", + "HHuhwjqxYvR/28r2bN/nOq4VjAeOm3Zvq4KnIpUkSZIkSdKRQV9rKbXa6WAwnJmZWfT9JkmSJEmS\n", + "tGVmZkbD4XDBNL5UpJIkSZIkSToytRipNoqUV+CufY7LPmr3RWYLtVmWLVsmqcmKop5T1/3VVuh2\n", + "iKsgngIVkf1ceumlkpo4BuIBaCfP6gLPynJ4Lk3cx5ve9KaR/RK7w36J7yA2CGhX4hE2b948sn+e\n", + "T/Ocn1iv3/zN35Qk/fEf//HI+fNKHAr7bZ1psWP/tO8FF1wwcn6TJrIX7P3000+X1NS/8pg94jSi\n", + "uBfOjxix8847b2R/Xl3Z15mqrZhP+2EvvL7whS9c8PyI6+hadyqKkXrjG9+oK664QlJjg7QR2U+s\n", + "8QaMccD2iPEg5sUrZr/61a+W1KzbiO0yxtkO8ZecM9sh/o0sK2rEMbaplk/dqNe85jWSYtuMYkG6\n", + "wn7+8A//UFJ/2VEONupzy6TA5i+88MJW+xu3fdnPP/zDP0hqsi19DGPbz33ucyVJV155paT51wzs\n", + "gxqF0f6mPZc93PYXkYpUkiRJkiRJR3aJrL3Fqnfk9XrwDsb1xshEQXnB6ywpXLDffvtJarwSV3zI\n", + "TEFJw9OnJktEpEQde+yxkhpv+vrrr1/we1FmCtlleNOc780337zg90teXpRp1TW7Dzj/pVbtGjWE\n", + "DJ0oe7Sk5HB+UdYg/eI1XRhv1HCh+rRXNMe+vA5bqS7buJlznnm1UK0jam1x7vzmiCOOkNTYNm2M\n", + "qoqixP9RPcnicZunDfg/tsRYJIOX7CPamt+hXDH30CeoyFF2F9AnzFVsZ9yxAaW5r6Rql2j7Oyqj\n", + "c1xkA9bSNSY4WuuuLW77tB9j2Wu6PeMZz5AkXXvttZKk0047TVKjWkeKVDJK2/Vo25KKVJIkSZIk\n", + "SUd2CUUKbw7vy+Mfxl3bCwWAu3y2z3pXbVfQjraPV4MyRXxGqc4QNS+iGhrEWbBeFnEcXStCuzdb\n", + "277UUmHdMGKiPvCBD0hq4kSIraJ2Cd407TyNTNJpgupBu2MPbfsPr4t4DtSRtlWiUXgYX9gpKg0K\n", + "GXZBTRheu64c3wfUKaLuDuoaqidzCbW2sLl169aNfI82o74Q2/HK4KjEvkYXyhBqHrXLUBzoK2Jd\n", + "UCpQsGqrw9MHHO9irZUG1GbDdvusQr8QzKGRjbWt1Vd7DUGxZLusY0k/UvutBPbHXB0pctdcc40k\n", + "6UUvepEk6eUvf7mk5lrw2c9+tmp/49I1rrcEsWpeP6qvWoTOpJQoSEUqSZIkSZKkI7uEIoWX6d5O\n", + "5EV4Jk4JPO2TTz5ZUuMV4mXhhfJ5bUwNd/PcdRNfwd29e53EOhEXgbdDvES0/hHeMHf54yoCHGfb\n", + "KrJUhUVR+dVf/VVJjTJFrNhHPvIRSY3iB480JQqiKs/RyuN40dgX3+N9235zsEvUGbaH6oF9oXzy\n", + "OXbdt/faBjzPW265ZcH/o4YSn8ixoxi5Ck2cX+TRUs2eWBUUIeamKLaGWB8yKsniom1RLlhjrARz\n", + "wGLH+7E22bhPBWphLqRyudM2likaY46rusyRbc/bxyZPQfzaxv4+8YlPSJJOOeUUSY1iQ+YzcA3r\n", + "aw7Fjic1ljkfrgmo3FEcbV+gRLPfvmIJU5FKkiRJkiTpyNQUqac+9amzigsxSXjCvo5S7XN3PHWU\n", + "nVp47oyHTYwPcQt/9md/Jin29kpr0aHUAMqWr8nnGTp4wdHafb4fYpSidZlqIQ6AWBtfU68EtXeo\n", + "sXPOOedIarLALrvsMkmNEtN2+9OGjCzPnuyKe7WMC+zYY/T4PnE72G/tGoKrVq2S1HixeLfE8uH1\n", + "4pXivREnwv5cAUO55f/TgBgZ4s5QDjjXSK3jc84Rzx6PnLFIGwEKCH2EwhFlotKnjFXmNpQotkNW\n", + "X0lhIKPX14gjNqsWX7OtlsVSooC5iVfiTVF2ahU86JqR3TbuEDzDtLSWItdCYqq4NjmM1XFjjBi7\n", + "jBfib/t+WoCdca1CYSwpUsw5bWF8ML7ZbypSSZIkSZIkU2ZqitQee+wx6wWV6s6UQBFC0Wr7XBcv\n", + "AS8Or8YzOvDM8UJRUvjc4e6X7/nz+9qMCP7P812/K+f48a7whlEs8FK6eo9tvRw/TuJOvDK9r2yO\n", + "Nz7pDItx6at6dERJHUD1wBt3NcK34/1Hf+DlgnvZ2C9VuF0hQ00hhhGiuleTguOUmiw7PqOtC73y\n", + "lAAAIABJREFUOFZUXzx4r8OER86YY+xG50SMEIoWthzNaez/c5/73Mh+OV7GqGcHOsx1qOj0Ncd7\n", + "zDHHSJof10aMkavck8qWmhS0N+3JXEK7eGYpRE8PukLWYq0a7DFZpZg2vo9ywnlTy43fc57jKiwo\n", + "USh8nl3XF1Typz/Wr19f9buuMVv8DvuPVvvoSipSSZIkSZIkHZmaIvWd73xnVqHhLrrr3TR34ygZ\n", + "xOjUgneGd8NzabxKXvFiPRsvqrzuMSYoRsRHnHTSSSOfs3+8G86D/+O9ovgA3ixeJe3K8XEceBul\n", + "mCuozQDCC2S79IdXWEe5oL2ooePP9z0jZakxaUUK78njKfASqc5Nu3n2I6AkeX/X9j/9yn6wS94v\n", + "VFFcmm839Dffx17Hrc8Gc7NUOTdiO3zdScYiah82SNsy9rFVPGay6PyYidXhe15vKAKFjONibKIA\n", + "lLLPsEHOg+8Tw8XxeIYw2YK+WkFbT5/tc7xdY42Y02qh/2hfbIrzQ6mhzpIrUj53jgvn7U8rIlAs\n", + "24JdokCiRmM3KI/jxpuSfcr2J61U0j9f+MIXOv3e10Dk/P110tmsqUglSZIkSZJ0ZGqKVGkNqS50\n", + "VQrIvvLn13ipeH1RhkUUP4HX6V4RmUR4L9xV47lHmQl4B64E4B2yPbxizwRqe1ce1VhBoaNd3Evn\n", + "vDdu3CipOT+OB6WEGjq0B9mNc2NeHongbbsdoBrQ3l5R3KEfvH+wI1eKHM8uRd2h/1A/iNtwBRTw\n", + "ClED3C7HZe744ljc1jkmFAEyL1GkaBNil3zb0eoD/I62QKGojfNjbFDfyhWmSOHAFuh7xiptiu3w\n", + "f/qMGDCy/TxD2oniOLEdFBL22/apQm0FcsCWaG/2z3lh85FN97Vmnh9P7XZR4GoreXtskmd50j99\n", + "V7Tva2xGuIKHfdGvpWxG8PbBLplraN9J17ZLRSpJkiRJkqQju0Rl80nDXStKCDVoiGUqZdC4N4B3\n", + "iPfrMSx4S2RNUV+JbEG8FVcMIsWN5+R4zyhUkVdWC9v1OlgodXgT7AcVgFcyI/g+61PhLdAueFnE\n", + "hE06Bmmp4c/5weMdvNo2dod36tuJat1g56VaOOzPs1PZPvt3r9C9c+wDbxxFs6/1tRZSf1xJ8crf\n", + "jG3ivrrWBeJcvbo85xop716TizZBKeL4brzxxgV/z/48a4s+o688c7ZtHR7mIPfoUc7ou9oK4U7b\n", + "3/n5EROFDXBc2KbHbkUZrm1ZuXKlpPZKB/biMXW1CgxPP4hhYv99r3E46Tk4UvDa2qcrZ9gTr4tV\n", + "5ywVqSRJkiRJko48ohUpvAKP4cGb5O4Y74f/UzsE79EVGzz0Uu0NvCcUGq99Uns3jTfL+RCnMK6n\n", + "H3kNfE47eW0WvATOj/gPnn8TF3H33XdLkrZs2SKpe9XaXZ1Spo0rNyg87tVix14fysGuau2D7RKP\n", + "ggpCDSUnqlGEl4sX3VdG0Nx6W4yFKG6RsUF1dxSXUswmMVWuXKE6o976fiJQvWlb+oS5pFTviLkl\n", + "ysBEoWHOYsy1jWWiPaNMYI67a9Ze1/pExMKdeOKJkpp29HVKXVnpK0aK2LK2sUn0F2O47VMD7A21\n", + "vxTjtqsxbh0s5ibscbFWzUhFKkmSJEmSpCMPC0XKPXZf6wvvDq+RDBa8Ca9lgjfrz7/xyIn5wbuI\n", + "vN9SlhxxC3gXXSuQex2qvjIio+fknBdeH+3KfukP2hcvkDgAvA5iwmjnSWdWLBW87lgUn4PS4l6V\n", + "1wvDq62N8ynFY3B8KLH0i8dkdV3LcZI1XUoKAQoIWXjr1q2r2m60rqLbOupgqbo7cwcKlFceH7fe\n", + "ETZBXxOfiCJVq8xQn4l2wyZR1Jhb+47RqcUzQmnPaO7qK2aG9mirqo5bUZu50+MCfRWOXZVxj59r\n", + "M+OJuSzKuu2LVKSSJEmSJEk68rBQpMhgwBvhPXC3jheIEuRr9LFOFxkzKD14oygueBWluAAyB7g7\n", + "9tgQFJ1NmzbtdDt8j+34c2Tee7wEXlrfCoDXuIm8dbx0+oX2wEvuu6ZLX/Tl3WFXrGyOAkftolpK\n", + "Xm/U/hG+AjpeG/2EnaJi+FqSqBIouR4/s9jMja2rVWPJxGUsd81wRZWjDxhz2D7qN7bE/mhDqv57\n", + "rFHbmKMoS439cL5tt8vvfW7xWmfTUkKuuuoqSc0Y6XstvYjaLDvHM7g5Xub4Uv0mV6KIP122bJmk\n", + "/rISYVJr7U0Kf0rStR5WFP8bkYpUkiRJkiRJR6amSB122GGz3g7eIHeRZCKU7ia5C8fD5nk5ihJ4\n", + "7A1313hneOKefdcVvFJqnLAfFCXO25UlvEqyAtkO3+P83DvAWyQrjrtpFAfiF2rXWCMbkf4oxXsA\n", + "d+8oGLxn3TPiFvCaUDzwbjnOuVlYi4HHIJEJRMV1r4OEAoP6Qf+S2cV5+PmxH/fevV5YrZeKGkCF\n", + "eI7H+8tr9VADh+1iF3j1vh4Ydoia4soviifqDHY4KVD0sLNx4onGrbXm2VeR7Xq1ftq6VNk7WpvN\n", + "a83RF8wh9ClzB2PP1cUSrDkYMa24Rmza4wh5qoD6u9TwdVGJu6VffC5g7btISaR/aYdDDjmk1+Nt\n", + "q0TRL9gj8co+Tpi7UHL9KdFxxx0nqbmG0r+uvjM+iA/llTmB9mbO4Pc+p/p6r7R3rcKXilSSJEmS\n", + "JElHBtN49jkYDIYzMzOLvt8kSZIkSZK2zMzMaDgcLliKPxWpJEmSJEmSjhRjpAaDwV9Keq6kfxkO\n", + "h6t3fPYkSR+SdJCkL0v6xeFw+B87/neBpF+V9GNJvzkcDq9ZaLvvfOc752UwdMUzC4jt+a3f+i1J\n", + "0sUXXyypnGnB81m258+leU7Lc1diXXju+4Y3vEHSQ3euC+ExUsBaexx/aW0/nv9ecMEFkprzI1aG\n", + "diV2xWOjeG7N+fF9znvvvfeW1Dx/Jibmda97naQmVobjJHaI2LTbbrtNUhPr9YxnPGPkONgf7cAa\n", + "e17pnerT11zzkAl5ZpRXsaZ/eE5O/InXCeO8fD2m8847T1Lcf87JJ58sqcm69DiUUlYi++GVDBza\n", + "gfPCbsDth5o+POfHHj1Wyvc3abrub82aNZKa8Yp90F9RXNPMzIwuu+wySU12EzZCzIbH4zGWiU3h\n", + "d/QhbehxYa94xSskSX/0R38kqbF1jpHve30lvscYIwYJG6UODn2MDf3yL/+yJOmWW26R1Ky3yP5O\n", + "OeUUSc0qAYz93/iN35DUjJmrr75akrR161ZJTQwOx3P00UdLasbeYtvKFVdcIalpN2KwGFscJ3Mm\n", + "/ee1+JjbsCFe+Zz9/fmf/7mkZm7BDsi4JU4S2J/H2HicHu1PvOBv//ZvS5Le8Y53SGrmKvqX42Ju\n", + "pnJ7LbQL58m1yDPNsTPs++abb5bU2MG5554rqbFT7I1rI3M8cw77Iz60ZC/ERvF7j0smrpS6T1E2\n", + "KPt53/veJ2l+LB/bH7dSOnb2kpe8ZKffq1Gk3ifpOfbZ6yV9cjgcrpB03Y73GgwGKyX9H0krd/zm\n", + "ksFgkKpXkiRJkiQPS4qK1HA4vGkwGCyzj58n6dQdf79f0g166Gbq+ZL+Zjgc/lDSlweDwb2Sjpd0\n", + "s2+3LzVqxzGOvHdPvLbmR6kWCt5OaXvctXv9pGOPPVZSo+TgBZEZEGUNuuJ2wAEHjPyfzA+8KLyc\n", + "qP4QXpXvj+PwWjZeS4PaN/fee6+kpt3I9sPLYS09vOxPf/rTkhov86yzzpLUrNm2ceNGSU374RXj\n", + "7XlmC3jVWrw6r0DPcbJ92tXrbOFFlvqZ9nrzm98sqbE7vNj3v//9C24fLwc4n8i+OB/UFdQI+uXw\n", + "ww+X1PR7tAbetKAfeUV5o19uuukmSY1X/exnP1tSM0fQv9g37YV3i51JcbV1xho2gHpHX7stMDa8\n", + "77x6PP93xSOq9M2Y4dUhuwjFw+ck1EnO3dXgyy+/fOQ48Mg5vg996EOS5itxjMlSFuGkQanBNjzj\n", + "1FdvYE5l7Hi70j6MIc/6cuUHtdOVKIgyaKNafT6WS5nobZUoiOqnffjDH5Y0/3x8NRDAfqL/O664\n", + "lcDOvL14iuRrT5aIauiNq0RBKWsVuqpF+wyHQ67C35BEvYF9JT0453sPStqv4z6SJEmSJEmWNGPX\n", + "kRoOh8PBYLCz1L9doyRqBbWxLygOrvjgJXIXz3P/O++8c8Ht4KFzd85dtj+P91gu3kfeBN6Ge59U\n", + "4CYmBSXAt4P3gzfgsU2A937JJZeMHBdeJF60q5OuKKIy4K3hZXrsE+DVc1wcJ94t54cqQTuDVw8G\n", + "V6o4Pz7n9Y477pAUe6muoOIFez0nwN6oqeKxeUAcRN+qAioICl/bSuoeC8fxcbzYGf/n/Ol32pEa\n", + "QfS7153bGZGHiw0wtkq15FwN5T19SmyGKyoca2n72D7bc0WDMUYb4MGjULntXHTRRZKauQab4XfH\n", + "HHPMyHnMrRI/SaLVA1xJKGWVo0ZGYxbbi87L10asVWKwG7YbXRNQ6SN8TintnzFY+0TH65fB+vXr\n", + "JTVj2VX92jUEvY5YaTUNnp7wylMJrpmo6cSdlvqf2Kxa5WhSdFWkvjEYDJ4iSYPB4KmS0CO/Kmnu\n", + "c6f9d3yWJEmSJEmyy3H99dfv9P9dFamPS/oVSRfteL1yzud/PRgMLtZDj/SWS9qw0Ab23HPP0ItY\n", + "qqxevVpSk8kQgZfH3TqeNUoO3ikeNp+790TmBO3EdjxuALxqsWd7Ad4CcQPc1ePlsv3IKyHWBQUh\n", + "yg4EV8xQooj5ca/UvccoA4d1zJzPfOYzC35Oth7eI/vFy4MoK8zbjf7y9b7oz8g7i+IZXPHk+Pg+\n", + "7Uu/Yj8cbxSXMy7YA2pLW0UKe8c7pt08XoR+pio17YZ6gWpC+3h801xK6yXSV7UVxsE9cNqescAY\n", + "8u+hJq5bt05S01dkuAIqZ+TRf+lLX5LUxFlii6weEKnH/5+9N4+17KrOfb8lckmL9PR0Fcg1Drgt\n", + "u9yUm7JdtjG24UIIoXGkEHwheoQ4QAIJGBkSSILfgdCJToGrBEJCnhMSEEgI0xiDyw1l3JSbsss2\n", + "bqCuYhK4Ckn+uUprKVj7/WH/ap39nTPOnHOttc8+jsdPso7rnL3Xmmt2a45vjjGmQ3noU4wprsfc\n", + "U0t01l8EfR2lDFp9W0rtRvv76QXg6rfXH30LBY8+SP8qlbdUH644RnMuCk7rGHf/Vurd/UdL0YLM\n", + "1ZTPoxKBMe79lzmLdxn3QYGiP6NAcV33SXQ2S4k6//zztWfPnvDvNekPPq1HHMv/a9d135V0qaT3\n", + "Svps13UX6dH0B5I0m83u67rus5Luk/QDSa+dPVZOO0ySJEmSJGmkJmrvfwR/+u/B598t6d2l626m\n", + "GlWylkrWK7Aq54w/31cG9u2xdtzyZrWNlYNSgnWFFUmkBeXGyo1OeMdawEqOzsHCijrmmGMk9YoB\n", + "1g5tE+VMofxYN1jhkdXnYIXcdtttc+UGP9/o2GOPldTXC+WKfKQc6pd9eNoNa8eVu+i5sbKwpviJ\n", + "NUVUGedEoUhdc801c9dxfwruj1LnZ9cBSg39GWt20bYK/YHcQ6342Ys8X9Rf3JplXLp6wHNTH1Jf\n", + "l9yLMYWy4Ke6M8ZqT4mP1GCIFBIiWcEjbyFSooCIWcYqfbg2ygncTxLLPvKpKUG9lyKGwZUooH3G\n", + "nrfJnOYKSiu1ykjEVNHpQ9VmHzPUK9GN+BfSfiiRzGm8Q5gDmEt5B7l/aaTmM958nDGHucpOvUXR\n", + "q1uNzPGUJEmSJEkykNFRe48FPDID8PlASYhyuwCrY/LgYCV4tBrZhX2/GasIHyCsAz7HKhzli9U/\n", + "VgHWnlvFfhK8n4zu8Dn23bG6sOypJ6wLtyLYV+f33IestCXrCWWD+1IOrCMvN8/P57GCUDqwoqhf\n", + "lAqUN7eOaW+s8dWKhtTXf61KgVLG/c444wxJvXV10003SVqbNRu8H0RWHf3YI83ox9Qj7YOyN9Sa\n", + "drAK8ZGLok0dMu6jEqC01UTbrQY1hkgons/rU1rb5tQZbcp3qVOPmuJnFBE7lqEKA8/hpy+0Kvw3\n", + "33yzJGnHjh2S1kYjtlLyq6xlqvoF5oRWRcqjGPlJv2DMlqLomMMXDXOa+6l6lCjtw1zDXMmcx1iK\n", + "djPcf9PV9eid40ot45D7c2IA7c8csdWVKEhFKkmSJEmSZCCPC0WKVa/7QvHv0n68n2XGqhkrxxUi\n", + "v57fF6vGo7KA1Tvfc98oX6X777FOI38NPudZkrHOXflw6zmy0lzZKYE1gzWCsueKDPd3nzGiDX0/\n", + "P4J6IUIFRYR8RjA0lw71iiJJlCfnl5G53f0KoJRJPfIrob2wJqmvoX4hJVAGUQJLSi7qD/3DVZ9a\n", + "PIu4q0pSPJa9T2GBo5YxRzBmoroeqpjQ5tyHcuIT1Jr7i+vws+S75XB/VE3aYqi/XVRfrdSeQoFi\n", + "hP8kCgtzhO8+RESRta7GoyzRb6hv/BpR2Sk/fZ05CvxdUPLfpd/4+a7uP8lcXjumeC7KQ7uvPiWg\n", + "Bu8vpTnYof/t379f0lp/4alwFZtxR72Tt2ooqUglSZIkSZIM5HGhSPnqm1W9WwH4cLg1g9WBUkGE\n", + "C993KxgrJ8p+WxuJwOfc98nhOp69OILroFzge8LzcF+sIfefwCrj9+6n4WcDRlBvWFv4+Hi7sM/P\n", + "/j7l5t+1VhDWKu3hUXjgOWOoz9pcOfgO0Y/wW+A6U/mB8ByRn8zYyCeHdsVqJKdRCdqX7zM+hvqP\n", + "YHW3Rm+uhjan79A2tXmJWsHypswoKfRh1MoSUd8Z2qfoozz3VGeUlUA99fqsVcTYJUBp4PzJVlyJ\n", + "8szijClXs4m65PNRTjSfs+n7PCf14L5N+OEyRnh38XlXpGhH91GLzg3lc1yP5yi9O/zvY33ifO6l\n", + "vkp5rVqhHsk9iG/bVLn3UpFKkiRJkiQZyONCkWL1H+VfwqKNovtQqrAKPEIjysyN9cFPVtsoU6Vo\n", + "Klb7WF2uUPn9eD7Pvuvl477s6/Nv8ix51uFSbhCeD6sW3yDOnItA8cKPACvErZzIamn1y8Aq8/xf\n", + "bgXzXF5/+CFE0XzUG+0Q+Q61ZgaPwCpGQcPPYFEcfvjhknoVx0+Uj3D/DurV84XVgl8TCmaUz60G\n", + "+mzJEo+Ico45PDtjbahvUwSZ1VthrmAOZAwuGvrQUIWPOYHow6H+gD7Gfa71PGQoRfQ9/FujdiTj\n", + "PKBqc1/6D3MZ9cJ9UN6Y43kXoQbzLuI6rs57VCrlpN2Zg4f6JI1VpByPvJ4K5maUKZS6qXyxUpFK\n", + "kiRJkiQZyONCkfK8TYBygGUc+QdgdWBNuPXjq2f+zb6z52nCaiBqDGsI3yP3dfF8T9H9sA7cFyU6\n", + "mZxyoLRgBWHF+DlgQDn5iQ8Z1mytzwpnEpIDxaMAwZ93bLbiknqA9eb9pfQ9niPyvYLW6MYI2nlo\n", + "NupWUD1acw7xecYZ+bXoJ6gAtXmlyMjPCQND/GPos1yDSMuSyokiACgG9JVaXyXGOGPIcf88oA49\n", + "1xtE+YQiyP3GHIOaHBHNUa1M5SdYG50X4UqS5zdiboyi7HwOd3zu9bmTMeDnjjI3e7Qg+P08XxS4\n", + "4uJKKM83VNGMznMdCuWd2r8TnyjGL+MmqrdWUpFKkiRJkiQZyONCkYpWt1gVrEojRaqUJ8fx/WoU\n", + "Fqw4FA+silKUG+UiX5JbxZ4Dp9bfA6sXq9qjq/zkcC8Pygv77PjsRAqYQ73cc889kvrnG+o7U4Ln\n", + "5LloDyKoAKvefev4vEd6ofxh9fB7IkS4Hkqat99Q6Ee16sNYeA7P5F/C6xF/BdqDeiopUvRPxjPR\n", + "syh/hx122EHFwM9+o6/RRvRZ+kKksnkkr/dNlBzGMn5jJd+R0hl/0Rg+88wzJfVjjXJxf9omyuoP\n", + "qNvUC3WPKrxt27Z1v7eZZ6RuBq6M+TuAfuR+fh4pXQv1h28T9e3KEQop/ZfdAtqz9rQCcvT55z3v\n", + "1FAFqPV0ghKML3Y3/LQN5oxWON/VTwS49dZbhxd2FalIJUmSJEmSDORxoUiVWFTuFM8azOrarRjP\n", + "W4R1gB8H0VLke3IrFouc72PdYC1HChFKBtYJ9y1FTFx77bWSegUJsKJqrdavfOUrknrrPIqgQD3w\n", + "DPDu31Aqt7czfgdu5WCNH3bYYZL6esSfgfLSHvz0aLxzzz137vuUf6rIqKlyrJTATwPrttWfguhQ\n", + "t35R1Gqj/1ACiU6kPqn/M84446AigwVPn0JNow3JZk+fjfqO++D4uX6MrSiPj0NfRs31KKuSDxJK\n", + "xp49eza8Twnq/utf//rc7/fu3StJWllZGXX9rQLKG5Ge9957b9P3UQZpN8YC7VPym8QHDTyfU9Tv\n", + "mDN4Z3j+qVoi9Zu5cGx0nCtZKGzMFZSfcUL/jfxbiRz3dxLXHVpeFCl+Tu3blYpUkiRJkiTJQB4X\n", + "ilTJB8mz2UagEKH8sMrG6oFvf/vbc/9GOYh8jqLzpfg9+7hYR+4/gdWBgoJVixUTZQxHGePzPD+f\n", + "c98f8Ky6UOsbBVgHjkftoS64IjXWmsKqpH7PPvtsSb3vDe2IiuFqRslP4ctf/rKkPk8W/YD6/JVf\n", + "+ZVR5d8seM4oitPx9rv88ssljT+PDfUGn8X1fBdRoMhY7Cqvny7f2od8rJLDiuszF1BWt9i9DwMW\n", + "PBGJ9E2y5IP/e9H4WW9EWOLXRn2gxkZnlqHMHHfccZLW+ikCcyx+q6j1fK412g8Fieu2qrj4QqGq\n", + "8rOWaK6E6Hnov/xs9dMFFEaHfj/1bsz27dsl9bsVnnMxwvN3EYk71RmOztRRgalIJUmSJEmSDKSb\n", + "OoNo1U27bvafZQ8+SZIkSZL/3KysrGg2m62bwj4VqSRJkiRJkoEszUdqZWXl4P41qljkKwRR1l58\n", + "Vzxj9Bvf+EZJ0i233DL3dyJv8GN45jOfKan3d/jSl74kSdqxY4ckaefOnXPlY/+WaCOyI+Pf4Gob\n", + "PlpEjuCDA/hVEJkQ+VE43Oe9732vpL4eazN+4/eAT0tU/5Trd37nd+buu2i4z8c//nFJ9WfU1Z5/\n", + "BkTtveENb5AkffKTn5TUR6fRT/GXiPI2Rb54+IPg64U/wPOf/3xJcX2+6EUvktT7ruFzBa95zWsk\n", + "9b5c11133brXIefQRRddtOH9pob7tN4Pnz9+ls7Sw+fs9a9//Zp7eSbqofiZbNzn/e9//9z1fez9\n", + "6q/+qqT+3EnPW+M+Qc7qZ1t93yi6D58mfJKY+4CxTh/Ehwc/Pua0Sy+9dO5+i8b7Cn6d+AhNxUte\n", + "8hJJva/WVh8Li74f78JW/1bAh+2SSy6RJP3hH/6hpH5OpX+WfMWIouNdw7uZfk40H75NF154oaTN\n", + "r8+IVKSSJEmSJEkGstSoPRQfrD1WrVGEQqQEEG3FqtbzG1155ZUbluO2226T1GdpRVHAGqJcKBwe\n", + "fcfnUKQcruflgpISV+L444+X1K/WseBLikytYuNRgiiAU52cXYLIq9pzvmqfC6LIFdqtNtIn8jdE\n", + "xSDXUG1mcKLl/LooZKgPX/jCFza8zqIiX1qJ8oE5z372syX1SlykSBHptrp/ou4ypqjrSJFC9cIC\n", + "xjJ3BYo+72O1NAaw2KPzFVELI0UqinqKxgB1G9UxdeoKQa3aWwIlAmWB52pVmFDv/fPRGYQobX6u\n", + "qqvEU2Vmpz25fu1pEluNoUoU+Nzi70jPERcpxLSXR9MxLrlOdKbhsklFKkmSJEmSZCBLVaSuv/76\n", + "Sa6DLwurYaygCy64oOr7WBNu+aNwsbrG+sQqZd+2lkVHSGLdcp8oi69njQUybmNV4gsW+fxsFpST\n", + "dop8kbBK+T1qgytOWLWoF+7XgnI4tZVJ/6n1YUORImcPoMzhM1XKDD6039EfUOTG+hu5ShL5B6FI\n", + "R8rikUceKalXH8hOLrUrRuCWuVu+0Vl8Je644w5JazOYU5ebPZZqc+a14v6r+AMyl/gpBCUihS4a\n", + "kzyPz2m0G/U/Vv3nOXbt2iWpz+vlGfAfr/BuYe71uQl/4tq8WKjvKMtbVflLRSpJkiRJkmQg/yky\n", + "m5NpujZLK5EKWPaRtYQFHe33EomDj1JEtK/fivttAPv+PL9b4ViHWPKUhzPK8EHheyXFYaxV10pk\n", + "nTooLzxfZO3TDpHP3VTtFVG7z49fCf0TNYF+WHtGXe1J8Q6Kz0knnTT376lOTI/6WZQd21nPf4ho\n", + "tNpT6aM29rHGdaM+E3H//fdL6tU9IkpRQz2qrsRZZ50lqVdeKI9HAjPHUccoMlMrUUQ8f+QjH5Ek\n", + "3X777ZL6jNp/+qd/uuH3ozPPpppjaF8UjVYfG/z6UFLweWOuTCVqHj9f1v1aUZiIRi1lPud6zMl+\n", + "LupWIRWpJEmSJEmSgfynUKRazwvCKoQowsXzMpFrxfNeRVYJVhCWPNZQq1XI9/GB8jPqUCYinyis\n", + "V6wqVvcoeYAVHkXEbHVoF6zv2nxcztjcKiVozxKoCfz0iKRaULacUvQlvodEdEXXGcrQfoV/ET9X\n", + "l+voo4+e+xt9wf0bsZT9HEWPQmIMb9u2be46EPkbAtc7/fTTJfWWOH5nrdFyKFBu+TvMWfiqUO6o\n", + "nDxH5E+HgkZfZGxQ935+JPUWKVKeWy36+1goB3N+q68WkeXM2fhPRueEPt6hfiPllt/j98k7MVLN\n", + "3TdxrALIeOFdzhw3lsfGGzJJkiRJkmQLslRFCoWklLm4FvZPfRXr+7Ge2bwE+Wr4HqtiVtNuPbHq\n", + "RUEi+ojft/qsYA1SX55bpeS3QXnJl0V5icqDKDJiar+KyNcrojVT+djvRzl/pqI2r5MrmEMVqciv\n", + "oDaijfvX+qpFeLsPjYSjPfFbcv+g1ddGaWLsoaTgs4EFzRjjc4wBxg5j1vtsqS24D9dBBR6qaGBB\n", + "l9qOclJXKElReUvP4ZHL8LnPfU5SP5egUEVRWYwtyhfN/cy13K92rnYYM9y3dS7juVHs0idqY6gv\n", + "V0r9FA1+4jMVvRPpt8yZY3dHaP+p8qZBKlJJkiRJkiQDWaoixWq0VaGIwIpxq8MVI6yFQHXZAAAg\n", + "AElEQVRCfu/RQ4cffrikPtIGawS/BhQg/BDc54rrYuWhhPDv1ufF14fPR5EuJf76r/9aktaccQj4\n", + "jwy9fi2t7VyrJKEAkuOF7xHBRZRliVofJvobn5/aWqU9sMJa/TsAtcXBT2Bq6yzC+z3jtNUnjXFE\n", + "tOxqhdbP03RfKZ8buGfp3rRtazZ/nhnVrHTmWInW+9P3x541WPJDJZ9SidpyMLcOVaLAM9y3jiHm\n", + "XsbK1Op8LVHuvK0G/d0jqD0HHXNz6V3gGemJmhzL1O2YilSSJEmSJMlAlqZI/dAP/dBgJSqKNmIf\n", + "1X1QiNAB7osV6tYK1hfXIWsvn+PfRMu5fwEKAuVkNc79eF4+57k0ovrAKh5qpZXyInnm8KlYVDZl\n", + "hxPvUQjJk9XqW1Xrg+T9oBbvjxH0Q8o/NB+UqwD0f3wHUXRq82ZhFbae4ef+SiifHglWApWAel89\n", + "flAymBvoy9xjaB9E2YhOP4j6DH2xts2nZqwSBWP9FFuJ/OdQGqnv2vakX9SeKgCMDVc4p9pFqZ0b\n", + "PUP7VoXdDsqJksTc4pG/JV9B1HTmmkVFUo8lFakkSZIkSZKBLE2R+uEf/uHB1mFk/dVmw3UrAh8X\n", + "V6QAS9rPZsMa9VwoWG+cJYZViKKEJc19aq0a7j82qiyyKqPzqoZC/VAfQ/M61YJ1g0KB38ZRRx0l\n", + "qT8bcb0or9WguNCfvD7oJ9Rjawb0qL25L9Ycvnzbt2+XtPbsu1rcLwdVZWj5UbJaFSnvtx79WgtW\n", + "Kd/H6pX6NkO9w5IfqwhxL7eIS5GUlGdoRmavs2X5ykw1J4yFvspcSLuUlB3aoVVRI0rSdyWY21p9\n", + "1pyovChgPNdmKYFjYU7gHcnz8W/eiVDqx7Qb7V3rv7rZpCKVJEmSJEkykKUpUg8//PBgK6fVgl1t\n", + "sUq9lccqmdU+q2VXttynCmUF68gjCbA+eT6+x2raV9esyj06z8vL6n5o/h3gOVE2vH6mgudfdBQg\n", + "YC2eeuqpktbWZ+3+uvvVOLRXa0Z9iKxL+oWfE0d/oh/WKlLUx2mnnTb3e/pRq28XDP0e/Zh+wU+s\n", + "/Vq1BYUYJXj1PIJCQdvT9/jOUDhzrXWs8CxT+bdt9agtotvo40PPzKNNvU/Qd5nDqNfa3Q1yAtbC\n", + "fRmTHgW6KJireE7qoVUF3myoLxQ15l7GDbsGJ554oqR+ziv1E8YBavhWIxWpJEmSJEmSgSxNkXro\n", + "oYcOnlu0aErKgVuNvt/OPji+NW4lesZnrFd8XFAQOPfKz7grwf3uueeeuXK24idoY+VMlVk+YrOy\n", + "AbtPFnmlUA5rc/jwuakinhyPXMGKf+Yznympb2d+/8IXvlCSdN9990mS9u3bJ2ltFBztyXlzWN/k\n", + "RXOGKsKtkU9E8mClAv2RemYcRv4uqAEobXxvdbZjH+uMRfzkUIGpyxL0IVROr7OhfplT4TnsXAFo\n", + "JbL4Ud1LcykKQ6sfn8NzefSXZ6hnTqVd/Lnpc5GPTi1E7zHHtPoVDgXfPp57sxSpoeeN0v6MN+r9\n", + "jjvukLR2Lq7192XMbxVfPScVqSRJkiRJkoEsNbP5ZuWEcGUByx2fE6wUVtPs72MNHXnkkXOfx/8C\n", + "a/Wkk06auz4+JB4dNlTh4ARyyj30nK6f/umfHvS9xwpYN1/72tck9dY5ClykpHgkSKviMpYzzzxT\n", + "Um+F8xwoNNdee60k6Yorrpj7HuqBK2233367pF6NQcF81rOeNaqcWMdu9VMOyu1qBKqBR22iOLnC\n", + "Gvm7MH74/N69e+eu+6IXveigvxVjlUhN2hhlpZT/ic+jRhO9NVQNnsqnhrkIxYBn9+z0nMtJmzAn\n", + "lXxtPKcdlJQo1MUDBw5IGq/AkbWe0whoB/qG93nmcPom5SHilbl4qF8jbLYiQvsuSh2PGJpLkLFO\n", + "/Xs+N/A5gnHL+ZmcwuH+pEP9MxdNKlJJkiRJkiQDWaoi5aAIsYqttWrIaM2ql4zWEb7KxZqLzhyL\n", + "9vs54Zx932OOOUZSb816uXg+9osj+Pxhhx0mqd9v9pPkoTbrMNYCn0fxqI2cWBbkT6I/0D+oZ/wH\n", + "sBb5PdYN30M5cavb1YLTTz997vd8nvriJ/WFtUg7uUKD9Uz5jj322Ln7YcXzXPiscR1+4idA+2HF\n", + "uXXO52lvf176Jb5T3J/+gxXs9eV+Ifhg+ZmZrlhFmdlL45v7ez1vpCrgV+aZrDkfkzrctm3b3N+x\n", + "dHkWno02RI1zn46dO3dK0kF/T/cloi4i/0jakO9Rh9QZyhJwn5LCxVyGGks5hipFKGHuv0Z90SeZ\n", + "E6kv5hbmZH7PGPVdCfwEUfmZe3neKFIaBcvzRVHvnt8IjjvuuLnno33oD4xJrhep1dQzcwPPN9RX\n", + "DcWR/sq/eZ5FKzNDd4vwJaSdKCcKMO80dnNoX/w6gbGOkrjo/FEeQR/1s4hUpJIkSZIkSQbSLSMv\n", + "Sdd1s5WVlU2/b5IkSZIkSSsrKyuazWbrOo+lIpUkSZIkSTKQpflIvf3tbz+4nwrso+PPUAv77vhU\n", + "sL/7hje8QZL0J3/yJ5J6Xw/8HNj/Zp8f/wH2w0vZcvFlIjrqda97naRHVq6rYX+bvD/kJImu5yoh\n", + "/gf4CrF/e9FFF0mS3ve+90lafBQkz7VZaqLfj3b2DPTuA4SfDPVFxBX+J/gZeHtQn5v9fG9/+9vn\n", + "ykf74x/h7Ypfjp+sjv8Kz+s+c8tqv0984hOS4jxe+LJ5RneH/FvR+FlZWal+NuaAUjQUbcLcQJu8\n", + "9a1vPXjPzYD7vOMd75BUnpvo4z//8z8vSbrqqqskxXWMrxA+Tv58iz7jb9lzC+Dnii8PPmn33nvv\n", + "3OeYY/B7jKId8f152cteNnc/fIbof94PX/nKV0rqI5Ddf5e5EF8++gP+la31ecEFF0iSLr/88qrP\n", + "O9H9asfZ0Pv9xV/8haQ+ys/BF8vnHuqPesNHKopmLdVjKlJJkiRJkiQDWZoi9bSnPU3nn3++pF6J\n", + "8sgOj3hg1YgChBXAqp8opK985Stz34usMK6HIlWrRAFKUSnaDUWBn1i1HgESWXuUCyuIn379oaDM\n", + "jD3JHEonsQ+F+n7qU58qqW9/twaxEok+8/xFKFooVmOjFXft2jX3b/Ib1YL1S7+m3ogE4npYSx4d\n", + "iDWG9cd1yN6NOrEsShnlS0oURErUehB5iSWP6kUdkeeGqBxUPeoeJYo6p45POOGE6jIsAuYO5ooo\n", + "r9GrX/1qSX3dl+rYFReHOZL7+2kOU0HfpZ0Y24wF5jpvJ37SriiIHn1VygzOXMEYi6IcPYI4wjPP\n", + "QykfFX8nh6ArUvydfsnzOyhWpdM0xp5FGVGrRKHQsXsTKXxO9Dnqg+dHpWfc+NqC35fyy0WkIpUk\n", + "SZIkSTKQpSlS3/nOd/Tnf/7nknplqOQbxWqV1SSrRvLToGi50hOtMslNgnXF50qw2sUaqf0eUD5y\n", + "rHA9rK5ov/fb3/72oPuVmEqJgqmVKMBKxXqK8gmhiEVWGMoGis7Q86tQTp/3vOdJ6q2vu+66S1J9\n", + "DhmUMfoDVjdWElYt5bzuuusk9dY7VjT5obgemey9PdwnCcVq0WcikmXcM/4D/d99Faln/HRK+dKk\n", + "tYqJn7WGhU8bYbli4XIP6mSzTmEowRzIHMDc50rNpz71KUm9Je7wvFyvdFpCqW/g78o5kNCao87V\n", + "YxQwFCXaizmAXQjyETF3uk9X7f0ZU14e+iB9M8qt5qw+B7IFxvi5554rqffdeuCBByT1YwmfqEg5\n", + "KylRvHv37NlTVS73GZwK3s2tSlA0LvGN4txS8pNFz0kesW9961tN94dUpJIkSZIkSQay1MzmWBG1\n", + "+7NYI644YeGyOndKq1yui9Xj+/RYt1juroTgP1ALVoqflM31+TsRNM7UClKJE088cdT3sXr8/KVW\n", + "aEcUpejcM6zHSOHEykUBGZo1l35z2WWXSer7S6REYc2hhEHk40V9UU7PuuzZjYm8oj+ikLki5dbk\n", + "Zp1kHylRQLnI/M5zEHHWAs9MHbivDG2Ahc+cgoWLWs33+XdtpmMHBQn/RuaU1rFAn6YvcV1v40iJ\n", + "AspRUvdKCgQZyIlY/vjHPy6p9+tr9T9kDJF5/v7775fUz4WMCcrF9d1fkHcKn3d1N8Kz51OvKFzM\n", + "zbXRizXq6Xowh+DvS6TuU57ylLnr+juPuaIW3kGl/jKURUXtgWf4Z87wkwVQYF/+8pdLkl784hdL\n", + "kt797ndLkvbv37/u9WvrMxWpJEmSJEmSgSxNkfrxH//xg5YnCgNKgu+TQ+T7RBQX+/i11oL7GmF9\n", + "YOVgxXK9aFXdul/MffgeJ5zXKjaueLBqjnyG3BrGqsEqLvlH4HMzFPL/UI9DI12wNrBC8O9wX6FS\n", + "lBhWGM/FdYDfu58F555xfeo7UkId2smjLvFV4n70c+qh1j+HfoXChZXJeW7gStZmK5wRtAP12RKl\n", + "57hPCW3ovi20KUoPygdjBKUDlXDo2WkeZTUU96dz1Zoz5/y8yS996UuS+r7AXOM+IT72SooUc8vJ\n", + "J58897M1ctXLjyLlfnF+ziZzAWMq8qNjDvKzEh1UU8/NRn3T/pEa7rT6X3IfovUY01yHOQQfoNtv\n", + "v33u+7R3LbRrKVptqB9lSZHivuQ7u/baayXVR4V6P4jahfxYvEPYBfrmN7+54fU2OtdzNalIJUmS\n", + "JEmSDGRpitTDDz98cNWPdYQi5VYQViF/Z5WIvwKrZVbjJUUCuD9Wmp9I7deJrIuh0U5Y3EQMYDWX\n", + "TvZ2q7i0asbKYPVPPWJ9skpnNc+qnPrxHCat1OYJArcmsdJQHrES/UR2+k3JmuG52Tf3fXBXIbgu\n", + "1qFHjdZCP6W/e3n4O+3A/dwPIIL+irVFFF+UY2azod/RXu7XgwqE9eoqCO1dU++0EddCyUBt5tqU\n", + "yTNFY0nTFozxReVPqqWU3R0Lm7kRlY8+h/IW+S5F+XUiyPyN8heps0SQMpZdCQB8VSKfFWCOop1Q\n", + "1aPyUl8llZN6o28ytzLnMDe4UhTRqkjRLtdff/265cK/E8XV8XeRK038m+hV2i+qN96NjM3Wd11t\n", + "vqzdu3dLalfHfW6McjTyLmM8R5nK8a2rnXMhFakkSZIkSZKBLE2Reuihhw7uR/tqGWsRS519c6wC\n", + "LG8sVDI4Y63VRiBwH1av+NpgnUbKlvvODM2bhLXMqp9/l/wShioM1BM/I3g+fkYKme8nLwraA+ua\n", + "56fd3NouEZ1bBSiSHk03NOstYM1FGe393C3uH/kMOvjLuNW5bB8o2qvkX4QKgbX97Gc/W1Kfm6jW\n", + "X0Hq5wpXKxlTKAVY5LQp96Dvo1ZSp2PPmuO6WPilPD/R93k+xiD/5jl4vhtuuGHd62Chn3322ZKk\n", + "G2+8UdLaOQcLP4rsZCy9613vkhQrTaittVGPpdMRmHOmnnsYc9Qj9eG5zVDHUeB8TEeUziyM/k57\n", + "8pN3nOfpcgWMqEp84fA9Y47hHVc6VYOIYJTHqfNI1c5xjj+/t4NH1JeiKGvb0UlFKkmSJEmSZCBL\n", + "zSPFqph9bl8N+r9RbrCS8L1h3xslwVfLWEFEP/nf2TfF/6GkaGHpo9SMzTSONYiywnNiBbolvui8\n", + "P17vrsxgLW6W7w31wv417YdChRLl1kakIGFFHjhwQNJaVSCKMMFaHApWl/cX+iX9GOXGoxRrcQVx\n", + "qII2Fa31RnkZ39QbVnPkB7HePfkMfYVr06ex4L3vuIWO5evqZS3MGSgZEN0/gjkOlZHnoq/Ql73P\n", + "uHrM50t5cmrLxfWjCGLao1bJYM6ujY4bS23Gbuo9Upcd7/v0qygKznPMRSo7Y4N+CV4e5jLah88z\n", + "hk455RRJa6P/gPpgTqLcter/oimdl8p4r1Wahs6VqUglSZIkSZIMZKmKFNYR++Bu7aG8sNokVwhW\n", + "D99HscDKcl8MPleyNvAxiawwlBj3OWF1PxaUKM6P4mw9Z2guG6CeUEJaFS6e18+RWlQWW3zlsOpR\n", + "KKivyGrFWsEPBtx/xiN56IfUD88zVpGi3r3/UP/0O8+iTXlq253nY9ws2oetRGt/QDGMIsBqrEss\n", + "feoWSxPVmb9727oS5RnOh/Zt9xPjuq1jGUXKiaKpGCOuIDBmyNszFhSPc845R1Lvh0neLNoBxYW+\n", + "HUW1jZ3jWqH9mdt4HvqavzvoB7x7ojk0OjUhUj54blemHO7n7er383J6zkCiKfHZczWb73O6gI+9\n", + "ZUcEl/pJNFdE49198mrn/FSkkiRJkiRJBrI0ReoJT3jCwdUzq0qsJ1aBWNQoElgvfA/rklVnZC3W\n", + "7o9idbBKdyUDHx23osbuF3M/Mr3j9/Dggw+u+/mxkUMoetQr5XcrCWvDT0Rn1T40wqEVnhe/CxQd\n", + "slLT7iiKPEeUEZw8S2QP5jwvQPly3zCuRz9ojYYjqhQ/A6CeaXfql+eIlNbSffDFcj+KrQqKJtbz\n", + "GFWCtqNvlKKCIjWVPo6CNNQ/0cvDs7VGP7Wqk6W5iT7t0YCt3HvvvZL6evaM6yhQ7uMVsdkqKvVK\n", + "PZTyJTGH0n7R510hYqxHihT9jTHLLkwplx9zis95Xi7eXdQ/ShTRfFGEts/1rf1wUeArxviln0UR\n", + "vrQHP0s+gLX+z6lIJUmSJEmSDGSpmc19NYg147/HukEJwEL3fEhDc1EAq+vIKvMow6l8gVjtu69P\n", + "ZP3WWrFRLhaui9UXWUfcx8+nipSoRZ3wjVXm5ylhVWGFuQIT1R85Vcim68oj98OqIdcKChh+FH5O\n", + "WQR50E477bR1y4V1h1WJVYxCi3LI87tS5jBOuK5HirVS8gOZCvoP9e+KcwvUIZYnY4C2Q/3zscfn\n", + "8VHBYqcPnHjiic1lkfoxxpisPT/RoY9PrQSg+g7ND+R5jpxbbrllWMEmJvLpoT9QD1EUGDAWSnOe\n", + "z72l+uXv5GtCXYanPe1pknplj34QKWJEoDMn+DsGP8TWsb1sJQr8nN1SrjnWDlF9+VxX7Zda9akk\n", + "SZIkSZJkDUuN2vPcJq5EsQ/N51hFuo+Q5xeK9tex+LHUUS74Pfv8Hi2EdXv00UdL6pUvrBZ8aoaC\n", + "0nHYYYdJ6q3XSGGrzWXD6hqrm+fgPoAfRZRFuPWsvKm566675v6N1UF7uZUV5bJx8DtwKxq1YPv2\n", + "7ZKknTt3Sur7IXm/ajn55JMl9daQKyzUP+XwiK5SdKJz6623rvv76HypEotWovz8OFcIUZHwbaO+\n", + "qE/G/2r4LMoSSoTnJOOeWO5kVSeTs6vQYy3xoUoUtGR330xqfXlqKUX1odKiJDFmeEfQvmT2pk9F\n", + "ihTqZxRl53AqR4naTO4Oc3F0tiNjJopIBvpvNHcse24fS20eNsY1c0c0p9E/Wue8VKSSJEmSJEkG\n", + "sjRF6id+4icO7m/iA4VChA8IVgVKCkqN+/Twd1bxrqywGiU6DqvQM4lj+fr+9KGHHiqpV6CwEvxE\n", + "bvDzf7ycXBdlyfM6RVaCW2ElojPdyH7M/YaeFbhZoDTir0J+KKwvrAeep2S10w+4jvscUW/0P9qT\n", + "ctRarUB/cYXRlUxXUvn8WN+/VlBxeH6stCivk7OeQiT1UZL4+WAlY1V6ziPqmYgirE7GP+NutQ8f\n", + "dcoYI2+O+z9SRr7L5/k+90BhYeygRjKnOMwp3Ae1+5BDDpHU9zV8rnhmzzM1NDKU66E633PPPZL6\n", + "OYb710ZGou5yXRQf5i7aIFKOmPOISGZsUa/R/T03IPXhudWoZ8YYY4jnp57xKSrlZ2Iu5Lr85H70\n", + "Qdqr5CPlf+f+0WkRnlMRpY9+QP1F0WRbfS6fmkhpo996xLPnDGRcRpHrtaQilSRJkiRJMpBubE6i\n", + "QTftutlQf40kSZIkSZLNZGVlRbPZbN1U56lIJUmSJEmSDGRpPlIrKysHo9WIPBi6v4vvEPvW7Jui\n", + "epXUryOPPFJS74txxRVXzP0dPwd8cSK/hdr7RdSeQO73e+c73ymp34/H94d64bwrIK8RUW+uSuIn\n", + "wn4y7VL7fEcccYSk3tfL951r8xKNrc9S5E90v8suu0xS3874ReCXgJ+I++bVQvu89rWvnbtvBL6E\n", + "/Ny7d2/T/YD7fPCDH5S0tl6i86daod+96U1vmrvv2OtHedH4/aWXXjq4rzglH6WxfbOV0v2mipoj\n", + "MvllL3uZJOnOO++U1PuQnHDCCZL6eiGXH36k+I4x9okgZQ7lc/wbf098WpjLGGulaCzwvhX1FYjq\n", + "k7mPdxPl2LNnz7rXwZeJn/g+eUR6aexNDff7/d//fUn175Sh/cjrkzmO9uPdRP3iuxbB3I3fK3MK\n", + "/eSXf/mXJUkf+tCHJK31+cNHjn5a8u/k3ct9Pc9UaZynIpUkSZIkSTKQpeaRqo0CKlFrtUQQ2cOq\n", + "2fPalM5dGgurdJS01uzCHhlSivb65je/ueH1SnmlIrACKU8UAUHUHNF1HsHiJ24TeRFFaESZ5rEm\n", + "W60/rkO5aA+PMBqqrPjZhSWw3qPnQEWgnH7CuxO161T+ktF4HHt9j6hqyfnSGgXHHNAaNbcsaiN5\n", + "S6AYwTXXXCOpb9Mbbrhh3e/dfvvtVdeP1FQsfsayzwElXJFq/T7RdMzFlKN01ppn46ePehQmLFqJ\n", + "cpgTqA+iLKO5eao8YERJUn8oc7Xnfno9MfejSEGUgZ7dllr8zETKXRvFt9SF1FaBwcfCLgpvH3pQ\n", + "I99DnmSBhvzJZF3baFwnYmwILGkGGFS1kxL3LSWro9MyCFyG9xduKYkhLxEfVB7qWgvtUtpKqz0q\n", + "yBeCUZK9CJ7ft2iBeistoGDoMSBbBRaWhIKvXkh5m9CGvECoI09pQts897nPlbR2rNOGQ40/krse\n", + "OHBgTZnXgxcxiUFLUH6OEKlNGAnMKT73scVVMr5aiVJkRCluSvicx1YPC6PSAgGjif7DnFJKWEk7\n", + "+ruD+377299e93ulrcepwGhjAUPi2Vp+6qd+SlKfMqcV2pH+7As6T9ETpQ7y6y2a1vvk1l6SJEmS\n", + "JMlAtqQihcV5zjnnSOqtSBJ3RkfAgFs77izO35EfHawZv8/QZHl8j1UuVsLP/MzPSOqtZxwzS8pC\n", + "7bEDrc7r4FZL7ZE0JUjq12rVl6z3sQqLHxvB1mZpK6r2kGa3brh+LZESBX6odAnac6x1F1nVUX9B\n", + "1fEjcFpBPVhPKfW+wBaB92m2QxmLzAUESlx11VWS+rbCgvY5gb7DdSK18cEHH5RUf/QExwrVuhWw\n", + "Tc7c1Qpbd1deeaUk6YwzzpC0uIPIh26ZeqLT6ADv0nFhEDmp0660WwTq/fe//31Ja+fmqP42K3Em\n", + "5UNxbFWkhipR0e4NSjBBC7QfW8alw6K3ymHJTipSSZIkSZIkA1mqIoWFijXk1iT72uxXR6t4D0F1\n", + "RQqrgNUsfhORIlWylvh76z43Vg8KAv4S/D6yZvk89ykpCThOYkUPtSpgqOJD/VAed34fegyGM/b7\n", + "/nyt/iUR9NupDv1FbSBNB34rHGlUy1QH30b9PnJ8rj10me+jGu3fv3/dz62nGPrvonvedNNNknqf\n", + "IhSO3bt3S1qrCvvhsEDfKfm9tSo7tc7bfv3IF8iVCdT9Eq3+fK20OsmjIDGnoAQyx6FAMuZKxyt5\n", + "f+F6hOczt7hytWvXrrnPf/nLX567/9g5dyp4B9A/okObS1DfvHsiv1V8nLxecRLnOnyOfkk77du3\n", + "b8P7b9UjcFKRSpIkSZIkGchSFanIWnQPfw+rd1Ca/PPg4djsZ49l6OoYK6+2HOy7oySUFBisMbc+\n", + "sJ5aD8Et+RlEUD9+P/xQIkVwKLWJPjeLUrRhK/5cUeRLiUVHDLWWx6HeIiVqCpgzIjUPixnVdKzC\n", + "QDTXovumH5pM9NhLX/pSSX0UWaRIeUQwKv9UKqbTegA4CmCtotaaBJa52d8Z1Cv9gWi2yIeKdxWp\n", + "XpYF/ZgxOTTyHF8m0jygJLn/JrsnPgeg1KH00j9J6IpvFFGi7kdL+03lIzXVbgikIpUkSZIkSTKQ\n", + "pSpSUR4e/BXYF8VCrY1C86ghV6qwgsYeWcGqtlV5aL2fK3euEKE0sapn9e8RPJudDC4C/4OhSlcE\n", + "PnfUR6vv0GOFsTl9Fu1nMNQPYyuAIkN0EXmE8OUZGum46MSeqJP4fOHTxX1Rf/lchCsxrT5MrZHC\n", + "PkdNrZa2zrXUF8oH/eG0006T1D8fc1ikSDHX1kZYLwreCeTU83ct78Df+I3fkNTPLdddd92G10M5\n", + "ckWKdyvtyHhBoUIRjaItUbpckaLcrRHKEVMlH4ZUpJIkSZIkSQayNEXqSU960pq8QqyOsWawDviJ\n", + "dRD5VrH6daWDdO+eUXvsqpTVc6uy0rpP7dYZygvwHPwe68NX/WN9V4AIjKF+E1MrUYAVuCh/jqHg\n", + "p7LoCKitgo/Pqf0RpgT1mzFJ3+YZFn081FRQx54ZHAv+rrvuktSuMLUqcK0Rvt4nlh2V5bsLKHQo\n", + "k5SPf5fm8KF5vaYCZTI65QHliEN+UX4iRYr6iA4d5l3LO5Z/+7FbDgqwHwEDzO1THYU0tf9qKlJJ\n", + "kiRJkiQDWZoi9WM/9mMHrUFWmayOWfWSVdj3XSNY/XpkDN+bOisq92mNPGk9UBPlC2sPJQ+wejbL\n", + "N4UDXbHOavMDLZqpFLda6G9Y/dFhvVNZpWN9+mBoxvuhML4XpUiV5oWNQOXmJ326VRlhDnCLfCgo\n", + "TLVRflj6bvHTV4iWOuSQQza8jh+oPbUviePKQOQ3O7Tvcz3aZ6gSEZ2ZF0GfnzoyuRV8tCJFijmA\n", + "Q37pd5Q/qq8o4pwoQRQklF7u43M0ShS+fVF98Ryt787NojgDdV33Z13X/X3Xdfes+t1K13Xf67ru\n", + "zkf/+9lVf3tr13UHuq57oOu65y6q4EmSJEmSJMumRpH6/yT9T0l/sep3M0kfms1mH1r9wa7rtkt6\n", + "qaTtkg6RdHXXdUfPZrM15t2//du/HbQ6sIKwWP0srtIJ3igkWKbui4JVxyqb6xPBMtRSxsppVUKi\n", + "Vb5HrPj+MvmY3CrDJ2izFCmUF9qFco71AcLqmDq6cGj+rBL4j5BTJlKkpvLZms3lJe0AACAASURB\n", + "VEodYBwsKorTFaLIL2IqxvjV0DcYY7QpPiM+59DWURnGnk3nFv0YtU3q5zbmupKysmPHjrl/L9rH\n", + "xyOsPQ8WczWKIQpT7Zg6/PDDJfXtfMstt2z4eXx0UD687x555JGS+ndKdAqC764sC3Z9ShB997zn\n", + "PU9Sny8qytfFHOLPh/Lkp3HwjqR9+Tt+vShh99xzj9aD64wdD4uiWKrZbPYNSev12vU0thdL+vRs\n", + "NvuP2Wz2HUn/S9Lpo0qYJEmSJEmyRRnjI/WbXdf9P5Jul3TJbDb7P5L+m6S9qz7zPT2iTK1h9UoZ\n", + "RYPVP6tc/AxYjeIz5UT7v4BVwz35yXVrs+QCq2oUmdK5WChXpWg1t6w9AgfcCsB6mjoSIQIFEAUJ\n", + "62SoIoWVgRU+Va4QrFj616Io+d5N7RtU8l8oMXV2bax0rHPOAgT3xcLajRTmMdDmtUoA+XBQgkoR\n", + "vZ7hHIsaP0H6Lud58vmSPxoW+bOf/ey58rfmDIv6Bkqa5+dxPO/R1H6lDrkCgTkVP1CiJv2cUvpw\n", + "bTvzbonagTm0pHQxV9FeP/mTPylprW/PspUoiOZk3/3AR4qxW9rdiPxiqQfeye7bhjJKxnfakc9F\n", + "192KEb+rGaqTfVTSYZJOkvR3kj64wWcX662YJEmSJEmyJAaZ/rPZ7ODyu+u6P5X0pUf/+b8lHbrq\n", + "o0999Hdr+O53vxvmonBYpbKf3mqJ8z32ybEiPCtrLShMWGslHylXojyvju/L8/vouq5Q4QfAuUVT\n", + "45E8WIluJaD0tebecSXO/UyI6KAdazOWozZMdbZixGbnGhqrPB533HGSpO9973uSeisfxbc1dxDW\n", + "Pu3oUaVOSYkisoxcPS20KgEoFMxFKDo333xz1ff5PJY8ai1Ky7XXXispfhbmIqKXKAf+fKUz/piL\n", + "UMmjORJlgrGM+utzzI033ihJOumkkyT1bbmoHGg+h/D8jFnmRvoo7VXbzrXRdrX+h63Re5uN+5xF\n", + "/c7nXJSkj33sY6Pu77tDUb1u375dUj/XbFYEcS1Pe9rT9NBDDx3s91FeLRikSHVdt9rj8ucl4SH2\n", + "RUkXdl33xK7rDpN0lKRbh9wjSZIkSZJkGax2CTn//PM3/GxRkeq67tOSzpX0X7uu+66k/1fSeV3X\n", + "naRHtu0elPQaSZrNZvd1XfdZSfdJ+oGk186CJekTnvCEgwUt7X96ThaUm7PPPltSvwpnNew+T9wH\n", + "6+tb3/qWpOEnuqNEDVW0gOfAOsDKal2do3gdccQRknprjutH1lt0rhV+Jli7rkjRXuxzc3+UI/wc\n", + "sHpRIGgnj0xy69l9mvDboN0crFbKQ/mwpiMfOp7Pzx+rPe+Lz2EtU98eodLqkxTdn+tRXtq1NXM4\n", + "/cvPoERN8SzO1D/1i0JM/VG/njOmFZ5jbA6mFrDE8XNErat9Bvo+qhxlJ29TpAjQhvguMReV1DpU\n", + "VnyduD8/vQ8wFvk96vUdd9yx7vV9rOD/Rl+jb9NWjGHGLNM9v/ecZfiU0efcR4rP8XPoHP14xX3a\n", + "6C+0X6REDqWUadzb38/cY/eB3zMuxpaPfs54bI3YjqIxI4oLqdls9j/W+fWfbfD5d0t6d1MpkiRJ\n", + "kiRJHoN0i85cu+5Nu262srKy6fdNkiRJkiRpZWVlRbPZbN3U6lszu1WSJEmSJMljgKWdtbeysnLQ\n", + "JyPyYSn5fnjmb4/2QvX60IceScDuvhf41rB/zH4vKl2trwb7wG9729skSQ8++KCk3j+CyAT8H/Ct\n", + "OvrooyX1vl5Ef1Ef+MRQLnxVvvrVr0qSLr744rnnXDTcp/V+0flZzvHHHy+pjx57zWtes+H92Acf\n", + "66sG3OeP/uiPJPX+M54raCzUx+/93u/N3beW0rlj+LW4ryD3ufLKKyXFWZ7PO+88Sb1fAbmMGI/k\n", + "SKI/e4Z0ItAuuuiiufu2go9blD8OGB+/9Vu/pcsvv1ySdPfdd0vq6+icc86RJL3nPe+RJL3+9a+X\n", + "JO3bt0+SdOGFF0rqMztTZnyR8P/Cp+dVr3qVJOmDH3wk80spS/wv/MIvSJKuv/56SWvzDhG9hz+d\n", + "5zPysUfUk/ua1BKdIrC6Llffzxnq/+f43EmUI9fHR4qf1AsZ2M866yxJ0l133SWpb0/eLfht8g7B\n", + "d+2SSy6R1D9fNKaiCFLai/5Ae3o7MHf4WKA/1ebpOuaYYyRJBw4ckBT78PFOe8Mb3jB3v4idO3dK\n", + "6n2C/F1c67PU+m6gn9F+N9xwg6T+Xcm7AP9Zn+P9fvjx0h9L+eBoN/7O8/nZjPz9N3/zNzd8nlSk\n", + "kiRJkiRJBrI0RepJT3rSwdUwESTkbCDSgPOuohwOP/dzPyeptwLIzorVAZGy5FbfUMXBrQOUJqKe\n", + "sNw9nxS/p3ysxnmepzzlKZJ664VVfGtU07nnniupX2Xv3r177u9Rdt6pqLWWUT48u7JDeRd1hptH\n", + "otAvhp5A70T1Ucr4jQKHFRtFNHn/d0oRKfv375e09pwurPooehJq88NF0N+x5kuK1GqrnrI7KEG/\n", + "/uu/LqlXrIB7XHPNNZJ6JcozpbsyUZvPiJxdHpFKJnMs8I9+9KNV1zvjjDMktZ/KAMw13qdrc4gx\n", + "lzAWaTPKg9LEHBZFL/rcydzGXBnlxkOB4qdDffOzRDSmUUW9/JST/sFc5FFq0Vxdq0ShnDAnlaJJ\n", + "S3OT5xsjahQV+UtfeiQl5KmnniqpV/7YBfnbv/3buevRvsB1mTuiOQqlifaJlEAUMZSm6B1FJDhz\n", + "NYokiqvXN6o6awDKQ/1w/9rowVSkkiRJkiRJBrI0Reqf//mfD/pqOFhtpZOrsQJYNQ61zkpE/gQR\n", + "vj+LleKrbqzZz33uc3O/57nJAcPqGSWj9rR79stR+li1A9YDChrW6Gbm8VmPUj1jdZROAi/52GBN\n", + "eeZzrou1Rj3RXrXKHdfHmiopK1j37Pe7akK7kEU7svbob5HyVVLysN48v5Zf3zP8l6A/RueZkcOJ\n", + "v9Mf3R8HXy1UHPxGavA6BVRaV0NLilOtOrl37yNHkP7sz/6sJOm5z32uJOllL3uZpF7lc9Uaxchx\n", + "paJ0jqeD2sdcizJQO7e43ypjhlxjxx57rKR+7qnNUs916OP4rNxzzyM5nzc7yjxS6Kg/z09Um38M\n", + "9ZkxHD0XiSBr322lXHIoaPQX+jcK1Atf+EJJvUJDv3UlijHo56IyRumXpXNBo1Mq6DfsSjEHUO+O\n", + "+1DxDo3ODIzmAdYSkdIZkYpUkiRJkiTJQJamSG0EVkDJgofIcgbPpN1q1fA9jz5j1euRK6y+US54\n", + "Hj8HKYLrUk6s1ZJC4NYQlj0/UZ5Y3ROh5M+D8jGVT9DU1O5bl/pPZG3WRgGWIm9az/jDHyTqJ1i/\n", + "pSy9JasYpS3ylaJ+sQpRLagv/HqIGMOfqJQRPlKiwP1sUF1QiVDSsLqjqMMxRGoodVbqe6U6QIVH\n", + "mUKRuOKKK9b9fJQ5mr499JxHFIVI8aqFvu9+cfSZKCIbXNFgzLQqWRHM/a0qO+pppOrWnj2IyuyU\n", + "lChgtyJSVlCFUZhKUZSMQcYU/RVlCB/Dkm8ZqrnPodQX9cN4KY0Lf7dyf547Ot8VPLM+uwFcz/tn\n", + "7TuktLaAVKSSJEmSJEkGslRFyi1d4N+l6CJW36x2o7xTU/n8uHUSWYNY1jwHCkLJOgNW5zwX5ef5\n", + "nNp9eT+5nHxXkbUQWUtRuzlT5ZqJGGptQtR+tfmLaGes19I5aSWFj/41Nl8VvnUoot6ukXUbEY1P\n", + "r/da/5oI+glWPPUa+TOsR23fbKX2zLfaOkCZQgWOlKfoOVABh0IfLKmEJfC58b7gc43jczb4eZUO\n", + "eaFQVIj0dZh78C+9//77Ja0de9FYp15QehhTtUoURHNMq8ofzfGtvnGMDxRW6qf1bDveaZEfc200\n", + "K/i7leu72h8phPRD5k4UKN4RqNv4WFFv0e4DilatYpuKVJIkSZIkyUCWpkg9/elPP7jqIxstFimr\n", + "yNJqm8+z2iQXRkkZcIaeOB0pLvhIUQ5+RpELDlaMn4ReqyTUZuJmP5ysuZ4zJbKaaq39RSlRsKjo\n", + "Qqxerh9F6HjumAjqF2s2Kndk3beClY+i49cb6xdD3rdWqxMi1YhxgnIb5aNCzUC5XT1PRJF+EPkT\n", + "DsV9VFohGo3M1/jJobRE5YzU6Vpq57qovlDQSj4k5D6jbWkfFCXPq0Wf5XPMQe67xpjiHfKNb3xD\n", + "Uv9cRA2SDwglwxW40lxGOY844ghJ/dxcW39Rvxj6zhkK7chP9+NlLOH7xLvAxySw64OyBcwt9M+h\n", + "cwTjivaln0R+pz43M+55DvprKR8VeD2VSEUqSZIkSZJkIEtTpI466qiDq2BWtaxysUqwKrHk2S9l\n", + "lcr+rispredOYRV4RnLP3eE+LpTPc8+gBFEOVtO+uuX7KCDs16J08G+u5xEu4FYj9Vnra8PzbNUo\n", + "vRJTlxt/CDKEl/JVldQNz64bfR4rbCy0O0qaK1Ilfx/6GfUQZfM+5ZRTJPURNrX5tSIVgHGCisF1\n", + "3apnfG6krEVq6FRKFIxV95jb8DVhTot8fyCKBquFPlGKJI7qy+fACPIloRjQ9lzXFSl2Fyif52DD\n", + "b5bM1Sgf7EbQd4866ihJ/ZhiDPscUcq75Bnfp1KQNluJor55BzGGmAt411EuFLjSnORqPMoP7Uj7\n", + "tT4vY552Z1zQ7k6Ur4p3MIqa96sI+kX6SCVJkiRJkiyYpSlSs9lsTXQaq0lWjx7RgvKELwnWEN9n\n", + "1R1ZvKwuo8zPRJpgiXtUmFszlNdXwSgCrPpR2Pg3++ysiska6xE/vmqOctxQjzx/bR4kwFqY2lrf\n", + "LGinqaxG9ycoKVL+Pa/H2lw4WO/0c/pjq9KGYlTKcxbBuMAqJIO4qyRYnZxxORbGPdmxUZ49qzJs\n", + "llW/EWMVKcY8/mC1kb1j/ehQR8f6WkXnYqKYMTd5eemj3rdRIFDloxxtRBx7BmveDbQLfRnlpTUi\n", + "FsVwbHTjokGpcYWNdyRzEvVNu/s7EJ8y6jXKPA4+BnlX0y+4Pu88n3toJz7v/YTvMU7w4XKYi/z6\n", + "rf7Sft/a8ZGKVJIkSZIkyUCWpkg9/PDDB/dfWfV5pmgsUlbHWClEPGC9oUiw2o5yufD3kg9Va64Q\n", + "h/J7niuUBs8tEkV2YEXwvJFi5IpJawQROWnwTXms+kpNpVDQr2gnrF38Oagft5ZL7cP3o/bBj4Rx\n", + "QX+h39fmKEKZqz2fK8ojRj1EfglD/R8iKDcqBvXL+EeRrVFOsayp61qlJ8Jzw3mZh0I5a303gL5U\n", + "ikKMxjK/Z+6k7Us+Q0Cbcx3aiPpgLinVj9+P6zEGeD7qh3Jyf+qL9qEv+99rz0mNGBqVORWe+duJ\n", + "+jfvVurRxzh+jb7rU+tn7H679Ev3c6Y9UQR918aVKMrB31EEo3cS5XefrbG7LLWnkaQilSRJkiRJ\n", + "MpClKVL/+I//eNB68IgBcN8fVqVYLawW+Ttn0i0b9mk9OgrLvjbPE9YayhwnYZNrBqZSjsjRUboe\n", + "1ufQc75KRCd8R4zNBO4Q9Yh15dF2btWVsmnzefprFAnj+/me04XIJHyVprKSI2sVX0GyQjuMX1SV\n", + "seei+X2pb6xaxr/fZ73+QtQWbTJWkaLNXIUcm0eKfEg8Y23kI32OOQXfIle0orFMneFbwpyK+lnC\n", + "FSzK4z4x0ZhgLHhmbBQUnsejzIA+y/Pzb8pPe+CrxXOWzqncqrRGogP9gfpwnzXaAd8ydidQlEr4\n", + "O8Bz69GeKJ/cBwUpmjPoT8x5vNujyHV+z/PwfdYUtYqk7waUolIhFakkSZIkSZKBLE2R+ru/+7uD\n", + "q9HIxwKrxK0RFAhWt1gti446I6qqFAlAObD6/FwpLG4iFbByeS7P+cFzokx5DpmpzhWrzeKKNTGV\n", + "IoX1gzVAlNhYhp675u3G80b+IyhHpRPTS2f3OVjPWHcoMlh3teqB4z5RkV9O5CtI3rPnPe95kqQ7\n", + "77xzw/u1+tzxfO5XEbXjer/HAsdCPe644yT1Ea1RNBhgiZZURD43VJFCOWMsRZmbHfcnbT1FgPuh\n", + "QLT2JdqUuuf5icYr+c9FOdVQqGjzKOcZf6e+qA9yv20V/07GylCi/Ej+d+rfFRT3raJ+aRfmFuZg\n", + "7hMpP46/A/zdxb8j5dLf4cxJKMj8nX7leccAxdF998DnbuZAV/qoR/pdKXP/wetVfSpJkiRJkiRZ\n", + "w9IUqRrrPFqFs8qN8ss47KOP9ZOotdpQDtiXZVXNM2MFsJqPziNiH/uGG26QJN11111z120FK8P3\n", + "jz1KqhY/B8kz0NeCden5oCA6eR1rj3r1eiwpUfj2eNTjLbfcMnc9lEQURLe2FuUrBm61D1Wi4OlP\n", + "f7qk9nxj8IIXvEBSX2+l529VB77whS9IWmuNRqxWPc466yxJfZ4h6g7Ls7ZvoqjUZkBuBYUMFXPP\n", + "nj1N3/dIUtoC5Yyf9BXKiaruaiv14menRdCmPqf6GXwoXhGu5HH+Z62KPNYv78QTT5TU18vtt98u\n", + "qexLxRjCb/XGG2+U1D9Pa/RbRGmXwCPR/X7us4TazpjyqEio9dXzsY2iRD9gbuadRb/w00l4Tnyh\n", + "+DvPg9LGdR1y7nm5Udo8qtPfeVF/q41ITkUqSZIkSZJkIEtTpKQ+1wirYVaJrD7Z5/RcF6xWXcFg\n", + "v9z9DDzrKZYuq+mhZ4Thq+Tfx0qLcmSwCuZ5PIN6xNhcKKzu3cJv9a8o+Yix6sd3iPvye6wDsjl7\n", + "xvebb75ZkvSc5zxHUm/1UU4yX0OtMglHHnnkXPm8v3g2X1cdsKpot0VnPUZ18DMlh+JnO9ben/H5\n", + "yU9+UtL47NoO8wH1Sr9BXaFdNrLSGYsoCq19O4K6b/VziyAb/NCs8B/+8IcHfa80dj33WClPlUPb\n", + "eGRxLYw1ftLnUINRzLydI5j7UWbc1+0lL3mJpF4Fja5Hn2QOPvnkkyX1Coora/STkq9RVL9nn322\n", + "pF6tp159zLqvnONRbIwpnnOsYublph4iJRKFhzMT+elEc3o09qPdJuZm2sGjBvk3PlFeH3nWXpIk\n", + "SZIkyYLplhHd0HXdbGVlZdPvmyRJkiRJ0srKyopms9m6ElUqUkmSJEmSJANZmo/UysrKmqy6kf8B\n", + "kQb8ZP+cfXP+7fukqF6bpX5t1fvt3LlTUh+R4pQyU5N75OKLL5Ykvfe975UknX/++ZL6feXdu3fP\n", + "fY99fnyQiLqjvYlcYl8dHzT271/72tdKkm666SZJ0lVXXTV3ffwW8AOIovrwHyj5wlGP73znO+ee\n", + "K8LzTbX6SnG/97znPZL6iLMDBw5I6iO6tm/fLql/nquvvlpS7/9DOYhuxB/E/T2i/kI9Ep0Y5e5p\n", + "hft87GMfkyQdffTRknq/D/xL3PcQHzb8GuiXlA//BvwtqJ+zzz5bn/rUpyTFvhqlTOTucxKdQ1ga\n", + "e3yPspGN3tmxY4ekvi3xDaFO6INbdW4ZivuXcp9PfOITknr/SaDd3ve+90mSvv71r0uSLr/88rnP\n", + "nXfeeZKkO+64Q1Lsx8f9PvCBD0gqR4aOxeuTaEF85OjT7gd70UUXSerHDP6jvPuYm9lZwufo137t\n", + "1+buFzE0157jz4cvm0fv4QdL1CMwTvFZOuWUUyT1cyDvEPxjL7zwQknSRz/6UUn93M8cgU9j5GuF\n", + "f6yfY0o/8/NFX/WqV63/4I+SilSSJEmSJMlAlqZIHXrooeEqHFgtY61hnfE9VuGsQlkF33333ete\n", + "j1Uwq9Cpo462Ki9+8Ysl9Vl/UU62bdsmqY+CjBSp6MT7K6+8UlKvhDhYh9ddd93c/WHv3r2S+hwu\n", + "WAlu/Ud5imi/qB2jiJAStZEsU53xh0JHRJVnSCcCiuf0SDQ/UT3Kwh1Rqsex0K6oDzynn9QOKE0o\n", + "aswP/ETJ5DlXX4e6i6J7ShnIPfrJ+2IJ1D3mrlKkLeof+W6e8YxnSOpzmZVUTup2UWfItUbt1RKV\n", + "15UooN3e8Y53SFqbSw2FB8UCtdMzv/vYiPIE8dz+joHWs9scFBrqNboeY5qxyRxN5DC7CTxHa14z\n", + "n9tRUBk/HtFcq1z5mPV6jqL6UHJpX49a9Ihq3mEoUh71GUG7+Pimn1HP0Ry1ptxVn0qSJEmSJEnW\n", + "sDRF6h/+4R8O+iNgVTn8Hl8qfCbYV/ZVLvurEaUsu1PtF5dgNYwSUZs9dSj4Z7h1i/WO9RYRWfFH\n", + "HHGEpN4qov5Qgr72ta9Jin2zAKUC68/rH9+aW2+9dcPrtIL16vvoY61wsvVi7ZRy9/A5rGfPfQOl\n", + "s/xg6LlvwPOTv8tzC0XjJPInAj6PdY1640SqBGClUh+rrX5XE0t5dsbieYLczwwV/NJLL5XUn06w\n", + "b98+Sf0zMAb89AM/64t/48PBGKSNIlU56lP8HiWCUxTAxwI5/lB4aHPmgFLb0Xd4Dld1+X00J0ZZ\n", + "/f3c0sjPj+cF3hn0Gz8rjuclxxlzEedL+thwojxE3k7RnHPttddKWtsPqH98zfCrHKscoowyhoe+\n", + "C+n3fJ92451OJnKHuQF/Z/o5/cF92YaeKlGakyE6289JRSpJkiRJkmQgS1OkfvCDHxy05ny1jXXD\n", + "yeh+ojMWqFstYyMvFq1EAc9dOkdpLFhpkZVae//IqqL+sYqofxSpkrUGnvmcKDQo7ae3+rFAFNEx\n", + "1qo74YQTJNVnd0ZBojy0WwnaZepccDx/pC5g1btVF7UDKgG+eED/wwqtVQL5O/MAypm0Vo1zJcqz\n", + "po8dg1jMnvkasGix9N/0pjdJ6v0D3/zmN899Ht+hk046SdLaOY0xh5Llka4RKCsO10dhcbw+3T8P\n", + "/8Zjjz1WUt8no7FFvUe+J/SRWv9Gxsr9998vqY9qc/zUDEBBpP78HcDzoiS2+s5E9Y5PF5nKKZ8r\n", + "LCg5KKv+faLTUOCi/oxfMfUfqdb4sbpvVCsorPRXykl7ofC5bxPwe8Z49G7nPj53+NxY+65gnEbt\n", + "FpGKVJIkSZIkyUCWpkg98YlPPLg/zWqSVaOvTskrQ26QoQrEkDJK431OHFbnWMuLyi6PFcLq2v0b\n", + "yEtU8h2jXRysYiIp2KcHrKvoTELwk8ldkbjtttvW/R5K5qL8X4aCX0PpnK2I2oggrj/VeXJO5KdS\n", + "618APA8+eliXPq7wn3BfO4d+VKvcrYa+uGvXLklrfYtKPj4OljNl8r7L2HjjG9849/vILxT2799f\n", + "df/aSEssbc+1RhsMnePw6ULJQa1kDvfcgNRPFFXl5StRO1ZQYrx98dEq7UZQfygdlBOfqcjnx5UU\n", + "rkPkKX9nro6i+HyO453himc0ZlFM6f9EWuN3Sj20KlHRu4HxQH1R/yhwvFvxU412L0r+w1wHxY76\n", + "dCXKo1spl49X5ijq05XAiFSkkiRJkiRJBrI0Rerf//3fQyUEJYNoM1bPWDtYFYtSjIDVO6vaaN+/\n", + "lVardyhYg1jb7uuEVViqR1c8qBciK6ifKOKm5E+AVUD0INYZoLz4dbEWUChL1gvXxY+ArMCeI2Ys\n", + "lANfPz+xvUQpcglol6lz/ZCPDV8vlELqG7WE8euqiFup+HmU8nPx3KXoW6xNnr8lnxd9HsuUZxra\n", + "B1AEsPi5fkkpKfk0eV+NiMYsigdtV5sbrRWUEpQ35pho1wAVMVLSUIaG+v+h9kenZDi19cKcR3/x\n", + "XZRaGNO8A5gb6Ee1Edz4hBFtSf/z0z0ApYmfRBZPlQsvgnc244v6pl35yZh3BY/6pt/4uKK/RD5U\n", + "9AfGE+UpjT/m0trdjlSkkiRJkiRJBrI0RaoGVtdf/epXJfXKyaJX0YAPUKsHP6te9lsX5QNVgtU/\n", + "kRiRYkHkURTd56BYsA/Oav+YY46RtDbfU5TTxXPKUM+unGFVuF8FnyspOChDWDfsx2PFlPxVWkEF\n", + "wLcP67PWl4nvl84GhKhdW3MoUY+oIChJfm4WvnUedQeuRtT6NGIllrISR76UNWCRU6ZWnxwHS5o2\n", + "myrDOH1y6FyHglLK21MCpSNSkFAaqIcoCgv4XMm3a+ic6Rm/S3Na7W4G7wLPV1Vqb49Ij8ZMa8Q4\n", + "5cZfkTkyyrPl1Oaki2AMRkouczvKIHMREbYPPvigpH5ujHYtWAOwe+CKVDRH0k6MS75f61PInFrb\n", + "P1KRSpIkSZIkGciWVqRgaPbSqUAJq1UUsKZQTLDCaiNMpiZSLLCC3CepBFYWq3wgp0wtKBvkoMHK\n", + "cx8y7oOPGlZylE/MOfTQQyX1VhKKFIrd1PnDUBFqrRn3UatVoiKwTlFdav1A6N/UJxnpqR/P61ab\n", + "9bdWkcJaL7WHP0/LGYGMzbFKFHi0nvu6lOYM/P+iZxqa54rvM7Y9ItLrOFJ1S2omajblL6mEU/mz\n", + "RuVFcaw9b7LWrxC1HOWEdimNrWhumiryHF8p5tDNimjnPpGPmPcv3n20G/2gpDwyPqLcdRHeLtRT\n", + "rYrdqnanIpUkSZIkSTKQx4QitejovAiUJHx/SmfGAVYoq/ZWJYp93UX7gmENtNYr5cLK5TpYg7VR\n", + "Z0Tp4avEPrrnX8LfgSgx2oX7lqxProf17CwqDxN+KiX/Ga9/P4uRf9f2o9qIJcetWe5LfWOFY5Vj\n", + "JU6dYb3Vql7vzD7KiDpH3aGwoNSUcrmh4NCHougg/CG5Lvf1vDyoq/yMIpepA++b7hcYqXeorq5E\n", + "RYoUfdXVYL+/z8X0iVo/vKl8yEpKz9Qqs/tZcv/W56H+8DtkLvUca7XQbrTTWDW7lVpFz5VVlKzS\n", + "9+lXtadkAOOZcTvEn7KFVKSSJEmSJEkG8phQpPC9KWXgnhryV7XmmKk9hylis6ISsVaj3CMRRIZg\n", + "HbPq91wdUbSeQ2QNUW6uSHnUJPfH6sAqiyJWsPaI5KA9sVJqI11qISvuEUccIUnat2+fpHrrFWsf\n", + "1cFVlbFEOVuicniEG5E31N+yolJhPfWBOqMO3VJHGcAijhQO/Pii0+eBOuJ69Cn3IaEPluayyO+L\n", + "vlXy72MOQQ1FjWUs3HTTTXOf53OR7xjl9vtRr34+5n82mINq1fYI6pH+Co4G6gAAIABJREFUwruC\n", + "MwYZ47U+fC996Usl9XPaFVdc0VQe5nD8H1HcOFuwBOOsBPXmUbNA//R3EUpb664B7cN9avOyOYz/\n", + "EqlIJUmSJEmSDOQxoUhhRW0WRHmhjLTuzy4qi/BQsHpQIrBWn/70p0sqW8coPoD1yfVY9XOiN89f\n", + "q0gBnyfrLmANooD4vnrJWsEX6957713371P7SKHIsb8/NEIMq4r2oX4ZD0PHRWv/JAcRVh0Zz++8\n", + "886q72ONlrIvo96gQBOhU/KZWt1/XTnwKB/PXVaKCMZS5nOMmQhUPPqoq9OlUw1K/mbUBWOB5+Cn\n", + "K1lEupZyxXGKRERJZd8sFb0Ec/fUp0egxPFOGKoOo/xwRp9HPqOY7NmzZ+7fDmo37Up/az3fEyWM\n", + "69TOVfQ36rsE4xIFCwWN/l7r21U6+87zW1F/7ucZwfe4D3NuiVSkkiRJkiRJBvKYUKQ229oZa80s\n", + "OkIgilLzDOH4c2D1HH/88ZKk66+/XlK9b5Bbx5FCd/fdd1ddL4J6Q0Hy30cRHiUrivraLKWQTPKf\n", + "+9znJK31qxnqQ9d6Zl9E5FfjvlMoUKg4KG0oeLU+i6eddpqkvr9FipTnpuFk+NJ9VtevZ3Onz6Cq\n", + "ovKV+owrPMwJ60UIrsb7KGMHy7akbntf9eu5glby8eI61OHf/M3fbHj/iKly+fF81O9Ufn+MKT8V\n", + "Yez1qF/qbewcQl9lDKLCo5zWjin64+c//3lJfX8mX9KZZ5657veof/dtuvHGG6vuC/S3aCyjmDEX\n", + "op7TPnyf8tT6j3p06HOe8xxJvWrOeOWdEWVwj5RL5kCU5euuu06SdO65525YrlSkkiRJkiRJBvKY\n", + "UKQ8dweKy9DIic0Ci57yYmm3+rawj80qO7KKqQ+vFyJ98D3ZsWOHpHrramgeLPabURRRHPg99YE1\n", + "EvnClCJISlFjQ7NDA89DBAfWJFYk/6Y+I2ub547yWW021D9WIj8pJ/nTeB78L+hP1AfWcKR03XDD\n", + "DU3lwq+n9ozL1YoUZXBfCeYQ9xdkrKC40Ib0RVdZW9VxrlPrZznVnMbcc99990mqP0fTIbKXucfz\n", + "bwFzFOWnnlEI+DvqJmN2Kv9XlCP6Ti308QceeGDd64E/L32z1b8ShYZ6QNGhf6KU4DNEPRHtR444\n", + "fPUoB/2ZsenwfeakVv/ViKi+eU4HVTraDWnNGUkEMXNMlM+M+WDXrl2S+n5M+/mZiK3tmopUkiRJ\n", + "kiTJQLpl5IDpum62srKy6fdNkiRJkiRpZWVlRbPZbF0nvFSkkiRJkiRJBrI0H6mNFCnyCEUe9w4R\n", + "CH7GGPfwe+HbMTSCxWF/+7d/+7clSZ/61Kck9ZEEY8HPAz8D/Dhe+cpXSpI+8pGPSKqPwmOfGN+j\n", + "yN+B/Xv8BahHIkvIPcN+9j333CNJesUrXiFJOueccyRJr3nNa+bKja/WGWecIUk6cOCApD4qDZWU\n", + "+vT227Ztm6S+3vfv3z/3d3zA8EO45ZZb1q0Hz6R+4YUXSpL++I//WFLZj+DlL3+5pL4eqE+iJHfu\n", + "3Cmp96XCD4d/R/1zUXCfd77znZL69sAHjPr08+Ecj2jCrwM/BPyILr74YknS+9///rnP+7l1jEf6\n", + "r/uWEfHG5z3nDOV529vepg984ANzn4Wpz+v0tqMM3Icxdeqpp879G58lYKx5TjZ+0ofpm0RlMUb4\n", + "O/5t1BVj9LbbbpPU++XR1vzk/vgyvepVr5IkffGLX5x7vkXBGXbc98/+7M8k9T4s9BWe0yNL6Qv4\n", + "6tCXGNv4YDGW8cf83d/9XUmLfz58ky655BJJ0oc//GFJvQ+O99MTTzxRUv9OI2oM6F9833eU/F00\n", + "9vlKec04M5A5/rLLLpMknXTSSZJ6ny3akdxzjPFnPetZkvp3HP0W3y8fD7wrLrjgAkmbP3dGpCKV\n", + "JEmSJEkykC0ZtYf1EJ1r5GeltZ52jwU9lSLluUtay1OC5/SID2g9K27v3r0b/h0rKcrbdPXVV0uK\n", + "FUOsEqxBjw5EkfFyEEGD1RHB9Yhc4XpYp1j/UT4v2gur1SM0SooM/NVf/ZUk6ZRTTpn7PcoT16F9\n", + "3KpeFt4eqCmlCKpf/MVflCR99rOfnfu952LxyCGsUaxpvw9RlagmrkidddZZc/dxRWp1P40yO0+l\n", + "REVQBld3USSiCFksfc/3BB6h+5nPfGZ0WTeCXGG1EZNj8bkSZYk5HoWJevF8Q55TjzkdBQPljT7e\n", + "6hNM/UdnH5bwzOWlMcZ9yMPkbN++XdJaFR6iqLWhlOrL84vRbuwqHXvssZL69uCMR6JI/cxIxjjt\n", + "TlQe/XGqvGNTk4pUkiRJkiTJQLakIoV1x/6556rAyhuaQZxVNMoUigarZxQDFJOSz5bnKfIT36cm\n", + "ytczFurDM6M7WHcoD5GV9dWvfnXD+6E8cj/PShuBNUPma8/tU/JNw8rifp6/qtVqjZTN0vllreD/\n", + "goKG9YY/Cf4RJUWU/okfBtYv1n6U8yg66R2rnft7fTKeGEfus4aqEGXsp52i5xqinpR8P6ai5GfH\n", + "2IkyrUeq8KJgLJE/atFEcxlzC0pilPkaxYnroFjwe/7N7gZjpZbWs+ucViUUhYa5F39QzrfkOSNF\n", + "qhXmgiiHH6o9Y4/+ypjjHQ2o7lwXNZ7nQqXn+fDFY873dw7thdJVm2GfdmP8LHqcpyKVJEmSJEky\n", + "kC2pSGGNsBpHCfJIlqGgQGF18ZP97JNPPllSv4pl9e2KFP4E7qM0NpP2smBfmsigCFdgPIoLarM0\n", + "t1obnn16aDZo2g2lZChYa09+8pMl1Z+g3gpRjpwbh9pB9m36dQnqjahMrMDjjjtuw+999KMfXff3\n", + "KEkoUu7ngxWKKuBqEL5ukRJ58803S4rPKFzt41arUrdaqJGChcWO/6L/nbpFIXG/T76PCugKxqLP\n", + "7XRK6p4rGCgGPAdtX+tTFN2PuSBSxf1zzAm8G5iD+T7+d62+Tq62o3SgwhKZe9VVV637/da5gHeM\n", + "v2uYW0qnPLTCmI36Gf3VffwYc65e8zn3U6UefY6P6ofrM0cxx5R2Y6KM80MV6NpTKFKRSpIkSZIk\n", + "GciWVKSw3lCKOMma/fvWVT5WE1aK7wdzPX6SzwirwyMvIFKeWD37Kj+KQtwqtJ6JBihRHk1ZAmUF\n", + "K5F2Ovroozf8Hj5yWMelff4S9LexLLpdiXjBX+K8886T1OeaiaztkoLLOCMPWCs8d+THQv9gXDko\n", + "a5H/ClapR8euR+sZWbVEliw+IqiSfq4k/ny0jfcRfHhqfWmmzodVwvNP8ZwoD4xh5sgXvvCFknp1\n", + "FH/F2rP+UMVRSlCUqD/v43zOz/SjnihXNIeX8HbnuVGzN8uHjbEf+YUOxedqzyvGeKqNlqM+GKv0\n", + "d65XW1+UCwXL3+EOf+cdy/jgOrVKFP2P/lJb3lSkkiRJkiRJBrIlFSn2QdkXJqqILL2t0VBY3ET/\n", + "oWBE+61YU/wke6uDdYKvlJff4b74E3iWXs+LhVXLvu/YHCEoRqyyh0b/YQVSHqwPrEBW/zwvPjDs\n", + "p3Nfnt/zApWixrCSsYapz9ZM8vg7jI3MAawnfHnov9QH1l2k3JTAN42fu3fvllRWwtyqcj8Cyhtd\n", + "B+uMdvdItKG5Xeg3WJlHHXWUpN5n7Rvf+IaktePM70+/HnLvsdE8RE+VFIKojqh7FJ/SdWi7RSlS\n", + "jE3Kg5KAKujwXPiIOaWcaa4gMma4P741KA20F2OWvEr0XeZM/PKo35Kv1VAefPDBhVzXYQyQ+Zx+\n", + "MnXOQnZlUGZa51Tam90c2pd+Vbt78K1vfWvu38z1UWQv73jmYO7vKnfUj4F3C8pc7ekqqUglSZIk\n", + "SZIMZEsqUlgTf/AHfzDJ9TyvE1YN1k5plYwl7nBmnCtSkXLE77EisPSxwvg9q3cUqqmy1WLpo1BE\n", + "yk8JrA7K5fWJQoAVSCSPK2BRlJ5bqbQPyiA+P1gdWBH4YdT6aEVKFH4vtX4dDvWLoul+H0MVKac1\n", + "KhIoB/XsUXYOVmBrBn2IolspF+2AjxZRu9yXccm//WzN1f3FfSlc9YWp8sqgDHhfijKZO/QVsvpH\n", + "50LC2Cg+5pxo7PlzjPX7a1WCUET83EU/cw8/SeYAlCfGFsoD/WGo/2RElDNtUbjPl78zpoKxNXSO\n", + "8qg9lFPmcNqxVlGlnlGc3D+auYKIY8aj+896pHdUb+yOUM+1GQJSkUqSJEmSJBnIllSkpob9dWB1\n", + "ir8BvhlYP56PJ1Iu8LOI8ttEoNyw/8pq21fNU0eE+L5zRMl/BCUh2m92qzmySrE6XQHy6Cz8JbCW\n", + "sJIpH6pDrQoA0QnqNdFhQ+5D5nj38RkbdVjCFanWzPtRxFkt0fjhevykP0X5sKhHlMkaRYqxuag6\n", + "jvLW1ILljsKyaEq52qaOPKXta8emn0vJXMmY5Druj+kZ0GkPfj/1mOa6i1akKDe7HygyQ8/+K8E4\n", + "GepTRrvxk/aiPVrnaPqPq9fAeOd+nquOXRDmCt6pxx9/vKS+v7ALxhoAld7XDhGpSCVJkiRJkgzk\n", + "caFIuY8Tq07211ml4svBPqlbP67UED011IfJo9XYl62N4FkUWPyRMjDUVybCfZE8MsMjMLBSsU6I\n", + "sGi1prFy+D64NeZRiq1Qj6gjbuWUsgvX3p/rch9UGVegajPIQ210J6qKR6j5uAKs1Fo/BPwhUCAZ\n", + "L6vbzxUClINSHTv4LPHs9FFXnnjmoWOC8tRGPo7tiyXGnhpB+bgOYzbyN/SxHuVtchij1Btzpfv7\n", + "UU/ReaBD4Z1B+ccqkxEeYU7keW00WSutc4PvxvBv2t/PM+XvtUoe/YfdCD/vk3r3iHTmCBQn3g38\n", + "nnr1/ua7FLVzXypSSZIkSZIkA3lcKFJRBAKrZZQNfFiIboui/Ry3tGvxnDDf/e53JbUrK1P7f5A9\n", + "l9W9R0oM3Z+vtdr8+igtWDn4C5ABHau+1R+D/GReb26VoRBy/aF5k2hfp1QfWGWRCuGZ2V3JRNFb\n", + "NNSL524p5eli/ET9A9WHXDIowbTTaoWPZ0Uh4m+tSgFlLn2/1efDYezWntbQ6o8JtacquHofnaMZ\n", + "4f6npfu5/x7lLJ1XSh+nL6AceHvQFxd1ZuGxxx4rSdq1a5ck6S//8i8nuS5znT8XuwX33ntv1XVQ\n", + "a/EBKuHRdIcffrikfq684447JPU+R34+J/3Z84cxxzJ3+3mtpfLzbnbFEWWSucB9sag/FEn6M/6Y\n", + "Pu7ot/S/zGyeJEmSJEmyYB6TihQe97UZzkv7yVivKDFYSUTTtWZ3rcVXzygOrcoSviNjc4qgxLHK\n", + "bz3TsMRQ/wGsHJQq/BJQQLiunwdWYt++fZJ6a+ecc86RtDb3EPfBWh+qSEXQfljj3Iffo4T6c2Ft\n", + "kzn+gQceWPf6991336TljcCKfv7znz/3e1ds/bw4rGys3muuuUZSP/5QlDlT0FmtYOKPheXa6vMB\n", + "zC0oXFEka3T2W8mHCcULxaaUywtafaMYO7UqN8/Dc/D9Wsuc+mcsRiosoABA6xzG5ykvCgbKw9Bc\n", + "cLXQjvfff/+k1+W0Bq6PsuL1VSJS9kq7GNx327ZtkqRzzz1XUn9eJvXuuz2MWdqfdmActp5ripLG\n", + "XE0GfeZsxgPvaMrDO5z6wresxFBfulSkkiRJkiRJBvKYVKQWdW4Sq2Z8MVh9e96fElgTpczhWAOR\n", + "EsVq+vTTT5fUW8NjrbgSJaXP9++Hgl8BVkdklfPcKGRYWexzo3Acdthhknpl7a677trw/pG16jln\n", + "8K8Y62fhkSWAosbzEI1GvURWJSoDVlSkOtRm8cZ/wcsDUVQe0B9oR5Rj94FyPwysXqxVj7gpsXo8\n", + "uH8Y10RZIoIyUlhoe1QyFBbapKRGRorRSSedJKlXTK6//npJvao4VbZ7p1XdRlGA2pxj1C+qrmeW\n", + "jtTSof6lQH3zk/r0SNxF8fnPf34h1+W0BsY0ZzpG9Rjhiin9mXdolGGcXRKUtltvvVXS2neNR3Yf\n", + "OHBAUj8XcB/mktpchnDDDTdIku6++25J/Tv6vPPOk9TPyb5rNDaynHdc7TmeqUglSZIkSZIMZEsr\n", + "UljI7M9+5jOfkVTvT9AKq232dUv7+xGcSI4yQu4LrssqHt8t9qNZXaNAkHGdyBCs6NaM59F+OOXB\n", + "mqw9/2jqbL6upHhumciKQTEcSmTNTO0D5fdz3Hri37SbRy3ye9QXrouSQ//xaEOIInmivGGcFYha\n", + "c8opp0iS9uzZM/c57kdE0Qte8IK5v0c+cl/72tckxYpdidVWN0oSz4z/GHWH2hz5duCnRd3S1xkb\n", + "Q3O7cY4g5aDPR+d4RrzrXe+S1CsFWPyohcwVJ5xwgqRereT+jC1XNpgLUJRuuummuXI6nr+HuZrr\n", + "UM/UP23kfczzVvF5oE+hRrtqixJFOWg/YCxTrtrotWUT+QO2wrsHVdozvjsoVihKtE/tOxfljJ9j\n", + "YfyVfB3pj5SXfsM4r909IRKceqiNUE9FKkmSJEmSZCDdVKegN92062YrKyubft8kSZIkSZJWVlZW\n", + "NJvN1j20MRWpJEmSJEmSgSzNR+pd73pXMa9Qa1ZdB9WrpH7hX4BPx9e//nVJa6P18L+IovhK9xsb\n", + "7eYn29c+31Rs1ft5vSz6fmOhH7zlLW+RJF1++eWSen8OfL/wecJHkFwo+APwEz8b6gEfJfoZ133z\n", + "m98safPbj2zP+C3RTtQDvolR9KnnnXLwz3n1q1+95tlKfQNfnih6jL975GbUV0499VRJfdvs3bt3\n", + "7u/4IxJhij8c/pj4r/GTyNLXve51c/fDl8h9Vzw7PHV+xhlnzP0en5MHH3xw7vfMhZdccokk6T3v\n", + "eY+k3mcEnyvu8+QnP3nu/lGksvdZ2gNfp4svvliSdNVVV0nq/SLpE0SAkj+IOZgoMdrl/PPPn7su\n", + "fnzud3jppZdK2npz2WPtfkSo/9Iv/VLT/UrjrsSy6jMiFakkSZIkSZKBLE2ROuSQQ4qRAETSlDJs\n", + "t56x5mCxkwGajNKuPHleHaw0jzSJiM7JOuSQQyT10VlRNNrYE9+xNnm+2myvnldpqzFWiYpAgaRd\n", + "sGo9kgPFiM9hVQPtjj+iR9FRfrL2Av2SCJ5SHivUgakz0pOzBaXWYZzynG5lenZjImmIBiTHEhnN\n", + "nUiJor7Xy3WEEoWCEUV+lixij6R1UFhQmlDPfe5gjrjooovmvnfZZZfNfQ6VjrnMo9ogmjtd5ec6\n", + "N95447qfdzxilag9fx5XO0sZtykX+ZGozygnHmOPuYdoP85oiyJrPXO272ZMHXEMY3dPABWan1GU\n", + "oZ++sCx8bEbvYqIqUWzJo7ZV4MxA+hu5FP3MwIhUpJIkSZIkSQayNEWq5hTzkmWNb4QrRUOJMmHv\n", + "2LFDUm+d4gfAarw210RkDe3cuVNSb/2hSJEDBCstirAs+W4BFvzZZ58tqVe4SvW3jMjOFlAkUAg9\n", + "RxD5vEpnLjpenyiH3t74sbjSBG6l1lqRrX4EYxVLB8WopFzyOdQFVzCpL7dW8e1C8eKkebJFl7J9\n", + "Mz7WUyewgFG7UKQ4T7NWjeU6kRqI0uJ+XihigFLi51l6PieUJlTj1jxTY/F5mTZjDogUl9pzNL3v\n", + "ew41+hBzUm3Gd1dw6BP8HLtrUSKqF1cUmavpJ9Qb9ev9FiWR5yBPFgpnpOJuFq5IRfVLu5YUu+hM\n", + "y0Vz4oknSuqVVhQpz/QfsaEi1XXdoV3XXdd13b1d132z67rXP/r7/7vrut1d132767qruq77v1Z9\n", + "561d1x3ouu6BruueO+ShkiRJkiRJHguUFKn/kPTG2Wy2v+u6n5C0r+u63ZJeKWn3bDZ7X9d1vy3p\n", + "LZLe0nXddkkvlbRd0iGSru667ujZbLZGill9ynLtKhQrje96llyPWBmLR6a4IoV15b4tEZFigPKB\n", + "tQy1Z+hRPqze6DwmrLtPf/rTG14Pf49apa0ESljtCfQeCVQCpQ/FiP1uIqPI6tyqSDlRfdAfIn+W\n", + "Eu5ngtXWGtESKT8lGH+Un35Ke5WyQbtyRsQUYOX5yeq0D+MYH8XaMw0ZNxvNG0QwYulz6gBlvvPO\n", + "OyWVLeXo/MzIV4X7kDUftfuVr3zlhvcBrjf0NPqhuJo4tYLjY8gVMHyoPIN8ySeI399+++2S1pab\n", + "OQLVGvg3ylj0LjrmmGMk9dGVtX3UfcCYC9lNcV835uirr7563eegH6IElc6/XDS1Eej4R0b1Rj3h\n", + "Q8U7dardphIofIxvomYnOWtvNpt9fzab7X/0//9F0v16ZIH0Ikl//ujH/lzSBY/+/4slfXo2m/3H\n", + "bDb7jqT/Jen0ukdJkiRJkiR5bFHtI9V13dMlnSzpFklPns1mODD9vSQkhP8maXXilO/pkYXXGlZb\n", + "gKyqsWQj/4WSdTY2YsJB2brtttsk9fvT+D9gLaDgODwXq/aTTz5ZUv98WPpY1qx++cn3/Lmw2oDV\n", + "PlYU5eN7+FmUzisCtxr9foCVSJ6f0onbtXm0ak+cB6xIfM3oR7SXn6XXiitNlO+ss86StPYsOvIm\n", + "OShF3l9Kvm1OyTqvVRF4Dqwx2oV+VIrEop/h00e/Rjn2z/n45XOoBfhE1vp6Uc71+gt9EhWSOuc7\n", + "WJyUIfLFQWXj+94XUD9pQz+DDpWYnyga9AX6Kj9RoTdbiYLWsTcW97FBUXKFpdavsNT3/br++Ujd\n", + "pN0Z65Sn5Gvn9Unfpp/Q7p5bLVK/6a+8O5jbeS5Xg/n71P6TgMIGz3jGMyT1uyKMK/q/z/3u34sv\n", + "o9cb4yXyGRybS5D643lQKmvPZqxaSD26rfc5SW+YzWb/vFr+nc1ms67rNtqTW/dvqyv0Bz/4Qeio\n", + "myRJkiRJspn867/+68GFWekQ6eLqpeu6/6JHFlGfnM1mlz/667/vuu4ps9ns+13X/ZQknDn+t6RD\n", + "V339qY/+bg1PecpTDuYEYfUX7fPW5uiYOkcIViVWAIs9FpJYU1GeJX8eyu++T1iprIbJfRP5Ovlz\n", + "Ug6scMrJ74lu4vqteYai56u1Emt9o6BVocGK5LmI/qL93GpqxZUa1Al+71ZhCdppKFPljmHc0R+5\n", + "LtZyyUePSQarEyvS64H6d/8T/IaImPF8bLRnqV7XG/dY4NQ1bXX//fdL6lW92qgw5iDPU4SPi48p\n", + "FCX6PnWDbxbPSnmijOBj+0oJb5NIkeK5eZ6hpzOU8LaO/P3wWaL+o/Kg0LA7wFwLtX6g+/fvr/qc\n", + "475ezO3UN+Uj8pddA3yh6C/UP59ntwQlBiXr6KOPnrsff6f/4qPk7V377nQ/ZPdxYy70dwZzi+8O\n", + "+FzvSizPS/midh6rSLma/vDDD+tHfuRHDr6zzz///INZ8tejFLXXSfqEpPtms9kfrPrTFyW94tH/\n", + "f4Wky1f9/sKu657Ydd1hko6SdGvbIyVJkiRJkjw2KClSZ0v6JUl3d11356O/e6uk90r6bNd1F0n6\n", + "jqRflKTZbHZf13WflXSfpB9Ieu0s2HT+0R/90YNKCdYZChWrSlbjWLSR1eZMtc/P/i0KB9aFKyy1\n", + "UYL79u3b8O9EL1EvEb5qxxrGlwkrFquc8g2tl2h/feooybGQUwUr6eabb5bU+12Mxa04zinjvK9S\n", + "bjSs6kVlV4ZaXzSsU8pT8heKoP39J9BffSogMof7UR6scaL6du/e3VQeqe+zPBOWPmWhDRnjfA5/\n", + "L+qOPk7buU9PpO5yP29rroc/YUlti7K6TwX1gOXt5UVh8M9NNfbdpcMjfBlTrkihQJx55pmS+rw/\n", + "HuVFO4xVpaeC+uUnyqir3oxhlCh89fDtQxWn//F9V6tRhmgv96OlXmgHrz9Xery9fZeId5grcZSX\n", + "8UaEbglXmKLxQH622rnL++9NN90kqZ97qO/afFYbLqRms9kNilWr/x58592S3l119yRJkiRJkscw\n", + "S/Pw/qd/+qc11p6v/lgtsqqu3c+dyq+A1TX78Kyqyfc0tbUYnT/l+PNjFVA/ni0XK3xoTpjIx2mr\n", + "KFGAdXXHHXdIWusP0UrkD0B90P78vbbfLfp8rFr/FVQYrNBSv4vAz4Tv449SKg9qB/0UBRo/kjGR\n", + "ayhSfs4hMIZQhrgnkZ7kn6Jta3PFQWTJ0vZT5WgbiysKPkegctM21AP12qpekj+J+ve5hfu4j5nj\n", + "pz+Uxt7U508OhXbHN4j6RRFiDkOJov95PfBO8t0Cb4/Ib5F2dqWKfzM2GcuR75GXC6XJ+z/tyfPu\n", + "2rVLUu8bFs3Vte/Y1jxa+M/6+Z8ohFyvOgK66e5JkiRJkiTJQZamSHVdd3BViJXmfgtYi62+JVMp\n", + "Jb4Kx2pFIbv77rslrY02KoH15KttrIHWKDfAqmHVzzlBWAO1SgXPg9WzaD+NqcC64KfnamnNkuv9\n", + "yPuf/73m/Ehpbb9qjZyZCs9nVcoDFoHVSo4d72f0d6xUxg/jmkz2Rx111Fy5vvGNbwwqz2o8Sslh\n", + "rGGRTnW2XXS/0liibijH0CikoXgmZ6KZGFMoKkP9LbkObe3qJWOAdqM8jGH6DHMdCpmXm/qjL/H3\n", + "1tMCpoaxQDtTHo+8BhRDFBKUmyii1ue4SGX2iHN8sqgn2qWkUntuQhS16F1D1N4FF1ww97mxuwet\n", + "Kr+Xm3rA5w5lLTp/10lFKkmSJEmSZCBLU6T+5V/+5aBnP74a7AtjbaCk1O7Dc9Ya+65Ts2PHDkl9\n", + "9CDWk5/5VwKrA2uDn1HUUy1Yj6yuqVfPIF3KcF57jtRWB38XrCSee2j9lpTCkqKEYuUnivv3plKo\n", + "SlmNGW9k7x2aG4j7oGhF5XbFDqsYaxjrnCjLVv+b9YiUISxt8u5giW9WZu8oNx7lLSlRU2Ws9ghP\n", + "9zWhPuiz3latMBajSE4/8w5/VFcOPbqN3QKizOiDHrnsysVmRx7zziudSsBcTj8hop13TeS74/VJ\n", + "/4rmLvf35N1L+Vp9j6j/0lzCiQNTnaU31geOtcO2bdsk9eez1pKKVJIkSZIkyUCWpkg99NBDB1fD\n", + "KDRYK6zC3Z/AIwjcmosycE8F1otH3LjCUIL9frLzEsGBFeAZ1LEE/rmGAAAgAElEQVTCPHoR/PfU\n", + "C9Yd1lat9cr3aI/orL2tCpEXnoul1uqMToCPfNsg+j0+QKgIfh4WaojndRpL1N48H9YtSh0RU5Sj\n", + "pEz+/+2da6ymV3Xf/4/SREprJC6FAMaOx8Y2M77fnQzOACIEx1HBgAA3KKg1VaQUg4IDrklSHyBI\n", + "yFEQxpEiSNwowU2aKMjGkJAaw8Dg+2U8HmMPvqAxCsbBbWmkonwh8PTDnJ+f86456+z97Pd2Zvz/\n", + "fXnPeS/PZd+evf57rbXZV4vcNmTij2pFzClDe+I++Z9+T8TcPIkKBfljZr1fZwZ9q6Q8YSlHZrV3\n", + "Wkk5iD5L0+4ByO95zdRx+jBtJ64yUH58L9sFosSiI49rV0vom4zp9Nmx11u7ukB9xLFoLLV+lrPK\n", + "7TcriCblWVHaQzFiRcoYY4wxppGlKVJr12yZxTIrZg+waHWV1mtLe4NNC7lLYob1GDGSgcUdFSUU\n", + "p2wdGyWDaEauAygvFJO4f1HtOjfXhfKHooPisCim3cB627ZtkoZ2xX3UgoIUlUAUyUx5yvxxaMcc\n", + "L7brsfm9yJ3T2t7x9UMNQCFDlSHLbwY+d6961askDdeP3wNZpiO0f+oXtYPy5rpQtO6+e/67S+F7\n", + "QpvPrr0E94ZlG9V12iI+IZkShUWMElObWXnezCsPU1T3KT/GPNRJ6oe2T0Tx2AhnxoZF0ZpRPfrP\n", + "tjLWx2msEjV2bC0x7Z55tbs6RN72trdJGsZCnnm1zyIrUsYYY4wxjSxNkfrpn/7pg3Zox9IlxwjK\n", + "SimrMFYfylDmVwBxP6cSWEFYzvhEYYHHdX6sqa1bt0o62ArFOq1dh+U6M98ZygulikgXZveUB3vC\n", + "YQXG686i+qLvGcoVs3XKn/NgBUUrNkajZZFHlPNYOD73h3JYu0cjoAJwXyh+kEVbRrBuyMtFuUQr\n", + "s9QOo8/WtMor/Yz2wXGjLxPErN/0V6xX+mdUSgElNe6bFqP08FfKjjNPWpWomHOtlA+HtpT5ksQ6\n", + "GBsRPC1Z1GLmN9h6/MzSpy2hzMXoPMp5LPRFfKpK0MaJ6oz+kXEvxayeuI8M+iBjAGMDfYXfo7DQ\n", + "fjhffCbEsZo8WpQjfRblj/OWoudQBBmbab8xF10rPJPx08SXrNYn7Jd+6ZckDWMj5VPqP5Qnz3LG\n", + "Itpp7W4VVqSMMcYYYxrplrEG33Vdv7KysvDzGmOMMcaMZWVlRX3fr5sawIqUMcYYY0wjS/ORmoUi\n", + "xXo3vkdxvZhzXHfddZKG9eOxOSKA9WDW91lHJRqL811//fWShozR7EGGDxHvsz6OjxDvk1eHyAH8\n", + "A/j8kUcekSRdfvnlE+dlPZfoMo4bywWfL6Ik+Zz7iXv+cd/ve9/7Js530kknSRrW9fEfYL0ZtXP7\n", + "9u0T58FniXV/osU4H/sc/fZv/7Yk6eqrr5Y0rOvjO8fvuQ7Oy/o95Uv5xWzKr371qyUNvmPvete7\n", + "JEkf/ehHJQ1+Cpwn5nSpjajh/BwPPwXKcVHqLOf51Kc+JUk69thjJQ2+bNzf/v37JQ3+CfgE4g9E\n", + "/+H+6YeUC/+/5S1vmTjvvFlZWdGNN94oSdqzZ8/EZ/QlfF6oc9oS/nr4gcU2ut651r5GduzYIWno\n", + "gzECkbaMP+Odd9657nHwHbnyyis3PN+sifeHXx1jDH2pdR9OfG7oi7/1W78laRir8TXLorAYk2LU\n", + "H2MbYwB+s4wF+CleccUVE/dH/fM9fp+t2HBdnI++wvVwvfgXXnrppZKGsSX6/uAbxNif5VIjd9ut\n", + "t9667uf0wauuumri/ubNssayu+66S5J0xx13SBraZ5Z5H58z/DZj/jHq9eyzz5Yk7d69W5L0gQ98\n", + "YMPrsSJljDHGGNPI0hQpKc8UjUKB8hNnjURgYBFHxSV62mMlTLuHHNFG0QqKMBsmCgnrAuWqlJOF\n", + "z1EGOG8W3RWVEr6PMhCvN4v6ohxjXqO4QztEhYd6xFrkfu+77z5JB2ekx9omsoJ6yyI1KFfqMWbA\n", + "j9YkakDMScJ5okIE2Z6HlM/YPFete9jNC1SYmG8sg3rM9r6L7QkFdhlEJQpQc2krMWqOvtUavRch\n", + "qmvv3r3rfn7JJZdIypUoqI0amjdcB9FdY7Pvx4zZ9InYx2JfzfpONgbHtshYVIreYqxg7EPBjH0E\n", + "RYPVBdRz7g/ljuuIUZzZ2MaYko3xqMelnH61Ps+sOtBXUWJZ7XjZy14mabgv9p5rjSJ961vfKkna\n", + "tWuXpKE/Qm1uPMZ4+MpXviKpPgKfqNgsQpn2Rr+tzWdlRcoYY4wxppGlKlLZ+joKS5ajItufKTtu\n", + "NvssEfPtYLXEnB8R/B+wmshVgTXDcUrKVlRKMn8B1vfj98dm/YV4X5kVFXNtxPLCqsGK4TgcH6uO\n", + "42RKXWYVYBWTcyRm8c2sM9oH1le2E3sG9zl25/Jsp3msMa6/1u8EK7aUGT3LDTQv5r3DwDSgZkdF\n", + "alb7GwI+VrENnnzyyZKkBx54QJJ02223bXicuC9jzMU2NideCdp2ZNrM5pnqGym1nSz3HMRdCGLe\n", + "pRJcV1SiGMvww+SZElXt1lUPro/7i6D+4xOUkf0+wn3STt/85jdLkt7whjdIGsaWz3/+85KmX82J\n", + "YzPlxrOgVnmNu4jMqt1HSs/miBUpY4wxxphGlqZIveAFL3hGaYjWBQpD5ptT2k9n2r3aIEa1RWUL\n", + "65CoJogKStxLsLSOjVITdwrP7pfjZYrHtMT7A+6f9W58srAuiHygPLDqmO1jlfCKAlkbDRez9Y6F\n", + "8471Q8mUqFe84hWSBl+uqHq0WuEZtXv0RZWB7MQlf5cYGVW7D1bJjyPL7s37qAot5RIVmwh+h7OC\n", + "vhH9xyjzuD8mY90tt9xSdfzoYxMzV8/aIkcdXRaZwpa1PaLcaMuM/ai6tW0Iv1xAqWFMJUoOHzzG\n", + "4re//e0bHvfiiy+e+J9nWrYHXqa08ewoKSXZ77N+QXu6//77JQ3PVlZ9UKSmhTGaZ0T0kSqN+aWM\n", + "+MvGipQxxhhjTCNLm95tZCkweyXaK1KKgoqWeowYyfaNYn2ZvERbtmyRNETWREUKRSMqDVk0VG1E\n", + "RVSiSsSdqmMOlLGWPcdBkciisPgcRYfrxheM3CiUE/9j/bCvFlYm1lpUiKLVH9fXW/1bsHJnFRkV\n", + "/Sg2C7H+a/1dom9VbQRLjKyJqkEsb9rRtm3bJA31G6Ndayi1BVQvxgj6butu86Vrw/+O6yrtG1qC\n", + "vsWYRtlRp2PKShrqguuLYxTKGgrPtL4yERQoIO9S3B8zqx98zuIecDfffLOk+sjUqJID7eMjH/mI\n", + "pOEZcdFFF214PJSs6O8Y/SFLxLGuVq3PjhNz4FHflBevEfoNz4ZM+QLGclZXiDqMuQSBsSbeL/Ds\n", + "WFRE8FjfQytSxhhjjDGNbM4FxxmDVZHlrQJmoTGzeLSGsNKYrUalalY+SnFdO/OBwg+Dz7FSsQp2\n", + "7tw56ryUE8eJCgOgvPB9rBTOS7mdd955614P38fawcqOik603lqtskjcwb0WlBNUAKxUFCmsZJS3\n", + "aNUs2w+llljvlFPJTyP6PkXVIfpHcDyyf7dmy64h88ucNbTRWfswMSagJHCeVt8RjpMpAShqs/a7\n", + "hFg++OjUwqrFOeecI0l69NFHm64jy4QNZFyHP/zDP9zw+5TX3/7t305c3xNPPDHquqgPMuCjCI5d\n", + "ZeB6SlGPEcZmokfpq5mihuLFs4PVBNpRFj0Zd/uIz1yOO8+xYS1j+60VKWOMMcaYRg5JRSr6XJTA\n", + "WkMRyXxEUCjIbrxv3z5Jw+w/5iiBOHseGz0XZ+EoGygAzNZRnuJegcz+8Z9AIcO6G3s9WKcoCVl0\n", + "GOUVI4koZ5QXfNqIQOJ+eeW6UDJiXqdZKVARrKNaax7ljfKNViHZf1nPP/300yUdnPsly9Wz2aDc\n", + "S3nbIrE8oyKV5b9ahLUZfWDmBZZ7lguvFRQF2iIK1VglB6JaH+tuXkpUxticfyhq+LFmPlylaLnN\n", + "TlwdaY30zZQoxiRWBVCg4j6vtT54KDqM5Yz9Jf/m+GwFfN3iWDIvaiOUwYqUMcYYY0wjh6QihdVR\n", + "m9k5KhrMNrGA4++ZtcfoIqyf0no6uTLI/ZGBYnPKKadIGqxYMqOTswRlKipRgNWLVcH3sSaJPqz1\n", + "H+D3WHElazdG+mD1YUWwVyL1wCy/VI6AikA9Reu5NeIqRiwBVg/tAwWU72dWEVbiMcccI2nwL0Cp\n", + "4jpr8z8tm1L7zYjKUvSZmpfCWMPYLPaRqL5mMIbMWmVDhWcMo89P26ayPQgXTa2CFzOKzzoz/bKg\n", + "faE0MvZkKvisoK8TFccYRv6z2kjkqJDyyrOE+8l8pWjPmTK5qDxSY58pVqSMMcYYYxo5JBUp1m+j\n", + "D1EG67UoPqwDoxxFZST67GRgFcUM7LV7m5FNl4zY3BfXh29KyRpg3RmrAusSBYXIiahIZfm0sPJi\n", + "pEctzObZGR3rIipmkVL2Xcqb++M1u48SZ555pqSDrSN8nLD6sYIyfxLUAP4nDxnfp14pl9Yd1BdN\n", + "q5oSrebYH8bWUwZ+IxtZ6aVM5/OC89FWaCNj7z0qYNFnCZ+SaZW27PibFcbcWv+9WavAY/10a6F9\n", + "oHrTjtgXdN489thjkoZnytgoSMZAnmG0S+6n5KOYRctNu/owb6xIGWOMMcY0ckgpUnGWXlKiIvgt\n", + "8IqPElYj1h/Rb1HxiEoP6/kxEqE2MgTrj1k6Vg4+Ullm9wgKEtYZvjkoQJnFnlnHWBNYB2OtAHxg\n", + "KBfOUzpOdj2UD1YJ/9MOaBdZREmWPyzzscOKwtrnPnjFGo6/4/wocCiJUYFaVC6UWRGzIpes+2hV\n", + "Ul6z9u+g/2+kmEZFh77dmtE8U5uzTMjUdUmJirsvAJm+AXWZyOPYNku58jL4HZmol0VtJvJaJYr6\n", + "RxWeNn8Y9cSzg/aTRQtmUWglOO6iFRjaAX11rJJL/6LcGQMZM0o59LL6pxx5ts2bsUq2FSljjDHG\n", + "mEYOKUWKWenYyBJmx8y2sRqx2jguVgWKRIwuQjHC1wqLOFq9tdYgs36i8bB28HW68cYbq47D97/9\n", + "7W9LGiIvsLrH5mahHIi247rI6F0iRiyRFwvI+RLJrPZo7VFfvJas06w+yDKcZabHdy76n2R+EZzn\n", + "a1/7mqQh6rLE2H2dSlD/UckbC/2Fdl+7B2SWi+iEE06YeL81C3U8z3pRgHFPMSCCld/ee++9o86Z\n", + "RRzib8m9YsnyPteT9cVMKYlqW8yFh2KBBc33a8cgFC9+h9/mooj+pXFsZ+wp9fUs7w9jSqZ0xPKl\n", + "3rK+SP3SdkuKxax9zs4++2xJg8/UrPNildopyl5WD6yCEK3HcdgLEcUzy6SfgdK1devWifdRqGYd\n", + "bRqjFktYkTLGGGOMaeSQUKSwRpiVjvW1wCrBOsTayGbz2V5hXAezbpQSrKaxoCBh1WAN/P3f//2o\n", + "40RfKnx1WqPZAEWi9f5Q2jjO2J3pM7DysGawdrDKUeiwnvAfifVKdF60PksRUJkVijVcq0QB9UQ5\n", + "x2hQ1IfayCOsQKzGqAjWZnlG1SgpUUSdYvVHVYPfx/23gHo799xzJUm7d++eOP8rX/lKSdKtt946\n", + "8bv1yqOUW44My7P218L3gzZJXaL4UBfUTfTByNpUjCjmd5Qh56Wtc1+1KjR9J+b5aYXrqS3fE088\n", + "ceL/uAtD5nsU4dkw1qcoKoGlqLKo9KFcjN1Dbyw8gzjPWCWKdvNzP/dzkob2wtjH6kMWIU4k8hln\n", + "nCHp4HYMXBftE3X8Na95jaShX6AklaIeL7roIklDuzr++OMlDf3s2GOPlTQ7RYr+umPHDklWpIwx\n", + "xhhj5s7SFKnnP//51bNIrJNaH42MViuUWXuWWXzaHC5YybyOhXw6MVN39A8oreezw/hxxx0nabDO\n", + "8D9o5fHHH5/q9xncD1Zo/D+zTlm/x6qJGewzou9PSSFib0TKD2stWrUx6hO/DcofhQfrHNUg+o2Q\n", + "Ayb6L0Qrc1Z+FZQbVj3Xl9U3voW8wqmnnipJuvDCCyVJr3rVqyQNVi/1GBWp9SjVyayVKCxvxgjK\n", + "nlf8KKMvSG00UMwuz5jJ8WkjWPZjLXP2E6UNMlagJPCKYoVvEAoBaiq+Z/yPH2SpPqKSc9ZZZ038\n", + "vgSrDKjL3H9UmWvV+cxnhz4Y23bmA0XfrB1bSnA/Y/0o8UkiZx5jH+VBfWf7zwLt8I477pA03F9U\n", + "l3k/jlGMgbTbuFsGYyuvJ5988sT3uD4ULZTU+ExG6aI9oLTVwhhGudRm2rciZYwxxhjTSDerLMOj\n", + "Ttp1/crKysLPa4wxxhgzlpWVFfV9v+5mm1akjDHGGGMaWZqP1Kc+9amDcnuwHhl9KCKsm0bfkgiq\n", + "13XXXTdx3JgLI4twwS8gRgKxTs26Od/Dx+PTn/60pCHCgPuKWV137dolaVhnJqN5jGQg/w7Xz3Vf\n", + "cMEFkqRrr7124nPWkYmmgoceekjS4CNDNBe+UURgsJ4dd4R/05veNHG+af1NSrlEqL9rrrlG0uBv\n", + "UFrPrz1+jFT6tV/7tYnzAj5LWa4f/ACIQKKdUJ74VUTfKM7zoQ99SNLQLolAYr0+tgfaI/4hWU4X\n", + "Pue6f/d3f3fd+5uWWD60v/e///1TnY9yyPpnjJhaWVl55lytGb5LcK9XXHHFM+dcBJxn7PlKUYy1\n", + "54vHoW7imIY/W9x1Ap8cvk8EL33mkksukSR9+MMfljT4wOCbk4315FWivu+55x5JQ5+Pvmjcx+/8\n", + "zu9M3N+84Lo++MEPLuR8lPNVV10lSfr85z8vqbxLBn2VcmesoE/jh4vPHM9gcuaNbZ/4ReKjF33N\n", + "6NtErUZ/19b+0ErpPFakjDHGGGMaWZoitV6m2ZISBSUlKoIVyayW35dyrZSim7CEo1XG3mq8MrvG\n", + "GoqRH6VcFVhllE+MoovKEApFKfKFaC5eY1bkqOSgSE2rRMU9CkvZbWPkUi2l41K/pXqOmeuj2oE1\n", + "hRVOzhcUJSJIUJZi5A1+itxn6X5RBUoZ3WOW7XkRlbrWTOqRUv+MkT9rIWKSXG2toNpS1zGvUy2Z\n", + "OooCUKuyjmWsElV7HOoGNZ37y/Y/pY3HXHKxfmir9J3SWM/n3/jGNyQNbR6Vmc/p47WRtrV7/kXi\n", + "LgXkXVoU0ee5duzcuXOnJOnjH/+4pIP7NM9OIudRu1vZu3fvhp/POy/XrLEiZYwxxhjTyNIUqRe9\n", + "6EXV1h3ZRvEhuuuuu0adCytw1jlksnxF+IjE/bZa8/fEPEm1O2BnVjB+CViPWJfT7owOpezG7NmX\n", + "KWal7MKLAsWD7LnkC0NRi1YV1jYKFIoRihbZfb/4xS/O87KfoXXvvugPM3Yn9GmzY9eyUcRxpkRR\n", + "N7VjT5bpeSyxDzKm4Ws0L0Vq3qAA4Wc5dv/EmBkbalcnUKIiqL/44pQUECi1i9LebvhL0vfYBWNZ\n", + "7N+/v+p77Dl55ZVXrvs5PlI8y0pK77S7ahxqWJEyxhhjjGlkaYrU008/Xb0DNEoOVtxYRQqrD6UI\n", + "hSfOloniQpmp9S+IVhV+D1gvnK91PyD8NDhO3LEc5YSoL15ZH8faZb+k7du3S5IefvhhSXnGaNb7\n", + "KT+gHLN9sPAJyxSpUjnU7giegVVIe6ndLymCfwWqBP4gpeNFq5Z6yPaVwtqjvONeefOG+qUdoayh\n", + "LGJdlzL40+64n3nT4v/DmEMb4Zo5FveYZayeFdPuZlAiy8Q9a8gs3aqoZbsPMIbQB6PvVdyTLyMq\n", + "UdR3RmnsKY1dsY+w28D555+/4e8yaiPUM+IzrqQu33bbbeu+j5JL+T344IOjzptBBnO+T2T5oYYV\n", + "KWOMMcaYRpamSEn1ygOWeauPEb9HScGKiTlmOD7WTi0xao+ID3xFsPBbd+zGCkLhif4D+I4xu+fz\n", + "aCUy2y/N+lHUsFqiFVayjkp+BvOywoH6rS3vGJUXof2gwLWqFfghRPC5IhqTfkE9tkbd1eZS4n5i\n", + "lNxYn0LaK34rr33ta0f9fiy1/h9ridFYUSVElZ63IlVLq7/gOeecI2kYE2688caZXdNaok/QtKDK\n", + "oubv3r173e9t3bpV0nCf9NHPfvazGx6/du+7ki9URlR84lg9VmHie+x/+q1vfWvD71N+EJW71rEE\n", + "dR91HWUqU9mBZyOKUyzPzMdtLPh14hOHUhqjROeFFSljjDHGmEaWqkjVglXWupM2s3As7loLPYs8\n", + "wOrAZybm1EBRiDtfx0zTJUWO62YHa6yNaKXis4O1gHLSmtUZ6y6zMktWTUlxmlV0YImStQS16/lR\n", + "pSCrMhntKTcyv0eyDOlYrfhXxB3SMz+SjLgzO/nMMsYePwMFcFFqTklJrAGLuTanWGTaDOqnnXaa\n", + "pMGXJtZF9IeshTaGknDWWWdJOjjDdasPDirqli1bJA3+ltQ9bRClgDGD81Fu8f4Yc0rRf/g+1Ubj\n", + "QW20ZqxP/Ai5j6ydxD4bx8pWX6eSEgUxhxvPnlJOthIoUIyV2bOBPkk5cP7WXIDAsy8qbrSj+KzN\n", + "lCh2++B3Y9tPhhUpY4wxxphGDglFCuXm9ttvb/o9s1Re8ZUqrX9nSgVWBrPjaAVgvcTzYcWUop8i\n", + "WM28ZpmjS7N+ImFQtLj/+LuSv8O0uUHG5vKZN1jXYznzzDMlDfto3X///ZKGLMFx/Z+oyegrRXug\n", + "naMmtGYPRhVoVXAzSvnBOO9GGcfHgL9SZv2To2et9VnaFxGIhMVCRVEpqXeRaffy49ozpWLsWAG0\n", + "aXx9sjbOGJad/8gjj5Q0ZLQG6pryjiok/1NHKDSor6ilWU68ZfuoUe6MtYzlpbExKoqLiryFGElN\n", + "pvZpFSnqn7326JvRByzuIkJ/mjYSG6UrtmP6H6/4RmUwNs06p6QVKWOMMcaYRjaFIsWsH+uFWW6c\n", + "/bfOIpnFYh1gqaMstVoNzPKzdXCud1qfJWbzKF2tETJcF9ZCyUpojVwpwXGxxue9F1yJVqsffxN2\n", + "MEcFIZIoKlIlaymqKFxXjASi/Hg/8wco5Vka699D/yztg4biOC2l9rne57X+d8cff7yk4d6ntdhb\n", + "iUrPrEDtjT4lkdJ9o0LyPdokdY86jQ9NHEsZy/Fh4fv4L8Z9Q2FWUYCM/bWZ0iP0IcbAsdeV3d+i\n", + "iBHlrZCPjHpGkYrEnIrU+7SKFO0ty4QPJf/cPXv2THUdGVakjDHGGGMa2RSKFLN+Zs/4FM1qB2gU\n", + "LyxwfIQ4D1bsWGsjs3K4H6wv1vtbo6OwBnltta5idmCsikyZyJSokq9MCfJbbZZ9mFoVMRSpz33u\n", + "c5KkU045RdLgixbJfMJKihBWLWpArUIY6zsyNkcR7bf0u2mjALlf2mV2vPV8Amv3BcRSpu/zf9wn\n", + "kbqp3YVhs4BKiSIz1vcLGHPoq9EHjXLC5ywqUiUlobRn27SMHSuz9lP7bIj7VC7b1yvbfWIsjPVE\n", + "iGcqOPcf9+bj99NG75XGymU9U6xIGWOMMcY0sikUKWAWj1VIFuJp18uxirCu4vr+tD46KFuA1cpx\n", + "8QdotWb5Hdbe2Fk3VhYZy0888URJg6U/dt04ixqsZVqrpAR+Ia3tJuYnovxQSmIUGb5P5JU69thj\n", + "JeV+I9n5ojULqADRl6u0wzoRKplVPDafF+WJlZlZu9NmE6ZdtihbqKwl3x/Kjqg9LF3u7etf//rE\n", + "9zeLEpW1kQh1j18blNpMhLEyq2vKmSi8jFnlKmuFei5dx7TPglgvs4pgbaU1M36Edkd7yJQhxjrG\n", + "LMbAo48+WtL0Y39JZZ81cZ/ZDCtSxhhjjDGNLFWRwgeCWTzKDrNXrINsj7KMmH+HWXS2Xo8Vy2x6\n", + "7Lp2VGiybMGtWZDZL4vyqPVNQkHBOti2bZukQfHDPyG7nizip3Wn90UxVoki1wrEDPQl65+8URdd\n", + "dJGkwbevNhqU89EuUTAp/9Z1/9ZoxAza86ys3FbIbURW7VtvvfWZz2qj7x555BFJB7f9VtV3XkR1\n", + "tNQWYW2ZSIOiNPa+Sn2d8ma/z2mj5AA/THxtyPPVWi/0ydbM4rXwDKO8UamXxbSKGM8QlBnGJJ7R\n", + "2V55jJ3syrFopm2HY3dTsSJljDHGGNPIUhWpGBHDOjuWea31BeyQfcIJJ0y8j/LCLBkFCaWG/7Em\n", + "xuaVIuIHyPODssB9tvoWsct95qeAwsT94cNDOeLfgZKFFVnykZlVLpdIbWTVvMDKwl8iKpRZJu3s\n", + "fazdG264QdJQX7VkeZko/6weZqWaxPLIwBpFJSGzO4raAw88IKleFWpVaDn/Rr+LfZu6e+UrXylJ\n", + "euc73ylp6KMxWu8Tn/iEJOk73/nOqGubNdPWcVSmZg1jyO7du2d6XMaq6M/aSq0S1epfSTuLOeTi\n", + "6giZwWcdrZiNqdFHbiyMCYxR9L3MD7K0G0Er+PeW9k9985vfLGlYVbrppptGnYexED/X2rHJipQx\n", + "xhhjTCObImov5nnCyhmrWGA9Risgzo6ZvRNRgBWCclObM4Z8QS984Qsn3idfULTwxypsXFdUvCJY\n", + "CdwX5ci6NjlkiM6jvFnnjnA/rT5jJWalRKE6sMM99Uy0Z4T7jtbmtP4ccPPNN0s6uJ5L0Xvz9tvI\n", + "YO8/ygUrOV4n5Yt19vKXv1zSYH3SzrEaS/2G/lWy9mj3sf1xPnLarAWfEOo4qq4oNPwW5YNM57TN\n", + "ZStRsyL6s22W6EPGqNJ+kpkKf/7550uS7rzzzqmugzHkta997cT1MCbgS0e7IFcc/+NDxrMgRvbG\n", + "9sfx8Z2KEeUob7Rx3i/VG+039l0ykk8L/QH/xMx3btZKFGTnIxoTf1Aym4/1q2asodwz368MK1LG\n", + "GGOMMY10y4hO6bquX1lZWfh5jTHGGGPGsrKyor7vu/U+syJljDHGGNPI0nyk1ipS5HzAJ6jkmZ9B\n", + "hALZUzlHq/oV95UqMe35xhLPx/o7PiX4icTcJhEilvgd5cd6P+vzV1555cT55k1Wnvgc4ZODH0Mk\n", + "u29y03BftDfOg1/JX/3VX0k6OM8Tx6W94Zfw6KOPTnwfH1tnzHgAACAASURBVDX8BvDfedOb3iRp\n", + "8I/gvBdeeOHEdX7xi1+UNOQR++Vf/mVJ0tVXXz3xPfrNeeedJ0natWvXesWxsPZJDqDLLrtMkvTR\n", + "j35U0lCuRC7h25flmsHvhPujXeKDRn1Qv1dccYV+//d/X9Lgg0OZ448Vc7D96q/+qqQh0vL222+X\n", + "NPgP8jvqHJ+Vd7/73ZKGsqzNON7KsseWw/V81157rSTpjDPOkDREntKmiPIkoza7GNAn8bVjLKHd\n", + "0edp8/SF7P6IWM+i4cjTVdozEb/Fyy+/XJJ0zTXXSBr6Dj5F7I24d+9eSYNfL32Nz7/1rW9NHD/m\n", + "93rooYcm7mts/WV+kCXi+bLIY/o394FPHde/Y8cOScMYRP1n58uwImWMMcYY08imiNrDiotZfMeS\n", + "7TDeyti9yDIWtXN8lsm6tAM4VlCMplv2/lgR8nOh+JTKM7tvFCSU0Aj1NTZyoxasxgsuuEDSYMWi\n", + "ikQrkPrJIpRQxsj+TGQNis5tt902q0uvIqo+WJu8Pvnkk5IGKzKDKEIUU6zmyHr1WLunFxZorGuU\n", + "Byj14WzsabW4Ydp9LQ9ViAxlDKYvZ5GvjA3f//731/2cMSOOkaj2MV9S3NUBJZLzZ/m52CUBhakU\n", + "NRf3pIuKFApSKdKZPkBuN8jGcBSZO+64Y+J9yiPbvYC+Xeq7tbkCZxURnt0nY0iM4kNh5PNMiarF\n", + "ipQxxhhjTCObwtypzSZLfqPMh6p2D7pFwawfsp2rs735ImN3boeSj9S8M4zPSpHD2sRvpXYfJMBn\n", + "CesyUxHmvcN4tMJQXLiv+DnXk11XfB9/ilKOnmWBKlDaCxClLWufKHtr87iV1Nd47Ex1RAnCF4Yc\n", + "bBlZTizqgjot+bhEUCyebTDGUceZckEGavpypkhlbY33UXsZU2hzDz74oKQ8N12k9L3oS8f5UHj4\n", + "nzGbdsXuCRnkvYrtKz5TUbxQbLP+UtqdoLRas+hdK2gn1CfPVFR6nkHRh3HsLiYZVqSMMcYYYxrZ\n", + "FIpUyZ+BCIKzzjpLkvS5z31uLtfx/ve/X9KwboyVQMbqWlCOsD5Kvlu1ma1ZR8+sK9bJsWawjrBq\n", + "UYQWnUl71r5h3H/0YygRlbyS/8C8INoQyBpMvdWCD1S0VrFKx6ofi6akVGbqAtYm/ii1e/tJgxKF\n", + "WpeNPfSlWos1U9UZA7jmCG0hy9w8bZ4/7jf6Am12qJeSIlVSVhgzSz5L1M+2bdskDX6KPANOPfVU\n", + "SUOUWwRfOPwTUWziXndREaHtopzwOUoU98/xS6s20bcvEhWpLNo0a49Q8pGiHPCHbKXkY0j94lPH\n", + "dZPhnHpgNYJ+yn1nEcPAakEJK1LGGGOMMY1sCkWqBBb7vLOwo0SxbxFW61hFiuvESsqs0bGUlDvW\n", + "yePsHStk+/btkqStW7dKkr761a9OHHez+ZiVGLtDe+2eelnEyryp9e+Bkt/EZiHz7aN/jVGUpMH/\n", + "Ait6rb9GKVqItl7qS/g21frGYPFyXPog6maMCsLSzvIGwVg/QMBCP+eccyQNY9Cf/umfNh1v0dAX\n", + "uP9s7C/VI20kU+JQ688991xJgwpK/fA+oOaTMw6ob5QOjlv7zMpWLXif3GuMYdEvEuWqtNcdSiv3\n", + "R1Tg2AjlUrTdrJ7VjB1ZVCaf79u3T1K7z1eE+ssihSNWpIwxxhhjGjkkFCmYdr21BLlBshwhY4nr\n", + "yK1Rd5FSvq0sooJ8QpTjshSNWZUDYD1gLS5j/8gxPPbYY5Kkk046aclXshi2bNkiacgCjV9QFulW\n", + "gt9xvLXQFjLLNO5+kEFbKkXNoV5iKUdfE5Sg0047TdLQ52rHstboJ3yB8PVBmTpUwJeFsWysogDU\n", + "I/Ue83JxfF6JCGfspp5QDqMSFeE6GeNihDnnR2lDGeL64pjM//QZvodSQvvguCXfJZQrvs/qC/dH\n", + "O+bzTMnLIufx85w2JyTQ1/Fxi4pUbb64sYzNIWlFyhhjjDGmkUNKkTpUiNYGVsOslJJpM7jPW4kq\n", + "7Z046/VzrDWiv6JKUOsbBa1KSS2t+7ERQYK/AFZkyc9m2cT7jf2C/8kJRIQU1v1XvvKVdY8Da63w\n", + "kp8ZbeWEE06QNPiUEDUFKDpY8BlY4NxD9DMkimhtrqu1lHLIcdxW6Gt33333VMdZNPg/Tqts0GYo\n", + "36wNoW5SHygyROmVojfjvpCMPTGXG+0lKm60wyz6k3aUPUtQjkr+nfg2UQ58n1c+b/XrPeWUUyQN\n", + "e/JB62oSzzoidKMiyLOW617WaoQVKWOMMcaYRqxIzQFmxcz6sW5mtUP8tFbqvCHPU2vEUS2UJ+WN\n", + "8pT5U5BzpGRdzjvXTsmPIQPlCet1VntBzhusaKx2rFXUG/oD1jqqEdZ5lmeKSKYx0Y6xTx599NGS\n", + "hjIl/wyUoqCog8yCR43NoqKI6qPNRp+Peaujm5WY+XtaUIiiwkVfpE3S9+PeehGUJhQTojz5HeeL\n", + "PnaxvaAu08bxgWIMjdF59Al8hjj/UUcdJamsTnN97DHH96NiVMr9lz3DogI4bYbz0moO9ZDlnKsl\n", + "i/YtKdLP/H6qsxtjjDHGPIuxIrUOWAsxQqI2Q3ec3bL+jMXdGoECm12R4r7H5kUaC+WAlZlZr2Qr\n", + "Zp39y1/+8lyvq0SrIkm5jlWisHqhdmf2WYESSL+KOWi4H3ItocJgbVLPvI96QL8ak6kf3yeUCMqG\n", + "Y0ZFqgT3goJA2cY920q/x4cqKlKlfD2HK4y1KDqxDYzdnYHjxF0hqB/aJn2zpHAwlqNsohxxXVx/\n", + "PB/XTz1T7ygufD+2Tz5nrEMpZdcPFKmSjxS+VzyDsvbVuvsF94fSRX+oXQ0oHTcyq6i9OCaSF652\n", + "jLQiZYwxxhjTyGGlSGHBlnaVL3HmmWdKGnxusIZK+xhFmP0za86UhNq8SszqZ70jPOvtWCGUX6sV\n", + "wex+1hnCYznhz8B1Z1YL69yoDmR9JnoxKkTTRkWWIKqx9DnXEcsfa4n2XoqIidb1ohUpzpPtKRit\n", + "X/yJaOf4n8Ss5NR/i68Yx0aJaPWLY2zgOFEtLvWdmNcnQl0fLpT2V4zQNqJfIW2q1ocsK18UH3zl\n", + "iN6M6jb1i08bfYrz06a5v2wPRcYwjsfvOA4KEWo+7ZLyoq1TLjGX2nHHHbfufUboQ5yf++U6YgR0\n", + "bX2hdPE7yr31WUL9ZPXHs4Axgv60f/9+SQe3Dz7nelCgsz0Qa7EiZYwxxhjTyIaKVNd1R0n6c0kv\n", + "ktRL+nTf95/sum5F0rskkSDog33ff3H1N1dK+o+SfiTpPX3fj9uobgqmVaIAJQkFamweImbPrH8z\n", + "O2fdOFoptbkvTjzxxInjR1AymMXX5otidh4jPmqtB2b5WFvUQ62PVLY+HcEPICqDMbIlwnU88sgj\n", + "kgarDvUgWiNZ1t5ZUcqNg28ekTWRabM9L0qJghiBhBXMDvEZMRt1vN/1lKhSXibgWLT57373uxt+\n", + "PyMqCPTBUhtCFSU32K5du9b9HlFahwslZQOVlVfaTFQMGTNQqkqKIgpkHNMY61GYUHdj26I9MfbQ\n", + "hzguYyAKSHY9tH2eKZwHRQwlK0a/cZ+xD3Ad+P6Nzf+EShyh/HmW1K7GRF/B6Hs2lpgTMIPrLK1O\n", + "MOZn991KaWnvh5J+s+/7PV3XHSHpvq7rvqQDk6qP933/8bVf7rpum6S3Sdom6UhJt3Rdd0Lf94sd\n", + "uY0xxhhjFsCGE6m+7/9R0j+u/v2Druv26cAESZLWM6vfIOkv+77/oaQnuq57XNK5ku4cc1FY7ERZ\n", + "Ye0x+85yu2AVMKtv5b777pvq9zFyh3VrfHSiIlUCJYZyyaxtrJyYFRdi1lyukx3Av/CFL4y6Lq4H\n", + "qwzrvFbxYF2b68BKyHzAyDs0dq8+fodfAFZSZrXQ7uYFfg07duxY9/NMiYJpcwstWpGK1iz9uWTl\n", + "Yq3TX1B7NlKIa6ONUKBQu6ZVs+lTUYlCgWCvPdoi2dtLdXG455GK/ojUA0odygjlFPMTlZQolJzz\n", + "zz9f0sH+hCg8t99++8RxM+LnHJ96Z8zP1PzYzhgz2RORZxvHQZVFpWfsy+4b/8K3vOUtG95HCa5z\n", + "bL+gfUeftlaVn2dfSWnL8rRFps03lVHtI9V13TGSztAwKbqs67oHuq67ruu6566+91JJazWz72iY\n", + "eBljjDHGHFZURe2tLuv9jaT3ripTfyTpw6sff0TSH0i6NPl59eY3KBFYHWP9FpjNt+bAGBuhkIHy\n", + "w2yeyAAUEc4Ts9vyO6wPrFlm0czqS7kzMkUqvo91NdYHDFCEyLM1lqx+435lgEJRq0ShTMb1c+47\n", + "81X6+Z//eUlD5mzqJe6HRaZu1t2xrrk+6vmxxx6buP5f+IVfqLr+eYMPHwoR14c1yX3UZimmPKIP\n", + "X1RUURmIrMmgXFEIuS7UimnysVGX+M1FUGmx/MdG7AJlGzNg4zNSyls1dgykjDlf7VhGnWV+a9RF\n", + "a14r+kxU1WMEK9eBEkeUHJHFjH1ZvUXYUxGFJypg1AP7PKIW4zdKnibaC2oxY3Mcq6jvUm67CGMF\n", + "14dyxn2jcDGWxTGN16jm8/ss4zl9iXZCedDXnnrqqarrj1B+rbsv0E8oP+4vRvzOC9phbYR8cSLV\n", + "dd1PSvqspOv7vr9Rkvq+f3rN538i6fOr/z4p6ag1P3/Z6nvGGGOMMYcEP/7xj58RH3bu3Lnhd7uN\n", + "rPvuwLT6zyT9n77vf3PN+y/p+/6p1b9/U9I5fd//+1Vn87/QAb+oIyXdIunlfThJ13X9ysrK+Dsz\n", + "xhhjjFkwKysr6vt+3WWMkiK1XdI7JO3tuu7+1fc+KOmSrutO14Flu/2Sfl2S+r5/uOu6v5b0sKR/\n", + "kfQbcRJljDHGGHO4sKEiNbeTdt26Jx0bjRXBFwPfmF/5lV+RdGAmuRZ8Q8ZGEsQ9vqJvEOf55Cc/\n", + "KWnwJ8C/AF8ncsjgK7Jnz551z8f6POu1rJ+TW+UDH/iAJOnaa6+VNKzXxyy1kVLulejrwyv3F8uT\n", + "dWRk0LFRYax740dBOXGeP/7jP5Y0+JTxPcqPiA3uB/8B7iPu+4QfCH4R3N9rXvMaSdLHPvYxSbmv\n", + "HefFryDuC1bru5OVZwb9Y8uWLZIOzmo8q/OdfPLJkoZ2tHv37onP6V+UAxFH2fk+9KEPSRr8Vfg9\n", + "vnmx/RPNSL/56le/Kmnw3+A41CPt5+yzz64uy2nJypI2tnXrVkmDTw3+kvTl008/XdIQIZyNeUQi\n", + "X3755eueb17E++O+8LnJ/CJ/8Rd/UdLQJrI2StuiLVx66aUT55sVcZcFxuRSXzjppJMkHVx/jEH4\n", + "AJVy2EE8H/VPVN7Xv/51SQfnW8JPMz5D+P/444+XNDz78MeMz77ox4kfbqt/a4TzXH/99ZIG3zbG\n", + "XsZEfK6oj7PPPnviOIzljHU8cxlbeWZfdtllE+fl/hgbuS98yyhn4P4Zg3h2UL/47uEb9973vndD\n", + "RcqZzY0xxhhjGlnaXntHHHHEMxEOWGNE58RIFSxfFJZMaSECprTHW1SisPqy/FSA4hP304qUclVg\n", + "3ZT2XGvNvlqKrMmUKCI4SlYKVjXlzOweBWfsfkrUZxZtiOKDEsX18zv2RnzwwQcl5eUfsxFzPqLH\n", + "UKRKUZ8x1w3lNe+cP/STaaNKS1C/WT6rsfnQuG7aBf2Ifh1BAcv646OPPjrxyvVE63YZ0MYyhQnF\n", + "AaWmpL6XxprIrPYbjXBf2diAek7dlqIR6SulCGTUcxSOsSos111SyRlbUHZQOx966CFJwxjHakJU\n", + "n2N0GvWWtXGiDrPdFaCUU44+hUIWxz6UP1T6qNpz36X6yohRkGRYj7n7Ioxhd91114bHr23HPPMY\n", + "E2LkMGM69cT3Y3Qr79MO7rjjjqrzW5EyxhhjjGlkaYrUejNNFBpev/nNb6bfXQ+Updo95gCLFoWi\n", + "pCwwa2VWPzZbKvl24mweLr74YknSPffcI6msTMU8UPiM1JYb58PaLClSWE+81voJZJQUNI7PK1Yc\n", + "r1hBtWC9oYDeeeeoxPvPgLU5Kz+DDNoJVn/JSp0WlCD8V2KuHNp9KQ9UhPLGSuY19teSMhz30xur\n", + "gK5HTdb0GlApY/6e2Bdrx4ySah3hPG984xslDWUb+1AttX6rKBuolFmfRimI+3JmkM8rU6u5T9rM\n", + "l7/85Q2Pl8H1o3xFtZXrZazh+1mepFK+I37XmmcJKBeelVGx41kW6z0qM61kSl9JaZwXrJJQ/owR\n", + "5KWivKK/LatUjOUoZaXVLbAiZYwxxhjTyNIUqfXAox9LH+Wg1uIsWbIZWG1YkxdddJGkwRJn3ZVZ\n", + "P7Tu21PKFst91+78Hq0KFLZaRQrFg9n72HKPcN0xW27tdZT8GbjfVmvq7rvvljR+p3TIdmKfF1hT\n", + "RKtlWbZjxnXUkCxTfAbWNwrv6173OkmDWoO1mVnT0a+H49C+sPpQW/BHqPXTiDsgZMruGDK/sxg9\n", + "lGWIBu6VNn/WWWdJGnxTvva1r426rujrUcvf/d3fSZLOPfdcSUP011hFqjaCmkzcpb5bOxYAyhCK\n", + "AWMTkaU33HDDxHGJYhu7KhGj4mgP9CXer1Uss7GTsYO9FmkXe/fuHXW9kbFK6rRKFGS7QywLrof6\n", + "ZE5AFCb3jXK3b98+SUO7grHt1IqUMcYYY0wjS1Okuq47yNrBwseqY8duIiWYbZI3KePEE09suiYs\n", + "ZSxuosFq93WqBeuNWS9KAuXB+TK/gAgKHrky4u9Kfg5YyXEW38pYJQpQXjKlI+bHGpt3jPVuyomo\n", + "0bF+KDH/VKb4UJ58b2x5ABFDKGjHHXecpIPzN1Hvsb3WKptAOXNfKJtY2agOHJfzxtwrgK8VVh+q\n", + "DvXIcehv3Oftt9++7vVRHqhEs4C2EKHuSkoUKhl1jNJwwQUXSBrKiDKt3a1+bE42oGxvvfVWScOY\n", + "Oi9q9zelnOjjpahExkr6Or4v3Nc111wjafAbbN0bjnpDeaLNogiOVbgyWPVgDCqtGtT64dL3Mn9N\n", + "/BN5trXuRwv00aOPPnqq40wL9ROfpbSXWN6MQShTjJWUB3MNxoNSvwcrUsYYY4wxjSxNkdpIRSBK\n", + "DasKxSWzrFEamCVn1mUJrDZmoazPM+uOlj7W0djz4dNBhAj/o8hhhWY+PHFHcf5nlh3Xyyk/LHgi\n", + "iu69915JQ/nxeVQeapUxoJ7GKjCUe1y/x7qgPGgX/F8b+YJShpVHrpjMisusQa6vFK03rR8Cygvt\n", + "i5wmJZ+n2C7HqhpYr7QL/DfwryF6kFf8DTI/Ddo1fZ7/saJj1CX+L1leM9ov1nyr0jdLaIO0VRQN\n", + "lAzqYGyUVmsbwrKmrLHIua6xka6zItZVbduk7aBQwfve9z5JB0cDjoXfM6ag3GT+iJHajOe0h6jK\n", + "ZtT64ZbqE98sXhkL8T2rfYZRvoxN8Vk0b2IUXXzWUA/8T/9hTrFt2zZJgxJ6yy23SBoUZMayOKco\n", + "YUXKGGOMMaaRTRW1B8x2mTWinDCL5nOsLd5nVt2a+ZnZZ1y3J3IjkkULlda1YyZmrCxm9/h4cT3R\n", + "2ojKXFSQIvisoMDgY8PvmKUzC0d5a7WGuW6UjVrrN1u3xxrFmkdxweqI6+QliMKkXjM/haz+an3m\n", + "4v5OpdwqMZcR7Qsrsjb6jvZFeY31kaIfYcVF65rr4f6w2rP2Qrvk+1jB9LPo61byH6L+KZ955/Ea\n", + "A3VH36JtUZZjc4C15rWiTzAWUmcoVSgjs1Lzxkbcxt0RWuF89B3GntpdIWiDlFOW96sEfa707MFH\n", + "DGWQNj82Y3stcV9S4D657qhgUk/02Rg9WburwayJ+bli+415orjP2267TdIw9md+wMwtGKtrn4FW\n", + "pIwxxhhjGtlUihSzQXyHmP0y60RR4XvRh4f15taIBM7zwhe+UNLgG8UsOGZUzma1pdwvWC1YA1hz\n", + "/E9enSxiIPMhKkEerNNOO03SkOOGHbPvv//+dY8/lrE+VbWU8kdh3WJ94/MW926EWUXiZNB+uN5M\n", + "kaL+ecWKpL3F90tRlShI8bi1EPmUWfX0M5SrUnvhvunX3AfWOTmOOG+p/TAuUM+tkW3SoGTgIzGt\n", + "QoOChHrIvbbumzltBC1+ZqeffrqkYayYlRIVfWaou2w/T4i7I7RCBC1jJm29trxpu4wVjCFcV+2z\n", + "hDbIs4I2HRVIFCjayazGyhhBC/yPgsT56bv0IT7nfqlP7idT2qIyVdq3tla5zIgKLfXFK0oi94ni\n", + "yH1lueoYi8hDhspeu7plRcoYY4wxppFNpUixPouvELNmZsfMKpnNss6M9ZMpD7VgOXMc8lhxPbXW\n", + "ScknhevFBwerIfqKZBEDcZaM1VDrT4FisXXr1onjTWPZrwWrYFGZv4HyG2v1TOunEfNbwWOPPSap\n", + "nCsn5mXCOorUZrmmX9B/xt4fik8EnzL8LWp9xaJyTPunHXK8M844Q9JQjvTD6KNF/iz6R2lfs42g\n", + "raIGZ/degrrhXuI9l9oidURfxL+wVbFAEaAtZRGxs4K6QOGb936QwPlYRRibxZ9Vju3bt0/8nvpk\n", + "TC354fGMinssRhjbqYfaHHglSu2EPsd5GbNob/H+uB9U4troQX7HWEY51K6aRIWpFNVIv2Ws4zrH\n", + "RtLj17x7925JQz0SQVzCipQxxhhjTCObSpEClAxmo8yamVXzeeZzgpXRCrNo1knHKislRQormOgk\n", + "1pWZFXOf2X5N0aocm8sDpYScJ1gLMbJjWjLrHmt71lYy1il+EyWFMuYUidRGA2ZWE/VYUoRQDaIS\n", + "RdQd58fHqLRfGooUKshYdYDrRunh/qJPUm290b6w9rEWsca53qj8ZjmXsL6pt7GZ6dcy9l4yaCv0\n", + "fSx8LHRU0qgm8z6KCn2COmhViYm24rrwGZo2o3UkZu3HV4n7bPUNK0G5MYbxLNizZ8+o41DutFHa\n", + "eowMjv6xEeqdvp6ppJQLY/usx9yMuFpRymfGGNOqiDJWAO2kpMAxFtQqi/SPV7ziFZKGCPhszKNf\n", + "xLkDvl7UN/dPfe7YsWPD67AiZYwxxhjTyKZUpKKFH/f8Ks2Sp/XNwfcDS5dotlpqz0/uEDJE44PC\n", + "/e7atavqOK3ZkmO22yyiYVZgHTPbr/UPKPkdAOVQm5H94Ycfnvj/4osvnvh/Wv8FrCSsnUxBRUGL\n", + "mfW5H1QNIoGwku677751j0d7ReEZ2z6A31OetOvW3Eb0J8qB46IsocLgl1FS8hgPWvdXW0um/sac\n", + "dRH6LHl4HnjgAUlD28NXCSUi+u/xGlVGzofCMxbUbq4fFZjI3VmD+owSU7tHWSsoQPjIlPpYiYce\n", + "ekjSwbtKoBjFthh3g+D7jK1ZtFdUt1HUGBuzdrhoWpUoFLtWhZf7rz0/ChTtG79f+h3lzZgV20cW\n", + "XclYVfLRAitSxhhjjDGNLE2R6rputMVfO0sdm5U2wnXdfffdTb+vXd/F2sH3hd8xq8fqKc3ux0Yo\n", + "YD2iXDz44IOS6nekb6U1Z0ytdUt5oVC0KifQmiH/zDPPlCSdeuqpkqQvfOELG34faxjwlUJJoj3S\n", + "PvAjQMmJ7YPrblWiIPMjGAvXH/sv7ZydC1DkUKZQaksRQ7OMDsVnhj5SOja+UCeccIKkwdeGOqRu\n", + "aJsxz06pjY3NARbh+rkvOOmkkyQNYxBjQa0FnjHv3GxAedI2Wn2xGFsYKxhLY74tlDZ8bOJ+mzHq\n", + "Las32kXMUzVtvrBFQbuhHcf7nFaJLOUfi1BPsf5px+ecc46koX5R8RlbXv/610uSPvOZz0ycnzlE\n", + "7bPVipQxxhhjTCNLU6Rq1CisPCxhZp/kdmAWOtYK4jhYGSUFC+uHLMH8jii7mE+nNtIGCx1rEOuU\n", + "dXNm/TFSpHWH88i8/CUy4o7aWAXRKo9789VGzxGtiVVB+aHc1CoqZIHGhw1rMbbZ6O9CvXB+FL6x\n", + "ymtUkqK1GrNmL4pps1CXog3jfbbkIqKNsY8ldYLvRdbm8QeLkabUMX56UXmgronwxSLneCg+KBko\n", + "Ehxv//79kg7uA7TZWCb4btB3UCfxx8Pvj1xb3Dev+HQxtqI68v7YCOB5Q/2x/yhjMPdDffE+9UCf\n", + "pPwZc6IqWqtkoUzUKhTZMyD27Xn7kgHtg3bD2MizK/qLRig/xthZZ8hvhf7E2BLHmJ07d0oa2jf3\n", + "zzP1pptukjT4Ccd+WLsKZkXKGGOMMaaRblaZVUedtOv6lZWVhZ/XGGOMMWYsKysr6vt+3eUgK1LG\n", + "GGOMMY0szUdqrSKFz9HY6LPacyxK/ao9X8nnB78HcsA8+uijG57v937v9yQN67z4VWQ+YDG3DH4C\n", + "cd+x6Pvznve8Z8P7MsYYY55tWJEyxhhjjGlkqZnNiYghGyn5ZMZCpAlZgIlY2ayUIh1QgMj9kilS\n", + "8Xgxb1IWjUhumSxHztgd1I0xxphnK1akjDHGGGMaWaoihQ9OloGZnCn49PBK/hyylJLFdFZKynnn\n", + "nTdx/i996UtTHQ/fpZipOoOcF+SpaiXmOTLGGGPMbLEiZYwxxhjTyFIVKYiZrIEsxSg4+AJ997vf\n", + "Xff7s8r4TXZUdnJvhQzlZIXlfoiqIzoPXyh8u9jHKWZZHouVKGOMMWa+WJEyxhhjjGlkUyhSRN3F\n", + "fW3YByruQp+B8tMKyhDKFopSaY+wCL9jnyf21WLvNYg7geNDtXv3bknSz/7sz0oa9ulC0VrU/kzG\n", + "GGOM2RgrUsYYY4wxjSxNkTriiCOeUZB4Jfou23EZpQelZt++fRO/I5N3K+wIzfnZgX0s/I48Tlkm\n", + "czKKx+vGJ+zb3/62pCFakfucNy996UslDUog5WKMMcaYSaxIGWOMMcY0sjRF6nnPe55+9KMfSRry\n", + "HfEawWcJpQTfIpQelJpp9+ojmm5ayGdF1BzXGUGhyjKMo0xRLplSN2vIkE7+K3yzjDHGGDOJFSlj\n", + "jDHGmEaWpkit9RdC+cBXKGY6J/qN6D7yLPEKi1JsSsT8TdNG2X3/+9+f+P85z3nOVMeLxAzo+HZl\n", + "e/UZY4wx5gBWpIwxxhhjGlmaIsV+edIQFbb2vfX4e1kaUwAABjpJREFUp3/6J0mDz1FUpNgbLyo4\n", + "reCbVdobD58tyKL0poXjEsUXQdlDWYrRdnzOdZ166qkT/+/Zs2fd484qY7wxxhhzuGFFyhhjjDGm\n", + "kaUpUs997nP1z//8z5IGpQSefPLJif+jkpJF1z3xxBMbnpMM47U+SyUlCl70ohdN/B99pFCSiH5r\n", + "9eXi/p9++umJ98nDFaMZeR8Fi+viOjgeUXr4qKFAEVWJb5oxxhhjJrEiZYwxxhjTyNIUqf379z+T\n", + "PwnFqaQAoaRkeZlKoBzhO8Qrx2vN4H3UUUdN/B+VHxQhlB+i5F7ykpdIGhSyWqUqZjg/5phjJs6L\n", + "oke0YzwPn/N/KTovRlEaY4wx5gBWpIwxxhhjGlmaIrU2mze+UhnkTUI5yTKBZ6B4odC8+MUvljT4\n", + "EKHM8PqCF7xA0qBQxfPxO5QgXiP4GJHpPML9sDdfq+8Ue/ZFZYlM79/73veajmuMMcaYjbEiZYwx\n", + "xhjTyNIUqbWgAOH7E6PyHn/88arjoOzE/FLs0XfcccdJkrZs2SJpiEZ76qmnJA1Rb/yeKEAUMaL+\n", + "TjvtNEmDghTPV8tYZS1j1hnI8ekieo/8XWYx7N+//5k2apaP62Pz4LrYXLg+DmBFyphNRimNh1ks\n", + "ro/Ng+tic+H6OMDSFKkdO3bo1a9+9ULO9Y53vGPDz1GqIueff37T+VZWVpp+18q059u5c+fC6sIY\n", + "Y4w5nLAiZYwxxhjTSFebvXumJ+26xZ/UGGOMMaaRvu/X3Xh2KRMpY4wxxpjDAS/tGWOMMcY04omU\n", + "McYYY0wjC59IdV33+q7rvtl13WNd112x6PMbqeu6J7qu29t13f1d1929+t7zu677Utd1j3Zdd3PX\n", + "dc9d9nUejnRd99+6rvte13UPrnkvLfuu665c7Svf7Lrudcu56sOXpD5Wuq77zmr/uL/rugvXfOb6\n", + "mCNd1x3Vdd3Oruse6rruG13XvWf1ffeRBbNBXbh/BBbqI9V13U9IekTSayU9KekeSZf0fb9vYRdh\n", + "1HXdfkln9X3//TXvXS3pf/d9f/XqBPd5fd//l6Vd5GFK13UXSPqBpD/v+/6U1ffWLfuu67ZJ+gtJ\n", + "50g6UtItkk7o+/7HS7r8w46kPq6S9P/6vv94+K7rY850XfdiSS/u+35P13VHSLpP0hsl/Qe5jyyU\n", + "DerirXL/mGDRitS5kh7v+/6Jvu9/KOl/SHrDgq/BHCBGH/w7SX+2+vef6UCHMTOm7/uvS/q/4e2s\n", + "7N8g6S/7vv9h3/dPSHpcB/qQmRFJfUgH9w/J9TF3+r7/x77v96z+/QNJ+3Tgoew+smA2qAvJ/WOC\n", + "RU+kjpT0D2v+/46GijGLo5d0S9d193Zd959W3/uZvu/Z3fh7kn5mOZf2rCQr+5fqQB8B95fFcVnX\n", + "dQ90XXfdmmUk18cC6bruGElnSLpL7iNLZU1d3Ln6lvvHGhY9kXKuhc3B9r7vz5B0oaT/vLq88Qz9\n", + "gfVe19USqCh718v8+SNJWySdLukpSX+wwXddH3NgdSnps5Le2/f9xOar7iOLZbUu/kYH6uIHcv84\n", + "iEVPpJ6UdNSa/4/S5AzWLIC+759aff1fkm7QAfn1e6tr4uq67iWSnl7eFT7ryMo+9peXrb5n5kjf\n", + "90/3q0j6Ew3LE66PBdB13U/qwCTqM33f37j6tvvIElhTF9dTF+4fB7PoidS9ko7vuu6Yrut+StLb\n", + "JN204Gt4VtN13b/uuu45q3//G0mvk/SgDtTDO1e/9k5JN65/BDMHsrK/SdLbu677qa7rtkg6XtLd\n", + "S7i+ZxWrD2q4WAf6h+T6mDtd13WSrpP0cN/3n1jzkfvIgsnqwv3jYBa6aXHf9//Sdd27Jf1PST8h\n", + "6TpH7C2cn5F0w4E+on8l6b/3fX9z13X3SvrrrusulfSEDkRmmBnTdd1fStoh6d92XfcPkv6rpI9p\n", + "nbLv+/7hruv+WtLDkv5F0m/03opgpqxTH1dJelXXdafrwLLEfkm/Lrk+FsR2Se+QtLfruvtX37tS\n", + "7iPLYL26+KCkS9w/JvEWMcYYY4wxjTizuTHGGGNMI55IGWOMMcY04omUMcYYY0wjnkgZY4wxxjTi\n", + "iZQxxhhjTCOeSBljjDHGNOKJlDHGGGNMI55IGWOMMcY08v8BGKNoaFbqcjsAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['conv3'].data[0]\n", + "vis_square(feat, padval=0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The fourth layer output, `conv4` (rectified, all 384 channels)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXvQZVV19vtsTbxHEy+A3OluupsGBJHCexEqVuqzEv0S\n", + "K/V9aGlSGsuYxBK1SOSYiK8GRVNENIZEy8o5ieU5+BkrWqlUWQaUEFEJcpVuaGiguSNijOaeiNnn\n", + "D/j16v287+x5WWvtvd/u8ftnd+9377XmmnPMudd41hhjTqbTqYIgCIIgCIJ6HrPoBgRBEARBEKxX\n", + "4kYqCIIgCIKgkbiRCoIgCIIgaCRupIIgCIIgCBqJG6kgCIIgCIJG4kYqCIIgCIKgkVFupCaTyf+Y\n", + "TCY7J5PJrslk8s4xzhEEQRAEQbBoJkPXkZpMJo+VdIukl0m6T9I3Jb16Op3ePOiJgiAIgiAIFswY\n", + "itRpkm6bTqd3TqfTH0r6jKT/OcJ5giAIgiAIFsoYN1KHSbpnr//f++h7QRAEQRAE+xU/NsIxs88K\n", + "J5NJ7EsTBEEQBMG6YTqdTtZ6f4wbqfskHbHX/4/QI6pUlp/4iZ+QJP37v/+7JOnhhx+WJD31qU+V\n", + "JD3xiU+UJH3ve9+b+fxjH/vYmfd/9KMfSZJWVlZmXkvP/8///M9Fn3f8fBs2bJAk3XHHHU3HS/HM\n", + "Zz5TkvSWt7xl5nxjU9qfxx9/vCRp27ZtkqS/+Iu/mPn7kUceKUl64IEHJEk//OEPe51vKDjP+9//\n", + "fkmd3cE//MM/jHK+ZRu/yeSRtYL58E//9E+DnO8nf/InJUnf//73Zz6HvTBfvv71r0uSfvzHf1yS\n", + "tGXLFknSjh07JEnf/e53JUlPecpTJHXz/+1vf7s+9rGPSZKe/OQnS5L+4z/+Q5L0ne98Z+acBx98\n", + "sCTpMY95RJTHFp/2tKdJkv7rv/5LkvTf//3fevjhh/fMOfrkta99rSTpwgsvlCT94Ac/mDn+qaee\n", + "Kkl6/OMfL0n62te+NvP3zZs3S5L+9V//daZ9zIWf+qmfkiQddNBBkqRXv/rVkpbHVg499FBJ0v33\n", + "31913KOPPlqS9I//+I+Sun5b1Fz44Ac/KKmzE+yGcfmxH3vkJ5I1q3QtZ9yf8YxnSJLe9KY3zZw3\n", + "BbbMb92//Mu/FJ3PGas/n/SkJ0nqro9xXNa1DGjvf/7nf868zxqS6+fTTz9dl19+efLvYzzau1rS\n", + "sZPJ5OjJZPI4Sf9b0l+NcJ4gCIIgCIJROeOMM/b598EVqel0+vBkMnmLpC9JeqykP01l7HE3iEfK\n", + "3S53uShSeI14ibziFfH67W9/W5J09913N7Wdu1ZXpGgnlHoJQytRgEdeC94VXhLXgfc1FHh1P/Mz\n", + "PyNJ2r17t6ROiTjkkEMktY9TK3h7KJY5sDOUkVawK+wYxXVZoZ0pO0epq1WqXImC++67T5L0rGc9\n", + "S1KnQNFvqBZu97SPdUN6REGSurFL9fWDDz645vvMfY4D9MkTnvCENd93+L7PLdYS2sc1uSpLO579\n", + "7GevefwU2Dh90qqu56hVooA1yBW8ZcHHi98g1rBSUD5q+4m1CQXU5yBK1aLWELL8U08Rlg3mJwov\n", + "9whw+OGHS5J27tzZ6zxjPNrTdDr9oqQvjnHsIAiCIAiCZWGUG6lSuPvmFSWKWCfuyv/t3/5NUncX\n", + "zudQPoh3cC+yFvd4USJQvPDuWp9bLwo8e7yZlDc+FMQSffOb35TU9RvjefPNdSXFHve4x0nqvPhW\n", + "UFKwnxR4W0N5Xf5cftnJKXatMVMpiJ0iHggvkvn30EMPrfk99zalzmNmrUBBwnawQVQw5+lPf7qk\n", + "1WsBSgVrjp8PiKHCZom9AdYoYrJStuEqZimMHe3g/Lzfd43sC4rZskA8YA7GHVvjN4ffpptuumnQ\n", + "dt177yNhxaxZzI1aZWxomFfLNo4psHdXoqCvEgWxRUwQBEEQBEEjC1OknvrUp+7xunhuzvNoFCky\n", + "WdyrA+42ed7uGQ99QZG49dZbBzneosDrnZcygpf2hS98QVL/bLe+SlTf4+C1Dr0LwKLwzDReUS3w\n", + "glFn+Dv2UzuexOtgFw7qzJ133impU7w88w51hnnv81/qYpBcUeK7rDkoVb62cE7/Pm1yG3B1mr7y\n", + "46JQpfrAQQFrVUUZO7LNWEtzcZs5BYy/YyOpuLcUjPGyUBprxDjzes89j5RKHEuZ4bcQuxtaBT5Q\n", + "GOppRo5QpIIgCIIgCBpZmCL1tKc9bY8HjCKFF1cag0RGBLEUxFrUZlnN6651WcllgtQqfHhpjIcr\n", + "GNSSmbd3irKEfeS8fZQbvPBcbFXp+RetbOUyppgHeMWoPLXxOpBSlAGl69prr505L3B+7AnFGvZe\n", + "L1CaUKs8Zgr1C2WKTEEUhrvuumufbfUsOI854lpoBxmyrHGo26UKQ2vGKH3I3CXOM6dIpWKomNPY\n", + "AGtmLestXhBSGb+lGcCLorROUi1jrWHEgnndt1YYN35zXM1mLSlVilOEIhUEQRAEQdDIwhSphx9+\n", + "eM9drddUqYW7Sry+2rgCvDZiOWhXaa0Tz+RZb9Bf3L2jnODV4s2WwnG85g7/X1R/cZ2lmTqeOeUx\n", + "OrV4LOBQDK10oRowH3OKEtfF+d1LL+0v1Be+z/Hwpkvshjnr8V+AMkX21d41qFrg2v082A5ZgsQ8\n", + "1Y6917ArBVvH06YvW2uAeYb1stdCGxrfRWPoXQ5ScD5q7zGOrXW8hmLo7E/WMObTUGCnvi4w//nt\n", + "D0UqCIIgCIJgQSxMkdr7jpZ/lyoFDnELeA21z+G5GyXTBeWEOADuZvEm/W586MrgrXh2VKmCkvOS\n", + "a/vTFQmPNUrV8Bmb2usgIwm77OuFedxOLbTDlb7DDjtMknTbbbf1aF0H7cspUd6u1HWVKma58Snp\n", + "t1TNKQebv+WWW4o+D9gyoJLh6fJ/roX3iU0q9Xx9DaqFdriCNFSWWalt7C+MVSE+BQoUiiYKZ23s\n", + "0LLXPOQ3wffNHBoUWN9dYqiYvVCkgiAIgiAIGlmYIvXEJz5xj1fIXSiKUqlXCTxX5W6z9nmn78/l\n", + "MUM8R8ULW9bME2JM8F6GqsxNlV3IKQzErJGBQcYECk8uM2pZGDqLs2+GD/09VHwP9I3dytkZ7cwp\n", + "tzllOjWvW5TsnGefqjPlMRyuUqIEoWBwzbUZj4xF65gwB4lvZA1j7z7WsNbYkPWy11qO1Dg7ubk7\n", + "dHYc9kI/kzG8KDV/bIjda1Vgc7AGcR7mQ+29RopQpIIgCIIgCBpZaIyU7wPFXX1tFhL7HuENuoKS\n", + "Ay8TBcoVJ7yDZa8Zgnc8tGKGogS5ccHL9XEl06W0jlMwC3ZI7aPWHeYd98qHzirk+DlFiutDySQ2\n", + "MZch1hJzRjyk16RK7ZEHbrOeoco1sLcXc+e4446T1GVC5pQLxqB1LrMGHn/88ZK6NY692vpmKe0v\n", + "DBXrNXScLPXO+C0cqq7SsuG/WWNVcOc8zFfm11BPHUKRCoIgCIIgaGRhitSPfvSjPZ4msTN4lsT4\n", + "lHoLmzdvnvn+3XffPfN3vMxU1t0xxxwjqfMq8fC5O172DBWe9+L14mXzXBgFaNeuXZK668JLJeaG\n", + "jKQtW7ZI6u7et27d2tQuvDQyT+hfKlQP9Xz6QMG9N9SNvl4cKgoxiihBQ9WKKVWMUC5RllFNmLct\n", + "CqZnsrIWEDvE3/H8yYCkAjlzadOmTZJWq7O0iePQl1wzfeg11EpjaRiTVpiDVFhvrdW3rIxVm62U\n", + "VMXzvngNtf1dvR9bkfK9K7GboeqhhSIVBEEQBEHQyMIUqcc//vF7Yj3wDh988EFJ5QoQ3tpRRx0l\n", + "qfM6N27cOPM5IvVz3hiZNuvtefSLXvQiSV3tEbLiPG6Du3IULBQAvB+8VvqBceB7L33pSyWt9vLx\n", + "sj1OgLt9+p0Yqb571rXC9aaqXq8XiJ9ozRBC8c15gXyOfmN8GX+PL0qR86Y5/uGHHy6pU1C9HprX\n", + "8sG+mf97g4rKsTkWawavXDtqLrFTN9xww8zxvC3edo8H5Dh4vrfffrukTn2nD/mex0Lx977xb5yP\n", + "623du29ZYTywVfpzXgrV2HGzpbtrwHod37HH64gjjpC0evcSfotST0d4mpIjFKkgCIIgCIJGFqZI\n", + "HXXUUXuUDOIP8LBRRvDiUDT87v+MM86QJJ188smS0tVnPQaEOAnuTvFs8Zz5HMfzGhSeAeD1fHif\n", + "bMKUV+k7qrc+B6c9O3bskNRVa/a9y1CIyIri7yiB9DPtQLHh+yhSfJ/+IbaKzxNvwveouN16fcTA\n", + "EbdSC94qit0999wz8/exqumORa2X2orHFjK+td4jmWOuoKHW8OpVw71+G9/nFa9yLS98586da7aF\n", + "c51wwgmSOvUadZysNo+dYA6jVqMCP//5z5ckbd++febzvrs8/yf+0FXdb33rW2tee25PN/oMtZC5\n", + "t2HDhpnrYo058cQTZ47vKv16UTQYR35DeMUmSustedwmYPuuLKIGk5XJ2kGcqSsYrbt1pKBdKJ/Y\n", + "F9dRuy9qLZwnVfORGEMUVtZ8vsf4+Pyin7Bn1mz6l/7n/VJ8f07/baJdqUoBpdmYoUgFQRAEQRA0\n", + "Mhlqx/iqk04m05WVlbmfNwiCIAiCoJaVlRVNp9M1JcZQpIIgCIIgCBpZWIzUPBQpzvGJT3xCUvd8\n", + "e+zzffzjH5fUPUd3+tY+4bnuOeecI0l63/veJ6mLATryyCMldc/9/+7v/k5SF4/Bc3xinq644gpJ\n", + "3fNunvezLxfxFb/0S78kSbr00kslSVddddXM5zi+x7oQ08L18nza3yd+hBim3/qt35KUthVq+hC7\n", + "47Fo/J2YolS2IHEQb33rWyVJH/3oRyV1sTmMV+sO8B5bx/ne8IY3SJIuuugiSeV1tYhvIc6AOAL6\n", + "PZVNRz/+3u/9nqQu3mKoWiqp833oQx+aaR/zglg78GxZz7BJtRO7f/Ob3zyXdUXqru3888+X1MWE\n", + "EJPEXPAYi+c85zmSujH8+7//+5m/00fElnAczpe7PuZqaw0w2vXOd75TknThhRdKWp2VyJwg69Ez\n", + "P4lNYcy8PVwn/fXa175WknTeeedJ6jI4mYOpKvesZbTb4x+Zex4HedZZZ0mSLr74YkldXOlYMG6X\n", + "XXaZpK4/6Rdsn3hS+pkYPNZKYtpYoz0Dl+t8+ctfLkn68Ic/LGl1HC52uW3btpnzsaYDazL9S0Y4\n", + "40H86plnnjlznaUw/rSLLNMcpfNhKLLzbi6tCIIgCIIg2A9ZmCI1T0rvcocCL8q9BTJi8MTxKsj4\n", + "QWniNdVur7OFV4MHj0KEJ+/1kvBqPv/5z695fNpF5o8redddd93McfFSoLVieSrTKgXeaaruF+3O\n", + "7VfmmUpD17lyb90zeehv/3vqulIZL2TS4L3yvl+/Z3GODefx8+XqtZXuB5dSfhcBfZvK9iE7DwXA\n", + "Ye6jFtbuicf3U9/LKVY+Rp4hWlq7LJftxBrmY+d1obDdlK3magOidqOoeEzwHXfcsc/vDw1rC+NP\n", + "+31/WPr5y1/+8prHwT7YlYPsTq4XRSpXKdyz8ADV/JRTTpHUZYT72tiq0sP+srtFKFJBEARBEASN\n", + "HBCKVF/PO1VjIodXQeY5MJ441VYdf56Pt8Dzfq+R4u3Dy8BbQPEovfun7g/xB+4t4d3hdQ613xXP\n", + "y0trd+CtpsYlp0SBK3zEb3gtFNQG+hslq7ZCOv0F2CfHqbVX+h1lEG8XhbK1Uj9e71gV4LFnvN87\n", + "77yz6Tjen/PEbazU5lzZYayY6yhGtR57SonCJrDZRe0uAPST95fbmlfXr63mz9qQquI/7z3siF/k\n", + "t4FXxj+3pgFrEGs036u1FxRH1jziSn1/1FQtRGoQHuiEIhUEQRAEQdDIAaFI5SBmyTMkeO7sVYcd\n", + "r2yei8nCg8b7QjGiKi3PowFlKfU8Gu+FSvAoRnineCm0E+8jlcXI5/m7x0B5jA/XQzta959yZSYH\n", + "19E3Bs6VQ9+3y71WvHrGy+3FvUk/vseneKZRX7wCeCtkfaKS0M6hFCrUAewVhap2B/gWJRT1k6wk\n", + "bJ051EpOTcVmsS3mKDbHXCrdx7CUUltAgVg0jAdj2/pUge+hOrfWTeQpwQte8IKZ97/2ta9VHQdl\n", + "h9iwVhWftZynE6i5tbs0+K4FrGlkXe7atUtSejeFee1puOyEIhUEQRAEQdDIulSkWp+Xp8ATfvGL\n", + "XyypixG6++67JUm/+Zu/uc/v1+6n5HuI5eoc1YJy5cfD+80pRng3KBKuqLgXwvN5YmroT49PyHmV\n", + "peOJt4SqgBLUag+MB9BPqeNhf1wn8QTUM7r55pslra4VAx6TVYvvBVlLaa0hYqu4Dq43lylVyyLi\n", + "LFBdU7EzraTiBelzbBdVk88xV1GEcjaCIoGSgKJVGl+YAhteNPRTrvZfqYrZdwcP5gD2wh6NtVAf\n", + "C3tojQtE2WRfWhQur+GXm+usdb6G83/iY3l/rJiyVjW6Fp7+0E/Mu777l4YiFQRBEARB0Mi6UKRQ\n", + "APDSWmNwUlBN9pJLLpHUKRyld9+1XiDxD0PHQbhSk/K2c5lFeDcHH3ywpM7rAVe68PZ4xcum//oq\n", + "MA7eFd477WtVpDzGLffc33eGpz1cJ3EKKTv1/q/NjuPzrdRWvd60aZOkbnz5/tD2uwiG9oA9PtFV\n", + "yVT2k7cH20q1DxtADcfTRhFzDxsFLLemeQZkzpbHotTGx1YwnKuvvnrmtRbicfvWX+K62cWCNd+V\n", + "t9xcR13GXvmt5beEtQrFqK/imWJe40j/8Bs21FOtUKSCIAiCIAgaWReKFDEo3DW31sXJwb5XPBcm\n", + "g2Fez2+B5++1GUQoK8Q20V7iQWq9SrzXnHeI14r3g6JTq0SV1qPifBzfK5MD/YD90A/urXsMWE4Z\n", + "IksQb4Z+wrvzfvY4BW8v3l+pIoViOjYvetGLJHWZbV/5ylckjadE+T5upbF1ywRj36rg4PFjsylQ\n", + "NLAt+iplQ6XqeqoKfg7Ua2yGuLevf/3r+/xebXzpesczfFOgbPq+mowHc5A1hzXR50qpEondcRx+\n", + "a5mLHGdRCuVQjLXLSShSQRAEQRAEjawLRWpsJQpQQjgfGSO5jI++MStOq+LgShBeAxk9tft24YXk\n", + "YqpckWpVEEprkjAeHpPkoHDwmlIU/bxe5yv1ef7O/2kH3+eV/uf8vs9arf1wXM6XGp++2X14b9/8\n", + "5jclra4nNjT0A/3Fa98aQGuBesucQBkhhqU1k3Ao9Szn8fN3nwt94xFLK7M72Nju3bsllXv+qTHd\n", + "X5WqXEYw6vRJJ50kqVPP2ROQOcHaQ6wP4+ZrGYpWSpGi/1lTaB/HoT3MTY43VGzR/kIoUkEQBEEQ\n", + "BI2sC0VqbCUKiDfAG+KuO+cdDl0NuPU5rtf6wGtprf2BIpW7flcOxoLrw4tifIgnwXvieT/qAOpC\n", + "yo7cC+c4nIfzclyvSo0yRH973SX6EUXKvfBUjFcK7DOXkVOrQDo33XSTpOEV1xT0uyttKHh9M532\n", + "Bpsl4/Owww6T1HnirYoUa0hrDImruzn4HLbZ9/ytVeuxtZ07d0pavRaU1seCVmUsxdj7RpbC+KT6\n", + "gXGkvpTvvUfcp8fEpdTu2srj/nlXBkOJWptQpIIgCIIgCBpZF4pUaSXmvuAl+M7cufN61te8wbv2\n", + "eAnaxfPvWmWqVNGif/pWvc31N+/j/RIfcMwxx0jqnt/j1ZXGmrmiSP9xPq+h4nWz+D7KEt4vqoB7\n", + "wV6Lxe0nlxlT2s9DZdb4XopjVTdGcUJhxK49q3EItYLYE86BeknGbilUSOZ4biu1CgiVr1HKSqvI\n", + "Y6t9Y4v6qo/MBc/gre0HxrwvrAlkQteO79CUPr2g3ti2bdskdYoTawP9g/1SR4y4SCjt95Ry5ZX3\n", + "g7UJRSoIgiAIgqCRdaFIja1EAYoC3iAeODtsl4JXWJplRHVavJDa59ooBMQA8Rwbz71VmfjWt75V\n", + "9Dm8vr5Ze16d2fH9yfi/V1SvBa8O6E/6LbXfF+P87Gc/e+b/xNekYpRc0fHxwWtNVRGed12zvrFW\n", + "pRAb6NWaURaHjJvBVqnizzXW9ik2iyLVd88u1ppcXagUXlm9Ft93shbGkLlQ2x5i1Y466qiZ76G0\n", + "UFuvdK670rjommSl52dNIosUpXDXrl2SurXBlSJX4b2fUmsHShfZrNgf/08pUot+GrMsRC8EQRAE\n", + "QRA0si4Uqb5wd5/zaPGCUARQCnK1OPzuvrbeDRW3W3HFbmwFwesTkSlCv9HPuevyqrup7DXiATgP\n", + "44JyRe2aVMXynKLpXn+pt0ssFf2AHdQqgK545vazmvf+YvMG9QB7GLt+ldTep65W9lXPUQZq49Bq\n", + "VfAUHmPTCkrKEUccIUm64YYbJOWvi7nAdaDSe9xhLWNVtC7djQFKM9D5zcK+uO7c2pCzP+zLsxj5\n", + "nmfGomCldjMYyl6c1NpN1uKyEYpUEARBEARBI+tSkfL9hxzPXMl5C9xVc/eL94K3wXPilNfqd814\n", + "0p5JgxdAe8hO4nPs+I6yc+211655Pry9FHiBeBsoNbkaLig/fJ92UE8I3KtEeUp5S3hXjBvepitI\n", + "xKs4KFz0E9fF9aDA+fP6Uu/VvS3GBQWMTCrOz3HpH+yEeJlNmzZJ6saTz5dWIOd79Cf2gh1yPo6L\n", + "vdEeMr2IMfJMJfZFo98YH1dD3F6Yb4wfxydzjb/33YuP73u9sGWEMcd2iZdjTOlj/p5ai7Zu3SpJ\n", + "OvHEEyV1awYVrQEbZwx9/0aP78vFWHEcjouN9YX2Y9O1ChtKFCy6/lMK1rTSGmf8BuRipfitod8Y\n", + "J9Yi/p5TUvk8c8nVfcaJfWVdVceeDznkkJl2s5Yde+yxM+cjvpjx8qcWnnntYH9kK3q8bC6Gj7+z\n", + "NpXGLvKbx/igjD7vec/b5/cgFKkgCIIgCIJGJkPuX1V80slkurKyMvfzBkEQBEEQ1LKysqLpdLpm\n", + "obZQpIIgCIIgCBpZWIzUysrKnliQvjEVxHagrhGzcdZZZ0mSPvnJT0rqns/yPJTz3nbbbTPHO/74\n", + "42eO5zFCPC/muTXPgX/5l39ZkvSpT31KknTPPfdI6mqj8LyX8/E896d/+qcldc+fL7/88pnzAzEw\n", + "xPC88Y1vlCR94QtfmLk+njNzfbfeeuvMcX7u535OUlcb5Otf/7qk7jk2mRFcJzEqZ555piTpox/9\n", + "6Mz3UxDLxfPpXNYkz++JC3jXu94lSfrc5z4nqYsv8crzZO1x/C1btkjq+pesL6+VwnN6rvMXfuEX\n", + "JD1imzVwncQVlFZU5zy58/G8P1VlmPPnMoI4D/1JLJVnWxLfQDVo4hW4Lvob+yL+h7gg+uHss8+W\n", + "1NkLxycuw/e0zMH4EdPFK/Pvd3/3d/dcG5/FBoj94Bqwda+8zdrB32mbz8VXv/rVkqQ//MM/nOkL\n", + "YK5jW8ReUGOMdjGXicnwWBtqar3hDW+QVG6bHjNVC+f52Mc+JqmL1yNuDttgDrF2nXHGGZK6fr3+\n", + "+usldXGnHhvz0pe+VFK3Buau7+ijj5bUjZfHUtGvnD91/ZznvPPOk7R6fGuzA1m7fL9TjvPOd75z\n", + "5rxj49eXis3LZXv6fquprMDStWwoas/HvCZ+lbhe5m1uDcqdJxSpIAiCIAiCRhaatddXiQL3HjyT\n", + "wbOQ8IpStUV27Nixz/PhfeGluZeFEsV5yZryrDKO88UvfnGf5wPa71lYKEh4Q7SLjCIHRcGvH+8Y\n", + "L5rve/aW/z9VSyWnkHA+2kG7vTYJ3gI7opNJgpfh2YK58cuBAoTXgqKIt+sKJioC7UlRW3MGuP5U\n", + "xffa45Ghg3eJXaKWYJccl/GgqvLdd98tqbMPvHHswpVHlGf6CTtFCaNadS5ek7/zfcZp7/Nt3759\n", + "n8cArtVJVbFPwbVhw/QpfcKYsSaRRcVrTq2trW+FwnD66adLki699NKZv9fuW5pSVxkz5ytf+Yqk\n", + "bg1hLUzxt3/7t5I6RSoHay39iirJ0wHWQmw1p8i17obgsAbl6jzNm9z1oc6ndqXAnua1u0gtXg8r\n", + "BfPMsxGHygwORSoIgiAIgqCRdVlHKocrVNxtcteKUuJ367m4Au5+8Sa5W0/VP4K+Xo/H9ngcBbVm\n", + "uD6vO+R4zBdQAwQFguN5hXL3WmqvD2+S6/Dve/+j9PA92ofXu3Pnzqrze2ybK0mujOCNpeyC/sjV\n", + "hmm1g9xxa5VdVA68e8bZz4MX9+Uvf3nN46CioMpwXFdXOD6qDSqC16WC1E4EXueN+bi3IpyrMeek\n", + "5jxzgT5g7FwVZC1xj51roDI07UGF5bx+Le5Zp1TIFPQlaxKqndcPKlXuaum75yAqZyr+0mvtHXPM\n", + "MZK68UMtLR1/joetuaLEWp/a2461hDVyWZWbFOzmgZ3wW+LzIqcsLora/iZmD4baKzAUqSAIgiAI\n", + "gkb2S0XKIXaDu9dU7E7uebrHIHnGSulxakH5Sj1/53y0A28il1Xnx8fLw7tKVQwvxTOfAG89dT2u\n", + "KOI1EttDe1r3KMTLTMXmuBKC4pPaC3C9QYaYZxbVgtqCaoJy6jBe9DN26vOE+UWcSyqOCdZS+GgT\n", + "yg7nTHmu3gbmAmuGn8PVy1xMDHOAa+OVjEnahbrq8Xetc88VJ2zXK6UvG6jorF2sSfQj40mcKP3P\n", + "+/RXKh7RK2P73nMcB7sgSxDIACZbkOOn7Cs1J5YF+ps1lrnJ2r/s9tL3aY/HibYqiqFIBUEQBEEQ\n", + "NHJAKFK1d5l4b9yt87wfZQUvib/zfDlH7V0v3gxxA/zfY2LwkvG2UGpK93/CC8ML59X3PKsltbdf\n", + "zot3lQCvCIWidL+qFB6/4ePhChoKVa4OVoq+NX3AY4daswCxC15bFSlUFD+u42oC7fV2oyLllChY\n", + "67qZI7y27tGGR048Hm1n7gOxVK5yY+Oofygb3me0D5vO1fXJkfq+11saitqYtByeJcgaQowXcxNF\n", + "z6FOEMdxVd7bic26gskrdoRig10QM5SrGdc6t+YFa5//pmEvqT3x9jeYf7n9aFOEIhUEQRAEQdDI\n", + "AaFI4aV59VnP5vNYjtIdo/1zKFTc7aMYEfuBl5rzvPFm+D4ZInj4wPVAqxeOF0LdJK6r9XhD1WjB\n", + "q3RFiHH+xp14AAAgAElEQVStBS+S/vXMqKH3n3RvtlQpdPz6W/sXe2ptB5ClR+waipnjStRQrKVs\n", + "+i4Htfj3+D/n8mtIxcB4XSEUFOrXAAoJcXv0JWtEbfYbawEqqKurKDYei9XKUEoUpBQB1iBXBJ3a\n", + "uM6cAnHVVVdJ6tbEeTGUspoDe2Yt5P/Yfavqvd5oVaIgFKkgCIIgCIJGFqpI9Y2UL8U9Yrw1zotS\n", + "xJ5lvJ/y2vAuiXvwu1m8CN+fCAWFu3zPlkNx8P7Aq8XbJDMJ3Gv1/ZHcm0CZc4+eOA9qi/jed4vC\n", + "FSNX4Oiv0ngEavfQ7368oeE8QylBfaGfXJGr9TqJXeN7qZ0C+saJpGLM1jquZ131xRUdn+ullceZ\n", + "a6wprqYSi+VV/Wvj8vh8SpFDHaWeVSrWaNmg33N1tRgPVPtUTTLIxaShuLEbxLxinnyt90zXoZRA\n", + "lE/OR//Rz8QA8lRgLGVsvROKVBAEQRAEQSMLVaS8wvFQpCp649V4LAfvczde6nUQU+TKDs/p8dT9\n", + "eb1nw3E+PG/3nvD08Qq8v4j58XiOFKnYIo8vQUnx2itj44ob4+l78Xkl91I78npGOUWxLyh9eHeL\n", + "xq+3b/wD9pfy+hkv79ecGkC2Kv3mCvFaGWOpulBDx71B695q3h72kRxKHU3t2sBalIs1WlZyCh0K\n", + "IjaW+3zOLlh7fM0Ym9LdEvrC3EWBwk68Nhz9EIrU2oQiFQRBEARB0MhCFamx7ra99gVeqSsuvI/3\n", + "ltszz6H9HqPE+65IuVcIubt8YoCIrfG4DLzw0kwV2ufeOtmGeHPEjs0b9xLxjvDWUSL4P9ddak/Y\n", + "Acd1BTNVp4rP1dZW4TxD7evUl9Z6WClQjrhO1BVAAeb6XYFN2T/KZKq92Cv7q0mr50ZfJYq4Sc/s\n", + "HRqO3zd7CPy66StioqgMvuy4eo4tsSam+muo35YDpY4SCiXZidg5sWGp+MfgEZZjZQ+CIAiCIFiH\n", + "HBB1pFASPFsJjxiFojSbyrOwPJbGs4zwmjyTpDS+guw5lBhvJ++jCODduuLmx6PdfN5joYhtGcpL\n", + "LiW3pyCkFKUcrqB4XS7+jldLv7DTPP2/txKyL5773OdK6vrdK9PPG+zX7QgFkvmA3aRqGdFP1Dej\n", + "n8gEAs8exdtlHvi8hFzdrbWyfVtrizmMFXGJ2N5Qx3foO64ZRSlVmytHqrI5WXvrBc/CxBbGzvQ+\n", + "0GANZC6zBq/XWLp5E4pUEARBEARBIweEIkXMi++71Johg0JDnEFqh3i8y1QF7VJQMPBOPaaE/btQ\n", + "Djgfn8/tYE9WGechjoL9pOZd1da9IK6PSvBcJ16pK0o5vHYOx33Zy14mSTrppJMkdfaBN0ycCf1X\n", + "qkihAnAc1I5FQUV+VyRdkeJ9FL8HHnhA0uqYNY7jtW6AcfJ9zDx7Dzgfiih7RzprxfnUxsZ43Sbm\n", + "bEoVHSv7DxXb48ZOPvnkQc+zLKoovPjFL676fOlaRC08YuboT/q3FuYMleF37dolqVP61rtCRsV9\n", + "FClio1gLcvW49hf4LaHOWum4hiIVBEEQBEHQyEIVKerD5HbQrgXvAVyJAryUofeSc28PL7ZvpgyK\n", + "gMNxvQpzynugfdx9076hvFS8/NYK3q6Y3XXXXZLStVX6tttVBpQmzz7jemqrZl966aWSVo/Porj9\n", + "9tslrY59Km0fdo+Sl9szEsXTSWVE4QWnvrcvahWjvlXmh6pTRTtQ6VD7atVWBwXG91RzUAFRXcH3\n", + "mPP4t1TVeYc1wWsH+lMBdotgDm7YsEFSlzXmCpPjew1yPaiobnPYGp8nUxTbo19OPfXUmetgLeb7\n", + "i1KkaA/ji6IEXA/jzvVgt/yf6+e3kjWX/kbJ5HyM96Iyu8eCNbB2rQ5FKgiCIAiCoJGFKVKbNm3a\n", + "8xzSlRG8Ct8jD68C743sH+6WeX+sCtJrVVKWVu8Af8IJJ0iStm/fLqlThvCOuPsn1or/c7fPdXNd\n", + "XD9emHupubtn+pP+pr2eDUhMVN+K3ng7HBfvhXbnapK4d5+KkRmLW2+9dc33S/dVc5ZFiYJ5x7zh\n", + "tXp2H9A/zBPsx9Uir77McYZQUpkjter0aaedJqlTL135Qamgral9IcmA9DUwF1fJGsjxfb9OV4q8\n", + "r+hL1gKPIcopWW5LrC2swShA3q++n+npp58uafW+oqimOSUK+Htqn1S/Ps8Y9ePT/zfeeKOkrn+p\n", + "OTjvfUjpX8bba7O5vdBvXsuN3yLexy5QAokj9fHn+D5nD3RCkQqCIAiCIGhkMlYWyj5POplMV1ZW\n", + "5n7eIAiCIAiCWlZWVjSdTtcsJBeKVBAEQRAEQSMLi5H67Gc/u+q5K7ERPH8le4vYHp5H89zdY6d4\n", + "rs5zX56759QvzuvPm2vhPLnz0d5UpfIctPc973mPJOnjH/+4pC52i3gH4hBSewhyvR6XQSwT/cA4\n", + "vP71r5ckvfe975353ljQj6XnIxandV+o0vFLQdwB45mrCN/3fLWsl/MRY4g9k2UI2CfrBHZ87rnn\n", + "6qKLLpK0OjsL2yZmxGtYbdu2bebvxAsC2U9Ut//FX/xFSd3cY8yJwWGOe40ttwmuhe9h4/z/0EMP\n", + "nTnfosaO9qRivEphjnIcYqLe/e53z5xvbDjPFVdcIamLCWLt2Lx5s6Que43Mct5nD0Yypvke/6e/\n", + "+NzrXve6mfOODef5yEc+Ikk6/PDDJXVZmNjrddddJ2l13C91pchOZJ5s2bJFUhfvSM2/F77whZKk\n", + "P/uzP5O0OuPZYxCZs8cdd5yk7jcqlcHPbzrtOOecc2auc2xy5wlFKgiCIAiCoJGFKVLf/va392QK\n", + "cHeaqsXBXTDeGxkZeKR4OSg8pVl7XgMGL2vjxo0zx+PunXo57lV67Q7u/rk+9445Lt9zRYpaKnzf\n", + "s8W88jdZbe795vYF8/4mA8MzMfz8846rKz3fUNloVC/Gi/IK5p6FR7YlagXjhr1gt1Q4H3on9daM\n", + "sxQomtjBvLP8yHZNZax51uneVchTGZ65SuU33XTTzP8d5oBng2ELqeN7/STWKtYostKwCfqa/7fu\n", + "jYeK71X8WxkqO62v7aMMtmbQOihI1MdiLWZcvAZhaX/yG9G3Tllf6G/f75LrSu0E4DULmRc7d+6U\n", + "1NmD7wyQmj+prE0UqFz237JnB4YiFQRBEARB0MjCFKknPelJq/aGS3HLLbdI6pQYV4S8pkWq2ipe\n", + "IYoQSgGKEV4OihKfwwv1+k08B/dK3HjFqbtovJSUt4KXkPK63IvwPeHw2Gv3HUvhXgbH71tvamhS\n", + "9Zo8piYHXirXnfOGGMerrrpqn3/H3nOxUznwyhlv1AeP62kFdaV1b0iH9jLPiNNABUgpXv4+85f4\n", + "jVSl+33BNfmxS1VPV3FT32PtYG6iDmOL1I3yueQxIrVzjPOmFCnUbo9hWS8wfuxBeP311/c6HoqN\n", + "21Cr4oXSyLj57gHzJrVHnj/VKIX+5zfPK9PX7mWYit91mD+ugJUytJLphCIVBEEQBEHQyMIUqYMP\n", + "PniPN4fXlPP83ZPnrhoFiuewxE44HvPhd+t4EVdffbWk7u4aD532epahP//FK+T92pii3N5ljlcz\n", + "Tnn4xx9/vCTp2GOPldQpbcSkpPD2L5sSlaO2snhfxShFam+5WvCeUaSGUqIcvL/UXpWlMA+82nZt\n", + "7BXzCu/y/vvvnznuvmCu+t5ztbhy4RnFtIXYJl8jeGXNYw1jLXJq1w7aRyyLs16VKCD+cOvWrZK6\n", + "eMbdu3dLql+bUopI6xo31L6x7IGHPaHioqCVngeFDLvgt8t34ygFJZVxcGVrKBXbKd3TMQVrRyhS\n", + "QRAEQRAES8bCFKmHH3541V55PG8tzXTwWi3crabuirl75pW71JR3yl0w7aR93M1zPrwHQCHjPO71\n", + "0L7nP//5M/9HIcLTLvVGc9l5gLKGMjKW8rLe8PFbVmjnUMpWDuZVX2/Q7SyV4ZaDeep7Oe7tZaZi\n", + "oLxWXC30gdsKqh1KgdfJQVHAkydTFwWKsUT14/gcZywPuhbPcF40KDL0F7XHbrjhhoW1aUh8jnst\n", + "tVLoH//tap0H/KZ57Uag7lYpqf1rnb4ZyTyVQEFmDRoqjjgUqSAIgiAIgkYWpkh973vf2+NV+A7m\n", + "pYoUd5m84jX5823uwt2r5NXPjzfL3arXV/LMBM/m43Pf+c531mw3x+dzRx55pKTubh8v1mt5pCh9\n", + "nk98BArZelGk+nrDOSVnXgpPX1Lt9KzNoVSDsdSQ1jgK5jnqDfNw77pxudin1nPzPffkmUOsFcxd\n", + "YqBoI2sQyhRznawuj9OE1qyvI444QlIXQ0SdrNr4S1gWJYo1mvHgeuj3oWuqrXeYM/SH23Gt2kw8\n", + "JjFbXrOxVuGZV4067ILfAtrNPUjfemuhSAVBEARBEDSyMEVK6ryIoSooc5ed2s+KbB/iE7hLxdOn\n", + "flDpebi7xcsEMhpy2UQ333yzpK5yNgoWXkJt/aNS1osSBX29YcZnvShPtXi2amsM0ljQ/9SeIYYQ\n", + "xas29grVhuOksnT3hrnoVf9LbYvvuSLFNTAGroqzpnHtfB4lhVpa2GaqRlwtKAe0Y+hq+g4KG2si\n", + "a/rQtsjxUaa8Nltr7M+y0XffUODpDnZF/zFevj8oMX/8hqV+K/hN6vub7fHGY0F7mWfUoqOf+ypS\n", + "vW6kJpPJnZL+SdKPJP1wOp2eNplMni7p/0g6StKdkv7XdDoddxYHQRAEQRAsgL6K1FTST0+n0+/t\n", + "9d45ki6ZTqe/P5lM3vno/8/xL04mk1U7iveFu1u/S+a5MN4nd7/+/LgUvC28H8+aKz1eqgosXihe\n", + "19CKFFDlmP7Bi132fY1qSe2/tr8xtDee2wOzFLxcMmZQZ1qzAfGSU/N9X/SNnXEP3f+f2gWAa8UW\n", + "uWbmGnMQpYA577sm1EIG8NjQD4z1UUcdJamLzRoKbNFr+gH9t97V59oK4SlSNdwAxdKfDuXqTPlu\n", + "Da2MrUQBaxlrBfZRmvGePf4Ax/CWvFLSnz/67z+X9AsDnCMIgiAIgmDpGEKRunQymfxI0iem0+kn\n", + "JR08nU5JDXlQ0sFrfnE63XM3SMxS31gY7r7dS+QulFfuTrn7JhYpVdMi5TnzOX+OzfFz2XTc1ZMB\n", + "QawH3x9LSeF8VDrnPL6z/f7C/prBg9fo3uSygWrA/MG+W9UDrpf5My+vVlq911cuC9AzcLlmlCav\n", + "hedjONZebUOpjQ4xOKiPQ+9xRsYm/cR48Nuxv8RIDRVbxm+azxGvtM/5XO1Ngd30XVsZP377ON7Q\n", + "v30+r1g7hooX7nsj9eLpdPrAZDJ5lqRLJpPJzL4E0+l0OplM1rw7+sEPfjAzaGOVlg+CIAiCIGjl\n", + "sssu2+ffe929TKfTBx59fWgymXxe0mmSHpxMJodMp9NvTyaTZ0tas5jSE57whD2e6HQ6nal03hc/\n", + "jlc894wdqg2XVlkFrx8Fpc9dUzuEj31TibeBklZarypYLvD+c/WjWuMAhlIrUHQ9/sL37SoFRZU4\n", + "ojvuuKP4u9RsI1M2B9k9vLoHnovP8s/TF4wV8ZDEJ/oYjhUfObQSBazpXPdQlaMd+gUlg6capTUI\n", + "50XrnnapfktV7k/hvyWeIe+/lfQj7+cUp6HUYNaoeWWU19rlGWecocsvvzz59+Y7l8lk8qTJZPIT\n", + "j/77yZJ+VtKNkv5K0q88+rFfkfSF1nMEQRAEQRAsM32kj4Mlff7RO8kfk/T/TqfTv5lMJldL+uxk\n", + "MvlVPVr+YK0vP+5xj1u1l5e/lnpjKEl4d17XCc+duARqZ/A9dmpP7Yzud90HHXSQJGnz5s2Suuw3\n", + "P19tXADt4fvEAwwNcQt4Ja3VjoNhcCUUO2Z+oFK4iuCxUdgxXjDqACrMonDlldotrd4sSvBacRrs\n", + "ucZc5jPM2S1btkjqPG4+554+Y8JaRAyJKwy1c5wxxvNnjUupicRUrRcYC65rrPg1bPvQQw+V1I3n\n", + "WDFlrZTuOuGk7KG2bpN/PleXKhevyNrk++S2wnxgvg2VRTdvmm+kptPpbkknr/H+9yS9rE+jgiAI\n", + "giAI1gMLi/DeO8AcD7M0281BaeJu2WOXNm7cKKnzhN3L47l6qnYHx+Pumbt8drrmLp59rWqzkHxX\n", + "e+Ilhob+Zp8hlIxlz2qjJg39zXjQb4zr4YcfLqnz5tgJnnHFvlAX6G/PxJo3xPyQNYlawbgwTrQ3\n", + "FVvEvlFObQzS0KB4Ms/6Zszs2LFD0tqKLTbuajbKEx45NoIt+ZxlrpfGUqXwjF/WNo/RwCPHlrHR\n", + "5zznOU3nZU3kuOyvWRtjUwpziz3+xs6e8+MzV5ZlT8ChQElFCaUCd6nShxrN2sDa4hXhsUevZ4ad\n", + "oPwdcsghM99zBal0Nw6+x5rN/8dWFD07kH5kTfV+LmX/yBUNgiAIgiBYAAtTpL7//e/vuRskzqA0\n", + "U8DBe+Mu+Pbbb5ckvfSlL5XUecDcleO1cFfN3afXmvA4BsCr5Lju3ZVmxHD3y10+xxvLq+Kum+te\n", + "L7FRKFHg44G37ePhrw797HEuZGihXgydeYTqANgLXhneIN4TXiLfQ1HcufORaiOMo8fYcVxip1K4\n", + "SoHdp+pSEWNHP7FHJAoRChvkqn/Xwnxfa1x37969z+8ypq5GMjdSqh54jJR7sq6m+155jAlKFZ/3\n", + "eDiuLaWIMcaslXyedqBIMVc4H/GhjFlOmeJ41IXymC6uH9Uf26SfUZNRGlAssK2cAsH4eN0r5jyv\n", + "zrLuO1mL27rXYmPupn4zfQ9CPs9awTj69xln7Jd+R7nlNVfp38FusSvf+7K1Ij1rlu+aQHtY41P2\n", + "gJLK2sY9QWmccihSQRAEQRAEjUwW8Ux5MplMV1ZW5n7eIAiCIAiCWlZWVjSdTtdMKwxFKgiCIAiC\n", + "oJGFxUidd955e56vE8NBfEJtxDyR/8SW8Fz0jW98o6RH7iTnAef59Kc/LUm69957Z9ozFDzvPvfc\n", + "c2fOC8QpEF9AxhLfe/nLXy6pi0+45ZZbJK2uguvPlTnPH/3RH0nqnh8T30H8BfEJjCvPvXkejgrK\n", + "cX2fMZ5vv+Md71jz+saC83zhC4/UkGXcvF/oT/qXzBjiCog/IQ6A6+T5O3EOv/EbvzFz3rHhPO9/\n", + "//tn2gHEKRDjRHyEVw6nVhP24XE8HOc973nPzHnHZmVlRe973/skdTbGGPi+hEDsiSvzXHuqajzX\n", + "dMEFF0gqr3mHLXH80pgQzpeb67SXvcq4PuYkNugxR7Sf988666w1zzcWnOeDH/ygpPI1k2wyYnxK\n", + "fzs432c+85mZ97l+YrvY9YFXfrOOOeaYmXYSm8dcYJxZA9/85jfPnHdsUvbieDwl1+O/zWSSeywV\n", + "MW9nn322JOlDH/qQpM7eOF7fCv3EdBEDVdufzLfWDPXceUKRCoIgCIIgaGRhitTDDz+8x2tCiWjd\n", + "IZysJc94qQWvru9+TShrY+0blMsKTO2gzfcuvfRSSemMDZSlVF2tlNfH+Xj1bDK8FBSbVFbYWPtz\n", + "lYKySeYR40h/4V35q9flwnvieyiArZkpQ5GqQUM7UVJTbN++fZ9/X2Qtn5TiVLsmlHqutZ427WCt\n", + "6WsLrDW5bEOv4bWs1K6Z999/f6/zsda4ik79phtvvFFSt5bxSsasg8LD95cd7M9rL9Iv2HdqPrj9\n", + "872h13CvgF7L2LUSQ5EKgiAIgiBoZGGK1N7gnXE3T20QYi1yHi53062KFlBL4qabbpp5/+CDD5ZU\n", + "Xndp3l4f/Yc3tW3btpl2XHHFFTOfTylB9CPVlInt8TpOeFsoSw41Pah7hLdHLBv/57iLVqAcvM3c\n", + "vlSQGm/sGS97rL0T9xe8Cvj+zFi2wP6f1HVijhLDQzwiNplaC2pJjR3toLbfspFa21AOc+qsQywO\n", + "v1nLXmmdpw+nn366pC62i+uuHbex63e1Vj4nlpDfctZsYidT++yWEopUEARBEARBI0uhSPGc2+/e\n", + "S+/miYto3Wkb7rvvvpn/c/dauwP70PtY5eDuH2/Ivc5SUJBQUvBKfK+21Lj4nnZkugB7yY1NrjJ3\n", + "jr5eOtePtzev6543qWrefY831Hw+EMH2yCQ95ZRTJHVxbV/96lclDadEMdfI8uIpAllvy6Y250DB\n", + "a1WS+B5PL2p/O+YNaz2K1GmnnSZJuvLKKyVpTxZsKWOrya1rAr9NL3nJSySt/o0KRSoIgiAIgmBB\n", + "LFSRwnvBq6lVULjL5K6a556le905/vyVvcS4e/Xn6YvCs+nweoiV4v+1XhWKFK9kSLhX5dmAgDdS\n", + "qsj1VY5S8Jwe76VWIWRfMd+PDMUv52Vjf3ye5/McpzWDhJo5xLLdeuutTcdhb8fUPmU5mG/YSd/M\n", + "KUCRql0HPOPoQIQ1ijFFUcCWx8ok3rp1q6ROAcP2eR07W2osWpU0ftNye+AtC/ymfeUrX5HUrcX8\n", + "lnoNvRzLer1cD1mKxEO33is4oUgFQRAEQRA0sjBF6jGPecwej913hC6N+EcBoV4P9M3eox20D4Vj\n", + "aLhurqP0+bI/J6Z99APtrq254Tu0c9deWyunNMtyaCUKPKYrRSrGh370SuvEgRDzlPPu6bdNmzZJ\n", + "6q9s4iVv2LBBUuf91T7fx2t2UM7w3jg+iiT9xPv081D11zzLsTQeotZr3p/AJplz2Ag2Wqta1sb0\n", + "oICxVqDiY2MoYtdff72k4RSA0ozuVrDp2rWP3y7W5EXXjCvl85///MzrvPAK+2PBuHzjG9+Q1FVq\n", + "57eobztCkQqCIAiCIGhkYa7ck5/85D137XiUtYoUcNePl5KqyF0K3ghZa/x/aFCMOH5pnSq/a/bY\n", + "JLzS2ngI7tLxwrhbH1qRI0aH/l1U3aCU4uGxTMRy0R/UmqG/Ul4xGSHsy9U3loe6VvRba6ZJqoYR\n", + "Sm5qDz5/n34aKu4GhYv1oFSRKq33tQz03fPLcVUVFdXVXpQh4tpSmaS17WLNolbdli1bJHUKFZmr\n", + "/L9vnClrO3NprHpc2Lzv35qDObKebHJISpUdrwDP05Cxa+1RF4tXnhb0tc9QpIIgCIIgCBpZmCL1\n", + "lKc8ZY/SkcqQ4K4VxQnvwPdCw5NFGUjFgOTA2+H7Q2UjpSCThh3ZW8Eb5bXv82YUD7yLoSu148WO\n", + "tRdhX2iXK1P0A15nLj6DzzPOfav9cr6+NU9S/Z5SBudVC4j5N1Y25yIZWokCPPlcZioqH+1I0bp2\n", + "YOvYODbPWjrUXGft77vG50AZmXdNwPVO6S4j/KbzG8tv/bxhfFv38INQpIIgCIIgCBpZmCL1pCc9\n", + "aY934TFOniXE3SLP991DxpPu68FynHnviebZYbUxQ3jw3F3jpaJg1D7nx3vleChTfSGeY9l3oMe+\n", + "6D/Gh9gxxilX2Zt+QzGNSt37Brsfyt6WibHq65SuFShNtXvHlcLTBdZoxpC1qHWPNGCusZaVHg+F\n", + "hLlbqnzQr+xu4btepOC3igzYsbPRxoLrqK0NyDiVwryY99rIbxz29N3vfrfX8fa/FSsIgiAIgmBO\n", + "LEyReuxjH7tHieJul7t3PH6UAd9R2p+/rvdYir7tx2vyGBPqIeElXHXVVfs8DjVpTjrpJEnDxVzB\n", + "elFkuF739mk/Xgz9nbou+h8vmMrky1r9F57+9KdLStfjwp74HJXuWxVV8MyzYDio0j8WrOWo3q5o\n", + "lKrhzBkUA/9N4Lip3RUcn5uuZHkcLk9FaAcZt2Tg5tZCaryRib3scz0FSl5t9mFrHGhuLR0a7Ag7\n", + "C0UqCIIgCIJgQSxMkXr44Yf3PHf2GCEyS1CqiFkaq4ptiqF3tx8L7q5dSaE/S2NO6F9ea+v51MI4\n", + "U2sGezj66KNHOV8peJV33HGHpE7hY0d77AIvJuVt49UyLowD1Z8XBcqjxwKimFFTharY/jnGyxmq\n", + "Htiyz7dgNazVPC3w3QFK8YrgKBwoR7yWxn3mMk5Za7yOEWsg18V5U5XOWYOp9E6dIub8K1/5yn22\n", + "Y9Gw1vObQb/WzulWBW7eGdzYD8pb36zaUKSCIAiCIAgaWZgihbe/N6k95+atRMGyesa+tyDPsVFK\n", + "8Jpof2mGC8ehSjHxAp7pgzKD93jzzTdLWj1O1MfyWDjg8/58elHjDXilHoeBt4J3mosfIC7Fvdh5\n", + "10zxyvyprFRquuTqp2FXpXEqYzPP/iQrbX+ltfo+ys7GjRsldZXU77777qrjpGxvqOw/55ZbbpG0\n", + "eq1nzbryyiuLjoPyNa+aayly9bVST1lYm9l1gv/XZlj7XMSeULxc8aE9vM9v/5FHHjnzfdZS7KoV\n", + "lMMTTjhBUjefifdEUawlFKkgCIIgCIJGFqZIHXTQQXtiNQ4//HBJqxUV7g6pkstzVGp0sK8T+/UQ\n", + "Y+OKxubNmyV1njjf5zwoC763GooKMSMcFy+L98nogFQMCs9hOT7n9/byORQfPpeqqJ3aN6uVa6+9\n", + "duZ8Dt5BzvvKVbdNHb/vflx9SXnRpZlPuf2mfEd4vECe22M32Dt2QGwScQx4edgT8wQvEqUPb6u1\n", + "vcwD5hleHN5vab9s27ZNknTYYYdJ6q4TxRO7Zh4yD1DUOC/9xbyYZ/VpVyG3bt0qqWsrVftRjRkr\n", + "qtET80Pfcc18jrHm/z529AXXTl+6SootpFR1xhLPv29mrs8Z2tO3Cv/YLOqpAzbM3GMu88oa4QoJ\n", + "f2fciLfEnjz+EgWHtYA1JpVdx9wrnVOsPYCChJ1i38wP7NmzJfmtYK3BHlEosee+6jO/Wdu3b585\n", + "D8dvJRSpIAiCIAiCRiaLiEeZTCbTlZWVuZ83CIIgCIKglpWVFU2n0zWD0EKRCoIgCIIgaGRhMVLz\n", + "UKQ4x8UXXyypi19IZVvxPNkrNBO7xfNUvu8xPpzvggsukJSuOTIUnG9e6t56Ox/jyXj53oEeF7Ko\n", + "68NeqFBPXADxMrST9hMrRXwHnyc+wfeqhF//9V+fOe/YcJ7zzz9f0upK6FwPcR/g8Rn0A/MQFd13\n", + "Pnj729+evLZctXayeXJxf/TtOeecI0n6wAc+IKmL3yIWhDEj9oO1gO8TQ0UcHJ/jGhljanu94hWv\n", + "kLy2rVYAACAASURBVDT/sbvwwgslDZ8tB8zFc889V5L0kY98RFJ9Re1aFjXXL7roIkn5jFevAcj/\n", + "eU1l3hJj9I53vEOS9N73vldSN2d870GH2DnmoM8X5ipxwKwxb33rW2euc2iIxaIuGef53Oc+J6lb\n", + "A4g9Y17deOONkrp+fOELXyipu/5du3ZJ6uadx6Dt3r1bknTmmWfus32hSAVBEARBEDSyMEVKWh25\n", + "3woZC7y60oCXmfNyvJ4Rd6fcneNt5qq9krFAe7hr533ullu9PM+UCNYGL98VjmXbkZ3MK1QI7CNV\n", + "x4vsN/eiUnYxVMXxVvCi8W59PPBuyTiito97mcxPzxLcex7RF64is9akFKmcEuV7sAEKE33Mcfg8\n", + "NddYe1AiuGaypLgG381h0bXsSm3HsxBL8bm4aFsdG2waO8B+UESxU/qF8UdRpX9SipTD3MHO2DuQ\n", + "NYanNKyVrCG0i3Ywr1Be+fu8sjJTFfJZM0855RRJXSa/31Mwv3y3CfqHNRVFj/4urbgeilQQBEEQ\n", + "BEEjC1Wk+ipR4HvEOa07Urvn7PVtUvvyeG0YXqlV0Vr3JrW/FHfZY8UxrDeIjcJ783HK1U2aN9gH\n", + "YB+oFk6q2vKmTZskdfaJPaDO1HLyySfPtIf5SnxBaf2oXKygK7bEcWDnjFPJPli01eeYq3ql4JnS\n", + "BreZXK00roHaXlzDzp071/y8z/HSfTKdU089deY49CmKwpe+9CVJeQXJbXNs6O/WNXto6H9i1Rjv\n", + "3Lin8LUbpYXzUOOQNcxrFOaeqvhc5/MoTdgByhcKGe3YsWOHpNUKIzUTsR/U4UWPE9dFe5lnrFX0\n", + "Hyo3MVFeNwrFDcWO/indey8UqSAIgiAIgkYWqkjNi9YdnR2eY+d2NG/drydH6nlt7X5I+yuMD0oK\n", + "SgiV2rGDZVOkiNshaw8lyuMRcs/rUWG4rr47quONUr0b7xU1pVSRysH1szMBiprv05Wbd2NALApt\n", + "QjEAPFdiK3zu4/nmFAyPgek7dqjUxIwce+yxkqQbbrhBUnksU6nKzfGwXZQRjzvNcc899xR9ziuy\n", + "M05DKyRcD7Fu2ODVV1/ddDyPeaPfUFCY86wFnnFcW4GbmD2P4fO9C5nbqRg11kx/HXufS8+gd3yt\n", + "ox+xA/7OuKXWEK/8zmtp5n0oUkEQBEEQBI0sTJF6ylOesue586233trrWLnaF0PFYi16Z+8Uy6Ks\n", + "LBrUArxvFJM77rhj5v+ejblofG88XvH68E5zexCiuOGdY69ep6kUjoMChcox1l6I7NeGCoAKxHxe\n", + "xPxDMWAsPG6NrB/6GBvLxXURD0bWEcoAsR4oBK02et1110nqPPprrrlGUqf6jQX9gEJXq0iVQoYn\n", + "qiX1goZWpFCAiB3qW98qZ8PE9PA5z/L0GDJXWPz/zFns12MIUXKYayn1m/Ni79jtWL89tMNr47lC\n", + "6vXasHfGqdTe6WcUNjKpS+dfKFJBEARBEASNLEyRevzjH1/8/J27aTIZPDYjtzP0omuxBPMB7584\n", + "FSp+u5fqFbVrM5PwyvDiUFJawatyZcorsaNSoLB6nAvfJ1asNfOL72/cuFFS5xVSc2asmDzvhz47\n", + "snvWETE7tWsBaw6ePWMAHI8xS3noKAoch2wjlAeulXYzBq3xnah42CgeO+0fawzph7HrQfkcGSoO\n", + "NsVQldZzCg4KiispKJgoQ1yvK1CuePl4+6vHADFP3P54JYaLz6HUAUok9sbna/sPu2WNZh76OHsc\n", + "qce/lto5axvzk+svzXgORSoIgiAIgqCRhSlSJd4md6HcZXK3CyhTeIWRvXZggz184xvfkNR5a+6l\n", + "+XPvWpUCRciVnlyF/RR473wPUJRKM7iwfzK1UD1qYwRpD6/UXknVPhoK778+uFrXqkqjfKRiW1A9\n", + "UwoM7SCOE/UT1dRjiDyLqy/erg0bNkjqbGOomCmOh5JAf7UqgTmIaaH9fbMc50VpzA1KEmo6axuK\n", + "SSqbzO3e658xtzwbLlcpnbmPGs9vsbcDZYjx53O1ihT2kssuRTliLfbv1cZw0Q8oYdhzjlCkgiAI\n", + "giAIGlnqOlLc1fpduddyCfZvavfx4nk3doIXhXrg1O4PhhdG3ILvTF57PD7v8Td4ja3eNt5rbWVz\n", + "vOabbrpJ0uosWLxOjk9/94V+8LgP2t+3P/rAGnT77bfPvJ+LBfK6PcRxFu/h1VjZHOhTMqQ3b94s\n", + "qYs1GUqRIrMUBYDrHav2V2tl8UVTGstFViLX6Xs6lsLaxPd8rSoFe7355psldePtSi2f43ytT4no\n", + "J98D0Mcde6MdnB9lCkWpdL75WhOKVBAEQRAEwcgstSKVqgmyXp6HLzvLVk8pBe0s9cZcESKzwxUp\n", + "vP1SrwPwgvCSyMhqrWiP4obCRbtqlS3A28SLbY05ciUKLw2Fr7Tqb1/wLpcx+7Y0Bgg1HdUx9XkU\n", + "K8aubzYaY0Zlbv4/VAwWkLnKXFtEFfoxod+Ym2NfH3OfGCDWmlqFkjWFNYvr8OOVxhLxPdZk/g/e\n", + "L7WKFPaD8kT7uBfw337mn2dvMn+Isy7da5PPkx3pTwlShCIVBEEQBEHQyFIrUrBt2zZJXczGonec\n", + "3l9YdiUKXFHh/+6NpHDlBC+H77cqNmRc9fXuvR14h61xDWSI4U25slQL3ifVfvH2Sr28/QmUHXDb\n", + "SSlUXtcmZXO+z2DfTGRXNcmeuvPOO3sdNwVzEeVj7PpO84I5wLiQNVgLcYW5GoooSajdxABhD7SD\n", + "8eU3EQULWAM8O5Tvo4CWqssnnXSSpE6x8b0RfY2q/Y3h+8wX5gP94Nn+zDevmYeyRC280rWKfmHN\n", + "jTpSQRAEQRAEI7MuFCmUqFa4yxwqpoO75JS3RQyJV9+tPU7wCHiD9BNeWK5qNePuXozXVmmtwjxU\n", + "5tBzn/tcSdKJJ54oqfM6PUuNPSlT9uL11vDKWvfag5T9lsZr1MZhLDNeb8evCUXA15pUTIp78ChG\n", + "Q1XSZuyZK9jsWGsOttIa37essMaQrYYKXft0hDmZUqTYw+7II4+U1P2WMG5XXHGFpPRvmdsT7UWB\n", + "5DpQxmhP6W8jn3MlbCh8reE8rOVeS9LjST3brjamjH4mm7X0KUAoUkEQBEEQBI2sC0UK8Oq4+/QI\n", + "fZQF94ZSXmIrOW+uNHsrlKgyUjFIuUwpvIuxsstK61sR70ANH9+fCu909+7dkjovD+8LL5J4h5Td\n", + "oHJceumlkjo1gviCF7/4xZK6+ZKre0VMFDVteEWVwXukfXi9nulCJg7tZjxTCpX3a00dsdqaY7W4\n", + "Cklfck0pD5YxoH0cxz8/tEqNDVD/auw1Z3/NqGYNIfuyNS4yty8nsVfXXHONJOnoo4+W1NlJLtbH\n", + "59Rtt90mqav1xtzlN7F0v1v44he/uM+/980E96cDzAf634/LWsr73CPwNIj+LI0z5ekX44syfPrp\n", + "p+/ze6FIBUEQBEEQNLIwRWrjxo17vDPuJrmbxSP3Pb/wdPk/3hVeEHfj7o0OXTMlmC+1KgPeFmoB\n", + "SgrPy71KrisoJ5xwgqROkSHOgOw3vDqeoxPThHdHZtdxxx03832y6Ry8KleqgOunUjvHoR2pGC/m\n", + "lWcYER/hihX95RkwKE5407xynMMPP3ymne4Vk3FEOzmex2ugwHFe+hsv0sdvrdhHYkwYW85B3+Fh\n", + "8nfUQq6dviLWgrEDtxU8Zq/dha0yBjmVmj5kTGhHawwKY8H3c6osfetZX/Qx/eCxXqzBHN9VYD5H\n", + "v5HtxXHpL2Du3HXXXWu208/PdaZiz1Ct+RxZaq0wLr63WynMNZQt8L3vWFv6Vp73bD2vPF8K10s7\n", + "U8oOMVfYHfOReZfKIMbuma+ME9+nn12RuvrqqyV118Vx+H+rMlab1RqKVBAEQRAEQSOTRWRXTCaT\n", + "6crKytzPGwRBEARBUMvKyoqm0+maBeBCkQqCIAiCIGhkYTFSKysro2fYoHq1ql+19W84z/ve9z5J\n", + "0nOe8xxJ3XNhnvsS28JxPUaF5+d8z6vYHnHEEZKkV73qVZKkT33qU5K6uALiPogLIW6B58e8TxwD\n", + "8Rs8h+Y5vcfMcH0XX3yxpK7GyYYNGyR1z8cvueQSSV0GxOte9zpJ0sknnyxJ+pu/+RtJXbwBz8G5\n", + "Ts5HFd1Pf/rTkroquqnn88TYlNZ3op94Lv+2t71NkvTe975X0vi1cOjPCy64QFI6jgU7JE7lgQce\n", + "6HU+nw+54zM+/P2OO+6Q1MUeeqbO1q1bJUlnnnnmmucbi5WVFX3sYx+T1MVoeKYv8Wy1Y0tsD2P0\n", + "rne9a8855wHn+fCHPyypi5Mji4s5wxgxJh5jQxZYLgar79qZwtdU1r6zzjpLknT++edL6tYSYrZY\n", + "E31uY5vEQRKLQ+wWawLn4+9vectbJEkf/OAHJXVrM7FcrImtNeZoN/GBY/VnitK1hZgnfhNa9wvl\n", + "fBdeeKGkrv+5/qFZVH+mCEUqCIIgCIKgkYXWkcp5hXgrXk14XrRWYuYun+wvMgDwnvCueB/lBy+S\n", + "jAru6lFOOC7eMaAI4ZUeeuihkjrlyvdDooI23tk3v/lNSatr4WzZskWSdMstt8x8HwWHduHN4SX7\n", + "TtxUFqemyZVXXjnzPdrJdXklcuwkVwOkttI46oRX/p533GAuowo7bFWicuSOj3qR2l/MM2N27tw5\n", + "YOvqYOw8uwu1FZtN2UqqDo5nDC8K2u1V74F6QV7RGbWX90uzAZmjqcxnsuxQMpijrEFkI/J3X4t8\n", + "LzOuC0WHv6fmPmuFZ+kx/hwnVTeJ/uO1776UMJYSU0tubcGeW5UohzV/vezjOhShSAVBEARBEDSy\n", + "1JXNh1Ki8DLxVvoqDsQhoOi4t8T/qXGBAsXzerw73s/VCvGaKn63T0Xs+++/f+Z1165dklZ7Ydu3\n", + "b5fU1VZJeU8oSO69ct2u6OA9usLzpS99SVKnBqBs4K1Si4frci+K/ubvqRozraz3PeD2l73sXvKS\n", + "l0jq9hMDFFdis/YFtozCgKKCrec89JQnvWyedm4NwxaYY8zZXB+i5EBOkUJlR0lireFpAv9PVfT2\n", + "Okecn7WS8/M51havQ+WxVKxFxE7xvaGUF8j1z4HGsihx8yYUqSAIgiAIgkaWWpEaiqG9SO66czE7\n", + "KC1+l15bDdfjNlzx8WrLkIoDKd0Pi+P6cWg/SpVXccabJKsPL9D7AW+O9nAeV8By+0v1zf70OI31\n", + "Bu1fFkWqdsd1wA6ImSPOhrifElyBIhvJK3en4r1S+H6HQ9G6t14ulgeFyCuP5/A1LaW00L+p+EKe\n", + "JtSMndTFPDFeVL33uElfIxgX3uf6uW7+37pGoIDRn+wfiSo/NBs3bpTUtXuRcYdBnlCkgiAIgiAI\n", + "GjkgFKmhKc0Ow5tDieG1VgFxRc0VpVS2Vd9YsJTX6/sheXYe7cspdihbnIf+wUv3dpR61SlS8QyL\n", + "zsTqy7K1n1pFrZAJRrwMMX0loEARK+NZW6ikxOuVxF1JnY2jxAxFrRJVCmsGyk4qGzFHSpFibSEe\n", + "MxUDVQuZv15bD1tIrSmuULFGsRa5claLrz3EbI2lAt9+++2jHDcFChjzhDjUsRQ3xuf444+X1PVj\n", + "zVxfJkKRCoIgCIIgaCQUqRFJeX8oI613+35cjx8YipT354oY8RBk6KAg5bIuiX0iDsBr3eTaAXg3\n", + "OW8bpWu9Z9hwHR4X0qpu0H9kR+J919blYtyOPPLIpnYQE7V582ZJnUKJHV177bXZYzAXyFLDVolp\n", + "oVYZNpdTOgAFwrPaWqE9KGRDx8CgGA2dpebQj+xCQL+zBqDgldoS/UJlc2yczObcOAEKB3MdpbJ2\n", + "/Lg+sv+wH+bMNddcU3W8ZcV3tRhLiQLGh3GhX8k0Lx3nZSEUqSAIgiAIgkZCkepBrn4Pz/eB5894\n", + "WXhLtVl8rtjMO1sL5YPXVPZersYKXgfVjqmk7v2BApOKBSqN+6C9vofgegPlBjWDeIbSyueMC68e\n", + "h9Javw27xIuvxWsKEedUczz3ZBljPGzUNj5XG1/W6ikfdthhkrr9Nxk75gxZhGOpy2NBrBmZlqwF\n", + "qIm1MVmeEc3cz1ViZ20lForxxoaIuaqFuUHcH9eL0kdWodfq6ws2zxwd+vgOu2zMC9Yaxpvx4npD\n", + "kQqCIAiCIDhACEWqB7msOJ7/AsoR3metEgV9M1D6gvLA9ePV433iXZTGItEPeCH+PWKnUl5paZwL\n", + "xx0qziXF2NWO6Wf2QKxVkOhP4lGo++VKYm2VYh//WsjYQV3ALsjiK8HVK/5PTEtt3NdQ+D6ZjAGK\n", + "mavX84J+aV2LUEEZe9a21lpivpdgafv4HP3oaxCKTu2cZC5wfGJ4UKT4O2sKClhfUNCYm1x/38zl\n", + "ZYFxYrzpz7GeEvBbPJbiG4pUEARBEARBI6FI7YNcLE1OkcLjJyYKL63v81+vs5Si7x5sqarLeGF4\n", + "jSgX/J/rLr37J14EL8xVg5wXWVsva6z90hjnvvW7cuQqvefAu2a8sHPGmXGYd7wO404tIeJPauKY\n", + "XAnhu631n+gr9qzLxeqkIAaF43js1tgxMClalSigcjmxQ9hOq7JAe/g+/c/xUzbJuPvcZi1CASSr\n", + "sBS/Pr7PmsfahX0NpUgxF/2pBvuq9h23RUM/8huD0sbTFtamoWrkjb2WhSIVBEEQBEHQSChSa4BH\n", + "jFfQ6l3hJeHx83/usmuPW7unmlczrlWmctmIvOJNENuC143CkNvX7LjjjpPUVdclCw04bioTiH7J\n", + "ZdDgNeI1e5ZYX1rVilZa41tQRPEKsRPGE++9ldb4GMCeUBNqvHw8XF5RB2lT7d529C193beyOTaH\n", + "DfP/9R77gs2gVlNHqlV9p99RJp71rGdJWq0sEJvk2XqATfP31vG77bbbJK3O/sOOhs56Y26ylrH2\n", + "ja1EDa0ElZ7P911dtt0acoQiFQRBEARB0EgoUmuAF9VaKZpYGbw0r69Uu9ce4I2wv1WOvvt4pWKJ\n", + "iAvg+vAC8SbwonJKFOCNEIeAsuTn43PELTBOXnsmBd5pag/BVlytGCsGC+gP97ZL4ydQzugHFB/6\n", + "v2/mDNWef/Znf7bp+9gP11kT14KKyrXQR8TZtV5b37g0YG8/5k5rzS5o3UMvBWpyLfQ7a06pKulZ\n", + "lv4UACUolQnKOLsSBih9ZIX1VY19vErX4lboh3nVCpy3EsQcZ5zIRF5vhCIVBEEQBEHQyLpQpPC6\n", + "uCtH4RkrO6pvBg1eDzuiD62ALBriFdhTjVgW3xGeeAIUEs/Go0YK+1il6kHhbbrChvLH9+jnVLYi\n", + "3t3QdjPvDBrfP42q0qXt8P7FCx3KTvtmpaIwllZq3xvGHlvDdoizwyZTCgrfc1tFQepbg4zzoSAx\n", + "B2rXnNz+kh5XyHm4jpSS4sqbK16eRYaCxRrgMWCAWovajMrIWgKMC59HAUpl7mKzKdWS8eZ4rVX3\n", + "U4ytPs+74vi8IeZt7L39xiYUqSAIgiAIgkaWUpHC6yO+AY8Z7xKvBeUHLwOvsm/WUV9QSvAafedx\n", + "lJGcAsD3jznmmJn33SucN9ddd52kzqvFK0MRwbvg/ZQXyOeJ7SFWh/8ff/zxklarBHzP92nC60wp\n", + "TqVKlFdSp/21MWeoAvTDUPEHXiUbr96rTENp1exc/6VAjUAVwP5T0B7Ok1KwiIVDxaA/+T7jv3d7\n", + "XcViH0fmEjEZqHiePcccxQaI3eDaaEMrrFHYku93WBrDlVMfN2zYIKnb44+xJW6xNLbnBS94gaSu\n", + "r7E5roN20D/0H3sK0l/YLApLqn4Wx/dMZ89iA34LXH1mfJkbnlkMvm8ltkY/oYRxfNYojkPVfa+h\n", + "hwK4Y8cO7YtnPvOZkuoziFHx6R/sfqhYqr4V71PQXpRCryfFOLjqPjRc38EHHyypf6xbKFJBEARB\n", + "EASNTMauwrzmSSeT6crKytzPGwRBEARBUMvKyoqm0+mahchCkQqCIAiCIGgkGyM1mUz+b0k/J+k7\n", + "0+n0xEffe7qk/yPpKEl3Svpf0+n0+4/+7f+S9AZJP5L01ul0+jdrHfeiiy7a8zyazBCeL19//fWS\n", + "uniBTZs2SepiKYh74HtHH320pO75Ns+bX//610uSPve5z0nqns8SY8Rzf2q78Nx069atkrrn+Pyd\n", + "7/tzfNrxyle+UtIjd64lpLLUSuE8vNIuMl1oH3ESXA+xJx43wt9RKXnOT8zLa17zGknSH//xH0ta\n", + "nU3H/z0ziP4hboFxvf322yV1sUg8Nyeu4dWvfrUk6f3vf//MddNvxBzxynlof21MEv34l3/5lzPX\n", + "Q7vY+Z3aNrSTcSd+46tf/aqkzr6IwyDW7b777pMkvepVr5IkfeADH5AknXDCCZJWV+HmuMQNMK4e\n", + "gwVul5z3ec97niTp8ssvn7kO+on5g73z/y1btsych0wb2kP8CRlc/P9tb3ubJOlP/uRPZr7H+NA+\n", + "xhN7w56Yx3zeY6OclZWV4rnXF597++v5PvnJT0rqbBZYE0466SRJnW1gU15xnGxAxpK1njpQv/qr\n", + "vzpzXvBYtVo4PjZFrNg555yz5vlKycW0sRYTB8t5+C3i+6y5ZECzxhBLRj96bB1rg2elcl7Wltz1\n", + "cV7m3vbt2/f5eYfxOfvss/d5vlT8Jb89XA9rCtfpsVr0W9/xqyV3nhJF6v+R9D/svXMkXTKdTjdL\n", + "+vKj/9dkMtkm6X9L2vbod/54MpmE6hUEQRAEwX5JVpGaTqdfnUwmR9vbr5R0+qP//nNJf6tHbqb+\n", + "p6SLp9PpDyXdOZlMbpN0mqQr/bgPPfTQqsrX3FX7XT5ejuMZN+4hA8pHypN1cvVrPMMC76qWvvV2\n", + "HM8C5HpT/cddvnubkKrtwXlQSvw6Ut5aLjOCz3stG7wyXsmQ8Uwc/o7iliO1Nx8KGcol7fJ+wn7/\n", + "9E//dJ/nQQkCr4mD93XttdcWtbsU+gmvjnagQPn+Xbzyd+YXGUJkazKfPCOKeeHjTv+6csb5sB+O\n", + "k8o8Kp2/JcwrO2i9k5pLzJEbb7xR0uoMStZEMm1diSBbK1e1vu8ehLn6RMwN1g5sNJehm8uuxL58\n", + "TaY/mBP81mCHvhalfiPob58TtfXIGJdTTjlF0mpFiqxE3/8USscnFYvN+JC96P3uWYN9d10Yi1a1\n", + "6ODpdMoMe1DSwY/++1BJe/8K3ivpsMZzBEEQBEEQLDW960hNp9PpZDLZV+pfcVpgq8eZ82p4nu/H\n", + "r93pmue4eMzcLffdER7Gqt0xNHhtqaq+rV5DqnoxXk/K+yF+gFikHMRtpEBxoWaM162qhZg1XlPe\n", + "3VBgp9g9cRNwxRVXrPk9t2PmFXEdjs+b1Lgzz3J2kauBUxJTSExMTolAMeGV2JSh5x4xJNgmSo7v\n", + "ArCsoPZ6f2IrjAnX5TX+UsoOsT1um0PBHPcaaw7jjW0yd/qSsiNsl7k1dGX02lp3rKmsvYyrx2GO\n", + "zdBPZ+ZNqyL14GQyOUSSJpPJsyV959H375N0xF6fO/zR94IgCIIgCNYdl1122T7/3qpI/ZWkX5H0\n", + "oUdfv7DX+//fZDL5sB55pHespKtKD1qrEHlFZXDP2is74yV6TEgO7vZ9v62hqsm2esN4UR7r4tT2\n", + "L+QqVS8a+t9jq1LgBebiCfru/4QdojqgcKUgOxDlyyvGM85U40WJw5v2eB+8PK/0n5o3pTXlUH2I\n", + "A8kpwkPFNZR4raVjhkLBtYylAnsVejIo57XLPZmg2GDtforYjvcrawJrK7bJWOfG3DNuh4Y1oVRF\n", + "TlVIbyWlrmMP2B1zGOWn7z6vtU9H6P9LLrlEUrcGMB9yFddz6r6DnfBbinLJ61h4hQCeDpSO9xln\n", + "nLEn23ktSsofXKxHAsufOZlM7pF0rqQPSvrsZDL5VT1a/kCSptPpTZPJ5LOSbpL0sKTfmC6i4mcQ\n", + "BEEQBMEcKMnae3XiTy9LfP4Dkj5QcnKek3P3XquYpDxh7vb3apOk7u7f94CjvhH1qXLgGXOXS2xT\n", + "K2QsUO+JeI2UV+NQA4Trc+WD91u9P8ZpfyOVXUiWGl5ZTklKgd3RfyhBKWWFeA7fq5DPY2fUa0It\n", + "oH1egwXvy73GlJKEl5YDOyrNjhzKyx8SPP++CkAO+pTaXIzl2OcFFABsr1aRStmE70NZqzpiQ7m5\n", + "hc2jgHEejwXy+DlsrrZdQ9lqan9R2sl48JszVKyUZ5Cz9qeui/f9/F53K0WtAsZaxPnmtTZgR9Sy\n", + "G5qo8RQEQRAEQdBI76y9PuDxc5eOklSqxDi+IzlwF8zds98N84rX40qA4xWv+9a34Tl07Q7g/v0U\n", + "fe/6qX2yv4GS5+NMvAL2gkLUOs54xdhXzq6wP9QE7Jfv0+7du3dLku6+++41j4ci5tmOfWOWSuNg\n", + "gP7sWxNoPZNSXlrjFku54YYbJHVrYy2pMca2SlXMFB75QTvpF9RTFAXWImwJBeaggw6S1P12kBnL\n", + "bwpPD1xFdcVmaGXI43O9dhvKJHPc25OqdZfClbrc2k/7vO4Vvym5OVtrt62/7X0ZOyswFKkgCIIg\n", + "CIJGFqpIcffdtw4T3gsxI+7l4Mnzd85LjEiqsjdeEO3zfY043lC1R5aVvnfzuef0i8L3FgRvJ/bV\n", + "qkjh1aFgprxe3if+hPNxftrJ32+99dY12w+8715g35i+Wmoz4nL7mO0Lj8FYdlhD+io7KXKZvIvG\n", + "6xSxlmLzjCdzAQUE2+Z95qxnpPK51J59rE2uCA2VaerXx/k9btHttXSOur3XPj2g3/ieZ/6ul3mU\n", + "Y+yswFCkgiAIgiAIGlmoIoXXgcfcGidAlhXKkXsdeLheD4nzphQX9+JSsSv7y1370JCNSD+P9Xzc\n", + "M3pKve+UvfE+3lpttWCHOAdeU+oD/YN3yHXgJXtWXg7s1O3b60otG33UgNq5yJpx5JFHSurU6bHn\n", + "NJXOUblzlcD3VzwjmDnnKqvXymPcfI4Sb4sNcRx+azxWzPejHEo1T8UR0m5XnHxXC4+hSuG/QbV2\n", + "i3K33iuLL5pQpIIgCIIgCBpZqCKFF8FddGvtTrwM38kbPIbKs/tQAHIxMK5scb5l3ZF6KDzz6XYl\n", + "uQAAIABJREFUpJTWLMRaWp9/4w17XAF2gZfWd3yJk3jGM54habUyh30yD9ybboXj1FYfLoV5RNVu\n", + "Ys7cu23NGEudb8hYOzIgvXbXWFArbvPmzZK6OkIHmhIFbpu+ljM3WIMYe7LLUI9ReuhHbJC12n9r\n", + "wL/Xdxy4nlTFfJQ1V6RaY9iG+u0ZK2v0QCEUqSAIgiAIgkYWqkjhqXNXjXfQWluF73kWoO9j5HV5\n", + "crE7HBcFwxWvvnWkxob+aFU4WrO8hoohq62lUkoqWxSVArug/a1779F/HmMH2HkqixD7rbUzvGs/\n", + "nlf+d0qz5tjHzVUdahcBmVSlyqHvxwVjKFLzqjAO9CmKSipjeL3Amsga2bc/GXvGmLWWOYDS5HOX\n", + "fvVdMjwGLaUQ+fteKb0UflOOPvpoSV1mLYyteHqWYClcL2tVxEzVEYpUEARBEARBI0tRRwrwQLkr\n", + "LlWkiMXh+56VRAwM8Qj8vTRjgXZ4Zg3ZgUNno+EdoCT0fW7fN9amNQbJM2FalQRXAIci5T0zntiH\n", + "V1uuVUpRHW655RZJ6etJZfPllCjP+HF27twpSXr5y18uqVOSbr/9dkmdfaAsEfN05ZVXrnk8qkhv\n", + "3LhRknTzzTdLSu+9V+uFp+y95Di1NajILJ1XPB97fTFWy65m52BOHHzwwZLqFSmfSx6viE2hSjM3\n", + "UaR4RYnxCvK5tRnFijnEXGeOsmZ5O1PqqGfe+vm9TpbTV8VvjbXi+vz7y1IDkH4jQ3/ZCEUqCIIg\n", + "CIKgkYUqUr4Tc+teXP493+GcfZdcWXElCu8GxcpjYvB28SbwfvoqJp4NSEwJCkVux3a8qpT3xfE3\n", + "bdokqVNa8B5zsT+tledbn7P7c/7cDvFDc++99w56PLfP0n7BG8QbS9WkQUnCq/Tqz67Q3nTTTZKk\n", + "Bx54YOZ96lTlYuKYR5dddpmkzp7GIhUztRZca06RYk6kFCn+jjJAVfrWCuTMaa6FOetq97KRU2FR\n", + "iqjDhc3edtttkvLKSm5twya94rbTaoNeId3jdbED5gRqLeN45513zhyPftqxY4ek9D6eqUzavjFU\n", + "KUWKceE3hjWf/5944omSun5mzX3JS14iSbr//vslSdu3b9/n+TlealeFWjge4xGKVBAEQRAEwX7G\n", + "QhWpeeHKF56tZ7PxmlJo3IOHlMJQ+nzZ24GCkfPWIHfXT/voh9osNI+xwksj+8u9KNrj8QV4YcRT\n", + "4J3xfbwgzyrzfbf4vMcG+d6NtBPvn//zd/rXlY7WWKihwev1mDnG0+015c0+9NBDM///2te+ts/z\n", + "5uIsatUTVAtUg1Q2oXvN2FGNIuVzDcXJ91BDWQBXCrzPuYbWfTXHVu3GIjcH7r777pnXoaCfXelC\n", + "RWetcKWIuY4N0X7WPrchbJ1xZm1g/J/1rGfNnJ81hONyXtrF31N73hGnS005B+XT61DRPtaslOKa\n", + "mrvMC1/zmcvXXHPNzHUB8Y+lMYTHHHOMpNX9wHV5PDPjx+fpH/qfHQD4TUTZhaOOOkpSZw+MB2s4\n", + "32P8U/HCfI92ofKXzvdQpIIgCIIgCBqZ9M3oajrpZDJdWVmZ+3mDIAiCIAhqWVlZ0XQ6XTNgOBSp\n", + "IAiCIAiCRhYWIzWmIsVz1Te96U2jn2tvOA8ZDkBGCM9bP//5z0vqnnefeuqpkrrn8bt27ZLUxXds\n", + "3bpVUpexwPF5Hv3Xf/3Xkrrn7jz35nk0z515n/gBjkdsDc/RvbYKz69f8YpXzFzn2HCe3//935fU\n", + "PfdOPe8vhTgYntvTL7/92789c176h37kvPRLKmbHaxnR35yHzLKzzz5bkvQHf/AHM98nHofx5/+o\n", + "x2ShYlfEkXiFdNrNdb7+9a+fOZ/3H/3C8bAv6k2RzUj2JzFMxA56fAX9OE97ueCCCySlM4CJfWAM\n", + "PQaC/xPbQeyL1/35nd/5nT3nnAec5xOf+ISkrs+poM1Yc93EfGAznm2ITRFz8vM///OSpIsuumjm\n", + "fJ/5zGckddlcjDFrhseH0k/er8wVtxGfC/Puz09+8pOS8hXmfU57HSvWBl9TsLe3vOUtkqTzzz9f\n", + "Utc/9D/26FmA/JYR+0S8I+ejvzkO53/Na14jSTrvvPMkdePF54hTpbYdvO51r5PU2dFXv/pVSd08\n", + "8Exi2v22t71N0vjjx/ne/e53S5I+/vGPS+rskzUMu6KfsNPaTHKu99xzz93356qOGgRBEARBEOxh\n", + "v8zay9UcGYpU/aYvfvGLkrq7Yf6OF+jZeFdfffWaxycTBm+CfZt2794tSfq1X/u1mf/jpXI+Xv0u\n", + "HG+JWi+Q2pMPr2pRDF05nv70bDbAC0GR8rpKOfuiH/EOySzhe3iZfj73Fskk43h8j+My7l7zyLP9\n", + "+Dx4LRng+yhenP+0006TJB1++OGSugw0VI5cZheK67e+9a2Z87tKgp1t3rx5pn1k3PA9lDi8zjvu\n", + "uGPPMXJt8Wyq0ozARWdwgmcOu4IBuYxfFAZePbMZqIpfitcyy9FaO3AoSvc69Cw5z/QGt2nPdiMb\n", + "z9cU7wfmvD/dcFg7WOO95p5nOqf2FgTmgT/VANYarnve88Lb7dfLdQ6VJVta0T0UqSAIgiAIgkb2\n", + "S0WqdV8g7t5Ld8BO/d3jCaD27p3n3157w+/Kvc4SypcrF7kMTWK06D/Ok9oXatnYsGGDpM5rb93H\n", + "jOtHEcQbpT9y1Yc5L5/D20ztOejqAEoZdogil/Iic/vLeRVllC3OR3tRxPBG8daJlfJaPShGrmz5\n", + "HprYH/abiy0j1o/+47rxPmnvWhXva2MgvC0pVXYoUCdRxlorpQ9Nao884uXcRvcX+taMq6lxJnVK\n", + "Cbad2luPtTunLDInmbOuxPiawJxJ7RaBGp1S60v3sJwX9F/f/Wj7EopUEARBEARBI/ulIuUecSlk\n", + "SaEY5PZ4I0bDvTRiXFCmUhkuOXiejsLC92kn4LHjLXA+Xku9a47vlaUXfbdfCgoKipxnbNRCv6KA\n", + "1O6sjpeLfaA+eOV2vEpXslCkcgprrXLq1Zs5L//3OINLLrlk5vsvetGLJHV24nh7Syuhc35eDzro\n", + "oJl2uLftle33RanSNHZdPTz+VmoVkFJQAx1seL2sAbUQB1irSLX+xrjylFK3S3e1SO22UQvKjsfl\n", + "LjvLYpehSAVBEARBEDSyXypS7hHj4eY8d2KRSu/GU5/jfO615LyeQw45RFLnYZfWvuDvPO8nZiV1\n", + "t+573Llywt/pR5S3WlAUjj/+eEldBorXLhkKz1xB+alVpIjROe644yR1XlptnAgxZ4cddpikLrYI\n", + "xQzoZ+yGmKpSRdHHx2OW3A7YV8t58MEH13yf/qN9kNrB3vEMpRQodjfccIOk1fErZPXR/7SnJKtz\n", + "ETs4jAFxbNg4tprKuivFxxZQE1vjDXO0KjvQN8apVmUG5uyyKCLg48jaw9MRFE36jVg91ppUliBz\n", + "ne97PbEDnVCkgiAIgiAIGtkvFSmn1ButvbtOxX64opAC74FMHjxuvp+q4eLeF7FRpV4SihP483j6\n", + "C2/RP18KXjPtSu2IPhatlc9d4WvNWqRffad3V0w5Pv3N+PJ+Tg3wmCu/7qGyLukXKuWXKpXE3+Ri\n", + "pbD7VG0hYg+xb4/lOxDwiuFDZVGlxobYsrHw66mlbx2j0vi9oWAtZc4yV/sqfjzN8LhF1nKP9yz9\n", + "TUQ9p59pP+/n1ljWHtT42qxP382iVUEcm1CkgiAIgiAIGjkgFKl5V1/Fy+EumufLZNtxF08MDRW0\n", + "8c5yd/nuTbi3kSOXEeJZhn37z6vjLjsoIsTsoKTVekN8nmwz7CIVa8TnUabwLnNVelP1qaBvHIpD\n", + "PM4RRxwhKV0LB4aKT8JuOV9pjNYyQX0gXrG1XIZwilZFBZvAZlJKQali5Huvla5F66VG3VC4wjeU\n", + "DaPK+vFSsXM5JZP9NLETdtXgPB7Pm4K/91X+WAuHfqpRk/m7L0KRCoIgCIIgaGRduHR97xr7esQ5\n", + "j9shdsRjpfACuKsnSwrvDe/M9+bj+3gH7nXg5QyVQUG7UaRaqy/3zahZNNgN/dvqPWO/Ke/es9oY\n", + "Z1emvMI6eB2xsWE8XXEdW5HyfdxSmWbLCPsUUn2fsU3tlZciVe+pFlcvU3GVxLbkYIxrY31a4xiH\n", + "IrVf6ljQT8x5n9u5tTL1W4hS4+NaG+OGEvW85z1PUlenCkUKULpy7c2p5TnGzg4cKuYqFKkgCIIg\n", + "CIJG1oUitehI/aHuhj0OwbO1iIXBO/S6Q3xu7P5whaT1Of56VaK4Xrw5/t+qrDBuKFKeBekZKT7O\n", + "rkx5nAD2kvKqW73tlKJIe4h9yylhHqM1lFKZyu5bRlB3GdNFZbKmSM3xUiVhvc71eWd+sqZzXtYU\n", + "+s9jmsjuY01mTfKnBGR8+9rCrgleH8rXNOqToZiyxyLt4fOowN7usVn2OnChSAVBEARBEDSyLhSp\n", + "ReGZLaWkMhT8rhov9dBDD535O1VoURo8a8s9/KGfH+MFoaBQv+dAAa+P6/esulo8/sHjFogT4dX/\n", + "zv+Jj+Fzbk+peIjWGjVklnmtG69Vk9vHztWOobxYYhFzWY3LwEMPPSSpUxbw7Ev3VIOxFACvRQa1\n", + "cXe5mCNshzXSa6zNm751rHK4uk+lcdZw5hS27Pbg+7mm+pXfEP+tIjPcFSneR8HilbWetYb2MYc9\n", + "U3f79u1rtudAIxSpIAiCIAiCRkKRWgOeK/PcuTazpnT/JRQp9nIrfQ7sXgftJfaE5+e0w5WFlIKF\n", + "l4T3gze6Hjz+IcHrx/vzasC1WaSoEeA7trtixHkYP7xDvEa8eL6Hd4mXmNt3jXHmOlIqB3biihL2\n", + "xl6KfH/Xrl2SViuYtM/38sv1Y26PzGWPm1gL1OZWhoqPRInBxlLKDH3M2sLYMyZuu/53b6+vXWMr\n", + "Qjmo7XffffeNcvxUhi124HvduU0zt3K/KaldMFw9BtZ24m9ZW5jrxD/eddddM59n7Wodt9anPMtO\n", + "KFJBEARBEASNhCK1Btw1u3LgUJHcP1d7t903YwRvIRVvUVoHinbPqx7RoiDuAKUnVZtnrOf/rsyk\n", + "FELiSHhNKU233XZb1fmPOeYYSZ2agP26N4wKgbdKLBSKJd40e++Bqy733nvvmu3IqSspJQpq9+1a\n", + "D2CLKAU+p0888URJXZ+SbcX3UPnoG95nrMjG8orV1A9yqGCNIuJ7xZE5iWrNWsYc4/98Hhvi/8ce\n", + "e2yyL+ZB7dOGWjyedceOHVXf77srROr6+E3w3wbPIPa523fOtSpRKGuLzuBPEYpUEARBEARBIwtT\n", + "pJ7xjGfs8XjxYH2/JjxS7mLJCEEx4X28rv+fvXcNtqys7n7/y5jXSplKjtGEcIcGmqa5XwSiKIdo\n", + "QI0xJ5oYY2leU4oxQcErclHYwdCiIkYUbyXRJCZaWpbXilGCSAKxBWmu3dxBFMuYT+fDqfKDb9U6\n", + "H+DH3Ovfe+zneeaca6/dMn5V1KL3mmvO5z7n+M8xxsPfee8NJ554oqTu6Zosw77bPNYT5+H6WFdH\n", + "HXWUpM5yx0dkx44dM9db65wqa5UDpQTv16NstnxPP2Ld0u/Uo1Qfxgfn9wzk4AoLVr775vTN5cO4\n", + "YLxhfRIhEyl7i/YLuf/++6uOc+UMWtuLfka1oP6oKb4/G+MEnz5XpvBdRC1ZZD4plBzqQtkZw3ff\n", + "fbekWF3jePzINm7cKKlTA13tww8NaFPOg38aaxNzAlUThcst+6uuumrF8uG/6bsq4L/G313VRcHy\n", + "nGGu0OCDsyhcDXafIY+ULfkforRxPP2wKKIIYNZgjzDftm3bquejXejf1n08GT++Bpciz/1ev95I\n", + "RSpJkiRJkqQnk0VEvkwmk+nS0tKaXzdJkiRJkqSVpaUlTafTFZP1pSKVJEmSJEnSk4X5SK2FIsU1\n", + "LrroIklxxADRd5s2bZIkXXPNNYOud/nll0vqIhzclwc/hsgHBd8b9/3g/TJ+GS972ctmrjtvuM5a\n", + "X+8973mPpPYM3bxPxz+jFPHB9bZs2SKp6zd/f4+PTl/fKsp1zjnnSJLe//73S+r8BvC54t/4weB3\n", + "4eODdsE/w/Og4RfxR3/0RzP1HAvPbI7fxAUXXDCX60UsLS2t+djEp4RP5ih9jP8nvjJEqeGbQhQX\n", + "Yw2fItYIfFKe97znzVyXPdHwMRoazYTfKL5cZ5xxhiTpn/7pn2b+zpjE14oxGUF9yOhNvib3I43W\n", + "Ft9loBTJGeG7A7z97W+XVL43kIOPNcDry5zDJ877wef6pZdeKqmbu54Jnhxx7l/p+3/iH0iOOn5P\n", + "/7z1rW+VVJ57HB/t41nLWPeG0i4J+BIyPt/73vdK6tqNiGT8lj3qER84jn/ggQckdeOLtRdfReYv\n", + "99qIVKSSJEmSJEl68rjII1XKXUEenX333XfF77H+eHotUdo/i6d/j/CAyLrEKiL3Sy1YHb5vk5cn\n", + "2iPQWevstIcccoikzorAasK6xZrA+iVSivbC2qaevoee5wGLsgjz+82bN0vqlCKyCqMEcf4oi7Xv\n", + "a+b975nkKSf1iaIaaRe3Kl2RGhu3HheZtTiaU/Pi6quvllSeO/Rp7dz1sYMiBUSPMeb7KlIeIenn\n", + "QRHz/FC16jDKU6REOZ5xnbHVup+ojwPO4+WmflH/lXLwlcaZzw3fJcDnMvUsjSdfo/rup0l/s1ef\n", + "rx0oNLTDvPM4lXy2vXwoekSRcq/zPQ6Be5/fA2lPIq73228/SfU5FVORSpIkSZIk6cm6UKTc4h6K\n", + "586o5X/+538kdVYX78dbc2VEYP0ccMABkjofFt6Xo3iVrAvPk8XTOOfj95wXKyLKXxQpMNFeZ2ut\n", + "OKDwUX63Kqgn1jkwnvAj4f047US7+M7oEbQHoGCiRHH+m266adXzeDlLYC0yfhgnlL+0Z55beZyn\n", + "rxU7L5hnnq0bdaZm3LnFP2/23ntvSfFeZ/NirKzujF2UFR8TKGl8osoy1kt5lTh/SaWHaC0q7cuI\n", + "6ox6jcrsuxP4GsjcwPfG98Ucit87qF+0ttb269i5A1F2UNtRfnzvvRL4G1MP7sWMq6H3DsYT0J6+\n", + "9+PQXH30W21OyFSkkiRJkiRJerIuFKmxc1m1WvzgPlBjZ0zmaRnlC+uHp//ap3V/SuZpvGRNRfXB\n", + "n8Ctxr4RMmNDRnqsIqwN90/A+vHM5/wbhYr2j96jR9A++LlQDqwXrCXOH9E6rlBIsfaYL4ybyBcr\n", + "ggiyRWeVdugvz5rcYsXW7isZRca2gjqM/x5jMlJWWmkdo/DCF75QknTbbbdJ6jKUOz5W/XqotfQB\n", + "Y622fkOVs5JSRAQz/n/XX3+9pPp9Mmt3U+iLK3yudPDWw8etZ4QvgULYN+qO8cF1Kbf7a5ZgHrgS\n", + "Odb+rf6s4PdOxq/Pa49OZO2OlDbmRbXfcNVRSZIkSZIkyU6sC0WK98U8BbcqVL7XHtbmeoUIlr6R\n", + "EH2tPNqX9j744IMldU/1tX4Maw3WQ0k9IIcIVp9H743lgxe1U62vVa1i6uMafxSsx75WHuONdqJ9\n", + "x7Iah+J7YM4D6hz5qtRCX5R8hfoSrQ0e3eb8+Z//uSTppJNOkiSdcMIJknbeuw88khhcDaQ8tYpU\n", + "3ygvxiblihQpFBMUBOZ8xFrvg+r4mI4U1NZy9r0noNQw9z3KsRUUHu7BHlE9NOqvtEZxj/N25br8\n", + "vuRHjW8Y/polUpFKkiRJkiTpycIUqSc84QmPWYO838X64H01T+Ul68ffexKVtF7BCugbXTg08gHr\n", + "m3ZdZN6fGrAKSn4M+FLhAzR2zhOsZM7vO6jTr6gTrnIwPmsVU7cSUdSGKkeUl35fL0pUBNGRY/p0\n", + "jaW+Rr5H86a0Jl555ZWSOpW05DvGWHXVNspaH0FErOencoWFuROpxIzNH/zgB6teDwXki1/84szv\n", + "Ihaxt+x6hjVyLPXX85GhlI3lMxhF5daq2JSjVB6+r40CTkUqSZIkSZKkJwtTpJ70pCft9N7Uc0LU\n", + "+rSU8iStN1rrNzb4QaDktUZmrDW1yt1a+NZInTWNMsW4RTFD4cE6xqpxf4FaOG9kRbkvVYnaSJT1\n", + "gu8D1xql+Hjkm9/85sxniciPkLcFrBG+K4D75nj+IaLSfF/IsZUhzs91fQ+7ZG1AefS3HmNRUoha\n", + "18II1hgU1hKpSCVJkiRJkvRkYYrUz372s50ycPf11XFFBStqvTJUARpaP3zIaPd5W/goN/hptEak\n", + "uE/ZUGvWM2jX+sswPokg4t9uhXnGcawjPj0yqhSBhXXt0XX4GKLYsOO5E2VXXu9QL6//GOB3xdhf\n", + "LznT1hu//du/Lalbsxg7pahHV7hcVWbtH2vXiOi6iwZF7vEC7T6vXRNK/YraP1SR4t5Ye69JRSpJ\n", + "kiRJkqQn6yKP1NhRY2PtQ7VeGRqViFWJEsN7Z7IIs0/VWAzN3eKZrodG41FPdvh+8MEHm35PZApW\n", + "NooJ5WI8Y6W7VePZpPFVi5Qi+od93XbbbTdJ3ThAHbjvvvtWPM96j8p0iGpEMWT8jJkDiHPhAzH2\n", + "Hmu7GviWeBvzd2j1QWLsRX6Ou9rYbGW9+5+ODZnNGSesRWPlWSuNt7HUdu41jPPi8aNcNUmSJEmS\n", + "5HHIulCkoHV/occrQ60cfJZQNLAi8OkZW5FCQcG3C1+pWuUQq5hyAtFnrVFoKHGcr68/BdY0VgvK\n", + "E+/no/frKFBQikTBmmOvPa6HckOk1K7i+1SC/vQozDHHJW3KXKBPdrWIxlpKewsypnxORpnNUZhK\n", + "EbVr/XYAhRFFYWxFqDUT/q6etwp/Tt/XNIJ2517O2spa26pMuf+or9WUD6WK8ep7/bWycePGmeuX\n", + "SEUqSZIkSZKkJwtTpJ74xCc+9vQ61JL2p9a+GcNrQbnBOsNKqT1+KEMjEnha5zy0W+1eca2gKKG8\n", + "tO5QjjVEOd3qbAXFM4pyK0F/Y/088MADVb/D6t9nn31m/l5SQaj3PffcI6nb8Z52bbX66YexIpvw\n", + "ZcJKHxpVSvk4n/uUjQHnZm7Sp62KFHUfqnywZrGWUS6P8OxLKbdaZLm7gsB5aD+Uh1blYl4wt+64\n", + "445Rz/u0pz1NUhfFSEZ75tDY+apQEGln1qxNmzZJku66665Rr8e4Y01jDhPdum3btqrz8DvPIM6a\n", + "3apI+bOB/5s1lXYiSpK3LX0VKd+z8cUvfvGqx6cilSRJkiRJ0pOFKVK/8iu/slNGc6ywVh8pfHCw\n", + "htyXhmgn9mLDinRFpqQY8TtyZHA81wdXoMbe820oRHfhq+QKwNigdKGEtWb2ditm3lYv1oxHLDEu\n", + "sboYP26N8j1WOudB9fDcMlhVvr+TK49Yh4ceeuhMOTmu1sfwyCOPlCT96Ec/ktSNZ1SRWsUQK/ak\n", + "k06StLOPWF8o/9i+eiuBmlfaiy4CpWKoIkXbRfmYWiEylb3o+vrqRErWPCIppXYfJIf6RrA2t0L7\n", + "eR6tUv+U3lZEMK4OOuggSdJPf/pTSfOLcnzBC14wc73rr79eUrsaTPu7EjQvXznmLf1CO5XYc889\n", + "Z37nUbut8yUVqSRJkiRJkp4sTJH6tV/7tZ3y4PCJdVfa+RulCQsbXEngKZ6nTCzwWsu5FAHiO8Bj\n", + "DZI1GYUC5cKz/bqVgbJwwAEHSJJ+/OMfS+qUGJSxVlCE+D3txL/H9isArBraca33vypFLHlkxtFH\n", + "Hy2pKy/9xXhh/NRav67UeNZf9/VyBZOIMuaL+x9wfqL6aG+ULa83/gooY4xXxgPWGf5CXJfx7zsR\n", + "oPTyd+r5rGc9S1I3zvEvob1R7Dgv44L6007uF8G84Ljl88Gjg9x/krbG4qcNKGPkU4Gy4GsLdZ8X\n", + "ff1HWRtZS/r6P85LSaA9fS+zkhLFGGJOMgZQJkq7NHheIMZDSelxxZBxMC8FjHufZwofKx+T8+//\n", + "/u+Supx6999/v6T2fUuZbwcffLCkbg3x/mKu0z7eD4cccoikndcGXyv97QbfM67oL87raym/p105\n", + "jnWhVp1PRSpJkiRJkqQnk0XkuZhMJtOlpaU1v26SJEmSJEkrS0tLmk6nK6YESEUqSZIkSZKkJwvz\n", + "kapRpI477jhJXXRRrUe+X6N0Ld7neu6IWngf++Y3v7nqen2zvDpeP97r4tdQeu9PVufayIza9uwL\n", + "763xB+A6W7Zsmfne/TboP6IR3ceI9+b4NbiPFj5Ub33rW2eu6/mW+D0+QJz3+OOPl9T5NeCnwft3\n", + "+gEfJvwO3vjGN0qSLr74Ykk77/9Wej/P+aLoNvxJ8BM466yzJEnve9/7ZuqFfxA+dO5Ps8cee8xc\n", + "76abblrxeu5z97rXvU6SdPnll0vq/EzwU/F8XCWfSGCPRN/H69xzz9Wll14qqRvb+DB5PhuuGfmA\n", + "lPIi+VxgbOJvRl1Zu/y8tBHlwheE3/H9XnvtJUl60YteJKkbK0QK04cl36AIfFroO8Yc9briiisk\n", + "Dd+LsBSN5+0ZRaCyxvWNsoyuV4J+oL9ao9lK1/O1z3FfP4f25d7y2te+VpL0oQ99SFJ8r+EeyzyI\n", + "8lORuw5/XS8n9frYxz42U073OfQ57/3L/OD7KK8b1/vABz4wU/7aCPlSe0fXi0hFKkmSJEmSpCcL\n", + "3WsPD3oUAVecsNJalahWnv70p0vqlIaHHnpo5vtSNtnWTOpYrb/3e78nSfrc5z438z3ZebF6PLrQ\n", + "82QBCkltefpmjEapwXqOrIDaDNooHVirbiXw+yiCiHpgtfnvff8lV6RclYii/Nwa5Lxbt25dsVxu\n", + "baGOEDEGvs9ZbaRIqf8ilcIjkDwflYNCVYpy5Xs/zq1S2hHFrFaJAo5HlVmeq6fUZyhMJd/Q1lxl\n", + "tKVH8EbnRXFhrrpSw1iIcpmhEA3NfO4RoL52jLV/Y20+rCiXIO114oknSpKuvvrqUcpHfaPxwBpG\n", + "eU4++WRJXZTbUGUMSspIqZ60r9ejNI5RmEo527gnlvKGUY5IeSxFZVJeH/fgUZes+aztkXLqil6t\n", + "ElXLQh+kSpvO8qomgsamcfomK7vtttsk7SzDs9ATbh09SLV2Cud59atfPXOdT33qU5IPTw4qAAAg\n", + "AElEQVTKi3G0keK8QmMdFu/SIlLbHxwXna90ntrFrHa7gOhBikW+tl7Rg6Q/yPXdKHesRK+ekBN4\n", + "4PcQ4RKlB3nOF5WfB6RnPOMZkqQbb7xR0s6pBvi9bwItdQ+H0WamY8+V1rWHG0Z0Y8IoitYWbkiM\n", + "VefYY4+V1D0E1yY39Rvx0OSqULtNVvQ97cQaHT1YeLJl+iU6vvRAzdzFmP/yl78sqT2p8Lyh3byf\n", + "+Xv0qnrspLcYAEMTtfIKlzU7egBjnpRePXv/8+zAg1nfrWQeK8egXydJkiRJkjyOWZgitdtuuz32\n", + "lExSs9ZtFtxa4ilzJQt1NZA33ark1UkpKV1fefkzn/mMpE65qE1+N7Ys2UptyoxaKx2FLTovCofL\n", + "7A5O0VHywdpEoJF1gpVU+0oUtYBxjfXk43OszYNrKV0Pqx4llv6h/FESSlQH3zLJYVxEViTbVDzv\n", + "ec9b9bpcbyXVJDo3FvpYTst9KVnszPHSXHNljTah7ejDv//7v5ckXXfddU3lHLptVKtTbwnmEnPI\n", + "1Vxv17FeTfr5x94aJ4LEqv62pBbG+9A0R7W/H6td6GfWHsahl4N53qoIR24IfUlFKkmSJEmSpCcL\n", + "U6R+/vOf77SFxlD6PmX6dgo46fKUywaOteCHgTUQKU28n64NLS45Rtb6IdRublsC5cKtBxSEaCNW\n", + "/z1b6HAeLxfn8e0BHJQowuPZOugrX/nKqr9D6YLIiuX6+LShTEXWkCusHNfXyo+s8AjGg2+SHI0f\n", + "FF1+h9N7tNWM45uQR3CeaPsMVBN8F0vrA6pHDawN1BX1jL5di42SW2hdy6gXbYwidcwxx0iKFamh\n", + "mwVHjK2e49NCOX0u8G/fLLi0TdRY5eq7/RVzjP477bTTJEl/+7d/K0natm2bpC51yS233LLieXyu\n", + "w9B6j62acw96/vOfL6m7x6KwRuMmCiRaNKlIJUmSJEmS9GRhitTPfvazx0Iqsbp4SuXpfK18gXha\n", + "R2nYc889JXWJB1sVMxSV0u9QNDzRY4nIkq+N4hqqRGHtoQTQfkR5YQVTnxtuuGHm99SXJHdYc1iN\n", + "kcJQay0THl8bVl9rbaEIUn98/Kg/45ZyRkn0+lqtrdF9vkEoROMSfyH6h3bhurXjpuTr6Jtmc36U\n", + "W/q/lAaCdiY9SQ2MSeY6iQZbUzCsV2jLr33ta5K6+pZSyDC2S6rvvCkpR9QjUvmZc3wyB+bth0i5\n", + "+/pQUT7q/cUvflFS1x+85Shd39X12k2ZI1DBGUdjRQrTPmyOvKuTilSSJEmSJElPFqpIARYoVgQW\n", + "P8oG+aTG8rB3HnzwQUnd07bnwcHnBt+pUjlak/nV1gslYa0iRiK4PooM/edRaSQWxRpCYUChob/5\n", + "fl79Oxb4srHNiFvFbq0xjlxxXOsoPVekojxPjC/K2VcRrrVaUZQoH9Y0yjTXj1QKj4Zsgd+iRBG5\n", + "+4vCAw88IEm68sorJZX9yFC5oxx1a0VJdeb7yCcJtZOxxFo87znnSYHH4gtf+ELVcbSLzxH6vaRm\n", + "057c66gPazj34NpkwbVs37591PMtilSkkiRJkiRJerLQzOaAJewWPlYF/gz4VI0V5QduQfv5+Z7o\n", + "skUrJ4v2Y3AfMPqJ/EtYLSiKbAFDvjAUKf/donL61IJVW6sIctx6iSyBknU+dH6VrFb3HaOdGNf+\n", + "e7bUKfnN1ICaiH8eytSic7O1Urv9Et+j8nmkLaBoRP6XQ6mNFC59j8LCRuXsEkF9UMl5qxHllKsl\n", + "aq+IsfNW1cKc8i2Dau8VjCfK7xHX8xoXJcaKMJ83qUglSZIkSZL0ZF0oUpHCw9PxUKuiL7w35j37\n", + "ov0HYNHlcL8DrAWP8sKnjKy8HhlFvy/KiutL7T5b60WJcmvS96GLjnellnGH9Rr9vqRoeWQV48X9\n", + "Y1CiUZEiPFKp5tr4Xa3V/pR9QTlz6MNaf0xUvWgfT+buvHyJxjovqjWf7itVm8usFsbL0DxR84Y5\n", + "FPlplmAtZjzxyVuitfbrBL8Ht8z1taSoSE0mk7+fTCY/nUwmty/729JkMnl4Mpnc/Oh/z1/23bmT\n", + "yeTeyWRy12QyOXVeBU+SJEmSJFk0NY93n5L0IUn/uOxvU0mXTafTy5YfOJlMNkv6U0mbJe0p6d8n\n", + "k8nG6XTayzTHp2ZRkCUW6ybaY42n5rVirfw5UAIiKyAqh+8LFSmOQ3fcHouWzNhSu4+av+fH126t\n", + "QI0Aoioj6zqKumMeDLX2yR5OO0TtiUJ1++23r/g9tIwj97NatLobga9L1DatOcXuueeewWUaAjnm\n", + "avepLHH33Xev+HfaZSzlgjlSUvRqac0ZOJTaKDvmdIu/4VrAWoS6v17fXhTvCNPp9D8lreQFvJJm\n", + "+IeSPjudTn8+nU5/IOk+SccPKmGSJEmSJMk6Zchj+xsmk8mfS/q+pLdMp9P/V9IekrYuO+ZhPaJM\n", + "rQkbNmyQ1OVQaQXlgPfBT33qUyV1T8XRnniliIKx36+X9k2KMmq30jdnCH4nRLqUfFxaIfP8WLl/\n", + "XFnD+hyqiLp/AlbyWiuYHg1Jf6DkjJWtGDxyyGG+lNq3Noqzdq9KaeccWfggoZL1nTNjz3F8QnzP\n", + "OFgv/ncl2MuQMTGWIhWBT89YygWKYKty+Vu/9VuSdq7v2P3GXGatHqqwuv/i0D36ht6L5rU3Yi2l\n", + "tQz6Ru19VNL+ko6S9BNJ71/l2HFzFSRJkiRJkqwTeilS0+n0scfsyWTySUlfe/SfP5a097JD93r0\n", + "b6vyhCc8QU94whMeU4KwwvDlQCHgqZtoMOfhhx9uqMXOkPeIcvAUXfKJGfp9idb36uvlPTJKR0lZ\n", + "KOVq8fq3KBB9oNwokh7ZFSkpboWiSLliudY5i3w88O+xlCiP8qPd1jOo1uQ4o8woU7V4JGMtrHGl\n", + "TN6tuySMjSserb/DD27ecxbGXvtYc1rVb8ox7/xLroAOzTxOf/VtR+7Z+Kr1PQ97C47tR4s/LP1S\n", + "Urx4FrjmmmtWPa7XHX4ymey+7J9/JAlv0K9KetlkMvlfk8lkf0kHSbrBf79TIRacYDJJkiRJkmQ5\n", + "T37yk/XkJz9Zp5xyyqrHFc2oyWTyWUknS3raZDL5kaQLJf3fk8nkKD3y2u5BSX8pSdPpdMdkMvm8\n", + "pB2S/o+kv55WpEn2HBX4wPh72kiJgtLTLz5QfPI0j5/EcccdJ6l7msZqLUXIuFWJdbv33o+Ic313\n", + "uMaqw3odmuulr3U5b3gPjfXnvkWuxM1bcSspaOw/RSQS/U9uIoZ8ZIW78ub+NVhjnBel1P0XOJ7r\n", + "osiSr8t9/oDxtO+++0rqxgPzDgXQ/Tu4LuUnzxNWKPVFmSuB/wzRsffee6+keqWMcUN5a3D/tKHR\n", + "bIzFyJcJpYqyYgljPJZ8hlrqNg/o29o1g/L6WI3WrHn5C9ZmJGetYa64Usj3tW8D+H10XVeqWCv6\n", + "+k6Nnd+JOUy/tb4NqZ27zH3q7WtlrRIV7cNJ/3v/cb1a8abWT7b4IDWdTv9shT///SrHb5G0perq\n", + "SZIkSZIkuzCTsfetq7roZDJdWlpa8+smSZIkSZK0srS0pOl0umKq+HROSpIkSZIk6cnCNq6pUaRK\n", + "O5yXfH64xrzVL8r5jne8Y+Z6+NCMHbHC++vzzjtv5nqt4LdRigzCf+D888+XJF1yySWSuvfO1J+I\n", + "D96T1+6Yznt43mvj+/PmN79ZkvSJT3xiphwPPfTQzO/x1cE3bfv27TPf8z5+//33lyRt3bpVK0E7\n", + "cj3epxNlx3t1fKRuvfXWmd97lKn/nnbG5+mlL32pJOnTn/60pC6rMO0R+WrhF8D4970o3feI9nr7\n", + "298+U0/8OfARxF+nNVKM8Uj/MV/PPPPMmeuVKM33EktLS7r44osldW3kbYjPBEq8Z5knDxFwHsrG\n", + "GDzjjDMkSZdd9sjmDkQD0Racx9cm91vjvPiVUS7+jo/G2WefLUmP1S/KXcfv3I+uFfrsfe97n6TY\n", + "T5S5EGX8pl0Ya4wt1ghfWz70oQ9JivdAPPbYYyV1uydEPmaUC79afJN87aR+fF/KCdgX2pPoL+Yk\n", + "/YuPD7kQiRKknRgv3FM4jjWDT9ag17/+9TPXjcAvmLX8jjvumPn+sMMOk9T5C0fjieuwltGe1I9+\n", + "9nbGV8x3EWEtYe1kLWX+ev0Y94yz1sz/4Hm4aO/TTz991d+lIpUkSZIkSdKThSlSk8nksac/z7fj\n", + "T+ERfZ86xyYqJ1F7RGGxP9Qee+whSXrmM58pSfrCF76w6vk9T0/k1xZlV8aqcGujVnnwSAysTKwY\n", + "6k//tUYFch6sFv89ShDWlrPffvvNfLoi9Tu/8zuSOqXnpptumimvg4oR5XuKco8wHkvjcseOHTP/\n", + "phxcr5STiOtH5UANoZ+ienikUN+syK7ytObJwromirCUs2U1otxlUXSPK1AO0VvMKc/Sz5hy9bWU\n", + "H4q2Yu6gQGBRo5R5n/i+jc6mTZtmvvc96Vqz9pfGcmnvOcZCNCa8HtQvgjUgys+EOk0/efk84pd+\n", + "oBw+lseGdmfN8/HIv6Pxg1IXveWI2jnKME6kL/cIznvSSSdJ6vrf7x3g/cD5/J7o1/W3ST4euTdR\n", + "btojWqOGRrRH5axVKFORSpIkSZIk6cnCFKnpdPrY0x4WeGum5bH3COuLW1FYqdu2bVvx+D/8wz+U\n", + "JH3kIx+RJL3hDW+QJH34wx9e8XjqiTUZWYluHaBIYMX13Q/MlYvIdyd6endFLbKq8XtwKG+U+wNr\n", + "HqXJwSrlPCUro5Snin7A1+muu+6SVG/lez/5OB6qtJZyvnB9lFL8AHxctPosYS16TqWSlY//RUnF\n", + "qcHHKtemz2r37kI1JtM5ZcefDJhjKFLR2KEcnv3exyJt4BmYoTR3yb9D+Z2S36Krocy5KM9RlP0f\n", + "UB5YgzxzPCoklFTyG254JL9zNMZZe0s5B8HbMxqj+BJ9//vfrzpvBOMvyg9Ge1EuH699801Fax7t\n", + "xPhkrl977bWSymual4fxw3zDd8vbFZ+o6O2FK4VQmyuy1dctUu9r/XxTkUqSJEmSJOnJwhQpqXua\n", + "nXem6r5PqbW4olDKBnvfffdJkj7/+c9L6hSNEiXrwJUMyoUfSN8Intp9xLBCXFnCujjrrLMkdVb9\n", + "FVdcIanLxB2BtRT5BURKFkTKYARWdhQRRD+QCfy5z32uJOlzn/tc1fl9vLi1VrI6S9GqKI+R1cv1\n", + "mXee9ZdoTvah43sUJ8YvoKIwv7w+tf4mrfuZrQZRP8x9z7hNG0SqNsfxe8Y25wXazM/D74kUxVep\n", + "VEd8uShv65wlgtMjOaGkLvr3pb5jDkSKFL5ekWXvfy/dC0pqK2vB2G8rWBPwHWJN/M53vtN0Htop\n", + "uhexhtcqp7WU+rF1j8novPQPSpf709JuKFUlmF+16jjzztuX+YT6jtLLWum+hFB770tFKkmSJEmS\n", + "pCcLVaTWinkpUeBP5aWn2KuuukpS9x56LEUOaxalwhWHWnhKp92wKkpwPc9PhVVx9dVXS5Je/OIX\n", + "zxzv+F57tGfJqqrdX6tESRGiXfCXGOo34VZ7aX8v72eHdiCC6cEHH5z53vcVA6w9+h9/Ho6PVA6s\n", + "QKLvhrb/GHgZPCIShYkx6r45RB/RFnyPeowKydzwscnvWuce5WIMRErPWlGacyV/PnxhItXYoyZR\n", + "DqI1m7HPmEOdRcEpqfalqMCIO++8U1I3xj3yNsIjjZlzkeLUN3IWWHvXC6jVjCOUPdqldh9axkXp\n", + "3hqNR59PnK/0NiSj9pIkSZIkSebM40KRmjd9c47wdD1UkUI5cCUFa9lzx5Tev3sW2taoLT7dyuc9\n", + "/M033ywpti48Ugkro2TdowJg5fbtl9bM3rVE7/mJnkNFwb/D60u7RL5PQL/j4+THY52535BHaKGU\n", + "uV8Q7YNCxTjhd4y39QSKFG1b8j3iOOrEnPGx4ccB52dM0hclXxT3a/Tzomj0jXAk632tj0oJ32UA\n", + "UBzwobrtttuqzlfqF8Yq0Yl81tI3zxCKGipv5D8JzDH6H5hTkdJI/0Z5zxyPiO4b1Tc27oPEvHHf\n", + "Kda+Uj/SDrVvRxyPxqv1Paz1tUtFKkmSJEmSpCe7hCJV+3S+XqjNJ+R5d/h3q7XI0z/+Alwfa4Dv\n", + "a9+/Y7V59uUSKCjRUzxWOe/JycPk2YfdiqvtdxQd2rPVPwVqrX3KiR9IKSIrakf6Bys2UupoV/Iu\n", + "RWA9Ex3p7YfyhNKElcwn/c688wg4V6QAKx3VYxG4hQ4ly5IxQ9vTp7RFNAYjyxaVztuIOchcwBeL\n", + "8kV5d2Cov2e0O0BffEyjRr7gBS+Q1I1p2jPKQQelfhqq3nu7liKsgbW19vpcx89LO0SgnNSued5e\n", + "Ua69tcYjg51SxvuI1uOHwtueEuuj1ZMkSZIkSXZB1rUitXnzZkmdlcP7eCxjFIC1fkodm5KVVoL3\n", + "zig8vEfGOkE5IdtxrV8Bv6+NdMGvI1JUiNBgj0HPagxuxdRmZO+bJ6svtOdQnyoUMKLwSqpDKS8a\n", + "7Ydy5VYrfglY2ShR/N33l6N+qBmRDxTlj/ZBg3nuZ9bXR4Q6o8LVZkJvHXP0DXPW+4bvozk01Aem\n", + "NuN3K/T5CSecIKlbO2hXVOiha93Yaz1rZWmvNtY2FMRafHyU1lKi7mojkN1nrjT35o3P7b5znHZi\n", + "3Mxr3ILvOAC1Cm4qUkmSJEmSJD1Z14oUT/NYukSAeDRStDP1egert2R1lHzEeOonEsQjlIh6I6tr\n", + "tK8QeC6O2uyuWNOenwi4HtZWVB/3K1gv7/0drJeovq3Qj1hjkXVcyrUDlMvbD4WP/vIcS8w78k8R\n", + "aUaW7sjKRC3x/vPxOw8lCrCIfdf42t0NOJ61huPJN+N9MlQBi8ASr/W3rGVeUV30Kf55qM977733\n", + "zKdnxW9l7IzlPudQdKL+4bhaldzLy9yIVFkUu1plycu51qq84/Xp69PGvKOdaqNVWesiRcwjk1lL\n", + "icbkWYN+qvUPXp93qCRJkiRJkl2Ada1I8dTIe0reY+6zzz6S4r3XdhVqrYfaCA4/DmvAc5a0+hm0\n", + "Rr+VnuJdOSvRN1oThQV1YmxrDWtnqJVM+/JZ8qOo9cnCinOrDKsO9YB+4LqUgwgy1BF8qKIcOlzH\n", + "/WCw+uYVdbvcekftxP8LJclzjEXst99+kjpfHzJa05ZjR71FMIc8y/9Q+mZcL8Faffvtt0vqLP9D\n", + "DjlEUqfwXXPNNaNeN6JWgWTssFaW5jJqfa0i5XDPon38eoxPFJLWzPbz3rd2rUENx3cs6p9ohwEf\n", + "5zw70M746dIffnwqUkmSJEmSJHNmXStS+BAde+yxkjqrZ9OmTZLqs+UOzQZcoq8Pz9gWemR9oTj0\n", + "9bdo9WmJlCaUDYiyIpcgWi7a+41xg/VBVNrY1vBYGdA9v9dYe0PS395//J1+QmHC6vOoTqwyFKnI\n", + "zyVSe1rHOdGnWOPuQ+h+DsutVFRIV45qLUuUKCKGWWMii7V2TUEhi/ZHdCLFYiitmcBbYayRLwmL\n", + "f+gecq3UziHat7ada/svgvHCmsT5GJ+MX/yAUVRrfduiexF+itwLmVvME/ptqGpfqwS2wvkitd7v\n", + "OT7eUMW5B3GPOPHEEyXF+6XWzu9UpJIkSZIkSXqyrhUprD9/r88O7FdffXXVebCKeLrn6dz3taqF\n", + "p1sseM/E7bgFDWuV/4r6rfX7c6yugw46SJJ0+OGHS+qiByMroESkRAHWFblHShnHF41ndh+LSAny\n", + "cYe1F6kVHE8OnVaFqdYfB6URK5F+xldrx44dkla3zpmL+OR4pvBod/iTTjpJknTkkUdK6nxZUN9Q\n", + "DNxC9f0TKRtrzMaNGyV1FjAKF8ejDqL2Uf71GqlaCyrid77zHUldBGiJeb89cEoR02ODAhWtxXyP\n", + "/+JYUZbMWZ+70Xzoy9hKFPda7tW15/f29ZyI/gyAb59T+9Zh156tSZIkSZIkC2RdK1JYoHwOBauQ\n", + "9/dY4K2K1MEHHywpVrR8/6bIquDpGsXMd8bmaXionwRWR22G8hK0Y+RzRX08Ooz375TDo7+wyrEW\n", + "+tIa6eKgiKBgok7U9gOqAnvd1UYEoeB5ni3GSeSfgRVPpA/qC34CtWpAidKO94z7vv4wzEeU5tr8\n", + "Zcuh7jfccIOknRUHouDwlaDNaUPyH23fvl2SdOutt86c12GuUmeuR5/R9vgDMgfYjxBlijnBWsLc\n", + "97akvK1r1lpDvZj7UXm9j0tK1FrVn3HCZ19lyPNB4ZNUejvgmb25PhGx+H8yTvh76e3IvBl71wLq\n", + "HSlRtddjPDIfeQZgvkbKnPv1RqQilSRJkiRJ0pPJPLMMhxedTKZLS0trft0kSZIkSZJWlpaWNJ1O\n", + "V0zslopUkiRJkiRJTxbmI7Vly5a5R5GherWqX30jR7jOxz/+cUnSEUccIanzh2BPQCJ3UAM9TxZR\n", + "iUQaHHXUUZK69+J8/8IXvnDmuvOG62zZskVS1068X478CPDzKPU3uXbwkXrta187c9154+MF/w38\n", + "DtxHiXxmHtmFrxftQb3dZ47rXH755TPn5/29Zzl2fwgH/xHKjf8OfgSvfvWrZ647b7w98Tcgoo6o\n", + "PNoNfxLqQT3xLWMc4aPH+MN/4qUvfak++MEPSurakDmEfxdtzLWYgz52KSu+Kvh/Uebzzjtvpm6U\n", + "2ffPxO/LlX8ifvGZoo6MfepKOc844wxJ0kc+8hFJ3ZjAn44x6BGtlJ928DXtwAMPlNTNPcrzspe9\n", + "bKZ+DrtMuN8c5yGjOf6FDzzwwIrnYW6dffbZkqRPfvKTkroM89T/2muvXfH3jAHagesx5slJxnX4\n", + "/vTTT5fUrdX0F+ehv/j3vffeK6nrJ9qT69Bv7h+Ln+Sf/MmfSJLe/e53S+rGvPtNEj3KXMdHDxjX\n", + "RNJGEbH027ve9a4VrwMedVqC431OnnvuuTPXnTdc56Mf/aikbp65LxXjm/nt45A9IPkdfsrR9SJS\n", + "kUqSJEmSJOnJwhSp1faQQqG56aabVvz+tNNOk9Ttw+MZzrFS+oL14tYbVhLRXNHTPNYsShJWDVYG\n", + "VjHWH1FmWEEoGChZlAcrb9F5kSgnESi0Q6SU1CqPtMvY2Zz7Qr9G0XIog05r9miUI37HuKO/jznm\n", + "GEnSd7/7XUk7t/Pzn/98SV0uFPI9cV7Ug1ZardUIVAUUNuanR30yv1B1OJ72oB/4HeddPt+ZK1ig\n", + "rDMeHYYl7Tm1UBM9whTFIVJdUShQplA+XImirFF+GspLn3kUluezQoGKLOlS3h2iFPfff/+Z65eI\n", + "IjgZqygn3/ve91Y9DwoOEPH7rGc9a+bvnCfKLE++MId2RD3mrQBwDwEfD56HDHwcMFY9mpB/o0iV\n", + "3nIwd6P+ZO4zzko52kpraevcHroW9IW57vVhLYjqGSlRwL166L69qUglSZIkSZL0ZGGK1GpP5pES\n", + "BTzlRxmWh2ZX9ZwcWMhu1UZP51g199xzj6ROWUJx4Om4lJuEcmCdYAUuWpHyTNj4RcDQ7MRjZ9td\n", + "73h/oryQ84R+Z7wzLk8++WRJ0qGHHipJ+sY3vjFzHsZha14tfPFQZ+6+++6Z87WCMobVGJ0HpRdQ\n", + "csH3AVvpfCgHWOoc4yqhl8H9yfieTxSAKMqZMUtbu4p52GGHSeqyt7MGoHigUHEe5pjXmTWIseD+\n", + "Za35jrDIGVNDM32TybwWV1epj2firs2O7zB3PHdgLb6LhStxGzZskNQpkr4PJeOmFp8DDsoaKv+i\n", + "84mtVQb6kuIUESlRwHweqrSlIpUkSZIkSdKTdZ3ZPGLr1q2S4gzYY+1PRGQM1kytUsLTsysBWA+t\n", + "5fOIm/XiQ4RV5L4uRNthfROJgz9GMotH+rgqEvlo4R9Tux9ULSiMRNc997nPldTtjdiqOqDoUk/q\n", + "hfrhKg9WOSoR44x/M3/4XK6IMhZbI4JdgXLI0B3B9chg7qBUMCfYfxLliT6kTlzPfYg4Hp8Ovu+r\n", + "wrOWoAz1VX764n1PeehH2iXykSnB8Sh7rYpbaVzsvvvuM9dh30zGw9h7z6EcLlqJWi+wb2tp1wUg\n", + "ipN5ytueyMeONadEKlJJkiRJkiQ92SUVKYjeaw7dqw14P4+ViDJU8gHiOCJGeKpt3TuM6xNh5EpB\n", + "K/hqsVcgUXfuW1OCemAl0g7Um7+T54pcHkSuRJBzpa8VR/2IHPrmN78paTyFcl64VYVfBRFjkU+c\n", + "55hx8H9BUa2FvS3pB3KtYL1t3LhRUucDWAJfK+qFykB9I2ufv6PQuT8Q83x5/fgOn5ax1bq+oPTg\n", + "s4H/V+S/hqLhUXSuzrnK17dcrGm026JgbWEtoXx9FSnGMGOQyNCxuPPOOyV1SpEroX32i5S6uUvk\n", + "LkrXtm3bms7D+Bk6Tlrxe7D7Mx933HGSurWatz/k9XKFiLXQ7w219wrueeQPI9KfPTUjRap2f9pU\n", + "pJIkSZIkSXqyMEXql3/5l8OnSaKRnvOc50jqLPYrr7xSUuer4dYUyshYkQRYF1iPWMRYC55FGFy5\n", + "8gzZrfBeH2UFJakVnrpRGPpGKvA7Pn2H9H/913+V1L3Hp/+IcIkiKbCW+lrF9NOzn/1sSZ018dWv\n", + "frXX+dYK2o1xS3vW+qtE1rorOa3lIVqPSCf6Z/PmzU3nwz8FXy/Gc1Q/+p9xg2rDeGLdoN7LrX7K\n", + "jkXMHB66JpR2ma9VTKg7dYoij/28QN1pI9aYvpGy9ClrWmuU2dhQX9ZKV6igtr74fuGnNzb4zfLW\n", + "wOm7ly3j47rrrutXMLv+WilR4LnjHObnH/zBH0jq1G4f7xA9K0S5Cx1Ua54dUPYi/1MofQ+pSCVJ\n", + "kiRJkvRkYYrUau82eYrFGkFpwDeI99JYtG6VjBUpwVMzvklkwS1ZGZ57hKfsvnsL4iNTyuJaC0/l\n", + "Y+HWOhFKfNJ/pRwuWGG12ZUdFCjaGx81fK/IGrwoIlXD/XiwsmrHC2qCR65gLbs13wrlwS+n1m8A\n", + "UF1QpqgXVjzz9/jjj5fU+TOQR8tz5rjiu9wHjnN5xuqhUHfP6wS1c9IjXEv49QpFo0oAACAASURB\n", + "VFCM6HPf8w0LutU3jDUrUgTWCupBOVDfWUNQLmqVN9qBe0LrGlzaJ5TyscZ4RvLWufKLQimqkLcS\n", + "r3nNayR1a/+8FFEUOfw/a/07a0lFKkmSJEmSpCfrMmqPPcz+8z//U1K3hxj5o1CifCfqsfBd6D1q\n", + "r6R4YaW4soIS0bqHGVYV1uxa53op4VFxWHGUszWbcF+/AiJzsF7JAoz1sWhFCgXFrdQoYzfjrRR1\n", + "GKkcWGG1uVAccuSg7jCuW339sNKj8U75uB7zBiXL1Qfag/pFKtGYUOe1uNZK1wX6gLHEWGFM8T0K\n", + "E8oAigprmqt7pb0E1wrK4TnzUOCiPehKcB6/V5TWYto/+r3/28dJyQfu8QpRiA7jM5r7fcHfszWC\n", + "uZZUpJIkSZIkSXqyLhUplIwovxFWRCl6ri9YGb7vFdZe6T27Kw5YfSglKF6t0VSct68P0VpB/5DF\n", + "ubV/+iqMWIFY21jljJNFQ708x4qPg9b6l1SEvtGZKHyMO3zOWqNGS+VDWUIx9BxCkQpUyjo9Jq2q\n", + "6ligPIHvP+hRiaiTqMKRYoLqyxyhTyPfFr6f9z6YzA3fK9HrXQv1I0+Rv00oraWlTOgoJ/STvy3o\n", + "6xf7eGVsJQrol7F9JyEVqSRJkiRJkp6sS0WqBBZ2bY6HElEOGN/zi316fP8rByuE/bCwsjwbce1T\n", + "N9YO54neL68XsCqwAql3rXLQ1w+F6DLaByVqaOQM0ZeMu74KCNbwWu+T1VfhQ30garWvdV3rd0M/\n", + "oWQyv0uK5lrsPbko3yGPvkNJos70CRa353hz3CKnbzmfKypRtGKrn6fD75fvkyjtnHuPOexZ7ftm\n", + "OPf6DY3wRvlbLz5muzq1e+YNhbxirVG0EalIJUmSJEmS9GSXVKR4X79WEREoEJ7JOwKrhKddIk14\n", + "396qSHhuHHJhkBW2FZQiz9Uydm4N6t2q4PRVPlCkyF+FkjHU6kAVGCsnTKsVjLXbd7z39Wvhd0TS\n", + "ME7uvffepvPURh+iFqDY7rPPPpI6ZThSoNfLfno1uLpXisB1xYexQ1uwNvTtY/zS+PQ8UihS9CFz\n", + "mZx+tH2rDxnX8RxnKF98z1pLLr1WJYr2/fKXvyypa8/DDjus6TwRqNX333//KOd7vLHvvvvO/Ju3\n", + "CX0jt0sQtTfW2yxIRSpJkiRJkqQnu6QiNXbkSG0UHNZMaX8f9rRDQcLC7uvLQfl4r9t3rz3A74Cd\n", + "r+cFUV/uvzEvsIq/973vzVx3rCjHsTLmt4IfRq2y4/TNVo0agerBOG4dNyh5nCeqxy233CKpU+AY\n", + "7yWFci18pMbCfZtaQZmZl5+dt6XnhKPPHnrooUHXYSy4ynvTTTdJ6hQDrjs0dx4q9djQj0Pbw+nr\n", + "C7arMbTdSntgOrV787WSilSSJEmSJElP1oUiNfTpG0t5w4YNksq5P5xapaTWqsF6wscDCxvrjlwu\n", + "vFePovdQjp797GdLko466ihJsc9PqR3JA0RUFPsd8VTfN1rOFQaUDOq52267Seqs6XmzqJw/fUG5\n", + "83LTX+TQwepCjSgpU8yLzZs39yqXR4eWolUj8LHCGiwpez/60Y8kdeOcf/8iMFRNx8eDuc4nawt7\n", + "ltUqOPioRDny+mYSr8Wz7jMHXA3tC2PPox3HgnuN5/saCv2BT9paqeGe+X690zcn49ikIpUkSZIk\n", + "SdKTyby841e96GQyXVpaWvPrJkmSJEmStLK0tKTpdLqiw20qUkmSJEmSJD1ZmI/Uu971rvB9Nbk5\n", + "8BEij4xDxEf0/hjV633ve9/M8ZEPFb5Ihx9+uCTpu9/9rqQumoi/U258OPBLOP/882euO2+4Tuv1\n", + "dt99d0lduUsRRLyHfuc73ylJes973iOp81/gfT7HRe2Lbxb5kPDJ8igtcu286EUvkiRdfPHFksp+\n", + "AuTHcr8OyhXlxOHvb37zmyV17el+I5STf7u/C+XHz8N9mPCjwHfsrLPOkiRddNFFknaOkIrAVyk6\n", + "jnbAzwEfuLPPPnumfvOCecZ8IO8U84j5Qzswr9ihfdu2bZI6fyDWA9oHXyv+/Wd/9meSHmkXr9t+\n", + "++0nqfOhYMx7bjOuxZhmbDI26Dt8SP7iL/5C0s5tWcr4fcopp8xcf+vWrSse5/mmzjnnHEnSlVde\n", + "KanzG/NyeWZoxix+iswh2pC+oty0A2266LWMOcVY9jUAP1T+7pnbfVcI5uaFF14oSXr/+98vqcuH\n", + "xdzyuRrt0cbY9FxmtDffv+IVr1ixfvg/MpZrM3tH/rCsbRdccMHM9aJI2SOOOEJSt5Z5PizGFWuI\n", + "7z8LUf8xriIfNcbboYceKkm67rrrZr5nHvzmb/6mpG7NO/300yU98hyx/Ly0Z6ufNNDvvlcla2dE\n", + "KlJJkiRJkiQ9WZgi9au/+qthZABP91iDUVRTbQSGZ8mN+I//+A9JXdZerBOe4rFmsZK4PtbHrkKk\n", + "mER4rhe35rG+S1F/5NfyfsN6wJrwfqqNWKmNMMKqwUrDqnVccSrlICllUEft8P3F6IfaSKvScd4O\n", + "pYii1qjZ0vHeX3fccYekOP8UCpTDeOEz4oorrpAkveUtb9npOzJ2l6J6or5FEWLMo2wAbUvfRtfZ\n", + "a6+9JHVKz+c///lVyxNFa/mYZOxESgZ9RAQm54sUiqH5mobie/+hZHg70A8oKl//+tdXPB9rF2uT\n", + "zwVXkjxfFmu7K1KcN8rRxpgt3XNQ51F+SqCSczy7NxDhG+0iEa31vO2J+p23F3fddVdV+QAlDkWK\n", + "cvmawbyLdm2gvtwb2L8W6E/6l3t2390guA7zozbvVCpSSZIkSZIkPVmYIlVj/WJlkT8JJcgVotJT\n", + "I1ZNbYbrz372s5Kkk046aebvPFVjNZFXaqzM2WtFa26WkpVKu2ClRX1b6nMUnbFypmANQWSdlPJO\n", + "uepQC+MC6wwrh/fva0Wp3K25dVqPn3der9WszqH5ZbyurjpiMZfaGEv6G9/4hiTp29/+9qrHR3MA\n", + "nx3aFLUeVRe/UsYc5UJ5QOV3v0jqgc/KWPiaUFLBPft91LfM7VJuP87XuqZQTlePgfOVfHFK9yb3\n", + "3astl+9RWOtb5fiec54pvFWJYm3ztzrkLIzuJfhPOiiBnM/vtZ51gHHdd94zTiln7ZqfilSSJEmS\n", + "JElPFqZItby75GkV64Dor1rPfKyi1n12iCDAWuMpF2uQOrS+hwWUtjvvvFPS8Cy+a0Wk0LiV1Art\n", + "2LqXHNBP+KOgAqCYuZWCf4P7STgcV5v1F2sZ9YD39YvKvtuqmDLPPv7xj0vq5sE999wjSbrqqqtW\n", + "/T31hnnvF4a1uha4RV1bN+bKl770pVWPYwxHGdBdIWEN5PwoDCgUPuYov1vyXK8283rtvo8oN8yJ\n", + "WkUKmDv+d+pdugf0zZOIksKc77vPZWk3gFIErsNaVvLH7Av91PetAO0z9n649LP7S3o5uTf3zTTP\n", + "Pah1D79UpJIkSZIkSXqyLvbaqwVri6dE3seWlBzem/a1Tni6Zs8yrCT8EPru5I7SRmRIKTppvYDV\n", + "QrtHigv14jisqVJ/eWRULeQieclLXiKpi1S68cYbJUk33HDDzPGoCZEi5f4vpahErBgiaDivW7Nr\n", + "HRnVOu6ZZzfffLMk6cADD5Qk/emf/qkk6frrr5cUtwe5m8D3UxubIbszUNaNGzdK6nxCfJ/BiJKa\n", + "CSgb+CB5bjz+7lFXPhfcJ8jnUkkdH2snC8YyPlklH5++anVftR/6qsDMZRQP+qfWlwncT9MjXksK\n", + "F/e46B7TVymLIAdd3/0t3eeLe1pUftqHdonuDYwDXzuZV1yPt09RXrUSlId7O/eAEqlIJUmSJEmS\n", + "9GSXUqQAK+Hoo4+WtHN2YM971FcxcrAijznmGEk7Wxt92VWUKMB6wF8DK8StBXyVNm3aJKlTOr72\n", + "ta+tev6+7bpjxw5J0kEHHSSps9ai/EUlsEI9q7LXE9XgyCOPlNRZm5SH9mJcjmU9zpv3vve9M/+m\n", + "H0uKIvWGvv4KtUS5c2pgrJx66qmSOt+TWkXK+zTyLWEMRf51tf6b0VqG6oeSUlJPh8J1yDgdKTX4\n", + "gRJ9tausdbyFoF6tShS4okaeotpdJVBKWcvwpx1b1WZuH3vssZI6RQpFpzV6j/kQRYcSgY9CGmWO\n", + "B+41Pq4Zf6wxnI952errxO9QWqM8YU4qUkmSJEmSJD3ZJRWp0ntvtwo9b09fhYqnYZ7SS3v9/aKC\n", + "tVaKWELBw4+ktt37WtNYf//8z//c6/cOETVebrcG8SE67LDDZspBpAnHM14if5GSP8SiabVKwbMR\n", + "j02fPG777ruvJOmQQw6R1FngvtdYCSxvFKFoLajtW8/IXOsjxBjDQi/l04n2iOP3JbDwqT+KBpnk\n", + "8RPEsmdOD1WkIp+gvrneIjh/a6R3dB5ojWZD1SfDuKu9Y0G7PvTQQ5K68YRy1EoUjYjv0oYNGyR1\n", + "PlnMO/djBdZO8qb5dVC6uCex9vJ9pFpTHt6W0N+MWxTEEqlIJUmSJEmS9GRhitSTnvSk3tYDVlZt\n", + "Lg2sQayooRY/VhfnXetM1YumNndOX/+Ceft3lPD36nxG78uxdvDtYu8+rDvyLzFu3WeI8YMa8OMf\n", + "/3iEWnQMze81lHn3Zx//FSJK2auM/QBLOcIcFKiSKo1ljEUd7QvZmnPLo8CwrEuqfaR0uX9pCaII\n", + "UQRcSUORoP6tPitO5F8YtX9rniaHewWKY6s/nueRai0H95qrr75a0vi56Ohv/EG5Hv2HctsK9WRN\n", + "pNwokiii5IBj7YuUUp4V3H+W8/p44jjqxbxjfqMMUr97771XUte/qOieEy8iFakkSZIkSZKeLEyR\n", + "qvWGX43a99dY/L7zObRGUfF7nroXlbH6F5VF+whhpUU5YJy7775bknTwwQdLkvbee29J3fhgvETj\n", + "BIVqXuNo0VGC8+7PPoobGZApW6tvVCsoGvgSRYpUSfFA4fD8RqyFtYoHvje0AxZ6676IjK0onxZv\n", + "DfA1GSuPVVSO2r/XgprK3Gz1i+17fZQ7+tWvx+4eRLvRrqVM6g7nxUeQT67fV5HCR472QjVmnDEf\n", + "UKBYW/GduvXWW2fOhzLkb7FYo+kn5o/vr4tiyvG+xvu8Q5Gr9e9MRSpJkiRJkqQnC1OkxvCbqPWN\n", + "4OnTrSa35mrhaZsIG3xhknEgQmVs8F3iPX3ko+eZ27GqPWLEIUoR64dPsmdzHs+2y7iszZK9qzHv\n", + "qFbff64GFKhStJ3TN0s7Y65v1n6/Pha3KyUlHyvPk+MZrMfeF5Hyosy4z0xfaqP0uF5fVRSFD+WE\n", + "dq8dL333nOM6kc8eqjc+ftDq4waeNw2Vt3U8oDyyVtLurIWMA/7NdTietR+/UpQi7tFeP/rhwQcf\n", + "nPm3q/zUg3s+a63vFAAcX8pvBalIJUmSJEmS9GRhitRkMim+Lx/LeuGpl6dlnkb9vXKtf4H7Rs17\n", + "d/vHG+T2aAVfOPqTCKaTTjpJUmdVlrJWo5b63o4lxQhfKSJReL/Oe3rGS20kSFIHOWNWAwsYhQDL\n", + "ttWCd18K+tJ9MyIiXyzGPApO5EOFAsOn+4fh++S5zABflKjNWtXDUn4sxjxzjzU4iriu9UGqjfhm\n", + "Lej7BsT3xxzDt3c5+FWydjgeXUn7EF3nDFW1UYSive1KcC9k7cPnzucN+bBYG8nnxvzx41FOGUfA\n", + "WykfL9H48LdPQ/dyhFSkkiRJkiRJerLQPFKlp12syNbcLm41RD5MNZbsSvh76ccbUa6Psajdcdvx\n", + "nC/kJqGcN998c9V5qB/7XN1+++2SOmsNq8Z99J7+9KdL6jKcYyVhRfK7IXvD1eC5hfCHWRTHHXec\n", + "JOn73/9+r9+jYkTztcZHyn1VGCt91U+/dl/Fg7F+wgknSIqVCWAMcj0sapQTPqO2Ys3Fn89p3Rex\n", + "5HtEu6NclXyGeAvRqowxxzyvUGsUYsRYGdMdf5vB2kW0nO8mcN5550mSvvnNb0pqzzlHJvFI8WQ8\n", + "0l+tPn2t/p7ud1oaT37eqB61jBXRnIpUkiRJkiRJTxamSNVYHFh7WBf4rJSYt88SUVgoEn0zR0eW\n", + "Nk/pY1lTEbyfxgrCmitZBUQ+0M70jys2nB8/EvcnQdkjy7Tn+IBof60IrCisXyIzaiNoPKKD8mL9\n", + "RO/V8ftgvyjGB+2K9TivXDqAEsd88XxYEd7OnGfoXnmHH364JOm2226TtPP4IifOaaedJqlT0PAn\n", + "Itpy+/btkqQbb7xRUqeeoBxKO+9n6EoFigxj3lVvj8pjjEf+mvjDeV4qh/PyPaohaxxRfSWfDc5D\n", + "3zJWmZP0Xeu+jShznGdsaN/SHK5Va4844ghJ3RrKW4fWCGrWctqTccPYwufM1y6UHfwtb7nlFkk7\n", + "16+064VHjTEuiAxHmeK8jLe+mdpLCg5KJ+Om73VKsOZTX8a9/31X8T9ORSpJkiRJkqQnk3lbxyte\n", + "dDKZLi0trfl1kyRJkiRJWllaWtJ0Op2s9F0qUkmSJEmSJD1ZmI/Uli1bHnsP2+oD4+C/gE8O/leo\n", + "Xp/73Ock7bwvEf4F+CngWxNFQuBv4bks8Am68MILZ64LnoW3FDkB3i68N+aTCI6LLrpIUucrQuQP\n", + "/gMcjw/PgQceKKnzD8CnB/8PfFLwB+B3b3vb2yRJl112maTOXwP/DjjmmGMkSXfccYeknf00at9/\n", + "0458jpVXrHS9T3ziE5I6XzXan3GBv4fvYE5/Uj/8TfD5wUcLf4BXvepVkqT3v//9M9/TrpFPF9eL\n", + "xinX8yy/Z5xxxkw95w3X+ehHPyqpGwfRTgLMQ3ztiCxj3jA/n/a0p818jx/Keeedp0svvVRSN1dp\n", + "Qx+DtDHnYozTp/jEkIUe3xHm5AUXXCBJj12P83M+j+wlKo+xQ9nxQWFs4y/m2fdpy3/5l3+ZOb/7\n", + "fjFm8bHBd8uz6eP7g28Qn/hKvelNb5IkXXLJJTPnb4V60W74pDE2mQvUb8uWLTP14Hs+yejNHKPd\n", + "aS9fUziPRyP+5V/+5cx1542vZev9ep53LYI8Xeecc44k6Yorrpj5nUezMh6Y661+wMzr888/X1J3\n", + "72Nt4J5HuciQ7nC8PzMw/5k/+GWW2jEVqSRJkiRJkp4sTJFabiEO3Q8JqwxFxhUSoo6wBrFmfD+j\n", + "Ur4qnlpbn6JdkSplxyXvDlFLWPBYWx4JgkLxzGc+U1JnPWJVYM1hJfA90YJYo7QfmcCJOiOPErgV\n", + "62zbtm3V+kVKFEpYlHl8XkqUg1LpEVY+PjjOc70wnhknKFVYU57ZHKsN5atkBUZZocHzWzE+Wjng\n", + "gAMkxdm4a/H5GFEaV4xjb7/l6wYqKsdGUVMcR5/yb8YYyhDn8T7yMkGUY44+pS1c4eG6paz7RKVF\n", + "eY0Yc6U1KsqM7WN8aNSWz9nSGs/3kVrPWkg0G/3mewhSD45fhC/weqA1ehNqI5w9hxvXidZ4FCDu\n", + "NVu3bp35nrkd5WXzaH/mI2sG46A0j6LoWMZ7a6RyKlJJkiRJkiQ9WZgitZy+SpTjViagzGDF8RTr\n", + "T728F3V/gqG4NYRvC+/78aXZtGnTzPUjXxJ/2ucpnf2IsDaxRryefO9WKdfl6Z4dtYdmj631gWvN\n", + "0jsv6A+sGxQmFKhSFmu3wrHCqL+Pd85fmzOlNcsy12+FcYtC6vPIrcl5g++U58Vi3ko7t6H3Bb5R\n", + "rBWufjGXPK/QUPAXHEppDo3tR0h70a7+OZTWfSdREvBdYWwzVvHxGjsTOWOfz7HvESWoV2tOxbEy\n", + "d0d4O/j+pA7zy99y4DfMPfA73/nOmMXcidJuCa2sukpMJpO9J5PJNZPJZPtkMrljMpmc+ejff2My\n", + "mVw1mUzumUwm35pMJv/Xst+cO5lM7p1MJndNJpNTRyllkiRJkiTJOqSkSP1c0pum0+ktk8nkVyXd\n", + "NJlMrpL0F5Kumk6n751MJm+XdI6kcyaTyWZJfypps6Q9Jf37ZDLZOJ1OBz0WY2X9/u//viTpK1/5\n", + "yorHocg4/r6U9+i+0/S8rIxo3yHKi4KGUuE+N44rGjzlo6SQkRpFqjbbL1Ym5yeywfdDaqVWkeL6\n", + "+D8sChQO+g0fKaxz6oFiVdpXiu+xKr0d5rWPF/Tdsf6BBx6Y+TzyyCMlxZEwEbVRqhFEwpEhHTUC\n", + "lvtBeUQocwK/MY+Oow99juAjwXlc+VgUzG3a0scSCg/lPfjggyV1CkDrPo+0F36ezAEioPvCmBiq\n", + "+Hl/1PrjtfLyl79ckvTKV75SkvSP//iPkqRPfvKTc7me07rfLKyVXynUzhP3wcLvs1Xl5nqltZhx\n", + "xj2tpESxbtQqf6uO4ul0+t/T6fSWR////5N0px55QHqRpH949LB/kPT/PPr/fyjps9Pp9OfT6fQH\n", + "ku6TdHxVSZIkSZIkSXYxqn2kJpPJfpKOlvQ9SbtNp1Me/X8qabdH/38PScsfKR/WIw9eg/irv/or\n", + "SdJLXvISSdK3vvUtSe3WFfA0WvId4SmX41wJqo2IKOVNKkUrOW7FYW2zbxPKGu+Ba0EZ4ame+nu5\n", + "qTdP7SUrsNUqipSLeeeRAiI3+KT/PWdPa0QTOUpq974bC9+7sC+33nrrqt8zzvEjgVY/GAf1gvHt\n", + "8201pcujfBjbKCzs2cbY51yRZVvaO23ecP1I3fU1hBxxfWGMk5eHdnMlgD5njpRUWo+gdrge/TKW\n", + "Eogq3ArRaccee6ykbiz+wz88oifU7B27nmGO+luaVhifrWsj44Z+r4Xysia4Lxn94tF9JSL/5Igq\n", + "XfXR13pflHTWdDqdmSHTR0q82ih/fMadJkmSJEmyy3PNNdes+n3RNJ5MJr+sRx6i/mk6nX750T//\n", + "dDKZ/PZ0Ov3vyWSyuySci34sae9lP9/r0b+tiluw/v4UnyaUF3xY3K8BK8mtHFeOaiNOeJrl92QD\n", + "JkcL71s9b4/TN2qq9Xzu11Eql0P7YC1ifUZKnGcr9n7Diqu1ArwcTq0SVeuTRRSY59yh/lwP62ao\n", + "LxNKlI93xivlHdsPp6+PVAnvd8ofKZh9wSeKdsFPB5aPC792NPbwybjxxhsl1c+VsSKM+8IaRGb0\n", + "ecMa4EqFKwGsla1jN/KRoo+H5rEai8985jOSpNtuu02S9N3vflfSeEoUyl7pfLUZx1s5+eSTJXW5\n", + "4/7t3/5NUqe8lcoDjJe+/XbYYYdJ6uZla3Qoa3SpHfH7rc0zdsopp+jaa68Nvy9F7U0kXSlpx3Q6\n", + "/btlX31V0v9+9P//t6QvL/v7yyaTyf+aTCb7SzpI0jBtOUmSJEmSZJ1SUqSeKekVkm6bTCY3P/q3\n", + "cyVdIunzk8nk1ZJ+IOmlkjSdTndMJpPPS9oh6f9I+utphYnC03XkS8FeeVim+Oa4IoUV48oFT599\n", + "o4Y4nysxKEO+j1P0+1pQLrDwXVmJntJRgIbuXYhCw/lc0fD9ryJoHyKkoqzPTl9FBl8az9weEWWr\n", + "pr70K/UsWVmewd6h39xHir+Xft+XoRFWDn4IPg7pN7eWh6o4Ph76+m+sREmJWiu/vFp8n8954z4r\n", + "qPDuF9k6Z5lL0Vhv9VGppe/cor5XXXXVmMV5jFpli6jNsRQplDDWPHIHltZq7g1+z+4bXQisVX3z\n", + "lJXmKc8OlLt1l5KIVR+kptPpdYpVq+cGv9kiacvAciVJkiRJkqx71kVmc4gyRpNXabfdHgkOjHwu\n", + "ot/7e1wUG6yokjWFYoGixXWwjMfK8gs8Vdf6tqBk4EuGFVnKwB3hiklfHy/fw3BeigvQDyhThx56\n", + "qKROdfD8XJH15BFHKJ0lpa9UL6zwyPqcV7uUxkHrflxEg9bmJ2v11QPGcYu/RW1das+NBcvYGsuC\n", + "7Uut8kPurdK+jCWYC6wB7Ic5lNq1d2wW7eM2lLHVZfqVcU3Ed+mehu/h2App7ZoS4YoUazYKFOvD\n", + "mKq2lHvtJUmSJEmS9GZdKVIlUAawEiM8EiTaMRpKO06Dfz+2EuXUnh8fMD5RsminVn8DrFkihMbK\n", + "FlxSXLCOUB6dKLKF/mZ8sIchESDsKVjKGA++tx4+QZ7ttjViB2tpXv4fESVlE1WgVs2p9XWDvtmr\n", + "I7UIP5GVdmivVXFr1T/m4Fh77g2lttz49XmmaVRrFIiSIsT18I1ibm7YsEFSl/W+FfcDTeroq1rT\n", + "f+7XylxnTePtDdF7KFSRstkakb3WML5Yq1kfhvpyOetjdUiSJEmSJNkF2aUUKZ6KS+9lW/cyQ+mo\n", + "zeWx3sBaxu8D6wNrlPqUouyA/EpYndddd914hV0FrOPIpwbFBJWA+mJF8T31xafN91oswfmw2nmf\n", + "jkKCNc04rPWb8X3Q1goibCJor9oM6K3zYyy/FKI/jzvuOEldLp/lypT7PpT2/ipF5dG3a91nEbX+\n", + "Zp4pmn97HqhaWDvw0Rm6RtKXtWvSWJQirH/RQE1n7Ynam3xRGzdunPl7pPCW3h6sFbUqOvcM3jKM\n", + "nZ8sFakkSZIkSZKe7FKKFHmkWq2KUs6Nsd+XOvNWujg//g9ch/fXrYoA5yOnSN/8W32J2gkfJY9q\n", + "pP9QJkrZeEugUuCLQ5Qa6gTjD+WPdi7lMMEaOvDAAweVr5Vav6F5jU9XhPvmOXv6058uqRufNeoM\n", + "qur9998/83f6uFaZqT2uT6RhC6yBJfAXdJWxNeoQ5Yg5xhimD1sjcVFH2Z1i6D6MrezqUXuteNQp\n", + "48LVe/x/ydzuUW4RQ6NCh1Lbn7V7QDq1vpGpSCVJkiRJkvRkl1KkeL/fmgNird/DO1iFWLVERNx9\n", + "9929zocSAjxl//jHj2xrONRKYB8vzuPKAU/pfLoS4zln8KugHSg/0WscX7JqsZ44bmjepWgvQKw3\n", + "rGZ8plCmsOrcF62UA4XrDN17rpVa5SfKDI+iFUWR4lOHguftwDghmvJHP/pRddmlzheNdrv99tsl\n", + "1dUr2pOOOg1VjtwHa957w9VG8qIw0HZ9fbxQefGFoY8ZG61zkOOJpGVOrRXzjrTuS8mXLwIfKNrR\n", + "I2rpNyKWS/dQ5gVr40qRscvLWdo9IgJfLM4/ViSz+82W/G0jRQtFjkj4jJb9hAAAIABJREFUEqlI\n", + "JUmSJEmS9GSXUqQct7J4Km99uh26N10JrEMUDKxEFA9yddTiebTwe4jyPfn7bsqDnwj/xgrBiudp\n", + "3n3SsEawTrHyyD9FOYiW853i+eR3tDuKSOSrw3k2bdo0U65aJY76oZRRfhQOIDdOZB3Sbx6953m3\n", + "onq4InPwwQfP/I5+wreP9sL6ZNxzfRQ/rKcjjjhCUufbVvIj4Dy0p5e7ZMVzfvrBowSxPvfff/+Z\n", + "40v5ychM73tromashPsjRmWnD7FgKTuWeu1awNwq+WG6ZTvvDOnUO1IMave/pB1dwUBVp0+3bdsm\n", + "qVvLornDGs2n7zpRS18FZ9F4pm1X+pizkZIKrDXMXeacvx1gXDOeUZxoPz/e1x5+x9rDWsW48ntt\n", + "lK/Kueeee1b9vhbKy5rO9bl3uSLF2wTWbBRS+oP6subUvs1KRSpJkiRJkqQnk0U80U8mk+nS0tKa\n", + "XzdJkiRJkqSVpaUlTafTFZ0NU5FKkiRJkiTpycJ8pC677LJwnx7e/+K/0DcvEKoXn7w/xX+A9/77\n", + "7befpM5fIPIp4f0274vxKcEv4IILLpi53rzx+kXU7iU41vXGgutcfPHFkjq/DN6Lk/PEfXuOOeYY\n", + "SZ3PFOOMdsCXC/8BfvfGN75x5nqotXvuuaekLjoS/wHer3t2X/f94fe8d2d8vfzlL5ck/d3f/Z2k\n", + "nX2siGgp+YPwPXnEqC/+AJSb8fnBD35Q0s7+DfiocR38eNxnyv0g8LvAX4N/n3322ZKkj3zkI5Ji\n", + "X0Daj/L0zXt2/vnn6/LLL5fU1Rmfh5KfVykyEZj7b3rTmyTtPBeGzjXWGPqCerzlLW+ZuR59Tdsx\n", + "VqIoK3xCPI8OYw6fJXx0Xv/6189cD5hr9FHtGw3GIlGN1JOx+453vEOS9OEPf3imXu7D5jnt9t13\n", + "X0lde+CrRX8++9nPltStGZznj//4j1esHz5bzFnuCUMjv7nOli1bJHXt4fciIltpZ/wpaS98gdxv\n", + "0H3i3v72t0vq5h7lZ1y6fy7XpT/dD5Hr0S533HGHpM7378wzz5ypZyu0e8nXkHZgLbvoooskdT5m\n", + "tGt0L8e/Ft8pX2O5N7jPGvULy7Xqt0mSJEmSJEnIwhSp1Sw2vosiZ7BCSnl7HJ5OPdtvbXSTW7dE\n", + "Sqx15u9WvK3ZqwxrpxQ91ZfWrMcRRJZgjXgeLc6PIoKC6RFLKCwoH1iBnr3WowlpvyjSqtR+WMGR\n", + "wkM5sb5dVeDvUe4XrEjqgfVNu/k88nZhHDMvSnmesG6x4mgvPr1/SlGpZM3um3V6eXtSttYs7bX5\n", + "hUoW89DM2fSF7w3mMBbo4yhSGQUt2r0B5YG5WsrR13cu+3mj9maser6jqPzcA/xewPlRHlgbSlFm\n", + "HIdiQ33HykXIHEWZ8zlUitbbsWOHpE4hKkWoR3PP/86cp/4O1/HvfTzUKktO7fG+lqGk0p4eIe5Q\n", + "T78ev2Pt5Tq15UpFKkmSJEmSpCcLU6RW25cMy533+g7+A30VKX9abc1GjA/KUJ+jI488UlJnZcxr\n", + "rzOnNo8PuMJQC/4ibrXU7tgNWHEoKZFSibVU2k8JK5Bx5L56fv7WTPoR+H2Q98mJlE3Ke+yxx0ra\n", + "eQdz2pnsxb4PmuO5j5iLrXtOun8M1iEKGuC3ELXj0GzgyxXFee+lFlnsUNpvsURtpmjmFGuQX5e1\n", + "84QTTpDU5UaL/E2ZA5EF7tn4h7ZzNCYYO9SPsVGrmDnuE+RjEx8fFCfmForNajnL+kB9KAeKIfWt\n", + "9TmrzZWIQoQPGep4lEcqGr+o1ZwP5cbbkzWO8TZvGLeUw1V5H6e1ChPjpvaenIpUkiRJkiRJT9Z1\n", + "ZnPfYwurpJQVtbTbfWtW3CgDOR7+fX2kyAp89NFHS5I+/elP9zpPK0S71dJ3bzi3mk455RRJXf9h\n", + "HZWgP4nCcwUDKwTfL46/9tprVzwfv/eImYih/hEoeqgZkZWDVeX188z4Rx11lKQuMuUb3/jGzPHu\n", + "Z4L1D8wrrLOhyirQnj4fKEdUPyeKMItgHvahdVeDvnvDsYZ49FSJSFWkrSMfGPY/ZC6UfJtQIqK1\n", + "E8s+2rOPaC7U1lJ7Rn5/vI2IxgjtQYZt2mH79u0rHo8C58oFcB3qzRxjXHB8q89PBFFjrKl8MkdR\n", + "eqLrRfcudg/weyP1o19or9Y1nePdt83XxigSH2oz6tfCuKUcQ9fqkj9qRCpSSZIkSZIkPVmXihRW\n", + "wYYNGyR11gI+UaWnWd/ry2nN5h5ZfUMteRSbAw88cNB55s1Y+4KRm+POO+9s+h39iZXgfiRYv+TE\n", + "YY82rFFXvrBisG5L+31xfay7Vv8QL3dkrZf8a1DYbrjhhpnzRqCAufXpv0PRKe1VWKKkINHOJUWq\n", + "dV617lW5nNb9NUs+UhF9y1i7z6HD2CcKrDRm6ZPSbvfR2lka207k4+P7grrCgbJWq6rj24Mi6PcG\n", + "7xcUR9qBcvZVpDxCnPOg2rqiEkG5Ih+66K1I5FuGslUbWR3lR/PfRedh7p966qmSpFtuuWXmsxZX\n", + "FMfG16ZIgXVSkUqSJEmSJOnJwhSpX//1Xw+jhLBqeFrnKRzrquRr4dZOa5RYLaX3wSVQGFqjD3c1\n", + "sGZ++MMfSmq3KrCCSkrF17/+dUmdP0DJByuyMrEi8WXyHdNbQVUo/b424qv2/T3nc6XIrd9aX6Ra\n", + "H6eIWiW4NqfTIhgalTfv67nPV+2ax5giiqyVsXyIUDR4KzF0jfU57AqR49Ff5Czsm2vPc9SVcrRF\n", + "lKI5o3Zi/Pjcc+WItQn/RD8fvlslH8FobeAeTHuiULUqUn3X4FZQniMfRScVqSRJkiRJkp4sTJFa\n", + "zTrFiuLp1q0BnhJrLeO1ys/Ul1I22xKtUYhjUbou1g25RbBy8D+g/0pRj7U+Mxy3devWquMjXJFC\n", + "IaE+fbM70061Vs5YuN8KVjL1qq3P0HxPtTmSYFHjejXWs1omtft8OX19wMYCZQvFwucic5C5Tn+U\n", + "fH0efPBBSV2kdAS/x18Q/8G+amzftYIoSJQ5yh8pjCg+rrjVKprMsZICSHQhc9kVt+hey1sifPfG\n", + "ypA/L1pzJ6YilSRJkiRJ0pOFmR+rPZHyFM37ZJ5+eX/faqHytN73KbiUmXnekQQl5m2xu9XRel2O\n", + "Q4kio3irQlECa3zo3n7+Ht5zzfDZqk5gNS96vMxboY1yEbX6N0T+GoukVh2dl19mCd8rrjVfz6LH\n", + "JtDOjCVXh93vsJQ7kDHk+1g6vjdflLuuL7VrB3nA8CliDY1yKDLOfDeQoQql42+HWpWbe++9V1Ln\n", + "azVv1bnvPOT40riCVKSSJEmSJEl6si4VKcA6AJ62eVrkHLU5MErHkWPELeAoFwfn7QtP4+RXGpIP\n", + "Zx7wNN7Xp4dosM2bN0uSDjjgAEld/w3NWzQvXIH0DOh9rTz8F9bKz4bxPFShayVSMFvrvZ6UKIjq\n", + "5gxVolz9rAU1HwWllH/Iqd1tYN54PcAVwdrM7VBSY5nb0b1gKLVrgO+hiEJFxG2kNPo9E8ZSSH3t\n", + "6+szhvJJ7r++0Ywl+taX9i/lGIRUpJIkSZIkSXqyLjObOzy9+o7ZtbvV1+6UHVkfvKd2q46n8b4K\n", + "Be+FsX5QpFr3/5oXWE1DM7hjRVEf2nm9KA6uMnjWX6waPlvf5z/lKU+R1PVz1J5cD6s1ynaM/0Yp\n", + "IgdF0Mvr1mmUtbgv+Of8IuI5t8ZuO2DuRap3ybeE6LfSLg/OWkVFYel7/inGvud9oj18TWQu1Coj\n", + "pbmLgofvD9evvYeUqC0n48wzzh900EGS6n3fGD+o7JFiVYLxxl55KJetig/1QhmsVXhL+HgZ6tPG\n", + "GpmZzZMkSZIkSebMLqFI8XTJnm+t78VrYWdurBEUsBNPPFGSdOutt84cP5ZihDVLNBtKQ60PkStY\n", + "KCBDrSiexodG8jzwwAMz5xvLChkL70esN6wbrBMUw1r14alPfaqkTmmi/lGWZMZzaVy15oZx/PzU\n", + "x3PQRP4kqBye7w3mrTTWlnMtGFuJcqKs8yVlBb9L1hT6ZOia6XmdgDWCtbmU6TzqMxQUFKgoMze0\n", + "Kg++pjI3+aTdSnvf9cWj9lgjXClC+TnkkEMkdf3G8bX7bXIvoB3pJ+5x1DNqR9Ys8m+hNqNItSqe\n", + "Dz/8sKSun4fu6sF4ZE1DUSQ6k3amX+ln2iPKYehvIUqsrztakiRJkiTJLsQuoUhB7Q7jZKNt5cAD\n", + "D5TUWXFkl523zwfvu/vmJ/L3uGO9z8cKHOo3we/vuOOOwWVaC1CkPLsxPnklFQK/Daw+fsdnaW+7\n", + "eSsskaKFdRfVD+sTH8Uo0sateSKOaE/qx7zyaNVSFmky5WOll3IDjQERwygFrfA75jptTSTrXXfd\n", + "NbSIM9CmrGVY5CgCfYkUqQ0bNkjq+o63B9GuDZGlX+v3OhbMBcaS7/1WG7VVC+o2a2Lks4SKv3Hj\n", + "RkndnCTDee2aHPnS0X8oVnyPQsO9iPoz/l3BaY3opt8ZH61QXvBxGClMPDuwdoytJKcilSRJkiRJ\n", + "0pOFKVJPecpTHrPYfUdo37Wep0x8a/w9L0/Tvj9TK/hAYUVx/rGtkoi++YV4f+3ZeyO/ApQFlBcU\n", + "LLcS+b7kh0A7odxw/ZKfhGf6xmr233mUZmQVl8DKQgnhOu7TgxXnPl20B+eh3rzvpx4oUrQn1k9r\n", + "hEspo36JaCeAKKdMyUqr9bPB6oOf/OQnKx4XWeO+87pfr0VVoe/22WcfSV2da6Oe6Gv6uK/azRxl\n", + "7qHa4dNRS20+INYS6jmWyuljhD464ogjZr4/+OCDJXXtj8JSC/XkE1p9l7i3MBeiNY4x536K5Dni\n", + "uLvvvltS/zlZ+zvW0P/6r/+a+V2rkoMKjKLEWs4na8Pee+8tqVvTuB5KDvdk34vR12oUUNZCvqc9\n", + "KUdt5DPji9+3ZlIHxn9p7aB8PHtk1F6SJEmSJMmcmSxiZ/XJZDJdWlpa8+smSZIkSZK0srS0pOl0\n", + "uqJElYpUkiRJkiRJTxbmIzVPRYr3queee64k6ZJLLpHU+Tr1ze6KnwTvl/HV4b06deITXxHet/J+\n", + "mffPJb8F94fAXwO/ije84Q0z1wOipCLflFqIYuT9+Kte9SpJ0rvf/W5JO++b5Du0Q5SpnffP9Av+\n", + "D7wHf+tb3yqpfax4HqiovWlfjnvb2942c73aKMra/czIToxP2oUXXiipG5/ui8Y4xq8GfwNUZOpD\n", + "/1Bejwyi/S+44AJJ0qWXXiqp6zf8KPgd9fV6Ux6uX/LToR0/+MEPSupy4NDPtEPkcxW1P/3LJ/nf\n", + "Tj31VF188cWSumg4Im/Ju+MRk5TJ8xZ5NBJtSJu/8Y1vlCRt2bJFUjeWvS6er8ep9XnyteWoo46a\n", + "KSfRZn59/AEpB9F81Nd3i6B+p59+uiTpC1/4gqTOT5UxWvJ/BM7P2omfI9fHp+Z1r3udJOmjH/2o\n", + "pJ1zreHDQ395dB1jAR821njaFd8X+unMM8+UtPPaQj9zXGnuR358/j33oosuukhSfQ7CUgZ4v6fQ\n", + "33/9138tqVuriXZzv1TWLG9v/FWjiFj6AZ8t1rIrrrhi5u8cR30ZP76PqeNzn/6lX84++2xJ0t/8\n", + "zd/M1DvK0eflbn0GKN2DUpFKkiRJkiTpyS6VR6oWtw54im19Cj3uuOMkdZEvWO48XfO0HO3QjnUT\n", + "RUOh+Nx3330rfu9RcFiLHrnh0WRYX0MVKaxzV1q8fUtRfZH1hbLhvx+aVRhrp5QpPMpei/VeG63Y\n", + "Wl73S4yu43mSsBJRVTwfFOPRI4M8+zDl9eNKqkjfrNhE+7XmN4usVcrNJ7l1pE4FRukgysqVKOYe\n", + "UDbfs4trEHX3wx/+cOZ39CVzztuINYByucXcGsmJcnT44YdL6sbA7bffvuLxKEGe88tzeaHgefnI\n", + "YF1SWyNoj2iM+1yIcpyhpEVjiH6KcpvVjr1apYi8WZQrmhvMWWBNRxmKyguR8kf/ucruOdlcgeJe\n", + "RDtHUWml6EDGtUfxuZJEu7dGjfrcj6IdGT+l3HzQ+gwQ7XXppCKVJEmSJEnSk4UpUk984hOr9wxz\n", + "Iusueq8bPc2W9qS7+eabJcWWcan8UZZViJQowCrwp3m34lx5qc2RU4KcG+4vwlM61nSpHUp+IGR9\n", + "pr1arfSIvnsh1ipMrUpUZOVhpUZ7K+Lzdthhh0nqrMGtW7dKirNBY21iPTuMo74Z9SPcSsXPo7QH\n", + "H+VFbUFpaskEjwV/3XXXSYrHJmOba7r/F5YrChBj3vu8lLsOZYw+5PyuHNTiPjwQ1TPKLA7sdcZc\n", + "8T6qtfQjSlHhnheIdqb9UVJoX46nHVr3dYzeHtRCeVB5S/mxfE7RT6Vch5FfqUN7RW89uL6/zeD8\n", + "0VpbWgv4nd+bGO+Um3LNe7eGee15WXveVKSSJEmSJEl6sjBF6pd+6Zd6K1KRBd6651bJB2aohd43\n", + "RxfWZu3O5vhneHbeodA/WOWA9V7K0ks0G9ZPpMhgnWEttu7fBCWfs4ihViqgcGLF1PZDSZHC163k\n", + "80ZUIO2H71xktdOvjLfI927oXotYpyXli/mCvw7WNspbxPLs4CgGjF36gjJEfnlY2L6vImMXBcst\n", + "+JLvEG2KKjvU/w+oB+fvq74CfexrlmeoHhsfW96enokbX7VjjjlGkrR9+3ZJZeWNMe4+L6yZtJ+3\n", + "oytDlMOjBh0/L9C++J5F1PZnaW4y1yiP+/71heg3vxfzloh+5N7EfKy9p40N0bsonYyDvnv+OalI\n", + "JUmSJEmS9GRhilSLaoIli8WPdTfUF2joU/nYnHbaaZI636xaPwrag/bBShhq/eL/4YoN77s9WtD9\n", + "KShHSZnjfIyJ2kgJByvP/VZKqoErJFjhtGtJ0YHayCDOD/fcc0/V7yLod/qbcqNwRf4JUXmJ5Dr5\n", + "5JMlSTfeeKOkstUPWPFAf0Z5xpwvfelLVdeB5co2ljJtggVayi9Dmfw4xjQqn/u2lCI3PdJ3qC8H\n", + "ihjnRaXsq+5DpNR5DrOIWp8ex9fwkk8WUZMoCe6PF0H9/Hj6Naqf1wf1E7/OHTt2rHo9V5lZM1pV\n", + "a8fzc0XKCv1JPcbyVYrWDq7HOKW+HkU7dLz25fjjj5fUzddUpJIkSZIkSRbMLpFHCmuRp3u3eMcG\n", + "i94zSM8bnuKxAiNFyhUirDism7EiGLAuPEKI9i9FztT6iHlm7r7+GGMrjKV+R3HzXDEl3Orv69+C\n", + "P8/mzZslSffee6+krh1oR5TDVrDWUPhqcT8i6juW756zXA1izKHU1KqEkaLC2Iyy46NMoJTU5kty\n", + "6COuF409Lw/l7asIAeVm7YNaP9Fav8mhoC73zWvlimLrmGQu0N74ALmSRrv59VCSht7D6K/99ttP\n", + "0s651RzGH2v50Ejd6B7jUbDUn/HMdfsqUrUKpMPbipJvWl9SkUqSJEmSJOnJLqFIOUMjVEqMlceo\n", + "FXK6lHyEPFM1VgDWJO0z1EcKq8mj6LBuxuoHt+L7RjuORWtkydCoP/ezweoqWW2MA46j/z26r1Ul\n", + "QPnFd2uoH0Gr1ct4rh0Hy4+rzcRNLjqUIOZc5PMStSF5hEp9xZiKIiE9uipSpPgeFZQ5iDISRTSX\n", + "QL0k3xXUriHrzd/Uod1q13aUIxQrj7ZD6Ywyg4P3I2spanIps3kJV52jfsBXiXFKO5Tmtvs3uj+r\n", + "K2ucn+85P+NoqCo977dRfVmfpUqSJEmSJNkF2CUVqbEgAqPv+/axQUnYuHHjqse5lePvoceKiMCK\n", + "c8UF62Is5Yhyr1drIwKrcq+99pLURYi1+tShSHm+pVIEE+MFqzRSI1oVIcpRspYj/xCn1QptHVfL\n", + "/aBq5zJ+fah41AElwlXJSHWsnWvMpaitsPyJbrrrrrtWPI41i5xh+Krwu76KVFS/eWWMHkqtagvR\n", + "vqGRqo7ay/GuZKFERf6cKEQ+juifsdZo5ihzkWhVQImiPKw1XJ/xHkXA87toTfP243zML8b7WPmj\n", + "5v02qi+71p0rSZIkSZJkHfG4VKR4aubpvK8ihdXSut9TBFaCZ6h2i979FrBSyYEzlo8X53UfKf49\n", + "lpWBdYkiNa/orrFxvxbGVasixe+x/vh3SfkrReqAR2KNBeOspA6U/EiGUtq3bCVoM889FikJQ3c5\n", + "cL9HV6ZYg0pqHIoDc5C2bY2sdFBX5zVW+hJFI9Ln5DyjHdjdonYN9HxjwPmi85Qii2lH7xf+7hHR\n", + "Q9X9kirM9Rhn3PtKc4fy1a5pHlXHWj7Wfp5j7UIxNqlIJUmSJEmS9ORxqUjxdN7XnwBQosby7eGp\n", + "H5+P2vfoXJ+nfX8P3jeihsggt8rcp2noe+vaXD/rDcqNNdjXWqJ/fB+osXzQPJP6WNQqh/P2a1ie\n", + "x6t1THKcq4vRcX2p9SssrUn0JWOOOY6ShgLSmouNepfUQ/fHHIrPGT8/a5mr/rQD/omUm3oQAe14\n", + "/aK3CaVM+CXoR4+wpj74JEXjYax2phy0C2sM48XL57T6yHE+rx/1pj59fe/GutdyHsbDUKUsFakk\n", + "SZIkSZKePC4VKfwLsN4OOuggSV3+HLIU14J/wViUdhZ3UEawmtnpmvr0VaTIrO5WG+/513vumLUC\n", + "VaCvauHti7VGO7f6vLkqQ0SPU8o9Mxb42rkfylgsVxm8D2ojC2nzyDIdGmXVN1u/Q18x51G6aNu+\n", + "18FXDP/MiLF3edh///1n/s1eif/93/8taee5wdjed999Z/798MMPSyrX3xWgee9a4bsK1O6xR7lQ\n", + "pyMFp3aNiCKvuQdGEezRmnbEEUdIkm677baZv0eKEQoin30Vqb5rLNf1fGIoaL4nYiupSCVJkiRJ\n", + "kvTkcaVIeQZprBesnr4ZnBe1kzXg8+X7GA2NqsMqdMgKjXI39D0zuU54n9/3PThWB1YLVgc5dqL6\n", + "9AW1w8cTimDJDwLcKqYfOX+tknPSSSdJ6hTX++67T1IXyeRgjbUqUj6PovNC5HcURfKU/JywornO\n", + "YYcd9th39DVt3lo39/8by4eillIU1/bt2yV1cxxfoLEiaFvXsqG+PO7LVFKUGBPsK8n110suQMfL\n", + "Rblrx1OpX0vnYY7svffekrr2ZXxzz4uu43+nvVEOPaLb/V2Z41wfZbivDxpKZCsog5SXe8FQJQpS\n", + "kUqSJEmSJOnJulakUCp4CiXbL5EaKCK1VpRb0Dwdc53IGuJpOsr03Ncaas3OC67Y+Pt2lAjHc9B4\n", + "bpFasDIoB0/77ofC+3vf5wnlCQXJ+6Xve3D8CVBy8PtozfNV8kugvviT4J+BdYhvWW3U3aZNmyR1\n", + "1qP7PVAO1BUUGcbPMcccI0k64YQTJEl33nmnpK6/o6jIyCpEcUQdac3r5e1NO3Be/DH22GMPSZ3i\n", + "dvfdd1ddj9+vtN8XawNjjb3wSjBmaFvmBv+mb13VJI8Rljp97wqNq2yR6uaZpH2ucx0iFV1xc/Wx\n", + "lFEdDjzwQEk7r0XPec5zJEkPPvigpG6sMzYjJcr3gaSvXEFx/z3WepQC2p9P2sMjUX0t43vOx/W9\n", + "flzfM8XTjlyP3Sb4PXPH7yEedeljmbnNGsM9J1KEmDuRUskcj5QV6sN1uC7nY/zUKpq+1vv4ZPwD\n", + "44B23m+//SR148DzfkUKMuO+79sfyluKEO+b1ysVqSRJkiRJkp5MxspV03TRyWS6tLS05tdNkiRJ\n", + "kiRpZWlpSdPpdMVEa6lIJUmSJEmS9GRhPlKrKVL48PA+199v4x9A/iaiozzq7p3vfKck6QMf+MDM\n", + "790XivNxncinBn8Ifw/sdeKT9+H4gvzkJz+ZuQ7w3tl9wRy+p55vectbJEkXX3yxpO69c18fo1Je\n", + "Ier1nve8Z9Xj8PmJ6lGLt2fEKaecMlOerVu3znzPe3rPKtx6PfwoeM/uai6+Y7R/pPYyrs8+++xV\n", + "r4dP0dAsy0Syve51r5u5nu8rV1Kna3368DO48MILZ65XSykSzP0YmGfnnXfeY3N99913l9TNOeb0\n", + "WAo8dbrkkksklX1M8BHZsGGDpM6P0dcifF722WcfSdLtt98uSbrgggskSe9617skdWsKa8L9998v\n", + "qasveHQV39MO+PacfPLJkjofo9/93d+VtPPaSc69o48+WpL07W9/W1IXfcfcP/zww2f+fsMNN8xc\n", + "j3oypl7xildIisfKAQccIKnzBXJfJCI3o2gsroev1Wte8xpJ0sc+9jFJnZ+m+23Sry960YskSddf\n", + "f72kne8R9IPvZcdxZ5555qr1G4rvmXf++efP9XoO17nssssk1fulshbiIxWtLYx31oQzzjhDkvSp\n", + "T31KUjeu+d73oozuVZFPFO3JPHzlK1+5aj1SkUqSJEmSJOnJuozaQ7GJoneIxvI96Uo5NaLsr1hX\n", + "3/rWt1b9PVZGpEgBT8NYynxG9eFpOVJw+D3Rgx7l5rk8sPKwjohyQoFwqxV46o+sPi9vxFAlKso7\n", + "FIFis2PHjhW/p30iJaqWUp6x2twwtZnKh+4FCVHEVmuOpdqImZLqU8rGXMpJhLqDmrP8erQZcwVl\n", + "aqy2dGqjneiDW2+9ddXjXO10dZkxxphnbEeRt/yd83nfUC6OcyXH282P8zxQrC2sOShRfj7KgVJU\n", + "gnozdhz6mzxNDmPKM3zTf6ypfKJi8/1Xv/rVVcvnkdIoMr42R3g0YhQxTD1pD9Y06ueZ6Wkv2pvy\n", + "+D0EJZHxgLLnOeN8jfPM7Sg4d9xxx4r1Yzz79binR3B9Xxv4XbQ2lda4aK2inrVrdSpSSZIkSZIk\n", + "PVmYIvUbv/Ebj1kHPL235qup3a+nZI3y3r60czrvU0u5JlxR8/fXrfBUjDXoma4pL9aD5/bgd9Ge\n", + "a+Te8f2XIp+yEvj2cD36CWsiyrQNrZnNsRojH57S9daaWmWnpHYwf/BbiZTAsfZ5KxFlPMfKxhoe\n", + "qg65H8tyK5Ux4BYx4AtEfiR8j9Yb+Da50kSfozRgkUeWd0klRSH4wQ9+IKk8NunjaO1lzOLbBa7M\n", + "4CtWCwpYlE0fv8joHsLvvNzRrgIlSvcK1uxaRYN+iNr1rLPOkiTm3A+kAAAeOklEQVQ94xnPkCS9\n", + "7W1vW/E4b2fKidLp44G5xJ6HKESMg/+/vXOL1bQq7/h/hWq0SEAOHcYZyIzhEMdUFDKjiSFgAqYa\n", + "g/SCWhsSLZaYCEqMMVQTy45cWE1UqBfERhq1UqrB4DGkggEsFzCAjAOMQCfM6ECYmQJqJNEEm9WL\n", + "/f3m2/vZe+31vus77b3n/7vZ+zu9h3V61/Nfz/Ms2l/8HUpifLaVfKO4rtJekTVKx6UfxHbbdVWj\n", + "NGZRH139ja1IGWOMMcY0MjNF6rWvfe0Sz3h2ksZK2LFjh6ShsvHggw9KKs9OW7OSEtWEr9R99923\n", + "7PeYTXc9fsyay+/7+qZgJZVm71xPLXtxzPqL9cism8/junqkZo3hQ9YabdbVioOu2atLYJW0cvXV\n", + "V0saZhbndUl5Kfl59OXSSy+VNFQvRvVNG5VS+8SPgr+jKlJE+sQoSalsocLZZ58tSbrsssskSQ88\n", + "8IAk6cc//nHTtZT2C2yFMRHfLqLxgPPUxoS+0Jdj3UR/NtTwksVf8m/ldcyM3XX/y9p9onDgm1Xy\n", + "GYsKQ1SkKN/SM4YxnSi9kvLZ+iwqgQJUi+SN/q+xXXL/tDOeAXfccUen8wPPgFhO7DYSidfR+myI\n", + "7a7UDrs+Q2rPYsbWGlakjDHGGGMamZkidfjw4SPWALP3aB0Q8XHhhRdKGu4pds899yx7zNbZP7Pj\n", + "p556asXv9d0pmlk8ESC1WXhp/y2sh7iXXFewHkqKVYxmq/mq1Wb7s8iWPwqjWvVYW29729sk1RWX\n", + "vopbCfxCukY+zQrKB+uX9ltTUGvHa1H2UKB+9KMfSRpdxaNPtt5LhL5e8/Ho6h/aFRSuGIUF3Cf+\n", + "pF2j0SL8blz+o8B1cZ1d9w+lnOmTtYhSIptrYwZjYN8I5BKf+9znJEn33nuvpO7+xH33GY1Qrigz\n", + "KIjsudiVWM41Sr5Lsc/Hz+MztDbW1JTkrsqZFSljjDHGmEZmpkj1seBKChTUfHZQhEqzc2bZtWgx\n", + "ZtNdMzwTLYb1ULvnUoQA5+XzGFmCXwBEa6wWtUX58D1m6aV1/q55fkr3y07qNQVwtUM9/PSnP5Uk\n", + "3XTTTVM9PxFb41K4JgXth37QNfdSiaigLlRHaHvR/w/I44RfXa1PMrZEVQ1qfaEvKE21XHW0PSz3\n", + "2q72NRgz2L0BaFsoPaMqHCgItIm+6noERWv79u2ShmN5a844fJDIGRfHzlq9RFB0RoVnTsl/t0RU\n", + "AHnGdW23qOuUQy06rrT7B0pSVyWVdlFSnKC0esMzEbW+VXl2HiljjDHGmAmzKjOb96WmuNRmlczW\n", + "u/pcdM0DREQAyk4rzLqxnuOsHGsR64DvdY0kImoRKw4rYNOmTZL652GK5Yj1fNFFF0ka+hlQ7jE7\n", + "8lqB+5y1stY371br8Vv3cKT91yLc8MPAT6fkhxF/vzDypmv+l66KeG1sGVVdK1Hz8Yn+ZqMSc9VF\n", + "KGPqsFUBY+xEkRo1YpbrQUmCGE1XWkWIygxRiSXlpO99jyuaE2WLvtjVRwmFhrG2tQ93feZFRYo+\n", + "TT139V1DSeI4lGPN/zbulxtzLval69hqRcoYY4wxppGZKVKvetWrJmbNxXXb2nnwzC/lwIh0zR3D\n", + "9/pmbC/BLDtaS8zSWc8uXRc7pGO9kaMGxaCU3bVv5AlWG4oNPlHkXhmXUjdr+uYDmxS19j1q5BAK\n", + "EVZi34gd2lXNGo6RV/ip1PwqFlqp0YIcNZ8PljRl3NUyH5WulvS4FA8oRaPRl2lLo47dHGfUCF+u\n", + "Y9euXZKGCh0qOz5TvB8jauP5ua5x5YHqmim9Bu2OXShQamqrLSUfolbfPvpoaQznfLxP++S85FSs\n", + "7VvKfZ188smShvfbddWo79hcqu+uPl1WpIwxxhhjGpmZIpVSWpJhe1z0tRr75oDhukv+E1ixREy0\n", + "rtPGWTLnjdfL/dYiavAb4HhYF6X7b80+i1XC8bHy2M+rlEXZtFErx1Fz9aDytOYuIiq05h9BJN2W\n", + "LVskdVfSFkbtRfWXNogF3nffQa4FSpmsx01XFbtm2Y8LMq2jMKA6d41gjowrvxKgrlNfMc9VySeL\n", + "92P+LhSsUaMUY0R1Kyg5XB/PgpoiVVq96FtvlA/9iXYQ2ynPcr5P+XG+0047bdHvSv1x7969y74/\n", + "LoUvQvnyrOY8vF/DipQxxhhjTCMzU6T+8Ic/HPG5YN0zzv5RZPD853utOUJKMAtltnzgwIEVv1+z\n", + "zPHxGDVjNlYR1hVRdKX1X6yN2vo+uXGwGkqRKDHioy+xvoj+wwrpGsFhRmNUXy4Uy1Zlq28WbNpb\n", + "V/+UhX5R0feDe29tw9NSoCIoQHHvtEkTFZQYEYziQN9GGem76wNtigjeUYltJkYzMtYwxgPKSvQ1\n", + "w8dqVEWqb8RzCcqZtt7VVyhG3Lb6+NGvyF1HeUVlMe51yXmpF575rT5ak/KrjmMU99d1rmFFyhhj\n", + "jDGmkRUVqZTSaZK+KekvJGVJ/5pz/peU0pykf5DEdPvTOec7Br/5lKQrJP2fpI/lnH+y3LGPO+64\n", + "I9YO69bMAlEsTjnlFElDq4j1YGa1UUlh/bbV9wYrsKZI1SxlFCGspNYIEKyhmIMjKl1xll46D7Nu\n", + "ypMoOq4zRi2OOvvHisKKMZOhtuP9uGi1Ikt+PCU/Ddpd1/a3UE2IPhcln6nV6p+Hjw/XOW1FKrYh\n", + "VMi4Fx2KT6vCgVKI3+SoMOaVMtBDzaeoa6RoV0ZVtIDy4pnYVR2OOQJjxHltb8EIfZZIXo4PjPkx\n", + "WpB+SM691t0YRl3lKVGKfu36zK4t7b0s6eM5510ppddIejildKfmJ1Vfyjl/aeGXU0rbJL1P0jZJ\n", + "myTdlVI6K+fclgXMGGOMMWYVs+JEKud8UNLBwf8vpZR+qfkJkiQtlwTovZJuzTm/LGl/SmmvpB2S\n", + "7o9fPP744zvno8Fzntl9ydO/1cpEqcEXqwTWQG3dm1k+s9yueadKMPtHecDHCbpGHWIVkFsFq6Cm\n", + "wEW65iLZt29fr+NOmq7115eYs2ba4GcyK5+zWvsutZOSmtE3e3QX6xZfEfLSoBKPWmbkSONesJi5\n", + "h1of4TrOOeccSUP1GUWKvQFnBRGXRPAy9rZmyI6MqnpTr2TUJs/S7t27l/1+10jk2nWNK89UV558\n", + "8klJw7Gra7Qmqw8oiKy6RJ8rfAFLOwOcfvrpkoZjDT5x8VlUUlC7Knwcj+urRbxzf6MqiKXy5Nlb\n", + "o7OPVEppi6S3aDgp+mhK6RcppZtTSngovk7SwtnRMxpOvIwxxhhj1hWdovYGy3q3SbpmoEzdJOmz\n", + "g4+vl/RFSR8q/HzZKXsXNQqFCUWK2X/JAi35TtXAmnzkkUcWvY+l3Rp1hDXHcVjn7muFxfXwuC7d\n", + "l9adsAHfqlKuDxiX1dpKVKDGrUShbpApnnY3rkz2Xakpf6PuQE99syci1iJqS01pRWVBrcHKwxru\n", + "m9updHxp2Fdi5CzXSL6hcUGdcx7Gpq7qM2Na7Et999DDd4UyjWNkbb9EFJ04NsXdDXjNmBajsmgb\n", + "1Ekpmo96og+1goJB+Y+aZyhmNo+KYvTrpbxow9Q7Y3TMQ9R3dSJmAu/rc8UzJ+bPYixkbEDJozw5\n", + "D88+fs/qB/Uan+OlsS8qXYzNKE4xQp9yrilSnI8xJWZcp13TT0tzh5JyzJyiRnUilVJ6haTvSvpW\n", + "zvl7kpRzPrzg869J+uHg5bOSFsaXbh68Z4wxxhizZmBCeffdd6/4vbTSGm+an9Z9Q9ILOeePL3h/\n", + "Y875ucH/H5e0Pef8dwNn8//QvF/UJkl3STojh5OklPLc3Fz/uzLGGGOMmTJzc3PKOS+7QWxNkXq7\n", + "pMsl7U4pse71aUnvTym9WfPLdvskfViScs57UkrfkbRH0p8kfSROoowxxhhj1gsrKlITO2lK+YQT\n", + "TjgSMUM0Wswfw3op66SsX8f9huJeYKz3Xn755ZLmZ5ILfxejhVinL63nx/XXEpzn85///IrfjxEf\n", + "XX27+B33fe211y4676ThPPztu5M46+1dfYji+cZ9/Nr5aEcxfxdRmdx/yceHeopZl/GT+MxnPrPo\n", + "fJOCdnPddddN5XzAeb7yla9IGvZj/EfwgYz9BH8M/Bvo1zHDOuMD8vtVV12l66+/XlJ7hGxX+rZN\n", + "iP5ifc/32c/Ou6biQ4IPzeHD894WNf9L2m4t0zXnm3Z53nDDDZKWRlOW+hJjOr49+MDwPm2F6+dZ\n", + "cc011yw6L2M85RMjwN/znvdIGkalPfzww4s+ZwzHt43rp21ynhtvvFHScKzn+uL+rdQPz0aeUeSD\n", + "ok/Qt7kv7pPzffWrX5U09NelnVBOnI92+cY3vlHSsJx37dolqTy2Uu6f/OQnF52371jc9ft9xzLq\n", + "hftszV81Nze3oiLlzObGGGOMMY3MbK+9hUoYlma0enh/27ZtkoaRC1i2pX20StFkJeurtk8UljFR\n", + "S1gtKDFR1ePz2p540DXKkN+VjosVhvUSI3SwRsZF30zXk45mG/fxS5GlXSOzSurApK37yKxX10vt\n", + "vVRfqDVY2aVIJZSthblepl22fRk1MzN9muP0PR5jRNe8O9Muz9LYVupLjOmjZqrn+KXz80wpRTxz\n", + "/tpYXrqPUi5AlK1SvrOY0b30+1qGfNrRAw88sOznpb5aUuPj6k+tHXUdu+NYUouC7PpsHTUflRUp\n", + "Y4wxxphGZqZILZyZx9kkO3ST4+Liiy+WNFRUmDWXcsKMmkskghIFMXdKJO5H1TXzeImuWXSZ/XM+\n", + "rAWyL7/73e+WJN13332ShhY9e+zFvfaOdmLunKjwTctaX+37w9XA1wxrH7+QkhWKv0QtZw7WI8rV\n", + "cuB7EpWAHTt2SJJ27ty54jnWG2SmruWAg1L5Ab43tNGYx6qmhMQcedPOwYYSgbpeUtlrufdi3jLu\n", + "K+YgxKeIvsDrUTPso8rGeqqtjkyKUXPDdWXUMZi5As9IfML6YkXKGGOMMaaRmSlSp5xyStEHhdk8\n", + "s3t8opjlnn322ZLKVlXfWSr7D0HNiqrteM7nk7Kuajt/R2sAy/3pp5+WJJ1//vmShlYQCtV6pXX9\n", + "m3aEtTfqfk6lqNFaxAoKLaw1ZYryI5sxVnJJcerabyjHlTLol5SU7du3SxoqKqjco6rHNWoZxvtS\n", + "ajsxQzfn7etTVVPB6SNER7EnG5mz+bzknznt3Q8oD0A5Y4yAmv9njPSO5crvY+b2qFDVlCiUPtpp\n", + "bV/UWF+cr6Ys1uA4XX2eJkWspxq1iHiiFLtmMC9hRcoYY4wxppGZKVIr+TGRK4PZ8/79+yUNZ6Pn\n", + "nnvuWK+F2Sg5WWqKVA2sjHFFS8Xj9I2WQ8H42c9+Jkl69NFHJfXfk3CtghXaN+9VzPs0KWoKDPW0\n", + "1pQoQFHmL/2s775jEcqtJTfMvffeK2noozKq2lgCZegTn/iEJOmSSy6RNMx/c+edd/Y6Hj5OtImS\n", + "7wsqO0oJY9LBgwd7na/WNlG/d+/evegv1PYpjXU/Lr/SEnEsjVFvK/nbLaQW6Q2tkdMoWai59JmS\n", + "IlVqB+OK1J6271oJlLWu1BRP8meN6kNmRcoYY4wxppGZKVIrWaGldVysxtpu930hP9W41utnnbcn\n", + "Eq27qERt2rRJkvTss+tzf+nWCBJ8esigXYvcqVHzrSux2tpTX+KOBZQDak2rIkU7JvtzHx577LGm\n", + "c/aFe/3hD+f3dUcJu//++5uOh1pfo+ZLMy2iT1KNSfuoRVCgJhVlFtXvrmp4VLxWS33Omr7RjTWf\n", + "sEOHDklqG0MWYkXKGGOMMaaRVZHZvC9EhIwrAgbfjVGzDq9V3vSmN0kaWviT8heZNV3bC34dtAd8\n", + "6PCnmVaOFHj9618vSTrzzDMlDVWNtQJWOAoUVmL0u2jtz30jeWbBnj17pnq+1ZJ7rJTfaLVA25lU\n", + "OdHmjzaIzG3d267EuKM8UXjxzeuaszFiRcoYY4wxppGZTZdb/UWkoU/FuGanrdlf2YNv3HvYTQt8\n", + "o7AaukasrFWwjmuKEhEy+M5htYxqXZILppaxO4JCRj6ptaZIRT+Zkt9M3/7cN4LnaGLaChB1yl/q\n", + "BmUM36c47tdy4k2aSY95jCHTYrWM4eNWolqp5ejjmc9fvt+3/6yOUjfGGGOMWYPMTJE6/vjjj3jM\n", + "l8BawVJFiSL3w7jWtVt9XlAY1poiheLCLBz/jfXuI9bVSsJq5vvjyqGCj1XfciavGT5SKGvT3j+r\n", + "FcoRtQIlN1qDXaEcY9ZuM2RcbbZrri+UJ8Zm+hB1U1qB4PvrlVFWXlpgdcXM07X8mWu05gz0CGSM\n", + "McYY08jMFKkuM+doaWIVTSqqrO9+Ql13UF9tTHvdflrUIkXIFULUZwmUzhhFNmo+JxSUvr5Av/rV\n", + "ryQN74/9oR566KGRrmdaELUXy7HVNzEqyGsham+tQjQT+Xt4TZ0xRuI/SJ9hjK7V7azVxNWSsbtE\n", + "3z3yVmt05KSoRdnRDtkRgNUjnvEoouQMfPzxx5uuw4qUMcYYY0wjM1Okav5R0lBZwBcJa4jZJHmP\n", + "uloVpfV+LFoyWD/zzDOdjgd9s/f2BWtv2uvtaw18Z6hnrOGzzjpLkvSGN7xBkvT9739/xeNMKuKk\n", + "VUml3vFt27Ztm6S1o0jF/dN+/etfS1qqZvRt39TzpPdCHCe13egnTd+97GIWeiz7qDTFMZXXNUWq\n", + "ps6iIvfNaF0iroTgbzit3HmbN2+W1P0ZwzMJJaXvPqvrna6rBDzj47Oadk1/aF11sCJljDHGGNPI\n", + "zBSpLioSs0N8l7BesB76KkHRamKHbaKI8J3pOyvFSpsU41Kiajk11gv4XWB942fQur/ZqKCYtEbU\n", + "YE1xP+ecc44k6dxzz5Uk/fznPx/1EifKli1bJC1tx/hz1PJqcf/0S1SOt771rZLWhs8f9zBqLjLG\n", + "rLgXW1f67mUXI0yffPLJRa9RWKLSRV3XFKeozBE9hfIybrU/qs3T3sWhr3/ket3/tJVWn7qSPzNK\n", + "56hjqBUpY4wxxphGZqZIbdy4sWqJYp3gI4X1gK8IFu3BgwebrgFLlr32WtdHo9XQNffKpIkK1FpV\n", + "orr6dWBt4ldB9N1TTz0lqX9EC+0MK6hVBaAdtLYH+sm3v/1tScP7G/e+U5MCJY5+jDrD9dNO8XGj\n", + "Hrlvfo86wu9QdxaOI0Th8N0NGzZIGiokKB20Ker2wIEDne6Fa+0Kx0f1ZqxphTbI2Ng1ErWVkood\n", + "fUvoa7FuKG/GxPh669ati44bVcuoWJ166qmShvdPW+LZwPtPP/10p/ur+XDh08b991WwYub2vjkL\n", + "x7Wf7LSIfZsxj7GUdtr3fshTxhgybkYtZytSxhhjjDGNpFFz4zSdNKU8Nzc39fMaY4wxxvRlbm5O\n", + "OedlnfasSBljjDHGNDIzH6nbbrttiQ8EuTJ4n2gfwI8BFY31Uvwi8EPAj+CKK66QJF1//fWShhEv\n", + "ZDFlXXT37t2LznPGGWdIGvrUxJwf+CWwzo+/xQc/+EFJ0s0337zoeiM33nijJOmee+6RJN1+++2L\n", + "Pr/44oslDf0PYrTZpk2bJElXXnmlJOnLX/6ypKGfAlFq+DfgV8A6f/QJ4/pZz6YeWJfGT4D7M8YY\n", + "Y8w8VqSMMcYYYxqZmSL1/PPPV6Pt9u/fv+Ln5IAg1wjKEcoMoLSQTZ3vlzJY1/bQi1l2Y/RhLQLo\n", + "lltukSTt3Llz2c/PO+88SdKtt9667Ocxt0vMdouSxl8iTUpZcYmoiPVBOfbdC80YY4w5WrAiZYwx\n", + "xhjTyMwUqT/+8Y9HfIzIOdKa56i2bxW5LVBk8Knqm9OjRMwtg89XSfEqKVH4fHFd+CpF4nXX9oar\n", + "RWbGfD4x39Kk9p4zxhhj1jpWpIwxxhhjGpmZIvXSSy+NnPG5KzEbLQrWuBSpmL22dW88fK2+/vWv\n", + "Syr7JsXd7mvn4/ul7/E+UYz4kM0ix5gxxhizlrAiZYwxxhjTyMwUqeXUDvbaGlUpwkep9j6vUWD6\n", + "Rqfxe3ywYNR9kcgfVdqzr6svGddXU6yoi7hvlTHGGGNWxoqUMcYYY0wjM1OkjjvuuCX5mFqj9iIx\n", + "ygwfJpQnIHM3ChjRal19g4j+iz5Lkb47S5NJHIWs1YeM+6j9nvxaJ510UtN5jDHGmKMVK1LGGGOM\n", + "MY3MTJE66aSTlihS0ZcHJYc99EqZ0FGGUJxiHiTyR6EcsRddVJJQZPAR4i970eG7BGQY5/wl8FWK\n", + "11WC45YykXcFJYo8XTVfKftGGWOMMf2wImWMMcYY08jMFKljjz32iDJUUmrw8akpJSeffLKkoQLz\n", + "4osvLvs9Pn/1q18taWlG8qhAnX766Ys+f+KJJxa9xhcrXl/Mw9RViYKaElWKSozgk4XP1QsvvLDi\n", + "972nnjHGGNMPK1LGGGOMMY3MTJF67rnnjkTT1RQpMn6X4HP2qqtF//3ud7+TJJ144omL3sdnCl8p\n", + "8iqVFC7Alyte96SImdS7QvmgPI3qg2WMMcYc7ViRMsYYY4xpZGaK1G9/+9slikjffEuAYoQSVYtO\n", + "I28UmdTxlYpK1v79+xcdv0QtT1NUykqKGb5M+FyVvtc38ztKG8ffu3dvr98bY4wxZnmsSBljjDHG\n", + "NDIzRWo5/5xR96jrqtSg+Dz//POShlF6v/nNbxZ9ji9VjdJ1kzmd/FN8Dx8n8jtxfpQxrmNcHD58\n", + "WNLSjO/GGGOMGQ0rUsYYY4wxjcxMkRqF6PNDlByKT1dFhwziKFD8vm/eJ5Sn+Doel/xVGzZskDRU\n", + "vIgOjJnTxwU+Wpyf+4v3ecIJJ0jSkozzxhhjjFkeK1LGGGOMMY2sKkUKRQSfoUOHDkla6ttDlBwZ\n", + "zfE1wucpKkTx+OyNx+/x13r88cc7XefGjRslDaP+Nm/evOjzkm8VyhnRgNBVQeuaJytChnYyyeOj\n", + "hVJ26NAhHXPMMUfux4rUbNm3b5+2bt0668swA1wfqwfXxerC9TGPFSkzspO/GS9xom1mi+tj9eC6\n", + "WF24PuaZmSJ1wQUX6B3veMdUzjU3N9fpe5dddtlUzzcuRj3f3XffPbW6MMYYY9YTVqSMMcYYYxpJ\n", + "k94XbtmTpjT9kxpjjDHGNJJzTsu9P5OJlDHGGGPMesBLe8YYY4wxjXgiZYwxxhjTyNQnUimlv0op\n", + "PZFS+p+U0rXTPr+RUkr7U0q7U0qPpJR2Dt47MaV0Z0rpqZTST1JKJ8z6OtcjKaV/SykdSik9uuC9\n", + "YtmnlD416CtPpJTeOZurXr8U6mMupfTMoH88klJ614LPXB8TJKV0Wkrp7pTS4ymlx1JKHxu87z4y\n", + "ZVaoC/ePwFR9pFJKx0h6UtJFkp6V9KCk9+ecfzm1izBKKe2TdF7O+cUF731B0vM55y8MJrivzTn/\n", + "48wucp2SUjpf0kuSvplz/svBe8uWfUppm6T/kLRd0iZJd0k6K+fsxF9jolAf10n6fc75S+G7ro8J\n", + "k1I6VdKpOeddKaXXSHpY0qWS/l7uI1Nlhbr4G7l/LGLaitQOSXtzzvtzzi9L+k9J753yNZh5YvTB\n", + "JZK+Mfj/G5rvMGbM5Jz/W1JMZV8q+/dKujXn/HLOeb+kvZrvQ2ZMFOpDWto/JNfHxMk5H8w57xr8\n", + "/5KkX2r+oew+MmVWqAvJ/WMR055IbZJ0YMHrZzSsGDM9sqS7UkoPpZSuHLy3Ied8aPD/IUkbZnNp\n", + "RyWlsn+d5vsIuL9Mj4+mlH6RUrp5wTKS62OKpJS2SHqLpAfkPjJTFtTF/YO33D8WMO2JlHMtrA7e\n", + "nnN+i6R3SbpqsLxxhDy/3uu6mgEdyt71MnlukrRV0pslPSfpiyt81/UxAQZLSd+VdE3O+fcLP3Mf\n", + "mS6DurhN83Xxktw/ljDtidSzkk5b8Po0LZ7BmimQc35u8Pd/Jd2uefn10GBNXCmljZIOz+4KjzpK\n", + "ZR/7y+bBe2aC5JwP5wGSvqbh8oTrYwqklF6h+UnUv+ecvzd4231kBiyoi29RF+4fS5n2ROohSWem\n", + "lLaklF4p6X2SfjDlaziqSSn9eUrpuMH/x0p6p6RHNV8PHxh87QOSvrf8EcwEKJX9DyT9bUrplSml\n", + "rZLOlLRzBtd3VDF4UMNfa75/SK6PiZNSSpJulrQn53zDgo/cR6ZMqS7cP5Yy1U2Lc85/SildLem/\n", + "JB0j6WZH7E2dDZJun+8j+jNJt+Scf5JSekjSd1JKH5K0X/ORGWbMpJRulXSBpJNTSgck/ZOkf9Yy\n", + "ZZ9z3pNS+o6kPZL+JOkj2VsRjJVl6uM6SRemlN6s+WWJfZI+LLk+psTbJV0uaXdK6ZHBe5+S+8gs\n", + "WK4uPi3p/e4fi/EWMcYYY4wxjTizuTHGGGNMI55IGWOMMcY04omUMcYYY0wjnkgZY4wxxjTiiZQx\n", + "xhhjTCOeSBljjDHGNOKJlDHGGGNMI55IGWOMMcY08v87vVmfz9SwBgAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['conv4'].data[0]\n", + "vis_square(feat, padval=0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The fifth layer output, `conv5` (rectified, all 256 channels)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3XmMXdd17/nfEUWRLM7FKhZZHDUPLcu2HDg2XgBbL0Hw\n", + "AmR4iYOkAwSdP/JHA+5uJ51AkB14uIITDw3HaSCIjaT7OfFrdAYjhuP8Y9hOolY8QLFlJ9ZEDTQH\n", + "cagqVpHFSRQlUTr9h7j2XZd1eId9z3jv9wMYOt5VrLvrDqfOWWvttZM0TQUAAIDB3VD1BAAAAJqK\n", + "CykAAIBIXEgBAABE4kIKAAAgEhdSAAAAkbiQAgAAiFTIhVSSJP8lSZJnkyR5IUmSh4p4DAAAgKol\n", + "efeRSpJklaTnJP2MpBOSvi/pN9I0PZDrAwEAAFSsiIjUOyUdTNP0SJqmr0n6W0m/VMDjAAAAVKqI\n", + "C6ldko65/3/86hgAAMBIubGAn9kzV5gkCfvSAACAxkjTNMkaL+JC6oSkPe7/79GbUam+TExMhONL\n", + "ly5d9/uSpP37DFrn1Wq1Mo+rwFyyMZdszCWbPX5V87jxxvap9MMf/nCuc7GffeXKlYH/bdXPi8dc\n", + "sg06l5tuuikcv/HGG5I6/26uW7dOknTmzJkw9tprr133561fvz4cP/jggwPNZfXq1WE+ly9fliS9\n", + "/vrrff3bXur0Gr3nPe/Ro48+et2vF3Eh9bik25Mk2S/ppKRfl/Qb/f7jbhdPHpstA6iLmIucOvxs\n", + "NM+rr766YsxfKG3YsGHFWDd2MRbjtdde6/txmuyBBx4o90IqTdMrSZL8r5K+LmmVpP/Gij0AADCK\n", + "iohIKU3Tr0n6WhE/G20WwvXH/u7CQq32X5TvrW99azi2FM3TTz8dxnht0CQ33PDm+qRhohgx9u3b\n", + "J0nas6ddNWKfncOHD4ex06dPlzqvunj55Zczjwf9t4hDZ3MAAIBIhUSkUI61a9eGY7tTtPy49GYh\n", + "oETUo0qrVq0Kx1bX54tFeW1QV3ZOGWZhT15uu+02SdI999wTxpaWliR1FlWPa0QK1SIiBQAAEIkL\n", + "KQAAgEhjldqzVFfTWajdLztdXl6uajro4sknnwzH47BMuF++aNh64Jw7dy6Mzc/Plz4ndNq4caMk\n", + "afPmzWHMzj2Li4thrN+WNcP4wQ9+IElaWFgIY5YWn5ubK/zxgW6ISAEAAEQaq4iU7z7cZGvWrJHU\n", + "2ZHWlrDm1VV2UL4Vw9TUlCTppZdeCmO+IHScEIXqZO/d7du3h7EtW7ZIkl555ZVK5oRs58+fl9S5\n", + "YMLOob4AvQxnz57t+C/qwZ/3bfGTb41x4cKFFWOjiIgUAABAJC6kAAAAIo1GrqtPo9LB1YrmfR8p\n", + "S49U1UfFes5I7V4zdUilVtWJuZu77rorHNv8nnnmmaqmUyp7b/gUtKWAfQEzqmev1bim5XvxpRV2\n", + "rvMLJsaBT/vefPPNkqRt27aFsRdeeEGSdPTo0TA2ivvkEpECAACIVH3IAAOz5ca+Q/bFixermo6k\n", + "zkJh6zhch0Jr6/RuRY9SdXdE+/fvlyTde++9Ycxet5MnT4axUS6otZ3rDx06FMbstan6TtW3R8la\n", + "tFGnqCaq56Mx1sLDZz3svT7KfCbCfl9/LrPjqj/bRSMiBQAAEIkLKQAAgEhjldqzHjZNZ2kH3828\n", + "6rTDlStXMo+rZr1wquIXBMzOzkrqfB9agfW49VCq+nXxrIO3LdiQ2gXwPj3t08MYDT41Neg51PfJ\n", + "sy7r45DO8/zn49SpU5I6P9vj8nwQkQIAAIg0VhEpX5w9CqqOQqE3/xpZ4bvvCm13taPSmqOJLNK0\n", + "adOmFV/jMzbahnl9/YKEqnaUqJqPONl5Lauw3Bfmj+JzRUQKAAAgEhdSAAAAkcYqtUexKMrmQ99W\n", + "mOkXCdSp6HrcnThxouop5MIXUANF8mk6O9f5dKn11/ILbPz5b1TwiQMAAIg0VhGpJvNX9Lak3i+t\n", + "t2ibdT2X2gV+fk8oi4qsW7cujE1OThYwY1zL9pvyxeaHDx+uajq1YXetfm9GInXx6rDHJcaDj37a\n", + "+87/XbJ994hIAQAAIBMXUgAAAJGIAdfI9PS0pHY4VGr3F9q6dWsYs5SdL/Sz7sx+w1vrUeRDrdbL\n", + "yIdkfUdnFMdv1DuuLMS/ffv2MLZv3z5Jnf1nLFXtU3xHjhyR1Pl+HeUNnmONSzfpPPg0e7eNdX0f\n", + "pM2bN6/4fnufjmKPpG7882J92Hbt2hXG7Lka9T55RKQAAAAiJd2uwgt70CRJW61W6Y8LAAAwqFar\n", + "pTRNk6yvEZECAACIxIUUAABApMqKzatM7fnHrjrFyFyy1XUuf/InfyJJOnfuXK6P4Yv/szZStQ23\n", + "/+AP/iBzXlXwj//xj39cUnXFtjaXqp8TPwfm0snm8Id/+Idh7MqVK5XOpU7PC3PpZHP49Kc/HcaK\n", + "Klr351/fY9E8+OCD3f997jMCAAAYE7Q/QFe+I63xS4attYIfs6v7y5cvhzHrXr169eowtrCwIKkz\n", + "iuG7sNdRUUvLs6JQZTxuXsZt2XdRbAn5KHd2ryoKhWbyf0eyZLUDGpRF/KX27h/+b1ovRKQAAAAi\n", + "cSEFAAAQqRGpvV6FuCjOK6+80vXrlorwnaqtm+2JEyfCmIVnz5w5E8ayQrHWjb2umtyh13fMt+7g\n", + "p0+fDmN16hJuG6COWxqo1+cNGDe2a4eUnfK2cpFhUnu+n6aVUfgdQXohIgUAABCpcREpu/rkzq0e\n", + "rIjc9gmU2vv5LS0thbGLFy9KahfyXY9/resoj8LGqvg5W6THXj+pHW2r6rPl9+2y4k8iUsB4s+i0\n", + "1M6A+LGsxU39slYH/txjn8GshVbXU++/WgAAADXGhRQAAECkRqT2fHjfwm2+74OF4urea2cUzc/P\n", + "S2qn7qR2/43FxcUV3++7xloqyYdp/etaR01M6RlfTF51YbnvJ2bvCf/c1j3FC6Ac/lyVtdjM//0Y\n", + "lF1b+GJzM0ianbMVAABApEZEpHwhmN2p+qvFrKvJMtiVsBXASe35+avoJhfMZnV39c+3Ffj1W+iX\n", + "FZHydxnD3F2gOfyig6wFCLwPVvJRvF6LNjBe/N/IJkfNs/RqeTTM39dunyMiUgAAACXgQgoAACBS\n", + "rePnVng8OzsbxizcduHChUrm5Dt4T05OSuoMLdpGvE1O53l5p02zUoU+dBvTC6Qb65N06dKlXH/u\n", + "KLKFHHXoZTQqn588lZ3asx0Kpqamwpid3/ziElTPp8LtHMtnqH/++bO/R4MsfCIiBQAAEKnWEams\n", + "K+qqIws+omJz8R28q55f3S0vL3f9et4tLOr0elihfR3267O7ra1bt4YxuyvzeySOA+vEX/coS9kF\n", + "5haZtBYnUv33wiyTL/C2yH1Ve8H6v0ujFonyv5tFZf3fCTuXDfO3w7dbsfOBf317/vvoRwYAABhz\n", + "XEgBAABEqnVqz8KkvidT3sXIg7JiS6nZG9hWparQdx3UIaVndu7cKUlav359GKtjassXfBa1c0HV\n", + "55R+lZ3aa8rzUgdZi2jKNMp9xXzvwaJSez6Nt3btWkmD/a0iIgUAABCp1hEp468WreXA3NxcVdMJ\n", + "7OrYL52sw9Jx1IcvYrQO+L51R5nRzKy7Ll+YWlVLkSz2vJXx/NSxONffhdtr5SNEZUY3fbSlql0k\n", + "6sheF6n9vFS1uGWUsyJ+QYw5f/58OM4jGuh/ni2o8K9vL0SkAAAAInEhBQAAEKkRqT0f0q5TsbLN\n", + "xXccJrUHz4edN27cKKnz/XL69GlJ5byvffjfUkM+FeHD21Wr0+e8Cj51V/UiBdJ52eipVQ6/2Czr\n", + "Oc+7JMHOk4MUrxORAgAAiNSIiJS/Cq3TXYBdsRa1LBv1Y/uP+de8W8Rgy5Yt4diiU77ou9/Ii0Wz\n", + "8nLy5ElJcYXWgxRhXsueg+np6TDmI3TGPuf+bhTA+KmqDccgLSWISAEAAETiQgoAACBSZam9G2+8\n", + "sSNFYEXavtOydSz14f2sNNrExISkzpTDmTNnrvt9ZfC9pSyV4wvR/e9ZR1V1bd+7d2+pjzcoK87u\n", + "N+zr035WtBvThTiroDKrF5Qd+3RZ1uP1m9KzVJwvOM5KM1rfp16pStsQ1H8WszoT9/u+yzvlCaDz\n", + "b2nVHe6b0COLiBQAAECkpIqlrUmSpK1Wq/THBQAAGFSr1VKapplt1IlIAQAAROJCCgAAIFJlxeZf\n", + "+cpXOgpYrYjXF7YtLCxI6iwotWJk/31LS0uSOgtiszYetMLZ3/md3wljVacY/ePXaS6f/OQnJXU+\n", + "p1Yg7F8PKy72xdBZCwKyiowvXrwoKbsw+gMf+EDmvKrgH/8v/uIvJHV2BLffN68NS9esWSNJ2rFj\n", + "Rxg7fvy4JOkjH/lI5ryqUMf3btXz8HNgLp2YSzbmki2PufhFX/0usLENw/1CoV5zICIFAAAQqbKI\n", + "1JUrVzoiERZhsjtvz7cyyGprYGwZtdSOPvml33Xqil53WXsGWuQlptt01Uto82JR0iKX5Npzf/To\n", + "0cIeAwBGXczODTF7WxKRAgAAiMSFFAAAQKTKUnvHjx/vSPdkpZIGlVXknMfPxfVZQbRPm2Z14R4V\n", + "Teiyez3btm0Lx6dPn65wJsBgtm/fLkmanZ0NY7ZY5eDBg5XMCTBEpAAAACJVFpE6d+5cVQ+NHFl7\n", + "iZmZmTBm7Sh8of+pU6fKnRgCa1fxlre8JYzZsuBDhw6FMX8M1Int/ekXFFmE1RaASKMdDUf/7Jy3\n", + "efPmMGbvk157nWbt/dkLESkAAIBIXEgBAABEqiy1h2L40PcgoclYJ0+elNQZUrdu6PTtGs4NN7Tv\n", + "c6yDfAx7bZ5++ukwZn3WSLmiCax/oN9pwY5jegVhtNkiM98TytLDvVJ7k5OTkqT5+fm+H4+IFAAA\n", + "QKTKIlKrV6/ueWWI7vw+QtPT05I6o0BlRKQssuHbAti8aD0xHH/3nQffkZ7PHprEziWLi4thrMmt\n", + "SDAc2w9Pau/f6lu62N++mDYv69evH/jfEJECAACIxIUUAABApMpSe3mnLcaR3/R5eXlZUvmbA2/Y\n", + "sEFSZ9dsK/48f/58GCsjzThq8v6MTE1NhWNL88Vs0Ini2Gfa+rNJ9EbySOd1uu222yS1O79L0oED\n", + "ByS1/yaMIr+oype45CHmbygRKQAAgEiVRaRYsjq8OkQTbIm+v0OwwlAfMSszIrVp06ZwbHewvvB9\n", + "XN97fiGCvTY+6lV2NBMr2SIA/9mxz9gwLTAwmixyafsOSqMdiTL+74kvPM+Dz6T0i4gUAABAJC6k\n", + "AAAAItHZHEOxMKhPRVjKsapUxJo1a8KxzS+vdJ51x21i0atP3VnfMf8azc3NlT4nZLt06VLVU6gl\n", + "+/xJ7XOOT/OMW/rzqaeeqnoKlfDnMutEnpeYMhQiUgAAAJGISGEoVsTtl2hb8V9Vxcs++mRz8Xeq\n", + "w3T1bnLbDr9339atWyVl70XVxGgbxoN/D9v7ddyiUOg8D8cUh3cTsyMHESkAAIBIXEgBAABEIrWH\n", + "XPhQq6XTqupz5fslzczMSMqveLfJaQSfFrG+M76wkpQe6s4vatm4caOkzvcwm3GPnzp0/iciBQAA\n", + "EImIFHIxMTERji2yUVVEyt+hHjt2rJI5DMrvrWZF+r6NQ0wB5LV8VO748eOSml08j2LZPpq+a3bV\n", + "/EIS+0wQhULViEgBAABE4kIKAAAgEqm9Evli36L4zYOtMLrITXrXr1/f8ViSND8/L6kzbWQ9X/xY\n", + "Ewu37TXM2lT2xhvbH6ckSST17nFiBbM+NWo/b/v27WEsayNSe+59cf21jy9lp+/GdePmLPTPylZU\n", + "Ss93J+/3Obc0o0+BD/p6+VQ5mqNXiUO382Av1hXd9zy08+8gfRCJSAEAAERKqig2TZIkbbVapT8u\n", + "AADAoFqtltI0TbK+RkQKAAAgEhdSAAAAkSorNq8ytecfu6p5WMHlRz7ykei55N1nqA7PS9bjf+5z\n", + "n5PUWXBdVO8YXzBuBeUPPfRQGPujP/ojSZ0Fs2VuzlzX16guc6l6Hn4OdZrLxz/+8RVf8wtTbDcC\n", + "3yXaPmNWkCu13+u9dgqwz5E/Rz344IMdc6pSHV+jOs3lz/7sz8KYFfWfOXMm18fqtSBm0OfF/7wt\n", + "W7ZIyl6kE6PXHIhIAQAARKL9wYB8xGKYJeR5LLXOIwrVBEtLS5LKaZfgX9Os19fu0ummPJy8o6no\n", + "Lut843ce6LYLQUwkwj47tNloJt/6oqgdKnpFpAblf4a1ldm1a1cYs1Y0/v2cV4sPIlIAAACRuJAC\n", + "AACIRGpvQFbEJklnz56VRPi6aNZptomd0NHJPj/33XdfGDt8+LCkzpC7pRN4zYHyFbnhvC1y8JvL\n", + "5+3kyZMdjyW1y3KKKMsgIgUAABCp1hEpW2JuS3Ol4vZ/6pcVPg/LF9qhO6ISo8M+035fLNsryzt2\n", + "7FhpcwJ68efrW2+9VVLnvn9zc3OSpNOnT0c/ht+/s+rFLH5f2LzPv/a8FRmRsizRwYMHC3sMj4gU\n", + "AABAJC6kAAAAItU6tWeFqdPT02HMQnbz8/NhrOp0X4wqNotuKlJ7+bPCy7IXSljqY5gUCFA2n3az\n", + "1JRP7W3dulVSZ8p60B0Pss5zfgcF+5tRxvnQF2nnvXNDE/9e90JECgAAIFKtI1Ld7l793QCA3nxR\n", + "98zMjCTp3LlzYYwoEZDNF0bbsd/lwgwTycnqPp/HDhgxiox6jWKGgYgUAABAJC6kAAAAItU6tddN\n", + "3gVw/cpr02KgbD7tULUdO3aEY9shwKdPRjH8P47q9J7Ly6lTpyRJk5OTK742MTERjm2T3CYqo4+V\n", + "LzXwRfpNREQKAAAg0lARqSRJjkg6L+l1Sa+lafrOJEkmJf2dpH2Sjkj6tTRNzw45z9ogCoWmeuWV\n", + "V8Kx3VVXtRR527ZtK479Xandzfv999AcFrkfxYiULdDYuHFjGLPoii8Ot9YFVRWMD6PI9jz23vA7\n", + "lox7RCqV9N40Td+epuk7r459UNI30zS9Q9I/X/3/AAAAIyeP1N61m8b9oqQvXj3+oqT/msNjAAAA\n", + "1M6wxeappH9KkuR1SX+epun/JWkmTdOFq19fkDQz5GMAyIFPS1edbrhw4UI4np2dldTeycAjtddM\n", + "9l4bxS7WlvZaXl4OY5cuXZLUmT6v+jNWV9Yl3m+MbJtCN3XHj2EvpP5TmqZzSZJMS/pmkiTP+i+m\n", + "aZomSdLMZwYAAKCHoS6k0jSdu/rfxSRJviLpnZIWkiTZkabpfJIkOyWdymGegV3FVrU82hfIrVmz\n", + "RlJ7+TY6+TsOw7L26vi7vc2bN0vqjAzZ18tYUOHv3Dds2LBiftzNo+78e9hYZArXZ9EnH22ueyTq\n", + "kUce6fr16BqpJEkmkiTZePV4vaSflfSkpH+U9FtXv+23JP1D7GMAAABU6YEHHuj69WEiUjOSvnL1\n", + "6vJGSf9vmqbfSJLkcUlfSpLkt3W1/cEQjwEAAFBb0RdSaZoelvS2jPEzkn5mmEldy/frsOOFhYUw\n", + "VmYawD+WpUCseE4qpyNsU/hwrW0y/fLLL1c1nbHn35v2Pq6qU7//HNkuBb4weX5+vrS5ADH858U+\n", + "R00qXbDSC9+NvQyjmP6kszkAAECkRuy155dFWxdkXyTrj4vm76St2LCJUagyomg+ImWPR0SqHuy1\n", + "sUih1L6bts7NRbKWB1L7jtgv2mjSnT3Gk98rziJSw5zfbNGFVE7bCOu8bv9FPCJSAAAAkbiQAgAA\n", + "iNSI1N6xY8cyj/Mw6MaS/vvs2PpiSPXvh2HKTkc2fVPKUZO1qWyZizaOHDkSjk+cOCGpXXRe9lyA\n", + "GHmn38o+J9vjlZHKH3VEpAAAACIlVURQkiRJW61W6Y8LAAAwqFarpTRNk6yvEZECAACIxIUUAABA\n", + "pMqKzatM7fnH/uM//mNJ0quvvhrGrIfNpk2bwph1sfXf54+N789kfBGtsQ2PP/ShD2XOqwr+8es4\n", + "F9+3pczi9bo+L5/+9KclVdeby8/lM5/5jKT8C3D77Xdmc6n69fFzYC6dmEs25pKtjnO5HiJSAAAA\n", + "kRrR/qBI3bqinz59euCf1++y7axoFrqzvaHwpjp1iS+qE3MTdw0YxuTkpCTpzJkzXb/PPgtFdoAf\n", + "tDUMUDdl7SXKXyYAAIBIXEgBAABEGvvUXlXh66Z0QK+TMjenboKNGzdK4nkZJbZLgt+o3c5NPs2Z\n", + "tYAlb/fee68kaWZmJoxZF/oDBw6EMTaYRt1Y6nvnzp1hzBYrLS0thTF/PNTj5fJTAAAAxtDYR6Ss\n", + "GK3siJTfn28U+KK+7du3S5IWFhbCGAWrQG9nz56V1BnlqTp67VtQrF27VlLnwo9xiEj58/Wdd94p\n", + "Sbr55pvDmEUIn3jiiTAWs1gJ+bD3bFYU1+8vmhciUgAAAJG4kAIAAIg09qm9V155pZLHrTpcn7c7\n", + "7rgjHL/jHe+QJD355JNh7JlnnpFU//5Z1nFeai9EqCuKzEdPnVLgL7zwgiTp6NGjYcx68RTZkycP\n", + "PvU4MTEhabi+a/58bT2+fCGzpTeLSBuhP/4137ZtmyRpeno6jFna/Ny5c/k/du4/EQAAYEw0LiJl\n", + "V5r+yn9ubq6q6eCqw4cPh2N7bXz0qe7RHeMjlFn7JgLj4tKlSx3/LZIv5rY9ToeJHPh9OTdv3iyp\n", + "c0HMME6dOiWpMyJsj1HmHqDolLVAw5/DswrQ80JECgAAIBIXUgAAAJEal9qzXhB5pYos3Od/nj1G\n", + "kRseNiXV1S9fyPkf//EfFc4kP+O2Ye6427BhQzi2fkk+vcT7oTi+mDuPzbh92s1+dt6vn59nVRuI\n", + "Wwd8K6TGm+bn5yV1fn6LTFETkQIAAIjUuIiUFfPlVdRny93tDlRqL0H2Y3kvNfdLNWMVGTEDxo3/\n", + "DFn0gihU+fJukXLx4sVcf16dFLGUfxRYFLKMhRISESkAAIBoXEgBAABEalxqL2+WxvPFjpZ28wXh\n", + "lkbLK4WWR8qAdB6QH1tkIo3ezgMYTbxP64GIFAAAQKSxj0jZslXfFdW6W/sxfwxgtBHtBdAvIlIA\n", + "AACRuJACAACINPapPeM3qzX0kAHGky04scUoAHA9RKQAAAAiEZECAHXuZGA7HtA5enRMTEyU+nhZ\n", + "+6laG52tW7eWOhcUi4gUAABAJC6kAAAAIpHaAzDWNmzYIEmanZ0NY1lF5mWm+fym5qtXr5bU2cV6\n", + "0I19t2zZEo7Pnj0rqXPT802bNnV8TRq8d57NU2o/pzfddNOK70uSJBwX1Zl73bp14Xjjxo2SOp+D\n", + "MmS9h2xsfn5+xdd86tHm+tJLL4Ux+538e8M2ZD5//nwOM0YsIlIAAACRkir26kmSJG21WqU/LgAA\n", + "wKBarZbSNE2yvkZECgAAIBIXUgAAAJEqKzavMrXnH7vqFGPMXKw/SVYxoy9EtLRtr/St/ZuPfvSj\n", + "A8+lKE1/jYrCXLLZ41c9Dz+HOs3lz//8z8OY7eLgC5TL2KS5js/L3/7t34axqakpSdLly5fD2PLy\n", + "siTp5MmTYcw2ul+/fn0Ys0J7v0OGjVnhvSRt375dUrtIXJJ+8zd/s2NOVbI5fPKTnwxjWbt+FMUv\n", + "EnjooYc65lSlXnMgIgUAABCJ9gcN1G3/r0GXLMf+G9MtOoZi2XJpfwdtr6W/s7M76GH4JetZS9qb\n", + "zJb+j/ISct9l216/IqNQTTkvzM3NheNDhw5J6r+1hG9NkMU+d/59tbi4KKn++7hWsQhNGrytR10Q\n", + "kQIAAIjEhRQAAEAkUnsYSt1D96Ps0qVL1/1aHuk8z4f6yyw+LcPk5KQkaefOnWHsueeeq2o6hfAp\n", + "rDI+s005LxTZrT4rvVn3lJ6pKsXmSwiahIgUAABAJCJS6GiZAIybM2fOSGrvyTaKmhIhuh5bPOFb\n", + "DlgLAb/Yomp+vzwr6vf7FzbFmjVrwnG3CPS2bdvCsUXBu0XKe/H7NTYJf0EBAAAicSEFAAAQidQe\n", + "tHbt2qqnUBgrXvTF0pbCuXDhQiVzqopP4e7du1dSZ1H6wsJC6XOqA+vzM8p9pJpu69atkqTZ2dkw\n", + "Zqk9vzBg0P5H/aaw+uV/RlbJhI0N07uvDL4PXbfnxRelD5PSM1X1rxoWESkAAIBIRKSGcOONbz59\n", + "ZexThThZdzhWEDpuESl7v0rtKGRTlmOjfJs3b5bUGbWxz0ze7TV6sb3ufDdxi4YME8WIiQxZEXlW\n", + "iwBf1N+r83md9Rud63UOtQicP/d0a61Qp4UDgyAiBQAAEIkLKQAAgEik9oYwKim9Ufk9+lVkN+M6\n", + "8ykaK9Qd1wLzuqpTMbIVePui6bJTetfK+7Pbb2rbPwf99t3LSjnW4XXtR8zrPDU1Janz+bHfd2lp\n", + "KZ+J1RQRKQAAgEhEpDB2nc3LLGj0rSWqLqS0KJRUfaH9hg0bwrGf17izO/isu/qyWfTHR6yrft9U\n", + "xb8Go7bXZF7sM+0Ly23XgFE3Xn9BAQAAcsSFFAAAQCRSewh9UZC/qtN5XlO7Bo+jOhQlLy8vVz2F\n", + "Wur3c2RpfZ/qsn9bp/NClpjUshXu+993XBCRAgAAiDR+l45YwXfjBcpAR/Xm8G0z7Fwxbi1TYqxa\n", + "tUpSMxdTxESkrNh8x44dYczeJ6NedE5ECgAAIBIXUgAAAJFI7aHRm2uimeqY2vO9rWzDXp+SqLqr\n", + "d1V83yQWpvRv3M6rlsr0pSLjkgImIgUAABCJiBSA3PRbpFqH5f3X2r9/fzjetGmTpM476nGNSHmv\n", + "vvpq1VNACWJ2uzh69Kgk6cSJE2FsXPY1JSIFAAAQiQspAACASKT2gAJYUe66devCmKWJYopQfSF0\n", + "nW3dujUcnz59Ovrn2PNXZippbm4uHJ88eVJSvfrf+ELvJqfYrChZaqeQ/OID64zti5bz6Mq/evXq\n", + "oX/GuPCbrdvr4NPx9lwmSRLGbFHCuBXZS0SkAAAAoiVV7L+VJEnaarVKf1wAAIBBtVotpWmaZH2N\n", + "iBQAAEAkLqQAAAAiVVZsXmVqzz92t3n4Qro8UqC+WNQKLh966KG+5tIvv8Go70jcD//4X/jCFyR1\n", + "Fmhu3LhRkrRz584w9v3vf1+StLS0FMZ+6qd+SpK0b9++MPboo49K6izeXb9+vSTp1ltvDWNW5Pje\n", + "9743jH3XPGmmAAAgAElEQVT84x+XJG3bti2MnTp1SlJn4arN9fLly91+zb5t375dkvT+978/jFWd\n", + "ku73vVuGOs6l6nn4OQwzl6xi35hu8KP2vOSljnN5+OGHw1gVJTd+LnV6Xuo0l+shIgUAABCpsojU\n", + "mjVrOiI+eUURrmUdimMeI++7gjKWLA8ahboeu/udmJgIY/Z8+DtjH4kyjz32mCTpwIEDYSxrKfyW\n", + "LVskdd59Z/08uyO3KFTW1649zkPW4w3Kom7SeC4LLtvMzEw4ts+C/xzbZzCvLuX23s37/JX1uVte\n", + "Xs71MRDH2jPkvY9cVVEoDI+IFAAAQCQupAAAACJVltrLKwXVy/nz50t5nFFjXZ59t2czNTXV9d9a\n", + "yLtXZ+tLly5Jko4dOxbG/PEoIJ1XLr/4wEoHfEfmvNO/RaX2/CKPqjZ4zurOX9UmtJs3b6708b28\n", + "U3rjwNKh0mg+f0SkAAAAIrHXHjJ1K6jM667Qitb9z6vq7hujwS9csOiUj1KdPXtWUn4LP2wPxLwX\n", + "kiwsLIRj24+ubPY7Zf1u/jnNO8pnbrnllnB85513Suo8P9hr+cILL4SxqvdG9K8V57I2iyhKw+3B\n", + "WVdEpAAAACJxIQUAABCJ1F6fLJTt+wJZGsEXtBfVD6tsVmjqw9N2HNNhOYsVm3s+ZQAMyi9isV5R\n", + "/j2V9yIXew8XWUBbxxSR7wFoz29RhfySND09LUnaunVrGLOFMCdPngxjVaf26vha1cGo/F28HiJS\n", + "AAAAkYhI9cmWI9t+c1J7XztfjJnVTbmJ7M7K791nv2ded572HPk9CP2dLjAo3zYg67OYd9TEIlGj\n", + "uKS7m8nJyXBsEeq8O6/7SNPRo0clSRcuXFjxfX4PzjLbp/jzli068KqOjtXJqLeBISIFAAAQiQsp\n", + "AACASKT2+mRpAl80Z+H8vIqv68R+N5/as+JP3yslK9Q+KF+gWcZzWVQ3alTPd1C219m/p+zrefV9\n", + "slThKBcZ79mzJxxnFZYX9btbnyipvQH67OxsGNuxY4ekzgJ0K73I47zUi/+97X3lU8vWET6vDbJR\n", + "X0SkAAAAIhGR6pMVrPqCShtremF5lqxuyhal8i0grDjcPwf2b/u9U/VFm2UUJRbViRlx7D3ko5/2\n", + "nhhmr8ysz6ePWOWhqM++//zZcdkF7RZ92rRpUxiziIs/D5YRjbPdD/y+fxMTE5I6X1MbKyMi5V97\n", + "ezx/LrOIKBGp0UdECgAAIBIXUgAAAJFI7Q0oK4U1iqkiC5f7vk5WoOs7Dlso23eM7jfUb2mCmZmZ\n", + "4SY7oFFcHNBklkLyhbqxxeD+tb148aKkzs9s3qm4Mj77VfWost/Nbypu/aP8nMr4PNl5xheWG1+U\n", + "bq95GXwq2hau+DSepRkx+ohIAQAARCIiNSAfobFutn4Zfd57eRXFF4xnzdnuOH10ye7m/d2oRRH8\n", + "z+h37y37t34umzdv7u8XwMiw91PerTRsHzxfjOyLlWP5QnBbbp/3575O7RT8nphbtmxZ8fUyIlL2\n", + "nGctSPDzK7ODdlZ2wsvaSxSjiYgUAABAJC6kAAAAIpHaG5APufsizKaw1Nn09HQYyyrQ9IW/xlIw\n", + "vVJ2ltqz/0rZxcM2duTIkRWPMW6yNmv26YJRXNBQBP+c2fsvq8/QMBvK+nNAnVJwRfG9vKynVNnl\n", + "DJY+9I9lr2VVrwH9oWCISAEAAEQiIlWRrIiPjRVZvGlRNN+BNyvaYXd5WRGiXnvU9bt03X72wsJC\n", + "X99fJ77bsy06sKXhUrtw+sUXXwxj3Zbe33fffeHYlnj714jC1f749569T4uMnnSLbPmIbFERRd86\n", + "xKJx/n2TB78YxN7D/ncrY2cHK3L3LQWs8Nw+f0BViEgBAABE4kIKAAAgUuNSe4NuiFtXWek7C1X7\n", + "dFreYXMLjfsUSNZzSSFltltvvVVSZ2rWUkdZr+nU1FQ4th43/rm3vkZ+E1hLv/r0Sd6b7Y6qpaWl\n", + "rl+P7Zgew6d67TX1n2d77YfZmNmn3bJ2I8iDX1RT1QIbe978uerUqVOSpKNHj1YyJ8AQkQIAAIiU\n", + "lFEouOJBkyRttVqlPy4AAMCgWq2W0jTNDPcSkQIAAIjEhRQAAECkyipYq0zt+ceuOsXY71x8x+Zu\n", + "hfa+0HTQtG0Tn5cy9DsXX/hrr1FeRftWSPzhD384jH3qU59a8X3WJ8l6UUntYma/iMHeJ36T6LNn\n", + "z/Y1Fyui/sAHPhDG6vIa/emf/mkYs+fA9ymzBR2+/5O9Vr64347952nt2rWSsguufV+x3/u93+uY\n", + "U5VsDv3Opd/zzDBz+au/+qsVX/OLMuy1OXToUBizzaHf/va3r/g+36vNekr5XlrWa+uFF14IY/be\n", + "beJrVCTmkq3XHHpGpJIk+UKSJAtJkjzpxiaTJPlmkiTPJ0nyjSRJtrivfShJkheSJHk2SZKfHWby\n", + "AAAAddZPROovJf2ppP/uxj4o6Ztpmv4fSZI8dPX/fzBJknsk/bqkeyTtkvRPSZLckabpULc2vntv\n", + "Vhdsu1sf5X3a+r07rGLxgFTsnWxTWHuDImS9t20pf1YUMiu6ktVWo98olDfMPnVF860E7PmxLvPX\n", + "Hl/Ldx/P6kTerSv6MC0M6sR/di0K1O05i+EjSPZ4fr/NLDaHf/3Xf+36fbZvqP897HWr8/sWzdYz\n", + "IpWm6bckLV8z/IuSvnj1+IuS/uvV41+S9Ddpmr6WpukRSQclvTOfqQIAANRLbLH5TJqmFhpakGQh\n", + "o1lJx933HdebkSkAAICRM3SxeZqmaZIk3fJJQ+eabMNKqV0c6zsUW1id0G11br/99nC8Z88eSZ3p\n", + "kaefflpSuxsxhpfV7dlYikPKf6PevFmXeF8gHJsm9d3li9z8exzkndIzeXde7/Wz/WcBxbHzvi8h\n", + "sOfe/72u+/koRmxEaiFJkh2SlCTJTkn21/GEpD3u+3ZfHQMAAGicRx55pOvXYyNS/yjptyR9+up/\n", + "/8GN/3WSJJ/Vmym92yV9L/IxAn9HYQWQthRZki5dujTsQ2BIc3Nz4diWIPvCdyJR5ar7Xol+Acn0\n", + "9LSkdmsCSTp27Jikwd839t6TiER4fm/IqiN19npL7SxCXnsg2qIXHw23LEaRi0HQPt/719Jeh6oW\n", + "QQ3D9sKUpAceeECPPvrodb+354VUkiR/I+k9kqaSJDkm6aOSPiXpS0mS/LakI5J+TZLSNH0mSZIv\n", + "SXpG0hVJ70+b+AwCAAD0oeeFVJqmv3GdL/3Mdb7/E5I+McykAAAAmqCyzuaD8L2jrO+NTwMUWbx4\n", + "Ld8vyTpZ++K5vELUTeP76PzgBz+ocCbjo8nB3sXFxXBsKTgfSl9evrbjyuDsszqufc08X8hfdWrP\n", + "d9O318YXKF++fFlSXMmGvea+9MO6ppPqLdb8/Lyk0enn6P/W9/zeAucBAAAw0hoRkZqYmFhx7O+q\n", + "sroQF8XfTdleXqdPnw5j4xqRwmiySIaP+ubxHvdRIisCzqMY2M+NSFRbnQqt/fnaok/+/WXvuZiI\n", + "lGUH/M+zhRcsSiqWRZTtNZXaf6d9hNB/PQ+2wCTviOMgkTUiUgAAAJG4kAIAAIjUiNRe1gaUPlRd\n", + "ZjrNpxTPnTvX8V9cn3Wnj9kkF9UhVY28+cU5dh736b5Binyvxy/EWFpakjSa7+Vt27ZJ6lxM4Hv6\n", + "lckWgPnyF0u35VWAbhuw+/dLUYsnBunATkQKAAAgUiMiUv7K0K4+/V2LFbLlXcSWxRe0sZy2O3+X\n", + "ZB3py45IZbWoGJXluVhpFAvMrXDan/PKXGCTNx8tyvo98n4NLYoxiqyQ3i94qoq1wMl6vov8W1mH\n", + "vfuISAEAAETiQgoAACBSI1J7vpjM+kj5LsgWHi4jtVcV38n9xhvffNnq1Bsmiy/uPH78eGmP60PL\n", + "9j7x6bwyUnuWjimj+7i9HyTSlnkUKg/CUsd5FzJbKtwfW9G01OzUnn+/ZvHnOjNo+sZ6/EnS3r17\n", + "JeWf/vK9qqraZaBOvbHsM1BkKrWuuzkQkQIAAIjUiIiUZ1fgq1evDmN1vUrNk7/Ttjs2fzdS9+eg\n", + "zPn5u3W7ky27ILGM39eWPvvf14r5/R253SH6iMag/Puvzu+1HTt2hGOL2PpIhC2A2LRpUxizz1Gv\n", + "u3tr4eG/zx4j70iYX0Jui2nq/LwPwne5zmLF5sM8p75g3Yqg847i+R037Pwy7hFhqXORUd7n3bou\n", + "JiEiBQAAEIkLKQAAgEiNS+0Z303cF/2NKusXcu0xuhvlBQiWsssqol1eXg7HPo0Vq64h9WstLi6G\n", + "46xUjhXE+jRnr+JnY+ecrBRb3s/PmTNnwrGlworq4Fy2Xr3k8vg9/d+Honae8Cks+xvk075N+czk\n", + "7ejRo+F4VNLRvRCRAgAAiNTYiJRnxddVRR82bNgQjm0OFB3G8YsI8jAqd/FZ+r3TtmLbcRATre33\n", + "s1rm3bX/PZq8R1zW53l+fr6CmeTPvx+sMN4XyI9rRKrpUSiLUPsFH70QkQIAAIjEhRQAAECkylJ7\n", + "a9as6QipW2FoVpdm3+nWCmx9CNUK/XyKzfq7+IJT//U8WK8eH8och5Sefz3y6BPi+8pMTk4O/fPG\n", + "RR026+yHf03ts+rTHvZZzUph+c/5zp07JXWG3PNOBdfFqJxT8kqtW88mX+Bt6c+qPgdlb8BeJt9Z\n", + "3/6G+kJ6+zvt/16XUVqzZ8+eFWO2e4VfoNFvzzz7W3b77beHMTvPDPK5IyIFAAAQKamiMCxJkrTV\n", + "apX+uAAAAINqtVpK0zSz1xIRKQAAgEhcSAEAAESqrNi8ytSef+yqU4xNn4sV++bdr2mY5+Wuu+4K\n", + "x4cPH5aUXZBqRYWSNDc3V8hc8sZcstnjVz0PP4dBP0NScZ+jmOfFConzKnZv8mtUZH+oOj4vDz/8\n", + "cBirqi9UHZ+X6yEiBQAAEGkkOpuPq127doXjEydOrPi63ekWuZQ6qwWE3+/MzM7OSpJOnjyZ6+Nn\n", + "efHFF8Nx1t2ULcFv8rJyjA7f/qPqTvy+vUC3yIvf39SiNVl7G+bFHq+q6Ig/1168eFFS536WZmpq\n", + "Khz3uwS/jprYndz+xkjtlipZuz/4925evycRKQAAgEhEpBosKwrl2d2tz+/nzfZx849hzfMsWuWP\n", + "y4hI+Tt8a/Lomz3a/OyuBdXavXu3pM4Gh3bXPw4uXLhQ9RSCfvf183fyZUQvqo6QHDt2rOvX169f\n", + "L6l9bpHa0b0m75XYJH5/yv3790vqPI9YhsZ/3nr9De0XESkAAIBIXEgBAABEIrXXJ9uT51d+5VfC\n", + "2PT0tKTO0O1XvvIVSdLCwkKJs+su7+W6Xrf9lXwxd14h1H74FFHW725pgiJTnujO7+V1yy23SOrc\n", + "y+vxxx8vfU6IU+T5pSmsTMCXC9i+sCiHT6vawgfbh09q/13IWgw1LP6SAAAARGpERMrv9m5X+Vbk\n", + "LJWzjN2Wv959991h7Jd/+ZcldV7hHj16VJL0ta99rfA5ZfF3QUUuR+5HVUWWve6QfeQD5bKFAHv3\n", + "7g1j9tk6dOhQJXOywtTJyckwZkvXfSuNMtjn1y+jtyjHOBXgj4K8z79Vt4CoO2sgK7XP8T4iZREr\n", + "yy5J+f2NIiIFAAAQiQspAACASI1I7flQpvXr8GE8C3kXmbKxlN3Xv/71FWO+L0W3PduKZGkJ30Op\n", + "jJ5NwCBscYJPh8/Pz0vK7kJcBjuXWD8rqd1zpuzUnvFFy1V3O68DW5zg02XjlqK3vlRZ+4ai8zNj\n", + "7w2furMSIZ/Cz6uHGxEpAACASI2ISPmrRiss90XV3Zbg58XuhL7zne+EMX9chZmZmXBsd9VZ+z8B\n", + "dXPq1KnM4yocPHhQknT69OkwVlXXezvPUFjeyaJyZZzr64oO6d35iHZWFNc+30V8tohIAQAAROJC\n", + "CgAAIFIjUnu+2HzcCgy78eFLC2uOc+gbGAZp8frivEb/qF76XZRRRLE+ESkAAIBIjYhIIdvLL79c\n", + "9RQAAA3h2waVsSPIuCAiBQAAEIkLKQAAgEik9hrMp/aso7l1ZJbaYVxSgGgqv8EoHZ1RB3aO9akx\n", + "2xC3qv5jvdjnyHYGkaQzZ85UNZ2RQ0QKAAAgEhGpEWGd3qempsLYDTe8eZ3s99yjwBB1sG/fvnBs\n", + "3bxtLyyp/T4+fvx4GPvxj39c0uxQN/be8DtaWPTHL3t/4403Cp+LRfq3bdsWxizSY/uvSsWda+28\n", + "LvX/+1rGIqurt89ijDL7PYvYu5KIFAAAQCQupAAAACKR2hsRFm62EK4fA+rmlltuCcfT09OSpNnZ\n", + "2TBmheULCwvlTgy1ZKm9ycnJMHb+/HlJ0vz8fBgrY+eLjRs3SuosozBFlk5YWtM+L1I7VZeVskuS\n", + "ZMW/zdr42BegN5kV/Evt94lPBVtn+CJKXYhIAQAARBqJkIVdfY7zck5/5W3s7mOcC8ytMNMXZVrU\n", + "bvv27WHsxRdfLHdiY+6FF14Ix7ZPpC8st8/ys88+W+7EUEtWWO4jTtbWpez9VxcXFyV1RvyzIj2D\n", + "8udwW4Dh2ZiPwNk5zBeg21x8dqJbW4azZ89GzrhefBF51nNg75Mi/h4SkQIAAIjEhRQAAECkxAqw\n", + "Sn3QJElbrVbpjwsAADCoVqulNE2TrK8RkQIAAIhUWbF5PxGpn//5n5cknTp1Kox973vfW/F9+/fv\n", + "l9RZhHf58uW+HrvqyFhec7GlrsNEGEfxeckDc8kWMxcr0M274NMev+rnxM+BuXQa5bncdNNNkvov\n", + "OrcWCpL0+7//+7nOZRhNeY3WrVsXjovaS9a3hXjwwQe7fi8RKQAAgEhcSAEAAESqdR+p3bt3S5Le\n", + "9773hbEdO3ZIkp5//vkw9u53v1uSdOLEiTD2jW98I9e5vOtd75LU2XOjTj1uLNTpUyZ59DYB8jTO\n", + "Pc0wugY91164cKGgmYyHrHTenXfeGY7f/va3S2r3qJPa/b983zHbCN12UvC69d66FhEpAACASLWO\n", + "SD3yyCOSpOeeey6MHT16VFJnsdmWLVskSU8//XRhc/mJn/gJSdL999+/Yi6PPvpoGDty5Iikzj3C\n", + "iiqG88ru7gvEWLNmjaTsO0DPinf9fmZ+jywUzxbx+O7QdYrCV2316tXh2HfVRrk2bdokSfqFX/iF\n", + "MPae97xHUueOFrYQ67HHHgtjX/ziFyVJc3NzQ82BiBQAAEAkLqQAAAAi1Tq1Zyk9n9rLcuDAAUnt\n", + "XkpFsEI1XyRoaQeffrCNV30PijJSe2WytIvU/t2XlpbCGEXu9WKhb0vVSO3PihVbStLFixcLn4vf\n", + "XLUbNtyuxvT0dDi23jk//dM/HcasfOJzn/tcGPvnf/7nQubi3yt2XKf3w8TERDj2Rc0ol523Tp8+\n", + "HcbsfepTrva3ypfB5LVhMxEpAACASLWOSPXLF5QV5Stf+Yok6e/+7u/6+n5fiDhqXn/99XB8/vx5\n", + "SUSh6szunO+6664wZgXEPgpVRkRq0IjCqEVz684Xlu/Zs0dS57LyzZs3S5K++tWvFj4Xf14v4xw/\n", + "KKJQ9WDvjb/8y78MY7aoxXZSkKRVq1ZJ6swq5bXXMBEpAACASFxIAQAARBqJ1F4ZBk1djXJfER8O\n", + "7dUPCNWzzbwff/zxMGYF6GWnoAf9XAzSXXhUWbqt20bsebHFMpL05S9/WZL0L//yL2HM5vDNb36z\n", + "8LkAsezvUll/n4hIAQAARCIi1Se7g7fi6nFW9yJQZDt06FDVUxgY769y+WjzX//1X0sa7eg6kAci\n", + "UgAAAJG4kAIAAIhEaq9P/XZkHjdWrEz4H0WwDcmlduHouPWW6rfI3LrV59Ubh8800B+uDgAAACIR\n", + "keqT7cnjI1MUwra7xXL3iiJMTk6GY2uFMG4RqX7lFYkCMBgiUgAAAJG4kAIAAIhEam9ApPM68Xyg\n", + "SNu3bw/Hc3NzFc4E17Nu3TpJpFwxvohIAQAARCIihaG8/vrrVU8BI2jbtm2SOguoFxcXq5oOrjE7\n", + "OxuObaFJGRGpG29s/8m6cuWKJGlmZiaMLS0tSeK8hHIRkQIAAIjEhRQAAECkRqT2rFeR1C5stJ4y\n", + "knTTTTdJanc+Rnk2bNggqTMFw8bOg7NNsaX28zfKPcuyUjSedek+d+5cGLt06VLxE0Owdu1aSdK+\n", + "ffvC2NTUlKT2eViSvv3tbxc+l40bN0qS7rzzzhXz85+ThYWF6MdYs2aNpN5/R+zx/HNg579+36N2\n", + "3sRoICIFAAAQqRERKV84uHXrVkmdV/R2RxsTkbK7mn73s+rXxMREOB7lO+lXX31VUv7PX11ZdLRX\n", + "Mavd3U5PT4cxW8rvo0t2d3v69OkwZhGpUYtCeVlRKM+Khi9evFjGdEaCvZfyet/YZ/q5554LY0eO\n", + "HJHUjhj67yvShQsXJEnHjx8PY7YPo+06MSzbN9T/HbG/M37nBhvz53iLSNnP8HwRvp0v7e9OXfnf\n", + "Y8eOHZI6s0BnzpwZ6Of5v9e7d++WJD3//PNhzN5PTV0kQEQKAAAgEhdSAAAAkZIqNrpMkiRttVql\n", + "Py4AAMCgWq2W0jRNsr5GRAoAACBSZcXmVUak/GP3Ow9rsWDFglXOpSjMJVvT5zJO792q5+Hn0O9c\n", + "9uzZE46t0PnUqVMrvi+mHUaTn5csk5OT4diKn2MWGfU7F3tt3vve94axF198UZL06KOPhjFrz7B3\n", + "794w9vTTT+c6lzI0eS6++H/nzp2SpB//+Me5zuV6iEgBAABE4kIKAAAgUiP6SPXL+opI+fUWMdYX\n", + "KO/0SAzr8eG7Q3fbMLTI5wX153vgoD6sS/gtt9wSxqxfku/NZCkL39vn2LFjZUyxdgbtXzQs66zv\n", + "03QnT55c8X2WZrT+Zyif7zRvqdjNmzeHsR/+8IeFPTYRKQAAgEiNi0hZh1TfAdW6JBcZbbE7RS/v\n", + "TsL9sghDv5EGolDjrYoWJ+jNohc+2pEV0bBO93Xvhj2K7Ln30Qzf1d3Y34Bh9vqLYX8PfTRmcXGx\n", + "1DnUhd+X89ChQ5LK29OQiBQAAEAkLqQAAAAi1Tq1Zxu+zszMhDEr9vb9RF544QVJnRu/5s0KPv0G\n", + "xKO8qWwTWVH9z/3cz4Ux2yj43/7t38KYHZPyQpWseLzfjZlHZWNw2/hbauYmtVWfN2677bZwfP/9\n", + "90vqXGxkm0z7TYHHgd8I/bvf/a6kuB5jMYhIAQAARKp1RMqiCXfffXcYyyosLzISZXwkCvVky8l3\n", + "7NgRxu69996Or0nlRDCNRVWldgTClkpLnQWSRdu/f384tufj+PHjYWx+fr60uaAdjfEdy7vxnZub\n", + "fD7yBcC2iIfofv98ZNKeP78YynYyGGdlRaIMESkAAIBIXEgBAABEqnVqz1IwPkxn4e28NiNsItsg\n", + "07qtS+0UUb/dzvO2e/fucGz9bnzaqIxC2YMHD0pqFxpK7XSVL7wsI6VnfH8Xe+9ab5qy+Q73liJf\n", + "v359GLPXbVSKmuvO0ln9piGanM7z/O4QpPQG58+rVuLiz/U+BYxyEJECAACIVOuIlN25WKQBb7Ln\n", + "xUek7M6uzCiU5++C7rjjDkmde4h961vfklTO/LJaHVTFR79sn7B+l7vnzUfl7D3klwwDZajqHFWk\n", + "bdu2SepcXLK8vCyp2G7ntmDB78NIRLl8RKQAAAAicSEFAAAQqdapPWSz4tSye2V0c/To0XBsaT5f\n", + "SFqnuZbJ94yq2qgUKwN14DeR3rVrV8d/pfbCnyJTe3v27JHUuZDEPudzc3NhrMwFNuOIiBQAAEAk\n", + "IlLIhY84HT58WFLnnlq2P5UvkB/XKBWA5vN77ln03S/eKKq1Q5Ik4XjTpk2SpFtvvXXFvHzEjIhU\n", + "sYhIAQAAROp5IZUkyReSJFlIkuRJN9ZKkuR4kiT/fvV/P+e+9qEkSV5IkuTZJEl+tqiJAwAAVK2f\n", + "1N5fSvpTSf/djaWSPpum6Wf9NyZJco+kX5d0j6Rdkv4pSZI70jSlfe0YsZSeDy1v3bpVUucGraT2\n", + "gPHjU1M+PdY0/vy1tLQkqTO1V9TiDv+cWc+o1157LYzZzhd+DMXqGZFK0/RbkpYzvpRkjP2SpL9J\n", + "0/S1NE2PSDoo6Z1DzRAAAKCmhik2/9+SJPmfJD0u6ffTND0raVbSY+57juvNyFRu7G7GRzusu6vf\n", + "wwnVsc7Fk5OTYcwiUVXtMwc0gZ3XfNTBltH7sSa3sti8eXM4tr3ims7Oa/7vUhnRNtslYXFxMYxZ\n", + "YfmBAwcKf3y8KbbY/POSbpb0Nklzkv64y/c2N3YLAADQRdSFVJqmp9KrJP3faqfvTkja475199Ux\n", + "AACAxnnkkUe6fj0qtZckyc40Ta1t6i9LshV9/yjpr5Mk+azeTOndLul7MY/h+d5D1i/Db9JoqSS/\n", + "KSvK5cP1loqwjTwlaffu3ZKkEyfa19WPPeazwBgn/jNt6Xr/mbaURZOLkftlCzEk6a1vfaukzoJs\n", + "c/LkyXD83HPPFT8x9M06i/veUbZJeZGOHDnS8d+y2Dl+XDY9f+CBB/Too49e9+s9L6SSJPkbSe+R\n", + "NJUkyTFJH5P03iRJ3qY303aHJf3PkpSm6TNJknxJ0jOSrkh6fzoOZ0IAADCWel5IpWn6GxnDX+jy\n", + "/Z+Q9IlhJnWtDRs2hGPbt8gXLQ+zzNOiJv5OYnl55SJFW9Jvhe3oNDMzE46tyPzuu+8OY7fccouk\n", + "8Wt54KMNWe+rceU/RxbNvHDhQhgbp/sv/76wSJPfFcDOb6OyUKPfRUG+VYqdn30xt0VD+o2K+H+b\n", + "N2tD4KOqddpnM29ZEdNxRmdzAACASFxIAQAAREqqCKEnSZK2Wq3SHxcAAGBQrVZLaZpm5jSJSAEA\n", + "AEQaprP5UKqMSPnHrjoyVtVc/PJzK2b96Ec/WslcsvAaZWMu2ezxq56Hn0MT5+ILsq2AOos/f/S7\n", + "gKTJz0svtmjp3LlzYazfIvgmPi9WbL5v374w1q0Fw/79+8Pxiy++KKlzgdcwc7EC/yL3Fuw1ByJS\n", + "AAAAkbiQAgAAiFRZag/10SvEitEzMTEhqTMcXmRoHM3QLZ0ntTta23+lcnrDWcoxa372Xpba/cny\n", + "nvILYpUAAB2fSURBVJPvabVx40ZJnWk823x5XPoMWmrX+jpez/bt2yVJe/fuDWOnTp2S1P/G275n\n", + "VdbiuDqct4hIAQAARGpcRMo6/t50001hzPbaK9ttt90mqb3PkiQdOnRIUjn7LA1j3DqMo7OQ+Pbb\n", + "b5fUeYdvRaBVfZ4grVu3TlLnXXad9jMbtJt4Xu644w5J7WiQd/r06XBc1J5zPiqS1WF+XCJRplfk\n", + "0likzu8TOWhX9LxaNNnfaZtTnohIAQAAROJCCgAAIFLjUnsWQvXphzL6SBhfZHnrrbdKaqf4pHbI\n", + "s+6pPYwfH47/0Y9+VOFM4PkyBSvO9Ru1WyrixIkT5U6sT5aqyXuXDHsuJGnXrl2SpN27d4cxe7xv\n", + "fetbYazflNOgfN+sfouk0d6g2grMpeJeo15mZmYkSZs2bQpjVs4wLCJSAAAAkRoXkcpS1fJHX7xr\n", + "6lQYCsSwCK9Uj6XFo87u2qV29MnftS8uLhY+B4u0+6hSvwXURe3XaguLpPb78PDhw2HMonZWoF8k\n", + "P5c6sWigj5hVtSCgm6wC/bxYV3n/9zgrevvcc89J6owA54WIFAAAQCQupAAAACKNRGqvTD5c+u1v\n", + "f1tSu4hNkp599tnS54Q4vifNhQsXKpxJvfjnhUUT5bJu2b5rdhmsc3eddjmYm5sLx5b+9D2jpqam\n", + "JHUW5luX87wLwut6frC0alUF3LOzs+HYirj938hjx45JKrZvob02/rx1yy23SGr3dfR8Kr0bv7Cs\n", + "FyJSAAAAkYhIDcHujvxdUlP47rK+uHic1PUusyrWzsMXGRORGg/93qVXJescu7S0JKmz2NyiIrQo\n", + "KIfvWL68vCyp/J0R7L2bd1f7QYr1iUgBAABE4kIKAAAgEqm9MRXTLwajx4pzJWn9+vWSpIWFhaqm\n", + "A/TNyhM2b94cxiwdMz8/X8mcxtk4b3ZORAoAACASESkQkRpjvijXCketaBSoM79nGsaXtb/wC6jK\n", + "XkhERAoAACASF1IAAACRSO2hFBZ2nZ6eDmOnTp2qajrIYH15gLqxLtN+c17rZO07m5OWHj8XL16U\n", + "VG2ql4gUAABAJCJSOVi1alU4vummmySN91LQLPv27ZNUThHgli1bwvHZs2cLfzwAxbLok9/X1Pba\n", + "886fP1/anFAvVb72RKQAAAAicSEFAAAQidReDnwfJlJ62S5fviyp2A2ed+/eLamz0zGpvXzccEP7\n", + "nmvt2rW5/mwrJB5kk9Drse7skvTSSy8N/fPyYhuDv/HGG2HM5upLA2wDXr9ZtH12PHs9/M+zBR1+\n", + "14JB1bVMwQqJb7755jBmz8FTTz0Vxubm5sqdGGrD95Ea5jMQg4gUAABAJCJSKEUZe18dP35cUufd\n", + "SNad+6iwonofLbLl4Vu3bg1j1r38yJEjff3c7du3h2Pbi88vMc/7bi+PSJSpUxTKs0iTL4h99dVX\n", + "JXVGUC3yYsXVUjuK6yPfFsVbXFwMY3m8Lv4xXnvttaF/Xl6OHj3a8V+pHeWr0zxRnbxb6/gIVy9E\n", + "pAAAACJxIQUAABApKbsoS5KSJElbrVbpjwsAADCoVqulNE0z831EpAAAACJVVmw+bETKd6+2AlO/\n", + "dNcKObOKjP1jVx0ZYy7Z6jqXhx9+WFL+Bde21Fxqv3d7zaXf58UKxW1PqmFZEebHPvaxgedSFHv8\n", + "qufh51CnuXz2s58NY1kdoIcp3Lb3l/9M2KIHv/edvV/q9Lwwl05NnIu912xBh9R+j2f9/e/3XJs1\n", + "l+shIgUAABCJCykAAIBIje0jldWxmn4iKFpRizP6DTHH6PdzYT2Mem3+mcdz4PtSWc+kpaWlMDZO\n", + "n2VLq0nF/d69XtNhHjcrZVzXfl4YPfbe9X2k9u/fL6mz0/3CwoKkznNtXn0GiUgBAABEamxECriW\n", + "LTZ429veFsYuXLggSXr++ecrmVMdvPLKK319X6+oRZ7uvPPOcGx7JPp9GA8cOLBibFSNU/QN+bJo\n", + "5q5du8KYFfifO3eukjmVzaJJPvpk541t27aFsR07dkjK3l2AiBQAAEBFuJACAACIVOvU3ihvODsq\n", + "rKeQ9fLwx2WHlq0/iN909+abb5bUTvFJnSHgceI3N7Zi7zLTeV5WOsu/h9auXVvmdPpSxvnIeuHY\n", + "psRS53sX1bNz3q233hrG7FznN5Eug70XZ2dnw5ilsB577LFS51I1v+H2yy+/LKm9kf31+IUewyAi\n", + "BQAAEKnWEak6RaLsDvnKlSthzI793aP/+jiwpfCXL18OY/64THYXYoXKknTvvfdKkvbt2xfGxi0i\n", + "tXfvXknS+973vhVjn/nMZ8LYiRMnSpvTE088seLYR6Gqeg91U8a+pPY+9eeUp556qvDHRf/sfXDw\n", + "4MGKZ9KOwnz3u9+teCbNlNdCDyJSAAAAkbiQAgAAiFTr1F6dWKGp3xjRikDHLZ1Xd0eOHAnHVky9\n", + "c+fOimZTvcnJSUnS/fffH8as8+9dd90VxspM7WWpYzrPKyO19+yzzxb+GADyRUQKAAAgEhGpPl26\n", + "dKnqKSDCmTNnOv47jqyY+/Of/3wYsyjq9773vUrmBABFs1YVUrERZSJSAAAAkbiQAgAAiERqDxhx\n", + "1o+NXjMYhC2ssf5sQNOUsUBEIiIFAAAQjYgUAGCFvLo+A2Xw++aV/d4lIgUAABCJCykAAIBIpPYA\n", + "ACusWbNGUuduDpYy8akT+/rFixcLn8srr7xS2GOg2TZu3BiOy+4bSEQKAAAg0khFpNauXRuO675v\n", + "F4ozMTERjl9//XVJ3MkCg7I7/FtuuWXF2PHjx8PYwYMHC5+LfY6B66ly9woiUgAAAJG4kAIAAIjU\n", + "iNTeli1bwvG2bdskdabxzOLiYjgmtTe+Xn311XBsqYgbb2y/1W0D6rK63qIa1lcmr54yds7xxdeW\n", + "Mq77puYxPXY2bdokSZqZmQlju3btktTe9FqSnn766Tym2JV/PKBuiEgBAABEqiwidcMNN4Q9wHrZ\n", + "vHlzOJ6ampLUWXy4vLwsSTp16lSOM0RT+bvXrCLzcY1EVdn5tyw33XRTYT87SRJJ0oULF8JYUyIl\n", + "Ma/3wsLCirGTJ09e92solkUIvfPnz/f1by2T4//mWuTe3teIR0QKAAAgEhdSAAAAkZIq0hxJkqSt\n", + "Vqv0xwUAABhUq9VSmqaZeVAiUgAAAJEqKzbPMyJlxXK9omuTk5OSpA984AOFzCOGf/xh5jI9PS3p\n", + "zSJ+M2hBaF5zyUPec/EFlYNGYUf5eRlGHefS7zxWrVq1Yiyv7tmDzqVIzCXbqM3Ft6iw81vM4qtR\n", + "e156sVYmL7/8cl9zuR4iUgAAAJG4kAIAAIhU687m99xzj6TOXkBLS0uSOsPw69evl9Q7leX7v4yC\n", + "DRs2hOP7779fUucGovR6aRvX3lFNZR3p/Xt8bm4ut5/vO933u6G1pc377X+XlzIft669xnbv3i2p\n", + "c8cK+1vge4f5XQ3GiU9V23t7mHKGGPY61P018OcUO8/0Su31QkQKAAAgUq0jUqdPn5bUeZdkV9b+\n", + "arvfffXqdIeVB38n/f3vf1+SdObMmaqmU0tVRREwuF/91V8Nx3v27JEkffWrXy3ksfqNQvkiXjsP\n", + "HT9+vJA5Se336zvf+c4wZvv4PfHEE4U9rvH7CNbpfGnRjv3794cx6+rtI+/2N6MpHefzYh3npXaU\n", + "xe8Icvbs2UIe10cDLSuSFTmen58Px/1+9opy8eLFcJzX3wUiUgAAAJG4kAIAAIhU69Te4uKiJOm2\n", + "224LY3v37pUkHTp0KIz5sOE48aF3UnrZSOkNzqd3hi3CHIT1QpPa4Xf/OS+TpZDe8Y53hLETJ05I\n", + "Kja1Z+/Xxx57rLDH6MbSiHWT9T6w9wib1Xcqc1HVfffdF45/8id/UpI0Ozsbxo4cOSJJ+vKXvxzG\n", + "inq9JiYmwnG39/HatWvDcV5pRiJSAAAAkWodkbK7M3+leeedd0riLqRurNBQkvbt2yepXQAvFXsX\n", + "P67yLqTftWuXpOIKU3v5/Oc/X8njZrFInL+zteLmUZZXd/du1qxZs+K43+e2qgglsvno03vf+15J\n", + "nRmkJ598UpL04x//OIx94xvfKGQut99+ezi2RSK+7YNF6p555pkw1u9CtV6ISAEAAETiQgoAACBS\n", + "rVN7xhfPWWjXhwpRPd+bw/rtbNmyJYyR2stfHik9nza3nzduPXiyWG+ir33ta2HMd0MfVdaDSGp3\n", + "qM4r/WH8+7buXbCzWLFy03+PPPgSGysJ8M/F1NSUpM4C76L4RTJ33323pM7P7FNPPSWpXRKRJyJS\n", + "AAAAkRpxi+WjT0Si6un555/PPEa9+WLqui59L4K/U+03AldmpK7sfdJMGcXmvm1Lnbqn98uiLD7i\n", + "btGOcWPF5JL093//95KkAwcOhDF7H/vO60XtyXf48OFwbJ8ZH021v0tFtHQhIgUAABCJCykAAIBI\n", + "jUjtAUCeKKjP9tJLL1U9hUxWBO87UVdV4L20tCSpc4HNuPLvl69//euSpB/+8IdhbOfOnZI6Xyvr\n", + "8XTs2LFc5+I3r/bHZSAiBQAAEImIFADUTJkF5k1giwPqUJxuBcx5t4VoOovyzs3NhTGL2llkSurs\n", + "bD8qiEgBAABE4kIKAAAgEqk9AEA0KwT3O1DkzbpWb9q0KYwtLy9LGo/NpJvKUrF+cYe9bqOEiBQA\n", + "AEAkIlIA0IetW7dKGs076mFs2LBBUrERKeuGvW3btjBmkTC/20URXasxGHutpHYXeGsZIY1mBJGI\n", + "FAAAQCQupAAAACKR2quRVatWSSpn41DgeiYmJsLxOGxk3O8mquvXr5dEak9qp9Wkzm7jRTly5Iik\n", + "zhSR9SNq4vnSzvWjyPf6svPHKKbzPCJSAAAAkSqLSK1evbpnl1q7A3zjjTfC2CgXEzbxzmrc9Bu9\n", + "KMMNN7x5H+Q/H8OwO/zVq1cP/G+TJJGU3ZHb333b85fX59gedxj2PPZy/PjxoR9rVFiBudTZybpo\n", + "fn+7Ju51Z3/TRrG7t/HngDNnzgz98/xnfJiO/3mfLzt+du4/EQAAYExwIQUAABApqWJzzCRJ0lar\n", + "VfrjAgAADKrVailN08xaAiJSAAAAkSorNn/44YeHKhwbho+GVR0ZYy7ZYuZihZwvvfRS5XPply0j\n", + "94Wz3T4XTX+NimKPX/U8/ByYSyfmkm3QufjFEdY53C/eGKbDfJOflyL1mgMRKQAAgEhcSAEAAESq\n", + "LLW3Zs0aXb58uaqHxwi6++67JUnz8/NhLKv3z+bNmyVJ586dK2diXRS50Ws/bryxfQq4cuVKaY/n\n", + "u6fXpeuxpYal/NPDTeZTSUX04MFg/GtgvQftnCaVe07x7w3rETeOf9eJSAEAAESqLCKVR0diwDt4\n", + "8GBf31eHSFRdlBGFynq8Ue7sPIx7771XkvTud787jD355JOSpMcee6ySOfmoZR06+lfNFoj4RSFV\n", + "dVk/ffp0JY9r/HtjdnZWUmen+1HeicTrGpFKkmRPkiSPJEnydJIkTyVJ8oGr45NJknwzSZLnkyT5\n", + "RpIkW9y/+VCSJC8kSfJskiQ/W/QvAAAAUJVeqb3XJP3vaZr+D5LeJel/SZLkbkkflPTNNE3vkPTP\n", + "V/+/kiS5R9KvS7pH0n+R9LkkSUgfAgCAkdQ1tZem6byk+avHF5MkOSBpl6RflPSeq9/2RUn/n968\n", + "mPolSX+Tpulrko4kSXJQ0jslrYhJj0vID+U5e/Zs1VNAnxYXF3P5OT61MKw6FJhfunRJkrR27dow\n", + "5o+rQDqvU9ULROrE+lhJ0smTJyVRbN5VkiT7Jb1d0r9JmknTdOHqlxYkzVw9npXkl0kd15sXXgAA\n", + "ACOnr9u5JEk2SPqypN9J0/SCLxRP0zRNkqRbi/Lo9uV2t1l2QSyAZqhqd4SiWLTDL5wgAoK6OnPm\n", + "TDgex0iU6RmRSpJktd68iPp/0jT9h6vDC0mS7Lj69Z2STl0dPyFpj/vnu6+OAQAANM4jjzzS9eu9\n", + "Vu0lkv6bpGfSNP0/3Zf+UdJvXT3+LUn/4Mb/xyRJbkqS5GZJt0v6XsS8AQAAKvfAAw90/Xqv1N5/\n", + "kvSbkp5IkuTfr459SNKnJH0pSZLflnRE0q9JUpqmzyRJ8iVJz0i6Iun96RCxd1J69Tcz82Z5nO+j\n", + "Uoei3W6sG28ZXZq3b98ejnfv3i2ps9v6qVOnVvwb9M86O48Ke2+eONEO5C8vL0uSVq1aFcZG7fdG\n", + "sVavXi1Jeu2113L9ueOczvN6rdr7tq4ftfqZ6/ybT0j6xJDzAgAAqL3KOptjNNjdcpOWSJcRibJ9\n", + "p+64444wdvPNN0vq3BfLijWJvkKSFhYWOv4L5CHvSBQ60SwTAAAgEhdSAAAAkUjtYShNSumVKavj\n", + "thVm+q9NT09L6kzllJF6BIBhrV+/Phxv3bpVUnvBhNQ+l83Pz4exUSxjICIFAAAQaWQjUkUt98yy\n", + "bt26cGxX236pclFLRK/pMF/IY2A4/nWx94Ef27hxo6T2+1WSjh07tuL7AKBu/N+gXbve3A3OR5zO\n", + "nTsnqTNyZWOjhIgUAABAJC6kAAAAIo1saq+olN6aNWvCsRXXWUhTaoctX3nllTBmqZq8bdu2LRzb\n", + "xqa+0M/md/LkyUIeH9d36dIlSZ0dqO29s2XLljA2MTEhqXPzzxdffLGMKQLAUPyOFnau86UsVuLi\n", + "z3mk9gAAABCMbESqKL5obtOmTZI6C4XtaryMq24fCbMrfx+lstYERKSq41sZWKuDffv2hTHbd+/l\n", + "l18ud2IAkCPbzcHv3GB/G/3+oqOIiBQAAEAkLqQAAAAiVZbaW79+vV566aUV477/ki/UrQs/PysU\n", + "9t29T58+LamcVI31IJLavax8Ud+PfvSjwueA7nzHcuvuu2HDhjC2uLgoSTpx4kS5ExsDlob3n0Xr\n", + "Kk9H/vqy3kR59VGzRR5+ARDyMTMzE453794tSdq+fXsYm5qakiQ9/fTTYcyOR6lPHhEpAACASJVF\n", + "pK53d1DHKJRnEQR/XFWH8e985zvh2KJjPmJ2/vz5oR+D7unDOXr0aDi2pcLf//73w5i9Rnm8Vuhc\n", + "+GEtKPz7lkjU4PxzagXFfol73udsiyT6n2vtbGL2abP5E5HKn19U9fjjj0tqL6qR2lEq/3dzFP+O\n", + "EJECAACIxIUUAABApKSKMFuSJGmr1Sr9cQEAAAbVarWUpmmS9TUiUgAAAJEqKzavMiLlH7vqyFiR\n", + "c7Eiy373HRyV5yXvFhqj8rzkrY5z6Xce9913Xzi2AuZnnnlmxff5vTWtS32vz9OgcylS1lxsP07f\n", + "dT9vtkjFP38f/OAHV8ylGytsl7ovEvC7TWTt95al7q9RVWwOn/rUp8JYr+ey6LnU6Xm5HiJSAAAA\n", + "kbiQAgAAiMSmxX2yjRjL2Ix4GH7DSFtI0G9qr6767XRsKT3f+6qbflMH6K2MdFGe/GtvG337z/by\n", + "8rIk6Y477ghj9h7JSgE2SRmvkX1Wh0kL+X5E3Tr/33777eHY+rEdOnQo+nHrznoGSu1eaXnr93Xz\n", + "51r7TI1jvy4iUgAAAJGISPWpqoK7Qfm76l27dkmSLly4EMaa2FW23zn3W1hu+60hP/1GOSz6Y3tS\n", + "VsW6MF9PVgfvY8eOFTonSVq7dq2kzgLqs2fPSqr/rg95s6jg9dhz5SM09lyNsqKiUDEsEi1JW7du\n", + "ldQ5v3HZsYGIFAAAQCQupAAAACKR4+hTEwvoFhYWJBWbzrNiQ1/waeH1U6dOFfa4w4jZ+DSWhbul\n", + "3qmKPPki0KmpKUmdaaqXX35ZUrnPhST95//8nyV1FgP/4Ac/kNSZznrLW94iSfr3f//3MFbmZ9AK\n", + "y5999tnSHlNqv0bDlBL4TYazWCqsTikiz967vd6b9hwtLS2Fsaak9nyvuybz6eb5+XlJ7fS91LxF\n", + "KLGISAEAAEQiIjXCyog2WOTgd3/3d8OY3SE+9NBDYayJRe55KDMK5fmC+k2bNknqbPFgr4dvl2F3\n", + "j0XO2d6Ts7OzYcwiUn5+o7YgwH6fMj6TvT5rFqF88cUXC5vDhg0bJEkXL14c+N8Oeq54/vnnB36M\n", + "qo3ywoGqF5JI0rve9S5J0rp168LY3NycpGKizESkAAAAInEhBQAAEGm04ucF6re79rg5c+aMJGlx\n", + "cTGMWQ+ePXv2hLEi0wjX8oWcN998c8ecJOnAgQOSRvu19MXm9tpk9XTxfcfKKIC1XkxZKS7fgf+H\n", + "P/yhpNFJgZRZ1N/rscp438ek9K61cePGcGyLNmyRhNS92znGmy2k8Oe0Ihc/EZECAACIRESqT6Mc\n", + "vRjG8ePHJUkf+9jHwphFEara489HMayru49IjcNr6SNS/XYXLiP6YwsRerUysMiDFS1LnR36ES+P\n", + "aFEZ/Dzt/dzENjQo3xNPPFHq4xGRAgAAiMSFFAAAQCRSe8hFXTd1tu7u48an9qxj+EsvvVTVdALr\n", + "MdMrRWOp2C1btoQxm/+od0kuWlNSe/49QkoPdUZECgAAIBIRKWAE+YJ6K9iuQ0Sq34Jx60jsO69b\n", + "q4Z+i+eRrapFIOPAL7cfldYd6I2IFAAAQCQupAAAACKR2gNGkC/O9d2g68I6VUvtTZJXr14dxmxT\n", + "Y9tgV5Lm5+dLmh0Qx7+HLc3nN+PGaCIiBQAAEImIFDDi6lic7e/Sb7jhzfu5iYmJFWM+CmVd0YG6\n", + "qmsbGBSLiBQAAEAkLqQAAAAikdoDULqsnlY+3Wf9pv7/9u4nNI4yjOP490djCf4BMSZRa6A9VLBe\n", + "mksRiqS5lPRi9eIfEHoQEfyLp9qL5uhF8SB6MUoRqRSkpRexVXLwZAlEW02LFgy0UtNAzEFyycLj\n", + "YWZ0stmVOtmd6ez+PpedfWeZeZMnz87DO5P3zWZCv1n5h31vxfmS8vMMZbcyt7IYc34G+2w2eM8C\n", + "blYuj0iZmZmZFXRLj0hlD5xmrwCNRqOq7phZGwMDyVfJVvIzP03D8vIyAGtra//rGJ0ahcpGtrZy\n", + "vPzo0/DwMLDx95PtLzIilU0LkZ89O3vQOT9K1crg4OCGz3dDtkbi6upqR47XiXi0MjIy8s/2ysoK\n", + "UM41ZmhoqCPHyVYtaDXFgqddKI9HpMzMzMwKciFlZmZmVpDyi5uWdlIpJiYmmJycLP3cVp3Z2VnH\n", + "vI843v3HMe8v/RTv6elpIqLlfXOPSJmZmZkVVNmIVOknNTMzMyuo3YhUJYWUmZmZWS/wrT0zMzOz\n", + "glxImZmZmRVUSSElaUrSZUm/SjpaRR+suyQtSrogaV7S+bTtHknnJP0i6ayku6vupxUn6RNJS5Iu\n", + "5traxljSsTTnL0s6WE2vrag28Z6WdC3N83lJh3L7HO8akzQmaVbSz5J+kvRa2u4cb1J6ISVpG/AB\n", + "MAXsAZ6V9HDZ/bCuC+BARIxHxL607U3gXEQ8BHybvrf6+pQkj/NaxljSHuBpkpyfAj6U5BHxemkV\n", + "7wDeS/N8PCK+Ase7R6wDb0TEI8CjwMvptdo53qSKH3IfcCUiFiNiHfgCOFxBP6z7mv/D4XHgeLp9\n", + "HHii3O5YJ0XEd8CfTc3tYnwYOBER6xGxCFwh+S6wmmgTb9ic5+B4115E/BERP6TbfwGXgB04xzep\n", + "opDaAVzNvb+WtllvCeAbSXOSXkjbRiNiKd1eAkar6Zp1UbsYP0CS6xnnfe94VdKPkmZyt3kc7x4i\n", + "aScwDnyPc3yTKgopz7fQH/ZHxDhwiGRI+LH8zkjm3fDfQg+7iRg7/vX3EbAL2AtcB979j8863jUk\n", + "6U7gS+D1iNiwwrZzPFFFIfU7MJZ7P8bGKtZ6QERcT1+XgVMkQ7xLku4DkHQ/cKO6HlqXtItxc94/\n", + "mLZZjUXEjUgBH/PvrRzHuwdIuo2kiPosIk6nzc7xJlUUUnPAbkk7JW0neTjtTAX9sC6RdLuku9Lt\n", + "O4CDwEWSOB9JP3YEON36CFZj7WJ8BnhG0nZJu4DdwPkK+mcdlF5IM0+S5Dk43rUnScAMsBAR7+d2\n", + "OcebDJR9wohoSHoF+BrYBsxExKWy+2FdNQqcSvKQAeDziDgraQ44Kel5YBF4qrou2lZJOgFMAPdK\n", + "ugq8BbxDixhHxIKkk8AC0ABeCi+rUCst4v02cEDSXpJbOL8BL4Lj3SP2A88BFyTNp23HcI5v4iVi\n", + "zMzMzArqizkezMzMzLrBhZSZmZlZQS6kzMzMzApyIWVmZmZWkAspMzMzs4JcSJmZmZkV5ELKzMzM\n", + "rCAXUmZmZmYF/Q0kXnLFpKb3UQAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['conv5'].data[0]\n", + "vis_square(feat, padval=0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The fifth layer after pooling, `pool5`" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJMCAYAAADaNPObAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XmMXfd14PlzWPvG2lhciquojSIVWZsj27GgcqA4GseQ\n", + "nX9sB4ghpNMBgo67Y4+nZSuDNKQ/0tM20OMMMsgf44kNJZioo0k7XgYtWEuz5FYUWZJlmSEliqTF\n", + "EllkVZFVxdr3qt/8wZJC1u+U9OPv3nfvfa++H8CweHiXU/fe997hrXPPU+ecAAAA4NpsyjsBAACA\n", + "ckQRBQAAEIEiCgAAIAJFFAAAQASKKAAAgAgUUQAAABFSL6JU9QFVPa6qJ1X1a2lvHwAAoAg0zTlR\n", + "qlolIm+JyP0ick5EXhGR33HOvZnaTgAAAAqgOuXt/aqInHLO9YmIqOp/EZHPiMh7RZSqMt0TAACU\n", + "DeecWvG0i6idInL2ij/3i8g9axdS1XeTElWVhoYGb0MzMzNe7N31rhR6J81aztpeFpLk0tHREbSc\n", + "dfzm5ubeN5dHH31UHn300bI8LmlLkstdd90VtNzPfvazkueStqLkklce1dX+W+bi4mKquVj7WFpa\n", + "Clo37eOyaZPf8bGyslLyXD7+8Y+/79+/8847snfvXnnzTf+XHCMjI6nmkrbQXGpra71YfX29F2tu\n", + "bvZiFy9eDNre1NRUUC5NTU1e7F0LCwvvbXt6enrd5T5Ikc/R++WRdhEVVNFcmSBfOwMAAIqit7dX\n", + "ent7g5ZNu4g6JyK7r/jzbrl8N+oqa+9EAQAAFEFPT4/09PS89+fHHnts3WXTLqJeFZEbVXWfiJwX\n", + "kc+LyO+sXWjtnSjrV0+W0LtWNTU1QcsVnVVgWrfXGxsbvVhVVZUXs36dd6UrLxogbTfffHPQcm+9\n", + "9VaJM4kX+mu1ou/DsmfPHi9mvQdZvyoKfQ8Pdccdd7zv33d1dcmuXbvk/Pnz3t9Zv84rRwsLC0Gx\n", + "iYmJoO1Zv3YO9UG/pkuy7XKXahHlnFtS1S+JyI9FpEpE/oon88oHRRSAcrBr1668UwBEJP07UeKc\n", + "e0pEnkp7uwAAAEXCxHIAAIAIFFEAAAARUv91XhFYc1bKkTX/w5rXYc36yKK5cvfu3R+8kIicPXv2\n", + "gxdKyGq4t4TOuEniyJEjXuzGG2/0YgcPHvRib7zxRklyylpdXZ0XC+1jKXJjObKZ3XP48OGg5QYG\n", + "Bkqcif2ea33GjI+PlzyXvFifRR/96EeD1n322We9WCWNNuJOFAAAQASKKAAAgAgUUQAAABEoogAA\n", + "ACJURgf2Glk0D6NYzYFW46MldLpvEh/+8Ie92HXXXefFrOb/Smkst66NJF9OmqbQByLGxsa82OTk\n", + "ZNrpFMaZM2fyTuE9R48eLfk+Qr9c2fr2B+tbImZnZ72YNWG8HIU+uLMRcWQAAAAiUEQBAABEoIgC\n", + "AACIQBEFAAAQoSIby2tra/NOIRVWE6vVnJtXI31/f38u+7Vk0TAeympyt6Y8W42olcJqqH3ppZdy\n", + "yKRy0eybDes9d25uzotVShO5ZXFx0YtZ38xgHYO2tjYvdunSpXQSKwBehQAAABEoogAAACJQRAEA\n", + "AESgiAIAAIhQkY3l5ThV+MCBA16sqakpaN3x8XEvNjMz48W6u7uvPTFcM6sJ02qkHBgYyCKdXNTV\n", + "1Xkxa5K7xXpIIM1p2mfPnk1tW3mqrq7It+/MWFP1renkra2tQetWcmP50tKSF9uxY4cXs46V9QDN\n", + "yy+/nE5iBcCdKAAAgAgUUQAAABEoogAAACJQRAEAAERQq0GupDtUdVnvEwAAIIaqinPO/9oJ4U4U\n", + "AABAFIooAACACBRRAAAAESiiAAAAIuQy8lbV7M+6yqZNfn23srISvU+rmT0kj1Ioei719fVezJpE\n", + "e+ONNwbt4/Tp017MmrI+NTXlxYp0XNra2ryY9XOEsq5xawr1/Py8Fws9Ltdff33Qcr/85S+DlrOO\n", + "i5Xz8vJy0PZCp26vnZhc9NdQaC6bN2/2YtbE9ixySZuVS01NjRezpmFnkUuRjgu52LlYnzvWZPi5\n", + "ubmgfVifbdaUeuuzaD3ciQIAAIhAEQUAABCBIgoAACACRRQAAECEXBrLQzQ0NHgxqxHXarq1Gs8Q\n", + "zjqmjY2NXqyjoyNoe1bTcjlOrb+WZsMQ1oMSeV27dXV1Xsy6DiyhTeRWE7XFujYmJyeD1i03oce4\n", + "UmTRRI7KYT14Ultb68VCG8ut7VmN5deCO1EAAAARKKIAAAAiUEQBAABEoIgCAACIUIjGcqtRrKur\n", + "y4tZTZhZNGYeOHAgaLnh4eGgWNFZE2sHBwe92PT0dND2rAbq0EnVoazGd8vMzEz0PkIbqIvEauq3\n", + "msiRj9CHOCxJrmVL2tPtkb7Q126lPLAwNjbmxawHzEJZ7+FJ39e5EwUAABCBIgoAACACRRQAAEAE\n", + "iigAAIAIhWgsT6JI08krpZnPmhhtTYQNnRLb2dkZvW45sqbtW2ZnZ0ucicjevXu9WFNTkxezprGf\n", + "OXMm1VwmJiaClrMeNElTc3OzF0t7Gj0qR+hE6ywePLEe+qlkLS0tXsw6zqGv35qaGi8W+n69Hu5E\n", + "AQAARKCIAgAAiEARBQAAEIEiCgAAIEIhGsut5vAiNWn39fV5MavZMHSC90YzMjJS8n2kPb05iS1b\n", + "tgQtd+7cOS9mTXdPor6+PtXtpS3J9OFYRXqowWpqtaZSZ5Hz22+/XfJ9lKPQ11AW7/+Li4sl30eR\n", + "WA+BhD6gkhXuRAEAAESgiAIAAIhAEQUAABCBIgoAACBCLo3la5vFGhsbvWWsqaRWU11HR4cXS7sJ\n", + "02r2tRrLrYbQ6upC9O5fE+tnS3sa7549e1LdXhZaW1u92Pj4uBdLMlXYmtBrsZpdrXMUOhXdanLv\n", + "6uoKWtdqDremou/YsSNoexcuXPBi1msr1tLSUmrbSso6P1lMsrdY31SAYj0wlMVUdOu9Ja+HMcbG\n", + "xrxYkvNhNaUnfb1xJwoAACACRRQAAEAEiigAAIAIFFEAAAARNOtmQlV1NDACAIByoKrinDOfGOJO\n", + "FAAAQASKKAAAgAgUUQAAABEoogAAACLkMk77jjvuuOrPU1NT3jJrp5qvp7+/34tZU11HR0e9WJLJ\n", + "0klYjfVFyqW9vd2LWZO0rUnu8/PzXsyaSG8tNzg46MWKdFx27tzpxayJujMzM0H7sKZwb9++3Yv1\n", + "9fV5sdDj0tnZ6cVGRkaC1rUU5dotSh4i5LKeJLncfvvtQcu9/vrrJc8lbeRiS5JL6DeDWN9W0NDQ\n", + "4MVC38NFuBMFAAAQhSIKAAAgAkUUAABABIooAACACLk0lp8+ffqqP4+Pj+eRRsWora31YgsLC9Hb\n", + "s5ql29ravFhHR4cXGx4e9mJnzpyJzqVIzp8/n+r2rOb6s2fPRm/Pav5f+xDHep599tno/QJps97T\n", + "rCZj65qfnJwsSU4oLuuBHIv1IFpra2uifXMnCgAAIAJFFAAAQASKKAAAgAgUUQAAABFyaSy/lmmg\n", + "uNqOHTuClhsYGEh1v1azptX8aU3hRjasc3Ts2DEvZk30Rz6sxmjLRmuWDn0YxZpAXck+9rGPBS33\n", + "4osvljiTbFhN3/X19V5sdnY2eh9NTU3R64pwJwoAACAKRRQAAEAEiigAAIAIFFEAAAARcmksd87l\n", + "sduKYE0Tz+J4btrk19tWY3lejZ5dXV1ezHqAYXp6OnofVVVVXiztJu2VlZVUt2edNysGFMnFixe9\n", + "WE1NjRdL8s0MKE/V1X7ZMjQ0FL29ubm5JOlwJwoAACAGRRQAAEAEiigAAIAIFFEAAAARcmks32hT\n", + "ZtOUZDJrEhMTE16ssbExh0xs1hRbK5aksbwctbe3By03ODjoxZhsXnobbRJ5KOubDzZv3uzFRkZG\n", + "vFjaD2cUSaVMIg9lfe40Nzenuo/h4eFE63MnCgAAIAJFFAAAQASKKAAAgAgUUQAAABFyaSzfSLKY\n", + "Dm1NDreaK5M09FtTYkNlMek7C9ZxtqYoW6yp8lZjfkNDQ9D2mpqavJg1oX1qaipoe+V4PmJVyvWY\n", + "NqthN/T6CRV67JM8tGI1paM8We+51rd2hOro6PBiSafecycKAAAgAkUUAABABIooAACACFFFlKru\n", + "VtXDqnpMVY+q6r9bjXeo6jOqekJVn1bVtnTTBQAAKAa1Gl4/cCXV7SKy3Tn3uqo2i8jPROSzIvJ7\n", + "IjLsnPumqn5NRNqdc19fs66L2ScAAEDWVFWcc2r9XdSdKOfcoHPu9dX/nhKRN0Vkp4g8KCKPry72\n", + "uFwurAAAACpO4p4oVd0nIneIyE9FZJtzbmj1r4ZEZFvS7QMAABRRojlRq7/K+68i8sfOuUnVf7nb\n", + "5Zxzqmr+3u7RRx997797enqkp6cnSRoAAACp6O3tld7e3qBlo3qiRERUtUZE/j8Reco59+erseMi\n", + "0uOcG1TVHSJy2Dl3YM169EQBAICy8H49UVF3ovTyLae/EpE33i2gVv1QRB4SkW+s/v/310soa1bh\n", + "FprHli1bvJg1NdWaCG5N6LWWC83FmsY7Pz8ftK4lyXFJm5XLtm3+b4QvXLiQ6n6tKeHW9G9rubm5\n", + "uVRzsRT9HFm5tLX5D+bedtttXuz06dNe7Ny5c15s7QT+cjwmWUh7Mr5ldHTUi1kT9K1p50U6LuRi\n", + "57J161YvdvHixeh9WFPHrc9Aa3K9dVys2KFDh4Jy6evr82LWdXotN3pif533ayLyuyJyRFV/vhp7\n", + "RET+k4g8qaq/LyJ9IvK5yO0DAAAUWlQR5Zx7QdZvSr8/Ph0AAIDywMRyAACACBRRAAAAERKNOEhL\n", + "Z2enF+vq6vJiVjPaqVOnSpJTWtY2xCaVpIm8HFlNrGmbnZ0NWi6LJvK0VVeHvcSt11YS1gMVFqsh\n", + "Gemyru/Qaz7U9PR0qtvLi9UEbT0QYTl69KgXC33PqKmp8WLWZ4fVfJ22ycnJVLdXX1/vxSYmJqK3\n", + "ZzV9hx7nxcXF6P2uhztRAAAAESiiAAAAIlBEAQAARKCIAgAAiFCIxvKiC51ObuErbpJJu+F5o9mz\n", + "Z0/Qcm+//Xaq+x0ZGfFiJ06c8GLWayvthzFQelZD9kZjTekfHBwMWreSr3mrGT7tB0ryfMCMO1EA\n", + "AAARKKIAAAAiUEQBAABEoIgCAACIUIjGcqsJ1YoBKF/79u3zYtZk83Pnznmxvr6+EmSEtFRKY/nC\n", + "woIXs741wfp56+rqovebxSTyUGl/K0alfysBd6IAAAAiUEQBAABEoIgCAACIQBEFAAAQoRCN5Zbu\n", + "7u6g5c6fP1/iTESam5uDlrOmL280DQ0NQcvNzs6WOBOIhF+TNTU1XmxxcTHVXEJfRyg/U1NTeadQ\n", + "MhcuXPBiVhN52g3ZaQt9/fEtG9eGO1EAAAARKKIAAAAiUEQBAABEoIgCAACIUNjG8q1btwYtl6Sx\n", + "3JqWbE2OXVpait5HkVjNw3ntg8by/FjTltva2rzYxYsXU93vpk1h/2azJpYDRWJ9TiRprreavtNu\n", + "1rc+77JgNeZXEu5EAQAARKCIAgAAiEARBQAAEIEiCgAAIIJmPZ1UVR0TUQEAQDlQVXHOqfV33IkC\n", + "AACIQBEFAAAQgSIKAAAgAkUUAABAhFwmlqua/VklZTWzb9682YtZ05ytieXz8/PR+52bm/NieRwT\n", + "ETu/IuVinaPJyclccuG42Lm0tLR4sSTTlq2p94uLix+YR5HOT2gunZ2dXsyahm29Z1ixJLl88pOf\n", + "DFru2Wef9WIrKyup5pI2crFVSi67d+/2Yk1NTV5seHg4KHYtD79xJwoAACACRRQAAEAEiigAAIAI\n", + "FFEAAAARcmksL4qFhQUvlnZzbl5Neln44he/GLTc3/3d33kx69hbsmiWbmxsLPk+KlmSJnLL2iZy\n", + "ZMNq6Lds2uT/29tqLM+ClUuS17P1fv3AAw8Erfv66697sYGBgehcYLPOeUdHR9C61oNjSXEnCgAA\n", + "IAJFFAAAQASKKAAAgAgUUQAAABEK21huTfK1msKSNO5ZTYTV1f4hsSaWh7Ka4DaaqqqqvFOoOFk0\n", + "3Feq5uZmL1ZfX+/FxsfHvVjaTe8jIyOpbi+Jf/zHfwxaLsn7ofWea03ft469xZpK3draeu2JrQr9\n", + "hom8tLW1ebGxsbEcMimW0IciQq+ra8EnPAAAQASKKAAAgAgUUQAAABEoogAAACKo1UhX0h2qBu3Q\n", + "ahi0YhcuXAjar/VzdnV1eTGradKayBzaXGk1vFnTukMnm6fd+G4dl7ymrJOLjVzSzSPtxvKiHBOR\n", + "8szFemAo9BsNLNb5tR7EKPpxsaTdWF6O14sldEr9zMxMVC6qKs45MxnuRAEAAESgiAIAAIhAEQUA\n", + "ABCBIgoAACBCYRvL02b9nFu2bPFiy8vLXixJY3loLuXYzJc2crGRS+nzqKur82Lz8/O55JIEudjI\n", + "xUYuNhrLAQAASowiCgAAIAJFFAAAQASKKAAAgAj++OsNZGRkJO8UAGTspptuClpuaGjIi1lTzJPY\n", + "tMn/d6z1LQdW023oVG9ryrW1X2vy9crKSlB+HR0dQblYjcJJHm5qaGjwYrt3747eXhJVVVVezPpW\n", + "DEt3d3f0fs+fPx+9LpLjThQAAEAEiigAAIAIFFEAAAARKKIAAAAi5DKxPOt9AgAAxGBiOQAAQMoo\n", + "ogAAACJQRAEAAESgiAIAAIiQy8Rya2ptqVnN7HnkIRKeizUBN3R7oftYXl5ONRdre6HK8Rxlwcql\n", + "qakpaLnZ2dno/dbV1Xmxubk5L1Zur+ebb745aLm33nqr5LmkzcrFmuA9ODjoxZaWlqL3a70/WNsr\n", + "0nG59957vZh1fb/55ptezJra3tjY6MW2bt3qxX7+8597sSIdl/r6ei82Pz+f6n6tSfMzMzNerEjH\n", + "ZT3ciQIAAIhAEQUAABCBIgoAACACRRQAAECEXBrLESZJk7bFauYLlXYuabMaEJubm4PWnZycTDud\n", + "krOaMC379u0LWq6vr8+Lpd1MinwMDAx4sbRfz2lv7+677w5a7mc/+5kXC20KfuWVV7xY6DVvNZFb\n", + "jhw5ErRckVifE6HvpSMjI2mnU3jciQIAAIhAEQUAABCBIgoAACACRRQAAEAEGssDVFeHHaYkE3+R\n", + "vtDmz3JsLA9lTR/e6EInkWdh0yb/37ErKyup7iO06Xv//v1By7399ttJ0ik063zU1tZ6MasB3Vq3\n", + "UiwsLHgxqwHdmtA+Njbmxa5lInjRVe5ZBwAAKCGKKAAAgAgUUQAAABEoogAAACLQWB6gUhrGQxvk\n", + "y5HVqDg+Pp5DJnYz99zcXA6ZiExNTeWyX4s19bhI+RVFFs3mRffqq6+WfB9JmsNDm/VDH24pkomJ\n", + "CS9mXX/btm0L2t6FCxcS51Rk3IkCAACIQBEFAAAQgSIKAAAgAkUUAABAhMrtNMaGl1czd177tfT3\n", + "9+edQuFYDe6tra1ebHR01IvNzs6mmkuRGsbPnTuXdwq5s85HkV7PWQh9sGHnzp1B2zt16lTinIqM\n", + "O1EAAAARKKIAAAAiJCqiVLVKVX+uqj9a/XOHqj6jqidU9WlVbUsnTQAAgGJJeifqj0XkDRF5d9Lh\n", + "10XkGefcTSLy3OqfAQAAKk50Y7mq7hKRT4nIn4nI/7waflBE7lv978dFpFcopArDmkSLZGpra71Y\n", + "Q0ODF7Om3k9PT3sxq+m56Do7O73YyMiIF5uZmfFi1vGzLCwsXHti69i3b58X27x5sxezzlnajeWW\n", + "PI6JiD3BOzSXUDU1NV7M+rYBayK4tVzoPrJQKdP3rSnr1rUROrW90iW5E/UtEfn3InJl2/4259zQ\n", + "6n8PiUjYXHgAAIAyE1VEqeqnReSCc+7nIqLWMu7yPxvC/ukAAABQZmJ/nfcxEXlQVT8lIvUisllV\n", + "/0ZEhlR1u3NuUFV3iEhlf/MgAACoKL29vdLb2xu0bFQR5Zz7ExH5ExERVb1PRP4X59wXVfWbIvKQ\n", + "iHxj9f+/H7N9AACAPPT09EhPT897f37sscfWXVZDm/XW3cDlIuqrzrkHVbVDRJ4UkT0i0icin3PO\n", + "ja1Z3iXdJwAAQBZUVZxzZutS4iIqIhmKKAAAUBber4hiYjkAAEAEiigAAIAIFFEAAAARoieWJ7F2\n", + "ovPc3Fyq27emD4+Pj3sxVf9XnFYsSQ+XNb3amtxs7TdUXV2dF7MmzFqsn+2OO+7wYjt27PBik5OT\n", + "Xmzv3r1e7Pnnn/diN9xwgxc7fPiwF9u2zZ/XGjp5PfS62rp1qxcbGhryYqHnqKmpyYtZ08lDWeco\n", + "yfWSRFFysfLYuXOnF7OOu/VeEKqtzf860EuXLnmx0GNiXd8W63q0JDk/ra2tQcuFHr+0c0ly3pLk\n", + "Ul3tf0xa0+yT5LJpk38/I4ve4bRfz9axsljHryjvLSLXduy5EwUAABCBIgoAACACRRQAAEAEiigA\n", + "AIAIuTSWp91IvlZo47HFavDr7OwMWvfCBf+rAmdnZ6NzCRXaRB7qxIkTXqy/v9+LDQ8Pe7EXXnjB\n", + "i1nNuGfPng3KxTqmaUt7H0mayBGvvr7ei9XW1nqxJA3Kzc3N0etWirQbrQ8ePOjFfuM3fiNo3e99\n", + "73teLPS9JZT1s1mfE5aVlZWg5SplAHXowwkjIyMlziQ73IkCAACIQBEFAAAQgSIKAAAgAkUUAABA\n", + "hFway4uspqbGi4U2k168eNGLlWPDoDUlNknzeui0+LRZjcaWUj/ogGxYzb5pN/lb3zaQROgk8ixY\n", + "3/RQVVUVtFzazdyhrG8+SDsX6+GErq6uoHXPnTuXai5FtxHfS7kTBQAAEIEiCgAAIAJFFAAAQASK\n", + "KAAAgAg0lq9hNVBvtAnUVtO31XBfV1fnxRYXF72Y1Zy6c+fOyOxQrqxJ142NjUHrJvkWgjSl/e0A\n", + "VjO8FUsyETyU1TBuve4vXbqU6n7feOMNL2Y1c2/fvj3V/YayrlvYNtpnpQh3ogAAAKJQRAEAAESg\n", + "iAIAAIhAEQUAABCBjrk1rAnjoVNYizSdvLW11YuFTtm1LC8vezGr6dQ6BlZjZlNTU3QuoYo+Pddq\n", + "4LeaiiuZdb1YDyeEsNazrtFQ1rloaGiI3l6olZWVku/DYn2zQEdHhxfLosndemjFauofGRkpeS6W\n", + "tJvrUb421js2AABASiiiAAAAIlBEAQAARKCIAgAAiFDYxvLQBtssmjCthstQoY2tzc3NXmxqaip6\n", + "v0lYzb5JJjUvLCx4sb6+vujt5eXAgQNezGqan5yc9GKjo6Ne7K677vJi1qTmSmE1JFvHqiis95bQ\n", + "9xvrIQ7rNRQ6iX3//v1eLEnTvMU6F9b1Hdv4fy2sbzmwms2zMDMzk8t+UR64EwUAABCBIgoAACAC\n", + "RRQAAEAEiigAAIAImvWUbVV1RZrsDQAAsB5VFeec/xUTwp0oAACAKBRRAAAAESiiAAAAIlBEAQAA\n", + "RMhlYrmq2Z91lZtvvtmLWQ3pw8PDXsyaDm2tG5JHKYTmYk1ttyYmW+uGNu8nOS73339/0HJHjhzx\n", + "YhcuXEg1l7SF5tLU1OTFrHM0OzsbtN/QCdENDQ1erKWlxYtZE7GtdcfGxrxYR0eHFxsZGfFioefI\n", + "mrBtTWifnp7+wG1Z5+fGG2/0YtbPdenSJS9mHff6+vqg/VrfaFD069Z6b7Gu5SQT5a1cPvzhDwet\n", + "29jYGLTcmTNnvNi2bdu82EsvveTFin6OspAkl927d3sx61sJrM9ja3p/0Y/LergTBQAAEIEiCgAA\n", + "IAJFFAAAQASKKAAAgAi5NJaHsBrKrJjVEJo2q2HXkqQJ02I1KFuYAJ+fkCboa2E1Zlqsxkzr9WEt\n", + "Z8UsVkNoEtbDInV1dV7s7NmzXsx6EGGtwcFBLzY1NRWU2/LyshcLPU5FZzWMW9dt2u9fFmsfFy9e\n", + "9GKh157V/N/W1nbtiWHDsl4f14I7UQAAABEoogAAACJQRAEAAESgiAIAAIhQ2MZya9KwxWoITVtX\n", + "V1fQclk0ZhbJs88+68Vo6syG9TBB6FR0izU5PO1pwadPn/Zi1vR0a6I4AJEdO3YELTcwMFDiTOz3\n", + "oKqqKi9mfVNB6EMb1vas94zQB0hKgTtRAAAAESiiAAAAIlBEAQAARKCIAgAAiFDYxnKr8WzTJr/m\n", + "y6KxfHx8vOT7sIROUk17anYSodPdQx8cCLVly5ag5YaHh1Pdb2jzddpT5a1J/aHTzi0LCwtJ0gli\n", + "XadpXrtZ/AxJpxuvZb1erJh13Yb+vEV6f7De1638rEn21rpWk3Ha32KR12sctsXFxVS3l/T1wZ0o\n", + "AACACBRRAAAAESiiAAAAIlBEAQAARCirxnKriTALIyMjuezXaq60FKlxtL+/P+8UNoSOjg4vtrKy\n", + "ErRuaHO99SBHkW3fvt2LzczMBK1rHRNr+n7aTa2tra1erL6+PtV9FEk5/myh38JgPYAU+poMlcUk\n", + "8lChDfxJpolbzfqh086zUl7vkgAAAAVBEQUAABCBIgoAACACRRQAAECEXBrL1zZMh04dtyb0Ws3X\n", + "VtNtEu3t7UHLTU5OerEkU6RHR0ej101b6ATh0Km93d3diXO6Ul5T5Ys0pTjtid1JmmI7OzuDlrNe\n", + "M11dXV4sZCL9xYsXvdjs7KwXC22Ita6ptM+39Rq3mq+zmMaeRE1NTdBy1jcVWO8jVjO39WDRpUuX\n", + "vNirr74alEvarAcx0m4sz4I1Md96oGJwcNCLpd30vXPnTi9mXQfW68h6WOTWW2/1Yjt27IjM7jLu\n", + "RAEAAESgiAIAAIhAEQUAABCBIgoAACCCZt0Yq6quSM24AAAA61FVcc6p9XfciQIAAIhAEQUAABCB\n", + "IgoAACACRRQAAECEXCaWq5r9WSVlNbPnkYdIslysCa4XLlwIWteaOhuay9atW4P2Ebrc0aNHo3Ox\n", + "HDhwwIv19/d7MWsa78DAQKq5pK1Sctm1a1fQctZ5SzOPtIXmYl17FmuKe9q51NbWBm3Pes+wJnNb\n", + "3zqR5BxZyyV5ICk0l927dwdtL/TnOHPmTHQuWbBysc5vFg+DhR4X69surG85sKanW6+tc+fOBeWy\n", + "Hu5EAQAARKCIAgAAiEARBQAAEIEiCgAAIEIujeUhOjo6gpYbHR1Ndb/79+/3Yj/4wQ+C1n344Ye9\n", + "2FNPPZWLiRC7AAAgAElEQVQ4pytZTXBVVVVeLO1GwImJCS9mNSCGNpanLbS5PknTLsLV19d7sXvv\n", + "vTdo3SeeeCLtdK5y5513Bi332muvpbpf69rbtm2bF2tsbPRiQ0NDqeaysLAQvW5eTcZZOHv2bNBy\n", + "e/bsKXEm6TfXhyr6N4rU1NQELVddnU15w50oAACACBRRAAAAESiiAAAAIhS2J6qpqSloubm5OS82\n", + "MzOTdjqFYQ3btFi9U0lYx9liDdHMQtq9cahcoUM/0+6JqhQrKysl34c1mNQa6JnXe701RDNt1kBU\n", + "a4AkRJaWloKWK0WfFHeiAAAAIlBEAQAARKCIAgAAiEARBQAAEEGzHqylqkE7tAbOWUMlp6envZjV\n", + "+Fj0b84OzSXtxvJKOS5pIxdbUXJJkkd7e3vQcpcuXSp5LmmrlFysYa2hD7eknUvaQnNJMmwztIF6\n", + "cXExaL9ZCD0uocM2rWHQFqtZf20uqirOOfPAcCcKAAAgAkUUAABABIooAACACNFFlKq2qerfq+qb\n", + "qvqGqt6jqh2q+oyqnlDVp1W1Lc1kAQAAiiK6sVxVHxeR551z31HVahFpEpH/VUSGnXPfVNWviUi7\n", + "c+7ra9bL5Suiy7Gx0GJNcu/s7Axa15qyWynHJW3kYkuSy969e73Yvn37gtZ9/vnnU8sjbeRiS5JL\n", + "R0dH0HJjY2NeLO0Hi7Zv3+7FrPfhd955x4tZk7RDcwltjLZ+3tDjNzIyEpRLFtK+dq0GdKuRPiSX\n", + "1BvLVbVVRO51zn1ndYdLzrlxEXlQRB5fXexxEflszPYBAACKLvbXedeJyEVV/a6qvqaq31bVJhHZ\n", + "5pwbWl1mSES2pZIlAABAwcR+G1+1iNwpIl9yzr2iqn8uIlf92s455/L61R0AAECM3t5e6e3tDVo2\n", + "tojqF5F+59wrq3/+exF5REQGVXW7c25QVXeIyIXI7QMAAGSup6dHenp63vvzY489tu6yUUXUapF0\n", + "VlVvcs6dEJH7ReTY6v8eEpFvrP7/92O2v57QZrnR0dE0d1sodXV1Xsya7r7RWE2YtbW1Xmzr1q1e\n", + "zGq4R/ruueceL9bd3e3FrAnCaxvLUdn27NkTtJw1xXxmZibVXLZs2ZLq9izWt3F0dXUFrRs6yd1q\n", + "QC9H1udd6LGyvsnDav6/FrF3okRE/q2I/D+qWisivxSR3xORKhF5UlV/X0T6RORzibIDAAAoqOgi\n", + "yjn3CxH5sPFX98enAwAAUB6YWA4AABCBIgoAACBC9MTy6B2quqz3CQAAECP1ieUAAAAbHUUUAABA\n", + "BIooAACACBRRAAAAEZIM24ymenV/1h/+4R96y1jTjY8cORK0/W9961tezGpmX5uHiMiXvvQlL3bn\n", + "nXd6sXfeeceLPf74416sr68vOhdL6HTy0Km9SXJJG7nYyjEXa7J+6PasCdHnz5+PyiMLlZLLgQMH\n", + "gpY7fvx4yXNJW5JcampqgtZdWFjwYi0tLV5sYmIiOpe0Ff0cWZ93f/RHf+TF7rvvPi9mTWj/p3/6\n", + "Jy/2F3/xF15sampq3TzX4k4UAABABIooAACACBRRAAAAESiiAAAAIuTSWL7W4cOHvdhbb73lxW6/\n", + "/fYs0gliNb9WV5f+cIY2jKetu7s7aLm1DcDIzvbt273YJz/5yaB1//qv/zrVXDZtCvv32fLycqr7\n", + "RZjdu3d7sTfffDNo3YceesiLJbl+rGvFii0tLUXvI4nQh3msxvLJycm009lQZmdnS76P6enpROtz\n", + "JwoAACACRRQAAEAEiigAAIAIFFEAAAAR1JoSWtIdqma7w1Whk1k3b94ctD1r6qw12XZxcTE6lyyE\n", + "5tLc3By0vWuZ9BqbSxbKMZcsGstDc7FeCxbr9WFNeV7boFuO5ydUfX29F5ubm0s1F6ux/MyZM0H7\n", + "CG0sr+RzlAS52JLk0tTU5MWqqqq8mNXob+13bUxVxTlnJsOdKAAAgAgUUQAAABEoogAAACJQRAEA\n", + "AESgsXyNtra2oO2NjY2VPJcshOZiNbtaQhtgk+SSBXKxZZHL/v37vdjaqcKDg4MlzyNUXo3l1j5W\n", + "Vlaicwl9MCbURrtuQ5GLrci50FgOAACQMoooAACACBRRAAAAESiiAAAAIlTnnUDRWA3jmzZRawKl\n", + "0NnZ6cW2bt3qxQYGBrJIpxCSTCdPwmoi7+7uDlr3/PnzqeZSXe1/NFnXimVoaCjVXID3Q3UAAAAQ\n", + "gSIKAAAgAkUUAABABIooAACACIVtLN+9e3fQcrOzs15seHg4aN3QycDWFGBLY2OjF5uZmQlat+jq\n", + "6uqClksysbzoqqqqvJjVAHvo0KHofbz++uvR6xaddaysicRWw/TFixdLklM5S/uBl5tvvtmLhb4P\n", + "p91Yfvvtt3sx6/3VEtpY3tzcHLRce3t70HITExNezJoCX3TWOV/7jQEiIqOjo17MOqa7du3yYidP\n", + "nozMrni4EwUAABCBIgoAACACRRQAAEAEiigAAIAImvbU2w/coarLep8AAAAxVFWcc/5TMMKdKAAA\n", + "gCgUUQAAABEoogAAACJQRAEAAETIZWK5NaV4rdBpstYU5LGxMS9mNbNbebS0tATt15rgGjrZPDQX\n", + "a9qt9fNaU9vb2tq8WJLjkgVysYXmUltbG7S9hYWFkudSakXJQyQ8l/vuuy9oe2+//XbQcmfPno3O\n", + "JQtJcuno6AhazpqanSSXL37xi0Hbe+2114KWO3bsWHQulq6urqDlQif8l+P10tnZ6cU++9nPejFr\n", + "KvpPfvKT6FzWw50oAACACBRRAAAAESiiAAAAIlBEAQAARMhlYvna2KFDh7zlDh486MWWlpa8mNUo\n", + "NjIy4sVCm9YaGxu9mGVubs6Lpd1YnoVyzOWGG27wYo888kjQPh5++GEvluR6sXR3dwctd/78+aDl\n", + "kuRy9913By336quvljyXNBUlD5HwXLZs2RK0vZmZmejlin5crAdexsfHc8kl9LhYyyX53EzyPnfn\n", + "nXd6MevBoh/96Eep5pKF0Fysh6vuvfdeL7a8vOzFYhvLmVgOAACQMoooAACACBRRAAAAESiiAAAA\n", + "IuQysTxNVlNwEqFNnVmwpqfX1dV5MWt6utVsmLZPf/rTQcs999xzXiyL/PKyefPmoOVCG8uzUF9f\n", + "78WshycQb3JyMmi5qqqqEmeCa2E1PB84cCBo3ePHj0fv13r9WddQ6HVVKawHzA4fPpxDJpdxJwoA\n", + "ACACRRQAAEAEiigAAIAIFFEAAAARCjGxPAvlOJnVaiK3ms0vXbrkxaxprUlysaTdWF6O58jS3Nwc\n", + "tNzU1FTJc7Em8C8sLHgxq1kz7VzSVJQ8RMhlPZWSi/XQxSc+8YmgdZ966qnoXKzYF77whaD9njx5\n", + "0otZ30pQKecobUwsBwAAKDGKKAAAgAgUUQAAABEoogAAACIUdmK51VBmNfhZDdRW42w5mp+fD4rl\n", + "5cUXX/RiHR0dXqyzs9OL9ff3lySnIghtGM9CkSbww2e9p1kTy62m23I8t21tbV5sbGwsh0zCWcc+\n", + "9EGMLFjXELLDnSgAAIAIFFEAAAARKKIAAAAiUEQBAABEKGxj+S233OLFampqvJg1+frEiRNB+7Aa\n", + "nkObHEMngleym266yYv91m/9VtC6f/qnf5p2OoXR3t7uxayp8huN9XqzjI6OerGsv1mhFKzr4vbb\n", + "bw9a9/z5817srbfeSpxTEWza5P9bvra2Nmjdubk5L5Z2o7X1MI81ETxt1jVvXQfW8Tty5EiquVif\n", + "vYuLi6nuo1xxJwoAACACRRQAAEAEiigAAIAIFFEAAAARNOuGTVV1ldAkCgAAKp+qinPO/xoV4U4U\n", + "AABAFIooAACACBRRAAAAESiiAAAAIuQysVzV7M+6SlVVlRezpthaE8stVjN7SB4iIjfccIMXa2tr\n", + "82Jvv/22FwudvhyaSxJ1dXVezJr4m0UulryOi6VScvnQhz4UtJw15d96bRXluBQlD5FkuTQ0NHgx\n", + "axL00tJSqrmETvW23oct09PT0blYfu3Xfi1ouZGRES92/Pjx6Fysn7e5udmLVVf7H53j4+NezDpv\n", + "5Xjt7tu3L2h7e/bsCVruJz/5SVAu1jR269hbrxnrMzr0G0mu5eE37kQBAABEoIgCAACIQBEFAAAQ\n", + "gSIKAAAgQi6N5WmqqanxYlaTWRKHDh3yYrt27fJiVpO21Viel/n5+bxTADYs68GY/fv3B6177Nix\n", + "VHMJbXjO4sGTHTt2eLGDBw8GrfvKK6+kmktjY6MXW1lZ8WJWQ3sWQh8IsM5bEn19fUHLWU3fSVjX\n", + "5NatW4PWtR4I2Lx5sxc7c+bMtSd2Be5EAQAARKCIAgAAiEARBQAAEIEiCgAAIEJhG8uXl5e9WOh0\n", + "8ryEThXOi9XYutG0tLR4scnJyRwyycYvfvELL3b99dd7se7ubi/2y1/+siQ5bVQLCwtebHh4OIdM\n", + "7EnQVgO15VqmOcc6ffq0F7MahZEN6/3BatK2PgNPnTqVai7Ww2TW9WxdQ5akzfDciQIAAIhAEQUA\n", + "ABCBIgoAACBCdBGlqo+o6jFV/WdV/VtVrVPVDlV9RlVPqOrTqup/jTIAAEAF0JgmQVXdJyL/XURu\n", + "cc7Nq+rfich/E5FDIjLsnPumqn5NRNqdc19fs27puxIN1s+Z9uTdUHnlYjWWW1PMN9pxsVRyLrfd\n", + "dlvQckeOHCl5LrGKkocIuawn7VxuvfXWoOWOHj1a8lySqJRcGhoavFiSh79Cc7EeDrIkeWBobS6q\n", + "Ks4588DE3omaEJFFEWlU1WoRaRSR8yLyoIg8vrrM4yLy2cjtAwAAFFpUEeWcGxWR/ywiZ+Ry8TTm\n", + "nHtGRLY554ZWFxsSkW2pZAkAAFAwUQMSVPV6EfmyiOwTkXER+X9V9XevXMY55/L61R0AAECM3t5e\n", + "6e3tDVo2dsrU3SLyonNuREREVb8nIh8VkUFV3e6cG1TVHSJyIXL7AAAAmevp6ZGenp73/vzYY4+t\n", + "u2xsEXVcRP5UVRtEZE5E7heRl0VkWkQeEpFvrP7/9yO3X3hWU52lSFPWrYnJadu3b1/Qcn19fanu\n", + "t63NfxB0bGws1X1UivPnz+edAvC+Dhw44MWs1zjyk9dnW15N+OuJKqKcc79Q1b8WkVdFZEVEXhOR\n", + "/0tEWkTkSVX9fRHpE5HPpZQnAABAoUR/aYxz7psi8s014VG5fFcKAACgojGxHAAAIAJFFAAAQITo\n", + "X+cBedm1a5cXa21t9WITExNebGVlpSQ5ZW3Hjh1erL293YvNzMx4Maup33ogYPv27VG5rae6Ouzt\n", + "ZmlpKWr7TU1NXmx6ejpqW0lt3rzZi1kPo1jnzJrcPDo66sWGh4cjsxOpqqryYtY3GuTVPHzdddd5\n", + "sU2b/H/zj4+PZ5EOCqS+vj5oOev935K0UZ07UQAAABEoogAAACJQRAEAAESgiAIAAIigVhNjSXeo\n", + "6rLeJwAAQAxVFeec2YHOnSgAAIAIFFEAAAARKKIAAAAiUEQBAABEyGVieeyE0La2Ni82NzfnxRYW\n", + "FrzY8vJyankkZTXWk0t4Lta05dtvv92LTU5OerETJ05E52JNTE7ykIQ1Idq6dkOPS3Nzc9B+rZ/D\n", + "Yh0/a+J76PXymc98Jmi5F154wYuNjIxc9edyvG5ramqCtre4uJhqLtY0f2sSeeh+revMupbXnjOR\n", + "4p+jLCTJxfpmAYv1rQRp55K20Fysb6zYsmWLF7Mm+luT/61vdbiW93XuRAEAAESgiAIAAIhAEQUA\n", + "ABCBIgoAACBCLo3la4U2uo6NjZU4E5H6+vqg5ZaWloJilcJq8Nu8eXPQuuPj46nmYjWxXnfddUHr\n", + "hjaWW9KetG81kSfR0dHhxb7yla8ErRu6XBZCX4OlZr0vWY31oazG7VtvvTVo3aNHj0bvd2JiInpd\n", + "y9TUVKrbK7obbrghaLlTp06VOBOR7u7uoOVCG8vL0cDAQN4pXIU7UQAAABEoogAAACJQRAEAAESg\n", + "iAIAAIhQiMbyJM2aabOaSa0J2ZXcRG6xmqrTbhgPZU1btibXbzRWY/ndd9+dQya2H/zgB17MaiIv\n", + "yrlM+0EClKcsGsZDvfjii3mnkDvr20fOnTsXtG4pXtPciQIAAIhAEQUAABCBIgoAACACRRQAAEAE\n", + "zbp5UlVz6da0fk5rCncWyMVGLrbQXKyHIj7ykY94MeuhiJdffjnVXEqtKHmIVE4uDQ0NXsx6iCOL\n", + "XNJGLrZyzKWmpiZoe9b7XGi9s3Y5VRXnnHlguBMFAAAQgSIKAAAgAkUUAABABIooAACACGXfWB46\n", + "8bgcG+iyUCm5NDY2ejFrsu38/HzJc0kbuRQ3D5HKyeVjH/uYF2tpafFi/f39XuzYsWOp5lJXV+fF\n", + "Ql+7lko5R2krx1ysb2awjI6OppYLjeUAAAApo4gCAACIQBEFAAAQgSIKAAAgQnUeO107WXllZcVb\n", + "5p577gna1tTUlBezmhxR2axGVMvCwoIXy/rhiixZ030XFxdzyKT0amtrvZh1vkO1t7cnSacwQq+B\n", + "bdu2ebGdO3d6MWsSdNrvudZDIRvN5s2bg5abmJjwYp2dnV7M+pwtR0kaxkuBO1EAAAARKKIAAAAi\n", + "UEQBAABEoIgCAACIkMvE8kpu5AUAAJWDieUAAAApo4gCAACIQBEFAAAQgSIKAAAgQi4Ty1Wv7s86\n", + "ePBg0HojIyNBy1nTeK111+aRFauxPjSX3/zN3wxa7sc//nHJc0lbklzWTsFfT+jU3ko5LmlLO5ev\n", + "fOUrQct961vfisojdJJ9W1ubF7Mmfff393uxJMfkIx/5SNByL730UtByobkkmYYdKslx+fjHPx60\n", + "3MmTJ73Y0NBQqrmkLUku3d3dXqy62v8Yt87b2NhYdC7WtwHceeedXmxgYMCLDQ4OerH5+fnoXEI1\n", + "Nzd7sZaWFi9m5XwtD79xJwoAACACRRQAAEAEiigAAIAIFFEAAAARcmksX8tq+v7Upz4VtO73vvc9\n", + "LzY+Pp44p6J65ZVX8k7hPb/9278dtNw//MM/lDiTjcdqpA9tmt+5c2fQcufOnbumnIrIamC1hDYy\n", + "W43lCGc1tCdpXt9ozp8/78WshyLS9sADD3ixP/uzPwta96tf/aoXe/rpp6Nz+dCHPuTFtm3b5sWs\n", + "5vCf/vSn0ftdD3eiAAAAIlBEAQAARKCIAgAAiEARBQAAEKEQjeXWhNlQldxEbhkdHc07hfdYE53z\n", + "EtpUjWJZO4k8bdY0Z8vMzExJ81hPKRpdK8ELL7yQdwrvufXWW4OWO3r0aIkzsVmTyIukvr4+1e01\n", + "NDR4sV/5lV8JWrcUD2ZxJwoAACACRRQAAEAEiigAAIAIFFEAAAARCtFYbvnud7+bdwr4AE8++WTe\n", + "KWxYSRrpK2ESedqeeuqpvFPI1PLyci77DZ1O3t7e7sVmZ2e92NzcXOKc8MGee+45L3bgwAEvpqpe\n", + "zJqynsTp06e9mDWd3Lo2StGEz50oAACACBRRAAAAESiiAAAAIlBEAQAARFCrIaukO1TNdoerrJ/T\n", + "aoLLArnYyMVGLvnkYTU3X7p0KZdcQmWRy44dO7zYwMBAqrncddddQcu98cYbXsxqQN9o5yhUklxq\n", + "a2u92L59+4LWPXHiRKq5pG1tLqoqzjkzGe5EAQAARKCIAgAAiEARBQAAEIEiCgAAIEIuE8tramqu\n", + "+rPVoGaZnp4uRTqFUFVV5cXymioMm3WdLiws5JCJyKZN/r9/QqeY19XVebH6+novNj4+HrQ9q/nT\n", + "2p7FagIO3UcsKzdrunFTU5MXsxrLK5nVRI5wHR0deaeQqZmZGS8WOqXeYr3uQx+GS/IeeS24EwUA\n", + "ABCBIgoAACACRRQAAEAEiigAAIAIuUwsz3qfAAAAMZhYDgAAkDKKKAAAgAgUUQAAABEoogAAACLk\n", + "MrG8sbHxqj+HTi1OwmpmT3MK8rUgF1toLnfffXfQ9k6ePBm0nDWZO+3j0tLSErTc5ORkyXOprvZf\n", + "9ktLS0HrhuZi7aO9vd2LXbx4MWi/sXlYrEnkltBvSEiSyx/8wR8ELfftb3+75LmEfnNE6JT+cnxv\n", + "sVivXWt7U1NTqeZiTdzu7u4O2kd/f3+quVjXxq5du7zYwMCAFwv9fC/69bIe7kQBAABEoIgCAACI\n", + "QBEFAAAQgSIKAAAgQi6N5WtZTaiW0OZXVLZTp04FLWc1jOfFahjPSxavo7T3EfoeUW7q6+vzTgEF\n", + "tbKy4sVCG8bTtmXLllz2Ww64EwUAABCBIgoAACDC+xZRqvodVR1S1X++Itahqs+o6glVfVpV2674\n", + "u0dU9aSqHlfVT5YycQAAgDx90J2o74rIA2tiXxeRZ5xzN4nIc6t/FlU9KCKfF5GDq+v8papypwsA\n", + "AFSk9+3WdM79D1Xdtyb8oIjct/rfj4tIr1wupD4jIk845xZFpE9VT4nIr4rIS2u3u3aCaaU2jVaS\n", + "bdu2BS03NDRU4kxExsbGgpazJv5arAbOUNYk389//vNB6z7xxBNerJIfnoidTi5ybROEP0joJPIs\n", + "hD4kUVVV5cWWl5dTzSV0EvlGU6SHQkLV1NR4scXFxejtjY6OBi03NzcXvY9yFXOnaJtz7t1PyiER\n", + "effTtVtErnx0oF9EdibIDQAAoLAS/brNXf7n4fv9EzG9fz4CAAAUSMzv0YZUdbtzblBVd4jIhdX4\n", + "ORHZfcVyu1ZjAAAAZaG3t1d6e3uDlo0pon4oIg+JyDdW///7V8T/VlX/d7n8a7wbReTliO0DAADk\n", + "oqenR3p6et7782OPPbbusu9bRKnqE3K5iXyLqp4Vkf8gIv9JRJ5U1d8XkT4R+ZyIiHPuDVV9UkTe\n", + "EJElEfk3LrAbNEkzrdVAl4WGhgYvZv24aTfaqWrQftN26dKlku8jbUkaxkMleShi//79XuzkyZNJ\n", + "0qlYaTdRF8VTTz2VdwqoQEmayC3W+9yhQ4e8mPVZbj08UaRvk0jqg57O+511/ur+dZb/jyLyH5Mm\n", + "BQAAUHTMcQIAAIhAEQUAABCBIgoAACACo8ID3HTTTV6so6PDiw0PD3ux0InEoe644w4v1tnZ6cWs\n", + "6cPPP/989H6ZZhyuubnZi+3du9eLtba2ejEaywGUA+t9znrQa35+3otVUmM5d6IAAAAiUEQBAABE\n", + "oIgCAACIQBEFAAAQIZfG8qampqv+bE31Dp1QnPZkVktjY2PQcmlPJ7dYTeRtbW1e7MKFC14sVF5T\n", + "0cvRzMxMqtvjOMdb+74iYr8/8JCEzWoKrq2t9WJJ3q8tVoOytb3Z2dno7SEZ67V1yy23eLEtW7Z4\n", + "sWPHjnmxo0ePppNYAXAnCgAAIAJFFAAAQASKKAAAgAgUUQAAABE060ZWVXU0zwIAgHKgquKc85+4\n", + "Eu5EAQAARKGIAgAAiEARBQAAEIEiCgAAIEIuE8utidilZjWzW3m0trYGbW98fLzkuYTauXNn0HLn\n", + "zp0reS5JWLls2uTX+VYsNGdrXWuCddGPS5Fyqaqq8mLt7e1B2xsZGUktD+uY3H333V6spaXFi126\n", + "dClov6+//np0LhbrGwgsoccp9PysrKwEbS9UfX29F7MmjFvHJfT9a+/evUHLvfjii16s6K8hK5fQ\n", + "b8pI8q0JVi4NDQ1ezJr839XVFZTLxMREdC5FOkfr4U4UAABABIooAACACBRRAAAAESiiAAAAIuTS\n", + "WF5kc3NzeadQSLfddpsX+/KXv+zFhoeHvdjDDz8cvV+rwW95eTlo3erqfC5vq6k6tHE5ieuvvz5o\n", + "udHR0aDlQnO2mpR//dd/PWjdgYGBoOVeeOGFoOXWevXVV4OWO3DgQNT212Nde0tLS6nuo6amJmi5\n", + "Xbt2ebEzZ86kmkuS11rodRbaWF4kVlN/qCQN40lYn4GhP0foNZm2T3ziE0HLHT58OPV9cycKAAAg\n", + "AkUUAABABIooAACACBRRAAAAEWgsX8OaXl101iTyvOTVWHjDDTd4sdraWi/25ptvljyXLJrIiy7t\n", + "JupSO378eC77jZ3YLnJtU5WLzJqQbT2c8c4773ixIr33WUIfgik66+cYHBzMIZPi4U4UAABABIoo\n", + "AACACBRRAAAAESiiAAAAImjWzYmqmks3pPVzqmoOmVROLvX19V7MakBcXFwseS7btm3zYlZj+dmz\n", + "Z0ueS9pCc7GOgWVoaKjkuezbty9oe2NjY14sZML2+Ph4UB5ZKPq10tHR4cWyePgh9LjU1dV5sZaW\n", + "Fi82Pz/vxSYnJ1PNJVToBG/r/bDo1wu5+LmoqjjnzGS4EwUAABCBIgoAACACRRQAAEAEiigAAIAI\n", + "TCxHtLm5ubxTeE+SZmmkr6+vz4tZU6itJvItW7Z4MaYjxyv6BH2rYdyKFUnoNzNUysRyrI87UQAA\n", + "ABEoogAAACJQRAEAAESgiAIAAIhQiMbyTZv8Ws6KLS0tZZEOUJbyaq6vrvbfRqzX6sLCQtD2hoeH\n", + "g2JrWc2+odPyk6xr2b59uxezJjKHnjOr2T60adn6ZoG0Hwppa2tLdXtpnw/L1q1bvdiFCxeC1g09\n", + "fp2dndeU0wdpbm72YtbrKvS1huS4EwUAABCBIgoAACACRRQAAEAEiigAAIAIajU7lnSHqi7rfQIA\n", + "AMRQVXHOqfV3ud6J6u3tzXP3WIPzURyci2LhfBQL56M4Nvq5oIjCezgfxcG5KBbOR7FwPopjo58L\n", + "eqIAAAAiUEQBAABEyKWxPNMdAgAAJLBeY3nmRRQAAEAl4Nd5AAAAESiiAAAAIlBEAQAARMiliFLV\n", + "B1T1uKqeVNWv5ZHDRqaqu1X1sKoeU9WjqvrvVuMdqvqMqp5Q1adVtS3vXDcKVa1S1Z+r6o9W/8y5\n", + "yImqtqnq36vqm6r6hqrew/nIj6o+svpe9c+q+reqWsf5yI6qfkdVh1T1n6+IrXv8V8/XydXP+E/m\n", + "k3V2Mi+iVLVKRP5PEXlARA6KyO+o6i1Z57HBLYrIV5xzh0TkIyLyR6vn4Osi8oxz7iYReW71z8jG\n", + "H4vIGyLy7pMenIv8/B8i8t+cc7eIyG0iclw4H7lQ1X0i8gcicqdz7ldEpEpEviCcjyx9Vy5/Xl/J\n", + "PAveniIAAAMgSURBVP6qelBEPi+XP9sfEJG/VNWK/o1XHj/cr4rIKedcn3NuUUT+i4h8Joc8Nizn\n", + "3KBz7vXV/54SkTdFZKeIPCgij68u9riIfDafDDcWVd0lIp8Skf9bRN59jJZzkQNVbRWRe51z3xER\n", + "cc4tOefGhfORlwm5/I++RlWtFpFGETkvnI/MOOf+h4hcWhNe7/h/RkSecM4tOuf6ROSUXP7Mr1h5\n", + "FFE7ReTsFX/uX40hB6v/0rtDRH4qItucc0OrfzUkIttySmuj+ZaI/HsRWbkixrnIx3UiclFVv6uq\n", + "r6nqt1W1STgfuXDOjYrIfxaRM3K5eBpzzj0jnI+8rXf8u+XyZ/q7Kv7zPY8iisFUBaGqzSLyX0Xk\n", + "j51zk1f+nbs8QIxzVWKq+mkRueCc+7n8y12oq3AuMlUtIneKyF865+4UkWlZ86sizkd2VPV6Efmy\n", + "iOyTyx/Qzar6u1cuw/nIV8Dxr+hzk0cRdU5Edl/x591ydeWKDKhqjVwuoP7GOff91fCQqm5f/fsd\n", + "InIhr/w2kI+JyIOqelpEnhCRX1fVvxHORV76RaTfOffK6p//Xi4XVYOcj1zcLSIvOudGnHNLIvI9\n", + "EfmocD7ytt7709rP912rsYqVRxH1qojcqKr7VLVWLjeh/TCHPDYsVVUR+SsRecM59+dX/NUPReSh\n", + "1f9+SES+v3ZdpMs59yfOud3OuevkcsPsf3fOfVE4F7lwzg2KyFlVvWk1dL+IHBORHwnnIw/HReQj\n", + "qtqw+r51v1x+AIPzka/13p9+KCJfUNVaVb1ORG4UkZdzyC8zuXzti6r+TyLy53L5SYu/cs79b5kn\n", + "sYGp6sdF5CcickT+5VbrI3L5Yn9SRPaISJ+IfM45N5ZHjhuRqt4nIl91zj2oqh3CuciFqn5ILjf5\n", + "14rIL0Xk9+TyexXnIweq+rBc/qBeEZHXRORfi0iLcD4yoapPiMh9IrJFLvc//QcR+YGsc/xV9U9E\n", + "5F+JyJJcbhX5cQ5pZ4bvzgMAAIhQ0fMbAAAASoUiCgAAIAJFFAAAQASKKAAAgAgUUQAAABEoogAA\n", + "ACJQRAEAAET4/wEtHY5P7rJ1tgAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['pool5'].data[0]\n", + "vis_square(feat, padval=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first fully connected layer, `fc6` (rectified)\n", + "\n", + "We show the output values and the histogram of the positive values" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlgAAAJPCAYAAACgtar/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3Xv8LEdd5//3OzdCEpIQAyeBBBKQICCQgITI9RAIBJQQ\n", + "RIEoGFkWXUVAVCTghYOiXBQVxXVXIRhZhPUHSww3ySHyVXA1LEsCIVwi/kBByQkriCDLLpjaP6Yn\n", + "ZzKne6YvVd3V3a/n43EeZ74zPVXV1bfPVFVXO4QgAAAAxHPQ0AUAAACYGgIsAACAyAiwAAAAIiPA\n", + "AgAAiIwACwAAIDICLAAAgMhqBVi2j7X9Ztsft/0x2/e3fZztvbavs3257WNTFxYAAGAM6rZgvUrS\n", + "O0MId5N0L0mfkHSRpL0hhNMkXVH8DQAAMHveNtGo7WMkXRVCuNPa+5+Q9NAQwj7bJ0jaCSF8W7qi\n", + "AgAAjEOdFqxTJX3B9utsf8j279s+UtKuEMK+Ypl9knYlKyUAAMCI1AmwDpF0H0n/MYRwH0n/qrXu\n", + "wLBoBuOZOwAAAFoET9t8TtLnQgj/o/j7zZJeIOl62yeEEK63faKkG9a/aJugCwAAjEYIwTHS2Rpg\n", + "FQHUZ22fFkK4TtIjJF1b/LtQ0suL/y9NWdAxsb0nhLBn6HL0jfWeF9Z7XljveZnxekdrGKrTgiVJ\n", + "z5L0BtuHSfpbSU+TdLCkP7b9dEmfkfTEWIUCAAAYs1oBVgjhw5LuV/LRI+IWBwAAYPyYyT2NnaEL\n", + "MJCdoQswkJ2hCzCQnaELMJCdoQswkJ2hCzCQnaELMJCdoQswdlvnweqUuB3mOAYLAACMT8y4hRYs\n", + "AACAyAiwAAAAIiPAAgAAiIwACwAAIDICLAAAgMgIsAAAACIjwAIAAIiMAAsAACAyAiwAgGztGroM\n", + "wJQQYAHADNiyrTMqPrutpOt7LhIwaQRYADAPZ0n6UMVnt+izIMAcEGABwDwcNnQBgDkhwAIAAIiM\n", + "AAsAACAyAiwAAIDICLAAAAAiI8ACAACIjAALAAAgMgIsAACAyAiwAAAAIiPAAgAAiIwACwAAIDIC\n", + "LAAAgMgIsAAAACIjwAIAAIiMAAsAACAyAiwAs2XrbFs/PnQ5AEwPARaAOXu5pN8euhAApocACwAA\n", + "IDICLABzFoYuAIBpIsACAACI7JA6C9n+jKR/kfRvkr4RQjjT9nGS/qukO0r6jKQnhhD+OVE5ASAF\n", + "WrAWqAcgsrotWEHS7hDCGSGEM4v3LpK0N4RwmqQrir8BAOPjoQsATE2TLsL1A/A8SZcUry+RdH6U\n", + "EgGozZZtvX/ocowYLTcAkmjSgvUe2x+0/YzivV0hhH3F632SdkUvHYA6Hjh0AQAAN1drDJakB4YQ\n", + "Pm/7NpL22v7E6ochhGCbX4IAAACqGWCFED5f/P8F22+VdKakfbZPCCFcb/tESTeUfdf2npU/d0II\n", + "O92KDADR8MMQmDHbuyXtTpJ2CJvPL7aPkHRwCOErto+UdLmkF0t6hKR/CiG83PZFko4NIVy09t0Q\n", + "QmDwJJCILUu6MQQGKbdh668knbVaf7aeIemVIejo4UoWn62HStop21dsnSzp79mPMHcx45Y6LVi7\n", + "JL3V9nL5N4QQLrf9QUl/bPvpKqZpiFEgAOhR2S/MB0i6Vd8FGRgteUBkWwOsEMKnJZ1e8v4XtWjF\n", + "AoCxIrBYoOUKiIyZ3IFxs3RTVyEAIBMEWAAAAJERYAEAAERGgAVgzhiDBSAJAiwAAIDICLAAzBkt\n", + "WAvZ14Ots4cuA9AEARaAOcs+sMBNd8leMXQ5gCYIsIBx89r/mDhbt7T13NjJRk4PmD0CrImxFWyd\n", + "MnQ5ACTzIEm/PnQhAGxGgDVNpw5dAADJTLJbs/hxOLdHFGHCCLAAzFlZsJJ7d9kkA6zCcUMXAIiF\n", + "AGuacr9AAGhvygEWMBkEWADmrCxYyT2ASVG+3NeZZ25idAiwgHHjgtNN7oFFmTGWGZgdAixgGgi0\n", + "5oMACxgBAiwAAAE6EBkBFgCMy41DFwDAdgRY08SvUaCeMXa3jbHMwOwQYGXA1h1s3TlikofZOjpi\n", + "egDyMccAix+NGB0CrDxcKelTEdP7PUlfjpgeMFVjDFbmOE3DEoEWRoMAKw9HRE7vpMjpIV9ccLoZ\n", + "S2CxaoxlBmaHACtDtv7A1h8MXQ6MCoEWAGSEACtPFxb/AGBdihYsAnQgMgIsALi53IMNugiBESDA\n", + "ykPuJ3RgqsYYrIyxzF1xjsToEGABmLMxPux5zhONEmhhNAiw8jDGkzyAYXBuAEaAACtf/FJDHewn\n", + "3RCsLFAPQGQEWMA0NAq0bD3E1s+kKgySIhgCRoAAC5inn5f08qELgVYIsIAR6DXAsvV9tn6xzzxH\n", + "oqz1gZNoj2wdbGvX0OVAFnLvdmUeLGAE+m7B+jktfjljpGy9zNZbhy5HAj8q6fqhC4HejfGHzBjL\n", + "3JXX/geyRxdhHsZ0wvwBSecPXYgEaL2apzHewZt7+ZKy9SxbZw5dDmAbAixg3Nr+oqclAGP1W5Je\n", + "NHQhgG1qBVi2D7Z9le23FX8fZ3uv7etsX2772Jr5zfqXF4DsjPGclKLMY6wHIGt1W7CeI+lj2n8Q\n", + "XiRpbwjhNElXFH9jHjgR56lpixTbcbzmPJM7MBpbAyzbJ0l6jKTXaP9J/DxJlxSvL9E0x+T0ie4a\n", + "IB+5H48Ex8AI1GnB+g1Jz9PNfzXtCiHsK17vEwOEgbHJPYhAtTkGWOyvGJ1DNn1o+7sl3RBCuMr2\n", + "7rJlQgjBduUBb3vP/r/efpT0Xa0KOnFjvJMJmAKOs4WxBDBjKSdGoohtdqdIe2OAJekBks6z/RhJ\n", + "h0s62vbrJe2zfUII4XrbJ0q6oSqBEMKe5WubrsQGOJEA6Y3xxw3nBiCSEMKOpJ3l37aj3aG6sYsw\n", + "hPDCEMLJIYRTJT1Z0p+FEJ4q6TJJFxaLXSjp0pr55X7iwnZsw7y0vdiyHQEgoabzYC1Pyi+TdI7t\n", + "6ySdXfwNYDi0arRDoLlAPQCRbesivEkI4c8l/Xnx+ouSHpGqUDPEswjRNwIyAEiImdzRma1g615D\n", + "lwPzZOtwO+oPktyDz9n8+LL1cFuPVv7bZNSKc/h9hi7H1BBg6aad68gBizCFE+bJQxcAs3WLoQuA\n", + "ZN4u6Z0rfxNopXOXoQswNX0HWDkHEkcMXYA5sPWDtq4duhx9smVbxw1dDpTiLsJ0aQKzRgsWmup6\n", + "8XmUpLvHKEhXtr5g6049ZPVdkv6ph3yayD2I6Av1ACAJAizM2fGS7tFDPimfdNC25YEWC2ALW8fb\n", + "us3Q5egJPzYiq30XIZIa9GJn65AQ9M0hy4DOCJjaGeNFJUWZc62Hoffr/6nF8JG5BFmIiBasAdm6\n", + "1NZJQ5dD0jdsfUdPeQ19wgS2YR/F0u20aOkGGiPAGtbjJD1YeQy0PbHn/IAc5Npyg4Xl9hkq6CXY\n", + "RmuzvYvQ1j1t/cPQ5Vhl66P2TRO4TvXAvmkfsHU/W6cMUQhb9xsi3zEqpjG51dDlwE2mem6oY87r\n", + "jpGZcwvWmVo0/+bkHpIePnQhtugaJFuSbN1e0gdU/zmWsb1noHzH6uihC9CjbH4IAj1iv49szgEW\n", + "hvW54n8O6m74Rd/NaPc/O+q2Zz8CIiPAygPPIhw5W0fYOnPocgDYz9bRNjP9YxhzDrBqBzDFQfqA\n", + "lIXB6D1P0pWSZOtgWy/pOX9aINrhh8zCVOvhy5Je0+H7HFdobbaD3Bv6eUl/mTD9JPVi60hb902R\n", + "Ng5w2MrrYyX97FAFQWdcVPPTZZt8a7RSAA3MuQVrI1sH2Tq7+HOsE7L+rKQPRk5zrEFyn7hAj0en\n", + "/dnWGfbNgus+zHn/mvO6p8a5PTICrGoPkXRF8XqsB3WKsQdjrQsghQ9J+g8D5c2xOEHFw+EPHroc\n", + "6G7OAda2aJ0dPCJb59j6b0OXIxdF9+1/HrocKNX0lzyDqBHTHkn/Z+hCoLs5B1g5GdMv0bbNyE+W\n", + "9Hjlt65DNYt/u6QfjpDOTfVp69Yr3dq1vzdzdItgkyGOk/sowg98W3ewdVGE8qAlAizMXe0TaNF0\n", + "n/NDX39O+7u1gdkqfmxcO3Q5BvY0SS8duhBzNuhdhLaeauucnsuQo87PIrR1vK1dkcqT0phbDL5H\n", + "0g01lhviVy8tUu2U7Y/UZX6abpM7Sbp7ioJM2JjPzVkaugXrDyX93sBlqGMMF8wPSPpkioKsifKo\n", + "nJG67dAFaKNoeTtp7W1OpuM15mNoMmw929bpQ5cD+Ro6wBrS1C4wJ0o6ZuhCjFCK/WCoC2BVvt8n\n", + "6bN9FmRExnweSL6fFdPVPDZ1Pg3kFFy+StILhi4E8jXnAAuYi1uXvJfThWrsxhykbXMfSZcNXYgB\n", + "cZygNQKs/c5a+7vPA4tnEQ5nSidQ9pk4qMf9uEYALfGonP1m8yvN1q/Y+nctv35i1MKgqykFiEOI\n", + "cU5iG2AKcr4+jxK/Tqqt7mypT6B979gvUPuxA7ds+b1cL0JzGINVprd9ztZhtvb0lR/Ss3Vq31n2\n", + "nB/Q2ZwDLKJ1TEnTC1CfF6y7SHpRj/k1EWOahqHOJYMEHbZuIen/7yu7nvLJjq1Hd/juD+nAYS/o\n", + "2ZwDrG1me2AnsrwI5VavuZUH2Gbofbb1dcPWBXangHTode/TOzt893WSzo1VELSTQ4A1pwOmCnWA\n", + "GEbdKmvrm7aO7znbUdfZCN2r4fJV24fthuzlEGCNAQFQPHM4MY5hDFaaAlgn2QdcROuW62BJt49c\n", + "pNpsHVG0rsxhHx27wff1CWK/jyyHuwhz3ai5liuWzg8TnYixb+fcLjR/IunDQxeipbYT9f6q3f3u\n", + "Wlvn2tltTwAtzbkFa9uFta8TXdUv5tQX/r7vAlriAjI/OQexscp2Qt0Fbf2WrW8r+ehdkk6LVJ6p\n", + "4HwhydaDCb7HJ4cWrLlbP2hc8T7SmFI953B8/d+S96ZUxzE8S9KTIqRzQL3aOrPLIPKML+K5lqsv\n", + "fyHpzKELgWY2Bli2D7d9pe2rbX/M9kuL94+zvdf2dbYvt31szfzmfpCkRN3mY6iHg+ewD5QFWDlr\n", + "NE2DrWDrkITlqWPTdr5ngjTbJWj9st05kMzhR0MuWg3rsHV6xoHzpG0MsEIIX5f0sBDC6Vrc/fEw\n", + "2w+SdJGkvSGE0yRdUfw9Zal3ztX0p35CyW39citP72wdbuvpkZL7RqR0+tJm+899/GLd8+ELteHa\n", + "UMynlSrvMatax7brfpWk+9VYbvbnwti2dhGGEL5WvDxMixPLlySdJ+mS4v1LJJ1fMz82YH1N62os\n", + "dTurE6St8yW9ZsCy1PFQxSvj2AIsDMDWmZK+PnQ5ZuTQoQswR1sDLNsH2b5a0j5J7w0hXCtpVwhh\n", + "X7HIPkm7EpYxlVwCkq3lsPV8W3/SR2EQ3WOHLkDPcjmuupjCOqQUo37q3nUZ7QeZre+OlVZi7H8T\n", + "sXUsQQjhRkmn2z5G0rttP2zt82CbmXnbs7Y/9/Apkr59SzqHRysRxmTux8+cjXnb91p2WwdLelvf\n", + "+UY25rLPUu3BmiGEL9t+h6T7Stpn+4QQwvW2T5R0Q9X3bO/Z/9dlR8/vBz3WzO0kMYb1jVnGMazv\n", + "qlitBWNb77qGXq8cHrFFi9KE2d4taXeKtDcGWLaPl/TNEMI/276lpHMkvVjSZZIulPTy4v9Lq9II\n", + "IezZn17ps5HGsPP2eXCPoT7aGPpE3ac5resU5b79UpZvvUU9V2MoY1uxB7nXNeU6rRRC2JG0s/zb\n", + "drQH028bg3WipD8rxmBdKeltIYQrJL1M0jm2r5N0dvE32jlE5QfOobbqTn8xJnM7iPta36Yn31R3\n", + "ro5t+8Yq72jW29atbb3U1vuHLksLbecJ7BKcjGLb2rrS1qOHLgf229iCFUK4RtJ9St7/oqRHtMgv\n", + "px01l7L8oaSvVHz2QUnf2mNZ6ghqd7LKpb7Rv15ahGw5hMHuvs291WvVz+jA6RP6Ln9VfofYOiYE\n", + "fXnLcn3quwxV++S2cpwp6TFaPBEAGcjhUTk5HEA5Wa2POw5WinRy2d59lSOX9V03pYA31zpGc78o\n", + "6Z8TpJt8f7d1sK0jU+eD8eBROXkYU71wMcPUjeV4LDsWj6jxva7rl/IcsP6M1By2Rd0yvFjSVxOW\n", + "g3PvyPQdYJXtIDkcQNswyL273E4OKeu5z5n5XfEaDdg6RtIDOiSRy3H7W0MXIJGu+3Yfx8Zdesgj\n", + "pVz24clIHmDZepOts1Lng95wEDaTa9BDuRaW+/MeSW/ukE6f5R5628U4B3Rdh1ZlaPlMvlzOeUNv\n", + "dzTURwvWkyT9VfG60YNVE8vloJHyOHBS10dO9T1Vc6/jLsfR6g0/ORyPQ8lt3YeasqBNXrnVHQaW\n", + "wyD3XA11sMwt36FMbX2nsj5tgsTJ34IfWc5jsFLlPYXjYwrrMCs5BFhjOMGxY3c3pzocQ5A8huOu\n", + "D7XqwdajbN2jazqR9TEDf2UeLbvbxqjutk095Uc29W3rj2wez7YNdxFW67OsoeI10pl7PWdzsl6T\n", + "a7n+VNLrN3yea7lzVTeIiH2cpp4Ffy4ukHTy0IXIXQ53EQ7lgAPX1n+29bQhCjMibU94cw9oUunz\n", + "jsW2cjru69hWj2NbnylIHXht0vdxNdRxnOv5Y7Ry6CLM6WT1w5J+rHidU7n6EOXgsvVIW0fHSGtD\n", + "HmfZOidScpxU8lL2w+cWNb87l2N2kDvwerJetljdZV3qbOt3bT1IW56MEsFc9u/JoIswDznMZRTr\n", + "pP1uST/RMa1t3ibp8o5ptH2mWZO0+1YrX1u3lPSgxGVZ1fW4/7qtB0cpyYFyurM5C7ZuaW+8NqQ8\n", + "dsbqfZIenzgPHvY8Mjm0YPW2UW2dt+XEUfnV6IXJlK2TbH1hwyJtn5PFSTmtJvX6Y5IO7Zyh9Tu2\n", + "frfOol3zknS7xOnXkSwfW2d0/P4P2XpspOJ8TdJPRUqrStuWqSEmHO078Mj6BxrqS92kuW7oCPlP\n", + "JN1L0jU1lp1rP/jdJR0/cBm2iVFHfc3knqNYx/2yO/1HI6U3hL6nhajyoRbfWS3H6yRdH6EcyzRz\n", + "ecj8HB/GncLc138QOQxyz3Wi0bk+HidV0B3W/s9Fn4+yQX5y2x/7kMM6Vx0XOZRtXS6D3OkiHJkc\n", + "ugiRh+XBdXDifAg4ZsDWO2z9et/ZRkpnjheaJnWXwyzqfW6jKZyz5rhPD663AKuYlC67jZzhZHlD\n", + "97+3bcFa3ba51WmZvsaE5dBCtl6GPo7Dx0j6vh7y6dMY9uvYNq1znzeIrL8/5Rndc+3VQUM5tGCN\n", + "YaOm3uFzOujbtmClHpxarxBWsHWnPvLaVIyB818XpTxF3R4RI61N2fT0nS6G3r5D55+lLTOLT+Fx\n", + "SkmnmuiYPkrkEGDlaq6D3Le1YA1dvjp21VimrzFhUztp3bLBsmNY9zFP09C2nDkcw3W7/pqU9X/b\n", + "2d+g0wVB0sjkMA9Wrs2hc91RYwxyL6u7mCf13INfS713P09lf81lQDGq5fyw5yY/AOqawj5ZJ02O\n", + "hcj6DLCsPC4C62WIcWtzV5127EgX8r4Guccw1IlgDHPo1NFXmeYyf9CU5DrYfV3TfavLmMsx7Vc5\n", + "nm9mK4cuwqF3iNsOnP+6oQe5t90nxtYi2Lo8xVike9dMO7f17tMYLmZNzj9znCz33w+cf6xH5YxJ\n", + "inVuczMMOsqhi3AMpnwwNzXUHC25yWUixhjGfhNH7PSjn6dsHZTRHct11m9Z1vMSlaFpXTwzSSnq\n", + "CZJk6yhbLxiwHHWkDsLQQA4tWF1aEo63dauGX8sxyFutg8HKZ+sZki6OkVTLz/rUx0zufaxrLvVZ\n", + "pk0dpwhu7mLrTbHTbegfJb06Ulp9To9wY0/5b/OSAfJc92BJv7L23hN7zH8Kd0LOSt9jsGJv5H1a\n", + "PPj3wMwWJ9VNz1ub0g4X64T3/QnzGqS+bZ1cPNwY1VJtm+W+ckD6to6w9QuJ8l33GElParB8igBi\n", + "l6QzI6eZMtDp9ckLK6176+sU+1E5YxhHeVN+tr6w8vzc1N18U7omZiGHFqwuDpJ0csVn10l6To9l\n", + "iSXXuyrHls/S30t65YbPs2kBsvWLth6eIOmYE422ee5gWR3fT9KLay7bJZ9tabYZg5WrE3rOr059\n", + "nD5AnrENud2Pj5R/7vvuJOUQYKW84G7qPiRav7m6B2BVvW2byT1mt1nTbfctJe+lPOG0TfvnJf10\n", + "hzzbDo5tUt5farDsGI6xXB72nKuyLsIY6tZh3fmypmSocVRTrtNB9N1FuP8P68495l1WjkFvR7b1\n", + "/pU/x7Rj51DWKcypVYs9imkzqrQZi5f19thgKkFXqi66tvl3Xa7t8qty2SensA6zMmQL1qeK/6dy\n", + "YmrqgRXvj/UX9bYy5HaAZz/I3dZxkr7Z4Ctt1ym3bdNUlxa6sa97G03WOafJoWMYQ9m73Kk9x/05\n", + "Wzl0EQ4lpx1xDAf90pjKOnZH1lim0fawFSTdvV1xokox3cdTO3x3VZuy9Xk+6eMu1WXam7oIU+Q/\n", + "xIPJt8mhDHX9eMX7nLcH0HeAVXY315h23s5s2dZtNi3SW2FuLuZ22DQG68APrFvb2ps4/zbLpMx/\n", + "yHxPa/m98kzjdmO+s8N3fytaKTab4sWq7y7b9fxiB40/GCkdqf/tPcX9a5b6HoP1HT3mt81Qdw+d\n", + "K+mGiOnF0nWQexd3l/SIBOmiH3+28rprl9KJHcoRawbsMcxAn1ouj6NqG/g9u2Y6YxAj+JxVQ0Yu\n", + "cugizP3XfmwpnvbeZJxOKjkdwEOXZWytkF3r60Err8d2IetzX6nT0tdH/TVZ51wmGo2V9xjmwaqS\n", + "ut5zWc/JyCHAkiTZutjW5T1kleNOFCpej0ndQe5lyzVd5xjPPexjlvE+L0SbpmkYWup9uq9f9l3H\n", + "YJ1h67AG+eVgsEk2t8h1X48hRZ0nqS9bR6RIdyq2Bli2T7b9XtvX2v6o7WcX7x9ne6/t62xfbvvY\n", + "jmV5nKRzOqZRR+Xs0gMa08miyXPMpqbNLeQ51MW2gcNdy3jQltnyN42/O9jWIzvmv03sbdAlvW2t\n", + "WEPvL02maehjvqbYM7m3MfS1Yuh9osqjJP3r0IXIWZ0WrG9Iem4I4R6SzpL0TNt3k3SRpL0hhNMk\n", + "XVH8vcnY5r2ZW9dlX60MMfLZlsacg8Ayrdd1wyNM1v2n4v+m2/dsSe9u+J2YcriAt83rtfbGpxTE\n", + "cLP6sfVLkv4mYX45Hpe5DHLPrW5OGroAudsaYIUQrg8hXF28/qqkj0u6vRZPWb+kWOwSSeenKmQi\n", + "U3pERgxDrmOuQXZbQ1xsu4hR/3co/m9angPOQXbl46+2qcr7jIbpDLk/Nqm/J0r64RZ5NPkBsr7s\n", + "2UozjrRpUNF2G7U5Xg5vmVdsY26Fm6VGY7Bsn6LFyepKSbtCCPuKj/Zp8TDTNnJtKWKHbGbbo3Lq\n", + "fDY11nz2o0MipnV0xLQk6QcaLt+mBWGq23mq6zU4Wy+wa91ZH+OcySSlA6gdYNk+StJbJD0nhPCV\n", + "1c9CCEFsnFjGWo9jC1j7mMn9Zq/t3uZpairGCXxrgGXrjrYOsqPfXJNDF06sMuTyg3N5fKSaaLTt\n", + "d9tOWXDA8rb+2m40X1bsbfMrkn6q5P3czpWSJFuH2Eyn00StE53tQ7UIrl4fQri0eHuf7ROKz09U\n", + "5dxOe4p/t/h5aadTYauKV2uhA8eSxLgTrY0Yd9FNzZDr32fez+oxr1V9zI59aI20z5T0dkl/lSD/\n", + "tuZ+7G0z9LMIU+Z/f0mPTZh+W7mOwfouKeqE0Fmwvdv2nuW/mGnXuYvQkl4r6WMhhN9c+egySRcW\n", + "ry+UdOn6dxf2FP/+z0uk3WUL9HUAx54pOKYc7jqrux26jn3oY5B7k5ncU9T3ENuwS7dsnTvFtqWx\n", + "bMHa1rrzUC0CrVpsPaTusk0VY71ymvxYKm9peYGtL9VdvoauzyKcq1wmX20jSJKtN9p6fMs0spnW\n", + "KaYQwk4IYc/yX8y061TYAyU9RdLDbF9V/DtX0ssknWP7Oi0GPr6sZRm6XuiazpvS5kIf84KZ6wmr\n", + "zRQEbZaJUZeHbl9kWorm+cOK14+1ddu1RWKOgWojVf5/3mBZS5Kt41darDf5r6p+6Hpl+n2y9Zta\n", + "dCV1nQZnVZOpF/6iKEfsdb9VxfuxpxBZT2eIbs1YYpT9yYr7GCFsUOcuwveHEA4KIZweQjij+Pen\n", + "IYQvhhAeEUI4LYTwyBDCP/dR4BKpdvq+nsE1FV3qq+l3d0mSrb+0S28VTrXtHlNzueU2vm/EvP+b\n", + "pI8Vry+T9Py1z5/ZIe0Y+2TZ/E5DzTn3BdW7q7ntHWopj+H1tC/cskzqur1yw2dd6uEeFWn1PT8W\n", + "9qNOI+v7WYSbpJ69tukBnHtXXWybHkC9qqp8Q2zfB6g8iEl1x8x3N1z+r3Tgg5Xbup+kO6/8fQdb\n", + "p2r/um66867PfWrTswhjtsKUpb/qhMjpDSWnsaJ9yKnu1/V1HFW14pV1H/+MrSenLxLayKFPddMj\n", + "VJp8f5tcxmCVlbequbxPr42YVtO7rKY2yH11Xes8f66N75X0qZrLbhs4HKMO6ty88XuNEvQBrRxN\n", + "dKn3Ic8RQ5+fquRWrmTlsXV6xZ2ufdVBk3xeLumlNZajdWoAOQRYXdW9cLcKsGzdtXGJtiTZ8fOh\n", + "jeFAbTKRom09WtLPNc3E1mkJxqY0cZCkuyXOo+5xU7Zc67opun4/2vb7ShPY5nhspnqmZtcfvm2l\n", + "eKzTWWp2/r9K9YcD1GLrmAjnijGPH5ulHLoIU47TWM3zmJb5fVQNdk5bj7N1z7rLIws/0/J7n5T0\n", + "QlvPXnu/z5NZjO6BxuW19Z4Gi2/qNlymd/ra521uZOij5bBvfd9lXffv2Pn1lW9dtyh5r8u2+GeV\n", + "j6erI5fgKJdyjMYUWrC27vS2ztL+ebqa7iRNT9SXav9z2cqMoQVok7YDgzd9HrtO+jwRvETSq/rK\n", + "rGhtu9lba//35eEV74eS13XKFnturJRdhClbEsZ0ERuyRSX5edTWUetvdUzy9hX53HSHcGGoa0TT\n", + "fMd+LUtuCgFWnS7C1QHcTQ+Svn65LZXttJ13ZDva40fqlGXTs7tyuYCEtf9jSrmOf9TiOznO35O6\n", + "C2rULVhUtAEhAAAgAElEQVS2jtj0ccXrKFlX/B07n1TTMVRpk35fPRFvlnRdjeW61FG0+Qdt/fvi\n", + "71zO5dnKIcDq65ElY1a5HrZesfXLi8kavxypLHXuIvyJkrFrfW6LOf2yWr0A1u12STnIvc1YrfUy\n", + "bFqXTWmuahpgrY5la3unbAy2da6kf91SlhoJ6WRbv9ry67kfQ223xdBBSpn7Srrjyt91j+MmYu67\n", + "663oqJDTGKy2cj8RrIt92/UzaizT9kHcXRw3QJ5Ldeowl7tKu2oyPnDZdV3aelBxQ0fqekp1/DYN\n", + "sFa7PFPuE3XSPrlBepvq73sk/XSDtFblMgZrbOf3FLbV/Sn24BMNo0QOLVgpbRpcO9RM7nO6oB9i\n", + "67K1t+dwwkzZhVOVV50Hrv/I2nfWbZqnqu561B2Lt95FuD52q81+EmuQex/jpPbYpT9CmgYYbcoS\n", + "69zXR4tKb4Pebf2Era+nSj+x7xu6ADhQ9gGWrVvYrScoHHswszSGoKSsjMdo/8NUN425ib1+c33W\n", + "Wt0bEHIYd5bqwr00hu2aeoqNLsZQf03U2afur/K7B/vWpot6WwtWk6k56praPhJd9gGWpIulyged\n", + "tpEk6LL1AFufq7Fom7vthpw/ZV3TiV1TlKFp3mX6GvvX+GRp609tXZyoPGWazBu27fOm2znlzQax\n", + "xdiHt7Vu3vSeratrpHekHWXOpjbTNLzU1vNa5le1vevuB233l87b0Natu6axLYu1vx9X8X6XNNGD\n", + "HMZgbTtQ7rzl8036PGk/UBW34TZU5+I8pOWdJIfbevXK+xzA5drUy6O0/6S6Lb0YY6Q2pdEl/eM3\n", + "fBZz2o6p7nv3Vr0fXO/YlIjdaQzmprp9lqQXRk435225LNsXe863zZ3DKeS8bbKUQwtW1wvEzb5n\n", + "6472xu6oNvkMtWPluEMvy3QXbX7AcONuuorHU7QRo0WmizpjsFLM/ZVDQL5ahsMql0pT/30dL7Hy\n", + "SdFaXeZva+S7Lf++xhLWHYNWVZ6fsDc+eLxOGVJ5SeL0kZlBAqzEjxe5XVmWJe/lcDGqa0xl7eLf\n", + "hi5AAqnHl60OEu86EL1LWbuOqZrLPj7Ej6YjW3wnl+3RtL5+UtJtUxREw9fJ0FNMrKdxUYQ0Jy2n\n", + "Wzvb7gB9zBA+5gNLilv+thfnPutw0/imixSnK7du/qnXO0bwUqeMXR68vKrNXbxtlu+iTStOm2P0\n", + "tyXdJ0I6Kay3KPVVriGPlxR3bLYx1Dxsuaz/ZPQZYFV1m3Sd0bnOSW99EsOYecRW9qiRTcay03c5\n", + "scX0XC1+4f5LT/nlsH1iTDuwPt1GmzQ2LR/j5J77+MV1Z9RYZgzr0Ubbrsi2AfqYjLn7HCuGGoNV\n", + "Z4xK/cSs+1b0u3dKNnJ6ddONWjc9ajuvTQpNAlNL2h05/9rruGGCQOvmE05uuyClqtcnRk4v6iNS\n", + "ivGWp3ZJoyzZLZ/fzz6gFbTt3bXbPk8RSLS5ZT/2/tX3ua3rfnaoph3U1TH39W8sh0HuSzdtPFth\n", + "7eGX2773QUnnbUpzRZtfQEMHOl27QYco/5B1NvT2auI5Fe/fWtJf9lmQCr/ecPkH11yuzUDrKifW\n", + "SDOmd0l6Q9WHtu7QIe1Hav/6VGbRIf26+u4arJLLRf0vNHxdDJ0/GsqhBavqvbotUsvvlQVkQw8K\n", + "jJVukgPL1rG2Pr7yVorJ6Op8f8iT6NCTbm6aymBVVVd6mzFYVX/HmOrhVg2Xr5oHa/CufFvfsyH9\n", + "Tdvh72yd1DLbl0h6ccvvdtH3xbvu9o59V2Pb753V8nsx9XI9s/VMWw/rkBcKQ82D1Xpgrq3D4xSn\n", + "kZgX4SYHSerA446Svm3l75gHcJOLeOo77XL5FZzSAfVqb20JqfxuQnUCxMEmkVzzFkmyW3Uhr0+N\n", + "sJR7K0Rf0zSkzOfeidLt6zwy1I++Zb6vlvSylmlgRQ5dhNtmcl7fqP/bvtnYlKZdZG3GCg01yD1W\n", + "vr8aKZ0upnIRr/P9lOta65e/reMl/WPFMjkMot0UBLvk8zZptrWezntbfKfuEIem6faVZoxWzaG8\n", + "K1G6jerC1hNsXZA6H+Qrhy7Cqr7+TSeBoyvSGoM2d0t1PclWjQn5+Yj5jG07dC1vrEH95yQqx6Zn\n", + "qt3YIP3YcwqtX7i3/cBa/16Z2OOFctqXh2p9TR2Ut03v+cX/Q3ft1/FHijsL+9D75Rx6AqLKrosw\n", + "0SSkZa1CQw1yjz22pEvZnrD2d8x+9yhdobZ+x9a1HcuSolVwXdsWz/vaOsFuNRlkLHWDnLbqjl1a\n", + "6muG8yptuq/qlu/o7Ytgg5/q+P3cxuXeJkGaZWKUfegAb3Ry6CJcWv9lW3djxt7pl4N0c4jWcyhD\n", + "lW3b55fX/m67LmdLunvL7y6lDtq7+ryk19RctipAaXKnaYrWidg/QqZ6Mv/71T9a/qBs/B1b92r4\n", + "lbrn46G2U9N8W4/77ZBnHcc1KEeMm1DQoxy6CNffS3HgNFn+rg3Ta2pM00M0sb5e37H295jWpY5N\n", + "XdqueH+TE7oVp1HrSt/dK5smz13+fWziMsTQ5cHzbcXaVndsmGbquqwK8lvlm/jxa30bal1y/kE/\n", + "SkM9KqfOxSBmt1gvvxIjpZvbNAZ9aHIL8Tsipd9XnfZ1sjxC0lM6pjFE92lVnmPb57vc+djHul4m\n", + "6QMdvj+lAGas2AYjM9QYrMbLFZOP3rHko7GdiLfZ1LpXpu/1H6rrdukxLfJuWqddDTFeaLekQ1um\n", + "ccC2svUke5AWm1rs0vm2hjwXpNrmMdfpzA2fVf2wzfWi3rReYt8IMTbB7vw80alda5MbWwtW2aSM\n", + "TYOPoQe5N8l3TDt0TieunMoSW5sJObfNC1aWxpuKf0PYuN8XF4qP6sBzxRjvIhxiXz2/xjJjOvdI\n", + "0z7ml7qOwfrWAfOfpZzGYFV9NtTAvibdVk3uAGtSphx36Lbz43R93M+Y9Nk61uYHQwqp77RdXb9v\n", + "qfyib7ora+j6yNl31lhmLC1ZMdVex4hjvureRbvM9yl2rQC5fgGmNX4tKzncRVj1a7pxy5Sth9dY\n", + "vlNXZYWvqv4jQtoYalLLJvq4U62uSV1ca54AY4xZ7GMetLaz7Netgxtqptc1r3Vt6+6pdumdZF3T\n", + "jWVZF4+peDB57Fn3Y+4PY9B0SpLXS3pdorJsM/S+ODo5zIN1ytrDUdseOPeU9J619/qcjbjJw6mb\n", + "fj6Vk4nUz7o06TbLbcLCPm7gqOvbE6RZJ/AOFe+vft6+ANaP2bUfSl072Zbfe52kp234vGyi1yHO\n", + "B29U3Hny1nXt5t32vZy7kVP86F/HPFgD6HMM1qY7iX5e7efBqkqzTRpVzouUjlT/RCDl+Yuhyfax\n", + "lG0TdK6DXo+JlM7qBIbr+1HdH1YpAqw6Um+T35H0l4nziCXWI3di6HTHo60vSvp0jTymonJdbP1i\n", + "zPQ6fndKdZ6VPgOsl2z5vOsFr2nTcpOWpJTdf5uMaccfS1lzvety0/J1gu717121IY+zG+RdV+zj\n", + "tklX4lj2vTFa/2Hcpev/1sW/pt8rM8QzGjs/EcLWoVpMl3F4g3w75dkAx1FkfXYR3m3ldZO7COtu\n", + "9LLnq+X4bL02ZcppgHib/Jq02jX1vR2+20XXC36fXRU5njibdt9vagFvI8c6GVKd823KOls+yaDt\n", + "GL1tctlnjpJ0eoR0YuJYSGRrgGX7Ytv7bF+z8t5xtvfavs725babzsK86c6Jtgd43SkZetuZbD3S\n", + "1k+vv90gia51kkJud0F2nVyzlpJuzj4Gjtcx1pPj0OXe1N01dNly0PcPt+8v/m97nPUxjqlVOrZe\n", + "HSnPLraNa6ybhiKkMxt1WrBeJ+nctfcukrQ3hHCapCuKv7s6oOXK1t104CNXJOnkkvdy7EL4JUm/\n", + "2vA7OY67quPta39XBbW5HJxDD3Kv2zW2nl6XLpqUYv4wKvvOpsftNEl3Ux7Yr6xFK6f6ilWW1Ts4\n", + "t6XZ9lzxzEhpDtGFHzuNWdkaYIUQ3ifpS2tvnyfpkuL1Jao3cd2qOifjMyV9z3pxiv/fVfK9g0ve\n", + "G+Mdebme0Nro+1flUpOLa19j/upKUZ4cg/ZNv4aPlw54asPYj4WYplAXuaxD1XjEMinK3KZHIPY5\n", + "IpdtMTltB7nvCiHsK17vk7Sr4ffrdBHubZjmz9bMZz2/McixrG27Cvs4mEvzsHUXld/23ibNnLpt\n", + "Y+V5lK37haD/kTD/Ot0M75R0ywR51/0OF5xyVcfVwZJuDKF5a4ytEEKr+m76RIPY27Rtej8cMa22\n", + "qq7XQ/0gnqzOdxGGEILtDQfWnuL/fzpVeoIWj0wr1TU6H1rKu1pGUSf2AS2OuZV7T8l7P9J3IWwd\n", + "pv13U61r2+oaI2D4OUkPbbB8XU0D7G3BVYxu0k1jsLBfnW33TS32nV9ukG7d1pRbNEhzDH40Qhpd\n", + "99vvtHV8CPpfEcoyerZ3a0Ng0kXbAGuf7RNCCNfbPlEbZ0/es3zxd5JOKV63vRg0fZjtGLsIK9n6\n", + "gRD0hqHLscG9V143uajW2ia2/qlmOR5t64Eh7B//VtweXba/153jbNOYoE3Lli33a5KeVTOfdW2e\n", + "RVhXnxezpheJ2MGQJd01cppzULUd7tVrKdrPF9fnIPe6QxX6mqZh9ftP0mI+uBjpjloIYUfSzvJv\n", + "2y+KlXbbaRouk3Rh8fpCSZfW+E7dC+6mz55XI5+6acUWK69Ndzz+l0h59KWsTrrU06ZHiqz6OUmv\n", + "WHvvU5KeuPJ31wt2l+b09fFFXfKNdaLvKvVYs21Ba1OW1PTu57mz+g1QNnlQw/RyDSJoRZ2wOtM0\n", + "vFHSf5d0V9uftf00SS+TdI7t67QYJPiyGnk9ZFM2Fa/XnVgjnzKDTNPQ0qbxaTlZjqH4gTbfq/ww\n", + "zazvQbrZ45i2lqOF1W6tLrNvV7W6nlCx/HI9ctxHlpIcc7b+oMPX6wbrc1E1RGNKN93ENGRdlOXd\n", + "ZbhPXzfizM7WjRJCuKDio0d0yHd9Az1d++9U7OtOjc4XJFtHqnzAYKyLXc4XzaWqVrX1oLZul1qK\n", + "sTEx9qltXYTPXXn9BxHya2rok17qQeNl+8SFJe/VdecNnw1dl9sMWb5YE4FWrUPfXY05anO338Up\n", + "CiLdNLb2slTpT1mfM7mvSnkyTnrysfUIW7cr/vw1SX9bvE7ZSpb7Cb9Km1+/Y1nXTeW83YbPuqSb\n", + "U5p9509LyvDKugjbbouhfkTl0sW5VNaSWpV219bqbd+ryvctWkybhIaGCrA26Rp8bVunrgfGXkmv\n", + "LF6nHsMx6IXE1qG2/tbWU+xGdwgdkFTF623LxjKmJ8k3vTHjCakKMiJj6VbPWdW5bLVuYz41oe9z\n", + "W4z8mt5gVCfPO9Zcrmm6Tb7XdBwnP3BqmkIL1vqJNNY65bTTDXWxOErSnbSYY+yFLb7f5ldlin1y\n", + "yAtwjJPnt3XMJ+q62qVPUqh7TE8l8Ln39kVG5aU1lvk+1dx+icZS9u1pa3+vBqFTWL91B09ku2Vj\n", + "qADrURs+63pBSt2C1We6uVyMYnbbrqe1PiC8rwO8az6pHiRe9tmHW2eU5oR5n7KsNhVjw3J16zGX\n", + "Y2Gp7TQB2bF1mjaPSbvZ4jWX23Ye/qGa6QwlSHpGmy/ajbvTbtq3bf2ayp9KIqW7oWWZ7p+qfCJU\n", + "qdnEvygMFWD94YbPUo/B+paa6XR53lmOg7Rjq1OmsmXW37t7i3SbStFFmOM2qTJ0WWO0WPfZCjZ0\n", + "fVUqxn9WXYDb+qSkk6qybJlm39eWukMPYo3V2vT5lR3K8VPaPvQk5f75nyrevyJhnpM1tjFYdU6s\n", + "29Yp1VxSKQbh5nKib9MVul4f683tm5aNrSzNWyXIp0zZ/tjng8lz2IemuE7r+irTP0j6sZrLtglE\n", + "p3buys1yupg2194hW91XsW1rGluA9Z01vl93nWIPtt64vK3vsVtf1HPrHqnjIEl/0uJ7uR68bbu2\n", + "uuYTQ+yyVs3JlVKfQWnublNzuSHrJcdrS0xD1G2q3p25HT+9yfEg6Lqxy9bp+R3TrNLkwvUWNR93\n", + "kGNgVff5iEdIum/J+0nuIrR1N1vHV3ycoh67dDX01UqXKq+yboSYN64MrU15g60jopekJVt3l/Sb\n", + "NRf/xqak1v7u67Eu2zO4+fjCse1jY5bjdSlLcwmwHtAxzSpNu85+sGU+Yz95NAmq2q7rx1Td/Vv1\n", + "9PgctV3/NpMTxpQ6wMr9GDhG0r8OXYgVD0uUbqxB7jE02SeajsFKHUSs1s96marGwy0NPcY392Mx\n", + "G3MJsNrYtBO33cG/o+HyOe7IqW9C6LL9qu502d0hzaW+fsm3rd+cW5BW8+/rbqQoF6HiaQ113LJY\n", + "fui6bqPsmPteW2d1SLN2PXSoszbfe5Wt74qQdsrtXPWDsGmQmMrQ+Y8GAVa1pheslDvd2Jtk2/zS\n", + "zF2Xcva5PXOozxhlGOoYmMMDocvuSry1pNeq/Q+LJufhGAFW3TSeJOnHW+aXSjbdrohrzgFWypP+\n", + "VJ5FuOkXU9v6K5sDbdOJcug6WIr5K7vv1qY+6jD1yd+SZOtbe8i7S3pTvwjGmuag7bJt5bSPSJuv\n", + "U32f86a+zw5migHWUDtLWZAwldtilxe3w5X+1u/1ZZd5/26LfFOqWw/3bJhu7O6SofcdKW4Z/kZM\n", + "ephym66n/Wst02lybVmfbLiuHPbtFHL5UVllqvUe3RQDrD7GYJUt03e3YR/WW7Denjif9der/kOi\n", + "vHPR9aQ69DQGbVvl6gbOq+uX83mrTV23DWKG0Ko7y974va+1LMuQwzIOTZj3jRXvx1zfNnMbPjBi\n", + "/rOQ84mqrT6fRdiXoX7RrF807rbyWVmZYtzJllO9r0p1cltPv9euDFs/qfQtQpvKcErivBFX1bZM\n", + "9UzYTVJO07AtvbpPBKmdvt3rDO5t0vrJ4v/cW9iyQYAVT1m5h5xJOYZNrXKpWuxyWv8hpLijatN+\n", + "+Eqp8bPTmhrbfsEYrIUuP4xuOg8nvLNyyB9uKYKdx0ZMM6Up7eNJTT3AOs7WHyXI5xBbt1V1M2vd\n", + "yTjL5NTVGKtVpcktzznuk9Lwvx63if0suaaS57PhQh3rx82UpFr/Nl2EXJAPVHaeG/o832r5DRM8\n", + "z16OF7OuO9nqLcf3lXTBARlYD1G3ySe/V9I+DTtDeB82BVjvSpBPVV5j8+qhC9DQgxKnH+uO3SYB\n", + "/1B3Yk1h/13qUoebJtKMZcjzRswfnXV/kKceptDW4RHTmpRDhi7AilsX//fRRfjnij/rcqxf0U0f\n", + "DpzSpotG2RiEtuWcWoD1jx2+23n9bX37Wnrb0rxZgFXcLdo425afNUl/mU6dY3zKLVg5HiPr9d3H\n", + "MZ1yrq3U+8+mnoo+nsqwLa1TG6RVNSh/9qbQgrW+I9T9fspfC11+zea0TZquR5MunFWrrY45Xjyk\n", + "uOM9Ut/xd7fti2z0GxHKsCrWNh1DC1Yux2+KsXxNvrdaD6nuuHtqonT7kONQkFV1HyguSfe19YVY\n", + "hZmSXE4Gq/oa5L4tn6a/kmNfRLa916fU+W/qTsi1JWLb88I26XvAdtM6PCFBGbrqs4uwy9jJHM+p\n", + "Q1itw99PlMdqEDC2LsJNY7D6Xpcf6fj9+0mMwyqT48kg9YDqpW3r3qUcsU7uh9o6WCu30ds629ZR\n", + "HdJvU5bU26SP8RpdrZfr+xss2yWfseij3Mv9pM8WrKatt2PdfrGtHtP3HqwU+9294fJDbse2PQFN\n", + "BEmy9QBJryjNzLpFxPxmaYoBVt112rZc07qJNQZrPZ2nS7rzyt9/LOkrLdJtVgjrnmp+0fiFltmt\n", + "dhHmuE+Wid3N1+XO001yuIsw9his9fRS3kXY9AfbWPbfOpq0pm8ag5WqTprsV7EnSY55nVrfr/sM\n", + "7v5yw2dfrni/zvEH5XkyyCXAavorOVbX3nq5br32d+sJ7mw9u8HiR4sWrE1SBxSx0s6hPmN3n/c5\n", + "yJ0WrHo2jcEqe5h07Dxj1/u2/afrtXPT9aIq7T4HuUuqbMEiwKqJAKtbOVLc7VF7m9g6QdIxDdJ+\n", + "VcOy9HXR6HSitPUTEctSmU2iZWN+N1djHoOVYwtWX/tIk6c1rFst410jlGVbHrG9JXHeq99fb73O\n", + "8bq8ydjK25scK2ZMg9y3pbfs5/6XjulU+YsGy7bRVwvWpi7COnnHvuutjtiD7+vWda4tWH206DUJ\n", + "YvpuwVruw1MMkFfFGuMaw5B1nbIFq6rFL/oYrEhyjCOykGPF9BVgxU5n0y+SW7VMp+zvVevdh9sT\n", + "bzbHUV8nsIMqXuekrxasIdPOXZN1HyrAynX/ratt+Yd4FuGQuq5fTjO5dzXWcieX40GQS4BVpxwp\n", + "dqzUO+vJNZerGlSconzZBFi2Xmzrog7fP17Sni5F6Ph52fJ9nAD7aMHKeZD7ctLmXC42bdd/2/HX\n", + "poswldTnpU1Wn7XYZsqWNmN2+x6DNURak0KAVa1OObYNzo4xk3vqSSk3GaKLsMuA2Id0+O7SL0h6\n", + "UYfvf2eEMmwyxpPZ2Aa5t7lwL/fbD9z0xXHe5r7t+LtzxfubBrmnkksX4ctbfL9NgPXwFvn0Icc4\n", + "Igs5Vkzqi3ld9+qSl61T1O5RRLlvkxQTf2664yiXiUZTn8xTPY/MGr4Oy26ueG/DNKxhpkLYdIyv\n", + "Pkh+eazfaeW9/y9JidLa9lSFupPQDt1qmlrMMVh1f8g+qmOesXAXYU05PYtwqevGinVL8M/WWGbT\n", + "L91Pt8w3p521rxasbLoIM9BnN0HMtDd995QO6Zbl0Wf3/ab98Ukrr8vOO10fWVQl5T7Q9vw5xBis\n", + "LLoIW2rTghVTzCcd5HTNykqOF7OuG+vXopSinqHHYLWeE6um9Qva7ZRmnWN1EaY01pPIWMu9bnWa\n", + "hnVDBZ2rn+X4Y7WN1WtC348b6kuMR0HFDLBSTTKcytxuaGgtx4oZy04mpfkFVSsdW98aKb+N2az9\n", + "L608tqdFOlX6mJSwL6lb+3JtwepD1Ris2K0BXcZgjV3b9RjTGKzTbX3bQHkv9X0XYcpWpxzjiCx0\n", + "qhjb59r+hO2/sf38SGU6L1I6fag4EV/WZPLPdXW3yWGJ05cadxHuNCzKTUYeYO3ETCxGgLW+X/52\n", + "++JsslOVZyqNxmDZOiTCJLQl67VT9tlUWrA2HH87TdLJ/S7CI+svulP25sZ90Na3SDp00yI13xvQ\n", + "TtUHdBHW1DrAsn2wpFdLOleLB2leYDvGmIM6Y5/qSr3hK+rvii4BVt0yt33gc5MAJlaA1eQuwhx+\n", + "DZV1jWxYh51t342pzT5dNxhvmPZO03J0VbU/Vl2s7qzuk9BuCrBW5fbDoO0djG0DrKjdRrZ+0NYd\n", + "ti3WJY/6dsre3LZ+79ryeVnZ+wzSa5yndmT3Ot5xcrocBGdK+lQI4TMhhG9IepOkx8Up1misXrhS\n", + "DaqtSrftWLO6FwKrcYBV6S5bPt/UgpVqoHCuYrRgbXtGZgp9tlikzmu1G7xuXmUXxyF/LOxq+b22\n", + "geIh9s3Oh13X/RJJP71lmVQ3ZdSxbaza/bZ8v2yoxSvbFyeZOvWUw4/iLHWJmG8v6bMrf39O0v27\n", + "Fac+W8fWWGxTE23jtEveX22puu/+lwdvqtdtTdPrB17V8tt+3UnSESXv1ak3aTH7/NeL1227I5e2\n", + "zSu12hp3TM1tu1WHdG6xZVtL1XWysWWxSLdsNv3ldt/W8lDnmF3dZ5rUwXKdyvabbQ4tq+9Y21KL\n", + "el1ug/VjouwYOUJrTzpoUJbVqRbqtkaXbfejI67/avnrtE4d3TDNpdW/6zz1YbnMEyT9ra17Nsl/\n", + "i23nyqNWyt+01+Cm8q2k0WR86erTOdocL6uatjYevmm/qvjsVrr5PnpUzX2zbJn1erplka9DGHxK\n", + "mKw4hHb1YfsJks4NITyj+Pspku4fQnjWyjJUNgAAGI0QQpRW8i4tWP+gmz925WQtWrFuEquQAAAA\n", + "Y9Kl7/SDku5i+xTbh2kx6d5lcYoFAAAwXq1bsEII37T945LercXAyNeGED4erWQAAAAj1XoMFgAA\n", + "AMolub0y0QSk2bD9GdsfsX2V7Q8U7x1ne6/t62xfbvvYleVfUNTFJ2w/criSN2P7Ytv7bF+z8l7j\n", + "9bR9X9vXFJ+VPfg3KxXrvcf254ptfpXtR698NpX1Ptn2e21fa/ujtp9dvD/pbb5hvSe9zW0fbvtK\n", + "21fb/pjtlxbvT317V633pLf3ku2Di/V7W/H3pLf3Usl6p9/eIYSo/7ToLvyUFg94PVTS1ZLuFjuf\n", + "If9p8SDn49bee4WknyleP1/Sy4rXdy/q4NCiTj4l6aCh16Hmej5Y0hmSrmm5nssW0g9IOrN4/U4t\n", + "7j4dfP0arveLJP1kybJTWu8TJJ1evD5K0ie1mIds0tt8w3rPYZsfUfx/iKS/lvSgqW/vDes9+e1d\n", + "lPMnJb1B0mXF35Pf3hXrnXx7p2jBmssEpOt3SJ6nxeR4Kv4/v3j9OElvDCF8I4TwGS021pm9lLCj\n", + "EML7JH1p7e0m63l/2ydKulUI4QPFcn+48p0sVay3VD7p3pTW+/oQwtXF669K+rgW891NeptvWG9p\n", + "+tv8a8XLw7T4cfwlTXx7S5XrLU18e9s+SdJjJL1G+9d18tu7Yr1XJ9NeFW29UwRYZROQ3r5i2bEK\n", + "kt5j+4O2n1G8tyuEsK94vU/7Z1K+nW4+fcXY66Ppeq6//w8a7/o/y/aHbb92pRl9kutt+xQtWvGu\n", + "1Iy2+cp6/3Xx1qS3ue2DbF+txXZ9bwjhWs1ge1estzTx7a3Fo6OeJ+nGlfcmv71Vvt5Bibd3igBr\n", + "DqPmHxhCOEPSoyU90/aDVz8Mi/bDTfUwiTqqsZ5T8ruSTpV0uqTPK8/HWkRh+yhJb5H0nBDCV1Y/\n", + "m/I2L9b7zVqs91c1g20eQrgxhHC6pJMkPcT2w9Y+n+T2Llnv3Zr49rb93ZJuCCFcpYpH4Exxe29Y\n", + "7+TbO0WAtXUC0rELIXy++P8Lkt6qRZffPtsnSFLRlHhDsfh6fZxUvDdWTdbzc8X7J629P7r1DyHc\n", + "EF70LhgAABTnSURBVApaNDMvu3kntd62D9UiuHp9COHS4u3Jb/OV9f4vy/WeyzaXpBDClyW9Q4tH\n", + "fk1+ey+trPd3zGB7P0DSebY/LemNks62/XpNf3uXrfcf9rG9UwRYk56A1PYRtm9VvD5S0iMlXaPF\n", + "Ol5YLHahpOXF6TJJT7Z9mO1TtXjw8Qc0Xo3WM4RwvaR/sX1/25b01JXvjEZx4ll6vBbbXJrQehfl\n", + "fK2kj4UQfnPlo0lv86r1nvo2t338slvE9i0lnSPpKk1/e5eu9zLIKExue4cQXhhCODmEcKqkJ0v6\n", + "sxDCUzXx7V2x3j/Yy/G9aQR8239adJ19UovBYS9IkcdQ/7RoUry6+PfR5fpJOk7SeyRdJ+lySceu\n", + "fOeFRV18QtKjhl6HBuv6Rkn/KOn/ajGu7mlt1lOLX8XXFJ/91tDr1WK9/50WAxo/IunDxUG1a4Lr\n", + "/SAtxihcrcWF9ipJ5059m1es96Onvs0l3VPSh4r1/oik5xXvT317V633pLf3Wh08VPvvppv09l5b\n", + "790r6/361NubiUYBAAAiSzLRKAAAwJwRYAEAAERGgAUAABAZARYAAEBkBFgAAACREWABAABERoAF\n", + "AAAQGQEWAABAZARYAAAAkRFgAQAAREaABQAAEBkBFgAAQGQEWAAAAJERYAEAAERGgAUAABAZARYA\n", + "AEBkBFgAAACREWABAABERoAFAAAQGQEWAABAZARYAAAAkRFgAQAAREaABQAAEBkBFgAAQGQEWAAA\n", + "AJERYAEAAERGgAUAABAZARYAAEBkBFgAAACREWABAABERoAFAAAQGQEWAABAZARYAAAAkW0MsGwf\n", + "bvtK21fb/pjtlxbvH2d7r+3rbF9u+9h+igsAAJA/hxA2L2AfEUL4mu1DJL1f0k9LOk/S/wohvML2\n", + "8yXdOoRwUfriAgAA5G9rF2EI4WvFy8MkHSzpS1oEWJcU718i6fwkpQMAABihrQGW7YNsXy1pn6T3\n", + "hhCulbQrhLCvWGSfpF0JywgAADAqh2xbIIRwo6TTbR8j6d22H7b2ebBd2s9Y9T4AAECOQgiOkc7W\n", + "AGslwy/bfoek+0raZ/uEEML1tk+UdMOG70UpKOqxvSeEsGfocswJdd4/6rx/1Hn/qPP+xWwY2nYX\n", + "4fHLOwRt31LSOZKuknSZpAuLxS6UdGmsAgEAAIzdthasEyVdYvsgLYKx14cQrrB9laQ/tv10SZ+R\n", + "9MS0xQQAABiPjQFWCOEaSfcpef+Lkh6RqlDoZGfoAszQztAFmKGdoQswQztDF2CGdoYuANrbOg9W\n", + "p8TtwBgsAAAwBjHjFh6VAwAAEBkBFgAAQGQEWAAAAJERYAEAAERGgAUAABAZARYAAEBkBFgAAACR\n", + "EWABAABERoAFAAAQGQEWAABAZARYAAAAkW182HMKtksffsgzCwEAwFT0HmAtrMdYxFYAAGA66CIE\n", + "AACIjAALAAAgMgIsAACAyAiwAAAAIiPAAgAAiIwACwAAIDICLAAAgMgGmgcrvaoJTSUmNQUAAGlN\n", + "NsBaKIuxiK0AAEBadBECAABERoAFAAAQGQEWAABAZARYAAAAkRFgAQAAREaABQAAEBkBFgAAQGQE\n", + "WAAAAJERYAEAAERGgAUAABDZ1gDL9sm232v7Wtsftf3s4v09tj9n+6ri37npiwsAAJA/h1D5TOTF\n", + "AvYJkk4IIVxt+yhJ/1PS+ZKeKOkrIYRf3/DdsP5g5cVDmNfzdPQHMJfnkyYvAAAwfmVxS1tbH/Yc\n", + "Qrhe0vXF66/a/rik2y/LEqMQAAAAU9JoDJbtUySdIemvi7eeZfvDtl9r+9jIZQMAABilrS1YS0X3\n", + "4JslPadoyfpdSb9YfPxLkl4p6ekl39uz8udO65ICAABEZHu3pN1J0t42BqsowKGS3i7pXSGE3yz5\n", + "/BRJbwsh3HPtfcZgAQCAUYg5BqvOXYSW9FpJH1sNrmyfuLLY4yVdE6NAAAAAY1fnLsIHSfoLSR/R\n", + "/iahF0q6QNLpxXuflvQjIYR9a9+lBQsAAIxCzBasWl2ErRMnwAIAACPRaxchAAAAmiHAAgAAiIwA\n", + "CwAAIDICLAAAgMgIsAAAACIjwAIAAIiMAAsAACAyAiwAAIDICLAAAAAiI8ACAACIjAALAAAgMgIs\n", + "AACAyAiwAAAAIiPAAgAAiIwACwAAIDICLAAAgMgIsAAAACIjwAIAAIiMAAsAACAyAiwAAIDICLAA\n", + "AAAiI8ACAACIjAALAAAgMgIsAACAyAiwAAAAIiPAAgAAiIwACwAAIDICLAAAgMgOSZ2B7YemzgMA\n", + "ACAnDiGkS9wO0hlf3v/OFw+V/u4IaT1PK4Tg+HmXrVv8vLpYlPNAOZURAIA5sB1iXX97CLBW03+T\n", + "pAtEgLVfeTnzKiMAAHMQM8BiDBYAAEBkBFgAAACRbQ2wbJ9s+722r7X9UdvPLt4/zvZe29fZvtz2\n", + "semLCwAAkL86LVjfkPTcEMI9JJ0l6Zm27ybpIkl7QwinSbqi+BsAAGD2tgZYIYTrQwhXF6+/Kunj\n", + "km4v6TxJlxSLXSLp/FSFBAAAGJNGY7BsnyLpDElXStoVQthXfLRP0q6oJQMAABip2gGW7aMkvUXS\n", + "c0IIX1n9LCzmekg33wMAAMCI1JrJ3fahWgRXrw8hXFq8vc/2CSGE622fKOmG8m/vWXl9Y/uSTkDV\n", + "pKIAAKB/tndL2p0k7W0Tjdq2FmOs/imE8NyV919RvPdy2xdJOjaEcNHad5lodDXniklFmWgUAIDh\n", + "xZxotE4L1gMlPUXSR2xfVbz3Akkvk/THtp8u6TOSnhijQAAAAGO3NcAKIbxf1WO1HhG3OAAAAOPH\n", + "TO4AAACREWABAABERoAFAAAQGQEWAABAZLXmwRpK1bxRw06zUC63MjHNAwAAw8k6wFoomzdqSOVz\n", + "aw0rtzoCAGDe6CIEAACIjAALAAAgMgIsAACAyAiwAAAAIiPAAgAAiIwACwAAIDICLAAAgMhGMA/W\n", + "dpsmAAUAAOjbJAKsBSbbBAAAeaCLEAAAIDICLAAAgMgIsAAAACIjwAIAAIiMAAsAACAyAiwAAIDI\n", + "JjRNQ31l82aFEKLO6zCWubmqyhm7PgAAmJNZBlj9zZk1lrm5xlJOAADGgS5CAACAyAiwAAAAIiPA\n", + "AgAAiIwACwAAIDICLAAAgMgIsAAAACIjwAIAAIhslPNgjWUSzy6YABQAgPEaZYA1j4kxy+KrKa4n\n", + "AADTQxchAABAZFsDLNsX295n+5qV9/bY/pztq4p/56YtJgAAwHjUacF6naT1ACpI+vUQwhnFvz+N\n", + "XzQAAIBx2hpghRDeJ+lLJR8xIAgAAKBElzFYz7L9YduvtX1stBIBAACMXNsA63clnSrpdEmfl/TK\n", + "aCUCAAAYuVbTNIQQbli+tv0aSW+rXnrPyusbK5fKbW6r3MqzlGu52mCuLwDAkGzvlrQ7RdqtAizb\n", + "J4YQPl/8+XhJ11QvvWfl9Zs2pJrjvE85zreVY5m6mNr6AADGIoSwI2ln+bftF8VKe2uAZfuNkh4q\n", + "6Xjbn5X0Ikm7bZ+uxdXx05J+JFaBAAAAxm5rgBVCuKDk7YsTlAUAAGASmMkdAAAgMgIsAACAyAiw\n", + "AAAAIiPAAgAAiKzVNA1TNKX5pYaW2/xWm7Ytc24BAFIgwLoJ8zHFlVt95jjPGgBgqugiBAAAiIwA\n", + "CwAAIDICLAAAgMgIsAAAACIjwAIAAIiMAAsAACAyAiwAAIDImAcLvclxMteyMq1PPprbxKkAgPwR\n", + "YKFHuU0+KtUvU45lBwDkii5CAACAyAiwAAAAIiPAAgAAiIwACwAAIDICLAAAgMgIsAAAACJjmgaU\n", + "6jI/1JByLBMAYH4IsFCh7fxQm5btC3NWAQCGRRchAABAZARYAAAAkRFgAQAAREaABQAAEBkBFgAA\n", + "QGQEWAAAAJERYAEAAETGPFgYLSYVBQDkigALI8ekogCA/NBFCAAAEBkBFgAAQGRbAyzbF9veZ/ua\n", + "lfeOs73X9nW2L7d9bNpiAgAAjEedFqzXSTp37b2LJO0NIZwm6YribwAAAKhGgBVCeJ+kL629fZ6k\n", + "S4rXl0g6P3K5AAAARqvtGKxdIYR9xet9knZFKg8AAMDodZ6mIYQQNs9HtGfl9Y1ds8tWbnMy5VYe\n", + "xFW1fUMIzFMBADXZ3i1pd4q02wZY+2yfEEK43vaJkm6oXnTPyus3tcxuDHKbj6msPGXX5KHLifZy\n", + "2+cAYFxCCDuSdpZ/235RrLTbdhFeJunC4vWFki6NUxwAAIDxqzNNwxsl/XdJd7X9WdtPk/QySefY\n", + "vk7S2cXfAAAAUI0uwhDCBRUfPSJyWQAAACaBmdwBAAAiI8ACAACIjAALAAAgMgIsAACAyDpPNIr5\n", + "YPJSAADqIcBCA0xsCQBAHXQRAgAAREaABQAAEBkBFgAAQGQEWAAAAJERYAEAAERGgAUAABAZ0zRg\n", + "FJiDCwAwJgRYGBHm4QIAjANdhAAAAJERYAEAAERGgAUAABAZARYAAEBkBFgAAACREWABAABERoAF\n", + "AAAQGfNgAWvqTmpatlwIodbkXFV51P1+XygnALRDgAUcoO6Epl0nPh3LxKmUEwCaoosQAAAgMgIs\n", + "AACAyAiwAAAAIiPAAgAAiIwACwAAIDICLAAAgMiYpgHZqTsP1RR1mVurT7HLyTxWAKaGAAsZKrvW\n", + "zuU6O5a5nFKUcyzrDgDb0UUIAAAQGQEWAABAZJ26CG1/RtK/SPo3Sd8IIZwZo1AAAABj1nUMVpC0\n", + "O4TwxRiFAQAAmIIYXYSMRAUAAFjRNcAKkt5j+4O2nxGjQAAAAGPXtYvwgSGEz9u+jaS9tj8RQnhf\n", + "jIIBAACMVacAK4Tw+eL/L9h+q6QzJa0FWHtWXt/YJTsgeykmSW2S5lgmKu1Ll/qoO/lp10lSu+ZT\n", + "Ny8mcwUOZHu3pN1J0g6h3fXA9hGSDg4hfMX2kZIul/TiEMLlK8uEm08e+CZJF6h8QsGqySXrLFv3\n", + "vbGkOeayzznNPMvefYb14fJpFqTELWfdMqUqe7186ufVtZzAHNgOsY6JLi1YuyS91fYynTesBlcA\n", + "AABz1TrACiF8WtLpEcsCAAAwCczkDgAAEBkBFgAAQGQEWAAAAJERYAEAAETWdaJRABi1FHOXpUy3\n", + "bl5MvwAMiwALACrnGkuRZtl8XV2lSBNAF3QRAgAAREaABQAAEBkBFgAAQGQEWAAAAJERYAEAAERG\n", + "gAUAABAZ0zQAM7NpfqbYcyf1ORdUXTmWKYWh1rPP/asvVes01vVBPwiwgFlKMe9T3bxSzQVV11zm\n", + "jMqpjvvOP4W57DeIhS5CAACAyAiwAAAAIiPAAgAAiIwACwAAIDICLAAAgMgIsAAAACIjwAIAAIiM\n", + "ebAARNHXxJZDTxQ6dP5jVlZ3bSfrnOKEpnMwp+1GgAUgkqEnL+0LE062F7vupjih6RzMY7vRRQgA\n", + "ABAZARYAAEBkBFgAAACREWABAABERoAFAAAQGQEWAABAZEzTAExck3mbcpvjKbfy9GnoecXW5ySq\n", + "u1wOYs631Wc+TbZ53XzGtN2mhgALmLwmcw/lNsfTPObLKdfXtmhSx7ntH1WGqrsY+ZSl2TWfsWy3\n", + "aaGLEAAAIDICLAAAgMg6BVi2z7X9Cdt/Y/v5sQoFAAAwZq0DLNsHS3q1pHMl3V3SBbbvFqtgaGtn\n", + "6ALM0M7QBZihnaELAPRgZ+gCoIMuLVhnSvpUCOEzIYRvSHqTpMfFKRba2xm6ADO0M3QBZmhn6AIA\n", + "PdgZugDooEuAdXtJn135+3PFewAAALPWZZqGmvN1nP3l/a+vP0zSLTvkCQAAkD2H0G4uO9tnSdoT\n", + "Qji3+PsFkm4MIbx8ZZnZThIIAADGJ9YkrF0CrEMkfVLSwyX9o6QPSLoghPDxGAUDAAAYq9ZdhCGE\n", + "b9r+cUnvlnSwpNcSXAEAAHRowQIAAEC5JDO5MwFperYvtr3P9jUr7x1ne6/t62xfbvvYIcs4NbZP\n", + "tv1e29fa/qjtZxfvU++J2D7c9pW2r7b9MdsvLd6nzhOzfbDtq2y/rfibOk/I9mdsf6So8w8U71Hn\n", + "Cdk+1vabbX+8OL/cP2adRw+wmIC0N6/Too5XXSRpbwjhNElXFH8jnm9Iem4I4R6SzpL0zGLfpt4T\n", + "CSF8XdLDQginS7qXpIfZfpCo8z48R9LHtP+Oceo8rSBpdwjhjBDCmcV71Hlar5L0zhDC3bQ4v3xC\n", + "Ees8RQsWE5D2IITwPklfWnv7PEmXFK8vkXR+r4WauBDC9SGEq4vXX5X0cS3mfqPeEwohfK14eZgW\n", + "4z2/JOo8KdsnSXqMpNdIWt5RRZ2nt373GnWeiO1jJD04hHCxtBhXHkL4siLWeYoAiwlIh7MrhLCv\n", + "eL1P0q4hCzNltk+RdIakK0W9J2X7INtXa1G37w0hXCvqPLXfkPQ8STeuvEedpxUkvcf2B20/o3iP\n", + "Ok/nVElfsP062x+y/fu2j1TEOk8RYDFqPgNhcfcC2yIB20dJeouk54QQvrL6GfUeXwjhxqKL8CRJ\n", + "D7H9sLXPqfOIbH+3pBtCCFfpwBYVSdR5Ig8MIZwh6dFaDD948OqH1Hl0h0i6j6T/GEK4j6R/1Vp3\n", + "YNc6TxFg/YOkk1f+PlmLViykt8/2CZJk+0RJNwxcnsmxfagWwdXrQwiXFm9T7z0omu//X3t3r5pF\n", + "EEdh/DkWASNpJG3EFNoFCzubgETBJqWxkeA1WGlhm8ImN2AVJCBCNGJrYasgGLQThQQMpPEO/haz\n", + "EiEgCDMI5vnBsl8v7HKqw+7OvK+Bq5j5SNeA1SRfgW3gepItzHyoqvo+rY+AHdrnNmY+zgFwUFXv\n", + "pv3ntMJ12CvzEQXrPXApycUkM8AasDvgOjppF1iftteBF3/4rf5SkgBPgM9VtfnbKXMfJMn8r1E8\n", + "Sc4CN4APmPkwVfWwqhaqahG4A7ypqruY+TBJZpPMTdvngJvAHmY+TFUdAvtJLk+HVoBPwCs6ZT5k\n", + "Hqwkt4BNjicg3eh+kVMuyTawDMzT3hM/Al4Cz4ALwDfgdlX9+Ff3+L+ZRq+9BT5y/Nj4Ae1fDMx9\n", + "gCRLtA9Nz0zLVlU9TnIeMx8uyTJwv6pWzXycJIu0p1bQXl09raoNMx8ryRXaQI4Z4Atwj9ZbumTu\n", + "RKOSJEmdDZloVJIk6TSzYEmSJHVmwZIkSerMgiVJktSZBUuSJKkzC5YkSVJnFixJkqTOLFiSJEmd\n", + "/QRSxC44KICduwAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['fc6'].data[0]\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(feat.flat)\n", + "plt.subplot(2, 1, 2)\n", + "_ = plt.hist(feat.flat[feat.flat > 0], bins=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second fully connected layer, `fc7` (rectified)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAlcAAAJPCAYAAABRvvFyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xv0LGdd5/vPJ3dygRADOzGJJsgdkWRxNyAb5BJw5OaI\n", + "okBE5CAiIJ6jgs6Y7XgDR5DjcMRZQ4KRYXB00JyIoyYoP424JKIJCTcjZ5JlgskOs4gKXkGe80dX\n", + "79TuXdVdl29VPdX9fq211+5fd9VT37p/+3mefsopJQEAACDGUVMHAAAAsE1IrgAAAAKRXAEAAAQi\n", + "uQIAAAhEcgUAABCI5AoAACDQ2uTK9jm2P2D7Y7Y/avs1xfun2b7a9k22r7J96jjhAgAA5M3rxrmy\n", + "fYakM1JK19s+WdKfSXqupJdK+t8ppZ+x/UOS7p1Sev0oEQMAAGRsbc1VSumOlNL1xevPS/qEpLMk\n", + "PVvS5cVkl2uRcAEAAOy8xn2ubJ8r6QJJH5K0L6V0sPjooKR94ZEBAADMUKPkqmgSfK+k16aUPlf+\n", + "LC3aFXmGDgAAgKRjNk1g+1gtEqt3pZSuKN4+aPuMlNIdts+UdGfFfCRcAABgNlJKjihnbXJl25Iu\n", + "lfTxlNJbSx9dKeliSW8q/r+iYvawIOfE9oGU0oGp4xgb671bWO/dwnrvlh1e77BKoU3NghdKepGk\n", + "J9u+rvh3kaQ3Snqa7ZskPaX4GwCAWbGVbH3z1HFgu6ytuUop/ZHqE7CnxocDAMDovlrSr00dBLYH\n", + "I7TH25s6gInsTR3ARPamDmAie1MHMJG9qQOYyN7UAUxkb+oAJrI3dQBzt3YQ0V4F22kX+1wBAObD\n", + "VpL0H1LSJVPHgmlF5i3UXAEAAAQiuQIAAAhEcgUAABCI5AoAACAQyRUAAEAgkisAAIBAJFcAAACB\n", + "SK4AAAACkVwBAAAEIrkCAAAIRHIFAAAQiOQKAAAgEMkVAABAIJIrAACAQCRXAAAAgUiuAAAAApFc\n", + "AQAABCK5AgAACERyBQAAEIjkCgAAIBDJFQAAQCCSKwAAgEAkVwAAAIFIrgAAAAKRXAEAAAQiuQIA\n", + "AAhEcgUAABCI5AoAACAQyRWwZWwdZ+sRU8cBALuK5KqCrSfY+oWp4wA6+m5J108dBADsKpKrai+T\n", + "9MqpgwA6usfUAQDALiO5AgAACERyBQAAEIjkCgAAIBDJVbU0dQAAAGCeSK4AAJBk61hbJ04dB+aP\n", + "5AoAgIVLJX126iAwfyRXAAAsPEzS8VMHgfkjuQIAAAhEcgXMGP1DACA/JFfATNl6qqS/nzoOAMDh\n", + "SK6qMRQD5uCsqQMAAByJ5AoAACAQyRUAAEAgkisAAIBAJFcAAACBSK4AAAACkVxV49eCAACgE5Ir\n", + "zJKt420dN3UcAACsIrnCXN0g6XemDgIAgFXHTB0A0NEDJd136iAAAFhFzRUAAEAgkisAAIBAG5Mr\n", + "25fZPmj7xtJ7B2zfZvu64t9Fw4YJAAAwD01qrt4paTV5SpLeklK6oPi3bR2LGYoBAAB0sjG5Sild\n", + "I+muio8cHw4AAMC89elz9WrbH7F9qe1TwyLKA4kjAADopOtQDG+X9B+K1z8u6c2SXrY6ke0DpT/3\n", + "Ukp7HZcHAAAQxvZ+SfuHKLtTcpVSunP52vY7JP1mzXQHuoU1OfpcAQCwxYoKn73l37YviSq7U7Og\n", + "7TNLfz5P0o110wIAAOySjTVXtt8j6UmSTrd9q6RLJO23fb4WNTw3S3rFoFECAADMxMbkKqX0woq3\n", + "LxsglpzQLDgP/PAAAJAdRmgHAAAIRHJVjRqReaCGEUAWbP2yrQdPHQfyQHIFAEB/L5b0nKmDQB5I\n", + "rqpRIwIAADohuQIAAAhEctWCrStt/cHUceAQ+sYBALLT9fE3266uWfBpkk4YMxAAADAv1Fxhzugb\n", + "BwDIDslVNZqbAABAJyRXAAAAgUiuqtHcBAAAOiG5wmhsvdLW+6aOAwCAIfFrQYzp2yQ9YeogAAAY\n", + "EjVX1WgWBAAAnZBcAQAABCK5qsZQDMNguwIAth7JVTskBwAAYC2Sq2r0uQIAAJ2QXLVD0tVP9Paj\n", + "JhEAkB2SK4yJZAgAsPVIrqolSbJ1f1tXTB0MalGTCADIDsnVek+T9JypgwAAAPNBcgUAABCI5AoA\n", + "gEzYer6tN0wdB/ohuVqPDth52/X9Q58zYPv8uKSfmjoI9ENyBczXrieXAJAlkqv1qBnIG/sHQCS+\n", + "sFSw9SybbdMGyVW1ups2BxeQKVuPt/X/TR0HsIV+S9LpUwcxJyRX1bzyf1ZsPdTWg6eOA8jM10m6\n", + "39RBYNaoDUeIY6YOYGZyOfE+JumLko6dOhAAAHA4aq6q5ZJEYb0saxYBYAtxX2yB5ArAtuDiDyAL\n", + "JFcYU3RNEzdTAEB2SK7ayakZKqdYAABAgeSqGjUiw2C7AgC2HslVtbpaoZySgyNisXWNrQdNEQwA\n", + "YKvldP/LHsnVdnmCFmP95Cq6KZOmUZRx8QeQBZKralykZ8TWF2y9duo4JsBxCmw5W/9i6xFTx4F2\n", + "SK5mwNa9qt4ePZB8HSPpUUMvxNZRdlYD73IMYDC2vszW06aOAzpW0tdMHQTaIblab/XmNfrNzNZX\n", + "SfqbsZc7kOialrFrbt4m6TMjLxOYyo9KumrqIIA5IrnK3z1r3p9jk9Dca1oeKenUqYMAgAnM8Z4z\n", + "GZKranUHEQcXkC/OT2wrju2ZIbmqtqxh4YDO29xrwgCgCa51M0NytV7OB3TOsWEcJP8AkCGSq2p1\n", + "Ny1Lkq1jMvvVGABge/FFamZmm1zZ+hZbx060+D1J10y07CVONrYBtZcAxrLr19tWZptcSfoVLUYk\n", + "H9Py4LpQ0uNGWiY3UKAZLv4AsjDn5AoAACA7JFfV5vANeI41WnOMGQCAVkiuquWUBMwh0ZtKTvsJ\n", + "AABJJFdtTXEzr1vmHJOuOcacM7YnsBtyONdziGE2SK6qcRAhO7aeYuvC8luTBZMnzlsAWWCspna4\n", + "ePcTnQzs2v74PUmfl3TK1IFgJ2xl8m7rbEmfTmnnrh8YETVX+Vs7oCkAoJVbJT1l6iCw3TYmV7Yv\n", + "s33Q9o2l906zfbXtm2xfZfvUYcMcXU7faEiiAEwhp+tgtHtOHcBc2NyDumhSc/VOSRetvPd6SVen\n", + "lB6oRVPF66MDm5hX/l99PwdzvPBFx+ya1wCwTWqvnbYebeuEMYPBZhuTq5TSNZLuWnn72ZIuL15f\n", + "Lum5wXEB2GyOCfaQ2B7YVuu+PF4r6TUTLRs1uva52pdSOli8PihpX1A8ueFiHWvIk5R9BWBXjfGc\n", + "XZKsFnp3aE8pJW3fja1ufXJaTw70vPbHFDgGgN2w6VrHtSAzXYdiOGj7jJTSHbbPlHRn1US2D5T+\n", + "3Esp7XVc3lQ4YIGJ2PoxSb+Ukm6eOhZgh23tfdD2fkn7hyi7a3J1paSLJb2p+P+KqolSSgc6lo/N\n", + "dr3WZtXWXgB22I9K+qKkH586EADbp6jw2Vv+bfuSqLKbDMXwHkl/LOlBtm+1/VJJb5T0NNs3aTFe\n", + "yBujAspETmNLkTTUY9ugjC8csTi/IHEcdLKx5iql9MKaj54aHEtOOJjmhxsrgF01xj2L+2ILjNCe\n", + "v5xq0ZAXEkoMieML6Ijkqh0uNnlhfwBbwtYf2nr11HFkasprHV/kOyC5qpbTTbvuwM4pxhwcPXUA\n", + "E+Cih23yRI03IDXnDgZFcoVtcahvoK3jpwwE2BIkIPMx5L7iOOhg7snV2Dt9ioOMGqp6dfvjn2x9\n", + "7aiRAD3ZOtPeyRrYKXBdbY8kq4W5J1dDyenEqzugOdDXO3PqAAbCfq+X03nbxV9LWfU5mvv2RAyu\n", + "OR3MPbka6uTnYBoG2zUWN7/tc5+pA9gRva9Ftn7O1n+OCAbbZ+7J1dBWT8CcbmY5xYLxsN8xFr4M\n", + "rfc9kv6PqYMosK8yQ3KFOdv1RCPbC6qtk2w9ceo4gBq7fu1oI9vrTM5IrqrNYeDOnGJpigtaf3PZ\n", + "76+T9IdTB4FeOF/zkcO+mMu1JwskV+vlcEBvk0Mnp6372fpMVHnbytYrbV04dRwddH0ofB+cr2hq\n", + "668dgdhWHZBcrcdBNZyHSzpdkmy9xNZPTBxPrn5B0k+V/iaBCGDrLFtvmzoOIAj3qsyQXFWru4Hl\n", + "dGPLKZa+/r2kH5k6COyUZ0l61dRBDMXWo2zt61tMSDB52qbrJzI09+RqqJN/my8qO8fWk+3ZH+tL\n", + "5WOTGwTq/KmkS6cOYsvtyn1iV9Yz1LbccHYRB3zz5OL3JT1pyEBwBI7P6fUd7X2bk3eOz/bYZi3M\n", + "Pbka++Sfw8G1zRfEPlof67YusPWYIYLpobx/53A8joljvyFbt9l6QYf5kq1HDxHTDI15vG1aFs8W\n", + "zMzck6uh5HSRbntg79KJMPS6/rGkDw28DGAKZ6l7be6DIwOZSE7XeGyhuSdXu5RIrOLiAGBIu3x9\n", + "BXqZRXJl61xbD5k6Dk2T0GxTEjXmxTpiu3Fz6Y5tBxSK5tR7TR1HR5zLHcwiuZL0QUkfr3h/qMRj\n", + "DgkNB/x6u7B95nCcYr62+fia4vpw8oBl78L1blbmklwdN/Ly6g7UKQ7gbTppoi/W23zxR3scD0A8\n", + "r/yPBuaSXAFtcaOdFhfi+dvmfTi368Pc4t15oyRXtu60dY8hih6gTOnuAzmHi8scRotvasztOcSy\n", + "ctjmrnkNYHtxrs/MWDVX95F06kjLwu5oc8GhgzuApdVz+RxbfzPIgsb5MRbjXGVm7s2CY9ck9F6e\n", + "rafa+t9tZmn5/lzMPf6p5FB7ht2wS8fag6XWv+Zreg2r+jFWW7u0L7bC3JOroQ1xQF8o6cvazmTr\n", + "+AFiGVtOIxo3QQLY3RTbjhsQmuJYaY4O7R3MPbkaemevlj/lwfVPtk6YcPnRhr64beuFgAc3S7J1\n", + "tK3vzSCO59l66dRxrGPr2219tsus4cHkq8u5tLPnHzabe3K1FWz9s61/12DS8oNY53hiR1+sh94G\n", + "q+XPcZtvq3Ml/aepg5D0DkmXTR3EBk+QdO+pg8jMtiWO27Y+szeX5KruwNmWm91xkh45dRBbZohm\n", + "wRwuYHN5cHPOsXVm61hbPzd1HEE27aNtub6in608l4c2l+RqbHO4qBxT0w9rDrFHaXXS2zppqECw\n", + "M75c0vdNHURDF00dQMaolcag5pJc1R34Y2fUuZ2Ar6p4z7Y+YuvfRi/M1rk9i5hy+z1C0ucnXH4U\n", + "vkXWy+38zN2m7cWxlo8pj206tHcwl+SKnVqt7heEXyPpGQMs72b7sH5fbU05AObpAWVs7c3b1olT\n", + "xwCMKOL6k9N9KadYoPkkV7ngAN5tOez/VPO6M1tnSfr7iLLKxQaXB8yGrbfZ+uGp4xiDrSfbeu/U\n", + "ceRmLsnVNj0CZpZs3T+4yIh916aMrTlWbN3PDhmYcOmegWVhe2zNOVNh6OvPqyS9NmAZOdj0Rek4\n", + "SaeMEciczCW5QnPhF0Rb50v6y+hig8vLbXlDsRa/LI18pMa2bBugq21OJIdmsf2OMHlyZesuW2d0\n", + "nb3Hcn/K1q1d58/YEDfKIR66vZGtv9vQMX/sQWRzk3N82Y7QbutUKayPWc77YJNNsc953TaZW5+r\n", + "3Du0k1ytmDy50uKBzl81wXKfKOnsms9ohjzcEBeR8rasa3I8RdLjB1jelGXkaFvXq85tkt46dRBA\n", + "CzknwtuchHeWQ3LVx9g3BQ6i+W6DLnGvHl85rPuuJUJDqBzvzNaP2HpAy7LmvD/mHHs0Hn/THc2C\n", + "FeaeXA0th2rfbb2h57Bem+QYY44xbYufkPRdLeeZ8/4IHaHd1vG2Ht4jnjHNLRnIoVlwnbltz8HN\n", + "Pbma84VtVdS65HyQb9P+ygH7GkNquw+/X9INQwQygLn1ucoZ26FCLslV75uErV+39eCIYEpyvnnV\n", + "ya6Tt60ftPXJlbebbtuoTpRz3JdoZ4p9vHaZtt5p681jBVPju2vej95ekw1Ea+sBdq+HUx+xLYpm\n", + "4mzGb7J10pp4hrzub+rQTrNghVySq02aHDjPk/TMgeMY8gDauk70tk4pfpn1NEkPUvxDh9uUEbG8\n", + "HPZFUsd1sfU7tl4cHM+u27QvvkPtmxrR3k2SfrnH/FXn9kskPb/lPEO6v9bHM6Ucro1ZmUtyVafT\n", + "DrX1g2r2LSuH6s4cYihrE88fSPoL9TvxcuprkMO+6PMIoWdIesGGMrE7QvtcZeDkFtNG9HHdlfMm\n", + "518qZuuYqQNoKLqz95tGXt6YcrogfpUOH/27vP3GjjOn7dLXoOti6z6SjkpJB/sUExVP5rbpuMrB\n", + "WNtzjONzV84BmgUrzCW52pWDdJMm24EnmMfJ9YIRvW9X1/NaSffWYgw6rDfn82zT8T3Fuk21PdPK\n", + "/23mGUOO+6q87FyvlZOZe7PgLsjtoK08iW0dZ+uymnmq1mEOj79ZnSeHfRH+4GYduZ5nSLpXUNl9\n", + "3d9uvJ457J85mXNimA1br6z5KPJ4nDp5qozB1mlatFBw7q3IJbnatGO2rrN3C11PqrG3zZmSXjry\n", + "Msf+lpnLzWgOx33Utpri6Q1tTL4vbH3RruxLh3qR14Nv2/D5Nvtv0uS/hs1SLsnVJrkcpBtPSFsP\n", + "tfWVAy1/qs6Wfcuq2m7blOyMaehHEeXmX6cOYINJjsFimIBlQnW0pEd3KKbrl9oh9VqmrafYekKT\n", + "SQNjGewYsHV6y1gGCWPNZ8s+tTlfQyaRdZ8rW+dp/S9Acry5fkzSLZLOm2j5Qx/kUdt8Ds2CuZvr\n", + "vmgj9+RqKj8h6ZOSfrVHGTn+CqzPMvcX//5BNY84WmOIx99EXIvvuXkSSfPqq7YTcq+5+oAWI/52\n", + "3nG2bGtf19k3/F3nuI7Li7CMMdm6Pai5YBtOnG1Yh9mz9e22HtRiltyTq6yPKzvrxLk3W6+09QdT\n", + "Lb74P+QYqDkvsj6+UC/35OrogDK+WdIdLefpe0DncEGzFh2Tn9hoYus0W+esKauP7C8Qts5r8Fy0\n", + "HNYjhxiaqDtm/qsWtS5NtUmupmhqbvML3tzM5Vha5/mSvm7lvRNt/Y8N82W17rbuIR3xFAtJ+tLY\n", + "sVRY9wv0ZXxZbc8c5J5cLdVdnJrs0Pv0WO6h8m29T9LxDecb6mI65EX6f0r6qxFjGLo/Q5Iku/GI\n", + "xsta0iFiiTTlWGFT6FxzZet3ez4SBYFsPdjWKzZMFnVMf9OmcAZabld19+JJ4rL1WltvbzApzYI1\n", + "5pJc1RnzZvcNIy4rQtuD/csCy2pi6MfRLMt/SINppepa0hySqSpDj3OVkz7Ngk+X9NCW87TdFk2m\n", + "z7Uz8tgjtP+IpF/cME2u51yViGfifsDW4xosY+xxrl6ju59JOad9ko1ckqscf7UidT+opjwYl9tq\n", + "0F8L2vrUhotCWQ6Pv+ECUW+IbdOoTFuPtvV3aybp2+fKxXL2t5m+bflbKut1sye/f0Vsn/2SnrXm\n", + "85y/+EjUXNXqdXDavsX2Dbavs31tVFBVixqw7CEMddLn0L/jLFu3aDH+0Kb+XOtiiWgWjCh/3fSr\n", + "7+VwAUnKI44+yvE/StIpa6bt3aG9eHj4B/qWs4VmexzZ+kbF/tihz7aouw5ty8Pi1yG5qtE3CUiS\n", + "9qeULkgpPSYioBVzfbBoDslg5LYpl/UwqfU4XlW1aUNvo4g+FXWj0d9h6wc6lBfBquhgausoWydM\n", + "E9Kg+g4Um9TuWBuiWbD1sW7reLvxz/DXLaNPs2DOHthz/ojr41C16vcbYBl9rOvQTnJVI6KGZYwT\n", + "dKoHKXc9YLrEFX1w5nDhzOkCFrGc5TbdJzUaqHBMl0j6xwbTNR7x3Nattn6ye0hZaNp03dVQ59ll\n", + "kv52oLIx7X1rk/KXpMkHMkU3ETVX77f9Ydsvjwioonxp/ANniuU2+eYZOarwokDr1GIsnKbr2meb\n", + "5PSg08aKWqGcvplVxfLghvO2eRjz2eqeROZysf/ZqQNQt2Px/iMsI9e+rk2M8aOO8q/Fbetetk63\n", + "9aiGMWxLs2CT7hc5xJmVvsnVhSmlCyQ9U9KrbDcaU2lkb5tgmTncWNYe7Pah0fnv0mIssLWT17zu\n", + "E8vYJ2OfJuYc9udSuZmLC1q8tvs6933Qp1kwp+N+at8o6W8k/YKkP10zXZdtNuftTHJVo9fjb1JK\n", + "txf/f8b2b0h6jKRrlp/bPrB4dYmkqx4v/fGvd11UnzgnENks2Hbd17WPLz6wHiHp+tI0Z3ZYTptY\n", + "2n7WdLo2CdGcmijXyf5CbOtiLY6pOpsS/3tJh56plrvs98cAcjgP+mq7Dsvj+dgWZURup6l/GVln\n", + "1seC7f1S418St9I5ubJ9oqSjU0qfs32SFmPK/Fh5mpTSgcW0ukQ68Mc94uwziOjgioEK/z4l/cvy\n", + "rcjia153mX/pjJZl9N3Ooc2spUf6DNlRuWxZIzv187vq/q57byq/1HP+y6TGg7+W5ZpAj3Hc5NCF\n", + "IeKJGmOJ2F5VNcip4vM+sSw/25RcDbn/t7ZDe0ppT9Le8m/bl0SV3Scb3ifpGtvXS/qQpPellK5a\n", + "M33kz+ablDmmz0p6c+nvXL9ldNU1wVu3X5vu86rpHtthvj7HyvJn/FMdb6vLzeW4H0qbfmHRdqlZ\n", + "MLrmZduue02NcT7mvm1zPw9G17nmKqV0s6TzowIpHlr5zSkd9tyxOd1EvmLqAApDj8009qCerY6B\n", + "HsMRVK1Xjsdfl2/G2bF1tqRP13w8pwt1ox+Z2Po/Je2lpD8bKI6woUZafB69PGm6fT/EciPH8hvt\n", + "XC+ec1j+grNu2Tk8+zBLg2fDLZ7K/gpJP17z2ZwutlLsiZDDzbRvDH2qjl9nt2pu2IYb9qrV7d94\n", + "XWydFR9OiFvVrelvaEM1C/6spNcPUPYm755gmX2MdY0bowm5y/hmdfP0HPC7/hmbth628mvo90o6\n", + "rWHRs24WHNKYVY2bqqfXjbY7aJ8rW19h65GB5Q7V52rsZfctM6o56+QW09ZdFLr8WjCXC0bddmwS\n", + "320ZPCakTt2+ymW71yol/LnHuu6XwOfYjYfwiJDTtorscxVRzqahePrWMn7W1tfXfLba6tJ4LLyS\n", + "nPZtFnK66HapXow6uK+Q9OGgsqQZN9eMqM3JeGzN+0Of0JP1dbL1Hlu/VfHRSS3KGHzIBltn2npj\n", + "y9mGGkduzAv8F4v/c27qOoKtf7IPdef4N5I+YevEKWOSlMNzAof4ctWl3+cgNVeF+3acb2s7tA9p\n", + "jAO66QW0quZqrB0XfZHvsl3bjBAeVV7Tstc2C9p6rKrHE1u3/9qsS11yFbk9ord/YzU3ludq/QNd\n", + "V63bxkMmhc+W9EMd521SI53beGhzd7yO7Cvb9stL3fuWWnUFKVsOVrtNI5K36Ve6qebqs/3DGaSf\n", + "K0lVjVyaBaX1NVdzOJH6ilrH1VoB23q6rTf1KHNTbN+pxbfgoRwXUMbkx5CtB9mVVe7/aq8d16nv\n", + "r2nD170Ytf4lfYtpOk3HG/YYJr25lJp6xuwOMMSyls2sOfW5yumY+4eAMqK6d5RRc1Vj6qrYshx/\n", + "dTDEwTi0qmW/TtIPjh1ISd8Tr+6b9dx8UtKf13y2rrmvbkDUTcdZ1fkddWyeI+nynmXkOH5dZI1v\n", + "m2m6el2Hedr+AvfhLcvNKSmpU3dOlUX3R+vyq8DI2iYXj/G5YMO8bc4BkqsavUZob6jpwVGVXA3e\n", + "Z2QgfX5RF1XuUNusTQxRF9mI4zTip+oR6xOxLm0vuK+2Dz3UOadzqe6Xj1XN0K1+JdnDHBKDKkNu\n", + "mxtsPTAl/eUIy9rI1nOkw36ANHdjDcVgSY/Q4gveXI/z2RgjuVratDO7/FowV11qBIccU6bJN8/K\n", + "C6atkySdEhJR3nJuJujbLPhz0qGnB+SkSXLVxhQ3/SbLHDKuLsdkl3nK94q+v2xbp8m2uqJH+ZHm\n", + "Npq/1a0VgGbBDsZMrjbJqVmw0QFj6/iU9M8jxNNG1SCifX4N9Ac6/Fti1Ym2qXlnqBNv6BM66fB1\n", + "++qBl1enrto+fJydkbVpUsupL05ZdLNg41+D9jDVcTF1E+o6QwzC2nT6Jh3aI2wsy9Y9JT2wxfzL\n", + "7ZZTF6Ms5PJrwU3jXE1lU+x/GLisXJsFH9Rj3tVm3XL8Xdr168qP0OQXjaF9v2z9la2Xd5m14r25\n", + "jDAvbe4zNuW34Km32WtbDpq7NHXcUlAibOueGQ9+W8kO+dGNNGw/3ybn2z1alr2c98UNlr9Tcv+1\n", + "YPSzr6I9auLlV+l6gevTcXKMb31R8+bkHElPHrD8NrWMwwRgPcDWU1be/tYOsfQ+Xup+cWjrDLtz\n", + "Lf7U16CxmgXHLP+/S7otIpARVSXEtceGrX22/n75p/rXXH1fg2mG2O9TH//Zyqkqb+wbdISpl99E\n", + "TjH27Ts0pLEuEl06yVc19XZZVpt5o/yypN+r+azJN+kx9v3t6v5r2qnPr6mXX3ZYLLZObzGERrmW\n", + "u+tgl2Pr0yx/P1V31xiyeZDkakS5NAvOVaMTwdbX2rozYBldmwXnvg/mHn9fdQnZpu2S+3aLrrna\n", + "1Hy8rox9LWJpa4h+XF2mbTtP3y9Dn5H0LR3nnYO59bnqer9v0iyIFaPXXNn68qLTXKPJG5aZUw2c\n", + "JB1j68tKfz9e0n1GWnbf/k2bdEnwhnrcSaSxLhJdHonRttzvaFn2VPul7rzt9cXA1hUr518bbWsj\n", + "cvmVaa/j11aq6OvVtk9c1fRNk9apb9Ktlm/rfl3KtPWfbH1nm2VlJOfrd3YGTUpsXV/+s/j/05Le\n", + "E7yoHDvD/0xQOREXnakuXFEn4+xPalvX1nz03LpZSq/bPoZkOfhh11rPHLWJ/zk68hEvTcsYqq/i\n", + "0GVGxNG031nXGtOph62IXO6rG0xTtR2+V9JrK6arq10d9deCHeabOinO1tA1Po9Q9Y5ZbVPPbQdF\n", + "1LQMsW3b3BzWffuPviHM4cY96jFm66KVTtKPrpn0+CbFdQyj6QjtuSXfTWqu2sSc9fFp6yW2zi6/\n", + "1Wb2LovsME/ncm3dt+h7lfN+CPmlY8NlTIU+VyMaozntjIAymu7A6B099ckgDfNto48u5VaNyxR+\n", + "c7R1c98yAuZZ+m1Jzwgus62q2q+cLoZj/2J0lE7Btl5g6/9pUebl6vYYm0bxBM1T1rbp9KCk5zcs\n", + "e+prbuSnufsoAAAgAElEQVTyI58KMeSx26fvZk7Xk6yMkVz9dPF/eQc9SpKi+161mC4bdueLalN9\n", + "D/6hqqWH+HZ+bosyV839InFexXu5nw9taqXqakWaNJ+OvR1eLel7Sn/n3qE9smN2nXUPJt8GVUlQ\n", + "5H68SLr7mYC2nm+37sd7VMuYmpj7dXMwU/9a8G9Lr3d1J72lxbRdfjEV/cugPh3a52bTCP1/b+vU\n", + "yDJrpmsyT9XI3rknV02uPzn0ORl7uWPHmUM3garuDP2CaD4MRFUcXedbN3+TpLQu8f1+Se8svf/e\n", + "4r02+u7n3K8nWZnsV3YND/y2J9qFXWJZI4eDaarxl9osv2mNQW5NnGVdRjg/UdKZA8TSNI5NtTZV\n", + "F+2cEt0+NVdD1+6MUVZEuZE1V9t2821zfxujz1XV8pavx1iuFT+eZE7Xk6yMWXO17uIYVZ3/TS2n\n", + "3ySHi8XU33pblVeTNC9rVXJOruauahs1fW9I6y6+TWLp2h8kh3Xvaqqaq6ha7j79MueQCFeVPVSC\n", + "mvv2ILmqkdv4ULssl/FyNukSwzPDo9gs15O+S//BJkMxbEomGiU5tn5R0gkbo2uuSzNJ9HMSy+tX\n", + "99y+qWv25vQ8xa4do8c2ZrNg2/lXz90xtukQX25zvc5ObsrkKrcTsWyKQS+jljXFwT70dhrjIjmn\n", + "i8Rhsdp6jqSHV0xXuw1sueZhs6/oGVsbIQlTyaZ+apb0rg7ltvk8wlQd2qPWrU85kedhl2bBppom\n", + "R3XLmOL+N0Tz45yum6Oa8sHNOSdXETqvn62jbR0bGcyI1tWWNNomtv7c1lvjQqqMZU6etPL36nZ8\n", + "waEP3PgC/jpJ/1y8HnLbdGkWrKqR6/PNvjxN3XhjrbdBcY7eu+18dcXVvG4zX1fL+0DTsr6n5pfe\n", + "EbFMXVPTpWa5/HffZebcLLjpCw1Kpvy14BySqzFjLB+kvybpLwYoN2L+Phf+pvNeIOlpHZe5xEm/\n", + "/qL9kDWfDRVDm8/G1iWWi8OjaK9x3HblsDityig8TtI3RMQ0sLk0C0YstwlXLLfpfHW4ztYguRpO\n", + "n4Pu0eo+blH0N5+o/hhdyuozX641pUM/57EuoaqsCbV1pqQ3N1qY9YrgGtUj4rf1H3X4I4HqagSm\n", + "uHGultFkdP2mxnjQ+utryh+qM3b1RA7vU1fnH1pM27cbQZ9mwTFrrnK5Dm69MZKrOTy0t05onxBb\n", + "z5N0oEeZUU4JLi/nby9HjLVl6922HlQzXaRNyc8QyuU3Ob+/UdUjyd9doHWhrZdJ+kVJX90ynrbN\n", + "gv9Xy/K7fOGoMvUxPGZ/nF3pc9VF11ryJtvwh4OXG/XFt3ab23qppPuvKXPq/ZWtpg/q7KNpzVWO\n", + "Oyn6IvfQEWJo8q1wU6fedeVV9aka+2bQxLrYvk3Snyuu6XUqET+JbzLNWyQ9psF0bTVppmhz42/z\n", + "68k2n+Usss9VX7n1uRpy+V1aZL6z9HrosQGblF31/uo0l0n64Joyc7xvZyGXZsHcdlBEPGPVhDSx\n", + "Gkub5oy2N6Rcb2Cblj3E/qoq8x4dR45uqmkNSFXN6tj7p08zRZ++f30MtY1qE0Nbjy5qvaPkXHM1\n", + "lTG7T3yNFgMQ911+22tW3/t9VYy53buzkctQDJOdjDXt/9E4ABc630htfaPdqqa1smbUzmJst28d\n", + "sOy251XOCW+Tads0dcy1Y+4vSfr1ms8ia4vG7p9ZlsujspquQ10y3HT+8jAoXftcvX7NZ1W6Xg/m\n", + "et5MKpc+VydI+tkRYmkrqs/VmDewUZvobJ2nw59rt3H5xfhKbceguVLSE1vMU6euirvtRaLPoK9n\n", + "t1xWG02Pu6rzsktTR5+L65DJ35ySzNXlj10rF30fmHMNR9dmwYjuG0MLqSW29U22/ktAPFstl2bB\n", + "qsEMsZBFDd8a/0uLPkxt/LOkNwYs+15rPltevFYfrPy4gOX29TPB5XVJipaGaCoYYt6Ivii9zh9b\n", + "D5b0lT3LONnWXaW/q5rox+7DOEbNVd++TEOLWvcu67mueXyQJm1bjyw6qzdZ3up73y3pu4rXXwqK\n", + "bevk1KE9RxHV3Kuv22p784v+RtS2vKYX2AcElblJ21+fRWqz7bqs4+kbyomqsVnXxDZ0crVpmrq+\n", + "m22HNmiyrz7RYJpN7qPDE/5/arH8Kjk1C66WN/Q8Uvz1rkuzYJf56+YZqz/mz0h6iqR3rpmmibnU\n", + "SI6OEdqHE3XCTL2dIvfbqOvSso9W6+KL/1+yaRq78tE0EV5Q8V6f5GrsY23Ix5O07TsS2aG47w1n\n", + "qpqrqHKjvpS2WebYorfhqDVXE82/U3Lp0N7VycUgiEPJ4WCaW9+RdULa/Fv4rs2THNL1htikU2lV\n", + "ErQq8ubepMwTGkzTpOypku3VfiDPUs1AqT2X0ziGBu83HfNr6D5Xq/O0ffyNNEwfxSn1PZ77zD9F\n", + "zVWbadbNl/t+ncwYzYJNdD2gLteRfWq6WD1AoodiGKrT7xSJVJtmmrGWWafcJ2ubLwJdfrn0ogbT\n", + "DK3NxX5TIvNbkt7bY3ldjo8cfnnaxdB9rtreoLtMN5QpmgXXzZdTzVWVbb6u9jJmh/Z11ahdd3pE\n", + "YrVu+VHfrAf7dm/rNPuwTrY5H+xHrIt9qAalid/vsexN22Wsca7qDNHfJaIpbdO0U98Mm7i+wTRT\n", + "r0fY42+KX+O2mqXLYjrMM7oBx24bqrvEkN1nqLka0RjJ1YNr3p+yr0dTOcS1bjslLb6t3zJaNJu1\n", + "3Wb3HqDMydj6tH3ocRFDNe+8aM1n5XKanN9Db9u2j79pOk3V+3XLOq3F8tro0vzXtqzDJ7K8kjBU\n", + "zdf2uj5GzVVTU92so7fBJnX76JU9l79pmY8vXkfXvGHFGMnVw2re/7dVcRQPh33bsCGNbsixgKJq\n", + "75oqx1O1Xv/YcN5uC+/+TXTTEAxRTeRfLun8oLLqfOPK331qXofuY3LBms+OUvNzY+hmk7VxtDzu\n", + "wm7Qts6WtK/02bskfaznsrr0uTq5w3LKpk6ahpp+db6+8/9kzft3v9H9GvhwSW+tK7eBNl9odt6Y\n", + "fa5Wd8wP1nz2fZIebOsKxT51fkpNDuSuI/52eTr73LStjaly0YbPz+1YbpQu+60qYWxbI9y1Brnp\n", + "tPfoWcZYzSKblnPfDvN0nb483S2Sji79/URJX7GhzKiaq/K+u7ZmWU3KqXtvXRlNRTxfM8JYSVwf\n", + "TZqL1+47W0+X9NTSZyRXNabs0L7pon71WIGsMeYJ0OSb+dy/OUR09hxqn0zd5ypKn+Sqiz61zH2S\n", + "uT438BzVHStH17y/TtMkaNP0q8+/G0vkedM2qZuiWdBr5svtmH7Nyt9zuv+MaspfuxxV8zonbQ7s\n", + "yIOsXNambbM6Qm7bZ6qNKSKOqGPlOUHlyK5tmq1dX1uXNJ22hyYJSNua0abzNXFYGbYe2bOMXGox\n", + "+va56luDuOkc6dIs2CaWPl8CU0AcZWvLsvVlbaZvsJwxjrGIL6ltzuvye19Y+SyXZ0JmZ8pBRFcz\n", + "9ykNMRTDiba+qkcMS11vfm2naWqKfTVEzdUTJcnWo+za8ZGauk+HeQ70XGadtjWdY9d0rSvrKWum\n", + "adu0XnfMr2umXCzI+oYGy1pbRObz1yXYnZdr668kPb3io6Fvum3XddX3dFxu3+4Yq+ddSM2VrePs\n", + "w571WhbxA5fV5Ao1qLkazjdL+lRAOZtufo8OWEZXUyRa0cfKn2r9r+/G0mdbdu2v12e5UTVXTcs5\n", + "q8HyN637qRXlVHlfw9H9u2yDpvOM+cisLuuxGt85xb/V8rokbnNoFuybDPW5jq1bxrskfabDfE2X\n", + "+y8r7y1bTqi5WjFlUlMem2nqmqs6OcQ1akfJlTGzoo3Z56rNA0WPU+zF4dc6zBN1rPWp5WtbO9RX\n", + "m+TvIz3KWGrSh6hvk1yEoZsF68rI4XonjdgsGLjsPjGvm7fqs3esmf6hqq+dLZf1tS2WV37viyuf\n", + "0SxYI5cao1xO6qEMORRDtFs2PFJoqItI0/maHrNzf1p7m1/KtvkW3bbPVdtljl1GtKNW/m/FVpLW\n", + "fkEZ40HDozcLril/6ptv3TodZR82xMXQy1s33boa3Krj8DvaBFSzzCYJWBWSqIam7HNVlkuSt2qI\n", + "i02feceqWWg7wnNTXW4EXaffmFytjBcz9UVjqpqrLJIrW3dJekDP5bfu0G4fkcTWJVdtjt1zat4/\n", + "NI+tMzZN01BkzVXfctqUvU6bc7HrjxheLOmOiun6ng/RzYKR98aIc72uf/LU18/s5JLUTP0NNqQz\n", + "YU91yUDbKuOhRS+zbSfLyD4rU9TCDW3TD0X6dmiPVF7eqZK+esM0m8ro4vSVvyOSqzrlX8I9c810\n", + "EX1j2nxe92vBrteevttqjGbB+274PGo5TaZvW3PVVdWXi6Ml7V83zQqSq4ZySa5yiWMoTQ68LsnV\n", + "d3aIJTdtL0pNj5W2yVWSJFv3tvU1LeeNUK7FiUr6qrbVLjcLNlneoeTK1pNtXbtm3i7xj9G/adM5\n", + "sprE1sV0WDkdj8vK83DAZ/4dsajg6Z8btLzoGq6uy3ySpB/oMT9JVQ2aBauN0S9iVZPkarWcNkM9\n", + "DKHtdurahDFUzdVq50xJ+nnVd54um/LmuM5YzYIRrMP3U9WQGJG1yq2SKy1G9X/0yvt9Re+TLknf\n", + "tzecfnWdm26DqmOwzdAFY/5oYrmssZsFm37JGTq5Wh2kdtPxRM1VQ7kkNbk2sSz7R4zxGJ665GqK\n", + "fbRuMMeN+2rNt9Ku3/431cZEWC5j4zhIAy9f6jYq91J5+xyoWs6aB/+O3XSzWsajAspYp8mxsxzj\n", + "qmtisUmTm3DfrgBtY23aLDhGc120XJeTS81Vl2mqkFytyCW5GjyODQN6bhrA86E9F9/kwPvXDTH0\n", + "8f6W07+39IvBugHp1hnyJh1d7S4t9s9yXKMhym9bXp/zoTzvsxosK/dmwcjtXLVd77Xy9/KXfkP0\n", + "uSrPE9VZvGtt8Go55f/ryin/ve6atq6mo2qaPtr2L+tbXtT8WfS5WrPcptNQc1Ujl2bBMb5dnD/C\n", + "MupUdST8fVvfXXqrS7NgU3/WYZ6oG3xZRLPgUMfsMrnq0/RRp+7xOHWGGmBw+XlUn66+xo6jqkbw\n", + "Yw3LjzrumjxqZuhmwVW/1LDsLtsgslm3i7bJzlTNgnVyq7miWbChXGquRmsWtHXuwItoepA9WYtR\n", + "3Je6dGhvatm8eVhZtk5YN09N894YfUbWTTPUsdKn5mrTefS9Lcvr0yzYttmo7bbtexOqi6OrNnH8\n", + "botph665Wjfvv29YVt21pu12XQ6BsSmZikwcos7j6OdJrhvjr8kyvs3WvVvOsy7GHIZiKM8/xKPi\n", + "tlIuydUocdh6uKSb28wStOgmVeNDJld1/nHD511v8tE1V5vKiNCnuSb6+B2i1nBpteZq7GaTtmVF\n", + "JuqntShryj5XL+9Q3qb3upQVsQ2GbhbcZIzlHF1azn0lvazBPE37s0VeW6rKavJDA5oFO+i842xf\n", + "ZPuTtv/S9g81maXjZ5HWPv5izQNbW8T3ga7zD9ks2KW24Sip0fPVCnur80rSKQ1mbHuD7dJs10bL\n", + "b+d7fZZVt9whmwVXp+mYXL0w4pmWEc2CQ107ampt9qpikK1T7VZN3ENe8wb4ZePeyt9N55tds+CK\n", + "veWLddfCY1ssZ2nTeHSy9UJJz2hZbtNl1i276jgvO5RE2fp6kVzV6viIBx8t6W1a/FT5oZJeaPsh\n", + "PeIYo9mnSV+T9xX/r/48t2n5kv6g6zftKWqu1jlG1ReUTRchqV2T4pQ1J1VaJm97beZpashmQSuk\n", + "WfDPx0quhk6S69TU2uzVTX+X2jX/Rh3HVeVUDWnRpazSNthb+bu33JKrGnvLF5uSq7ImiUaTJtf/\n", + "Jun7G5RVy9b/sg89mL7FdWXvsGJqJvpKkVTValEzcZjHSPpUSukWSbL9K5KeI+kTHcv70Y7zDW2s\n", + "fgHScL8W/EpJr+pQ1jHqfpE+qmbers2CUbU6TXSpGYvuOzRks+DqsromtxHnxrdIenxAOUPo0ufq\n", + "KxqUO0bNVZMHVFfZ1FTVpRboe4r//3PHsvqqW07bpCC65mqMCgVJOk/SLxavq64NqzVjm2IpbzfX\n", + "vA91T67OknRr6e/bJD12wzz3tGt/NXW/0uuq59odLy2q3jcFtmaaUySdXPPZoY7dxfzLsY6W/9cu\n", + "t7S8e1Qtu3hvebFbveiVx1Q6oTR/eX3LMd+rbv1K7y+nXy7r7NJk97YrB848SUc+KPg0Vdemldeh\n", + "bpiGe6v6RK7at/dcvlhZt3Jn+3LzYnl7rtvfJ6v5Taa8jU/cUO5Sed/V7ZdTmhyzhfL5cUSH2A3l\n", + "lGPZtLwTV6Ypb6Oqee+hw/dFEeeJhx0vm9az5vN7SHrQ+nDvPi5XylgeE+XmuOMrPm9q9Vi5tw4/\n", + "FlaHbKia57DzYfV81uIHLD+/jG9lfVbPpSN+bFJMf1zNNCeVyrtPRaxNLI/jh0r6oKQ/Wvm8fFye\n", + "vGaf38vW54rXD6yZ5lT7sHVZrv89VaxXw3Nn3Y9ylsv5kha1Nv9Sen+5T05c+Vuryy5erx5PJ+nu\n", + "L5Anq3Qd093XkxM2XJ+WTlyZv7GKOKu23XLbVo3XeKhmrJinKo7lfIf2TancoZ5DO3tOqX3Cafub\n", + "JF2UUnp58feLJD02pfTq0jRksgAAYDZSSiE1iV1rrj6tw5/8fo4WtVeHRAUIAAAwJ137dnxY0gNs\n", + "n2v7OC36TlwZFxYAAMA8daq5Sil90fb3ajEo39GSLk0pde3MDgAAsDU69bkCAABAtUF+1t5hgNFZ\n", + "sX2L7RtsX2f72uK902xfbfsm21fZLv2Kw28otsUnbT99usjbsX2Z7YO2byy913o9bT/S9o3FZ//3\n", + "2OvRVs16H7B9W7HPr7P9zNJns19v2+fY/oDtj9n+qO3XFO9v9f5es97bvr9PsP0h29fb/rjtny7e\n", + "3/b9XbfeW72/l2wfXazfbxZ/b/X+XqpY7+H3d0op9J8WzYSfknSuFj9VvV7SQ6KXM+U/LR6hc9rK\n", + "ez8j6QeL1z8k6Y3F64cW2+DYYpt8StJRU69Dw/V8oqQLJN3YcT2XNaPXSnpM8fp/avFL08nXr+V6\n", + "XyLp+yum3Yr1lnSGpPOL1ydL+gtJD9n2/b1mvbd6fxcxnlj8f4ykP5H0hG3f32vWe+v3dxHn90t6\n", + "t6Qri7+3fn/XrPfg+3uImqtDA4ymlL4gaTnA6LZZ/TXksyVdXry+XNJzi9fPkfSelNIX0mLQ1U9p\n", + "sY2yl1K6RouRp8varOdjbZ8p6ZSU0rXFdL9cmidLNestVQ+wtxXrnVK6I6V0ffH681oMCHyWtnx/\n", + "r1lvaYv3tySllP6heHmcFl+K79KW72+pdr2lLd/fts+W9CxJ79Dd67r1+7tmveue2BK23kMkV1UD\n", + "jJ5VM+1cJUnvt/1h28uHrO5LKR0sXh+UtK94/eU6fJiKuW+Ptuu5+v6nNd/1f7Xtj9i+tFR9vnXr\n", + "bftcLWruPqQd2t+l9f6T4q2t3t+2j7J9vRb79QMppY9pB/Z3zXpLW76/Jf2cpB/Q4YNDb/3+VvV6\n", + "Jw28v4dIrnahh/yFKaULJD1T0qtsP7H8YVrUG67bDluxjRqs5zZ5uxaPkjhf0u2S3jxtOMOwfbKk\n", + "90p6bUrpc+XPtnl/F+v9P7RY789rB/Z3SulLKaXztXiKw9fZfvLK51u5vyvWe7+2fH/b/jeS7kwp\n", + "XaeaR9xs4/5es96D7+8hkquNA4zOXUrp9uL/z0j6DS2a+Q7aPkOSiirEO4vJV7fH2cV7c9VmPW8r\n", + "3j975f3ZrX9K6c5U0KJ6edm0uzXrbftYLRKrd6WUrije3vr9XVrv/7pc713Y30sppb+V9FuSHqkd\n", + "2N9LpfV+1A7s76+V9GzbN0t6j6Sn2H6Xtn9/V633L4+xv4dIrrZ6gFHbJ9o+pXh9kqSnS7pRi3W8\n", + "uJjsYknLm9OVkr7V9nG2z5P0AC06xs1Vq/VMKd0h6e9sP9a2Jb24NM9sFBeepedpsc+lLVnvIsZL\n", + "JX08pfTW0kdbvb/r1nsH9vfpy6YQ2/eQ9DRJ12n793flei8TjMLW7e+U0g+nlM5JKZ0n6Vsl/X5K\n", + "6cXa8v1ds94vGeX8Xtfbves/LZrL/kKLzmBvGGIZU/3Toirx+uLfR5frp8WDjt8v6SZJV0k6tTTP\n", + "Dxfb4pOSnjH1OrRY1/dI+mstHnh6q6SXdllPLb4R31h89vNTr1eH9f5OLTow3iDpI8VJtW+b1luL\n", + "X0x9qTiuryv+XbTt+7tmvZ+5A/v74ZL+vFjvGyT9QPH+tu/vuvXe6v29sg2epLt/NbfV+3tlvfeX\n", + "1vtdQ+9vBhEFAAAINMggogAAALuK5AoAACAQyRUAAEAgkisAAIBAJFcAAACBSK4AAAACkVwBAAAE\n", + "IrkCAAAIRHIFAAAQiOQKAAAgEMkVAABAIJIrAACAQCRXAAAAgUiuAAAAApFcAQAABCK5AgAACERy\n", + "BQAAEIjkCgAAIBDJFQAAQCCSKwAAgEAkVwAAAIFIrgAAAAKRXAEAAAQiuQIAAAhEcgUAABCI5AoA\n", + "ACAQyRUAAEAgkisAAIBAJFcAAACBSK4AAAACkVwBAAAEIrkCAAAIRHIFAAAQaG1yZfsc2x+w/THb\n", + "H7X9muL9A7Zvs31d8e+iccIFAADIm1NK9R/aZ0g6I6V0ve2TJf2ZpOdKeoGkz6WU3jJOmAAAAPNw\n", + "zLoPU0p3SLqjeP1525+QdFbxsQeODQAAYHYa97myfa6kCyT9SfHWq21/xPaltk8dIDYAAIDZWdss\n", + "eGiiRZPgnqSfSCldYfu+kj5TfPzjks5MKb1sZZ7NBQMAAGQipRTSKrcxubJ9rKT3SfrtlNJbKz4/\n", + "V9JvppQevvJ+klbL/klJB96Y0hfe0CdobB/bB1JKB6aOA/njWEEbHC9oynaKSq42/VrQki6V9PFy\n", + "YmX7zNJkz5N0Y0QwAAAAc7e2Q7ukCyW9SNINtq8r3vthSS+0fb4WVVM3S3rFcCECAADMx6ZfC/6R\n", + "qmu3fnuYcLDD9qYOALOxN3UAmJW9qQPA7mGEdmQhpbQ3dQyYB44VtMHxgimQXAEAAAQiuQIAAAhE\n", + "cgUAABCI5AoAACAQyRUAAEAgkisAAIBAJFcAAACBSK4AAAACkVwBAAAEIrkCAAAIRHIFAAAQiOQK\n", + "AAAgEMkVAABAIJIrAACAQCRXAAAAgUiuAAAAApFcAQAABCK5AgAACERyBQAAEIjkCgAAIBDJFQAA\n", + "QCCSKwAAgEAkVwAAAIFIrgAAAAKRXAEAAAQiuQIAAAhEcgUAABCI5AoAACAQyRUAAEAgkisAAIBA\n", + "JFcAAACBSK4AAAACkVwBAAAEIrkCAAAIRHIFAAAQiOQKAAAgEMkVAABAIJIrAACAQCRXAAAAgUiu\n", + "AAAAAq1NrmyfY/sDtj9m+6O2X1O8f5rtq23fZPsq26eOEy4AAEDeNtVcfUHS61JKD5P0OEmvsv0Q\n", + "Sa+XdHVK6YGSfq/4GwAAYOetTa5SSneklK4vXn9e0icknSXp2ZIuLya7XNJzhwwSAABgLhr3ubJ9\n", + "rqQLJH1I0r6U0sHio4OS9oVHBgAAMEONkivbJ0t6r6TXppQ+V/4spZQkpQFiAwAAmJ1jNk1g+1gt\n", + "Eqt3pZSuKN4+aPuMlNIdts+UdGf13AdKr/f3ChQAACCK7f0aKDlZm1zZtqRLJX08pfTW0kdXSrpY\n", + "0puK/6+omF2HJ1eS9MGOYQIAAMRJKe1J2lv+bfuSqLI31VxdKOlFkm6wfV3x3hskvVHSr9p+maRb\n", + "JL0gKiAAAIA5W5tcpZT+SPX9sp4aHw4AAMC8MUI7AABAIJIrAACAQCRXAAAAgUiuAAAAApFcAQAA\n", + "BCK5AgAACLRxhPZdYrvyMT4pJY8dCwAAmCeSqyOs5lfkVQAAoDmaBQEAAAKRXAEAAAQiuQIAAAhE\n", + "cgUAABCI5AoAACAQyRUAAEAgkisAAIBAJFcAAACBtmYQ0brR1SVGWAcAAOPZmuRqoSq/Iq8CAADj\n", + "oVkQAAAgEMkVAABAIJIrAACAQCRXAAAAgUiuAAAAApFcAQAABCK5AgAACERyBQAAECjrQUSjRl2v\n", + "KodR2wEAwBCyTq4WIkZdXy2DvAoAAAyDZkEAAIBAJFcAAACBSK4AAAACkVwBAAAEIrkCAAAIRHIF\n", + "AAAQiOQKAAAgEMkVAABAoGwGEV03GnuO6uJl5HcAAHZbNsnVwtxGUp9bvAAAYGg0CwIAAAQiuQIA\n", + "AAhEcgUAABCI5AoAACDQxuTK9mW2D9q+sfTeAdu32b6u+HfRsGECAADMQ5Oaq3dKWk2ekqS3pJQu\n", + "KP79TnxoAAAA87MxuUopXSPproqPGHcAAABgRZ8+V6+2/RHbl9o+NSwiAACAGeuaXL1d0nmSzpd0\n", + "u6Q3h0UEAAAwY51GaE8p3bl8bfsdkn6zesoDpdf7uywKAAAgnO39Gig56ZRc2T4zpXR78efzJN1Y\n", + "PeWBlb8/2GVxAAAAoVJKe5L2ln/bviSq7I3Jle33SHqSpNNt3yrpEkn7bZ+vxa8Gb5b0iqiAAAAA\n", + "5mxjcpVSemHF25cNEAsAAMDsMUI7AABAIJIrAACAQCRXAAAAgUiuAAAAApFcAQAABCK5AgAACNRp\n", + "EFHUs52q3k8pucl0VdMCAID5ILkKV5Uz1eVKbaYFAABzQLMgAABAIJIrAACAQCRXAAAAgUiuAAAA\n", + "ApFcAQAABCK5AgAACERyBQAAEIjkCgAAINAEydUXX287rf4bP475q9qObf9NvQ4AAGybiUZoZ2Ty\n", + "OKvb0hXv1b3PNgcAIBrNggAAAIFIrgAAAAKRXAEAAAQiuQIAAAhEcgUAABCI5AoAACAQyRUAAEAg\n", + "kisAAIBAEw0iOj1GJ1+o2w4pJUYYBQCgg51NrhglfontAABAJJoFAQAAApFcAQAABCK5AgAACERy\n", + "BQAAEIjkCgAAIBDJFQAAQCCSKwAAgEAkVwAAAIF2eBBRRGg70v0QI7+vi4GR5gEAYyO5QoDV3MYV\n", + "74zGqzoAAAiBSURBVC3fHyuGoZcHAEA1mgUBAAACkVwBAAAEIrkCAAAIRHIFAAAQaGNyZfsy2wdt\n", + "31h67zTbV9u+yfZVtk8dNkwAAIB5aFJz9U5JF62893pJV6eUHijp94q/AQAAdt7G5CqldI2ku1be\n", + "fraky4vXl0t6bnBcAAAAs9S1z9W+lNLB4vVBSfuC4gEAAJi13oOIppRS/QjZB0qv9/dd1GHajgw+\n", + "l2XVLW/qkcbH3gYAAAzJ9n5FJyeFrsnVQdtnpJTusH2mpDurJzuw8vcHOy6uStWo4EOZerTxXEYa\n", + "ZxR0AMB2SCntSdpb/m37kqiyuzYLXinp4uL1xZKuiAkHAABg3poMxfAeSX8s6UG2b7X9UklvlPQ0\n", + "2zdJekrxNwAAwM7b2CyYUnphzUdPDY4FAABg9hihHQAAIBDJFQAAQCCSKwAAgEAkVwAAAIFIrgAA\n", + "AAL1HqEdGMK6EeGnHq0eAIB1SK6QMUaEBwDMD82CAAAAgUiuAAAAApFcAQAABCK5AgAACERyBQAA\n", + "EIjkCgAAIBDJFQAAQCCSKwAAgEAkVwAAAIEYoX0k6x7nkqO5xVunaj2aPj6HR/AAALoguRrN6n06\n", + "93vz3OKt03c9eAQPAKAdmgUBAAACkVwBAAAEIrkCAAAIRHIFAAAQiOQKAAAgEMkVAABAIJIrAACA\n", + "QCRXAAAAgUiuAAAAApFcAQAABCK5AgAACERyBQAAEIjkCgAAIBDJFQAAQCCSKwAAgEAkVwAAAIFI\n", + "rgAAAAKRXAEAAAQ6ZuoA0IztNHUMEbZlPZqqW9+UkseOBQAwDpKr2ai6R8/x/ly3Hqvvz3Hd6mzz\n", + "ugEAVtEsCAAAEIjkCgAAIBDJFQAAQKBefa5s3yLp7yT9q6QvpJQeExEUAADAXPXt0J4k7U8pfTYi\n", + "GAAAgLmLaBbkp08AAACFvslVkvR+2x+2/fKIgAAAAOasb7PghSml223fR9LVtj+ZUromIjAAAIA5\n", + "6pVcpZRuL/7/jO3fkPQYSaXk6kBp6v19FgUc0neU9yFGTW8bU9MY1pXLKO95Y3R+IG+292ug5MQp\n", + "dbtP2T5R0tEppc/ZPknSVZJ+LKV0VfF5OnJk6p+U9O/UbpRupt3uafOJrTqx6T/tWDEgL9X7jv0G\n", + "5Mp2ijo/+9Rc7ZP0G7aX5bx7mVgBAADsqs7JVUrpZknnB8YCAAAwe4zQDgAAEIjkCgAAIBDJFQAA\n", + "QCCSKwAAgEAkVwAAAIFIrgAAAAL1ffwNgC3HKPEA0A7JFYAG6kafBwCsolkQAAAgEMkVAABAIJIr\n", + "AACAQCRXAAAAgUiuAAAAApFcAQAABCK5AgAACERyBQAAEIhBRIHCupHIc1QVb9MR0xl1HQCGQ3IF\n", + "HLKab+SeY/SNl1HXAWAINAsCAAAEIrkCAAAIRHIFAAAQiOQKAAAgEMkVAABAIJIrAACAQCRXAAAA\n", + "gUiuAAAAApFcAQAABGKEdqCDoR6VM0S5bcvsE0OXeXN83E7Ojweqi23quDCNnI/VXUZyBXQy1KNy\n", + "cih3qMfqzO1xOznHO7dHNWFYOR+ru4lmQQAAgEAkVwAAAIFIrgAAAAKRXAEAAAQiuQIAAAhEcgUA\n", + "ABCI5AoAACAQyRUAAEAgBhEF0FnEiPJVZVSNLD3UqPh1yxvKUCOsR2yfPjG0GSm87ajiY45KP9SI\n", + "50NuH9SbaluSXAHoIWKk8L6jxzcdET6XUeKHiiGH7dCm3LYxjDkq/Ry3D+qNvy1pFgQAAAhEcgUA\n", + "ABCI5AoAACBQ5+TK9kW2P2n7L23/UGRQAAAAc9UpubJ9tKS3SbpI0kMlvdD2QyIDw67ZmzoAzMbe\n", + "1AFgRmzvnzoG7J6uNVePkfSplNItKaUvSPoVSc+JCwu7Z2/qADAbe1MHgHnZP3UA2D1dk6uzJN1a\n", + "+vu24j0AAICd1nWcq4aD1T3lbw//++YTJB3fcZkAAADZc0rtB/W1/ThJB1JKFxV/v0HSl1JKbypN\n", + "M9hoygAAANGiRm3vmlwdI+kvJH29pL+WdK2kF6aUPhERFAAAwFx1ahZMKX3R9vdK+l1JR0u6lMQK\n", + "AACgY80VAAAAqg0yQjsDjKIN27fYvsH2dbavnToe5MP2ZbYP2r6x9N5ptq+2fZPtq2yfOmWMyEfN\n", + "8XLA9m3F9eU62xdNGSPyYPsc2x+w/THbH7X9muL9kOtLeHLFAKPoIEnan1K6IKX0mKmDQVbeqcW1\n", + "pOz1kq5OKT1Q0u8VfwNS9fGSJL2luL5ckFL6nQniQn6+IOl1KaWHSXqcpFcVuUrI9WWImisGGEUX\n", + "Ib/QwHZJKV0j6a6Vt58t6fLi9eWSnjtqUMhWzfEicX3BipTSHSml64vXn5f0CS3G6wy5vgyRXDHA\n", + "KNpKkt5v+8O2Xz51MMjevpTSweL1QUn7pgwGs/Bq2x+xfSnNyFhl+1xJF0j6kIKuL0MkV/SQR1sX\n", + "ppQukPRMLapmnzh1QJiHtPhFDtccrPN2SedJOl/S7ZLePG04yIntkyW9V9JrU0qfK3/W5/oyRHL1\n", + "aUnnlP4+R4vaK6BSSun24v/PSPoNLZqWgToHbZ8hSbbPlHTnxPEgYymlO1NB0jvE9QUF28dqkVi9\n", + "K6V0RfF2yPVliOTqw5IeYPtc28dJ+hZJVw6wHGwB2yfaPqV4fZKkp0u6cf1c2HFXSrq4eH2xpCvW\n", + "TIsdV9wgl54nri+QZNuSLpX08ZTSW0sfhVxfBhnnyvYzJb1Vdw8w+tPhC8FWsH2eFrVV0mJQ23dz\n", + "vGDJ9nskPUnS6Vr0f/hRSf+vpF+V9BWSbpH0gpTS30wVI/JRcbxcImm/Fk2CSdLNkl5R6lODHWX7\n", + "CZL+UNINurvp7w1aPHGm9/WFQUQBAAACDTKIKAAAwK4iuQIAAAhEcgUAABCI5AoAACAQyRUAAEAg\n", + "kisAAIBAJFcAAACBSK4AAAAC/f9A40wIgLpJlQAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['fc7'].data[0]\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(feat.flat)\n", + "plt.subplot(2, 1, 2)\n", + "_ = plt.hist(feat.flat[feat.flat > 0], bins=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The final probability output, `prob`" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAmEAAAJPCAYAAAA0UwMNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3X2Q7md93/fPV0fGMuLZphYWcnBAtoEB29iVabCdg00Y\n", + "hXEsppkxCD+kDkNoU9m0zXQI6YyR23/atJ0kDgmRXcVJXGJNkgKRW4jASc+YOg4gm4BjJCoFa6oH\n", + "TDDgBzyxfRR9+8d9L9xa7e6955zdvX6r6/WaObN7P+7vnN+59/fe6/rd11Z3BwCAk3XZ6A0AAJiR\n", + "CAMAGECEAQAMIMIAAAYQYQAAA4gwAIABtkZYVV1fVXdX1T1V9eY9br+hqj5aVR+pql+pqu/euO2+\n", + "qvrY+rYPHfXGAwCcVnXQOmFVdSbJJ5K8IsmDST6c5MbuvmvjPld29++vP39Rknd19/PWl38jybd2\n", + "9+eO768AAHD6bBsJuy7Jvd19X3efT3Jbkhs277ATYGtPSvJbu56jLnkrAQAeZ7ZF2NVJ7t+4/MD6\n", + "ukepqldX1V1J3pvkxzZu6iS/UFV3VtUbLnVjAQAeLy7fcvuhfqdRd787ybur6juT/GySb1jf9LLu\n", + "/lRVPTPJ+6vq7u7+wMVvLgDA48O2CHswyTUbl6/JajRsT939gaq6vKq+srs/292fWl//map6V1bT\n", + "m4+KsKryyysBgFOju4/kVKttEXZnkmur6jlJHkrymiQ3bt6hqp6b5JPd3VX1kvXGfbaqnpjkTHf/\n", + "XlVdmeSVSX5iry9yVH8ZTl5V3dzdN4/eDi6cfXe62X+nm/13eh3l4NGBEdbdD1fVTUnuSHImya3d\n", + "fVdVvXF9+y1J/mySH66q80m+kOS164dfleSdVbXzdd7R3e87qg0HADjNto2Epbvfm9UJ95vX3bLx\n", + "+V9N8lf3eNwnk3zzEWwjAMDjjhXzuVTnRm8AF+3c6A3gkpwbvQFcknOjN4DxDlys9UQ2oKqdEwYA\n", + "nAZH2S1GwgAABhBhAAADiDAAgAFEGADAACIMAGAAEQYAMIAIAwAYQIQBAAwgwgAABhBhAAADiDAA\n", + "gAFEGADAACIMAGAAEQYAMIAIAwAYQIQBAAwgwgAABhBhAAADiDAAgAFEGADAACIMAGAAEQYAMIAI\n", + "AwAYQIQBAAwgwgAABhBhAAADiDAAgAFEGADAACIMAGAAEQYAMIAIAwAYQIQBAAwgwgAABhBhAAAD\n", + "iDAAgAFEGADAACIMAGAAEQYAMIAIAwAYQIQBAAwgwgAABhBhAAADiDAAgAFEGADAACIMAGAAEQYA\n", + "MIAIAwAYQIQBAAwgwgAABhBhAAADiDAAgAFEGADAACIMAGAAEcZUqvLfVeUto7cDAKq7x25AVXd3\n", + "Dd0IplGVTtLdfgAB4MIdZbc4EDEj0Q/AcCIMAGAAEQYAMIAIAwAYQIQxm7HvRAGANRHGbEQYAIsg\n", + "wpiNCANgEUQYsxFhACyCCGM2IgyARRBhAAADiDBmYyQMgEUQYczmkdEbAACJCGM+RsIAWAQRBgAw\n", + "wNYIq6rrq+ruqrqnqt68x+03VNVHq+ojVfUrVfXdh30sDGAkDIBFqO79j0lVdSbJJ5K8IsmDST6c\n", + "5MbuvmvjPld29++vP39Rknd19/MO89j1Y7q762j/WrC3qnwhyZXd8X8OgAt2lN2ybSTsuiT3dvd9\n", + "3X0+yW1Jbti8w06ArT0pyW8d9rEwgJEwABZhW4RdneT+jcsPrK97lKp6dVXdleS9SX7sQh4LJ0yE\n", + "AbAI2yLsUAes7n53dz8/yZ9J8rNVZaqHpRJhACzC5VtufzDJNRuXr8lqRGtP3f2Bqro8yTPW9zvU\n", + "Y6vq5o2L57r73JbtgoslwgA4tKo6m+TssTz3lhPzL8/q5PrvSfJQkg/lsSfmPzfJJ7u7q+olSf5x\n", + "dz/3MI9dP96J+ZyYqvx2kqc6MR+Ai3GU3XLgSFh3P1xVNyW5I8mZJLd2911V9cb17bck+bNJfriq\n", + "zif5QpLXHvTYo9houARWzAdgEQ4cCTuRDTASxgmqymeTPMNIGAAX4ySXqAAA4BiIMGbjxHwAFkGE\n", + "MRsRBsAiiDBmI8IAWAQRxmxEGACLIMKYjQgDYBFEGLMRYQAsgggDABhAhDEbK+YDsAgijNmYjgRg\n", + "EUQYsxFhACyCCAMAGECEMRsjYQAsgghjNiIMgEUQYcxGhAGwCCKM2YgwABZBhDEbEQbAIogwAIAB\n", + "RBizsWI+AIsgwpiN6UgAFkGEMRsRBsAiiDAAgAFEGLMxEgbAIogwZiPCAFgEEcZsRBgAiyDCmI0I\n", + "A2ARRBizEWEALIIIYzYiDIBFEGHMRoQBsAgijNmIMAAWQYQxGxEGwCKIMACAAUQYs3lk9AYAQCLC\n", + "mI/pSAAWQYQxGxEGwCKIMACAAUQYszESBsAiiDBmI8IAWAQRxmxEGACLIMKYjQgDYBFEGLMRYQAs\n", + "gggDABhAhDEbK+YDsAgijNmYjgRgEUQYsxFhACyCCAMAGECEMRsjYQAsgghjNiIMgEUQYcxGhAGw\n", + "CCKM2YgwABZBhDEbEQbAIogwZiPCAFgEEcZsRBgAiyDCmI0IA2ARRBizEWEALIIIAwAYQIQxGyNh\n", + "ACyCCGM2j4zeAABIRBjzMRIGwCKIMACAAUQYszESBsAiiDBmI8IAWAQRxmxEGACLIMKYjQgDYBFE\n", + "GLMRYQAsgghjNiIMgEUQYQAAA4gwZmPFfAAWQYQxG9ORACyCCAMAGECEMRsjYQAswtYIq6rrq+ru\n", + "qrqnqt68x+0/UFUfraqPVdUvVdWLN267b339R6rqQ0e98XARRBgAi3D5QTdW1Zkkb0vyiiQPJvlw\n", + "Vd3e3Xdt3O2TSb6ru3+nqq5P8lNJXrq+rZOc7e7PHf2mw0URYQAswraRsOuS3Nvd93X3+SS3Jblh\n", + "8w7d/cvd/Tvrix9M8uxdz1FHsqVwNEQYAIuwLcKuTnL/xuUH1tft5/VJ3rNxuZP8QlXdWVVvuLhN\n", + "hCMlwgBYhAOnI3MBB6yqenmSP5/kZRtXv6y7P1VVz0zy/qq6u7s/sMdjb964eK67zx3268IFEmEA\n", + "HFpVnU1y9jiee1uEPZjkmo3L12Q1GvYo65PxfzrJ9d39+Z3ru/tT64+fqap3ZTW9+ZgI6+6bL3jL\n", + "4eKIMAAObT0wdG7nclW99aiee9t05J1Jrq2q51TVE5K8Jsntm3eoqq9N8s4kP9jd925c/8SqevL6\n", + "8yuTvDLJrx3VhsNFEmEALMKBI2Hd/XBV3ZTkjiRnktza3XdV1RvXt9+S5MeTPD3J26sqSc5393VJ\n", + "rkryzvV1lyd5R3e/79j+JnA4IgyARajuscekquru9g5KTkRV3pHkdd3etQvAhTvKbrFiPrMxEgbA\n", + "IogwZvPI6A0AgESEMR8jYQAsgghjSlXOCQNgLBHGrEQYAEOJMGZTuz4CwBAijFmJMACGEmHMyv99\n", + "AIZyIGJWRsIAGEqEMRvnhAGwCCKMWYkwAIYSYcxKhAEwlAhjNjvx5f8+AEM5EDErI2EADCXCmJUI\n", + "A2AoEcZsxBcAiyDCmJUYA2AoEQYAMIAIAwAYQIQxGyvmA7AIIgwAYAARxqyMhAEwlAhjNuILgEUQ\n", + "YQAAA4gwZmVEDIChRBgAwAAijNlYogKARRBhAAADiDAAgAFEGLMxHQnAIogwAIABRBizMhIGwFAi\n", + "DABgABHGbIyAAbAIIoxZiTEAhhJhAAADiDBmY4kKABZBhAEADCDCAAAGEGHMynQkAEOJMGYjvgBY\n", + "BBHGrMQYAEOJMACAAUQYszECBsAiiDBmJcYAGEqEAQAMIMKYjRXzAVgEEQYAMIAIAwAYQIQxK9OR\n", + "AAwlwpiN+AJgEUQYsxJjAAwlwgAABhBhzMYIGACLIMKYlRgDYCgRBgAwgAhjVkbCABhKhDEb8QXA\n", + "IogwAIABRBizMiIGwFAijNmILwAWQYQxKzEGwFAiDABgABEGADCACGM2tesjAAwhwgAABhBhzMpI\n", + "GABDiTBmI74AWAQRBgAwgAhjVkbEABhqa4RV1fVVdXdV3VNVb97j9h+oqo9W1ceq6peq6sWHfSwM\n", + "IL4AWIQDI6yqziR5W5Lrk7wgyY1V9fxdd/tkku/q7hcn+R+S/NQFPBZGEWMADLVtJOy6JPd2933d\n", + "fT7JbUlu2LxDd/9yd//O+uIHkzz7sI8FAJjVtgi7Osn9G5cfWF+3n9cnec9FPhYAYBqXb7m9D/tE\n", + "VfXyJH8+ycsu9LFwgqyYD8AibIuwB5Ncs3H5mqxGtB5lfTL+Tye5vrs/fyGPXT/+5o2L57r73Jbt\n", + "AgA4dlV1NsnZY3nu7v0HrKrq8iSfSPI9SR5K8qEkN3b3XRv3+dok/yLJD3b3v7qQx67v191tVIIT\n", + "UZX3JPnTSb6xO58YvT0AnC5H2S0HjoR198NVdVOSO5KcSXJrd99VVW9c335Lkh9P8vQkb6+qJDnf\n", + "3dft99ij2Gi4BIIfgEU4cCTsRDbASBgnqCrvzWrZFCNhAFywo+wWK+YzK+EPwFAiDABgABHGbCxR\n", + "AcAiiDAAgAFEGADAACKM2ZiOBGARRBgAwAAijFkZCQNgKBEGADCACGM2RsAAWAQRxqzEGABDiTAA\n", + "gAFEGLOxRAUAiyDCAAAGEGEAAAOIMGZlOhKAoUQYsxFfACyCCGNWYgyAoUQYAMAAIozZGAEDYBFE\n", + "GLMSYwAMJcIAAAYQYczGivkALIIIAwAYQIQBAAwgwpiV6UgAhhJhzEZ8AbAIIoxZiTEAhhJhAAAD\n", + "iDBmYwQMgEUQYcxKjAEwlAgDABhAhDErI2EADCXCmI34AmARRBgAwAAijFkZEQNgKBHGbMQXAIsg\n", + "wpiVGANgKBEGADCACAMAGECEMZva9REAhhBhAAADiDBmZSQMgKFEGLMRXwAsgggDABhAhDErI2IA\n", + "DCXCmI34AmARRBizEmMADCXCAAAGEGEAAAOIMGZjxXwAFkGEMaMevQEAIMKYlZEwAIYSYcymYiQM\n", + "gAUQYcyoYyQMgMFEGADAACKMGZmOBGA4EcZsds4JMx0JwFAijBkZCQNgOBHGrIyEATCUCGM2lqgA\n", + "YBFEGDMSYQAMJ8KYlelIAIYSYczISBgAw4kwZmOJCgAWQYQxIyNhAAwnwgAABhBhzMZ0JACLIMKY\n", + "kelIAIYTYczKSBgAQ4kwZmQkDIDhtkZYVV1fVXdX1T1V9eY9bv/GqvrlqvqDqvpLu267r6o+VlUf\n", + "qaoPHeWGw0UyAgbAIlx+0I1VdSbJ25K8IsmDST5cVbd3910bd/tskh9N8uo9nqKTnO3uzx3R9sJR\n", + "cGI+AMNtGwm7Lsm93X1fd59PcluSGzbv0N2f6e47k5zf5zkc7Fga05EADLctwq5Ocv/G5QfW1x1W\n", + "J/mFqrqzqt5woRsHx8ASFQAswoHTkbn0EYOXdfenquqZSd5fVXd39wcu8TnhUhkJA2C4bRH2YJJr\n", + "Ni5fk9Vo2KF096fWHz9TVe/KanrzMRFWVTdvXDzX3ecO+zUAAI5LVZ1NcvY4nntbhN2Z5Nqqek6S\n", + "h5K8JsmN+9z3UdM7VfXEJGe6+/eq6sokr0zyE3s9sLtvPvwmwyUxHQnAoa0Hhs7tXK6qtx7Vcx8Y\n", + "Yd39cFXdlOSOJGeS3Nrdd1XVG9e331JVVyX5cJKnJHmkqt6U5AVJ/qMk76yqna/zju5+31FtOFwC\n", + "05EADFfdY49HVdXdbVSCE1GVX81qWv2HuvPPRm8PAKfLUXaLFfOZkZEwAIYTYczGqCsAiyDCmJET\n", + "8wEYToQxI9ORAAwnwpiNJSoAWAQRxoyMhAEwnAgDABhAhDEr05EADCXCmM3OOWEAMJQIY0ZOzAdg\n", + "OBHGjIyEATCcCGM2RsAAWAQRxoxMRwIwnAhjRqYjARhOhDErI2EADCXCmI0lKgBYBBHGjEQYAMOJ\n", + "MGZlOhKAoUQYszEdCcAiiDBmZIkKAIYTYczISBgAw4kwZmMEDIBFEGHMyHQkAMOJMGZkOhKA4UQY\n", + "szISBsBQIozZWKICgEUQYcxIhAEwnAhjVqYjARhKhDEb05EALIIIY0aWqABgOBHGjIyEATCcCAMA\n", + "GECEMZudc8JMRwIwlAhjRqYjARhOhDErI2EADCXCmI0lKgBYBBHGjDrJZVV52ugNAWBeIoxZfWeS\n", + "/330RgAwLxHGjDrJVyS5YvSGADAvEcZsLFEBwCKIMGa0E2FCDIBhRBizEmEADCXCmM3mdKQIA2AY\n", + "EcaMnBMGwHAijFkZCQNgKBHGbHamIy+LCANgIBHGrIyEATCUCGNGzgkDYDgRxoy8OxKA4UQYs7FE\n", + "BQCLIMKY0c6J+QAwjAMRMzMSBsAwIozZmI4EYBFEGDOyThgAw4kwZiXAABhKhDEj05EADCfCmE1t\n", + "fBRhAAwjwpiRFfMBGE6EMSMn5gMwnAhjNpaoAGARRBgzEmEADCfCmJUAA2AoEcasjIQBMJQIYzbO\n", + "CQNgEUQYMxJhAAwnwpjRzhIVADCMAxGzqX0+B4ATJcKYkelIAIYTYczIdCQAwzkQMSsjYQAMJcKY\n", + "jSUqAFiErRFWVddX1d1VdU9VvXmP27+xqn65qv6gqv7ShTwWBhFhAAx3YIRV1Zkkb0tyfZIXJLmx\n", + "qp6/626fTfKjSf6Xi3gsjCLAABhq20jYdUnu7e77uvt8ktuS3LB5h+7+THffmeT8hT4WTkpVvqEq\n", + "X54vTUdeFiEGwEDbIuzqJPdvXH5gfd1hXMpj4ai9Lcl3rD83HQnAcJdvub0v4bkP/diqunnj4rnu\n", + "PncJXxf2cmb9JxFhABxSVZ1NcvY4nntbhD2Y5JqNy9dkNaJ1GId+bHfffMjnhItVefQUpAADYKv1\n", + "wNC5nctV9dajeu5t05F3Jrm2qp5TVU9I8pokt+9z390HtQt5LBy3nQhLjIQBsAAHjoR198NVdVOS\n", + "O7Kayrm1u++qqjeub7+lqq5K8uEkT0nySFW9KckLuvsLez32OP8ycIDN6BJhAAxX3Zdy2tcRbEBV\n", + "d7eDIceqKr+Y5H9O8neSfCTJVUme3J1vGLphAJwqR9ktVsxnFpvnhFmiAoDhRBgz2TwnLBFhAAwk\n", + "wpjF7nPAnBMGwFAijFnsNR0JAMM4EDELS1QAsCgijFmIMAAWRYQxi80I27kMAMOIMGZRG3+MhAEw\n", + "nAhjFrunI60TBsBQIoxZ7DUdKcIAGEaEMZPNJSoEGABDiTBm4Rd4A7AoIoxZmI4EYFFEGLOwThgA\n", + "iyLCmMXuX1skwAAYSoQxC0tUALAoIoxZ7J5+NB0JwFAijFmYjgRgUUQYs3BiPgCLIsKYhSUqAFgU\n", + "EcZMNqcjnZgPwFAijFnsXjEfAIYSYczCdCQAiyLCmIV1wgBYFBHGLPZaokKEATCMCGMWu88JE2AA\n", + "DCXCmIVzwgBYFBHGLExHArAoIoxZ7LViPgAMI8KYielIABbj8tEbACdk94n5fgABYCgRxiw2zwlL\n", + "jIIBMJjRAGbhnDAAFsVIGLMQYQAsighjFrXxR4QBMJzpSGbhd0cCsCgijFnsXjEfAIZyUGIWfm0R\n", + "AIsiwpjJ5q8tMh0JwFAijFnsXqxVgAEwlAhjFnstUSHEABhGhDGLvVbMv6Iqf2vcJgEwMxHGLPZb\n", + "rPVPjdkcAGYnwpjFfueEmZIEYAgRxiz2WqJi8yMAnCgRxiw2zwnrjeu9BgAYwgGIWew+J2zzegA4\n", + "cSKMmYgwABZDhDGLyt5rg4kwAIYQYcxiv+lIrwEAhnAAYhbOCQNgUUQYs9jv3ZEiDIAhRBiz2L1Y\n", + "6w6vAQCGcABiFrsXa928HgBOnAhjFvtFmNcAAEM4ADELK+YDsCgOQMzEEhUALIYDELNwYj4Ai+IA\n", + "xCw2pyN3Xw8AJ06EMYv9Fms9M2BbAECEMQ2/tgiARXEAYhaWqABgURyAmEVt/PFriwAYToQxC+eE\n", + "AbAoIoxZmI4EYFEcgJjJXivmm44EYAgRxiz2W6wVAIYQYcxiv3PCAGAIEcYs9jsnDACGcFBiJnud\n", + "EwYAQ2yNsKq6vqrurqp7qurN+9znJ9e3f7SqvmXj+vuq6mNV9ZGq+tBRbjgcVtUXzwUzHQnAYlx+\n", + "0I1VdSbJ25K8IsmDST5cVbd3910b93lVkud197VV9e1J3p7kpeubO8nZ7v7csWw9HE7t+ggAw20b\n", + "Cbsuyb3dfV93n09yW5Ibdt3n+5L8/STp7g8meVpVffXG7Q58jLY5EmY6EoBF2BZhVye5f+PyA+vr\n", + "DnufTvILVXVnVb3hUjYULsGB05Eb05UAcGIOnI7M4UcM9juIfUd3P1RVz0zy/qq6u7s/cPjNgyO1\n", + "3w8dRscAOHHbIuzBJNdsXL4mq5Gug+7z7PV16e6H1h8/U1Xvymp68zERVlU3b1w8193nDrHtcFib\n", + "54TtFVyXJXnkRLcIgFOhqs4mOXscz70twu5Mcm1VPSfJQ0lek+TGXfe5PclNSW6rqpcm+e3u/nRV\n", + "PTHJme7+vaq6Mskrk/zEXl+ku2++6L8BbLft3ZGmIwHY03pg6NzO5ap661E994ER1t0PV9VNSe5I\n", + "cibJrd19V1W9cX37Ld39nqp6VVXdm+T3k/zI+uFXJXlnVe18nXd09/uOasPhAogwABanuseeClNV\n", + "3d0OghybqlyR5N8nuSfJH89qRPa/37jLFd35wxHbBsDpcpTdYsV8ZrBtiQqvAwBOnIMPM9i9WKvp\n", + "SACGE2HMYPc5YfvdDgAnRoQxg23TkSIMgBMnwpjJfu+O9DoA4MQ5+DCDbb/A20gYACdOhDED64QB\n", + "sDgijBk4JwyAxRFhzGDbSJjXAQAnzsGHGViiAoDFEWHMwGKtACyOCGMGTswHYHFEGDOoJI9k///v\n", + "XgcAnDgHH2bxH2IkDIAFEWHMoPLoCNvrdgA4USKMGWybjhRhAJw4EcYMdo+EWScMgOEcfJjBToSd\n", + "OeB2ADhRIowZbI6EdZyYD8ACiDBmsHNO2H6x5XUAwIlz8GEGOxF20O0AcKJEGDPYjLCK6UgAFkCE\n", + "MYO9wmv37QBwokQYs+h9Pk+8DgAYwMGHGeyMhO03GmYkDIATJ8KYwU6E7XdyvggD4MSJMGawO8Kc\n", + "mA/AcCKMGWybjvQ6AODEOfgwg90RZiQMgOFEGDNwThgAiyPCmMFOZIkwABZDhDGDbdORXgcAnDgH\n", + "H2ZhnTAAFkWEMQNLVACwOCKMGVgxH4DFEWHMYNu7I70OADhxDj7MwHQkAIsjwpiB6UgAFkeEMQMr\n", + "5gOwOCKMGTgnDIDFcfBhBlbMB2BxRBizMB0JwKKIMGaw7cR8rwMATpyDDzOwRAUAiyPCmMG2E/NF\n", + "GAAnToQxA+uEAbA4IowZbFsnzOsAgBPn4MMMTEcCsDgijBlYMR+AxRFhzMBirQAsjghjFtYJA2BR\n", + "HHyYgelIABZHhDEDJ+YDsDgijBnsjrA/2uN2ADhRIowZ7I6wP9x1u9cBACfOwYcZ7D4n7A/2uB0A\n", + "TpQIYwa7I2z3SJgIA+DEiTBmsHs60kgYwBZVeVVVvnf0djyeiTBmsG0kzOsA4LFeluQ7Rm/E49nl\n", + "ozcATpDpSIDDuyLJmdEb8XgmwpiB6UiAC/flEWHHSoQxg21LVIgwgMcyEnbMRBgzcE4YwIUTYcdM\n", + "hDED05EAF06EHTMRxgysEwZw4UTYMTMNw6lWlddU5Wnb7paDV8z3OgB4rCvWfzgmDj6cdm9J8i1b\n", + "7rMTYV+xvvzwHrcD8Ggi7JiJME67p67/HGQnwp6UJN1fHBHbvJ2BqvJVo7cBeIxLirCq/M2qrd+f\n", + "pybCOO2esv6zp6r8iSSvyyrCnrzf3Y5hu7gw9/hmDYtzqSNhr0vynKPZlMcnEcapVZXK9pGw70ry\n", + "Z9af7xdhx/I6qMpzq/J7x/HcjydVeWKSpyV55uhtgR1VubIqf2r0dgx20RFWlcuSPD3JM450ix5n\n", + "RBin2Vdk9c6dfUfCsjqwf2U2piP3cFwjYV+X5ElV+ddVecsxfY3Hg6/a9RGW4GVJ/trojThOVfmZ\n", + "LacCXMpI2FOz+t4qwg6wNcKq6vqquruq7qmqN+9zn59c3/7RqvqWC3ksXIKn7vq4l51vMJ1VsP3R\n", + "Hvc5rgjb+ebzTUledExf4/HgK3d9hCW4KsnXjN6I47KeSfj+JN9wwN2+fP3nYjx910f2cGCEVdWZ\n", + "JG9Lcn2SFyS5saqev+s+r0ryvO6+NslfSPL2wz6Wo1d10S+Yi/x6dfYkv94uOyNgT6nK66ryp/e4\n", + "z2aEJfni9OCbNu5zXBH21euPfy/Jq6ry+sM+sCo/UZWXH8tWffFrDN13m7ZGWFVeXiVkNy1o/z1e\n", + "PSvJ06uO592BC9h/T0vyxCTPPuA+lzIS9oxdH4eqyrOq8vdHb8du20bCrktyb3ff193nk9yW5IZd\n", + "9/m+ZPUX6+4PJnlaVV11yMdyhKryzCQPHlWIVeXphzhZ+uxRfK2LtDkS9tok/+ke99k5z2gnwr6Q\n", + "JN35yY37HNe0/FcneWtWUxpPTQ4fYUleneSVx7FRG84e8/Mf1mFGwv6bJD98AttySaryZUf8fAe9\n", + "/s4e5dd6vKjKk9fTbJf6w9VV64/PutRt2sfZY3rew3r2ro97uSLJFRf5b7moCEvy0iQ/cFxRfbG2\n", + "HXyuTnL/xuUH1tcd5j5fc4jHcrReltWB7FuP6Pn+VpK/uXOhKk87ypG2qlxWlR+pyhMu8imesvHx\n", + "m5J8867nvzrJC9cXr1x/3OtE+eMcCft0kgfXl1+8Pln1QOsD+fOTvOSYtuvIVeWvVOV1F/nwx0RY\n", + "1WNW6X5JjunfoyovqjrwHbZPrsrXH+J5bkzyi0e4Xd+b5ONVp/M3m1SljjpKD+nlSf6zZO99VpWv\n", + "rMr3HOJ5duLr8TolefWuj4+y/n93WZL/kGzfj+s3Iv3jquzMeO1MQ15yhK2f+1JHwl+c1SkpL9x2\n", + "x5O07cW9ez2l/VzSQawqP38pjz8Fnp7kjyX56BE/7+7987ysVoP/qar8VlZDzU9P8old99trf+11\n", + "3XckeaQq/9f6a31bks9X5d717WeSN72o6qKj7ylZheOPVeVTWb3YL8RVWUXOS7P6ie2ZVblj/Txn\n", + "sgqzJ67vuxNh9+zxPDdVffEdlEfp25L8n0k+t778hCTvrdrzvLRNVyT5fJL/eOPf/hj8F19flW9b\n", + "X6isvuFBEI0uAAAF1UlEQVTufDzM55vXPS/JH61D5DCuyGr/fybJc5N8NqufUr85q3NQ/mRVfmn9\n", + "+eez+n/80n2+Vxz0/eeyrP6ffGa9jf82j/21VS9P8sDG/+sdO//u1yZ5VlV+MasD1sNJ/t0eX+ub\n", + "s/o/+M/XX+ORXNq+e2FWI7nvr1qN4D7af/71u157+/07PDGrkdg/zJf+L56E5yW5qir/T1bHmidl\n", + "9WaaTx3isU/PatT6/CG/1h/L6jV+PquRnT9I8g+r8tA+2/XHq/L+HLx/XprVQMKtG/83dv6NL8vq\n", + "h91fyZcWf64kX7t+zCN5tCett2vje/GjXn87XpTkN7L3D4tH7dlJfjfJ91fl2j1uP5Pk32f19/un\n", + "VXk4q9fs+fX1u70wq3+Xf1qVT2T1b/FbSb53/X1sLwf9+2/e9pIkX1aVDx1w/22+KavX7U+vjzd1\n", + "kX+OVHXv/29QVS9NcnN3X7++/JYkj3T3/7Rxn7+T5Fx337a+fHeSP5nVO8MOfOz6+mM6wAAAHL3u\n", + "PpIg2zYSdmeSa6vqOUkeSvKa5DE/6d6e5KYkt62j7be7+9NV9dlDPPbI/iIAAKfJgRHW3Q9X1U1J\n", + "7shqaPLW7r6rqt64vv2W7n5PVb2qqu5N8vtJfuSgxx7nXwYA4LQ4cDoSAIDjMXTFfIu5LltVXVNV\n", + "/3dV/XpV/Zuq+rH19c+oqvdX1f9bVe+rqqdtPOYt6/15d1Ud9xILbFFVZ6rqI1X18+vL9t0pUVVP\n", + "q6p/UlV3VdXHq+rb7b/TY70/fr2qfq2q/mFVfbn9t0xV9Xer6tNV9Wsb113wvqqqb13v73uq6m8c\n", + "5msPizCLuZ4K55P81939wqzeKfRfrvfRX07y/u7++iT/fH05VfWCrM79e0FW+/VvV5VfjTXWm5J8\n", + "PF96p5F9d3r8jSTv6e7nZ/X2+rtj/50K63Oh35DkJd39oqxOyXlt7L+l+pms/t03Xci+2jm3/e1J\n", + "Xr9evP7aqtr9nI8xcidbzHXhuvs3u/tfrz//QpK7snqL/hcX6F1/fPX68xuS/Fx3n+/u+5Lcm9V+\n", + "ZoCqenaSVyX53/Klt1bbd6dAVT01yXd2999NVufYdvfvxP47LX43qx9in1hVl2e1TMhDsf8Wqbs/\n", + "kNVSOJsuZF99e1U9K8mTu3tnGY1/sPGYfY2MsMMsBMtCrH+y+5YkH0zy1d396fVNn86Xfj3P12S1\n", + "H3fYp2P9tST/bR69ZpF9dzp8XZLPVNXPVNWvVtVPV9WVsf9Ohe7+XJL/Ncn/l1V8/XZ3vz/232ly\n", + "oftq9/UP5hD7cGSEeUfAKVFVT0ryfyR5U3c/ahHBXr2z47AL7nFCqup7k/y77v5I9llg0L5btMuz\n", + "WqDyb3f3S7J65/lf3ryD/bdcVfXcJP9VkudkdXB+UlX94OZ97L/T4xD76qKNjLAHk1yzcfmaPLoi\n", + "WYCq+rKsAuxnu/vd66s/vf79oFkPwe6sHr57nz47X/qVPZysP5Hk+6rqN5L8XJLvrqqfjX13WjyQ\n", + "5IHu/vD68j/JKsp+0/47Fb4tyb/s7s9298NJ3pnkP4n9d5pcyPfKB9bXP3vX9Vv34cgI++JCsFX1\n", + "hKxOdLt94Pawy/pkw1uTfLy7//rGTbcn+XPrz/9ckndvXP/aqnpCVX1dVr/u5VJ+zQQXqbv/Sndf\n", + "091fl9UJwf+iu38o9t2p0N2/meT+qtr5/YevSPLrSX4+9t9pcHeSl1bVV6y/j74iqzfI2H+nxwV9\n", + "r1y/Zn93/S7mSvJDG4/Z17BfDGsx11PhZUl+MMnHquoj6+vekuR/TPKPqur1Se5L8v1J0t0fr6p/\n", + "lNU3m4eT/MW2EN1S7OwH++70+NEk71j/kPpvs1oI+0zsv8Xr7o9W1T/IarDhkSS/muSnkjw59t/i\n", + "VNXPZfXrFr+qqu5P8uO5uO+VfzHJ38vqd6S+p7v/2davbT8DAJw865AAAAwgwgAABhBhAAADiDAA\n", + "gAFEGADAACIMAGAAEQYAMIAIAwAY4P8Hf+iH2xY5ngUAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feat = net.blobs['prob'].data[0]\n", + "plt.plot(feat.flat)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see the top 5 predicted labels." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['n02123045 tabby, tabby cat' 'n02123159 tiger cat'\n", + " 'n02124075 Egyptian cat' 'n02119022 red fox, Vulpes vulpes'\n", + " 'n02127052 lynx, catamount']\n" + ] + } + ], + "source": [ + "# load labels\n", + "imagenet_labels_filename = caffe_root + 'data/ilsvrc12/synset_words.txt'\n", + "try:\n", + " labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\\t')\n", + "except:\n", + " !../data/ilsvrc12/get_ilsvrc_aux.sh\n", + " labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\\t')\n", + "\n", + "# sort top k predictions from softmax output\n", + "top_k = net.blobs['prob'].data[0].flatten().argsort()[-1:-6:-1]\n", + "print labels[top_k]" + ] + } + ], + "metadata": { + "description": "Instant recognition with a pre-trained model and a tour of the net interface for visualizing features and parameters layer-by-layer.", + "example_name": "Image Classification and Filter Visualization", + "include_in_docs": true, + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + }, + "priority": 1 + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/python_solving.ipynb b/examples/01-learning-lenet.ipynb similarity index 53% rename from examples/python_solving.ipynb rename to examples/01-learning-lenet.ipynb index de6c40196ad..3562c7adaf2 100644 --- a/examples/python_solving.ipynb +++ b/examples/01-learning-lenet.ipynb @@ -56,59 +56,59 @@ "output_type": "stream", "text": [ "Downloading...\n", - "--2015-03-12 11:54:02-- http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", + "--2015-06-30 14:41:56-- http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", "Resolving yann.lecun.com... 128.122.47.89\n", "Connecting to yann.lecun.com|128.122.47.89|:80... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 9912422 (9.5M) [application/x-gzip]\n", "Saving to: 'train-images-idx3-ubyte.gz'\n", "\n", - "train-images-idx3-u 100%[=====================>] 9.45M 194KB/s in 51s \n", + "train-images-idx3-u 100%[=====================>] 9.45M 146KB/s in 57s \n", "\n", - "2015-03-12 11:54:54 (188 KB/s) - 'train-images-idx3-ubyte.gz' saved [9912422/9912422]\n", + "2015-06-30 14:42:53 (171 KB/s) - 'train-images-idx3-ubyte.gz' saved [9912422/9912422]\n", "\n", - "--2015-03-12 11:54:54-- http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", + "--2015-06-30 14:42:53-- http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", "Resolving yann.lecun.com... 128.122.47.89\n", "Connecting to yann.lecun.com|128.122.47.89|:80... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 28881 (28K) [application/x-gzip]\n", "Saving to: 'train-labels-idx1-ubyte.gz'\n", "\n", - "train-labels-idx1-u 100%[=====================>] 28.20K 104KB/s in 0.3s \n", + "train-labels-idx1-u 100%[=====================>] 28.20K 107KB/s in 0.3s \n", "\n", - "2015-03-12 11:54:55 (104 KB/s) - 'train-labels-idx1-ubyte.gz' saved [28881/28881]\n", + "2015-06-30 14:42:53 (107 KB/s) - 'train-labels-idx1-ubyte.gz' saved [28881/28881]\n", "\n", - "--2015-03-12 11:54:55-- http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", + "--2015-06-30 14:42:53-- http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", "Resolving yann.lecun.com... 128.122.47.89\n", "Connecting to yann.lecun.com|128.122.47.89|:80... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 1648877 (1.6M) [application/x-gzip]\n", "Saving to: 't10k-images-idx3-ubyte.gz'\n", "\n", - "t10k-images-idx3-ub 100%[=====================>] 1.57M 224KB/s in 9.2s \n", + "t10k-images-idx3-ub 100%[=====================>] 1.57M 205KB/s in 8.2s \n", "\n", - "2015-03-12 11:55:04 (176 KB/s) - 't10k-images-idx3-ubyte.gz' saved [1648877/1648877]\n", + "2015-06-30 14:43:02 (197 KB/s) - 't10k-images-idx3-ubyte.gz' saved [1648877/1648877]\n", "\n", - "--2015-03-12 11:55:04-- http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", + "--2015-06-30 14:43:02-- http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", "Resolving yann.lecun.com... 128.122.47.89\n", "Connecting to yann.lecun.com|128.122.47.89|:80... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 4542 (4.4K) [application/x-gzip]\n", "Saving to: 't10k-labels-idx1-ubyte.gz'\n", "\n", - "t10k-labels-idx1-ub 100%[=====================>] 4.44K --.-KB/s in 0.09s \n", + "t10k-labels-idx1-ub 100%[=====================>] 4.44K 26.9KB/s in 0.2s \n", "\n", - "2015-03-12 11:55:04 (50.0 KB/s) - 't10k-labels-idx1-ubyte.gz' saved [4542/4542]\n", + "2015-06-30 14:43:02 (26.9 KB/s) - 't10k-labels-idx1-ubyte.gz' saved [4542/4542]\n", "\n", "Unzipping...\n", - "train-images-idx3-ubyte already exists -- do you wish to overwrite (y or n)? ^Ctrain-labels-idx1-ubyte already exists -- do you wish to overwrite (y or n)? \n", - "\tnot overwriting\n", - "t10k-images-idx3-ubyte already exists -- do you wish to overwrite (y or n)? Creating lmdb...\n", + "Done.\n", + "Creating lmdb...\n", "Done.\n" ] } ], "source": [ + "# Download and prepare data\n", "!data/mnist/get_mnist.sh\n", "!examples/mnist/create_mnist.sh" ] @@ -118,67 +118,57 @@ "metadata": {}, "source": [ "We need two external files to help out:\n", + "* the net prototxt, defining the architecture and pointing to the train/test data\n", "* the solver prototxt, defining the learning parameters\n", - "* the net prototxt, defining the architecture and train/test data\n", "\n", - "Here are the learning parameters." + "We start with the net. We'll write the net in a succinct and natural way as Python code that serializes to Caffe's protobuf model format.\n", + "\n", + "This network expects to read from pregenerated LMDBs, but reading directly from `ndarray`s is also possible using `MemoryDataLayer`." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": { "collapsed": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "# The train/test net protocol buffer definition\r\n", - "net: \"examples/mnist/lenet_train_test.prototxt\"\r\n", - "# test_iter specifies how many forward passes the test should carry out.\r\n", - "# In the case of MNIST, we have test batch size 100 and 100 test iterations,\r\n", - "# covering the full 10,000 testing images.\r\n", - "test_iter: 100\r\n", - "# Carry out testing every 500 training iterations.\r\n", - "test_interval: 500\r\n", - "# The base learning rate, momentum and the weight decay of the network.\r\n", - "base_lr: 0.01\r\n", - "momentum: 0.9\r\n", - "weight_decay: 0.0005\r\n", - "# The learning rate policy\r\n", - "lr_policy: \"inv\"\r\n", - "gamma: 0.0001\r\n", - "power: 0.75\r\n", - "# Display every 100 iterations\r\n", - "display: 100\r\n", - "# The maximum number of iterations\r\n", - "max_iter: 10000\r\n", - "# snapshot intermediate results\r\n", - "snapshot: 5000\r\n", - "snapshot_prefix: \"examples/mnist/lenet\"\r\n", - "# solver mode: CPU or GPU\r\n", - "solver_mode: GPU\r\n" - ] - } - ], + "outputs": [], "source": [ - "!cat examples/mnist/lenet_solver.prototxt" + "from caffe import layers as L\n", + "from caffe import params as P\n", + "\n", + "def lenet(lmdb, batch_size):\n", + " # our version of LeNet: a series of linear and simple nonlinear transformations\n", + " n = caffe.NetSpec()\n", + " n.data, n.label = L.Data(batch_size=batch_size, backend=P.Data.LMDB, source=lmdb,\n", + " transform_param=dict(scale=1./255), ntop=2)\n", + " n.conv1 = L.Convolution(n.data, kernel_size=5, num_output=20, weight_filler=dict(type='xavier'))\n", + " n.pool1 = L.Pooling(n.conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX)\n", + " n.conv2 = L.Convolution(n.pool1, kernel_size=5, num_output=50, weight_filler=dict(type='xavier'))\n", + " n.pool2 = L.Pooling(n.conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX)\n", + " n.ip1 = L.InnerProduct(n.pool2, num_output=500, weight_filler=dict(type='xavier'))\n", + " n.relu1 = L.ReLU(n.ip1, in_place=True)\n", + " n.ip2 = L.InnerProduct(n.relu1, num_output=10, weight_filler=dict(type='xavier'))\n", + " n.loss = L.SoftmaxWithLoss(n.ip2, n.label)\n", + " return n.to_proto()\n", + " \n", + "with open('examples/mnist/lenet_auto_train.prototxt', 'w') as f:\n", + " f.write(str(lenet('examples/mnist/mnist_train_lmdb', 64)))\n", + " \n", + "with open('examples/mnist/lenet_auto_test.prototxt', 'w') as f:\n", + " f.write(str(lenet('examples/mnist/mnist_test_lmdb', 100)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "And here is the version of LeNet we'll be using. In future version of Caffe, networks can be defined directly in Python (see [PR #2086](https://github.com/BVLC/caffe/pull/2086)).\n", - "\n", - "This network expects to read from pregenerated LMDBs, but reading directly from `ndarray`s is also possible using `MemoryDataLayer`." + "The net has been written to disk in more verbose but human-readable serialization format using Google's protobuf library. You can read, write, and modify this description directly. Let's take a look at the train net." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": { "collapsed": false }, @@ -187,17 +177,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "name: \"LeNet\"\r\n", "layer {\r\n", - " name: \"mnist\"\r\n", + " name: \"data\"\r\n", " type: \"Data\"\r\n", " top: \"data\"\r\n", " top: \"label\"\r\n", - " include {\r\n", - " phase: TRAIN\r\n", - " }\r\n", " transform_param {\r\n", - " scale: 0.00390625\r\n", + " scale: 0.00392156862745\r\n", " }\r\n", " data_param {\r\n", " source: \"examples/mnist/mnist_train_lmdb\"\r\n", @@ -206,43 +192,16 @@ " }\r\n", "}\r\n", "layer {\r\n", - " name: \"mnist\"\r\n", - " type: \"Data\"\r\n", - " top: \"data\"\r\n", - " top: \"label\"\r\n", - " include {\r\n", - " phase: TEST\r\n", - " }\r\n", - " transform_param {\r\n", - " scale: 0.00390625\r\n", - " }\r\n", - " data_param {\r\n", - " source: \"examples/mnist/mnist_test_lmdb\"\r\n", - " batch_size: 100\r\n", - " backend: LMDB\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", " name: \"conv1\"\r\n", " type: \"Convolution\"\r\n", " bottom: \"data\"\r\n", " top: \"conv1\"\r\n", - " param {\r\n", - " lr_mult: 1\r\n", - " }\r\n", - " param {\r\n", - " lr_mult: 2\r\n", - " }\r\n", " convolution_param {\r\n", " num_output: 20\r\n", " kernel_size: 5\r\n", - " stride: 1\r\n", " weight_filler {\r\n", " type: \"xavier\"\r\n", " }\r\n", - " bias_filler {\r\n", - " type: \"constant\"\r\n", - " }\r\n", " }\r\n", "}\r\n", "layer {\r\n", @@ -261,22 +220,12 @@ " type: \"Convolution\"\r\n", " bottom: \"pool1\"\r\n", " top: \"conv2\"\r\n", - " param {\r\n", - " lr_mult: 1\r\n", - " }\r\n", - " param {\r\n", - " lr_mult: 2\r\n", - " }\r\n", " convolution_param {\r\n", " num_output: 50\r\n", " kernel_size: 5\r\n", - " stride: 1\r\n", " weight_filler {\r\n", " type: \"xavier\"\r\n", " }\r\n", - " bias_filler {\r\n", - " type: \"constant\"\r\n", - " }\r\n", " }\r\n", "}\r\n", "layer {\r\n", @@ -295,20 +244,11 @@ " type: \"InnerProduct\"\r\n", " bottom: \"pool2\"\r\n", " top: \"ip1\"\r\n", - " param {\r\n", - " lr_mult: 1\r\n", - " }\r\n", - " param {\r\n", - " lr_mult: 2\r\n", - " }\r\n", " inner_product_param {\r\n", " num_output: 500\r\n", " weight_filler {\r\n", " type: \"xavier\"\r\n", " }\r\n", - " bias_filler {\r\n", - " type: \"constant\"\r\n", - " }\r\n", " }\r\n", "}\r\n", "layer {\r\n", @@ -322,31 +262,11 @@ " type: \"InnerProduct\"\r\n", " bottom: \"ip1\"\r\n", " top: \"ip2\"\r\n", - " param {\r\n", - " lr_mult: 1\r\n", - " }\r\n", - " param {\r\n", - " lr_mult: 2\r\n", - " }\r", - "\r\n", " inner_product_param {\r\n", " num_output: 10\r\n", " weight_filler {\r\n", " type: \"xavier\"\r\n", " }\r\n", - " bias_filler {\r\n", - " type: \"constant\"\r\n", - " }\r\n", - " }\r\n", - "}\r\n", - "layer {\r\n", - " name: \"accuracy\"\r\n", - " type: \"Accuracy\"\r\n", - " bottom: \"ip2\"\r\n", - " bottom: \"label\"\r\n", - " top: \"accuracy\"\r\n", - " include {\r\n", - " phase: TEST\r\n", " }\r\n", "}\r\n", "layer {\r\n", @@ -360,7 +280,56 @@ } ], "source": [ - "!cat examples/mnist/lenet_train_test.prototxt" + "!cat examples/mnist/lenet_auto_train.prototxt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's see the learning parameters, which are also written as a `prototxt` file. We're using SGD with momentum, weight decay, and a specific learning rate schedule." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# The train/test net protocol buffer definition\r\n", + "train_net: \"examples/mnist/lenet_auto_train.prototxt\"\r\n", + "test_net: \"examples/mnist/lenet_auto_test.prototxt\"\r\n", + "# test_iter specifies how many forward passes the test should carry out.\r\n", + "# In the case of MNIST, we have test batch size 100 and 100 test iterations,\r\n", + "# covering the full 10,000 testing images.\r\n", + "test_iter: 100\r\n", + "# Carry out testing every 500 training iterations.\r\n", + "test_interval: 500\r\n", + "# The base learning rate, momentum and the weight decay of the network.\r\n", + "base_lr: 0.01\r\n", + "momentum: 0.9\r\n", + "weight_decay: 0.0005\r\n", + "# The learning rate policy\r\n", + "lr_policy: \"inv\"\r\n", + "gamma: 0.0001\r\n", + "power: 0.75\r\n", + "# Display every 100 iterations\r\n", + "display: 100\r\n", + "# The maximum number of iterations\r\n", + "max_iter: 10000\r\n", + "# snapshot intermediate results\r\n", + "snapshot: 5000\r\n", + "snapshot_prefix: \"examples/mnist/lenet\"\r\n" + ] + } + ], + "source": [ + "!cat examples/mnist/lenet_auto_solver.prototxt" ] }, { @@ -372,7 +341,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": { "collapsed": true }, @@ -380,7 +349,7 @@ "source": [ "caffe.set_device(0)\n", "caffe.set_mode_gpu()\n", - "solver = caffe.SGDSolver('examples/mnist/lenet_solver.prototxt')" + "solver = caffe.SGDSolver('examples/mnist/lenet_auto_solver.prototxt')" ] }, { @@ -392,7 +361,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": { "collapsed": false, "scrolled": false @@ -412,7 +381,7 @@ " ('loss', ())]" ] }, - "execution_count": 10, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -424,7 +393,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": { "collapsed": false }, @@ -438,7 +407,7 @@ " ('ip2', (10, 500))]" ] }, - "execution_count": 11, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -457,7 +426,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": { "collapsed": false }, @@ -465,11 +434,10 @@ { "data": { "text/plain": [ - "{'accuracy': array(0.07000000029802322, dtype=float32),\n", - " 'loss': array(2.375746726989746, dtype=float32)}" + "{'loss': array(2.301163673400879, dtype=float32)}" ] }, - "execution_count": 12, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -481,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": { "collapsed": false }, @@ -699,7 +667,7 @@ "eU5QDbaKiorKc8L/DzAr6bE92WeRAAAAAElFTkSuQmCC\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -714,7 +682,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": { "collapsed": false }, @@ -920,7 +888,7 @@ "AAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -943,7 +911,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": { "collapsed": true }, @@ -961,7 +929,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": { "collapsed": false }, @@ -969,10 +937,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 16, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, @@ -980,470 +948,437 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAATQAAAD7CAYAAADkSGhKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJztvV2sb0tW3TfX2fvce9tOAxcRXUOLNA04tIksgfhQJCeC\n", - "liILy5IdHrDFS3hwIgslThTlwfjFdpKHxJGMkGwJReFDGFk4liI+8mDHuOUo8EAAicSdxIZY3S3R\n", - "DnQjpSF033vO2XuflYd75r5jjz3GnLP+++yPe/hPaWnVqrVWrapZVb8aVWvt/972fY+jHe1oR3sV\n", - "7NF9Z+BoRzva0V6WHYF2tKMd7ZWxI9COdrSjvTJ2BNrRjna0V8aOQDva0Y72ytgRaEc72tFeGTu9\n", - "rYS3bTt+D3K0ox3tVmzf903FHwy0bdu+KyJ+KCJOIuJH9n3/G3zNxz72sWv3fepTn4qv//qvj23b\n", - "Ytu2ePTokQ1fXFxcbufn59fCGHdxcRH7vsfz589j3/crYbXP7eLiogxHRHzJl3xJfOmXfumVvQp/\n", - "/OMfj+/+7u++lg93nOXMjY8xLv0C/rfhbdvi5OQkHj16FCcnJ2V427Z4++23r2zvvPPOtbi33347\n", - "fumXfim+5Vu+JR4/fjza9n2/Vkeq3tLXWEbcc1j5qdomeTg/P78sn2onalvJA9cv1quKc+2Gt4iI\n", - "09NT6X+O/9mf/dn4nu/5nrLPYZh9oHyScenD8/PzODs7uwy7rfMtbmw/+ZM/abl00JRz27aTiPjb\n", - "EfFdEfGNEfG927b9sUPSOtrR3o+Gg8h920PKy33boWto3x4R/2Lf90/v+34WEX8vIv7sy8vW0Y72\n", - "sO0h/YXNQ8rLfduhQPtQRPwmHH/mRVxrb7755oGPfPj20Y9+9L6zcKv21ltv3XcWbtW+6qu+anzt\n", - "Q1JF07x84zd+4y3n5P7t0DW00ZDwqU996jL85ptvxptvvhlf/uVfHhF6bQTDuGX8UgZfjFpqz2sQ\n", - "yqpnq7WM58+fxzd8wzfYNQ+XvlsLw/twX/kh1144j7k+lXt8VsarjfP/1ltvXUmTt4uLiytrRmq9\n", - "Etcp1bO4HXAclnO6dWXL8n3oQx+69BHWGbfHR48eXVnzc21W1Q/WI+5d+5yWT5WX4z760Y9eW7/N\n", - "tUBsZ1Ubd77k9dDJNi3fb//2b8dnP/tZ2+7RDgXav4yIr4bjr453VdoV+9qv/dprN3bw6ra8D62C\n", - "V+5XIKaeh40xzS1g8nMxfQ6rDoANnZ/J1zhTMOM85LFqiNWCNL94QZgh1FYaepZRwavzF5bXdUJX\n", - "RlVHmBcEzwRmmE4HuKqupwDjuu4W7zNvCDPe8/NXFvBXYDaF3VtvvXVldvCJT3zC+vNQoP1qRPzR\n", - "bdu+JiL+n4j48xHxvXxRNVIdCjKnaNIqiFWNxOVTHVcjF+eDw5hO1egZnEqxVIZKQ70pwrxUqqka\n", - "SZ1Cu7i4uHx2pq3eavKzGCZqn2HOi4rLDqreXmPZXB0hyDgv6g30VKnh81gNYr0pgKl2yxBQAw62\n", - "TwUxB1Sn/tifXL/V5qBWQXtqBwFt3/fzbdv+o4j4n+LdzzZ+dN/3f8bXqQrtYDUBmUrbAaSCWAWy\n", - "CTjR8VmpHWzUKO6M84cdt3tOBzIEATfOSsV0o3b6wAHNPYvLVIUnQMMOO1EBytjXCgAV1DDvrr7U\n", - "s7s2i2Wc1IlSaVwWBbgKjBXMDlFpHOYBZ2oHf4e27/s/iIh/sHqfm0JM1VkFAQUyPlYdlPPH4OBn\n", - "VkpFdcSuc3K8Gr0VxCrAucavTI2cKxtCDDcGGoOM1VI1iPC57HQKaNgpEdiq06gOg0q8y0fXZlVZ\n", - "Mu3KHMBUG1aK2qkgzEsCLMM8aKlBGwdvNwiuLDPwXpVzxW7tLwUi5gptCrWJTUDmYMb5djDDdLki\n", - "cw1CdQSnOLsGjx1LdbLKDzwi8/mIGDW8DuKszvIZSpFVSlDVg4rb9/0K1BJorDAYdA4MFdjQ8Jl5\n", - "PIEa141qU67+JoPKFGrcDrA86Dvls6lC47qeLGlUdbNidw40jL9NuHUgcw0Y4ysF5Tp3NtYObNXI\n", - "j8/h4ynYsIFmA1YwiIgWMl0n2rbtEmYXFxfX8qDSV1NOZQ5qDDLeZ9nxWtVRq07TtTWsS/5rDtdW\n", - "uQ6xPBjX+R3zzerGqTNWYzjgcbx7XqXGKpBVL2U6lbZi967QVFwHshXFxlaBTqWtGqaq3KywfMOX\n", - "HV2BrQOzG7FXVBo2dsxPPh/TUNMH1dAyXaWCGGZpFcQmQEPj6VIFtFSN6DM1qLmBDX2o2kSeq9bP\n", - "8toKbK7cHYC7QdWpITYHsSr9iVqb1rkq22SwcXarQFN2iDrjezkccdj3Oyv5VKYqPA1ff6sGnhuP\n", - "zJy+imO1qPyC9yJ09n2/piYOUWiYZqWeu46wAjQsY5ZbgQ3VGfuj2/Nz2MdYZzcdhCuoTUCW7a2b\n", - "vrFCU748BGiszKqwAtwU2it27wptFWyuYSjrYFY1Yj5miLjKRuP1Fix/Ai/Tw4aFecO4Ttmp8is/\n", - "YnzEYWtoDDX3/E4xHAI09AWWBcMINfSnyiOny4B0z8d8TOCOz6zy1YFFteMJzLJ9YlvrIOfqS00n\n", - "uxcFKwMmlmHF7m0NTSmgm0AtTZG9or6DGsOAr1cwwykXj7z7vl+ZfiqF6Z7hGn0HE6XkVJm6j065\n", - "8yDMcFqn8s+dwYXZB843abg+piDGeevA5M4pqLHyUu1XHXdlcm12opang0f6hcs4hYsDVbfneybP\n", - "dG2/slsF2uPHj6/FpTrhvYpLZ6cjTk5OLsN8T1YWTkHwmWlqRFbhNP7ZHRz1Mz1uMJgW7hUEVKUx\n", - "DJ3SZeN7VBrqGgXQqnEpqLl8cadSQOO0q3JhHP/cTT4P1W/lCzYGmIIZPr9qY6vKkM+tbm5KiB86\n", - "818BdHlx6moKsQpqrpw3tVsF2uuvv34tjhdRu99mmlRcwi7i6hu8TtU5lYj7R48eXf621OnpqYUa\n", - "K7SJKRXH57mTuT1aplOpD36GSkP5HgePjMOy8BSmgxkDTflBxbm/Q3T+OiTMz1eg4zjcY7gqizpe\n", - "GVgSXNkGXf/K45OTk8t7XTji+trqykez1abKoXwxab9stwq0N95441ocT3u6LcJ3rmqK5KZXq/lA\n", - "oOGPIjqVhnFT6xRY1znRVlTF1Jz/Mx8KZBjv9hzHz6yOI/SX+66MlT8d0BXAJv7lDuoGrirOwUuB\n", - "TYFMtX0EbcIL0+Y8IchW1NcUalx2NB6YpnbnCo0d7SoA1QkCKx1yenp6TVpXla6MRzE19T05ObkC\n", - "M7wG83eoQjtEgVXxER6mk8bRqQEHNnyGqjMHMTViq3K4MvHHtXh9NRBM/axgVrUpdU7BKvfdOXct\n", - "A81NOdUAnTDjPT+fwXVTiPGU0/kr7cEpNAe03KtGpYCGHQNBdnJyEhcXF5dra3idSitt3/drEHNb\n", - "Ai2hVk05uXNj2ZQ5Balgz7aiAKfPVUBZ3dSUc6LSlELg4wxzu1BbpdKqNpjPUb7hwcfVgYNaBSf2\n", - "N6bTxVUQ4+MKoJx3BtmhMMO6PqSfrNidTznTumkUNhp2SEItVVNCLa9VP/FS5QPhxfuTk5Nyyon5\n", - "W1Voas0Q86WUa6UAMHyIslNpdsDqbDLVrKYgXdkYblzWSpF1Ko0h1qk1Fa6Ul1NhU+gw0PCvNdyA\n", - "jqqsShPTVWC7qVJjv7u6XbU7V2hpKx1LOSThktvz51cXrPnrePVMluFuQ6DxlJPzuGr5fKxQrGie\n", - "3qpOhJ0a46d+dkqt6mgriq3bp9+mcED/ZB07hcfXKx9zx+p8pkA3gc/KptJwYQWz3GO58x6EGYMN\n", - "rQLZTaedytcY5waZzu5FoSnnqfPZYHlLRYaA4Y0VWgUzhlrCK6eaOOXMZx6i0LjcqSZd5XIelQrh\n", - "dLnTVx20aiyqI+agMVVsCmoObA7IKpx+wY6hQKDKWsFMTTsne1du9p8CvYpXZaiO0w/897SqfhXM\n", - "nL/3/eoPdFYgWwUc+9v1gVW7F4U2HYkjri94XlxcxOnp6RWoue/TJtNNnnIyxPJfgXVraFn5q6ZU\n", - "hsqfsmpgwMYxUR0qzaozplWAW1FplRpxQGOYOeCnqQEDw85HU5hVagsBxjBT55w5JZX5R5ip9pjP\n", - "YZjhMcbfRIV1QFPfC7I9eIWmRlIXF3H1WxgHs1xHU28pubGigmGYoUJDkKFiwzW0Q6ecqmNxB+D8\n", - "oZ8UONjH3fSpU2cVzCqI8c/TuCmmAxqWx8VxvVYwUkrAwUxNvV1cBR3nww7oE6ApU7MRN7gyuBzM\n", - "Ml2l0CaKrdvUDzhE+EFnaneu0BhebkTDCua5O8NMTTlXGjvehzDLzT2L83noZxtKiakOi/Bg9aUG\n", - "hA5qmE5lVd1EvKfS8DjDU3VWDWqqXOkvla/K1yqOAVeBTIWVnzqQVXEV0FR9rbY7zJuDWYRfQ6um\n", - "mxPA4cCIPlTTzQcFtNdee+1aXDX6q4agAOZAhi8Hqm3fd6vMWKXxVJOnmxFXR8g07Cg4pVTwzuv5\n", - "PoRtpoMfk6q9S6dSNeoYTTUq7tQIFVZxkw5dQUwdO1+rz3G6MnO5HVgVPLNeVPkzHiGpYNVBGcvK\n", - "sOVz6HMF5Qpiqn2qX9CoIKfqlwctHpzYuI5W7F6AxgVUkjsd320IpefPr/69p4PHvu+X6gvVGEOs\n", - "+qAW00J1EnFV+anGyR2Op8lOcebzco+wZKhiepw2K8IKCAqsSvlyh0WFtgK0yhTo1YDE9ag6SBU3\n", - "hSqXh48zn1hH+ExeouABCcvNYa5nrB/VJnMQV6IhN+w7WZbqLwS6nweq+mClltXx1O4caF3jxpFt\n", - "oszwGKGmnJiGQGOQKai5dbkJzLgSFVwcwHifeUdVwAown8vPUtDKNB2sVN6wHMqvfNyN2gy0qkNz\n", - "flXbUPWo0qjSn8A1QgNNbexTBpnzo8uz8oeqEyUSGGbZVzKv2f8YaAys6lMOBzE21d5U/Ird+a9t\n", - "qAbAcelUBzIHtgnMsuNXIFPTzUqZRLzXuBFmOPXC5zuYdXDL56EactNZ1Vi6BuSm6NU9XLdoE5jl\n", - "lmlyXalGzvVevcxJoKn0V+JUvOrw3MkrvytTMJuGXbvMa7A9MszcDEfBzJVV9esJ2NjHDxZoTqFN\n", - "tm3bWpApqE0dyAv/lVqL0CO7WgvIDpeNh011TAc2dY0Clxp9p6PfBH6s0JQ/eMrJU5pqasZTMW7I\n", - "Lj+45KCmm1mfqzZRcVlGVDQ89UqI8Jf7zlBhO3+oY85XpoX7tEyfwYZCAmdJqm9OVGkFs+lg++CA\n", - "phTahOzZALo1Mwzznz8pQwepkdxNOSs4csNRFcrPV6BSEHNrI5x2BTQut+oQTpmpDeHtfIF1zWCr\n", - "gIbAdEqFfeSmmzhAqby5OOUv50Ps/PjbYzkgu6/1ne8qmHVgUwBLv2Jc1geCLcvBYOuWDCZwu8n0\n", - "88EBzSk0nIdjI0CYVW83EWaszvgNjmoAOOWcrKNxY1EwyTCvQaiKnIBDga6DGMa7jsj7lekpNzDX\n", - "QLEjTUd49A3mC8uA/piunz1+/Phah+a8s9KeQASBxj+kiIqMv9rvlNTqkgEPdK5tIMhyQ5DhcZYl\n", - "6xIHpW7ftX22yr88K5jYvSg01QgYZhFhFZmabmZcmpO5OTJN1RlPY3kE5HNcofx8VWkTleaAhmHu\n", - "mPhs3KuwakhOoeEzKli4Bq4gh3lRKrDKmwObUmjOf1imqp4U0LAdM8iUOZ9VEK/ywmDB9HgQUf7j\n", - "+OxbXGeTY947sCmQqbb44BUaftHPYW4ITpG5dTTnNOUgnnIqwGXnULI7jRsOSveqIg9RaV1ndEDD\n", - "Zyvj/FSAU8+ZqINuzSXzkdM1Hgyc75w6QwWu8uXiFDTYJ3nMIOg6o1JnLi8OYCoccf0/eymfY3+r\n", - "tixXpfRcHbtzziZQW7E7V2jsPPcmKCLktMKpNhzl0ZyEVY3fKbVsvBF68Xu6dnCoOlPqqNqv2L7v\n", - "1zqjAqtrXAruU4gpoDHMuB4rZebW0VY6pasLVU/Z8auBU/lLbXxf1z5y7+oijxNkuKzjBk6OwzQn\n", - "A8Jky7K5/ftSoZ2fn9tRja9V6kxNN7Fy0UE5cqEijAgLMPWBLapGp46y4eCr8K5jVvByqgmfOw2z\n", - "VUq2g1uWzT2TR+sVoClVUKlFhpqqSwaaWyZQQOs6fbYnVkurnVDlx4GU47BNoLrlQSWhptJRx1gG\n", - "BpgKczn4GmcTqK3YrQKNF+iVceGx00w6OsItLR2B6g/X7iI80HDtLMNoKO2xMTmJjeFKAbk93pPp\n", - "4XNVw+OwOkZT6qAaLZWKUo26moIocOEIzr7oXgDwSx7cVH7cGtCkzWHby8H5/Pz88roMd5uqg4iQ\n", - "z3XwcVDDuuAXbti/Kniqul2Nq8o4HdxX7FaBpqaB6VgcNbq/5Feg4M6eU8NJ54zwQOPvmRjKSpHg\n", - "i4OJyqpAgXu2aYPicHVO+bcaZbsRl69RCkude/ToUVknDK/XXnvtyvb666/L8CEKbQKzhAF+MnR6\n", - "ehrn5+eX+5yN4D43Psa4BPxUtZ+dncXZ2dk1wDHc8Fi1Ndf+usFR1Xdl27aVMy+eha3YnQOt+lsw\n", - "BTr1JixtQvJseJzOtPNUKhM7fUJtKuc7qHF4MiIeCjenMNW0onpupwJREaRqxhFaqS2nwBhobqvW\n", - "0BTcpjBjoDHMTk9Pl0GGbd49U7WrZ8+eXZkmZtlwuaQDGs6OXF86ZPrIexYh7oUfnluxWwWaenWN\n", - "4Kpg5hbZ09g5DhQ52rFCUOBym+q4DDE3XVHTgw5qWb7KOqiswM3BTD1r+lyuq7T0FU4z03fd1DHP\n", - "IawUwKZAU1sFMo5HaKRKS7itAEwptClU1fQQ32hiP6iApgDXtUG0akaktsknWQ8OaCsKjUcohBo3\n", - "OgUzfNOpgIZKLdVA91EmKzTu2Ag1BzQ3TZioNbYKHocArVIqFeCm+UpjUKu0+fuxhBEqMg4zwFS4\n", - "AxrXp4OIiuO2iyBz200VmsoX+jfbeK7t8bkp0Fw77OLUoM2DegUv9WnWij0IhVatqSHU2NBheZ6n\n", - "Mrz4mecqiDHsWB1W05Su4TmITa2D2CFAU52b0632lbFKRmWG+cj6UBBTCqyDXIbxw1oHMTx2g5A6\n", - "3nf/m/uT9WGn1BTQujf7qMwSrjwNxfJWIEM/YD1mOmqA4jQ6Zam+JXXfma7YvSu0TrF1LwWy4NhR\n", - "UAVgBWVDiajfcnYvBbopSzW6K6hheSaAU1BSYXc97yfK7NB9lk2F0ZRC69bGlJLjOAZaF+6AhuFq\n", - "UK7a9MqUswNa+jOfcX5+HmdnZ5ftGEGUg7lTahXI+DquRwez6Ufx1fkVu3WgMWjUOlkFM4ZaGjtO\n", - "PY/DqOQ6kOWW96itmxqoqaVTaAwyDCslVKlGvqeLm0LNpTdRbq5sGVbTTX5ryW8vJ5sDmtsfCrTJ\n", - "vgNZbgw0BTPs7AyzbM/YNxBoPJDmXkGLlTXXKcarKWbmVX0cP4HagwKam3IyyCZTzg5qeawUEwIo\n", - "K6ADGTo/4nrHzwXhDmyqcziwZRmcKaU6gVAV5xSwi6vyxseus6gwTznVZxm44bXqJQK+YFA+cP6p\n", - "AMbhrHsenLmNu7ZdTTldp+fjbduuwOzs7CyePXt2eQ0CyQENy41h3hByVf2nn3iNGvfd9PNBAs1N\n", - "ORWwDgEZKzQ1lVBwS6C5dTSecjp1hmBLqKkKUaNWBbNuyunKp6ZReaz2XTp8vktLpd0p0tzcG06E\n", - "2BtvvHENaJN9l0eV3wpouVdAc9sEZHlu3/dWxWQ4Ii5h9uzZsyufuvD00QGtCrsZRJpSbTyIK9Hg\n", - "FKc6XrF7VWhKpalp6ARqaa5z4/G2XX8poEaT3BBeDDHed0qN8z2ddk6tUlZq323uGZM9myp3hruP\n", - "ZxlqfK0Lq0Vllb+MU+ByUMu2oDY+N1VnPOWcLJifnZ3F06dP4+nTp5flr9bQsgx4jPWDYbVVkOHr\n", - "GGZZJ5Pp9IMDWvVSoBvFqhcCaTidzAYW0S8AV1NOBTUFtBWYOVVWjX5O1q9seJ/bHwq1ztLPWRYe\n", - "uTmMDd7BLIGWa2iTD6NzyonlrvJcAc0pNAUwBTsEWfWJB045J99oPX369HJ9EYGmZi9ZxgpuSlkj\n", - "WPDlmrJDFNr7AmgqM9kQMPOq46RTLi6u/j0mOpnPVeqM1R2ez8bGcfi1N26sGHE04oaQxnnKRp73\n", - "q/xxY8JOxNapqc7UqJqNML98Pz09lR0W6wbzxg272twaJl+H/mJfZj2y37s2gccKXi6soFWpNgcv\n", - "pdAm32elQnv77bfjnXfeiSdPnsSzZ88uoZl1kf7NX7+pBtTpOdXOuD+pvpDnp+3iQQFNFRyBljBT\n", - "0wIlcxFgDDWemqJzleF51QGws7qGyBBiNcY+UB0QYcDp8YYNNMMI1UPVFHdUNbJeXFzE48ePZSfl\n", - "/GG6k7WgR48eXfvlYO7AbpBQgxKaUte45zhuc6odopLp1s7YV7xXcQi0TqVFRHzxi1+Md955J54+\n", - "fRrPnj2Ls7Ozy3SyvZycnFwBWrefQAytGlyUgHAzGBW3Yneu0LJQDmaqATmYKaXGjTSfyQDAvGTl\n", - "oxzHZ3KDxLSVinKVoVQF5tv5ENNGVYf7VBc3UWoVzFTHQ5Bx48X0VEfkOIaZUmgOarwWlJZTt26Z\n", - "gweY6YYgzXY0hVoVxgHfDQQI+gQaKzQEGio0rnN37FSbM27bOMBwX2SAVeEVuzeFNoVZBTKGWnZ4\n", - "hheqMOz0rNC4c6RD3WjOU06uCDU6KYWGPnG+yHxkGbk8U4WmrlEDiIKaAj1O8VTn4LTcN0nqfzs4\n", - "oGFZnBLHwWkyzcMOqHyv4ldU2cq1EXEFWhXctm2Ld95554pCw2URHFTw13sn7YTLjvXK1/KMh9Wy\n", - "m446mOF+xe5FobkOPIWXKmQ2MG5waDi1Q6ghDFwl4vW553twquDyyY04fcFpYrpYsazqMLxifD1D\n", - "jaGTfxOJdZRhNxJvm/7PXazCMn331tmps3yOqmfsIOonfNzP+6Qv0CcuPAEYKy91D8dHRAsyBP2T\n", - "J08u33LilJPh2P3DGK479oXa47XTZRwGlgs/OKA5hRZxde0n99hJlNLhBs0KTTV2dx/mYTodc8cZ\n", - "VqNMpSiwQVeAqbZD181U+ZRCyxcBao1JjcRYVqXQ+APL3KNCc1PObDvcgSKu/qep9EvG8Usd3M7O\n", - "zq4cY/qTzlwBrAIaq30MR6wptGfPnl1uWR415cS2xoOoO66UGdc3Dy64jMPLOdyOOK4SBZXduUJD\n", - "c3Dq1jPwepWeAhZDoBqdOG4KFwXiNCXLuWE7yPNIxeVx6mVqDmZZD/lxajbKSi1hGd10U33EfBOF\n", - "hhDDNpTX5hf0ueFX9RzHfqnCDDReZ1RA4/pW4QgPNKXQGMrqhyJRoalnq61qL1wHWBc4uKj20PWf\n", - "m7Tpg4G2bdunI+L/i4iLiDjb9/3bxTXX7lOQy4KwFO+AhvezWlCjjusMqmIxjlUCqwWGgeuACmid\n", - "QnOjGXZevu8Q1aagjN/gKbizob/dWpzb8K8DnDpT/sSwahsRcalcco9h3D979kzejz5CU9BSL0+4\n", - "nrst4vqUU4EsFRquCWIY6+z09PSybSiFyO2ep/ETw7aNyqzqy5NtxW6i0PaI+M593/9fd4GCV5I6\n", - "4mqnzXis/GrK6RrvlQwCyBxgqrWMjOO3c9lQ8qWGAppSVZgn18jRlELj8uB1hxqmg52lUqvKz3kP\n", - "d7oKbN1/3ML7XR3inm3f9yvAynUm3jJ+xTqI8acYDl4cp9Syg1pCo4Mj9jNu5wi6LFemq/zp/Ixh\n", - "HFir9ur69qFt+qZTzvKJTqFlgdGZE6q7NNlQWbEqyk1VbPVNEP9NYDaQDG/bJqdHTqHlcaXQMG1W\n", - "ZTcZxZQppclQq5RZpWbVC4Hqby8dzLpBguMi3u2cCbRcOMcFdI7De5XhuQ5iCmhdfjugqWP0iRrw\n", - "sd7US4nMIxorNGwDzkfcVtDUscsrh1fspgrtH2/bdhER/+2+7/8dX6AUGo9ECj4YtwKyTB+VQkIj\n", - "RyeVF2yAasO1BweYbrqZz1NK1Kk0VmjoI/WM1QagAJ35S/U5UWa84XqJgxpPNd36GUMt8+LUDSuN\n", - "fd+vqDB8I5jhJ0+eXIZZaVRhBS5uSwpoXfoR0ULMxalZAh6rwVv1MVZZnE+uA1cudZzmZlurfR7t\n", - "JkD7E/u+/9a2bf9qRPz8tm3/fN/3X8ALfviHf/gy/K3f+q3xbd/2bTaxSjLn+SpcNY7bMoYJT926\n", - "vVIfTtGlqlSK0i1Aoy86daDuU35EkDo1l1u3bua+SaummROoqvIqhVTdg+l34ao9qLwrKLgp2mRj\n", - "c4CPuP6L0WqJhWcNE/8cCjX2m4r7/Oc/H5///Oft/WgHA23f9996sf+dbdt+OiK+PSKuAO37v//7\n", - "3b0WXO78ypZpqP2qucbjRg/u8NzxceNfRXAwS6DhqN9BrfIBd2xWitWCMPtDqQYGmvugVr3NVDBT\n", - "sO/MtQesOweHCjSZVg4wahaCaacCWhmgnV87JeZmBPh89xLDwc3ldQr6lyE0PvjBD8YHP/jBy+NP\n", - "f/rT9tqDgLZt2x+KiJN9339/27Y/HBF/MiL+c75OFeBlw2s60jblOXhUdB2NO7ybMlTrIQwYbITc\n", - "KLlhTmCW++5NHJaJy4ZTVE474ytF5qaXbgrfQU0NkFWdc3k6kOHxJH1U1phHDnOeV2HGZcJ0M86B\n", - "y4FtBV5TqK1cewgAD1Vob0XET79w1GlE/N193//RSgIMoNvY8FnKVAepRu2J3J8omGyg/DMq3CBR\n", - "oUWEBNlNppx57KYbym8KZqjI8LosI74IqH57rgLZIVaVw9UXn1NAR2B36aG/8F4MK3BM1sdyq8rO\n", - "ea+g5oDm8l2Fu+NKgLi2OrGDgLbv+6ci4psOvFdm2EHJqQanzJzT8tiZU16HdCinzjpl4qYM+QZK\n", - "KTIHOSxv12C4EVc+5fJV0FB/EVBNQ5UaWVVnKuzqZzpAcXoqzqWb4J/URe7VQFhtK2njwOXWzzqg\n", - "db6enHPtTMWv2K3+pUCVGTdSdYBb2aZ5qUC2OgVVaSiY8R9fc1oM9YhaofG51UZeQU35yk3T8Jz6\n", - "VEMBzq150pDzAAAgAElEQVSfKeWa4WnbmpiqSwUr9YxUSDm1VDBD8OO9bp/prgBNDWJOIDh4KaXu\n", - "/Nr1r+7eauvaYGW3CjRnLxNaquAd3CL89zoqbqIS1L1uuummWZwGN9TbUGgRcQ1kK9NO54sEWvdW\n", - "s1o/m/oey8JxVaeo0sew8wFDiqG27+/9/eLKABMxBxrCHevdAayK43MTUXAI9By8XHjF7hxokwp9\n", - "WWBbtakS66YnPEqraSeun+V1SqFhI+0U2uSlgIpz62fqXqU++RwqEzXVrKacTp1NppyuvK6OVJ1V\n", - "96hncbtVIONpYdf2sT1MgMYgw/xVU0sHkQomq1Bzxw6uKn8rdi8KLe1lQKy7vzJu1BznYIbXTqab\n", - "SqEl0CqVkPnPDzM7kOHf8K0oAjdi4nVZtuxwDC4se17D5e3W0rgjK9BPoIb+U23A1TGCZ8VwwR83\n", - "XmN0UFO+VnB3QMt7FTizTrltVIpcDYjKt12cO3Yg615MTOxe1tC6yn0ZGz9rArcJzCZqATtI7tUa\n", - "WjfNSTDksVszU59toP/dfuJzVTbcZydCkGXnmr4M4G/xGGRuMKk6DBvHuXpVdeGsarsc565X4fTr\n", - "BGo49eUyYntAoLkXbe6lUOeDKk7VUQUx9fnIit3blDPDKzBzFVE1ps5UQ55MOdVepcsKjdfPuhEw\n", - "927xv/qpGpWOiqs6osufUh8Jsgy7NbTJTwRVynVi03Zwk+cgVCs4dSBT5xS43BpjfgOY63eYFraZ\n", - "/J+f0419WZkbXNQxA636hZIHDzQeWfEYpyyduQ7bTSfcQra6BxvMy9yqf6/WNYRDOgnvK8ixL26S\n", - "BzXddH+rmd+wTZUx1ncVXoEUt0tnmAe+jtvvBG4V0BBkrFwzrH5kcyII3HVuEOj65RRqKk9q+okv\n", - "uKZ2579Yi42MGyyGq2s4bdcZecGa06/m7rhVa0Dql1cnf7fIb6iygqup1Oq0aAV4ri7UcyZAi4hr\n", - "qlT5UC3+q3w4FYztyYWrNLpOzM/D8qlzyl/OV5XvEFgrb3yVuprCrLLq/AR+3f1ue1BAUzZthLng\n", - "7GBXpc/KDC3TnW6oNLq9+40vt36UZVYNSylZLufEVNocl2lNpn1KcfCegbbymQaWTe2xnfAA4FRZ\n", - "1/mxw+M5TmO1PtRAMIEalpXVWAczVTbXxro8cJrV86b38HUuPw/ypYBzfDeCOrU2eR5DkdWNguYU\n", - "aCtQm3xEGjGT/FyGSedh657BPndrNxOg5Z4/V0HAcRjflKo88Z6h5kBXqUzXsZVvsQ7yngmA+f4p\n", - "ULqBZQK2KdDwHg5X6d80nq9R24NSaFUjc3F5X+67CnQdExen87p8FoKsg9u+72OQqUXw6i1f5ku9\n", - "NsfyVY2384vrQLjx1Jy/ncNwplPtM8wKjFWZmnJyPXIY41bajzMHeGUKbHjOPRchyM/EY/ahSmdS\n", - "HpUmtqtJ/anjlbgqHvM02Vbs1qec1eg6Gdmqht49My3fAmHFKXgpqDHQVtRZtxge8d6/pcNF0cwH\n", - "l2U6QrO5kS/D2FHzOQkazrcayV3c9LMDNd3s6tQNlApylZJRA0nn1wnY1BRxqs4y75g+9wnMx1R9\n", - "dgMQxyl/TeIOTYfr4sG95XTKwU0HUF259bMq3TzHKpCvyfMMMAW6BNqqOpv8kCHnC2HWNdrKuMwO\n", - "ZjxiY2dUb2UTwuoZKqw6d/fh7KpVMOPrFFjYRyvP4bRdWfHaKdQyXc4Dh1fUpyrjpB4nxy6uu0aV\n", - "X73AmNq9vhSI0KNRhqdqhAs9UXROleFxOrQC2BRqTqGlOsN8JewQ6od0+GqkxvJVU05+2aF87hq7\n", - "qsNqU2m5cnH7Ue0IB7apf9h4UMS4qr2yAsWydVA7xBy8VoC28qxD0nD3uXy+rxSauobDPMJNOraD\n", - "I4azEzuIOaAdAjVWOm76hsYg4/KvAq5qMNzQlUpLmL322muX6XH66tip66o+Wc24dDnsBkg3C3C+\n", - "qUw9g88jzFiFOoBOoObyVuVZ1Xdnq8rrEFWGcR3U3hcKLa2CG087Jx1YdXw8xmsQZAwx3lfQ6qBW\n", - "vRhwHUMpi6oDuTSqUY+hjekpmOWmzDXYClauTFXHVaos03Hhzj8Yzvam2iXmC+FUKc7uT5SmUOOy\n", - "V36q0j1U/XHaKtzlqUqrGmwfvEKLuD6CZ5xq8NWmKmk6vWGQMdwYaNVLALXwX31MWim0VI/cWbBs\n", - "K77mtLtRkKGG081UaKouq2dOzzGounuUYlIwWgW/GzzUs9Wz3MsPfh4eu3N8jfMFxzlAOOv66jS8\n", - "as4fkzwru5df21DTik6BVCMgynp1jWrUOBInzNR+qtCqzzPcx6RYefinWW7kV/5jP6r4qkNUAwL6\n", - "NvPeAUflZ9L4EWb8jKpjq/y78kzyXHXsKg01O2A/KhU5hRvfc1fmBgq+ZiVPrs1Nru3sXn8+KKJW\n", - "Fgyuk5OTa1OlLLBad3IKBxVahrkz4acT0ynk5Gt49VV8BTGn0NSgUCmvyr8VPN0zlE1URAe6TrE4\n", - "AGCZOFwNelPrBldVVy4/Km1WmZ2SRlPxDrBV+bryd9YNNnnMfWHSd6d2bz/B7YwbAMMs906eVwBg\n", - "B+EUQ4VRoU2mkKenpxJeqG44HwgzBzYui/LxtAOwcsCOVI2SnN608a7EVWVw5arKmHXIalN9I9bZ\n", - "Crw6cLDPWf1kGdUH1spnzhercFgFHse5AYrjOoA9WKApq0aTPI+dncHgRmX+KHKyV52Hp4IJtO4v\n", - "BVCRTVUaQpQ3t47G/kqfVSoG78M0MX7SGScdaQoyd+90Y1ONH6HmQFZ1GtepJnBTYRx0OT32CXZ+\n", - "vAYHXfZZlT9sc1OrQO3ai2p7LBYmAJu0R2UPYspZVTRWBkMNKwc/RsX7VTjCT89UXKfMGF6rU04H\n", - "sNURa9rxWRFUnXyijKrReGLse1bguKFqcSqH49366ooicT5SPnMDUAVO9odq2wpmXVqcV6zXzrqy\n", - "KR9W/QmfqwaYlcHG2b0CTXUuPo+L5Qkz/GI9C736erdyOB9Xa2e8xykmh/klRjbUKcyqslTgUYqW\n", - "/aeew/dNIbYCM86n+rtWDme+HcS4Uyj/V75V/nG+cvCaHLtzWVb1nKpOOK0JZKu6mpS7Gvxcu8T7\n", - "KqitwiziAa2h8QiEHR3fOCLM8j4HNPV8JYd5z3HuJYBSawixCmZYvhUZrkZEDE8UmoqbAHPqP+f7\n", - "Kg9KiXGY/7rBKR/22wRkzi8cVve59Bywur3yTVVHna9vAogKOHgu8zFR2Zyvlwm1e/03dhHzKacy\n", - "HrmmqmHSCTE8faPZKTPuWFwGLK+DnPITl8EBzfl6mn4FfXVuxVTDd98FZvrZLlipcbtxbzldWdkU\n", - "eKZgU2l04SxT7nHti6+pBq2bwEG1P/Qf+zTvwa8HnOLO+zqQvW+AxsaVhBWClckgvLi4uLwGpyOu\n", - "43XgcuHuT5j4pYB6w6k2Na1YgZmDmCsr+s5BgBuQGwg6uLlBKs+r53TqjIEWcfVnorg8CTTVATuo\n", - "KYgpX3WdrgOYywsq0U6h5fXdc6cvBRzMqjfGeB+DjX9JRpX/kHVOZQ9mypmGBcD1MzyPMFPfpbmO\n", - "7ZRLl99KoXGcg1c3Gk2nn5VNYTaJ69JdgdvqMxhg/OdamG8e5PI5lZqofNrBrQPbpL4m96AvqnQ7\n", - "Razura53AwNDTL3gQqAhyPIc5ncKsgcFtM4mmVUwy039TWI1demA5vKoppYOblUD4OOIvuF2naSC\n", - "+MT3rlEpqyDmjrmxV+bqTgEt699BzSkJjJ/4aAqzialBrBrYsvzuGa6eDx0QJ/l1M5CIq7/th30U\n", - "84pTzkMHhMru/R8NdyNkFj6vzzh0spqisOzlc86UE7Pi3FoZx7nO9LIqsbqGy+dGOjUKr+blEBXs\n", - "ylMNSE5xcxqu46n6UYONghcfO78cAjd1vworq/xQ+YTv4TDf3y2dINDwefySbvVj2kOhdqtAc59S\n", - "uExmw2ansgyOuL4gzPIW34zyx4lpqtO5uK6jqkY4Ac+qujpEgXX76tMT/CuHag2mis9nVWFXBqUS\n", - "Ivw/YFFlwT+wVz/tpMrJkK/K5IDLcahOuIPv+3tvbvd9l/9wFxVr1WbwGVm2fb/+hUBXj9XsQk05\n", - "2T8VlNRUtGoLU7tzoClocbyCWlpWVIZxuqbkLd6fafMz0Sqg8TUKDlyJE7hVtgo7NJUXtU3/BtWN\n", - "vurZfG4FatjJGWR5HYKo+gWUR48eyX8t6D63ibj+qQLmiesl87miVqtvzPIZ7p/udiBj+Od16nMn\n", - "NtUn3ayDz3F9Y92pc7dld/5SwEErooYdGq8zsJPwbQr+BQE6uFJnCnKuIhQs+FkrtgIwlXfMl9u4\n", - "w1afpDDUUkl0f2fI0J9ATeUf00BlwwpNAQuBhlDD67mszndVXTHU+Bjbo1Iv6jkKZqtgw36C5zjs\n", - "4lybUWHMS/dc9B22FWWrfehBKLSqcaOK4ntYzvOzHWSw0aV10reDmmuYbpTCMk8ApgBeNWh+fjXK\n", - "rryp7f62UOV7VZ1xfbMqR3XQgQ2nnJ1CY6Bx3WKZMK8KYlhnEVfbI5bftU835URIKigwzLBMrmzd\n", - "+cnAyPmrBgTV75QdIgjuBWguow5mVbyCnbKLi4tr97OphriilKYj+yTdQ5Wayk+3DtJ9JMz342/G\n", - "uQGCy9JBjfPNxssLKt+svh4/fiwVmltDc9OySqHxwNq1HezsWH7es0JLiLk3+lzn6SPl22pT13Cc\n", - "O2bgVjBzvrmp3QvQlKP5GgxzxavR3QFKVdoqSCby/pDRpHr+TU2V26kvt0Cu3tyqKTwPLFVduLBT\n", - "vnyc1zOIGFYJsekaGk45K59ieXiv4KammxXI0tx0k9WZUrcMNKWoOsWl1JvKLwI4Xz7wgFcptCru\n", - "ELuXD2txHSSNG4tyojvONPGZKbcd1DifFby44bjO1418zhws1Uh8iGJUiozVWfd3qTglS393gwXX\n", - "YwU1lXc3kDmFVq2l4VtOtYbG5XP54rI4kKk935flUuVOgCmVhipIQS3ivWk69gH2H0OMw5ymMq4f\n", - "XJqo+vDUz6t2rwpNQcIVXMUrhzGEGGrKnMpTkHN56yCmnu3SnECru4ZVFMPMTTMZduot5wTUrFww\n", - "XkFN5V3FY6dxIMN/6nJyciKnnK7s6FcEj2qrK/sK4GqAPeRlAKfHi/OZB/fmksOcJ2d5rmoreO0h\n", - "g/PU7hxoPHJEzD/ZqCQwO4nXXColgeYUGp7DZ3NenFRXz3HP7vIztUqhTTY1Pc08rcLtEKXGfsQO\n", - "qcCspp0JtO7FQJZP1Tvmm8PcdvFcpdQ6c0BzcGOfYd7w2d16KoOuU5tYL9mvWe0p/02tm92w3fmU\n", - "kz94VZKYjRu2goYif6eYpopsooYczCYVUim1Lm5FNTplo+DgGnqmo1SvUslOjTmQTaY3ldpU4Ko+\n", - "quWptYKEUmx8rlJ1PP3q6i77hlJqlcJRvubnOoipOs+0VD9Q4J8oNLz3ZauziHuacqZhA0K4sUTn\n", - "+xkc2YgyHTcFVKOFgtjKtmrcUdRx97wpcBXMnEpzjXplodiN3nkNhvmcM/WcTm06qE3+G1e2IVd3\n", - "DiQIL7WksnKMbRmhhnGcDzVTUH5066gqrMpcbR3IXJlfJthuFWhf+MIXrsWpuXu1j6i/ncHOgV9X\n", - "54bHapGVGw/HRbz7xun8/DzOzs6urM88fvw4nj17duXYKTQFApU3t52fn19uZ2dnV445Dl+QcHlO\n", - "T08vy39ycnLZAauRGuN4sbrac7k7pd2F2X9YLvTf2dnZ5X3Pnz+PZ8+exdOnT+PZs2eX4TzOcG7T\n", - "gSQHXBwwlCJ2HbuzCl4MAAeO6QCOAK/U1IpvpqBSdY0D8CrsbhVoX/ziF6/FdY0Az+X1kz03bJTp\n", - "eJzhSUXkPkFxenp6CQ+cxuB+mt/sbBXQOO78/Pwa3PA4w65s6YOE2snJSVxcXJTrKLxNfMxAu+mG\n", - "g1uagtmjR4/i/Pz8Sie5uLiQIFMwQ6Bh/bu9K99E1XbHDmj87MoYauw7tSHcuj6C57tpsQKTGqiU\n", - "P1fsXoCWe0fnStW4OHZqtZCqPvGo9qenp5fqLGHm1mlUGVW+EWisMJziQagpBZdh11Bxw+lWpZAZ\n", - "cM6v6rupqqN3YX4mD3BZPww09Pm+v/s3jAmwCmRPnz6NJ0+eXKl3Ntcpu23SFlTZcn+o+lF5dvBS\n", - "17iwinOfk1TKsvPh+0Khpa3ASt3Hx+xMtUdHp3WNd9ve+zUKhJn75sk1XAe0FVVZTaMx7CCW53nd\n", - "zCkLddwNFAy0DpAc3vfrf66DLyGwfpRK4/aACq0C25MnT+Lp06dte1Vx1eDMx9N7HFBuahWQ8jj9\n", - "X12v7q8UpetzlZ8enEJTa2hpqxmd3FPJdDw3TTvj+Cdp+M9scL8CtMxT9UfIEyXkfpEBF7kRZrl3\n", - "i/6VyuDGW4URVNMNvwXLvPEghJ2ep7gZn9u2bRZiSq3xM6oB19WvO7+yVSBYBRv7Tk0Xc7BioLI/\n", - "8ZjPdVCr8q6UGSrzqd0q0N5+++1rcVXhJgWvbDqapE2nA+5LevV2rUqPw07ZVKrHQURNp7OR4uI/\n", - "Qg2BNvED57nbVy8b1Ju1hNnJycnlMyedDK9R9X52dmYVGkPN1VV1PN1jh1XhPK7aNxvCb3I9Q5Fh\n", - "xvmuIMbpVBDjOPaJ2l76lHPbth+LiD8dEZ/b9/2Pv4j78oj47yPiwxHx6Yj4c/u+/6663yk05ZAK\n", - "PHifS28azlH7RVlGm/tOS736r0ZrDis4VaqHlaaLi7j6aQPDhV8EoLFS5WP3TJVHhhX6DKe+CV2E\n", - "GT7bNWyGGT8/VRsDrFpHU+3CqVj2TxXmtNwe2ydbFV+Jg+6Y1zvxWZO+mmmoWUKlyFz8FPDKOoX2\n", - "4xHxtyLi70DcD0TEz+/7/t9s2/aXXxz/gLpZraEpOeq2vB7v5bQOtWq9iM+pTqnUxQRoeMwwUIBQ\n", - "jaNSngy0LE917MxBpNp4ylsp2mz8CbM0VIO5Z6hVgEeA7/s+nnI+efKkBQ+H2Vwc3qsGm/RX7qv0\n", - "qviVesQw5pGhOgFa1Q4qsGVZ7kSh7fv+C9u2fQ1F/5mI+I4X4Z+IiP85FoHWdVxWG05p8bmI+dqH\n", - "W5hWcW6tR8VXAHNAm6gvLr/yK1qnBHC/4mc36Kjt0aNHct0xwzyiY30h0DqFhjBQamPyUiC3qv75\n", - "3ApU8F5uO+wzBIp6joIOqjQnApQg4PQ5rmoHXA+HrJ+p/oF1fhdraG/t+/7ZF+HPRsRb7kIFtG79\n", - "x0nWbnSI6N8mVSNltU1UziFAw/J0G5qCNYYRBkpx8rECk8qb8n8VPjk5ufx+7/T0NC4uLi7Dz5+/\n", - "+z0cl0/VkRvh+Xlq4Nr3fQQyBbRuIHPmOm7ey9PxDCPUWC1xmfi4y4fqM9gGVVudCgknTFz7QZ+4\n", - "PfeXqd3opcC+7/u2bVYTqjW0fde/xum2vKfrRBF+4VXFVdNGNYpyGi6O89FVUlc2BbMVcE+2riHm\n", - "hvWBexWXQEuQJcyyXhFmakDKju/WY1Qe0Edpz58/H/2FAAKt+rMghJFq2+44BxlMM+Hl1g9dh17t\n", - "5Awx9qOCpCvHRKFVMyxXFic6Vu0QoH1227Y/su/7b2/b9pUR8Tl34ac+9anL8Jd92ZfFm2++GRHz\n", - "zodTDTdiKOMK4YbhwmjuWal8cFTjac5068riynEI1Nx5VW434jqgVQ2+q99cvEeAdW98Vzp0pt/9\n", - "sxFUea4zKhBw/SgF0vmhq5PKHNAVqFSeVFilP9m7gVHlj4+r7cmTJ5cfPXd2CNB+LiK+LyL+xov9\n", - "z7gLv+7rvu5aXI5SaJORudsynW56Va2N4TXVOokaiatOy6YqlMNKmbGvJtDCOD6fxwhpLpeCG/vB\n", - "df5M270By2Ouc3UPQm+l03dtpquHVQA4VeHaXKX4876qHbp8qPhpHKafexfOfddn+Xkrg+4HPvCB\n", - "+MAHPnCZxu/93u/ZPHefbfxUvPsC4Cu2bfvNiPirEfFfR8Tf37btL8SLzzaK+6/FserCUQTXFxzt\n", - "XZwCiTuerJm5hsSjuBqFGYYINgRH1UEq6POxaxh4Hcepa7A+lI/541XcqzgHtJtuq0BzqqHqaF39\n", - "uHh3rNodD57c9qo8YDusbMVXDpoYVj6sgKbSqZ4/EQSVdW85v9ec+ncmiavMsDOyUhhm3BDxbRbH\n", - "c2OcqLQKYApm3JhUOK/LfOY9XDZObwqflVFNpe2ey2B2jZWnnHwtx60AzSkzpdS4HJWpzsb5ZX9M\n", - "0698qvYVyBTUVsq5ku9Vm8yQVtbPqv5WiYmJ3epfCqgMZYdXSgBh5hzFU5TsNBH1t2V83L21VE7l\n", - "ylGdGCGO9/LbOqfuVsHlzrk64HPody4r14ObcmKYVc+h4HLTTVZoXaN36l6VAf3ojpUPea/C3YyA\n", - "w+55XLbqfOWnqi2r56zCrIMa5ktt6YPs21O7VaA5hcYwy3gOY+PH9ZNMA8MRawqtGhmV9FfSG+NV\n", - "RfM0MzdMcwXCHdwwnq1q9AwzLKcCkvKHCiug3VSdofLtysZlUHWEaXQgc8/qBhYeMFcG0cnzVf0p\n", - "0FY+Uu2cj93gwMd8zuUr217lt27AYrsXhRbRvzWJiLLRZ2GR4B2YGGZVHG6uUt3G5eU8Mtgy3uXH\n", - "5YvvO6QBpJ+5vrA+eLo3gRkq1inMeLRfWUOrVMwEZhjuoOVM1QXWabXUwfGdufzjsWonClgqHp/h\n", - "xIarL9cXMH8oStRxXvdS19BualVmKgemqYbstggNhclxp9I4b9VIxYZ5q6CHjdqN6FOorfrc3aeU\n", - "8gRmmO7q9LKaauaGflW+5ny4jubUA8c5n1bwmgBt5UVUdTzJG8a5+xFu1QzEDT5qwKjaPKszFV61\n", - "O1doaRPyukbuKv4QmLkGyKNHGisXVaFYdkyj6kyc/0eP9P/EnEANrZtCuPIqmE2Bhj5YVWfdVLR6\n", - "KTCBcuV/5d+JdQPlBGgMN8ynGlSV311/cG2Z0+jOK5Wr1HU1Y8HncPtVcat2bwoNM+vCDmQYznv2\n", - "/bD1qEPA5jq7Ug8OFuwLzof66wUHMDW6pamRFs+h39gY2uqzDQ7jcdZVN+1cVWuuwVdlmCjpQzqQ\n", - "qw+1bDBRZi4fqJ7Yz6ocrg1WVim/apCrgFblE8ukQJb1vWL3sobGGXf7fX/vz6RytO9G6ENAVm1o\n", - "VaVmPjk/+HazGr3USM7/kaiCmAI85jnDvGeVpsrKwJ7ALPOxqs5UZ1FLD/gM9jnnxymHDggdZPiZ\n", - "CmbdEkIFOFZpTj1VfcENzKy2lVXtVvWFiY+xHAgz9mPag19Dc4pChbPxpiJDZYaQS2gcCi0HB+Xo\n", - "Ls8dSFemHgi2lXxHxLXGNJk2KFXE26o5ECil6PJXdRIGqAKs6sBcJ9X/I+2mhxXAKrDxOUxLlYMH\n", - "HPavA1vlH1UvHbiqQWql7lResZxdXpXdKtDUH/BGeBDwMW4JswQYT2WY9BPwrB5zJ1Bl4s7Bv2jb\n", - "/ept12mmQGM1xR0b9/wv8fC/SCmgqZFUwb9TlWyV2uOyKFPxbn2T6wr/a9cK2BhEVZwDnAJbVb5D\n", - "wIbXq8EDfVQpZQe2VXhNbAJgtntZQ5t2So5DB/K6TFWxk70Lc547CdwBi+HG62TqVz7UdET5hztD\n", - "qlgFNVRhE5Ax0Nwzq3xVndVZpTT5OnXsplfoVwYaq+MJ0BhiLn6yn/iEfY3H3X1uuqj2nRpTAwYD\n", - "zcFtAqvV9vIgppwOZjiNZIAp5zpTTlmFHeZBNby8xv08t1Nq2GkU4FzH6YDB0h0bn/rXeAiySq2x\n", - "P7i+8dwk/1PjDjLZR1z/ljHrimGWezflnwCN20sFOwe03BR0nF+wDarzGL8CtcnG+VMQq+Jett0b\n", - "0CYNISuDQaIWkCNm37ZxXjhcqbMMZx6yfNv23sezago5mWJ2MFuBGjfi9ANDzf139kqhYV6yjpWv\n", - "OuCqOujqC887BcDhbsrpFFr1T11wU+2ja9cKbG6QcH7iczcZHCZTzSnYuI643jisynIT2D0IoFUd\n", - "E+FRSePV0VvBbBLGjoxpYoOcgEytma1Obyq/pV8qlTb5T+z8j4wzffyFVQYowmIKNrRuJHdTGt4i\n", - "rq6hcTvEOspf0nX1oerKDX5u7wYmFceKbBX8k2uVzw6BGfu3A1pn2GZXQB3xgICmKjWdjFBDgPHI\n", - "EnG9klwc5qc65vjMQz4Xj7dtG6+hrb5Vm/gL/YYwS1PqTMHM/Zf28/Pzyxc92FF52lPlk++tbFJ/\n", - "qj2oDuoUWvdSwClnBNqkLXWDEPop2xlCDdNSA8hkoFC+fBkgq+rG1enEDlFr9wK0idpAUCTUXEW4\n", - "SqquqSp+OipgniLiUrlM1Jlbr3Ewcz5zAwE3bvaHmmaqdTOGGvrIwaxTlSs+VlbVrTrGZQmsu9zw\n", - "Z8IrkHHcahm6Ns91hlBTKtB19km+nM8OWTtTCrjK323anX+2Me2UWGnTqYWqnOzcfK6zSqlVCrBb\n", - "P+MXAgpcLm6qbnMAYKWLMHv+/Pl4monxXI849XZ1rPI/8XVlbtBynXOi0FJxrwBtpSMrqLt2zyDD\n", - "/oCDlvOf82nVnyZraA58K3Cd9sFD7F6nnGpBVAEt9y4cEbIysOLxxcGqQ12DUfmZrp11n2c4dTZR\n", - "apVC42mnWz9jmOU+y87TbQWL6dpfZZ36Vh0R4xLeVR4ZaN3bZwU03qs4p1QrdZZ7hhf3j6kqY5+q\n", - "9egOaCr+EJv0w9XB7t6A5jopryVErL+e5w0bDMahVY5FQKgREu+dfKqB36AxtLq9g5oCGhv6ZAIv\n", - "95azGplvAi/l9+68mvq4doCGMEPgTYGWs49qoFVAQx9VYYYYhlUbxPSdr9QAt+LDKl6BlRXsav07\n", - "BVzZva+hVeGI2avfbIjZUV3nUcrFmasIBVq0So2p6YvzQQWwzMcEFGokdrBSDdeNoiovnGel0jrV\n", - "xs9w5anUmlp2UHnHukCgTaGm8qPiuP0otaXiUJ25MPuqavfKXxOfKkjjcycq0Z1T0FJCYWp3DrQJ\n", - "zFHsffIAACAASURBVBBoEdcLVsl6dR2CzKk/dqKrqKrTbdsmFZmC2sQHVYevKptHUP6QlqHmRlrV\n", - "4Z3aZPXiAO6OFcjZv1XHUnXvQMz5wI7r8qfyptqBGghdO1KDU5oCWPYJDDsYoB+wLVcwU8b55LxM\n", - "oLOiHF3c1O71pUDXsdEqYEVc/e1xhhw2Vp4qroDMjah47KaZ1YuADmbsP+UDhLaaFjiYKahhudJn\n", - "WZfd36OuQE1tE6hhnTk1wYbl4cV/vA/z4OpK1UsFMpUP14YyTgHMxXXG/aTzl1NhmTfMCwPzEHuZ\n", - "UHtwa2gOaGlVg+XzKPnR+ZXzVAU50KhGXn220XXeDm4TX+C0i2GllJlaNMdyp9/yOEGd26ScDmoO\n", - "cJNyV/ByHVZBDWEdEdfqxtUTm1KSfE7d7+rZKTSnjqbhbkrJ+XbTyfTdpC5U3ARgh0DtXqecFcxW\n", - "CuKcwRs+B8GlYMaViXmr9thR3d513BWlphRl7p06UzC7uLi4hCBPOTM/eDz5xRAFt6k6m8CM4dF1\n", - "qjT2czUldXXe1Qem485xXly6Dma8x/aqBmQ1vVTTTuczFdcBkUE4UXA3mWqmPZgp5yGNBk1J6dz4\n", - "TWfVUSZTFqe0JirEvQzoNmeqEXWv3hluTs1gp8njyZTT+WIKNyyzAkMFMRfPKqmaPUw3Nc1U9TJN\n", - "G2cmE4i58ipQderM5ZvLxgN99WzcK8hOB6wVexBTTne8YmrURsnOYMvr0tGqonCvgLaqQCaKpAPa\n", - "ZGrRAYzj8H4FNYzHKWe1fqbW0Sq4VQOagxrXt4MblqdqW+7ZlYJS/lfnq+eo9DuIdWtoyj/qU4tO\n", - "4WIf4Dh8jtp3ImEKtRW79882XEOeAg0bXjoxK1+BjDsJg8vFKZipRfBKueExj8iTRt6NhEqhVWto\n", - "+G1Z5Vc094azUmlq6/ylAMI2gRiWp2pfGMdlV+2GO6rrmCoPKk+sTCOuQ43jGHDqmVNlVpkqs2uT\n", - "DDKGmlJgLxNq9/6nTw5mXJhJ4fKNFQONGwan5RRalWelRtwnGW5/qCJw0w0cifmFQPWWUz2f85LH\n", - "k09SlHKtVJpTrc7UNGc6dUr/4+I6xqGfqzAfd4BwIHObA5gK80e4K1Dr1JmLY7Cp5yDUKnuZUHtQ\n", - "f/qkRipXINW4El4INvUxYl6rGqRqEB3I8AcCu/KpeHwG+2jSabghdd+h8VblhwHdqbPu041DpuFc\n", - "zkOPsd0kFLDTTWcFqj4mHW8ygGUeKoBxOI1nIqzg+MWP8leXfw4j4KYqUIFKAfIQexBTzgoA6n51\n", - "jA0zGyduatpZORbTzLCCGq4nMdC6DdPtwpw314AqmLmPbNFf6RMsK5d7+mGtm2ZWoHM+Yus6pgMZ\n", - "txX2pWsL6nh6Dp/vQMYbK7QMK7C5vuLKWMGn85uLi+hfzHHeXJ4ng7ize59yVoBzjuNjHHUnWyWN\n", - "VQVP14ROT0+vlRGPJ+fc9Q5m2YhwBK5eAPDGv3HGQN+22c+Kr6gzrPNDppu8nyoOBTW+rkrfpVuZ\n", - "A0LXDxzI8JjzjQMSP9uVL/2Ae84r5tmdw7S4bWa6Cniu7/GgM7UHo9C66UbeWx1PJS8qnq6DRMQ1\n", - "JaLWyyKu/kGxe26lALFBYaVivrpPMp4/f/dngc7Ozq5sGad+8wzzo/JYwUxNww+ZTlbm6tHBbKo4\n", - "VBx3KJeHlTaGxysDGOeVB2P+yBah1u0RMAy1vK7Lo/Mdw6yK67ZVuzeFNoWaul8Zkx6Nj3HtwTVa\n", - "DFeqQ8ER03AQZpC5sBr1uulkB7Ozs7Mrv7bB9YJ5RSW18v0Z+mkKspUGfAjMuB6cgnGdyXW4Cdj4\n", - "mcofDhTOuB2rwRnPMRCxbeELBjzPeXXH+RwHrQnM3DUrdu9TzgpseI8zVEfZiboG7V5xpykAVmrD\n", - "3VdZBzIMMzR5GsnHDDRWZvwTQelznspgfUymnM5P3RpZlm2q2NAXHWSUQsI64D1O4fFZ7vl43g1G\n", - "nSJzcWg8sPGm4MaqjPOn4ObagAOxU2gTkPG5Bw+06ZTTHat7K0uAOqAh/JRV6q9Tkez8SQfFezuo\n", - "YaWrb8oQUApi1cZA4zxOp5RuSl6ptM5H3aDjIIZxTiU7dZT38pQMn90NmvgspXYw7PLBafCxg3gF\n", - "Nwd8Fa7yV/WBVTXWhVfswUw51XFnarTd96t/bMzX5CjcpcPH3cgecf21+dSUElOwQ/XAMEPlpRRa\n", - "pdYSRvxa3yk0p9YqJctwU75GY2XFDbvrkOqeqdpwnz+o56rnqPqtwKXyg/eqwY2hpnzAIMMwplv5\n", - "zQGsAtpkw7as9u87oDHEDgEaG8PMPZc/oHSNyz2jC6tnV3nOa1YVWoKNFVcHMd4YZvhst+hfvRjo\n", - "XgR0wGegs08yvlIpqixcJ5M1W1Qqqt6c4fU8QFRQVfdz+XEAdGWfgIzLwWFVZ5XaPhRoCmr8FxJT\n", - "e1C/tjFpYM7ctcr57k+h3Eg5qaC8TlkHuwnUMh2ebrIyOz8/j2fPno3fcPJaHD8T66b6NEOBbTq6\n", - "c+fH8jqfHFoXVSfF9upAhmmrZ6jrJxCbtnsGvYOYO1f5huOnQOM3rVOgMcDU8aqwuReF1ikzBZTO\n", - "1Ii2bduVf+yRmxt9+DoEYOV87kxsruF38HJAVVCr1BlDjeGW/yAEy4W+cAqtevur6nFloEKYsapg\n", - "v1Z79CO3jSybA5qCGqeNdcb1hufcwKnisNycb36GArkCHN7T+R/PTwUIP7sbeNTnRip+0vfRHsQa\n", - "WuWkiSmgcANBVYYNtXrLilDkzyMyXjV2lT/2gVIfeK0CnoIZAq0CWfem0zUg7PQVxNwnLarzYr04\n", - "f7GPGGorakCBTdV5Ao0VPOeT01Rgc8du4OQ41V44XXx+BTFWbi5/HFf1T46r6kSdm3xPmduKPcj/\n", - "KeDeckb0n2K4joN/hJ0VP6msvDcXz/O7rcwLdpTsCFhu1Rhd4+TzbuTj9bMJ1Lp/IKx+F407ewcx\n", - "3juYcbgyBQ3uKNUezUEMyxdx9ct8lXflJ2cK4A70lX/UwOnaB0MNwabSc+FJH8F67pRZxk9Bln1u\n", - "xR60QuPOj9aNNmrUS6gx0Fw47zs/P78GWW7wWGn8BTfmaarI+Bw+kzc35axeBKi1M6Vy3RtOBzme\n", - "crr6UfE4OCi/4HXdxnXCz1RwU/Fs6jmuPCq+g5l7bvWMiSJS/cUNOLl38HIDf5eHjFPgUnHbdv2L\n", - "hM5uFWioZtKmDUlVWnW8ImGnQMtwp2z4lyvy7QwuxHLnVmV1fsjzJycn8fjxYwuf3PgPx/MP6B8/\n", - "fhyPHz+O1157Lc7OzuLZs2dxcXERr7/+erzxxhvxxhtvxOuvvx6vv/56vPbaa1f+fyiCRXUWVMis\n", - "lic2VSfccTgPyjeYv2wDbgBz3/apMOZtUpcM/GyHXM6M64CD+xxUHCTyeBWsXdvE+zug4oCvwIXH\n", - "GLditwo0/DtBtGmHjph9JsFTsU7WZkNiNaGOs5G7f8bL61BpKPuxLBN4OcirDsvpoZpKkJ2dncXj\n", - "x4/j7OzsEmao4hJguE/4JdDY1+hzhMxqA+R2MQ1PVBp2IARy1XF5fbLaVD1WdcsqNv+qJTc8drBx\n", - "7YVfUqm+wOWfgMzVj4qb1knm18GMwbZi96LQuj0XQoHMAY1hpuAWESXM+Fw1WvOfHylpj41UNZ7p\n", - "9Pv09FQCDfOPbyNRmakXBPk3nanaUME9fvz48n61pqnU2cTUNI39xeEKaFUYn+cGQ47jlz/VPvOz\n", - "Ah2conNeXHldu0Dl3KnVrg06wCkfVn1wuk1g9uAUWgW0KozHK87sRinsfB3IGGjqZ3cU1DDvWSmq\n", - "bK5xVntu/Hye1dn5+Xk8fvz4yvqaWkvDf0uHEFRTTuwYqhNhnaAqQuM4pTZd++B20bUNbB+TTu8W\n", - "p1U812UHtFRguLas6lT5A+uY223XN9jHEwA7UE6gOblPwYynm/wVwcTuZcq5YgpcGM8jswKYA5rb\n", - "8qPQ3E+nIDwN4YpEc1Bz63ichlNmZ2dncXJyIv8kisPn5+eXqqH6syb1QgT9jj5162dOISmFguEK\n", - "cnx/9bzVNVZ3jOEpzFChcZtQv3KcdeLaCrdVZQ4EK3muxIESC1PIqTU0N9188AqNrRvBHbhUnHKq\n", - "CkdcBxqubzx/fvW/7bjpZaXQsAGiVQ2+2rhi1X0JIFaP3XS5mnojcNPXqCIYbAo8E+WA5Zrs1T3O\n", - "Mm+TOuzakGpHEzioX4HJjpzhrGen0lRd8/OxbUyVWAU093JBqdYJ1LBP5XPcdPOlK7Rt234sIv50\n", - "RHxu3/c//iLur0fEvx8Rv/Pisr+y7/s/VPcrhdbByu27uKkcTjDwAm06Wik11xkwPsMRV79Hy3SF\n", - "b0cgU7+9hvclkFKVnZ6elgpSlQXzk2EVxzDD+kDFgmms1KnLQ7WvwpjHLLdSqXisVLXrnGpQcnBA\n", - "CKo8JxR4aQH9ks9wCprzUK3HurxivIO+a1dd/8PyVQC7TYX24xHxtyLi72D7iIgf3Pf9B7vEnUJz\n", - "DWZ6rrpuskW8C1ulyhAkOJqo0UntsxKy4vi5EX6hV0Esw9iB1EitgOVGVT6X/uN9FZeG8Oa4Sf1h\n", - "+h1QJ+fQT5gfBBr/GRiGu8GVwwoMCh6uY+J5hhqDXq2TVj/npLYunwxh9Vafw5j/Cmo4Rc30Hcxu\n", - "RaHt+/4L27Z9jaqHSeJOoa1ufF933MVn5SHUEGgIM6wsBQkVxnsqdcYNyamzXCdBeGA+XV5Wtmxo\n", - "1bHq3Gmo0HDKMq0/9k2GVRyH8XlKrbFCS4jlH/E/e/bsMuzKp8zBQIGC17rwHLYZNwCqtsFQm/6d\n", - "7VTNqQEAjzO9BBxDjMMJard+dhcKzdlf2rbt34uIX42I/2zf999VFymF1knSVbh1HUadi3hvyplQ\n", - "U3DD4woUeA6nD65x5r6DGQMNOy5+RFkBivcqbvKiA5UcggLrFTsx1/dk8OnAhWG3Kdv3q/84BiH2\n", - "9OnTK3s0BqsKd1DIPU/tWXVx3VXthT/LYbjxhvEqbyouQZXwz09/clPLIEqJObihEnP7l67QjP1w\n", - "RPwXL8L/ZUT8zYj4C+rCCdC6fdcRlHJwcbnPUYAB9vz580tQoEpbUTpqpFVQU42aQYbHWclTn3WD\n", - "A553n3Scn59fNqi8Phsu1ykqpApoVf0dAjPulOhjzANPORNiT58+jSdPnlyGq2dO8zAFmhrEqvbi\n", - "FBr/K8XqGEHU7bNdpHrltok+xnav2iHu0SedSrt1hbbv++fA0T8SEf+ju/YXf/EXL8Mf/vCH48Mf\n", - "/vBlobADqA6S+5UO0e0naeMIgfe4BobH27ZdGRmx4XE8TwPcdJMbjwM05hv96pQwrtOoZ+OUGztb\n", - "lhd9gaZG1Gn94f1ZBva5Akm1j4jS1wwkfJZ6Lse5Z3McT/fUtuI3N5gqnzrf5jU4EGe8GshdnXGe\n", - "c+9mBm5G4dL+5Cc/GZ/85Cfl89iWgbZt21fu+/5bLw6/OyI+4a792Mc+di2OiYtrLzjCO4dF+IrG\n", - "810Yjx3Uqg6Hyi7zzQDjKYFb25gs7PIzca/OcX6xvAzHjMsy4JS7a8CVVc/Dazi+6vQOIi4uIuSA\n", - "otaW1ADVqbNDoFYBzvnRgSyVzGQmgX7Gfsd9LwfG6odAHYhUHiuQdWDb9z0+8pGPxEc+8pHLvH/8\n", - "4x+3ba77bOOnIuI7IuIrtm37zYj4axHxndu2fVO8+7bzUxHxF939OAWobBVkGHYqje9zxy7NKdQw\n", - "vX3fr0l8XsNw/99TyXlu9ApmHdSUmnKjN96foEZlVvl0JY793pmDh1NADKj8qwmnlqffdPG5DmC4\n", - "V/XroKn81MGsAhu36U6NZlh9t6jS5XxWAMNPPBz0bjKIdm85v1dE/9g0cfcVM6R/WQkINXVdBTIe\n", - "farnRVxdwOzSZVOAQOP1i27Btpt6ThSaAhjvcZqh9tgh9/3qb2phPfLAgXsckNjXVZ2wkkP/VjDr\n", - "1I9TaJVSVs+tADdVZ6qO8Rouv2vjGXYwY7DxvVw3rk0j0BJqCkiqDzGg3Me46nruz6tQu/MfeETL\n", - "AnWjFF6P9ymnHmIKZpUyw7JxY2CYOZA5oKm1s3xWBTO3R58qmKFxR536C+P4One/2yuoYd468Cto\n", - "OHWm1jUnEFNAm8DN1a9TSexvhMG2bRJsTqG5fuL6WkSMFZrqj0qZuY9wVV++FYV2U3MKTYGJK3Zy\n", - "T6Wk0Ko0qw1Vj1I+qvErhTZVZy6M6acfcP0OjxlmnF8FM9VJ1WjOynbiNwfPbgReAQpv7LsOYhjX\n", - "PQ/zdZMpZzXtdH7iqWYHM7wnw6ou+FlpCSAHNTWgMcwmf1Xg0jkEaneu0BzEOpDxvWpTaajOy9e7\n", - "TokdO+/NvWrE2XDdtPOQt51uyhlx9WfHHcz42DVoVmYOeGqqwIMK+nXSgSq4TQBWDQgMNAYY36Oe\n", - "WcF1OuV0002l0tA/ql0izBJkWc8MNoZapY55n+mp/z2xAjUFNn6Wev77RqFF+DeLqnJXaI73YWfi\n", - "Tob3s/JAmGVYNWjVQPn7H/fGcwoyBBqrsCyDO5fx1YDBZVKQ5nie9mAe0NcVzLhusU5c3ipAuLeX\n", - "lUJTYJuoQuenCm7qhY8DpvMR95EEA/vCQcf1HTzm560oLB7oFMzyF164nlm4qPDE7k2hITAmSk2l\n", - "g5VWWXasSgUi1DD9zKdSLKpDqU81JiptMhVhFYbqyyk0BrzaWC0zLJ3aS7+zauxUmTrn1BnnW0FN\n", - "wWwVaJXvHXg6VcZ792JgotDQr7g2GvGucGCIdVCbbNWCPqbLeVUwY7Ddlt25QkOgufUeZ10FKHBh\n", - "HCsB7Hi8VwvrmCZ3KFZi6vONCczUlMQptAnMXIfk8qQ/EuDsIwU+TG/1uU41YJ5yr1RRpdAYcOpb\n", - "QHX/yhraRJVVitJBcgI1rjucdjLcGDBOTamw25RKy7xW9yigqfJUx53duUI7OTm5BFrVAdGcVFad\n", - "Ig1hpUCXafG1mI5SaNyYp0qsAxo3fAU0zBOrIjUVdT51UOO6Q5+goua/seMpwkojxMFI5YkhVoHN\n", - "vXCZ1s1UoSmgdXCrBrCufhhAbAiy/JO+SqHhlJBhx3HqeKL6HMxyPU5BnPsp9sup3SrQlLmpBVfo\n", - "ZLRX8HMNw3WyaefjZ7qONAHXStlU+RR8GfgqzNdWvsjnoDqrppEYTgBiXPqM78s4BsDKVpka8Co4\n", - "VecrU+d5RsD5QcWFz8ABfzLYcdlYram6c0qsiqsU3bQtsvrn8MSvld0q0NRocshUIysNw6hE8LxK\n", - "w6WrIIqmIKaUgYIaN76VzlGZ8t2kcU6VLZY7w5W6dR1Fpel8jP6t1rTwepUPB4nJGlLlb/aL6rxK\n", - "MWeY2yD7Kmctz58/v6YUKwWYYVzLQj9yvGt36Ifpx68OZNVgWdWli8P2V4Ev7VaBpgqHTmGrRmEF\n", - "NRxVseK6fTX6dnEdyKqFX8zHy7AKZpM1E9UA1ajpAOL2FSDwOayMcJrYrTepZzLUcK/UxiSf7O/M\n", - "O3ayNAUyhA6mwfnGJZgVpYqqlweF09PTK33t0aNHcrlAtSH1+2Yr7Qjr2MVVEOPzuK/szhXaiiMQ\n", - "XBXIJg5wcZ1yqq4/BGw3tUnjqhZ0p8qka0SHAM11Suxw03Um9gf7JtseAk3BzAE9zzHgGWps+KKG\n", - "4zjfCS81nUR/VWF8joJZpdIqmCXQpltlrp9NgbZi96LQOpA5ZaZA5hSaC3fOco7vVJqaLlUj7SGm\n", - "RvfJm6yq8TllW4UVEDqgJViUPx3QOnXC5UCQoU2BXsE78+lApp7JbQZVGqaFqgwHvkld4H34lp2h\n", - "xH5XvlODoRos+HhlkOyUmAqv2L2toXEYTQEkr+c4TBfv5/Sq9CcKDZ+LUKs+F+imTIdapdJW30Y5\n", - "cw0un4954b0CBXZw7uwINPQt+rvyHfoAwZHW+aLz9SrMVBrpB04P83xIG8nrs/3lP4vOD1jRF91A\n", - "wCqNp8mqjp1oUXlUxxPIrdi9TznZKtgoiCknqDSnz1DwUflw083VKdOqVaOkA1kHtYl/0I9Vw3Yq\n", - "kEGGCjvbSbcY7jokgib3WeZ8brV+NoUUg0nlw20K4u6ceqYCSKaByuy111678qdKrNA4bdV+1L1V\n", - "HjAtNgWy9y3QHL3dKF5BpANc58ybmHv2BGgdLKemOpACmVJrDmqY7grgV4CWHZahlnsEqoLXxHf4\n", - "PAWHyRu6ie+5/Hhe1SdDTvmZ4/j+agDLe/G/3eN/sXJraNVz+KWA8rHyTefLapBUEHuQQJu+FFBw\n", - "YzXW2epUYNph2MmT9TO8jjvpTaxSWdwgJ8pMjfbKP7xYvTJSI8gYaqwQD4W/GzgRaBOoZZ5WnuOu\n", - "y3xjOJ8x2Vd1h+cSaI8fP47XXnstnj17Fq+//vq1v7vsYOZeCjhzdeKEhYO3g9j7BmhcIWzVaPay\n", - "1I5KeyUf1TpaNVV6GVBLcyCrppuukziQqbJ2EFNAy2dkHhBm+371O8JJA8f8Ytp4jHFOwSpTHX6l\n", - "ThTIlI+75yq1rfYRcQmz119//VKdIczwGei/SRty+VSqdUWl4bEKc9zU7n3KqUbICmhOufGzJs7l\n", - "Y+VAfjZ3cJ52OiC8LKgpeChoMbzU2iVDQJWZy9pBzAGNweZUEtaNgkAFM47PsAI95035eVoXCoL4\n", - "fJXHLl0FF/XCZ9u2S5jlf2dyUKtUFabPCg1936WF1gmQDmIPDmjVW84J0dPQEZNRw8VV6VYd+ibb\n", - "TYw7jOqILs75Wd3n8qlebkyApsqg1MCqL1R+lX+4nbj1xQ6sqxDCAZkH5i5driMFL/Umctu2K/+C\n", - "sPoRRsyLalO5xzpyZVLl7toe2m3ALOKeFdq08NNOWj3TGYOMFVW1uO+eM60I1ThUA6s6n7uneiaf\n", - "XwE0rqN1Pt+2q/9LtLp2BR6ZZ9y7uIiwCgc7vpqiVc9VxmrMwYPvUXHVP7ZmoCmIKTXaPbcqa3V/\n", - "1nOnhKfPuok9OKBNIafSqp7Jxg5UHZenW0oycz7U81RlVfIfO4UaOR3UDzGnTHktMDf1PPfshNjz\n", - "59f/76Ma1dkPbJXScKM8qg0HBfy9rso/mIdVlViVheM4vwpu+J3Y5AcYq+d2ZZ7k261Tdn1z9fmd\n", - "PYgPazuArYJv2jkc1Nybyu57KDdC87OcbFf57Xx1iLpRxkBwvsi88BtPlXe0hFlurgyu7Byn8ovH\n", - "eM10+pZAc3U17eirMFPHDDF3XJXvZbWRSX4RYh3MVoC1CrcH8VJAAYnP87Vdp55WQoR/+aDeXLqp\n", - "JueDwaYAWuWPR3zXUA8x1+EmUOO8Vulw+Sb+wzRdHOZR5fcQoOWmfIE+c4MUl8fZZOBFxaOmxU6h\n", - "VSqpy5cqtxMKrp4cSKvnHjJ4VHbnCi3CQ0qdw3sqWwWaMgW06Z8wuU7pKsZ1bs5vdhzXQA5Va0pJ\n", - "sg+UPzBvHO7KoZ5XDU4ursqnUmpOjamN7+X0GGQrg4rzm2qr6qevK6BVCm01ny7vXZ+t1OFNnz+1\n", - "e1FouZ+OyJNNPc81GuzMqoO49TP1gayCS4Yno7lbo1F+qxrVIcZQcxDj9bTumVju3CqFy9dO6roC\n", - "GqpJTHuq0JTywzJwvlVZqrgunHllqHUKrfsXcZVV6qgbaNi/Ge76Z/fsQ1TavSm0lb26fwK1ahR0\n", - "NlFoXX5YUU0rBu9dLfPLGgE7hZYL/FPjBu/UmeuIrnOoAQiP8Vnc0SrF1k1juWzu2J2bgs3BjPcR\n", - "vUKr8rlqVV2twOzQKWVnd67QML6q5Go0wGunQFPn3Gjf/YF5N+WsIDZRKgy1QwC+apynaso5TWPf\n", - "r/93r7yuKpvqGNxJsD7SZxnH57uXARjulF9V/64+pnHojxWgqZcG6DN+RlV/KtzV02RQWrGbqLR7\n", - "m3JOwgpIFdgOeQYaj/bupQB3TFeJXcVyx8b0lN8mUDvEKlXCU/CVNBMsCbOJwlUd0o38OAXGPZcH\n", - "061gxvlU01dlboDu9i6O88T/Bs4pNPfz2Tcd9DCPbtCpYDaB28tSbPcy5Yyo1RMeVwBznXoFYmkT\n", - "hXbI284Vy3sU2KpG05VtYg5q6rONSVoIkmrKXsFMTRMZaAwzLAuqw4lKQ4XG+a3gxvWgAFZBTLVt\n", - "BzEHNPXXAVOYcN0pY5C5wYfr9JBndecqu5cppzs3gZwDm7pnWoHVmlE31eR8uMa9kie8plJtXI5D\n", - "TMl71YkrP7EppcPG/lIdxa175f34bHxGqsKMr6awnHaWCdcKVZtS6nxyjGlUQOsgjL5gkCmoOVP1\n", - "g/WG5eU4Lg+nkeewPXHb5raG97q2U9m9/hu7yjGT0aXqMHnexXf/6JennsrhkzxnA8vKzGPMP6bp\n", - "AFM1PBWn1jfQVgFZjdxO9Uw/PcC3c5XKcIadhtUbl1cpqK5TsQ86FcPHHdBW88ftgdtBNYCw8QCO\n", - "/9Mz4r3BgWGv1JkDtdq7/Hbl6OzeFVpV0YcsMk6ozr+Q4X6YsVJoburExwpifG3GuY6lRjZVbj7G\n", - "BoeqRXV4lU4HUFXGDlpqradaN1Mdhf2u1ACWsbpf2QRmzn/KLy4P08Hd5c2BrjLVjhhq2TfyegZZ\n", - "hif15KB2W3bnCi1ibfGU6c9pRNRqwnXK7ueyK5BVjcY1ZqWU3JTJjcRsDmwJM/RTjrB5DXb4qjyd\n", - "GsFyMdQm31GptZ8pzDg/CmBqAFkpJ567KdS4HK5NTwaabnP5cWkwzNTgp0Cm+udqeHI8tXubcqpK\n", - "5rgVdTYdVSOu/ruvQ6CmynTIhus0Kq9qIX2iztBwqoDHVWfslJkre7fgXqmzQxazGcpq7/LqoFHB\n", - "i/fqOVUbzjjOE4e7/CkYVe2kgoMCWvYPBTJ80eL8OYVV1/+7vCu7N4XWQcwds2GDckqKw1xx/HnG\n", - "5Bu0Q+DG61jZOBxAMC+q3CrO5QtBpqxSuSpOla1bQ+v2Vf1zfOV/hk0FxcoXbu9s2qbVPeq4gxoO\n", - "hittk9PClyAKaAgyVe9dmVw+qnperbO0e1tDy/PTglUVzeBSx7x1Cq16s1eVJc+rineNAhuNgsxm\n", - "mgAABi5JREFUmwZwWfG462iZH1UWbuCTtLm+1HRzFWrVwnI3+vOg5tKYdJAJzFilKZt2UBenAIig\n", - "rtp8lR9VBoZarp+pAeEm5VL5UUpPDW5Tu5cppxt1p5uzCmAOFNU/B3bfnrnG48qEMGOV5pRQ9/3X\n", - "ikLDEdbde0i6mfahUFNTzkwT9xxWecCBBMPqWlfuycDQwczVf5f/Lo8IM86HG2y78qh+gfnnwcH1\n", - "V8zzxIcR9f9MwCnugweaMgUtXJSsYNZN19TxZA1tRaFxJ0LVgBXOYONrVP55xFTl72CDU9tOaVaG\n", - "97g6U+tnk7ed6scVJx0dzymQKR9zOg4EE7VW5Wc6EKs8VflksHXt1OVDwcw9zw02Kk1lKj/uLTf2\n", - "DRYAnT0IheakpnJaN8IqeCnFM/kOzX2LpoDAo1rVANz0U5VFKTQHJIzntFdANr3Wwaz7ut2Fb2qq\n", - "Q7p2VJU7w9M9PqfaVsrQ5TNNzSBUei5NhFm2M9d2u3OcN3esYIZtIctySJt4MGtoVSNweyXDHdTU\n", - "92WVSlMgWymz26OkzvTRsCwMY2WuEbsBY1WlVaN+7vmTiwpaVdiVR8VPVEHVmSfAWFFoTmGtAq3K\n", - "WzWIcR/o0lR9hc/f1H9V2A1y27Zd+5GAFXswbzlV58PrVRhNqRqGmXq7qdQap7HaYLAxMMgw7Bq7\n", - "K0ueq8rPPu5Attpgqmeswow39BvnUcVjPipbVT0qXu1deq59r5hTm5wHtbnyTNraar44LX628xu+\n", - "hMAfBkCoHWJr/578aEc72tEesN050D7zmc/c9SPvzH7913/9vrNwq/Zrv/Zr952FW7Xf//3fv+8s\n", - "3Kr98i//8n1n4dbtCLSXaL/xG79x31m4VXvVgfaFL3zhvrNwq/Yrv/IrN05jZYlidTnjZdhxynm0\n", - "ox1tbC/j5cZt2hFoRzva0V4Z226Lotu23T2ej3a0o/2BsH3f5Xz21oB2tKMd7Wh3bccp59GOdrRX\n", - "xo5AO9rRjvbK2J0Bbdu279q27Z9v2/Z/b9v2l+/quXdl27Z9etu2f7pt269t2/a+/+Bn27Yf27bt\n", - "s9u2fQLivnzbtp/ftu03tm37R9u2fdl95vEmZsr317dt+8yLOvy1bdu+6z7zeKht2/bV27b9k23b\n", - "/s9t2/6Pbdv+4xfxr0z9ObsToG3bdhIRfzsivisivjEivnfbtj92F8++Q9sj4jv3ff/mfd+//b4z\n", - "8xLsx+Pd+kL7gYj4+X3f//WI+PiL4/erqfLtEfGDL+rwm/d9/4f3kK+XYWcR8Z/u+/5vRMS/GRH/\n", - "4Yv+9irVn7S7UmjfHhH/Yt/3T+/7fhYRfy8i/uwdPfsu7e6/JLwl2/f9FyLi8xT9ZyLiJ16EfyIi\n", - "/t07zdRLNFO+iFegDvd9/+193/+3F+EvRMQ/i4gPxStUf87uCmgfiojfhOPPvIh7lWyPiH+8bduv\n", - "btv2H9x3Zm7J3tr3/bMvwp+NiLfuMzO3ZH9p27b/fdu2H30VpmTbtn1NRHxzRPyv8Qeg/u4KaH8Q\n", - "vg35E/u+f3NE/Kl4V+L/2/edodu0/d3vfV61ev3hiPhIRHxTRPxWRPzN+83OzWzbtn8lIv6HiPhP\n", - "9n2/8oeqr2j93RnQ/mVEfDUcf3W8q9JeGdv3/bde7H8nIn463p1mv2r22W3b/khExLZtXxkRn7vn\n", - "/LxU2/f9c/sLi4gfifdxHW7b9jjehdlP7vv+My+iX+n6i7g7oP1qRPzRbdu+Ztu21yLiz0fEz93R\n", - "s2/dtm37Q9u2ffBF+A9HxJ+MiE/Ud70v7eci4vtehL8vIn6muPZ9Zy86edp3x/u0Drd3/yr8RyPi\n", - "/9r3/Yfg1CtdfxF3+JcC27b9qYj4oYg4iYgf3ff9v7qTB9+Bbdv2kXhXlUW8+6OZf/f9Xr5t234q\n", - "Ir4jIr4i3l1v+asR8bMR8fcj4l+LiE9HxJ/b9/137yuPNzFRvr8WEd8Z704394j4VET8RVhzet/Y\n", - "tm3/VkT8LxHxT+O9aeVfiYhfjlek/pwd//TpaEc72itjx78UONrRjvbK2BFoRzva0V4ZOwLtaEc7\n", - "2itjR6Ad7WhHe2XsCLSjHe1or4wdgXa0ox3tlbEj0I52tKO9MnYE2tGOdrRXxv5/B3a4grwG0zQA\n", - "AAAASUVORK5CYII=\n" + "AAALEgAACxIB0t1+/AAAIABJREFUeJztvV+obt113jfWOfvYcmSLEtvfJ/FZqnSR4siWsS8sG9Ii\n", + "XZSgEEiam8QCU18kJZg2LaUXcS6cpO1Fm4KMIYFQ6j84dew0UOy6hqRxikuNLxwLkkpuJepgCUup\n", + "8snQmqb6952zz+rFd8b5nv3s5xljzPfde7/7HL8DFnOuudaaa84xx/yNMdda797bvu9xlrOc5Swv\n", + "gzw4dQPOcpaznOWm5Ay0s5zlLC+NnIF2lrOc5aWRM9DOcpazvDRyBtpZznKWl0bOQDvLWc7y0sjF\n", + "bVW8bdv5e5CznOUstyL7vm+q/GCgbdv2kYj48Yh4GBE/se/73+BzfviHf/jadR//+Mfj+7//++Ph\n", + "w4fx4MGD5xvvP3jwIPZ9j6dPnz7fLi8vy/19369trnzbtufbs/7IsocPH8Y73vGO+KZv+qZ4xzve\n", + "cS2P28c+9rH40R/90Xjy5Ek8efIkLi8vn+fV9vjx43jjjTfijTfesPncf/z4saxX3ePp06dyzNw3\n", + "h5eXl891qdLMf+pTn4pv//Zvj4cPHz7fcuxUnnWJqSqrUszv+y77rvTy9OnTeNvb3hbf8A3fcCXN\n", + "Dfd/+Zd/OX7gB37gSv9U37iP2Ncun7ZdlUVEaTPYv8ePH8dXv/rV0fbrv/7r8b3f+73ynpzPfaV/\n", + "tY/zLeccpi4/SVl+9md/VtpxxIFLzm3bHkbE34qIj0TE+yPio9u2/dFD6jrLWc5ylpuSQ5+hfTAi\n", + "/vm+75/d9/1xRPy9iPjTN9es0wtGEqe4/ixvyn3R4221477072WRQ4H2WkR8DvY//6ysv/C10Wkn\n", + "l0N+EvbhD3/4qOvvu3zzN3/znd/zLvX4/ve//87bcZf9e9e73nVn9zqVHPoMbTQKv/mbv/k8/9pr\n", + "r8Vrr70W3/Zt32bX46rMHVPb88aBkeT6Xh3LfOclndHxc7kPfehDcXl5+fx89exudcN6qj5gf524\n", + "Y/m8EuvjNCLiW7/1W+WzTrdVz9CqZ2qT49wv3B48eBBPnz59/jxKPetS+9/5nd8p78E65vF5+vSp\n", + "fa7EeXyGi2m2N4/nczLe8PkxP0PG58VKRxlMTOwd5wbPE3WMr7sJ28/t9ddfj9dff71sc8qhQPsX\n", + "EfFu2H93vBmlXZHv+77vu3ahMyYFNr5m8iAfjYSFJ2llvG7QHWxue8N7YTtZt1Xbqz7nZEoIOLBV\n", + "LwEQdg8fPjzohUDXVjxWbQm16kE8nqvsUekJ9YEgUxDDLYGVKeY5jYhrLzgc3BBq2Sa2G6VTp3c1\n", + "f6p9zN+W7b/yyivxyiuvPL//Jz/5SWsXhwLt4xHxR7Zte29E/F8R8eci4qN8Ug4OSgWzLmKbXMOe\n", + "byI8WJPzOqix53RvWw8F20S4L25f1esmA4KLAcZl0+isixi6PlYgw3Z3byUrO0S9KFgwyLBtESHB\n", + "5aAWEVdApsCm3vJPYaYk26/yeW0HtdsC24ocBLR9359s2/YfRMT/FG9+tvGT+75/is9TCpzArIvC\n", + "VDmf76CmlDSBmIuSjtk6yLn7c9u4LyoSqvIclSnJ8xlcKkKbfLahUjVWbr+yE1y6Zf8QampZrJbJ\n", + "fG9nA5O+uWgMoYqfKyXIXHTmlqLOjjpQc18UyKpjkzlxqFNfkYO/Q9v3/R9ExD+ozlGKW424Vq5n\n", + "L8mTf1U5lRwCtUnE1tXJ969kNTJygESZRmjVktOl3D+eMOq8vN5tCl6TY84OcSzZzpzDyP1uqYlL\n", + "TvzWDCM1BTG35HRtqco7qPE+j9HUllfgtiK39kuBiHWguTpWtk4BEyVVHozTQ8B2qJdaGWQXHVVQ\n", + "q+plCLhnZ8e8FMA+ooNSoKsAxrrrXlrgtZU9Th2Ls3sXlXEacX3JqZabCmwVDCbzDfuEYJtAberU\n", + "V8G2IrcKNPcMzcFsUrayHSqsRGXANwWqm/JUCh6qvAKdGi8Wt7xU0Zq6N98XU+6vgpnqM8MM9zGS\n", + "cstMBTjWI7aBHdtUJtFZPkNzMOuWnO7r+tU5oeBVBQydAz7WmU/lXkVoCkbHgEwNovNcnVSR0k0N\n", + "nKq3q1/pFyd15xyUdBHQBGZuyelg5vrpxqKzkYTb5HkZX+fsBvWrjnGer5vALO/LwJq8FJjYSGXr\n", + "DDHVb+w/5vleq0582v5O7hxo7vW4846ovCnM3KBVE6S6rqrjNmBWwW3aJ5aJA6jqZBhUMJsuOTHv\n", + "DF+1qwI0w4yhVi01uyWn0o1yPiqN8BEatyEiSpgpqCEUqiiNdY/9YOeCY4N5B7W87i7s3slJIrTq\n", + "IWyew/kVsLl7R1z3JDyIU6jd9DZ94znxWl2ExbrCpWZGElxXljmAVUvODmYpqANeguHY8Pg5mOW5\n", + "k6WmisxclMZ2MMlzhMYQc0vOlaVm9emG0nflzCpoueM3bfMTW2e5N8/QnPfgc9I4pjBMqSKcCdQq\n", + "uEwGTj0MPeQ1dtefSkfOkbh6EWRYxxRqHcgwj5O+Woopx8b7+CyN295Fa6rNbAecThxR1uUghsci\n", + "Qj7878DWwaBz9txPBS0HukOAtmrzEznZklN5R+XV1eSsOjmBDr4ez/O4DlVfVSdCyr1Od57Vedru\n", + "tXw1eRhMrgzLGYY5XnjO6k+f8F6V00mY8RhPdK9sQPVT1eOuw7JqYq9MSuwj2zpHiNUbTXeMwTbR\n", + "heo39o9tAh2F0+kK5LFtqKeUyYsqlDuP0BzEVJqD7wxtAhdXhlCrAOfqruplWKnf4HXe9ljIsa5Y\n", + "GB58HRtVGnIHsO6NoUsnTmqiD35+NHFubCsuCmG9ZL3TTw9cRKkcNtpAl/IvCRhqeD+lG7fPbXKB\n", + "htNvJS7YWa2H5eRA66DGiovQwHFG5cCGIb+qM+L65wTd2xmGmvsx8QrUHORcm7gvEdeBjcITHoWN\n", + "rgOaghrXUy3pFCy68T1mYz3i8rrSgWpf5/RU/ytdKPup7Mp9aOvu38EM552DMJ7H+lD7TpSO7yXQ\n", + "Hj58eK1MhdkKbmqQWSbwcp5YPadhuE0nRBWhsUedAmy6LO08Wu5jRFYt4RHmaNRZPl1qpi4dHCpo\n", + "VGMw1cGhY9dFZBXQlON0k7KqNyLseHd21cHM2YdKlZ0o+2F9cB7r7XSQ17mVWScnfSlQPUeoPFlE\n", + "/axsYux5XZdOJoQD5hRqFbC6pVXVv07QuypR0Fl5fuackjNkF4lXEFIgUfZRjSfqlPvMunRAq9qT\n", + "kZ/Sv5NVW3BQw3ZX0ZnSUQUv1ZdqjrHgmKtjnX6cnPwtp3rTlGUcVSiZeGIFAhWduQkwuY+D2+pS\n", + "c/J6nvu2CjQ0VjaqLl8tMd1LAR5/JdPxZafhIOLGbnJ91SYFNFePahNeiymXdY6ycppVhOb0qjYX\n", + "0TvQdVBzzgFtsILmRE4OtApsx4CsA0+2D2GGiud1/ARgDqCHwqyKzNzErICmQOaiIxcld8/NcMO6\n", + "DpFO5xXIOkfk9IhtdnrEiagA1rWN24X7XK9bCUzsz7Vf9U/pppqr3XipPlVtwfQYuTdAm3qBiPot\n", + "5MpSjWHm4OYmg8pPlwfuj/dV0d10srCOWNAjYh7HyI1Xt8ScLlGqNrkxVhP4EIBUY5d9rvSH51Tg\n", + "6YCb96vOm0R/XR7H0elW6dLBDI/x1wErtjhZGazKvQYaDgamKQpkzniUIVUwqwbdTQYFtekLgOrF\n", + "AL6Kny5vWBIYnOI4OZCpt8/T52h4/0rUGLuJNoFFBzPnhCYw4/ZNoqlDgFSVTTfWsbMN1e60DQUz\n", + "9cnTpA1uvLt0KicFGu9XXr6C2XRz0FMww4lfgayadB3YJsvNyacaaqsmpoIbluNYqU8xpkDjccf7\n", + "O7tQbVXwmU74ia0w0KYyhZkrOxTSDhjYX6VnFSxUulBjo8CGkeYEZlgvt0vtr8jJgIb5CeQq6YxU\n", + "AYHbeQgg3X0YRu67IRedqfwq0JyeeKmZ56IOeBxWnpspoKmJ1Rm7G9cVHUwmrapnKiuwUvesbEe1\n", + "Hfc5X0nlLFjXDmjdJ06uPZ1upwHNVE4CtEw7Mk865wxXyarBqms7kDlgVf9BvXqexs/QViYww8vl\n", + "nV4qXXUGx8BU9anJUAGrglA3caZOaSrcTgeqzlbcMbwH6sqlHFljXp3jYI/92rbrP6jHeniedrDF\n", + "VYHa3LPYFbkXEZrLV52vrnMKcddNRU0AhNXjx4+v5R8/fnwl78o4z5ubxNguZ0ScsoGzEU/Amefn\n", + "OCMM9n23ERpPxMyzM6gi7Omm7tk5JdVmtgFu9yEwmwJtokMe08qBrW5qecm2xPNctZXnmoOXKl+R\n", + "kwOtK5sAjPPunghKd6zzEGikKgJjWHEetw5iHLXl/SdA67wp9mcFYggDBJmLEKYRxuqnK67fPFaq\n", + "Hdl+TlPHXR0pFbg6mE2A5trBZQyYDnArDgGXlwkzF3hMZAIw9YH9VO78p08Ra284qk8C+PzMT6O6\n", + "CcBSlFdXMFsBWwcyhhpPSsyryKcyPjZ+7J8DXNbPz1IwTY/NIFAg4zpX/yprpwu8Px9nmFURWgVj\n", + "F0l2MOugtiKd02JdKJgrvaQgyDhSU/PGzUtMeV7z29R7CTT3Ad6kw5nvILYCJXWdO0fVxYPuoKbA\n", + "5iK0CmZYNxpZN6G5D2ofverKUjPFPVvh8ZnCRy05Fcxw8qk6caxQXH+qpV6XHgqxDmoqGkPbVGXs\n", + "oFz0VI2tchhKXKSm5lQXSDiQ8c/npnKylwKcV8eUF1gB1+Saab0TmOFWgUwBjSMyPqYmMrYLy1CX\n", + "Ez1MQKaMXD1byUlUfaCs7slAq56jcSRVgafrZ7WUneQPhdgUaG6+KMfPeew/wm51rBGQHaCcjU1A\n", + "9sIDrdvvvkCfKFRtaoAq0KUwzBhqHbTcMYzIHNxWo4eq/+ohLkZpLu+8tnI8DlwOaqjLDgBVRKba\n", + "WIFI7XPbVD+y35Nt3/eyXw5oaOddqkDmwLYCNAVFBU+EEo8Jn18BTB1bkZM8Q2NxjZ7Qf7XDXG91\n", + "P5YqonDLxy5CU8tLlTqgubIKYgig1W/w8j5Tx3EI0FSk5q5nHTiduHYo+FQg665fjcbUMYSIA0jn\n", + "oFEPvL+yMcxc2/b9rbedCSN1bgcwBbkVOckztIlsm/5zxXnM7U+2vEZdy23AAcu0W3JOlpsINIYZ\n", + "56dAw7x6sKrgtmrgPEGyjmpCMQAqMEzecCJwuB2VMKRwCauAdtMwWwXa1M67OcA6ONSB5b6bQykM\n", + "MxT+MHuSrsi9BVrEfACrc13koOpwZSnKkNWS00Vq6sVB9fMnfsPZQYzbqhyB+65oxcDxHipKyHtV\n", + "IFBl6mNihkCe2wmO8QqUOvDy8ckS+SaAxtFNRBy0LFsZE3RgrM/Mp+DvgdGmUiYR2ksHNJ4wHJ11\n", + "UJvKFGQcoVUwu7i4KCM0VV7BTC27Kl3xfi4l0Sgy5Z+tYN86AOD92BM7oPFkUeCYTHo8/1CpIiv1\n", + "a4yu7SvAWgFa9X0W6r77rAkByGNd9Q/tTcEsBecH2oAaoynMXjigTQ3SAcdBbBqhYd0roFQRxZMn\n", + "T+Lhw4fx+PHjePDgwfiTDQc0XnbhBKiEveHTp/pbsWw7H0sjzHxXxjpU6aFAm0RNE5vhMZtEam5y\n", + "V0A7BmLqOEZGDDJ+xpRjUn0ixY4IHRnbztTGuO4KPAgqF4m9EEDrFKWOV8pXkcKKsPeYRGp4DEHG\n", + "S8MciDfeeOP5luDCMizPt5fdUgs/ql0d4Gw3wom/H6vq5TFQ11T1qKVMBQ4Hs2MnXQWxClxV2TEQ\n", + "c33k/nIUrKRy7rzPkVtCMu+hytR9+J4PHrz5v1gfPnwYFxcXz/NuYzC/EC8FlLDBVfsMs+o61/EJ\n", + "tKoyvB9HZwyzbduuRGAMMC5Ho1cTgJ8dOY/YQcbpNSLKyI/1Xt1blVUgcWVVVHaMQ+tA5e5bpTe1\n", + "VUBjZ1JBJveVXWPewS3vg/kuCs88Ao03BTiGVpVfkZNEaKtQc2DrDLsbbCyrBh7vx8BJoOV5CC21\n", + "zMTy7lkRl7n2d0bOusrobMVgOGpQ9+K8m6hTsB0LMWz3JEpzQLsNqKk2OKChg5hGasqe+VgHNleH\n", + "KptGaBcXF+XPnl5IoKnjCmrKU03qjfCDy2VdpKaijYSZUvp0uclA6yYRGpjqC/eZdYX9wGPumipq\n", + "cPdXxzqgOMCtRmbumAKr07OK2iqorQLM7bs+c9tXYMb5FYBheefo8fxJZMYR2mRbkXu15FSRmYOa\n", + "qy+iHtyp1+Jr814YnfH5+76Pl5u55JxM6FwWKmNkQ3dGoPSeE8bJFGiqTIHE1TnZ8FrVn6q/Dp4d\n", + "2Lr8KtwmTivHuoKYGnPOVxFVBTY1rhVo8Pru2Vker76RPAZmEfdgyenyuK8MuTPoiNmzpUmkhpOT\n", + "l5w8cVcjtJUJrX6yhFByBlDBbNu255MIj+/71WcpHCFNoMbXKqipcyqQqf64sq7uCkYduDqQqeMM\n", + "NJVOdOLG2QFMlU3h5o6rsml0lr8gcgHGCwc0PlblV71zNdG6iEyV4zGcBJeXl7J8JUJzRox57isa\n", + "3ARk3H7Oqz4yyPiH5pWusbzrm+rnJM997Mo6eHUAmoBsAkcHMF5qKr04UcDidBINuZ/GOYjxfvdW\n", + "EwGnvo3s0qmcdMmp8gpoE/ixrCqqC3XR+Bzknj59KkHmIrQ05E4XCCb+pgwjLewHtq0SvJbhhXmM\n", + "BJ2uXf3cFuWcDk3VvVzfqm0FdIfATcGLQcb2sAo3FmXzqROGU9q1is6qH5FnfvWzDdfGKj+Re7Pk\n", + "rKDVgc3JKsRcpMZtwSVa7j948CAuLy9biOExXupVesJ28A/KJ4OuJnulJwZZBTQUFREeAqmqvavH\n", + "ViG2GslNojkFsC5Cw/Z3usZ9BQQXpamfwvELgcnPk6bRWUZoVfu7skpOFqF1EQmfg+d2E8sNKKcq\n", + "GnOQY5ghyHBg3ScbCnAc7bk+cLsd5J10+uW6+ct0TA+RQwBW1ePKujxDBH85cejG17t9By+1cVud\n", + "zlIqgKk8RmlZpn5VwhEY5tX+ymcbtyV3HqFNjFoN6qEgw3w1yG5TbU+obdv1P0LplpvqmzQE2tS7\n", + "5jXK2PE6F8WoiYJeWkEN00OkGmPX/kPrVfWpiEj9DOymwDaNzCqgOV05qWy/cuoRIWGG0OOfLSmo\n", + "HRKhVeN5qNwq0L70pS+151SdcH99Ao0l4uqEZ2VxaJ3XKQ/jvJBqM0MlRf23Jn6OoiKjLnXLYqXH\n", + "DhAMPAdz9Tarin65zEG1a+9UpqDMCTVJO3Dx5zpoV1V+FWg58RMWmHK+WgqqsePnrxiBo506mLly\n", + "hhbm1acaK9H1VG4VaF/+8pfbc6olVxoQp+rP6TDM2ODQa0bEtYGp8lXEyNGO+rNADLVKD86jdtFj\n", + "3r/Ts4q2qgi1i16rMteubt9JFXVWZROYVUBjiPFxBTIVpWW7uk0BQwEsyxlgFdRwzNl2E2y5r5x7\n", + "BTcGL8MM24NAdWN3iKO78whtJSrpHsRineh9WGHoIRXQOOUyZ5S8pHj69Kn9F3RuWaHAovIuWmRx\n", + "dasxYH1PwaUmiosIJvByhtudW00ABloFMQc0BJkr5+Ua2iqXdY4R210t8xRUHNQqZ+PAgSuIauXS\n", + "tYshzHbsxpf1tCJ3HqFNPDt7dw6F1dJNhfWoOL5GeQ0HOfx7ZPn9GUM2z1H/3ISXnE4nuK90445N\n", + "REEM61P6V/eqwM9lLFNwTfenaQUwzjO0JoBjqKmILe0z2+VgxkBz4GB9Tx2Nswm3X61epu1T8HXj\n", + "6XQzlZNEaM6bV5O1C0dxEk6WIhPPxlGRgmRCzP3pbAc11f5phOTghP2roKXKXF6VrUQOE4N0kVWX\n", + "n6buzVsFNAcz3HfgctGZm7hcFuH/VLVzuh3I3LiijXBZBbMu78pyq5zWvQWaitCqyIiVkVJ5EjVQ\n", + "Ef36WylZ7WddvGTNPINM/eOTLkLr2lkZJQoC1+lnauQuVUsK97BatTHb2ZWvQqtKO5jxkhPhxVEZ\n", + "76edVFDj1UO2qwOaA1cHs25jW6jsZAKqSXCA+2hPVfSN820qJwXaJJydDE6E9jDVfmcQqHylXFxy\n", + "JsCq/xHgorNDDHIVangf1WenP3Us6+A3WWp/VVYgtXJs+gV7Ao3hxSBzz9AwGlPR2QRoPF4VGKbA\n", + "Wt0qeFYwW7Hdauxwvt1ZhLZt22cj4v+NiMuIeLzv+wf5HPcMbbpkcWtyzEf4/3CUaZXvjCTirf+/\n", + "iGWpdP4nKfw2Vr3pQl0o/UyN1QlDrTJUrovr5WMcoVVRT9VG1+5MO1CtQK77GQ63OSFWgY3HNdMu\n", + "Opv251AY4bVcj7KFLgJ056nU3Zvz2E+1r1ZEUzkmQtsj4sP7vv/f7gT1DK1aorhjqmzb/D8Mvskt\n", + "4q3v4ThqS6PG/yGALwh4q54LVLB1Hu7KYJB3R91wnWyo3A4lWA8DzX0Kwc6lk27CHwq3FaDheE3A\n", + "tu+7hZh7wznpQwWqCcB4zNT4sYOqgodJymOt8mre8vgjzO56yVlaqltyqg/vXBl7/uc3JmV0zxg4\n", + "j3VUhhMRzyMwhFkqnCM09akJ568psfGsh8CNjYlhhgbr2qOE68Ex4m217mpZdgjcViK07Au/BOCU\n", + "wYaRmYrWpkDjdAosBa8uzU1921Z9alHBrHOE03Jebt7ZkjPejND+8bZtlxHxX+/7/t/wCSpCmxgV\n", + "T5KnT5/GxcXFFe+VxpL7rOTJUrWCWObRw3OEhlBLoPFgqH2UyuAmEKsAgefwhjp6PqAD41HLTQbZ\n", + "o0ePngNtxaAZYBXcppFcRFj7qoCWwOIUAacisgps2KYKaEpHU2BNrlMQU4FFBzAX5au+VI4cz1FR\n", + "2oocA7Q/tu/7F7Zt+9aI+JVt2z697/uv4Qmvv/768/zb3/72+MZv/MayQjdxXcd5Hw0jFZFGh/Vw\n", + "yOsgURmaiz44Oso2cPv4+d/EG1bQ43LlbZ0XRj06yWNVvS76m0ZqzohduzrgscOrdJfH8JGBeh7K\n", + "/4kLnZXLO9BinlNul7KrCmaurAJhJXl/1fYEPp+/ImosU4e/8zu/E5/5zGdG9RwMtH3fv/As/b1t\n", + "234hIj4YEVeA9s53vvPadZMIhCe0A4iieQIMoZRAQcNw9+BjeC8lCj7VRMMy1YYuP9VhB7Ep0LhM\n", + "1ePg6yaN2uflVtUGB68KalX/8FGGAlj18zsFLhWh8/0rqKVOKsdZ5StoVePCbWGA4YsxnGcTOFbz\n", + "V5Xh9r73vS/e9773PT/nV3/1V+19DgLatm1/KCIe7vv+r7Zte3tE/PGI+E8nnViZiJU3VQqICKlk\n", + "hAeDJPfVM7ZqSVD1QXljhpmqg/vsdFBB2AGt2lCXSr8oVTQ2GbOVfWfsPO7TJf6kf+qfPTvIVdGY\n", + "+1xj2g43rk46mDmo8TFsSxVlOZi5+6nIE+/ntrtacr4aEb/wrHEXEfF3933/R3zSBGhqYkwGkQ0E\n", + "FazglRt+DIkwy7bxc5FKcPC4zs4bp6xCq4soV4HmjFm1NaMZfOayMn4VvHBs1L2xDQoc1fdfXX9Q\n", + "HMjUfgWvalJWdsU26xyO0muVKtBU4qDL46r2+Z6qzaruLsKeyEFA2/f9MxHx3d15FdDcBJhMEmiH\n", + "7Xin/LwGl4j4XAshWSnWTeDOaN21K9Cq9qsoircJfDNfLWPduCp7UB5cOSIVLVRQU9+Huf4wzPIa\n", + "92E0l02iMo4qJ4Jjmc6V7SZ1xPqsIOZsinVQzSccG3UfngPcBlVvNbZ3ArSpVEBzIKsmtRI2FqVE\n", + "pXRUGHpBFFde9QEn/kQ/q5vSkSurQIZlHcSwzEVnDq7Y10meQYZSAUR999cBjet++PChhZfaqqhi\n", + "MjGdTaO94vgwxJwuXZm7H+pAAY6PV3Osm7MINgUyzL8wQFNLI7XfQU15QJwMbuJgVMYKY9jhvuqL\n", + "Ao3qu9s/FGiTdAI39pwV0HLSrzxHU/1VZajviRPrQIYb90flM1qbgOwQoCmpJjw7RLbZzkEoJ455\n", + "NZewTIEM83gc26ycmesr30s5rLv+sLYUN2Au2qgiNJap51XXPn36NB4+fFh6TQZbdV4VkUy8pjM4\n", + "9tQVsBzEurwDmgObWm5W41f1nY/lpHWT1XlxBhj/UkP1A5eb2FcFLvcb3SnIOghVOppGK3y9A1jV\n", + "Bm5rBTV3/xx7XCpnXdU8XnUGTu4caO65mQJb95BZGc5Ku9jLbNv1v9nfwbKC0mq+259EXVPYTYHG\n", + "abXkVOOJ+u4mlZt4KMqLI9QQZvh37NT4ZVnCLeupIIbHOoBxeQV2LktbzP2JjfP8cDBzumW9TMpc\n", + "fxBq2PYKopi/l0BTz5GU0TuwqcnB4jpe7btBzy0N24HN9akD3LHw656LTeClUuUUVIoRWrV1E0ml\n", + "GBmoiceOpYIaf2bBdTDE8Pg0Qnvy5EkLMixj26tS1kFli2pucB2uXqXjvA87OhQ1t/I6nPNoWx3I\n", + "lP7uHdBUJxzEXORReW3ltSYT08FRgW1yHrY7wn+K0YEN61ZlHUQcWDqoqcnnyrpnaJP+qVTplaVa\n", + "ljiYXV5e/Q/3lb3kSwEFMoZaBzSlu+l483IdYebE6a0aEyUIp6nesO2ZX4FTN64rcnKgTYxfiVIu\n", + "5qdlqq2ubTyB+a804J+fUdA+dLKr+08Ax/d2efTKnXOofhfJZazTKsWoeDoBV7y3gg7+RjPb4p7D\n", + "uTeonQPobM5FQCoqUzpS109tudvPtjj7wD5MYKl0wHXxvOjqYzn5W05u9BRiKPxbsgpWqg0TQKT3\n", + "Tnjhj+bZuA+BGebVsSoKc2VVO7Cdla5Ylwytat85JtVnfN7Ck1a11e1jf3MJpPrpAMew4n0VcSiH\n", + "qfpd6ZihUYGMv9LHMcf6WXds652jc/rivma7J6ssrk+NXdaBLxamcufP0LrlWMqEzKvrazYANcAV\n", + "3PjvZeVfAEGD7/rW9dfpQBmKg5oyjkrX2K5OJiDjv0yyMrH597grYGOYdTamljYuCnNLJxchoXNT\n", + "yzIWFyFzJMlQS0EAZF14z87WVar66MDW2ZsT187pr3VYTr7kVGVOASudq+BYwWwCMt4uLi5k/ROY\n", + "qba5fAU6yo3XAAAgAElEQVQy1Z/pxvfr2uBAxsdU/ypBmGXq2sXlasOIRbUDgZH3q57nrICtA5lr\n", + "j2obAoxBhpIAUG1BnTi75zLXLpXm/Sdz2UWy3E7Vl05O9pZzQm8U9DrK+7FXwn28d6bTQa3g5pYe\n", + "NwEz1eZJe9VE7nTO91D5TKfRGT9Dmximi8y6Nqu+uiiNJduFUKuelzmgKVmBObfJLTu5XrZ57hfq\n", + "poroVZ7rcstNvk/laJzOOqc0lZN8hzZddqYwzDrFqH2nrGqgFch4iclAq6DgYNYZfh6fLhU6oCp9\n", + "OB0pnU2WndWyRe1n/3Lj50RKV127qwhN3b+ClxvzmxAX3SmQ4T5fg9dxOT9mcUDDjdvWAS3vh/fF\n", + "Midu7A7R8b36Dg3PUeI6WEVjeE83uJ0HY6jlrwzUAOP9sB0OdFPp2q10Wt1X6UuNCZdNQIZLThwj\n", + "1hXnJ0BVepleV4ENHeUkMnMT2e2re1bHqgjN6cBBwIGs2hCQqm1dX6b9V/M0+3EI1E7+DM1NMjY+\n", + "teRcuS/f23msbuD5JzPKI7p06rFW267yXVsmdbol+OT5WV7jlisq7aJ3pQsHLewLjw2OH++rt5wq\n", + "n+ejTTp753sovbAupjDLe2RUyxBgvaxCbeKInD4rcUGAgtqK3IufPuG5E7JXYMtBmEwA5ZEcxNTy\n", + "UoX2ri/Tfq48Y6giKndf1xbuvwP9aoSm9KWi2zRe169KZ9gvngAOBGoibtsmHyt0z9C4XW6sGWaq\n", + "PayjbH9OcP7lQ9ZZvRXsnDjaOS85K311YKtgrdpXOaOp3IuXAquG24XsDmrV/SceC3/QXj074DJ3\n", + "fLV/brIrI3CTTOVXvXcHMoxkVdTh9rF/XbTJbedz2dNX+sU2YIQ2WXIi1FSUxu3l8127+B4INn45\n", + "4NpZ2TmPN8Is81XbuvbiPKxAznIIxFBemA9rp+EsKjDr4/zKMwSGGT8bwnqrflTHKo/t7jNxDOpe\n", + "VZsc3JSxTz/bqICAG0+0ztExHNw48xf3SscqKmKouZcCHH2xPvkcbjuPdQUO9xmL+uUCjzM7CzW+\n", + "PM6VrlTeQZ/PVW1z47cqtwo0NfmrEJcVjuIIj2Vd5NJBy0Uh6eX5+ZmDm9t3E1L1ZQq0qtwJH3eG\n", + "vgIzdSz7UW24hHIwVuUYgfA5CDO3DOOooZuwnTidd2OB93IQSCgzoLNvWa6gphxzlWLegdeVqTHl\n", + "89U+trWLeDu5VaA9evToWtl0WVOFvLyPyxWejFmu4MnQqpZYeC8FMyxzEYXKT/qG11WTuLuvK1sZ\n", + "k84h8fgpI5+AogMEGzxDDGGmlmJq4iMksr4q3+lanYM6URBT16eo33FmXycgY8fTQY7boVLlmLG/\n", + "7hzVR+xDpxsnJwOaAhCXoXRhuYswquir2vB8VK6KyricwVKB5pAobSXl61Q9K/CaOIA8D2GWE4/7\n", + "rqIk1+6JPhlm7kfeeY0qQ3hxlK8iw0rv2K8KYtUEVm1BqOE3khOoOaDxOGO7uB94LNtRja+L9vge\n", + "7p5TuXOgoYK7fMok7HURWgW0KfSUVJCbwKYbYL4XXs/3OSavItgptDp9M8w4ulqRlagXnVDqT0HN\n", + "AbSCmCpX4iax2lflXA/mVVQ6gdnFxUUJMd7HtqjoiSNdZedVhNZB/YWI0FLJkzSl8hAo0+XjJFJz\n", + "EVoVqWEfM3UwQ5mCrbufK6tgUEVoq/rkLduPSyU0/i46c+1X/cVxwuUtw43rVWPLwHL5Sv/ZJxWJ\n", + "VyBz+uBoB9s/eX7Gdu0ghvuurawr5bgQvjjmDmJKdy8M0BBaVT6lC3mz3tUIrYrUugitEgZZBbgJ\n", + "zCaDyudMosRMVyE2BZwz1GMjNAeQFOeEJhGag5faJrICsgnMUBeZn8BsGoVjuWub6gfCrHNeTk+T\n", + "8enkZEDj8L0yGDXYXKaWTl1kVkVqXYRWiYKY2u8AVkGt21ftcOkqxDrvzkBTUHBt50nJ/an2sXwC\n", + "M/ebSAUyBTolDuKZViCrdFGN701EaGqMJzBDXTrwHwKmqt+V3DnQIjTUHNAcwLgs4vqSc+U52SER\n", + "mhrYCmAuyqgAVpVVx6YRoopsb2pLnbhIZyIKYmgb6jjqoAIYthEfaDuQTaDsHNUEZC5C47q4vwg0\n", + "1lM3H6o5wm11TkDpbTrOE8ezIrcKNP47YRG646o8xQHNRWiTgVMQW4nQKpn0zQFb9RnLKqAjULkt\n", + "XX41IpuejzpDMGD7UJxu1cRQEyVhgiDLCR9xfSnqnrVNojS2URWJuPFy46r2WS98LPun6uY5sfKG\n", + "Wtl9FamxLrpxdnPpXgOtWnJO8pUSuQxD625phKmDGD9LYOkm3wTcqq4JzDoDy/uo9qgyB/1DIIb7\n", + "PNEmEU4leC1CxJW5qKj6feQEZFnG39Z1UOucsnNalV10EVrn6Kst4vrPqpwuKzvLfCUO5C8E0Kbp\n", + "xDNgh7tvaxzMnBfDJWflUbh/043r6Ix3ZZtGwpMI7dCoLdvt/pz2MVLVwVDDaIO/UYu4/vvIDmQq\n", + "ClHjpcau2udr3Tl8/k1HaLkhMNX9+ZcYzmlNYOZ0tSoneYYWUT/g5cnuIMYTeAIyBTO37yK0yps4\n", + "eD14oH+f6AxZHUsjqkDG8Eh9VoA7BGgrHh4Borx3JVXbU9/uOoSagheDjO+n7s/nVhOvs9mb2E8d\n", + "K5s8dowRWt1H0a7/2GZV1tly9WeTlNz5X9tgUQbpDBajtjyOIFFLSpdeXFxcSauN76UiIde3buKi\n", + "UeAkdILRhmsPt2ua5zYjiNnYsayCdk6GrqwCV6W7HBvczzJlR5OJiDKZeIdurn7skwOB6pc6numx\n", + "/y8B61B/nhz/Dyqn7pjL878QXJGTA60SBTPMc1kFMBWNKagpwEVcf27AE86BYqWfHcxYF50hKli5\n", + "tIoqO5hxvqqPf2iN6bFgS1GOEMtVitdiqsqm0cUqyBxMurw7Pr2HE9cv3ioodekkvyL3AmiVcivj\n", + "5HMUvBzQusgMz933t57D8BfRCmwT4Wiiu5Yh5soV0Lo8g42jrg5sDoTTiKyCmmsn6q3SLerIQcyJ\n", + "g1oFpUMioQlsujmC+Wn9U7g5oFVwmkReDowvZISmJl6n2CqSyQitey7GW7f0zGtzQBNsOEmxbV37\n", + "VcSxEs3l+ZVhTgHp2sYgUzCbwm0SpVVRWeUwVpyHgpkD2yGAqGC2ArmVCcxOsYMu/izJwc3pAvvR\n", + "LSkVlKbLzBc2QuPJ544ro1VlKiKroq5umYnXJMByW31rNzlH9Y8NFo0RJ6OCmRJ1bAKgDmAOag5e\n", + "k2dorLdDoI96Q6jl8U5XfHwVZiuA47IK3JVjX4WxusbpQkVouFVL0ZUIjo+tyEmAhhNyxcicUeME\n", + "6h7wuwhNgQ2js1wS8aSuoNaBbAJCzDuoMdxQppHwFGgdwBTMphFbBTanr4kOGWqdnbH+qohmCqjV\n", + "fexztT9t8xRuXV3HAq0DnILaitz5X6xVRsEGpgasW3ZMYeaisSpKe/r06fO0e86j8iwKdCuT1QFs\n", + "Wubuo2AzjdQmYKvyTq8OZofqq5JjIOfg5MDlzsEJzACuIrXpppadrv88T6sl5wRe08iM0xW58wiN\n", + "vZDzDuyVUpyhT56TrR7DKA1hpqITbN9KVDZZWvA+6sYZJINM6RkjYwezDmLqBcAxEVkVqTn9Tvan\n", + "9R8a3XQwU3mX5vh2jtPNG9cXhhmfM61jGqEdE5ndywitAxpOKAc29tYun5OrA9bkuzMGmlpuTpac\n", + "rh9YxvlJlKfAhvrllPVc1emg5iDW6aSC2PRZmtNfpS91bTdGTm4KbNNUAU3NJR5PBSkXKToH5+yD\n", + "YYZgevLkSVxeXtpzcqvqeCkiNKdYFAUxNtAc8JU3mtMl6oMHD+Ly8vJGQcbHOe9S1KEqZx1jvvLC\n", + "LjpzEVoHsA5q3QsC1a5Kdx3UJmDs9MhlU2hUS04FtJzADLJ0qqqf2S6XTrdKBwxotexU0KogN31p\n", + "kIBXDpzl5EBzBHZhdzVhKqipzzO6N6JYZ0LNAXVVXLSm6q0iOydTPat7O/2ujEcXZXWO6hidTkCm\n", + "9itRDkEBYVLmYIjQyLnD0XVlN9g2dd+E4hRuCsIMsYzOGEBdfuUXBStykpcCHForL1AZPteXadax\n", + "bdvzFF/7svFkdHB5eXkNcJnfti0eP37cbk+ePIknT55cAwBGIjhZ0VDVRJyWqRT7inlnuOgIIuKK\n", + "7lJfT548eX5OFbnhMfWcxW2pP9Qn6hUnzuXl5VgXaF+sc4yAKpCnTeD9Ly4u7DJuJVJz57vntSp9\n", + "29veFl//9V//PH306NFz242I5/p94403rqw20M65LMcPx0DlM01bqfrWRWxqieoiRycnidAqiHFE\n", + "4bytqhevVSBTQEuYqYHOjSeZm3AJNF5SJdgQag5okyiG9aI2521ZH1lHti2PY6ifAEFYMdTUsX3f\n", + "rz00Vg+SEWhq8iioTeHPfUcbQpgxRDAydxHFJNLpop/KySiAcdmDBw/i0aNH8XVf93VX0gRajuXj\n", + "x4/ltVU+HdlkbBzc3eaW2+rYitz7CE1JFaVhhOaO41tL9YyMJ6oaROWtcqIhvFxeRaHdPk5ALmej\n", + "xz5PUtan+6CxmghclvVMHvwqqLnoDAGLelB57BMCHPuDx3Gc0FbU854KUnzP1bQDGZbh4xR+pJJj\n", + "gDY33RBoPD64n2PC/VB947k4gd6K3PsIja+txF2b5RhKd1EGGo2aXG7iqQhNgcwBzYEty9JIFdSw\n", + "3UpnCmLOiFyZmlguRc/LQFD7qNsqxei9cwJO8DjqQy2L3D5OUKXfymlU5dgXBTSVV3ac/csILaGD\n", + "emEd4X4CjZ+XccrPurhfbr+Cf6c7J/c6QuNOVZFHRFiQZd0uoug8IYOMU8zz9QwwTiuAqQ37ywaN\n", + "S2XWDepEjQcaJZdhOtUZA617VqKeqbnnbeksWGduH9Mu7575OOBXenXStYXHvINaN778+IXzztGh\n", + "o2G48daBxzmXVdh3cu8jNGc8PLlVKJtAwSUEGoQyEi6PiHKSqYfVeR91bwe0bstrsa8RHmpTQYPH\n", + "tvHDegS20pmaaAg0l0egVc/Y+E3axBlgeeZZb3xe6nmyrUoHYT5W6Rj3O2ehlsmTZ17VGPA+Bh1K\n", + "190xzqv9iZRA27btpyLiT0bEF/d9/8Czsj8cEf9dRPzrEfHZiPiz+77/vrr+JiI0Z0Quj8aO0OBJ\n", + "4LZnfbyydW/ocIDT0DAiVIBbBVq2C2GlYIZAcwaB5ahrfNidHpnf5naOgCM0Fem4yIcjQhclVrpT\n", + "44d6q9rLTkNFMM6pVDp2bar0OAFabu5RSETI5XoHPd668cg6pmPB5eo8LFuRLkL76Yj4mxHxd6Ds\n", + "RyLiV/Z9/6+2bfvLz/Z/RF18bISGIFPLSbePyo3oHxp3ZZMH2rgUSsAwwLiPU8NWE04dQ6iloEG4\n", + "fHrjLGOgvfHGG883vnfVZuWQXGTQLUtxUh0a3XL/1bMnZa/VPtuNKlP6Wnn0Uek7Iq6MUTqdiKvP\n", + "A/OzDWe3Lp2MR87Nzi66MgXwVSmBtu/7r23b9l4q/lMR8aFn+Z+JiP8lDNCOjdBwQDLSyTryutzP\n", + "lEPfY/MRUQ4klzPIEGYKbjiQPFF5gFE/2FaGGX6D1KURcSW6TD1mWU6Wr371q/G1r33t+bWTDcdk\n", + "slVLU86nsXdOAPur9OuW6gpuqpzvUeUZoG7rnAWWR8TzscE3m+lcc3xzHNVjEvcopVq2sv3nWEyA\n", + "zXm3X42Dk0Oeob267/vrz/KvR8Sr7sRjI7ScxBFv/fQjyxXMUDiim4hT3kqYjoPCIOPnMxw9sLHm\n", + "xMV9hhlPFgTaZLJFxPNIDF8mcIT2ta99Lb7yla9cq8PBg4HGY8V5F8WpfF6nIOUmv4qs8jg6ArQD\n", + "7pM61ukDN/cBq9qvgMb35u/O8HknR2jVpzHu27LuUUHq1sHZgVvpIOtFh7UiR70U2Pd937bNPh29\n", + "iQgNBb0O18mTXYHO5bv9lYFlqCmQcd9xciHoGGqqnwpmFxcX48m273s8fvz4SlSX/ciJkUD76le/\n", + "+rw+rJfvged0YzGFHPe9ilpUW9RynScTO4JDN7e0Uj+5Y6AeAjT3q4Dsc5Z97Wtfkx+Hu7x6POAe\n", + "GSh9un385QV/M5dQy3HiednJIUB7fdu2d+77/i+3bXtXRHzRnfhzP/dzz/Mf+MAH4ru+67si4up/\n", + "LkJo8cRP6bxwSqWALqKrwKcgkm3CtjuYdcsLtczgssq7O31kWzudVdd3gmCe6L0qq6A2bYe7f4oC\n", + "Der1JoDmIFctuyZwVlvVbwYRrzBY36kf1BPrsLOPiQ2pcXbjFRHx+uuvxxe/aDFzRQ4B2i9FxA9F\n", + "xN94lv6iO/EHf/AH28pc9IIdxqWQ88B5vJIuauuOde3mCdKF2RXAuIy/AFdAW5Hq/M55uHQiFcz4\n", + "HGyPG4sOxArefN1qVNTpZqK7SicrUUkXzaqoyumPIZv1p/6rep3tOyer8k4/r776arz66ltPtn7r\n", + "t37L6qP7bOPn480XAN+ybdvnIuKvRsR/GRF/f9u2Px/PPtsorq+qbyWV5CI0dY/K+FmqqEzlVX9w\n", + "sCP0cwQFoVWoqb8Uoq5z7ZxIF13w84zKMFF3q2nVPm7rMf1y/bwpkKnyia4OBZr6MqAKFlByhYHP\n", + "sRTI3OOirGMSbbIOjuUESveW86Pm0L89qbxrqCO/itAwVcrhpY8DWxeldRGaGgg8bxVoDmoKaO5P\n", + "HClDmRgJ64tTNeH5/EPlWLgdIwrU1RJ+BWiYr6DGesj8IUCbgIzfkOM48vji8pvrUGUKaMo5q+Dj\n", + "puVWfyngGsxkr45lfhKpOUOoDEQBbAVqvK8AVu1PYJbXdEvOQw2mgpmLAlel0u0EYui0uI3TdrnI\n", + "4RigYb0qj2mlmy6Cml5bwU199oNtzjmGb3vxOpybXJbnO5Ap/XAbVH5V7hxoCjxMfSxDRVeejyOH\n", + "CcRWYFbBogJaB7cKYpyfLjkPkQoUeJ8q6lUy1XHnRLJtHfS6CVP17RigqXtU963GagI0hPsKyNim\n", + "GWaZIqx4fmKkhhGagpjr8xT2q3KSCA2PK4hxVFZFZnyvQ5Yq3URzA6GMtgKaylcQ44m2suTk9k6k\n", + "MkS8D+tJ6b7Lq+VPFbFX+l/pn+qncy6HAk2VTSA2jc7YJlWE122sl+x31pcpLzMZZjg+KzqrxucY\n", + "ORnQWBHsFdjwUYFq6wyBB7KaTG6CVd6WJwf/NdDus4sqv22bXW5WS87pOLgy1TdeZqDOJuOgdN1d\n", + "U9Xr+q3gwn1i/a0ALSc/1+/u7RxO6oDt3kkFs2OWm6pP3C4HM/XTJ95f1cmhctIILc9Ry0wVmT14\n", + "4P9L0FQ6o1GgqyYEt8OBrAJaBTV+jlY9gzvU+yldqomPETPrjMfO6dWNA+u5a3+33/XR9W8CtDw+\n", + "uT/rs2vr6gpDRV/VLy34Hjy3EmrbtpUAy+M89lV/pzo4Rk7654NQeEIoz6Cghtere1XiorQKas6b\n", + "YyRVAY1TN6HcvoLiFOpTI6qgjecoIHXOogKbi4hdPyY2UPXtEKAd4zyq6xgyU7BVAKuWm3y/iKt/\n", + "PHQCMyzjutS4qL4r6B0j9+IZmkvRa6glZ3ePyjCOgRlPBJ4U/LMWTrsIbQVuatIdOibV5M19nhhK\n", + "p7jvzlMTbAXKDmQTmKg+3iTQVgRXJ1ymzuX7Omh1kEO9sJ7UKqmCGV7Douq/Kd0puVWgTbxMp4xq\n", + "4zCZvUXEW16n+rG6iy7cBM228n7VxwksFKzdZGUY4HIClw2uTqxL/QFFnAhd31x5BT8+XtXjylYn\n", + "hnNI6GyqMZk4jkpf1TW86nD347K8Vv2kqYrQXNvUWLC+c95hvnOU03KO+lflVoGmpINGSjWwCKnM\n", + "R8SVffZWqlwtmVwb2Wtx5MhtR4OrJrW7P16bZWg47EnRc1Zg5LJ936/9FQaGm3IGbgIoz66isckk\n", + "q0T1RwnXzTBTUXXnSBloKsrsJiZfo1YCmHdlaRc8XlOHtCJqzDkYWHUyKU5fq+0/WYQ29RQMMn6e\n", + "psA0nUQMI2d4Ci6ZImSyXMFzRWdoIAhrNGLUS/WiRE14hqL6/6IcrXVAxvq4/dU4YJnSxaGiQFuB\n", + "jP9KSQcyBzS8t4s+O6feRWU8ftVfonXOW+nLCY4n7x8KMCVuHq/IyZecTpwxTSItBhZfw3/hgyMQ\n", + "ZXA4iFlngqTKd5NWRWloLBVklcFjnQpivI9AU/8yTum5MmiGewU01guPYxftdNGZOk+Bjf8wZgcy\n", + "3J+AmduNZZVjn0At4vrf6zvUmVaioHZsfUqUfazIyYC2opDOYyY4FLiqMvx+BturQFLtY4TEMHMD\n", + "xEbJ9bo2OGhVk9vpmiM0hlkVoSmdueMVwFy+6/+qOLthqE1Axk4IIzHnZDlqxWMqnUI17VgtNQ8F\n", + "baVDd62KWKf1ODlkvO8caNOJkHlnUAyMCiCqjKOsvIeK9pS4ZR4DE6O0Y3XH5Svwqu6Tf4ue/1pp\n", + "9QxN3c8BehVmnHcw6Prq7G+y5MxzqzzbVjXOCs5VlNpFZphXz88qZ+p0syoOYpWjdqLafEiEebKX\n", + "Agi2KoKYRmRZVwU09RLBGaprd9WvBFpuhzxLuwlPulJPRmj8H+BVhMZjNcl3E7cbPzceSirAKRvC\n", + "t5v5O9kp0LB/CiLOCVQTl/tdQQ3boF4KqCgN00NkxVnyfTiQwfMqBtwroLnGpJG66IxhV8FMPadi\n", + "eLlJhe3sAKAGhNuX9508x3BerAvdnZc9NL/v+xWYqWUn609NbpdOIIZlEw891ac6p4vQ8Lyuf8qu\n", + "+HMGp3fus3Ic1VITbW4aoR0qDkZ8HPu1Er2xOAc6kZMsObOhXYO75Sameb/O46fxOK839RTch7xu\n", + "5TkGD3pnOJXH7Y5V16h/kIEwc6//1fjg/kr71KainEOMHNvLdqSeoXHfXIptRCfKz2adM8R+sq4r\n", + "2+T96hnasUBTEXIFMGXH0yibIXZI2+9FhIZ5lTLIMs/3qICmnmdVnnDSDwXmSYRWTUiu0wHBwdqV\n", + "YT+4TH2DNvlsI/tSTb4VuPLX7fzyhnXSCdtVBzNecuZ1mGKebSni+hvwPL+DmdJ1p9tMq2/QWM/V\n", + "GHSiQKX0rUDWjZsC2cpYp9zLt5wYTrvoDPfxfm6C437mua6qD065Cjwu/O/67wbRAWvly/CqTP1f\n", + "Rl5yYvt4nNQYHQI01F8V6bBelLjJWsEsXwrw+S6P7cNoUn0zqNrnwMY2WYFNQdE51A4OSlcOTnm+\n", + "ymN9K1Dja1ZhFnGClwJKHEyqgXSgw2cYbh+frSlIYpucMTqZQmYyyHyOgli1n3V0gHMgU5MEdYLt\n", + "Rj25Scxj6wx+avhd2aQd2B435m6fIwq3YdSkNv5v5djuzu5x/DhCUw51Agl1rrMddUxdq8p41aRS\n", + "toluPE/yF2s5dObySb2qHtVh3ne/NqiiQCedkVQGvvJJhwNaBzdsg8tXE60DMU8s/NnQxKA55ck/\n", + "cQhcH+dd39QSjSNC1L8aEwWlyX6XZ3t09p5p9YZT6crpX8kE1NPx5XrRrvH3xxHXA5IpkE8KNLU/\n", + "ua4bYBT1S4AVmKloBOtRA9WBA/en0gGtW2ZUaQde3HIiu2jBOaYJ4Fb6V9WDeQSP6hfv57iyuEid\n", + "oyuXTqCXZROgoY5dZF05s05/FbxcvhsLHBOEGIpaWa3IyYDGeT6fz2FwuMmkhKG2AjNnyEomkMAJ\n", + "VE16VffEqHBpyHU6o5tEMdjmlcnWtQXzk6hsCjQHywpuFdBUOUIIAebyHcwc0KofzEeEhJmK1Jx+\n", + "JvbBqYukJ2ONkZm6NuLq76FX5ORAc2XuOgZcBR4U/pMnE5ipJSEOCJdzqjwcpthmVx/uHwK0ru6b\n", + "BFo1HhPIrmxO55xihOaismOApp49umeSDjqqfajHSu8RIe9VwUKNS+UIFMxUm6djHRFX/v+nEzXP\n", + "OjkJ0DJVYFPXccfcMqcTDGenMGPo4D2dst0kVF4Nr+G885SuLlWvatu0vVivAxqPRxWhuX5yGyZt\n", + "Unpyx1aAnf2pxIGk26ZtYFusIjVsRxehdQ6gs4kqwlR258a6KkObYqc/kZMCrUsZHApiXWTn2oXQ\n", + "qmCmIg0Hs8mk5AhtJdqoIOZC/04PkwnPfeiisi5Cc/tOb5Vuu7xa3nRAyz50usPJjRt+BoP5KVxR\n", + "xwgx5YgjwkaAyslVMHNlrDd3v8lYZ9+4nG0n+4r1TuTkQHNluY8ww4FW+ZV2uU1959ZNRiUKYmwY\n", + "DLQu4pgAzRlApduVKIb1h/vq2NQzHwKrKn9I37B/kzHmyY0A49R9VtHpGCHGEVoecy8EJpETl01s\n", + "T/VbwdDt89xX++iIVuRkQJvmcx+9rYLaikwjs6pu58XcNlkGTCZmlWK+cxiYV21yk44dSAU2p69K\n", + "j9PU6YrLVBRa9U+13Yl7Zoa/unB/vcSBzdklAgzBlu2ofuHBuun0zec4ffE93bhymdOvCy5W5KRA\n", + "4313PsOMQbYKtLxmAjMXabjyFbjh9e5cPNYBjScEttOlEf5bLWXIqp6qbieTKKEqq4DmHIEC2zFA\n", + "40nNPyGrfhvr2oDj50CG+xH6OzQGmtNnNw4TmDHQHDhTFAN4HuY9V+f2Sf7rUwU13ncw43TSFlYU\n", + "K9ApVrVJyRRuHO1MIThNsc9uKciwdhELw2AKSjUmnbdVE88dmwAtj3cAYaC59rOoic1wy79i4u6p\n", + "8vv+1n88Q3t0YHPRWQc1pV+Vsh2qZTZHaO4+rNtsf/ZTzc0VOel/Tl8tr2DWgQ0V45aT3TLT1emi\n", + "KfY2CDKM0FaAVsEM8y7KVP2b3JujhyqtxpHHojvm9qd6S11PtxWpPtOo/hSTStkhZdsTXgk51HVG\n", + "aApiOF6drjuYKfCrb+0qcfMv5wmnCsQTOfl/Tj/m/JRVI+8mrvKm0xQ9Dnoe7h9HR6vtdAOuIjIX\n", + "nVXnOj3fVLSsxo/Luok2GfdslxpbjmouLy/btmM7+KF/9YmGajOmSo9KT2qloGyhGn+sa+owJvpD\n", + "qZNw3ZoAAB8OSURBVFZdzib5mKqnk5P/OP2QaEil6vwVKPDAqf1JyjDL1PVVtaFrPx9XOu02PA/D\n", + "fG6r0vchEKuEJ9ZEF5PzssxNRjUxsQ0sXDb5xqwbQ6WHLro9RN8OkHhfLK/mjdMl2g62s4JZBd1D\n", + "+nmvIrRjRBmMO65CaAeyVaApmKXnX4nQXJ/UZGDPnOkq2DqvWMHsWLBlfasb6knlI+ofqPPSifur\n", + "8rnfRWbKRiobTT1kWo3DVKfTcXXlzrGzDhlg1T2r6Kzreycnj9AOkWpy5/5q1FN5IDWgFdAUzCZ9\n", + "mUQhlfByZbrxA2jVRmxPBbNjwOaiBHY0DvCqLCNQFY2pVLXHgU3BbOV7MCUcLU0mt6rXRUUTeKk5\n", + "4YIB7G/akutX5UiraG5FTh6hTb2NO7ea+CueXi0RHMSqMhwgB7Osn6MS1WbXb9btamSGxleF/U7/\n", + "xwDMQRPzbgJlHq+pUgZaFaGt1Buhf/rULTuxf0onaEOVzpQTd7p2Y7sKt0p3aAdsW649eFyB7hA5\n", + "eYQ2UbCS6twKEB3IquXnBGir4iIMBzT0tGgAPBE6kHUG5KCDE4/P6+A2dXDdRFK6cdFUAo3r4Wdo\n", + "GKGpOlUZRnzd0rNqs9NR5VhwHDqYYZ7B6cDYjYHSY0KM/2ijg5eL2FR7p3KyCM0NpiqvPAmnHSAm\n", + "YHODV0UMCLRJpIMGNWk/16tgxnqvQNZtWI/StYoYDoWZG3c3gXgSV/kqQlMvBrivlY2pTxecQ6za\n", + "rPSgxoClAhnvV3ZTQa1aufCYsKjvyKYgO1ROFqGxp59KpfxMHci4TD3jqKI1Bz3cn7T/4cOH4/Zj\n", + "ykDisH4KK76e63U658gA5RAjdNGIczbqE4EKEh3QVITF/VV2k/tqyTr5ZOMQnXCf2CFy/dW4IzQ7\n", + "x1BFaKg3vrerdxKd8XkrcpIIreq889buelXegYzBpQDnorMp0Fx0kzBzxqP6gXpJ+OBHiJ1HVtGZ\n", + "i9bwetYtj9NU1LmdbVTRgHIclU1wPd1nFnhd5xC7evFcp4NOl5N5VF3bgU3pS21VXxW0Kpup7O7e\n", + "RmjsSTCNuLp8WYXYxLNk2g1SlarB7IA2maxdlMYpR1TcP2cUE7gp47pNUQDmMawmU+p5OqEnkRlH\n", + "aG7D45OlLNqIchJKH05P6jqGhrt+dZynzp4jtLQv165JJHaMPd76knPihSo4TferaGy6Kag5b+vg\n", + "5vqq2ocTmVMuU3UiFFHf1YYR3irUKoBMJ2W3n/fpIoOpOKA5EKn7T+ylivhw6+bDygRmm8LrK4c2\n", + "jcRX+o1ON1cOPF8727wJh3qrQPvyl798rWw6gTPtIihlNJMtBQc3BwFBwRMiB8wBDf/nI2/VYGE7\n", + "lOfO9uX/ksSU8+q+Kq8+21BjkX28uLi4dn43YVQfXb8RujhWDG4GWgdapf/sE/72Ev8s9CFAq5yd\n", + "6m+VdvrCfR7T6s9bZ58fPHhw5Qv/bGfm89jFxUU5f7INOU4XFxdX/tcp/s9TVd6dd6/+ScqXvvQl\n", + "e8yBbeodKlB1kFRQq34QyxCr9jkCqp5V5b1ZXBmDTAGtApuDXRUluSW18vQKZhOIuzFwk3KyXGK9\n", + "Yds48kuY4Y+9pzCbOl1sj4uiuAwjOlfG+q+glrDCKArhxh+DT8YC2zUB1iHbitx5hBYxg1mmDlgT\n", + "RUf4JQ0e58gAr8vBmj5Dw7p4ok+jNLWPhurAhsdU5KaOVcsOnLBoXG7ZUi1luv66CE1Jgqca9zxe\n", + "RWj7vl+J0BioDmxcruDGedXPaj/bnqkrw3p5hYG2nBuCLK/BP6LAf1Chi8zwXGWfbh/LVPSG56/I\n", + "vQFaB7WuLMUZCOfdNTjJMRSvojIFNK63muQuquF61GB3+Qp42VelW+wTfpKgIq+u/RNhmFU/oZku\n", + "ORFo7KC4f0+ePLlybAKvDnx4HPvo7KKzlS5CYyBfXFxcq5MfiyDAEGqpv+zbdMwq21O22G33aslZ\n", + "AW0FapO8i4ZUXl1XlXcQw2N57SRF6SDsjMEZR+URcauiM5zwl5eXz5+hYZu7/FR47NR9eAKxVBEd\n", + "R2jYN7SPKsqawMtt3MeVTemC9aYcAes0bXTlvtO5lvd2KwH1aKSC2L1ccn7lK1+5VsbgWom+KsFB\n", + "wzwrOweUr424+v868xr1jKyK2ro2qjKGgdp4yTmBGm8utGeAMcj4s4ZpvyJmY4hLqEqHCB1XtypT\n", + "S2sGNraX4VUBjqHlyrD97rlqpwPnKCpHwJEZLjU7eHbLTLRLnGPdNrXbPL4iJdC2bfupiPiTEfHF\n", + "fd8/8Kzsr0fEX4iI33t22l/Z9/0fquvdW041+OoYtaXcVx4Ay7I+5/0zz23IwapeAmDUxu3u9vHe\n", + "laFNQ3QHMJfnZQr3ld8CrgpDpBJ0OFWkUS051T04QsN+Kpi5h/uqDO/Z2TFGM268Kx0gGFnHeD7X\n", + "hW1GXTiYVc7IARiBxgGFKl9ZVaxIF6H9dET8zYj4O1C2R8SP7fv+Y13lFdA6qOWgR8yWcKwMfpCd\n", + "57GXx3K8Z7YlIsrlJue7qBPLUZSRsBesjEGBDFOXR2ArmF1cXDxPnzx5IsezE56I1TVq6Y/LJFxW\n", + "OZ1y/WrJiYB68uRJCTIGGjuvrh0IMIZZ9gehgjBS+sA6eC6oVQb2oYoOsR6WatWQH9YytNCOuWzl\n", + "8ciKlEDb9/3Xtm17r+rfpHL32cYhYToqXA2EmswMEjQiLOvyHI1NgOY21AHeyxnM1AAqkKkNz+OI\n", + "RS0381zVflfGk3AqOEY8Ofkh9STPesX+5rlcvxtnBtxUHww0hBnCIM91euh01gUKCmh4TyUVyBTQ\n", + "2HadPXd2feNLzkL+0rZt/25EfDwi/pN9339fndS9FOjA5iY6K2rbtucT9OnTtz4GTMlz1JvIPM4p\n", + "5hW8KrjhhMGJk3104iKyLlRXy8kE16NHj67BDMsw8uS/PvHkyZNrdVdRCZdhRIZQc4BD2OA1uPEk\n", + "n7SFJ28ez/HBKLCCGOdXhIHGMMtzIq7CKW2N9YL1sv5QWDc8b1Q9lf6UfSqgVXNV2bLbv+klp5K/\n", + "HRH/2bP8fx4RH4uIP69O7H4pUEUxmXakR6A9evRIvmbG6/AeVdSHA66emXVwywmSho9vQCfAZsOZ\n", + "PG9AmCG0Ms9pnq9eAjx58iQePXr0HGoYzfE44nhmXgFsNVJDXbHNKHtSKdfH5/CknjxWqIDmIh0V\n", + "lSHM3LW8oujuyaBS9VW2zvVW9sgvizgQqLYOZHcWoe37/kXo8E9ExP/ozv3EJz7xPP/KK6/EK6+8\n", + "UkZkXIYTwE0ON3grE6cL51fqOWY/ojaELmTnaE15O+UYOsPOtiqH4/rR9bM75iI6jrI6O+A6J/lJ\n", + "NLnanzzmbF1FYnzc1ckgQX0wYBKik005EKeziYNmoLGzZjtN+/z85z8fn//850f6Xwbatm3v2vf9\n", + "C892/0xEfNKd+x3f8R1X9t2A4nFzzzblydh5KpbJxMLzqgiz6+OknxXM0BBUBOegxobS6WkSQVd5\n", + "p+NJVLUCzC4aZHtRZZny5zf4iIIn7gR0auxdxDmBGJ+jXihU80OBSx3DiLKTmwBa9ZjlPe95T7zn\n", + "Pe95fr/f+I3fsG3pPtv4+Yj4UER8y7Ztn4uIvxYRH9627bvjzbedn4mIv+iur7yKSllJaqJ1MOuu\n", + "O1Qm0FoFWzfBKphVz9QqiHXRWNUnfIjurlP1HJJOpIriKv12DpIhxlsXvbmyym6yLhWxod4Ttnxt\n", + "2gf2A/ub46/6lvaBx/A+3bisAs3ZsbPXFenecn5UFP/UtHKnhM4jo3Te1UVl6rpVmURZK6BT/cT9\n", + "m4RZB7bKYFT73Xd2ri+HyDFwi9BLU5xoWd7l+boKbAy1yqYrgClbS72zLSfYsK4EUJY7qK1skzFQ\n", + "91H2O4Fa1Y6p3OovBfDNkZNqgqdMjbHzvBO4KcDgsZXI7JBopDKK6XKTP5ytojSnFwe1FbmNqIwF\n", + "J7nb72zFORLshxoXPNZFqB3AFNDwA1ucSwgtjNr4PsdAJO9RAcUFFB3IKkfNZTcaoR0rnUfncyup\n", + "IrGbiMx4QmA5G50qPwRqqo0uGnAGUH2XNl1+Vjpx/V/V66HpVBgqbC+ZOqBXERoCRE1i11bVlxWg\n", + "pXTP8dB2MaLDNlaRfgU0p+vKdhXMuEytFlzZitw60I4RNTDOI1SGOmmnAplqwyEAc8dW+9bBbPoy\n", + "QOmFJzNHZrjvdDp1IisQc7py5e7aylYULBTElON0bVaAQgB1QHP35jaoSLSK0DLqOgZorHOeb2hn\n", + "CmTKSVfXrcitLzlZVieDm3wdvKoJ2wlO2pVIrIMb51XbJiBjqKklp1qaOu/JMFP6wG+vFNR4cmFd\n", + "lR6mOnI6q85l25hs+OzIRWYIDtV/7Efl5CrAcT3O1hloCkR4jKO9KdA6veU5DkoV5DrwrcidR2g8\n", + "GXBgqsa7CYh1dMddG3lCT9vE9VTG2Rkt9yNTN/gcgVWRmfoGrTKWDtCq3RyFcN0TqFV5J5Px6QDG\n", + "+nAwUxN42tZJVMb53GedYprl+FZU9d1Bi99sKqBl/ZVec7+DmHOoHSynctIlZzURuo50HT9EIQpm\n", + "q5FYB4JJtOYmngJU9cV1tU10w33gXzsonaPeXB87qLnrDpUJyLKMYVZFaa6NlX2wTeH5eYxfpqkA\n", + "gPuVcHJvozuwKbipscF78s8IHbhWYcb3WZF7seR0EwSP3wbVXTTm2jKFm4JYBTalFzX5JktOBhpf\n", + "p3S00lcnDDOsczUS6yBYySE2xJOvghlPuq5fk0is029lK9nO/KE41+OA3W3uL32gU0OoYVsmKYOL\n", + "21qNZSUnfylQNdrB6VioVe1Sk7L7axrd8ax3Cjt3fhX13IRRrLQb76smnIOU6g+fMylTDkC1jdMJ\n", + "zCei+jg5h6M0zCuITNqBEHJ/yqqro4I9/l6Zy7CtCl4un/fF+1f5qZwMaOzB2cgm3rQDGd/DAUUZ\n", + "PqZoKGpbidacfhiO6U27+6q/8sHQcBMIIwwHzmmElvpCb451qP6qlPNqH8tWQKbEORLOd23Ee3OE\n", + "pACs7hURVyIeJ1x/Rurux/Td2DlHhW3PNNumQIfgciuESYTG+RU5eYQWMYvSKsBVyylsRw40GxkO\n", + "Grdn2+b/qHYCti4CYrCp+7PB4r2xjJcgCmo8Tl273Bih7jpwOZhVIHOTzpWpyTGZJFU7uzZiGxg6\n", + "3f266KyaS/mXLxBqbBvYp4lj4r6oiB/hlul0y+td9PzCAc01VhnfSrSG53NbXCTSGaD600AKYvxA\n", + "tgOCOw89X6ZssOqe1f0RYux1XVtVXagjt491qn66Y6yXKq/uN50czuGxHlz7JtLdQwlGOitw72BW\n", + "2X7Xbi7DPK4iOLjoXkxNYbYKtZMArYqGMN9FZi5Cq9qTA4D3qyZqhAYa1lUt9xgEbr+CWrapAqr6\n", + "+JXrdFDr2r3i2Ttoc5lKXZ7rdpNPTRB3PurB3W/S3k4q26x0xse5bNu2K3+XTDk9ZXNd+117VRnP\n", + "xeqzoYcPH8r5jPc8Jko7CdBwMDBKSFGQ6wCnIja8XzWx3L1TVpZ6VWTjIFFBLfuiIFotd3nJiRDD\n", + "+7tIlvcV0BTAHNQOgUQHus7Yu8gM61Rwr9p9E6L0xHbbpdu2XYvOpi+pDulPBTn1Bl6lVYTm4DaV\n", + "kwHNwSxlGp0pkDlPPIk03GRUD+FVGV6D9blJiWUIMN4OeQlRHWewTa9V46Sgpvp+E1DjtuP9Mt/Z\n", + "gpKqLW68lEwgi/1wUHM2pHSEfzq9ejHQtZ3bWM1NZU8dzKoPvKvAZUVOBjQ2TBVmTqIz932LagPC\n", + "aaXtDmgqXZm0HUQQcMpoq+Wnis4OAd/EETBglB5vOsX78v5kQlSgUv2t+o/3n0Kf++LawPdWbctn\n", + "rJPnZ1OwYZunkbD7RpK/l1QrKTe/V+XOgebors7LtFteVp9yZDvcpJwYmnuLqMq4DmVAaqI4mLk3\n", + "nW6ZOYVQJatAS3Fguw2ouQi/WrIwDFU7O5A5PXSRqls1qDzfp3JCEXHlP3U5G8F7VH1YaT/220GN\n", + "YaaAVs3dex+hVcpBmXSYv3XpqF55qCrvgKGgpvrd3edQmE2WoKr+leOHwFFB5JjUOQI34ZxT6yKl\n", + "qr+rzoEjnA5evL8yfvlCoHssoe416Udep4DHMOv+jFX+4YQJyF6IJWc3QapOTaI1p4Ru4lRlDmiu\n", + "rNODMnQFszwnIiTMKrBON4aP6/vqhFb9PQZiVdsqmHH/HFw6gKxIBbNKL6o93ZhG1B9+r/bDOQLX\n", + "x0wnkRn+eSu+Vwe4qdwq0JR0EZeDVPUtiwNfCg7KoZOrMii8j+szHlftnA6uCsW76KTSv2rnTYia\n", + "pJifOBgWjggmxo/XuPpdWyeiJn6VdzK1Nwc0d6zbn/av6281P91K6oUD2sXF9eqr71PcWxL1r61Y\n", + "USsK6CIBdc7EELp75xfSeL57tc0p/8Ng9ee2V/7KRuov28WOJNs30anSiXMgTsedLicwO2YiKKkc\n", + "b7Z7EomhqCgRj92kTB1uxPW+5kslbHN1D/dZBl/HOrtpuVWgZWiJcgjQ1PEV0kdcHcw0qA5sKs91\n", + "ZX3VvitXb4LUGyGEF0Nt8ue2K7hlu6qIt+qTMnY3kSqoOXFtqOyga3PVRrwWJx5O9HwsoM5V+929\n", + "+dhKBNWJq0vpScGMz3WiIrHuuXZ3j3sXod0E0CqYHRKdRXhYufA88yrlJU2WTfLVq20GFEdoq5GZ\n", + "23JMptHOBBI8oafLz65+BhpHlTgxDxE38TEyzLKc9AwMBbNJhOOO3RTgOrAdEuUqez40Qqvm0Iqc\n", + "DGgVwBzEuggtQlO9Mia3tFTHnTDUpin2dfJ2CKHGD1lVpMdG5oCmwKDg0MGMoxrU2wRwSq+cR91V\n", + "k/DQCZHXYn/UvflbRo76WabL0WPrmNyDRc0fjNK6+YTXTCJnZys3IS800FRY2xm0m2BuU9cq4cmn\n", + "2qOMpgIY7ncRmvt5yVRn1ZLTeWue9Or50EreAczpsoMa1nXoMysHdI7QVmHT2ZarcwWMnajo2+mx\n", + "c3Boa110xjBTzuNQOQnQFKymAHMG3Ck/4npYW4GMDbVStPNYPAF5vwKZSt1WLT2d51xZcnb9VTpe\n", + "hZrTa6XLyfFDhe2Eyw4VtyzH48rZTtuq6uqg2+lzmlaPAZwOOlnV+b2N0NwEVJ4Al04p1SBnugI0\n", + "lMpLZTqZeByhOYgx0FZeBjDQWH+T9uJWLYeyvhWo8bWr7VGTj8eqe07VSVXv5Gd0eC/Vnm5Zvtq2\n", + "VZk4iEl+4hQZ6FV0dkjf7n2EhrR3aWXQE1kBWqX8LOsintxchOaiMvXphnqpMHUGGKF1y4VKdwgy\n", + "1BGWcd4dc3rl8e4m1op00Qvv4/lq6ekgh7bj4Jbt4XZNYDeJ5pw9Z94FCRXsun3XDnaANyEn/Q5t\n", + "CjQ2ZgUMJZUyGVgKZPnBIg7QoTBT5d1LgG6ZWT1HY/BXQOu8M/ZX6VQt5fm425+ATDkxvEY5tUMm\n", + "yNR55TEHrgcPrr80wHZOYda1b0U654x6w/ZPHLPSucu7CM3J6jie9LONFaB1kJiImlgOaurPrkT4\n", + "h/+4P4Ew992BS70MmLwUUPByYJg4i07Hled3uuf9FajxeKgJdIzXZ/CoujA6Y4Ax1DgKmkC+gttU\n", + "uqjN9XMKMuX0qrZgfuIcV+VeA+1QZU4mD0Os+j2kkgpkFUAwVVFWF5lVIFNvOKtUGa/rX6bTybUy\n", + "CatnaLyvIjTVZlXvVBzEuBztRcEty/J4xNU/s81bFUE5uFYOVumE68ZzEMIYvVdzEccDZSXCxLl2\n", + "DMwibhlo6EmxzEVj6vmPMmzOO3ERAkKr+tNAmaolWooC2DSvIKaepXVbB3/st5o4CuBVdFXp3TkX\n", + "vi9PKNdu15fVSaQeM7i2V9DgutM+UIdufxrZoG6qyC1lJRhQ/UVBMOc5hwQUxzgXXimtyL35pYAq\n", + "Y0/cpWpCqrQDGKfZbjcoCDVlWFVU2kVhVVTmtgr21bJ7ssTpJrqLanic1LHJhFl1ZNxPd45qixJ2\n", + "EFOoTSDG+umcS9ZbPWpQDiIF4aU2bNdkXHicsb0TmKKuKsdTycmXnFW0FlErYmrY1RKz+5PaKqpA\n", + "o61g1m1VFKbA5j6gZQPGSNJNIBe5qHIWNwaVgVdREU5MFZ11Y10tZVR/XRvwPuq+zoGqicj7K3DG\n", + "P+Ve9SWlsgPWoQOM0gm30QHNjREHANW9FchwqT6Ve7HkdJHaTYibpApmDm4RcU3ZKTi4VZ9UH1ee\n", + "k1UvAFx0VoGM9aOgpvrJZV3qorFKj9WEUZPG7Xd51QZui7s/w6uL0lSdE+dcgSzrnb5Qw/uo1Yay\n", + "8Q5sru0KZpMAhG3jhVlyTiY8Kl9JZbBqicEgq2CGZWwYPOBV1MnwwWOTFwDT782U3iaTpHt+5qTy\n", + "0GqisrG6qKjasE7VRm5/BQPVHzXWDkS5z/pj0CXUHjx4EJeXl6WOqv6tRGgOaM4esM2cxz5jWyug\n", + "VTBz0arr26rcq2do6qXAxDhZYXysi8pcGQItnzeg8OAqsCkIZTqNzCZ/WaMzXGc8LjqrDMtFGqqM\n", + "AVZBbTU6475gn1QfJlBTWwUHBzBVxv3BFEUtOd2+itDYHtkZd2Dj86YptgnbyzBzcizMIk6w5Owg\n", + "hvspk4lWlavITIGuAhq+mkdho2eYMdCwrHoJsLL0VFsVwbBu3J9qVnVwZOEiF57wmHdl0+iM6+X+\n", + "cH5FHMhwfLFNFcA4cuP2T6Qbx2zT5E2nui/DC/Xn9O7KVCSGbe5gpoKS1TG8Fz99cvsR15eP00jC\n", + "XVPBy20JCL638uRqczBSX/5XbznVctN5Z9aF2meYKf2iVPByEKoAxh68A5mDGbeXx0pNpKpMQQ31\n", + "y49DJlCbgmzVYUfoJWfnGLjfKpri9rp8VZZ1VfWyPajrpnIvn6EpoPEbR5ZJhLYSmT19+ua/BcNz\n", + "qoneAUxFWwpm1eca7lmcm2xKLw7yrm+dh+yiKgUwvJajjWmEpmTSJxdBMMzU0k09p6yisnSE+A3a\n", + "5eVl2X6lF3densufOjGAJzB10dQKuNT1VdSm6nG2MpWTLjk7qLnojN98VIRX1ypIKZipj2+zrpQq\n", + "QqsiM04rsLk3m91bTtYF62WysVTQ6aKBCm7Tujup+oD35/uq+7uIGx+JcCSo7t+1/xBHjTKN0FSf\n", + "lVSRXCcTmKkxcDBfBdu9iNBcPiKuRGYJl/SGWba6BFEgc9FaFaFNJkAFMwW2KqKbgCzzLqI9BGJO\n", + "HHQ4gqmiM0yn0OqcF/ezu2/XN+d0+T4qSsvyKjJzfVDHVTunL4qOAdVEDoUZ13GMrH21dpaz3LIc\n", + "a9B/EOWss7fkzoH22c9+9q5veWfy27/926duwq3K7/7u7976PW4qWjhEPvOZz5zs3sfIVGef+tSn\n", + "brklp5cz0G5QXnagfe5zn7v1e5wy2rht27wtWE919ulPf/pW7n+f5LzkPMu9klNGaLcttwXrl1ln\n", + "q3IG2lnulZyfB63LWWdvyXaLXuOs5bOc5Sy3Ivu+y7D01oB2lrOc5Sx3Lecl51nOcpaXRs5AO8tZ\n", + "zvLSyJ0Bbdu2j2zb9ult235727a/fFf3vSvZtu2z27Z9Ytu2f7pt2z85dXuOlW3bfmrbtte3bfsk\n", + "lP3hbdt+Zdu2/3Pbtn+0bdu/dso2HiOmf39927bPPxvDf7pt20dO2cZDZdu2d2/b9qvbtv3v27b9\n", + "1rZt/+Gz8pdm/JzcCdC2bXsYEX8rIj4SEe+PiI9u2/ZH7+Ledyh7RHx43/fv2ff9g6duzA3IT8eb\n", + "44XyIxHxK/u+/xsR8T8/239RRfVvj4gfezaG37Pv+z88QbtuQh5HxH+87/t3RMT3R8S//2y+vUzj\n", + "J+WuIrQPRsQ/3/f9s/u+P46IvxcRf/qO7n2X8tJ8ELTv+69FxP9DxX8qIn7mWf5nIuLfudNG3aCY\n", + "/kW8BGO47/u/3Pf9nz3L/38R8amIeC1eovFzcldAey0i8DPzzz8re5lkj4h/vG3bx7dt+/dO3Zhb\n", + "klf3fX/9Wf71iHj1lI25JflL27b9b9u2/eTLsCTbtu29EfE9EfEb8Qdg/O4KaH8Qvg35Y/u+f09E\n", + "/Il4M8T/t07doNuU/c3vfV62cf3bEfG+iPjuiPhCRHzstM05TrZt+8aI+O8j4j/a9/1f4bGXdPzu\n", + "DGj/IiLeDfvvjjejtJdG9n3/wrP09yLiF+LNZfbLJq9v2/bOiIht294VEV88cXtuVPZ9/+L+TCLi\n", + "J+IFHsNt2x7FmzD7b/d9/8VnxS/1+EXcHdA+HhF/ZNu2927b9nUR8eci4pfu6N63Ltu2/aFt277p\n", + "Wf7tEfHHI+KT9VUvpPxSRPzQs/wPRcQvFue+cPJskqf8mXhBx3B788edPxkR/8e+7z8Oh17q8Yu4\n", + "w18KbNv2JyLixyPiYUT85L7v/8Wd3PgOZNu298WbUVnEm3808+++6P3btu3nI+JDEfEt8ebzlr8a\n", + "Ef9DRPz9iHhPRHw2Iv7svu+/f6o2HiOif38tIj4cby4394j4TET8RXjm9MLItm3/ZkT8rxHxiXhr\n", + "WflXIuKfxEsyfk7OP306y1nO8tLI+ZcCZznLWV4aOQPtLGc5y0sjZ6Cd5SxneWnkDLSznOUsL42c\n", + "gXaWs5zlpZEz0M5ylrO8NHIG2lnOcpaXRs5AO8tZzvLSyP8P5bdSohzrzUEAAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -1472,7 +1407,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": { "collapsed": false }, @@ -1481,16 +1416,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 13 s, sys: 134 ms, total: 13.1 s\n", - "Wall time: 13 s\n" + "Iteration 0 testing...\n", + "Iteration 25 testing...\n", + "Iteration 50 testing...\n", + "Iteration 75 testing...\n", + "Iteration 100 testing...\n", + "Iteration 125 testing...\n", + "Iteration 150 testing...\n", + "Iteration 175 testing...\n", + "CPU times: user 12.3 s, sys: 3.96 s, total: 16.2 s\n", + "Wall time: 15.7 s\n" ] } ], "source": [ "%%time\n", "niter = 200\n", + "test_interval = 25\n", "# losses will also be stored in the log\n", "train_loss = zeros(niter)\n", + "test_acc = zeros(int(np.ceil(niter / test_interval)))\n", "output = zeros((niter, 8, 10))\n", "\n", "# the main solver loop\n", @@ -1501,21 +1446,33 @@ " train_loss[it] = solver.net.blobs['loss'].data\n", " \n", " # store the output on the first test batch\n", - " # (start at conv1 to avoid loading new data)\n", + " # (start the forward pass at conv1 to avoid loading new data)\n", " solver.test_nets[0].forward(start='conv1')\n", - " output[it] = solver.test_nets[0].blobs['ip2'].data[:8]" + " output[it] = solver.test_nets[0].blobs['ip2'].data[:8]\n", + " \n", + " # run a full test every so often\n", + " # (Caffe can also do this for us and write to a log, but we show here\n", + " # how to do it directly in Python, where more complicated things are easier.)\n", + " if it % test_interval == 0:\n", + " print 'Iteration', it, 'testing...'\n", + " correct = 0\n", + " for test_it in range(100):\n", + " solver.test_nets[0].forward()\n", + " correct += sum(solver.test_nets[0].blobs['ip2'].data.argmax(1)\n", + " == solver.test_nets[0].blobs['label'].data)\n", + " test_acc[it // test_interval] = correct / 1e4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let's plot the train loss. (Normally we should plot the test loss as well, but we're only testing every 500 iterations, and loss drops very quickly for this example.)" + "Let's plot the train loss and test accuracy." ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": { "collapsed": false }, @@ -1523,258 +1480,340 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 18, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEPCAYAAACp/QjLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXncXGV5978XOyEJkIVsBMIuYZFoi6ioqS0tYMUVkde9\n", - "1q1ara+teyttfVvf2ipq0aJVXrAuRSyKFRRUYnFjDYFA2IRASCAhCQQCRAJe7x/XfZ45c+bM8jzP\n", - "nGfmmfl9P5/nM8/MnDnnmjPn3L/7Wu77NndHCCGEyLNDrw0QQgjRf0gchBBCNCBxEEII0YDEQQgh\n", - "RAMSByGEEA1IHIQQQjRQmTiY2UIzu9zMbjKzlWb27pJtlprZFjNbnv4+WpU9QgghOmenCve9HXiv\n", - "u19vZlOBa83sMndfVdjup+5+SoV2CCGEGCWVeQ7ufr+7X5/+3wqsAuaXbGpV2SCEEGJsTEjOwcwW\n", - "AUuAKwtvOfAcM1thZheb2eKJsEcIIURrqgwrAZBCShcA70keRJ7rgIXu/piZnQR8Bzi0apuEEEK0\n", - "xqqcW8nMdgb+G7jE3c/sYPu7gGe6++bC65oASgghxoC7jyl0X5nnYGYGfBm4uZkwmNkcYIO7u5kd\n", - "S4jV5rJtx/oFRSNmdoa7n9FrOwYBncvuovPZXcbTsa4yrPRc4LXADWa2PL32YWA/AHc/G3gl8A4z\n", - "exJ4DHh1hfYIIYTokMrEwd1/RpuEt7ufBZxVlQ1CCCHGhkZIDyfLem3AALGs1wYMGMt6bYAIKk1I\n", - "dwszc+UchBBidIyn7ZTnIIQQogGJgxBCiAYkDkIIIRqQOAghhGhA4iCEEKKBSSMOZpq9VQghJopJ\n", - "Iw7Anr02QAghhoXJJA7zem2AEEIMCxIHIYQQDUgchBBCNDCZxGFurw0QQohhYTKJgzwHIYSYICQO\n", - "QgghGpA4CCGEaGBSiYMZ082Y32tDhBBi0Jk06zmAPwE8DFzrzom9tkkIIfqdYVnP4ZPAnwBH9doQ\n", - "IYQYdCaN5+DuluZXehjYz50He22XEEL0M8PiOeCOAzcBR/TaFiGEGGQmlTgkJA5CCFExk1EcVgJH\n", - "9toIIYQYZCajOMhzEEKIipmM4iDPQQghKmYyisN9wM5m7NNrQ4QQYlCZdOKQKpZWotCSEEJUxqQT\n", - "h8Q1wHN6bYQQQgwqk1UcfgCc1GsjhBBiUJlUI6Rrz9kN2AAscmdz7ywTQoj+ZWhGSGe4sw24Ajih\n", - "17YIIcQgMinFIXEJCi0JIUQlTHpxMNPa0kII0W0mrTi482vgi8CNZpzea3uEEGKQmJQJ6fr3WAJc\n", - "RiSnt06sZUII0b8MXUI6jzvLgcuJhYCEEEJ0gcrEwcwWmtnlZnaTma00s3c32e6zZna7ma0wsyVj\n", - "PNw/A+81Y6exWyyEECKjSs9hO/Bedz8COA54p5kdnt/AzE4GDnb3Q4C3Al8Yy4HcuRJYC5wyPpOF\n", - "EEJAheLg7ve7+/Xp/63AKmB+YbNTgHPTNlcCe5nZnDEe8kvAG8b4WSGEEDkmJOdgZouAJcCVhbcW\n", - "AGtyz+8F9h3jYf4LeIEZs8b4eSGEEInKY/RmNhW4AHhP8iAaNik8Ly2fMrMzck+Xufuyug85j5hx\n", - "MXAqYwxPCSHEZMbMlgJLu7KvKktZzWxn4L+BS9z9zJL3/41o6L+Znt8CvMDd1xe266gcy4yTgY+6\n", - "a8ZWIYToy1JWMzPgy8DNZcKQuAh4fdr+OOChojCMksuAo82YPo59CCHE0FNlWOm5wGuBG8xseXrt\n", - "w8B+AO5+trtfbGYnm9kdwKPAm8ZzQHe2m/EAMAt4eDz7EkKIYWbSj5Bu3JargXe6c1XFZgkhRF/T\n", - "l2GlHrIJVLEkhBDjYRDFYSMws9dGCCHEZGZQxUGegxBCjINBFIdNyHMQQohxMYjiIM9BCCHGySCK\n", - "gxLSQggxTgZRHJSQFkKIcTKo4iDPQQghxsEgioPCSkIIMU4GVRxmmjXM9iqEEKJDBk4c3NkGPAFM\n", - "67UtQggxWRk4cUgoKS2EEONgkMVBeQchhBgjgyoOSkoLIcQ4GFRxUFhJCCHGwSCLwywz/tiMw3tt\n", - "jBBCTDYGVRw2AQcA5wIn9tgWIYSYdAyqOGwE3gJMBeb02BYhhJh0DKo4bAJ2AT4N7NNjW4QQYtIx\n", - "qOJwFfBe4OdIHIQQYtQMpDi4c5c7nwM2IHEQQohRM5DikEPiIIQQY2AoxEGT8AkhxOgYaHFw51HA\n", - "gT16bYsQQkwmBlocEgotCSHEKJE4CCGEaGBYxEED4YQQYhQMgzisR56DEEKMimEQB4WVhBBilEgc\n", - "hBBCNCBxEEII0YDEQQghRAMSByGEEA1IHIQQQjQwDOKwEZhhxo69NkQIISYLlYqDmX3FzNab2Y1N\n", - "3l9qZlvMbHn6+2i3bXDnSWAV8Mpu71sIIQaVqj2Hc2i/hvNP3X1J+vt4RXb8KfBZM+ZXtH8hhBgo\n", - "KhUHd78CeLDNZpVPp+3OVcAXgDOrPpYQQgwCvc45OPAcM1thZheb2eIKj/Vp4EQzpld4DCGEGAh6\n", - "LQ7XAQvd/enA54DvVHUgd7YAPwNOquoYQggxKOzUbgMzmwo87u5PmdlhwGHAJe6+fbwHd/dHcv9f\n", - "YmafN7MZ7r65xI4zck+XufuyMRzyQuBlwH+O4bNCCNHXmNlSYGlX9uXu7Q52HXA8sDfwc+Bq4Al3\n", - "f01HBzBbBHzP3Y8qeW8OsMHd3cyOBc5390Ul27m7jzs3YcYc4FZgrjvbxrs/IYToZ8bTdrb1HAgB\n", - "eczM3gx83t3/ycxWdGjYN4AXALPMbA3wMWBnAHc/mygvfYeZPQk8Brx6LF+iU9xZb8aNwAuBi6s8\n", - "lhBCTGY6EQfM7NnAa4A3p5c6ylW4++lt3j8LOKuTfXWRXwBHI3EQQoimdNLI/wXwIeBCd7/JzA4C\n", - "Lq/WrEpZBxrvIIQQrWibc6jb2GwHYKq7P1ydSaXH7UrOIfbFqcBp7hoxLYQYbMbTdrb1HMzsG2Y2\n", - "3cz2AFYCq8zs/WM5WJ+wDljQayOEEKKf6SSstDh5Ci8FLgEWAa+r0qiKWYvCSkII0ZJOxGEnM9uZ\n", - "EIfvpfENncei+o/7gLlm7GCGmTGt1wYJIUS/0Yk4nA2sBqYC/5PGLWypzqRqcec3wCPATGKwyBU9\n", - "NUgIIfqQUSWkAczMgJ26MUJ6FMfsWkI69scNRGjshcCngP3cWdOt/QshRD9QdUJ6LzP7tJlda2bX\n", - "Av8MTBnLwfqILCl9BLANzbckhBB1dBJW+grwMHAq8CoiJHNOlUZNAFlS+gjgXODk3pojhBD9RScj\n", - "pA9y95fnnp/R6fQZfUzmOSwG3ghcZcauKR8hhBBDTyeew+Nm9rzsiZkdT8yDNJlZBxwLPO7OrcQy\n", - "osf31iQhhOgfOvEc3g6cZ2Z7pucPAm+ozqQJYR1RqfTL9PxXwDHAj3tlkBBC9BNtxcHdrweONrPp\n", - "6fmETp1REeuIpPpN6fkjwB69M0cIIfqLpuJgZu/LPfXc6wa4u3+qSsMqZm16zMRhKzCjR7YIIUTf\n", - "0cpzmMbkHgndig3Ab6mJw6PAfr0zRwgh+oum4uDuZ0ygHROKO0+acR5wQ3rpURRWEkKIETpa7GcQ\n", - "cedNuadbkTgIIcQIHa3oNgQ8SswdJYQQAolDhsJKQgiRo21Yycx2A15BrOOQbe/u/ncV2jXRSByE\n", - "ECJHJzmH7wIPAdcSk9QNIso5CCFEjk7EYYG7/1HllvQW5RyEECJHJzmHX5jZ0ZVb0lsUVhJCiBxt\n", - "F/sxs1XAwcBdMDJrqbv7hAlGtxf7adw/uwBb3dmlqmMIIcREM562s5Ow0sAvhOPOE2k96V3ceaLX\n", - "9gghRK9pNbfS9DTJ3iBMtNcJWWhJ4iCEGHpaeQ7fAF4EXEf5HEsHVGJR78jE4cFeGyKEEL2m1dxK\n", - "L0qPiybMmt6yFdjDjN2BZ7vzk14bJIQQvaKjuZXMbG/gEGC37DV3/5+qjOoRWTnrs4HPEetLCyHE\n", - "UNLJCOm3AO8GFgLLgeOIFdReWK1pE04WVpoFzOuxLUII0VM6GefwHmK95dXu/nvAEmBLpVb1hmyU\n", - "9Gxg7xReEkKIoaQTcdjm7o9DzLPk7rcAh1VrVk/Iwkqz0nN5D0KIoaWTnMO9KefwHeAyM3sQWF2p\n", - "Vb0hH1aCEIc7e2eOEEL0jrbi4O4vTf+eYWbLgOnAD6o0qkfkw0q/Beb31hwhhOgdLcXBzHYCVrr7\n", - "0wDcfdlEGNUj8p7D7UgchBBDTMucg7s/CdxqZvtPkD29JMs5zCbWllbOQQgxtHSSkJ4B3GRmPzGz\n", - "76W/izrZuZl9xczWm9mNLbb5rJndbmYrzGxJp4ZXQN5zuAF5DkKIIaaThPRHgeKsfq2ncq1xDjGg\n", - "7LyyN83sZOBgdz/EzJ4FfIEYR9ELtlKrVroRWNojO4QQoud04jm8yN2X5f+AkzvZubtfQeu5ik4B\n", - "zk3bXgnsZWZzOtl3BTwKzAW2A79GYSUhxBDTiTicUPJaR+LQAQuANbnn9wL7dmnfo+VRYp3sB4D7\n", - "SGEls86mGBFCiEGiqTiY2TtSruAwM7sx97eaiMl3i7GGrLrNVmB/YCOwGdjdjD2B1WYs7JFNQgjR\n", - "E1r1ir8OXAJ8AvgAtUb8EXff1KXjr4W6hnff9FoDZnZG7umyCspqHwX2BDa642bcB7yN8G72pd7D\n", - "EUKIvsPMltKlfGmrKbu3EHMovbobB2rCRcC7gG+a2XHAQ+6+vok9Z1RoB4Q4QHgOAOuA9xFLo+5T\n", - "8bGFEGLcpE7zsuy5mX1srPuqNJ5uZt8AXgDMMrM1wMeAnQHc/Wx3v9jMTjazO4jG+U1V2tOGrenx\n", - "gfR4HzFt938RYx+EEGJoqFQc3P30DrZ5V5U2jIKi57AG+BqxTKo8ByHEUKFKnBpFcfhb4EngLcB+\n", - "PbFICCF6RCelrMNCJg4PALjzkDtb03N5DkKIoULikHDnKWAbNc8hYwMSByHEkCFxqOdRGsXhAZSQ\n", - "FkIMGRKHev6GxgV+5DkIIYYOc+/VgOTOMTN39+JI6gk6NrsQZa67uvds9LYQQoya8bSd8hza4M4T\n", - "wGPAXr22RQghJgqJQ2cotCSEGCokDp2hpLQQYqiQOHSGPAchxFAhceiMDchzEEIMERKHztAoaSHE\n", - "UCFx6AyFlYQQQ4XEoTOUkBZCDBUSh86Q5yCEGCokDp1xC3CUGc/vxcHN2NeMZ/bi2EKI4UTi0AHu\n", - "rAVOBy4w46gemPBi4L09OK4QYkiROHSIOz8C/ho4sweHn4Km7xBCTCASh9HxFeAAM443Y54Zp07Q\n", - "cSUOQogJRcuEjgJ3tpvxD8A/A3OA3YBvTcChJQ5CiAlFnsPoOQ/YGfhHYG8zpkzAMacAe0/AcYQQ\n", - "ApA4jBp3nnDnme58EVgNHDABh90DeQ5CiAlE4jA+7gQOnIDjTAGmpIWHhhIz9jDjs722Q4hhQeIw\n", - "Pu5kYjyHLHS15wQcq1+ZD7ym10YIMSxIHMbHRHoOMNyhpenA7r02QohhQeIwPiZaHIY5KT0N2M2M\n", - "nqwlLsSwIXEYHxMlDnsAmxhuz2EaYDC8eRchJhKJw/i4ixgUV3VvdgqwjuEWh+npUaElISYAicM4\n", - "cOcR4FFiQFyVSBzCcwCJgxATgsRh/NxFi9CSGdPM+Mg4vYspwFokDiBxEGJCkDiMn3Z5h2cDHwee\n", - "N45jZJ7DMCeks7DSbj21QoghQeIwfm4HFrd4/xiiYf/AWHZuxo7ArsD9yHMAeQ4iYcZ7zNij13YM\n", - "KhKH8fN94BUtwkZLgL8FjjHj6DHsf3fgceBBhkQczJhpxoWFlyUOoshfAYf02ohBReIwfq4iZrdd\n", - "0uT9JcCvgH8HXjuG/U8BHmOIxIEYDf17hdckDj3GDDPjL3ptR46pwMxeGzGoSBzGiTsOfJNYKa4O\n", - "M6YC+wGriMT1WKqaphAVUQ8xPOIwFdgzhdQypgNPoZxDL9kT+LRZ73+D5KlLHCpE4tAdvgG82qzh\n", - "fB4F3OzOdmIQ21gu5MxzGCZxyLyEvQqvPcAk8xzMeP4AjeqelR77YY6v3YAdkThURqXiYGYnmtkt\n", - "Zna7mTUkZM1sqZltMbPl6e+jVdpTFe6sJBrvYkXSEmB5+n+s4rAHNXEYlmqlqekx/32nAeuZROKQ\n", - "ROFi4PBe2zJWzHiWGe9MT2enx364DrNrZEZPrRhgKhMHM9sR+FfgRKKa53QzK7tJfuruS9Lfx6uy\n", - "ZwL4f8AbC691Qxx64jn0uLebeQ75Rmg6sIFJJA7E99iDyZ00PR744/R/Jg794MFm4iDPoSKq9ByO\n", - "Be5w99Xuvp2Iy7+kZLtBcbn/A3hpyjNgxq5EUvWa9P4mam55KWbsV/JyJg7bAJuIeK8ZuwNrzErz\n", - "KDubcWjFJpT1CidjWGlBeqz6fFXJAmBu+j+7fvvBc8g6EEMnDmYT852rFIcFwJrc83up3SwZDjzH\n", - "zFaY2cVm1mq8QF/jznrgf4BT00tnADcCV6fnDwLTC0nWEcyYD9xuxrzCW1OAR1Piu6X3YMbhZrx6\n", - "zF+ixknAZuBfSvb3fOCyij2LMs9hGuE59DwZOgrmp8fJLA77Uiuk6EfPYRjDSjeZjfwWlbFThfv2\n", - "Dra5Dljo7o+Z2UnAd2hyI5nZGbmny9x92bgt7D7nEA3qMcBpwNGpUcedp8zYQjR4G0s+uy8x4+i7\n", - "gI/kXs88B6iVs97f5PgvI8IA3xzn93gVcBZRYfX3hf3NISqwjgJuGOdxmlGXc0heGIQ4TjbP4T76\n", - "RBzM+AjwNXdWj+JjC4B9UqemnzyHqcR9MapedOp87eLO3ZVYVTHpd5hDeHMPNL5vS4Gl3ThWleKw\n", - "FliYe76Q8B5GcPdHcv9fYmafN7MZ7r65uDN3P6MqQ7vIRcQ5fRrwcnc2FN7P8g5l4jAPuAl4qxn/\n", - "4M6j6fW8OLRLSh8D4+tRpBGnJxIiNTXZlWef9HgK1YnDNGLgX/ZdpwOPpNcq7zF1kfnAMhrHbDRg\n", - "xpuBr7vzeIX2vBRYAaMWh6wqaDbhvTV4DmbMAA5yH/GUq2YqcDejDyu9PX3mXV23aGLIzn1piDp1\n", - "mpdlz83sY2M9UJVhpWuAQ8xskZntQvSkL8pvYGZzzMzS/8cCViYMkwV3fuvOBe583J1flGzSKu8w\n", - "D/gFcAX1ie2sWgnCY2hV+TJucQBeBFzpzsZ0vLmFEt05wE+AF4/zOK2YRoQkZ+SeP0yIw2TzHK4m\n", - "xmxMb7PtJ4hORZVMZxS9/vS7zwN+Tfzus4jpYsrCSicQMwFMFNMIcRhtWGkujeHtyUT2+1XeSapM\n", - "HNz9SUKdfwjcDPynu68ys7eZ2dvSZq8EbjSz64EzoSvx8n6mVcXSXCIEcT71Pc2853Am8BGzxgVv\n", - "UiJ8f8Z/0ZxAEnF3tgFbCzbvA3wbOLQkP9ItpgL3ULsRplHzHCZbzuFeokFtWrFkxs5Ewzu32TZd\n", - "YhqjyxfMJkR5NWHbbOK7lAnMdGgtgGa8tmQs0FjJrpG9RrnPuUQId7KSiWHL4pZuUOk4B3e/xN0P\n", - "c/eD3f0f02tnu/vZ6f+z3P1Idz/G3Z/j7r+q0p4+oJU4zCPE4VbqY9TZCGncWUbcnG/J3jRjakoO\n", - "H0UkwHc0G1lWdCzMI266jHXUh5b2IUKGPwBe3mwnqarpuDHakHkOxbDSNiaf57AWuI0Q07PNeH3J\n", - "dpmgV70uyDRGly/Yl7B/Pe09hz1pMTjOjL2Br9K97ziVCLM+2uq4JcxjcovD5PccRCkbaS0O9xM3\n", - "38G53lDecwD4ENStD/FN4C+IkNL1RJKq9MIxY4oZn8wleMuYTX2i6z5qVTcQ4rAe+AzwwVT2WsZx\n", - "wCVmY8prtfIcJpM4zCfE9Tbg9cBbgcNKtptbeOw66Xqayug8hwWE53M/nXkOrRrpY9Jjt8owpxFe\n", - "7eZR7nMuMKfM+54kDIbnIBpo6zm4j1zwWTK/ThzcWQ7sTK0hOYqYnfJZtBEH4JPAe6mV25axD9Ql\n", - "0u+j0XPY4M6viLxSNnoWM/6PGe9IT/clGqJntzhWM4rx5EmXc0iNcRYqvI1I8v+c8hj5nMJjFZSN\n", - "Om9H5vmsJyrUdiN+lzKBaRdWyiam7FajNpXoMGyiw7xD6lDNSZ+pKiRaNTOALchzGDjaJaTvS//f\n", - "Sq2HmU9IZ9wCHJZ67XOIcNJraSEOZpxMJJvfTH2DvpsZ1+dCUUXPoSyslInHR4D3m42MS3gJIVYQ\n", - "4rA9HbNoyxFmHFl8PcdU6sNKk9FzmA1scec3wC8JD+8syjsHc4DfUG3OIWu4RxtWyjyHI4nrt9ns\n", - "wNOJcTzN2pRnEOXt3fIcphKew2hmHtibuJfuoMtJ6dQxemY399mEvYnOhjyHAaP0Qk431D7Uxi/c\n", - "Rk0cimElCPF4GnAwsRLd3xPlhjfQ3HP4IOE1fA1YYMYz0usnAU8HFiaB2JG46TJGPIdU5mrUciA3\n", - "E1OWvzglp48gkuIQDcuFlIgDIVBvL3k9Yxr1YaV8zmG3ZMufVpgQ7wZZrxt3bnPndJqHFecSZcxd\n", - "9xzMRn6PsskM25F9h0wcHiDEoVlYyaDp4jtLgGvpXqM2lrDSXOK73Ev38w5LiQGiVTMDicNA0qyX\n", - "Mwt42J0n0vN8UrpMHG4hxOMw4FZ3fgYc7s7DlIhD6tkvAX7ozpPAv8HIvPxZhdiC9LkHsoF7iXzO\n", - "IQsp5d8/nxg090JCqLIpQDJxmJNroDIWAgeVnIeMaYTHsnuq5CkLK72TELZ+ZT5JHHI0C4HMIcYf\n", - "dFUczFgEXJmeTgOeYOwJ6dmEuG0hSnOLI+Qzz6Qh75A6HQcQMwh0M6yUeQ6dlrNmeb21dF8cZjAx\n", - "EyxmnoPCSgNGnTiY8SIzXkMtNp1R9BwepZ4s7HRo2hZ3bknvlXkOLwCudh8Rmc8DLzTjRUQs/Iek\n", - "kbDQMHAvH1Yqe/+7ROnty4GvAPunhmMBEZ++BDi58JmFhNczghkfNOPDuWVRszUs9qY8rDQTJsSN\n", - "HysLiHOXp1nnYC4hDt0OKy0CZifPdDoRqhtrQhqi47Cd+B2mFbbds/CY52iiQ7OO7oaVspzDaDyH\n", - "+xil52DGdDOua7PZTFovF9wtRjyHqifHlDhMLCNhhTQu4YvA+6jPN0B7zyELK42IQ44NNIrDCcBl\n", - "2RN3HiJ63t8mkqQ3kPMcCp/NJ6TnUBAHd7YQIzJfnvYH0QBl8epfAr9T2Oe+wKJCJdNr0neaSm0u\n", - "qSyEkR8hPVnEocxzaBYCmUOMBZrW5Sqa/Yh7fBqNoboRUt7pvJLPZ57DRuC31Eb2l83xNZ3w7sqS\n", - "0tnsxCM5t9Qxevoov0+eseQcxhpWWgAsafbbpEZ6BrB4AmYz3pu4J5+gUaC7isRhYtkEzEwX0PuB\n", - "nxEx+mdSLw6riXDM7pQnpO8iGp+n0ygOZZ5DnTgAuPNdoqf/BaIBaOY53AfMSzaXvQ/wn8QNdyvh\n", - "LRxILYdyI9SSz0kQsv3sl147OG2zgNpND9GYZp7Dw6ScQ5qZdlfgqLGUyprxdbPKQ1JZCCPPVmDn\n", - "kpl1sx7tRmrTk3SDrOJtJrVQ3ZSSc3YQ8DqzWq8/hSJ3IJLqTxHXVdZxaCYOayj3HJ5H5BvyOZc3\n", - "E4Ngx0o+59BpWCkTh9GGlWYXHstseZxIuO9jsZxqVVMTzSA6TQ9Qcd5B4jCBpMqVJ4jpzN8J/CVw\n", - "KfAmcg1JuhnvIkbVNngOybW/i6gdv7VwmDpxMGNfosFZXtgOd/7Mne9RmzG3wXNIoahtRCPdShxe\n", - "kHr79xBltVkI4ibgiFwVy7x0jFuohZZeRkwbMp9aCAniJphBY1hpZtrHGkpc+SZTn+d5erKxSmYQ\n", - "nYER0vkpi5HPIeL699PdvEMmDjOo9ey30NiAH5geD8i9lpVWZ/ml+6l5DmVJ6enEdVS3bzMOIzon\n", - "36C+Wm8/CjF6Mz5mxv/q5IsxtrBSJthlM0Rnxy+7dtoNUpyZ7LiZuB7fSqzvUgV7E4K4kYrzDhKH\n", - "iWcT8D3gf7uzhlgp7GDqPQeIeZZOpjysBNG4bqExDFT0HH4PuDwJTjOynlSzxj8LLZW+785T7tyZ\n", - "nt4NPJc0yWIKYW0m4t8QDdYaopwwLw5nEeKQ3fRQa4T2pFEcNhG90brQkhlzgduajRJPHtAB1Epu\n", - "qyKzsUhdaCmFKqanbdczhryDGTuYcYoZf114ayHRm80E9mHKG/YDC49Q62Vn3E/tt6/zHFKeaApx\n", - "HRXDSn8PfMqdB4kGLROH/WlM4B5O5zPYdhxWMuM9ZuxD7TutI7zh4vT5byQ6bkWy+6mZVzeD+F1X\n", - "Ed/hzTSGUruFPIcB5j7gPHfOTc9/QNzARXH4AvAOUgy+ZD+3ArcVKoegURyOJ3rlrcjCSmU5h8zm\n", - "TBzWt9lXnTgkVlI//uFeQhwOsljH4nCismnndJx8WOklRNhjRaq0+i1xk5eKA+Ft7Ur5TQ7R+9sN\n", - "Wo6zaEvqZbYKHWQNRpFiY7YP4WX9lrF7Dt8m1g/5cCFktR8Rdsx7X2UhoQOJcRYNnkPu+buA/07/\n", - "FwUma6gfgrrQ1LOJ6++z6aWNRFh1D0JEDiycw5l04AUkgd+DuC/ygpO9v4vZyOp1AH8N/BkpfJc8\n", - "+AfJNfbJjn2hobIO2nsO2W99M/CKbD8tZg8YE2l/OxCdRXkOA8jJRL4BAHceIKqF6nIH7lxL3Jy7\n", - "EmGdIlcTYwyKbCFKQLMpMo4nchutuJ+40ObR3HPYn+aeRZ570rb5ZGw+75B5Dr8mPIc3At9KZbxr\n", - "iZ5j3nM4FXhL6nlCeA8LaC4OmTdyfBP7DiRCbPuN9eZNobozaD2QqpnnUAwrZSElqM1hNBpbphBh\n", - "m+MJwc2H2RYSVVD5sFIzz+HnNHoOI+Lgzh25areiwOxJXHcjCWmLxWi+CbwzN/38FkJIDiQ6Eeuo\n", - "L2nuSBwIL2Vb8obLGsmjgXNT7H9msultxO+VeUP3FI49n5huf1HJ8WYT4tnMc8h+61VESfd/EPdz\n", - "t6uX9gYeTB3CBlHsNhKHCcadzamXmH/tpDQtRpGzgMeL26fPfNu9cU76/IVjMcf+Qtqsu5ByA5uI\n", - "3n2Z5/B14B+Im66dOGSLqHTiORwK/CnwpfTeOqJEN/MclgOfcOf7uX1tS/vIxGFx+p4ZBxGLSD2v\n", - "iX0HEl4InNAgAAAUlUlEQVTX7Yz95s3yFfNbbNPMcyhWLOXDN9kcRqPhd4GVqeG+njSHUUoo70yc\n", - "5ywhnXkOZeLwI+rFoSyhnlEcJV2Wz/gqsT7FhdlG6TreTFQv3UMtDJPRqTjkixa20jjZ5Czi/M8h\n", - "rrHriTDsNGqCfTnwh7nPZB7DopLjzU62duI5AJxHdIi6HbrMX1MPEGXK7zbjTV0+DiBx6HfOBz46\n", - "hs9loaXnEGszPNnBZ9bSxHNIjfPriOulWJ5ZpJk4lHkOTyMalWyd7bXptUfScb/tzocK+x/xHNI8\n", - "VD8g1grJOJi4OY9rEvY5kBisN56bN5ttttRzKLj/RYphpXF5DtR7hitgpDw0O8+Zp5KJQ13DnsvB\n", - "/JgWnkOBosDUiUMq034BNORASPY8g7hOysShk97wiDikzlAx/p79fyTR2bgN+Fdgfa6j9d/Uj95f\n", - "RDTui0qON5u4htuJw73AS91ZSXTIju7gu4yGLBkN0QF8ITGFzd+Z1a0B0xUkDn2MO79x51Nj+OgD\n", - "hAv8XNqHlDKyRr/Mc8CdS4F90iJArbgfeJJ6cVhF5Bd2Ia0ImEIN9wFfyuVNip5DGY9T8xwAzgXe\n", - "kHv/IGJU8FrKb84DiUqvvGCNlmcRPdFmYaUZwOaSfBC0DyuN1nPIi8P11MRhP0IcslLPrAEvNuxz\n", - "CdFYScTJ81VlzTyHZuKQhZX2B+5u0inZSIjDPURjfDiMLAW7B008B6tfMzkrY83vM/9+Jg5HkGYR\n", - "IHJa+cGYvwAOyE3Bsgj4KTH+pjhWYR+i6q5lWMkdTyXiUJ3nkIVXHyCS3n8J/AHw6VSM0TUkDoPJ\n", - "j4iFgV5MxJI7YS3wWC4+3EBZeKtkm6dgZN2J7LVthECcTDTsa9Jbfw4jiXkIcdiHWs6hjEwcsh7U\n", - "pcQNnY0oP5gIpVxBeWjpAMbhOaTpPJ5BrHfeLKw0k/KQEuTCSikU8lpqU1xkY0Q6tWVHYtbbbNXB\n", - "FcDTU+O2kGiAW3oO6Xh3prDU5tx3auU5FJcALoaVFtF8KdJNRFgp8xyy0N5MmqwJnTyRu3KD5vIV\n", - "bdDoOcxOto+IQ1qlcUW2QRKuS6kJxv7E+XuSxrBbp55Dnhtp4zmYcYIZ57TapkDec1gO/DPwH+7c\n", - "SghtV9cqlzgMIO58gqgQmUet4WnHWpp4DWM4/gnuDQ3L+4DPUbtxs7BRvgeYeS+txCGfc8hu8q8B\n", - "r0+5hx3SexcBf1FSt94yrGTGc9t8vaOIhm8VrT2HsmQ01IeVPkX09rO4/J3EzKZls+qebsYfFF4+\n", - "ggiVbICR4obHCK8hCytlYpQXh3zjd1A6bnb8TJyK1Up5bqF+SdO8OEyntThspLb+8yrgaclbmZle\n", - "27VkJPLLCa8iKzLI5xyyfRY9h2XUwkrFsUAZ36cWWspsvptcaCkJ7Sxaew5l4rCWGPDYKkx4HKMb\n", - "5T/iObhzjzt/lfNO76S+2mzcSBwGFHf+DZjt3rKhzbOW9snm8dhzOZEf2NAiB5LNRdQurFSsBDqX\n", - "yIkcCtyR3PvvEwL5EzPON+NnZiPluvcSveq6tZ3NmAX8zKzl/EPHEYK7jrF5DpuAGanM80TgHdkN\n", - "nh6vI9dgmLGjGZ8jFlf6v4V9PZ9Gz3AFkZTOi0OrsFImlhDhtgOTd7Q3NA0h3gtMzZ2nPamFldp5\n", - "Dtk+70lTr2wlhGhmeq9sipHXE9fOc9LzYlipWL49iwgRHZG+3x1NbLmEmGNsCikUluxelNtmL0Jw\n", - "11Kbp6pIQ2Va+i1HOiDpdyyOvVlMnO9Op9zIew5FRoTdjD8x4yUd7rMpEocBppMwUI5riBuwSv4S\n", - "RhYDKqMTz+Hx9DhyM7pzA3HTvJlcQ+DOp4EPEz3Em4BvEfmOp9LN+2vqyxmzsEWrHtix1HIaI55D\n", - "Kpv829TrbeU5ZI3fa4h8y8OF94vluacQPebDCFHJD656BWm97xwriCKGE6gXh5ZhpfR/1vvMxl6U\n", - "DpxM5y6/5show0pOLbS4mmiYswa2bs2TVDb8DGIFxEwc2oWVZiX7Hk/fozRUmvJn1xChpYWUi0M2\n", - "U/ET6ZhlU3U0q0y7gZp3eho0zF+1mPCIZqWBjL8yqwvXYcYf5gbrzW9yHEjCnv7/Y2i52mNHSBwE\n", - "AO6sdOdvKj7GljRdRzOyMEY7zwEaG99ziWlIfl045vlpwOF7iUbvztzb+VHaUFvKspU4PINowNcR\n", - "62Jkvb7fAf6G8F6aNRaZ3fsQ8wr9Z8n711AvDn8CfCaN8/gSUa+fNZpHE73fPJ9Lfx8gpsjO5qfK\n", - "GtSi53AYNUG9lRDIVsnojHxoaTr14xwW0dpzuC83Pf3d1ItDNlBuRzP+hJic8tuE6E1LgyY7CStt\n", - "JPIEzUJKGRcQua+H3HmcJuKQ/l9PeWip2e+dzzv8LrkwZqqkO4Q4jwekv2dBrTrPjIOIMVBvSOGp\n", - "l8FIwrtIPqx0NG3K1ztB4iD6hnRzPkhnnkPxZvx6eiwNIaSE62nEWhYZRc/hmHT8EXEw41Qzlpsx\n", - "NZWoHkI0OlmPP5sZ843p8RCaD4DL7J5FeDBltl5LmnohVdIcTzRgEBMlvjKFv04DLkyjffPfc507\n", - "57nzNXe25abYzgaNjXgOqYE6EkYStZcS060sonm+IeMWamWomefwOIw0equbfG4jEdLLKIpDlpP5\n", - "I8LruxT4cPJWfkl4D52ElTYS3mJxYsoi/0Wc46wE+26iautPU3nobGrh1g0UktKpc9As3JPPax1D\n", - "LWQH0cu/n7iWDiR+h6uA06y2/slriPDYx4G/A76Wptwp4860/6mEh9EslNYxVc0cKMRYWU3zXjdE\n", - "Qvrh1OiN4M56Mz4D/KrZB9Oo82tzL91B9OgyjiHmvToAwIyPEGWyTxFlwZuJypffpPcz7+E3RGP9\n", - "baJhnEGuWqtgwzYzHqPca4AQrCwp/Trgv7KkvTv3m/F5Itm6AzQOgmzCZhiZVmMTMXPoDoTXsC4L\n", - "bbmz0YwVRKPUznNYleyDJA7uuBlbiFBJs2lWfkS9cNxNNKBbicZ3BrUE+vfdOTO37c+J3vM86kOg\n", - "I2Gl9L2ysN6naNMBdmeDGT+l5h2sJnJBxyab/onWnsN0YqDqdhpZSQzS3Im4th6hNghzMVFhdBdx\n", - "vRkhBD8BPm7G64nf4XXAu4m8S6tKtnXpe/8OsKrDsU0tkecg+o0TqPVky3icJr1yd97nPjJKtRNG\n", - "PAeLOYkOJgZHZZ7DqUSp6flEj/oZ1M9uu5bopb042fwj2nsOEA3AN5t8BycELFvW9d8Lm3yUiF3v\n", - "SjQmnbAZRgRgE9HYHUltnYU8303fpxPPIR9Wyjyph4kxDmVjPHDncXduzL1U5jnMSvu+pfDxZYQ4\n", - "XEnMPZaRDyvtBWx1Z7s7d7tzV5vvARGGy8TmVsJDO5oYYf771IvDfIv1orOGumkIMRWD3E8MVnuc\n", - "6LhkeZqiOBxJeDr/SIT2ziME42qi0u/UkgrA/LF+S5zLU+hCSAkkDqLPcI/BRC02aSoOYyCfc1hM\n", - "9PZvIQZH7U7kD24gGqWlNDam64ik9NuBc9LnM8+hqffjzotbhAcgBrWdCLzOnV8WPuvu/BNwSLOE\n", - "cQmbqQ/V/YRo9JqJw460F4c7iPElO1OrVoLIPazu0C5oTEhnaz48jfBORnDnV8De7nyoUIWXDytl\n", - "IaWOcedC9xhv4M5j7rwjlQVfQJTRZuKwgZhT669gZGK/VsUHENfP64iS5XwSfzEhBpk4HEFMg/Iw\n", - "sfztC4gxDO7OeveRSQ9bcSfwUqgT3zEjcRCTjW6KwxqiPHF3wu1fQdysi4je261pAN8viZ7d82j0\n", - "HP6YuOHPpyYO7TyHdpwBHOnOj5ptMMpKtE1QVxX1Y6I32yAOKQ9yM23EIYXW1hDimvccRisOzXIO\n", - "ZZ5Ddtwim4my5J0Ygzi04ALCe8jE4XrCw/jf1IoGWpUtQzTUL6dRHI4gzvOdRCfkUJIYurOWuB4/\n", - "MUp7M6GR5yCGkm10SRxSz/tu4oZaAlyf4vuPEuWN16btthFVRIuJmzxjLRF6+kyqvrmXSE7mR3CP\n", - "xS5v4z2NlqLncDkxRqLMc4DofRaroMpYSYSgimGl1Z0aljyA3xCNZiYOhxKNcrvp4bN9PEVUYc2g\n", - "u+JwJSGA2SDD77lzGpH7yEqKOxGHKeTEISWNs0qlu4ky2rVem/U2m6DziZL9tSKrxOuKOCghLSYb\n", - "q+lup+YOohf4KiLUAtEDO5UYeJZxOTC/EM5YRzSGX4TozZtxJ9ErHLM4VMBmcovwuPOAGauJQZIN\n", - "DbB7eTK9hPcTIap51MThCjoflZ9xN9FT3kSI6+8A141SILPQUtfEISXYT6Kx8ucmIqQ2lRgUubLF\n", - "brKGejnR6TiMKLn+QXYtpcKGm7pg8l3EINOuDGaVOIhJhXt5Incc/JoYefx995Gb/C5CLPKVTedT\n", - "m/Qs48fAKwsD2W4HDkxluf3CRhrnC/oxtRDHmHDndjN+jwh/ZDPpfnIMu8rEIVv+cmdKQkptyNY3\n", - "6KbngHtjo+3OE2bcRBQovAIapjXJcwcxBufXxOC/3YgxKKfmtskmghwvvwT+pQv7ASQOQtxBVLjk\n", - "p5e+C9hOzj13ZxWNCdLNwGWF/d1OdUtEjpVzoGFho8/TfK6gjkk5ileOczd3k8qTzUZChqMVh8xz\n", - "aLaaYbe5hlgH/iH35ramktI3Zs/NuA14olBocBnUFx6MBXfWEaW3XUHiIIad7wBrUhIw4y6icqQs\n", - "+dmO2+mvkFK2jvdDhdfuoAsDpbrE3dTySA8SPexVzTcvJR9WGu1nx8K1RJnx347yc98iylNHcOfv\n", - "umVUN5E4iKHGnXuoH7ELkYxtV8rZjKupD0eJ9qymNsvuU2ZsZvSewxpiZbdd6WJYqQXZAlUXtNyq\n", - "gHvD5Il9i7l3syiiGszM3b3TmQuFEJMIM/YGnucekwiasZgY5dtx45RmPP0+MT7gePeRNS4qIZXN\n", - "/jlwZpcry7rKeNpOiYMQYiBI1UOfAd6fRoIPPRIHIYQQDYyn7dQgOCGEEA1UKg5mdqKZ3WJmt5vZ\n", - "B5ps89n0/gozW1KlPUIIITqjMnEwsx2BfyUmEFsMnG5mhxe2ORk42N0PAd5K/UyLoiLMbGmvbRgU\n", - "dC67i85n/1Cl53AscIe7r3b37cQUxcV1TU8hRg/i7lcCe5lZqwW5RXdY2msDBoilvTZgwFjaawNE\n", - "UKU4LIC6aYnvJbfmbott9q3QJiGEEB1QpTh0WgZVzKT3f/mUEEIMOFWOkF5LTEWbsZDwDFpts296\n", - "rQEzk2h0ETP7WK9tGBR0LruLzmd/UKU4XAMcYmaLiKmNTwNOL2xzEbEO7jfN7DjgIXcvmUJYYxyE\n", - "EGIiqUwc3P1JM3sX8ENi2cEvu/sqM3tbev9sd7/YzE42szuIuc7fVJU9QgghOmdSjJAWQggxsfT1\n", - "COlOBtGJ1pjZajO7wcyWm9lV6bUZZnaZmd1mZpea2V69trNfMbOvmNl6M7sx91rT82dmH0rX6y1m\n", - "9oe9sbo/aXIuzzCze9P1udzMTsq9p3PZAjNbaGaXm9lNZrbSzN6dXu/K9dm34tDJIDrREQ4sdfcl\n", - "7n5seu2DwGXufiixItgHe2Zd/3MOcQ3mKT1/ZraYyK0tTp/5vJn17T3WA8rOpQOfStfnEne/BHQu\n", - "O2Q78F53P4JYrvSdqY3syvXZzye7k0F0ojOKCf2RwYfp8aUTa87kwd2voHF50Gbn7yXAN9x9u7uv\n", - "JhbTORYBND2X0Hh9gs5lW9z9fne/Pv2/lVjkaAFduj77WRw6GUQn2uPAj8zsGjN7S3ptTq4qbD2g\n", - "Uemjo9n5m099ubau2c748zS32pdzIRCdy1GQqkKXAFfSpeuzn8VBmfLu8Fx3XwKcRLidz8u/6VGR\n", - "oHM9Rjo4fzq3rfkCcABwDLH63r+02FbnsgQzmwp8G3iPuz+Sf28812c/i0Mng+hEG9z9vvT4AHAh\n", - "4UauN7O5AGY2D9jQOwsnJc3OX8eDOkXg7hs8QazJnIU5dC47wMx2JoThq+7+nfRyV67PfhaHkUF0\n", - "ZrYLkUi5qMc2TSrMbIqZTUv/70GssXsjcR7fkDZ7A/Cd8j2IJjQ7fxcBrzazXczsAOAQ4Koe2Ddp\n", - "SI1XxsuI6xN0LttiZgZ8GbjZ3c/MvdWV67PKEdLjotkguh6bNdmYA1wY1xA7AV9z90vN7BrgfDN7\n", - "M7G4+6t6Z2J/Y2bfINYlnmVma4C/AT5Byflz95vN7HzgZuBJ4M9cA4lGKDmXHwOWmtkxRHjjLiAb\n", - "JKtz2Z7nAq8FbjCz5em1D9Gl61OD4IQQQjTQz2ElIYQQPULiIIQQogGJgxBCiAYkDkIIIRqQOAgh\n", - "hGhA4iCEEKIBiYMYKszs5+lxfzMrrkw43n1/uOxYQkxGNM5BDCVmthR4n7u/eBSf2cndn2zx/iPu\n", - "Pq0b9gnRa+Q5iKHCzLamfz8BPC8tMPMeM9vBzD5pZlelGULfmrZfamZXmNl3gZXpte+kWW5XZjPd\n", - "mtkngN3T/r6aP5YFnzSzGy0WXnpVbt/LzOxbZrbKzP5jYs+GEM3p2+kzhKiIzFX+APCXmeeQxOAh\n", - "dz/WzHYFfmZml6ZtlwBHuPvd6fmb3P1BM9sduMrMLnD3D5rZO9MMuMVjvRx4OnA0MBu42sz+J713\n", - "DLH4yn3Az83sue6ucJToOfIcxLBSXGDmD4HXpzlqfgXMAA5O712VEwaA95jZ9cAviVkuD2lzrOOB\n", - "r6fJRzcAPwV+lxCPq9x9XZrj5npg0Ti+kxBdQ56DEDXe5e6X5V9IuYlHC89/HzjO3beZ2eXAbm32\n", - "6zSKUeZV/Cb32lPonhR9gjwHMaw8AuSTxz8E/szMdgIws0PNbErJ56YDDyZheBqxdm/G9uzzBa4A\n", - "Tkt5jdnA84mpksuWxxSiL1AvRQwbWY99BfBUCg+dA3yWCOlcl+bJ30CsL1BcSesHwNvN7GbgViK0\n", - "lPFFYvrka939ddnn3P1CM3t2OqYDf+XuG9Ji8MVyQZUPir5ApaxCCCEaUFhJCCFEAxIHIYQQDUgc\n", - "hBBCNCBxEEII0YDEQQghRAMSByGEEA1IHIQQQjQgcRBCCNHA/webgPPorxOoYAAAAABJRU5ErkJg\n", - "gg==\n" + "iVBORw0KGgoAAAANSUhEUgAAAaAAAAEPCAYAAAAEfBBiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXm4HGWV/z9fwhK2JIRAgCTsYYkswsgiiwYBRVRwGxV1\n", + "dNRxcEGZUcdtVBhHZ3Abcf8xiruCjguigohIANmXQBISIAECYd9CSFgTOL8/zlvpun2r+1bf23V7\n", + "uefzPP10d9XbVe+t2/1+65z3vOfIzAiCIAiC0WadTncgCIIgGJuEAAVBEAQdIQQoCIIg6AghQEEQ\n", + "BEFHCAEKgiAIOkIIUBAEQdARKhMgSTMkXSjpRkkLJH2woM1sSSskzU2PT1XVnyAIgrGOpO9Lul/S\n", + "/CZtvi5psaQbJO1TZX/WrfDYq4F/NbPrJW0CXCvpfDNbVNfuIjM7psJ+BEEQBM4PgG8APy7aKelo\n", + "YGczmynpAOA7wIFVdaYyC8jM7jOz69PrVcAiYJuCpqqqD0EQBEENM7sEWN6kyTHAj1LbK4FJkqZW\n", + "1Z9RmQOStD2wD3Bl3S4DDkqm3jmSZo1Gf4IgCIJCpgHLcu/vAqZXdbIqXXAAJPfbr4ATkyWU5zpg\n", + "hpk9IenlwFnALlX3KQiCIGhIvVeqsnxtlQqQpPWAXwM/NbOz6veb2crc63MlfVvSZDN7pO44kbAu\n", + "CIJgGJhZK9McdwMzcu+np22VUJkASRJwOrDQzE5t0GYq8ICZmaT9AdWLT0aLFzFogqSTzezkTvej\n", + "H4hr2V7ieraXYdy8nw2cAJwp6UDgUTO7v/09c6q0gA4G3grMkzQ3bfsksC2AmZ0GvB54r6Q1wBPA\n", + "myrsTxAEwZhG0hnAi4EpkpYBJwHrgY/JZnaOpKMlLQEeB95RZX8qEyAz+xtDBDmY2beAb1XVhyAI\n", + "gqCGmR1Xos0Jo9EXiEwIY5U5ne5AHzGn0x3oM+Z0ugPB6KFeKEgnyWIOKAiCoDW6fewMCygIgiDo\n", + "CCFAQRAEQUcIAQqCIAg6QghQEARB0BFCgIIgCIKOEAIUBEEQdIQQoCAIgqAjhAAFQRCURdoAaQuk\n", + "8Z3uSj9QeTmGIAg6iCcF3hjP9/UU8DRmz3W2U6OMX4PxwITcY2Ld+0aP+nbrACuA1wEXjeaf0Y/0\n", + "TCYEsPXMWNPpvgTBqOKD50bApBYem+VeTwSeAVYDG+AD8WpcjBo9nh5i/0jbrKHMwFP720cqGhOA\n", + "Z3HheKzko1Hbp0v1vUvo9kwIvSRAJ5nx2U73JQhaonb33UggyjzWAI82eSxvsm8FZs/U9Wd9amLU\n", + "6DHU/pG0WYfGIrUeNdHYNO0fjlDkHysxe7r5P6o/CQFqA0mAVgHTzHis0/0Jxjju/98F2B3YgaEF\n", + "5TmaC0gzMVnRd4OntC4DhSl7vSFunWWishKz8HqMgG4XoF6aA7oB2A+4oNMdCcYI0kRcZOof04Db\n", + "gEXp+RHgdorFZAVmT41637sZF5U1eL2ZYAzTSwJ0BfBCQoCCduIuqakMFJhZ6XkCcBMuNIvwCr8u\n", + "OmarO9LfIOgjekmALqfi6nxBHyOtA2xPsUXzLC4sC9PzH9LzXWMuYizoeyQdBZwKjAO+Z2ZfqNu/\n", + "GfB9YEd8Xu6dZnZjJX3poTmgacA8YAszur/TQWeQ1gdmMlhkdgEepmbN1B5mD3ams0FQLfVzQJLG\n", + "ATcDRwB3A1cDx5nZolybLwGPmdl/StoV+JaZHVFF/3rGAjLjHokngJ2BxZ3uT9BhpE2A3RjsNtsO\n", + "uIOawPwJ+CpwE2YrO9PZIOga9geWmNlSAElnAsfiv5WM3YFTAMzsZknbS9rCKrhR6xkBSlyOzwOF\n", + "AI0VpC0odptNAW6hJjQ/w11oS/ouaiwI2sc0YFnu/V3AAXVtbgBeC/xN0v74Td10YMwLUBaI8ONO\n", + "dySoAHefHQgcCbwIt2rWoyYyC4Hz0+s7MHu2Qz0Ngq5E0mxgdpMmZaYvTgG+JmkuMB+Yi8+Ttp1e\n", + "E6BrgDd2uhNBm/AItN1xwTkSOBS3bs8HPo9/+e/rpZXnQdBJzGwOMCd7L+mkuiZ3AzNy72fgVlD+\n", + "GCuBd+aOcTu+3KDt9JoAzQP2kFjHjIhO6kWkLfEJ0Ex0ngX+jFu1/4jZQx3sXRD0O9cAMyVtD9yD\n", + "39Afl28gX//2pJk9I+ndwEVmtqqKzvSUAJmxQuIhYCdiHqg3kDYEDsHF5qV4KPQc3Mr5b2BxWDhB\n", + "MDqY2RpJJwDn4WHYp5vZIknHp/2n4a7vH3r0MQuAd1XVn54Jw85CCSXOBn5kxq873K2gCF9vszc1\n", + "C+dA3HL9My46V0V6lSAYHSIVT/u5AdgLQoC6Bmk6NcE5Ak9Bcz7wTeD1mK3oYO+CIOhSelGA5gFv\n", + "6XQnxjTSpnikTSY6W+Apks4HPoHZHZ3rXBAEvUIvuuB2Bc41Y8cOd2vs4NmLX0BNcPbBV1BnbrW5\n", + "kbImCLqPbnfB9aIAjcNTtW8dpRkqRNqJmuC8BF+8dn56XIzZEx3sXRAEJeh2Aeo5F5wZz0rcCOwB\n", + "XNbp/vQN0mRcaDLR2RAXm7OAEzC7t4O9C4KgD+k5AUpcARxOCNDw8awDL6QmOLsDf8NF5xvAjREe\n", + "HQRBlfScC87fcxBem2VWZMZuAWka8DrgZXjWgZupudUuixxqQdBfdLsLrlcFSHhqiNeaMbdzPesB\n", + "pM2B1+OrnfcCzgbOAS7A7OFOdi0IgmrpdgHqSRecGSbxc+DNEAI0CC9VcCwuOofiJQlOBf4U5aGD\n", + "IOgWetIC8m3MwsOAt428cIC0AfByXHSOwudzfg6cHXVwgmBsEhZQRZixUOIZvCjZwk73pyP4+pzD\n", + "cNF5Nb5I9wzgfeFeC4Kg21mnqgNLmiHpQkk3Slog6YMN2n1d0mJJN0jap8XTXAocNPLe9hCSkA5C\n", + "+gaeRv2/8ISBe2I2G7PTQnyCIOgFqrSAVgP/ambXy+ckrpV0fl3t8aOBnc1spqQDgO/gySvLchku\n", + "QN9rZ8e7Dq+bsxdu6bwJeAK3dA7FLLKCB0HQk1QmQGZ2H3Bfer1K0iJgGwbWHj8G+FFqc6WkSZKm\n", + "mtn9JU9zKfAvbex2dyHtjAvOccDGQFa/fV6s0QmCoNcZlTmgVPxoH+DKul1F9cmnA2UF6EZgK4kp\n", + "ZvRHITNpG2pForYF/g94N3B5iE4QBP1E5QKU3G+/Ak5sUFWvPkKjcJCVdHLu7Rwzm5PS8lyBu+HO\n", + "bkd/O4Kv1XkdLjp74+lv/h24MGrnBEHQr1QqQJLWw+v2/NTMzipoUl+ffHraNggzO7nBaS4DXkSv\n", + "CVDxWp2vEWt1giCoEElH4esCxwHfM7Mv1O2fAvwU2ArXiC+b2Q+r6EuVUXDC0+UsNLNTGzQ7G3hb\n", + "an8g8GgL8z8ZvwHeKnGBxM7D7vBoIG2A9GqkX+BC+2Y8mGA6Zm/E7KwQnyAIqkLSOLxQ5FF46e3j\n", + "JO1e1+wEYK6ZPR+v+/UV+ZKPtlOlBXQw8FZgnqQsW8En8XkNzOw0MztH0tGSlgCPA+9o9SRmzJfY\n", + "Fvgi8CHgfW3pfbvwf/hhuNjEWp0gCDrJ/sASM1sKICkLbMoHh92LR90CTAAetoqmAqqMgvsbJSws\n", + "Mzth5OfiGYmvAVdJnGjG6pEec0S49Xcg7l57Ax5ocQbwacwKXYxBEASjQFHg1wF1bb4L/FXSPcCm\n", + "+BhWCT2bCaEeM26XuAUvLXDOqHfARWdPamt1niTW6gRBMIpImo27zRpRJpL2k8D1ZjZbXpjyfEl7\n", + "WwUpvfpGgBI/B95CJwQIfoebrWeSudoibDoIglHEzOYAc7L3kk6qa1If+DUDt4LyHAR8Ph3vVkm3\n", + "A7sC17S5u72bjLS4HVsCi4EtzRi92jZSdt4pmHXW/RcEQZAYXMpG6+J1wA4H7gGuAo6ry1DzP8AK\n", + "M/sPSVOBa4G9zOyRdvevsii4TmDGA/gE2mhHw70EuCjEJwiCbiYFE5wAnIcncf6FmS2SdLyk41Oz\n", + "/wJeIOkG4C/AR6sQH+gzC8jbchbwUzN+VXG38ic9Hbges2+M2jmDIAiGoNvLMfSVBZS4CS/RMDp4\n", + "8MGReFnrIAiCoCT9KECLGE0Bgpn4dbx5FM8ZBEHQ8/SjAN0E1K/srRK3fnrBlxkEQdBF9KMA3Qzs\n", + "Ko3a33YE4X4LgiBomb4TIDMeBVbiK36rxUMaZwMXVH6uIAiCPqPvBCixiNFxw+0H3EnrCVSDIAjG\n", + "PP0qQKMVCXcEHicfBEEQtEgI0MiI8OsgCIJh0q8CtAivdVEdXlBuX+CSSs8TBEHQp/SrAC0A9pAG\n", + "lftuJy8Grsbs8QrPEQRB0Lf0qwDdl563qvAc4X4LgiAYAX0pQGYYMB+vz1MVEYAQBEEwAvpSgBLz\n", + "gT0qObK0DbANnqY8CIIgGAb9LEALqM4COgL4K2bPVnT8IAiCvqefBahKF1y434IgCEZI39UDqn2G\n", + "TfFghAlmtM9S8fILdwOHYnZr244bBEHQZqIeUIcwYyXwALBjmw89C3gauK3Nxw2CIKgcSUdJuknS\n", + "YkkfK9j/EUlz02O+pDWSJlXRl74VoEQV80BRfiEIgp5E0jjgm8BR+M30cZIG5M00sy+b2T5mtg/w\n", + "CWCOmT1aRX/6XYBuB7Zt8zFj/U8QBL3K/sASM1tqZquBM4Fjm7R/M3BGVZ3pdwF6ENiibUeT1gcO\n", + "Bf7atmMGQRCMHtOAZbn3d9GgdI2kjYCXAb+uqjPrVnXgLuFBPF9buzgQuAWzh9t4zCAIgrYgaTZe\n", + "o6wRrUwdvAr4W1XuNxgbAtQ+CyjCr4Mg6GLMbA4wJ3sv6aS6JncDM3LvZ+BWUBFvokL3G4QLrlVi\n", + "/icIgl7mGmCmpO3lUwpvBM6ubyRpIvAi4HdVdiYsoLJ4GOIewKVtOV4QBMEoY2ZrJJ0AnAeMA043\n", + "s0WSjk/7T0tNXw2cZ2ZPVtmfvl2I6p9jCnCLGZPb0IlXA+/D7KUjPlYQBMEoUPVCVEnjbAQpyfrd\n", + "BfcIMEFivTYcK9xvQRAEA1ks6UuShlUAtK8FyIzncBHavA2HiwCEIAiCgTwfWAx8T9KVko6XNKHs\n", + "h/tagBIPAVNGdARpW2Az4IZ2dCgIgqAfMLPHzOx/zewg4GPAZ4D7JP1I0s5DfX4sCFA7AhGOBC7A\n", + "7Lk29CcIgqAvkLSupGMlnQWcCnwFz7/5e+CcoT7f71Fw0B4BCvdbEATBYG7B1x190cwuy23/laQX\n", + "D/XhSi0gSd+XdL+k+Q32z5a0Ipd59VMVdGNkAiStAxxOBCAEQRDUs5eZvbNOfAAwsw8M9eGqXXA/\n", + "wLOuNuOiLPOqmX2ugj6M1ALaC3gUszvb1J8gCIJ+4Vv5Ug2SJkv6ftkPVypAZnYJsHyIZlUXSxqp\n", + "AEX4dRAEQTF753PFmdkjtJB/s9NBCAYcJOkGSecMN5Z8CB4EtpA4XBqccqIEIUBBEATFSNLk3JvJ\n", + "eIaFUnQ6COE6YIaZPSHp5cBZwC5tPkdmAb0NeKnEeDOeKvVJaTzwQuANbe5TEARBP/AV4HJJv8S9\n", + "WX8PfL7sh4cUIEmbAE+a2bOSdgV2Bc5NxYxGhJmtzL0+V9K3JU1OZlx9P07OvZ2Tsr6W4UFgOrA3\n", + "ngl2f+Dikp89GFhAhenIgyAIehUz+7Gka4GX4B6t15jZwrKfL2MBXQwcImkzPIHd1XgG1bcMo78D\n", + "kDQVeMDMTNL+eG66QeIDYGYnD/M0DwI7AxfhfX8x5QUowq+DIAiaYGY3SnoIGA+YpG2tZNBWmTkg\n", + "mdkTwGuBb5vZ3+NZoYf+oHQGcBmwq6Rlkt6ZUjUcn5q8Hpgv6Xp8EdObyhy3RbLicb/ERWjI2PQc\n", + "Mf8TBEHQAEnHSFoM3IavB1oKnFv680Nlw5Y0F3gf8FXgXUnt5pvZnsPtdKuMNKOrxN9wAX0GL0e7\n", + "uRnPDPGhzYHbgSmYNW8bBEHQhYxCNux5uPvtfDPbR9JhwD+Y2TvLfL6MBfQvwCeA3ybx2Qm4cNg9\n", + "7gBmHGLGA2Y8CiwBXlDiYy8BLgnxCYIgaMhqM3sIWCeVZriQcuMrUEKAzOwiMzvGzL4gzwrwoJl9\n", + "cAQd7jSXU+4ChfstCIK+Q9JRkm6StFjSxxq0mZ2y0yyQNKfJ4ZZL2hS4BPiZpK8Dq8r2ZUgBknSG\n", + "pAmSNgYWAIskfbTsCbqQu4BtSrSLAIQgCPoKSeOAb+IZamYBx0nava7NJOBbwKvMbA98rr4RxwJP\n", + "AP8K/An3ML2qbH/KuOBmmdljeInWc4HtgX8oe4Iu5B6GEiB3M44HbhyNDgVBEIwS+wNLzGxpWkpz\n", + "Ji4ied4M/NrM7gJILrZBSFoX+IOZPWtmq83sh2b2dTN7uKh9EWUEaF1J6+EC9PvU6e6v492Ye4Gt\n", + "h2hzJPAXeqFeeRAEQXmm4YFYGXelbXlmApMlXSjpGkmFBoeZrQGey+eCa5Uy64BOw0Pr5gEXS9oe\n", + "WDHcE3YBZQToCBhW2p4gCIJupsxN9Xp4PrfDgY3wTAdXmNnigraP40tp/oy74gCsbJzAkAJkZl8H\n", + "vp69l3QHHiHWqzR3wbmP9CVALwdaBEEwBpE0G5jdpMndwIzc+xm4FZRnGfCQmT0JPCnpYjyTTJEA\n", + "/SY98pT2HJVZBzQJOAl4Udo0B/ismY2aFdTOWHYJAU8BEwtzwkn7AT/E7HntOF8QBEGnqB8707zN\n", + "zbh1cw9wFXCcmS3KtdkND1R4GbABcCXwxlZS7JSljAvu+8B8PMmc8ACEH+ALO3sOM0ziPtwNd3tB\n", + "kwi/DoKgLzGzNZJOwNOqjQNON7NFWXYaMzvNzG6S9Cd82uU54LuNxEdS0RhqZrZjmf6UsYBuMLO9\n", + "h9pWJe1ezStxBfAhMwZV8UO6EPgyZn9s1/mCIAg6wShkQpiSezseD9ne3Mw+XebzZaLgnpR0aO6E\n", + "h1CbbOpViueBfK3TfpRPVhoEQTBmMbOHco+7zOxU4BVlP1/GBfce4MeSJqb3y4G3D6Ov3USjSLhD\n", + "gevIlYkIgiAIipH0d9SCDtbBs8y0ryCdmV0P7CVpQnr/2DD62W00ioSL7AdBEATl+Qo1AVqDL9kp\n", + "XcCzoQBJ+nDureW2C59k+p+Wutld3Estqi/PkbjFFwRBEAyBmc0eyeebzQFtCmySHpvmHtn7XuYe\n", + "kgtOSuaiF8fbDi9aFwRBEAyBpP/KZ0KQtJmkz5X+fC9km6kgCm5v4KfAF4APAAcaOg54A2avbtd5\n", + "giAIOskoRMFdb2bPr9s218z2KfP5MkEI/cg9uLXzZXzC7PnE+p8gCIJWWUfSeDN7CkDShsD6ZT88\n", + "VgXoYWBD4MfAw+K5f8QDEE7pZKeCIAh6jJ8BF0j6Pp6o4B34uFqKMemC82Pyb8B3gc1nceNVC9jj\n", + "ccF2kQE7CIJ+oWoXXDrHy/HUPuCluc8r/dkSmRDGA6/D6wBlFpOZ2Wdb7+rwqPoifkafXfImzrx9\n", + "li08sqpzBEEQjDajMAe0A3BfSlyaueCmmtnSMp8vkwnhd8AxwGq81OoqPAV33/BqzrLf86oHOt2P\n", + "IAiCHuNXwLO598+lbaUoMwc0zcxe1mqvegZpvd0ZP/3N/Px3hcXRgyAIgkaMM7Nnsjdm9nQqYFqK\n", + "MhbQZZL2GlbXeoP9VjDxkZvZrcy1CIIgCGo8JGltSe/0urCEdxFlLKBDgXektNtPp21mZv0iSkcu\n", + "YvcF+ALbIAiCoDzvAX4m6Zvp/V14yZ5SlBGglw+nVz3EkZdy8CV4kEUQBEFQEjNbAhwgaVN/a6ta\n", + "+XyzXHATUuLRfkg+WownWH3+d3n3qcAene5OEARBryHplcAsYLynCoWyUdLN5j3OSM/XAdcWPPqB\n", + "FwNX3sl2jxAuuCAIxgCSjpJ0k6TFkgbFXkmaLWmFpLnp8akmxzoNz379QXwh6hvwLDOlaGgBmdkr\n", + "0vP2ZQ/Wg2TlF1YSAhQEQZ8jaRzwTXzsuxu4WtLZZraorulFZnZMiUMeZGZ7SppnZv8h6SvAn8r2\n", + "p1QqHkmbATPxkqsAmFk/VA09Engbvq6p1zN8B0EQDMX+wJJsoaikM4FjgXoBKrt49cn0/ISkaXia\n", + "s63KdmZIAZL0bty8mgHMBQ4ELgdeUvYkXYk0HZiK/03bEBZQEAT9zzRgWe79XcABdW0MOEjSDbiV\n", + "9BEzW9jgeL9PBsqXqE3NfLdsZ8pYQCcC+wGXm9lhknYD/rvsCbqYw4G/YvYsYhUhQEEQ9D9lcl1e\n", + "B8wwsydSnrezgF0KD2b2n+nlryX9ERhvZo+W7UwZAXrKzJ6UREq7fZOkXcueoIvJl19YBWwiIWAC\n", + "8DIzftmxngVBEAwDSbOB2U2a3I17szJm4FbQWsxsZe71uZK+LWmymT3S7NypJMNTLfW3RDLSs/AU\n", + "2yfiVsNyYF0zO7qVE42EtifU81jBe4GDMLvNN/EUMAk4GPiqGf2y0DYIgjFK/dgpaV3gZnwsvwe4\n", + "CjguH4Qgrw79gJmZpP2BX1YVjDakBWS1CqEnS5qDWwiloxy6lD2AxzPxSazCAxE2BzbrSK+CIAgq\n", + "xMzWSDoBOA8vxnm6mS2SdHzafxrweuC9ktYATwBvqqo/TS2gpJYLzGy3qjpQhgosoA8Bu2D2ntom\n", + "lgKHAS8DvmLGxm07XxAEQQcYhXIMF5jZ4UNta0TTBJxmtga4WVLphUU9Qrb+J08WiLA5sJFUvqxs\n", + "EATBWELShpI2B7aQNDn32B6PtCtFmSCEycCNkq6iVgfIyixSSmVaX4H7E/ds0ObreL65J4B/NLO5\n", + "pXo+XKQNgEOAt9btyRajTk7vNwPur7QvQRAEvcnxeFzANgzMjLMSX+haijIC9CkGL0oqW7b6B8A3\n", + "aFAjXNLRwM5mNlPSAcB38HVGVXIgcDODIzryFhC4EIUABUEQ1GFmpwKnSvqAmX1juMcpUwPnFWY2\n", + "J/8ASkXAmdkleNRcI44BfpTaXglMShEYVZIPv86TBSHkLSCktYIUBEEQDOT+lAkbSZ+W9BtJ+5b9\n", + "cBkBOrJgW7tCsItW5U5v07Eb0UyAMgtoJbVIuGukKNUQBEFQwKfNbKWkQ/DQ7u8D/6/shxsKkKT3\n", + "SpoP7Cppfu6xFJg30l7nT1X3vqx7bxhn0mZ42vDLCvZmc0CbA0uAyRLr4Au1tqysT0EQBL3Ls+n5\n", + "lcB3zewPQOmS3M3mgH4OnAucAnyMmlCsNLOHh9HRIupX5U5P2wYh6eTc28wV2CqHAZdi9nTBvswC\n", + "mowL7GbAFDxWPtYFBUEQDOZuSf+Le5ZOkTSecp41oHk5hhXACipchAScDZwAnCnpQOBRMyuc+Dez\n", + "k9twviMZHH6dkc0BbQbcmp63TvsmN/hMEATBWOYN+NrJL5nZo5K2Bv6t7IdLlWMYLpLOwIu+TZG0\n", + "DDiJZJ6Z2Wlmdo6koyUtwUO831Flf/D1P438k6vwDAlP4tFvO1AToLCAgiAI6jCzxyU9iC9tWQys\n", + "wacwSlGpAJnZcSXanFBlH9biC6QmAPMbtFiFV/J7BI/c25daXYuwgIIgCOpIUyN/B+yKL7tZH/gJ\n", + "nlNzSEr76vqAI4ALMHuuwf6VuAA9jAtQ5oJ7hrCAgiAIingNXtDucQAzu5sWinuOJQFqFH6dsQoP\n", + "iHgYt4Im4wJ0MyFAQRAERTxtuZt6SS3l0BwbAiStg8eoNwpAABeg9am54DbDXXCLCBdcEARBEf8n\n", + "6TQ8icA/AxcA3yv74UrngLqI5wMPYbasSZtV6bneBfcXer38eBAEQQWY2ZckvRSfwtgFX5jazNM0\n", + "gLEiQEO538AvINQsoMwFdyNeHyMIgiDIIekLZvYx4M8F24ZkbLjgissv1LPWAjLjSeA5YFvcBRdz\n", + "QEEQBIN5acG20qna+l+ApA3xDNhzhmiZCVCWJXs5sBq4kxCgIAj6BElHSbpJ0mJJDS0VSftJWiPp\n", + "tQX72pKqbSy44A4B5uOZHZqR1TrK0gwtx2sUrQLWl9jAjKIUPkEQBD2BpHF4vZ4j8LRnV0s628wW\n", + "FbT7AvAnBufrhDalahsLAnQEQ8//YMZqiaepWUCPpO0m8QhuBd1XWS+DIAiqZ39giZktBZB0Jr6O\n", + "Z1Fduw8AvwL2KzpIu1K19b8LrlwAQsZKBlpA9+VedywUW2J9qfziriAIggYUlcAZUEJb0jRclL6T\n", + "NlVWoaC/LSBpCrATcGXJT3wAuD29Xo4rfPa6k/NAb8ZTW7y7g30IgqDLkTQbmN2kSRkxORX4uJmZ\n", + "JFHsgmsL/S1Avvj0YsxWl2lsxpm5t/cBD6TXmQuuU0yklhg1CIKgkFSmZk72XtJJdU3qS+DMwK2g\n", + "PH+HVygAL0nzckmrzezsdve33wWoFfdbPSfjodjQYRccMB6iNHgQBCPmGmCmPDnzPcAbgQFJo81s\n", + "x+y1pB8Av69CfKCf54BcvpvV/2mKGU/mot467YLbEL8TCYIgGDZmtgavwXYesBD4hZktknS8pONH\n", + "uz/9bAHtjP999dEdwyFLTtopxhMCFARBGzCzc/EQ6vy20xq0rbRGW/9aQFn2A7N2RHB0gwU0Serr\n", + "G4YgCMYY/SxAI5n/qafTAjQ+PUdW7iAI+ob+FCBpXeAwhjn/U0CnXXAbpudwwwVB0Df0pwB5GOFd\n", + "mLUrc8FyYAepYyKUWUARCRcEQd/QrwLUTvcbeOjiFcASide08bhl2RB4lrCAgiDoI/pVgMqUXyiN\n", + "GU+Z8U7geOA97TpuC4zHY/ZDgIIg6Bv6T4CkTXAX3EUVHP084CCJTSTGS7ywgnMUsSG+WjlccEEQ\n", + "9A39GNb7IuBazB4fsmWLmPGYxFV4ip+dgH/Bi9ZVzXjgNsICCoKgj+hHAWqr+62AP+Iluo8Apkis\n", + "Z0apXHMjICygIKhDYm9gnll12ZqDauk/F1z7AxDq+SPwVuByPGHptObN28J4XIDCAgqCGr8Fdu90\n", + "J4Lh018CJG0FTAeurfAstwB/Bj4L3AFsV+G5MjILKAQoCGpsTHgFepp+c8EdAVyIJ9yrhGTuvwxA\n", + "GjUByiyg+LEFQY2NiN9ET9NfFlD17rd6wgIKgg4gIVyAIj1VD9M/AuTlF6oOQKincgFKP7QNgHuB\n", + "CZGQNAgAWB8fv8IC6mH6R4B8MnI1sGQUzzkaFtD6wOoUafconU2KGgTdwkbpOQSoh+knAWpn+YWy\n", + "jIYAbQhcmI0AAAAgAElEQVQ8lV4/TLjhggBqAhQuuB6mnwRotOd/AO4EZkiNr6PEBInPj+Ac46kJ\n", + "0EOEAAUBhAU0bCQdJekmSYslfaxg/7GSbpA0V9K1kl5SVV/6Q4Ck9fAMCBeM5mnNeBxYBWzZpNm+\n", + "wCelYQvHhsCT6fVtxLqHYBSR2E7isE73o4CwgIaBpHHAN4GjgFnAcZLqx5S/mNneZrYP8I/A/1bV\n", + "n/4QIDgAuBWzhzpw7qHccLum5+H+iPMW0AV4GqC+R2JSp/sQAHA08MFOd6KAjfAbs7CAWmN/YImZ\n", + "LTWz1cCZwLH5BjYwjdkmuOelEvpFgDrhfstYSnMB2g1YxvCFI28BXQAcnnf5Sewpsekwj92VSMyg\n", + "2sXEQXm2ojvdvhvhSxPCAmqNafh4lHEXBdlcJL1a0iLgXCq8AekXARrt8Os8dwAnSnxb4nKJi+v2\n", + "7wacxvAFaK0FZMYy/G5k79z+rwHHAEhsILFF0UEkjpWYOcw+jDab4wNf0Hm6WYCWERbQACTNlnRy\n", + "9ihoUipIy8zOMrPdgVcBP2lnH/NUKkAlJrtmS1qRJrvmSvrUME4yEdgL+FsbujwcvgH8EFgEfAbY\n", + "X2KD3P5dgV8Bk6TmmbMlZkq8UWKv3Oa8BQQutEfk3m+Lpx8CeCPu3y3ivcDrmv8pXcOmwEbS2kqw\n", + "AEiM61B/xjJT6c5BfiM8KlTS2pL1Yx4zm2NmJ2ePgiZ3AzNy72fgVlCj410CrCupku9AZQJUcrIL\n", + "4CIz2yc9PjeMU80GrsDsyaEaVoEZS834rhnfMON83CLaGSD9MLYBbgX+CjSMJkmWy3zg48CHc7vy\n", + "c0CQE6DkiptB7Qu1Ez5gFDGdgZZTN5O5FNe6VyS2Am7sTHfGNFsBmzeL9OwQGwGP4yLUjQJZGRKv\n", + "HMH/4xpgpqTtJa2P37SePfD42km+sB9J+wKY2cMj6XMjqvxSDTnZldAIz9NJ91sRN+FuN4CZwG1m\n", + "rMEttAOafG4rYDHwSQaKSL0FNAc4JH0Bt8AXqmYCtF3aVsQ0GGBZdTODBIiBll4wemyFjxPdFhSy\n", + "EfAE8AhjTICAMxhmFn7zPJkn4MU1FwK/MLNFko6XdHxq9jpgvqS5uIv/TW3ocyFVpnUpmuyqH4AN\n", + "OEjSDbhp+BEzW9jieY4E3jzsXrafRdRCpXfFBQk8i3aRAGdMwed37megAA2wgMx4VGI5LjpbAs9Q\n", + "E6DtKfDXS2ySjrOjxHizARZVS6TUQOtWXAOpSIC2AjaWGGfGsxWeO0ik//VWeBqoKfhg3y1kAvQw\n", + "YygQIaXi2gTPiLJsiOaFmNm5eHBBfttpuddfBL44gm6WpkoBKjPZdR0ww8yekPRy4Cxgl6KGdRNq\n", + "c8xsDtIM/Idx/Ug720ZuojZHsxs1AVoMTYMAGglQvQUELma74l/Ea3PH3Y7kLjHjuVz7afgNwFO4\n", + "O/S6Fv6eevYDvgocPIJjDEUjAQL/m1dUeO6gxgT8BucO/Pt5S2e7M4CxagFNTM99IbpVuuCGnOwy\n", + "s5Vm9kR6fS6wnqTCC5ufWDOzOWnzEcAFmD1X9JkOkbeAdgNuTq/vBKbWT6zn2AIXoAfwSqvZ/6Z+\n", + "Doh0zF1xt9S1wKbJypmW2k6sa58J0A2MfB5oGrBfk7+jHWySnvPfha3Tc0+FnHdT5KHEKS32Zyv8\n", + "hqgb51mGZQGlSNFeDlrIXKEhQENQZrJram6ya39AZtaKmd/J9T+NuAnYNQnI3+F+VtI80B3Ajg0+\n", + "NwV4KLm2VlL7gjWygHbBBegOXOwPAB6k5i7JM52aAI10HmgysB7VBjRsilvQRRbQhArP21aSC+ta\n", + "ae1i5E7zUuB5LbTfCq/6uzYFlMR+FfRrOAzXAjoRj1btVTIB6oukxJUJUMnJrtfjk13XA6fSymSX\n", + "tA6+tqabAhAwYwXwGHA8bo1ck9u9hMZuuMwFB37XmQ24zSygGbhltQw4BF8U+xCDAxGm4yI1j5EL\n", + "RyYK+4/wOM3YFLiHYgHqJQtoCt7f53e6I4mJtDZYTyUnQBKTgasqtn7LMtw5oBlUEMwi8QJpVG6O\n", + "+soCqrS2TInJrm8B3xrm4fcEHsNs6bA7WB03AacA704VVDOazQNNAa5Mr7N5oAW4BbSyrm1mAd2P\n", + "i08mQHfgA169BTQNdw3eAOwlobp+tcJkPKy8agG6g4GD5Vb4gNMzFhA1a3dv4Bed7EhiEq0JUOaC\n", + "yyygmbntS9vaM9ZOsFvJIJNMgEQt6rQMW1JNRN8XgO/hEWpV0lcC1G2x/a3QbeHXeRbhP9xf121f\n", + "TFojVMAU3IUGAwMRiiygpfggMJOaBfRCahZQIxfc/bhrayRZBiYDf6J6AbqTwRbQEnrLAtoRT1bb\n", + "8fVXyR3YqgVU74LLAoS2rm8ocYjEV0fYzVOAd5ZsO1wLaEuaJw8eLpszcM67KsIF1yV04/xPxveB\n", + "dxXcybXigssEaNAcUJpPuh0fjO/DBWhj3GpoJEB3J6vnRtI8gMQbGvn0077fS3y3btfm+JqmbSQ2\n", + "qygPXWYBTU59ET7oLab3LKBzSAIksYU0KEBktNgIGMfwXHBZEELeAqpnJ0YutFvReCF1PcOdA5ra\n", + "wjlaYTKjJ0B3ExZQB5HG42HAF3a6K0WYca0ZlxTsGsoFVyRARRYQ+DzQ3UnksvUASykWoCwKDlyA\n", + "9kivPwR8Jw3wa5E4HPgKcDGeaSLPZNxSuw5fXPyIxA4N/qbhsgn+t2Q/sol4OPB9tMECkviixAtH\n", + "epwS7Ih/RydIbI6nbPrnBn3apGh7G8nunEdqAT1GgQWE/49GKq4TKH+DkRegVi2gLSrI7DAZmqfa\n", + "ahOT8LIsIUAd5IXAQsyWd7ojLZKFYr9A4kN1+1oVoFvS8aAmQHfg4rBWgCTWx7+sD6RNC4DnSayH\n", + "z6ONB16Taz8e+A7wfjyVUn3Bvcn4j/5M3KK7nBYj6yT2ltinSZMBFhC1gfAx2mMBvZDRyQqxI36N\n", + "5uGLkF9O48Se10vsVGFfMnEY6RzQ3ximAEm8bYiBfyLlbzAyAXp0qPPmzr8ePoA/QRvngVLux40Z\n", + "PQvodsIF11G62f3WkOQ6W4pHBn5acp+65MW1zHgiNW3qgkvMpbbGKBOgOxkcBbcNcF/OHZi54J6X\n", + "+vJvwOdyA8MHgYVmnG3Gk/gPPD/gTAYeMeM7ZrwfD5wYFNorMVHivQ0uxdvwKMFGFAnQvXgwRjtc\n", + "flMoHkTbzY743eoNwH/h/5tBApBEf0eoXIBW0Vpm63wU3Ba4BXQxwxCg9B3/UYPPZrRiAW2MC8kK\n", + "yovJFNydeC8tuuHqEgzXMxm30EfLArqdsIA6SjcHIAzF2/ConR8Cb03bskWoGWUsoDNJ7hwzHgEO\n", + "SwJW74LLu9+gJkD74SHif8LvprZJ+w/BB4qMpQysd5RZQPnjzSro3wuBb0scVbBvK5pHLmVh2OOT\n", + "BdduC6hyAcr1exkuQFPxpQZFA8f2eDRXlQPYJDx6sZQFlG5ItsQt5+X4d+QpPMCmoQDVu3NzZK7n\n", + "ZgP/cCygVcCGKYJuKLbEf1sP0EIgQkoUvLhJk83xG41NspvJCgkXXEfxTAm74a6fnsOMK814EPgx\n", + "8A/ph553v0EJC8gMy4dSmzEnvawXoB2oueow4+F0vFcD16RjLMUHQXCxuSP3+TuyfekucH38R5+x\n", + "kOLFjTvgg9W3C36UW9NAgNIAtkk6xyP4wLc1LkBrLSCJGcMpz5Cu92Sqt4C2w+foVgMXAacDl1Es\n", + "AJnlU6UATSQNXAVzfpI4sK79ZsDjZjydLPdHcbfvvTQWoPWg4RqhbDFus4G/5TmglHLqMcq54abi\n", + "4nP/EP2oZyY0/b5Nxn93dwHTJQ6V+GgLx2+FSfjveeOSotvV9J4AeUmDv2H2dKc7MkKux9PJH8xg\n", + "AXoA2DINFI0soEbUC9BeeJmHPAuAl1FbJLuUmpVTL0D5fZvh7rf8GqJFeOaH+h/njrgldTXwgbp9\n", + "W+FzYUV+7I2AZ9Kgl0U4FVlAv8RX9g9AYh2J4wqOmzEJ/95XLUCZ+w0zbjbjn2ic0mZH/LvQdgFK\n", + "wQ/gf/dD+M1H/SC/NXBxnTBtQW1ZAOmzi3EBKoqCm1j3XE8Wwl1oAeXCxFu1gGCIeSCJbdLxh2UB\n", + "UVvP1cjVtzn+v12G/w9fD7yrheO3wiT8d9GK67Fr6UUB6mX321rSIP4T3A03QIBStuon8AG/0RxQ\n", + "Ix7FXQHrpfd74y6gPFldnSyJ6x3A9ilEeF0GutiWUrOO6t1vmLESH6jqI+GyAfh/gdfW7ds6Hbco\n", + "Rc2m1BbeZhFOmQCtpDZ4TqfY8poG/Fxam4+vnim4oI+GAN1at61RxNZO+OR+WwVIXto8u/mYiH83\n", + "ikRwW9x6yd8QbEEtcAX8+3kLPoBvUXDDMZQA7ZqO0cgFNx7/7g1pAaVzr0/txmxF/XmTCzTjz/iN\n", + "XuZSfKCoHxJfbRAIkn23G7m9st/FnXggwqHALlIl640m4f/HVqP/upJeFKCeDEBowK9wV9hUBt5t\n", + "Qs0N15IFlFwS+bURezM4W/iNwIIUZAA1K2c74I46C2etCy4dsyhX343ALIndVKv6mgnQxfiPcWtY\n", + "O+G+Ee6OKhKgTWgsQI/hiVfXSduKRCaby3p7wT5wAVqIW5hVfv93xCeL8zyCZyuvnyfJwrVHFEVV\n", + "cNwdgK2T63QiPlA3EiAYaNlsycDv5DJgfnIpLmdwuqeJ+E3TxNSXcRL/mVtHtisuso0G5Qn4Iuky\n", + "LrgNgSdz39MB1kBKuHp1rv0MPFdi5oIbZAElUfsnKFwXN5QA5S2gPXFr70LgoNzxN5PasiA5BKhj\n", + "SDvi0S8LOt2VdmDGrbhL41gGuuBI27eldQsIarm7tsLvbO+u2382kC+RnolMvfsNBrrgBllAiYV4\n", + "8MJfgI+kgXBHvBjfajzQ4ZWp7VRcXBdRPA+Ut4AeBvbFk7reQM0FNwW/Wy4SoGzB6lsb+Oyn4AEO\n", + "K6k2w/PW1F33JPjPwqA5sZ3weaL6kPfSSLwAuLRucyZo21AbuB5mcCRc1i4vQPUuuLcAf0ivi+aB\n", + "JuLfncwS+Q3wIuCNaY3TrvjNSCMLaGI6bhkXXN79BoNdcNviNz1K554AvICaC65oDmgWfvNTZAHt\n", + "iN8EDmUBLQP+HrgKr4B8SK7N64DPD/WHNSPN+WzIwPnRnqa3BChzv5kNN49ZN/Jr/IdaL0B/xcuZ\n", + "tzoHBLV5oL2BG+rzvplxnxnn5TYtJWcB1R3rDmC7JCqNBOhG4CP4Hf8LU7vnzMjWaf0eeFV6nQUU\n", + "5CvH5ql3wX0cONVsrWhsmjvG7gV3/dsAF6T9hxccP3N3NppMbxf1FkTGAAsk9X8H/KZqJY0r2jYk\n", + "HePLwAvrFrTmBaiMBZQXhwEuODPW5L5HjQRoGR4JNx7/7h6Oh+m/FViN33Q0EqAJ+P9sgxKT6/UC\n", + "VD8fknkOJuN/+zO4ZZO3gKZKbC3xs3T99k/tirLV74DfAA1lAd2Ju4Yvwa29vADtwMgzMEwAHkte\n", + "juVN+tMUSUdJuknSYkkfK9j/Fkk3SJon6VJJla2Z6zUB6if3W8Zv0nO9AP0GnzsZjgV0Nx58UDT/\n", + "U8Sd+CC0PXUCZMbj+B3XljQWoMtxl8Mx+J3k8xjofjoXmJ2i4bI1PWsFKN2pbpfmoOoF6C58cIWa\n", + "BbQ1PrfxLIN/1Nuk4/8ELwFSz+aMngA9ULC9XgC2BlaasYra/6FVXoELxkIGFnTMBGgazQVoBv6d\n", + "aeaCy3Nfvm2abxyPW5YTSVZuCiQ5G/gwtfmjqekze0pr3aXk+vcYQ1tBQ1lAmXUzHf/br07n3Y2B\n", + "QQhvxKspvwB30Z1DnQWUC6dvJkB5CwhcgK4C9sxFgG7PyHIwQs2KhWG64CSNwxeYH4X/Vo+TVO9J\n", + "uA14kZntBfwnPo9bCb0jQH7hXkIfBCDUsRC/M7yvbvuNuOWzEa1bQP8DfAKfDB1SgJLIrMTvAust\n", + "IKgFIkzGB7D6z99kxuHJ4lkAvIEUAZb2L8f/nv2oWS9LgB0kTsQHrpuAzzJQgL4PHJ0rIf44PtBN\n", + "xwVkIYPdcFun411CccLU0bKA6ifxM+oHjnywQssClKLcTsVdqjcy0KqcgQ+K9S64IgvoKpq74PLU\n", + "X7sJuHBkQpBlUAC3fnfGF03n517+g4GLkbNj5ANNGjGUBZSdYwb+ty/DU0ftwMAw7DfhN09vwgXo\n", + "5wy2gLbFv0/301yAMgvoceCKtCZvPrU5pR2oRbYOl3oBGo4Lbn9giZktNbPV+HrCY/MNzOxyM8uq\n", + "Dl9JBeUrMnpHgGAf4H7M6uczeprk1jiYOv992v4bYE26k2zlmNfg2RZeSTkLCFx4DqBYgLI5okYW\n", + "UJ7L8TvL2+q2X4vP5WyFZ2Z4Che21+Hh1MfgFttaATLjHrNaGeh0TVbhd/n34MJdvwh2m7RvAbCT\n", + "xMZ1+/Or4YclQCnUe7EaJGJNg0yjAfxhPBBhssRJ+ER1dq2W0UIgQgou+A3wWzP+QK1OVMYMfADJ\n", + "W0BF2Rhm4FbCcAUoO3YWjZZlUMCMpXgqokyAsmq/e8CAtUcTaK8FtJqaBXQ3tSUHD6RzjMetnffg\n", + "VtDOwB9x11w+60EWTNPM4tgcX57wGDAjWbOkc2Ypp7aHtamAAJA4UuJ7Q/yteSZRK0c/3CCEadQs\n", + "NXAPw7Qm7d+FW4aV0EsC1Bfh10WYsTz5dev5Na273zI+if8AFpZsvxQPbS0SoGvx619GgC7DB/lG\n", + "ArQ1PoCB+8hnmzEfH6T2wgefVTRmJT7I3svA8ucZ2wD3mvEMbhHUF4NrhwW0PT5gbddg/0Q8Sqto\n", + "rVo2cLwYeC/u4liS9rVqAb0fv1aZH79IgK6gyRxQmq+ZhF//vDuzkQsRfEDP3xXnBWgStajFjI8A\n", + "v04BKY+lz24H7J8LupjIyCygvABNxa2P6dRuSK7GXZ1Z9NwDqU/z0uv5yWpZRi3qE9xyuZ3mA/5a\n", + "z0Bu3pPUh73kJcAn47+J/DV+Ea2VNclbQMvxG5mPShyWNZA0W9LJ2aPgGKXnzyUdhpfHGDRP1C56\n", + "SYD6cf5nKK7F3Y4tk6yH/RoMgkXcgd813luw73R8cd0ulLOAoFiA9iU3OJnxUCa8Ztyfzr8rgwvw\n", + "5XmMoQXonvT6Glz08rRDgLJs4o2slWbzJ5kAzMKzYWwPa+votCpA+wK/zN285OfVNsKjum7A73Ab\n", + "RcFl1XLvobwFdCsDXVWZ9ZIJQd4Fhxnnm61NZXM/Lr43p/7MrDtGmXRLRRZQvQvuWmouuLtxD0M+\n", + "Q/1ifJ4QvJDcn3N/W34eqLQFVLB9Hh6WvS0ubPU56PbF3dACkDimIEvFUbmgjHoX3Btwcf9w1t7M\n", + "5pjZydmjoE93M/B7O4OBqbrSebUX8F3gGKsw6XMvCdABsDbdzJggpdu5ZuiWbWEpsKzIEjPjAeAs\n", + "3JpoKkBmLMOtrpvqdi3Ef4gzKRY58B/swTQXoJX4AHEvbuHsmYVbpwnjidQGzmvwCeY8LQUhSKwv\n", + "8cG68OhMgBqJRTPrIROg3fGkr/emMu7gAtRKaYtZDLRwbwFmpr5mwnIXPshsjF+7+jmgbdN515aB\n", + "T5/PrlMRt+LuzWywbOiCK+ABPDpuAW6dZW64zAIajguu3gLKBChzwd1jxjIzXpFrc7iZu73N+IYZ\n", + "n8n9bXlxbWoBJesmn0g4zwL8f7Qz/vvKp9gCd8+Nx92SmwK/I1dTKQXlnAv8S9qUF6B5eKaRvYFD\n", + "G2QVKeIaYKak7SWtj7vLzx74N2lb3LX7VjNbUnCMttFLAnQ9Zs0GpmBk3JIejfhaeh7KAsKM55nV\n", + "8s+lbWvwH+RuNB6c5uMRdENZQOvig8pd+OCQJTzdCo++ykS0SIBanQP6Mv635y2tPfCBqpEF1CgA\n", + "AWoD2SzcgstzA75+ZUCKFRUUsUuiuys5oU9zEI+mfmUBCPfgVtbKdF3qBWgGLkAP4i6dcfhA93hy\n", + "Yw4iZb9YRe361QtQvQsuz/3UBOhK/MYSRhaEsNYCSqI4FQ86yCyge+oP0KQk/W0kCyjlxzsMF8pG\n", + "FlAj6ye7TtnfezsDowC3wsVnHi5yWfDIy3OH+DvcPfvxlKFhrQCZcYcZ/2zGvfiyg9dQAjNbA5yA\n", + "zxEvBH5hZoskHS8pCwr5DB7g8B1JcyVdVebYw6GXBGisud9Gm/MZnDJnLWZcj2cXWNaoTQmuTc/3\n", + "N9g/Lz0PZQFBzYo6jVo01TYMtK4W4muYsgSm2eC6PLXbusDlcUTu9XH4gPB7GFDAbg98Ynbbus9m\n", + "A+dQLrgpuHgMEKC0UPVScm7XNAjeI9VW1Se2Ax5Og1yebB5oBm7RPkatbAG4MGyZc+tsm9plGQ6m\n", + "0NyCy1hCzVWVCVBRFFw99+OWSZEADTcIIW8BZUEnN6XzZFGRZbkV2FFiN9wK+EeztRZQkZVRGBma\n", + "Yz4eYLOUgRbQPnhJldtwi2sW/r85OvfZ/fHFv/+Fe3/eQu3/mOcXFC85KMTMzjWzXc1sZzP777Tt\n", + "NDM7Lb3+JzPb3Mz2SY9W5qlaopcEqC8DELqF5O5rGvBgxo9bjcir41pgeS6sup4sb9lQFtCKXF9/\n", + "ARyc8p4NuNtNg+o8agsCN0ufXZMilVaQm0yXmAqcL61dDPoO3Mf+J5KrKK152RmfM9g299nxwJ1p\n", + "bUuzAfwRfPBZnsShnvPwRLEZWdLY30q8U+IlSTR3pzjA5CZyApS23ZP+1izP4H3UJtozFxzU3HDN\n", + "5n8yluDXAVp3wYEL0FxgtzRflXfBDbCAkhv0BokXp03N5oC2xK3glfjC0ieG+l7XcRtZwmP4dzP+\n", + "mLYvBzYrCKNuaAEl5uNCPcACwud/rkvbd8D/n6cDe+cs4P3w8Piv4gu5/wNP31XPH4ADMzecxAYj\n", + "DPceNXpJgCozA4NR4zIGu53yLASeY2gLKC8yjwNn4FZQ0d3ul4GvpXDs+qzjC6jN50AtZDZzt83C\n", + "8+hdQc0C2hmfW7mZgS64Q/FB9Pk0H8AfxoWy0XU4D3hZbgA5HL8DficeiPMjPH9g/fxPxqV4nai9\n", + "qQnQ3dTmDiDNFaXX21EToPvwAbKMAN3KQAF6jPIuuCeApUkMF+Nu18wCKio6+Np03B+ndU87UWAB\n", + "5dxvmcgtY3AaqqFYBHwB2MuMH2Qb083MUwV9G8oCyqz6pTS2gHbA/5/X4cJ3ZGqzP3B1ujm8Pt0A\n", + "DgoYSL+B66hF1H2RwRnou5LeESBfNBX0MGYsMuPgJvufxAfVZj/oxxgcxPAVPKT5gPp9Zvwad/V8\n", + "hdr8T0a9AO2bnmeleZdJ+CA2D3flTUrtF1Cr/ZL9hl6GD1B7MbQFBI3D4xfhc1wzU1qdfYG/mfFH\n", + "M44DTsJdoY0E6Of4xPXrKLCAErdQy5iwF7XcilmGg7IuuCILaHN8XGkUSn8vcGNunu6G1IeGFhAe\n", + "bv5hPBBmKf4/+L9sZ4r0fBbPGpLv+1205n7DjGfM+FxK/VRP0TzQDjQXucyqv52awIP/X+em7ZkL\n", + "biH+v3t1miPamMEZ1RtxNbVFrwfjgtT19I4ABWOFQ6ndNRaxksEiczvwLeAfKB5wPoAHI/ycwRZQ\n", + "vqTDvvgPeRZuBd1kxnPJ7Xgtfoe5B7VM4iuorbp/KV7ldk+GDkKABhZQmhw/D1+dfyheNPDxXJNf\n", + "AbNxt+KgY6TPfwwX5Gxx8z0MtoCyDOXrUgvDbdUFN2AOKAnBM/hC40aT/OfjCz8zsvVfeQtorQCl\n", + "DNLb4xFiH8UDTg40GxRlmVlfWcJRGIYADUGRAB3C4CSweRbj4fZZBoapEtNTX2/BBWh3PFrvVuBn\n", + "uIB8jmT9lOzb1cB+6aZldxi16NkREQIUdBVmPDrEj+4vuJDUcwq+lmlp0TFx6+iL1HLvgYdx11tA\n", + "P8UFqN7CuAIf2N+HzwlBWreT5n2m4z78zAIqHMBzizGbLRD+PC4gn8YjnPKffwz3+e9MExEz4//l\n", + "FkXezMC1HpkFtA8wN3e978Pdg6XngFQrJJdZWCto7H7DvMJqPrR3Hu4uzKLgspIbkng7LrhfT/N2\n", + "T5txaYPvRxYAkXfBzaO9mfMHCFCyfg/B3WaFpH6/PVl8mcAfA5xjxrP4d3ZrUuZ4s7Xre95Ga9MO\n", + "V+E3SPvjCYhbTd/VEXq+pGswtmi0LsqMJyT2gAHWQn7/s3gSxjwL8Yza6+CD1xb4nfbHGSxA5+NJ\n", + "P49MEYFQq4A5CxeKBbgwPElzF9b3GFyjKd/X2ySOxSOf/rWgyQ+Bl6TBakjMOL1uUyZAmRso4xI8\n", + "Hc1qPPii2TEfkXgOd7nVC1CjCLgiMgHKUjBlLriXA5/CU+X8tcRxsiwMW1KrRPuNFvpRhnoLaDc8\n", + "O3Wpeab0HV2NZwf/atr2tMTd5L5rZlwl8RoGr6Vrxp3AOFy8mllkXUVYQEHfYMaqFlwWmTWRVXPd\n", + "BxeFO/EMAgcxcFD4ixl75MSH1HY74N3A2emu8zY82q7RIk7M+HCDCLh8m6uAbcy4smD3BdTCl4fD\n", + "HbilcBA5AUrneh5uYV5R4jhZIEJpC6ge8wwYzwBPJVdnFoRwOPBDMy4o+T/Nu+CGmr8aLvUCdAgD\n", + "syuU4X58fc+fcttuY3BI/h/NSs//ZK7Xq3HLKQQoCHqEzA23L3Bd+iEvwqPemkXsgVtAH8Lza/0s\n", + "bZuHh1iPOGgmuQ6LtpvZ8NdjJWvwNjy/39y6ffcngSwz+F2Di++wBSgxD9YKcmYBHUZrmU+yUOz8\n", + "HFC7qRegQxmeAF1Yt37rXLycyUi5Gg/EuKwNxxoVwgUXjHUW4GG+++LzSOCWz94MLqldz524C+ol\n", + "uaiuedTCubuZW3DrbfFQDZvwUbzK6TSG74IDv2bZeqyV1AIhrm74icGswANN9qQgt1mbeAR4kcTH\n", + "cAt3Nh4s0ArLqBNWs7Xfu5FyJXCLWWUWYNsJCygY61yDzzd8G6+NAi5AN5dYdHsO8FIzbs5tu5bW\n", + "1550glvwyepnh3uAdBf/Ctxll93R/w+eOaIVsnLrpOeNgMutQSqgBjyK50z797r/Rzu5Cr9p3xJP\n", + "qAceZTUAAAbWSURBVDqX5umring3nuSzCv7MwEXMXY96obq1JDOznljZG/QWKYprXF5sJPYFjjDj\n", + "i8M83iYFKXK6ComjgVlma6vNdrIvU/Hgjp+m6/c0cJIZ/93CMfYANjVbm409oPvHzhCgIAi6ComH\n", + "gFealQqECJrQ7WNnuOCCIOg2/p5IvTUmCAsoCIKgT+n2sTMsoCAIgqAjVCpAko6SdJOkxZIK64pL\n", + "+nraf4OkXghfDYIg6FmGGpcl7SbpcklPSfpw0THaRWUCJGkcnvrkKDxVyXGSdq9rczSws5nNxFPI\n", + "f6eq/gQ1JM3udB/6hbiW7SWuZ7WUGZfxjPEfgOojJKu0gPYHlpjZUvNSCmcCx9a1OQavb4KZXQlM\n", + "kjSVoGpmd7oDfcTsTnegz5jd6Q70OUOOy2b2oJldAyPP5jEUVQrQNAaWb74rbRuqzXSCIAiCKigz\n", + "Lo8aVQpQ2fC6+giN7g/LC4Ig6E26anytMhfc3QwsWTyDwTma6ttMp0EaE0lddeF6HUkndboP/UJc\n", + "y/YS17NSyozLo0aVAnQNMFPS9nhVwjcCx9W1ORs4AThT0oHAo2Y2KJFhN8exB0EQ9BBlxuWMysfd\n", + "ygTIzNZIOgEvLzwOON3MFkk6Pu0/zczOkXS0pCV4IbF3VNWfIAiCsU6ZcVnSVngm8gnAc5JOBGaZ\n", + "2ap296cnMiEEQRAE/UdXZ0Ios5A1aI6kpZLmSZor6aq0bbKk8yXdIunPkiZ1up/diqTvS7pf0vzc\n", + "tobXT9In0vf1Jkkv7Uyvu5MG1/JkSXel7+dcSS/P7Ytr2QRJMyRdKOlGSQskfTBt75nvZ9cKUMkF\n", + "U8HQGDDbzPYxs/3Tto8D55vZLnh55493rHfdzw/w72CewusnaRbuU5+VPvNtSV37G+sARdfSgP9J\n", + "3899zOxciGtZktXAv5rZ84ADgfenMbJnvp/d/A8ts5A1KEf9ZOLaBcDp+dWj253ewcwuAZbXbW50\n", + "/Y4FzjCz1Wa2FFiCf48DGl5LKJ7sjms5BGZ2n5ldn16vwkvIT6OHvp/dLEBdtWCqhzHgL5KukfTu\n", + "tG1qLtrwfiCyT7RGo+u3DQNDWuM7W44PpFyQp+fcRXEtWyBFte2Dl+Xume9nNwtQREe0h4PNbB+8\n", + "7PT7JR2a32kehRLXepiUuH5xbZvzHWAH4PnAvcBXmrSNa1mApE2AXwMnmtmASrzd/v3sZgHqqgVT\n", + "vYqZ3ZueHwR+i5vc96dQSyRtDTzQuR72JI2uX+mF1YFjZg9YAvgeNZdQXMsSSFoPF5+fmNlZaXPP\n", + "fD+7WYDWLpiStD4+eXZ2h/vUU0jaSNKm6fXGwEuB+fh1fHtq9nbgrOIjBA1odP3OBt4kaX1JOwAz\n", + "icqeTUkDZMZr8O8nxLUcEkkCTgcWmtmpuV098/2sMhPCiGi0YKrD3eo1pgK/9e8p6wI/M7M/S7oG\n", + "+KWkdwFLgTd0rovdjaQzgBcDUyQtAz4DnELB9TOzhZJ+CSwE1gDvs1hot5aCa3kSMFvS83FX0O1A\n", + "tiAyruXQHAy8FZgnaW7a9gl66PsZC1GDIAiCjtDNLrggCIKgjwkBCoIgCDpCCFAQBEHQEUKAgiAI\n", + "go4QAhQEQRB0hBCgIAiCoCOEAAVjCkmXpuftJDWqBDncY3+y6FxBEBQT64CCMYmk2cCHzexVLXxm\n", + "XTNb02T/SjPbtB39C4KxQFhAwZhCUlZW+BTg0FQE7URJ60j6kqSrUmbmf07tZ0u6RNLvgAVp21kp\n", + "u/iCLMO4pFOADdPxfpI/l5wvSZovLw74htyx50j6P0mLJP10dK9GEHSWrk3FEwQVkZn8HwM+kllA\n", + "SXAeNbP9JW0A/E3Sn1PbfYDnmdkd6f07zGy5pA2BqyT9ysw+Lun9KfN4/bleC+wN7AVsAVwt6eK0\n", + "7/l4gbB7gUslHWxm4boLxgRhAQVjlfoiaC8F3pZyal0BTAZ2TvuuyokPwImSrgcux7MLzxziXIcA\n", + "P09Jnx8ALgL2wwXqKjO7J+Xkuh7YfgR/UxD0FGEBBUGNE8zs/PyGNFf0eN37w4EDzewpSRcC44c4\n", + "rjFY8DLr6OnctmeJ32QwhggLKBirrATyAQPnAe+TtC6ApF0kbVTwuQnA8iQ+uwEH5vatzj5fxyXA\n", + "G9M80xbAi/A0+EWlqINgzBB3W8FYI7M8bgCeTa60HwBfx91f16U6Kw/g9WnqK0r+CXiPpIXAzbgb\n", + "LuN/8dT415rZP2SfM7PfSnphOqcB/2ZmD0jancEVKSMsNRgzRBh2EARB0BHCBRcEQRB0hBCgIAiC\n", + "oCOEAAVBEAQdIQQoCIIg6AghQEEQBEFHCAEKgiAIOkIIUBAEQdARQoCCIAiCjvD/AXFRJnS871y9\n", + "AAAAAElFTkSuQmCC\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -1782,23 +1821,27 @@ } ], "source": [ - "plot(arange(niter), train_loss)\n", - "xlabel('iteration')\n", - "ylabel('train loss')" + "_, ax1 = subplots()\n", + "ax2 = ax1.twinx()\n", + "ax1.plot(arange(niter), train_loss)\n", + "ax2.plot(test_interval * arange(len(test_acc)), test_acc, 'r')\n", + "ax1.set_xlabel('iteration')\n", + "ax1.set_ylabel('train loss')\n", + "ax2.set_ylabel('test accuracy')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "It seems to have dropped quickly and coverged (except for stochasticity); hooray!\n", + "The loss seems to have dropped quickly and coverged (except for stochasticity), while the accuracy rose correspondingly. Hooray!\n", "\n", "Since we saved the results on the first test batch, we can watch how our prediction scores evolved. We'll plot time on the $x$ axis and each possible label on the $y$, with lightness indicating confidence." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "metadata": { "collapsed": false, "scrolled": false @@ -1908,7 +1951,7 @@ "WjSakdGi0YyMFo1mZLRoNCPz/yU19i71FpCwAAAAAElFTkSuQmCC\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -1918,92 +1961,92 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAEj9JREFUeJzt3X2QXXV9x/HPJ5vdZBNCd0g2S4HY0BZakglPFQbwkWo7\n", - "1FG0rRUpVWo7djpqpVQdkZn2r3a0Mh2p47QzFuoDPrVFQZkWhFaKgJXwkCcSINCREhQICQ8SYzab\n", - "5Ns/7t2wbrLZ892T395z4P2ayXDPud/9nd/e3zlnv5xz7u/riBAAAABmbk6vOwAAANB2JFQAAAA1\n", - "kVABAADUREIFAABQEwkVAABATSRUAAAANc3t5cZtM2cDAABojYjwwdYXTahsnyfpSkl9kq6KiL+d\n", - "HHPRRRcd8HPr16/XySefPLmtQr3MacK8XZnPIvu5HY7Pee3atTr11FNrt1NCZvxKxe7Zs6dy7N69\n", - "eyvHzp2bO5z7+/sPWLdu3TqdcsopB6wfGBgo0o/M/jY6Olo5dteuXZVjs/GZ8cvE7tu3r3LsVJ/x\n", - "5s2bdeKJJx6wPjN+CxcurBw7ODhYOXb+/PmVYzP70Jw55W60ZPbPsbGxyrG7d+8+YN3dd9+tM844\n", - "o1a72fjM/plpN3Peyuz32b+/Jdq+4YYbpnyv2J5ou0/SZySdJ2mFpAttn1RqewAAAL1S8hmqMyU9\n", - "EhGPRsSYpK9JemvB7QEAAPREyYTqWElbJiw/3l03rZGRkSIdwuw4+uije90FzBDHXrstXry4113A\n", - "DB1zzDG97gJqKplQzfhhI07q7UZC1V6MXbuRULXXscdWut6ABiv5UPoPJS2bsLxMnatUP2P9+vX7\n", - "X4+MjJBMAQCARti2bZu2b99eKbZkQnWPpBNsL5f0I0kXSLpwctDkb/MBAAA0wZIlS7RkyZL9y5s3\n", - "b54ytlhCFRF7bH9A0rfVmTbh6oh4oNT2AAAAeqXoPFQRcaOkG0tuAwAAoNd6OlO6VH1StsyEXplJ\n", - "xbKaMLFnRra/mfjMpGmlJnrLxGY1YaxLTbwnlZsoM9OPTGxmksWSEwBmZPpRcvLipvSjqnnz5lWO\n", - "7evrS7Wd+f0y561Sk7iW/HvWhLEuabbzBmr5AQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANRE\n", - "QgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQEwkVAABATT2v5bdz585KcZl6TdnaTiXbLiFT\n", - "BypTXyrbdimZ+lJVa0HOpO1MbBP2oezYlaq5l9nn2vYZZ9ueO7fMKTZ7XGfiS9Wk2717d5HY7GeR\n", - "qdmWGevMuSgTm92HBgYGisRm+lHquM7WHixRy++RRx6Z8r2iV6hsL7N9q+2Ntu+3/cGS2wMAAOiF\n", - "0leoxiRdGhFrbR8h6V7bt0TEA4W3CwAAMGuKXqGKiCcjYm339Q5JD0g6puQ2AQAAZtusPZRue7mk\n", - "0yTdNVvbBAAAmA2zklB1b/ddK+mS7pUqAACAl4zi3/Kz3S/p65K+FBHXT35/06ZN+18PDw9reHi4\n", - "dJcAAACmtX37dj3zzDOVYosmVO58x/FqSZsi4sqDxaxYsaJkFwAAAGZk8eLFWrx48f7lnk2bIOlV\n", - "kv5A0rm213T/nVd4mwAAALOq6BWqiLhDzMYOAABe4kh2AAAAaup56ZmFCxdWistMIZ+JzcZnSiI0\n", - "QbY0S6YMQH9/f+XYUmULsmUZSpWHaEIfsv3NxJcq+1LqMy5ZmiUjU9pjcHCwcuyiRYtS/ci0Xapc\n", - "Tqbky09/+tMisVKuXE4mNrMvL1iwoHJsZh+ScuflTJ8z41eq1FGmBJYkjY6OVo6tOtY33njjlO9x\n", - "hQoAAKAmEioAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYS\n", - "KgAAgJp6XnqmatmATDmSbDmLTNuZshoZmfI3pUonZGX6nClbkFFyrJvQbqYsQ7YsUiY+04/MmGTK\n", - "nJQqiSLljpPM55YtlVFVdn/L9DlzrJbahzKx8+bNqxwr5fajzPk+sw9l9ovsPlTynF9CqbJWUrlz\n", - "0ZRtTPWG7d+VFJIOduRGRHyjygZs90m6R9LjEfGWGfUSAACgwQ6Vkr1FnYRqKpUSKkmXSNokKVfN\n", - "EwAAoCWmTKgi4g/rNm77OElvkvQ3kv6ibnsAAABNNO0NRttH277a9k3d5RW2/7hi+5+S9BFJ7bqp\n", - "CwAAkFDlia3PS7pZ0jHd5YclXTrdD9l+s6StEbFGB38OCwAA4CWhymPtSyLiX2xfJkkRMWa7ylcw\n", - "zpF0vu03SZov6UjbX4yId08M2rhx4/7Xw8PDWrp0afXeAwAAFPLcc8/p+eefrxRbJaHaYXvx+ILt\n", - "syRN23pEXC7p8u7PvE7ShycnU5K0cuXKSh0FAACYTUNDQxoaGtq/vGXLliljqyRUH5J0g6RftP09\n", - "ScOS3j6DflWftAgAAKBFpk2oIuJe26+V9CvqPAv1UESkZhqLiNsk3TazLgIAADTbtAmV7UFJ75P0\n", - "anWuMt1u+x8jYlfpzgEAALRBlVt+X5T0Y0mfVucK1e9LukbS7xXsFwAAQGtUSahWRsSKCcvfsb3p\n", - "cHWgak2qJtSNk5pRm6tU3bg2ytT8knL7Ual9LtNuphZVtq7h4OBg5dj+/v5U21WVqgW3a1fuAnqp\n", - "c8bAwEDl2Pnz51eOzY51Jr5UbdNMbMm6jRmZunhV69JK0s6dOyvHjo6OVo6V8jU9q8qcAzL7fal2\n", - "pdwxVbUm5B133DHle1WOsvtsnz2+0P2W372VtgwAAPAycKjiyBsmxNxpe4s6z1C9QtJDs9A3AACA\n", - "VpiuODIAAACmcajiyI9OXLa9VJ0ZzwEAADBBleLI59t+WNIP1JlL6lFJNxbuFwAAQGtUeSj9ryWd\n", - "LWlzRBwv6Q2S7iraKwAAgBapklCNRcQ2SXNs90XErZJeWbhfAAAArVFlso9nbS+SdLukL9veKmlH\n", - "2W4BAAC0R5UrVG+TtFPSpZJukvSI+AYgAADAflWKI49fjdor6fNFewMAANBCh5rYc4c6E3keTETE\n", - "kYejA5lyBKVkSoFkShGUKnOS6UNTlOpztt1MiZFMqZNMbKZ8UabdbPmUUmVtMvty5vfLlODIlojK\n", - "lKopNSYlxzozJqX2z4xMf7NKlnOqqtQxIuXGr1TJrFKyZdcy8YdjrA81D9URdRu3PSTpKkkr1UnO\n", - "/igivl+3XQAAgCYpXYHy7yX9R0S83fZcSQsLbw8AAGDWFUuobP+cpNdExMWSFBF7JD1fansAAAC9\n", - "UuYGccfxkp62/Tnb99n+J9sLCm4PAACgJ0omVHMlnS7pHyLidEk/kXRZwe0BAAD0RMlnqB6X9HhE\n", - "3N1dvlYHSag2bNiw//XSpUs1MjJSsEsAAADV7Nu3r/I3HIslVBHxpO0ttk+MiM2S3ihp4+S4VatW\n", - "leoCAADAjE2eTuFQ01iU/pbfn6lTrmZA0v9Kek/h7QEAAMy6oglVRKyTdEbJbQAAAPRayYfSAQAA\n", - "XhZK3/KbVtXSM02Y9l7KlcopVeIgE9vf3185Vsr9fgMDA0X6MW/evMqx8+fPrxwrletz5nPL7MuZ\n", - "sZ47N3c4Zz6LBQuqz3hyxBHViywMDQ1Vjl20aFHl2Ex/JWlwcLBybKacRanzVrYER6kSKpl+ZGIz\n", - "x1P2HFfqmMocT5nfLzvWGZn9s21larKq9vlQf5+4QgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIF\n", - "AABQEwkVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAAQE09Lz2zZ8+eSnH79u2r3GZ22vtMfCa2\n", - "VFmGUrFSubIMpconlBzrTKmFjMznlonNluDIyHwWVY/pbGzmHNCUkkSljpHsfp/57Eq1Ozo6WiR2\n", - "bGyscqwk7d69u3JsZv8stV9k9s1sfOZ8n9k/M+eLzPhlxq5kP6ZS9AqV7Y/Z3mh7g+2v2K5epA0A\n", - "AKAliiVUtpdLeq+k0yNilaQ+Se8stT0AAIBeKXnL78eSxiQtsL1X0gJJPyy4PQAAgJ4odoUqIp6R\n", - "9HeSHpP0I0nPRcR/ltoeAABAr5S85fdLkv5c0nJJx0g6wvZFpbYHAADQKyVv+b1S0vciYrsk2f6G\n", - "pHMkfXli0IYNG/a/Xrp0qUZGRgp2CQAAoJqnn35a27ZtqxRbMqF6UNJf2h6UtEvSGyWtnhy0atWq\n", - "gl0AAACYmeHhYQ0PD+9ffvDBB6eMLfkM1TpJX5R0j6T13dWfLbU9AACAXik6sWdEfFLSJ0tuAwAA\n", - "oNcoPQMAAFATCRUAAEBNPa/lV7U+UF9fX+U2M/WJMn1oY2y25ldGqX6U7HOpWoWl6nhl2s0cI9m2\n", - "M0rV3cx8btlafgsWLCjSdqY+2M6dOyvH7tixo3Jsth+ZMcnUjRsaGqocu3Dhwsqxmf1Cyh0npepu\n", - "Zs6d2b9npepuNkH2HFdirK+77rop3+MKFQAAQE0kVAAAADWRUAEAANREQgUAAFATCRUAAEBNJFQA\n", - "AAA1NTKheuqpp3rdBdTwxBNP9LoLmKHHHnus111ADYxfe23evLnXXUBNjUyotm7d2usuoIYnn3yy\n", - "113ADPEHud0Yv/YioWq/RiZUAAAAbUJCBQAAUJNLlvmYduN27zYOAACQFBEHrR3U04QKAADgpYBb\n", - "fgAAADWRUAEAANTUuITK9nm2H7T9sO2P9ro/mJrtf7b9lO0NE9YdZfsW25tt32x7qJd9xNRsL7N9\n", - "q+2Ntu+3/cHuesaw4WzPt32X7bW2N9n+eHc9Y9citvtsr7F9Q3eZ8WuxRiVUtvskfUbSeZJWSLrQ\n", - "9km97RUO4XPqjNVEl0m6JSJOlPRf3WU005ikSyNipaSzJL2/e7wxhg0XEbsknRsRp0o6WdK5tl8t\n", - "xq5tLpG0SdL4w8yMX4s1KqGSdKakRyLi0YgYk/Q1SW/tcZ8whYi4XdKzk1afL+kL3ddfkPS2We0U\n", - "KouIJyNibff1DkkPSDpWjGErRMTO7ssBSX3qHIuMXUvYPk7SmyRdJWn8W2OMX4s1LaE6VtKWCcuP\n", - "d9ehPUYiYrx20FOSRnrZGVRje7mk0yTdJcawFWzPsb1WnTG6NSI2irFrk09J+oikfRPWMX4t1rSE\n", - "ijkcXkKiMycHY9pwto+Q9HVJl0TECxPfYwybKyL2dW/5HSfptbbPnfQ+Y9dQtt8saWtErNGLV6d+\n", - "BuPXPk1LqH4oadmE5WXqXKVCezxl+2hJsv3zkijM2GC2+9VJpq6JiOu7qxnDFomI5yX9u6RfE2PX\n", - "FudIOt/2DyR9VdKv275GjF+rNS2hukfSCbaX2x6QdIGkb/W4T8j5lqSLu68vlnT9IWLRQ7Yt6WpJ\n", - "myLiyglvMYYNZ3vJ+DfAbA9K+g1Ja8TYtUJEXB4RyyLieEnvlPSdiHiXGL9Wa9xM6bZ/S9KV6jxk\n", - "eXVEfLzHXcIUbH9V0uskLVHnfv9fSfqmpH+V9ApJj0p6R0Q816s+Ymrdb4V9V9J6vXhr4WOSVosx\n", - "bDTbq9R5aHlO9981EXGF7aPE2LWK7ddJ+lBEnM/4tVvjEioAAIC2adotPwAAgNYhoQIAAKiJhAoA\n", - "AKAmEioAAICaSKgAAABqIqECAACoiYQKQM/ZvrP731+wfeFhbvvyg20LAA4n5qEC0Bi2X6/OJIdv\n", - "SfzM3IjYc4j3X4iIRYejfwAwFa5QAeg52zu6Lz8h6TW219i+xPYc21fYXm17ne0/6ca/3vbttr8p\n", - "6f7uuutt32P7ftvv7a77hKTBbnvXTNyWO66wvcH2etvvmND2f9v+N9sP2P7S7H4aANpobq87AAB6\n", - "sfTNRyV9ePwKVTeBei4izrQ9T9Idtm/uxp4maWVE/F93+T0R8Wy3tt1q29dGxGW23x8Rpx1kW78j\n", - "6RRJJ0salnS37e923ztV0gpJT0i60/arIoJbhQCmxBUqAE3iScu/KendttdI+r6koyT9cve91ROS\n", - "KUm6xPZaSf8jaZmkE6bZ1qslfSU6tkq6TdIZ6iRcqyPiR9F5JmKtpOU1ficALwNcoQLQdB+IiFsm\n", - "rug+a/WTSctvkHRWROyyfauk+dO0GzowgRu/ejU6Yd1eca4EMA2uUAFokhckTXyA/NuS3md7riTZ\n", - "PtH2goP83JGSnu0mU78q6awJ742N//wkt0u6oPuc1rCk10parQOTLACYFv/XBaAJxq8MrZO0t3vr\n", - "7nOSPq3O7bb7bFvSVkm/3Y2f+BXlmyT9qe1Nkh5S57bfuM9KWm/73oh41/jPRcR1ts/ubjMkfSQi\n", - "tto+aVLbOsgyAPwMpk0AAACoiVt+AAAANZFQAQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANRE\n", - "QgUAAFATCRUAAEBN/w/rm9is+RzYUQAAAABJRU5ErkJggg==\n" + "AAALEgAACxIB0t1+/AAAEjpJREFUeJzt3X+QXXV5x/HPJ793ITSAiWyysaEttsBoDRFYEEGq7VBG\n", + "0bZWpa1S27HTUQulyojMtH+1o5XpiI7TzlgoCv5qqxZ1WhFaU0TsJhASfiQBsUNawq9N24DEZZMl\n", + "PP3j3oRls5s9T06+e84N79dMhnvOfe73fO/5nnv34Zxzv48jQgAAADh0c5ruAAAAQK8joQIAAKiJ\n", + "hAoAAKAmEioAAICaSKgAAABqIqECAACoaV6TG7fNnA0AAKBnRISnWl80obJ9gaRrJM2VdG1E/OXk\n", + "mEsvvfSA1w0PD2toaOhF60rOl5Vpe+/evcX60QZz5lQ/aWlPeUxp3bp1OvPMMw9Xlw6rzPg9//zz\n", + "Rdp97rnnisRmxk6S5s6de8C6jRs3avXq1QesX7BgQbF+VLVnz57KsaOjo6m2x8bGKseOj49Xjs0c\n", + "F5nYqcZOkh566CGddNJJB6xfuHBh5bb7+voqxy5atKhI7Lx51f80TbcvpjPd99ZUMn8bMsfF7t27\n", + "D1i3YcMGrVmz5oD1mWNzuranU7fP02nD92wpa9eunfa5Ypf8bM+V9BlJF0g6RdLFtk8utT0AAICm\n", + "lLyH6gxJP4qIbRExLukrkt5acHsAAACNKJlQrZD0yITl7d11MxocHCzSIcyOFSsqDTNa6IQTTmi6\n", + "C6jhuOOOa7oLOEQDAwNNdwE1lUyoDvmmJxKq3sb49S6+1Hvb8ccf33QXcIiWL1/edBdQU8mb0h+V\n", + "tHLC8kp1zlK9yPDw8P7Hg4OD/DEGAACtsHPnTj311FOVYksmVHdJOsn2KkmPSXqnpIsnB03+NR8A\n", + "AEAbHHvssTr22GP3L2/btm3a2GIJVUQ8Z/uDkr6jzrQJ10XE1lLbAwAAaErReagi4tuSvl1yGwAA\n", + "AE1rdKZ0qR0TdWUmFis1wWim3Uxs5r1J5SZka0Os1I79XGqywOxnKdN2ZoLRUpOcZmTbzeyLTGxm\n", + "MtKM7OSpmcksMxNlZvqRaTczEWl2X5SayLnUhL3ZYzmzP0rFZiZmzcRmxzoTn/1bMuX2arcAAADw\n", + "EkdCBQAAUBMJFQAAQE0kVAAAADWRUAEAANREQgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQ\n", + "EwkVAABATY3X8svU8ek1baj7V7LtUnUYMzWVsn0oue96TWbftaE+X0mZ4yLznZWpX1eqxqNUrnZc\n", + "ps+ZdsfGxirHZvdF5lguVb+uv7+/cuyiRYsqx0q5OoiZ2Pnz51eOzey3TJ3JTKyUO+ZaX8vP9krb\n", + "a21vtn2/7UtLbg8AAKAJpU8PjUu6PCI22T5a0gbbt0bE1sLbBQAAmDVFz1BFxBMRsan7eJekrZKW\n", + "l9wmAADAbJu1m9Jtr5K0WtK62domAADAbJiVhKp7ue+rki7rnqkCAAA4YhT/iZ3t+ZK+JukLEXHT\n", + "5OeHh4f3Px4cHNTg4GDpLgEAAMxoZGREIyMjlWKLJlTu/MbxOklbIuKaqWKGhoZKdgEAAOCQLFu2\n", + "TMuWLdu/vHnz5mljS1/ye52k35F0vu2N3X8XFN4mAADArCp6hioivi9mYwcAAEc4kh0AAICaGq/7\n", + "UnW69+yU80eykvuiVBmANsRm4zPlEzIlRkrFltRrJXuy5W8y7y9zXCxYsKBybF9fX+XYo446qnKs\n", + "lCsbkpEp+7Jnz57KsaOjo5Vjn3322cqxUq7ESOb7IlMiZsmSJZVjFy9eXDlWypXAyeyLUmOSic2W\n", + "GcrEH47vOM5QAQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANREQgUAAFATCRUAAEBNJFQAAAA1\n", + "kVABAADUREIFAABQU+OlZ6qWcchMC9+WMhml+pwpF1BSpgRHJjajZBmevXv3Vo7NlkQo0YdsuZVM\n", + "fOaYK1WyJzPW2c9I5vOXKaGSGb9S+03KjXXm/WVid+/eXTk2Mx6Zki9SrhxQZkwyfR4bG6scu2vX\n", + "rsqxUv57oKrM5y9T6ihTKmfhwoWVY6VypcamM+07sf0bkkLSVD2KiPh6lQ3YnivpLknbI+Ith9RL\n", + "AACAFjtYavgWdRKq6VRKqCRdJmmLpFyFRwAAgB4xbUIVEb9bt3Hbg5IulPQXkv6kbnsAAABtNONF\n", + "Q9sn2L7O9s3d5VNs/37F9j8p6QpJ7bjpBwAAoIAqd2F9TtItkpZ3lx+SdPlML7L9ZkkjEbFRU9+H\n", + "BQAAcESocnv9yyLi721fKUkRMW67ys8IzpZ0ke0LJS2SdIztGyLiPRODhoeH9z8eHBzU4OBg9d4D\n", + "AAAUsmPHDu3YsaNSbJWEapft4/ct2B6S9PRML4qIqyRd1X3NeZI+PDmZkqShoaFKHQUAAJhNS5cu\n", + "1dKlS/cvb926ddrYKgnVhyR9S9LP2P6BpKWS3n4I/WrH5FAAAACH2YwJVURssH2upJ9X516oByMi\n", + "NYthRNwm6bZD6yIAAEC7zZhQ2e6T9H5J56hzlul2238TEdWnegUAADiCVbnkd4OkH0v6tDpnqH5L\n", + "0o2SfrNgvwAAAHpGlYTq1Ig4ZcLyd21vOVwdqFoLqmQtv1JtZ2IzNYdK1q/LyNRLK1VfMVMrTcr1\n", + "OROb7UdVmTpX2fpumdpVmX5k6ruNjo5Wji1Vjy4rs98ydeMydcqytQozx0amNl5/f3+RPmS0pbZp\n", + "5pjLjHXmsyfl9kem7UxsppZf5rjItFu67alU+Wa42/ZZ+xa6v/LbUHvLAAAAR4iDFUe+b0LMHbYf\n", + "UeceqldIenAW+gYAANATZiqODAAAgBkcrDjytonLtpepM+M5AAAAJqhSHPki2w9JeliduaS2Sfp2\n", + "4X4BAAD0jCo3pf+5pLMk/TAiTpT0RknrivYKAACgh1RJqMYj4n8kzbE9NyLWSnpt4X4BAAD0jCoT\n", + "S+y0vVjS7ZK+aHtE0q6y3QIAAOgdVc5QvU3SqKTLJd0s6UfiF4AAAAD7VSmOvO9s1F5JnyvaGwAA\n", + "gB50sIk9d6kzkedUIiKOORwdyJSTqCpbmqVUWZRMP0qVRMkq1Y/MOGfGI1vypQ39yPQhE7t79+7K\n", + "sdm2Sx1zpY637Gd6bKx6rfdMbGZMSrUrteP7pVQZpUwpIKlc6a7MfhsfH68cmy2jlGm7VHm0UmWt\n", + "SpaeORylkQ42D9XRdRu3vUTStZJOVSc5+72IGK7bLgAAQJvkqi7mfUrSv0TE223Pk3RU4e0BAADM\n", + "umIJle2fkvT6iLhEkiLiOUlPl9oeAABAU3IXn3NOlLTD9vW277b9t7b7C24PAACgESUTqnmSTpP0\n", + "1xFxmqSfSLqy4PYAAAAaUfIequ2StkfEnd3lr2qKhGrDhg37Hw8MDGj58uUFuwQAAFDN+Ph45V9O\n", + "FkuoIuIJ24/YfmVE/FDSmyRtnhy3Zs2aUl0AAAA4ZPPnz3/RdA0Hm96k9K/8/kidcjULJP2npPcW\n", + "3h4AAMCsK5pQRcQ9kk4vuQ0AAICmlbwpHQAA4CWh9CW/GVWd7r3UtPeZPmTbLtVuqdiSbWf2xYIF\n", + "CyrHLlq0qHKsJC1cuLBIbKZ8QqlSR9mxzvQ5Myb9/dVnR1myZEnl2MWLF1eOPeqo3BzCmfjMfsso\n", + "+bnOKFVGKVOaJfN9kS1HUqrUSeYzUqr8jdSeck5Nt5tVtR8H+5vDGSoAAICaSKgAAABqIqECAACo\n", + "iYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJpIqAAAAGpqvPRM1Sn4S5ZaKDX9\n", + "fqbdTCmCTGzJaf1L9SOz3zKlL0r2I9NuqZIv2XIWmfc3Pj5eOTYzJqXaLVmSqFRppMwxlD3uM+Vk\n", + "SrW7Z8+eyrGZ4yJ73GfaLlUup2RpnUx85rso8xnJHMuljotsfKYf0yl6hsr2R21vtn2f7S/Zrj4i\n", + "AAAAPaJYQmV7laT3STotIl4laa6kd5XaHgAAQFNKXvL7saRxSf2290rql/Rowe0BAAA0otgZqoj4\n", + "P0l/Jem/JT0m6amI+NdS2wMAAGhKyUt+PyvpjyWtkrRc0tG2f7vU9gAAAJpS8pLfayX9ICL+V5Js\n", + "f13S2ZK+ODHozjvv3P94+fLlWrFiRcEuAQAAVPP444/riSeeqBRbMqF6QNKf2u6TNCbpTZLWTw46\n", + "/fTTC3YBAADg0AwMDGhgYGD/8qZNm6aNLXkP1T2SbpB0l6R7u6s/W2p7AAAATSk6sWdEfELSJ0pu\n", + "AwAAoGmUngEAAKiJhAoAAKCmxmv5ZWoaHclK1dwrWcuvlExtrkwtqqzMsZnpR6bdTA3LkjW/MkrV\n", + "QMzst2wtv/7+/sqxmVp+Y2NjlWNHR0eLxErl9nNfX1+R2Mz4ZWuwZY7PzOcvs98ydfEyx2a2H5la\n", + "jKXqoJaqMynlxq/qd/j1118//fYqbw0AAABTIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAA\n", + "qKmVCdX27dub7gJqYPx618MPP9x0F1DDtm3bmu4CDtEDDzzQdBdQUysTqkcffbTpLqAGEqreRULV\n", + "20ioehcJVe9rZUIFAADQS0ioAAAAanKTpUls915dFAAA8JIVEVPWR2s0oQIAADgScMkPAACgJhIq\n", + "AACAmlqXUNm+wPYDth+y/ZGm+4Pp2f4720/avm/CuuNs32r7h7Zvsb2kyT5ierZX2l5re7Pt+21f\n", + "2l3PGLac7UW219neZHuL7Y911zN2PcT2XNsbbX+ru8z49bBWJVS250r6jKQLJJ0i6WLbJzfbKxzE\n", + "9eqM1URXSro1Il4p6d+6y2incUmXR8SpkoYkfaD7eWMMWy4ixiSdHxGvkfRqSefbPkeMXa+5TNIW\n", + "SftuZmb8elirEipJZ0j6UURsi4hxSV+R9NaG+4RpRMTtknZOWn2RpM93H39e0ttmtVOoLCKeiIhN\n", + "3ce7JG2VtEKMYU+IiNHuwwWS5qrzWWTseoTtQUkXSrpW0r5fjTF+PaxtCdUKSY9MWN7eXYfe8fKI\n", + "eLL7+ElJL2+yM6jG9ipJqyWtE2PYE2zPsb1JnTFaGxGbxdj1kk9KukLS8xPWMX49rG0JFXM4HEGi\n", + "MycHY9pyto+W9DVJl0XEMxOfYwzbKyKe717yG5R0ru3zJz3P2LWU7TdLGomIjXrh7NSLMH69p20J\n", + "1aOSVk5YXqnOWSr0jidtnyBJtgckjTTcHxyE7fnqJFM3RsRN3dWMYQ+JiKcl/bOkNWLsesXZki6y\n", + "/bCkL0v6Jds3ivHraW1LqO6SdJLtVbYXSHqnpG823CfkfFPSJd3Hl0i66SCxaJBtS7pO0paIuGbC\n", + "U4xhy9l+2b5fgNnuk/TLkjaKsesJEXFVRKyMiBMlvUvSdyPi3WL8elrrZkq3/auSrlHnJsvrIuJj\n", + "DXcJ07D9ZUnnSXqZOtf7/0zSNyT9g6RXSNom6R0R8VRTfcT0ur8K+56ke/XCpYWPSlovxrDVbL9K\n", + "nZuW53T/3RgRV9s+ToxdT7F9nqQPRcRFjF9va11CBQAA0GvadskPAACg55BQAQAA1ERCBQAAUBMJ\n", + "FQAAQE0kVAAAADWRUAEAANREQgWgcbbv6P73p21ffJjbvmqqbQHA4cQ8VABaw/Yb1Jnk8C2J18yL\n", + "iOcO8vwzEbH4cPQPAKbDGSoAjbO9q/vw45Jeb3uj7ctsz7F9te31tu+x/Qfd+DfYvt32NyTd3113\n", + "k+27bN9v+33ddR+X1Ndt78aJ23LH1bbvs32v7XdMaPvfbf+j7a22vzC7ewNAL5rXdAcAQC+UvvmI\n", + "pA/vO0PVTaCeiogzbC+U9H3bt3RjV0s6NSL+q7v83ojY2a1tt972VyPiStsfiIjVU2zr1yX9oqRX\n", + "S1oq6U7b3+s+9xpJp0h6XNIdtl8XEVwqBDAtzlABaBNPWv4VSe+xvVHSsKTjJP1c97n1E5IpSbrM\n", + "9iZJ/yFppaSTZtjWOZK+FB0jkm6TdLo6Cdf6iHgsOvdEbJK0qsZ7AvASwBkqAG33wYi4deKK7r1W\n", + "P5m0/EZJQxExZnutpEUztBs6MIHbd/Zq94R1e8V3JYAZcIYKQJs8I2niDeTfkfR+2/MkyfYrbfdP\n", + "8bpjJO3sJlO/IGlownPj+14/ye2S3tm9T2uppHMlrdeBSRYAzIj/6wLQBvvODN0jaW/30t31kj6t\n", + "zuW2u21b0oikX+vGT/yJ8s2S/tD2FkkPqnPZb5/PSrrX9oaIePe+10XEP9k+q7vNkHRFRIzYPnlS\n", + "25piGQBehGkTAAAAauKSHwAAQE0kVAAAADWRUAEAANREQgUAAFATCRUAAEBNJFQAAAA1kVABAADU\n", + "REIFAABQ0/8Dsw8TC+BipngAAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2128,7 +2171,7 @@ "pDExN0zSmJgbJmlMzA2TNCbmhkkaE3Pj/wFJ7Hv45ZreFAAAAABJRU5ErkJggg==\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2138,95 +2181,96 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAEvZJREFUeJzt3X2QXXV9x/HPJ5vnJ4RKtWrILg+2AQxi1cEHDATLEEfR\n", - "tlSlrYjt2OmolVJ1QGbafyyj1elIHaedsVIVRC1FCzotCk0gRq1EMCGEBB86hAcppIE8bzbZLN/+\n", - "ce+GZbObPd89+e25F96vGYZ77v3u7/zu/f3uvd+cc+7v64gQAAAAJm9a0x0AAADodiRUAAAANZFQ\n", - "AQAA1ERCBQAAUBMJFQAAQE0kVAAAADVNb3LntlmzAQAAdI2I8Fj3F02obF8g6RpJPZK+GBF/Nzrm\n", - "6quvPuzvVq5cqfPOO290W5n9pvqZWYurE9btyjy/adNyByGz8WO57bbbdP7559dup5tk5sXQ0FDl\n", - "2IMHD1aOnTVrVuVYSZo9e/Zh9916661asWLFYffPmTOnSD8y821gYKBybH9/f+VYSdq7d2/l2AMH\n", - "DlSOHRwcrBybmRfjvcZ33nmnzjnnnMPunzdvXuW2jz322MqxxxxzTOXYhQsXVo7NzKHp03NfYz09\n", - "PZVjM/Nz//79tWKvu+46XXLJJYfdv2/fvsrtSp0xPzOxnfCdKlX/Xr300kvHfazYKT/bPZI+L+kC\n", - "SadKutj2klL7AwAAaErJa6heK+mXEbElIgYlfUPS2wvuDwAAoBElE6qXSnpkxPaj7fsm1NfXV6RD\n", - "mBonnXRS013AJJ188slNdwE19Pb2Nt0FTNIZZ5zRdBdQU8mEatInRk888cSj2Q9MMRKq7nXKKac0\n", - "3QXUQELVvUioul/Ji9J/JWnRiO1Fah2lepaVK1ceut3X10cyBQAAOsLmzZv1wAMPVIotmVDdLekU\n", - "272SHpP0LkkXjw4a/Ws+AACATrBkyRItWfLM7+luueWWcWOLJVQRcdD2hyR9T61lE66NiM2l9gcA\n", - "ANCUoutQRcStkm4tuQ8AAICmNbpSuiQ9/fTTjbdZamGxUouRZmIzC6w9H5Ra1C+zuGBm0cLM3MzO\n", - "+8zilzt27Kgcm1mMNNPnzGucXdw3I9P2WIunjiczN7PPL7OA47Zt24rEZt5PmYVkZ8yYUTk224/M\n", - "/Cw177Of4Znnl5lHmc+iUt9n2e/qzOucWRB1PNTyAwAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIA\n", - "AKiJhAoAAKAmEioAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmhqv5bd///5KcTNnzqzcZiY2\n", - "G5+pJ5apqZSRqU+Ure+WqUeVqTGV6Uep2opSZ9TnK1WnLNNfqdw8ytTmKvW6ZWKl3GfAvHnzivQj\n", - "Mzez75FSNT1L1cWr+r0wGSXrPFaVmW+ZepDZ+MxczrSb+SwqVV81q+p33xVXXDHuY0WPUNleZPsO\n", - "2/fb3mj7wyX3BwAA0ITSR6gGJV0eEettz5d0j+3bI2Jz4f0CAABMmaJHqCLi8YhY3769R9JmSS8p\n", - "uU8AAICpNmUXpdvulXSmpLumap8AAABTYUoSqvbpvpskXdY+UgUAAPCcUfxXfrZnSPqmpK9GxM2j\n", - "H1+9evWh24sXL1Zvb2/pLgEAAExo9erVz8pTjqRoQuXW71OvlbQpIq4ZK2bZsmUluwAAADApy5Yt\n", - "e1ae8olPfGLc2NKn/N4g6Y8lnWt7Xfu/CwrvEwAAYEoVPUIVET8Qq7EDAIDnOJIdAACAmhovPbNg\n", - "wYJKcZlSC9lyK/39/ZVjS5ZFKaFkmYVSZVwypQiy5VYyr0epMgf79u2rHHvgwIEifZByzy8zJpnY\n", - "jEw5kscff7xY25nPl8z8nDt3buXYhQsXVo6VypXAyZS0GRwcrBy7a9euyrE7d+6sHJvtR6YUV6ZM\n", - "VKnyRVKunFOmz6XKh2Ve48zYZeOPRnkmjlABAADUREIFAABQEwkVAABATSRUAAAANZFQAQAA1ERC\n", - "BQAAUBMJFQAAQE0kVAAAADWRUAEAANREQgUAAFBT46VnduzYUSmuVBkQKVeOJBObWao/E5tZIj9b\n", - "hifTdia2VOmg7PPL9CPz/DLlEzLtZsrU7Nmzp3Jstu1MCZzMeyRTmiVbZqiUgYGByrGZkjaZz7js\n", - "52GpEhylyoZk3qczZ86sHCuVm0eZz6LMvMjMNyn3Omf6kfkMKPXdULL029Eo0zbuzLL9+5JC0lh7\n", - "iYj4VpUd2O6RdLekRyPibZPqJQAAQAc7Uqr+NrUSqvFUSqgkXSZpk6RqVZABAAC6zLgJVURcWrdx\n", - "2y+T9BZJV0v6q7rtAQAAdKIJT8TbfrHta21/t719qu0/rdj+ZyV9TFLuQhcAAIAuUuXKxi9Luk3S\n", - "S9rbv5B0+UR/ZPutkrZGxDqNfR0WAADAc0KVnzu8MCL+1faVkhQRg7ar/LTj9ZIutP0WSbMlLbR9\n", - "XURcMjJozZo1h26fcMIJWrx4cfXeAwAAFDI0NFT5F5xVEqo9tn9teMP2WZJ2TvRHEXGVpKvaf7NM\n", - "0kdHJ1OSdPbZZ1fqKAAAwFTq6elRT0/Poe0jLRVSJaH6iKTvSDrR9o8kHS/pokn0q9wCEgAAAA2a\n", - "MKGKiHtsv0nSb6p1LdTPIqL6ymGtNlZLWj25LgIAAHS2CRMq23MkfUDSG9U6yrTG9j9FRG75VgAA\n", - "gOeoKqf8rpO0S9Ln1DpC9YeSrpf0BwX7BQAA0DWqJFSnRcSpI7ZX2d50tDowa9aso9XUIUejJs/R\n", - "UKpGYKYWVbbmV6l6YpnYkRcATiQ71pm2S9WPzLQ7e/bsyrEzZsxI9WPOnDmVY+fNm1c5NjM/M3XH\n", - "MnXj9u7dWzlWytUey8i8xgsWVC8mka1Hl3mfZOqlZdrNzPvM88uOXam6ok899VTl2O3bt1eO3b17\n", - "d+VYKVf7L/PaZT47M+OXyQGydRszbVd9r1500fiXkFeZ4T+1/brhjfav/O6ptGcAAIDngSMVR75v\n", - "RMwPbT+i1jVUJ0j62RT0DQAAoCtMVBwZAAAAEzhSceQtI7dt/7paK54DAABghCrFkS+0/QtJD6q1\n", - "ltQWSbcW7hcAAEDXqHJR+t9Kep2kn0dEn6TzJN1VtFcAAABdpEpCNRgR2yRNs90TEXdIenXhfgEA\n", - "AHSNKotFbLe9QNIaSTfY3ippT9luAQAAdI8qR6jeIalf0uWSvivpl+IXgAAAAIdUKY48fDRqSNKX\n", - "i/YGAACgCx1pYc89ai3kOZaIiIVHowOZ5ey7TabEQSY2U64jW5qlVDmZUmV4ss+vVFmNUmNdqlyH\n", - "lCtrkyk9kykPUWoOZT9XSpVQybS7b9++In2QcnMjU+InU5qlVPmp7GuRKdGUed2OP/74yrHHHnts\n", - "5dj9+/dXjpVy8+jAgQOVY0vNi1Kfh9n4o1Fq7EjrUM2v27jtF0j6oqTT1ErO/iQifly3XQAAgE6S\n", - "+ydt3j9I+s+IuMj2dEnV/5kLAADQJYolVLaPkXR2RLxXkiLioKSdpfYHAADQlPonDcfXJ+n/bH/J\n", - "9k9t/7PtuQX3BwAA0IiSCdV0Sa+S9I8R8SpJeyVdWXB/AAAAjSh5DdWjkh6NiJ+0t2/SGAnVqlWr\n", - "Dt3u6+tTX19fwS4BAABUs3HjRm3cuLFSbLGEKiIet/2I7ZdHxM8lvVnS/aPjli9fXqoLAAAAk3b6\n", - "6afr9NNPP7R94403jhtb+ld+f6FWuZqZkv5H0vsK7w8AAGDKFU2oIuJeSa8puQ8AAICmlbwoHQAA\n", - "4Hmh9Cm/CVUtMTA0NFS5zcyy9yXbziypn+1zKZk+d2O7mbHOlGXIlHvYtWtX5di9e/dWju3v768c\n", - "K5UrO5GRKe1RqhRQ1sDAQOXY3bt3V47NzKFsOZLM+GVKW2Xazbz3siWlMkrNjVIlbUqWUSqlVJmh\n", - "7Gsx1aVnOEIFAABQEwkVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANRE\n", - "QgUAAFATCRUAAEBNjZeeqVqOIFOapWQZl8zy9JkSAKWWyM8up58piTBz5sxi/agqW0YiE58plZFp\n", - "N/O6zZ49u3JspvSFlJufpUr2lCpdMn/+/MqxkjR37tzKsZkxKfUeyX7GlSq3kulHqdI62dciW7an\n", - "qsycy8QuXLgw1Y9M/KxZsyrHZr4bMu/VzHhk5pCUK6NUtR8rVqwY97GiR6hsf9z2/bbvs/0129VH\n", - "DwAAoEsUS6hs90p6v6RXRcQrJPVIenep/QEAADSl5Cm/XZIGJc21PSRprqRfFdwfAABAI4odoYqI\n", - "pyT9vaSHJT0maUdE/Fep/QEAADSl5Cm/kyT9paReSS+RNN/2H5XaHwAAQFNKnvJ7taQfRcSTkmT7\n", - "W5JeL+mGkUGrVq06dLuvr099fX0FuwQAAFDNhg0btGHDhkqxJROqByT9te05kgYkvVnS2tFBy5cv\n", - "L9gFAACAyVm6dKmWLl16aPuGG24YN7bkNVT3SrpO0t2ShtO7L5TaHwAAQFOKLuwZEZ+W9OmS+wAA\n", - "AGgapWcAAABqIqECAACoqWtq+ZVUqj5fRqkac5m6alK5momZPmdiM7WapFyfO6H+WUa2v5l+DAwM\n", - "VI7t7++vHJupzZUZ6+z7NFOnLGPnzp2VY7dt21Y59sknn0z1Y8+ePZVjM2OdmXM9PT2VYzP1ErPz\n", - "PjM3SsWWVPLzs4TM65aZQ9n4bC3UsXCECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioA\n", - "AICaOjKhevDBB5vuAmp46KGHmu4CJumxxx5ruguoIbtMCjrHwYMHm+4CaurIhGrLli1NdwE1PPzw\n", - "w013AZNEQtXdOmFdIUxOJ6zJiHo6MqECAADoJiRUAAAANblUeY1KO7eb2zkAAEBSRIxZL6fRhAoA\n", - "AOC5gFN+AAAANZFQAQAA1NRxCZXtC2w/YPsXtq9ouj8Yn+1/sf2E7ftG3Hec7dtt/9z2bbZf0GQf\n", - "MT7bi2zfYft+2xttf7h9P2PY4WzPtn2X7fW2N9n+ZPt+xq6L2O6xvc72d9rbjF8X66iEynaPpM9L\n", - "ukDSqZIutr2k2V7hCL6k1liNdKWk2yPi5ZJWtrfRmQYlXR4Rp0k6S9IH2+83xrDDRcSApHMj4pWS\n", - "lko61/Ybxdh1m8skbZI0fDEz49fFOiqhkvRaSb+MiC0RMSjpG5Le3nCfMI6IWCNp+6i7L5T0lfbt\n", - "r0h6x5R2CpVFxOMRsb59e4+kzZJeKsawK0REf/vmTEk9ar0XGbsuYftlkt4i6YuShn81xvh1sU5L\n", - "qF4q6ZER24+270P3eFFEPNG+/YSkFzXZGVRju1fSmZLuEmPYFWxPs71erTG6IyLuF2PXTT4r6WOS\n", - "nh5xH+PXxTotoWINh+eQaK3JwZh2ONvzJX1T0mURsXvkY4xh54qIp9un/F4m6U22zx31OGPXoWy/\n", - "VdLWiFinZ45OPQvj1306LaH6laRFI7YXqXWUCt3jCdsvliTbvyFpa8P9wRHYnqFWMnV9RNzcvpsx\n", - "7CIRsVPSf0j6bTF23eL1ki60/aCkr0tabvt6MX5drdMSqrslnWK71/ZMSe+S9O2G+4Scb0t6b/v2\n", - "eyXdfIRYNMi2JV0raVNEXDPiIcaww9l+4fAvwGzPkfQ7ktaJsesKEXFVRCyKiD5J75a0KiLeI8av\n", - "q3XcSum2V0i6Rq2LLK+NiE823CWMw/bXJS2T9EK1zvf/jaRbJN0o6QRJWyS9MyJ2NNVHjK/9q7Dv\n", - "S9qgZ04tfFzSWjGGHc32K9S6aHla+7/rI+Izto8TY9dVbC+T9JGIuJDx624dl1ABAAB0m0475QcA\n", - "ANB1SKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAtA42z9s/3+x7YuPcttXjbUvADia\n", - "WIcKQMewfY5aixy+LfE30yPi4BEe3x0RC45G/wBgPByhAtA423vaNz8l6Wzb62xfZnua7c/YXmv7\n", - "Xtt/1o4/x/Ya27dI2ti+72bbd9veaPv97fs+JWlOu73rR+7LLZ+xfZ/tDbbfOaLtO23/m+3Ntr86\n", - "ta8GgG40vekOAICeKX1zhaSPDh+haidQOyLitbZnSfqB7dvasWdKOi0iHmpvvy8itrdr2621fVNE\n", - "XGn7gxFx5hj7+j1JZ0haKul4ST+x/f32Y6+UdKqk/5X0Q9tviAhOFQIYF0eoAHQSj9o+X9IlttdJ\n", - "+rGk4ySd3H5s7YhkSpIus71e0n9LWiTplAn29UZJX4uWrZJWS3qNWgnX2oh4LFrXRKyX1FvjOQF4\n", - "HuAIFYBO96GIuH3kHe1rrfaO2j5P0lkRMWD7DkmzJ2g3dHgCN3z0av+I+4bEZyWACXCECkAn2S1p\n", - "5AXk35P0AdvTJcn2y23PHePvFkra3k6mfkvSWSMeGxz++1HWSHpX+zqt4yW9SdJaHZ5kAcCE+FcX\n", - "gE4wfGToXklD7VN3X5L0ObVOt/3UtiVtlfS77fiRP1H+rqQ/t71J0s/UOu037AuSNti+JyLeM/x3\n", - "EfHvtl/X3mdI+lhEbLW9ZFTbGmMbAJ6FZRMAAABq4pQfAABATSRUAAAANZFQAQAA1ERCBQAAUBMJ\n", - "FQAAQE0kVAAAADWRUAEAANREQgUAAFDT/wNpIwQCSUJFIQAAAABJRU5ErkJggg==\n" + "AAALEgAACxIB0t1+/AAAEx1JREFUeJzt3X2QXXV9x/HPJ4+bZPOglUqV2BsabAVNg1UHfEzQdigj\n", + "aFur0Fap7djpqJUSdURm2vGPMlqdjg/jtDNWqoAibdWiTqtCYaNRkQhmCU8+pAMFFEhLMdnN4yb5\n", + "9o97N1mS3ezvuye/vffi+zWT4T5895zvnt+5Z7+cc+7v64gQAAAAZm5OtxMAAADodxRUAAAADVFQ\n", + "AQAANERBBQAA0BAFFQAAQEMUVAAAAA3N6+bKbTNnAwAA6BsR4cler1pQ2T5X0kckzZX0yYj426Nj\n", + "3ve+9x3zc0NDQ1q/fn3N1J4gMxfXoUOHKmZSxp50LCc1Z07uJGQmfqo8br75Zp1zzjknfLknQmas\n", + "Dxw4UBx78ODB4tixsbEqsfPnzy+OlaSBgYFjXpvqs7dkyZLi5S5cuLA4dt688kPQ3r17i2N3795d\n", + "HCtJo6OjVfLI7BeZ2AULFkz6+i233KKzzz77mNcHBweLl71ixYri2OXLlxfHLl26tDg2sw9Nth8f\n", + "T+ZzkjkW7du3rzh2z549x7x23XXX6cILLzzm9V27dhUvV8rt+/v3768Sm9mXa86Fmfm7M3fu3KK4\n", + "DRs2TL2+4rUl2Z4r6eOSzpV0uqSLbD+n1voAAAC6peY9VC+StC0i7o+IMUnXSXpNxfUBAAB0Rc2C\n", + "6pmSHpzw/KHOa9NqtVo18sEsWbVqVbdTwAzx2etvp5xySrdTwAw997nP7XYKaKhmQTXjC6P8Qe5v\n", + "jF//Yuz628qVK7udAmaIgqr/1bwp/SeSJn66V6p9luoJhoaGDj9utVoc0AEAQE/Ytm2btm3bVhRb\n", + "s6C6TdJptluSfirpDZIuOjpoNr/NBwAAUGr16tVavXr14ec33HDDlLHVCqqIOGD77ZK+rva0CVdG\n", + "xL211gcAANAtVeehioivSvpqzXUAAAB0W1dnSpfKJ9PKTlCZ0QuTdWb0yraoNUlmRs2JS2tNUFlr\n", + "/LIT5GXiM7GTTVp4ImS2cXaS01qTTmYme6w5+W0mPjMxZGbi2R07dhTHZiaSLf0bMi5zjMtMZpk5\n", + "xmViM9tYqjOZZdZUE89OJvNZrTnWmQl7p0IvPwAAgIYoqAAAABqioAIAAGiIggoAAKAhCioAAICG\n", + "KKgAAAAaoqACAABoiIIKAACgIQoqAACAhiioAAAAGqKgAgAAaKjrvfxK+w5lelFl+1xl+gPVyiOb\n", + "c7eXm1Urj2z/ukwemZ5YmT5ztXrSZfpnSfXGJPN5yvx+mR562V5+mTEZHBwsjl28eHFxbM0enQcP\n", + "HiyOrXXcyvRVGxkZKY7N/G41ZbZFZr9YtmxZKo/ly5cXx2Z6WC5atKg4tleO95k+iKV9Gzds2DDl\n", + "e1XPUNleaXvI9t2277L9jprrAwAA6IbaZ6jGJF0aEcO2ByXdbvvGiLi38noBAABmTdUzVBHxSEQM\n", + "dx6PSrpX0jNqrhMAAGC2zdpN6bZbks6UdOtsrRMAAGA2zEpB1bnc93lJl3TOVAEAADxpVP+Wn+35\n", + "kr4g6TMRcf3R7990002HH69atUqnnnpq7ZQAAACmtWnTJm3atKko1tmvIWa4/d3JqyQ9FhGXTvJ+\n", + "XHHFFaXLyqy3OLbmspk24Yhe+Rot0yYcwbQJRzBtwhFMmzAzTJtwRK8c72tMm7B06VJFxKS/YO1L\n", + "fi+R9EeS1tve0vl3buV1AgAAzKqql/wi4ltiNnYAAPAkR7EDAADQUNdbz5TKXDuteU09k0et2My9\n", + "CNlrzrW2c+a+moya98tl7mnJ/H61YjP7RVatZde616L0fohxBw4cKI7N7BeZe7mWLFlSHJu5T0bK\n", + "3V+XGevdu3cXx+7atas4dseOHcWxO3fuLI6VcmOd2RYrVqwojj355JOLY0866aTiWEkaGBgojs38\n", + "fqOj5V/Qz+wXmdh9+/YVx0q548CJOMZxhgoAAKAhCioAAICGKKgAAAAaoqACAABoiIIKAACgIQoq\n", + "AACAhiioAAAAGqKgAgAAaIiCCgAAoCEKKgAAgIa63nqmtA1Ar7RbqRWbaeNSs8VIRi+0A8q2Lsnk\n", + "PDY2VhybaWeRid2zZ09xbKa1R3bZmRYOtdrJZGS2sZT7TGW2WyaPTJuhefNyh+5MHpn2Hpn9Its2\n", + "pFSmZY+Ua82SaTOUkWnjkm2tk9k/M8e4zGek1r6c3e8z43cijltTZmf79ySFpMnWEhHxxZIV2J4r\n", + "6TZJD0XE+TPKEgAAoIcdr9w7X+2CaipFBZWkSyTdI2lpaVIAAAD9ZMqCKiL+uOnCbZ8i6TxJV0ja\n", + "0HR5AAAAvWjaC4y2T7Z9pe2vdZ6fbvtPC5f/YUnvltQbN/0AAABUUHLH1qcl3SDpGZ3nP5Z06XQ/\n", + "ZPvVkrZHxBZNfh8WAADAk0LJLfNPi4h/tn2ZJEXEmO2Sr4y8WNIFts+TNCBpme2rI+JNE4OGhoYO\n", + "P261Wlq1alV59gAAAJXs3bu3+BuqJQXVqO1fGH9i+yxJO6b7oYi4XNLlnZ95haR3HV1MSdL69euL\n", + "EgUAAJhNAwMDT5hqY2RkZMrYkoLqnZK+IulU29+RdJKk180gr9zkUAAAAH1i2oIqIm63/XJJv6r2\n", + "vVA/jIjy2cDay/iGpG/MLEUAAIDeNm1BZXuRpLdKeqnaZ5k22f6HiNhbOzkAAIB+UHLJ72pJOyV9\n", + "TO0zVH8g6RpJv18xLwAAgL5RUlCdERGnT3h+s+17TlQCpb12Mj15avbyqyXTRygTm+mpJOW2c60+\n", + "STXHOqNWT7rMmAwODhbHLly4MJXHokWLimMXLFhQHJvp21irn2C2b1xmn8tsi8w2zvSky+6bmfhs\n", + "H8RS2WNRqWy+mf0zs9127Jj2u1qHZfpuZvflTH++jFo99zL7Rba34vz580947MUXXzzleyXZfd/2\n", + "2eNPOt/yu71ozQAAAD8Hjtcc+c4JMd+2/aDa91A9S9IPZyE3AACAvjBdc2QAAABM43jNke+f+Nz2\n", + "L6o94zkAAAAmKGmOfIHtH0u6T+25pO6X9NXKeQEAAPSNkpvS/0bS2ZJ+FBGrJL1S0q1VswIAAOgj\n", + "JQXVWET8r6Q5tudGxJCkF1TOCwAAoG+UTBbxuO2lkjZJ+qzt7ZJG66YFAADQP0rOUL1W0m5Jl0r6\n", + "mqRt4huAAAAAh5U0Rx4/G3VQ0qerZgMAANCHjjex56jaE3lOJiJi2YlIoLRtQK2WKFJu6vtaLWJ6\n", + "RaaVy6FDh6ost1abmqxa7RMyv1+mRcXIyEhxbDaPWu1WBgbKZ2J5ylOeUiUHKde+JNPaIxObaV2S\n", + "bbdSq71HZvwysYsXLy6OzeybUu5zndkWmZY2NT/Xo6Pld+Rk2trUOoZn9otse61M65lMHlM53jxU\n", + "5U3EpmB7haRPSjpD7eLsTyLiu02XCwAA0EvKS/WZ+aik/4iI19meJ6m8+ycAAECfqFZQ2V4u6WUR\n", + "cbEkRcQBSeXntAEAAPpEvRtQpFWS/sf2p2x/3/Y/2i6/MA4AANAnahZU8yQ9X9LfR8TzJe2SdFnF\n", + "9QEAAHRFzXuoHpL0UER8r/P885qkoNq4cePhx61WS61Wq2JKAAAAZYaHhzU8PFwUW62giohHbD9o\n", + "+9kR8SNJr5J099Fx69atq5UCAADAjK1du1Zr1649/Pyqq66aMrb2t/z+Qu12NQsk/ZekN1deHwAA\n", + "wKyrWlBFxB2SXlhzHQAAAN1W86Z0AACAnwu1L/lNq0brkMwU+VKuZUAtmZxrtYfJxme2Wy+0qcku\n", + "O/P77d+/vzh2586dxbGZdiSZlhOStHv37uLYTIuKzHbLtA3JHCsyrVak3H6UaSezZ8+e4tjMNs7k\n", + "IOX2z0zOtWIzn9Ps35Bara0yrUtqtbWS6rVpy2y3TMuXTA6Z7TaT+KY4QwUAANAQBRUAAEBDFFQA\n", + "AAANUVABAAA0REEFAADQEAUVAABAQxRUAAAADVFQAQAANERBBQAA0BAFFQAAQENdbz2TbY1SItuO\n", + "JKPWVP2Z9gKZ5Wbb8NRqW5BRq01NTZltcdpppxXHLlmypDg20+4hK9PqJNPmJLPcAwcOFMeuWLGi\n", + "OFaSli1bViU2m0epTJsaKbftMp+/zPhlWh1l9qHs8T6z7IzFixcXx2ba1AwODqbyyMRncs4cizL7\n", + "UGa/GBkZKY7NLru0NdJ555035XtVz1DZfq/tu23fafta2wtrrg8AAKAbqhVUtluS3iLp+RHxPElz\n", + "JV1Ya30AAADdUvOS305JY5IW2z4oabGkn1RcHwAAQFdUO0MVEf8n6e8kPSDpp5J+FhH/WWt9AAAA\n", + "3VLzkt+vSPpLSS1Jz5A0aPsPa60PAACgW2pe8nuBpO9ExGOSZPuLkl4s6bMTgzZu3Hj4cavVUqvV\n", + "qpgSAABAma1bt2rr1q1FsTULqh9I+ivbiyTtlfQqSZuPDlq3bl3FFAAAAGZmzZo1WrNmzeHn1157\n", + "7ZSxNe+hukPS1ZJukzRe3n2i1voAAAC6perEnhHxQUkfrLkOAACAbqP1DAAAQEMUVAAAAA11vZff\n", + "vHllKWR6tmX7u2XiDx48WGW5tWIz+Ur1+uhl8sjEZnqJZZfdC2PSK30NM73j9u7dWxxb2j9Lym2L\n", + "bJ/JTB/ETO+4HTt2FMc+9thjVWKl3Phl9s/Mdlu4sLzzWGa5mX1IqtfXMLPPZbZFpt+eVP43Vcpt\n", + "i5p/d2rJbItM7FQ4QwUAANAQBRUAAEBDFFQAAAANUVABAAA0REEFAADQEAUVAABAQz1ZUN13333d\n", + "TgENPPDAA91OATP08MMPdzsFNJCZHgG9hbHrfxRUOOEoqPrXI4880u0U0MD+/fu7nQJmiIKq//Vk\n", + "QQUAANBPKKgAAAAacs12FdOu3O7eygEAAJIiYtL+U10tqAAAAJ4MuOQHAADQEAUVAABAQz1XUNk+\n", + "1/YPbP/Y9nu6nQ+mZvufbD9q+84Jrz3V9o22f2T7BtsrupkjpmZ7pe0h23fbvsv2OzqvM4Y9zvaA\n", + "7VttD9u+x/b7O68zdn3E9lzbW2x/pfOc8etjPVVQ2Z4r6eOSzpV0uqSLbD+nu1nhOD6l9lhNdJmk\n", + "GyPi2ZJu6jxHbxqTdGlEnCHpLElv63zeGMMeFxF7Ja2PiLWS1khab/ulYuz6zSWS7pE0fjMz49fH\n", + "eqqgkvQiSdsi4v6IGJN0naTXdDknTCEiNkl6/KiXL5B0VefxVZJeO6tJoVhEPBIRw53Ho5LulfRM\n", + "MYZ9ISJ2dx4ukDRX7c8iY9cnbJ8i6TxJn5Q0/q0xxq+P9VpB9UxJD054/lDnNfSPp0fEo53Hj0p6\n", + "ejeTQRnbLUlnSrpVjGFfsD3H9rDaYzQUEXeLsesnH5b0bkmHJrzG+PWxXiuomMPhSSTac3Iwpj3O\n", + "9qCkL0i6JCJGJr7HGPauiDjUueR3iqSX215/1PuMXY+y/WpJ2yNii46cnXoCxq//9FpB9RNJKyc8\n", + "X6n2WSr0j0dtnyxJtn9J0vYu54PjsD1f7WLqmoi4vvMyY9hHImKHpH+X9Bti7PrFiyVdYPs+SZ+T\n", + "dI7ta8T49bVeK6huk3Sa7ZbtBZLeIOnLXc4JOV+WdHHn8cWSrj9OLLrItiVdKemeiPjIhLcYwx5n\n", + "+2nj3wCzvUjSb0raIsauL0TE5RGxMiJWSbpQ0s0R8UYxfn2t52ZKt/3bkj6i9k2WV0bE+7ucEqZg\n", + "+3OSXiHpaWpf7/9rSV+S9C+SniXpfkmvj4ifdStHTK3zrbBvStqqI5cW3itpsxjDnmb7eWrftDyn\n", + "8++aiPiQ7aeKsesrtl8h6Z0RcQHj1996rqACAADoN712yQ8AAKDvUFABAAA0REEFAADQEAUVAABA\n", + "QxRUAAAADVFQAQAANERBBaDrbH+7899ftn3RCV725ZOtCwBOJOahAtAzbK9Te5LD8xM/My8iDhzn\n", + "/ZGIWHoi8gOAqXCGCkDX2R7tPPyApJfZ3mL7EttzbH/I9mbbd9j+s078OtubbH9J0l2d1663fZvt\n", + "u2y/pfPaByQt6izvmonrctuHbN9pe6vt109Y9kbb/2r7Xtufmd2tAaAfzet2AgCgI61v3iPpXeNn\n", + "qDoF1M8i4kW2F0r6lu0bOrFnSjojIv678/zNEfF4p7fdZtufj4jLbL8tIs6cZF2/K+nXJa2RdJKk\n", + "79n+Zue9tZJOl/SwpG/bfklEcKkQwJQ4QwWgl/io578l6U22t0j6rqSnSlrdeW/zhGJKki6xPSzp\n", + "FkkrJZ02zbpeKunaaNsu6RuSXqh2wbU5In4a7XsihiW1GvxOAH4OcIYKQK97e0TcOPGFzr1Wu456\n", + "/kpJZ0XEXttDkgamWW7o2AJu/OzVvgmvHRTHSgDT4AwVgF4yImniDeRfl/RW2/MkyfazbS+e5OeW\n", + "SXq8U0z9mqSzJrw3Nv7zR9kk6Q2d+7ROkvRySZt1bJEFANPi/7oA9ILxM0N3SDrYuXT3KUkfU/ty\n", + "2/dtW9J2Sb/TiZ/4FeWvSfpz2/dI+qHal/3GfULSVtu3R8Qbx38uIv7N9tmddYakd0fEdtvPOWrZ\n", + "muQ5ADwB0yYAAAA0xCU/AACAhiioAAAAGqKgAgAAaIiCCgAAoCEKKgAAgIYoqAAAABqioAIAAGiI\n", + "ggoAAKCh/wcQESvdP72F3wAAAABJRU5ErkJggg==\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2311,7 +2355,7 @@ "y8xY0VhmxorGMjNWNJaZsaKxzIwVjWVmrGgsM/N/z4EQsKT2Kt0AAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2321,92 +2365,93 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAEi1JREFUeJzt3X+wXGV9x/HPJze/bkKACSGbArE3bUPLzwhVBhBBqu1Q\n", - "RtC2VqRFqe3Y6ag1pcqIzLR/taOV6YiO085YKAr+aosWdVoQWilGrEQgufmFIXQM5UeTNDQJJCE3\n", - "N+HbP3ZvWC735p5vzn3u7ob3a4Zxz+73nufZ8zy7+XrO2efriBAAAACO3LROdwAAAKDXkVABAADU\n", - "REIFAABQEwkVAABATSRUAAAANZFQAQAA1DS9k43bZs0GAADQMyLCYz1fNKGyfZmkmyX1SbolIv5q\n", - "dMw111zzqr8bHBzUsmXLjrjd7NpaBw8erBz70ksvFYnN9CHz/jJ9yMaP1+dNmzZp6dKllWLHMjw8\n", - "XDk2+/4OHDhQpB/79+/veOxkeO6553TCCSe86vnp08t8VWTm8tDQUOXYF198MdWPffv2VY7NjElm\n", - "DmXmpj3m97kiYszXMuM3c+bMyrGzZs0qst9p08pdPCm19mLdf0f27NmjuXPnvur5zLyYjH6MJ3Pc\n", - "SsWWNN5narTDfbcUm7W2+yR9XtJlkk6XdLXt00q1BwAA0Ckl76E6T9ITEbE5IoYlfV3SOwq2BwAA\n", - "0BElE6qTJT3Vtv1067kJNRqNIh3C1Jg/f36nu4Aj1N/f3+kuAK9JM2bM6HQXUFPJhOqIL4wuWrRo\n", - "MvuBKTbWPTjoDXPmzOl0F1BD1ftA0H0y95ihO5W8Kf0ZSYvbthereZbqFQYHBw89bjQaJFMAAKAr\n", - "HDx4sPLN+yUTqoclLbU9IOlZSVdJunp0UJ1f8wEAAJTS19envr6+Q9uH+9VlsYQqIg7Y/rCk76q5\n", - "bMKtEfFYqfYAAAA6peg6VBFxt6S7S7YBAADQaR1dKV2SZs+eXSkuc7Nl9sbMTHxmwbn204QTySy8\n", - "VypWyvW5VGymz9lfxlSdb1LuF2+Z/Y61eN94Mu8vO9al5n2pz0jmGGfnRebYZfqcudE4E5vpg5Qb\n", - "61LHIjMmmc9IyXmfWfiy1IKvmdiSumGxzuxCzplFTqsuHLxkyZJxX6OWHwAAQE0kVAAAADWRUAEA\n", - "ANREQgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQEwkVAABATSRUAAAANZFQAQAA1NTxWn67\n", - "d++uFFeyfl02vqpMPaMDBw5Ujs3UMypZ+ygTm+lH5rhl31831B8sWbMto9RYZ3RDXbxsP2bNmlU5\n", - "ttR3S3beZ+rBlfpcZ77j9u7dWzk2OzczfS71GcnUu8zWpczM/VL1MUvVg8wcN6ncv8HjKXqGyvZi\n", - "2/fbXm97ne2PlGwPAACgE0qfoRqWdF1ErLZ9jKRHbN8XEY8VbhcAAGDKFD1DFRFbImJ16/FuSY9J\n", - "OqlkmwAAAFNtym5Ktz0g6RxJD01VmwAAAFNhShKq1uW+OyUtb52pAgAAOGoU/5Wf7RmSviHpyxFx\n", - "1+jX165de+jxwoUL1Wg0SncJAABgQps3b9aTTz5ZKbZoQmXbkm6VtCEibh4r5qyzzirZBQAAgCMy\n", - "MDCggYGBQ9srVqwYN7b0Jb83SbpG0qW2V7X+u6xwmwAAAFOq6BmqiPiBWI0dAAAc5Uh2AAAAaup4\n", - "6ZmqS99nlpDPliLIlGXIlnwoIXMsmrexlZEpA1CqvEC2NEvmeJQ6dpn5NhnlEMaTeX+lSvZkxjrz\n", - "2du1a1flWKlcaZbM+8uUAZk7d27l2Oy+M6V1MjLjlyldsm/fvlQ/Mt+fGZl5nxmPTKyUL89SVaky\n", - "Q5nx279/f+XY7L4z3wHj4QwVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEA\n", - "ANREQgUAAFATCRUAAEBNJFQAAAA1dbz0zN69eyvFlSwZkonvhmX9M7JleDIyS/Vnyj1kjkW2jESp\n", - "fpSKzZRayJbgGBoaqhybKSWRKRuSic2URMl+TjP9KFUOqNRxy+qG77hMGZf+/v5UPzKlXDLHOdPn\n", - "nTt3Vo7NfodnjnNm35nYUuXRSv7bPhmlxsadLbZ/S1JIGquViIhvVmnAdp+khyU9HRFXHFEvAQAA\n", - "utjh0u8r1EyoxlMpoZK0XNIGSfOqdgoAAKCXjJtQRcTv1d257VMkXS7pLyX9ad39AQAAdKMJL5bb\n", - "XmT7Vtv3tLZPt/0HFff/GUnXSypzgxAAAEAXqHL34Rcl3SvppNb2JknXTfRHtt8uaVtErNLY92EB\n", - "AAAcFar8hGFBRPyD7RskKSKGbVf5mcuFkq60fbmk2ZKOtX17RLyvPWjdunWHHi9cuFALFy6s3nsA\n", - "AIBCtm7dqm3btlWKrZJQ7bZ9wsiG7fMl7ZrojyLiRkk3tv7mEkkfG51MSdKZZ55ZqaMAAABTqdFo\n", - "qNFoHNpuPwk0WpWE6qOSviPp52z/UNKJkt51BP3KLRgEAADQIyZMqCLiEdsXS/pFNe+F2hgR1Vd0\n", - "bO7jAUkPHFkXAQAAutuECZXtfkkflHSRmmeZVtj+24jILcsMAABwlKpyye92Sc9L+pyaZ6h+R9Id\n", - "kn67YL8AAAB6RpWE6oyIOL1t+3u2N0xWB0rVjSqlVM29TB2ozDHLHt/JqGdUtx9TXX9pPJl6VKVq\n", - "Js6YMaNybMn6dZl+ZGTqD2bqGlatEXok+y5Vk67kWJesj1lVqZqp2c9epoZlZh7t2bOnyH6zNToz\n", - "c7lUzb1SdSmzNSwz9T9nzpyZ2vdYqszaR21fMLLR+pXfI7VbBgAAOEocrjjy2raYB20/peY9VK+T\n", - "tHEK+gYAANATJiqODAAAgAkcrjjy5vZt2wvVXPEcAAAAbaoUR77S9iZJP1VzLanNku4u3C8AAICe\n", - "UeWm9L+QdIGkxyNiiaS3SnqoaK8AAAB6SJWEajgitkuaZrsvIu6X9IbC/QIAAOgZVRZ12GF7nqQV\n", - "kr5ie5uk3WW7BQAA0DuqnKF6p6S9kq6TdI+kJ8QvAAEAAA6pUhx55GzUQUlfLNobAACAHnS4hT13\n", - "q7mQ51giIo6dlA5UXEq+VDkEqVxZhsx+Dxw4UKQPJY9bRqmSPVmZMhWlxrrUfMuW4cmUOsnEZvqR\n", - "GY/MZyQ730qV6yglO9aZUi4lj3NVpUpxZfddqnTQvHnzKsf29/dXjpWO7rmcLT2TGb/JKD1zuHWo\n", - "jqm7c9vHS7pF0hlqJme/HxE/qrtfAACAbpJL9/I+K+lfI+JdtqdLmlu4PQAAgClXLKGyfZykN0fE\n", - "tZIUEQck7SrVHgAAQKfkLj7nLJH0v7Zvs/2o7b+zPadgewAAAB1RMqGaLulcSX8TEedK2iPphoLt\n", - "AQAAdETJe6ielvR0RPy4tX2nxkioBgcHDz1uNBpatGhRwS4BAABUs337dm3fvr1SbLGEKiK22H7K\n", - "9qkR8bikt0laPzpu2bJlpboAAABwxBYsWKAFCxYc2t64ceO4saV/5ffHaparmSnpvyS9v3B7AAAA\n", - "U65oQhURg5LeWLINAACATit5UzoAAMBrQulLfhOqulx/qTIgUrlSGZll70vJlmXIHItSsaVKQ5SU\n", - "mRf79u2rHJspA5KJLSlTHiJTgmPWrFmVYzNlQKRcnzPfL0NDQ5VjS5WfksqVOyr1vZwtrVNKph+Z\n", - "OZeZbyWPRanxy/y7k3l/JcsMTcZx5gwVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAAQE0kVAAA\n", - "ADWRUAEAANREQgUAAFATCRUAAEBNJFQAAAA1dbz0zP79+yvFZcvJZGSW3y9VBiCzRH5m+f2SS/X3\n", - "YqmFzL5Lzbnjjz++cmzmGJcswzM8PFwkturnX8qV98nO+8z8zMQed9xxlWMz30PZMkOlSoxkxjpT\n", - "cikTm5kXJfdd6vswU3JJkmbOnFk5NtPnUiXaMnM5M3ZSbn5ORumuomeobH/C9nrba21/1XZuZgAA\n", - "APSAYgmV7QFJH5B0bkScJalP0ntKtQcAANApJS/5PS9pWNIc2wclzZH0TMH2AAAAOqLYGaqI+D9J\n", - "fy3pvyU9K2lnRPxbqfYAAAA6peQlv5+X9CeSBiSdJOkY279bqj0AAIBOKXnJ7w2SfhgRz0mS7W9K\n", - "ulDSV9qD1qxZc+hxo9FQo9Eo2CUAAIBqtm7dqm3btlWKLZlQ/UTSn9nul7RP0tskrRwddPbZZxfs\n", - "AgAAwJEZfaJn/fr148aWvIdqUNLtkh6WNHIa6gul2gMAAOiUogt7RsSnJX26ZBsAAACdRukZAACA\n", - "mkioAAAAaup4Lb+SNfqqytQoytYIq6pUra1snatStbkyfS51LErKzItS8y07NzPxmTpXmTmUmZ+Z\n", - "sc7USsvGZ45b5jOya9euyrEvvPBC5VhJGhoaqhybGb/MXM4c49mzZ1eOLTnvu6HGavb9lfqsZj5/\n", - "pb6Xs5/rUrVpx8MZKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioAAICaSKgAAABq6sqEauvWrZ3u\n", - "Ampg/HrXli1bOt0F1PD88893ugs4Qjt27Oh0F1BTVyZUVSs7ozuRUPUuEqreRkLVu0ioel9XJlQA\n", - "AAC9hIQKAACgJmfKfEx643bnGgcAAEiKiDFrLnU0oQIAADgacMkPAACgJhIqAACAmrouobJ9me2f\n", - "2N5k++Od7g/GZ/vvbW+1vbbtufm277P9uO17bR/fyT5ifLYX277f9nrb62x/pPU8Y9jlbM+2/ZDt\n", - "1bY32P5k63nGrofY7rO9yvZ3WtuMXw/rqoTKdp+kz0u6TNLpkq62fVpne4XDuE3NsWp3g6T7IuJU\n", - "Sf/e2kZ3GpZ0XUScIel8SR9qfd4Ywy4XEfskXRoRr5d0tqRLbV8kxq7XLJe0QdLIzcyMXw/rqoRK\n", - "0nmSnoiIzRExLOnrkt7R4T5hHBGxQtLo1eiulPSl1uMvSXrnlHYKlUXElohY3Xq8W9Jjkk4WY9gT\n", - "ImJv6+FMSX1qfhYZux5h+xRJl0u6RdLIr8YYvx7WbQnVyZKeatt+uvUcekcjIkaWSt8qqdHJzqAa\n", - "2wOSzpH0kBjDnmB7mu3Vao7R/RGxXoxdL/mMpOslvdT2HOPXw7otoWINh6NINNfkYEy7nO1jJH1D\n", - "0vKIeKH9Ncawe0XES61LfqdIutj2paNeZ+y6lO23S9oWEav08tmpV2D8ek+3JVTPSFrctr1YzbNU\n", - "6B1bbS+SJNs/I4nCjF3M9gw1k6k7IuKu1tOMYQ+JiF2S/kXSL4ux6xUXSrrS9k8lfU3Sr9i+Q4xf\n", - "T+u2hOphSUttD9ieKekqSd/ucJ+Q821J17YeXyvprsPEooNsW9KtkjZExM1tLzGGXc72gpFfgNnu\n", - "l/SrklaJsesJEXFjRCyOiCWS3iPpexHxXjF+Pa3rVkq3/euSblbzJstbI+KTHe4SxmH7a5IukbRA\n", - "zev9fy7pW5L+UdLrJG2W9O6I2NmpPmJ8rV+FfV/SGr18aeETklaKMexqts9S86blaa3/7oiIm2zP\n", - "F2PXU2xfIumjEXEl49fbui6hAgAA6DXddskPAACg55BQAQAA1ERCBQAAUBMJFQAAQE0kVAAAADWR\n", - "UAEAANREQgWg42w/2Prfn7V99STv+8ax2gKAycQ6VAC6hu23qLnI4RWJv5keEQcO8/oLETFvMvoH\n", - "AOPhDBWAjrO9u/XwU5LebHuV7eW2p9m+yfZK24O2/7AV/xbbK2x/S9K61nN32X7Y9jrbH2g99ylJ\n", - "/a393dHelptusr3W9hrb727b93/Y/ifbj9n+8tQeDQC9aHqnOwAAern0zcclfWzkDFUrgdoZEefZ\n", - "niXpB7bvbcWeI+mMiHiytf3+iNjRqm230vadEXGD7Q9FxDljtPWbkpZJOlvSiZJ+bPv7rddeL+l0\n", - "Sf8j6UHbb4oILhUCGBdnqAB0E4/a/jVJ77O9StKPJM2X9Aut11a2JVOStNz2akn/KWmxpKUTtHWR\n", - "pK9G0zZJD0h6o5oJ18qIeDaa90SsljRQ4z0BeA3gDBWAbvfhiLiv/YnWvVZ7Rm2/VdL5EbHP9v2S\n", - "Zk+w39CrE7iRs1dDbc8dFN+VACbAGSoA3eQFSe03kH9X0gdtT5ck26fanjPG3x0raUcrmfolSee3\n", - "vTY88vejrJB0Ves+rRMlXSxppV6dZAHAhPh/XQC6wciZoUFJB1uX7m6T9Dk1L7c9atuStkn6jVZ8\n", - "+0+U75H0R7Y3SNqo5mW/EV+QtMb2IxHx3pG/i4h/tn1Bq82QdH1EbLN92qh9a4xtAHgFlk0AAACo\n", - "iUt+AAAANZFQAQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANREQgUAAFATCRUAAEBN/w/tXPX4\n", - "8PPk+QAAAABJRU5ErkJggg==\n" + "AAALEgAACxIB0t1+/AAAEn9JREFUeJzt3X+QXfVZx/HPJz9IsiSQwYRsAqmJChoyLQRbBiiFYquD\n", + "TKFVaykqxerUcdraiC1Tyoz+pdPajlPsdHSmgrTQXyqttB2FghYDpZYU2A2QpIQ4RIH8MpjQ/Nqw\n", + "SR7/uHfDZtnNnmdPvnvPDe/XTCb3nPvcc773fM8999lzzv0+jggBAABg4qZ0ugEAAADdjoQKAACg\n", + "JhIqAACAmkioAAAAaiKhAgAAqImECgAAoKZpnVy5bcZsAAAAXSMiPNr8ogmV7Ssk3SJpqqRbI+Iv\n", + "R8Zcd911r3rdmjVrdO655x41LzNeVnZsrcOHD5+wsSWNtZ3Xr1+vZcuWHTWv1Ps7ePBg5VhJGhwc\n", + "rBx74MCByrEvv/xykeUODAxUjj0eduzYoXnz5r1qvj3q8WNUU6ZUP/Gd6ev9+/cXic3GZ/o6s38e\n", + "OnSocuxY/RERoz43bVr1Q/2MGTMqx5500kmVYzNtyOxDmVgpty9nvkvq9vW+ffvU09PzqvmZY1a2\n", + "HZn3l/mslvy+zsj0ddXYYx2/i13ysz1V0uclXSHpHEnX2l527FcBAAB0n5L3UF0gaWNEbIqIQUlf\n", + "l/TOgusDAADoiJIJ1RmSnhs2/Xx73rgWLFhQpEGYHKNdMkJ3GO2SA4Dypk+f3ukmoKaSCdWEL4z2\n", + "9vYez3Zgks2fP7/TTcAEkVB1t8w9I2gWEqruV/Km9BckLR42vVits1RHWbNmzZHHCxYsIJkCAACN\n", + "cPjw4co35JdMqB6VdJbtJZI2S7pG0rUjg0b+mg8AAKAJpkyZctQvSY/1a9xiCVVEHLT9YUnfVWvY\n", + "hNsiYn2p9QEAAHRK0XGoIuIeSfeUXAcAAECndXSkdKn6IHJNGeht6tSpRWIzbc4MkJdpg1RuW5R6\n", + "f9kbOTODFmZiZ86cWSQ28/4ygyxm4zPtyMRm9qHMdsvenN2EQXgz2y3zGZFyfT1r1qzKsZnPSGa5\n", + "c+bMqRyb3RaZgSSbMBBwdpDazLE2+/1QYrmlvkekMgMHn3HG2IMVUMsPAACgJhIqAACAmkioAAAA\n", + "aiKhAgAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioAAICaSKgAAABq6ngtv0xN\n", + "o1Kydb86vdxua4OUq5+VkanVJOW2R6nYUrUYszXNMg4dOlRkuZn3l6l1l635lYnP1K/L1NDL7EPZ\n", + "/f7gwYOVYzOf1UxsZh/au3dv5djsd0imHaViM/typgaiJPX09BRZdmZfznyuS35HZfrkeOQiRc9Q\n", + "2V5s+wHba20/ZfsjJdcHAADQCaXPUA1KuiEi+m3PlvSY7fsjYn3h9QIAAEyaomeoImJrRPS3H++R\n", + "tF7SopLrBAAAmGyTdlO67SWSVkh6ZLLWCQAAMBkmJaFqX+67S9LK9pkqAACAE0bxX/nZni7pG5K+\n", + "HBF3j3y+v7//yOPe3l719vaWbhIAAMC4nn32WW3atKlSbNGEyq3fQ94maV1E3DJazHnnnVeyCQAA\n", + "ABOydOlSLV269Mj0qlWrxowtfcnvzZJ+R9Lltvva/64ovE4AAIBJVfQMVUR8X4zGDgAATnAkOwAA\n", + "ADV1vPRM1WHnm1JCJaNUuZVSy83KtCNbCqTUckvtR5myL6XaMDg4WGS5JWX2oUz5lGypnEwpl0z/\n", + "ZUqMzJw5s3LsnDlzKsdKubIhGZk+yWzjkqVLSpU7ypR8mTt3buXYU089tXKslHt/mWPG7t27K8fu\n", + "2VP9x/z79u2rHDswMFA5VsqVk8nsy2PhDBUAAEBNJFQAAAA1kVABAADUREIFAABQEwkVAABATSRU\n", + "AAAANZFQAQAA1ERCBQAAUBMJFQAAQE0kVAAAADV1vPRM1dIhmRIVJUuzlGpHpixDJrYpZWqaUjoo\n", + "sz0y5UtKleDIlE7IlmXIlJ3IbLdM6YtMbKa8T1amhFGpMjWZ8jAzZsyoHJtV6lhUqvRMtgxPpkRM\n", + "pvRM5hiwefPmyrEbN26sHCvljhmlvksy/ZfZ77PHgEx8ps1jrm+sJ2z/hqSQNNoRISLim1VWYHuq\n", + "pEclPR8RV02olQAAAA12rPTtKrUSqrFUSqgkrZS0TlLuzwgAAIAuMWZCFRG/W3fhts+UdKWkv5D0\n", + "J3WXBwAA0ETj3jhgu9f2bbbvbU+fY/v3Ky7/s5JulFT9Qi0AAECXqXIn5hcl3SdpUXv6GUk3jPci\n", + "2++QtD0i+jT6fVgAAAAnhCq3wM+LiH+wfZMkRcSg7So/Z7hY0tW2r5Q0U9Iptu+IiPcND+rr6zvy\n", + "uLe3VwsXLqzeegAAgEI2b96sLVu2VIqtklDtsf1TQxO2L5T00ngvioibJd3cfs1lkj42MpmSpBUr\n", + "VlRqKAAAwGRatGiRFi1adGR6+EmgkaokVB+V9B1JP2P7B5LmS3r3BNrVjAGRAAAAjrNxE6qIeMz2\n", + "pZJ+Xq17oZ6OiOojAraWsUrSqok1EQAAoNnGTahsz5L0QUmXqHWW6SHbfxsRuWGZAQAATlBVLvnd\n", + "Ieknkj6n1hmq35J0p6TfLNguAACArlEloVoeEecMm/6e7XXHqwFV64mVrEmXqWfUBJm6YyVr6DWh\n", + "Pl+27zLxme1cqs7c7Nmzi7Uh8/4ysZlaYvv27ascm6lVmFmuVK4+X6ZPMrUj9+7dWzk2K9OOjMw+\n", + "lDne7969O9WOzPvLtGP//v2VYw8cOFA5NlMjUMq9v1LHuMxyMzX0st85mTZnagqOpcq7ftz2RUMT\n", + "7V/5PVZ7zQAAACeIYxVHfnJYzMO2n1PrHqrXSXp6EtoGAADQFcYrjgwAAIBxHKs48qbh07ZPV2vE\n", + "cwAAAAxTpTjy1bafkfSsWmNJbZJ0T+F2AQAAdI0qN6X/uaSLJG2IiKWS3ibpkaKtAgAA6CJVEqrB\n", + "iNghaYrtqRHxgKQ3Fm4XAABA16gySMNO23MkPSTpK7a3S9pTtlkAAADdo8oZqndJ2ifpBkn3Stoo\n", + "fgEIAABwRJXiyENnow5J+mLR1gAAAHShYw3suUetgTxHExFxyvFowPTp0yvFNaXcSimlSuuULKuT\n", + "aXOp2EzZAqncfpSJLbUtMiVfsjLbORM7Z86cyrGnnFL9kJPdLzKlQDKxVUtrlYzNKlWSaObM6qPu\n", + "ZEqGlCy5lJEp+ZLZhzIllyYSX1XmM1Wq5Eu2PEzV/EKqvn8++OCDYz53rHGoqhcRG4PtuZJulbRc\n", + "reTs9yLih3WXCwAA0CRlKrq+4q8l/WtEvNv2NEknF14fAADApCuWUNk+VdJbIuJ6SYqIg5JeKrU+\n", + "AACATilzMbllqaT/tX277cdt/53tnoLrAwAA6IiSCdU0SedL+puIOF/SXkk3FVwfAABAR5S8h+p5\n", + "Sc9HxI/a03dplISqr6/vyOPe3l4tXLiwYJMAAACq2bJli7Zu3VoptlhCFRFbbT9n++yI2CDp7ZLW\n", + "joxbsWJFqSYAAABM2MKFC4860dPf3z9mbOlf+f2RWuVqTpL0X5LeX3h9AAAAk65oQhURayS9qeQ6\n", + "AAAAOq3kTekAAACvCaUv+Y2ragmFUmVAsvGlyhY0RRPKyWS2cbbsRKZ8QqlyMqXKnBw8eLBybDY+\n", + "8/4yfTJr1qzKsZnSJdkSFZkSOBmltnG2VFWmLEqmrE2m3FFmuaVKcWVljkU9PdVHBZo7d27l2KaU\n", + "Uit1DMhs46aUGhtzfbWXAAAA8BpHQgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQEwkVAABA\n", + "TSRUAAAANZFQAQAA1ERCBQAAUFPHS89ULa3RlNIzpcoAZIfUL6VUGZ5M7OHDhyvHZkqzZJUqfzFj\n", + "xozKsZkSFdmySJntnCkbkumTTOmSPXv2VI49+eSTK8dK5UrgZMqRZMrDZLablOvrzLEoU2IkU4Yn\n", + "E5vZblJuX85st8y2yMRmyyiVWnYmNtMne/furRy7f//+yrFS2dJdoyl6hsr2J2yvtf2k7a/arv5N\n", + "AgAA0CWKJVS2l0j6gKTzI+L1kqZKem+p9QEAAHRKyUt+P5E0KKnH9iFJPZJeKLg+AACAjih2hioi\n", + "/k/SX0n6H0mbJe2KiH8rtT4AAIBOKXnJ72cl/bGkJZIWSZpt+7dLrQ8AAKBTSl7ye6OkH0TEi5Jk\n", + "+5uSLpb0leFBa9euPfJ4/vz5Ov300ws2CQAAoJodO3boxRdfrBRbMqH6saQ/tT1L0oCkt0taPTJo\n", + "+fLlBZsAAAAwMfPmzdO8efOOTG/YsGHM2JL3UK2RdIekRyU90Z79hVLrAwAA6JSiA3tGxKclfbrk\n", + "OgAAADqN0jMAAAA1kVABAADU1PFaflVrbmXqqpWqwSblat2VbEdVmVpUUq7N2RpaJZab3caZ+FK1\n", + "CgcGBirHZmpRZWv5NaF+ZKbNmbp4JesaZvpvx44dlWN3795dOTZT11A6PnXKRjN9+vTKsZkaiJm6\n", + "cZn+kPLHxKoyn6dMPc+S+3Kmjl7muFyqbmNWpk8y+/JYOEMFAABQEwkVAABATSRUAAAANZFQAQAA\n", + "1ERCBQAAUBMJFQAAQE2NTKi2bNnS6Saghq1bt3a6CZggPnvdbefOnZ1uAiYoM8QGmqmRCRVfyN1t\n", + "27ZtnW4CJojPXnfbtWtXp5uACSKh6n6NTKgAAAC6CQkVAABATe5keRTbna/NAgAAUFFEjFqDrqMJ\n", + "FQAAwImAS34AAAA1kVABAADU1LiEyvYVtn9s+xnbH+90ezA2239ve5vtJ4fNO832/bY32L7P9txO\n", + "thFjs73Y9gO219p+yvZH2vPpw4azPdP2I7b7ba+z/cn2fPqui9iearvP9nfa0/RfF2tUQmV7qqTP\n", + "S7pC0jmSrrW9rLOtwjHcrlZfDXeTpPsj4mxJ/96eRjMNSrohIpZLulDSh9qfN/qw4SJiQNLlEXGe\n", + "pDdIutz2JaLvus1KSeskDd3MTP91sUYlVJIukLQxIjZFxKCkr0t6Z4fbhDFExEOSRg7NfLWkL7Uf\n", + "f0nSuya1UagsIrZGRH/78R5J6yWdIfqwK0TEvvbDkyRNVeuzSN91CdtnSrpS0q2Shn41Rv91saYl\n", + "VGdIem7Y9PPteegeCyJiaKj0bZIWdLIxqMb2EkkrJD0i+rAr2J5iu1+tPnogItaKvusmn5V0o6TD\n", + "w+bRf12saQkVYzicQKI1Jgd92nC2Z0v6hqSVEbF7+HP0YXNFxOH2Jb8zJV1q+/IRz9N3DWX7HZK2\n", + "R0SfXjk7dRT6r/s0LaF6QdLiYdOL1TpLhe6xzXavJNleKGl7h9uDY7A9Xa1k6s6IuLs9mz7sIhHx\n", + "kqR/kfSLou+6xcWSrrb9rKSvSfol23eK/utqTUuoHpV0lu0ltk+SdI2kb3e4Tcj5tqTr24+vl3T3\n", + "MWLRQbYt6TZJ6yLilmFP0YcNZ3ve0C/AbM+S9MuS+kTfdYWIuDkiFkfEUknvlfS9iLhO9F9Xa9xI\n", + "6bZ/VdItat1keVtEfLLDTcIYbH9N0mWS5ql1vf/PJH1L0j9Kep2kTZLeExG7OtVGjK39q7AHJT2h\n", + "Vy4tfELSatGHjWb79WrdtDyl/e/OiPiM7dNE33UV25dJ+mhEXE3/dbfGJVQAAADdpmmX/AAAALoO\n", + "CRUAAEBNJFQAAAA1kVABAADUREIFAABQEwkVAABATSRUADrO9sPt/3/a9rXHedk3j7YuADieGIcK\n", + "QGPYfqtagxxelXjNtIg4eIznd0fEnOPRPgAYC2eoAHSc7T3th5+S9BbbfbZX2p5i+zO2V9teY/sP\n", + "2vFvtf2Q7W9Jeqo9727bj9p+yvYH2vM+JWlWe3l3Dl+XWz5j+0nbT9h+z7Bl/4ftf7K93vaXJ3dr\n", + "AOhG0zrdAADQK6VvPi7pY0NnqNoJ1K6IuMD2DEnft31fO3aFpOUR8d/t6fdHxM52bbvVtu+KiJts\n", + "fygiVoyyrl+XdK6kN0iaL+lHth9sP3eepHMkbZH0sO03RwSXCgGMiTNUAJrEI6Z/RdL7bPdJ+qGk\n", + "0yT9XPu51cOSKUlaabtf0n9KWizprHHWdYmkr0bLdkmrJL1JrYRrdURsjtY9Ef2SltR4TwBeAzhD\n", + "BaDpPhwR9w+f0b7Xau+I6bdJujAiBmw/IGnmOMsNvTqBGzp7dWDYvEPiWAlgHJyhAtAkuyUNv4H8\n", + "u5I+aHuaJNk+23bPKK87RdLOdjL1C5IuHPbc4NDrR3hI0jXt+7TmS7pU0mq9OskCgHHxVxeAJhg6\n", + "M7RG0qH2pbvbJX1Orcttj9u2pO2Sfq0dP/wnyvdK+kPb6yQ9rdZlvyFfkPSE7cci4rqh10XEP9u+\n", + "qL3OkHRjRGy3vWzEsjXKNAAchWETAAAAauKSHwAAQE0kVAAAADWRUAEAANREQgUAAFATCRUAAEBN\n", + "JFQAAAA1kVABAADUREIFAABQ0/8DDbzgL6GT1HEAAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2538,7 +2583,7 @@ "YII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2548,93 +2593,94 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAEo9JREFUeJzt3X2QXXV9x/HPJ5tks1lCM1SqhewmNEALCBUamSiJSJVK\n", - "GUHbWoFSpbZjp6NWSn3CzLR/tWJ1HKnjtDNU6gOitEWLOi0gRYpZbIjBhKcgj+YJCiktSJ4Twrd/\n", - "3Ju4LHuz57snvz33hvdrhuGec797fr89v3PufnPOub+vI0IAAACYvGlNdwAAAKDXkVABAADUREIF\n", - "AABQEwkVAABATSRUAAAANZFQAQAA1DS9ycZtM2cDAADoGRHh8dYXTahsnyPpSkl9kr4QEX8zNuaj\n", - "H/3oS35uZGRES5YsedG6adOqX0yzx/1dO8psu9R2M7F9fX2VY6dPzw1xJr5TP26++Wa95S1vedG6\n", - "Ur9fJjYbX2r8ssdnVQMDA7Xjr7vuOl144YUvWT84OFikHzNmzKgcu3v37sqxu3btqhwrSTt37qwc\n", - "+/zzz1eOzczz98ILL1SO7bSPr732Wl188cUvWT9nzpzK2547d26R2Ewf+vv7K8dmjiGp3Hm9Z8+e\n", - "yrHjHZ+f+MQntGzZspeszxybUu48yfQ5s93MObJ3797Ksdl5MzPnVNXY0047reN7xW752e6T9HlJ\n", - "50g6UdJFtk8o1R4AAEBTSj5DdbqkRyJiXUTskXSdpLcVbA8AAKARJROqoyVtHLW8qb1uQsPDw0U6\n", - "hKmxcOHCpruASXr1q1/ddBdQw8knn9x0FzBJS5cubboLqKlkQjXpB85JqHrbscce23QXMEkkVL3t\n", - "lFNOaboLmCQSqt5X8qH0xyUNjVoeUusq1YuMjIzsfz08PEwyBQAAusKqVau0atWqSrElE6pVko6z\n", - "vUDSE5IukHTR2KCx3+YDAADoBosWLdKiRYv2L1911VUdY4slVBHxvO0PSLpZrWkTro6IB0q1BwAA\n", - "0JSi81BFxI2SbizZBgAAQNManSk9o9REYVKZyb+k3CRkpSYAzE6Eltl3pcYkM9lcpg/Z+EyfS8Vm\n", - "JqjMTma5ffv2yrE7duyoHJuZiDATmznus8dFqfErda5mtiuVmzwx24+qMpN1lpqYWSr3t6HkZ3hG\n", - "qX2Xmby45PiV+hvcCbX8AAAAaiKhAgAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAm\n", - "EioAAICaSKgAAABqIqECAACoiYQKAACgpsZr+VWtP5ap95OpAyVJfX19RWIz9YwydYRK1RKTcjXQ\n", - "MrHdUANRyo1JZqynT69+KmViS9a5ytRMzMRmjs/MeGT2W2bsSvYj+1lUVWY8pHLnaqkanZm6lNna\n", - "rb1WqzB7DPX391eOnTVrVpF+ZD63MudeVon6n1dccUXH94peobI9ZPs22/fbvs/2B0u2BwAA0ITS\n", - "V6j2SLosItbYPkzSXbZviYgHCrcLAAAwZYpeoYqIJyNiTfv1VkkPSDqqZJsAAABTbcoeSre9QNKp\n", - "ku6cqjYBAACmwpQkVO3bfddLurR9pQoAAOCQUfxbfrZnSPqGpK9GxA1j31+xYsX+1/PmzdO8efNK\n", - "dwkAAGBC69ev14YNGyrFFk2o3Po+5NWS1kbElePFLF68uGQXAAAAJmX+/PmaP3/+/uWRkZGOsaVv\n", - "+Z0h6fclnWV7dfu/cwq3CQAAMKWKXqGKiBExGzsAADjEkewAAADU1HjpmapT32emkM+WC8iWcagq\n", - "WxalG2TKAGTKC5Qqt5ItzZL5/Urti4xS5YukXNmJTGzJ8asqU7pEyn0G7Ny5s3JspixKZh/PnTu3\n", - "cqyUK0eSGZNMSZvMPt66tfqXwTOxkrR79+7KsZk+Z8odlTr3JGnmzJmVYzOfy6VK9pQqXyTljs9s\n", - "CaPxcIUKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoA\n", - "AKAmEioAAICaGi89ky0TU0WmBICUm36/VCmQUtP6lyx/k5mqv8Q4S/nfLzN+3aBUSZRsfKYfpUoS\n", - "ZWKzMsfn9u3bK8dm9lvJczXTj1KlWTLlgDIlQzKlVqTc34fMsZz5PMyce5nxkHL7LrPtzHa7RWas\n", - "s3nDeDp+Qtn+HUkhaby/QBER36zSgO0+SaskbYqI8ybVSwAAgC52oH/ynadWQtVJpYRK0qWS1kqa\n", - "U7VTAAAAvaRjQhURf1B347bnSTpX0l9L+vO62wMAAOhGE94gtv0q21fbvqm9fKLtP6q4/c9K+oik\n", - "Mg/QAAAAdIEqT9x9SdJ3JR3VXn5Y0mUT/ZDtt0raHBGrNf5zWAAAAIeEKl+beUVE/JPtyyUpIvbY\n", - "rvK4/+slnW/7XEmzJB1u+ysR8e7RQXfcccf+10NDQxoeHq7eewAAgEK2bdumbdu2VYqtklBttf3z\n", - "+xZsL5b004l+KCKWSVrW/pkzJX14bDIlSWeccUaljgIAAEylwcFBDQ4O7l9++umnO8ZWSag+JOk7\n", - "kn7J9g8kHSnpHZPoV7lJVgAAABo0YUIVEXfZfoOkX1brWagHI6L6bG6tbdwu6fbJdREAAKC7TZhQ\n", - "2R6Q9D5JS9S6yrTc9t9HRG5aZgAAgENUlVt+X5H0nKTPqXWF6vckXSPpdwv2CwAAoGdUSahOiogT\n", - "Ry1/z/bag9WBqjW0StWC6xaZOkKZenTZ+kSZbc+YMSO17aoy9bOytflK1fLL1GHL9GHOnOoFBrK1\n", - "7jI10Pr7+4v0I1MfLLOPM3XjstvOnFOzZ8+uHHvYYYdVjs2OdalzKrMvMn0u9dlS0pYtW4rE7tix\n", - "I9WPUvUjM2OS+bwYGBioHDtr1qzKsaW2ffbZZ3d8r8pZ9iPbr9u30P6W312VWgYAAHgZOFBx5HtH\n", - "xdxhe6Naz1ANS3pwCvoGAADQEyYqjgwAAIAJHKg48rrRy7Z/Qa0ZzwEAADBKleLI59t+WNJP1JpL\n", - "ap2kGwv3CwAAoGdUeSj9ryS9TtJDEXGMpDdJurNorwAAAHpIlYRqT0Q8LWma7b6IuE3SosL9AgAA\n", - "6BlVJgZ5xvYcScslXWt7s6StZbsFAADQO6pcoXq7pO2SLpN0k6RHxDcAAQAA9qtSHHnf1ai9kr5U\n", - "tDcAAAA96EATe25VayLP8UREHH4wOpApf3EoK1UaIltqJVNKohvKWZQqJVNSptxDRmY8svGlSoxk\n", - "YjPlp7KfK3v37k3FV5UZ60w5kuwxlBm/TOmSzJhkjrdSsVK5Y7nUZ1G2fFimnFMmdvfu3ZVjM8dy\n", - "qWNIyo1JdtvjOdA8VNULS3Vge66kL0g6Sa3k7A8jYkXd7QIAAHSTXIXNvL+V9O8R8Q7b0yUNFm4P\n", - "AABgyhVLqGz/nKSlEXGJJEXE85J+Wqo9AACAptS/adjZMZL+x/YXbf/I9j/Ynl2wPQAAgEaUTKim\n", - "SzpN0t9FxGmStkm6vGB7AAAAjSj5DNUmSZsi4oft5es1TkK1fPny/a+Hh4c1f/78gl0CAACo5tFH\n", - "H9Vjjz1WKbZYQhURT9reaPv4iHhI0psl3T82bunSpaW6AAAAMGkLFy7UwoUL9y/feuutHWNLf8vv\n", - "T9UqVzNT0qOS3lO4PQAAgClXNKGKiLslvbZkGwAAAE0r+VA6AADAy0LpW34Tqjrde2Z6+kyslCvj\n", - "UKpsSEapki9SrhRBqTI1JUsRHIzyAuPJlC7ZsWNH5dhMGZBS5VOk3H7LlOsYGBioHNvf3185Nlt6\n", - "ZsaMGZVjM/t5586dlWNLlXzJKvlZW1XJ0jOlypFkjrnM8ZY5n7LxpUo/vVxxhQoAAKAmEioAAICa\n", - "SKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJoaLz1TtdxC\n", - "Ztr7bAmObig9kymHkC0nk5EpJ5MZk0yfS451ZtuZMjyZ2FKlITLlLLIyZVG2b99eOfa5556rHJsZ\n", - "60xJGylX1iazn0uNScnyWhmZMdm9e3eR2Oy+2LVrV+XYzO83a9asyrGZ4y17LGfiM8dnqfJhmc+W\n", - "zHFRetvjKXqFyvbHbd9v+17bX7Nd/SgCAADoEcUSKtsLJL1X0mkRcbKkPkkXlmoPAACgKSVv+T0n\n", - "aY+k2bb3Spot6fGC7QEAADSi2BWqiPg/SZ+RtEHSE5KejYj/KNUeAABAU0re8lso6c8kLZB0lKTD\n", - "bF9cqj0AAICmlLzlt0jSDyLifyXJ9jclvV7StaODRkZG9r8eHh7W8PBwwS4BAABUs3HjRm3atKlS\n", - "bMmE6seS/sL2gKSdkt4saeXYoCVLlhTsAgAAwOQMDQ1paGho//KKFSs6xpZ8hupuSV+RtErSPe3V\n", - "V5VqDwAAoClFJ/aMiE9J+lTJNgAAAJpG6RkAAICaSKgAAABqaryWX9UaU5lacCVrmpWso1dCyZpf\n", - "mTpX2Zp7VZX8/TJ1DWfOnFk5NlMTK9OHTKyUO5Yz287UxMrsi0x/M7XSpFz9s8xYZ/bFli1bisRm\n", - "+5E5VzPjlxmTwcHBIn0oue3s+VdV9m/Ojh07Ksdmj6OqStWmzY515lzNHBedcIUKAACgJhIqAACA\n", - "mkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJq6MqHasGFD011ADYxf71q3bl3TXUANTzzxRNNdwCSt\n", - "X7++6S6gpq5MqDZu3Nh0F1AD49e7+FDvbSRUvYtzr/d1ZUIFAADQS0ioAAAAanKmFMdBb9xurnEA\n", - "AICkiBi3Xk6jCRUAAMChgFt+AAAANZFQAQAA1NR1CZXtc2z/2PbDtj/WdH/Qme1/tP2U7XtHrTvC\n", - "9i22H7L9Xdtzm+wjOrM9ZPs22/fbvs/2B9vrGcMuZ3uW7Tttr7G91vYV7fWMXQ+x3Wd7te3vtJcZ\n", - "vx7WVQmV7T5Jn5d0jqQTJV1k+4Rme4UD+KJaYzXa5ZJuiYjjJd3aXkZ32iPpsog4SdJiSe9vn2+M\n", - "YZeLiJ2SzoqI10g6RdJZtpeIses1l0paK2nfw8yMXw/rqoRK0umSHomIdRGxR9J1kt7WcJ/QQUQs\n", - "l/TMmNXnS/py+/WXJb19SjuFyiLiyYhY0369VdIDko4WY9gTImJ7++VMSX1qnYuMXY+wPU/SuZK+\n", - "IGnft8YYvx7WbQnV0ZJGT7O9qb0OveOVEfFU+/VTkl7ZZGdQje0Fkk6VdKcYw55ge5rtNWqN0W0R\n", - "cb8Yu17yWUkfkfTCqHWMXw/rtoSKORwOIdGak4Mx7XK2D5P0DUmXRsSW0e8xht0rIl5o3/KbJ+kN\n", - "ts8a8z5j16Vsv1XS5ohYrZ9dnXoRxq/3dFtC9bikoVHLQ2pdpULveMr2qyTJ9i9K2txwf3AAtmeo\n", - "lUxdExE3tFczhj0kIn4q6d8k/ZoYu17xeknn2/6JpK9L+nXb14jx62ndllCtknSc7QW2Z0q6QNK3\n", - "G+4Tcr4t6ZL260sk3XCAWDTItiVdLWltRFw56i3GsMvZfsW+b4DZHpB0tqTVYux6QkQsi4ihiDhG\n", - "0oWSvhcR7xLj19O6bqZ0278p6Uq1HrK8OiKuaLhL6MD21yWdKekVat3v/0tJ35L0z5KGJa2T9M6I\n", - "eLapPqKz9rfCvi/pHv3s1sLHJa0UY9jVbJ+s1kPL09r/XRMRn7Z9hBi7nmL7TEkfiojzGb/e1nUJ\n", - "FQAAQK/ptlt+AAAAPYeECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioAjbN9R/v/821f\n", - "dJC3vWy8tgDgYGIeKgBdw/Yb1Zrk8LzEz0yPiOcP8P6WiJhzMPoHAJ1whQpA42xvbb/8pKSltlfb\n", - "vtT2NNuftr3S9t22/7gd/0bby21/S9J97XU32F5l+z7b722v+6Skgfb2rhndlls+bfte2/fYfueo\n", - "bf+n7X+x/YDtr07t3gDQi6Y33QEA0M9K33xM0of3XaFqJ1DPRsTptvsljdj+bjv2VEknRcT69vJ7\n", - "IuKZdm27lbavj4jLbb8/Ik4dp63flvSrkk6RdKSkH9r+fvu910g6UdJ/S7rD9hkRwa1CAB1xhQpA\n", - "N/GY5d+Q9G7bqyWtkHSEpGPb760clUxJ0qW210j6L0lDko6boK0lkr4WLZsl3S7ptWolXCsj4olo\n", - "PROxRtKCGr8TgJcBrlAB6HYfiIhbRq9oP2u1bczymyQtjoidtm+TNGuC7YZemsDtu3q1a9S6veKz\n", - "EsAEuEIFoJtskTT6AfKbJb3P9nRJsn287dnj/Nzhkp5pJ1O/ImnxqPf27Pv5MZZLuqD9nNaRkt4g\n", - "aaVemmQBwIT4VxeAbrDvytDdkva2b919UdLn1Lrd9iPblrRZ0m+140d/RfkmSX9ie62kB9W67bfP\n", - "VZLusX1XRLxr389FxL/afl27zZD0kYjYbPuEMdvWOMsA8CJMmwAAAFATt/wAAABqIqECAACoiYQK\n", - "AACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJr+H2eW+wXdCzz6AAAAAElFTkSuQmCC\n" + "AAALEgAACxIB0t1+/AAAEqlJREFUeJzt3X2QXXV9x/HPJ5unTUICFKoFdjcWYitBa6gygAkP1RbK\n", + "aLStBWmr1HbsdNSaUmUMzLR/tSPIdKSO085YqAI+QdWiTiuBVioLYiKQ8BTkoSNNAoWkFDbPybJ8\n", + "+8e9Cctmb/Z89+S3997wfs0w3nPud3/nd8/v3JOv55z7+zoiBAAAgMmb1u4OAAAAdDsSKgAAgJpI\n", + "qAAAAGoioQIAAKiJhAoAAKAmEioAAICaprdz47aZswEAAHSNiPB464smVLbPl3SNpB5J10bEVWNj\n", + "Lr/88gP+bnBwUMuWLXvVumnTql9Ms8f9rIdEpu1SsZl9MX16bogz8a1iV61apfPOO2/S7Zb8fJm2\n", + "MzLj9/LLL1eOzcwT19vbWzlWkubMmXPAuptvvlkXXnjhAevnzZtXq91WZs6cWTl27969lWN37dpV\n", + "OVaSdu7cWaQfmbHOxLbaxzfddJMuuuiiA9YfccQRlds+6qijKsceeeSRlWPnz59fOTZzLM+ePbty\n", + "rCTNmDEjFV/Vnj17KseOd7xdeeWVWrly5QHrt2/fnurHjh07Ksfu3r27SOzw8HDl2FLnw6yq5/Bz\n", + "zjmn5XvFbvnZ7pH0BUnnSzpZ0sW231RqewAAAO1S8hmq0yQ9GRFPRcSwpG9Iem/B7QEAALRFyYTq\n", + "eEkbRy1vaq6bUH9/f5EOYWqceOKJ7e4CJmnx4sXt7gJqYPy619KlS9vdBdRUMqGa9M3OgYGBQ9kP\n", + "TLGTTjqp3V3AJPEPcnc75ZRT2t0FTBIJVfcr+VD605L6Ri33qXGV6lUGBwf3v+7v7yeZAgAAHWHt\n", + "2rVat25dpdiSCdW9khbZXijpGUkXSbp4bNDYX/MBAAB0giVLlmjJkiX7l6+//vqWscUSqoh4yfbH\n", + "Ja1SY9qE6yLi0VLbAwAAaJei81BFxPclfb/kNgAAANqtrTOlS9Un9RoZGancZnbyr1KT73VCbGa/\n", + "SdJLL73UVbElP19mP5f6fJnJAjMTTmbbLtWPUpNkltwXmQkOM+1mPl9JpSa/7enpqRybmfA1299S\n", + "3+tOON9L5SZGzrSbmTz1UEwm3UqpCZdboZYfAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAAQE0k\n", + "VAAAADWRUAEAANREQgUAAFATCRUAAEBNJFQAAAA1kVABAADU1PZaftnaPOicml+ZfmTqK2ZiM7W2\n", + "OkWmJlamFlUmViq3n0sdF6VqzGVl6syVOr8NDw8Xiy9VZy5zDO3cubNIu1nZurBVzZo1q3Jsb29v\n", + "qu1M/OzZsyvHZvqcUWofS2VqrF511VUt3yt6hrLdZ/sO24/Yftj2J0puDwAAoB1KXx4alnRpRKyz\n", + "PU/SfbZvj4hHC28XAABgyhS9QhURz0bEuubr7ZIelXRcyW0CAABMtSl7KMH2QklLJK2eqm0CAABM\n", + "hSlJqJq3+74paUXzShUAAMBho/hP7GzPkPQtSV+JiFvGvn/nnXfufz0wMKCBgYHSXQIAAJjQhg0b\n", + "tGHDhkqxRRMqN37HfZ2k9RFxzXgxZ511VskuAAAATEp/f7/6+/v3L999990tY0vf8nuHpD+QdK7t\n", + "tc3/zi+8TQAAgClV9ApVRNwlZmMHAACHOZIdAACAmtpe96VTyqhUVaqESqk+lGw7M3bZsihVlSxd\n", + "lCl1kont6ekp0m72uzQyMlI5NrOfS5WeybS7d+/eyrFSrkRFpu0ZM2ZUjs2UDJk/f37lWCl3zGWO\n", + "i0yJmB07dlSO3b17d5FYKTd+mX0xd+7cyrGZ8cuOdaZETOY7NTQ0VDl2165dlWMz47dnz57KsVJu\n", + "/A7Fv6tcoQIAAKiJhAoAAKAmEioAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKh\n", + "AgAAqImECgAAoKauKT1TqpxFSaXKapT8fKVKxHRCaRYp9/lKjV+pEirDw8OVY7PxmRIOpUr2ZMYu\n", + "U0pGyo1JptxKph+Zz5c97jNjXarsSyY2c7xlSvZIudIsmTHJlNbZsmVL5ditW7dWjpVyY505PjPn\n", + "w8zxOXPmzMqxmVJOUtl/S8bTMqGy/TuSQtJ4R1RExLerbMB2j6R7JW2KiPdMqpcAAAAd7GBXqN6j\n", + "RkLVSqWEStIKSeslHVG1UwAAAN2kZUIVEX9Yt3HbJ0i6QNLfSPqLuu0BAAB0oglvGtp+ve3rbN/a\n", + "XD7Z9h9XbP9zki6TVP0BBQAAgC5T5SmsL0u6TdJxzeUnJF060R/ZfrekzRGxVuM/hwUAAHBYqPIr\n", + "v2Mi4ibbKyUpIoZtV/lpwJmSltu+QNJsSfNt3xARHxoddNddd+1/3d/fr/7+/uq9BwAAKGRoaKjy\n", + "Ly2rJFTbbf/cvgXbp0samuiPIuIKSVc0/+ZsSZ8am0xJ0tKlSyt1FAAAYCotWLBACxYs2L/89NNP\n", + "t4ytklB9UtL3JP2i7R9JOlbS+yfRr86YHAoAAOAQmzChioj7bJ8l6ZfUeBbqsYhIzSAYET+U9MPJ\n", + "dREAAKCzTZhQ2e6V9FFJS9W4yjRo+x8iovq0twAAAIexKrf8bpC0VdLn1bhC9XuSbpT0uwX7BQAA\n", + "0DWqJFSLI+LkUcs/sL3+UHWgav2cUjXYsvGl6uhNn169rGLJml+l2s60W6qeYFapsc7Ulzr66KMr\n", + "x2ZqYmXjMzW0MnXYMvXdMnXHsrX8MmMye/bsyrFz5sypHDtv3rzKsdnvSOa7WqpuY6lzXKYOYza+\n", + "VC2/Xbt2VY7N1ugsNX6ZGoiZ2My5JVvLL3PMVY1dvnx5y/eq7M37bZ+xb6H5K7/7Km0ZAADgNeBg\n", + "xZEfGhVzt+2NajxD1S/psSnoGwAAQFeYqDgyAAAAJnCw4shPjV62/fNqzHgOAACAUaoUR15u+wlJ\n", + "P1NjLqmnJH2/cL8AAAC6RpWH0v9a0hmSHo+IN0h6p6TVRXsFAADQRaokVMMR8b+SptnuiYg7JL2t\n", + "cL8AAAC6RpWJF16wfYSkQUlftb1Z0vay3QIAAOgeVa5QvU/STkmXSrpV0pPiF4AAAAD7VSmOvO9q\n", + "1IikLxftDQAAQBc62MSe29WYyHM8ERHzD0UHqpaeyEyR343lVjpFptxKpoRDpt1u3G+Z0iWZ0hDb\n", + "tm2rHJstt5LZz5kSDpmSNqXazZRxkXLlPTJlQ4aGhor0IVuOpNT5s9SYZMr7lCxHktkXmfNhJjZT\n", + "nknKlcDJHEeZPmfOh5ljKFteq0TpmYO20eqNiMidkcZh+0hJ10parEZy9kcR8eO67QIAAHSS+inZ\n", + "wf2dpH+LiPfbni5pbuHtAQAATLliCZXtBZKWRcQlkhQRL0mqfv0bAACgS+QeNsp5g6Qttr9k+37b\n", + "/2h7TsHtAQAAtEXJhGq6pFMl/X1EnCpph6SVBbcHAADQFiWfodokaVNE/KS5/E2Nk1Ddc889+1+f\n", + "cMIJ6uvrK9glAACAap544gk9+eSTlWKLJVQR8aztjbbfGBGPS3qXpEfGxp1xxhmlugAAADBpixYt\n", + "0qJFi/Yvr1q1qmVs6V/5/Zka5WpmSvovSR8uvD0AAIApVzShiogHJL295DYAAADareRD6QAAAK8J\n", + "pW/5TSg7lXwV2dIlpUqdZEvgdIJMeYGMUqVnMiUOpHKlgzL7befOnUVi9+7dWzlWypWqyXy+zD6e\n", + "M6f6TCqZciTZ80omPnMs79mzp3JsZjwyfZBy45c5jjKfL9Nu5rtXsvRMJjZzLGf6XPIc1wmxJcvw\n", + "ZI6j7HdqPN33Lz4AAECHIaECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAA\n", + "gJpIqAAAAGoioQIAAKip7aVnSpV9yShVFqVUGZdS0/p3ikyJiuHh4VTbIyMjbY/NlDnJlFuZO3du\n", + "5Vgp1+fMfs6UI8mU1tm6dWvl2EwZEEnq7e0t0vb8+fMrx2bOQyXLDGX2RabdTNmQTLtZpc4vme9T\n", + "pvRM5hwg5cavVGyp8ky7du2qHCuVK6PUStErVLYvt/2I7Ydsf832rJLbAwAAaIdiCZXthZI+IunU\n", + "iHizpB5JHyi1PQAAgHYpectvq6RhSXNsj0iaI+npgtsDAABoi2JXqCLi/yT9raQNkp6R9GJE/Hup\n", + "7QEAALRLyVt+J0r6c0kLJR0naZ7t3y+1PQAAgHYpecvvbZJ+FBHPS5Ltb0s6U9JXRwcNDg7uf93f\n", + "36+BgYGCXQIAAKhm48aN2rRpU6XYkgnVTyX9pe1eSbslvUvSmrFBy5YtK9gFAACAyenr61NfX9/+\n", + "5dWrV7eMLfkM1QOSbpB0r6QHm6u/WGp7AAAA7VJ0Ys+I+Kykz5bcBgAAQLtRegYAAKAmEioAAICa\n", + "2l7Lr2rNn0xtoEzs4S5by69U7b9S41fy802fXv3rkanPl/l8mfpg2X2RqQmZqWGZaTcTm6kllhkP\n", + "SZo1q3pVrMy+eP755yvHDg0NVY7dvn175VipXG28TJ25TGxmPDI1AqXcd6rUeStzDGXr3WY+X+Y4\n", + "2rZtW+XYTvn3OnN+mTdvXv3t1W4BAADgNY6ECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKCm\n", + "jkyoNmzY0O4uoIaNGze2uwuYJMauu23evLndXcAkPfPMM+3uAmoiocIhV7UyNzoPY9fdtmzZ0u4u\n", + "YJJIqLpfRyZUAAAA3YSECgAAoCa3s0yLbWrEAACArhER49YDamtCBQAAcDjglh8AAEBNJFQAAAA1\n", + "dVxCZft82z+1/YTtT7e7P2jN9j/Zfs72Q6PWHW37dtuP277N9pHt7CNas91n+w7bj9h+2PYnmusZ\n", + "ww5ne7bt1bbX2V5v+zPN9YxdF7HdY3ut7e81lxm/LtZRCZXtHklfkHS+pJMlXWz7Te3tFQ7iS2qM\n", + "1WgrJd0eEW+U9B/NZXSmYUmXRsRiSadL+ljz+8YYdriI2C3p3Ih4q6S3SDrX9lIxdt1mhaT1kvY9\n", + "zMz4dbGOSqgknSbpyYh4KiKGJX1D0nvb3Ce0EBGDkl4Ys3q5pOubr6+X9L4p7RQqi4hnI2Jd8/V2\n", + "SY9KOl6MYVeIiJ3NlzMl9ajxXWTsuoTtEyRdIOlaSft+Ncb4dbFOS6iOlzS69sWm5jp0j9dFxHPN\n", + "189Jel07O4NqbC+UtETSajGGXcH2NNvr1BijOyLiETF23eRzki6T9PKodYxfF+u0hIo5HA4j0ZiT\n", + "gzHtcLbnSfqWpBURsW30e4xh54qIl5u3/E6QdJbtc8e8z9h1KNvvlrQ5ItbqlatTr8L4dZ9OS6ie\n", + "ltQ3arlPjatU6B7P2X69JNn+BUlUa+1gtmeokUzdGBG3NFczhl0kIoYk/aukXxVj1y3OlLTc9s8k\n", + "fV3Sr9m+UYxfV+u0hOpeSYtsL7Q9U9JFkr7b5j4h57uSLmm+vkTSLQeJRRvZtqTrJK2PiGtGvcUY\n", + "djjbx+z7BZjtXkm/LmmtGLuuEBFXRERfRLxB0gck/SAiPijGr6t13Ezptn9T0jVqPGR5XUR8ps1d\n", + "Qgu2vy7pbEnHqHG//68kfUfSzZL6JT0l6cKIeLFdfURrzV+F3SnpQb1ya+FySWvEGHY0229W46Hl\n", + "ac3/boyIq20fLcauq9g+W9InI2I549fdOi6hAgAA6DaddssPAACg65BQAQAA1ERCBQAAUBMJFQAA\n", + "QE0kVAAAADWRUAEAANREQgWg7Wzf3fzfAdsXH+K2rxhvWwBwKDEPFYCOYfscNSY5fE/ib6ZHxEsH\n", + "eX9bRBxxKPoHAK1whQpA29ne3nx5paRlttfaXmF7mu2rba+x/YDtP2nGn2N70PZ3JD3cXHeL7Xtt\n", + "P2z7I811V0rqbbZ34+htueFq2w/ZftD2haPa/k/b/2z7Udtfmdq9AaAbTW93BwBAr5S++bSkT+27\n", + "QtVMoF6MiNNsz5J0l+3bmrFLJC2OiP9uLn84Il5o1rZbY/ubEbHS9sciYsk42/ptSb8i6S2SjpX0\n", + "E9t3Nt97q6STJf2PpLttvyMiuFUIoCWuUAHoJB6z/BuSPmR7raQfSzpa0knN99aMSqYkaYXtdZLu\n", + "kdQnadEE21oq6WvRsFnSDyW9XY2Ea01EPBONZyLWSVpY4zMBeA3gChWATvfxiLh99Irms1Y7xiy/\n", + "U9LpEbHb9h2SZk/QbujABG7f1as9o9aNiHMlgAlwhQpAJ9kmafQD5KskfdT2dEmy/Ubbc8b5u/mS\n", + "XmgmU78s6fRR7w3v+/sxBiVd1HxO61hJZ0laowOTLACYEP+vC0An2Hdl6AFJI81bd1+S9Hk1brfd\n", + "b9uSNkv6rWb86J8o3yrpT22vl/SYGrf99vmipAdt3xcRH9z3dxHxL7bPaG4zJF0WEZttv2lM2xpn\n", + "GQBehWkTAAAAauKWHwAAQE0kVAAAADWRUAEAANREQgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIF\n", + "AABQ0/8DEfw5JxfRlIgAAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2744,7 +2790,7 @@ "T5UJ3wAAAABJRU5ErkJggg==\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2754,94 +2800,94 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAEqRJREFUeJzt3X+QXXV5x/HPJ5uE3SSAY6GxwUjYjWmE0QpFBomK1DSh\n", - "jqJtrUpbpdKx01ErpcqIzLR/tYOV6Ugdp52xUBREpVWLOEUSUilirIRAAvlBICC0oDVpS9AsSZYl\n", - "PP3j3g3LZm/2PDn57r0nvl8zDPec+9zv+d77Pffsk3PO/T6OCAEAAODwzeh2BwAAAJqOhAoAAKAm\n", - "EioAAICaSKgAAABqIqECAACoiYQKAACgppnd3Lht5mwAAACNERGebH3RhMr2+ZKultQn6ZqI+OuJ\n", - "MVdeeeVBr1uzZo2WL18+sa3MdlP9zMzFVWrerlLvb8aM3EnII9GPVatWaeXKlantTpdSY/38889X\n", - "jn322Wcrx+7fv79ybF9fX+VYSTrmmGMOWrd69WqtWLHioPX9/f2V2505s8xh5ZlnnikSK0nDw8OV\n", - "Y0dGRirHjo6OFontNNbr16/XmWeeedD6zPjNnTu3cuycOXOKtJvZh7LH+1Iy3+vJ9qHJ/u5J0p49\n", - "e1L9KLV/Ztp97rnnisRmjrPZ+KqxN954Y8fnil3ys90n6XOSzpd0qqQLbb+q1PYAAAC6peQ9VGdJ\n", - "eiQiHo+IUUlflfSOgtsDAADoipIJ1UmSnhi3/GR73ZQGBweLdAjTY2hoqNtdwGFi7JptwYIF3e4C\n", - "DhN/95qvZEJ12DcbsWM12+LFi7vdBRwmEqpmI6FqLv7uNV/Jm9J/JGnhuOWFap2lepE1a9YceDw4\n", - "OMhOBQAAesKOHTu0Y8eOSrElE6r1kl5pe5GkH0t6j6QLJwZN9qsGAACAbps/f77mz59/YHnTpk0d\n", - "Y4slVBHxnO2PSFql1rQJ10bEg6W2BwAA0C1F56GKiG9L+nbJbQAAAHRbV2dKl6TZs2dXistM0JWZ\n", - "DDEbX2KiMKncJJLZidBKTciWiS01gZyUm8iu1PvL9GHfvn2VY7MTAGYmv8xMfJnpx969eyvHZvbl\n", - "7H6ROQZk2s60W+oYkO1HRqmJjiebdLaT7ESymcmOs59zVSUnk868v8xkwJkJVDNjkulDyYmqj8S+\n", - "TC0/AACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioAAICa\n", - "SKgAAABqIqECAACoqeu1/Hbt2lUpbtasWZXbrFofcEymblSmH9m6Q1X1Ss2vUnXKStUHk3JjkqlH\n", - "ldkvStYpyyhVfzCzz2XqeGW+1yXru2X6kYnN1B3L1irM1ITMfK9L1aXM1HjM9EEqV7s1c9wqdWyR\n", - "cseXgYGByrGZfblkfb6MzJhU/U5dfPHFHZ8reobK9kLbd9jeYnuz7Y+W3B4AAEA3lD5DNSrp0ojY\n", - "aHuepHtt3x4RDxbeLgAAwLQpeoYqIn4SERvbj4clPShpQcltAgAATLdpuynd9iJJp0u6e7q2CQAA\n", - "MB2mJaFqX+77mqRL2meqAAAAjhrFf+Vne5akr0v6UkTcPPH5O++888Djk08+WYsWLSrdJQAAgClt\n", - "27ZN27ZtqxRbNKFy63fA10raGhFXTxZz7rnnluwCAADAYVm6dKmWLl16YPmWW27pGFv6kt8ySb8v\n", - "6TzbG9r/nV94mwAAANOq6BmqiPiemI0dAAAc5Uh2AAAAaup66Zn58+dXisuUAChZbiVTPqFUuZXs\n", - "+8so1Xap8gKZch1SbqxHRkYqx2bGr1Tpi2w5klL7XKnSQZn3lyldIuW+15l+ZPb7TMmQefPmVY7N\n", - "tp35TmX2i2effbZy7J49e4rESrnxy3xXM2Pd399fOTZbSi1T9iUTW6rUWKkSWFJunzsSf/s4QwUA\n", - "AFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQEwkVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAA\n", - "QE1dLz2ze/fuSnGZKfJnzsy9rczU/pl+lCq3kpEtzZJ5f5m2M2OSGY9MSY2SbWfazcSWKgOSjc+M\n", - "35w5cyrHHnvssUVis+U6Zs2aVTk2U84iU4Kj5H5fqnRQphxJqTIgAwMDlWOl3OecOYZnPotMaaRM\n", - "WSSpXCmXUqVnMp9x5u+TlDtuVY296aabOrfR6Qnbvy0pJE12RI+I+EaVjdvuk7Re0pMR8fYqrwEA\n", - "AGiSQ6Vkb1croeqkUkIl6RJJWyVV/+clAABAg3RMqCLiD+o2bvvlkt4q6a8k/Vnd9gAAAHrRlBcv\n", - "bb/M9rW2b2svn2r7Dyu2/xlJl0nK3dwBAADQIFXuBvuCpNWSFrSXt0u6dKoX2X6bpJ0RsUGT34cF\n", - "AABwVKhyW/sJEXGT7cslKSJGbVf5GcE5ki6w/VZJ/ZKOs319RLx/fNCaNWsOPB4cHNTg4GD13gMA\n", - "ABSydu1arV27tlJslYRq2PYvjC3YPlvST6d6UURcIemK9mvOlfTxicmUJC1fvrxSRwEAAKbTsmXL\n", - "tGzZsgPLV111VcfYKgnVxyR9S9Kg7e9LOlHSuw6jX9UnpgAAAGiQKROqiLjX9psk/bJa90I9FBHV\n", - "ZwNrtXGnpDsPr4sAAAC9bcqEyvaApA9JeoNaZ5nusv33EZGbvhUAAOAoVeWS3/WSfibps2qdofpd\n", - "STdI+p2C/QIAAGiMKgnVaRFx6rjl79jeesQ6ULF+TqY2UKaWUTY+049SMvXdsrX8miY7Hpn4TD2x\n", - "UnWuStVWlHJ1rjK17jL9yNR3y9Qdy9RKk/LHjKoyn1umJl3J73WpOmylYkvWsMzEVq1LK0nDw8OV\n", - "Y0dGRirHSrnvSUamfmR/f3/l2Mx+n6kTmm07Wx9zMlX22vtsv35sof0rv3trbxkAAOAocajiyJvG\n", - "xay1/YRa91C9QtJD09A3AACARpiqODIAAACmcKjiyI+PX7b9i2rNeA4AAIBxqhRHvsD2dkmPqTWX\n", - "1OOSvl24XwAAAI1R5ab0v5T0ekkPR8Qpkt4i6e6ivQIAAGiQKgnVaET8r6QZtvsi4g5JZxbuFwAA\n", - "QGNUmYhml+1jJd0l6UbbOyVVn0QDAADgKFflDNU7Je2RdKmk2yQ9In4BCAAAcECV4shjZ6P2S/pC\n", - "0d4AAAA00KEm9hxWayLPyUREHFemSx37U6ztTKmFUv3ohZI2UrnyEJnPrVQfpHKfc6mSNhnZzyJT\n", - "amHu3LmVYzPlVkqVlMqOc6YETqnjRabd7PvL7BuZzyJTcqmU7H5fquTSSSedlOpHVdmySJnxy7Sd\n", - "OW6VOs5mx7rU351ODjUP1by6jdt+iaRrJJ2mVnJ2cUT8oG67AAAAvaR6qn54/lbSrRHxLtszJVX/\n", - "Zy4AAEBDFEuobB8v6Y0RcZEkRcRzkn5aansAAADdUv+iYWenSPof29fZvs/2P9ieU3B7AAAAXVEy\n", - "oZop6QxJfxcRZ0h6RtLlBbcHAADQFSXvoXpS0pMRcU97+WuaJKFavXr1gcdDQ0MaGhoq2CUAAIBq\n", - "Hn74YW3fvr1SbLGEKiJ+YvsJ20si4mFJyyVtmRi3YsWKUl0AAAA4bEuWLNGSJUsOLN96660dY0v/\n", - "yu9P1CpXM1vSo5I+UHh7AAAA065oQhUR90t6XcltAAAAdFvJm9IBAAB+LpS+5DelqtO9Z6a9z5b2\n", - "KFUKJCMzRX7J6fRLlX3JxPb19VWOzZSRyPajVFmUvXv3Vo4tVUYi66mnnqocmynX0d/fXzk2Uyon\n", - "04ds25nPed++fUXazR6zeqUETlWZY0C2HFjmsxsdHS3Sj8xxa2BgoHKsJM2ZU312osz49UKZoV7H\n", - "GSoAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJpI\n", - "qAAAAGrqeumZErLlEDLxpcrUlCqJki0XUKpETEamz9n3lynvUSo2U3Zi9uzZlWOz45HZj0ZGRirH\n", - "7t69u3JsprRHZqwz5TekXAmcTGxm/EqVn8rGZ/bPzD6UKaOUKc+UPSZnygFl2s6UL8rsF9l9OVOq\n", - "JlOiKXN8yRwPM/tFJjYbnznGdVL0DJXtT9reYnuT7S/brr7HAQAANESxhMr2IkkflHRGRLxaUp+k\n", - "95baHgAAQLeUvOT3M0mjkubY3i9pjqQfFdweAABAVxQ7QxURT0n6G0n/JenHkp6OiDWltgcAANAt\n", - "JS/5DUn6U0mLJC2QNM/275XaHgAAQLeUvOR3pqTvR8T/SZLtb0g6R9KN44NWrVp14PHQ0JAWL15c\n", - "sEsAAADVPProo/rhD39YKbZkQrVN0p/bHpC0T9JySesmBq1cubJgFwAAAA7P0NCQhoaGDiyvWdP5\n", - "zqWS91DdL+l6SeslPdBe/flS2wMAAOiWohN7RsSnJX265DYAAAC6jdIzAAAANZFQAQAA1NT1Wn5H\n", - "on7ORCXrXGVqH2X7UULJuoaZek2ZdkvWVszUKcvUbCtVx6tUu1JuX+6F/SIzdnPnzq0cK0nHH398\n", - "5dh58+ZVjs18FsPDw5VjM/USpVzNxMx3KrPPZcbkuOOOqxybrWGZic/EZuqgZmTfX2afy/z9LXUM\n", - "z/6NyihVw7ITzlABAADUREIFAABQEwkVAABATSRUAAAANZFQAQAA1ERCBQAAUFNPJlRVCxGiNzF+\n", - "zbVly5ZudwE1bN68udtdwGG65557ut0F1NSTCdVjjz3W7S6gBhKq5tq6dWu3u4AaSKiai4Sq+Xoy\n", - "oQIAAGgSEioAAICaXHLa9yk3bndv4wAAAEkRMWlNm64mVAAAAEcDLvkBAADUREIFAABQU88lVLbP\n", - "t73N9nbbn+h2f9CZ7X+0vcP2pnHrXmr7dtsP215t+yXd7CM6s73Q9h22t9jebPuj7fWMYY+z3W/7\n", - "btsbbW+1fWV7PWPXILb7bG+w/a32MuPXYD2VUNnuk/Q5SedLOlXShbZf1d1e4RCuU2usxrtc0u0R\n", - "sUTSv7WX0ZtGJV0aEadJOlvSh9vfN8awx0XEPknnRcRrJb1G0nm23yDGrmkukbRV0tjNzIxfg/VU\n", - "QiXpLEmPRMTjETEq6auS3tHlPqGDiLhL0q4Jqy+Q9MX24y9Keue0dgqVRcRPImJj+/GwpAclnSTG\n", - "sBEiYk/74WxJfWp9Fxm7hrD9cklvlXSNpLFfjTF+DdZrCdVJkp4Yt/xkex2aY35E7Gg/3iFpfjc7\n", - "g2psL5J0uqS7xRg2gu0ZtjeqNUZ3RMQWMXZN8hlJl0l6ftw6xq/Bei2hYg6Ho0i05uRgTHuc7XmS\n", - "vi7pkojYPf45xrB3RcTz7Ut+L5f0JtvnTXiesetRtt8maWdEbNALZ6dehPFrnl5LqH4kaeG45YVq\n", - "naVCc+yw/TJJsv1LknZ2uT84BNuz1EqmboiIm9urGcMGiYifSvpXSb8qxq4pzpF0ge3HJH1F0q/Z\n", - "vkGMX6P1WkK1XtIrbS+yPVvSeyTd0uU+IecWSRe1H18k6eZDxKKLbFvStZK2RsTV455iDHuc7RPG\n", - "fgFme0DSr0vaIMauESLiiohYGBGnSHqvpO9ExPvE+DVaz82Ubvs3JF2t1k2W10bElV3uEjqw/RVJ\n", - "50o6Qa3r/X8h6ZuS/knSKyQ9LundEfF0t/qIztq/CvuupAf0wqWFT0paJ8awp9l+tVo3Lc9o/3dD\n", - "RFxl+6Vi7BrF9rmSPhYRFzB+zdZzCRUAAEDT9NolPwAAgMYhoQIAAKiJhAoAAKAmEioAAICaSKgA\n", - "AABqIqECAACoiYQKQNfZXtv+/8m2LzzCbV8x2bYA4EhiHioAPcP2m9Wa5PDtidfMjIjnDvH87og4\n", - "9kj0DwA64QwVgK6zPdx++ClJb7S9wfYltmfYvsr2Otv32/6jdvybbd9l+5uSNrfX3Wx7ve3Ntj/Y\n", - "XvcpSQPt9m4Yvy23XGV7k+0HbL97XNv/bvufbT9o+0vT+2kAaKKZ3e4AAOiF0jefkPTxsTNU7QTq\n", - "6Yg4y/Yxkr5ne3U79nRJp0XEf7aXPxARu9q17dbZ/lpEXG77wxFx+iTb+i1JvyLpNZJOlHSP7e+2\n", - "n3utpFMl/bektbaXRQSXCgF0xBkqAL3EE5ZXSHq/7Q2SfiDppZIWt59bNy6ZkqRLbG+U9B+SFkp6\n", - "5RTbeoOkL0fLTkl3SnqdWgnXuoj4cbTuidgoaVGN9wTg5wBnqAD0uo9ExO3jV7TvtXpmwvJbJJ0d\n", - "Efts3yGpf4p2QwcncGNnr0bGrdsvjpUApsAZKgC9ZLek8TeQr5L0IdszJcn2EttzJnndcZJ2tZOp\n", - "pZLOHvfc6NjrJ7hL0nva92mdKOlNktbp4CQLAKbEv7oA9IKxM0P3S9rfvnR3naTPqnW57T7blrRT\n", - "0m+248f/RPk2SX9se6ukh9S67Dfm85IesH1vRLxv7HUR8S+2X9/eZki6LCJ22n7VhLY1yTIAvAjT\n", - "JgAAANTEJT8AAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoKb/\n", - "B1nWRTATo8RuAAAAAElFTkSuQmCC\n" + "AAALEgAACxIB0t1+/AAAEr9JREFUeJzt3X+wXGV9x/HPJ79vQoJaaCwYmx83psJohYqDv6IUwwRG\n", + "0LZWpa1S27HTUWtK1RGZKX+1amU6UsdpZ6zUH6hIqxZ1KDEpgkGthB8JEBJ+hAktYE1aCprLzQ03\n", + "4ds/dhOvl7u5z/eePHd3w/s1w7Bn97vPefY8Z8/95pyzz9cRIQAAAEzdjG53AAAAoN+RUAEAADRE\n", + "QgUAANAQCRUAAEBDJFQAAAANkVABAAA0NKubK7fNnA0AAKBvRIQner5qQmV7raQrJM2U9NmI+Jvx\n", + "MZdffvkz3rdhwwadc845Nbs2Zb0wb5c94VhOaMaM3EnIo9H29ddfr3PPPbdRP0plxyMTf+DAgSqx\n", + "o6OjVWJnz55dHNspfuPGjVqzZs0znh8YGChud86cOcWxmf1teHi4OHZoaKg4VpL27t1bHLtv377i\n", + "2Mz4ZfahTmN966236owzznjG83Pnzi1ue/78+cWxCxcuLI6ttQ/NmpX7MzZz5szi2MzxYmRkpDh2\n", + "on2o09+97L6c2T8zfc7EPvXUU8WxBw8erBJby9VXX93xtWqX/GzPlPRpSWslnSLpQtsvrrU+AACA\n", + "bql5D9UrJO2MiIciYlTSVyW9qeL6AAAAuqJmQnWypIfHLD/Sfm5SK1asqNIhTI/BwcFudwFTtHz5\n", + "8m53AQ2cdNJJ3e4Cpoi/e/2vZkI15ZuN2LH628qVK7vdBUwR373+dvLJRf9mRQ/iu9f/at6U/qik\n", + "JWOWl6h1luoXbNiw4fDjFStWsFMBAICesHv3bu3Zs6cotmZCdZuklbaXSvqxpLdJunB8UK/+mg8A\n", + "ADy7LV68WIsXLz68vG3bto6x1RKqiDhg+32SvqPWtAlXRsSOWusDAADolqrzUEXE9ZKur7kOAACA\n", + "buvqTOlS+SRrmQnWspM9ZiYLe/rpp4tjMxP1ZdrN9DczsaDUGxNU1oqV6m27TLuZSe8yk+nt37+/\n", + "OFaqNwFg5vNl+lxrG0vNJ2XsJPP5MseAmjKTrdaaZDgzEWl2Ys+MzJj0QqyUm7g0s+0y7c6bN684\n", + "NjPWmQlfpdw+dzQmn6aWHwAAQEMkVAAAAA2RUAEAADREQgUAANAQCRUAAEBDJFQAAAANkVABAAA0\n", + "REIFAADQEAkVAABAQyRUAAAADZFQAQAANNT1Wn6ltaCORp2dTjL1jDK1qzIy7WZqFdbqb02Zz1ez\n", + "/lmtOlCZ/S3TbqbWllRvO2draZbKfL7s8SLzPZk9e3ZxbKamWWa7ZWtY1qqZWKv255NPPlkcm63b\n", + "mPl8tWrIZvahTK07qXfq6JWqWdcws3+Wxq5bt67ja1XPUNleYvtG2/fY3mb7/TXXBwAA0A21z1CN\n", + "Sro4IrbaPk7S7bY3RsSOyusFAACYNlXPUEXETyJia/vxkKQdkk6quU4AAIDpNm03pdteKuk0SbdM\n", + "1zoBAACmw7QkVO3LfV+TtK59pgoAAOCYUf1XfrZnS/q6pC9FxLXjX1+/fv3hx4ODgxocHKzdJQAA\n", + "gEk98MAD2rlzZ1Fs1YTKrd8iXylpe0RcMVHM2rVra3YBAABgSlauXKmVK1ceXh57Emi82pf8Xi3p\n", + "DySdZXtL+z8yKAAAcEypeoYqIr4vZmMHAADHOJIdAACAhrpeeiYzNXwvqFXqpFaJg2wZkF4p+3Is\n", + "q1VGKVuOJFOCI9N25jud6UMmdmRkpDhWyn2+zH6fGetMyZAFCxYUx0q5sj2Zz5fZzvv27SuOzZSe\n", + "GR4eLo6V6pWemT9/fnHsc5/73OLYRYsWFcdKubI2tcY6U+ooE5s9xmWORUejZBZnqAAAABoioQIA\n", + "AGiIhAoAAKAhEioAAICGSKgAAAAaIqECAABoiIQKAACgIRIqAACAhkioAAAAGiKhAgAAaKjrpWdm\n", + "zSrrwtGYFr4T21Vie0G2zEnm85WOnZQrhzBnzpzi2Llz5xbHZvuRKdeR2c6ZPmfGI/sdybSd2W4D\n", + "AwPFsZlyHZnYzNhl4zOlS2qVnsls46zM53vqqaeKYzMlRjKypVky2y6z32e+f5nSOk888URxrFSv\n", + "jFJGrWN49nif+V6Xxl5zzTUdX+v4F9H270gKSRMddSMivlGyctszJd0m6ZGIOL/kPQAAAP3kSKcY\n", + "zlcroeqkKKGStE7SdkkLSzsFAADQTzomVBHxh00bt/0CSedJ+mtJf9G0PQAAgF406QV+28+3faXt\n", + "9e3lU2z/cWH7n5T0IUl1LtQCAAD0gJI7Jj8vaYOkk9rLD0i6eLI32X6jpD0RsUUT34cFAABwTCj5\n", + "mdYJEXGN7UskKSJGbR8oeN+rJF1g+zxJ8yQtsv3FiHjn2KD169cffjw4OKjBwcHy3gMAAFSyadMm\n", + "bdq0qSi2JKEasv1LhxZsnynpp5O9KSIulXRp+z2vk/TB8cmUJK1du7aoowAAANNp9erVWr169eHl\n", + "j370ox1jSxKqD0j6tqTltn8o6URJb5lCv+pNJAUAANBFkyZUEXG77dWSVql1L9R9EVE+c1irje9J\n", + "+t7UuggAANDbJk2obA9Ieo+k16h1lulm2/8QESO1OwcAANAPSi75fVHSzyR9Sq0zVL8n6SpJv1ux\n", + "XwAAAH2jJKE6NSJOGbP8Xdvbj1YHSutGZWoOZWuaZeJr9aNWjcCatQdr1pkrla1FlalTlmk7025G\n", + "piZWpraiVK9WYaaWWKamWS/UjZNy2zkzfplafjVrm9balzP7UObzZfY3qd7n27dvX3FsZl/OHuMy\n", + "2y5zDKhVc6/W9ynbdvb4OZGSPfwO2688tND+ld/tjdcMAABwjDhSceS7x8T8wPbDat1D9UJJ901D\n", + "3wAAAPrCZMWRAQAAMIkjFUd+aOyy7V9Wa8ZzAAAAjFFSHPkC2w9I2qXWXFIPSbq+cr8AAAD6RslN\n", + "6X8l6ZWS7o+IZZLOlnRL1V4BAAD0kZKEajQi/lfSDNszI+JGSS+v3C8AAIC+UTLxwuO2F0q6WdKX\n", + "be+RNFS3WwAAAP2j5AzVmyUNS7pY0npJO8UvAAEAAA4rKY586GzUQUmfr9obAACAPnSkiT2H1JrI\n", + "cyIREYuORgdKS0Rkypxky61k4jPlE3qhNEuvqFUCJ1M6QcqNX63YjMx+kS2pkWk78/kWLSo/NJxw\n", + "wgnFsbNnzy6OzZaoyJQCyZQ6OXDgQHFsplxOpr9SvWNcZjvPnz+/SrvZkiGZ+My2yHz/MmM9PDxc\n", + "HCvVK+eUKYGT2d8y45E5Bki5vw/ZtidypHmojmvauO3nSPqspFPVSs7+KCJ+1LRdAACAXtK8GuCR\n", + "/Z2kf4uIt9ieJWlB5fUBAABMu2oJle3jJb02Ii6SpIg4IOmntdYHAADQLXVu/GhZJul/bH/O9h22\n", + "/9F2+UV0AACAPlEzoZol6XRJfx8Rp0t6UtIlFdcHAADQFTXvoXpE0iMRcWt7+WuaIKG64YYbDj9e\n", + "tmyZli9fXrFLAAAAZe677z7df//9RbHVEqqI+Inth22/KCLul/QGSfeMjzv77LNrdQEAAGDKVq1a\n", + "pVWrVh1evu666zrG1v6V35+pVa5mjqQHJb2r8voAAACmXdWEKiLulHRGzXUAAAB0W82b0gEAAJ4V\n", + "al/ym1Tp1P41S8/UKifTC7G9IlPmpGa5gFplJzJlGUZGRqrEZvog5cpO7Nu3rzg2M36ZciTz5s0r\n", + "js2UfJFypU6yZW1KZfa3gYGBVNuZ719mv8jEDg0NTR7UltkW2fJTmfjM8SIzJpnj1nHH5YqWZEo/\n", + "1VLrb1TNEm1Ho23OUAEAADREQgUAANAQCRUAAEBDJFQAAAANkVABAAA0REIFAADQEAkVAABAQyRU\n", + "AAAADZFQAQAANERCBQAA0NAxWXqmV2Smss98vky7Nafqz6hVmiVbYuTgwYNV2s58vlplTrIlODL2\n", + "799fHDs8PFwc+9hjjxXHjo6OFscuWLCgOFbKlQ3JxGb6kfmuZvf7bFmiGu3W+j5lj3GZfTnTdqac\n", + "TK2SNlKuRFOm7Uy7tY73mRJY2bYzZZQ6qXqGyvZHbN9j+27bX7E9t+b6AAAAuqFaQmV7qaR3Szo9\n", + "Il4iaaakt9daHwAAQLfUvOT3M0mjkubbPihpvqRHK64PAACgK6qdoYqI/5P0t5L+S9KPJT0REf9e\n", + "a30AAADdUvOS3wpJfy5pqaSTJB1n+/drrQ8AAKBbal7ye7mkH0bEY5Jk+xuSXiXpy2ODNm7cePjx\n", + "8uXLtWLFiopdAgAAKLNr1y7t2rWrKLZmQnWvpL+0PSBpRNIbJG0eH7RmzZqKXQAAAJiaZcuWadmy\n", + "ZYeXb7rppo6xNe+hulPSFyXdJumu9tOfqbU+AACAbqk6sWdEfELSJ2quAwAAoNsoPQMAANAQCRUA\n", + "AEBDXa/lV6NGX6/Ur8t8tkzto1p1/7Iy/Sit2Sjl6tdlamJJuT5n2s7EZmru1eqDlKs9ltmPMjX3\n", + "Mvt95vNla/kdf/zxxbGZ+meZWmJ79+4tjh0aGiqOlXpjOy9cuLBKu9n6bpl6npn9PvO9zuxDixYt\n", + "Ko6VpLlzyyu8ZeorZrZb5hiQic30QaozfpdddlnH1zhDBQAA0BAJFQAAQEMkVAAAAA2RUAEAADRE\n", + "QgUAANAQCRUAAEBDPZlQPfjgg93uAhrYuXNnt7uAKdqxY0e3u4AGGL/+dccdd3S7C2iIhApHHePX\n", + "v/iD3N/uvffebncBU7Rly5ZudwEN9WRCBQAA0E9IqAAAABpyN8u02O6NGjEAAAAFImLCGmZdTagA\n", + "AACOBVzyAwAAaIiECgAAoKGeS6hsr7V9r+0HbH+42/1BZ7b/yfZu23ePee55tjfavt/2BtvP6WYf\n", + "0ZntJbZvtH2P7W22399+njHscbbn2b7F9lbb221/rP08Y9dHbM+0vcX2t9vLjF8f66mEyvZMSZ+W\n", + "tFbSKZIutP3i7vYKR/A5tcZqrEskbYyIF0m6ob2M3jQq6eKIOFXSmZLe2/6+MYY9LiJGJJ0VES+T\n", + "9FJJZ9l+jRi7frNO0nZJh25mZvz6WE8lVJJeIWlnRDwUEaOSvirpTV3uEzqIiJslPT7u6QskfaH9\n", + "+AuS3jytnUKxiPhJRGxtPx6StEPSyWIM+0JEDLcfzpE0U63vImPXJ2y/QNJ5kj4r6dCvxhi/PtZr\n", + "CdXJkh4es/xI+zn0j8URsbv9eLekxd3sDMrYXirpNEm3iDHsC7Zn2N6q1hjdGBH3iLHrJ5+U9CFJ\n", + "T495jvHrY72WUDGHwzEkWnNyMKY9zvZxkr4uaV1E7B37GmPYuyLi6fYlvxdIWm37rHGvM3Y9yvYb\n", + "Je2JiC36+dmpX8D49Z9eS6gelbRkzPIStc5SoX/stv18SbL9K5L2dLk/OALbs9VKpq6KiGvbTzOG\n", + "fSQifirpOkm/IcauX7xK0gW2d0m6WtJv2r5KjF9f67WE6jZJK20vtT1H0tskfavLfULOtyRd1H58\n", + "kaRrjxCLLrJtSVdK2h4RV4x5iTHscbZPOPQLMNsDktZI2iLGri9ExKURsSQilkl6u6TvRsQ7xPj1\n", + "tZ6bKd32uZKuUOsmyysj4mNd7hI6sH21pNdJOkGt6/2XSfqmpH+W9EJJD0l6a0Q80a0+orP2r8I2\n", + "SbpLP7+08BFJm8UY9jTbL1HrpuUZ7f+uiojLbT9PjF1fsf06SR+IiAsYv/7WcwkVAABAv+m1S34A\n", + "AAB9h4QKAACgIRIqAACAhkioAAAAGiKhAgAAaIiECgAAoCESKgBdZ/sH7f//qu0Lj3Lbl060LgA4\n", + "mpiHCkDPsP16tSY5PD/xnlkRceAIr++NiIVHo38A0AlnqAB0ne2h9sOPS3qt7S2219meYfty25tt\n", + "32n7T9rxr7d9s+1vStrWfu5a27fZ3mb73e3nPi5poN3eVWPX5ZbLbd9t+y7bbx3T9k22/8X2Dttf\n", + "mt6tAaAfzep2BwBAPy9982FJHzx0hqqdQD0REa+wPVfS921vaMeeJunUiPjP9vK7IuLxdm27zba/\n", + "FhGX2H5vRJw2wbp+W9KvS3qppBMl3Wp7U/u1l0k6RdJ/S/qB7VdHBJcKAXTEGSoAvcTjls+R9E7b\n", + "WyT9SNLzJA22X9s8JpmSpHW2t0r6D0lLJK2cZF2vkfSVaNkj6XuSzlAr4docET+O1j0RWyUtbfCZ\n", + "ADwLcIYKQK97X0RsHPtE+16rJ8ctny3pzIgYsX2jpHmTtBt6ZgJ36OzV/jHPHRTHSgCT4AwVgF6y\n", + "V9LYG8i/I+k9tmdJku0X2Z4/wfsWSXq8nUz9mqQzx7w2euj949ws6W3t+7ROlLRa0mY9M8kCgEnx\n", + "ry4AveDQmaE7JR1sX7r7nKRPqXW57Q7blrRH0m+148f+RHm9pD+1vV3SfWpd9jvkM5Lusn17RLzj\n", + "0Psi4l9tv7K9zpD0oYjYY/vF49rWBMsA8AuYNgEAAKAhLvkBAAA0REIFAADQEAkVAABAQyRUAAAA\n", + "DZFQAQAANERCBQAA0BAJFQAAQEMkVAAAAA39PxShDsSnYXpyAAAAAElFTkSuQmCC\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2931,7 +2977,7 @@ "aBwD40TjGBgnGsfAONE4BsaJxjEwTjSOgfl/g7yNWl4b+UcAAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2941,93 +2987,94 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAEnFJREFUeJzt3X2QXXV9x/HPJ5tkN0/EoQnZDSQNLVAeBjGpMoAIUm2H\n", - "MoK2tSJtFWzHTketKVVGZKb9qx2tTEfqOO2MhaLgU1u0qNOC0EoRYyVCNg8QHjvShDzSAiFLks0m\n", - "fPvHvRs2y272fHP2t/fe8H7NMNxz73d/53fP75zDl3PO/X0dEQIAAMDRm9bqDgAAAHQ6EioAAICa\n", - "SKgAAABqIqECAACoiYQKAACgJhIqAACAmqa3cuW2mbMBAAB0jIjwWO8XTahsXyrpJkldkm6OiL8a\n", - "HXPNNde85u/6+/u1fPnyo15vdm6tV1555ZiNzW6LgwcP1u7H448/rtNPP/2w9w4cOFCkD5l2s/FD\n", - "Q0OVYwcHByvH7t+/v0i7WfZrzwnPPfecFi5c+Jr3p08vc6rI7J/79u2rHLt3795UPzLxmfHLxGb2\n", - "t7HGTmpsz7E+mzFjRuW2u7u7K8f29PRUjp05c2bl2K6ursqx422L8ZSae7HuOW5gYEBz586tFDtZ\n", - "/WiX/+60ul2p+n708ssvj/tZsVt+trskfVHSpZLOlHSV7TNKrQ8AAKBVSj5Dda6kpyPimYgYkvRN\n", - "Se8uuD4AAICWKJlQnShp84jlZ5vvTai3t7dIhzA1FixY0Oou4CjNnj271V0AXpcyt0TRnkomVEd9\n", - "s7Ovr28y+4EpRkLVuebMmdPqLqCG7PNEaB8kVJ2v5EPpWyQtGbG8RI2rVIfp7+8/9Lq3t5dkCgAA\n", - "tIWDBw9W/mFAyYTqIUmn2l4maaukKyVdNTqozq/5AAAASunq6jrsV6dH+jVusYQqIg7Y/pik76sx\n", - "bcItEfFYqfUBAAC0StF5qCLiLkl3lVwHAABAq7V0pnRJmjVr1qS3OW1a7ln7zIOcmbYzk9NlJt4r\n", - "1W627cy2yPQjM4lk9vtlJiLMxGb240xsqe2WVeoYycRmxiO7LTL7fSY286BxqYkvpdz4ZbZdph+Z\n", - "djM/jsieAzLbIjOpZqkJX7OT+2a+XyY2M7FnKdk+ZCY5rbqdTznllHE/o5YfAABATSRUAAAANZFQ\n", - "AQAA1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANREQgUAAFATCRUAAEBNJFQAAAA1kVABAADU1PJa\n", - "frt3764Ul6kDla3jVap2Vabu0NDQUOXYTH2pkrWPSvUjIorESuVqMWb2oZI12zIy45fZLzJjkhmP\n", - "zHYrWcOyu7u7cmymz5ntlhk7KVc7LtN2qX1o7969lWMz504p1+dM25lzXKn9Xsrtn5m6oqXOW6Xq\n", - "x0q5Yyq7H42l6BUq20ts32f7UduP2P54yfUBAAC0QukrVEOSro2ItbbnSnrY9r0R8Vjh9QIAAEyZ\n", - "oleoImJ7RKxtvh6Q9JikxSXXCQAAMNWm7KF028skLZf04FStEwAAYCpMSULVvN13h6SVzStVAAAA\n", - "x4ziv/KzPUPStyR9NSLuHP35unXrDr1etGiRent7S3cJAABgQps2bdKmTZsqxRZNqGxb0i2SNkbE\n", - "TWPFnHPOOSW7AAAAcFSWLl2qpUuXHlpetWrVuLGlb/m9VdLvSbrEdn/zn0sLrxMAAGBKFb1CFRE/\n", - "ErOxAwCAYxzJDgAAQE0tLz2Tmfq+qmy5lcHBwWJtt1rjMbYy8ZnYnp6eyrGlyhZIudIF2W3XaTKl\n", - "JDLHaclSElXt27cvFZ8pzVK1XJaUK0mU2cbz5s2rHJuNz5Y6qSpTBiRzTs6OdbZcVVWZckezZ8+u\n", - "HJs5d0rljr9M6aBMbObYy+wXUq6EUbac01i4QgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQ\n", - "EwkVAABATSRUAAAANZFQAQAA1ERCBQAAUBMJFQAAQE0tLz0zMDAw6W12YjmSTDmETPmbbJmFUm1n\n", - "SgBk2s1+v1LbuVRspixDtgRHZkwypSQy5Va6u7srx2ZKomT6IOXOGZNRomIsmT5nv18pmXNnZr/P\n", - "jEemjIuUK/GT2T9LbYuhoaHKsdm2M/tyJjZzni1Z4iuzH01GP8Y9Km3/lqSQNNZaIiK+XWUFtrsk\n", - "PSTp2Yi4/Kh6CQAA0MaO9L85l6uRUI2nUkIlaaWkjZJy1TwBAAA6xLgJVURcU7dx2ydJukzSX0r6\n", - "07rtAQAAtKMJb/ra7rV9i+27m8tn2v6Diu1/XtJ1kqrf1AUAAOgwVZ6i+7KkeyQtbi4/Jenaif7I\n", - "9rsk7YyIfo39HBYAAMAxocpPRRZExD/avl6SImLIdpWf/Fwg6Qrbl0nqkXSc7dsi4oMjgzZs2HDo\n", - "9QknnKBFixZV7z0AAEAhW7du1bZt2yrFVkmoBmz/3PCC7fMk7ZrojyLiBkk3NP/mYkmfHJ1MSdLZ\n", - "Z59dqaMAAABTafHixVq8ePGh5TVr1owbWyWh+oSk70n6Bds/lrRQ0nuPol+5CYMAAAA6xIQJVUQ8\n", - "bPsiSb+kxrNQT0REaqaxiLhf0v1H10UAAID2NmFCZXuWpI9IulCNq0wP2P67iMhNywwAAHCMqnLL\n", - "7zZJL0n6ghpXqH5H0u2SfrtgvwAAADpGlYTqrIg4c8TyD2xvnLQOFKhJla3JU6qWUKbdTB2oTE2z\n", - "TLtSrs/tsN1Kaof6ipnjIzvWM2bMKBKb+X6Dg4NFYnfv3l05VsrVS8vUNCtV1zB7jGTGpFStwozM\n", - "vpypdynlal5mtkVmn8vUsN2zZ0/lWKk99uV2iJVyx1QmdjxV9to1ts8fXmj+yu/h2msGAAA4Rhyp\n", - "OPKGETGrbG9W4xmqpZKemIK+AQAAdISJiiMDAABgAkcqjvzMyGXbJ6gx4zkAAABGqFIc+QrbT0n6\n", - "mRpzST0j6a7C/QIAAOgYVR5K/wtJ50t6MiJOlvQOSQ8W7RUAAEAHqZJQDUXE/0qaZrsrIu6T9ObC\n", - "/QIAAOgYVSZ1eMH2PEkPSPqa7Z2Sqk+iAQAAcIyrcoXqPZL2SLpW0t2Snha/AAQAADikSnHk4atR\n", - "ByV9uWhvAAAAOtCRJvYcUGMiz7FERBw3GR2oWkYlU9ojK1OWoVQJh0y72VILGSW3c1WlxkPKjUkm\n", - "NrPdDhw4UKTdbOmZrq6uyrGZ0jMZmW2R2e8z7Uq5sjalxq9dZL5fJjazf5YsgZUpX5I5RkqVzMqU\n", - "GsvKfL/MvpyJzZTKyR5Ppfbl8RxpHqq5dRu3/QZJN0s6S43k7Pcj4id12wUAAGgnk1+Z+HB/I+nf\n", - "IuK9tqdLmlN4fQAAAFOuWEJle76kt0XE1ZIUEQck7Sq1PgAAgFbJPXSRc7Kk52zfanuN7b+3Pbvg\n", - "+gAAAFqiZEI1XdIKSX8bESskvSzp+oLrAwAAaImSz1A9K+nZiPhpc/kOjZFQrVmz5tDrvr4+9fX1\n", - "FewSAABANbt27dKuXdWeViqWUEXEdtubbZ8WEU9KeqekR0fHrVixolQXAAAAjtr8+fM1f/78Q8ub\n", - "N28eN7b0r/z+WI1yNTMl/bekDxVeHwAAwJQrmlBFxDpJbym5DgAAgFYr+VA6AADA60LpW34TypbL\n", - "qCJTMkTKlS8pVUoiU7agVAmHbNul2s2UhihZbqXUfrFv377Kse1S5iSznbu7uyvHzplTfa7fnp6e\n", - "yrHZUjmZ8h6Z7VyqpE225FKpfblkmaiqSpV8ybad2Ycy+2epc7JUbr8o9d+okuf7qlatWjXuZ1yh\n", - "AgAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioAAICaSKgAAABqIqECAACoiYQK\n", - "AACgppaXnhkaGqoU1w7lYaTcNPmlptTPTKefLcuQKfuSKZ9QogRAaaVKZcydO7dybKacRcltXPU4\n", - "laT9+/cXaXdgYKBy7KxZsyrHSrmxzozJvHnzivQhW14rc07MxGbGL1Nyac+ePZVjMyV7sm1ntkXm\n", - "fJiJzZRcknKln0qV+crsn6XOLdm2M7HjKXqFyvanbT9qe4Ptr9uuPtIAAAAdolhCZXuZpA9LWhER\n", - "Z0vqkvT+UusDAABolZK3/F6SNCRptu2DkmZL2lJwfQAAAC1R7ApVRDwv6a8lbZK0VdKLEfHvpdYH\n", - "AADQKiVv+f2ipD+RtEzSYklzbf9uqfUBAAC0Sslbfm+W9OOI+D9Jsv1tSRdI+trIoP7+/kOve3t7\n", - "1dfXV7BLAAAA1Wzfvl3bt2+vFFsyoXpc0p/ZniVpn6R3Slo9Omj58uUFuwAAAHB0ent71dvbe2h5\n", - "/fr148aWfIZqnaTbJD0kabgHXyq1PgAAgFYpOrFnRHxO0udKrgMAAKDVKD0DAABQEwkVAABATS2v\n", - "5ZetNVdFpj5RVqaeUYnvlm03W48uUyspE5upiVWybmOm7cx2LlVHr1StrWx8ZjtnaquV2i8GBwcr\n", - "x0q52mqZMdm7d2/l2F27dlWOfemllyrHSrntka2NV1WmxlymFmN2v88cq6WO60ytu0wNRCk3fu1w\n", - "Ds/EZscjE5/ZP8fDFSoAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAamrLhGrbtm2t\n", - "7gJqYPw615YtW1rdBdTw/PPPt7oLOEo7duxodRdQU1smVFUrO6M9kVB1rq1bt7a6C6iBhKpz7dy5\n", - "s9VdQE1tmVABAAB0EhIqAACAmpwtTTKpK7dbt3IAAICkiBizLllLEyoAAIBjAbf8AAAAaiKhAgAA\n", - "qKntEirbl9p+3PZTtj/V6v5gfLb/wfYO2xtGvHe87XttP2n7HttvaGUfMT7bS2zfZ/tR24/Y/njz\n", - "fcawzdnusf2g7bW2N9r+TPN9xq6D2O6y3W/7e81lxq+DtVVCZbtL0hclXSrpTElX2T6jtb3CEdyq\n", - "xliNdL2keyPiNEn/0VxGexqSdG1EnCXpPEkfbR5vjGGbi4h9ki6JiDdJeqOkS2xfKMau06yUtFHS\n", - "8MPMjF8Ha6uEStK5kp6OiGciYkjSNyW9u8V9wjgi4gFJL4x6+wpJX2m+/oqk90xpp1BZRGyPiLXN\n", - "1wOSHpN0ohjDjhARe5ovZ0rqUuNYZOw6hO2TJF0m6WZJw78aY/w6WLslVCdK2jxi+dnme+gciyJi\n", - "uIbCDkmLWtkZVGN7maTlkh4UY9gRbE+zvVaNMbovIh4VY9dJPi/pOkmvjHiP8etg7ZZQMYfDMSQa\n", - "c3Iwpm3O9lxJ35K0MiJ2j/yMMWxfEfFK85bfSZIusn3JqM8ZuzZl+12SdkZEv169OnUYxq/ztFtC\n", - "tUXSkhHLS9S4SoXOscN2ryTZ7pNEgao2ZnuGGsnU7RFxZ/NtxrCDRMQuSf8q6ZfF2HWKCyRdYftn\n", - "kr4h6Vds3y7Gr6O1W0L1kKRTbS+zPVPSlZK+2+I+Iee7kq5uvr5a0p1HiEUL2bakWyRtjIibRnzE\n", - "GLY52wuGfwFme5akX5XUL8auI0TEDRGxJCJOlvR+ST+IiA+I8etobTdTuu1fl3STGg9Z3hIRn2lx\n", - "lzAO29+QdLGkBWrc7/9zSd+R9E+Slkp6RtL7IuLFVvUR42v+KuyHktbr1VsLn5a0WoxhW7N9thoP\n", - "LU9r/nN7RNxo+3gxdh3F9sWSPhERVzB+na3tEioAAIBO0263/AAAADoOCRUAAEBNJFQAAAA1kVAB\n", - "AADUREIFAABQEwkVAABATSRUAFrO9qrmv3/e9lWT3PYNY60LACYT81ABaBu2367GJIeXJ/5mekQc\n", - "OMLnuyNi3mT0DwDGwxUqAC1ne6D58rOS3ma73/ZK29Ns32h7te11tv+wGf922w/Y/o6kR5rv3Wn7\n", - "IduP2P5w873PSprVbO/2ketyw422N9heb/t9I9r+T9v/bPsx21+d2q0BoBNNb3UHAECvlr75lKRP\n", - "Dl+haiZQL0bEuba7Jf3I9j3N2OWSzoqI/2kufygiXmjWtltt+46IuN72RyNi+Rjr+k1J50h6o6SF\n", - "kn5q+4fNz94k6UxJ2yStsv3WiOBWIYBxcYUKQDvxqOVfk/RB2/2SfiLpeEmnND9bPSKZkqSVttdK\n", - "+i9JSySdOsG6LpT09WjYKel+SW9RI+FaHRFbo/FMxFpJy2p8JwCvA1yhAtDuPhYR9458o/ms1cuj\n", - "lt8h6byI2Gf7Pkk9E7Qbem0CN3z1anDEewfFuRLABLhCBaCd7JY08gHy70v6iO3pkmT7NNuzx/i7\n", - "4yS90EymTpd03ojPhob/fpQHJF3ZfE5roaSLJK3Wa5MsAJgQ/9cFoB0MXxlaJ+lg89bdrZK+oMbt\n", - "tjW2LWmnpN9oxo/8ifLdkv7I9kZJT6hx22/YlyStt/1wRHxg+O8i4l9sn99cZ0i6LiJ22j5jVNsa\n", - "YxkADsO0CQAAADVxyw8AAKAmEioAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAaiKh\n", - "AgAAqOn/AVxVFcygFE4dAAAAAElFTkSuQmCC\n" + "AAALEgAACxIB0t1+/AAAEptJREFUeJzt3X2QXfVdx/HPJ89PJExMFrJJaqKCQobaRGCAUii2OsgU\n", + "WrWWorZYmTpOWxuxZUqZ0b90Wttxip2OzlSQFvqk0grtKBS0QCm1hJAEQkIDOETJ4xKEkMfNZvfr\n", + "H/du2Cy72fPNyW/vveH9mslwz7nfe85vz+/cc7+ch9/XESEAAAAcvwmtbgAAAECnI6ECAACoiYQK\n", + "AACgJhIqAACAmkioAAAAaiKhAgAAqGlSK1dumzEbAABAx4gIjzS/aEJl+3JJN0uaKOmWiPjr4THX\n", + "XXfd6z63Zs0arVix4qh5AwMDhVqZW3Z/f3+R2IxMe7PjjGXiR4vdsGGDli1bdtS8zLbI/H2HDx+u\n", + "HJuN7+3trRx78ODBIrGHDh2qHHsiviMvvvii5s+f/7r5EydOrLwMe8RjzYgybd6/f3/l2Mw2zi47\n", + "s19k9rfMd2TChJEvLgwMDIz43qRJ1Q/1U6dOrRw7ZcqUyrGTJ0+uHDva31c3NitzPMz030j7xb59\n", + "+zRz5sxKsdllj6bUcbnkb1QpVfejYx2Ti+2JtidK+pKkyyWdLeka22eVWh8AAECrlLyH6nxJz0XE\n", + "5ojok/QtSe8uuD4AAICWKJlQLZT0wpDpLc15Y1qwYEGRBmF8jHTJCJ1hxowZrW4CashcbkV7yVwS\n", + "RXsqmVAd94VREqrO1tXV1eom4DiNdA8HOgcJVefK3I+G9lTypvStkhYPmV6sxlmqo6xZs+bI6wUL\n", + "FpBMAQCAtjAwMFD5JvuSCdVqSWfYXiJpm6SrJV0zPGj403wAAADtYMKECUc9AXisp/yKJVQRcdj2\n", + "xyR9X41hE26NiKdLrQ8AAKBVio5DFRH3SLqn5DoAAABaraUjpUvVB5wrOdBbJj5z02dmMMRSsdlt\n", + "UWrZmeVmBiHMPhmTGbRw2rRpRWIzbcj8fdmbWksNypiJzewXme2WVWpw38xyS+73mb7O7MuZ5Wae\n", + "IJ09e3bl2Mx2k3IDSfb19VWOLTW474EDByrHSrnfqFK/q5k+ycRmjhdS7rtatU8WLhx9sAJq+QEA\n", + "ANREQgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQEwkVAABATSRUAAAANZFQAQAA1ERCBQAA\n", + "UBMJFQAAQE0tr+V36NChSnHZmnSlZOoklVpuphZVqfa2i8y2yOq0uo3ZOlcZmZp0GaXqg2W3Raav\n", + "MzUFM7GZNmRqlEnS4cOHK8dm+rpUXbx9+/ZVjq36GzIosy0ysZk+yezLmRqI2fhMbGZfznz/Sv5G\n", + "Zfokux+NpGiWYnux7Qdsb7D9lO2Pl1wfAABAK5Q+Q9Un6fqIWGd7lqTHbd8fEU8XXi8AAMC4KXqG\n", + "KiJ2RMS65uu9kp6W1F1ynQAAAONt3G5Msr1E0nJJj47XOgEAAMbDuCRUzct9d0pa2TxTBQAAcNIo\n", + "/pSf7cmSvi3paxFx1/D3165de+T16aefrgULFpRuEgAAwJief/55bd68uVJs0YTKjechb5W0MSJu\n", + "Hilm+fLlJZsAAABwXJYuXaqlS5cemX7wwQdHjS19ye+tkn5f0mW21zb/XV54nQAAAOOq6BmqiPiR\n", + "GI0dAACc5Eh2AAAAamp56ZmS5TI6SaaEQ6nYrEyJilKlCEqWGClV9iVTbqVkWYZMO0r1X6ltkSkZ\n", + "IuW+J5llZ8qtZMqAzJ49u3KsVK4ETqZcRyb24MGDlWMPHDhQOTYrs9/PnDmzcuzcuXMrx86ZM6dy\n", + "rJT7TmX2z1dffbVy7N691R/mz5QZyuwXktTb21s5NrMtRsMZKgAAgJpIqAAAAGoioQIAAKiJhAoA\n", + "AKAmEioAAICaSKgAAABqIqECAACoiYQKAACgJhIqAACAmkioAAAAamp56ZlJk6o1IVPmpGS5lYxM\n", + "m0vFZpXadv39/ZVjS5Zbyfx9mTZnypFk+i9TriNTZkHKlVooVWYoE1v1WHE8Mu3I7BeZMiBTpkwp\n", + "EltSZluU2oeyZXgyJWIyJXsyJXC2bt1aOTZTmkXKHTNK/a5m+m/y5MmVY7PHgPEubTdq62z/tqSQ\n", + "NNKvW0TEd6qswPZESaslbYmIK4+rlQAAAG3sWOnelWokVKOplFBJWilpo6RTqjYKAACgk4yaUEXE\n", + "H9RduO1Fkq6Q9FeS/qzu8gAAANrRmBf4bZ9u+1bb9zanz7Z9XcXlf0HSDZLK3fQDAADQYlXumPyK\n", + "pPskdTenn5V0/Vgfsv0uST0RsVYj34cFAABwUqhyy/y8iPgn2zdKUkT02a7ySNNFkq6yfYWkaZJm\n", + "2749Ij44NOixxx478rq7u1sLFy6s3noAAIBCtmzZUvmpzCoJ1V7bPzM4YfsCSbvH+lBE3CTppuZn\n", + "LpX0yeHJlCSdd955lRoKAAAwnhYtWqRFixYdmR56Emi4KgnVJyR9T9LP2f6xpPmS3nsc7WqPwaEA\n", + "AABOsDETqoh43PYlkn5RjXuhNkVE9REBG8t4SNJDx9dEAACA9jZmQmV7uqSPSLpYjbNMD9v++4g4\n", + "WLpxAAAAnaDKJb/bJb0q6YtqnKH6XUl3SPqdgu0CAADoGFUSqmURcfaQ6R/Y3niiGnDwYLUTXSXr\n", + "82WWXSo2U7+uVGzJZZfqv2xdw1I1E0v19SmnVC8wcOqpp1aOlXJ15jKxmVpi+/fvLxJb9bgyKFOT\n", + "LqNUTbOszP6ZqUuZkdmHMt+97du3p9qR6evMdiu1f2b7o9SxKFNHr9SxJRMr5dp8IupjVmndGtsX\n", + "Dk40n/J7vPaaAQAAThLHKo68fkjMI7ZfUOMeqjdJ2jQObQMAAOgIYxVHBgAAwBiOVRx589Bp211q\n", + "jHgOAACAIaoUR77K9rOSnldjLKnNku4p3C4AAICOUeWm9L+UdKGkZyJiqaR3SHq0aKsAAAA6SJWE\n", + "qi8idkmaYHtiRDwg6dzC7QIAAOgYVQZpeNn2KZIelvR12z2S9pZtFgAAQOeocobqPZL2S7pe0r2S\n", + "nhNPAAIAABxRpTjy4NmofklfKdoaAACADnSsgT33qjGQ50giImafiAZUHe69ZLmVjFIlVNqh/E02\n", + "PlMeolSZmmwpgoxSZUNKbeNsuZV2KI2UKfeQic3uF5ltl4nt7e0tstxMeR+p3DEjs52nTp1aOTZT\n", + "MiQTK+XanNkW06dPrxxbar+QcvtG5vhSqk8y+0W2PEwmftq0+qNCHWscqll1F277VEm3SFqmRnL2\n", + "hxHxk7rLBQAAaCe51D7vbyX9e0S81/YkSTMLrw8AAGDcFUuobM+R9LaIuFaSIuKwpN2l1gcAANAq\n", + "5W5AkZZKetH2bbbX2P4H2zMKrg8AAKAlSiZUkyStkPR3EbFC0j5JNxZcHwAAQEuUvIdqi6QtEfFY\n", + "c/pOjZBQrV69+sjr7u5udXd3F2wSAABANbt27dKuXbsqxRZLqCJih+0XbJ8ZEc9IeqekDcPjzj2X\n", + "KjYAAKD9zJs3T/PmzTsyvWnTplFjSz/l9ydqlKuZIum/JX2o8PoAAADGXdGEKiKekHReyXUAAAC0\n", + "Wsmb0gEAAN4QSl/yG9OBAwcqxWXKWWTLTpQqVVOqLEqpMi7tIlO2IFPyRcqVkym1X2TKTmRLjGT0\n", + "9/cXWW6mT2bMqD6SSqY0RKacRTY+s1/09fWl2lFKpq8zbc6URTl8+HDl2IzscTYTn4nNlDnJHrdK\n", + "KfX7kDnOlorNxlft67vvvnv0ZVReGwAAAEZEQgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQ\n", + "EwkVAABATSRUAAAANZFQAQAA1ERCBQAAUFPLS89ULUeQKQEwMDCQakOmlEQmNtOOUmVqSsqUiMnI\n", + "lEPIlL6Qyu5HVWVKqMyZM6dybHYfyvx9mRI4mdj9+/dXjt29e3fl2OnTp1eOlXIlcDLLnjlzZuXY\n", + "THmYbEmiTDmZUiWJMqVnMn9ftkRUZtmZY1HmeJgpiZIto5Qpa5Mpl5NpR2Z/27t3b+XYffv2VY7N\n", + "tuNElIkq+itu+9O2N9heb/sbtnN7BgAAQAcollDZXiLpw5JWRMQ5kiZKen+p9QEAALRKyUt+r0rq\n", + "kzTDdr+kGZK2FlwfAABASxQ7QxUR/yfpbyT9r6Rtkl6JiP8otT4AAIBWKXnJ7+cl/amkJZK6Jc2y\n", + "/Xul1gcAANAqJS/5nSvpxxHxkiTZ/o6kiyR9fWjQ+vXrj7zu6urSaaedVrBJAAAA1fT09Kinp6dS\n", + "bMmE6qeS/tz2dEkHJb1T0qrhQeecc07BJgAAAByfrq4udXV1HZnesGHDqLEl76F6QtLtklZLerI5\n", + "+8ul1gcAANAqRQf2jIjPSfpcyXUAAAC0WucNzw0AANBmSKgAAABqanktv6q1rjI1lUrVYMPRMtu5\n", + "VJ9kl5upU5apjZepzZWpJZapf5at5Zep+ZVZdqnlZmroZfpDytU0yxyLdu7cWTk2U6twz549lWOl\n", + "cvX5MvXdMjUsM8vN1vPM9F+2TmBVpertSbmagr29vZVjM3X02qF2pJQ7vsyaNav++movAQAA4A2O\n", + "hAoAAKAmEioAAICaSKgAAABqIqECAACoiYQKAACgprZMqLZt29bqJqCG7du3t7oJOE5btmxpdRNQ\n", + "w65du1rdBBwnjpudry0TKnaszkb/da6tW7e2ugmo4aWXXmp1E3CcduzY0eomoKa2TKgAAAA6CQkV\n", + "AABATc4Mw3/CV263buUAAABJETFiTaKWJlQAAAAnAy75AQAA1ERCBQAAUFPbJVS2L7f9U9vP2v5U\n", + "q9uD0dn+R9s7ba8fMm+u7fttP2P7PtuntrKNGJ3txbYfsL3B9lO2P96cTx+2OdvTbD9qe53tjbY/\n", + "05xP33UQ2xNtr7X9veY0/dfB2iqhsj1R0pckXS7pbEnX2D6rta3CMdymRl8NdaOk+yPiTEn/2ZxG\n", + "e+qTdH1ELJN0gaSPNr9v9GGbi4iDki6LiLdIerOky2xfLPqu06yUtFHS4M3M9F8Ha6uEStL5kp6L\n", + "iM0R0SfpW5Le3eI2YRQR8bCkl4fNvkrSV5uvvyrpPePaKFQWETsiYl3z9V5JT0taKPqwI0TE/ubL\n", + "KZImqvFdpO86hO1Fkq6QdIukwafG6L8O1m4J1UJJLwyZ3tKch85xWkTsbL7eKem0VjYG1dheImm5\n", + "pEdFH3YE2xNsr1Ojjx6IiA2i7zrJFyTdIGlgyDz6r4O1W0LFGA4nkWiMyUGftjnbsyR9W9LKiNgz\n", + "9D36sH1FxEDzkt8iSZfYvmzY+/Rdm7L9Lkk9EbFWr52dOgr913naLaHaKmnxkOnFapylQufYaft0\n", + "SbK9QFJPi9uDY7A9WY1k6o6IuKs5mz7sIBGxW9K/SfoV0Xed4iJJV9l+XtI3Jf2q7TtE/3W0dkuo\n", + "Vks6w/YS21MkXS3puy1uE3K+K+na5utrJd11jFi0kG1LulXSxoi4echb9GGbsz1v8Akw29Ml/Zqk\n", + "taLvOkJE3BQRiyNiqaT3S/pBRHxA9F9Ha7uR0m3/hqSb1bjJ8taI+EyLm4RR2P6mpEslzVPjev9f\n", + "SLpb0j9LepOkzZLeFxGvtKqNGF3zqbAfSnpSr11a+LSkVaIP25rtc9S4aXlC898dEfF523NF33UU\n", + "25dK+kREXEX/dba2S6gAAAA6Tbtd8gMAAOg4JFQAAAA1kVABAADUREIFAABQEwkVAABATSRUAAAA\n", + "NZFQAWg52480//uztq85wcu+aaR1AcCJxDhUANqG7berMcjhlYnPTIqIw8d4f09EnHIi2gcAo+EM\n", + "FYCWs723+fKzkt5me63tlbYn2P687VW2n7D9R834t9t+2Pbdkp5qzrvL9mrbT9n+cHPeZyVNby7v\n", + "jqHrcsPnba+3/aTt9w1Z9oO2/8X207a/Nr5bA0AnmtTqBgCAXit98ylJnxw8Q9VMoF6JiPNtT5X0\n", + "I9v3NWOXS1oWEf/TnP5QRLzcrG23yvadEXGj7Y9GxPIR1vVbkn5Z0pslzZf0mO0fNt97i6SzJW2X\n", + "9Ijtt0YElwoBjIozVADaiYdN/7qkD9peK+knkuZK+oXme6uGJFOStNL2Okn/JWmxpDPGWNfFkr4R\n", + "DT2SHpJ0nhoJ16qI2BaNeyLWSVpS428C8AbAGSoA7e5jEXH/0BnNe632DZt+h6QLIuKg7QckTRtj\n", + "uaHXJ3CDZ696h8zrF8dKAGPgDBWAdrJH0tAbyL8v6SO2J0mS7TNtzxjhc7MlvdxMpn5J0gVD3usb\n", + "/PwwD0u6unmf1nxJl0hapdcnWQAwJv6vC0A7GDwz9ISk/ualu9skfVGNy21rbFtSj6TfbMYPfUT5\n", + "Xkl/bHujpE1qXPYb9GVJT9p+PCI+MPi5iPhX2xc21xmSboiIHttnDVu2RpgGgKMwbAIAAEBNXPID\n", + "AACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJpIqAAAAGr6f7xE4rRkFyo0\n", + "AAAAAElFTkSuQmCC\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -3152,7 +3199,7 @@ "SUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -3162,96 +3209,95 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAExNJREFUeJzt3X+QXWV9x/HPJwm7m80PIj8qJBsb28YijNZYYYI/Q7Ud\n", - "6ija1qq0FWs7djpqSakyIjPtjDPtaHU6UsdpZ6zUH/irrVrUaUVpJQpICIH8AAIaO6QlWhIaYsLu\n", - "ZpNN+PaPexOXZTf7fHPy7L03vF8zDPfc+73PefY85577zTnnPl9HhAAAAHDi5nS6AwAAAL2OhAoA\n", - "AKAhEioAAICGSKgAAAAaIqECAABoiIQKAACgoXmdXLlt5mwAAAA9IyI81fNVEyrbl0q6TtJcSZ+I\n", - "iL+eHLN27dqnvG/9+vVavXr15LYq9VJ64oknimMz83bVis2oud2m6/OGDRt00UUXPem5I0eOFLeb\n", - "GY9Mu9n4w4cPF8eOj48Xx46NjVWJnTMnd8K5r6/vKc89+OCDOu+884piT0Y/MmO9b9++KrHZ+JGR\n", - "keLYAwcOFMeejLEeGxvTwMDAU57v7+8vbnvBggVVYufPn18cO29eR/+tf0zmuHzw4MHi2KnG+tFH\n", - "H9XZZ59dFHuy+nHo0KEqsZnjYa3vhmz8yfgOrnbJz/ZcSR+TdKmk8yVdbvu5tdYHAADQKTXvobpI\n", - "0g8jYkdEjEv6oqTXVVwfAABAR9RMqJZJenjC8s72czMaGhqq0iHMjmXLioYZXeiss87qdBfQQLdc\n", - "KkPe4OBgp7uAhmomVCd8QZKEqreRUPUuEqreRkLVuzL3o6E71fz0/UjS8gnLy9U6S/Uk69evP/Z4\n", - "aGiIZAoAAPScmgnVRkkrba+Q9GNJb5J0+eSgyb/mAwAA6DXVEqqIOGz7XZK+qda0CddHxAO11gcA\n", - "ANApVS+4R8Q3JH2j5joAAAA6reN3ME41Cd1UMhN0ZSZklHITEXbDZJ01+5CZZC0Tm5norVsm9szI\n", - "TKBaus9n281M6CdJe/bsKY4dHR0tju2GiUuz+30mfu7cucWxCxcuLI5dsmRJcWxW5jOV2c6ZfS5z\n", - "XK45CWjm78scLzL7UKbPmeOFlNvnMvty5liU+ftq9SGrdP/cuHHjtK9Ryw8AAKAhEioAAICGSKgA\n", - "AAAaIqECAABoiIQKAACgIRIqAACAhkioAAAAGiKhAgAAaIiECgAAoCESKgAAgIZIqAAAABrqeC2/\n", - "3bt3F8X19fUVt3naaael+pCJz8Rm6g5l6kBlamJla9dl2s7U5+uGun9Sbjtnxi9THyxT5yoT29/f\n", - "XxybbTuz3w8ODhbH1qoxl6kPJtWr5ZfZxpnP3qFDh4pjJenAgQNV2s7UYhwZGSmOLf1ekPLbotYx\n", - "LrMvZ/ah7PdZ5jiQqZmY+Q6udTzMqvW9Op2qZ6hsL7d9i+37bd9n+8qa6wMAAOiE2meoxiVdFRGb\n", - "bS+UdLftmyPigcrrBQAAmDVVz1BFxCMRsbn9eFjSA5KW1lwnAADAbJu1m9Jtr5C0StKds7VOAACA\n", - "2TArCVX7ct+XJK1tn6kCAAA4ZVT/lZ/t0yR9WdJnI+LGya9v2rTp2ONzzjlH5557bu0uAQAAzGhs\n", - "bKz416xVEyq3fnd+vaRtEXHdVDGrVq2q2QUAAIATMjAwoIGBgWPL+/btmza29iW/l0j6PUmX2N7U\n", - "/u/SyusEAACYVVXPUEXEbWI2dgAAcIoj2QEAAGio46Vnli4tm5YqM61/Zrr5bHymhEq2H6Vqlb6Q\n", - "cqUIMqVZapX3yZZlyGy7TGytMkO12s22nYnthu2WKXMi5UqoZEpUZPbPRYsWFceeccYZxbGStHDh\n", - "wuLYTImRzHE5s92Gh8t/DL5///7i2Gw/Msf7zHbLjHVm7LL9yHxWM9sis40zn72DBw8Wx0rS6Ojo\n", - "SW/76quvnvY1zlABAAA0REIFAADQEAkVAABAQyRUAAAADZFQAQAANERCBQAA0BAJFQAAQEMkVAAA\n", - "AA2RUAEAADREQgUAANCQa5VHKVq5HVdeeWVR7Jw55blfZjp9KVceolZZjYxapUuken9fpt1M6YRM\n", - "bDY+U7Ynsw/19/cXx2Zkyj1k4zOfv0ypjNNPP704dsmSJcWxAwMDxbFSbvwOHTpUHJv5jGT6nCkR\n", - "JeVKxNSKHR8fL47NHOMWL15cHCvlyr5kt3OpTLmVTKyU23a1YjPH+5qlxmoc720rIqb8YE/bgu3f\n", - "khSSpnpjRMRXClc+V9JGSTsj4rUl7wEAAOglx0vJXqtWQjWdooRK0lpJ2ySV/7MAAACgh0ybUEXE\n", - "7zdt3PaQpFdL+itJf9a0PQAAgG40440Rts+xfb3tm9rL59v+w8L2PyLpaknlF9oBAAB6TMmdpp+S\n", - "9C1JS9vL2yVdNdObbL9G0u6I2KSp78MCAAA4JZTc1n5WRPyT7WskKSLGbZf8POjFki6z/WpJA5IW\n", - "2/5MRFwxMWj9+vXHHg8NDWloaKi89wAAAJWsW7dO69atK4otSaiGbZ95dMH2akn7ZnpTRFwr6dr2\n", - "e14h6T2TkylJWr16dVFHAQAAZtOaNWu0Zs2aY8vvf//7p40tSajeLenrkn7O9vcknS3pDSfQr85N\n", - "eAUAAFDRjAlVRNxt++WSflGte6G+HxHlM7S12viOpO+cWBcBAAC624wJle35kt4h6aVqnWW61fbf\n", - "R0Ru+lYAAIBTVMklv89I2i/po2qdofodSTdI+u2K/QIAAOgZJQnVBRFx/oTlb9vedrI6UFrzJ1NH\n", - "6MiRI6k+ZONryNT8ytRVy9byq1V/sNf6IOXqlNXah2rVmZRyteMGBweLYx977LHi2IMHDxbHZmrB\n", - "jYyMFMdm285s50wtuEyNuUydSaneMSPTj1qxmc9pNj7zud6zZ09x7P79+4tjR0dHi2OlXK3JjFrH\n", - "i0zsggULimOz8Zl+TKfkU3aP7YuPLrR/5Xd34zUDAACcIo5XHPneCTG3235YrXuoniXp+7PQNwAA\n", - "gJ4wU3FkAAAAzOB4xZF3TFy2/TNqzXgOAACACUqKI19me7ukh9SaS2qHpG9U7hcAAEDPKLkp/S8l\n", - "XSzpBxHxbEmvlHRn1V4BAAD0kJKEajwi/k/SHNtzI+IWSS+q3C8AAICeUTLZx17biyTdKulztndL\n", - "Gq7bLQAAgN5Rcobq9ZJGJV0l6SZJPxS/AAQAADimpDjy0bNRRyR9qmpvAAAAetDxJvYcVmsiz6lE\n", - "RCw+GR0YG+t8jeVMWZtM2YJa7XaLWiViam63TCmJTGymdEkmNtOHzHaTcuU9+vv7i2Mz+0VmW2TK\n", - "1GTLb2RK1dQav8OHD1eJzcockzPbIiOzD2VLLmXKOfX19RXHZsr7ZGT35Ux8zf2oVGb8siWXMvGZ\n", - "/WLa9U33QkQsbNq47SWSPiHpArWSsz+IiPVN2wUAAOgmuXQv728l/XtEvMH2PEm5yoYAAAA9oFpC\n", - "Zft0SS+LiLdKUkQclrSv1voAAAA6pc5F35ZnS3rU9idt32P7H2wPVlwfAABAR9RMqOZJeqGkv4uI\n", - "F0oakXRNxfUBAAB0RM17qHZK2hkRd7WXv6QpEqq77rrr2OOlS5dq2bJlFbsEAABQ5vHHH9fwcNlc\n", - "5tUSqoh4xPbDtp8TET+Q9CpJ90+Ou/DCC2t1AQAA4IQtWrRIixYtOra8a9euaWNr/8rvT9QqV9Mn\n", - "6b8kva3y+gAAAGZd1YQqIrZI4hQUAAA4pdW8KR0AAOBpofYlvxkNDAwUxWVKOGTLkWRKdmSmyc+U\n", - "T8jEZqbTz5ZlqNV2JjZTAiBTEkXK/X2ZMcnsQ5kyJ5nSENnSM7XGZHCwfHaUZzzjGcWxE+9jmMn8\n", - "+fOLY7PxmWPR6OhocWxmrDN9yKp1rM3EZsq4ZI9xGZljQOYzkulztqRNZjvXKplVq0Rbzf2+tB9X\n", - "XHHFtK9xhgoAAKAhEioAAICGSKgAAAAaIqECAABoiIQKAACgIRIqAACAhkioAAAAGiKhAgAAaIiE\n", - "CgAAoCESKgAAgIY6XnomWy7jVJUtL1Aqu30z8bVK62RKHBw8eLA4VsqVLqhVgqNWGZe+vr7i2KxM\n", - "WZQ9e/YUxz7yyCNV+rB48eLiWElasGBBcWxmTDIlbWqWUMnIlGfK7PcHDhyoEpvZLyRpeHi4Stu1\n", - "9ouFCxcWx0q5Ek2lpd+kXJ8z221sbKxKu1Lu+yGzz02n6hkq2++zfb/te21/3nau8BoAAEAPqJZQ\n", - "2V4h6e2SXhgRz5M0V9Kba60PAACgU2pe8tsvaVzSoO0jkgYl/aji+gAAADqi2hmqiHhM0t9I+h9J\n", - "P5b0k4j4j1rrAwAA6JSal/x+XtKfSlohaamkhbZ/t9b6AAAAOqXmJb8XSfpeROyRJNtfkfRiSZ+b\n", - "GHTHHXccezw0NKTly5dX7BIAAECZ7du3a/v27UWxNROqByX9ue35ksYkvUrShslBF198ccUuAAAA\n", - "nJiVK1dq5cqVx5ZvuummaWNr3kO1RdJnJG2UtLX99MdrrQ8AAKBTqk7sGREfkvShmusAAADoNErP\n", - "AAAANERCBQAA0FDHa/mV1njL1D/L1I2TcjW0MjX3arWb/ftqqVV/sGYfMvXuMrG16nhl2s3EZuMz\n", - "+1ymvltm/DLjka3ld+aZZ1Zp+9ChQ8Wxe/fuLY7N1EuUcjXNMjUs+/vLq4llaswtWbKkODZ7DMjU\n", - "KszEZo73teqgSrnaeCMjI8WxmTp6mXqs2fp8GZl9I5NjTLu+xi0AAAA8zZFQAQAANERCBQAA0BAJ\n", - "FQAAQEMkVAAAAA2RUAEAADTUlQnVww8/3OkuoIGHHnqo013ACdqyZUunu4AG7rnnnk53ASfotttu\n", - "63QX0FBXJlQ7d+7sdBfQwI4dOzrdBZygrVu3zhyErrVp06ZOdwEn6Pbbb+90F9BQVyZUAAAAvYSE\n", - "CgAAoCFHROdWbndu5QAAAEkRMWU9oI4mVAAAAKcCLvkBAAA0REIFAADQUNclVLYvtf2g7e2239vp\n", - "/mB6tv/R9i7b90547gzbN9v+ge1v2V7SyT5ieraX277F9v2277N9Zft5xrDL2R6wfaftzba32f5A\n", - "+3nGrofYnmt7k+2vt5cZvx7WVQmV7bmSPibpUknnS7rc9nM72yscxyfVGquJrpF0c0Q8R9J/tpfR\n", - "ncYlXRURF0haLemd7c8bY9jlImJM0iUR8QJJz5d0ie2XirHrNWslbZN09GZmxq+HdVVCJekiST+M\n", - "iB0RMS7pi5Je1+E+YRoRcaukvZOevkzSp9uPPy3p9bPaKRSLiEciYnP78bCkByQtE2PYEyJitP2w\n", - "T9JctT6LjF2PsD0k6dWSPiHp6K/GGL8e1m0J1TJJE+vO7Gw/h97xzIjY1X68S9IzO9kZlLG9QtIq\n", - "SXeKMewJtufY3qzWGN0SEfeLseslH5F0taQnJjzH+PWwbkuomMPhFBKtOTkY0y5ne6GkL0taGxGP\n", - "T3yNMexeEfFE+5LfkKSX275k0uuMXZey/RpJuyNik356dupJGL/e020J1Y8kLZ+wvFyts1ToHbts\n", - "nyNJts+VtLvD/cFx2D5NrWTqhoi4sf00Y9hDImKfpH+T9Mti7HrFiyVdZvshSV+Q9Cu2bxDj19O6\n", - "LaHaKGml7RW2+yS9SdLXOtwn5HxN0lvbj98q6cbjxKKDbFvS9ZK2RcR1E15iDLuc7bOO/gLM9nxJ\n", - "vyppkxi7nhAR10bE8oh4tqQ3S/p2RLxFjF9P67qZ0m3/uqTr1LrJ8vqI+ECHu4Rp2P6CpFdIOkut\n", - "6/1/Iemrkv5Z0rMk7ZD0xoj4Saf6iOm1fxX2XUlb9dNLC++TtEGMYVez/Ty1blqe0/7vhoj4sO0z\n", - "xNj1FNuvkPTuiLiM8ettXZdQAQAA9Jpuu+QHAADQc0ioAAAAGiKhAgAAaIiECgAAoCESKgAAgIZI\n", - "qAAAABoioQLQcbZvb///Z21ffpLbvnaqdQHAycQ8VAC6hu01ak1y+NrEe+ZFxOHjvP54RCw6Gf0D\n", - "gOlwhgpAx9kebj/8oKSX2d5ke63tObY/bHuD7S22/6gdv8b2rba/Kum+9nM32t5o+z7bb28/90FJ\n", - "89vt3TBxXW75sO17bW+1/cYJba+z/S+2H7D92dndGgB60bxOdwAA9NPSN++V9J6jZ6jaCdRPIuIi\n", - "2/2SbrP9rXbsKkkXRMR/t5ffFhF727XtNtj+UkRcY/udEbFqinX9pqRfkvR8SWdLusv2d9uvvUDS\n", - "+ZL+V9Lttl8SEVwqBDAtzlAB6CaetPxrkq6wvUnSeklnSPqF9msbJiRTkrTW9mZJd0haLmnlDOt6\n", - "qaTPR8tuSd+RdKFaCdeGiPhxtO6J2CxpRYO/CcDTAGeoAHS7d0XEzROfaN9rNTJp+ZWSVkfEmO1b\n", - "JA3M0G7oqQnc0bNXByc8d0QcKwHMgDNUALrJ45Im3kD+TUnvsD1Pkmw/x/bgFO9bLGlvO5k6T9Lq\n", - "Ca+NH33/JLdKelP7Pq2zJb1c0gY9NckCgBnxry4A3eDomaEtko60L919UtJH1brcdo9tS9ot6Tfa\n", - "8RN/onyTpD+2vU3S99W67HfUxyVttX13RLzl6Psi4l9tX9xeZ0i6OiJ2237upLY1xTIAPAnTJgAA\n", - "ADTEJT8AAICGSKgAAAAaIqECAABoiIQKAACgIRIqAACAhkioAAAAGiKhAgAAaIiECgAAoKH/B5/L\n", - "COx3ba+AAAAAAElFTkSuQmCC\n" + "AAALEgAACxIB0t1+/AAAEvtJREFUeJzt3X+QXXV5x/HPJxuS7OYXQwNYdbNLG20loxWrDoKYpNoO\n", + "ZQRta1XaqrUdOx21UqqOyNj+4bSj1elIHaadsVB/4K+2alGmVaQ1iRFKIpgQSFAMYyhoZQkkkt3N\n", + "j014+se9G5ewN3uePfnuuTe+XzMM95z73HO+93zPOfvknHO/jyNCAAAAmL15TTcAAACg15FQAQAA\n", + "1ERCBQAAUBMJFQAAQE0kVAAAADWRUAEAANQ0v8mV22bMBgAA0DMiwtPNL5pQ2b5Y0jWS+iRdFxF/\n", + "e3zM+973vqd8buPGjVqzZs2s13v06NFUfGYsrieeeKJIbC+OB2ZPu0/p1ltv1YUXXviked2wjSXp\n", + "yJEjlWMPHz5cJPbgwYNFYufNy11w7uvre8q8HTt2aPXq1U+Zf9ppp9VabieZY3V0dLRy7N69eyvH\n", + "StK+ffsqx46Pj1eOPXToUOXYzD7UaRvv379fS5cufcr8TP8NDAxUju3v768cu2jRosqx8+dX/9OU\n", + "2d+kzuet6WTOF5ljdbp9aGRkRGeddVal2BM5cOBA5dhS57iJiYnKsZlzQPZv+1wrdsvPdp+kayVd\n", + "LOlcSZfbfk6p9QEAADSl5DNUL5a0KyJ2R8SEpM9LelXB9QEAADSiZEL1DEkPTpl+qD1vRkNDQ0Ua\n", + "hLkxODjYdBMwS2eeeWbTTUANCxYsaLoJmKXFixc33QTUVDKhmvVDQcPDwyexGZhrK1eubLoJmKXp\n", + "nuFA71i4cGHTTcAskVD1vpIPpf9Q0tRLFYNqXaV6ko0bNx57PTQ0RDIFAAB6TsmE6g5Jz7I9LOlH\n", + "kl4n6fLjg+r8mg8AAKAbFEuoIuKI7bdLulmtYROuj4h7S60PAACgKUXHoYqIr0r6asl1AAAANK3R\n", + "kdKl6r9KyQwMmRkUTsoNDpkZWKzXlivlBrLLDN6WWW4mtuT3KzUYaalB77IDAJYadLJUbEZ2uZlt\n", + "UWrgxMyAk9kBbTP7UeYYGRsbqxybOS9nBhfNDFoq5Y7rUuetkue4zGCry5cvrxybGTg4M4hrpq+z\n", + "v2LNHFNV94sNGzZ0fI9afgAAADWRUAEAANREQgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFAABQ\n", + "EwkVAABATSRUAAAANZFQAQAA1ERCBQAAUFPjtfyq1qTK1OTJytQoKtWOUnXjMsuVcnWjStUHy3y/\n", + "bM22UjUTs9u5RBuyMjUFS9X9y/RHqWMk246+vr7KsZn6dZlj5ODBg5VjpVz9wcx+UWofeuyxxyrH\n", + "ZrdFqZp7mf0zU38wU5tPytXGK1WfL7PcUucWqdzfnU6KXqGyPWh7ve0dtu+x/Y6S6wMAAGhC6StU\n", + "E5KujIhttpdIutP2LRFxb+H1AgAAzJmiV6gi4scRsa39elTSvZKeXnKdAAAAc23OHkq3PSzpPEmb\n", + "52qdAAAAc2FOEqr27b4vSLqifaUKAADglFH8V362T5P0RUmfjogbj39//fr1x14PDw/rnHPOKd0k\n", + "AACAGY2Ojmp0tNp1oKIJlVtjDFwvaWdEXDNdzLp160o2AQAAYFaWLFmiJUuWHJseGRnpGFv6lt+F\n", + "kv5A0jrbW9v/XVx4nQAAAHOq6BWqiPiWGI0dAACc4kh2AAAAamq89Eym5EM3KFVipFtKl2RK62TK\n", + "aixYsKBybKZsQSZWyn2/UiVGSn2/TJkFKbdvlCpJlGlDydIsmRIqpUqMLF68uHLs8uXLK8dK0sKF\n", + "CyvHZr7f+Ph4kdj9+/dXjn388ccrx0rl/uYsW7ascuzZZ59dJFbKlYjJHH+ZPhkbGysSmymhJOVK\n", + "1VTdFtu3b+/4HleoAAAAaiKhAgAAqImECgAAoCYSKgAAgJpIqAAAAGoioQIAAKiJhAoAAKAmEioA\n", + "AICaSKgAAABqIqECAACoqfHSM1VlyiFky7iUKgWSKXNSqvRMpiSKlCu3kvl+mdIzpWKlXCmQTF9n\n", + "tlu2zVVlywxllCqhUio2u99n4jOlSzL7xcDAQOXYzLaQcueXTImfQ4cOFYnNHHtnnHFG5VgpV7an\n", + "v78/teyqRkdHK8fu2bMntezMds7InO9L7cuZ5Uq581bV73fttdd2fK/jWcT270gKSdOtJSLiS1VW\n", + "brtP0h2SHoqIS6t8BgAAoJec6J9ll6qVUHVSKaGSdIWknZKWVm0UAABAL+mYUEXEH9ZduO1nSrpE\n", + "0t9I+ou6ywMAAOhGM96otv0029fb/lp7+lzbf1xx+R+R9G5J5R7uAAAAaFiVJ/8+Ienrkp7env6+\n", + "pCtn+pDtV0oaiYitmv45LAAAgFNClZ+2rIiIf7F9lSRFxITtKj8DuUDSZbYvkbRI0jLbn4qIN04N\n", + "2rhx47HXQ0NDGh4ertx4AACAUjZs2KANGzZUiq2SUI3a/rnJCdvnS/rJTB+KiKslXd3+zBpJ7zo+\n", + "mZKkNWvWVGooAADAXFq7dq3Wrl17bPr9739/x9gqCdU7Jd0k6Rds3ybpTEmvmUW7ygy0BAAA0LAZ\n", + "E6qIuNP2yyT9klrPQn0vIiYyK4mIjZI2zhgIAADQg2ZMqGz3S3qrpJeqdZVpk+1/jIiDpRsHAADQ\n", + "C6rc8vuUpMclfVStK1S/J+kGSb9bsF0AAAA9o0pCtToizp0y/Q3bO09WA6rWjcrUosrWNCu17Exs\n", + "qRqBmdisbqhVmO3rTHymplkmNmPRokWVYzN1q6RcnblMrbvDhw9Xjh0bG6scm6lRdvBg7gJ6qbqU\n", + "CxcurBybqWmWPa4z55fMsZppR4m6alL+2MvUYsy0I1OfL7MvZ89xme+X6ZPMuSiz32fOLdk6qJll\n", + "Z75fJ1WOsu/YfsnkRPtXfnfWXjMAAMAp4kTFke+eEnOr7QfVeoZqpaTvzUHbAAAAesJMxZEBAAAw\n", + "gxMVR949ddr2WWqNeA4AAIApqhRHvsz29yX9QK2xpHZL+mrhdgEAAPSMKg+l/7Wkl0i6LyLOkfRy\n", + "SZuLtgoAAKCHVEmoJiJij6R5tvsiYr2kFxZuFwAAQM+oMkjDXttLJW2S9BnbI5KqD7gBAABwiqty\n", + "herVksYlXSnpa5J2iV8AAgAAHFOlOPLk1aijkj5RtDUAAAA96EQDe46qNZDndCIilp2MBpQoSZIp\n", + "qdEtMtuhVBkXqVxpnUw5hFLLzcaXKkmUacP4+Hjl2Ew5i2w7MiU4MsdfpiRKqfJMUq4EziOPPFI5\n", + "NlMC58CBA0WWK5U7v2RKe/T391eOzZQYKVlyKRObOZ4y/ZfZN6XcOaNUmaFM/2ViM/uQlNs3MuVy\n", + "OjnROFRL6i7c9umSrpO0Wq3k7I8i4va6ywUAAOgm1f95MTt/L+k/I+I1tudLql79EwAAoEcUS6hs\n", + "L5d0UUS8SZIi4oikn5RaHwAAQFOqP5SQd46kR2x/3PZ3bP+T7YGC6wMAAGhEyYRqvqQXSPqHiHiB\n", + "pDFJVxVcHwAAQCNKPkP1kKSHIuLb7ekvaJqEatOmTcder1y5UkNDQwWbBAAAUM2ePXv06KOPVoot\n", + "llBFxI9tP2j72RFxn6RXSNpxfNxFF11UqgkAAACztmLFCq1YseLY9H333dcxtvSv/P5MrXI1CyTd\n", + "L+nNhdcHAAAw54omVBFxl6QXlVwHAABA00o+lA4AAPAzofQtvxkdOXKkUlzJshOlyl+UanPJbZGR\n", + "WXYmNlPOYtGiRZVjpVx5gUzZgsz3y5SIOXz4cOXYqsfSpEzZicw+l9nGy5cvrxy7dOnSyrFLluQK\n", + "PSxeXH3M4cy2mJiYSLWjlExppMz+mSmhki2NVFWmP7LxmdIzmXNR5hyXPYdnjuvM/pk5v3RDCTOp\n", + "TPmwm266qeN7XKECAACoiYQKAACgJhIqAACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJpIqAAA\n", + "AGoioQIAAKiJhAoAAKCmxkvPVB0aPjM8fcmh+ksMZS/lShyUaq9UrgROph3j4+OVY/ft21c5Vsr1\n", + "SbaUS1WZEhWlSuVIuTIOmRI4pcqRZMpkZMrUSLlSNQMDA5Vjly1bVjm2VMkQqdz5M9PmTF9njr1s\n", + "6ZlMOzLbbcGCBZVjS5bX6u/vLxKbOUZK7ReZvw3ZZZ+M0khFr1DZfq/tHbbvtv1Z29X/OgAAAPSI\n", + "YgmV7WFJb5H0goh4rqQ+Sa8vtT4AAICmlLzl97ikCUkDto9KGpD0w4LrAwAAaESxK1QR8Zikv5P0\n", + "v5J+JGlfRPxXqfUBAAA0peQtv1+U9OeShiU9XdIS279fan0AAABNKXnL74WSbouIRyXJ9pckXSDp\n", + "M1ODbrvttmOvBwcHNTg4WLBJAAAA1ezatUu7du2qFFsyofqupL+03S/poKRXSNpyfNAFF1xQsAkA\n", + "AACzs2rVKq1aterY9M0339wxtuQzVHdJ+pSkOyRtb8/+WKn1AQAANKXowJ4R8SFJHyq5DgAAgKZR\n", + "egYAAKAmEioAAICaGq/ll6mLVUqp+nWZ2FJtyMosO1N/MPP9StUSyy47U0cvU28rU8crUx+sZM2v\n", + "zH6RqX+WkdkWmbpjknT66adXjs2cszK1x/bu3Vs5NlvDMlMbL1MTMlOrMFNfMdN/+/fvrxwr5eog\n", + "Zs4vmeM68/0y+2a2HZn988CBA5Vjx8bGirQhU1NUKldPtxOuUAEAANREQgUAAFATCRUAAEBNJFQA\n", + "AAA1kVABAADUREIFAABQU1cmVLt37266Cajh/vvvb7oJmKXt27fPHISuRf/1rttvv73pJqCmrkyo\n", + "HnjggaabgBpIqHoXf5B7G/3XuzZv3tx0E1BTVyZUAAAAvYSECgAAoCZnS3ec1JXbza0cAAAgKSKm\n", + "rWHWaEIFAABwKuCWHwAAQE0kVAAAADV1XUJl+2Lb37X9fdvvabo96Mz2P9t+2PbdU+adYfsW2/fZ\n", + "/rrt05tsIzqzPWh7ve0dtu+x/Y72fPqwy9leZHuz7W22d9r+QHs+fddDbPfZ3mr7pvY0/dfDuiqh\n", + "st0n6VpJF0s6V9Lltp/TbKtwAh9Xq6+mukrSLRHxbEn/3Z5Gd5qQdGVErJZ0vqS3tY83+rDLRcRB\n", + "Sesi4vmSnidpne2Xir7rNVdI2ilp8mFm+q+HdVVCJenFknZFxO6ImJD0eUmvarhN6CAiNknae9zs\n", + "yyR9sv36k5JePaeNQmUR8eOI2NZ+PSrpXknPEH3YEyJivP1ygaQ+tY5F+q5H2H6mpEskXSdp8ldj\n", + "9F8P67aE6hmSHpwy/VB7HnrH2RHxcPv1w5LObrIxqMb2sKTzJG0WfdgTbM+zvU2tPlofETtE3/WS\n", + "j0h6t6Qnpsyj/3pYtyVUjOFwConWmBz0aZezvUTSFyVdERH7p75HH3aviHiifcvvmZJeZnvdce/T\n", + "d13K9isljUTEVv306tST0H+9p9sSqh9KGpwyPajWVSr0jodtP02SbP+8pJGG24MTsH2aWsnUDRFx\n", + "Y3s2fdhDIuInkv5D0q+KvusVF0i6zPYPJH1O0q/ZvkH0X0/rtoTqDknPsj1se4Gk10n6SsNtQs5X\n", + "JL2p/fpNkm48QSwaZNuSrpe0MyKumfIWfdjlbK+Y/AWY7X5Jvy5pq+i7nhARV0fEYEScI+n1kr4R\n", + "EW8Q/dfTum6kdNu/KekatR6yvD4iPtBwk9CB7c9JWiNphVr3+/9K0pcl/auklZJ2S3ptROxrqo3o\n", + "rP2rsG9K2q6f3lp4r6Qtog+7mu3nqvXQ8rz2fzdExIdtnyH6rqfYXiPpnRFxGf3X27ouoQIAAOg1\n", + "3XbLDwAAoOeQUAEAANREQgUAAFATCRUAAEBNJFQAAAA1kVABAADUREIFoHG2b23/f8j25Sd52VdP\n", + "ty4AOJkYhwpA17C9Vq1BDi9NfGZ+RBw5wfv7I2LpyWgfAHTCFSoAjbM92n75QUkX2d5q+wrb82x/\n", + "2PYW23fZ/pN2/Frbm2x/WdI97Xk32r7D9j2239Ke90FJ/e3l3TB1XW75sO27bW+3/dopy95g+99s\n", + "32v703O7NQD0ovlNNwAA9NPSN++R9K7JK1TtBGpfRLzY9kJJ37L99XbseZJWR8QD7ek3R8Tedm27\n", + "Lba/EBFX2X5bRJw3zbp+W9KvSHqepDMlfdv2N9vvPV/SuZL+T9Ktti+MCG4VAuiIK1QAuomPm/4N\n", + "SW+0vVXS7ZLOkLSq/d6WKcmUJF1he5uk/5E0KOlZM6zrpZI+Gy0jkjZKepFaCdeWiPhRtJ6J2CZp\n", + "uMZ3AvAzgCtUALrd2yPilqkz2s9ajR03/XJJ50fEQdvrJS2aYbmhpyZwk1evDk2Zd1ScKwHMgCtU\n", + "ALrJfklTHyC/WdJbbc+XJNvPtj0wzeeWSdrbTqZ+WdL5U96bmPz8cTZJel37Oa0zJb1M0hY9NckC\n", + "gBnxry4A3WDyytBdko62b919XNJH1brd9h3bljQi6bfa8VN/ovw1SX9qe6ek76l122/SxyRtt31n\n", + "RLxh8nMR8e+2X9JeZ0h6d0SM2H7OccvWNNMA8CQMmwAAAFATt/wAAABqIqECAACoiYQKAACgJhIq\n", + "AACAmkioAAAAaiKhAgAAqImECgAAoCYSKgAAgJr+H9OLZ8u3dMr8AAAAAElFTkSuQmCC\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -3375,7 +3421,7 @@ "jYuZ4ZLGxcz4f041SDwzkyB1AAAAAElFTkSuQmCC\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -3385,98 +3431,97 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAE5JJREFUeJzt3X+QXXV5x/HPh/zabH5sJFmwSsguqbb80IpVB4wKRNuh\n", - "jqJtrUpbtbZjp6NWStURmaF/taPVYUodp52hUn+gIq1a1Gn9QQkJGJAIJkBIVEAoQZsEQgKbhJBN\n", - "8vSPexOXZDf5Pjn57r03fb9mHO+597nnPLnfc88+nHPu93FECAAAAEfvhE4nAAAA0OsoqAAAABqi\n", - "oAIAAGiIggoAAKAhCioAAICGKKgAAAAamtrJjdtmzgYAANAzIsLjPV+1oLJ9oaSrJE2R9JmI+PuD\n", - "Y6644opD3rdixQqdd955B6+reLv79u1L5bl3794q6+6G2BNOyJ2EzKx7ojnMbr/9dp177rnPei7z\n", - "Ge/Zs6c4NrPebPzo6Ghx7O7du4tjn3766eLYXbt2FcdOnZr7Ok+bNu2Q59avX6/TTz/9kOf7+vqK\n", - "1ztlypTi2Mx4bN26tTh2y5YtxbHZdW/fvr04dufOncWxmf1iorEeHR0dd1xnzpxZvO6BgYHi2Llz\n", - "5xbHzp49uzg2sy9n/jZI+WNGqcx3dbyx3rx5s0466aRDnt+xY0cqj8yxqFZs5thZ83ifrQWaqnbJ\n", - "z/YUSZ+WdKGkMyRdbPvQIzUAAECPq3kP1SskPRARD0fEqKSvSHpTxe0BAAB0RM2C6vmSNoxZfrT9\n", - "3BEtWrSoSkKYHKecckqnU8BRWrBgQadTQAPZS/zoHrNmzep0Cmio5rfvqG84HxoaOoZpYLItXLiw\n", - "0yngKA0ODnY6BTSQuX8N3YWCqvfVvCn955LG/mVdqNZZqmdZsWLFgceLFi2imAIAAD2nZkF1p6QX\n", - "2B6S9AtJb5N08cFBB/+aDwAAoNdUK6giYo/t90v6rlrTJlwTEetrbQ8AAKBTqs5DFRHflvTtmtsA\n", - "AADotI7OlC6VTyKXmaCr5uRfkz1RWFPZfGt9zt0QW1NmcsFMbGaCvGeeeaY4VspNOpmZXHBkZKQ4\n", - "NpNzZrLH7K8V58+fXxxba6ynT59eHFtzwt5ak2pmbpjv7+8vjs18blIu58ykk7UmqMysV8rtG9nJ\n", - "gGvkkNkvJppMeiKZ/b50Ytbrrrtuwtf4jS0AAEBDFFQAAAANUVABAAA0REEFAADQEAUVAABAQxRU\n", - "AAAADVFQAQAANERBBQAA0BAFFQAAQEMUVAAAAA1RUAEAADTU8V5+GzduLIqbMWNG8TozsVKuF1Rm\n", - "3Zl+RpkeRbt37y6OzfSCk3J9ozJ92DJ51OqfJeU+51o9saZNm1Ycm5Hty9UNOff19RXHZvLN9rrL\n", - "7BeZ40UmNtPfLfu9zvRizBxfMseATO/Ibdu2Fcdm8pXqfc6ZY1FmX872Ksz0QczEzpw5szi21nc1\n", - "04dRyo11thfqeKqeobK90PbNtu+zvdb2B2puDwAAoBNqn6EalXRpRKyxPVvSXbZvjIj1lbcLAAAw\n", - "aaqeoYqIjRGxpv14u6T1kp5Xc5sAAACTbdJuSrc9JOlsSXdM1jYBAAAmw6QUVO3LfV+VdEn7TBUA\n", - "AMBxo/qv/GxPk/Q1SV+MiBsOfn3lypUHHi9cuFCnnnpq7ZQAAACOaNu2bcW/Oq1aULn1G8drJK2L\n", - "iKvGi1myZEnNFAAAAI7KvHnzNG/evAPLjzzyyISxtS/5LZH0x5IusL26/b8LK28TAABgUlU9QxUR\n", - "3xezsQMAgOMcxQ4AAEBDHW89M3fu3KK4TGuIzHTzUq4tQ6a9QCbnjMx6s1P1Z+Iz7QUybQumTJlS\n", - "HJttiZJZd62WCLX2i3379qXia+WR+dwysZl/38jISHGslDsGZI4vmf2z9FgoSYODg8WxkjRnzpzi\n", - "2FrtcjKtPbZs2VIlVpKefvrp4thdu3YVx2bGemBgoDg2s19IufZomWN45m9fph1Q5jPOtC+SpO3b\n", - "yycVKN0/b7nllglf4wwVAABAQxRUAAAADVFQAQAANERBBQAA0BAFFQAAQEMUVAAAAA1RUAEAADRE\n", - "QQUAANAQBRUAAEBDFFQAAAANdbz1TGnrgkyLisx0+lKuZUCmdUmtdiSZFhzZ1jOZzzmTc2ZMMrHZ\n", - "1jOZ+Fo5Z2IzrT0yLRykXCuQjNmzZxfHzps3rzj2xBNPLI7t6+srjpVy+0WmdUnmu5pp+ZJp5STl\n", - "9qNax6JMO5JMDpn9Qsq1cunv70+tu1Tmu5dpiyTlxnp0dLTKemu1MMv+ba/xt+Tqq6+eeHsTvWD7\n", - "9yWFpPE+mYiIr5ds3PYUSXdKejQi3ljyHgAAgF5yuPLtjWoVVBMpKqgkXSJpnaTy7pwAAAA9ZMKC\n", - "KiL+pOnKbZ8i6fWS/k7SXzddHwAAQDc64g0ztp9r+xrb32kvn2H7zwrX/w+SPiyp/EI7AABAjym5\n", - "A/lzkr4n6Xnt5fslXXqkN9l+g6TNEbFa49+HBQAAcFwouQV+QURcb/sySYqIUdt7Ct73SkkX2X69\n", - "pD5Jc21/ISLeOTZo+fLlBx4PDQ1paGioNHcAAIBqVq5cqdtuu60otqSg2m57/v4F2+dIevJIb4qI\n", - "yyVd3n7PeZI+dHAxJUnnn39+UaIAAACTacmSJVqyZMmB5SuvvHLC2JKC6oOSviXpNNu3SRqU9Jaj\n", - "yKt8YhEAAIAecsSCKiLusv0aSb+m1r1QP4mI8tnAWutYIWnF0aUIAADQ3Y5YUNmeKem9kl6l1lmm\n", - "W23/c0TkpmUGAAA4TpVc8vuCpKckfUqtM1R/KOlaSX9QMS8AAICeUVJQnRkRZ4xZXmZ73bFKoLR3\n", - "XK3+UlKur1KmR1EmNtMjMBOb6c2Xja+VR6b/UrZXYaYfVWY/yvTRy+Sc6Uk3a9as4lhJGhwcLI7N\n", - "9OfLjF+mL94TTzxRHLtt27biWCnX0ywzfpkxGRgYKI7N9jSr1aOz1jEg01tx48aNxbGStGHDhuLY\n", - "zH6xadOm4tjHHnusOPapp54qjpVyvf8yY13rWDRnTnkTlcxxSMr1bcyuezwle/iPbJ+7f6H9K7+7\n", - "Gm8ZAADgOHG45sj3jolZaXuDWvdQnSrpJ5OQGwAAQE84UnNkAAAAHMHhmiM/PHbZ9klqzXgOAACA\n", - "MUqaI19k+35JD6k1l9TDkr5dOS8AAICeUXJT+t9KOlfSTyNiWNJrJd1RNSsAAIAeUlJQjUbE45JO\n", - "sD0lIm6W9LLKeQEAAPSMkslMttqeI+lWSV+yvVnS9rppAQAA9I6SM1RvlrRT0qWSviPpAfELQAAA\n", - "gANKmiPvPxu1V9LnqmYDAADQgw43sed2tSbyHE9ERPmc7oeRbY3SaZmp+jOxe/bsKY7NtE/plhYV\n", - "tdabbT3TDTL/vkzri0wbF0navXt3cWwm5xkzZhTHZtr7ZHLItuHJtOvIfFe3by+/O+LJJ58sjs22\n", - "18rYuXNncWyttl0ZmfY3Um7/zLRbyeSRaXOS/RuZOeZnjgGZfW5kZKRKbKYlkZQbk8x+MZHDzUPV\n", - "uLGN7XmSPiPpTLWKsz+NiB80XS8AAEA3yZ2+yPtHSf8VEW+xPVVS7j8bAQAAekC1gsr2gKRXR8S7\n", - "JCki9kgqP6cNAADQI2rewDQs6THbn7X9I9v/Yru/4vYAAAA6omZBNVXSSyX9U0S8VNIOSZdV3B4A\n", - "AEBH1LyH6lFJj0bED9vLX9U4BdWyZcsOPB4eHtbw8HDFlAAAAMo8+OCD+tnPflYUW62gioiNtjfY\n", - "fmFE/FTS6yTdd3Dc0qVLa6UAAABw1BYvXqzFixcfWL7pppsmjK39K7+/VKtdzXRJD0p6d+XtAQAA\n", - "TLqqBVVE3C3p5TW3AQAA0Gm9NU05AABAF6p9ye+ISqd7r9WaJRufaX9RS6YVQeZzk3JT9df6LDKt\n", - "E7KtdTLtLzL7RaaFQ6bFSKadTKYNiFSvxU+mhcPAwEBxbKZdR39/boaWTIuRWq1ndu3aVRybPcZl\n", - "2obUOtbW2t+yrWcy687Ezpw5szg28x3JHuMy36nM+GX2i25pCVZrrCfCGSoAAICGKKgAAAAaoqAC\n", - "AABoiIIKAACgIQoqAACAhiioAAAAGqKgAgAAaIiCCgAAoCEKKgAAgIYoqAAAABrqeOuZ0nYZmSny\n", - "s20ZMi0RarVPyLSTqTmtf6aNw/Tp06usN/MZZ1pqSLl9Y3R0tMp658+fXxybaWeRGQ8ptx9l2trs\n", - "3LmzODbTbmVkZKQ4NvN9knKf3Zw5c4pjTz755OLYTM7Z/T4jk0dmv8/sF5mWS9nPYseOHVXWndkv\n", - "Mm2U5s2bVxwrSc95znOKY2fNmlUcm/mOZI6dmWNLZuyk3PEls39OpOoZKtsftX2f7Xttf9l2eQMj\n", - "AACAHlGtoLI9JOk9kl4aES+SNEXS22ttDwAAoFNqXvJ7StKopH7beyX1S/p5xe0BAAB0RLUzVBHx\n", - "hKQrJT0i6ReStkXEf9faHgAAQKfUvOS3WNJfSRqS9DxJs23/Ua3tAQAAdErNS34vk3RbRGyRJNtf\n", - "l/RKSV8aG7Rs2bIDj4eHhzU8PFwxJQAAgDJr167V2rVri2JrFlQ/lnSF7ZmSdkl6naRVBwctXbq0\n", - "YgoAAABH56yzztJZZ511YPn666+fMLbmPVR3S/qCpDsl3dN++upa2wMAAOiUqhN7RsQnJH2i5jYA\n", - "AAA6jdYzAAAADVFQAQAANNTxXn6lfdsyveAysVKud1Vm3bX689Xqi5fNIxOb7a9YKvvvy4xJpjdX\n", - "X19fldhML79MrCT19/en4kvt2bOnynozvcTmzp2bWvfg4GBx7MDAQHFsppfY448/Xhy7efPm4ths\n", - "HpnvamafO+2004pjFyxYUBw7bdq04lgptx9lYjN5ZI5D2b6UmbHO9MbL9OfLHAMy/RIzvTElaerU\n", - "8hIne/wcD2eoAAAAGqKgAgAAaIiCCgAAoCEKKgAAgIYoqAAAABqioAIAAGioKwuqhx56qNMpoIH7\n", - "77+/0yngKK1evbrTKaABxq93LV++vNMpoCEKKhxzDzzwQKdTwFFas2ZNp1NAAxRUvWvFihWdTgEN\n", - "dWVBBQAA0EsoqAAAABpytnXHMd243bmNAwAAJEXEuH3XOlpQAQAAHA+45AcAANAQBRUAAEBDXVdQ\n", - "2b7Q9o9t32/7I53OBxOz/a+2N9m+d8xzJ9q+0fZPbX/P9rxO5oiJ2V5o+2bb99lea/sD7ecZwy5n\n", - "u8/2HbbX2F5n+2Pt5xm7HmJ7iu3Vtr/VXmb8elhXFVS2p0j6tKQLJZ0h6WLbp3c2KxzGZ9Uaq7Eu\n", - "k3RjRLxQ0k3tZXSnUUmXRsSZks6R9L72940x7HIRsUvSBRHxEkkvlnSB7VeJses1l0haJ2n/zcyM\n", - "Xw/rqoJK0iskPRARD0fEqKSvSHpTh3PCBCLiVklbD3r6Ikmfbz/+vKQ3T2pSKBYRGyNiTfvxdknr\n", - "JT1fjGFPiIid7YfTJU1R67vI2PUI26dIer2kz0ja/6sxxq+HdVtB9XxJG8YsP9p+Dr3j5IjY1H68\n", - "SdLJnUwGZWwPSTpb0h1iDHuC7RNsr1FrjG6OiPvE2PWSf5D0YUn7xjzH+PWwbiuomMPhOBKtOTkY\n", - "0y5ne7akr0m6JCJGxr7GGHaviNjXvuR3iqTX2L7goNcZuy5l+w2SNkfEav3y7NSzMH69p9sKqp9L\n", - "WjhmeaFaZ6nQOzbZfq4k2f4VSZs7nA8Ow/Y0tYqpayPihvbTjGEPiYgnJf2npN8UY9crXinpItsP\n", - "SbpO0lLb14rx62ndVlDdKekFtodsT5f0Nknf7HBOyPmmpHe1H79L0g2HiUUH2bakaySti4irxrzE\n", - "GHY52wv2/wLM9kxJvyVptRi7nhARl0fEwogYlvR2Scsi4h1i/Hpa182Ubvt3JF2l1k2W10TExzqc\n", - "EiZg+zpJ50laoNb1/r+R9A1J/ybpVEkPS3prRGzrVI6YWPtXYbdIuke/vLTwUUmrxBh2NdsvUuum\n", - "5RPa/7s2Ij5p+0Qxdj3F9nmSPhgRFzF+va3rCioAAIBe022X/AAAAHoOBRUAAEBDFFQAAAANUVAB\n", - "AAA0REEFAADQEAUVAABAQxRUADrO9sr2/y+yffExXvfl420LAI4l5qEC0DVsn6/WJIdvTLxnakTs\n", - "OczrIxEx51jkBwAT4QwVgI6zvb398OOSXm17te1LbJ9g+5O2V9m+2/aft+PPt32r7W9IWtt+7gbb\n", - "d9pea/s97ec+Lmlme33Xjt2WWz5p+17b99h+65h1L7f977bX2/7i5H4aAHrR1E4nAAD6Zeubj0j6\n", - "0P4zVO0CaltEvML2DEnft/29duzZks6MiP9pL787Ira2e9utsv3ViLjM9vsi4uxxtvV7kn5D0osl\n", - "DUr6oe1b2q+9RNIZkv5X0krbSyKCS4UAJsQZKgDdxAct/7akd9peLekHkk6U9Kvt11aNKaYk6RLb\n", - "ayTdLmmhpBccYVuvkvTlaNksaYWkl6tVcK2KiF9E656INZKGGvybAPw/wBkqAN3u/RFx49gn2vda\n", - "7Tho+bWSzomIXbZvltR3hPWGDi3g9p+9embMc3vFsRLAEXCGCkA3GZE09gby70p6r+2pkmT7hbb7\n", - "x3nfXElb28XUr0s6Z8xro/vff5BbJb2tfZ/WoKTXSFqlQ4ssADgi/qsLQDfYf2bobkl725fuPivp\n", - "U2pdbvuRbUvaLOl32/Fjf6L8HUl/YXudpJ+oddlvv6sl3WP7roh4x/73RcR/2D63vc2Q9OGI2Gz7\n", - "9IPWrXGWAeBZmDYBAACgIS75AQAANERBBQAA0BAFFQAAQEMUVAAAAA1RUAEAADREQQUAANAQBRUA\n", - "AEBDFFQAAAAN/R9mVy2QoO8DbAAAAABJRU5ErkJggg==\n" + "AAALEgAACxIB0t1+/AAAE2tJREFUeJzt3XuwXWV5x/HfLwm5kavBBDSHRKi0wsSKVbkoIFU6lFG0\n", + "rVVpq9Z27HTUSqk6Ik77VztanY7oMO1opSp4oa1a1Gm9pDWQaDARTEJCUKCaNhFISi6cnFxPwtM/\n", + "9k48nJyT8z5Zec/eO34/Mwx7rf3std693rX2ebIu7+OIEAAAAE7chE43AAAAoNeRUAEAADREQgUA\n", + "ANAQCRUAAEBDJFQAAAANkVABAAA0NKmTK7fNmA0AAKBnRIRHml81obJ9taSbJU2U9KmI+NvhMR/4\n", + "wAeO+dzy5ct1+eWXP23eU089VamVuWV3Q2xNEyY0P2m5cuVKXXrppU+bV+v7HT58OBU/ODhYHLt/\n", + "//4qsXv37i2O3bNnT3HsxIkTi2MladKkYw//hx56SOedd94x86dOnVq83NNOO604NrNf7Nq1qzh2\n", + "+/btxbHZ+P7+/uLYffv2Fcdm9qHRtvGhQ4dG7Ndp06YVL3v27NnFsbNmzSqOnTFjRnFsrf1Nyv3G\n", + "HTp0qDg2c6wODAwcM2/r1q1asGDBMfN3795dvNxsOw4ePFglNvM7m/kNqDlupj1ijpRqQ7VLfrYn\n", + "SrpF0tWSzpd0ne3n1VofAABAp9S8h+olkh6JiE0RMSjpDkmvqbg+AACAjqiZUD1b0uYh01va88a0\n", + "aNGiKg3C+Ojr6+t0E3CC5s2b1+kmoIGTcckenXH66ad3ugloqObRd8IXO0moehsJVe8ioeptJFS9\n", + "K3OPGbpTzZvSfyZp6F/WPrXOUj3N8uXLj75etGgRyRQAAOgKmRvhayZU90p6ru3Fkh6V9AZJ1w0P\n", + "Gv40HwAAQDcY/vTf8RKsaglVRByy/U5J31Jr2IRbI+LBWusDAADolKrjUEXENyR9o+Y6AAAAOq2j\n", + "I6VL5YOylQ66JeUH/6o1sFit2JoDhmYGyswMeldrudnvl4nP3OCbGYhwypQpxbHTp08vjs1sN0k6\n", + "cOBAcWxmsMDMcjODBdYc1C+znTMy+0VmfzsZg7iOJtPmzHIzx17m9z4rs89l9uXM8Zfpv8ygrFLu\n", + "acHMoKiZPsn8xtUcxDXT5tLBSO+6665R3+OREAAAgIZIqAAAABoioQIAAGiIhAoAAKAhEioAAICG\n", + "SKgAAAAaIqECAABoiIQKAACgIRIqAACAhkioAAAAGiKhAgAAaKjjtfwytZLQkq1fV0umTlKt2lyZ\n", + "GoFSvfqDterMZeq7ZepnSbl6YpnYTL2tTH9ktkXNGo+16jZm9qFMPTpJ2r9/f3Fspk9K659JuTY/\n", + "+uijxbGZ7ybV+w3I7EOZ+nwzZswojpWkmTNnFsfOmjWrOLZWXcpaNW+l3D6XrYU6kqpnqGz32V5m\n", + "+wHbG2y/q+b6AAAAOqH2GapBSTdExFrbMyTdZ3tpRDxYeb0AAADjpuoZqoh4PCLWtl8PSHpQ0rNq\n", + "rhMAAGC8jdtN6bYXS7pQ0qrxWicAAMB4GJeEqn2570uSrm+fqQIAADhlVH/Kz/Zpkr4s6XMRcefw\n", + "91esWHH09dlnn61FixbVbhIAAMCYdu7cqV27dhXFVk2o3HpW/lZJGyPi5pFiLrvssppNAAAAOCFz\n", + "587V3Llzj05v2rRp1Njal/xeKukPJF1pe037v6srrxMAAGBcVT1DFRHfFaOxAwCAUxzJDgAAQEMd\n", + "Lz0zefLkorhapUukukPf11hupsRBtgRHpmRAphxJZrkZmTZIuf1o0qTywyMTW2u7ZUsnZMpq1IrN\n", + "7PeZ5e7bt684VsqVUMnsQ5kyPLNnzy6OnTdvXnGslCt1krFnz57i2P7+/uLYHTt2VImVcqVqMvvc\n", + "nDlzimMzD18tXLiwOFbKlarJfL/SG7Ml6cknnyyO3b17d3FsZn+Tcn1d+rdy2bJlo77HGSoAAICG\n", + "SKgAAAAaIqECAABoiIQKAACgIRIqAACAhkioAAAAGiKhAgAAaIiECgAAoCESKgAAgIZIqAAAABrq\n", + "eOmZ6dOnF8XVLLdSq6xNrXIymeVmv1um1EkmNlOCo1aslCsRk9l2mdhM6ZlMaYiDBw8Wx2aXnenr\n", + "008/vTh25syZxbGlvxVSviRRaQksqV6Zmkx5mMw2lnJ9feDAgeLYTGmPbDmgUmeeeWYqPlO2J1PG\n", + "JSNTxuWxxx5LLTtTniWzL2eOv3PPPbc4ttZvgCRNmTIlFV/iE5/4xKjvjfrXxfbvSApJI/0iRER8\n", + "pWTltidKulfSloh4dclnAAAAesnx/rn+arUSqtEUJVSSrpe0UVJ5GgoAANBDRk2oIuIPmy7c9kJJ\n", + "10j6G0l/0XR5AAAA3WjMGyNsn2n7VtvfbE+fb/uPC5f/UUnvlZS7qQkAAKCHlNxp+hlJ35b0rPb0\n", + "w5JuGOtDtl8laVtErNHI92EBAACcEkoeeTojIv7Z9o2SFBGDtg8VfO5SSdfavkbSVEmzbN8WEW8e\n", + "GrR06dKjr88555zU0wEAAAC1rFq1SqtXry6KLUmoBmwffc7U9sWSnhzrQxFxk6Sb2p+5QtJ7hidT\n", + "knTVVVcVNRQAAGA8XXTRRbrooouOTt9yyy2jxpYkVO+W9HVJ59heKemZkl53Au0qHzwJAACgh4yZ\n", + "UEXEfbYvl/TLat0L9eOIKB8NrLWMuyXdfWJNBAAA6G5jJlS2p0l6u6SXqXWWaYXtf4iI8iFyAQAA\n", + "TmEll/xuk9Qv6eNqnaH6PUm3S/rdiu0CAADoGSUJ1QURcf6Q6e/Y3niyGlBad6hWrbvayy6VqfmV\n", + "qUeXrWmWkWnzoUMlD4a2ZLZxpu5YVq2+zvTJrFmzimMzNbGkXF2sTK27TF/v3r27OHb79u3FsXv3\n", + "7i2OlXL7cqY+WKbm3uzZs4tjd+zYURwr5WoxZn4PM/typu5mpj8ef/zx4lhJ2rx5cyq+VKZPMvt9\n", + "pl6ilDv+MvtF5vcic4xkYjO/QzXbMZqSrflD25ccmWg/5Xdf4zUDAACcIo5XHHn9kJjv2d6s1j1U\n", + "Z0v68Ti0DQAAoCeMVRwZAAAAYzheceRNQ6dtz1drxHMAAAAMUVIc+VrbD0v6qVpjSW2S9I3K7QIA\n", + "AOgZJTel/7WkSyQ9FBHPkfQKSauqtgoAAKCHlCRUgxHxhKQJtidGxDJJL6rcLgAAgJ5RMqDRTtsz\n", + "Ja2Q9Hnb2yQN1G0WAABA7yg5Q/VaSXsl3SDpm5IeEU8AAgAAHFVSHPnI2ajDkj5TtTUAAAA96HgD\n", + "ew6oNZDnSCIiymtiHEdpmYPMEPndUm4lE1urzEnNMjy1SvbU2hbZZWf2uUxsxsBA+dX1TMkJKbd/\n", + "ZsqGTJs2rcpyM2UnMiVfpFwpkK1btxbHlpbWyrYhW1qn1nGd6ZMZM2YUx2b2oWw5kkzprsxxnSmD\n", + "1d/fXxybLTO0a9eu4tjBwcHi2My2yBzXmZI2mVgpV05m6tTmo0Idbxyq8r1/FLbnSPqUpAvUSs7+\n", + "KCK+33S5AAAA3aQ8VT8xH5P0HxHxOtuTJOX+2QgAANADqiVUtmdLuiwi3iJJEXFI0pO11gcAANAp\n", + "dW78aHmOpP+z/WnbP7T9j7ZzF0ABAAB6QM2EapKkF0r6+4h4oaQ9km6suD4AAICOqHkP1RZJWyLi\n", + "B+3pL2mEhOruu+8++nrRokVavHhxxSYBAACU2bx5s7Zs2VIUWy2hiojHbW+2fV5EPCTplZIeGB53\n", + "xRVX1GoCAADACevr61NfX9/R6VWrRi9lXPspvz9Tq1zNZEn/LemtldcHAAAw7qomVBGxTtKLa64D\n", + "AACg02relA4AAPALofYlv47IlE6Q6pWTqdWGbliuVK9ETKZ0ULZcQKYkQmbbHT58uDg2U2KkZjmS\n", + "gwcPFsdmjqnMNp4zZ05x7MyZM4tjsyUqMmVRMmVtMuVIMvtQ9tjLLHvfvn3FsZl9LrPcWttNypWe\n", + "ycTOmlVejW3+/PlV2iDlSsRkylVlt3M3qFUSbNT1jevaAAAATkEkVAAAAA2RUAEAADREQgUAANAQ\n", + "CRUAAEBDJFQAAAANkVABAAA0REIFAADQEAkVAABAQyRUAAAADXW89MzAwEBRXM0SKplSJ5mh7DOx\n", + "tdqQLVFR6/tlZMpOlO4/R2S2R61SC5kyJwsWLCiOnTx5cqodmXIy+/fvL46tVY5k27ZtxbGZkjZS\n", + "br/IlMA566yzqrQhc4xIuRIjGbVK2gwODhbHZkodZZedkSlJNGXKlOLYTEmbbPzcuXOrxGb25czv\n", + "RaYUl5Tb57J/S0ZS9QyV7ffbfsD2ettfsF2+FwEAAPSIagmV7cWS3ibphRGxRNJESW+stT4AAIBO\n", + "qXnJr1/SoKTptg9Lmi7pZxXXBwAA0BHVzlBFxA5JfyfpfyU9KmlXRPxnrfUBAAB0Ss1LfudK+nNJ\n", + "iyU9S9IM279fa30AAACdUvOS34skrYyI7ZJk+yuSLpX0+aFB99xzz9HXCxcuVF9fX8UmAQAAlFm/\n", + "fr02bNhQFFszofqRpL+0PU3SfkmvlLR6eNAll1xSsQkAAAAnZsmSJVqyZMnR6TvuuGPU2Jr3UK2T\n", + "dJukeyXd3579yVrrAwAA6JSqA3tGxIclfbjmOgAAADqN0jMAAAANkVABAAA01PFafvPnzy+Ky9ak\n", + "y8jUCeyGWne1livltkWm/mCtNmTq0Um5bZepjTdt2rTi2Mx2y9T8mjp1anGslKs9lumTTN24zHFd\n", + "s/7ZGWecURybqcWYqT32xBNPFMdu3769OFbK1a+bNKn8z0JmO2fqK2aW29/fXxwr1atrmPm9yHy/\n", + "efPmpdqRqW1Yq+5mZrmZ9mbqaErS7Nmzi2Ozv58j4QwVAABAQyRUAAAADZFQAQAANERCBQAA0BAJ\n", + "FQAAQEMkVAAAAA11ZUL1k5/8pNNNQAMPP/xwp5uAE7R27dpONwENrFu3rtNNwAlauXJlp5uAhkio\n", + "cNI98sgjnW4CThB/kHsb/de7SKh6X1cmVAAAAL2EhAoAAKAh1yzpMubK7c6tHAAAICkiRqzF1dGE\n", + "CgAA4FTAJT8AAICGSKgAAAAa6rqEyvbVtn9k+2Hb7+t0ezA62/9ke6vt9UPmPcP2UtsP2f627Tmd\n", + "bCNGZ7vP9jLbD9jeYPtd7fn0YZezPdX2KttrbW+0/cH2fPquh9ieaHuN7a+3p+m/HtZVCZXtiZJu\n", + "kXS1pPMlXWf7eZ1tFY7j02r11VA3SloaEedJ+q/2NLrToKQbIuICSRdLekf7eKMPu1xE7Jd0ZUS8\n", + "QNLzJV1p+2Wi73rN9ZI2SjpyMzP918O6KqGS9BJJj0TEpogYlHSHpNd0uE0YRUSskLRz2OxrJX22\n", + "/fqzkl47ro1CsYh4PCLWtl8PSHpQ0rNFH/aEiNjbfjlZ0kS1jkX6rkfYXijpGkmfknTkqTH6r4d1\n", + "W0L1bEmbh0xvac9D71gQEVvbr7dKWtDJxqCM7cWSLpS0SvRhT7A9wfZatfpoWUQ8IPqul3xU0nsl\n", + "PTVkHv3Xw7otoWIMh1NItMbkoE+7nO0Zkr4s6fqI2D30Pfqwe0XEU+1LfgslXW77ymHv03ddyvar\n", + "JG2LiDX6+dmpp6H/ek+3JVQ/k9Q3ZLpPrbNU6B1bbZ8pSbbPkrStw+3Bcdg+Ta1k6vaIuLM9mz7s\n", + "IRHxpKR/l/Rrou96xaWSrrX9U0lflPTrtm8X/dfTui2hulfSc20vtj1Z0hskfa3DbULO1yS9pf36\n", + "LZLuPE4sOsi2Jd0qaWNE3DzkLfqwy9k+48gTYLanSbpK0hrRdz0hIm6KiL6IeI6kN0r6TkS8SfRf\n", + "T+u6kdJt/6akm9W6yfLWiPhgh5uEUdj+oqQrJJ2h1vX+v5L0VUn/IulsSZskvT4idnWqjRhd+6mw\n", + "5ZLu188vLbxf0mrRh13N9hK1blqe0P7v9oj4iO1niL7rKbavkPTuiLiW/uttXZdQAQAA9Jpuu+QH\n", + "AADQc0ioAAAAGiKhAgAAaIiECgAAoCESKgAAgIZIqAAAABoioQLQcba/1/7/ItvXneRl3zTSugDg\n", + "ZGIcKgBdw/bL1Rrk8NWJz0yKiEPHeX93RMw8Ge0DgNFwhgpAx9keaL/8kKTLbK+xfb3tCbY/Ynu1\n", + "7XW2/6Qd/3LbK2x/VdKG9rw7bd9re4Ptt7XnfUjStPbybh+6Lrd8xPZ62/fbfv2QZd9l+19tP2j7\n", + "c+O7NQD0okmdbgAA6Oelb94n6T1HzlC1E6hdEfES21Mkfdf2t9uxF0q6ICL+pz391ojY2a5tt9r2\n", + "lyLiRtvviIgLR1jXb0v6VUnPl/RMST+wvbz93gsknS/pMUnfs/3SiOBSIYBRcYYKQDfxsOnfkPRm\n", + "22skfV/SMyT9Uvu91UOSKUm63vZaSfdI6pP03DHW9TJJX4iWbZLulvRitRKu1RHxaLTuiVgraXGD\n", + "7wTgFwBnqAB0u3dGxNKhM9r3Wu0ZNv0KSRdHxH7byyRNHWO5oWMTuCNnrw4MmXdY/FYCGANnqAB0\n", + "k92Sht5A/i1Jb7c9SZJsn2d7+gifmyVpZzuZ+hVJFw95b/DI54dZIekN7fu0ninpckmrdWySBQBj\n", + "4l9dALrBkTND6yQdbl+6+7Skj6t1ue2Hti1pm6TfascPfUT5m5L+1PZGST9W67LfEZ+UdL/t+yLi\n", + "TUc+FxH/ZvuS9jpD0nsjYpvt5w1btkaYBoCnYdgEAACAhrjkBwAA0BAJFQAAQEMkVAAAAA2RUAEA\n", + "ADREQgUAANAQCRUAAEBDJFQAAAANkVABAAA09P8W4xDCBDf4RgAAAABJRU5ErkJggg==\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -3504,7 +3549,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "metadata": { "collapsed": false, "scrolled": false @@ -3614,7 +3659,7 @@ "WjSakdGi0YyMFo1mZLRoNCPz/yU19i71FpCwAAAAAElFTkSuQmCC\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -3624,80 +3669,79 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAD3dJREFUeJzt3X2wXVdZx/HvL/cmNwlJw6RtQCAYqqC0A1IEprxTQKcy\n", - "UHxBoCIgOjgOIBWR4WVG/9IBh3GoDKMzSOWlvKmABUZ5qVKhgDQU0teUN4dqC9IohrShTXrvzeMf\n", - "56S5vdzk7n139j3nXL6fmTs9e5911nruXud2nqy191qpKiRJkrRy60YdgCRJ0qQzoZIkSerIhEqS\n", - "JKkjEypJkqSOTKgkSZI6MqGSJEnqaHqUjSdxzQZJkjQxqipLne81oUpyHnARMAW8o6r+fHGZnTt3\n", - "/sjnDhw4wLZt2+5xbt265oNpyZK/63EdOXKkcdn5+flWdTfVZj2wNr9f22vRxvGuxe23387WrVvv\n", - "cW5ubq5xvbOzs72UbRtHm+9Fm7JtrPY6cUeOHFnyb62vOFwHT9Ja0duUX5Ip4G3AecCZwAVJHtpX\n", - "e5IkSaPS5z1UjwG+VVU3VdUs8EHg2T22J0mSNBJ9JlT3B25ecHzL8NyyZmZmeglIq2PDhg2jDkEr\n", - "1OcUsSStZX0mVCu+OWLjxo0nMw6tMhPiyWVCJUkr0+dN6d8BFt5xvpPBKNU9HDhw4O7XMzMzJlOS\n", - "JGni9JlQXQU8OMku4LvA84ALFhda/DSfJEnSpOktoaqquSSvAD7FYNmEi6vqxr7akyRJGpVe16Gq\n", - "qk8An+izDUmSpFEb6UrpAFNTU43KtVk4sc3ijdBusc42cYzDYohtF5xscy3aXOc29fbVH9Du2o3D\n", - "opPjEIMkaXnu5SdJktSRCZUkSVJHJlSSJEkdmVBJkiR1ZEIlSZLUkQmVJElSRyZUkiRJHZlQSZIk\n", - "dWRCJUmS1JEJlSRJUkcmVJIkSR2NfC+//fv3Nyo3Pd081A0bNrSKYWZmpnHZ9evXt6q7qTZ7tt11\n", - "1129lG0bR5JWdY+63rbG4ffrc+9B9wmUpJOn1xGqJDuTXJ7khiTXJ3lln+1JkiSNQt8jVLPAq6rq\n", - "6iRbgK8kuayqbuy5XUmSpFXT6whVVX2vqq4evj4I3Ajcr882JUmSVtuq3ZSeZBdwNnDlarUpSZK0\n", - "GlYloRpO930IuHA4UiVJkrRm9P6UX5L1wIeB91bVpYvfP3To0LFgpqdbPc0nSZI0DnrNXjJ4Pvxi\n", - "YG9VXbRUmY0bN/YZgiRJUu/6nvJ7PPCbwLlJ9gx/zuu5TUmSpFXV6whVVX0eV2OXJElrnMmOJElS\n", - "RyO/A/y0005rVG5+fr5xnW231GhTd5utXMZha4+226f0tQ3PunXNc/cjR440Ltum7wDm5uZ6iaOv\n", - "LXvalG17Lfq6zm3K9nWNtXJ9bY0krXWOUEmSJHVkQiVJktSRCZUkSVJHJlSSJEkdmVBJkiR1ZEIl\n", - "SZLUkQmVJElSRyZUkiRJHZlQSZIkdWRCJUmS1NHIt57Zv39/o3JttkOYmppqFcP0dPPL0KZsm20Z\n", - "+toGpE294xJHn1vP9BVHX1tw9PUdalu3fnz4vZBW5rjZQZJfAwpYKpOpqvpIkwaSTAFXAbdU1bNW\n", - "FKUkSdIYO9Fwy7MYJFTH0yihAi4E9gJbmwYlSZI0SY6bUFXVb3WtPMkDgGcAfwb8Ydf6JEmSxtGy\n", - "N6UnuW+Si5N8cnh8ZpLfaVj/W4DXAO1u7pAkSZogTZ7yexfwaeB+w+NvAq9a7kNJngnsq6o9LH0f\n", - "liRJ0prQJKE6rar+DpgHqKpZYK7B5x4HnJ/k28AHgKcmec/iQnfcccfdP7Ozsy1ClyRJGg9NEqqD\n", - "SU49epDkHODAch+qqjdU1c6qehDwfOAzVfWixeU2b95898/69evbxC5JkjQWmiyq9Grg48AZSb4I\n", - "nA48ZwVtubiJJElak9JkEbck08DPMLgX6uvDab/ujSe1ffv2pmUb19vnwp5t6nZhz5XV68KeK6vX\n", - "hT0lqX9VtWRCsmwmkWQT8DLgCQxGma5I8tdVdejkhihJkjSZmgzNvAe4DXgrgxGq3wAuAX69x7gk\n", - "SZImRpOE6qyqOnPB8WeS7D1ZATSdymszPTE31+QhxGP6erqwTcxtpjT71NcUU1/TeGt9yq9Pbb5z\n", - "k/j7SdJqavKU31eTPPbowfApv6/0F5IkSdJkOdHmyNctKPOFJDczuIfqgcDXVyE2SZKkibDc5siS\n", - "JElaxok2R75p4XGSHcDGvgOSJEmaNE02Rz4/yTeBbwOfBW4CPtFzXJIkSROjyU3pfwo8FvjGcBuZ\n", - "pwFX9hqVJEnSBGmSUM1W1f8C65JMVdXlwKN6jkuSJGliNFmHan+SrcAVwPuS7AMO9huWJEnS5Fh2\n", - "L78kW4A7GYxmvQA4BXhfVX2/c+NJnXrqqY3K9rmw4Djsw+bCnse4sOf4Weu/nyQ1teK9/Krq6GjU\n", - "PPCukxiTJEnSmnCihT0PMljIcylVVaecjABmZmYalWvzL+S2/5rua/RkHEZD2l6Lvuoeh2vctnyf\n", - "11mStLacaB2qLV0rT3Jv4B3AWQySs9+uqi91rVeSJGmcNLkpvYu/BP65qp6TZBq4V8/tSZIkrbre\n", - "Eqok24AnVtWLAapqDjjQV3uSJEmj0mQdqpV6EPA/Sd6Z5KtJ/ibJ5h7bkyRJGok+E6pp4JHAX1XV\n", - "I4EfAq/rsT1JkqSR6DOhugW4paq+PDz+EIME6x5uu+22u38OHz7cYziSJEn96O0eqqr6XpKbkzyk\n", - "qr4BPB24YXG5U045KasvSJIkjUzfT/n9PoPtajYA/wG8pOf2JEmSVl2vCVVVXQM8us82JEmSRq3P\n", - "e6gkSZJ+LPQ95bes9evXNyrX50a1bcpv2LChcdmpqanGZaenm3fFpk2bGpfdsqXdgvfbtm1rXHb7\n", - "9u2Ny55++umNy+7atatx2TPOOKNxWYAdO3Y0Lrt169bGZdt8L9o8fNHmu9n0b+moNt+jNvc63ute\n", - "zdfvbRPzunX++0/SaCVL7osMOEIlSZLUmQmVJElSRyZUkiRJHZlQSZIkdWRCJUmS1JEJlSRJUkcm\n", - "VJIkSR2ZUEmSJHVkQiVJktSRCZUkSVJHI9965s4772xUrs3WM23Kti3fdlubptpsq3Gipe9XM46+\n", - "tgK56667eikLMD8/30vZNt+LcenrNt/7vq6FJK0VvY5QJXl9khuSXJfk/Ulm+mxPkiRpFHpLqJLs\n", - "Al4KPLKqHgZMAc/vqz1JkqRR6XPK7zZgFticZB7YDHynx/YkSZJGorcRqqr6P+AvgP8Cvgv8oKr+\n", - "pa/2JEmSRqXPKb+fAv4A2AXcD9iS5AV9tSdJkjQqfd6U/ijgi1X1/aqaAz4CPG5xoYMHD9790/aJ\n", - "LUmSpHHQ5z1UXwP+OMkm4BDwdGD34kJbtmzpMQRJkqT+9XkP1TXAe4CrgGuHp9/eV3uSJEmjklEu\n", - "wpekduzY0aisC3se48KeKysLLuy5kAt7SlJ7VbXk/5jdekaSJKkjEypJkqSORr6X3/T0yQ+h7VRU\n", - "X9NcU1NTreJoqs000NzcXKu6+5panZ2dbVy2z2muNnW36b++6u0rBmjXf22mVtv0ddvpeUkaV45Q\n", - "SZIkdWRCJUmS1JEJlSRJUkcmVJIkSR2ZUEmSJHVkQiVJktTRWCZUhw8fHnUI6uDQoUOjDkEr1HaZ\n", - "DUnSgAmVTjr7b3K12WJGknTMWCZUkiRJk8SESpIkqaOMcmf4JG5LL0mSJkZVLbnP10gTKkmSpLXA\n", - "KT9JkqSOTKgkSZI6GruEKsl5Sb6W5JtJXjvqeHR8Sf42ya1JrltwbnuSy5J8I8mnk9x7lDHq+JLs\n", - "THJ5khuSXJ/klcPz9uGYS7IxyZVJrk6yN8kbh+ftuwmSZCrJniQfHx7bfxNsrBKqJFPA24DzgDOB\n", - "C5I8dLRR6QTeyaCvFnodcFlVPQT41+GxxtMs8KqqOgs4B3j58O/NPhxzVXUIOLeqHgE8HDg3yROw\n", - "7ybNhcBe4OjNzPbfBBurhAp4DPCtqrqpqmaBDwLPHnFMOo6qugLYv+j0+cC7h6/fDfzyqgalxqrq\n", - "e1V19fD1QeBG4P7YhxOhqu4YvtwATDH4W7TvJkSSBwDPAN4BHH1qzP6bYOOWUN0fuHnB8S3Dc5oc\n", - "96mqW4evbwXuM8pg1EySXcDZwJXYhxMhybokVzPoo8ur6gbsu0nyFuA1wJEF5+y/CTZuCZVrOKwh\n", - "NViTwz4dc0m2AB8GLqyq2xe+Zx+Or6o6MpzyewDwpCTnLnrfvhtTSZ4J7KuqPRwbnboH+2/yjFtC\n", - "9R1g54LjnQxGqTQ5bk1yX4AkPwHsG3E8OoEk6xkkU5dU1aXD0/bhBKmqA8A/AT+PfTcpHgecn+Tb\n", - "wAeApya5BPtvoo1bQnUV8OAku5JsAJ4HfGzEMamdjwEvHr5+MXDpCcpqhJIEuBjYW1UXLXjLPhxz\n", - "SU47+gRYkk3ALwB7sO8mQlW9oap2VtWDgOcDn6mqF2L/TbSxWyk9yS8BFzG4yfLiqnrjiEPScST5\n", - "APBk4DQG8/1/AnwU+HvggcBNwHOr6gejilHHN3wq7HPAtRybWng9sBv7cKwleRiDm5bXDX8uqao3\n", - "J9mOfTdRkjwZeHVVnW//TbaxS6gkSZImzbhN+UmSJE0cEypJkqSOTKgkSZI6MqGSJEnqyIRKkiSp\n", - "IxMqSZKkjkyoJI1cki8M//uTSS44yXW/Yam2JOlkch0qSWMjyVMYLHL4rBafma6quRO8f3tVbT0Z\n", - "8UnS8ThCJWnkkhwcvnwT8MQke5JcmGRdkjcn2Z3kmiS/Oyz/lCRXJPkocP3w3KVJrkpyfZKXDs+9\n", - "Cdg0rO+ShW1l4M1JrktybZLnLqj735L8Q5Ibk7x3da+GpEk0PeoAJIljW9+8FvijoyNUwwTqB1X1\n", - "mCQzwOeTfHpY9mzgrKr6z+HxS6pq/3Bvu91JPlRVr0vy8qo6e4m2fhX4OeDhwOnAl5N8bvjeI4Az\n", - "gf8GvpDk8VXlVKGk43KEStI4yaLjXwRelGQP8CVgO/DTw/d2L0imAC5McjXw78BO4MHLtPUE4P01\n", - "sA/4LPBoBgnX7qr6bg3uibga2NXhd5L0Y8ARKknj7hVVddnCE8N7rX646PhpwDlVdSjJ5cDGZeot\n", - "fjSBOzp6dXjBuXn8f6WkZThCJWmc3A4svIH8U8DLkkwDJHlIks1LfO4UYP8wmfpZ4JwF780e/fwi\n", - "VwDPG96ndTrwJGA3P5pkSdKy/FeXpHFwdGToGmB+OHX3TuCtDKbbvpokwD7gV4blFz6i/Eng95Ls\n", - "Bb7OYNrvqLcD1yb5SlW98Ojnquofkzx22GYBr6mqfUkeuqhuljiWpHtw2QRJkqSOnPKTJEnqyIRK\n", - "kiSpIxMqSZKkjkyoJEmSOjKhkiRJ6siESpIkqSMTKkmSpI5MqCRJkjr6f002U8GpKcFcAAAAAElF\n", - "TkSuQmCC\n" + "AAALEgAACxIB0t1+/AAAD0ZJREFUeJzt3XvQXVdZx/HvL2+ubUoh0oJA2lAFJR2QIjDlTgGdykDx\n", + "gkBFQHRwHEAqAgN0Rv/SAYdxqAyDM0jlUm4qYIFRLlUqFJCGQtNbys2h2oI0SkNoapO8SR7/OCfN\n", + "2/Am2Ts76z3npN/PzDs5e5/n7PXkrJPkyVr7rJWqQpIkSUdv2aQTkCRJmnUWVJIkSQNZUEmSJA1k\n", + "QSVJkjSQBZUkSdJAFlSSJEkDLZ9k40lcs0GSJM2Mqspi55sWVEnOBS4C5oB3VdVfHByzfv36n3jd\n", + "9u3bOfnkk4+63b5ra+3du7dJbJ889u3b1zm2j2TRfj9m8Yu54447OPHEE4/69X3e4927d/e69vz8\n", + "fOfYPXv2dI7t09fTvPZbVQ3+DEzz70+SWmk25ZdkDng7cC6wETg/ycNatSdJkjQpLe+heizwnaq6\n", + "qarmgQ8Dz2nYniRJ0kS0LKgeCNy84PiW8bkjWrVqVZOEtDRWrFgx6RQkSVpSLQuqo76RYvXq1ccy\n", + "Dy2xlStXTjoFHaVjcQ+dJN0Ttbwp/XvAwjvO1zMapbqb7du33/V41apVFlOSJGnmtCyorgIekmQD\n", + "8H3g+cD5BwcN+TafJEnSNGhWUFXVniSvBD7DaNmEi6vqxlbtSZIkTUrTdaiq6lPAp1q2IUmSNGkT\n", + "XSkd+i2e2FXfhQX7LKrZKrbVIqB9Fwzts6jmNLxvfX9/rRaddDFLSbpncy8/SZKkgSyoJEmSBrKg\n", + "kiRJGsiCSpIkaSALKkmSpIEsqCRJkgayoJIkSRrIgkqSJGkgCypJkqSBLKgkSZIGsqCSJEkaaOJ7\n", + "+a1atWrSKfTSZ8+2VrF99tvru8dcn2v3ie2zZ2Of2Pn5+c6x0G6fwCS98mih5X6C7lUoSYfXdIQq\n", + "yfoklye5Icn1SV7Vsj1JkqRJaD1CNQ+8uqo2J1kLfC3JZVV1Y+N2JUmSlkzTEaqq+kFVbR4/3gHc\n", + "CDygZZuSJElLbcluSk+yATgLuHKp2pQkSVoKS1JQjaf7PgJcMB6pkiRJOm40/5ZfkhXAR4H3V9Wl\n", + "Bz+/bdu2ux6vXr2aNWvWtE5JkiTpmGpaUGX0XfKLgS1VddFiMfe5z31apiBJktRc6ym/JwC/DZyT\n", + "5Orxz7mN25QkSVpSTUeoquqLuBq7JEk6zlnsSJIkDTTxrWe6bjPSZ2uPltuATMMWHC3fiz7xy5Z1\n", + "r8dXrFjRObbPljZ9t57pE99n65k+5ubmOsf2eY/75jsN2wy1eo8laak5QiVJkjSQBZUkSdJAFlSS\n", + "JEkDWVBJkiQNZEElSZI0kAWVJEnSQBZUkiRJA1lQSZIkDWRBJUmSNJAFlSRJ0kAT33pm5cqVneL6\n", + "bH3RdzuLVtvJtNraYxa362i1HVDLrXX6vM99YvtszdLns9nycz8NWy5J0jQ7ZEGV5DeAAhb7F6iq\n", + "6mNdGkgyB1wF3FJVzz6qLCVJkqbY4Uaons2ooDqUTgUVcAGwBTipa1KSJEmz5JAFVVX9ztCLJ3kQ\n", + "8Ezgz4E/Hno9SZKkaXTEm9KT3D/JxUk+PT7emOT3Ol7/rcDrgNm76UeSJKmjLt/yew/wWeAB4+Nv\n", + "A68+0ouSPAvYWlVXs/h9WJIkSceFLgXVfavq74C9AFU1D3T5mtLjgfOSfBf4EPC0JO87OOi22267\n", + "6+fOO+/skbokSdJ06LJswo4kP7X/IMnZwPYjvaiqLgQuHL/mKcBrq+rFB8etW7eue7aSJElTqEtB\n", + "9Rrgk8AZSb4MnAI89yjaciEbSZJ0XEqXBfuSLAd+jtG9UN8cT/sNbzypM844o1OsC3se4MKeB/RZ\n", + "JBNgfr77R7dPbKs+cWFPSZouVbXoP2hHHKFKsgZ4OfBERqNMVyT566raeWxTlCRJmk1dpvzeB/wY\n", + "eBujEarfAi4BfrNhXpIkSTOjS0F1ZlVtXHD8uSRbjlUCt99+e6e4PtMZfacnWl271TRJq+mzvlq9\n", + "F32mP/tO+fW59jT09bTo85k73t8LSVpMl2UTvp7kcfsPxt/y+1q7lCRJkmbL4TZHvm5BzJeS3Mzo\n", + "HqrTgG8uQW6SJEkz4UibI0uSJOkIDrc58k0Lj5OcCqxunZAkSdKs6bI58nlJvg18F/g8cBPwqcZ5\n", + "SZIkzYwuN6X/GfA44FtV9WDg6cCVTbOSJEmaIV0Kqvmq+l9gWZK5qroceHTjvCRJkmZGl3WotiU5\n", + "CbgC+ECSrcCOtmlJkiTNjiPu5ZdkLXAno9GsFwL3Aj5QVT8c3HhSp5xySqdYF/Y8wIU9D3Bhz+nj\n", + "eyHpeHbUe/lV1f7RqL3Ae45hTpIkSceFwy3suYPRQp6Lqaq617FIYNeuXZ3i+ozKTMsITh+tRnBa\n", + "jta1GtlrORrpqJMkqYXDrUO1dujFk9wbeBdwJqPi7Her6itDrytJkjRNutyUPsRfAf9cVc9Nshw4\n", + "sXF7kiRJS65ZQZXkZOBJVfUSgKraA2xv1Z4kSdKkdFmH6mg9GPifJO9O8vUkf5PkhIbtSZIkTUTL\n", + "gmo58CjgHVX1KOAO4A0N25MkSZqIlgXVLcAtVfXV8fFHGBVYd7Nz5867fvquKSRJkjQNmt1DVVU/\n", + "SHJzkodW1beAZwA3HBy3evXqVilIkiQtidbf8vtDRtvVrAT+A3hp4/YkSZKWXNOCqqquAR7Tsg1J\n", + "kqRJa3kPlSRJ0j1C6ym/IyewvFsKc3Nzx/ya+61YsaJz7MqVKyce2+e+szVr1nSO7XvtE07ovgrG\n", + "2rXdF94/7bTTOsdu3LixcyzA6aef3jl23bp1nWP7vG+7d+/uHDs/P985dtmyfv8/6vO5P+mkk5rE\n", + "rlq1qnPs8b79lKTpd7i/WxyhkiRJGsiCSpIkaSALKkmSpIEsqCRJkgayoJIkSRrIgkqSJGkgCypJ\n", + "kqSBLKgkSZIGsqCSJEkayIJKkiRpoJnZeqbPVhJV1SuHPtt77N27t3Psrl27Osf22Takz3vRJ9+W\n", + "+uSxc+fOJrEAe/bs6RzbJ+c+n7k+/dd3O5k+9u3b1yS2758/SToeNB2hSvLGJDckuS7JB5N037hL\n", + "kiRpRjQrqJJsAF4GPKqqHg7MAS9o1Z4kSdKktJzy+zEwD5yQZC9wAvC9hu1JkiRNRLMRqqq6DfhL\n", + "4L+A7wM/qqp/adWeJEnSpLSc8vsZ4I+ADcADgLVJXtiqPUmSpElpeVP6o4EvV9UPq2oP8DHg8QcH\n", + "7dix466f3bt3N0xHkiSpjZb3UH0D+JMka4CdwDOATQcHrV27tmEKkiRJ7bW8h+oa4H3AVcC149Pv\n", + "bNWeJEnSpGSSi/AlqVNPPbVrbJ/r9s2jc2yfhRZbxbqw59HFggt7LuTCnpLUX1Ut+pe4W89IkiQN\n", + "ZEElSZI00Mzs5ddSq+nEPrF9plRa7mvYauqqz3X7THPNzc11ju2bR6u+noZp477xfb6B2ye21bSq\n", + "JC01R6gkSZIGsqCSJEkayIJKkiRpIAsqSZKkgSyoJEmSBrKgkiRJGmgqC6pdu3ZNOgUN0Hf1ck2P\n", + "+fn5SacgSTPJgkrHnP03u/pszSNJOmAqCypJkqRZYkElSZI0UCa5nUMS95KQJEkzo6oW3WtsogWV\n", + "JEnS8cApP0mSpIEsqCRJkgaauoIqyblJvpHk20leP+l8dGhJ/jbJrUmuW3BuXZLLknwryWeT3HuS\n", + "OerQkqxPcnmSG5Jcn+RV4/P24ZRLsjrJlUk2J9mS5E3j8/bdDEkyl+TqJJ8cH9t/M2yqCqokc8Db\n", + "gXOBjcD5SR422ax0GO9m1FcLvQG4rKoeCvzr+FjTaR54dVWdCZwNvGL8580+nHJVtRM4p6oeCTwC\n", + "OCfJE7HvZs0FwBZg/83M9t8Mm6qCCngs8J2quqmq5oEPA8+ZcE46hKq6Ath20OnzgPeOH78X+NUl\n", + "TUqdVdUPqmrz+PEO4EbggdiHM6Gq/m/8cCUwx+jPon03I5I8CHgm8C5g/7fG7L8ZNm0F1QOBmxcc\n", + "3zI+p9lxv6q6dfz4VuB+k0xG3STZAJwFXIl9OBOSLEuymVEfXV5VN2DfzZK3Aq8D9i04Z//NsGkr\n", + "qFzD4ThSozU57NMpl2Qt8FHggqq6feFz9uH0qqp94ym/BwFPTnLOQc/bd1MqybOArVV1NQdGp+7G\n", + "/ps901ZQfQ9Yv+B4PaNRKs2OW5PcHyDJTwNbJ5yPDiPJCkbF1CVVden4tH04Q6pqO/BPwC9i382K\n", + "xwPnJfku8CHgaUkuwf6badNWUF0FPCTJhiQrgecDn5hwTurnE8BLxo9fAlx6mFhNUJIAFwNbquqi\n", + "BU/Zh1MuyX33fwMsyRrgl4Crse9mQlVdWFXrq+rBwAuAz1XVi7D/ZtrUrZSe5FeAixjdZHlxVb1p\n", + "winpEJJ8CHgKcF9G8/1/Cnwc+HvgNOAm4HlV9aNJ5ahDG38r7AvAtRyYWngjsAn7cKoleTijm5aX\n", + "jX8uqaq3JFmHfTdTkjwFeE1VnWf/zbapK6gkSZJmzbRN+UmSJM0cCypJkqSBLKgkSZIGsqCSJEka\n", + "yIJKkiRpIAsqSZKkgSyoJE1cki+Nfz09yfnH+NoXLtaWJB1LrkMlaWokeSqjRQ6f3eM1y6tqz2Ge\n", + "v72qTjoW+UnSoThCJWnikuwYP3wz8KQkVye5IMmyJG9JsinJNUl+fxz/1CRXJPk4cP343KVJrkpy\n", + "fZKXjc+9GVgzvt4lC9vKyFuSXJfk2iTPW3Dtf0vyD0luTPL+pX03JM2i5ZNOQJI4sPXN64HX7h+h\n", + "GhdQP6qqxyZZBXwxyWfHsWcBZ1bVf46PX1pV28Z7221K8pGqekOSV1TVWYu09evALwCPAE4Bvprk\n", + "C+PnHglsBP4b+FKSJ1SVU4WSDskRKknTJAcd/zLw4iRXA18B1gE/O35u04JiCuCCJJuBfwfWAw85\n", + "QltPBD5YI1uBzwOPYVRwbaqq79fonojNwIYBvydJ9wCOUEmadq+sqssWnhjfa3XHQcdPB86uqp1J\n", + "LgdWH+G6xU8WcPtHr3YtOLcX/66UdASOUEmaJrcDC28g/wzw8iTLAZI8NMkJi7zuXsC2cTH188DZ\n", + "C56b3//6g1wBPH98n9YpwJOBTfxkkSVJR+T/uiRNg/0jQ9cAe8dTd+8G3sZouu3rSQJsBX5tHL/w\n", + "K8qfBv4gyRbgm4ym/fZ7J3Btkq9V1Yv2v66q/jHJ48ZtFvC6qtqa5GEHXZtFjiXpblw2QZIkaSCn\n", + "/CRJkgayoJIkSRrIgkqSJGkgCypJkqSBLKgkSZIGsqCSJEkayIJKkiRpIAsqSZKkgf4fuHwpG022\n", + "rncAAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -3822,7 +3866,7 @@ "pDExN0zSmJgbJmlMzA2TNCbmhkkaE3Pj/wFJ7Hv45ZreFAAAAABJRU5ErkJggg==\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -3832,90 +3876,90 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAEeFJREFUeJzt3X+QXWV9x/HPJ7vZ3WySjaQhWpKY8LvAYIUiA4ga1Hao\n", - "I2hbK9BWqe3Y6ag1pZYRmWn/YNrRynREx2lnLBQFK7ZFizotCC1EESsRSPgVhNAhLSGFkIbdbJL9\n", - "mXz7x70bLsv+eJ6cPHvvDe/XzE7uOfu953n2PGfvfnN+PF9HhAAAAHDo5jW7AwAAAO2OhAoAAKAi\n", - "EioAAICKSKgAAAAqIqECAACoiIQKAACgos5mNm6bORsAAEDbiAhPtb5oQmX7QknXSeqQdH1E/NXk\n", - "mFWrVr3qfQMDA1qyZMkr1nV0dCS3O29e3om3AwcOJMfu378/OTZnjq+c2JyfL2e/HUr8VHbt2qWl\n", - "S5e+Yl2p/ZYzdiW3nfPzDQ8PJ8eOjo4mx+Ye91ON9fDwsHp6epJip9PZmf6x0tXVlRy7d+/e5Nic\n", - "fSxJY2NjybE5x0WrzPNnT/n5P6Wc46i7uzs5tq+vLzl28ufH4dquVO5YHhwcTI598cUXX7Vuqr97\n", - "ktTf35+8XSnv2G+Fv2dHkmKX/Gx3SPqypAslnSrpMtunlGoPAACgWUreQ3W2pKcjYmtEjEn6pqT3\n", - "FWwPAACgKUomVCskPduwvK2+blY5p5HRehYsWNDsLuAQ5VziAHD48Hev/ZVMqA75IupU93CgfZBQ\n", - "tS8SKqA5+LvX/kp+ej4nqfGO81WqnaV6hYGBgYOvu7u7OagAAEDbKZlQPSDpRNtrJG2XdImkyyYH\n", - "TfVUAwAAQDspllBFxLjtT0j6vmrTJtwQEU+Uag8AAKBZit4wERG3S7q9ZBsAAADN5mZOwGU7VqxI\n", - "evCv6GSPOfE5saUm08uJzemDVG4/l5oMMff4LTUpas7N3Dl9GBoaSo4dGRlJjs2NHx8fT4490if1\n", - "a8efL6fPuZ8ZJeT0oWR/W2Gsc/vQCn0+0k03Uzq1/AAAACoioQIAAKiIhAoAAKAiEioAAICKSKgA\n", - "AAAqIqECAACoiIQKAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAAoKKixZFT7N27Nymup6cneZsL\n", - "Fy7M6sOSJUuSY/v6+pJjc/qcY8+ePcmxw8PDxba9b9++5NixsbHk2FI1AqW8+nzd3d3JsYsXL06O\n", - "XbZsWXJsTo3A/fv3J8dK0q5du5Jjd+7cmRybU/cv53fvuOOOS44966yzkmMlaeXKlcmxq1evTo7N\n", - "+SwaGBhIju3v70+OlaQdO3Ykx3Z1dSXH5tSlHBwcTI7dsmVLcmzOZ0uunN+ppUuXJseefvrpybHH\n", - "H398cqyU9zuV87nV29ubHLto0aLk2AULFiTH5hybUl6dx9QaiDMd80XPUNleZfse24/bfsz2J0u2\n", - "BwAA0Aylz1CNSboiIjbZXiTpQdt3RcQThdsFAACYM0XPUEXE8xGxqf56j6QnJB1Tsk0AAIC5Nmc3\n", - "pdteI+kMSffPVZsAAABzYU4SqvrlvlslraufqQIAADhiFH/Kz/Z8Sd+S9PWIuG3y94eGhl7uTGen\n", - "5s+fX7pLAAAAs1q/fr3Wr1+fFFs0oXLtmcUbJG2OiOumisl5ZBIAAGCurF27VmvXrj24fM0110wb\n", - "W/qS31sl/Y6kC2xvrH9dWLhNAACAOVX0DFVE/EjMxg4AAI5wJDsAAAAVOXW69SKN23HyyScnxeaU\n", - "AMgpfZG77ZwyB6X2bc52c6bel/JKSeT0I6dkQM6DCTnlYaS8ny+n7EvOvhgZGUmOHR0dLbJdKe/3\n", - "pFR5j5zjIudYTi1pNSFnP+fst5zjIufYzD3uc+5VzTnuc46LnH2cUzIr9/O+1OdyzvGZE5tzXEh5\n", - "P18rxOZoZr7SKCKmHEDOUAEAAFREQgUAAFARCRUAAEBFJFQAAAAVkVABAABUREIFAABQEQkVAABA\n", - "RSRUAAAAFZFQAQAAVERCBQAAUFHTS88sWbKkxHaLxqc6cOBAcmxO+Zuc7ebESnlT++duu0QfSh6/\n", - "rdCPVim1AAComa70zLRFm2z/hqSQNNUbIyK+ndKw7Q5JD0jaFhEXpbwHAACgncxUBfMi1RKq6SQl\n", - "VJLWSdosaXFqpwAAANrJtAlVRPxu1Y3bXinpPZL+UtKfVN0eAABAK5r1pnTbb7B9g+076sun2v79\n", - "xO1/QdKVksrcbAMAANACUp7y+6qkOyUdU1/eIumK2d5k+72SdkTERk19HxYAAMARISWhWhYR/yhp\n", - "vyRFxJik8YT3nSfpYtvPSLpF0jtt3zQ5aHh4+ODX+HjKZgEAAFpLSkK1x/bPTSzYPkfSwGxvioir\n", - "I2JVRBwr6VJJd0fEhyfH9fT0HPzq7JzpHnkAAIDWlJLBfErS9yQdZ/vHko6W9IFDaIsJdQAAwBEp\n", - "aWJP252STlbtXqgn65f9qjfOxJ4HMbHnofWBiT0BAHMpe2LPCbYXSPqYpPNVO8t0r+2/jYjhw9tF\n", - "AACA9pRyye8mSbslfUm1M1S/JelmSb9ZsF8AAABtIyWhOi0iTm1Yvtv25sPVge7u7sO1qYNKXcKT\n", - "8i7B5PSjo6MjOXb+/PlFYiVlPRiQ0+ecfdHT05Mcm/sgQ1dXV3LsvHnptcNznlDNie3r60uO7e3t\n", - "TY6VpNWrVyfHnnDCCcmxOWOydevW5Njt27cnx27cuDE5VpJ2796dHLt3796sbac66qijkmNzfkek\n", - "vON+dHQ0OTZnrHM+65cvX54cu2fPnuRYSRoaGkqO3bdvX3Lstm3bkmMHBweTY3NuB5HK3YpxpEv9\n", - "GzVTDpDyF+Mh2+c2NHqOpAeTWgYAAHgNmKk48qMNMffZfla1e6jeKOnJOegbAABAW5itODIAAABm\n", - "MVNx5K2Ny7aXS8q7cA8AAPAakFIc+WLbWyQ9I+kHkrZKur1wvwAAANpGyk3pfyHpXElP1cvIvEvS\n", - "/UV7BQAA0EZSEqqxiNgpaZ7tjoi4R9JZhfsFAADQNlImEXnJ9mJJ90r6B9s7JOVN/AEAAHAESzlD\n", - "9X5J+yRdIekOSU+LJwABAAAOmvUMVURMnI3aL+mrRXsDAADQhjzdNOq296g2kedUIiLSa2JM17gd\n", - "K1asqLqZV8kpGSLlTdVfKrZUSZvcfVFy2yX6kFtmKKfsS46c8hBjY2NFtpsrpyxRTtmQnO2WKjOU\n", - "W9Iqp3xJTuzIyEhybM5nQE7ZJylvP+f0Oef3KWf8ckrl5JbXyinRlBObUzpo586dybE5JW0kaWBg\n", - "IDk257OoVEmbnOM+V4kydBGhiJhywzPNQ7WoasO2XyfpekmnqZac/V5E/KTqdgEAAFpJXmXZfF+U\n", - "9G8R8QHbnZIWFm4PAABgzhVLqGwvkfS2iLhckiJiXFL6uUgAAIA2UeYmmJpjJb1o+0bbD9n+O9vp\n", - "F6QBAADaRMmEqlPSmZL+JiLOlLRX0lUF2wMAAGiKkvdQbZO0LSJ+Wl++VVMkVLt37z74uru7O/vp\n", - "HAAAgBJynkIsllBFxPO2n7V9UkQ8Jendkh6fHNfXV3n2BQAAgMNu8tQLMyVYpZ/y+yPVytV0Sfov\n", - "SR8p3B4AAMCcK5pQRcTDkt5Ssg0AAIBmK3lTOgAAwGtC6Ut+s0otG5BT4mB0dDSrDznbzikFUqr0\n", - "TMmp+kttu1XKFrRCmaFS+wIA8LKSfyunwhkqAACAikioAAAAKiKhAgAAqIiECgAAoCISKgAAgIpI\n", - "qAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqanrpmbGxsaS4UiVfcs2bl56DdnR0FNluZ2f6\n", - "sOVsV5J6enqSYxcuXJgc29XVlRybUwoo9fg5lG0PDw8X6UfOvsgZj5zjQsr7+fr7+5Njh4aGkmNL\n", - "lezJ2W+S1NvbmxWfKqfPOZ9xObFSa5SUyikJlvvz5ShVEiy1jJqUd3wuWrQoOTY3vlRJt5zPgJzY\n", - "3LJyJUq6zXRsFj1DZfszth+3/ajtb9juLtkeAABAMxRLqGyvkfRRSWdGxOmSOiRdWqo9AACAZil5\n", - "yW+3pDFJvbb3S+qV9FzB9gAAAJqi2BmqiNgl6a8l/Y+k7ZL6I+LfS7UHAADQLCUv+R0v6Y8lrZF0\n", - "jKRFtn+7VHsAAADNUvKm9LMk/Tgi/i8ixiV9W9J5k4N279598GtkZKRgdwAAANJFhA4cOHDwayYl\n", - "76H6maQ/s71A0rCkd0vaMDmor6+vYBcAAAAOjW3ZPrjclGkTIuJhSTdJekDSI/XVXynVHgAAQLMU\n", - "ndgzIj4v6fMl2wAAAGg2Ss8AAABUREIFAABQkUvVeEpq3I7ly5cnxTazn40ab06bTYk6QrmxuTWx\n", - "StVWK1WLMbduY6n93G59KL1tADhSRcSUiQBnqAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAq\n", - "IqECAACoqCUTqtHR0WZ3ARWMj483uwsAAMwpEiocdrlzXwEA0O5aMqECAABoJyRUAAAAFTW99EzT\n", - "GgcAAMg0XemZpiZUAAAARwIu+QEAAFREQgUAAFBRyyVUti+0/TPbW2x/utn9wfRs/73tF2w/2rBu\n", - "qe27bD9l+07br2tmHzE926ts32P7cduP2f5kfT1j2OJs99i+3/Ym25ttf7a+nrFrI7Y7bG+0/b36\n", - "MuPXxloqobLdIenLki6UdKqky2yf0txeYQY3qjZWja6SdFdEnCTpP+rLaE1jkq6IiNMknSPp4/Xf\n", - "N8awxUXEsKQLIuLNkt4k6QLb54uxazfrJG2WNHEzM+PXxloqoZJ0tqSnI2JrRIxJ+qak9zW5T5hG\n", - "RNwr6aVJqy+W9LX6669Jev+cdgrJIuL5iNhUf71H0hOSVogxbAsRsa/+sktSh2q/i4xdm7C9UtJ7\n", - "JF0vaeKpMcavjbVaQrVC0rMNy9vq69A+Xh8RL9RfvyDp9c3sDNLYXiPpDEn3izFsC7bn2d6k2hjd\n", - "ExGPi7FrJ1+QdKWkAw3rGL821moJFXM4HEGiNicHY9ribC+S9C1J6yJisPF7jGHriogD9Ut+KyW9\n", - "3fYFk77P2LUo2++VtCMiNurls1OvwPi1n1ZLqJ6TtKpheZVqZ6nQPl6w/QZJsv3zknY0uT+Yge35\n", - "qiVTN0fEbfXVjGEbiYgBSf8q6ZfE2LWL8yRdbPsZSbdIeqftm8X4tbVWS6gekHSi7TW2uyRdIum7\n", - "Te4T8nxX0uX115dLum2GWDSRbUu6QdLmiLiu4VuMYYuzvWziCTDbCyT9sqSNYuzaQkRcHRGrIuJY\n", - "SZdKujsiPiTGr6213Ezptn9V0nWq3WR5Q0R8tsldwjRs3yLpHZKWqXa9/88lfUfSP0l6o6Stkj4Y\n", - "Ef3N6iOmV38q7IeSHtHLlxY+I2mDGMOWZvt01W5anlf/ujkirrW9VIxdW7H9DkmfioiLGb/21nIJ\n", - "FQAAQLtptUt+AAAAbYeECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioATWf7vvq/q21f\n", - "dpi3ffVUbQHA4cQ8VABahu21qk1yeFHGezojYnyG7w9GxOLD0T8AmA5nqAA0ne099Zefk/Q22xtt\n", - "r7M9z/a1tjfYftj2H9Tj19q+1/Z3JD1WX3eb7QdsP2b7o/V1n5O0oL69mxvbcs21th+1/YjtDzZs\n", - "e73tf7b9hO2vz+3eANCOOpvdAQDQy6VvPi3pTyfOUNUTqP6IONt2t6Qf2b6zHnuGpNMi4r/ryx+J\n", - "iJfqte022L41Iq6y/fGIOGOKtn5d0i9KepOkoyX91PYP6997s6RTJf2vpPtsvzUiuFQIYFqcoQLQ\n", - "Sjxp+Vckfdj2Rkk/kbRU0gn1721oSKYkaZ3tTZL+U9IqSSfO0tb5kr4RNTsk/UDSW1RLuDZExPao\n", - "3ROxSdKaCj8TgNcAzlABaHWfiIi7GlfU77XaO2n5XZLOiYhh2/dI6pllu6FXJ3ATZ69GGtbtF5+V\n", - "AGbBGSoArWRQUuMN5N+X9DHbnZJk+yTbvVO8r0/SS/Vk6hckndPwvbGJ909yr6RL6vdpHS3p7ZI2\n", - "6NVJFgDMiv91AWgFE2eGHpa0v37p7kZJX1LtcttDti1ph6Rfq8c3PqJ8h6Q/tL1Z0pOqXfab8BVJ\n", - "j9h+MCI+NPG+iPgX2+fW2wxJV0bEDtunTNq2plgGgFdg2gQAAICKuOQHAABQEQkVAABARSRUAAAA\n", - "FZFQAQAAVERCBQAAUBEJFQAAQEUkVAAAABWRUAEAAFT0/9KDBwoLkjK0AAAAAElFTkSuQmCC\n" + "AAALEgAACxIB0t1+/AAAEbZJREFUeJzt3X+QXeVdx/HPJ5vdTXaTGAIhIcliooIC01qwMEChKbQ6\n", + "2Cm0ai1FbbE6dZy2NmLLlDKjf+G0tuMUOx2dqSAt1FKVVtqO8kuLKaWUFEjCj1AgDigkkohJyO4m\n", + "2exuvv5xb8Jmsz+eJyfP3nvC+zWT4Z5zv/c8z73PuXe/nB/P1xEhAAAAHL1Zre4AAABA3ZFQAQAA\n", + "VERCBQAAUBEJFQAAQEUkVAAAABWRUAEAAFQ0u5WN22bOBgAAUBsR4YnWF02obF8m6UZJHZJuioi/\n", + "GB+zZMmSI143MDCgefPmHXW7uXNr5cQfOHAgtzvHvA/2hGM5oY6Ojqx+5MTPmjXxAc7du3drwYIF\n", + "R73dnPeXO9Y54zc0NJQcu3///iKxw8PDybE5n9tk8SMjI5o9+8ifhc7OzuTtzpkzJzl2orYmMzAw\n", + "kBybM3aSNDo6mhx7vM/dN9n3eiI53+vu7u7k2Pnz5yfH9vb2Jsfm9iPH4OBgcmx/f/8R6/bs2aOe\n", + "np4j1u/evTurHyMjI8mxx/u+PNOKnfKz3SHpS5Iuk3SmpKtsn1GqPQAAgFYpeQ3VeZI2R8QLETEs\n", + "6RuS3l2wPQAAgJYomVAtl/TimOWXmuum1dXVVaRDmBmlDqmjvJzTPQCOnZzT6mhPJX89j/rkLAlV\n", + "vZFQ1RcJFdAaJFT1V/Ki9C2S+sYs96lxlOowYy807erqIpkCAAC1UzKhekTSabZXStoq6UpJV40P\n", + "qnI3HwAAQDsollBFxIjtj0m6R41pE26OiKdLtQcAANAqReehioi7JN1Vsg0AAIBWcysn9rIdfX19\n", + "0weq7MWyOZ9BqQk420XOBIelJkPMiS05cWnOpJM5sTnvL2eywNzJLHMmAMwZ63aQMyGqlDfha05s\n", + "HSdOLPW7VWpC4tz+lhrrUtqhDzjcZDOlc0sPAABARSRUAAAAFZFQAQAAVERCBQAAUBEJFQAAQEUk\n", + "VAAAABWRUAEAAFREQgUAAFARCRUAAEBFJFQAAAAVkVABAABUVLQ4corUGn2l6kDlxufUFCxZj6pE\n", + "H3L70Q51ynJrzOWMX059vjlz5iTHdnZ2JsfmvL/u7u7kWCmv3t2ePXuSY3t6epJjTzzxxOTYk08+\n", + "OTl2//79ybGStHDhwuTYVatWZW07Vc4+1Nvbm7XtnDqP8+fPT47t6upKjt2xY0dy7D333JMcu3Xr\n", + "1uRYKW9fzqmjl/O5XXrppcmxF198cXKsJC1btiw5Nmc/yvks5s6dmxyb87nlfEdypf4eTrXPFz1C\n", + "ZbvP9v22n7L9pO2Pl2wPAACgFUofoRqWdE1EbLA9T9Kjtu+LiKcLtwsAADBjih6hioiXI2JD8/GA\n", + "pKclpR+PBAAAqIEZuyjd9kpJZ0t6eKbaBAAAmAkzklA1T/fdIWlN80gVAADAcaP4XX62OyV9U9LX\n", + "IuLO8c/v2rXr0OM5c+YUvYofAAAg1dq1a7V27dqk2KIJlRv34N8saVNE3DhRTM7tygAAADNl9erV\n", + "Wr169aHlG264YdLY0qf83iLpdyRdYnt9899lhdsEAACYUUWPUEXED8Rs7AAA4DhHsgMAAFCRW1k+\n", + "xHaceuqpqbHJ2819TzlT6ueUAsnpR05sqT5IeZ9FTmyp0jq5282JzylTkxObMyYjIyPJsbnlVkqN\n", + "dY6c8cjpQ87nlqsdSi7llEXKjS+1f7bD/tYuckqC5Y51qb9nx/uY5IiICX+4OEIFAABQEQkVAABA\n", + "RSRUAAAAFZFQAQAAVERCBQAAUBEJFQAAQEUkVAAAABWRUAEAAFREQgUAAFARCRUAAEBFRYsjpxge\n", + "Hk6KKzlFfqkSMaVKLeTEliyTkbPtdik9U7eyGu0y1mgvqb+bRxuPsnL+nuXEorUmTahs/4akkDTR\n", + "X6yIiG+lNGC7Q9Ijkl6KiMuPqpcAAABtbKojVJerkVBNJimhkrRG0iZJ81M7BQAAUCeTJlQR8btV\n", + "N257haR3SvpzSX9SdXsAAADtaNqL0m0vtX2z7buby2fa/v3E7X9B0rWS8i5qAgAAqJGUu/y+Iule\n", + "Scuay89Juma6F9l+l6TtEbFeE1+HBQAAcFxISahOioh/kDQqSRExLCnl9qcLJV1h+3lJt0u61Pat\n", + "44P6+/sP/RsaGsroOgAAQHtImTZhwPaJBxdsny/p1eleFBHXS7q++ZrVkj4ZER8cHzd/PteqAwCA\n", + "ektJqD4h6buSfsb2DyUtlvTeo2iLSXIAAMBxySmTAdqeLenn1bgW6pnmab/qjdtxyimnJMUysefR\n", + "xTKx5+GY2BMAUEVETPiHZ9ojVLbnSvqIpIvUOMr0gO2/iYh9x7aLAAAA9ZRyyu9WSbslfVGNI1S/\n", + "Jek2Sb9ZsF8AAAC1kZJQnRURZ45Z/p7tTcesA7PTygnOmpVexzn31EfuKcIS/ejo6Gh5rJQ+Hu0S\n", + "mzvWpU7ZlqqVtnjx4uTYhQsXZm17xYoVybFLly5Njt22bVty7MaNG5Njt2zZkhy7c+fO5Nhcpfah\n", + "np6e5NjOzs7kWEnq6upKjs252zrnlHvO9zqnv4ODg8mxUt77y7Fnz57k2JzLCXJr+XHq/+ik7stT\n", + "fb4pWcpjti8Y0+j5kh5NahkAAOB1YKriyE+MiXnQ9otqXEN1qqRnZqBvAAAAtTBdcWQAAABMY6ri\n", + "yC+MXbZ9sqQ5pTsEAABQNynFka+w/Zyk5yWtlfSCpLsK9wsAAKA2Ui5Kv0HSBZKejYhVkt4u6eGi\n", + "vQIAAKiRlIRqOCJekTTLdkdE3C/pzYX7BQAAUBspE4PstD1f0gOS/t72dkkDZbsFAABQHylHqN4j\n", + "aY+kayTdLWmzuAMQAADgkGmPUEXEwaNRo5K+UrQ3AAAANeTJplG3PaDGRJ4TiYhYULlxO1JLa+SU\n", + "UMkpcZC77ZzYkuVy2kGpPueUs8gtwZGju7s7OTZnn8spfdHf358cOzCQdyY+pyxKzvtbtGhRcuyy\n", + "ZcuSY3NK5Sxfvjw5VpI2b96cHLthw4bk2JwyPDnli3K/e6V+t3K+I0uWLEmOPffcc5Njc/YhKW//\n", + "zPl9ySkns3bt2uTYhx56KDlWknbt2pUcm1PWph1+73Pl7Mup5Y727t2riJiw01PNQzUvuSeTsL1Q\n", + "0k2SzlIjOfu9iPhR1e0CAAC0k7xDOfn+StK/RsR7bc+W1Fu4PQAAgBlXLKGy/VOSLo6IqyUpIkYk\n", + "vVqqPQAAgFZJP8GYb5Wk/7V9i+3HbP+t7Z6C7QEAALREyYRqtqRzJP11RJwjaVDSdQXbAwAAaImS\n", + "11C9JOmliPhxc/kOTZBQDQ4OHnrc2dmZfKU9AABASaOjo8l3RBdLqCLiZdsv2j49Ip6V9A5JT42P\n", + "6+3lOnUAANB+Ojo6Dpt2ZKrpMUrf5fdHapSr6ZL0n5I+VLg9AACAGVc0oYqIjZLSZ2gDAACooZIX\n", + "pQMAALwuTFp6ZkYat2Pp0qWpsSX7UWzbqXLKgJSKlfJKEZSKzZE7djn7e6n3l1Oioo4liQDgeDZZ\n", + "6RmOUAEAAFREQgUAAFARCRUAAEBFJFQAAAAVkVABAABUREIFAABQEQkVAABARSRUAAAAFZFQAQAA\n", + "VERCBQAAUFHR4sgpUkt2tEvpmVmz0nPQnNju7u7k2Jz+5pYu6ejoSI6dPbvM7pNTmqVUSRspv2xP\n", + "qhNOOKFIbGdnZ1Y/du3alRy7Y8eO5NjBwcHk2KGhoeTY/fv3J8f29PQkx0pSagksSVqyZEly7LJl\n", + "y5Jj+/v7k2NfeeWV5FhJGh4eTo7du3dvcuzu3buLxOb8BuTK2Y9yzJ07Nzl2wYIFRbYr5f1u5fx+\n", + "5vze79u3Lzk2Z7/I2TelvM8i9W/lVN+lokeobH/a9lO2n7D9ddvpWQMAAEBNFEuobK+U9GFJ50TE\n", + "GyR1SHp/qfYAAABapeQpv92ShiX12B6V1CNpS8H2AAAAWqLYEaqI2CHpLyX9t6StknZFxL+Vag8A\n", + "AKBVSp7y+1lJfyxppaRlkubZ/u1S7QEAALRKyYvS3yzphxHxfxExIulbki4cHzQ4OHjoX6m7LwAA\n", + "AHIdOHBAo6Ojh/5NpeQ1VD+R9Ke250raJ+kdktaND+rt7S3YBQAAgKMzfvqjqaZiKHkN1UZJt0p6\n", + "RNLjzdVfLtUeAABAqxSd2DMiPifpcyXbAAAAaDVKzwAAAFREQgUAAFCRc2u9HdPG7ejr60uKzak5\n", + "lFuDLeczyInN6UeJmkNSfq27Uv0o9VmUHOtS222HWADA0YmICQvqcoQKAACgIhIqAACAikioAAAA\n", + "KiKhAgAAqIiECgAAoCISKgAAgIraMqHat29fq7uACnKnagAAoO7aMqEaGhpqdRdQAQkVAOD1pi0T\n", + "KgAAgDohoQIAAKio5aVnWtY4AABApslKz7Q0oQIAADgecMoPAACgIhIqAACAitouobJ9me2f2H7O\n", + "9qda3R9Mzvbf2d5m+4kx6xbZvs/2s7bvtb2wlX3E5Gz32b7f9lO2n7T98eZ6xrDN2Z5j+2HbG2xv\n", + "sv2Z5nrGrkZsd9heb/u7zWXGr8baKqGy3SHpS5Iuk3SmpKtsn9HaXmEKt6gxVmNdJ+m+iDhd0r83\n", + "l9GehiVdExFnSTpf0keb3zfGsM1FxD5Jl0TEmyS9UdIlti8SY1c3ayRtknTwYmbGr8baKqGSdJ6k\n", + "zRHxQkQMS/qGpHe3uE+YREQ8IGnnuNVXSPpq8/FXJb1nRjuFZBHxckRsaD4ekPS0pOViDGshIvY0\n", + "H3ZJ6lDju8jY1YTtFZLeKekmSQfvGmP8aqzdEqrlkl4cs/xScx3qY0lEbGs+3iZpSSs7gzS2V0o6\n", + "W9LDYgxrwfYs2xvUGKP7I+IpMXZ18gVJ10o6MGYd41dj7ZZQMYfDcSQac3Iwpm3O9jxJ35S0JiL6\n", + "xz7HGLaviDjQPOW3QtJbbV8y7nnGrk3Zfpek7RGxXq8dnToM41c/7ZZQbZHUN2a5T42jVKiPbbaX\n", + "SpLtUyRtb3F/MAXbnWokU7dFxJ3N1YxhjUTEq5L+RdIvibGriwslXWH7eUm3S7rU9m1i/Gqt3RKq\n", + "RySdZnul7S5JV0r6Tov7hDzfkXR18/HVku6cIhYtZNuSbpa0KSJuHPMUY9jmbJ908A4w23Ml/bKk\n", + "9WLsaiEiro+IvohYJen9kr4XER8Q41drbTdTuu1flXSjGhdZ3hwRn2lxlzAJ27dLWi3pJDXO9/+Z\n", + "pG9L+kdJp0p6QdL7ImJXq/qIyTXvCvu+pMf12qmFT0taJ8awrdl+gxoXLc9q/rstIj5ve5EYu1qx\n", + "vVrSJyLiCsav3touoQIAAKibdjvlBwAAUDskVAAAABWRUAEAAFREQgUAAFARCRUAAEBFJFQAAAAV\n", + "kVABaDnbDzb/+9O2rzrG275+orYA4FhiHioAbcP229SY5PDyjNfMjoiRKZ7vj4j5x6J/ADAZjlAB\n", + "aDnbA82Hn5V0se31ttfYnmX787bX2d5o+w+a8W+z/YDtb0t6srnuTtuP2H7S9oeb6z4raW5ze7eN\n", + "bcsNn7f9hO3Hbb9vzLb/w/Y/2X7a9tdm9tMAUEezW90BANBrpW8+JemTB49QNROoXRFxnu1uST+w\n", + "fW8z9mxJZ0XEfzWXPxQRO5u17dbZviMirrP90Yg4e4K2fl3SL0p6o6TFkn5s+/vN594k6UxJ/yPp\n", + "QdtviQhOFQKYFEeoALQTj1v+FUkftL1e0o8kLZL0c83n1o1JpiRpje0Nkh6S1CfptGnaukjS16Nh\n", + "u6S1ks5VI+FaFxFbo3FNxAZJKyu8JwCvAxyhAtDuPhYR941d0bzWanDc8tslnR8R+2zfL2nONNsN\n", + "HZnAHTx6NTRm3aj4rQQwDY5QAWgn/ZLGXkB+j6SP2J4tSbZPt90zwesWSNrZTKZ+QdL5Y54bPvj6\n", + "cR6QdGXzOq3Fkt4qaZ2OTLIAYFr8XxeAdnDwyNBGSaPNU3e3SPqiGqfbHrNtSdsl/VozfuwtyndL\n", + "+kPbmyQ9o8Zpv4O+LOlx249GxAcOvi4i/tn2Bc02Q9K1EbHd9hnjtq0JlgHgMEybAAAAUBGn/AAA\n", + "ACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqIqECAACoiIQKAACgIhIqAACAiv4fPgLxE2ST8JkA\n", + "AAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -4000,7 +4044,7 @@ "y8xY0VhmxorGMjNWNJaZsaKxzIwVjWVmrGgsM/N/z4EQsKT2Kt0AAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -4010,79 +4054,80 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAD2tJREFUeJzt3XuwnVdZx/HvLydJ25OEdmqxLRAMKijtgBSBKXcK6FQG\n", - "CioCVQHRwXEAqRUZLjP6lw4I41AZRmewlUsRUAELjHKpUqGANBSS3rk5VFuQxkuBXKbpOcnjH3sn\n", - "nB5Okv3mzTr73en3M7On+3332u9aZ699Tp6utd71pKqQJEnS0Vsz7QZIkiTNOgMqSZKkngyoJEmS\n", - "ejKgkiRJ6smASpIkqScDKkmSpJ7WTrPyJO7ZIEmSZkZVZaXzTQOqJOcDlwBzwKVV9afLy5x55pk/\n", - "9L6dO3eyadOmo653//79ncrv27evybVbXbdL2a77jB2LdiwuLrJ27T2/Wl3a0aosdP9utGqHJOn4\n", - "0mzKL8kc8DbgfOAs4MIkD21VnyRJ0rS0XEP1GOAbVXVrVS0A7wee3bA+SZKkqWgZUN0fuG3J8e3j\n", - "c0e0fv36Jg3S6lizxnsdJEn3Li3/5TvqRSUnnHDCsWyHVpkBlSTp3qblovRvAZuXHG9mNEp1Dzt3\n", - "7jz4fP369QZTkiRp5rQMqK4FHpxkC/Bt4PnAhcsL9bmbT5IkaQiaBVRVtZjkFcAnGG2bcFlV3dKq\n", - "PkmSpGlpug9VVX0M+FjLOiRJkqZtqjulA2zYsGGicl0WOnddFN3q2ieeeGKTspN+ZgDz8/MTl+3a\n", - "ji5lu6yN6/LznXzyyROXBTjjjDMmLrvSprOHcvrpp09c9pRTTpm47PINUo9VWYBkxc1+VzQ3N9ek\n", - "HV2u2+Xu35Y3RnT53LqUbfk3rotWP1+rsse7rpsGu8nw0Zn0czvc3zdvx5IkSerJgEqSJKknAypJ\n", - "kqSeDKgkSZJ6MqCSJEnqyYBKkiSpJwMqSZKkngyoJEmSejKgkiRJ6smASpIkqScDKkmSpJ4yzbw/\n", - "Seq0006bqGyX/GBdcn51Ld8qT9m+ffsmLruwsNCkLMDdd9/d5Npdfr4uZffv3z9xWeiW56rLtVv9\n", - "HnW5bsucX+YHa6/lZzyE76e0klnL21hVVNWKjW46QpVkc5KrktyU5MYkr2xZnyRJ0jR0S0/f3QJw\n", - "cVVtT7IR+FKSK6vqlsb1SpIkrZqmI1RV9Z2q2j5+vgu4BbhfyzolSZJW26otSk+yBTgHuGa16pQk\n", - "SVoNqxJQjaf7PgBcNB6pkiRJOm60XkNFknXAB4H3VNUVy1/fvXv3wefr1q3rfIeeJElSC13uZG0a\n", - "UGV0P+RlwM1VdclKZTZs2NCyCZIkSUdl+bYOhwuwWk/5PR74deC8JNvGj/Mb1ylJkrSqmo5QVdVn\n", - "cTd2SZJ0nDPYkSRJ6qn5ovQjmZ+fn6hcl4Vhi4uLndrQJd1Kq7Qos5gGpEs71qyZPHbvUrarVilw\n", - "unznulx3KN+LIaSHaJkKaCi/U5MaQn9At3bM2mc8FEPp61aOp++FI1SSJEk9GVBJkiT1ZEAlSZLU\n", - "kwGVJElSTwZUkiRJPRlQSZIk9WRAJUmS1JMBlSRJUk8GVJIkST0ZUEmSJPU09dQzu3btmqhcl+33\n", - "u27V3yotSpd2tEpH0iVdR9fyrVKBtEwxMoSfbyjpZDS7/F7ce9jXs+OQAVWSXwYKWCkqqKr60CQV\n", - "JJkDrgVur6pnHVUrJUmSBuxwI1TPYhRQHcpEARVwEXAzsGnSRkmSJM2SQwZUVfUbfS+e5AHAM4A/\n", - "AX6/7/UkSZKG6IgLgpKckeSyJB8fH5+V5LcmvP5bgFcD3RbySJIkzZBJVli/E/gkcL/x8deBi4/0\n", - "piTPBHZU1TZWXoclSZJ0XJgkoDqtqv4W2AdQVQvA4gTvexxwQZJvAu8Dnprk3csL7dmz5+BjYWGh\n", - "Q9MlSZKGYZKAaleSHzlwkORc4HtHelNVvb6qNlfVg4AXAJ+qqhctLzc/P3/wsW7dui5tlyRJGoRJ\n", - "9qF6FfBR4MeTfB64L/Dco6jLzTQkSdJxKZNsGpZkLfBTjNZCfXU87de/8qROPfXUSct2uW6ndrTa\n", - "rLPLhmxdNvZstTlly2u7sWf7spKk9qpqxUDgiCNUSU4CXgY8gdEo09VJ/rKq7jq2TZQkSZpNk0z5\n", - "vRv4PvBWRiNUvwpcDvxKw3ZJkiTNjEkCqrOr6qwlx59KcvOxakCX6bZWukztdJ1OnNTc3NzEZbss\n", - "3m/VXhjGNFeXqVKAxcVJblBtW7bllGYXrabRW03vDuVzk6SVTBLNfDnJYw8cjO/y+1K7JkmSJM2W\n", - "wyVHvmFJmc8luY3RGqoHAl9dhbZJkiTNhCMlR5YkSdIRHC458q1Lj5P8KHBi6wZJkiTNmkmSI1+Q\n", - "5OvAN4FPA7cCH2vcLkmSpJkxyaL0PwYeC3xtnEbmacA1TVslSZI0QyYJqBaq6n+ANUnmquoq4FGN\n", - "2yVJkjQzJtmH6s4km4Crgb9JsgPY1bZZkiRJs2OSEarnAHuAi4GPA9/AOwAlSZIOOuIIVVUdGI3a\n", - "B7yzaWskSZJm0OE29tzFaCPPlVRV3eeYNGDtJLOObXVJadEl1ckQ0mp0TcExhHQyLVOMzGKftLpu\n", - "y7RELZhORtKQHW4fqo19L57kFOBS4GxGwdlvVtUX+l5XkiRpSFoPD/058E9V9dwka4ENjeuTJEla\n", - "dc0CqiQnA0+sqhcDVNUi8L1W9UmSJE3LJHf5Ha0HAf+d5B1Jvpzkr5LMN6xPkiRpKloGVGuBRwJ/\n", - "UVWPBHYDr21YnyRJ0lS0DKhuB26vqi+Ojz/AKMC6h507dx587N27t2FzJEmS2mi2hqqqvpPktiQP\n", - "qaqvAU8HblpebtOmTa2aIEmStCpa3+X3u4zS1awH/h14SeP6JEmSVl3TgKqqrgMe3bIOSZKkaWu5\n", - "hkqSJOleYep5X+bnJ9tJYXFxceJrdkkP01KX1B5r1gwjth1CWpSWKVG6fDe6fOdalT3e06106euh\n", - "pMoZQpohScMzjH/FJUmSZpgBlSRJUk8GVJIkST0ZUEmSJPVkQCVJktSTAZUkSVJPBlSSJEk9GVBJ\n", - "kiT1ZEAlSZLUkwGVJElST1NPPbN79+6JyrVM99AqPUSr1DMt09TMzc1NXHbdunVNrtulP7qkcQG4\n", - "++67Jy67d+/eict26esun0VLXT7n/fv3T1y2S3qfVm1omaamVbqcoaSpGUo7pFnTdIQqyeuS3JTk\n", - "hiTvTXJCy/okSZKmoVlAlWQL8FLgkVX1MGAOeEGr+iRJkqal5ZTf94EFYD7JPmAe+FbD+iRJkqai\n", - "2QhVVf0f8GfAfwLfBr5bVf/cqj5JkqRpaTnl9xPA7wFbgPsBG5P8Wqv6JEmSpqXlovRHAZ+vqv+t\n", - "qkXgQ8DjlhfatWvXwUeXO7AkSZKGouUaqq8Af5jkJOAu4OnA1uWFNm7c2LAJkiRJ7bVcQ3Ud8G7g\n", - "WuD68em3t6pPkiRpWppu7FlVbwLe1LIOSZKkaTP1jCRJUk8GVJIkST1NPZdfl/xcrbTMjTepLvmz\n", - "uuRK6/r5drnTcs+ePROXbdXmLtfteu0uZVvlmpzFvGqt2ny8f26SZtv0IwlJkqQZZ0AlSZLUkwGV\n", - "JElSTwZUkiRJPRlQSZIk9WRAJUmS1NMgAyqTJM+2hYWFaTdBR8ntBiTp6AwyoPIf5Nm2uLg47Sbo\n", - "KBlQSdLRGWRAJUmSNEsMqCRJknrKNIf4kzi/IEmSZkZVZaXzUw2oJEmSjgdO+UmSJPVkQCVJktTT\n", - "4AKqJOcn+UqSryd5zbTbo0NL8tdJ7khyw5Jzpya5MsnXknwyySnTbKMOLcnmJFcluSnJjUleOT5v\n", - "Hw5ckhOTXJNke5Kbk7xhfN6+myFJ5pJsS/LR8bH9N8MGFVAlmQPeBpwPnAVcmOSh022VDuMdjPpq\n", - "qdcCV1bVQ4B/GR9rmBaAi6vqbOBc4OXj3zf7cOCq6i7gvKp6BPBw4LwkT8C+mzUXATcDBxYz238z\n", - "bFABFfAY4BtVdWtVLQDvB5495TbpEKrqauDOZacvAN41fv4u4Dmr2ihNrKq+U1Xbx893AbcA98c+\n", - "nAlVtWf8dD0wx+h30b6bEUkeADwDuBQ4cNeY/TfDhhZQ3R+4bcnx7eNzmh2nV9Ud4+d3AKdPszGa\n", - "TJItwDnANdiHMyHJmiTbGfXRVVV1E/bdLHkL8Gpg/5Jz9t8MG1pA5R4Ox5Ea7clhnw5cko3AB4GL\n", - "qmrn0tfsw+Gqqv3jKb8HAE9Kct6y1+27gUryTGBHVW3jB6NT92D/zZ6hBVTfAjYvOd7MaJRKs+OO\n", - "JGcAJDkT2DHl9ugwkqxjFExdXlVXjE/bhzOkqr4H/CPws9h3s+JxwAVJvgm8D3hqksux/2ba0AKq\n", - "a4EHJ9mSZD3wfOAjU26TuvkI8OLx8xcDVxymrKYoSYDLgJur6pIlL9mHA5fktAN3gCU5Cfg5YBv2\n", - "3UyoqtdX1eaqehDwAuBTVfVC7L+ZNrid0pP8AnAJo0WWl1XVG6bcJB1CkvcBTwZOYzTf/0fAh4G/\n", - "Ax4I3Ao8r6q+O6026tDGd4V9BrieH0wtvA7Yin04aEkexmjR8prx4/KqenOSU7HvZkqSJwOvqqoL\n", - "7L/ZNriASpIkadYMbcpPkiRp5hhQSZIk9WRAJUmS1JMBlSRJUk8GVJIkST0ZUEmSJPVkQCVp6pJ8\n", - "bvzfH0ty4TG+9utXqkuSjiX3oZI0GEmewmiTw2d1eM/aqlo8zOs7q2rTsWifJB2KI1SSpi7JrvHT\n", - "NwJPTLItyUVJ1iR5c5KtSa5L8tvj8k9JcnWSDwM3js9dkeTaJDcmeen43BuBk8bXu3xpXRl5c5Ib\n", - "klyf5HlLrv2vSf4+yS1J3rO6n4akWbR22g2QJH6Q+uY1wB8cGKEaB1DfrarHJDkB+GyST47LngOc\n", - "XVX/MT5+SVXdOc5ttzXJB6rqtUleXlXnrFDXLwE/AzwcuC/wxSSfGb/2COAs4L+AzyV5fFU5VSjp\n", - "kByhkjQkWXb888CLkmwDvgCcCvzk+LWtS4IpgIuSbAf+DdgMPPgIdT0BeG+N7AA+DTyaUcC1taq+\n", - "XaM1EduBLT1+Jkn3Ao5QSRq6V1TVlUtPjNda7V52/DTg3Kq6K8lVwIlHuG7xwwHcgdGrvUvO7cO/\n", - "lZKOwBEqSUOyE1i6gPwTwMuSrAVI8pAk8yu87z7AneNg6qeBc5e8tnDg/ctcDTx/vE7rvsCTgK38\n", - "cJAlSUfk/3VJGoIDI0PXAfvGU3fvAN7KaLrty0kC7AB+cVx+6S3KHwd+J8nNwFcZTfsd8Hbg+iRf\n", - "qqoXHnhfVf1DkseO6yzg1VW1I8lDl12bFY4l6R7cNkGSJKknp/wkSZJ6MqCSJEnqyYBKkiSpJwMq\n", - "SZKkngyoJEmSejKgkiRJ6smASpIkqScDKkmSpJ7+H8jVQl8390BQAAAAAElFTkSuQmCC\n" + "AAALEgAACxIB0t1+/AAAD4tJREFUeJzt3WuQZVdZh/HnPz2XnjhDpiJJEJg4qKAkBRIEKtwJoBUp\n", + "CKgIRAVEC8sCJEaggHzwkxZYlEWkKK1CIpcgoAIGKBWIEiGAJARmcptws4gmIBkvGchA9dA98/qh\n", + "z0w6Tc/02b2z+pw9eX5VXXP2PuvstfqsfU6/s/ba601VIUmSpLXbMOkGSJIkDZ0BlSRJUk8GVJIk\n", + "ST0ZUEmSJPVkQCVJktSTAZUkSVJPGydZeRLXbJAkSYNRVVlpf9OAKsl5wCXADPD2qvqT5WVOP/30\n", + "H3rdgQMH2LZt2932dVkv6/Dhw53a2aX8oUOHxi7bqs1djttynbFjHXt+fp5NmzatuR1d3ouufT0N\n", + "fSJJOvE0u+SXZAZ4K3AecCZwQZKHtqpPkiRpUlrOoXoM8PWquqWq5oH3A89uWJ8kSdJEtAyoHgDc\n", + "umT7ttG+VW3evLlJg7Q+NmzwXgdJ0r1Ly798a55UYkA1bDMzM5NugiRJ66rlpPRvAjuXbO9kcZTq\n", + "bg4cOHD08ebNmw2mJEnS4LQMqK4FHpxkF/At4PnABcsLLb+bT5IkaWiaBVRVtZDkFcDHWVw24dKq\n", + "urlVfZIkSZOSSa6fk6RWWodqJa5DtbbjTmIdqr5lXYdKkjStJrKw5zi2bt06VrmNG8dvapey0G0S\n", + "dZdjb9myZeyys7OzTcqO+/4e0WUOW5eyXdqxffv2scuecsopY5cFOO2008Yue+qppzYpu2PHjrHL\n", + "djmHpqWvu3xGunz2utw92jXA7VJ+YWFh7LJd/gPW5b1IVvw+P6ZW359d+qRLm7v+fkPT5Xzrcg51\n", + "PXarPmnVfy3Pi3Hft+N9Tr2/XZIkqScDKkmSpJ4MqCRJknoyoJIkSerJgEqSJKknAypJkqSeDKgk\n", + "SZJ6MqCSJEnqyYBKkiSpJwMqSZKkngyoJEmSepp4Lr+5ublJN6GTLrmEWuVUGmLC41ZJibvkVet6\n", + "7GlIhN1Fy/x1Joq+S5f8dV3y801LAvhW/XeinxdDdKLnTFxvTUeokuxMcmWSm5LcmOSVLeuTJEma\n", + "hNYjVPPARVW1J8k24ItJrqiqmxvXK0mStG6ajlBV1beras/o8QHgZuD+LeuUJElab+s2KT3JLuBs\n", + "4Or1qlOSJGk9rEtANbrc9wHgwtFIlSRJ0gmj+V1+STYBHwTeU1WXL3/+zjvvPPp48+bNbNmypXWT\n", + "JEmSVtXl7tSmAVUW78m8FNhbVZesVGb79u0tmyBJkrQmy5eWOF6A1fqS3+OB3wDOTbJ79HNe4zol\n", + "SZLWVdMRqqr6DK7GLkmSTnAGO5IkST1NPPXMuGkchpiapYsuqSFapS6BdukvWvVflzQgLY/d6r1o\n", + "eV4MLRXItLS3S0qiLmW7nBddU4a0SjEyLX0yNF36o+t3XBfTkGrsROIIlSRJUk8GVJIkST0ZUEmS\n", + "JPVkQCVJktSTAZUkSVJPBlSSJEk9GVBJkiT1ZEAlSZLUkwGVJElSTwZUkiRJPU089czGjeM1oUsK\n", + "h67L3rdaUr9LKpAuv1+X4w4xDU/LFAet0oa0Oj9N93DvYf/de3Tp6y7fLZqsY0YzSX4FKGClpENV\n", + "VR8ap4IkM8C1wG1V9aw1tVKSJGmKHW946FksBlTHMlZABVwI7AW2j9soSZKkITlmQFVVv9n34Eke\n", + "CDwD+GPgD/oeT5IkaRqtOik9yf2SXJrkY6PtM5P89pjHfzPwGmD8ST+SJEkDM85dfu8EPgHcf7T9\n", + "NeCi1V6U5JnAvqrazcrzsCRJkk4I4wRU962qvwEOAVTVPLAwxuseB5yf5BvA+4CnJnn38kL79+8/\n", + "+jM3N9eh6ZIkSdNhnDULDiT50SMbSc4BvrPai6rqYuDi0WueDLy6ql60vNyOHTvGb60kSdIUGieg\n", + "ehXwUeAnknwOOBV47hrqcpEVSZJ0Qso4C4wl2Qj8NItzob4yuuzXv/KkzjjjjLHKtlr4ElzYc61c\n", + "2HNtZV3YU5KGq6pWnBe+6ghVkq3Ay4AnsDjKdFWSv6gqJzxJkiQx3iW/dwPfBd7C4gjVrwGXAb/a\n", + "sF2SJEmDMU5AdVZVnblk+5NJ9t5TDRj3zr6Wlz6Gdglmw4bh5bRu9b4tLIxzw+naJOOv9tGlbKs2\n", + "tDS0z4gkrbdx/jJ/Kcljj2yM7vL7YrsmSZIkDcvxkiPfsKTMZ5PcyuIcqjOAr6xD2yRJkgZhteTI\n", + "kiRJWsXxkiPfsnQ7yWnAbOsGSZIkDc04yZHPT/I14BvAp4BbgH9q3C5JkqTBGGdS+h8BjwW+WlUP\n", + "Ap4GXN20VZIkSQMyTkA1X1X/A2xIMlNVVwKPatwuSZKkwRhnHao7kmwHrgL+Osk+4EDbZkmSJA3H\n", + "OCNUzwG+D1wEfAz4Ot4BKEmSdNSqI1RVdWQ06hDwzqatkSRJGqDjLex5gMWFPFdSVXWfe6IBs7Pj\n", + "rcQwDWlAuuqSVuPw4cMTLzst7ehSdmZmZuyyMB2pTlq9Fy1TLrUyxM+qJK3keOtQbet78CQ7gLcD\n", + "Z7EYnP1WVX2+73ElSZKmyTiT0vv4M+Afq+q5STYCP9K4PkmSpHXXLKBKcjLwxKp6MUBVLQDfaVWf\n", + "JEnSpIxzl99aPQj47yTvSPKlJH+Z5KSG9UmSJE1Ey4BqI/BI4M+r6pHA94DXNaxPkiRpIlrOoboN\n", + "uK2qvjDa/gArBFT79+8/+nh2dnbsu/4kSZKmRbOAqqq+neTWJA+pqq8CTwduWl5ux44drZogSZK0\n", + "Llrf5fd7LKar2Qz8O/CSxvVJkiStu6YBVVVdBzy6ZR2SJEmT1nJSuiRJ0r1C60t+q5qbmxurXMvU\n", + "M0NLa9MqpU3XY7cqu2HD+HH+xo3dTuFNmzaNXXZhYWHssvPz82OX/cEPfjB22S5apk9pdexp+DxB\n", + "t3OulSH2n6S7TP5bRJIkaeAMqCRJknoyoJIkSerJgEqSJKknAypJkqSeDKgkSZJ6MqCSJEnqyYBK\n", + "kiSpJwMqSZKkngyoJEmSepp46pmDBw+OVa5lioppSD3T6rhdU050aUeXdB1dyh46dGjssl1SvnQ9\n", + "dpe0PV2O2+U97pJap2tfd/n9upRtlZJoWkzD98UQ3zfpRNd0hCrJ65PclOSGJO9NsqVlfZIkSZPQ\n", + "LKBKsgt4KfDIqnoYMAO8oFV9kiRJk9Lykt93gXngpCSHgJOAbzasT5IkaSKajVBV1f8Bfwr8J/At\n", + "YH9V/XOr+iRJkial5SW/nwR+H9gF3B/YluTXW9UnSZI0KS0npT8K+FxV/W9VLQAfAh63vNDc3NzR\n", + "n4WFhYbNkSRJaqNlQPVl4JwkW7N47/DTgb3LC83Ozh796XKLuCRJ0rRoOYfqOuDdwLXA9aPdb2tV\n", + "nyRJ0qRkkgvEJamTTz553LIt29GkbKs2dDEtC3t2aUeXRTK7lO1avtXCnl106Q8X9ly7Vt8Brfqv\n", + "6/s2Le+zdCKoqhU/2KaekSRJ6smASpIkqaeJzwLftm3bWOVaXXJoqUs7uvx+XXQ9bqtLc60uL7W8\n", + "5NfqPJqWc3laPidDMw2fa0nTxxEqSZKkngyoJEmSejKgkiRJ6smASpIkqScDKkmSpJ4MqCRJknqa\n", + "yoDq4MGDk26Cepifn590E7RGLqUgSWtjQKV7nAHVcBlQSdLaTGVAJUmSNCQGVJIkST1lkkP8Sby+\n", + "IEmSBqOqstL+iQZUkiRJJwIv+UmSJPVkQCVJktTT1AVUSc5L8uUkX0vy2km3R8eW5K+S3J7khiX7\n", + "TklyRZKvJvlEkh2TbKOOLcnOJFcmuSnJjUleOdpvH065JLNJrk6yJ8neJG8Y7bfvBiTJTJLdST46\n", + "2rb/BmyqAqokM8BbgfOAM4ELkjx0sq3ScbyDxb5a6nXAFVX1EOBfRtuaTvPARVV1FnAO8PLR580+\n", + "nHJVNQecW1WPAB4OnJvkCdh3Q3MhsBc4MpnZ/huwqQqogMcAX6+qW6pqHng/8OwJt0nHUFVXAXcs\n", + "230+8K7R43cBz1nXRmlsVfXtqtozenwAuBl4APbhIFTV90cPNwMzLH4W7buBSPJA4BnA24Ejd43Z\n", + "fwM2bQHVA4Bbl2zfNtqn4Ti9qm4fPb4dOH2SjdF4kuwCzgauxj4chCQbkuxhsY+urKqbsO+G5M3A\n", + "a4DDS/bZfwM2bQGVazicQGpxTQ77dMol2QZ8ELiwqu5c+px9OL2q6vDokt8DgSclOXfZ8/bdlEry\n", + "TGBfVe3mrtGpu7H/hmfaAqpvAjuXbO9kcZRKw3F7kvsBJPkxYN+E26PjSLKJxWDqsqq6fLTbPhyQ\n", + "qvoO8A/Az2HfDcXjgPOTfAN4H/DUJJdh/w3atAVU1wIPTrIryWbg+cBHJtwmdfMR4MWjxy8GLj9O\n", + "WU1QkgCXAnur6pIlT9mHUy7JfY/cAZZkK/DzwG7su0GoqouramdVPQh4AfDJqnoh9t+gTd1K6Ul+\n", + "EbiExUmWl1bVGybcJB1DkvcBTwbuy+L1/j8EPgz8LXAGcAvwvKraP6k26thGd4V9Grieuy4tvB64\n", + "BvtwqiV5GIuTljeMfi6rqjclOQX7blCSPBl4VVWdb/8N29QFVJIkSUMzbZf8JEmSBseASpIkqScD\n", + "KkmSpJ4MqCRJknoyoJIkSerJgEqSJKknAypJE5fks6N/fzzJBffwsS9eqS5Juie5DpWkqZHkKSwu\n", + "cvisDq/ZWFULx3n+zqrafk+0T5KOxREqSROX5MDo4RuBJybZneTCJBuSvCnJNUmuS/I7o/JPSXJV\n", + "kg8DN472XZ7k2iQ3JnnpaN8bga2j4122tK4selOSG5Jcn+R5S479r0n+LsnNSd6zvu+GpCHaOOkG\n", + "SBJ3pb55LfDqIyNUowBqf1U9JskW4DNJPjEqezZwVlX9x2j7JVV1xyi33TVJPlBVr0vy8qo6e4W6\n", + "fhn4WeDhwKnAF5J8evTcI4Azgf8CPpvk8VXlpUJJx+QIlaRpkmXbvwC8KMlu4PPAKcBPjZ67Zkkw\n", + "BXBhkj3AvwE7gQevUtcTgPfWon3Ap4BHsxhwXVNV36rFORF7gF09fidJ9wKOUEmadq+oqiuW7hjN\n", + "tfresu2nAedU1VySK4HZVY5b/HAAd2T06uCSfYfwu1LSKhyhkjRN7gSWTiD/OPCyJBsBkjwkyUkr\n", + "vO4+wB2jYOpngHOWPDd/5PXLXAU8fzRP61TgScA1/HCQJUmr8n9dkqbBkZGh64BDo0t37wDewuLl\n", + "ti8lCbAP+KVR+aW3KH8M+N0ke4GvsHjZ74i3Adcn+WJVvfDI66rq75M8dlRnAa+pqn1JHrrs2Kyw\n", + "LUl347IJkiRJPXnJT5IkqScDKkmSpJ4MqCRJknoyoJIkSerJgEqSJKknAypJkqSeDKgkSZJ6MqCS\n", + "JEnq6f8BUrepXiOjd3cAAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -4214,7 +4259,7 @@ "YII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -4224,84 +4269,85 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAEG1JREFUeJzt3XuQJWV5x/Hvb2d39u5yceMibIIBTcSSiKiFqyiooYil\n", - "aBKjkkSNSUml1EiIWipVSfFHoqasKLGspIpIvGDUJGpQK1EhCVEUZEW5LnhLSQISIRCU3XVvszz5\n", - "Y87CMMzsdG/Tc85Zvp+qqT3d5zn9vtPvnNln+u3zPqkqJEmSdOCWDLsDkiRJ486ESpIkqSMTKkmS\n", - "pI5MqCRJkjoyoZIkSerIhEqSJKmjpcNsPIlrNkiSpLFRVZlrf68JVZLTgfOBCeCDVfXns2OOOOKI\n", - "h7xu69atrF279kH7li9f3rjdFStWtOrnkiXNL9S1iW3T55UrVzaOXb9+fePYDRs2NI5te+zZY7TP\n", - "JZdcwmmnnfagfatWrWp83Dbnrc1xAQ499NDGsWvWrGkce8ghhzSOnZycbBw7NTXVOLbN2MHcP3Pv\n", - "fOc7Offccx+yf9myZY2POzEx0Ti2zfupzZp5bc4bwM6dOxvH7tixo3Hs1q1bG8du2bKlcexRRx01\n", - "5/4LLriAs8466yH7jznmmMbHXrduXePYNuOn/TvvvPM477zzht2NRdfmfd123cxdu3Y1jr3nnnsa\n", - "xR155JHzPtfbuyHJBPAB4HTgOODMJE/sqz1JkqRh6fPPi2cA36+qW6pqD/BJ4CU9tidJkjQUfSZU\n", - "RwK3zti+bbBvQW2mRDR62kwvaLScfPLJw+6COjjxxBOH3QUdoFNOOWXYXVBHfSZUB3zDeZt7aDR6\n", - "TKjGlwnVeDOhGl8mVOOvz5vSfwhsnLG9kemrVA8y86bNyclJkylJkjQSrrjiCq688spGsX0mVFcD\n", - "j09yNHA78ArgzNlB831STJIkaZg2bdrEpk2b7t9+73vfO29sbwlVVU0leSPwJaaXTbiwqm7uqz1J\n", - "kqRh6XUdqqr6AvCFPtuQJEkatqGulN7Gtm3bGsc2XaBrnzaLAO7du7dxbF8Llt133329HLftsdto\n", - "2w9JksaJy9xKkiR1ZEIlSZLUkQmVJElSRyZUkiRJHZlQSZIkdWRCJUmS1JEJlSRJUkcmVJIkSR2Z\n", - "UEmSJHVkQiVJktSRCZUkSVJHGWaNtSS1evXqRrGTk5ONj7tixYpW/Wjah7bHnpiYaBzbpkbgvffe\n", - "2zi2TQ1EgB07djSO3bNnT+PYvuoajmONwCVL+vk7pm0dxnE8d5I0bFWVufb3eoUqycYklyXZkuTG\n", - "JG/qsz1JkqRhWNrz8fcA51TVtUnWAN9McmlV3dxzu5IkSYum1ytUVfWjqrp28HgbcDPw2D7blCRJ\n", - "WmyLdlN6kqOBE4CrFqtNSZKkxbAoCdVguu9TwNmDK1WSJEkHjb7voSLJMuDTwMeq6uLZz+/evfv+\n", - "xxMTE60+GSdJkjQKek2okgS4ELipqs6fK6bNcgiSJEmjqO8pv2cBvw2cmuSawdfpPbcpSZK0qHq9\n", - "QlVVX8XV2CVJ0kHOZEeSJKmj3m9KX8i6desaxbUpq9GmJArAXXfd1Ti2TYmYtqVA+jhu2/IibeKn\n", - "b5Frpk25lXEsiTKOfdb4avPeA38+pcXgFSpJkqSOTKgkSZI6MqGSJEnqyIRKkiSpIxMqSZKkjkyo\n", - "JEmSOjKhkiRJ6siESpIkqSMTKkmSpI5MqCRJkjoaeumZpmViJiYmGh9z+fLlrfqwevXqxrFtSj60\n", - "KVPTplzO7t27ezkutOtzm3IWoxDb1iiU6xiVc6HR4lhLo2fehCrJrwMFzJVBVFV9pkkDSSaAq4Hb\n", - "qurFB9RLSZKkEba/K1QvZjqhmk+jhAo4G7gJWNu0U5IkSeNk3oSqqn6n68GTHAW8EPgz4I+6Hk+S\n", - "JGkULXhTepINSS5M8sXB9nFJfq/h8d8HvBW4r0MfJUmSRlqTT/l9GLgEeOxg+3vAOQu9KMmLgDur\n", - "6hrmvg9LkiTpoNAkoXp0Vf09sBegqvYAUw1etwk4I8kPgE8Az0vy0dlB27dvv/+rzafXJEmSRkWT\n", - "ZRO2JTl830aSk4CfLPSiqjoXOHfwmucCb6mqV8+Oa7NkgSRJ0ihqklC9Gfg88PNJrgDWAy87gLZc\n", - "OEWSJB2U0mSBuCRLgV9g+l6o7wym/bo3ntT69esbxbZZ2LNNLMDSpc3XN3VhzwdMTTWZ+Z3mwp79\n", - "92EU+itJB7uqmjMRWDCTSLISeD3wbKavMl2e5K+raufD20VJkqTx1OTSzEeBe4H3M32F6jeBi4Df\n", - "6LFfkiRJY2PBKb8kN1XVcQvtO6DGkzr00EMbxbaZzmgzLdf22H3FLlnSvE51m9i27ruv+ZJhbWL7\n", - "Om9tpijbHruv76+NNtPRbc9FX9/fKJy3tr8D2sS3ef+tWbOmcezxxx/fOPbuu+9uHAtw6623No7d\n", - "tm1b49g2Yy111fb/vsnJycaxhx12WKO422+/fd4pvya9+1aSZ+7bGHzK75uNWpYkSXoE2F9x5Btm\n", - "xHwtya1M30P1s8B3FqFvkiRJY2Gh4siSJElawP6KI98yczvJzwAr+u6QJEnSuGlSHPmMJN8DfgB8\n", - "GbgF+ELP/ZIkSRobTW5K/1PgmcB3q+pxwPOBq3rtlSRJ0hhpklDtqaq7gCVJJqrqMuBpPfdLkiRp\n", - "bDRZ5OaeJGuBy4G/S3In0HyhEkmSpINckytULwV+CpwDfBH4Pn4CUJIk6X4LXqGqqn1Xo/YCH+61\n", - "N5IkSWNo3tIzSbYxvZDnXKqqHtW58aSOPfbYRrETExONj9smFvort9JXWYY2y++PSgmOvs7F1NRU\n", - "q/gdO3b0cuzdu3c3jm1zLtqMx86d7eqVtylVMwqlZ/r62YT+fr+0KR3U5ly0Hes2P8t9lQOSDhbz\n", - "lZ7Z3zpUzYtQzSPJIcAHgScxnZz9blV9vetxJUmSRknzP58OzF8C/1JVL0uyFFjdc3uSJEmLrreE\n", - "Ksk64OSqeg1AVU0BP+mrPUmSpGFpd6NBO48D/jfJh5J8K8nfJFnVY3uSJElD0WdCtRR4KvBXVfVU\n", - "YDvw9h7bkyRJGoo+76G6Dbitqr4x2P4UcyRUd9999/2PV65cyapVXsSSJEnjpbeEqqp+lOTWJE+o\n", - "qu8CLwC2zI47/PDD++qCJEnSouj7U35/wHS5mkngP4HX9tyeJEnSous1oaqq64Cn99mGJEnSsPV5\n", - "U7okSdIjQt9TfgtasWJFo7g2pRa2b9/eqg979uxpHNtXWY022paTGQVtzkWbsiFtywy1KbfS5udi\n", - "165dvcT2VfJlHLU5F23fe23eU23Oc5vfW31+f5L65xUqSZKkjkyoJEmSOjKhkiRJ6siESpIkqSMT\n", - "KkmSpI5MqCRJkjoyoZIkSerIhEqSJKkjEypJkqSOTKgkSZI6GnrpmbvuuqtRXJsyIG1ioV05kr7K\n", - "Q7QpfdFXmYw++9HmXExNTTWObTN2bfsxCqVAxrHM0ChoOx5tf2c05fhJjxy9XqFK8o4kW5LckOTj\n", - "SZb32Z4kSdIw9JZQJTkaeB3w1Kp6MjABvLKv9iRJkoalzym/e4E9wKoke4FVwA97bE+SJGkoertC\n", - "VVX/B/wF8N/A7cCPq+pf+2pPkiRpWPqc8jsG+EPgaOCxwJokv9VXe5IkScPS503pTwOuqKq7q2oK\n", - "+AywaXbQ1q1b7//atWtXj92RJEnqR5/3UH0b+OMkK4GdwAuAzbOD1q5d22MXJEmS+tfnPVTXAR8F\n", - "rgauH+y+oK/2JEmShiV9LUjYqPGkNmzY0CjWhT0PLNaFPQ+8H+O2sOcw38uaW18LezrW0vBU1Zxv\n", - "bEvPSJIkdWRCJUmS1NHQa/k1vXS9bNmyxsdsEwuwZEnzvLKvKZi+ph3bfnKyzXRpmz63iW0zTdl2\n", - "6mMUpuZGZXrXaaMD0+b3xShMG0taHF6hkiRJ6siESpIkqSMTKkmSpI5MqCRJkjoyoZIkSerIhEqS\n", - "JKmjkUyodu/ePewuqIO2q5dLkjTuTKj0sGu7HpIkSeNuJBMqSZKkcWJCJUmS1FGGWe4gibUWJEnS\n", - "2KiqOWuCDTWhkiRJOhg45SdJktSRCZUkSVJHI5dQJTk9ybeTfC/J24bdH80vyd8muSPJDTP2HZbk\n", - "0iTfTXJJkkOG2UfNL8nGJJcl2ZLkxiRvGux3DEdckhVJrkpybZKbkrxrsN+xGyNJJpJck+Tzg23H\n", - "b4yNVEKVZAL4AHA6cBxwZpInDrdX2o8PMT1WM70duLSqngD822Bbo2kPcE5VPQk4CXjD4P3mGI64\n", - "qtoJnFpVTwGOB05N8mwcu3FzNnATsO9mZsdvjI1UQgU8A/h+Vd1SVXuATwIvGXKfNI+quhy4Z9bu\n", - "M4CPDB5/BHjponZKjVXVj6rq2sHjbcDNwJE4hmOhqn46eDgJTDD9XnTsxkSSo4AXAh8E9n1qzPEb\n", - "Y6OWUB0J3Dpj+7bBPo2Px1TVHYPHdwCPGWZn1EySo4ETgKtwDMdCkiVJrmV6jC6rqi04duPkfcBb\n", - "gZmlJRy/MTZqCZVrOBxEanpNDsd0xCVZA3waOLuqts58zjEcXVV132DK7yjgOUlOnfW8YzeikrwI\n", - "uLOqruGBq1MP4viNn1FLqH4IbJyxvZHpq1QaH3ck2QCQ5AjgziH3R/uRZBnTydRFVXXxYLdjOEaq\n", - "6ifAPwMn4tiNi03AGUl+AHwCeF6Si3D8xtqoJVRXA49PcnSSSeAVwOeG3Ce18zngNYPHrwEu3k+s\n", - "hihJgAuBm6rq/BlPOYYjLsmj930CLMlK4JeBa3DsxkJVnVtVG6vqccArgX+vqlfh+I21kVspPcmv\n", - "AOczfZPlhVX1riF3SfNI8gngucCjmZ7v/xPgs8A/AD8L3AK8vKp+PKw+an6DT4V9BbieB6YW3gFs\n", - "xjEcaUmezPRNy0sGXxdV1XuSHIZjN1aSPBd4c1Wd4fiNt5FLqCRJksbNqE35SZIkjR0TKkmSpI5M\n", - "qCRJkjoyoZIkSerIhEqSJKkjEypJkqSOTKgkDV2Srw3+/bkkZz7Mxz53rrYk6eHkOlSSRkaSU5he\n", - "5PDFLV6ztKqm9vP81qpa+3D0T5Lm4xUqSUOXZNvg4buBk5Nck+TsJEuSvCfJ5iTXJTlrEH9KksuT\n", - "fBa4cbDv4iRXJ7kxyesG+94NrBwc76KZbWXae5LckOT6JC+fcez/SPKPSW5O8rHFPRuSxtHSYXdA\n", - "knig9M3bgLfsu0I1SKB+XFXPSLIc+GqSSwaxJwBPqqr/Gmy/tqruGdS225zkU1X19iRvqKoT5mjr\n", - "14BfAo4H1gPfSPKVwXNPAY4D/gf4WpJnVZVThZLm5RUqSaMks7ZPA16d5Brg68BhwLGD5zbPSKYA\n", - "zk5yLXAlsBF4/AJtPRv4eE27E/gy8HSmE67NVXV7Td8TcS1wdIfvSdIjgFeoJI26N1bVpTN3DO61\n", - "2j5r+/nASVW1M8llwIoFjls8NIHbd/Vq14x9e/F3paQFeIVK0ijZCsy8gfxLwOuTLAVI8oQkq+Z4\n", - "3aOAewbJ1C8CJ814bs++189yOfCKwX1a64HnAJt5aJIlSQvyry5Jo2DflaHrgL2DqbsPAe9nerrt\n", - "W0kC3An86iB+5keUvwj8fpKbgO8wPe23zwXA9Um+WVWv2ve6qvqnJM8ctFnAW6vqziRPnHVs5tiW\n", - "pAdx2QRJkqSOnPKTJEnqyIRKkiSpIxMqSZKkjkyoJEmSOjKhkiRJ6siESpIkqSMTKkmSpI5MqCRJ\n", - "kjr6f12ScjOibt0UAAAAAElFTkSuQmCC\n" + "AAALEgAACxIB0t1+/AAAEJBJREFUeJzt3X2wXVV5x/HvjxtIbkxEgoINxsZSoYbRiiiD4guoZaiD\n", + "KK1VaavWdux01ApUHZWZdvijHa1OR3ScdsZCfcGqbdXiS1GhlSoqgkTeXxQ70oIi0BIhCSG5CU//\n", + "OCfhcsnN3TubnXNO+H5m7nD2Ps/Za92zzrk82Wvv9aSqkCRJ0u7bZ9QdkCRJmnQmVJIkSR2ZUEmS\n", + "JHVkQiVJktSRCZUkSVJHJlSSJEkdLRpl40lcs0GSJE2MqsrO9veaUCU5ETgbmALOqaq/nhuzevXq\n", + "h71u3bp1HHDAAQ/Zt2hR865OTU217Wer+Kba9Hnx4sWNY5ctW9Y49uCDD24cC7By5crOsRdeeCEn\n", + "nHDCQ/YdcsghjY974IEHNo5dvnx541iA6enpxrF9rdE2MzPTOPb2229vHNtm7AAOOuigh+07++yz\n", + "Of300x+2f8WKFY2Pu3Tp0saxbb6rbcZjy5YtjWMBNm7c2Dj2rrvuahx70003NY694IILGsceeeSR\n", + "O93/la98hZNOOulh+4899tjGxz788MMbx+63336NY/v6O7u3OOusszjrrLNG3Y15bdu2rXFsm+/f\n", + "/fff3zh206ZNjWMB1q9f3zj23nvvbRR39NFHz/tcb1N+SaaAjwAnAmuAU5M8ra/2JEmSRqXPa6iO\n", + "Bn5cVbdU1QzwWeAVPbYnSZI0En0mVIcAt87avm24b0FLlizppUPaMw499NBRd0G76Zhjjhl1F9TB\n", + "YYcdNuouaDcdd9xxo+6COuozodrtC1DaXOei8WNCNblMqCabCdXkMqGafH1elP5TYNWs7VUMzlI9\n", + "xLp163Y8XrJkicmUJEkaC2vXrmXt2rWNYvtMqK4AnppkNfAz4DXAqXOD5t7NJ0mSNA6OOuoojjrq\n", + "qB3b55xzzryxvSVUVbU1yVuBrzNYNuHcqrqxr/YkSZJGpdd1qKrqq8BX+2xDkiRp1Ea6UjrAfffd\n", + "1yiuzaJ+bRYgaxvfJvaBBx4Y+XHbLk7Z17H7WiRTkqRxYC0/SZKkjkyoJEmSOjKhkiRJ6siESpIk\n", + "qSMTKkmSpI5MqCRJkjoyoZIkSerIhEqSJKkjEypJkqSOTKgkSZI6MqGSJEnqaOS1/JYtW9YoLknj\n", + "Y7aJ7VNfte62bt3aSyzAli1bGsfOzMz0EttXbUUYj5qCfX0+29Rh3J14DYzD35dx+BxLeqhez1Al\n", + "WZXk4iTXJ7kuydv6bE+SJGkU+j5DNQOcUVVXJVkGrE1yUVXd2HO7kiRJe0yvZ6iq6udVddXw8Qbg\n", + "RmBln21KkiTtaXvsovQkq4Ejgcv2VJuSJEl7wh5JqIbTfZ8DThueqZIkSdpr9H6XX5J9gc8Dn6qq\n", + "8+c+f/fdd+94PD09zfT0dN9dkiRJekT1mlBlcH/xucANVXX2zmJWrFjRZxckSZJ61/eU37HA7wPH\n", + "J7ly+HNiz21KkiTtUb2eoaqqb+Nq7JIkaS9nsiNJktTRyEvPNC110qbcQ9uyDG3i25Tr6Ou4bcqt\n", + "tC0v0ubYbcrJ9FWGp88yIPvs0/zfG236MTU11Uvspk2bGsdCf2OytxuH96Lt534c+izt7TxDJUmS\n", + "1JEJlSRJUkcmVJIkSR2ZUEmSJHVkQiVJktSRCZUkSVJHJlSSJEkdmVBJkiR1ZEIlSZLUkQmVJElS\n", + "RxNTeqbPcitt9FVOpq/YPktO9PU+tyn50lZf5Vb6GpOm3w+ArVu3No7VZLOUjDR+5k2okvw2UMDO\n", + "ikZVVX2hSQNJpoArgNuq6uW71UtJkqQxtqszVC9nkFDNp1FCBZwG3AAsb9opSZKkSTJvQlVVf9D1\n", + "4EmeBLwM+Cvgz7oeT5IkaRwteLFKkicmOTfJ14bba5L8UcPjfxB4J9DfRU2SJEkj1uTq348DFwIr\n", + "h9s3A2cs9KIkJwF3VtWV7Pw6LEmSpL1Ck4Tq8VX1T8A2gKqaAZrcTvQ84OQkPwE+A7w4ySfnBm3Y\n", + "sGHHT5s7miRJksZFk2UTNiQ5cPtGkmOAexZ6UVWdCZw5fM2LgHdU1evnxi1btqx5byVJksZQk4Tq\n", + "7cCXgV9J8l3gCcCrdqMtF06RJEl7pTRZIC7JIuBwBtdC/XA47de98aQOOuigRrEu7Ll7sZO4sGfS\n", + "3yV3fS3s2Sa2ze/X5j12YU9J6l9V7fSP+IJnqJJMA28Gns/gLNMlSf6uqu5/ZLsoSZI0mZpM+X0S\n", + "uBf4MIMzVL8LnAf8To/9kiRJmhhNEqojqmrNrO1vJLnhkerA9PR0o7iZmeazjG2notpMJ7aJbTO1\n", + "s2hR87KKbWrdtZ0+62u6ra8p27bTXG360UabKb999923cezKlSsXDhpq+7nfuHFj49h77lnwPpQd\n", + "Nm3a1Di2r+9TW23G5IADDmgcu2bNmoWDhk455ZTGsddee23jWIBLL720cezNN9/cOLbNndnWH5xs\n", + "bf6/0+b7tGTJksaxS5cubRwL8JjHPKZx7P77798obu3atfM+1+Qd+kGS527fGN7lN/8RJUmSHmV2\n", + "VRz52lkx30lyK4NrqJ4M/HAP9E2SJGkiLFQcWZIkSQvYVXHkW2ZvJzkIaD7ZKUmS9CjRpDjyyUlu\n", + "Bn4CfBO4Bfhqz/2SJEmaGE0uSv9L4LnAj6rqKcBLgMt67ZUkSdIEaZJQzVTV/wL7JJmqqouBZ/fc\n", + "L0mSpInRZPGjdUmWA5cA/5jkTmBDv92SJEmaHE3OUL0SuA84A/ga8GO8A1CSJGmHBc9QVdX2s1Hb\n", + "gI/32htJkqQJlPnKASTZwGAhz52pqnps58aTWrZsWaPYqampxsdtE9s2vs3y+21i22hTwqHPMjx9\n", + "lYhp04e25Sza9LlNqZM2sW0+F21+v82bNzeOhXbvxTiUDemrlNPuxDfV1+e+7fdaejTqo1xVVVFV\n", + "Oz3wrtahapbp7EKSxwHnAEcwSM7+sKq+1/W4kiRJ46Sff5Y96EPABVX1qiSLgOaVCiVJkiZEbwlV\n", + "kv2BF1TVGwCqaivQvGS9JEnShOjnIp+BpwB3JflYkh8k+fskS3tsT5IkaST6TKgWAc8C/raqngVs\n", + "BN7dY3uSJEkj0WdCdRtwW1V9f7j9OQYJ1kNs3rx5x0+bO2IkSZL6NLyrb8fPrvR2DVVV/TzJrUkO\n", + "q6ofAS8Frp8bt3jx4r66IEmStNvmLr2wq6Sq77v8/pRBuZr9gP8C3thze5IkSXtcrwlVVV0NPKfP\n", + "NiRJkkatz2uoJEmSHhX6nvJb0NKlzVZS6LPkS1+lZ/pY9r6tNuUsALZs2dJLbF+lS/osM9Rm/Nq8\n", + "z21KxPRZhmfStPn9ZmZmWh27zQ0xbT4Xbfq8t4+ftKft6e+UZ6gkSZI6MqGSJEnqyIRKkiSpIxMq\n", + "SZKkjkyoJEmSOjKhkiRJ6siESpIkqSMTKkmSpI5MqCRJkjoyoZIkSepo5KVnmpYC6bOMywMPPNA4\n", + "ts1S9m363LaESlNtSmpAu/eirxIcbfrc9vfrqxRBX5+LNqWO2v5ubcZ6bzcOpZHajIdjp3HW1/8b\n", + "xl2vZ6iSvCfJ9UmuTfLpJIv7bE+SJGkUekuokqwG3gQ8q6qeDkwBr+2rPUmSpFHpc8rvXmAGWJpk\n", + "G7AU+GmP7UmSJI1Eb2eoqupu4G+A/wF+Bvyiqv69r/YkSZJGpc8pv0OB04HVwEpgWZLf66s9SZKk\n", + "UenzovRnA9+tqv+rqq3AF4DnzQ1av379jp/Nmzf32B1JkqR+9HkN1U3AnyeZBu4HXgpcPjdo+fLl\n", + "PXZBkiSpf31eQ3U18EngCuCa4e6P9tWeJEnSqPS6sGdVvR94f59tSJIkjZqlZyRJkjoyoZIkSepo\n", + "5LX8tm3b1ihuXOpc9VVTsE09o77q4kHz8YB273Nfxx0XbWrutdHX50K7r83fgLbfP2lv8Gj9W+QZ\n", + "KkmSpI5MqCRJkjoyoZIkSerIhEqSJKkjEypJkqSOTKgkSZI6GsuEasuWLaPugjpos0SCJEl7AxMq\n", + "PeImcR0pSZK6GMuESpIkaZKYUEmSJHWUUS4Rn+TRuT69JEmaSFW10/pTI02oJEmS9gZO+UmSJHVk\n", + "QiVJktTR2CVUSU5MclOSm5O8a9T90fyS/EOSO5JcO2vfiiQXJflRkguTPG6UfdT8kqxKcnGS65Nc\n", + "l+Rtw/2O4ZhLsiTJZUmuSnJDkvcO9zt2EyTJVJIrk3x5uO34TbCxSqiSTAEfAU4E1gCnJnnaaHul\n", + "XfgYg7Ga7d3ARVV1GPAfw22NpxngjKo6AjgGeMvw++YYjrmquh84vqqeCTwDOD7J83HsJs1pwA3A\n", + "9ouZHb8JNlYJFXA08OOquqWqZoDPAq8YcZ80j6q6BFg3Z/fJwCeGjz8BvHKPdkqNVdXPq+qq4eMN\n", + "wI3AITiGE6Gq7hs+3A+YYvBddOwmRJInAS8DzgG23zXm+E2wcUuoDgFunbV923CfJsfBVXXH8PEd\n", + "wMGj7IyaSbIaOBK4DMdwIiTZJ8lVDMbo4qq6HsduknwQeCcwu7SE4zfBxi2hcg2HvUgN1uRwTMdc\n", + "kmXA54HTqmr97Occw/FVVQ8Mp/yeBLwwyfFznnfsxlSSk4A7q+pKHjw79RCO3+QZt4Tqp8CqWdur\n", + "GJyl0uS4I8kTAZL8EnDniPujXUiyL4Nk6ryqOn+42zGcIFV1D/BvwFE4dpPiecDJSX4CfAZ4cZLz\n", + "cPwm2rglVFcAT02yOsl+wGuAL424T2rnS8Abho/fAJy/i1iNUJIA5wI3VNXZs55yDMdcksdvvwMs\n", + "yTTwG8CVOHYToarOrKpVVfUU4LXAN6rqdTh+E23sVkpP8pvA2Qwusjy3qt474i5pHkk+A7wIeDyD\n", + "+f6/AL4I/DPwZOAW4NVV9YtR9VHzG94V9i3gGh6cWngPcDmO4VhL8nQGFy3vM/w5r6o+kGQFjt1E\n", + "SfIi4O1VdbLjN9nGLqGSJEmaNOM25SdJkjRxTKgkSZI6MqGSJEnqyIRKkiSpIxMqSZKkjkyoJEmS\n", + "OjKhkjRySb4z/O8vJzn1ET72mTtrS5IeSa5DJWlsJDmOwSKHL2/xmkVVtXUXz6+vquWPRP8kaT6e\n", + "oZI0ckk2DB++D3hBkiuTnJZknyQfSHJ5kquT/PEw/rgklyT5InDdcN/5Sa5Icl2SNw33vQ+YHh7v\n", + "vNltZeADSa5Nck2SV8869n8m+ZckNyb51J59NyRNokWj7oAk8WDpm3cB79h+hmqYQP2iqo5Oshj4\n", + "dpILh7FHAkdU1X8Pt99YVeuGte0uT/K5qnp3krdU1ZE7aeu3gF8HngE8Afh+km8Nn3smsAa4HfhO\n", + "kmOryqlCSfPyDJWkcZI52ycAr09yJfA9YAXwq8PnLp+VTAGcluQq4FJgFfDUBdp6PvDpGrgT+Cbw\n", + "HAYJ1+VV9bMaXBNxFbC6w+8k6VHAM1SSxt1bq+qi2TuG11ptnLP9EuCYqro/ycXAkgWOWzw8gdt+\n", + "9mrzrH3b8G+lpAV4hkrSOFkPzL6A/OvAm5MsAkhyWJKlO3ndY4F1w2Tq14BjZj03s/31c1wCvGZ4\n", + "ndYTgBcCl/PwJEuSFuS/uiSNg+1nhq4Gtg2n7j4GfJjBdNsPkgS4EzhlGD/7FuWvAX+S5Abghwym\n", + "/bb7KHBNkrVV9brtr6uqf03y3GGbBbyzqu5M8rQ5x2Yn25L0EC6bIEmS1JFTfpIkSR2ZUEmSJHVk\n", + "QiVJktSRCZUkSVJHJlSSJEkdmVBJkiR1ZEIlSZLUkQmVJElSR/8PcYZmdpOLkfYAAAAASUVORK5C\n", + "YII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -4411,7 +4457,7 @@ "T5UJ3wAAAABJRU5ErkJggg==\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -4421,86 +4467,85 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAENFJREFUeJzt3XuwXeVZx/Hf7+xzy4UDxESQkBrUoFxaC7YEKIViq4NM\n", - "oVVrKWqL1anjtLURW6aUGf1Lp7WMU1o6OlNBWqhtVVppOwoFLVJKbVIg4RbKxWmUexQhJ7dzcpI8\n", - "/rH3CZvDubxvVt6z9kq+n5lM9lr72et9937X3nmyLu/jiBAAAAD2X1/dHQAAAGg6EioAAICKSKgA\n", - "AAAqIqECAACoiIQKAACgIhIqAACAivrrbNw2czYAAIDGiAhPt75oQmX7PElXSWpJuiYi/mJqzLJl\n", - "y17xuu3bt2vRokUvW9dqtXLazern3r17k2Nz5u0qNcdXX1/6gcWcWCnvs5spdnR0VCMjIy9bl/MZ\n", - "7969u0hsbvyePXuKxOb0IWcfyt3vp9s39uzZM+13LWc/yulzqc8YAOZbsVN+tluSPivpPEknSrrY\n", - "9gml2gMAAKhLyWuoTpP0eERsiogJSV+R9LaC7QEAANSiZEK1XNITXctPdtbNaWBgoEiHMD+Ghobq\n", - "7gL2U+5pQwBAW8mEar8vIBocHDyQ/cA8I6Fqrtxr7gAAbSUvSn9K0oqu5RVqH6V6me3bt+97PDAw\n", - "QDIFAAAap2RCdbekVbZXSnpa0kWSLp4aNPVuPgAAgKYpllBFxG7bH5T0LbWnTbg2Ih4u1R4AAEBd\n", - "is5DFRE3S7q5ZBsAAAB1q3WmdElauHBhUlypiRNzt50TmzOZZanJRXO2mxvfC7G5k6eWmmy1iZgo\n", - "EwAOHG7pAQAAqIiECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqIqEC\n", - "AACoiIQKAACgIhIqAACAilxnbTPbsWjRoqTY/v70soNDQ0NZ/RgeHi4Sm9Pnvr703HZiYiI5Nreu\n", - "4fj4eHLsrl27kmNL1UvMrUdXan/PGT/btW9Xyts3Su1zpeo2lvxdKzUmJWt09gLqaPaenH05JzZH\n", - "qe9Ibnxq7N69exUR03a66BEq2yts3277IdsP2v5QyfYAAADqkH4IZf9MSLo0IjbYXizpHtu3RcTD\n", - "hdsFAACYN0WPUEXEsxGxofN4m6SHJR1Tsk0AAID5Nm8XpdteKekUSWvnq00AAID5MC8JVed0342S\n", - "1nSOVAEAABw0Sl9DJdsDkr4q6YsRcdPU57vvFGu1Wmq1WqW7BAAAMKeISL4DsGhC5fb9kNdK2hgR\n", - "V00XMzg4WLILAAAA+8X2y6Z2mG3KktKn/N4g6bclnWt7fefPeYXbBAAAmFdFj1BFxHfFbOwAAOAg\n", - "R7IDAABQUe2lZ04++eSk2JxyFrnlVnJKqJQqt1Kq7ETJqfpLlb8o2Yec+Jzxy9lur5QNKfXdp8QI\n", - "gINZLaVnAAAADgUkVAAAABWRUAEAAFREQgUAAFARCRUAAEBFJFQAAAAVkVABAABUREIFAABQEQkV\n", - "AABARSRUAAAAFdVeembp0qVJsf396XWch4eHs/qxcOHC5NgFCxYkx7ZareRYe9qZ7KeVM2Z9fXk5\n", - "8+DgYHJszvsbGRlJjj3yyCOTY48++ujkWElavnx5cuyyZcuKxC5ZsiQ5Nqf8zdatW5NjJWnbtm3J\n", - "sTljfcwxxxSJzdmHcr5PUt7n/PzzzyfH5nxuOft97m9cKTm/RePj48mxo6OjybG5n0XOvyU5csqS\n", - "5by/Z555Zn+6kyRn/MbGxpJjc/7dGRoaSo7NHeuc+NTv6qpVq2YsPTPjnmX71yWFpOleGBHxtZTG\n", - "bbck3S3pyYi4IOU1AAAATTJbqn6B2gnVTJISKklrJG2UdFhqpwAAAJpkxoQqIn6n6sZtHyvpfEl/\n", - "LumPq24PAACgF815otP20bavtX1LZ/lE27+XuP1PSbpM0t4KfQQAAOhpKVeOfV7SrZImrx59TNKl\n", - "c73I9lslbY6I9Zr+OiwAAICDQsrtDksj4u9tXy5JETFhe3fC686UdKHt8yUNSxqxfX1EvKc7aPv2\n", - "7fseDwwMZN1lBgAAUMratWu1du3apNiUhGqb7R+bXLB9uqQtc70oIq6QdEXnNedI+sjUZEqSFi1a\n", - "lNRRAACA+bR69WqtXr163/LVV189Y2xKQvVhSd+U9FO2vydpmaR37Ee/6pvwCgAAoKA5E6qIuMf2\n", - "2ZJ+Vu1roR6JiImcRiLiDkl37F8XAQAAetucCZXtBZLeL+kstY8y3Wn7ryMifdpUAACAg1jKKb/r\n", - "JY1K+ozaR6h+U9INkn6jYL8AAAAaIyWhOikiTuxa/rbtjQeqAyXu6supqSTl1SjKqX1Uqk5iTp2y\n", - "3Jpmpd7f3r3pU5Hl1FXbvTvlhtP923ZObM77y4nNkTvWpfajUmNdZ91RAAe33N/P6aTMQ3Wv7TO6\n", - "Gj1d0j2VWwYAADhIzFYc+YGumLtsP6H2NVSvkvTIPPQNAACgEeYqjgwAAIA5zFYceVP3su0fV3vG\n", - "cwAAAHRJKY58oe3HJP1I7bmkNkm6uXC/AAAAGiPlovQ/k3SGpEcj4jhJb5aUVtgGAADgEJCSUE1E\n", - "xP9K6rPdiojbJb2ucL8AAAAaI2UeqhdsHybpTkl/Z3uzpG1luwUAANAcKUeo3i5ph6RLJd0i6XFx\n", - "ByAAAMA+KcWRJ49G7ZH0+aK9AQAAaKDZJvbcpvZEntOJiBgp06XqSpbgyCl/UWq7JfX1pRy0bGu1\n", - "WkX6kPNZ5JQukaSJiYnk2JyyNqVic+Tu9/39KWf824aH02dMySk9s2PHjuTYnLHL/T71yvcvVdP6\n", - "m6uJv50HonQJmm22eagWV9247SMkXSPpJLWTs9+NiO9X3S4AAEAvSf8v6v75tKR/iYh32O6XtKhw\n", - "ewAAAPOuWEJl+3BJb4yISyQpInZL2lKqPQAAgLqkXzCT7zhJ/2P7Otv32v4b2wsLtgcAAFCLkglV\n", - "v6RTJf1VRJwqabukywu2BwAAUIuS11A9KenJiPhBZ/lGTZNQjY6O7ns8NDSkoaGhgl0CAABIk3MX\n", - "abGEKiKetf2E7eMj4lFJb5H00NS4kZGenX0BAAAcwqZOhzFbglX6Lr8/VLtczaCk/5T03sLtAQAA\n", - "zLuiCVVE3Cfp9SXbAAAAqFvJi9IBAAAOCaVP+c0ptXxJTomR3NIeOaUycmJz5JQtyCn5klNKJnfb\n", - "pUrP5Gw3t9xDzr4xPj6eHFuqhErO/pZbgiOnHzt37szadqpSZUN6pRxJjib2GS8pVZYs9zc8Z9tN\n", - "K5dTsqRUauxscRyhAgAAqIiECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgA\n", - "AAAqIqECAACoiIQKAACgotpLz/SCUuU9SpUiyNlubhmeUiVwcj7jnJIou3btSo6V8koY5cT2Qkmi\n", - "kmUkeuE7gkPHwb5f5Ly/3N+WUmVtcmJLvb9eKD0zm6JHqGx/zPZDth+w/SXbQyXbAwAAqEOxhMr2\n", - "Sknvk3RqRLxaUkvSu0q1BwAAUJeSp/xGJU1IWmh7j6SFkp4q2B4AAEAtih2hioj/k/SXkv5b0tOS\n", - "XoyIfy3VHgAAQF1KnvL7aUl/JGmlpGMkLbb9W6XaAwAAqEvJi9JfJ+l7EfF8ROyW9DVJZ04N2rJl\n", - "y74/Y2NjBbsDAABQRslrqH4o6U9sL5A0JuktktZNDTr88MMLdgEAAKC8ktdQ3Sfpekl3S7q/s/pz\n", - "pdoDAACoS9GJPSPik5I+WbINAACAulF6BgAAoCISKgAAgIpqr+W3Y8eOpLiSdcpyahSVqq1Wqu5f\n", - "bh2onPicOoGlaujlyvnsBgYGimw3J7a/P/0rumDBguRYSRoeHk6OzamvODo6mhw7Pj6eHJuzX+R8\n", - "p6W8sT7iiCOSY3O+IzmfW24Ny1Jy9uXBwcHk2JGRkeTYnH1IKlc7Luf9LV68ODn2qKOOSo6V8r4n\n", - "Oftnzm9RqT7k/A7lxqfuF5s2bZrxOY5QAQAAVERCBQAAUBEJFQAAQEUkVAAAABWRUAEAAFREQgUA\n", - "AFBRTyZUubdGorcwfs21c+fOuruACnJu80dvGRsbq7sLqIiECgcc49dc/Kg3GwlVc/Hda76eTKgA\n", - "AACahIQKAACgItd5iNg2x6cBAEBjRMS0NZdqTagAAAAOBpzyAwAAqIiECgAAoKKeS6hsn2f7h7Yf\n", - "s/3RuvuDmdn+W9vP2X6ga90S27fZftT2rbaPqLOPmJntFbZvt/2Q7Qdtf6iznjHscbaHba+1vcH2\n", - "Rtsf76xn7BrEdsv2etvf7Cwzfg3WUwmV7Zakz0o6T9KJki62fUK9vcIsrlN7rLpdLum2iDhe0r91\n", - "ltGbJiRdGhEnSTpd0gc63zfGsMdFxJikcyPitZJeI+lc22eJsWuaNZI2Spq8mJnxa7CeSqgknSbp\n", - "8YjYFBETkr4i6W019wkziIg7Jb0wZfWFkr7QefwFSW+f104hWUQ8GxEbOo+3SXpY0nIxho0QETs6\n", - "DwcltdT+LjJ2DWH7WEnnS7pG0uRdY4xfg/VaQrVc0hNdy0921qE5joqI5zqPn5N0VJ2dQRrbKyWd\n", - "ImmtGMNGsN1ne4PaY3R7RDwkxq5JPiXpMkl7u9Yxfg3WawkVczgcRKI9Jwdj2uNsL5b0VUlrImJr\n", - "93OMYe+KiL2dU37HSjrb9rlTnmfsepTtt0raHBHr9dLRqZdh/Jqn1xKqpySt6FpeofZRKjTHc7aP\n", - "liTbPyFpc839wSxsD6idTN0QETd1VjOGDRIRWyT9s6RfEGPXFGdKutD2jyR9WdIv2r5BjF+j9VpC\n", - "dbekVbZX2h6UdJGkb9TcJ+T5hqRLOo8vkXTTLLGokW1LulbSxoi4quspxrDH2V46eQeY7QWSfknS\n", - "ejF2jRARV0TEiog4TtK7JH07It4txq/Rem6mdNu/IukqtS+yvDYiPl5zlzAD21+WdI6kpWqf7/9T\n", - "SV+X9A+SXiVpk6R3RsSLdfURM+vcFfYdSffrpVMLH5O0ToxhT7P9arUvWu7r/LkhIq60vUSMXaPY\n", - "PkfShyPiQsav2XouoQIAAGiaXjvlBwAA0DgkVAAAABWRUAEAAFREQgUAAFARCRUAAEBFJFQAAAAV\n", - "kVABqJ3tuzp//6Ttiw/wtq+Yri0AOJCYhwpAz7D9JrUnObwg4zX9EbF7lue3RsRhB6J/ADATjlAB\n", - "qJ3tbZ2Hn5D0Rtvrba+x3Wf7StvrbN9n+/c78W+yfaftr0t6sLPuJtt3237Q9vs66z4haUFnezd0\n", - "t+W2K20/YPt+2+/s2va/2/5H2w/b/uL8fhoAmqi/7g4AgF4qffNRSR+ZPELVSaBejIjTbA9J+q7t\n", - "Wzuxp0g6KSL+q7P83oh4oVPbbp3tGyPictsfiIhTpmnr1yT9vKTXSFom6Qe2v9N57rWSTpT0jKS7\n", - "bL8hIjhVCGBGHKEC0Es8ZfmXJb3H9npJ35e0RNLPdJ5b15VMSdIa2xsk/YekFZJWzdHWWZK+FG2b\n", - "Jd0h6fVqJ1zrIuLpaF8TsUHSygrvCcAhgCNUAHrdByPitu4VnWuttk9ZfrOk0yNizPbtkobn2G7o\n", - "lQnc5NGr8a51e8RvJYA5cIQKQC/ZKqn7AvJvSXq/7X5Jsn287YXTvG5E0gudZOrnJJ3e9dzE5Oun\n", - "uFPSRZ3rtJZJOlvSOr0yyQKAOfG/LgC9YPLI0H2S9nRO3V0n6TNqn26717YlbZb0q5347luUb5H0\n", - "B7Y3SnpE7dN+kz4n6X7b90TEuydfFxH/ZPuMTpsh6bKI2Gz7hCnb1jTLAPAyTJsAAABQEaf8AAAA\n", - "KiKhAgAAqIiECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICK/h/BppqaWNmBIwAA\n", - "AABJRU5ErkJggg==\n" + "AAALEgAACxIB0t1+/AAAELpJREFUeJzt3X+QXeVdx/HPZ3fZ7MaEkBBoA0kJKlF+tBYsDFACxVYH\n", + "mUKr1lLUFqtTx2lrI7ZMKTP6lw61jFPsdHSmgrRQ26q00nYUCirSlNqkQEKAUCBOUX5IorKEXfJr\n", + "d/P1j3s3XJb98Tx78uw9Z/t+zezknnu/9zzPnufes9+cH8/XESEAAADMXU+3OwAAANB0JFQAAAAV\n", + "kVABAABUREIFAABQEQkVAABARSRUAAAAFfV1s3HbzNkAAAAaIyI81fNFEyrbF0m6XlKvpBsi4k8n\n", + "x6xatepV7xseHtbSpUsnr6tQL6WcubgOHjxYrB+pcrZFb29v1rpz4nt6pj7AOTQ0pOXLl2e12yln\n", + "PA4cOJC17pz4nNixsbEisTmft9zvyFTjNzY2pr6+V+8Wcj4XOeM3Pj6eHJuz3Zhfr35K7cMZa9RF\n", + "sVN+tnslfVbSRZJOkXS57ZNLtQcAANAtJa+hOkvSjoh4MiJGJX1F0jsKtgcAANAVJROq4yU91bH8\n", + "dPu5WfX39xfpEObHwMBAt7uAOZruNC4AYGYl955zPrG9aNGiw9kPzLPBwcFudwFzREIFAHNT8qL0\n", + "ZySt6Vheo9ZRqlcYHh4+9Li/v59kCgAANE7JhOo+SSfZXivpWUmXSbp8ctDku/kAAACaplhCFRFj\n", + "tj8s6VtqTZtwY0Q8Wqo9AACAbik6D1VE3C7p9pJtAAAAdFtXZ0qX0u/oy5ngMGeywNx150wumNOP\n", + "UrG5E5HmxJeKLTlRH5MAAt3Bdw8LHbf0AAAAVERCBQAAUBEJFQAAQEUkVAAAABWRUAEAAFREQgUA\n", + "AFARCRUAAEBFJFQAAAAVkVABAABUREIFAABQEQkVAABARV2v5Wc7Ke6II45IXmdObE4fcmNz9PSU\n", + "yW1z+5tTb6tULb/R0dHk2P379yfHSnl1EHO2RR0+F319eV/nnLqUBw4cKBKb04fcupQ5csY6Z0xy\n", + "YkvWK20a6v7Njzr87csZ67p/LooeobK9xvbdth+x/bDtj5RsDwAAoBtKH6EalXRlRGy1vUTS/bbv\n", + "iohHC7cLAAAwb4oeoYqI5yJia/vxiKRHJR1Xsk0AAID5Nm8XpdteK+l0SZvmq00AAID5MC8JVft0\n", + "362SNrSPVAEAACwYxe/ys32EpK9K+mJE3Db59aGhoUOPBwYGNDg4WLpLAAAAh1XRhMqt+yxvlLQ9\n", + "Iq6fKmb58uUluwAAAFBc6VN+b5b0G5IutL2l/XNR4TYBAADmVdEjVBHxHTEbOwAAWOBIdgAAACrq\n", + "eumZ1NIhpaa9l8qVWyk1pX6pPuSuu2nbYi7xqUr9fiXLMtTlM9c0JUvgAPNpIZV9qQOOUAEAAFRE\n", + "QgUAAFARCRUAAEBFJFQAAAAVkVABAABUREIFAABQEQkVAABARSRUAAAAFZFQAQAAVERCBQAAUFHX\n", + "S88sWrTosK8zd4r83t7e5NhSJXBKTevf15c3xP39/UXWvXz58uTYY489Njn2uOOOS46VpJUrVybH\n", + "Dg4OJscuWbIkOXbVqlXJsTn27duXFT8+Pp4cu2LFiuTY1atXJ8ceffTRybEDAwPJsTm/mySNjY0l\n", + "xz7//PPJsUuXLk2OzdnGOduipNHR0eTY3bt3F4nN3Qfk/M3p6Uk/5pCzD3/ppZeSYzdt2pQcK0nb\n", + "tm1Ljs3527d48eLk2HXr1iXHnnDCCcmxy5YtS46V8v/+pZjpOz1ta7Z/RVJImiqDiIj4Wkrjtnsl\n", + "3Sfp6Yi4JOU9AAAATTJT+naJWgnVdJISKkkbJG2XlP5fNQAAgAaZNqGKiN+sunLbqyVdLOlPJP1B\n", + "1fUBAADU0awniG2/1vaNtu9oL59i+7cT1/9pSVdJOlihjwAAALWWcsXd5yXdKWniyr8nJF0525ts\n", + "v13SrojYoqmvwwIAAFgQUi6BXxkRf2v7akmKiFHbKbfEnCvpUtsXSxqQdKTtmyPifZ1BQ0NDhx4P\n", + "DAxk3VkFAABQysaNG7Vx48ak2JSEasT2oXubbZ8tadZ7WiPiGknXtN9zgaSPTU6mpLzb6QEAAObL\n", + "+vXrtX79+kPL11577bSxKQnVRyV9U9KP2/6upGMkvWsO/Soz0RIAAECXzZpQRcT9ts+X9FNqXQv1\n", + "WESkz+bWWsc9ku6ZWxcBAADqbdaEyvagpA9KOk+to0wbbf9lRORNywwAALBApZzyu1nSi5I+o9YR\n", + "ql+TdIukXy3YLwAAgMbwbPWHbG+PiFNme25OjduRWofp4MH0qaxyYnPjc+o1larPl6NU7cFcpcYv\n", + "pwablFfjrVSfcz4XObXEcsc6Jz6nzznbOLfmHgB0W0RMufNM2Vs/YPuciYX2XX73H66OAQAANN1M\n", + "xZEf6oi51/ZTal1D9TpJj81D3wAAABphtuLIAAAAmMVMxZGf7Fy2faxaM54DAACgQ0px5EttPyHp\n", + "h2rNJfWkpNsL9wsAAKAxUi5K/2NJ50h6PCJOlPRWSZuK9goAAKBBUhKq0Yj4X0k9tnsj4m5Jbyrc\n", + "LwAAgMZImdhzyPZSSRsl/Y3tXZJGynYLAACgOVKOUL1T0h5JV0q6Q9IOcQcgAADAISnFkSeORo1L\n", + "+nzR3gAAADTQTBN7jqg1kedUIiKOPBwd2LNnT1JcXUpwlOpHHcrUSPUorZOz3Xp7e4v0IXfdOdui\n", + "LqWOcuJzxqSvL+VKgpac71NJdRiTuuwDSqnLvnOhb+eF/vvV2UzzUC2punLbR0m6QdKpaiVnvxUR\n", + "36u6XgAAgDpJ/6/k3Py5pH+KiHfZ7pP0Y4XbAwAAmHfFEirbyyStj4grJCkixiTtLtUeAABAt5S8\n", + "gOFESf9j+ybbD9j+K9uLC7YHAADQFSUTqj5JZ0j6i4g4Q9JLkq4u2B4AAEBXlEyonpb0dER8v718\n", + "q1oJ1ivs3bv30M/o6GjB7gAAAJRR7BqqiHjO9lO210XE45LeJumRyXGDg4OlugAAADAvSt/l93tq\n", + "lavpl/Qfkt5fuD0AAIB5VzShiogHJZ1Zsg0AAIBuq8c0xQAAAA1W+pTf7B1ILFNRqjxMbnyp2JK/\n", + "X45SJVRyYkuVOZlLfKr9+/cnx+7enT4d24EDB5Jjc7axtLBLqOSWn6rLulPVYRvnyv18LmQl9/c5\n", + "6y71Wa7LvqXE92SmdXKECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAq\n", + "IqECAACoiIQKAACgIhIqAACAirpeeiZ1Wv06TKcvlZsmP6fPOesdHx9Pjs1dd07s6OhocmxOuZWc\n", + "WClve+SUyig11nX53JfaFk0soZKj1PcazVZyH15qn5FTAqdUCbO6f0eKHqGy/Qnbj9h+yPaXbC8q\n", + "2R4AAEA3FEuobK+V9AFJZ0TE6yX1SnpPqfYAAAC6peQpvxcljUpabHtc0mJJzxRsDwAAoCuKHaGK\n", + "iOcl/Zmk/5L0rKQXIuKfS7UHAADQLSVP+f2EpN+XtFbScZKW2P71Uu0BAAB0S8mL0t8k6bsR8X8R\n", + "MSbpa5LOnRw0MjJy6Cf3ji0AAIA6KHkN1Q8k/aHtQUn7JL1N0ubJQUuWLCnYBQAAgPJKXkP1oKSb\n", + "Jd0naVv76c+Vag8AAKBbik7sGRGfkvSpkm0AAAB0G6VnAAAAKiKhAgAAqKgxtfyaWB+sVL2mnPpL\n", + "OXWSpLw+59R26u3tTY7t7+9Pjs2tX5ezPUr9fjnbOGe9ixblVXYaGBhIjt27d29y7O7du5Njc+7s\n", + "zRm7nO0m5W2Lo446Kjn2xRdfTI4dGRlJjh0bG0uOLamvL/1PSM4NSMuWLUuO3blzZ3KslFdXNOcz\n", + "l7MvGhwcTI4988wzk2Ml6bTTTkuOzfn+5Xw+d+zYkRz7zDPp833n9EHKG+vU/f3w8PD060huDQAA\n", + "AFMioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqIqECAACoqJYJ1f79+7vdBVTA+DXXnj17ut0FVFCX\n", + "KWOQry5TYWDuaplQ5cyNgfohoWqunPmmABw+OXMRop5qmVABAAA0CQkVAABARe7mOXfbnPAHAACN\n", + "ERFT1hnqakIFAACwEHDKDwAAoCISKgAAgIpql1DZvsj2D2w/Yfvj3e4Ppmf7r23vtP1Qx3MrbN9l\n", + "+3Hbd9o+qpt9xPRsr7F9t+1HbD9s+yPt5xnDmrM9YHuT7a22t9u+tv08Y9cgtnttb7H9zfYy49dg\n", + "tUqobPdK+qykiySdIuly2yd3t1eYwU1qjVWnqyXdFRHrJP1Lexn1NCrpyog4VdLZkj7U/r4xhjUX\n", + "EfskXRgRb5T0BkkX2j5PjF3TbJC0XdLExcyMX4PVKqGSdJakHRHxZESMSvqKpHd0uU+YRkRslDQ0\n", + "6elLJX2h/fgLkt45r51Csoh4LiK2th+PSHpU0vFiDBshIiamte+X1KvWd5GxawjbqyVdLOkGSRN3\n", + "jTF+DVa3hOp4SU91LD/dfg7N8ZqI2Nl+vFPSa7rZGaSxvVbS6ZI2iTFsBNs9treqNUZ3R8QjYuya\n", + "5NOSrpJ0sOM5xq/B6pZQMYfDAhKtOTkY05qzvUTSVyVtiIjhztcYw/qKiIPtU36rJZ1v+8JJrzN2\n", + "NWX77ZJ2RcQWvXx06hUYv+apW0L1jKQ1Hctr1DpKhebYafu1kmR7laRdXe4PZmD7CLWSqVsi4rb2\n", + "04xhg0TEbkn/KOlnxdg1xbmSLrX9Q0lflvRztm8R49dodUuo7pN0ku21tvslXSbpG13uE/J8Q9IV\n", + "7cdXSLpthlh0kW1LulHS9oi4vuMlxrDmbK+cuAPM9qCkn5e0RYxdI0TENRGxJiJOlPQeSf8aEe8V\n", + "49dotZsp3fYvSrperYssb4yIa7vcJUzD9pclXSBppVrn+/9I0tcl/Z2k10l6UtK7I+KFbvUR02vf\n", + "FfZtSdv08qmFT0jaLMaw1my/Xq2LlnvaP7dExHW2V4ixaxTbF0j6aERcyvg1W+0SKgAAgKap2yk/\n", + "AACAxiGhAgAAqIiECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhApA19m+t/3vCbYvP8zrvmaqtgDg\n", + "cGIeKgC1Yfstak1yeEnGe/oiYmyG14cjYunh6B8ATIcjVAC6zvZI++EnJa23vcX2Bts9tq+zvdn2\n", + "g7Z/px3/FtsbbX9d0sPt526zfZ/th21/oP3cJyUNttd3S2dbbrnO9kO2t9l+d8e6/83239t+1PYX\n", + "53drAGiivm53AAD0cumbj0v62MQRqnYC9UJEnGV7kaTv2L6zHXu6pFMj4j/by++PiKF2bbvNtm+N\n", + "iKttfygiTp+irV+W9DOS3iDpGEnft/3t9mtvlHSKpP+WdK/tN0cEpwoBTIsjVADqxJOWf0HS+2xv\n", + "kfQ9SSsk/WT7tc0dyZQkbbC9VdK/S1oj6aRZ2jpP0peiZZekeySdqVbCtTkino3WNRFbJa2t8DsB\n", + "+BHAESoAdffhiLir84n2tVYvTVp+q6SzI2Kf7bslDcyy3tCrE7iJo1f7O54bF/tKALPgCBWAOhmW\n", + "1HkB+bckfdB2nyTZXmd78RTvO1LSUDuZ+mlJZ3e8Njrx/kk2SrqsfZ3WMZLOl7RZr06yAGBW/K8L\n", + "QB1MHBl6UNJ4+9TdTZI+o9bptgdsW9IuSb/Uju+8RfkOSb9re7ukx9Q67Tfhc5K22b4/It478b6I\n", + "+Afb57TbDElXRcQu2ydPWremWAaAV2DaBAAAgIo45QcAAFARCRUAAEBFJFQAAAAVkVABAABUREIF\n", + "AABQEQkVAABARSRUAAAAFZFQAQAAVPT/E259UVIep5MAAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -4590,7 +4635,7 @@ "aBwD40TjGBgnGsfAONE4BsaJxjEwTjSOgfl/g7yNWl4b+UcAAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -4600,78 +4645,80 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAADzVJREFUeJzt3WuQZVdZh/HnP90zyYwTJkQwBBgcVNAkBRIEKtwJoBUp\n", - "CKgIiQqIFpYFSIxIcanST1oglEWkKK3CRC5BQAUMUCoQJUIAyRCYyW3CzSKagGS8DIEmmWF68vrh\n", - "nEk6zVz27j2rzzmd51fVNWef8561Vp/V3fXO3muvN1WFJEmSVm7dpAcgSZI060yoJEmSBjKhkiRJ\n", - "GsiESpIkaSATKkmSpIFMqCRJkgaan2TnSdyzQZIkzYyqyqGeb5pQJTkbuBCYAy6qqj9ZHnPyySf/\n", - "wPsWFhbYvHnzivu94447msUvLi42affAgQNN2u27z9ixaPvAgQPMzc2teBytYlcSL0lSF80u+SWZ\n", - "A94KnA2cBpyX5NRW/UmSJE1KyzVUjwG+VlU3VtV+4H3Asxv2J0mSNBEtE6oHADctOb55/NxRbdiw\n", - "ocmAtDqSQ15eliRpzWqZUK14sYoJ1Wxbt86bRyVJ9ywtF6V/A9i65Hgro7NUd7OwsHDn4w0bNphM\n", - "SZKkmdMyoboKeEiSbcA3gecD5y0PGnI3nyRJ0jRollBV1WKSlwMfY7RtwsVVdUOr/iRJkiYlk9yX\n", - "J0kdah+qodyH6i6T2IdqWmNXEi9J0lIT2dizi3vf+96d4pZvFHkkfe8y69P2/Hz3j2zjxo2dY084\n", - "4YTOsSeeeGLn2C1btnSOhX6XYPt8f5s2bWoyhpNOOqlzLMApp5zSObZPst/15xj6fRZ9FvhPy92V\n", - "rX5XW/4NaKXPOFrFQr//SLT67KZlTmbNLP6ncRbnuuvndqS/Q96OJUmSNJAJlSRJ0kAmVJIkSQOZ\n", - "UEmSJA1kQiVJkjSQCZUkSdJAJlSSJEkDmVBJkiQNZEIlSZI0kAmVJEnSQCZUkiRJA028OHLXGmjr\n", - "16/v3O5xxx3Xaxx94vu23VWf4si3335759h9+/b1Gkef+P3793eOXevFn/uYtXb7mpZxtNKqTtla\n", - "/9ykteJwxZGbnqFKsjXJ5UmuT3Jdkle07E+SJGkS5hu3vx+4oKp2JtkMfCHJZVV1Q+N+JUmSVk3T\n", - "M1RV9a2q2jl+vADcANy/ZZ+SJEmrbdUWpSfZBpwBXLlafUqSJK2GVUmoxpf73g+cPz5TJUmStGa0\n", - "XkNFkvXAB4B3V9Wly19fesfa/Px8r7v5JEmSpkHThCqj+4svBnZV1YWHitm4cWPLIUiSJDXX+pLf\n", - "44FfA85KsmP8dXbjPiVJklZV0zNUVfVp3I1dkiStcSY7kiRJA0289My2bds6xfYpGdInFmBxcbFz\n", - "7DSUUJmG8il92163bjpy91Zz3afdVvPXd65blVBppeVnsdZNw1w7JyszDXPX0iz+XEyk9IwkSdI9\n", - "gQmVJEnSQCZUkiRJA5lQSZIkDWRCJUmSNJAJlSRJ0kAmVJIkSQOZUEmSJA1kQiVJkjSQCZUkSdJA\n", - "TYsjd7Fnz55j3mbfMid94luVAehTjqRV+RvoVwagzzhalQ3pW7ZgWsq+TINZHLNWxrmeXc7d7Dhs\n", - "QpXkl4ACDpVBVFV9sEsHSeaAq4Cbq+pZKxqlJEnSFDvSGapnMUqoDqdTQgWcD+wCTug6KEmSpFly\n", - "2ISqqn59aONJHgg8A/hj4PeGtidJkjSNjrp4KMn9klyc5KPj49OS/GbH9t8MvArot5BHkiRphnRZ\n", - "jf0O4OPA/cfHXwUuONqbkjwT2F1VOzj0OixJkqQ1oUtCdZ+q+hvgAEBV7QcWO7zvccA5Sb4OvBd4\n", - "apJ3LQ/au3fvnV+Li12alSRJmi5dEqqFJD988CDJmcCtR3tTVb2uqrZW1YOBc4FPVNULl8cdf/zx\n", - "d37Nz098FwdJkqTeumQwrwQ+AvxYks8C9wWeu4K+3ExDkiStSemyaViSeeAnGa2F+vL4st/wzpPa\n", - "smXLsWjqbqZlY89Wm2S6sefKYsGNPSVJw1TVIROBo56hSrIReCnwBEZnma5I8hdVtffYDlGSJGk2\n", - "dbnk9y7gO8BbGJ2h+hXgEuCXG45LkiRpZnRJqE6vqtOWHH8iya5jNYC5ublOcX0utbWqt9dXn3Gs\n", - "X7++c+yGDRuajAH6Xbrqc/ms1aW2vneG9omflsuw06DV75SXVSWtFV0WD30xyWMPHozv8vtCuyFJ\n", - "kiTNliMVR752ScxnktzEaA3Vg4Avr8LYJEmSZsLRiiNLkiTpKI5UHPnGpcdJfgQ4vvWAJEmSZk2X\n", - "4sjnJPkq8HXgk8CNwD81HpckSdLM6LIo/Y+AxwJfGZeReRpwZdNRSZIkzZAuCdX+qvofYF2Suaq6\n", - "HHhU43FJkiTNjC77UO1JcgJwBfDXSXYDC22HJUmSNDu6nKF6DnAbcAHwUeBreAegJEnSnY56hqqq\n", - "Dp6NOgC8o+loJEmSZtCRNvZcYLSR56FUVd3rWAxg06ZNneJalqhoVWJkGkqX9P0sWpWemYZ2W7a9\n", - "1suirPXvT5KGOtI+VJuHNp7kROAi4HRGydlvVNXnhrYrSZI0TbosSh/iz4B/rKrnJpkHfqhxf5Ik\n", - "SauuWUKVZAvwxKp6EUBVLQK3tupPkiRpUrrc5bdSDwb+O8nbk3wxyV8m6bZgSpIkaYa0TKjmgUcC\n", - "f15VjwS+B7ymYX+SJEkT0TKhuhm4uao+Pz5+P6ME625uvfXWO7/27t3bcDiSJEltNFtDVVXfSnJT\n", - "kodW1VeApwPXL4/bsmVLqyFIkiStitZ3+f0Oo3I1G4B/B17cuD9JkqRV1zShqqqrgUe37EOSJGnS\n", - "Wq6hkiRJukdofcnv6AOY7zaExcXFzm32iYXpKPuSpHPs3Nxc59iWWpVm6fNZ9NVnrlv9zLUsrTNr\n", - "Ws71NFjr8yetFV3/Fh3pd9ozVJIkSQOZUEmSJA1kQiVJkjSQCZUkSdJAJlSSJEkDmVBJkiQNZEIl\n", - "SZI0kAmVJEnSQCZUkiRJA5lQSZIkDTTx0jO33357p7g+5Tr6xEK78hDr1nXPV1vF9v3eupYCAli/\n", - "fn3n2D5j7lMe5vvf/37nWIB9+/Z1ju3zc9Tn++tTbqVPbMsyJ63KDLWK7atVCZxpmT9JR3Ysfv+a\n", - "nqFK8tok1ye5Nsl7khzXsj9JkqRJaJZQJdkGvAR4ZFU9DJgDzm3VnyRJ0qS0vOT3HWA/sCnJAWAT\n", - "8I2G/UmSJE1EszNUVfV/wJ8C/wl8E/h2Vf1zq/4kSZImpeUlvx8HfhfYBtwf2JzkV1v1J0mSNCkt\n", - "F6U/CvhsVf1vVS0CHwQetzxoYWHhzq++d2xJkiRNg5ZrqL4E/EGSjcBe4OnA9uVBmzdvbjgESZKk\n", - "9lquoboaeBdwFXDN+Om3tepPkiRpUppu7FlVbwTe2LIPSZKkSbP0jCRJ0kAmVJIkSQNNvJZfV31q\n", - "pc3NzfVqexpqq7WK7VvXcO/evZ1jb7vtts6xferztYqFfp/HNMzfLJrF728WxyxpuniGSpIkaSAT\n", - "KkmSpIFMqCRJkgYyoZIkSRrIhEqSJGkgEypJkqSBpjKhskjybFtcXJz0ELRCbh8gSStjQqVjzoRK\n", - "knRPM5UJlSRJ0iwxoZIkSRook1wzkcQFG5IkaWZU1SFr0E00oZIkSVoLvOQnSZI0kAmVJEnSQFOX\n", - "UCU5O8mXknw1yasnPR4dXpK/SnJLkmuXPHdSksuSfCXJx5OcOMkx6vCSbE1yeZLrk1yX5BXj553D\n", - "KZfk+CRXJtmZZFeS14+fd+5mSJK5JDuSfGR87PzNsKlKqJLMAW8FzgZOA85LcupkR6UjeDujuVrq\n", - "NcBlVfVQ4F/Gx5pO+4ELqup04EzgZePfN+dwylXVXuCsqnoE8HDgrCRPwLmbNecDu4CDi5mdvxk2\n", - "VQkV8Bjga1V1Y1XtB94HPHvCY9JhVNUVwJ5lT58DvHP8+J3Ac1Z1UOqsqr5VVTvHjxeAG4AH4BzO\n", - "hKq6bfxwAzDH6HfRuZsRSR4IPAO4CDh415jzN8OmLaF6AHDTkuObx89pdpxcVbeMH98CnDzJwaib\n", - "JNuAM4ArcQ5nQpJ1SXYymqPLq+p6nLtZ8mbgVcAdS55z/mbYtCVU7uGwhtRoTw7ndMol2Qx8ADi/\n", - "qr679DXncHpV1R3jS34PBJ6U5Kxlrzt3UyrJM4HdVbWDu85O3Y3zN3umLaH6BrB1yfFWRmepNDtu\n", - "SXI/gCSnALsnPB4dQZL1jJKpS6rq0vHTzuEMqapbgX8AfgbnblY8DjgnydeB9wJPTXIJzt9Mm7aE\n", - "6irgIUm2JdkAPB/48ITHpH4+DLxo/PhFwKVHiNUEJQlwMbCrqi5c8pJzOOWS3OfgHWBJNgI/C+zA\n", - "uZsJVfW6qtpaVQ8GzgU+UVUvwPmbaVO3U3qSnwcuZLTI8uKqev2Eh6TDSPJe4MnAfRhd7/9D4EPA\n", - "3wIPAm4EnldV357UGHV447vCPgVcw12XFl4LbMc5nGpJHsZo0fK68dclVfWmJCfh3M2UJE8GXllV\n", - "5zh/s23qEipJkqRZM22X/CRJkmaOCZUkSdJAJlSSJEkDmVBJkiQNZEIlSZI0kAmVJEnSQCZUkiYu\n", - "yWfG//5okvOOcduvO1RfknQsuQ+VpKmR5CmMNjl8Vo/3zFfV4hFe/25VnXAsxidJh+MZKkkTl2Rh\n", - "/PANwBOT7EhyfpJ1Sd6UZHuSq5P81jj+KUmuSPIh4Lrxc5cmuSrJdUleMn7uDcDGcXuXLO0rI29K\n", - "cm2Sa5I8b0nb/5rk75LckOTdq/tpSJpF85MegCRxV+mbVwO/f/AM1TiB+nZVPSbJccCnk3x8HHsG\n", - "cHpV/cf4+MVVtWdc2257kvdX1WuSvKyqzjhEX78I/DTwcOC+wOeTfGr82iOA04D/Aj6T5PFV5aVC\n", - "SYflGSpJ0yTLjn8OeGGSHcDngJOAnxi/tn1JMgVwfpKdwL8BW4GHHKWvJwDvqZHdwCeBRzNKuLZX\n", - "1TdrtCZiJ7BtwPck6R7AM1SSpt3Lq+qypU+M11p9b9nx04Azq2pvksuB44/SbvGDCdzBs1f7ljx3\n", - "AP9WSjoKz1BJmibfBZYuIP8Y8NIk8wBJHppk0yHedy9gzziZ+ingzCWv7T/4/mWuAJ4/Xqd1X+BJ\n", - "wHZ+MMmSpKPyf12SpsHBM0NXAwfGl+7eDryF0eW2LyYJsBv4hXH80luUPwr8dpJdwJcZXfY76G3A\n", - "NUm+UFUvOPi+qvr7JI8d91nAq6pqd5JTl7XNIY4l6W7cNkGSJGkgL/lJkiQNZEIlSZI0kAmVJEnS\n", - "QCZUkiRJA5lQSZIkDWRCJUmSNJAJlSRJ0kAmVJIkSQP9P+KhTy08mN1cAAAAAElFTkSuQmCC\n" + "AAALEgAACxIB0t1+/AAAD4BJREFUeJzt3XuspVdZx/Hvb87cO4OT2pYWGBysoLQBKQIpdwpoKoHi\n", + "BYGKgGgwBpCKQID+4V8aMMRQCcEEqVzKTQUsEOVSpUIBaSnM9DblZqi2IB2ltyl2JnN5/GPvaU8P\n", + "Z+a877yzzt779PtJTma/7177Xevstc85z6y13vWkqpAkSdLRWzXpBkiSJM06AypJkqSBDKgkSZIG\n", + "MqCSJEkayIBKkiRpIAMqSZKkgVZPsvIk7tkgSZJmRlVlsfNNA6okZwMXAHPAu6vqLxaWOeWUU37i\n", + "dbt372bz5s33Onfw4MHO9fYpC3DgwIEmZVu1uU/ZvvuM9Sl/uLL79+9n9erVncouZtq/P0mSFmo2\n", + "5ZdkDngHcDZwGnBukoe3qk+SJGlSWq6hehzw3aq6oar2AR8BntuwPkmSpIloGVA9ELhx3vFN43NL\n", + "Wrt2bZMGaXmsWuW9DpKk+5aWf/mOegHKunXrjmU7tMwMqCRJ9zUtF6V/H9g673gro1Gqe9m9e/fd\n", + "j9euXWswJUmSZk7LgOpK4KFJtgE/AF4AnLuw0MK7+SRJkmZNs4CqqvYneRXwWUbbJlxYVde3qk+S\n", + "JGlSmu5DVVWfBj7dsg5JkqRJm+hO6dB9AXqfO/8Wbiq5lDVr1jS59oYNGzqXPe644zqX3bhxY+ey\n", + "fadU+1x7/fr1nctu2rSpc9ktW7Z0LnvSSSd1Lgtw8skndy574okndi7bp819+rrP563P5xhgbm6u\n", + "Sdk+NyUki244PLhsX6021u2zEXDLmzn6vHfT0NcrXZ9Ng/fu3dvs2n1+v/T5XEzLz3ULR2qvt2NJ\n", + "kiQNZEAlSZI0kAGVJEnSQAZUkiRJAxlQSZIkDWRAJUmSNJABlSRJ0kAGVJIkSQMZUEmSJA1kQCVJ\n", + "kjSQAZUkSdJAE8/lt2fPnk7l+uQz6pPLqK9pyDvUJ5dYX33eu1b5z/qU3b9/f+ey0C+3Wp+yrd63\n", + "Plp+7vtcu2U7WmmVe6xP2Zbv8Sz2iTRrmo5QJdma5NIk1yW5NsmrW9YnSZI0Ca1HqPYBr6mqHUk2\n", + "AV9PcklVXd+4XkmSpGXTdISqqn5YVTvGj+8Ergce0LJOSZKk5bZsi9KTbAPOAC5frjolSZKWw7IE\n", + "VOPpvo8C541HqiRJklaM5nf5JVkDfAz4QFVdvPD53bt33/147dq1rFu3rnWTJEmSjqmmAVVG9wxf\n", + "COysqgsWK7N58+aWTZAkSWqu9ZTfE4HfAc5Ksn38dXbjOiVJkpZV0xGqqvoS7sYuSZJWOIMdSZKk\n", + "gSaeembVqm4xXcuUL61SPrQq2yd1ScsUFX3a0Spdx9zcXOeyLa30dDJ9tPpZnZb3ok/ZWfzct/r9\n", + "Yvqbe/Tp65Y3avVJr9Unzdd9ta8doZIkSRrIgEqSJGkgAypJkqSBDKgkSZIGMqCSJEkayIBKkiRp\n", + "IAMqSZKkgQyoJEmSBjKgkiRJGsiASpIkaaCJp57ZsGFDp3J9tr3vs51+S31SOLT6/qYl9cy0tKHP\n", + "e9enbMt0QJpd05B+StOnT1/v2bOnYUt0LB02oErym0ABiyUdqqr6eJcKkswBVwI3VdVzjqqVkiRJ\n", + "U+xII1TPYRRQHU6ngAo4D9gJbO7aKEmSpFly2ICqqn536MWTPAh4FvDnwJ8MvZ4kSdI0WnJRepKT\n", + "k1yY5DPj49OS/H7H678NeD3ghL8kSVqxutzl917gc8ADxsffAV6z1IuSPBvYVVXbWXwdliRJ0orQ\n", + "JaA6oar+DjgAUFX7gC63pD0BOCfJ94APA09P8v6FhW655Za7v+66664eTZckSZoOXbZNuDPJTx86\n", + "SHImcPtSL6qq84Hzx695KvC6qnrJwnLHH39899ZKkiRNoS4B1WuBTwE/m+QrwInA846iLjffkSRJ\n", + "K1K6bDCWZDXw84zWQn1rPO03vPKkTj311E5lW27s2WrzvT7tcGPP5WmDG3tKkoaoqkXXhS85QpVk\n", + "A/AK4EmMRpkuS/LXVeX2rZIkSXSb8ns/cAfwdkYjVL8NXAT8VsN2SZIkzYwuAdXpVXXavOPPJ9l5\n", + "rBpw++1Lrm8H2k3Ltbx2qymxZDp2oVi1qntu7VbvRd/rtvwctdCnr6ehvZJ0X9XlL+I3kjz+0MH4\n", + "Lr+vt2uSJEnSbDlScuRr5pX5cpIbGa2hejDwrWVomyRJ0kxYKjmyJEmSlnCk5Mg3zD9OchKwvnWD\n", + "JEmSZk2X5MjnJPkO8D3gC8ANwKcbt0uSJGlmdFmU/mfA44FvV9VDgGcAlzdtlSRJ0gzpElDtq6r/\n", + "BVYlmauqS4HHNG6XJEnSzOiyD9WtSTYDlwEfTLILuLNtsyRJkmbHkrn8kmwC7mI0mvUi4H7AB6vq\n", + "R4MrT+qEE07oVNaNPe/RcmPPVptDtsp11ycHYt92tMqZ2KesG3tK0nQ56lx+VXVoNOoA8N5j2CZJ\n", + "kqQV4Ugbe97JaCPPxVRV3e9YNOC4447rVK7P/9T7pESB6UiL0mekpdUoS99rt3rf+rS55WjdNKTW\n", + "cdRJkmbDkfah2jT04km2AO8GTmcUnP1eVX116HUlSZKmSZdF6UP8FfDPVfW8JKuBbsNRkiRJM6RZ\n", + "QJXkp4AnV9VLAapqP3B7q/okSZImpd9io34eAvxPkvck+UaSv0mysWF9kiRJE9EyoFoNPBp4Z1U9\n", + "Gvgx8MaG9UmSJE1EyzVUNwE3VdXXxscfZZGA6rbbbrv78fr161m/3vzLkiRptjQLqKrqh0luTPKw\n", + "qvo28EzguoXltmzZ0qoJkiRJy6L1XX5/xChdzVrgP4CXNa5PkiRp2TUNqKrqKuCxLeuQJEmatJaL\n", + "0iVJku4TWk/5LemOO+7oVK5PipG+6Uj6pBhp2Y6uZjFRdJ/3YvXq7h/LNWvWdC4L7RIv9ym7b9++\n", + "zmX7ME3N0WuZwqgF+1qaPo5QSZIkDWRAJUmSNJABlSRJ0kAGVJIkSQMZUEmSJA1kQCVJkjSQAZUk\n", + "SdJABlSSJEkDGVBJkiQNZEAlSZI00MRTz3RN2TENKV+gX5qaabjuwYMHe5Xv897Nzc11LtsnVcaB\n", + "Awc6l+2bxqXPtfuU7fM+T8tnuU+bV3qqk1bfX5+f65X+HksrXdMRqiRvSnJdkmuSfCjJupb1SZIk\n", + "TUKzgCrJNuDlwKOr6hHAHPDCVvVJkiRNSsspvzuAfcDGJAeAjcD3G9YnSZI0Ec1GqKrqFuAvgf8C\n", + "fgDcVlX/0qo+SZKkSWk55Xcq8MfANuABwKYkL2pVnyRJ0qS0XJT+GOArVfWjqtoPfBx4wsJCe/fu\n", + "vfur6x1/kiRJ06RlQPVN4MwkGzK69/uZwM6FhdatW3f31+rVE9/FQZIkqbeWa6iuAt4PXAlcPT79\n", + "rlb1SZIkTUomuZlcktq8eXPXsn2ue7RNWpIbex5d2VYbe/adJp6GjT2nhRt7ttdqY0/7Q5qcqlr0\n", + "j5+pZyRJkgYyoJIkSRpo4qvAu075zeL0RJ92tJoy6jv92Wraoc/316dsn2m5vtdu9TmaxamdVtO7\n", + "K90sTgVLOjqOUEmSJA1kQCVJkjSQAZUkSdJABlSSJEkDGVBJkiQNZEAlSZI00FQGVHv37p10EzTA\n", + "vn37Jt0EHSW3PJCko2NApWOubzoYSZJm3VQGVJIkSbPEgEqSJGmgTHLNRBIXbEiSpJlRVYvm4ppo\n", + "QCVJkrQSOOUnSZI0kAGVJEnSQFMXUCU5O8k3k3wnyRsm3R4dXpK/TXJzkmvmnTs+ySVJvp3kc0m2\n", + "TLKNOrwkW5NcmuS6JNcmefX4vH045ZKsT3J5kh1JdiZ58/i8fTdDkswl2Z7kU+Nj+2+GTVVAlWQO\n", + "eAdwNnAacG6Sh0+2VTqC9zDqq/neCFxSVQ8D/nV8rOm0D3hNVZ0OnAm8cvzzZh9OuaraA5xVVY8C\n", + "HgmcleRJ2Hez5jxgJ3BoMbP9N8OmKqACHgd8t6puqKp9wEeA5064TTqMqroMuHXB6XOA940fvw/4\n", + "tWVtlDqrqh9W1Y7x4zuB64EHYh/OhKr6v/HDtcAco59F+25GJHkQ8Czg3cChu8bsvxk2bQHVA4Eb\n", + "5x3fND6n2XH/qrp5/Phm4P6TbIy6SbINOAO4HPtwJiRZlWQHoz66tKquw76bJW8DXg8cnHfO/pth\n", + "0xZQuYfDClKjPTns0ymXZBPwMeC8qto9/zn7cHpV1cHxlN+DgKckOWvB8/bdlErybGBXVW3nntGp\n", + "e7H/Zs+0BVTfB7bOO97KaJRKs+PmJCcDJDkF2DXh9ugIkqxhFExdVFUXj0/bhzOkqm4H/gn4Jey7\n", + "WfEE4Jwk3wM+DDw9yUXYfzNt2gKqK4GHJtmWZC3wAuCTE26T+vkk8NLx45cCFx+hrCYoSYALgZ1V\n", + "dcG8p+zDKZfkhEN3gCXZAPwysB37biZU1flVtbWqHgK8EPh8Vb0Y+2+mTd1O6Ul+FbiA0SLLC6vq\n", + "zRNukg4jyYeBpwInMJrv/1PgE8DfAw8GbgCeX1W3TaqNOrzxXWFfBK7mnqmFNwFXYB9OtSSPYLRo\n", + "edX466KqemuS47HvZkqSpwKvrapz7L/ZNnUBlSRJ0qyZtik/SZKkmWNAJUmSNJABlSRJ0kAGVJIk\n", + "SQMZUEmSJA1kQCVJkjSQAZWkiUvy5fG/P5Pk3GN87fMXq0uSjiX3oZI0NZI8jdEmh8/p8ZrVVbX/\n", + "CM/vrqrNx6J9knQ4jlBJmrgkd44fvgV4cpLtSc5LsirJW5NckeSqJH8wLv+0JJcl+QRw7fjcxUmu\n", + "THJtkpePz70F2DC+3kXz68rIW5Nck+TqJM+fd+1/S/IPSa5P8oHlfTckzaLVk26AJHFP6ps3AK87\n", + "NEI1DqBuq6rHJVkHfCnJ58ZlzwBOr6r/HB+/rKpuHee2uyLJR6vqjUleWVVnLFLXbwC/CDwSOBH4\n", + "WpIvjp97FHAa8N/Al5M8saqcKpR0WI5QSZomWXD8K8BLkmwHvgocD/zc+Lkr5gVTAOcl2QH8O7AV\n", + "eOgSdT0J+FCN7AK+ADyWUcB1RVX9oEZrInYA2wZ8T5LuAxyhkjTtXlVVl8w/MV5r9eMFx88Azqyq\n", + "PUkuBdYvcd3iJwO4Q6NXe+edO4C/KyUtwREqSdNkNzB/AflngVckWQ2Q5GFJNi7yuvsBt46DqV8A\n", + "zpz33L5Dr1/gMuAF43VaJwJPAa7gJ4MsSVqS/+uSNA0OjQxdBRwYT929B3g7o+m2byQJsAv49XH5\n", + "+bcofwb4wyQ7gW8xmvY75F3A1Um+XlUvPvS6qvrHJI8f11nA66tqV5KHL7g2ixxL0r24bYIkSdJA\n", + "TvlJkiQNZEAlSZI0kAGVJEnSQAZUkiRJAxlQSZIkDWRAJUmSNJABlSRJ0kAGVJIkSQP9P+4wayRS\n", + "hyMkAAAAAElFTkSuQmCC\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -4796,7 +4843,7 @@ "SUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -4806,89 +4853,87 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAEX5JREFUeJzt3X+QldV9x/HPh112FwQEqmj5YcEirTLxB00cNUbRpB3r\n", - "RE3bNMa2iU076XSSNNQmTowz7Ywz7SRNphObybQzqdZE0yRtSUqSaTXaVowxjQQF/AGiMqHlh0J/\n", - "AAsEll349o97F5d1lz2Hh7PPvfh+zTDe59nvPefsc5579+vz6+uIEAAAAE7chLoHAAAA0O5IqAAA\n", - "ACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAq6qyzc9s8swEAALSNiPBI64smVLavk3S3pA5J90TE\n", - "nw+PmT179uve19vbq2nTpg1vq9AopcOHDxeJzXnG15EjR5JjSzoZYz548KB6enqOWVdqG+dut5z4\n", - "nNic7VYqFgBQn2Kn/Gx3SPqCpOskXSDpFtvnl+oPAACgLiWvobpU0ssRsTki+iV9XdJNBfsDAACo\n", - "RcmEao6kLUOWtzbXjam7u7vIgDA+OjtrvTQPAIBxVzKhOuGLP0io2hsJFQDgjabkX75tkuYNWZ6n\n", - "xlGqY/T29h593d3dTTIFAADaTsmEarWk82zPl7Rd0s2SbhkeNPxuPgAAgHZTLKGKiAHbH5H0XTUe\n", - "m3BvRGwo1R8AAEBdil7sEhEPSnqwZB8AAAB1q/3q4alTpybF5Tzssb+//0SHc1LlPBhywoT0+wNK\n", - "PXBSKvcAzlZ5sGe7PSgz54G27fa7AcCphFp+AAAAFZFQAQAAVERCBQAAUBEJFQAAQEUkVAAAABWR\n", - "UAEAAFREQgUAAFARCRUAAEBFJFQAAAAVkVABAABUREIFAABQkeus/2U7pkyZkhTb2ZledrCrqytr\n", - "HN3d3cmxEydOzGo7VU5NukOHDhWJzY0fGBhIji1Vny+3ll+OdquNlzvedvv9AKAVRMSIRVaLHqGy\n", - "Pc/2o7aft/2c7Y+W7A8AAKAO6Yd9Tky/pNsiYq3tKZKesv1IRGwo3C8AAMC4KXqEKiJejYi1zdf7\n", - "JG2QNLtknwAAAONt3C5Ktz1f0iWSnhyvPgEAAMbDuCRUzdN9yyUtax6pAgAAOGWUvoZKtidK+oak\n", - "r0TEiuE/7+vrO/q6o6Mj624+AACAVlA0e7FtSfdKWh8Rd48Uk/PIAgAAgFZU+pTfWyX9lqRrbK9p\n", - "/ruucJ8AAADjqugRqoj4vngaOwAAOMWR7AAAAFRUe+mZiy++OCk2Z5w5JVEkqb+/Pzk2pzRLqbIo\n", - "OdtiwoS8nLlx2dvJl1MOKKe8T6lSQFLetsvZLw4cOJAcm7MvD73BI0VuWaJUOftQzmcv5/fLaVcq\n", - "W8IoVc7+1tHRkdV2zucvJzbnuyin/NTBgweTY3O/71uh5FLOZyT3Ozxn38iJzdluOZ+nUmXJpHJz\n", - "XUvpGQAAgDcCEioAAICKSKgAAAAqIqECAACoiIQKAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAA\n", - "oCISKgAAgIpqLz1z9tlnJ8XmPCI/txxJT09Pcmx3d3dybE55gVIlHHJ1dpapl52z3SZNmpQcO2XK\n", - "lKxxTJ06NTk2Z7/IaXfGjBnJsTt27EiO3bRpU3KsJG3bti05NmdfPuecc5JjFy9enBy7cOHC5Nje\n", - "3t7kWElav359cuzq1auTY6dPn54ce8MNNyTH3nTTTcmxUl75kpyyPbt3706O3bBhQ3JszjZOLV82\n", - "6Nxzz02OnTlzZnJsTkmpLVu2JMfmbDdJmjVrVnLs3Llzk2MnT56cHHvWWWclx6bmAJJ0+umnJ8dK\n", - "ed/hqWyPWnpm1L+etn9NUkga6Y0REd9M7LxD0mpJWyMi/RsDAACgTRzvcMQNaiRUo0lKqCQtk7Re\n", - "Uvr/wgMAALSRUROqiPjtqo3bnivpekl/JumPqrYHAADQisY8sW77bNv32n6ouXyB7d9NbP9zkm6X\n", - "dKTCGAEAAFpaypWKX5L0sKTZzeWXJN021ptsv1PSzohYo5GvwwIAADglpNzSdUZE/L3tOyQpIvpt\n", - "DyS87wpJN9q+XlKPpGm274+I9w8N2rt379HXXV1dWXeDAQAAlLJy5UqtXLkyKTYlodpn+6cGF2xf\n", - "JmnPWG+KiDsl3dl8z9WSPj48mZLybjcHAAAYL0uXLtXSpUuPLt91112jxqYkVB+T9B1J59r+gaQz\n", - "Jb37BMZV3wOvAAAAChozoYqIp2xfJenn1LgWamNEpD/5rdHGY5IeO7EhAgAAtLYxEyrbkyR9SNKV\n", - "ahxletz2X0fEwdKDAwAAaAcpp/zul9Qr6fNqHKH6DUkPSPr1guMCAABoG2PW8rO9PiIuGGvdCXVu\n", - "R04toVJy6ugdOZL+SK2cdnNqbeXE5tRgk8pti1LbbWAg5YbT1+TUQWyF2Nz5y5HTdm59zFR9fX3J\n", - "sTk15nL2t1aRMx+tsl+Uii31PZTbdp21blFdic9JRIxayy/lL/PTti8fXGje5ffUyRocAABAuzte\n", - "ceRnh8Q8YXuLGtdQnSNp4ziMDQAAoC2MVRwZAAAAYzheceTNQ5dtz1LjiecAAAAYIqU48o22X5L0\n", - "YzWeJbVZ0oOFxwUAANA2Ui5K/1NJl0t6MSIWSHq7pCeLjgoAAKCNpCRU/RHxP5Im2O6IiEclvbnw\n", - "uAAAANpGyoM9d9meKulxSX9ne6ekfWWHBQAA0D5SjlC9S9JPJN0m6SFJL4s7AAEAAI5KKY48eDTq\n", - "sKQvFR0NAABAGzregz33qfEgz5FEREw7GQM4eLD+Gss5pUBKlVAp1W5JpUo4lCw7UWo7t0JsSQcO\n", - "HKh7CKe8dtwvgFY23p+T4z2HakrVxm1Pl3SPpMVqJGe/ExE/rNouAABAK0m5KL2Kv5T0LxHxbtud\n", - "kk4r3B8AAMC4K5ZQ2T5d0tsi4lZJiogBSXtK9QcAAFCXlLv8TtQCSf9t+z7bT9v+G9uTC/YHAABQ\n", - "i5IJVaekJZL+KiKWSNov6Y6C/QEAANSiZEK1VdLWiPhRc3m5GgnWMfbv33/036FDhwoOBwAAoIxi\n", - "11BFxKu2t9heFBEvSnqHpOeHx512GtepAwCA9lb6Lr8/UKNcTZekTZI+ULg/AACAcVc0oYqIdZLe\n", - "UrIPAACAupW8hgoAAOANofQpvzH19PQkxQ0MDCS3mVuOJMeECek5qO0isR0dHcmxEydOTI7Nbbuz\n", - "M333yYnt7u5Ojs29Bi9n/nL2uX379o0d1LRz587k2JzSTDnjlfLKMuRst66uruTYqVOnFhlDbsmJ\n", - "UnOdU9Yq5zsg9zsup+1WKIGT8/vlboucOcn5/XK2cam/IycSn6oVymvl7m8l2j5eHEeoAAAAKiKh\n", - "AgAAqIiECgAAoCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqIqECAACoyKVK\n", - "ByR1bsecOXOSYnPKC+SUFshtu5Scki85sbllCHJK1aSWDZLySi309fUlx+aUZslt+9ChQ8mxpUqM\n", - "5JTsydnGUl65lVKxOdutFT6nUrkSIzmf69zv7ZxxlCrxkzPXOftQyXIkrSD3O7xUabKcdkvNde7f\n", - "9oIlcEaclKJHqGx/0vbztp+1/VXb6UXaAAAA2kSxhMr2fEkflLQkIt4kqUPSe0v1BwAAUJf08wn5\n", - "eiX1S5ps+7CkyZK2FewPAACgFsWOUEXE/0n6C0n/JWm7pN0R8a+l+gMAAKhLyVN+PyvpDyXNlzRb\n", - "0hTbv1mqPwAAgLqUvCj9zZJ+EBH/GxEDkr4p6YrhQb29vUf/5dyBBQAA0CpKXkP1gqQ/tj1J0kFJ\n", - "75C0anjQtGnTCg4BAACgvJLXUK2TdL+k1ZKeaa7+Yqn+AAAA6lLyCJUi4jOSPlOyDwAAgLpRegYA\n", - "AKAiEioAAICKip7yS5FaNyqnpllOzaHctru6uoq0mzPmnHZL1jXMqfmVUxevZN3GnNpV3d3plZKm\n", - "T5+eHDtjxozk2AULFiTHXnjhhcmxkrRo0aLk2Jx6W5s3b06OfeGFF5JjX3nlleTYWbNmJcdK0pIl\n", - "S5Jjr7766uTYPXv2JMcuX748OXbFihXJsZK0b9++5Nicz1/OvnzRRRclx1577bXJsRs3bkyOlaSt\n", - "W7cmx+7evTs5Nqe26ezZs5NjFy5cmBwr5f1+mzZtSo7N2Yd27dpVJDa3dmvO353Uv2fbt28fvY3k\n", - "3gAAADAiEioAAICKSKgAAAAqIqECAACoiIQKAACgIhIqAACAiloyocq9NRKtpbe3t+4h4AStXbu2\n", - "7iGggpxb29Fach53gNbUkglVX19f3UNABXv37q17CDhB69atq3sIqGD//v11DwEniISq/bVkQgUA\n", - "ANBOSKgAAAAqckTU17ldX+cAAACZIsIjra81oQIAADgVcMoPAACgIhIqAACAilouobJ9ne0XbL9k\n", - "+xN1jwejs/23tnfYfnbIupm2H7H9ou2HbU+vc4wYne15th+1/bzt52x/tLmeOWxxtntsP2l7re31\n", - "tj/VXM/ctRHbHbbX2P5Oc5n5a2MtlVDZ7pD0BUnXSbpA0i22z693VDiO+9SYq6HukPRIRCyS9G/N\n", - "ZbSmfkm3RcRiSZdJ+nDz88YctriIOCjpmoi4WNKFkq6xfaWYu3azTNJ6SYMXMzN/baylEipJl0p6\n", - "OSI2R0S/pK9LuqnmMWEUEfG4pF3DVt8o6cvN11+W9K5xHRSSRcSrEbG2+XqfpA2S5og5bAsR8ZPm\n", - "yy5JHWp8Fpm7NmF7rqTrJd0jafCuMeavjbVaQjVH0pYhy1ub69A+zoqIHc3XOySdVedgkMb2fEmX\n", - "SHpSzGFbsD3B9lo15ujRiHhezF07+Zyk2yUdGbKO+WtjrZZQ8QyHU0g0nsnBnLY421MkfUPSsog4\n", - "pm4Qc9i6IuJI85TfXElX2b5m2M+ZuxZl+52SdkbEGr12dOoYzF/7abWEapukeUOW56lxlArtY4ft\n", - "syXJ9k9L2lnzeHActieqkUw9EBErmquZwzYSEXsk/bOkXxBz1y6ukHSj7R9L+pqka20/IOavrbVa\n", - "QrVa0nm259vuknSzpG/XPCbk+bakW5uvb5W04jixqJFtS7pX0vqIuHvIj5jDFmf7jME7wGxPkvSL\n", - "ktaIuWsLEXFnRMyLiAWS3ivp3yPifWL+2lrLPSnd9i9LuluNiyzvjYhP1TwkjML21yRdLekMNc73\n", - "/4mkb0n6B0nnSNos6T0RsbuuMWJ0zbvCvifpGb12auGTklaJOWxptt+kxkXLE5r/HoiIz9qeKeau\n", - "rdi+WtLHIuJG5q+9tVxCBQAA0G5a7ZQfAABA2yGhAgAAqIiECgAAoCISKgAAgIpIqAAAACoioQIA\n", - "AKiIhApA7Ww/0fzvz9i+5SS3fedIfQHAycRzqAC0DNtL1XjI4Q0Z7+mMiIHj/HxvREw9GeMDgNFw\n", - "hApA7Wzva778tKS32V5je5ntCbY/a3uV7XW2f68Zv9T247a/Jem55roVtlfbfs72B5vrPi1pUrO9\n", - "B4b25YbP2n7W9jO23zOk7ZW2/9H2BttfGd+tAaAdddY9AADQa6VvPiHp44NHqJoJ1O6IuNR2t6Tv\n", - "2364GXuJpMUR8Z/N5Q9ExK5mbbtVtpdHxB22PxwRl4zQ169KukjShZLOlPQj299r/uxiSRdIekXS\n", - "E7bfGhGcKgQwKo5QAWglHrb8S5Leb3uNpB9KmilpYfNnq4YkU5K0zPZaSf8haZ6k88bo60pJX42G\n", - "nZIek/QWNRKuVRGxPRrXRKyVNL/C7wTgDYAjVABa3Uci4pGhK5rXWu0ftvx2SZdFxEHbj0rqGaPd\n", - "0OsTuMGjV31D1h0W35UAxsARKgCtZK+koReQf1fSh2x3SpLtRbYnj/C+aZJ2NZOpn5d02ZCf9Q++\n", - "f5jHJd3cvE7rTElXSVql1ydZADAm/q8LQCsYPDK0TtLh5qm7+yR9Xo3TbU/btqSdkn6lGT/0FuWH\n", - "JP2+7fWSNqpx2m/QFyU9Y/upiHjf4Psi4p9sX97sMyTdHhE7bZ8/rG2NsAwAx+CxCQAAABVxyg8A\n", - "AKAiEioAAICKSKgAAAAqIqECAACoiIQKAACgIhIqAACAikioAAAAKiKhAgAAqOj/AWRdweAmqSyC\n", - "AAAAAElFTkSuQmCC\n" + "AAALEgAACxIB0t1+/AAAEQZJREFUeJzt3X2QXmV5x/HfL7ub3SVvJE2QEiKBQFLIaIWaDCBCqLRQ\n", + "RtC2VqStUtux00FrSoUR+aN/MC1amY7oOHTGQlGwalu0iNOCUEowYiUCCS9ZJIEhJUAhUEiWQF52\n", + "w9U/nmfDZtmX+87Jvc9z4vczs5PnnL2ec9977rPPXjkv9+WIEAAAAPbflFZ3AAAAoO5IqAAAACoi\n", + "oQIAAKiIhAoAAKAiEioAAICKSKgAAAAq6mxl47aZswEAANRGRHi09UUTKtvnSLpGUoek6yLib0fG\n", + "zJ8//y3v6+/v18yZM/dZlzNfVu7cWnv27CkSW6rPObH2qON+QLY9lh07dqi3t3e/t1tqPEpuux3G\n", + "GgDQOsUu+dnukPRVSedIOkHShbaPL9UeAABAq5S8h2q5pCciYlNEDEj6jqQPFGwPAACgJUomVPMl\n", + "bR62/Exz3YS6u7uLdAiTo7OzpbfmAQAw6UomVPt98wcJVb11dXW1ugsAAEyqkqcSnpW0YNjyAjXO\n", + "Uu2jv79/7+vu7m6SKQAAUDslE6r7JR1ne6Gk5yRdIOnCkUEjn+YDAACom2IJVUQM2v6UpB+qMW3C\n", + "9RHxWKn2AAAAWqXo3cMRcZuk20q2AQAA0Gotfxxr2rRpSXFvvPFG8jZzYiVpcHCwSGypSSTrOPFl\n", + "qfHLnfiyHSbVZLJOADj4UMsPAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAAoCISKgAAgIpIqAAA\n", + "ACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqanktv9xacylsZ8V3dXUlx3Z2pu+yUvXrStXQy912\n", + "qRqIpWKlcnUCc2Jzj88SfdifeADA2IqeobK9wPbdttfbftT2p0u2BwAA0Aqlz1ANSLokItbZni7p\n", + "Adt3RsRjhdsFAACYNEXPUEXE8xGxrvl6u6THJB1Rsk0AAIDJNmk3pdteKOlESfdNVpsAAACTYVIS\n", + "qublvpslrWyeqQIAADhoFH/Kz3aXpO9K+mZE3DLy+y+//PLe1729vert7S3dJQAAgAOqaELlxvPh\n", + "10vqi4hrRouZM2dOyS4AAAAUV/qS33sk/aGkM22vbX6dU7hNAACASVX0DFVE/FjMxg4AAA5yJDsA\n", + "AAAVtbz0zK5du5Licsp15Jb2yCnBkVvKpYSSfZgyJT3HzinDM3Xq1OTYkiVRSu27digns3v37qxt\n", + "DwwMJMeWKndUKvZgL6tT6njL3Xap8kx4U+5Yl/pbWbe/k63AGSoAAICKSKgAAAAqIqECAACoiIQK\n", + "AACgIhIqAACAikioAAAAKiKhAgAAqIiECgAAoCISKgAAgIpIqAAAACpqeemZVDmlL3J1dHQkx3Z1\n", + "dRXpQ6kSDjmlZKS8EjE5254+fXpy7KxZs5JjZ8+enRwrST09PcmxOaVZckotzJ07Nzl2586dybEv\n", + "vfRScqwkvfjii8mx06ZNS45dvHhxkdicPjz99NPJsZL05JNPFoldtGhRcux5552XHLt8+fLkWCmv\n", + "xEjOcb958+bk2NWrVyfHbtq0KTn24osvTo6VpCVLliTH5hxzOfutr68vOfaqq65KjpXyxmTevHnJ\n", + "sQsXLkyOPfvss5Njly1blhyb018p7+916t/V8f7ujZlQ2f5dSSFptN/EiIjvpTRuu0PS/ZKeiYj0\n", + "TwwAAICaGO8M1XlqJFRjSUqoJK2U1CdpRmqnAAAA6mTMhCoi/qjqxm0fKelcSX8j6S+rbg8AAKAd\n", + "TXgTjO3DbV9v+/bm8gm2/yRx+1+SdJmk9BtMAAAAaiblruKvS7pD0hHN5Y2SLpnoTbbfL2lLRKzV\n", + "6PdhAQAAHBRSnvKbGxH/bPtySYqIAduDCe87VdL5ts+V1CNppu0bI+Jjw4O2bdu293V3d3fWU1gA\n", + "AAClrFq1SqtWrUqKTUmottv+paEF2ydL2jZOvCQpIq6QdEXzPWdIunRkMiXlPSIPAAAwWVasWKEV\n", + "K1bsXb7yyivHjE1JqD4j6QeSjrH9E0nzJH1oP/qVPnkSAABAjUyYUEXEA7ZPl7REjXuhHo+I9BnM\n", + "Gtu4R9I9+9dFAACA9jZhQmW7V9LFkk5T4yzTatt/HxHpUzgDAAAcxFIu+d0oqV/SV9Q4Q/X7km6S\n", + "9HsF+wUAAFAbnqh+je2+iDhhonX71bgdhx9+eFJsTi2/nFp3Ul4dtpxt52w3p9ZWqdiSSu23wcGU\n", + "B07flHMc5fSj1DFUx7Fuh/0GAKVExKgftinzUD1o+5ShheZTfg8cqI4BAADU3XjFkR8ZFnOv7c1q\n", + "3EP1dkmPT0LfAAAAamGi4sgAAACYwHjFkTcNX7Z9mBozngMAAGCYlOLI59veKOkpNeaS2iTptsL9\n", + "AgAAqI2Um9L/WtIpkjZExNGS3ifpvqK9AgAAqJGUhGogIl6SNMV2R0TcLendhfsFAABQGykTe75i\n", + "e4ak1ZL+yfYWSdvLdgsAAKA+Us5QfVDS65IukXS7pCfEE4AAAAB7pRRHHjobtUfS14v2BgAAoIbG\n", + "m9hzuxoTeY4mImLmgehAaimQnLIaHR0d+9udlilVgqNkGZ6c2JySL6XKw+Ruu9R+LlWGJxelXADg\n", + "wBlvHqrpVTdu+1BJ10laqkZy9scR8dOq2wUAAGgnKTelV/FlSf8RER+y3SlpWuH2AAAAJl2xhMr2\n", + "LEnvjYiLJCkiBiVtK9UeAABAq6Q85be/jpb0ou0bbD9o+x9sH1KwPQAAgJYomVB1SjpJ0rURcZKk\n", + "1yRdXrA9AACAliiZUD0j6ZmI+Flz+WY1Eqx9vPbaa3u/du/eXbA7AAAAZRS7hyoinre92fbiiNgg\n", + "6SxJ60fGTZvGfeoAAKDeSj/l9+dqlKuZKulJSR8v3B4AAMCkK5pQRcRDkpaVbAMAAKDVSt5DBQAA\n", + "8Auh9CW/CQ0ODibFTZmSnvvlltTIKVVTKjbn5ysV2y66u7uTY2fNmpW17Zkz0ysm9fT0JMfu3Lkz\n", + "OXbz5s3JsVu3bi3SB0nFHgLp7Ez/WMm5hzLnuOjt7U2OlfJ+T3L2c86+yNHf358Vn/OZmPqZLEkD\n", + "AwPJsbt27UqOLVUiKnfbOaWfco6hrq6u5NjcY6hUn0v1Ied4y4mVypTXGu9nq99fWwAAgDZDQgUA\n", + "AFARCRUAAEBFJFQAAAAVkVABAABUREIFAABQEQkVAABARSRUAAAAFZFQAQAAVERCBQAAUJFLTM2e\n", + "3Lgdhx56aGpsznaz+lGqlEtOP3LKC5Qsw1NqP+eUIsgpUZETK+WVLihV/iJn/HKOi9zjPqdsSM6+\n", + "KLXfWvlZNVzOfm6H0h65co+jVKXGr12Oi3ZR6vicOnVqcmzOmOR8DuUe9wWPuVF3ctEzVLY/Z3u9\n", + "7Udsf8t2ejEuAACAmiiWUNleKOkTkk6KiHdI6pD0kVLtAQAAtEqZUugN/ZIGJB1ie4+kQyQ9W7A9\n", + "AACAlih2hioiXpb0d5KelvScpK0R8Z+l2gMAAGiVkpf8Fkn6C0kLJR0habrtPyjVHgAAQKuUvCn9\n", + "3ZJ+EhH/FxGDkr4n6dSRQTt27Nj7lXO3PwAAQLsomVD9XNLJtnvdeI7zLEl9I4N6e3v3fnV1dRXs\n", + "DgAAQBkl76F6SNKNku6X9HBz9ddKtQcAANAqJZ/yU0R8UdIXS7YBAADQapSeAQAAqIiECgAAoKKi\n", + "l/xSzJgxIykupyZPyVp+ObXVStVhy6mplLsvOjo6kmN7enqytp0qp17T66+/nrXtnFp+OT/f7Nmz\n", + "k2N7e3uTY+fNm5cce8wxxyTHStKSJUuSY3P228aNG5Nj+/re8pzKmPr7+5NjDzvssORYKW/fLV26\n", + "NDk25+e79dZbk2M3bNiQHCvlfX7mHPeLFi1Kjj3rrLOSYxcvXpwce+211ybHStJTTz2VHJvz+ZLz\n", + "2Xnssccmx1566aXJsZJ01FFHJcc++2z6XNs5v9d33XVXcmzO78i2bduSY6W8z63UPGDHjh1jbyO5\n", + "NQAAAIyKhAoAAKAiEioAAICKSKgAAAAqIqECAACoiIQKAACgorZMqHbu3NnqLqCC3Edb0T7Wr1/f\n", + "6i6ggpzHxNFecqYFQXtqy4Rq165dre4CKiChqi8SqnojoaqvV199tdVdQEVtmVABAADUCQkVAABA\n", + "Rc4pSXDAG7db1zgAAECmiBi1pltLEyoAAICDAZf8AAAAKiKhAgAAqKjtEirb59j+ue2Ntj/b6v5g\n", + "bLb/0fYLth8Ztm6O7Tttb7B9h+1DW9lHjM32Att3215v+1Hbn26uZwzbnO0e2/fZXme7z/bnm+sZ\n", + "uxqx3WF7re0fNJcZvxprq4TKdoekr0o6R9IJki60fXxre4Vx3KDGWA13uaQ7I2KxpLuay2hPA5Iu\n", + "iYilkk6W9Mnm7xtj2OYiYqekMyPiXZLeKelM26eJsaublZL6JA3dzMz41VhbJVSSlkt6IiI2RcSA\n", + "pO9I+kCL+4QxRMRqSa+MWH2+pG80X39D0gcntVNIFhHPR8S65uvtkh6TNF+MYS1ExOvNl1Mldajx\n", + "u8jY1YTtIyWdK+k6SUNPjTF+NdZuCdV8SZuHLT/TXIf6eFtEvNB8/YKkt7WyM0hje6GkEyXdJ8aw\n", + "FmxPsb1OjTG6OyLWi7Grky9JukzSG8PWMX411m4JFXM4HESiMScHY9rmbE+X9F1JKyNin/oXjGH7\n", + "iog3mpf8jpR0uu0zR3yfsWtTtt8vaUtErNWbZ6f2wfjVT7slVM9KWjBseYEaZ6lQHy/YPlySbP+y\n", + "pC0t7g/GYbtLjWTqpoi4pbmaMayRiNgm6d8l/ZoYu7o4VdL5tp+S9G1Jv277JjF+tdZuCdX9ko6z\n", + "vdD2VEkXSLq1xX1CnlslXdR8fZGkW8aJRQvZtqTrJfVFxDXDvsUYtjnbc4eeALPdK+k3JK0VY1cL\n", + "EXFFRCyIiKMlfUTSf0XER8X41VrbzZRu+7ckXaPGTZbXR8TnW9wljMH2tyWdIWmuGtf7/0rS9yX9\n", + "i6S3S9ok6cMRsbVVfcTYmk+F/UjSw3rz0sLnJK0RY9jWbL9DjZuWpzS/boqIq23PEWNXK7bPkPSZ\n", + "iDif8au3tkuoAAAA6qbdLvkBAADUDgkVAABARSRUAAAAFZFQAQAAVERCBQAAUBEJFQAAQEUkVABa\n", + "zva9zX+Psn3hAd72FaO1BQAHEvNQAWgbtleoMcnheRnv6YyIwXG+/2pEzDgQ/QOAsXCGCkDL2d7e\n", + "fPkFSe+1vdb2SttTbF9te43th2z/aTN+he3Vtr8v6dHmults32/7UdufaK77gqTe5vZuGt6WG662\n", + "/Yjth21/eNi2V9n+V9uP2f7m5O4NAHXU2eoOAIDeLH3zWUmXDp2haiZQWyNiue1uST+2fUcz9kRJ\n", + "SyPif5rLH4+IV5q17dbYvjkiLrf9yYg4cZS2fkfSr0p6p6R5kn5m+0fN771L0gmS/lfSvbbfExFc\n", + "KgQwJs5QAWgnHrH8m5I+ZnutpJ9KmiPp2Ob31gxLpiRppe11kv5b0gJJx03Q1mmSvhUNWyTdI2mZ\n", + "GgnXmoh4Lhr3RKyTtLDCzwTgFwBnqAC0u09FxJ3DVzTvtXptxPL7JJ0cETtt3y2pZ4Ltht6awA2d\n", + "vdo1bN0e8VkJYAKcoQLQTl6VNPwG8h9Kuth2pyTZXmz7kFHeN1PSK81k6lcknTzsewND7x9htaQL\n", + "mvdpzZN0uqQ1emuSBQAT4n9dANrB0JmhhyTtaV66u0HSV9S43PagbUvaIum3m/HDH1G+XdKf2e6T\n", + "9Lgal/2GfE3Sw7YfiIiPDr0vIv7N9inNNkPSZRGxxfbxI7atUZYBYB9MmwAAAFARl/wAAAAqIqEC\n", + "AACoiIQKAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAAoCISKgAAgIr+Hyoqh+rLDshuAAAAAElF\n", + "TkSuQmCC\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -5012,7 +5057,7 @@ "jYuZ4ZLGxcz4f041SDwzkyB1AAAAAElFTkSuQmCC\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -5022,91 +5067,90 @@ "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAlQAAACbCAYAAACkuQVhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAEfRJREFUeJzt3X2w3NVdx/HPJ/fm5uaZPJFAckNAg4ZMK2ALhFJopDoI\n", - "hVatpVFbrE4dp62N2DKlzOhfOq1lHGinozMVpIU+oNBK21EoqEgpFdJAQoCkhGQIJkQSIzdpbsjD\n", - "TfL1j90Ly+U+nJMf5+5u8n7NZNjf7nd/5+zv/O7ul9/D+ToiBAAAgGM3rtkdAAAAaHckVAAAABWR\n", - "UAEAAFREQgUAAFARCRUAAEBFJFQAAAAVdTazcdvM2QAAANpGRHio54smVLYvk3SzpA5Jt0TEXw+O\n", - "mTt37hve19fXpylTpgxeV3K7uXNrHTlyJDn28OHDRfpx9OjR5NgcudsiJ3642EOHDqmrq+t1z+V8\n", - "vpzYZny+Vo0FADRPsVN+tjskfVnSZZLOkrTC9pJS7QEAADRLyWuozpO0KSK2RES/pDslvbdgewAA\n", - "AE1RMqGaL2lrw/K2+nOjGny6CO2lo6Oj2V0AAGBMlUyojvniDxKq9kZCBQA40ZS8KP1FST0Nyz2q\n", - "HaV6nb6+vlcfd3V1kUwBAIC2UzKhWi1pse1FkrZLulrSisFBg+/mAwAAaDfFEqqIOGz7E5J+oNq0\n", - "CbdGxIZS7QEAADRL0XmoIuJeSfeWbAMAAKDZmjpTuiTNmzcvKS5n8s3+/v6sPuTEl5rYM0fJCUNz\n", - "Pl/OdssZv5zY3M/XChNllhq/3G1RcgJVADjRUMsPAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAA\n", - "oCISKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqcjNrdNmO6dOnJ8VOmDAheb3d\n", - "3d1Z/Zg0aVKRdY8bl56v5tTQ27dvX3LsgQMHkmMlaf/+/cmxhw4dSo7N+Xwla8yV2t9tF4ktWbeR\n", - "Wn4AkC8ihvwSL3qEynaP7QdtP2P7adufLNkeAABAM3QWXn+/pGsjYq3tKZIet/1ARGwo3C4AAMCY\n", - "KXqEKiJeioi19cd9kjZIOrVkmwAAAGNtzC5Kt71I0jmSHhurNgEAAMbCmCRU9dN9d0taWT9SBQAA\n", - "cNwofQ2VbI+X9G1JX4+Iewa/3ngXWmdnpzo7i3cJAADgTVU0e3Ht/vBbJa2PiJuHismd4gAAAKDV\n", - "lD7l9w5Jvydpue019X+XFW4TAABgTBU9QhURPxKzsQMAgOMcyQ4AAEBFTS8909PTkxRbsgTHkSNH\n", - "kmNzSqjk9LlUbEk527mjoyM5NqdkT856c9ddqkRMzj6Us2/29/cnx+auO/dvKlXONs7pQ842zl13\n", - "KTn75vjx47PWnVO6q6urKzk2Zx/KKVWVUwKrFcaulZQqg1VKO/72NaX0DAAAwImAhAoAAKAiEioA\n", - "AICKSKgAAAAqIqECAACoiIQKAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAAoKKixZFTpJaIyCkx\n", - "klM6QZK6u7uTYzs7y2yyUqVLcuWUIsjpR852y4mdNGlScqwkTZ48OTk2Z7/Iic3p8/bt25Njt27d\n", - "mhwrSb29vcmxOWVtcj7fokWLkmPPPvvs5Nic8ZCkzZs3J8euW7cuOTan5EvO57v00kuTY6Vy5Y5e\n", - "fvnl5Nhnn302OXbjxo3JsYsXL06OlfL2uRkzZiTH7t27Nzk2Z397/vnnk2Olct9bOd8BU6dOTY6d\n", - "N29ecmzOeEh5n2/37t1JcTfddNOwrw37y2X7tySFpKF+YSMivpPSuO0OSaslbYuIK1PeAwAA0E5G\n", - "OhRwpWoJ1XCSEipJKyWtl5SesgIAALSRYROqiPj9qiu3vUDS5ZL+StKfVV0fAABAKxr1onTb82zf\n", - "avu++vJZtv8wcf03SbpO0tEKfQQAAGhpKXf5fVXS/ZJOrS8/J+na0d5k+z2SdkbEGg19HRYAAMBx\n", - "IeV2qtkR8Y+2r5ekiOi3nXLLyIWSrrJ9uaRuSdNs3x4RH24MarwzoqurK+uuGAAAgFK2bt2qbdu2\n", - "JcWmJFR9tmcNLNi+QNKe0d4UETdIuqH+nkskfXpwMiXl3V4JAAAwVnp6etTT0/Pq8qOPPjpsbEpC\n", - "9SlJ35d0hu0fS5oj6f3H0K/0iZYAAADayKgJVUQ8bvtiSb+g2rVQz0ZE+gxftXU8JOmhY+siAABA\n", - "axs1obI9UdLHJF2k2lGmh23/XUQcKN05AACAdpByyu92ST+T9CXVjlD9jqQ7JP12wX4BAAC0DY9W\n", - "Q872+og4a7TnjqlxOxYsWJAUm1Prbty4vJrPOevOkVMXr1StwvHjxyfH5vYjZzvnxObWYsyR04+c\n", - "mmYHDx5Mjs2piTVlypTk2NyxzqlreNpppyXH5ozfli1bisTm1jXcv39/cuzRo+nT6uWMydy5c5Nj\n", - "p02blhwr5dU0y/kbybkrO2e9OTUCd+3alRwrSX19fcmxOX/Xhw4dSo7N+c0p9ftUUs5vX6nfESmv\n", - "Lmzqb19fX58iYsgPmNK7J2wvG1io3+X3eFLLAAAAJ4CRiiM/1RDziO2tql1DtVBSetlwAACA49xo\n", - "xZEBAAAwipGKI29pXLZ9smozngMAAKBBSnHkq2w/J+l51eaS2iLp3sL9AgAAaBspF6X/paRlkjZG\n", - "xOmSLpX0WNFeAQAAtJGUhKo/InZJGme7IyIelPS2wv0CAABoGymTNPTanirpYUnfsL1TUvpEHgAA\n", - "AMe5lCNU75P0iqRrJd0naZO4AxAAAOBVKcWRB45GHZH01aK9AQAAaEPDlp6x3afaRJ5DiYjIq30w\n", - "dBuxcOHCpNiS09PnlJLIKUdSqmRAq0zVnxNbqs+5ny+nPESOw4cPF+lDzr6ZU+5ByisRM2vWrOTY\n", - "6dOnJ8fmbLcdO3Ykx/b29ibH5sbn9LlU+alcOf3I+Y7L2T9bpdxKzrpz/6ZK9KGV1l1CqW1cSkQM\n", - "W3pmpHmo0ouIDcP2SZJukbRUteTsDyLi0arrBQAAaCXphxiOzRcl/WtEvN92p6T0aqwAAABtolhC\n", - "ZXu6pHdGxDWSFBGHJe0p1R4AAECz5F2Akud0Sf9r+zbbT9j+e9uTCrYHAADQFCUTqk5J50r624g4\n", - "V9I+SdcXbA8AAKApSl5DtU3Stoj4SX35bg2RUO3evfvVx93d3erupv4yAABovpy7JoslVBHxku2t\n", - "ts+MiI2S3i3pmcFxJ510UqkuAAAAHLPB0zqMlGCVvsvvT1QrV9MlabOkjxRuDwAAYMwVTagi4klJ\n", - "by/ZBgAAQLOVvCgdAADghDBs6ZkxadyOpUuXJsUePHgweb39/f1Z/cgpJVGq1EKOnHIrueUscku5\n", - "pMrZFjl9yCl/kyunRMz+/fuTY/v6+kYPqsvZl3P3t1KlQHJKSZQqM5RbziLn87VC+al2VGpbtOM2\n", - "bpVyKzn9aIWSPSWlfr6RSs9whAoAAKAiEioAAICKSKgAAAAqIqECAACoiIQKAACgIhIqAACAikio\n", - "AAAAKiKhAgAAqIiECgAAoCISKgAAgIqKFkdOsW/fvqS4nPIwObFS+5WTKVUuQMor5TJx4sQi680p\n", - "t3LgwIHkWCmvnExOuaOcciRTp05Nju3q6kqOzS3Dk1Mu55VXXkmOzdnGOX97Odu4VAml3HVPmDAh\n", - "OXby5MnJsbmlPXJKUOXsRznftXv37k2Ozdk3c/ahY4kvoWR5rWnTpiXHLly4MDn2lFNOSY7N+V7u\n", - "7e1Njt25c2dyrFRmnxvpd6HoESrbn7X9jO2nbH/Tdvq3CwAAQJsollDZXiTpo5LOjYi3SOqQ9MFS\n", - "7QEAADRLyVN+P5PUL2mS7SOSJkl6sWB7AAAATVHsCFVEvCzpbyT9t6TtknZHxL+Vag8AAKBZSp7y\n", - "+zlJfyppkaRTJU2x/bul2gMAAGiWkqf83ibpxxHxf5Jk+zuSLpT0jcagxiv8u7u7s+4cAwAAKOXo\n", - "0aPJd4aWTKh+KunPbU+UdEDSuyWtGhw0Y8aMgl0AAAA4NuPGjXvdNBcjTd9S8hqqJyXdLmm1pHX1\n", - "p79Sqj0AAIBmKTqxZ0R8QdIXSrYBAADQbJSeAQAAqIiECgAAoKKm1/JLvXq+VC2qkuvOWW+p2k4l\n", - "61zlfL6c+m459cFy6rtJ0vjx45Njc2qrzZw5Mzk2p9bWySefnBw7f/785FhJmjVrVnLsCy+8kBy7\n", - "ffv25Nicfai7uzs5dsmSJcmxkrR8+fLk2PPPPz85dteuXcmxd955Z3LsXXfdlRwrSbt3706Ozfn7\n", - "mz17dnLssmXLkmOvuOKK5Ng9e/Ykx0p52yKnJl3Od8AZZ5yRHJtTb0/Kq3e3YcOG5NicfTmnDmpO\n", - "bM73RW78nDlzkuJWrFgx7GscoQIAAKiIhAoAAKAiEioAAICKSKgAAAAqIqECAACoiIQKAACgopZM\n", - "qHJuVUXr6evra3YXcIw2bdrU7C6ggpwpAdBaVq9e3ewuoCISKrzpSKja1+bNm5vdBVRAQtW+SKja\n", - "X0smVAAAAO2EhAoAAKAiR0TzGreb1zgAAECmiPBQzzc1oQIAADgecMoPAACgIhIqAACAilouobJ9\n", - "me2f2n7O9mea3R8Mz/Y/2N5h+6mG52bafsD2Rtv32z6pmX3E8Gz32H7Q9jO2n7b9yfrzjGGLs91t\n", - "+zHba22vt/25+vOMXRux3WF7je3v15cZvzbWUgmV7Q5JX5Z0maSzJK2wvaS5vcIIblNtrBpdL+mB\n", - "iDhT0r/Xl9Ga+iVdGxFLJV0g6eP1vzfGsMVFxAFJyyPibElvlbTc9kVi7NrNSknrJQ1czMz4tbGW\n", - "SqgknSdpU0RsiYh+SXdKem+T+4RhRMTDknoHPX2VpK/VH39N0vvGtFNIFhEvRcTa+uM+SRskzRdj\n", - "2BYi4pX6wy5JHar9LTJ2bcL2AkmXS7pF0sBdY4xfG2u1hGq+pK0Ny9vqz6F9zI2IHfXHOyTNbWZn\n", - "kMb2IknnSHpMjGFbsD3O9lrVxujBiHhGjF07uUnSdZKONjzH+LWxVkuomMPhOBK1OTkY0xZne4qk\n", - "b0taGRF7G19jDFtXRBytn/JbIOli28sHvc7YtSjb75G0MyLW6LWjU6/D+LWfVkuoXpTU07Dco9pR\n", - "KrSPHbbnSZLtUyTtbHJ/MALb41VLpu6IiHvqTzOGbSQi9kj6F0m/LMauXVwo6Srbz0v6lqRfsX2H\n", - "GL+21moJ1WpJi20vst0l6WpJ32tyn5Dne5KuqT++RtI9I8SiiWxb0q2S1kfEzQ0vMYYtzvbsgTvA\n", - "bE+U9KuS1oixawsRcUNE9ETE6ZI+KOk/IuJDYvzaWsvNlG771yXdrNpFlrdGxOea3CUMw/a3JF0i\n", - "abZq5/v/QtJ3Jf2TpIWStkj6QETsblYfMbz6XWE/lLROr51a+KykVWIMW5rtt6h20fK4+r87IuJG\n", - "2zPF2LUV25dI+lREXMX4tbeWS6gAAADaTaud8gMAAGg7JFQAAAAVkVABAABUREIFAABQEQkVAABA\n", - "RSRUAAAAFZFQAWg624/U/3ua7RVv8rpvGKotAHgzMQ8VgJZh+12qTXJ4ZcZ7OiPi8Aiv742IqW9G\n", - "/wBgOByhAtB0tvvqDz8v6Z2219heaXuc7Rttr7L9pO0/qse/y/bDtr8r6en6c/fYXm37adsfrT/3\n", - "eUkT6+u7o7Et19xo+ynb62x/oGHd/2n7LtsbbH99bLcGgHbU2ewOAIBeK33zGUmfHjhCVU+gdkfE\n", - "ebYnSPqR7fvrsedIWhoRL9SXPxIRvfXadqts3x0R19v+eEScM0RbvynplyS9VdIcST+x/cP6a2dL\n", - "OkvS/0h6xPY7IoJThQCGxREqAK3Eg5Z/TdKHba+R9KikmZJ+vv7aqoZkSpJW2l4r6b8k9UhaPEpb\n", - "F0n6ZtTslPSQpLerlnCtiojtUbsmYq2kRRU+E4ATAEeoALS6T0TEA41P1K+12jdo+VJJF0TEAdsP\n", - "SuoeZb2hNyZwA0evDjY8d0R8VwIYBUeoALSSvZIaLyD/gaSP2e6UJNtn2p40xPumSeqtJ1O/KOmC\n", - "htf6B94/yMOSrq5fpzVH0sWSVumNSRYAjIr/6wLQCgaODD0p6Uj91N1tkr6k2um2J2xb0k5Jv1GP\n", - "b7xF+T5Jf2x7vaRnVTvtN+ArktbZfjwiPjTwvoj4Z9vL6m2GpOsiYqftJYPWrSGWAeB1mDYBAACg\n", - "Ik75AQAAVERCBQAAUBEJFQAAQEUkVAAAABWRUAEAAFREQgUAAFARCRUAAEBFJFQAAAAV/T+uJdIF\n", - "H1NcrQAAAABJRU5ErkJggg==\n" + "AAALEgAACxIB0t1+/AAAEbVJREFUeJzt3X+QXWV9x/HPJ7vZZJONYfgRAyE0SQsUMloBYQIiCNpC\n", + "QcBSK9JWqWXsdNRKqTJiZtq/2tHKdERH2hlLioJVS1GiDi1CW0DEQviRAEkghI78SGiyQCHssmST\n", + "Dd/+ce+GzbI/nicnz557w/s1s5N7zv3e8zz3POfe+8359XVECAAAAHtvWt0dAAAAaHckVAAAABWR\n", + "UAEAAFREQgUAAFARCRUAAEBFJFQAAAAVddbZuG3u2QAAANpGRHis+UUTKttnS7paUoekayPib0fH\n", + "zJs3702v6+/vV09Pz163+/rrrxeLLxW7P90PbHBwUDNmzNhjXs77K7WOc+N37dqVHJvz/krFAgDq\n", + "U+yQn+0OSd+QdLakYyVdbPuYUu0BAADUpeQ5VCdJejIinoqInZK+L+mCgu0BAADUomRCtUDSsyOm\n", + "NzXnTaqrq6tIhzA1Ojo66u4CAABTqmRCtdcnf5BQtbfOzlqvdQAAYMqV/OXbLGnhiOmFauyl2kN/\n", + "f//ux11dXSRTAACg7ZRMqB6QdKTtRZKek3SRpItHB1W5mg8AAKAVFEuoImLI9mck/VSN2yasiIjH\n", + "SrUHAABQF9d5nxvbMdZ9qKriPlSth/tQlY8FAJRXy409U8ycOXOfLzP3R6gVfmRLJV+5CUfO+xsa\n", + "GirSj5KJaE68PeZnZr9BsgYA+w61/AAAACoioQIAAKiIhAoAAKAiEioAAICKSKgAAAAqIqECAACo\n", + "iIQKAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAAoKLaa/kNDAzU3YViStVKy63Pl6Pdat2VrNtI\n", + "rTsAQKqie6hsL7R9h+11ttfa/mzJ9gAAAOpQeg/VTkmXR8Qa2z2SHrR9e0Q8VrhdAACAKVN0D1VE\n", + "bImINc3H/ZIek3RYyTYBAACm2pSdlG57kaTjJN03VW0CAABMhSlJqJqH+26SdFlzTxUAAMB+o/hV\n", + "franS/qBpO9ExMrRz7/66qu7H0+fPl1dXV2luwQAALBPFU2o3LiufoWk9RFx9Vgxs2fPLtkFAACA\n", + "4kof8nuPpD+UdIbt1c2/swu3CQAAMKWK7qGKiJ+Lu7EDAID9HMkOAABARbWXnpkxY0ZS3LRp5XK/\n", + "nBIjpUqXtEIfpLz1vGvXruTY6dOnZ/WjFeSsi5zYnJI9OWM9ODiYHCtJO3fuTI7NGetSctZFbnmm\n", + "VigzlLMNdXbmfXXnXOyT04+cbS5neytZXqvd5P725Xy/lPouKvXb1+rYQwUAAFARCRUAAEBFJFQA\n", + "AAAVkVABAABUREIFAABQEQkVAABARSRUAAAAFZFQAQAAVERCBQAAUBEJFQAAQEW1l5456KCDkuKG\n", + "hoaSl5lbJiPn9vs5cvqcc1v/nPeX+95yS1qkmj17dpHYuXPnZvUjtdSRlFcqY8eOHcmxOeu4t7c3\n", + "Ofb5559PjpWkvr6+rPhUBx54YHLskiVLiix369atybGStGnTpuTYF154ITk2Z/s88cQTk2PPPffc\n", + "5Fgpb/vcsmVLcuyqVauSY9euXZscm7NtnnXWWcmxknTBBRckxx555JHJsQMDA8mxK1asSI69+eab\n", + "k2Ml6bXXXkuOzfl9yPnemjVrVnLsEUcckRx7wgknJMdK0uGHH54cm/q5vuaaa8Z9btw1ZPt3JYWk\n", + "sdZ4RMQPUxq33SHpAUmbIuK8lNcAAAC0k4lSzvPUSKjGk5RQSbpM0npJc1I7BQAA0E7GTagi4o+q\n", + "Ltz24ZLOkfQ3kv6i6vIAAABa0aQnpdueb3uF7Vub08favjRx+V+VdIWk9BOEAAAA2kzKVX7fknSb\n", + "pMOa0xslXT7Zi2x/UFJvRKzW2OdhAQAA7BdSTts/OCL+xfaVkhQRO22nXL52iqTzbZ8jaaakt9m+\n", + "PiI+PjJo5BUlPT096unpSe89AABAIZs3b9bmzZuTYlMSqn7bu+9tYHuZpG2TvSgilkta3nzN6ZI+\n", + "PzqZkqT58+cndRQAAGAqLViwQAsWLNg9ff/9948bm5JQfU7STyQtsf0LSYdI+vBe9GuiKwYBAADa\n", + "1qQJVUQ8aPs0SUercS7UhohIv+NhYxl3Sbpr77oIAADQ2iZNqGx3S/qUpFPV2Mt0t+1/iIjtpTsH\n", + "AADQDlIO+V0v6RVJX1djD9XvS7pB0u8V7BcAAEDbcMTEpzbZXh8Rx042b68at+Owww6bPFB59esm\n", + "e0+j5dTRy112qmnT0utUd3R0JMdOnz49qx85y86p7ZSz3Jz6Ujn1EqW8sc5Zdk7dv5yxTq11KUkH\n", + "HHBAcqyUV9cwp45ef39/cuyTTz6ZHJtTqzCnD1K575eurq7k2Hnz5iXH5n6uu7u7k2Nzts+c2O3b\n", + "0w9qbNs26XVPu+XWK83ZNkrV82yF35xcOeu51O9ZTmxufGqfX3nlFUXEmCsjZQkP2T55eKJ5ld+D\n", + "SS0DAAC8BUxUHPnRETH32H5WjXOojpC0YQr6BgAA0BYmK44MAACASUxUHPmpkdO256lxx3MAAACM\n", + "kFIc+XzbGyX9Uo17ST0l6d8L9wsAAKBtpJyU/teSTpb0REQslvR+SfcV7RUAAEAbSUmodkbEC5Km\n", + "2e6IiDskvbtwvwAAANpGyo2EXrI9R9Ldkv7Zdq+kvJu8AAAA7MdS9lB9SNKApMsl3SrpSXEFIAAA\n", + "wG4pxZGH90btkvStor0BAABoQ+OWnrHdr8aNPMcSEfG2yo3bMX/+/KTYnFvZ55REafajSGwpOaUI\n", + "cssW5MTnlE9ohVgpr8RIKa1Q/ia3HznbfU5ZlNzPaqrccR4YGEiOzd3mUFbJ7+RWKfuC1jJe6ZmJ\n", + "7kPVU7VR2wdIulbSUjWSsz+OiHurLhcAAKCVlPnv4Ru+JunfIuLDtjslzS7cHgAAwJQrllDZnivp\n", + "vRFxiSRFxJCk9BLiAAAAbSL9xKR8iyU9b/s62w/Z/kfbswq2BwAAUIuSCVWnpOMl/X1EHC/pVUlX\n", + "FmwPAACgFiUTqk2SNkXE/c3pm9RIsPbQ19e3+29wcLBgdwAAAMoodg5VRGyx/aztoyLiCUkfkLRu\n", + "dNycOXNKdQEAAGBKlL7K78/UKFfTJel/JH2icHsAAABTrmhCFREPSzqxZBsAAAB1K3kOFQAAwFtC\n", + "6UN+tcgtO9HR0VGkHzklEXJK65TUCmU1ckqXdHd3Zy17xowZybE56yKndMmLL76YHLtjx47k2Nzt\n", + "vtRY55TAydnuc2Jzy5GU+vyVKmuV+/5KlasqVaoqR6uUh2mFsmTtqFVKv6VuRxNtx63xKw4AANDG\n", + "SKgAAAAqIqECAACoiIQKAACgIhIqAACAikioAAAAKiKhAgAAqIiECgAAoCISKgAAgIpIqAAAACpy\n", + "nbfttx1z5swpsdxi8aXKX3R2plcByulD7vjm9DmnZE9O2Ymccis5ZU5y+5FTyiVnPeeU1skplZNb\n", + "PuW1115Ljs0Zk5x1XCq2VcqAzJo1Kzl25syZybG5233O9pmzHQ0NDSXHDg4OJsfmfPZyt/uc7Shn\n", + "vbVKqbGc7+VDDjkkOXbZsmXJsYceemhybF9fX3Ls2rVrk2MlacuWLcmx27ZtS4rr6+tTRIw52EX3\n", + "UNn+ou11th+1/V3b6b8OAAAAbaJYQmV7kaRPSjo+It4hqUPSR0u1BwAAUJf040z5XpG0U9Is27sk\n", + "zZK0uWB7AAAAtSi2hyoi/k/S30l6RtJzkl6OiP8o1R4AAEBdSh7y+1VJfy5pkaTDJPXY/oNS7QEA\n", + "ANSl5Enp75b0i4h4MSKGJP1Q0imjgwYHB3f/5VwxAgAAUNLQ0NAeecpESp5D9bikv7TdLWm7pA9I\n", + "WjU6KOeycAAAgKnS2dm5x22NJrqFTMlzqB6WdL2kByQ90pz9zVLtAQAA1KXkHipFxFckfaVkGwAA\n", + "AHWj9AwAAEBFJFQAAAAV1V7L7+ijj06KLdnPnLpKOTX3cmoq5dSB6urqSo7NqVsl5a2LnH7kyOnz\n", + "wMBAkT5I0ty5c5Njc2pXdXd3F+nDQQcdlBwr5fU5Zz1v3749OTbnyt6c7S31e2XY0qVLk2Nz1tvT\n", + "Tz+dHHvjjTcmx65cuTI5VsqrxZizHZ122mnJsWeeeWZy7JIlS5Jjb7nlluRYSbrzzjuTY5955pnk\n", + "2Jy6tJdeemly7IUXXpgcK+XVCt26dWty7L333pscu3HjxuTY3t7e5Nic+qNSXv3IxYsXJ8UtX768\n", + "nlp+AAAAbwUkVAAAABWRUAEAAFREQgUAAFARCRUAAEBFJFQAAAAVtWRCVfJSeJT38ssv190F7KXH\n", + "H3+87i6ggr6+vrq7gL20bt26uruAikiosM9t27at7i5gL23YsKHuLqACEqr2tX79+rq7gIpaMqEC\n", + "AABoJyRUAAAAFdVeeqa2xgEAADKNV3qm1oQKAABgf8AhPwAAgIpIqAAAACpquYTK9tm2H7e90fYX\n", + "6u4Pxmf7n2xvtf3oiHkH2r7d9hO2b7N9QJ19xPhsL7R9h+11ttfa/mxzPmPY4mzPtH2f7TW219v+\n", + "UnM+Y9dGbHfYXm37J81pxq+NtVRCZbtD0jcknS3pWEkX2z6m3l5hAtepMVYjXSnp9og4StJ/NqfR\n", + "mnZKujwilkpaJunTzc8bY9jiImK7pDMi4l2S3inpDNunirFrN5dJWi9p+GRmxq+NtVRCJekkSU9G\n", + "xFMRsVPS9yVdUHOfMI6IuFvSS6Nmny/p283H35b0oSntFJJFxJaIWNN83C/pMUkLxBi2hYgYvgNy\n", + "l6QONT6LjF2bsH24pHMkXStp+Koxxq+NtVpCtUDSsyOmNzXnoX28PSK2Nh9vlfT2OjuDNLYXSTpO\n", + "0n1iDNuC7Wm216gxRndExDoxdu3kq5KukPT6iHmMXxtrtYSKezjsR6JxTw7GtMXZ7pH0A0mXRcQe\n", + "tUsYw9YVEa83D/kdLuk022eMep6xa1G2PyipNyJW6429U3tg/NpPqyVUmyUtHDG9UI29VGgfW23P\n", + "lyTbh0rqrbk/mIDt6WokUzdExMrmbMawjUTENkm3SDpBjF27OEXS+bZ/Kel7ks60fYMYv7bWagnV\n", + "A5KOtL3IdpekiyT9uOY+Ic+PJV3SfHyJpJUTxKJGti1phaT1EXH1iKcYwxZn++DhK8Bsd0v6TUmr\n", + "xdi1hYhYHhELI2KxpI9K+q+I+JgYv7bWcndKt/3bkq5W4yTLFRHxpZq7hHHY/p6k0yUdrMbx/r+S\n", + "9CNJN0o6QtJTkj4SES/X1UeMr3lV2M8kPaI3Di18UdIqMYYtzfY71DhpeVrz74aIuMr2gWLs2ort\n", + "0yV9LiLOZ/zaW8slVAAAAO2m1Q75AQAAtB0SKgAAgIpIqAAAACoioQIAAKiIhAoAAKAiEioAAICK\n", + "SKgA1M72Pc1/f8X2xft42cvHagsA9iXuQwWgZdh+nxo3OTwv4zWdETE0wfN9ETFnX/QPAMbDHioA\n", + "tbPd33z4ZUnvtb3a9mW2p9m+yvYq2w/b/pNm/Pts3237R5LWNuettP2A7bW2P9mc92VJ3c3l3TCy\n", + "LTdcZftR24/Y/siIZd9p+19tP2b7O1O7NgC0o866OwAAeqP0zRckfX54D1UzgXo5Ik6yPUPSz23f\n", + "1ow9TtLSiHi6Of2JiHipWdtule2bIuJK25+OiOPGaOtCSb8h6Z2SDpF0v+2fNZ97l6RjJf2vpHts\n", + "vyciOFQIYFzsoQLQSjxq+rckfdz2akn3SjpQ0q81n1s1IpmSpMtsr5H035IWSjpykrZOlfTdaOiV\n", + "dJekE9VIuFZFxHPROCdijaRFFd4TgLcA9lABaHWfiYjbR85onmv16qjp90taFhHbbd8haeYkyw29\n", + "OYEb3ns1OGLeLvFdCWAS7KEC0Er6JI08gfynkj5lu1OSbB9le9YYr3ubpJeaydSvS1o24rmdw68f\n", + "5W5JFzXP0zpE0mmSVunNSRYATIr/dQFoBcN7hh6WtKt56O46SV9X43DbQ7YtqVfS7zTjR16ifKuk\n", + "P7W9XtIGNQ77DfumpEdsPxgRHxt+XUTcbPvkZpsh6YqI6LV9zKhla4xpANgDt00AAACoiEN+AAAA\n", + "FZFQAQAAVERCBQAAUBEJFQAAQEUkVAAAABWRUAEAAFREQgUAAFARCRUAAEBF/w/CsMbhRL/ldgAA\n", + "AABJRU5ErkJggg==\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -5125,6 +5169,9 @@ } ], "metadata": { + "description": "Define, train, and test the classic LeNet with the Python interface.", + "example_name": "Learning LeNet", + "include_in_docs": true, "kernelspec": { "display_name": "Python 2", "language": "python", @@ -5141,7 +5188,8 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.9" - } + }, + "priority": 2 }, "nbformat": 4, "nbformat_minor": 0 diff --git a/examples/02-brewing-logreg.ipynb b/examples/02-brewing-logreg.ipynb new file mode 100644 index 00000000000..d36871fcdfd --- /dev/null +++ b/examples/02-brewing-logreg.ipynb @@ -0,0 +1,5771 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Brewing Logistic Regression then Going Deeper\n", + "\n", + "While Caffe is made for deep networks it can likewise represent \"shallow\" models like logistic regression for classification. We'll do simple logistic regression on synthetic data that we'll generate and save to HDF5 to feed vectors to Caffe. Once that model is done, we'll add layers to improve accuracy. That's what Caffe is about: define a model, experiment, and then deploy." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "import os\n", + "os.chdir('..')\n", + "\n", + "import sys\n", + "sys.path.insert(0, './python')\n", + "import caffe\n", + "\n", + "\n", + "import os\n", + "import h5py\n", + "import shutil\n", + "import tempfile\n", + "\n", + "import sklearn\n", + "import sklearn.datasets\n", + "import sklearn.linear_model\n", + "\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Synthesize a dataset of 10,000 4-vectors for binary classification with 2 informative features and 2 noise features." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAiMAAAImCAYAAACB54oCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXmQHOd5p/m8mZWVdZ9dfV/oRqPRAIiDIMH7ECmJkqjL\n", + "lqxrZK3Xno0Zz3i0G2Fv7EZs7IR3YsYbc2x45N2Vx4csj6WRZy1bHh2ULZOUSPGUCJIAiLvRDfR9\n", + "Vtd9V+a3f2RBbIIACRJoNAjkE4GjMquy3swvK/OX7/ceopTCxcXFxcXFxWWz0DbbABcXFxcXF5eb\n", + "G1eMuLi4uLi4uGwqrhhxcXFxcXFx2VRcMeLi4uLi4uKyqbhixMXFxcXFxWVTccWIi4uLi4uLy6ay\n", + "oWJERH5fRH4qIv/xguU+EfmaiDwpIl/ZSBtcXFxcXFxcrm82TIyIyK1AUCl1P+AVkdvWrf4y8F+U\n", + "Ug8rpf7HjbLBxcXFxcXF5fpnIz0jdwD/0Pr/E8Bd69Y9AHxcRH4iIh/bQBtcXFxcXFxcrnM2UozE\n", + "gELr/7nW6/MMAz8AHgX+dxHRN9AOFxcXFxcXl+sYzwZuOwdEWv+PAtkL1j2tlGqIyBmgA5hf/2ER\n", + "cevUu7i4uLi43EAopeRiyzdSjLwA/BPg28DDwNfXrXse2CMirwKDwPLFNnApo11uTERE3QxjLiIa\n", + "dPwWPByCbavO0ooHnuiDl/9cKXVqcy28ttws4/52iIgHur4M7zdhOO0sLRnweC8c+ppS6szmWnh1\n", + "ccf92iMSvAf2fxQeOAceBTZwqAeePaVU+lsb//2XdjJs2DSNUupVoCoiPwWaSqmDIvIHrdX/Fvg3\n", + "wLPAnyilmhtlh4vLdUg/DLS/LkQA/E3YnYGOuzfPLJdNZgAGE68LEYBgA/bkoP2uS3/MxeXtERGB\n", + "+P2wf94RIuBIgL1z0D4mIrG33MAGs5GeEZRS/9MFr7/c+ncReGQjv9vF5TomAOGLPCFEK2Akrr05\n", + "LtcJgddnttcTqYAnfs2tcbnR0MAIQiz9psWEFBDgjeEU1xS36Nl1hgg7RfiSCMnNtsVlw1iGeQ2s\n", + "C1zUswkonN4ck1yuA5ZhThzX+Xrm4lAc3xSLXG4YlFIWVGdg+gIPSNkDKxawtimGtXDFyHWECF8E\n", + "fgz8MvCqCIOba5HLRqCUWoX5n8NTg5D2Q02Hkx1wUEHuhc22z2VzUEotwewr8PQWWGudF8c74WAD\n", + "8j/bbPtcbgQW/wGej8DZBDQ0WAzBT/pg5XGlVHUzLROlrs+klZstuEmEUZwYmgeU4rgIvw18CrhH\n", + "Ka7PQbrK3Exj7qSzm7dB272ghaB0AtaeUkpdNJj7RuZmGve3wwli9d0OyXtAC0LpWOu8WH37T7+3\n", + "cMd9cxCRAWh/CLz9YKVh6Smwj6lrIAbeasxdMXKdIMLfAC8oxX9ovdaAl4DfU4q/2VTjrhE325i7\n", + "OLjjfnPijvvNhytGrnNEuAWnWu2wUpTXLX8U+NfArTeDd+RmGnOX13HH/ebEHfebj7caczdm5Prg\n", + "N4GvrhciLf4OCAMHrr1JLi4uLi4u1wZXjGwyIviAzwL/+cJ1SmEDf4RTPM7lOkVEvCISFxFjs21x\n", + "2RhEJCwi0c22w8Xl3SAigdY16rq957vTNJuMCJ8F/rFSfOAS67uBo0CXUtSuqXHXmPfamIuIHoL7\n", + "k3B/GPQCNFbhqRI8ey2CwW4UrudxF5FkCj6RgCEBsjC3CN9VSs2/7Ydd3pLredxvFEQkEIcPJ2Cv\n", + "D8hCbgF+YCl1cpPsueSYb2jRM5fL4vPANy+1UinmRTgKfACnuaDLJiEiW9vhPi+kKnDWB/ZeuO1u\n", + "mAlAswTGs/CRw2DhtDxweQ8jIr4e+O/vB98ITGvAOYj/BH5DRP5AKZW7Ct8x2gH3eiBRhokMPOek\n", + "+Lq4XBkiEo3Bv+yF3TFYaYOJTrCehi+JyB8ppaY228b1XLcum5sBEfzAQ7y9yPg28JmNt8jlUvhF\n", + "9u+F3/gItH8Wyu+HsR74F/1QCEATIAiNu2EuCe9zO1G/99Fg23aIjcLy+QvlIGRuAcMPu690+wGR\n", + "O26FX3sUkp+DyiOwcxh+U0S6rnTbLjc3IhLphN+5HQ58GFZvBU8T9o/D8H4opODezbbxQlzPyOby\n", + "MPCKUqTf5n1/A/wrEbxKUb8GdrmsQ0SMfvjwwzAXxjn+vZAvQXMOtm9z6sMAEIZ6AEyc0sqFS2wv\n", + "AcG9EGiHwhRUX1NKFa/N3rhcLkFoS0DjwuVJKIfgsgRDa45+BNp2gW3B2lFgAjAHnXNqNtj6ju2w\n", + "pEMqB+8HvnEVd8XlBkdEUhDaA/42yE76IbkTkoOQC0AzAM19UHsGtgjMmpd5/l5LXDGyuXwC+N7b\n", + "vak1VTOOo2Z/vOFWuVxIWxt4zwsRAB/U/FBahVQNdNOZmiELZgkqQFlEAsAwiAlqXik1LyKDMPxr\n", + "sEsgXoGlnXD0ARH50xuxsNV7mRIsr8KbgpJXIVCA2bf7vCNEYr8Mo/thaxFsgfE74NRzUDjc4VQ1\n", + "e4PYGYJVP2yT1uT6BdvrAOkF1QQmXAHrAiCib4Ntvwo7LYhWYX6Xl5/u8VNdzkC0HYqGU26VdlDn\n", + "oLsK112lZ1eMbBIiCPBRnA7Gl8NjwKO4YmQzqJZBs3l9XtMAy3Dm+PdXW2IkB+bz0JOGv8XpzPtF\n", + "GPGBX8G0iERfga5BeLgA3QXn5jS4BtEOePyDwJtaeIuIF1BKqTc9obtsLDaMn4K1FHSMwrKAmoS2\n", + "16BahdcuYxPDjhB55OzrZ86wQPMuODRTusg0eQG8NrxBZDjdViMfhp33wBYFVQ9M1ET0byllnboa\n", + "++ry3qM1FWxC76fgg2loO18aIlmjb+sy6f4wtn2a0v5eGuNRSOfAPAeeVXhm0wy/BBsqRkTk94H9\n", + "wCvrO/iKyO8CnwQywPeUUr+/kXZcp4wBVaU4c5nvfwzHdfvbG2eSy8VQSmVSIuNHYXA3LIDTymzR\n", + "6Tr1138N0QCYBbAzcC4EO2q0/1Ob903AYCtIbB/wg/ugFAB92s8rt3qoRy085TLRKfA9ItJmQ/Ec\n", + "1F4DAtD2IdiyDZQSSRyCzONKqYtO/bhcfZRSNRH5+pPw4ZdhTIAcnF2Bx95qHESkDcK7IfEIJMPQ\n", + "MMBsiUmPguEmjCeXKJ07Dl07YAmgAsZzcFcViv3wr9pEjqXhSSAB2++D23KwtgOCCQho0BwWkS8r\n", + "pS7Z4MwRMgy3wT4NvKvwmg0nXHG78YiIH4ydENsClTUoHr4a3k+nhEDofui7G1QbxEZAPQOUYTUB\n", + "9d1V9uQX+ck2H9H8El4tQ3aXQX3yCOQX4StKqbf17F1rNkyMiMitQFApdb+IfFVEblNKHWytVsBv\n", + "K6We3Kjvfw/wMO/My/EKEBdhSCkmN8imGxIRMYHe1stZpdQ7TpFehe88A184B/1xsBdBm4dXy/Df\n", + "ys75fF8X/JNtcKtAXogOlDnTW2R2HMKrMLQMW9Pw8t4kk73tGCUTM1OhFlth9hMZAiXFg6cgvRMO\n", + "fwA0A+6vw8gMWBoc3w3P94jIf3JvJNcOpVQG+JZzY8EHdIOxRUSCwDml1Bta7IroIzDyq7DLhsUO\n", + "8A7ARBIGn4NAqxGZBdjNFfj2U/DFCeiPgpqCPX6ofgmOBKFxBkaeh+FpkkswYEH6HuipQzjjnBPV\n", + "QVj7TRH5PaWUEhG/CXsTsLMJpRU4GIKh7fDgqOOqb56Fna/BuIg8jXP9X1RK5a/hIb3hEZE4MAjJ\n", + "T8A+D3SXoGA607H6N5SyrrADc/wTcOs+2D8H6SpM7IDZ98GZk1DrENp6QjTCeUSfIxP1oVMmoPLU\n", + "tTT8llJq+mrs59VmIz0jd+CUOAd4ArgLOLhu/b8VkQzwO0qpwxtox/XKQzhZMpeFUtgi/B3wEeD/\n", + "2TCrbjBE9FHo/wz0eZ0ls3UR/dtKWe8oz14pVRCRP16BHiAEpJVSKwBBkQe2wG/vAyMB+Qnon2Nl\n", + "QCNR0on3WMg0PKdD7IhONhKhUjTxVRWgaHb6Uc06lXqR3iyMrEL2NvAkYfRHkDXh+AgUBiASg2xC\n", + "JDzuxMkGK1CegNrR9fEDTjCbMeS8aky4sShXhQj0/BpsC0MEONsO0yGRyDhUX4LGT4Ey9H4aHllz\n", + "XObhGkz2grkVJraAbwoikzDVhMpppVRORL667AjlkV0Q/DT84rzcDks5GJ6lOWBTDMGIDZGWK95j\n", + "QzIHqSEodYtIpgN+Yy90DECmCqnDcFcGEh+CZzyOYMYPjdNEPg/9d0IoB1NxEf8RqH4HmL9R6+OI\n", + "SA+kHnLGws7C6k+h/spb7a8jQD1jEOqE0jI0jiulLqySvf79OkQ+BKN3Q2QIvD1QnYboSzCUhp4A\n", + "fPfTIvLvlVLNd7kfbbBjL9wz5czymXl4QQO7H2LdoPngZIefeWMrqtJGpFCiYZyhYdrgBc/7RPRD\n", + "YI+/1b5sBhspRmLwiyf4HLBz3bo/UEr9HyKyFfgz4P4NtOO6QwQdeAD4Z+/wo48Bv4ErRi4LJ2tl\n", + "6xfgI2uQqDhLMz744RdE5CtKqbfLYnoDrQvXG9ybIhIbgUfGQIaduAIqUOnCE5whWvQS81UI9kEb\n", + "8MJIkFza4Kidpz8OAU+dfNSklI1il4ocHILODJg6+KOQN+Gle2EoALdUYDIFvZ+DVaBrBdIV8B2H\n", + "6QdF5GtKqRWR0P0w9kHY2rrInhGR4N8pVXquZe+bAiNd3hpnqqPzM06pn74ZOHkPbDsAfX7IjkLt\n", + "fTD9UVj+E+jyg6cIR7shF4RsCIZC0KnACMOJe2Hme0qpRfjFOTUjIu1beL0dhAXaKYzdZQIjJh6z\n", + "wmovDCyCVQLdgqbAItCXhXMJH2zZBx13wi+eehVEj8O+LBxsg7IF8jTRA152Wx4k2UT1wH0a5MZg\n", + "+haYf0xEvn+ht+e9joiMwcCXYXcNRiegosOrn4YjcZwH5Tf9Lpybfs+vw44ItFVh1YQTD4vIn51/\n", + "CHkz5m2w+1548Byc2gWjM7AQgkO3wcPPOAK1MwEzXcDMu9ydBLTbr4cbLUQg4oW2AKgEYPjR/T0E\n", + "lQ+P1KgG2zALFUqBEvFBgx2fbBAYgdNVEfnPSql3a8dVZyPFSA7nEQIgCmTPr2i5PlFKnXGmNC9O\n", + "K7bkPE8ppZ666lZuDvuABaWc+IN3wJPA10XwKUV1A+y6wfDvcKb6zwsRgHgVxhTM7QKevgpfMtQJ\n", + "YQW6AhFQecxoikB6num2JjEDwg2wbIiUFPHaANlKgEOncniSJfz+PEnPArFeiNchZ8FqwLnAnOmC\n", + "riAMZ2B6AJIeaK9CxIC2DGxtwpEOuHcVnviIiDwBux6Bj85CJgW5URgLQX23iPkDSLVBv18kdQJW\n", + "n3SLa102HdDZDoMzMN8FshdCNlRsyPdAxyyU90LjY5DphIP7oFODYgcMhCA5B8sGtB+GO1cgHxOR\n", + "5Hkx3ApETExARxIK/ZCZRBtZJLmtjNey6TgBJYHpPqho4JuHKT94T0OxAhQScP8QpBegcxH/tjpa\n", + "CBoSoW4uQLwNytMQr9IZ9uBr2GQG4aFxCDShVHLCnmJ3wgvjwPHNPNhXE5HgPdD7O3Bb1LkOTA9B\n", + "/CC8bwqWHxCRM5C8E/p3ivTVIPsCFJ+F1KNwvxdGW+JuFGhPweOfAP704t+WvA/2LTpxQShQAn0F\n", + "mIrDfLgVtA6tv94lBVhbF/g80wPdSUjUYDIEARWmokxiYlPVGkRZZjbuI6gC6HaGALA9D4MWPPZ5\n", + "Efm/lFLWFdhz1dhIMfICTk+Vb+PER3z9/AoRCbfc3m1vZYNS6nc30L7N5CHeRVaMUmREOI4z5fWT\n", + "q27VDYcZgeBF4iuCDfBF3rz88hEnb/f+DvhMAw7UIXAMurbDMRvRPaiaRdNsULJBhUBVwciX6Dsx\n", + "S237QzRe3ktz9rs0Rldp668zkoZEEmwTlBdeqYP0wO46VE0odDmpwB6BjjpkA9C3CN44RMsQ2Qrl\n", + "FRitw3I/NPZCXxG8RZjfA/F/Abu/DT2zcGYIXhgWka++U+/QTYreusEA+S1QD0LNB9uakGhAO2C1\n", + "weIdYPth3xokS5DvhJEKzA1A8EkYmHC20RWFEykgLSLDkPpdaB87jZ5KkzuQZPmkh+aOABW9TMkI\n", + "otk1trwE8wKrEQjkoeMVJ1vz1TQwbUNlDhmtkhrxkCh5MUo1apFFZjtzlHvjjmrxKnxkyMVteguO\n", + "EAEwGoAPRrMwsZ8bRIyIyADseRR8Hhibd8awzYDJ2yHyBMRM6P7ncH8ets5CzQOHH4KDQxDpd+K1\n", + "1jO8Ai8NnL9/vfkbtTBEW20C/GchPeJ4On1AzXAEyUIBx6X1rlBKLYjEq/DjT0LKhmwb+FPChCfC\n", + "kh7EtD1kBDxYKI+PYKkEAYW/UUH3W3QmIfsANBehexnme4HrohLrhokRpdSrIlIVkZ8CryqlDrZK\n", + "KH8Z+PcisgvH1/S/bJQN1zH3AX/xLj/7OE5RJFeMvC3ZszB3D2y/YPmsH7JXFATshX3b4Vd6oXcV\n", + "wl2gCtD5KoTDVBcnqGzNMCgQa4DHC1Ud0qZNW/4MybNF8r1JiI3j81cIVWy0GEgVbNuJNQg34WgQ\n", + "ZKcXb1ChouApNAhYUM2AtyWyBOcJTAG6AZpAZp/jRcnFoV6HgAE9y1AeAX0RRpeh1g1rB3A6Q7tw\n", + "PtbGP+YUWM1PAJOtKYtlWKrCmt85zmtBOFAFSwdfBQwTegNw/FZofwEWvJCNQ7YHFn1O8cvMGMxN\n", + "Qc8K5AWnDk0Ekn/kZ/uWKPEyWOUS4c4Gpf4dZKshPItxYhN9+MpHmd42x8jzcPpW8KdhwQerpyD9\n", + "XaWUrYm8chLz10ZIzekYTYA6IitELYEHTMojWbBWWA6W2TrhCPXzFELgnXbiUDTvZhz7jSG+F8Yq\n", + "MFuCohdiNSerKS6QboeVHtizCNtbHkJPA+6eguWtsBKAwhKE62/MwJZf/PVmqqfg7BYYWYGeMzDZ\n", + "5hQ7PROFs/tgpQjLf3AlnggR320wGoN6GpYTkAtBNtJNs96J6THxSI6geFmTJpqZJaw38eglNHJ0\n", + "LkOyBt46ZLqc6gTXTxX2DU3tXZ/O23r95da//3Qjv/d6plVf5C7g3R6DJ3Bqk/xvV82oG5dxOHkO\n", + "AgMwugKi4FQHnJoG+/SVbDgJ7+uBvm3Q6IbjEzCUgOUiJI9BY45GCXxhCJmAghUTvE2YuK9BLTdD\n", + "Z2wGyo54aOYglIGGB7xV2FqAxXaDSSPEaV8nw/kaZqVEPZilEquxosM9x5z6WLWCc3PMnoT8Cryy\n", + "H3YNQaDiXGfmA45nJnEcFuJOFoZuQ3cWQkNX5SjfAIiYe2H007DdAtOCqfth/LiI/H9KqYaI/rfw\n", + "D1+AnipUNSj6oFKDqG5SSipKugezGqSWylPI1SgNQp8FWQvQIbsTFrvhmUlYfBaYBeOLQWIjXXQt\n", + "amgKwEOlEcHXZ2NWdNomPPgrAINU/SvkQ3XqT8Hk14Dy+t44ChbPkpirUY62I6qG8ixh9YcZOa44\n", + "5dlK+eUiBBdY6bJJZRxPzqAHSiFYsaB3Ag6lIP2OH3Ja6cOj0H47eAKw9hpUD21+gKQRAF8D2sdh\n", + "/DbYV3e8Izow3Q5VCwbm3viZugeiAzDXAc/uAt8CDL4Gw2k4m4TMzKWzj1Z/Ai9uA6sD+tbAOAHP\n", + "doO/AH0ZGMzAxKdFTE2p2qvvdG+clN6+R+DhKSguwultYEV8pK0ONJ+XoLJoSgilVhERBI1KPYtm\n", + "rBJWdXr8oHdAtRPsohMHw3XT8NEtenbtGQFKSjH3tu+8OC8AO0SIK0XmKtp1w6GUaorIN+CZO+Do\n", + "bYBA5nEo/+wqpMcOJkEPQT4ExOH4AoTKUFyG0026UhCvwUIMfBYM1sHjg/xOGJ6FWBXyOswagAlr\n", + "JdjZiiEqe6BUj8HWA6ycWaSZgJiWZdZvojSLULTJwT2QWQLPEfiJ3sHaQCfsyzM/kqGZzOJZhs6q\n", + "E9dQAuomUGvVbgMyQahPXOExuCEQkTAM/xJ8dNF5EgbYAZi74PnjwKtKWSdE5KswfwCCt0OiDbps\n", + "nVxUkbe8ZPMhqismxUKT0PYaQwoGZuCHg1CP+iloMWp+k6ZZpG4W4DkL444gZuO8EAEQmnoEj61B\n", + "vclKQJHSDMyKgRKDM711cn+mlLpYrFm5TujMOe7PnWMlJpQ6+8AK4c1VsQKDMKWDqtHM/Yij4xaR\n", + "EKzd6cQgmQswtRPO/Awal1PM7QLCH4SxB2FHDnx1OPsROLy/FVS9iYJk9Tic2wX3T8FLAXhqG8QE\n", + "pmMw8zSoBcgNQue6InNnb3OmR+98HvwjoKfg1Adg4jDMLsPydy/1bc4UivwhrHwJwh+BUgr6YjA0\n", + "BYEAxGZhLAt/+0siMvEuUqqjEDdhOQKzd8GwBUNFD/8gTdKaQc72IVoFj3gIqQLY81BWbDXrRKpQ\n", + "E0h7wKjDmRSUD8H1017EFSPXnru4glK8SlET4TngfcB3rppVNyhKqSpOoOrTTgOy2K0Q/pSIOWVQ\n", + "19qcaFZrFV5qwmuX60KtwWLRKVwHgAlWL+RPgNeAWgUtACPL0Cw6sQOVMORM6NGdKpwdraDaI+1w\n", + "OgiNPmjPQkOHMyaY54LY226BpR1kVg5T2dlFfMFGb55mMTVPZh7ypyH3zR545BGnWV91jo7JIqpy\n", + "hp91LrF9Cvqn4fQgnBmAnsegqcNUHxzcCrlTIhI/H1B+EzMAQ/rrQuQ829bg9H7gVXBuNsB3RYJ5\n", + "WPs8qC0BKoNemgZko14KHiEftPAEhZ664lAcCAXxWMO010wahsaK0UMzvkzlt6aozesUlEVN1zEt\n", + "AI1AI0tV66aWHab03ALlkSqeRJG6Vqf+LaAkkvqs4+VbOQKcVkrZSqm8SPIYLI3B/mkPJ2NesvUi\n", + "c7GtZI/prdTeKNS9EK0wOAf9fwXlJJSDsKpB8fg7rcHjxP2N3QcfmAKjJXQ7iyAD8NQ+4LkrGZgr\n", + "wz4Bx6bBMwDD81BIw9FemPwOFL8O9MKRMegwnSmctSgUtkBjEXadAzUDy12QGIAXViD3f799Cf7A\n", + "MGxPQNcrMPlx2N+EYBegIJeCxkHn9z8xCBx5hztUdorznt0LB8qgMDjcL5Q8BootKGlH2SVqzKM4\n", + "hthBRnMNYok6/Tk4ZcJEwIk9C8yDlmnVp0lAaJ9jZ2EWyoeUUtm3teYq44qRa8/dXHl7+fNxI64Y\n", + "uUxEjF0w9jnYVQdfPcjTnx9hydxH7UkPNE7CZ4/CqIj81eWkvq7Bd1+DD6UgGAMrC+Gj0DlJiCId\n", + "eaiY8FwnDOiQbDjBhw0DUjqEgqCvOV6K7SswbcCiCd/vgWAOuo5BNlDCLs1DyoNIgKTtI1hqoIwA\n", + "sgwPPQGnwvBichv4klCYhM4mdihB9HQfRTIU9DqaDmYWXq3BnALtY2AFoP0obLsFjt/SKsR0uZWA\n", + "b0SE1s36jWg26+IDRCQKdAN4ODxlEd+q8KaCNK0eqpl+AvkF6tEKZ7x5PBVohGBbrY0l8eHRbZQu\n", + "9GAx3x7D9iyQLxisFWqc8uv0NwXdyjGXTFM1vAR8E1gHOikd9cDkEag1CAvs/BKMtJ6oT++DUwdF\n", + "5DvOObv2DPxkBI7f2SAUWGW+J0lhfg07/gxs74T0PPgqtG2Be2da5cNb2SIFL/zVgyLy83foNeyB\n", + "AV4XIucZTEN8F5soRpRSdRH5c3hmLxzbCyoDy98H+/jrKdXGX0L+E44gKbSDVoEHXnCm6rCgfwoi\n", + "i/CaoVT2LYWI07ph4GF4YBZeuAfaxOmXGbKdhKe+cZjYBeoEl4w7eUtMmKuBvQNOphOcHuxCjzQQ\n", + "+oEaSA7BoGkZ2JqNqVWxQxYLApk4RDTYtQbNEJyIQOWQiNwNfR+D/XVIlGB1BI7c1+qV9U6zPa8I\n", + "V4xce+7ikqlhl80TvPuYk5sOpwLrwC/BI0vOE9CRnmE80klPpcp01yjNo12QL8Pul+FnwLmLbCOM\n", + "M8XWj5O2PjkJ/28V+Z+DGIkqmiwSDtXoaNj402AvQK0PxtGYbyQ546ni16r0WopGsEmh3bnIrXmd\n", + "aZlQENp1KHXD5GiM5aUOmJ+E3TFQNna+Qi2QoelfIXQS+jOQD4D01pEdPye0TfAE6pSiNbyDfrRJ\n", + "k8piHe9rUGqD9J9CaQfsN+HeU87UEcBAAP7bZ1qFmG7Wyq5TMKlgr/HG7KvxJKSfBhAJPgBb368R\n", + "GwlT6NNZDTQpxjvQzE6MchKlIngaIczVBRqJJXJpiKdAs00aXhvNFAJ1DU/Jxh/woed06EiT/VEP\n", + "Zx5ULPlXoatOl1bltidPUp+aZ2YY1h6okfurAjwLY78CH1zX52ZLGqzb4ODJpMiBfvSPe9Da1kgH\n", + "sqS9eYIxYVuygbKyLLPKUn4OJiF01hEiC2EY3waVTtCroOWAqIjkgCEgCKzgVC2+lEBvwMWcKVUD\n", + "7E0vP9Dy9Pys9eci6xtHReQUzLQDKdj36TdO2wCshqF+9mKfd4oqtj8IRjsks2C0wXITyvtgyAMr\n", + "EQg1oC7AWadp5oTJBdcYJ5iZLTgiZWq9t9KJyQm9HwY/B8n94OnycXKgm5ovjJIqNj78YlFgCdu2\n", + "8Gg1YraHiC1sLddYMkH3OJV7vRnwlSHSDp33QGgUfDoUTzrTxP1ZiCeg8lHgT97lYX9XuGLkGiJC\n", + "FOdHfugKN/UaEBVhUKk33zhvNlp1GiJApTUtcyFd0G04QgSCzHUmMKpevJUcZh80j2rAADSPO2Lj\n", + "3Bu3b+yCwS9B5z4I+2BNIHO2QXp8irZjBmqgQWUnbPfAliJoKajPw5EuKAbaKWm9+CrnyItFXdnU\n", + "DMGONjAyzjTNgOk8gXWehELCx6FhE2+jg8njNZqFcdSDipUhH2Y+jydvES1BzgcZDYx9M4Qe2E6y\n", + "YSLNBqVimYo/Q2NXmdAqvBKC0y+COumUp77zzOtCBJybUk8CZru5TlL8NhInCJAQUFJK1QGcKQ7f\n", + "9+GxT8BY0wk0nvbDyVPQOCwiI3Drh2C3lWSm20fMyjNiengl2Is/pxB/lka0SsaroWeDmIt+FoIa\n", + "VV+DQCBHzgzTXjfQchaNkE3NX0G1l2lXDYovTFB/zEv+n9foj9qMzYLodXz2Kvd9Dxai8MOaE3Q4\n", + "VH5j8oORGQzxAAAgAElEQVQGDFUiHPrHe7AiGh3+ObyaQShikEw20Cyb5YCP8ILGVjsH1k6WZl8k\n", + "3V3jXBrO3AOjCjqKUPJCeQxWPgKxDhiOQVQ58Y1TJ1sew4vFF5yFiRqMBaG95CxqChyPwdLbdiS/\n", + "HmiJ8DkRmYfZ2+DVPtg975QOWgnAK0FYeZOHR8S/H/b8CuxPQ2oVJrvh4Ifg1boTa2JUYK0Gkzoo\n", + "A5ZG4HQB5r6/PvjYCZ4e/mXYqjkB7ZNqfaFCkF2w5Z/BwHYYVFAt+chHgqD5MOwGFZpYdhil5VFa\n", + "mYRtYTbzVGolyhmnyFu/D/wLkFiBQ/3Q3nTaU5QM2DUHrw3Bq1U4cBoG1iDSLyJBpVTpWo2DK0au\n", + "LQeAV5Tiip5AW6Xhn8Cp3/K1q2LZexTnh9z7YYj6oaJE4i9B9h8uuHC2Klaef+GtNbF0ha0JWHXw\n", + "6GDXQGviFJMTkRDQCZiw9bOwqx8GixBbdLb1syQE+6Hpa7BnFV5THpIVWAs28fqg/yyMjsMLQ0ns\n", + "vIGsdSPxSY70K/o9YHhgdQtIDSJF6DgNnoZGM2jSU62TC84RGdzF2hELtnix+vLoq+1EFsLk2sf5\n", + "649XyaWhYyhPuJImbwQQvwKjSqW+RLnhJVeqUPsznHbztkjfJQ/jRo3P9YLzdBm4G/ofcgrKFZoi\n", + "kWeg8LRSylKq+pKIzMD0LvAGYO00MK6UskRSt0NXSmdpjx9POI+Keog1LKKqTs4IECiXiRabWHYE\n", + "/6Rien8KZipYVolFslSUh2kjRCQWQJRC5WZI5hp0NCDzqEX5RxWGcpA6A/1rTv2PuVGYa0DXJHg6\n", + "wJp06opYAucSwlpE4a/CYiJCcyiPkcxQjVTo9gpdEiBRqdEMCPFqhsl6F/3H6lTjEZbKcQrNRV44\n", + "AHcJ9OWcGlzlIGw/BNkvwL4X4ZZ1wvTZMXj+7lY/GxOonfeUKKUqIvJN+MEXYWvSWT2FEyD6emn7\n", + "9wKt+Im/hGcehWO3OPVBMjlY+MaF/VxamS0fggfnIFprzfINwq1lmOuBvhUgAilgXIe6BY1OyE7D\n", + "eiEiSdj2Kfj4EoRa16zdHvjhR0Rkymlol/gsDLVDW6Pl0QrYKK1AjSw5rU6FMnVuQbMEpZXxFLIE\n", + "V7Kk1qD3R5C7BWJRWCvC7CrU4rBrHmYSLSuA7Vl4eis0W31zrF/89U4QkW6BbgUNnOvO28TYvI4r\n", + "Rq4tVxS8egFP4sSN3LRiRETfDrs/C/cvQiINNR1evhNe8gF/ve6t8zCXP18Fscrw3CxzwwbpjhCl\n", + "+gR8pAr6Ucg0YNpxyQ8/DN0Cc93QvgW8liNEwEkPHKjDfA+0Bz2cNdvJBxKcVaAkQ8WzxPyOJjtO\n", + "GhQDJtWmTj0IXrMTtVrgRLBOuJLBVhCugG8Fym1QbdcodFvURdGoZ7C8r8LWrRCqovzd5HvrlDos\n", + "lL4Fu2HimV2m3F7E1E+S1PxYmgbNBj1anXTVx0SlrNS6plzZl+DE/XD7umJOKwGYq3AZKX4tD1Q/\n", + "4MXpY/Ie6iDsPwC7Pwb3zkKgAfPtcOiLcLRHRP5SKdVslWh/Q0EqEfFB4g6QHUKyCiVDYYVsECj7\n", + "cmT0OFVvk4LewJPNkh5YRQsa7MvGMCyN6a4oTd2kpFnkfHNo5Sw75+vsn4JjAeg2Apz8lzHOBX1M\n", + "xstM5HL0LVe4dRYWR2BuDWqzUBiHEw8HOPlAF8VkCq1RoGnMszDWCc12iOo0fKusqjS6JcTKAuIh\n", + "ZjXw+UusxIsU26bw9Gk0s5BVkO+As3FHfxuTkJyFrr1gXHATumUBXv0UxG9zigVWiyK+H0PtZeVw\n", + "VkT+A0xvwTk35i5dMv36pJWe3A2EYe3HsPYkzv1x5RLl8WMQjUA2DGk/WBZ42mDwFJzrAJqw0nDS\n", + "6dssGJmFnA23/xwOfUZEryplnQDfdsc7FVr38ORvwva6U6KfWTDHIJkHCTupxzNdwgqQJYUiik0Z\n", + "OIqtp52c3UqR2087mVIzoxA9B7N3wMDzoOcg39VqtFgFzzJMd4O/Bg2fUw/pbBvkjl3Cy3yp46dF\n", + "4WO74cCgMz+njUNdF/mW9YZr0KVxxci15W7gD6/Stp4Efk/EedS6Stt8j9H+ENyefr3cu2nBndMw\n", + "tVdEnlzXdsASkf8Kf/8lGI1DyJ6mmVcsDd0Ciw2wVpwLei4Lv55jLOJkB/gsOGiCsQ2qHa1mvYCt\n", + "QSMG1ZSXfLyLpWYbutcRQyHVgQ9YGZjj5a4I9dUY5UYcO9aNXZumaKRIvjJPxczQdwKWdkM2AknD\n", + "QEVC+KtCIaTTMDsotRXAlwZ7FKw4LK5ipcYgPw6+WfSOXmzvPOlEGUP5ERSa1QQbkkaJlQsKWBWf\n", + "g5e2OU33eipO0OIJu/Xk95beOicTqesfwUDUeWKcRST4hFKlq1FS/13Tuolsg9Q+p2DXyuFWgGJj\n", + "3Xt06HsI7poDQ8Hpe8Bsg70Cxf8B1lIi8hegdUByJ9hNSB8G6dFJ/Hc23tsVpVgTvZanogtSt/lZ\n", + "W4Kyt4K3OkHN046lFSi3z2ApD9snY8RUnXP9u2mW4oSLSzRSFmg+YpTJtNU5tgr1mQ4W93Rhd+/B\n", + "N1WiYqyQbV+jmphgsbdMfAnmm2DMQN/2IKfv7YP+MP5yGbGgFLody7TRghECqonHGydQb7BipkmY\n", + "DRJlm6Y0aJgr2FsVKW2V6OAy6SzkJiFyGiKWk9nlr8H0IOSjMNMHwarjNQGY6IbuffDgGUewrPnh\n", + "xU/BazqtWAylVIX3aOVWJx4s9QXo7XNu+KvDIBXgJORfFpHHLzJd0QGVO0GrgSSgnIKyD2QcrDSk\n", + "JiEB1Ech1YTYFDTK0L/s9ChafBg4AZoJVhQmw6A1IL4I0aIzVWgEnK+qp6EUhJIfzmwxOW30UiKG\n", + "zQgKDaGOwgMUERYJzzoF7AJVaCbAmICXF6Dshe4gzEWcINbgMTD6oNzlbLtowbc/DvlZsLMixj3Q\n", + "fPlyRIkGYzvgzvfDufOZW9vB/z34goj8u9b58Za4YuQaIYKG08n4S1dje0pxToQisAsnhuQmxOiA\n", + "zgue6DUgaeH0Q/pFEJhSakZEfh9mR8Ab8lGdHoEZ02n2Yd8N6RDUsxgfz9F15PW4irY0zBYhmoK1\n", + "GPhqwvwozCY8ZD0+yipO1aehdJs2BR4RmkTxacuUfHXagqdINjrJGu2oagq9eJh89xI7noH3H4Y/\n", + "7IL5EIjfwO9tUkEx6YlRtrxIMIR4YygtCbk0pDzgr0PQxEMD3aOj6UHKWhc5/PQom7pWYk1N0oiU\n", + "8Ovrj4xSqiwifwyr2yA6CJUsVI+9XRqf45Lu+VV4BOhveVVqOjz+IRFZVEqdusKBvALCj8LYPU6/\n", + "DY8Fk9vh6LiIfHOdIPFBwA/RNJzZDbEEdLbK4PdaMNgOP//XMJaB4Tw0NZ2nP9dBdkc/kekVqsEZ\n", + "JuN1Rq0sOhrjZhTd66HfMtA8RdLWDIuNCI1jJXx2hDalqKQ8FIwE3oaNRAwCykO6aVL3pNBSkM8o\n", + "Ao0k1WA3dr1ANZbH5/cTL0fRfAma/jIrfdC7BPeeifD3946x1rmVat1PwcpB6AQEeiGzgDdQx1IB\n", + "sItUPQEsbZ41zcIKZkDpFP1+hpYC1FcKhDNNDjwHjw3D4R740DHH6ze5C9J7nHYEA71wthcWjsOt\n", + "4zB9O2w7BcnWDSVahduWYP79IvLyu+1Ae/3Q9sswuhPqPVC+BQZqECpAcgpy++DFDhH5k/MeEuf3\n", + "0PsxSC3A0gGnR1RH1kkDnhyE8jlY0p3KvH4djAKkBZKHnSmRzgJ4+hyRHNoJS7c5XX1tDRZ3QPEV\n", + "OGc4dVIAKn8PP/8/oSsFvkCUBmEUA0AMwUYoIpjYhAjZGmbQ5lgYjpmwoEPxKKx9BZZTEP4oRHIQ\n", + "TkH9YfDUoPccTIUhuKxRuyWGPxVBH6xgfjpL6ZiI/K/rY1wuRgpuH4OMvi4rTXfmF4cX4B+JyJNc\n", + "JDFgPa4YuXaMAWmlWL6K23wSJ27kJhUjjQWna2Xvuh+KJZDWWdeY8Tytm/GpKNWHIvDJglNTfXEY\n", + "joZaxX9iaF5orosS7M/AzFmY74CVLWG0sEkhbDBnmWQCGppE8YkQpEaGOiXAryCLQdzWiNsG8cVl\n", + "TnQbYMBSWwU9IyiBE51QPQ7mksb4dh+lfg+NkBd/yYNHa2AHB9GtKpYmqEAIrBLiz2LQJGRp+DQN\n", + "H100qFOlQUGgIWEsqwtLy1PZf5Fj0ACOtf5cLoMwGH5diIDjhdqVhZk7gWsmRkTEDMI9MbjThqSP\n", + "9oEq+5+DjtaTa38W1Ag8s53XfxdVKFWcJ/r6AKRa50tNc4rCtdVheBfc9W0IVWA+3Emzv58O04NO\n", + "haDZQU8zS85boIiGoSWINiLQ0NDKAdolR8XfTdlco2mkKQXzmEYYsFD+OrpWp0kXygqi2QX81Tj+\n", + "YJaFPXkavjqReoFQD3i1JhXLwKx6qVehewm2KJjq7CaXCtEIedANA6vUBcY8GFmI6XhUk0CxSilY\n", + "IBNsElUBYjUb2y5z1mjiXa2jHy3TOWPRNe3U5rt1Hv6+6Ljso93QvAu8ORg4CHYbjFXhyB540oSS\n", + "BoNHwUbn4JYYE6NeGt4yRW/ZaUtxpaUKNg2nxkb/HWAOQn8IUhWncNupKJy7Ax7+Biz1w8oAcD6j\n", + "phvauiHe53gUTmvgizqCYxUYLEFuDipjMBeCHa/B0IuQaF2TFiLOtUvbBXu7wXgNzg3AQBmiGrzy\n", + "EIz/BdCa3ihNgnghXjFZiASoEcKDhkKniY7jq3QCv/y24GvCljocPwvz/xWkDIk7IWfAcAo+9EOY\n", + "G4L8h8E24OUU7PihcPKhQUy7G1NLYi5Y2DLN0q5xar8F/Ju3Oo4amMa6GJMZZ2f2JiC8H4p1GDoD\n", + "r7zVU48rRq4dVzNe5DxPAl8E/uNV3u57hOUn4ee/7pR8bitDxQMHe2Dp4MWe9sWJFvvcARiOOPWe\n", + "OxoQOgr3euGpTihWaKxBxf/6pzTgwBH480CcXF8SvRnEW1U0rUE8bWUs/wqWN4GoMGGVo4qNr5kl\n", + "pDUZUAbL6PiaNUy9RNZXA49BrdHJaw/Oc0zqyAQUum3aZ/2cEYv2oE1fo0jRBDyrrCiBagbLC5pW\n", + "xBYPZjOHEgNThKal49FsTCIYdgMNH9VmgpqKU+rSRe6xlLrSWg8+JwHlQkI18FxRw8F3Qmv8Pr8f\n", + "Rm6BhUWIncFIjvPje9f48FPns6VgSx5O/MJj6EzT+Z6A538Fej1O/ZCqDkfjED0KxU7oqDm9ZgpB\n", + "jRO3tEFYI8AyhUEvPUYQA5Nko0rRGyEmDdB07JKGFLzgt0g2l1iK9dL8qSI9tEZnb5WAb4ayP4g0\n", + "TEr1TozsAvVYCV1FKWttVLVJwtgEPQY+y0PEtqhrVZaDRew8dGfAD5zuNiiONQiFSii9iS9gUq53\n", + "0CytQtjAVm0EawUaoSCR2gKNZoBFS8cqBfDNrRFpq7HjGcdt//rRBFbg3CqE74fbs05sSDkKixak\n", + "005c98EpJ15Bq3t4cesI47cMEMx58VYKLCUy8ElTpFRT6vC1Og+uMj4wtsCuAuQSzrXEb8HOIjze\n", + "AQUTOsCZcznbmhbsAHsvpDRoX3D6SVV0iPihUHa6NU93QfsZCC07TS4XxiD6ImT88POkU++k/R7o\n", + "Auyo02fm552gz0H1BGReWudx2g5bVvzkhuPU8eKhgWINjaSzA9jYlIAMtrIoNuCED46fhM67YGfQ\n", + "6ep77oATc5JdcLyEnnPQnYN0L5weDZDr7qA7q1EyAHQ01UdifpnsAyLylbcKRl2DI2fh0S4oFCFQ\n", + "gj2DkJsH9sHpJJQfh/1vdQN0xci1YyPEyI+BPxbBoxTvcVfpO0cpa1zE+CasfhgifVBpwtrTULhU\n", + "f43eAdh6B0yvQWHFeV3cCvoZ2LIGy4vYh2DSA+2dsGXVSaF9fkRYXtuJVRiG/BIDexbIDXrQzDi6\n", + "toCuFihJAp+qobFCgyVSyiKvNNY8eZo9RcpRizZVpVMzWY5XKabAZ0OqAxomlMYW8etRUrYXo6Fj\n", + "aAZ9jXkMvYeZ6jk01QnNVZQnT1Mv4pUIHtbI6xaoECZNllEIFkUBVe9xvEOfEpEXLhGEd7kswowG\n", + "B8RJdzzPdBxyz1zOBlrBr6NtsKMJ9SwcUUqde4d2DA7ByN2tFOQ1aMQxSsM0zTzH+5rc3SrcVtfB\n", + "uqD4Re0gHNNgfhiWukEKkHgN9k/AT1pz/7kUVG4Bf0IRCDaphOso5cNb1tErFpWQh2ogQFgpDKtE\n", + "TQLUu2pglWhKGbvWjs9QZAQqngzm/8/ee8fIlp7pfb/3O7FyV3V1TjenuZMzJ5AccpbLsCvSpCVt\n", + "kAWvBFuwDQkLGDAM2IYA+Q8DtoSVdyUIsCBrd21Ju7LWXIpLcmkOORqGyfnO3Bz6dqyurpxOnfT5\n", + "j68v53J2MufO7lJ8gAa6uqtOVZ3vhDc87/O0rtDzFoj1PJG+gmTX8HYnqZ7x6Lghbl7I7NtGW1XC\n", + "yCZNU2yrDWqEF8IQ8AVqJzvkpwuU1Q47UiLEJWv36LqXIPYZ2kOa1R6xP4AYFsdT2KMYqx0Qu23a\n", + "lYQzD5vsfKILXR9O3Q+LczB3CFQRRj4E28Zl1ilBM4TKcyDPQzOFH3y+ws7xA+SbNkJAozxPcPom\n", + "2NyBR0XklfciFvgXEG2IM5BrmerZuGwIpIkDuZHZV3UBa0Vk5nMwfxdgw2AZmiPIJzDdg2IM5z3w\n", + "+qAV3PI43HXVtDOfugmeexCenoXROWj+HqQDGH0RztwBVQuW+2Ybm8dhIwN4e9ojY2BGaM7ksXM2\n", + "FgEeXRRtEgI0VTQN4BJOWiduQ/E1GAWQL8HHkzfch9MRZHJw+mZ44FnjELB2HAoFKGUSpLxFx1+G\n", + "y+AAoBBypuKRx8i/viXG8OJLcFsCKwXI2ZB7AVQOXp8yBzJHofPzYOQvBu4HfufD3KDW1EW4AtzN\n", + "hx/o/LlARGyMXnJBG87HlXeSaNc6ek1ETsNmDgjehYhZmd3raVagHcJTl8wJ5J+HQwN4fhe+CmsW\n", + "9B8C73bQx2G2q3kgc5HNAx1qm1XqmQS3nFAMLRIp4iRtfOsifekzkQ7IaOjaUCBgpRCwNQF5xhRE\n", + "MUhsjmhNnQka9pBRYUhmlGXNdlmwMwQ6Yej2UGmAnRSYD5s0rApxcAEZXCTnd7g5dNHKoekoJmTI\n", + "jqzQpIgd23QkwQ4CVFwiGbbg5g58XESeei8ksrfex7ouUnoSvvsA3FyHTARXJuGFIfSffbfXi4hd\n", + "hl85AccPQC8C+wzclxf5Tl/r777Xz2HB1IKZQwVgEna2aFFgOsyyO92FC2b89UzeEFB/4jto4GkR\n", + "+Xtg/R24Y88s8Ow0XBCjIKofgDs2UiaDJhulBXYcH1UY040c3HGPoTtJtjOi5ZWYsvu4qod2YmJ3\n", + "SCt1yGbanLgrR7Ee0GdAU2qEF9vo+S1UfpLcsIDf9wj9Md2wjq7CyGqS0ztEiaKZ0eSigMrQIzvo\n", + "cWnKEFj9I3WKVpG+zjBNQKQjurJG7CQk5Bl3zjKe6FDC5oBt0Z0IqBU8KCdUGop2ADuLMPw8pDuw\n", + "edSIYB1W4OZhbhVqx+Dcfph8HcpdMyl2vgHD88AWvDiZRd2bkCUhZJLBuQMkZy3QWVjCJOgf6Pj6\n", + "KCEiOXBOQG4K+lvAGQhehnMnjE7K7hSQg3EK413YLsL5GbjnIageNXySeg7OR7BrGWXVkTY/uyNw\n", + "FLRH8MAel+38NNTvg+kpkHkYHYb0IXB8mK2CnwdvaKZyggQKFtTuhsXfAnkV0jmo9oWNWRAnIERI\n", + "iLBw8agTsUZMD802hQTuXDNGf6ddmFiAlW+88e3dGuT2QzptWpT1CPblQBKobKeEKwFjp8GGKmOK\n", + "wyO6xYBwAyP0eP1+VMDhKbhVmw7RKzvwL5+Am/LwuWVonoQXDhvRvGt4x2D1hgYjhjDIncALb3bw\n", + "3St3vQj8ttb6Z3o8VYQJzAl7I7gd13gjPxPByCz81wdhugq6BlwyYkS//04lwr2s/72MmY42IROA\n", + "5UMyC7Up+PYpWOnAmZbWv7eXwR8QWhua4kF45DTctgHt4pjMdJ9KIeFlO8JOXyHJOCgHvDRHKZkm\n", + "VG02YsNavzmGgjJeMPcgdIAkTdFqxKvuUSxyWDImR8CW32IsEZ6GSW3hxAVia5fESmhainFYQg93\n", + "yTgBRwLFpIa2PYPNBFOEKJpc1h1i24PIRUbzjIMOWNMgR+AXTsOte8ZlH3Act/sNeHoDLn3MTBy0\n", + "12H4no5nBcdPwvFPXUdg2w9WCI+IyKn3+gkSGHSu00TJw2iR7guvEj80ZiGC50xSx+pjwKW32obW\n", + "et1clzp3Q3Z/jsbCfqJOFrXUYryvzvpUm8MbW4zGMfFugdiJOO3VWLFSvMEsuc1L1JbqDCeKzKUW\n", + "aRhSdwV/oKlqHys/wsoHzPbhodfhm0fGlHsNuv0JxrZg+XW2btLoZBLllMhQwB6uM7auYqUxTlZo\n", + "ZFOa+y3i0GY0GrOUHbHCWZpSYIgiJwEzRPRwGMoWvYxidqTJeIoNew5LJshbOeJxn42pHsPamOU/\n", + "MSJn9RXjEH13BJZAtwrShdw2rC/Ba9NQGBu58LXvG50LEJFvCtx1iGGrAEPP6EjQAS8wme/78rT5\n", + "84CIzMDS34ITGdO22PHgtR7svgBn5ve+0prxqOlapoD62g4s+HAEyCZQ7RtdkfE8RJuw1YUnfJM7\n", + "6QJcqcPNZ4xWzMiCU1+C2/KQsQ1npKYhPQkkUE1hEujmoKehE8Mogf0JTOTg8oNw1yXFqbuX6MpB\n", + "UorkGGNzgQEdNC4T9IEu3RTuHYA1B/Rh/5bhoWwtwcoVswdmLhlfqmEFagVQPthb0B0BnZDMDwLi\n", + "W1uks0M67YS+vUNr3Eb/4fWJjBhfhC8eg7uPQFeA83DbGXihBf+uBZen4TeXoHn9/r8AE++0Pjcs\n", + "GBGRO4Cc1vphEfmnInKX1vq5657yS8AO7xIt/YzgXuD5G9RKeQz4b4H/+QZs+yPHw1A8cZ0S6Iuw\n", + "8B/gUeD//aDbNIFv7kFY/uTryE11Brcfo/PCx4gutCBzBnQbvisihWn4zw7C/ARYz5B9YEC8EdDt\n", + "wNpck92FPuNpKOVssmHEnC242Ixw2Q41TjAm6xuR3eUh7JRhMgVHaUoorgAz2sdRDqGGFCFhBksg\n", + "lXW2xKWoYWRrlFYkEtDSLZRuU3T72J7CGwvttMKGWyEXWQTaRqksRSKaqYbdAnEyhE4edn04fQes\n", + "deDWOtnfFMk89l4maN6MvYDvRRFpLsGvrhjZ2JWr8IW8yP/X1/qJt3ttFW45+KbMyoPkIOizsPI+\n", + "lJUunIf+PphY2SMoW+j2BoMrYy6+COcuAc9ord+RJK61bgDfyoh87F5YehDOXkDpXTLJNH3neZ6Z\n", + "Djhc2+Zma4fNnM9Ze57TL9TJ3LaKP69BaVQ9ZlNsnLFQ8EMyXoZursVqachU2OeWSyAWTFSEuU6E\n", + "nz1Ps1ugVVGIexBn7DFxNiVc6hDPjclhM21ZFAJFlgFNT+H1xmzNQyCwSUSGJovAEooeNldRFNOA\n", + "rOthh3mazFDTBUQNsSUiyeSxuku4g9MMspr9ocuum2EwkaMepVi6w8gb4a3AvmdhVcPGFgQuXPxW\n", + "jnE0LfJX2ybCO9WEH7wOD9y7V64fgf00zO/C137KNuCHBnOuqxMw/RDYEzC8AM3va61rMPMleCSF\n", + "/Xtti2IBGo/C7Ajowuv7wKlD+ALsnDUBOIvwwFcgmTIVQQAngul1E7itDI1fTD6A+lW4+QJcPgE/\n", + "DA03vjBpbrOlBBoa1hbgNgWhhkCZqpwvhvyaJqAci57rsX1QGErKN+cUYW4JrElSFAkOcByPc2i2\n", + "yRKS02MKEcx1QK/D0iqkAjszcOX+N4KR/BDS1+FKwbSCChqO/xBuu8qec3SbK2eHnHnkNLVWAtst\n", + "+FoAu1MiX04gbJkgf2USPn87nJo1luDsg0YCdzwDL2qtL2RFvvUn8NmjEDqQXIHsWXjHxONGVkbu\n", + "Bb699/t3MG2K64ORXwH+Df8RqD8C93HjKhdPAH8gQlZr/hztuj8cHIPa9Y9PwtYrcJuI/MnbyFG/\n", + "B2Tvh1s+Bw+uh/CtOmfu7HDh/jOcnxbi1zfh97XW62WRv3ESuX0SJ2oROha2V2S0HPHMoQQKcEcY\n", + "4rThQjlEeUBqcyIIGFpDzmVhVWDBgbyA9sBWRqXe8AYVY5WnRwEfYVcUA1Js1ScQi5D9NPSANSVU\n", + "tcWYMXWKhExRZQzRBWI7pmdrcvYkapxH9R1U2KdXyZJpBnjZC8S5VVxXozIlwtbtRI2vU3q4z74J\n", + "m8JKzIQNr39aRH5Pa/2WfhtvBxHxl+HXP2fMTBqYb2Z9Gz4rIpta67c020uNIpR6898T87/3fBPT\n", + "Wo9F5F9+C/76LCxFULzI5IkRizVQD0Hvs7D7sIj8Q3PzeWdMwv0noaaAMnGtQXA0Jhe5TC8G3NWD\n", + "0iBlYjyk1L3K8zfZzI888r6FF6RMhAlXsjkygyHjXpWtlSq262DpkMha4+VjdYZti7hoo1xNwbKZ\n", + "1i22cvO85M0hic+w2mVYuIiXahbdDBARekOKVsRELLwybzGrNMf2dpKP6VyeIgVcptF0VIqnXba8\n", + "ZZSsUIgsHBkRyiotNEfX8mxbObbnBnhTBwiyHvn1XYazFkXJYccxq9WIaN5MgtibsDo4wHjhVpgq\n", + "QrAJN5+CB7fgd58HrsB9e3Pz6S58O3gb35c/H+QehBOfg9saMNEznIhnbjLKqscXYf9VU63cmoNX\n", + "fgFusmE4gGPfgehpeOIYvPQ9CB8HjkPmi3DqAZhrQVqA4t7UViOCxgh29hkfKvUqfPZl6Duw/glY\n", + "/VVz/qsJ6AhkGoYzv+gZA72LtvGruTk1p0ZX4FRGkTDFscQj1QmRO6bl2JxVDh42DikxWXxyQJaY\n", + "LDFDBqRU26D7UK6bwEJpOHIFvrsE7hJMBiY3eb0Ljd8CdkH+GxD/WiBikPZC0v9jHf4VkFTgP70D\n", + "fvlMF/0AACAASURBVHE/DFZhvg63lmA8Y1qts1fh9XvgvAIOmJ7eMeDCUOsfiMjlVThpgd8yarwX\n", + "gP/r7VbuRgYjE7xRKu0AN137h4j8AvA45nr0HwNv5X4+PLGzn4DW9ER4GXgA4+b7lxpvvmNZkFrm\n", + "z9ZbPf/dYDgoi58RljyP8/ekOKOQ5dMhyy/36U3D+j/WWgcisjyD/5/bTA/PkMw1yC6OIavxhpp+\n", + "1pBZ51uwUYJyBBUXVhW0BTwb5lO46ICnoWbDjG8mFiIMGewyOSwgJqbJBD18Ino0ZZssGWJsInFY\n", + "JWSdSUIpE9MmR0TOzUK0TEKD1qhPktMkaOLMkJHv0NdCJg1wnJDSUHM4jSioBoPlx7nwn/gsdieZ\n", + "Xa+jBe5ah8U8fO0rIvKP9gTh9iYEuDZFlMVkv2tvyngPHoLM7HV9YB+Sm6C7BndhLjZ/Brvw4jnD\n", + "rm9e0yEYgHMB0G/TTnk7aK23ReQfb8ECzPxXcMurkByFgxHku3D+PnjxH4jI/7SnqPq2SKD4LN70\n", + "Jtl9CYmXpylD0lmHA9rIo7czEK1Bth4y82DI7DjA7ziMCppkasSMNWQjKdONllA6pm+BTZ403Yf2\n", + "A84uj0gSqGiL2simmVa5ksvhJIqRaxHNZInyfbJ2QsiABMhiUY6h6VoUEeb3liYmZYSRW/cAF4WX\n", + "htSVoi5FBnpERlrE7hRae8QyTaq32Vh0iVohYyfHenUadw2s/hUuTSQcdhTlWAgFnpuEq/8com8v\n", + "wJc/D7XJPQ7IfmjmYOFx+FhL66+LyOMYQmP3/ah03mgYPsiBR+GRNUNCBThWM15RjY+DaDP6f/Eu\n", + "iPbBdBGWRnB2Hi7fDkefgfsvwNqdEB6GpV+GpRzE89Bagdf1nrBhH64ehANdaA8BGxqfhq9PmcmY\n", + "43kopBD7cNkBncKlGdDaBCg9TEHhuDa7cV1ACyyJww4OKtGM7YQYh0AgZpOIHFkcAlxkr0aSkhKQ\n", + "pT8KiT2T+GSvO1+HAuMX4Ltfg8Is9LYhev2agJuI/DF87zfglpxx7N0pwCsR1L9fhE9k4NMTcLIC\n", + "zwdGRe3wL8H6edg3Z/p7rSfhpqch8SFsQjHCVP9FpApku6ZSsnPdGr3t+t3IQKCD2TtgBKiuLwv/\n", + "LYz416+80wZE5O9f9/BxrfXjH+Ln+0hwndjZ37yBb3ONN/KXPhjZgsLcdfyPVaj0jIvlByXHTXno\n", + "+2fphlnsUUxYbHJhpUn1tKY0gvUMEEDlc4osQ5xCl9xShQPjLP20wUZR8Czw8lAfQsMGP4bUEcS2\n", + "uZJxmZKYUZoyUNNcUFCiydNOwAwxI0DjskaWLAlbZNhimYgLuDSZYoBHEWGKiAl6QCBXsXCYIGJa\n", + "drG0zyhfpBUPsNbGbLs1UidH2xZsbVEadoimtnF0l0rOx0l9JB6R9UaUKpqJfoO+PWJpr5Uy24e5\n", + "JdicE5EyFL4CCzmf/v5pWlNzDFcT9OpV2NoTD7vWYvEyb7GDs2ZesPAOa3DuDDw1hnsOQByBnANZ\n", + "hT/WWrfe6QL1VtjzELFgScPgADzQe8Nt9+QmhIswfhT4/WuvMc7NTGF8VeoikrEoLwRM3w0lS1Px\n", + "23SLEZd8ze4uTNagdBG2y3D11ywWJj2qPU235DC2DIlQrIT+pCK0wSKLrSPyhCSe0PJyJDpmZpjw\n", + "4kSBdlhlkK/Qc2qM3G1COYToTfJqzAIhywywNOxamgsiVLBQQAFBoXCJiEh/HIy0GbImc2zpaXoy\n", + "RyoxKQ0S8YnTCjE5YuXSrIxRhWUuSp8RQ/ITLfRMiePNhMgKuVwU4s2Q5SehN4CdwTz4XUhWYSoD\n", + "4QGoH4Xac4b/93Wt9RDevgpr1kadgOm7jT5G62UIXvywApc98uSt4B0E2YXgnNZ606zvLG8EItew\n", + "vwGFBWhuwqkjMDEHpY4hq44VlGqQzsPuJBTaEN0Kxxw4qQ25N9iBnYNwqgivzBuX7SNNU1QrWOCV\n", + "YFZg9ZPQs2BxA6IpKI8gG8I5H9y9gzxJoalMQTCrIdUm7h9pKGuLoUoZJyldt0xNVQCNRcqQFl2q\n", + "QIeEBj5NFB0SMiyPFZO9lKwHL98OVg8SG2p9E4xEbWhe1Fr/BIdDa31VRH4bardDfg66z8Lw4gL8\n", + "9bshb8GkA/4afGUH4gOmh1UoQVCHXAHsEOaGMLUMOwMo+dAuicycMOTWdBdUVeRMA/7du13Db2Qw\n", + "8iTwXwL/FnOj/D+v+98R4KvAAqbN932t9bk3b0Br/fdv4Of7qHAEaGnNu5aNfwo8BvxvN3D7Hxm+\n", + "C6VbIV+Bfh0KL0Fag29+0O3l4dYSI7uANCyseERcTWDBon44prcOuf8gIk/CoYUBfm2X3Yds5h0Q\n", + "x6dAnhF9OklC3YJBYk70xgoUbEDHFFVMKBYX5BD9NIsaa2K3TESTVTZwSemTJWSClH30KBNzGmGL\n", + "GULKeOyyQIEcFjGKIm2WyfE6iiJTpHjSZQQMrCFjzyKtjcj451H5DEnBpZ/vMkoz2PExlMDp7JCx\n", + "XaAchQxUi4zVJRtrNvdBeR3Kgcn8K/8AZj4GM65Ql1nizi0cODWmXl1i+/IBqHwPvgz8i73duXkV\n", + "5A5DhvhxafcqTLTgqbdbg73g4WsvwQtnYX8K0RjO7XE3PihsiLNQtd8IRACs1CiE5o6IiLWnMXIX\n", + "rHwWZhwYKpGZNbAvJKxIj6KXZSlr4ziKxWhE0UtYzUFkwziEwX059jsRg8hnYhBjTViMMnlGWhFG\n", + "CTVtgZuhnEzh9yFJWuhMi8QTBrjUUp/1eBnLtRCrQqQWiTmP4hlEQpaxKDHARjMl5pL4qtLskjLA\n", + "Y0RMB8gh+AhdNLVUsS5lQjlAIDnQPonkCMhicYW+8kAP0NLHTifwIwerWEHGTeL8EM/xSRMHaRao\n", + "vLaJikyFaX0f7BQacPM2OFXMbfIJMwLyLO/BOM1U2Up/BU7eDceaxufm0hfgpdtE5F9orX8qoquI\n", + "LEDlf4DFm2EugXEEW+dF8v8WeB36f6YdaMbz0y5sfxWe+V/hTh8qEax6YA9hZQOGGehMw45jiL3V\n", + "HJT3kiJ/BIunYGseBjsmaCvsgPoYOAtwa2i0SfIedF04vQQ3KbALxt+qDVzcq8qUlKmeBgKbYqa/\n", + "+omR31dWQuClKMthXU3j4KPRxNgouqRcAVxstkgZU8XmcBqSZjRqFbJDUAuwWoW5i5CdhpXPmMmh\n", + "bl2k/By0v369Yu7eOfida4/zIo/cAYXbYP1VM2418zC0vweTUxCUIbNmyCbPPwnHJ2EiY6IrTsKT\n", + "E4Y5e8eX4esKE3I9B0d/BL/Iu/D+blgworV+UUQCEXkCU6p5TkT+d63139Va3w4gIn8TsN4qEPkZ\n", + "wv28w4X6Q8JTwDERylq/IYH+lxHn4Xd24K4MzA3g1R489+aI/v2gBDcfpfPCZS7fNGY20yF3WKGU\n", + "xeVsgt/VHPsinHUhcbpktM14wifGRsYxqfTxsXGDmLbWWD64FaEkmqtAS2LmRaiRZ1MK2DpGWZq+\n", + "bRNTxaLDiC534fEUJ+hRROMjlHBZp8wYYRqLBIsYjZAhYICDMCYliweAIp/u4EtIZ6pAcWOKud0m\n", + "u8E2nu1hyxTKm8fVFmOZwgZUcoEgzmKnDqsOZByX3O09LlTrzJxLaN4G97pQcWC563J6MsCer9Nr\n", + "TFLe3aFz6DZGj5+C/SIyqbVuaK23J0Se+S7cdwIaPkSXYfIlaAbw0jutw95o7drez1tCRDJ7z30v\n", + "VbBNqIdQetM1rFUAtQppCKQichBu/TJ8egMKe5yjM9Pw2H1gVRNmRz0GZYVKUspD2NczwlSbxwDb\n", + "olJW6NSjOxyxVbJR2QxiFUnSlJ30AEl3nYzXo6dKWJaHlWRBrxImwthaYCwJtjdmIvWZkIC6rpDK\n", + "UVL5IRk8JgnRCDFvtPSywJAYjUsdlxJj2pjWXBNIWKYgOXpUcIG+hMTkSCkgFFDsoPQYO1nEi1zs\n", + "cICXUyx2Ha4kI6KxR7EV0cu00XaPueeN6miifLhlGoq3QCO3R3bahtwP4BMt+EfvYV0WYN+d8KnL\n", + "prtay5ub7+ydsPsahuP2gWDaMDN/D44egYevGMPKkQuXlsD6JXj9HGyvwelpOL7XGogFXpqB+h9p\n", + "rbdE8v8P1D4PwdhUVbYXoeRC4MHaBFzcAbkMcutPzlYowB2BakISQXsOrCKsNCEpmsmZ2IJ8CgPP\n", + "FAB9TIvG0Yakugx09saAI4GzGqZT48YLsK5C2gS4UiEhj01EFyHARxEjXEWxnxLTKC6SRTHLkB4a\n", + "FUM/gtkBhB5sZOHkBuyvw8VpOPgyPHUPPN0C/oyflIgcrMIdRfiCZ85ne2xkZcWFdBbCDXBXTLSX\n", + "y8HVTZj1IYnh1BKcyRnyzdGxUQbOVIzVBnfA+lm4XUT+9J3W94byNd48zqu1/rtvevy7N/L9/4Lg\n", + "RpJXAdCasQg/Aj7BTzF18hcBe/3Fb7zrE9/r9iA4SLI14rz/Mo2/5pB3ynTVLBIpvIkrDD+5jVep\n", + "sObMMDqmcZNtav4Q144pBC65ep6IEWezsFO2KeYVRa3ppTG+MpmqTQaLCNsCx4KiNreXAuZ6PqKH\n", + "w1U0B4iJgRoRI1I8CkQ0sXEZEZKSYKEBjxifATExmgYJwpAF+pkpMgsBa0mDQabKIWyCJM9Q9em6\n", + "wsiOUGkOW9t43jpxdJJIK1I3otyfZ5izeeET2yxOe+gwJHKEvmuh8zbLgx1O7Z/C3oqwcgrIsPdh\n", + "9tCBf/8kXLkE9ynw2/D4wEywvNlI7H1hSuTXD8LRvd/P7cI33qlyYqzrvX8D9kk4M2ssAXo+tEaG\n", + "WNh60lRkZj4Gt3XeCEQAjuzAE4/A4GCRc4VJLMdB6zaXnSbTvZjyBqxuQb0oHAoq5GohmeMttnxN\n", + "XzloEpqyzBAXrYpY+gqJ7DDOWETeyNyYVBXiGbAttNWkbzVJUQh5EBdXazQBWkb4KKZJyGpDanSB\n", + "o2guEnGOiC1ismhcoIDCxccnJSAlwcbDQugyJCChjsUYS46RkYDU0SSBkNchth6inISGvcupxSEz\n", + "nZTCNlQ34Dt3wriSpXR/hkSfYriwSNr2IR6DHRmVrrdNGvd4RwuC+kVtkuhtmxeX57h4Yg5ICP1t\n", + "rN/MiAxGWj//wY4S+yhML8DBgQlEwFg1TWehWYGrR2HnD+B7vwbnl6GYwpaC7e9D9LyZSGUbun34\n", + "xHnTzrl4AU4fNlWS+tdh+Bhkb4XGAWjMwOLeMTi0YVtBqwHDPtQ+BZVpM6GuR9DOAyPoZ4zo2Y4N\n", + "pRj6tvEPrGgz4VLBVEQOa9gQw+sghi0POkpzqNvicr5Chz4pAQFLQI6EESAkxAwYU2CMJkbSGFeD\n", + "N4a4CEsvwvYUeC4c3TLzIb5jjPbu2IQLD+11In7MLcmJfPxW+OUqLNXh1jrkLpsPrnvgrxv2rtMH\n", + "6+tQycJuAcp9yAFnjsPzlnHqda0957/oOo6fbbRoBBOdvf3qfrCD4ud4H7gf+Ocfwftc4438pQ5G\n", + "3g0ikofSw8byAKD7HHSfeKuboYiI4Ay/SvGvjrGXNEl+ho4+Rj7UKDK4jRKxD+37DxF/XdO5RVNU\n", + "GUZRjQ27R9HN4rh92gls/8DlyIpHf0nYZ48oFmyqqcZWCSF9asQM8Uiw2JUGFj0ihuRQbFMBhmTY\n", + "ZIAP2CS4XGVEnwYRM/QpIkAfF80mMKaIjas7KK1Z14fpMoUkDtodou0sEZuspw7aOkCo84TKQbND\n", + "qtqAx4gctnKZ7IU0UWyOfZrhPsgEeJkSqdRoZyJyCrxUM8jEKCKCfI6w1gGvbjx7fkxY3buIvbz3\n", + "86HhU7Dv6F7V5Bys/AD+toj89h4/4fo1zWCu6P296ut/B4P/EeZmIN+AwRXYeBX6e8qwziSU3lRp\n", + "Wa1ANV9iwznATOowHwtWXKLnZLhQWCW/AZVNn3N4nK+OmViOqNgFDgaaZ61FOqpMgEVsp6Rln0jl\n", + "cfU62XQfYlVAlujgg6yi7DmcZBqlnqcnARNpA6XaBNJCE9ImpkJKB8iLoLRmKC45HDJUccgxZJ02\n", + "XebxyTJmpPqElPBoU2caB41HQsgIHxeHPOgeIxGs1MNXAYkecWlmiaHcQmbjLPWZbcaLPQqf0Zy5\n", + "HSSCz/6h4nv358n2xrQmt9nqVUjWM0aRy+Nt2jQiYpXgr+yDO13SqVUaxwf86MAUa85JSusWKg0Z\n", + "FJZg9zR8UUSufLAWnTdhqizXT38AeBFIFsTSWrdF5J/CzgKmxFQHulD8LMzeZ2hDaxPwh4/CymVI\n", + "NGxsQO2faD16fu/7nIUXt6G+DCu3GiHRTWD7ZeisGepT+BzsPAqXi5CbBhWC3YNhAuuYMeCBMgFM\n", + "RUPWgoGGIDXCaK6GldhwhIc1GMyYKp8egpUbETEg5RhCEU0IeAh5FDVgQEhAThvV6SgxxNhQwcYk\n", + "1DWUh+b+H7jGiTmdg5k1sH1MoHDN9K98ED5fgE8lJqpTu6YyVnahUYTWszDvA/fAiyHo12DfizAd\n", + "w3dvN74KKYAH4RCiDtiTeyO/AE3ItMzjdzTb+3kwcgMhQgEjOvFR+DY8xjuMTf0swJAQZ34D7qnC\n", + "iW2TtJ++H548URA5V4JjKQwb8FQIL0HuY5qbDzVxsj72pKKlMjRVB1QJ6cYkJRuiWWIX8GcYNQSR\n", + "PjqXo+6cwfH6eH4HvQbRUxade12KXkA9oylLSrjXn47oUaFGj0MM2KFAzBKaDHkcAobEtBkBNVwy\n", + "JBTR7KfLCE0Tj3N0KBOTY0wXTZ0BIZoe2xIxYpItNUEuHGG5PRylABcHRYtpfCCyCjhJjwQHnz4W\n", + "dfObilH5gFwohNUSUsqg8xZtVWJ/DHGww24mYCJosmXP0AuHDMse4YXHYH4b/vCaqq2I+BiVpsH7\n", + "1Sl5NxznDQPJY7DTgKUanGBPDmBPK+aTsP9hqCroKpHyGZgswb4L4O1Cw4OdPjT//RvchP5F2LwD\n", + "KiOoZ6FehKv7wGcOte6ytS9hnBeyCSRJhX5SZ2d2gtGXDpJccmjvdkj21Rl6PfxRhEQD+l6VhAJI\n", + "F1t5eIQkaoqOFJlKHSLJI+Sw01kUTex0HqFMYq0zsHcROmTI4gA1QkI0CbCBJtQwKy5dUurYZPFw\n", + "2U+D8+wQkUWYokWEyxrrhHRQuMRsoxgS61l8mvQEknQaiFHSYVstEKgZshtruI5mMZ0iHyeo3AB7\n", + "QTFIHF753JB8u80gV6FSH9ObmKVzZQzsmCGEt+S9KThxEu7+FFzuwnaL2qxHNDlDOqlgAxKV0vYW\n", + "iC4lkFk1FbAPYK432IBxG9YrhltzjR7S9WCjAb2xiBzCTIGtX3uVSP5huO1BONCCzUVYseDSArx+\n", + "CDJt6F+GyBERF7J/G1a+DJOekXw/lUDuNExdgf1j2Pg8rLxqpuriEM64cCIxx2RYgKEGdwid1Bgz\n", + "nggh75qpu+kUagJXUuOKQGgqMtYkVB2j2rw9DZPWkAYhHfpERGgiBLBYxOIFPEbkMdWhVy1wY6gc\n", + "APrw5EmwXoWugrUZ8x3yIeSPwtlboPvidedzxoUvhvDXIqjuM30e1TGzylKCyiqoKqRlaDowCMFb\n", + "gScEdn4I3/kRPDKEuVnoNCH/mpEMttagPAvdHcg/D+Ud+Nd7k3tvu7o/D0ZuLO4BXtImsL3ReAmY\n", + "FmFBazY+gvf7c4A6Biem4c6rb/zteN3j0peW2L1rDhoKxj3Ydxr2d5k8BkdDRaNoU9lSDGcUWS8h\n", + "SIY4ToYwP2QQ+ow7GvJl6HWIymO85AoFv08JwU8Vw4U8+m8UqZPDi7Y5k3WYFJsKMWOGdAk5QkCH\n", + "i/ToMYmQwSOz177pE1HFYagLaBmRUiCnQxIJGKczFBKfntPGw6VK4cfZcIcuc6mgFfhJgOfCvNK4\n", + "pAyIKBFxQXkM0x5K24RWQAmHMj5jYJ4RPbZpqBy27ZIqi/JEwDhToBO3uJwpsBhU6AVb7LoBV1WL\n", + "ZsslTi/BwTr8UQgvvSEat+8RmLJMIFB9DRp//ObKxYeFKQgKMP/GX7y74ZZH4eNXwU8MGfB7v2SU\n", + "Mr/wbX4slHd6Br77JX5Muu08Cc/d4XDhgRk61Um06tJe2sbyFSKK2VATBSmdjGbg2nScKdLyncio\n", + "BIdaJElKW9sMkhH9bEAxXMez8wytCG25KFqMdIhKFxESxjjoOMC2NJZy0cmYVA/JJl0iZ4OczqFl\n", + "hSp9AoRlXHK0SUnQmGz6KiFTZKkyQjNilzKKMoodUiwuk1BmFXAoIijGTKKYwWHIDuuhj8sKw+EZ\n", + "LHeMHjkMveNYY0HFdfwFoew6uFGRKE3IamHfEJ5fzlFQp2hPLdLFx+Zp1GCb9Oo6fAemf1VkaQ7G\n", + "G1B/Qmu9CjANdx/bIzFOwPhOtp/5Ef1ftvG8AXrBod+bpntqChrbsKCua/u9T1yErVMgVXhqCpbG\n", + "0CvAqRw0evDQp02CcjUUsf5A6+ScOXYXH4KShtWPmwms7SNwrAqDCE5ehv40PPu/wNpjcPDLcJsL\n", + "VtnwSJrAxWPgXYKZOrQ/AxeOw4Rt+Ju2BZsKrmpj1mkFkOmYSs0gZ2wGaokpCsSW8bKxBbZSo7y6\n", + "oMEpmsDqfKzAdZiVEUMCOgiGsFrCRhCGJLiMGLMCbAnkemaEOGhCqQn7ijBagfMjCGbg5hbMnTPn\n", + "SUdgIiMii8DONPzGMtzrG0vfcAjuGjhzkK4Zx754T6XNTaBwEUpleOmA0cKfLoB9Ef5JA+7JwkoA\n", + "rzXNoIrzTfi4C4sR1GrwR2+nQXQ9fh6M3Fg8CPzgo3gjrUlEeBx4hOtGGn+2UF6B+Z8ouSuuHsnh\n", + "LWZw8/sIsz2whhBVIN8lM4QoJxQSF783Yio/pGFlCVTMyBrQzboEF7bRYQWidTKLQik5TVzsUMmE\n", + "zCQOlaFHlIb4s0XO79TZXvYpKdPr7TBFTIYCp3mFhJg+VWAZizIhARFdLYSUsaWITY5YT6O1SyQ9\n", + "XC1mvE9NkUUokKWKpsiYXXLUGLKrFIvpgKYKsdUbVuEuIQFDCoxIyOCkTUaWIktEaihtuARMskOf\n", + "Bfq4lLtd2pld/PQofqfJqt+lZgmWlWOYTjC6+Ovo37aACNSfwm3Pw4bGGcFNn4dPXjV99hR44Tg8\n", + "qYD/+0asdAv8wU9k4tVPwN3bJhAB05efy5rBnmbGVD4Ajtbg5f0iUtJad7TWu5bID49i3zlnOg3W\n", + "EuPTeTJ3N8iWi0x1bbxmSuzHrE+O6FgJKtomm3QJfZfQA8edJY1iQhUxznaIaZCKxtWKFJ8cN6F0\n", + "i45ShHpMRQb0xMLRHQIJ0HSI7E1KpKzIPNvYTDIiwKWEh0fEmC6RhkQETRHIkENhkWDTokdMgM3k\n", + "3pTNZSaxEMp0KTBiCpuBdlgeDwhUkWY9T7QOUdKl+zvT8Is+8W1D9ExC1fLJBimpK6AUBBovTVET\n", + "HrbqcSD7Gl43w2uZhIliQCsPU4/CfbvGFK62CM/9FyLW72qdnBNwr7ePPw47Y/rf2qb/hUl4fdmY\n", + "BY1S4BI4w/epLXMNWutYRH4Pxquw9Rl4eQaCy5DLwq+8CuW9algzA9/4NRH5LaAPVg4aJ+Fw1uj1\n", + "+XNwMIZtD3aqcMdFM9rb/jsw7UDXgZEHOQsOJKCroG+FM4dgMAlHxpBzDEViWsMhDc8JHBwaLZHv\n", + "zIMXGw2RjmXGbI8lIMrwRhIFT3kwKYZTtqQho102XZebRUgRCnSBDBofB4XgAC0UBYRdHIzD8CiG\n", + "ox2461VwI3NubszB1RKkz8DVAC7nwWvAwXNG/6h+k6JbOQHztrEl1gFYTbAdw9LVWWNiRAgIbFpg\n", + "rcAT1T2J9y7YI2hrrevAn7zFcl15v+v782DkxuJh4B9+hO93jTfyMxqMDFtmdO4NeNRvrTCWw8SN\n", + "ZegCVCHbhgPQWYVBKaGQpCSOx/TuFjt2SitbReKUUX8LGV/G3qihF2cplALGOYc0ux9JQ9ppjdbE\n", + "iEMDiwPuJer7C8xYM/gaRCI8etToM8aiQJ8xDkXYK69buIzxxcFiRJ8hETVyUkFJkYQRCSmx0ojk\n", + "UGgsQDOgRwsLzQEsPBIyohHp0CLHiBSHgIQaMQNm9TZbMktMHqGIT48AIUsGTR+HAQXGjGKbbGgT\n", + "BPvxIps0nSIfHaE+PA0TFWNUcSUx4kb6PM7NWfzDebKHezgueB14ch7SDGRqcPAizBy/Nmnz067s\n", + "JZg8sKfqehkqr5lxh9fgmm7FviJUrquIpXv30XwKfe+NYESx5zjqXHvmDBy7k/i5EfHNOUO6K/Vw\n", + "vDrK2aLmT1K0NGGuQTdtU3QyzLgBrrVDaCe05BA9XcQFhjpPX8ZETJHIPpwUFCGxSsnIRYQcnmTx\n", + "aNLVQ0JrG2UliLUGaYP9aYVVlSNmTA9FHrUnhOej6KJwcYhwETK4FFAoIiw6OHtHUMaENGgcyiSU\n", + "ydLF5jwDVoi44iXYaUwcnYb+EP4ZyKtNso+eJdx3gHyoGSmNqJBYArzUxR8PWS0KytZYGRtXByT+\n", + "gCO7UBDYPQzOGWNsDXCgAdkxtD8vIud9ePkSfGH2OlfXQ7D9LFxVMMqZHlrmLJQumRHh69bx/WGv\n", + "EvdN4Jum6pF/BO596I1ABMyxcExg/bjWox+JVIYwswDrk0ZDMSemOFN1YGM/hOuQi8GdhEJkEvqu\n", + "ZYZBGgI5Bb0S5BagWYA4BxOR6Vxoy/A1ysDTM4YfksO0cKy+IZUeSKE4NHI8oQ1Vz1RwDmLGiFsC\n", + "dZ1nLEMG5EjJUCdGs44wS4yDzQioo3CwCAiA/sBwi5caRqL+2vG/sAWZGcMDKl8Fz1ZkSMk4hrNi\n", + "ewV4wILbIzNOF27CRBV0ybBxaZnIiSkYvwRT+2F1/14gsg6lMxDEcPaDruNb4efByA2CCC6mTfMB\n", + "eqMfGI8B/70IovXPoufP6BS8/BVwZqDQh1LNYjCRYTtaIv0xOWraUN+PlqhHmtcX+xye6VFyPfQ4\n", + "xWGHylaNnarGt4XZWYdJf5edlSZFOUzNqpLRwqT4JK5PqK+ylg04SELeUXhaUBSxdUAiNUpoMtKG\n", + "SwAAIABJREFUmqREaFZIKAGX6LNJhgXGKCCgT40Rlgg2FjC1l/MOiCXGZpOYDCAMqJMScYgURYRG\n", + "YYnDLD3GXCGiQA8Ln0kmKDCUDVIdk+gSwjpDYjxciliEe14WDR1wshHzsdeEs1PC07fYpL0xycw5\n", + "3GkojiIiHAonnma3NEl8qsPcvgz5hgMCaRX8g0bMaWoTdpbh1UXwzmPSv586GPlTaJaNmaS0YL0G\n", + "X71mjmh6zXObsF4yUzNg+uRJE+pzcPI68nItD40O15l0WVDows37zSxmYwD+NjIo42ZPU2nUSRON\n", + "thTiT3EAD5GU1J4ko7pk2WRVIPV2sbVHUSIcrhIQ0JeD+NohpkNHDXH1NqLKtHRKhS4WYyZI8SRi\n", + "zZ5nnQJClgSPLruEaKoIiogYi0ggROPSp0RMl5QWYyxCSmgExWWqhP8/e3caY0t63of991ad/Zze\n", + "l7tvs3JmuIyGQ4qiRJqmaNqOZdmxkQSJAyNCYhsxDCUfEiTwh0RBPgRBYlgO4h3whsRW4gRW7DiS\n", + "aS2kFlIkh8sMh5w7c/e9b+999qWq3nyoc8Wr0XCROAtl6AEafft0n6q6XdVVz/t//ouqdSNTXHcC\n", + "mzJXXdFVjS2N/LZ4L+PPlb+BJ/5iZnn6DZdn94wXZ7LqyNV6tBqbjo0Tk8Wm64H7aaHdyVQKfuAm\n", + "jdD00nM1h9OMzsDJezw+JzMf77N4hrud8Tw+PuPcOY7G1F6hfcBP32P/Cs9G8m3+OS7OZd7fc5Vq\n", + "qfUFWm+Q1N3KqM2N+A52ufdUSX5tRO42SknwMyMqHa69j2/UWU3Kj0qVlYTNwNcTDlPiu2gXZBW6\n", + "kfv10o11W0mKHeMCmqE0H28lfGm5DMBrVThsMwhlGvCxOJcKh2A9lg3Jl0PVWHBRzZIzBno6pUez\n", + "XKEiqmqquaRAb8KHv8IX30e/W+KlUdls3Wovu7V8XHy64eAH+mI6sraXOba/71ZasZ/X+VMt1tYY\n", + "fp3iaaaNchyTB/Id0ozRLo9ss7dLvMkTCaP7HNzlH36vCrrX1+83I29dPYfLMXpTiX7foV5TXpWP\n", + "+zYyvN+LVa6OVz5Bq8rVR1io001z18JZ3e3GQzDxDicy2j8m/7XPuPuJscmpaKEyLZcwo57hiURn\n", + "0vahvUQUbS8lkk5bvZqqGxqEch67GBvaYUk3HTnMghiTUoKbdCQyRUw0w1iUe1RiXWJVYVXmK3q+\n", + "oGnmuD3nsK9pqu/Ioq8bW5GpmbplYmzJI2oGxkaOq9k0NZsjI32FJbkVy7pOSGXGxqbqqta18sw4\n", + "FCrFgWpStSpRUZPHUkY4GtTIMvdPRtX+jvf/X1233ldx8/Syc7f6OpOqUf209cORyqn7tlrLli/e\n", + "N1jq2bhL/z08NSRbKg0Zzx9hiU+d9bpkzt9tbcX4t+fSy/DG5NjtT/G5nyjFaaePSij++iG3Mi5v\n", + "lOODgxYvVtn6Rw9LF4/YHpc5K7f2WdznTDRoDdQrDbXm0PplLm+sSCupJNTlsUc4RFXVgVrct2/m\n", + "dBKtyWUCcdsgDtwKpySidixZH43irnqSOaFcJY8CRag7oeG6dRuGdi3rW9O1I4jW9NTV9EV3JTYU\n", + "Cl23NdUkEtGGuuNSd7RkclOJkQtyLW2ZVBTCLYdxZGWwKD2xbzZi8c9S+xDJsZkTC9s6aaKRc5Rw\n", + "FKO79WWhWDLsHTMYH0rrmceGM+P6cderm6qxolJPjdItn/2RG6afi57ZKh/E4wLTeWbQ3/sVnlkr\n", + "mZnDvdJb6kH20UtvxjXy+pqH4l3m9gfKW97DdbtO93oI4Rwn/1LZKGxiWC3Jr/uBFxOyjO4KaYfj\n", + "Wdlk5JFmQhLKhIT7Rfkc3qmUlvJpUjYgmRIM+kZ5lekohSoV5CmtUN6OFyP1pOSt3KmUVIyKiiKk\n", + "+iFXk2kpHFi2L3HPWE2NOQ4atUwdKVwX7GtE4jaVHTYu8XKNyslUdTnRa3V8buNxo8OOvJ6otk9r\n", + "H92yvXxfb7Lu1sk6Ty6X/JB0kUGFeI3ZKeTlYuCwS+8Yqx3CY2R9lr7B4f2Si3XxrQhG/P1m5K2r\n", + "j/oeDH5+NxWjGMJvjmr+jWpGSvLqU8/xia9SvMjtZWZpdPP9EwaXyj8cOeEmx2u8Ug49VqpPye53\n", + "HNhTWRzLu0ca50ZOazg/gMxGLfqNauFWvW6cnJDExFEYGCZbKgrNrHBHSuypJX1ThUyVMNY1siBY\n", + "w0iQzYctx9Td9C4zZ4z1NPTkms5raYjaBqI9WzJ3TVRc0hdMZIKpsVyQGKpqChKFAwvGJhr2FYYO\n", + "1azEtiTfVdTWHNOU27etL2JkIstqGnf4SjWxt1h4/NdpDCYOT04cvz3ww99gfVTx0vHbrh5b1c5m\n", + "qpsT/XsXJUszjSUWGuy0SzfNpRoKsjrFXoyx963P2e+sHrKdf4Pv5ZdDSP8+e5+kfrZUEO79IyZX\n", + "+IXn6Zxl9CqHL7w+k6bHV67xZxY5Fji5QrZndlTTjw03V6a8t1Cv1GU6akVNlrRlcUcRtgVjwrK2\n", + "TQ1dibE1I9Gyjol9C3ZjZjqH2Ssh+qDgSVE1lNLNL6sZ65vquS9VcV9fzUR0YNeaXEdNZkXXlqGq\n", + "e85JLVhXONR1YFtb6owjh1bmNOkaciMjhanMmpEDtdFYp8b4vw/qf5rjMYqd0rr8QkzsSiwWmaHc\n", + "nZC4OmqZjI6064eag7rVybLLy6esHaWyIhpW2uLoCc3ukZfffeDJLb58isPfeKBamn/+8vzjLa0Q\n", + "wnHWP86Zp8jHfLVG7TxP3S/Hdxc3eO0KLrPyv/Jcmyf2CJ0yA+bavKG4VOdUSnNE6LNaKc1FbzbL\n", + "tU0pyC8FZJ3A7cjjBbWE66FsbnIlPeK0cjwzUSIUaSgTEpqhNDgbKsdDq7gW6IjIHSpB7K9ZFj2B\n", + "RGHZ2C0l3jKVGAq2cGRplFk85Pz/zlPXOXwPLz7a9OKppmrM9bJT9pw0bS+S1ez1tx0trpL1ZI+e\n", + "L31C4vGyk8xf4fSIQZP8LlmHgxNcjLz/dOncNtjgdpUs4Ykh7+vG+I234rz+fjPy1tVH8Q/egf3+\n", + "In7cWxTM987V+g/wxFEJbyaR8wcw9t5rL/lM5T3cm5RD2uoVmj/Crw2pJ2Zr57THLZVsSSyumeXR\n", + "6QmxPnO0Fg07iXFa0ay1XE/P6sRFzTgzji1FSA19WU/Ncr+hs9A1SjJFUThKyPT18YzEIhKJ37Bm\n", + "bMHM0KFlmQoyExNLNi0qTEQVQVOq6kBX05NGamauYqZtpq5mgEKh6simREvdnrqBk6KqsVD03asP\n", + "LMf7+pbVnHDMWHTXTsxUxuecujjw6urM1z41ce8W4zbdV/jEKTZGJDHz7L0rVoZbXryQyOtjq8OZ\n", + "RxssDLi5Vn6+u8b+k7QuU7yCK2/nFRBjfhmXH9i8P/StT32r95RoS3VxX777ouLEGnoli/HmmkHt\n", + "X+s/0ZZXZ7ZWGob51CBUdeJENFSVqWhaioW1cEchEdW0IewoQrQah/o2TMKmatjRVMwbwURfYqBl\n", + "XdW2czKJvtocR9sT9aRSi+55UtS356pUw3FdyxaEuRV4XSbqO3JMX8OCmVRXoSEX9BXqquWa3O5a\n", + "Rzp9t9q/M1Kv7NuNPZsxs4zdNLMQK/qxqR+DNAbV0WmT1wYqGy2t9j0XV+uOWkSJwV5N7/ai2dWh\n", + "bLMpdA7808fZ+SqHb3sWVhnAduHP80M5j96mX+NLS3x+Uo5URPb/P8YvYJON0xyflP580xQpp2OJ\n", + "jCQFa1c5d5W997PVprlYoh67ygZiG4uBVwNFUQq81rIyAO+BGr2uREaWlM1IXdn07CnV6cfMk3nn\n", + "2ztSIjlrcjMVv+G4Xc8p255dJcbyXqWufRk9LQOVYqoyqdkbj6weZ/8+V+OSrWzRXjpTTaZymyaz\n", + "J7l3yKlj9NZl01c43aT+FJN9woTqSaZNRp9ncsDkJAc14j7HU5pd+qulhrkfcI7xy6Uo45+8Fef2\n", + "95uRt6BCkCpTdP/jd2D3v4i/OndPetOhtHeuAsRSHpfmDzQltMfb/NyvlUyx0wN2q7xYlCvgQTCs\n", + "NSz2Y8nmEiUToopppbBz7Jgkr0pDrkg25fqyUDFLa9JYGIsKuVpaVW1PVaWuOGkWVsvVj662266Z\n", + "OS9125m5eVnFSE20KDURnBJcUjGRqwpmc+vvgUJuWdW6qaFUVcO6iZtyi3OCY0/NPSetuW5H1XEL\n", + "KoaqoiLkTqo4sm2pOFCkiYmpdux6XFUvO9A9PXFiMrH18qbtE+c53aDxeZc2MqdC7vSlkgB35mjg\n", + "Uo/JP2TwR1PXl2r2n4qypcz1kFm/VlqPnPgsL6yz+7YoxV5fr2tEflvNE0OPYYXzn+CZZM/uQc3X\n", + "fuA9xuPzijtD6lcoWpavVqSnhvK1ZQ19N8KRNQONUNrP9WxaKnqSpO94SGxpmmppyVTiWCOMLBjI\n", + "3NSIQSfUDM3sqqprSyQaMn2n5kTVLVEFuyrGFqRSDVeMJHjKum3rcmSiBYVDi2bGEtvuWlC3M0dD\n", + "Ts1twpva6mpumyULxrVVORZHazrDpu7Cq3qV0gujHRI3berG4xbzaJJMhfZt1k4Y3D5y9L6gmo1N\n", + "ZsFwSF6smXzt3bIX7ttbfpkz7P61h308vsU5eJT156l2OHiF8VffHBn40g/x/sATc+7K0oSPXWbv\n", + "LF//xzHG31RghRBaLN6j/zjHMmr3ywYjdjhIcIWzN0rEL01J5w1Goyibif3AoChBgXNKa/ndyG7F\n", + "3A23REFmypHNnnJM01GapE2VwX3t+c8FD7AO7sjtYN8Zr2nPL9iOcst3fTN58r7CvoEa8RHjYsFC\n", + "se/ij17x4kc6jl5raT/R0G5nivaBfn0X92hG8kkpP1vMSOvkoxIemkTCDu0luqEMxrn2QtnZXRnx\n", + "rpPs/0FeXJ43Iub/g/jbg9XftPr9ZuStqXfj/lscjveGFaM7IdjBs94GyPTtqHI2nE556ZMMRiQD\n", + "ll4pvXSuwMVxqej4/PznX/08f+GDNGtGW9sOTjQsToP6nQWjStdOyHSyJcM00az0ddPEraQqSE3t\n", + "qsZUkeTaJjrIw1Clkbgaz2pYE2JNPeQqFjQFO674VS0sWJKYSEyk6g4VVkwtqlsxsGWigcSRgQN9\n", + "XYtGgq8o1C2qiw5UrGjaVjERTKwLjmQOzQRbotn8NriSBEsSC4F2OpJqipoqIbcXonHrUH4hc/xn\n", + "Gzz+gyy9f65mGLjdfsWv/aGRR9vR4j2u1bj8OfKfrrn2Y22bZ9sezWrq+zOz2p7+yaEX23z5NXZ/\n", + "juztMPP7rqvkFS39GE9/gJOR7Q9T63HuM7kP3L5vVr3m0g+N9Ncr4tZUc2lq+OTAbKmmbl01X1XE\n", + "HTth26jStiBIZWbJgtXi0FFa/nZH8ySZe8oQtCVDi6p6YWpP1argvjgnHUY9GwaGCuQK0ackZlYE\n", + "G9iU2pHoizZkuoKJ1CFyQWosmJko7IpCaYdnUapiUaFQuG/gQPS4epEbp1uS9shROlGTOpnMbOKY\n", + "tpshmiZkoW0yWtAqegaLl9RrA0tp32qaWc8O3F9eMmj1xDM7XL1YJsf9y+/ciLQ+zoU/09ZqZprD\n", + "iQvv4doHQwh/93snPXYe49Tr8rcSpV/H19f9VmO2XQ73GF4qreI3xiXP4mqNnQlnvsArz3DsqLxO\n", + "zi4ilhyQqTJpd3P+8L2h5IecSHgqlA3GlvL+kysxjW8wz9UtJbZrSjfW48o2Yzw/vJlVV1SkMlNN\n", + "ifH83VEpA0vn/95VRpgvyYun6a4Ydo+MqgvCTldybtux56ZO15tCI1NUc5Nw143Q0K8ulEfYqJTp\n", + "ucWU6hGjDkWj3HZ6l409QoN7p3jhJpd2+Qdr/NRIqRFS/jaSiyzt8cvf2/n71vX7zchbUx/Fr76D\n", + "+3/AG/k3ohmh9SGe+GAwHNV97VSmlmaKZ+i+zM5ff720NMa4FUL4W4d8JJEtTu199LTBbEFlVjca\n", + "jxzOhk6kqVDpykLqMHnccBYklQ1ZGOqFbSvqVvX11LWLulZyqBU6siKRmppqObJgQUNi7MBERTIf\n", + "ytS0VC0Y2nPfTE8u6jl0INOUqliw54KBhqpgaM/Aoba6ZVOXZAYqplr6Kjp2TCw4L0g07OsYmblr\n", + "V9+eXGrdipa6VJSp2VLVSO6YNDI3rXA6pfcip0+x/8flX3zElZufcuPDRxq/Tv/TSvXXWkdotT2+\n", + "07TRQ5kpq7lw214rd/Ufxxjf0rwlyib0u1FehBBWcZLKU7z7eT5+lcOl0pOmEXnpA3z80zMffumG\n", + "o/UgO71ieVS33M3txr779bp68nU951SKqiJ5WiwqqiGoFMEk7LoblsXYNwsTfUEjNoxVnMfQcbnE\n", + "kvu29dy2anku+I6C2x4ztIod0V1RS8OGiolDu0Z6jiGTCHrW3XfVewWM9I1NcCjTct7MmoE7EgM7\n", + "TtiVK3TVlEyEQ73kyAmFs6EQjBSxdC6JRXAz6SgES7perTQlWS4epIrptvb62LvuRM0FlkbXXeos\n", + "e21thx9+iZMHklfHJr8UQki+FYExhHCsY+m/eFQMK7JR5rB9W37ypuPtwtEH8Onv7aqY7rJ9gX6V\n", + "vMrCAasHpcOp34K8xBiPQlj6lVLCm43YfhfDBle/yr2/RW9IzDn/LJtL3KmXzqXtWDYia0o+SGoe\n", + "XjgnpB6hmGfNVJVNxnVl9MqDrOO2b5JZryuRk1RQWJU4qy5xBld0TX4zAOqcsgnp4xVlm7WgZJo0\n", + "tRol2WWavWhxfWQlnTkVouU06qXrurGpYddmGJQJ4vEeSaaoIauWbN0kIz2gXicMyJ/map37B1TP\n", + "sfLLnNnll3+DjxxjrUG8Q+smL+Vv7CnyptTvNyNvTX0E/+Id3P8v4s/jf3oHj+FNqRBClVN/ZNHk\n", + "7FnDWuGwuWCyGuTVHXl7X/xGCOHLr19xxRjvhxA+u0FnKjauGZ0tyI5srrG5TfdE5lijInXc4mTg\n", + "KG3amr1mXG+KcWDmtu14pB5qOkmug3Uzl5NVE0HDxjziYaTQsaSqMNXVUpUj0dRQc1fbvtSBTFVf\n", + "sI6B42raOnJ95Dakxo5M0XRgVUVFtCu1b2jJWaUh2X01LamqmtKhsWpH5lDLqkxhYCzR1ifNzZrc\n", + "e7Ze5pb3qhQvERZ5+XmuvCJ74Uj/bz5o6kIIKzXVfkXejqa1oDalSEv7rfZh/rqb/pt8vkON59b5\n", + "g2dZPhHCrS3+dYzxtxllhTKo6Eef5GNniS9pf6inMR463Ke/GAyPJdqzXIJrmzy6veNDX+j5l48t\n", + "asSJ3nrXsXFFu8gspDsyB66kp43ieWkxME7bFo9Sabpo2r5nV9CvNKypSAw1QkVmRW5x7o7ZNrVg\n", + "z749FYnEyNMmHlE1EG2Jqkp2QWEgkdrEgX1RQzFfSQ/mg5sVhZGxXR2Ftp4chVRdxTFVK2amciuG\n", + "7hnblmmFluNmqnNp+HLItWNwlESjgjRrSiJpUjdsdQxaXaYVrSI1Xs88uUW9mJo1tq2MuT1h7Q5P\n", + "fYZf/xhfPjRHIV9fNT75mNrCOcvXH7y2KE/H9s9sWXje99yM7NzlpT/PB/u0cw4TLh5y4wt+04X3\n", + "4er+Ai8/x7H3lfZDswqanPtY6Vm0scb4iK83aaTldGMZ5yP3lHyRFSX6sakcxVxHJ7IUeDLyUiiR\n", + "j0U8pRyyvKgc3ywqFetT5Oq+ZllVooaJsYlN5Tw9KHGTknFUfj1ThrpsSMJYXjsS0tuqaccpuSxJ\n", + "NcOGVGpJbhpaxpY0JNLQEIuzVA5UZ7tC/l71m3uGJ67LFxZKo7PkFIcXiBNO3Cs94y+u8Mw1/lrO\n", + "xR0+GqmMeeGwRMXeVDnvw/WWNiMhhL+K9+PLDyf4luFW/qhSN/XfxRjftJTWd7pCEJTIyH/5Dh7G\n", + "p/EPQlB7m6zo39QqV7oLz7NwgcVhavbUk6at3KRz2qx9SjJNpKM7xgtd8d/6UrmA+KnXbWPjEf7c\n", + "DzO9wNdGXPw/tT6565n79LOaU+tNxbhmXK0pQrAeuyZp0052WVqJahY0Q1ti6tCqhih1pHBeEE1F\n", + "DZmuPVQ09KTu4rj2PLZs36GZqQtuu2vFSMVJdcdMXNZUV1gSJbiratGCzC23PG1q3UzfoqpNO7p6\n", + "ZmYyS84aaeqbCIZWbTuncGCq477LFvRdMNPW0hY0cel90aXu2LSfMTvL0U1WvkSxXw7KH5bodpns\n", + "JSZZotcpxE4o42S3CqMBb51cvcMfeDd/+Hnur3PzKmuf4y+3Q/jsjJdmvPLQDfFdT/GJT3K9SnFN\n", + "9b3LarObLv6hupBFsZ3qTKdCK3ftR0Y2/xU7a2PrXx37dz/DZz7Bs73cxVM1K7FhscgtZnVfrE6J\n", + "Fbt5YlpkOmlF0Qv2q+dM6i1HlaGaYDV2tELpDxP1dGVyE6clOpjo2XXTRCHXUz5Y3oeWVCLRk7th\n", + "aBEHqkrY/8iSuqjiokOZ0yrWRBW5A7mxpmNzgfctE6cEq/O8565UQ1tNxUw0MpaLlkPdTEeYTQ0q\n", + "iWlcdpRsiHFBOtoltiT1pqEdd5ejzoRhp1SXLG+zUBArPH+P6x8LIXzhjVCrJZ5YkfyWZrUqzTfF\n", + "dMuk/b1cG2VI4rkf5tTnee0JlkrzWLdX2H7hjdGa6rM83+aj/5TL76dzuny2/uIP0lghbNCs8miV\n", + "1UAvlD3NFaVt+9NKVCSJpQFayfZhObIe2Q5lo/HM/PUrSozjgtIT7GvK5mYDh4KxsURuX91YMHUk\n", + "ehRPKFueoXK4U0VXsCjYUgiy0BCrQ4uhoWpspm6sqSUXjNX15tGLdcJdRboqxLrmkCK9pNKoafcO\n", + "dWstilP0n2C3WfY+OuUqbTMpD2N0EOPPhhD+hVJun30v5+67qbesGQkhPId2jPGjIYS/EUJ4Psb4\n", + "wvzbfyXG+D+GENr4V97EyPjvg3oSkxjfqEt/eypG+yF4DR/yNsuLv9cqZXvn/xw/kHKsy+7JxOef\n", + "K0yvBoPNk2JoqkyJFpidYPcGPxpC+NsxxnsPtrPEh57Do3NDriazVDtdVl3YkxRTa92Bfn2o3wyK\n", + "tEa+q1GZSZzVsWRJpQyjcqTrjrtaEkNctOCkmUxiB9FMak/0tKFV11Sldsy0jG1JVaypqom66nJ1\n", + "NFX15MZzYlihYiiRWNTQ0HRgLDo1f/9UX0/iOTUzVTU1LV0TI4c20VXTc0pVx7Ig2MN2yDUFx5Ou\n", + "7tKuW0ub5Nc4gf6XaN7lJx5+sMQYt5ZD+DWu/6llT99t64ymstqWrZMzO7/ke3DQ/A7nvnmBj/0B\n", + "bjVLb4PWmOeeY2WBzXUuvMIfCiH8vRjj/WN88BkOqvPU0HWDrR39Ex3x9Jr2lULl1R33Hk3sxCUL\n", + "tS2/9CO5O19gYVq6tlabtEaFpe5UczWVJYlGMhCStkZMNZIl0/pMv3IkKzbEbCYpMoXUyMQgjCVW\n", + "5mdw11DTKQuW5yqpoUzLfQUOdZQw/En0TAVNqypGcjvGqvpmTgqioUwuiFYtiaq6epI5yH9HZklF\n", + "V/CIjk2ZibFVTY+J7ulqioKJisyujqqOwopZZWqS9d2qMsxzndFlQkdtq6G/OdBvrrl2MtEZDk1a\n", + "fd0hJw+5W2+5+lQhhLHZMU785RBOR46+SP+zDxrECjv0stxaPVWbu6JGM4MWR1/5Hi+R8zxS48Ov\n", + "MbrK/YXSdv3RQPcpbxi9sf5Bntpl0CKe5sQ+L5/g9GppB79UL13RH4nlM7goSlfVS7HkodTn/M08\n", + "zI3KlM/uPCWNZSjwksQ26grLSmzjtJLtcTg/6wXOqTgtt2/gNRWpnr4Vc/2NcrCzPN/DFoaqGjLH\n", + "hLAmDzWsyA1FUw1s21dX0dKTmGmIDgw9Zmw7zBw4ob80U89WLU8yMUsNw5osaVEMWR8xXWQ7ozjk\n", + "bI9fijGO+M5k8Tezvm0zEkJ4Cn9C6RJD2bD98xjjK9/Ftn/QNyV3v6B0K3qBMmNg/nrLW7jKeofq\n", + "4/ild/ogfJM38nuqGWHjk/xwweNzItrxfmJn667XHj0jq9clGVEuq6WKYY1Zp/zBMjmqjIU8sy75\n", + "RFDkPY4aTG5LzuXimaphlfwg17mcOVw6rj1s6NWCmKXGnZoQNjRVTBX6ppo6Gqp2dYgDKyFadckN\n", + "K6aaqmpatmSCRC4xtaiE0msqToq61gytK+zZVTgptWDfoWVDTVOpwpGZAwtaggRBQ26gpTBV/q8L\n", + "HSO76mbzx1VVV81tmX1tiyqCIxesCDomEmu64bY7YSg4UM9OmRSPEa9SrXO4Uv7uvvrwWTji72bu\n", + "ZUODP05ncyqfTQx+lv7ferMcNN+gVtdJmuWA3V3efZzaKvdusvpBbh9n9V/xJ/G3Uzot30T+njV6\n", + "9edcPJ862YhqITErOm5uL7u5tSDtjo3CHj/N7E/wyrPlW0dVFg9nqtVMMotCZaay0FaNTZUwEpNM\n", + "Vukq0uNqs32KiWS6Z6WWWjQ2dl/bnomxms7cR/fIREe0oGFgxWMO3VPe8CaomMyB+6ZErmuEVFOC\n", + "RQM9E1sesW5BWzGPRgwObWmK7ipUVDUEE9FYYqqlpq8himpWpEYKIxXXNAwlJE392rLRbFctP1Sb\n", + "prLRSC3NDTRcKthMMktabtgwrudefa6iGHQs1Gqq69tm9S2P3Zn68Ctc/AhffGJOTp1u8/Ki4R9s\n", + "u3QhWMwWtbtRL+zr3iB+Swn2d1npNx9ZzeyBvL903U1qb/yWpEYlL13pm7FsKrobnBlxbYNToXRE\n", + "beSMKmXzsRHnqpmkPFtt80tSCSAeKduHG4EjiYa6NYUlM4Voee4dMpVKVGybWMeKoX31ucC7qqci\n", + "WlYiZg/vaeYBEze3IGiq2JJKTUQDia4NSxqqsedG2BKkhqoqFnTkqlI1uXG4bpRumBV9exs9kk0x\n", + "PyQ5SW9AJ6VxhRMj9m5T2X6HwIFv2YzMRyn/Pn7GN+eDZ/BPQgj/R4zxf/gO2172zUCkIyWO9fD2\n", + "/wb+bfyHv4vj/n6uj+Nn3+mDUDYj/w3+23f6QH5n1X6cR289/MrU+V+buPbjPdPmkaQxXMXCAAAg\n", + "AElEQVS5JE4T+SBjOColu0cYhBASlv4kp374SO/5X5cf/5LZeNXhzopjw3Xp7iWj82xUefmJjpWD\n", + "oN440t2oGjVP2Q8jLKjEXAyFmZrMWGpBEWeSOFGEih2bGoK+k8YKQU9i4MCyhh2ZQkvqrJmb83Vx\n", + "amZFzcTYKzqOG2g5sGNNX13mnqmemsSCqVyqa1GmLjiSyzSN7JrJZUZaZnL0NcysmVo3tm1TX8Wm\n", + "TKKYYyin3DOQWddK98Rw1zQ51AxHmufGir8UQvM+4y88gLrnMsy/HkL4h3TXsPtWzovnNegS8vIj\n", + "zTm+zEGfamCcEB9hb5UzIYTlFl+/wY9ulvdyx+k/b+ezn3d4OujMmvLes7pffRf3B1RvlIzE8wx2\n", + "+ewOS0Mqp1hOOXk5SlocLI+cqF0xqa9qD/ckychO2hGTlmntjGpxi5ipGOtIFQqHhnYk6voyVVMV\n", + "Jcsow0TigTLhUPmgWUJd7sCRa1KFtqqg4Z7julIVg7lHzWiOmLVVnDPT1RdkppZNjaSiwlRwYKaB\n", + "aOKKaCw3k7umPU9KWihXxQbUdkzjXZMQnYuFhUZm3Go7CNHdg7rb4awsrCsafTFfVx1edvjESGvy\n", + "tLWvpO5duGb/Bs/fpn+WnSdDCAfn+egmcdVsOLXXumFv7ZAvbPN3cDyE0PsesoxucT3yXKVsRh7U\n", + "1dXSW+SNav8rfPY/oLHK7DHu7pceX7Nx6Xg+nZs3Tx98hLkMN5ZfXyovGW0PJLnlo21FOcK5JHhR\n", + "piM3ELVFGb6mpacl1TYW3HPfVSNP29NRM7JkoCHYFZ2c7+mB+HeoxFJOCu5ZEm1YVtM3NnbPkhv2\n", + "rTnSCcHYSV2rmqaCbdGyFVU1XS1PGdkUdOWNVUWyK5+2Obg8Nz/p0tgpQ6e+fpu/+TDC/HbWt0NG\n", + "/hM8HWP8Lb7/IYS/olQhfadm5EjJ3qH82/stCEiM8S+GEP5r/GslivLbKoTwUw99+ekY46e/wz7f\n", + "0QrlgvZj+M/e4UOhhCyfDUEnxm8GWH3/V5Ez+S03m+js9SPhYluRvKR4/nz59zoL7L1K44CXcZXk\n", + "KR79CM3zM+8ZDPRGFTG549Z7x7ovN8TByN09Jjn7K4VrjZHFbm44O2V/dNp48WX1atc0tDWM5OqS\n", + "IjMJQ2MrYnhGIqjomnlWY27bPbMuU7HjtprEMYW2iTtKTvyCI+ckanNS42uqLhoJ1uQacotSqwo7\n", + "em5J7Mqc0ZNbcqTtrkKu0HRgWYKKroapmcKyzIJEW3TOyMsyh6aWUZXoWjdSVXNC3aE03KLWczKJ\n", + "Gp2ovkDxJ/jaMn7+4bMxz4d5W66fGOPhWggvf5l3v6dkD8oJF1la5ysPDA7muHkY8sJXeC5w+jz7\n", + "Q2q3aUzMfuUTDm6cf4gH80XObllu8vSfLW2/D1K+8Q2+8gLHP8DRCWyX4WNrzcIkO3Ji2FJP+YpT\n", + "DprHTZNCDIs6aV07vqYwcVrDVMMgVoxCw8RUTTJnAk3kUkfmhMFwA8cERzoKub6luUT3gpl9Ffct\n", + "OjTVsoa6qUJNfZ7cmkosGWCkZmhPXWZFUMgtmKmpaKtaldqdS4HXNa2rGBsZ2HPbmp6I+9bqHZ2V\n", + "mTRPtSosTAeq1WNuTZ+QHubydqGorJi5oKh9TZjWnekf16vccns9c/awVC0tXzhu/6MfZ3iGn99l\n", + "bVAGvXR+VRqjR/50iTgcJCGsfYP9f/a7uD6OQmj/HD//Yzw9pD7j5iIv32b8LUZASZvsAmcSkpTe\n", + "U2zXqO6UI57bsQzEe7xKCORFOXrZSUolViVwS9ka7Ct1LReUdMdJeYV6BCtzs7u7OFB3zIozElMT\n", + "UdUNp01ccR+FoNCRWRXdVqIgm8oxTV/ZXT+Bm5qaTklVZeioSlRVXFZ1X8t9j2CsaaBuRUUiM8RE\n", + "jCsKaxiIcSAvFhW9J9nfIjnGYJ1bFfJPcWybX4184Xd6Xt6s+nbNSK4cz1x/3esnPZQD8m3qc/gL\n", + "+KfKccHff/CNEEJ9bh889m1MVGKMP/Vd7Of7qd6H3RjdeacPJEbDELygJNP+HuLkHH6elz7MDz6E\n", + "jlxeyw1/7haf2uYn7vChdkllX88ZZOXd5FRh/Tkaizxa4ZH7R3YmU7feVXEiHjl8ZlXv3mm12ZHe\n", + "2oHT91pup5u6g5Htx56TH1y3tLymFu87DJuWFBp2ZcmB3aJjPGsL9VWJmYqawp6ZmsK6DLkVIz3X\n", + "deVSBNsqDi3YEBX6ojIL56zomlNmclM1mY6KTO6cmoq+Kybz9qEp18Ixyw4VbiscUxHkhtpKPVDX\n", + "TNNEPrfkKt05SyCjpq9QaCjMNMOuakitSzTSgUYHZ6l+gLXnQlg9ycEvxRivv/3nnn3++ecIV3im\n", + "yuwyJzf56g/MlRLXWdkvx+mHZVBa+DuHfGCFd+fsbvMvC3Z/gf/oMc4u4S7haxrN3I90ef4hvsup\n", + "dT7V5dJPcuPjtD5Sl38k0WwVnpwmWkuJnVhzWGuYhJFZmKkXFY3YshRb+mEkN9YTVUPHvrF7ploq\n", + "qhKZ3JYVh8V9laSQFEOSixbUpUgMXVBxRsW+RRVta/Zdt6ZrJtewY2ZJrjQPH+haMbEg05EpXDFy\n", + "TM8JdX0z+xYsq1rWm2uwqp7Qt21dsKhtz0k3Xbaiomeh2JOktVIOHuuqRXS8UrjZDhyMBYHJiuJ2\n", + "hcVvmG2QJwWhkM4Jo/0ag3yFE2fnfKIN9jbYy4THW1Y+3PXH/gnL0/Kh/qV38dk/xuvsQr6LinHw\n", + "2RDCHW4+Wxqq7b9C9vUHtvQPVwhhkcc+xCf/H177Uer9Eg17bKUUjZxPy9yZGMrMmLVYsjVuoJ6z\n", + "ntGrl/lCMyUy8l7lY4uyhTiBvtRUoSVXinVaFqWaOFSTz23yjjRdM5HY1NVSeEK0qlzd7yofyD3l\n", + "3HQdd7U1VHWVbJVF5fDnlorcxFk05yESuaimak1iaqYvhkf0swlplBXHOBhTG5UypF187ibHbnDi\n", + "Ki+M+JkY4zsmePh2zch/jl8IIVxWtoaUY5rH8Ze+04ZjjF8JIYxDCL+iDE16IYTwv8QYfxI/HUJ4\n", + "l3Lw9ntefvpQfb/wRR7UA97I76FmpPtpvniC7UdK46r9wJVddv7vGOM+fqodwr93ij/yFFunuXtA\n", + "7bP8xMsmh8zW2JiPEzYORypXq15bWXFseFpyt6py4owTu9fsre5q3F9TZBXt7JrhJp1Yk2tZidvG\n", + "4UjfQDurqw+WZfWxLB7KbSvCigWJVMdAlAuCqkLL1Lod++pq9qVaFmTqc/D2UGLPkpqKVT0nROdV\n", + "7CrcEnTkcmNVUeaMqg0trfn2S2b92F253MSyhqdlJqK6aDCnxE1kBloyE/U4kocojccsh4qankzV\n", + "oqAWc2t5kFaCyXujc6/yxJPcfSyE+s/EOHlLAs6+Xc2Jcz8TQljBmRP8+Dr1a6zt0/w6ky3+2QPe\n", + "yhy5+WWvM2MKIfz0bR5N6eQc0fkpjp7k1z/I2i02X2U1Y/kptv9Z0/TGedMfXbJ6OBMPe7Y7267X\n", + "F4VYkVSqEn1F7MuSmV6s6iRBHoODwIX5g6in6oKamYk9wcApNYXFpKvq0DAZKuamd1Uja4IViW0N\n", + "mUKwoGmqourgN0c6ZZNZXhk9M2cEOxKvaqk7homRkQpWdWyLxkZm1pVr7aGRzB1xLh1tWNCMa/J4\n", + "l7CiMyvUJ1NFJTespnq1iSIdyVdHQh5JbrNWYViRZ2Oj9l0xFM5ts9sqH6WTlwt+qPDN1WVB2NV6\n", + "nE6X2rxxSfDcHV573++mGZmf8xveUMb722qzXDvHCq0aj7/M/jLdhdKUNPY5vsQjB2wnXF9ic1be\n", + "d/oJ/QqNUK4xawXfSErmwaZybENJJ52omEg0REOFZYUxqnJBrm8mmurHRAh1U2vGdvElpRj4A7im\n", + "7LKfVbEukZmqKuYco3LUsK8vOHRMZlM5bth54I2qbzDPf+6aqBoVU7Mkp1gupVFypi+xusW9nmrn\n", + "ls2TR46Ppto5N34yhPQfz2MX3vb6ls1IjPHnQwhP4oNKhCQqB2YvfLcyn4flvPOvf3L++T/9XR/x\n", + "93d9XJlq+P1Sv4i/8U4fxO+kYoyjEMLfZ/csX1pTopZXH1xzIYT2ozzzh/lCfY7QNZl8iOSuo5V9\n", + "g6QkJS7Mx4uToqFbKQxqBw7ONKyly4yOK7J9rXtft7Ld0Hv6QLJwVjKLYlq1rDDTtV4MVWcdL7UX\n", + "NMOKUegK6loORU0zNVVBVXRkV6Fi0TEdB4ZaDtUtW5bPRwupmZEDYzNn52vcfW2HqngUA4WmoCeq\n", + "6CpM5da0bci07SuzgVMbcomhzETTTEWnzEjRchRzuZ05fXHfSnxMEYOasSIEE7lQjKRZtDQN8kBn\n", + "xuVlfvA+78o4/LEQwjfeDknfG1WM8QAHIYQruzy9yKkB98e8/O3C+UIItYQnFuaEvIxbrP1lzvwI\n", + "53oMcu6e4uDDpXdGq8rGf3XMTv0RjVZm8Wiit1u11VgwTMcahmbumYZzqvm6UNkyC3fd01cLhUeQ\n", + "S8yMta1bmSMaqyaO3HFgJo1DUeqkqrvhpIkVbVftqethKpeoWVGZJ988pS6Y2FXGLy6bKeYi7apS\n", + "BlxzzlKZMm1iVaFjYldHRc+mctJ1oGXJqqA9p7kOJHOT+qHgIEanMmLSVplNdGZjr7WDpLgqhkfF\n", + "8QL7N1m5zMJA2rvu5pk9J77OV1e4M+bO/xZjvLEZwtVLnHiynHOYm2stdW1epvXQdZTG0qfjrasQ\n", + "QgWxdDOf1KlHtjeZnKKyWDYpzfrcjGyrXGcXGYs9JifK9N6kUg5Lhkpi65pyDHNXiVMMlaObqYnV\n", + "+XKhdAcZq2k4mNOU12SaduyFQrRk36pvcoh+XbkqH+GYVGXuv7qEit580FOfK/iObIo2zCwpsZkj\n", + "QaEyx2sL9/XiWD2bquSXhGRN3OqUMcuVfWoT9vbp3fToYu5Dn+HkXWpZ2Vj+v38mhPA/vw38sN9W\n", + "31ZNM5f1vOVOi/8mVAiqyhChP/tOH8tD9UVcCMFGjHbe6YP5bmu+6v1Wq5/VddRfNyo8zVGblX03\n", + "P8sXf5wf3CamNZceW9CfVdypL+ofHxo3busunLH+1brcwLnZ1GxcczG7olFhIJOYOVvUrZu62Dwm\n", + "KdZUYlMt///Zu7MYa9LzPuy/t6rOfnpfvu5vnflmvuHMcIYixUWUqM2yHNlaINhBYiGB7ViOEyBG\n", + "kps4CZIAgQPkyoETJIDtq9iOlzheEmuxSFmyRIqWSYrrLORs3770vp/9nKp6c1E9JCVrn6GGSvgH\n", + "+qILp7vfrjqn6nmf57/MNNJrWl4xclOhodCWOj6/EVxQuGVqQTzPmuibGcs0HRrqa0qtyowEXVOL\n", + "XnbH+x26LPjXoouCD2HbVKblyJF9TC0bnDd9l84zboZuOXNBMG9s38C+TCqol5lOXCYcSOJ9kqn9\n", + "cslUA1v2jH3bgCSNyjI6yRnmrA54daNt+p4mf+G8s/maqkO8qepV3/uDKlLOb4qfDSG8ovI7+O0K\n", + "kfkN/vy7WL9QhX/V/rX2swPPX+DqA1ZaPD7llSvVdO/set1+2pIvzUkXeyZJx1a9JYaOvDUnuqvQ\n", + "lZUXKpePpKleLkmcCfGBmATHITG2KDPS1Ve51TJV6jjUNVYvGsqkStmdhcvq9gxdMdK1YqhuXuLQ\n", + "kR3RM4ZmgvY5GTHT1NCUmjjR9LpCsKirrYVS09jeOfG5IZzTmjnQtaergbpEet5ZuycI4UgwZ280\n", + "dCupuTApxFlpr73iVClzIA9Hyk6T2bFGvmPTyLWXo/Qur+V8+qfwwpu8wn1+6hP8+R2uLlbf115V\n", + "HA1dv/vrr1S/XtWJby+qOADvovsjXHycRo+H13j9lPoi9XU2I2+0uHFSlXWP6swusPA55g44XGLQ\n", + "qIYkF2Jletav/htt1Ufgy6q9+Z6K3fEM5yqXWKlsTFx3pNQ8l/UWJhKXBK+7oRr2nKsAXcGnVV2w\n", + "mboD0ZnpuRHayNB9YysoXTRUN7Kq4k5lqt7XialE34k0nmjGmYXJmfL+JfHRiNXXqn92Ms+D72Xv\n", + "nuZzhff+Ix7b+toZXB3y5Bp3r6sMUv5A8S0H1rcPH8TtGP1+meJvO2I0C8En8Ufwj97p9bxN6J2c\n", + "Ky7S6o4A9mlXc9D+/8oLD9n7cebbXb1RYn/lwwaTC7I4UmSv6s/fV94YetevsP99xNgxfzTVmZu6\n", + "UJtZzOoWyqlhaOuVTQvFsZ00EqvZfamBI4tuG9hUk4lWznkeZ6YuuSB36nGFV93Rt2wiFXR1nZoK\n", + "ziwKLijwgr5vMzFWmlM9+Sf6dqVqOiaOTaVaenZ1najLNY08rqrLtk2cyl2OJ2qmYtF0GEemYcHj\n", + "9yem3XteWRtK4qFWMlaP3MyiVo2iIDtk8ZWmf/Z9jzm4vGwQrnDpHn/2K0wvkFxV7QXvcRZC+Ht/\n", + "EKz7KvRu7ce4cZ0ghI377P60qse/hvGb6oxF/sSzPB81Vl5VrE3lBd1LNaFVc3Q6dbCYWy5Zyri5\n", + "0HGcXBf2U83ljrOVDTG2xOFQ0ZoXkyFSsewqbcimO/LWUF4eKkPQVdcwcikm+mHqSEtDTzCTaciN\n", + "pHK1GBRpsBQGUqWeh3a0DTwndWLfQE2hZtnMzMSKuiOlQzVtM22ZR2qOTS3ZFB2anPfFRgozTR0N\n", + "Q7dM1eTn+q2GU08rZjvu1MbWlMgc2zC0J8RTrWLTcHDVg92Zo+WORv/MMJbGzcfV+os6oxPT1uti\n", + "Z+TxQXT1xeg7P1o9Bq8u87EPxrj9pneUGONhCOEf9Pjz3cpvaVAYf54vrtGacfmU/Q6fW2P/n+Gv\n", + "vA3vj2Xaz9O4wNxzrH0bTy+x0ac34daUV36A9UBrjVspoVc9wmdpNfxIVhh/H0dbnHYpZxX/tlji\n", + "QlnJfx8EishCrMzRFrEYqu7TnqrP8UBwLOpIva5wxdCZlurstyT6alZVXZDa+dcF1dBnS2pJTd9Y\n", + "du7K2lTFcS7oqyktqNQgB77mS5KJemIcyl12Ib+kUQz08ruONqb0v43bnYptKyUe0ozShOEaxY6v\n", + "cn+oOkh+C5n0NxbfKkbePnyz8UXexJu8kf9PFCMxxpPlEF76LM9/gIcZcUDts2wc8H+d79j/Xgjh\n", + "/1nkL13k+6/KVpc1lWKaSeNlZfbA6NLY8fvZXuc7XzjVf+ay0DtzvHxqy0gnLTWlpob6tahd7ihk\n", + "euYV5lVtw4FGeKA4v8G07YvGpiYOzbTsOfOYka6hr2g4taCvo6lpoCZTw5K+iz7poeXzx8whElHb\n", + "qZG+jmjJnvw87TfzuJHU2EyqKdc1sW5fNyyJedv8tKcVjz0cLQrlRGzMdPIdi0UUa1ErlBbqHB+w\n", + "/oCTAUebm4ZXV8zNUtNJVFt7zmxvxh97F//8qfP2+30WP8afCSH8tW9kh6Ry3Lz0k3xvnRvnvLU7\n", + "q4mf+28vOjzZwIiwHsLdfX52Xe3fPzG3NjW5tKDTnKpnDfVuYhYXhJOa9ta+7c2+Rit1nF2TzVo2\n", + "5gtntZ7TWt1wNjRr1YWwzOweWVMMmaJoCmFByLdlouW0Zq2IhqHUCzVrZlKFPWMP5VpKhVmlegl1\n", + "N6KvdjFyA9EFD3VFHaXxuUB3XeJYdCQx0XJipCczMjKVxa40ZE4kJgo9afV8OS9yN9QlprYV5lCY\n", + "GMd9J9mauqnxeVZO11gt7krHOYP7+p/7DpNXM5PvzGTNR8rLV6TDZUke5Z056XBd1jw2bU7UB5x1\n", + "Wejz2BHLV0IIS+cjNSGE1mX+zPcQbpwbkN1k7Re8Nt131Kd5kfyA/X8Q4+ylyhLorbw/sid44s/y\n", + "bCC/xPA5Dru8+0U6ObdXmHua73idV5Yo5thsc7/Nrw1Ya7MSuFty1qB+idMWP3jC1hxZrBQ1SWQ+\n", + "pYjBzWReazYyq01dVpUDE5Vqrq5hzcR9GRIXNZTWUBclEkEiV6lCgqrXsqgaFmWqjKFLqq7JQxWH\n", + "ZBHLEi3B4TlFdlX18J6oXB1Lwg0L4znj2ciotqm+nVmsvyife9Fs6XkOF5g+YOlTatcnWgVH38Fr\n", + "myx/kY3dKpX4bjj/03/g+FYx8vbhj+J/eqcX8ZvgX+IvvdOLeDtxzE99mvwW75urKv3igJ+dnht3\n", + "VZEltWdzYamU31jUPuobr5UsJLI4lBUtzSHzrzBrMqsNNQZ7Hl5dkqR17DkJQ5tlMKcvhIYsqZvl\n", + "S0qMDDQsy8K8mUeiaMmpXN3YVU2resbqXhNcP6e2tU08NFTXlWk6MxbV5Q4MdM1bseDEIkozO3Lr\n", + "akYKO6oNy5IVmcKZQ01reueqmsRYzWOinTgwiz3zpi7v5aaPzhwkcw6ud6T5TFKe2TiZ6Relr3Rz\n", + "s5yb22RP12yuzEmyKPTbNt841b428fDaU/SOqvvfPlzl5DGublUGDN9Aslv2NM/M866vU8DEcEX6\n", + "7R/mM89U4yNf4eIv8p/lOmu52fKmxbRlpT82bW8YFqdiODbaWJY+7Gj0+vrLTZKOx8ogndXktaaL\n", + "8cvu1xZMp10x36u2iLGBfTGbE5NjaZhZmtWs5GfibOZqs9TJ+vZDIhFNRMuCe2ZIdGIVhnZZbuBA\n", + "X0tpxaJ9u7JzFVaVa5PYkjhRM7FgYOTIvJmOBbuuOQ5tVRDebVwVLOjLNBwr3HbHkZrENXUtUSMu\n", + "eCNsWDJvpKtppOEOds2FiYt1JrOhq48+7o0L847vNOXX2rJRSy3pK5pdIS+V7aDRLMhLq/Ns/xEm\n", + "n2b93xj71nn2mSrf5KtKuKfYP6T5S/Y/O43xs2/XO6PihFz+d/ihE9YHfPl5ru/zaJFbF3jPI846\n", + "XE7Ir7BaZ25As1PxP77YJk0rh4DHJpWNTTFg0OR0vlIlL0VeTSrb9xMMQt1eOefZsnRazvSSaKxS\n", + "19zAktyhDG2PFLZ0rWpJpaYGcoNz4uoTqoLjEK+qmCfXVR+oXHUCT6SmglzdvK4DwZnjc/5Q1RQ+\n", + "whlxJrOqnUehJPSbasOmWllTm+6a3R/TmbKyo7kRPfcoWJow6DNbYut7Of40dzPu/6sY4x942jzf\n", + "KkbeFoSKV/ZB35xupy9jLgSPx+jOO72Yt4oQwkLKjSG7b/D3VHeJkzelfZWd/JWf5N2tvln92GcW\n", + "ekaNDckkNz8spWWuSEqNhKUp8XTJr9y4YmHC4tnEbHmsVx+5nieuKrTCI9vlxO1wwUlIheJYkSw4\n", + "mx3Ka0OtkKvyeJlY0T13Hdm1IZHIPBCM1OQKHQeG6miKqtzVAqtWBH1B32smNqU6KvLijsSquvG5\n", + "y8SCUt2pB04El9V1ZNbVbRpJY8OrxdhkOhPPEgdrTzquddVmC64czpTxoa90p5pxVToa26kfyhd2\n", + "PTmLVu5m8vma7miof7Vr7vZIdr0t305+A0enU3WJG9/Yq929wOqvk2x2vfrEVa1eVG+VpuGAlQ7d\n", + "Fcl772jOmnpzdXOzIIhidlmYnXhQC5bb0cmVxCwGh7WgU0SmpUkzCFlHW2rZIzvpE5z2JfU1ad7Q\n", + "LHNF+nnDrKk96yjzQ2fpkc1Gai0Qy2icFDINIw339Uxiy3VzhmFMLIzC+DwYPtd2rFBT8wWFFUFX\n", + "Q8vMl5R2taWitiUbNuTuuWzRRK6FmYFFXBatKA2NLEt1FXoKhVrMXIuZBy5px7ZZHKinlRNFDcM4\n", + "8G14LAT38obmha6wtOil48zwpYH8mWXtfqK5v2eyMNOtF0I5k9RYOWPS5tFH6P0KR1tvdkXO3xMb\n", + "q+fjgK/HCuO5imzxdmKDzQ7rb3rJJNSnzE+rUMQ3Rhws0Kgjq/xCVvr0O9Q6aLCccn1U/Xg6ozvl\n", + "VsndOk9GNiLtsuoWPCxr5mPd4ijXDwuGtaimcGBsqoo/PJALmHeqo+3LlSGSjompgSMXDM9DEr+W\n", + "yPtmSu/GeXlaU9NDIXOkpq2ukEqMXVN3Ud2JsZFoJonrZrP7Yu1EXmbCtKbeGyhbE8VJLuw+4hNd\n", + "nspYmLoxN7I66bv2a8wf8uoVHj3L/RYH/7uqxfOO4FvFyNuD78KLMfotyXXvFGJUhuDn8cfxN97p\n", + "9bwV1EN49gl+4ilCg3iX9A6fO+WnvvaqC3+SHyh5/AHsevTG625/e6YI5HEs6OuMB9Kkod4o9M7a\n", + "ppcOhUZUS6Kz0FWLK07CgdWi4Wo5MZc+lBr5bHFD+6AmX9+zmgVrMh25iS37nrZv2dCZbRN1+xKF\n", + "qZ6GeUvWjF0z85rbth0ZWRBcFi1IEAUNF/Scum1qZmSi1JCZNyc10DfWtAKmguiGzAMtryttYd5I\n", + "drYgvDJ0y5JHR0+Y7R+5vEwoU9P0ulm6Ly27lsq2ZLBmPsuN2oeu3d2z15mT5rSzqd5CLhnfpP3e\n", + "qmMMcsL9qsv8DeaM9HfZr/P0194DBt3EpDUzbb/ED87T6VJeVG5uGaV9knlljUIhBkJYczBecZI3\n", + "FftrJsef1X7XqUutIzutRUsh1ZmMjWo9ZVrTKjvy5UQ9f1UMXclgItR2LKVTS2Fe587I5ELThWZJ\n", + "vVJTTZOOB2HdINS14gN5mJick437ISjVBKW2ID1XRGSGasainqltHQMXBFdk2mr2nTmzJtFUR6qm\n", + "VZ5K1PWSgKFSQ6JUWJGaExxpyiQxM461qrOTFNplX5GM1CSaIWoXNaNJQ1rMmayuu3Cn7/7Sdxve\n", + "/jgnxwaNTQuTqFk2rA6OHHfGZnjtPazMOGzx6cDOr7N46LN7+JsUqEcVk3TnNx5/i4iUX6fIaTxg\n", + "eo3ThMMLXC9pt3mwwnqf9TO6Q5r3uHmF+lI1oklTGlMmdYpGRUO6k1fiE6FibcTIUpHYz+g3umJR\n", + "Myz6HiTRfMxcDjPXfO0jcSra0HdRdMtYoS1aNnZJMCdzqHQkihJtQVN0X9ueoY7ootQiTnTiSCMc\n", + "OrGEmmBJplu56Bqrx76ZvrR8QaNR10oyg3LFbO/QIOmb/EP835/iekP6I1Nr7ei5F6tzAe+/zdoR\n", + "W9sxxq+8zdfo94RvFSNvD/6YahzyzYqPqqz9/9AWIyGEzuP8uz/G/uL57ut5wtsZ5lMAACAASURB\n", + "VC/yoc/wOr4cQljkmUs8/tW2funGp0ZOrrzgeD4ViqA7HmnGhtU7ibLG0aXgxlbbchnFem5x2tNf\n", + "rRnnuZjmJkUmTqN2Y6aZ5JK5I82k7kJZkyU1szCSaZsXHNoUVMmnfRNLcWwpjKzEu2I4sWdF4VQw\n", + "UkdDy46ugVRfXV3vPG+kbsGxA2cmLphTattz6kxf3YIzDWO0fcUVx5aIU2fxzGn5wHh+T/5saWf3\n", + "itmnLnP/xOgDU735xLC2Kiu3TZtTx0XL+DCxat04HhrXtj21VXh9c01MOb14rHhjxL2LzLWZDmi8\n", + "zPIWnzj3ffkGIn+VV85YX+PGPoPazOEVDjfmKove5ZKjFvcDe++SN7fEzry8nOrmhXQ2cLayQtFQ\n", + "HD9n8PKIxr5e8ZL+c/cspieGoa2II5N8KMmXzeWfczbXFIp1c4OpdPhAq557PCndX5h4VyN6lIzd\n", + "lFsLQZG13UsuEqO6PXmYWFHoahrqKsxsmVg201PREY+talgWnRra0dXylEV1UyNjUWnF2C2FGMm1\n", + "xTiVm0i/mpIyUaXStGTlmCQRY65Xjs8Nc6fGxUArmZFMkcnjyKxcZDhmWDdNZsLirtn1UkhG1Ja4\n", + "uau4fOa4HGjWR04mQ3NHicuYv0m/WYUM3niVyQdwK4TQavPhFb7rK3wg5eLzfLHJ9A4rX2Y0qyQo\n", + "bycqqwzbc2z22HyDNx6jt8DaIeNm1dXYPWB7vrL835nnUUXdsRAZlRVPYjEQSva6VXbNU0c0suCl\n", + "+WAuYaEoHcXSnfGKabJuT8d4lmmkuy6HoIy5k1CJcRfRE23rOLSso+NIZuJMRXVNZbpaFtVFwba+\n", + "XGnm8Xhi19MmoSZ3IsrFEK3Eh85Cw1iOU7moNNZWmIYDWdJz6VHh2lGLhUQRt93anDn7m+T/9Dzi\n", + "4Y0Qws8yWPtaIfLVUznHya++zdfn94xvFSNvD34I/+k7vYjfBv8CfzMEjRj/zTbqHxJcf4La4te1\n", + "gVPi0xzf5gN+y5vdtYe5l25eVlvdNQ0Dodm2uD02WRjZXk5151ILRU16t6ZxPJWs55IP9vQz6gdN\n", + "28sNC6L9WLMyfGCnQ11NG1NDdJXW1G0rnJiZPzc423UaTtUVZjI1hzp2LCv0YpCGS265oI3M+Fya\n", + "d6CuYUMqt68m6jpyqi13YsmpCwptwWLk1bDp9DxabxwztbhoFqbGHrg24cLZll/74VvKlxlPZs4m\n", + "mUmtp6iVYujqHW+Kk23DS6m05LXFwod2tq3c3PaVy2wfUvyX2PolPjzPuwtO9/hYWY3/fs84DzJc\n", + "VXWp93/z2PcK554z/zu/+KN89smGkxvXnfRmit6scmbNdyRX/6X02oHs3g2jL+3KWrftL60bNzPp\n", + "dN/oLFM2N42PHlaihb2PiL+8507nnsceO3K9PDJtv5kGcmJ6PHGYXFY/OJXMdtQXc08ftbVHR27r\n", + "u5+zNKoZ1TOvjWoOOiti7EuymTlt188j4uc0XDHz4LzYvCu3rXRVdNUtIw9sS800LJ1H5JWaCnVT\n", + "R4iyeExcdlSuivmWIqzKk0OSAiuiHRwpw4ki9gWFvTixkBS64YHj+rqZzIl5MwO1cCYmU6NQyuNM\n", + "Wi+tLCTyLNUtPmX1h5ccDDLGN8R//AXF80PrF3ILj01dfsjjh+x22BvzPa+y9VwI4aNr/MT7ufY0\n", + "O0d84ot85FV+JOOLZ9zZrcJV31bfihhjEUL4R/yLP8fTiyxMuT9iepen3yAdcWGnCqH95Z/kU5s1\n", + "83mQ16ayLicliyMOA8M604SzgsMpz/bXfXlzTas4cRr6eulMy9DTh8d25i45KubNOg/UdYUYjONQ\n", + "P42mqrTeTXUPLXrWxC3HtrWxoXJXzRTnxPhKzrsl19Q0th8aeqYyD4kjIeZOk8xqiC656ZFLCi+a\n", + "WFNXlzqQlzetjcfec0TjwUz33OByLuMTn4+x9/WfrzvcusNnrvH8NrWS1y7wYp/xC2/n9fn94FvF\n", + "yFtECDZUvKNPv8NL+S0Ro8MQfEXlg/LN3MH57ZBkXyflfRM1iqRSyIkxnoSw8Yg7yzx+xLDBdGFf\n", + "a9QxmVyW7o08yHbtXDrWaXDpK4XFjTOt+dTscaZFTWsvGN3r612vedTtCMXEC0lNb9Ax96itNr4j\n", + "fy5Qb6jFYFYmJHuOLIlORXVVw3Z0nhHxIe3QMIwnhmFfzbZpWHfqhrpg5kCpo7AsWjb1wH19waY5\n", + "DdGh6AVDIwtqlnUx9UpIHceWGApJWchjYpQmogX1ZMu4W3iueey4+cCDa4/beHHk9LEzw0sHprWr\n", + "ws3n5TdbjIfO2m9Y3KDzauUyOVhm6zYH/8PXJXT//PnX7xshhEsb/NvrrAXsV6Zm//S3+5lz2e7f\n", + "CSEsXOC/+mEe7NH9Iv/h61pLifrkSG3a9O6Hd2xdbbv5pTdMP3qo92SqvTRVzK6YrD7BzUNar2lf\n", + "+VWNH+4b15veKCamnejxAQvZvFmja7g6cJoObGyUFvq00lQjG9haiDY/GT37af7Vj+eOPnBNXizp\n", + "JMt6aTB1G3XBnMLEgb6BVOLMjhVRS4zHgmAcUicmji0YS52Z01cKxiprvMzQ1K556exIMd0TFabp\n", + "qkQmKW8qww6hipsvwpDymrQ8cmbglsJaONUKXffiVVEq0RXKa6I7PtMau65wKWs6KRI7zZZumZpr\n", + "TgwmJ0aDQz6yavrKA2+sn7qal64MeHG58p179+epxXMF6NPv4tqHzz2BFplc52d+nic/zU+VMX7m\n", + "t766v+P7JeAa808TC3qvxhi/So6NMd4LIfwvPHyaxpO4yHcWLD7gwja1AhKLN1NfXC+ELt2MNOFy\n", + "we0GT25Xib15nQcn7O525O+5pDbKDdu5+bBgsyCb7SrqI0t7t714sWZQdsziyKC2oJEMZeedirHS\n", + "sZqU8w1GV7VbylQylQNR3czgXG9VU/eEugP75szMqcVcFk9NwiVB3x0jK46seGhXV4hHUhNFfuLi\n", + "3syH+oQVZm0OWlz7RdYS2iu/4bNUhBD+Pp/8CC99JyGj/wLHv3zuZPyO4lvFyFvHv4VfitE3TOL4\n", + "NuGj+BP+8BYjD+4Q3kva/Doy5S2WD/iVEEKD7N10Ir/wNFfrXclGU785cLB232Nnu5KQGoeeYiX3\n", + "nj0uZby2fGwxnzhNW/rXo8nZ2LhW03tpyRdajwuvXhLvHll7X8v8UWIhPnBvI+pv1qyUQ7N600xd\n", + "z5NyZyrJSWXNTSbXMDS1HOY0q0eRh1ITK6YKmZGpK6pbV9S0oPS0hp4FUdOaqaaegR2Jvr5oXRmb\n", + "xDWl0p6RScKC1OZ5M7+Yz7z43pln9l63nx2Yteqahz1LecNW9ym2+6RHzB+aHadOj+pevzi19DmO\n", + "v8T2T8cY3zbCcwihe5X/4AeZXT1XW2wx94v8udu/0w9XmJ4P9Yt1hgu6Jx3rk450ODZuFxp54rHB\n", + "Q/sXOfmZ/GuE5vpt/mKD6w9ceHriQrfp4LFrWrVS3hg5zLdksbAR5yV5tFW/qjaZOBwfGnXPLGRl\n", + "lTb0Kb7vlzlu0+4sOkgvyWs1pVSwItUX7TiybNFIqalyFkmMLMjtG4ZVLzvSEi2b03bZxIK+fT11\n", + "c7qqFNfcUWw7LHsahuYnp5Yfrtu9nMtrjytNJMmuMj1POA5diXWdsiXJ9s2VqXFo200WZXFoKadd\n", + "ZPK0ZZxu2ol3PGrPKUYd2XhZM2vJ4kPF8pHO6LuNPrZL+ByfzfX/Gtt/iXurrO3zkd3KTXWny8nR\n", + "PMuXfhPS6nVOX38LpNWqEJn7EZ78Lp6cVPuQN74/hLmPx9j7hfPXXGLhPcT3ceE662PiBcxx85jr\n", + "nyKbpW5fzayNg6fLme5SkBfRoxqNku1FRmcc1Hj0OqP/uu3g5zPza2faUutlMFcm0mHTtBjqd8eW\n", + "MnbHbVOZg1rdZpwzCjOkBuVYL4lqMndsGltSnYigItQ8UvmMPMC7BBdE9/VdU2jIykO1kAjhaUl4\n", + "qPBufQcmrmiWN43jfe8uZjaKyB6d2/Se4/GS6ZjiEgffx6O7HP/S153PBZWA5zjG3i+qol7Cm7EK\n", + "3wz4VjHy1vFD3uKO8Q8IH8Xfxn/xDq/j94UY41EnhH/xsSqTZtAgv8f8y9yZ8Qar/wkb765pxZlJ\n", + "WPXis1cVb0wVk4H3HbdtnD0ymztWHNHsVeS1hRHr9+hfHloZDc3iilMrHm5tmt59pPs9PcXzJ0a9\n", + "RB4TIU7laaa9m9ip9xwuzMvixDCsOI3LYkjObbeDoM+57fZMLouJWmgaWVdoqUtMkLsiWhCciE6x\n", + "pKajZWwqV9c2taHuvpmr9u2qyTV1tZJjZ/GKcQhaYWxd1HIkDXXvjdHDkDvsFpbG+67c4rnbPLh8\n", + "0Ue/LdX77OtsJsyu8eDdpuN/Yjvbtf0PVZ2mt7WtXuOZZ2he9TUn4Iv0nmXhd1OMxBhHmyE8vMvS\n", + "InlN83gsS6dmcz1Znkqax2I2MPfg6wPCY4zTEMLfOtL+y6lrjQVbTzylMWtLpmNhfuQ01OyFAyfl\n", + "nGbZ0Z61dGYrRtuHhvXP214YunbEhz5J3uQLP1qz/dy6cdaVxYZQZtJiYpY2TDQNFZbUzkW+ZyYW\n", + "5dblenLXtK1q2JNq6OgK2o4tuevYgkwzTg3DRafjq8rTLxlNF7iZGC9Hg6wlL5Y0JntqnjKrL+C2\n", + "WTaRJrTSOY14Ig0dawrj0LQfcu2SMmWxzOwXDa24qGXBaj42S46VjSFJppYHzXxg89lFBwdrZpe2\n", + "YtytRmXbP1mlHQ/r3F/hi3V2//a00tX+G8+RfhXIdvIbj/8e8BhPfYQfvlvZx8O7En7m+ys33vo6\n", + "7/5TlSB258M8mzM4Zu9eZfve3OSl59g/od9IfOeE1bSmeVpKamPTdhQTFhusjpgbUjvgle8ptI6D\n", + "Ri1otCuufJ6VynZuWnTMQiJMT4R8qta+6qw4FJO2thOHYaadBAvnrLAqY6qtKkKiyszwTPUB6+Ip\n", + "dWUVz6ApKevmtJTl2DRpq8WmJBwpzGsWQShXxOS2SYxaA5ZfZ7iMEbvNiq/SHDBKuXmZ2cvVJm3p\n", + "R3nqvRVP5lAIc5+g/8u/3Yj0ncC3ipG3gBAkqs7If/NOr+V3gc9jPQRXY3T/d3z1NyEGMX4ihHD/\n", + "Pt9Wo73Pl0teof7jK2o/ds1o2DYuHzndWFdPFxWdR9KiZalfk+RVFkS8xnRSRYCPmjy7zQuBTz+T\n", + "VMZXLydieeB9l4LW4cDowquOP7Jsa3fd2cIjZe3M2v3g4OJFu+k1WU633JPU9sWwRMyFUBk5l2VO\n", + "aMrCyCQErZhXDbSwLrNjZlmhRszEMBbPJZxBoVAIcvtWECQyqUVR09RDs9DQsyqGuwgazvT0ZGZu\n", + "yGShsBh4o8G77rB/Q5XyNR7Ke4+z3/W1dOlf5Wqfoyf5jy/glLBW5cL847ejhdtieamykv91WPxa\n", + "BOrviB1+7pP8hefJZsZhJt+9o1zY9/hWaXE319zjpSnq55u+KcQYhyFcHuYWbl+wdW1FOpwpNrpC\n", + "UlNLMqedseZ4wcI46nSjXiAkmVqamLvDcMAnnqfzJMfPN60npU4spWHgLK2UK0nMDMJUDTNzEn0j\n", + "NVuahoYyF6SONWNXQzAK1GPNQjgx1XFi1YFexaQsNpk0Kw/z5vuNJsFo+3OsP2J1lUmqrPflWRRD\n", + "UzQiCbJYiEVl8V8F4o0kMr2MaZmYxro8H0uLtmk41W8sydI6WSGdnOllTdOzjov7p8qN3O7G+anf\n", + "qnvjsw0P/mShsTyTvzgz+DsxxlshhMNX+KFrtNcq4o0jWl8hDN+Spfjis5WCP/26nXut5MaMm8+z\n", + "8WF+eJt7K1yZVGPZnSVajxjd5eET3Gqx+zcKm88VwvuCZgxqI3qNoBWiemAa2Vmk8Smuzdj+z09d\n", + "6B3bNW/+sO9ss7RUTo2bI0lZMykmjjV0mhn5RUl60Th+ySxp6aIhWlToG5liaKKyC+6oBluJKlNm\n", + "iGOlXBbJpMowOw/drPyQJmEk1aDIjEIqDUOxbDrOJ3ZiYbkkafDcHh9frXxCwrCKEeoMqz+3+AN8\n", + "6H186EF1Licpv/KDfH7gm4xa8K1i5K3h23EQ4+8qQfIdxbnE92fx4/jf3un1/H5xPjr46vgghBAW\n", + "pP/ee3R687pnMDGcXzWZG0vXMtPe0LRW15omxEQtlOqH3LrMkyW7XXobXC4XrN3kJD3UfGLNyutd\n", + "te2+etlTv3Rq0r7vXnpirRulmyfm5rv2i4F6qIYxl8a37DefMAodSdyRuKMRpuYdmOqYWDEKI2MD\n", + "mRG6gjMh7osuoke5SrFvVEvkcnNqxuo6DoykKoulDubPg7TejBR/aMXIvNyiKFE4Na1C2CKPn5A3\n", + "qhv3q7We0d/6OT7yTDVknt6n+wLJe9j4AW7XKhsEX+LaJ/lT+D/e6nXrs7VD4+nfcHy3qgp/V4gx\n", + "Pggh/PVDPpQYLQ3F9bHv/SRPHNGvBz/93jXbg2X+8ohiPoRP9/ilKjtldpw5ebIQ6yPFfFeYlGKj\n", + "MGsuSoqbJs1o2o/6s6A4HEj6O+JZ3zMf5yzlV065+u7g8UFHmvTtpxPjtNR12yyQnvex+rHwWpiq\n", + "mxetGZua19I2cWqgG5Jz1UzUNjTWsmzq1KJojaJk/3HSIe0ms4LmWmXrvfNpVj5v1loUi6EYnhaK\n", + "BfVyT9EYG9jVSGtaojxUOh6edKwrT0YOsx2Nsqd71jaYW3OvCBbMdELdSZizE4L6EE7U0iPtcQgh\n", + "WeEn3sfTzxq/UDMu3mD9s/xYCOFvxhhPshD+7k/xp69USXIeMXnI33/Tpv/tR7nG1YTOrHJHfVPi\n", + "u9jn+Aprn2F8n9dP8HIpvDAxeCbTW2BpmBsUpSRUPODLPRq32LrB1gdZbRY292/pNxcdLKfm81Ox\n", + "MbE+Kw3znn69rT4eWa+npum2wzRKnbliQUfHmSO3lYKJkUVVebqvIqtOcF9VjHTUbYk21OK8hkP9\n", + "MG9WFjplXSO5bS/kYlxDUEzvEYaS8VX93T23iiOzBbIF7rbobnHlszz+SqUIun0ZddbexwcffK2o\n", + "axR8cIt73x9C+Mz/b8Y0IYT/Ge/HF74+wTeE8N+rxhvw38UYvxlt1H83+CF87J1exO8B/xR/2R/i\n", + "YuQ3wfqystVVP33zQF3rbGCwWposbxj969c8uJHrjPpiWmrfobnCG484Cxw/k7jSrJn1Clk2opOZ\n", + "a48N3jcRp31pvW+pXxI47vH0NtlGU9mgeWkmNtuaeUeaHlsfftGDViYJhdWyZkNdluyZhcKpXf1I\n", + "M7YkycjUTG5ZEIXyFqEmK09N02P14lCSLmpKz42tRkqXjPRUBklHKkeEkSSuacVbeknTikVTJ3rl\n", + "yCyZ6c1YOeDBJvdz9loc/p95jC+EEL70gOebzB3y+gY/+kGGbxYi8B62XudGCGHlrT5YSl57lf0l\n", + "Lj7LTiC+ysaXq3CQ3zVijHv42RDCxzj8Qf7Vh/nSZXbmbzho/DHx5TWGI7LP8b1foBVC+OkmrZrm\n", + "tZEwV5rVBrJaYjZpOHUkr+Wy6SMPm+vauy1rr2+Z1u5Z22H9hC92WD5kLomuHUc7WbDafs3dpFCm\n", + "dU/GmWkciGHRWPTAsrELEj2JVEMpONDQ0IlDeXliOVnU9dCsXHISGxJHijCgeIz+gLXzJ23zlGfH\n", + "QnYkac0L6a4QMrHWlRQvCRoYivkt0yRRCx2nBurl0Cxc1HFWGZ8libNkZpI1ZK0oT54yGU8chZ5m\n", + "SKnNi7NHyrVbTg7uaJ8WBq8zfOw67/ruysEcfDsPx1w94Hn8Wl51SP7qw0pKAo/e7Er9/nHyFd74\n", + "bm6Erz1IZwlv1BjfJr9RHbt6yK8W9GvVKOreJrt/lHyB9j3m/iIHt6O1L8/svXtmWqMfGc5oHFWd\n", + "hF6gt8b1QL7Heiw1R0denCdPEjtF0+3QkMZoflRqJ/dl+YZaPjCo78uTRY1zPVTbnGAkcWrNffc8\n", + "pSK5vaZyXK2jLvW0zK0qRjN0DOOOvJio95ZlcSa2T6yWhX79TD+ta+ZD2XRF55V1p1tPOX3jl+0U\n", + "Pc2U927wHS/ROTdwe3GT4xeRMFdWtvZfj8UJtXXVtOgtXqe3D9+wYiSE8O3oxBi/N4Tw10MIH4gx\n", + "vhmq9HdijH/lnFTz0745M11+N/jj+B/f6UX8HvAL+Lsh2IzxG21Y9QeGpGGyNdXbbFo5gIlYe117\n", + "kW63pXh35tFox9nVExf2ybaqbsj1l6mFlul7VhWjttatodPLAwePz1sd1SRZphGa0mQqLSaKza76\n", + "u5e8cTwy6y5K03krowf26l2H9abGdIgd7btNnY01l/Oo1hzJ41RWJFbKM+O0o5UemUiNzavZEcNU\n", + "LSl1ponuzraTuX3zLRbTLXlkWF8wDs9IjM8lwyeqgqRFXFLGoamGqYGmM4sGYpiKZVQeVjkdX9Dy\n", + "2l7T+HPHDM6Ja9vOTctC5a39pxf9+pDHc4fIqIrQeEvFyJvcjY/zA1/gfaq0speO+EX81d/H78vx\n", + "sRDCx9G5wE98L4/eHBW0yL+L+/d5/xmLV/lTPByf6NZeJ2wosmCStuXbW8zeY/rxT/Hysf5SKf3A\n", + "yNUtWod8tMmDv8v8uyjGZPUzncGqWTGz0hmbqw8UoZDkhSxONWrBONz30JlSkEkcG0uMNZR27OvE\n", + "oevj3DTL1OOuIk/VQleSXZblW9JmbpSUitoSkWy+FOtL2qEvNbNa3BRD5iReMhlPTWXyWGp0BrrJ\n", + "lrmkNIvX9S1Ii7qNWU2RBdNk3qz4gklzQWFH2c61pxPprNAZJTrTI2eNY5u3K0uZ1z/XZPPy1xHG\n", + "qzAEtQ16S5UH+q+dX48Zb6vD811e/1XKcwLruMPtJnd/Dp/l/vdXkferQ65+lk9/B4MnWBszzire\n", + "yNwV6n+c/kPGN3llxsqYUYJBTb07Z1LOnD02tNgtDCaJYjF1eymnFq3KHMZFY8smZU0zLeXF0Dg+\n", + "shxed7UsdXTcNJGZKbSkOgqJwpHSmWpWtaDijSziSBCk2rJ4RWJPVuwpen3T3dLceNvaQqo2Cqbt\n", + "3Gg0FWpNyeFl5f11h69cM3ttn2ZL3OoZ/RPe+AnGT7Besp/w4C5HP4eco5JhVpGO38T2HOO9t14w\n", + "vr34RnZGvkPlb0F1w/lOfA5ijHfPj0/9JnLNPwwIwSLe65vTAv43RYwmIfjn+JP46+/0et4m7J3x\n", + "erBTH5uuHMva2xYvZy4N9rVe7mkclrYWpl79GC//YxWR/Zij5+aV/1HX0sGC1q1MbTIxuPCYwp69\n", + "hWg5LciDZNB0tNF1L33KfL+jGQvbyVBsbVHPvHd4pl/bN01OjRq5s2Ri42ii2cmIqVJTYlN9cCif\n", + "WzdWs1GOLXroLI61kprh9HGLt1e1vpSI1/atXOJoI3cjb1nJBh6mrzi0KlgRPIOomg3ex5oYn9Yq\n", + "Smde1otTTWOtKRcGNR+9ftX28VPyew0++JD3v8GnQwg//WaLNsYYN0K4fZ/1x6qmC9WJyvaq58/B\n", + "23GhYoxn+GchhJ85/76AtxKYFmMcY3w1hAsXf0PAV0pM2bzBD71HNjenMTvS7z9ULuC0oLzHyfP8\n", + "/Da1Ab8SY/5KCOEKR+9T3Z9+NcbYCyEMOHyNWx8Zeaa356AMYqNUTwuTaeGZT6/YfiI1XTxSLjQM\n", + "nKonTM2bmNO2rhtHSkNH5ci9/5e9Nw+y6zzP/H7vWe6+9b6hF+wgQYAkQFIkJUqiFkqivMkaxXbZ\n", + "HieWx7NUMqlJTSqVeCrl5I+ZZOIlY3ts2bFleyxbXiRZ1kJZIsV9AwmCAAgCaHQD6L373tt3387+\n", + "5Y9zQTRBUCRINAhy+FQ1gNs499zvft9Z3vO+z/s8tok0chTyCWLNIqlJk75YkYaXx2m5OL05ymoU\n", + "mwF8PUpUCihVQ/wIA16KjtkmIsJZT3DiO5FAo9OZoZPUSaswkM6ogEAM2hEfnyhOK4VLFAwDGk1i\n", + "iSSmM4YEOp6Wp5J2SbZhdTuUfg+YdSDZDBtBmA4dFfcJpBoQ64QdGcZmmCUqpZSIfBdeXIH5X4Z0\n", + "T0gT6z0QVhaX/hoe+AXY3QdBFBZqYDdChdXOHfDRJqRy4FrwwiSs2nD7X8JTe6Cd7Cc1NYHM1anH\n", + "KjhjOnGnjZc0GQl8LIljSZSkZJhmDBVY6NowflSjZS7gSgdXisRjPZRkHAuXChESWNiUcMiik6bE\n", + "VsKU0jxhSTUDjJB2NeKtaVpxG7QAt7aCOeOjuduwshb5IMDw4zh5aFlVgvy9tB7IgC2EJ+SZ0Bj0\n", + "O10tnj+D9THCWKcGLF04t0VSD8Pj98Pta9DXgeUMPNsL+T+/2mv2drGZwUiOkDAH4QTtvcw2vw58\n", + "aRPHsJn4NPCYUrTfcMvrC18D/kfeI8HIBfGjOG58G/lSnsxtAVPFGuk1jxsf9Uh1YCIBqzdCawiY\n", + "hsRtkPlwkur2fprrTUqZBH0dk/ZQH9FWh1K0RhPFOB5WwmRe30pQj2IEHsqIIVqGwF/GNGNkXJOG\n", + "1ktNHyIILCLZFRoJi90B9CqDlmdSijSp5aJoJBgMAiJKCCQgJwl2Bg6ndZsg5xFEW2h1GJyFlc/B\n", + "rAm+9OEHHTwZRWQYXdXxpEZ4YcuCpuMGa4iqE3UzDFsZXP00tuNxLjdERY2Q9upEP6ERWH005y3a\n", + "PTU4zoYn2Tw89Az8agAyDpUSJI7AYAEeUEp1rvaaXc39AbiwtgbpUS5aMlih8tXeKaLpJKmOgeEM\n", + "kpyPUBufxY5nYXYADpfBOB2q+M6kRO7ZCfdNhPvkPBwUkYeAKqz+QWisuLbfJqtBoQXKhrufAtc0\n", + "EbuNE0/TYJyOxGmxjoNPBg0Tl14xcYNhGnodL27isoWIVAkGk0xaHbxInETVxKykaE5UMDSfVS+D\n", + "MpqIWsVXJaJK0TI9TNXCMsroqXtAFlH+MiORKAdtF990Eb1GQxvE9H0KkqbjZHHN5TCwaMVgsUhw\n", + "015oCKI7+I00WjCB3zxJs6BU/bsAIjJzBpwoTLXhltugmYDaDOhJGDkBKLvQvgAAIABJREFU9xNm\n", + "tzcDJox+HD6xDNuOh78qx+HBn4dTvw/nfgtWfwFG74QtbbAcqN4OdzphY70Tg7gON+rQuAFeGIDk\n", + "ssbayggqkWRYz2K0M7iLc9T2xZkMPPxYlKYxSDLoUNL6CGQbIjU8qeDLMEnZgsE6AREaMoalejFU\n", + "lSVlgT6AgY9PC4cYLtuAOBoG4s3i6wkQHUcsfL0GTpSeRRdVqNOyYGzbLOmBJIGfxG97JIxltEyL\n", + "0jcewB/cFcr7B+fBPAuHg9BjD+jaFsFsNzjfgNaTcKQNC/dCZACsFSh8Syn/zCat2VvGZgYjF66X\n", + "EGapXtXmJSKfA3qUUn/9ejsQkV/f8PJRpdSjV3mMbwc/weadhJuJ7wNfFmFcqYvumu9mKKXOich/\n", + "WoObbWJjPrvOKIZWIObA0Uko3wx7MrD7CzA3AZkKfOhYwPea/fjSZnq4Str0acfnaGXj6AxidxKU\n", + "3Da+4WLrPWSwcQ2XckLQdQOlDHzlUNAy5PUdRDolTMOFuNDUl1mKWiQ8j5Rfpe07zETG6KgOSjlY\n", + "rKOpDoMqg4ciSplSZpXOrSVip0HqkDxkMBDozH4wTWBqGIZLRGp06OCpHmAI7DaYFjgGAW2CToyy\n", + "7xJRBr1NUMkcEvUZTsdIrfq4UYvKaJKVdJLGB9gQjCilFkTkD8vw0Shs86FchL/yfkRHhC6ydwju\n", + "NWDQgcV8SBY9ey3WXES0CNzaBx/UINWE+hMw/slQ8a5jg/4UbFdomkl/vk27LwIOCDmyS4rqyAxO\n", + "x4JzVXjSDR2fJ3bB/Z+ChRj4HYjm4IMx+OQQPF2GYJ71h1rUT5nIwQi23cbepyinoa/WpNmXoqb3\n", + "se7vISYayBSBPk2bFg4RdN/ECEz6/SjrZgstvkgm4eGkXYi00YvrJGci1O9JYmoaORWn6pVQmqB0\n", + "F03ZDJkmPYGFplxGqNFvHOJcYFDHZcRPkbQUHdWmHq0SkRWq9NPwxml7DrqxCJIiW69iD6UIrCaJ\n", + "uoOXdInlk2QXB2jlMpTcC/OslGqJyH+x4TfvhkgNEisQ5OC53bBchNtF5DGl1BVxfy6uY+xOyIxB\n", + "swCd45fsZzvsyMK2Dd1/vR3Yb8PabVA5BXvH4VNPh/SaB/vA3wGpCLg6aBEwXDA0GA5AVxrTe016\n", + "Dgi4Po2KQo9GaGlC04L+pCBGFF8c1iXCKr0YgKMG0VjFkwaWeJjKwZc460EEXTQynk/BnCSKRgyP\n", + "sKfGxeVlIAZBCnnFGM/EUXFiegqjtETLz+P2wmgTdsc77Fy0aEYqLCZ8qm04WICHt0xT/LV52KND\n", + "tAVnCZOiukj2M7Dtru4tNhDJPA6NRy+07XYzJC8AL4iIvhkPAlcLmxmMPAP8c+DvgI8Df3rhP0Rk\n", + "P/CvgM/+qB0opX59E8f3liGCSZgZeddpdihFR4S/Bf4p7y6+y49E1yflEZGRPaCnwkBkJQ3VW+Cu\n", + "WpgszZZgaCfkB8E26wwvtMhvGSBWqbK4awz8gESQQ/NrOJQpm5BWVaL+ICQMOvYk9dUq5tA6Qdwi\n", + "plLUmv1o6TJG1EbTdGytF1OzKKlVzokCw6cidTSngyERAqXolQjjrkJpa8ybAY7WYlwsegwXScOL\n", + "t8COYy771xT1XcvEhjNYbkBL66DrDh6j+E4E7Ar4W2Clg5ZrEdhVMh2XtG2R8nS8KHg6pHQfFdWJ\n", + "2B6JhE/a9HB2XGYOF4G/eDPzHRO5/Vb4/G1QHITlZeh5Dr6oi/y5r9T01V3d1yIDn74JPnwzFNJQ\n", + "nYP+p8D8G+jtA+lAsA6PxzBvMkg1q7gxhZNMoLk2gbaOrtbgzx2lvnxhnwMiB28MzVd8gAW4eRwS\n", + "EWgpcHsRrcDwv4Rhs5/UskZVb3K2UueZbTaZqsdKsodGsIuYiqArH6ULQhbRTDzl0rJN4lqbpvJJ\n", + "dpKk2yv0LoRmgH064IIz4THhJGhGdZoSoS+iUdVT2Jwgppv0+gGG5jOOju0liTsdIlGPWfFoqTpB\n", + "TOjDIIZGX2OVs7pFXhM0IuATEmrtEobbTzUSug6nG1ESxQDf9CnHTOxXGaYppebHRU4Nh3wcbQQq\n", + "kdDpnn4IzkAPV0hEvoh7PwuD7fCB4cS9IvJlpVS33CbJMMF+KbItiPVD/22wzQPfANOBsRNw7I7Q\n", + "OycjoAO1KCRcqBspIr0G0XiUyRbkzSRmwkHsOP1zgywES8xGA6IGtFQPhvRjKIUvDp6ApmxMFTCo\n", + "WgSBhy6CrVxsimhajAQx+gOFEpcAiCqFyBotNYHpTuPrY0RtH709SLtp0NGaaKZPkKmTrcPuGKRS\n", + "4OqKVMPn9jU4nIBYAEamSyB/lX+MSObjcPAeuHMx7JKxdHjyk/CiKyIvEq5L/UKAdz0HIrCJwYhS\n", + "6kURsUTkceBFpdRhEfkdpdS/Bv4jMAh8X0RqSqmf2qxxbBLuAWaVYuWdHshbxJ8CXxHh3yv17uTs\n", + "vD4KD8GhXwbDh6URGCNs4ojMhJLPvUF44i6Ndtg38yKr+6KoPTvIpNoEotCJoKkkeIvUzVV0T2EG\n", + "FYqxbTitDtGEh+5Xcf0KtuvQMNIo08TDwA8UzUBjTOsjRomEyuApDQyDut7Gtso0/CgTcUVgeKyL\n", + "ohEkiJd1MusdlA790zBhwuJ+2LLLIxeBqWaNsjnPtDlJYGuY0Q6+4YLtgFODhIYrHhJvoNwlsKE5\n", + "4OPHS3T0BI5tYEQAO0CjgGg2ibdcXhQRcxzu+ygspbts/AmoRsArw6dF5MxmtgyKSM9u+ODH4PwF\n", + "i4AbYS0A+QEcPQmPAR2llB2V6P5F6vdtZeBcnU6mSju3jBtfJnXEp/PAxv0akIp3v08rTH2P9EO5\n", + "Gqr8xk8wcLtixyBEzQZmkCJRjOJHB5mXBn4PBG6GwPRpGS2iARiBYOLRIUrEh1QQIWovoOmK3R3F\n", + "Ga2XelzHbbd4alebrRkYMcAxalRUP3XPJaWqOPoKHk00pdHEo0dptMTEdIU4PgmxyBk+Hc/EwyMi\n", + "Pp4fJ9qwMdMGKp9kdL6O1buMN7ZIKqpj2ooWo6z5DokgihER7FYHe7Zykev3CnxY8yC2sQwWAJXw\n", + "jv823Mrv7GZntwFDWXjgcyLye+Hxo9ZhRUIFhY1YzUK1CrnPgZWD8zYYS7DrJZj7IRz/8ZBbm7VA\n", + "i8O8rtGQASa0MmU/xUC7QTuZoho3MWM+yhT0aEBe6yeJhhVEiOk6MVH4dAjkPIo8WVUBcQg0kz2+\n", + "T6Ct86IyqGnDpDFQyiVQgrhp9HaFdKqNqz1Hr5OhrXaRWIkQ+A7tdhUjV8dIu6CHBYTt87A2Br4O\n", + "9QFCHRofluIQvCa4F5EYTN0NH+gGIhDK2t+2Ame+CMNL0B9AVRPpfREq31FdVeLrFZva2ruxnbf7\n", + "+l93//70Zn7uNcC7tURzAc8R1hg/BDzxDo/lqkIpf0ZE/zNY/wxoo7AnCuMvwtQsFIbCTn8zgMCA\n", + "0/scDnoRXo6A4XgYArVIg5aZI+b1IK0qIwsaxb4ijlUlmU6RxsKsOeTmhNJEBT3ej66lSQXQ0nRM\n", + "peMFVTp6Gl+2YEsPcT/AIIZtPc+SX6GhHKKmRpMEPflRdh730VWLSN1j7CjUbwoFnBabEG23SAQJ\n", + "RNUYdM7T0pK0Iz4S7EaVcmBUoaeF4hw2yzgG9CYh50C2lOdsT8BSZpiYpRH18jQTBbKnofLC25jm\n", + "XC9E05e0BQ6HfIJxQt/1q8ozuQRDY+ECvirgGYdyGnbVlPqHC79zcP6/M9g7i9S2pIl0msTrZTIL\n", + "PoVvKaVeZWtfgVOL8GNboOaCaYSGKDINqVUStxXp2ZskjkGvo5O265QnU6RjI2hrfZzrzJKMNkkl\n", + "+lBuhKivcDQLRxUJRBFQpRVYKCwSvmI6PUqlM0Zvw8UebxFLLrGUWA9Fy7QAnBoDHY/AtIloPgkr\n", + "gqV8PDeKpGPoQQfD9tHEA83BNAQdn5LvUtJ8EuUmxWSaTkWIN22izWmC/joHzuuMmgaYLYzgBaaT\n", + "22if8CBdhdw66FnYKyILXcIxAHl45DD84kfAyYLtgbwAW/Jw4urpiYzXoHccVnsJu7fm4fwMPLMD\n", + "9q9C1IPZQTgch6m9sGUBIgnYXYHiFpiLwCefhT/PQmEYBsfA0UF3UwxrEVAarZiJ+DDoNxC/RtN0\n", + "8TQN3zuIVUri9gcYqkFVFfCZAnsa3VxiQDR2+TWU4dIWYUUXskGDKDq27yJ6BN+Nojsm4rUJoiXQ\n", + "6gwWFfcVFCczJc73D1ApW6TiJn3tGDp1iMGgEZaTcwHYSUhpUB2B6Q5wFEqXk49IQlrCAGQjzkzA\n", + "1A645wjE3TALfPLH4Fi/iPzx9ZwdeV/07AohghAGI++2bM4rUAolwpeBX+Y9FowAKOVPi8gZ4AYY\n", + "/UWYOB82qvYXYcaCUk8oCe9tg2i/R0oEo2aQ8DyMHhs/WsSJlXE7TaqiUVgZIZkPuMXoEGg+vqEj\n", + "gY/0BAx4K6x7k6AlyEYcNL1D1a+QZhBLBkn4CsdXuE6DwIoxnoaBehytY9CpWzRTDoG2RjVnIxFY\n", + "v19YvTlL3R7mjNvE7y9TtJpMlKMk4m22uj6LVVjN+ej9A4ihg6yj3En8H0Dj7mWGZmCqBMu7AsZj\n", + "eXKqyLINvZ2A5BwsvgjtF9/GFLebgBc6bb0SELTAtMMAZbNbBjsXOjw2ohFemV/FTVOhnPn/UoD7\n", + "C/h7gRrkH4P205e+34ZjR+EOHcYnoboO+gtEbyoyjk1/DIaUhZ1QrKko6SBCQneImQFoNqKlmCqv\n", + "4iYCKvERHKXQnQKa5qJVFokbMGGaDPk+7SiUomt4fht7Vwo9nWOyNUo9ahHxbPboARXNI2+4BH6S\n", + "ljZEy/WxKvPkYz4DukOv38HRAywvIFbXUSaoiE+86RNfB6/pMNiu0/YszqdXaCY77KrA3Us+AT7z\n", + "YzBh58kGFsdu3ELQHMKa/RTeY+dgz1MwJCJ/0G3ZxVfqZEzk60X4VC9Em0AJjlRDm4mrCAVdrZtu\n", + "R81X4al74OW7Qg5IdRn8FNyowZ55eHEoNIkbaUFzEh5sQvOPofE0VH8Vpm6Csa0+9S0Wq4lRrHKb\n", + "fCJJVO+np9ogG3MotvbjOlPQdPBjffhOAJGTkFoGq8aI5bOdBlFN4Sdhp4K2Fjr+9otPf2WdZipK\n", + "x5zEQ0eCKkryBJ5LrKhRDRxSahndj6Bi/fRaAYa/SCdWZvs6HJiHB++B0XWI29BOhCZ+TgDOGAzf\n", + "J5KMQ/uJDcFEHWoONCOQ6p5vnsD6jTC2DsqAM/dAOhHKwVR+AfKRbhnsqlo9XC28H4xcOfYS3tne\n", + "htTxdYE/B86I8G+VensaEtcjuhey0zB7FH54C+yqhPevhSWYbUFPGvpTsN5rsb2wzkxslERgkCkF\n", + "rCctRApUzrUp/q86tMr0/JZBW3dIZKAfh2LCQe+FiWqD8eYZShJnqR/i8Q5tP0m22Us+oqP5AW7d\n", + "oe2uMJyOMOyZaH6Z3JE4btpBHzzH0mDAkAW3tMFK9SDxKCk9Qll24Fcq1DMzrHttts5FmU0EKFUk\n", + "3bHwhwRpa8SsJIlWjErfJOZKjeMDTRIWqGLYwerrAcUMrJ2GzkNQOweZO0TMMninlVJXVLJRSrV6\n", + "RY4choN3wKJGGJg8D2MVePAaPH0tLkBxFvp3dNuObdCPQV8BvnuZ8a4BX34jY7Bum+SfPAq35eDm\n", + "KpRcBm5PEMehHYOy2OxyNZZ1j0rMJK65tLSAprJItGP0pGL0nj/Pwtg5amYE24eBRpvWvE88A/1D\n", + "DpJUxMw4O1yNuu9SyNTQIj5lv594I0ot4WN6PlHRyOuj1LQe6vY4RnmU4OxRir3Pc3xXk7rhMroG\n", + "yVVoOR7pdVjZCv2PAInQGmZk0eXBKZf2X0DwMZCfgfkesAQaCdi5pDOdmyIen2LkZYty3xpL2/YT\n", + "TBdgMg/budixgRWW2o8thkSO9tW/qZ3rg9KSUqqyYU1swhbiRyD7UzB1ALK3Q8qGI9tg8nlopOH4\n", + "GOTrcOoB4Pvd8/+34MRuWPppB//+FMHoBJpV4GTQINMzRzpTx+pkKDZ34a/GQZ2DXaNQjoE9Dtkj\n", + "6HGfvqjge4qWD/ucMHMRJKAHoaed5pyt04l5ZIM5PEPDS7RRbh/eyxpqdZ3MMWjerrNNXqaxN0cQ\n", + "sfCjRaae8xlNgB5AfxPOCDgJaMch6sKBRfBbocLwc/eF4nvh8a2UckWSD8MTPw4fWAuJvasZaOSg\n", + "72FYuQWGDfAsKKUgKrB9D3gfA759ddft6uD9YOTK8RPAt97tXAulKIrwLeCLhBye9xyUUoGIfA2e\n", + "Pg2nPgeRneCWwf8OzMyB+/PQE4Hh5BKa1eJsNktHdwmcMrrTwvsPSqnHRUQr467ppO+Is6MRCj8l\n", + "GzCTC420xHbY0uOwuw0lDx5J+5S9Mp4aplN0qMUtsijGDJ+0GRBLgHGwQ2QOjIfhyEG4tQl2IsbZ\n", + "qQx+J8qg0aEV6UWtJLGddabH2yz1tkhbilhHkTT7aZWmSNc7qEQnlAQJojTdOFapSexpSHSl4JsG\n", + "nEjA6pdg6Jfgw3tgyIGKCafbIvKnl5Ys3ggV+N5zEJ2HfT0hWVTLwzPNa5Bp667rVx6Enz8F4wlg\n", + "BVQe/jH0Knrd973hOdu9wT4mInMaE/9NhJtbQs5TOBJQMxXTmke/qrHcbyLozGtR1EtD+NYi9kAF\n", + "a9JmZ0TR17LpAKcT8HIE9npw0yHFwgHoiyvaCQ1MjzUvw1CtzarYuLYQCTSa4lJOZ1ljiqDcIdKq\n", + "0HajIBNQmaXaWKD1LDQsaDkwuACmCccK8PSHYUoLv80TNVj5i1BxOLkF6gqa62EAY+6DbDPK+ngC\n", + "vQUQJVMtE98KrenB0BWw7zLz47LB7PDt49GJsBmrbMJ0C/LfvPx25q2w/za49zzMDsNQD0z6cPgg\n", + "3Psg6Ofh6xPACxv0c1zgBHBCRL60BP9zC/0nkyQjLXxpUglSOGcmcactGMuFXVhzs9A7ACyDVAlW\n", + "NSItH8MDbwxED+XW24Dl6Zimi2X246kpGlYBJ57Adj3sSJy+uEtgrJMoN9n7A4uTtwhmf4fdczbb\n", + "j8PIKpzbC8u3QjMDcR9u0GBFwVYLIqlQ6j3mwT3zsHKniDxxsXzWfgaOurD8MYj2Q7sG/tOhOJ/0\n", + "wmICvAHoVzAYgfZ2iP6kiHxvM7Rh3i7eD0auHD8J/Lt3ehBXCb8LfE2E31SK67aW+HYQ6pDkJmFv\n", + "DG5+HpIOnN8Dh3ZD4XHIjkLsYMDucom0W+JEHIbKcGYBeLK7j0Bk6KxH31CDTBuiVmgdcnwYykZI\n", + "ko3noZ2EJQXRNZ/l54u0x1dRO2Lk0lYoiJS20W2fPgVGJFSVbE+AvwqJQ2DrOkEqHRpaJVuY8RaN\n", + "WATlx1FKGDobwa/GaN8eoJvLtPURooFDxIpjrrtEUgFtzSYXwFBXqMwXODICpW9Dz8fh7l64eUOr\n", + "5Fgv/OPnReT3r4R02n1i/RsReZCwY7H6Vts73wqUUiUR+d18OPkxIK+UehtEykvR/9kIo4k42WqE\n", + "REeINJvEt5jMRBTresB63SKyGKNeysFSFEsdIz9gsy2mmKiHRmU1DSQNxpbQ/6Q5FVJRelsOIgb1\n", + "WBRNaeAqtESBmlXm5vUonajBGZWk6fnoxWGCp3yCxjTc7ENa8PMa5SDgprOQsWA5Dc8lYD9wxzdg\n", + "qS8kQk4aUP4k3FqAXWtwZB30LVDrh5QObcOh6fvdYETQlAolikdmiBy0SEVFMiloPLt5a/v4X0Ny\n", + "BDrr3Szd63CN+j8ANxXDpHTvDKx9GLa0oDcKMwNQicHKcaXU6wVKroMZrZPRmxiqQ2ZNZyBQuLFV\n", + "Tgy26aRrEN0K367B+DzsW4LGMOrwCZb2d/jQ87DqgB6F4v6QezbVAjvpcy7aIXBjxLVJfHsYvb5A\n", + "LFUjOtygbUPaBsvwWFuGyl9B9SOQK4aZ2m0vwyM7YSWAD/gwUAyN+wYUNFOQLkBxAIYLYVAxkyM0\n", + "/r0QXD8vIocJVeYdMG+AQ78KgznIZWGHC8s94XHSn4OlAUInietOgfv9YOQKIMIEYery0Xd4KFcF\n", + "SnFYhFXgx4HXeSJ5d0NE+uGGO+Cj5y96XNy4Bv4oPOjAqd+GlV+Dl26AhA3RdZibg7U/AIZFcneA\n", + "VYc+F9JPw8oeMCNhZ07qGMzeAg0dcgrqDdCXYGABNLdOJXICQ8ugmyZRs0JNBWyzY2TbHs2kzfpO\n", + "WKuBNQ1aA7bUHAq7AuzhHFreo9SXptKyUXGLXG2AYt8eEmWT5Mkmxq4qRvoUpfQNTJ7QENehaq7j\n", + "nKtTWoFvToSEuOUYrB4H6zgMfQZuvKQDbKoM/eOwdoE0eEXotlSX33DDTUD3Yrz0hhu+JZjbkiRL\n", + "AbUhRVwUXiyN4zloOsxLls6qUG+uYv/hI+Cl4LYObgvWXLBN8JPQ9GHHacgPwWocxmIhrcY2AjLN\n", + "FieiinjTpxWxqHo2QVExrXWoKig+WEPRj1coYOwuo39mG5qfwusU8CtDFMrH+BY2PStQnYWeD8Nt\n", + "Tqiy2dedk3N9ULob9p2CbBtueRJO3AbOFNR6QXc8ZH4elUhjxyM4EYXNMfo+tkiuDp8swNrdcPgW\n", + "EflDpVT1R07ZW4BS/gnC7MUbQItDtNsN0l8G/ylYuAmKGTg/ANYDUL+srYiIJEfhX42g37+FXN1E\n", + "nHWs+CyFoMyYtk5PxqDzzSUYHAlbWAor8N1iqBi+CmsaHPqJUHT21ACkapAtgjMYsGbEyfktlHme\n", + "FXMcx28iGTAbNRyziorDN3dAvQPrf6dUcEQkWYfSJ2FYh4YJlQCGnwRtFzgeaAGU9bAtP1cFKw1B\n", + "Acoal+lc6p4HFzplTopofwDrfwa3JOBcBIba0NcMH5YmIrD6BeB33sJybSreD0auDJ8H/kEp3Dfc\n", + "8t2D3wP+B96jwQgwCGPq1VbkAOMlSO9UqvZtEfkJKO6E7H7wa9CcgYFPwK5JGLOhZcCR7VAowu3f\n", + "h1YS7CjENPjBGGTL4UXEdKDWhC3TsPKz8KGKRf9hi9k7DIaSARYaS4ZDM+OjYsISimwxfLh/+hPw\n", + "8QdcRk6uUt7vUs5NUF0Zxc0/jbHTImJtQ2/3kGiAaircmE7f4BIrHKI0lsAWi9rZGvwRNF6Ao9sg\n", + "+VkYGIedu6D4b8EfA235tVOkvfLH+7iAYMnBvbkPd7nKyriHmUuBC8v6FhZP3of6ewuMb8Dty0r9\n", + "RshPSn8WDtRC0zYlsK8Vtpg/m4IgD6ezkFKwkADNUZjrLW44CS/mYP00xAcgmISJFuztq7BW/SEz\n", + "X+ghot+E0UqiqxJu3MJv3U5zvoKTniH/LaVUXWT8M9BzSfainIEhBU4kfD3chMzTcKgHSgp2WpCJ\n", + "5TmZbjE3mKHdUkRVg/HpJh88CgPt8D2MQe0DhIKJ7xBqx+DcPXCgG2gNFSH9BDw3DoX/+0cFSjHY\n", + "vx2m4hgqjm4DDBNvt2gnwG2tECs48BdtqK3CEKHOTKHLO8mC2gIL3wC+A/l/AXv3gJeA80GAajj0\n", + "p3TQl1nDxRCfQG8Q15vkVn2smVD3ZLAF5v0iMV0p6+lQB2RuANBg5xdhKAOxWGgGGHVgrg/GnFAB\n", + "Xu/AoQkoHN/Ip3k9KBVMi/T+FThfhKk49DfCY8D1YXgBem8VkZ43s69rifeDkSvDF4D/850exFXG\n", + "3wG/IcJepXj5nR7MJqATunJeilocvCK8IgZ0uvuDSOpjcHAC7py/uH1PBx65J7xYxKaAFCxGoH0S\n", + "Gi3oXQ1JdTcX4bm9kIzD1pchbgunfB1lBfQmBenAQjzBOsOojoObKmP6TYIa/O0eGCzWKMzGKGVr\n", + "OJWjYNt4JwL8uzJkulkNUWnMOVgP+rGsBdTDJVoPE6oyBoBA351w5wAcmA0DsUYEvnkrvLAX7tjw\n", + "JLqShvUyV8l/5r2D4vdb9NyVYjTXQ2TOoRKJUtcGWKnejfpBCpxUeIWfEBEdKENlBvK7wpKIIpQj\n", + "P98LrTmonIboXkgCNQuq8TAFv56Fsy/DthYkBuCuM5B2oNADGbVGsu1xKldDVAPd0uiZj4AUmds6\n", + "hFucCXkddbBnYX4LbN+Q3dK9cFnTG56mC5PQF4PIizCxFOWZjw5QiYbW9c7cMr39FwORC5gsQWYv\n", + "72gw0nwWDu8HbxzGq9CKwok05L/9RhmbLGzNgaPhdFyciEnEAcghaplazKSCDZVuhuGVzGFS5CM7\n", + "4ROThO1h58FapP4d8F1w9sL+J0CL2EzfqdOOKHq8Jba4iqG6hx/xKSRgpQ9+4R9DPkgjAo/8tIje\n", + "UEqdJjxfERlehriCZQ/6HOhLwDJwpA86JnRWoP4NqF5B51LlIah8AYwaNAwwyqHy9Ok0TFRgZQR4\n", + "3WBERHoIy5+la2Wo934w8iYhwjiwm3evw/BloRSOCF8C/g3wK+/0eDYBCzC/DrP9sKN7w+0YcLwH\n", + "8v9w6cYiYkLvZ+NUki5PRT12rMJQE3aU4KVpODoauoimVuGmBdgeg0O3hbpYwxVY7IG5rZBZBl+F\n", + "CYftizrnxz3cREAh3UdLTZGtmehGBG9lHJejRPUW/otw7O998JpwZwE+YIBRh4JFPdHBzCQwW4pA\n", + "HBrZLLWzTbxl8B6Fkbtg4LNhHXrFhZ5BOPjSxYRH2oGDL8CTB8Lsz1A7rLO/HMDKn22mSNm7EUr5\n", + "p0Riv71K+VeiRG8wace20Vo+gPXQMBQAVkMyQH6D4d/vwJP/L5R3QToNjTjMAs0HISmgHYPWLugt\n", + "w5YGTMdh7VGIN2BbBhwTst3AYagCq5Owu2GxFFFkZ6MYtkMn49PsqSHpElhAt6Ol+DA8+6sQDMBE\n", + "OQx2lmOwfAZKsfApG6A+AUUXdi4YzPbvoRpMkjvuoHp6aOV78QZP8MRtDX7q8YvHTisK/lUv0VwJ\n", + "umaFX4LKAcjtDk3xysUc5NIin2jCSaXUZUUo27DugJ/GKbUo9Jv06hEibh07ZrHqKirfvvT4F5Ed\n", + "B+DT93WtAQDykPo26vYlFl34oAMDHShFocf2seodRgwY1YSsr2iyZLMsAAAgAElEQVQ0w0AzeSYM\n", + "RCA8Bw+UYeWjbOhSgvx34PgXYcu5sMW3vxfEgehTsPUYzCVh5fwVipadgaXTMLMDpioQCCykITIN\n", + "nTYXyzqvgoikoe9zsGcXJAMouiKx7yllHb6Cz35LeD8YefP4PGEXzXVlu3yV8J+BGRH+nVJcUVfF\n", + "9Y6ukd5X4MGfg5PjYYfJCrD6XXWJbLmIxAbgFwdo39pHseWyziJnb1zhwPOKm1ZAcrA7D/ed0Hhh\n", + "spfDt6XxzTZ+qsbjcYuTDQgq0F6FgTthdgJuWVcMrQVIJsJMkOJcbDd9nomrFO5qhsSsIkKO0lgL\n", + "V20g4H2vSw41lFKWiDySZ+XfJSindJAIVqdGMDoPWaGvV3HfHGztprAPT8LqTdCehdQGQuCuAjzx\n", + "Mjz6ndBevV2E9ptK/f7XCXt5mMKJLDRsWLXCx9cmwBz0PAI3B7C0ReTflOAQcBgW/ido/T8w4EH0\n", + "NNxyNNS16dwOH/06NA5DdQqCGIx4MPccJO+EVAuqG26IQihj3jaa5EoLNDPjWJksTjqKZ5RwvCbs\n", + "iIQ1voJSallE/ggqH4H4TvAqUPxL8Nbhuz8HY+NgqvDeuvsETFSzPHnnKMmaICh8SUO5l3a5l8pI\n", + "g7U0jDZC7YoTvVC4ynoiV45up9MTIvJ0D/yTXfDJrdB2QT8N9yZFvttS6jX6MQ04fQL+2TAM5WhH\n", + "67QV6HYJ1TIJHnEuo5WSg08OwtZzsFsP+2VnhqCwC/qWWHkEDu2DZi9YKSgL7MtDwoPzacVSHTwt\n", + "VFHdeklZdKAJ5sAl32tJRH4P1j4Go9ug7wXoWYCt+XCL4RTkPwocu4K58kW034Ol/x6CAHQHRlfC\n", + "NuLjitBI+FUQEYGBn4V7xsIHLY0wm/PDz3eV0mfe7Oe/FbwfjLx5/BPg37/Tg9gMKMW6CF8l5I78\n", + "2js9nqsNpdR6eLLnR4Eo4dPsazQS4nD7rTDVj3usjNoZJVPJ4RkuRw8U6G1AwYR7ivDy8HZOHNhB\n", + "shrBaFqIX6PYP02hWlbqb0WkD/KT4Wc9PgD9ymKtrXHSG8DzdBoZncxanPgyCEKASSsClROXjNuj\n", + "6wGilHopKvJ/WbQ/3wN3JiErsHwAynNoN59jJrDZ2g0qthVgRYf8FkhtuIAs5SA4p5R1iPDm+T5e\n", + "ByLSsw3+u3uhMw6nPDh9BA48BB8x4CUbdtwAhZth0QP9FHz2KOwsEZ+HD74ABzbchJ7LQFqD4jCM\n", + "L8BAt5QS7YGXUuAugpaDshfyTVJuWG0LOiF50iifJaugvM1G8ywsPQJH74fnH4KfEpEZpVRTKbUM\n", + "/NVlvstvwcoYoIP0wMQXwBUNL2ISb/k4EZ2a0w/FOO1DM/j3wTMTMFQPZWRWHoXguinharDnRrjl\n", + "43D+Qu5mBxjfhPtFZPpSRdg++OhuyOcgosNoB3rO4MdW4est+M+XdgqJyOQE3D8C+ihULUjm4YMu\n", + "vJAI629LUP0dKHwSRqtQD0ANg6nBLcchWYfDYzDrwvgl5c+VLNgLXIJud9hzMLjvIi/mAvpboI9d\n", + "+Uypl2Dp6xDcA+MKziRhvg4rX3md1t5RGJuE/RvGl3bg1gqsfhh4Pxh5p9Et0dwIPPROj2UT8VvA\n", + "MyL8B6XCp7/3Erpp2MuQNy+iF27bDYUkvt9gddjC7dVJOH20cgW+uxXyX4fSwSz5bZPEmhGM7glt\n", + "GTcRnKnCPhF5sHth+WNo/xjEd8DpJDS/F9D8Sgd+tof2Tou1XTa5HtCVQ9VoUT8DPP+jxmcr9WJS\n", + "ZHAbJG+ExWFoTmPsnSRbarM2Nc/KufBptrcD5hxMb4Wh+VChcTkDz2Uh/7dXaUrf00jCrftAH+8a\n", + "wBmg7oAXOrD+GJz8KHgf3vB0eQ/MN2BXCSMFuUts3DO1UJqjJ/Hq3+dTUJsHuwBHvghbTsNzN8GY\n", + "Bp04rKzB3PNgrSRQv9APCwZWYxfuiZ2EjttT0HMWJuH1+V7dMlKXnyDz8PIWqH+ghbhF1sZztGrb\n", + "aD4bAc+Bjo39FLz0N/CSAKvXW+asH27dGfZNv4I4eDuAMzDFhq4wERm6CXZ9GI77cKIGGQX0gv59\n", + "KDaVyl+6/yH4zBQstGDSBN+EThTcGdh7PiyvrED9GEw3ofhBCM5CJR0uQ38W8v0wU4Tat+DEEBxc\n", + "Cc/BpSw8l4bCV1/nq5UhT8hLM4OLv17MgfOaAOaN0L3mfT8McqZHCEsz8z9CYyQFPZcp1/a3wOy/\n", + "0s+/UrwfjLw5/Dzwd+/REg0ASjErwmOEEvHXXdvXtYDqalHHwNmH9USBpeE6kf4obgPUfwFegpNb\n", + "DfhQgr4lCDSbZiZCqTEU9saOEGpulLvOo18SkSTgK6UsABH57nH4lZtpHI3SiDQguQBeDf70zQgR\n", + "5WDHPpgfCFWXSOJVV2nFs5hAIRsGIxDu9ul5WB0CMwqdPBT+RCl1fjPm7r2GZKiq9Rpl2j5w07Br\n", + "/DItluPgHaXpOawlYduGp/PtRXixDSoGIzoYAZwZhJeaYB9XSrVE9D+F0qdD8bKTWfDOQe17oE4q\n", + "pewRkf5dkJ4INcg34jLk7NeHCq3lvyUiz7XDXPxPDkLdCj14hk9BfA2+rpR6XfG46wCX5Te9Dukp\n", + "09eVl9ch6O3aBSTAMMPOmVdBRCJTMLYNFk6Gi9UzCi0XtAUYmIe/V0pd0Oj4YdcINgZkIH8XaOPQ\n", + "OA88ArTg+Xtg9oPhOdheheI3lFKvKZHABV5M9ml47COh4V3OhsUsHMpA/m+ubIpetd8KP4KsugEl\n", + "yEs4XRtDveUcdGbf6ue/WbwfjLwBul40/xT4Z+/0WK4BfgP4qgi/rxTXnULfZqMMz0/D/XfDfAS8\n", + "LbBUwVk/BFngmFLKFpE/8TF3VqntSCBWBntxCveUFqqQCq/1Rmld8npJRP6gDHclYMqGwjo8rZSa\n", + "ezNj9KDehLEBaC9B9lmyu6uYY03MJJx3Qz2JZhROV8D6CizagHmF5Lf/6tGAxXW4YeqSi3gBDBvm\n", + "WzB66XtaoPmol+DlNGRGYM8a+BqcHIbSQ7A6C7O3gmjQfAlKP7xwfIQGjzJLKF7ldoOGV1CCQ3Pw\n", + "uckNT/0NiJwPyZVzV/r9uoq7ayKmWif538bRB11Up4XzA2hdNyWZy2Edjp6Bmya6whsAHTDOAgou\n", + "DbbLxVC441W31zXION3s0iXYUiB326PklMKVdUoygGVGobkELzcvMUjtqry6hMHp1y6zv0dE5DHe\n", + "9DlY/wEcrsL5j4A5BNYirH39zV4f3g7CcnbPEXjyNjiwAgkHFnrh+SiUNl1ZeVODERH5beAgcERt\n", + "cPAVkV8mVDF9Sin1i5s5hquAg4Q8g9cQo95rUIpnRVgCfgb4y3d6PNcaFhw+Aje0YOs4WC0wTwOL\n", + "8FcXLiRKqZqI/GYZ94s3hiSAZgvMJ0MvjzelVKnC1PBb0nUpwLMvwS8nwX6c/ruFfUGS2GwJZxCM\n", + "GDz6Kah+GWrf3qBmaYtIBszdEElDawE4fw08ZN616MDx4/DhLAxsh2IAchKGz0DRgn88Cf98MpxM\n", + "B6AAyelQyOElWD4FD38Cnt8HKoD6EagehcgYFB+Dzhwwd2kHxyXiVa+CC0ePww0W7J4EqwPGadCW\n", + "4Gtv1SNGRL8BbvmEzb2HbNJOSFZ9cQye+Wmu4/M/gNMn4UUXbtkKlgv6GdDn4TtdEb5XoJQq9Yoc\n", + "expuOQjLcfBWIP08ZArwqnKJiAzAjl+yuPG8jz3VS2y9QyVV5yV/O5V5C069FeG3bmD5et0rGjAJ\n", + "iUlwO8C0Up1nReQQoF972fbqt+DZEszcA3osPFbzP3i9TqWrCdmsjj4ROQD8C6XUr4rI7wNfVkod\n", + "7v5fH6HZ0q+/XjDS9bS6ohTkZkCE3wXWleL/eKfHci0gwseAPwJuuNbibtfDmouIAezMwVYbGp2w\n", + "ZfA1yqS6yO5huD8FvRa4FXiyAY9fi4tHQuRDaeSXAvbv1hmpNzA6bbY/B5k6PL8FHn1Aqc4zG77T\n", + "Ntj6i7DHgKQHSxGYmYHSV6+HjMn1sO6Xg4gMDcBnMrA9AFWDE+XQhK0WFbl5FH5qnJA4tAidJfhr\n", + "pdS5De/Xw39F9sPUT8NuBREF50w4dxhq37w0A/IG49GB7TnY7kC7HR6bb9knRmT0X8KPJy6W9iBM\n", + "0X9tHE7+J6XUpmrPvJ11797Et2Zhlwd2K5yLy3YCioiZhnt74a4IGE0o5uEBX6nZV2+X/RR84i64\n", + "MW8yfXOa+ngCUQ0WcgEnv9+A31ZKXTU+XXit6fkC7LgJJl3o6DAdwLmvKuWffuM9bB7CzpqrHwz9\n", + "qDXfzMzIB4AfdP/9EHAXobzuBeZwehM/+6pAhCjws8Cd7/RYrhWU4mERzhNyR/7wnR7PtUb35DvF\n", + "jzBcA/CVmhaRM0AccK7lE0xbqSdFsoMw3oTJQqhbcUFhts+C5Cutg6FuyvjPwWfqoQokwE1AameY\n", + "juWpazXudxu6Gaw/E5E4EGwM3GyljonImTnYQlgqWeym7De+3w8VPCc+Bz+Rv2j1vhd48HZ45jRw\n", + "8grG4wNnuj9XAfogDFxC4NSAXkXIfbpuhfC6QdzZ7s8bbesCPxCRhwnLYJ3L6+rEh6CnBYbvsvdI\n", + "mfqZMu1k2IE080OlnKtM7Ddvgf374CNzF4tIO2LwDz8jIv9Rva5Pz+ajOz/XNCuzmRLQOS6SvGrd\n", + "1+82fB44ptQbH/DvMfxvwP8uQuqdHsj1DBWife1TqQDtc9BphW2iG6XuCzGob0ypjsOW2MVA5AJu\n", + "LEDvHddkqO9yKKU6l8sgdX8/o5Q6d2kgsgFb+f/Ze+/4OLLrzvd7qqpzowMaORIgmHMaTp7hZEnj\n", + "0UgrybKsMPKT5ZV3V2v7eT9rrf389Lwv2ZL8tLZ318/yyrYkK1hhlEZhcuYEZg7JIQmCIBIJNBro\n", + "RudQffePaooYDjlMAJoA6vv54AOguqvu6b7dt86995zfoUc/54iANeyuSEDD5tmx+HIpDsJw8K3H\n", + "TIGoxuUFPM4rlFKlyvf1ItsByQEYmzbmBVLQNAqJDBRnwTGr2worYm+9DYdz0OXAygpaVMymM5IA\n", + "ApW/g5wX2MdFg5/PISKfn/Zz5wzbdzn8G+C/VaHdqqIUr2OtZi006fsFROlNODIJbzRbe/2mwOFG\n", + "OJyA4vQARAH9AudrZRA7gH320UC7wFinla1y9NVk9Bkr3XukskqddsCLnXDmtauJjZj/ZPbC/oJV\n", + "BbiMlWK7txV6T3MZKzBXjuhvr5kFlc/LoqsVNZuD0U7gd7Bqn9wN/MN5j19yr1Ap9fmZN+vyEGEj\n", + "VuL4jy/13AXK/wocEuEbSrGn2sbYvJWKKuv/gGfuh11rQASmjkDsF+ct7w7DUAkSLghOm90fb4D4\n", + "s3Nt9yLkFPQBG3RwTQsYPhGCaBVrvYBS6qSVUjz5AHg7oJCHiSch/Xw17aoWleD0v4fH3wU1S8Es\n", + "w9RemHxydoK9J/ZA74NWuYmzpB3Qr6jowiwmZi2AFUBEvgxsBvYqpf69iPyVUuqzIvIg8B+BpVgZ\n", + "NR+8wLlVDWoT4SvAgFL852rZUG1E+E0sRdYb5kIIrdp9Pl8RESeAukhBKxHHWuj5MKwpgS8PQ344\n", + "dAZGv3q1mRgzyULvdxHfHbDsfliZA0cJ+v1w5CjEvvkO2ztzaJ8IVsZgcS4zrK7nfhcRF1ac0Kz1\n", + "j9VG/SdgdSd0pCDrhCNO6P2RUrnXZqvdavJOfT6rzsi1UM0PqggtwBvACqW46mj1hYAIX8UK+vqY\n", + "UpfeWru2tq7fwWm+IyJNULMe3CGrumzp8PWQSQOLo99FpBNCa8HhhugR4Fh1Yo2uHxZDv18KK8Bc\n", + "Wwm1K6CYhsQBZcn6L0hsZ+SK2+aLgKEUv3fJJy9wRPBi1TH570rNbvyMPTgtTux+X5zY/b74sJ2R\n", + "K2qXCFZBoA1KXVChb9EhQg9WCui/UooXZ68de3BajNj9vjix+33x8U59vugidi+DPwS+bzsi51CK\n", + "XuAR4F9EaKuyOTY2NjY2Cwx7ZeQtbdIO7APWK/XOFV4XIyL8J+C9wB1KkbvU86/8+vZMaTFi9/vi\n", + "xO73xYe9TXPZbfKPwJBS/MlctjtfqBQN/C6WhsynZjqg1R6cFid2vy9O7H5ffNjbNJeBCFuBB4C/\n", + "qLYt1ysV5+MRLKn/f11da2xsbGxsFgq2AiMgggF8BfgPSjFVbXuuZ5QiJcLDwEsiHJzNgFYbGxsb\n", + "m8WBvTJi8XtADPhGtQ2ZD0wLaP2OCM1VNsfGxsbGZp6z6GNGRFgPPAXcVLnJ2lwmIvzvWFL/dyvF\n", + "NSsV2nvIixO73xcndr8vPuyYkYsggg/4DvAHtiNyVfxnIA3839U2xMbGxsZm/rJoV0ZE0LEyQ+JK\n", + "8Vuz1c5CpyIStxvLofvBtV1rfs2UKjU9lkPdRtA0GD8I5TcXu8z3lTLf+n06ItINtZvA4YHYISgd\n", + "uliNIJu3Mp/7fa5561gjOsQOzMexxk7tfdu10YC/BlYBDyiFPXhcAyJsA34GPKwUL139debP4GQN\n", + "DoEHYeXNsGLKKgXeG4TDh2DiW3NZcGy+M5/6fToi/rtg+T2wKg2uIvQH4Y0BiP7j9VL353pmvvb7\n", + "XLOQxpp36vNFl00jggMrc2Y58G7bEbl2lOJ1ET4KPCrCQ0rxSrVtmgPaoOsmuL/fGhwAlkxAeQ28\n", + "vBw4UkXbbGYZEYnAyrvggUFwVW4GnXHQOuH59cDrVTXQZiHRCl03vn2sUavhpQUz1sxqzIiI/H8i\n", + "8ryIfPm84y0i8rSIvCQid8+mDW9tlx7gRaAWuFcp4nPV9kJHKX4JfBL4iQgfrQikLWA8XdBdOjc4\n", + "nKU7CXVrqmOTzRzSDl2cc0TOsnQC6jZUxSKbBYqnG7rNhT7WzJozIiKbAZ9S6nbAKSJbpz38R8Af\n", + "A/fB7KuditAuwl9iVZ/9Z+C9SpGe7XYXG0rxGHAP8DngRyKsrbJJs4hZAvMCDldJB9Neol/4mFC8\n", + "QP8XDChfc2aZjc05ykW4UGhI0QBzwXzWZnNlZDvweOXvJ4Gbpj22Vim1UymVBpIiUnOxi4hQI0JI\n", + "BOflzrZF8IqwWYTfE+FxrHozOrBGKf5qpmXMbc6hFPuBzVhVfp8Q4QURPifCu0VYLUKnCI2VnyYR\n", + "mqps8lVSOAZHBdKOc8eKGrzpgcmD1bPLZo7ogxNFmHSfO2QKHA1BdFf1zLJZeOSPwbELjDVHvTB5\n", + "oHp2zSyzGTMSAvoqfyeA6ctJ+rS/E5XnJi9ynT8FPg14AU2ENFY6aaryOw1kATdQA0QqPyewtmS+\n", + "grUSkr32l2RzOShFHvhzEb4M3AXcjyUs1wl4sPoKQAEFoL0adl4LSqlxEfcP4UfvhWVYfn2fQP9T\n", + "Sqn+KptnM8sopdIizu/ATz8MyzRwAf0a9L8C5QWxh29zfaCUiom4f2SNNT1Yt88+gVNPKaVOVtu+\n", + "mWLWsmlE5HeBqFLquyLyfqBVKfXXlceeUUrtqPz9I+A3lVKp8863Vy9sbGxsbGwWENXIptkJ/A6W\n", + "lsfdwD9Me+yAiNwIHAQC5zsiZ5kvaV8iorfCH74P8nWQOXv8KDQ8AX1Rpb5ZTdvC8IEe2NAFuSJo\n", + "b4LRDz/JKPVqtey6EHaq3+JkPva7iIS64P/aCp11gBPMJDiOQHkPfCmn1DPVtvF6Zz72+4XwiNx8\n", + "B7z7Jhg4eywP+g+g9Sh8SSk1ea1tXGwc74Mf5ZSaN5lb77TIMGvOiFJqr4jkROR5YK9SapeI/JVS\n", + "6rNYlXG/hrVk/6ezZcMcUt8Avjp4y4euB6IvwyoRMaolTqPBqtWw8W44eTZAaBkYP4QHReTYTHxR\n", + "bGwWIUuaYPVSGHVjlUIIAwVo7IWHANsZWSTUwoZumJh+zAXmEuCotQV9zWOsBqvPH8d7wPFDeEhE\n", + "jiul5n1m6KzqjCilfu+8/z9b+T2MtVqyUCgVeXtwbQH0shUGXa6CTQDUwaZlEJ8eqeyF0lKQY7CE\n", + "Gfii2FwbZwOz7cDqeUWDAcZZR+QsPsgY0FIto2zmnjLkC+A//3hFwGpGJqH1sHk5TE4fx31Q7AHt\n", + "uDWO75uJdqrJoq5NM4PExmC4F+qmHzwIzQl4XSlVNWcEQLjoTW7eL5HOZyoZRY9iDVj9Inys2jbZ\n", + "XDaDUSglwXn2QBkYAG8ehqpol80cMwavHYZac9p4Og7ePsgDMxZgepHBWl38ofnFolNgnQ2UUkpE\n", + "vvc0PDIAHWHgNHAS+qeqvFw7DvuOw+r2aasjWWuvEaC/WnYtdkQIA88D3wN+E1gL/LMITUrxhaoa\n", + "Z3M59E3A3pdgZRsoF6hRkDMQz8JPq22czdxRhsOH4ZUU3LAEVA7kOBQG4Z+VUjOSxRmFvcfhw23n\n", + "jeMnLGekfybaqDaLsjbNbCEiTmCpgF9BDOiv+qqIiBGGDy2Hdd2QLoDxJjhOwE+zSu2spm3nMx/7\n", + "/GqobMv8EOhTit+fdrwVeBn4rFL8qFr2zTXztd91kZWd8IkGCOnWTag4BIfH4GszdRNayMzXfr8Y\n", + "ItIi0KKsrbveio7WTF3bqIVfXw5ruiAzbRz/SVapeVN+47oslCcia4C/A0zgkFLqM+c9vqA+qNVE\n", + "RHSgOwwripBLwWGl1Ei17TqfxdLnIrwf+D+BjefXRhLhRuDHwBalGKyGfXPNfO53Eanzwho3BOPQ\n", + "V4ajSqkFo4o5m8znfq8GlXF8aRiWX8/j+DtxvTojv8owEZGvAn+tlNo77XH7g7rIWAx9LoILOAZ8\n", + "XCmeu8hz/hTYBjy0GIJaF0O/27wdu98XH+/U51ULYD0v1dUDdtE6m0XBI8DhizkiFf5foBv4wJxY\n", + "ZGNjY1NlqppNIyIPichBILeQZG1tbC6ECA6sIoJ/9k7Pq2zd/DbwZZG3pwza2NjYLDSq6owopX6s\n", + "lFqHVSzv3mracjmISEBEakXEXlq0uRo+BvQqxSUDh5XiZeBprArXNtcZIuISkYiIuKpti82VYY/j\n", + "1ydVS+0VEadS6mzw3hTT8vWnPefz0/59Vin17ByY9jZEJFQH710OPU5gAiZE5EdKqb5LnmxjA4hg\n", + "AP8J+K0rOO1zwD4RvqIUp2bHMpsrQUQ0P9zRCbcHQZ+CckDk+SQ8p5Qyq22fzcURkXAdvHcFLDWA\n", + "CYiJyA/twpbXB9UMYH0I+AMswZaTwG9NT4O9XoKbRMRogn9zOwRWwqgGnIaapyF4HP6rUmq02jYu\n", + "FK6XPp8NKoJmn1KKO67wvM8DK5Xiw7Ni2HXAfOp3v8jtG+Fdt8KgB0pZMF6Gtr3wRNKuR3NFzGW/\n", + "i4ijGf7t7eBbAWMaMAyBZ8DfC3+jlBqfCzsWO+/U51VbGVFK/RgrhfF6p3sp1K+eVgSpGZIbwB+F\n", + "rcBjVbTtHRGRlgjc5oHOAoyNwQtKqRPVtmuxIYIO/Anwu1dx+heA4yJsUoq9l3y2zawhIo4OuP1m\n", + "GPJUZL49ULoJhgbgdhF5adpq7+Ve0+OBbbWwBSjH4PUc7FZK5WflRSxeepZBZNW0cbwVptaDf8x6\n", + "739ZRdsuiojoTtgYgRs18EzBgSS8opSaqrZtM42twHoJBAKRCxyPQMoDTXNu0GUiIp3L4VNbIdcM\n", + "iRg07YFPuUS+nVdqf7XtW2R8EEsE7+krPVEp0iL8OVZByffNtGE2V4THB07fefVovFDyW/F3XuCy\n", + "nRERcTTAxzdDxzIYUyBvwnv2wQoR+Zq97TNzOCAYuUCNsFpIe6G5GjZdDkF473q4YQ2MuSHfB7fu\n", + "gnUi8v9frNr9fMV2Ri6BgskL7cNEoSYFB+fcIKASeCVYBblqgInzt4ua4IFbIdlRSZmugYkQpCet\n", + "ar2HgDZo2AHOViiOwuhzSqljc/5iFjgiaFirIv/hGjRD/g74jyJsVGr+F8SaL4iIF/w3Q3CLdcS7\n", + "K0GmmABX0Ko7AkASnEnLQbkixU0NVqyCzhunyXnfCqfSsGwcbhKRGJCohrCViOgLyRkqwsQo6Ocf\n", + "j4I/CbtF9FXQeCfoEcj3Q/Q5pdRliw6KiIZVGWTG4h5EpHkdbNkBfWczTTbDkAntk7AZq5zE2ec2\n", + "ABEgBQzNpB1zhe2MXJr+PhjaA63r4LQO5VNQuw/KSdh9uRepqOd16RAxIQGcuFKlRhHxQ3AHtN0M\n", + "ah04s9ByEhJFkdoDMPkDpVRRRFzd0NbBWxU8Q5CPgGsQ2QKr3gs3TEFTDKIh2PVJEdd3lMrbN7uZ\n", + "5dewZsu/uNoLKEVWhC8Af4y1ymIzy1ilHRo+CduaYOUolAXevPM0Ox0vEK+5FQZDkI+Daye0jMOP\n", + "r/T7HIaetvMcmDw4HBgrnDR0FVjdC1FNpP44jH/naiXmLaeKHgGXsspmDV/sZiXi2gB1d8GSiEhL\n", + "FMafUKpw+Gravc440QsjDdC6FkY0UP0Q2Q+lNC4N1n4cNscgEoPhdnjt0yLy90qpdwwcF5EIRO6B\n", + "jrWgSiLB12Dq2RkqB9DUAWp6ymsMPDnwuuB+ETkCxCH8MKzZAE0KJgUGh0Tkm/NtK8d2Ri6BUsoU\n", + "ka8/D/cdhI06aEkYGIWfKaVil3MNEfHVw8eWQnuTtS+s9VoZOf+glJq4zGs4oPETsL0B3I2WE5x1\n", + "wfEuuO85OLAeXokBTwKlIhQyYHinlbAuAxnQoOFOuH0cmirLfO0J8Och9i4RObiQZkTVpFKD5nPA\n", + "/zMDSqp/D/yJCO2LRSa+umgrYHUzbBs4d2z7oCLZuZcX95yBbi80ZCATgx9m4bUrbSEPyQw4ph87\n", + "gWNNmkidyfpX4MZKP7++FF6+H6ue0RUhIl1L4KPLwOUBNQBaP+wVkUfP/56LeLfD+ofhhjFoGIAz\n", + "fnjlYyKubyuVn9dbu5Vx/GvPwX37Yb0O2hT0j8GT0PQI3DUEvoozuTQGehni9wFfudg1RSQA7b8N\n", + "Nzth2RAUdTh4M7zeJiJfnYFxNDfdUz0A7eOwKQze9RCPwr8/gR4rsKkObj11TqnjjSZ49v3AP15j\n", + "+3OK7YxcBpWCR4+KyGOAoZTKXMn5IbjnRmjZwrn0zDaofwA2RcYAACAASURBVNKKAfgfFztPRHyg\n", + "LQOjBmiH9nXQOgTxRmiYsHZqMmE40QybRuDozSLytFLKrBHZuQd23Aynzn5ED0JLFE5AoBuazruh\n", + "hXMQroehEFZ8g821cwcQBn5wrRdSiqQIXwc+g5UibDOrhLqh9QKz27acSTA5ROILgBtLsPGqbjop\n", + "OHgYdiypbPsUwBjH1T2CN2nSkIXTTeBJw8ZhOLJFRH6hlMqdf52zehnnr3aIiLMdPvJuSBkwdRJp\n", + "aEQMoXznAegD9kx7rgHt98BtIxCsbEE1peA2E6L3ViYpVS36ea0opZLA90Xkp4CmlMqKSAvU6+cc\n", + "kbN0TIKnc3rZkrfj2QgbvLBqyPrfKMENgxDrhOgSEZnAiivMAQOX8zkREW3a+9x3AtLLocaA8jhs\n", + "vgGSZ0Bvhd0BmPgOjl8/ieM12NMFoqBtHFafgUM9IlJ7uZPd6wHbGbkCKpHyVxot7+iEzWut5dFf\n", + "sQyi+2CJiISVUpMXOG+J0PTHLhqWg9FUJOU1yedgdACohXwWHHmoLUBvBDynwHBg9WkhBc/vhshp\n", + "WN8E5gRoQ9A/CY9C/rOQNcAz7UtWEsgorC+OzczwOeDPlWKmVpr+K/CSCH+mlN1Ps0suDqm3aR9B\n", + "ygH5ROXGclVVWUXEjRXrNXUCvv0o/KsOMIrgOoZ4Y3RNgtoGZQVjAgyDMwq4mPb9FBF/CO5st7L6\n", + "pFZk7yQ8o5RKVJ7S2QnuMcTYS9NWRZsmGKrAqNvN8KdF5Hen3fgCEHSdc0TOEsmCP4IVnLsgAibP\n", + "y1TKQkqsdePpGyJJF5Qy8E7f3WAXNCbffry5DO5fg846aCtDWuBUXES+rpQau9CVRKStAe7tgO4W\n", + "ETUBO4HHB+Hrj8Fv+mBFN9QMgvLCgQaImiAGelhj9K4ya8+AAg4LBA+At4j1eZk32M7I7KPpoDvO\n", + "+1Br/OrNf1sfiIhuEPk/6ljeWoPTUPhyBUpqjLH6HLEM+FthPAzOBMRS4OiDgTBkBs+mFlZ+f0dE\n", + "njkEtUASGFFKKZHAK7D7Dri5srRXBva0QWzPTJa9XsyIsAVYDXxjpq6pFMdFOIAVh/LdmbquzYXI\n", + "vAGH74JOD9RWVkiiXjhShtxVxVBYcWP+HdB1KwQ1SJRLRF/oJ/XFfmgFFHjaoS0MXVHrLIW1FTth\n", + "YolDnr2WoxEeuQEa1lixbOoIbNwJS0Xkv1ViFgzAsY/GDR42pAxcJYACEccYrqVwdBVw6OwLhnQZ\n", + "8jq4po1VaQdkSyzQSYpSalKk7k3Yvxw2DVtHTYE9zRD72TsHgmbHILHE2uaezplGWNICH3gdjMr5\n", + "/bXwy4+KyH95+/aYtCyD394IRg53Vxp3eBTzrl7K782T/rNh+JITPtAFmU446q0ET5+C2inqncKy\n", + "LPRUJrQdGry4CUb2Ms9WuG1nZJZRSuUbRHqPQ1sR9LiVAVN2w0QMJrjwB2adh3B3PcGhHPk1Gp6M\n", + "m3IujLt+lLHOMmsHYbIB9CQMNYI7Ai9lYPRbF2h/DDjPG08+Y63yDW+E+jLENDh9BOJXHWRp8zb+\n", + "CPhSpc7MTPJ1LFl52xmZRZRSMRH9n+HRD0JbBJTAUBZOf10pdZVFPf23w6a74ZYBSHgcHO50Uvp3\n", + "efIrSxT/CTDAPQH9QXD7IZSFuBuGTVA5rH1ZBaDB8hXQtGWabsZ6GElCR8xygncDQ70QctPsOOuI\n", + "AGQo+Qt0n4CJrVScEaVUTiT4Krx2K9w0YN1Eixq81goTT1x8q2IhEPshvPQh6FsK4bKlbXlmJ2Qv\n", + "UbYhsceKEWnyQl1l6/5kLQzUw72vnHNEAJZMQEc7nG5nWvYUQARu2wik8a8WWss1eMb9qPE4sWXD\n", + "BH4XTn+xCOPHobUEWgsMLoVYH+7WEg0Jk0IWJgPgS0PeBU4/TBy/Us2bamM7IzOAiDQBQSB+IUXW\n", + "KDzxNHx5FbR0QiILrjfBOQF/f5F92IgbTVmB1OfE6gwcBYO0p8CAglgG4nnQR+CEE8b+9mwKoIjU\n", + "YkW4JpVSZ86/eCXq/3si8gwcCQFTSqnozLwbNiJ0AHcBn5yFy/8A+C8i1CuF3WeziFLmMRH5Cxhs\n", + "w3IChq80Y+YsVgB65+1w0yAMhVvYeVMnghu3Gcf44BjF4DD8AAJJcB6C3e3gdIJrAjpfgwE/RHUq\n", + "Whk10NoApRMQKYCzHSb8kG+CdAA6sYTTkg6RnV5Y66CQ19FKGUqeKM6kInIKNMdbrZx6EnY5YGAb\n", + "hJQ1V4q+AKnn3/aCFhCV1eB/EJFGwA/ElFJxEdEqmUj5C8V7KKVGRfSvQ/r90FBrbXWPjUL5wLnV\n", + "tOl4ADoq9YxiZ1VfPbDUCe4kEYcLzySAINTiygwTjtRw5g9Wozw6YMLmfljVB8eGoS6BbxA6X4fx\n", + "bjgTseJyHcOgz7tSJbYzcg2IiCcCH1wHy+ugHAUtInJkAr731n1JbXstRoOOoY9QavJR7L0D9VoZ\n", + "lotI0wUchv4SE+UypTKYJTB1UFIga0BwBJpOwaTDj2PUTTpcIBdOQoOIREPwaythcyOUJ0CrF+kd\n", + "h3+5UNBtJRtoXi3lzRM+A3xNqZnfY68Esj4G/DrwNzN9fZu3UnE+flVRXERcXrgxDDcKuFKwLw7P\n", + "X8ZqiRd8OrjMWnZtXoMr68WZB3DhNrrIep6Gj7jpvaGOVKGIZo7hSk9y65tWlkbm1HRHKAnuQ3Bv\n", + "A3oANNdRKIcxd3kpn8pM+06X4CdTTG3NsMRpgDNP/XFF85C14jH+5AVe64+tSQoBLI2TBREncjlU\n", + "JpKjACKujdB6D3gDkMuL+J6BzCvnTx4rDusXYKgBays+CqH3wMBWWDdNH2bc42Pf5m5w10F2FLSw\n", + "yJ44/LgJxicxlgrOyuqTIk+yNktsiZ/JlgaUW4OReisWMJcC9zi095P7JmTXQigOtZVgZFPgJx2Q\n", + "mXdK29UslLcd+EssT/91pdQfVMuWqyUED9wIy7ZVlkrLwKuwaifcAzxmRbkb7/PQ8L/58TgF75gD\n", + "NZIlXjPBmZYWyvoRS9zop+fNuPpMYi9McvA2N21xk3xzkaKe5aQU2D4KA752hqQHl9+LI5el4I7D\n", + "h9+Egc3Qdgv0K9ANMHdD10vwEPDtarxHiw0R3MD/Atwyi818B/h9bGdkThFLVOLDm2H5WjjjhGQv\n", + "bH7FmlT8rVIqJSJ1EL7FKoFSmoKxF6F8CEhDMg/9tSEKbi+BSYAyJUOjWKiFUgPcdwO5Z8dIboEa\n", + "vYF08CCP3xvHeA1GvznNjkAb3N2Ao3EJ/owb50QeU99P5uZD5IMZzC+efa5SakLE970S/vtLrM4A\n", + "JdjZCof6oHjgQq+zknVygcDMxYGltbL21+GWMxAZgqQTdv4aHHABb6s/VEkbjgJlKyZPXoLX14Fq\n", + "sXbNUm4vP7ttG1Pjd8DxEWitwb3EQN2cRi0fpfDMKUo3NpNxOvGRY6K5wGSHB3eihYy/BUI9lhrb\n", + "YY8l3uZ9wXIWT8BRE7R10JMEU4Njfuh7CRia6/ftWqnmykg/sEMpVRCRb4jIWqXUG1W054oQEc9S\n", + "2LRpWqdrwGYYPgrbROQJ8N4Krf+2TGMB0lLAWVsgFfYQOH2KzLvSEDOp80J+tYj+L0qZx8FK0ROR\n", + "LwrDkybRrWAUchQdSVyHYEACZIwVeLIepFxgPNBN/nUfRKPwvmbYvRfvPSV0r4GZbiTzZh2sEZHA\n", + "fBPBmad8ENijFMdnsY0ngK+LEFHKXtmaQ5Z0wfJbpqXor4ORLLTHYIOIHIXOz8A2DTpjMOWH/R+F\n", + "I48rNfW0iPdJ2P8bJqYBUKboKDAebCazbwq6/JB2QVGR0/MYdQpx1RE34+R2K6UGLZXNunuh7o4g\n", + "mdugJn6Gkuah4AVw4chO4ilD7C1ZQEqlnxORUzCwARxeGD8E5TfnW0zBXGBNIFvuhZtHrUwigJoC\n", + "3DYII3eIyM7p6dUi0gz198OSHjALIjUvA8/DwN9C4iaoWQW5YhPjI7fBnuPoq2PUr3AQTrVCdIjk\n", + "vROIdpzB748x/tkA5U5INgfwRiM4ckPEu5oxyi4keIby5kbMfY2QrIUGgTrF5L/Ay/vg2HpQJsT2\n", + "A722AusVcF5sRZFp4lzzBLcbxOCtYlYuMF2WXxKBxnugPpdn1dQ4r/Z04kyZeH1J0qsglBmlnIX7\n", + "D4Gm4OcfFZG/OiukVknP+0trplVwAeNQrIVjf+JAPphCL5rkBrsoPNlmRdYZBtSNUr/dSd2kC+ek\n", + "SdE5xPgNOmODWBuWtjMy+3wMS6Bs1qgosj4FvAf42my2ZXMOBzS2VWI2suAaQu9K4GrNYRoeCqUc\n", + "wUbYDqyupPHXFKAuDRM7ROR14DU4ok2g//kwse1eJBMhva+F8uCLsNENZ4YJbXXTGvPiOAOQxtkI\n", + "uXtEZBd0fAJuEYPolJNeVcbvLhBPabgHNYyih7I4KFAkFqay3XAWpVQ/5wVO2lwQF3gCUHfeyoKn\n", + "BCHBWpHIAYhIPXR/Gm4pQNeAFbaz+xHo/QQYOyH6CiR+CTSE4TNZ8MTwL3dSO6VhFDQEB84crHcX\n", + "iLZE8T4WJfuuJZTMCKl8EUfIgW+8SL7GgZ4XTGcMowvyx01QCqKVWJYjlZ95TdVjRkRkPVCvlHqz\n", + "2rZcIYk4TI2Dtw5+FY9xBvxTVuSXH9pMMHMQLAzROVpkoKGWgreE6Y+RLURZvxcME8YCUFcHg9uB\n", + "n01v5GyQkzUrav5b2BwuMzCmY6g8E/XDnN7STmEgBa4o7tYS7pYyBeUkl2tC6w1QGx8j2QHZq8wA\n", + "sLlcRGgGtgHvnYPmfgg8jO2MzBlFIArBBMR78dxQpMnnwJvKk/ZmYK2lT9X+8lvPcpnQqqC3CeiH\n", + "0Noky/b0caannZIzi3vpASbaRzHHI+hdwwTqIJcLk4014RmLoZnQU4CpB2GjE1YMl9BUguOmB4e3\n", + "iFZfJBsy0JKTlFNZjD7sSce1UIB8BibdlhDkWfJ65W2dFkMT2m6ViFkag5wTxrbDRh+4HeBug8HP\n", + "QN8+yPxTFMwjyNY0rqVZsnmhVDJhMktkGPJu6PowbH8cCi8qnvWVSTidhGJ+zIk4pW6NklchChz+\n", + "cfItY1YW1DvGhYjoayr1duqgMABjT19K3r6aVNUZqWR9/DXzsN6GUqrsFHnsWfjoFphqsJTxAq9C\n", + "YwpONsC/jjO8oUBtQuOpJSV64kNsOzHCia4ykwYYRyG6AR5/yEon805Bc0TEl1Yq/dzbW/R8yFIC\n", + "3nZqCnc2xvGWJtqiUVIrf0HsA8dxrE/TFYDWYghfoYgqnaBvo07s5CThfZB1Mq24l82s8GHgh0ox\n", + "E3UpLsVjwN+I4LYF0GYXEXGE4D1L4YYorDkAN5aplQCBowVK+gBCntt3was74GQ9rB+BCY9wolGn\n", + "4Cgx6saaTS+H7jUGrqYCroZjmK4cNShayqB7MhR6ArgKYdqTo0TbBzm+KkHNaci4wdcBkV2WRV3j\n", + "I+zNGWRbAoQLQqk4Rdnbx2RYMfVzzhNYtLGqmDfAXU5YYkIsCs+W4OD52xlKqbKI9xl49WG4rSIR\n", + "n9fhlTYYf1EplRERtwbLNeruK+NIQ0mH0Xao9UHjJBxZAqM3w/I0+FfCYMcgY3mhZnUDtWUPkWyG\n", + "tOcU451TBA7B+HpYNQpLJqHMBIdO1VFc40f3uHEMnUL5EpRrBFfJxPBM4ZRhCt84mwFp1VH6lbZU\n", + "5fV6t8Omh2HLONSPwnAjvPrbIsZXlSpdl5k21QxgNbAEof7wHVTpPj/t32eVUs/OgWlnC0s1Yg0g\n", + "Zy62/1ZQ6rCIfGUMbnNCSwbiLqh7EGqaoe+7DN/uJ73MA+k8w+EzOIihF8CMWrOcZJew3KPh1MuM\n", + "NCjWnITwgyIyrpQ6NM2WCDTeZkkUg8mq6AlyjiiHO+vIRpwQKhJwOWgu52ktxcgCRU+J5ekiRz0w\n", + "NcRlihaJSBhLC6UA9F9tKuMi5UPA5+eiIaWIiXAYuBl4ei7aXKwE4J4tsO0mOHUaJp/F+SEDMzLA\n", + "xPokomVoivmIbk9Tm4ODnZB213Foaxt6yY1pxBgrR+HmON6gm6EHOig6O3AlT2HWTtDqnSSUKBMq\n", + "lqnfF+fo2jTRWiHgLrC+AM2nQRlQdMHAdgi9APFIjnWxXnJ5L28s0zC9GZqiJZqOwP7T08eryjjr\n", + "wPr+13hhUwC6chCNwx6l1IJ3XERkyUr41HZItcNIDHy74TcOWVsuL779jOxrcNAJp++EkAOmyhB7\n", + "AaaeFJH6VvjkSggMk2me4FRdklRXFk8Z6rKWMF62CW46BPVJ6zbS4lLs236KVb8Yp/8+g4wvT/1E\n", + "jo0n4WA3iB9Cu6wdf40kd77+Jj8NuBjbXkOhS1F2nSSs3HjJopOjNZOhuFlE2xZB9XTBagUqLNIX\n", + "h13Aaei436q34yxDPAw1ZdhkwtgjIvJPWGP7dVWDrJorIx/EkjH+i0pphc8ppV6Z/gSl1Ofn2igR\n", + "3y3QfR80C6Q1GDktIt+6mMa/UuokldS/WpGHb4X6FTC2C3o2k487iRPDF9Jx9UdIGG+Qjk/Q7gaz\n", + "RcNbr6OZUBADV0ln8jaFc8SBryck8rUi5LrhpgbgINklGUbdirpDYJhFlo07ONko6AShGMFrKETF\n", + "SHiK1KXK+HJFPDHoDUF0z6WcCitwy38XrNgB7QpyAv0pEfmGUmreRWbPNSI0AKu4QLT9LPI4cB+2\n", + "MzJriIhrCdy4DYYMUO2QqEPfPUzThhRaYyONe1pwZouUjRHiSyYZcrrI3eUkXIySVLVMnH6Awo92\n", + "Iu/ejXOjm3BTCWe6j6irhE9vpS6RZ6ouRX0cAlFoP13kQAP0TEBeQX8ThI/Apl7htUdcZJcLLkee\n", + "sK+M71SKxhdgyyvgzVsLn8fqKnY7amBHB9zoBEfCqk8T2QK5JkgmoOMg3KiLfMNU6mh13+XZpRHu\n", + "uxmmOiBe+T+1A3JjcLeI7Dq/3k/FmXtBRF6FUwEgfbYKb6PI+3aA0QMDJ8mknmfkdg/u4DB5T4nG\n", + "BLzZYAW+RirZSEXAa0KnDoZKc9+3YHg7ePyWMPfYEoNy0UfdxgLRpVna3oDGaJaO3jr6b1uFgwK+\n", + "YhqPnMKhK+pNNw6ziNZgcOaP7mZqXxecOQUbxuH2fvhIFo6cwVNvEj8OiY3gNSDTAFk/NEzBUgOG\n", + "Yu8kT18NqhnA+i3gbYqhs4WIaFazF48yFpGVsOVBuGfwXN2WY3Xw1EdF5G8uVSjKa5UEnwSIw5Lt\n", + "EPORP3OEfPcozroizkYfLmMCTwrGgkKroXAoIadMyjWCKT5KTh0Ju+GPDdC3w3dXwLiXqRd3cvxD\n", + "OSJdirZeGPW5SATcZIwemBgl3+zHURDSRMl6CwSBcg3ERiD31GW8RSth1T1w3ylwVF7nSA387GMi\n", + "8iU78v6SvBt4chYUV9+JJ4AvY6m92swOXh+Ie1o5h2VkB0aJ3VFDe9bAKAIocrrGqO5keX2E+qO1\n", + "OLIKzBRB9z4OrXDj6/YQbDUJOsZRAaFGypQMD5NuBwUHpJstyXd3HDKtwvFGIaWVye+HjbucHLxb\n", + "cDh1RpVGbanEhFvQekw69kIoBaebnfSu1YmPOkQ2hmDFVli/BYY9UPol3FoDnUvg5z7IeUBClm7F\n", + "+0XkCwtVYVVE9E7o6JimVAvggVI96P2WOOTwhc6tjHnj064VXgUdPZVrdcHEAKeGjpC8U6gJw4kS\n", + "mJOwo8/KYUi7YazGS2FFnmynMPEeJ7kzCtdEFr1XY7ijlsSEh6wqs79TpzaRIN6QIPdshP23bsAc\n", + "DGOGBvHVufBqDRTlJKaRJ9BRJufz4TyzAsaOwuYirGiDhAecechnmFo6SbQLVvVDIQhBD5CF3hq4\n", + "dcQKtv3FRypJE9dFAcSqB7DONiLSCg33QUc3mFkR/4uQfvnCX77GW2DD5FsLyC0fh+Md1p4g7xj8\n", + "U4LJBESC1pRG08Ech/BpAj0l6pxegikPk4YO9SaNuiJWMnAaXlJuH6ZepIRJsraTjMsJ9S5IDsF9\n", + "JXj2Vjg6yrHnj5G8tUiHwGBTgmKwndpUHAn6SDPFiDtIS0Ewi0OkczCRgInHgEYRuUTVyMYbYE38\n", + "nCMC0JKEJR1w+iGR1lbQPJB6A+IvXr0k9oLlQeAnc9zmK0CPrcY6q+iTIJPgDle2OttgKshQpo9c\n", + "Y4KxTTpm3sd41IM/WaRW1xAMnFMKNCeRwCn873LgqMkjHiElGn7RaZYiJ4mRdUEEoehRGH7hWE+Q\n", + "cWcb2UyBBAlcS8fZ+bCOs9FJeKoBOarjLI0z2pmnKZgitU3nDVeEiSVOTsgm0kfG4ZFBWHID/NwJ\n", + "Z+80tSth4iTs8ELRY+nLS8AKvm/lEmPbfEUpZbaJJOPgCk2LmSsDyUqJMJHQu6FmPZRzENsJ+d0X\n", + "cc40fVr25EloH6LuRp3WgoZrCvyTVgX1Q8uheFKI1oUp5OvxZk9zmgASqcHvKmKSIN4yxdFuD1MO\n", + "Jy5/iqwrz0jZyWBKeMPTRCJaAw4BVxGlFO6ynxrlRml5mvQSwxGTwtTzsC4Fd/VAtgDhODjTMFnD\n", + "VGKKZI+J0QtT9RDIwgk3RBJWSOOGIWjrgDNtnOeoVYsF7YxYMu1LPw235GDJIKSdsOcB2FvHBcu6\n", + "G2EIXiD4MFAGvCLSCZHboLw+QMoQim8k4DmgT1m5yi/th0/UQyoAAydhxSDOtUm0gJN0PkveE8db\n", + "FMIFnUxAY9LhJ0mYWq1MSQxSGAyLm7KzC8onILgC1JuwsQdGP0jhue9zavQgQznY3GOS7zSYDJoY\n", + "gTCSS3DMf5rRmhJes0iuCGocNvvB/C0YmKpsuVxkj1j3g/cCs/r4StjSBNveAG8STmyF19aIyH+3\n", + "dUssRHAA9wK/O5ftKkVRhOeAu7FF7WYUEalvhPevhrYMND0JN62HV1bAwH5oPUVjxE93nxd/okTO\n", + "MMFZIu8o40zFMV15Ej1lRru9JN05iu5JajHZXNZoNgymlDBU1miWBGOGh/qch7KZZXd7mH7nUkol\n", + "B1GnQTBXh9edZ3TTFGFxkzyl02TGiTUXyPt1dteEyTY7oclFuX8L2afWw+lRS4Niax80rDyX4msm\n", + "IeCFthXwulZxUt6AlUH4/UaR1yfgUAkOL7RV0Bg8vwseuhP6jcrr3getZ6APWj8EN/hg6TjkDDj4\n", + "MOzvFJEXQ7DZZcmbnsjDAWBiDJI/w7E1iT80ibmuTJfTQ+tUGU8clp+EzhH46TbQmnQifhPJD9Hf\n", + "0s2ZyUaKiZOMLjXRNrsp5F0UG3wECdGumtBLI2S1KPmAwXiPg/L309A4Ac4YaZcwpIRwqUSIEq4C\n", + "5IwCxbY0PLAEAgEoB6wbnHEY2n2oIZ3TGZMX68Dwg5TAH4WuNEy4rXfGq7iOKvsuaGcEam+FbSXo\n", + "rghD1RTgtn4Y3Swiz59Nm4Wz2zjBkzC4FoLTbtimwIgGWhiWf9JHcWMn+VAQX0GIb0yS2twHjwJP\n", + "Acf3ox0/Rs0HHIhLiHd1oULL0EpOtPI4BSOB00xSKyWOqABxrYWCyjAuBk5ClKjFW05Q0EsUlQMc\n", + "OfAGIT0KNY2QzEAKGgpw04tJDjuPk1jWgMKg4F0HOBmNjkB6EG96iB27FNsqM57BIPzi4yLylxeO\n", + "H4kfhoEd0DCtau+pINAIt7wMwUr68voRKLbBxBbmNj7iemY9MKTU+QUJ54SnsJ2RGUVEXC3wyF3g\n", + "6IFBYHAnxF+ELc+BZ4JQZ54NL3og4sU1peMp5/C4TrF/aw79ZYXe42B4ZTfK7cZPlow+RUmVmCzl\n", + "aCuXCOk6hbLJgKbhMuG4qsEpBpPmespxP6KmKHkcFIsGOSJkVALRi5Q9/YxsL9PiDJBztxHQDEpq\n", + "KfEBIDkCXWU47YJsAEoT0IBV9Q0/9J+E96yCca0yu38dOt3g2w7rG2B8CFYfgpOVWIIFk3mXg1f3\n", + "Q+gEPAQ17RkMT57coRzlw7BpibVKAOAvwB0nYfSebuK3bIVxP+SHYeVBuHkEvj1GYyRJy6Za/KUU\n", + "400mzYVJ8hRZVhE5dDmgrQTFXhfDK1xoaY2SQ0eUUK69k2zaBCMJ5hhijOI1veilAQoO6BAvHpVn\n", + "3NvH4a0miUIrOOtxF0Fppxlx9pEplXGUPbhSBrpjGRQ9iBrB3TyIu1DCLIZIF6bI+MA9AsufgIGN\n", + "0FJnafO9FoFwAnI6DCuuo8yrBe6MeLuhdfKtxzSgqQyH64Bxywnx3gRtd4DUwqurIHcc1h2FpAv2\n", + "N8LwK9D0AIS3thFrr6M1qyh6BHepg8FIifwOEdkPoTtKrFuWZOWzEA818kzQIKdPYNTo+Io6Nbk2\n", + "yo40p91pVClAzhHGJ+0EcQIlskBJsnj118jjI0cEPAUgA87noGMUngRtO0S7oMM5gn9fmZfXb8KR\n", + "gpKeIZ90YUx10qjSHN06wcYBcChonYKudhjuBi4QsJbZBXs2g7RB5wTkHPDyKmgYhmDKyqMvixUo\n", + "1xaH4HJsZ+QsNwGXqPA5a7wA/E6V2l5wiDUgLFsBwZ5py9c3wXEvpH8Br+eovxG2D43RtyzF+AoX\n", + "SB60HO5exfEWneZQEw7lwDBLREWj1gxiGBlizhEypolHmThNIWvq+GhF0x249XESDg+Gu0DOdBMs\n", + "+fHENVQujhGCUCZNrMtgdd5JsdiKT7mIKHAVJsi1rySfP41a+3PEkSWgxSlHhMyqWszTzZBshpFn\n", + "QTmt2ibhKDhPQ/1dcCgK7nrI9MCYBl0vwDqsrIwFgZWu608lWZGBZQcglLASH1/6CAQOQH8PZDus\n", + "ysxa1I1v9TJ4aXVlVakd4h5o/QX6v8ux4oYsSydHyPlhShQNJmSnBcAmGyGQh7pjTpKeMMXgFO7g\n", + "OGNtnRRMF0Y6jWaWKPqD6JLHlBFSOizFQ025gNKFiIqzdLCd/ZsjmP1TFPxZ3GWISDsOcxCX7kJc\n", + "TsxEAow4IYeDGjJoeghjcJKkL8pEa4HBx6EjCN0HYOQ2GOmEySGoM+GJDjjz82utPSSV7JOZUHxd\n", + "4M5IMQYTEWtFZDpxDaisANTcDRvugm0jEByHQ1PwryWyKgAAIABJREFU2kbYLSCnrPLS+dPQ+Ckf\n", + "hGoJTem4iuDCxPCkGFvRSb7/CNwAtXdD0xnwZSGv1xI840RzmDhFw+UUDOUgj2LQlccrUQyC6Pgx\n", + "VZKsTDFFDl3G0EjQorspmpOcieQpDhXBN4lnWFFq8xLtynPiDpNtg4quWJk3xxMU9RKFgE7AreFS\n", + "QtB0k47AgVscuLJuUq0l0v4yjFTiR96yHaWUSorI30HiBgiugXIczjwKkdvh2A1gNlUqCMehOAil\n", + "EWzOciPVc8z2A60i1Cl1LtjO5vKx/A/PNgjfDu0BRVKPEW97GjrL4PTByEo4GYaMFxqypGvhWNjE\n", + "KCRp2Z9kqgcIguaFOC5yAQ9SFBziwFnK4fIrKAcpcJqYUjSYQgoHZtFJ1GHQUEqjOdzU5uPEXF5y\n", + "hhOnylFsymIWR8j4vJw+kUGkiFec9Hk1NFOjnNCoKSXxNU7iTMUhNEJrh4dwMQGSJN/0XYaXeykP\n", + "QPyEm8KP3ZCZBCMOoRVgeqFQAMNnqSIGwuAMwg4R2T0fJcUvhIj4oPseuPfEuXjAZqA3D0MPwMqo\n", + "FadcrIO410nKX0TvH8ecHMG1IoOjvoxZcqE25ug5AB0JBaMwYUBsOfhNmKoBZxEmg5Aag21DSXY9\n", + "6ERvNXGSAWcMbzmDcniRqImYJYoKSkyScHiJqgyFco5Q2aRUcGEGXPhLMRKZNKXeHI5OF+6yn6xD\n", + "Z1CvgVgr2cQwjmAXwSETPVxEBUdxtERxlmLUH4GRr8AzK6BmM5h7rYX1mhL0TcDYo+q8LKqKrIMG\n", + "TFyq70WkJgh3tlsZsdSK7J2Ep69l636BOyOjL8C+T0IkYy3BlYHDTTA4BAxZH9Klt8JtA5ZSIsCa\n", + "MxB6GX6SgdPfgNoHoPE3gA1lEqUCmugYeQ3JaRi5ElooDWEIfxw6W8HshN0KjN40ZW0Jgb4MIx0m\n", + "mWARRyhDwZujhho6JoQ6bYBopEBCeUhJCA0PGiVqyOGTKZq1OO566I/wP9m7s2Db8vs+6J//GvZ8\n", + "9pnvuefOt+/tWd2S2pIs2TKOU46dCXCcpBzKdiqGQFHhAQoeKHig8kBBQUGRFKSo4gESIAxJSBzi\n", + "OEPZjuNJsmRZLau71eOdxzOfffa8hj8P+7TVNrJly0PLkr8v955d65617hr2+v1/v+/guc1E/9qa\n", + "0bmme8WxmyndqzMnL8487o80Qq4Xg0mvaTis3U7mumXm8Du3tW4s69w7cZBe4vqX+KEQwv/86wmt\n", + "pwFZP4mfDCH06XwHt/44a4GLtxE4eJpXPsjuH3ZFvoxP4L94P3YcoyoEn7II5vuH78cx/MFH/3t5\n", + "4V+hHxidiw5evCVcuGZ4t6FVDU0u/4LyiSY3DqxfpHmp4e3nW1aS2qw3tXG3lD9i4yY+WUh6hUlM\n", + "NbLaUhYN0iCLU7MYjSIno+hWp7KTBgf1LSedJetlS7O+7ySedRI6yuaAxkwZr+ruthW9u6bZA69O\n", + "ZnpFaZgksnml6tUUd8TssdV+bXt+oJmNbYy4cL/ymfUT9w44Pznxpdu3TLc/vlCI1Hf52Fua1wrp\n", + "/ftm39O23JxqNibikHoUQvjbp7EUf9BxZmHV8G4hMm2ws40ug4skYxprbAxRM+wP9J79rPK5JWf3\n", + "aORD0/O1ySaf/TC7t9g6ZqnFg5r8DPW3Mt/j4SHn3+bmh0ornccelZysJVbDDVWyZh56ypXEdD43\n", + "m80MWlf0qoZpPDJI9jyIbIyXJctR1e6zHBW92oMmS1khS2ZqlfHyNoeflrVy805fNy019ofSk/vO\n", + "F8xXeLAa49GP48cXflXNF6iuMz/yHpfeEMLmGf7Ms1xKifvshxD+fozxKxJbQwiNLX7k46w/xyN4\n", + "nQ99mqunXMKvyYTxG7oYiTG+GULnRzn4Xs5kjBN2brD7/5yG0a2wHr5ciLyL8wPyK2z9m3z7Mpdu\n", + "8/pswvqu1/Jzlo+CpMd+lZgfvqH9MT78kO0G3ZrjM9z94GPjum86v2b+qQvGX3pb+Og9a8+Mnb2z\n", + "LlyvaIxED0ielhpJFc7qaDpv6qZBqF1P2P+W4OD5ymyW6rzV9PRR4dVG5uWNzEpz7Eq85zBsmcSz\n", + "OgmN5thRo6VRNxTVkfzq3Fv5NY++8Ed4/Yhndxdhfp/9SgqbRSFy/t/hmat0TrtLDz5Kf0494MyE\n", + "8i+G0Hwc4+wLvz9X8+sTp/4ia3g/4wx+Dt/hD4uR3zYW9/qT30arR3Kd5+a5w6WJs623vXX1aWff\n", + "mZu3B2698MBkNXr+CxfcWut4mI4M+pVeo+ne1YGyKJwvefGoUG/uuOOCbB6NmixVM/eTXbFk723e\n", + "zhMnW1HRLlytKg1H6rzjIOmpyhnhobIRJclVjSozWwlCtawMqcHSTZsne46y3L2LPaPQNhrfU20e\n", + "u9yoZLESG9FJxpvJoumRfJL+DTZf/BV3//rbmn9iovPHGlbW1p0dpJL2vmGr5+hWVM9Hnt7Ht/K5\n", + "HH/9azyvDWxg9m7e1vuIKcNk8ddhhzvfzkqblS2GMz73HOcPFp3f+8lEo75r+1Iia2UmF9aUjZF2\n", + "Y+RaYLxMZ50vPcGLR6QFXxqydosHG1Q5J9c52mKyzMkST6otV4ceJgOPQ+Z+u6XR6JqELWURjVUe\n", + "ZpuCllm4ZWetttI4MukMeL6ilWlLdOZjiW3bs7GYvSy7nDuublmranUx1z0eu/qwduWQnzhH9zJ+\n", + "KYSwxPZf5sW1hUJyeI1Xvi2E5v/N/M3z/Mi73ilwj+Wf4kdOZb+Hv/5kJjz9LGc+/J4x5gd5MODS\n", + "7sJr6fNfy0X6hi5GIMbxL4YQXub2Bqa/7sEYchQWJNX0PW2pvQ6jlOc3efE2R0ukJSvDBzaXCneW\n", + "VqUq43TPvLnvpQdcbPLFJxm+RDfyxHxmff9Nn1/ZceMTy8rZfb3LY+eGxJUT75y5JjaiGEuTGAml\n", + "NWyi1tHUdhAqqyHXiktajYca6b7Gs/tuZw1ls+V8UlhDI9R6HtsNR24lUd6da8635XHqdmtoo9X0\n", + "OL9kdv+n+M5sQR65fsLdEMLfwS9Y3AvTxZ/dj/FSf2Hc0x2Sl4vPy8DV1xaGjrcqqu8LIbzxtVbC\n", + "3yD4BH4xRu+nVv9n8V+9j/v/g4wN2svsvcS1GUcd8k7uuf25aX/HYKVvZVR4YjB3b61jsHVBfaaQ\n", + "zCfmsXZSdU1Siu19FwZcf5PXrj22Fqf20yVHoTILx5YmY/F2y+Dtq2bbDdn5Xamxpebcap2SlPrZ\n", + "wIN84qAuXKivOEqW5XFq2pjY3061q46TNPdaf2gWjx3nU1Uo6BRUTTGZaGTRJGeSETqsVJyveLK3\n", + "+H+W/93Y5oiVeuYDbx27c6bnZDlxafpA8tRUdZ8nd7l/tqH50UYIRcH/+ZVeSr8RmiF8+Bw/3JNd\n", + "nkmaKyH5lWPxv38f3V4f8fD+wpAsvcDWqUjm5S3O3WVljf2K7l3WLhaeOTh2a2tJJy/NGjfcSWc2\n", + "J7WnI7dyHm2Rp/zc8iLktB4vPrvaZgXTe+wEHp5nO6WIjJOJTkg8JdNQKJJl90NUxcSRLUdFIglL\n", + "ZEOT9tCgPVFXv0JoEjJlmBm1CleKjn4yctLY0W807M6PHah85GWevU+d8KVV2m8tpm7Q/yQfW+HD\n", + "d798Si40+fvfF9z+sVN+1K9Kuy9w/AK9x3zYVzBU7HPh7FeIFjm7IE5f8ofFyG+MU2b4VzK2aS04\n", + "Wz/1p7j6Ntu3UfKZs4ze5MylxWbHG5x5QLlReiI8VLUe6k7Yay++B7IVXr6W6XRyl5JUQ2mnXbhx\n", + "du6P/PyO1tKue9+eeGqXi+sd46VVmYk7MnNNMw1NE3OZmVxUi8hMHemYm2lmLGXk+TkxFHrWrMRC\n", + "HWYKE1HUEXXDFbN0JqQzMea6MXN9Otbc/GUH33ONmHCmy/K+7KVE+oMHuvdpfalt0Oga7h9LLmRu\n", + "jprebEysnZlJm3zHCUct6gaTQOcO5zNuncPXZdbB7xM+YeH38X7iM/hACLoxGn3Vrf8Q78UKx9/G\n", + "B5cXSrKdpcqjbqY1T60eT433+no3KydbCc80HH7oUOxEV+uupVkpTUpHYebGKqHNzkrDQw1lo9DK\n", + "H9iKtcmcc0Xbm5fX3N3INMtAkVvLL2g5dpyRh7EQE+uG0mRTljTFqi+bd3WSHUW7kJjIi9xefkmd\n", + "XJOVUTfMFPGWsnFiN2mZpxd0tMRwZG7fW2Hmo3NOziWO0548C/aXJtbMFWHk+Xsjr11lraCdsj9a\n", + "8rlL5w1WOup2Lf/3DhXXQgh/I8b4VZ/zEMK1J4X/6KL1My1rw0Q62XX0idccPRVC+JHTUfDvK067\n", + "4P8XP/VDbH4PT53whVWmN7h3gS5WksWicyNj2JnK86nVhCwuzs1yubAZKWpagXnGWsXFOZ2aX1nh\n", + "UkEPr71Ae4cnEs6EZBGxGGpPqFHYFtwOiV4MBqG1+MVJX+2YpBRcxkxILyKK7gtKTUMHeamZBkEh\n", + "pkEjXfMoNPyTlyZ+8rlKNi41HpM3a3v3QwhbXPgwT50q/Y57qceXctOlmaVeymyJ9L3na4+1iexq\n", + "kG+G0J4w/YKFBPgy6pzZMY1ff56PaY597by1b4pi5CshhPRJnv5hnqnYPeDVj/D5D3H8WQ7/0WKu\n", + "dnCVImGWLUxj1t7hlTXCbq6YNhQX56pmYX8zt513ZYKmxJJEHVMvp6VPvViaF6mz9YZkf+DBhSDN\n", + "m5aM9ZNr7poo1DqxZRY4kukbGGNFZkcphGXnjXUs2UvWbXnk2FyUmuk40ldYljhUoLasSjuqdN9x\n", + "7MrzgU53LEkL9SSnOdBZ2hAa61ayHeHyI/nlygcPxu7WZ+32thwWfb0vDDxu3Dbb2vXUw8XtUjU4\n", + "nnPhDm+se48z5TcpPo7/8v08gBhNQvBFCzLZVwhZ/MZECKFF8iTNVSY7ePu34yS6IK6e+y6e2mWt\n", + "z9aU9br21tnC22tt3cNS0T7w+W9ZM1/JzKuhZGNotdHTnlbKrBKbiUasLOHm+bP2+tvKVqblQOpQ\n", + "CBODfMsgWZPVS7JWw9H0gWanqTVrCSEK6UAZK8JIK6ZyK3rxwGFYN29lkjCUigbpurk1uUy0K6Rn\n", + "xLiqTudiMjS1qdSSm6Kp1DUMt91oJ3ouelj09ePUSb4nzOd2+4eyIf0h8x5VmXqwet2st6VZUlZ9\n", + "WX6i+OiMfyuE8J99tTyTDb57S297yfYj0hrO2rq3J145Uf0p75MEPcZ4GEL4G4QnuD5keo3mhabj\n", + "jcqnN0rdnLrJ9hIXjxfRXFnNalhkA9XpQvMwqjlXsVvQnjBrBKsd+lk0axBTqpQnh9wT1HJJmJtg\n", + "KNiQO7apXRemdSJPW6qwTUhxR+Ka6FjtWbS0pWZStQcm5mp7jpIM1+3HC7IwkyYPTdofUkVCPpeH\n", + "I2WRKC/t81feVmSLIPmH68t2nl+TlCeqrSCeKV148g1H86ZZ/ynFF+8LFx9Y+9CeVnviyqv0/lTq\n", + "U//GVYPJ9UUl5i3SX6Z/gePzp9yThyy9toiof/VrvUbvZ1DetkXy6LPo/l5b0i72t/LSQsV2dJOt\n", + "f4XvPmBzjHscf47Xz/GLr8c4/LkQQq/hl7b63vp4LqtPdM4NXT/iaL6uqC+LSW3QKq3N33GSNZwN\n", + "uTQWhMpd6x6EFZXao5Uj43LHSnkiPN80bc60s7GmrjSZm8WJXnxLP1mSaNiX2jOyrKXSdl/beaXa\n", + "XKGn1hCl5iZqXXuuy4zklgSbasfmZjJNSdnUivuO8sxRLKUrmXr+UNa5ap6f6DdTzbgpZg15vKOx\n", + "3NYOV3TGJHmpemJb95cTs2zsZ8+PPLVL94CtLzBMuTf0G1gpfzMgBBm+Bb/4fh+LRXfko75JipEQ\n", + "whnO/yWeXma15HHKWw9DCH/rtyFX3GJrhRf/OW/8EPkKYZlmKA2bU6Otys7WeXndsTXpG99+0/Hl\n", + "gbyZinlDb5IqZhOpmZVs1Stbz1iZtCzPK2neU8g8jhOc0U264izTbq84CQ1F9kUHaUs/jFS6EstS\n", + "j43D1IFCM9TWve5AT6EycNbcWD9sSrRNw74iDM2r/mKFkLbVlnTtmTjWUFqSmGnZS1JFvaFR1opG\n", + "X2N2aCfvWpuO3NyYO0mDopcYanu43JGOK1m2zKgpfTd//sOPOOurPO8JTzQszd8tRN7FkuaI3ge9\n", + "j344C4nv6k9z5/sb4jNXVPmalWFpNt/1YO2ek3Zlc8oo0JxTtdlNuJWQdVitWC8ZNLlb0u6z2owe\n", + "WMTeHISeQaeynlRuP9lxN5zR0LJST5wkj3zeyPPajnRtl7VOcstj1yzaCQOJocRlZEq5oMRbco8s\n", + "Geo5NJbacdmKNVU4q5VOTOKSNFTKzjpxX+U6N16XfPC6unps9zKf7TQtr26K4UgWC8u68v2+Z+88\n", + "dGNryckHgr3qSPfqiXbztjpUVo5ZHp/X+c6XDH/5OfU78AKNf0DnR2mdX7C+PWbwgL/5O3Hmfj87\n", + "Iwf4oxaGYb+nCCF9hmd+kBeKhcPqrRe5+SLxH395q+UZH7nFl66HELIVvu8ZJ822IqXVnTic33D7\n", + "0pFeuqkVKlO5dDw36aybq40sq8IDM32PXLSiMFKRnLGRpDTu227NtUPtrloWMuO4Zz3puSSTmlk2\n", + "M5W77YyW4EjLxIFopBK1FOaRKqxrx/seh7NqqVRlojSyopCI3lQktX4ZqafezFcMJqmifYduX9mb\n", + "aYbSclJohUoZ+rpVw27elc5TnWZTdTywvz7TW1lV3eq5G0byn+Pph7ze48059//WN2qmxW8RL+JO\n", + "jL4erPE/g3/9/T6IrxV5CC9tLAo7+3y+4Au/ebjj1p/lj6ZcO511v4D18/zMd+NHv9r+Qgg5LlKs\n", + "Lsyhrvxdbn4/zS3ak2C/21DNG/JWTzd0zKpasn5R9/HrxiuHhNxJIwjzmd6gNhltm27k9ppTszwq\n", + "00xiW7BrlrJUV2adTKVN1lLXmZ38vsyqtdDSUClj08OwbmzfUNd1pXW3PXLJsSHmpslELZPqmduT\n", + "hFRipDSV2ZUbu6hl1VyltqTwUEMRKmUjdVwt2RxsmvQfebVZyfLEJR1V3dKtaOSHbvX6ZpOGlaQ0\n", + "78w0NoP51GKe8ZtizK2x+bcuveezKDpUZ4TfF+l5CGGT7gs0lzh6h/qNL99LRz/F3X//rOWNTauT\n", + "oMoayukHnP1UavrhG96p6KSLkVWz5lGGesGbO0kWHnKDsEjruJSQptSCgbNelWnEkTxmpskVZQha\n", + "dTCNTWndsJvc9Fl9F2Mii5VxSGT1CckeNgWpYKxWoxTcETz2hMSyllQ00XdH5khHQyaLpTpsSb2u\n", + "Dmu6saS3p325MC721cvnTHqlt16f2GqlVsdT9bnEwcG69ddbOuMdl1uvGNy/afDxTLnSMppclE7P\n", + "+/l/7Z6qcVZ7b6R1nvGrsMT8eY7/KT+5uwiJDXj8O20ovJ9BeTPMTj1Tfs+wiNC++Gf4nsUoDIv5\n", + "X/wYP/8dwbk3ogv7CwVNkVBXuNDX+OG+zTLTPapMW6mDsGV02DP66BXNtJDM70nzjnHjOalfdmhq\n", + "U8OhVUOFSmVPtFpnhGV1cuBE4lIYODL2SOUkNJw30BLVEkPk5noGbtg0c4RjO0505QbG0nissCbR\n", + "N66CcTowkKh0FTHXqEtC0K0KM0MDV5T5hlgnWvXQdH0oyVYtVczk2nEqC4mQEM1VIZNOc820YbB/\n", + "zt3PZ0xe53O89rd5+xrFEfHlGOM3Oz/h/TQ7+/X4LP7z9/sgvlZ8O3/+6dN581t8/6/w/Gl8wVdS\n", + "e63z/HmuvUd6WKYL4uXLL4UQfuw3K5LTEK5f5AfO0brh3tMjP//E2Lk3mK8t1HAPsxXDeUtjUssa\n", + "bUVYE8spS6VkpWU0K8QwszZCOlEk7B+nspVM2V4yiW2hKsj31HEixiVl2hCrwig8Jj8iS9VW3bNk\n", + "P07loVCHLa1IEh57ZCrV0JY6EDSUttEwtKNhosJY4k1Vdk9wIlXINS0plIJSVJtbEdxTGSVn1fei\n", + "/XRJUg3Mci5bMZl29capPJ0LSxOTpHQ7nTvOVjQfjWTpvnKJ+n4IoUnrJdY+ujibB59j+kvvOrYO\n", + "+Uc3Df9cw/Haiv5BqU4fGK4+ZsjhT/xu3S8hhDYunv54510SfQj5B3j6B3iuWvD57n6ML9057ZhN\n", + "0clUy6tCHZU5RZWqJ4l03lKHRNWrHU+5n9G2MDDrNRbekzcDs0A743y6ENF1kGp7w7JgnTB1x1AU\n", + "tQVZMhOrYFiuqIqO485UEnnY6DiJZ5xUgfKIbLHgpBDVglzwSE9mWRAFUVdTz5LMnrFCJQkkShXS\n", + "WAhKSUi0WmOhWZq0cuvzvnR96k590Z3DiY1W7slxolHuenBpana21BtNdIvnzfcuSvNVdasjm/ZM\n", + "lzOzJwu/NgC0QcxpzmN89Lt1Tb8ZOCNbbLVZ+1UVTXCw0VX2W/bPXzdoPPJ6ct+VNwvtE44/Reu7\n", + "l6y02jbvFMpuLawc6m71DTfPEZ9QxFLWzM27B7KkqRH77mGoL9NzrGXHSFLXkpgqk1QaohMT76ic\n", + "4Jy5lsoVM5XcRGGkZaBh3zkTfYmm3FCJIVqxMAl3TBwYiJpVIYQL2prEHYfJWBUm8nouJA/MGg2q\n", + "dRvFimr3xGy5YZLsG4UDSZpomNkLubmBZpg4Z2ZWjIW6VjZz1duXuflZLu5xj/N/mrXlRSz23pMh\n", + "hB/9Jg/M+wR++v0+iFO8jdU/qKF537VYYYFznEx5+lNc9xXdgiVfVr+Nm9x/luIiwuliYstvME4I\n", + "Iaxc44f+OEc7pEeK45k3X2g4fGluIyb20r53kheIQ6P+HZuOzPRIjkzzoVmaKtKhL8XEajfVjrlp\n", + "txbbe2L3qhhWFGmqGWFXGQ4IZxzrmYWocIt8ReKahlIZZqZaqKw70Q1HmGianZYglVVB4ZJaMFJK\n", + "DJT2lB6LgSyuaVcdkkPCsqlEUCicyFU248xuHJnGynylZ368p56e6GSZtWJFp04kjUqoMo1ipJ3v\n", + "qOtMPR6rk1vqxoGlmxxnbPwAH7rG07uLBfGbf5LPPxdC+JsxxiLGeC+E8J8M7f7HHcMrpbwccLcy\n", + "/FHqL/5u3Csh5M9z5c9xOVs4298uQ2j8XYqbXP5zPJlwfJaTmnP3aFzmZ384hO0G299VS4tamGVa\n", + "46hcGymeu2H4gaEzWe1iZKNBGhKdOjpuROPICWLk6QZ3k0UR0osLZeGuFQPXdeRKU4l1EwNVvCMN\n", + "qXZCC9O6MjzsOnm0wdKKsDzRzh+pswtKZ7Gv8sBib3dVokxXLZMZaejqGTmwJpiqPDLVEtxTSLUc\n", + "ysPcWhyZtY81ilSdbFl+3NSMJyYlg82OeTkzb+7aeXLuYrdy7hGamcHFmXeqJXHe1z2ALe3DR04u\n", + "rijbQzo9xjVukY3f88yePlvLfb5tiQ/UjPf59JyXvxrP6F18MxQj1UKS+i5OussefnBb6+2R6VPL\n", + "YtLXiMHnP3pT9c+DkwOWfuBYWhXKbmn6ZF8ojo07F6Rhqirm6mluXuWs9MTkgap+UVbnRmHPOAzU\n", + "NqX1XDOW8jAXwo5o7gmVQ9EZmVwpCg6sWparlFIHjvREd6zqGevKbFs3NzMVQtey1Chu25wfGeV7\n", + "8pCqnFGEtio+0rWrq3R2cmwQnpalDXUxMLsQLZfBsoa5G/bCBfO4JjFSGRlYUaSHzo1fMc2XPS4u\n", + "m3zpH3L5Fo9HnrzCJw+pxouW5eAiP/MXT1n236wk1k94n8mr7yJGdQg+a8Eb+fH3+3h+p7jC+HWe\n", + "9JWLkX32Drm/zODDbCwt0kjv99iaEf5SCOF/+EqGXS2ee5bkdfnFG554run8aNVw78Bgee6L6ZZG\n", + "uGj7qOdRb418bOqOmIwcrmyp045WPK8rEcKRfJYT2i4UY+90xkL+WCcuupzT5Bg7og1l/cgspIQJ\n", + "liVhW1JnOJaFZambGmrRwDLWlbqiqDCOtS+FPWfxwEXHeqcvvCCLS0p39MOJvmhkbm6kJ1MrZRZC\n", + "iaNQqTy2Xg7drxNV+0QopuI8mjVKjbQnmVdCNpOGVDUbMD7RGNWaw339t2bmNzi+wlPX+eStL5/R\n", + "jdtMrrD7JF6DGONnQgg/ODJ80uJt/SD+Lq2gFyOYp/4Cf3KHlVN56WGLH/8LvPWPab1IaPH0dGFy\n", + "eefSQgX4xMe49jJHF2rj7K43NyaGea2VzUzDyFI61kwoC04a9JPoZkKvpJUScspkoaB5jJAsxjhV\n", + "4ChZMZap0NIVjI01pKGhZVm7pB0PdUJUVE1Hh48XcsRWVMXLsioR7CqSNQvDoHdlS581NZVZ1zp9\n", + "S1SmNtxzXx9HUnMj+xId3djWV2o7tBxHurH2RroiqQ/tra1zsiOsNx0X99zqjn3oqLT1OFJm7jzd\n", + "t1RFa73a/ThRNTKtwbJpeEM5yElucqHPzpusvsPnvMdnJISwdJ5/+6MsXWVvSvMV/vyvLKS+vyUq\n", + "xtdLMfIVZzUhhL/6nh9/Osb401/D737Mox1urXLlMNg/s4qZ/eZVg5+8Yr4/pzVku+TZp+kcmD23\n", + "73jzdYP8AzZ2Mtm8NG9OievsP2KrT9onPVbbV4dnlSHFM8RXCPd1QktMJnYcW7XrikJX6pZMR2Uq\n", + "VVn2SKYtlRo71rClq5TKjU5r300jK6Z2TKzoVzNnQuFRY0M7RD0PtJ24r6shMY5Ry0TZLBWziTqd\n", + "m7UbzgwzjfmQdq6bToQ4MoipflULYdlhbHB/4kHY13xrYPzTd7V3mLzK8iabH+DN51lNmAfGx5x7\n", + "yOOrFqvybyqcmp2t40vv97G8B5/Fx3wDFCNTsvki3v7/hwURMfwD/vl/yHMX2NjlrRXuzLn6KsUH\n", + "mf/XIWx/np2fpX7tXXvrJssJyU2bT7ddPp66e75heOGsJE1Nmk2DdCjrFqrkgiJ5wiBMJNalVaGT\n", + "pJbrFuGyRjk3yYdaIfi8rmnJqlK/vm8S5qoYhLBtNxyJcUqyJI+H6nBWqqeZ1EqpJA7EkKo9VKj0\n", + "jeRKM6vesaEOmZkTd0yMkJoiUVlTGjoTWi7V3dNtAAAgAElEQVQIturCOORGCneUtizGCAGPJPJy\n", + "qh2PbXRrzbJj0Go6U4+MkwMNQUhbkvncYRI8Gh7Y/sKxp19mbbgYX/+Lm3RepJcvFnfZe3yZLkxY\n", + "u+60GDm9RlP8rnRCfi06z3M557XrjM+RzNh4h6dx49tZO8NLN7/8SlkKfObpzO7jc175lhWNtVr0\n", + "SKPzwJKOtXhsJ689GYPN+YIDctTmYYw6CVcSBgmbkdsJN+KCxPpOTj9JPQ59r+iZq0UtU7WmVM9M\n", + "Q72wUqgLMa/kZdNyGhy/tClv1qpkKFrWEeSaDpxTauKAuEbYc+yORxrOaGiYKCQem2p6ZF20pDaM\n", + "tXk89FyVWlMJoibmMwbFfY/PfdxkcE1zMDC2r9zNjJcKk2btcLfh+NxF6eul9kpt9Xru/vGSSRpN\n", + "jgNHy8x3OHiV/YzHu/yTepHu/Kv3QIePfJj+h7gHy8w2GB3yLSGET/1WitH3U02T4Z/ig/hnIYT/\n", + "NMb4mfduE2P8q7/T/ZxqzP8OP/GXePIStqfu9bc8vPmt5m90KIc0Znzsw+yWek8uW63aurNHdtc/\n", + "7aCxqbN7IMQV9bRP6wKxzfSQrCTbInlsEZH5ELlM05J3jOMjuZluCB7quy1R6dl2pBDsOqdp4p5D\n", + "B2qXNUWpVEtPYtVYFIykdqWO0E9rtcqhhpamsQtObNiWqkLTfQPHyVA5Wbd+a6C6dIY8aDQqdSyE\n", + "sKuUynT0TM2TcmFTXZeqak21t2/zHv9qRusMty/xxlPk63zboy+71T7s8fMvWLj8fDPi495/s7Nf\n", + "j8/iL7/fB/G1YEijdzqXHpG/Tjb6TWSCMcabITR+nDPLiy/d9iGXj7j7rTzf4qkxKz1e/iFe/adO\n", + "VUbH3P8CT5fiubkvdK9LqmWt8cDJxjUxOVKFnt0wkMYvmsW+EFsmsc840RPUzR3tTma97huZ2qiW\n", + "7KcddXZiCXXat1aXgso8DD0MI5K2EOey0FZo48RUH00hTPQcyezrqC0LWla87Kq5pkXJcs7AA7Vz\n", + "2pZlZsZ+RRWiSzqWnOinlQ6WJN5Uu2ARM5LgAoqQeJS2PRPmTqpEM1mzkrSUBo7iY+Nmbphnjkcz\n", + "9S+NXX2dOmv59IuZB/0l8w+sCPXMF7cP3b1y6Ft/iSunRmiTnNnvKHDtt45si70P88Kcs0OmTd75\n", + "GLu79O/RmzLLaZ0SVsslssZ5g/4Lzt8cqNcKs/W2i/O7jvNj7ZPa5eXgagzGKfOUfsIxBpHjMmjI\n", + "LJ0ULjX5hQZ7KceRg3TbOK6qTXQUKE1VRiYajmTGWnKx0Vs0LxNmKxetqrVUakGhr3RgZhOlRFSb\n", + "EeZ4SmXPTZU9pZauUtvMA9eVrkodxr6RUgwjbyWlj8+CPKGqOEzYmJT2RY3Ht8z6mfrR0/yzoXh5\n", + "rn76WOfVM07CkubRTDbZMTt/n9Yqg116Oxyv88ZdTvb5b2OM8690VVZ45qJfS+RPiRfxykKF9fVb\n", + "jJwSzL7792lfj0MIf41716P0akf1J/4EX2wu+nhuLfq8rUKzG5wrl7RuDJTXVmwu7wvxnmmdCXt3\n", + "JRuVeOaSmMzF6g5Zj9C16FlNLfyPJ2pTQ3MtbEpdj2veCuc0TA0deaRjyUwhE60qlOaCxFBhdqou\n", + "j6KgY+7AWE+2mF2bm+idyoAJ1mxIdFXmZrpxSRK3mBdWjh4abL2tytcNs1LIDnDkqVnHnTD2KLuk\n", + "UfbMQ66YDVWt14QnOpYfjD25c+qxssHtZ1ifcXTIzspCc796TKttMTz9ZsTXE3n1XXwG/1MIQoz+\n", + "QIWc/QM2r5IG3Fjkpvz9GOPj3/xfFXfo3llkS8HPfIRnIo05JwcLUvrSnIc/fCaEJwsGazy5znpi\n", + "uNkUG6vS6tCsvUTa0p23FfmuJCwJ6b5ePXJ2NPKoPzDqJJIkkcWgXc+l6UQdUgNtBaahaWxXVc/M\n", + "0obczECh9gRWpKGHL6jjQB2WpQ5Rqowce2xVYtUiSHPgrKmlUxn/xNCa4Oh067m2WmWuLVhTCBK0\n", + "NX5VQRPkotWacZI6tCZLKkU2d1tlLSusGRnpa9RrluqZpdmhWZiZ/B9j/gM+852XhR+8Ih7NWf4A\n", + "nQOxe+Aov6TZec3Pf2LH+k8skry/lDB6NYRw3qIl8fD3bnRb9Dnb4YlTE69OuSCZ/ujzlNmimHj9\n", + "0iI7pjlnt9Pw0LbmUWGyHI1DpdlNJMmmGI8Mm8HZOiqSSpHSS8hrOgn7MdEVmBNrqhlZO7cUo8tS\n", + "b8Q105BjrOXAzIaGucJDwY6WtrUwNzMkTBTJhrkgrxJVmpwOXgZ2JaeGpk2ZwSlXdNninXJelBlo\n", + "OZHqeltPoafjtiumoS2Pc2UYG7jrF6uJ5/cX5pS7bVrjRDFLNR83jIbPqn+hy+RpY6+59wHON099\n", + "8kXjdMX+K0eU/5InA0WHN24yusf//hsVIlAwGC0Wpr+mKD1VOPyWHLq/XsY0v+c4ZXu/ilf7IcSf\n", + "4JNPMcyoXuXiCodN7bSlcwzL8rcLwyrlXGGSNlx8cOS43XLUjgKKvKPSEsxEZyw6Ix1sq90yD4U1\n", + "mS2FPetSTbmGSuWBfZWx3LGpNZlcYmQiyh1roFhQngw8Vom2FO6ZG1qQ4fooRWMtqUpDLZWokiXZ\n", + "dEeR7buz2RIPJvLWTb2s0E4zvcMg78xNG+tmcUWRNswtq8Iq8ZYsXDftveEff3LF6NKWav2RamPf\n", + "2+3K8XmuPV6stu6dZzC04Fp9M+Lrhi/yLmJ0PwSVxVL47lfb/usJ7/DfvLNweITbX82pcxFyaYc3\n", + "jji3uTAum5xdBGI+TBfExWmj5a1P9HXPf4Tdh5wbyz4y1nkwVs7Oqru1JGPc7Frdq427lMlA3d1w\n", + "oVpW1m9p90oXpycO9cyalVbNtJo5SGdmoavMNs3rM+owNAoPNZKHGnrqOFd5WhKWhTCSWBK8IITP\n", + "qU8NC4OBloFULdWxpzRQ62iZaEgURhrGGlpa2De1KhUXSjgnClFPX/tUkVeqjdUGp+4lj22ZWRWS\n", + "h5q2POGxOrBZl4Ijd8KmaexaHhxLu9MFKbHY5tnvFb94hwuXmOeS5Y58/VCaz52sbyiqHT+2z+wO\n", + "d37mHH9xezET8ZBRCOHvxRjf+d2/U1aXaN7jwTprp/fIvSt0+4tuWChZLbjfpH+T5PXE3veV4upE\n", + "a2kh2x2pzNJgXheGKYnaYbboXDTighS7izMSG2o7VWGnzVFMrGp5flopmx3D2LSXZO4lHc1QWPGa\n", + "A8cSR5pqB0ot61qihoZjS4t+SLoQZ1fa2h4KWtLTb/NohisWfuv3LSRDS7gvmqvlck1TywaW9YUF\n", + "AbrIhLBl0Hnsdp6IdTAa1Yat2s6dVHXzRV5rUEKbWXDv88TJvvZSqg5te8PvcvTpCxz/BLc+xeer\n", + "Rbf15rtqqd8Iu/ziK3xgm+P26T7usXxjUZz8lhy6v2mKkffihB//LG/c4EMJ2R7/8jrfvyQ+t7gR\n", + "A0I9UR8d2r4b3Pu24MxB0I9H6kFf7DWFrOlIS4y3VWFVNLHwyF2Yj809NnO04G85sSPT19TQUSkd\n", + "irbtWMNMT2HfY2Pb5hJjqwYOZcbOOevYocRM7a4ejhUOtdARDFXWpUZx4RJ5mO2TjayeX5YfrGjs\n", + "jRysDqw2otBsuJctu50uKWKpDg0xHlJFWmeEcirUm+5+8lkbg1XN48wgm6haM+vdubq/4OGdG/Kw\n", + "TfhgCOGV39wT4hsL7zE7+8xX2/Z9wMv4kD9gxchp8fHKV9suhLC8wZ++zjMZ9j0c7frxks9fOm3Z\n", + "l1z8BfrDxNtPnVUsBfPJUHLpnrU/su5cKLTah0I88aiZKKqmSTJxsLaqngyEaa2bTvTikYmRy+OG\n", + "1cktn+mvu1t3PcjnqrQgPkk4Y6QWkqEYN4zjXC8M5OY6EuOweN5bCmOPRT3BEm4LgpauflyTh6kj\n", + "57Ud2VPIzE77HtFEpTBWaAh2BF90om+x6jxwYNk5iVQtShxK7cutGNtJeoY2FMZOtOVairgiOjZR\n", + "WzG1Wd93s26r5sFg3uHOCb1lNs9x9wadivUTS2cSeZYrGsHq2x2DTu7GYaH4H6/y734Po+1TvsAO\n", + "3X/GD4cQ/vpvJ9PmN7jeKdkH2fz4IqZltk3n9cWi/dZlygbzcuGOvXaTg2NuPUOvxb0+j/enjn7m\n", + "yPr3NOVFIa7XymaQz3Y0WpVz8+Aoi9YRq8WkoSgYp/SS0iwg42jM3eXgWhVMqpZYVNaSEwfpum5I\n", + "HXoLI88rbUkFtdtyN5Q6gsyagVpTD4e/6iiSachNbTpWuOWuy7hlMSiaWlic9i1MXtaM7UsMZPoS\n", + "jOSq2FYntUF9RrM68nq4IB9MFC4a3b1J9XmmFRfPcXSPJ29wpa1+venuzj5/L+WZZcIX+einyO8t\n", + "CpG/Z/FKa4cQ5u/liPx6xBjf7obwY8d87wXCjHCH4wf8r79ZR+W9+KYsRk5P6tveQ7zshtCMRs9u\n", + "OdhKNJNDk+27sqR2VKE+drXouBcOXU8SD5OLYrlnlJdmhhIbgkLqLU1x4dehMBC8YduJdROrKocW\n", + "dXmlq3LRqqZc6eSU0Jq4Y8nbcrlUJlhy4lDi2HXnMPO2Y8e6Ej0te24bWvFA17yoVfGuVuPIclyS\n", + "t9fMzncN6rZ8PlbF6F7+lGq3QWdL3swUjbZqfMR0k8N75udrx+f66k5f+jAh5qZJQ2PWUpUHJmml\n", + "a2EffeGE0fezn4UQ/revVj1/A+EF3I3R7+iL9vcI7xYj/+j9PpDfLZzyy84jW+fPvsjW09zbYnSX\n", + "5Z921H3H0f9C9i849928eAAtxxeCQZ463HxoeytxpW5rOlFspLaPa2s7d728fkFW7Ws3Bor6jnmY\n", + "6zg0T/ZJaum0kHfnrjfGBnHdSbVknjyhoa+ot8RkIrorhnuCrhCX7Ie2k3pMGi3bM9RRydX21O4J\n", + "mqKmYGhqoIpz03BoILfqrFouc3iaOJVgV1SJvhUP8Kq2XWfkgsJbCys1E4ljG0aO7KIlNT3llz3S\n", + "djG2FGZSA4chqmMQ66AcNN0ZpgY7u4v7p5ijXLz9jx/Lr16RVTnzplA1xeW78ryw2m3YeepZ8u33\n", + "dEjPMHqO1YcLU8DfoSPwyvfxwkd4fpdGxad7fPHD/LH/l8vv8GCbo+9gf8hL+wuvmYcPePs8X4wc\n", + "/jXO/5X7+m/Ujj667P9j705jJUvv+75/nnNO7Xffuvv2Oj0znIU7xUWiqM2WYlMLDMeLEseGYTnI\n", + "Ar9IgCBGXgSJE8BB3iQBEsQvYidxFMOIIy+KF8qmaYuWRHEbchYOhzM9M73f27fvfmuvOsuTF1UM\n", + "SZmUhhxSQ0X6AQ3cRlfdevo8p875n//y/a0U0er4yP7ygYWUmuh4wIMO5wuGGad1NsuZ0++NZNZ7\n", + "kSWUZaZetuXpRFIfW0ju64TUkQaGNiQuSSQ66gYeEfXV7EtkSlEhuK+Y481yJ3Ycazhnoq2vqeHI\n", + "SA3bZlmRXfMoDyfY0tdVqrTUtFAlpaGWqUonrovF+5wVlWo4YnwqWX/O2rVPaPXquu/fcjb9cT7x\n", + "KMcPWPw1LjyY1eMvbc0ogGdhlqX8b84zSGaf+2COcviWBN5BjJ8KIbzwOhfM+A93v51y3e/LYOSb\n", + "aRDjJ0MI/fuO/2rH4tVAtWnUuuhksacWj7y+NLZkydX8RGda2akl0vRQO6xIwkBuILMt1RFMRWOF\n", + "ykPXLSpcVjgRdDGVaWjZlVnRsomapr7zgi2VgcxQ6cCOqaGLVh04c6Qu9zQ6ckOlJUcOHFI2TJJK\n", + "lg48XSxop0tqoe8kRA/CmmKSCdW+vLFsnE7F1q4yu6hMGqSLtPZmxdKi4Wy7J2tODTu5vFrU627J\n", + "xwMHbdI1LpywfJfmkO4Jl6/z6z9g5v77+0Hfj/0iX9Vz+FNv9SK+WwohPMKln2e7w8G7BqbvekX7\n", + "1m3jJ9cdPfhxw2ffTWefR3uKT8xawQ4/zIVYuL+ceNjatnJwS+tCzfrJme7GREuqkUWtowPLawOj\n", + "pKlejAzrE0tJagUrMbeWB2drqXBSGVapqrZktXlFFZclBcN6LpMobEgM1YyMQk+Ii6p0LLWvb91U\n", + "Oe8B2xE9KtpUuWUsMwjV/EGmY6SQOJPanLeuvqhlxaqWRKbrgVOLKjWpmmWpqQZmGd2+jq5ly7qi\n", + "VF/w0JJD14yrL+uGuk4shVBIq7ajKjHortnbaxid7Sh+2czfp1wL4bnnedcqxZeEdEWRN8hyjdHQ\n", + "VE8rp9ass7X0W4BY0CZvzCzI3+TeX/tZ1HnpMqt3+IkX+Kcd/v57eeQ+p+sMIj/2mdnlC8736PVI\n", + "J5hS1UYebd5UO2vq1aIiTGwP2W+TnczcmgcTHi7zaJyxatZwP/JqNZvYyTLKamJQ71qTioLU2Lqb\n", + "7lqWKG3JVDJjhVJuINFVWdKwpnBi4shInM9NjeXzc6PmyFNSU6WaxAOZA3WJQsvYxCzV+TaJBUt+\n", + "SNN9XYyEeUm/L00OKBfUpk0r1bHBym15deKRTuKJlyrv+kLNZ7dTd9KRW02iC/TOcXWFx3+Ej72m\n", + "8b6p9qV1ro4Nm9umv/xj4st3WPkkvxBC+B+/2cj8VzXPcH5Hpfs/CEa+US9tGTyzatDdklxtyIqG\n", + "iwd9k5Ud9y/dcGE6dKWsWym67jUuS8q+pexEFXNH4R1q2lJDY30NKxaN9d0xseHIVN95leuCPVGl\n", + "MnZopKbU1HBi5juRGGnJLNpy177cvqGBDRNXZqeQSqmlsiSzHEtFcmo/JOrVqk66Lg9NIUx0Ylc9\n", + "LBgt1yTTiXFyS2OtTRmMRq9Ia21la4DIYYf+iXjQkl9P7Dav8GKN0YH9p0cWCjYPeHw+svfMBhsv\n", + "sHU2Mxr8fRWMfL96wDyHv/pWL+K7oRDCMtf/PH/0jPvLrGw2bA1GTjaW+Mqxg3P/yovvfrfhjQ7b\n", + "3RmO+mMhhE/zymbJZ5pq/9GChdMgP1dXn/TUxgNxsS5JJnobueX81HvudhTXCrfSxCPlVJ5kqjJV\n", + "1CtrZenLC5lury4bVfqtUgyZNPbV4tg0LAuGApK4qxnOrBrKLDs2MNKa/W+qe8pkTU1i6jVsmLoi\n", + "OFObhxFdTWMnUgfqbqtLXXVeTaLQs+GGA5ftCIbI5YLckS2JhonMWE9b07LEkkzw0KmUJDqMtzRC\n", + "33Je13jxyGBcd7esdF/sqt2qbJzS/2AIYY/m8BOsnDO+sqrqPSekOSHTGLKx37A4qXsxG/DKLj/w\n", + "5HzPDmm/xNMPearD5Y0QsiP+2bdbrpllw5b+Am97nKd3Z8HW3ffymQv8wJf4hyN+9RMoufgnv/bO\n", + "YZPbH+Dmdba+xMpfZmeNwVWebo51puwszkxodwsuVSRD7o/Zbs14IiMzT5payXrOE13WIzs5z14e\n", + "mqqpqUxCMFSzOv/ssdyOwoIpGl5Ss62jrm1JadmppoZbrmNRqpTqzfPiY9FYsG7ROdwWjC3rO5Pr\n", + "a2FBS8RAYcminqGRMu4qjDXiWBqeMh5n0upEzY7m1lhzVDla5zc/2CBpe/TkJSdPPe1kN0FkZZXs\n", + "FY0PTV1aChrlkryIhsOviB88b/f4CfbfzqW9Wbbr17+T7/PvpD8IRr5R61vEBs0PqG48I7wnV2Rt\n", + "zeMVw3TRa4tHFh5OdWOq9uCW9JHKYlpoGJqGoURppLIss6qptI7b6qIHFkUrZtvfNDU2tKbpdQ+V\n", + "1i0ZSoz0VXKpTM+iiYGGgbZUKlNXGCllUh2VXalhKOwKzse6UdKSxEoMxSw/ExJjZyb60ubQ07Gm\n", + "JRGqh+53rtotOtLpnmkyJTvj9R/j4y/wkwe8c41am6LtYPgai6XOKbdX2EvJb/O+PY7as3rr7xv9\n", + "EP7bt3oR30Kv4lwIlmP0LZ9gfm+o8TRPJWwMeO5tvPe4NFoMFpMje481NOMdS1cLw7T/dQZs8xvf\n", + "SQjh9ZtqPzPSe6KmmpzaWRvZ6o5k45HQnj1Rdx6y2ZvY265RW7I46uo36qZFbhKiflnopdFBOZFk\n", + "Z6ZFS5KuGYbSzNxsKHEXd7RD4jELmiEXNazr27Fqb47xrjTlUrOutHWzC3BHYWRgVeKWiYGmPYnc\n", + "ZQtqzuYgs9SSaNVNqYEzq26pbBgI7jrWNsK6zLplq0ZKXTsW5cY4Jw8tt6vXtMNEKhj94kT56Ykn\n", + "/hRv77B8nhc+wtl1nnhmZPHgti9vdb120NQeLnjbcUNnPDVodd3cSBz/cuTGy+wucWltNgzw49ss\n", + "PsGdx3n+Fo//BpfmcMTRG9/75G287TxXz74GN1ud8Lnz3DnFp2OML0MI4f/kV/4c1y+Tv5dykbUv\n", + "8NMvUib8gw/PWkEXIxspxwmhYn3MV9q0Trm/wFptNkF4YYLarEyzNgeWBFwe8PqIu/Wgn7Ia29rh\n", + "iovG2g7tKn3ILKtSSixqWDGWKwxEUSFxTtA2QBDm5qalyhiFjqlCXTCQe10imvWOLKLUsKFlrHAk\n", + "1bHitkHIncSWKj/naBo1khuqzm0hnlrusF62tK/kqotdewvr1p4tNepT0iZlPkv9hKnFi6n6NFcs\n", + "N8RQClXN1uhl/cee0N1fZ7gwG9P9nugPgpFv1LBLtkLjVy0+cWR9obTSDAZlR9ZvKE9pHrE2Kl3+\n", + "lxMf+9OF4t2cy2tOG5FaqdRU4lihrmeqI1rV0jEV5AYK5wUDJ051FDK5ysChCuMZZVVwMh/WW5er\n", + "CTK1uTFeT1Q3lQraxhoGTuyFqYape4ETuYGOussmesbJoUuhbl1PiEE/27BdvW5YX3ZYtNQnpXR6\n", + "onPuV/nRy05fvqlIb7Bdl7V60sHA6Wf4YpPyHuePuXw0w3K/ssnxP3yrN+93Q3PY2YbvL9jZ/6cY\n", + "lSH4khm/59fe6vW8OTWWZgTMKqDJ+snI/QsLji+tyEcbavtHGs0x74izO8A3KMZYhpD8Tzct/yXO\n", + "jTl8nH6DZpsbFxn0eO8pp6uF0ShTNgpTddMi6pYTSUzlMTEWXAmsOtOdDt1rjR2nJElDaiQayGJh\n", + "Lcy+5WOJhkNraHnNWHQW2nI9s5nrJYnmfAC3r9JQqGmrjIwFOSp1A3V3JZatSGVy0UjLxLboVUv2\n", + "XFTMzCKkWgrLJk7cMHbibUYuzo/HPmr0PmJ41OczBzzyJZuP8lMP2Bhy1qBxmQ83OHuS9c/yM58a\n", + "+scXtnx5v2t4fl9jvWl8Epy9PuafxBjzEMIv/jr/WYefvsZGm/2S9inrT7N3PLOTeNqMgPAGtfI4\n", + "j+5wtsVqg/Y8INks+fVtDp/5un2+H0L477j/fq5u8dFXWJqPkyaRy4EbE6a7PNziqMYPjthd4As9\n", + "Fi7SbtJpUB8yHswG0potjhbYqc+4IlVrdi4u9yvTRZbTVKXvTEfdok09XaUCU5XCbL5yoDCdz0wN\n", + "1SW25/t/otA1y9OM5fM5qdxEqScTDC2qLEmsiqbG9qW2NDRM3ZcqJLE9Y9U/fKA5uq8+CNJqoLzU\n", + "slWs2tjN1Ce5vH4oz3bsvnPb5IX6DKedHc1inZVLkuWWfEhs9eTLDyVHizaOR+4uwAHt3tfaV77r\n", + "+oNg5OsUYzxaC+ErJxb/2AVPFps6B2fiuYmN5p6d5Z5BxvPZjIz78tPFrLcn5059KnHqQXyUsKiO\n", + "yrFDXblrrmvqGTvRUGljqLIuSvSkyJ041bBrzaqWpsJE047CmcpYW2pb4VjUVNdQk6GQmlhzSdM9\n", + "Dx14yrKmqQ2pMyP3jZSWbFirBtI5z6RM+5bz3KPjtlZ/X7lYaS8MpbVSrTqzstW3kw195FcYbJFd\n", + "oL3Fa5u8+iTFMUc5+2fc+adMvviWbt7vnn4Qn/s+g539Vn21ifX3eDDSvcvOj/JUJDvluBlVvQVF\n", + "lTI9k7em+uP38dkJP78YQujzqRjj100SxZe58w8Y/xE2jri/xt5Dzv4qtWXSf4vHj1idJqZ514Ol\n", + "RGvcsr1fefgYeRZsT4OttHS3UYj1wvr0jknjvFpcVgsd0ZKzsO9Ycw4qnMx7waJc5cCBtVBz30Df\n", + "u9WNpRLRQGEi0VDpy02lcmuWPaZnJDhvqu9UTV00NVVqa1sSZTYkzpvdzBYFd3WNkMq9zdiVeWdJ\n", + "UFg1KV+aXfN7B8LVSmNSE5dzzf9ndqxefpzVR9kYMzw3w6If745d//Krjn9i2bW9uta9M5NsZG/C\n", + "zSU8SLj+TpI2n77K5Yv0JtRe5/2rfHyL8cKsAfnbCEamgxnp9cJnuP0hOu0Z2v72Irv/OMb4Db4o\n", + "McZpCGGXduBLP0zSoBpTnjC9wvICD1cYRdIBzzfpdmcmeI/26QfGgcd73FnieEAR2QmsL7LRZ2+D\n", + "fkWzXXhEzWqoaZrqG3lV3SUrMiP3DazKpUZOtdXUNZVyIylKq7NsupYgEe0wh571pBpuqFkUvEuq\n", + "JjU0cd9YR+HYUE3qTOGuppo8vt3C9IZ0bdfCjcK/8zf4zafqbv58TXvv2GCb6bQpGaxaOnng5sap\n", + "0/7f5x2nbJ7RW+H0vsHKtnqYCpO7qjLaqjFprRk9eJXNFxmN38DE23eqPwhGfotO+Hzqwg71q7mi\n", + "VjEcKbOBtcZQ0uOdH+PVxzh6hI/8Crv3OPpA5WAzUjyQ1wYGyvmk/6p0PsBVKTTtmrqqbmIomnkL\n", + "XFc5E1Qa7prl1hOFoWCkY9lFDU1TZ1jUc0tzXq5ZNrLhvHROW7xiNMefzTyAl0xsim5KqqY0GZrG\n", + "hnaMYpJaGTKsdU1qQxdD3bUkStNC0ui6s5ErhhQLbF3gXUeMmixfZDiepUrbr82Gzuo1/H4p03zY\n", + "939vzHP40Fu9iO+CXuWVuyxeZusGL3w4k11osEv7Tt/dpYtOiw5PXRLWSrU/35H/yVoIXyx42ew4\n", + "NKi/h8n7OJrOvFQ2j7nxGPt/k1tfZvinWLqQq4eG/kGiU43c3IjyUGpVwTumFYuV9yTciZSNFYNk\n", + "WxmitoCWFRtOve4Em/NZmYlKV1M9Rgthz6mWqUNNhdKLCssSbUFP5VUT+5qanlJa1LZnat9EUyGZ\n", + "M0i6WhYsylWG3q6hlJuVfiuPaXveUEZCDJQAACAASURBVBBsS+TKeS41ix2VJXnjczqPTF1dzCyc\n", + "lIbbNb+03VY9GGlcmrrWSQ2zUlWyfcb+RQ5bpctfPvYDzxADy2czP5hf/rkQwqvn+cCTHO8Tu2QX\n", + "Zwc9XyI7Zv10dvff//a2vv8iL/04j/R528c5WqPX4n7G+O9+8/c0rs5Kex/cZfmEu4s8/4fZ6rBV\n", + "cn6XgwV+c4FXdige5z31WfmmVXEHzyzO2Hs3a0yTGexxtZiRD9Yr0jrtIlgqKgfpVE2iHQoLKoey\n", + "eXNx0KoqSXLsxMSylpahidzY4ZxAElRWzJxuemZAjkxlVy7T8bRq3ldS6ai7aOaAWYleNnEqmqKu\n", + "qO5rhCjNma4t+J//zJpR59hGZ2glS3TGmVoYmaxMHBSJwcmJ+BsbvPsHebk3s5CIXzHdeUk9bdvs\n", + "tq28vOf4qWOvnB8b3rzFzgEf+534P29GfxCM/OuKpcu/eeD6b5zafzwzOJ9rDwsX7/GlKY/dI38H\n", + "C+mqT/3QNWmeiXdv66+umbYWpEXXNFuUuSY4lbvrgUWrFiSGxl4wdWhGCGmrdGQ6UstyAyceKKyr\n", + "uSYx1XTiwMiaqGPseJ6o3XHZspaacm7hUSm1JXKLaImCMyPJ7CKYzN57LkRTqdTIw1bDTjmQlTVP\n", + "HhZqjYmiGFt7EK08ZHCd/af4wMEMdHa6xmZBHNGPPH6LzSHFVfavm/UrvCGFkD7J1h+ido58l/1/\n", + "+T3Zze++fhj/1Vu9iN9Bz+Hff6sX8WYVYyxCCL/Ir32YlfczfSEYJ1ONrKEsrju9uy0+0rWwdqbV\n", + "7jm3mMnXVzz46Ibhaa4qjywcnHq8zweP6Ke8ts1Tr7Fyjn/1I/Re5PjXeDBKhT/blF6tVEmN9Irz\n", + "ZSo49aXWoYtJ5UmUaWovLEsQpCrBBVGi4UTHsZF1LaWRQ9Guyko4NVTIYksalixoS5zKPZSb4tjE\n", + "SMdQRzBRt6rtnMKZsddVMixpaltXSB3NnUoCgqZoLKoL6kKcEGZI+iAXzfzqojPRwKX6utWVUr6x\n", + "qd1MdJbq7p5/xLix58XY1Rw2lIOR1x4fO7/L6eNs/wbrX9eEujVg5TK7S4E0o3yUB5/j6fVZCnWY\n", + "EA9Y/jInk98G7f8t9n4vhMbf4+//cR5JqCK3C+79XzHGo9/6+lnD6+WP8MQXOH7b7P97ssz1GoOU\n", + "uyNubhPqLKeM38aFOo8ms2CjStgIvJxSFjOy73qN1W36AyYZm9UsCOtUUZpG7cnUca3SDJVakroT\n", + "B0Zh5LKgTGir1PWcmtrXMvCoSpR50WgeMM5KdetmAckmUqWhoa7UJZVEUM2nNPdFqQW5IMhlugYu\n", + "J9FymaoPgrtrFx2Gi6qDL8tkhrWpZpZrPKhbGI/sXKrpLqxr/6fHGuUXVLevOst+kINUvvrQnd2e\n", + "s/Vc1u4Y3NrV/++HfObb6/f5zvSmgpEQwl+IMf7vb+L9/4MZPOqLMcb/+M2s5c0ohHCe2o+y+hhb\n", + "BTcv84HP5y7u5l57P1sbHGbE2PbMT+eSJ1L5yjnlwwuWXk2EB335ExMPmk1Feg2pxFQmEy0pPFAo\n", + "tKVacj0Nhz6gtIDXRLsKG9iSGenatqAuzivJwUNndi2qeVR0Og9AEkMjuYGgdGwYmzpheY6Ijkg1\n", + "HZhgEjKvx4mzEGwYGhnppZcUr3Q1Lkwl2UR9WGk/ZHWP4eLsiztaml1TmIGG2jCapUFvn6N1b2ae\n", + "ZcsbDEZCaLyHd/08Hzzk3C4PlvjcL/DCd31vv5sKQQPvw2ff6rX8DvoSngxBPcZ/fezy95LmF8F/\n", + "Mf8jDeHpC3p/7ie5e4uP9DU3h1ZaB5KFVZ16lKlrlBvuFecV9R3ZpVsO+w9Uh1ztki3y6lP8wBf5\n", + "7J/h+j3OrS57+Q9t29+Y2atrLsvSaJQlimrFNDbcTe6oC9ohuGpsR2mASs1Y4UDHmWVB7obcvppK\n", + "w8TImdKK0nLoGtpReVRTWybYMFLZcWTFBSNtY4eilPkUzYKOoYeC3MLcj2rJmUyiZqqvUqGm7kyr\n", + "6ukmicxtuU2LsWcS6oo4VoY7amHN6rSjap8ItW2d3ljeOFLvrGuWlxxVr/tsreOdg5rx4titx2Y0\n", + "04vv5MZ5Nm6wdjoroYwjJsc8/xo/9xHuPMWnXuC9GesPWTjiwT5/+zt5oo5x8mwI4VVuXjEbp7kT\n", + "Y/ym5olYYKnOk19m92zWP7u3SCtjv8V2Ovt5nFCLHCWz/pNBwkacMUyqOovJLG7KFnmwzShLDdul\n", + "pcDWcMYAG7YIZd00YZhUepEHcWIaxkY4FvWQCtZkSo8ZW7IgUero2ZR4RfS44L4ZsvTdvjYjvYGu\n", + "0o5SZx5Qjk3sK3VNnFezKhq4JlpMjqkFxdaqrdDTbRw5rS9ZHeTuN6OzZGThAsNh6iiJOnHTY2VL\n", + "u79jfOWGw7zpVvuq6uFEWfyMo48d0/rHM7z7p+emh99zvdnMyH+N7ygYCSG8D50Y44+GEP5aCOH9\n", + "McZnfsc3fhcVQkiX+GOX1P7igrWlocbo0PLBUFHnV36aD36SacmdFe5mWzrTDdnJPYN26mwhKloP\n", + "jVcTVZ7rL2WqZJ2wjZHoSHSgMYtPFYLrenoSGVo+476nFZZQm/tLjHBFIlPoS+fFlpYNqZ6pRGJs\n", + "oC9xx5nr8xNzKFdIPMSyqKlhYKqQe6ipI1eXh0ccV/tO4sRiVbg6va3zBe69g/EaizmthzNvpAdv\n", + "52SB1iafXuDiPRo5B826wVrT660103Tfl352qFlwrRXC5iMc/qPfbg59RlS89FF+7AGr85P80tns\n", + "d39/ByNmgfMrMX5/I/BjNAzBHTzp98BB/XZU8ZWX+een/MQClybq233tUW49XdJIg3FtRWdypN6+\n", + "JJ0sSrINRePA564Vlqd1h62GvcdGjuuFzcf42U81/eY7N0yaK5rNZUFmWjTlCeNaJShUMTXI9jWq\n", + "qeWQ2nJmEFaV2nqiI2sGxoLHtDxu7At2XdQyVjd02VRdX2Wi7bYdQwOLasYmjkx1XTK1oBCRqXso\n", + "11KqVKYyQ21HViW2JFbV3Ra9LrWgNi/VVCb6IZFI1Z0SC5NwJhMUYU8ou9phWVrvStNMYqBqFoq0\n", + "YZSkJsVUEbfEg45bu0cmG5nGucL289RqbK2z96NUv8HtNsfPxRhHIYRnn+ddBVev0tvm5edZvc0/\n", + "m8zGer9jn6QYY9/XuQH/NhrO+jnGGRfvz/7czTl+mnemXMwZZdQmPNtkKcwCqjO8XufcZBYKPAjs\n", + "By5uEJsdd5NMTenUxIN67lrBXQ3raWYDm6F0HHKFwmWJC4InEZW+MrfruGe2J4lEZSw3VBniGaXU\n", + "rF02Zb77sybWBZl9hUexrHKsVMOa6O0qL2hpW9AUYkOZ7Au1TYkZDv9kbapbLVmbFCZhYJilmtOJ\n", + "hVFH47ShVatLyi2N6b5Lg1ecLtcdFUN6L3Hhy9R2+aXfrUCENxCMhBB+OxvorTfx2R/Cx+c/f8Js\n", + "XPJ3NRhp85En+ekVW6Fl83YU7emtv2BxPHbW5v/+w7RbpGt1K5MNG7tTvXO5g+VcVe+5WJ3pb6UO\n", + "PW6UVDODryQl5DMqo5al+eWk40wu09OyNp8fX1G5693OdEQ3VXIZ6jq2JFpmrRgn81O4NDZRd2TJ\n", + "0LJKquZE1LQ8XTVOh2L6JVOrClHUR2FdqnJBETOd2Bfj1NaYw4TTS2Q3ePW9s+mC9nnG1zlOafVp\n", + "tDlYouiQ3qyrwqru4nnx1onFzQ2Xs548nHj6AQfX+fU/H0L4a3MjxG+mJVbarP6WVOvmt3ri+X7S\n", + "R/Abb/Ui3qCew3v9/ywYmd/Y/mUI4Qs0LixZe/Sc99yfOnisEqqmLE5Ma0EYUsmFeKBaoNZYomhZ\n", + "SDJJsWrnAweuj0a6y6n+uZrxxkXNdCyEoXF2RYxjk9CXpEFjuqyqWu4Z2yjbknRow22HllXWDPSl\n", + "mprWNLxqoq3hSKontWxkXVNhaKjAsj17duWiptJFbBmLEplKZeiOiMqymQfVqo6mjpahA/tG8w6x\n", + "0p6eukpX10TpgmtVYimuGYfgJDzUtaduIqmWFGFEEmRxorCozBbkZWqYvJ3pnrz5smL5mmy4J19J\n", + "XHnIez/Os+/m5ByNBs/9CAe/xOmvzLelPNB4+ZOWnqiJjwWD16ZG/1uM8be7d3y3z4tpCEu/zmd+\n", + "kg/fm2Hiy6fpVDOC6lmdNCXvzCZiQpyBRp8q2U95PZtlenbMhrN6i8ti0nBF3QUJJo7CsZu1XD/m\n", + "hqG0o64RWxZD8ITS/rxX6EyiPW+i2xNt66npOrRqz0WZY7lc1DXDvJ+ZBSIRGxJn8xJeT7A3B8dv\n", + "y5wT7YoyidYce1kXQkcaEzHO/MnSLJXEmp1YMy5ydbnVvK35YOru+qon7o1MrjfEUBPKIMlYu/+S\n", + "o7MDvvgSN854Lsb44Hdr/3hjmZEt/FG+Kfr6zTTyrfiagc4Z3v4mfte3rRBCcpkfOa8WC50xVKp6\n", + "Xf3KguHS2PqUKyPWdiieZ+9Hd7zcKpXnKxfrNY3Y1Im5Kpk6TVJnNnBoVq2sSV1Td2riIcY21Eyw\n", + "rWZRoiFKTARf8qotfXFusBQ1XZmdVCotmdyZA6U1F51Td0nfy7btzxvUmqbO0kovbFg0tGHqnJGu\n", + "JVFw37rJfA0dC6qkodeeaJxy6y6dEY2vcHyFpTVENs74uf3ZKfLsOW71OK3WDG4/Zjo40zwXPdHs\n", + "SB42tM4GDq5NveMZdq/y8DpufItDP2JYMUlpfF3T6+j3Qv/SD+Nvv9WLeIN61myi5v94qxfy7SoN\n", + "4e3n+PF01j1464BPfuOEDBhzYW+gdufA8WpNMpmYtmZ8j2l1zmQQlLW7kuXo+llN1l6zOmEUJi7H\n", + "qZezddnZQztPltL1XAxtQVSm98WkKWiq5nbwedqfcSNCKs/GDiwYKZzz0BQjF6xrOXXb0KFLlqyY\n", + "qgsWnDk28VDuHM7NKZsNLXcFNazqI9oUDKVKM/P4+6IrZuzNDxq6Z2qsUneGZQtagpE1NZnUoQW3\n", + "QlNNJohiElwsl2xWe0ZZQyfN7RjbLWrOZVPjUJnG6EHtMXnZErJleWwSjt1Mxi53px75OCsjfuIz\n", + "M/DcWYvuKkd/62sPHKt/gve8m3fezbVe5/VNPvuzIYS7GJqxKaLvqZsv9P4VX8y4+2Gal8gXWD5m\n", + "a4WLGQJ54KWErJqt6WbGRjkzcH8l4UJkOc2M05oVDdvznHUpqElcwTjUvUflSO5maMzNCmdD2yOl\n", + "ocotLMqck80RDA3bBiqVI9k8GFlTmarcNktjpiC1LDrEBcGixCWVNZUTdFRGpralXjLAlsks9Ik5\n", + "1dhh9oOCsTJUzhpn6rHrrOizsCbczGSjSrpzanSxVDYnascjg8Wc/3XE3/tWmawQQr3JB9b4YCA9\n", + "5bnBrIwz+G7s3hu5AfwTLMQYn/0mi3szFMozs1EMZm7Jp2/id30nyjIaC6rBsfJ8qWx2jd8btBeD\n", + "wzpLDVa6LHXpxoa1r9T0LxZOO01XIrX81Mu1juPQUsSJkBwLYUFqT2XTDAc/Ee3KFUqpQy2Pyp3I\n", + "tM1Qvm09S6KxmkTUEqzrGllUyQ115R5o27SgpYFU6pyJYwtyE0MtaVKThZ6euodKwbKo5cBjjpE4\n", + "dhiYpplSRxajk4Wg8a6JP/13aL/Kx36E8TWupHzohPp8fPXtR7Pa6v7O+/TvfJB7/0Dzx9qWmk2t\n", + "4VRZT+Wd2Ws3I2H5Wx30GOM4hNXP84Uf5Afvzhpjy8AzF7/Ve74fFIIUP4L/8K1eyxvUc/joW72I\n", + "b1edED78Pn7ufRyuc3CfS5/j3wsh/I0Y452ve2lFLEs/9A9PffkPsTw4VdRbuq0NO1aVxUNFdqY9\n", + "HUinDcq+3fZY2qgsjypLydTdtVSajV3a73r1/Jlh1jEMmRBfJayrjKROVOFAlTREjzidg9lnDeNb\n", + "0pgqQ8uxqcqRJSPrOprS+Rh9ZduZV9Sti4JFUysW1D1m6nV9hbYL+gqVIw1LxgrRttmsxSbOG6q7\n", + "71lL8+fkQmmqZlFNQ6KtLZHG3GHZshVyaVVzLHWWrZrKrBvbKGvupsFgVJm0T5XJqhAPhWpkWs8Y\n", + "N6ndVr6Xg+GSL17qyvszz5dLZyyP+HRpPj0XQtjmXe/iR27PvsvwjgeMrvLgL51XnNuejaWMd+mG\n", + "EP5OjPHu9+LcmQc6Hw8h/DqNP8LjHeof4mKXVspwjUZt9hz8iln712HJa+UM01GvWMxIsxnufWUe\n", + "LM4sCEdqMpsm7qJZZbaSUicOfCqU+pouaUjmV+SaGdQsk+LMSEOu0nHPgb6GfUuCY8nMddfQDITX\n", + "ldvFER4RbakELM7JJa+jPYen7djVVehaCiPT0NYrtg3SOmFAPGfSXzWpmuTPcLwkedB1f3vJIwcj\n", + "4n3Hm2PHgeqUcyvzB8l/zW05hJCu82fey+NPzVJJxav82DM8FUL4X74bvmS/YzASY/yF3+bf/u03\n", + "8dmfNuv4/yX8Yd+k9ySE8Fe+7q+fjDF+8k183jcoxji9EMIDyio6TsZcS6XtfaPYtVhPXc4z29WE\n", + "83TXB+ovZBbeXspj3UKsHMcVI2sW4lAMp0bWtOSm6nhF7kghVzmzreWehtSaoJQZOdUz9UDT1JKm\n", + "0pqBpimWndpyrKcydGBBw2ie+BuYpeIyh4I1dZmplTkkJ5G74ljHsSWZnsIaXtcy0pHqVGeotOKK\n", + "V8KixXDTjUtLHlzcdLK9bzWOLbSis2u5xgkLh7Nxvk5CPr7J1nV6K8aHO4aPsGCsaE8tz5tX9wPx\n", + "dwgsTz/O55vcfTdr82ay/c9/t/b2e6T3YzdGu2/1Qt6gnsN7QhDi7JHt+14hhOZVfuonuN+ZGW15\n", + "lKN0dqX8N/DXv/raGWxr9VlO3seP/yNeP58rN3KDD1R6lz+tWq3EkxNrO4W1l+p2PhotWrVxEgU9\n", + "D5oVnYnXN5gMD6yWz7sbHleEBVk4UzqRxpGWpmUNuZFJjA6s6oSGYZwahXWXnSA3EDVMLCstOlVY\n", + "lGjK9VFpyNExlDq1ApraWtYd2J8P6ieW5Ag6ZodghKaau9pKlS0P9OcF2KZNUaWva+xYX81ijCRj\n", + "B+W6Ml0j3TOOlywXK2rVPWexpzU90U4q16crM3xBcdNh+qh7R23qNaHz1MwFuJvbf8cDv3rlruPf\n", + "5P23+cI2x1/fB7I1R6p/3U7ubTH50JaFq0/q3GzoVy29gy1JEZX/eQjhv3yzJYAQQhPJN2tonfex\n", + "PM/4Z2ZZnX7GaJksCbpVlKMe6x6MogtyzZLJhGmNTqDKphqxMAhRMncaK1UyhSrSiLlcXYzR1Ozn\n", + "JXVdDTXLODHQ01TINeRWtQSlnpFjpWMrxt7hllc95siKUz0M54iGsaghuqdy1aybZWBGJ5vitsqt\n", + "+de68lA5c5APi4pkSRUGatqyaVCUF5UParRfYHRT9bczN/7svsNHJpp5ZTFy/XWe+jTHa3zu3w0h\n", + "/Zsxlq/M+vtcNsPYtB7jbR+ZGQqDD3BvzJWjWVXjTXOm3rLUeIzx2RDCOITwa3j2mzWvxhj/yvdy\n", + "DQf802f5hWtOdqYmj3c1a/ctdQrnpqkwydQnhaPFmnGS6L2/J9ZKZ9PSWbPtXrKiHZuyUBiFPatx\n", + "aqJShhWlKCi0HAkyJ644E9V07TJnE2QypaZMYuKpefhyFwfqHlezMrff2lVJ5UptQ7mohpGGGyZW\n", + "JVK515QuSdREj6o08QAftyC4IuroGiSlqupYnBYW0lzv4obP/LFV2XBR6/TYWSM1FeVpKW5UyhYP\n", + "cw4LVhdu22p80tE7Ng13KzezY9m5Y4v90uZdnt/m9V1fK799U80tpf9uCOFfmGfFYoynIYTv5Xa/\n", + "Wf0U/vlbvYg3qhjth5mByVcdyX8vaH2L9KuByFd1mZMG10MI6Tem+U//OZ89x/7lWXp9ENYcn3xU\n", + "+fce5fCE5t919tEDO08m0oWaxTSIaem0WKPXtdCIpoF6I/VIr2f56CteurChys6kajpx1VLoKsK+\n", + "lnXnIvfC2+2WXdLPS+KuKqTqbs5dWHtOla4p1Y2dmqUIjxUGOLZhLJjK1HVN0LNkIjqwaGpZVyJz\n", + "onKmEl1Tc8OGd6mpyVUqi/p6xqKRPctyXRHnBGvFlKovD2P3akOFzFKxaVkQkjUxOZUHtuPEomND\n", + "m5KsoVne0FtfcFy8W+3kWKwN6bQddVaFtdInt4985stj5d9i+Kmv254h3a/74g4bnHwok7cvaXYX\n", + "LZ92hcf7Vh/ryG6e02vtKf+LEMJ35J8UQlhh/aNcf5pECOdusf9PYowPf8tLb/Pw87TfwVGL5iQx\n", + "rqfaRWUpROdDqcgy6YRY0Ltbt/tES5FGRRiowsBE4q6WRTMzw7GJQWRzUhrUR8Y4SoKrGjbVpHNo\n", + "w0OLagb2NbTVLMpNZIKga11wqIGahiVNY0NT0dSqaFmUiO6qSfEJk7kb2deCkZl/WeVUdKqNbZn7\n", + "4aFpYyxxjeqc2lmqWe7qbj8Uy+lsHjtn+pfZu8K5v8hP3uXS4eyQLUxoFBz/dAjh5AJ/9jJrHapb\n", + "XKuIFbe/Puy8RH+Nx/1eDkbgrRznhSLGmyGEv/6QP94xfP+Zaq3v8Zi5Mi3daybK2oa80SFPFYsT\n", + "u7WB3vjIi0kiNpo6aTRROI0152NuP7lgWV0jBmloSKS6DrWdN9QWvOCuaENNw9SSuvuWNRwZSnQ0\n", + "zXAdU/05EmkoMxQtmqhbUtMSde1LDe3b0DGIwVgHXdPYNg1jRMEDHRNvk7psiIm1qrIXSnu1Jeth\n", + "Tb68oKidF0e39N62av1k4rVa1KgSabsybNGr2C9oXBnb/PKLFgYd958unYWJV6qok/Klp+l/gpNf\n", + "eaN14a96iHwPt/i7qZ/y/etH8630VRLr7bd4HW9Uwx5J5WvP2Ttc3OedkeVt/pNmCL864Zk40yCE\n", + "8DfYv4a1Nf74n5hx3nuwzvgH9L/4L9z4D6YeKaKpwkmWOailGmWQtLjSZeGsUt8sZGlpeFi4txW1\n", + "q+iR0QO9ha48VDYkFpNCjJ83SQqlbe3Qlghz3seesSUNfTtS1wwtz+kfRxoqiwbWzG4oZ6aCfe+W\n", + "SwSFkUVMrKJtzdh9fQ/tW3OqckNuQ18PF7TR8IptdROVhi3nZNVDspownWqEro3YdlJdsC4q0twk\n", + "JvrVRD0ZawxYyqc62ZlBu1KmY1spvXBffSVKq1Wx3lYfNXX7J6b7jxndep7xyTc2p9/i5hm317h2\n", + "zNEW7Syz1+xo7A8NLkSbSarRL/UaC5xm1pJc9m+y922dHCGEOhf+Aj+8xFP/L3v3+StLmt+H/fNU\n", + "de4+fXK4+U7cCTuzecmlyF0uVzQVaFm0DEqyKRtUgAEbkG1Ihl/Y/gsMCxb9QjYMUTIgCjQlSKJF\n", + "kDRJMS43z+5Ozjffe3Lo07m7qh6/qDPL0WzgkrPSzED6vro4t+vcuvVUV/2e3+8b7pQk1Gtb/O5f\n", + "CyH872+WD8cYYwjhZ7l2H/X/lEdP6mp5VM+ia0vl2CZT6NXYTRa9uHpZzGqW01wtHRmnN80ce9Xp\n", + "mahgbo4rkcWCyYTdJt1YMUemph4zm0kZw7EQK15WkYaZC6Yqoj1dAxWLGlJzFZkVuUzuyFXBA2oS\n", + "0bJCR8UtQd/Ugj8gua5g7czVdabuVTM33FVVUXE19owMzdwxXK+axIGFcEvdQHeV4f9HMmTheWpt\n", + "js/R+V2Wzq7d5oD25S3+6o/hCreOWFok7vCBZ7jzwdIdDgyoT3xzBlYIoa2ch51+t7Lu9wJp8N8o\n", + "Yow3Qwif7bnyNxsePglCNbfSKPRVPd2pWSwIw8Sd6SN6Wa5a/4LbJpLkUBImGjGT5H1HyUVF6OqI\n", + "WrFQhJaxDRP7Fuxp2lJYdeScEzsakjMya0swkzmVSpVs6kV7jhwbipYlzuk5dWJb/cxvYKahrtCL\n", + "FdGullNjNbUwVfOasXXBvq5U1cihiQJ9wVKMpFX5nIU8VzFzvHBFrZiYth6Uv37Pl+8PukVmtaCS\n", + "8EOnPPM4+SW2joaWO5wkPPGzJDkvrHB08G/Soe+dQgg6ygHze81e/Q1Fzb94p0/ku0GM8Xg9hJee\n", + "5qEPcfcuF4d8bEblA3zlfqZf5D9+tuSIf+7smByvhxDuLPHnLrwlvvxQa7WpftR0ezYRG3Wded2V\n", + "WW64kYk5xZCLr0T2R/LHo241UxlEJ+0NNxYWVWJLJfQcGVgULISpJ3S8DEZSp4KgJtVQkQuuOXSs\n", + "0FUakmUaTnT041BbXwj0fNSpBcFLomWpRew7MpdoaMXL1vK+NCxqp1W3Hbojs6pmrG5kU01V6UcR\n", + "1SE5R3Es1pZV47FWHNsvxrZDIQpqYaKVlJFtw1YingbFtCft1CxFWsVIPUxcSNr2tdRGqepkKOsW\n", + "Bjvfx6s3+VgI4dfOupveyKbhV/8yFy6Rn0dzqvu1gdm5BdlSqjMqZNVI5Uiezt1/h/E6O0IILWV3\n", + "dPCHPzuSh3jfKu9/E+fkwQOOL7L3JL7RsQkhBDo/XHJn9w8JKzOxGkyqhc2sYnVQeKrGzUmi8uxF\n", + "yfpEqO077SQqYUFWbMnDHRuCRpipRRZPuNbmizVWptwKPFSwVCSmyVhMKxZjoR2G9gV5KOM/npFI\n", + "NEQ1OVJNQdPA0NyemVWlJUMqGivsoSJVM1HHBalUbv/sYjXNzc8+cc5YX6Ln/phYj1O74brTkMgV\n", + "OtgKQx1RI0+EUEgWqH+Ew2MWm7y+zAf/MWlRCglOW5cJl7j1Gh8KZeBPMmXhNn/uPD+/wX6P+gtU\n", + "T8vnzBvXPe3yow/wAys4ISyF8OUevxJj/Nc6nm/Fv/PFSDkXW/2ruQ9tZ5YWql4fFCYpzeZ51WzV\n", + "0XGqP2sZF7mlxblQ78iTXe24p2HDcmxrn5zorRzat+JEyyiZq8XEPCwiSOKuldByoqbivEzbxIvK\n", + "kO+ZQkUqlTg0RnSq60RL3cyGsQ2ZDxjr69tWaKnbNxGth541iWrsm6vaFxWuW9UxMJEYm5zJB7eU\n", + "qZQH6BkR96wMU/1qIV+6Kp80GEjaOwAAIABJREFUxUHdwvyi+fA1MefBMbUWs4IHK3QSBqs8dsRR\n", + "jVc/yp/8VS70OP5UCOGL3yt29bsIP4bPx+i99v/6Gv7KO30SfxQc8M9/n598nQdqfLxBbPPSR0rZ\n", + "Q/wkd7b5TAjhK2+8EM8wmzI4prFcNh/AifrKxObeir0sGK1UnZtVNOLQMB06zVnusTpimOZMgnS1\n", + "EOJls7wpmxXa466FxQ6Va24mEwtGoroFJ+pnhmNb2meh8ntOVBxoOFbeLlWLmhblNgg9u05FlxQS\n", + "qeuCniUXJGpyFfmZQVoeKmJaxaGopmYgwUVNqzJ7uCWRaarFnllo6ZjKk6gwFIqpuWAeRrrzinYl\n", + "UyQ3zeJcd8SsE93XLYS8qpekXgtN+3Gko28eO9JAUmSydE8yS1Uz5pWk9OPaVEp8QIxxN4TwM+yc\n", + "w2Ue//PRZ25d98ufuuKovigfZyb1U4PRbYvHPLDPc2eE9fv/hzIZ9ySEsPwVTn7527+0mpusfYu/\n", + "Wx/RvfiWHz7EI5/hx27yyv/L7qdyqw8wWU40ZoWX64n+IHr891p25j3dq9Fm0tCZ1YTaxDTNvBZL\n", + "p5iLRV87zG00eWTEl+rsptQjLXO1pDBMaybmpqGwrdAz9f4YXAsbMm0rirPguyMDUV1baSJ/qKqn\n", + "cHwWATLVEiwj0bOvau6ehpdEq1Kn6sZon4XtVVQ0dY3VVK3H1IqBG2HuROG8xLKZpbxwPeGCoB5T\n", + "YmZUY5bROs/1h7jvFb5ykePnFri6zYUaVy9zUPr8ml/j/s/xoy0+d5fpNr8QY/xGi6vDD32IT/4g\n", + "t6oUGeELfN+XS1+3X/5O3/1/54sRnGe5y/Lh1OZ2YIsb56N8PjFarjkNdfLU+QWa1YKQEYmGHpod\n", + "6lUOjZZSQWrJxIlLxgayMNNwcJYyM1ePtx2HpsJ1QUdUs2euaapmqozUmqi668MqBgLqjp0YSmVS\n", + "mbnE+pkL301dU5ccKeSSEDQMdM0MsHLWCbmG9yt52jNlFHY7UrHo8o2K5ig3S+8Zb3TtDgdi7VRv\n", + "fU877XtkUuYxTMbca/Jgxl5JE1fUaU5ZrHF7iavHbIZS1veee2n/YfgJ/LN3+iT+GPg6/s47fRJ/\n", + "FJwVsv8ghHDfJZZ+gldXShYnaDNfonqrTFQ/fNNxsRHCb32Rn/gkt1tkc5KJSWVi9fVbusfLXn9i\n", + "7uvrY9XWyDTJrH62vI8PF+k9umRSq5sMW4r++62c9vVXt2XrUciDorJmFu9ZjhXjJPGQVE/NqtSy\n", + "qQMzE11LUizakxq7LrevbqQdb5uETKJj2f5ZAHyuoWbzzF85P3NebQoO9U1CYdHImsJcalW07FRb\n", + "LjlTZ0yk8hAMjbWKkWoYKkIwDg1HMZqlrxpG1vKJGObuG1CMqaXRsF4R0rpqTCwVbYexbim9Q9Jz\n", + "mg+Ma1NxVtG+2zJb/y2t/3pfI6XzcAiLv87p331DRRFjLHC3DKu7c44vfOzEk8+MfHmlafuBIPSG\n", + "rn5t7uMvc6/LwVlWzV/cKSX+WeALH+crOX7pW98d432Oqt/884MWg7fMfNY/wmOnVAse3eZgQu+Y\n", + "Xq1QhOjS3cyFE4b7hWK9abO2bPF2bv5YUz1raeT3rFeDJOYUUa1WBgfeScvpQ56UPiU38fH8VC1U\n", + "3U0Sp8q4u/vV3QhVhUOLpgYKDOX6Viw4lpgqNDU0jFUcm6pZlOhIJDKZXNtM1YtyM/cbOIot9ZBq\n", + "FUOHITHRVwtl0k2jSBBVVJ0rhg5DYTGyEetOQ6afFioRMQgFW6G8JrsLjB/ny5OSZzP77B3+2zWu\n", + "XC4TBMGEeJHfPqT4HL+F3yvVkaFSfjVNL/PJj3O3WlJcVIgf487rfDyE8Fvf6bv/74sREqrH7K5w\n", + "pRddvc6V62y3Dz3//RcNh12X8kxoF4IDucx6QUhmNosTMVtykKxIVTTirhg6Zqq4a+hA4gG0TUJL\n", + "RabpNXOPiR6UueGGXa2zhMc5LqlYE+Wi5yzJbWnpS52aaZu6Kziy6NiW1GVFGXse26qhZ4xtXYW5\n", + "e/pWFSZKJV6tKJ/fg8Dm/MC9zZr1vOS9pMkXLYa+ZjXqZFTq7GZs9ljpM7taFjNRMGzV7aWJxsHU\n", + "5L5c/xkcc5rgvWBe9l0jBDX8Gfz37/S5/DFwDUshWI3RN+V5vMtxC9vVtwQwTkn75YPum+6zKV9+\n", + "lvo2n16m0ifuGv+Lwp1HZ35kb9cT19ntcmedV1d58kW2n+RzH01laxW9sGR4r656mgixpVpbMygG\n", + "WrOphZR6dWwcamfbjQSptqqKqYaop2HhzN1nqmZB3cyRy8amOg5VDBwba1mMiRDINBWOBdfNBA3B\n", + "0KncsUSQSFw2cAuLZzndt23Ys6lp1UTF1I5cz4tJT0dbdN7EsizeVs9T48rYjUqqbWjSnOvWeaCf\n", + "upfUhEqulgSNrC/HUZbbdNdSNnN4+pCFF4PxhVNL67vWjvo+8SIrE774H/FUxP/y5jU442r8Ip9/\n", + "lY2PzeS/NOM+Hh9zbsCzW7wwYecf4Wf+wGuoEvm+21z7eAjhN7+17XvxCi+fsLXOg2d5WTeXeH7O\n", + "6GkIIXSwxsYWjbPOWa/LxZyrz/D0RXpp9Ng9Qs6vPpybFyP1yqrGbiFbzkwuz4UwVYs1w6SqnwyM\n", + "sSy4L604VtUME7NQuI2TKnVzI2Whch790LBgXhaicttqTqUmrpjoSixq6jlyV8+mmUNV588CQ44V\n", + "+godK47lUlls68YdWYyOk3NEWvGuk+RE3akiFhbyWMp/04FZUphjFNuup8sacaASxwYIodBKqQ75\n", + "4C1+OXL9dxn8vTMen24Iv9vkby2VGUPzHTqvk3+QV18qu2P3MG2F8H2X+EyHxqC8oJfrpR79G6iT\n", + "d8rFan2nL/y/L0a4R3+3DFX6+jqXBmRNXr04MPvsM6pXN0wfbEkcCdWBbpx/I35qkmYaRVTJ27J8\n", + "7Ki6apZsiTEKyVC0KMc0ZCpYtCk3VnddqmYsM5WZmGgpPIzzEusKPW0rZ3bTK1pGjm07kDhQta8m\n", + "F3XUhTLBN0yNLJpgatO6KHHP3L6+Qlkzly6DzcgsHXuglZumNXfklsPI5RM++RvcuMArDyEpuY9L\n", + "GUmflzs1J60l+7OoWWQuxKpjmfpjQ1+fs3M9xvhHTOd81+NH8GKM/q26EX4vEKMiBE8rYy/eK0GE\n", + "KLkgrRB+5wv82R/iVoN8TvJFLh7y2TP5ZkL1I6z/EMkia68MHfzWkC/dLD2MhjHGUQjJwxz8dF16\n", + "NcrizPQpxr/Nb/5tHulweVz18vS8fNbRLIYGYc98YVXeWpbMZkbTsUp9T6eaq2Cmqmns9MwfqGmo\n", + "sCQYaauIKlK5iqqKuqdd0QplPF6zKJwmYzHuaJsah0TPQEXPlqaa1ImhSswthyCTGImCiqCmrmvP\n", + "FqqWnJiqn/EKbpupOXAOqRB2hYQsPKZSDKQGlgyNqrcchomlSpQUuZV5VVIv7d06aUVa5DYDi8N9\n", + "h/2B595fMWrPfeD1iQ/cZPOsSPi+W9z40yGE/zPGePrWtVPmIz0LIYQ6n32UzjmGh8xfiDEOvlk9\n", + "Vy3Khpe2b1FsxhinIYR/yK//OZ66jyRwvM3Oz2EeQv2nOfcxLp2ws8Wz6yz9GlnC9gr3LpZdlOQW\n", + "v3o/0y3yLunRUKt3w+iJhpBEkqhIG7J5017CQtFUhIGNUDOKiancrkQH7wuF+9BRurc+j5GKB7XM\n", + "DQxVDV2Q62iZOHZVcGwkmFk0tyizo22scEtbU64vNdWxoKZwIGjGqSIZWimuaU0O7VejYVKYFYV5\n", + "NrV6XHdaPTGpT6WNzJ2irT6verZa1Y1zK6FOHHpOw5ViTjrX3Odzj5Vu2/kylfeFEJ6OMY77/Nrz\n", + "nMv4i4tkrdKH4bU2sxvli+R2nY88wZ//E9xb5GBA9bf4gc/ygR9+E4+kT+2EKU7fuqZvxr/zxUhJ\n", + "wEp/gfp/znzG9Q+SLTI+4LE7fS8ujHXu6+iMgpPGpmnSltqxnRyRTK32p2KRyyK7Sw+U9rxJ/Ux+\n", + "ex4DUydyEysOTbSUjqyZFfecnM2IM3nZ/jPzuqChoq4ql59R5BqW5Joq2nIP45qhuzo2BU25Aw2n\n", + "mgaCviC3qtCzEycuzEt79wFuLhI1HSYXHMWmNCnUwrHDhR1ffbLwwdfJn+fmAs+f58YCw/22k+rD\n", + "muGS1t2h4eKepzZ3hf2qo5WhfsHJL4QQyshgjv8wwtJ7BD+FX3inT+Jt4A0S63uqGIExn3uG2j0+\n", + "uUzSwwG/f1rGR6D7YzzxST60y9I9rl/lC/8lr/8fb/hYhBDCIo8+6MAVrs1pPK/x4zddGOaqG6W3\n", + "2k46EWanGq26RrWq6Nw0TKeGtZpkUhGP79ltn8gL5iGYhwUXZTrFqeOQlzqYUComJqIbNsxsqJor\n", + "WzwNBxq6WaaT1CUSo+QWpqpnzp0PKQxMnJy1gqrB2XYjWrVsZmjbwJaOKKgr5KrGFiyrKfQca5hZ\n", + "k1pS8aJpWMeCVj6RJ6lqsmzL0G13TVLWijInK93N7C4k1qWyIjqd1s1rTXExce5g5m41uhBZfpOx\n", + "VTMrDcKs+0NeMmejnK970wvqW2NY5WTuW6gz3vS7DvCzIYQuEpIrrP9N6p9hqcvmbSZDPvxMqbT5\n", + "7I+S7lLZ5MKM+24zaPLKubL7u3bKPGdnbeLR8cTyuGJ2p+50reegkQvTxM0w1UwTKyF3EoOpwiSU\n", + "XawrglTUxIrUpuj4zAmqLrFn1VzHgqnrVswtiWdP65FM1JZirKvjQFB1TkVmInFiJjiU6GpYzFvl\n", + "qL6WCfk5cX7O/F6F2ct213Yld6LWWmFYOW8/3bI8b8qTmr3itnuVoVicIzs1LDLtcUWy0TardA17\n", + "DSsfvavy8Mjkd0MI/1eM8TSE8Av7tLc4f4neEZ3P0r5XjtEG63zm+9lZLAsNHeZP8LnP8cM3uHGV\n", + "k31aX2TrgH9+Rnb+tqv/ri5GQqh9jNUnSx34/lcoXjybTX5PEWP+Sgjhf6P1V3hgiYdfPHMv/iDn\n", + "H89k3bl78RGyumrIHVYuGsWal4o9rcpQ42jH6doVA92STxLmZ4Y0bWV/qibYlhvZ0rNnx55FNRfP\n", + "OiTbDh2oCtZlUsGGuVUT4zOOdYolmYmhiqoLcgsKTxkZq+gI7ukaaqiamRWMtSxkC3rpxLOBzgJH\n", + "GfsheGh+ST9Z1EgKSaAeNtUqMzv3HdhdpHlE5XrF5KDrzp0JCw8yfcJwMlerLct7j8uefZ6FYyc3\n", + "TvmdDn9qlSfbxCNmrRB+fRTjuz3h9tsilCyyH8d/806fy9vA1/Dpd/ok/jg4+67/Zgjh89fLTsfg\n", + "DXJ0WWM8/Cf49I2yxU/pElpscPJJ/D9nv+b+h/j+P82NlPhVtU+0ddqrjj5cWG6OLWZDF3OO27cc\n", + "FVGaLErymo3+K8YtZsVIsjl2Ja1byKd6lan9oi+xYCl2ZOHUUyExjYUYmurFiknykLYg1Rfdr2Fo\n", + "otCvkCjUzozU6rhP4ggvWJFra5uq21PVl+IwVk1Cbv3spXfHzJEoiDJLUnU1hYEFifukdkTLWDjj\n", + "puUkc7U0UckZJy2VwI0QqYylMdVvVMxniUfGU4dpMBxfsr5NvxUUu4furnX0Onv21goXz1rw/Sq9\n", + "uT+qPvebsNNha1B6gXxpi/1/+RZi8re7N05DaH+KR/8CFx9lI5CMubnO+RFPf4rOtTJpuPUgH366\n", + "tMQISekO210qx8of3WZhzO93ea3Lqtx4IZdOGh4ZDcWlxGJsmExytVqwUsxtp6Vishqi2tmzeSqY\n", + "q+rIjeTqxgYa6DpSOLJoIMokogY6ClNBIjszmy8sOtY3NdaxhoadYkW/uGOcJ+oxtWjkNLnsxKKh\n", + "jmJljVl00hgaPXZkYbagmly0VjRlRV08XDBvdGXVa2ZFyp3zRl+4ofmDNbXsnOU767YOU0nR0lt9\n", + "xqVHoskP4pfLrmL4+0c8scxjGf0jvhpjvBFCaDbprLzFmuEqt7/Es79EpcPlGUcH/PyMp/+wNX1X\n", + "FyN88ie4/4h5yss/xfNfDCH84ttJgXwDZYvXJWW9sB9j3A/hYpP/4Lc5bfDKp1lY41yd7qDjy52K\n", + "WcJ+XpNMaaeXxfHMINs2mOWSwyHnR2JoKvWFFeWQoyNYUdU/ixqPqq6I7sfIxJ6JVSM1N4wkCovG\n", + "duXYdmRLU1VqLjg6Y9+XBjoLuCjYU3Nd9+yBNDpTpafCtHTnaydUZuWYb2/eViQNtyvLqiHKQtAS\n", + "NSUyK+rZgVhhtlR3/JEtvTsPE3tcWGTzRDx90vQrlTOC0mXCLeoNPvgJVj5cMrxin9pv8xNpCP08\n", + "xu8mdfPdiP8Mv/Ie5Fu8GV/Hf/dOn8TbQYxx7IzEGkLYWub7N/hw3+SRsTv9kjz9Bi4flWaRJZZ4\n", + "5EFGKXFA6yYfWzBaXrFaHVqPmeV8x0my46pM5rpGXneS0Xo5c/G5luNPd2zGXK0SrIq6cebIqX42\n", + "d5RG87jgKD5sEnYk8chmWDoT+I4V5qoSM1tS+2ZqZx6bUV1VzdyKwqFLMnVdQaZmasW+e4JUCKfu\n", + "mOiJOpYc6RqeJVjVtM5o7YfGZ7THmsqZqXwU5CZOzZPMahFkSVCPpZdJHgOR/nAqvTN1Lo3SbhTy\n", + "Va1ZGYwZV+ZOl1acng683qlKtqYu7HLU5EvnOfi5tyrnQggPbvLDNbam3N0rnbOvf/vV/cWc+iXm\n", + "Pfb/KbPvyjyrlATf/yO8ryg5LHmFjXE5Ufjq+7k6pxFJqmWj5dyXuXmFGz/GeqtU8CQ58xVm+2xl\n", + "LBW8kEadItUdVDRPxlrtukcGud3q3HYS1NJgsyg8n0bLkU4ot5sDQaYwk5rIHZkZqDk885CZWD7T\n", + "QA1FbYmOqqroptwFiR3DM/nvQNuuy3LnFIYkJ7L0pjtx7FTTKCzI4op5JVA5ZJYLratyLQMNSWgq\n", + "Qq7WmppUFs1dJh8zP8/+83ywbnz4iIXjhqVvfHfWNQYLxp1TjU+FEL6GPXS6PNDgwUiWMQkh7GI6\n", + "ZnBE880E8wnpmL0D/s4B8z9KFtG7vBj5oRt/8OdLJ4w+xtNfwZ2381tDCMub/NRlNheJ90iWQniq\n", + "VDLVcm5dYqmGZtnak0X1NKg1c1kIClE1tuRpXatZVV24LBtlVqav2W88aGJTMJG6JjVWsaQwkymD\n", + "vJo2TdEzxCXRilTfzOvu2DGyYumMXbLi1PzMPL5q7AmlyvweKgoHcseqGg6smuvZQMUsBLG6Lwk9\n", + "9ZzdKtXpeUv5innl0GloWopVbadOk0wSy9jrWiTmvLbYsT35qPn4CY5eoNYkHbL5Og8+yGsFYZvl\n", + "e7xyhbWPcPMNs6oFZh9h/y4/7LuLAH9XIQQBfx1/650+l7eJ5/FgCJox/sFD472IEMLlh/hrHyZv\n", + "Mn9Zf/Wu3/nULaPP89jZjv24Sfbm3VqMhJs8cMgH2+bnlqW1iWoahKJKsqEWT+yGifM5L0+ovbrs\n", + "VM/uY2319pYjuRj23Q0TSxKtkInZWHdetR22xHRmJVnXDiP9MFYx0YhRElJDiakoQ2FDy8DAS/qi\n", + "izJ9VUNDWdyRh1xLRd9lDWuIojXRjqFg6EMaatbiPf1wz8Bc1FOVSzxojiVTM32JlLgj0yxZZSHX\n", + "CFOZI6lK+X0Pia1KYTrg/Cm3rjBIgsVGatIsTNKandknTG++5PVLR47qvHaF6YD9/5vJ33/z+tRD\n", + "ePJJ/vJHOd7gcIfNL/M30hD+YR7jtwzOjPHe3w0hVJH9ETeZ66V6L61RyQgDpk1Omlxocn+PwZzp\n", + "iGF7wW/8pRWzjapuree4cWw5ZCqh5HqMlsr36VGLrVri8nBquDF3bSOSFU4bE9qZep66m1Y1YnR0\n", + "Nip7OZa2N2mIego7Go6LiknYMrUuCcffCAMIzuE1QY5l0TEqVlQMzUycKizhCVyXesFiUhrK56aW\n", + "Y12wbGRJLemoxLlREmheEkNfNa5Jk7vGYcXcVC3tyBpBnN6VpcfMF5h12e1RU0orv4GhabPm5MJV\n", + "w80V/qttphndH2HwEHfmpM/xiS9xYZ+f3edffYG/cMYZmY6ofJ5L+/yrGOPEHxHv8mLkzUgj9+W8\n", + "eMXbKEZCCGGDn/w0i49wq097Q3KpJvkvnrV/N/d0tSSw5meS+sqIeXdo5WTssFrTSQuDZFGRV2Wx\n", + "qVl0JaEjqyRqyUR38rpZ/RVpMrIoWLJl0avGZg5dlnNmbDPVtmxq2VyQq2NRz9wQ9zTkptaRaZg6\n", + "EQQrZwz7uYptFacSNZnCyCWlT0BP3TiMtNLCg3nFxZBbzHmpWbg9q1mLCw7Dkb1kTevsVj+VaWeH\n", + "AiYhdW9wyXTyYGlK4jzHL7F5oXzIVF+kOyZ5jteH/ONlfiJ5y7XeYFDl3B93rd5hfFg5GviOcrR3\n", + "O2I0DcEryvyIb4pceC9hqySzDi9zEnFsfKdhcXXgmQ8cefjXS6Li19fZ+0dvHHPCC8/xH36AqxtM\n", + "ErFfYWWskMoUinlFXqs5MRFV9ZIPa2UN1clNs/WrFkJTNRam2YrF9IZKcuJC0bdXTd2bLerP6hqV\n", + "hmplrB4rstBzWF0wDnVVbdVY1/Cc0zCUmCtMVTXkZm6oOTRx4tCVUHW/iqZo6rrXdN2xbFVwaMVc\n", + "JmipKsSwZcmuuX1THQ1Boo9cxaHUgnZsmg1uaVX2jOstdwx1wtiK1IW8IYToFYVQSVQuFe7cof4a\n", + "oTpw9EN11ZA4dNnodKS60jU/ajj+7MzxzyhdNf81gmkIIb3In/lhdt7YKV/lqMHsiD8TQnj12xUb\n", + "f0xu2agcszR3Ob3KxjYnD3O0wMUJvRqjCt2nF+x//AHF+bq1mNroLTtNWq63b7o65bhDPmG3zmY1\n", + "lU9rupNCZzZ3ulB4vjO3lpPmJCG3OI/WcZAWukW5ybuKuijGwjxMHYfztsMFqY4irsniEcld0VBF\n", + "oa2rbarMsHlYRSFVV1hRXrwbUrdtmFlVWDWUyd1NanbiRBHuoCoPBemq0sSjR7wgDXOJvmjJVKqw\n", + "Jg6fpUj43Qf47JDaK/ypqD/LTRup+mQmSw8dPPyQau9+2dcf4vYzPHGNJ9f45xVihexj3D7k6j73\n", + "TXnqWdJtPrNQWs3PDvm1wR/THPIdK0ZCCH9a6YFwEGP8oe/uqGkgf7vpgBtbXHyE2/usvm7xB1i1\n", + "LhQLxo+feGbE0gHdRYoutRn58dBW44Z7cdO40jXKJyrFDUkt2pwHR+nUuLGsPq/L01Q3u2ahVrEq\n", + "kbgnqmgppI7dNBdkOlZlFgRR48wgKeiecbT7mk71rTvV1TTXUHPsnl+XWVN1qmYmlVo1VZd62bbc\n", + "R/RN9N2U6ISKZlJTiXPtLPFQNjRozuzHNdOiJ0sOnYYFoRjqFIdMTnzwKZJp3cFSXX+lfkZOWmJ6\n", + "juvP8ciESY1ntzm9U87mj/ZxTD2cfRbusDQr+XvvRfx1/GyMvuccpXcAb9jCv2eLkRBC80HOXz4z\n", + "2wp42OQrr9r+SEf96pFffpCTMTu/QvH8mw69eZfeCo0twiHZivE8N6w2tOPQJC1ks0x1yr3GOdPh\n", + "mpXDe44ub5mniVmsC3GonnR08y3D2HOYLImx5dy0JS+mQlyRVW87qk48EArLbrllzcTIOBwrYk/q\n", + "PisydS2HFgQ9wYmeV1Q0PKChI0qlKiYetmvHTKGtomlorGaKucI1JypqZhJHck1LjjE0ULEUJ4bF\n", + "vrrE1mzuXjG1lp1qNSsuh8J2uuEgrMizxLzo2e/cEbfHtl5k5QO5fDCzl16V9hq6kxfVl8ZOtrtm\n", + "ee9NBldvweISrRWO3vzDLQZdLm6X4/DB9+A+WFducCbs3GDvMvUDDteo3uZgqzRmLE7Z+iz56aZK\n", + "v+Eki/bSKK9VTIcr5smBfhgaFtxLmYzqRpNonE4UK1E1YZDyYFryUVJczXktFG6ERDcjiD6al+/5\n", + "04L1EC0VuUmo62uahwVFbKiETYkXFA7ULViUKS9U4Yqbti0qL1BXudMuRQqbmu53IpPYLZOHVELb\n", + "wB5exXI5Qg9zLCtE0/CQNPuCPDkR1cXhAQczJsul/870Noun/No144srbjyRWEy2zbqLsrBh+vIV\n", + "+WvQoP0g0+tcXOcbna1z5FXWZzG+hi+GEJ46O/3RG4VlCCFJeHSNj6XUj3hmWvLXvi3eyc7I55WS\n", + "w3/17T8yTf9Ah35S55VI/urb/HfrrTLwJ9zU+nDF+XGqPi3EUCHl8af5nUdZrDNs0VqgOyOZ96wO\n", + "Bl6zpDVY1spyi8s1q1nTJD8xS+qOKk15Hs3TaKsYSJJG6aqUtBVGZ/bNXaltifxsjthUNVUDXYlD\n", + "U0OZJVXn5YLSSueyTXN3bcu0nVfREIxkeuhr6BqdWQRnagpdhdM404uJ9izXSDP1RsO4uCKd5Irk\n", + "2Dx/Tlrra4eR9cDuVY7vjnjtWPa+EWmHIqJBusxTX+S5Y34Od2OMWQhh5YDOb/LpRfoJB2u8/hK1\n", + "3fegEiWUkal/EU++0+fyPcLXlIqa9zKyebkTSetn3iNtxk+afvYZ032++g9x460chhhjPB/CzWXm\n", + "hywdky/RWnN05ch8NTod7cuTkdZRsH/rqv4R0yQxnSyJe5nTS1OdNFpVKJKyY9q3omkqqc2EvK3h\n", + "JceVka0QdMytxFOLDuzGqWNbYnHeeqUpMXViydRQMDMwMBDcL5OamUjPFDhjDZklbOk7sW8eE6du\n", + "2QvB3IbUqiWnCnsSd0XHHhKdxiWN0VDI6ppSoywxLvriNJElwX5tzVFyUS1fEOYzh5Utqkt86qad\n", + "cKxfTV3anblQeUleT0yrC9ZuB5U4de87FROTMTJChW90QMZUJuV6va1NZMnxW/xxHv84F5W+iq9N\n", + "+Z0TLtyllpU5K70vs3GPT3yVSs4r61VZvao4rEhPZ4q1xPqkZfEodbDCC4Hh14PJ1bqFJLdVKcRq\n", + "ZtJiOSmLkIOknGrMA9XI3aywUrBdsDljmtCu0ohRZ5jZqh94rXlR4sQ0rCkQBG1jbTtacm0tLVW5\n", + "nmBg5EklG3iCuTrW9E1OrZRTAAAgAElEQVRl6jZMXXDeibF1I39SYQdHZ4VIDStmSVApMkXaEezJ\n", + "Jym3I62C6jYPvMzxU9R7/GyPrGH8kdTk4blw/nFF40leSM/WLy1d3sJJOcv6Bk5I5m9SUMUyq+hf\n", + "U0B1+bOP8wOPlCGX2TV+/Ot8+Dv5PryTqb0n8J2TWv/ZBe5XNqFez7j98zHGbyv7+i6xt0O+x1Km\n", + "1ayrH0PPuDO2skNW55ENPvKzfPknefkSlWYwrTclB4k8nTpamBrWGnpx5HqtLswWnN+/bn+xIqu0\n", + "hWxkVqw5n/YNql1ZPifUDLSMpdpJYmpb18yJ+6QKHR19M4nbgpq5VVWpwkzfqVR0ZMVM36pLoqZZ\n", + "zNTDwIYDI1UVURZLL5FBEszl1pNMI7LTYhKjaT4Rp31FURHzTFoUpCPTYaE3KncZ9VMGv3mb3/9l\n", + "fup9TBKyPqfXuHnMz8UYb56tX/08P/2D5bD+82MeOuXCl1m6w//8nclr71r8J/hcjG+Pm/Quwtfw\n", + "l97pk3g7iDHOl0P4ytf5vu97kxX5c5zv8VSM8flvdVwomY7pdf7EKqM2+R0OG/LpoZOreyanPa1X\n", + "mPxSorfX5NMfMbr9NJf6/OiSeTNzsjEQkoFpODSONetzalkhjmp6rZaYjiyZWjfUialG7KJmMd5z\n", + "z8Dr6dyJTKqhr6lqRy4xtYG+kRpmEuMzphipYCL3okzH3P0hM/GKXRcNLes4xETLkkU1A5kiTozi\n", + "RL8+1y3m8nuM77V8MF81CQPPPJbZWV5Vj031mJvFNeN8VSOuGM8rXDmRt1/VqNd9YNTSOCqM04HX\n", + "tjJxOuLbKuNijKPlEL72FB/+GLcTJcP9q1w4Lp0636bMv/Ik7/8EP3KjHNnD+xb5lZTnfkZpJ7CP\n", + "wPM/TX6hLBR2W8cOXTV/aaz7SOqkzWRxKKYT1SE3n+bwb0ULf2Pm4k8GzTTRSlKHIdfjjBZcN42l\n", + "0LZhroFGj+ywtMDpZDQuUBsFo2bdcW2gG3eNLIlun/XCb8tDbk1XV8/coR1BW3BBsOj3HKobS2Rn\n", + "I/oo11ITLXEWuNizKZgquyg56kp3wxFFQ5bdJD0tN8G7n+aVwNINLh2z9Rs8us//GGO8d/b9eHlD\n", + "3MjFS7tcOeHe6plCZpVbX+ZDzTc5al9j9ZWyEHnt261UCOHcE3z/nzxTsFF2yAqu/MZ3WuE/1n3x\n", + "bw0v/x1evqy85tdjjG+7zRdjnLRC+NXP8Ze6skaQVfomrVcx9MGXePYHOXeKFo8fcf5W3Y33171c\n", + "Oaf7zNDg4xcdt+tGxYrmPBGS61QPpK0Dj92ODi8um+ym+iv79rs0i7FqoF9UbIdUXswNksuiFYmx\n", + "um20Tc3O8gnauvZN9M1MzUw0ZFoqJqJEfqas6QqhQpyYBTJzx1KdIpUXUR5yG6F0BGzMKFJeCHW7\n", + "R1Elu2lWVC3uzmUrc92lwhMTLr9QbkBfq3P8ibHh336B39/lR2sszHjpsHyw3HvjeiY8/D6WHyvH\n", + "MTs5r+Wkaakt73ybZXi346/jf32nT+J7iKfwRAjqMb69Heo7iRN+40us7fDgJvGgJKbeOeRffrtj\n", + "WvzA+7nvPCcXqNYZP8faTbbv8XMDk3/CpIgxzkII7Rf4/i1WHmb7d7gxZTkRxz3HrbpRsqheZE7j\n", + "gXnRluxvKmoNR6s17XpmNdKJDVneVismimpVHo6tx5lOOO9AqupY1aKWgW2bFENH4Z7XQsMDRaKe\n", + "TI3lrll0pOqcJZeQOnFqqOFEoqUvUcN5U0NVFalBDORzKxJbo8LCPvuzkcHxhu2PPmohDgzyVaO0\n", + "a5IV5BsqkTDLJGlVEVbULMrmR+q9qXk3VTV1vpJ5/RC/94esz698kdYtHl0l36eyw9On3xOPm/Uf\n", + "4P0HZVLvc+fYv79837bnWI0xPvfGJ0MIf4+9h+lcYHzYM/+tm/ztLfvVluXjvkHtQF5ti0fB8T+d\n", + "xPhqCOEfzdz886nqZrRZK5zkHFYT61b1NLRDMC8mTkzsVk8t7REmXHuBh5vlK2p3q2W72TGaZR6L\n", + "t9xM+g6SqFUMTLJTWnXzNLVnzcBFdXNDx8g9rCIzds1csGpH5kDqnMJE5kTbSEu0qCLI9YhzIaZi\n", + "GAjxRWk2kceRynFqnjzJpKB2zHSFX3w/18ec3y+v0WrCRx7jxz7O/iI3f4+HnuXPPshvbLJ3i86r\n", + "/H7K4JCLGWGPnV3+yRsxAN8KgQtXiembOmRwhZPvtML/xouREMImfv4tP96JMf7lP+zYGOORt8wg\n", + "vxcYxfjFEMLxgun/VDFandi6Ofbka6Xe/fPLtJ4v54CVyLjb1MwTC/nMqLVkUr2g0h/RPNVQk8/a\n", + "YnFNOil0bzIYjtXutmXn5+5uzITNiqS6bJbXFEkqqVwx1Ve3qmUuc91IYWpN3VRxNg2+Ysd1D2Ns\n", + "pqJSTM3DrmCqG3fMk0yhKY25PAZZ+P/Ze9MgO6/zvvN33v3uW9/eu4EG0ACIhQTE1ZREipREyyPF\n", + "sl0ex055MhNr7DjJB6fictlV8yU1S5VnqXKcZcZZnBlJySi247G1WIoWiqQpcV8AEBsBNND7dvvu\n", + "9777e858eJsSRIGUGBGEKOZfdT/gVt/ug3vufd/nPM9/sWlKSSXRcXzJeCYhFrCaQDmA2ABlRESa\n", + "Tv/iKKY0cOIr+LOSPQImVmB0V4VQ8WBtHhhVSn3HSfFGyEF9BL5z6tHTD2E8Am4+9Xx7V0EIDgMH\n", + "gL+61Wt5u6AUg10S6wne5HT7447dHIxPN2EKqJCe0FbeyHtICGHOwkMPwDUBy5uwL4CpHOx0oTuA\n", + "P7ne00IpNRRC/Nv/BD9fg8kYrm2nDMW796MO6khNQ4k6ATpdPUBUFVqQIRgKvKJiSxuhJu1UO6El\n", + "DJA0gKoacpdcZEvkuSKy9AnoI1BK4Mg9+EbABdVmR0vIKvDIMBBViipmlByaMIilQ6J10VREVSQ0\n", + "d4e3HRJMegxUDw+NQ4lAj23yrsuUC3s6Nv/xjgPkz0iMCcmw2kGfnADVIbEEoqOQ4RbKccCXWH0b\n", + "d1KR9Hyq2+DtHoy1xR8k09xVUPz7XV5HidT48G2SxWvZNAvr2aOgH4Tjw3SEf24WOr8qhPhfXkv9\n", + "3d3Ts7sPhBDVAVzxCbYbbE0EWNEMycIR4mtfh727Ng/nJcmfSYa/lmbOlAT0EpsFzdrtS0TE6GzJ\n", + "afrxNc4rQVOF5O+NuVJJOyQ53UIkeYpRB2VoWInN7Po6wopw+hmiXofzd+3D0YpktHRgH1JAskST\n", + "iGliyspCEGIIiysMyJNQpkeP/Ui6u7osHSFjNEAoiyTUMJil2nXoix5hdxk6ATQH8Godtiq7Y5Qa\n", + "6Fn4lT1QkHDvQYgTuFyEsw/B15+Bk1+B+zR4oQ8vd1ICf38DRklHFDs/SPWkILpRpRKksqM3xE0v\n", + "RpRSW/xnmi4JIf7xdf98XCn1+NuxJgCl1CUhxO9A+N9BpgCLY/DEYdjYhoMtmO6kIUgZUxAK6CYC\n", + "R2WIzRJRS0HYwywo6q5OJC3CCFo9m836CUp6nfolgbj0Ipt3KuT+MsVeiKcqGDWPRPfwsehgIJlg\n", + "CCQqIhY+FpsosmzSJqKLTQEwCXazdm1pYQmJrQb4qo2rFP3YZuDlqLPDdhwSaJKJOC0ucsug6jDj\n", + "QiEv6DBgb2RzbvMOVlZPUzviU2jB+HVEUzuBrA67RJY3wTDN5/6+D1kTsoPU2OTdhk8Bn1aKH7Gt\n", + "/GOHZ4D7eBcXI5ByQEg5fj/MCC2XByufhiqxP5U5nwO4CNObaWv/ewy2dhNI/y8hRGX3qcpR+L0a\n", + "emNAcVpScWxGXJNEnKVVfIV+rohvKzS3iudIFoRLXnPxNZeGshgkZTzl86Qx5Lhq86Dq8bLIsyhK\n", + "qV28kpjhFJ4YZ1PvY7GAoM5IopPRE2wVoYQk1AokykNXXXTRoyhrmCi2tIAhm5ixYMzVmPd1XC9i\n", + "UBb0C4pazyRvpo4nXneUeHWdTHwJb0yg9ITIaUARnEEBZSX4MqB8FYZLMCyD3kgPxN+bN/ID9qhB\n", + "OjJ5G9E/B+cegugAfLCZjmoSDUp9uFPAk3fzxh0YswaNR+BlF2V4BGYpHT0rLZ126Kk7qPWnkPsE\n", + "TBahkAFhFrgiEgrEWCKDCB0C38cJTbw9Q8pC8FPSYIKYLQEbokuoG2ybCUNjjLGNMuVmh6i8TvVM\n", + "l15YxSsV0cYVVsEgI0BoFppw6NJhVOpYUic2BLUkZl3TWBBp3Y1aRgkDXZ3Hp4SGjU5AJF9BJFPY\n", + "6zUiqRMEOZKtCyAsuDB3HfEUYBXmT8Da0XQ+pVkpqftEBMlhOP9RePbfwcwV+P3XKabeShzGlcsQ\n", + "HoJMbVdZFYB+ftfr/41wK9U0dwK/DxwTQnwN+Buvb/0opf7xzVzDbvT1H0Lr12DiPpgcgrMKL9yd\n", + "dnNzV2HhniFbhXH0SxFDe0AvakGpR9WxYQB9usSZDkERtrxxpF+hnAjAJbQlJd1FhmfolzL4QsMQ\n", + "BiMx7GhZQmmitAi0HVABSkRIZolkiNBiDjEgwxYhGg1N4KsSe0LFlhjgGkNsAwQ2rjeK2tjhWm1I\n", + "vZNgRwmbY1DrgV+HOS9V4q5mXbLLbUoMqRwSeO02ccsnEWly6Ug7/X5uVsDd5Ue9OSRcugjtOowe\n", + "gm0NuAbVV1JTnDM3c//ebuyG4v1t4IdUd72r8AzwMeAPb/VC3kEMBxAPwcxd170bgDVMi5A3DHVU\n", + "SrWFEKN1+I0q3DZD4q7QneljRQmOkoQO+Nk+t70IwaEqHbNHXInoOx5ZPcARFpoapSzrlJKIlt7m\n", + "29oKIyohpkst8ajJIjEVnCihF3v0sy0KBByQAxbMUXpqkHphqCyx9EAMkCoE1WBUDnGBIO7h6AHj\n", + "scC3YT3JUNuOcHKKThVyLUmQ8+jsFbTWIDFHiAkQySmkkcERs1Q6BXJLCrmzxOahNuoVmDuTHkou\n", + "1+CZ90GiCVH72xqtnRpkXGgP4cyuPfs7gN5T8NJH4e4CRIPUOr6RgcxZGNmAM0d442KkuQXhl7Hv\n", + "alKeAFsYDIJxOitD5KnX+CxKhaeFKHwawl+B6BDE2gBDKwA6fSkJZJeiobEnihBIirYgUYKMEBxE\n", + "kVeS02KHbauCMdhgpTpkoNrkkxhXZjg/XkCpPJ7bR2UitqwMuoAcWaRKSKKArhFRC2ICYTIiq9S1\n", + "IR1iHE2gyR5D1SQObDRhEBl99F6WyqV1/HpI37FIuoswuQnfNIEJKExCPwbxEuztgPNRuPws3G/A\n", + "TCE1BNSvwCMObIxBP0o7INFuGq98q67nSqmhLsTnvgh/ax+MmqAWgVX4OvB7b/Q68TaYmd4UCCGU\n", + "UurN2K1vx98YAx6A2x6Bj52G0u4p6dw4PLYHrDPgagbhiRHM8QL9oYu8u052rEotMoj8VTx9mYo+\n", + "4NA16PdGWTZn2WmNkEm6JNmzFN8Ht5lDaki27f0saqngtyFzSIqYcplI6PjuJlFGJ6dncOigi4g8\n", + "ZSbZQWAwpEVfZZFBSOwl1HI6U7GioGv0Qo3LrsbaygD3TwSZv6mY2i8YV4qMBaNB2pXeHsDJz4KT\n", + "wDeOwtUeTNRh9ghUM6nHjb0Cwy148SXY/mc/jBGREKI6Ap8ow7wGdGFlC774Wj7IW9iPm77nb/73\n", + "+QXgt5TiwVu1hpsFITgE/CelmLvVa3k9bua+54V44AT8zP2wmoNoCOa3Yfo0fHmg1PdxIIQQDqlx\n", + "hF6DRz4M+TW4+37wNrFPbmHXupRMF5sFHC9haO5hUxzDu7gKE2cYn0g4HGvkLYsYQYsi60yQk5Ie\n", + "C3S1DqNKMJcYTMQFGonNlmbgyw79TMieVkQ9p7FuTdPWPYbagBF06kriazENaaAHJiNeHlYaNKZ8\n", + "DhYFdV1nK5IYgJlI8suwHVt0shbnnH30kxzkauB5aW683sc2mlQ6Cfmmg5QhtttlZENyPoFiF7Qi\n", + "JMfh8GWYvWZz8cEi18pHWHuxguycA7EAn02U+s9SOL7VfRdCnIQ7fzu9zGh+KtYTEtZn4KUQ5Jeh\n", + "eUopdfX1r9VE8R/l2fcLo4w1bWx/yLDQYCHvsvR7Sqmndn+/yMHfMSj+Dx4jdcl+Q6HpNQJdx096\n", + "bCU16q8MMUYG2NmQPSVBoEuUDqF4zSQYXDQaUsdOEuJE0ugbGMM6ThO2Z08g3QIqXENOZyhpLpa4\n", + "iqkUpbiI8Fcwsj5N3UZoFo7SwQvZ0cfp2nVMN8Q1XMxuDyfp4BRq9KNZBt0GyihCXIDtPDxxGgo+\n", + "DGsQRSnHamkWDkyBU4aDWShkoTQC3gIUr8CFHFx4Gs5l0wL+YAJhB57pwxNvxhN5g/3KkCpQDNJx\n", + "auvN9vzHnMB6cyDSNLf/6ijcn8O6w2fgbPCl0Qb3PZMaNR7dhDULnvqSUmpBCKFvwkNDSv8kR927\n", + "TOBWGWYyhIUmNWWxv+VgOxFJEWaiBmRnWf3qEFGV7LtPZzZQOEKjaGwQK8FFLY8jIrJylZ7ewg4l\n", + "Sh/D0etUhMSmRp42fTbZQKOgoCeKBEKnY2dwjCI5IhbtFpkkYDZUzJg+3l4T8XdLHLIE5UGfYSlh\n", + "w1QMLIgtReFyQskFPYZeER7YhBPfgqfdlN9nleBKCFuvwPb/+8M6Iu5yez6TfpfRXpvdvgvx68Af\n", + "/8CfenfiMlASaYX6I+aJvHswhG+dAlbhwTyYA4h24MtDWBAi9yHQDBhcBpZ12DebnuZswFmHe1x4\n", + "ugQL30J7JIeqh5QtF93cItMx2deu0q1JOjkH77YeGTPHIU1R0yOUZlMkoqJ6+FQIsDB0B4lJX0ks\n", + "LcK3XSpuwnhX0neGbBo58t0Iw4yZ19c5RYGenqGFi6s8skrHIIPUKyRyh+GemDFNIx+BEwqmEli1\n", + "JH0JrbrFWm+crYUMfb0I+6ZACchpaWcDF+XVCc0FRq92efAsmAm8MlnAP1Gk+WIbp+Ty8AtwzzWD\n", + "V49NkVVZjq5u4M1+gJ0LM2D/JfyiEOL/eIdCMc/B1jl4X6jjThXZOJHBm/TYqoK20uboALp3CZF/\n", + "VKnBdywjhBA1uK3a54Nf9NmaMwkKIWNXYsZbEBwTQpwC5oC5abhrC3OYUB5T1DUoJC3aWLRETNZq\n", + "sblfUhoq0BVDUzEi4LyW0phSDRU0kRxQkosiJbnuswVxPqJVsRnRzrJQ2I/n5QllQtPbhmyEHZu4\n", + "pktUzuOrDLGy0MQMhaiNq+kEzihGYBJaeVRsoXlr5Fo19rYzdHN9LsRHiMiD8mHxOCzOg/0XULsI\n", + "f0TKGUm68LsZOHYSuhp0V8HoQiUCOYD9F0BU4I6TcPV2OB+BfhoeeAHGhRCffSsuubsxDjdUud0I\n", + "78liRIMjR+EDH4HFUxgHBMXBOEq8zDP3Npj4GmRjyCjSixJKqUSI/AmYjCI03aFrzDLhtvHNDJOa\n", + "jW0V8csdop6N09Coja2x8f4ejm+RD/t0dBgzTKzYZcJaYJ0MQgkMzWdCKHLJCKecPAVyIGNizUNS\n", + "psAWDQR9sZcsFlBCigBlrOFTZEoVGHCNqznF5NCgiEO3bpNxe2haGdOyKMV9PC1htJcnsnY4e29I\n", + "exPCAO5cSkm6H3oeli+n7oWNKmz869fHgv8weL3Hw7sJQrAPuAv4hVu9lpsBpZBC8Cwpb+Qvb/V6\n", + "3g7snrwOiDSEZIPU9+Z7Lpa7Lea/FkI8TaruGkDmXtj3D+BgDLqEhYfh8ukZBoc+Ab2R1C47P5aq\n", + "CI5HWDGMts4xnNRwjA5l5TNv52lWs6BFFEWXttUmb5QoyiFKdzFEFjvRUGJAXgQEmpWq30Qdy+vQ\n", + "diSaFpEtRHiWzlAaxP2AxZykYhZwjVk6usO+SENnyEBbIyJLueUzsASRcNAyHkUlkTq0hcboUDAf\n", + "wqKCl5Iya8FtgAczU5BEKUeAfalVaf9ZkokCsbXNwok2Hzmt88LcXk7fu5eoeQd0nkbMLfDKnm0S\n", + "3SLenyPX0RHSo5TfZic/Bb0JqK2kJmQ33dxwV/H0WfjibxUo3VvAVpJBdi+8Wqe2c4bVfZv89DfB\n", + "f0gIcfq6EVIJRiSMtCNG2t+tmiINxDHY+zuw39AZzrdYmusy3KPImIJCIjA0ixEhycQxA8tmy5pA\n", + "Y42glPpgbZJO+4qkRN8uUFSpB1hOgLKhZhrIxCXKmmhhyCF5lrN2Bk030SmjolECTeFrEySygxI5\n", + "RNBFl0OG5giRsx8R+UhNI1EhRi+DHtYJ6ybmyyZTos3C7VWilTHYvpoaYxklCPaBsQhjpPwotuFR\n", + "Cx7xICiCNwLrSxAMQWYhtw+8echl4eAiWAfg5Z+C5W042EwNXr4jq3+78Z4sRupwzxFoG6CKBOst\n", + "3PkMpfYEfr7B4gjMb+++5xtCiP0a+s/X0X9zklaxCDTpawGmYVNIdHRTEWYd4o5DkpQoLTYZ6FuI\n", + "TIsoPyBOJEFb8OpEjIagnOgkmsYkBlPSARFy3skTigya8ImFicLEIyZHQsQMkjw5FCsUMMmh4eHT\n", + "xldZHFHGVdu0Cw690CDS+8S2jhGWqbgGBc2gF+1wMQ+eyBBNhwy/ALN3fDftFGC2kz5eBdZu2ajk\n", + "FuLvAp95t+e3/AB8m5QP864vRoQQe/bAfzMPThbUMmiLcFoI8ec3Un3sntzbaRrE3Mfgb6ym40qA\n", + "2wR87pEZrvgjuym0RRispTHpIxexqgUqmkFxEDOtx5gCIhHRK9nEoY4mm6AkkUjDMC0ktvKINBsd\n", + "gYfAkkN8zacgLVzLwBd5SjJCigHK9HF8xWYGas8L2ocnkXoWSwNN01CyRBbFthziGhG+GTC0TBxd\n", + "pykirESQixQ7hoaIE/qWwOocQPPmkf018MdBLsJYBmSczl9CQRLmSMwy0mhztVbl/B178aODhKcC\n", + "MFzi2l66Tp3nR9pknQH19QLTa4oIK+UVoFIz3HfMpVgptVoT4sWTbGo+1mGDqTBHrmeiR1P4+ibr\n", + "1XQycGGW3SgLoJMal0nSULvXsDQC+l742QWoeoKLZR/jngzLjsWObrPDkESXjCgdy9Toyhhh2BTc\n", + "AlEY4NuKpoCmgGukXZGySuXHCBAJWLpATxRCKAzNpeuMo0caecaRYZMoK1BCYIVzwJAYg0iroYwK\n", + "uOcZZnWUVkIYEqXyaD2JQQ9pZgmckFgzKfQF+tCEjgGhkZ6mDSsNaapOwKf27qppVsFfg0dPwd11\n", + "sA1o67BVg/kubJogpqBTgHAB9rThWhU6E6Behir/pRh5e6GDY+9+maZJrvXYmg6gYpCY0CjDYgbW\n", + "HoPyL8L4L9cY7p+FgkGcL6EGI5hBk67RZahFxLpgUlPoeojKh8S2Q7tZIdlYIXfSYsXOs1MvoMkA\n", + "ZW7jiDJt4TGOia0Srog5QhGioxGSwUQSAz7ubpJFFohYx0EpE1tFxORBtHCFoBybuKbDUE3R92vE\n", + "5iL9zADT0an2AUwycZEg/BBbT1wFnoIXoF+H5XJagLyG1RJ0trnOXe+9ACGwgb8DvP9Wr+Um45vA\n", + "v7jVi/hRIYQwp+Fv/Qy442myKCeAx+Hk0+ld4fk3frV1IA0gda4rWHQlGAkVi6O7lwUEUIeXL8PH\n", + "h8iKgTYUeFGLMIL9gYOyEhpmSCh0OkRg1fBpsKJH7BOKNJ11wA6CTVYxDJsSNgOVwdEdTDnkmoKi\n", + "ZhKqiJ6KyW+CMWHTLlSJzSymlLQ0iaVCNHLEhPh2na48SNRvQTFgwwnIKIODnsQ1NLoexEOb2Koi\n", + "e7k01U4NwOqQNUIc3YT8NYZ2QtDxcAcZZAKPHizRMvcRfLsOjW/CA7cR9bNkxDpKmyC32mB7zw6R\n", + "GKW1VAd3Awpr6bXiLXHDflQYYFvo5YjMZELOGWCOCMLQQLbThPdYsevSC+kYWYjqaXj6BNy5W4Q2\n", + "svDcXGppUPUAYpSWgXKWyf6QayWNvqiQU10aWkRWaqwrnZbRwap6oGm4KkGEYJrQFmkDQigY7NrH\n", + "BwpcXVFPYlpGnj7jxBh4hkFfhlh6FosmHYbERhV0CxMTDYm0Q6ReAZkmpKskA7qGUiYoSaL3EcLG\n", + "lkPaBReZfJ3qkTwi0hj2SvjGBtT6cPRn4UsTu8XIDmT/CsbOw1MnIDMJg+V0HKnthRcbMNWH8WIa\n", + "qCf7UKlCp/VaNPHN3df3HlrwyjX42BgMsuAfwX1yiaV9ZzEPw/AqNB8FIw+H/yE45REGtoGtEjTa\n", + "uPkCelxEam2kXmAoh7RUTIUIO97k6rE6KxfWOHAwQ12MYl6NUNMujUyFtq7YUUUK8SZtzWdHlOiQ\n", + "x2CAzhYt6hQpYKiASDTo4zBQFWJhYdCloEIUNtkkoK/DBpJtzcVXE9jeYeLOAKM2RjsZ4Bo9woyJ\n", + "DGIa2hTiqg76dno8aMLmF+HRvw+j+3WsOMGMYKULG3/6FtMzfxLwi8BppfhRowZ+3PE8sF8Iakrx\n", + "Nvk/3BLMzkJ2nO/+HzTgKDQuwz28aTGCAO37Pt+KSncLRq8/O9eheQZOLWDmLEqhz9yqojkmuDIL\n", + "wtFwo22WjVE6zKKrkESLaNAmlB4ZTVJEoJPwYDKkjcaKVkago8hSUnmSZMiWcLFCnWLUJqlCr+Hg\n", + "2hqhbmMkHkibCgmJNiRQktCs0YnyZEQB3WsRGy6XZMDQAUvEJAEYyzatYgEubsBcDOHz5GcqlIME\n", + "zYyQahnTHuJyhP7nL+MVwfsTC35xAtbXoJSFyjwsbTGYS7CrOl6Uw4s22R6bJHr6GZi5CNE6fPqt\n", + "xMS/HWgi4hVKt81QWRkQzulU3ITIWmM4BQUPnjNJTUmvQ/vz8OwALt8Ljgb9Hmx+DT5+7LWfcPDL\n", + "DkZfYFt5ksDgij7ANgxiFaCJIpEapRBCSA/d1JhXCU1A8wyuOIJAS9gREkkq1qpFIJTGFT2LriwS\n", + "oREowboaI6CLrRtYcRlNDJB6HUeZCNFBoSGFRNM8EjUH8SJoNkQzqKSDby5hWtsUlzSuzQna1TyH\n", + "V3wy0iOuRPj2n3L1d6EfzSKaAbKqUF0BjIB7FKKvw1NPgFtKA++yHwDjMGw5aUdkpgRmDEKH6AKM\n", + "LqZF/+LN3Nf3ZFIpnb0AACAASURBVDHiw0un4KSC2T3Q9sFaQHodgv9dKf9RACHGfhfsukCUdcak\n", + "Trkn6doh23afUNeICLDlLFpnne3cGm0zw9hlA8I+udEhk1QwWwVy6xHexoDSHX2a5SxlaRLpWfQ4\n", + "pCMtepZGIkfQhYulttnR1hGiCSiE3Icm2whjH0oOGIoWJjqBvoXAoDhs0jWmyHWniXp5/ERhDlyU\n", + "XWPg92hTwm6PUz6f0LMvQGUbvqCU6ulCjM2wpE2yUtAw8i1idw15oQdWRYiPA3TgAqnz7U96cfL3\n", + "SEMbf6KhFJEQfBt4EPj/bvV6fgQYNzLAsdLYXvvNXxouwBUdbtvNvYoFXB2By+MrxGe/AfuOwo4F\n", + "8QKMXIILCdGih/o5qHhlFlWRq7FGmIAnBwyGJrqxTMaQaHaFQIX0dMFI0gUtpq6gpEDFIZcMHVtk\n", + "cQkZSptMrJExc+Q0jzhvo4c28d5DWHFCopeJVY6ObNPXFEo2UOIQkXsAkiZBbgUjEWTaUxS5ghEp\n", + "BhIKz0H+miTZa8FyFtZaOA/sMLvawM1HhFWTXKIzs6PoDp/m/P7NVPl2qi7EibOwJ5PGlisBMkF2\n", + "RvBO5VluSHj6KlSfhG960I3g4q0gqyeM1heprJkE2Sx+r89StYlpbJIN4OkRWP03r1/XrhHaV4QQ\n", + "3wRmoXoPjNwNr94ONQEzKwKkgd4I6JfHcFYzuNUqsdHCqwVgFCBUjNIgG8ccSRR6Bhw/wyljL3o7\n", + "ZNX2SLwm0gmYGKacEVvPsVQsk2VIw3IIggPoQ5vcIMQbjUgSH5Uro4kdQjGLJkpItpA0EZoLsQ/h\n", + "EKSbcpicbVSwRdgo0+hl2Cx22W/5mDMu9lUDTdQwxyUHfIcrwypJZgXjYUnviX3IKwB5iBxwOko9\n", + "Rhp0N7cGv3E8nVm1h/D8X8NdLuRisJuw3IAbjj/fTrwnixGllCuE+DcdOFGBozG4jTTR9LqTscxC\n", + "XFHc1W3xvF1Ib/6tGK9usKUFRN0Bo/FVCr6ieL6AUe1gaQlq3KdYVWRXynjFhLBvYLctig2XnJ7B\n", + "jHcIslUMt4VbCDHQEYlJLKp4jBDJBcqmQU0qdFyGUmcnvExk9okISEQDXcVMxYoxmWD2RmjFgq5n\n", + "E2/1iMoGohtTTHY4/q2Areom27OS3sYQPhPAc0IIexZ++WdhvYZcgJAY+I/wkRm47/juqeIyfOAS\n", + "fFsI8Vc/qQWJENwFzAJfuNVreYfwTeBh3t3FyNpKenE2sq/NVYCrMNKBJ97shUqpTSHy34QvP5xu\n", + "+9K9YMzBSOiT3fsUy2uX6KxbIFvwFR9eSq0Yzk9nufzwAZSexdjMoGeKBDuXoJwlmR7HkBFCrqBJ\n", + "j1yYo+528XKQl6mb83Q/YNPc4pIzi2uGvMqQSdNIXZeNCD8pkHOniXITZMwQw1+ibTkktIkFafJw\n", + "XAB/BWyXxOhgBjNkLl6kt1exdwmOPw704ZmRPsE/fwIePAZWHyPy0KMBZS1k+pJJTpm4+ZhkbB3r\n", + "jCT8EsAO/PmT8CujKSm4aKeE12sH4IwO6lUYDeGprlJvFjHyDsB0Bnz0W6e4NlpkdTomsobkB+nE\n", + "aPHT11vD3wCjMPv34UQCh6/BU2W4+GHYOeejt/tsJyVW+jWKDZPCqk+/skg3GFLrb1Ibj7AcRVlA\n", + "P0koBODaJoOwjxMrxgcq5fv5ClMLmVmCKJvHmZvA1Hy8MI87sNFdAy00iX0fx9hBiCmU5mHIU8Ro\n", + "KDxMVlGJRN9xiTcyYNgwtgGmCwslYJRE6uiJQ6ltYMarDOctjCDL+FqIqys2JLi2A9ktMsemGS5a\n", + "EK+mwTqLr70hSqlreSG+PIRH9gIRiE14fgW+puDS2+ei++Z4TxYj8B3Z0dO7jxugewqS/xZq0TYz\n", + "A5OlQgVNVwTCRZMRqmNQ6OY4cFVDi7oMbBfqkmwOVACToseG6RAfcOCKIlQ6URBjDjbZt+7Tqubp\n", + "ij5dc5XAOErcrKNaT1MbGzKbn8IcdpHZEoV4gNQNtpINxnSdidhDxYpuLNiIYvzeFs2LJvSbkJGw\n", + "NWSoNwl9uNTpoxp9hp+G6AkgsuBkCX4uC/dfgIsH4cooDJehNgHVOkSHd90WD6Qi/vtfTu3gl96p\n", + "vXmH8TvAHyj13ZvaTzgeAz5zqxfxo0ApNcgK8eWvwiePpOF3wQqUzsDO8IdwmFVq8KgQ4jJc+204\n", + "Pg7HLsHYDiQ6nJ7Z4dubSrV++/rXCCH+YAR9eoSsI5GmgVcxke1ZKOkQlkmCECvKYAWbBMUufScm\n", + "xOGCSsgmEXUBg6jHkacu8eyBvXRik8FUhO30yOp5jkeCtp0nF3u07Qpooxhtk7C7lt6EuvvgCzbc\n", + "WUMrKYxMl7i4QXtvm2QLXnoWLhrgh7D9/yglXxVCnFlF/5uS8oOS0SqM2DCYieh0I45eBM+C/S5c\n", + "mCFNPO4LIf51AyYc+KgDJ++C5RD0Jag9B1oLlseF+O9NGPVhZSf1n7jpSprvxeACbJxQ3LXU5a7d\n", + "61Kgw59NcoMANyFEFcr3g/0BGH0IDgPVBizuh2MvwPYqPH9SEfy1z45/CGlk6FouenmDuNtGfB6m\n", + "Dnj4j8BsklIOXR3ORxqDgYUXhMwmITlTogUSKRSxhNUWjHUGiIxO35sgWZOwuEiy3yGpXEMfUWix\n", + "RmKBsArYIoupTDRfgOoS6hJ/WIOVNsy1wDXhpTEoJzBbB1UguXwRP1ei5CaEo03iDOiNBM+qYTVb\n", + "RMUCflWg57ehtAq5V1Pl0/e8TwOlnhRCnLkMM3w3C86/6Vt5Hd6zxcgPRvQ4bK3C5YmYKW8JxSYr\n", + "OYHj2uTd9zFydYnNcZdy3qYohyQTEk2D3AaM9qAz1acoTXpGnuFcyLql0xZLSAfuXOzghB2q05As\n", + "WVzKLREZFxiMdakrB8fzkU6E0BKE8KiqLiGTHA4EdqiwehpHGorzDEl8l61WAnMCfY9PJruNMRhi\n", + "PQbNx8B97LWuRkmITxyH90+DcNLc6+nTMHkCntiC8WkIw9SERE9blqgDECyk396fuGJECPYDHyYN\n", + "xnuv4GWgLgSzSt18OebNwm6+1NYK3GlBoQ3fCuD0btfTBO0w1I5CEkDr1A3So7ehsgfuugSVXUm6\n", + "lsCJJXj1HiHEtFLqesv5Tpbk4j30VwSodZg+Bx8/CGyBv41rldBbimGlQmIsc9U4QCnKopuKXrDD\n", + "ortF8UVJsFom8j8MT32V+NeOEjtPkp8ZkrU0XAYMREIiNHwtwcw7aKJNYPkoOQXNdfSVVXI1ENEW\n", + "YqfNscdC8AXPLVbY3vKh6V5nxR6zbwbe/zhsfgrKOuzz4EIVnrkTeBYO9eDSGLsn5d1rxboQ4jOn\n", + "4NQafFBPw6oudqB5B3zyfdAehc46TL8Av2EI8X/HSi3cvN1+PTrfgueOgZyE2Sb0MvBKBTa/9vrx\n", + "TOoxMvubcHsJzOOwXYBxBXYHxoaweB/s/wY0T8MTn+/D6rNwvIY6GhMPd+AlUNuw8kdwuw8THtQ8\n", + "iE2wcorHjYBKFDJZElQU6HpCJxPR1KCZhXs/36czd5Vn7jlBcG0G1pbBfR799g4nv1igc6jK1qEm\n", + "XlbhOzaWlCTJGrEe4fsCVfLRH87hYKDTJH5/hqhbIsqOp1a0UybrrkvBMtFiC2V7dLOCdTVKtmVQ\n", + "aLzCJn0G2mUQHXjUhWde7wsjhBCkrm3nblUX/L8UI2+A1A66+L/BlV+FzjRohYDbz8Kqp9OTPlY0\n", + "i9xu8XK8Qf62NlkJIy14+Ao4MZwHlqdbqGaHxb0GaiHk6FlgAp48AHkH5s/B9JMuwYEMnSlJZtQl\n", + "W7WoJQPcao9AmehyB2VlqSkDMxmQaJJsYFKIQnJZk8vZw1DOYtZ1xuQ4mY1RYjMmvneH6QGcCoUQ\n", + "1wB1G9z3ECxGYC3C0QMwlGky4z4NZAcqCYZ8gczHQaky/lJE3JXXMdN/wvCPgH+pFO9Wk7a3DKVI\n", + "hOArwCeA//NWr+dHgVJqkdeR6tJCZORX4cg8zPVSpePFu4XIf0OpwfV24WZqxVB4XX6SAeQUMMJ1\n", + "+TdKqe64EKtLUJmD1hSsXoYzHsw7cC5LsrxN/4MemaKH7c3gigq4GpYn8fJ5OlHC9sg28q8OEg7G\n", + "wC3D2UuUPjpDpbNDKxdS1tpsGTpZ+pQ9Sd/rkPhXySSKwFnBnR2QPeSTFStE9hajZ2GkXebibTPo\n", + "9xyHbwzAOAcPG0J8BijAfg38PVBZA38ENgwwA1AdmDJgR4fk+/yBdm9Ip3cfCCGMGfidh2C9TJr8\n", + "vB+aDkQd+BkhxL94p25iSqlmmszbvQ/yhyFuQuNLIC98/09XPgD3GJDTIR+D34eqDs0JqLagImBn\n", + "HHoJ4O12A57nOhK0EEIHYwuKF2B9FlYroCJwXlbY5SG5n7KZ7umYkURpCZkg1WOdLcN/KID/0iaD\n", + "T38bJnIw1oPnXOoBPNTo01vS+FamwnZlh6Qi8EwH3zdQQgPrCFocUpc+tlFB18qo+DJJOWLb1AmU\n", + "jiqdoHP5AudGWxSkC3GGa84+Cucz5MM+bq6H0e9i/EFbqe8L/0yLEOskTD0Mdgn8thD2o0oFp2/e\n", + "Dt4YtzKb5jdI5ZQA/1Qp9blbtZbXIISwIXs/VO4DYYJ2Fi7+GZQ/CrMxdDtQenXIJ1dP8eKhHKv7\n", + "QdIleCrmwauw9UEYFGGgwb4W5AJ41tAYa1qMdwRRJsBfF+TbCjFTYqFjcu4+H1M7g6qWoezRyQ+Y\n", + "3PTJDTPkLRfXTGgJ0OIdXM0lG2tYAUBMaBnsjOhoFcjaDqYnkEkJszeOX99h8CDMHYXq07Behc2c\n", + "RrKcgSAPZxbhZBZUC/YlsNpBr84z28xQaIPSWnTnrrCuDYj+1S3emrcdQrAX+GXgyC1eyq3AF4Ff\n", + "411ejNwYxjE4Ng8fWvzuc3t18B8WQryilGoIIYrAFHSHcGkaKi7YIZQG0LWg63EDueoW/OVj8Kkt\n", + "mKmC3wZ9BzK3w3Id1iOS50NKUcRg5BBjZx1sXxKbClPT6QQ2/sI2nGvA/CpMSrTKBkWrgLBNNlRE\n", + "W63j4ROoMSJrG6JNigWYbXn0Kl9j6eMlyMTEgcCQ07jHIx49OYvWL2NszELbgXAKcn8Bv74Jp1Or\n", + "lMF8Sq8JczDZg6oL/hDiPFxS3GC0cQNUqpAp870qrCno5dLWvgPvnEfPruvzl3cfb4LcEZjbgY3x\n", + "VCAyug2Lc6kJmpsBK4GrE7D2DG8a7GkM4PCj4OVguw7LM7A9AmJGEiQekdTRLIUWS3IN0DMg20qt\n", + "/P5rv0EIsdBHvA8yd0F40uQrmSJeIomTJXQxigKE2KKaHWCYk3Slh25a2IlAs3QgjyUzhHJIPlpD\n", + "y1ZwBxHk9zNoWQwWXwInAGuDztgGdnUb6XcJvzFOOD8rxP8YwvIWPPrdTmHmHjj2c3DfZupf18jC\n", + "078shK0pFbz8I27TW8Kt7Ix8VSn1r3bDeJ4BbmkxksZI134F7pyH4xupNfLl2+GZAax+FsZ+CUYC\n", + "8Grwqu1x5JrH3jX46iWQEWx8DLojsJmHaQ8aGiyIAp1SncmrCe1pweZkkdiU9PEIMjp5MUm9NUQb\n", + "X8NhnaoHLRMGCuZfimkfCuhkJM2gQ1UvENoZpOWzuKdLEkVcFRXKSkczImx9iOlkCe2YpJYQGjb1\n", + "fEI2k7DnKcUdW5s8/rGzLCzfjlqbgaUmdBfh8DKEDYwXdOaLAr80waCkgA00scp0C65Zu+9RBXIn\n", + "IT8Nw3UYvPxOkZtuAv5n4J8p9cOnkf4E4avAHwtBXqmb6x3wzqN2O+zrfO9zdpIaYV2czQtxeB4e\n", + "GQN7iZ36kMcPmcy3YvJen1iGNHrQ/AugK0T+YajcAxjQfwl4chn+cBOOGlifdBlPbJzFAZ0HyvhV\n", + "UMNNZHFIKQ6gmEEf6uhJhJczkW6cHpc7y1jmE2R+uk2xljAb94itGFMPaTdmCLUaI1nJIOriGBZ7\n", + "4ohJlRAkGQrCZD0YI5RVEr2JX+qgG3XCRBKOAoRgtOH2KTgwA+VzvPqgz+1VyR0r6bhhrQ5PjYC3\n", + "CV4Rtl4mXdcPguemLl5Ch+90QFwwwjSE8Mc05Trpw8AGpwGDPbC3CRfX4MU5qOdhx4FrL0L7P7xR\n", + "Zyd14K6dgbMnwZqDtWMw6UBRQt6AYQjP2wmzXQgsaI+lmaGxJoSYUEptCCGmYeIfQvFDBqpisF3b\n", + "w4pZprjjYF1co1vcJjQUk7qgLKtEfhaNED0TIA1JTrdRSJQjQUHGWyYeNvDJIt0QmusweRucrUK8\n", + "RFBZIrgawnN3wYfvSiuotZWU+/PrhhB/nMAyzHwEHliDwm4uW92FD2zC9iO7LrbvmKHdLStGlFKv\n", + "cRAS+LEgD+6BffNw/3XciOPr4M7Adhm2DsAeHeZ74Nbg0ny6t83PARps/RY8uAmNPFysgbTyXMhV\n", + "kauQZHSao3PIJItvWUS2TSIW6M2tYFZnmF/dg2f22CgN2HsZ9AKcyiYYFyKE1HGOFFnKG8xJg4o0\n", + "CLWEFSemGkdEnR2GoyWElhAZMbFmI4M2NibjfplBK2D1zg5Hvukxu3OGxonb6a4B5KC/Advb8Gmo\n", + "3R1z/8tXkWKF5TGFIGZ2C9p5WKsLIYYw9ym43YD6AJr74MwHhBD/9p0nsP1oEIL3kXJF/t6tXsut\n", + "gFL0dq3hH+Hdraq5AWSURsu/HokANXEQ3v/TsPwcnHgYthTb/im6cy4lWcZVmwSXhkT/Mh313LkX\n", + "jm2mlvGv3gvPHYKNPwrRhiF3CfjI0wGuvcjZTxrIoWTJkFjrglp1nWuHbPTIwWgltDIOwebSbufA\n", + "44i8jD/Moo+PsumUKIQJJH0GpTJyRxJoq4h8zD5D4CiXHVMgohr1lsuw6LJeTtgjDQoyYmBfYacy\n", + "xVqnARMR5EtQr6fZI+0CpaaOmR2wOaUYWwfLhaIOhQjKFyA5AWemhBB/rJR6w8JUKTWoCvHKy3Ds\n", + "rt3xlQRehKkWPKaU+nG4ht8AjW/DmV+C96/CUge2K6kXiXYOOmtwdRE6/+QHr7/1DXjm52H/fihb\n", + "MO6lRmdZwM7AigZXc1BTMBaBrafPj/8DIYw/gfrPl7A+OsawbmNYDpY2QJchRrHP5t37CVoaRVcy\n", + "2tNJRhyw2uhCYWKjMLBUSMCAmIiSyrKp5chvXaDfieAJB973MXji0K744C7gcdh/Ef7rh+D0a6nV\n", + "e1PncdmCn96Ez0HJ/m4h8hqqXpqpSA7euRH2jwNn5Df5sbCnNsdg+gbciMkeFD8Mxy+kEsChk7rr\n", + "VcWuEngF9BOw9xXYmTYIRmLEDliXimTm6+y4y2wfmSYSOTynhhEnYOfQvHlio0unPGStnyEOcwRd\n", + "ybVyhsmSgy18rKjNwMuzfe0oMvYYMGBQNZAiQasEmGOKOXOVlhfScbLopk+gu/jJkNkQBkEFY90n\n", + "cbo0R32OPrnM6Q9/CWazoNZAbcBXgIvg7YH2HNy+EbHnupPl1SKEXRj7ODwQwdxuJ2G6C7USuJ8U\n", + "Qvzzd5n0938F/qf3ElfkBvhz4Jf4iStGGi/DxeMw2wZ99zPZt+ByUoWRY9CTIAKYmoWODl2TYBiy\n", + "fW4MVr4A9UuwH+bn4KeuO5icXEsPJjvHoHoEDrVTe7T2KOwJYiY2wJoq8nzOpp1rE9sJnbtKhC0d\n", + "79p5mN+EP4XcPIzq0FaTeO1Rip7EzoIQY1j2Bp3RNsVEMeEaTCWCjIR2QbClW1hJF2mETEQ1arEC\n", + "3fn/2Xvv8Lqu8073/U7vOOegd5AgCXZSFEmRlCiZKrZkx0WJYzlW7LhMnEwSJ9PvzXNTfOdOynVu\n", + "4plkPPa1E8eObcndkSyrF0qUSIliETsJkOj94PRe1/yxDkgQhNgJgDTe58Ej6pS919lr77W//ZXf\n", + "h7VooiEyRs7hY7TSCA1uyMZBuRFxUh3yYhgdYHBNipgBxADtIehKwJo3wJEFSzO8cgfw0kxHdJIw\n", + "PPUmOPpgSSWUxsAwCu8kLlFOPbcUDsGRepjYptVWTzRBwAPFA5DYCak9l2lIlcDVD9kSmDq00rqh\n", + "AlqB4STUVoC/BGYjGHNQNQK2JNhKEPukk/zqdnBZ8ZYMUKhFGVMUzT1kjBYMpXoKo0NYq4qI0Yop\n", + "mAGvgWo1SNTpJWF1YVRBDIQwFQykCyay2S5yNS6KJ9p1jXpjEewTWmglZAAWQXII1jq1bMVZmiBq\n", + "16G1HCRKkDGer0icNEO6wCyG3WAWjBERqQW+P+3lEaXUJ0TkDuBB4CM3ehyXJp+E2AxPVHEbWGpg\n", + "/S4wdkHQDyWjzsiuqYOR5SAVNuIrajBn7ZgG85TME5TqsxgMlZTiY4zkilDhwGgoUaRIXiyYYxYK\n", + "dgcFiRLOlnAGIdO8hapDYUbq4qTwQMRJzGilGLBQ7TNh8XopOsyYmCBVUcJuMVJjFJoGRgjUGgi5\n", + "s9gtRnqA0UQDdYdsmNJ5ilahaFLETDkMP9wHL6JjvKOT2ecicgCObIM6J9SUE9rOVEJnFBgGdwu0\n", + "TutL0BQFXzOMeIHwDZyc64YI70WvIN+Y67HMMT8G/l8R3LeYUXYSTuyGzBZYVIS8wCkFAz+xwiY7\n", + "5IpgKN+VFYAFlNJ5VBm9IFqboHGGsENjErztYDCDqey+Lpp1n76CwUqocSm23ga8vaNM1MWIuyKU\n", + "PCZIbYFjMbjtAClfgLiyE/FUUpG3Yk8WyGZyJGoVWbsRAxaq4kZy5iQBi4maFFjD4CFHwlQgbTJS\n", + "lzdiTJYomKxILo5lIo+/po9Rrw18wxBaAnsSKDukxExF1kxmBEojUNWs1eHdp7QhAtAegIO3cQlj\n", + "RCmVAr4lInWAGwhPaUY3rxARF9AA5CH2GsRicLoRij8H9lyFgJdFt3xp6gOrDzwpyNRDVQr6Mrrx\n", + "LS7w5iAUg9Z3ADv0+8BvdNNfZcNRUtgpkrYUyVt9WNQQKYsJiiUMVYqUo0DWXIHJUAAJYnJkaM4O\n", + "ccZYIqey2AsmKuJGLLkJYhYfE7GHYE9cJydG2yDbC5t98LwRSjZtUZimh9aiYM1rQyMFwd3w1ntg\n", + "Wz+YS7pE+q1GCD0/296uG26MKKXGgB3TXxeRRuD/Az70bk/VIvLFKf+7Uym180aMsUwXdCahrQKa\n", + "o/qliBWOWIF+3fPAmgNXAvo3g8ULVjcs+pyZEbOPEYuX2jEDBmUHrBStZ8gtHsRgq8OooiQNQgkz\n", + "hnwJUzpLydxDqTSG35qltSoAdQWMEiJVXUMmfifh16og1AO+F+CuJJlaP0WzA0MKwE02NYLFlaZg\n", + "d2Ev2agfyuCqMtDvt2M4s5zQ7iGG2vM0ZmKUjCWyOTjsgsBjSqkLmh0ppcZFTN+GJx6GqiatTBkY\n", + "gvGfAGntlC1Nk9IuUY6wzVMX7fmIYEB7Rf5Yqfka454dlGJChNeADwPfnevxXC+UUkpEnoJDB+BE\n", + "GxRzUOxSSkXsIq4BePAOGBAIjoOrGpIxkCrdTr0iDONQGIbYDGtj3AaZEGTOQPfD0BjTVcURA+Cy\n", + "M27w4Yh1E2+J4Kg3ssToIJVLEWxoIf2yG3JWlOl5Ti0RXHlFzg6OnAFjzkZemZFwGqNPsFjcOAtp\n", + "Bu1pzMk8rd1CtjJOj8lOOJamypkg6TBQLJlwdBYwx0cwZcLwqhWq7wPjIgilwLSXXnM/6rYk9Urn\n", + "NwRaoTMOa6boK+WNoHIX/t53PcajlBsKzkdE7Fuh/SFoEgh5ILIc2k5CZQwG1kJPm4j8YHp56yUI\n", + "QyiuAyCdBXC6dGO8rAXyJciZoSECFVGIGsFU0KFBQxHIGMjmzahYhrTPjE1SGJSVPGZUsQi5FCWv\n", + "l1ghRCCWotrlxKwi5At5+m1GPGEnVYF6zIk0qjpL2OYmpOzkR+p1xUTuLVDLoeAERwh81RAcAk8I\n", + "9hyAptt1HIkCyD5oCMIvytfKy3DABP1btFJwBAjshMSuGzA1F2UuwzR/CtQAP9Ulzjw0XWRFKfXF\n", + "2RqMUiojIt+Gp38DGpp1R9uRHAx/H6y1cGQHbO2HgQ1Q4wKVBnMSHjlp4uePVtA1Euek30R9zoCh\n", + "lGDQK5gNXazqqiTcVMLkPkTEtwgKDszBPhLeU1QZFW3FJC5nFneuEr9pjJ41PgZerIIQgBNyGTg+\n", + "TGqJlRgm3IYkeUsWY8rAeDqHPx/GZBGyNkUsDcWjleSCy8j1KY7TycCqENYg0ANjL1wsv0OpwhkR\n", + "+Tud5EZhanKqSOUROL4S1k7JOD9VC+HTcyEJfZV8Ashwy4UmrprHgE9xCxkjcLYsdaj8d5YMvPMO\n", + "bDZCUx107Yc7fVBthjMpcB4GRuAHUAzCqSwsckN9+dwO2+CoEeKHgDAcWgfFxdASg9EoHOrwEI8E\n", + "sNVEqK2344o5yVscGDMhKt276Fr7flL71kLP24SrRjCkQ8TvNpGyK4o2F4lcgXQpgSmdx6AU7iIY\n", + "smkGTDAqiolEkoF3qsnbEkQ29FFnBmsGzPE01qEiscMFrbDsPgifBxq8kCpgtmfwqiKOAhirwW0G\n", + "gxNCO6BvNzR3w/FqCMyDUPm1IyKLYf2H4H0D2nv1ykrYkoVoMyx5EdYXYNdKeGMTsPtyt6uTWI1P\n", + "wFufgqZOOLQKxANuC0RyWjndAoy3AAOQN0C/CZxxCEYyZJ/PE7pPex5qTGncpRgj5ggqYyAfPwrO\n", + "RajhZvpGjxJqO4PJbyAfc5EYG6dmMIdhKVR4TORSdgLpDH5bGoO5i6GaDl3Wc/gtuM0F9jh4u/T5\n", + "HIjDd/fAg92wwgelcZBx2JUui32WvR9Pi8iraG9XrOwBm3Vkvob6RUQppWa9lb2uqqEebaiNKKVy\n", + "uuS36hPQvAYqN4InDqNZWLkHGmJOXv9wHQcNHYS7x7BVGjAmE5RcQ6yvjrHlKSgWYKDBxPE7qxlY\n", + "UklqMAtDY6xZkqStWKSjC3IuN92LvWTyHvbGPkLs22Yo7oGWnfBKFfyaA9PKLPbqEq6UUIoYiOcC\n", + "tNalWLkfPEEdatrrMNL5RjXUKygEYH9J95C4Jk+ALoes/S1YUgc1RQgaoCsII99SSl2XEM2NnHMR\n", + "bMBJ4JNKHj9GhQAAIABJREFUMetW/3xEBAdajXGjUje2CdbFxzF717qIuJyw2QtrsmBMQNwDuRQM\n", + "JeBsdZiItEDDI9Do0bknwzkY/IlSxRPl981gWAGVKyGfgajUYfqsGW+bk3VDJqxJA/GlCohjGTVw\n", + "PPchhp+zQ+F7UNsPX3HB77XCBi9S4UBVDFDhTtHaF8NQC22ApxRBpeB0P5x6EkLfAyrB8SFYtAIW\n", + "5SFtgp40DHxfqdzk2Pwe2GyAO+LctrrImh7IbYT6iJam718CwyVwRmHibRh4G8JPo3MPjEB/uXT2\n", + "Rs/FNc27XpdpR/cjGtVVK9UfhwcXw5IJ6PFDYDtsDsGAH4x7oWEEQnb4sUGpoS9fxT6boWormOsh\n", + "egd0rIIdx2HUC8OLoOSDUgEyfZDuhehRGPwWUGqEP6pB3mPB2p7HXApgTBVR/R1ED8RgYxbiXkha\n", + "IdwE3c1a3a1pJ7wKDZ8x4nXYyBqL1Azn8BsaiC2u4tDwR4i9DnAKqnfC6iK8GIYjeThSVhovi7/h\n", + "QofW5qwr+8XmfD4ksM4ryqVMQ9Ney2qvycRWaK+A2wbgrnEdQxyvLpBrSiIteZyLK7DGLORHg5hs\n", + "OVxBbbgI4D9TYM2ZEZ5bE+OtE0WMjgweH6wcAXsOSCXIYOB0qwmLqxPaQlA4AsNZ2F2Cle+h0G0k\n", + "XkoSt1oh3w3143SWIKjAZodsH4w9V7hQbfJ6HJeYFhoaawdLJeTCwOlrNXJmkT8ADi8YIudQipQI\n", + "3wF+B/jjuR7PbFCuGHm5/HcBZSXKVhs05RneWWQ4jo6vD08918v/Plz+A8AmErRi+Asb5iygEihD\n", + "ESlW4phIY/VkwdwNVUHd+8mVgC8fg3o36j4vfEjRFqqibdhBPByhvyFKsRoMEegfhtCPyh6fCRH5\n", + "noNjv+7g+D1mlCpBKKBjppNjCwHPisiQdvyUKqEuChXlXLDCKeixQWEMju8CTsHifw/tJn1L6EbE\n", + "+YJSyXmbmKqNguZPwhKHrmjpFxHvPrBX6BQKgILx3C3OjA6lgNYWMdivZr/lEPeAHkPd58EThjcb\n", + "dNVz/ggYAwa6V7oYj3pQsRLIBNRklXpHRP5yHLWvmcyjjWRG2mG8XXfD5cfQ0AoD28tVEXGwnIbq\n", + "M9qAmIClZ4rsGDynTpeyTnDEV8DU3A/eFFiPgC0If5NV6sAM4w7ChZ26RaTOAouVLkM7PZc5QAvG\n", + "yGWilCqJyH4o3q9FdBwFCPq8nHrATsllwBAsYs6aybtHMFnGKJQymI+cX8JvAHKxJDwJxRIEH5yS\n", + "V4SiYTxKnyWFMRfVLradZes2KyK/eA0+vQFyAagcgbusULuG4liacWMaTo1Cd+IK2zyXPUEt6Ct6\n", + "/GInY9mld+pKtj8fEKEa+D+BO+d6LPOQrwK7RPiiUmTnejA3GhGpB3zormpDU/PVRMTkg48uhjUt\n", + "UEyDdEKxF75XvAyjO6PUayI1z6dgsQlrKUPTS04ibQYSfgNR49vQ2A8Ni/Qds72ceLEzDl8XcFpJ\n", + "fCRH0WrAUTJjjhSwdgJ9cGaPUurs3Pjh4Y2wYgPqgA2KY+B6DX5LRL4xTfZ+AHqVVhydSsAGzUd0\n", + "1ceRJDR/HD4YAG95H+uN8Mz7RKR/Bhn9OUd7pZoehfdnob68Xm0QeGUzvN0Fg14dXmuI6Oe4lBHi\n", + "AlXlXMCuaoi9ee0jMQgs74baQ+WcwqKFV1YtpWS6HXVkMfSHwP4aPGIUqQaG8vBaAJIu2F4FhhNQ\n", + "1wXGAfhWFtY7y1nSMVhlBJsTeivh3iBDDm1vTtZYOLIZvEfGKBp+AaM5iIbhwEz5gO+GW+T+VbBj\n", + "CZRKQBeIXeSptFLX4dhcOQvGyBWg80ocz8JLH4H1YQuBDgcxv5Fwph3/iRwlU5KcY5ycLUlTFxy1\n", + "Q60XWiO6fOpQA/R3UV4ERdwvwhsfhNVj2hU8ZIf4YB5rdwi+MuliK++7W0S+NggfbYUH2nV92X4X\n", + "JIbAdUyX9O04qC3ry1pAtOuu7jd1zyWPgiGDiHcvRJ+6imzz+cyfA48pdfMZUjcapegU4R3gUeCb\n", + "cz2eG4V26Vf+OqxdDrUlmDDAQK+IPK6USgKYYf1aWHsP9E4u+UvA8SR8XES+NNUgeHcC3y3Q/bkC\n", + "G9NQH01imEiyr81CZE8CGu+D2OqyumsWjC/DA/thIgZ/L0z4Y4yvM1AdTVN3CIoJ2G2E2FRp8upV\n", + "sHoL9E2OsRYSG8ESgLuZcu0rpSIirhfA9Cgk/brJ26gDxsKwcQheqtOJ6svknCECWiRuRQr613GZ\n", + "a8ks0wItTl2qO4lRwaoJ6PTAwQgYm3SVkOMUPL8Nqvt0AeHJFjgSgtgb1z6MiYNw+iPa8LEWIW6p\n", + "pH9JI9loXdnjUQJJ4+kwU3t7lta3YNgQZ3j/YSJf64JFCooZ7ZEYE5E9AXhkGdzZoSWzT9fB6Emo\n", + "eZa+iiivt+p5cxRgyAPvWBXRr4+e0+y6bESkdT3c9wHoM5e9aivB9CT8ioh0K6XGr/34XBkLxsgV\n", + "olTqLRGJwNB2I/kaL9lwDbWxClyTST+xLDHfCM4sHHkKnmkCZwsUChB+E2IvnXsaS3wVDnsg3KH7\n", + "Jhh6IRSB0Z9MNUTO7VsN14kkl8CRJmhzodUzGyExCH4nmHywlstYQLQ7uubjcJ8TlpaTWosCO7fA\n", + "3lEuo/vpzYAIK4BH0M3+FpiZv0Qrsv7Lrdu9uOI+2NQBW6YkcB9ohl0fAH4IUAWbV2gr5SxVWlyk\n", + "ph9WlBUpL5pkp5TqEZGvQWg7WFsgNwDj38tBeiX8/mrONSe0QvE2CPTD9mGlDovI/5Ol8wEY2wAm\n", + "IyTGYOyZaSrH3iqd+HEedRCzQNOF40m8psM1I78H1cugugfqArCzHnpeAVMSrDP8JmsBzI6L/dY5\n", + "xKzTRKZjy4PZBEPfgFe2wv41UOqF8Zd1oulhj07DyB6eNECvjfwhOLQW8ouhJQGjfjtBdwOJNxyQ\n", + "KQGv4d5YYp1YcOaybBrSjdBf3QRvTqTJ7gdSk+eUUipaL2K4A55t1J47AFbAeCd5x0F2H4HTy8Bi\n", + "huQ4jH9TXYUhAuCF1R2QNk8J79mhsEx7AjsoG1OzyYIxchUopU4Bp2pE0otga4H84qnvx1AGmMgB\n", + "+5Ua+YWI2NHVKXkAEbFXwP1tsNFEnDDHO4N4+kGdhvjhcjn0jJjBa9fiCectIE5QQb2CmS/zZ9RB\n", + "Q/05QwT008X6UThzJ7eIMQL8DfBXSl0YL11AoxSvijAM/Abwnbkez/VGu/XbNsNt03qPrBuG42tE\n", + "5BdKqaSAyTRlcU6D6SB0RGDdIvBl4aRR5OmiUl0X25/S3X7Pa28hIu3uadcsQIXWNvGXv5cCnhCR\n", + "pwHj9OrCMtEJMEx12AOMaUnVC/rplLd7RkT+C4SXQHAlHMtD5Ci6E3cj9BhhjZwTiQPodUPg2MV+\n", + "5xwyrNM2pot1dVdB9LVyguZz5b8bxrlcwtc7wN8B6WKJpLGpHCofBXeCKq8Nb7KIymsl35zJiM9v\n", + "w/6njWTfjMG4iDw1GQ4zgc87xRCZpAIKkDkA/T9Gr/GZaxGaNOh7xQXeb5N+73LvIdeVBWPkGgjA\n", + "692wtpnxeAYqjTiT4yR9oxQyEH+hXI/PVC+HiEgVPLIZ2tfBsBWKg1DxGrGGTq1Ea7KL7CiCPa/b\n", + "OZ9n+SbgdBLqzWCsBMbA2YfV14VUQCY0cfk5HTZwzNB3wJUDY81VH5R5hAjvQ3tEfm2ux3IT8EXg\n", + "H0X4kVLMdBO8qRARpwk6rFAW5DOZtSt9KkYFdtCP2ckwHDwN76sqey/2wnofNK+AZDscj4DlNfi0\n", + "iHz9Sp5Iy1UfpSEw5bViWikAjpOYm4ewNE+QPS4iFUqpKJxNjp0xR0UpNV4lcuJtWL4BhsxQCoJ9\n", + "P3jHtJDdjJTDrqeYtj5or0nP2/DiHdruMheh2w/Humfugjv36GR6x3Pw/AdgVQwcORjwwjthSMzq\n", + "Q1R5ro6W//CJFHbD1s0wmANzCYsxSM6TpultAAsnN9aRqjFiyn0CBobA8xp8VkS+CSS80DcA7cs5\n", + "1zOrANIDXvDcDrbbIXQSCsfhwhwvEXGYoMMOvrg2TmcsMgjByTOwZYluogZAEeSM1qu4qLF9o1gw\n", + "Rq4BpVSfUeSbUbIP2xlYksJSE8F4PE36n4EBv8hHnLCsALFx2FWC40BDEyzZPMVd2wTRDWAdhz/w\n", + "QZ0H2hxgmgCDR+SpOPx3tLDYYnCaD5DyrkDF+zAsG6fRn6bKGMOUjJPzwOBmETml1CVFjMZgVOnS\n", + "QPsU13xPFaSO34DDNauIYEd3pf3CL0Ni5rWiFC+Xc0f+C/Bf53o8l4OIVPvgzvI1FhmHNyavsRb4\n", + "9HKweyA/DJb9TLRn6U3oRmmTTDi0WiZRgDTsOwBrc9Dq0QmsHfW6/8NhO2TtkN10Ljfjkh4kEREn\n", + "3NUK93rBGIKmH8HiFXDqKHW3ZWl2RLCV0tg8cOoPROQfZ/KK6hb2tENFG2QTwEt7IHkKNtiBiI7n\n", + "fE8pdeZKj2FZ+OpJeKsLujeCmCD4KuQPX8YaMmcolXpdREZgYBOYPBDZC+kD1yf8cvVE4Ll9UOiG\n", + "O+xgHSVkznL7AUXzIIQqPCTrbGRyFaQnAOohvghWhuF/VWAIJijxinah0A4TcbA+g2H7ME2NNpo7\n", + "itjCedLb4PRREfn2VO+ZiNQ3w2eW6wTpwihYOmG4/LnpfYdOd8I7Bli/RLdIMHSBq1trrwzO4iE7\n", + "y4LOyHWgXJFSAWSVUikRqW6D390E0qJXO9shqDoGzydh/H3wsa3TJvwMNL0G9y+D6ApIFbXcq/kY\n", + "+I7Bt6L447B0BbRmYNxj5eAycLQa6UjmcYzlaTwEdSPweivs+rFS+QvKuy4ct3MbrPggrA1DRRoG\n", + "/bBPQe/X5iKB6XrOuQh/CbQrxSPXY3u/DIjQChwAtig1e09HVzPvIlLTBr+7GVQLhKP6Gqs8As/5\n", + "YMP7dQZjdPLzz8OaN2mpLHHXMaiNwYQL9vmg8wko7p0SQrWaYJUD7umATVvgUOWUVgcpMD0GFQNK\n", + "/dWlxugQuWM9fGQ7DDigkAHjK7DxEO7lwoZEkaqBHE2nwBeF01Xw/KhSY+clEYuIBSo/AcuWQnMW\n", + "UiY4qaD7MSj1o7MyY5MJ5yJSg84dyQNn5krA6nK4mdb4y6FcFu5Hhz/SgAOsK2DlB2FdBAqeWrru\n", + "dNMb3cHYrkaIdUNHGHmoD4c00tBZIGsaYtw/QGZfBUykwZum9j0NrO+zY01lKdgmKNpCpHph73eU\n", + "yuwp79tVAX+yHuyroLcGkgD79X3l7YhSP59hvEZgWRWsVjrMfwjtSblhRsGCzsgNpqxNcnbB8sH2\n", + "zSAry5LJbshVQTII7zkDjwXOD/cCEIB2M1iqwR6GZgt4ChislSijA/kPUdpeh4fKioErR7NYi5Cs\n", + "gK0/1K0GJlkchhPr0DeVS4w7uVtEgjC4Dcx+3SY9umcua82vByLcBXwWuG2ux3IzoRR9Ivw58H0R\n", + "ts1nj5If7tmiJbDHAFyQq4TkMHyoEvJNcJ6XYDucOE3/onGeOw22VkhXgt0Mq98H4XtFHM9Dem+5\n", + "YuaAiAxnoLJyWs+lcd3i9JJS6CJiaIIdd8Cwo9wuwaZb5B4/SsWSJNuenHbdToB7kYjYz09et22E\n", + "25bCXVPCQovt8MTHoO9Lk4KDolUJH1oFd7aBygKnIW8S+W7hKjwmC1wZItIK9Q/rU6YIBPth/GdK\n", + "ZXaLyAQM3QkGp5Hw+P1k36yDRBEkBFvMOI0W3OMWnDELTlqxpyfoWz5I5sN++K9V1I+7sMUBHJiT\n", + "tRgKSaz1WfzrgT0WkZWt8JkW2FIPseOwpAdO3gGnVsPIO7CxnBd1Xli+bMCeKP/NOQvGyA3ACcvb\n", + "4LwbuhWKjcAZKAxA30FoWgvDRlDj4Dytn3CUBaq8iFNhEyPGpJ2C5TSlyhGcHRA8AZXlxdGR1a3S\n", + "Q5VQP2VxLBq1fs3lMZmMe+2/en4gQg1a5vxzSs2c0LfARfkKcD/wP0X4vFIXJl3OBxzQ0TpNxMkG\n", + "xWqQgm59fh4GfW2lIPhD8D4Mmz2w6bRuDpawwKsfgYMZ9NMhSqnRKpHOt2HpbTBo0k+O9v3gHb9I\n", + "bsYUrDZwesttHc6+CAUjJYG09XxjpCRQUkxJoNX4N8LywLTX0tBSBX0tnIvvr1gB2x+AXlM5UXY5\n", + "OH4Oj4rI38xUnbfA9UFLJLR/Bu5NQGO53LirBnZ+WkT+QSnVCXSKiOThc8PQXAXJApjTGKsDmHJu\n", + "PGc90RbsaRv2Gsisd4HDxPkN66wYsxZyvixFk4hUtMPHd0AkC9F2naUse2HFaQi2aals4XzBq3nJ\n", + "DF1qF7hWihCLa+PiPBL6eGcC8NguOP44NP0Ymp8A4xn4x5x+36wwm40Y8wrIAQopgkVBqP3c1loD\n", + "OucjZZmyZ4GTFTC+/0b/xvmICBXAs8A3leIXcz2em5Gy8fFJYD3w30Tm5yJWgnh8hvrOEqQCEAto\n", + "Eb+znNKtqA8AHqi5De4Y0IYI6KTtTeNQc+/U7wThR2/Awceh8cfQ9DOwnbj83IxMSle+nDcOO+QV\n", + "0RAMu87/+PF6iBy9UMtEjCAzGIQGmHKDqYVNKyBimlKxUwWpdt0wZfGF31/g+uFcD6tFN06cZGkA\n", + "lnnBsHTyFaWUCsDju+DY96Hp51B7BClBxYAH+9lwWp6iMYUUgYhARBgp5cmcrXApogwFAnYI7DFA\n", + "+zKQBpjIQjoFVhOoVsiNQvMpqE1o4cx5rxs1Z54REfkU8Dn0gvJ1pdQtI7gUgDcOwcfuheTk4tAF\n", + "1UPapTyp+vgD3V0UK7pVokTh46fg/g4wuSmWEihDP8ZCCdO4kDIoip5zezEpCB6DN4wQbNbGSo8R\n", + "et/kFvJ0XC4iLAKeQMt8/99zPJybGqWIi/B+dEt5rwh/NN/0Rybg9UPw0R1TPAGdUDUCwwF47nn4\n", + "5GrweiAzAs6jEAnDTsANPnV+GStoW8XULCKGSXd22ZvwUxF5Fv1wEb3cRV0ppawiL+yGj98Jo5WQ\n", + "joL1LWgokPwmvL5MN1WrLMK4ETrHIfzshVsK7YPO9+kmnZNErdBXoCxLDmAAm22GCpzyk8qCB/yG\n", + "4qoF/wyJs/4iWP1TXykn2P5QRH4BWA0YAh4yH/OSj9ow57MUTL1EqyOoU0BnFN5exrg3yKHmNM0G\n", + "wazijHgLjL0O6qARNltBGUBVw4E+2Fap+4uYxqDuBHQH4cVZOQzXyFyepI8ppf6lnPy5l1tI/bEA\n", + "h45C3QRsawQVB8MAjI/p33x2ESyfmGdPYqPIV0ahPoRa5URKRSwJK57BHIaSIgp0GnXnzbQZTpgg\n", + "+HXI9UDfUjBbdHOm8yWub3VEqEf3VflNtBHy9/M1tHAzoRQBEbYDPwKeF+FTSs1Nlv1M5ODgEaid\n", + "gG0N+hqTARgbh8eVUiER+YcRWOeAqjB0l8vkUyJS1BHUvOGcZwRg2A350elxdTir/3HFiaBZpQ5Z\n", + "RWQM7ndAVRrSE/BkBt6CYTOMLgFrJaQDvGufp/TbWrxrfJ02mGxpOGmE4R9ODb2E4UgPvL+uLIQI\n", + "kAdDOdFk3szbrUlsAALLtdL2VMZM5bm9gMm1X0S+eYZ04wTBjXZMkoVShFxvicjfKqUKIvLsGXDX\n", + "MJoURr1RDJYUpefz+gG+KCL93WBcA1INwRS82QuLhrUh8pMC/GyuK4wulzmvpikLgj2rlLpn2us3\n", + "faa1iHiBWnRm9eBMC925zxo7oOERM+7NHrJLraQN9Zi6UxhL3XjHssQHoPsF8Pt1eV/i6KSOyWWM\n", + "w4zWW0jN5xPzSuZchFrg/wA+DXwL+JJSl04sXODKEMGINva+APw74PvX29i7lmtdRHxADZdxjZ37\n", + "TsVDsH47bB7WIZphN7zaDJ3fVqp08GrGcYkxCtqzkrtSd7mIcQU0fgwq66Hkh7EojH1VTWuGJiL2\n", + "WvjsOmhog1AGLMfBcxJeiis1L5+Mb4U1HiY7mrd8AbajJehLAsfqYXcQxr42s5F53vetYFwJ7mWQ\n", + "HYf04Wmqu4hIHbpiM4LWFzFSzkeqgA8tgzsz2JoiVNVkcFkjpKJ5ot+F6E/nU4n2xeZ8To0REfkz\n", + "4LeBP1FKfXvae7fEiXo5iEg1LPtDeHACXHlhqMVM79YinVVFintA9sHY00qp/ktv7XxsIhtr4H1+\n", + "sCaAoG7c8My7qDvOKZcz5+UE1f+MDvF9B/jrhUTVG48Im4F/Qj9l/55S169nyWxf67qk0Xkn+O8W\n", + "8i1+Io3VZPoLMBGEQ2H4xXxI+NRluh1fgAcD4Ctfr6MueNYFvX83XTtCROxWWOeHVQX9SL4P6Jqv\n", + "ntJbaY3Xc1X9ILiX6kTk2GEIPaeUil/HfVRWw4crYbFZJ1SHhrVQZh84f8fMyvcZaIzk8A0paodg\n", + "fyO89bpS0Weu1xiulTk1RkSkFvj+tJdHlVK/UX7fgo5NPzT14hIRxfmx/51KqZ03dLBzhIj7Pnhg\n", + "u5annsqeFnjpWaXyr1/Ndo0iK9fDJ3fAkBtyBZD90PQWHAsqNX1O5pyLnqhCFfCf0Mbr42iJ96HZ\n", + "HN8vOyKYgf+InocvAV9Wamal0Cvb7tzclAwiK9bAZ3dAvw+yBZB3oHEPdE4o9d3ZHs90RDwPwAPb\n", + "YO00Y3tPC7z8r0rl9s3NyK4Pt5IxMklZbVddb2+EiFga4Av3gG1pWTV1GNwvg/s0fAMWfx4eGT1f\n", + "ZThjhO/XQu9fzhfvyJzqjJQVBXfMMKh1aIXMItDODKVHSqkv3ujxzQ/sXnDNoOlQkQO7/Wq3Wgs7\n", + "NsKEWxflYAK1CQZ6YbWIVE53Bc5HRPCjb4C/i25otl6pc4l7C8weZcPjr0X4IfBV4JMi/EeleH6O\n", + "h3ZV1ML2TTDuK8tqm0BtgMEeWC4iNXMh/Hc+Nh+4Z1gX3HmweC58fYG55sJqqOvGkqXg65ii3N0A\n", + "8bXgHobNKWxyYbsDWxFsBnSRxLwwRi7GXJb2/ir6AJnQB3jJHI5ljgl3w/AF2ggwZIX4FYdmJjFB\n", + "Tc2UhDbQE+7XWgbuq93ubCDCEhH+ATiNzgnYoBT/dsEQmXuUoht4EPgztB7JcyLcMcfDumJMUFM9\n", + "w/VROW+uj0j3hSXAAEMWSC5cB79EWMDrv0CDBnyQdIEHYkkITntwDTggFmNKkcR8Zs6MEaXUnyul\n", + "diiltqFb3kcu9Z1bl8JxODoO+5sgaYa4Bd5sgc4+pilJXgk5GBzWSU/n9gQS0F6o8Lt8bc4p64Xs\n", + "BOLAaqX4baW4qlbZC9wYlEIpxc+AVcCTwOMi7BXhP4mwvtwb6AJEMIrgfLf3Z5McDI5Muz5KwLhe\n", + "F+fB9ZE/BkcCcKC8LkStOkTT1QN0z/XoFpg9cjAxppNWz2Mc3Anog8DT8God9Hsha9T/fa0GAk9f\n", + "TlL3fGCuE1g/BPwFsE8p9Zlp791y8cSLISIucN+pOzNShMjbkNxzLYl0ItK+Gj53F0zUQSIJ5n3Q\n", + "eADejCj15HUc/nVh6pyLYJpv2hYLvDvlqpv3Ah8E3oMW2sqgtS8mq0lslIX/0NVPX9TfnZtrXUTa\n", + "VsLn74JgA8RTYNoPTfthX1ipn872eGZCRNzguRPcG4AihPdCas98TEC/Un7Z1vhrQURMNfA7W6Fm\n", + "NYwYodQNVbt0+fb/VEpFRGQp1L4HLA2QG4KxVy5ToG/WmLfVNGcHIfL3wM+VUi9MeW3uB7bAAgss\n", + "sMACC1w35l2jPBGxTMnwjXFWLPAct7LVLFLxINx+N2wZ0IlHGSO83gIHn1YqsevKtiUmoN0NjRmI\n", + "5+HE9LK/m4Fb7Ump3LPiD+H+GPhS0FVjpq8pz5kEhL+olIpeeiu3PrfavC9weSzM+2SZee3vwz0V\n", + "sHxMOw4nHPBSNZz4KlC0w1JApbUw3k0tY3AxJ8NcKrA+KCL/Ae3C7QHmTS30jUZEbLBoi+6PMZkB\n", + "bSvCliHou1tEdl+uOJKI2Kvhk0uhtQFyCTCd1Mf2X5RSC3kWc4rrNlirwJav4Of3tJJ2ezAUo5hW\n", + "jMMXReSvy9VmCyywwC8nbbCoBlZOKVSoSsH6tJmef9NBxrxEV5xyGh50ibyUUOrlORrrDWXOjBGl\n", + "cxbmXd7CLOEEl0EbIFNx5cBhBWxamdb0AHiWg3kCQm9C/p3pan4uuHMjNN8BfUWQMagDy9IY6i9E\n", + "5K/QXpKbIoHp1sNRC96UnT1rl5FqdOMQAypvx5VuZsK+H/Wr6BLZa0ar7JrWQ8X9UHJCYh/kn70V\n", + "cgsWWOAWxg3+srcg4NCdmPMNkPHVoWruhu/XlJOpV4DxKbhPRDqVUjNK/OscI/t68CzSunexAzfL\n", + "A89CA6VZQkT8dlhlB69AvyJS1K3LXeVQVcKiq2gSCRts9GH+z5X4KkrY0mMY80Eal0PvHhF5bKpx\n", + "UQGbV8FYCeQE5g1xqlqMeNJ+kt4Qvn8LAztF5CfzVYXxZqcs2meeWWY/3g8D6xwEtlqpLBYx5wso\n", + "V5GYsxHVVQkNIuJXSoWmbM9ng5UO8EegtwSnLiVYpPs7eR+14/61esTmQUoRzO+ZIPawiPzhQjho\n", + "gQXmhsn1Ad2KQ4mI2aDb+S5OQxSIwIhY2Lmqit51HkyNOayFCaIOL45EN/btBiKvV0HICsVluhnZ\n", + "cmboN6TDws2/DWudUBeD6CI4slXE+F2lip2z/duvlAVjZBYwiixbCo+uAJyQH4It+xkxJ3nVBYvi\n", + "Hk4tdRKpKRB1pojsqofPtFFlclLbC9BEznKQWFOA1rUQ2sOUcl8BgwFKAaiK42+xUTMBgom8BdYP\n", + "gnUD7DvAQingdUVE7F547yLYYAJDvcjIqJYRnxIaS78DRz8LDocJ25gAReImMyoSw90M8ShTxP5E\n", + "ZHE7fGoFGNyQG4E7TsCYiPzzJXKA2qw4378aszTgGQVoxccAanEnmc8Bf3djjsICCywwEyJi9cD9\n", + "bbDJAsY4BIwiL1bD3SuguRHSSTAfB05z0rUI98Za/HYDlRFF1ljJsD1O0SDUZ/rJrqki/SrojBLD\n", + "DCUAYYLNAAAgAElEQVS+Gv99sM0CK8oaNM1RqHNA8ldF5G+utC/SbLNgjNxgRMTSAh97CEJ+3cyL\n", + "DsBBoeVF9of9HHnvMkxGL6VwNam9PdARQBaZcJ0VNbJjyTWRcQawu8DZyhRjJA4HDsN9Fkx1JZxm\n", + "wJAhb5zAVICmKGQt0LmMBWPkuiEiUgW/sQXa1un2q6UBqHgNPici/2uygaFSKi5SO5CiOBCjq8aF\n", + "JWfGEHLgG4mSrwoQL1JudiUipnr49O1adjNRCaEOKLih6VXdgesiOVX2pRVQU4frvKelGryBUcJb\n", + "RcQ+H3qtLLDALwt++OgmWLFBK1cWh8H9IvxxHQTvheOTn2sD+49I395GtidJYROkskZI+Kk4kWNi\n", + "SQplsGOpyJI2m6BwBqwxODV9f9o72rIGlk7zmFSloMYPgzVw8R5e5dYtk41dey/V4O96s2CM3ABE\n", + "pMkDq4zaPZdsBJsfzpOWXg5j+yit3UZmz0oYN0NBgCw0KZQpRrqiGudZ178VgLQFcskp+zG6wXcS\n", + "1jZQrBeSjjD5+mFMQxNs2qWTYwsGKF6RFLDOPzCvg6r1oBRM7IfCUaXUgu6HprkFFm+cIs3cDNEN\n", + "YJuALejmVWVM4TR3PdvH25sWkbfYKJqDBDoGyDqDmH4KBYeIpGzwsVrY4YNYATgNuWrYuxhCe+HD\n", + "VSLWJIxl4JhSKnb+cPI5EwWDAcN5oTihZLJQyqBPnwVjZIEFZgERqVsDK7eihRqzYC6CvxlWpmE0\n", + "CT3O8vXoh7QHrNWU+qHos1IREYwlUBRJVPUSq24kn+uGym6wn4E3gT4RqQffHWBvKKvxvgWqAHkj\n", + "mKat0wXtlH338Ror4MOr4fYmUAmgG6Ii8p3L7Qx/PVgwRq4zTpF71sB7OyBnhuIhaEhBbREGjJzf\n", + "et0MFTVw0sI5cS8rjDogP07EpvAZBWNRoRijYIFADPKnpnx24wZYtRH+dT9q2Wny26E2GaQ6BcvH\n", + "IW2CU2ZInrjc8esy4cpPwNoOWBICJXDqETi6QkR+sJAMC4C3dtpcAtRAzAHN578aegtGfyXIB14O\n", + "8/JWC/nlOdqzJYzjYGqCQ5+HkVcXw7Y6iNWXPSUpsJ6G7QpylVBxGwxEYMNRuF9E/kkpNaWpYuFA\n", + "glQyTtLlxpkAUBSNKYK2NKWD6NL5BW4SRFgM3A1Uox9idi4oEN9U+GrKN/8EOPrhTi/YK8E2Bov7\n", + "4d4a2F1ZTkxVEJgAh4v0cIpkrQVPtIiSMJ6xITzDEwRHT8KhEBwDzoBxMSz5LVhfgMo4BG6Dgxth\n", + "6AwcXQqbprQK6PHD+BgQeLfBmmHDWti0A3omJdl7wfccfEJE/sdshXcWjJHriIhUr4QHfgUGreWT\n", + "sRmCT8CqM9C6DHonP3sSauOwPwiuBi17DkAdDL4D4RKJWJxeXxGnKUDeMUxhAGL/v1LqrGx+JWxb\n", + "A+NuyL8HjlmIZU8TXmXH7M+yewUMJqD/F1dYm74UlnfAPb3nXmqIQmYNvL2Xa5Cnv4WIBWZo7DgB\n", + "7jScPP/VzNvwzmIYX1fC2pRh4ygkclD9JlSFwNTk5Llf30B+qBvqI2D1QtYBWYGlWcg1wZtLy4tJ\n", + "DXifgYfL4SAFoJSKGkT+9iSFP2nDVWHDnMsQtYyS7A3A9xYMyJuDshHyP4A7gBfQbvXbgb8V4Rng\n", + "j5QidJFNLDA/iAbLeR0jsLIWLJUQjoCnBO5myA/ABj+8FAJ7ArqPQGoDOZdi0B3CVT+C0TaOpQ8G\n", + "Xk+S/2GiXBUnIgK1H4IdEagr55HVJMHthae8sLcfJlqhoQQRA3TFYfRHFytgqIZta2Fsam+YNgg3\n", + "QcsINDLFA3wjWTBGriNmWNwOyjrFJeaAYgu8vRs64lBwQW4Q7KegPwFPH4J/UwnuBoiXgDPgH4IX\n", + "43DAS/z2PHFnCA6V4LnpFRsGcDim9NDYRuH0YgZGX2ZgZQTDK1B6Qyk1cWW/wr8MWqdVhhiAtiyc\n", + "XMyCMQLQ3w8Dh6ChLM2sxsB1EGwh2DP1g0qpvIh8D4JjsLUKZAAWjYOtHDprCxVxbXER3tsO+/bD\n", + "1maw20ANQWURjt4NXZPba4WIH5pHwQfnbkwlpV4Ukd4k6Q9aobYAJ0PwklJqoaHaTYAI9wGPA38L\n", + "fFQpslPecwF/BewW4V6lGH6XzSwwPxgZhNP7YLENGnwQjoNlDFIZCHaCPQeON2HpGUiNwr+UYDwO\n", + "W13kAjlC5gn9ULMfGJ5mSHjB54e6add1SwS8zdD5JQjUgqUGcjGg61KdhA3gdOjKnvOwae/vBWKk\n", + "N4oFY+Q6UoKSmuGJuQ6Cb8PxF6HTCp6I9pB0lW9U/5yED/uhOQ+EoGsCnix7QF662P6ScLQb1q+e\n", + "kpjkgUweBqH0glIqdeW/Ip+C7AznRdYIhYW8A0ApVRKRx16DXzkKK61ACMKj8G2l1NAMn1ci0gvG\n", + "QWialmCWMeeQvj4dAB7wwks90DAK7kFo/CDsdM/c/vuCJx2l1Gngy9fnVy4wW4iwHW2IfEwpdk5/\n", + "XykSwBdE+FPgCRHuVGr+t4T/ZaV8vf/gDfigD+4OAjnINMKebTB+GmoOwfJR2JmFPVNK+5/h0uKf\n", + "OcgCRQHjlDUgb4B8CciV14HTlzveOBzphtvXcM7ITYNpSK8xs6b4umCMXEeK0HMaWAUmezkPpAR0\n", + "agPkZ0qpk9O/o5TqFZG/H4EV4FgC1hKEq0Ukdin3ehh2vQUr89DYpK1v+xHwjMATFzNEyvLxppkF\n", + "seJH4eQ90G4CRzmXJW6BUwLpC8Z/s3LxY3BplFJx4HHd4BALELnEfPVBbwpG3FBfDssVBI75S4R/\n", + "chC2Ai2LIFgNweNQSsCLE2CrnbKRHvAH9aJhE3HfD2YbhDuBM/O9dG+BCxGhHfgx8OhMhsg0/huw\n", + "Efhz4P+6wUP7pUREPGBbBc5qiA5C4cTVVKKV198feEXMS2H1XdAzmTPohEwWdmfh6SvVf1JKJUX8\n", + "nXB0Cayb8uBzuB4iBy/lBZmJKLy+F1bloakZQgmwHYaKUd0vbgb9pBvDvGiUNxPztW+BjtlRi65Q\n", + "GJ9+otpFtrbDB5ZB0QilHp2IuC8K//puNysR552w+P3QkQNzCXrs0HkIwj++1A1GRLwu2OiBjjxE\n", + "AvDmu3VqLNe+7/DBFhMYEzA0Bs9Ml40XcdwBjR+AxQZ9/XQXYeBnSmXfuZJjdaXMxpyLiN0D9/pg\n", + "kwlMCegrH4PBaZ8zA3WUnw6ux41eRFqg+ZPQbgc7OhQ78CbEngbsdtjggzVFSAVgbwlGGuCzK8BX\n", + "DdkQWE9Csh/LO7D0LlieB0sBehzQeQxCP7gZK57m67V+oxHBBOwCfqAU//0yv9MAHAY2KUXPjRzf\n", + "jWa+zbuINEHbZ2C5RUfbwxYYGISRf1JKhS+9hRm3WVGvr+HKGsiGwXICMv3wz+cnoV/Wthpq4CE7\n", + "dARxrUrRkijR0gMTBejrg8BjV2s8iEiFCzZ5oKMA0XF9H7ls78oV7Gd+d+2difl2ooJWx6yBj9VB\n", + "sxNKo1Aag+eTSu2e9rk6Byw3gDWh3VynJi1WXQ+OD+1Oi2vVvI5/Dw8PnZOHLwEvLYI931WqeOwi\n", + "47EDhss9AStFHt0EK9bDsB0K/eB9Fbxn4FvosNHZk0FEKoBW9M24t+wJuKHc6Dkv64N8ejMsLuuD\n", + "FPvBvwtsZ+ArSqkAaJG6Rvi1erCXQIYhNgw/UEpdViKXlmSmBm3EpKa9ZwUWo43ZYaXU+JT3nGhv\n", + "ZWxyLkTEZoQVdliUgaECDMKy34WHR8BeNjxKwCuL4I3HlSoevtbjNNvMx2t9NhDhz4A7gYeU4rKT\n", + "jEX4c6BNKT5zwwY3C8ynedcPmfV/BOvqKuleVknBAhCgYAkT+ldIfAvtAY2j1+/MJYQIp27baoAO\n", + "NzSmYCIPx7WHQ4yAo7yti2p6iEjlIvj97ZBvg2AGTK/D8iMQicMPgf4LS/7nHxeb84UwzWUiIoZa\n", + "+M0dULG8nF2cBNOz8Cm3yAY7TAThaAlOKqVGRWxNULMVPHZIKpGKPZDoh8b3g98DWRGpOgn0Qzsw\n", + "6jExXFXEVFAsGoOlUehajy7nmj4WL1S+H9pXgAGRun4Ye+piVTMiUr92Su17BixxzItqsC4fwrY0\n", + "g2WPiPHnShW7QFdooJ/AbiWaWqB985Ts8DbtlqwP6gqGp0Skein85oMQrIQgwDC4n4ffEpEvX2wB\n", + "0oaG699B24PgNkAsJ+L6KSS/MemxKBulJ6Z9zwOVH4AlK7U0TWRcRH4OFG0YfrWE744E7iQkcmYi\n", + "mfz/Zu+9gy257vy+z+ncfXN6OU7OgwkYECASyWVcMK652vVKxd1VKFtr0SqXvKu1Vest+w+Vtsp2\n", + "uaQqa+W15A1eaYNEU6SYiUQABDAAZoCZwWDezLycb8634/Ef/SAMSSSCAAYE8K2aqnn3vdvdt897\n", + "p3/nd74BJw03jrUC7KnD3AnefWP2roQQ7AW+DBz/aQqRHfwL4KoQjEr59u3pv8tRhNTEGFf3H8Xq\n", + "WThdgEm6yfNEv1VlagbIQDgOqQUIGkLkL0D966+0JS6EyCXgxHC8L7vWjPkhjfh75gmY+BgkE9AL\n", + "hEj9ADoPv9iBFUIMW7AHYADzaTh+ApRdO3OSA8FtsFRB/1CbkRzYDSGGF2H7azcucH6ecNOKESHE\n", + "bcQ21RFwVkr5392sa3mdmJyE4QM3PMi2YN9u2GfC0GF4ch6OXYLLQmgX4ZZfgrvWIVuFjgbf/i9i\n", + "Y81PPQSl1fhjX9wDDxwxuLZ7khcSwwgZIlnlhaMbTFyPiF4uf8CA0d+AO1NwYBWEhMUiPPS3hRD/\n", + "/FVySPLD8UmRwBXM031GixmcTRupDrgXePDXhRD/8l2swMiPvAzxcwSaTtwFIgnHjkCUg/4WJEMQ\n", + "Q9DZD9mV2Dz36Vc+fOofwS2fgjuW465Fx4DH/hacd4F//eM/vbPlp8Hw34IPFuHwakxKW0sLvvVP\n", + "RlnRYWbGYKLjsXo8jUmCjNdjUd/iq/ka9z72Ev/kffyc4X8H/kBKfoLw/FqQkqoQ/DnwW8A/edOv\n", + "7L0JqdIZmsLGQt8hB0siBqPDZBNVxtKQmIQDLtR2QeEhWDoMP0wA/+bGA8WLC/bMwGePAwXolmH/\n", + "BbhLCPFHsdLlyC/DnZuQr0NXhyc/CudM4FtJIe4+DB/bDZECXAN1C+whWA134j9cMK6Q/GCGjAO3\n", + "NOHECswPw0O/ufMceNu4Hm8WbmZnZBH4kJTSE0L8mRDiiJTy4k28nteCk+GlFUwdMiHs2wNbFdBn\n", + "oTYbSy0P/oD8EbhtE7IuXBmC5ROgTsOuAmy7YDwJmQ4c24C528e4vvsA0/MaxgAECRpDLs9+poKT\n", + "FGIsB1vflTLcIY+KwzAzEluXvIhdVahNQOU48PArXH+ruqP0qUO2R7pkka016SU8MjUY7sBJG8p3\n", + "EjP7341ov3gPbkQVkoMdfxAb8hGoXyF9T5d8BlQM6u4QtVUHMq904HgHaOYj8IHll7ZPkh6c2YCV\n", + "z+90Oho7CioTknfB5B3gDcHIJEz94CV2fM51GNsd0dLy7N4YsDF0iCCwMLU+dsuiPlrCM8/zw1ta\n", + "fOEHOzTpHJRfi4n/Pt4BEIJfBPYBv/QzHOYPgW8Iwe+9gc7K+/hJVE2aro7xn5+JPoOEh5ZPoJcV\n", + "WrMRJzpQ6oGWgsosnDoHS7uFEKNSyo142zz3adh71ECeimhqLvVnUgSVNPTzkOjCp8sUk3D7FuR3\n", + "+IYJH+5YgZU7hBBzR+Dj98GqtWMRcRiUP4XPnMc4nsXsq4QDk0E7Im90Ufvx9KUAeyqwPQWbh4Cz\n", + "b8ZN2Qn6M4DuT0u2/Wlx04oR+aOxxj43uJC+Q7G9DkoIQgXZgnwGoho4Fi+tbqah/UOUWwOGrsN6\n", + "CtY/AGe68EIEkz3QM7B2Ozj3gyJ11H0O/dQmV+8OUEWE1jNIM0qqUeHUOowY8MMvCaH9hzzh7Dji\n", + "voil6S5fGWtx6kKsLwcodiEx/irXv7qy441RBCmw5QBfX8S3uhzcKWxKLTBH38J7eLOxtAibF2Hk\n", + "EGwqQBmc87E/yOKQEH9TgTufwLxHZ/dqgalNAI++cYkLJ9ts/LtXOXYJEhokfuz3uGak6B0cht/x\n", + "oZ0U4lHIjcOt++CWNbhsgHYYNu4C9UFIdaGZS2EFLlZBw1xSqBdNXFMQJHTIRXhdgZtNM0i1ODsD\n", + "ZQFXz0P0/Mtd2Pt450AITOKuyH97o5fITwspuSAEFeBDvIYFwPt4bUgppSrEXzWIfjeBzAmMwKVR\n", + "ULD9Hmo9whDx4hLAdiHMxv8vSCANbED+83D7QdhfTXBJ2ojW08x9ap35ehY6Mk7erYHeh9KPZYWZ\n", + "IeQw4cQ+8K0bvKqqUMqTzC9j6GlGKjpCVtg42ieSa6Suw64bvKQKA0j+ZwGeEMJJwh0ZOCWAOpzt\n", + "xttFr6oQEkJYGfjoDJw2QGlDRRPi68EriCPeDNx0zogQ4hhQejnZ6zsJUspqVoizD8Ftt8BWFBtd\n", + "OdvQPnyDpluCIvAbsJWEpWnYFULGA30AtSzsbkN1WOW5ey2647C+PwO9U4SbGqG5gj+6iFKXZGsQ\n", + "apAO4Ew1zdV/fA/9CznkwhpKwWPgPM8PPrjFxx+Iw5CqCeisCyEcoAAYOTiegKMSPAceK8NfPQyf\n", + "yMCZkGamg+3VOPVk3FkBKKdh8KYzqN8pkFKGQog/fRA+ewH2GkAN2uvw/f3w2TPQA2pXSSkdtmea\n", + "aGGS0VoXkWyzqw6d3IvHEkIYGnyoEKf2JpKge2yNCZ5JeoyUJUMV2EhOcnbfBG7/QzDvgngUPncO\n", + "u+Ryx84DJN2HRg/GBWzPQuoiCBnQ1y0G9QEdK6KdK6JEFpo3gCikF/TwBgbdCjxwHnqXgQUgsRN2\n", + "1QG23ndefUfiHwJXpHxNP4nXgz8BvsT7xcibggge3qJ/vMjS/gLqIEG4cp3MiRWmtuM5vJaD0Q70\n", + "rNiGIwK2FaAeCxEOHgLTS/Hdu1Rae5pYaoGs65B27qW1vAqpZRiH/kNQceJ5+0X4CjQQIPwbnsub\n", + "kHwB87RFvlkhu/UUnpPBs1wMt4ZaGHDX2ViB+SIqJnQ2d9SAmRL8ypmYXrAVgbgMH34a9goh/vWr\n", + "kWYL8MtnYO9eqNXiXJAzc/A5S4j/042tI95wIf1KuKnFiBAiD/xz4Iuv8P3fv+HLB6WUD76F12KA\n", + "eRIKpwEFak/D4OkbfSia8PUnYes63ClBVaD+YXhqJJ78CUBcgaRP4y/h8XvAyYMhNa7s0qmMwVre\n", + "5PwndQJVRe2pECSpR5NgRaAloTOK2oVAe5TOLODFAoptfQRROrgz6WxSdRXC4ihRtsp37wsYvgyL\n", + "VZteahR+Jw9WE25NQv1OeFiD6AJ87BmYqsKfVeHrwJdg1zDs34RKHpZugcvjIO4XwjwF3jNvdVvu\n", + "ZmCHU/MnO2ohHagPw2/eAe1paCwgMhlS8zaavc3W9BZ516V4JWSkAi+cEmJsH3AEhg4lUHUTWTMo\n", + "W8cI2aLmrzNXBM+q0sqYzDklalkDf/F7aJ+TBJoAPUdrZJOLz8ORDZitwIPNeAzcYXi6BxsHGqwM\n", + "7ad5vsq1iSwickEqSF3i9XL4mwKiFrIHThJKX7KonCjQG80jm0FMpn7yJzNsfjbsTHAG0Hs3/m68\n", + "1diR5f73xGGKbwb+Avg9IdCl5G1NWH2Xwt9GPFIjM24Szep0Nrp4T/uMduP0jit3xh2RjoDcEjw+\n", + "BRsXpJTbQoj9Cr0jkzx9cBgnBDVj0nZqtFubhM5jcMSPHbN7Gtu9gMdH4K41yLhxhtgD+9IsiSLc\n", + "fQ1OlmFRgpaAdEi4Z4uqFqCpNUqDGmEEE8/A2iHYLsLQDm/s6hA83wWtBKO/C9HYEOVDCuHaFYx9\n", + "GpE7yWC+A1PlmBz7spllO2KHfcdgawHuHgJrBiojkDoLv7IRL3r++M1e7NxMAqsG/Bnwj16J/Sul\n", + "/P236VpUKPwq3LIf9pdjUujVT8G5w0KIf/NiBbnDdH585x+2EKceh89VwdFBXgd1CX4A0bfh0iak\n", + "/r7O4ANDJH2VDTFO4Cv0DB1P9YmUbfrOBEG9CKzAZBn8iMDqIIVPsg1JCbVJqBR1hHMJblcxgg7q\n", + "bhdlVMEQBjgBg0BQCY7BXR+CxY3YyKLXAeM5OPYheOJOWKrBgRpMSimXYyLVDz8OF+8F5xSkGnDr\n", + "tyDfhae/CBcywP1vx/2/GXiR6CuE0GyYnoRlH9QeshSxtcvEdNMo/W2c87B3DR68HfIGnF4CZgy8\n", + "vGDVl3giRTCao1nO4q/VWBpvUs2oRAWNvpkic71NJsox2FskVBP0Wil8Q/DEXRtkvw0TTTjyDDz6\n", + "i1C5A6ZOQmEpYPTBBa4esZi3k8jwMiI5TOQNEWzVoDsHdg+7BPdOZnhm/wzq+GEynkPH0gjsefjI\n", + "82AIIf7pG3PifQlxoZ7+CEyfAVODdlUI9T+9qLx6H68b/wz4V1K+fnfMV4OUrAvBHHAP8L0345jv\n", + "VcRk8twXYP8dAcN2AE0oW/DCFXh8FQpHIZiHK8NgboG0oP4ItC4LMfJ3YfxMlsa9Y8xUTFLNkK7q\n", + "oDhtyrki/WAypiIMhsHtoP7qCnNPwfwuSBngqRm2wo8TPbMfNq+Dchk+VgT2wNwCYWKCIKFSSy9T\n", + "XPA4tQLre+CFFjy0BM/thHM2r0GnB7feBR9YtXlgysIv1kiPJlCuS0RnmcZtFtvbGaIZXqEYAbJD\n", + "ILdhIg92cSdypAjdDGgW7K7ADDD/Cu9/Q7iZnZEvErsJ/kEsKuB3pZSP36Rr2QV798Ndiy+9VFqC\n", + "wTRU9wMvS6ztS/m0EGL+OuxRQfdg4QZ57XkhxP+VQR4QTAUF/ENF8h2X1WyJQQ+MroOSLcNwH7Wr\n", + "E6kOaqgRRQFC1/CtOI1xjwSh96goG6j3GaQ2IixbYdhzaVsutg2T3RQLt47SO6/Ebb7SEPSHYbAG\n", + "I9uQGILuBETPQEkIsQaMQ9iF1gCOPQKnFmISFMC9S7B9jxDiiZ9HVvZPiTDYKdw24EQWRrO4jQDN\n", + "3iRIFDh3a5WBBfMT8KlvQuMEFH2Tvqdi+D0enxzC6V3DHaszrMCQLJK6uE19KmDD8TDLCq2jQ6Sk\n", + "ghr1UEswUCYJ0k0u7OszaBks/0JAIx8yW4eTC7EKJ4h63PdXPb56zzBXl07C1TpoG5AxoaVDyWdW\n", + "EXh6iU5xFtW1EXSxRnVIpgnJ4H9mleA54K9+tluU+zzcehRO7njhbCbh4V8XQvyrHzfMex8vDyG4\n", + "g5jfceBNPvRXgc/yfjHys2IKxu+F6SkoAqYf8/X8++Cp34fWfyTuCnYAi7i4SMHsfwN3+7CVynC5\n", + "JfFSHm1Nw2wNkD2FfiYLskJRBoisizs+hrZUI7Gvy6QBaqTjmzqp8WdZHcvS+6oBKzlYG4o1xMNJ\n", + "GGRIawWMgcLy6DYDs8HxDUj6MP+XUH1xyySCXf8YPrgCZujRzwakVZ2hhkujaKOVNYYGK3Rm+3Re\n", + "ravRqsQqwlIBbtwZMHWolSA6Hxt/vjuKESnlv+Udo9rIzMLUy9iCl3ywPmoKkfFikurSj7enpZR1\n", + "IcT5EOUAZD9pCXsmy0ABljXo3ULtyUU6hyx0PaDv6ww8G2EERE4GxVtBsZaRySlEaKN1B0T6JjIV\n", + "kBUmWsKl34DJeplqxiHKCshJkmaIaG/i9EP2tmDlgAIjNYrWOdwpnU7gIZUEDBIQdWODrW4zVpJ4\n", + "kPsvYd9BmHJh43ZotuBKHw5uxp/KCmFIwHwB+LkoRoQQFuhHIbcPvCY0zv+4q+rLQUopHSEe/iH8\n", + "yi4YGYdqQNi4RGs3GMFutp02mwmPvc/GKZnVFDj9kB4aab+P0Jv01HUyRYf9PRXDk4ixCDXTIVNZ\n", + "4NLhvQgH8CJ8tUtkBBhbKo2EQeeDNpuBTWgJqHg4Vp3tEY8912FxFwQLcPDKGtedw0T9U7ClglyE\n", + "3Dm0MZ+9103KORikAiKriZIwyAY9unoLw9BIJhS0/1GIXBIaf/FGOiRCiBIcPhqrhF4sVkc6cKsB\n", + "lXuBP/5pj/legxAIYhuD/2EnZ+bNxP8HfEsIvizlT8rW380QQkxC7hbQ01C/Av7FNxrvAMY0FPfB\n", + "dB2cnYd7uhtTy67/TWgHQAT+NSllNT5/6iQc02B2C8q2T6rt4Q5ctvMaApVB5CDRSbsqad2HrE/a\n", + "V+ikdcK0wsxGks09EbqSISUH2LvPcu03huh+PwddC4I0pNNoTY8AH6+goSqjVOwWP4wiCs/DfElK\n", + "eWXnfgxDVsRkWAix1Q3wU0QoCEMiFZdQW8ORHp3GK9wIgPVVuJ6BXXnQk9BvgTEH1hRcW42roDf7\n", + "9/jmE1jfTgghhoAEUP1Rt7p+COt5GGq9RCqaLxR5/O7d9NfHILcM2gI8L4T4ixuJP/E+euHXYO/R\n", + "PFsH9+CYCQZhglrxOpGoQeoo3tkOwewEdreFmW/TG3LQ+nVI93CiK7jKKkI1iXIStdZE71pM+QG6\n", + "5jJUhqTXoatfo5dKs5jVEaJHSJMjVSgnIK+4zHoeFZkl0emxNbrEtmrCoAliP3QWIXcFAkh8GvZ+\n", + "EqZqYC/ASBXGJDx9Gqa+HcvMIqAl+PkpRBIw/JtwbBjG29DfDRdvF8L6ipSDp17r/X344bNw0oXj\n", + "XYjaoPhw+V68p108fQnYwsvvKLub0MgPEH2DrqNg9BYIR3WGEdiRwKqB4g4YmDCS22QzZVM3TXw7\n", + "IowCRJRikGsQqTr96iyDxQK7uyt4xQZKwaY17HElC1LAUhN6yy3kVx6AiXNwQAXRjG38/xwqH3FY\n", + "OBLSK20gnAKqUKgHIRlPkPXaRIOIg3WofxAu+MTboj8tslCULxUiL2KkBcarqbfex0v4G8T8pDdy\n", + "/18Ll4lX6Ud5DxneCWHdCkc+B4fdWN2yeggu3L7Dk3oD25KhA8KIC5FAga4db9e302DdC8d6kOjA\n", + "NSGE9VUpB2chOQGlnYeyvd2hfmoCTytBOKBrbCDNNqoGZiIg0iV6mMDoV2jnPQzfYMMKURIGoak3\n", + "QUsAACAASURBVOzjoZDw+mStLhzr020qMSEsDAj1LfxUHcv3cPp5SlUbJepSO8qPhmi2oSHjUFMz\n", + "BKe9zcyqz9WxHF2tjMiU0YIKxQuw/Ypp7lLGQX/nQF2HL43FmRPdSfihBuFc/Fx407do3xPFSBxm\n", + "VvwiHNkNGQlbCJF5FFrfS8MvzMKHNc6d6LNyoMrIcp/bnyvw2AcO0wlOIM9loX0UeAQOPQJ36EL0\n", + "M/BxF3tXzCMoJVX88l5EOEJxHSLRIZyZpf7cebgzAdNdIi1Bq2Ria3W0wQaD1DaYBnpQYYSQoSDA\n", + "dFXWTIeyImllJGoUt+z1ELqGTjJyyHZdUiLF3pbCXL5Hz9HZ23HR1EV808YzHQrlBs3cd3HH2rB0\n", + "P4ysQrPMqAojd8Dtm5DyoLIHGkBLhayEp3fDUA2aNmxdeXEF8M5H4gNweghuvcGufUqHv75PCPH8\n", + "a01OOyqbbwBTCaiXwB2PLeBHr2CebGP0oVJV+bf7c4RZAzHTxwlbCF0nanUoRjq+dAl7ITWjyyCv\n", + "gdBp5SEp6wh1myiyULQEq34GEawTpaYgbODfus2CZ6D32gwKPmd8hRE/Qh1AdRyezoL8g4qUD+8o\n", + "pdSdGIFkkqd+2yZ7oM8hZwXFaNAVFltGjihs4aqbjOz4xzTNJPxySYhsDR6OYjvq1yulb0H1Zeyb\n", + "t1Lgb77eEXqvQggs4J8Cv/5W+IFIiRSC7wAf5T1SjMSLj933wSfX48UTwEwdjEl48Ay8ZuDgyyC8\n", + "Gje/V4swGAXPNHg+n2Qxa6DXTRYO1UnVWnzgPPBZIcQCpDZg/ghcOKazcnIEzzJQA8nASSJkgcB4\n", + "HlOmMcIkiq+hBwFRWKdrqiStIl0lQBUhUioQgasN6ApJwlmnG9Vjo81wlWSuw6TVJuUqKEGPctFl\n", + "dCO2uiL94ieQUvZip+/H7oYPrMby4dZInQMbdbpzkFsHKeH7ITtO3K+EnTnzjzQhznXh8xMQzYG5\n", + "Ad0N+H/feAfqlfGeKEag8AW4cxpu2XlY+Qo8dI/OY5PHiXbdDfMVup0lxKktOgcvsTKRp55LEG6+\n", + "QPJejag3RP/qLLJ2CX5rFtEzKEwKUoNl3Nlt+rbNZrJBWK3S7PTRE30SaR3l8DCd5gC3DLjP4u0J\n", + "8S0NLVBAJkmXy0ykUkz2dbq2RFNVRu2QHiGboYmlFpgbqZOsq4Qdh22riBqGiN46T2VG8MwaOUWl\n", + "LwV6q8Nk6ywt1aZn+aiyC/+zHzvGdsCYhYOfgbqEpgHZAYzUoV+InYpXzuxQS/qwXoHWgztqp4aU\n", + "MorzVpyTkNkHfgMqZ6WUizdvTG9E9jjsKf/oawkfplRYmADmXsdBFjdg7QDY49BaRJldJn9qAVvp\n", + "cfcTKnN7Zrl8bBKxoWCt99geruD359FWQ/YuBUSJPq1xSFoWqqVT00PKOHQVnZxYoKon6Eobz6gR\n", + "JvcgOwI0DfQqUaJClNhDV1nmrN5j4IEIodmE3AqsjgkhWgJmknBcFWLKgcM6+gnBXs0iE0oCv4+n\n", + "NbCURZYdl6FqQEJqPLR3L92tIoo/AuOb8KsX4cJOh+81w/+klFtxbMHZfXBiDTQJNRueycLWX7+x\n", + "8XpP4cvAs1Ly0Ft4ju8Cfw/4X9/Cc7yTMBn/bSf8H315TwWePcEbKkaYh41z8NhnBEPRCEvZacqJ\n", + "Akbg4poV2sNjaN4LPHFrnclllWtfNGmrPS59AfajMpVs0Q99yk4WXxvB6I6gNDfR8lVsv0LPMXHD\n", + "Jr6exCBJW4WMOoYSRfFWuhxQVSLaiUvI6TFoWrD4JM4+lVlhkPMtHF/BjMqQCGhmIRfA0JeFKH4f\n", + "qt+Mw/xa34WnfVi8E6JhGKQgacVejs+PQy+E3neACWLj0Z2tWNLEc/2PLECDmBd5YT0ODQ2J87be\n", + "EsuAd30xEuu/D+2FYzdYnOsRnNhM8dQXTjP4hg5RFuoBnWczdDJrMKNiAzPSxGpEBMYa9VNNNloz\n", + "UMyR7OiMbob45h4aiTSerZPxHDaGlzHGYcLLoGoSOegysDwW1Ntpf1MB+Q3kIYF/9CCWuUnCsikq\n", + "oJhdzHBAy0mi4FEMLOb7Gstan4Tl4OdCOrJAd6WALDdxZodxFQ3htlC0kLQDga4SyYB8o8OBZ+EH\n", + "UzBxD4QSqheB26BzHHI2zA/BZg0OL8ScrPok7J6HiYdjHu7mPrj0e+A9A/0lIZQHYfwjcCIF403o\n", + "DMGFk0JY/yFuV95syAB89Sdf9+EG86BXPYKUgRDiT74HX3wOZvuYtzfJtKocOwdT9TxP5mcZmQtZ\n", + "GlJphzp08hDWoFOldh1yJ6EQKSR1DT/0aWmSUBFEoUUjdFFpcoAmTUWhrPdodhOIRA7dM9H8Mqol\n", + "yMthOrLGUiNk93fgg/OwmoOF3Xla9+XQPtkkO2uRSvt4eoTQk6Q7oAgXOzDQ6RMl+vhqxJE0uEUb\n", + "XQFRc/DaM7B5EPoeHHkidmh8na3W6r+HRz8BL5yI04Yb3Z2E0LfMAOndACHIAb8N3PEWn+p+4I+F\n", + "wJKSN33F+g5ECP7L8GN8NXZKf/3YiWRIAh7IpyF/PMvSzAwDbxjN0BCqg6FquBOb1JUREs0B61P7\n", + "kdk29v4qM0aHgq/iCgM96GFEJh0SSFfFEDo9NUBnwKi3hS6zrGqT6P46bTyW1HVGlZCk4lMXSTqh\n", + "TSQ6GL6K03EJ8iqpKCRZdlFTPr7Sxw888j3wNdCb8JF5CHfDD35TCPEvdvw/vi+ENYBDvwS3/nvo\n", + "6XDuEzBahPHvgzYEF/6eEObXILkLDh+EQgRlRYj8eah/9UYqgpTS44YYlLcK7/piBHAg9TJ73ran\n", + "IZJpcJcQ0xukj0nSCkh0arsrON1dmANQUDA8i1J1gcrpWfzzEjsZIB2PxlQJ4QJ2GVeRCDPPuNvG\n", + "VHR8kUIJl1CsPqXd3yGdsgjaKo2ui7se4Y31CEo+UhdEionud1E1gQwyOK09OJUObUeyXYSQPtRc\n", + "lEyZKMrglruoqQoTpiAbwURfZawT0jR9LtwGy0Nw6vtwZgUaDjz8ORgcheNrsUpoTY0NvJ7cD0EE\n", + "moDR+2F4C67cBcMZSNdgRYvl6F/7bTi6HhO1qgchyMK+DtR/TQhx8bXc/N56VJ+Ey5+F4g2KoO0E\n", + "rAyATSHsD0L+VkBA/Snon325NqOUsiqE+MNtuBOGRuDu52G6CTXbItQi1KEWYiaHiKYQCKJwADNt\n", + "lqRHIQXjSwqLuwRrRZWSrzOhSTqyRkcJaSOYiRzq0qAo51jJHWI7rBLZ1xH2NqYIkYGF0nEIr7U5\n", + "fSW+qpZh0N43jn1fg7GsxoQcRe1VGaQrVIVPYFhoAw2p9IkCF0eJSAK6qiAGaabVBtf2jrP6TR38\n", + "NiSnwLsCe3mdxcjO+H5FCPFtYiVB8/V0Vd4H/xD4j1K+rs7cG4aUNITgInEC8HvBAG0JlgZQdmJ7\n", + "doj5XJeLUPnK6z2IEOo+GPtFSOfBjaCVBP1ikTBlMBgSSEWSVEERKTx3hcGwTq+Uwl/cT7TwKLnb\n", + "S0yt27hOBQgIHY2S1mBNX6Wf16Afkeim2FJaYKjkOg79LYElPMKUhqJY+LpNR/okpEZCLOKIiIzp\n", + "kMi6uNLHtw3UXpeorREVi9hCougdyrbLZnbAr9Rj1+fKFGztB56LpfhTH44LlaQHjx6D000Y2obl\n", + "adj7AIw1oPZlOLAId+zMmxHw2Al4ogV8500ftdfAe6EYqcB2FBvL2Dfsk29nPKLlqzBeJXeLyXhT\n", + "oIY+odpHE3Wc/iWapTEiRRKl2wTmFpo6je/7uLscBoGGW9IRUYCHgWf2MWSEYum40kNxB7h0EZbg\n", + "lpZG13XQm1usTvvMzWn0ruvUv+BRTduYUYhvh/iagRJo1PAIMwnC9BiaXEG1IgpqgrCwTK9UJWz1\n", + "UdISWzPZ21GQfsBSRoKQJAT0enB6UePKkSS1PQH+IZfRrOTqaEC4CfllSJdhcRqulOGDL8DECpQL\n", + "YOWgVIOKDaEdcw5K+Zh/V9kPwx4k+tBPw/JuWLsb+PbNGtwY7tPw7G5oH4LJELoKzHmw8udQ/FU4\n", + "OQv7twEJcx+HZw4IIf4f4rbQblAtCNeBch4+PwynBZUDXb5+uIk2aLHnfJfQ7uBO6GAfwqpGKE5A\n", + "aI8x0BsoH13Ga0uuI6n7EUlsRjshbileXoxEHgkRUsdBiXx0VaUULlPVwEZlV2CiCwvVr9EzetQn\n", + "YhJazYHngyQc62In2hhFQTXtYysOBhEGFTytADoYUYdeso+lQKIJQV/SSEV0hEq6XUMZukb4CQOU\n", + "SkwYEkKIZ/kp2q47+8g/k2fJewU7XZHfIk6DfjvwHeBjvAeKkTjPTPt38I1fg31FcCJYVmH+Avjn\n", + "Xuv9O92QO2DP34n9xXYvARF87xc1rh+ICBN9tLyHUCzUUBIoPsKMMMM2fcWk0r5MYl8f3dbwPAtN\n", + "CnBqKFGKri5xRIc027h2QLJl0g2h4Wg4/SqVXBdF6ZKJFBwtiSUUpFRRaNBRQnah46oqUSqH3ajg\n", + "KQ3kaIJukAYlws8O8JUS7nYSo/ksl8clp5eg5EFqhJg3lIOCHhciELs6jLXBjIA8eBqoAobHoXTx\n", + "pQWcApxag6u3CyEeeDWH1rcC7/piRErZFyJ5PzzwKTi5DYVeLON+ItHE/cPHUf7+BAndRAn7eMYS\n", + "/VSD8RXJaLjEJW8DbVQlEQ0Y2pYs5a9z6Y7DdDoKaSK0XoBvNkEk8VQTb7CNr7kYRKidCj0VZmVI\n", + "mBowKA3wEwNmrga09Ue4fmIUzzGYEx1adkgKnShqUrdmaEUBhjuMjBoECRcnEJD2SSgOSWuOtB3R\n", + "FgamNMEw6STShDJAhi1UpQ+74dnbS/TG0qBvoVsqwx2TsldnPePT2Qusg1yHzr+Eyq1xVezaYO+0\n", + "P7dtSOysnPUuDA7A/quQGLz0WiYB+buFEN+7mSvlnfC5P4faNDw3Dn4qJv0qp2DPQbjjyks/ffsy\n", + "9Gag/GmYvA32BfFk9kJWZ8GZJfBOwNomfdNBOE3U5CKXb99C0dfpZE5DV6KYIPVtIuFRkHmEvsWg\n", + "BFY2JIp8ko5GGEaEnoarxt2KnKdTabRIJAJ6iQyoHRSRZSxyMVQDwzeRXojqSMxhnT+6z0c+BZW/\n", + "7JH9M8nkeMBEWiKVLSoih5RJbBrUhUsC0NSAuqFApDIdeeQ6ktFyh8sTSXqmRTi+D55rgHMBSnvg\n", + "Ez7sasKzQoi/fufwf941+DLwNSl5u7ayvkvsZv07b9P5biqkDK4LIf43WNoLhhNbKv2k9cKL2HEP\n", + "zgM+5D8J2b8Bp5OQGoLreyHxfJqM2WMzs03gJFCjFjoKA9Ug9GuEYRdBFSVIcdAckE/4bIU1emMO\n", + "qi9IKD2cqAehjkqf0cBDUw18Z52a4tEJxlmz6iS1NrolySsBQ4qHygbbSpGO7IOQpCKLKCrjWgpB\n", + "yUITEes66JGB2fNphjbtYArTDTFIszLd5PQSVPU4HBiAXuwSG4o4fFN48RaWECB90EJoOXEosBlA\n", + "JHa2fYJ4wW5qxAu194uRNx/dH8AzDVi5B9RhcBeg/EAk5YoQ6SMVrI+ZtHM+VrfJ8ackBWD+Y+AI\n", + "j0+9EA/oZhG8aI1OSrJuZNgyA1SjR6jnUUJwtRS6u0jF6pMgjZqqEugeRCZ11UOYLooMaB4AR+sw\n", + "GlZopvcyUBOsRH1MavhKE19UUO0yrlrH1zxywsXUdMinKPngRzAhJG1caqpCxS5heSoGgiiy6CoV\n", + "Onmf1p0Wwg0QioHd7lNN2aTKPoFWJ70B233YXIOUBldDuP8gzLTiqrmdg7UO3LHj0xHVobYfnBu2\n", + "Nio29FowLKGSZsel72ZhR462DPYJOHQaZkNY2AvpkfizjO+EGbYdMA7D+H1wZhNkFzYimE4oZA5t\n", + "01n9LssfmqLnN+kmJIoqURMForBGIMqodkCk6mhuB0foFKSk4wgi4dOyQmwJoQhwBdQkiChCCkGo\n", + "hggRofkeKc+lr5hoWh9DMVGlgTTa9A0LWkWcrTGqjQGR9gLOvT67ZAo9LVFVQZoIhxZXlSQZ6dEM\n", + "fOaDJOgJlKDHZGRg6W1WJ5qM1toM1wLOT1tE1y9DYQ5md8PKEdiag0walPvhS0KI/0NK+SPeA3EK\n", + "qXUL5I5C2IPts8Dc+1bwr46dMLz/mtjk7O3CE8AuIShKySvKNt9NkFJ2gNfRCbFPweQnoGjC1iRM\n", + "5ECRMLsRdwuyFlz8sEQWBNNql4G3wHaiSFepE0YdhGhgD1rk62Dnh8l6FvYgR/9amc1bqzgZH2UA\n", + "DRX6is/+qo/MChK6jzAkDZGh4ts0zQZJ3SGnJEkpdQQBScASG1wRGr6EvnAIoz66TOHqNobMUI3y\n", + "LIYRmmXhRQKFAQVXIPISqwz3H4WrI5C/VQg1AJZhYwUe2xXzzvLzcO045GVsF3L9JNR2w/YwrH/I\n", + "ZiMyEZGPOuhiL0F7hZvQAX1PFCM7k+dzvKz0rftwi7EJuGcx/vrqECxMwhULxrW4i+IJaBZgsqmS\n", + "rTQ470dUkgXaSgFvuw97WhjaGsJR6IYGi7KGZrgMDJVkM2TYjUiqHmTA1gTVSCcKUmhqm5TsEAkX\n", + "SYpATAM9QlEnUjcYUSymQwWTFogOFd1FIElKHRH5bAuNltRIu+BrEa6m0+qO0daXqToqu3sBjZyG\n", + "qCvM+ZJ9QsUAAh8uHoShLtx9ENoCzqdgzgWlC8M9uOvpmK2+nIXqOnSvwSNFGJLQTCpsWgqFuYDV\n", + "LLzx9NE3GQfg0Bk4swFXpyAqQqcAC3dD+wEoj0H3FggSMXncTUJ5EkwHjp8zudIVbGUSJItFvO4x\n", + "grUWofkw4aQO66OoHVBEDsVoIQ2JpbYIlQq6qrI/9NhWJL6AlpDs0sEKoNiEalKyYEicrErkGgwQ\n", + "lMMEdhBhWRp6KPGUAqrbBBlQTwsiZwzSixifdkh4XVxVpSZAyghLdLHRqBJSUVP0m3vBERS1Oj2z\n", + "zhXLpOhrNPMBXtOjs52E763A6G7gFigDGCAy4B2C5AYcAR558UbGMuKRvw3Hh2G0r7A5q3P9SxqL\n", + "F1Qh/u8defD7RcnL45eB56R8RbvtNx1S4gvBI8QF0M/ouPvugRBiH+z5uzBig6KBOwG7PFiwoBHE\n", + "c11iAEoxIGcJyoFKSe1ycNCmocOqgMwAaMDmMDjuKuExnTUlINRDMnpA14d5oVATCawgoDnkcjCA\n", + "TGSgRZKUYjBDh6v2gI4+wqQIkDh06BMiSBKSJsGGjJgXNUoiiS51FOkzGGSo6Q4hJwkDDfAJxXXK\n", + "pTnqyRbZARgl+PDjoOcVnvmfslxhls7cOg+eqHH+zoBSJaShQ6YGpQNg2dCtweTTJtXbdRLdUZIX\n", + "PLp2ledub7H5cHgT/rbfE8XIqyO6As/Pgz4LbhH0PZBRYXId7By0epBcgOHDMNz0qY9aDKwJ9EEP\n", + "I13FnfbBCVC9ACOQWF4S18nQE1l6cp35tM5QS9I0JZpqsCqytNRxPC1Co0xeQBKDiBRdWqyRY8Aa\n", + "GTXNWFBFqDZqJLFEDU0MCKWCRoQmBHZkMkefqqGgqzr97jSDCgTmMotmg3ZSIzBz0NmDPVdhrlgm\n", + "LIGZgmwVPv1gbMoKUIxMvnl6iM3LA8ojNVaPh2TKggYOtctd7C3oHNDoT+QIZZahtT6VUcmW04Z7\n", + "gW/cvDF8EUOnYLIHT90JUw7MdGBjArb3waUinNgCmYMrhdiUdioAPQuhCi/MuhgDSXl4BiuAhNWg\n", + "WYhAGYt981GRlSp2dBl3OkWo13BlGVvUGZHQI4Gi5NGljhAdrokKlu7TtsFpQJgyWbBtItXECzRM\n", + "GdI3Q7YDnWEsorBBGDSoOWlWlV0w3YdbDIJxSScaQRUCKfs0RBNVePRkhN31SDBBw5zEaLfwDQfd\n", + "TdJPtlkwevh+h0IrQeeJWSi7kC7sFI4+qB5ENrgZcJ3YA/sGWCfglmE4Wk7w/F3DYJrsq3XoHSuw\n", + "9neuw7e46Vyhdyz+AfC/3ITzfh/4MO8XIzcg9xswvg8ONcD24WIJtj1It+D5LDhBTKFCD2mo0IsU\n", + "ZiNJVlEoBgEDGywJFyYh8mBX08OzPdwh2KvGLq1bisWamkDoSZaFQUfU6OoDjoUeiiqoS522ZqGJ\n", + "cdqiy1V8UmRIkMWjSQePTUy2hEoU9fFkSEp4dLCpS4WB3At+C0wBShrCYWT4Ar5ikBm3KFwJaB7y\n", + "UPwRRhyVrp3h+skJwlyDKk2qXROuPcdm2CeagKPzcMtWiksfHaLzXI2tqTqXxsfwrh2nfe5JOCCE\n", + "+Nrbnfr9ni9GdvgGfwoP/gLs/gdwfBNSizC9BWd/AcwM9LIwBMgoYCVU2B6p4hsaoboLgjwETUL9\n", + "PB27gOJnSOGiiRSu0OmwzqPZIpYcBSXCkwp5IVHpkWWEMcp0SaCSIccGEo15YZCRIbYIUMMNpC7R\n", + "gGngkogICSlKuCxyEByi1fDp6jlSqz3c/CJBcRS7bLKthgRulkQYEhX7eEMu6Tr0k3DswZcKkXIh\n", + "z+atJqXkONuJEuHiJtXCItXx0zCfhfF1+s5Znpu2KBbT5CsBc8YQWyt3M3jq+/BBIcS5G3J5bhIU\n", + "DTbGYNqGfS9uG82DdxvIDHQ74FnxxNRKQd2EVATjHjxTdAm3QlxHYhg+QuuC0YYoAwwgYxA9MsLA\n", + "KaOZm8jRRVxFMBZFZBWN69osGWmjyog8WUwc1lmgrkaknWE69hRIg4CQpF5BCeoMyS6b2oCy9FGU\n", + "LH3jMH6QJEguwx4b5G56SoW2OkYGl1B0UYWBoExLREzbCoEbYBhdMAWDZotKUVJSTAwkXR227A7h\n", + "tx6FE0PQ24SsDmMVSPvwQhuSm3HK84+ZIOWPwWxNZW1miNBKY9YBXEYGM6y1+3CXEOKslLL29o7x\n", + "OxtCcAoocXOK8/uB/+omnPcdidgcbeYM3LYVFx0A0xvQnICqB8lz8Pg4aEVYkgG5BZXMHgUjVIkG\n", + "AVECFC/2XnJCgd1RWCqFODYMKbEzcdtR6GIjtCK2ULDEBBKdBgs8KXQyUZYuYyjCZoSQdcZo0qKD\n", + "IEEfjQwWITUiRmWFEAs/UNhQcrRFAanVQFERTg+NJnq0RSjAEwl0zSOZ0QmSSbRejeoZB70hSRYU\n", + "FH2GqFYFpQozY7BaRHy0QTpS6GU6LGwaRHqKfFXHcBNstD5N+3GAizBJrOF/Wx24b2Zq7yjwn4CD\n", + "QOLtrsJuhJTSFUIrw/6zcOgGP5LpJ2DuHmAmNnpqZkdZ6+9CK+t4E9Mg+8A2hvTQ9BSBatFV+gwH\n", + "EclIUInySBVUkcFEJaKIKRr0WSIkIkdIhEM86h0EPikqWHQQSh9NcdGRKBLUCNYVCCKJlHBNQBCu\n", + "obWztK1ZgpUK3akeMtEj3Rtj1oe25jIfzdEo9UlEPQ5vQb4McyVwd8NgHizPYu2gRpRvYxeWOCy3\n", + "0DqC5clR6s198EQOBvsBnf7eMitrB1h5NgX9CWgC7ILohTjF8SYXI5VnIf+rcOYG/ooSQboOyjaU\n", + "VyGbgpILjgeXsnE+T9MBJzKZzyhoLY8gEzEQtZjxFQqgDlYB3YK8mcCsKbQdla502UyHNI0MTWGQ\n", + "RCKRqDKiL1KkogR1y2fdmMZGp68aFEIdSzq4ooerNBnHYzGcocspUAoYigq0CZwrIIpEYsCKbDNA\n", + "4sg6AzHAx8DF50poMKS0MJ156pqNTCukQ4XIbzLQe0z//+zdaaxk+Xke9t//LLXf/d6+vS/Ts3PI\n", + "ISlxFWVro2TLi+zIih1ElgMHSeAYCZJ8SRDAiT8bMRAHcGDHMGzHgZPAkuM4lmVLIkNJliguw2U4\n", + "5GzdPb3ffalbe9U5558PdUmNKEpibA17JPIBGtVdt+rWv885dc5z3vd5n6cgr1fSv/w5u//HuuLd\n", + "LS5NKK5yu44v8cde4hPFb0nwLEeMF+p651ryN+VQzEKN4hL5q5zDd8jIb8ZP4R/E+M352/we40Ws\n", + "hOBSjO79rq/+g49zrJ4wq+OUjKzvcbLM/XMsnWeyPJe77f565eKFSr1f6K4xm0WzA/YnnP90UP6J\n", + "NWuTnntLleUsWk7oJuyHtpE1mVxdpl4tKUImhj2TpG9qURUSZ2LpUEsSzps4kdsxdknmjj1Lph6I\n", + "oeFMGBmFiXByUaNsKtqpqjOVmyqTkVRwthyb1Xb1qpF6QnjHyGhxkVgzvhhVg1w0pNlhVnJ5wAc+\n", + "IB58Vn9j0cXjA71LPZONUv24MKwvGXWhR200D8f7lvvVPMrKyKF5SfGbngt/axELZl9ne/3kHrN/\n", + "zb/oE5aXtb//eWu3ZmbXR8oYxGpgJR9bSINazOyqmSRd/Wx+EUurRWU2FJWmgdJYZUmCwgQ9pULi\n", + "CDO5XKKvZSgx01JYl+mH1CBwoDQsomOlULLwWt/Kp7/o87M3uBQV19csz5as54n+uUpPTa2bS0ZD\n", + "659pGRRD6/e43KT7g9x4N0+9EPSujjUWU6Ppks3dXKsqNNKeV9b2dBdWGBeEVY4Pefwx9upvMhOb\n", + "mSdIfSv31jdG8dKccNy5wuXuvP2yvUAYZfprHbPp2Elnanu1srJDtsO05FaN8XSJvai52nW//X7j\n", + "uzWqh7TvkhXEnrXzTSsPEtXkoXJl0dU7hx68c1lVNp3kqWVBkNtPckU5k4RUlMtmiVFGFTO1pFKW\n", + "xwZpoZ8mzsdMrF2QxVxQSRNoSsKaqQOsm4QL7ldf0Ek6Llqz4IGyGipTTtKpMu1ajnWT0JInpSwb\n", + "OCu6OqZ5wqhe2Xi+8FL9+5R/6x6Xv8xlc6Z2b8bD3+q7svcZXv7J0plpqWzlktnUqJbaml1l/z7n\n", + "vX20Qm8LhCDHnzP3+/iWI0ZVCP5f/CD+/qNYw9sMBeVdth+f38x1RvNDfjqiP+JqYOV1ek12nuFg\n", + "QLUXpRgHHuzz1D9l77GankQaUpdmmWxcOmgmNmKpKXUSMqmRng295Fiu1JJLw8g4CSZVZhxTEx1J\n", + "0pAplXInlmQuKb0mOG8cUvfiWFH1tY4m2t2XjN7RV9kRwlkZYjIxSO5qx7EnYyUP0Zkw8WoaTgAA\n", + "IABJREFUMDqf2KraimRma3lDrJapjudhO0ubZJsc5bYW+pYeW1JvDxRrex4uNdx7+LTZ3SHZJ7lw\n", + "wP/zKKYjH2Vq7wST+cj32wHVzflUybM1QsaoST7ijSaDf0xyLvLDN4yfKozWojwk6rWGZkJWVdLZ\n", + "iLQuD+SBIBomE9FUXV1HIsaeQah0ZYLEQxNXHWsqdByr8BWptsqKobtqRuraSvtx2V65qF490B33\n", + "5EVUPuTgwdjs74w1/9KG9kfOydKaw1gpqyCzzeqqyeoF9yTy4tiNDzxQtQsLnejkSunB944cLhZC\n", + "3rB0vK33XMPhYE27GltvHOgu/KLGuS2LVwqx03dy4VMm19foXeaAuXNW6a0fYZynUjprfhG8deoM\n", + "+DXM/QeSv8GN/4w8zmURtVt19/9k09HwsisPh4r+loP3Dt09H3mN5AbrP5f5hY8uGW51TEdLJkc3\n", + "aLVJdogHvHLP0rtZupBI1mbG44lLn2qpLjUMa2MhjxKF25axIisD1ZFJuqDmxL20UC9yaR6FatdB\n", + "qBul1zTjQL3oqrJKnkxNzETZKaWJSvtyQd3ENMmcl2nbl+rqJJXFZO7ovKnSxINQOZQbhkK9YpBy\n", + "7wp7A/KtaHn1nINPXeXF6lTMHQkP52XZr0P1Fb7yKxP7f3LHwvVlsZt5MPugvV8/oH2Hnt8l3+Lb\n", + "EB/FrRjdeIRr+Kpu5O8/wjU8UszNzDZ/mMvn2L3GuT2qHCtUBbdSrv0iH/oC44xP/Thpm/Elhg84\n", + "KOZmkPU6X/wRJkuZ4eDIw3O5q+PKYZ46J7odok6cGIWBY0sO1S1gaZ6xK8FlXZ9L1nTHpSQv1eLY\n", + "TFcaG9IkE0QzhbrEukqFfiPVu1rnIOoUXRtlV5XMPEhXRNsmZi6F3GJWKWeVWznrugbtmQfhWcdH\n", + "i5QHpDfJG5QFa116Tzi5u+dLT00sJW1hVOofBr36L/C+EfmQWwUxhND8VptZfttrRr6KGGM3hNo/\n", + "46f/a66co1lxL+HeL7HyYd71xEQx3nNwcWa1nTuKC8bJmk4cOwiJk9pMLdw2dt5uyMj7VNsS61bL\n", + "XKGpNFIL+7KkMI3LBuVNt7OxcyC4bdlI9Izcgsyhhq5EjKVMwyRuaveOvLHQM9lh9o/p/aslfqJu\n", + "/BNB3pgapZU8yWWxZ1qOzWoNMUy1Fhet7p5x97GaVnbs8nau3D22v3AsW+Dxfs1Kg7Qxsr3ywN08\n", + "lW3f0HqWd4a2je6+h4upB7V9x38mmGy9yvSAr+zxt+e5CG8NQgjpEn/8Od5/iTgk3mQYQvhfY4wP\n", + "vm5Pvsitf8Lkw1yWe/iuVffv55JxX75MPbZs3y8MFiee/SIHx9woc7v/8D3i6tK8CvL+DW4NqR2x\n", + "NLSaTz0zLHzwC/MfT/CZtaHj0PBUtWRWlB5Oxw7rLWWckvRJdmRxg6JwlN3XkEliy07SNk42NB1a\n", + "qRqypKYT+nqxpx6mRnKVXOohdp3Vtu7AtmBRoaFvQeWSeSX1GXPxbDesaOC84A3rbiZ3HbUK7ymo\n", + "pUze07Mbj2iepf9Vm6NDGiUnvg6nkzL/IoTw2QH/Tpt3X+boJu3b8xDBf/itNkX6fYCfxD98xGv4\n", + "OP67EIQYfdtNO4WQPsU7/gIfPOTCHV4Z8cIPsHiPtS/xoGJvxh/7IkXgVz5CeJYrCU9VHC7Ow2r7\n", + "bd5Y55lf4/B8obE6022WXquxWlXuhIoYDKqJu8nUWJAaWTHFsYYTq3JnqwOX1dxvrFipMlU8kTgy\n", + "Sh4T47FZeKCm6VrctGAsOjZKj91J7xue6xMzeVK357wVQ4kosWZJVIV9rTBSZjW7Se6gXDOJ+xqN\n", + "f2KUXxHLs0yG5G+wcZlPL7D23UYv9oxqv8rSR/jnr/Pcizz9PfziIuM7/PEv8t3/5gnI/2Z4W5OR\n", + "EMJffdM/PxFj/MRb+4mtTa7cYfk1YsKHjsifIHucD/3rsU+22Ki3PNOberB0xxuhqwgdMfaFMNCI\n", + "a5ZDX4KRI/1w4LzoJGTidKyej8VwZ14Fibk8mzmLjsRES0emqVCTqmuoW8JMEiYKLbOysJM19IZR\n", + "8T/jpwPfdZE/c1mcHZgUD1T1JyQyaTUxzB9TJKm06tnd3LW33rIQlnUmXQerTZvDvtqZhqvJWLHU\n", + "U41TZSitllMHMXezlTi3vmxtZ9fx2Zrdjeetf6bQWGq5t7Oh2voMpm/xHXLGu97JB7+f26n5CfZJ\n", + "Fv8FPxlC+OtvTqB900X007x8fonGj3O/TnHTwZmxUEvF8g5rL9n9OG7g1oj25/nLf4jegAe7XD+Q\n", + "LN5Q1brO1wuLfe48HawcRp0+a0tMVkuNtG4/XNYqxsa1vmkIpo7FuKAKK4pky3qMVlMy2wZhxTTk\n", + "0qpUSxiLVuOxrtzAZQmCmwp3LVj2mBOJnqiyhLrgTEUtzEfOo6CwJEotIDd1bF3LqiTs6iZsnnDh\n", + "sHBw6Rft/8B1bq2zc4X9z3P2kP/7t9v2McZd/K0Qwsr9uUZkYm4u9c2m/n5b4NRb5EfxXz7ipdww\n", + "b6E+hVce8Vq+pZg7q577Yd45Y3yV1xq0dvjhf8ZPP8YLP4N7nP8p+g1efSfN97Ha5mJF39yp+dV1\n", + "muk8FXf/Iu8wUWRBfVB5vRUcSSzHoBui3SR4MnY1w9Cx3LFMpWfT1IUYhCq6GG6b2jUJmVaxQLqm\n", + "Vt3TCwMzfSuuWQpjpYGxRSfWtEyNwirhxLY1tKWiTE0wVWioxWiQzduzySzKDzetzUqDVk2VXTA5\n", + "XhLHHR7eZnWLzjOYzCsmi6u8nJB1uHiW4RPsZcQLnCRc/gTvwa9+q/bf24WMfMNeTYzxr37LFhBC\n", + "g2vvn5vE1N/UL7sZqK+xc572dKwRK6PNRDOZ2Yg97ZC6p5LF62YWrYRUiFGoCnfDVMe2BSOTtCHE\n", + "iVYcmOEgmVkyn5BJ1OxrO2PirtIdqWuCKEHuWHTPhl4yEZql+vScpf98qPcXx4ymYucVjaUJzQVl\n", + "OJY7MMguitWiNCYaoW4h1hTJA3laCslMNc1YroRmqkwzR2lNrcotH5eqUCkaM9PtPZduHVs8Dg5W\n", + "v1t9XJOPE82Qqk2fNr7R5+J9nsYn36p9s8GH3sH+V4kIXODkMpcezLUPt77+PTHGfeyvh/CZQx5/\n", + "kr0m013xucV5qWBpkwc7fOrUPKkfQvbrO/L/OMifnljpjCWzuSX+uRiszzKzDfY2c8fHI8OFaNoY\n", + "KWNq2u5phVQW2uYzspti2Da1q5ZULlhQjw1lNVKrRhrx2FFYU6UzC2FqbE09GUm8dpoyH+Q2LCMx\n", + "tGdBX6EfK+thapZUlkRTFHJBqiHIZILKUKpjUbQrBKZLwcNsQWtWaV8MBp0bZJ9g64R/MJ6H5v2O\n", + "OK18PVJju7c5vh8vxWjnUS4iRjEEHzPXjfyBJiPzc7biTcQ4J3uecJ6VGfmM3jn2Tzh7m50h7XfQ\n", + "r/GzH2XjKs8VjEbzKfdxyXSVlR63F3HAhQbLM3pZ1M45k0QhrVSxkiWclzhXFdbD1EjlYP42T8R5\n", + "carCKPDkdGg35dz+0KjV1W2WbuRR4YLVMFWYCFInLqs7UqkJUkRTXcGGjprSguDQkZHFQM8FpUoo\n", + "KydFX71bVzQvyUfHZq4oX2yQdLnz+XkGSOMsxRovvo9b25xPqOccZG86v17j8EXe5duBjIQQMnOv\n", + "gufxr0II/22M8dOPaj1o0Ep/MxGBfELMmLZJVjOjhZrNklDWLZcDowZVUlOGhiLOjOLYKEYxpsTE\n", + "Tpp4TLSZzLRUpiHxRggKdZmOHblU30RhaoxEruue1MREadGxDZNqpp7tGicpBa2kbuNsota+o6Fu\n", + "ULYcxpYYxoYWlSLJTdEF9bImjQuyin56aDnpa2Uto3rHQbpqmGXKousgHTlfr1s4rDsejCRl3+Rw\n", + "5umXWu68J5c2oTKr1RX9041WZvMxsLcMKc0m069/vjF/qP1O7z3gVz7Lc0MuHvDe72Y0JFnjpfcx\n", + "/nn+gxDC/0j9Gd79h04s32J6HoukZ+iMGedBv71g+eZIsjazfSaxW6vrJ7nV6UQWBgZhXTQ0cUtp\n", + "ybyEsKsVEiKTZCyqSWZj9eTINKs7iJnEzAkmokpHEqeqkKlryb1hz4ZdTcG2bjh0glXBgeBEZV15\n", + "2mtORYU9qyp10ViQSEWDxoKBJbG3Jnz2yXlwT23G6gNe/apY7TSz4yLa5sZoyQLvrLF0xI1q/trf\n", + "sh++A/Cn/A4Vpm8xPoY/jb/5qBfyViCEcJmzf5Trl5jNQlj6NCcfR0a4yplDlibza+vCCCtzger1\n", + "n+LxOvEd88DP3UW2Z4xyHmApMF1ht0G1zSihvsjuZfImVZ5SRqtJYhiCaVVpJzPjJJhWmaUQDJRS\n", + "7MWgE6PdlIPALEu0Y2JlqWYtm1qsVnwlaZpVQ6Mw0TIy0jbw0MDIVE0hNdJUOlLpaupoausauK+U\n", + "uqQuM4sjk/w5rZNbRmkpzqaqWqFMb3J1wsFj/PzLLD3ky5d4/lnupXP76fx1WlffZHgIY7IRC6sh\n", + "/FgyHw/+Mm68lVOvj1LAWuCHHtXnfwP06PbnI7yrbxLuLBzwcsVaUVN15u31bpWYhAWdSaGXV/aS\n", + "uoWqr2fViXPyKoqh6zgZKIuuWRg7GzKNJBig1DZWCUqpjqnU1KFS7prGaVF+aKTvFUSJpWRi5IyF\n", + "WDdujZy0dk0MrUtlIfV80fWFrOYNT8q0VVYlDqTuG6YbkqouL08UcV89BGnS9HDxjDSMdS1bizNp\n", + "9ap7tcrqbFO1/dC01ndrlxvrQ+d2Dm1fWTCdRQfJWcWdCneoDeYqyrcMXV66xfe8l/tffW5Mejq7\n", + "+OC3ex/EGB+GEP7OHv/F83NPjaLJy9e4kVE+Na+uPF3a+CG+9wGf/KOpcDX31KxQTVlMKq9llHoO\n", + "LyTOlNEsz/XDVJoOjZuLuuG6RQtqorFS6WWlQxTEDZmWuTvMUFWvU1QKY71kYDeMJJ6TVxs6lkxD\n", + "qfCqY31R6Vjb1L62iYtarql0jBQqhcQDhS87UbcoWjW1onDsgWNn5JqT0qCsqaqRo1pTv1zmOMEq\n", + "yzUL/2kIF+/S22XpWrDyWFNcmjqpbejO3q/60gKT+3zXV9gKIfy9b2Uf+fcDQpDgx/CHHvVaTvFx\n", + "/I0QpI9oxPgtQwjhLE/8h3xkwJW78wDUL3wPn12bp3cv3OMrT3G1TpITBjycEdr8kU+w95F5Evfu\n", + "Q7oTbjZZSXi84myfWY1Xpry0wKjOjQ5lHYGYVM7FTKfKLMWpvaStUYxMk9IbSakjk8boAPeq4ExI\n", + "NMrKLOF+UgmxcrtRyELDYbjkpHqc8uftJXc01BzaNLIucc/ACq4qDFVqMlu2PZCpKa0o4nl5qKvU\n", + "TEIQkttGVxfV9x4qixPD9gbbHY7HxNf47h6/NuAff57d23ykSdajV/D595/aNEBJ+Nd81wVO3kkt\n", + "Id7g/a/xuRDCz7xVhOTt0qZ55IgxliHU/yW//Od43wFne2wt8soyd19m+H1Re6ESw8y9LLdcnkjb\n", + "HffDpv3BA+NGosguakklmFYtZkfG6ZqtpOUgFKKuGFmy6KyhQuK8gamZN3DWUN9UqbKssopUYVff\n", + "xCWs64QTR6Gp5YrM66axqx0qDxullgXFaVWkkoiWRD1199UlkvzIk7NSmtS8kjVVWSodLJvManbr\n", + "hTSsmFSFYW9FVTw0foPR3+Hn/zRrl27pFYmHq8+afKpP8gLXbsynMm6/lfumxyc/yzsrLl7ieEjt\n", + "Syxt8XMxxh6kITxzhu/NWB9x+4BfepO4tTtjf8TDiqOcQUFakC4QczZLnRYniwzeG51pFjp5dJgF\n", + "SZG6OK3cr5futqMbBUd5y0aYahipQkdm5Egw05MayE0kJmZWnISWsqpJw0CZnKW6YVqrWVG5otDX\n", + "dFddkeR6JqaagksSn3YgkZjZNLaMZQ1nVSqFqYmpVEvmTlwQDRUhV5kKhhJ1x4Kb+UyVZXrOOhpF\n", + "nv/lecVj+yuufHflyXs8+wYv/PuLXn/yceXtJY3eSPnEWD2bGu8+Ln7ucTS5/Mt80Pxi9x38Bt6H\n", + "wxi9/qgXAjF6GIJdvBsvPOr1/N5i5cN8V8GV0xylZjEPv9x6moOb5DWKjBs1FuPcU2SvYvWAkwtM\n", + "r/OgpIicGfNKY+7/VwXu5xzUmR1wvuLmBkWdp8O8WLgtej2ZmYXKPI5rJk8q60kijampShITszIX\n", + "Q4HKXkIj4clACC27cq9btuuI8OuEUqbmDRfQUEoVVnHd3P9ipnJeYQNfEfRVVsQQpEplTNXkpqFj\n", + "mt9TrMX5jdDeBW41mfRZvcNTO3PH5Ookxo+HEH7FvLg8SLn6z/nJJ1hv4GUWM8Kf5IXaPEHV9Xml\n", + "9L2f4ot47a3Ys98hI29CjJMvhpCO2f4B8vOMe2SRP7LPzR2K84F2pqbuQdxwHDeU1VmhOnEyWpS1\n", + "j8ySmm4SMVQkDdEzQriokqrcF8PLJmpyhamZW2rWDRGNJYLKGTU56iY2kZl5VUvN1FBNadFMTWLs\n", + "JMw8dOKSljdsqkvVRSP7RhpKmbGeTM9KVZNP6npZrqdjfbKpdXiiu1A3C835GoYDk+Oh2f0e/yjG\n", + "uGMuYFwb0HyZC7u8J1Lu8/GCF99qw7oY40kI4W8f813LPDNjZ4+fiTG+Dq0QPvAe/vR7OFjl+AHX\n", + "PsMzIYT/hfom1/7sxMIffmC22XcwPmd/eFeS0tq6Y1ofK29wvM7Oc0GzCGYSnWLmoB7t11JL08rZ\n", + "NHpYrdhpblpJFjF24q6h3IpjBx6KzuC8tk2JPV1DE3teSyrnZVJMkwVdbee1rcnUJI6UjpQqOXqi\n", + "gcoEYwvmxncLgianXeRSlMtjqlPNtMKifmwapZeJLWkYER+YVhN7s45kdEbj4IKkWOXoDhc/Y+Gp\n", + "meujwuOvkuR1483r1qZLBq2m0FuTThvy4UtmHy4Un8+IT7HzIu/1HTLy9fgxb58WzVfxVd3IHzAy\n", + "0rrCZve3Pn82zu+Ljs7Nc8aaxVwb8ljBpy+xs0z3R0ivzts3k5QbxbxysrE3t3Iot2m9ijXapxrv\n", + "7+kxXCQLrAcKwXbIPRdn7oapV0PNUKYepirRQJCHGUldUpaaaelxwXK5ZCup64dNjbgoDy3BWBXm\n", + "lfBgE0sSe+bUJzd3ahtiSZTJkGgrnZdaMBPmrsyxUJUV0x3l5N3czth9ncGUp1tUT9Cb8ONH87Hd\n", + "//3UWuOr03C3Qgj/w505/6k1uPyjPP9VIgIJrtO/wTv8DmQkhFAztyufYu//T37VtzUZCSGs4oL5\n", + "hrsdY5zEWL6KV+c/X/8Jvq9Bd4lrKaO0o5olqlpiLVS+nK3rx6+IoaFlUVlcJx6Y5jMhjsT0HHJp\n", + "1VaFVBUuyZyo3HffqksaZqbuC7pKha7zUjU1TaUEh2rac5NgMwyty6VSqUwqc05q6kiqZyY9/d/V\n", + "JYIT4+qhJHlgSWozJob1BTuzjnJwZL9Z19ioCU5MQ2lWbYsHR8LwWHpnqPzaQRdjPDj96/0QwufM\n", + "HVfrWHLqN/JW4rQC8onTP19DCKF+hR/5Ae61T79cT7CXz61mf/zIY+s1j29cNNuZGubRwuo92eYT\n", + "jg8fSs8+9PhXaD3f9KUPr3pxqaGVPfAwnWh0ok5CFqMj0VFs2a2dV6U1a6JoQcOmvrEDmaguWLHM\n", + "qdonF5yTCKKagzg1DI1T55hK3djMQKkmlchMTc0r/tFM1BGcWHKoFMyU+mbGZo41zWRmYeAoLfTi\n", + "oZF3CdU1aTETTaRpKhT3TNNz0rSrvvm6KlvSaLSN96aSs0c2fpYzu9zfbNlda1s6mZmuNNR2I9qy\n", + "aWve2lq8SLdyurjv4Ovxw/ivHvUivg4fw3+Cv/aoF/J7i+k2B9dYGdNv0l2ZG5nt50hYfIkXrnC+\n", + "Pc+U2QkUd+h9H7WMy9Vc4hYrPtPg4ZQvr81b8/URi13G59itz9s3jZS8pJ/NbwQuiu4qnIRK3QUL\n", + "cl17Uh0bsWbdSBYGUoXtJDGOLcdh5uU0c2hJ37IYKovamqduQif29BEUEsuCE/P+WmZ+gTpGX6VQ\n", + "xIsyURnmNyRRTRW2hOSOvEbSi8ZrDRZrzDaZbHLzhOSY3nUe/1W+F7/41S06t83Pn6F9hv52pTgp\n", + "v8FQSTXf0L/tFF09hOcv8yc2qU0IO/O27v/5pmvH74hvSzISQggdfugp/vAVc7eGNxiFEP43841d\n", + "wxaXnuLyIb/yXq41SZPUwjgxrSrL8a5ue+b2KFdUiZq+XjIxlxe2ZcXrpmkTiSqZiNqCRGkD+yoN\n", + "M211iVzDiZktiQWFVVGldKLuSGLJTK5vakNAFBVO9PU1tHS0bJlhz0RT0NZG4phkT7uqW4uZViBN\n", + "Rhab0X5JWVYGoUl/k5OXWbutWQ58/6vzL+GrfymE9s/GOPi1N22781z481zpUC5yvx1C8zOM/94j\n", + "EjeunyFrf50D7GUOg/QjPH6/aXqmZraYKM6fSBcmNsIX9VeHSj3v/ULTl566Jlk5K9zasffcdeNk\n", + "ywvZ0DOxtDijW9ZsHy9JVmpqiApNPHRecEMhGLkglRgZ4kRUWY0No1AJlqWhkJmZ+/S2ZaZKa1JD\n", + "LWPHNuWmp0TzgYmJqCN1pK1moFAXfMWaNTVUulruxaBrLAtdafW6Kq1LLKhrqrIgpBOdkLi2nzI+\n", + "crJyYGt9Iip1383nK/YuVZLOVFZLZMnEaCNSLZi2qAbp6R3SK3Nl4L/81u/ity9CsI4n8euPei1f\n", + "h1/CPwhBLcbfKv7+/Yu9X+PzzwXDs0sG1xeIY4cLI68d9/kZRgVrD3jlMmHIlVc51+J+xV4yb+HU\n", + "s9NDOrKwwPEBl/bZRP857mxyOGI1ocjndYpRnJORCQqFoaYjCY4ElaeVlo3tB0YyY0sWy4mDrPQg\n", + "XNLXVrMi2JCYmZlIZRo6Ftw3NTNzonBVbmL6NYHcClLRrtK61DlF9bqYbqBlXjk5UDN2PhTaazfd\n", + "Gz+u29tk2CHd54k77K/wlcfZ+TIfckpGQghnuPQXeWqRfKVm+2L0xuwlxydPs908ddouCK/ROuKl\n", + "b7RXQghXnuPf/SG2l0+dmV9n4+P8hRDC//TNWAF8W5IRPP0sP/BR7uSnR+VLnCv5m2f4UpPZFuVd\n", + "J61KdzgPVxufCxpJoaoKZTpTTypn465xo6ZZq3lQnRGql5XZU9I4xS7xHOExla5gJlrAHVNBw0yq\n", + "J+rqyx16h8ILXndioJAilVsy9EB05K6oMpDITSw6ENQ0BYfom2pINN1XE8xUgh3N2HMttD0eCt0w\n", + "M5ZoasjTd5gOMbpLq0eWaxys27wzcGmfcz2eyPinPxpCeC3GuB9CyOdE5IcCt8/TOctjuPdTvP5U\n", + "COGvxRi338odN2fxLpqTxrsY9eeMXfKm1/WoF7KSWkn3XN3s7KL2uBRrQ4lcs5iq4zPvX/Hw2VTR\n", + "uOPg6TNi9rha/zWxed9RNtENU2G2aHO/sLXKLHIv0NEytXDqljoT7ZqaC10zicuCGPYdnFY2glKw\n", + "Y6R03tDsdOImyqSGErcEBypDLT0LKlML9mSaSrnCgYsO5BpKQcvQWWXYk8VFRdgU0jqOJXFPUa0q\n", + "40hWDS2WDXmvVHWC9WxqnDA6arExdvfPlt770tDi7b4711ZsHMyMliuT4S1Hq8equ4e0v8Tqa7wx\n", + "4lFOvL0d8YP4pbfbBT9GhyF4zVzj88uPej2/V4gx3gkh/eVlD/+bZcvDYBo2Hd94zuC1j/Hv3TN9\n", + "gtUOz+/RbfD6e9kZEOOSo/qi+8lcFl7T1wlsZPPsyG7O9uV5kXwnIZvNp2B2UjYCkzA/w9zma+qO\n", + "A/uWRXWVXKYVgnUTD5Il5aAmJn1FXje1ZlGpMJQj1THSNT0dZYhYsO9QVMqVhqef9NWxtvnBlUpl\n", + "YWiSZuYnwAOMJXZVYVEn5GpGzqdfVq6NTNv3ZcVttdZYbXFZ2R87zilnIYQwb6Gc+VN8JG8YXtow\n", + "Xuu4MBhqLnZ99sxPmzaf45UEN8nemBPc299ov6zzgefnibJfi4h4gr3bXN7iGr+7nurbkoxs8v5n\n", + "Of4qEZmQ3uVDzwsXo5pVxY33Kh/8gu6113zsTGrWyXRW2i7F3KTdVeWZRpkpZ3WdtKkRDzXTkVFc\n", + "Vp9NJBVhtmma7c/nQ01Oq9snopHCRA875iO+R9ZOJ9SDidSRkU2JdaWJ6ETUsuTYoQ2ZqahStygV\n", + "DW2bWJI458GpB2BTW88wHpkEmroOMZK4ZtkrLlnUNmksGhSXVaM7TB9aPOxII8PTcdlmwRORG9ew\n", + "j8tcWZhH06yf452n5bcLIxau8Pk/d8qC/600JHPS43Ha5xgdUL0WYxyF0PoA13+US8n863l3yP1/\n", + "tMfrL3HtXTxkrgb/HOdGJv+SNz4UNRuVTJCWQVlGJ9mSonpDml6x8/yzTDZU/ZvGZ85KK/Lhimp2\n", + "32Rp2dJgKq9OOFuqOdaNC3ohOaUce2baGp604YEjYzOVDkqlsS1tXZsmptiKQ2th5ERNlOhg36ot\n", + "ly24KzNzVuqMKDF1aOAVm15VaKoUHjezikpNoumuiRUxZHKJRJDZJNxWJDcUcdfabKZdremvZxpZ\n", + "YVbeV4+p5n7qjon2eqJ7fWbx1TuqMHNQ65BN9GqHiv9rn088YHqa6nvjUWRWvM3xUfzCo17Eb4Ov\n", + "6kb+wJARWFMtfNTRx5YdDesUK4wj1tW+/57HXqPeZvcs9chSjS9vnzFpXNWsLVoq5r4d3ex1J6Hr\n", + "/ZH1Dv1VLnyW6RovX+fO1lx/8skNzoV5DWLPvMXzDrxuakXNVYnU2MDYVEOhUI9N4/7E/lKqUdVI\n", + "k/n5x7HMMVZERD0TWwq90ymZROJVlcbpWSBV6ZlnLyzKbJvEHuFZmZpcJZ4OKyTu6oWgGftaWeZK\n", + "7yV3046LoenCSa6qMln1BW9875Fbn6J8JoRwwlOXg6YNh2trGgdQsz5Ora2ytftzvJByPOLmb3W7\n", + "/g3UWF+aF2l+E5bmD+1vZr9+W5KRlE7rTb4Vn+ddLfXHF9SLYyvZoeT6noffddnin2owAAAgAElE\n", + "QVSkGnm9ESXnD8yyQr2cyZMgxNROlsqLQqxm8iqVe6BKNlXJdfkkKpOSohTCF8WkRAcjdFXWtPUN\n", + "LZq4qtKVeiBI1eZdQGOVmyrnJDasCaamcuvuO7FsqqXvWM2eFaVMaWBqU89EYlSVapEsYTHMu44N\n", + "lVRHGWmHiSoZqddyo+4a/bsmi0c6B6y+OTo6+I3+4QJZk6PrPPcmEVlWzD/j/Brb5/wu47a/E0II\n", + "C2z+BZ48x+aU44xXByGEj/H8j/Ej938jDny7w8/9+X13/vav8GM3ubpM3CZs86kZP8vrl1LnxzsW\n", + "k6ZZu3CcNmwn+2qz3Kx2Xr1b6NUzRbchLqwp0xdZPrZUjYRyaJxXeo1SqKbqyZ5L+maifRN76tqu\n", + "WpIJLliML9gPY5Wa6SmtvKBmU+bE0EnInNNRmupp6GlpaEkcmuk7o7Dg2FShp2WkZcU1PQv6ujiW\n", + "OaupkMvURKWaSk9HYWJBYaZZlcp4RxoSzbDn7HjXINQkgdXhzGF6xuigqd2bmXUKh7OxJ3514Cd2\n", + "XndzI7O9VugljP/Ktzqf4vcTQhDM9SJ//VGv5bfBx/BX8N8/6oX8XiKn02Zydm6ZCoY0U/V20O5H\n", + "T71Er820xrl+zae/56rjg7bDxSBLZ8Zpw6oz9nSNTqdqOjW2n6S5RNIhfoDrCdtTejWGCRtx7sz9\n", + "onldIjeWa0pl+l/71kbCgb31ZVvjmQuGhnFLERqCXOqewo7KgNPpuw3BxLaRpwx1VdYFawq5eRT6\n", + "sdQtEy21sIREIqqcYKhmQYwTJyYuiM5Uha3azGpad/6kIQtR0De6PLDebjl4/4ccju5Su+14M3dc\n", + "tmW/iUgE4hP0b7M9+Sb8v3rc3OJDZ+YB9F/Dw/nD/jezX78tycgxL93hh84wmJAfaj6zoT4eClVN\n", + "+6QwWOqobS6Y7Pc5eZfq6FO2zr8hLLOcpPJ20CqnHiQt+8WSB8k5kpkYD1TlF5X1VXpDy2FDaSCm\n", + "A3lSmoQzhqEtOLIoqDQcnHqpB2csuGrdocIb6o6smhfiUgV6MnVNNZftGyvdMbCMBU2Zyh01x0ob\n", + "porAYsKyuQQmMVfH7CnNVKfWObla6Jt1hqrixDjfd/HGXBwG43Sef1feCWHxo1z6QfbeN7fNH92j\n", + "sTX/vScd6q9Ti/6tj6mVH+SDG7znTRbzF1f52f+IZ+7+BhFh7gvwxCp3zu7xd/eceutzEGM8hBDC\n", + "Ty969bme1bV9y81MczRxococZblB1jActIxe6olXGoxfE5a2rOeZzqyjMR5rVgf2FuryakUttmUm\n", + "WvZ0wkjpGZVcIpwq47vW9GwKLuqoy0wEQ12HooG6LR3nnNjQt29BU2Vgx5Gupr7MxEDdqoaaYOS2\n", + "qcc9dB6fFt3Wt6wpkZoIKrmgYWTZyL1TypnGi5aKun428Eb7rpXuwNMhd5LX7PUXXD6YGjQre3l0\n", + "tsfKIXnF0zuFSUr56e8Qkd8VT5oT9ber0+mv4j1h7r7V/11f/fsEB3z5Lj926U3eGKj2VKKN0+cW\n", + "BhhQhNxs6QxbbcfpofH5mUaWaFUtqdROKA0jzUh1hmlCL+MdQ56s+FzK3UBSpx1ZjvPp1tVAS6Fr\n", + "bE3lgspYsCN1aGoUS0V9qkxn3itXmiqwY82hHaVDVyxbtS4VVDK5V9y0qO2uji0TuQMXTJw/FbSe\n", + "l8tPRxkK2Wn+e0PPKBRWY3ReKc0alseFEHoWqq6sFxRThvUrVl6ttLN3Odz9ILOfdvjOW+7NKhtf\n", + "q3gOHS8s6e1FyvgNzCYhhJDg8TXeFdDjzguUDc5cZ29M/gXO3eVl3+TN6bclGRnywufmI4qXVoiV\n", + "RnpH0Txv6XZTNin0zqxrdLeM1mqKO1j9sGqnZ6uzZ5BWsmRZETYVZUeZrkhCJepx/ARbn2fjrno7\n", + "FUYLqmZHnmxIRYumCiOVbT11Q4tSh3Jn1JSWBKm26IqRTKrSkbsnMfSEZan9UyvgdTMXcVPTq5bV\n", + "wZFDUwPBYphLpZaVp13JeYlxS1cMZ6VxbC3ueFjl0smuWrhv+mJhNOCVTWYJr9V445N1+Z/PLX/v\n", + "2JOvF+KLHH6Yh49RJVRDDkasP2SrgX9Lzcjie3j2637H1cO5v0DxDQ7qFkI9xiqa30R8Pe5sa2Qd\n", + "l4/XrQ5yndlEme+rrVZeHq4Yf/YMW29wfI8nj+TtMwq5cX5iVjtSJFFDZjG9YFblinAiDUOZE2e8\n", + "6lbcFUND6kTN2AV1LewY2hSU6g6VXtVSyj0usYjSnouGbmgZK1QGpipjiQ25uvbpCO+is7b1DZ24\n", + "IppIbJsaKm3LtCw6J5cYy8x0DJNd9bCoFhiVqXFy1uHSbXtVKSsTYX/bw6dLq7VSnk/sd/jcR7j8\n", + "AlsLfLFL92s20Kdts8KceXYwPh0N/HbHD+MX3q6BdDEahOAF8+mJn3vU6/m9wowvvcj7Ey5fobvL\n", + "xRvy61viCVsXuHL0G8XcL58bm3yuy/c9q3wpN0m3NM4Qqz2xnqnH1BezUrtR2kd6MtdsVnXuNbhU\n", + "0U0Yj/8/8u40SJL0vu/758nMOru6+u65Z3Z29t7FLi4SIAmKFCmCpCRashy2LPnQZeuN71CEQmFL\n", + "Yb2xHWFLtiJkyxFSSJYUDoUcoiRSJkUFRRAgBJA4Fwtg753ZuXt6+u6q6joz8/GLrAUXy6WxBEEu\n", + "QPwi+sV0ZVQ/U5mV+X/+x/dXuU48lFGkHMx7SI4U8jm8vS0zizUdQxdr971Slq5g06Fcw0AqN7Cr\n", + "0LVhxYbERDYv4x66pGbZRBDsyQyct+3m3H8qOKe0L9ESpQotdQfG9jDWKWu21ZUK9XYujKJ0xpUv\n", + "c+PMKbW8yWhs3G4za1C81+zZu156Zsdsdd1SUhpkNTfGjxu8+ms0yrdxYw8hhC7/1uN86CEGgfga\n", + "H3iBV3+R8QJPlEwO+dgJn3qn473flcFIjHEQQvg7H+eDHX5gqHaY27yXmnROmTYTMdszy+6Kkye5\n", + "dlv2viXNEMSlVD15SN9lMe4JyQUx1k3DnrxYFidXeGXM/mesLPe0snPuP3BeXgyV2dg0TCWGc/eQ\n", + "TR0zuQWFYu7GGFXdBitadp0YWrBsYkNDVXfMNdXl9t1zWapuwarM2IrCqtxVd+SekM5x4EFLISjt\n", + "YmjgglfdsaFXdqTbJ06/smVpL7fzHJ//F7z2KMWUfv8Kf2hN6yMLWocnbjz6ujTfc+aTvPj7uHue\n", + "Ux+ntsOvLHPvn7zTh1QI4Ryr30fzLKM7HP7aG6+Qvk3PSbLH9hJPvSngKFW7lvi2fiBVs+vafzSx\n", + "9uDUo0XPySJHa4WFgsuzVL/xGXd/qmtUtIkNsivSGC0mhcWwqiEYlDdNQqoZx8o400xaauWyLDkx\n", + "wYIFY7QqhwhHmtYkSoduyxRSM4uCRYUD+4JFYy2sOzFy4s78GjhSIrpoJjcyU9OzKNi1qKmni0UN\n", + "I8G+6MCiHZsKh845NpHpS7R1Q9M0nRqVK1butmTxnnR3anVp4PBc0C0a6nejK5+m8wJf+n6++F4G\n", + "v8j05yoX6+wKGz/O5TP0l0gzVg8Y5SEsfZbeL32XO/f+GP7Ru72Ib6A3+kZ+zwQjMcZxCOHvfYIP\n", + "tTT+fGFzqe/hl1ka8JUPs73OxdfZwfV7hfE/eY1HNli/IH9+x+D7dmSLM4vjhs5spFsPejhKWa3T\n", + "LVlv0Emr6ZtO4Jk+n6nxckF/uZq0SZDO76tN0WsK0xCdEu2JVsMbThlxPl9TU9dwhHvaSGXqZk5s\n", + "OS/qaAhGVjS0zdwyNbEqOLAkaImWpV4XdRWmxvE2dmTWFBaNi1IIR4owNMurQkljlfFOpuz23Vw5\n", + "7/DqpzSfONDayExmdYMvnvhyoy78gQVlGbn+KRZuV87c/bc5BZce4ns/+ibj0gfZK3n48/zdff7x\n", + "b4Uv8oa+K4MRqoAEnwgh/ArFX6L71Ff1Ojccn2uaLmxKe48oP3Gs9tBYPT1QnDu0kmVqsS46MRVN\n", + "y2gcZpJ8JCnq8mK3Kj5OM6PxuvKRsSQcatUalrTmcfGOvq4DmxbdM9YytiQ31DGZNyOVStFMsG3T\n", + "WGrBWKqUqkmtKtyXa1mx6JyJPQe2nVY6bd89fQ1MncxzLU3RRLSFk7Kv7PUtPscjr3LhNvUpP9vl\n", + "zI+TrjF6/RQf+Qjj+1qDhvZJF00ni19w/xzNr5RefGTilX7kBQ4/HWO8/U4++xDSh3jsT/O+Met9\n", + "dp/k2fdVLJ3+i7z2MI+/KcC4t8jRqxxNWDnPg3tMM17Y4MaXvAkTX71/OM3S97D+h3h0BUM2x8HR\n", + "atTKUr2woL1f6NSi+tKGUadFfkirQZGqFSO5qVboaGs7qM0clCPdpFnxW5IqOXqg4YEwtmVZ7qxJ\n", + "HBqGE2tmHpLYVtc1dG0+EdNQuB2PDEPuIVX2cl+qJnFeW2aorzQyVTp26AFjucxQKaj6jY7nnNaJ\n", + "jq7cjgNHMoUFhdMecjT3I1qY7qo3Sv31sfpoxXTtrJP9Q4oDaRxoXS88/mlufYgP4vkNWk9z9b0h\n", + "hI/z+If4gUMGU+4/VjXypS9y7mW+8BG+0MQ//21/Gb8DFYIafgh/7t1eyzfQx/A33+1FfCsVQrjM\n", + "2gcm4pMT58f8xKd+vXz76D/nH7+H//cTuK7iRxUhhL/4K/z3K7xnbDKdOi4KSwohNBxOS9vjYLA0\n", + "08qqcd57IbEZoxiifsFOncYxOyd0Fyru4yjlchKMRbexpHBPqYlF3AhvjAJXY8G5higotNWMTXWl\n", + "gqhhqK3GnKt8go5MTa4naEpV/tw0ZM7KHCk8r69Qxsuo2deT1IKV8rRmmJmsDLxSn3r1TFO7MzQ4\n", + "s6y3dV3nqZaneg2d0Y7+ubFXLj1lf/u0uJfS3eeh15iVvwk/apGHr1TUuK8FHHMo2ug1HjuM8Tdk\n", + "U96JvmuDkTdplVaXzunSlfxYtnPs2XLBq+NFcW+Ln0ylzV3dMvfEYcd2O+rUDh0lE/n4eUn9vDIM\n", + "xWyHjXt8aIDc8WjTQudYN/S0Qlcpyg2kps5oed3AoUx1RkszqUOpDTmODY0kmvpalgTRSFBaUhqp\n", + "qQoDLU0VDnjBzLJjO3KJaF/pptSyXF1wJNiKUX/cdLgz9sxtLo+onWdwji/VWLnPjwxY2+X5xxp+\n", + "+fd1nPzCrmke5WmQFU3jzmmHl87aeDkzO8z0Jl9l7f47bFKqzNjO/hQ/fFD1fMDaiM5SFYzs/2s+\n", + "fYneBU6dcNji+cj238ceH/8Qzz5DOWHvnzF79s1ReLWbf+RP82hg6z1cSYPnHliwNWxYSFnpF/qr\n", + "idvrifvxacnolHpMTAeBc20zxw6TxFJaAfWLMppasBPGMqVWeWIYZrZDZixYMjTQFgSHYVGp7zhy\n", + "PUR9qX2UplbiLeJYDJWv756qHPuA0lWZhqZFC5b0TJRW5Pq2Neatbj25ukxUWtC2qJDItSQeiMGr\n", + "MmfCgo6evlJZpmplQzOe6DcGRo2nnbrfkR4vSxub8uyaq4/tGbSrUcj1nZrDs+f0H13Rah5r/uie\n", + "6es9zY/zynt53zHLY165Qnm1QnDf/kAI4eMxxqNv2bfxO0cfxrUY7b7bC/kG+jweCsHa3DTlO1oh\n", + "dH6Q9/5BnhjQe4Kwxq82+b5PszCjWfLkITcO49c/FCf7Nm/t6zycqA0f0ws7DpoLmsdtraulxfqu\n", + "xWdmTmWUddqxdBfHeWZSFu6lUdqmWOHMiKSgvkp7nq/YVmUh3q9y6q1K4lS+24lFUd3MLQsOnVZz\n", + "3y09qxoayEU9QZTqGiIVnChNTS2rWdN028hEPncuoxTCY2I8Ky0ODbMN7XDXfjq2Gtvuxa48Hyof\n", + "WHd46xHlLw9l33NXc3OofG0opAeS8Snp6rLkfU8qn+uwWw0au/hZ/kII4S+/dYKupHg7KFr+DaBo\n", + "30jvajASQvjf8AE8G2P8r9+dVXR/mEceYXNCbNFr8OTnrjtOeu4+1FGu9KXtvpUYzGol+W2jWmLD\n", + "zHKz5SCwU55RhMcqrF9jTP8GjZsmaV8SatpJX2FBW12m4YYldQ3RaYUD0TV0RYU920pTLas6atYd\n", + "GNhUAeZJFKJ9Y6XN+QBYKZfryRxbVLhk5ljulpq7WBBNlXpl02M7Uy+16LXojQg1bm/QP81DL3LU\n", + "Jr7Exb1oJd+SP7Jp+PKW3fdlusNMf7MrnbSc1M6bPHuJmykXf6Xywfi1d/CBL7O8wuk7X//r88dU\n", + "pNcQwv/O3tN0L3Kyy8lzbzSkqnZ6H3u7N66aqs7+EX7wpOHu+1Nhs84ksVgvvdYqXJgm1selYai7\n", + "np1yMonqzbFsoYW+PF0Xy4ljI2XJOBmapQOnputGWWbPzDjkDp04MbAu2lLT01DqCgpR0A5RX5Rq\n", + "ObSJjkUTRXnTfrZnrOKznEi8hEKqq9DW1FB3z9CJYj76t+SehzUlEi3BVNtEYizYlyq1wkRqZmLR\n", + "ssKqVx2ky0bNEzEcKrLT0rIuqZPWo2HSVIuLxiv7Ot3o0jYvvnfVqHjS6ZczablndOGsovZl/+YD\n", + "fa0lVuZ1+DaGC7QnrJWq6b3vxmDkx/CL7/YivpFiNA3Bp/D78dPv9np+OwohLPHIR/mJW1Wz9Us5\n", + "61OaS7x0iQ9erY6c8aaHYrUBOv3HufAYTx2U2jtHPv5YTW297XzMTOq7djcKG6Fy8K2rMhqzSD8r\n", + "XU4bTh2Pjfs0ejTOpo5j0JpF+wo7abW5KHCoyoIc4dGYuhYadkVNpZHotrrUsZa63MxVhcxM7sRM\n", + "fd4r1lDaMdGTa1q140TLRJz7cJ9TM1JYEh1KwhnSdWVMHKMM9xyHnoVYuNxtaY8Pjc8+7/YjZ+S9\n", + "NQuTe+6fPtD6cnDwyMTyhS2NxtjBlQ85ubrM5Ar7N3j0uCJtf12m44SXX+FHHyFtzqFoE9JXqfd4\n", + "8Zs9v+9aMBJCeD8WYoy/L4Twt0IIH4wxfuF3fyXtP8KlBS7uVjfbIuHOxejS1oGdpYFH5K7EoC03\n", + "a+SOw9SlsKQ9Te3VuprjfZPsgoNRVtlEju/Q2NFsj1xM67qi5fm0wz1Htl2Q2NSwrLSh5ozC86bI\n", + "lM5YEAwxMUDTdaljrFpWOrFrYN+qxCP6JugZy80k6h4yUcOm6CVTixIrSmVEHr18qmPlpK4RJ75w\n", + "paPI2pq1E/VwYOf01Pu32f4ewmePrNy7bf8DR7LJ1GApGtSDcT2RXL+g94UL4i24zMFXeNo7C0am\n", + "TANFIH1TXXH2NWZZjPFk/l7v5P3erGVWV1LjhdNie6g4mjlpdXWHdWXWcyuZuJc23Ms3FbM63aHO\n", + "rG6YJZa6i4rJVf1W3cxEXh5Jp1tW0pmHi5uuxWV7tZZRed8snXhK4glNEw1jB16yYddZUV9haCTD\n", + "mpqFqh8oNBTpeV0T0XBeNktdxKtyU9EMHanTFu3pua6hdFlNV91UcNVEc46+u6+t74qaKBNF1wyM\n", + "bejE4IItJ2nfNO/YSRZloVQs9s3aheOYa8S6jWnULqlraqWpKye7dlbP6O4lTDuy2Zr+al99xGGz\n", + "mrIaB8os88rDwdWzM5ZDCLd/p/2Jvg31Ufx37/Yi3qHe6Bv5jg5GcIFLqp6N3Q+QrXNwjvKE7Rmu\n", + "Vtfp1dzXP0BPs3aO1mJF1A62Pbi94JV1inZidPaE2lSR8UyZGE0jCReT6DCJGjkHC9THNHLKIjhu\n", + "FpUDe8pFledcQ/Vs3laVacahqyW1L9EXJcYeNlZYlGpbd2RL3SA2zcJ1uQsKpT19wTWZzAPaLpma\n", + "ec11q7ZclppIRJmzclvycE0RzkniKSGsSV2TKTwaV8WYC1mpE4ayx7fdmJwzvRvkQ4rN6HsGNbdj\n", + "x2w6cTr9Na88+GN6L09I2xWJovvWkxBj3GqH8Av/gp94qErsx2skN/jYOy3Vv53ezczIh/z6zuKX\n", + "VIja39VgJISwwsVlWie/nnVKy8qI6ZNPlC4s171vNwinWUqj/bSwWCutFrsMliS1ic6LLc3TNFtj\n", + "497rbNynO7UWVi3KRDMThxhbx20NLYuGUqnrckc69pVaSh0TEy0jlxy4o+LFfMCRQzsOhLm3TW4g\n", + "es0MIxOVm0nb1FD1hairSIGHgn6x4ELJfpZaG04d1lJHlx4SWwuSek2zNxHrXTtrr3t9JffwIdee\n", + "HmmfuSq7csnqpKUW90zTA43pE3rPXpwHInBUbZPPXAjhryAd8KUjPhFj/A2GVjHGkxDWvspXnuR9\n", + "b5qO+fLZb8EpnTHVcPBAV6NX153teP2xnla9U43gzrjfPKM1mNG6J2+dlbcOqgbf2FLPd7SmL5sl\n", + "E+l4LDmh003k05nzzQNtdc/VKjDZZdFMS1TTNvaQa/ZcsmjdwC2zeafO2hwdP1QahlTXkqmJiVQi\n", + "N1S4qG+i5q5UriaIrtrQ11bt0fa0LGobiu7YUNhQOG3Rka6ZKHdO5shd1ywGlgVTXffDkmI2NEyD\n", + "rJaplx0L43uShbsGNW712VsqJaOGzcGBvdVNk37LyVYprde0IyvXefEpzi0GW6Nzbn3/aSeLHft3\n", + "Tvj3rvJYCOGnv1uAaCFYUZGvPv2Njv020cfw59/tRXyzmk9zQc6oyd4zPDCmdZujgt2LHD3Ox17j\n", + "RoP7nyN5eE6OPkFaZSuy+MZ9vvSBrb5Jc+DwoaiRMK6xmXPQLO0kFS97mhAkdtOgM+XxXWYx8clT\n", + "tGNqkObOCmaCqDRToRR6uPE144imnjXRTpU1lWkopE6kas4JrodNqTuC1yzIbItmShclFtxzNKdu\n", + "Lzs7d6hJLEjM9B1asOBliw603bCnZeLAcmxaKvv204mQJspaYrUc6DtRWx06rnPmZc7sH7kd1+Tl\n", + "ks7o2On2Tb2lu6TTirZ6+HbnZBjjp0IIr17jSiRMKyja2w4SvFO9m8HIsmpWimpe/Ml3YQ3t6oK+\n", + "9mBVD6/Pd3eHdXpLPLwztne6615eUqc7y6UJ4xnJ1amFWTQ6G6Ure8rmjI3T1chB0tSRq5J1qVxT\n", + "4VBDw9jQ0H1TPamhMzZtqCuNjN23Yyabc/cSVZTdVTjjwDK2dOxYNXLoSOWnsGBqilLUK4P3J1VJ\n", + "p4sj0QtpcBBbpsXQShLFomPcWHeuqGbsB/WO2iwzyXa8dP7Ie+5z8nDd8QMNT9w9tDg6MM0KmZHR\n", + "xk3XnhnYeaXDdET6BX7gaW58L9dT4su87zM8FEL4W2/Pqjj4l/zqCncvsh7ZCdy68Vs5cSGEJuKb\n", + "p3dijP0QNl4rrX6YzXHb0mDR/d2J1840qNXlCmaF5nBPCAdanab6nNmRjO4aZNdsxBPh9ar6kO/V\n", + "7TzctNCb2Ns4Y6e7IIQ7FmJNEoYmgppSgpZ8DhpsKbA27/XYVkdQmBnJJapelKGpmeBBiQH2RYWB\n", + "ly3Ys6lUU0gEy5qO5Pa1NE0FE4m23IkFQxxZnfvejHS0nDK0EDqGcWyWDMWiJ00u6CR1ab1nPH5d\n", + "uz7wVI8Hv0z/VO7m6SN3aismR7nd1oNGn9g3Wj/UeobulP1bfGV50+jsY2J/w/jZK4qXE4qP8d5f\n", + "q9KzX/2tnMPvYP1+fDpG43d7Ie9QX8FaCM7H6M43PPrbRJWR6dqP88ATiBy9zLVNrjRozzc6y1sV\n", + "abzV49kVHj+oJk6PH+XVSQjhH2Cb7UjR5kaNjWPuPkDrTLRXY3uRWZ76aj2VZ9FFhbNllBXczKL7\n", + "ceJUUZWGduulo5R7WdAMmeVYZQsbSofVMuUyC+oWdEQtK6JbruDAtnuac/LTWK5uJI9jzVDXkDs/\n", + "t/XYsWRNLreqUBPsGghKQS44MTKQ6kq1NLUVzoZty0ZuqOuUheOsKcRFWayLhkoH8uS+WXNkZUL/\n", + "LNvTgdZLN00e2DRbmmpmz7Lc5OXd6vt8821PDmKMO6qRpW+J3s1g5Nivp4Detu4cQvirb/rnJ2KM\n", + "n/gWr+GA6S5hxCcfrUA2k8DejHi15ublc1rZmsVRJgk9+4u3HSd9D41YzoPR5RELdNIddxuXSHJC\n", + "F9tGWjpzQHdNZqrpdWcNXdKwVvnG2JM7kDuWSbT0bUptKw1k2nJdwY7o+jwCX1S6ouem1FkTLaUs\n", + "VmWPAqMkVt40MToJVRvUcszshEQrTUxCqr9fo5syphXHBrXM0WhDntfdXeWzm6mvbjTko65nDsKb\n", + "epWGDps7Fk59koc36D/P+irHP8SX3jjqGbYGlfPUU6oGuq/TfLT6b1c7Gkuq6PsO/s43OmEhhDXW\n", + "f5IHH63+vf4S+78QY5xH8Hs/O1V8aNfh06laseLu+Q15L9PKZmrLQa14Sb62Y3G4ZHG650Kybzdt\n", + "i8XEymRm0qFc4XgSTN/HqXHf0aUld2rrZjE1icFJUjMrGySlqXQeXGSmaOgZ4JyRY8HEprogNcOO\n", + "PQOrCj2lS4KG4NgC1gzsO3HG2GOamhr6RvaNNMz0Ravz+nHuVkzshcTUqbm5+J6ZNQ/GqSzcnYPt\n", + "cucMTGsdZ8Z3zdKJo3pPrX7i0oiHtsk7nH2x1Dzs+dhT6+68ciwef44f7dGYGP0cX/5p1U3nylP8\n", + "ye/lev1NNflHObxW9X59twQjH/Xti4D/DYpRGYKPq0o1/+DdXs87UQihzbk/yw+0ePRO9ZB/8WE+\n", + "0eSrNYarFWTxfkL5KqebJAv84TfRQh/o8nP/PsMbrC3TXuQrm1WPyQbKGnkkLRcM2+t2amMPhJq6\n", + "ib30UCvmukqHSYUR+MIZDpd4KA2aofR6jEah4UGlVHXMACN1TW1TywqJzEjLsm2bVvXteMiitpqB\n", + "4Mg49LQdCHNbj0SwKxiKCiMzuw7NRAdGuqa6cnU1XQ2vm8WRehgblCPNWWkzTGzVVnRjaaMcm4bC\n", + "qCyMysSJ2x67S7jK4SNc+jTv3z+yvz50/XsTd891+cqEf3VclV1+1xg672Yw8msqi+t/ovqS/F9v\n", + "PSDG+Fd/JxdQ+Z0sfJzNn+SJf1ONi5YL1QRHcbmhtTHRDfdMi65gyerOBfeXXnFnr7C4uijpFuwN\n", + "HS01pMWuEFJlWBS17JlZlGoaSc2MrNj1FI4VdhSCpjWZHUcaHjCQWFA38zqSicQAACAASURBVLrm\n", + "fI68crFZUjqlsC2qGVpAW0PTioZUEk7mfSZVH8K+hFDYk2poCKFjGjIxLtqblcrxmMaMUAoxmMY1\n", + "5f5MvSiI3LjecXfcdf6R0jRNNd6Ufs8mE3Hrc/w/GLe5/D089dbW6rOcLFcGSb8hGJl/9tFbou4Q\n", + "fkODtre83ubcn+MjdR6Z7/BeucKn/lwI4f+IMY4qPkb4SyOHf2GZHzpPL3d6faKbTtQGwdJsSa+5\n", + "J1nvGExGToydTnP9+sRRe8FS0qI2kHZLZwOThQWN4arDWt1JqOm1l+zoeT1puKyvclfOXbViEIfG\n", + "4VhDqmlJrqftrqiDmam+0oKeBZmenqFSKXPiSGbborFH0DIxMRXULGm54cShEwOliZqGO2FTtGxi\n", + "JpEZq2lLhVAo4/K8mXZkuRhYSjPTWlPXus5sqlcWloqR6+eoLdFrMikL2Ut74tEF1i5xs8ONbZY+\n", + "z0/d528h1pjU39IxH6onRfLW8/V7WD+m+jy+k/RG38h3RDBC7UmeXOKJN/UgPH2vYhv1T8jvMM64\n", + "eFT9/Nyf4OJbeszO9Vj9Hk5f4ief49qMr/wIxVrlWxNmtNNgpXPGVlaQp1YliqSlWc6cJEeaJRcj\n", + "X+zQWuD7c8qy0Iwsplwz0VM1pNfwgooUtVE27SbLMqVC0JKYOtSf01Qrh7HgwLrCyF0tmZa7TtSc\n", + "aNh1IFGz7NB51NXta9vVmt8JSvcURjoy9dhUy3M1Y620Lo4yW+lUbRok6UQ+quuNNpzq7VkekW3x\n", + "xWUupqyiczhVfpXjnxvz99/MD6o2gM6azyl3eSQhOeIVvP6tCljeUTASQnh8vpjPzvkcb/z+J2KM\n", + "35SleIzxSyGEcQjhk/jSu9O8CsNP8qU+t3+IdJHBHumHeepMR4hN7XGpaBy6t5B5LSxJbnSEGwOv\n", + "PpaaTVeNh0GYji12ZuppXUPPgTNGDlxzx+Kc/7DnCVNLMgvG9mT6poKG0tRw7sxa85KHTJ3VNjZx\n", + "IHcO9xTzkeB7juwZmFoX53tiWnMzvCN9wZYUCyaaeqa2JQ405dM1iyGVlS9JJvuG2brsMDVwZLJy\n", + "Q6gdy77C9X9U8mDTwX9x4nar6YGTRBZnZtnQbpODj8cYfxVqIejxvrd+qj2ao99kTv2bV+1Jnlzk\n", + "8TfdoJ64z9ZTHff+wsUQzCqf8F855n9MmQ1kf6jQKRrW79XMOgWLmZCmFgpmVtwfbXs1nSjqa66o\n", + "yYqBo05ptTbTCrnGNNMczTSbmSyWjoon9NPXfSXedyfMNE0MZKIDp0KppSaJY1dDV92KrqGg75YV\n", + "0RPqrhorHBhrCVoGtq3ouWzd1H2ZQq6Y58UYzJF1TevxtFpo23fKWENXkOso7Jipq8W+aZipW8Sh\n", + "qVynjEIY2K6taw3HptnELK0rsqZJLerXZ5rdE5375PXzkuMfUP7sDcmVu9ofiGrphtHCjvx+lP/L\n", + "14nPVAZFXwtIrrKyN7ck/72uEFxRNXJ9p2WBPoa/HILw7UqM/Xp1z7P5NiXei3f55VOVgedTt6s4\n", + "+Nnz3B3ykbchMCfnOPvVxJf+ZKp+utRcKzyeVg3zd3NOJ3VjLQtGekk0K2gnjLQ0p0c6SWW3sjCt\n", + "gpJTh2wtM27Msyt4VpXYj6okb8eMZKqUy6SqTeKCUk9fQ6LuQFBI5+MGG1jDOZktQy8oDJxyycCS\n", + "TW20HLqk7lXRkVP23XPWmqZWuKMRE5sx15qkerNoIyzbSXjhpJCNGrpF16mje05ala9gL7D91/nX\n", + "G/zqk5RTjn6FwSffCERCZRT20cf4wYu4xaXA+Qd5dpGja/zgq3w+hPAz34oG9m8YjIQQ/kv8ZyrG\n", + "/N8LIfxXMcafmb/8P+GbCkbg3Rvn/TqtUltmdo+9V1n5CR4/xeX+yAtx5ng5KmMmnZxIdxe1jwvN\n", + "TmHxpG036QiTu6ZLhUvJnl7SENSdcuTAwJFgT+7YY0q5IJo6J1gTXDcy1JVoGaupu+68gStoy2Si\n", + "ukLPVNfAvlRi25LR3IvmSEXnri72umMLDkQLzuqISqldZ9yNp0xmB+qDE8V4olgsFPGuLN9ylLXM\n", + "8rbO/j2to9zGDW79232zf7Vt9OUlr31wYHet0Al9g3Tq+NP0vgZRynnlFcYXWTo/94rYo/08YVCZ\n", + "OHwLtXiWjbfU6XfXFuVPP6x+/aMmn9uj+0X+1Iv80x6/0FP+/q76OMiKTNor9BuHRllicXKon51z\n", + "HD6iv/W87rlMnqVOkpY8luqhLiSHyuZU2RladeRWY00i08gfNk4XbNkXdGy6aV3ustSiqe2Quq1U\n", + "CoYaUut6LknsiwaaFnS0bMsFiaFTGlrzse2h0vn5Xmo2hySlkjkAKc6nsKLUwFg9zgg1hb5BHDhy\n", + "3uk8VS+WxdrAbpgxTp2E1+3Xp04rTGuJ18KK7mxFa5JZPLzt/uqJyfGitcXn7X946PSphrXDIC1W\n", + "9GJN/kendq/dMvr5n+OnHmPaIL/BwsvVjOXz39pz/W2rH/NtjID//9FV1dPyEdWO9ttcJzsc/YZN\n", + "DnsdDj/DLzb4wnlCweBz5M9z84mqh+QNHbQ4jJx+smX11ILufs/9hcK0yXZSYQ2CQlIWMgsWDWyH\n", + "0uU8lcVcmdAP3J2oRv0b7EQOBvSbvtYj8sbIe6l6pN5TSuJIEu7ILcrlDkxVZKElpUcNlX6d1lio\n", + "Ws4X5x1lU7lX7FrRkci01OQGFtFVzl3Za0Z2TZwpK95RGYK9LLM+mjjtwChesj9s627n9s737T6y\n", + "LYncuc/4l8h/Oca9OPeZiTHGGEI4ux7CD7Z4YJXaKc7/O3xpm27O2jPs3+XyQ/zrR6rR0+/5bBWY\n", + "v/bbPePvJDPy5/GBeZ3/Afx0COGBGOPf+O3+8d8NVUjw5jMsP8asx/4XY4zX569d5sqf4j2B5SGv\n", + "fYidU5Qdrq/0dRc7VmNqauQon9k5F/VOpRrTrn56S697YLE7tpKVlmp9dVcdx4ax0lI4MDNU1xAs\n", + "G9sycSw6i0S0LHfHrtKaxDVdOxaMLUlMTeTq1iX2TSzK7Nlycc5hHcgduqNf/S30dRwq1eReks8d\n", + "XZeM4mVlzDX3OprHpdCL9h49K721IpmN5Oe3tU6uufjc1EJJ9ywbK03X3s/+ZNfxZwrDmMvGpckv\n", + "Uv7SW5pGT0IIf//n+eNnuJBUrrmjLf7vGOM7AqG9c53scNB8829abj+1bDI7a7rVpDjP8RKj/QpG\n", + "8L/e4OUz7j+8pN4iK3flo0PN446b00vuPjdj+hJPN4xHhWmrY202Va+NHCeZRTXDZKi2kDszfcXt\n", + "cE6RnlaEUl1d6ZT2PAt1jF3R63KTOTe1La36eKyqEEivOK1mU6Gp4UTPNUGqoW3BzEzdiWpD2FcY\n", + "K+2goyYah6HSOTOpxJKgIw8TypFaqCtC1x2HphqWpxPD0DGLW8ZJbiMmurOZST1YD5Rx3/36WC0s\n", + "22ptGoxvapcTjfLAwtNL1l4Kcyz/iDDz8E3KHxm78z+/wO3bPJXRPKgebK99t0zSqIKRn/mGR32b\n", + "KUYxhK+Var4DgpHx8zz/o5xa4sIxZeALH+bmA/xQzizn9T53/2GM8V7FIPnMBU4ucnZQ8aJeSNn9\n", + "6dTpv9LywF6QyLSHXFuush/nC6YxdzrZ9XpyXqdYM5gderk2tZj3TOttjbzrVG/iMDtyM4tqC5yr\n", + "c6akl1QTxOdVFelCFZz0poxCblwbKsz0rKiwhAtyE1W9o1TVNkfMyaqFIKpJnJLaMkOYl3lqKujv\n", + "VB1Hc5rrknZx4Fac2U+CWt5Uz2fOjnOXDu+J7ZFf7l62M56o1Q50B23ntxNxoWf/DzJ8SUWoLSGE\n", + "cPER/tMPMj7L8Yv80IC1F9ibUj9HscTomNV91k6xs05c4c+cC2FrwvZ+VT35psZ730kwEt4ozcQY\n", + "b4QQfhj/NIRwydtQ2L6dVGWZzvwnPLNaXdAnZ3jh/SG0f5bR5zn7x/gDfc7M+fuDGmnC3lkem5Ye\n", + "3T9x1KkbNqLYHltMhxrDmjPT4MWFliztyxZyiqg+O3avvmQQzIG/U1116yYKW7aN8FU1W6aW5A7R\n", + "tOCi3CuOhTkKfmKsbiaf1xZzhR1H1k08jvtS+xouKgwMnahLdA0dmxh4QvCIMk6Mw0ui66INoT02\n", + "aQyM10f0Tklv0+rmuoMVMew4usQDQ9YnZ3y+e0ZZa1s7Gio/sufk87fM/oZqd3UxhJCpWOYnuMTi\n", + "g/dMP3vP5EiVr9yOMX7TJL7fXJPneeFHWN1kc0htltg/3XK796j4tRTtItM16rdY7Cn/Wk+60XZw\n", + "pdQKY0s7icODy3r17+VzmxXc54u/avpn2XpgolOraSZNR+HAyyHTKnKJqWGNNPS0wwVkFvTtWjKT\n", + "Mc9DDVzUNVOaODGQlC9Lk2VDOe5a1rKuIzVTmmkZuyh1W9/MeZlVdfdlrqqynm8YQ1wx8fnqZhcj\n", + "oRAMRAsaZoZGSuuUV+TFru3kpv3aqoXBTLOxpT6bOdsOLqW0Y2YUM/uxdCEm9qd1J/l52dFtndFt\n", + "R+GyUF+eByID49YtaR49fYs7G2jGGO96h06cv5cUglQ1SfOfv9tr+Sb1MfxR3wH9LvPer7/Hz/8x\n", + "1i8wOUU4yw//Sy7OJ2luLfOv/sMQwv86P/7/ZO8plh9kfED/OdSj1/+HvuJ8ol5GJwVHCR8uWQ9c\n", + "K6iHXU8Mp15Il80mwYGB43ruTJnJitLd5JLF+7ntRl/aJqSEuaHthmAvLvicqAgnupHNQHdaeC3L\n", + "3A9tdbklA6mOPZkqlVDZaVaByNOCRGEBhXKeEa38KaOJvlTDGKldUc+hmlgGC+PE/foZw+SCTiNT\n", + "rx0bNrYd1rZsDgaa09T0V/seefCUK/eCYKpoXLN5fiL8iRDC//LGvfoUP/79DB6Yj/MuUjzM4Rd4\n", + "avFNmY+MmJPdqJDdH/pA5RWxs89jz/G+NIR/WMT4Ww5430kwshNCeG+M8bn5RTIIIfxh/F0V6Orb\n", + "WJ0P8cEVPvCmSO38IYM/yLX7bCxz5k2vJXPWS1YSMswKa72RvMswa7o4TGzlZ7zSXlaGxNJsYL95\n", + "V1EEg/SiellXTztmcc9BOFIqLZqYeVlX1wNqSifG9hzYsGvRyHWloOnERGHkSBVrtwxdVT3x6zgt\n", + "8YLq8oxW9E3UHaoZ6ctsGTiviAtqYWqiLfOQqec04z2L9SNTmWRyxiyr23Rg5MTRUkcW143PHbr3\n", + "WuZ6clZvLZG2c/XFuuVwVv09R0Z/vWf5szxYq7rYb6l8Gh7p8uC0st5+JeHGz8Q4/p0aHxy13Xo9\n", + "9S/+g0S3Ww0zHyXf6+Rzi2+yui4IPVpL/PgyD03sjg5svD516R6tSekk3jLyCRaW6bys+cRQlj6q\n", + "n0Qvh6FaqPySp2XQno1drdENNJK+83FoJzD0sEzfzKHEguiMmaFjpdqcrzhOqpLMqjt2JZY1RPum\n", + "ehbNLMltaJrY0tM0dGZub9gwNVDaUP3H7qluUhcIO6KagMShiRNF0hfjpQoZWSwqZ6dNx3s6k6H0\n", + "Ku11noxRfTFoJdFyKGVl6aaoG0pJuGlnYer8Z3aEfGyntuN4nVAcap0c+f7PVTu+kxHfMeOsvxP6\n", + "IO7G+Lbu0N8J+hj+RgiSGH3bQ+pijHdCCH+T7TXW/wx/7BXOvsm47eIRFy+ydRHXY4xDfG7+I4TQ\n", + "Yf0vRudnpZXlXD2JkpiYzkrH5iymfXZKjrNj03Bs/y6n1oMzK01ZXhg0+vaW9pRynTSRlaWdQEgY\n", + "xbqWjmPn1UJQ07PjjiJpuN5sW4hshoGxwpEDS0itic7JDCUaSj0zPdEZFaHkWNXvNbbkjmh5ngcf\n", + "GbsucaS0YlaWVotjrzdXTZM2pqbpgo7T8jTYXzlxv1GI108sLXed33tjKrIunTRk7YnVh1fd+W8v\n", + "hDDu8dIKj1x8U9DRYGvKIx1im5O7JBdI+oRzHH2WD5wjOcsL6wzXGa7R7vNHQwh/7beaLX0nwch/\n", + "bM7XfdNFMgsh/Cn87d/KH/vd19J7ufIW74h2zoWUa6fmJNs3aeEqN9/LWq+6+d6rMWuR94J6vSZO\n", + "F/STy7rl0CAUYtJ0IVx0LxsYBDYNDGVGNvTjrnoYiTEYhdJjTiQKR/oyC7ruKuzo2dec+xdM4jah\n", + "odp2Hqse+RuqfudqDjrzqkImEazbcmBXI/ZshoaX5IQjjdmEtCvEmhCWtMqblsOhMydnvd5r6Zb7\n", + "9s8keqfeY9ZsaMRMTI/dv7DjOAseTFIrvUQyKxx2gnunGmpneGCbj36m+qxunOfLP8UTP8dD80bV\n", + "R2v8zB8JIVz9nfAr6fIHPsB7Pqz/8339xrRinLz/OR67zK++Ydz0RS71OP1jDB7jbiHee87OQ5+x\n", + "lx1q/CKjGwOSF1mh/X6+r8F05ZZXz66r1XOjOBREWVp3kG1Ii5GT0Pd4nHjGDf/GaXthV2lixVRT\n", + "00BLw8BIqW5qscikSdMgDB3Gh2ThQNSU6cvklo20pGZyLamOa67aM1WY2ZY7g1TiRGpk5nHBuiAR\n", + "PS8KohO5RTE+QOxp1UcWyiBJZ07sG0/3bdxmaZmddtAso/VYaIfSUhL0YmEp2TftDDVvlnZ73H62\n", + "J/1nPSt/mPdsVXbsJ3U+fY79n/kuKse8nT7qOwAB/5spRlsh2FFZNzz7bq/nnWg+qbEXwvlYNZG+\n", + "Va2oiiq+ThUCvvPf8N7vi9a3CuO1zEaMzhSFl+qEMYcDmtc5O6NT8MqUU4v8u7+W2v5g4XAtl9ZK\n", + "Md1ycyUKabSG1SmtwNXGkn5I5/iGoGNFGse+moysxMwVI/04q4ozIXXLvrZnzdyW6gjGanqGnjO1\n", + "rXr3qhlp6jFHXpV4RaFuqE1RI2Sy4rYkWbOXPiwmbZyWGSlct5NuaJctebaoKPfNhoc6ZzriXjZ/\n", + "jhfKLDdZWzNZ+T7uPcrBVT74RZ7e5/5GFRM5zfXrFaLh1CaTXW79PE+vc23I2g6XL/HlTb/uz7TO\n", + "cIW1O5wNIUzRnweJ31DfMBj5zeo/84vkU+/kj7x7KsfVJKK32NpPIva4v8+z72FlVjkynrnF53ZI\n", + "ltnP2BiwsEPzXvTl7y/8f+S9WZBk13nn9/vO3TJvrpWVtVdX9YLuxr4QBAGCBCmOFlIzpEayZcsT\n", + "1jjGYzvCoQe/zMh2zMOEH+wJT0yE7QdH2A7HaEIzYQU1kjhaxqJIUxJXkQAIEGgADXSj19qzMiv3\n", + "vPs9xw+3APaAICQSjWkQ+kfkS0VW5Il7qk5+5/v+S9fySa0xMTEzFL4FjvKxzBCNossSIRGh3EDj\n", + "YmHxGjMcctYQfFJSoDAJDolpoLXLSC3TYZmCjprxfSeZ8yjWUYxQTDFYCDllDphSIWJIlRltlrnC\n", + "KjEelu4zsmfMmRxfC0M9pD4x3NfxcPwh+5MZ+CmTjQfJ9TzWeId4zkHlNSaVGdpKUDMbSEnbBmzD\n", + "fDljCKSPQvAC+BEka0VY1cHG94uRSgp3KXj9FPC927mTIlI6BU88Adse5F7h6sYn4Onfho/8Nmws\n", + "Q94HtQ3Jg7DfhkkITg2Sx+HSDL35LUL/BPynG2DnYF+CJ3v0OuDeN+BsGLLtOKxYHjlLhJQom4Lh\n", + "E+WH7Ns7nDNjTrDIlIQyHk1ihnQZHjsNCBaZMdRNSlNyGpSJZQ6bLkP2aDPEw8aiTorQwcZjhkPA\n", + "MgmhqRBLmwkuIQMsYjCncaSGYoywjOJ+NHsIdbQpKHQeFg0Tg7Gx4wluuYcxCZN76/Q323RsF58R\n", + "nvRZjGPKtsUIzXQ24Wgb8v8NbjzDmzbal1PofQKq6zCJ4egPIXzmh27QXw/8LPBP7vQi3iW+Anya\n", + "n5Bi5PuYvAI3HoeHbiGoxhZsA2/bqToFCx+D010I1zWV/YT+YmF8pgwMO3DyJgSXwM7gZgkGOZz5\n", + "WegvZRwtCJThbl3wNlyrOJVjQLTiZqlQxAzxiTBYZkZHB+hjiburIyZWxoKxCWSBMSUsphiGuGzR\n", + "xCGlzoQFykwpkuAXKCL22kCfiAY5S9h4qKyHSaaYGwmVxROErdNYZoWcKRyPdYQaikNyXIxOcCox\n", + "9x8FDE9NGZ+qkYY+KhqRKgcdzTHYvRd2fcgegd1tOPgufOjj8PQRspyivAH50VW4sg+THJ7pwOf9\n", + "gsvgNKC2Bpdu5WqkhXDh1An4tQVIh0BT5Dsj+PJfNrr/gKf29p6GV/6Doqh4wwZhvwbbMyABaxGu\n", + "3ltorW2BZ0PY+xIMFmH+FHy3BcshjFbh+qEQrTWIyyVmJiOzx2RSJmLGjAUyOUEVCkc9lrC5is2M\n", + "itRoHAu7BGiRETEhJ0ebDqlpMqOMj2IgHhgDskDhxXsSwUXoAdepMaKCTYUEnwFCwpY5TS+/Bwuf\n", + "WlolcQKMXGEiITqzUIxoqBiroQn8mLXpJfbsBWI/Qs0u4jRSGqqEkBHgABOGnovngUZRCcckzpS6\n", + "AmcVXv1Z8LswfQSqZZgZSC+Ac3xjFgPqveASVWqgvLe0s5oQ1eD6Zfg/Lhdj2ImP/fdu0nxyj1oM\n", + "kSwzuPlxold8sE7Ar3wcrgd4qwmqegZZE8brXZ4wsJRFrOcRXVFcUhntbEqoPIz2KJk2PT3ggsx4\n", + "wmyzKy5TLFL2GNJGWEChsdknl4SRHeARsKHnGMk+kQQ4jDggx0IYYAho4VBnniLZ18JlUVo4JqIn\n", + "cMOs4eucWAoCX47CYp8MD02P3MwwZGCW8BTYRmMRof0jtE64x9R4beMk2nEpaQOWTyAlLnpdnHyF\n", + "YLZI/FrA5PIVGE+Kk/YUsGfM5Ksi8i0KGev0veEA/eRAhBqFhP3rd3ot7xJfBP57CiXkTxDGfwHP\n", + "Pgj5GmwMYOrBC8uw9T2gLSI5cBLwiuby4t+F0jrsOtBbAs8DVxWikLqGG/NwsQTzr8NwAjtlOO8V\n", + "eVlpG1LfcF4JoVWccT6wIfACNpd8h5pA3/h0mCfhkJSQeaVwTURVQkoYOkYhrDGRFk36HLKE4i5s\n", + "hkwZ0CSnicc+FaCOokmRUDYDrpFzH4JDnq5irngQ/AW0LjJyfVwp4amEhMJrw6OESxWl+9gERAS0\n", + "pppHn55ysaE4Wo4xvoXfjVD5PFfb5+n9qX+LRP+xwt3wiV38/7BBjRmW6aKnM6IXhgx/wxjz73Sm\n", + "miLWBfjo48cVIcAz8BEH6r8CWyXIY7C+Ax97ruDrvqPy9gNejKTPw0snYfQwbGqYKrgSwM6/guVf\n", + "hM+MYOELcGUJYh9cH5JFqJ6DaAVGfsGDcK+VMXqNIE3JleBIBUVOwoTIRMRSJIHkZEzI0XRwGKGY\n", + "YB8n1PSIWcRBI1RNyg0yImMQ6oBDSgfLXGdRDDVcEgYc0WRKD8NVTjDlFA7rTBkT0gUWTIWZKbOj\n", + "+iTxBFFjJG+h7QoJO2QyopwGLHrQDhXdGPwgoF8eoib7lByfdj6P0g46q+JF15i0B0QmoWdXaAQz\n", + "YjnCUikKWFbgfhRMDxZ34eAkNOtw7cNw7unipnIV0D/UQvhdYDKCdAZO5ZaxYb8IFhpTkGa1iPNA\n", + "yLkHhZW8hD+bMlt8nc6n9rlyP8SjZcTqsvioTTPQ5DaEjTa2fURPaXwbWhaEMiOXHWzb0DIOE9Vg\n", + "xCrN2GPHnvGMPSbWW4yVR5Atoa1zNOgRiKFEBZt9InpM0PhqQgWLKgllFC41XDQtFA4BW7iMKWMT\n", + "EuAyT0BAQokJdTnD1LIxlACXMk0sAib0yU0Ipg6mh8glYtPiyLjYaoJrepRs2C7NEdouJ3IYK4Wf\n", + "GUJpMrYm5CbBGpcILjwIO0d4/82E8xegMYNdLeL/sTHmaf56JvK+HT4FPGMMf6WW8/sYXwV+W4SG\n", + "MfxAdtT7FccE1f8Tho9B/R6IF6HiwVNnofMYDO+Ck68WXI7DD8NaBE4CNzdhwYczQEtDx4UbBh4a\n", + "wNNluN6E2Rfg40/Bx3bhX38Cqh6IhkvK0JAi2HNkYCgQSpMFbVMmZwXFzBh6ElITm9yUORCHDINt\n", + "jyjjs0WZmAkd5olYpIlDQo2cBjk3mTDA417GdNDcQ8ER3KMYzTeRLEQliswVyE9B/jqW36KZJISO\n", + "hwLqKkQzI2GAkQ4VM2Apj5ERfO8xDWuaVhf6dsr4OtQ7DdJzdVSJW6hDMyjFVOWIz31pB6OKyLH1\n", + "IXzjpPD1/3hJBANZF14ALgN/9gwsduCupeJLQe3Awufg62+k+XqQPw47N+AJEfnqO+3xB7oYMcbk\n", + "IvK7MPg2XFgGE1F8W1ZhYRFOHld0Dx0TLv/0ITj5WfjEd2HxAF58GPbWQJ0ts02FxN/Ayj1sVSKT\n", + "Gbk8TV9CmmjGCMPjm3ITzepxukiLGSMcusSMcKiYiJSMjgj3SYUJioyMGRMWpEILD5sMTUqd17lG\n", + "GQvFCkKdDCFmDjgBXBUhFQ9jlsCukZsJRnZIUxujFUmW0DKwJTk7FU3DgFmEuB+QTXawT54ksVyc\n", + "mcHEPVInoBlYqHSfdlWzEkPown4OzhRMqSD3tgO4uAI7XdicwOQMPDeCmyHs/Ikx5jabnYExJqmK\n", + "fPUb8LeegN0mxEdQ/gtY6cJvf990Z/FvGB6/2Gfv4xmje9rAKu1Zn95yRGcpo5KWWHoRlEkJqgo/\n", + "sHAXLMJYE+XCwIOuMpynyimjMSREMuSSsblhRUTi0UdoM6CRu9xQ51ESgTEskB1LfjdwSaigeYmQ\n", + "lB4loIZiiRoJ6ZtpQi3GvMbicQBAxAiHk6KoEzPHFteoMqBeyBIJGBJh2EdkAUtclAkxcgaMxhKN\n", + "qxNEeTRNhO1ZeBkkxqKeOoyjlLxms5yWiYIyZy5d5eDsETcfWqSVbHF6Bg9vQ2DDl/62iHSNMdfe\n", + "YVv+OuGzwL+904t4tzCGQIRvAT8D/N6dXs+PguPgza+IOEfw+Cp86jJkCr5+PzyRw3gNrmk4PQ91\n", + "HyZzRZekqSG1oHds634ug54D7QFUFmD3E7AeFom85hBeWIO6rXhYFBZCCGxIjgck5ERKYZkyiwSs\n", + "yJApNjOWEVFUMTSYx2OPDmMMZRaYssUyGZBgobHI8dEsYjjEoormEB7SNQAAIABJREFUBoUldZFw\n", + "JcbBEOFowTVTpu0qJknBE5Q08LJdpo6gxcUDbPaZsY1rhqymhvlZxjUL7mrAQgiVoOCovmbBU88M\n", + "6M0dMD5xnuxlgAisF2FjymYXznbhxrzN9kLG/lyZg9OnsR97jPwrGtQleOg1+M4I/vAIfvOo0FvM\n", + "Adk5+E9Wjzknb6AEebUYTVTeaX8/0MUIvMlt2eH7/jKISL2YG74V3Q/BfTEsBNCvwXQBfnoEr1Qs\n", + "rjmrzGU2kWVAa8qUMKZJoGZ44pBRosRVHBxWjq17ARQWp4h5DQsLj4lMCYEGHjOaeASUSIlxWKZG\n", + "Rohhik2JGoYGEZoITUiCQR2bi9eAxFQIZRWhiicOM9bJURj3ZTBTKNWZmJSUKZvTgNNXYeMqjEop\n", + "/bsPaB3kJHNHxNqgnJRmPMfc6zNeWUqY2THxDMYaPtqFzQCevQu6UzgycDSCB//f4iZy+QF47TqE\n", + "v/9uIqT/Mszgmy9CsgOfKhX2jKMufD4+VnoVpLUTbdjcDhjvtgg2QPIZuhxStjykN8E9nZDXXdTI\n", + "wk40s/IEV6fg2OwqQyxF8N08MZl4ONpBVMy86XDdtqnT4h6jKB87CAyJ6GKRieBSIqeCIsbgobBx\n", + "WWHKNRQJDgqPMTHzKKrE5ARkhHgoUirAGhZ1DDYKH581AgJmRPQZkhQONWYeTwwtevTMGn3ZxKOP\n", + "YQBygiVScompmBGL6TyW1ozsHFxhUUdMZEY9aFHrCnbziMlSA+taMTuHguT9wBR2P8L3wyz/2kIK\n", + "GcJngX92p9dym/BF4Of5CStGvo+Fj8GD3SKF9+o8LDiFSvKlJYhOwNmwSC4wBs5ocK3iEqWBmoEs\n", + "h5sG6iNw+jBZhqMObM2BtQnLiUNql8HkhJLjYLFMiIvFLmVWmHFFHJRxaeVj6rJIrIQmhjZgY2Gz\n", + "RIUpFkcF9wyXsTHMJMMjRuMdy3khJKTohAyBHrB/TGNto8Um9IcYNQWzB0wps0VSaqPMFNvsE1o5\n", + "ZULqpkkjTVCzEUcJLHdgZQTRAkw9QTuGZgMubA6o9S+QnujDo3U42iv89b8GzfvKfOnRdQ7XF1G6\n", + "T1SzGZ1YQa6cPJb8bkI/gY98D54/Pu+3gW0RUTOY9qHcgjAo5L/tEEpHxcMfv3Unb8UHvhj5IehC\n", + "d1TwR1ZukYqlbWh1iiKuU4clKTIMGmTgKMjBMUKkLOwsQKsc22SEHCKiiIhoUsFhhKGOkDAiwiMu\n", + "SEiMKRnoiMsSHhkeipwF+oQ4WGhSIgQHmwYOR8dBamUMIRkZGUUcdgCMpImYMRibVPlkaLSKgAmW\n", + "WaOWOYit8XRKpK/y2vwENa0xWLZZtBOG6YgToYdKyjj9EuXDEdu1EsNhTqwLoqpfElTNcL0OegQP\n", + "vwqLA/jWHDSiIv9h34XwK+9lIQJvFpZPi8izgAdEt+YiFA6Cq3uw0/BIKhUaL+doNyI6pRHdYHV2\n", + "HaMUwcPLuK9a6LDPuNwBu8ViWMPLR0ydKYklrJkAQ8TUcshMhGUES9VZwaeaGgwjcFKW5Igj3ILH\n", + "YUogmpwDMqzjpKAKZSxibEaUOHnspzuigcEjQZOyhUGhcPGZEiDElMk4pITQMOfIZIqrE1bFYYpH\n", + "CQs3NyD1QuarbXKdoywPK28SSxedD2mZPbr2AkGa42UzYtPBNj4LVwtxsJKMir1HREH2ewPVCNzG\n", + "e7mfP0F4BJgY8+5dJt8n+CLw6z851vBvhVWFynEsSWYVmTAAoxq0IggsKNngZoUwvmQXOTZLGsoa\n", + "uhpCDc4MqgfgluDFBhw8DAvKY0CFepYzclIyFAsYQhwMGkVOGcUyKT2xqEtOJB45xxf/Y85cioPB\n", + "o2oOyFhCmR65tIg5AhQVHDIOCVhhyi7FgeZTzDcskBmYHVL7dGFsQhfkOkKJqt7HYcKEeZSekJHS\n", + "pEl5ppA4J05gfwyPRDCzbbaaNUK/gj2MYB6+9SstTPcc+df2wX0ZGMD/BfTh8lOnKZ86w1yn8CQJ\n", + "a2uYTBNVo+JBJRaY05BdKmZfb575xhjtiXz5m/Ar65AdwQNzUJ4Wc6/LPjz5TjPO93UxIuI+BvMP\n", + "Fh4r3e+CfvV2eOAX3AL5PfjK34P76tCMoOPD+BCmxyQdSQEDk4pi6MfMJ/t0K0tocYhViMWrOKbH\n", + "ikpxTMAhN+hKwRwBHyHDUCVjwD4OHRQhGZ4ILgmCjUcGx7kjDQJywMEBfCwy4uOYvZAjJliU0eyR\n", + "McVihtBHSEzGmjmkbzxSciyZIPhofYpmOkDyGbh1xF5lsnTApUaLxlAxdyXlhknwK4c02nXsWcpr\n", + "d1XYXWlRHjVwmLKzPkJlGY5SVMYT6hcyhj6YKgQBLE/gRguujnlThfHe4/hv4G1yKwA6X4Gn/37G\n", + "qsmxrYyoGTKqtJGtJVoHVxieuMTJ4S6vn60yyVxUvsGRMyRxAhy3SiBCQ6cE4pJrB0OC5JqJqZFK\n", + "mZKxQQZkktOkgpERq2i2qDGRCjaHpBxSxWOZlIABHsIRDboE3CRnmRCLjAkuA9ZIuQvF0wxJOMBG\n", + "UMXcGRubgEx2SfBQKmdGhE2ThBoVXGyTYZmcUCJsFFYm5HlG5KS4saZq7VExPSZik+URC4cab6zJ\n", + "MotgKSW3+0yshI9+u+iIvIGdJgxvm+JCRGrVIuHw0x6spHBzCP8mg+du12e8h/hAjGhuwesUZOUH\n", + "gAt3eC0/BqYX4foj8MA+rAwLCkNkQ+jA5gFsr0BbQW0Kh/WiKxIGkHlg2fCahmEPAtfH+2iJTmoz\n", + "O+pSe8xwwga8iIFlUTIGSzQpLjYWUzLQU3JlUMfWhjskpGaCQ5WRFBfFiIKQnpPRMhYiPbRETGUO\n", + "TU6Gx4hrQHJctJxF0cewi2GOgolrgyTYXCQjRahTNk1sUeQSU5YBlqmTqbtJzAFXZEC54oFfJxi1\n", + "SKcdDtoxOqkQJy6SKExaote6m2gyJp/cB1c/DNlLsPzn8OSRMb8zL3LQon4uwWkqrDQnqFiE0TyM\n", + "+zC/eqxcSkHpW7yd3kBszAuOiNeD/+GRQnAwWSqsc3e+DJ95pwPljhUjIvLzwP8C9IwxT739u576\n", + "RTgzKOZ9l34VXnlaRP7gNqUETh2ufstw83yGH0P4IqRfhhf+R6i2oBnCFWMR1ytEowYnu1tEpxJG\n", + "XhmdHaJVwAmj8YMWdpZj1xQlytwg54ZklJlSZZ4WmhkKaGBzhRYRDg4TbFYwaGxyIKfEVSJWiHEx\n", + "GDJGVMnIaOEzYcqYGi1yLiPkJmHeHJKqKpF2UIQsYlPWU8ZSI8jKEIKxI2w3ZVDy0fgkjo9lpsza\n", + "m0y/MePygsGtdxFZJCufYuFiicrQo7/Zpt57gdlij9cPDCeGhmBlSPegMCGqvQD/dh32e3Dw+bcy\n", + "re8UjMlfF3H/ZcLBf3aI9VSVvLVM9UaT0nCP0WJCdqDppnWy5TNUO4Zhawl7qiF9jVGzQqYPwRpz\n", + "HZd14+OalIFyuKzLJLliKDEtCVBKCKTYnxqaZnpIYidYIlS14qwCiwaaKRYZUKOD5lWgQ4UGHkcs\n", + "MWOdBjMSWoyYcYWAORaYI6BMxpBlRqxg8LBMyFi6uGaIZRwCUVTyLkOVk+QZeWpjshCHDl6Q8tDT\n", + "UIvg5XMJUkkId+EgVZzeM+SLI9JSRNdP6L8EF0+CpeHEEK62i/DI4LYUCiLiL8N/tQBPbUJlHYIh\n", + "fOganL8Kf3DbCUa3H58F/rs7vYjbhWNr+DdGNT+Bxcjwm/Ds/WBW4UQfzDZ8+aFiKjBqFrmNl3OQ\n", + "GugArlZgaVT45dysQHwJ6tUS7ZMKSRQrnRnJ+RJnxiELFI2ISjmkrywWjSGR4orZocGymdE3M3aA\n", + "SQaVGB5MelxtlplI7TidN8TiAIucSBwi6mhq3JtdZ6oy6lLiJbkHyyT4kjFki8KGrQqcBy5S+EvJ\n", + "MU3WwiXClyLH15UuXb3ATNURqqhkBS0TIutlCq+PM7DzTXYf7DO3pNjYz5AsYLdZ4SD7EPkzl6B+\n", + "CZbbMNmAfh0eEJHfX4GDTcbf0MyaKVZpnWR7COebxcxLAczAuVQYtVx+u93JIDwHz90Hew5kb0gr\n", + "74Hp+7IYAb4NPEThCvhD8IlbVBknhhA8Bi9+l1v4Hz8OfJHHz8PnzoNRZOYqY+sGbE/gS/D6P4bh\n", + "fwHNFUU/9akeNFkcCUpprO3rRG2h7iX4lkdtXMHvR2S1MU61QlW5lDjLgIiEKgFdehg0LRpMCMnJ\n", + "UBjTwBObDhNChCllAuQ4lSRASHApkeAwT50KFYSEq9SZmRNM5QaIJgViMyWROQSDx01GakArPUVo\n", + "pWinuGWPyRCTUJKIRnLAUQWuV7aQX1jBBI+QTG7AXAWvleElE2arLrlYuMESzrRDNhczkJDpJkTr\n", + "kH4XBlsw+SPgyu2KkL5dMCZ5VUT+UQSf9nD+wSHW3FWckzM2spTGrsvF+jKT/iqzZ7vYVbfoPrZP\n", + "oOQQ4V6G5hJTM2ZfZihWGccOydEB3pxF3+sTOmWWjcITzSF1jsw8C1oxMx0O5JA1sRmhyJhgUJRY\n", + "ZA7NITYZDRI2GFDkTJTZYkadmE0MMyCiT48+EXN4dFklNxlKUmasIcaiIdcocY2cnKltyKni5AuY\n", + "cUTidRj5Q+7tQb8BByXoXof2DFhXzKwSzz5Zw74pZLlLTsqZ9oh6Ct/7BPzZDsS/C+O/MMZM/pJH\n", + "jYi4FN3lHyr/9eChE3BmAbwPFw7YLMHEgZaBR9/PxYgIy8BZ3veeSj8yvgj8OvBP7/RCflQYY/qF\n", + "9fvwo1A7D/mzcPD70FqAm58pCKof/hMYVeDKo4Uqsj+E8CpE34D2P7JorlSpjxxmyRhzMuGMGEQs\n", + "hlEMeDSUg2UyLpOigSqKRYYMJSPUkKdwZgR2AHvtnHS6Te577FqCR4hDSkqZm1SwjcNauoNYEffm\n", + "ULX7RFzkJZZIWcVQoZAk3Dh+FR1zaGKIgISYGBjgsk9kfGbqdOHcrRMyq0uuqli0cYDq6rPEiwlW\n", + "VuLApAQlB8IS8ZFLtdVl6G/hLB0y/4kS1alhasYcDSGVHrywD5tPkb/6hovCt8B8Ex49Bf4ObFwB\n", + "swW//8OyxwTcMuDeIhsGKL9NJ+VW3LFi5A2HTpG/qiWFZeBUDq9u8i6KERFpn4fP/W3Ye0NjfT/I\n", + "F+GTz8HrxqRfK/wV9ueW4B8+RWf2OgenhpiTKwQqwRrvsrEUsbIX8cDhiNSBwYLPYLmGEgtL1VCm\n", + "ykxKFJrxfXwTUaPLmmScRhFKQoowwmORAS1CLAzXj+nGEXUW2MRgA+Y4h0RTIaUrXTDreKYGUsGI\n", + "TVt3ScxlQqlimQoTa0Ike5iqQwmNYwQVdTGS4RvhsGyx4FdoTUKM3+HwhDCdbODriKyRshBNGVQH\n", + "TMMb2I2QkxKw4BmaCkoCVx6E8RLsVWH4P/GDVrZ3HMcF0p+IOCdg/dfgyZehOQNlFKO6oetvwuWU\n", + "zJ8w+aV5/NhBLAHlYZwGkSwRJW1QVYhH0OkT6wlqYZ2ZypiqlLrJGHEWO5syloyQBTKzi5IYnxCX\n", + "Cgp9zPbxsFnBZQ+FIgMUE+YQUmwUE1q4rOCwj2KHAwJzilQ2MJKh6QF9FHVSU2KEi5OPybOEk9LB\n", + "TPdwtqA1bxGWfIYriptLHnFvRKOb8eQhrIeNQor8/ISL84pEL/GRqxrHSlBpyOlnS3z1wz7d+yfQ\n", + "E5GXjDFvOw4TEasCn9yEpypgTSD2Rb4SwjNvLU6bcNYDZ/kWSbYAdTALRV/7/YzPAl825t91of4A\n", + "4KvA50WoG/POxML3I4wxA+CPj19vQkS+ANMn4NqHwIyh/08hep5iLFWrYv3jnPJ6GTexmMqUtAab\n", + "mc2yp7HDhFkFIjemrMEoYQ04DRwYzbbEzASsPiwkMJqBnbns9O5C6whZzEnJmeQlmpbHfLJNVt/m\n", + "tIKGEkraYk5BRQtzlo0j62hKOChSZhQk1msUY5o+sAzEGI4o2J9blLGYk5AxQ45YI6WEEb9Q8pgy\n", + "trg0jMXEfpWWU6aapBi9SHXXoikhVvU79M71OWW1OfO6g5WNCRtj9mtw9cMpwXMvwoMZnN6ESQTO\n", + "AcyuwT+5Aj0N2sC14+f/9nsDezdBHi5aTG+eBTeh+U57+r7mjPwgYil8VH58eHD2fOG1/2bVZoM5\n", + "B7PrRavqGsV3WXdB5EXgdM5svoVVU9Qpk8uQfRUhKxn3H0JUcjh40KJkQ24cMDGOtsmki1E2xmjy\n", + "fJ+yFdHWhlAZcmCFMTEKB2EFYUbxh+/jskWMzZQUD5hg6GIRYJEwT8wR86TiYEkNi5hYGYw5jzF1\n", + "HDMikBw/PSK2poyUoak19qFhIXborlk0yiWaqokRQWmhlhyy1RgwlRY4HonEuKUd8oUhbSujNtK0\n", + "K5rFBGq9IvFyB8g+BcPfAV59N3vy3qKVw8LlgtyWO5BKhDuZ4ske040UljOybMjY3QcrwUouYiyL\n", + "eR1SZ59MbCZ+TnzXEU5/jnG6Ab0Juh5TLgfMZftE2mFmpyRqh6pS2Hgs4iJSRkioMOUmJWJsDGC4\n", + "SRmLEQl9loEJTWxaGDQag0uFBqGsA/NogkJDJdtAD0sbfBOgJERbNU7HE7ZrhntWK8TSoJQ71GxN\n", + "WwuX5sFpDolUjnWphDRK+NGUDQK6zXlK+wZSYefkaV5qrmBZPs7DkNYvwOMi8hvGmNlbn2oVfupD\n", + "8NNPwI4P2QTcb8AvvViw5p+99b0JjDKQ+PvOg2/8XLJbjQ7en/hl4F/c6UXcbhjDTIRvU0h8v3Cn\n", + "1iEy/8tQ3oD4AHrfMsa8K4+iY+vxPzt+3fI54rTh19axPtyjNCrjVSJ69YA128Kf5gzKhgWnGGum\n", + "ApMyKGM4r2FeoG2Ki9hrU+AIsilUZ3BzLWexusu0GoNbpZm7xEbTT4ZkZYt5nWM5UJPifzvVEGqf\n", + "PbVAVc+TaU2ubFIro3Bf1RSs0EXgWxTf5kNKjFlA0WIZmxk++zgscFMaIBE2A1IJsJjDWC52WiG1\n", + "AkpAvNoDr4odzqDaoVqvsfRSii5NyJwebpjxsWdh8FMQfKcHv/kNuPsi3JPCbAgXfhRxgjFmryHy\n", + "7J/C4/dA34PsGrQvFPYpPxTveTEiIkvA59/y4wNjzN/5y3/7X/1C4egJsHoNdkeQvytGuxRWtj8w\n", + "VrBA53DPWhGwUlsR2e3B63+E/1/aNB72OJVZ2NojiGwGnRo3rAF/dB5WV23aohkaRZcVlogYiE+a\n", + "pxjTJ2cPbWAjh8UMUkczkYBDJbSMoSMFhbWPZpmAiBo2GQkDoIowooKQYmGTM8+ECjcZEBGaFiXj\n", + "kJASyyIoYawrZFmJeFjCyPOUqjN88ah4p/GCDnFaZjlJ0aWMzFbYYwsz79O2hozjkNBrEiiFE++Q\n", + "Nqa4owTXzaibHBPAQQPGZdifg9oAuIf3dTFiObDxDNguBE2wYnikt8WVz/gc/Y3zELWgv1+kJJpd\n", + "8kVYNcusYmFph0o0IaPPTYm56xWbF57oE+Q5ef+A8TLUcMmzIxKZ0cwtLNWgwYQtSWlg46GZIOzT\n", + "wANiUmKWaJsDhD65eEQ4JEAXhXUs3y7C9yI0Y8DFxiFDgBuUJOKkzqkazb7S9MSiql1MxSOwSng6\n", + "R4lD1UypKIeW63G4HnDfH4RMHy+iy700x/ZStB0RVhocNu6huQWp52IlD5Fu2bDxtSIc7mu3PtFj\n", + "a/6nnoTtN8yNapB8FPb24KdF5LlbieYDeL4Pn7RhbQ1sH7IAvCPIt74fTPy+gwgt4KMUBckHEW/w\n", + "Ru5YMQKfvrvgcxxtwvP3iTi/ZUz6yu38BBFZh/Z/bSj9VA9zImFQA1+n6JKHa2LKFuzrjIlrONcB\n", + "bOiUYB6oipAgJFrjZVAZgHwDXrwMi78MD9o5VjhlvwVnVYRC0Ew5cGx2jItrQlIDMwWrRjMV4Xlr\n", + "npk2OJKglM1UK9Ae2AmFpfo6YMB0ClK6pCxj0QIEgzAH9KhzlZI8QMQhmksYMhxcEkpgxYQmBzVH\n", + "JehQnYyo9TO2Q1jrhdT3B5QOUyoDw/IeeCl4JwDXGBNRBAu/9OM+8zH84Xfg6jV4XIHXhz+OigiC\n", + "//2H/c57XowYYzoU7oU/BuwXihZZBlzNYPtfHxvf/NiI4NpVsO4vYnkNFJXoy3D/Gkx/Bl5pwWAb\n", + "Gl+g9usDNqXKcmSxkhhMPmKSt2nvK7LKlK0rKf6ihY5KZJ5g2WBjqElCzwqxdQ8JhabJsVyHTBzQ\n", + "OVPtsu2AkYiJ8fGkStVkTGRGGU0Jlx6GMSPqJickZ4bNCRQbJIxQDE2PPdllnyVcDKrgbiNmQJke\n", + "qt5lwbi0JGDOitHz+3ScDKwSSht0GCOpS9rKkUqKOApP9mklDiIw0zHszMhfBvcEUIOpD+28iHU5\n", + "FcPhPJTufjf78d5j8DLc/Hl4YguOrV9IVULUt2B/D9wc/FNwUMVd6OGvjziVX8e1hdhy8GZCbWTR\n", + "aTW48ijUpjdISoaTQ0MjtsnLU3J7xJ5rWNE2A1OigSJnQkegUFa5CDkxIaAYmh1EDGcpY9NnjwYO\n", + "NjOKdJuMPTLmMCbDNUdoSmSS45kenkpwTJWZ8gj0kJQApQo/G3IwZcFJbOLYIgltUs8wQbEaQOZM\n", + "adzoMzydMGto+nNjBg+OmFZOQN9G6YiZv0h8CeAM9F4seF1fe8tDrdVBld4ynpuDqFzw7jxuUTsZ\n", + "Y7ZLIr81hr/fh/sWCvJbegAvHcDvAP/te7P37xq/CHzFmGPH7Q8evgj8gzsr8T1/HMPVjKEZwOhz\n", + "IvLa7QpkFJEGnPzP4YFmjVGtRZ6FpOkRu57CTWNGXogpZ7gTiC7BdhO2y4rANmwIDCxQSogToTYx\n", + "OFFhBi2vwNmzsHYGLpzKOZtazDs5iaQEBjZVxNg4NLXFiTRnz4YdKb5totwmkRjDFUI2QLdwGJPm\n", + "N0FlFMlzI8qSsmrmsdhinpAKVYQuIfOk1EkxKHMZZAsPm/sp02CfKSE3VY7Ja1xTipanmMwnTLZh\n", + "8XvQecjQ2UxYugqbx4XIYQXCPuCJyD2qsKC9+eMaWB5fRn6goHknWsadVNM8CvzPwP0i8mXgc8aY\n", + "t4xgLv2vcOkExaF33Rjzrg8FY8xeXeQbX4RPnoOZDfllmO+A96vwzcrx+CYD5dKoCvFSQpp4ZH2b\n", + "emLjuBP2Fy3aScaBC5tTg28VnZB69RKHUkVbmlz2qeopmevSCHw6sY1nOWxZG+jEULEzOsaQqxkh\n", + "y8xTxtUdjmSf3CjGss6IHloSGjqiIi5tERIyHPo4tGnKTY7QjKWPlfsoASUptrVLzSrR1gors8jS\n", + "nHoeYMWaI5XTqbdZTntYnoPGkMmAsSg2Q4cHAtBxyk5e5pm9GZ3nCge//U/CXXnBQdoB1lJIIlht\n", + "ikjdGDMWkYUqPFiG1giuJfDKcZV9BxF9D174EJgNODmAyIGLjSpHuw9Dbx1GN2D/EPtnc1pVhbZy\n", + "WtpiZRYzdmNMeZFXrA2ycpXKEZTDA7rLI4zfAkej3THiZqxhmCQxdj5lZJdZReEzI0KTodmjQ45P\n", + "xCPkconqsQerRcB9XKNDE0wRjicyJs3m0FJBpRY1UhI1QtsjtD5FybhF0JZeYMZ1et4YiRyWKoUH\n", + "9lSVUaOMUb4G3Q7DckQ9h9jJOPfyHt9cneP6ykkGh2N2SlUae4psZUz3bJ3+6yuYXYC0IGq93f5N\n", + "RpCHYJdvGXf2oRzClB8IpoTImO+KyCsHBRl0GTig+J+e/NV5Y//e8R8Bv3mnF/Ee4hIFj+d+3sUt\n", + "+PZhPoTWPOwUF//bgtJ9cJ8LtdTQ9ys4PTCqQsOqcz3eZeZMODWAh/8F5AI3fwbq3zbEH1XYJchc\n", + "Q0U0talhN4RwCJ0LUHehFhYeS8MW+FmOYyKMqzHkKDIakpOLwddwV1h0lKcsAMuIXqRqpoRqn9Tu\n", + "o/QQVAPSJ0Dv4ZQaNNllKkNaJGRYLJPQx8elwwybAWcI2McjZRmwicnI8YlZMktcM3eRxlMG/QTt\n", + "HjFvGcwTFuV1Ta1mmMxn/GnPsPb/wZayOHj+NPzDuwqjFHMNqIp8eWrMv5c8pjtJYH2OIgXznd5z\n", + "xJu32duHCXzpOdh+FX7OgdoIXngUogpkBrgJm1/H/twMfwNWTEI7HdOpOvRSh3YeE1kZwZ4h/hOY\n", + "PDTj1Ew4kCqu0qx4W2yriLkkZ+kCRCZjbdPhQBJestcxfomSl9CTMkMWqZibxGTsm4QSdQJCAl1H\n", + "5wZxq6TmgETZQJkZmjIuFhGIoEyOK4e4eozLK0i2TubYlEzCkoypWBlGa7LQYhI6xK4mskAmYzzH\n", + "pWoPMYwYiFAK6qyNNUNbEZTncF/qMVeG3f8HLnwI6h+Bo2phmTwfwFEMc1+H1RiutS2RlXPwq/dB\n", + "XoN4Dx56BZ4SkX/+V1Fl/KiwRO5ehE/Y0Arh+hF83RjzA+mdxphARP45DB+GC/dDHsDhv8lh4wg+\n", + "tg6jFbi5g9+PsUo5zizBWC6S2IzLLvulJYKySxzbNGJBaOOnKWNvUtjAi1CnSosJUSlG6T774mLE\n", + "sAyUmbKDYYMaCU0umgqYGmUVAGN8ypR1yAm1T9kY9sk5oaEXb3NYssntNpECMTeI8PFVCS+BsZUR\n", + "OTZ5tkpshFByXibEZ0hZZcR+g8kIkBDresbeGLYqUD5RpiOfYvIbp+FoixvN16mcGhGXbbL8bnjG\n", + "hUwDF6HdhT9/41mKSBvK90Dd32d87Ztw75OwU4F0BN63C2v+3/1hXkDHZNgL/ATISY9HNE9SFCQf\n", + "SNwi8f2bvC+KkVwgEt6mmP3xUVmCuVDQtTHGeo3kpKGiwdERHcvjaM8lej6hW4F4Hqb7MB8YWl/K\n", + "ufBzMG8VZ16QwUECo9+Cye+B9Rhcvwc228V7ghIYZbBMjDnmbY4xLGhwdGE/38XnQC0Ta0hNQIcq\n", + "duTgWK+QezUU96HskEzKOJJimyaZ7B+7e2dsUXBDXIqc3ql5FUtsFvS9LCQdEuc6uZRQ0iZjhdA0\n", + "SfUQ1b6bUuc1ug8pNt0Sa7OYfD8EP6R8V8x3lqH7z+6Ch3/RfcHcAAAgAElEQVQB9t7I/noQrD+G\n", + "T4vI9ffa0BJ+4gistw2rG/CL56FUB70FjxzA+QnsX4d7X6byc0M253IWlEUiGUPLcEYbXvcU49Al\n", + "mmZ00gwuZFzfhtbqlLXRlGAGr7chyWDjS/Chb8Jey3D4dxWbUZW+ahCXhYnMMdYWRhrEapVUDkmp\n", + "MdU+DjYwxuQDVKaImDFyDCtkWOR0KaGok6OxpEKu57DJKXOdchhQNi6JHaLEYj4FL8zp5TFWWGPk\n", + "G5x4ndOdLfqnD+lKRinVlDUsaxsd+ThhjilPMSqgehkYGzP6HZGlDZg/CX4TVARz12GxBy9sAPEa\n", + "/J3PQK913J4/DUcVWPtzeIq3MN7fLXyRxx+BX3oYjlow2YGzz8K9IvJ/G2PeTmk1B14D8hH0XgOu\n", + "T6F3gf+fvfcOluw8z/x+70md081h5t4JmAyAgwEIIjEApEglipRWkZRFaVfWrlRey2W7ymuXXSUH\n", + "1daW7d2tpezdUqlIUV4xiJQYxASCJAgQEOJggMnx5tDhdu4+ffLnP04PMBgMSFAEMCCBp6qnbvd0\n", + "n/76O93feb/3fd7n4e5RKIzBQAOnR6D12LasaCWF/vQIVii0zSJ+YNH1HbTREKNn4MsonuUQUCJP\n", + "SDMq09ZcQqWYFY++Cmgp0MUkUAkyIgSiSFJnNydZFYe+srDEIWDAVqQRSohFrBIpIaR0l5lBlUWz\n", + "T1ETUtGAuiqgazqEFh2VIwybaGYOXyVIRkk0v0f/0hpbsw5Jepgdj9FjA1ItjZNeifazPWhMg3nj\n", + "ULxoP1T3069ehEuPw/t92FEEexlkCZ4J4DkAkcTNsPfXYL+CZOCynHqMU9EyvbEc6D0YbMEX3Z8M\n", + "EbNXgg8D3/kpLtFcxt8D/zNviBbfk9OwdebV3bx01mDlvgzWoSwqo5NKOCitS08J21Zg3FZcOAt5\n", + "gYMVGFmGlUm4qEP7X8V/J0vgboL7daXUEoBIfhzGdNi1DEYJyhmYU9DUIBdBXYPukCviJ2MFkb6k\n", + "WI8mGagkaRWR8R18rUvCAN9PEco6CQMs+gjgyiiayuDjkFY+vhayRkBeaaQimKWHRAnyeoVIt9H8\n", + "SaTrEBQC/LBP4G5AMI3yXPx0SDIzyVg3xEmkkHAOqYJZvkChmKb23ikYZGJ7HCD2lNkP7nKcOXsr\n", + "GHm1ISLaNPzm+8HbFpfmuAl4AHZ8C97pk73J5YCeYucgRCcgGeksZHSWVEDSdTjtTtE+czuNxx+D\n", + "W1ao/Sk89wewtBM0DRrrsGcVbv8etJKweruiVrKpJxVB4NLWxxkYoxDWUZYLYQAUCHSdSAdRfQK9\n", + "REJaBL0mRipFWo8wtFg6bRrFEllCNmgqCwefKEzSUSmClMWN7YhMwudiSjC6Frm+Rz8X0gv7tDtC\n", + "mLxEsMNknFmSfcGQdWqmg+7XSAYGSTvC6UeMPwJnHOIOM6DxAFR+C+49A6lhE8RzM1BeAIwZSIwM\n", + "5/My9kHlKBzhVQxGRCS5A372Pli9HMHvg6oJo+24M+AvX/z85Nvh0IfhoAtpD5ZvhlOrUPvUJfhk\n", + "Hz40ApNtBqpB1h1wx4LBhYlJFlIRZiKioZLYwQRSr1IZcShshNizJppkKVEgFwqiEjTFoa977PIi\n", + "0oQ0jRI9xgkloEKdIop5TNIiaKrPikCXUVajEE2z2RmFFBUciqCiLNo9RT5qkQhsEpqLmw/JSYFu\n", + "lKaug4QBoRvhJ0x8sUhFOfTIwkyl0FfWaE2XSRcUazdnaW29A++peZiswO7jcMsatLddcb5moeXC\n", + "Iw/BlwwwfFgH1mKJfcnAzl+BD1YgN9QKOEhEesca378fgtNA/9Wq879B8DvAx6/3IF4HfBf4jAiT\n", + "SsUaMK8v/m4OJhXUBVZXofGVV/f4/tkUJ3aPsk/pJKIUqbZJVzPZNBRT1RZTvs/WvXDoCdizEZuA\n", + "HqjA5Cw81Feq8W+vPmLsgbXtENx8P6zeA3YaogAu6LG7r6bAV2AJbI8gO6xD5gCTEFtSeLpCNwdE\n", + "5NDVgEhbwZCAZKRQojBUjjxrVDBxoxyXwg6h2UOLYEKEBDqLXpaZQYXN3AJJbxRroDAaOr6Zoxbs\n", + "RV0ag0we5T2DPy0kQpOoLUjaROlGTE9Bw2AEOkZsQJZMX1GaNSE04iaf1xxvumAEmJqG4rarIr3b\n", + "4Pufhl8MGcuaJJVNZOhkKmkEh1JCZ0ESGNUJls/uJTonQA6S4D0Nyxdg9BaQcehsgx3T0EkJT/xK\n", + "mm1jCW5ctDk7r7GUcrATE+Bn0QIdI6rgm5vo2k6sqIdQQ5cWPjqetQPdmyHv+wyMLmV8oENGAnRp\n", + "clHl8GUfaTVCFNToYDCQDU5kArb7I6SaHS6YPUbGfFwDNtsR5a0CUoHo0BiltkLpPmGxSNqtcU4P\n", + "2ZUJCGqgnYAnTdj47AsXmOAEnCpA7b0woUFPg8pF2PoCUIpi6YgXIYpbOV/t1s2xCdAzvFj3YTy2\n", + "mr0j1ohhSSnli0gWdv8i/PwGZIbP39mAxBw8dESpwaMi8vEyFMEfheBfwdl9KXqZaXK2hd8ZkFwe\n", + "0M5Oo05bML5Bq7OFfyBCIp2u5mNqgqtyuFEJkTJbSqcbbWPLm8TSBV0PSZlFNLXKgvQoAS2ZJ4FH\n", + "kwk0UuRosqStYQeb+EqRDzSmA8VKJGiBh2FF7PfBSlY572foYlAVhYsiH1TRZD8JxwBlQ0mRGc3R\n", + "9xXbzugE0xbObA+vNgrLc9DqwIWn4O4ifD0Lng3GY7Gq4AORUk9fY87nYafxQiByGXvrcPawUhuP\n", + "v8rn+LpChJ3Eu8GfJgn4a0IpXBHuBz4I/MXrP4Lj/w+xvEaHYfD7Kr/B6D6ap4XjMzVGdvhYiTx+\n", + "OIXZPEVtqke0BjM7Id2FE4fAugS7l2CqDblbROQrL29B0pqEfMoiZafJdmxaWY9GLl72bg+gYcIe\n", + "id2CB4HGwFaMp7sM2E0oGhE+PhdQ+OhMkmSaSDKYUQNHVukTEGi7MbWQhiogKiQlq5zCIxOOYPTH\n", + "KfYDVswKS+0NCksW4ViJVi1Np5mArge58tAN0MRuOdhKJ20aaB5AnyARUWcSWjXY3Yf0lcHIImTr\n", + "r1O35JsxGNH1a7T2psHVYMkmn86R6rqE2xJYXQVEGD2TUBlsBduIciNwcxukHQs2JZVSiyLpCdh+\n", + "C9yUgNoe+Id3GuTH0pSqHo10kRVvCs0oYZnn8PQRUA5Ka2DRQBOXVNRCAodUkMNPTaAFCrFA97IY\n", + "joaTKdNXWVRUoaP3yUgJWMXRfDzLQaIsbn0cO1WjV9YYa2uMbtNxXY9KC+751IAzH9B4dm+BFdMm\n", + "ZWkk1QDH0Sm7swy8FY53IPo+RMeg8aRSMZERnhcR+76IPA2LY4B9mWktIoONuNiam76iVfMUTDZf\n", + "2onx48LpX6FXoYAl2NeBg0WwdsHvLENfRP4ayMK8/kIgchk3bMGJI8Cjw8/VBJoi8j/A4//SRf+1\n", + "JmE2jdRLOOsGauPR2P7TbOJvbMGlW1C7kjRTIUislZvQDDyVxXYsmv5NJOoDmiWXVCIkF+poRh7b\n", + "CFDRFEosdKbRySJEaIEBWsggGrCsmhx2A6oFRZeIMTTyvk7RiShGDoXBeZ4pFOhaBVyjT2h4lGQD\n", + "CllEBhiqS5s2qYslJuoa3QmN+cDg1OxZom23wuK74dlPQOqzMF4A6cWmVt/qwcsR1eQasSYvtN3/\n", + "1OG/AD6n1KvJXXhD48vAb3EdgpEhz+slXK8fFSKiExOjFbF0xOUAQs/A4F3Yjx5Fy5nMd4WM6REY\n", + "Ic0dsNsCmnBTMxZxfOp90KlDsgt+AIwB1avGrEQKJ2D1j+GucsCqNiAsKHxLRxeDCTS6moNSiuwA\n", + "XEuoRWnCdp5cZguTM3hakUgNUFEbXY0g2jhjYYeB7jPQNCKSOBKiK+goE8gjfkjO1AhDodftkjRq\n", + "ULQYSA59q8PcMy5Lk5MMRubhiQXY7sD0FLQy4M4SLVVYuEexzVLkej7uWINK6QbqS9Ow6yQUH4X9\n", + "h+GsQHQJimdjZfpryr6/2ngzBiPlMgzqkBq9ov3wHEza8JBLexSmjQx21aYyBrnIoakH1NQtbPXf\n", + "A+UIZANGDsGmB78gIl+BAx+E99Y0zs9nGWRdtkpgpYWV0SSbajdRO0Qzx7CCDp5po8QmkESsIKE8\n", + "RoKQPQMFXp7nlEZbE7zIoO945FOCjk1b6yJozJLBpohg43CJVbmZvutBz6dz/gIp0yM7Dql2SLcB\n", + "Nz8Ig7eFHHQd6myn5vpczHmYgxxsTpJaKqPnYPCwUs3/FUBEsiLpd0HpUCzwU30SOD8kIb4oq6SU\n", + "CkXks/fDx/ZDMQvBBlgXYLkf6/a8alBKbY2LXDoJ22+EcgUmQjgYguyGp2+D1Q3IfQN+exX+HsJr\n", + "XDBDDa7Z5RPM0O/eAA+n4W1FcMqQzkIrBccegqgFfzEKfxpAxiLKteiOuIgWYEgFP/LYlCI9Q6FN\n", + "TiLSoGd5OAKlTpGg4GCqNIbWp6mV8CW21fJMHTMycaWIHtZ5LqeRQ2dnpJGTgNFkRDWhkEZEP53E\n", + "MNLM9LL0cnME0TK6WsASHVd5uJpDGKUZd6uUd2YJUyWSPSFp9LCngUUBScLaAvyfa7Hlaf+HeAst\n", + "w1IIt1iQveJ5F8Zg60s/1gl9g0EEIS7RvAIdpJ8afB34TyJkfxI5MiKyC7b9GkxmQAmUWyLyeaXU\n", + "CrC+Br4D2hT26QpbN5uM9Jr0sn0KxM69bh/KeVjeAXe50E3GGkrJLsjviMjHX9rp2TkOqwN4dldE\n", + "yQ2p5lOsiDCqICUJfAJqkc+KDIMaCZHREC+aIoq2g6FhRBNgN/GzJcCgqZuEmkZAiMMYES6RmgTX\n", + "BiOBcpLYtmDpa4QpoW32aUZ58k1FPg3zwO2PLPH5X8iwduhugu9WYPUivKcNzj7YaNB7dJPze3uk\n", + "tuUJ9btwnjkUp7iLc/DUAnhfhIyg0SZ6WMG3X6/y65suGFFK+brI330LPnoIwjw4m5A9Aa0ufAWa\n", + "3jqbH80w4ul4tR4bIz7Lz+aoOjNgLEDJBSy49HY4vQpzVRJvh3mtyIN3zdHdNYkkG0SdBbqZInrf\n", + "wBFFVGriZmYJZAAqg9JngAGe6iIsY6LIayEVfwDaBglLBzHpJwJ0HQxCFBYFlcUVE0WIMEKSGgU0\n", + "2k6eIF3GHzhUnlT4d8Khc3D4FPTnIJOHyS2PC0sOW6UxojFIGCZWqkf7xjL1LRh8CuJABKb/Szgy\n", + "AnNNGBTg5O/CmQe4StnwinldFpF/tw77k5DrxpyDi6/FF3kL/vYh+K1LsN2EGzVIZODMnbGSMjPQ\n", + "3QXbV0GDJQ8aqbjpBuKq0Zlx2Prbq49bgLtvh/xhOFaGjQYcHof0UXh3Gz7dijUx0rNQ7sMpA2ZN\n", + "PLtFfWwTK+iQqChGFkfov8snNMBwR9DbJv2whlZqYZEiM6izlhnBIYMii9CkLx0SWoQQIj4YKiIT\n", + "QWRY6AK+FpLzUzw+NgNhHk816adbaGo7GfZiqyU6qka67WJmQ7YZHuOjAUrr0MzXWR07iHMxMexS\n", + "OB2rTJ16pa3ySqmeSOJL8LV/AgeCuLtgJQ3nLoD/7Kt1Xt8guJu4f/1a5aqfSihFS4THgfdzXQXQ\n", + "fnSISAl2/w68vwOTQ/L6Rg6+9TER+fdKqW5C5EvfhF8/RGSnqJxZpnngIpoRsGcVxh8BpcFzH4Tt\n", + "SUjbsFkAZwl2nYb6neDNi8xehK1HwDs2zLpUQZ4F5w7oLxo0jDzpTIcwo+FLipSCpLfFc5Zi30Ax\n", + "pruEeodlfQo/7EFYQFFHUn1CxhCVp6mnSeMSUkCoohgQkQKjCEED/CTBVp1gIocrc+iDFmJ28fUy\n", + "osDZD85Gm1/65tN8+o4ltsYFenX4NwG0ViDRhRWIFiL6/9V2+HAf3IegaMDaQVh3Sd/3DLsMxZ41\n", + "WH0nLIyKyN8opV5zO4Q3XTACECp1TkT+bAMOp2Li46ILJ5RSfRH5QsC5pTalnwEpxs6l7e/l4Y92\n", + "QcWFVAoGyaHpjwkKjJRBeXYfg0yOhJUD10IP6jS9Jnopi2rrdLO70aM1XGMaor1o3iaR2UML0xTs\n", + "IiQqbKoIM12laGYgSOLo0FN5umGZyBiQYAJbRjGVgaJKSAQqTdofYERdwsIlknOKO87AmgvRjdAM\n", + "wJ+FgoJGBnr+GhNBhLmVp5O1aTsVpN8gfxwGQ7+B9Nvh1hLcdkUGZLoNnXtF5JnLvkJXY8iCf+pa\n", + "//ejQETGgTzQVEo1rvE+HRH58xrMjMDvfwCCfVeRZ9PDQ8Hq5+BrH4W9GqQjWDbh0gnwnxWRWWLV\n", + "5Q2lVCUHt+wZpmSnoDIely6yyzC1AA8opZoikjbBeSd85zzMbGC8C8bXdpLf6hKaDqlcid0bq6wX\n", + "TGiMkehl8JOL1EcbJKM0UUJho6NkCyFHRIoo6BBF4OtNIi3BRD3FWDOkPKehSUQ3kcQzSpjBBCZJ\n", + "Qm2EwGuQUqukmESLsgyMZbykTcKEkAi7ZLKnpbOrM0AfOU17bj+dZ78D8xegWo8Fr14xlHKPicgG\n", + "rN4IVgYaF4ALL2eO9xOMfwp86vqJgF03fJm4g+gnKhiB9M1wUIPJKwLrmS4cKML6AeBJV6njIlJb\n", + "h8NJKDbxPuPDAvT/GDJdSIagX4KEB800qEWYOAq1O2FHDkYXYbcGz/0qnJgAvhGvQaVTMHMXHFi3\n", + "CMcFO6FYCzQiGcRdkIYiFDhngKmZWI2QnNXGzupoA5sg2SMydLSgQ2TsJog0uuKDpFGXzfKUHXdG\n", + "6Gas/eG3wLgVFUUoCdCUTqE3jxWcws4qOpOw85zH+KUNtv7dy4mEjous74MHCzH71stC8AzZ9ycY\n", + "cwwmWj5vW4tbO75/I/zDJeA154W9KYMRAKVUFfjWNR4PgSeGt+cxIXJhHbbvueKiV4P0FvSgfyzL\n", + "6j8vMtHqEYy6mAlIkqCpbVExmiSLBwisHKE7iHu/Mmso3UXzNcxuElUtUtu2QS8ZcsjukHYW2ExN\n", + "IWIiKiTUCuTUNEEUd9wkCXElQxh10KjTM2zcnItoNlkf+rfBzhQ0J+HZHSmyTpq247Kp+9T7Lu9b\n", + "XiQd6pybijCPKg5eiFPu9+8CjkHxJthxVRCQCGEOOD8LXDMYeTUwJvLRQ3BwFMIaaCMizzbhy1dH\n", + "5kOux3pG5HuduIvmeYQgKzHJYVOpsCoi/xaW94M+Bu4isAGF/wlG3xWLF3URKT44BZ5/BR9FB1WI\n", + "+/MKvKA2Wt6Ebg+sI7Dkk7zRZKy7QW+mTTpM0DqooYcZsv4GXn+VyOygsi2KoUXkZLHTKRANjSVC\n", + "tQQyikgScVsEloYZJqEzoD2ZpCAehhES6BYNNFqqja31sbU8qbBIRJl0VCE7OEuz0OMGgakeqFSA\n", + "Y0ScL+pst2Gi0mF742mWFiL6XyLOWP3IO52hmvJ16Lh4fSCxyvavAHuv91iuA74C/G8iGErxExRg\n", + "pkagcI2Sa96HVOnyvWtxU0Sy34bv/By8rRFzPBvbIVmG+X+A2m6YBJYGUGrDRB/uXYLaXSLyWLwh\n", + "a30ezt4Hg109alMBWs4i6TlsGBFFPWQmgqKAo2uUnRx7NzTMaINnx+ucSvlEKYeilEiYGmXO4jNL\n", + "nK60QSYgGgO1Hjv+SQ/yLdDmSZg1RsQmJMAfWGQGOVJemq1sn6wOp6egWYOXN0BswPky3Hpg+Huu\n", + "wnhEzmwgymdqqO2lEbc7n7udt4KRNw5qcP8j8Ac9mJ2ETgvSz4G1CX8FLGi0V5ro74bJrEZSt2nQ\n", + "ZUpPMhIoejWbPsfpJkIoJSHQUSqLYfcQlaGw3GZThVguVHNwIGOzT6pEpk9daRy3ZsmGBgNVpawN\n", + "SEYahmaDeLiRR11GEBN0b5zEZJnWbJm5OmwPDC6NCMetAonOLNlFG9l2hvOzNvdeDJnchH0nQY/i\n", + "r4IMvw/RAJxrOCw68ENsoH9cvAP23wbLl9twHoVbnoQ28ADErdlXstttOHoMbtNg206oD8A8BaOr\n", + "MTm1CqDBxBTB3SWCkgN3rGPtdti7He7ZgIIHngZPvrfC42dP0qvcc0Wv/Trk12NS7jo8z4/5/P3w\n", + "sYNQbOOoZTbuLpNIhaSigPlEl75WwnMStLNVXNNhXyZA1yIip0nT7rIyPo4nM5jKIRm4GMploGfx\n", + "7Cq6FtBJRIzpJmOBhRZ1CEyfpqTYivaDE6IS4CXXCcRmPdhizOhz0IeMxGaSYw3YUY04XohQy7HM\n", + "9lg5oh0p1XsD+whdd3wM+LpSLyYsvhmgFKsiXCK27njgeo/nlaO1GgcEjgUj3TgrArEyam8NQEQs\n", + "SN4KI2+PjWQbR2HwFPB9OLoVt+eSBm0D7lyGfAfWJqFuQL0DNw03oIaCGQXnJ4CWUsoR0T8N5p9F\n", + "zGkRxcjE0H1CCWkGAX2B2RBGwghNt1kfS7O9qUhKm5wVcKPA3obLaiZPQYcFQ7BJQGTFwYgqQ1QE\n", + "MQEbmCSb1okkQEUFxpt9PMuhPB5QaCmc5CTLt1t0PJ/+P9Rj37DT15q1CM6ehuUEzO+BWgMya3jF\n", + "FWbOw+4r1G+NaPj2rzneCkZeIZRSFRH5szrcmoP5AZxrxXXltgGHXYJKk25hjFxT4aZ7kNSZD3v4\n", + "CQdnooboeylpCUKtSUufIvCa+LkB0WKa1X4D9ynImTA7D6MT0C8IpAyMaMAullmWnSQiCyfscU4G\n", + "ZPAQAvxolkIE4xp0TJOxzAzJcMBKocfNbp7dbZeqjHB+M42YCfROkfVdNqe2YPZR6GVA82FBIBxe\n", + "hKuPw6mPwFQn/gECbOZgyeaKC/VrgSOwdjk1oQG3wfoFuFPEqMPEu2BuTGSmDJUHlArPxXwG+fMO\n", + "3P4M3BRCpwrfiuAkgIjM7oeP3QuNSVhtQOGLZG4pM+b45IeBlRXBreuK1R2Pca66ivGzkyg/Iqyt\n", + "xP41n7qS+6KUWhKRf78K90Rk74uYGIFpgQywri/SI0KZaSg2KWR9pnp9EhWDKB+rQZrVC1ycuZmk\n", + "ypIKhVBqJFUPFXYIVoVSwSTs9Tk+pjCMiEhl6Kk5rChDgEPaVyT0PF3jHGbYwfMh8qDdgWQPSIPp\n", + "wXgf+h6UdcjUIHhZ2+83O4bE1T8E/tn1Hst1xGeB3+QnJBgRkRGYfDd4+6CfgLoNZ9cgW4ZzmxCd\n", + "j7tsRj8Ch/fA/hpoEVz4ADxzAKqfUCo8zfCCHZu6PvxzcPQQBDMw6cIN58FLgDnknHU0ho0PIpKA\n", + "mXthRxl26Q7dGQc0Ia0pcgKrUfz8UYEx16Y84VHPxurJu7MwE0GodSg5FoN0mboqMNB3oMIl8I/F\n", + "u0RR6DRI90ZIuwajdNjM5OkHkNVTmJFDQm2xVJiD9behnp4hXPIhehA+OhSCXLp67obSB596GG49\n", + "DndGMKghZxX3PBe7QFzGxXFoPXj1618LvBWM/AhQSjWBb1++LyKFafijQ1DqwO4lIsthbTxBxm6Q\n", + "DAdI4GIqSJp5iipDKjJAOqQ5RsVK43tNhC7u6gZ8AuzfBnMncUsXAxx0uppGmho51cHBJ+nbpEIv\n", + "dgAeFOkk8xR1nYztc2ZcI6lM8kGGWrpPDyEZ6uRtG7N1hI3THYyxLKLDJQf8e8AwYMWClQeIMxBA\n", + "dApOPQqdO+LSjA0sDGDtr35I18WPjcvmhZeRgkCQebjxI3D3OkysxAS1x39XxPzPSvmnhlyV7wxv\n", + "L8Io3HkLOAaYKzDnQjpW9hCjQTcD+f7wnQNIz/Y5NHqObRfP0yooqgkoH1XKfomqq1KqLTI+D8Xp\n", + "DGlHo1Hw0HDZo3wucZF+mCRheCRUxEgbpk56dKcCKntgOmzT6/foallszUDzXRKNGlk7YO2TEPyG\n", + "z5QBKdMklTDxE2na+gA72SXyLVJtG2dUkfVHSLsRJh5bkcfNX4SkDau/Bm4RNnUop2D8aFxdrL6q\n", + "nU0/ZbiPmOD7Zp6jvwGeE+GP3uhtzbHw2MSvw3sTsO2rsLEXBvOwsg+OnoP+Xw4vuHtg7x545xWb\n", + "qNHl+Llb+7lCBn+44fw2pHbB5HNQ2BvflnfAzKNQScD6JrE5F8AcjOVgxIbQhbwTe1+5hjCqCwmJ\n", + "TUU3DJ12XmMZj1agmNqE7A1xc0A5E1Fw6yjfxKdNXZbx/ByoELwaujFGtjPGxAWhv9sg6ftMs8pq\n", + "IknHMbH0ZWxDCJ77PXgRKf9W6FVjBeyll5tHh9JUmdECZBVsePCNI3B4EdIurOfgRAX6T7zc619N\n", + "vBWM/BgowfvugGwHch247RYC3cKM6vRTOvpgiWoIpQSkVIZcZJMRDVt0xv2QhOrQbq4Q9fr4FWhv\n", + "QvfLsHQ7iAX5iksr1OmmoK0rEIttgyzGmoOaElSg2H8UnrhFIxFp6KGG4Sm6BuSiEPSASCJcR6Pn\n", + "JtCdGdgcIag+CglwzbjsYjpwQwWKOTjxYeBzwzLIV0XkSTg1TVyaWXhpe9urj2asvfx8DXgdCi1S\n", + "k3DfsbikAnEq9p0hbH1ARE4T670UiLVPBlcez4JtA9jbgrEsRAqMNJ3cgL4D3hXpx40piDS46wLM\n", + "duKIyNXhy/eIyFGl1IsIsiJS0Bl97wxOYYwRQ0iFPn60yapsMRZBz3Q4sAyLeRg7CYkBdGoR3ijY\n", + "WZhdrzDVabE2qqG2QvIbLuEGrD0ZK7a398O44ZPt+GxMp/DnfBJ+AzGEVlFI93JkahpBqsToeodK\n", + "SWf9wIA7vwHWf4YTH4CLGRh7Gi71YPO7EF0zZfsWAPgj4P99ExJXn4dSrIlwEvgAMYfkjYwJmNoG\n", + "e1fiuzccB3UctiVgI61Ub7jJyO2A7cN1azMXS25kHNjWh9INXBGMxAHO1IfgvT3YvgZPd+HM/tg1\n", + "5MS7ofENqHzmxcJslhu3BW8PIbNlcmEqpIPCUjoGKWxyuMqnIkW8MKITLmPqPsEAVASlLjTQ8PQE\n", + "oV5EBgEsrIDjIisB4zv2kt9IYYUO9rYQx8qS9nsUgjpjCx6WWWWtfRecvcYEdRMw/fJTOPIrcMcB\n", + "OLIWZ8C7Vfj6fvhaNSb2Ns+Df+L1Mju9nq69fwD83niYgbwAACAASURBVPDuf1BKfeZ6jeUfAxHR\n", + "p+DuCiRacNcB8CMsFZI3s2gofGwW1CqzBsz3ekgyh6YpCgMwQwMlHXr6gEwWMh+G8XGon4KV0zCb\n", + "hXwVJt2QWsHgwQNjDETD9gwStSytiRRjmT6J/V0SUYtmYoTRwEBvRtSSNko65Acgyz0ujeSxBzP0\n", + "1zYhdwzGN8k78IGzcSR/9BBs3QYWUDwiYm4q5T8Mz5N8X9f6+fdg+jZoTMQiaoXHYKLN5PILgchl\n", + "jNuQ3Q7WnXGqtpiCPiLFp6F9/+XAyY5rJ/O7YOWybFef3vo3ubAX5hNQ1KCZhdOzoJ+B2StIX4kQ\n", + "dgFn5rmqWwdIFOnvnqIQgpEQDF/HMGYQ1WdLG2AF0A4h9wQ8W4RoDrQ8qAxUDcHJJrGqPvPfCZi9\n", + "AIk+fGkWOAfVL8KlP4FEHRbHNZyxHglvg0BtwwwnUX5IOGjghDB+KUmmk6e2tIE9OaCyF8SG8peg\n", + "8hCs9oCKUqr/GpyunwqIsJ2YK/G713kobwRcLtW80YORBKSuUkYVYpVgbfyFx7wedC146DaQWSgp\n", + "WBOohDC42rCxAKUpmB92Ed5+HtrLMY/v7DhUPnXV72gVah1I+7EjxYQjOCKA4pwoelESkwAnUlh6\n", + "l1ExGIRFKk4NpwzHZmCHo9FUJXqhyYazG+/RIpxZgpsuorIeGXcNZ3Q/ySWNdNmnucNmkGhAT0hL\n", + "k2oAjc924dDVE1SOF/ila02eiIzCwYNw28oLnP2cB+9chK9oSm3+9Y9wLl4VXM/MyP1KqT8XEYOY\n", + "qfsTEYzE0TM70vCrGbhnWJyfaJDIjjDeNzFSgJkkI3m2IuFCV5E0ttAlRzvMMxGEeIkWZW2VbCri\n", + "8BaoAexegzN74MEmnK1B24wzJG53guDiYfIdlwVJEuSzcOIJ/MN5WrMpjKCOaw4ou3koD5D6JvXx\n", + "ATiwuOQzON2l6h5Duc+AW4a/VuR/A8Z78P3bYGIG9rTiyHhCg+O/IaJXlArPXY/5fQ4+WYZ3mzDp\n", + "wXoVvgTyEfC12P3yMvomNPJw8EPwnjUo1uPnPH07PJkkTjljQaoGg8ZQ5C6IGWzVFBt0uN+D3Ay4\n", + "deh+Fz5wDSXIUGLjOhARk9inwcvBr0/h5jK0UxEp3cUwFCYmoZagxoDEOpzpwM88A4//jEVmZ4ac\n", + "puNpMN5x6IQWi7kR/H01lm/z6Aygfhoyh6H/KCx9BYI/hBvyKcb6SfbVW2yM9jg1pgiCCM1cRYsK\n", + "TFUHXMjfhfv4M7iZJo0vAGWg+hpIa/+04r8G/lKpF9SD38T4W+Bfi5BRijdEABtzM9hBfL1aI87U\n", + "FmCtBPUWjF7R1ntpHOwrMoDuWXj2D+EdU/C2ShyweDo8Phu7I7wIYdw0F/HCBbrgxkJ/j2aBjIjY\n", + "Q78mHZKHwclDMAonMqBnFUkzRRgoZkKFa/pckDQzyqCowPM0Ik1Y3jtBZU2n3a7z7KiGUgX81hjt\n", + "Y32UrsEvb4+7CLQW5UqN2fyA1g2T6I0+sllhc8JGXwzpPBPQ+QxwbB0+8hgcOALrCQg3IXc07vb8\n", + "/stMaz528dCueniiF1uNvf64bsGIUupyDS+En4xWMhHJwejvJlG/NMNgXwHf6BAkDbB10uKj6xa0\n", + "NZRhofwIyxynf0nnwniDXZMLWFaChXyIz4CkUhRdsEtxMIIGR9ZhcR7Wn4KbLNixBX0rSeV9IY1U\n", + "gcDZCc0VKNxMu2njRAnSnVGC/BaRfY6i8pl3obEGzSZUqtD4hIc6uX5FK6fI9D1wZhqYgf3N+Aca\n", + "AVEEt25A/V7gugQjSqnzXCU/LFJ8Cp68A+5YiclVvgZPzsZy5LdXoThMw5oRvGMFlm8WkQeUUs0E\n", + "eHPw/WfhkMBICFEKVubgRIXKn0OlTry47YSlj8FeeYHA1bPgQgjRck7kffNwdxr0JkyNQGoEtVik\n", + "bTUxxjKkNUFwcUODlqMxfjxi7dPw1d+zSNw6wYxvEgQmTujhhR561iZImJzMTWB6G+x+OuIXTsCJ\n", + "98LROag3oZgTJjUTlYBwWii6HlObZeqqhG4psF2OZw5Qe86EcAvqwPG3gpBXDhHyxNoiR673WN4I\n", + "UIqqCE8Qe9V89nqPR0R2wvaPwM5kbDx3sQR2Eg5sxGKG3/1l2P0s7LgI60U4qqB+JeGyAzRASrBa\n", + "ite6bgS7HoL1GREpXNbiUEp1RSYWYvmC/cOM8MBI8LW7Sqwli/AvO9DURb4Ghf3wtnfA4VWwvwDP\n", + "/BZkDANxp0E6aEkHX2wSZkhg6NSUgatNkSwJowR0xkt0t3bgPLKGmjwC31mF/QdgfBL6KXBTkFml\n", + "71dYX1ynMLGGlME5Ac4nlVJnr5qnLzwG7zsHb7dA78JWBf5SKfVybrsNqAkE8kKTAsB6AfzX3KH3\n", + "WngjcEb+BfATIik98uE0pfsOUpu5iUzFRKjT3HmGoNRBU/OElo3uJTE2t3Ane5j2JKmlt9P+5tM8\n", + "90+WyO7uMm4pbvAgFcJcD1YNGFhQ3Qbzl+Lr5YlvwqO3wcl9EM1tsbVnG8F6AgoJWGzB+H6wu7i1\n", + "cdyNdchn0fwmyfkqqcfg3Ssw3YXH5uCxKaXax178OaoPwNH/Fvaa8Y/T12GzFCu4z22BMXVdpvdl\n", + "0b4fnjJg+UicZt0iVkPM3flisSOII/2RkJhD0uzDcR/edi98rwsJK3ZJ1r4Qm3NtXi7niMg5OPs4\n", + "OO+AXQH4EsdEK39XgDuOwD23w1oKgqNwiw2JBnRGCJZKVLI6KX2ASA+as2TWUmwUVinuhh3rGVrN\n", + "NKWGTzfdprndYIeeI+c0qSR0eilYyiTYuH3AsxHsPwe1AyA7YNuKojXjY5cMUBnsVAKtlsU45dAd\n", + "SdNduREuuSAPQHITPvNWIPIj4/eBbyn12naJ/YThr4hLVtc1GBGRNMz/NvxCDyZq8TW6eBjqCZhZ\n", + "gHufhJOr8NSt8OQWOEeh9dhlz6wh9FjW/cA3oDkS8+N3NyHhQ3obkOR54j5A7Svw8O9BZQ5GgxRP\n", + "HD5AJX0PwTdGoF+FzHfhn5+laMK7T76wcXE3oTQ+QKIGtlWg6rXpWyE3CBRCA+VrtFSLNWWSdfIo\n", + "+yYGtXMwPQa5JXjvKGRNUAlo9cFKgL0fumn6GwX6F47G2d6j1zLuG65jXxORB4hr7v0ftBbEBPzi\n", + "k/DInXDbRpz92cjBk0WofP7HPnn/CLzmwUjcLvWSL/WmUuojIvIO4GeJlf+u9do/ueLu95RS33tN\n", + "BvkKICIFmL91mtAaw3ANtEgQNUJxaZatXc8huk0Q5AkHHn5hCy1MUlqcobzZg1veT3TpEUJzkdEp\n", + "jVSlgTvmEg7g8BY8nofWDGy/BBUNWITqElj/PRxZ7HDzqQWO3rGN2vYFBroN6RbYU7CRBieEnCJr\n", + "ZigswZ7lWPgK4PAGnH3HMEvwfPZJqfCiiPZJkP8D8iUggPTJeHexVgB//VpzcL0w7OD5ooh8l1iZ\n", + "tQX0ILUdNvKw/YrFJBy6ZNIk/ufhJ2C/C7Oz0C5D4QSkNuELVxJyh6nXr8BzR+HcDgh98C8A3hj8\n", + "8l2wYsYEWJIgu6D1BGgXwZ+ArTwDq45kPcz6blonx/HdNcYPKKY2LSpuQKAG9KyIaaWTNQIiT8dL\n", + "WUxGfSLxMX2Ym4FnJ0BrwaQJjpvFHKRR9QKBlcWK+jRSLoMdZfiLDjy8BTN9qPtwZthV9BZeIUQw\n", + "gf+GWOjsLbyAvwP+gwjbleK67JKH2A17EjAxFNqrT8a+dSM9uDQHe2pw4ybI0/Ctp5RqvURVWCnl\n", + "iUyvxRLv81fw31oJ2HKAxlXPr4vIx6G8B8wbtuFOfwCeTQxFDyegvx/UGmquh34izp4evRtmNSiW\n", + "oaCatCybCymL2UGAUfIgABGLEl1sJmg3CwTdPORHQPdhfQXS2wEX8jVQPXDHYdEHFUAqiLOeay/v\n", + "IPzC5wW8IZ3gh6D9DXi6B5fuHsY+Vah8Uim1+MNf++rjNQ9GhqqN9179+FCK+/8CfunlIjil1J+8\n", + "tqP7kWCBliggCpLtAfZIBmugoQfjmOUkHapst9YYPx+QX0mzdXCchcY0oS2QiMBtYeYEQ1Kk7HH0\n", + "yga1UkTBgLRAD/jePotlfwL+uIO1q8cNKuLQE5Dw1xj5dp2H+2WWbsrgV1OwlQGnCsUI6gH6SAcj\n", + "gFH7hSGnAjB04vP8olKYUtFTIsX/BNU74bZlyPpQycJTJai8xLfljYA4mhdzBH4uA4dsypkGD80o\n", + "7nsGZjpgG/D0LFSfuiL12hCR/1iHIwXYY0O9PSTlikhp2K59+fiKuCb9fCuviMyOAGZcx0LivzeI\n", + "CTbmJJyfAicJgUIZB/G+ngTvcTggmKIYb+sEVY+LIx4JA8ZCD9f06aSS4EAytMmZAek+zHfiltxH\n", + "JmHnurCcSzOayDNVsXHSLWojwmYwS3TMg9ORUs8Bz71+Z+CnDr8KLCj15vGheSVQioEInyPOjvzv\n", + "13EoVkzRuozQiksKWgBh8oXHUz5YuZc/TPmb8Ojvx8JoMy2oZ+GZAlQ+dy0l4uEm5aSIuLNwJPGC\n", + "+jIA49Cw6A3f7/wMzGZg9zo8XgSiiD0nBmwecUjq4JQDCvUQY8QEMcnkPS5a8/T6KUgIqD4MdsHj\n", + "a3DfFNACbS+cz4JzBkoDaGzGa1JbRG4CSYDaUEptXDkuidXdDo/Be7bDyJTISgW+o5RauNasDDeo\n", + "D4rIw8SGme71zKxezzLN/0LsC/J3wyDu516vFqJ/JBrQb7ZI7pqlUN3CKUR4KQvoE0Y60UWXxS+F\n", + "2BnQUkKtdwCvp4NWQ58tk8p5aMUuoWHTmS+QLBuohse6grNpaLXzNNL3EtQOQvmLZA52CEo1Hnuv\n", + "z75HYHt7wG/cv8nfeKOcj56A7dsgm4oJSxcWse9rsOP4i0mey0Xor738vLa/Ckd7sHgXJAzoNaD8\n", + "l0qpS6/LjP6IEJHiHPzBnWDsgQ0HzO9wMXuSxi0+owvg+tD4LvQevvJ1w8DkQZHUAOZ+AXbvif/n\n", + "khJJf1Up+wf10XeaIEEsT6sAJuHcxbg3UCtBowz7p8CehKeTQ0n5VXAi3CqU7Cbbz25j5UAAiT5G\n", + "CEYUEtlChgqNrE/P1/FSIY1k7KrjCtRbFvmLORbzLuWkhqgRutVZmke1eFt3DYXct/BKIYIG/I/D\n", + "21t4KT4B/I0If6oUP3A3/hpiE5YFDg95XNk6dPXYTiV3xRq1koX6S1pbL2No4vkfof5OSM2DV4bq\n", + "51/BOtceqqS9iObpQegzWIczE9Afh1knHt9oFdYbsJaD6kARNOHur8DW9pDaezyinMa62kXFHsDM\n", + "OSgugTMBD98BFx+GERd2R+BdgqwDE+fAbcOJOjwG8/9dnClKAcsiUjwK7S9fFmTMwD03ws/fBpVR\n", + "WF2D0uPwzwyRTwQ/4LMOX/+6OPP+IFxPAuu/uF7v/Y9BLANu/HWZ4s0jRGPjjC5U6Mx41EdWicpL\n", + "8HGlwudFt0Rk8mn4pzNwWJHYngFl4qoCDS3CKjSxcz7pNahswubHLbqP3Ak/fwus+aD1CYo9erMG\n", + "xXmf0yPx9e/tx1xGLm7A5zcgtwpvS0PBh2oF/9/A+jvh4ljMLq8U4KgB5Zet+w53BQ+IyPeI64z2\n", + "G5lzkIVbb4HEgaE0exa8D8Ez0Jg7RuP/AxZfznNFRGbg0AfhF9fjjBHATQZ89YMisjTM4L0ESqlu\n", + "UeTJf4A7b4fVJIQKvBU4dx7OVsFw4Og8JA+AdxqmzkFiCb4NzRZ86zc9JnIbTJhJyrrPIjb7j4ZM\n", + "bKRpvyePZ+tsZEYxZyuUx6qMroL9V7DSdJn7OQvp7cdY7tAprTMYXeSG2Q6yr4WdEkkuK+W8tav/\n", + "x+GXiUXOvn69B/IGxVFiG4T38DJO3a81lFIbcav+d2+Hg3WwHLjowlYW7mxANROvd6dXIHrZYOTy\n", + "sYDPXf24iExDeh9oBvQuACuX10ClVHVU5MxTsP8IrJsQbcUu3oUug/8bHnwHpA6ANQqNbtzAcuMC\n", + "NBPw4E1xZfegCTvPRhTXPZ78UIq17Bojc+tkTRtXSrS7Ac6uS7BxJxz9ezCqUNP/f/beOzqu68rT\n", + "/XblQhWqgELOIAACBHMmFShRWbYcJGfZbdnu5Ncz73WvsfvNmuk30+3uWT0zr8PMtKdf2/2m3XZb\n", + "cpZkS5aVAyVKpJgzGEAEImdUzlVn/jgXUhEEkxgAUvWtxSWhwr2n6ta9d599fvu3IRSA/ii8DfRB\n", + "3R8b2hnjOrUGeH0DvNsNHBQRRyPcvRX6nUYWvB78JlBTuhvzd67agblGLAQB6w2DUuljIvLNY9j/\n", + "Dw9qhYOURVCjBXB0EWxxiyQj8LbSjIrI/xyk4J/qscV9FBQ2YJck8fQwfdYoWSkkFk8ROhoj8e0i\n", + "+FSVXqthN5aWDA1WE3VpB6WpGJ4EjFXCttugfzdw1Ihm384dn4gch7FbwVYB0WMwvUMpNXLxz6VS\n", + "wDVvEX2leKCl6iyxmaYGOADuCzd/cy+FJan3AxGAgjS0paG3nQs0gAvAC3sg0Q23FoApCLFx+FFc\n", + "qb2g++VMQ1MfLM1AKgDHlFJ9AB6R28twLXZg6/cR2+chHtpNfF2QwiVuMl4vKXM9priJuKOAjDXO\n", + "mDVI6BVgCI6d6cfxh1ZGa4IUOE2sHM7glDDOHlh0Al77tIhMztca742KkRX5M+Dff5hNzi6EUigR\n", + "vocW+M5LMKIJPAM7u6FrE5gcMP1tSKUhuEwnK6eeh/i+D+IMLeLeAssehNa0dl7vuhu63xWRX88E\n", + "JFPw1A64/ySsc4ApAIExeFwp1SEih4C3wfz78EAfVIQs7Gwu4fgaL+OWNLETgzy1KkHlIGTFxBBp\n", + "SlJOqsedWGPFpAtThLwpuio7iW2YgGNjsGsM/jlXzyYirbqaqDzH68gELJ3Q3wsHAV8pmJ2zluNr\n", + "IeCAehGxqAXeYTsfjFwmSqmTIvINF/zrZdqg64zRrMDyOnx0nxZEHTNeG/aI21NGRciKJZsl5bJh\n", + "U/VI2MmIw4z/oIKp/VAeg4mgvjP6eylqKaF+yE4qNs5gM8SdICkYL4KRX+b2SZk1tjPk9I4REdPs\n", + "xnI3MnGYCEBZpRG0zWBEJxfxRLA6wDrH92bNgsVx7uPvY5zEL4vIm+gcaWhWr5oscNr49x4iUtIO\n", + "ZZ8l8rwpZ3jFBIOvE/zqSgr8JVhMWtdjwkPSOkysKqiV8FnggIh8/Rg8Yqblaxa8oTi+3iw1fWBL\n", + "w4owDG4E8sHI5fEw+azIpfA48OciVCl1dsfb64VxHsyljTqff8YlISLlsPQB+PgAOIxzuV3gxc2w\n", + "5zjQaew/DjwrIi+jK2+CM9dTI2A5JmL+B3juM+BsbmB05WKSo83EdvvAf4JA+WsEomE4VkzRGhPV\n", + "oWqcIQCFORLE5Buj2GMiVngQ3knCG3M4XVu0pGM2tozWjwAQCYEpo32U3guwp8GR0hmueV+GuRj5\n", + "YOSDUVULlRtzbvxOSK+BiQG4AyMYAciSCmfI2JzYsk4cQROismTFRNZagMls1wUahSE4eBTu8IE7\n", + "haXQRtZiQaEwnQTvbnDEwOvBaNI0g2HEVYReYokYj3mh+B6oXw1KiRTvB//rM9UW2mjO1AYlKyCb\n", + "hslD6LbyC3qWOAW7D8PaCrAX6ZsJ3VDSpatr5hRpvc/0Kei5TXeHn1kBzgI9Dgh2Xsr+jYvE5Vji\n", + "u4u1x/xZlEDUjPgKsYwOYHFMYrNB1lKGJWzWF5clwE5jn0kROZmhcW+SdYb1td8D/XUQ8YHJKyLP\n", + "5R1WLw0RLMBfAP8unxW5MEoxLcJP0PYLfzbf47m62FqgJft+IAJa97E4At0rMIKRGYygZE7tnVKZ\n", + "kyLyV6XwjTZIjePwnKJsi4CqJNRXTTzSB0HBbBas6RkNiiDKiTkSoCCehmNJ2D67nYXBoL7VLKqE\n", + "eBUoCxQMwYAV/C8b4wv4RI7sh+XroN8EJMC8F6om4Zm5ru26dJpGdDuNvhnR/3yRD0Y+GC4v54q6\n", + "iiFmBp9258MC2MB8eIKJzXZKsiksVhOoONOmKJlgAwQ6dYHGpFJq3CzykxD8mSLckGDClMAZS+M+\n", + "rdvfqAxMOzBKVgFECjZB/X1QbIMwIsUHwP86VP8OrKmEwiJIlsPUBjhyi4j8KZAB3xe0FXBzENJm\n", + "OLkOTr4N/OZ6fYEfBKVUv03k59PwW2XgyEJ4HAZHdD+diy0zdcGpw2BdCS1+/VBnEZw+yBVmFkTE\n", + "BLY1UHIbmN0Q6YDp7cD0+CzxK3pnFUHMpv1YGxw0iAurWJDUEOHSEN0I0TaMYMRgHAZF/+RGKyG4\n", + "EUqzEHPqbsG2PxCRfwGmzpc1y/Mev402qlnQv/UFxP8E3hDhPy/05nmXh0nOdR8FfTl+vyxWn9tY\n", + "geRFJmsFWSwbjlK8TNFssuMKWzEPjBCsj3LMEiK0z0ncFCPhGSJbXoQ56MQUTJAxxwlIAg6drzRf\n", + "VxEWxOHdT0N7AApj0N0OR85A9D0PqWl49l0wdcGyIsiOA2Pwehx2z96mTaS9ET7XBFYzqF7AKfKb\n", + "mFLvXtLXdw3IByOXgIhYrLC2DDahc/qd/TpPftZNphdKA5itUP0nJrKtboK+OkIjEyTCZxhxlYDN\n", + "gSRjmP0erJMTRLJDWv8xCuCC2mVw2kS49zij6zy0BIrJWvo5dEuSqV4Yf3rmpitiXgZrHtFW6IVJ\n", + "7aS3dy1sb4OWCnA3Q0UWCiO6yiSzBXZ9GdI7oX0p3Nv7/idcNAHJW0XkoFJqQXmM5CIilVVwTwUk\n", + "s2CbBPMU7FKzmtjNhRYgy89hx1HoXANKwcRvIHtcKZUVkSIP3FqodR/hMdiRhSOXli3yfBRW3Aar\n", + "xsDth56VsGsZ9H1nDHa+BVs26BaYyS7wvYXvljCuERO+hhKcJhsQJmPL4EkIlZkyurca69aTxtgH\n", + "RXyH4c21ULQUWqIwZYfhELSfhFO3g2kDSIeIdw8EX1/glWnzguG2+ufAQ/msyKWhFMdFOAR8Hm2G\n", + "dpMQ74bTZliW02YiC3T4nEwU1Yp8M4apUvA5FF4/xMdFzC/N1SZDTz4rvhzC7rFSLV4apyFjThFY\n", + "5KSkc5S6YkVX0zRVZiuJzDjuVBSKLIRLI4yHUky/GYYn5xqliNi98JVaCh+0M+2fZIc3jJs0TTug\n", + "BZhoxFjCMrIqPxGRYsANTCulwnNs09sMX/gYTM40JV0Llufh4yIyqM7v2npNyQcjF0H0kf3cKli+\n", + "FMYtkD0Nm3aD91Vo3qA9iOM9ULIdy4oQ64agNVzOWKmHVCzGyco1DO88g3PVSaw2sAULSZhMhPoj\n", + "8MsIvGXsx1SnnT4HCyBdQb//KP62IHafi6QnSegZpbI5EW7F3bB+XAcioOvvN/ZDx71gN0Ol0RES\n", + "dMFHy6QWaMWT0DQrArcoaMrAqUaMSpWFhojYauAr94NqMJbHImB9CT4lIhOXIuI0sgZHyOnUaWy7\n", + "qBa+vkHX/U1GwXUEHj2mtbHnGCnNem8JtG+Gu3vfd2NcNgLZaghsDhB4aR+Eu2GLDRyTiC3Asg7I\n", + "jMShSmG2xbCkTWQsEFVZHGMezD4bmXXAy+/vafpp2JGExrUwlgXXINQNac3Ihqy2xm4eh0O3wp5y\n", + "EfmXhb7sNg/8R+Alpdg/3wO5wfg74C9FePxmCeKUUsMi7tfhubuhNQmWDJwo9nGk9HZotGDyTVC6\n", + "ZAJHpovqzgTL/bDjKyLm7yuVmb2s2wCNlSksQyEcdQ6Sdhu2RAYn4wQWxSjrgtCKJB97Ksux9SbG\n", + "l0aIFGeJZmD0ZUj/m/Nldr1w/3LY5KYk4KBoWqEGBwj5jhK1J2kbhK4VzNLTGN5J03NtD8AKbW3a\n", + "luC9CYsT0u2Q6IeVMD9Gd/lg5OLUN8GyO6B3Jqm3EfqTYHoLOvug1AwlERiZon4IHjjm5OBWL6aI\n", + "GXM2RY39NGOti4gEi6B8FNPkBNntQfj7WbNXs1mrLNMAzTDZTGgHhHgGaqfPWUqwlEHFwNmPmQBn\n", + "RJsEemZpKKIm8MRgsqGAfcvNdETD1Awp2od0hUkGyCzkFH9TMxQ2QN/MAy5IrYDwEGzgCpZaCmHT\n", + "eihYZQRiRZAoh/A03CYiu5RSUxd4ezP47LpPTi51k+BeopT/eeAtEXkbsELhVqjZCIF4kmRfGMrN\n", + "ZGxp4mkHI6l6olYPmWoFjzlFnHZIOaHcBX0RUsd1F+AHjO9gx3JoRncwnnbq47i5D8ZaYLKWebqo\n", + "LERE2AB8GX2xzXN5vAj8F+Cj3ETLW0qFXxORTuhZCmarnWnPLbBkKYwepHB1MZUjRUg2wnDjGZZ1\n", + "w6ZpGL+PWXoSwAMlChiP4hwYwuG0EvFkMWXjFI6DfxKKLeCOpmneZyMQqSFQW4rFFMPcFCD9hyLy\n", + "uNJd0t9DRBxNsH4xDA+jKgEEoRpnsJ/ONVFGaiAwICK7uAzNnwUcjjlkBk5IWuEC5nHXlnwwchEc\n", + "UFsPmdmri3UQKILUoFJ/AyAibdBg/GAGq9NMFNnJmtKEiqtQahNsH4boarK7u6Bopxa6vjfzVUql\n", + "ykW6eqCqWVv/AjAFzgktWp04ewTJAd3UyJ2AkAN8US2cTozDQI2uwa8yMiCTThhIQ9LdSmJxKSOV\n", + "DkonpzhS0cWZhhB37IVTYtifL1Scc50lHohZofhKNuyB9vpZttAWULWgTkAVs54DEBFfGTzcDGuS\n", + "dKwKMV3vZ/1BaDKOXdAJ6feOo6HAT4iYh2DMDu39Wd6dzlBi81AcynCgoRUVchGLuGDSB9Md8P/4\n", + "YO9y6B6BpkOQ7KMvBf1ebYEfLwFfDCa84MxJH1cqoIR8MAKACHa0ide/UYqxi70+z9koRVaE/wT8\n", + "qQjP3yzZEQCjBL8PoEbkDxpgKgIFunDGlBW0M+cZxr2wagBsdXNUKE7BiMCtg3CoLcXa6RSLe2DS\n", + "C70T0B2GAq+PJ++z4S+vIFxdgXvYjHvKgUx7dIb3iyLybWPJWDB87+1gLoPxEfxZRaEZRKWYWFRG\n", + "pKSQmKok3jcIv31Cl1+/cimfOQZnzoBlOWerElvtLgAAIABJREFUZs6AZxI6zve+a00+GLkISYhG\n", + "5lA6RcGR5KyW4yGYNguHa6sZ9S7BLlZIjJC2NJJJD0FNFMIlEFoN0ydgs4i8lis4HIeX34HfjUJV\n", + "FQSmwXUQCowGaLNqxEe3wyt/CTVuKErCcRME/TD1U4i8CW98A+qtesYei4B1uJix5k/Bs30EpieR\n", + "1kq82Qwji47yZEIx9V11doOphcbYAMg6zj4YA+ANwIHzvelSSEMoDCW+WZVKUa1mO0d7ISLWKvja\n", + "neBshqOHiJeHibtP8s6tw7jeAG8MDvtg9Nfn7i17Co5Pgs8LLa8F2PfJFMnaRUzbnCRjDhJTJ7Co\n", + "CYruseGydBPfbCKg7iB+tBB8LzAxNc3LhdBWDyEbnCoDVx8055QVTwln/zY/7HwbOMEC6EJ7A/M0\n", + "Wm/zADpTctORhlAEvOUQUyRNWg4oxkXBlobxAkhPz2GV0A993VC5CGp3wZ7VYK3Wq/qTu2H05Tps\n", + "f7mYurifjGMpDr8i7h0hVFxP/OdVMFUL9SNQKyIxqPgslFeBRXo5s+44U/trCR4YoH9tCofXQajM\n", + "gko0Eju8BE4sB1MM7jQ0fxfVzwF9XXDodVizBKYskDkNJcegN6vPk3khH4xchCx0noJkC7jKDS+L\n", + "CFiPgd3PWWvPwzDQ42Xqs424ziTILkqScJlJmatQEz1Q44BXCiCeBcxaoW0mp/5bOw7Kd6ZgUwE0\n", + "JqFzAt6dMdA6m+I2aByFiiSY3DpFn1CQmILMOzCUgfj9UAZkonDGtIbwMQdkW8l0+JkcmGaq1IFy\n", + "jsDpMcPAa6GilBr0iRzeDqtWwKgDUl1QfgCiUe0W+YEZh51H4csVEJrpQ3FGWzUHYM5uri2LoXiJ\n", + "MaNaTGzXaYY31mKvmuCltSmkG4ZfYI4TWymVEJHvw+v3g3dFmuzLQUZqCkg2OqDvDGbGaKvxUJwu\n", + "wByNIalhAo1v05HdSuKoF2qn6f8rGFwE5iYI3wf3ndYXyyxwogJ6xoDeK/lObhZE+DqwBdh0M83o\n", + "rzdGduTP0dqRl+fRIv6aMQa7jsCy+yHgIdwfxF+XxhEdxpKACj+8Ww0T57i4KqWUiPwEdtwD3vVg\n", + "PgF+P0y9Bhwqgc9tJLk7yVDzJBSaMKetpJSPRMgKSYACHfm4ofrzcI8FmvsBYpywbuetO7cy9EYr\n", + "gdc7CHxkAqYbYFu7biuOFbKNQAfUA5ci5lci8tQObeu9UXQhwI4EHPgg5nFXi3wwchGUUmEReeLX\n", + "8Gg9+KwgfZAZhF8ppQZyXqdE5Gd2LA+ZKbRlMY8miRRFSdj9ei0ulEJMHVhXJ0gmwnBq9oE3SoKz\n", + "ftg2PYcKOud1bmhZB3cc1KLJpBUsaai3wdgWGNihVOhFEdkJfWXoGX+JBT43s40iCBahgj3gY45l\n", + "iIXINDy1E/pOwa0C7jDs9+va/OCVbDcLxzvg1WndYEpFwXQG/MPwxFyuhVYoKslZc/VCeA2xN04R\n", + "q+vC75+C786o2I1aficQmNmWUsoP/FxEfoXOvvjC8H8ugv59FD/ooiaYIVI/SdqTwDbqoio8xHBj\n", + "gJHOrA6WokplDgOHRcwnIPYwlBRDwgST3UbV1ULW/1wXRPgt4E+BrUrlM0VXgV+guxx/Fb3sdVOh\n", + "lOp0i7wQhPtqSE1NMuAbpMA3TfUReKYYxn8NyYPneW8MeE5EXgLMuXrAWpHKGhgrItY3DUSgtRJT\n", + "OA3EwBWHwKAORpyw2AvNOZPPJV0BAvZXmfIWE08loWc1HFw3S7eSBtQs99XZiEiRMVa/cX1YUI02\n", + "5y0YEZHHgN8B7MD/r5RasD9upVS3iPx1v448zehWzueYTCmlQtUir1cx7SmCuBuiJ6DyFGwFS52V\n", + "ylAck6mbmH2c9ISIuGa2YxZpq4FP+MATB0pFOibh13OVZgEu8ChdBQNgN5TYRQmwlfN+B8YAhkGp\n", + "iAROa8W0Y0ZFnQY5Ad5x+NXV/cauDcbNfCdne3Bcje0q4DUR2dupNSIJtAnQnDf0FEyO6t/Be5h0\n", + "EJNJwH4jgHUUw4PNsLYAxA8xu8gLCaXeW1LKCUaHvSJ7XoPb41i9WTJFMeyeCNasUFQwSqjNhX3y\n", + "CNQF4c2z3V8zJ0Tkr2GgBEipnC7EH1ZEEOD/Bv4IuE+pcwSHeT4AhkX8HwHPiPCkUlzRJGAhElbq\n", + "LRE5eBqqIZOE0CScdAD+OZxRz2Gu1hox6BuD5TEotuIp7tJthh0JUvY46bUHSDmG4TkQExTPkb2r\n", + "HYhQNBlWw98XkTY/fDXXVsIP9k4diMxp/CgilRXwSLuuDqRSZHAUfnkprUKuJ/OZGfmxUuqHhqnM\n", + "bhZ4pG3cOE5f7HWj8MoB+MrtELFApgYmD2Czj1HebcXjj+GdirG8C4a9sO1WdKO6+qXw2N0wXgr9\n", + "GZAj0PYOFIrI/5pDJe2HyQxELbq/ygwjbohNYKT+Zo0/bBP52a/h84vBYgfVDXJG97c5p3b+w0hu\n", + "8HYRurtg6CDULIchE6geKDkE6YixdOeDhzfBsnUwYAHlB/s2+JxZJJpR6pzvOwjP7oEeK/HbBIs9\n", + "SU2HGbxOsGQR+wTx+ig86Z+jT4gRnOSFmYAIi9EakTJgs1J5Ee/VRCn2iPAsutz3a/M9nmuBkWnN\n", + "DbSuyJl0CnbuhQ3VuNZ7qZs0kw2cYKJxCnsoTkE2zNBhSL0FapE2N1w9awsjHgjNSAJOnYDtUbht\n", + "EWSTIKch06+NH8/J/omIux5+5y7ILDKWlXvA9wb8tiGYPW8G/nozn117Z26idi7aV+TGIaPUCavI\n", + "E+PwgBvqwuAcpfZkhi/ueD+TAToBcmA98Eop3LoGoqUQBRBQK2C4D+rHoY6cclaY0R24X4c3Pwob\n", + "R6AkBkOFsLMURs/rL5FU6riI/G03NAtYFfQvtOj4RkAplRaRH74J9x+ClSYwhbRQ4wWllF9ESpbC\n", + "8g3QNyO2LYLEBpgchrtFpHO2CM5Q0R9LYjsI6UbwhNJ4hkKMF0NvEdgGY3o2E73+n3jhI4IL+BPg\n", + "68D/C/ydUucG5XmuCn8MHBDh00rx1HwPZqGjlBoRkZdG8awqJOZJY8oEWLIrwS3HIW6FJ0uVGlQi\n", + "cga6e2FXA6wc1r1nOsvhUAIi+4xtKeB5Edl/DGqVXrbtOt9StR2WLQXHopzKukUwNQp1w7CUOdxZ\n", + "54t51YwY9uS/B/yH+RzH1Sal1DER6UBrBSqg7GtnByIAWcHQHdihshRCMbAcgsUBaAIsCZ3hWMSs\n", + "YEQTeRsORGHgLrCWQWIERn8wl0NgLkb0POe6Z55Lx/genxKRX6PXiHMrcTy+WT1pEmDug2oLrKqH\n", + "6nKRU+PwqlIqtwGZAsc4FI3C3iWQLQKJQMU+8KKTZnlyMZZkHgb+B7ADWKXUwjTuu1lQirAIXwSe\n", + "F+GMUixo8fsCYTBE8/4Qm0d1w067cS5HbZBxloh8pg5WKiZNk7yajHGoWt8zIsdh8pXZfWOMSeRF\n", + "J5IuKPfNURFYDIlCqLhKn+2qcM2DERGp4NySuhGl1KNKqb8Qkf+KXq9/anbKSES+lfPnNqXUtms7\n", + "2quHEcFGRWQABmPa96M8JwN0vAL8bwDEYGAUlgxDUzlUrIGAFTJ7tZnEQyJyZLbxlrH9fcA+ETHn\n", + "BYvzw3nU5/7xWR0034U1LmjeDCPLoL8L6nfC74nId2bK8bRlve8gqJVw7+va4t+i4EwRTMQ5x2vm\n", + "w40IjcDfo4P3ryrFG/M7og8PxnLN7wK/FuERpZi3niY3CP3Ql4S1ZnDnXDOOVJUy5roTrEt0CaQc\n", + "I1W1i6HhMfinS9GpXIgwDI3DxtZZj0+APQxDV7Ltq801D0aMvit3zX5cRGzGhTyFzhDIHO/91rUe\n", + "37VGKZUSkZ/Bi49BezG40zBgh1N9ENkBMAXv7IAtTdCwTP8gTWNQ7IXu9RANaIfRly6wj3wgsoBQ\n", + "Sk0Xiex7B9avh8EpcGVgUSEkiuGYCVgM4wndUXMzkONHMv0q7KiDqXqoTMC0DY7HYeSJvL27RgQr\n", + "8A20SPVvgU/ll2SuP0rxjAhpdEDyN8B/zx+HudFL6+afwW++BO0CrjT024VDiTWozAoYBl15sA4G\n", + "pqFhTAfZx69kv0no6IC7fFDeapT9noKyDggk59HgbC7mc5nm34vIVrRm5KdziW9uFoxqnP8Og0vB\n", + "7oFgH9CZU+o5LCIv1UPrCSjOgrJDzyI47gd7oV6qOS8iUlIAyx3g8UNXVm/7Yl1s81xDAvDcbgid\n", + "hlvTUN0AWS/sLM/JblSD360vOO+hlAqKyHdhrBU8NRCZhNTx8zS8qnFDuwVsfi1C7pnDkOmmQoT1\n", + "wPfQF++NSs1dQZDn+qAUvxFhE1rQ+kcifA9tkHYw7+tyNkplTonI/4DBdrAVQrC3BFZXz3F9r4Jk\n", + "oa7su6JgRCkVE5HvvwYP7oElAEE4MQEvzlpafg8RsQAtxdCSgHAUOmZb1V8L5lPA+udoR78PBcaa\n", + "34VKUjsV7GuEEQtkLIb51jT44hew9TaLLFkMX1wKqgBSA7D5BPQZjdLynVvnCSMYfFVEtgGtNfDF\n", + "ShjNfc00FCTmMFUzUrPnNPTLxSVy5wq4vxWSFl0ZtaUT9orIL2/GgESEAuAv0P1lvgn8KH+zWxgY\n", + "AeHHRViOrrD5BWAT4SngJ8Ce/LHSGKX3O2b+dovU+LWQ9Cz8YImB/yrtcxL4kYg4jL/Pe18QEVsJ\n", + "fHEJLK6HWBwsHXCvXeQXCaWuqSfJOTbneeaNnm6Y7ANPTiDiOAzOKdg11xtExF4Hn/0oTKyBwTYY\n", + "uwfOrIP6Ath0fYefZy6M7NeJPhg9rttcABAA+yEonPgAnikiUt4I9z0EAytguB1GPgI9S2A9MHt5\n", + "+IZGBLMIX0G72VYBy5XiifzNbeGhFEeV4pvAYuBBdHnsE8AREb4qgm1eB7gAicChY6BGwT3zWB8U\n", + "nYR4+ipbLiil4heboFph9WpovQ/OtMHYKhj6GIzUwCMi4rqa45lN3oF1gTBTLvoqfOYw1NlBjUHC\n", + "6EtzvsxIXS3YimeppVth7AisA9689iPPczGMst0nXodPH4UGpz62yRH4uVLqsrsNW6GpBZQjp5WA\n", + "oUMJnoYVzGN/iauFCA7gi2htSBD4glLvzyjzLFyMQLED+DMRvgXci9b3/CcR1iiVF2LPoJSaFJEf\n", + "xuAz5VCbBcZgynB/vu6WF2WwbvEsoXwhJBeBpQcauIY6k3wwsoAw0mn/KCJlaC3TeF77cXNgpGf/\n", + "SURK0Tqp8avdB0LNIQK/kRDBAtwJfBb4FLAXvSTzcj4TcmNiHLdXgFdEWJIPRM7F0BT+7aDOnGaB\n", + "sQUqVr+mY8oHIwsQdWmdFwH6+yE5Bc7cjrMnoWwKXr5Gw8tzBSilrvhinIKuTpClYJ7JjmSBTr3s\n", + "c/iKBzl//Ft0EPILtHtqXpx6E6HUjZ+xu1YYFZHDF33hNWYc9p2ChyvhPcF8CGw92m5+Dr+rq4cs\n", + "zAAMREQppW7omd71wCzS1qwFR+KGZD84T0LvODx+owlY88f80nGLbFkED7ZBygzZbnB2wp6AbuB4\n", + "QwlYZ467CKabsRtsnrnJn+8LD0PA+mgrtDVALAaWE2DqgSevhoD1Qsd8QQcj8z2GPHny5MmTJ8/V\n", + "43zByIJepslHzZeHiIgN1pTBvU4ojEN4HF5LwD6llHKK3Ho7PHR7TjlpCGxPQ2kP/PV8CKZmjX/B\n", + "zpREpHIZ/F+f0I517y2NvAyL3oV/UUqdyHmt2GC1cRw8s4/DvH2IBcpCPu4Xwyay8Q54eAv0zjwW\n", + "AevPYHkC+gqhIA7RCdgWh103WtbqWnIjH/c8H4wLJRkWdDCS5/Kww/oV8OlbYLgE/FPgfBc+fUS3\n", + "u9/lg7Wts5TSSTB7dYfTDSLyZv5mOTc2aGqGjH1WBUuLNjY7q4LFDuuM4zBSAv2zj8OVjkVEzECt\n", + "HhZD8x1EfpgphTUtMJn7WABK62GFG4KbocsP9t3wicPggCu3rBeRYvQ5G0Ef//w5m+eGJx+M3CSI\n", + "iLkW7r0dBosgAeCD2BYYHIZ7RWRfFaiZiosMyC5YGocWL3iWgWkclonIj5RSV8Vs52ZCna9lAYjK\n", + "UZkbx+G+22HofMchp2P1ZSMi1dXwpTrw2EENAE6R52NK5XuDzA9nRQIKCMBSn+6AFgXdsXkL9A/B\n", + "nSLy7vmcLy+GiJi98FAbbKyCrB9Mg9AvIj85X9fWPHluFObN9ExElonIOyLyloh8Z77GcRPhKgTn\n", + "zA1whkJIevQM2j0Be05CKcBhqLNB62YIVcD0J+DoXVBcDp8XkXzqdBYzFSyxnAA+A9IJ7smzK1gK\n", + "3Oc/Dnb9vx8MEbHVwmMfAT4C/XfDwGdgZAl8UkSaLrqBPFedSdg3c04BpMCSBM8UxBtyMiZOSPv0\n", + "9dbzQfflgI2rYPPnoH8rDDwMfXdCRSl8+so+RZ488898ZkZOKqVuAxCRfxaRNUqpA/M4nhudWBRS\n", + "EbA69X9tDkinwRTRs/poCg4cgvYotMVhzUow9YG7GPbYIdUOYyegfgwqWQBlZgsJpdS4S+SF5+Aj\n", + "rZAxQ7YL7N3wLtCZ89JkCCQINg/vNw2LgSWil3iuZEmluRncdTkldgWQXg6hAdgI+VLY600SDh+B\n", + "9ji0N0AiBpZjYGuHg4U5xz8FpmkdjHzgppYlcMdaGDbnZOKWw8hxaBKR0qtRNp4nz3wxn71pclPV\n", + "Tq6SD/+HFaVUqlBk+wvwpULwWcGehGwQghPwgxmDLRF5YhKaqqBWwWgNDBYa6WQAt77QOebtgyxg\n", + "Ikq9IyJdPbDEBJawDkL6jLpUswtuq4MtZqh/Hm5tg51roC8B5nehdgJeu0KjM4d7jgfdELeC9wq2\n", + "m+cDYnTl/vEuaDoBTQmIZGF7OdwTBUsBpP1gfwW2JCHdAn9UJTI0As8rpc7pS3Q+RETqwO2B6dnP\n", + "Gees86p+sDx5rjPzqhkRkU8Afwns/SC22HnOJgJjaXCVgcursyPmNJgVVNpFblOQQnf07SwVeT4N\n", + "LbmBSBzMw/rCds07NN6oKKVGgJHZjxfC3avh7k0w6IQdx2HlcbjzCBxRMDYB28Kw7Qp3P9IPso6z\n", + "11cHoCgA+3NfKCIuE7TawBWHIaA3X8lxbTC+19PGP0REjkB8BO72ai3W6maIPgTvFECqD4q2w2+L\n", + "yD8opUbPt10RKbFCi2jhc08CTvdCdVPO8k8ULKM623KpRol58ixI5jUYUUo9CzwrIt8WkfuUUq/k\n", + "Pi8i38r5c5tSatv1HN+NRiXcfQfsK9VmNc5aiNuhPQhfb4K3zZDuBOwiTydh2y5oU1BRB1MBcByE\n", + "0hHdWjpfnXEZiEhBE9x+O/TNVNssh0M+6P0V2Mfgbz+oaDEXpdRwsciBbbpaZ9QB6W4oPQChKOzL\n", + "GU9jI3y5FewuyA6AuQtOiMjPrrYFfZ5zMapbtovIbqB9NTjuga6Z5+vBvwbsE7AZeGaubThE1rfC\n", + "J1sBC6guMJ+GjnfAkYLyOpiaAtcB8I3Br280g8M8ZyOCFfhddGXeL5S68qqrG415C0ZExJZzYQzC\n", + "uR0dlVLfuq6DuoEREVMDVFYbegIbhEag3ArNLeCvgOkG8LeD7Rn4VCf8t274rh+2FMDiDPhH4UdZ\n", + "ODbfn+UGxOsDsc/SA1RDwAX1aCvlq4IffrkT+k7DZgFXCHYH4R2lVAhARKy18OhHIFIBowCrgO2w\n", + "5B3d1TffbO46oZRKiEi2Kkc7MkMFBAv0b+McRKSkDR7+BAy7dDaT5SAvwPJ98IxfN1tsSsPkGDyX\n", + "Uer4tf4sea4dIpjRLRA8wHPA4yL8R6X4/vyO7Poyn5mRB0XkG+hyyR7ghXkcyw2PUipbIzI5Bq5y\n", + "iGTANAorCsAzCqrSEL25IbkYOA1NWaX2AU/O78hvCkLTQBrEkiMunARnUmuh0qBvMg5YYgFHWP/m\n", + "L3vpxOhhsdv4Nxe1dVBQMcv7YimMHYdN5IOR601wYlZJ+BR4T0NrWJfl1iilBnOft0LLYlAzgQjo\n", + "7EgbhHuhekKpn12nsee5PvwxUATcrxRJEX4DvC3Czg9TP5/5FLA+Czw7X/u/GRmD13bDo5thfBzW\n", + "WqA1AF4HTJ6C2zOwcxFMWQCL7gqc5yqglAoXiezZCbdshH47ZMJg2wWV4/ALpZSyi6xqhc+0gbJD\n", + "5gzcfRqOiMiTV+I7Mgdm8xwPWiBryguT54O+MzB4GKqXwXAftAZh5QTY1+lA5V8VirwZhldmzMsE\n", + "LLlB7QwWyEr+vL2pEKEa3SByrVI6g6YUJ0X4z8BfAZ+Yz/FdT/KmZzcBIlIANAHmw7BtEL5Qr1PA\n", + "QTekt8KpMFj3wvpKeK0bTCk9M89zlQjAi3sh0wObXGAKQGIMnknCARFxN8EjH4fRmXLPpcAbsGqn\n", + "dm49eKX7F5EqoApQfaBCYMstLT0NZX5460r3k+fCiIgLfS5agH6l1ISIPPEmfPwAbHTBukIYb4E3\n", + "22AsBabnYOshOInRpiEJPV1gXj4r09al/UuOzM8ny3ON+HfAD5RidmXVd4BvirBWqbPF6Tcr+WDk\n", + "Bsci0twIv9UMNjuoM8AIuGrhnSKITsKaM1BbCtMW8D4Ly/rh2Qup+PNcGiJiARrRZZWjfqWeF5E3\n", + "gAK0Dmrm+UVNYMkNDkxAG0x1wjquIBgREXMRfHIlrKsDFQFOgvdpKFoPEy5IDIL7CEyEtSdKnmuE\n", + "WaRtETzaDFYrqF7ArX8Pr08o9eMCkeAdkFgF/REonIKiYvC3QqIH2jGCEaXUkFfknRdhSyuELdrT\n", + "xnMcjmXh1PX4LEbLgUb0b3ncqCLLcxURoRT4MrBk9nNKERfh/wP+APi96z22+SAfjNzAiIizAb70\n", + "MQiUQjSuZ8PrTLApCK1pcNnAn4boaagZ17qBnwLvzPfYb3REpLwavtwIxYXall2KRPYAzymlYk6R\n", + "zVXwYDWYRqA8DI0BmPJCeGYbJm1Gd0UuyFZYswI23AU9MxtqhcJnwfcyHHDom15nCo5ejYqePHMj\n", + "IoVN8OjHYaoY4gCrwfwS3LtfN9HrMkNcge8MLHWBpEBGIJSEXpMu332PILywF072wCoT2CbhSFYb\n", + "RV7NJb3zfZaSSv3bLvWCGgSTT+TgNPzyeuz/Q8RXgWeV4nwTwx8AHSJ8QylC121U80Q+GLlBMHwj\n", + "HiiCdQKRALwGxFvAVmp4hfTBSh+UtsD4KNRuhjNjUCAwVQKTh7QV+cF8Y60rQ0RMlfDF+8HaaFQv\n", + "ZUC2wS3vwpCI+NfAJ++D/jhYj0DxMNTvgE+3w7ONhnHVaSiZPM/SiYg4LdDmgJIojGS1P8w5VRml\n", + "sGk5jOdGNNUQWgTFO+GYX6m8K+t1wATNi8EyE4gA2CHTDuE+WAt0hSE5BkvXwZmZyqtpcL0K6/3w\n", + "vdztGedoFzklwXMhIhUOWGwCcxS6lFIDV/I5RETK4Qv36PYSU93QWALeLDSHdSCdLzS4CohgAr4O\n", + "PHa+1yjFsAhvAY8AP7xeY5sv8sHIDYCIVJfDf1kMLQ0QTWob9zs64IDFaNQ1CuVx/fxoSDfRyh4B\n", + "bxkkzkB9DLrKoLMfFpFfd74gRm+eGvTyy5hSKjDrJTW1UNqYY8tuBrUCRrvg1hRMrYJAGOyHYEsj\n", + "WGtgeBSaj8KnemFXGsLH4VQKDs2x//Ja+NoSKCyG1BhYT8K4iPwgdywiYq6EqhikkhC35ZQQ27XW\n", + "4IYRO4qIFag2/hxSSqUu9PqFhoDNAuYxKBPIFoPfors8p8yGO2oZNDjg1H6oqIWU6IyaLQlTzCFY\n", + "vRgukduWwkcXQ9oEdMMDXpG3g/DCFUw4KqqgygyRDrirGbIeSEyAOwrfEJGjSqn+D7jtPO9zJxDj\n", + "4kunT5EPRm5+RKQGfBvBXq6r5kJ7lFJT8z2uXERESuB3WqH2LuiZ6UtRDkVxWHoKAoXQaIVyO9T2\n", + "QNUZKPNAKKCDFo8fAvfAtmEo2m/4uYiIDV1dEc47c76PiBSXwxdroaoQskMgHpHtoZxqB8DunOPm\n", + "4YKkCbxWUIUQOwZL28Bcr8t7/WZdSTNxAEoH4Z+AjrnS3hXw6bvB1GQEO8uAEqjaBvej/QgQkbpq\n", + "+IITGgegaQpSaWzTdkx+F/HhPj3zHpy97YVKHfxxNTgFZBDiZpGfZZQ6Pd/julQUFHTBraUQAkwD\n", + "4Ehjnx4iaxsn9biImGugaDkcnYS+PigRoAyGs+DsvEw7dxGpWAof+bh2/E0DLNNeJFv2aVH0B82I\n", + "2R2Q7YZVayHuMzI9XkhOQEUcPoYWV+a5Mh4FHlfqokHoc8Dfi+BS6or6Wi14PrTBiIh5CbR/GVbF\n", + "oTgCI7fAwY0i8r8WmFir3A0NDRCbCUSMKW/aB3VnoGoYUsthPALpAJTEgTZILdEujfa3wJIFOaP9\n", + "DsYKRR6qhk+asVVFIWIR+WkGnvmwL9+IiFTAo3dB8RIjEEiB6XW4a4+2255p5DjcD6YDUJeEAieE\n", + "W2C0G0rDcDALqQHYGIXqGgiAPmYpSLbAnlHwDsL0XIGIiPiaoaUHh/UQ9qUeEv6lxHuXwsh+WCEi\n", + "vwKsDfCVFeAcB8cA1JdhLjBhivnxnRoi0TpA9BVtxHtj8AmIlRneKBNQ8AJ8WUT+7npNDnRwbl0J\n", + "JatApWF8L2SPK6WyRqasvgAWpSGZ1NqNyZz3Vi6Beyrg+Bg0FCOlZgo8fUhDJ5VHs5Suhw5riGDJ\n", + "XthaBOE0ROvgcDOMH4IGLrMFg0N7kWScOdkwC6hWiHRrF88PGoyMDoK1SRv5vdd4LwCFpdDjgWoR\n", + "cSulwhfaSJ7zY7itPoI2IbwgSjElwi7gAeDpaz22+eRDGYxopXjtI3DvGJQYF+yKMBSUQfg+4PF5\n", + "HeDZiAmyacM4KQsMQH0CKuzgqYVQBEZ3QrEZUmWQXg9j3TrFXxSCTANMvg3rR+DHHtjQhPV3Syk3\n", + "OfCEYiRdXUz9215ilcB35/ejzjvVlVBbBLEhqCqCqQJIrIbxXtjC+8GINQLuCVhfB9EoqBdBxuFd\n", + "P2wH2AdrisEZh4gZGAOvQG8RhFLa4OgsCwtpAAAgAElEQVScZQhjqWLNGBW3CC3jFuypXqYqexhY\n", + "disT20T/BkwmWFwFJSFYvBpMEQqCk1gDI8R93URLA3z0p9Drgh2L4cYwTSrL6ZFUCtGl4BvSSaHt\n", + "13rf+nsvfQxWLoImv171OPlbcGyXiDzrhYebYH2TXg6TU/BRu8hTCaPLeCGsXAaZZbB/D6Q7cFeZ\n", + "KZiKIukwLcdhY7eT3s+tIjhaDv4aEAWmg3DHCegcgNdzq9tEpAzwoSuyRt7zH9HZzEbAagfPXMpn\n", + "E6jZYtjLQSkVt4m86IYtAYjZIRmGgjFtnHgqrRsyziliNX6/ZUAy30H4gtwNdM1Rzns+XgDuIx+M\n", + "3JSUQZlT6wdzaR4HV6uIWBaQanwsCmd6dXbEEoSiIDQXgCUEJoFSE1QngEJIecEch3hA31B7TXom\n", + "lx6FvQF4swH+powKCigdB3Bjj7dgjU8x9rCIPKOUGjZmgtysmRIRMc21NCXQatGaj7AJXWfpgiNl\n", + "0G/RNwcASuCjW2GyBF4IQpMTCqohNqj1JVPGPv7RD5btcHc9jLrgYBP09oBvWM+Cz1LQW0WW18In\n", + "43huS1LvSxL3KAayVWRRWC27sX5pktQ/A1hgXQQ2LwIxIyk7jmQ91ngF1kQIJQGyIlBkx/55s8gv\n", + "jSqMxLX8Tq82hZBw6qDtOmBqh+VNcEfv+4/V+SG6EQ7522HD/TnVSm1g+xU8IiLdSqmAA4rcEDcB\n", + "bmzmaqp6rBSEJwh7u0lZU4wUlmEqbsB8upzMiVFYnITqAkgdhXE//Ap0sFEMjyyGDTbwRcA+CYdF\n", + "5B8AXy18qRGcdqATCjugZBkMzXiRZIHjUBOH6QqRRyd0KfDxy9XfJJV6s0jk6UNwazlghd467X1S\n", + "5IfDc/XBsYusrIOPl4M9DlIh0jcGTyqlzukynIfPAZfjovsqusT3pmY+e9NsAv4b+hzao5T6xnXc\n", + "fQoScu7DCQtk0saYFgpqFH5shupXYJkdFleAcwjiSYjWQI0bJAKEQcIgWaiwwLtr4JcAb0N9WFff\n", + "eBxYSmy4o7k7cOGIW7FXgCwTKb0d6leCSot4d0HwzZuhJFRnwxwboeQOqHeLVJ6B0ZeVUn3G8+46\n", + "uMcGiSotPlQVYOqB1cfBGoVdxuuczdC+BAbMerY4BvoH0wP1IlKolAoZZlf/tRN6U9Bao5ud1Z/W\n", + "PYB+lhvoiUjdMnh0E/i34ckK3pMpOm5ZhCXtwTGSBuyETSZSjRb4w0XQmAJfKSSTKFeaZMaCNR4n\n", + "Y7Fhifl4Z2sdGWspqQIFnzsB0yLyzzfSjWEQCvy6JPY6ULoMGoNnP2ZWsCjt5fDWNlQgNwthtFQw\n", + "n9bmZgem4fQArNLuxtmkImsGmCRrTlE+DcECD1nMqJQHwh6dYTsQAesxcE9pi38KYWsj3OWG2np0\n", + "NU4nfOwoNLpgeCukenD4eimst6BkimnP02SSK/WkI3sMlgbA+TEYdoKnB1Ycg9Mi8sRMJZaIyKzf\n", + "nsw16QjA945BKg4VpUAnlHbD0BS8OPu1IlK/DD5/L4wWG92DT0DFNnhMRP7eaGGQBxDBBjwMfOsy\n", + "3nYU8IjQqNT1OieuP/OZGekF7lJKJUXkCRFZrpQ6ej12rJSaFKnogxMVsCRnrfZQNQTevh6CTiMV\n", + "WwpE0E6NatbztWVwbx00ZyA4Dr8ch7fK4U8rYLAI/HZY2wRZpduIq0WQOgT2EcAHVQNQNgr2IzCW\n", + "hiCUfqwf1RYnli0jMeLBYc5icidJqSSSguKPwT2T0DqgiwAO3w5764wb2YK+oGi5BzXo5Y8upVT0\n", + "7Fd4HoBVd8DaIfBOQ18J7Px9EflHpVS/CVraATMc3Q9LF0OoAFJpsO6D2gjsqBX5k2pwpWFJGKZn\n", + "PEOSYBnEVB/Fugo8vy/ieBsS+41GaT+chKZ9WO4C7zKtGU7cJyKvzWiTSmDTKoiWQFTIoAjYGjGP\n", + "CVZnAElbMI+6MNEITjesegi2PwlLT0N9BcQTRMqSmJN+rLEQKddSnH4X8WQb2WM+7UFT8Rp8BPjx\n", + "dTwkl8VuqGuHUQGOQ8VxGMpqV9Krjnar9d0KznpIjELSrSciMwx4YcwLQ2WCGjPNMTkxgRLDIyYN\n", + "HUfhNifUlZMeH2GyfZS0tR/fqM629vqChKSU7FnZsDEoTBgiYxGxlMP9KViyGAJ1EBSgFoJx2BSA\n", + "jgMUWeO0F7goCQAkGHWc4rh3kPBRgcJCqHkU3ikwllEaYcoELdthuVUkVQZ31UF5lcjgKBxVlLdA\n", + "XZNITQim3oL4npnzXCkVEJF/GIUmAa/S5ei9c10HSmHzaojmljUvgbFeqB/Ry0oXLE/+kHEvcFwp\n", + "LrkiSSmyIrwG3MOsEvCbifnsTZN7Yqa4ip1NL42xp2DbY9BXrzPwwwK9nRDcdi33ql07iz6h7Qaq\n", + "MuA3Qf+wMXsJiIhN4PZGXUETqoFeB6SPwD37oKMI9ruhbRxaK8FtBREgDKYMmH16uSA5DKajUBOB\n", + "p8PQC4sfg1tiCfz7o0zfPkhsZZhIuAT39AD+whCmrJZLLO3QI7WkYVMfTDXAeCML9IIiIuKBh5bD\n", + "LQ2gEiCnIWkReSKtVJfxGi8svgXu7AGLEfQ1TkPGBFNbgcfN4CwAtRJOHoPwflicBmcM/jd7bx4j\n", + "6Xnf+X2e96z77q7qnr7nvmdIDY8hRVEUdVqyLUuyHcuGV+sjiyBBgt0AySIB1kj+WCDYAEF2Y2eN\n", + "jZ21pWhtadeyJQvSihLPITkccjgnZ3rOvqu7676r3uvJH08NORyOxFukaH6BBmeGVU9XvW/V+/6e\n", + "3+97VNvg3Q93HlQ7zsr3Yc95+PQB+H4InPPY924S3dFBlxEm9nUR22Fh1/Cc+kJk7oBDW+HQNYg5\n", + "cG1mWAj9CVDOwo41GK9BJkq9XiG6NYTwQ4iOg7EJAxmlt96G0SRU1yHeI9U7QcpOYsSgboZohXT0\n", + "psRNxmi4BVpnM0Py7E7YfB52CyFC79eo+Sfg8dNwRICowxNtePp2viq3QgihAXNxmHWV8d/Fm8ml\n", + "t3n8FGz/fbjThUIdKtNwbAJOWzBRDXFs3xjr0yP4eo9SpAich5EUXIpAzwR/APo1QL7imNoXQvzZ\n", + "Y3BvCu4cUL9YxUr4ZNbhkT02l0bbdIonYN9dcCoGgxJEnod4CZ5U14Tkl1vEPh4hHn+BXuYS5d49\n", + "dK7HwM0rae02j+lKgtGXCb0J8rUSg0iDc1cgMI7Cjsgt19GtUDsFX5wD4wiURmHpNEw+SuGrTe45\n", + "DgfmoRGCk78KpzPA9288d1h4XH69c2DBSJrXKj3SanwUe73n/wPDb/DmRjQ38CjwIB8WI+8ehBAH\n", + "gBEp5c+VaCelrAoh/g2sz6K+MFVg6d3nSYTvhUMfUfPpG83fl/Lw6JeFEN8qwNeS8IkRmO5D+Kq6\n", + "+C2OwslRuK8Fcx1FjMxYgA96B2QaBhHwO+AkwQ3g2avwl30pnxFi5LfgrgHMVXy8YxWe2WFjzjWp\n", + "J1fZ9NpE1iDvQusu+P4IhKqwZR52bsJ4AFaed6EYGRLeokDnrfpKaLBnD9z3MCzcmJ3vgsh34beE\n", + "EP9qOGLKQl6+UojcwEQdQnMALqwsgnYA2A+r8+AuwSFgpgCWC64Lm3FwPgJPHYfPHYePpKG6hH5X\n", + "B1dsJ3k5RCdVxA1dJ550qT4thGjCvkPw0euvnO/tJTUNqtwbpUEa7khDLgHNDj2rxKrcwIrkiCFo\n", + "hSM0NrbinHkUPhuH6pOk7wlxuGsROtGjO9Ejl12kbHpssAW3nKdzbvqm7CGhdvHDP74/0ZLyEdRs\n", + "/A1DCGFk4De2wd4Z6PfAmIfP2EJ8ayDlmds/q/BZuL8N03X199QA0l34//bANw7P4O2Zwq5rNNxx\n", + "uo/Ow5ZrcO8x2J+CngYLa7B5FU7D6C8LMTkNfhmMx9p4Px6+D4QQKYONz8zCJ/bDlRD0zsChb8Ev\n", + "heBUG8qb8HUp5YIQsQfgjgM+VtGmE0lidltkI89xcfYo3es+tLto2QTJV31Hunhhl7FVWJ6C2srt\n", + "Wpd9MCOw60F4/EYcwRrRsSzbGx7eRBcxD+m+KtQ37hVCHLuNr87PRAeuF+Gu3E0kZICi+sB/SGQd\n", + "Qghs4AvAP38LT38a+B/e2Vf0/sJ7WowIITLAvwa+8lP+/x/d9NfHpJSPvZO/f0hSfd3K/+1CCBED\n", + "e69S6yQ+DfuuvdoFfM8GnN0To/RHeThQh+0FcHZDxQOzDCMLcNiCfFh1PlIxcNeAURBN0GZhMABx\n", + "CmIxOLMOxcHL7y08BxPDHZXuB6Q3exSK0J8A9wXIl6H5MMxYMNkHLwwXjoL/HDQ0cG6Zp7/t46FB\n", + "9H6Y/hjEDGi5QkQffStr5eDIbpW7I2/6t+4c5BaVwdtLQEd1oG5FNQLejYvlygKcehTuyCmnzHtm\n", + "QZTV+CQ8gHufgX0H4O8nYe0APPI9SDsYuRyh7i7G5kOYLkAC2emxObmM9XnQJIR3w2YfCjd1A0fb\n", + "YP+2weiYh917iUbuME33ftiAHov0fGiExlTrO/40fOwyXJ6A2ICxcJJ4FcAjtFEknPLYcRWuF9ts\n", + "Rq5SvhtqzBJcA7gMo03l4PoLz/25GQYc2A97P6Y4EwDsAOs/wa8JIa5KKV+1WxdC2LB1EqaXXr1S\n", + "pgdbNnKcdvdAKwOtrPKD2Z6HsVnlZHytohjv+UU4Idl9QKUuTKxBMa3xzP+cYL42IcRSA04AJydh\n", + "16/A6diwCNgBjzwDM0/A8R5895VxcOp+uGPNoTUocX5nlEHBIGJskrZP0k/VCU7VkfMu7UMGCVcg\n", + "gi5udBOjI3Er0K0C166AvwfsKkQXFUk2U4RIZMjjOIGYaWLH17C3pUisW3ixLo4JtqsK9YKESzmG\n", + "HbU3igYcPwkfCcHIVij1wDwNY8twAVh7s+f1A4zPAmekfEvH5AKQFYJRKd+cDPwXBe8lgdUAvg78\n", + "91LK2x5cKeUf/Vxf1LsANZ+e+sewJ6R2YWcOwkYBQsd4mUjajoRwD+2FyB2w9hyYI2C2wU9C3YSo\n", + "gFkHZjJQ6kJfB7OquiKNOISugrUJYhNWGvDkksqRGN5ovQrUIhBuga9DLwf1GMoAbQ6uHISH1mA9\n", + "DVKHXAsO+vD4EVh/kne8YIs9AAc/DUdXIOpC24Jjn4dn3vRKOtj2bUZ8lvqPCWokKMTIVTg1DQfW\n", + "VCHYNeBkDja+MXyMFEL8p2fgSgr+8BB4A2UotcsCYxvUXUhsqFbp0z50NHjOQB6eJDp5oxABCAiE\n", + "j1eA8d+AqARzHDb2w/p52PljCA3g2j2QmYpQcCR6qI1TP8aVfI2ipimZ8HkD4hVVrfkBNBPQugzV\n", + "EPoejYH0gCLelMeOBXANg9Yhh8LqRfqhDt2jDr1ODazz0Cl9AG28c3DnDsWLeBlxcOZAv664Cudv\n", + "eYqnGlw9A8I3fWYCoK+Z4GyBxSz02mB1YfYuqD2F2HqB9MclKSPAkxrtf+az8z+oUZ9jhNg8mGc8\n", + "blCOfpbNi9fhgafg3gkwYzeFIwLshuI52L4yLERUYT4VhmgZYsUqy4sB3b1JhHSIulfJtIq4BZPG\n", + "cy2uTrcIhUyynT65iwFGFR4zYHBeStkyhfjWX8F/OQ6HtoMjwY1B6RJs+xuyBZjt60S8DmvZDu2M\n", + "S2hFjWNvoK5xm3HL60Fx8MSftuGTEdgZwKAGj7XhiQ+qIu8t4qvAN97KE4e8kePAvcDfvqOv6n2C\n", + "97Iz8hWU6cv/NlSS/nMp5QcqVVRJZPNfhIc8mBkSltavgDkJa/tgx3MAOte3Z6hr41ALQIwoL4qY\n", + "gNhAmRiNCYhuQ0W8rkJyHvSjsFAGYxW6NpypKzOt/+grt9Cb5uYbT8DJ34F0D4o7IR2AZ0GyAvsr\n", + "cHIaFgKwXoI1qYolJNQDWP3rG7LQoc9BFuhJKetv8ZhYMP1RuG8ZIsMLYcyBo6tvpRipwdnr8LnC\n", + "TQF0LmgL6o83kcTK34Infw3md0A8gE0fNr+nRAgKwxn5i1uEOLMdLlXhrjnY3IRIG6wUeA70KrD/\n", + "knLSfC6Nnwqo3ytJ6gLDB9igOdImkVCeFUeuwAs6ZEPg7IKFJiTmYW06QtxI4SVjyO4AoZfYYqzS\n", + "2Jimu5CDiV+Hp25kmADMw+jfw1qD3qkGKV85iXcsHT8ZpphKYq5mSNbqzIlz9DKX6XUd+JEDZ2/u\n", + "EgghQqjz2P1FUtjcCqE8V15zs9PUOOo1IynF30keh1P3w703dUfOjUP5QgPWrsFDWVhugh0FrkDm\n", + "IvntBeaKceyaS2CcwdnaZ/kTkl1fh3I+h5NIE620SKT7bJpHYHkFDrZV1fuyl4Sn3GXTDgQ3VCzK\n", + "VC1/Ba6PK57oiFMn/1SD9azGelxjWylFEB3j7OFJGpfO8sLBFcaKAekebAxg7etSyuZw/fMBrE2D\n", + "Z4OTgMocNM8S3Qoz0yNsOa6B9PGvr9E91Ce6CpUIODqUY7C28FYNH4fP+8th2m/wYRHyaghBEuUV\n", + "8odvY5mngaN8WIy8s5BSfhP45nv1+39OSEN27JVCBGDrBaXisfZCaBECx+DUjl3UTurKeW3OBc2A\n", + "ZhkyK4rYGJtV8fB+B2JT0O5C9BRk8+Cm4GQXNjfgKV9p+2/pFAQvwUvfhdJnIHkQ0g3oDZSBaCWu\n", + "du+rcdj+NHjblH1JX1emr/EvC5HNAnlFcE2tgFsXInsBqt+5tRX+BhCFuPlKIXID8dclK94OfXjx\n", + "FByWMDUN9T6YFyCxAo/c7N45dIz8i+FoMAKUfxqZswOL63CPpRQKNR2urcP0FYjrYBUhtAA/lFIu\n", + "CSEeb9K6N8biqEZSSBAbdKe6FFyYcmD9HkhH4QogHWjsgY2+Rqw/TqFn09sSQnPCgI4t1zF39qGW\n", + "h+rNhQjADFRs2BdjyQTtMIx12+jjFr2wTbGRYnTToWX3qGV1kqNtUvug5UNxBeio4jhyL8x8EkZ0\n", + "aGlC5C5A5a2cx58Lhh3UrRbkHKXouHKD2FqGk5fh18Z4JdG0A+Y11er4KYZSzUfhRA6Ku6EQQEXA\n", + "8jJU/q4LwUk46MFUAVplCF/F2ppirJ3E7gDoCBkh1PGw8i7zkyZWMoLu+EhtQDfcgHABmlPQfhYO\n", + "P4sdG8Vd6xL0z5LZVyWRL2FdhuZ/LYT4tpSyqDwKn/gSzOQgEwF9VbI+8CksT2DnYlD0CRlH6M3v\n", + "YnD92yzMLrLw5yh1y81Kn2gSwvvhQgCchtlV+JgknuthRhdp7AwR2ugRo0/lJJzeA8tfAi1Ql4/K\n", + "373d8/V+V929h/gS8BMpeTvF/9PAv3iHXs/7Du85gfX9hGFVP4baVRXfqPGZEPpuyD8I+gg4i7D5\n", + "mJTythdDAYkwhh7wYs7m5G9J3IGgu1qGA1LdpbMBxK5D1IJgHYyMkpjKKWi2IdJTVs2DCyCuQV3C\n", + "s1V4xlMx8a95zcNdyjEhxCWYjsM9y1BoQSsOnRhYJRUwOtgPOyvKtuTFg7BFQPP3YLICXgG2LcLA\n", + "BuMUVHfAsV8H/vym4zeVgSM2pBpwtQsvSClvjb5uq8ZPx1Qjmhto2G/kWN/mvfWEEH/2OBxIwz5f\n", + "jSReQN39b7wuzYQ7R+C+CTUbu1iFx7lJijhUZczqkPOh8SKIXWA6oFvKOK7kwuJWOLkGcU/9DoDG\n", + "Eiy2aY1HaEkHYh2ilkEQ1WjfFRD2BTE/YE7zWZOwfB6K3wwz879GCG+6BFaLwUgI4fn0LUlfW4IX\n", + "Xbj726Qe7GNE0/RK++lcakEoDnt+BeeRCpc2rrCxdRG2asTTWSa6Pu1tG3Rikik/RnfTJ9dxiZrw\n", + "yNeEEP8HaFOw55fhoSVVDAbA6R1w7CuouPL3FYQQ8Tz87jYYGwW/Atpl5Zny51LKqgunz8A+B7ZP\n", + "QWegClFzRY0obxu5PuzyfV2NT89kUIXMy9J6IcSf1uBQGnZ34ZiBuXUKq+fhZAOk3gVCGK02/his\n", + "P+gzutiin65T2p2l0mnBXf8Z9DbhTJnpay/QGx2hu62MnveYK/exvSj2iIv7UQcxIUToe3DoC1C4\n", + "CnUPLt1pUs9GCBYE8YxOoeQgwzkGawAh8Oaguwj2bSwInAEEfdAvwsQADt0NHQfR8zD7VYzmJtH1\n", + "gKmzcPw+2LUGO36kRGOuD4/8mhBiA8XzyAMJIKErpd4GPxeC/wcWXwX++G2ucQI4LAS6lHzgir4P\n", + "i5EhhBDTsOU3YDwO/QisGUKI7wGP/yyJoRCRu+HQr8KdFciVYG0MnvtDIYz/B7iulJgLaTVfLmcy\n", + "rNwZohzJ0+rch3+lDeETcCAEiRFY74FfgpCBppURpoYvNZAZ6Lig2eA2wKiB1YH1OvxfAyJXoC8h\n", + "sLiNzfhNMKGfhxd3g9GH1FU4eFkZuz4xB5YJXgxKIxDtwi4PKmnohBWv1s9A7iJc2wt7fwDXtgoh\n", + "8lLKDUuIj8zB12ahPwkbZZg+BXcLIf705lGAlNIVIvY4HPusGs3EHGhZ8Mz4z3jdPxNDYubx4c9r\n", + "kIDPHYD7DsJGDKoLsOdZJXX94+G8OzwCX52FmXGQdRAXQD47NLOKK4LNwgNw4QTMrSuliiGEmN0O\n", + "/+ggBCE4fh0ebEEkTe+JeQa/IWnTx7U8YlLZwQQCOvuBswab5TZr6SiF1T60S6xv6bAc9vA9yPxX\n", + "K4QLcRLlAuPzDbzsY1x+QLLGTrg2Ac0JaI7T6J+DuQadqItjdLCikE+GaK/YmKUqVhcmG7AnAet7\n", + "IXMn3FFSoqBGFKJ92L8GV7cJIUZ/GnfrvUIGPnMUcgdv6nKMw+iPlWnUnw09iv7yKdiRge0udFuq\n", + "IC++3trDx7zmcUN/mqeBp4UQWoz+wzWauyDpSAh8sELohmC9CxYB7q4GK7PT1IsfZbA4Cp3n0e6+\n", + "jrAk235UYvuxEk/cLYikUojoNNHzJvpggBZdJXdfm95uGA2BaYBlbaFljBHrR+mYHo5V4fL2Js7a\n", + "BP2rf0X64QFWtEPPNmkNJoToByrA7lkXTkopnZQQz52Eo23YdRQaMXAtmnRw2yNk1rt08k1WViE8\n", + "CvmrkC+98u4PDmD146rmTe7MUDuwha6Ro3ulCcXrcEEI8VdvVfn2DxVCsAU4DPz921lHShpCUAR2\n", + "ooj5Hyh8WIwAyqpi9nfhkx24llZTkbkYLH8a1teFGPkJNL8Hzou3uBdaMPUp+PjqK2OG2SqYPtQ+\n", + "I2Xxj4UQfwM/+RrsnTTob7MpR2wup+/Hv5SB3hWY2A9GFOoliFkIM4lmbxBuZom1LRq2Ti8pQa+A\n", + "kQI9C8EyWB0s3WHHJ2DnFDQ1OBMVIleESEhZjWw8JofJp8pkbe73Ye8GxFOqAbC6Cx4tQH8R3Cdh\n", + "e1vFZnAE9riwtEeFia6kQK+DIcAPgRbXuPARMKwAtgshUpPwL3eAZyrXyG1b4MW7IdRRUdnfefUR\n", + "7zwFpyWsfEw1gNoDKP0t8D++C+c2uxvu+Tgs3Aga3A3rPozV1fz1uwl48AhM3zUMxwOYhOwPYWMB\n", + "flKAOwLQ/ho+HYHgsPKJ+GcVKHwU5qeg0YCYBz0LgjMEB8OURZUlQ7Bfgi3ACQSelHgZIKbT/U6Y\n", + "M5+scnWsSXwiIGFr5BKS3X4cOxQiVqvSHFlgI5Rm9GqbWcunHnyW7mWALoQWEJ/Mo6U6+Nosm90y\n", + "Vj1Goefi6kWsIGB0yNpPDSCSBa0AL00qVVcKuJyA56PgtyG+MhwbvC+kmEIIexb27b1FjbEDNl+E\n", + "OSFEUkrZGHYCX+LduThPZvEvQzHnE3YihDUNLdVgMxrQWYDpZ2D5oRC5bo9R6xFKB11aJoyEA0ba\n", + "UPoELG+CFDaWyEBgoQ8EEMbsRNAtH+7LUSyGQFZZGxsQ0dYZ2DFa9ihyaQv9sItnXGfb7ggzTQuz\n", + "t0l5LsPG5/az9PgcweZ5+OIZmBVC/DXw4+OQG4WP1aFRBJGlc7XKpUKL7nZB2IeVOch4oFfhwkMQ\n", + "RMAogb4Ckc/DA+fSnJk4zEgliuEM2Bg7wua1FOw5BncBx96FY/1Bxm8CfyMltx0Lv0mcBO7gw2Lk\n", + "gwpzF+wyoZyC0FbY04HOhJK6NQRcuQuCJMxneLUXQhqy5mv5DhMNiEwKISwp5ZoQ4v+EjT022u9M\n", + "0atFlSqm2wBLU3cJqUO3BLE6mh3HGFSBOJbTwwpy4J+mNxKHYEXxRvQmrEXYseozkWiwtaK6LzsO\n", + "QHQnHPwelDLw/O8JYX5DSvccpO6GOwTse0k1LjZ3AiY0UjD/x5BIQPteGPWgHoGyBu001CyIOrBa\n", + "AOlbbIbjLGctnG1d2miQtkC7B9g79BTognEcjszC41E4wC3FyLC9/KQQ4hkUf6MrpfSGROZ3GqPj\n", + "6vi+qr08AdU47BBCaBNwzw6oSF5hPW6FyihMnYO/ugKPlOBrR0G/ezj+aUD0GDx8FowKLJdUouud\n", + "UdAGoBugpwjJPvP4+ATEhcD2BFEjSuX/DqCyzCCjE8rEmNp0aU/6FAYmu0oD6nmBJ0fIbaxgUYQV\n", + "OHJe5/I9ZbqxBLgvEf6ohzGRJlyDrn6RIGnTD+q06RLymxTOvqLW2ghBYwUIQ3YSDq/B6QmYSkEa\n", + "WE7Bvik4+U+G3aKfS1Lu60DTbkNQ1VDptLyNMLg3igjM3gmLK9SDIufu3SRUkGiGYNAOGC3CYJfB\n", + "4XacZiiMu1RBZLtsG8lgVyJYWg1zNEDm4KoMaGf7RCo3O4AJVgvb8Y00ic4S5XyMaVMjRhfNaBIl\n", + "YHGwF+eZGqkH40xcaiLTZVqjWcKtBDtWF2huT1PtmJBMw1dq0M9CPArbO+C+BPUx6ORgcpJqdZ1a\n", + "/HnMTA933WG3AXP7lA2+3YRWGl7YC5EiRLwRnFCMRA3AIN3doLltL/0XLyg1x4fFyJvDbwPvVNzJ\n", + "jWLk6+/Qeu8bfFiMABBJQcKF4g441IbeGMQCFc1Qj4OZh34UsgeEMLtSuk8Pn9iDjgBfqCyLG2hb\n", + "4A4YSk6H8+vjcSHiSXioC9IH4YOmAw4MHBgNIJRC0yIE4gr98CLVKEivji8CNbf1siAyMGhiGWXq\n", + "hQHxEjSSsLoX7q5AJQr1EcjV4KA5qa4AACAASURBVGMDqHxWCHEBxudUMwAgv6l+ADqTcLEBjQq8\n", + "+N8qO5OcoYqVugaaC7tbsJyJUkzM0UulkK6GG+/gaUtk7s3i0KdXGeDXbTXj8mbAX4QpyU+3PR7u\n", + "at9RD5PboNe6jbKiCWFFiIx8oo//8FnMfhi/OkHvTGEYYmcqUoUBuGOQPXITD6UMkyOQ24B7inDA\n", + "hvEtEC6gexaa8RJSs7CFRTboE5ESgxjX7DhtfxfszYKzBJHLiEidlm/hGD6jA0GgaYT9Ho1oGnvT\n", + "xIgMaGfg6j4fb/ACJBzIuYxEJK3eIs5oj4ieIVvpsS50inWHuAbpDXA1uJCHCxUILkFEUwqc1aS6\n", + "bx3uQScCoR5s3QSRhPo93OTC+V5BStkbFeL6dchvhZeVYauQqKq/v+sqIBf8K7A3BfE8jojiDCws\n", + "x8dsn2PzcJ28F9CvdBnYIYLAxbZMZqoDlhMeMhmwbRUSfajHAupBEyMSxw1ZaE6D5VyKupEk3Gyw\n", + "mRyQjkSx7RCB0cUXBjm9RXDoCheTPeKlKtEWmGMWYcPEiTg4iRZmsAGJrdANQ0aHfzEL8/vg+Dw0\n", + "avDgdTC3wboBJR/ZP4jzowqI56nmlWGt7qluaEdANYCkBbWRgGCqhjupI7s2ouyiR20VZxx9o8dP\n", + "+SuhA81/qFwTIdiDSjJ+/B1a8iTwP71Da72v8GExAkBjGdY+BtKCkKeInaEebIwopvlEHxJN6Nhw\n", + "/neEsLtSDk5JKZtCZM/Bi3vhjhW1b/MFPD8OlR/eSjBrw/MX4MgItC5BehpaVRUHrvchaYAwcFlS\n", + "YXdyioGAaK9PP1ECfRt0JxXhrnkabWQHRvUEa+OwXSijRbsH3SlohVWkhaxArISyX9iE2hxkbzG+\n", + "qgmgA/nPw8ETajO1NqWsLTTLxsOgOOpQMsdYM2wCTeBJA83bzkhZoxnzCJstdHuN9vYZ/LOqDY23\n", + "CePVt2Z9DChC8a3sfCFEKgH3JeBgoGS2zwzg+Z9BNl5agtIVyG0bdm76oJ+B9Ca2liD1FZteVOJn\n", + "Xcz8JcyCRvMHAfSLYKN+tKiKZgegDJkAds3ARkkFiVkzYGxgaGWEkcAaTKKH5mnqfcKay5gfomjE\n", + "qDONp02BNqqKsJQEq0bD0YhSpxNy6Y57aD2BZ/p4tqQ7kqKejLFOnGq5CtUfY0QEbsYlNGITaFOM\n", + "LLfxwi4ip9PI+Zw9DevjoPWgeQZqjwC+ss4YfRwu3AvhsCJMhpYhGoCnK0fa2A7eB8UIQAm+/wT8\n", + "QR0mRtV3JXoGKMKf/6ybm1Bs5D15eECHTB+ulRX3602ZTQmIhqGQUzLZwRZYvYQ7uYRX2E6ouoyT\n", + "DqiHW3RDJej46IaOCAZIOtgOCB36IfCtgMRVwWaiyqWJBLKUobGm4U6apBp9agXIR1xCuoGDj4uO\n", + "rweEzU3C2/v0rkM8BrOLkvnDAich0aSJk9wKnVGoXofwndCwIH0VHp6BIAWVC7BtHqaaMKdBMwKG\n", + "BYs6yaZPfREenQWhgbUBO07D6S+AbVRJ6GNEOwFYLco7swyevwyjrZ/Cy7rl+Kcg9wXYvgN0AY11\n", + "oRLB33AeywcIXwW+KeU7Fr76IorEqr2Da74v8GExonAF5ldgbAaW05ByYSMONRt2FuG0DTM9GOhw\n", + "5ypUHhZCnFYXxOp34Rkbru9Q96hNDdafhe6rWplKomh8sox9uEYwN08/NIKseVBehG07QUrMYJ2I\n", + "3kCSoEsZ10jTzISRgY7wXaQWgpIOfhqnX8dNRRA9JRl1NNXN0HTYuQ56AJUE9OYg+dvgHoZnD6g6\n", + "aOIcjFTgwihc3wRtJ2Q+pwqwRBHsY1AaiWFFJRfCIUoNjfXRBEndQggb6QRoeotuNInpL+NYcdKd\n", + "NRwbemMRGJyHxCL8sAdv2jtGCH0H5D8FMwUhJupQfgwGLwCxLfAHdynPlVIPzHPwy6dhmp9S9Cgf\n", + "B/Efvwf/NAtHDWUnu1aFH6ax/rtDxOsGqXqFjW1j+KZLkH8e/XNVfDcL5ybh95ehvQ7hNlgxcBow\n", + "kVWtr3IDsikYb6PFNXTW0Ls2pi/RAocKHcZRBpgNX6cq4jhSIyErtAshAtIMRJ+eDEgFNlWhk9T7\n", + "GHaETr1OdU5jw4hSb47R3NgO6wuI5AsUxgfs6oPW7lGMdtjYkSfwcriDBKHeVvpL51kur8Gf3Kwq\n", + "EaJwDdqjMH4cqqb6DAxMcCyIt9W4xt243XF8LyClXBdC/OsSHE7ARBvW2/Di6/FaInB0D3zhMJQz\n", + "UFuBuecUYflPpZQrNx4nhBhJwEeiMNmDtbpKD3/5/edgzxwcuwa/lAfRBVFGilmkbBKkFqjYLZKm\n", + "wAzAmXOp+x2KToB1TjLTATOAUgL8pYAjT3V44WjA9YSHnV0itC8G4V00NY2oIRGexDYHdHQbKcMg\n", + "XAZWFNkx6E25LCTA8TU8u4PvG2xY0wz6YZVvM9cEcx+U+5DpqmiB6x5EpqG3AcEh6IWhXoP8CsQM\n", + "qn2f/+L74L+kiNVmAJtReNKHjlZjx/I15ifyeJpOO1hGG9+Ak43XGdGoiIfCP4IH4rBrWW3QllLw\n", + "2D8eJvj+1NygDxqEQAN+C/jiO7WmlJSFoI5KjL7yeo//RcKHxQg3FB7i30O7COV/AlNAQkKkA/Nh\n", + "SK+q77JXhW2bEJlE7Zj7Q/b9XwghRlEZN43hjyWEeQCiOWgWDezfnCb20CgxdIg06Uav0cp0KGzm\n", + "aQSX0PSAMT2BJbNIunRFmyUS9MigyR7SaEO8CNMW+DqBO6Dc9Yn3YbkADQMupeDQKTACNVZfyUAs\n", + "A5Evw64+9AewcA8s7oD2BSjPQ9+Avb8CeQ2296C+ReeFO5IUZyJYlsO6YUEuREiX1IREZ0BYmsSd\n", + "LgO7Td8vInRBO5XDWujQe2kRwhfgeBv+1Ztl3guh74S9vwv3VmB8CSphOPElOBM16U6PwOEBrHag\n", + "MQqdB2ChBgeEEE9JKVdfu56IFuBLw1Tckz3lEaJVYMc4ppUg3B3gmRAvz9NNg2fXCbZ8Bv7ttuF4\n", + "YAWSfwvRR2B6l3LnnO1B/pIiC21pYtgR0AYY0iNnaehOH33gohlwzhaYSDQh6OOh+QHQRE91CEyD\n", + "Hg38iE68b2L3upyNCqRWQ4/ptPtj9JlCigzaqE9grhJLG8QZ0E5DTsBeBFF6FPUqhKIEERexawLJ\n", + "JsbvCDG6AbUN8FaBJ+An/43J5KykMRdgzgaYm5D9iTK+OpuGze/cegxvOpb68DPev2GE925jaK73\n", + "hqMChBDhWfjkJ2ApPByTblcFfLahUk///fBxk1vh9w6CHIVWBe44BXcNZcPXhRDmFohMweIqnOpD\n", + "oQ2RLogawlrFFG08IVg2bcL00bBo9UKck222pFyKrvIiXBwzYMTiR3eE2UgamL0Occ1hd6tO4C5z\n", + "YTxJx9JZwmVc76MJnZRXpiOgokvseIQxGgwGUDR9hFllVYtQHVj4ogZ6TVkCnO+AMYBsB9Ln0VJJ\n", + "AmMTrG3QyoNXU/Pm3gBIUnM3eX4SPrKsRsyuBs9Pgn0GtLKkuG0VrVjGCyzS1Q70AopffwO5Ndtg\n", + "+wjsucnaYKoOByOweZg3mT/0C46jqLye0+/wuidR/pcfFiMfRAyLiu8IIX4M1Y9A7MtgPwQHy2qu\n", + "Wm7A1POqW9LvcIvNMzCA9EchcRC8CAQF1VXJt2BxPMTlT42TWEuiJyNorRS+CLDGrqLPCKQmSWsJ\n", + "bHwQEoFBDIdRaiyKLoHugwiBNMANQ3URcj0IKrijUPwEtDzoroAwIJGBzbByg87XwYrAoWWgBNVN\n", + "OBeF6pwKCxOHYa4BKyY4mkExNEO1MIo0DOpmGpcqmtEkjEdPC+HTJWa7aFYPl1VMz+Po+jyt6irn\n", + "8ybtXB//zzrwzE8zFfvZyH8KjlZgbLijz/bgaNHk2j/dQ9ferzSy8XOwuwAn9kBxEuRp5YvwmmIk\n", + "DHcehpG7b1LK7FLKpKMGfaNBN3oN5iQzmsAKXFaiGov+GJ2mrwiUwQQ09kLjSSU/+KgFGQlTEYhs\n", + "QdObID2kH8bTOrh6Dzu6TsXok9MsdosIRuBTBAY4mGKNZj6ErqXwhYPwM7gMuGwYWIMxnJVL6NYG\n", + "dz49TufIdvSJbZgdD0t3qIej2GKTaEzdG7NxEEYMx5jEFSPEWgJpZehEz2N8ymDLpMeWDWhtA9+B\n", + "cj3D6niaYhVCl5qs5fskI23SE5KGBuvflVLO33z8hBB5YFzFH43thrQNXSlE8lloPvI+lHnmRkEL\n", + "3xIRMKMM47bdcD7Nwy89AN1pqAMUFFs73oDfFiK3ADM7ytS2HafljxBcvwSzLRKzDUYiJWyjgiZs\n", + "SuyiKy16fg1PX6On30X79AnKk2ssboHJlM6kabEcm2bdyOABRqiD7hWpDza4d3MNM9Lgii6pyAFt\n", + "I84W6bBhJKiLOD08ZskSlmvoqQ6mtLC6DhlDYgSXWIuZDOwwyDAYZ2F3BvJhwtLGCJZxQgs44g6k\n", + "qIFdAnw1y700gXdykyfrsDilNl4bwPojkLsb9q2DfQ1gAAwY6PDNAm+Ip2OllVLvVmQ7EH3L8v1f\n", + "UHwV+IaUr3UJfps4BRzkbYzA34/4sBi5BcO29qPAo0LEvwi1h2FmAfpJuPwxuF6AzuOo0cB1uBHA\n", + "VfgaHE3B7jV47H5l4ujbMPcYBFtCYJRZnc6h9fo4hQ5eLEEqCFO2ozhijAGSKpu41IiTwQR0uszi\n", + "YmltGrJMFR8nFQGxSshaYTTd5rPPQHYAl6dhPQT1NrRTkNJAxmCtAPsuvfIOEwOI7oMDi7BpASaU\n", + "c4p3+ogepzybRg8b9ENRanIUP4hgai9RFSGyQRGXPj0cIjTIij5aPyBek0Q2m8x8H57X4PSFt+7o\n", + "GRpVGVuvQKO8JU00MwXXs0qX3B4H4xjcOQM/GFYttw2BS8LhHHgNiCWHlvE2+DNQv0avW6WzV+dw\n", + "2yLWh0AL6BouovME81+cxuujrscVTyXDRu6G0gamdREZzODpUwgC9OAKrt7CxaEh1pF6k7xvMCmS\n", + "JAMdA5+wrNERPlKk8bRJhNxEl2tEtBhp6eNqTRrZAKfdIbEKnzjl8Sf3J8Ar4llLGKEa8VCZgSax\n", + "JeiuQBfQEjlcooSlRyWq4UbbCJHF7M7jJZTT6v2rER7fM05z1xhpx6ZqVmi38/BCmFr3DAuU4H+/\n", + "YSs+/EwLiH8O9h6FfAacA+DWYfsxmKzBifvh+RDwN2/tPL9r6LVvQ1huQCiA9jCDKLodtkzfQq5O\n", + "gGcTfgjuewoOLQ9Yr5/he5/bykZyhXBGZ86WGHoHQ1hERJgwPkURwxK6onlZK7RnNLRImHHPwNS7\n", + "NGNpmmaUMJKeHEUjgW9AKVVj3texgz4pPyAWFvQ9j2VrKz3mMKgSsEZN9NCDLDY9PL1LPq4R8zyW\n", + "rQGaf4219A5aJQO2bEKhTLg9gik0hOkSGVjoxll6Yp2kqZPvO5i4NMwOG1PQ+Jdw1uYVR+KWECng\n", + "haNwz5IasQTAC1ug+iwwI4SdBacKXL19IepUoHSbUMpSDDon34Hz+wsBIbCALwNH3oXlzwJfexfW\n", + "fU/xXgbljaFMYHYD0du4Cb4P0P4unOvB0m/CyDawmrDlGByuw/E/EEL8OynlNdB2wO4cHFiCUgTE\n", + "lFKkVPJwuQ16FyKyh5GW+GYIDAfhV+na47haEgsLCGFh4bNClSYJLCbJ0MYENKJinQjzXMcnXHMY\n", + "M7vc3YGx4U1/Zg1KeyA4Ag+cgEgAxYIa2WzmYLAKgzBUCiBNaMZtLv9qBiOZQsOjozXpiBBSTyMI\n", + "QOoIBIY2QoCOJ2ySgU7Iv0jfqzPrQ6BBowyVl2DuHOSqUJqEM2PcpkvxxuB2oG4rbwwFm8pMmH43\n", + "C1fLcHcUehHwcqCfhumrasd29daVbCEO5eDBtpJGDdagNgkvxKDbBq+F9A20nE0l16fhaGitGqKU\n", + "IxZxiI7uoXG6DdEl+Hgb/F1QiaCPJDHTMXrRafBBGD4Yc0TlKl4wjxfU8b0QsaqGn7NBg0DXsJCM\n", + "4lLWypSlhj1okBAWk4ZACAPP6JDX1ikWXKRu8M0vgWNfwYuWyFkRAgoYWoIBGyxoJTrRgIwUBFh0\n", + "iNIQaQJ0QCATPRzDYDDmsOeEwXxujq6RIGqNECo16U3spdu4AmMGXI8oo7wor1I2aXtg7/3w8AJc\n", + "noGpNUVqPn4XjP9nle2yfKcQ4tG3mlP0bkBKWR4R4tpZmNwP66AyYU7CWOWVTA/PA+mpNuLLu9Yi\n", + "2pRLwoKYCauTkKpU+fLfNfj2/RaaliRWMnHdNkE2jRQWCVZYYUBLGPi6Ry+ow5RGRE5h1wO8RJVN\n", + "s0BLjGPLFq5eJCBHwk/R1y1W4gO26Bo7PJOS7+EGFjEk18jgE0KXOnCFqghTkDrKZk1QNpJ00Inp\n", + "JSaDOlfCGs5EGl2kMZ0Gom8QCdJYcZtq+kWS2XG2NgSWoWEXJePtKrEwXChIKS+++gg2fgwnYrB8\n", + "ALI+lHVYuwyh7XDgHhgJlOz/clkI8f/e5txfhcubMDoGe9fVCGghA2d8aP+DKUaATwMXpWThXVj7\n", + "LLD/XVj3PcV72RmpAg/x/ttZvYyh98XjkL4f7jwHuQ6Ehi1IAVQ/CfxbSExAfqCua6sHQE6o0NeQ\n", + "AYND4F9s4xDC0wNESEfILn2jTFWbxkYQkh06oouGDhi41NAx0KkRxcIB3CBCwo8SdTpEWy6ppCR9\n", + "k+V1tAeDPoyYcHlWSXK92rBAyMOZXTBqKjPXQQROjc/Q08bxdBuJQLUWiiBnEEFfWV/LTSQxpIQg\n", + "kPRkHx8HS0JXKq5cvwKJy+r3gAqzfTt8gvJjcOJX4IElsH3wRUAxlaO2MgPFJTh9BfZFQZQhcQFk\n", + "Ff7iVpdcIcTsAfj1SbjgwOH9UGtAfAnuMeFMGfbvg/YaWi+GNPoMrHX0sEdsySUY7YLZBbOl2MzU\n", + "IVzAHHWIM8AkzkC4+LqJL7roQQOXCIGeItBbtKSDW9Tpp/oMTEkTjYEI6ApJA5ewWEVaLhlCCCnx\n", + "hUCTYPtJplphrox49AsacmMD0wpRNycJhMAPwPLHsLBZiy/wHBqTskcDl75cx0XgkQLNQmo6bhSM\n", + "IMr1sTiEBG64jpwKYQSTKt/IHoFBS0mUD/IqR9KRI7CnpqLl/SREauozPxqDhRzsWVfJBSQZjjp+\n", + "XhgGNk6jrl8rt1q/l+HbT8BvXoHplIpU0IrwVF/ZaSOlHGSEOH0GDtxxU9F8Dv3eBmbeZvnhAemO\n", + "Sl+InfXZuTpgcdTE26ETxKcI6OIQIAloMIoghUkXR3RBO42QFtLsUrcm6Ik8kESKGOAjWaSqh7Ck\n", + "Q98IiBohHD1MX/ZxzBApGmTlJkUi6FLQEylClOnrHmBxXuiUhE5ChjCJ4uiWUub5OoHp4WZ3EVo4\n", + "Ry9xEU1zsfUuI7KMIeOIQQs3VSd2zeeOs1C+SwgRgEiArKGybgbAX6tx9Y1zm/00fDQO+28KFywU\n", + "4NHPo6z1LYjeD+mjMGVDawEe6cPpyaGydwXWv/eLHMr4FvCWE3rfAK4BI0KQkPJdt0b4ueG9DMob\n", + "AIN3yejqnUQW8gFM3HLSp+pgTykVoVmGugWVDNT3KuJaNwyGpkLnerOCJbNP0XoJEQpAGrgiBEgC\n", + "TBxhEaDTBUxqCDxiZEmiA308mlS1LP2ugd6Fjt3HIUDc9OXuWdBPQMRU6bwALR1KBtTDyi+l7usU\n", + "0zbLRhpX24qi6go0OkgCJC0QZ5DaNhK+TqB7DOQFNAGSPt1gHel0GfdgrAkdC7oZiB+AbhWaJlzu\n", + "87aIVf3n4HQUig9AVkBDuKw+kaQfR73e631YLcLIIsSr8L8M+T6vwgjccxBaM6q/nHgK5vIg1yF3\n", + "HrTdsD4LuR7Nks2Elybsa3jxNTrbBIPFKoPEfyB8CIJwHreeQ4pNwoHEY4FWXOLrl0BLIRkw0GYA\n", + "H0EbZBbPmWdpqkm+Z7EQTaEJDWhRoUkcjSlCrGoRDHIE0gTaeFoJ3RQEI3E8mcbTL9ObczEYJdCS\n", + "6AyIahYpBEaQQBoRWvQ4T4uGMAgYw0DDZA2PRYJwmEHQYiFr0s7F0LChDX7cxwlaEEIVcsktcGFR\n", + "2VX/4JUjqIfBHvIu9AZ0Q8o+3pRKBuwLKAt+/oXIzCR8dRrCJsglkGEhvt+7KfFbjRvEvytBAdXx\n", + "Kd+6g6/BD56F3DpMpcG4ALt85NadWA2Lrt6gnllCZATBtEap3sYbK5OJzCC0PJpzkc1QQJE9DMig\n", + "0adHh0CMoHkJulodJx5lICaIIgkY4GAxIDz8ti0zMMDWbHoyoGcYDISNKwQbtHFFkUDOopOi763T\n", + "06u0tBGkGEGSRMgmbW2RgCxCjuCa46CHEXoHJ3oGf5fPVheSuosfwEi/gSZ8Oo0MoeU2InDRAf1z\n", + "/P/s3Wmsbvt9F/bPfw3PuJ89n73PfM6958732tcTMYnBAWcqSRQ3oiltAlWFQK1EEZX6ohUSfVOp\n", + "byqBVFUgASnQCqigkBISgklIQoht4tg3tq/vcKZ7zj3jnsdnftZa/75Y+9jX5jq2g6/tmPykLZ2z\n", + "9/OstbSG//oN38GHnqoNnLcCb9wLIfzfMcb+CetlN4TQZvE5nrv3ZRfCsxt89ukQQpfln+T9z/Li\n", + "Q9ozbpzhE4Gbf0OtMdL3H1GEYB5/An/hndj+SfXyKl5QWxd8V8QfYEa+dgw4TOrZ6VtHoXttZocn\n", + "1NHXePWHGbxAd7mWXL++Ti+QzlZ86l2P2c1WlZN9sj2yVWKXEJTGCm3RKnaNBZetGCgVOjITmbGF\n", + "su9oumB4dKh8MHWY8dIKz7dJVrhxjqM5mjMO30Oa5qY6JkVqaza105yYthrayYJu6DpwDvMShbp+\n", + "mQg6ogcaClWIQjzSjBtSibScGlcjp3JWjxkNuL1JMaJ9il/+INuvcO//OvGK+b1Gp6nfb+l/vu+N\n", + "QclLFYcv82emPHaB0bA2REs2+Nm3S0Qg59Qiw5T4IT7/gFubLA1YLbjX4ntbhBfs3/+8GxdGzkqk\n", + "SeKwdeTg3Bkf+ELX8vHEcOXAvWen7jYbsntTB8++W0wmdYvfm1ir96cvxkUGyxwXDsefNzm3pB1W\n", + "RT1TE9F9Mw9t6RlpGGnrBCaWJHGqCtuOGkcm5YEsm1gJqVlMjByLKt2QyCSyLJeEXIhTx1YVujoG\n", + "oiCa17AgJnumndQnvyfVGg8dxDn5wcRx57TJ9AFr9zi4zBsX+fwn6zfSW+/vz3PrT9RG0otXufUD\n", + "QStGN/LaBuYTF9n69NfBrvhinIhgnVO7Ed/53Tyfvsr3O5f4Mz/KYL3mSxuR/Ut+IoSwEWO8/eiz\n", + "JzokX9WjJsY4CCH8rS3ZT7L8Myum739cs0wd9xoWhm3j5qK9hT3NYmpwvqWRHNpsblpIjg3TtgfW\n", + "jZ1DrlQJVUMSB9J4lnjoTtKQxVw7jOUO9c0pHYpGkjgWy2WDEG0lc7JQOa4WHIVTUtGRvqlXzcIy\n", + "6ZbKssx5LZmWxDg8qRLMLKvCAqbyNJPFurDJ01SWbqtMNCeVgxA8FgbG5ztm+7kqH7n2h+vR7g+9\n", + "pdvxO+f4jR/BP3nLqUrr1eGRqGOltocYtCi6uFiTzD70FvbM01uMz7L3rhiPPvaNXOPvkvhJ/JsY\n", + "vZM05kejmj9IRr4VEUL4ayTLxIr48zHGb/lIJ8a4XwubvfTcl4TNJimfPs3uz518ph9C+DsM/jrf\n", + "kzPMagXMUb/j488+7aC5Jhe0sz3D8KTKI9TYUKWnpnqMsSnV1NUQPXTHyJqxXKk/nbi/v6+4NvLU\n", + "DU6vs3GRjz1bY1Kk5BP6PZ6eNoRGRxkKx62ZPQsWQkcwMbUqN5XYO9l3gkQ0EQylOpZ1NIxNI3OH\n", + "fU9ei/KSz2S1e++Nuyx8nvfepjfmxmnuRHa/YSrvV8ZF/tLztJYYb9N6lXfd5//c5u9u8+QSVyYc\n", + "D3nlq+lNhBDO5brrvyB78ZzJ7eeNb53luFO3XS5HyQ+NVE8PqQrKJ23uTu3svSlbmDedHXimaJgb\n", + "T/Q7QT4YWZns211YcXDpgtgYSJOojL7YehcP0KSqaBySZ6pJbpqtCPGMtlQ7RImeypE9i4Kph/Zl\n", + "saERGtKQ6GMrbFlPWrigsqwII6VCJRGMJGmibWIch9bkYsjMqwSLHhkfl6FnVA5ksedWnmsXt1Wz\n", + "maJ1xnS3YnyL9jL/8jleebkGHn0F/XD8O/zO+ygfy4WLPYftzPbqnK3jodd/cFP5D6LJL3y917UT\n", + "wgev8KMX6vmhO4xDCP8gxnjrG7g9nniS1vqJQi61uN5l0pvyPxvC8qfYv1pvPnuelRcoJ+y8hBtv\n", + "I5T2dO7Cn5u3MnfZhmW9MDRLJ26f75mEjui2Ya/tyuRxp/fuOejueTgfbOSPKeNI0w1VeMwsJhJN\n", + "eTgwy0fy6jHTMjVOZo7SrhibYmjWB+ZAFlddGQfj9r6t0LQaC0fJk1KHJx2UFa1wV+mqIhRSz0mr\n", + "s5JwbKJUSARtlY66xdVQ6kskMpVGuCuIulrmkpGjRnCvmZhWU9MXxkYH7G22nXuQ+KX3D1y6z1Ob\n", + "LA9o/EAI4fPqMXoHOxxscO0Ma3tzfv0D645Wu2bNQ5vFNj8xtP42gNUzh/SufAPX9rspfgZ/+x3e\n", + "x3cdbuQ7JRn5KrOa9w65csgscP39IbQfxjj6hkW0/sNj75/xiYQbz7FQ1UXZ1q8w+e1azMyTKzxz\n", + "aPpGYXKa7hZZi72nl/QX1swnmamWqVTdOx6oT/4FNVbjAa5jTomRiSVMJO6ap6oMQ8Pe0oYza/yp\n", + "X6S4yfUF+lv8zrvpteskaB0vt1PjUKm09HWUFg0w0MfYVMu8O0YCeiozlZvoC1qSMJGEgbLc1NiL\n", + "3nWLN+e5eIf5J1l6yNNveXmd2aPR/2bQPP845WMnLIensFy7tP4n2zH+fbVr6LX6Tys/GMJaxfbn\n", + "cP0RADqE9Eme+a9mnk22HSaF4TO33Xhm1c5wU/7kxNzyU9qbx46bI0XjjPHgWDwzUc41lFcnsu7U\n", + "cevQv/v+rrQcakx2tbcXDGhudgAAIABJREFUTBcXlMtLsiRXSsQkV/O7dwlLMrk0jE2yfc3OQ/Pd\n", + "TAhti9WRftpTyIy1BfMKicT7jD1wPTzUNJBoG2tp49hTgp7MTK6ro69mk6faDhx7YCFEK3hTKtoT\n", + "TU21pAamHsrSwrpU2eg5Hj1r/95tGp/W6M2kyxPTckv7Xa/Jnz82fnhs9A/r8xcWcB6LbP5G8Kvf\n", + "u67z4hnV5x43uHOBwxHpL3Lm9olU/te6piGES+/iJ/4E9zsnlNstuv+CPx1C+Ktf772R0up8hVfN\n", + "TcmTu3rvi04d8YemXPsj3F7khX2u7DNLee09vP5r+Fdfvr3eT68608xNhsymmTLpaRUHsuUl/XFK\n", + "uaCRcTg+kLcGynZwKkwV8Q3tsGLOnmjfQThvK/RM7AseCGFZTC5KbInVWQ1U4VAsbypDYqE4drcz\n", + "MQsTHNgNlwXHKESZeUemekptqed0tIySzFRTpilSj91M0BakUqU0VKK+mXnz2vI40893NGLhqEhd\n", + "zzrGvWjUzORLlzTzXH6wY+PSGz6dTVyacGWR1b/KccbyyzUIf9Dkt9abrD5l0l/T2AkOhx82/fi/\n", + "4+JL7i9VvhKoedBh8hWjne/+CMG6mkHz0Xd4Vy+r3au/a+LbyabJ1DPqF/GxEMJfjjF+6ss/9eN3\n", + "vtQefCbj//vxEMKNb7Wz6MnY4R+EEJbUok97J23efIX/8plaGnxw03H7C+4tDbgYrWapyVxTSGfG\n", + "eqbaEs2TvOtLpmyJAQ6lunJrxoY2DbWsamlrxNJU4XDwlPxuJq7f9vqFWvL99RcIpznTbGhoOMZ1\n", + "XVMrUpVooO8xwQWJKNgx9bpoTkuBPTN76uToSG5DV66nUpZD7eHY8zcY5dwree81PnGFxlt0BMrA\n", + "F06x+cvfjHP9WF2RfTGeYvu3eSaE0IJU5y/nLv6xxMpsqrldOPw+bvxG7Y4scPajfGSPtUHfwe7E\n", + "F96/Kv3eI3lybCU5bRL7yksjvfIlw3JROdc1HR7QGDA3VSy/YGv1knxIGQeK8Zbj1aGynGmWlWmy\n", + "IgbqTtZ5XEVL6ow82RWroV62aVHTJKZyiZVq4F5ySt9AQ1eiEk1UVpQuShwpXZWZ09Awc0ZTW2Jo\n", + "YijR0vUZQ1EXS6KWRW8IjvVV5gSHCvuCqRXbcvMWQynYtdp8SXG5sj4cON8bK2djxfyh/D2Z+CBK\n", + "Drn1386F8NJjfHiZpyLpgP2BMn/B8ct/+C04oDHLp3hmhz+fhvCrFVd/t0R0mfe9cMKAevS7NQZP\n", + "snKbJ77ee6PkwR3Ce9TdvFe5eE3zh4eqbtPw7sRer3C2oPsunvnYl7yYLu0x+nAI4bMxxq1H28vE\n", + "D3DvQluZ9w3mpkZJoZd3ZaGFe2KrrTFtGZVXjReip5PEfojaYaaBkWWlPeteU+naNtSqgvVwYBrn\n", + "TMNZjfGhSXbgIB9LbEiqS/azgfmk57Q1uV19qU1tU5klQQsTTZmemRWZBzJrSpVSJUFhoE5GmurO\n", + "5raRQs2vioZmstCQyh2Hlr3GRZ1qyZ5l8i1Fa2Z8OpfMM07bGqcmhrsUs+CMhvlsYv+P8keP2IuM\n", + "P7fktQ91TTotx/tXlC/1GH6YwWvu/NjA1bV6PEPNhvtch92vWM//o4ifwMdifHupgW9ivIx3hSC8\n", + "Azom35b4dgJYC/zg7/6pt5rPtQuejLxxxYnHyLc6TtDgXwSNZrzwAs/8cW4fMrers75sqzOlVxhm\n", + "DdOqEsOe0mlNucwCHigfuY96Q25owbHEWWv2DHBX4oaenl3CglHxjFE1lS6dId72qZ9INE9nhqsr\n", + "pmHRtonSUKLUdNrAgpZSaklhCbmGQmJe6oLMdTPzmqYYKvTN62sa+cCU5W2KnJdatarr/T5PfoK8\n", + "5PAqGyMOL9Zd3DuBe5+g+sI7ff57/MW2sx9Z8+SbqaQamvYeOvVYX1ny2d/BIcsLrJ3oRywe5faH\n", + "ucb+vudOVdqzQ7sLmW4jdxyD7uiBYbzgfj9w94jOOkvPK5K2tDFUhZnYXFX0HgrpsVAMxEbUCAET\n", + "M7uiU6I3xHhf4VBaww6tZFPj6Zbd1rJugIHCrplCPXl/Q6mH2yaOsS26pDQ1cN/UmrZFubGhFJf1\n", + "7ciVgqaHFh3bt+bQJaUDXTN9xw4cY82KTNCajfSTB+YWmlrNSrMYG2SJFyep42Zi+/S86aiv/cx5\n", + "6UeeUx4+XQvWTG+w+DpLh7y4xcM1Brd5YsYLK3S+h8szfvpVroUQ/v5XS0jyum337+FDujXHvP0N\n", + "tNPuv8lnf433rTB7wA+eFXqF5u7jFrbvu/auV7Tzyvcc0j/vhNpbM4Iew6sXsAUhhIvzms9fkLR7\n", + "To2OdYttm62O/XSkig/M8gazVZNsR5hPjNNCEQpjuSUNiT2FNVVcFMKGRUf68aylZMcgDuXhqkl4\n", + "4KBBGaeKYWlhNm/Y3ZUlK3JL+mboSQ319B3oKNXvsdKWRNBQKcxL3FQJSlM1qP1sfQ7LLVmyoQp9\n", + "ibbEWT0HDgwM9dGw5Zw8dswVUTNdNqnmVfEzdtd3pYd9F+Y61odHdBu2O0tuzZ/T2z1weGHT63eO\n", + "fc8tPn25bW5zwcqgdKvZMxrCPNMVh68O/Mph7Z7QimxO2fhHMcY3QwhrKZcrysit7xBH6HcyPuqd\n", + "Y9F8MWK0GYICZ/2eZRS+s+I7ZUzzdUbCVx3pfPPjBHDXxMFXGrbBCi8+cZKcvKH13l3za7mD+Sfc\n", + "ambuhoeigTl9M9dV5pX6MrekzikNMdQxlGpbNCcXLRoaWffAil1vSuKadtGV56lpuGOwkFueazuY\n", + "P20aHpMYKZ1WigqbCptmDk1EmYsKFY4NZVqCoCsxk5tZdaRyoGOiE2kd8cJNGgUPF5iNuPfrPFbw\n", + "apeNnI2/zfQqDx8/OTcP3+rn8R8at1h+a3fkGmtHvI61ec33d5zZzSQVdDWO10wWh5ZPVeaf4ugT\n", + "TMNbwcaJrUuFc42m9mSo3ymk6WX9pCfIxORQGu5pzc0Z787z4TPMllTlxKTRkTgSuqU8aWnMhnR3\n", + "TU1VWtjSNNTRNjCShGOrsTSJ6xaqgSKMLDbvGVcM05apkWiqnvG/oH74jiTmsK2yIGqbaEksmjhU\n", + "SXQkZkZGUjxv30OFBexo6TiDBaU1G3b1Lcrcc9GWkWGYWM1bNuIV06SpH/ddT2dCqy3EVBUnQl4o\n", + "H++YZvPmqoZie9e0t2p28woHt1huMX+HM20eTHj+HEdvUn6QN3pMM576t/X8+m11JPZ4/R5PXXwL\n", + "86bCmzV+5Os2rzsRLPunv8Ubi/zF5ynGuptz1m8FWXlZY/qm3eeOjPe+vJChnibVZoq1oNvSn1/T\n", + "3GubrjMJixaGA2k8cC/fNhw9y4MnySdma03tNJi54XpVqtKora8j07FlHEqlqUNnhdA1NjYJpc3w\n", + "hBjXGee1YnJ1y+FRzgtNmXfJ5IIoGqp8Dnc0LMlOoKmljlRTlJrpiXLBfbl7J4D3BY14rEweKCSa\n", + "uiozqZ5FDVEhGphJzHTMQmWSJdJqSLrIlCItzbWbWnEqThuKuObcaCpNj2wsNBTZaRsrY6+OZ9Ld\n", + "I+l0JsQgmytIM8q7LEy5yfbfYPuUGsu9FWOczYXwkef4yJUa9Oc6WiH8/DjG3/56r/nvpwjBHD6M\n", + "P/0t2uUj3MgfJCPvfLyVwTJJuRmYfSOAt99TnNDVfpwnX6hfHfv9EPJfiHH2yld8NFaEYzrbGk8c\n", + "6T99RWyekYdCu+oI6XXLdmxZlDmWOEBPW2bbNbm2RQsn2hUDdabVsCDYMFJpS2JCOiU7ovPApDdn\n", + "M8w7Cuc1jAXnRatS4xNmzorKrhrlP8KOzGld0QSFvlTUiwPtWV82nVge12rZ65vsN5g1uIfBr3L0\n", + "P/O5FfUis/kWBsRr78S5/zXCJueXmG7TfK1WVfslXFpQldOvMKpsyUaZo+WpIsECW7f5wjne/RCm\n", + "minNZkvcLPRfWFFk8/LQQDBpLsmKA2k+4bnzTCriA3ptVT4UQ6pVToViX9HuWhEdhI7UQCa1bMmK\n", + "u+47UmpoVy1bIbdkwWJcVqSZU9WWA12bnlC39LpY9MgSOLgtOC3qSCwp9UUPlHpm3jQ0Fo3VwhoR\n", + "LcdmUpV5LalCZWhsUWZRz0j7pM81CTtu5I/rjkdmMdWdtB22Vxw2p5qTrrZD+809jdBQaCjTRGxP\n", + "Ze1NZfus6rM9Do9IHnAh0s7ofRprvNQ76XZcYf813uOrJCMzXv5cre9y4Qo7M9JXWb1dg2a/ISfX\n", + "k6LgMxdDuPk8r1xX/DFChESIp8TDI1eXeP9bkpyDJtcLvBFCmMc55k8vSB6kkiLaW53SqhRK/TBX\n", + "d8jWD4nBTKIsGhppV5rMXNYQTCwa2arRIPY8Zd+6oI2ZIq6LYR1nas794WWmm7VBVFwRHSuQiypN\n", + "lWW5a7qG5vTNa9r3vL5FDXcdaynsm9nHUBJPa4QBYaJ0WaqnUii8IpoodGVmJhLBw1r11bxB0kRR\n", + "A7fDWDNpaZuYhaFRryWbxrpz15hznJ83FWVh6uUn7jh1uG9u6zV3X7hocjAk3WD5M7Q2+H9PwMFf\n", + "HIGFEC69yA/+KHebNXvKc+T/vGY+3Y4xbn8j1/33SfwwfivGbxnd/VEy8i+/1gd/P8R3eDLyscd4\n", + "fECZcLXJ7X/9zazCIYTwOKc+RGOd0W32Ps7qj/F9F3jxXl1h7bb5tZ85cf28/ei727x0jZ9+kaND\n", + "8XxX2TivMhFCpUpapsma3F1nXLfptNSqpmisLzHEsbaJXKKmCCyq2/8NwS1UiiQhmyiyDTrLJCum\n", + "KM2b2jlpzZbqJ76ttKq+sInUntKewm0Tq3IDldtidSwWpdabUfOYq2dp7NC7QZmzOc/du+z/45PW\n", + "+8Y385z/bnGH//0hz8/VduUPCl6LMY5CCCu52e7Ig6XKUkhOKt+xabtyd/684Q+d5Xv3HDTv+6Xl\n", + "kTdbrBdT4+MjR7Gj1+o4aizrmWkZG8lVoRLjnCjheErZ4MyI7CzVvCTdUSabQuuhhXJZzBKJfUFP\n", + "R6pj08Ce01KlrhvpunEcejNMTJOe+TIaho5dT0lclBifqKQeekQHLm3hOalDLbm25ZOE656RA8yf\n", + "3BcJltHALaWJiYZobGLOVEulFCVGTht5w9S8SqFqBKPRWD9fMosNeXHLYZprFmuaWobxvmFemFRB\n", + "ki/JxmNheYPnD7lX8PnX+Df3ePIxlj9Yc0C/qLtT+yl5Gz+SOk6u38/+Oh/8HV6MTHb4uVntwBu/\n", + "Xq2hWvMie5aFSz3Zwo6iOu3w5Q3h3cFiGSRxqp9z+G9qJ+LHL9Sdshsld/7ZMj+2yvMZ7Ztmz27L\n", + "wzm9qzOtBxOz5SObz5wW08P6fM+j3KAxVmmo4oLGbKqVBYOkcEtTruFIZtu80QmQNDoyDo9jRhiR\n", + "BdqR5JTQuCqmUcPYqjkNUaVvqLQjk1tx2lRuzrKbXnHO0EhlR5RjSVAK4dDUohpwU9XHpyVxRvCG\n", + "DQt6FiTuS42slVvuJ++RxoapkslnyXNF3DXt0hhNOeyKrajfntPPV01mC7Ldmap9wSir3H/qjFXH\n", + "xuGWaX6dpwt+c5e3Nahc5IVnGDffcl90mT1FvF1j078bk5GP+pLK77ciXsb3fwv3947Gd3gy8lt/\n", + "h2vPUk05fCXGeOdrf+frjxCaL/Lu/4L3Hta0to1n+M3vY77J2YdsnGX+oDZ5et8xm98fQmOVxY8Q\n", + "LjF3/3f0Jzt8pNBfymmNNOJIKXOUnsOOHXMuKjXt2HNspHR0AmEMMbEbOCOTgg0zY9typSNBTnxF\n", + "kSyowWrnTS3hQDA9YWUUMjOJkZnGyaI1FgSlqClXUwrrsdH8rO/yzcr2K/z2y9hhfI3FD/BLHyJN\n", + "GX+c3b8bY/XqN/N8fz1x4mnzdsC3W1vcPudua095jjNKMdt29/RFW9f/FNeblCXhU0bFJ3zm7nFd\n", + "qX9yKPwPmdnzibIa200b5spEqSMZTU3CsXG1zOs7vPg+QoLXyfqqdCKrxlqjzOl4ZJqNtFKe1JAK\n", + "EjNBU6VpV1PqReINo3zPlokqSUSZqQ0j93Gs7ow8e/LvPameaCKRSzROAIo9HVOlOU0XzKwaO1b3\n", + "Y5fUK/yOA4VdDYsWFep05cgFfacVRqZuIjcJOXcTG2lLfjbIqsp+xkwqVPMmYcvQsby/xyRVZIkQ\n", + "77C6w3irdi/+5WN+Y8DSfI3dRd27vMrSNv/i67iuv3ry8w1HzfI58+d4fonTw2P3Ox/zyvf8sK1f\n", + "fsber+3YP31XOHWs+k38b7yyzqvniSVuLPOfPcEfmqfKGU/0d/esPXbTwYVzupsHdi4t688vEEri\n", + "MVmb0Kn9CZpNlZG9kIlhJHcK8wpDdyybOHNy9mdmUlGFIIsH2o19w/UoNmeSfKxhpmViZKaSSBUy\n", + "uyo9iyrlSVHRMbbooR2Jpp6o7cAZ8USvpEZsnVYzcO6pO6GXRFOZvsIDLUNrMmV1KIY7ZipVVZAN\n", + "NMKe+eTQJEmtJHPKwcykCsbtBXdna4bbubQcOcw6hEuyIrFdPW/0r05x/+c5+zq/+nYdjhBCNid5\n", + "z32N7zuUFV3TjQumry1ynBOTOg//rooQZPgx/JVv4W5fxn/3LdzfOxrf0clIjPEarn3ND/4eIoSQ\n", + "c+HH+ciDL/mgLGxx8zzl9zO5RZLV4+nZhPw+/gjv2mX1EusjNt7d8Fvr9I93zcfS1J1acjU0REFp\n", + "0a4NZexaUEgcKsKyaWwTFpWhsGlqLDVvopI71jFyQ0MiapqFUyfH3OQE/zFVqjVJOtgyc1o0qGm5\n", + "dlW2sGJFTf6htFKVdSq0XbnykFvbjP+Xt2gv/MojR9N34nz/h8aJNP/fKxU/teBOf+buwhHTjvjG\n", + "R3n1UQWWEj/Andf5viUurlHdcvf0UKPZ9ORw191OW5I2jRWOs5bx0YEqnUlePBYWbylb+cl2JmKZ\n", + "aE1XdcKR0GzrmtkQzUSnFMZSAz0NEwcaJloYWgzB5TAn0zJwZOJAaUGhq2Fg5JNK59AX7akMpc6K\n", + "MkGUGproSyxrSfVMbTtr5tfVXZXzOK3wmpu2LGloaZpYc+hiTfOUGxkSO4y67B+aHM2bHG1xaZnJ\n", + "Y4bTSuhsanZyyXjB6c9sGizd0j9TKLq09jZ0DZw7z8O/wPbP3uWf/jx/8mk0ibfI3uDT1Ts0tvtS\n", + "LP0A3ztX+z/BEzsHFopf8OsfetbBp/riaFv85QN+7uQe3jj5EUK42OOnzuIU0zHpnqN2n8Nr1tO7\n", + "9h+bc7j8hFK7ttsOdwmBLJFm+7JkaGJeFp/Xt60Gv+zrxUQUCcucjNNKi7J4VxHOCEVilrSExkCV\n", + "DxUWtBxI9UxOCPUcK+1bOhmtkCkMPDCyq6uhJ1Nq2LFg6p5n1cPKvjo5zU5+WuiJUlPrcnv6Doyq\n", + "05qjmZCfFaoxyT2tsvJ4OK3T7BgVI3vG0rO5o/7M3uSS436braEyGzB+nJ1rpsnjpr92vr79PEV8\n", + "gye9bYdj8aN95y4/sNd+3MLmULl61eaHn3b0G2+QDWs58++2+BDuxOibWjB/jXgFT4cgi/HLXap/\n", + "P8Z3dDLyDscyq19myFbjUiZP15YdzYrpEheG9KfsNOmcrYFwjX02qtRhecmykXy+59ys8GbWNGxe\n", + "kmjL444qvCI6ZRYv2khywQMpYjinRu49g3MO7Tl0pMYUXFNXv6fUC0xfXQVdPPndUL3yV1q2BDeM\n", + "NQQrkhOWzkxHW2reTLQrSJ2SmouZa4szry+RHD9KPE5o1lfonQshO6R8/ffuuvvORYxxN4TwN7d4\n", + "mtjE9cf5nxbqptEXY4uzK1x5N6/2GN0131i0NA3Gnaa5wb69zqqq2DLJ+4p2IcSh1uOlSZZJw2lB\n", + "U1kWsuObhs37YnOikBpVTQcpn1Z4WsO8FIX7MntOG3ogTSbOSjTsGzltzwUN805p2XUsuiozE11V\n", + "WRUtYEHmodKeqY7o1kmFPNG3rW0oNzYzpx4SN9SdlYsmPmUjHhCeklhS0zyneCAgxmvSuKB1qZQM\n", + "Hxrklerq5fq2avbFtWtmnYneqC2Zn9c5GJl0Eou3dkx7q4rWOYPH9jReONBuT+Lwfw0h3L3NUzmt\n", + "Ye1cfeebmcTWhYLH1Jn0Lu5y8UWe/TJF1eg9Xxi41f+0g3+KN7+a90mTP/oUvfdwe0hzhzMXWdp3\n", + "lA8d34zS8SnllYT8LMkeoUEIQpiJZqoYNeOiM2FoPyxqxnlFuONheMw0BjU4c+HkqNqK8HniliK/\n", + "ZJaWtVqwS1JruCrzpmOVwkBuYlEUNbXROOFcvekpHfMa5nBo5J7MzLJoUxQcn5B8H3VlJrgrigpB\n", + "X0NlQQhd3eFYa3NTXCmV62NLjaaumSrk2rML0t09w6yyc9Q22H7I4y26XUY90jtcGvDK2ZNEBFKq\n", + "9G3eHyGE9cT5H181XslMexvuna3kg5asvK7xU/eVv0j5Hbe2fBPiWz2iEaNBCO6rk8J3uBh45+M/\n", + "imSkBqRaV7eXH54snBNG4ctBsq88wdoFhqPaffdCRbNVCwC9vsaTgeWEi9s0pql/fanQPBwq2kEy\n", + "OaPTSTXLO/pJUIWoGVeJh4SOxJ5SVyFRV7b3kAimch2V2wpTtRDa0+oj21G3YoMaLbinXnxqW9zU\n", + "vCXH5u3q2bKta0fPoTmpPSMHchPnqyZFpVlVGrgSuf9YCOGpetOnPsJT5zkzrf1lrk5OHDm/IXDh\n", + "Ox0hpFdSC39pXni+qWhMTR7umz18SO9M/W4GuzydcbzO8U1WS63Fy/LxgTLLdaWa1YZptW+WPm9v\n", + "NtPpnJZV98zSNbPQlaqE0FK2VoXqqiLOTGJhKTSslomNpO2VMNVVCnoG1g2cU3lZ04FER6V0pCvV\n", + "OKFnTs2cxaGZEVbVyegOxiqrMrcwlGqZea/CnJaxwpaZePKdmhJ+khajR3iILZGTEcE2mhKlkGy6\n", + "NNjV3O5L9kfK4ao7p+YNb7wpefq++emOJ/+fnvvPDxwudPWTXLq7a9Y5ZbRwztrVlt7BTOvodXs/\n", + "mobw8zHGL+AdER8MIayc4b++wtIS8T7hNjf3lCnV24FLCvUz/VVN2JZ5vMdgROMBT57CBfpjFtti\n", + "475iISdPqe6THZM8jamGO6KzWrEgHDg2L2o5MDCLi8ZatWGjnJORWP2stggDMR6eMGauqDlP1/Vd\n", + "Vlg6GfRtmLjl0JHUoaFKouHAMwqrWgaCEmsaRiY2zdmV6atcUC9otzxSc65xZ1NzWuYlJg6MwsTx\n", + "YjC/d13WXDNXlnpxIo8TMXSVSSnOd3UHQ41yanDhmI1jtlv1uCo+ZLHJ+NEqWRBuko3exikb77tk\n", + "8uSzlu7kuq+OHK7u2n/+hk449L6rrGW88hdDCH/v93J/fCdGCII6GfmT34bdPwKx/kEy8p0cNYWv\n", + "+0e58gOcTurH9f5GCOEfxhj3Qli9zhcee8S84PgJGilPX+P2efp1gaS/XCt9Pztl3GDvNKc2oouj\n", + "fTsLuWowUQ4bqm4qtlJ5rKimpkmbsC/xpkql8ozaZrFmzjT0BW3BgdI2HlczJs6rk5GmWqG1p05E\n", + "FtX0gzHuGGtYMLYqWDa1ZuR+tWO/SMhWnKpyucziLErSsVE608HDK6SX+cCIg4z1U3zPx1g4eaFf\n", + "mucX//MQwl97pGz67Y4Qwnpq/a88qXHhsoWtprToO1q65d4f+iWz3o/w6jmOdujc4Nw5fqtNscWV\n", + "ZbPDmaq1JJkOpf2RuLqr0VgUp5XEJelsrGouiRZljiRxpEoKVWusLBNZyKwVhUaaGKeVUwqlFQ+N\n", + "T+QzKrUEZUdlZGjRnLHCosREif0TH5NgXXCg1k9NZJaU9kyMTQXBxMR75Cf/S/QkUqVX1YnqbR5p\n", + "TGip/XHueCRNmuqqcQTXRYtC2HLc2XF+kfa5VNLc1U4+4eVTMyu3+fF/zIW9A3feuO7jHzwlnI2O\n", + "TidGjYalOy29A8hl5XnpqF9TF98RTZkQQljjpz5S+9Xfgffjk1z5NTuzqVdP8963gCXvLbC15y0s\n", + "jrfZZrpOd0h5lRfOYoHjCfmY9DE+e8gP9UleJL1fM02SHUEhlchEeVyVlwcmSYfQc2yJySdpHp9I\n", + "DYzUbKfL6s7m2snuHxNrtT716rOArrHeyUBmAQ19r5o39S6pB1LHUoVSJRUdm5gppYKZoXuiSuUy\n", + "zslsKe2cdNgu6NjQtKLjntSqNaW7WWl4fmQ52aVMDZLEYliVxKEsXDXrlfrtxGiuFOLzFnf7xvPR\n", + "6OVlHna5+CrPvML1nPIac7e+CnB1mefOqia5tISCbtcTO0sm7UNLu7zvPmd6jH7yG2B1f6fH82oD\n", + "n899rQ++A/EoGflH34Z9f1PjuzoZqc1Zn/1RfvBNWieo7mur/Os/HUL4P/Bz/OZPc/siy5E7a8zt\n", + "875NqjbLfUYLbDSZDYmBokWvYrA8s3Y4MFu4ZHj/gTQ9dFSdliSpPGQYmrijCm9qmsnjk0aB+gXy\n", + "eUGqY2Bi39S20ll1j6amndYxpy75a5GtujKeqROTicKhqURHUKhsR0YF79qpbC7s2WvXep/jZmmU\n", + "TM3KSj6miHx/Sf99pHdr2f37f5i5X6nZQ+eOOH2BB3UD5jsieh9ckl143OLmo4VuzsL+JcPGyzbL\n", + "n2fU4uKM/T4fe/cJhmTK8nOOb73u4PLA4lxd3aX77J2ZNylH8k4pyQtFWgphTiLTjBsmMZeUDTMd\n", + "XSumk21HvZm5WWmSpfIwVTmnfsGM1UvrGXQdOdSSypUmZsaWjbRlpifJaBTN4/hETb2n1lUlmlMZ\n", + "i2bmTnych5pSlcwtU++VWRBMlKYqpTqJraQKwU1RT/SsqJJUqWFnZL/dshpbJBOnq6nNc/OG7bHb\n", + "o4H5X+XiwZ71X9nz2Yt8/Huf19Oy8sW3xcyoO2+20Xg0jXhnYnWN848SkUfxIg9eNjn7wCe3OLjE\n", + "mXHtkv3alIf/8KuNiB4pJM9zLq0f2lafuZKs4PiIWxlnEvnlLTHfUCRzddVRdcQwlYW+1Fg7NE1C\n", + "IomJcejK4lVFWCJdnziLAAAgAElEQVRcJtYFR92NOlQ/ryvq53Wofmb3BaMvMmLoKQ1FudxluTeN\n", + "jS3JJUqFiXuOHWhL5FIzDQcm9hx45kQ6/q66WzqvaU3pQDQTTHHb1NicZV2Hemkw63V1jVTlsq0w\n", + "1EruuxzrnspxSDzM10zSiWS2obrYsjgpWHne6Gfn+e2XmP7KyS73+bSvguVrYc5gf2Ywl2sPZ6qF\n", + "VHvUctzzRePCM8esXvguSkY+in/2bVJCfRl/5tuw3296fFuTkdoIz/vxUozxv//m72HtQ7xn90uJ\n", + "CDy1w7WLbJ6PMd4JIfxNts5jjtUR5y7w2Uu1M+3DJUZzbBXEIbOCnZwqY9biqDwy3brn4Ch3cKkU\n", + "5gpZyM3ManhaOJabWZFKwpGxe6ZGeFOUONJTaauxIKX6YR6c/Dt65KZbZwRN9UJ3qK6O24LctomB\n", + "oTxGpyfMTqi5D5uli9OR00l9vFu4Fep6uhdo92m0eLDK4jUGi+yusHaibpvyLRSY+9rRuDgnLR8l\n", + "Io+iqTvtEt7k72B84qJ8/lP8N8Ma05Alik7Pze6RxSqYizODbjSYJbozJunEtJlrhLEiPhBPJvhF\n", + "0tMqrinSUj47FvOmy2VfnuWSkNoxs+mSY7tqAEZeG9lpi1IPHSrcMbZsZiaxq34pHaMtOlQ/gA11\n", + "0jlVj2xqMGJh4kCuZU4mlcnlRjJ79rVVKolDtdniKWwrLMmkKldU9qkGlKc0ssKwmulr6ZVD46TQ\n", + "jRPD3pK9hZm7z0wtfJpmWSfg1T8/sP8TY43FTHNSmrSCnSI3uT96Z8GHeZN/rxPXpMyIbP1Ndp5g\n", + "/jz9I4pt3l52O4SQNfjgizzzAT75SQS6cxSb9WhlM6H8grM/cuRMPpZWr3gjnNUP0dg8cWgYCktV\n", + "1C1vG6aHpqFjMttUZkOa766ZOemwPkZP4/PqZ3mgLizeUD95y+qxbEfd3TquR2hKwaaZRK7tNQtK\n", + "MwN3ZR7XV+mKlkzFE4uIBdfddcoRUlHtRZNiX+qeto4Vbd16IEmM0ho85Mi6pTRXqczi1L2Q14yh\n", + "uGSpOjaIQSsZWpsbaadHlrq/4uZHP2DyC/uS8b5z55hr0L/M7q+GEP7dVyaCQ260jFe4e2Gsu1wJ\n", + "LfZj33Sj9rZ6FF+VCf77Mf5T/I/fpn1/1xjmfTu9ad6HbozxwyGEvx5C+ECM8dPf3L2kiyy8zWI1\n", + "X6nXhUdW43frY0pTBj/D0g53zrPZ5vAM58fELv+2wdMvMzfh2jlu9aPRZjB3cUlx6qzKnlacGIdU\n", + "mUS5dR1DG8ZmRkqvnkiAn0GtEFBXUefU0Oi6aqr9ThbUYg576hpiTp2EPMCmdTwhcaxypqy30kj5\n", + "dMF+wlrFelH3UQaN+u9N3G6Tjetuz9qAxog7C/XfihPK3U6Hh0PfQn2Rrx2jG0ONRqkKqST2jdtH\n", + "+isT+6v9eu1vxBiHEGO81wrhMzP+bIf1Gzz+vGLYsLsZ7RxvyEOpc/BQmp+TJfuG+aKy2RTDfeJV\n", + "w5hR7AplKcymjmNTO2+4nlfSUFhTmpNZ9LKRU1rOiVKFmcp9+xoyi9pGKtc03RfNCSLaUpSuqxOR\n", + "y+qs7576mm+rX2DzGBl7Q0NAsCoXDPS9qVA74jQEu9W2KpmpE5LT6qW+TyyVcSqJa/J415GZEDIb\n", + "1Rmd8g1VIzhqNPTPTm2ss/s4L68x/ltHir+74/YPn9aYrpjeLsX+Z0h2+bfv4EXe3mKyVzsKf/G5\n", + "vcGpYa03M8YXmiHkp/mxtfrmTdZCuLXNP4kxHoQQ2vP8yFm+L+U9Q/Z3OPgwH/842y/xkWXKc7z2\n", + "eQt/curpcmxpVGrmI63GPVuhdDMdmVlQFkMH4VA/2aKiSt48Ie4+JimXKIdmVZN8oH5Oezgv8ZmT\n", + "McppdeLx/7N3Z7G2pPd12H9fVe35nLPPfO58b9+eyWY3KZKiRFODNdqOIkuWbdARLENGEMMPjh+M\n", + "BEiAJH4zkMQPCWA7ieJMzmBYliVDEjRYMi2ZpEixJXaz52ZPdz7zsOehqr481G6SoilzENlNClrA\n", + "xcXd9+yza9euXd/6/v/1X+ue1IngzMw5LCndQ1CYqLYILROrgjruSb0mtaSFmaG61KXFoPjciaaZ\n", + "0rG+lrlE4kiU27Sjo764to6NjRzJzMJ5R87MHNsSbYXMyJZQpFoK0YmNZMvGfFQNEtVqLo4OTO//\n", + "Za99x4nH7vJDpyzN6Nf52I/yVPRF2qFTPv4Z3v0ek1uXTF67Kz27Kb1y6PqzVUUEXt3g8I9FWSQE\n", + "F1WFyW/k9+Lfh1ewE4LlGD+vm/tWxNtZGfmAz6do/ga+U1X++zpi9FluPs47v2BRzQN3El+izxxj\n", + "8WwI7V/g4IdYu8PoEg8+w9WCjRNOl3jyKs+dcRBXlc0V7c01/etRq5nLw7a8jIqwJBrJvGBkS2Fb\n", + "ZqK6WlbxDhUbeknldf5ela/8q4vHuz4fg9kWBEGq4UjpwENSlwUXFvNcrwRqkTJWbabunOV18oxe\n", + "ViUNdwKdyDRWG81GjXtNLj7PKxuE81xKObjAswl3/8kiP+ibBKNPnqrfuOHo6rJ6r3By3wVFfW5U\n", + "rjF6jb8ZQviZGONhCOHSu3j/n+NXP8Yje+rbL6kt1YRHpsr5jNk1G596is0bllorRkuvy7NEkq4q\n", + "Y5AWZ4qsbl6P0tGaYWPHPGaWTSSG7rgj07MqGFsWbWk5MJE59oCKXJwZ2rcic79TfYXEhkThzIET\n", + "wdBcVQ0JKro4X/wdVavxCs4UXtbS0ndO1Besaaijp4wDteLQ3EWlg4Uae+HUGSZiiIbFREzGzrQs\n", + "Fee1i6E87ZhMxu6VE+EivR+upl4vPMeV9/V9evc5Bz+zZ/odKe0JN/f4VzHGb9giEmOc10L4hd/g\n", + "rzzBpMvoLqufYu3Q+lkI5/86+/vv4rt+iFtvOsA+z4Xf4idDCP+oI/kvOro/WLNcMN4OztZfNGvf\n", + "4cVxJV7tnXD5Dt99oLE+1xnNdQe0G8fKctVSPTVMZ+7M7yhrbYVUEh+SJ11LcYAl5exAUb+rVraq\n", + "UeyyNE+GcoXgdVFX8IwlVf2ysGpmRWIfz5tZUm1AmirSsKLuwLGb6toypWbMzALn1SxZVTNTN5Wj\n", + "Y1nPZU1NdX09x8YmmhJ37du2rGHiVMNReMREkLilZs2O1KaJ86LSrlvpBfOirlC3oS2EMyGZS+OZ\n", + "IpnYvDc3zPjh5+ksYoSWZ/ypO9z5vhDCk190n2gO8GkeTdgYKUb7Bi8UwhHPXuC4xss99n4O//Ab\n", + "dS29hfhR/EqMXz69+huBGBUheEGlW3kbEu2/fng7yciqz5d8z1Qn8+uMk4/xqcdJd7h2SL/B0zvc\n", + "++gfFtgU4+iTIYRPc/N9fLDOB2/y+ndytF53Y31Vv9V2N6SK5oqdGxN2WiwvmyW7ZiEjvSDVkHjZ\n", + "WB2PWFJTc+jUO1QkY6iqgrxD1YK5qdohD1WK+H1kUm0dA4kVNa9KDNwveEDqUCJXqJVREqrizkZC\n", + "c7WqkAyRJGwn1VRQEbiRMC2qn7vdIR5y/i75kGc+zst3GR8xePqtTkb+cogxnoQQ/suXTP7OhvzH\n", + "3yUWhfJoXfzE+3h+h50h34d/1uVdjzArSF6x+t4VsZNLamNCqVMsS7Op+QOpznPH3vtyMP+hroOL\n", + "25JmpiGo1ztGemZxrnQfg2CyNJZKtaygJzdQV/OIU8d6blk3c0VitNBy1NRdsORYsGTTPRxJpUpj\n", + "NY+4Y0XuVOkcrkm9vJiSOFAZBwylVkQdQytYXgxy7hsIVSheGEjL+zTzkTw9spQeydMrGmUhjyVS\n", + "J3GoDJcoo5jumoXozMysl6vPcuNlJrtsvdpxvNFyenWq+d6B9Oi24u8h+VLZTN8IzGN8LoTwj3b5\n", + "9gbbRxprM+/KebxF0uz49T+/4W4xkvci4xl1audXhW/fk5+vufRXtlwcN2XlSJEeO7nCa0tHpu+4\n", + "WPG7uMTxEkd3yebOq1zuz1pzq5MD3WnDkxsXpdn96vmWOHld3r4mJPuKpCuZtdSLwjy7RXrdksys\n", + "mMmTPXUtTTcNZJasayuljjUd2DZ1y7K2FUzNtFQ9qTlywapuPBTC1Hlzt0JHrlSqqamagDOnopYT\n", + "l6WW1aSCzKrMxNQovkeZ/75eekMjuWzuumhDY/F7ltwy1hWNDbEqsePM7WTFPAZjNe00JQzV0qA0\n", + "1+jTiJ8nIm9ieUaniZbFJFsIYeUaP/2DDC/yKyV2Wf41w+UbPv5LtDtMjik/G2OcfKXOu9/k+PP4\n", + "x2/zMbzZqvkTMvI14ky18aMqBPw7fv4hhL/7Bf/8NzHGf/PVvECM8SCE8D/R/x7aj1AMOPgXzH/v\n", + "yzxvFkKYsjGjOePBjzb80l94yMH2tnSaC51z0vlt/fuGknbEBUkIaj5r5o1FD3eA+4WFfVkpU1U9\n", + "thdvtpquqPrJr6C3cFJty8x0tDXUNOS2RDWJl3FtUcjNYuEsRK2kEp0eqPzWHp4zrPFiWjV2LsTq\n", + "8cHilK+G6h5+OmX/aW4fc/BL5E/HOPqmmJz5wxBjvBNC+PvnmL+jmr0e1Rex9A+x9zs8FkL42Q2a\n", + "dfIXOZ9JLm8oWpd1CtJy37y+q4zR6Hzfuae4/9Ujzz297dbFJXE+l9YnmmWmMVmTx9vyekOZnOqV\n", + "M51Y0445SUNfaaqwbNVQV9uGqSWZYuERUqhb13ZqJGpbUndgVXX/5q6+mRPRIglo0bZbF7SkC6t3\n", + "gpam3Ia6poFEW1vbyEzNmUQZlhTFHZv1pnfEQjE/sK9ulpZ62UxaduX5un6WSsKBeXpXOTuyM5t7\n", + "ZMgDY/qdLb/94w9rvN61cjhWJrclP3VbcXMY48fe6s8ZPx9CuJ/H/zp/9oWFk0baNNvMZOf68rV9\n", + "slPtpZrzt1tmTfIPd2x3lzWOU6FoSMcnuvW7utc+YL/3DgYjwhGzFzWvrUmO993r8ESfpR43NjhI\n", + "G3r5mlQXMxodIanJtCVxpB7HBvUV2+Xr+tnLMhnJvqmpeXyHZkhk3mlJprZI5eV1M6eWbBk4L5Gr\n", + "NiMNDNQW240y1KoNhlVXjYyMHJlZ0lAa4cSZC451pKqB8LqmmkIqVYQ9Ic0thagelwx1xHgmTQZm\n", + "ZqKOUs9Mw8hYzUxUmMa6o7wpZPuupKmsKOT9ue2b3K1VPkvD2h8kJP06w6kvaKfVeM/DtC4u2rsJ\n", + "LtB/jNU96uM4/K235gp6axCCFXwQf+ltPpRn8PjbfAx/ZHxFZCSE8CEcxxifDyF8L96nypX4zT/C\n", + "a/8O/gZ+Ft+vEiD+AcQY/+4f4fe/+Tv2F6/x1eKQu4H3Cj770I7Daw9r38uNG6VcQ1jqKpYLYdbU\n", + "nP2+XqsQkdtWEY49VS94skjQnS7aNBOf6+lLVIr7luB5Ncc6alLrWgtd/FDQUhpXCSrGC+fGHpTc\n", + "SyoVSYw8MaFsUE+qbvUungtVi6aMrESSkpdTjp/l9G/Qu1Bl82TfH8LaZzn92JtVkRDCm/KWKW6/\n", + "VbvjL4O8ZLa6yEbZZekzWg8cap07NgsMHjrixTd4f865HVqpc3lfP7QIG+qzE8PsZTHPvZHxvz7Y\n", + "tX/luvK1TbW1ubRx4OjcsUaYWS2m+nmhnGwoB/fsnc+NUhJTcy3njAzcj0JwIreDVVFNbtfQ2Imh\n", + "trDwyu3YMzGTmVg1dllQLoLyZqpSYV2io+7YRBQMBAMthbq5QuZUIqgJsSYpa/LdU9pjq60lq3mm\n", + "0FdkB0YhsxzXlOWW+bhungaz9Jx4dFtdy6M3Jy68RPJQ28HaNduzmtNuJt1vyvKHheMZPxBC+P0Y\n", + "45cUin5jsXyda7M3fYBqPvnQqnljSX3aNUsbspWaenpstHyqOUw0aqXlYiJf6sjOghATtbOW5maT\n", + "wSG9O5rZsfr6UOhmxke8PGa0yVqToyzxwqimnIzV6n3zdlusDaSBUCZKiSI7VQ8jE4laHKrHQ+10\n", + "4D7BmZfcdFlYLPKnMkFHal1wV3tBSyu9SF21GYnqZhLVQHYdUa6U2rQmt2fXgQK5ZT3LghXB4nN2\n", + "IF+4mfCUjVD6rmnNXpr7bPqqs+ScGHckYWjsjrmeJW2rmkb29Mpcb1AYlTVJa+heMtTNS2dly43V\n", + "qXhvJj/m45f44O2KkAzqfPwiR7+4cEbe2OTPbfHnIjsvce4cz3SrW5wuk3Y1VPTHDX8GH/sm0Gp8\n", + "RtUu+pbGlyUjIYS/hz+NNITwEZXPwC/jvwkhfFuM8b/7Wl44xvjpEMIkhPDbKmLzddaLfOUIIdzH\n", + "5ndS36zkB6efwE3eeJmPPtI0fXSFSWFWD45jU9lHvS6v10mDkJbmEtF9KiKSsyjHRoXcWKktuKeK\n", + "dLzkTSFqpRMZWDa2rnBNoWFqbmqgbVdm4NBIX4pPqW5jm4FrsaIyUxwHPtmsqiBXcBDZjmRJlWN2\n", + "Hu3AzRqTgsk92u/i0R/hiZNK6Hv7CT71RAjhf6b1Lq5/P5fzyhzu1kkI4f+OMe6FEN7MbJvHGM+8\n", + "tdjfY+911hvMP2Lnu6MHTdQbY62b7P40z/3yiyYvbfLuNdOQWCp72mXPKCbMC3kcWzvgtX+5LN9/\n", + "L8mURwtxZyZv7VpJchcUluLMLL7m5c67FEct45OJ2OlrdXJroSszMjIXjQwtLyobmcSS1KqGOwo9\n", + "Dee9oauhlJg7dSLaVLesrjCyr9BeaAKeVFqXm6qbKh0uHC8SY12pfjUSWjANM8W0wc1jdqasRweN\n", + "nmGYWDZzXrAXJlJBPW0YH7WFWjQd1zSWOhrjgeny3LxoOux2rPYLJ22KpHDWumz21D7ZG9VC8jYY\n", + "4OUTZguvrXmy6ub1KzbfuOneY01lu60emmqjQ/2Le859LFOejISNM7HbWbiFThQNRvkhg2es76Qu\n", + "FHPNbiFfmjporzt96UwjL8xD5nin7vLZzFY4cmulFMtUOrsr1HJF2TZJgnkytJHsqZeH5krtLPrg\n", + "PLWUBGdpz0qcei7M9GxoqgsKiVUzDT2HC/LQUX3vOyqR8syxVwVntqVmRmga2Jea6UpEwZELluVK\n", + "ZxJLn6MxUz3n4qlRGNspO7aTqfHoWFi+rhl3zDUWRnojiQMDTTEem8REL3a04jXZaSq4pdeoOQvr\n", + "mst1ybQUl24bvnvXJ/4/bmyxkjKYcvhLjH4nhNC6yE9/qCohvxxY2WH1Dh9q8K+bVVpxq+cttUl/\n", + "q/CWu67+IXgG7wpBeJvGi78u+EoqI39eVQKqq9bOSzHGsxDCf49P4msiI/CNGef96hBC4908/per\n", + "Uu3qiHvv5fe+jdd/hqN/ykf/Wq7zY/smaxdMT+uyYmYjOdXrBvM0ytMDE2sL/4jrqjv3THWybuBl\n", + "hW6VWeEF0am6O1rmCmdmohWlUqa58GjtOJVrW9G3hzUj51VF3VUVAWmrvt+tOY9HjjNCyXFSFQ2u\n", + "BE5DVSTuxopQ9Ev2JnzgHr/9GOFH+IFbtBYCtJVd5vdx8t9y9X4e6lHbZ+eZyhzt138qhPRfcuFH\n", + "2egyCyFsvcLhv/z3OWB+PbFIef1n/4q/lmn/qcL1lVxnfKq9W3r0qUp6dPz9R17/+1NWl02ulXYv\n", + "BVvzxNqkNAoTo5zQI392hQ8+yq3PsLknf/ex0OZCiBrhgKxtczKQx9/14nrTfPdMPjpTNtftZIme\n", + "jr6egY6xC3hVsCwoJQ4Xlt1dA2vaODCwrLAp1bErGhjoKtR1DdSlel6SWVXTUCo0UViyb6TjUI6Z\n", + "Q0V6KiujneFE7zqjdrAXThVh7r2iTdHUXNvMJBk6bg8UjW3xdEBaxfwNr6Rqg7nLn8xNHpg67aZm\n", + "YeLO6rreZ7fZ7XE/VkMIoxjj0VvxGX8e4xd58Yd5sA41ZbqsNciFO28wHMsfCcpiT+dw7L3P1rzW\n", + "zp2+d18tzSXtoAhH9pqJyehZD+ykroTcMFvRS9a1Bdf7hRsbXafZ64qE+8uW9ZNEkt8xXdrXX+04\n", + "V9Zk8UVnIXUkMQ8DK6HvvkAR6ZaJMmFSBuNYM05SMWyZCRjrsHBPXZW7I4nPCWGLz4WJVOGIwQVL\n", + "GkbumaNZJcZ4VOaiOWp2HTux7sgbcutKbaUjHFkJU5dwYKaczXUGPc1mSu2UkIqGoomZjhO3PR+b\n", + "2nlLzMfOwp5aHGjWZ+rh3c4dJLJ0YNqt2e9+p/yN5/jwwO2znBfnfPykmm6KtRAefoTuo9wak/0G\n", + "s+OqN9y6Q97hjee5l1c6/T82CEENfxb/2dt9LDHaC5VR73nfwuYtXwkZmS3U0nkI4dU3d8KLWPBv\n", + "ao3Bl0OVgXHlR/j+e3QX+SYb4yqbpv8DjG/w8PXM0ms1vc6r7j52XpyuqvdGeo0DYlMMA1UVZFNF\n", + "F6JKJb+jEqh9RqXoOMDIFevWZRJEc3NNt23I1cwMvOKeTVPvMfW6qoZyXeUX9JCqZH2oepkrOE2o\n", + "T6nVmKdcjNxOqp+rqeZ1rofKWLIc8cg9WjXa6zTO0Xq9et+7Oxw/xvSdbG3xnhe4ekR/hbvfxZWP\n", + "cPEa6d/iR15n59Yis/Uyv/VTIYR/8FZN38QY90MI/wMr13jwRZb7bB5VMyl1ldvu6+sD/tmJ4uEL\n", + "Rk9wvFpI21NluS8dc/qv8eyMR3Z5V1ute1vo7Kq3Uq0wk8aJ5TAzayxrDArrN2+Le3OPT5edjgbe\n", + "ePSckJxHaSgoZRI7on11fW01a1SeFWibSvWs23ReU6EvF2zak7iGqcxtmab7tGUShcaizH9mojR1\n", + "Kjq2ZappSb0I0uW2cWjaLc6Jk0PD1k0vmVhCqlAqnCtP9EOX5NC8ccLBBdOjGw7O5WY7LIeBy796\n", + "7Onve9jxZ+4Xn16h/9uS77xheZ1H/xK9UDkWH/3cW5VbVGm+Gj/Hz/849ydDs/qZw637DX73Mm88\n", + "Kcxya+ktCXYGc51PBr98re2gmGtNSvN0btKPHk3rttZSm1lqujlzFO66q22pM1dfbzuOdfN0Znk+\n", + "MVtqu3gytzUZOTefmpc4G9tqly4vV0S/G1lLqpmlrtKJaBA7boXLWuWpJBmalBtiiPKwp+5UQ9eq\n", + "XXnYFcwNLOl7SLFwWR6Koi1dZ+4s5m8um3hoIWWuSWyKmub6VmwamjgztW+qcMlYC3uhcLfB2Xau\n", + "npyomwtloh6jZpKiZjdsOZy3NaZz7eE9l8e3TBqlzclFt7KGLJ2YtzrKWqLe65LtsPIBDt6oohce\n", + "/DhXQwj/sMv5rcVU0126TVrL1cfXPObRFynu8b8vxrL/OOF78dkYv2kW/zdFrN8sx/NV4yshI9MQ\n", + "Qnvh4fBtbz4YQlj1JQyKvsWwzXb980TkTdx/QOMxug/xQzcmDmYjb3zvmfXTnrutxM1LK8r0IVk+\n", + "UqR7YhJUNYi+6qSuqEjJTFXHOI9dbeuLocypuplCYsVc4sxUKrdkZsOufSeLZ2+oTnNbRXHSxSvd\n", + "CdX/JUUV9ne7wUFgcyFoPcZprOzs+6F67iNnZKscZYQZ83dyc5fGkN4HK0ldfTGZEx/h7hXat1kZ\n", + "c3CJ7DwXT6p39qag7dE9bl1l9z5VXthbgkpkfOl1Vuesj7l3rmX3ocS8M7UnZy3G+FQSwv/Yd/Z3\n", + "OqbvzDWHJ7LegN9h/3+JMU5DCDd/z9LfvGSr09GKTeVsoFUb6oTMZlGal0f26uQrc088nThXC0K+\n", + "4sb0AdPmZVkIUs8r9RdTMnMrmi4Z6st1F9ZkjCQSOwoENRO5JoJtfXfNpUY6trSlCrlCgkRTas3M\n", + "sbm6rh3R1DJpKaa08hPLzZlitmKt3DZLbnpesCLaKodaZl7VkybLOrXLxr2h2Do1rkfd+7j1Q6Wb\n", + "s9ed/WYUJ6d093jktu2dkb/w62yPqmvw6fv56E/g/3rrPufpp0MIr/LqfT1+d4/vuY/TnKRr/MIn\n", + "3f6uE9df4zefYK8+s/eLp0avrTjbmXJn7Pp38IG9udd+ciKULaFIrGW5oyxq1gppOLGmaq4+OB06\n", + "ujDx7FapaEQPFiPHgaIbLWVksRIft3M6RTUavxtoxGgcNs2LsZN6z4ZXjMMtRWCi0LDhYbt6Mh0r\n", + "nrdmTQ23FRrWlJrGhpZM7Qh2FRIdqUS+SLyZ6pibmGBNqqXhxETfmpkLRdRLKu+i04SNYuQ49O2H\n", + "rtYk167NNQMnTm3GmWV9N+pD/XrTvY1UUtQq19U0N84ok6bkpBQmgXaD0VVOb7B1kd9/vHJHfHzI\n", + "3hH1Eq/z7vfSX+fgHmubPPsgJ7/C9/hjkJ3yRfgJ/NzbfRBfgDdFrL/2dh/I14qvhIx8z5us9oty\n", + "SjL8tW/IUb11mDH5EvNlvQbjNg/MyMpoY/dE/7lU2Ji5OKm7t/aYcj40q9ckSalwqhrN3VPtnTKV\n", + "euuzqv36QN1sYWI0k5qoOZGqOyco1E2klg0MtO2rWt5RtfvaVIWXliwEbtUrDFUju4ctTgpWZqzW\n", + "uZNVEtkHF88vYuW6emOT9SNGE5KbLO9y5wM0Rqx2OexyeI7OtLrxduskqwzXGR5w7yrdLV67zCiy\n", + "9Crve4HN0ucno95CHH2Up34suBa37L17XTbM9dPgoMRPhBCOcbZv6zO055RtBjc4+sefDwHcefim\n", + "+5/p2/u+jrmeaRhKYrRVlLIYhSxqTiiXV8TvXHKQjYw6q1qqocwYCdakbqiHpvoi3n3mwLq5hlMD\n", + "dcdKURBMZHITpZZD02r5UBpZUxiamqtLBE2FqbEzUz2p0hzBfHFNCWvCrFJ4NkOUZJlaXNGMmYuh\n", + "0FMR2rm5lRjc15+azp+xe7HUnp939XduibXC5susNmYmuy/b/5mX2WDzJ/mJ5yq/MapK2xN3eOWh\n", + "EMLmWzn6HWPsqXI/ng4hPHPCn65zec7tPZP/Ojr4UVprwcVuS/KDy3ZPVwyf36NPY8LWcaH3kUL8\n", + "9pTtVJJFaVIaFIlJSD0YCo3FmtuOBU1ulpTzaKXOSp1xwixW+qwrOULiwrz0ap1WQhELu8nApqAV\n", + "Dxw5r7SuaeLAmZ4TazFTk2qGQs9AzaprOuoigg0DUxO3lOqCiXLh11u5rTacSc3NYmEQpkpTbYlL\n", + "scqxe90izRAG0Y8AACAASURBVCqptkWX4x0xFnZbS6Yl9XgmFgc2sJROZcmqk8kFjV5iUB+Zz3It\n", + "R6bNpjzNTGuFs+WXhHiokZSSa0OjWUk4R7/LtT1+/gUGHS7V6Kxz0qNzyvwqd9pMV7gcQuh8MyaB\n", + "fy0IQYofV03SfLPgM6pqzbcsviwZ+cPKa4ub0TeVF8VXi6oMvHOTF3Y4f8atde5e4ORh2qeZl757\n", + "1SunNfXBQGvUl85SJ5t1/dpnleE+kvtUMysjVVjDJu6qoWUq6GlLZOZmTk2UJhIdPfFzI3vRSGpt\n", + "Ec1VN1Kq2jID1Uc0W/x9qKqGHKoWwluqxXCc0JrSKTnLkfB9JSsFo5RXSt6osxw5KTk64b2/VolW\n", + "f/0naLyP+8/YazCr8cCocj8pamyVlRj+uXeQDviOCedPKvO4Zx/iycjxUMV6vmFYiGavqkjPqUow\n", + "8yk+fbHp1f+0bWs0M2q27fa/V/+Tg6pM/CNHrqzxbQ3yM5xV5/HTP1W1eQy4cq30oeeOvHr1yGzO\n", + "6Q7TJW5k0WpRZf2cSnS724ZnF2wdH5IlYlKqxSNzXWKilixZ87Io0zVQoC6aG0gNtHQUpu7oOWek\n", + "riZVSs2NVI4zlQFuz5m6VXVNhcLQxGxhdsWxoTUdbblTuVk9CiEaqelkUSjHYqiyod+M0ZuWdPpN\n", + "DUuyF+dWl3Lb9RPTrYmlnNojnItsP87JizHOfjGEK1lVcfpCJBbuxR1f43e/ao26pOLod2KM0y/z\n", + "lD+AGOPrqlV3EYS59bd5/zL1tU1nF7c9enNsvX3B062HzS79mr0rc7sH7LwWfPrPzLVqc7GW6sXE\n", + "blKzHEeaolbkuMlywXJa5Te9XOeJKefH9Nu8ErkdWKoxSpuSGI3zqdNYOkn2q++hxHJMhPCanhtO\n", + "BTVRq0ysqdkNqZaRvrkLxhqiVCKKChMdA8sSm2YGi6m5gYqQjBVeNbUaS9OycBbqapEk1BwqjMpo\n", + "syzVa1wrgzyWNsMbbieZF5K6pKSlcD1JXc6Dk6Rwt9x3rGtYFl5aLbXzl81r58yT8/KsL5hYEqyM\n", + "7tleO3JYvuH2VirmY45ijKMQwv825i+vs7IQhpyc4zNtpjkhtxgz/OODD+FejF8ytfjtwjP4W2/3\n", + "QfxR8Mc8KO8rwf4/51f/K1Z/nPoGyx3O9zvubV7WP7ciO9dWvPy646uZ/P7zsnTVehn1s5Gp38ap\n", + "JWMr+nK3nWlb0ZAZaGm4rpA78pKR81J3FS4obChEE7d1rQgLL8boUF9lVVXZr9zAU6pEi5dUN6Zm\n", + "/Hxo+DjQOmOwxN2iuok+UlQ31TSQFtw/YNzgTo/6x/gPP16VmucJjRkrr7F8ynLG3cdop9TGHOa8\n", + "lnEw42DMX/xlTj9YmRetDHn4jF95D3d+1ucNY7/uCCGssP1XuXaezche4MYbHP4/9D/xgP53POpO\n", + "v8XsCicpcZ1RED7AWsrpVqWlgdsp7YzOo9W5GV/nt29WLacLxxxusZbTSxbVqIzQqWk6c7jdUs9O\n", + "FBusxBUxZMjNkr7EiWjmgsy6NamZqbETU5mpq6Y+I+orrIk6qlW4oyKWM8FwMRTcd2BXY2EDnztd\n", + "5Pi25F4U3RN0bRuFNbnMyGSRZlRqJIeysuKGA9yIPNxj6+zAUTHXHEyUO1ONpJC0efg1OosNx5WE\n", + "2Z8JITzL9uvc3OG+LzAHnKYL4+KvSciahXD/ZT58iUYg3GaWhvC1jN2/iUfY+FGujhruXV7SSaem\n", + "DzWtv37Hyn0fdvhLn3G8edOvvpMr51jTND2ZuZE1rIaJnbTvrmAWKruMcU4tZBqxLoltjfmp5xq5\n", + "k8qN341FdeSVGu041U9aJsWS9nzF+vi2s/WuuQv2QgMzmV0dx0o1B5bE0LIacwdxYCNJZM4wl2sK\n", + "RoIB5hqmVlXX7IuBeaQp2Itb9mJdOp7armWuyNXD1Ena1CzH0qQ0TxP3lVEjieahtJus2V8okCZh\n", + "pEjqsnIsTyJxKssaht1zyvFFjeOxSXHbbPtEMjxRmyzbDlvS1sB45bPG065HnvmM0beljp7q8ftU\n", + "mzr8g/UQpmPue0910wLPcOGUp79a0vlNjm+2Fg1VmsjDIchi/NYkfn9CRlirxODvHHLW5eFxZn95\n", + "VW/9mvnpzGh11+y9Y9v5wybFskZeo5ioL3PgVOKiq0aaeoIjQycL82ZWFtkT0cxlPGziOUvuOrMv\n", + "WDN1VV+htfAO6uub2sa3q0rCmar5M1r82cL5RWvpesFJ5PU6o4Kl06q91Et5o1aZthVJRUSWzpjP\n", + "eN+zFREZZ/zedcar3P/JqsjTneCEkyY3VmnfIHmJC/eYXa0qIo2Pcu+xKmAvlpVz59EvfFEL7+uM\n", + "zR/lQ5s8/gXjgU9e4aM/xOm/zZk+wu5iBtSU2l22x7Jt2suVdXWtrOzx6+9mfIGLIx4bM2/TfyQz\n", + "HATPlXODWCU2P6GqLIgch9wnAtPyloNLmcdmpWnxoufipsI6BmLY04gTq2FsVaqnVF8MfG/HTc9L\n", + "nF/YXu2GvtxYG7maJ+QK0ackLittloVRMpJ507FmyZpEZux+pSPnHdpCR8TIiprPGhhqx6GLRZX6\n", + "/jzONam3SD4y8x2f3nfzIkcFvUvcd1gRkagyJd2r89AJx+9j/zf5xH9SFTCuHHPQ4d8+zK0nVdv0\n", + "wVfzCYYQutf5q3+2YoYHcEzrV/nJLxn/+hVh9Qeq87Nzkrp3pWZpQDObO7lYSvZ6LLc0HqJ+i9tX\n", + "o0kWTcM57f7EdnNEmjtuVsW2DgZJzc0y1dOxpmW9ziwMlOXEMiZpNVx0QSYJmULulbDkhXyumWaa\n", + "zptra2JZS+ayobkbZs6XwSSM3UxKwzjyxIi9epBmA8vq0jLRT2amZkoVOZoF3q3yO9oVPRL68ryu\n", + "0dxwbm8idvuS9twVuRtZZlYW0liaBDpJw71w1Z5Nc3WpzDy5aerQZ8LY+/NoNK+Rn9eslTQpR6W0\n", + "cV5t2hJHQ50Jm+OBeWuqXClNylNpra/bmDr65YWH0+dwws9+gp/a5+oW5R7hNW6ffAvrGL4YoXKc\n", + "/LBvrhaNGI1CcFuV1/jc2308Xwv+hIzo/AUeb/PwXV5YTy03UwfzdePuujhtCme7alsdeWNL7WRC\n", + "IxcbiSzQXtSrozUsiY4kcpsmDlRkoq0ax72JXVOrCqXSrlLAgaFNw0WsVdXr/ZAgiJ+Tvq6odrob\n", + "qgpJrtpNz1PKlEFK/YTuiKLNUSQrudOoKhyP3uH1NtMpv/M+9l7j4NuoL3Eu4+Q+XmnRukq5UWXb\n", + "5Dd55//L8oR/dZHRKxVJWT9j/WPMMkYZn1jxJXJ+vl6ojNceepjHvsjn4l33eObbOP2VfV5+hutP\n", + "cPeGcPWupcdvq60NhVAZQt5uEtNq0rC5WWlcmgUPDWoGrehO2tDLg6MsOmhWtnUDlUanDExCYcOp\n", + "e50NO0Vbfz7Qr5+5nB/rFDX3mnUHMTGJiXsht2eGUlTtxu+FibbMUjx1GOqiDWsOtU1FpYmgJS5q\n", + "ZSuGyUxp6qqgJTOVmpojFXRNbC/GOpctK6V65lqCU12ZPMu9cj+1Q5ae5OgSZnzkw9TOMWxVE1dZ\n", + "QnvInfvYXaK5y8EHKJv457z0M5x+P+ExwgOc2+d7r3Hnb4ew+inOfukrNcJr8I5HSbcqRg3WGb+D\n", + "8mshIyGEBtd2yE/p13KtwcysWVebTY1XtwxefFXj/We2E37waT69w/f2Jl56/9jd5a7BcOh0PdiO\n", + "HIeoENRDzXZSeioWrsS+YVaoR0YJd0uaJTuBSUjFsimJNRdk7tUT9yZtm1oLp5lK21XI5LrmsWee\n", + "ZG6FqAzHdhaj+IM86mW5mnwhdq00H2/6DG6r7PRmi8zmkzi1nI5dMhLOJ2ahLpQ1RZxIlUJJqFUt\n", + "1ruh69Q6OjLRxKo0EkPpNAw9V5u6f3fm9sauWXaibmC61lCEVVmxpJ6eKLqFXN3yQTCbTIRXex78\n", + "bd5Y9SUEqQvLh3+4V43/vdlOff0bu1F5y/Ef4MUYvfJ2H8iXwO+rhkz+hIx8a2L50SpNsugwWi9M\n", + "2i33UkI8o32mVp+ISVLJyVq5ELpirRRMpZqimtREIlVakhstQtBSj8WpVoiaKlJyR5U4U60Npang\n", + "wsKNImOhNWGw8HAMKiHqNdXNqada95s+H7HVUA0RPzbjhTXWs0qsuRJp1dmt8RvbpE/yY7/Crz7O\n", + "U+/jnRmzUyYN5o9WGTbXn2PlFZ5/B2eR39/gaMK9n6uM0z72F/nO3Wr8eZjxifMc/mKM8RsZElWr\n", + "3mfyRQ83CmoJsiP+xb/lwy/yBCvv7lsbHrr0FOMV4sNk19m6yfEWZy3GJRvDxLRbV5sWurGuP62r\n", + "J21JsS+oJpLGSUX6uoFTc+frh5rlqrNkbCOZeXBMo8hdqJdeShODkNqSqimdqdRELcGWxIr6Ygpm\n", + "7Lamqu4xUYhqi2vjRFupaVNNy8xARM1UlMiUogNddBeuvEyVGpaU2gpNN4xsx+A9Meok3HtP1Z47\n", + "+xCPdVgZ8M7X2K/zew/zRsrlMe9+hvND7qwz3aH3RIzzp0II/wfn/jY/vM+1RcumCHzkO/jkHV9h\n", + "uGWDlSX/bphYZzEW+jWgRMHFp/i9b585NzjUX10xaWZec8Ho8LNW3n/sgSfZGpP0eeN6YW144HR1\n", + "ZJrOhVhTn0a1ciYIxrWOGOZW5lMHtcS5SCzndhOGSfWd62GjnKlJzENpHGmHJUlgEqvKJQuX9EBf\n", + "Q6YtU9O15VLZ0gs3LddYCVXVc1cV07CqWsO7qs3HFMuifdFYbi1UYQErWhohkYgO04ZpHImCh5JM\n", + "Qy5bRBXsioK5qbmJnpU4MVeYxJr+dGp/febBGEzKKC327JdL7mqJw4KybrlfmC3PjPJD49jzxNPc\n", + "bXH48h/mK7Qgp2/ZVN3bgJ/2JdzCv0nwpMod/Z+83QfyteBPyIj8LgeP02qxM+KNZU5rd4SsrVls\n", + "6+SbRqNblpt3HLXOSfIq6qyM0TAcauuoOxQWS8iKuVeVthfWV6cqm/h1lW5vf9EPrh6LVqRWpYLc\n", + "qWhLarzwSzwWlarkmhuq+/aOz5ORvkXMVqg0IlmXy5HkmHmjqqCsRl4PXHi2cmcNj3B9pSIXV7eZ\n", + "ZvSWKwHj/sPMX2DtozzQ46NPMv+lN/u9ITRK7n0/rU0mQ45+gfHvfoM/oFOOz9hbYucLWgM3Vunf\n", + "WYycw/8aQvc/5n0zHr3F+ohf/FEaR6RN9rv0a5Ux3FHgQp4o0yCdEQVlK5OVNaGWmcRcL1Tnq6si\n", + "hCHyRMy9nhxS4+KApRGT9agWCheUjhTOISyi75bwmtIDaubmBqGpWRbOJRNvmC9ISHRXFLSdSk0U\n", + "OjJNHXtGXhRcUjiTLOzk13SdGljWkBujNJfpmYvyMLYWg6JFMatM8GqNqnX/2O9Syz+XGmJ3k7M1\n", + "3v98VUnbW+NswHufY+9DKrHSJS6vc+0LKlNp5PF9Xv2gr5CM9Lhxm+9+9Isev1Ox9K8aMcZ5COuf\n", + "IX8XD/wWN64OnPVyd3c6Dke/y/jA1oulD73AnUtsbHJ3uUqESsNQNmU+5uo9lhvsr0WDbCgGpo01\n", + "V/ulfjZw0giuljWtydydTnU9lKLGbC6tzYyTmbPQkiVjoRjaz5Z1VaRiiIGJlVCax5ZaDEKyigP9\n", + "OPY+FdGeqCbf7qrkOEG1KXlOVVHdlrshuIxCYmymq6mxUIa+LlgKQRJzIaQuxOjUzJqxV000DFzW\n", + "1E3mZmXfII6dohVZ7g8kcYPYdDWOzLNDu+muLHY1JzW95rHdnVPdT1bHcmePw5//Wj6zb3WE4Br+\n", + "FP6jt/lQ/jD8Hn7s7T6IrxV/Qkac/iZvfLhy007m9OLESla6GF9yKzlwnGayOHJaHmvEuVF9JphX\n", + "I5ixpowzeRLVDcwlxi4s5h96boSgZaSlujE1VMLUM9VN6AGcyDU0nGpU5VrBifA5AfoWPr34+euq\n", + "9kFP5TVyqrppbQR+5zxipQE4XuPcoNoF1+dVv//un2b2aXaaFXm5Grl2yivLlYvr+UNOWzSe5L47\n", + "dLo834lx93PCs4Xnw1MqJjR9K8qvMcaycn39yE/x7g4bffZX+HTC3j/9gz/dwQN32Rxx3KoWjuY9\n", + "PnvfQrQ6qM7NqOTmamGtKMQ0Ogs1I4les6kxr/wj2ioy0VZViZYE18roOOFuTtjn8HwlEu6hE6Mi\n", + "RF3VYv/mGntkZiOW9kNpXIzEhJqJscJMa1H1mntJZjmWdkT9EBy7YlVPMPe83NhlcysypTUHi6mr\n", + "GsZSJ1qOrBlJYzV2fRh5tcXwiPuG1HaqqIOlEdM0c+9cMFmK8lrhuY1o6Zjmy1x7nVCQrS/eQH2h\n", + "nfkidGakX8049ysv88YSVx+tFMheZvv5P5JJ08mv8/ELPHiOnSOK04nykxP5/4kz8v+csyZnT/DO\n", + "A2aHPH2JO4NKrJ73GZa0BuQFzdbIwWoqjyPt/alxd+5SLXV+3pT0zuy1uJVyoWCe54ZJ6tVQV05X\n", + "JPv3pJs3JUs7jkPHUagIIlEa6w50dEPQF5RS+Fw1dIIVNXNRqjRTmqlIyYrqetoUzaS6Gm7KHZlo\n", + "Ss2VjjV0jZWhGgWexNRSmFtzJEqsartkpnQsCyOdaSGUtIqaWE6kcc8kb0gauaV4LOlNvPfJI9NN\n", + "zr3Bc/8/e+8dZNl13/l9fje9+3LqHKYnDwYY5EyAQSQhElyJpiRLstamd9cluXbX5XK5LIdSuVxb\n", + "Lru89m6tg1SSVqpd2YqrsF6LUaIYAIIAiTAIg8nTM53T63453Xz8x3mDGYCUCJAABgPqV/Vquvul\n", + "O/fce87v/H7f0IWlf4bG+qwrpW5ayfEfMv5r4LeUemt4qXcxXgTuEsFUiveCj9hbihuWjIjI48C/\n", + "APaUUh+8UccB0Tp0T8OLs8ACHOnE1EQoGDHCOtspG2Nokdnz6RXX2cv5REaZfFQmg6JnbbNIkxQR\n", + "ittIqCLJGQaSI02HUPpEcY/ADAlGiiR5dJJxNUHx8Elj4Y1KsrvEzKIooOUVriYxndHPe+hE5PDo\n", + "oUa/Py0aZGeYkGtCVNLeHmYAVRPW74epAbSKUB25JLsRdAQiE8q7unIgQCcN/nexJkYT0btqmqZU\n", + "fElEfgNqD4I7A4OXofWdNwLooHUR1h/TbbdUpJO5w5vwF4dgMoY4gXQfDjtQsxVPpn1cM0d7I2a3\n", + "0MXNNkjbEVMBLLv6nNeBtMBcYhBHin1Rwnlg7wxgQ2YSchYMRFdPMsIohdDzQR/FZNQiMFNEiaJu\n", + "BMRABxeXNC0SFIoFFCiDKXFwEFqEtMkxy8ZrbBt75Ai8qzJkxcPgCuO0uBWdBFWANYEGihMD7cz8\n", + "ogXtSZjIQOMO2B2kaFuTOF5E6Ed0Y4cwqBG3Aw6c12N/YQIGV0vt27Cp9HXlXjfBXRmD7otvfgxV\n", + "JCK/9xQ8dBruEzCb8ERfG2b+2g92XaiuduXeOaTHwWtAcvG6St4X4Cv/CRzNw9CDvQwMd+HDT0F/\n", + "DL7603Cyr8X+preh5cLqfMzkWpPjNbg4BbmDJn5Ke9y4vk7uL6a01UJ2N6YqA/LOZbpGSMUIqbZX\n", + "OFdwUYbCVGk84yANMbCkjUWfWPlEDMigGcpL6I7TKgZZYsIRAi2N4CMcJxnpNxsEGAgW85j4BKxi\n", + "UadIKDWyKBwxiJOEbcMml0SEbGMaLlUG6LuhSyFMSEfQsWz23Cqhl8JtDLBUAysX48aw8ALc/3V9\n", + "lteLcHaI3hFlgTkR6dwAT6obGiJMAb8AvLG4954JpWiLsAncwk2IG7mRlZFvoykLP4zz79sRfcie\n", + "AXcd8hGUmgo73efy3SYTaeFg4NOOB/gluJBNKGDSTwxsc4BiQEFtk0NhqCo75InI4SRZ6tLCNIS8\n", + "KqAkoU9AS/mkJXxNuGwRnZgcAHJE7KD7xjbQUVoNdT96Z3pB6V342Oj3KrqnPADyid5BTSh4wYQ7\n", + "hhA6MOjBlRLEISQVzaqYuQANEy7OwJGa/j+fN3SZ3m5pumsrBacdaL3pxeadDqXUJvB9ysPDl+Dl\n", + "B8CZgcO7QA2euhemTbh3V9OYa3lYSul59VKQEDQHxBMDZu2YhbQi5cOOpam+KQdmRKgmwl6saMcG\n", + "UQidTsKlSJf8pyIQBxYF9iuDRBQxBiGKZRI6Ck4ZignlERh6fPvYPKpiYnqcFQdT2eyTkBomXhKS\n", + "Mi0q1KkT0qHPGMIBLrPDPLHKEqiItnRIqQ53oDikwDB0jmiPzsVuDJggOTg2gM1AJ6cF26TrBOy0\n", + "8uz4Y7Se32J9LMfEQoPty5qJ9awJ9SdG570nkvsr+KtPwe0tDWheL8NJH9pPv8Ux9IAnRo/XQuR7\n", + "6A6++c8M0b4n3+V9Mqrk/S4E/50Wbc0swt3LGvPUDSD+GsQNkCKspKA2hJ1/CeFPw6lxvXzHtZg7\n", + "FmM2yxqLtYBmno3vwnwAmwcifC/iqA/VXdiuZpiVKnNKSFTAjuqzTcxQOlSASeliqoRkpHQ8h65u\n", + "rhGQxsRVikBEN36TBAx9b6dG0ngOUMTFxEJRQACLgE1sskmKiuoxxKduCBuJsD/sUzEHZEUxBKYS\n", + "yAQGNcuiNxhQlDSGX8YNAtYLbZYFblvRlcVaAV50YOv/hcLjMP6Qnn+aIlJ+CVpfUEr9oJifmy3+\n", + "S+APlWLnRh/I94mruJG/TUbebCilWvDDTURvU2zD9jpkq1BuwkQDFquQTmKm+lqzp5GCjAMTmMyq\n", + "Bn2jw+UkwjZ8yniMRS5GNwXmCo30Fn7UY2hPsjSsk01HWFIlibcZNy0OEZJFJyEDNCDVQFc8BJ3U\n", + "9oDLAh9Q0BZdHb1NdHvnKqsyh154VoBKpGXhrRjqu3AmBytFyK6A2oVOCcZDaAXQzsLhZWgcghUL\n", + "3BCcS3ChqcGs2bQG1G3+kVJq690ejB8mRjvl34avPwLP3wXheRguwN1F6FjgWeD3oRJr09/4HEwR\n", + "EU7CtgXTsYVyDTyV0DYjptALUl8lVGPhnCmcN1IM1ocYM7AeQMMQpkJFxhS2LUVfCZYY9FEYJIwL\n", + "bBi6uqAMmE1gUtmURWup7sfnkrhYCqrKx4w8uqZJmgSLhL4SJiXFjAqoskXbN6hbPQYyJCuwLwYj\n", + "0dihIfrfrg+dADpZcJRmwQTAphic2ycEgcl6/CCdLxyE5VOcn3+RjfsbnJ+D6JtQf1IptXPtvPae\n", + "EpEarD+kcUmdb0P32av38Hs8XoD+k3Awcw2AC/DKNHT/FHZehsX96N3B8ogR8mXw/x5MLgAnIByD\n", + "idOwsAbnfxx2NmD/q3A5DxdKMN+DaFLTxDtpm7wRsIdNVtnskwZ51WdTKcrikUa9dv8eQY/LIcBF\n", + "8QoKTyyqSUxFGZhRQtPWVbey6GsxIuQiERHOyDZvQAVhSMyaDOhjYicRkaErq4lp0hGhqiLyol13\n", + "mwWL/rCCvNRh7WCHaMwl8IvU6x7dP/HxL8OZaRiehcYzkDkKdz8Kj65qinws8Ow98GwIfP7dHc53\n", + "P0QoA7/IdXYo7+E4CdwL/D83+kDeavzIY0ZGLrB/DFERuic0NmO1CpNLWkiwX9VAL8eAshhsJhnG\n", + "E49NI01fpamLR0d1mXW2MWUfxSTFThwSB9o4r5dMQrJCWpnkkz32TBiIT0MScugk5CB6LjTQQ1JH\n", + "76DXBMJYszr2oVsATXRZt4ve3WcD3fNuhhB7cO/XYPkADMYhdQ7Sdah8GPbycMdlMMdgbx/0QjiT\n", + "h8oSRKdgexs2voLOfLZv1h3PqHz8pdEDkemsTt5iH8oDnZilU7BqQKoD0QNwaxfCso3nWaQs2HJt\n", + "MuTxgy5dy2DQgEQMBrbLIOwxndYLSK+g/94kYSiKtjIYw6SsIMDExuQ4PssJdENYSGBcwHECDBxM\n", + "DMYl4iwRbeUxnQgpBT0vZsu22cIkFOEgBnFiY5MwqYbMi08auJLAaYH95jUXpPUI+kOt0C0GpBN4\n", + "uQB3vAT3dIQXggr1YZWNxcMjobq7UGt7dFil8/tKqQt/zXm9gFbdu6lidH9/3eXPfjlFfsKj2POR\n", + "DaidhMEzo+v85Te8pwn8HyIyBczCzj1QWQDy0PxTGNZgtwi9JniLMPtTQFZX3Vw7YFpLjLEraZQy\n", + "sVFMSsBkrNgfwauWFu9TwKKp8T05LI4IvICQiU1igV4E+T7k8lpozUTTfRWKHD7z+PjYuBjMqJCh\n", + "pLg1CmkZBsPEQMWKtmlQjmMuABOinbs3sVFhlX2bGVptmxe8EwzOrMDsNuzA3hevSreLiAnVX4QT\n", + "DVg/oqtrVhtuWYfL94vI164Dkb9f4z8DPq/UNTG393C8gBZlu+niHU9GRGQSeAPQkG2l1C+8iff+\n", + "k+t+fUIp9cTbeGjXhw2Nz0G3BdFdUKxB75CmjxYHMDWEJAdxLmTJdDmrDqBUEUVCxCohGbbjDuXk\n", + "HM2URc4U5uxNQsulEaYIgz5OWpENTNLmOAXq7Fp9BqY2sUtxDah2VeRMi1mBZeodUW/0tyCBgwlc\n", + "MsEWrYMR2KA6EPTg+BXY6cHlLrRKwATYRfjoKc0AUbswl4UXp+GFbTj/P6NLLstvhqI7kvOObx7t\n", + "AKlB+WW4eAz2OdApg7JhZwj798BzwO1CVqAd5amZRfyoT8ou4XSKDJ1t+l4OiR2SQppUOEnn1nVe\n", + "cfrMBtCTmHHLYiY22EOYVgnbhklKwaREOEAp0YycrgX7Q+gEEetuRCC6ktFWQ52AmgrlaZxPV0LG\n", + "PWjlIMZFcEm8PmZiYioTP5VQSiBK4EVTXzu9RLfuTjiQG2GBkhDKPdjNwEQnptBssVY4TO81PNAS\n", + "VK5oQNKVGzJE72CIyIGj8PN30Fuy6W012CpdBFmCp9+YcItIBV16rCulPKXUNrpMeFJE0vCaW7kD\n", + "zidh4gFwx3WiL45B1nWZQ6iqlFaEEY8rYpJNInrETPrgC5BoMULlQ2YAUQ6UFREY4CQmvSRhPFJ4\n", + "pqahbyRaqK5gwIbSlPbDaOzvGiE2QkoUfRXRNxJsUXQlpqOETJDQEpNqoKi7iqKCmXrEruPhl4f0\n", + "Ugk+UX79WwAAIABJREFUTzH+8Q7VTMD4ENb3iTh/olRwFkiBXYG9g1Ad2U4MJzROJ3WFa1LQ78sQ\n", + "IYuWWf/IDT6UNxsvAXfejEqs73gyMir3/tgP+N5/8vYezetDRPIl+Knb4OgUJE1CY4nzy02yG1CY\n", + "gUfXIeOCNwu+gi1lUzTS9KSAUg6hZEgnMYjCjVr0nYhJK0UmjnGHTcyhxVz0ImeqKTzVomULsddm\n", + "LecxJXCngiujNoyFFjs6h164ZtHVEQ896Vy14JtREIpWPz0zEq4SC+wMpHrwpWOw+wxUZ7WHxjCj\n", + "xZqsEQJe0EJXEz0wryil3hQ1U0RmYeKTcOAARIFI4TvQffK9L/O8802Yn4fjT8HONGwJFCdg7iJU\n", + "65pZ0XbB84Xt1DiBJIRJly16+FmDyLchlae0OKQ35lAyW9hWmik8SnbMAAhURIiFb1hIYjMfBzQM\n", + "kxIxLtBO4FEfvpSFyykBsamIhRCwgSInMTOBlqBvpiCOoTcyPcx5sJruYRGRNkL6TsySmdBCV8jc\n", + "BI7EsG7p91RNSBm67ZSygDSsjjyHZjqwobpsPn2JuDeAOR+MLdjZgT/WdFmx0Nnx4L3OmhCRIzD5\n", + "QbAnYLg6ai9tXPe8TMOnPwKtGV1KBGAeil+EnxCRXxtVTnJQ/Sk4fgxyCewmItm/GlVOFOgk5No3\n", + "Z/8DmP37kBuDyIZoDLyyzQR5nLjNltFAiYEixiFiVRSugqYNhiGoSLGrdCVzcggTIdQr0ArhoZWY\n", + "Qgjny3rOWS0Dy1Aeh+N5zQrb4Brw9R7AQrEOtCVEiUkqThi3IDGElnJY6AmBgrokpMOYYttnt3SZ\n", + "1t0uq1aBrFMi6WcYLO/Smuzw4S146udF5F8AHRjO6vbOxEhbJD/UWKTOYeD9DmT9ReBbSt0crsNK\n", + "0RFhBbgdnZjcNHEj2TT3Av8UOCEiXwF+8t1a2ESkVIVPTcPjB2D/PliahFfL0D4FM9+kzx7Bb8KF\n", + "fzSyTy9BEBtkbBffGdI3anSNDDEDlJHGTQz6tiKxAo54DVTaxVQOhuVjscNE22V9DFwrwslGHEGL\n", + "krVFbywKaOzHFfTG7GF0QnJ1XYjQ0t7pEVtjWTRe5ChACL1NCF+Foy/ByRkY+zjM5qCsoFcG34Bn\n", + "b4OHz2tH3l4aagqil7/H6fle52sCDv0SPOrBwqrGXrz8YXhhAvj9t3t83t5ITsPpL8PeR2GyA8OL\n", + "2ixw30UotmFzE87th51BitAYsme3yTgeGRRjqZi869BglyvZMSLpU7aFg0YaoUdkxEwrcGI4nUQo\n", + "X1gWYdpOiI0ID6gnULa06eDUAC4VUtyCTYAQkMclZpYWK07EB+sQGdAyNbtpcgcODOFcOeFsdYBl\n", + "g2nAtAcP+lq2ftmBlyKNEckYMG6NWEQ+ZBKNJznvZHh1xuC3pU/4B4rwV9ehu65Fa0L07t8UyX8M\n", + "9j0CaQt6bRH7L5QK35NAOJHU3XDnz8E9TRjrwuYBeOG4iPwrpdTy6GWFEozNaKToazGnfR/mtyAn\n", + "Ij0Y+1l4dEHbDRhoZeFv/AScbAOnX/+9MgMzvwwHsjDmQLsEwzSsGCEpuqxjUSWkgI9CWEdhKpgC\n", + "njGFlEqhYqHNkHRGKyY3YliyYWwXDvc0JmMiAfHB97RmUAwshbDfABGtH/MA1+aHfegW85okPCog\n", + "gVAME76ejtlJFZjaMdnX2KWRgq/OgGkk2LUKMp6jEJn4FBk6E1j507x0osvRFVg+onFVRh2u5CDt\n", + "QsWDtgOXXZBNRtz3d3Swb1CMpN9/Ge3QezPF02g9lL9NRt5MKKVOAo+9W9+ne58sAMUx+MkP6zup\n", + "+CFY8yG3CY848I0TsHkWju0R/iHwPBRSKbYzJtaxhCBKuODO0pLDWLHCNraAGqFEBKmYglikGcM3\n", + "XdKASMCwXCO0PW6JtYtu04KZUTLRQRvbHR1hUi6iJ63s6KhNrt3rJTS7JiuA0gycJtpFdH4TGiU9\n", + "kbqzMH4QPnwK0jH4A1iqasbMhYEGspobsKugvSIit6DbZq8DI4rIAlTv1S2e3ATcZlwzTctE8IEV\n", + "2DkuIjMjpst7MkY72ydF5Hm4Mo5Geabgq5+G0gwM1zTbaKbWZ/ODBkbRI23Y3I2QUhF+aNGxs0w4\n", + "MTtGgGU4pEaf3kdXM4ompLAoYuP1hMt5k7641PEoi5AWoeZGBNi4VLAQFAZphBQJWRxWJWI1Dc5Q\n", + "4zzmEkgygAPHElgNwRrCtCVUTJtKqEgIcQx4KdEsqKMx1E3AGnnxKIeL1jzbUiW1XqT1ckxovQI/\n", + "UYffU0q95vUjUnoc7nkY7l/X47ubgaf+IxHzd5SKf3D7mHcgdKtw/lPw4S1NQV8vw2QbHgmh9Ung\n", + "N0cvDQMg0qXD16o8PUh1MA7B9H+jk4HCAhz+1jWV30wE9+zB+od5QzIC9uMwVRIOGSa7+YQpOyGj\n", + "IFIJu5KwgE0JhYFJlhA9Sno8SmJwORrH6Y4zvXeF9kSLxTRYlu50HHMMLhxyaFsK24JqP8B2FHMl\n", + "qIbwrMA5A90CHB1PHIMSvYmZAWpKMfDB9CBKUuS6Npelz041ICcJSQS+A7cs5blUnkUxhnIcrLhN\n", + "e6GOokxidRmvabG8OAF3D6pb8OIx6M9CFEF+EZwW3Hx6Fm8hPgucVerNCfu9h+Jp4BP8gJT5GxU/\n", + "EgBW3Que+qz2b3LGFCsnVqids/GsFMQu9D0tsjG7X5u0KKABl8/lGPzDEhNRQjeO2banaDINEpOI\n", + "jTCLTQ1l1HElIBMUaJopKoEiyoKRmGC5xEaPqQgwdRIyFuukIiNwQfSiptATylXfmQy6pSJcE9GK\n", + "0CqI08CyGmlg2BA8oNUkT6YAW+MS0qNJIuXDzBKs3gYbArlluJDXiqb3/zjkFGwgkv8m9L6qy9bu\n", + "A3DHZ+C2ga6knP0obA+gtQul66pXUwm8UuWHEq56d2IEsnsNgCYivw7befRkWrDY+aUSks5SVC2U\n", + "xAxJyGHimiEDJSRmwN4I4xGLh49PBj12ZcAkQ2EoTHshvUyBnSTPpNkhMCMakUFsdPENkxATQbDR\n", + "10IMRFgIJrtGzPioBL6bhvFIL1KhQl8gRSiGgp9E7OYTQgc8Q1dLCraWLPeUdmPuZ6AdZ1i2iqT7\n", + "BdJrDpZ5P/6KB0ef0VSO86NzUYAjD8AjK9faeeMDeKABtY+hs+T3UlQgVyrytdsnGea08o6wx/4L\n", + "IZm8iKSUUr5SalARefU03HrX6BqNQb6F/YkG+4fw01uwWoHde2H1ETj4JDiBbo008hBlRMR4PT7K\n", + "XYB8SvDSMY4DrqWn0VlgkQQTjwDBQjPlImButIk4rGJCu85OISRSKY7FWg140gClYLEIsYopk1BQ\n", + "BvWixSAI2TahndGblFaok5eh0nNCMdHXSGtkXYACbwiVU4rE88nYAZVpxdRFLT/vPzjCR82U6GZm\n", + "sRMwTME2K6SihOGBHZIJODsLppYmoXkO/GMZhv40jbAExQ57n9il1W+RPiUin78KeH2/hAgm8N8C\n", + "v3Sjj+UHiKeB//FGH8RbjR+JZAQmfhZ+LAfHVg0W3RKZZp3KbIZXzF1UZgIGafA7UG5Bak8DNRo5\n", + "+rXjLJ5ZZ/WRKqIy+MxD1CblDLAMwVB1ImmjqDMXQ6TSbIYBSWKSsRJ8K2bPyCJJj5atWTN2AruG\n", + "1gZRI7nx9RFt10L3gdfR+iIGeqLpcG3XNkigbkBO9AToKY2Sn3K1mdniEIyN1///C3u6GnL+23D5\n", + "Jch/FH68rtsWRU+D6b72UXhuW0SuwIFPwSc2tNYG6H784BCcPwQPnb32uQ3hul78zRSjikkHQETm\n", + "jxIdm2BirUc6FWCNmySqzh4+U0AlbtARF9/IEKkmHTVkThQ+ujR+2YQVNWSYCMOS0BUbL0m4YhlM\n", + "JCYBPh2JsRGG+Pi4FIEIRYzP9kjMLAO4OdhzYc8GqwR+CLURSLliQikxwFTU0Xb2pdiglihyhiIK\n", + "YNzRgNmqMlCGzVzSYnMwhkQZwj2ABRic1XSgq9ocJc3usNTrz9JMG+x978qAvLXwC2zeeTeTvSKF\n", + "JsACiVxi8cQFehfhGnCvCV96BsobsG8c1BqMXaFqeHz6SUhHMN7VuKFiGlYXYH1cg1LTaZjqgvwj\n", + "Efk9pVRHf2LYBT8lGlyeaP+onoI1w8ZQMCSmLQYWFllCckCCkBWwQ6iaEQY9rDzsCczaOpntKthn\n", + "JHQkYQ/YlZg4EgqWcMhQFBQMQ1hSsB7D0NHgdwcwQ8gF8GxO/2wuQX302vELir4LR56H0/8h5HPQ\n", + "caGn8mCG2JaNFSmUAaaRwXUDvBzcU4fCQ3Dpblj9/0y+Vj1E6liJQj5B0jnM9gxTWy8R/YMO/riI\n", + "/MublYH318TPoMF837zRB/IDxCLgijCv1OtblO/leN8nIxrvcPscHFsDSEj3fDBKTLe6LFVO004d\n", + "0zVupwPxaZjegT9RSoUlkSM9uP0OglQRghUorWNaFaZUD6VWEAmZVH0M0c65XZVChgV2G11UxaZv\n", + "ZFGJR54d9kw4KroN01FwCr0bikQzJqd8nZz0bBiKbqOURSurukq3djaAsqErIxk0zQ8Fiwa4ogWU\n", + "rhiw6cFYAUqj/nOtBNs7oP4YghKUboOVMqyO6V10ZVFjKJYfgW0P5s1riQhA+TL4+6C5HzirE6Zz\n", + "k7CyhS7V3NQxCQ9PY1spins+nf0pnDgkljSm8lCxwcCIIeoQqw77lXZxvWJoczNbQZgYHAgNekaW\n", + "Wy+FtOZbJIUS6cjHshzqZpmWFEnLLqbqsiIJHiYZYupE7Ko+toItBUYNdqfh4aEGoO45sGBA29SA\n", + "xk0zwhSdsDqi3xPFYMc6h16I9PXTVYrENMjFQ6zMgM38cYJFgCHYgS7pXI2OxiDEon1nrkYtB9EO\n", + "XG1z2vfA+AfAyELvDLSeUkpdp93xrkVphl7fpXpV4Q0TURMEVo1W2LjOSViLtslv1zSoogjOLfDw\n", + "rZAfLZyVIbhXYPV2aN0NBzyY8WALePR5uHQfnPqgyNxJaD6vvazqA5izFb6p2AJiEwST/cTsiEtJ\n", + "GRgCrvIRgZZSTAHLpkV2aJLEHu2MSWBVSBKLphriW30KKqEaa4fpW2I4LQrLMnHDGMfQQ/ZwC57I\n", + "wJU+PJ3XrRkjgR0T2i0wFHRyYKXBsqF2HFJdOP2TcKhgMG4YWIOIi5khS0YbIy4wtBx8P0GpJpHZ\n", + "Z64Ld17WQNVqBdwH8rwwOEzvdAtudykvO5S7YCYTdCodJg/D3jHg1XfxGnjHQgQBfgX475VCfb/X\n", + "v9dCKZTIa7iRNzJZ37Pxvk9G0N4a111Q47UGWwOXKGPiREfgyVNwx6a29nxlD76ilLosIqlpuO0I\n", + "WPthmIN+FgqvIPkeAXs4IhxWaQqqhWdARsFUrcYr2SrCFKaXENgRGW+LKAVFH17Mw21Ky4Z3Qm1a\n", + "tp2GRIGK9G6nh7a494BzAgcSncDsokv606KrJTHaBM9Renc0jGC8A24TFl8GdwpyBU393KnD7peB\n", + "HSj9IhxcgCNpKITgxXD6OHSroBzgL7/bXLXYgvNLcPko/NlB3TPeW4S9f3fzUHz/+rCglCNuDYmm\n", + "fWiZ7FZ6DJyEcVE0gV5ssBfFuAnc24aNgjCwwBZtZDirbGbbCUuFiJ4T0FAWJwKPhjuNGaWZSZrs\n", + "popsJilyxjIOEREWuySY+JQVGB2wNiDwtcppJoGcr6+JATAfwaKCFQMypr4megqMOGHS1LoxXQO8\n", + "EJIIainFkD6RnycOIgxjERZsaLwK7uA6hUalVEuk8jI8e5fGjNgJtFPw3DjsjBxAi5+GOx6AO3Yg\n", + "04Yrd8Hzt4rIb9wA8TN3kviCy8b0kM6Y4CrFQMp0ltPEtTe+eHSNLgNo6Fj3xOtf8cAZ+IssbN+l\n", + "pTa2+lB6Eeq3waECDC04Bmw+Bs/nIfM1xSs/LpiRwnU0wy0DGFgYScKG4VCJe+wZMR6wLxl1unwY\n", + "b/i0qg5bZoEZP42yFKHhkk4cBmaDbKzPv6EUFYGUitkTsCKtGrti6oJe+Tto4b1EV3UWPGjYsF2G\n", + "XAjFsk4mmj3YSMH+kpBN2xjDGHEMqsEeWbOArzwilSbpRrisUrQ9TuxBMirF5n2YskLycxb9VZfK\n", + "rkO2c/XMWYiCcgDlA7xPkhHgcXR//Is3+kB+iPjbZOQ9GDWohdB19G7IiQYce2aFk4/k6KunodCC\n", + "Z7bhc9fTAoGDh6Ft6JX8lhx0UxDmsaNleuIzYYLIgD4R+dDEVzF31jx6hXPsbhWpjRskQYdcts+x\n", + "LaiV9cThCsx5MN+HSxnttjs5onWGpmbIjIsWsaoBm4ZOKHJK73rSBliiuyNRBLYPxRg6CQx7MFyH\n", + "7X8G/scgdQ/E4xC2wHKAD8BCEdJZKHhafdUFjvjwah6SKrABqz3YymuPl9USnHsQZBIOXIBdG7ae\n", + "UMr7i3d/KN+Z6ML5PvHCEq39HofSDumeS9fdYz0NV/wszqYickOKPdjLwRCDCQwKXsIOCco2MKKQ\n", + "ot/h0oSBZSTkGika0ylEQaxsClGXmlkhl2RJpM8EIQKoWGtInM/A+CEYjzVAcUPBWEv7CoU29C3Y\n", + "NeFECFMGIFqzomaA8nSZPu7qNp6rdELbdXqYYchS2Sd9WDG24JG+NKR7DurH0RnuKJqfg2d9WLx/\n", + "hE3woPZvlYrP6uribffBR5avVU5u34J4FpoPAF95l4dsZxviR/Gf6eIXAnAz0F+BfAe2RXIf1dT3\n", + "waU33NNAchEuDGFfCfaNkqhmGho7YD0BJy7CwIWl+0HdCX4bVKArTw+twN7d0PUSqt+AvY/oyoRY\n", + "0LU9jCiNoxQFZ8B2EJBBJwgLoQagpnYjxk/Csw+X6VlCx46ZFQPDhCFpbGWxZYaklAGRIjJ15bSe\n", + "6OpXwwaxYTIB7oIrAUx5cMsKxArUPFQU7MzAeAOakZat396vFZqHKQO3pzc8LbvH9HCJVWuadLuH\n", + "sbWLWd1j31BriWQ8fW4CC8yhj9ltkrgWoXn1TAZEVh0jBtuD4fuJUfMrwP9yM1ZFrotvoQG4N028\n", + "75MRpVQgkvoi/NXPwl0dLWK2WQhZOdVk8PtNLXD0vW4kJwtxGU6t69V6nwNikKiETNghb5vkVEwq\n", + "NMEPcLqwWICdskd3xSP4n8DfgL3fgnMzkLehGsOqwJqjhbcObkC2q03M1mZhHsirkUqn0vS+0NSt\n", + "mpxo1s0ADVpLh7Bl6/fsWJD0YDmCxu8qpbZF5Otw4DDc19b28a0p+OYjkDNBdfWiWlF6F5aYukxf\n", + "2YHdPGz8IXz5P4aDVWg8pEXWMmfh0ItakOsrHxaRRaXU4rs6mO9QdOA7J7E+k2LOz1JIIpQbkbNt\n", + "jmwUuLA9zu5LS3Ae1AE4/wlI+SZmbOJ0DSw/YLcYQiGh6UKnljCfJDh9EzsZElvglSK9mmCRRAam\n", + "CalEJxgtgVUbjigYN3WLJRnCgQFcLkLsaOuAJNaMKuWgd21AmMB4AhdNnWxuAbshHElBNwuTDdhO\n", + "fCZrPicSaOSg/AxMr8BXHheRbaXURdD3CfB5EfkqGkndUUpdxV5Mwpx6fQsHYK4JhWO8y8mIUqpZ\n", + "FPnWN+BDd+gLtrEE1acxDvQ4WoTbDugW6KXHRHJfU6r39eveOxSR/xu+/HMwOa8Zazt92PwdGP8x\n", + "uDQD8R2Qn9c2C14G+hVYmYXpC3BwC/7yDpibhuIqzBc19b+RMYjbQ4ohSFl3wnbRMi4XxuBgAIkF\n", + "z8zCWiPFWCYDqQYrKYPJSLCNiD1TaCm4N0nIoNWXMwHEkdaqcWI4ZOgNiLMBwyoc2wHjomYFGQ/B\n", + "8QBUBjJD2FfXQNRsExqi8FMRO2mDQWhqbAk9zHARqxNx8DsQ3QbteUht6+QrsDQ7a28Y0f3zM6hH\n", + "p6kdLWFFISKrxFadw2fgYgKD90VVRIQPoqlKf3qjj+WHjBeABREmlOK7qoXvxXjfJyMASvkvikgT\n", + "tj6grcP7J0eur3t/w9s2F6Fahv13watdyPdgooW/v4bn2vRiixiFZw9p20oD1RIodeDoGTj/MNQL\n", + "OlmYNmDa12C5joLzJjSykN/Urrk7s9o7ZUHAE10BUWhMQFHBmoJjgQbcLRmarluyoSfwpAvNGAZ9\n", + "GP4WBCOviOpn4NZxKDT15xxogG/Bq4/B9B44e7AzBokNvR6UzsOOB3hKqboWPFr9ONw3CfMXodLU\n", + "a2A6gRMd7QDMTZ+MiEgVcJqMbVrsN7pEYwlqxSPfcTAij065Rv1zwFegpSD4CSh/JqbxmEUQmSSB\n", + "4EQhZlYrah4xYDkNhWSAiicoPxfQPRzRmc7RiT3aOY9SqBfLoQJlwa3oNkAaXfE6mdIKu7i6beOH\n", + "sO5CNdAvaojgJDZOnBDGBm0nRzecoGa2EHeHDVtxpKf1ITJDODgF+4Zan8If0xiJ29uw/iBvYMqM\n", + "xL3e6Mo8/N445Z4L4Q1hUnXgL5+DrSV4xIRCG7a7HCvDz1y4BsQ9ZsIXPiYiF66vkCilNkXk/4St\n", + "STQyfEcpFYuIB0//r/BACZwuNKZhJ4S7L8LlY9Ba1hXWbBtmL8Hlh4WLt1jMh0K2l7CTdQiaHlci\n", + "MM7Ard/UyULfhq8/CBc9KBZh/ECLVK5CwRjHo8cVIsw4RYuEiRAkhDOWheFZ1IjYsSMKJuRiGA4g\n", + "qUF1DdyqBitvHgczD2MBpAPNpEvy0CxA2YOzBQgugDNM6JhCfr/BROjS6Fjcst6iruCUguTPQd2l\n", + "k+6tfRCGOs9bfgmib23B8w0GFx22/v2ASuxT3ISzLdj80xuEHXon4leA/02pm5uyrBSRCE8CH+Um\n", + "adX8SCQjAEqpJbRs4fcN0e593QbENUhVNWdysIkp25j9g3i+x/qgyXAyxVwipJMe2Iq+BzM9rQh5\n", + "9AFYzcItkT7NFaCX09RB39Wl3fJB2PctaG3p0nAjDYVEJx1KRgJYiSb6DPqwGoNj67LtakqXZu0N\n", + "+MA6NE149RPg/blI9jhM/l2Y6wAHYS2B3MtwdBWebcNWAMUM7L+kHXpXs2C0ofHKVYreaAe5BhNb\n", + "UG2+/gzlfLAKb+sAvcshIkUY/xm49YAWk9u+LyL7asSx56++RnOYa/PApeuwMZ8XkSdi+JBH47OK\n", + "iXsUZQUdD8YDKJlQM+G822estc7uQ2mS2KbWSxEOVhEvZKYDhTlopTWu0mPkEgxgwT6BdqB3paqm\n", + "QbKVPKyX4DYElZjkI31AW3aWKCkQD45y5ImQOH2SzQ/WsMegNNTVkKIFnQykdnVCClrZ9U2P4TIs\n", + "t2G5DPtH18LQglNFqP3bH24kfrAYjcfLo8dIJ+X2qdczglIxHA3hyjE0+vv69yu02Nv1f1sTmboE\n", + "e13YGgMKcOsGzHagXYbLU1oh2W3q/Ce1z8EToW0LZQGlTC5SYfnVBtPndPK+k4fNvHYEvlNgoQQ7\n", + "RptivMWiU6WgClgEDNQGBBHNHrwU26TCLMrLYjSapOcVExVFVhIOxtCbhtUCuB2o58Ab00mJZcJu\n", + "VjPz5i1dSekbut0XZeG5tZix+2ImE6FNgNlImP823LcOfzwOK78GKA3kvXgM0kNonkFf/xG6d/xv\n", + "ROTPtN7IGsDmm7GRuBlChHvQyqWfudHH8jbFV4GP87fJyM0XIlI0kU9aVD4WkVcDuscbtC6/TGKt\n", + "kbqzx6yRZRjNke6DWm/SpM9WaxNjIcVk5HHbeTAysP4hONqCelYvMkYCrq/pmaGh8R+hoZktu3eC\n", + "5cPcEM67miEzbmqA6jrQ9CH7vE5U9vsw34FeBhr36efmmjC3rDd4yT7o/EM4lIJMA0p9XfnwZmD7\n", + "56BxEaQFrz4Fa49Bdj+oAfiXoHMSml96wynZ1mZ9976BZbFWgvaL79KwvO0xMv/6L+Duadi/BRO7\n", + "8O2LsP4oVFowPvJtaaS1Jh7r179fKdUFvigiqzD9TyH1IBwdQKYHbg+mYvh6GTbdNsZlj7jvkve2\n", + "cMcjKvtgLKvbdBZaJXfPgh1DW9KbQEq0VP3WGNxag0kb1hXYKaGdgVys2BDF0DBZlAxeNEFaBoRz\n", + "AUZ5iunmHr3xBNuEggtLJaiehngI7mhRXq1A+8k3c76UUpGI/C785d+F2X06edtQsPn1FIxVRY53\n", + "YTOEszfONE0MXVH8rr+jK0JvNowa3NKGqZOwPQm7H4DOcX2+VjOw+wWL8omIkz9pMlVxmO8KXRWx\n", + "mrJYM9IkDa0DorLwbAG8deg8DUcfhVsy2q03iBV5c4v7kwY7iUUgHpkkJhlqfFh5OEacFMiuBQwD\n", + "SB8xKEdCWwWElpYDGE5C4sKrMZQdmK9r3aGGpTcyHU8rw+74kNmD9DrsVGDuEty9p7BjRTsLG0dh\n", + "Zk2DonFHFObnRo/vGaPEZOWve/4mjv8B+OdK8R63uHjT8VXgl0WQmwH/ciPl4P9T4B+Mfv2/lFJ/\n", + "dKOOZXQ8C5PwX4VMfMBheigUhx2i3C7t/Q3ORT3mKhkqhslaLiSOQYYpKnGBVKNHbLWoljzscQgn\n", + "9C5kO691AYZ9XeFIZzUllgA6KTgQalpmOKvxAAMT2pGWAU+uMm4URIHWDVkswWRFa0tcPqyrLJYP\n", + "y4d0ZWNyCebakPsIHH8Cepfg7J1QHIcJBWOe3lk7BpgNWP0smpJhAW2l1PdiIWyLlE7CEw/AbTUN\n", + "eL04By8OYXBTSQ1fDW14VvjP4cBjcLgD3gJc7MOx5+HZHXjmITj2AqyPwdIchOeg/EkRWazCrWkt\n", + "h9rZhiXNTCreDTMmpFIa59N3wWhCxoFWFop1n8lLCdE+uHjcYt4xyaqQwE7omSPRq0QL0pmO9pqp\n", + "KWjmdDWsd0DrXYQp7frb8w0uGxbZWLDCPKVslmbikO0MifYZZIYuydCg3Ui43ISZCCIXXjgMuStw\n", + "qAMvz8KLXei/KiIlND7kb2RFKaV2Rq2NWXQJRy3AL9wKqQp4Nbj/LHxERP71jSnZt87B4qNw5LrE\n", + "ORK45Oh7Qceo6pkDgu9tP7H7DLz6czDWh/RAC3/FQwhWMxwLMxR/3uFKccDKXEReUtjikSQm4TB4\n", + "mcqJAAAgAElEQVTL1KBPMhmR3oOFBnQmoHm3xnZM+qAMiBx9P64DpcSnKD5GpLVDUg5kTSHBoBJH\n", + "qP1D6koYE5deEDLMwdMZtAWBoTH17Qg229AqamxJKoSDKUjvwq4L/qvw0BOwcwTGJkC1tbeVDRT7\n", + "0KnA0jx027ye7v0jFSLcB9wHfF8D15sozqPn90PcBC11uVFeWCKyoJRaGRlzfUcpdd8bnldKqbew\n", + "o3nL339gHB60odqFKxY8VsZ6bIwxy8UK6wg7FFVEMVG8tDDBoWiWfL/GVnmKAIU59EmGLoWtFTr5\n", + "ZQ5MxxQCGIxraqwCdhOQBA6HkMnoXe+egnoAczGMDfXEsGvoNv0gA/0++Bm9y8u0oB/C1m9APoKF\n", + "W2HjUYhnwHHhdk8D2gYG7HqwNYRL6/D45/Vk+Pl/D8YOavZO04XaGtz/efjmGJz+1ZGJ4fc7TyY4\n", + "d0H5Y2DcD1YAuXXo1GHr3ykVX/p+n/EWxuQdHXP9HcXH4cinYf6QTkYyHnSyms459gL80ST4qzDz\n", + "MNy9DFN1WJnO8J0HP8jOc3fD8hUY+zLlnxoyUUgRZCJm0j4pSy8QSaTBwJEHYR8eew7OzLucn4rI\n", + "VhSTKUEiwUhCJtMasuEA5VgnobsmrA01k+lAWrfk+i6ElkkkVfqME8URttrDFJ+UOU9nOM78csig\n", + "YuL2tvGSRZw6DOvgHtYqoc1NzahoBND+gwJ9ZxyOpoAWNLfhC/EIzPomxkmm4B9/EnL7tScBAOdg\n", + "8qtweU+pP3xrY/LDj7tOMoqfhiMPweGBrg5cSsPiU9D5slYWNg/D1N+BfFVrttTPavaZY8NglRH9\n", + "FwqPw+zDkL9VCPZn2VMmjlFgfDcgGrNYnBrHVxvM5cC1bCw/IteFYtSlV/DYXlaMDyCVgU4RtqtQ\n", + "7sPhyxAcgPKENrGsoyteKoKMrxNaowGdnTw7+/LklM+anTAmJWKEQcYlkT6JWQfVYzKEqoJA9Mbk\n", + "4BpspeH8GEzuQep5ePCbuu373Mdhz4DqBoS3wommVlO+MgnPb8Hl/10p/015Vb1d8W7c7282RPgS\n", + "8AWl+PUbfSxvZ4jwO8CLSvGrN/pY4G8e8xvpTXO1zKf1sN/FSIvcewf8zB3QK8LgMnziAnx6H5Y/\n", + "RaENMIUiRSt/itjZh5gWfVUnXwqZjFfZtsqE+ZCB2cPL10lbMbsRFCowKwYSK5qiCA3BShSXbL3j\n", + "7Y8ou4Y3clv1oeWAIZpVMQzhaANK25rnv5QBfwkKeWjUwf47WsysGGuBqnpa0zhvGWg65npGT0rn\n", + "j2jF73ILDp/VLSEjD/d/VRv/zSo4PY62Av4bYwTsOwXq03D3Nuzfhuoe1DPwtc+KyK+PrNbfM6Fd\n", + "WDP3anG3uA87z6KV5QSmPgJqCjYOaMGr7Rgqq1rtdH0Skuegcgt86gUN/gObrdIYR8IdBlMu3ctX\n", + "cBYKGJUDhLkMuZ0+lwq7uM4Ox2JF1tbA1LoHhW3Ih4JdDBmvmNziRXRSEErEWlorlJfQFN0VQwNV\n", + "hxHYl2B6Hhb64BfhUAhrwSxn0pNM+4qha5KOcoRqkXWzSRJn6NqKULUYZtfJNXQ1bbIMj56CzQrI\n", + "CzC7Ac/OZ/nKnR+C6C5t9atqkP0G/D0R+U2l1JtRbCxXYGr/GwzojkLtOTh+VY79bR7WvzFG7ruf\n", + "gxdOw+XjGiDcOgssj56bh+N/Hz7UhOl12JiEc/8YWg04dgrWLFg8D41/o1T7iyJyMov7B4cpdyvk\n", + "OwHe4VVWT/SYyKQ4EbapGQb9JEWh71Ie1oncNi07pllXRA5053UlpGjAwRj+//bOOzqu67rX354O\n", + "YAAMei8Ee++UqGbJKnFV7DiJ7cSOY8eWX8pLntOzXvPKy4sTO8mLveKVRHYc23GNLUdyHNmS1alC\n", + "SSTFDjaA6H2AGWAG0+e8P/YwBCGQBMkBZgjcby2sBVxgzj2459xz991n798+XAJjNeAp05iiFKqs\n", + "awMqbDBpB3ccPCOw82SUl6bL6K0sw+bz01VSQomtkvJYHHGV46KCUTlFlGl8AmuicNyp2kXlcSgt\n", + "gvEuePAFcCfhlVVwYgMUFUFxndazeake7FP6ctT5bWNSi2qI5BOZDJqN3HwF8ebDY8BvQX4YI1ci\n", + "H2JG/gvw6GKdTETcLfDO+zWqLA4wqfmztgAJR5Kkw4EjaUOoxRE/S8BbiQlO4ndEqMdNeTyG19HN\n", + "YMkUk644k4dSsA5qisEed5KMOiiyG5pTUexFhmGHpuh6hiFVBBVOLUI2GoFni8BXoJofjQFVTjzZ\n", + "CGu71eXa2KnbOU/shLoa2OGB+hRE7DCUBpsDzhrw2DUbp7Qf1h+GU3Xw9Ard0om7dcErOXUxFiIo\n", + "aI7wfK6XC4p+B9ruhaYgTLfBWAiaXoEtSRjeBfxogYbrmlFDpP4h2F6m3qHpYjjxEWh/GkL7wLED\n", + "doZgeBCiZXo9h1eAPwjtDgicgRXbocx/oU0X4eoSysYmKayMMWX3Y1u7Envc4EgJ3iSEp1z4CqIM\n", + "OwOsj2vWVMUg9Abg1WbDRIWhJZli3C1E0vrwacxohQSNCpwVZbZJplPgr4XhOEwUapZhzFZAdLqC\n", + "ipTB77XhihtCKScmUk1F+CzO8DjjIsSnYjjDUNYOVYNQ7INACUxOw6qM4VmeLqBoxy4mH7vw/1VD\n", + "eAcUjsIdwHy2S/Ny/zkTlNqR+ZpF1R2wc1o9TnEHBHfCHUPwuhfKp2DzJLywHl7aCey3QXUbJtVE\n", + "2RjYbX4iHjdtaS8FtjS2ZCnVcRexAj9dTkNseJqoJJkaBucklO+A7SnApsrMpwUaYzC50kYkBaFY\n", + "mna3xgutSWu15T67Lkd7O0BIcFtXDwN+F89trmbIVo5xgXGmMHY7hfgoSZURZhoH6nH1pkBS0HgO\n", + "RgLw6qvw3UpIroWy1bApkpljlRCchHUT0DkFwZ9CerF1YvIG0SJCfwf84RKKFZnJT4Gvi1BmDBNX\n", + "/escsuDGiIjU8OZo3kFjzC+JyC3A21jc6OWaWnBcMEQAnBArgcgEKWecoMdGWdiGzaQwTkM8Eifq\n", + "bKEgdJaO0j6KysHjTBOxRagIQkMZDIxBaZHgs7uojELamSZWJDiNDdJCJJykNgqrxlVSvSIF4oZo\n", + "Gjb1QSAJlaehf6e61D39sH5Mc/17KsFbA2vKYG0PRJvAnanc2ZPUNL7AeCZ4sgsSk1A6BS/+CErv\n", + "hOCdsOcorOzVYL7TVdA1yrwD0Lx3Qts6WBWEukwswIQX+nZC2WHw1Fz584tN4W7Y4YNdF97aw9AQ\n", + "hMm74fQk1IS0QOGWHk21PFwNoQLomITRLwAhiNg0vkdFKNM4IwliHhuppAPSLhLuUpyRAFPFaVwu\n", + "wZtyUzZewogvwNAUtJ3Tz55pA4bA2Awhl42RlINbJlKMl6WoQb0iIaPS/w1ROOsEX1x1XU6KigLX\n", + "RqEYO70iOMVGWcRFfFQIpKDcODQGIRZnvAP8/wNIQvrt0L8dGktAzkDTMXBlvI+hEi/JN9UQqdJA\n", + "prp5XuTAOAx0QXkr/Gd8yGmontQg1jxc1F2NWosJYKIcihzgmVIV42ChZsysG4VTe4D9FbChldjp\n", + "OIFVLsrHJ3C6SihLJImkQ4TtXpxDNtJVYZyecjqmJkgfgvgj0PI12GRTVdaAS70jGw3E7ODFji+W\n", + "pt3uhhE7pakUA54k054UU2OAU7OevFGdP850HIYLYGIzkdERUpvGcFYIFTbwJB1EM4URIzb1ruGA\n", + "zgKwHYf0s9BzBNb+HqwrgLUxjUcbq1PNoddjMDkKo0tCRfkG+HVgDPjXXHdkITCGsAjPAu8Avpnr\n", + "/lyJBTdGMnEJ98w+LiINwF8BD5rLBK6IyKdn/PicMea5LHQpHr1YdQ6AUt0DGYlDZRH+iUmmKxO4\n", + "7UPE7BHS3x0ivcHAzjQ1jlqqYzEMI8RTmlrX2QQ7nofh1QYvKQo8NlxJQ2LaTtikmbLrm29rWDNq\n", + "PIP6MI8VqgDZaBLKu6EkDF0JKAvCSKXGlYQEIgNQVqr7vrYkuEcg5QNvAeBWpUlHDIoG4FwaNgTg\n", + "oAfM68ZM7BfxPAuRd8LpBhXUGuqHkX81M+p3XA7dh2/cq56a8dqLvykLwVgZ9NZAKM/cu77N0Dqu\n", + "ol+hYnDFVCOl2cDpFVDVBYOtkCiFliDUROB8AZx7/sIWhUjVOTjZDJuGACJUnx3h1fu3EDxgB1NM\n", + "ajRKcLWdsrE0/mQCRwU4nCkm49D8pGZfeMqhYUqNolcqDJ4yQ4HLEHYliWW8ZWmjFVSHBDwu3Vqw\n", + "JdRLdqoG7H0QaAQn05TEIvQ5y6kYFeJxL4VdAtFOYjXgfQM4lElfB3hYRCpB/itsD0JxxgsWs8N5\n", + "h4PpwdlXbUTdc/MKcstsezz6DHxsPTSVQ2wE3O0Q8EOeKvPGB2G0CYr9Gk9yYQkICrRkdFUcadTN\n", + "QBLCBTDqZSQ9yvSaNCXxKOHCNLFkCsKDJMrBEYrhGBoi+kwIPg+u34LmOKQLNBYsmmmuxsAbDiiO\n", + "CS4HlKFRtOuGDDF7kImyFK5noGsXvFysczUBBOIQeikA9aNQ2UD8SJL0Zj/+2igVjiBFSZiKwoCB\n", + "5BgU7YOac3CsBqbOA3UqRe9wgSusBmlzl+obxVNQ2AED9tlXarkgQg2aQfOWmyHb5AZ4DH3hX97G\n", + "yBX4n2ge6w80wJ23G2OiM//AGPPpBTjv8BAMdkDFSo0goxhCQzAU0ChGv5OIJ0DEMQSnUvD5IdgR\n", + "QP65gIpUmmjpFKP2NF4bJGvAVMDoeQj1wEg6TmiLG684SETguEkwWZCixaYxIANlWj8kHoT0eZhu\n", + "huSoKmmeLYfkeQ2CNANgOvRNLpWE46vB9MB4E1QHNfhu2qbVXYcFivy67VN7GI5Vgv/f0R2W3VC5\n", + "W3VKDvVA4gDQcznjbw4EbG5Y3Q/7xuGMD1ZM6qIdLNRSFKE8S/FNTkP3HeCt0hTqgKjbOtQPjMBY\n", + "GDY9ByMtEKgA2zAkYhDZf7GNsX+DFz4E3c2qUjtom6TzuR4SPA2NfhhNE/JWEg9F8TSBSAwkSOF5\n", + "WHsCzrZqwLB7HAZLITEGkfEU9uYUNgMuBySdUBqCcKlmTrnjQErl38fL1FA551Fp7qlUGmdfP3ab\n", + "jaHGYhKRKZzFA0w0D1M2Dp1tMPrczHL3xpgxEfkn+NGHoLVMyxB0G+j7fgBWvA5t22DACekBKD4I\n", + "BX6tZzEvjDGDIvL5QVhfBFUhGExC++x7OH8Y3QcHH9J6Lb4J6DDQXgHxEd1+BDhbBYGnACbgyCnY\n", + "+3aSpxsInB8mGZmi0RfA4wrjOx3AlrIRsaeITgGfAaahaD3INEw7YcirYoNJ0aoS8SSUjiQZr7OT\n", + "Tl4orhclXpwkPgGbDkO7E/xTmpWVTsPoKAx9c1StjM9tgJJSkmejjKS6CZUHqZ1WTZEzAr4oeFbD\n", + "vp0QHYC1HwW/W7fpykMw7dYgWYCkA4jCeAqVd16u/AXwVWM4edW/vLn5d+BvRCg2Jn+rrOcsm+Zq\n", + "LGSktYhU1sGvrIDyUmAApBuOB+B4Deywq0jH0Si8YYyZVg9B7b/CXVVwchtsFqg1EHGqTPPxOAwe\n", + "gOQPwbfRQWKLEK60URSO0xAwBFdCXSFURdUNn56CaT+80gK3fS9TGC0EURe88E5ofAX2dEDQA4dq\n", + "4YQN9rig4BYorYCiJJwvhkMBGPseVFRmFpwIjD0L0y9D2QdgyxZYP6rGw7kqONQHI1+5Fje6SNWH\n", + "4YFmLSd/ZB2EWyDlhO4pGPpvb679cUPjkoWsCtcvw67fhLd2qlgYQFclPBGBwQ9A5YdgV5vWRnSn\n", + "9Lq8ZKDnizMLvomIDVUk8wLjGdVOLxrEkSiFe314PlJOhS2CLd5PqnyK+pjWiZmwQ8MZWN+jZeNL\n", + "AnBkJZx4F7QW6vZMuQ1K0OrJSRuUCBxOQtu0PsCGA1A2Ah02GD+pyr4mamd0owfv5hTl7ijVBpIx\n", + "SHeA/RC0vwrBf5tpbGrMDy1oyk6fMSYoIgU+eKAMdrhAJsE/Aj9KGjNHrMXCs1hZFSL2dVD3LvCV\n", + "wlQNmHLY3q6ZLr3FcHwARv75glZKgcjeJnjHCpAgFB2jaus0W9phZaeKyR11QMdXjUl2iIgbKh6D\n", + "0lthpx3cdr1PEqgxEgzD6vMQSwmddUIfNlbFkpR0QPErmgXTfgT8j6Dlt5Poi0Mic41qnTh+uwDX\n", + "LUnsU9OkBqG6BtaOw3gJpFfAdBHUBVSLKDYCRUfh+XfD+jMqslcfUu/s/lro7YTefzEmtG+hr/vl\n", + "xyN32TQi3IV6Cjbk8wM6W4jwQ+ARY/habvtx+TFflsZIpn0H0IqmoYwaY64oay3iex+0fhQK7oKd\n", + "NhVSKo7qg2QwDs8mYfRBlV123A633Q+3darc+8kVcObjUO6EpjFIJKEvAkOdEA7B2l51UnUZ6D4I\n", + "xcVQsBpSk+DfB7F2qPolaFgDhY0wXgVDZyDwf4wxfSLizPwfYWNMQkRWwM5PwDu7Lt2Rer4F9n3f\n", + "mMS8NUI05qf1k7BDoC6oio9HiqDj28bEjl7zhb/yubJgjDT8EaxuBVuTOt5iaL2WoR7o+DNgCorf\n", + "AqW3gM0J4Xbw/9QYM3rllmefp/BO2P1eqAiBJw52H/i3QH859E7AriG45WVwZLbDYnb45koIVcOa\n", + "tVDkg4RL03YLS3Tfv3wSSpNwLgbFP4HbTmp5gEdKoPdvgHLY8BuwsQQce6EqrP/PURusegYOlsEb\n", + "882IQR+guIDQNXjLss5iPpQyRmYpOjFKoWQreEpVEDD5pngXVeqlGQ0imgDveihugekhCB68kB6v\n", + "XsjNf6py6hWF6lFLF8A5gVQCWnuh9QR0VsOBYzD8dSjcC76fgWIXJPtgcj+Mfm/2XNSXoYqPwK5V\n", + "sHVA155D74WpCDQdgIlbYFsQDm7XWLPq89BboRlUowIHtkNjD9jbVKF1vB0m/xESh5bLuF96XlzA\n", + "G8D/MoacKAgvNiL8PPDrxnBvbvuRh6m9uSajIngNQjDB56DrQbglCAkv+GyQcGhFT28SCsPg+whw\n", + "EGz3QUuXptUBOAqgbVL3Z7tD4A2pCFJ5FPafgGd+hG4u95rLlGMXkYdhtBl9nZ5A80JXiNh2ozXF\n", + "Oy4WNito0kqhtlmttEzB8bXojTgvMmJXX4TxPeBtg/gZGHt1Rmp23qCLdpMX7joMY2dhuFS9H3eM\n", + "wXO10OHJLPRPiMiTgG0+sTNz422AthGNT+lZAZGd0BzVwofFnTCwFvbfBltfhWABHK0A/+MQPgCn\n", + "fg9q2sDhhfhmkFFIn4PgaigYVzXX4UI1clyAux7KP6I6Yw3l4LRBTY+KVoFWYu6v07ik9hZmpdxe\n", + "jsyDNw+DTReOzDbWhayCabS6IKDzRw15qQQTRu+pILofeYHLvLRU7dVCkr2rYFUMJoohFYNqm27J\n", + "dtjhVAWMHoDAZ4Ak1P4M3PuUBs8CdFTAsx8Tkc/P2u5qhtZVsLdHf/T7oD6q9tHx9bApBVEnlMbA\n", + "lGiyU2kEhuph+2sar/Lqv6Dr/eC1Gt5LkE+hmjI/yHE/FpMfAf8oQrMx9OS6M3OxbI2Ra8Vo8bh/\n", + "gIFbob4AYlGwxzQwLOgARxLqt8OaMThbA6kq3UppOwmRJiiNa3BiRSfUZR4iR2ohbTPGXHXPMrOI\n", + "dsGF9NXqh6CtUYPj/MC5MRH5mjFmAuLT+qY9m2kXJK7ZJWmM8QM/vtbPLTYaWFl9RhUlV41p5gxo\n", + "obLhFFpG9T//FuYuhqUqrTRlfuw1WjxuFuFB8K+HegcM3wdVhVoLZKoAgilY8zzsX6NFytJjMPI4\n", + "pE9mgj//HELroeBWWDWlxpM3DO12WBvSGJLuCj3Py5ugeCvs9GvAcOFKmEpCxYzUbIdR2f+4QOpN\n", + "mTIWVyezzfJBWLFadXiCwNnJzD11VT0ezY6rHYPzUzBVrRo2ElKhsfFhmBiEoc+COaXeS+9bYbPt\n", + "oiECsNIPA80wsFpETqHbaw6gCupnnMuR1F2cqggki3UrqDABIZsKqAkak2JLwEgRJEfms8YsB0Ro\n", + "BP4A2LPEg1YvwRiiInwL+CTw33Pdn7mwjJF5ots6pQ3gn4DuGtiQ8TyMCBzzQEsvTE1A2yhMnAFH\n", + "CyRXQ7BXy8B3OmHCB3VRmB7RgmNjBTB26tp7U/YA7K2F7TO8Ew018MyDwNcgdQZOp2BVAVRkHqRh\n", + "J5xwQ+BINq5H/jL6NLzykAYXN0yoVsfhMhh+dD7BlSLOTdD6PmjJ3BvdSRHn941JnLj0L6ePwPG7\n", + "IL0NXNWq8dDrAv807Iio8FbNKTj85dlS+xmPxGER6YN4o3rKbEBBBwyv0/ghRxh6SyG8Fdacg/V9\n", + "YItDsFa1aYZ9GkdiS8OgEwon4LgNEllTxF3K6PZLyW1QsgGSYfVi7myF22bcU63l8JNfFJG/u/p2\n", + "xtQxOPE+zdDyO1SYsCgJ/V4YKITRLxmTnuFhKayGsjm0fsoS4NgA1e+CliINZj1Vrm3szLzRloZg\n", + "cBwG68HXBf21ajubKPQlwefQ4FXHELxaDSM5LbWRZ3wa+JIxdOa6IzngC8DLIvxfY+anM7WYLGtj\n", + "JFOXowHVHOkyl6k+KSJl4L4btuyB7d+CH78PRtaBpwimE1qELF2lmSc9O6FqGM7FoawKgq3Q0wRV\n", + "bmidAl+RfvbIBEx0Q/rla+yzC1q3waZZ7uK1w3B4tYiUGGMmRezfhB9+AForwS7QnYK+R40xfXO3\n", + "fHMjIkXg2Qa162C0Fx53qXJtwg/DjxljTl/l8wXASlj5Ebh9TKsou5OwKQQ//YCI/G3GQwSAMSYg\n", + "Il+B0HehqQimEuCZhtVxGGoA5xgMF6Gv2HOiGS+Vp+GNVbC9H5rOwmkfHFwL6WPw7HpoCkFLJmNp\n", + "1Sjs64fUKg1cfaNGNVJGh7WcQN/31DNmcSXUEGn8L7CrEFrHNPDztQcheRxmurBbx6G2SQvmXVrh\n", + "981MvgztH4W9SajsgxN14C8Fx2ko7YbkLI/kVC+MbrhYBfkC/YVQeRu8q1tLEQBsG4ZH3wOHx6Cx\n", + "H4ZKNWbldA14wuDqhUc3QnkvjMXhZAPYuiAWh5H/MCZxxdiuTL2edVC9U4UUx45C8rgxZkl52UTY\n", + "ADwIrMl1X3KBMZwV4WXgw8A/5ro/s1mWxojok+ueNXBPM7qMd0NYRL4x82EtIoVQ/h5Ytx6St0FF\n", + "DCYFfuHb8NJWiK4Atxe6mlQb4JYQSDn4G6ChC06HodsLG/vANw4tAU2rK3BqvYrAT2a/NV+mvzZU\n", + "kMoJBMBuA/ssoSIbmfLpzSIur/5b3X8H3dWZX/YaY0JZuoR5hYgUQ/0nYGsZNAU0KPS4F04/ZszM\n", + "lN05PytQdAe0vhVsKxy4dlbxfLIW+1AM0oO4pieo74bejcALsz4ehdIE7DoINEF1WANWzxfB6/Uw\n", + "Po/MJf8j8NJ74MwGKE7DWA8M/hvEOsHWCmv3av2cC7R0wBGnysebYQgMoim5J41WE7a4Kt49sLMQ\n", + "tmUywUpjWkBwtBVGzuk4XsBpmMc6qS8AlU9C79vBvlJjlZp7oWQchqK8qeRF9CgcvQtKqtWb2lkJ\n", + "51bACQM7J6B2xr1aGoeN+x08tbUKubUSm0kQS04QPTysgpJOMmW70TiYIVTkZOpiHNmVKH03rNur\n", + "1YodKej8eTi2TUT+5XIvaDcpfw78pTHLOp35r4GviPDPxpBXxuayNEaAtevhgfuh252JGxiA4sfh\n", + "wyLy1xffCCreC7etga298FQENgShfxOMROCeNyB4Eh6/FQoESsrAG9GKod4wnGyD4DHw9MIWO9jd\n", + "MLAJKNWg15IzMPUmwTA1gNxbwLcKYgEI9ELdPVBXCe40DKa0eFp3OayYUR21txSG2mDDp6DWDbEw\n", + "9A1C99dmiGEtUby3wk4f7LwQuDkFjRMQeruIHL+yEebYAhvfAff0wpNrWwi566lKO5kuKcbVWUOk\n", + "8ABndk/hiYvUNMHYMUi3ZxbpWvWCuYrA0wHjdUAhYCAwBbFHNb7HuR48PpjqB87OXOAzaaTfynjp\n", + "CtE04iiAiPTD2VtggwsmPXByNxSUgFkJlRO6BVcYgzNvhb4e/b8tZpMx5tvA2wKJaSjfCc0z7h0B\n", + "PAPgXQsjpReNkQkPDMWYRw0nxd8LK+rhLadUpBCgvxJeqgQuuQeNMVMi8mV44t3gfi9UlUL5ELQ4\n", + "NS7tiaNQdw7WDqlhk3CtJGZ/gMRjNpASmOoG3w8o+FSI1vNQkdQt4+HXIXhsfkbIBfHJrbfAA10X\n", + "qx03BSG9CvatB7KaMZcrRLgd2A58INd9ySXG8III54CPQ34VBVyWxkgN3LIJJtwzAhjrYaoNmvtg\n", + "BXBaC2ut2KMeDgdaW2asHGonoWsN0Kf6HdMFcNfrMFoHL63S8t6JjGBV76tQ4VJxszY/VD2vdTHs\n", + "KRhuYlbJbn3Dr/s4bKnQwLbAajj0Kdh2DLZlAtBCLviP1fBkEdxSoArcfi/sWwUtbRroWJCCcJlW\n", + "B01+VET+bKm5XC+ldCusnJUhUJDU+i8dDWiRvMtQ9RbYOQoFyRImvRWQclAYSRAvTpFyT5AoFYpW\n", + "wKZzUD8J57bA8WER+TYQg1QvjKyAcg94z0PMA+OFEHsBqISWX4V1bvWgDLrh9ICIfNUYc8nYZ7Ko\n", + "ArOPibgfgR/8AhTthU0GIl6om4C6DjjQBM3noTUNj79fRL6wzKW934SmvVe8H1ZugOYYRO1wZBsM\n", + "nIGKGVWKa0/ByVXgqdBaNcEiOOaCwW/P3ztQWQP203CgGmrRwNKBNBT2AhUikkDzzePAiDFmVKS4\n", + "B3Ydhz098PoaqN8K5YWQ2ASpMnhpBG5/1cvptWtInq/QzDkAzlLQ4mZdQ4g9J6BuRItnvngrvBYC\n", + "nplfn10tsCJ10RC5wIpJaN/IEjBGRBDgL9FU3jwV5VtU/gR4XIRvGnP5beTFZlkaI3bwFvJmF1Wh\n", + "5sS5NdK9+WehZhucXgntw9DYAe1VsMoDERd0lcERHwQPqof0tuMw0A1D5Wps+DyQPgujYTagsfYA\n", + "ABVoSURBVDi+CeoD4EmpJPNAMXSGYXYQVcntsLsMdmT2rcMe2JQAVyal1pUEbxy2j8Dj/fBUHxQ3\n", + "w3Q7eLbCDr8GbQKUAwWl0L8R+pu5pjTmmw0Tg5iTN6WpxuGqFaEdFVAxAODAkXATCiYZLwKxTRH2\n", + "jWJvKaBuYpLWHkiUQcMG4DboWQvh16A3CGsOQ7QEJqsh7dcgwvHvQf0vwv0xaMxsxW0AfI3wwluA\n", + "x+f1n5nYEY0T2l0DhSMQ3w7NAa1btDIOna1w5yGob4KhWi6berpccW6DLRvgLV0Xj4kNzr4FWruh\n", + "ODNnJpww+BwEX4auFoichcDBaxP1c1fC3kMQdsNwma4Du0bhRDV07IGGdVDjVO2YoX4R+Z6WW9jW\n", + "q8Uz42vg9gGt4DtUDzVJSNXDU9scDCVquZhOHwT3CL6mIiqn/KSdetRuYFc/nLtdRJ6fX9p6Kq5Z\n", + "WLOJOTQ1eUnwLlRp8Bu57kg+YAxviPAY8DngoVz35wLL0hgJwMkeuKd6hmciCdIDAo4q2Hw/3Hoe\n", + "BlfCmgCcr1bphg3Pw5Gt0OOG5AiMZPLU2z8GzRNQP6VfEx44Uo7qFEyJeH8Mk/drxHsU6AlB/7+8\n", + "OZ6gZBusmRFDEnVBSUoL4wV8UD2W+bsIFLqN6X8KLgTYlv03jUuZSXkQnC1AQVYvYN4xuh9O/Jyq\n", + "kl/IaB4s1ut8tZz6WBf01UDreJia/iQJdzHhYITxxmmidjsbR0MUBCDugfQWWD0OFXGVdPc1wjMh\n", + "eNoGLXF9A+5FH2pmHGrKoHGW5sfGQXhjt4j8+BoEp9JQOwzNPTC5BWyZzxXFtRI0ZOKFlm2dkctT\n", + "tQvWjl16bHsPdHTBI+vVYxkBuidh6MvGmDfV7Zk/050wsAU2DF9M2U0D58pgzR3w9rNQnHkJOlMJ\n", + "T38YcGpK+GC5pu86DPh6dMulPwWpKHSOx4k+NgS3NmS8ZxFwpimQKWxA8Yy326IEuF2oQM0cKemz\n", + "SZ2FM2lY69bYGVCBvlOF4M+zulPXjgh2NFbkT4yZO5V/mfKHwHERfsYYnsh1ZyCHxoiI/Arwa4Ab\n", + "eNgY85XFOvc0HDikkqKNreCPgOuEhqK/CNVbVT3TNw3j56BvLTQGNX1urBfGhmHsVSgx4CyDxAk4\n", + "9SxE7lJB1wRwLgm9370QUGhM6AUROQzn6jN/0DO369ckID7jgVI+CX2iFUBtM9zv/T4IzlwobJAe\n", + "UvXPtTOi82M2GDNA1iTb85PEITjWCsFtGkgcFjg3Df1fv7qLfeQZ2P8QSDrG5o4z9LeuYLKwkdAL\n", + "AVKxKdK7Q1S1Q7RZM1scaXWHSwq2DEJHMxz5Bxh0oXN5ICO5Xq96IbOxG30zvzoi0gglm6C4QQMc\n", + "t/RqDNJEI1QGYbQACnozsQ1xrprxsRwxNh2v43UQrFFtoKZ+qO2GZx6DrhDqUeuZb5zF5Zl4RVVQ\n", + "XZXQNgZhFxyuh8k03DF00RAB1SPqbIbjg5oVY0tfdOLFneph2/AkdPtAzk/DvoPqWruwZjknCRZP\n", + "UnQcSmbERA0WQ3gE5rcdoXPV83344c/DKrs+EjqBnqeMMUsh/fWX0Yy2H+W6I/mEMUyK8GHguyLs\n", + "NebSmKZckEvPyLeMMV/PBJe9BiyaMZIJHns4CHt8Kl8YGIGfpOE42G9VuwSgtV1l2zvXwHgxHHBr\n", + "Dv8DW6AsAiPb4MQ90PdlOHEYTmxH90c6mfVGboyZZMZ+79z498OJd8CdGXdsUwDa/XCqAfZEdL/7\n", + "XDUcnobwwRkfHIfIUThzByTLtRJt1AEnfTD2tDFmfM7TLRGMMSkR+T5MvKxCcsRQr9RV3wyNMd0i\n", + "8iWYuB88LX6iB8OMBwZISxwSE0w4VV67byW4w/pg6y6A6guaD2nAY4yZvQ02DMMhGPZeFF8DaK+B\n", + "0BtX8opo7JDj56D5Lljnh4ogHKiDn9bDlldgsAb6mqAvDLVReLIaBq4htmE5MX4MXvojWC2wIqZv\n", + "/afXw5kuNAMpfLUW5osxZkSVkifv03IO6SiMPwml28A3x3gXC4TG4al10ObW6rqlZRqHXPYakIbT\n", + "JTB2KLNm/eMk3FIKG1Mw7if4RTi/DSqLoToEfT54vRSG//laZN6NiR4TkS7oaOOiEvRNr9IqQgHw\n", + "p8CHlpPA2XwxhudF+AzwmAh3G0NOnxM5r02T0Xf4iTHmLbOO56huQe3H4O3VqjFwgZgdvlMPoSA8\n", + "KBerfII+XH7aCakQtOyBFqMvJWcT0PsNY5LzLj6msQHl74e2tdCUVkXFU3EYPgFVK0E8ED4KEy/M\n", + "NjA04LbpE1BdD/YS9dAOdcDoX83Ux8hnclk4K3N+++x9dhH3Vmh+H9RugmofBCNg74Bbj0Na4F8b\n", + "4cxfzyXjLyJtqluyESiNwlAhnAjAwJczMuNz9MG5ERo/orEEjSEYToPrDGw/A4/tBb8fnCGYDINr\n", + "ElI9mdiGG9heyC0LWxTTdSfs/GPYIFAS09T6YQfs74Xe312odPfMS5ZRxV3fO+De3epJu8BwIfz4\n", + "nVB7QiUD+mqhp1S9J6sHwDsFnTboehmmHr+ccSFiXw/V9+j2cqIPhp+5WbLnFr7+GH8GrDaG9y/U\n", + "OW52MsG9fwXcAdxvzNVemG/0fHlaKE9E/hfwCeB/GGO+Nut3OTJGpAXWfQJundI4kPFCOFQDh1+H\n", + "tu3w87NiAFICD2+HFUG4v/NiVPpYIfywGHo+Nx/lzxnntwEt4KqHZAjSZzPpn/P5bCkUbAFvNUz2\n", + "Qex4Nt/8FppcGyOXQ9Nu5Rao/QXYMQI7uyBQAG/UwdEXjAlcNhhVRMqhcAsUVUCgGxInLuexEZES\n", + "WPn7sMet2zN141rB90AFlL8IngQ8PmLM4FcX6n/NBQtrjNT/Jry7APDCdA3YYlDWD8dK4JlvL4ZM\n", + "uohUQOtvwF6jWV8RJzz+NmgIwR0zsl4ONMJz7RA+Aw4nJLpvZiPzaizsuLMO2AdsNcYK6r4SGYPk\n", + "i2jq8zsX0kOS00J5WvWV78w6PGSM+aAx5k9F5C+Ap0XkkdlvKSLy6Rk/PmeMeW5hezvTbT9+H7hb\n", + "IRWA0UcgcR7M9jk+ATjqYcP5S9PjKqehrVKLqNF+DedPo5oE1/x2k3nbzllJ8KVKxuvxhIicgNfu\n", + "g6MrtaLy+KMQff0qnx0HnpvfmWwrYbVNtUPI3LAOowX4OpqhqRPSVhDeNSFpjceoHeCSTCNTCovj\n", + "ujda1+phmLoXCtdD3IB3HPa8culfbh6EY2sh9D1j4jcYv7J8EcENfAtN5bUMkatgDEaE3wQ+C7yQ\n", + "CWpd9DjDBTdGMkWm7pl9XERcGe2LBBpy/iZryRjz6YXu31wYrUj7T5Ix4+CCUufYIJyfJTZ2slYz\n", + "azxz6HjMT73R4uYgo8771ZnzIruIU2uRlPuhNw2Vdk3hdaYh7YCzPhj7j+yfdykzegBOv/dSRdOA\n", + "G84nyBSeXAwy6+C3MtLrlVDz25pFMxNnCmx2NG7DMkaugxlv+eeBf8hxd24aMjE1fyDCKPCiCA8Y\n", + "w6LWucrlg/JPRORuNAPhO/koZT3zgaN7v/IDeOajsK4JyhMw7IJTYxpF33HXpTLSMTt0wzzLuVvc\n", + "PCyMIQIqoHbeBlui4D0MnduhzMC5EuidgLGDkJ63l80CIHEYjq6F6fXQHNcg8FNA/3fmE+CcbTLr\n", + "iB/8wTcHN3dWQqjj6iUELOYiY4h8FtgK3GsFrV47xvBZEfzA8yK8xxheW6xz5zyA9XLkcfxAITjW\n", + "QVElTA1C+gxgg5qPwZZ6rT8TccHJIjj9hDHh53Pd55uFfB3zxUSk9B2w7k5YNwkJN3SugDOjMPEw\n", + "KiWfnzfsDbDwgYwX5OCLV0AiDNFTuc4wE3GshJW/CluSUB6C4RI4nITuLxljlkWKdjbHXYQS4GFU\n", + "X+FdxjB25U9YXAkR3g38E/BxY/hh9trN0wDWK3GzPZg0K8i5GSo2auDp2CFjzLwzaSxuvjFfCDJu\n", + "/DVQtV2rQPuPLcUKqjNZruOu8XS+XVBQA1M9EDpollHV5WyNuwjvQuus/AT4HWPmI/ZmcTVE2A08\n", + "BvxfY/hidtq0jJGskElDTi3lB0Muyccxv14yb+MFQHR2urDFpdxs4671bnACkaXoqVosbnTcRWgG\n", + "/h+6LfOQMfOtx2MxX0RoQ0tX/BD4Y2O4odpXljFyg2hly5p3QnETJNMQfAMmfnozpc3eDOTTmF8v\n", + "6tlw74aqt0JhEUxPg/8ZiLxmPbjm5mYZdxFxQ+m94NsNTgeEBmHoxzeLrke+cb3jLoIL+F3g94Ev\n", + "AJ+1CuAtHCJUAI8CY8Cv3Ujqb05Te292RKQS2j4Od8WgtRcSNji6HfbXiMiXjFUl1eISCvbA5vfC\n", + "bf1aKyjghlfekyl++mque2dxI5T/IuxeC9v7tehlXym88DER+XtjjJVCugiIcB/wd8BZYI8xs4uN\n", + "WmQbY/BnrvtngCMiPGQMP872eeZVI2N5U7IbtnFRkdWZhp390NoEtOSyZxb5hYg4oPJeuLMPfJmM\n", + "CF8M7uiHyvv09xY3IyJSB41rYW+PGiKgNat2xqDi9tz2bukjQpMI3wO+BPyBMbzbMkQWD2OIGcPv\n", + "ovXkPi/CkyLcJ5I9G2JZGCOZFOLrxNsM1XOkHdcC3Hf97V6ZG+vz0mo7W20uQjtF4PVcWhAN9Odi\n", + "t/5+UftzU7ezUG1eZ1vlUDPHNltNEJLX096cZPva5cF1u8FzUiXCnwOH4eEwsMEY/v3G2rzx/yOf\n", + "7pXF7IsxPInWt/g+8DmgW4SvivBJEe4WueN9mRTra2ZZGCPA3df/0elBGC968/ExATZff7tX5W6r\n", + "7ay3udDtTEM4AWHnpYfDTj3ObFn/he7Pzd7OQrV5PW1Ngn+ORdbvhenaG+3QDO7OYlvZbi+bbV0W\n", + "ESpFeI8I3wROA2XATvhkV5YyZe7Okzay1U422ph3O8aQMIaHgR3AA+j2863An8FdXwcmRTgkwndF\n", + "+D8ivHU+7S4XY+QGCLwGh10w5NWf08CJGugcBpZNGp7F1THGJGDsBXilESKZLZmIA/Y3gH+fsarq\n", + "3sz0QW83vNGg9ahA608d8kKi58oftbgSIvxl5sH1ogjdQAfwm8DLwDpj+HVjFk8t12J+GIMxhnZj\n", + "+Htj+Kgx3AGf+RzQBHwSTQtOAc3zac/aw74KxpghEcdXIfSzUN4EcWD8LIw9Bnwqx92zyDum98ER\n", + "O/TdCSV2mEyB/ykIWTWDbmIyyqnfghffDSc3gsfAeAhGvgn8Yq77d5PTDRwG+oB+oNsYrHT4mxRj\n", + "CACvZ77mTV6n9ua6DxYWFhYWFhbZ46bTGbGwsLCwsLBYHlgxIxYWFhYWFhY5xTJGliEisifXfbDI\n", + "LtaYWsyFNS+WB0thnJfFNo2IeIwxCyIXLCLubJT8FpFdwF7ABwSAV4wxB26wzbmMTQGeMMbcsEaK\n", + "iGwCksaYUzOO3WqM2X+jbc9oz4vO0zm0Xq6rvazMhesZ92yMcTbHNFvjJyLbgYAx5ryI3A+4gB9n\n", + "Q5042+M/o92srQk3sgZk675fiHs9m/f3jc6RbM6DXK0B+XT/5+O9v6SMERH5IPB7QBLV0v/LTBT8\n", + "s8aYexbonE8aYx64wTb+Fh3Ep4AgUArci06W37mBdiPAXJNrqzGm/HrbzbT9N0A1kACqgI8ZY0Zu\n", + "9FqLyMeA3wDCwFeAj6P51I8YY75wDe0s6Fy41nHP1hhna0yzNX4i8veAm0xRQGAKmAQajTG/Ot92\n", + "ZrSXlfGf0d6CrwnXuwZk877P9r2ezfv7euZINuZBPq0B+XT/5+u9j8kkCy+FL+AVNF1ZgF9H85zL\n", + "gGez0Pa+y3xNZKHtF67l+DW0ewjwzXH8qWxcjxnfbwGeB3bf6LVGb7QLFW970RtYgJdzMReyNe7Z\n", + "GuNsjWm2xm9m/4FjM75/Ppfjn+15kM25kO05kc15ke35cb1zJBvzIJ/WgHy6//P13l9yOiPGmGTm\n", + "278XkUNo6ePqLDRdiVqfl0h9i8hPs9D2QRF5GHgStS5LUKv50A22+06YU7HwbTfYLoBNRFzGmLgx\n", + "5qiIvBf4BioVfCPEjLr4IplChHEAEblmN3iW5kK2xj1bY5ytMc3W+NlnfP/fZ3x/vS7XrI3/f3Yk\n", + "e2tCtteAbN732b7Xs3l/X88cyco8yKM1IJ/u//y896/HgsnXL+AhoGXWsQbgH7LQ9tuZ2yLdmaW+\n", + "70Ct9z9B3ZPbc309r9LfW4CaWcccwAdvsN1fARyzjrmA/52LuZDNcc+nMc7W+KEL2Fzj9WAuxz/b\n", + "8yDbcyEf58RCzI/rnSPZmAf5tgbky1jn672/pGJGZiMi3zLG/NICtf1tY8wHF6Jti4tk6zpnay5Y\n", + "4764ZPt6Z3NNsObC4pGNa22tAfnNUk/trVvAtrNZHMvi8mTrOmdrLljjvrhk+3pnc02w5sLikY1r\n", + "ba0BecxSN0YsLCwsLCws8hzLGLGwsLCwsLDIKZYxYmFhYWFhYZFTlnoAa40xZvhma9viItm6zvnW\n", + "jsX8yPb1zmZ71lxYPLJxra01IL9Z0saIhYWFhYWFRf5jbdNYWFhYWFhY5BTLGLGwsLCwsLDIKZYx\n", + "YmFhYWFhYZFTLGMkjxCRt4nIKRE5KyJ/lOv+WCw8IvIVERkWkWO57ovF4iAiTSLyrIicEJHjIvLb\n", + "ue6TxcIjIh4ReVVEDovISRH5TK77lE9YAax5gojYgdPAfUA/8DpaK6A9px2zWFBE5E4gBHzdGLM5\n", + "1/2xWHhEpBaoNcYcFhEvcBB4j3WvL31EpNAYMy0iDuBF4PeNMS/mul/5gOUZyR/2AOeMMV3GmATw\n", + "HeBnc9wniwXGGLMPmMh1PywWD2PMkDHmcOb7ENAO1Oe2VxaLgTFmOvOtC616O57D7uQVljGSPzQA\n", + "vTN+7sscs7CwWKKISCuwHXg1tz2xWAxExCYih4Fh4FljzMlc9ylfsIyR/MHaL7OwWEZktmi+D/xO\n", + "xkNiscQxxqSNMduARuAuEbk7x13KGyxjJH/oB5pm/NyEekcsLCyWGCLiBB4BvmGMeTTX/bFYXIwx\n", + "QeA/gF257ku+YBkj+cMBYLWItIqIC3g/8MMc98nCwiLLiIgA/wScNMb8ba77Y7E4iEiliPgy3xcA\n", + "9wNv5LZX+YNljOQJxpgk8FvAE8BJ4LtWdP3SR0S+DbwMrBGRXhH5aK77ZLHg3A58CLhHRN7IfL0t\n", + "152yWHDqgGcyMSOvAv9ujHk6x33KG6zUXgsLCwsLC4ucYnlGLCwsLCwsLHKKZYxYWFhYWFhY5BTL\n", + "GLGwsLCwsLDIKZYxYmFhYWFhYZFTLGPEwsLCwsLCIqdYxoiFhYWFhYVFTrGMEQsLCwsLC4ucYhkj\n", + "FhYWFhYWFjnl/wPBByFp6Gp27QAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "X, y = sklearn.datasets.make_classification(\n", + " n_samples=10000, n_features=4, n_redundant=0, n_informative=2, \n", + " n_clusters_per_class=2, hypercube=False, random_state=0\n", + ")\n", + "\n", + "# Split into train and test\n", + "X, Xt, y, yt = sklearn.cross_validation.train_test_split(X, y)\n", + "\n", + "# Visualize sample of the data\n", + "ind = np.random.permutation(X.shape[0])[:1000]\n", + "df = pd.DataFrame(X[ind])\n", + "_ = pd.scatter_matrix(df, figsize=(9, 9), diagonal='kde', marker='o', s=40, alpha=.4, c=y[ind])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Learn and evaluate scikit-learn's logistic regression with stochastic gradient descent (SGD) training. Time and check the classifier's accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.783\n", + "Accuracy: 0.783\n", + "Accuracy: 0.783\n", + "Accuracy: 0.783\n", + "1 loops, best of 3: 508 ms per loop\n" + ] + } + ], + "source": [ + "%%timeit\n", + "# Train and test the scikit-learn SGD logistic regression.\n", + "clf = sklearn.linear_model.SGDClassifier(\n", + " loss='log', n_iter=1000, penalty='l2', alpha=1e-3, class_weight='auto')\n", + "\n", + "clf.fit(X, y)\n", + "yt_pred = clf.predict(Xt)\n", + "print('Accuracy: {:.3f}'.format(sklearn.metrics.accuracy_score(yt, yt_pred)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Save the dataset to HDF5 for loading in Caffe." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Write out the data to HDF5 files in a temp directory.\n", + "# This file is assumed to be caffe_root/examples/hdf5_classification.ipynb\n", + "dirname = os.path.abspath('./examples/hdf5_classification/data')\n", + "if not os.path.exists(dirname):\n", + " os.makedirs(dirname)\n", + "\n", + "train_filename = os.path.join(dirname, 'train.h5')\n", + "test_filename = os.path.join(dirname, 'test.h5')\n", + "\n", + "# HDF5DataLayer source should be a file containing a list of HDF5 filenames.\n", + "# To show this off, we'll list the same data file twice.\n", + "with h5py.File(train_filename, 'w') as f:\n", + " f['data'] = X\n", + " f['label'] = y.astype(np.float32)\n", + "with open(os.path.join(dirname, 'train.txt'), 'w') as f:\n", + " f.write(train_filename + '\\n')\n", + " f.write(train_filename + '\\n')\n", + " \n", + "# HDF5 is pretty efficient, but can be further compressed.\n", + "comp_kwargs = {'compression': 'gzip', 'compression_opts': 1}\n", + "with h5py.File(test_filename, 'w') as f:\n", + " f.create_dataset('data', data=Xt, **comp_kwargs)\n", + " f.create_dataset('label', data=yt.astype(np.float32), **comp_kwargs)\n", + "with open(os.path.join(dirname, 'test.txt'), 'w') as f:\n", + " f.write(test_filename + '\\n')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's define logistic regression in Caffe through Python net specification. This is a quick and natural way to define nets that sidesteps manually editing the protobuf model." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from caffe import layers as L\n", + "from caffe import params as P\n", + "\n", + "def logreg(hdf5, batch_size):\n", + " # logistic regression: data, matrix multiplication, and 2-class softmax loss\n", + " n = caffe.NetSpec()\n", + " n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=2)\n", + " n.ip1 = L.InnerProduct(n.data, num_output=2, weight_filler=dict(type='xavier'))\n", + " n.accuracy = L.Accuracy(n.ip1, n.label)\n", + " n.loss = L.SoftmaxWithLoss(n.ip1, n.label)\n", + " return n.to_proto()\n", + " \n", + "with open('examples/hdf5_classification/logreg_auto_train.prototxt', 'w') as f:\n", + " f.write(str(logreg('examples/hdf5_classification/data/train.txt', 10)))\n", + " \n", + "with open('examples/hdf5_classification/logreg_auto_test.prototxt', 'w') as f:\n", + " f.write(str(logreg('examples/hdf5_classification/data/test.txt', 10)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Time to learn and evaluate our Caffeinated logistic regression in Python." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.782\n", + "Accuracy: 0.782\n", + "Accuracy: 0.782\n", + "Accuracy: 0.782\n", + "1 loops, best of 3: 287 ms per loop\n" + ] + } + ], + "source": [ + "%%timeit\n", + "caffe.set_mode_cpu()\n", + "solver = caffe.get_solver('examples/hdf5_classification/solver.prototxt')\n", + "solver.solve()\n", + "\n", + "accuracy = 0\n", + "batch_size = solver.test_nets[0].blobs['data'].num\n", + "test_iters = int(len(Xt) / batch_size)\n", + "for i in range(test_iters):\n", + " solver.test_nets[0].forward()\n", + " accuracy += solver.test_nets[0].blobs['accuracy'].data\n", + "accuracy /= test_iters\n", + "\n", + "print(\"Accuracy: {:.3f}\".format(accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Do the same through the command line interface for detailed output on the model and solving." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I0318 00:58:32.322571 2013098752 caffe.cpp:117] Use CPU.\n", + "I0318 00:58:32.643163 2013098752 caffe.cpp:121] Starting Optimization\n", + "I0318 00:58:32.643229 2013098752 solver.cpp:32] Initializing solver from parameters: \n", + "train_net: \"examples/hdf5_classification/logreg_auto_train.prototxt\"\n", + "test_net: \"examples/hdf5_classification/logreg_auto_test.prototxt\"\n", + "test_iter: 250\n", + "test_interval: 1000\n", + "base_lr: 0.01\n", + "display: 1000\n", + "max_iter: 10000\n", + "lr_policy: \"step\"\n", + "gamma: 0.1\n", + "momentum: 0.9\n", + "weight_decay: 0.0005\n", + "stepsize: 5000\n", + "snapshot: 10000\n", + "snapshot_prefix: \"examples/hdf5_classification/data/train\"\n", + "solver_mode: CPU\n", + "I0318 00:58:32.643333 2013098752 solver.cpp:61] Creating training net from train_net file: examples/hdf5_classification/logreg_auto_train.prototxt\n", + "I0318 00:58:32.643465 2013098752 net.cpp:42] Initializing net from parameters: \n", + "state {\n", + " phase: TRAIN\n", + "}\n", + "layer {\n", + " name: \"data\"\n", + " type: \"HDF5Data\"\n", + " top: \"data\"\n", + " top: \"label\"\n", + " hdf5_data_param {\n", + " source: \"examples/hdf5_classification/data/train.txt\"\n", + " batch_size: 10\n", + " }\n", + "}\n", + "layer {\n", + " name: \"ip1\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"data\"\n", + " top: \"ip1\"\n", + " inner_product_param {\n", + " num_output: 2\n", + " weight_filler {\n", + " type: \"xavier\"\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"accuracy\"\n", + " type: \"Accuracy\"\n", + " bottom: \"ip1\"\n", + " bottom: \"label\"\n", + " top: \"accuracy\"\n", + "}\n", + "layer {\n", + " name: \"loss\"\n", + " type: \"SoftmaxWithLoss\"\n", + " bottom: \"ip1\"\n", + " bottom: \"label\"\n", + " top: \"loss\"\n", + "}\n", + "I0318 00:58:32.644197 2013098752 layer_factory.hpp:74] Creating layer data\n", + "I0318 00:58:32.644219 2013098752 net.cpp:84] Creating Layer data\n", + "I0318 00:58:32.644230 2013098752 net.cpp:338] data -> data\n", + "I0318 00:58:32.644256 2013098752 net.cpp:338] data -> label\n", + "I0318 00:58:32.644269 2013098752 net.cpp:113] Setting up data\n", + "I0318 00:58:32.644278 2013098752 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: examples/hdf5_classification/data/train.txt\n", + "I0318 00:58:32.644327 2013098752 hdf5_data_layer.cpp:80] Number of HDF5 files: 2\n", + "I0318 00:58:32.646458 2013098752 net.cpp:120] Top shape: 10 4 (40)\n", + "I0318 00:58:32.646502 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:32.646518 2013098752 layer_factory.hpp:74] Creating layer label_data_1_split\n", + "I0318 00:58:32.646538 2013098752 net.cpp:84] Creating Layer label_data_1_split\n", + "I0318 00:58:32.646546 2013098752 net.cpp:380] label_data_1_split <- label\n", + "I0318 00:58:32.646556 2013098752 net.cpp:338] label_data_1_split -> label_data_1_split_0\n", + "I0318 00:58:32.646569 2013098752 net.cpp:338] label_data_1_split -> label_data_1_split_1\n", + "I0318 00:58:32.646579 2013098752 net.cpp:113] Setting up label_data_1_split\n", + "I0318 00:58:32.646586 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:32.646595 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:32.646601 2013098752 layer_factory.hpp:74] Creating layer ip1\n", + "I0318 00:58:32.646615 2013098752 net.cpp:84] Creating Layer ip1\n", + "I0318 00:58:32.646622 2013098752 net.cpp:380] ip1 <- data\n", + "I0318 00:58:32.646664 2013098752 net.cpp:338] ip1 -> ip1\n", + "I0318 00:58:32.646689 2013098752 net.cpp:113] Setting up ip1\n", + "I0318 00:58:32.652330 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:32.652371 2013098752 layer_factory.hpp:74] Creating layer ip1_ip1_0_split\n", + "I0318 00:58:32.652393 2013098752 net.cpp:84] Creating Layer ip1_ip1_0_split\n", + "I0318 00:58:32.652407 2013098752 net.cpp:380] ip1_ip1_0_split <- ip1\n", + "I0318 00:58:32.652421 2013098752 net.cpp:338] ip1_ip1_0_split -> ip1_ip1_0_split_0\n", + "I0318 00:58:32.652467 2013098752 net.cpp:338] ip1_ip1_0_split -> ip1_ip1_0_split_1\n", + "I0318 00:58:32.652480 2013098752 net.cpp:113] Setting up ip1_ip1_0_split\n", + "I0318 00:58:32.652489 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:32.652498 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:32.652505 2013098752 layer_factory.hpp:74] Creating layer accuracy\n", + "I0318 00:58:32.652521 2013098752 net.cpp:84] Creating Layer accuracy\n", + "I0318 00:58:32.652534 2013098752 net.cpp:380] accuracy <- ip1_ip1_0_split_0\n", + "I0318 00:58:32.652545 2013098752 net.cpp:380] accuracy <- label_data_1_split_0\n", + "I0318 00:58:32.652562 2013098752 net.cpp:338] accuracy -> accuracy\n", + "I0318 00:58:32.652577 2013098752 net.cpp:113] Setting up accuracy\n", + "I0318 00:58:32.652590 2013098752 net.cpp:120] Top shape: (1)\n", + "I0318 00:58:32.652642 2013098752 layer_factory.hpp:74] Creating layer loss\n", + "I0318 00:58:32.652655 2013098752 net.cpp:84] Creating Layer loss\n", + "I0318 00:58:32.652663 2013098752 net.cpp:380] loss <- ip1_ip1_0_split_1\n", + "I0318 00:58:32.652672 2013098752 net.cpp:380] loss <- label_data_1_split_1\n", + "I0318 00:58:32.652679 2013098752 net.cpp:338] loss -> loss\n", + "I0318 00:58:32.652689 2013098752 net.cpp:113] Setting up loss\n", + "I0318 00:58:32.652701 2013098752 layer_factory.hpp:74] Creating layer loss\n", + "I0318 00:58:32.652716 2013098752 net.cpp:120] Top shape: (1)\n", + "I0318 00:58:32.652724 2013098752 net.cpp:122] with loss weight 1\n", + "I0318 00:58:32.652740 2013098752 net.cpp:167] loss needs backward computation.\n", + "I0318 00:58:32.652746 2013098752 net.cpp:169] accuracy does not need backward computation.\n", + "I0318 00:58:32.652753 2013098752 net.cpp:167] ip1_ip1_0_split needs backward computation.\n", + "I0318 00:58:32.652760 2013098752 net.cpp:167] ip1 needs backward computation.\n", + "I0318 00:58:32.652786 2013098752 net.cpp:169] label_data_1_split does not need backward computation.\n", + "I0318 00:58:32.652801 2013098752 net.cpp:169] data does not need backward computation.\n", + "I0318 00:58:32.652808 2013098752 net.cpp:205] This network produces output accuracy\n", + "I0318 00:58:32.652815 2013098752 net.cpp:205] This network produces output loss\n", + "I0318 00:58:32.652825 2013098752 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", + "I0318 00:58:32.652833 2013098752 net.cpp:217] Network initialization done.\n", + "I0318 00:58:32.652839 2013098752 net.cpp:218] Memory required for data: 528\n", + "I0318 00:58:32.652964 2013098752 solver.cpp:154] Creating test net (#0) specified by test_net file: examples/hdf5_classification/logreg_auto_test.prototxt\n", + "I0318 00:58:32.652986 2013098752 net.cpp:42] Initializing net from parameters: \n", + "state {\n", + " phase: TEST\n", + "}\n", + "layer {\n", + " name: \"data\"\n", + " type: \"HDF5Data\"\n", + " top: \"data\"\n", + " top: \"label\"\n", + " hdf5_data_param {\n", + " source: \"examples/hdf5_classification/data/test.txt\"\n", + " batch_size: 10\n", + " }\n", + "}\n", + "layer {\n", + " name: \"ip1\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"data\"\n", + " top: \"ip1\"\n", + " inner_product_param {\n", + " num_output: 2\n", + " weight_filler {\n", + " type: \"xavier\"\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"accuracy\"\n", + " type: \"Accuracy\"\n", + " bottom: \"ip1\"\n", + " bottom: \"label\"\n", + " top: \"accuracy\"\n", + "}\n", + "layer {\n", + " name: \"loss\"\n", + " type: \"SoftmaxWithLoss\"\n", + " bottom: \"ip1\"\n", + " bottom: \"label\"\n", + " top: \"loss\"\n", + "}\n", + "I0318 00:58:32.653069 2013098752 layer_factory.hpp:74] Creating layer data\n", + "I0318 00:58:32.653080 2013098752 net.cpp:84] Creating Layer data\n", + "I0318 00:58:32.653090 2013098752 net.cpp:338] data -> data\n", + "I0318 00:58:32.653128 2013098752 net.cpp:338] data -> label\n", + "I0318 00:58:32.653146 2013098752 net.cpp:113] Setting up data\n", + "I0318 00:58:32.653154 2013098752 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: examples/hdf5_classification/data/test.txt\n", + "I0318 00:58:32.653192 2013098752 hdf5_data_layer.cpp:80] Number of HDF5 files: 1\n", + "I0318 00:58:32.654850 2013098752 net.cpp:120] Top shape: 10 4 (40)\n", + "I0318 00:58:32.654897 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:32.654914 2013098752 layer_factory.hpp:74] Creating layer label_data_1_split\n", + "I0318 00:58:32.654933 2013098752 net.cpp:84] Creating Layer label_data_1_split\n", + "I0318 00:58:32.654943 2013098752 net.cpp:380] label_data_1_split <- label\n", + "I0318 00:58:32.654953 2013098752 net.cpp:338] label_data_1_split -> label_data_1_split_0\n", + "I0318 00:58:32.654966 2013098752 net.cpp:338] label_data_1_split -> label_data_1_split_1\n", + "I0318 00:58:32.654976 2013098752 net.cpp:113] Setting up label_data_1_split\n", + "I0318 00:58:32.654985 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:32.654992 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:32.655000 2013098752 layer_factory.hpp:74] Creating layer ip1\n", + "I0318 00:58:32.655010 2013098752 net.cpp:84] Creating Layer ip1\n", + "I0318 00:58:32.655017 2013098752 net.cpp:380] ip1 <- data\n", + "I0318 00:58:32.655030 2013098752 net.cpp:338] ip1 -> ip1\n", + "I0318 00:58:32.655041 2013098752 net.cpp:113] Setting up ip1\n", + "I0318 00:58:32.655061 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:32.655072 2013098752 layer_factory.hpp:74] Creating layer ip1_ip1_0_split\n", + "I0318 00:58:32.655148 2013098752 net.cpp:84] Creating Layer ip1_ip1_0_split\n", + "I0318 00:58:32.655159 2013098752 net.cpp:380] ip1_ip1_0_split <- ip1\n", + "I0318 00:58:32.655170 2013098752 net.cpp:338] ip1_ip1_0_split -> ip1_ip1_0_split_0\n", + "I0318 00:58:32.655180 2013098752 net.cpp:338] ip1_ip1_0_split -> ip1_ip1_0_split_1\n", + "I0318 00:58:32.655190 2013098752 net.cpp:113] Setting up ip1_ip1_0_split\n", + "I0318 00:58:32.655199 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:32.655206 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:32.655213 2013098752 layer_factory.hpp:74] Creating layer accuracy\n", + "I0318 00:58:32.655223 2013098752 net.cpp:84] Creating Layer accuracy\n", + "I0318 00:58:32.655230 2013098752 net.cpp:380] accuracy <- ip1_ip1_0_split_0\n", + "I0318 00:58:32.655237 2013098752 net.cpp:380] accuracy <- label_data_1_split_0\n", + "I0318 00:58:32.655251 2013098752 net.cpp:338] accuracy -> accuracy\n", + "I0318 00:58:32.655259 2013098752 net.cpp:113] Setting up accuracy\n", + "I0318 00:58:32.655267 2013098752 net.cpp:120] Top shape: (1)\n", + "I0318 00:58:32.655340 2013098752 layer_factory.hpp:74] Creating layer loss\n", + "I0318 00:58:32.655354 2013098752 net.cpp:84] Creating Layer loss\n", + "I0318 00:58:32.655361 2013098752 net.cpp:380] loss <- ip1_ip1_0_split_1\n", + "I0318 00:58:32.655369 2013098752 net.cpp:380] loss <- label_data_1_split_1\n", + "I0318 00:58:32.655378 2013098752 net.cpp:338] loss -> loss\n", + "I0318 00:58:32.655388 2013098752 net.cpp:113] Setting up loss\n", + "I0318 00:58:32.655397 2013098752 layer_factory.hpp:74] Creating layer loss\n", + "I0318 00:58:32.655414 2013098752 net.cpp:120] Top shape: (1)\n", + "I0318 00:58:32.655422 2013098752 net.cpp:122] with loss weight 1\n", + "I0318 00:58:32.655438 2013098752 net.cpp:167] loss needs backward computation.\n", + "I0318 00:58:32.655446 2013098752 net.cpp:169] accuracy does not need backward computation.\n", + "I0318 00:58:32.655455 2013098752 net.cpp:167] ip1_ip1_0_split needs backward computation.\n", + "I0318 00:58:32.655462 2013098752 net.cpp:167] ip1 needs backward computation.\n", + "I0318 00:58:32.655469 2013098752 net.cpp:169] label_data_1_split does not need backward computation.\n", + "I0318 00:58:32.655477 2013098752 net.cpp:169] data does not need backward computation.\n", + "I0318 00:58:32.655483 2013098752 net.cpp:205] This network produces output accuracy\n", + "I0318 00:58:32.655489 2013098752 net.cpp:205] This network produces output loss\n", + "I0318 00:58:32.655503 2013098752 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", + "I0318 00:58:32.655511 2013098752 net.cpp:217] Network initialization done.\n", + "I0318 00:58:32.655517 2013098752 net.cpp:218] Memory required for data: 528\n", + "I0318 00:58:32.655547 2013098752 solver.cpp:42] Solver scaffolding done.\n", + "I0318 00:58:32.655567 2013098752 solver.cpp:222] Solving \n", + "I0318 00:58:32.655575 2013098752 solver.cpp:223] Learning Rate Policy: step\n", + "I0318 00:58:32.655583 2013098752 solver.cpp:266] Iteration 0, Testing net (#0)\n", + "I0318 00:58:32.683643 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.3736\n", + "I0318 00:58:32.683686 2013098752 solver.cpp:315] Test net output #1: loss = 1.00555 (* 1 = 1.00555 loss)\n", + "I0318 00:58:32.683846 2013098752 solver.cpp:189] Iteration 0, loss = 0.869394\n", + "I0318 00:58:32.683861 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.3\n", + "I0318 00:58:32.683871 2013098752 solver.cpp:204] Train net output #1: loss = 0.869394 (* 1 = 0.869394 loss)\n", + "I0318 00:58:32.683883 2013098752 solver.cpp:464] Iteration 0, lr = 0.01\n", + "I0318 00:58:32.698721 2013098752 solver.cpp:266] Iteration 1000, Testing net (#0)\n", + "I0318 00:58:32.701917 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.7848\n", + "I0318 00:58:32.701961 2013098752 solver.cpp:315] Test net output #1: loss = 0.590972 (* 1 = 0.590972 loss)\n", + "I0318 00:58:32.702014 2013098752 solver.cpp:189] Iteration 1000, loss = 0.54742\n", + "I0318 00:58:32.702029 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.7\n", + "I0318 00:58:32.702041 2013098752 solver.cpp:204] Train net output #1: loss = 0.54742 (* 1 = 0.54742 loss)\n", + "I0318 00:58:32.702051 2013098752 solver.cpp:464] Iteration 1000, lr = 0.01\n", + "I0318 00:58:32.718360 2013098752 solver.cpp:266] Iteration 2000, Testing net (#0)\n", + "I0318 00:58:32.721529 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.7696\n", + "I0318 00:58:32.721562 2013098752 solver.cpp:315] Test net output #1: loss = 0.593946 (* 1 = 0.593946 loss)\n", + "I0318 00:58:32.721593 2013098752 solver.cpp:189] Iteration 2000, loss = 0.729569\n", + "I0318 00:58:32.721603 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.5\n", + "I0318 00:58:32.721613 2013098752 solver.cpp:204] Train net output #1: loss = 0.729569 (* 1 = 0.729569 loss)\n", + "I0318 00:58:32.721622 2013098752 solver.cpp:464] Iteration 2000, lr = 0.01\n", + "I0318 00:58:32.740182 2013098752 solver.cpp:266] Iteration 3000, Testing net (#0)\n", + "I0318 00:58:32.743494 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.77\n", + "I0318 00:58:32.743544 2013098752 solver.cpp:315] Test net output #1: loss = 0.591229 (* 1 = 0.591229 loss)\n", + "I0318 00:58:32.744209 2013098752 solver.cpp:189] Iteration 3000, loss = 0.406097\n", + "I0318 00:58:32.744231 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.8\n", + "I0318 00:58:32.744249 2013098752 solver.cpp:204] Train net output #1: loss = 0.406096 (* 1 = 0.406096 loss)\n", + "I0318 00:58:32.744266 2013098752 solver.cpp:464] Iteration 3000, lr = 0.01\n", + "I0318 00:58:32.764135 2013098752 solver.cpp:266] Iteration 4000, Testing net (#0)\n", + "I0318 00:58:32.769110 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.7848\n", + "I0318 00:58:32.769170 2013098752 solver.cpp:315] Test net output #1: loss = 0.590972 (* 1 = 0.590972 loss)\n", + "I0318 00:58:32.769223 2013098752 solver.cpp:189] Iteration 4000, loss = 0.54742\n", + "I0318 00:58:32.769242 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.7\n", + "I0318 00:58:32.769255 2013098752 solver.cpp:204] Train net output #1: loss = 0.54742 (* 1 = 0.54742 loss)\n", + "I0318 00:58:32.769265 2013098752 solver.cpp:464] Iteration 4000, lr = 0.01\n", + "I0318 00:58:32.785846 2013098752 solver.cpp:266] Iteration 5000, Testing net (#0)\n", + "I0318 00:58:32.788722 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.7696\n", + "I0318 00:58:32.788751 2013098752 solver.cpp:315] Test net output #1: loss = 0.593946 (* 1 = 0.593946 loss)\n", + "I0318 00:58:32.788811 2013098752 solver.cpp:189] Iteration 5000, loss = 0.72957\n", + "I0318 00:58:32.788833 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.5\n", + "I0318 00:58:32.788846 2013098752 solver.cpp:204] Train net output #1: loss = 0.729569 (* 1 = 0.729569 loss)\n", + "I0318 00:58:32.788856 2013098752 solver.cpp:464] Iteration 5000, lr = 0.001\n", + "I0318 00:58:32.804762 2013098752 solver.cpp:266] Iteration 6000, Testing net (#0)\n", + "I0318 00:58:32.808061 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.7856\n", + "I0318 00:58:32.808112 2013098752 solver.cpp:315] Test net output #1: loss = 0.59028 (* 1 = 0.59028 loss)\n", + "I0318 00:58:32.808732 2013098752 solver.cpp:189] Iteration 6000, loss = 0.415444\n", + "I0318 00:58:32.808753 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.9\n", + "I0318 00:58:32.808773 2013098752 solver.cpp:204] Train net output #1: loss = 0.415444 (* 1 = 0.415444 loss)\n", + "I0318 00:58:32.808786 2013098752 solver.cpp:464] Iteration 6000, lr = 0.001\n", + "I0318 00:58:32.827118 2013098752 solver.cpp:266] Iteration 7000, Testing net (#0)\n", + "I0318 00:58:32.831614 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.7848\n", + "I0318 00:58:32.831657 2013098752 solver.cpp:315] Test net output #1: loss = 0.589454 (* 1 = 0.589454 loss)\n", + "I0318 00:58:32.831707 2013098752 solver.cpp:189] Iteration 7000, loss = 0.538038\n", + "I0318 00:58:32.831728 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.8\n", + "I0318 00:58:32.831745 2013098752 solver.cpp:204] Train net output #1: loss = 0.538037 (* 1 = 0.538037 loss)\n", + "I0318 00:58:32.831759 2013098752 solver.cpp:464] Iteration 7000, lr = 0.001\n", + "I0318 00:58:32.849634 2013098752 solver.cpp:266] Iteration 8000, Testing net (#0)\n", + "I0318 00:58:32.852712 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.7796\n", + "I0318 00:58:32.852748 2013098752 solver.cpp:315] Test net output #1: loss = 0.589365 (* 1 = 0.589365 loss)\n", + "I0318 00:58:32.852792 2013098752 solver.cpp:189] Iteration 8000, loss = 0.684219\n", + "I0318 00:58:32.852840 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.5\n", + "I0318 00:58:32.852852 2013098752 solver.cpp:204] Train net output #1: loss = 0.684219 (* 1 = 0.684219 loss)\n", + "I0318 00:58:32.852861 2013098752 solver.cpp:464] Iteration 8000, lr = 0.001\n", + "I0318 00:58:32.868440 2013098752 solver.cpp:266] Iteration 9000, Testing net (#0)\n", + "I0318 00:58:32.871438 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.7816\n", + "I0318 00:58:32.871461 2013098752 solver.cpp:315] Test net output #1: loss = 0.589656 (* 1 = 0.589656 loss)\n", + "I0318 00:58:32.872109 2013098752 solver.cpp:189] Iteration 9000, loss = 0.421879\n", + "I0318 00:58:32.872131 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.9\n", + "I0318 00:58:32.872143 2013098752 solver.cpp:204] Train net output #1: loss = 0.421879 (* 1 = 0.421879 loss)\n", + "I0318 00:58:32.872153 2013098752 solver.cpp:464] Iteration 9000, lr = 0.001\n", + "I0318 00:58:32.889981 2013098752 solver.cpp:334] Snapshotting to examples/hdf5_classification/data/train_iter_10000.caffemodel\n", + "I0318 00:58:32.890224 2013098752 solver.cpp:342] Snapshotting solver state to examples/hdf5_classification/data/train_iter_10000.solverstate\n", + "I0318 00:58:32.890362 2013098752 solver.cpp:248] Iteration 10000, loss = 0.538933\n", + "I0318 00:58:32.890380 2013098752 solver.cpp:266] Iteration 10000, Testing net (#0)\n", + "I0318 00:58:32.893728 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.782\n", + "I0318 00:58:32.893757 2013098752 solver.cpp:315] Test net output #1: loss = 0.589366 (* 1 = 0.589366 loss)\n", + "I0318 00:58:32.893775 2013098752 solver.cpp:253] Optimization Done.\n", + "I0318 00:58:32.893786 2013098752 caffe.cpp:134] Optimization Done.\n" + ] + } + ], + "source": [ + "!./build/tools/caffe train -solver examples/hdf5_classification/solver.prototxt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you look at output or the `logreg_auto_train.prototxt`, you'll see that the model is simple logistic regression.\n", + "We can make it a little more advanced by introducing a non-linearity between weights that take the input and weights that give the output -- now we have a two-layer network.\n", + "That network is given in `nonlinear_auto_train.prototxt`, and that's the only change made in `nonlinear_solver.prototxt` which we will now use.\n", + "\n", + "The final accuracy of the new network should be higher than logistic regression!" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from caffe import layers as L\n", + "from caffe import params as P\n", + "\n", + "def nonlinear_net(hdf5, batch_size):\n", + " # one small nonlinearity, one leap for model kind\n", + " n = caffe.NetSpec()\n", + " n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=2)\n", + " # define a hidden layer of dimension 40\n", + " n.ip1 = L.InnerProduct(n.data, num_output=40, weight_filler=dict(type='xavier'))\n", + " # transform the output through the ReLU (rectified linear) non-linearity\n", + " n.relu1 = L.ReLU(n.ip1, in_place=True)\n", + " # score the (now non-linear) features\n", + " n.ip2 = L.InnerProduct(n.ip1, num_output=2, weight_filler=dict(type='xavier'))\n", + " # same accuracy and loss as before\n", + " n.accuracy = L.Accuracy(n.ip2, n.label)\n", + " n.loss = L.SoftmaxWithLoss(n.ip2, n.label)\n", + " return n.to_proto()\n", + " \n", + "with open('examples/hdf5_classification/nonlinear_auto_train.prototxt', 'w') as f:\n", + " f.write(str(nonlinear_net('examples/hdf5_classification/data/train.txt', 10)))\n", + " \n", + "with open('examples/hdf5_classification/nonlinear_auto_test.prototxt', 'w') as f:\n", + " f.write(str(nonlinear_net('examples/hdf5_classification/data/test.txt', 10)))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.832\n", + "Accuracy: 0.832\n", + "Accuracy: 0.832\n", + "Accuracy: 0.831\n", + "1 loops, best of 3: 386 ms per loop\n" + ] + } + ], + "source": [ + "%%timeit\n", + "caffe.set_mode_cpu()\n", + "solver = caffe.get_solver('examples/hdf5_classification/nonlinear_solver.prototxt')\n", + "solver.solve()\n", + "\n", + "accuracy = 0\n", + "batch_size = solver.test_nets[0].blobs['data'].num\n", + "test_iters = int(len(Xt) / batch_size)\n", + "for i in range(test_iters):\n", + " solver.test_nets[0].forward()\n", + " accuracy += solver.test_nets[0].blobs['accuracy'].data\n", + "accuracy /= test_iters\n", + "\n", + "print(\"Accuracy: {:.3f}\".format(accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Do the same through the command line interface for detailed output on the model and solving." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I0318 00:58:43.336922 2013098752 caffe.cpp:117] Use CPU.\n", + "I0318 00:58:43.654698 2013098752 caffe.cpp:121] Starting Optimization\n", + "I0318 00:58:43.654747 2013098752 solver.cpp:32] Initializing solver from parameters: \n", + "train_net: \"examples/hdf5_classification/nonlinear_auto_train.prototxt\"\n", + "test_net: \"examples/hdf5_classification/nonlinear_auto_test.prototxt\"\n", + "test_iter: 250\n", + "test_interval: 1000\n", + "base_lr: 0.01\n", + "display: 1000\n", + "max_iter: 10000\n", + "lr_policy: \"step\"\n", + "gamma: 0.1\n", + "momentum: 0.9\n", + "weight_decay: 0.0005\n", + "stepsize: 5000\n", + "snapshot: 10000\n", + "snapshot_prefix: \"examples/hdf5_classification/data/train\"\n", + "solver_mode: CPU\n", + "I0318 00:58:43.654855 2013098752 solver.cpp:61] Creating training net from train_net file: examples/hdf5_classification/nonlinear_auto_train.prototxt\n", + "I0318 00:58:43.655004 2013098752 net.cpp:42] Initializing net from parameters: \n", + "state {\n", + " phase: TRAIN\n", + "}\n", + "layer {\n", + " name: \"data\"\n", + " type: \"HDF5Data\"\n", + " top: \"data\"\n", + " top: \"label\"\n", + " hdf5_data_param {\n", + " source: \"examples/hdf5_classification/data/train.txt\"\n", + " batch_size: 10\n", + " }\n", + "}\n", + "layer {\n", + " name: \"ip1\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"data\"\n", + " top: \"ip1\"\n", + " inner_product_param {\n", + " num_output: 40\n", + " weight_filler {\n", + " type: \"xavier\"\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"relu1\"\n", + " type: \"ReLU\"\n", + " bottom: \"ip1\"\n", + " top: \"ip1\"\n", + "}\n", + "layer {\n", + " name: \"ip2\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"ip1\"\n", + " top: \"ip2\"\n", + " inner_product_param {\n", + " num_output: 2\n", + " weight_filler {\n", + " type: \"xavier\"\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"accuracy\"\n", + " type: \"Accuracy\"\n", + " bottom: \"ip2\"\n", + " bottom: \"label\"\n", + " top: \"accuracy\"\n", + "}\n", + "layer {\n", + " name: \"loss\"\n", + " type: \"SoftmaxWithLoss\"\n", + " bottom: \"ip2\"\n", + " bottom: \"label\"\n", + " top: \"loss\"\n", + "}\n", + "I0318 00:58:43.655120 2013098752 layer_factory.hpp:74] Creating layer data\n", + "I0318 00:58:43.655139 2013098752 net.cpp:84] Creating Layer data\n", + "I0318 00:58:43.655264 2013098752 net.cpp:338] data -> data\n", + "I0318 00:58:43.655297 2013098752 net.cpp:338] data -> label\n", + "I0318 00:58:43.655310 2013098752 net.cpp:113] Setting up data\n", + "I0318 00:58:43.655318 2013098752 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: examples/hdf5_classification/data/train.txt\n", + "I0318 00:58:43.655365 2013098752 hdf5_data_layer.cpp:80] Number of HDF5 files: 2\n", + "I0318 00:58:43.657317 2013098752 net.cpp:120] Top shape: 10 4 (40)\n", + "I0318 00:58:43.657342 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:43.657356 2013098752 layer_factory.hpp:74] Creating layer label_data_1_split\n", + "I0318 00:58:43.657373 2013098752 net.cpp:84] Creating Layer label_data_1_split\n", + "I0318 00:58:43.657384 2013098752 net.cpp:380] label_data_1_split <- label\n", + "I0318 00:58:43.657395 2013098752 net.cpp:338] label_data_1_split -> label_data_1_split_0\n", + "I0318 00:58:43.657407 2013098752 net.cpp:338] label_data_1_split -> label_data_1_split_1\n", + "I0318 00:58:43.657418 2013098752 net.cpp:113] Setting up label_data_1_split\n", + "I0318 00:58:43.657426 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:43.657433 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:43.657441 2013098752 layer_factory.hpp:74] Creating layer ip1\n", + "I0318 00:58:43.657451 2013098752 net.cpp:84] Creating Layer ip1\n", + "I0318 00:58:43.657459 2013098752 net.cpp:380] ip1 <- data\n", + "I0318 00:58:43.657467 2013098752 net.cpp:338] ip1 -> ip1\n", + "I0318 00:58:43.657479 2013098752 net.cpp:113] Setting up ip1\n", + "I0318 00:58:43.662454 2013098752 net.cpp:120] Top shape: 10 40 (400)\n", + "I0318 00:58:43.662477 2013098752 layer_factory.hpp:74] Creating layer relu1\n", + "I0318 00:58:43.662497 2013098752 net.cpp:84] Creating Layer relu1\n", + "I0318 00:58:43.662508 2013098752 net.cpp:380] relu1 <- ip1\n", + "I0318 00:58:43.662520 2013098752 net.cpp:327] relu1 -> ip1 (in-place)\n", + "I0318 00:58:43.662530 2013098752 net.cpp:113] Setting up relu1\n", + "I0318 00:58:43.662539 2013098752 net.cpp:120] Top shape: 10 40 (400)\n", + "I0318 00:58:43.662546 2013098752 layer_factory.hpp:74] Creating layer ip2\n", + "I0318 00:58:43.662555 2013098752 net.cpp:84] Creating Layer ip2\n", + "I0318 00:58:43.662562 2013098752 net.cpp:380] ip2 <- ip1\n", + "I0318 00:58:43.662571 2013098752 net.cpp:338] ip2 -> ip2\n", + "I0318 00:58:43.662580 2013098752 net.cpp:113] Setting up ip2\n", + "I0318 00:58:43.662595 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:43.662606 2013098752 layer_factory.hpp:74] Creating layer ip2_ip2_0_split\n", + "I0318 00:58:43.662654 2013098752 net.cpp:84] Creating Layer ip2_ip2_0_split\n", + "I0318 00:58:43.662665 2013098752 net.cpp:380] ip2_ip2_0_split <- ip2\n", + "I0318 00:58:43.662678 2013098752 net.cpp:338] ip2_ip2_0_split -> ip2_ip2_0_split_0\n", + "I0318 00:58:43.662689 2013098752 net.cpp:338] ip2_ip2_0_split -> ip2_ip2_0_split_1\n", + "I0318 00:58:43.662698 2013098752 net.cpp:113] Setting up ip2_ip2_0_split\n", + "I0318 00:58:43.662706 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:43.662714 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:43.662722 2013098752 layer_factory.hpp:74] Creating layer accuracy\n", + "I0318 00:58:43.662734 2013098752 net.cpp:84] Creating Layer accuracy\n", + "I0318 00:58:43.662740 2013098752 net.cpp:380] accuracy <- ip2_ip2_0_split_0\n", + "I0318 00:58:43.662749 2013098752 net.cpp:380] accuracy <- label_data_1_split_0\n", + "I0318 00:58:43.662756 2013098752 net.cpp:338] accuracy -> accuracy\n", + "I0318 00:58:43.662766 2013098752 net.cpp:113] Setting up accuracy\n", + "I0318 00:58:43.662818 2013098752 net.cpp:120] Top shape: (1)\n", + "I0318 00:58:43.662827 2013098752 layer_factory.hpp:74] Creating layer loss\n", + "I0318 00:58:43.662839 2013098752 net.cpp:84] Creating Layer loss\n", + "I0318 00:58:43.662847 2013098752 net.cpp:380] loss <- ip2_ip2_0_split_1\n", + "I0318 00:58:43.662854 2013098752 net.cpp:380] loss <- label_data_1_split_1\n", + "I0318 00:58:43.662863 2013098752 net.cpp:338] loss -> loss\n", + "I0318 00:58:43.662873 2013098752 net.cpp:113] Setting up loss\n", + "I0318 00:58:43.662883 2013098752 layer_factory.hpp:74] Creating layer loss\n", + "I0318 00:58:43.662901 2013098752 net.cpp:120] Top shape: (1)\n", + "I0318 00:58:43.662909 2013098752 net.cpp:122] with loss weight 1\n", + "I0318 00:58:43.662922 2013098752 net.cpp:167] loss needs backward computation.\n", + "I0318 00:58:43.662930 2013098752 net.cpp:169] accuracy does not need backward computation.\n", + "I0318 00:58:43.662936 2013098752 net.cpp:167] ip2_ip2_0_split needs backward computation.\n", + "I0318 00:58:43.662942 2013098752 net.cpp:167] ip2 needs backward computation.\n", + "I0318 00:58:43.662976 2013098752 net.cpp:167] relu1 needs backward computation.\n", + "I0318 00:58:43.662988 2013098752 net.cpp:167] ip1 needs backward computation.\n", + "I0318 00:58:43.662997 2013098752 net.cpp:169] label_data_1_split does not need backward computation.\n", + "I0318 00:58:43.663003 2013098752 net.cpp:169] data does not need backward computation.\n", + "I0318 00:58:43.663009 2013098752 net.cpp:205] This network produces output accuracy\n", + "I0318 00:58:43.663017 2013098752 net.cpp:205] This network produces output loss\n", + "I0318 00:58:43.663028 2013098752 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", + "I0318 00:58:43.663035 2013098752 net.cpp:217] Network initialization done.\n", + "I0318 00:58:43.663041 2013098752 net.cpp:218] Memory required for data: 3728\n", + "I0318 00:58:43.663158 2013098752 solver.cpp:154] Creating test net (#0) specified by test_net file: examples/hdf5_classification/nonlinear_auto_test.prototxt\n", + "I0318 00:58:43.663179 2013098752 net.cpp:42] Initializing net from parameters: \n", + "state {\n", + " phase: TEST\n", + "}\n", + "layer {\n", + " name: \"data\"\n", + " type: \"HDF5Data\"\n", + " top: \"data\"\n", + " top: \"label\"\n", + " hdf5_data_param {\n", + " source: \"examples/hdf5_classification/data/test.txt\"\n", + " batch_size: 10\n", + " }\n", + "}\n", + "layer {\n", + " name: \"ip1\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"data\"\n", + " top: \"ip1\"\n", + " inner_product_param {\n", + " num_output: 40\n", + " weight_filler {\n", + " type: \"xavier\"\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"relu1\"\n", + " type: \"ReLU\"\n", + " bottom: \"ip1\"\n", + " top: \"ip1\"\n", + "}\n", + "layer {\n", + " name: \"ip2\"\n", + " type: \"InnerProduct\"\n", + " bottom: \"ip1\"\n", + " top: \"ip2\"\n", + " inner_product_param {\n", + " num_output: 2\n", + " weight_filler {\n", + " type: \"xavier\"\n", + " }\n", + " }\n", + "}\n", + "layer {\n", + " name: \"accuracy\"\n", + " type: \"Accuracy\"\n", + " bottom: \"ip2\"\n", + " bottom: \"label\"\n", + " top: \"accuracy\"\n", + "}\n", + "layer {\n", + " name: \"loss\"\n", + " type: \"SoftmaxWithLoss\"\n", + " bottom: \"ip2\"\n", + " bottom: \"label\"\n", + " top: \"loss\"\n", + "}\n", + "I0318 00:58:43.663349 2013098752 layer_factory.hpp:74] Creating layer data\n", + "I0318 00:58:43.663365 2013098752 net.cpp:84] Creating Layer data\n", + "I0318 00:58:43.663373 2013098752 net.cpp:338] data -> data\n", + "I0318 00:58:43.663385 2013098752 net.cpp:338] data -> label\n", + "I0318 00:58:43.663396 2013098752 net.cpp:113] Setting up data\n", + "I0318 00:58:43.663422 2013098752 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: examples/hdf5_classification/data/test.txt\n", + "I0318 00:58:43.663457 2013098752 hdf5_data_layer.cpp:80] Number of HDF5 files: 1\n", + "I0318 00:58:43.664719 2013098752 net.cpp:120] Top shape: 10 4 (40)\n", + "I0318 00:58:43.664739 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:43.664754 2013098752 layer_factory.hpp:74] Creating layer label_data_1_split\n", + "I0318 00:58:43.664772 2013098752 net.cpp:84] Creating Layer label_data_1_split\n", + "I0318 00:58:43.664783 2013098752 net.cpp:380] label_data_1_split <- label\n", + "I0318 00:58:43.664791 2013098752 net.cpp:338] label_data_1_split -> label_data_1_split_0\n", + "I0318 00:58:43.664803 2013098752 net.cpp:338] label_data_1_split -> label_data_1_split_1\n", + "I0318 00:58:43.664813 2013098752 net.cpp:113] Setting up label_data_1_split\n", + "I0318 00:58:43.664822 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:43.664829 2013098752 net.cpp:120] Top shape: 10 (10)\n", + "I0318 00:58:43.664837 2013098752 layer_factory.hpp:74] Creating layer ip1\n", + "I0318 00:58:43.664846 2013098752 net.cpp:84] Creating Layer ip1\n", + "I0318 00:58:43.664854 2013098752 net.cpp:380] ip1 <- data\n", + "I0318 00:58:43.664862 2013098752 net.cpp:338] ip1 -> ip1\n", + "I0318 00:58:43.664875 2013098752 net.cpp:113] Setting up ip1\n", + "I0318 00:58:43.664901 2013098752 net.cpp:120] Top shape: 10 40 (400)\n", + "I0318 00:58:43.664924 2013098752 layer_factory.hpp:74] Creating layer relu1\n", + "I0318 00:58:43.664945 2013098752 net.cpp:84] Creating Layer relu1\n", + "I0318 00:58:43.664958 2013098752 net.cpp:380] relu1 <- ip1\n", + "I0318 00:58:43.664966 2013098752 net.cpp:327] relu1 -> ip1 (in-place)\n", + "I0318 00:58:43.664975 2013098752 net.cpp:113] Setting up relu1\n", + "I0318 00:58:43.664983 2013098752 net.cpp:120] Top shape: 10 40 (400)\n", + "I0318 00:58:43.664990 2013098752 layer_factory.hpp:74] Creating layer ip2\n", + "I0318 00:58:43.665000 2013098752 net.cpp:84] Creating Layer ip2\n", + "I0318 00:58:43.665006 2013098752 net.cpp:380] ip2 <- ip1\n", + "I0318 00:58:43.665015 2013098752 net.cpp:338] ip2 -> ip2\n", + "I0318 00:58:43.665030 2013098752 net.cpp:113] Setting up ip2\n", + "I0318 00:58:43.665052 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:43.665066 2013098752 layer_factory.hpp:74] Creating layer ip2_ip2_0_split\n", + "I0318 00:58:43.665077 2013098752 net.cpp:84] Creating Layer ip2_ip2_0_split\n", + "I0318 00:58:43.665086 2013098752 net.cpp:380] ip2_ip2_0_split <- ip2\n", + "I0318 00:58:43.665093 2013098752 net.cpp:338] ip2_ip2_0_split -> ip2_ip2_0_split_0\n", + "I0318 00:58:43.665103 2013098752 net.cpp:338] ip2_ip2_0_split -> ip2_ip2_0_split_1\n", + "I0318 00:58:43.665113 2013098752 net.cpp:113] Setting up ip2_ip2_0_split\n", + "I0318 00:58:43.665122 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:43.665128 2013098752 net.cpp:120] Top shape: 10 2 (20)\n", + "I0318 00:58:43.665137 2013098752 layer_factory.hpp:74] Creating layer accuracy\n", + "I0318 00:58:43.665144 2013098752 net.cpp:84] Creating Layer accuracy\n", + "I0318 00:58:43.665153 2013098752 net.cpp:380] accuracy <- ip2_ip2_0_split_0\n", + "I0318 00:58:43.665168 2013098752 net.cpp:380] accuracy <- label_data_1_split_0\n", + "I0318 00:58:43.665180 2013098752 net.cpp:338] accuracy -> accuracy\n", + "I0318 00:58:43.665192 2013098752 net.cpp:113] Setting up accuracy\n", + "I0318 00:58:43.665200 2013098752 net.cpp:120] Top shape: (1)\n", + "I0318 00:58:43.665207 2013098752 layer_factory.hpp:74] Creating layer loss\n", + "I0318 00:58:43.665216 2013098752 net.cpp:84] Creating Layer loss\n", + "I0318 00:58:43.665223 2013098752 net.cpp:380] loss <- ip2_ip2_0_split_1\n", + "I0318 00:58:43.665230 2013098752 net.cpp:380] loss <- label_data_1_split_1\n", + "I0318 00:58:43.665241 2013098752 net.cpp:338] loss -> loss\n", + "I0318 00:58:43.665251 2013098752 net.cpp:113] Setting up loss\n", + "I0318 00:58:43.665259 2013098752 layer_factory.hpp:74] Creating layer loss\n", + "I0318 00:58:43.665273 2013098752 net.cpp:120] Top shape: (1)\n", + "I0318 00:58:43.665282 2013098752 net.cpp:122] with loss weight 1\n", + "I0318 00:58:43.665290 2013098752 net.cpp:167] loss needs backward computation.\n", + "I0318 00:58:43.665338 2013098752 net.cpp:169] accuracy does not need backward computation.\n", + "I0318 00:58:43.665351 2013098752 net.cpp:167] ip2_ip2_0_split needs backward computation.\n", + "I0318 00:58:43.665380 2013098752 net.cpp:167] ip2 needs backward computation.\n", + "I0318 00:58:43.665387 2013098752 net.cpp:167] relu1 needs backward computation.\n", + "I0318 00:58:43.665393 2013098752 net.cpp:167] ip1 needs backward computation.\n", + "I0318 00:58:43.665400 2013098752 net.cpp:169] label_data_1_split does not need backward computation.\n", + "I0318 00:58:43.665407 2013098752 net.cpp:169] data does not need backward computation.\n", + "I0318 00:58:43.665415 2013098752 net.cpp:205] This network produces output accuracy\n", + "I0318 00:58:43.665421 2013098752 net.cpp:205] This network produces output loss\n", + "I0318 00:58:43.665431 2013098752 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", + "I0318 00:58:43.665441 2013098752 net.cpp:217] Network initialization done.\n", + "I0318 00:58:43.665446 2013098752 net.cpp:218] Memory required for data: 3728\n", + "I0318 00:58:43.665534 2013098752 solver.cpp:42] Solver scaffolding done.\n", + "I0318 00:58:43.665568 2013098752 solver.cpp:222] Solving \n", + "I0318 00:58:43.665577 2013098752 solver.cpp:223] Learning Rate Policy: step\n", + "I0318 00:58:43.665586 2013098752 solver.cpp:266] Iteration 0, Testing net (#0)\n", + "I0318 00:58:43.683938 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.5184\n", + "I0318 00:58:43.683981 2013098752 solver.cpp:315] Test net output #1: loss = 0.716141 (* 1 = 0.716141 loss)\n", + "I0318 00:58:43.684236 2013098752 solver.cpp:189] Iteration 0, loss = 0.764954\n", + "I0318 00:58:43.684267 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.5\n", + "I0318 00:58:43.684285 2013098752 solver.cpp:204] Train net output #1: loss = 0.764954 (* 1 = 0.764954 loss)\n", + "I0318 00:58:43.684305 2013098752 solver.cpp:464] Iteration 0, lr = 0.01\n", + "I0318 00:58:43.714700 2013098752 solver.cpp:266] Iteration 1000, Testing net (#0)\n", + "I0318 00:58:43.721762 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.8168\n", + "I0318 00:58:43.721818 2013098752 solver.cpp:315] Test net output #1: loss = 0.434918 (* 1 = 0.434918 loss)\n", + "I0318 00:58:43.721899 2013098752 solver.cpp:189] Iteration 1000, loss = 0.282425\n", + "I0318 00:58:43.721917 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.9\n", + "I0318 00:58:43.721932 2013098752 solver.cpp:204] Train net output #1: loss = 0.282426 (* 1 = 0.282426 loss)\n", + "I0318 00:58:43.721942 2013098752 solver.cpp:464] Iteration 1000, lr = 0.01\n", + "I0318 00:58:43.750509 2013098752 solver.cpp:266] Iteration 2000, Testing net (#0)\n", + "I0318 00:58:43.754590 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.8224\n", + "I0318 00:58:43.754621 2013098752 solver.cpp:315] Test net output #1: loss = 0.416874 (* 1 = 0.416874 loss)\n", + "I0318 00:58:43.754660 2013098752 solver.cpp:189] Iteration 2000, loss = 0.51988\n", + "I0318 00:58:43.754672 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.7\n", + "I0318 00:58:43.754683 2013098752 solver.cpp:204] Train net output #1: loss = 0.51988 (* 1 = 0.51988 loss)\n", + "I0318 00:58:43.754690 2013098752 solver.cpp:464] Iteration 2000, lr = 0.01\n", + "I0318 00:58:43.782609 2013098752 solver.cpp:266] Iteration 3000, Testing net (#0)\n", + "I0318 00:58:43.789728 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.8176\n", + "I0318 00:58:43.789777 2013098752 solver.cpp:315] Test net output #1: loss = 0.415907 (* 1 = 0.415907 loss)\n", + "I0318 00:58:43.790487 2013098752 solver.cpp:189] Iteration 3000, loss = 0.5093\n", + "I0318 00:58:43.790510 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.7\n", + "I0318 00:58:43.790530 2013098752 solver.cpp:204] Train net output #1: loss = 0.509301 (* 1 = 0.509301 loss)\n", + "I0318 00:58:43.790544 2013098752 solver.cpp:464] Iteration 3000, lr = 0.01\n", + "I0318 00:58:43.817451 2013098752 solver.cpp:266] Iteration 4000, Testing net (#0)\n", + "I0318 00:58:43.821740 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.8252\n", + "I0318 00:58:43.821770 2013098752 solver.cpp:315] Test net output #1: loss = 0.409124 (* 1 = 0.409124 loss)\n", + "I0318 00:58:43.821822 2013098752 solver.cpp:189] Iteration 4000, loss = 0.284815\n", + "I0318 00:58:43.821835 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.9\n", + "I0318 00:58:43.821846 2013098752 solver.cpp:204] Train net output #1: loss = 0.284815 (* 1 = 0.284815 loss)\n", + "I0318 00:58:43.821890 2013098752 solver.cpp:464] Iteration 4000, lr = 0.01\n", + "I0318 00:58:43.847015 2013098752 solver.cpp:266] Iteration 5000, Testing net (#0)\n", + "I0318 00:58:43.852102 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.8256\n", + "I0318 00:58:43.852145 2013098752 solver.cpp:315] Test net output #1: loss = 0.404445 (* 1 = 0.404445 loss)\n", + "I0318 00:58:43.852188 2013098752 solver.cpp:189] Iteration 5000, loss = 0.511566\n", + "I0318 00:58:43.852200 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.7\n", + "I0318 00:58:43.852210 2013098752 solver.cpp:204] Train net output #1: loss = 0.511566 (* 1 = 0.511566 loss)\n", + "I0318 00:58:43.852219 2013098752 solver.cpp:464] Iteration 5000, lr = 0.001\n", + "I0318 00:58:43.876060 2013098752 solver.cpp:266] Iteration 6000, Testing net (#0)\n", + "I0318 00:58:43.880080 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.8328\n", + "I0318 00:58:43.880105 2013098752 solver.cpp:315] Test net output #1: loss = 0.396847 (* 1 = 0.396847 loss)\n", + "I0318 00:58:43.880700 2013098752 solver.cpp:189] Iteration 6000, loss = 0.397858\n", + "I0318 00:58:43.880718 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.9\n", + "I0318 00:58:43.880729 2013098752 solver.cpp:204] Train net output #1: loss = 0.397858 (* 1 = 0.397858 loss)\n", + "I0318 00:58:43.880738 2013098752 solver.cpp:464] Iteration 6000, lr = 0.001\n", + "I0318 00:58:43.913795 2013098752 solver.cpp:266] Iteration 7000, Testing net (#0)\n", + "I0318 00:58:43.917851 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.8316\n", + "I0318 00:58:43.917876 2013098752 solver.cpp:315] Test net output #1: loss = 0.398135 (* 1 = 0.398135 loss)\n", + "I0318 00:58:43.917956 2013098752 solver.cpp:189] Iteration 7000, loss = 0.243849\n", + "I0318 00:58:43.917971 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.9\n", + "I0318 00:58:43.917989 2013098752 solver.cpp:204] Train net output #1: loss = 0.243849 (* 1 = 0.243849 loss)\n", + "I0318 00:58:43.918002 2013098752 solver.cpp:464] Iteration 7000, lr = 0.001\n", + "I0318 00:58:43.943681 2013098752 solver.cpp:266] Iteration 8000, Testing net (#0)\n", + "I0318 00:58:43.947589 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.8312\n", + "I0318 00:58:43.947615 2013098752 solver.cpp:315] Test net output #1: loss = 0.394763 (* 1 = 0.394763 loss)\n", + "I0318 00:58:43.947651 2013098752 solver.cpp:189] Iteration 8000, loss = 0.513399\n", + "I0318 00:58:43.947664 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.7\n", + "I0318 00:58:43.947674 2013098752 solver.cpp:204] Train net output #1: loss = 0.513399 (* 1 = 0.513399 loss)\n", + "I0318 00:58:43.947682 2013098752 solver.cpp:464] Iteration 8000, lr = 0.001\n", + "I0318 00:58:43.973080 2013098752 solver.cpp:266] Iteration 9000, Testing net (#0)\n", + "I0318 00:58:43.977033 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.834\n", + "I0318 00:58:43.977056 2013098752 solver.cpp:315] Test net output #1: loss = 0.395663 (* 1 = 0.395663 loss)\n", + "I0318 00:58:43.977710 2013098752 solver.cpp:189] Iteration 9000, loss = 0.399341\n", + "I0318 00:58:43.977735 2013098752 solver.cpp:204] Train net output #0: accuracy = 0.9\n", + "I0318 00:58:43.977746 2013098752 solver.cpp:204] Train net output #1: loss = 0.399342 (* 1 = 0.399342 loss)\n", + "I0318 00:58:43.977756 2013098752 solver.cpp:464] Iteration 9000, lr = 0.001\n", + "I0318 00:58:44.003437 2013098752 solver.cpp:334] Snapshotting to examples/hdf5_classification/data/train_iter_10000.caffemodel\n", + "I0318 00:58:44.003702 2013098752 solver.cpp:342] Snapshotting solver state to examples/hdf5_classification/data/train_iter_10000.solverstate\n", + "I0318 00:58:44.003850 2013098752 solver.cpp:248] Iteration 10000, loss = 0.244639\n", + "I0318 00:58:44.003871 2013098752 solver.cpp:266] Iteration 10000, Testing net (#0)\n", + "I0318 00:58:44.008216 2013098752 solver.cpp:315] Test net output #0: accuracy = 0.8308\n", + "I0318 00:58:44.008252 2013098752 solver.cpp:315] Test net output #1: loss = 0.397291 (* 1 = 0.397291 loss)\n", + "I0318 00:58:44.008262 2013098752 solver.cpp:253] Optimization Done.\n", + "I0318 00:58:44.008270 2013098752 caffe.cpp:134] Optimization Done.\n" + ] + } + ], + "source": [ + "!./build/tools/caffe train -solver examples/hdf5_classification/nonlinear_solver.prototxt" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Clean up (comment this out if you want to examine the hdf5_classification/data directory).\n", + "shutil.rmtree(dirname)" + ] + } + ], + "metadata": { + "description": "Use Caffe as a generic SGD optimizer to train logistic regression on non-image HDF5 data.", + "example_name": "Off-the-shelf SGD for classification", + "include_in_docs": true, + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + }, + "priority": 3 + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/03-fine-tuning.ipynb b/examples/03-fine-tuning.ipynb new file mode 100644 index 00000000000..cc90b16bbfa --- /dev/null +++ b/examples/03-fine-tuning.ipynb @@ -0,0 +1,947 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fine-tuning a Pretrained Network for Style Recognition\n", + "\n", + "In this example, we'll explore a common approach that is particularly useful in real-world applications: take a pre-trained Caffe network and fine-tune the parameters on your custom data.\n", + "\n", + "The upside of such approach is that, since pre-trained networks are learned on a large set of images, the intermediate layers capture the \"semantics\" of the general visual appearance. Think of it as a very powerful feature that you can treat as a black box. On top of that, only a few layers will be needed to obtain a very good performance of the data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we will need to prepare the data. This involves the following parts:\n", + "(1) Get the ImageNet ilsvrc pretrained model with the provided shell scripts.\n", + "(2) Download a subset of the overall Flickr style dataset for this demo.\n", + "(3) Compile the downloaded Flickr dataset into a database that Caffe can then consume." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import os\n", + "os.chdir('..')\n", + "import sys\n", + "sys.path.insert(0, './python')\n", + "\n", + "import caffe\n", + "import numpy as np\n", + "from pylab import *\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# This downloads the ilsvrc auxiliary data (mean file, etc),\n", + "# and a subset of 2000 images for the style recognition task.\n", + "!data/ilsvrc12/get_ilsvrc_aux.sh\n", + "!scripts/download_model_binary.py models/bvlc_reference_caffenet\n", + "!python examples/finetune_flickr_style/assemble_data.py \\\n", + " --workers=-1 --images=2000 --seed=1701 --label=5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's show what is the difference between the fine-tuning network and the original caffe model." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1c1\r\n", + "< name: \"CaffeNet\"\r\n", + "---\r\n", + "> name: \"FlickrStyleCaffeNet\"\r\n", + "4c4\r\n", + "< type: \"Data\"\r\n", + "---\r\n", + "> type: \"ImageData\"\r\n", + "15,26c15,19\r\n", + "< # mean pixel / channel-wise mean instead of mean image\r\n", + "< # transform_param {\r\n", + "< # crop_size: 227\r\n", + "< # mean_value: 104\r\n", + "< # mean_value: 117\r\n", + "< # mean_value: 123\r\n", + "< # mirror: true\r\n", + "< # }\r\n", + "< data_param {\r\n", + "< source: \"examples/imagenet/ilsvrc12_train_lmdb\"\r\n", + "< batch_size: 256\r\n", + "< backend: LMDB\r\n", + "---\r\n", + "> image_data_param {\r\n", + "> source: \"data/flickr_style/train.txt\"\r\n", + "> batch_size: 50\r\n", + "> new_height: 256\r\n", + "> new_width: 256\r\n", + "31c24\r\n", + "< type: \"Data\"\r\n", + "---\r\n", + "> type: \"ImageData\"\r\n", + "42,51c35,36\r\n", + "< # mean pixel / channel-wise mean instead of mean image\r\n", + "< # transform_param {\r\n", + "< # crop_size: 227\r\n", + "< # mean_value: 104\r\n", + "< # mean_value: 117\r\n", + "< # mean_value: 123\r\n", + "< # mirror: true\r\n", + "< # }\r\n", + "< data_param {\r\n", + "< source: \"examples/imagenet/ilsvrc12_val_lmdb\"\r\n", + "---\r\n", + "> image_data_param {\r\n", + "> source: \"data/flickr_style/test.txt\"\r\n", + "53c38,39\r\n", + "< backend: LMDB\r\n", + "---\r\n", + "> new_height: 256\r\n", + "> new_width: 256\r\n", + "323a310\r\n", + "> # Note that lr_mult can be set to 0 to disable any fine-tuning of this, and any other, layer\r\n", + "360c347\r\n", + "< name: \"fc8\"\r\n", + "---\r\n", + "> name: \"fc8_flickr\"\r\n", + "363c350,351\r\n", + "< top: \"fc8\"\r\n", + "---\r\n", + "> top: \"fc8_flickr\"\r\n", + "> # lr_mult is set to higher than for other layers, because this layer is starting from random while the others are already trained\r\n", + "365c353\r\n", + "< lr_mult: 1\r\n", + "---\r\n", + "> lr_mult: 10\r\n", + "369c357\r\n", + "< lr_mult: 2\r\n", + "---\r\n", + "> lr_mult: 20\r\n", + "373c361\r\n", + "< num_output: 1000\r\n", + "---\r\n", + "> num_output: 20\r\n", + "384a373,379\r\n", + "> name: \"loss\"\r\n", + "> type: \"SoftmaxWithLoss\"\r\n", + "> bottom: \"fc8_flickr\"\r\n", + "> bottom: \"label\"\r\n", + "> top: \"loss\"\r\n", + "> }\r\n", + "> layer {\r\n", + "387c382\r\n", + "< bottom: \"fc8\"\r\n", + "---\r\n", + "> bottom: \"fc8_flickr\"\r\n", + "393,399d387\r\n", + "< }\r\n", + "< layer {\r\n", + "< name: \"loss\"\r\n", + "< type: \"SoftmaxWithLoss\"\r\n", + "< bottom: \"fc8\"\r\n", + "< bottom: \"label\"\r\n", + "< top: \"loss\"\r\n" + ] + } + ], + "source": [ + "!diff models/bvlc_reference_caffenet/train_val.prototxt models/finetune_flickr_style/train_val.prototxt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For your record, if you want to train the network in pure C++ tools, here is the command:\n", + "\n", + "\n", + "build/tools/caffe train \\\n", + " -solver models/finetune_flickr_style/solver.prototxt \\\n", + " -weights models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel \\\n", + " -gpu 0\n", + "\n", + "\n", + "However, we will train using Python in this example." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter 0, finetune_loss=3.360094, scratch_loss=3.136188\n", + "iter 10, finetune_loss=2.672608, scratch_loss=9.736364\n", + "iter 20, finetune_loss=2.071996, scratch_loss=2.250404\n", + "iter 30, finetune_loss=1.758295, scratch_loss=2.049553\n", + "iter 40, finetune_loss=1.533391, scratch_loss=1.941318\n", + "iter 50, finetune_loss=1.561658, scratch_loss=1.839706\n", + "iter 60, finetune_loss=1.461696, scratch_loss=1.880035\n", + "iter 70, finetune_loss=1.267941, scratch_loss=1.719161\n", + "iter 80, finetune_loss=1.192778, scratch_loss=1.627453\n", + "iter 90, finetune_loss=1.541176, scratch_loss=1.822061\n", + "iter 100, finetune_loss=1.029039, scratch_loss=1.654087\n", + "iter 110, finetune_loss=1.138547, scratch_loss=1.735837\n", + "iter 120, finetune_loss=0.917412, scratch_loss=1.851918\n", + "iter 130, finetune_loss=0.971519, scratch_loss=1.801927\n", + "iter 140, finetune_loss=0.868252, scratch_loss=1.745545\n", + "iter 150, finetune_loss=0.790020, scratch_loss=1.844925\n", + "iter 160, finetune_loss=1.092668, scratch_loss=1.695591\n", + "iter 170, finetune_loss=1.055344, scratch_loss=1.661715\n", + "iter 180, finetune_loss=0.969769, scratch_loss=1.823639\n", + "iter 190, finetune_loss=0.780566, scratch_loss=1.820862\n", + "done\n" + ] + } + ], + "source": [ + "niter = 200\n", + "# losses will also be stored in the log\n", + "train_loss = np.zeros(niter)\n", + "scratch_train_loss = np.zeros(niter)\n", + "\n", + "caffe.set_device(0)\n", + "caffe.set_mode_gpu()\n", + "# We create a solver that fine-tunes from a previously trained network.\n", + "solver = caffe.SGDSolver('models/finetune_flickr_style/solver.prototxt')\n", + "solver.net.copy_from('models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel')\n", + "# For reference, we also create a solver that does no finetuning.\n", + "scratch_solver = caffe.SGDSolver('models/finetune_flickr_style/solver.prototxt')\n", + "\n", + "# We run the solver for niter times, and record the training loss.\n", + "for it in range(niter):\n", + " solver.step(1) # SGD by Caffe\n", + " scratch_solver.step(1)\n", + " # store the train loss\n", + " train_loss[it] = solver.net.blobs['loss'].data\n", + " scratch_train_loss[it] = scratch_solver.net.blobs['loss'].data\n", + " if it % 10 == 0:\n", + " print 'iter %d, finetune_loss=%f, scratch_loss=%f' % (it, train_loss[it], scratch_train_loss[it])\n", + "print 'done'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's look at the training loss produced by the two training procedures respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEACAYAAABMEua6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XmcXFWd9/HPtzt7AlkkJCGAgbCIqCSyuIDaRECEYZvB\n", + "EQRFB5iMo8CjzuMwOlpdioo4IM4iM6wTgdHhgRFBRAhLM6gQtgQCIQQkYc8CJIEQQpb+PX+c01hp\n", + "eqmqrl5SfN+vV7266tZdzr11+3tPnXvuLUUEZmZWHxr6uwBmZlY7DnUzszriUDczqyMOdTOzOuJQ\n", + "NzOrIw51M7M6UlaoS2qUNFfS9fn1OEmzJS2SdLOkMb1bTDMzK0e5NfUzgAVAW6f2M4HZEbEbcGt+\n", + "bWZm/azbUJe0PXAYcDGgPPhIYFZ+Pgs4uldKZ2ZmFSmnpv5j4P8CrSXDJkTEsvx8GTCh1gUzM7PK\n", + "dRnqkv4MWB4Rc/lTLX0zke4z4HsNmJkNAIO6ef/DwJGSDgOGAVtLuhxYJmliRCyVNAlY3tHEkhz2\n", + "ZmZViIgOK9LdUbk39JL0MeDvIuIISecAL0XEDyWdCYyJiLecLJUU1RbMNiepOSKa+7sc9cLbs7a8\n", + "PWurJ9lZaT/1tiPA2cDBkhYBM/JrMzPrZ901v7wpIu4A7sjPXwYO6q1CmZlZdXxF6Zajpb8LUGda\n", + "+rsAdaalvwtgSdlt6lXN3G3qZmYV68s2dTMzG8Ac6mZmdcShbmZWRxzqZmZ1xKFuZlZHHOpmZnXE\n", + "oW5mVkcc6mZmdcShbmZWRxzqZmZ1xKFuZlZHHOpmZnXEoW5mVkcc6mZmdaTPQ11FSUUd1tfLNTN7\n", + "O+iPmvo44HoV5fusm5nVWH+FegMwqh+WbWZW17oNdUnDJM2RNE/SAkk/yMObJT0raW5+HFrmMse2\n", + "+2tmZjXS7Q9PR8Q6SQdGxFpJg4DfSToACOC8iDivwmW2hfkY4OkKpzUzsy6U1fwSEWvz0yFAI7Ay\n", + "v66mXXxc/jumimnNzKwLZYW6pAZJ84BlwO0R8Uh+6zRJD0q6RFK5Ie3mFzOzXlJuTb01IqYB2wMf\n", + "ldQEXADsBEwDXgDOLXOZpc0vZmZWQ922qZeKiNWSbgD2iYiWtuGSLgau72gaSc0lL1toZhypPd41\n", + "dTMzIFeUm2oxr25DXdI2wMaIWCVpOHAwUJQ0MSKW5tGOAeZ3NH1ENG82v6I+BzyHa+pmZgDkSnJL\n", + "22tJhWrnVU5NfRIwS1IDqbnm8oi4VdLPJE0j1boXAzPLXObYPL5r6mZmNVZOl8b5wPs7GP65Kpc5\n", + "DngS19TNzGquP64oHUsKddfUzcxqrL9uE+CauplZL+jPmrpD3cysxvo01FXUUGAwqfeLm1/MzGqs\n", + "r2vqY4FVpNsMuKZuZlZj/RHqLwOvAsNV1OA+Xr6ZWV3rj1BfGYUIYDUwuo+Xb2ZW1/o61Mfxpzs8\n", + "rsTt6mZmNdVfzS+Q2tbdrm5mVkP90vySn6/CNXUzs5rq7+YX19TNzGrIzS9mZnWkP5tffKLUzKzG\n", + "+rtN3TV1M7Ma6utQHw68np+7pm5mVmN9HeqDgI35+avA1n28fDOzutbXoT4Y2JCfvw4M6+Plm5nV\n", + "tf4O9eF9vHwzs7rmUDczqyNdhrqkYZLmSJonaYGkH+Th4yTNlrRI0s2Syu3FUhrq63Com5nVVJeh\n", + "HhHrgAMjYhrwPuBASQcAZwKzI2I34Nb8uhylJ0rdpm5mVmPdNr9ExNr8dAjQSOqKeCQwKw+fBRxd\n", + "5vLc/GJm1ou6DXVJDZLmAcuA2yPiEWBCRCzLoywDJpS5PIe6mVkvGtTdCBHRCkyTNBq4SdKB7d4P\n", + "SdHZ9JKa33zxWUYy1aFuZlZKUhPQVIt5dRvqbSJitaQbgL2BZZImRsRSSZOA5V1M19z2XEV9GdfU\n", + "zcw2ExEtQEvba0mFaufVXe+Xbdp6tkgaDhwMzAWuA07Ko50EXFvm8kpPlK4j/U6pKi20mZl1rLs2\n", + "9UnAbblNfQ5wfUTcCpwNHCxpETAjvy7Hm23qUYiNwKY8zMzMaqDL5peImA+8v4PhLwMHVbG80hOl\n", + "8KcmmPVVzMvMzNrpsytKczNLZ6FuZmY10Je3CWgEWqMQrSXDHOpmZjXUl6FeepK0jUPdzKyG+jLU\n", + "2ze9QOoB41sFmJnVSH+HumvqZmY15FA3M6sjDnUzszriE6VmZnVkINTUfaLUzKxG+jvU/etHZmY1\n", + "1N+h7uYXM7Ma6us2dYe6mVkv6uuauk+Umpn1ooHQ/OITpWZmNTIQQt01dTOzGunvUHfvFzOzGvLF\n", + "R2ZmdaS/a+oOdTOzGnKom5nVkW5DXdIOkm6X9IikhyWdnoc3S3pW0tz8OLSbWbn3i5lZL+vyh6ez\n", + "DcBXImKepFHA/ZJmAwGcFxHnlbks19TNzHpZt6EeEUuBpfn5GkmPApPz26pwWe1PlLr3i5lZDVXU\n", + "pi5pCjAduDsPOk3Sg5IukTSmm8ldUzcz62XlNL8AkJtergbOyDX2C4Dv5Le/C5wLnNzBdM0A7MZ+\n", + "7Mkb7d52qJvZ256kJqCpFvMqK9QlDQauAa6IiGsBImJ5yfsXA9d3NG1ENAOoqK8CO7R72ydKzext\n", + "LyJagJa215IK1c6rnN4vAi4BFkTE+SXDJ5WMdgwwv5tZufnFzKyXlVNT3x84EXhI0tw87BvA8ZKm\n", + "kXrBLAZmlrGsDk+UqihFIaL8YpuZWUfK6f3yOzqu0d9Y4bLeUlOPQmxUUa35vfUVzs/MzNrp7ytK\n", + "wU0wZmY1M1BC3SdLzcxqYKCEumvqZmY10N+33gWHuplZzbimbmZWRwZCqPv+L2ZmNTIQQt0nSs3M\n", + "amSghPqIPiyHmVndGggnSl/DoW5mVhMDoab+GjCyD8thZla3HOpmZnXEoW5mVkcc6mZmdWSgnCh1\n", + "qJuZ1YBr6mZmdcShbmZWRwZKqI/qw3KYmdWtgRLqrqmbmdWAT5SamdWRbkNd0g6Sbpf0iKSHJZ2e\n", + "h4+TNFvSIkk3SxrTzaxcUzcz62Xl1NQ3AF+JiD2BDwJfkrQHcCYwOyJ2A27Nr7viUDcz62XdhnpE\n", + "LI2Iefn5GuBRYDJwJDArjzYLOLqbWTnUzcx6WUVt6pKmANOBOcCEiFiW31oGTOhmcoe6mVkvG1Tu\n", + "iJJGAdcAZ0TEq5LefC8iQlJ0Ml0zAB9lBA/zQQr8pt0orwEjVZSiEB3Ow8ysnklqAppqMq8oI0cl\n", + "DQZ+DdwYEefnYQuBpohYKmkScHtEvKvddBERAlBR64CxUYjX3zL/ot4ARkch1vV4jczMtnCl2Vmp\n", + "cnq/CLgEWNAW6Nl1wEn5+UnAtd3MqrPmF3ATjJlZTZTTpr4/cCJwoKS5+XEocDZwsKRFwIz8ukMq\n", + "qiEva1MnozjUzcxqoNs29Yj4HZ2H/0FlLmcwsKGLNnOHuplZDfTVFaWdXU3axqFuZlYDfRXqXbWn\n", + "g0PdzKwmHOpmZnXEoW5mVkf6sk29u1D3PdXNzHqoL2vqPlFqZtbL3PxiZlZHHOpmZnXEoW5mVkcG\n", + "0olSh7qZWQ8NlBOla3Com5n1mJtfzMzqiEPdzKyOONTNzOqIT5SamdWRgXKi1KFuZlYDbn4xM6sj\n", + "DnUzszoyUEJ9DTBKRVX169lmZpZ0G+qSLpW0TNL8kmHNkp5t90PUXeky1KMQG0i19THlFtzMzN6q\n", + "nJr6ZUD70A7gvIiYnh+/7WYeQ4E3uhlnObBtGeUxM7NOdBvqEXEnsLKDtyppKikn1FcA4yuYp5mZ\n", + "tdOTNvXTJD0o6RJJ3TWblFtTd6ibmfXAoCqnuwD4Tn7+XeBc4OSORpTUzJ4cSNCqZjVFREsn81xB\n", + "bn5RUX8OzItCPFll+czMthiSmoCmWsyrqlCPiOUlhbkYuL6LcZtV1AjgpSh0GuiweU39NFJbvkPd\n", + "zOperuy2tL2WVKh2XlU1v0iaVPLyGGB+Z+Nm5bapt50o3REYXU3ZzMzezrqtqUv6OfAxYBtJzwAF\n", + "oEnSNFIvmMXAzG5mU26b+gdUVAOwAw51M7OKdRvqEXF8B4MvrXA5ldTUtyX1a9+6wmWYmb3t9dUV\n", + "pZX0ftkxv3ZN3cysQgMp1Ntq6juQmnUc6mZmFRpIof4i8A7gnaReLw51M7MKDZhQj0KsJ93Y632k\n", + "3jQOdTOzCvVlqK8vY7zlwN7AwzjUzcwqNmBq6tkK4N24pm5mVpWBFurLSWVyTd3MrAoDLdRXAJuA\n", + "x4ERKqqxV0tlZlZnBlqoLweeyz+a8Sq+AMnMrCJ9FepDKL+m/kx+vho3wZiZVaTaW+9Wqtya+sPA\n", + "dvm5Q93MrEIDKtSjELcBt+WXDnUzswoNtDb1Ug51M7MK9XqoqyiR2tTLufiolEPdzKxCfVFTHwJs\n", + "iEK0VjidQ93MrEJ9EerVNL2AQ93MrGIOdTOzOuJQNzOrIw51M7M60m2oS7pU0jJJ80uGjZM0W9Ii\n", + "STdLGtPFLBzqZmZ9pJya+mXAoe2GnQnMjojdgFvz68441M3M+ki3oR4RdwIr2w0+EpiVn88Cju5i\n", + "Fg51M7M+Um2b+oSIWJafLwMmdDGuQ93MrI/0+N4vERGSotMRLuIUJjNZzWoGWiKipcxZO9TN7G1B\n", + "UhPQVIt5VRvqyyRNjIilkiaR7oPesVO5Chgbc6K5wmW8CoxUUQ1VXI1qZrbFyJXdlrbXkgrVzqva\n", + "5pfrgJPy85OAa7sYt6rmlxzkrwMjKi6dmdnbVDldGn8O/AHYXdIzkr4AnA0cLGkRMCO/7sxQKr+Z\n", + "V5vXgJFVTmtm9rbTbfNLRBzfyVsHlbmMak+UgkPdzKwiA/mKUkihPqqGZTEzq2sDPdTX4Jq6mVnZ\n", + "Bnqou6ZuZlaBLSHUXVM3MyvTQA91N7+YmVWgr37Ozs0vZmZ9YKDX1N38YmZWgYEe6m5+MTOrwEAP\n", + "dTe/mJlVYEsIddfUzczKNNBD3c0vZmYVGOih7uYXM7MKbAmh7pq6mVmZBnqou/nFzKwCAz3U3fxi\n", + "ZlaBLSHUXVM3MyvTQA91N7+YmVVgoIe6m1/MzCrQ7c/ZdUXSEuAVYBOwISL262A0N7+YmfWRntbU\n", + "A2iKiOmdBDr07Ien1wNSUUOqnN7M7G2lFs0v6ub9qmvqUYjAtXUzs7LVoqZ+i6T7JJ3ayTg9aX4B\n", + "h7qZWdl61KYO7B8RL0gaD8yWtDAi7uxgGdU2v4BD3cysbD0K9Yh4If9dIemXwH7A5qF+O5u4g4Ka\n", + "BdASES0VLmYN7gFjZnVMUhPQVIt5VR3qkkYAjRHxqqSRwCFA8S0jHshr0RLNVZfQNXUzq3O5stvS\n", + "9lpSodp59aSmPgH4paS2+VwZETd3MN6iHiwDHOpmZmWrOtQjYjEwrYxRH6h2GZmbX8zMytQXV5T2\n", + "NNRdUzczK5ND3cysjvRFqM/v4fRufjEzK1Ovh3oUYl0PZ+GauplZmfqipt5TvlOjmVmZtoRQ9z3V\n", + "zczKtCWE+oBsflFRE1TUNSrqnf1dFjOzNj2990u3JBRB9GAWC4FzVNRuwMvA/yHdv/3F/JgETAa+\n", + "G4VY1UkZPgCsiODJkmHvAv4S2Bk4I4LV5RZIRe0K3AS0AscDZ1exXmZmNdcXNfV3VTORxGCJM2mO\n", + "B4F/BG4BHgS2YcUeE3lyxgnAUcBOpFC/RkXtrKJuU1FfLJmPoPViaP2HkmHbALOBscAuwKfKLldR\n", + "Q4FrgPOAmcBfVLN+Zma9QRE9qUR3M3MpIL4UwU8rn5avAz8AvhnB2SrqBOC5KESLxC+BI4G9I5in\n", + "ohqBXwKH0Np4Adp0ImKPKMSLmvjggRwx8yZGLW1k62fORq1bsfCoo3j4+Dv51HGfpTmOJtXUm8oq\n", + "V1HfB/YA/hxoBF4A9olCPFXpOpqZdURSRER3v1XR8bR9EOpXR6SasMT2wPKIjm/FK3EE8FfAfwBX\n", + "AMcBvwD2iWBJHmcn4F7gR0BTBJ8EUFHDeeITe3HFby/kswe/xtRbHgLOZ+let7B+5HPc+v3RHPbl\n", + "+3lptwZe3GN/PvK99YhNbBr8W/51wYms3GVaBE93uT5FTQduBPaKQizLwy4BlgA7knrpfC0K8Xx+\n", + "7wxgqyjEWdVuQzN7+xnoob4a+DkwGjiaFMhHR7By83HZClgAXA18HvinCL4n8Q3go8BhEbRK/BPp\n", + "xzm+mcf/TgQ/k5gA3ADMZ8SKI/m7iauBVh44ZXvu+urOvLT7ycBU4FDgcJo1F9gLOJb1I7/Gsvc+\n", + "wg53XwT8KgrplsIAKmpYXt564A7g8ijERSXvHw78GrgMeI7UJPMDYAXwfdIvQ50ShbipNlu1exKT\n", + "gfdFcGNfLdPMamegh/puwDF50H8AzcAnga+Sgu8HpJqugMYIPi8xHFgXQUgMJt2j/RekNvWrSc0u\n", + "SySmA/8NPAW8H/jXPP//BJblYX+MYKbEnsDDwIURzNysnO+67iDGPnkDk+fALjdt5KVdj46L5sxW\n", + "UVNIgT0Y+K+8HntHITa9OW1q+tk3CnF3fv1u4BzgY8ABpHb7/wL+Igpxlybf+3l2/N0pTJu1inc8\n", + "di6D17UAXyEdYH4KPApsjEKs7XS7FrUDK/YYy3//zzHMnP4rBq9rJF25Owh4N7cXz2fYyg8y/dK7\n", + "GPbKH/J2D+D1KMTSTub5UeCHwJejEPe3e0/AoCjEhpJ1PhB4D+kguLizspZLQnz0rP2Y8a1v5vX4\n", + "HOl8x4nAT6IQj1c0v6JGAu8D5kQhWkvWY0oUYnFehwuApcD3oxDrVNRY4N9I+9k5+ecUa0JFDYlC\n", + "rFdRDcAMYCvg91GI5R2MOwKYGIV4sv17ZS5rIrANqSK1FelOqYtruT4ly2ok7Vt7Ax8G7qFkm5eM\n", + "N4r0zfuxKLzlh3TKXZaA7YAVUYie/PDOgKOitibly9woxEMDOtQ7KpjEMcBZwDtIJ0F3JNXiD4rg\n", + "rTu52BmYQ+r1cmIEt5S8N4oUADdE8FQetiup18wlwBcj2JROmHI28KMIXuxgGQ3ABD7wk3+nqXgE\n", + "oacZ/vIwFh1xAxuHPcee/28m8Gma43lSCG9PCtLrgDnte/ioqBFtwZzPB5xFawNsGPlOVr1zEU8c\n", + "Opq9L9qaoasXIjYC19Da+EU2Dd4ONJhNg29h2CtXk/rpfwI4CPgNsBH4S9Zs20jj+tGodQnDXllD\n", + "MBUQm4YuZuHRU2ltvJ0nPjGFo7/wWxpaTyR1Dd0qz2NJ3uZzgeeBg4HDgYuAU4EZUYhH80Htb4Bj\n", + "Sbdavoj0jeVE0kHzQeAI4HHgKtLPFo7Pj02kwFwKvMwrk0ewZsJTbPfA3cA+wKlsGvRJkGjc8D+8\n", + "MO0jbP3sNF7a7Up2/MNzwEkEwaoptzJ2yaHAY8CupIP/WmAI6acSh5K+sd1FOsexNelAegCwEniW\n", + "tK8tBZoJDkdcCmwghf4KYF/g7vz3xly+52ltPJ+NwwYx5LVv5uX9nhRgytttEzAceIRUsdid9LsC\n", + "B+Vt8iCpQrAP8CHgJWAdsCqX50N5fovzZ/IaMA7Yn9Sz6sK83n+fP/fHSQH9ev48JpCC+2Xgj8BD\n", + "wGdI4fpCXs5rwHvzNJeSvs2uJR2UZ+Tt81iefi/SDzWszWV9iVQR+iNwAjA9l2E46YC7Sy6vSP9v\n", + "vwc+SOqRdhepI8ZUkvGkytk+wM15uncABeAPwLtJ33IPyp/bE6QDxOWk/4Ef5XXbSOrivIB0X6nf\n", + "ATdGIVbkA8cHgHeSKgb3k/bxrUn7/gZgWRQiVNSeuQx/yON+lLSv75rXcW0uf0Meb5f8ea8g9bp7\n", + "mNREPBX4OCkHXif9psRo4Mn8ua4BJuay3JTX91DSPnMTcBvwJdL/VAtwVhTi3i0u1NN7NJBq5hvK\n", + "mxf7AksjeKbM8d8FPFZNd0ptP+dAGjZcyIaR27J0+nxgMrTeDw3jSTvfBaSdZTqp9jGS9I81K4J/\n", + "6qAsUxmzeCPjH/kui2dsig0jviAxmlEv3M0BP1zAwiNPZ8mMGcC5wH8xcukrvOcXn2e/nz7CS7vt\n", + "z/N7r2T5e2Zx7HHraGgdyYX3LOT5fb8D/AvpH/NTDHl1HpuGrGHT0KdJtf1/JPXweR6YGcFaFTUa\n", + "OJm0gz9Hql1tB/wvcGUUYqmK+hzBT9kwYh2D3mikYdOlpJ33ReA0UthcHoV4BEBFDSYF2dH5vRX5\n", + "0UDamScRGseSj32YbR4bxqgX1iBeZ+24y5h12+dR61g++ON5PH3ANF7Z4Uye+OR3gD+jWQ1cOGcn\n", + "nt/vcva5YAZ/9reNwELmf3oIzxywJ4ed9gDpILKRdAvoffPrV/LjrlzmU0ndTiexascWLrzvM5wx\n", + "9U6Gvro98JEoxCoVtRewJ6kGODs3uf0dr044lQ2jtmfR4b9g2qwrGLZ6b9I/Nnm7iXSQ2wvYgRS4\n", + "d5IODFPzPN8AFnDx75/g8zPWMeiNMcBDOVjE7c27snTad5l8z3p2v+4BJjy8hBRUyvvZGFJQrAZ2\n", + "y49hpIPCsjx8LKmXWVtgXhSFePN3gXMNdzrw16TAH0lqBv0N6cCwOynMHsvTDyIF7vg83R6kHl8t\n", + "pN5ma0mh+0T+rCn9FqCitiOF+yZSQLYCq/L+NQ44PW+rVuB7pN5rTwFXkr6Jj8xlaiJ1SFhJqtR9\n", + "Nc+j7VvY3qSD0yHAiPxZ3J+XGXldd86fwWpSBWAT6UC2HbCcVLlpqxhckrfL1DysNY+/Oq9rI+kb\n", + "0HjSgfcE0sF4NqkX3Bjg26QD3E552Vvlz+lgUvhfTPo2uDupZn4I6cD1gyjEije3YQ9CnYjotUea\n", + "fe/Nv3fLHkMg3pWfj4T4GsQREEPbjSeInSD2hVgCcTzElyHuyc+/CvEixIr8mFAy7TshbodYBfEQ\n", + "xLSSeV4BsQziaIhPQNwNcRnEcXk+H4QYnp//HOIqiFMgHoPYtqTcV0A8AXEfxG8gppYsfyTEdvn5\n", + "cIgTIH6GNqxg/MP3MHTVcogP5GWdADEKohHi/XndvghxEMQOEFtD/Divx/g8z10gxkMUIG6BTQt4\n", + "7xUzmX7RKIjfQpwPsSfEXRCfyNN8CmIBxGCI2RB/gLgmfx7/lrfVaogZefxdS7dpB5/joRDn5G36\n", + "nxDPw6bzaKaxm89/XN7+n4K4KZej0+XkaQZD/FX+7K8oWac9IDZAHN7BNN/J8/9ZXobyY5v+/h8o\n", + "8/+ky+3Y7fTNNNBMQxfvb08zh9CcKqCdjCOaaezoM6WZEaXT0swUmvk4zQzOr7ejmZHt1mkiRKdl\n", + "6qIMnZYxjzO8/O1KVL1Ne/cDr75gW+IDYi+INTmkPp3/ue+CmJL/UYd0Mp0g1G7YIIhRJa9HQtwM\n", + "8Vxb+Ofh5+RgH9/FvA+A2I90YHoRogXi3lzWl3IQr4C4EWImxJQ87eEQayEezQeEl/PjEYj/hriI\n", + "dFB6AWJTDs1z8zp/Ly9rVQ7H7SAOgXga4kmIX0AM6qS8N0P8ewrgGJ3X+W6IayG2IR3kni5Zn1UQ\n", + "d0L8EOLb+SBwIMTQvKxnIM7O6/revA5j8nb5YV63n0Ic2/bPDPHPED/Nzxsgirk8V5EOUvtCfAHi\n", + "DojLIS6AWApxK8RhEH+Txz8K4pa8nW7J87sA4jyIYXnb7J6XMZd0EPkuxDqIY8rc746DOKHCfXUk\n", + "xF4dDG/MZbsVYlweNikPuxri/XnYqLwPzMlln0SqUOxSMq/d87bZuQ//B3eFmNxu2BCIbSGGtxve\n", + "kPfTr5EPohBTIVZCzOxk/g2U/K/mef8NFR4Eul8Pouppe3cDV1+wLfUBMZke1l66mPcgiK3bDdsa\n", + "Yo8K5rFjDrwP53/sxvx8aifjD2/biUk1mEmdjDcs/xXELIhfQ0zI/wRDS8Y7k1zL7qKMe0JshPh2\n", + "fn1cDtlBJeP8mHRw2SWH46EQ38rhfTrEcogLIa4r+Uf9Xp72CojHSYH/7Ry8p5O+zdwDcT/p2802\n", + "7cq1F+kbyo9I3yZuytOeDPF1iF3bjb8v6VvFgxAjcsh/E+KPEIty2W4oGX8GxCsQC0kHrudJB86/\n", + "Jn0bEsT0HEQPQPwLxDdIB60XyQfjTrZpI0QT6eD0q1yul/J6j4H4D1JI3wJxG8RP8vb9Vd5250Oc\n", + "kcu0GOJZiItJB9vPkb5FPg5xbV7eyblMl0E8BfEZiOtJlZChpG81Y/K478jLPpN08O+yxtvJ+o3P\n", + "+9wruUwNpArBhXk9l0O8Tvpm1LY//wjid6RvSS+TDqYPQlyZP9+2b02D8vgHQrwG0Zo/+6F5ewbE\n", + "sbX9Xyeqnbbf2tTNuiJxJPC/EXR26wcBDRFvtnG3f/84Ui+o90WwSGIq8HwEr+cT74cAl0XwRsk0\n", + "DaR2zleBWyJo7WDWla7Hh4GVETyau+eeReoZtYp0cvao2PzE/1eAqyN4RmLHXJ69gcNI5w9eI7U7\n", + "30g6gf4B0rUdx5PaoBfm13eTTnBOIJ24nAo8A/yWdAL3VtJ1FXeQTgJfQzoPMQa4KIL1Ep8lte3/\n", + "KvJtNHJvtB1JJx/nkdrOr+dP5xbuJp1v2gs4IoKFEqeQzuVcmtfjfaSTj5DOF3yGdNJzcF7fBtKJ\n", + "xPv4Uxv5aNJndiypff3XpLb4e0lXm/8KeBr4el63y0jt8UuBb+XtuS3phOZrpPbyHYEPRfBy3tZn\n", + "kT77L+d1+wZwUl7Hc4Bvkc6htfXGG53X5cy83Pfksm+VH/vk9yeROlXcBJwCbAucGsEGiUl5mw/K\n", + "j2cieLHfTpRKOhQ4n3QC4eKI+GG79x3q1m8ktorg1f4uRxuJrYGPRXB9fj2ms4NWB9MOJvXq+GPE\n", + "W0/+SwwhncicT+rltRcp9F4gBdtTETzXwXQ7ATtHcGtVK5Xm8RPg9xFcJXEYcAapl9qKDsYVqWdS\n", + "W1BfQgrQ09rWS+IdpB47++THzqSD4L2kLsz7kw6Mz5JCdj7p5OWH88Ho/aTgv510fcvGkuWPIN0W\n", + "5GXgruigJ1we7wukLsa3kTLuLODfIvhZfn846UB4GekgewfphOqHSMG+jnSgeoC0/T9C6vVyZV6f\n", + "l/Pwk0knUjfmR3ME1/ZLqEtqJJ0tP4jUk+Je4PiIeLRkHId6jUhqioiW/i5HvfD2rK3+2p75osNz\n", + "gO9FsKhk+BHAneUeNDuY7zBSL51/jqDbH/rJ18wcC1wcQZfXbeQDy/Wk3jendXRg6Ul29uQujfsB\n", + "T0TEklz7beZeAAADf0lEQVSIX5BusPVoVxNZ1ZpINTGrjSa8PWupiX7YnhEsIzWRtB9+fQ/nu450\n", + "sCh3/LmkZqdyxl1L6t7YK3pyl8bJsFmf8WfzMDMz6yc9CfXeO8NqZmZV6Unzy3Okq+ja7ECqrW8m\n", + "3f/FakFSob/LUE+8PWvL23Ng6MmJ0kGkE6UfJ12Kfg/tTpSamVnfqrqmHhEbJX2Z1PeyEbjEgW5m\n", + "1r969eIjMzPrW73yG6WSDpW0UNLjkv6+N5ZR7yQtkfSQpLmS7snDxkmaLWmRpJsljenvcg5Uki6V\n", + "tEzS/JJhnW4/Sf+Q99eFkg7pn1IPTJ1sy2ZJz+b9c66kT5a8523ZBUk7SLpd0iOSHpZ0eh5em/2z\n", + "lvcryLX+RtJtKqeQLvudB5R9bxI/3tyOi4Fx7YadA3w9P/974Oz+LudAfZCu4JsOzO9u+5Fupzwv\n", + "769T8v5b0xs0bcmPTrZlAfhqB+N6W3a/PScC+Y6sjCKdm9yjVvtnb9TU37woKSI2kO6RcFQvLOft\n", + "oP0VZUcCs/LzWaR7mFsHIuJO2PwnE+l8+x0F/DwiNkS6mO4J0n5sdLot4a37J3hbdisilkbEvPx8\n", + "DemCzcnUaP/sjVD3RUm1EcAtku6TdGoeNiEi/eA16X4RE/qnaFuszrbfdmzeHdf7bHlOk/SgpEtK\n", + "mgq8LSsgaQrpW9AcarR/9kao+8xrbewfEdNJv+f6JUkfKX0z0vcyb+sqlbH9vG27dgHp132mkW4a\n", + "dm4X43pbdkDSKNJNwc6IiM1uPNeT/bM3Qr2si5KsaxHxQv67Avgl6evWMkkTASRNgrf+nqt1qbPt\n", + "136f3T4Ps05ExPLISD/R1tYc4G1ZBkmDSYF+eURcmwfXZP/sjVC/D9hV0hRJQ4BPk+5hbGWSNELS\n", + "Vvn5SNJ9pNt+5Lrt5kUnAdd2PAfrRGfb7zrgOElDJO1E+r3Oe/qhfFuMHDptjiHtn+Bt2S1JIt1y\n", + "eEFEnF/yVk32z57cJqBD4YuSamEC8Mv02TMIuDIibpZ0H3CVpJNJP3j7l/1XxIFN0s9J99zeRtIz\n", + "pB8EPpsOtl9ELJB0FenHhzcCf5troEaH27IANEmaRmoGWAzMBG/LMu0PnAg8JKntzo7/QI32T198\n", + "ZGZWR3rl4iMzM+sfDnUzszriUDczqyMOdTOzOuJQNzOrIw51M7M64lA3M6sjDnUzszry/wFBsEB8\n", + "UlvRigAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(np.vstack([train_loss, scratch_train_loss]).T)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice how the fine-tuning procedure produces a more smooth loss function change, and ends up at a better loss. A closer look at small values, clipping to avoid showing too large loss during training:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEACAYAAAC57G0KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXeYHNWVt98jgXIY5ZyQMNlIJJMMwhhssI0Dxsbr8Dms\n", + "zTpne9e73qa9tnFYrzMYe53WOeyuFzA4YBAYTEYiCQQCCSRAaZQTEtL5/jj3TlXXVHdX9/SMZsR5\n", + "n2ee6a6uqq5Ov3vu7557rqgqjuM4zv5Hv319AY7jOE734ALvOI6zn+IC7ziOs5/iAu84jrOf4gLv\n", + "OI6zn+IC7ziOs59SSOBFpL+ILBSRK6s8/g0ReURE7hGRea29RMdxHKcZikbwHwQWA52S5kXkXGCO\n", + "qh4MvAu4rHWX5ziO4zRLXYEXkanAucB/ApKzy3nAjwFU9TagTUQmtPIiHcdxnMYpEsF/Ffg4sLfK\n", + "41OAFan7K4GpXbwux3Ecp4vUFHgReTmwRlUXkh+9d+yaue/1DxzHcfYxB9R5/GTgvOCzDwJGiMh/\n", + "qepbUvs8CUxL3Z8atlUgIi76juM4TaCqtQLsqkjRYmMicjrwMVV9RWb7ucD7VPVcETkR+Jqqnphz\n", + "vHIxy4EXaUmXNXyhZbkK+I6W9KpGj90fEZGLVfXifX0d+wP+XrYWfz9bi4hoswJfL4LPouEJLwJQ\n", + "1ctV9WoROVdElgLbgLfVOH4QsLOZCwWeAQY2eazjOM5zjsICr6o3ADeE25dnHntfwdN0ReB3AQOa\n", + "PNZxHOc5R0/PZPUIvnUs2NcXsB+xYF9fwH7Ggn19AY7R0wI/EBPqZvAIPoWqLtjX17C/4O9la/H3\n", + "s/fQ0wL/rJa0Wj59PTyCdxzHaYCeFvhm7RnwCN5xHKch+prAewTvOI5TkL4k8M/gEbzjOE5helrg\n", + "mx1gBY/gHcdxGsIjeMdxnP2UviTwPsjqOI7TAH1J4D1N0nEcpwH6mgfvEbzjOE5BPIJ3HMfZT+lL\n", + "Au8RvOM4TgP0NYH3CN5xHKcgfUngPU3ScRynAfraIKtH8I7jOAXxCN5xHGc/pS8JvEfwjuM4DdCX\n", + "BN4jeMdxnAboSwLvaZKO4zgN0JcGWX2ik+M4TgN4BO84jrOf0tcE3iN4x3GcgtQVeBEZJCK3icgi\n", + "EVksIpfk7DNfRDaJyMLw9y9VTueDrI7jOD3EAfV2UNWdInKGqm4XkQOAm0TkVFW9KbPrDap6Xp3T\n", + "+UQnx3GcHqKQRaOq28PNAUB/YH3OblLgVF2J4HcDB0hZetpWchzH6ZMUEksR6Scii4DVwPWqujiz\n", + "iwIni8g9InK1iBxe5VRNC7yWVPGBVsdxnMLUtWgAVHUvMFdERgJ/FJH5qrogtcvdwLRg45wD/A54\n", + "XqcTXcqb5GI5I9xbkDlHEaIP35WegOM4Tq9FROYD81tyLlVt9Mk/DexQ1X+vsc8y4FhVXZ/aplzM\n", + "XC3pPU1fbFnWAYdpSdc2ew7HcZy+hIioqhaxwDtRJItmrIi0hduDgbOAhZl9JoiIhNsnYA1Hnk/f\n", + "lUHWeLxbNI7jOAUoYtFMAn4sIv2wBuEnqvoXEbkIQFUvB14LvFtEngW2AxdWOVdXrRX34B3HcQpS\n", + "JE3yPuCYnO2Xp25/G/h2gedrhcB7qqTjOE4B+tJMVnCLxnEcpzB9TeA9gnccxylITwv8ri4e7xG8\n", + "4zhOQXpU4LWke7t4Co/gHcdxCtLXpv17BO84jlOQvibwHsE7juMUpK8JvEfwjuM4BelrAu8RvOM4\n", + "TkH6osB7BO84jlOAvibwvvC24zhOQfqawHsE7ziOU5C+JvA+yOo4jlOQvibwPsjqOI5TkL4m8B7B\n", + "O47jFKSvCbxH8I7jOAXpawLvEbzjOE5B+prAewTvOI5TkL4o8B7BO47jFKCvCbxPdHIcxylIXxN4\n", + "j+Adx3EK0tcE3iN4x3GcgvQ1gfcI3nEcpyB9TeB7bZqklGWelGXWvr4Ox3GcSE2BF5FBInKbiCwS\n", + "kcUickmV/b4hIo+IyD0iMq97LhXo3WmSHwReva8vwnEcJ1JT4FV1J3CGqs4Fng+cISKnpvcRkXOB\n", + "Oap6MPAu4LLuulh6cQQPTKb3Nj6O4zwHqWvRqOr2cHMA0B9Yn9nlPODHYd/bgDYRmdDKi0zRmyP4\n", + "SfTea3Mc5zlIXYEXkX4isghYDVyvqoszu0wBVqTurwSm5p+ry56/R/CO4zgFOaDeDqq6F5grIiOB\n", + "P4rIfFVdkNlNsofln21gWWTXnnBnQc556tErI3gpy0BgNL3w2hzH6VuIyHxgfivOVVfgI6q6SUR+\n", + "DxwHLEg99CQwLXV/atiWwzNfVGVrw1eZ0FvTJCeF/4P26VU4jtPnCYHvgnhfRErNnqteFs1YEWkL\n", + "twcDZwELM7tdAbwl7HMisFFVV1c5ZVfFubdOdJoc/vfGa3Mc5zlKPU98EnBd8OBvA65U1b+IyEUi\n", + "chGAql4NPCYiS4HLgffUOF9XBX4LMELKkrWE9jUxgneBdxyn11DTolHV+4BjcrZfnrn/voLPd2Dx\n", + "S8u5npJul7LsAYZhYt9bmAysxQXecZxeRE/PZG2Ff74WGNeC87SSScBy3IN3HKcX4QLfGiYDy/AI\n", + "3nGcXoQLfGuYhAu84zi9jJ4W+C558IF1wNgWnKcTIswXqUj5LIpH8I7j9Dr6dAQvZZkkZanwvaUs\n", + "35OyHN/oSUUYBPwSeHET1+QevOM4vY4+LfCYIN8lZTkWQMpyJPD3wGHVDhZhugjn5Dz0dmACDYp0\n", + "mMU6HJvc5RG84zi9hr5o0aQFfjbwI+APUpb5wMeAbcCYGse/EKt62YEIBwKfwHL9G43CJ2J1enbg\n", + "Au84Ti+icKmCFtGyCD5EzuOArwJ3Ar/GXs93qe3RD6azEL8Yi8D/SuMCPxl4mt47y9ZxnOcofVbg\n", + "genAk1rSZ4HrpSzvxCpbKnB0jePzBH4i8DCwk8YFfjTQjgu84zi9jL4s8DOxgU0AtKT/ByBleR21\n", + "LZrBdBbxNmAjJvCjGryekcAmTOB9kNVxnF5DX/bgZ2KpiVnaqW3RDKJzpD0K2EBzEXwU+J0553Uc\n", + "x9ln9MUsms3hPIeRiuBTrCNE8FKWfsGrT5Nn0YwiieCbEfiNwG6gv5Slry1k7jjOfkqfE3gtqWIi\n", + "fjz5Ap+O4F9P5zVi8wS+jeYj+DZgU7iuXrkgieM4z036okUDZtMcQ3WLZkwoKXwwMD7zeK0IfgfN\n", + "WzTQXAPhOI7TLfS5CD6wFhgCLBdhsAh3xge0pDuAZ4GhWKbNsMyxrY7g0wLvmTSO4/Qa+ozAizBF\n", + "hP7h7jrM834aGAEck1nQO9o007FZpmnqefCDG7w0F3jHcXolfUbggZ9hs1DBIvjHtaR7sEheqBTm\n", + "ONA6jc4Cn5dF01UPfmO47QLvOE6voS958KNIctTXkgywDgn/01ZMvQh+kAjpZf+6mkXjHrzjOL2O\n", + "vjTRaUT4A1iCeeyQRO7DsJowYAL/POz15XnwEh7bLcLAcHs77sE7jrMf0Zcsmg6B15L+Wkv6j2F7\n", + "XgS/DpiHlR8YkslNjw1CFOI2YKMqigu84zj7EX3Cogl2SjqCT1PNojkGs3F2kET7kC/wG8LthgRe\n", + "ytI/PH9cANwF3nGcXkNfieCjjZL106F6BH8E8AQmvunjooBHIY7+OzQewY8AtmpJ9zZ5vOM4TrfR\n", + "VwR+ROZ/mrQHH2nHGoQngK2kBX7ONSN5xTv30IIInkp7BjyCdxynF1FX4EVkmohcLyIPiMj9IvKB\n", + "nH3mi8gmEVkY/v6lyum6Q+CrWTSQRPDJY2MeHswhVwr9n0lH8C7wjuPsdxTJotkNfFhVF4nIMOAu\n", + "Efmzqj6Y2e8GVT2vzrmaTZNsVODXhf+dLZrB7QMYtrofx3x/JrznISrz2HcBB4rQX5U9Ba4rFhqL\n", + "uMA7jtNrqBvBq+oqVV0Ubm8FHsRWMcoiOduyNBvBD8cW8mjEooGMwIvQnyHt9prnXHNM2Kcjgk9l\n", + "0hQV6TYqI3j34B3H6TU05MGLyEws/fC2zEMKnCwi94jI1SJyeJVTdMWiWU31QdZnqRT4tVhe+9NU\n", + "RvCDGbpmD+uet43RS+dKWQbz5rNexwE7NqeObaTgmFs0juP0WgoLfLBnfgt8METyae4Gpqnq0cA3\n", + "gd/ln+X9zxORi8Pf/AaucwSwkuoWzVpS4q8l3QbMCsv5pQdZBzF09V6WnbmGYauPAt7F7GuP5vDf\n", + "psscNBKFu8A7jtNSwphm1MmLu3KuQgIvIgcC/w38VFU7ibeqblHV7eH2NcCBIjK685m++aSqXhz+\n", + "FjRwnbUEfjCwhsyMVS3pmnAzPcg6mKFr4eGXPc3AzbOAT7J+9kae9/t0SeFGCo65B+84TktR1QUp\n", + "nby4K+cqkkUjwPeBxar6tSr7TAj7ISInAKKq63N27YoH/yTVI/hOAp+i0qIZ0t6P9udtYufIp4A7\n", + "uPeNq5m4cFpq/0Yi+DwP3gXecZxeQZEI/hTgTcAZqTTIc0TkIhG5KOzzWuA+EVkEfA24sMq5uuLB\n", + "r8EyXLKZOMUFvt+uwQza0I/NU7Zw99//BvgIj58Gw5+ck9q/qxaND7I6jtMrqJsmqao3UachUNVv\n", + "A98u8HxdSZN8FFuPdTiQ7h0MAR4BplY5dgtWeAym3TKeZwft5dkhO7j2i0v0z198VD67fQADtk+S\n", + "sgzSku7EPXjHcfYT+tJM1s3hL2vT5HrwKbZ2PDbuwYk8M3I3aSF+dkgbe/s/DMwN+zcq8O7BO47T\n", + "K+lLAr8l/GUFvqpFI8LZ/OlLryJaNMOeGsfOthilD+woYiZ7b8MW8YauRfDuwTuO02voE9UkMYGu\n", + "FsHHNMm8CP4INs6cRBT4Ie3j2DlyJ0mkPQR4hn57bwdOCMd0ZZDVPXjHcXoNfSmCb8aiGceOMQcS\n", + "BX7QxrE8M3I7icDHnsF1wFmhbnyXPXgpyxgpy9sKnsNxHKdb6LUCL8JIEf4S7qYFPjubtSOCzyzD\n", + "BzCeHW0DOo4ZuGU0O0duJRH44cAWLelj4RwvoDGBj9cViec9GagouCZlmS1l+UXB8zqO43SZXivw\n", + "wATgRSIdC33U8uA3Y+UKsv73OHaOGkCM7gdsbWNn2xYyAh/2vQI4j4ICH6L9wcC21ObowU8HZkhZ\n", + "0pbUHOC4eud1HMdpFb3Zg4+R+iHU9uAHY3VnkmyZhPHsbBvUca4Dt7axY/RmEq88nhcaFHhslajt\n", + "qcU+SJ13OtAfSE+gGkOyaLjjOE6309MC30+E/gX3jUJ+GCamW8kIvAj9MEHdSb7Aj+OZEUOI67IO\n", + "2DqcHaM3kUTasWcAcAcwmuk3DqKYwKej/0jsGcwI92enHhsDtElZilTddBzH6TI9LfC7KB7Fxwj+\n", + "OGB7qM+e9eAHATtV2Uu1CF77DyWuyzpg23C2TthAjkUTIvE/ccRvplBc4LNF1+J5pwNLgINSj43B\n", + "ovqhOI7j9AC9WeBHYIJ5HEmknPXgh2DiDZml+UQYhNk3Q9Eg/gO2DmXLlHbyPXiAexm3eDTNR/Bp\n", + "D34BlRH82PDfbRrHcXqEnhb43YSBVhEGi1SdfQom5Aux+vPRJ8968NF/h84R/DgsffJZEBP/AVsH\n", + "s372OioFPp0Fs5i25eMoVk2ymkUzHBgP/JXOETxY7rzjOE63sy8i+JhJ83HgX2vsOxy4C4umqwn8\n", + "EGoL/FpgG3v7bwMuZPvY7WyZspHOefCRxQxbPYFiEfww8gV+ArbQyBI6e/DgAu84Tg+xLwX+aCqz\n", + "TLKMAFYBK6gt8NGiqVxc26LoNcA29h64A/gX/vzFRWj/9EzWbBT+BP2fGcSwp/NWjspSLYK388Bj\n", + "wOzUoOrY8Hpc4B3H6RH2pQd/BDCpxr7RPnmISg8+Lb71LBqL4J8duBP4H+5702asQYipkBUirSVV\n", + "dratZPKd4wq8lrxB1p3h/xNa0vXAHpLIfQxWEdM9eMdxeoR94sGHAdA55C/eHYn2yRKas2iSCP7W\n", + "D18GvBtrEHZQPYKHHaMfZ8J9Y6hPXgS/K/x/Ivx/lMSmGQMsxSN4x3F6iJ4W+I2YR30IZlcUieD/\n", + "Ctwftm3G6r9EinnwN/zrai3pBjoLfLbUAGybsIwxS4qIcCeBD6mWu0kE/jHgICnLIMyaWoELvOM4\n", + "PURPC/x1wFmYPXMLNvGpWibNCGCLKr9W5cth2yZgeJjgBIlgQy2BT3LP60fwG6c/wuileUsDZsmL\n", + "4AnnjgL/CHAwFr23Axtwi8ZxnB6ipwX+GuBcTOAfwLJNqkXx2RRGwmSnrSQ2TTaCT/vziUVTKfC1\n", + "Bllh5UlLGPXYkAKvZRidPXjC+aPAPwQcSiLwG/EI3nGcHqKnBf42bBLQWSQCX82Hz6YwRtIimRb4\n", + "tZioR2IEv5VE4AdRL4Jf9NZlHLijv5RlVp3XUi2CLwMPh9su8I7j7DN6VOBVeRb4M7Z60v3UjuA7\n", + "++PGRhKbI50muRyYmdqvWgQfs2jyPfjdQ3ew6P9tBj5a5+XkCryW9Fta0pgu+RA23jCOxKLpUYEX\n", + "YYgIv+/J53Qcp3fQ0xE8mE2zG8soqWfR5EXIaZFMp0k+TlLkC+p78J3SJAM7uPkTO4G/k7JMqPE6\n", + "ql1fB1rSLeF655FE8D3twY8BXpJTK99xnP2cfSHwVwJfVWU3VQQ+iFHeTFGobtGsBw4QoS0M3B6A\n", + "Ree1BllR7ZicFNnJlikDgF8CH6jxOuoKfOAh4BRgHfvGohmKFTkrMq7gOM5+RI8LvCrtqnwy3H2K\n", + "/Ah+KLAjDKpmyRV4VRSzaWZgJYaXhG3bgKEiHIgJ3a5QffJZ8gU6ToL6NXBajZeSN9Epjwex9V73\n", + "iUVDIuxFMoMcx9mPqCvwIjJNRK4XkQdE5H4RyY1qReQbIvKIiNwjIvMKPn+1QdZqA6xQaXOk0yQh\n", + "sWkOBxaHbTGCHwesCaIPFsVXE/jB7DlwJTAl/UBYa/XccLdaDyPLQ1hvoR3rUQwLq0H1FLH3MrLm\n", + "Xo7j7HcUEZrdwIdV9QjgROC9InJYegcROReYo6oHA+8CLiv4/NU8+E4pkinSUXDaooFkoDWmYUIi\n", + "8JOwyVWRZ/KeIwwEK7d8aB0wObNAx3zg31LXWETgHwz/28NEqK30rNi6wDvOc5S6Aq+qq1R1Ubi9\n", + "FROsbNR9HvDjsM9tQJtIzQHKSDWBrxfBVxP4x6ku8BPpLPDVnuNPXPulz6FsJ6klAxbRz6yyHms1\n", + "Hgr/23OuvyfoswIvZZkoZSnt6+twnL5KQ1aBiMzEMkJuyzw0BZuGH1kJTC1wyvXAEBGrvy7CiSKc\n", + "S/UUSagUyKF0juCjRVNP4HdSXeDfAJzO9rE7qLRpJgOjsUYpux5rNZ4Or2VduN/TPnz04BsSeCnL\n", + "BQXmAnQ3JwB/v6+eXMrSX8qSXcjdcfoMhQVeRIYBvwU+GCL5Trtk7munHUQuTv3ND354uibNa7Ef\n", + "dC37I+3BZ22X5cCRWL2bx8K2tMA/ndq3agSvyibgvaw7ZCidBZ7wHEUGWK1CJbyIZPJTx/WLcIAI\n", + "J6X3l7IMkrKcX+TcBbEIfuziSVKW2XX2TfMB4PQWXkczzAImSVmKruPbNFKWN0hZPp/Z/P+Ab3T3\n", + "cztOGhGZn9bKrpzrgIJPeCDw38BPVfV3Obs8SWVt96lhWwWqenHOsSuwqPsx4HlY9F0rgk9HwFOp\n", + "7Dk8Hs6xKJWBE2eyTsRqw0RyPfgUS9hw0CBm3JwV+J3AURTz3wHQkt6VupvugRwNXCXCuJDZA9ZD\n", + "+qGU5X8L9hDqYQJ/3rsuBM4EXlnwuBkkywzuK2ZhmU/jgaelLKcBf9OSPtsNz3UwNgEvu62RRtFx\n", + "uoyqLsCW/ARApHmbskgWjQDfBxar6teq7HYF8Jaw/4nARlVdXfAaHsBEHUycZ2OReU2LJuS6D8QE\n", + "P7IWy6pZnNq2Dct4yRtkrSXSq9k8rR87R6SX3ZsM3I5F8IUFPu/6w+0RwGjec8TXpdyRnTQN68HM\n", + "aeSkIpxVpXDbUAZsgcl3Hos1HvXPVZYDsJ5Lkbr43Um0iGIj+xvg2G56rrF0fs+nUcxqdJxeSRGL\n", + "5hTgTcAZIrIw/J0jIheJyEUAqno18JiILAUuB97TwDU8ABwpwgHYAOkDwMnUH2SdCqxMpT2mc+Ef\n", + "SO3fzCCrnWvH6DU8M+KQ1ObJwN9oMILPkK4oOQIUhj99IYn4xp7QMQ2e9wt0jkABhnD0j7ew+qgV\n", + "wAgpSxHRnoJ9NwoLvJTl/G5I/5yF9QSnSlniWrcHt/g5ImOB6RnPfVp4bp8F3CBSlqG13jcpy1FS\n", + "lrf24CX1KVr1nSuSRXOTqvZT1bmqOi/8XaOql6vq5an93qeqc1T1aFW9u4FruB/LepmJeeS3Y41K\n", + "rQh+FJ3tmci9wB2p+00JPAA7Rq1A+80E+8JiPYZFWI+jkAefwzISkRrOhHt3MGjjWJI6OtOwAdlG\n", + "I9U28hcLH8rxlx3Anf/wGHA3xRqOWPKhkMCHkg6/xT7HlhC+4LOw9QCmkCxg3l0CPwb7PaQHlqdj\n", + "351uy0CSsgyXshzXXeffh/wBqDWW9BrgrT1zKX2SN0pZvtXVk+yLUgVZHsCE4RDMI78X+7FVE98t\n", + "2EzTWVi2TgWqXKjKn1Obqg2y1sqiMXaMeYT+uyaGe5OxmbfLwvM3G8EvAuaG28M5/rLHefjc3WiF\n", + "wF9B4xF8vsAfd9mhDNyyl0Vv3UpjAr+c4hH8yeF/Kwdlx2CzjR/ABH42sJcmBV7KcmCdXcZiFt+c\n", + "sH8/7DN/jO61ac4HftcTA8k9ReglngK8vMZux1PZmDqVzCdJsW6a3iDwa7Af7mlYpsm9YXtuBB9s\n", + "mE2YD54XwWf33x3OL1RG3TvCeaqzadr9DNgW7ZTJmF2wPNxvVuDvBY4MP+jhPO/Ksdzx3idBpgTv\n", + "eyrwf8AxRbppUpZ+csSv+wFtjHx8lJTlnanHhjK/dDJ/+dyNaP8RmMAX6RnMAO6k+CDrKdiXsXUC\n", + "f8uHXoayjCTldjaWnttsBH9LNlKWsrxIyhLHLcYCt5L48BOw3uKjdK/An4A1YC+qtoOUpaHxmCrn\n", + "OEjKcp2U5dNdPVcBzsG+ay/Ns+3C9/o4YEqBhve5yhnA9V09yT4X+CDYDwCvxgT+vvBQLQHdiPng\n", + "nSL4KmwDVqX9euDjmJBWZ+3h93DAzoHBl40RfBzIbUrgtaSbgNXAHGZeP4MBWwfy6FlXs2vYNkxI\n", + "pmE/jq0Ui3Dezflv/Av9dvfjNW+6EPiulOX54bESTx+7gXvffDdmM9yFNRwTpSxfqnHO6WHfohH8\n", + "KcAlwOkt86ufPvar7Bi9DmtUYwT/B+DgRp9DyjIaa9iOzDz0DZJ6Q2OxBiSK6XQsgCg6p6NZXgD8\n", + "nCp2hZRlMHC/lGVG3uP1kLKIlOVd2Gu7H3hHD4wpvBy4FPudzs15fCoWcK3A3uemCPZWoUzAvoSU\n", + "ZTqWaLG43r712OcCH7gfi8weVmUtyeSgajQl8OkNqjyuWmcm6p5BS9k2fi8m7pOBp0Je+3Kaj+Ah\n", + "2jTP/+nRrJp7L3rAY2yduA3LIhqLvf67gJdIWU6p030/Htk7jwtfDZMWHg98C7goTFJ6B1ddvgxr\n", + "mEZiFtg44FrgY1KWiVXOOQNraAfnTfSRspyYuj0YeD6WRrsNK/TWdUasGM7Wie0kAn8QNrayl8bT\n", + "N08J/zui/yByM4Fp4TX0B+4hEfhp2MpcLRd4Kcs4KcuA8LyHAZ8EXiZlyfP6T8XGfpq1M34EXIR1\n", + "+T+IBScvaPJcdQkR+VnA1Vhp8HNydjsO6yEuIxlbaYb/g47lPPcn5gMLgtZ0id4i8DHrJU4G+hxJ\n", + "JJ/HBuxHXteiCWyj0n8vyuNsmtaPbWNnkkTwYALf7CArRIGfueAQHjn3VqCdjTOewbzs1VrSPVj3\n", + "rMze/n9g15Az0wenbAWAw3j45Z9i+JNw88euBL6IzcT9D+AbbJo+IFz3yJBXfztwQzh/XnQFiQff\n", + "TkZMpSxTMbsjTk47DlisJd0WztuUTSNlaZOynAcgwmDaHj+A9bO3UGnRPEpY5zYbhUpZBkpZpgbR\n", + "zHIaVmIjbe+MxcZmpmJ+/7pw7rTAd1cE/zOsptFc4EEt6UpsIZyP5OwbP/uGI/gQGFwAnKElfSAI\n", + "xi+x70dLCdH097AGZamWdBXVBf54rLFeRpMNV7DbDgH+n5Sl2qpwfZUzSOXBd4XeIvD3Y0XNHgdQ\n", + "5duq1Mqj3xj+Nx3BF0GVZ9k+djsbDjqWSoG/jq51nxYB5zFk3XBuf+/dQDsbZu8BXkhotLSkX9eS\n", + "jueO9+xl/ZzXZI6/WcrywiByh/G3jz/B5QvhhouXBbG4EWss/gMTsRjBg3Wf3wcsJCcvPpxzOvZZ\n", + "rKWzTXN2+H90+H8KcHO43bTAY6m4Pw6iNJq2ZbBq7g4t6WZsVnS8priQ+delLHdJWc6SslyGjac8\n", + "EF5zlhcCP6BS4GeG/1MxsV+HCc60EIVGi2YFKYGXsoyXshxNQaQsr5KypHsOw7DP5h3YD/n28NAH\n", + "gbdJWV6fOcWZ2Oc5Mxz/DilLUYGejQUM6d7wL4DXdcOg7kex92kR8I9h243AYSEoSJOO4GcBSFk6\n", + "9cqkLIfVsJM+DnwF+CHwT12++hyqjQ9IWQ6WsmTtvqbOL2W5OOezmE8L/HfoPQJ/N/CvVeq/57ER\n", + "62quL7h/UwIPwMMvX8q4xR/CIrsnAbSk/64lvbqp8xn3AIez7EVr2T1sI9DOukP6Y9U6O3olIoxg\n", + "2RkjGLKuI/NFyjIKs0ROw6yL7TxxavyCxOj1U8AbwopSQ7D3qZ8IA7WkO0Ikl87mSTMO2KEl3YoJ\n", + "fPaHdzb2XsZjTwVuCrcX0LwP/xpsQtox9Ns1ijEPw8qT4/dhJWaPPYMJ/DnA3wHfw+Zd7MEmss0D\n", + "zk/7siG99Sgsap6TurZZmA0YBb5dS7oL+4xnUt2ieTPWWBTlEuBjqfsvBm7B0j//kSDwWtKngFcA\n", + "34oNQhg7OAT4FUkEfz5wacH5DEdgwVMHWtKHsc+1S6mZUpYxqdvjgfcD79WSfllL+pfwXDvDtb81\n", + "jAUskLIsxoKCDoEPabYr0j1TKcsIrMG+POuzS1lmYg3f94AvYSmF1ezGZl/f84Hl4feW3t4fWyvi\n", + "2no9BylX2NA3AAAgAElEQVTL66Qs36vxe5gDlLDxx3jMBCwY63IGDfQSgVdlmypfaOCQjWQmOdVh\n", + "K80K/F0X/Y31c57GfhBPZR8WYZ4IVzW4JN4KYD33v34z5uWvY90hAzExTttOh7PyJBiy7vBUNsIL\n", + "gF1YFHgY1pNIL2GIlnSxlvS6sG0o1sBtpnLRj2oCHyNlyETw4cv9YuDrwNxw/1QsUgOzdXZjYwmF\n", + "CdHbsdiM6Rcz/zMnov1g6dnx830Ss2fABP71wNe1pN/Rkh6kJX2flnSDlvQx7P1LL9RyIrBQS/o0\n", + "lhobq5zOwnoe00gieLBg4zyqWzSHYwPV6Qlw1V7XVKwRPl/KMiBsPhfzp7+GDaTFCB4t6T2YYMUZ\n", + "4/PDNT5C0uM4HGscLsk810Apy6VSlqNSm4+kctJf5GbsfUkf32kWtJTljKzAhe2zgaekLPFz/jTw\n", + "8/D+Z/k+1ls5H/uevhV4T7BwHsM+h1dgqcfp780xWCA0AxuwTXMScL2WdIuWdDXwP8Dbcp67K5yK\n", + "fffLme3vwn5L3wJ+I2WptVLafGyG/yerPD4Hs5s/lWoEjgDub4X/Dr1E4JtgA8XtGbBlAm9t8rke\n", + "5RdX3An8b5XnnA+8jNo5vxWED+9sFr82rirVzvqD4w8sLfBHsnUiPDtoJxbJgQn7z7Av+RGYt9yG\n", + "NWJ5X7Yo8JuonLDzEDZLc5iU5Z9SXc6DqCLwmAivBq7CGoe5WGS9JvW6Otk0BSL68zAP+krgLA7+\n", + "/Su55y1Av/jcaYG/DxtPqVY24zfABcGP/yU2+Pvr8NhSEptmJiaUaYsGrPfzT9j7vQILJg4Um0kL\n", + "9p7fRTEf+8WYD70YGzAXTOB/jzWKbyFZLyDydayncTEmLtcQqqQGER6PFUE7V8ryAuh4f7+NBSHX\n", + "SlliAbsjyUTwgVvJCDxwp5TlTfFOCCh+A/xfzkD7C7Be079LWV6KRaCfqfIe3I29h98HPqElvV1L\n", + "+uPwWLRoXol9fw9NHXcs1jO8AHitlCVdE2o6SboyWC/undLamdQnYNH166UsH5KyfE7Kcin2Ot8P\n", + "fB77DT0oZemo7yRlOTTV4zgMG+B+v1gdpSxzsN/yASRjFenFirpMXxX4dSQiVBdVLlXN/aIX4VE2\n", + "T5umJX2NlnRHzuNzMcH7jEjx91NLehd6QKyauZFN04dhBccqBR620X7Ik9BRdfIkLGLZiP2wFmMz\n", + "e58mM9Ep9CqGkCPwoWDXYqx65+eBd4eHXo6NMYC9z2mBPxv4I7AE+5G9jM6DQR0CH7rlXwDuk7LU\n", + "KpH86vCabgSOZ+xDp3Pf320ksYduI/j8WtL7gIOC/ZTHb7GqpDdjP8BDtKSxImT078GE5V4sK2d2\n", + "eK3RwvgqZhc9HRqtlVjOtmA/wE8DbwiNyAeyFkKKs7CMpZ9jYv56rBfxiJZUtaQ/yRaUCzbRe4GX\n", + "AJ/FhDuOAxwBLNGSbsCiwm+HXtQnMdE9E4uWfxuuqZNFk3o/OzJppCzTsEj5c6lB6mPCe7Ia+Hna\n", + "ksEaki+G9+KXwBu1pGvz3oDw/n0TuFFL+qfMw6ux93k+ZntlBf6uMH7wc+AfUo9Nx+yzyJ3Y7+HF\n", + "edfQJCdgjes7sdf7DPZevk5Leq+WdK+W9B1YY/uT1HfgKqwRBxP4a4EPY2NG/UNDEXtfc7DEkq9i\n", + "nxu4wAPwEyp9ze7kUUJFQRFOEOH7mcfnYa36XhqI4gMjgC2q7GHPwI1ov6eoFPgjgFtYeWI7cFL4\n", + "MZ+ARWB/I8kOacPso2wEPwhbg3YPnSN4MJvmy5iQvDb41a/ARBI6R/CnAddpSXdjX8KLMEFPswDz\n", + "4fsD38UGEm8FfpY3sBe2zQf+EER7IdsmrGX9wQ8RBF5LeqmW9EfxmODt5qIlXYo1FJ/Wkl4cuvCR\n", + "dJbMTCyCXIF9hu2p/b6M/ZDjGMAKrGdjYx6Wj38A9oO/CPhKGDB7v5TloPC6BBOcP2Pv5yuwgcgP\n", + "1et+a0mv1ZKepCX9lZZ0T3i96zEBjz/+n2LjUH/FBqhfFiyLq7Dg57zwWvO83IeBUcE7B2uQf4/1\n", + "TN4ftp0dXudbMCFeImW5IDx2PBZdvwP4qJY0+x3Ivp4fhOvJbo8px7dh35FOAh9ufwuL0GNPokLg\n", + "w3kux8S4y4ilq04HHtCSXqElfZOW9DPhe1gx+KklXYAFAM8P4wCzgROCtTUE633+BgvkfovV6XpJ\n", + "OHwO1qv8C/DCVADx3BZ4VbarVvwgu5PHgJkhOj8dEyMARBiERYT3YStavazBc6fr3rdz5z+8l+RL\n", + "DRbB38jD527FunDnY1kR6zCBh8SDf4rOpQrSC6LkCfxtWDZNCROxL5L41ZAaZA1fvmOxaAmscZhM\n", + "Z4F/FJvE8mcsSj4T6x0MBr6TI/IHA2u4WDeLcCjwNW765N8wMa5M0SzYQ9KSnq8l/a+ch5ZiKZb9\n", + "sIj1cezHOZfEokFLuktL+j+p427AovEjsJRQxayD52MDhi8J1/tJLLsDQkE6Leny8HmN1ZIeHwS4\n", + "GZZjkeHicI2Kva8PA6doSdMR7fexVOPH8xrD0Gu4gySKPx1rmP8R+LhYCuxLgD+FQfn3YL2Pz4RI\n", + "dR4WXd+gJc0GPLnUaNSWAr/DGqJDoUNgpxDsKy3pQ1hjGhuJGVRG8GDiebaUZVDcEBrdi6QsV0hZ\n", + "XlXt2kJPc3Rq07HAohDIFOFmzDqNRRJfgEXvD4WemgIfwmyxM4FDw3XOwVJKn8Aa61guPW/cpCn6\n", + "pMD3JGEy1EbsCzcXmCFCTJ86HFiqyk4skjq16HlFGIBNrok/wHau/vb62GUXYQwWAdzHo2eD/WB/\n", + "gGVggH2p1mPRVbUIPvrvkC/wPwBOD8/5K8wa+FXq8XQEPx14JgyOgQn8ktR9oOOH/AcsIn6ZlnRr\n", + "+KG8Eouar5SyfF3K8uFwyDyskTkZ+JWW9H+4892bMOHKZvDcIdL8zEdMhJ+HDbRuDrn7K7H3ZV2N\n", + "467AxKVjKUgt6d1a0ie0pBuxxvcj2A/49WHg7b1Y5EbYvyvzJsAao5NIRXda0vu1pG9Vmx2d5leY\n", + "pVNLKG4lEfj52MSah7HG4VLMokk33tcBA7DewlPhdbeCd2I9vYexxrc/9p24Vyvr/i8gyfzJWjRo\n", + "SduxQCs9/vMWrBFcTu3o/mTgrtRY0fGkBr8L8DesoT8F+00dj2lDx/iKlvRuYEr4vyTsM4XEav4r\n", + "ZlUeSLMJITm4wBcj2jQx6ySmrEVxAvtyTQ3CXIThmD0TI5t2Ktd/jWLSDv1GaUkvw6KCT0FHxsWx\n", + "QVBzPXgqBT6bRUPwEeO4wq+xga505Jr24NNdZrBB54+Tzzu1pBeEtMb4XFswC+tG1s9+ht2DLgl5\n", + "xsdg7+EYkmnro7Av/iAR0gN8E+hajfoHsPfknzF7BpKB81oCfy/2wzufnO6zlnSZlvR/1OYg3BrO\n", + "/xpaO8tyOfZ7rdt9D43Jz0i+m3nchllp07H3O57337DP+vbQAMZzKvBfWPbOHbQILenq0GPahtWl\n", + "mkHn7xrY7+uoEN0fQH6K9FVU2qRvAS7GxkxeGCzIPE7Cgo+YxXMCjQl8jOBPwXojG7CApmIAPTXe\n", + "cif2XXoyjLmAWV7vJOkhtgQX+GI8itkls7DWOq7yMxeLZG1SlP24T8k7QQ7ZZQnXkS/wG7B1YNGS\n", + "rtCSdqyUpSVdHm5WWDQivEqET5AMsEJ+BN+BlvRxYGJmsCwdwR+LZUTE/Z/Ukl5Z5Vy5K1FpSZ/R\n", + "kn6Bbyy9kY2z9mIRZGwkR2MLuQzHBGd9znsyhGQR8YYJjdmrsZS65SKUWHtofH+qWn7hB3cl9iOu\n", + "133+T6wR/rKWtOg8jSI8jqXHPlpvx8AHoGbq8Q3YBLI7gRviZxaE9g1k0jADP8Gqst6Z81greAgL\n", + "Yl5O53Wf78Nsr+nAE1VE8Crg5cFymYVF0VeHHs4dwItD1tibxQrNxeDhBOzzf0mwTk4jsUCL8Aj2\n", + "3ZyLNQy3Yb26bIZU5E7gdZg9FfkrNs7TMv8dXOCL8ijWIi/BPrROAh9oxKYZTmW9nWxZgIOxbut6\n", + "kjVc+6fsoTRZi+Zw7Etaz4OvIB2xpa5pSJjQcQydo6pmaePRs3ZiPu88rOGIQj4NE/sNmMCn35Mh\n", + "kLtqVWHUsnBeh2VmnMfy+XFMoFYEDzvargFg19B6P8CrsCJm3+zKdeawHLPECi1XGKLiqh5yiPJP\n", + "xyyML2ceu1lLem3OMY9hPb3rso+1iIewAf9hVFqFYK+/DZtBnfXfIw9gmnYENiHtl6kIOdpsP8Je\n", + "8zcx2xMs0PgqNrB8ATa+UO05OhEam79httJ2TOD7U1vgJ1Ep8A9iv3UX+H3Ao1g2yKJwe3YQ2qOp\n", + "7AbfhE2LL0I2gs9aNDMxG6EjgsfSrfKqQGYHWUdi0UDaokmvJFWIICbfAf6FTATfRdp45GWKTXrZ\n", + "FXz8+BqnURnBj4OOAdaBdFHgAbSkv9eSXgEMYdXcrdg4yPaaB/38qnu56RPw+a15tW7S596lJf2g\n", + "5qfUdoW/0OIaMmEA8L+1pIXniGhJXx/swe7gQWyg9S3Zxin0MB7ABppzxTcI7fexaP2fMEspciWW\n", + "0jgDK818AXBhGFAejn3PT8NKRmQnVhXhD1haJVgUvwtL0MjjvvB4h8CH1/dDkkmDLcEFvhiPYi1y\n", + "h8Bjrf5S1Yo1YW8HjhIpVK2vnsDPApapsgNQEQZjX/6z0icRoT8memtIIviRWAMxjETgn6K5olmX\n", + "ABdi3flOC6k3SRvLTx+ICXlsIEdjqaZR4LMRfBTWLgt8iqEsOW8T8JW6vueKUwZy7RehVdUyGyQ0\n", + "HC3Lruil/BY4V0taLfK9D3gpNebAaEk/g/2O5mpJ70htfwyL0l+rJd2pJV2MBREfBu4Ig7SLsYDi\n", + "941euJb0Mi1pXBz7duAd1XpboVexEHME0ts/piVtVS8ZsMEKpz7R91yEWR2zsXSnv6R3UmW7CO8H\n", + "fiXCNaodk4fyyPPg03bETJLZeusxAZwFHCHCeFXWhMdGYlbPNmBwmNw0AhPEWSQCv4JkvdfCaEnX\n", + "SVn+AzihhYM/bewZOBTlKqRjgZfR2Be+msDHxqtpDz6HoWyddKCW9F8K7Btnsh4GZCfsOC0gpJPW\n", + "KrJ1HzYxr6Z9EmySJTnbs0kBv8IGYKNF9X1ANZn/0BSh9/HTOrudR41xn1bhAl+MdZivtgiLMg/C\n", + "JrF8LrujKj8U4XZSKXJVqBrBi9CG9RjiIF20V2ZivvxpJJOR2oANqjwrwh4slS167UeSlDVeAUwT\n", + "QRqo4RP5HPllEJrFZrWuOKXE9JtjSthorPbIYcAzquwSyRX41kbwxV9XWuCdfUMsIV7YH6/DrzDP\n", + "/zYALen3WnTeumgo79HduEVTAFVUlRNV2aTKFiwqPh4bVM2jncRTrkYti2YmsDwlxOuxruNUzFec\n", + "nzqujaR88g4sch+JWTJHUjnICplUySIEr7b24iiNYQL/g5tWq1VRhETgj4YO2ytdzbKlFk2wtmKB\n", + "tyIMxz73w1vx/NUQ4TIRWloZcT+ipQKvNuv5SyTVUPc7XOCb41Hg9horQq0HRtepMFkrTXIWlcWU\n", + "NmBivQ6rBTM/9dgoEoHfTiLwi7Bocxt0LI3YlE0jgoSJWa0i1qUZnto2Brvmg0kEvjsj+Gj1NCLw\n", + "d9H9EfzbyB9If84TLJx/pvhCP0XO+ckWTtrqdbjAN8cjWBGhXFTZhRUnqiVGI6gU+HSjMJNkIk58\n", + "7JiwbRE2oSrWEclG8EMwgV+IRajpRqgpgcemqf+47l7FacOsrrTAxwheSKyp7hT4IZn/9RiOfe4H\n", + "ijS8ZGAhQq9iAHCGSOFsrOcUWtLPF00VdQoIvIj8QERWi0juEnoiMl9ENonIwvBXZMCqr/Nx8lcO\n", + "SrMeas5qrYjgQ6OwAxPnvAj+WCyr5llsZuUR4bE2kog3G8FDawT+NJpYMq4GMa1zOHTU9IlTtDeR\n", + "vJ703IDcQdYu9CyGZv7XI35eD9J9Ufwg7DvwaZJVkRynaYpE8D/EUpNqcYOqzgt/n23BdfVqVFmt\n", + "WndN1mzaIwAinCbCyXSe6AQWsU4gP4I/nET0nyZZuGIMiSDuwCLcYVg0DJX53c0K/Imp52sFbeFa\n", + "YgQ/ClifspHi69mS2mcwVoM8G8HfK1KxFF9RmrFoWiLwInxAJHfG8xDs83qQrpVkcByggMCr6l+h\n", + "Itc7j2aWaNvfiamNWd6EpWVlPXiw9Lu3kR/B9ycR/dXQMRA3iWRB8e2YMGwPx++lMoJfSYMCL8JQ\n", + "TNBaMvAXLKiRVAr8aJKUMVvtykgL/BBs0DVZ1s0Kjx3S5LU1KvDDSAS+qwOtp2NjKlmiwG+htdlC\n", + "znOUVnjwCpwsIveIyNUi0q1ZBn2I3AgeE9iTsYlSWYH/HLYk2GwqBT4KXty2ikqBj5koO8L2Tars\n", + "xrINumrRHIfZPSLSEtEZio1PbCAR7zEkr/EJCgo8SeXAWouJ1LqOeN4ixAb5UZLl85plRJXnjQK/\n", + "lcrxCcdpilbkwd8NTFPV7SJyDlZNLXdNThG5OHV3gaouaMHz91aqpUpOw1bBuZCMwKuyQoSfAW9S\n", + "JT2yH3tQMYJfRbIy0WQqI/hJJCmR11OZUtaMwJ+IlSiegDUeS2vvniDCcaqdClPFQeG0eI8mEfVL\n", + "sAYA7PUMFOEAzKJZg5VYjZyO9VKaFfjtNC7wT2auoRmGV3lej+AdRGQ+lZlyTdNlgVfV1EChXiMi\n", + "l4rIaNXOlfRU9eKuPl8fomOQVYS3Ar9Q5RlMYF+DVTXMevBgEy+yNSzWY/5zTA+rG8EDqPL2zHlW\n", + "YBk4Eh4vMuHpJKww10mYyBcS+CDKt4gwVZX0qko1BV41mYauioqwFRO7GMGnF7uej+UwNyPw8Xzd\n", + "KvBh0trWMDgeKRTBNzkpzenjhMB3QbwvIqWqO9ehyxaNiEwQsUL5InICIHni/hykHRgTxPTbwFwR\n", + "RmBe+iNYUbLO06ltAPermc1PAQ+mRGI1MDGcOx3BR4HPazgIA8PPYEWrltTJ049++YlYGeR0o1KE\n", + "GVgAkU0prBfBZ4n7VVg0IkwJ57qZggIfqnHGBZKH0pzArwLGhgasCD+gcj3ReK5qAr8j2GvPQkUt\n", + "fMdpmCJpkr/ASmEeIiIrROTtInKRiFwUdnktcJ+ILMJWur+w+y63TxEHWcdhP9xDseh9RZgZe4fa\n", + "Itt1UbU1H1ObotgOB/aG2bXQ2aLJYwW2fuUU6Milr8Y8LJpcgTUqjWTSxJLK2XGIRgU+G8EPCw3P\n", + "6dhM4vXUKYOcYiYmuGACny7QVo/hJJH4Ooo3dvOw3lqaahH8YJKsJ/fhnS5TNwpR1ZolSlX121iE\n", + "6lQSB1lnhfuHYiK5suoRNch01ddgkfE0EnsGkgg+d85C4Nck67AeFK6pGhcAvwlWySoaE/i4uHVR\n", + "ga82OzHuNzjssxebDDQXKwu7kcrFmmsxHBgVSg/HCH5eA8fGhjTaNDU/y7B4yQRsAttoVdaHxim+\n", + "nizRooGkYVubs5/jFMJnsnYf0YM/CBPeQwgRfFdPHLrwG7EVbp5OPbSdlAdf5djPqvJ7zOc/qNp+\n", + "QYguICmalk7NLEIjAp/OosmStmi2Y1lBQ8O1PIW91qIe/HDoqLY5FIvEG53oBMV9+COxErTXkyzI\n", + "PjRcQy0PHirfH8dpChf47iNm0czCfuAdFk2Lzr8aiz6zEfwgals0kWUkvYs8jsa+H7Fee0cEL9Kx\n", + "+HEHIpyQ8fTnYAOyRT34aqVT0wK/gySynYg1bhspLvAxM2U0zXvwUFzgj8J6U78DXhW2xWJv9QQ+\n", + "vk7HaRoX+O4jWjQHYROYDsIEtVUCvwqrT5MW+GzlyFrUjOBJ2TPhfhzYnQjcIZIsHiLSsYZmevxl\n", + "dtjWVQ8+bdHEDJNh2FjDKhoT+PTzDQnHUmUZxA6CpTOEpPTyUzQm8FcBZ4WB2XRefxaP4J2W4gLf\n", + "fWzEBv9mY930J7GBwVYK/DwqLZq4TFwrIvgzgaszzzcBW7oQbKJWTAP8DlY75SsitAVBPAhb2abV\n", + "Fk06go8CPzJcy7w6q2nFiHgUyXKGRXLhhwLbU4PiDUXwqqzDspdG4RG804O4wHcTIdtiCzYYuAxb\n", + "ULiVFs0qTBhbFsGLWI55KOB1FJWLbEcP/kxM4E4M28vAlap8EVvY+HOY+G3AJlnFuQBfEOF9ZAQ+\n", + "FBobT/XlALMWzbZwjjbMQ09H8G+kdpGudATfiMBny0rUFfhgV8UIHpLCacPD7appkuF2RwMo0r01\n", + "6J3qiPAGEd64r6+jWVzgu5eYwvcEJvDQWg8emo/gV2CWywAAEY4EHgoWzFHAY+mCaqH2/bPAy7Fa\n", + "Oi8IlsMbSOqX/zNm05yN+e/papBHAx/FBD8dwc/BFjepWGQ5RV4EPxtYq8qe8FrbgqBOwUrtVssO\n", + "6zGBxywkJfmcYunjEVjjXCRNMkbwN4e6O07Pczz23e2TuMB3L+1Y3vsuTOA3pXLWu0pc6i4vgs+d\n", + "6JQmCOpT0CEccWHts7Ev9R05h63CMkB+hPn/Z2Cvb1k4ZzvwLUzwo8BHi2YGJmCnYgK/E0vTPZKk\n", + "8csjz4OfE64lllnejQnmVEwUj61yrmHYjOBGLZpcga8zUSzaM3EMIwr8cKoLfCcPXoSBWA9lUp1r\n", + "3KeIMFIk+RxFGN/AZLDeTByv6ZO4wHcv60nqxzxAZQngrhIFvtkIHoIPH4TqQsxLfylwAuafZ1kN\n", + "XK/KJmxl+zLw35l9voo1AksJq1SF888ALsZEfWMQvi1YMbNOM3pT5EXwc6h83dGmmYKNG7y4yrmG\n", + "Y+KcjuC30bjAxwa01vKHp2AzgCPpCH51fE4RThThv8I+eR587AHtE4EXYYgIRUqAzwQOTjV6P6L6\n", + "59CXcIF3qtJOUlfmFiw6bhWrsJmVaeFpVOCjD38cNoHoEuwaX0B+BP8E8Odw+1asPs1v0zuEImlv\n", + "CdvXY8I7FtiFzSK9mcS22IL1FopE8GkPviOCD2zEovLJ2MpTtQT+cZIf7fbwVy8XPrs4i5Jj04gk\n", + "lhfWu7k+9XBckrEjgk+t3hUnauVl0cS68Psqgp8DfCTbWxHpVEhvKqYncQLXqPDX13GBd6qyBisv\n", + "GxfubuWsxEeA7OpZjQyygkXwLw3n+aUqK7DIeA75s2HfiUVmYAJ/vyoPZ3dS5SpVHg4DzdswD/Nx\n", + "VXapcmqqUdqCWT1FIvi0RTObzgI/OzzXH4HjRDoi5GkiHWUThmGNVFWLJmTiZAU/r3b/Sjqnmf4Y\n", + "+GB47nlYYxaJ4xEjsIZPsVWs2kiEsFYEv68W4p6MvfcdvZUwHrA0I/oxbXZ46n9FmmemAewrjCJ/\n", + "1nGfwAW+e/ks8M3uOLEqO1X5embzDpJiVUX4C8lCIrHcxB+AhcHbzj7ntjCwCfAz4PwCz9GOifjj\n", + "OY/Fsri1BD7WZElPdBpIZ4vmSGBlGBi+FTgvPPYV4MPh9nBM4HMHWUM+/B/pnIkzHDqt4PVj4Asi\n", + "9uMPYncsVs//VGBRZlH2tAe/OfW8I8kX+KYieBEmiXBJkX0LMjnn+edi15we+I1lqOPAcCeBx4KD\n", + "l7fw2lqKCB8V4SOZzR7BO/mo0q5af8CzhawjVWa0Hqrcqsp5qnwoVdL3P4EvFDh2e170nkM7Fs1W\n", + "E/h1YXC2GlswkdsdGpcotNkI/kiSVMvLgPeLMAkr9BUHetMWTV4E/zLsPXxPxoLIi+B/go2rxAyi\n", + "KdgA7k6szs/1mf3THvwWMgKfmkwVbbYYwY/DMp6KWjRHYuWoW0UU+HQPIha+OyK1rW4Ej/WyevNg\n", + "8fNI2Xuh0W5I4EUYWq9Ka0/iAr8focoWVc7t4jmWqPK7Vl0TJmzHULnwSGQLtf33uM94ksg2RsVp\n", + "gd+EiU0s/nUFJjjfDM8bbY5o0UzEqnDuplLg34algP4v8KHU+eNyfR0EH/4i4M0ijMcasYXAd7EV\n", + "u/IEPnrw2Qi+H5U2VHzdMYK/j+IWzURqD/42Sl4E/3zs/U/n53cIfKqgWofAhwZsBq1d27fVjMHS\n", + "f6NAD8YK2zUSwV+Nfd97BS7wTnfTjkVG1SL4WvZM3Gckld40dLZoDiUIfPD+L8MspEuojOCj4MeG\n", + "Yjs24DkROA0rrnYJ8N7UDz0vgo8DytcBL8Fsi4XAT7ESDbdkdq8VwYNZHtU8+PsoHvl2h8BnexBH\n", + "YVVJ0xH8NOy9HYZZaOmyDITjD6T3C/xokkJ5sRfXiAc/kfylOvcJLvBOdxPtlzyBXwPcW+f4dK17\n", + "SAQ+XeZ4IyYe6dmw3wU+jWX9xAg+ZrDsIiPwmJVzhSpbVXkUs1smpo6rNn/hGuAcLIJfpMoGVU5U\n", + "7bBaImmBz0bwUJnZE193jODvB8aHKLgeE7EGq6Ec9ODd51kLk7AZzRPDfoOxSPx/CQIfjpuKLUie\n", + "jtzTAh/LYvSYwIswQoRzGjhkDPAwySzt0dhn1UgEP5JeVGLCBd7pbmoJ/D8Dl9Y5ficmtmlvemt6\n", + "li10rF/bUZ9dlfWqfJbK2bTRatlAZ4E/ksrSDA+RpC/WE/izsQHWhVX2AbORhmGikY7g27CJWtUi\n", + "+HFYw7WZYpFhFNBGC5XdTP4EscnYussxgj8cE8FFwGGh0WnDZjk/Fa45Pnda6GZiEX5PRvDnAp9p\n", + "YP+xWGG4WM9oFPbeu8A7ThVioa1OKaIhbfLZzodU7BMnRKVn6T6V2S0KfF49m21Av1AULc58XU+l\n", + "pz8EOAyLQCNLSAQ+2ip517cyXM8YaqxXGwqVbcAyT2IEP5iklMVYzO+NC46nI/i1mCVVxKaJvY7C\n", + "No0Is7AIe1Jmez9MkBemzvt8bIbuxvA6poW/lalrzovgZ2LWVU8K/HEUbOhCL2QM5qGnI/jCAh9S\n", + "QAdRfI2BbscF3ulu2oEnii5PWIW0wN9HkgIZiXn/nVZYCg3EOkxgokivpzKCH4qJeXrA9yHg0PDD\n", + "PxqrCFqNa4B7CrzGdZiVlPXgl2NZONtTpQ22Y172REzgV1Fc4PfQmA8fK4SOy2wfhzWeT6Se+/kk\n", + "tjqGaqcAABLySURBVNoDmE0zFXvvY0rrcKyhyhP4estEtpJjybwPYd2CdhE+GVNcA0Ox9+1vWM9k\n", + "MInAD8qzr3Iss2i3eQTvPGd4CMu37wpbCBaNKntVOw3MbsQEu9oEr3YqBT5r0UzCxCjdQCwhWYXr\n", + "AGqXmfgeFMo9Xxf+b6VS4JdhVkiHbx+EfhtmE6zHIvgimTQTw/kaFfh2OotvXNA93XuYS77AryCZ\n", + "1zAc69VkPfj7gf45E8laThDfY+gcwZ+Drc9wHvC+1PYxQHsYO1mCWXajSHqgg3Ke5gYRHhLhg+G+\n", + "C7zz3EKVe1V5dxdPk47g81gJ3JZZtzbNOkxgom+fjeCPBZZkjo8e/EnALTXOjSpLVbmq7quw64iT\n", + "xbaTiOHjhAg+s/9WYENI56xq0YgwV4SDw0St2GAUEvgQmZ6B1RTKRvCTMaFux9IfR2C2R6yxczNW\n", + "onkOnS2arMDPDNe1GpggwgHhfN3FbMIAaSbSPgObw/DLcE2RsSQN8IOYZTcaCwaqFaSbAXyeZEZ5\n", + "FHi3aBynAWoKvCorVTmzxvH1LJrxVPrvYLbJBOBFdE55bJZ2kkJlO0jy+9diUXD2NW4hGbuo5cH/\n", + "G/CecL61mCgVFc/ZWHG4v4XjSdkRk4GngvW0Bot6HwzF5sAahaXAB7AIPm3RdAi8CP3D63ucIPDA\n", + "m7BJdZ0Q4VSRQguq1OJYrJ5SbEgJaw8cB/w1XF/6/RxDkhAQG/e40tgO8gV+DHAlNlGtP8m6BB7B\n", + "O04DREujWeoJPGQmXIXB38eA19M6gV9HZdrnJMxW2kD1CD4K/CpyLJpQTvgMLE0zrnK1meICfyY2\n", + "KWsNSQT/DhG+E64vDmg/jUXrHRO4Qq/m77HofQmVFs0qYHCInidjM5afIRH440nyzbN8HGsAusJx\n", + "WFZUeuWwk7D6SVvC65qc2j9P4KM91imCDx79gSRrG7ThFo3jNEWHB98k7VRaNDeSjAvkCnxq21Dg\n", + "zi48d5p1JBH8dkxgNmEikifw6Qj+CeDwnMG+UzCxmhfOV1jgg/i+H6srtJZE4Odhs3RfSSLwq4Cz\n", + "sIldHYRsmkNVuYlKiyZmCg3D3vvl4ZAo8PMwiyOPcVjJ6q5wLPa5bSYR+HSFzzyBjxbNQyQWTRT4\n", + "7GSnMVijFQfxx2ACv5m+JPAi8gMRWS0iedUF4z7fEJFHROQeEZnX2kt0nLoefD0qInhVblDlN+Gx\n", + "eN6sRQP2Q1+k2qXnzl5HtQh+APkRfBSdW7Hfa7YU8kuAX2DCciImoEUj+FdjDecfMIGPg6wzsHLP\n", + "6UXdn8YqYN6cOUfs7cTrjQK/hUTwZ5DMg1gTXvfzgWEiuWmM4+m6wB+OZVxtIXkv0gK/ClvRLGpg\n", + "OoJ/BGuUJlDdg0/vHyexjcSybvqUB/9DrKRsLiJyLjBHVQ/GKuld1qJrc5zICiprzzTKOqpPVtqG\n", + "pcfl5bD/gSo+cZPch/m/0Fng47Y0HRF88MEvAT6V2eclWAXMhViGSKEIPvQEPg18JkSha4FxqcVZ\n", + "PodF9jFjZhVwe2aCWZa0RZMW+MkkcxRWY72O1ZgFlhfFjwNGi1RE2IVJFQlrp9KiOQyboEWwizaT\n", + "TIIbG/ZHlZ2Y7XQ4VSwaKgU+TqaLAt93InhV/SvJFzCP87DSqajqbUCbiPTmehNOH0OVL6jyrS6c\n", + "Iv4Q88RpFXBRlfLIf1Xl8i48b/Z8d6tSCne3YxHiRkxEoLMNtRmLeCO/BGaIcDJYeQFs4tTtmMDP\n", + "o7hF8wIsz/6qcG3bsdmoMeJersqb4nKMwLXUL32dtmi2kMzGjemWYMJ+Wrje5WQEPowpDMFstGaj\n", + "+CFY9dEo4iNSM27Xp/ZLD7SmBRus99af6oOs6aybtEXTtwS+AFOoXEh6JUllOcfpDcQfYl7BsGdV\n", + "+X4PXw+YwPfDIvjNmP2RjeAvxnrQQIcV8j1seUUIA6Rh+91hW1GBfzFwdSb9cw1WGE6Dt96BKjeq\n", + "8ss656xm0aQHa1djdtRCzLaZmTlHFM5baV7g20hmN8drGImVuEjPnE778GkPHsyyUyrrBqWpZtE8\n", + "RS+yaFq1KG524Cc3Z1hELk7dXaCqC1r0/I5Ti6oCvw/pWH1Llb0ibCQj8KoVFTMj15KI/otIBotj\n", + "HZxV2KScegJ/JlYaOc1aLPskr25QEaJFE0s7pAU+HcHH691DiOBFGKXKBsyeWYP1Sj7a5HWkBT4O\n", + "smYjdOgs8NkIfkP4bKoNsuZZNHfTxQheROYD87tyjkgrBP5JktVcwKL3vJogqOrFLXg+x2mUWhbN\n", + "viK7vGK6Pk4t7gamiDABE+m44MgKTKCfxESyqsCHJQWPx2yQNF0SeFV2iaCY+GU9+Cjw0XJaiAni\n", + "MSKMA5aLMJak9s4dwPEiDMizz+qQjeBHkGTEpKkl8A+m9o8lpQWYptpROyg6F+uw+QRttMCiCYHv\n", + "gnhfREpVd65DKyyaK7BFlhGRE4GNqrq69iGO06Nsw6ab98oIPvzfQAGBD7Ngb8Dyzw8k1NMPVstc\n", + "VZaSsmhE+IecGaNxScFsg7cGE/5mI3iwRnQy1SP49diYx9MkHvw5mAUykyDwqqzDBqSbieLzLJp6\n", + "EfzYzOO3Aq8Nt6NFcyhJFlHa0klbNKuw2jX9m7jullMkTfIX2Cy3Q0RkhYi8XUQuEpGLAFT1auAx\n", + "EVkKXI7NqHOcXkMqV7k3CnwUokICH7gO+BhwXdpDV+3wuePAogBfxPLZ05yJWT1Z1mK1Zboi8Fuo\n", + "jOCnAnviQuth8fnvhn2jB/9yYC+WmhgjeLAc/Y+KdFrcHAAR/l2EN+Y8lLVoRpAv8E8Dk0MVyIEk\n", + "cxRizaN7wt04yDoZmCrCMKpbNLEuUq9Yx7WuRaOqbyiwz/vq7eM4+5h17B8WDZjAf53MpKMUUdTG\n", + "h/+vxOqvEFauuoDQ686wBssc6arAx/9bsAYjbywBLNodiaV6XoEJfCy3gCrLRPh3bKzg/Jzjz8WE\n", + "9WeZ7XkRfDWLZhIm1utr1Bvajs1qjfME5tB5kDVm0WwiyR6qGVCEBni+aqflHVtGqwZZHae383Ys\n", + "D723kBX432B54UV4AKvMmBeFQyIwh2CTds4KdVhmYLn9PyBnwhJJ5NxViyb+34Jl5WTr9wMWJYuw\n", + "AhPeWzGBH0GSEQRhXV0RpgfvG7BBWez15bkQjVo0B1GZQZMlzjqO6d8H0zlNcmx4nhjBF/HhZwN/\n", + "FGFgrWJ2XcFLFTjPCUIO+u59fR0pKgRelf9WrbkiVAfB5jgqLXiZx2O1ynlYHZ17sFmrVwGfV+Xf\n", + "qghKKwR+C1bXfg+JwFeL4MF8+Kuwxi1aNB25/6psw3of/5A57kSskZos0rF2aqSoRbMKi8r/E/hK\n", + "jWuMHvx4bK7A8zLnW4/1EPphK5BtpUqqpAjDwqAy2Nq2B9LaNXQrcIF3nH1DnNRUrYZ9V9mMZcQ8\n", + "DPwfllr5J1W+V+OYNdhg9Joa+9RjK0kUvwVLL8yN4AP/io3dLcMi6bQHH7kMK4A2MLXtJOAmrN7M\n", + "C6BjkhQUtGhCg78BuEk1mW+QQ/Tgx2MFzA7HIvSN4TzPYu/3ptBwxh5UBeH6rgG+HTYdGf5nyzS3\n", + "DLdoHGcfoMoeEbZRe5Z4V4gCfyUWxc8FPlLnmEeB/2rB6ltpHx5qRPCqVqlThD1YBL+ajMCrskSE\n", + "e4HXEcYSMIH/Ojbn5sQwEPtKbH3cohYN2HjE7XVeU4zgh2ONyqsIOfKpfdaRzAfqZNEEv/3SsM8p\n", + "4f5R4eFx1FjusSt4BO84+46jVJPMjRazGfOoH1ZlhSpvDlP3q6LKRlXe1cXnTQt8jORrWTSR9Zge\n", + "zSRn/V7gq8BHRJCQgngC5tvfimXhfA6zTiDfoom1aSoIM3R31rm2ONFpPCbws3PO1U7SG8uzaE7A\n", + "Jqa9FAusp2ER/EqSejgtxwXecfYRqTov3cFmLFrslsiwBnFwldT/WhYN0JHKugzL4snr1fwBS2V8\n", + "EVblcnXIlb8t3P8B5sfHhTfyIvhsFk1RYgQ/gaRCZVbg11Ep8FmL5u3Ad8Pcg1uwmaqzsFx/t2gc\n", + "x2mIzdhqTD2dGtqQRZNhGTAxzyIKGTdfwQZDJxKWyVNljQgfwgZK34iJcFbgh2GNXZ5FU4S4MPt4\n", + "zEJ6OOdc60gW/KiwaMLM4QtILJm/YYL/GMnM4wrC5LTRqh119JvCI3jH2T/ZjAlRT9NVga81wPsz\n", + "LPPlDapJGWdVvh6ybVZg1keHwIdsnp1YBN7sgPYOTIQ1NJiP0DmtslYEfz62rm8s4XILcDrWG+hY\n", + "aEWE14rwcxHuxno972zyejvwCN5x9k/2lcAvhI7aMRtJVlUqwjLy/Xego0571bUpqBT4tJjH1M1m\n", + "c823Y1VzY/roYqygW5rVJIOsW4GhIhwJfAZ4IVZaInInlm55P/Z6Dw/bP4FlPH0TuLvemEkRXOAd\n", + "Z/9kAfR83r8qfyUsahIE+fgGDr+RrrkKK7CB5d0ZcdwMXcoM2o6Jd+xdfJnOFXQvJdHTrViJhndi\n", + "kf0LVZMlIVXZIcKd2OIjQmLRHAR8X7VLi9tU4ALvOPshqvzvvr6GRlFlEWHFpSZZga3FujGzfQvU\n", + "zZSpRZyUtho6Gq4KgkUUiR78kcCn0uKe4mXhOk/AVtIagdlILS3U6B684zj7Cyuwgcw8gW82gwaS\n", + "SWlFJ4BtxWyio7GJUZ1QZX0YTI4e/CxgWatLFrjAO46zvxAtmqzAb6b5DJo4ULuL4tH1VqyUwuOx\n", + "imYN1mJ58LMoXouoMC7wjuPsL6zE8ujzIvimBT6wneIR/DZssPeOAvtuwZYw/P/t3VuIVVUcx/Hv\n", + "r9IHMwgJxi4D+uDD+OQQDJFI8yT60oWiFAIfeoju0EMiSPrQgwVBD0EEGViEJUViEGRBRRAkkrdS\n", + "KcEBLS8DRSQSKP17WOvk8Xgue2b2OXtm+/vAxj1775mz/LP8u2fv9V9rBMqvi3CCN7O6+J00dUHZ\n", + "j2hgagm+UXvQM8E3rVUwhu/gzczay5OHneHaBP8ezPil80Wm9ogGes9x0zBJmjCt9ATvUTRmVien\n", + "aEnwEXxfws/9hrw8YgEXSENUD/W6MJskvZAt/RGNE7yZ1ck1Cb4MEVOqKj0FPDyFQqVGVawTvJlZ\n", + "Fx+RXrZWJo+6+WwK3zJJWmi89HmDnODNrDYi+LjqNkzDJH14/g5+yWpmVrWz9GlaZ0X0Za3Xaz9I\n", + "iohonb/BzOy6lhdEXxDRfijnTHJnoTt4SWskHZf0q6SNbc6PS/pL0oG8bZ5OY8zMrjcR/NMpuc9U\n", + "zwQv6UbgTdI0ncuB9ZJG2lz6bUSM5u2VkttpLSSNV92GunAsy+V4zh5F7uDHgBMRMRERl4APSYvb\n", + "tvLjl8Ear7oBNTJedQNqZrzqBlhSJMHfSRrX2XA6H2sWwL2SDkn6XNJyzMysUkWGSRZ5C/sjMBwR\n", + "FyWtBXZzZYVzMzOrQM9RNJLuAbZGxJr89Sbg34h4tcv3nATujog/mo4NZriOmVnNTHcUTZE7+P3A\n", + "MklLSLO1PQasb75A0hBwPiJC0hjpP46r3gp7iKSZ2WD1TPARcVnSs8AXpLmWt0fEMUlP5vNvA48A\n", + "T0m6TJp1bV0f22xmZgUMrNDJzMwGayBTFfQqlLLuJE1IOpyLyPblY4skfSnpF0l7Jd1adTtnK0nv\n", + "Sjon6UjTsY7xk7Qp99XjklZX0+rZqUMst0o63VTouLbpnGPZhaRhSV9L+lnST5Kez8fL6Z8R0deN\n", + "9FjnBLAEmEdaNX2k359bp400jeiilmOvAS/l/Y3AtqrbOVs3YBUwChzpFT9SMd/B3FeX5L57Q9V/\n", + "h9mydYjlFuDFNtc6lr3juRhYkfcXkuacHymrfw7iDr5ooZR11/qS+n5gR97fATw42ObMHRHxHfBn\n", + "y+FO8XsA2BkRlyJigvQPaGwQ7ZwLOsQS2hc6OpY9RMTZiDiY9y8Ax0h1RqX0z0Ek+CKFUtZdAF9J\n", + "2i+psfDAUEQ0lhA7BwxV07Q5q1P87uDq+cTdX4t5Lhc6bm96nOBYTkEeqTgK/EBJ/XMQCd5vcWdu\n", + "ZUSMAmuBZyStaj4Z6Xc3x3maCsTPse3uLWApsIK0JurrXa51LNuQtBD4BHghIv5uPjeT/jmIBP8b\n", + "MNz09TAVr7gy10TEmfznJGnx4DHgnKTFAJJup/iK75Z0il9rf70rH7MOIuJ8ZMA7XHlk4FgWIGke\n", + "Kbm/HxG78+FS+ucgEvz/hVKS5pMKpfYM4HNrQdICSbfk/ZuB1cARUgw35Ms2kKaHsOI6xW8PsE7S\n", + "fElLgWXAvgraN2fkBNTwEKl/gmPZkyQB24GjEfFG06lS+mffl+yLDoVS/f7cGhkCPk39gJuADyJi\n", + "r6T9wC5JTwATwKPVNXF2k7QTuA+4TdIp4GVgG23iFxFHJe0CjgKXgafznanRNpZbgHFJK0iPCk4C\n", + "jSJIx7K3lcDjwGFJB/KxTZTUP13oZGZWU16T1cysppzgzcxqygnezKymnODNzGrKCd7MrKac4M3M\n", + "asoJ3sysppzgzcxq6j+vUsbacqJa4gAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(np.vstack([train_loss, scratch_train_loss]).clip(0, 4).T)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's take a look at the testing accuracy after running 200 iterations. Note that we are running a classification task of 5 classes, thus a chance accuracy is 20%. As we will reasonably expect, the finetuning result will be much better than the one from training from scratch. Let's see." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy for fine-tuning: 0.570000001788\n", + "Accuracy for training from scratch: 0.224000000954\n" + ] + } + ], + "source": [ + "test_iters = 10\n", + "accuracy = 0\n", + "scratch_accuracy = 0\n", + "for it in arange(test_iters):\n", + " solver.test_nets[0].forward()\n", + " accuracy += solver.test_nets[0].blobs['accuracy'].data\n", + " scratch_solver.test_nets[0].forward()\n", + " scratch_accuracy += scratch_solver.test_nets[0].blobs['accuracy'].data\n", + "accuracy /= test_iters\n", + "scratch_accuracy /= test_iters\n", + "print 'Accuracy for fine-tuning:', accuracy\n", + "print 'Accuracy for training from scratch:', scratch_accuracy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Huzzah! So we did finetuning and it is awesome. Let's take a look at what kind of results we are able to get with a longer, more complete run of the style recognition dataset. Note: the below URL might be occassionally down because it is run on a research machine.\n", + "\n", + "http://demo.vislab.berkeleyvision.org/" + ] + } + ], + "metadata": { + "description": "Fine-tune the ImageNet-trained CaffeNet on new data.", + "example_name": "Fine-tuning for Style Recognition", + "include_in_docs": true, + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + }, + "priority": 4 + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/Finetune with Flickr Style Data.ipynb b/examples/Finetune with Flickr Style Data.ipynb deleted file mode 100644 index d8cfc7a3925..00000000000 --- a/examples/Finetune with Flickr Style Data.ipynb +++ /dev/null @@ -1,951 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Finetune a Pretrained Network with Flickr Style Data\n", - "\n", - "In this example, we'll explore a common approach that is particularly useful in real-world applications: take a pre-trained Caffe network, and finetune the last few layers using your custom data.\n", - "\n", - "The upside of such approach is that, since pre-trained networks are trained on a large set of images, the intermediate layers capture the \"semantics\" of the general visual appearance. Think of it as a very powerful feature that you can treat as a black box. On top of that, only a few layers will be needed to obtain a very good performance of the data." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we will need to prepare the data. This involves the following parts:\n", - "(1) Get the ImageNet ilsvrc pretrained model with the provided shell scripts.\n", - "(2) Download a subset of the overall Flickr style dataset for this demo.\n", - "(3) Compile the downloaded Flickr dataset into a database that Caffe can then consume." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/jiayq/Research/caffe\n" - ] - } - ], - "source": [ - "import os\n", - "os.chdir('..')\n", - "import sys\n", - "sys.path.insert(0, './python')\n", - "print os.getcwd()\n", - "\n", - "import caffe\n", - "import numpy as np\n", - "from pylab import *\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading...\n", - "--2015-03-17 10:51:07-- http://dl.caffe.berkeleyvision.org/caffe_ilsvrc12.tar.gz\n", - "Resolving dl.caffe.berkeleyvision.org (dl.caffe.berkeleyvision.org)... 169.229.222.251\n", - "Connecting to dl.caffe.berkeleyvision.org (dl.caffe.berkeleyvision.org)|169.229.222.251|:80... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 17858008 (17M) [application/octet-stream]\n", - "Saving to: ‘caffe_ilsvrc12.tar.gz’\n", - "\n", - "100%[======================================>] 17,858,008 287KB/s in 55s \n", - "\n", - "2015-03-17 10:52:02 (318 KB/s) - ‘caffe_ilsvrc12.tar.gz’ saved [17858008/17858008]\n", - "\n", - "Unzipping...\n", - "Done.\n", - "Model already exists.\n", - "Downloading 2000 images with 3 workers...\n", - "Writing train/val for 1903 successfully downloaded images.\n" - ] - } - ], - "source": [ - "# This downloads the ilsvrc auxiliary data (mean file, etc),\n", - "# and a subset of 2000 images for the style recognition task.\n", - "\n", - "# You won't need to run this - we should have already created it for you.\n", - "!data/ilsvrc12/get_ilsvrc_aux.sh\n", - "!scripts/download_model_binary.py models/bvlc_reference_caffenet\n", - "!python examples/finetune_flickr_style/assemble_data.py \\\n", - " --workers=-1 --images=2000 --seed=1701 --label=5" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's show what is the difference between the finetune network and the original caffe model." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1c1\r\n", - "< name: \"CaffeNet\"\r\n", - "---\r\n", - "> name: \"FlickrStyleCaffeNet\"\r\n", - "4c4\r\n", - "< type: \"Data\"\r\n", - "---\r\n", - "> type: \"ImageData\"\r\n", - "15,26c15,19\r\n", - "< # mean pixel / channel-wise mean instead of mean image\r\n", - "< # transform_param {\r\n", - "< # crop_size: 227\r\n", - "< # mean_value: 104\r\n", - "< # mean_value: 117\r\n", - "< # mean_value: 123\r\n", - "< # mirror: true\r\n", - "< # }\r\n", - "< data_param {\r\n", - "< source: \"examples/imagenet/ilsvrc12_train_lmdb\"\r\n", - "< batch_size: 256\r\n", - "< backend: LMDB\r\n", - "---\r\n", - "> image_data_param {\r\n", - "> source: \"data/flickr_style/train.txt\"\r\n", - "> batch_size: 50\r\n", - "> new_height: 256\r\n", - "> new_width: 256\r\n", - "31c24\r\n", - "< type: \"Data\"\r\n", - "---\r\n", - "> type: \"ImageData\"\r\n", - "42,51c35,36\r\n", - "< # mean pixel / channel-wise mean instead of mean image\r\n", - "< # transform_param {\r\n", - "< # crop_size: 227\r\n", - "< # mean_value: 104\r\n", - "< # mean_value: 117\r\n", - "< # mean_value: 123\r\n", - "< # mirror: true\r\n", - "< # }\r\n", - "< data_param {\r\n", - "< source: \"examples/imagenet/ilsvrc12_val_lmdb\"\r\n", - "---\r\n", - "> image_data_param {\r\n", - "> source: \"data/flickr_style/test.txt\"\r\n", - "53c38,39\r\n", - "< backend: LMDB\r\n", - "---\r\n", - "> new_height: 256\r\n", - "> new_width: 256\r\n", - "323a310\r\n", - "> # Note that lr_mult can be set to 0 to disable any fine-tuning of this, and any other, layer\r\n", - "360c347\r\n", - "< name: \"fc8\"\r\n", - "---\r\n", - "> name: \"fc8_flickr\"\r\n", - "363c350,351\r\n", - "< top: \"fc8\"\r\n", - "---\r\n", - "> top: \"fc8_flickr\"\r\n", - "> # lr_mult is set to higher than for other layers, because this layer is starting from random while the others are already trained\r\n", - "365c353\r\n", - "< lr_mult: 1\r\n", - "---\r\n", - "> lr_mult: 10\r\n", - "369c357\r\n", - "< lr_mult: 2\r\n", - "---\r\n", - "> lr_mult: 20\r\n", - "373c361\r\n", - "< num_output: 1000\r\n", - "---\r\n", - "> num_output: 20\r\n", - "384a373,379\r\n", - "> name: \"loss\"\r\n", - "> type: \"SoftmaxWithLoss\"\r\n", - "> bottom: \"fc8_flickr\"\r\n", - "> bottom: \"label\"\r\n", - "> top: \"loss\"\r\n", - "> }\r\n", - "> layer {\r\n", - "387c382\r\n", - "< bottom: \"fc8\"\r\n", - "---\r\n", - "> bottom: \"fc8_flickr\"\r\n", - "393,399d387\r\n", - "< }\r\n", - "< layer {\r\n", - "< name: \"loss\"\r\n", - "< type: \"SoftmaxWithLoss\"\r\n", - "< bottom: \"fc8\"\r\n", - "< bottom: \"label\"\r\n", - "< top: \"loss\"\r\n" - ] - } - ], - "source": [ - "!diff models/bvlc_reference_caffenet/train_val.prototxt models/finetune_flickr_style/train_val.prototxt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For your record, if you want to train the network in pure C++ tools, here is the command:\n", - "\n", - "\n", - "build/tools/caffe train \\\n", - " -solver models/finetune_flickr_style/solver.prototxt \\\n", - " -weights models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel \\\n", - " -gpu 0\n", - "\n", - "\n", - "However, we will train using Python in this example." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter 0, loss=3.786610, scratch_loss=3.163587\n", - "iter 10, loss=2.556661, scratch_loss=8.774073\n", - "iter 20, loss=2.035326, scratch_loss=2.266603\n", - "iter 30, loss=1.943101, scratch_loss=1.703273\n", - "iter 40, loss=1.982698, scratch_loss=1.831079\n", - "iter 50, loss=1.559268, scratch_loss=2.041238\n", - "iter 60, loss=1.464433, scratch_loss=1.836157\n", - "iter 70, loss=1.481868, scratch_loss=1.705826\n", - "iter 80, loss=1.394870, scratch_loss=1.695532\n", - "iter 90, loss=1.055422, scratch_loss=1.867379\n", - "iter 100, loss=1.407976, scratch_loss=1.881758\n", - "iter 110, loss=1.569579, scratch_loss=1.701803\n", - "iter 120, loss=0.951682, scratch_loss=1.764299\n", - "iter 130, loss=0.905122, scratch_loss=1.879305\n", - "iter 140, loss=1.020678, scratch_loss=1.746009\n", - "iter 150, loss=0.784985, scratch_loss=1.739624\n", - "iter 160, loss=0.911735, scratch_loss=1.673230\n", - "iter 170, loss=0.965255, scratch_loss=1.725484\n", - "iter 180, loss=1.028102, scratch_loss=1.676103\n", - "iter 190, loss=0.905020, scratch_loss=1.885763\n", - "done\n" - ] - } - ], - "source": [ - "niter = 200\n", - "# losses will also be stored in the log\n", - "train_loss = np.zeros(niter)\n", - "scratch_train_loss = np.zeros(niter)\n", - "\n", - "caffe.set_device(0)\n", - "caffe.set_mode_gpu()\n", - "# We create a solver that finetunes from a previously trained network.\n", - "solver = caffe.SGDSolver('models/finetune_flickr_style/solver.prototxt')\n", - "solver.net.copy_from('models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel')\n", - "# For reference, we also create a solver that does no finetuning.\n", - "scratch_solver = caffe.SGDSolver('models/finetune_flickr_style/solver.prototxt')\n", - "\n", - "# We run the solver for niter times, and record the training loss.\n", - "for it in range(niter):\n", - " solver.step(1) # SGD by Caffe\n", - " scratch_solver.step(1)\n", - " # store the train loss\n", - " train_loss[it] = solver.net.blobs['loss'].data\n", - " scratch_train_loss[it] = scratch_solver.net.blobs['loss'].data\n", - " if it % 10 == 0:\n", - " print 'iter %d, loss=%f, scratch_loss=%f' % (it, train_loss[it], scratch_train_loss[it])\n", - "print 'done'" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's look at the training loss produced by the two training procedures respectively." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false, - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[,\n", - " ]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEACAYAAABMEua6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XmYFNXVx/FvD8O+DYsCIgpiRAxE1LiiEY0LGvdEo3Eh\n", - "aoxZXkSTGJdouHE3CaAxica4IVETlATEJCohjkrcArIpohFBRFllUUAWmfv+ce4wPUP3dPV09XTT\n", - "/D7P089MV1dX3aquPnX6VNUtEBERERERERERERERERERERERERHZbjQBpgMTw3MHLArDpgODC9Ms\n", - "ERFJVh5xvGHAHKBteO6BkeEhIiJFoizCOLsCJwL3AYkwLJH0v4iIFIkoQX0UcCVQlTTMA0OBmcD9\n", - "QEX8TRMRkWxlCuonAcuwunlyZn430AsYACwGRuSldSIikpVMJZRbgPOBz4EWQDtgHHBB0jg9sQOo\n", - "/VO8/12gd86tFBHZscwD9sz3TI6k5uyXbknDrwAeTfMen9cW7VhcoRtQYlyhG1BiXKEbUGIaHDuj\n", - "nv0CltVXz+iXwL7h+Xzg0oY2QERE4pNNUK8MD7CSjIiIFJkoZ79IcagsdANKTGWhG1BiKgvdAGkc\n", - "qqmLiGSvwbFTmbqISAlRUBcRKSEK6iIiJaQwQd3RpiDzFREpcY0f1B2tsHPbRUQkZoXI1FsCnXE0\n", - "K8C8RURKWiGCenUwb1eAeYuIlDQFdRGRElLIoN6+APMWESlpytRFREqIgrqISAlR+UVEpIQoUxcR\n", - "KSGFCOrNw18FdRGRmEUN6k2wm09X386uIzAJeAd4FqjIYp4qv4iI5EnUoD4MmENNH79XY0F9L2By\n", - "eB6Vyi8iInkSJajvCpwI3IfdpxTgFGB0+H80cFoW81RQFxHJkyhBfRRwJVCVNKwLsDT8vzQ8j6oZ\n", - "sA6VX0REYpfpxtMnAcuwevqgNON46r/1kkv6vxIL6stRpi4iUm0Q6WNsVjIF9cOwUsuJQAssEI/B\n", - "svOuwBKgGxb403F1nu8NrEBBXUSkWiW1b949vKETylR+uRboAfQCzgb+DZwPPAkMCeMMAcZnMc/q\n", - "TF3lFxGRmGV7nnp1meU24FjslMajw/OoVH4REcmTTOWXZM+HB8BK4JgGzrM5Kr+IiORFoboJ+BQA\n", - "R4sCzF9EpGQVKqhvAj5B2bqISKwKGdTXoKAuIhKrQmfqOgNGRCRGhQ7qytRFRGJUqKC+ESu/KFMX\n", - "EYmRMnURkRKioC4iUkIKdeej6rNfVH4REYmRMnURkRKioC4iUkIKGdQ/BdoWYP4iIiWrkEF9A1Zf\n", - "FxGRmBTyPPUNoA69RETiVMhMfSMK6iIisSp0+UVBXUQkRlGCegvgVWAGMAe4NQx3wCLsptTTgcER\n", - "56mauohInkS589EG4ChgfRh/CnA4dmu7keGRjeqLj5Spi4jELGr5ZX342wxoAqwKzxMNmKdq6iIi\n", - "eRI1qJdh5ZelwHPAm2H4UGAmcD9QEXFaqqmLiORJ1BtPVwEDsL5angEGAXcDN4TXbwRGABeneK9L\n", - "+r8S1dRFROoaFB45a0j55HrgM+DXScN6AhOB/nXG9bXm4SgDtmCZfztgIU6deomI1FE7dmYhSvml\n", - "MzWllZbAsdjZLl2TxjkdmB1hWk2BTTg8qqmLiMQuSvmlGzAa2wGUAWOAycDDWEnGA/OBSyNMq7r0\n", - "AhbUm+Eow1GVZbtFRCSFKEF9NrB/iuEXNGB+NUHd4XEhsFt9XUREctTYV5QmZ+qgM2BERGLV2EG9\n", - "+sKjagrqIiIxKnSmroOlIiIxKnRQ17nqIiIxKoagrkxdRCQmhQjqG5OeK6iLiMSo0Jn6RlR+ERGJ\n", - "TaGDujJ1EZEYKaiLiJQQnacuIlJCCp2pq6YuIhKjQgd1ZeoiIjFSUBcRKSE6T11EpIQUOlNXTV1E\n", - "JEaFDurK1EVEYpQpqLcAXgVmAHOAW8PwjsAk4B3gWWpud5eJgrqISB5lCuobgKOw29Z9Kfx/OHA1\n", - "FtT3wm5td3XE+Smoi4jkUZTyy/rwtxnQBFgFnILdt5Tw97SI86t78ZFq6iIiMYoS1Muw8stS4Dng\n", - "TaBLeE742yXi/JSpi4jkUZQbT1dh5Zf2wDNYCSaZD4903Nb/ZtKLfZmf9JqCuogIDAqPnEUJ6tXW\n", - "AH8HDsCy867AEqAbsKye97mt/+3LvWx7nrrKLyKyo6sMj2rDGzqhTOWXztSc2dISOBaYDjwJDAnD\n", - "hwDjI85P9ygVEcmjTJl6N+xAaFl4jMHOdpkOjAUuBhYAZ0Wcn2rqIiJ5lCmozwb2TzF8JXBMA+an\n", - "oC4ikkfFcEWpauoiIjEpRFDfnPRcNXURkRgVQ6auoC4iEpPGDupNqZ2pK6iLiMSoGDJ11dRFRGJS\n", - "6ExdNXURkRgVQ1BvhiPRyO0QESlJhS2/OHx4rhKMiEgMCp2pg+rqIiKxKYagrrq6iEhMCn32C+i0\n", - "RhGR2BRDpq6gLiISk2IJ6qqpi4jEoBjKL6qpi4jEpFgydQV1EZEYRAnqPai54fQbwGVhuAMWYTfM\n", - "mA4Mrncqjibh75Y6r6j8IiISkyj3KN0MXAHMANoA04BJ2M2mR4ZHFKlKL2Dll5YRpyEiIvWIEtSX\n", - "hAfAWuAtoHt4ns3l/alKL2CBvmkW0xERkTSyran3BPYDXgnPhwIzgfupuUF1OgrqIiJ5lk1QbwM8\n", - "AQzDMva7gV7AAGAxMCLD+9OVXzaH10REJEdRyi9gmfQ44E/A+DBsWdLr9wET07zXATCC9pyWciey\n", - "CQV1EdmxDQqPnEUJ6gmsvDIHuCNpeDcsQwc4HZid5v0OgB/TGzg1xeubUflFRHZsleFRbXhDJxQl\n", - "qA8EzgNmYacuAlwLnIOVXjwwH7g0w3TSlV+UqYuIxCRKUJ9C6tr7P7OcV7oDpcrURURi0phXlNZ3\n", - "9osydRGRGDRmUK/v7Bdl6iIiMVCmLiJSQoohqCtTFxGJSTGUX5Spi4jERJm6iEgJKYagrkxdRCQm\n", - "xVJ+UaYuIhKDYsjU1aGXiEhMiiGoK1MXEYlJMZRflKmLiMREmbqISAkphqCuTF1EJCbFUH5Rpi4i\n", - "EhNl6iIiJaQYgroydRGRmEQJ6j2A54A3gTeAy8LwjsAk4B3gWaAiw3R09ouISJ5FCeqbgSuALwKH\n", - "AD8E+gJXY0F9L2ByeF4fdRMgIpJnUYL6EmBG+H8t8BbQHTgFGB2GjwZOyzAddeglIpJn2dbUewL7\n", - "Aa8CXYClYfjS8Lw+6npXRCTPsgnqbYBxwDDg0zqv+fCojzJ1EZE8K484XlMsoI8BxodhS4GuWHmm\n", - "G7AszXsdABM4gI4sSfG6MnUR2dENCo+cRQnqCeB+YA5wR9LwJ4EhwO3h7/ht3wpUB/VT6QvMYvI2\n", - "rytTF5EdXWV4VBve0AlFCeoDgfOAWcD0MOwa4DZgLHAxsAA4K8N0dPaLiEieRQnqU0hfez8mi3nV\n", - "X1N3JHAZ6/IiIlKPwvf94qgCqoAmjdgWEZGSVAzdBIDq6iIisSiWoK66uohIDApffjHK1EVEYqBM\n", - "XUSkhBRLUFemLiISg2IpvyhTFxGJgTJ1EZESUixBXZm6iEgMiqX8okxdRCQGytRFREpIsQR1Zeoi\n", - "IjEolvKLMnURkRgUU6auoC4ikqPGCeou9MDo2JJmjE2o/CIikrPGytTrK72AMnURkVhECeoPYPcj\n", - "nZ00zAGLsDshTQcGZ5hGfaUXUKYuIhKLKEH9QbYN2h4YCewXHk9nmEamoK5MXUQkBlGC+ovAqhTD\n", - "E1nMJ1P5RZm6iEgMcqmpDwVmAvcDFRnGjVJ+UaYuIpKjKDeeTuVu4Ibw/43ACODiNOM6RtGBfrQB\n", - "BgGVKcbRxUcisiMbFB45a2hQX5b0/33AxHrGdVxBX+B4/pMyoIMydRHZsVVSO+Ed3tAJNbT80i3p\n", - "/9OpfWZMKlEOlCpTFxHJUZRM/THgSKAz8AG2BxkEDMDOgpkPXJphGqqpi4g0gihB/ZwUwx7Icj5R\n", - "Lj5qneU0RUSkjsa6olSZuohIIyiWoK6auohIDIql7xdl6iIiMVCmLiJSQoolqCtTFxGJQbGUX5Sp\n", - "i4jEQJm6iEgJKZagrq53RURi0FhBvQ2wtp7X1fWuiEgMGiuotwfW1PO6MnURkRgUS1BXpi4iEoNi\n", - "CerK1EVEYlAsQV2ZuohIDIolqCtTFxGJQbEEdWXqIiIxKJagbpm6ozmOro3UJhGRkhMlqD8ALKX2\n", - "Les6ApOAd4BngYoM04iaqV8N/CFCm0REJIUoQf1BYHCdYVdjQX0vYHJ4Xp8omXor4HtA3whtEhGR\n", - "FKIE9ReBVXWGnQKMDv+PBk5L+25HUywLX1/PPDZhgX8esBtOB01FRBqioTX1LlhJhvC3Sz3jtgc+\n", - "weHrGae6X5iRwEKgdwPbJSKyQ4ty4+lMfHikNorr6UcZ4IDK8KhrAzAKeBK4EOgDvBVD20REtgeD\n", - "wqPR9KT2gdK5sPUslW7heSoex/44pkeek+NXuIw1ehGRUlZfZaNeDS2/PAkMCf8PAcbXM26mg6R1\n", - "vY1l6iIikqUoQf0x4CUs0H6AlUduA47FTmk8OjxPJ9ugPhfYO4vxRUQkiFJTPyfN8GMizqNhmboj\n", - "keHgqoiI1NEYV5RmG9RXYPWknXD0yE+TRERKU/EFdcvO3wZeBubrnHURkeiKL6ibEcA1wMdAp9hb\n", - "JCJSooozqDvG4RgLLAc656NRIiKlqDiDeg0FdRGRLBR7UF+BgrqISGQK6iIiJWR7COo7xdgWEZGS\n", - "tj0EdWXqIiIRKaiLiJSQxgjqzYF1DXyvzn4REclCYwT1NTn04aJMXUQkC40R1Jfk8F4FdRGRLGwP\n", - "QX0nHIm4GiMiUsqKO6g71mM9NraKrTUiIiWsMYL64hzfrxKMiEhEud54egHwCbAF2AwclGKcXMov\n", - "UHMGzPs5TkdEpOTlGtQ9dgfslfWMk2tQV6YuIhJRHOWXTAcxFdRFRBpJrkHdA/8CpgKXpBlHQV1E\n", - "pJHkWn4ZiB0I3QmYBMwFXqw1xu1cAKwPzyrDIxvq1EtESt2g8Cgqw4Ef1xnmcTn+GnB8H8c9OU1D\n", - "RGT70tCr8HMKuK2AtuH/1sBxwOxtxnJU5TAPgGVA1xynISKyQ8il/NIF+FvSdB4Bns25Rdt6C9gn\n", - "D9MVESk5+b783uc8D0dTrOvenXAN7u1RRGR70uDY2RhXlObGsRl4G2XrIiIZFX9QN7OALxW6ESIi\n", - "xW57CeqzUVAXEcmoEYK6j2Mes4D+OU/F0V3d+IpIKWuMTL1fDNOw8ksuAdnRDXgP+HYM7RERKUq5\n", - "XlEaxVexoJwFfy/wFiRGhQFLsaPBZ+G4HtiEnRHTArui9TXgLzjm1zPRoViXBr/EMQXH/7Jrk4hI\n", - "8WuEUxr9U5A4OYu3nA7cBnwOPA38BBIex2RgP+AiYBHQjnU7baHlyl0o2zKQqrJzWLP7fDrMP2eb\n", - "gO1og3UTfDAwGOun5ggcn+a8hCIi8cv9dPA88eBXg28Xnp4Mvks9o1eA/wD8V8B3AD8TvHUU5tgf\n", - "R6+kcfuBfx/8TwFovvpOBt62keGJj3HciAt3S3LsjOMuHI+H5wkc9+J4FkezMOxQHONwNIl5+UVE\n", - "GqLB3QQ0Rqb+ODAF+AswH7gDEteGl5sBD2BdDszGMug/QeKn4fW9sQ7CrgXOAaYD1wNnAr8C7sEy\n", - "973DtN9kl9f+w3cP7o11jrMBn+jA/KOWMeXqh3jvuJsBcJTzSfcXSFStpO3iM4DXsS4P7sQxMuel\n", - "dlQAXwMexTX8w4kwn5Y4Psvb9PPF1s/ZwB9qrR9H67xeYOboCkwAvo3jrTzO5zDgNRyf520eUuoa\n", - "nKk3RlA/HHgIeBI7g2UfYHegCngYaA+MA74MPACJ6XUmMQT4P+BO4FTgBOANG5aYCn4ydveldsCV\n", - "2Jd2Dy4+rB+Tbj+XDw8cwpYWfwrv/SMwEzifpmsPZsjRPahYsJjPW67k778fy7dO+hEJbgL2BF4A\n", - "JuD8TpSvr+K61vsBc7bW7e2g7ReBj3CsxLEz1gfOFmBiWMaf4rgX/DeAFyGxFEc7oAzHahxtsR3S\n", - "tLR95Nh8zgAuBm7C8VIY/mU8U0hwAY6xOPoD63C8l+VnVD9HR+x00iocL8Q0zYexZboDx3Vh2FBg\n", - "BJ91eICp3xvDEbe+gmNLmvcnsM97U9qdmqMlcC7QHJiK41UcfwjL0hU4DJfjrRYdzYEfAAuBf+NY\n", - "hePrwFjgUeygfFdgM45lOc7rCOB0bBtYmTQ8kTFxsPXVDcdHGcarwBKrx3AswrEX8Aku5+6zk+fR\n", - "EfgJcBeOxTiOB1bgmBbx/e1DmzItcwtgY52koRXwWayJlq3b3YH3cfjwa78qhnkUdVAvA/6LBcAv\n", - "YP3FXEdNV5NfhcT6dBOoM7kEFgTfhkQIgv5kbIfxLUg8Br4SW8mdsODqIPE/8LthO5GNwEvAr+g7\n", - "bgAH/fYpnhk1lSUDYP8/7sNXbppBxcLngcF49uGF6zbTZVZn9nx6MWVbOvJptxW0Xl5J+cb+QHds\n", - "p7QOaIntXLoCvwCeAF5kza4T+LjPxbRbtI5Oby/H+sypIsGHwC7UHASegHVR3B3ogd2+bzNwILaz\n", - "uA+4Kvy9hc0tpvHa0B4cdNcmmm6YAfTBDnyvDtP8GOsKeTnQBNtpNgdGUVXWitU9L6LD/MdJ+Bd4\n", - "7G+30Ou5jznkNwuB3YCmYR19BTgP24l2x7pXvgnrZK36s7gE6xp5QWhDJ+D3wEfY8YtdsAPbj2IH\n", - "tE8K6+dY7MD1S2F632T53hfw0QHj6P2vClov20zC/xm4N6yPHkAb4DDgcNiaBVcC44GncCwLX7ID\n", - "gAeBD0K7vh7a9MPQxkuBy7Bfe+8C3cIyl4Xleg+oXqd7YzuQRPh83gbmhXV5D/AplqAcDIwO6+sM\n", - "4MawzjqF9T8deDl8HvuGec3DfiHulDTvKizxeCvMu3tYh0eG9XV4WJYewBGhjU+F7WV/bFtaCryD\n", - "HXtqAnwXS6geBm4Ny/F5WOZ9QhuWYtvWh9i28gG2rbYIr60I71uHHet6BNtpHYJ9vyuwbbVjWCcT\n", - "se/GIGBOWJ/lwM9C23pjv96HAM2w7WgdsFdYxx8An2FxYxfgP2G9Xg/8L6yDZ4EBwI/CPP4ZluV4\n", - "4DTs+zMN+27tin3+C4G/Yzv39eEz3DUs89/CejwmLHszYC12UsZq7ISPWTiqQul2X+Dm8Jm8ht1X\n", - "4kIsDjwd1sOq0PbWWPybgOP9sHNri303mofXWwELcVtjQrEGdRLgTwAGQOJW8D/AgtMGYCAkVuQ4\n", - "izLg58BtkNgAvj32IX0EiVVZTCcBfAP4LTASGMGXHr6Gfn8eRvO1MxnzzABgC3tPWEC7RXuxucXr\n", - "TLv0Q9ovvIFhe36O7amrcJRtzbodRzPzvN+xrP9/+fDLPdnQoRnL+vUGv5ozz/oBMy5cztsnf4d9\n", - "ntiDAaM/Za9/zLV2s4g5Z5zG8n2O4LOOzzH9wtfZWLGRYXtMpsP8e/F8mUUHN+X+l/7Czm98g/0e\n", - "fInXLxnOZxUfc/R1/Rnw8FrKtnTBgkKFfQbMwCdaUFV2Jat6d2LmBR04dNR/aflxb5b1q+CzTmvo\n", - "+fxjwEKqyhIkqgaS4B3gNhzLcbTDJ0aBP54EO2PB5yMseL7L5817U77xbWyneQXQBs/feeXyvqzv\n", - "fDRH3rCc8k27Ayt4zt3J88P7cFWHG2i5+gxW9j6SyTe9yJtnfxULIDNpueJyhvZ5nFYrT8K+xPOx\n", - "L+E04Dkca3B0AE7EfoUdj+3IEmwpb4pv4ijfeH/InvbBvmS/wnFX+Gz2o6rsKsqq2oXl2EhNHbMP\n", - "PrEfCf8WtkNbE5a3DRYEe7K5ZQvWdvkrHRZcHj733bBkpRLHo+Hg/MFUXv8a3aZ7+jw1CAu6O2PB\n", - "YTMW2D7BAv2WMP9yLDj2Ad7EgtA6YCyOj8MvgSPD8JexndJp2I5hWmhnt/D+blhQnwD8C8+twMkk\n", - "KMcCehW281iL/Tq9BxiF7TB6Y79WE2GZ22FBpwL71XgUMBkLhPtjQe+VsCxdwmeyJoyzd5hGAhiH\n", - "YwKOS7BfUudh39fHsUD+Jhb8dsEC3VzsRjtHhLZeEpbtQmyHsQS4JbT/K9itNadiO7AyLAk4Iyzj\n", - "rUAv7Iy818P6uQTbtl7Hvv87Y8lLdVLVJix7h/C5dA/bSqswzr3YDuZcbIf0RyzBOxoL1t2w+058\n", - "Gj6zU8K62in8bYbFwvXh8QscEynuA6XbDOpo2bTvte1rxcDvBv5f4BeAXwb+wDB8v6QDvgeAvwj8\n", - "7eBng+8Ofjz4VeCngj80jHcg+MXgW4cDv78Avyf4n4BfCH5FGPadML9Lw/s6g18C/ofgfwf+AfBT\n", - "wD9D2cZ+HHPVY3SYNwt8kzC9e8DPD/NaDH5amGYH21n5L4B/DPwm8J+Cvwv8teAfttKQfwH8UvC9\n", - "wZ8F/nPwPhyovgL8hWFZF4eD0yPB3wr+1+C/B/6hMO1nwnq5D/zE8DlPBX8T+DfAnwr+kbCsb4I/\n", - "F3zfsB4eB38v+OZhHYwE/5TttH05+KZ1Pqdy+5Xm/wz+bso2fpv+f7qcnv/+K2zZDP6WWqM7mrL1\n", - "Ogd/HPhXwG+m+kB77WkPDOtgXPiFV/f13UOb37V1XOu1tvY5+h+BvzNsE3/IvN1tff+5WGKSBd8k\n", - "xfrpA/7gOuM8AH4u+K+FbaNNdvPZOt02uHzeuMYn7LHN8DLwDnzuFyI2lKM9js6hvNeQ97fF0Y/M\n", - "J2Xk71hcjoq2YZn5g8Cfn2GcBPg/gt8Ygm8X8N8MAfKH4e9Zad57pgXkrc97Y4H+IfB/BX9HnfHL\n", - "wY8Iwftp8Gm6TfBl4E8MAekT8OtCALqu9pfYd8LOTKoMgfg3Nk+/2IKBLwN/TAjQD1mQ9H1tvv56\n", - "8D8Df1V4/Wdh2S8B/wT4y0IAPxt8q7CebsR2HleCbwf+cGwH8TL2663ucjQNr40B/15Y7uqd5V7g\n", - "XwuP6gD6KPixYT59wS8Pf4eF8aaA/2XS53IqNTuU3knz7YDtdM4EPxz8Smzndz62M9gX/PNh2e8I\n", - "n0V/8L3COl4S1sFI8D8P6+tD8APr35YA/Dngt7B1J+B/ZI+tr+8J/vvYTrZ1GNYE/ARsJ7l7GNYT\n", - "/KKwnD3ANwvLMBn86dgOdlXYPpJuQ+mPDuupS9K21NzmAeCPB78e/G8zL0vGZT0e28EcXGd4P/DT\n", - "sR16nZ2Ovzy8Zzn4i9km8Pvm4B8M679ThvmfBv6M3JcjCt8afHmK4W3DNvvFVG/Ke7MaqGgbFh/f\n", - "DPyRdYZ9PQSsI1O/J+20OmIZ9GT7wHNuW+v6p+MfBh9KVv5ALDuP4QsbuX1PgH+RtF1J+N2wTPyI\n", - "EISXhiD8Cfj/2/ZLXeu9l4XANc0+B38k+NtC0EraIfqfYkF/cpj2SvC/SXq9A7YjegT7BTcrfBFD\n", - "duzvAv9OeO/vSZlF+rNC0B0SHg779TIUSx5agj80BKujQkD+Hfh52Cm+J4O/Gfvl+FAI4ivD/B4E\n", - "PwnbAXwU2vlemPbV2C+SadgvyVZ12tUH/Bxsx/4gtkMai/3K2j28tgn7RTMvrP9TwrLuYevRf4et\n", - "v65qTfuLod3fwHa8Z1Ozc0iAfym0fxmWGJ0N/v6wDr6DJQsz7bPwt2IBfTmW/PTFdkxjwnZ7MvaL\n", - "cUrYpkZhCdLhYV5XYInSCGzH++fwmS3Ggvve2C/mieB/y9YdJmCB93Lw/wX//TDsEFLuEHxZaN++\n", - "4XEUts2tCevyVGpt6/6esB6WYknDCeB3rX4x9XadWa41m8HAHVjd7j7g9jqvF21dSAB8P+DkcKwj\n", - "gR2buAMSaxpp/q2Ackh8ksX4rYF1mQ+u+3LsQN4jkKjntE/fFHBYHfZlrNa8CBIxJiQ+gR1H6ovV\n", - "ed/H6rK7UHOwcx5wOyQetCDFvVjtvDPwb+xg5BmQWB6muSt2Om8/4BL7zPyBWF13FST+EQLIfcCr\n", - "Nr1Uy+RbY/Xf3tgJB4vCetjT1ktiVFhHewBrIfEh+J9jp+zugZ2KvBt20PlZLCZchJ0wMAOrS6/A\n", - "Dni2xq7sToR29Q3jnRPaUAmMhsRSao5x7YIdUNwTGAeJiaHdrbBjX4dgB3c/DPO7x06i8CeFeSzE\n", - "jh3cidXuK2w5+A1W65+EHawcE5b7VOAg7GD+IuyY0UzsQP8I7IDooLBcN2PHO4aF6VbXyVeHZVwZ\n", - "3vvr8DndjNXmx4XXvosdsD0QOw7VBPv+PU2BYmcT7CBNT+yLMAP7kJLtAJl6oxlU6AaUmEGFbkCN\n", - "VL9UfFLN1fdPnQ3nrT29wH+tntfbgn8S/AHh+THwl+ewX0ZjwQ+u3X4IGfOZ2K+QxZaN55vvDv67\n", - "2PUw6cbptO269WeA/yf2y+WbScN3C78meoaMfAFWIjwGK411zNCeBHZsrvp4Vn0luYLEzkOxMwqq\n", - "XR0eyRTU4+MK3YAS4wrdgBLjoo3mK0I5pBF3UvmS7oBuPBNv6Btz6aWxO3YKUrVFYZiISBqJ1VbS\n", - "SWwsdEtyl/DxlunikUtQL7qFERHZ0aU4zSayD7GLFKr1wLL1ZPNQ8I/T8EI3oMRofcZL6zM+8wox\n", - "0/Iw457YVVGpDpSKiMh25ASsn4Z3gWsK3BYREREREclkMNYRz/+wiy4kewuwjp+mYxc8gPWANwnr\n", - "5e5Z7IIHSe0BrHOw2UnD6lt/12Db61zguEZq4/Yi1bp02DG06eFxQtJrWpf16wE8h3Ve9gbWYygU\n", - "8fYZ5aIkyWw+9iEn+yVQ3QHVVdht/yS1I7DbHyYHonTrbx9sO22Kbbfv0jg3Zd9epFqXw7Eub+vS\n", - "usysK9ZlMFgvkG9jMbJot88oFyVJZvOxvriTzcW6NQXbMOY2aou2Pz2pHYjSrb9rqP2L8mns8nOp\n", - "0ZNtg/qPU4yndZm98Vgf7rFsn/mI9rooKR4euynCVKzPZ7APfGn4fyk1G4BEk2797ULt03G1zUYz\n", - "FOvb5H5qSgVal9npif0KepWYts98BHWdlx6PgdiHfQJ2x5Yj6rzu0brORab1p3Vbv7uxG04MABZj\n", - "nV2lo3WZWhusc69h2E00kjV4+8xHUI9yUZJkVn3/zOXY3WUOwvbeXcPwbpDjfS93POnWX91tdtcw\n", - "TNJbRk24i3YpAAAA0klEQVTguQ/bPkHrMqqmWEAfg5VfIKbtMx9BfSp2O6qe2EVJ38S69JToWmHd\n", - "jYJ1V3ocVs98ErunI+Hv+G3fKvVIt/6eBM7Gttde2Pb72jbvlmTdkv4/nZp6u9ZlZgmsZDUH67q8\n", - "WlFvn7ooKTe9sKPdM7BTnqrXYUeszq5TGjN7DLv36CbsGM+F1L/+rsW217nY/U6lRt11eRF2D9BZ\n", - "WE19PLWP72hd1u9wrI/3GdScEjoYbZ8iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIikk//DzX8Jz0M\n", - "ra0pAAAAAElFTkSuQmCC\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot(np.vstack([train_loss, scratch_train_loss]).T)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Notice how the fine-tuning procedure produces a more smooth loss function change, and ends up at a better loss. A closer look at small values, clipping to avoid showing too large loss during training:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[,\n", - " ]" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEACAYAAAC57G0KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXe4JGWV/z81Odw7OScmz5DzEEQYdJUgAioqqGsWTAs/\n", - "d1dXV11rjWvOAQMKiJhFRERQHBRRchgYZpicmByZfGemfn+c9731VnWlvre6+/blfJ7nPrdDdVV1\n", - "dfe3Tn3Pec8LiqIoiqIoiqIoiqIoiqIoiqIoiqIoiqIoiqIoiqIoz2t6Ao8Cv0t5/mvAYuBx4MR6\n", - "7ZSiKIqSTo+Cy10DLACChOcuBKYDM4ArgW+Xs2uKoihKZygi8BMQEf8+4CU8fzFwvbl9PzAEGF3K\n", - "3imKoigdpojAfxl4P3A45fnxwGrn/hrkpKAoiqI0kDyBvwjYiPjvSdG7Jf5ckpWjKIqi1JFeOc+f\n", - "iVgwFwL9gEHADcAbnWXWAhOd+xPMY3GWANM6vKeKoijPT5Yiec6acg7JVTQXAreb26cD/0x5fYDP\n", - "Snwmd3gPfAbgs6fDr+9e+I3egW6E3+gd6Gb4jd6BbkaHHZG8CD5tQ1eZ/9ci4n4hEqHvBt6S8fp+\n", - "wL4qt+nSBvTuxOsVRVGeN1Qj8PeYPxBhd3lvwXV0VuAPAr3w8fDV51cURcmiaB18WXRO4EXUDyED\n", - "r57vzGv0DnQj5jV6B7oZ8xq9A4pQb4HvA+zv5DrUphHmNXoHuhHzGr0D3Yx5jd4BRai3wO8vwVpR\n", - "gVcURSlAvQW+M/675SAq8IqiKLk0o8C3UX31j6IoyvOOZhV4jeAVRVFyUIFXFEXppjSjwKsHryiK\n", - "UoBmFHj14BVFUQrQrAKvEbyiKEoOKvCKoijdFBV4RVGUbkozCrwmWRVFUQrQjAKvSVZFUZQCNKvA\n", - "awSvKIqSgwq8oihKN6XeAr+3hHWoB68oilKAZo3g1YNXFEXJoVkFXiN4RVGUHFTgFUVRuikq8Iqi\n", - "KN2UZhT4g6gHryiKkkszCrxG8IqiKAUoIvD9gPuBx4AFwGcSlpkL7AAeNX8fSVmXCryiKEqdKGJ1\n", - "7APOBfaY5e8FzjL/Xe4BLi6wrs6iAq8oilKAohbNHvO/D9AT2JqwjFdgPdpsTFEUpU4UFfgeiEWz\n", - "AfgLYtW4BMCZwOPA7cBRKevRgU6Koih1oqhQHgZOAAYDf0Q893nO848AE5FI/wLgFmBmxVq+zpvN\n", - "85jXz6tYJp82YEAHXqcoitIMzDV/DeGjwH/mLLMcGBZ7LMBnVqe37vMBfD7X6fUoiqI0B0FHX1jE\n", - "ohkBDDG3+wMvQSplXEYTevBzzO0kn149eEVRlDpRxKIZC1yPnAx6ADcCfwauMs9fC1wGvAsR3z3A\n", - "5SnrUg9eURSlThQRyvnASQmPX+vc/qb5y0PLJBVFUeqEjmRVFEXpptRX4Od97EAJa1GBVxRFKUCd\n", - "Bd4vQ5i12ZiiKEoB6m3RlCHwGsEriqIUoN4C36eEdajAK4qiFEAjeEVRlG5KMwq8DnRSFEUpQDMK\n", - "vA50UhRFKUCzCrxG8IqiKDmowCuKonRTmrGKRj14RVGUAjRrBK8evKIoSg7NKvAawSuKouSgAq8o\n", - "itJNUYFXFEXppjSjwGuzMUVRlAI0YxWNRvCKoigFaMYIXgVeURSlAM9fgfd5HT6zO787iqIoXZN6\n", - "e9ldqdnYa4C+wMIS1qUoitLlaNYIvowTU39gUAnrURRF6ZI0o8AfAnrg43VyPSrwiqJ0a5qvisYn\n", - "oBybRgVeUZRuTZ7A9wPuBx4DFgCfSVnua8Bi4HHgxIz1lVX9UpbADy5hXxRFUbokeV72PuBcYI9Z\n", - "9l7gLPPfciEwHZgBnAZ8Gzg9ZX1lCXwZPrxG8IqidGuKWDR7zP8+QE9ga+z5i4Hrze37gSHA6JR1\n", - "lSnwatEoiqJkUETgeyAWzQbgL4hV4zIeWO3cXwNMSFmXCryiKEqdKGJzHAZOQPzqPwJzgXmxZeIV\n", - "LUHyqq44F/DNnXkJ6ylKWQKvHryiKF2Nueav01TjY+8Afg+cQlSY1wITnfsTzGMJ3PwA/NSvZgdT\n", - "6FzDMZ8eyCAnjeAVRelqzCOqsR/r6IryLJoRiKcOEvG+BHg0tsytwBvN7dOB7Yidk0RXsWj6mf8q\n", - "8IqidFvyBH4scDfiwd8P/A74M3CV+QO4HVgGLAGuBd6dsb6uIvD9geeA1hIGTCmKonRJ8myO+cBJ\n", - "CY9fG7v/3oLb62oC3xMYAOwuY6cURVG6Es3YbAw6P9CpP7AXuYIZjAq8oijdkGbsRQOdH+hkBX4H\n", - "6sMritJNqXcEX8aMTlCORbPX/KnAK4rSLWmCCD7wIIjvpwi8z0x8BnZgP6zA70QFXlGUbkoTCDxv\n", - "BT4Xe8x68D8AbuxAJYwr8DrYSVGUbkkzJFnHAFNij1kPfhzSKuFb+MwEluC3l29moR68oijdnmaI\n", - "4FuAUbHHrAc/FngZMnr2Z8Br8RleYJ1q0SiK0u1phgi+lWSBHw4cxudp4OUA+MwFXo/0p89CBV5R\n", - "lG5PM8zolBbBTwLWxR7/HvD2Ap68evCKonR7msGiaQWGQNDXeewg0uAsLvD3ICNTk0bfuqgHryhK\n", - "t6cZBL7F/B/pPNZGksD7HAbuAF6Ys061aBRF6fY0g8C3mv+uTZNm0QA8Apycs04VeEVRuj3NIPAt\n", - "SPvhuMAnWTQAD1OdwKsHryhKt6QZBL4VWEp0nteDyIQd6xOWXwAckTPCVT14RVG6Pc1SRbOUygge\n", - "kiJ4nzbgKWSawTTUolEUpdvTTBF8MYEXHiG7kkYFXlGUbk8XF/igNzIYayXVC3yWD28FXmd1UhSl\n", - "29LFBZ4WYBeSZI178G3AlpTXPUyRCN7nILCHsFJHURSl29AsAr+Rygh+PT5ByuueBGbhp7ZisBE8\n", - "wFZgWJX7pSiK0uWpt8ADQc8qFm5FbJQkgU+zZ8BnPxL1T0xZwhX4bajAK4rSDam3wB+gukoaG8Fv\n", - "AkbK5B9AnsATeGyftJ/KNsOWeAQ/tIp9UhRFaQrqLfDVTrVnInhvHyLIQ8zjS4G/Z7xuICvmTiPw\n", - "pqY8rxaNoijdnnq3C65W4G0ED6FNsw2fO5CeM2n0Y9s0j8O9poUFNxFU4BVF6fYUieAnAn9BBg89\n", - "CVydsMxcZFToo+bvIynr6mAED1T68Fn0Y9sUCHpMT3leBV5RlG5PkQi+DXgf8BgSUT8M3AU8HVvu\n", - "HuDiAuuqNoK3Ar+d0KLJox/bpwBBpQcvNe/xJOvIiuUURVGanCIR/HpE3EHskqeRuVDjFBks1JEI\n", - "3lo01fSNkQi+x6EjEp7rjcwEddDc1wheUZRuSbVJ1snAicD9sccD4EzgceB24KiU13ekisZG8Dmd\n", - "H4NpELzI3OnLrrHgHW7FZ0BsQTd6B62iURSlm1JNkrUF+CVwDWFUbXkE8er3ABcAtwAzK1fxn0Ph\n", - "d1cjfvo885dFK7DW3M7rG3MRcCpwN9CPoAcc7Lue3vsmIx0mLUkCrxG8oihdhbnmr9MUFfjewK+A\n", - "HyPiHec55/YfgG8hork1utgX1sAXrgPvoYLbdSP4PItmNCLeAP0AONCynt77pqICryhK8zCPaPD7\n", - "sY6uqIhF4wE/QETyKynLjCb04OeY21sTltuLFd9iuB583uQco511y/+9wzdQOdgpLvCVI1l9zq5i\n", - "HxVFUbokRQT+BcAbgHMJyyAvAK4yfwCXAfORZOxXgMtT1lWtwFcTwY8hHsHvHL+FfIGPRvBSZXM3\n", - "vrYRVhSluSli0dxL/ongm+Yvj32EIlyEaiN4O6pJBH7r9K1MvXtabLm4wO8BeuLTD5995rU9zbZ3\n", - "VrGviqIoXYp6tyrYS3UC31EPvi8A60/cQV4ELx0p3UqaFvNfWwgritLU1FvgbYQMBD3kL5OCEXzg\n", - "IaNcoxbNinOeA6bEJvSIR/AQtWlaY/8VRVGakkZG8O8lvaWBJV4HnxbBD0Hq66NJ1i0zbb94t859\n", - "OHI14OImWjWCVxSlW9BIgR+JiG0W8ZGsaR78GKSVQTSCD3r2A5YBblfJU5B2Cy5uBN8S+68oitKU\n", - "NNCioT+ZFTWBBwwkatEMcnrCu4wGVhAV+MDcX07Uhz+dypG46sEritLtaGQEPwCbDE1mALAPvENy\n", - "19sPHCb5pJAk8DaiDwVe2hbMRko9XdSDVxSl29HICH4A2TXxg4mOkIV0H340sEZuBr1IE3iZiHsB\n", - "fmaSVSN4RVG6BV05gp+KROUuaT78GGQOVrv+vkjitB9RgT8N+GfC6zXJqihKt6PRAp8Vwc8EFsUe\n", - "y4rgXYHvh4h2PII/jUr/HSoj+INoklVRlCan0RZNVgQ/C3gm9lhaLbwVeDtS1rVoVgBH4NMTSbAm\n", - "RfBukrUV6YGvEbyiKE1NF4vggzEQ2JLGWVRG8GY0a3AmBK93Hh+NiLIbwW8H+uGzB4nmvwhsQibs\n", - "jhOP4NehAt/98bkNn5MavRuKUisaIfBZEfxbgM+a2zNJj+AvQhqcWVyLph9RiwbEprkcuBQ/GArB\n", - "CbH1xgX+WVTgnw9MACY1eicUpVY0wqKxoptUBz8MmAtBbyTJujj2vO1HcyQywQimLj7LgwdphPZy\n", - "fFYDrwI+EVuvm2RtRSP45wsD0dm8lG5MNTM6lUHcookPWhoKjAAuBNaDFy9ntEnWIwl/mMOAPeDt\n", - "g8CtoglHtvrc5KxjitmGyw6g1fj0LUjv+9M68P6U5mIgOtmL0o1pdJI1KYLfDLyTSnsGRIhHIHPD\n", - "DoWgLzANaUdg1+9G8ElVOlORNgkhPoeQk8cQ1IOvPz5nxBrC1QsVeKVb0+gka9yDHwb8FjiPygQr\n", - "iAifBKxGfPLxiMDbxKnrwbu9aVwSIvhgCvtbDyBXBeV78D7vwa9qopPnG7dS2da5tsgJRS0apVvT\n", - "IIEPehHt/mgZBvwasW6SIvidwMnA04jIT6RS4JM8eJepwGDj81tezI6JA8z2a+HBf5JowzMlyiDq\n", - "H0n3QSZ20Qhe6bY0yqLpj8y+FI/ghwJPIuL+dMLrdyCR/0KkNcEERDitRRMvk4wJfNBqXr+JaCfL\n", - "I9gzogfyY28BNiIllj2rf4sxfPog1k/WbFTPX3z6ImJb70h6oPlfW4H3+R+d41dpFI2yaAYgAtw7\n", - "NunHMKRk8cXA3Qmvt1PopUXweR78FGTg0yaiPvwkdo/qQyjwO5Gp/AbSeex2hpSwru6IvVKqdyRd\n", - "H4GXwXXH1ngbipJIoyL4AcBuYD/tUXzQD+gtj3trwDuc8Ho7UYcV+Akke/B9kUZlPSFwo/ApSLS/\n", - "iagPP4ndo3pzYOAY5Ie/27y+DJtGBT4b23qiEQJ/kNpfOQwhf94DRakJ9Rb4/YiItyAR8n7CKHso\n", - "sBW8IOW1EEbw1qKZgQi16STJXsLqnP1UTvI9FRn0tJm4wO8bGrBv8AxgPz4HKU/gR5n/tbVofL6C\n", - "z/SabqM22GMcFVqfL+PX9KQ4EFhL7U8sg1GBVxpEnQXeCxDRHYaI8T5CH34oYqtksQG4HrztSAR/\n", - "JrAy7BnPXuQH1WYei0/ybSP4zbRH1kEPYAIH+6wDbxrhBCNlC3ytI/i5yPiAZiMtgn8ztbU2rMAP\n", - "KiXXko5G8ErDqHcED6HA7yFaF2/99wy8veC92dxZjVwJLHMW2IecKPaZ+25rBAgjeNeiGQNs41Df\n", - "DfRom0DtBL7WSdZWKgdwNQOVAu/TCxHGaTXc7kDkijBjMvdSGExzfi5KN6CIwE8E/gI8hVS4XJ2y\n", - "3NeQ1gKPAydmrG8vEtFYi8ZG8AUEPsImpBLHbR62l6jAxy2aKVRaNJOAVbQN2EDvvWMIBX4X5bQM\n", - "HoVEirWO4FtoTiFpBewYBIu9XWuB3020D1G5+PQ229EIXmkIRQS+DXgfcDRSEfAeKq2AC4HpiCd+\n", - "JfDtjPW5Al9lBO/iHUa897jADyEawRuBDzyiAm+TnyLwB1rW0WfXEMJZpMpMsj5DmVGiz634HBV7\n", - "tJkj+FVERdYKYj0E3u1DVDb26kQFXmkIRQR+PfCYub0LqWAZF1vmYuB6c/t+RGRHp6zPtWjcCL6I\n", - "Bx9nOdEBUVbg9zv37QlkPLATvOeIWjRHAKvY37oKL/CojUWzmHIj+DORuWUF8ZD707wCv5JKgW+j\n", - "fhF8rSpphiDf6fIF3uf4BrV3UJqIaj34yYj9Ep8VaTziiVvsIKQkSorgAXgtcEds3XEP3lo0bn/5\n", - "uEWzkj0jVpj7UYH3ORu/U8PoRyEnoXIE3qcVOX7u8bVWUjMKfCsi8K7IDgeeoLajf2tv0chnvgoY\n", - "YAa8lclfoCmrpqL4vAC/PU+llEw1At8C/BK4hlAEXeLRRFK5ow/XjIJ3vgCuH0bnPHjA2+xU0EBl\n", - "ktX14LMEfhXbplqrJx7BXwu8sbr9imAjeGPRBEMhSJp2sCiTzf/xzmP2SqMZBT4tgn8a6I+fOEVj\n", - "GZRv0fjMwo/kbQab9Zd7EpFjMpTKK+ly8fkMPkfUdBvwMeCCGm+j2ZgL+M5fhykq8L2BXwE/Bm5J\n", - "eH4t7f3ZAYku1yYs58NXF8F3NsCbnqHzEXycvciJqEgEP9L48iLwOyetoq1/wKHeeyC4nwMD9iEH\n", - "ehZwSif2KW7RfAB4byfWN9n8dwW+BThMcwq8nSKxp9OQzXYVXUbtbJoWyrdovgS8y7k/BBmct4Vy\n", - "bRr7Wxtb4jqTuAyYU+NtjMNWmvmcj8+Pary9ZmAedRR4D/gB0iP9KynL3EoY5Z6OtCHYkLKstWj2\n", - "0nkPPmndkFwm6czx6u0BDiE/cvHgYQN7hnusO2kUMIctM/sCLwRuQBqchfi8EZ9zcvfGZyByjNcQ\n", - "JlkH0bkf+xRkoJdr0bQiFll9knl+an6lIwxCRHAbodAOR0RxKWUJvM9v8Lkfv/3kWguLZizwcuf+\n", - "YOS3ULbA21moai3wo6htHgRE4G3Bw3S6g+3UhSgi8C8A3gCcCzxq/i4ArjJ/ALcj0dYSxNJ4d8b6\n", - "OlEHn0tc4F2LZibRFsSbgTchrYE3g7ePfUMOsWbOMUDA5tkDzHKfBPrgMw6CKRC8D7gEeEWB/RmJ\n", - "NC7bhTQvs2VznamomQzcS6VFswoYjE9PfMbiM6sT20jHZxqwypy8ymAQYoe5QisCv3fIszzxureX\n", - "tJ05SHXXJ839Wgj8GOA0/PYrqVpF8Fbga2fRyNXUIGop8D79kZO69eBHO7eVEigi8Pea5U5AEqwn\n", - "An9AhPxaZ7n3Imff44FHMtZXVh18ElbY3Sqa/qbPzTik6sayCfmxf7i9PcKBlv1snzId+B3rTuoL\n", - "3IPPEuBhJIo/BrjCrCse1V+W0DVwFLARn4BwusEBpCVcJcKcmfMepwB/B8Y7VRQtZv07kB/M24DP\n", - "56yno7wP6f44Pm/BgrQig40qI/h1J+0n8E7v9BZk4NRI4CYk4dmXqAffeYvGpwdikd2JlA1DNIIf\n", - "gU8rfimjcychwVQtI3grtCLwPqfgc37J27AnKLutMTS7wPtMq/HI6KpoxEjWvYio1yOCtx78dGAF\n", - "eG3OspuRRN6t7Y+0DdhDj4OLgX9y3/sPIF0tAR5CBN0OJhoHnGh+1JY3I2MEwGcKPp9GIpKN5vnt\n", - "iLAPxAq8j4fPGHN7LBJlnprzHicjA87cwUGtSBRsk8ezgLNL/6L5DAdeR6VF1BnSI/j1x+9k8KoB\n", - "qa8szhhgMz5tyIl9FOVH8MORE9UvkbJhkM95O/K5DEeCgx+WsK1JwD/pqMD73ImfW6E0Cjk2NoJ/\n", - "E/CRDm0vnXHIb9VaNKORq9B4G/FkREy72hiDXyFuR5egUa0KIBLBBz2QH/r2Tq47zYN3E6yWXwJX\n", - "R5qbPfL2B3j25B8gkf4UM5UfhBF8C96h4cgPawcysMtyDHC+sWGuBD4EvAMRFMzyQ5AI3lo0rwSe\n", - "MBGmjf7zIjw7WGstYRTdithArsAPQK66yuQqJMn+MOVH8JUC//BVGxixqDcf7ndS5hp8jsTPTEZN\n", - "IGxIt4HaCPwYs+7bgZeak+tgohbNacAJsUqbjjAJKVWuXuBlv86BioFycUYjn/MYI7inAmfgl1pS\n", - "Oh6YTzSCh/iUmul8AvmNZSMngrGxx67E5/KC2ymGXFFPA3MVLgFcIzS2nUZF8BCN4AcDu2Ilj51Z\n", - "d9yDTxB47/vgPRh56MkrXs6KF30B6Rk/2XnmYaSSZiADtgwiYCfwD2T6QFu2NhKpljkbeD3w/5CE\n", - "mxvBD8aN4GXu2UHmNecAfyVL4KW7Yk9ElNyxBi08c8Ex7G/dY/ZjFnICKzuSeBHwc+TkUmYEn2zR\n", - "bJnVl7s/BT0Ofif1h+IzCfgj8MGMvMB4wqqujVQKfBnVR2OA9fhsQj7rSYQRvBX40xHB72xlihX4\n", - "qAfv82EzTiKLyYjFNilnuVFIfmo1IljHAfcg02mWxThkEOUoI46jkeNV1KaZRLGGdJ8Evhx77KXA\n", - "ywpupyjDkat8a7O+G/h6yduoii4SwZdiz4CMfrQdKyG0aI4leY7XGN5hE9FLBB+yCujDyCdH0/os\n", - "HO69Ackz2MjyaKTK6LfAZ4Bt+HwV+B7hzFTWohEP3mcGkq/4DFKOdg7wDeSHlIZE7+LpRyP4zUdO\n", - "YecEz+zLAWTqw7n57zlOMB2Ci1OetIlqd9sdR37UUYtGHrNVNEN49K1wuHcvSI22fgZ8FUn+pwmn\n", - "G8FvRITECvx6oKWEevsxZl0gJ/qZRJOsU5GKreuRwoWOIRH4OGQgWH+TqLSVTZ9EKr+ysMn3vPr2\n", - "0cgVyVLgUqSI4ueE+YUyGIccq8OIMI4mGtHnMZFiAn8icKkUSrQzg/D3WxZWM+yV/RzKPSFWTVeJ\n", - "4E0v+M7iBYTll3Zb5yER8m1VrGgjMBACuZQWQX2a8Q9MonUtHBi4lajAH4P44rchl7I/Nq+7Er/d\n", - "c91BGMEPJuBK4EfATxDxmoDYH0PwU5N+k5GrCxDBsiLbwr7Bvdg1+iDSxuAZpJb2LGP/VIOtmori\n", - "MwC5OlhF9khlu7yHz//L2X4/4CA+Bwitkv5AgM8eYAhBD9hw3J8gYdo7+cHORMp3/066cI4nKvA2\n", - "gt+Fz2HkeM1OeW1RRhMK/DPIj9wmWTebfXsMiYLP6sR2xgBb8dmPzB1srQebAM1LSs8y+1Mkgt+I\n", - "CPzlwAOI/XR+ibmd8chVwkbkeB1Avt/5Ai/7MBaYYWxR+/gl+M6JXuywScCNiHVqE+LTgan4DMSn\n", - "F34pduYUJNCzAn+82cbE9JfUlkYKvFsHP4zO18C763ctmunAq8FLq8tPwAuQ0ZWTnQcXMnLhWFqf\n", - "hb3Dn0MixpNMxHksIvCPAb9DRDuORPBT/jSYt5/eG0nKfgefxYho3meSgE8iJwwhGlnOJmyP7Nok\n", - "rewb2oedEwDOABbhs9m8h/824hziMwyfeST3MulL5VSHIN7iMpOXSI/gw3Uei1wWZ1UFWXsGQotm\n", - "OOHJXqysNadvJlmAXwr82exTlsC7A+/iHjzIVVZnBT4ewc8gatH0QhKj9wGnd0IkZWCesI7QpnkZ\n", - "ctUmAu/zYvxEC2IW8Ceqi+CPAh7EZxUiyO9L+e6EyAn+jfjc3f5eff6V6KQ045DPZSPyfdlAmATP\n", - "Q050cizckuC3EA1Qjkc64X4FuBJpGTEO+d49hVwxvwK32KLjTEGmGp1kfnOzkIrDhiVdG23R2Ai+\n", - "LIsGogL/R+Bl4N3XgfUsJy7wQ5aJRfPcuD34bEB+0C9CBHk+PgE+F+MnjuKVJOvZnx7EU685wLfm\n", - "n4TfLtZfJzwpzMfaNOIpL8bnChN1vA34hVkuatHsG9KXHZN6IqJi7ajLzbqejIn8pYgllFRHbac8\n", - "jDMTES6IXj2E+MxFBNdDqm0gnsyL9vWx9gyEEby1Z8A2jlt48XMkC/B5SFkiiHCekeLVZ1k0IALf\n", - "2clSkgTeTbIC3G88+nXYk7jPEfi8NbImOQGfmvJe4gI/1kSwL0FGPc4xr/s08DN8Xh17/WzkmOUJ\n", - "vBvBA9h81WVID6g78bm8Pe/h0wefLzrC/y2kpHYGYcDyv8h32DKOMIK3Am+vsPKYiOQH5hO1aWYi\n", - "yWzLScAj+DyFHK85ZplnCK/CXw1MpPMziE1FKszWId/NVcDv6ZBVWg6NtmjK9uDt+o3Ae8+Cd1cH\n", - "17OCqMAvYvDqYQxZuZ9tU60F9Ankh2Qj+Cy2EzCZcQ/15OF3rGLTMWElhc8P8LnR3HuC8At7FXI5\n", - "/QkkytiKCBm4IhvQwv7BfdlxhBXmRWa9T+NzmVmn+8N6LXI5fJRZ7sv4nGGe6wv0NRHYacZm8Qh/\n", - "FCA/xBGRS2PhHCRaeQVycrnN2UY/fL6JXAXYKM5W0Nj3MwuxgawgDgWWs/IcDxgYsa5ExP4FOYlj\n", - "TribkBxEnLhFMx7wjDUEtRH4WYQCvxXJDdkmfXcTjnj9d+RKbrKxCr6LXKXdCKzF50Wx7bgC/yxi\n", - "U5yBHNf5yPflUrPc2cA3YvbDLLP9kWQ3QHMj+APIdwhzxfkCJPdxNfAFs/xM815ONrbI65Ay4zuQ\n", - "kt1JiChfatbjEVo0m5Dv/HqqE/hVuAIvVwpTgWMISy1PRK62QYoYXoicdBYjAn8WIsaLCU+6j5A/\n", - "HiUJO2PcM8CrkLkx/oJG8GV58O3r35e7VD7xROtCBq8ezJDl+9k805ZW/hTZ/x7IWTuL7cArWHn2\n", - "YQ60SgIxmfnAC02k+5/ID2U5cB3wFfz2Jm5rsD1Jgp5D2N8K2yfZKP2Z6Cr5FPB+E2WNQC7jbyYU\n", - "tdcgdgdYgReBuRH4b+QyNxR4mbN2I2FZm+UEpLXDd5GyzZ8RRvBfQiLpPxEOEnMj+CcRm+ZyohH8\n", - "MoKeQ5HIyI3iTwI24Ue6mFbaNKGQuBbNFMLoHcoTeGsDLkMEdh8+beZ4nWksDoDvAO9yhPDnwIeB\n", - "/0EEaho+s4GPY3vb+PTH53+B/yAcSGg9+H8lzDH9A/gi8BN8HgH+z6zb2n121PM6svMoNoJfAFzs\n", - "nAzB5wA+3wc+iHw3ILTiXgNchFiOW4G/IaJ6DmKDDMJvP/m14bOL8iL4SWYdiwlLhCWCF+y+uBH8\n", - "q5H8glSw+WaMi+Sy7Psdhs+/4XNmjjVlS5gXIyfwJ5DvbX98Po7fflVbN7pSBF8LD74zrCAq8Mvp\n", - "v6Uvw5YE8l4CAAAgAElEQVT2YNNRPSDw8IMH2TT748DtjvCmsQOPVp552V7ChGsS9yEi+CTiez6O\n", - "iOwyQnsGRAT74dPC4Z6DONAKOye0IhUJSyNr9HkQ+aJ9GPEo70AGbx2F1AePI7ys7cvwRYOQpN0J\n", - "iMhfgkQ97okjqVTyRORkshBJND9FKPDnm/dxD6HAhxG8HL9vIT2NogIv34/QJ/d5CXLCuD22/Xuo\n", - "jJZGALvx2793GxEhcAV+CXBEe0TrM8pYbcfgJonlBOnjcxuSQHetrDCCFzFchXzO9rX/dG4/gVxl\n", - "3YCIwNXImIi3A2/Ab3//vwJeYrbzDvPe/gWfm8zz65DP5kKkkgjE558M7VeE30Ui6COx/ZjkWK8k\n", - "LdEqkfBw5AR6CN9cJVUiJ10RvRmI9fMa82e/q39FriTmIlcOvzX7bO0ZkM9kLPEI3ueiCpvKb6+R\n", - "TxJ4K9z3Iy0j+pr3PN88fy8SAMxGRNg+/gvkcziOMEA42WzvUuT7cRZSAXUvSUUQcswmIrqxGAle\n", - "njDH2o7+/ia++c34fNp8JjWlUQJ/CClprJUHvz93qXxW4wqYz0F2TjzA4NUtbD6yLyIcJ/HNp9fh\n", - "868F1redgICFl+wgLJmsRCK+a5Af6ZvNYw8iCd02Z7kAEZGJQCsHBuxh6/QhSFI16f3L5bP4oD9G\n", - "IrOjzGNPId6tB/RlzjdGAzcglSz2B+l68BBPtPrt/vkS5Grg84iIzUD61ww023yYsPrITbKC5CF2\n", - "ExX4pcj3YyFwJD7nIVczPwY+GnuPdyEC6CYwXXsGxA7ogSvwcrxWmX29DhGJ9yIJ8++aZfojkd5J\n", - "Zj/fhox1sFPzDXb2G3OssgbufRWxsn5gIt2rgcvx220e8NmInOhfjNRUfxg/YgU+i1x5XGnWAWIJ\n", - "3I3YA+Cz22zrS8gIW5ufWUmSDy+e+jBgh7nyyGIT0oxwBPL9+DXy+3sZYdfZlchv/TLkBPxbxCJ8\n", - "KeFVlR0MGEbwcgX7O9xWwlIKuhax+KzALwOGm+9fVODlqmFJ+8ldjuc65HguNo9/ATmR2hPFWUjg\n", - "YDvIvhN4Jz6vRU4WUk1UOVhtHFLdtI/wd2JtrZvx+SByBXOpOUm9Hyrst9JplEWzx1Sq1MKD30U0\n", - "OusozxJPQm6eeZDAC9g2dSBh5n5G/IUpLGHXmF+wa9xzZAm8xWcTvnNVk3yFsBqYhBe00DZgNYf6\n", - "DccPknvQ+DyJz0VIzffvELE9EjiFBa96joN9DgFT6LNzAMfePASJpkGuKCYh5YvrnTWuIRrBnwA8\n", - "js9hfPaYyG8PchzfDswz70ESW9EaeLuPexB74UkIeiInBTudn7Vo3gP4+HzXicrt69cgP2C3vjna\n", - "ulrEfDuV35GnETvjRKTPz0sRkXilEfeLkO/oJfj8BBHcd5sIfxQ22g15BjeCr+Q2s73fmP26CZ+/\n", - "Jiz3W7NcGxKBuvwTeAc+v3fe3wKkgsb9vnwNOX6XIjYFJAm8zwuR79Qs0rvBussHZr2zCMX1p8Dd\n", - "7SccWeaviI+/ADkBLUM8arvfdjCgW0VzPvJZvt/Z4uVI6/KXYwVejvlfEB/dFfgXIVdI/xXb678h\n", - "0fRSs38fNFdMVuBfiBQ9HIcMGjuTMM9zGAmUliD2mYu1ZzDHZBtyjF1+jVypXYF8nlljXkqhV/4i\n", - "pbOX6IjTfsiHVpZFcxVhRNAZ1gGjRGjMCNvNR8GUeds43HsEoR88vdDafFbDus8hg5+yLJpqWAVM\n", - "wjs8kAODliAJSttLPW0/DptbG5DP/wIWXTSMMY8uZ9iyOZz96WNZd0IbN/55iVn+oBGQY2KiES+V\n", - "PIEwmeWyABH4j5r1bTBCPploktXu3yfMrWGE/XWswJ+BBCVXpL4/sQnOI6z6iEfwIIKSJPA2Sbjb\n", - "7MtGxMc+H/HKb2w/Bj4PI9VSL0c+h/Wx9S0m67shwvShjPdh+S3wOeRkEj3J+2wHvp+7BvG53xd7\n", - "dBWVA8OuQYT4U4Sim8ci5LdgxfVeKier/zPQw3z3DkBFZY/d1noTHLSZZT4IfBxJ9t+P5Bq+gZxs\n", - "bQQPEhlfguTybkc+y97Ah/ArbLy/Ia0k4sHBZvO5H4mcMFYjdfNP4EestgCfzwG34vMfzmcSCrzP\n", - "MnyOSgjK7kROOuORQObFJCFBw3FAL3weSFymII2I4HcTzppUgwjeWwvegfzlctfThuxT2Pt849E9\n", - "ONxzPWJFzEIun4tG8CCjWHfTHsEHMyCIfwGrYRVwBN6hfuxv3U7xBJWNrBYAc1h5ziA2z14B/Asn\n", - "X3sqf/50PIdxPVLP67KGqIC51QouC5BL+HnOY48g1lDconGxNeS2fHIJ8gO+qV2Ak7mTMGEMEs0/\n", - "HVsmSeB/AbwZv92XdR+3/vevY899HRGhy6gU+D9ACZNX+DyDnBx/3Ol1RYlG8FLlci5iiZxFkQhe\n", - "WIicKAYCzyIWYzxY+xHZs6K5Eby9fzYi1l8CvorPucgV9YfN9kYQFjbchpzUj0ZyDIeRWvTvJWzr\n", - "d9ikcyXzkbzXfiRH9Z+QmH+wNtkxzmMvJQwqiFht4WN7ERtxIFKXfyw+PfBpwbb3lqq3DUgO5YyK\n", - "dVRJIwR+CeGou1p48GXiRKmBx+IL+7J71OcIG3rdRnUCPxBJLtu+NKfSuYZgq4HZBD3bONzbViNU\n", - "0251AQGb2H7ECFaevRp4G2tPW8+zc6JXdjJYJd5J8I9I46zXI4mwkwknZ3d5ChE/t1XEw0jkewGV\n", - "wmiJCrwkLu8gtI7S+CvS6dMOEHsxEkG6bCAu8BKRJw1Q+w3yfb0rEskJv0I82clIVZK7viX4/Dxn\n", - "X4vh80l8x8oqh2eAc/BZhyRRvwlcj8+jiM2S9rnEWYRE1ItTbESMbdeW+JywCThIVOAfRgbrfQs5\n", - "ad+FVAbtRKLw9e2WmN/+/RqFtUXkKjFpX7bhp54sH0Kid7CN1pIEXt7nrdiuoVJ5cwESCOXxZSRP\n", - "tgX5fk9GbKT5+CxAclcvxedo/PbEeYdpgEXjBYRJiFp48GWyltCH78vu0Yf42tIbEJvleOTS+T0y\n", - "9Z+XV0UD4eAa21nyKGBEFa+Pswo4ikN99iNXRbZhU1EW0DZgGvQ4lycv38BLPvgMf/jaEoo0EpNL\n", - "2pcjCb3PIMfqqYQl70TK4cz7C17HwX6P0Gv/R5CywOtStjAEse3MnKmBh+9dVGC/9uAzD0lm3YNc\n", - "JcTHKGyE3KZcdn3r8fk1JESDctL5t0Lr6Wr4LMdnMPLbOwuxOKygvAcqxjiksRCpgInnB6rZlwNI\n", - "R1C30ukx89xB4H/w+S2hp30blRbnrUir4bzEcBYfc24/hGjSwynL3oqMgfkUkoi92Vhm2fj8HSnn\n", - "hbBy53LkiqUfYgmVpoWN8OBd7CTZgLc3c8nG8Cyhz2zE2Qsg2IyI4INIsmQUxS5pBxBG8EOQS8re\n", - "iGfZkQhNKj8O9t1uXr+X6iL4G/jrR1YD57LjCIDZbJn5O9mnoIc0X8tAErdzkRmvkqJ3G12Z6Dbw\n", - "gOv4/PrZfGjoVKI17HGGAtvlexEcIrS3inAd4jn3QhJ+8fexkequXl+dGp02MyKoa5HxCj9zHq+m\n", - "bfdSpCouPvai2n1Z4tz7LGHPJfu8K7TXEw74s9xA8bxB2j64JwcZUxFNnLv8FZiJz2eAt9Kx0apP\n", - "IJVyHjLKufTvWKMFfj/iZ+cNEmoUbiKxhTB3sBkR+/0Q2GHpRQTeRvDWohlBOFl2hsAHps+0tyT2\n", - "xGqgF20D2sy+7acagffZAh+yX+p+5gtma7v7UGQ8gVxWFmUI0Jf9Q4aknhCiy1qhsT58UYG/DZme\n", - "70pkPuE4d1BNi+DuKO5lIdG3Hb1Z1jqzW4tIDuax2GNrKJJwLr4Ph5Grk7Tn25A2EGcglks8z1OE\n", - "+UgO51O1+o41WuCtgHRFewZE4G0XQ1fgtxCKja2WKHKJaqPQHYiVMh6xNUYQnU4wznTgIQiGgxdG\n", - "GT578dlM28CDZt+2IcnOarAWlJ27tq/zv4wBYy525Gts0ojgPOCu2BVDksBnRfwh8uO7ASmxqxw9\n", - "6A46Usrga0iN+/MLnz8hgxI7yhPm/82ZS3WCRgu8HZDTlQXeCqDbnMp2agRJGs+AYJQ872VFmW6S\n", - "dRpS3bGO/GhyMOIlz6Hy0nQVBwYOR64Aqk2yQthZz3aQtALfj+w67o5gBd4ZCRh4SLLyGKKX5a7A\n", - "Gx++Kr6HlHYuy11S6Rw+32j0LjQpC4Gr8RNzV6XQ0OmkCAW+rBr4snE9eDeC/wdh2d9ipARsFdGG\n", - "Xkm4ZZIgJYR2vk4gOBeCb0LFYCVbV/yShHWuYv+gwOxbRwR+PDLwxAp8XOjLxPYud8XazlMbn43J\n", - "JllBAoDqJsb2WYxf6uQUilIuMsakpjM+NVjgvQDaJ3voirgevEwQAYD3JfBsc6d7kEusH5IfidsI\n", - "fjeSmLICb193PZIofX3sdXbO1RSBHwwdF/hxSKIsLuy1EPgki8ZOhhAfHGOSrEB586YqyvOKRkfw\n", - "ID5vVxX4bUAfCAYiApRgv3hrwfsAYrfk9ZM2EbwXIPbHU7QLfNAbEUAfGG6sC0sLUo54PASDIJjs\n", - "PL+AnRMOIxbNallHUM30c/EIvi9ykqmVwO8gGo1bgU+K4F2BH16D/SmJYC4E8aHritJwigj8dUiF\n", - "SHyEn2Uu8qN91PzFB8TksZ8uK/BeQNiTxrVoksjvLxNG8CADSZ5AErYjzDY2gLcLKb10I9pWZDDI\n", - "/cBNSMQto9x8ruX339og++btNcvMLfT2hKQI3vXky2QMctWSFMEbgQ+Og+A0ogJfVmuHWjGLsEOm\n", - "onQZigj8DwlHnqZxD1K9cSIy8W817KPrevAQ2jRukjWJ7eT7xG4t9xzwnib04N2JHLYQjVhtnfzP\n", - "kYkj/ka0D4xbR38nyVZOAkF/s09riQr8DmrnwecIPO9AapBPonkEfhD5J3dFqTtFBP5v5Atw9vyM\n", - "2XThCB6QCH4C+RH8NqqK4D23ImcE0hfEVuYkCfwu8L4L3sXIyMyxlc8Dlb1YshiHVPHspTKCr5VF\n", - "s4DoiXAScsViBb4F6b3yfcLS0U4IfHABBK/p2GsLowKvdEnK8OADpKXm40hzoKOyF6+gK3vwIAM4\n", - "ZlKORZM0GtMKvBvBu4lXCJOslvVEZ1Nyn38CGArBqRA8KP9TsZMu7CNaB19rgY9H8IsJBb5V7ntX\n", - "G7sKOhfBv4xwLEMHCb4KwSkZCxQU+MAzuRZFqQtl1ME/gvxI9yANd26B1PkMfef2PPP3FNmDfBrN\n", - "U0iviLWEM9AkUcSicT14i/XgJxEOfEiK4N1jtI7o1HSOReMdhuAupGnSDqS/9YMkcwLyvkzTt6AH\n", - "0BM5WeQIfNAfGAfe0oTnPgI8Ct7vncd6IyK4mEqBf5Qw59BK5ajezgj8dAo1zgouRN5P0mjIU5AT\n", - "00MpLx5UcP9eDrwBmfFIUdKYS0kTdZch8O6P8Q9I97e05mF+5UPe5SXsQy15EukZs4PCEXzQCpwH\n", - "3i9jyyRF8FbMj0BambqPWZIieGPRBL2obCvwA7Pfm4nPUdpO8E5kCr1LCLt69kUsMyv4HtKPvBW4\n", - "BTy3u93lSJ/3pPVfiAi2I/CMNvuzifYTYdADySX8lGgEX6bAzyD7c7O8CznuSQI/mOj0jXEGAQPl\n", - "JOZldU08nerLWGtEMB74EXgF8zVKHZlHtL32x5IXy6cMi2Y0oQc/x9zuypZLtSxGousRZAvFLkQU\n", - "eyOi9/OEy/qECN7bh4jqMaRbNPFmZOsILRrrzzu9LLy7wfsMYpsdTwXBSKQT5lngPUClwNsunwOR\n", - "hO0NVA7iOgU4GYI+sXV7yAlxdmz5MWa/nwMGmOM0knBSD1fg48e5gwIf9CGcWCRruUFI3iJei28Z\n", - "RL7AQ/4+npCxjXozGTjHzJyldFOKCPzNyPD4WUid9VuRWZOuMs9fhpRQPoY0se/qEXmVeG1IO4KT\n", - "yayi8QLCKH4s2F7WkR9QWkfELUgiN62KJsuDz+pE+SQwK8H3nQk87dgrNskaF/gWxI//CTDd2DKW\n", - "U5CTebyf/Xizv0kCv94cp21IFG9n5dlNNMlaVgQ/GfmO54nqhciAu7QTQZEI3i6XxYkF9qVejEA6\n", - "mY7PW1BpXooI/BVIMq4P8oO8DrjW/IFMFHAM8kM/E7plI6enENHOu9S3Aj8GmcWmjajfmlZquRnY\n", - "Ad4O535SmaRlIzI4qieZyV9vD+Ecmy4ziE6gnWTRWIHfJV0zWUj7HJJBb+Qz/wViO7gcjQQEk2W5\n", - "wINgAO0CD4StByZRKfBJFs1OYFBs8FcCwSwI3Fl2bJfPPFF9JfDL5OWCHmaf8gR+H5mJ1mAMYs8U\n", - "60Nfe+wV4tSG7oVSU7rCSNZmwDYDymtXayPTMUhC9k5kjkfCKDrRo91MGL1DmHi1xETcO4iI5EiS\n", - "LQ2Xx6mc3Hc62QK/39x3xVYmyxaOQko6/0TltGLHmGXXIA3VXo4kcl9NKPC2eVhSBJ8g8F6b2cc8\n", - "ob4GmYDBfZ9uAjeBoB8y3dtNKcu1ILbaQAiyLJxVZFfS2Dlru1IED/IZNSlBa6VFqLiowBfDzghU\n", - "NIIfi4iZa7VkDZRKEvi4RROPaq1NkzdZyBNU+vAzIDLBghX0flRaNPY9P0w4WvMUc/8ftEfwgY0E\n", - "j0ZOiAuRK4eLkNlvjias87e9ZY5A3vdu2VbQB/lOJs2pW8SmOQV4qWktYd9nnqhORI7/cpKj60HI\n", - "57qC9Ci+iMCfSPuE1HlXInXBzkHQzBH855EJM5QUVOCLYSP4aiyadUR7qNjZnJLYQih+kJxkjW97\n", - "HXIiyavPT4rgYxaNdwiZE7OVqMCnRfAnIwK/GBgMwReApRCcRSjwi5Crl/OA/0OiaTs9n73SOROZ\n", - "09RG8GZ7idMX5gh80Ae5enjUbNO+z8fIFviRSGXPrpTlBiMW0XISBT7oSTgaOOsEdAJSZrmfcMxB\n", - "DsGZMjF7TRhh9qeZBX4EkmdRUlCBL8ZSRLx35iznWjTVRPB3EJZIEn1d4JEdwSc95/IEcEIYNQYe\n", - "lR48hB5yggffvp7ZEPRFIuWHzAQd/0RaWXwU+F/EvrER/CVIInahVAu121NbEbE82rx+F3J8sq5G\n", - "8iL4o5GmaTcBl5rHpiMnuH4Z1SKjkJxGmsAPMttOEfj2Y5Qykjn4AAQ3IPOePpaxnSTegVwBdZJg\n", - "HAQ/jD04Ajm5NrPADyKcr0FJQAW+EN4h4Ajw8gQ+yaKxg3qSBjnZ9f8BvDucB3YDvUzVSh8gAC9u\n", - "WxSN4Fchn7Pt+TIa2A9evP3EPkRAUyJ4by9yovsRYWQMMi3eC5B5NCfL8t42ROBPB/6YEJFvRcT/\n", - "AVMmGovgE8kTeHPS4RbgZcYymoAI8x4kyk7CRvB75D0H8bEhORE8g8zzaSOZX4mI/5+QY1KNwA+m\n", - "nKTsNOBFscdGII3pml3gtQooAxX4wuSKO8iPfAIyGnQn0Qg+bfBX0rYCwkqaNAG3EfzRZI7U9AKk\n", - "quVM80BS9A6VAt8vYdvXI8nj48I2At4aqf7x2pAo3s4Yb+ez/GPCtrYhNs/d5n5Rgc9qg2yvKtYi\n", - "A6z+CvzDnBh3kS6UI4GN5ji5yV6LFfA0gbcngASBDzwkD/EJ8N5kkuPPZexLnEFVLJvFMCqP3Qhk\n", - "dO6AKttLOwSvgaDDg3BKYDAawWfS6Cn7uhvbgXNpr/cOXIG3UX1R7Gt3kCx66xEr4ngqPfY4/0Cq\n", - "XX5KZQWNZS+ZETyA94XszXg/geCn5s5mRNyT5qy0J7okgU+7GikSwRsbwntj7LmsqHkUYYLbLudO\n", - "VZhn0bgRfHz/hiO9mrYU3Jc4ZUXwRuADz7maGoFcuSxDovi8SdCTmE1jrwDMCGIlDY3gy2Ubklhc\n", - "Z+4/h/i/fQgTr0XJi+DXIf0qfiZRdCbVRPD7SPbgC2InzvYC8M4Hb3vCQtvMem1vF2uhDCLXogl6\n", - "Q/DC6FNBX+S4P57y2ixRNRE8kBxd2wh9GTAloQLGCvwOKi2amcAzMYuqGoHvQAQfeGZ+YJdhRAZ8\n", - "Bb3NercTCnxHGEVjBdYcn0BFPgUV+HLZjniCJlL3AsKSQHegTxFsLXyabbEOqXz5vwLrehg4ygw4\n", - "OopoiaQlx4MvlfnA58Okq3fIbHNUxvZsBH8m0jrBZRawwuQJkniO7Ah+k7mdJL4mgvd2IEI+KeH5\n", - "NA9+FtKNNL4vRUV7cMZ+p3ECMv7CxeaBBjn3t5qT8TLgwxA86ZS6FmUkNRf4oC8E8WOOU720CrVp\n", - "UlGBLxcbrbpCbq2WsVQXwdvXpUXRS4BTwVuZ8FwMby9Sy/8RxMq4K2GhIh58SXgrwItPcbcLOQnm\n", - "CfxMYFwskp5ItMw0TjURfHw5G8GDHMNjYs9nWTQmgi+8L3E6YtGMojLxaLuc2v0bgVwhgpwsb0Rs\n", - "snh7iTxGkp68roLAg+BbZtRwnIuB7yU8bu28NWiiNRUV+HKxlSmukFuhrjaCt7XwKVG0F4BXjW96\n", - "H/BfwOvB25zwfD0j+CR2IxU+RQS+D9FxAhOQH3oaeR68G8HHBdV68JAv8CkWTeF9cQj6EI4mroZh\n", - "yJy+vWKP2X2FsHII8B4F7ytIwtWdRAYIjs/pX19WBN8H6eaZNO/uJKJzH1jscV9LagQfTIfgyyXs\n", - "X9OiAl8uSRG8HexUbZJ1BVLeVlYUfT3wZvDuSXk+rw6+1uwmu9+PK/Agom6xLQ/ScEQ1OD4Uv8Aj\n", - "TDbGlmunSAS/g3QPflHssaIWjRVjs2zQD4I5BV43FBl7MNJ5bBhwmOQI3mLLbl1uoLLXkEtJEXz7\n", - "wK+kSHwicuKPY4/7symvAziWUsYR1IugT9mjnFXgy8UKfDyCtx58NRaNFZO8VgQF8R4D78aMBZIi\n", - "+HoLfFGLZjXRH3XBCD6YiozIfRaC1yKCvNc0U4Nki8ZGiiC5g2NTnt+JJPzMbyroiVQsxfMdRS2a\n", - "QUQ7XJ4FfKPA66wd44riMOT42JNGksDbyeVdxpJamhr0MOspI4K3J4k0gR+ZMFCtQATPaGBsF2kN\n", - "UYSfAi8uc4Uq8KXi2QqUuAc/DvmhVtMnfwFSGTKY+ohsgTLJmlJE4IchpYr3EBWDohH8eGTk7NVI\n", - "22vHqmhfLqmKxlo0TyPtl137wwiNdyj2etPjxouPXi4q8IMR0bXrG0axlsnWjhkTe2w5VUXwQW+z\n", - "XFqN/BBEP8oQ+LwIvgeV9o0V+KwIfjRh+W0zMBrpz1QaKvDl8xjRhN8WpHJlQ1hCWARvJyI+x1Ef\n", - "kXUtmhonWRMpIvCzkZPnUqqP4FsJ56C9B0k2jyZMsNrlMiJ4bzcSMU5Pfj7iw88iuRy1qEVjBX6g\n", - "iUCHUWxi76FI7X08gl9OdgQft2hGIlZPmsCPMvtXhkWTFcFPQD77uE1jrbO8CJ6M5w3BCAjeX2RH\n", - "a0wrJc/4pQJfOt4ZsSTmFnJHm6byJDJAqR4iu4+w2Zj14OsZwe9CJqDI8uB7I0nLNbR78IFH8SSr\n", - "qWTy1iG196cRjeDTqmjcgU9PErVpXIF3ffiTSB48VI1FsxX5PAaSGMEHM2RC8AhWzI24Bb3M9lZT\n", - "nQdvrwDSBH4kUqLYL6X6pRpsBB8T4sAm0x+nUviKRvBQmVuIcxLhBEaNZBAq8E3HVsLIs1rmI5ds\n", - "9RJ4j8Z68JAdwYMI/FrCH/VQoA28rBORFVUbwYNMRH4hlRF8UhWN26ZiPtFEa1oEfxrJk99UY9HY\n", - "UcwtyPvsa/rXW14NvCUmsEORNhFW3IaY9WwjP4If4/jVRQR+I2LtFeyOmUqaRTMOmbDlWSojeFfg\n", - "42WzljFkR/iWiUQngm8UrSQnlDuMCnzt2YJEntUkWC22D329LBoIBb4FaWWxL/UV5ZIj8F4bIiZx\n", - "gc+L3u06nQgeEIF/IZUevCO+QW/EqnJ99L8Ab4TALT10BX64EZvTkWZeSftStIpmp7O83Z5r07zM\n", - "7K87acdQJFdghcL2QNpJNIJ32yfgNH2zXndRgTeToXSKAWZdcYG3uZWNJAv8DjNr2R6SSyxHI+2j\n", - "8yL4icCQxs5PG1g7TCP4JsP+kDpq0UD9IngIBX4gFZN515S8CB4kEo1ZNLkJVohaNG4E34tsi6YV\n", - "SaDGJjTn18CPTeTsCvzfkcm7JyE+uDuJS3xf8nAjeFfgjUgHwxGr6A5kMhHLMKIRvBV4t1mbeyXj\n", - "4to0YxBhzRL4TSQ3aKuW/ki1UZrAbyDdg4f0KN0KfJEI3qNYjqNW9EW+jyrwTUZnBH4RcIj6RvD7\n", - "EIGnTtu1FBH4OxFfexvQx/QgKRLBuxaNjeBtH5wsiyZuz1g+iIjaN4kKzc+AVyFXBvennBw7K/BW\n", - "hM4D5iGN5E5yXpcTwbdXxyR9H+MC/wzZXTitwHc20WpbDrTGLKgJpAu8+9m4V3SGYABy5byIfIG3\n", - "wULSVUC9aEWCAhX4JsOWRnbAovH2IZNnJI08LRsngm+f4ale/juEAp+xTe9N4JlOne3JNSsCWcSS\n", - "rGCaoC0m06KpSLDa/WhD5po9lkiDNG+FWecHSbZnoOMWzVBE6KzAX4i0RXZm2gr6IqK2lNBiiUfw\n", - "Y5H2yAcTtukK/FhEHPMi+DIsmv5mPfFErxvBpyVZITnROho5iT1LMYtmF3Xx4YNzIXh7whODkEBl\n", - "eJlWkQp8zfH2IV/ejkTwAGeC91T+Yp3GNura7/yvZwS/Czmp7M9b0LAWEfeJFIvgRyJC4o5FeC1S\n", - "MmmJWzRpETymjPV84CpzQrTcTDhTVdq+dDSCd2vZz0FaMT8KnGg83KFIHmCz3A56UenBZ13xuGJo\n", - "I3gj8MEoCC6G4DizrTIjeCvwcaHOsmjiEXw8Sh9NmKDNiOADz2znCeoTwZ8PvCLhcTtOZiclnmhU\n", - "4OvDU0jrgQ5QMVCmVrgevP1f7wg+bT7WJGyTqaIevOnyGfHTH3VGsdrlbGuA/qRG8O2v3wXed2MP\n", - "/hwR5YcSXgAiZP0LlBZaAbP7NAzp/GiTgWMQW2MdYuNNQAR+q4nOtyFWTDyCzzpeSRaNjeDfAnwV\n", - "6QMH1GAAAA+pSURBVPH/r4Q9fMpKsu6l0mqxJ++kJKv72SRF8GOICHzqaNbBiDWynPpU0swmOo7C\n", - "Yq8Ek65WOkwRgb/ObHR+xjJfQy5NHyea8FEA8OaY2uuuTFzg91F/D76a7a0GvoWULOZd4dgTVVJi\n", - "Mb5cCwTjkUj4E+TPwxvD2wCMTS/b9A5TTBTdCH4EMkvYOsSiMRPBeG3mhGVtmmGEDe9s1GtEv73V\n", - "Q1YEv44w2o0L/Cgk5/A64MOEg8TKSrLuoVLgXQ9+VEykC0bw3nOIgKfZYvaEZ9t6FyC4AoK3FFu2\n", - "glnIvALxyZbsmJON1Fngf4hcVqRxIXJGmoHMz/ntEvZLqT9dIYKvZnufRwaBjQUvT7jtVVDeSdZa\n", - "NGcj1s1vSZ5yMIfcq64iNo0r8JMQAbItieOdSY1N0y7mEAq8FX0z5yxTyBb4sRC0ICeUtUQFfhOS\n", - "2N1s1r2Z8iyavUQi8WCoeXyD0wLErXIp4sFvcJ5Ps2nsCc82BTQEvSE4LeU1F5HdhC2FoDcyb/FW\n", - "wjmSLaZiq/4C/zfCqCCJi5FOhSCJpSGUXKyv1IUkga9nBL+a7KvEGN4W8J4s1v7BO4wIUd6J4ADy\n", - "m3gxcAd4Png/Kr5PhSki8G6S9QhCgbe/L1fgbQQ/lPC3up5Q4LeaSH8n0t8oTeBXIcHaBPP655BW\n", - "CT2Izl37SeQKYj/lWjRrCIXPjARu/3zj1kWRCN4eI8d6ClpMozmLjeBtU0DLFUhVVBInEu3WWZRp\n", - "yHt8ikqbxlo0SXZUhynDgx9P1NNza5SV5qHBEby3CLzLa7iBXeRG8F5gljsfCWxqRZFKGjeCPwIR\n", - "bivwSRF83KJZB1xCeHIAEcSjSRV4bwVykv0veX27ndSCiKstKb0DuXqCci2aRwDbEvlkc9/iCF/7\n", - "bE67nOeGx3rXp0XwZwA3Q3CKue9aNG6S9d3ymniuJBiA2CwjqJ5ZyBiFJVQKfE0smrIm3Y4nMNIS\n", - "Zb5ze575U7oGSR58PS2aWlNA4AH5kQ2nY5NQV7Mvtj99T2CE8e4NgUf4g7cWzRJCH90mEC3Lzfpm\n", - "EpbUfgnxys8lFPQdiOBnJaU/hgzY+rW5v5NwhKWdJCRAau0hnE8XCMZIGWvV2Ah+EdLbZjIi8Lc5\n", - "y2wA3mBE/GFkEJ6d//cgBBuR42Lfm3uMXAtnPCLmX4PgLETg/0okgg9OQk4IuxAhd8dKHGv21RH4\n", - "YLhcUeYyGxH4DSRH8DvluZsuIqqVHaaMCH4tUT9pgnksCd/5m1fCtpXyaHSZZK3ZRb5FY5f7Rzhf\n", - "bM32xUbwHwEWQXCy8/xAZDxCG+02ScSiiUXwXoBE8S+mPYL31oH3XvCGg2dH1O5Egq+ME513HxKh\n", - "2/Xb8sp4a2WLieCDEcDiYo3HKipaTATvBYjYnoNckTzsLPNl5Dt6A3Aplclv17/3iAq86yqMA36A\n", - "BLefJZxfwI3g3wV8h8p5B0DsmXm0WzTBVNIrpuJYgc+J4F9/iKhWdpgyBP5W4I3m9unIl3BD+uJK\n", - "F6XRSdZa80XggQLL7aK29gy0V8YERyC96T8K/B4COyeqWwJoT7JZHjyInTGL7HzZDnld7snrSuQK\n", - "AERIJyAnnKRJzW2SdRzhYLIMgnOBpbEqEptkBUluX4wItDMblncveNcAHwA+TaXAmwqcoAfyWe8l\n", - "LE1eTRiEjkME/zJz+3TkCshU0QSe2f5NJI6Q5URk/MFQc/U1ieKTisw27ynPoqmrB38zMp/nLORA\n", - "vRVprWnba96O1OcuAa5FvCul+Wh0krXGeDeClyV+lseR73Qt+SUiQrcBXwfv68B3EWGFaALRnmS3\n", - "EbVo4gL/qPmfNanMTvIHhQHeavCWOq+ZTnL0DmGS1Y6cnZa8WOBBcCqSuBxJ9KrfWjQgAn8p8ERs\n", - "AJnlp8ixSIrgxyFR+anA2c4Yh9VEI/hn5arGez0wCrwlhBbNWEQXV5Es8CcgfYx2IkntcYSdVzMI\n", - "PEIPfhkwNXa1Yz/zunvwVxRY5r2d3RGl4ViBP2D+/4RiEW83w3tHHbbxCwgeRKyAz5kHb0GO+b+T\n", - "H8EnCbxNSOZF8AUEPsJORLQ3pjxvk6w2cp+G2CwOwRnAL5DJtd8NvMcst9wsYJOsIDOZbSVqzzh4\n", - "hyD4b+CVsSfWIhbVmcCRsZO5W50Ta7TWPnfDDkSkT0GqdwIIYgIf9ELGXTyB5DpGOM+PIDsguhD5\n", - "jW02695KtEDFRvAbZF+De4DbwPt8xjpzKSvJqjQ/e4A7w5Ge3s0N3Ztuj7cCqVaxPIaMUp2GJBhX\n", - "mMddgd+FiOF4Km3QRUgUnCXwOwlP4EWxEXyawNsk6xhkYu+kCP4VyHia/zHidr5Z55/M804E7x2G\n", - "4I/Avem75P0WGaPgshYp3/z3hITnesR+6UtqJ03vMATbkaS0TbCvJVrvPlXW5T0HwSbkSsRW54wg\n", - "PGEZgqORmvmdwMeBi52R1EsI/X8Ip37cCcGxyPHcTidRgVcM3kGkQ6HSELzDEPwB8X+vIbxydgTe\n", - "OwyBLbGM93M/BMGrifjWFfyCyoq3PHYik5fcl/K8jeDHIJHt1IRlTgE+FxM390TgRvCA94Yq9xFk\n", - "1O3TyGjbGN4hCNYjNs1o0pPMW5GrgM+a+0mtE2zC2kbwrsDH+TRi9wTAq8D7h/PcY0gi+c/mvjN7\n", - "mreI7M+xMCrwitJ1uB34PvCwIwauBw8S1e1N9qe932ev3ita7eGyExHtW1Ket0nWMUh55anRp4Me\n", - "VFbELCWsd4dokrWDePdJI7TELpkgkfKJyACttKuYLUjE7kbwrsCPJ6wQ3EQo8KuoEPjgCOAsYFLK\n", - "yOYHkY6klppMj6nNxhSl63AXIpafCh9qH4Vrk6fb6Xhn0o6wE0kiZlk01oO/l0qLZhqwHTw3SbuU\n", - "aBWJm2TtBKniDiLwp5FdKrsV8clt9Jwl8JsRi2Y8cuUSj+CvAm7MaFvxENGTYUbn0o6jEbyidBm8\n", - "7RDMosLL5YeEwrKDUsSwMFZ00qporEXTExG6fhAMBs8miU+hMmG6FKki8YxtE7NoasIaign8fOdE\n", - "sQUYIJ1Fvb2ImD9jntts7o9DKg1tXXwPJNH7NqSnURrPIKNvR5hEr0bwitL98ZZVtkz2/s2pQW9E\n", - "BA/FkqzraC8BbOdkKgYCefYkNdqMTO0B1HJgGUgEfzLZAr+FyAjmyMQyUGnRzETeh2vR/AYpF/+U\n", - "8dJT8A4jlU8nm+RvD4rPhVAYjeAVpbnoagK/G6kHP4zs21LElrF1+acgycY4drDPHiSnUOu5f9cg\n", - "J6Isgf85MumMi51Yxs4Z61o0x5n12YQrSK+b4wq2bHgQsWkepmLu33LQCF5RmotF5Pe/L5M8i2Yv\n", - "EijayVSswJOSYLXY5ephz0BYjpgh8N594MXHfrg+fDyCn0BE4IPByEmk6Eh+K/A1sWdAI3hFaTK8\n", - "z9R5g1bgU+YF9g5BsI+w9HAJErWDzBGxOaURlxX4khKsuRQQ+ERsC4ReiM9uI3N7PJ4lrKiZBiyt\n", - "IhJ/CPg6MnitJgKvEbyiKFnsRKpgsgZI7SYUvkcIBT4pwWqxlTT1iuA3IvZLtQK/ALFiRgNbnD4+\n", - "9opmLaFFMx05wRVlhfl7IzWooAEVeEVRsllBtF47CXdS+ceAGWZWqFNI77S4AmldXEINfBG8Q0gf\n", - "nGoEGGSA15lE7RmQ8QkHkBPGViQPMbO69XsBMqjqXWgEryhK/fEC6eSYiRPBeweQhm2nIFUraRH8\n", - "SkTg62XRICNkvWqH/y9CLJRYBY4XIJH7s6as8jnkPS+tXEUmtyLHQiN4RVG6JHuIDv+/H4l6TyRd\n", - "4NcinvZg6mPRdBDvMBLFv5rKeS5WI2WhIGJ/OlVfIXi293sV01UWR5OsiqJ0FteDB/gn8L/IhNkp\n", - "zc+8gxCsQxKx9Ry41RHuAz4B3B17/EXg2ZPTZuS9VGsBUcvGfhrBK4rSWT4K/MW5/0+k93la9G5Z\n", - "iUyC0YUjeEAEvgcVEbzn7vdmxJNPm82uIajAK4rSSbx7pM1tO6uQiD6vudlK4Ei6fgT/IHCIbPHe\n", - "BCxLmaSkYajAK4pSMl6AzFD1x5wFm0Tgvd1IP6CsAWab6ZA9U1vUg1cUpQZ4Hyuw0EqkfryrWzQU\n", - "mOlrGdVPplJzVOAVRWkUK83/Lh7BF8G7ttF7kIRaNIqiNAor8E0QwTcnKvCKojQKO/1dN4jguyYq\n", - "8IqiNAhvH1JtowJfI4oK/PnAQmAx0ZngLXORmWYeNX8fKWPnFEXp9qxELZqG0hMp/5kM9EaaCR0Z\n", - "W2Yu0lMhi1o39H++MbfRO9CNmNvoHehmzC2+aPBxCM6o2Z50DzqsnUUi+DmIwK9AptX6KXBJwnJe\n", - "R3dC6RBzG70D3Yi5jd6Bbsbc4ot6/wPeP2q2J89zigj8eMJm+SBTX42PLRMgzYUeB24Hjipl7xRF\n", - "UZQOU6QOvsjlwSPARMRLuwC4BemNrCiKojSIIrbK6Ug7y/PN/Q8hE+x+NuM1y5H+yVudx5bQPlej\n", - "oiiKUhA7+1VN6GU2MBnoQ3KSdTThyWIO4tcriqIoTcAFyMwmS5AIHuAq8wfwHuBJRPzvQ6J+RVEU\n", - "RVEURVGalbyBUko2K4AnkEFkD5jHhgF3Ac8AdyLzRirJXAdsIDotWtbx+xDyXV0IvLRO+9gsJB1L\n", - "H6muswMdL3Ce02OZzURkspSnEBfkavN403w/iwyUUrJZjnzgLp8DPmBu/xfwf3Xdo+bihcj8oK4o\n", - "pR2/o5DvaG/kO7sEbenhknQsPwb8e8KyeizzGQOcYG63IFb4kTTR9/MM4A7n/gfNn1Kc5cDw2GML\n", - "keQ2yJdkYV33qPmYTFSU0o7fh4heZd6B5pTiTKZS4P8jYTk9ltVzC/AvlPT9rIfyFxkopWQTAH9C\n", - "pkCzEw+MRi6VMf9HJ7xOSSft+I1DvqMW/b4W49+QgY4/ILQT9FhWx2Tk6uh+Svp+1kPgtQdN53kB\n", - "8sFfgFQsvTD2fIAe586Qd/z02GbzbWAKYjWsA76Ysawey2RagF8B1wDPxZ7r8PezHgK/FkkkWCYS\n", - "PQMp+awz/zcBv0HGGmxALt0AxgIbG7BfzUza8Yt/XyeQPdmyIsfOitD3ke8n6LEsSm9E3G9ELBoo\n", - "6ftZD4F/CJhBOFDqteR3nlRCBgCt5vZAJGs+HzmGbzKPv4nwi6EUI+343QpcjnxXpyDf3QcqXq24\n", - "jHVuv4LQn9djmY+H2FoLgK84jzfV9zNpoJRSjClI1vwxpIzKHr9hiC+vZZL53Aw8i0yKvBp4C9nH\n", - "77+R7+pC4Ly67mnXJ34s3wrcgJTxPo4IkZsP0mOZzVlI65fHCMtMz0e/n4qiKIqiKIqiKIqiKIqi\n", - "KIqiKIqiKIqiKIqiKIqiKIqiKIqiKIqidBf+P41gkbjYnj6JAAAAAElFTkSuQmCC\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot(np.vstack([train_loss, scratch_train_loss]).clip(0, 4).T)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's take a look at the testing accuracy after running 200 iterations. Note that we are running a classification task of 5 classes, thus a chance accuracy is 20%. As we will reasonably expect, the finetuning result will be much better than the one from training from scratch. Let's see." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Accuracy for fine-tuning: 0.570000001788\n", - "Accuracy for training from scratch: 0.224000000954\n" - ] - } - ], - "source": [ - "test_iters = 10\n", - "accuracy = 0\n", - "scratch_accuracy = 0\n", - "for it in arange(test_iters):\n", - " solver.test_nets[0].forward()\n", - " accuracy += solver.test_nets[0].blobs['accuracy'].data\n", - " scratch_solver.test_nets[0].forward()\n", - " scratch_accuracy += scratch_solver.test_nets[0].blobs['accuracy'].data\n", - "accuracy /= test_iters\n", - "scratch_accuracy /= test_iters\n", - "print 'Accuracy for fine-tuning:', accuracy\n", - "print 'Accuracy for training from scratch:', scratch_accuracy" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Huzzah! So we did finetuning and it is awesome. Let's take a look at what kind of results we are able to get with a longer, more complete run of the style recognition dataset. Note: the below URL might be occassionally down because it is run on a research machine.\n", - "\n", - "http://demo.vislab.berkeleyvision.org/" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/examples/classification.ipynb b/examples/classification.ipynb deleted file mode 100644 index a76cfb10773..00000000000 --- a/examples/classification.ipynb +++ /dev/null @@ -1,3342 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Classifying ImageNet: the instant Caffe way\n", - "===========================================\n", - "\n", - "Caffe has a Python interface, pycaffe, with a `caffe.Net` interface for models. There are both Python and MATLAB interfaces. While this example uses the off-the-shelf Python `caffe.Classifier` interface there is also a MATLAB example at `matlab/caffe/matcaffe_demo.m`.\n", - "\n", - "Before we begin, you must compile Caffe. You should add the Caffe module to your `PYTHONPATH` although this example includes it automatically. If you haven't yet done so, please refer to the [installation instructions](http://caffe.berkeleyvision.org/installation.html). This example uses our pre-trained CaffeNet model, an ILSVRC12 image classifier. You can download it by running `./scripts/download_model_binary.py models/bvlc_reference_caffenet` or let the first step of this example download it for you.\n", - "\n", - "Ready? Let's start." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "\n", - "# Make sure that caffe is on the python path:\n", - "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", - "import sys\n", - "sys.path.insert(0, caffe_root + 'python')\n", - "\n", - "import caffe\n", - "\n", - "# Set the right path to your model definition file, pretrained model weights,\n", - "# and the image you would like to classify.\n", - "MODEL_FILE = '../models/bvlc_reference_caffenet/deploy.prototxt'\n", - "PRETRAINED = '../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'\n", - "IMAGE_FILE = 'images/cat.jpg'\n", - "\n", - "import os\n", - "if not os.path.isfile(PRETRAINED):\n", - " print(\"Downloading pre-trained CaffeNet model...\")\n", - " !../scripts/download_model_binary.py ../models/bvlc_reference_caffenet" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Loading a network is easy. `caffe.Classifier` takes care of everything. Note the arguments for configuring input preprocessing: mean subtraction switched on by giving a mean array, input channel swapping takes care of mapping RGB into the reference ImageNet model's BGR order, and raw scaling multiplies the feature scale from the input [0,1] to the ImageNet model's [0,255].\n", - "\n", - "We will set the phase to test since we are doing testing, and will first use CPU for the computation." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "caffe.set_mode_cpu()\n", - "net = caffe.Classifier(MODEL_FILE, PRETRAINED,\n", - " mean=np.load(caffe_root + 'python/caffe/imagenet/ilsvrc_2012_mean.npy').mean(1).mean(1),\n", - " channel_swap=(2,1,0),\n", - " raw_scale=255,\n", - " image_dims=(256, 256))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's take a look at our example image with Caffe's image loading helper." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAU0AAAEACAYAAAA3NiR2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvU2sbVt23/UbY8y51t77nHPvfa9euSpVZXAqrthWYgWS\n", - "2MIdPpJITkkE6EAiBAIpoLQQSPRoICEhpEjQwh1EI42AIiQ6ER8xKFG+MEEmUqQkhpjICqRcrirX\n", - "q/fuxzln77XmnGPQGHOfVyahiKWKXiGd0XjvnXfP3WvvteYc8z/+//8YWyIieI7neI7neI5/oNBP\n", - "+w08x3M8x3P8/ymek+ZzPMdzPMdvIp6T5nM8x3M8x28inpPmczzHczzHbyKek+ZzPMdzPMdvIp6T\n", - "5nM8x3M8x28i/qEkzZ//+Z/nx3/8x/nKV77CH//jf/wfxiWe4zme4zk+lZDvt09zjMGP/diP8Wf/\n", - "7J/li1/8Ij/1Uz/Fn/pTf4qf+Imf+H5e5jme4zme41OJ7zvS/MVf/EV+9Ed/lB/5kR+h1sof+SN/\n", - "hD/9p//09/syz/Ecz/Ecn0p835Pm17/+dX74h3/46ecvfelLfP3rX/9+X+Y5nuM5nuNTie970hSR\n", - "7/dLPsdzPMdz/MBE+X6/4Be/+EW+9rWvPf38ta99jS996Uu/4XfssOLb/v2+9HM8x3M8x/clTu8t\n", - "PHy0/X3/7PsuBPXe+bEf+zH+3J/7c3zhC1/gp3/6p/8eIUhE+MLP/ONogBMQgpoSxPxzQwxCBS1C\n", - "GIQ5boqqgIEqRAgCOOT/l/xZAAkQH9AHo+0wBoKjEeCO4hiOCSCDESAKioMHEfluxANEiBCut0o1\n", - "P4OaICK4O+4OBGMEvQWjO/u+M4aDBBE7D99s3Hx+IQLMDJGCiFKKYgalGrUWaq3UWliW/LdZYVkW\n", - "1lqxYpgoRNB753x+5P7xzP3DmfO5sW2NCKdY3juxQEwQBaoSDNQCUUFVKMXyZ1HcAx/OaM62OyEt\n", - "72s+WSIEsLw37nlPXBEpqAaHo1GrUExgBG0TpAu/9r+94zNffkFvsG8bbQ9GF9zzulag1GA9GKUK\n", - "ughlKQigNvAwRjfCFVwYwxEq+Tg6IoFgCPDdyzkiGCGz+gnwQFXBBBS0Cq5B+EBFcAF3J3zQ+4Ch\n", - "MPJ9ehdKAK6UItjRuHlx4ObFLafblfUgHA4r67Gw3hxZ7w78tf/ub/H7/rWfoS6VshaC4LJvnM8X\n", - "Hh8eePP6De/evOXDb3/E/duNvsH2sLHdN3wXGDafc+DdkS4QBn1ABMbAVEACUcUUzGLeTwUCMcdC\n", - "IRQRwyNwhNYdpOAilINQD4VyUtablfUYHG9WSg1KBYmChDLGYLt02uZcHgbbBdpl0M/BuAwujwPf\n", - "Bx997SNuPrjFzPK+K0AQ4lACnXtHRaiHhcN7Ky8+eMXp1YEXN8d83yJEOGM4rQeP7x75+Ftvefxo\n", - "J9xRA7VPXlfNUIQhc7+6IDFYF2E55L4q2hACFUULqDoigxiWa9KdEMOXxl/5E1/j/y01ft+RZimF\n", - "n/u5n+Nnf/ZnGWPwR//oH/37KudaKt4GwUx4QSY9EUQgYgBKhOYfISjg4ij6lDAhkyQB4YA4IYNC\n", - "YDIoq6Gl0M6dPjoxBqaGEIgDEngIoiMToMyNN19cPCDi6VqOgxiiMh9sbkQRYYyBqmNlJqFY88H7\n", - "eb5LBTLxixQEg4DegkAYOhgREIqHEATJdijeYATECLD81L1Bb4K74iPoe6P3garOBBeZwAx0MVAw\n", - "NUZ0tBgqmUyviT9cGCMYw1ENIhaIMW9uefqMIiCihBeg43FmXY6UQ6euhaJC352qxngIIqDtjbY7\n", - "owV9z/cWHojl9a0qYoGZYqpcj79wZXRyHYRAKCqF4aASoDXzofd8FiL5+d0RhGqCXDev5AFiZgzp\n", - "SJnPORyrSo+BAqM5NgZhSmwDcbDN6VtBeyYONuH87pHLw8bjyxM3dwsv34fTqyM3r46cXrxgOazc\n", - "feYOWYJiFY9At9ywIY2tVS7bwuHuiKixbTuH20I7DN69vbA/7EQTdBRkKB4DjQEGJkZ4ZNJUEAlq\n", - "hZDAaq5PJZ+viYFn0lQPRh9zXTaKFRZdnmg1M6MWkLl+Egx0TBfCBVsKSHA5D1rv9A7hQu8dhuT6\n", - "JBAJIgaiiqjgRB7immtHRZBFKTcrL95/xfvvv+LmbqUcSv69ubdaayxR8b1TF2W5FaIHixo+X8s1\n", - "mG/3KaG5Zx5pM/nijqAYg6aDKoao4gwwwU55b0SMKN87LX7fkybAV7/6Vb761a9+718SwSzRjTig\n", - "88ORH1b0mkfzhoRoogTN7B+Rp+v1NMhkm6drELnxuhMMajFuXt4xfGc7X2iXnidRglMsBI+ep5Ab\n", - "EfkqgyAkF18mi0zd4ZEIGZ/XnclTlMiMT4RTl4HQaT1w/2RRMpOh4KgKnussrxtBHw0UejcusbFW\n", - "RWNHCWQoQ5OK7n3QwxnuQKKLNhpqsB4OlCrUGmg13AAdDAYmhooiJjh5yKhmUlYV3EBHPoThAeIQ\n", - "Mp9ZJm7H5mETnI4Lx9tgOQliA4ZgKD2AYkQIexvsO4wdeELsibK1QOj13uQBOno8rY8IRdUYYyRq\n", - "FzIhIBPx8rQGAuhjAFBrQUxAwEVAE9HnQQdhWeGYDELnAYNTVmMfMHygVRg9oARWwS+wD0d6QRDe\n", - "vr7w0BqXccROyp28gMUopwJFqIeKLIbMe9vGeDpwSzXWm8K6wyDwIvS9JRK6ObK/W7j/9oX9sYEb\n", - "oSNzP4rYwEIQCUxjomynmKICGk6ZC1wJ1PLPR0RWSOQzwjTXXR94KKN3iqy5RlBUHTzXd0QmaZeg\n", - "LsZSYWyd3A0xEyLzH3OPQu4hlUR3ZghKVcOWwuF4YFmPrMuBZV04HAqiwnCn957PtIFVYb1Z8OHE\n", - "KHmP5i4UCURyHbhnyaiRFUJ44EM4+0Y3yfuDEB2MzBmqFVOhVAFzQj+FpPkPEjL/qSKEOshEkzbL\n", - "ilBQcORpk43rQ4h4SlT539eNELhDFUUjN10RQ3VAbNSiLDcHeu1c9gt9T7geIWjovI7P12MmP74L\n", - "8SWVEKGEg5RcKD7y/aACkYm6mBAmSIFoC4Ryeu+ClYKpJpKer5mnnoEFEuARiVolMXb4pBw8KKXg\n", - "lkjZfUzkrBwOB9bjymHfGGOw1EpdjLKSi5CBqyIRhAxCZuIXQJU+OohhVsCDEUEbI8+oSITs7vQB\n", - "ogrSMAuWg/DifVhuNqJ21A+MJjiCNzi3TnlhbOcgXAkXEMe0oDYPLQtM9IkS8WAeool4BEMi37tP\n", - "NOnfvZYmGhfJTaPFMBNKrQz6TBx5KAcBcj0AIaJDIWmLAmGB0ykO6gEDYh9ggZNVSvUFaUZcgojO\n", - "6J1gpYnjAl0D1+BHfvcXaTJYrDKGE70zxsCH4zFo0enS0INj4Zg5UQUW0E3QWhi2EEB7O7CuFBNE\n", - "BdOspBhBsSUPqxCqKhIdm9QRVzRPTBQyEqjoRHs2KYlwSih771wuykJgItgslSHmNszDxUywItTV\n", - "6K1Ti9JbJv/lZpnPJaslwpEJKlSUoka1QlkKh+XEoRZKMZZlpZaClGBBGT5orbGzs5SFtRY4rbTm\n", - "TFLuqfLJ9ZlUwPDcWx6DsIBYCFcaTphQXJGYn18NJ5O6VLBSErF9j/jUkmaCJUWAMXeAqE7EJYQp\n", - "KoFcmc4IPCCuvBSfJE8RJcITytdKicAkKNIxDRYzwsFjQxzUnGUxii301pHJYfpwfMRTeafzupFv\n", - "7lrJ4T4QUfoOVgIrExEJ4IqVitqgnhZKPSAiXLbB7atKayMXMgvugjtIZuanUl9nudx6cnKmgscZ\n", - "P8KB/Jn5bNdSqVGAFQTMXib61kS7Ho7rQNhp44IF7JGJIyyImfSxPJ3H2PEqIAY9kZzoYIhjIZiC\n", - "LiCl0hnU96DcDpbbSlaOBY/B/RBcKiMa5WahP+4QA7OSaJyGmKFFn0rJCcbxAI2sGFTyf4RMOK4L\n", - "3R1RY4yGzsSgargPVAUrhmqiDzyTjE80ThTcFYsA2ajacauUUhi649GIIkgRNGCMPHw5G9zm87LN\n", - "6UzKJoKbm5XbuyOn2yNDgt4b22XjR37yi2z3G23PZ3t+PON743x+zeVypp3PtP0NqjvLKowYSBWk\n", - "O+NQGJcLCw3dhU2U9jigTbRkA3VBqkB0ihVkdJLjVbwHVibj75J8ogcWSROFg5NUjlaoy0KilGDz\n", - "Tq2SPKFYrgFJ8OAjiA4SShGlW8dLJxi5R0Q43i6zapqJ0z0Pvh1sAVkLulbKWlELukyeuRi2VpSB\n", - "hFAtEbofhXLZWG+PSZ89XvDBpMUS6EQkZhkek26KWXlO7UNmbTIUrTrRaVI1VuJJpyil8P8l8nx6\n", - "SDOSnwyUrJmumTORg07ElaejZtUmgWEwq0Wd5XnMcpgIRmt4EYp48jMiecqq42MiQXd8DHrvDB/I\n", - "TMSlVsL8u04vwefrf/edlHK9LvhIvsZUQRwtgZWgHhZsFY63hWU1RKB35/FhsF0arXnylCMYzfGW\n", - "5ZGoZVKVeXi40EYnAmrvdDUEo0jBiqUoYZqCilluAjVUoHvnYXtg6xfcdS4qMIzuSQG4CItpJnxA\n", - "SX4UPDedAmoUMYLOUozD8UBI54P3P0Drh/jq1JPz8nDDh6/fsNgtnzt8jm88fHseBj756iyd1RSr\n", - "mgjTcvFqkSREAiRsIlJwyYSeqEWvRWUeXJoHGddKw6CU5EbzYG2UsmR6UxLtzXXm4ZgX1Au+7/TW\n", - "oQRis8asjmqWky12OAyMCj2RsoTRVChm2K2yvLBEiQS9Oful8RgX1JTe79mac7lsbPdvGHGh7Rf2\n", - "2MAiS1frHI6aCL13aAOTQBvUlwkdhnX0Uiie15FZhYnluhZNMfKarCTy8wwfyaGP/FvJD6eeMAZZ\n", - "ZS2V5WTIKqyrUEsKkeG59FMkhNGdvjnnh86+C5dLZ+zbU4KSKciGT6otrpz5YIggA9gbUTM5aVFq\n", - "dbCgmlKXOvn+POiKQCFYa6GvC6MP6J6v1zt1sdzXwBgdCUF1lunzfYcPUJ8rBzx6ygJk0qxLUIpS\n", - "S0U0GL+hjvl741NLmqhkCc5MjoCpPiGCiSvQma8yb11RZUzy//9Rpo/AcbokX+EST6XXVXggBmMm\n", - "TG8d94GZTFRjHI4LrXX2vefvzIQaYYl5NUvXCEekEJHoIyIokjff1mA9GstN5XhbWVflcCyEwPkx\n", - "eHwYXB4b27nR2qBdBu3S8eZJ2GfxDfgk1mEWWIxwKolOTSzLmnV5EkAQmSxB5O8YmAh9zFIzoOMM\n", - "aUhIqoWqeYqFI8WoXRlTUNOqXJmLZTEOp5VYC7UYt3cLn7n9IqfjwtkeaKNxexi8uzQk7nPjemAB\n", - "AyGELL/MU/CxLLVtHprpKsgDIAZoLYgGoYpDCjoB1wyvT/xxJl+1T1wUY3SsMJ0L8w5OukMlGHvD\n", - "ZdAt+V4phg6HklxIrAMxsGQEkTWy7GvC0MBiEFaxCuvLhVE9OWIf7K1j543LpeNjsD1sPD5cOD8+\n", - "4P0xHQJl0HQDazS/oKvNAwJEByYriwh+R1IoRehqxMfg507VAhPtqkyaYUqm10rIiUTskyPOklQZ\n", - "ozM8mLUUVSpWFg43leW2cKgFLYHISKFkCnIqwj6cCKX3oO1B9Cy7e8S87m/c5nGlgOZz8p4Hl1Zj\n", - "Pa1YrZSS/H4EeB/YkodkH0kjKZ6ARBNlsxQuW0ct96EVoTfHPZ72dkSKUzE58YhI54kFBcdKckOi\n", - "nWU5pEtFDWSko+Z7xKeWNEMy70fko3sCciL5mCTRT2j2s6MFF33iD6/8V4RTEcIMCc/Nt3dambwF\n", - "QtVU8ojIE9P9k0SLECMtC5D8zuF4YD2m0HJ+uNB6x2NPK5RADAfRabfJBbt74ApWVpZDpRwGp6Nx\n", - "WIPDTeFwLGgRDkflcNx5fCfcm7JdHBUnuCT/NhJ0p+UmiDYXm6Sdq5jh3hjREQolDhNt8CSSjRjJ\n", - "XclALEux8EzAw53Gmc4l1cZY6VKolKRDYqS1q4BJSWuOOGbCertQqnBT065TS+czLz7L7/itv4Nf\n", - "e/Mr/O1f+zt85Ys/zq/8nb/Nu965XByLI/Q2bWRB8eTqVPI9myWpn44FmRtZkGL4LPcEUCtoKH0S\n", - "vCIQPbL8fqK9PxEgrg4CVU1kOhz3ndECuqNXLgDHqyM1cAt0CUQDOxuyBl47elBsGBKDMMdYGAyO\n", - "y8COJ0oNTAcRjR6F8/meve2MJmwPG5f7C+3hkbZtuDll2bEykkKpG8MajLyeYSx2xEuj2IWVRJ9d\n", - "hNIEzpLKdkvuVmJndJ83oGJy5btzPRZN5biPYPSOSSW0pmvJgsPBkIOiRTFRFikcyoIuSkiH6rTW\n", - "cXZ8DA7HQpNOsVxnQbD3TGii0PqGT+FI5Fqp8aRUO8mHdmAbjRfiRBhmlRAYGoh3+tQXPAaDYIud\n", - "7htCY8QOkVYzIoVH3NHh6LSMJcJ0Rneiz+pUAz0IshSIgmpJkDN51qvw+APLaRIjM2JMFRtJdKSz\n", - "5LiKPpPXCkB6Ehd+tasAV718jIZ5CkCNkYmtgXnB5waN5jBh/ZWQDx/JWV3FHk21eC2Z6A6HyuPD\n", - "hcdto/WRaFWZpWJakCTrAXxA2zqH20P65pbkbZbDwuFYWU4FD+V0e8SWM8FGyMZwp7qiZlkuiVJK\n", - "ydN5xKQRnH0MtHVEEyUMz2tLgaozuYgR6oSk/t9bo3suuK3vNG9PfrlSBGJDLeZSUMIiLV0T1Ys6\n", - "IWDVsLUgFZoGv/23fIHPHo9svvGtb3+D3/87/0V+5oe/wf/6N/9n5L2v8L+//jq3qnzUO92CauAO\n", - "LIGaohqppAqI9kSNCBKJADQEUZ3I9FoiOurTeoMwiMl761RPAw/PezDXz+ipsPY2GHtJKoYrR8p8\n", - "YYgxcl3tqfKKAppcnmrSC0U0S7dDAzOqVqiOLIauyhiN7aK0PfJ+P3YuD432bmfsG9EHIhvlCOut\n", - "oSURFBJIbKgsyQwcrnROPtMuQg1lbEKcY4pIggxJRxiWSr8k7SA4Irk+xp5IawyHMAaKj05gLKcD\n", - "68koZcU0RZUg6KNjPf2zWst0qCw0WtIYUliOh/SO0ogubOdt/p5M3t8JHJWCBnRvqFmaMKZvWNRp\n", - "ozPoNG/s7YxvO8uS1+y9MUba1EZL2iwrvClyxRQNfSTX6mndU7Mnx8eQQdHpwQ2f+UYoRVmXSin2\n", - "G4QuUcVlfM/U9aklTZ8+Sy06b3Au4pjE+xgdsykKiKVyHkGPSJ/dGBRVfDgGFE0exSOQKIQ3ugSP\n", - "rU34n9xGjA0fDfeOBti0OokUcvdMo7RBKcLhcOBwXFgvncvlwrY1tjZo29xtAAxUChLBtjXKo3B7\n", - "d0fg1CWtDHZQyrJSy4HlvRPLek/Eh7QY7L1zu55YygGPTmudPhQfAx87Mgpsg74722hEG3SEWivs\n", - "gdpASqVoIWzgPvAQLm3nvF84b488bI8Eg903rM4DySPft1hSIbO8l6sX6+oIsKQWTOGkynJQpHVe\n", - "2ZHf+ZP/FLYrv/0zX+b27vfwMz/yz/A//MKf4f/4q/85v/fL/xi/8Ou/zDikx/Z83pCaIqBZmYRD\n", - "Jo5UhI+ZrIuiYmkKXyopWUQ+njYdBt+t6k4hr0CiVfEnQa2NgOFEGxhpObqKBOGChzMaRE90G8WJ\n", - "qsk14pk4C1kKSmBK+iSrYBLImrfJbeDhyfH5YL9snB+ddx8/0t/uVDWWopgKVuMToUYLIwaVymp3\n", - "3NzeUauAdc77zo7j0YmtYQeHm4J32NoguiEudM8N371T1Kag6ogpe480t4/OQPDRQQcNoUb6pcti\n", - "T5zkvjfK/IziwEguOBs4sgkgXfRKWQveAquCbB18fJfGkBYyTZYcRxBT6lKwalAFl0GLneYLe2vQ\n", - "glWNEQXV5OhNwLeWHGzkc5PJSUgk/yuRe3vEpOCuGoM5lQWmgFVMcJKes3JkXdd0gJRCqXVSAntW\n", - "pd8jPj31nBQ3+mB6IZlewdzQViRVVsnSSiVPKSQ3gSHQR24gdySSU4pwNAQkOzBa2+iXjnpj0Blt\n", - "J8Y+OTyoJflGjx2TgtkxN7QoIYWQfNAvbeF4WHh4PHMa0PadbQwue08rTfTUskK4PAweHxo3Lw4E\n", - "wlLTnrHUA6flDimV918tiC+If4TxbnbnFIQjrScvs22d7dHYt473nRYP9J6kPlJQFfZ9ENbYtbB4\n", - "ohcXGF3Y28alP7KNgUewj45YLjoTQdWmT81SkY9MnIOs9lTBtFx1OKQrx9sT6+Lc3N5Rjq/4/PEL\n", - "fPlLvxV/vfH2419lffmKP/jVf4vP/fBP8wt/6b/hW5/7NV6fjW++u2dZjjz0dygdvVIdIZSyMq7W\n", - "hPnMy1I4nJLTBFAXvEs2yfhAwhJxTluLePpOccdJOmJIcqkEhCYnnXam7LRxRooCkV7S2CMN/qXh\n", - "CmudZZr4bAzIikQjX98UlIJqZfSBx4bvjb4p9/cX+tvGeNtoPQUtWRUqtL1Te0lDvg9KPXJ7vOXl\n", - "y/c5HVfqakg1tv4er998RPgD+znAHDejEVSpuAShIz3HbsndKwSOaFBMaZGiY0hhdJn7xXCH8/1G\n", - "XQwrhePNTXKYnkKIaf5/d8cJXITQBSc7xmxeWwvEErBoHq4klWOWrzGAUbIjx4pS14Itii5CXZZs\n", - "NAmdNEqW9b11zIy+t7S5tZ029nQXaHYAmRmjd9LZP3NHa6mID5u2oxRnrYBowT33vYizrpX1sLAe\n", - "jLUYIqlpmFZa1O+Zuz49pDnS7iAI4leTakHEP7EZceWnpol5yubCTJSTtzCYvkdBNZK8n5xIzD/r\n", - "YzAi7RfZQTOSIbAAUhmtxZ6UV7OSnq0s5pLnEuF0szK60KpQx+CwFHrb2fZODMcjO0revL5nPQll\n", - "MQ7HQT1m6SlWKFaxVbi9VfyzxuF4w2W7YJZl5RhpnyrbBafTxlXMgt4b3Tt7V5or9ECbU7egnAxq\n", - "cl2+5+LufdA9aOFYKVMsSSKeef9TdU9RRlyTR1VFDFRScAg6g0HbGp9/8RnevXng85/5Erftlr/z\n", - "S7/Cm49+jYfvfJtaFo6fu+N3/b5/ld/ze/8A/8if/I/4r//yn8Hlhnp3w6987R1aKsQnXklXxyXQ\n", - "sEQja+F4c6QsyTWNMdDJ0UU40pUryv/u5gbvPqkLAEdCU+SB9H0yBcSrH4aJOOePfrU2hVKuwiHz\n", - "z53Z3ZKcuE4TOdf1KmndGgO2fWc/N8Yl27hkFDw6wwItBfMs4WXN7qdiJ17cvM/7Lz7g9vaGuq5I\n", - "FfZ9o8gB+A7b43eQ/cJ+DMbB6eekMwh7uo+1LBA7alBPK7oWLAxvg+0hGPeT8x7ZUCEhPJ4b9VhY\n", - "o3EoilSddIfOvXNt5Eihp/fB6Lk+YySFVCLFNa1KXQ3PooAgK0A1RRelLlnBWVXKalACqoMGfexI\n", - "V0bIVO19rvdBa3vqCp5VRhvZpZX0tqAy1/LBaHujR7owxkTbeD5bs0o9rBxPaQNc6srxsLCWkteL\n", - "QMIY3r5n7vr0OE3Ph2C1ZJeCpOBzTRzERA+S6qszH+LszNHZJ83Idjks0aeMTzbjCKaBNzc+I4ne\n", - "LPcdGY73YHfH/AErN1gR1rqS3q+Yfr+rutd5ajfL5ne0DIoaRYXdoc9+8+0cfPThmVIry3rg9rii\n", - "hxUoSBRKqdzeGuJGPR54eHxLaz1vjTuLK37vlMuGXXZUUwhKFAoUZ42A4ughWGrnMLLvO4ZlohXA\n", - "FoSgKAglPWmmaEn0e3UH2DTWm2kqnJCoJUBQNAr76KjAD91+wKFXfvt7P8rf/ut/nXePH2EBN/XA\n", - "/XZh+9XBn/+T/zE/+dP/NH/oX/73OL56j5/7E/8pt+v71GJ4AZGaz0b0iV+8dpUsa+F4WLBiBDui\n", - "0JvinvdnjJ6IEUnVOAQRw0cne5wqk5BJ1VTTf4jMxJdaPN6nNcOnZW1azBhp9XIP1K/qe3aK4TyV\n", - "junnzbkCY0AMy0NqG/jWaJeOdJk+YOjNqcXYtz1bCncwX3hx9xlenD7DzeE9bk93nG5usQIP50cI\n", - "wQfsl8Gb/jHRO3V3ojvS0vWQXtqYB5ywHhdOdyf0JJhku+GlDdo7eHh9xs+JArUa9aRgnTF2RI55\n", - "iMXI9TNdCqIyu5gSPCCOidIh6RuFRQXqVRidcxtm5YJp0hkraJmwsOiT1xgJ3ButAT0PxmseiLiW\n", - "2/lkR+9T4BngKfaN4Skmdke1JsiKhrhPNG+zg0hYl5V1rRwPh+zIWldWs3loOs4O7QfUcmSTe/D9\n", - "jJSSCpqSCASSlwzQ6vQQstcgRRIfYz44R0pQ/CougOosETQXvXkQYQwF1cYwS1IcoyNEG8TeOaO4\n", - "XUAUK2dCVtaoRB34HG5BTP9ZJG84vCcnNmyqvoNSFkTS7LudG+8+3jidjlxewl0o+9mRNXtzl/WA\n", - "vFzgcia0c748QIDIApGlt9pIm4g7Ixr7bA07VAVrVFtY187xFnQFLWPaKwpjgA9FRxq/hcAlBapa\n", - "O1i2syVZmIdEH3NjWCAtu0v6CGo5cVLj4eEB2+F3fekn+ejr3+Dxow9ZxAg1ugifffUB948Xei/8\n", - "rV/8Cyw37/Oz/+y/w9d+/SN+/n/6b1lfHBmSYkWIgQ6izxMeqFU4HoWyDrCsJtRn+2oYLn3mP8s2\n", - "ukhrTY+emzEUdT7pdgoluyolr4kQs0datUz/YCdIIm8EWHNkh2FO1Nm3Lx3X7E4yZuPA7JwKLwyX\n", - "RPbbYGwD3yDcEOk4ua58L+wE6+TkRwsqxs1y5ObVK9774DO8ePmCYiU7uCzovKC1zsP9zrYHizVO\n", - "1nnjZ+7bA/IoyKVMm9lgPS0stwW9Cepp5XCsBMLahX4Hx/cPPJwH/bJDFCwqlB2PQffOEoURG/tG\n", - "OjIk91wtK6LC4iV9n0w6wOLJ70tJ2mdEZNktcxCPZouv2RzEY2mWKprrPGIwRlYZqOe69bRQ9dbT\n", - "XBzCooqr4laQEXRaUuIy76dfe87T0kYUCGhxRqiUpWBVuT0cuD0cOZaVKglg0npos+mmf8/c9elZ\n", - "jnyfiDAVQNFZcj8ZvQLXASOTBggtJjNNijSKQ/Rs51qmy19nt1HIkxXa3RmuhNucmtJxMSANt2NT\n", - "/OzgDRmsCARtAAAgAElEQVSPWWbfCj65l08UthTXR/fkUz2RLmNkyTNVPFEIbSDG+bxxftx58/qB\n", - "m9MtL16s9H1QbUF14WYtk9jOz9xGQ9XoPvuFZRDijPikx/r2xYH1MHAdHA7K6WWlHoUoWfr0lkZw\n", - "ruW2zO4JND9LEepyzIX1hJwTyQ5JZV7EEynIgnrHZUe78uV/9CvUR+OD5Y6/+61fJlXHzt3xltZ3\n", - "3t5vrMfC7c0N3/z4kf/rf/l5ylD+zX/jP+R0+Zj/4m/+Rb51/0Ctgmu2W8YO++zAWtbZ/qm5NoZI\n", - "zh0wJaIlGvdrt3N8cjhOGxpC2pLmShH35MrmPQ7vmcBmqf7JzIJZhSBEd6IVtCjRUoHu4ZSSKOuK\n", - "SmqtU70W+tU4H0LISAQmMS11uc1CheY7qxvsQl93TI4UO3E63PLi7iUffPABPjrNOzymdWg7nzke\n", - "T5z2DZeGSHBTXvGuvuXDb3zMw3lnGdliWQ8L66lk8jyuuDk3NycCo/dGa4VT6+xn5fLYiJ52PilO\n", - "jw2NQHykMyOSJx7e6K0hGMULyFUY2umN3HBLfkovCsw2To90dqxLcsIyRV/NykCQp30l0/+sEbPn\n", - "PEFV74225fssnr3xyMjhLpLDb6JLCqSztVKuA0csoAsegg+nVFhW4+Z05Pbultu7dfqFNd8vzijG\n", - "/vefCPcUn155PgYh8+w3YThPnTbp7+pc+8Bllk3ppEyrjEqOrSo27ceWVpxSCuJpDk+vapL47sDI\n", - "pGmtMGRgutK2ThPJKUj74DGUMc7szVnXjWWtLKt94iec01uyIyEX1xhBDOjj6pcL1CqqQRsbb988\n", - "UmrhsJ44LnfoonQFkywHaq3p/POV/WFn0HPARd+y93bsiDl1hdPNwrokOswxXoV67Gi1ORbLKUXx\n", - "UHwIwVXgSVXViiYpL0tynJqTqRQYdWTpu++0lpOHIpJ77mPjaJWPP/xVftvv/hnefvsdKsG6npIH\n", - "NmeRRA0qha1tfOkzn+fx0rj/5i9RfkX5g//Sv8svfONv8MADodn1cfGg6YDmqBr1VNIjWtIqU1C6\n", - "pxjYe/baf3e0qajmXQfIlsFaKzfHwxTUtlkh5GYlkvtm+BMnep2sk5vYGLvixSk9J0xZrfh4wCyr\n", - "lFzCA29ZxspIe1iQliip2dzgF6Gfn5oucR+0PUveqkdUC3VdORxuOBxvETXWpULfWMeB0Z26HKhL\n", - "lpSDRGRbdG5e3hFeKPGW/aPH2ZUWSBXKsaJVOJ1uoBbWdSV0ZfTO5XHDlkI5dqKD9wk2ypwDoU6t\n", - "lhO9NG1EWYykJYk0VFDGgqrnKMQBIUmDqFi2sorOOQXTLzsV7xR05+i3FlweL/TR5yjDK8c+QUjP\n", - "fUkkIGF4WpF6Guk9YLFCqSkAEvDJZDRAIl0lngNc7u5uuXtxw+m0Po1eTJM7iHcue6MuP6ADO0Yf\n", - "T5N2ZCLM1HImYS8pcrhC9l5lAi0CFk6d8wPTbhMsdZYDGlgkz6n2CZcFOS2lt0GRwjCj2Zhtdxtl\n", - "Wejnwd6D7XEQY6fVQV3aJLCvcx9zEYw5b2NEmuNHS8sJMlArBDmVRkR4e/8OOSjxLXhxukNule7C\n", - "8IEtAUsmEMSIcPq+0bad1s7I9CKaBq/eu+WwVsZoLMvKchrYMrCl0n0wYswSqLL1gUvgmgg0Zktd\n", - "sbQYqU0fnVXMjFIWyhhAx03odbYPSXZTvYwjivCFFx8g0tiaU2UlAmo9pApcChLM6gDO+4X1uHL/\n", - "4Lz5pb/CT/wTX+SP/eF/m3//P/sPuL9JwWu5zA6WCksRahG0xJPtIzwV7D4850o+dUgBksXyJ2P5\n", - "jOHOejjw4sUt77/3ilILb9685fXrj3l4uMfDnoaBgExf8LU1M5FKDGYPclYUNpzLvufAiOFoyefk\n", - "PRNEMk2zUYKBrcZSCvTCWCp9aVzuJ6obOfEpFnjv8IrD8cSyrqyHBZH0SNZ1ReYcz701xhhUKxzr\n", - "gssBr45qowSMsROXlcswtod7aBujVdyDUgt2LGjNTq5kjVfKslJOO/t5m+28OfijjzkZRnsm9YnI\n", - "HXlqSxwRRBmIVdbjCg2iOccbxyOT6/D+VDWqXscOJpqH+bwRfAR+cRxj905ZDanzOn16Z/tgvzTc\n", - "W3LR7knnSA7nMRH20ZKl1jH76XPWREQOTtECxQr1YNzeHTkcj0lRLWtWpSVRlUj6xkf/AeU0cytk\n", - "+SFkyRQMrmZ3tzTj5si1QDTJXiEnpkT4PB2DtQa1+PT3pQl57gmUmq/nadkQM+zKfdiGNUVN6G1A\n", - "KWzbYN+cfR/0NnBf2C5tNpMpUiSRriZ6y0YWnzMKp4dNHSkjrTEWGJX2cOb16Pzdb36d3/ZbV+ql\n", - "54K14HBac+bnvjP2nfP5TO8pHKSAGxxujJvDylJyKLGWkbaNWnFt+O4U0hAeDlYUbZLWIolsYwyn\n", - "xZ6KrCwIimkBsVSEJekMWZMnHb4jmsNdDwJrOfDecsdNVB4+/pgbLdih5tP0nRiK1kMS+aXgbbBv\n", - "O/YqWC+V//Ov/UV+8g/8K/z+n/oL/Pd/43+cLYw5GrBKJoXjsiSnrQKec0WH5+DbffPsmGKq5h6I\n", - "lqfrhcNyKNze3fDy1S3H08pxWXl5e+KDD17xne98h29/+BHnyzbR6bUrLFFVQIp7qkm7tDm1qCjV\n", - "jL515uSXXI+aqNZj5EEkUCqs64Hb5cAit7Rd2S8b928eeff6zP39DqYcTwq1c7q94XS8RTG2fWM5\n", - "Lextp/fOvu88PNxz2R4QOoe1EEvlfGmsGAdZWPVA2St+vmdvDwTBeNzwF6d8TxROp2MCCM3Zouth\n", - "obbKflh4OKclz0ebFVrgUVHNIdDi/kRtiKcAqnJAerLAbopYzdkNVhJZzohJKfXeuZx39r2x7+Np\n", - "zGIO4pYUxlBa7Fhkg4dEosrRB96zStDIqnP39GZqUTyViXRWkKwIZF4ID4oIKsrN7YHT6Zb1aJRV\n", - "WQ9lzj8wsGn4bx13aO0HVD3/xFwtaQVi5Cg1zSnp0ixV1atZOdLRr5aw3FBMB0s1ShnUIpgFWJ/J\n", - "LHuzr3PVDKDniTNc2fpgsYWxdawavhleB1I6WgKisKwLpeQEpcfLzn7pKeTo7MCxMk3Wyal136lr\n", - "JUkVsCW9oqFO2zZ6DL718Yf80Oc/4OXhkEZ8qeyXC2WtjP2Rbb9w2c70FhCCSaGWLBnWY6GaUWxk\n", - "H+0sZ5qnr82jTZ6OXGhYDkNhGo/JMreNQWhnpWZJGRAaDOlYUYqmN9Vpc5EoL25vKBfjy7/ld8C3\n", - "hLt6YHt4pB7WLOE054TevXrBxx9/hPeWNhSUr3/9V/mhz36Z9fwhb//6X+IP/8F/nb/8N/8i3ZXG\n", - "QyIigXWxnA0pyb9ezWe956Tx60H5NFVPZQ7mzYnd9Vi5u7nh1csbbm6OqcKvhplxPKSvdWuNfd/p\n", - "Pd0CwnWKj0x6NysTF52dQpr8Y3VKU9ymYMl1jmpWQMigLJWDrhzWE3eHWw71hqWcGA6PH1/48Nuv\n", - "+fZHr1EbHN8rHF/d8uLlC+7ubvPAD6HtO+7Ctu28ffOOd2/f8e7+Na0/Um0lUEyDoZn0rRq3L+6I\n", - "XbDYuNw/Evtge7dRj5V6WukjgYea5VDiqhxKpdQch7bV5PEul8s0sE8PrCYqL2SjQ04eWlOk1exl\n", - "t9WmUi6ILIlLp1Yh02UQwzmd8gC9v7+wXXb2ts/uuizbr7NSfXeipBIeIzuCZAPYYXaQpQ+0oHPY\n", - "ycApcwBvG+PJ76vzWxFuDyeOxxOvXr1gXVaWo2FV0/5lqSkMz4aRFER/QJGmj45IycEMRRmRfkui\n", - "Jt+Rhro0LwvgWW6L7FgoGg3F0BhpXrUxOREy2czBD3MOzjRx56i0ll4kpKV5e3RhWBL+DeH2cORw\n", - "OFFsdiaUnBR+ebzw9s0Db17fs507Rk/BNkp2hOqVxNbs+RafbX7JZVUMH43X9x9zOn1uztXsqTz7\n", - "YPSd7fHMtu2Mnh41s0JZjPVQONSKlZz5V6bYpFVpTRk9T/wY+ZUbY8tNj4wcvzY0v+IghOaN4bOT\n", - "IwrLkgR8XWT2mRuiwaEe8++P7D3+0c/9BF+qX+ax/938Co6b0xwiHUg4TYPXbx6AlXZ5xzG/f4HP\n", - "fvB5Hi7fpK7v8+4bv8wPff738y/83j/Af/VX/zxvR1qCFiss5TpUSfF0lNC60z0TepROFaNb2oWC\n", - "wFsSbOoNZ2M93fHi9pZDNQ51Qc1YjyvVDIrycH/P23fvGPc76ehVcjao0XOZZVurCuhC7w3tig4l\n", - "6GlZMsdKKsjZu5hVyEEX6nLDq/d/iLvbG16sL6aQZoyXzvuvXvDZ+5d85/W3sdX47Puf4eble6y3\n", - "K0Kjj0LZO/ulcf9w4e3rd3z00Xd4/fARgrPW4HicIxMt2GfydFFqNWQ90B5StNk+OqPrgtR7mjin\n", - "21uMPue51vQDke6UOpgT/+fEKYzer5a7q8CqmOdXiuTwlIqxULUg6khMblAmDz77uNPGk8ffuhZK\n", - "OXHZCvePxuM5u/PC95wd6qlpjL4TfXB5POM9hwgXGSwL1BIsy0IplXWtLMuCLalh9HC6j8wt4U9J\n", - "9VRvuL25Y11XXty+pC7G4XBANfn9ER0L5RI508H5Ae0Iuk5d1+tT0FSiPQRkmp9jzgGUVMJGTB/j\n", - "FAnSAjS9dpITjuY3xeRF4koOJ/yaQme2iIlyKNlto0L2FYuyHBbWdU2Or1RqKdRSMV3Y98bdi3tO\n", - "tx/z0YevuTyc6Z6nk7iglr3P3jvesmUudqEV4bgYx0Oin/P2Fi2vsFoJCbrkIInNd7p3RmvM1g4g\n", - "DwA1zQEMlZwl6UlXjFAue6c/jfDKBKo6UfbQVIs9h8z24TkZvu3IKsgxv8bCloXR82suiBVc6OMd\n", - "WoTb21t077w+v0XLhm0N5zqCbo7iGjmI4d2bD/nsZ36Yh95n947zcP+O4+nA/bt36M2R7fU3+ee+\n", - "+sf4X375l3j75g03dzcMyQpBMa6DUXRaVpxHaknk7D3QEYSkn1RqtsbJUNpwzucNPiOU4xGryvGQ\n", - "ooSp8uLFgQ8+95LH7Z5vje8kVxZpbxsC6PUrD3TylDlBx2PktPAROS1I8neK1Uyk85BcS+Vwd+Du\n", - "xYn37t7n7sUdh+OJ0oz7hweWg1AfC7fvHXHpvHjvFasV9svGUlf2Lb9ZYL888u7dW968+YjH+zf0\n", - "7ZGtbVzsQu+DQz3gvdFDszWydHacy0gSSfzAdhm8/vV7usP7ZaWXHbMDZXa72PySnVEDjTa/miXY\n", - "tj7tO9k549OcWgRQzf3lmQTTHZB7K+Q6jm9OLpC04F2/qWAE00+qHE8rUrLH+3IZ9CHZreZz8n7f\n", - "aXtntJH2sJ4zMKPlvpXIr4qp9cjt7Q2nwytKBZeNbey07SEPAEBLYVFjXRdOpxN1LSyHhbCYQ2EC\n", - "xmDrF1pv89/fWz7/FAd2ZNuAzgHCXGf9jUC0409TaHKAwtWAPCS/U8eM2Zs98E52fkzbjuic3Dx5\n", - "bUiofp2TF0ROCxqwrjkcIJozKpSysKwHii0c1jW/6KwsKOl7XA7r5EQWXn/4joe3Z9plRy0ntbh+\n", - "ktDpc4I5QSmV42lhvalYce7PH3O73GElT+Y2bR4RSXDHSNEjSXNNFXUtOXE9AmYPbW+dy2VLq5AH\n", - "MYxxnbcYQrVC77nZcUVcKFa4tAtEQ9iyfAtlWXJQyPAN3LG2sNO4XDqrD17e/hCXX9/SMjJycIRa\n", - "nVPAgzF2TssC4dzcvZptjZ398SMez4NSKr/6jW8jy1/jK+99jj/0T/7z/PJ/+Z9wLEZjfjeQ/t/M\n", - "vcuvbetZ5vd7v9sYY17W2nvt29nn+HCOC4gNGENFhIJAJaTAlCJVLKxE0KBBC/EfQJOuaaeRTlDk\n", - "VhR6oZGUCClBJKSSowJUVCqYMhj7HNt7n3P23us25xjju6bxfnNtV2GIlMgyq2Nr2WvtteYa8/ve\n", - "y/P8Hs23sdYgtZGybmpraXhpJKk0Y+54BDStZoI4Uq4cDgtXN1ec398zDIFh0FZOrEYzhOB49PiC\n", - "ahvXr266r1pfr9YXFjnmTp8bKHXFGkixUF3FB1TErdPDO9mSbWqw8N4xhMD5/fucPzjDe4+tlrAd\n", - "uPEWDgYfPc4Z9puJQQxnxtFiobXMsi5c31xze3vD4XDF7e0VS7phSQsihnlZ2O/u6Wyx6u9caiEJ\n", - "OpvOlVrVEz5fZzARP80M06hRGl5Uyubc6+24Bawhi/q+aiukmulNtrb2rqPoRNkQphs/dGTiVePb\n", - "dC4u5cQiNd1VhUqIOlQG0wgDnLEhBMfN8UiNSlEqRa2cNYFUreItDpXtV4wNeLdhu92xmzZshq0C\n", - "xZ3Hmi17L1hTqCgDoLSEM6qmGKcR5x1uUFB1k9pdXFFxeSV2Tei3LBu/zcd379BEy/4iXXFXdb7k\n", - "WtJivvVApqpOnrvjr/Uf2UdIunhpqVIdd7MRbZlVx1V74pLeiKYvPPTw8Bo2o5s40zfiRgjOstls\n", - "GYeRcRxx1iuBKOuhaZ3BMWBQPt9xbiTNgcCJVShAFjBOHQ6dwBO65GHYO1YRQo440YNxXSNxrup0\n", - "qk33EDkT46qZLs6S1qhwXhJiEo1MzpUcE615qlFDgDRdojhjkGI1tbAKOVrEWZzViAINY1PPvCaO\n", - "BBoRJqE0YbAB4zakCO9sn7CPF0w1cYNWsH5w6sqqpwvLYGzg8vaSabNhubnCecMwnVFqphwzbz15\n", - "g+XmwOHrX+Znf/zn+Bf/4n/ha+19nNsCq3YBFqDqa+gjdUkwVmqquGpQ3bNu6FNqSHVE0diMdV14\n", - "eXXFk/IGD8IG4516tmuiWgFfkFDZbhzN7YhJcWLGwJp01umyypJqq6TVUYpeUp0fBO1kvdRZMqeq\n", - "DDBVl0Zhb5jOBzZ+UKfbMCo9R1aIG87DxGZNPGSkvYqsQVGGLIklZYiZ4/UVx/mS1BJLnBFjiC2D\n", - "E0Z/hqnKnKxZPfRNoHpHWbJ+ThzXlzPNw+ZsD64gJlGKZbMdddTjlTamDjHbLzpNIzDdDeYkqGrh\n", - "5MrpTh/bCrY1SrIKuqgOkYwRjWDxQWf76uvuyz0xVGlY8QTPHf9gdiuHw1GXrwlaRN1+uZFlxuUB\n", - "2ViaNUzjxHbYMQ0bvB3V3STKkQ120FmtrWRWirFIUadbk4IPAw6Hb5aSC/lUqORMy0pAq+Xv6UwT\n", - "6SFZdz+fOgyaaCWoriClT3N3WylcNiZBYqF1ISum4Tps2HWFlo6aNGa2S167hks3cIVKNeofdlZh\n", - "DtI028d5Sxgs+/OJadqrjtFoBoqde3RGUslQKklv6Vw4wZGbvE4/zK2oyrp5gtsx+R1TCNigyyuR\n", - "QsxJt/ZLJSZ9E7QsrMtKyqsuSky7A8giEbGJWpR2k4tTDmHWxcXrWbGnpEyNQop6SbUCcS1amlt9\n", - "bZwoHCVWVSzkagnWUMUxsiWII7cNm+0F66uEkw5wreC869pGo1HJphKCZ5y2WoVSqcvCZr+l5Myz\n", - "D56x22z42p//Gf/g0Rv8V//0v+R/+Of/PTkEmmtQhdKxXsYUjFSVeVV18ogDk/tle9JoGkGauoOs\n", - "sVzPt3zt2ftsxu9hkj7/kaa8gyD4yTIyQBQQ3RLT41IUM1gpuRGXSkr6+doyyaQ7HW6tpcdJvO6W\n", - "StKDywendHqr9POCpaaFbbDkJvy4e4N7a+DcT9w3AYwQpTIvK7Oc8X+t7/PR7XNujrfUZkirLvhy\n", - "rXqpmRulU2WV7RRRDmVsC5nS/45e9Ze1cvvBDS/GAevvs8aEn1RY7oMCoXWsk/DekrOhFqPmg6Tp\n", - "nCLd107/9UXu9K+mGorM6oTqCg3bVLLlB8846Pxd7xYtairaPRlrcALDIBgzUGMmL4WYViiJlrTD\n", - "yAWS0UA6v6E7fYI6sbLR9FfjcE4BIPr3qV1t+FqLLKKwYrFJ30cN/bvGQkyJuKQOxLF/59H13Ztp\n", - "dlfBqY3WNqeTb/rMpIOsdTrfK02kUpKhdIFwSXRBr27VSq5Iy9Seoy5NEyJbvROVUKRiWve1287x\n", - "FEczSiy3HvxgmTYT27MN3o2KGUsKBcmxMK6BKY5s4uaO1g3ST2W1Iqa06OwxeLwdsAw4ExjchA0W\n", - "ZxulLpS8klMhRo3CyOtCSYa0rJSTfdScqC0ZMYma9WbPWR/BlAo0qy16zrTciEbjjktUgIG3VgXK\n", - "0jiFyRlRupK1SnhxNuDMhLUBa7eYbHnw6IKyWDx7xHxEWTOjm4g10woKOult2zyvuOC5ubzGjBta\n", - "jkzW8uryFTUlHj96wBJX9tvMB1/6E37ox36G+//b/8jNEClOFxDS89RrLd0e2bBapLD2zWjlhOzQ\n", - "w7vQ8M7gnM6xrg4vef+F58mDM7y3Pa4WsJZpPyC+4qJQxTBYi3T/sRFHyY2SE/MSiVEp/mldOKQG\n", - "vtBM6iqP8vq5pFE6UKRVJZqvy8xgLRbLRZnYfCTcT9/DVC2JzM37H7B6SxHYuYFxN7ELZ3zv/glf\n", - "+uAveGAGbuZKapZYI82IitPXWxpgm7rLytooR0OqhbVkltyQRVtrki56Pnr/JdP5xHDuqXXVgz5l\n", - "CILYQqPrjBXiRm2nw1SzwRGj0SFND8ZhHMA7ciwsOWGDskpjKhzXhMSFdJOZRs9uF9gOk2o+OyRY\n", - "22n9G3svCI7gJ4ZQSUtiTUKLalWt2WqFLVCvIZgZbzcIXuVqhm5kad1YYMBqvIzUih8HctKteLFV\n", - "x/xiaU3HW3FJzMeF5Rh11FW+g4ugd999l7OzM83Z8J4vfvGLvHz5kl/6pV/iq1/9Ku+++y6/8zu/\n", - "w7179/7G175OlNSbrJHVR9zpJpos2a1xfQcuIrgGjUpJFuO7dMQ14qr/L+8btVq1OJ4KPqldSdJd\n", - "H01Uw9lEgQp9aH0X7Gb00LRGfaw+iEJ4s0Ir3OIxIeCCxzlPGAaMtZ3TWDFOISRYj2uVYQgEO1Gy\n", - "Ja6OtDpdAlkV6qYFak6QTNcjJtZZ9W1VNN9kjSpPkl4VlmKp1ai8qTVsseSi1ViJ6n/OUgk+3AnC\n", - "a+1hal23ak19DZ9wJwG/J4wDQ9jiTGBqgfUIb5w/oBwPpNaIWTAlUoyiuaydsHgMlhAiYhWovJ0m\n", - "lqWCEwYvxPnAMs/s7p+zpIS/PTB88+v83D/6z/jn/+6PWK0jsZJboqRIMVEF/6iQvORCzoaUWgf9\n", - "0mVDMA5CmCy4SrADYhu3x2umyTKNI6hXgmBaz6HRUUtqeoFaa7E24K2CQYQ9rQrLvHJ7ODLHhU0Z\n", - "WeLCXG4xJkFLOkaSrhuVSklJM97XSEuV+fLAxa3jwYeCuy0cb2+4LZDXqCvLWQ/cZ/kV/iPL2+++\n", - "y/c9/h5+4KO3uXl+xY0zxCVpR6axkrQmpLqSciJHS02ZWAbmrAtJyR3S3XkCCUtd4OrFFQ/HM5oz\n", - "HOOqxPKm443aL9ySiy4N+6IIUR2rsV2mIxZnjZLWq4XNwJALcU0cjwu2CdNk77KominMecUNgc12\n", - "o6yDlElrImW1DFNs/zcrwUAwCpyJUS2STVYqwjpXYm6YfKlR2wnqturys2TCoNI8qRYxuduZNdrE\n", - "ekcq2n6nfpaczqHjcSHOibgWUhJS/A7qNEWEP/iDP+Di4uLuc5///Of5zGc+w6//+q/zW7/1W3z+\n", - "85/n85///N/6PU4kZv3oOSdCnxudQLP1TsogTdl+NMHkRk4qNA4SqCYrDKJKX8a0u2zj/gPTR9HK\n", - "6qz6uRNlqVUQr5xJgFpXWvVggjobMD21TrOAELo9TN90rudoG6cVjLGRXArjtGU7brStzUJZofju\n", - "UCpCOhrijOaxx0ZaK+sSaTT9Xn2EscwrPnh9fcTTTg95s0rYKfSZkA7Sa4/EoGenJDTATBoqwDf9\n", - "EO6vs8pLBCtaDQ9up5KvJhjjGMQyGk8LmbYqbanagmGhOYcxuvAyVqt2kcJmuyEVsK0xjXpYHG9u\n", - "GaaRq5tr7t0842d/8rP82Xt/ydfSh+SSya3orLaIuoBSoyyVtBby0sgLULyObkzDDuC8vaPpYDQW\n", - "pKyJ25sbUkyEweKCUHGEfpkMwZNbRw6ekgC8I5gJjF6qwzjihsBUVtbllmUNuBlSOWCcJebYyVkC\n", - "RRcjKUdiysiHkfuz5+0bwVwduKwLU9OkRusnrOjfJcaVIJ64rnz5L/4d319/mB98+in+zasvs66X\n", - "FGuRJp0/UJWfWbqBoSVNAfWNMBmW65XctG03RSU3tRsv1nUlpoStXp+JpAckXWwOkHOjVas6FG2a\n", - "OiZQ7Z4h6ILUOafs0aIFScqFfdxwezgwHw/Eoh2QGMFbr9W5JKbdRE5WUw1it0hK6amf0iNQFCNX\n", - "cyPmiNCjb1rGtsIyF25upG/3E7mMrEvGByEEh5/UVolJ+NGSOvaN1rrRRTPVQYXsy7IS55V1jeSU\n", - "KMt3eHt+8u6ePn73d3+XP/zDPwTgV37lV/iZn/mZb3tont6s3/phbNOZAkKp33LYwWvBqVJU+x8d\n", - "shSsbRQXkbU7Tq15LTru3unW5yxqdQPQf79CR3wBVlP4bBfcGltAMrlGyEYPpZyhFRoJPXVLt1bS\n", - "ZUfqMDLG6h97njFiGMcJEU/JaArlbKmmcZyPzIfMfCzkJTHPmbQUzdWxRl+HouJbZyykohCPTnCp\n", - "ySjdJau+sOZKjZpPXkpDSHeD7VrBe/Martv/DrXWOyzfaRZk7cQwTDRv8VVIMbPcrNTrhZVMKIYY\n", - "Mz4YzWfCd7NMxroADY5x5d75A24ub/FFBdvkhB0t8zLz8Pycj97/Ovff/FF+4lM/ydf+j/+JabAc\n", - "Y6T2A3NdM3Ut5LlqJbCo2L1mBT8Yo8utagHJONFlTy7Kxb28vmYcItPkGEZL9pZWR3VWiWpwDUo4\n", - "z7lSKrjB4MWQe8bMtJ3YuZFlCdwebjAG5iiUfGCps87aa2XrNXfGN4t/duRxGfjeFlhc5mAaZ5wx\n", - "S2UYJw7zwmR9lxBN1LyqQkwKV69eYt/c8Or2JZoHRReC96F8Fc1Ql0IVD07hNrEmTFAgS4eIdcfd\n", - "CZD6p0IAACAASURBVDoNa0yEbGhJ1FhCz0/vmVf6uqMSoqoXrHilrofRM00j3oZupqg40SXMzjpq\n", - "buzTxHHZcnV7w7zOtFqY/IgfAlI1Q8iEgSEMuGMk20ReGrFFSk19G68W0CirFilNM6tM0B2GNZZl\n", - "nSmXmeNyrQzXcSCMls12wE+DBhsOhtCEIXhFyrU+jhO6wSF3t9JCXldiWslrgfU72J6LCD/3cz+H\n", - "tZZf+7Vf41d/9Vd5/vw5T548AeDJkyc8f/78237ta1be6Zv1P7DIXctzIhrd2d1EKE3FxQa135mm\n", - "by6J+i6pJx1dVt95NjrrFBFqUjSYc55SFbTbEJWcSMZIo4lDpCAtU2RPrhXmmep6NOs6M6cDS5qZ\n", - "8y2prORYAX2w9LDUnJIGhOBZ40KxaMpfc8S1YGRFjHBcGtc3M2kuxHVlXVeVt1RdfkjVw9qIoRjd\n", - "IOv87UQ9cuS10LJmFOWssaynJM2c1v6Aa5a1uKAxp8WQ14R3iSpCjJkmVk0CywHrrxiGDZs2EazD\n", - "JmCtuGnicHmlrg0nHNZbgjOUYjRDSCZSg1YL66sDh5eXOGtYBEzVWNpcDdthIObG/uycD//ij/mR\n", - "T/ww/3L7v/OX6ZZUEsc4M8+FNmfirJKpnKXbS4umI3Zhdblr84RSBEkD2MZcBSOZeT1C81hGbDVU\n", - "pwsHR0XEkkwiZzU9uGYoxmgkgwjWgbc6F7fOM40T1hnCYpkXT8yRVBe25owQduzsxIOD8CO7e3xc\n", - "7rHUxHqzMPiBYhrBGHKMnE8bWhWsUe5jEcveTxxuEzfpmrfDW+yGLeG4IGsiUfBioTikQnWQS8M2\n", - "9Xnr4ee7vrLhTO0wDkHGwjCNWGewZFpxd/nnxjqtkpshlwIUvPEdmA1iqrpovFM1iDW4UQEvKmwX\n", - "RJTKXhoEE/DREvaWnHfknDEoE5QMGGEQHb/JJFTRzitTcK4RPKSTWcVrp+hcn7sbcM5SpFCaKIz7\n", - "NgOXuGDY7LesbceGQMaTimVNwuId3ulyznm1YueUe9RyJMeiFW9s5Hmlxu+g5OiP/uiPePr0KR9+\n", - "+CGf+cxn+OQnP/nv/e+vqTF/80PUmdXlHHInST+146f5+ikgS4QOF+3kI6NfUUrFVukar0YxWpkZ\n", - "V1WqYw0l65JCNYB6sLSTLMk6rBXls58I8U1L+JRXTLLUatX/nArH+cC8HJnna+bllmWZoViMBJp5\n", - "veVXH6ySgmoqLMvMZtiQUiQ3bcucc/0Pp8No1ahJH1r3oLc+kC+iW2X1vBdUK2UoTQ+UtqpUKcUe\n", - "W1o1N8VZXdJ4EUarC58UEw5oXn2/YswdNCWiVcmRW47+gN84gqn4PGKrkHIilcyaMmEwTNsdN8st\n", - "U0uEOoDxiHVs9+dszy6IaWY77ri6ecE0Om5vrrm5veb6VeKNh4+Qltm9NTGlmf/6P/9l/tv/+b+j\n", - "lMIyQ1qgLEarqtylUaJtaSlZ27NiNPrCKoW+iHYh1itGLFfUd2kaDs8YLC0LJVaKqVhbiKmwxEQs\n", - "mqMtxdB8xY2eWqF0o4A0dVtJM+w2e4ILrGVFZsuZ3+M2W+5lwz+e3uZiuCAXmDtb0tlBnUbe9+RP\n", - "hdUogDnjXGBZCyE4lpLwBDYMKtGxFltQJxuCcQaKYDyctJPQKDWrFdkaNYJUARzOC2Fy+NFgBw3P\n", - "Q4yqRlrvztAMoFpPIy3N+LHO9feqUEoCRnJdGYYRNzjcCZhCwxudt4vZ4LxTYlaHd6SYVKhewVbB\n", - "Wc8QBuDAvC60RZdR08ZTbVWr4xhZDlFjqF3f9tNwOEXxlUbOTQ0RTmfRy3LEONXLRlJfZilL1omn\n", - "lKasziqdnJXJJVFqZZkzyzFRv5OV5tOnTwF49OgRn/vc5/jiF7/IkydPePbsGW+88Qbf/OY3efz4\n", - "8bf92stnrwDtNqbdyLAbUT3layvWa2xXu2sjT8sjWu6pg1p1lOI07a81Vgq+GcV1me7LLk1th8Zg\n", - "bNX5lxX0+hMQreAQIeXMklaIQpOgiYhZWJaVNR5Z1iNrPJLyrJj+asA0Wgl3F0XL6qbQxVbhcLhh\n", - "M20VZpwaxs6a19wiKa+sKdFK1SqqNUrJuuHsc9fT5VOMEulVGpMxTbFcJXU1QtVWrhbNvs654Jpm\n", - "zojoaxKs5qUIQkmZbBO1VWUmjlsMBmlHrl6+oK0Jxj3b4QzTImtcwBnScSGnwjhZvudjH+ODZ89Y\n", - "0g3jMBHCfVJSSc5mdw/xgfvT2NmNG26vn2N8YH9+xhoLKcPh+Ue8/R/9Q3783U9z/ef/Nx/MN7QI\n", - "u805t7c3Cg2WqJiraoAeGytqlz3NEyv639MSSbkgJVJz5tg0B3232TC6iRIrkQhtJRY4zImr2wNi\n", - "Mvv9ljBqhowbBoLPTKOCoNUVr4F+Dstu2rO3E/th4o068Zk3f5S93TOvM740hmYhBGpT6DT03CVR\n", - "SIRzWq3pZWg41JlgGhu74dH5Y/7s+AxrvEZIVLUnnuqgE6mpIYjR7J1sKhk1SEgGsa0nllb85PU5\n", - "NaghoZk+H9ffp5TC66m/3DmfWqtahRYhpqiyryK4ZmlOR1Kuazg1rNUQ/EjWLRclFfzgKKlCM0hS\n", - "DTVFCFNgiIFcArRMzTAFlUs1Wxi3E0LpqLnOSejjqrhWrC+YqtCY1jKlrqpZbplgQ1d13Dlf7l6z\n", - "lBIpJXKO1Fp5/tdXfPhXt+RcqPE7BCE+Ho+UUtjv9xwOB37v936P3/zN3+Szn/0sX/jCF/iN3/gN\n", - "vvCFL/ALv/AL3/br7795djeiAdSqJiqmPX3uDlD6H1SrmvJraDZjUIlSqRWyg1qpNlNXOsFEeh4R\n", - "1B745O4eDEOvb/UQrSpizjWyRGg2U9vAYi22GWKMrHHVLOaaMJ1mVNbaIxIKxkxajUiPR2hCSUJm\n", - "5uXVM7abneY7o/zA0jJrXllTpKZEzYVcix5+rUFfzuil0cgov1Oquo5qLf1BquSiF4ARnWFq6p4+\n", - "zCCkjuRqtYDXaly67CPGhKRCyer3jqtWx9fHW4bdO2zfHmn2QBZDrTD4wDzfssyZr/71e3zqhz/F\n", - "+1/7K26uL1lyxQ8b5sMVu/MLzh89ZTMGrq5eYa3j/OyCZZ55/uwDLh494ZvPvsHTx+fYv/5Lfuan\n", - "/xn/65/8MW4WHm7P+XC+YTAWPwwUJ0jSeW1PG1G5eYNWtQuJKSFkUk56yJSTzS9xc3Xk3v2MjBaa\n", - "oSZlBaRUSEvh6sUNl7cvOD/fst9tcYMwbUe2uy15u6FVheJmKqVlBhF2ZsO0sTyInp9959O80SZu\n", - "jwuSM1WUFlSoDNMWQQPdTprBahumVYZh1AurwWAKh+XA9dVLdkFVBiOGZB3WCElS15UqDCXVokAN\n", - "U2miF6W601RGl2vEhgk7DVRfcWFg8K8XgLYrm2vTrbyzHim6CBWULGSD0c25reSyIPOIUEFmNpuK\n", - "9VtCCORatGNzhULGi6cUNTzU0sPYGt262JSiZRvDOOjrmjLZqMSsxcKwV0K7GBX+16Yjt5Z7jIjV\n", - "51WqoVWnQBJbVS0jBeuaOrJ6mCC9u5XqNTynRV0sp8b5oy2bzUg8JuIx8t6Xbv7Ws+//86H5/Plz\n", - "Pve5zwE6P/vlX/5lfv7nf54f+7Ef4xd/8Rf57d/+7TvJ0bf76J0sp0xzK2jVKGic6re056elDWiL\n", - "3i9HGtLnMbpRTC1jvGCLdPCCCsuNMTin8y7ndYBtG5r/glXnUGl3ede1ZlIWTH9TeR/0Ae3i59YK\n", - "4xheB2nVqJktNHJZFQTRFJNVWwKJ0IQ1rgoiMbn74BVmvCwzKS7qta1Va5keACdNBf1VDA3bIQiN\n", - "FCPG+O4QUjtYw6hFDpVlqQhAgRi5rEjzlKaREnpfFBrSWZX6b+cIccmMPlGHLWVqTFPlgZ94hVCL\n", - "UFUXDMZSa8YCf/rH/yef+MQPcHtcsEH9vc4Gbg5HLm/+kuAd5/strWbiqmg2v9lxefmCN54+4OZq\n", - "5vw88cbFY/7Jp36SP/q3/4rnty8YmiV34PTAlmpusUVVB6XnydSSVVtZdBsc/EQrleAEcRXjCsJE\n", - "KZlliZRRC6zcMrWVO/J7nBeOlzfUw8K6P+p22hu2+w2PHj1inEZtNaVhqWyGkdYMj2vgc29/miFO\n", - "xDhD0xnldrNVa3ATmjgN9rJdPmd0gSc16xtZrRq6SGzCMkemYSRYhY2IFHKacVbI0lmp1K6RBZOF\n", - "MAlpThSbSM4gTnFw45nHDgVnNeu79vddKZVq9eIsuWBFwcEVjc5Ver6WGEY8wWh4fa3CIR+otxnY\n", - "E/xW8YFu0N/XFJodqV0dkOaF2hrFaMpqq9rV1FzJMeqi1SbCKBjriCWpzM/aHgtv+7Kykis4qwFy\n", - "0rGPLVusCYTRYfxJQ5vIWT3nxkgPxItaYFRNXC3VkqqqTuJaybGyLJXj4TtUaX784x/nT//0T//G\n", - "5y8uLvj93//9/9evrwKmtf7mPekoe0tgu9ZSTg4EFd2eYi8a+qZvBrJpOow+fd+iiYJyCoWyRoPi\n", - "S8UanYU5Z7A2K1PPgh+LDve71ar17Jic9UAquY8F+qLKOxWA6sxRMMWyrqdZYqbQNG60mbufVcdG\n", - "lRhvaWRSU72kob/Z+7ZTsOoRb4Kp+gJI36DrBqBSS69eOxbtpEmqFhpaVZ9uHenieDGNTjygWgtS\n", - "lEcqXd6TpcNdoZL1FouWkhqPvu8cYiHmqhlMElX0WDu/Uyrb7RnvvfdN3nz6vdzcHkA8GcfZ2YgV\n", - "dS6VmDnMt4xjUCjDmrCSuL6+5XyzYbm5ZvjgBf/sn36Wr733ZV4cXnF/u+XlcoOzjkomiNcZdW4k\n", - "03RpRqVEyCUzjVu2W0+jMUzCvFzjAhgCqRRyOXYdaB+dtEYuCr8wRghiKSlz8+pW+QS2sRxXnHiG\n", - "cSJ4RySzwxCmDT/y+GN8cvMIEK7jS9YCgx2ZvCcX5RAE56gYrCjg2DptH1VDbLpywVFMpR0q0zhA\n", - "Wpn8xG7aKyuyRCyQ5Uij6mLKWIokaqcRxVxUy+ks1hayy2x2I35rNZfKqYXRWM2JKj00pKRCSeCM\n", - "1wVRq524btS/HzzGKQ6u5EJMl51PGzi8EgZZ1LwxeJwV8EHnzhQFbVdhqQkJVhdVNMRo3IwxBvEC\n", - "nVFjQsVno+i5oFg5yYaUdVnVbKSkQkon2ZDRY91qt+qNJ4y6yHNWL/VTlWW1MqM0HcHlXCgRSizU\n", - "Ykml9aPoO7gI+v/3oRs/c1IS1ZM7p5OOiLTmOOW3tKa1daMg1moOcwNnXs8qTouYWjqUoOmGnW57\n", - "yyYpUzM7hsHgq1Zj22nLZqsD7dyqQkAQ0mkrbjTN0fSwKO+d5ooYofRUTREhx6w57l0Z0HLpv6lq\n", - "R0Gp1o1CKrlfGJrjLFYfCqnKkVSajkBVgo+SdwoUpz7xUlVKJOqNNlYlIkYErJrBDfS8JHUBFQGR\n", - "3CUojWp6oJhUjCkK9E1eLwmbVTJSKr7B8fYVMS6opDFhndYgpVQwAy5MeD/y0asPuLh4yJoru90e\n", - "Zz23h2vGacNus+XcPOL58/eYxomSHMsxEpdCsoU1FW4un3Hx7k/wE9//aa7TNe9dHzkbd2Az2Rj8\n", - "qkaD6xTJx1UjiaNqM59sdmRnGMbG7myPcUc2dVBMbavYo2ps1zJTo6h0pxr1xddKSbMeqE1wOIVE\n", - "r7AsMz5/hJ82XDy8z2255GJ7n59++sO8u9sjJXJzfcAUFYV7rwsRjMEHjbSQvtALztJqwp26qqYZ\n", - "NmK0NZ62E/EwM4yeV9dHrVBdY/RCTAZpIyUDbdWLtVlKK7SWaM1Sii6XmhfCzjE+DPidYfQBEUOU\n", - "hvcN6W1+6TEtIpZBHN7qIsZ77cDCqBKe0tRJYIxgzaDPnLFQ4HCMhE3C+gDW6vadRnCW1CIpG1zp\n", - "C9ng1NPuDFasVpmtUWyCoHsAK4YqOq/ORjBNPeKlQcqOtCzUZIjRYTE44zRTHr00jASs1Y37CYGn\n", - "Iy61S5vWcKicz9TW464bOTZiSbi/r3EXgMqMmm5rT4eCHpKtE8jl7gA6tes6gzuFM51sXv2bcXJm\n", - "tDtB+LfmYnd0DV3NgwSHDRbvLWMYGEZN3FvmRVvp00hA1NPsumzhxBmsIvhaGfOAqZG1+5I1ykSF\n", - "yLVqKJrOJAvFJppUnDV3bgv1wTYQBS93mlaXgABFb1LT3VG1FTQlSPNShEaNGTcG1UxKw9rcD0ND\n", - "M5ZmAdvUTdQS1hU9/MTqDRwc9USir6LkFxrpMjJWi7OenCEdM8Y63f6LVn9Kuj5SSmO7vY+zW/bn\n", - "O168eEkpN5SauL255HmtvPnWx/De8eLFR1zcP2fabnl5+QpjYFomjF2Yn32dn/ipf8KrZ+9x5Ov6\n", - "ppLGmhd29wIpZ/7qo4/YbM+5OR65TTMbO9Bc4p2PvcmHh29wfm9kGs85Jku1lZeHSwbXoMys9ZqW\n", - "AikaDesSDWrLVZNQXX/YjHFsQuD6eMN8dWCsaoQYbeazn/5xfujiHuUYmY8R7zwiFes8pYC1jorq\n", - "fo045XKaDtyutTsp9DlX6rkueIpVNuvZxQXXVwvbJ/eQJUPziDkieSWWAlUXh03oWe1dIWIbzQrN\n", - "VcbBsD8bGTZgR8GNFuuUXytGSfO5RJzVwD1bDcFZpmGDsxbvRkQsRTLOWFJO+ny4/m9W3SmUWJmv\n", - "FoxYttsNxWVyqXixGGcYx1HPsz6qKEUXvg19H5V0SkJVXZKxKqwvVcXnpWRqEciVFjMlVlJUMlct\n", - "hdU1BgwhDIjVuBTnLNbyLZlDndVZirrJ1vqaqNRGhEhrSTtK//c0jfKu3UUPPsOp9VZHkMFQ4c5m\n", - "CXoAKjS7VwlWv77vS3SYfWqbTw37yaqJnMpRxBhcCGqNtJ3ebNWiNgSLdxv8alkWFcDqH9dijMU5\n", - "na8omEARc8VXSrDYnLQl6W6cRiPX7p/tP6PQML2i1viOhrf2bqEj5uTY0SF8rqj1sTWdX9am7pWm\n", - "RJ2W1UV1d9mIuqfEZHXJGB1PmNAQV7HeYoyuVq3ROAzNZtLqtIpmN520qw92FwxGPcfjtGG+vcY2\n", - "1UZiHbmCxzBtdngfwFQ+evGczXJg3OxIGRqBy1czKR758z/71/zgpz/F17/2NeI6s9tO2GCY14VX\n", - "h1um7Yb84gVnP/Kj3H/ykI/HW00ARZi2EzZnnl29Ip4rmSlu93zp+is8fHyfD28+ZHSZj12csXGJ\n", - "Jw8ekWXDh7cfUBrMqK885VVdU6shNa+xx1WbMmt9r6bVz38+jki6ZTNtOBPLMC/88md+gU/de4tU\n", - "F5a09upFHUk0i3WBhjCOEzElggHvut1VUFlO1bmzdO2d9JjosvYRSDDsz8552jK35kCuHieC9Y5Y\n", - "i+bitKjwi84AFQFjlWsqo1FavSuIE0wAbMV5T+tFw5ISwTlcNUwuMEhg8pMCZazHSCCforbRrPOC\n", - "5s63imqdaXjxpJgoa6KEggwajCi53bENNtsNyzFS69oXOI1CVzyU0hdbqOSuamc2LwstV1I0qoVe\n", - "LXEplCSkNTLaAWMD+KZkI9cjgkULqVP6jEijFLW81pz10ExVgxQPK8ejkFflzIqTjsH72z++e8Fq\n", - "Rf/QRvSFp+mbvdaipp8mCBpqryiqPgyuOgepqD5LpTUK4ajVorSk1IGo3FWXTbRFo2Vq0YfYW0dw\n", - "oy5UGioaF314x2HC4Dgcjl3Ocqo6O97fCMFbWjEUEbJvNJ9otWeaoBSkKq0nJipX05RKaxZj0QPK\n", - "9Lx2eY22o6n2MBjBmkqRqnlBVUEVJUt34OjiQ0zGjhMEtap5GxDvsR5wGnFsXL98pGCMvoFd4y4a\n", - "WMRhqlVxdwNTg+YvDY79/XNcUcDCZjtxuJppAkuKBD8xbnZYv8UET8bw8OkTps0WFwIvL1+Sc+Lt\n", - "d76P977yZfzG8+df+jI/+MlP8sf/6l9yPFgGb3jj0WPECkuJyKsPOcfwo+98Am5vucyVEBwfv3jA\n", - "9e0NJjeePnjMzdUlizMMt41798953yjQ5HsffZzn5X324Yy2OXLEkfMOKyvz0VCiY8kZlwoHkxlS\n", - "ouWMlcTmbOA4Z1gjUhX6EHwgWOHt84f84x/9NJ969CbpcMPcFPSw3Z6RlswQBsRbqjNsNrt+IXqC\n", - "9V33m2hetBIsmnleamUYPFYg10Krkc10RmuRcXMPkcI9v6UdLjnWiomOOFTWmPsyI2Kr5urUqOaO\n", - "Jo0weYwfyMYQrMf0fUFqakuMVbn1ZBhdIIhl6x0Wjag2VCQkrFU5W0yR2FK3fUY1VxT1cduxQmgQ\n", - "J8qxIb4XBkarXoBhGJCq7qElFZJkxDiMFFwTYp8n5qQzepXr6cHsciYvwrqoAaTMIAzEVthsiuaZ\n", - "O/CmEJyG7ZmT9K91OI0ESrcdi6gKYlmL8guMKnHsRjBBL76/6+O72p63pi+Oge4F77rMXmm21tQX\n", - "jLa2xugGmb5p1LjYPutsmljZjOgyhdfaxtPGWXqkaIqVZUls9hO9dtWqrzXIKjo2aKyptUIzlsF4\n", - "rDha1tK3lNMNqRKHU6UiGMToVrJWXQ7pz62pjjqf1W21c6cSWjOhRQRvnLYwUqmx53mbviGl9Vwh\n", - "fanMqbrwDlyfMwaHuAwOqgc7GKp0XaoRcA0k60yYimShJQel4+SqajuNq4zTlsfnb9FWSJJw3tFq\n", - "VH1pFkIYGMcBP05M2y1YYT9MGBFefPCclBPWGY6HI6yRRw8e8M1n79PSzAfPP+CNt76Hjz74BmFz\n", - "RqyF+TBzvt/pDHK+4uzhQz5+cc6rm8jufM9977l3fl83tH7gvQx2O/KwOYyfeHRxH2Hm3v6CXWp8\n", - "//13uLp5id8Zvr6+ZM8NcyxMmzd4P36ks79lIZXM4JyS1SXwYbxh8R4jjr0LvHlxj3cenPPf/NRn\n", - "eGN/Rl5mlqTaVu88Ka4YY0k0gvWEMJKStnqDN5QSsc4zGk/OCUtTdUfuz3SpHMsKtTH4wCEWpu05\n", - "ro5sZEOTGbd6jNsoXGRdsMZhyoptVrPcsy4BaxOs8TpOGnrEC5mExfcwOVsLMWdsFbybdDzTo2AM\n", - "SaVsfa5ejWo9Tc1IyTQSSCFnPTiVSdmIrXC7Zvb7lUlGhtFjijDZAamewVl2O/WsewKt3WLrwhIL\n", - "xo+43EipUPJy10bXIoBV1q0pYJJKioJHMJ3/adhsu9bVVR07OF1mqmtOSKXLkKqmfeaEOu6KMhpK\n", - "1ahsFzSIzU/+7zy3vrszTbT6Oom3W+2HJ3AKR6L1tvzkBjIoubx/TalVB7683qCfZo5aHDZOoVld\n", - "vEQzwuF2ZbNb2EwOcKr7bCpjki7dkWRUYA69OtPvI13Aa8RQS9QNdgcCtKri9CZFK0TRn5mTELk7\n", - "nBS83K8EY3pbpUxRi+oIMbW3QF2bK3rR9F8S+kzIOoEeZdxsw01NF0seTeBEEF9ptkLPTbGilKSa\n", - "KtYE8iqUpdJywTrHxcWOwex56/HHsOK6Hzjg3MqKWk+XVfPZU64Y59me7VnXSC2Z/fmZujC85WuH\n", - "A1evXjKNI8M4kuLC8xcf8AM/+EOknBmsYdpOLGlmGEY2wSKrMJw95ixMyNYwhUBdZ0QM98eA9SOb\n", - "p29STOOtccNu2vPs8hXjNDKd7Xh2GHiQd7x9vuffvJrxZ3tWU4ntkm3YULeJOc483Yy8vLnlwdl9\n", - "fG605tgbz/vXVwxhw/fdf8Q7F+d89h/9F9wbhOVwydoy2RmV46SIcx7Es92fY73vz6L056HHZ8So\n", - "TW7OYBuVQs3qFqqtasY8jRIj1lhsCLhhYhMyqTQ2cUtKGXJDCBjxCJZWsorUq2qFQZeCdCq7cRrz\n", - "UqjqdksNU1tnKEARRzKRwU+9iKl6mLSEC0G7upopLRLLQm2FXA7qkIuJXCprblwePM46tod7PKhP\n", - "2J9tcIMWCwMjQbwK2YcBycJmrBzXSjQrrx9whYYbjErvWud2Rt3mi7dqTPAddejAhQaSlKVp0d+0\n", - "Fc1lygYzBE21LA2apZTKumbWORNnhX+XWjFWW3rrDcP47+vC/8OP7/KhCfpCofIL033gXfZvxHUv\n", - "d+kHpipUbW/PS3cIlVJOFKveakp34vTWnL6R6/IbmqFkuL667TPMSpOJ3CrbUZBmsdbgjGVwpzeB\n", - "CnPTekrb67DTpkQjZzUpsjoLuVGKUEp3bzQdB2holaiQGdvtXfrztKrbbGvVnaGhXU2jjI36rG0p\n", - "5HKaX2lb7iw0WxHXNATTA7Zhg1KLijQ9OJ1okFpVhF5tCWkeY0aoCr1Qt2DkyeN7PH34CNsGbMvg\n", - "Ki2PtKKAjpwEpJKPK9Iqty8+5MP3/xpjG/cvnnDx+BFzPGKaxq2+9e7bfOO9b3B1q159Y4R4jOTa\n", - "uP/oCfHmIx7eP4N2TsorZRgpV88oObLZbNWzVQo4S1kLj7b3cIOHs53SccxASjMPthuqcWw3W94Z\n", - "d9gQaFiG9imeHS555Z5x9uAdvvTBMz795E3m45GXV1d879P7BPFsd3tu5oX74wZK4/H5nk8+fMQ/\n", - "/PinGGWhRFiKWu2sVbCwYMi5Me0m1pjxTdhMIyVnpFYG1w0XosJv64yGltWTdjDjxNw5uBKVkmEc\n", - "dxAdO+e42Qy4ecB7XbJY77DJY6rD2ULOq0qAqmDpcRT6pGHtQG1d53yKRM6ZmhuI4UDC1AysbFwm\n", - "WIO0QVv5fEvNmTVHYlUeQGwZSlSN5YK6r1pmjSDGsqQETnD2EVszUZdMc43iCjFFsOrnd04Rc2Du\n", - "0IU5V1pXn9RYWWNUdUZRPKDVNEGNRRFwTl9DOVXK6Pe15nU8cKuo3TJpNE7qsSKNfFeolFqwwTMM\n", - "hjAWXPh7f2i+/jixNBv0pMZvgXoIdzOKk53Sul7CSX+h6fk8aJusYWv6/U4xF70gBAO31wnhQMqV\n", - "NVWmrUJ9N6MneIcT3ZjX2rpVswe7Vb3JTy16y6XPZQVDwFshdXKQNPX4nkLaRITqdcZVa1R3UZ9j\n", - "6u+r80UxggkOX1RHKQgEIdV29zUiaNC9z9iA8kOd/qcYAaswZDpyq1FxVue+NTVyEgIDtVpapBI6\n", - "WQAAIABJREFUUo3b07ce8+TRA3bTlk044/F0TrBgSurrgIL1VhmMLH2hNeCCYfCedTny7OvvEUth\n", - "u91z794FN1c3WGs5zkdKSazHa7bbDX/xb/81/8lP/KdctZkWI48fPuLZB99kcA9YXl1i6kIRw/78\n", - "PrfXN6ypcphn9uf32IxTv0QNVgJxsbjB89GLj5iypw0BaY1pCGzangsDN8Zy7/yC4SgcWdk8fchX\n", - "83s8vbhPPMxcPHyDD66v2JqBUCrf87E3+cTj7+dj5+dcHT4iV6f2RBFiTAyDh2QI2x0N6UxOtex5\n", - "P1DWhDFe4ztST1lE9YGaDy5d9lPuFoFUNWPklgnbAak3mCxYp6JxCZZpGFiSJ1dPK0k1nhTFEXqL\n", - "L04vbhqpapvbYsGKkFrPdqrQnG7zfY2INMiWZBuILrcKSllPdSHWrC05/b2W0MVKz7KyzRDXylwX\n", - "Xplrght64oAn5MY6Ry0ehoAzFhesdi5W319xSazr2rsvPUz1jQ00jc/A9ILGa4/qnLbozlqM1bHV\n", - "a+ePQnNqz3vWKpoukleik3UwjA6sLsbcYLvG8+9pe15rveM3fqssqBSdU7aqq55vdVB+KxVJ+v/H\n", - "nryx5nU7XyuaBInQTL37uvYtjM5cMs46bm4iqVRSTZzX0JdNI1PIBOd0DlT7ULo7TkAlSLW34rU2\n", - "agGj8mNEVMPYnL+LALbGMAR9YGiNWAspWWJe74hEDelEeSVP22Y6PKFSzWuqE1VlQTnnXnWrD99Y\n", - "wViFejRBZ5nmjm+OGBVz1yq06vEmkIuS8FsuPLh/wcMHFzw4e8BmDNwbLxgZdDRSFSqB8zx84wmv\n", - "Xn5IqAmHo5aG854wOAbvGPbqsX/23vt8+MFHfOUrf81P/vRPsRwOLPOR7Wbk5uol/+Ddp3zlS3/O\n", - "D3ziXdLhiufPv8nmbMtye0s8Lvg2M222iBg2+x3Pv/pVWNVyejHe5xvPn/Hw/mNeXr7EuMCLb3wd\n", - "Hwxj8JhmGYeAmxz1mJmM5fzBY4b9OZ98p7KsR17cXvIf/8AnkOtb2rinmcb5kze4tzvyMGy47x5w\n", - "cXafZK5osVCs3rZSKtM0shxuGMN9lsMKrjAMELzrVaNjGEZqzliriZZQWNcF0IViijoOCdZp4JnR\n", - "SnActhgLqUaVLDmDCZbNdqJJwiXLbrPFuMrgDYebW81CRyur0kdbrSmAV4weuEtOlL5V9qK5rdYp\n", - "Lei46mImu0YVhYAUGhh9VnMpGnpopetE1TByYnWS+6MW4eb2Fucsu/2OcRhZjqtqM/si11bDctDs\n", - "cwDnBlo7kuJJDK/b7VbpqpXX73lpFWdVV+q8RqI4b9FDtmJtB4nzugixYvBO+gy5c28HQ0mJEDyS\n", - "gzrbjGrAXY/2+Ns+vquSI+DuEKu1du95l9oYoFlat7gVHSzqnKgJtelsspygAuY1asC6Rq5ZM4Yy\n", - "3Umk2+r+r2OMVf1kFY63ysa0UnHNYeqBOghl2ECnvKScSSmizW3oSZDdjYHgaHprmwZOyCjWzVqD\n", - "d0q+DtbgmlMJBnBjjM4VzYKS418j8DTdjy5FUfCIN7YTiXR2pd7i3IPiQKQgUjHSidsVpHiaK2Qa\n", - "vnmSUYBIM4ZWDCYL1IQ4x2bjubefODsfCGGiBRi85+XhBn9defzkTUJwvHp5yW67Zz2uHG6uiWui\n", - "UjCtcn7/PuZwTQMev/kWZ9s911ev+LM/+VM++ekf4qNnH7DdDVw8vuDMGNK4cogL5XCrm80mOF+g\n", - "CXPNjOOGKrCuhfl2xo8Da0y8ujlQU+ErX/lyH9OA84Hj8dD5pQHnhGff+CbzfOT83j22Z1tKK2wG\n", - "z9n+Id4HakvM2wopsd+fU+xAXiqExPm9LZvBkOIGsQutedqyYMUQ55lhs+sXKQQ3YL1TBkBc9Fkd\n", - "J4IPCBnEqTzHW3JaWY4LKRXEZIpz+Ko/r1jLfn+POFiOhyN1qDgafoCxGoQJKZnaIjkPYCtlEmo8\n", - "4moiidCS5j9oag9IQQnoJyeYGIx3CoNpWo3mDIioUcD2SA/XsDSyFHzQYMFWtJihQq4KIq5ZFSOl\n", - "CMYob/ZwecUz/wyqsNtWSiqE4LHHSMtqZknHhXk+/j/MvcmvrdlZ5vlb7dfs5nS3jcYOmwhjmyKr\n", - "SilRDBIJCZlRCeWgZMlMEAwZMgF5yAT/BcwYeISgBlWQVUqLQlnlkqoGlAqSxiaxwY5w+Ebc5tzT\n", - "7eZrVleDd+19I0hjJFIle0sRuvecc/c5++zvW+td7/s8v4cYhaNprcTYYKDEw2KIYACVlrQXihDh\n", - "c6Jkg9IOjppP0cjK6VCKJ62r4L+A0bWXrGaKRrK9cqwDM5ltGG1/vKfnwMcqzX/0mVfOGmqv8h99\n", - "XlEOY2SxGVKqVbLI8fwjD60QQnst8w+Lk6pH+3GIDDvwaiJnTYiaGPck7yqVOxFTFE2oqlknRY5U\n", - "qVqvlBHro9FinStZdj5rrERj4HDaCRMwZzrVyUBr1MQYqhxIgBgylEIGYkWO50ZrlLfkHGqbQZOj\n", - "7LCHkwxoYrSYbOUGMZkSLCUoCV9zcqOWHIGMtgbtpKeGLXQLT7ds8b7BuYY57ZiswmmPdYbOr8mx\n", - "sN1tMcajbcN0e43V4ox6+u4VpvOsViu2bcc07Gm859Of/gmm7Y433nmTvNthUmK7v+bkZMX1hx9w\n", - "fv+CJga2uz06BMGwzZHOO5yzvHjxkhAjp8uHjBHK7RalFL5t2dzeYpuWm82OxssNM4fIZrNjs91h\n", - "naVfLhj3e263ezrXUHLidLVgmie2Nzfcf3Bf/PdxZne3wWnNG68/Zp4n5mEHRhP2E2gIIeO7jt00\n", - "su7PMdqhlMag0bFgtMVqjw6ZkieiEl1tSokYA2GejxswKMI8YxorJ6ZQUG3DZdyym7c1xniWa1sJ\n", - "Dcl1FhcVTaphazmA0hhdN8hckBRr6amrXIS6laXvaKyBVNGJlcKotSYiLR9t60BGIwuvgpwSxoh7\n", - "CsS8IZDMA0ZRNvEUFSpl9nEghOeooon3LujHmaZtZd6T64YeM/M0EsJUr3+wVvqxWouc0FgjZDD1\n", - "aiCsC5V7K9e+pO4KmPsA0v742iLyv5gTqYj7KxdxbemawKlUjY0+SBN/yONHtmjqf9yzRGq4Ut+g\n", - "I3mCQ4FZezG8cuSInEfE4PGwIGapzgyaVGVDpQgdCOoRP5WjiPyQy1xSZthEWpeksiuRkAQG0ThL\n", - "DHPNZBf9qBzZ85GiUoo6vi6VJf85o+QGsharZQLsdYNx4sFl1tTEVA5BTyDiYTnO1ViNUqOMNYA0\n", - "qmUn1eQKtIgpYrNIgVQpJDLGGrKumlFAWS0kJguUQiLgUGRtBGSiJpKNWK/xSysAidDgVcPD0/t4\n", - "K+mK67IQx0sSIbK+9eSSmELAuoZFvyYXzYffe5/F6ZqT+2cMl3tWXcN6/SaTUcTL57SrnpvrK/Yv\n", - "X3D/8Wu8eHHLul+w2Y2c9AbXOF6+vGS9PmGz2Qhncx4pwHK54GZ3zcOzc8bNljnDFBPOCZBiux+5\n", - "d/+Ceb7m7PSMNBdu7255eXXLerFivVrSdC0fPr3CacP2bsucAsY1nJ+tefTGJ0SeluV9UEmTciHm\n", - "wmK5YgqR1fKUNBfZ7IxE4BqjccaJ/5pMjjMpCyE85UQMs4Cmwwwo2rY52nCLMjTOYxcL7uKeq5uX\n", - "wgUtmWkeIEbmKIR25zTBadrOE2Ni3O0rdLoQJ6kQS0lgBfAr38NIrG6U662WbsJIKEUifhUQ5bpT\n", - "1eNOEi11CK84rZJBZCtf1EoLqUZWlCLAmTgmri+vZNE+OyPOcy0KshRAsTCPI/txT9FZ7KwpCs0I\n", - "6iQ/k5Wquus6NM4ch0EyAINMwRxTGsqx1RdzrJWpQmx11Vef00eSVDPGWKhmA6V+UBH36vGjO57X\n", - "Kfehsayr+FBRE28r6qtUVwzIjpiPlkRZMGUQJNNI0ZfVxVGlSjupLYBiKDYfK1aDOmorD4L6YZtw\n", - "ZpDQpghqSjAVoq9asaDQyuBs4BjXiyzS6bC7aVCliC895goIsXjvcc5KE9xqnFEoX4SkREIhUoic\n", - "5NicsqC0EqlGlGaKjihV0KXukC7W/qYTF1EoqCiIrJRmitYYbckEjBdbpvYIlVtr5O4B53pwimz2\n", - "xDzifSGXPaFY2nmBCYqzR2s2+y0pBzbbDfMocqhp2DHPE8462sUp1ipM0zPFkbOLcxbLjvNlT0jS\n", - "/nj3L/+Kd/71v+LqTmPCgEmRxcUZN7fXvPapT3L93nuEOJCKoNTGlMnbLVOKdIuWq5srTk9PSCQu\n", - "Ts6YNgP7KLa50/MzPDBOYwXxJprGM44j05S4urpmmvZ86lOfZp4GXly+YBpGtBN6eVYaUuLi4h4F\n", - "cb3EGNDKMKeA0oaucQzDjHONcAy04N+sbzHGVtmcoTEaTINxHh12cq2VhHMN+/2eGCN93xNCkHgV\n", - "Je6tUqDrFjx78X2ef/ABru+xSq7nmGchUmVJUSQrrHJ4l1ktLDfzHXk7Q1LkFEhKYZRU3toqSTyo\n", - "7jsV5BBDko3VWlX1xCJbK1lAMamIrTQX5BieM2VWFewKqjipdHMtbogYJTlI0lYJ3G13GGtoYosE\n", - "oxzmAZk5jMQ0H2OS8yENU2URmpNxxcKhaq5/yjmLpTkXQowSeVIymYCr8ORSCimK9KpkGf6QX7nv\n", - "cs51eGfr+iLfI//Ak++rx4/OEaTKUYIDB+2lLHBCUBdZDXAssQ+7wLEPWiQQLZcsLoBUyKYQFEg2\n", - "ckHqPYR9WX8Xh1+MbDIZrYAogtj9JqOTw3owLjK56tiw1b+qEyobcpHgsJTLEXKc0qGdcPh56xtd\n", - "bwaZ+CuU1TjnUEWmfzEXYpIqIcVAzpk4S7RHURHbFWleV2C7OC0K2inKLIMnEjArspLdVSI9IJUg\n", - "WLxQdZsFsArlEsYVos4YPeC1RRfPdrxjl7csWZLuAovS8PjkIXe7O66vrgmDwD/urjcEZSHPlJgY\n", - "54S1E9ukefjmms99/qd57zvfYb67YX3SsupaQhgJceYf/vIv+G9+4d/wja/9B9rVgqurS6ZhYtUt\n", - "uRkSn3jtNS4vn2Gd4/ziAc+ePmGeRjmBmIauW7PZDjx6dJ80jnQLz24/sV6c0FvDkw+f8Nrj17i9\n", - "2XJxep9nl89ZrxdcX1/z+puPuL29xRvLZrPj5u6Os7Mz5jDTdT3TMLK5vaZLgYQn7AdCgnEcsbZh\n", - "ChPWivrBaiuMQ1176El6b5TCFDOuRFrvsW5N42e2mzumecD7BmuFzwoCRlZaFqjlssV5zwfPnvP0\n", - "2XMuFhe4zoAWlF0kiFFCCYQ51GhapRR9t8SsHbt5T4gVBKMVKsrXG62kx6qUXPPUggGJulC6oJU+\n", - "Xmdy71WIlqKqTwpWNWCM0NNVwRpbr3sNCKwDJaAsZz0kxeZmT5hmGdQkjfe6PneqqQvpeKzWRr65\n", - "qeAZV4X2By01B6VzyoQoziiVEsWIYF2pQkkypA05o1MWTW1R9VRXYR4cZisHxY3cqzH/mC6ah8FN\n", - "Lq/iLOo7I4vdgbhxkKRXMbfi1cBHURfUA5XZiCDWR4EelMwhcFIWFV0X6rrgVqm7INiQ4cM0RAiF\n", - "ttMoW3CNJgWNdWCsxCFIz7TKepRYOEvtm8ixvL4ULdVsmGe8d4KoU7LQowtWaVAGby2N9xLsNUvM\n", - "aB7lmK5cpiB+3qKLQFMLR+WBfA+FSjWHRcvxPCdEC1o00ywyIVsQITQKrWTCi7MoNF5bvFdkNTFM\n", - "I5RCG1f0vuN8dcrt7UvCPLPd7RiHQJpnYg1cM1ozTyMxwGq1wBL48L2/5/VPvsl62fLdb/8lq8US\n", - "p2WzGO5u+fP/5d/z1ud/ir/+iz/nwcUFm+sb/vav/4q3P/ffcnX9FGMbjDHcbTaM48D1zTWnJ6cY\n", - "LTIVUMSY2I4TyljaznF7e8Pq3n3axtM0nozi5m7HOAXWyhJL4fziPjFl7u62dZIt/dnVeslu2HN+\n", - "fo9xtyGOA0oX9rsNBYX3PbFkjLaUSI2BkBbSPM1oqzDVLjmXgjfilx/nGcg4q+mXC9JmxgZLiKn2\n", - "8CyHzDRvBTeXyPzlX/45T29eMnYzTetwrUQ+Jz3jfI01JjCHVI/+FT1HxjhHCCMxZZhmisp4pbGA\n", - "LRlnPUolChpTYEaOxipp8ZhrOZarUiQnqCpIYpLXb3QrfdaiK9owixWZOkDJNeKjEZyeM1aAJFFm\n", - "AikEUpTFNsSZnEWPmVJ5JSMkkUqRHKIiyo+SpS2WDjdYdfqlGsNcRDZDKhFbZGk7LJwciiSqSaYc\n", - "rNnyvZRSQrSncDDq/VOPH11PsxyqSFV1VQg44qCjrLuJPF5Rjg7H+bruHJ0/iXR0CxVyhVBUmYKR\n", - "Y4fiEJdRq1qy+ItTRFUQRo6ZMEeICtNoUnSklHA54bOt/VQBuiot3nKJGJXWgNa22tEOPyykaSJo\n", - "QzSOxtZe4XEQZWmsY7YB7yzBmlqBF+Y5keeCDomSJSMFPVPQ1RoKRjt57cXUhn/15FcBe0GsZDJJ\n", - "FN8zUegzmoLL0ghPJoMyqByJ88CoC4vwAKcdsUwsuyVX5oq+7xm319xeXaJoCHMgH/gBKbEbtpxz\n", - "xmq95sXT9+HBPd5656d4/zvfIE0z69UpJc682NyS/tM3eOO1Bzx/dokFXBtRZUsumq5tmcY9BhjH\n", - "PSFNDPtI5yaGaWCxXHJ7s8F7z+WzF9x7cI+SLeM00jRSCQ37mfWiZ5w94zhzfv8++ylinUTC3m02\n", - "dG3HFAZKWYoBooDxHTEENpfPKRZ8t2A/7ijKyDG6gkpiEqG3MQ6jLeO0A6TnOauMVgJoJmZ22z3e\n", - "GZq2QSvN7V1G61F87U3HOI+c2BV923KXJt77/hOur2/Z+z22c/he4zpDthHjFV3nBbxBIodMjBai\n", - "QxdNmEdCrKzMHCkqQSOOGacSrRYzSCajkifmPakkYhIt84GiZbIWm62WdpPFoaNmziMgRKyiD/1F\n", - "K4VDKaLcQGOVxRSDLiL3keZjPX7HGo42SZ/2oIDIOWONxFeQZHIe6z2eD0NhpK96bI/V1hx1tqCQ\n", - "VFuQhfEwbyh1iKWMrprqKh1E5hhay7Nr82Mqbn+Vt13qBFt2NGp/88AaLCV/bGj06t9RyeiH6boS\n", - "EraWX5pWhwGRSJmk5M+QVfWt17yRGiQlRHZAHdItFdSduyCykhI1cQbrFNkdFmQ4tA448Pp01YpV\n", - "NBwqEWKQiiBGqHEDugajaW3w1jGpiFHi5dAoSkiEVFBBmJqlKSinyCqi1KvAN61q37dWwClHYhZ9\n", - "KPXn0VZhrbgojBNXhjLC8RSQsCYVS8iFOW7QU8PKn/L47AF3l9c8fPSQftkTrOVluSTMU82sBg55\n", - "3EphlGYYJvopsl4uuHz2lMvnT7hYn7FJNzy/fEbfOCiZZ88+AC2SGLdoSHNks5/plmvStK9V3YzC\n", - "4F3LfphZX5wzzxE9zJQ0k2oPeT8MeO8Z9oO4QQrM88RtDOKAiol7D14HJTn0z5/eYGzLNO3BKIZh\n", - "kP6vuqFpGqZpIhlRLNxe34C1LBYrtDVstnu0abGuYZ7F1ROmrbA9jWGkYIxo/fpepEj9qidOEyXB\n", - "drdn2O9o/ALvWrEMpMTJ6QJyYZgC733wnMu7O5xzaFNwnaNdGfyyoJpCXHd0q4Vs/AppHxVHs7Aw\n", - "OOJ4K3ALZ1A6Y3SpqY6gTERp0WpqbZhjBcUoI06zeurKWRYQlaQXKC4mhdctkVxpXZBcgiynrZIL\n", - "RclADJDqsDpzBOv4SjM9jfNRUVCQxAKclTgMkHUAKY5ShXfklOramytsvLb0ULIgV53mEdgjq42s\n", - "7kjvOINQ7KuOWhuH0kl6vJQf3+k5HBbOTDmYs0uuOLgiQNzDVLEucB97lI/8d6hCCzLhlimTTNGV\n", - "vJFaIZPAw/EcqpRH/mFOUvpLT0QGSHHO6KQga0nSCwnrCjmJE8JYLUiwKi0qJVUx7qufOWVJT5Rp\n", - "txytS90YY4likVTIgEhpSbA8euULKUZ01sxFKhvTypEJVWnrSZr26EKJSrrvSO/U1ERO6zTag2uy\n", - "IL+0COad0WijqbJOUimMsRCDbFLrk4aTbsEwBi6ffUhjpO/WdS3tYsk2jcyzBFN578kx0batVK45\n", - "sb3boYnshw2Xc+DexRnjtJFoBQPTOPD8xQvefvsdNlc33HvwmDgnQghcv7zk/sWFHGORPG5jFM45\n", - "xmHA2Uam0WRiCWij6NqWZ9fXtMuO3VYyrMI0cXJyIr5+BfMc2L94xmZ3yxwGVB45Wd6TCtNZ2q5j\n", - "v9virGV5cspwe4NJCbwnzAHintPTU4zt2IcEqUNhmOfAMEycrHpy0ORxR0ozYSeSNYmaMIwFxmHC\n", - "WE/by6K3ubnm3sU9Wt+hXM8Hm0uevHyJ0p6cDMVltC5km5nVhFWKcVSYxmB9i9IF7xxOt8wh0DeG\n", - "soKUb9jHGWxmGCYWyxatQz1Wa7xzYo1FIi5CkT6hdhUEY1/dIyVFnLboYmRTNw1FaXKNyYgli/xJ\n", - "ga7tE+n1p2qNTuLQqb7yRCFHavKq8B68cyhlRKtr5FoupRC1lJQSAaOEu1nVMkpJhlFKkoSQs2yi\n", - "JZd6T8rgU4YBsk5Y06Br2KG1hm7RSLZ6DbhL8cd00TxIjUReedAhKlIMtWcpi5+2mhhe6a5yrTbl\n", - "NFjf0HpM+Lje87BTyoJgYiYZKcVTPdsf1tuDpKGkKE1sIMcoURlZk5CeobURX6TCi6Fgva6yBQDZ\n", - "0XMppChSDk2d6EeRBYUQiTkR6psuTWhJSTRabiyDwhqDbwzOO8Is0R85QYqRFICoanWXKmBV1fgQ\n", - "RYnVfmYy2hZ8b7FOgrGMtoKhsxFjLNZqvFckE8W3rjNzLAxDQbk9s53ZtXckHekax3Y7oYssXNp7\n", - "ulNFuYvsbkRKc3HvgnEaySj2wx5SpHWiGUx64Oo68c47n+XvvvUNcewYx9I2/MPf/h2ffPttbi6v\n", - "+fRbb7PZTgxJrKnzJPaTaZrxvrC5u6YUGf1q12L0BAbmaeT2+lrg0SqzPGnJCfplj7YWbRQhDeSY\n", - "mcZb5uGOOAdWi5VsirqwPD0lJFiuV+y2d2yv97RG0a869llhrKdbrEjKMMwSvqeLx1jP8uSUk3NF\n", - "gyaVAHRMwzU5J5p2KWLwlNjc3qBsz6pf45y0kvb7iZO3OqY4sXrwCd77f/4jw/aW1dlpBaVYtBLI\n", - "hhDQJUp5P+5wRdNYjVcJXSTuVlXsoTWWtN9TIuwS9IuZ3uoqERIQh/Wg54TOSbSdup5ejCIHkU9J\n", - "jnrBGY/NrYQJHgLZGoUmE7JGzXO9oxM5Qc4SVZyj4OhCzLWQkNNbmEdpsymBe2tjUDljrZF+qpKI\n", - "4bnk2tssmKKw1hNyoqQk9xv6mPpgjAPycUElI7ZkdTi1KuI+cHnzkhRnHjy4II6RppW8oZQzRf2Y\n", - "LpoC0BAUk0iMKiZOEtOIWnoVqtotRUx+LCrrwlkXSfWRj9XHocTO1cubqGNAo2rPpWo/cxEyelKU\n", - "JLk7KktUa0lCK1JFILMly2StuFjfWKAovNPC0NTuOM3XSgshvsZ4UGRqqBIQMmg5yislvUgjdEUW\n", - "bcErh9OWOCbmKTCOkvFcUiTPDiUbOdbV12IsJgvFSFVdZrEK22iMB+eFzI0S/ak24FtF02qMkwgG\n", - "rBFpE5EYAmPWXM43fPrkEc5Ydvs91iomHdBG07Qe9rKgdYuWGAz7aUPftpR5R396j/0+sNvtBE82\n", - "J1TK/PVf/0fOTh+gmHGNQE4eP3rI9uYWqy0fPn+fxp5xcfE6c5oxjUaFhtXpqWTEh5HdfoNvV7ic\n", - "aZwjR9htd4zjKJRwZRh2O7a7HW3/QBiQIUIqdG3Dk/c/IAwDXb8mYzBNizWKaRbyz26Y2O129P1C\n", - "2jza4eLMer1kDjLU6bqe9dKRkmEaA8MwootiSCNpDuQSyGmQDW2ScLxpmtBo+sYR0kTYzgy7Hc57\n", - "ijVMIbFaeP7d//m/0Txa4XAYnUUupAs1KU+ST1NiniKxbAkObKuxeJQS3bBzHmcsGkkXVSiGu8Rs\n", - "PKpLoFVFDc44BxFFUoliSpXhyLfKKtNkjVWiKfZGQMRK16VDK2KJWKPI2crgNUFSkitOkUwrVTJT\n", - "nIlzln6kkg3DWo1zB8qZQLJzViLfos4dkCO10QarHEolnLFkHUUnbF3NCwLRWpqjrpM6EKYoGVbl\n", - "QibSNg3Ft+Tksd6hjSPlSfqp6scUQnyAGR0wb8fZuFIiaoU6yeEYaPbRQjJTDoP2o8Tn45VmpZm/\n", - "miVVRL98v3zog6QiiZXVISA0+Y+gvQq1qitErUizxnhD8cKaNxWHLFNosa4dgMkaRHtq4JWGA0pO\n", - "hAmprq0Qk1QRr3u2EauMXOTdhB1mzJjJMZNjrSoz2MYKNUf6C7KxqFe9YmMV1im5+E2W66AUjC40\n", - "raZpHd6DaYSAn4niFMmaOCXaRuI8rm7uWPcdhsLd3Z0MPazCOkt0jq7vGPeFxapH6YTThWkaCeO2\n", - "ciMLYZ7oGqH99E3L9dVTHtx7ROt6YphYLlbcXN+xWK9QOjCOI48/+SmuLj+gKEXTdljfcHl5xbpd\n", - "cnNzx93VjtWZ5fz8gs11IsxbtNUVkjvim8T6ZIUpmWG3I+QgOdg5s725pW0ti2WPdQuZhDvHHCJa\n", - "KdI0sugX7DcbfLdkyju6rmO/H2i7lXi3e8cU5PifS8Y7xbAfiWHG1XymIpGobMcN8zyhtWPRnZBL\n", - "ZtqNxGlHKon12Ymg0Lzj+vkLnjz/AN87mqmAleA6Y+RERFKQqZrDRCwTRlv2Yc+yPZNqwxictXjd\n", - "YFVDiCMFxbDN7Lwck1Gi9TTagilYI7fGISNLGSeSKsAZI8d57VE1V0cAGEoKmzpdBxk2ksEZTZgF\n", - "NkO1MYY5kWJ9fq2wXqI+DiqUgtDyrRHNqlzLhzM3KKOw1uDqghiTwgihXE6etRcL0oM9UPG1yseZ\n", - "iDUGv2jp+xatM86J6qEUSbmUwuzHdBCUq5ZLIUMfXahhSgAKmwAlFBZtxHaoaqbFEcArueflAAAg\n", - "AElEQVRRF9hXw6GPZgq9EraX45RdKtlS4RgHyVNRUSjodU2VEAohtFMOQA55MyV/R1GiXJ9aFYGf\n", - "ZmHGKyVVs/hhM0YJRM4aJX3IFDDJCFiuTsCtNRQVBfZqFWhNa3raKdK3kbwfGUOFk6gkGdTe4LxU\n", - "mqk6LFQtD7SSnVokaHVaWbmOxmqUVShvoSngAkZ7VIkURiFcR/D0LHpDmjOjGlFpZr/fkRIoxO9r\n", - "nQUlWTSqBFoHbdfgGyhlJudEiDu6bk3Md5gMVi3o+o5p3kHxvPnmW3zn3e/yzk+8zTzPLJfnjGbH\n", - "5uYFaIfRPa6L4Bpuxog/WbIcBnxVP+xToT/p+eD9K/pepDD73Z5TdyF2R6u5fnmDNgPm9DF3t3ek\n", - "NNH3F8Rkmcuei3v3uL7b0/SWYb9DKU0aB5TRbHd3+EWPbXq2d7L4KevYjQN9f4ZrBMwcY8J7yzwO\n", - "THkmhBFFpgQRfm93O87O7jGFgF94EnK8bBYti9USrS3t+Rnf2wxk73AlYZtCUmIIVlqoXpF4XKSU\n", - "EsfbHDNFz9yN1/i8RBdHzDOt1TTGMqDx2ZJT5Go3o01Dp6qETYFuwCiLs4qcEt5ZVC7YUslhGkHM\n", - "YYkFbDkc7USlkkoiHtUwBaNcdf8GcgzEQB04zVUmJNerwcnwqZpQBD5RjgNUfcisKoK5s1buMa2l\n", - "3YIyGH0YAqnqbKL+HBmKrnVXkfsBI7MLE3De45ykJuQoPx9VlZPSD1809Q/9LPBrv/ZrPHz4kJ/+\n", - "6Z8+fuzq6oovfOELfOYzn+EXf/EXubm5OX7ud37nd3jnnXf47Gc/y5/8yZ/8c08vj4N/vPYqi6rR\n", - "t9TFjvqi+PgR/KN//ygp6aBhlGrzFU6uZE2O0kxOSSJAZYJupP+Saxxo+Qim7vC8xUjed9LkkEgh\n", - "Sc7MfOAAFoTCpmsDWwT6KJnYaW3QqsKOs0zopykyz7Euyg5Kg1Je2Jna0zStOIk84uTxBdvKzSNg\n", - "l1xTMevrTa/y3MmJynmqP4shR/m+ISbIM8YWrAXnoes6rOnRJTGUHWPZsxuu2Q0bbjc3vHh5RQgJ\n", - "YxTDeIN3CZ1Hzk96lkvHciU8zv2wJZfMIVdJFmqDcyu6xQOa7oymXbFYnqKU5/33P+TRw4dcvnxG\n", - "TIre9YADpRiGHXPYE5MMhz796bfwfsVifYJftAy7O9beM+4Gcins9wPGWsZpBuPxTcsHz5/z4vIJ\n", - "BMUcM67rQHmysvSrNY8fv85mKFjXs9/sscoR58A4T0xxxvqOkh2XT58yzwPzvEOrTN8t0NozDxM5\n", - "RG6vrnn54TO217fs73aM+5lpNzEOE8OUQFnGMNP0XiDEKtPeO8UvehrXUIylu3+P7zz9Pvcf3Wfd\n", - "tjSLBu8U2kjYnrVycpAUSlkochBy0JQi23nLxJ4x78FM+D6zXlv6torFi6HMMIbMHCAmzRggBoNS\n", - "Fm0tbevr0EyKGWNkMYkxEmMgFSGfx5hkkJOkV5tCPA4Fj8jEOqwxWgoJp41cq2QUkZCmap1Mr9w7\n", - "RR/RhyLaB6UjSsufnddoF9A24HzCuYixSf7zGm21qEMMaJNBiUXy0IpTyqBoUEi7TazI0stMWQox\n", - "6Yv+049/dtH81V/9Vb72ta997GNf+cpX+MIXvsC3vvUtfuEXfoGvfOUrAHzzm9/kD/7gD/jmN7/J\n", - "1772NX7913/9uPj8oEdGFsvDELwug/X/5Vg1fvSzr0Ab//ni+bHkSerRvWo+ZceSyXL+yFG+1GqT\n", - "+nX1tCvJj/XjqiANaG1FxhRKtUhKtGhIgv0vIZDCBFW+lEpNxdR1YUNJZGrIzFMgBElyFMw/5FRQ\n", - "VRohlHjJWG9aS9cbbAUMU48bh81B1WlYSZKBkqJQwXPI0pBPuX6fyDwLFCLGgNHgar6KseBcg7aG\n", - "pHZ8cPuEd3dP2OYdc4qgDa5pxHnSt3hvuDg/5/R0yfn5mrOzM05Pz1gsOmE/FoHGNm0DBbx3oBNN\n", - "p2n8guX6gnv3HrNYOJ49fcbJ6j7OeG62W+7fu8+434hudZplCOQcWmlc03N2eo/t5pYQB65vXorE\n", - "qesoCJOxX52itGEeZ26fvc9ivcCt7nNyfkK/WHHv4QPWZ2cobdjtJm5vrrm++pC+cey3G6awx/se\n", - "oxfsx5Fh2mL1hM6Z8/UDUjDibppuyDGyud0QQ8A0kmaaKKI/HOp7W2QUvVguRZCeAv1qwfLslO5s\n", - "LbT51Yrruy17HfG94/75fVbLBd3C07RGqqLDFVrNC5XlAsUQ8syU90Q1oWzCdOA6WPaaVW/wDkzt\n", - "V8YkR9uUNTlpUqi5U5UmZBCpFfWkllI+XqspREJM1cGW5c8xEw+pkTlTciQf/PZRTl1Gyb0VQ5UX\n", - "GTnK55q4KvzLOoStGtgYY03AkT69RlULMlhbcB7a3tItDL4zdI2l71raxtO2LevVkpOTnqYRZkLT\n", - "avqlZ7ly+KbgnEKbVDcIaWtIeOJ/IRru537u53j33Xc/9rE//uM/5utf/zoAv/Irv8LP//zP85Wv\n", - "fIU/+qM/4ktf+hLOOd566y3efvtt/uzP/oyf/dmf/c+fWMsvIacCSvRb0piWX9Cx6kS/6k1KTX+E\n", - "EGuZ4XyM2P7RBVVrBVq9qhrriqhyjf/MWaQQdVoPULI97mo5She5QJ2Ki0DXeEQXGgvojJssuWhm\n", - "n9FZQ8hYK3176QZpjCiRoShhWNbc8hAKJY246pXNsdSpe0algtUG3zREBXkSUg6i6yUa6cnkXCS0\n", - "qr5IATJnUjKUSRImFRBjFHCulvzoccpY36CPfv5MLIqcHMkpxjIxTBONkyHAbhhYdh1N29F2PeTC\n", - "NG9xbo1SwqhU5oT9docqEll7fnZOTIFpP7Jen7DoFuy2W9K8JStD35+wWl5wcnpKVg7TNmw2L2na\n", - "Fp01u6TwVjbOvmnYDhNusURbh1WW/uSE7WYAApu7Wxrb85nP/Fdsdrc8+f57tM7z4P4bvPbmJ0gl\n", - "MV9d89rjN5nChDKFEGG5bBh3E0+ffoD3La5bMgZxPWmVmLaJ7DpMo3l+9ZIY4cy1kgw5z6xPLzi/\n", - "53jy/SfcO7/H9X4jmswMeC908aLY70Zw8NrZI4oWX/bJeoluFXGx5H//xv/L3zz/FtsyEp2mMy14\n", - "h5kDcc6EFFFJevnaqio9VJALTssQc4pB+JxaPN6qUyxnTUqa3ZSE0IUmK1sHOmIazznRKJlex3q/\n", - "JICUKEEd4cCKQpyh1Pwe0Ex5IqUgpwojPXtdRDqUYpYTT01dEO5blT1pTVGFOc0it4PqkmtEH23E\n", - "NmqMZH5pq3CtxpoGYyX3xxhJzhy2SbiwyBRca8EyppSITiJxnBNiVkqprguHQgqUkeDAnDMhHBCS\n", - "P/jxL+ppPnv2jIcPHwLw8OFDnj17BsAHH3zwsQXyjTfe4MmTJz/wOT7adzQcgsc49muq3bUSjvLR\n", - "yK+UrrDWcjTWl8IR60TtKepqrj18ja7QYPkeH83q4VhRgoAxZNFUGBdFFxbqil0XlxhklzJWUUik\n", - "qAm1v2q0k95TKFU8bI92LZVEB2elAylH5TAT50LjG3kNCKwjhFirZI1SBqPNqw2h1I5sqNP8pMnx\n", - "kPBZ+6ReE1MBM1G0JlVBcAwBsMS2MPvMoDNNK/EfKYoeUmuYcyYUacDHEOmXC3y3EKeINpQs+sim\n", - "aYUrmmINw5JjVdd1NWM6c//+fa65JRfRqz6494gQAuv1itubS7TShCny6c+/w83dnl2YCbtbhmnk\n", - "9OSUUCJZa4qFRb9gGHdSoSjLfjexWq65ut1IvjuGueZzj+PAyeM3OT27EKmV8cxo2qYVlBkOrQOb\n", - "l89xzrBan5OyZthtKWlmmjeQYdlfoIxFKdER3n9Q/46i6xpyyTx79pSYAxeffMT2OyPblGm7lmIU\n", - "u+2OtutJKbFatGxv72hXDSenj1gverrO8J3NFf/p+nu8v3uG7Q0tDTFMmCRHxphE5K+0rRVZvfGL\n", - "5D3p6oTJMZLNjG4MVkv12CdNVIrxuqBtQRnprYegMNbJ0VwpYsxYZ7DaEGOULKGUpKWUoBQB24RZ\n", - "3leRwolERybhTlwWShxvJdWwQ6gnM0TmZOXkVTJgiuhslcVah/UCSMhZUHRCj1KSmNmAb8GZhPca\n", - "Y9va7oJu4cjRoorDWMQXXzLGKpqmoWkl70iUNLb2TC1GV3dcHaKK2P6HH8D/iwdBP+io/I8//4Me\n", - "IgmSALN/zL8TfdXB+FhQpmAKlBIp2XEEeKCO2DittZScJNFZKSXSAw5ypY9oPXP9/HHZlOpOIZWp\n", - "NfXC1BIs74wmjCKyLkXcRaKPLBRd0CTZfQtkm2qLtmCcrj9HlSGVOsjSSE+lJFIqpDCRU8HZBoGU\n", - "JOmrjZNkpHBwMR0UBOKEyCmjkiLO6SieFzjIQVaVRdJZkXMlJ5LJOGuYhkIxQfrHFe2liyUHhS6G\n", - "zi54uHqDvl/TUsgpoqzDGcc8jQi/sJDngFWaqfqSYw5cXFwwz/Nx+vnixS33zs9wzrHb7UBp2ral\n", - "FMVPvP15vvWtv2Wzu+LZ0w94/fWfYNjcwVHEHHDdGqU1TdNChBQdMcJPfuazDHEmMciChuP+o/u0\n", - "bUNMM6ZpOb+4z9nFPYpSOFPY2ySuMNNgrOXy+QuUdbz1zuf47nffYxxmjDLiZz95gMKwvd0xlw3O\n", - "dSyWKy6vXuCbBU2zYJpmSJa2dTx+8wHZJKxSWO/YDDuG/R6nC64xWCzzmNmPBdOeUryje3CPsr1l\n", - "jiNX821VWoDTTrB+hwQDa8QEgUcr2VBVOjA2xd7pc8ah8ErhdcG7wBwLTWewU8LagvYKZQpJQcgK\n", - "NUe0qbBvI1APpWRjDCnKSbC2mUrMpJCJUyRGYWgKgjFBHcY454RKH4Pcj1Wxcrz/tPS6C5BzwGmH\n", - "a71Uxl70yVqVOiQqaGuxTtFYg28yxgW8BAhgTal9SbknQjWuaCXT+5ypVklRfIAMcUVHm9FWdNZt\n", - "6zikMKhUcM3/D3EXDx8+5OnTpzx69IgPP/yQBw8eAPD666/z/vvvH7/u+9//Pq+//voPfI67Jzu5\n", - "kQv4padZ+WNVqJR4pMtBi6mUWKuSohjJDT+wLYUTqOsELtdS/vCoerAiE7dSEmSxWMaDyOkwCSTX\n", - "aaRGm7ojK4NqZGGLIZNDwWpH04rbxji5oLTWhH0kpULT1J/dlOqSSKSkK1XFCkjDaKxxWA1RCdx4\n", - "DjPZiIsppsA0z4R5QhXJadZV0xqSLIpZH/BdhjxLdaoVwg9VwjQsRqAK0uYQOUaJMG1hZ8sRlkKU\n", - "doJRGp09UUsomJrBny5oncbNMyUXxjjKz+IMOUZK1sxB+JA5JxZ9j9aG09NzciyElLj/+E3G3a1c\n", - "I2+8idKW1Xotv/+m5VPvfI4Pnnyf9959j+1mplt6qbZjYIozTnesml7iPTDs9jte++TbkuGtIiGk\n", - "6nDxbLY3tG0HSvPaozdZn5+TgaZtGO+u2Q43MLeYvuN285KLizOM6/nekw/RKtEvBd3m3IJhGJjD\n", - "gHWFdXeKxkPWdI2rA5FQY09mXGMw3nJ9ec3uZstut8PogrcZ7x0lK+ZRMspt79jfbXjzE4bu8Rvo\n", - "uwXv/9XfEM2MQYYyRVX5TDKkPImLTReMqqJvJQM+U8BhsEqBCoJGVGKWMCmiVBRrsU4UHcnKCjZP\n", - "F7GwKtBZFnqdIM+RZORkpuosoOTD0KmQgmQCkWXwKTi2cqziZHZQsFpegzGWFBKN90zzWJGQMuxx\n", - "rcG3nq5vsQYxY1hwthzbVd45lNXi7KvidK1r642KStRCGZujYOw+coYk5CiRv0pjjJWN4OgwFGtp\n", - "IvLdv3nGu3/94Q+dwRwe/6JF85d+6Zf46le/ym/+5m/y1a9+lX/7b//t8eO//Mu/zG/8xm/w5MkT\n", - "vv3tb/MzP/MzP/A5Vo9XVfIjFSdksV8ddySEr1elA3Jw1cRa7hcRdtUjuyx6xoBSEimQ84E8pKpt\n", - "sFbFQFQfHRgdUG4zrmkkOVfN8sYoA0p6J9Za5jmjdcQ6L5ZEK0d+ozI5S3pmSQWxIZQ6SZTpPFQ/\n", - "rlYi7jXifGjblrlMYu8bdhIfkITunUuufmbpR+aUyVNCZU2pvvNcokicauUcVUI5och7a4gFQpBc\n", - "l5w1WhfiPjGbgioOFQNlNhhvcDrR+syyPeXUtnzm4ac471bEcU9OmWke8VaxWq8YpxHvHFMlehsj\n", - "nFBrLM43pPgq42XYb3nw6BNobbi9veVs1RGjZg6RaR65f++Cvuu4vLzhO999n2gG3rh4yJwT2jSg\n", - "Ds9ZKKowTBPOedanp3zn77/FovEMw0DXLTg7O2fYT7z+xuvc3m7Q1lHIzPOM1g5t13jvmXNitTzD\n", - "G8vlZsv5w8dcf/A9bm7uWCwXjONIyTNKJRq/JIaZGGa58ULAupZs9pLd03eUEthubpiGPdfXLwDY\n", - "3N2hSsE1vQw2w0xSDq8aSky0fYvq1ijjoFhSgXGaiDGRYiAVIfhIQF9B61ytgoLnO3jWXRECu0Na\n", - "BU6rWv8dHG6vrkmrjBynDQKoyAe8oa3uPNBRKkGlDEY1zLGQ54N9OAtLU2oZ6acai/fNkfcgdU71\n", - "hVPo2p4UM646lUB6srp19AtH0xisAWUkQlergFJgncMYhVUahRGJYs6kOZLTLImWSlxHWsnwNs6B\n", - "YowMyZATZizglUdXRUkusR7PxVmlMbz+2TNe/+yZIPKA/+t//Ma/fNH80pe+xNe//nUuLy958803\n", - "+e3f/m1+67d+iy9+8Yv83u/9Hm+99RZ/+Id/CMDnP/95vvjFL/L5z38eay2/+7u/+08ez4+aqrrg\n", - "CZC4UrLR9XhZ5UPVN3rYXcm8gnqkmuOti6TU1STHksrxWB5zPvZCAUzJpFLnMiVJRdA29F2H8VF6\n", - "L0XIJ1YbYgAz136rivi24BuFtkUC7XN9jdnKwqZleFUq+T2XGetkd1RGKuoYM41r8N7RdR3DduDl\n", - "dMU0BvKcpbF+yIuKEFKQDPQ5k6JCKMmHY7ipAyC56o3NtI2jWyhiKYxzJk6GaS/oOa0tYaMoKRLH\n", - "TJgKrs94VyBqmjLJZFt15HlgHG5J0xZrPVq3oqdcLLi7vhVkWJQWgvdtrU6ksg4xSnWQC3fbLYvl\n", - "ik++9QmmcWAeBm5vXnL18il/8xd7Ht2/z+rsdX7ycz/J//F//weefO97/MSn3yYXR9c2BDTDFGhM\n", - "pm1blsueYRj51Cc+zbe+9Q26rkFpw6Jfc3v9HsZYuq6TSW5p0CkyDAFtehIR5zy+6VEYXn/rPsN2\n", - "R86FRWvZ3lwS4oz1lkW3JMRE36+Y9B6tYRp25JKwbc+6OSWVSNt2xDBDEpr/9vaGEiaWp/fI2rHd\n", - "3rFcNCRr0M5ycn7CYrkmF0mYNMpxd33Hbh4Yx5FhGgU0nKJkJ6ksiNxKJwopShtKS3WIl7gMp01t\n", - "NRVUyWJ4MNXiSyKpLHpiFKUkZG4p75EwvVW1Hh6SDV5N0UtSpMoAUFEwN8pomsZhjaGUuinHVPkL\n", - "Gu8NzmSckX+fi8J4g3GGoDLFCM/TaIO38u/RPVZXPkSWe/GwDSgtAYJWVYedE3ScqcPWOeXaz5Sh\n", - "cs4JlQrTQX+qFBCgCHoxxIBxogeVGBppt/2wxz+7aP7+7//+D/z4n/7pn/7Aj3/5y1/my1/+8j/3\n", - "tK8m4NUNJJVgkXlLERqRcDJTnWAXstIiydE1bkIBTkg9Tafw3pCTkaEHWY45RSo0rZVcZIXK0xSC\n", - "dcoK1zgan3FNxncKimc/BrKKQELbhG0NeiygDcoUrAdlCphMyV7CqGIkZ7l4UxFWoSKhTcaYXPuV\n", - "GaOl6mwbg/eeohS+MSSVuHz6kjkEAoKK0y6jYqmVhGY8QDqqXEtVRpNUmiLlaHvD6tSgfcZrw1It\n", - "2N4kGq2YhpEwZfJYyFp+8XGXKXNBLRznbcujfoFDs58msNJ3RmucteL7nQMvty/pu4btMBJDBZUo\n", - "6R0ZbZhjlSkpzzSMoLdYlfi7Zx9wfXXN9dUVz5+/YDdIFev1t1mfLvmpf/Vf89/963/Dv/v3/ytP\n", - "nl/x+MHbqG7BTEJPhbaXSt16h1WGzdUl/aKl5IjSjpgi5xcXtL6RIUYWC2lKgawbUt4wT3usbWkX\n", - "ltPzB6QUMe3E1jtuNldYW+i6nqZfoopBm1xRfAVdijhknFjvYpDB11hGwhS5fnGFsZrVyZI5QL84\n", - "5W7Y0PYNy/Ua27W0y5azi1M2u0su5k9Cu+bDZ8+5vb5miJFxHIhzYB4nWShVPYtpAzqRmBA8oEIX\n", - "y36YaJzCIu6hkhPikbAEXcSh5DWq9RyQlyrVe00rmXLPAUxDVkoWBV1zgIqjxICYLsU0obMs2IqC\n", - "jBI0WjtSFoShdUokczpjncbbhpIj1ovTx7aerDIlTqLFTEWye3BY29SvzxIFkyX+IicFSuzBRTli\n", - "mtHKUOZCiZF5NkyzZbubGMIEWgkNPgoj8pCDbg6U/hRBlZqoIL1Nd6DXp/BD164fKbCjFJATq6qN\n", - "YXH/qIM48iPi9EMCpVGCqJIcHzmqd31D24qPtWTBuY17GbikRKWdxOoBp5LeqagqhfbQLh2ujWhT\n", - "8N4ypkn6NrqQdMImi7UyDFJolI4YrchESpnluZMcC3IpGCQVUlPQJgoCDukjde0Kpx1N4+m6Duct\n", - "y9jSOokOuLqNbG4mlAuYVgLGhF6taZaWMCa5iSszS+kqyDUR7TX9PY9fB5yDtumJsyLuExaNMZ69\n", - "lmCvRjmWbY9y4lo67dc8XN3jnj9l3ZyQ1MQ4RlSINLaVI3ISLWSeZ7Z3W5rGUUqmaXrZrV1DKYqm\n", - "kdbFOAa0dQy7kWnO7KbEbtS8++Gev/+HW242G5JS+Kbh9QeRy9s/5zNvveCX/vv/gf/5j/8nFosJ\n", - "vRtYeMPJYsFmuCMn8MUxM4ht1cL+LvLo0QV977FuSbdeMyvNarmsCAnNy+vn5JK52+559PiEZtET\n", - "EAvmzfVLtrdXLFYdXq0oWjPWSXDTL9hvZeEjwzQWYgr4GJiTbP7TfgtoFqsWf7Hg2Ycfcu/8TbZb\n", - "QdidP3zEEGZWi56mb5hzJk2JtL/FLs9p+zXDuGUcAvshUKZACAGlCr4xKGelX6ml5RGTBOOFLEfd\n", - "ORWsKSiJepTrIWvJO9eqWl9FjWKdwIbLMSZIevmpJKEcYY60olgzkkKYyLmtw9ODdTKitUPZQirz\n", - "QbRHqRFfh7Ay14ipxBhF03is0+zDhEkVcJPF2lmqy+tQpYaQmWcxoqQgVLE4R9om0fUwjwOBgRIT\n", - "m6DZD4qbzcR2lKm9DKk1TjdgJbxwt79lLodKNGKUEkvtosd7h/WWQ2DcP/X4EaLhxOJU6gtQSoYg\n", - "Rx9UFWaWckj9Oeg2D+HvgCo0XmOdZrHw1TJoCbGQs0Skmiy8yBSrDZNSM3KAotCpoHShWQqCX9si\n", - "u/ZeMY0HEbkSYbCDFKQDqo1ESxircFaO7UXJMUOha09FYbwFLYi2WApeC2jDGk2/6GjblsY5jDGs\n", - "lyswCd0WpjxQVEA1IkBnjLgg0o12YSp9SZMr5i3lgDbQriz9RWa9drKDZssImObwW1XYAF2/oG8b\n", - "2qbHWEdUkd0w8e6T99mtbnltfcp+85I3Lh7RGw/aMM0zaZoYdgMlzOQc0GaBd43QhXJExZ0MF6xw\n", - "Cr1zTMEw0/L0ww03+4Fv/8O79CcnPP7cZ7kIgeeXz7nd3vHdZ5F333/C1d3ELibefucdJh1ZLk7J\n", - "aSag2Q8z99Yrht2OptFYrQXs3HXMY8CcONq2JQOnJ+eEPGHs/8fcu/xalt33fZ/13o9z7rOqu7r6\n", - "zSbFpkhaEvVwYDgJLAhOAliInVGcQQaZZJSBPbATJAYyyT8RBHk7GWaQIDCSSHAUKxLsmBIpUXw0\n", - "m81mV3W97+vcc/be65nBb1eLA4sZBc0DFLpRqH7ce89Ze631+34/n446RXy/5fLFQ6wLhG7A+kBM\n", - "C8SCwfDqvftkJUoNcsXTOOwP5BhxWqC6ymmJPOVMLjfg5DAcQicDSdMxT3tev3+PB59c0ppiczRS\n", - "NRyfHXN6fkyuQvLqug7jHMvNA3708fdY9o04F7FeVsixYL2mZWimop2Q4i2GyILSYJQBU1lqojMO\n", - "lSt1VaqY1jAWYlshwkbaSM0UrLXSaRe1IyCDRWHBriWQJJAVsT2CUQLDkNhbxTmDcxalxYrpjbjU\n", - "BXotvp+YIsGDs4JIpCVaVXTGkVWVmrRePzfr1UBeCkY5TLWYWiglU1IiJfkstlUJ01lJ2sScoDkU\n", - "VhbYtVmkjZH1oxayyRIRsxtUymIgiEmmGX1mmaUGq435jIvyF70+Z+95+wz1Jt/sP0fSr2A1WAO3\n", - "L3+3rTEGVYUFaWzFdwkb5GjYlILcWIpoIIwHlREqi1pJSUbqjTlXtBZPugtip2tmRgeD6RRlFiCG\n", - "ImH9+u9vhqZWYruTqaU1gWEDeYESMzQn1VBTwRaMl6M0LUl7Ind4FwjB0XeeEHqckxxZVpFsMvt6\n", - "zX56IZrcJhi6MkFXGjaA7WXHnRbQLpBKoSroNjCeKIaNXXFfmRw1rpNFrJqMpxG6wPHJOcZoAhrr\n", - "HXOb8V3h7Oics/GEwVgOseF0QetITYllEk4lREqOtEPDHVmuby6I6YZBC6GpkbHe4t0R2zvvEY7P\n", - "eXH7Kd/5o9/nS1/9Oq7r6LrAl97/Bh/88EN+7/f+T6q/pMUT/tn3f0CMld/8rbukktDWc/f8LhfX\n", - "j1HKkMtEHzakODN0HfvrG4KznN09Wz8omhgnNuOI2XakRUAkS70lFs27b71F6I642k2c3DkjNU0f\n", - "erQylPl2zQg3pts9mgNohesH5mlh3AZOjqXiSU1y3FuD2j5Yxr6nHvU8fnZN1QtDOKK0iA+GO+db\n", - "qJFgFJvgKB7wgYcffI9Hz58zTTccrpMsGlrR9T2bTc849CxlJppJdoDak+uNkOQlWAbVUFpAN71i\n", - "2xTegY+VXAyKitMQ1ysipatMrLXsxqgNlWSw+nJ+3JIwF1KR4zamAQml1kSH0aVrHpcAACAASURB\n", - "VDQysEK1Jf8n12vNkHNB6cjiKnZYJ/LKUldNtWT0oLRK1U1qlsViq5XcZpVKcq4Fo8UXXzLoVtF2\n", - "wVuPxYKpGJWwFJwq5GWPVgMUS6kJ1Qq4Jn6kYggaxjuvEHPh8nrHHPekXHFertLszyu5vRSZZsqd\n", - "nFrzjGv+8qf65K29zFiugVOlXraqcM4SuoIPDe0LXS8Edpc1cTbSDW8F443UCpu8QawxEjlSBpct\n", - "2qR198jKnWwMfaAsipYk+F5awwaZbDvv8J2RWFJrGF0Yj0V0P++gpor1iuDXi3AnU9+cI2mKtGqF\n", - "PpMS7ugE5y2hF6PkZjzmPBcu98+xfqbmRM1CoWlORFXdoOm2kJthmjW5REZnJKtoCmFIaCeu65wz\n", - "ph8IW1gOGaMrfefx1tBvDMEFOhdECZIKy7JnKntS66H5FYispBJXJINKa8Rc0cpRauPFxTNKXUgp\n", - "0XIkp0I/BgZruXvnNV778td5elV4dPVdXvvSe5QK3/uT7/MLv/g1fvO3/hX+n29+k0+eP2feXfDF\n", - "d9/gS1/9Ot/842/y5a98iXffe4/gPcZaxn5kOeyYpz2b7QmHQyIue8btiJHhMNvxiMOyMHYdZjOy\n", - "VIfpNOWQOTo/5o3XX2XaXbHbz6S4MN08xPiG1h7vLJ0ZBUZmJV429gPTYcfN7oZuMzDFBa0R1umc\n", - "MK1huw7f9YzjBmM83gXcsGXcnnB9cYVVA3fvnNIocmVUwXjH0d17tJz40z/9No8+/ZQ6FTau43ba\n", - "E7xn4wc6O7DpRo7tKfs6cR2fktSy8hKURI0I2CLXlcZUnMpY5VEYKWGohrEO48R/o53BrNhV+TA2\n", - "uQ992chTRsRkGmhaej9KUG2yG9QYJ5pqsSQUOm9RiIJXK0k+a2TXmLxCKScnQZWoTYFyEhlMDWoW\n", - "GEhNtCKAYqMqfRjwrseYnkPckXMirnCUkjLRRqq2FCZy1fL3bYZWmKY9Rsl132YY6EMnAyOrcXZA\n", - "awhdx9vH97mYdlzuXnCz7NGe1UH1F78+t0XTB0uKbUVArcfml0H5NWb1Mhz9EtaxBieAFcNvFNo1\n", - "jAcbGtrJMKm1l80HjTfSxilajJXyTzeslrYBTVD31qywXmtQBkKviRMsrdCK7DiNK7heoY3wMp11\n", - "OCPH+1RkCOObJk0N4xXOKZxhrbjJlDtHxcX+lqCPmDcLpUas6yROYaDre7p54OhoQ1ZX5JhQTiqY\n", - "rgvUMdN1DhsMyji6ZJnnjHFS5TQ6Y8MeY0UP0GxbFRsQ9QE68MbjHdig2Pa9ELYNdN7QdVuUlye/\n", - "VnL9L1GOSM6JZZqwSuGsW5tLkcN+x9D1UPt1Ejzhui1Hd+9zcv9dZj3w8NGPuLy65v57r/P8yVN+\n", - "8vDH/LNv/Qm/+3/9IRcXz4nLRIqJHz98yF/+pd/g6M5jHj+/4c37C1pprHM4a7hOM1pD7yzZW5zZ\n", - "4BxY5dgenzIvB45OR7qjc4w/wVbZNfphw4nd8L1vf4snj55x8eIBaVmY9gec9Yxjz9mrp7z9hV9g\n", - "u93Shy37NGP7wKA1lcQ8J+xKj3LayIOpCSHcOIu1gVIKSxLL5J27W8bRUXOlqYRRFqu05Hi1wjjH\n", - "zcVTPnn0Y9699xp3230+fPCIfdszhi3eeoJRBKNxztIY2ecOtMLrmUVsgVgqqgnqzVu56pG2TRVz\n", - "6Vqtc1atPhwBXb9s4em25pVfTsl5GRtS6+S9odVab24SxdOr2kVc5w1ri4TKtSGmJHnjWslVeAcp\n", - "N7QpKGPXBl6FaohTZlkSk4ocbccVGCKxQVVlUKysIlRH6yx6Fh9nqolQJSPaVERVRa0RrfLKh5AB\n", - "0tiPOBRBWbquxxmHVQFnnQC1vWc7HnP/9BUe3zzmYvecpuLPXLs+t0Xz+GTgdrcQUxZPzcsLYP4c\n", - "4stP4d4AUNKAQAvFxHsJmSstbQZlGs4aSqmr7mE9NllLzXKx/vKeFORSnGbQZgAq3stCDOA9uN6x\n", - "RHnymlYwfjUIBolGeBPwfkEZTSoG1wA9Y7zF6x5tLM4K0FVlJT/sotk927HtDoybA7eHK4btQMuS\n", - "c6ytYD30fSAsHTATtIcoH8yqG8PoQVXG/oT9fpYpu+mpLZFLxnmLUwtNW2ZdiWbGhICNkmY2TsCv\n", - "1ii8tZIosApvBJhrqyKTOJQdTlUWBsosQXtnDLFkAoZaktT7FEzTgjEdyjnunG157d67vPruF1Fu\n", - "wyFNPH36BNf1nB+f8Gff/CapVWqFBx//CDRMhwP/xt/4bf77/+a/4O//nb+P/tqv8emTD5jmSQZh\n", - "Rhofxjd06Zj3B4bBc31xJQCCznF1mDg/GdFO0Z28giagUmF/mLlzdpd/8r/9z3z3ex8w2Fe5nF7h\n", - "2fMLUq4M1nKeNM+fP+LTjx/wi7/yPl94+8sMR1tKzizTAaUNNU/CvQS095ycbjikPc5YOmuI87S+\n", - "NzPOBQwNezRQqyLGiDWWuCSq0WxPT9A1UQ/XfOHNt3iy3/HRRz8GBdtuQ0sVf9TjjAwyfRBlrrcG\n", - "pwNRdygTsdqgkLxuLprm9FposCglXAXVBD7dWhH+6hrRAbWqRwQFh6prAw10s2gEhahsxdoKpf4U\n", - "4Ud2nKnW9YQmdtVUM1o1Ui3EJlnjlCsxa5wzlMZaCknYplC50BJMJaN1wnuPMnq9nKsoVait4K1e\n", - "DaWN62VHrQs0TWsGihFmZs2oJnGiVioVjcngbQC1kIvm6PiIwQ60FuQUZhUai3eee+4eY7BcTU9+\n", - "5tr1uS2awxhw3nB7e2Besjy5SgEr942q/XQUSa1h1NXDoxrOOYxLEqh2Gucb1jWMyWhb6HsheiuE\n", - "7qK9J1QJJmtt0cqwLGnNZymMqWgjfnOaHKe74IheqC66GZQyhKBxTmMs1LZQjYAEjG+4FUCsek/n\n", - "A7WsrMyWASWiq1gpB3j2+BofDJvjgO93bMfGNJUVUxXX+1rDoAZc8TQnaDnnLMFo+o28uZRqzKkJ\n", - "7q4KZ9BqhcLKw6hmQYaYgg8V5QzKVpyWIz9mvUe2BauVuMbNiCuyyz6khKoTtUZYEt4Y+q4jRdGu\n", - "xtW7XltjGMQPNIyn2G6gKcPp6Qm7h8+RDnLj+cUNMSmuLm9Ad1gteVrnO37040+otfLbf/O3+S//\n", - "q3/IvDT6oxP6IIMZqx01JU7PXkF3hpxuGTZbWs5sjo4YTu5Q5z0ta1rTlNDTmOi6jo++/wGPH+15\n", - "8Awe3XzE6at3GO69SscJ0xL54GKHSZ63tOKjP31AjI53v/AOqlZiqmjX04+NmtOqa5CHYHCOUiqH\n", - "aY8PPb0fUUrG0k0BtcoO0BliWghDx3B8ynByxhIXfvDwh3zrwz/l+z/5EbXA6XjKrB03h2uMKhjr\n", - "cc5InK5W+uRYioAtVDWopjE6YDGonDBNTlROGwmSe0VulUknNJGsKraBWjcO3ggVXcwGMjh+WVZQ\n", - "VUyT3stASSNRvxgzVgVKE06s0w2vqzBZdaUoyKWJ3tk6yVhmwcm95HXINimhrDT6jLaUbFiiIRgH\n", - "2kjqELk6qLqimlwnbetWhIntIImRKjXOYA2da4x9YZrAKQFuKz1Lxls1DtMz+uO36J0nzU4aVl6W\n", - "wT4m1HAE7ed0pzkMjloNobdcXx2YJiGfNNYIUv3puFFba1NiO3ReM246fC8cPa0kS6hVA93oe7+6\n", - "YNS6YKg1qwc+dNJ9rQ3tNM6vE3IjrR9RCwhAQmmBvCrVoAkbsh86hlGhzUKtiVI02hmCl6GUKwaa\n", - "wakGbV2EWeuUOdJW588yRfa3M5eXN4S+R9xRilwjSxF3SrBeYhtao5RH6Q5tDM42uiDTz1wNpiTJ\n", - "pc0FRZEPRJOprjOO1OSoHYJFd4amFQ6L0o1qRNeqkF2MqpB0o3eWPjt80Zgsu4hq5ft2OEw4q+XX\n", - "ZkPKGW89tcF2M2CsYhwD/bDBe8/gLGfnW27+7Pu8+dY79F1PMJacG0XpzwLhD370ff7hf/s/UpeF\n", - "/e6W3X5iszlhHHqJjljD8WaLMdIKGq3nZnfFyXaD7TrKelS2fkS7Hpwn7W9Jh8R3v/MB3/zuAw6+\n", - "45VffIXT8Q0ePnzEhx//kDvHI+//4teY9ws/+PBDju/cY7drPH1yyenJiHOOuExy4nAKq+Glg0bK\n", - "ZdLgUbVQc8UHUdDqpigUfDCklCQE3nm2x6coHXjw4Xf5J//093mRbtlYj9EBZTs6Z2m6kNNM7TW1\n", - "RGo1KJ3pQ0edQStHkCIdpq4+cmXQzQg7QSm8C/SdwwWDs6BD5Ho+UNNCSUmKB3ZVVFQls0tlaUVh\n", - "rBF7pWmEFSv30lOkqqKkLKcjYzG6rgYDOS1ar+mzo2QrNWaiXMGpTKNQysusk7h9jLXY1qNVYL9L\n", - "GDLWBjkJqoquoFzFAjkVgnb04QTtDU3vaU0iYFopnFV0vWYzGgyWcXC4oPBBiGW57Hmx+4Q7x2/R\n", - "hwFT22rWNPTeAp7iNz9z7frcFs0QAs7JHZA1jt3uwP5WlJ4vgRq8LEz+1G7TOE0/eMaNoRuMuG90\n", - "lvsMI6FV6xq+M4RexPQheIyR6FLJFec8VnvsnFhUpLTMuDnB+0xT6bOKmLEK6y25zdSoscFiOnBB\n", - "g7LoamRjnApKa7rBQ9MrLagILNYoaq7ElKipsCyQdWF0jjYbbq8X9ts9ZOh6y7RMxJrIRIzSWNdj\n", - "SqWgsKbjM5J17VE+YXUBZkqWuIi1A9YYalpoTeGV9G2TW9bduZfKXLQYxI1u7LojFiqKzE+zplMO\n", - "ry3WK/SsiCtCrFE47G8pSViK25MTmmr0vYUSUXrDxdPnvPb2O8R5z52zM774ZuEfpT9kOSTefvct\n", - "nt0850++/REgWUCjNF/+4mt8+4/+Kbe7iR9+8AO2RkMRpe322HP1/AZlBpZS6b1DqUzfeWJtnNhA\n", - "t9mQ9w1/ciJUpDljbceHP/4JnzzZ83yuvPHOa/zb/87f5s75u/zdv/ef8uD5Nd/7zg958viCv/pX\n", - "fo2v/Pqv8sff+hP+tfvf4Oj4dUKXSdMlU1zojUFjMEoTYxSCjvNQM1o5nFuHe84SvAw68pLRSpw0\n", - "g+9x/YDfbEna8L2PvkOsezpVOD8/58X1Itlb69mwYZ+ek8oVcx6wBRoJrxVZ289UFMY0MhHVEk5t\n", - "2dhO+tvOSZSu8/ihw3lFNzju5sJuOnB9c8M0H1jqAd0ke9yZDucttQh/0nmFdRmnEzDjjBEWrPLE\n", - "JpVKhUK3QqsZYy1Gd+jScH2PqWsN2hoMk7zPXKOUSM2Wisf5AVqAOhDchsZCLpXbaUEph/ca1Uv+\n", - "1JoV6OPXarQB6zqimmipUqjYDlzW9J0g5cxQ5RRq/jx7OcULPn66cP/8C5wNJ+haSXkBJVdb3f/H\n", - "svi5LZr96HHWYe1I3/d0/gZjrjgcFva3cpyV1qNM1Guta/WtEbqCcQ0XLMFLmF0ZiSLVlkFlQteT\n", - "JsVcpW4odxfSQddKjpTOy1SxNodzDesqqA6aYNtKzryknqPAGkfXebqukss6BHDI/asKYntUbYUr\n", - "yNepSGtv+eUxVuIYxgcRryWIU8GwQC0scWYpM9XIXalZwR6sldAubISEvfqCFAbdMt6IgtWoRrCB\n", - "hiYhcBOQnacLgeAHjLYktABQKAIidoWiBdXkzIitDpUUMSWhINGIKUFp8vWUyjBs6LQllyo9YR3I\n", - "OTJNM9lm/vD3f4e3vvB1+u3rHA2av/Vb/yr/0//xj/nSL7zDF997B4PnweNP6fuee/fu8fWvfZm4\n", - "ND768SdcPH/GN/7KN0QzXKHGSrCOpDRdCDjdqPNMS4mTk3OUlxplVQbjN+QqErDDTeGTTx7zB9/+\n", - "gK/9yi/zw598n//g7/wndP2WDz78gPmwZ9kv/PG3v8PdOye880XFe3/p1/nkOvKV8R7kSyyXONWo\n", - "K2A6z2IB9V7urdMyEXzHkma0giXKdYVzDmsstam10VPo77yKPrtHTjNHJ+ecbk7YPf2Evh+4q0dq\n", - "ysyt4sII80TmgPEFpSeMlpZbDYqQDaZVgtOkIgMmr4S63nsrv8a1mugMOnR0uSemzHg0cLQ95mZ3\n", - "y+72ksN+xqAI1tE5h/cb4U96hQuZVtedbo0yU6iRqhsZvaZHDJBBFbQu9DqQGthNL8PCatA64taY\n", - "k1rvPIPVVKNEj1ECPnj6LqCryNqmZaJZx3So9J0G3SCArQplRThnnUJbQ1MLyiqqUvRViXe+WZyr\n", - "eC9XC0Z7sSboyrwkLnaP8KYRXAdqkayzbjjf/oVr1svX57doBo93HqOt/KCcpZmInNYa8yFRqxT1\n", - "Gy/955m+9/iu4AM43wh9FcJJlcXVGPlzWmV8F8jr4sI6IUc1ako45yXvWcBqTT+IoldhMFqOKJOW\n", - "aZy1ilzEL2StxgVoy8vJPqu9z4mveY1zxJZQupFLpNSFnCulKKmDNcU0HTg5O2PTDeikaLYxlURZ\n", - "nT/OOrQR7p/SBqUqS5oZx9O1RVUxqqBbXZtKUmFzyqErNGVRukDVaDwGg9U9gx9AVYJ2kOVOx6zD\n", - "BvneZ3JeiMXR2gAKcs2oZaLEQlwWnDUMw4ANFopmGAYhJDXQ1jDf7lG9ZRy3PPrJj3n9vQ7dMr/0\n", - "pdeY6q/zO7/7+7z/9S/T9Rve/fJbbLqO09Nznj6LfP+7P+BHH36fr73/Dr/6K18n51tyilxfLKS4\n", - "wzuN9YY4z6Igrl4yltZhXKCyx2yOKMnQlsxH3/shf/BH3+Z6aSjfSMvEd7/7LYoCVw3T7pr/6B/8\n", - "A/7yb3yD//jv/V3unt/n9LhwnW451MqQG9fPP2W6ekxOC40qtdtuJMaBzck5J9tTrm8uqLWseVvx\n", - "J2ljsM4Anlwiwzigjo6hH6BERhc48h3v3X+dw1KYOs9+Mgza8Dwe8FnkX239MMtubyQXRauJ4Axj\n", - "CDTA6kbJDeclVmadwXeBzjuM6/BqJCdPypUua4au0XUbhnFk2S+keY+qRQoRVkl+uFMoU6lVMH5W\n", - "Jw77HSXLsIcqiw9V0Q2FlAvbsRfcm7XEWeP9Fu97Urui8ARDouodxkqluet65grKVrypbMcNXncU\n", - "VdlNF+ymW1TQtAjKKqwuWCdYN6011q8AHyWcz1YtGs8QPIqwxheVXH3QQTFUlfEqYIrh+uoJ52d3\n", - "ZPixXh8Y83O6aG76NdCtjMBya+Ps7JRSILW8VtMEgMrK66ssoJxEebyiD4ouFHI2tKLWO03kiWcq\n", - "NiRMFOWDkG6KtBVoxDThrCcEjzYNZwvBO5yR3JsmsPSJeZopRdOMHBWcl0CwIPEtygvNR9zQYgAs\n", - "VLIppCyRomqjPA0nYWi6AK1Gzk+2nJ6dQoNgDM0UplZoqaGrwuHIaiZXycwZnal1xuhe4AhK0Fah\n", - "OaHeNCTIi7ixFW6twQkyK1hH7+SqokSLsT2siC7B6FWyBdMaNWVu0h4VG33z2LiQp0XUqTkx7TOh\n", - "eHyQgZeyipgKeUlSIa2ezThgmfjuP/89su94/c0v8o333+W0s3zvhx9i0gFXMjePdlx88phSKu/e\n", - "Gfg3//2/zZ2796hzIS3XPHvygPv3z6EWtF6PxkZTS2McB2JrdLkQdzs2J2eUacH4nsvHL7g+FL71\n", - "g4+49+Z7pCWTpkqnFRGDMpqlwNnZKb/x67+GdT2tNQ7zhI6iCDk6GZkuO/YVbndX+NCxnw6ELrM9\n", - "0jSuSV0ip8SyHDCbYzKRmCaC79kenUjxAiM7nZRQOTLtrki7K0almWohLTuGcIwfey7iHmsUm2HD\n", - "bZJjbQWsHtf7+cIYLE1B54VUbnXF9p5SZ5TJglA0Ct91hG5L1R0QSKWyRMc0z2C0gDP8TIkdqlZp\n", - "eWFEEREktldKlWBTjTgPSjvB9qVGikAViI21DaWSzBSsx9uOo82rWN1YUqDZHuV2LDlwe9iRUsS6\n", - "xmazoWaNN06aV53cnw4qkNrMVdqhqsNGjeoq1RacrWuDp6xDngoqY7TDmxWajNz9irDN0srq7LIj\n", - "NWmUFUndFK8Zh1O0scQ0r3nxv/j1uS2azkv9EJCFrhmiMvSDIyxGNBGqME9xJZJL9bC0ggua0AnP\n", - "0jrJTc77RKmyEzS2p7UolkhdaMWTM7TqSEkupYU7WNCu4L2T+xEb8N6jlYdWONqMlBS5vsnUrNc7\n", - "GcRKycrkM+IX0drjjBezo67YmlnSLYKWU7hQiVPEeU1Vmlfuvspmu2Wz3UgWU1W013L5r2X4Y1cS\n", - "ea1if8bIrk+3BCVjVlOnLprcDlhnKRHaOgQCjXUeE2cKUXD/1mF1IxuDNR1UK7peDlSiBPo1JNUo\n", - "LdE7j60e7TOuNlIsLPNMP46oYiTuYySvp1sl1cIUE/vDnsvbK95++13Oj04wXeDFowdcXt5w92TD\n", - "X/3Vr5BiY5lneWNrRW+hlJllitxMz+jdBlPAuca0v8Fby3xYON4OTIcDvQEzeEw/cJgPbE7OmA4H\n", - "NqFnuYxc3+y4uV0wdsvN7S3O3+fOK3fwXaDOGVrl5PiEf/S//y6qFbbjBtMbjIIWNcErNnd72vwm\n", - "h90Fp0bx/OICq2V09vzqkm4/8corr6KUIoRBuKJNpsTBD2I+VY3edeKaqmKodNMtm03HJm6YLg+0\n", - "znOxXBH1wpwjyhp6pVB0JCf1Ya07uk6MAlMLUgv0hqYrugmk2DmLd4qSIzkq2mmPHR3OBJoeyAXc\n", - "tKp7lVx5RQ25M1AarcgDSWthJgiLM0kkqVYMCquyBMerPLjKSidzToNKGKcYuzOcOYNqMTqBKiTE\n", - "VOq9JseCUgspX7AdTmjFrWH0mboOX63PuNQYlELVSFLSdRqURtsqR3KdsG6FgWtDUgqlsmxkEIkh\n", - "hJUUbyhZfOxOW1rVkppRjlIP9H0AJbi4n/X63BZNay1o8XDXLOpaXRpdZ+iCZc4T4ybgTGY/JUqu\n", - "n4WtG/mzPndTQv0wVgvWScslMQqUroReYkq1WLHplSKZtYroWNVA6BogObDgB5qydA1s66gloWjk\n", - "crv+wCvaK3QV1YQAYQPBBLwPQKNUsM4yqI45TqRUsUHTDYZ50vih4/U3XmXcdDgnVTitGlUlDI4Q\n", - "eqxX8jU2yZW+pNekdMBqh9LSNzduHZTVdadtFZS6LoiyaNZOo7XBG9lRvsTkybXCEcE3GpXU5Ii3\n", - "nwoB2PqROkWKlu+BtZYUM5vtlu7oiFI0ZmUeqpZJSYYBtVVMU3QedjfXvPH6mfiqtz1LSVw8fc4Y\n", - "Arlmjjcdoe9oxmH9wO7qGTomTscNNzfXHPY3TFNhfOcdrm9v2Y6BGjOaJpPU0IOSae50u2N7fEpe\n", - "djz7dMfuUBmC4rXzI77zk4+pX32P19865+3X3uDPfvADjDZYY/jHv/O/8qMPvsmXv/T+ykrt8LbS\n", - "O8twukFdn/Puu1/kxbNPyc1y2F3QmmHTBZncpnlttOn1IW6wrqMBuSRc8uAaug/i2Zl25NsLnLFY\n", - "29OFnpu0A5XAaLabgaUWmWprRykL3ajpjaLvT8FodLhhng4YD2gLGeIc6Xyj1SJd8fWBbrzH2YDv\n", - "B1KqGH1YYduW/X597yyALXKPnw3WeJSVHKMpUJIE0xMOoyPBGg5UdHEol0Qlo8D5QOMa609lk5My\n", - "zjqqahiV0NoQ281q2fTE2XGYLjg5fo08Z1ItECVxYK1m7B3WOZYYiSWitFkD+3+u2VDKMvQD2Ypu\n", - "JtlF1gttaFlgzlKXl79mPa951baeLOW9NC+3Mu3/C3CWn61d/7+ujD/jJeShArVKuV9brLUYI/Gd\n", - "WgRY0CqMyrHEBdUMVpfVDCnys0bEuoG+98zzywnZOn1fp2GtGuaDApU+oyvVqqkolpToq5aGh9Vg\n", - "wCiH9oZgBmo9xVmDdSO17QleKCulVlQuOLOh5p7gPFYHlrJfw/iWvpcAcs6WohphmznGcbo55+ho\n", - "KzY8rTFBKEwtKbSy+H5DbQmMIscZVIUKMU0S3DcOVQET6WwGnagpoZR72Q+hqroi/leVr1I4o3DW\n", - "UlvGBo1Vspt1K2gipQOqNI5tj6odaoLebzAEbEhUnfG6k2+xNozjSKvSvrDaYpwjl4LzgZpmctEs\n", - "S+Lxo4+5c/9NSoHTYWTjE8PRlvHkFaiF4zt3GY/OuX5xzWF3QUkHOle4uXpIKYUvv/8+F8+eoI3m\n", - "bDvScsUqOT7Pc6Y3iZZmbueJrvM43TPd3FJj4Pz8Lr/9r/81Hv7X/wOf/OQpb75zl9/4l36F2A48\n", - "ePCYWitf+8oXefvdN7h//11OTs958vED/sYv/wqnr56gN0foo552Bcenp9wcJqyONDRTWtAYrq6v\n", - "GccNm80RxmmUshgbcM5RFcRW6Y0FF1Bec3j8kHLYM4YNZ5tESbc4/SrbfmYphbkVDrUxk6nOoHVP\n", - "6HsGd4T1HSEE+nHDzf6S/byjUuQIrysxzjSV0M6QSkGpQG4d1sppKlgPJlNVBAW6Wpy1JGeIy56s\n", - "IDPLe7guKDVjdKSqeY0IaawRipX3mezteo+/R2vppVciqT2nFU3n7pFrwXlDbR5lNeDJfYerFas9\n", - "KWWW+QpvNkJKapF5Fv5lsOBdwCpgiUIpq41aHcF7vDOSteQW5w+0ujraW6ZmRdN23fgYAXYrTTBO\n", - "OunKgPIS09OVWhXBO8Eu/ozX57Zozsse5yw5JeYkk6/WCtosuFDJ1aKbQHwVZsVUZZkYa6FOC3rK\n", - "ShTBNVLSq2BNtBbSNRU8lbXSHqhVtBTOGErJtJYpRa9g4EwLUtnT1kF0bLfH9P2GTZeJ5YqmL3B+\n", - "ljC5bTjbQzkWt7KKBNfT5pnSFlALzje6wZBTo1o4GjtxWgeDcVEqnNaSSmWeD1SV0aoHbWUDUQw5\n", - "HagkSjtIUDoIoqxNGUwht5lSo0Bei+wuYVWAVAEBWwOKjKLInSOCwKMqtHZYs8VnMG5gNANdf0IY\n", - "HFY1HBB3EzlNLHEGVium0lhvMc4yH3bM+1tKkhjQ2HfEqdF3R9jecXl9ydtvvkONlXG7pdSMbxMm\n", - "bHj+6QOunj1h2d+yu3hM33mePXuMVpnt8cDFi6csy8LdO2cYldjvd1itCDA5DgAAIABJREFUSVKE\n", - "58WzJ3ivWeaFw/U1tw+fkPaNkgqb7RFvnAX+s//w3+U//+/+Fy4edrz11Xv89d/8a3zy8BOMabxy\n", - "9zXeuP8Wu/mWxx9/yq+/8zavvL3l7ntvENOO2nYMznN58wJvNH7csp8TNUJTijgnXGgY19H1PbUm\n", - "jBH7YdNKHtzGY+xIvd1hlz1VGXql2SpPsyNJOYJzXM97VFogGNCS7w1e0/UndO6YMHhMcxx5y2Zz\n", - "wtNnn3K9e7bGrzr2+8g8LWgTaNVBtXInj2NOGWOk6tj1jlqiYNycpnnDrUoc8oy1CUUBFamp4UxG\n", - "WVjyAWtlAGt9wfdmtRnI/6tICQu0Qk4HtNtRWo9xQfxUdU+rC5WJ0BlKMXgzUqsmR6lXagO5zhgD\n", - "NUds8Cg0g3e05qh5Amsx1WOUxZse50CZDbncktUe40TMlpug9MraFnK+k2poquJEbwrvRNmiKqCN\n", - "6GzG7meuXZ/bohnTRENyeDHvqVl0F8ZIRKBVTQSUEuhtwGJcJ9Uwm0W25gWwga4Yi1BMELxbKcKv\n", - "bKVgrFu9IhKmhZdUTCONBiv5u5yjkL6LvOmtCxhtmKcDfhhRJlAIxPKcqsTD4swGyga0Jq/k6sqB\n", - "Jc1CNNcW7wAS2jtG7wlmwYcJpXpimah4puWWm9tLjo+PBebrLNpAyh5SpSk5VueSPzP61VaIS0Fb\n", - "Q4pK9BLrG8Q4g2qS16str+0kyHmRlpSuWGMw1mOtxXvFIWWWekWOL6h6ppYOE4XJaIG8zITQybHW\n", - "u7WTr0lZuJnKDAyuEuc9Lw4HIIPNDGUglUaKH/HK2V0ePPgJJRceeYPxnWRdafTbY4KRxS9XqMby\n", - "6MULKJU7Z2fs9rd4pWQ40aDvB168eI6zQrSquZCnmZsXF1w+u+L8lXvoAo7Ckd3w7/1b/zIfPXzO\n", - "dz++4MDM66+9QWuJki0vntywzJf80uv3eP+9u/zCL71NPFxx8/wB5uIFF7tLpsOtRNfMgFUJ1xQl\n", - "Svsspsjzi6cMw8B2M6JS46AawTt8Bbc9po0D+dFT2rJnOUxM0wGdIyddx20x7KaCcQXtoOkMpTAE\n", - "T7YNZQSC4s2Gznfkkuk2W5zqiNPCNF/LvbjW1GaISyYtkcM8448hN6l/UiKtIVc7KpHVhFGe3MQT\n", - "1DnPNEUaiaZEC6Faoa4blqqU+MZ7zdHW08pMZkGpRllBzbktUCAXzUSiFXmAh07T8i3GZUInylxl\n", - "Da14kjKUJBuhbtys5soElFWeqBlcRyHijRPvUtbgBVVndQfN0/meXK8peVo3DQVjwtqZBqc0tS7r\n", - "51+WP2tlSFeLlEN0/TnNaWpdxcNCJpcDiYhuDioSKUBBlQZQ5wXIoHWguYnQW6yptDavaCtR7zpr\n", - "KElo1sZ7UrkGEs1KnSsXoVlrLWR4FwasT8LXxK6K30xpkRorw3CXlGTh6e0GZQaU3bCbHXMWIIc3\n", - "5wKqMI1UHCndoE3GFE2pGZrC2gBKpuzGWvlv+j0tWWJaiAV2tztyjSgtu1aJT4H3niUp6ewa4Wc2\n", - "GtqtDqLaKDHJhL0sco9U5B7JWCs6Y9NWe6a8d4wWZmBrmZxn0E52ACoxc8tSr9lPC12+w5Ee2FgP\n", - "RaqDu5uduFmsGPuU0kLsBrR1HOYbye3pxnSY6XoRWXnvSDFyfXPNq/ff5uLyOcZa+n4kx4VaFqZp\n", - "Yd7PlFqIy57aDK0FmorEVLnjRpwfscGzpETOMHQdtUZKnEkx8uR2xnUd6Jk0PacuYMKWzXZkON9i\n", - "deH9t+/zycOnPH52w9WhcXQUMK3yyhtv8PZbb/De19+FJVGvP2L+9IfcPnvMze4KZzsyho0fGLU4\n", - "bOIhk2Jmmm9wzhC8kJ+stoSuF6Tg0TH0IzlFvNZEJ2HzlGZSVVANWhX60DMDUWuKiuhciTagVGJJ\n", - "t+SaODs6EgbAygTt/REUePjoA/aHF3inIMuCU/ItOU8sKWKa0NM9AmRuFQFYl4m4FEoVgLczA3bs\n", - "iHHHkjMxXeNMxNpMKQalPdZHhtZDVZSmOExaNhQ5SUi8jRSVoO1FkFYDBkNrBq0DqlkUhuDFclow\n", - "9ENPjpZaBHitnZfvT9mjtJPscZ05LAeRB7aCMnI6Va2X+0oEOqJVh9FJ2lrKgupQKtBqWIEhhVoj\n", - "OcvGwPuOlj2tgGoR6s9pjdIYQ4xNIjlNpms0yShaYylruNYag1UGmmgLjAsYK64YZwMtTWhrsM1h\n", - "6ClaiRLaQjOe3MS0aB2kHCEJpspYjXWGfpRBhjaGSmFJB3ptSWni+vYnbPu36foBimIcenAa48+5\n", - "vp2lNaS9YK4UKGeobQdzQrsiCdOyUJvBWJFgaVfASrUs1SuZlKpGinvAgJqxrhCzaEyd2WKtIbVI\n", - "6KRKp8xCa2LYqxUKhiVK5lTZgpzFtag0qoK4oLVYFGO6JeaE1zMJLcO1FigtAguaIkcU1zHYjhob\n", - "+3TAZkF4lZro1EDLhXlZqLWSSuRmd71mPRVD13G8GTi9c87N1SUX1zvSsuf46JScMod55gvvfYmH\n", - "Dx7S9QOvvfE6F8+eMh92jGPP1e4GbTXLbqbrNjjb04eRrj+nWSdA6QpVa3I1tNS4vdkxzwvOGXot\n", - "QNlGoWsVPzpivOH8zffp7r3Ch3/wf/PmGz3vvH2OMj26t2yPTzk+7qmxsH/xEy4fP+D5xx/R5oiy\n", - "im7jsb6nU4Z5lnB/qzCOPQd1YIry4LDWMo69UNBpnBydoc5fgeNT1IsnlFzXHZ0jayO6Z20INnDU\n", - "JIJH0nhvOajKbCpHpmeXPLc3V5wd3af3G4nJBYPzPefxNTbdEdfXT/n44T9HuwPGKmq9JOdLynJC\n", - "PHhaH4C0CtosVXXM2UFVWBVANXKFli2dOcYbj2k9MT2RoUqTzLJKgeIK/WCJ2RJCR8x7piVR5obu\n", - "BEJMS9Qyr0kTvy66cqIzSWGNk567ttRk8bYHq0lpwdgkLFnVr0fpjPEBuItyO4LvX24eSWXCak2t\n", - "mSVONGZKlbt/o3vJLFcDyqKUwfYj8yIAk1QWYmr04QyyktPvT2FJ/kWvz23RrFVQ96kUytr91LD6\n", - "aCq6VZzXaOWwTdzlxoAz0ot1Roldztj13sauHDwLWix8unqsTqSa0EYyYbWKMdGg6JyROp6uq3St\n", - "Usokd6M6MMdLunCK1SdY72kCCsQYQxf6z3KYRksFsdZFyDMeWoaildgoyYD4VKqKNO0pTWAM2lRy\n", - "3mO7Ri1Q24RSSTwprWCto+sGCjuSSrgmKlKFIdcijd9myFmm56U1nFoJ1qXgXUCrgRQTpR7k+AfU\n", - "ektplkqgpkLThUZEo3AtYJrDNkcXPDpWdC0UK62l2+tLUYW0yjJn5uWAptCyoTs6ocVIOizslkjJ\n", - "9bOd79X1FVrf0lSltIWvfuWXePH0Mc8fTZyennB21HF5c8upOyU9ayydZZonjk7vcPfVN+m6EyE9\n", - "xYQvWSbyXjHlmYahtURqBpcFUG2NZnd7wRv37tKsZrl8gj67yxd/+S9xuLzi6vKSZX7GWE+YLw/c\n", - "PJ2J88J8uEEtM94o2mA45Mh8dWAzCHyjOsGMeec53EykHOmHHtXg5uqSVhPD0YZNv8EcnaKOz2go\n", - "9IpMW3JiOczUIj+LluVr6Y2hGUtVPddKCEO6ZpK1wr9Mt1wfPsX61wl6xChH5yz2aOSw71HV0+5n\n", - "rvZ/xpye0uxMXq5ZDs9xfSBnoYLV6oQ1mxUwUtIt1AVTe+mFV9FFGGMZ/AmhGFK5IOUdjUxDtMJK\n", - "K/ou0ErF6A6rDSVngZqstCSjG0pVai4sU0S1tVefK615tArCRFTSW6daWhMyu3cG321Qpch9fkkE\n", - "7cjVoKoUOlByoqux0SjUFslFct3OeKwNsoM0DZqE31EapZw8BBzMywGaJfhjVPOU+HOqu1BK3tgq\n", - "G7SWjJbVegUFQ6wCcVCARQvJ2YppUhuDMgVp8ldas9SqpTutxZHeapbpWDNYW6muEhdhIWoT8Xoj\n", - "YjM0xitqFQ+RapWUrlFuizKB6/1Djke5K22x4buXwidFaYWSK1EpDJXKxFInrO8BMd9pZYl5QmHJ\n", - "daaWiZID2lnG0Et3NlnmQ+JwuCbVayrnaNzafy90HJPrgaYupfOOXrFdkuAVG6UciZuWqJUCSiwU\n", - "5I1idKCxrLU+QW61lqAmStPkKJpglS0dhqNui8uOkjLKqhXkkIVNSqRMkTlm5qmQcyKVxGZ7wsWz\n", - "5xjdOPy/zL1brG7pVab3jO8wD/9pnfehdh1N2RhDuZ1uh0MIJCg0EUlDK4mEZBQhYaEkROLG3FkC\n", - "gRLBFTcQISEBUhMpBDURQQpK0lHSdtJpCQeBSbnLUGW7ylV7V9U+rb0O///POb9jLsasouk2Jgpp\n", - "wX9Vqlq1dtVac47vG2O87/N6FEmGChmmcSLGxOZgzfrgiKOjM3IqvPDCs+zGHavNIeN+INQ9MSVy\n", - "dVRnOL15BLXh+nLEhIFbTx0TnaNkwTlHJmDWJ7hcMXGvpoNqGKdrbPGsVyfUccIddEzbC8y45fLd\n", - "u9im4Wx1wGVxXDy5R9e07C6vKbVyfLghL1vefecBl+f3WbcGfKdAZtcTayElyFMk5kSqM6jD6R1l\n", - "HAb65ZLF+pDatdRwjc2VGgdKSnjXEGVPDpGcktKlqMQQMLnQW0ssFpGWnIWpFLzvWYpl2l1zWb9M\n", - "v3ma3i1orMMsFhgimZHt2HNkn2efWoZ4nxICDDvSfqs6xqDvW04VyQZrOpAd15fnODZYezyjGS3W\n", - "Ohpr1RSSRyKJmCeEiOBAHH3vyTFgRaliOSudLMakl5hqscZjrUKRY1R9dUwT02Rp/UL5VzWSwg6K\n", - "x+BJAQyVVa+yqZoMtRQlgBkDZSDGgWI9Xgy5VlLVDbjUhUJzzCGWDtPuNEkzKXlKELzvNBa7BITM\n", - "MD1SWZ1Z657k63z+GjOC5kB5r7nWmsEjs/hc3t9mOycqZzFKpX5PD2fm63jKf5ZoGYPyojMN1im5\n", - "yNCSMlAz1hS6pgeqwoaNqP3OVEQmqmQwmVInYk4IC6RmLq/e4fDgBuDIRXT+VxI5JVLKpLxTgrYU\n", - "ckq6RHJqgWxblcCUAsUtqDVibY+zepO0pqPvT3F+S2RLLDtiuqDvnJ7oWelKIgbnvMaZlkipmSI6\n", - "hzIUWtNoBAcWqnIUS6nkpA+JGEFEN/zvKSpSiZgSKAmN8ciVGDO5JCTvWNPgm4a0D6SQsKUQxokw\n", - "BmpK7Pd7chZNZDSW3TjirKPdrBXskRMAXbfA9ZGr6y3FdmxObhFKg+1WnO8musUhX757ztnRMXee\n", - "v8F2u6e0D7n7ypc5f3BFzg/ZtI6lF+69fsTJ2W0WywPEeprFEu97olmS3AlLH/C+4DZrSgTEsNs/\n", - "4cbpDTha4oZAazsePHqXEgL7aUByxswz477teP0rX4YaadqOg8MjnDEKl0HIJCgRb1pa17NceIZB\n", - "/eW1JqRUGu9ZLdeYtgNjMPstNU6YUqjWEseJrmuZRk8qkRgnjDgWtqERy7YEVhha47G1YlIilIqn\n", - "Y5smhu05sY4smobGPo3FIRSkOPpuwRguWDVHyJSZ0iU5XRPHLUVavFgsaY6/zqSUNVnSV/bjE0wa\n", - "6Zo1OYGd419qjXMn0yLonF55CwqVWy5WDDISgyoWUlE6OrViTYt3DWBneDGAI8WRfd1SS4NrWkpu\n", - "dOEU1a5sciGlwJY96/VqhtG8N1vPxKBxwKVkcoFMBJOpMlFKxbuOXFXor/G/aoKJaU9JmZh02VWq\n", - "dqG1JKb0LtFczDXiL/78pUXzk5/8JL/3e7/HjRs3ePnllwH4mZ/5GX71V3+Vs7MzAH7u536O7//+\n", - "7wfg53/+5/n1X/91rLX84i/+It/3fd/3Nb+viC4nKt3s305gC4JSjpwR8pzFY5v3tt/yXnKQMi9R\n", - "iY1YzctxzlKyzEVmxsph3kd62QlKcTNuTdmUzluMVep0ISNNpERDzZYiW2qqlNKw3cJqfYgkUYAB\n", - "mVK19ZzSSI5q/apkataxQtuojtE53a6mFKnG4Eyjsakl4myHcUZD19qWFCdiCdi0V2xXcmAyRty8\n", - "7WcmQFlynAnbiJ7mTuVWxugIoyQV8DurDqsc0dmxoEWcQs2JWjzTOGhJKBliofUecR1UQ9s21DxQ\n", - "cqBpO+IwEXJksdxoiJWx5GJ0tmxVuTDlQtf2iAhXY8BSOTy9ycFmzWpzwLMf+AZOT4/BONq25+Do\n", - "Nk8eP6bajnbTsYqJk5MbvPbwVcouIl1ldbpg2j3h9Qdv0fmWbrlieXQD3y9JtmNxeIy3idZOVGNY\n", - "r9dIqSwWjmF/xfL4iJAM3fqYdYpc73f4pufsxjHbJxeEkNltH9F2HbZ2NL7BOa83yRw1frbRW9A4\n", - "bnWGPRSsc7TekSZVKKyWG3yrQOZsG8yUYHdNiokcJ1IMTMM1UGkbjbMVa8gxYhH6WlVbWwpL4/E4\n", - "kghXFIZiCCYTtw94bJbUpaN1C3JRrKAmpToEza7KeUFMetMEVYDEOqn0BiFlCOMEJErdM8VrQrmi\n", - "9z01Cg36zNSayblSSppvmZqoYK3yI9qq7X+pou191SDDvl9iMPqezrNCTYwVfXem/ZyfBbVUcnZI\n", - "jhoYR2W/nelIbn7sJapZZU6xtGJIUUdVxhWwGiUtoo4nIwHnNEUzJV30pvnSAQXrtBuyAqWOlDoS\n", - "yvBXK5o/+qM/yk/8xE/wIz/yI/9cwRM+9alP8alPferPfe0rr7zCb/3Wb/HKK69w7949vvd7v5dX\n", - "X311nhf++U+tVbl/ttHYUCNQC9Zape0wkqvVxDqCbnhJNKI3rxjTzOkDmQuKVNHi957uigrGYygq\n", - "ircg1WGKx2LmRL74fia6sqwFcZaCJeWJWjOpDkyx0BeDoyekRAwjSCKTKZIJYaTxnoJGY3jjqGKU\n", - "vJPVt15KoWSjVvr5T7M2Yp0QksH6AC4wpiv9b8yNZsGkNLunWphzZkSMivQFUi6zrEpUJ0dRmRGG\n", - "mCKlWGy0+FZjQnJVelOuFakRi1KsS43EMuKlIcZMcYWmXcJYsDZQ2w5iQdaJ5bLjYjtQykTTAzmz\n", - "3+6IKekhUISLqyd60zLCcnmDao84e+oZPvrSN9H6lkcXW/bjyFO3b5Oy4YN/62N4t+Dy+gorHmc3\n", - "XFxPfOXz1/zR73+BF24t+JaPPoUlMeFZtisuL3c0IXCVPM+uDtlNe45vbog5YFLEdZ4qlrbrKX1H\n", - "d/sG5tYzHN+/x/jqFxjHS3Z3H9N4w+1bSx7e23G12zHFxNAf0blC23bQ9fSLHus62sYxjYFxGui6\n", - "nlwy26vHQCRknQ93scDVpb7o/QozteTrc0ouWCKLpiVadfE470i50jjtUDo8aTfSkjFVD9nRGLwJ\n", - "9HhibsnumsvdVynZ4lhi7IYadSkSoiY/1mxxtOSSiEOiykBtqjqPqnYvOWWmKZB2O4QRa4WQ99Ti\n", - "6KXHu1ap/m1FopAmsFKJRWN/a7FIY3BY2oUF02GmaY4BcTRe4d1TCKoksT0xB8RaSgnEOmKDByIl\n", - "tYTksSlTcTS+o5TI5dU7aqSQgSlcKlzD6OVKRMhlrzKq7HAiiK1zLIe+B1PYIXTknBATZ+Kk0tGQ\n", - "pJbMKjjjYUYy/5WK5nd913fxxhtvfM2i9y9+fvd3f5dPfOITeO95/vnnefHFF/nc5z7Ht3/7t/9L\n", - "X+uNvvRGBGyjt0OTKSXibEPOAbFgiuipUKNqKv0KQTFkMSdy0V90KoWU1VObS6amjPVG0+oEIoHW\n", - "VlIxiFiM6OnnPVQ0LIuZ0QeGkPIcE6wLErHCMF2oDSvpD1tT60S3/jWr+DZ7sjiMc6S5ODnX6QLK\n", - "FVItTONE13dUKYS8x+aEMZX16pgQd+z3e8ZwjrMLjGm0fTZRRxjG6MNahWqFWNRDrbkvGp0rkrUN\n", - "yUKIELnCGk9xhhIVaZfShHULRNOz5t9pIZcJTMDWR+yCpaSJlVvhmoZp3BFKQpwCpFdHvYKSjbbx\n", - "65UaAXKBmAFnODg8ZsqFwyO9lbZOKDRELP36iKlccf/xjt12z9uPLrHOcfvOM7THt7l9dJMPXW11\n", - "sRUmDpuJ633keNVzevMp/uS1h0yp5dadO9x57gOYruWp0yOOT9bUFNhuBxKVg6NbNLc+CLYjhx5q\n", - "ojt8hoPlQ3Yh8nAI7Act+vSHLLtDzfrZXrMb9Sa0OTymGkOqajtslits15NToml6DmxHGa8xs20x\n", - "Hqxpjtb6uxq35HHPFBJTmFMTjZBzVZwgWfOcaiVXzdVp51a2lsw+XVMEnC3Y+Z9FK0S27MI9pK7I\n", - "6SGmNNRkQTKd8zizYAhxfi4jebzUpY+gJK8qlCKkOBJzoHEeEPVgl4lq9qSyxUmL8Zpe0JVeo28L\n", - "SrSXgLEVIVHKpLduseSUEaPgnJzUpGKtJeegkjkRGt+QkzCFa4yxMxW/o+L0WYwTvrHkEgjxShe2\n", - "0mO9R2zByBFIZgyXhDhhTNUcsBn9WEqdF1JCjhM5F0rN5CqkOlAp2NohUtQdZRW/WP+qRfMv+vzS\n", - "L/0Sv/Ebv8HHP/5xfuEXfoHDw0PefvvtP1cgn376ae7du/e1/2BrEeOYYp2lKrrFVqlExTlLa3ty\n", - "LlTRjG3bqlfbmo4ULMYmzWQmYavoILqEORTKo1kpKmpXrFuFbGakm26gQUnUqSZsowNwEYuxBUmW\n", - "lANWGp2fJiHEHSXb2YqZlTCPLmNKhpw1j2WUQWODEaxJc6H2GDMRAux3ezAR5zO+eLpuTetPWPVP\n", - "I/Uu17sLYtjibY9U+/4c0tiZYiX6M8xZPfgiyjW01qqEi0KpGjuQc9B4WrF0c3ZMqUIJ2pZUSaQ8\n", - "IaK3zVoSsXqkOyVLItSMsR0HN26zuLNApsqwv+TJxQPyZLi4esiUIvshsGgdq4NjlssjusWK6/GC\n", - "guXeW4nOt9y8ecaqc3T9jBBrMuv1Ac5fc3LrBl3bcb0duNzuaUzhw9/yEgeHJ7z9lS/TDQ8o2XP+\n", - "eMCvRl76+Hdw69mPcbU9x/vM8e2Ws9MD2s0B5xeX1NxTs2WwRyAdvjsF72jMligThy++yMM/PCeb\n", - "x4y7rVoYt5eEMbA4WOvopqpDZXf+gCJCzJnVoqftOnWN5cQ021R3uyusF9YHN5HgmLYT1idSSXTW\n", - "0y/WWDNAmZT0Po+EUoogRu2BSaOYqcpisLXi502xKZVDJzgMe3Fkk9QcURMxOnIQvKxxzpCix/ke\n", - "7xK77agtcBj0MRJQu4Ih10gKATu3rwY7O+garNXCGeuEbxtyTjOQxkLRGbkYQwwR6wKYmRFh1IZc\n", - "a0Yo1JSQrIsakYRrdLRmnWoxU94CDlPXWNeSY9ZuMaFJmX03L5YMYj1iFT5uZgxkLxus25LLJTBS\n", - "1OxDSAHnwcqKWiGGogCcGpWKxHzbzrPppWgumYrq/38umj/+4z/OT//0TwPwUz/1U/zkT/4kv/Zr\n", - "v/Y1v/a9ON5/8WOtnTfoWa/IxmJMM5vwA9Zq6h3WzqFLHm86naFIA85i6grJlVx3FBEgUquhcUul\n", - "PjuLdZPawWrFiH7PnMBZg2+8puxVbaVTAcl+ZmpWHVybCERCKO+HUzm7JEwRbCTmQsxRs31CJJWi\n", - "Pvbq8Y1FJLHdbWmadhbPR20p5jYup0grG7xd422Pk451/xTDkNlPO6Tm2e/bAQNGkpKTcPP2XDeA\n", - "1ugiyljBiNWFTp6dV8XqwshZoo0qLZJWgckm6AbaZowpNFkYh8LyYM1ivWDV3uTQnTJdDVxtdzwJ\n", - "19Rhy7i9Zhqu2F0N3H76aZquo2B4/O4lj999xL38FhXP089+AyenJxyenUJNXA7XHIVDLt58AycL\n", - "Do6OwRoODk8Yc2bTb7i9OeH+w3dxVuUvB0enfM/f+wH+19/+B7QhUcdATi37sRDjRCpPONxsOOpb\n", - "jOtwfsnpc6cQoaaM+DXVOmhWWFGL7vnddxievMO7b9+ltwmXA5dPHrLslvjNCuMdxjX43lCqYYoj\n", - "fb/AWa8EoahMz8P1ijQGas2s12uOjs/YnJzSHB6Abagxk7ePmcIEUeVhecqUaWAqI63oZrmWqA6w\n", - "mHR05bRDMqniqtfDvC20thKz5To4aDydh33Ql9xKo6qJohCcVM3srMmkvFfCUoGUE1QN1CsykpNV\n", - "EnzJWlBQ+pFoQAHWRGqNtIueahLRWBgsMQmNW2BcYZwG7cAwlBowRlvjVDKlCGMcEGuxThF072mM\n", - "MQWLoRSZY208+KhxKJPDUNiPmvNkrcyLJDNnqKs7jllPgniqKKshhAnnM/tpoG+1jmAMgsfZFskt\n", - "xuiFQsShO0tl5FL9161//5+K5o0bN97/6x/7sR/jB37gBwC4c+cOb7311vv/7O7du9y5c+drfo/P\n", - "/eM3qRVSKTz1wiHPvniqEI85O8S5npJVY2ktONfg3FLnelUJPYYGpKGEgEiac350Xul9jzGC9wbj\n", - "G6wplDqR7Lxln617OWVyiSTUSeRqg/MK381moFpLiorGSjGTkm4TEV2ipAKIRlpQIcailBSXyEVb\n", - "IWcs03SN80IuFZlDnlKsOK9F3JoVtRpqHbVlMw2gkASZ2xVrPDGN81zGUYujSsYaQ6lxPvk1SraW\n", - "qENzdHhvRJcDuWj2UZ3lSrlEKhNIZtGsOexucvr8HeLQIKFnex6ZhndZ9g0GtaTWdkUuHmkOufW0\n", - "5+LinDe/9Ab73QXtwnF4+BQf/eC/wWp9xPVuz8PHjxjjE1YHa77xQ99MHPfce/iQTX/E4+2W7sGC\n", - "WoVu1fL2vXcxxnHj7AbX045xu2WzOebkzvP87b/793n5s58hJE9ZnnL81B3cBm4cHrJZLDHec/7o\n", - "ios3H2C7Hu8cTbfm8LShXy+xNVGNxTcd6/URnD/i6GTNW19+nX7V4w9vsQ8DZRppqeQpEKdJRxC+\n", - "YbvdUYoWx265pm87ckos+p6LS4UQu25JuzwhWdF5bs74/oAigWQm0u4aMZaQi3ZEVrshXcyAGKFx\n", - "DbUUMELrhBQqYy6klJFSaMTSySG1joQ8gBkoVZ041rYgfoZXN0C/ZgpTAAAgAElEQVRPrU6f8zxh\n", - "rGbYl3ylMr3iKRSyUR4BFWTUILWVayg5YN1E4zMljJjOcdgvCM4x7D0pZKztsPaQGJ+Q8ohIIZdM\n", - "KhFqQy5CrIkaGjwJYytNM8dSe0cMy5leNsfVWIupomyErP77lNQs0EkD0VKsxo4IhlQmSt2T614V\n", - "E1ZZm3lWRUzhCmpLpdP8I2kwTuO8pS5IKfD6K+e89eql3lL/VbTn77zzDrdv3wbgd37nd3jppZcA\n", - "+MEf/EF++Id/mE996lPcu3eP1157jW/91m/9mt/j3/73v4mSLcXO5vqU5jmhQ2hwVsiibWlMSUXa\n", - "1QCt+k6LI5WCE0vI+u9b22Do1IZFo6mRjSeXHV1vqDkxEkGqnlJJiKkorTwXXGmg7xDrtOA2hTJp\n", - "BnhKkZQLuQamXBTDZpMSocVQUO0mYhlDJKSIiQXn3ay3TDTGULLKqaYIJWsfcV0u6PsVy/6UGHVT\n", - "aXH0fkkpdT5FC7mIbrxLmhdeWbfr8wbdSEVqwdmebMCZTOM6hrgn1R25Nljmr6/Ky6ypIibxkQ+/\n", - "hPWW+++8zZdff4XjzS18OWLhT1m2h5hs6FxiGAeSeI5vHZND4atv/CmXjx7gTOVbv+M7uXX7w7zz\n", - "zlf5Pz7zP/L4yQNOb93k3/t7/yG2P+Ltu2/xv/zP/4iTm2f87Y+9RO8UwzeNE+MYWB+uMMayu97x\n", - "R3/4RxwfH2Oq4dE7j7nc7tlsTnBHN3HrAxY3bmAWHuMNi/6IkkaGYSCFhHGVcfeY1K7Adjx5/ISQ\n", - "LKuasZ3HtC3d8U18SSQbwXekNFFCIFahwRCmHVUycRjJYSKHiHcObx0xRMKoSyAaj3HCwWbNen1K\n", - "vzmgmozPLRJH0sUjdtdXpLDHOEPI0DUdp7efZ7jest8/JoWB1aLDWIMJ6EHpHCYF4n5AaqUzKp0x\n", - "xutMtQoRyxBVZ1tzJadJl57WIuqkwJSG3h0Spy2IJrkaosbCFKEkQ1YzsxobrCXs37MROtYH2pF4\n", - "V0gZSjaKL2w6pLYkFwnRYUxHKZDynpIdvtHn2xqdMUIllqQ/R++UkWsV2+adI9UIWCV/Va85WFY7\n", - "z6XrVQsctuR8Tb8y1AnaWikUxEKOI5hKiAlXHdU1eL8ghsxuesyyb+etv1f6mVOQdywJsYYXPnLE\n", - "cx8+QKowhC3/9H9462vWrf9XRfMTn/gEn/3sZ3n06BHPPPMMP/uzP8tnPvMZPv/5zyMivPDCC/zK\n", - "r/wKAB/5yEf4oR/6IT7ykY/gnOOXf/mX/8L2vMgcipSTesffw9I7BeVConEdORmkRkqqiPuz+SEG\n", - "lRsUwDjEZ1KqWNOQq0EsGiJmCkjA+kh1FY/mm9TsEAc1CTm1GjcqC1JQ6Ib3YEW0fS8wBdVUZqNy\n", - "hZgHyBVvq1ows84PU1BtJKIRHW1u8M08O6oVisbLhqjxqCkZELi8ejzHbLznoAFXe4SemPbEFEgV\n", - "clVBv3W6jSxzWqcK2i0UQ5oSJcssU6q0zZKuB3GaLe3m2zaSuPnUs3hOePfuu2SuEWs4O7kFucEY\n", - "mPKWkgJtWugJbVsOT3qur7ZcPH7EnTsv8JFveYm7b36Jr7z+FV794hd58OQRd24/w3f/O/8uu/0V\n", - "/+Sz/5TqLN572u6YF198kTdef5M7d55mHCecbbHWE6fEOG6ZJpVJxRC4utpzujnA24Htbou4hoPN\n", - "AY/P90z5Psv+CTfONrQu4UzFeej7jpOTm7SLNdV1rFanGNPpIq0IaT9Q6khdLlie3eHZzSnj9RXD\n", - "9SXjuGcct6zmm0owHaNcEseRadKQvkW7YBq2pDDSL1YU69gcbug2HTXuyUPBNAM5QWk6+o0hx54Y\n", - "RmydSNOOy7CjGEO3OqJpn4IcidMOjCPnqEaDKrRNgxTLEAdKyowpgTesxBOqILXDDpkxXjDFJ4xD\n", - "ZLV4RouuiUryMSsOl08zxUsqo8qCbCCTSLEyxVEXN2gGFrVh3KksTySyMUvw4FwkxURI+3kZOy9x\n", - "65JMT24qIYAQSHFAjM5HmRUvalLR/QWS0YztoiYXo4QjY4TO95QIgiHUSs1C4zqkVqZ4xeXlfayD\n", - "fqnvqpgAkqi54F0z15AeZ1qa3lFYoFJ5g7hCpcWZTsHNTdSkBCI5q/ba/SVV8S8tmr/5m7/5L/29\n", - "T37yk3/h13/605/m05/+9F/2bYmlYpyGlcU0v/RZaSapZhppMM6xWDjGFEghKKjABYpzGKObOKmG\n", - "mqxawqrOZJxfKonHWdVyWYc1hmyCYuQmIU5A1gF7qoacHGGyODQxrzoza9EADM6uqLVqtojrSbkh\n", - "1nN1Jc3a0VqKbuxKVsmFE1KpaOx5hFgBSwwZZmiBtyr83Q9bUglslgsMjW7NrcXiqWVFyjvCNFBw\n", - "iNtTUNKRcVlvAKUSo2K6StGM8YrON7vG03pH1zvE7hjGa5aLDacnL/LmW6+T6+ucrI+QamjoFb5Q\n", - "ITPhbYtNPUaWNNbRNR3biz3Wej70Td/MeL3j5Ve+QOcMfdfx4OKa7/7u78G1K/7P//2zxLjj1s2n\n", - "GYqwWJzxw//xJ/iHv/UP+Q/+o7/P7/9ff8hzT9/h6upaSThiSSkSQqDrOq6vr2lcwzaO7Ic9YRh5\n", - "67WvIN/wHIfPnCHeEXPmajeR88CN40Me3H+A9x0HRx7rJ+7cfkZZpCXAJNjFzLdKUJuO9vgU2e51\n", - "E2w8hkfE7SXTtKdQcVI5ONpALJQc5meqkFNlCnqYnR2fIdXQr49w/ZI0RcZxS9uv8G0PNTKeP2bY\n", - "bRl3V0jNNK3DiiOnSIgjWI/3K4pMLG0l5UoIIyEZhW+UTK2FphqmkiEbGtPT5USolTjt2A2JWi5w\n", - "5gDX9+/bcL1dUoP63UuN1NqyD+eITIhMM6NSI3Bz0flmKY5hp++HlBYrmb53FPTZLjlhaHS2Xg2m\n", - "dLTmlFXbMsaH5CqUule1B0LfeyIoC1Z0ZiuE+R0TBcjkQJGJUrdYv0RqZWF7alpQyTR+iY0dU3lI\n", - "SFt2+y2+KRgbEWOwRm2/zneA0o8QMKihxXghpkmBOkbf1ThumR0gmmprdIn69T5/fY6gbCgygTQz\n", - "8NSSqTTV4n3LNAVaa2jcir4tXG4fkSUgU5mlB41uHnMC9AdQcsa4oNxNsYzDiPMC1ulySToKAeej\n", - "UtCz/rKcF6YxE2Mh2Y4YIxjNQwHVvJms1rOUIq1vlTifVSjvnCFRkFyBMoOOtYDlEqBYEL0RxhjI\n", - "sRCniHWGtikgSn6JEhhMZdEssEbHECnOA/PiKWlkShHxgabNiFFRu2TVfOZcGadA0/zZdtM3LV4E\n", - "ZwYaByI9d57/Zu69fY+vfPWPqUUwsmLcQ99lSh4JZYtzKxwdhkRM51AHSlpTa+Xm7UN22z1fffNN\n", - "JBuevfUcFxfnLI6f4sN/69v4/B98jjhds1lYmsVtrvaBb/nYt/Hxj38b/+V/8TP8Z//pT/Bf/4P/\n", - "hm//ju/k1Ve/hFA5O7vJbruj6zpqrTx++Ihpmtjt9ioFipk4BA6Ojhl2E/HeWzz97B265YIQlOCe\n", - "MRyenOHbJbVaFosNF5dbQqpgLSdnB8RBA+TEClbAJGidw5wcY8eBtm+RWhkuH9BZy7Db0TjPjds9\n", - "1xdPiGEkpYiVwmrhNUveGbp2Qc0CpsUedjAtVYQ97tmdPyHur4lBpW2N8aQQKTON3wZlH9RuQSmV\n", - "UHSTLUZwXU+I4LKng3mmLjqvNJ79NJHjBTV7pqnHSmHYD3Re7YZ91+ozbB1hnB11pcFWxaxZVzEp\n", - "46rSqqCS0pZaW0qx+MYTbeHySdQZek2EMJIHi6kTzjQYY7TdnaCxPTUdkmwhSyHViJVWDRadJ6Wi\n", - "IXwqpHx/UWWtxmbkvCWRcK2nMQdI7WgWPYIlhKDQ8nSEMiYs5J3alSnMvkCcPaDooBhrdQyQUyZE\n", - "3WVQCqkGQkiMYSKFLaVWXGPUVPCvSnL0V/3EkAjTiJvjGnIqhJqQMeNNi/MNVcA1SxZFmEJhzBfs\n", - "pi3WRxq7whg/pz0mck6UbAgM1HpB9Su8OIzpwSpk2MSilBMTSJIR4/QWmg3eiQq6KeyHPb0bITYq\n", - "LaoTvuk059k1FCrGFHzV+AJbzfxjLv9cu/xeXLBF5ozolLOCC8bAOBS865CaMWbS7BVvmaaEYWTR\n", - "GMQKxjRYBx5Dmx1TZn7QoFSwaJ5QxpCLbktJSrfPuSLGzeR5jxg4Ojzi0ePXCGGHtR0xGYpkprRD\n", - "ksG6hIREi6Pxa8R6nGuoudL3K45Wxzx6cI/d9YC3DYt2yZQTdz7wQbZXF7z8xy/T9Au805z4YYQP\n", - "ffgFnrn9AX7lV/4r/pP//Mf5zP/2Wb773/wuXv3Sq2w2a8ZhQIxmT5ch8cbrX+XR/UecnpxinMfk\n", - "Qq2Zg4M17vSMkBLjbse7b7/D4eaQk9MDrFjeuX/F0dGGzvQcbNa0y56K0K06uq5lNw50bUsOgabt\n", - "mcaBEAM5BFLcUYYtIcPqqedYnN7m4s1XGcdHnD95GxPBt7phjiFQbWbReY4Pb3P7+Q/DZoOzjuni\n", - "MTlc0EjLlDP7ccRkQxj25BQZ91uysbTeYrzRXJ9mgTiPEXBujlV2lpgScRqQFOhqxSBEgUollUDK\n", - "E7lGTA7kvJs5sC0lwn63xVqPkYauW1Cyw9kFOQ+kkIkBqjXkojALg1DS7PgRg9CQkyWFJc1yiacy\n", - "bHcKxk6BEAakXNJ6S9ecaLyGabEkvPWk7Ei1YJ06gxrjKEYPd71ZJvLM6FRaewVUG13rRIxbjFuz\n", - "Xh2wENW7jrKnZqWB7YbCNE2IK7iawaV5plkwztN3R/pnWYHaIpKodZiXXwZhAvSgiOqzxiSVfRlr\n", - "v27t+usrmiUyjiNtSTTek0tmCDtSzIjNLBdHONtpzo/vWC832LFwNV2TUsDUESNxFr4Gcs7EGDUT\n", - "GWGfEr3vMTYjOKwpeJkzU7zHWkimYm2msUJpHWY+bXOZaHKkOnUNWDMvWholqk/TqCOB2a6prUhB\n", - "yTCGnCI5B1LqcdbTti2lTKScybXMG+1CzoaUMzU7oq2UKdFgKJyrUNc26lX3lloNrfMsuzW7MBHT\n", - "VmlKUjRUSixFmBcCajfNRU/YvtlQSsuN0zPOn9wF+5i2OSCMnpIHjEtghXGaMCVi8h5rWqbc4Rdr\n", - "4li4cfQ8ve/5kz/9v7l5csZ6fUzXrrj31bf5pg9/I6+9/iW8t6yOj5CSkXrAoycP+ZaX/g7eH/Df\n", - "/fe/yd/9vn+L3/nt3+a5Zz/A5/7g9/nGb/wQr7zyxXnG+VVCCIQQuLq65GCjMN/N5pCcEturK6RU\n", - "uuWas9WCxw8ekuLEw0cPuLw+5/T0iNMbZ+yCoV16Lq52iLUa5RA9uSRWBxv2+z2b9SExRFzXcbHb\n", - "UcdL7t9/h+ODNY3AG1/8PDHD3/m27+H83Xe4eueLnJ/fI11fQplYrU91+WcdpUSeXL3DwapB/A3a\n", - "BUAi7LfUkDhoWmKBq8d79rtLdcE5S0Xm5aVlGAZsm+maDubBijGWFEdqyph5dj2OW6Y8gZup/Bly\n", - "mHAZGlEHulRhypk07Fl2C/bD1fsCb+sqOVtisgyhII0+j84pyMK5TIoTxmgIXLvo53QFo4J3YzFS\n", - "2E/3lXNZLLV6apm100kLaqma1aU3Ce2GfNO+L7w3tkKNeN+r7ZmsSapSFa5dKk3TUstECFes+mPl\n", - "JFhd+jhf8dkwDjJv3IWUIyYXXFfYDXexLuHsmpiEPMdo5+TJcUnbWmU3lEDXGZxtKNkwTbrYDePf\n", - "0GC1qVyDKeQ6ErNHxFIZGdOAnzKr5SHOepyt2OrJ3qggPHliHLFmIr0XOlaqRlcUodSorbLRdMqU\n", - "LVAwrqG6pNnec0vPHMokBhonSIvaIst7zoyBRkPGtSUznnGaCCniHag4VnN+SBZKpWajPmURaq4U\n", - "KmlSx4/MWlFrLN5rzChZZkBJYdpPVNyMk1Oh/LI5wpleTz9vSaWlNGumEig5YlwFU6FWpBiqVIyp\n", - "1Fmom9LAdl947rlnefvRG1h2UNfEIroYSoYqhSkN5DzRsMTnlkkCrrnk4vGWF5/+19hdXbCLV5yc\n", - "HENtmabI44d3ufXUU7z8z15muV5QK3T9gtZ1XFxc8tI3/+vEEHn5C5/l27/zW7n/8DE3zm6SU+aD\n", - "H/wgX/zin/Dss89y9+5d2lZVCKvVCu8skirGZEoZOTo80JgFI7RNT6Vy+/YJVMPl9SVXF1ecn1/g\n", - "ugWb444QE32ni5zlYgFU+r7Hzo1XihN2sSCnyNFiwa4OrPsFD+6/RdjuONtsuLx4zD/5n/5bbjz1\n", - "FL6D06eeY7g8Z395TuM965MbHB6esD68oQsnMileUfFE14GfGK63jPsd18MexLJaHjAN16qysGa2\n", - "A8d5vqejHZm35KUW+kVHLiqvm8aBputY5ol9HNmWwqGz7GImEVnWSmggYohVw/rGcYvIUpkHBUQs\n", - "MUWG8Zox7hC2tF1WCdqcJeVQqVzruzkmV0h1UoC3/vRm91zB2EAM19QSadwRpQqBnapMZMJaNY/k\n", - "EjDFYEw/R1+XOVl2whqoRa2kahax6ihLic57pjFwUe+x6I8pEsEkMgmxMrflnpQCY87UMtKIp6Vw\n", - "ffkO3j/COqvx1tki9YCaOu0ygVwTMQ/EGGdjiiNGKPFv6E2TrPDdnLK6dSx0nWcaEyFOxHLNwqxZ\n", - "NGcEM5CLpfEL7ORJcUtyI8Z4YswouF6jbpGqyXw1YcqIsR6pBZ8d2WScq+SsLoycDGAVBlDnM74k\n", - "jAipVqQkBZnalpwrw7BlioFiMsVokdKMZIOVBc4bTAbJjlwi3gtQsEXtcM5aUlG8mjbWKlMSGrpm\n", - "llmFcbZ/JShVXTOdwxl1LZkUqVkfrpLVe2uZ/we8JUwqSUIEyYa0h8PTY9746p+yPBgxlHnjuJqh\n", - "KYUsdXYyaeZOqZ4k1+z3hg/c/jj7/Y4ahb5Zs9+NeoueLM8/8wyvfenLrJYLhv2OzcEhi37Fdrfl\n", - "2eeeo1a4/85dTk5usOg3vPbaGzz3zHNA4Qv/7GWevnOHR48eaWyyMSz7Fftxh9TKwcGGtm2pAuOw\n", - "pXVC03gODtbst9c69jCew5M7PHzQcvXkknHcsswrqJ6+W9I0DavVipwTMSg9q+97Lq4uOHAG41qe\n", - "7C6RGJUcHo9ADE/Oz+lax7O3Trm8eEBtW+g8x2c3uXHnWcIQOD48YLM+wK6PMAfHlKEgjOzTRLs+\n", - "Y3d3R9pPbC8fkqo6srx1WLGUnCmmQPmzMMGma2dhesEaozKckqhZC4hm2SuN3GZoMiQRjmeaUBTh\n", - "yiVSjTQoKWiaRkIccLadZ/4z19UaTGGW2k10Tm3MRipZQEqmMlLZk0ulaRZshx3rZTN3UKoTLlVB\n", - "Gjls2UehWkcou7mbmt5HKBZJ1JIVeGJ7PeDJOKOHRapBUw1MS6094oLO/8OEAa53T8jZqgqFHanu\n", - "dHmGKlVymRe5sUFqxVLIdk9KQuN7jHOIqCQql4EyKjFMjCGXSEwDIKRkoQo1t1+3dP01RviaeQ7S\n", - "KKKJSOs7pCyZpoHtOHKwajGuxVGxblLXkBVSEUJIWFtBVBDsrCOZjFRtGWKcEDNSR1FakCt0uRJT\n", - "wMyc1VLyvEEUbYExpAQlZ2pW8lE2GtAmaOpiipHqC756jNGtvJEFIk4hqbbBeI+RhHOVkPbEnBQt\n", - "VrRtLwXiBN50c/FToXrjlpi2ZUwDMURGChd5i0jLctHiOvXimwIkBSqn6LDOg2hL5LzeXlLOTIPn\n", - "Q89/lIeP32KzPsSWazADtVQsFRFN4as1YlymJH0kjLVIgeeeeZHHF/eRMLGuZ7iiAWteOk6P7vDG\n", - "V17n5umZio77BdUIpcLpjTO22z3GgnUNH3vp4/zjz/wjPvyhb+T8/AnWF87Ojjh/8gjB0nXKDh3G\n", - "HcO4Q1JkHK8IQfM5bhydslouefLkCSenx5yeHXF9ecli4agi3Lp5yGbdIc5iuobVao1vGpbLJdaq\n", - "1CnnTAiBtmlZbw6o0x6RzOlzL/LojS/QWsvh+gM8fniPrvWMwxUYy53100zTiPctzjiadsPJnZsI\n", - "hdy2uNWhFrrGEEbP6mBDyBPrm8+zDEBJXFzen2d9FeySXMZ55q2diogwjRpYJyIU+54CQsEsJRUQ\n", - "S6lFlyZiaEUo1tOkQtpFsjP0qwMIV4SUMaaS9iMhTCwXB4AlxEiuI0imbR1RHE2j89Guaahp0pC/\n", - "monhgiJWOZXFYnCEKeC9YQrTLMszOBOgRGIKZFpiyGT03ZOis1GRoss3FC9XSsJURwoyRz7vKGlC\n", - "TMWagtARoyOlMPNfJ652d/HhPUyiBriJcdQYiThSEVrnkVygeFKdKKZipSWWALMOVYojlUCpCesK\n", - "lIyYNM//PWHc4+RvaEZQygPWtojxWHFAIcWCwWKko5YFpQqZCUQzTTRgScXoZHW3eN9oVKlRkWxO\n", - "7/nCYRyjwoSqo+yBRnBZ/d4xJmqpqiEzBUyedZuaUEmGUova10WF4GIgprmY+qQRoq6j5E7BHKK8\n", - "zda2GKcLJOfNvL1PupSxLcU6ohUEjzcLGtvSOE/jIeRA53pijcSQcWLYb/e0jcE0dt6oW8Y556Wm\n", - "hjKT76sxQAAKYaqcnT7H/XffxjaBxi0QseRiqSYhcxiW85USVf1qrCK0ah443HyA7W7HdvcWB+55\n", - "akmkOCI4bp09y8NHjzg9OSGmeZBuhOVmw9XVBSKWRb/g3r03uXXrDn/0x3/A8y88z+XlltPTGzx4\n", - "cE+p9zljrTCMe7xvFAdWBWsqzgklRxrXYGaKlKGw357jDg9ZrRfUkvGNY7064OD4kLZfINbRtgsW\n", - "iwVd24ERmn6hpgmjywZrPbUBKRH2W47ufIAHb75C3T5hc/MWw2WDua6EZHCupV2fUtLI4vAUsiEN\n", - "I4uT27THx6TthLhMjpPCda+22q3gKd2SxcGxAnfHa6ZYKPmarms0d9xYpVNZR9M2egAblbqJiOIE\n", - "Q8F6LSDGGozRg6LWwhgnplKYxFKrw7mGRWtpmqK5QK4S4kBMHdBQyUxhwHswNapzJyWaRjFtSmjT\n", - "Amd9VdK/tUxBLyPjvtIvFH6d0h7nEoUM3s2Yt5E4WZIMNK2mBxhTVLeZBExHqRNWhDpbPWtOqtU2\n", - "EVOVzCTFkoIup8I0qYun0bGadQYMiOkQM5JKUbaCabAuYUwmx4TxLbZWUkiMMWJNpvUVI3OBbCwp\n", - "R1KNs+e/zHlaUMr+69auv772vCZS7sBA5xtsFUKs1GKhqHDdmlZBGCXjnNJ93nMPCS3VFQwJsLPM\n", - "x82g3YSxnpwLY5gwNlOLV1hxVp5aLUp+0ZO9Yo3CE4ypuuWOCduo9KMQlQotAjMcQzX7HlNaqB7v\n", - "LUUqJe6wzilphULXtGAt++lKmZvGaaywEUqGxnm8bVl2a7rWM8UdU4o0pmFXB8JUaAlM4zWtXSkd\n", - "vG/ZB8MYKiU2GmIlBicNzlViyNw4O2F7caXpgbaB4mjajlAKyE7J5+8jtBrILY3bYMQxDomD9YZ3\n", - "732VVb+BFJgkkPMa7AGPLh9TpXJ5dUFIyg04OT3j6uqKp59+hkcPLxmnLauVjgCaxlJroW09T548\n", - "nscPlff0raoxDVTn8NbjDHRtw/XVSLaW/bDn8KCja73696vaOa+udtw6WrFYHFMEuuUK27T0i15F\n", - "1IAY8G2H9w0pjzSLjriLtIs1aRwo4xYxS25+4KNs33qVOI3cfP5DPL7b0qYBI57FcoWjoS48aZ9o\n", - "xOCmQLm6wm6OKTkzXu4pV/dZmEx69JBtrSzXR0zDgDE6R+X/Ye7NlW1J0zLN55/dfQ17n32miCQg\n", - "s4ukDVrowgwBRASSG0DAUEBDROQWSCQMLgBk0OAOUFpAwdq6O7FKoMkhpjPsca3l7v/cwufnVFV3\n", - "VQqUtWW62bYIizixYw/uv3/D+z5v1zhnWNeIsQYTmtzjenvRd3HRhBBEC9nZjBOdnGXkYrRDaUta\n", - "nphTpGnPYdhJHO5gWZJYIbtRuNWQk2VeT9D9ds+KesPRKFo4Ca3KLDU3SX5sTaMZaF2itoUvq2gt\n", - "c1kru92IcYXaTjgnBY+2jTqLz7wiJDBrO62tKG2ofaW1E96MgIauaaWQcyVRML6gmhzmtIzuEymD\n", - "JK9a6F46w54Fa7hNYbGGXkT/2VWXOOLSpaBQss+Iq4Je6H7BDxJG2FKhfUjcrJ1WNIogyy31MzrT\n", - "bBvqTXVFjhqtPYpCqVWsV6nTcqVuqYuyUXMYNciNg6c3yFFKcKUyylqWRbblWoEJltI1ikqtmbhK\n", - "lk9JbWuL5O2OUpIE3iHnCCB6RzdAkSiCtiG7lO503clFMziPUpJzYqwn94w1Ha0LxjlqCyhdBEpg\n", - "FLordJUMdmsVpWu6FvJ5SR2722HtDrWcRRxtoaGovZETOCcthTWGYZjIbaZWsPVIo1BVRgH7/RXn\n", - "+cycCzv/EmcCtI7WAa+vyF0R88Jgd9TWJPXFBLx9jlaBX/z5l3z+w39hMoGaKr2dUfWKYbrmG598\n", - "k68/f0OZV7qWyInr6xsen554/vIF3//+P/Pi+Svubu/55V/+Ff71X/+VX/qlX+KLL77g6uqKGFcR\n", - "HOsPQmdFSkkywjuEwaM6nE4nhmHk6fTENE6s64W0rLw8TtRaxZpqBLJ82DesGxiHEesDKSamacI5\n", - "R6kF6x1ohTEO2oAZO117TAi0oKhLwWXN/tU36U93XO4fufrGLxMvt9S4+f9DwAwHFBk7OXGAXRa8\n", - "uUfvj+xfvCRbg56fCFeK+ct/4uuv/o3p+jmPj3d46+RB3iRp1li0spRc0ErjtNogNop1XaUwUBIs\n", - "2BVoNdHxLGmGXrk+7FF5x12qtH5mbZDTTK+Sj6V6YZomtAqcTpF1jZSaBeirNXGJmMFQomzhhQon\n", - "M3rNjpREwtc7Qh0qAoQhN6xZGLXfOq8L2ngheqlGzI3aJZxMdSf604o4cVqm1PMm+2lbThiAIkWH\n", - "cQ3NIvdq06QkdDBjhMerlNsWNtszvum7lb6IDhrp3owR+/AbxAAAACAASURBVHWvAtxOuYg7q1XW\n", - "MqNtwdoslXU1lGLpzVFLxRoveUI/4fqpHZp+2AnduUHJjaajBJRtwnA5SCJzF/pJ2fBmwe+oXMki\n", - "pxvZVHvxoIPB2RG1zYOs8wQcqFXmOUXkFtrtKC1vURqajuQ61y7SnlIaOVfOc2S/G2TOojpm433S\n", - "pVItLuOdxikv0onuWOKZ1i5MUwOdgYIEQDVJ3WsrdIv3AarYR60bKdmS5sJuvyPYRjaR0mQTXkpk\n", - "XTXeR6CjlRV3jpM3sO576CsKodeHwfJ4XnHO01VGmRFl7AaI8Oi6hy62UWc/6FjLlkJ5zeUpMgwT\n", - "1BGfO0EPOG7Y2WfcvbkjXy5oFKV0xmnk9HRiHCd6E6dHCIFp2vHu3TumaSLGyDAMzPMsdjpjhWfa\n", - "t5ZIa4knbmKpM9oTnCHGlWEnkN+YVnqTQC4Gxel8wRhFro1GYwgB50Xb+2Gx1HrDh4FaZcxhg6Om\n", - "hvaetm2Te9cYP9DWSB8CanrJLs3M64ndzWfky4kWn1hrweeIP1yRY0aHgJue0R8+h3c/og0HejpT\n", - "0z3r03v8/gbTFKf7222LLCaJRscZs7045FBkMz2AYAx7b4I+0x9iXRrSTWn2g8jg1iR4udorFcNd\n", - "bbSSQXcqmVoiRg9Mg4OaKOmBGCtLWrFGqEWmNmzQ+CAVGXTK5k8vRdGKEeZml46sYzBaM8+yXFIK\n", - "DFXmpOww2tFLISZFKxYVBkxQqCwyI6UaKS0SZ6GEHlWoEmWhBzoC/daA6uJb781RUsEZxRB2tB5F\n", - "Ytg6ujesK3QlBQTNCpRZO4FwN9GE9mYpBVFjULEqg4o4ZSjZkbOmpUZXmpYLdvgZrTQHfy0WyOwo\n", - "KFqPeOPQxrCmyBwv3J9umYYj0KXKo1ArKDWBmjddl7Tv3QaqlhmXqp3et4fTGIFxaKEP9cK2HVOA\n", - "EKJbU9sDJDeGNQH6hbgW9vuOG/Q2MO7krIix0bUixogzCWf3eOvQ2rDbR5Y509uKdaLZbVU4oSkn\n", - "eVEgeUcuKHEfYaA7atEiLfEGHQ0oRUVuonVNKLsyDQO78cBoNc1pqvZYHEp3Yl1xRnOJD0yjJUdP\n", - "K4VuMqUqbHc4rTFtxFkwBHTb4d0gVVksHMOOy9OZgz3SVJMOIBse5hPXV6+5e7zDKYGlDMOIQuGd\n", - "YxwG3r95SxhHvn7zJS9evODh4Y6XL19zf/+Ic4ac8ybR2iJHtmiTEAK5iK+70+jaUir43Z7eKrU1\n", - "NIpxN1FqZZ4XEf47jzKB1BqmV1IpDONI2WQ8y7Kg0HKYaygRsHqbl1W6CqjuZAY5WEzLtGGCDr4/\n", - "kk7vsYcrWl6xqXJ+/46bb+ywuwnSSp9n7KtvMv/433DvvxT4SF55eHrPQOHF8xvm+T09RpQL4hLb\n", - "wgFr6+Q1Mg4GoyzeSpT0B8j1sqx4v8G5FYCSw1MV0TJjMaax844lZ56Ne0qurOXCmmZCcGizE5vj\n", - "YNFHg+meLx++IFKElFY7YevKaq7kmqQj0pnWRDrnnYwP6GKfrE0zhhsRoVdIpQsQGLEGD25giYW4\n", - "yjxTbMgdnTb+ZWvbjsCgrZDFvDV4Z2isxHihtYzqBZA5bvCBcdhht0iX3gxWw5wixhQqQgRbo8w2\n", - "U0bAHKiNd2vRulFrxgfRoxqzjRyylo8mlXHpmVx/RoPVDJ5gDmgr8bOlLJS0bjnnlkzhfLkXa6SW\n", - "qE6lNVa5LREvMPmA1ppS1y0ULWP1jGk7ehW3g9YWp8IWwCRZLKAwymHUxs3rRqjtqm5JjVKtSFUp\n", - "6C5rJZxsqEbiR0uh5UYunao0zhq8t7Q+SDVZJXWwdkPOiVaykJJKlcTLFElRlk1392959dwyL9Ji\n", - "lGaxdkRl2R5qFDFLtrgzA9UZhvAcEwaWdKavHW0c2npifmQYnLTqXaHsHoPCWaFYm+oxRuOqpleL\n", - "cTvAcnV8xXxeOJ9OKBI1GxSNuD6h88Cr5z+HKo79eKCuM2prgWrrxLTgvRx8g9lJfksVa2PvneO2\n", - "ICqlbGF5cttp7bYqSmaYzmvJvbcOY6VNMgZoFacNgx+2vCiDHwd8mBj2V3Q8rXUenx4BmRvO84zS\n", - "ipQiznviUjHe4ZTjclkIVtFVx45OmKR1E4H1SLcKFTVNr8S7hJ5uaJcTo3W8/+G/8uyTz6RdX26J\n", - "vRBePKf+4McYgO45fOOXePt//m88vPkRLz77D8RZtIDaGMmX6h3nPGGaCEHGCKlmgfkag9EWPzr8\n", - "9r0C1JIxppGy8FNjSlIEKC2Fxnrm8fw1l5pAG5TzaGeFgNQUjoCzEiq3JOEjYDU5Su66OHGCaBiV\n", - "sD2tVXS1opQjZzAmiPssy8Go9wGlB1pdSB9g3KajjYjVY0qYZlBNQdViR9ZCendWGJqqK1T7z+kB\n", - "tQticc0XtG5Y17m6eo1zA7VsYyozoLTicr5I4eQTJSlS7SyXLM/MpuQAaF1jtMI6hTENpbYqtgac\n", - "OdKLoSB2Za0lhO0nXT+1Q9OpPaYZtAk4N5BxzLVTW0aj8S6wxJU1nTFesQs7DAeUdgz+CGklaIcP\n", - "GnTeAqFWrE54HajFoaISnJIWR4XzGt0967yKda1rdGvycGpopQq0wDS0lQNatQ2nZbbMEe+wRpGy\n", - "Yl0TzhfWPuO8wdFxrjMER1qlUmTTZNLlZumqySKqI5lGrXE5X1j2F1Qw9BYoOVNNZxpGYlwJYUTF\n", - "zGVRlLyjIVCC4Ce8c5yLAGC1dfQu0QnBj2QMrUhOumhNxbERgsfoAaUHvN2DgnXtWBfI/kRaErZp\n", - "VK2YlnFqx9AmYpzJdUVr0EozrwnrPNdXVzydTgzTtOU0qY9SH2OkwvwA1wUIIXC5XND6gzlAMQyB\n", - "TsVaK2OYMCBZ9wpUZxwG7BYlEfwgIW7DhDKe1BoqJva7A5fLiePxKG1u65QqyYveWWiOukS8NeT5\n", - "gp08ywK+5S0pUkGXl/MyZ3pMrOnCZB3T1TPq0z0vvvENyuUkP7PcCfmO0s7oZ695/Ofvoawldc3u\n", - "k5/n4cf/F+fLLdevXvD27VtqlReGdyKxqimTlHjZldabg8nLyEgrwiBZ6jFK0FeMK7VVtLWMNnBO\n", - "kXldeZjPrCWjTGAwikstzPPC3h7FnUijI1tmo7SMl/qm70UOwdYzyjSqACkJZuMo0FG1MbgBqyUX\n", - "vRdDKZr728TVcRIYNkUqxNZxWuawpUpFV0qDnnCILrX3iDMNYw3oSm0rusmIqNVVKkDElaONQemM\n", - "s0estqIGSBIVrIxke3kDuED1nRihlLqlvYo0ySiZaTsnWVdKO5Qa2U0vyGaQxaI21CpuQO1+Rmea\n", - "kk1TofdN+DvhfWNNT+KdNhbvR56Wd7QS8UZt9HPwbsSbidzWTfsFzg60okS64B5BDbQaKLFTtAhs\n", - "a9XC9nNQKDg1UreHxRtDaxlvLao5isloFN5orO6iXELhtPxdR0Lq1+XCeB1o3dFaANWxQZOrge1r\n", - "s8pRlMAEjJYb1XoHraKLcAPn+ZGbqyNaiW6y5YK2kjSosRwOB5ENaYPVO4awxxiLVp2zuqepRFwi\n", - "KkTZK5pRkhNVp7VOR6RVrWdSrih2eDOizIDVgbwmrG1sCmBUy9hoUHqgl443UHLlMI3E1GTUgMSs\n", - "Pj4+YKwlx4Q10qpba7m7u+Pq6or7+/tNXiRV04dq80Ni6DhOrOuCUshh2TshDKSUtj8HtSn5mRlL\n", - "VYq4JmrjowbTasPlcmEcR5ZlYRwlCbM2eeiXMjOZgU6j5UaKhbXeY4Zn1HVBlRk3TvQMl/nEOO2p\n", - "rGgF8f6O6Rf+Fx7fvWF8e8f0/IrqwexeU8pKffsVJhb218+5/fF/4urFS+IYKDevWc5PtKoJw7At\n", - "sDYiVu8EL9G7wcsipSGc0941Tlvymj62s9YY3OFI7o35MpNSpG0pjmG346palqfKaX3LEmfS2jFq\n", - "QuuBVC4ilLcJ6zp7Y+lNwYevpXaMlTmgNisKAfH2DrZ7yT1SAaqHaqjZU3OlVsNJty0tcoPGoDG6\n", - "C1bRCFXJmwFtG0rLi1ObSiqPBBPoutMpxGRoFEHf1YZSWaJtbKerFW36xh4SF19vRbSuVlIWgtUk\n", - "J+T7WjspCsy406FLuF+viao6VlmG6RlKTRgUe/bkbOmtkcojVSV+0vVTOzTnfMtgrtC9ojbCiTay\n", - "6OlV0uEmt8d5x93Tl6QU8fpMV54YFVO4olQoKeOHQK1P8mYhSQSu3WEHCTYrZZD5YK2gIygJs+pd\n", - "5BklNoqRXObRB1RqLMwYZSQqootz6YMsROkuVBVTqIjrInjJk9EKEd8a+eUaJzeSUoa9tvQy05um\n", - "akOqCJCiG3qT4Ks+jiKf8ZZUErvdDaqPeD9ymDQlCxLO6B3GgGEH1jEvd0DDtSQRAz0RwohWipY2\n", - "ao6pgCGuBWMWaCe0GnBmwJgglrhe0LYQ14WmRlyxeKXpaRbKTNfkUknrSk4JlMFqLfkq2hBjZH91\n", - "5O27dx8rypQS3nuW5cJ+v8d7z+l0YrfbkXMmhMDT04mXL19QqyxBlFIfK9UPWUygoAnspdZCrY3d\n", - "bk/vjXmetxmgVLmC5pMo5bxmlviIdo7BD6TSucQFc04ML8SJlWOjR3lpOmeIcaHWxM4NnO8e+fL7\n", - "/8jNy5+jvPu/adFhwp5iQD9F3PGKy/07rFIMw8jdm7ccryZGF2DY0Uve7k2E1xiCAChixDtHTAml\n", - "Ky5Im26bPOTGGKyXWeCHq5ZKCAFjLct6lphcPOt2pOSaxXFE493T14zuSuI5aqT0SDcL1hT0Rifq\n", - "vWGUp9OpathqywtOG6ySzkwrRy2WViRZNadG75rWDJfTgh3k0LReSRFkOj4I1xZjsMbibGdwndpW\n", - "Yl3pXCQpVgVSziyLQG5ayWggBCEUDZOXhV95IkVLTk30oCmBVRgVaFay2IfSUWNl1Zp1rdRuMC0I\n", - "0awIXm/cG6zaY9WO1py08mHCWUdKUSKA3f9g7vn/X9fp8ojZH7AUUJ2GJsaMtRrndtSS5Bdn9lyN\n", - "rzjPb6jB0FslxotkjWi2llMeql5Fv9W7QrmIUhZMxaKgaBHL90JXmVTYHsRN/4lCtYZz8suy24NX\n", - "SmOZq1Sw6C0TqFK1QmNoPdF0Yq0z2IrtssyATteaMHi6lh9zp6KVIy6Fbi2WQi8Kqy0WR68LuimU\n", - "8YKUQ1My3Fw/Y5qODM6RYmEpi1RX1kNrWHvAu3vOl4WqFAfrqClS1IK1E3FplJjItUhueis059E6\n", - "MS93aDRTONBKw3gjej0ndkzTPWVNzDYyhonSqryI6CJaTgqFpQdNbBmLxj+/kQwkYJ5nhmHYZEVB\n", - "smeU4ng8CrAlBJZlEbjvtP+4LFJKMQyDuKmMJ6XEOE7kmGhSkxFC4P7+npcvX7LOy391GNecOVwd\n", - "uL99x/X1M5ZLZH8s3J4fuLm6RiEba7eeMeFImAZaKuS84rUhq0Zm4PHrH3E87Lj/8l94Gi07N5Lm\n", - "i1TTJZL2Gn54z3R9ze0XP6CkwmE3cT4tPLs6kNJM12L0Lbl9nOHK+CJsml8ZZWhtsWic3WZ8XcDS\n", - "vUs2t1bS6Sjr6EoxuoGzi1we77mfH0jlLAdu0ZRUeYgnZp/QGmrNaJU+OsCUg94dk79CYcglYowm\n", - "10rvHqMLRjmc3knhUA0tKzEzZNFK9l5IJZPRTIMB3bHO43SVPYF10D3WC1KOrWPTBVIrQi3qhpw6\n", - "KRnohl6rdHuDB1Up+QzuyBobcQ7kLMvTulmTp2AkGkQVlC0EZbFOobUjzhLlba2Xdp5Or2DMQO8G\n", - "7wa0ChQKKINRgg9T7mfUEbSmR5Z1ZBeeb5KFCWcCKZ9EzqC32IduOQ5HtIrkItqqSuXh8pbReUqJ\n", - "uA7eKazZ0zr0ulJUxqpCGAbWtRC0I66NUjvNJNCN2CKaCY8sLGT5M6OtQRtLWiK0DbRhJVI150Ip\n", - "mdaEValUY00n8XPTaVoOM60VvWe6dttG0kur0RtUqaR072S1Bb51IcBIbnmhNJHMzOsjn4ZfwJsg\n", - "EAVT0dkwr7eEEBj8Adt3jO45hMjcIKcFZTqxrTgzC4k7RnICrRONhUHdYFyj5ZleHshpQetCbRWL\n", - "x7qGriOmj0yHPd5fk5cVb7WI6WnUkhmcRKo2YAoDVhtxFXVZDGj9n6EUtVa8DwJX6bKkG4aBN2/e\n", - "cHPzDLdBG5xzWGs+VozeuY9V0RpXrLFY53DOMY7j9nk9zm2LpdZQVmJkj8cDJSd24w4qjONEuTxy\n", - "OFyRtUF1ETsv8yODdZS4ELPEn4TjDdEZ7h/uOYwTt1/8E/rqG4zGkG8L1Ir95FPKFFCnB24++ZSv\n", - "Ht/TrQHVuL29YzcdOF2eRGvYJc9J5nqiN9RagxYW67AtyHLOoJBFYt0E7dYAGmUaVhuK8HtRKdNa\n", - "Y24rl7qSeiOiaMoxmj2xLJS6oFXHqI61nW7M9nU4jHVYHNZ5lnRCa0/vGqUiJQtxyfQAzWB6p6pl\n", - "G9VnecF1gav0UtFG461k+5QGWNH/OqOoTZ4HYz2mRGoyxFxBJWqFWgaBzKgmErhWoFl6zazpTMsT\n", - "OWvWdQP0tI6ycD4XdqPGeEXTG5WsN3ZTwDTHujRUUzhjaShsC+ju6AhRiarRtpOWZdufVMxPXp7/\n", - "FMXtbSHmO5x1uBSw2tONgTwyL3dMwyizlS5zsv3wnKfLV+QCtVXWtLBGAXRMm4TFeS2zzKagOpqR\n", - "OIphkAfXDdCzJrfN2VPESmfVgGl92+LJNlVLUgxKd2qVhUXpUQSwKGJt5FwYxrAh5SCXBmRUQ97o\n", - "CJ/QOgvdoLB4pyj5JAN322QY35QwGlUndYEs126xztPqSswzV4dPUKbLzFBrni7vWdcz03jFoK9J\n", - "JRF0pPREzFluhtqJbUYDS8ykKNlI1ncos2zSlWdeH+h1xFnFNDq8HWlREkDDMKGyaAlRnZIbtYm7\n", - "x9gdcXbUZkTq5RzLecHN80dLoLyIGikl9nuh37dtrbnbTayb5zqEAVDs9zu0tqS0fmzRx2nClSJt\n", - "/MMTGD6K1/f7PTFGpnHcBPId7zxdS8Rxb3A47jmfThjAaIV3lrXJdj+WiGqVwVlakQz5h9uvIK3M\n", - "737M1WffZtDCn0zv7qnXL1DK4lJh6RH/byfc//xt3v7v/8LNp8/ZjYHzwwO7aeTd4z2n8+NGtZKv\n", - "rVUxcAzDAMh8d11npv2O3iraeozzBC9RtV0Zuh8lCKw2lLHk0wMqZ7w2vLh+jgk79DDA3UiNtzy1\n", - "e7QCbyy9CjUJIroVvHIYv3EKrAZkL6CUbO178xQWcfg0JH6lCRWsNhlx5RIFbdiqIOBwsvRp0KqM\n", - "vLTptB7Fc648Vn769FpRykN15GI3ZoKl1UBvHTcYjG04L0WKRnOZ35PmHTmOxLXJjNJ6dDM0ldFt\n", - "4MrvQHkST7Re8V6j9xrVNfMaZYNPk2Vr0ZhmqGmFFilkqi5gsgC/8/oTz66fno1Sw5qfcG6P1TuU\n", - "ndBqZPCKFBtrOuN0gKowoWOdZXI75rISa6SRUKVuIAArc0qt6RgoFmM7kMi5YCwonbFuFGlFtuKx\n", - "NUJ/Nmhx62jZXtPWbVEVRCjcEyVv4VUtUaumFiOtUnUEtxPykM7EtG1szULXDVKTA6FqdA+ovsOH\n", - "ziU+UVSkmYyzshkuOXOJDesbxgbAYJzh9uErXtz8Aik7CcXScnA9nS54E6BKK616geoobQLdsE1J\n", - "+FpbKa0TS8FqGfw7Mq0t6C6ynlI1hgnTHbrBLniBJ8dEqQrVEzXLR1eKmhOldvHWu471Qt4P4yia\n", - "OrulHFY57D4Qh0TgvmXRa9Ee7vd7Wus4J3ZUrS0xLh9b9BAGrG0Mg8zyhmHAWMM0TRhjOBwO0PqW\n", - "FLknWEspBeckisFay36/E0xYl9gKYzzn85PELFdLywpNpZXG6Acent7gW+bu/Z6XQ8COBz55/T9x\n", - "+/4d7ue+RX16ZBhhiSf8j/6F558+Z/76nZDCVSYuhW/+h1/k/dfvyXnevOaaopRoDXunlYK2hnHc\n", - "IaFpSuRgLqB1oPeCsQpKomYhX5Wt01FKScSDMRzGEW0dqnu8GegEPn94y5wWUm9oHRjchCJhTaG3\n", - "TKcIPamL+kRCVWXT3XWjVqlMW51lkdgtrYkoX+J3RWHSexZwRt/o80qE93wQ8BuRC1qv6N1Qm0fr\n", - "inEDKmd6DeI9R+GcYRccIXSsEUhJbiJfyzWSqwLlaV2UAKObMHovFKeicf451u4p5URKYqQIo6fS\n", - "SKlvTkKDVp6SK2x5W1VLBr21kjjb1c/q9hxPa4o1NbwqGApD6Fg0IYw8rrd4XXDW0EvE64Hgr2n9\n", - "kdzF8dN6wiiFqSIPao0tpElRyirC9p5lnmM6Sq14H7DWU0plXcVFYXyTz7NxCFs3KJFnUkoTkbeS\n", - "GWjJ4pUuWYkLyUo1MI47Sl1ZyoXYErpLoJtE5jaCuqYWkT7RA9ZN9HShq0JuCxpLN3KTqKbopaD0\n", - "gm6OmO+5vXvLfnwFOpG2lus8v6e3GWsmYl7prOJe6hatnQibVREUl1KbW8cwjNB1pLVE61oAI7Xj\n", - "tcY0jQ0QlxnXxARQc2W/M3g9osJILpm4gVOUaXRdNqsr2CBkoVIETXZ1dSClzDAMIjbfYj92uz3r\n", - "ulJrY5p2HA5Hdrsd1op97oOzyFpxT8nmvTOOAyGEjx/ee7z3lJSZlxnrLd44qe6MwbmBjmyrVRea\n", - "VV1FD2lNJ81n3NghK+L6QFsj3hnCbiQ/PpKfvuTHj4Gfe31D1pnnXlH6SmkrRCT1MxcuD2/ZP7+m\n", - "rhee3bzmdP+WXBIvPvuM09svyFXo4GEMpCTQbBMsHwTYWlsJBTMGyII81HK4am3khY5Ceydqg2XG\n", - "KcNazqytMNdE7wXbO/tp4lW/4evHewGJWIt1Fm+D6BSRDmRNM4oi4nVlqB2sGSkUcswbxEbRS2aZ\n", - "E7oPtN7QSqGNJrWI851OpKlOTBk/aOZ4gSyide0SPWUGdcCa8JEnG+wONUzM55WUZ5zpjMYzmhFv\n", - "K86Lrri2TlyQbqUWepOK3VrhPxz2V+ieiWuCZgnhiLKNeX4AEtYcCWOnd0OvAzl3es843/G+ir1T\n", - "ic+/94rRSqKMf8L10zs0FXSlSG0m1hljLwxKAp2s8wx1YIknum/YNkGS+IeKwZqBsXsqia4KBkVb\n", - "Km70wqjUGtUqpURJOcwFctvym4Novxjxe8e79480FqnscmfQRuhDNlDsQoqZ0jTBAV1EuqWA5I47\n", - "0bg5D21i0CNJi2zKtoaxmtwzSwLvj2gl4WdrljjgXhW5JKE86UbDbfNAjbV+i+NtoDR3t29wrweM\n", - "caScSOWRtXzF093KtH9G7hdyi1g/4LqW7BZlZX5qOmaUWZPqnXGwdO1QNWJUQbWC1RqrKipXWulY\n", - "5xDnu2VSE9bA6XLmcpGFizGKaTdSK4T9kdOcGIYgUJMudspRDdQqsQRirZy2KgkeHx8BmKYdu518\n", - "eO8JwZHzmXEcGcdRljq1E0JgXdeP9CJrRfP3ca5pHdNuJOWIUrCuM8PwjN6bzFFLFluldbC5t4Zx\n", - "ZD6f6CZzefcVe1+ZT48s85lvvP4mLdywdM903HP75T/xySefcvf5VxjT2SnHl1+95XD9guiaZK6/\n", - "+RHP9s95eHfL1fXI/d0bJr+yuzqIRKoWtNGUUkgpg24E5+RFirTqc4p47whWMoDEe23Q1goDUll6\n", - "q3gNy3Jh5wOJjitS3HVVBa24nDFGMypP6xVrDc4OaIwkduoXxBC5f3zL+SyONeUs1lusgmwqS75g\n", - "nXQDFZjjLFwIoHUlraxydH0RVQmG03oSY4RRYCq6bpK3dmIc5eVllMW3IyWDqQrdheVpjRH+rZIx\n", - "ilKVZY7QPb2JySPVKPCVloglsafSssbg0X2AakAdaNVj3Ap6wSAb/NI6KXZyUpTSNi9+xgdJjnDb\n", - "DN2Z6SeeXT89R5Br6C4zpFge0XiMsiI5oqGapavOvC5iGUTLJrE0oTAri3OKXuWfobbEQatRAUFz\n", - "9coaIygoPTHqCa0cznmaHtBq5LNPb7jMicvyQAiNMN7gCEBhnI7kAvG0sPaM7o3S1QYXUZQU2Y2f\n", - "YNgLIkvDGI5c1kRKJ2yvKKMoqfOQ37OfOqVaaqqkXIm5bjT5gtEHBBIv+jnVtWg6G4xDwKiOplNz\n", - "kr+WzLw8kvoT69OdiMC3MYN1OwYT6JQta0baMR8MLYPVFuMHgSakAmSUMmhd8d7hzEAps+DwSmJe\n", - "H+mpU3vn2fNrOUq1IZWKKo3z+ZEQjlgn/u9hCDyezqRU8Erx/PkL9vud5JJvEQ/DMG4H3n7TWgpE\n", - "pWSZFV9dHZimHcZotG7sdjvWdcUHoRjZTY5kjCGEQNUGpRBrZ63sDgeeTiee37zg4f4e7w0lixV3\n", - "Nw6cLxd0a0yDJ7aMSjO3T3eoBn1duP36x5jBUO1I5omrqxuens7cvP4Gn7/7Avv8E477Z8QUqTVz\n", - "PF5xONzw7t3XKNu5vb0n+EA3iqfTheD8RqeXw7H3TsuZ0jYtgPak3rHaMPgRawPaOLrpIkvTjtaF\n", - "lqQ3yrpC4Yzj5d4z+MBaklSrStHpzOs9RTfGcKR3wzAcGcKEphH8EWMGPrkpLJeVd7dvWeo9RhWC\n", - "fYbe7L8xztgtHdVaoEv2eU6ZXCF4jZ1E7dF6kQhfJfNhpQR47Wyj1UxbMt5NtLrdq2iMGpBcjErX\n", - "CrSltUYpIvPLqZPTB/aDRPaiOlY5es88Pb3n+fFTDB7VusiRasWaG7R+BCWfW0LTJNYiZ7VV8Uqe\n", - "myaYR8MHXefwE8+un3ho/vjHP+b3f//3efv2LUop/vAP/5A/+qM/4u7ujt/93d/lhz/8Id/61rf4\n", - "m7/5G66vrwH4kz/5E/7yL/8SYwx/8Rd/wW//9m//Nz+36orWq0Rp1kwqC75OqCIOELxFN0uqmiVG\n", - "nNFQQVdDa1pwZ13TKjirqemM1pq4dHTtTOOAM0bkQaUzhAOtSvrdECzDOEKfCPaKF892XJYH3t99\n", - "Tm4LNIdwKR3jMDLPE2s8YY2nZkuwHqcNKRXScsF5i1ZY7wAAIABJREFUaVm1FjeLVY5zFL+u84Za\n", - "t/xwFE6PLHGhFkWpHaONbMxVxLoBowLOOnSWUQF0equMe0uKZ4z2oLqANnSllSjJkxpkiORQ2tN1\n", - "wiAb+a4auWSRfmhp/yydpkT034hUHKlHzukJy1lSohs4PH4I7PwBeqOguLl+xjxfYF3J6cJu3OHD\n", - "hA97wuS5vX+idTgcrlCqc331nDWeWNcVrcXtI9g4mMYjp9PTBmfQNKWYxon9/kAInpTyVmEpnj17\n", - "xt1dxWwV5gexfGsN7yXV1DpZOdQqmTvaWnKOzJcLtSR208Td+4XdOJDnMzUvDMcXvHn4isMhcHla\n", - "uTruWZeFyd6gwkA4HHn/wx9w9ewZb96+55PjC+o0YlYIKnH77i21FA5XR6ZxR4ozTVvWmBmN5zAd\n", - "RGtKYxxHcimiojDSfovovaOVAFdKzegP35/RMnvf7gatRRpH7/hR6FV3T4903dlPI4dhz36c2ccT\n", - "T0mTU6GVClYq/nG6Yh+uOeyu2E/PUN0SS+QXPvslvrr9IXePn5PiBW/2NFuJMZNVkQWa9xKGaHe0\n", - "ZkQutBZx9li9LZY6zu2gdlqJ5JrQo4y41lzw2aKVkxl5k1lo8I4Q5EBsVSSDtRbJHMqWmkFbISdZ\n", - "3alNXjoyW83McUT3HdRKZyG2jPONro0I6mkYW+ktCwxcNaHLl04plVITpRb2uyucPQhE5d97aDrn\n", - "+LM/+zN+9Vd/lfP5zK/92q/xne98h7/6q7/iO9/5Dn/8x3/Mn/7pn/Ld736X7373u3zve9/jr//6\n", - "r/ne977HF198wW/91m/x/e9/X2QV/6/LYKh903O1TOHCZVU0taertJGPGk4HcpZUvkakRdj5a47h\n", - "haD2XSLHldgiS5rx4UBchAu42+252u2J8YFORjtDK5116YRjYAzXeHvEENiFa6Zw5P3jj2g9QhE6\n", - "UisNbwaKXVBN4Y3HmkYwBpUr8+kdfhzpeBQrzhvCMFCqIpVHEbmXSm6Juj6gmKk0YumorkmLgdGg\n", - "bRHvevEYHRh2I70kIIJaSOVBbHVaAA678RXH/beID6t45muWoXZNGL2QS6WrA8ZWlJlRJBqFcdhR\n", - "Y4Ju0L3QcpbwKazE2jrPNO5RpTEazeCuoVr53sPAYRhJRUKMWmvsD3uUCyjlURYRwANXV1fUWhhH\n", - "yS9XunwUsj9//nwTsEtK5ziO22adDYzsNreQHIYfDsZpmnj7NhPCFa21TbrTpYI1MgPNKWO8/Pdh\n", - "HDDOc7i6Iq+GWiJ5XbG9sTzcUtcz58d77GXB9Mz8eGE/HokloYPjtF7o68qL0ePGgct84ebFCy7v\n", - "3uF3Ab0fiY8Lz25umC8X7u/uuDkcCKMXPWw3hOA30IYs+h7u77cZK/Qm1fUHhUHPldzAB0tKCaU9\n", - "1riPv9vWq+h4lf6IMCylQJdIjF4aow84RN6kdUeZTiORkmY5F6bxGXaaOB6vuT6+4rB7xhIX3rz5\n", - "kqvpGSVfeGgXNAGln9GaY0l3aFXQrmLM5rxTMkpSJtFKQiNqBR8CTnmcG8TH3RIlz0JLV52CAKZ1\n", - "lRli8I7RGYxr9J7oWVGsGNNK06I4CRI3Y4wHMqUs1NzQxmOM5f3jO3bDjGpGzBy9YbSn1jMKYUl8\n", - "yO2yXuM0lFRQ6kOsTCHVC+c5c9wNeHf49x+an3zyCZ988gkA+/2eX/mVX+GLL77g7/7u7/j7v/97\n", - "AP7gD/6A3/zN3+S73/0uf/u3f8vv/d7v4ZzjW9/6Ft/+9rf5h3/4B37jN37j//O5JzvSWyK1TGli\n", - "V2tVUZe66e0qTYkQWGlFJYmoto1b+h3spmthL/LAU5xJtdNyYhoOkBWmeXb7ieA8a7yAltzndZ15\n", - "7E8ML59htcFbQ8kGo0fGcENuj/QegSeabTiXULEzBI9XFt0VrgutPPaV27efc7x5QQsabSfGMDG5\n", - "a86LYcm3lO1Gbz3JlhsvM8MipCFqh6rJCcJHaYoCZUFVnPHkvLIsDxwPn6AqTGHPZy/+IyVV7i//\n", - "SeZH6oMkI0qchfXshh25LqIAKKvQopqnFIM10JDo5KoSXg+UXrisMwOW0h2Pl3u83qO8pqyJyzLT\n", - "miZ4s0UDS9SALN+EAfnq1SvKVi30bQm1LAvGWH7+s2+RS6Q3LZG4RnM8HolReI+dzm7aM4SBXArW\n", - "KEoteO+ptQqCbjuwpZ3PMtPMZSNGyU2ttKLUJhZdOo+nE5BklEEhzRfIkV4SukpIXXCOuKzowaGt\n", - "YzCOUg2X04x3CrosnMabK+7e36L2N3TVySUz7Sdomdoy9/f3XB8PInPDMM8Xrp+/YM0rOWWBEpdK\n", - "iuvHEYPzAsPQxklr7iy1ZtoqG3bjLEZ7So7kKtG3Wmv8BufI85lh0EwEhtMD5tFChTVGmqlMo0MZ\n", - "y/3jV7y4fkWvhiHsuLk5EOwLnu0nvv+jhbm845Q0eVnoNELwKP2MuDyilUU7K9k6WgZmgl+zdCUW\n", - "Ua8HfAuophl0ABWYlSL2JMnkCUyX58E6w+Ac1gMqkVKlFU3NTYwozWH1bkt2kJbc2iAsU06UdkH3\n", - "hNFB8orMnpKFiNbmFT/UjZMg64jSIjU3UAPaKNKa0FYJPV+tdHVmXj/HaPfvPzT/y+sHP/gB//iP\n", - "/8iv//qv8+bNG16/fg3A69evefPmDQBffvnlf3VAfvbZZ3zxxRf/7f+xcijlqBRSTRhjqO2JSiRV\n", - "v7Vkkhipbcf0Tm4ZqsU5jfeGw/4oMAtreVgf2NsdMSe0ajizoxdNTYohHHB2YM1nUok4P/F0eqTz\n", - "Bd94MdA9aCuzxNYqKWeULliF/HmXGaxjcCNOd0wV0EfsGaM763xPf+y8fPmK1mBwE6PbswuB20fF\n", - "pT6hraLrKHxLFGMYKWuGbih0cqwSiDZIjk1FeI9KDTQ0qJllecNuv8e7a4bg2ZmBb776X0lfPvC4\n", - "/hCtZEPbe2I3DpvMoxHcHq3gcjkB201eC1V1lJfwq2VZqRmmkBn7me6P1DJw5SdUU+RaGQbL/d0D\n", - "x+MzTqcneu8Mg8P6A4+PD9y8es311TWXNRLCSK0S6XB7e0drleurl2LnxEiQW1NcXV1tNB/NZS6k\n", - "lDDabAu8ytaJopTaFkoj3gfmOdM2J9jp8Ynj8Sgb/FqZt4N0WVactWhVmLzhy8+/YHm4Z/LCIKgx\n", - "4vcTu9GRfMCYAT1o1rTQc0Gnxv7qOQ3QXWOMIzjPeHAYF7h9eKQvJ3opXB33LJcTZRj49NNPuX+4\n", - "58XrV8znM7tJ9KjDuBdjREnkFDc1gWKaJjoKHwLBObQJUmEqUYP4wYMSwjqqSmLqFq/SNnG+dxPv\n", - "L4/MpdCCpVlLSsLPXGtDK0/wisuy8vmX/we7ceI4Hyl5x/PjDU5rUv9FLvXE+9uvUf1CJ1GaZGgN\n", - "fkdKCa278E+9kpyhJFEukUyMib0RuLfqMkoz2uF1xemVljO6D2Iv9g7nxfDhQgXtaAykBj0tpJKh\n", - "BUzwjG5P02xyIcewv+Hkbrms70At4uFvidwu9A65J9GLFoX9oFelkjfKliLJfkQrIZ/Z7RD3HcqF\n", - "8/zP/+OH5vl85nd+53f48z//c9HE/RfXB8vbf+/67/673ii1UrYYn1pWKo1mVxnO9gGjPNrIW0Yp\n", - "acdKO+NDYhiOsmEd9pSW2T0deZxPaKM45/eEyZHrHr1WyUr2Ft0HbBP/uHMr727fEHPjsDswjBMG\n", - "jzOdOTZifYR2odPxg8W5PaYNIpnohbJErG20WMmt0taF+fLEzfUrCXejE8KB/f6GckpUpWndbGgs\n", - "Je2TVdSkaNVSeqF3Ta9ZiNeuYLRDY+gqU2sh1RN3p5Gff30jLhljGMKB11f/kVo7T+vnQKeUwjTu\n", - "aF3SDZ11OH2F1VUwWcpJHISKWOeYumfyE2WttFpRekQj8Rg5NXQrTNOe8/mJw37PMl9wfmC3P3B3\n", - "/57RFl6+ekFXmmVd0MayrCvOWR4fH8URZQYOhz3DMHK5nJnnCyE8p5SM924jGhlp0+ms64pzbnNg\n", - "lc1hJXKlEAKlZHIpuG2+ef/wQPCe3ThRUmJdVuhwe/cWXSNadW5uXjJrRTzdk0vDGst8ufD/MPcu\n", - "rZZ1973eM+7zttbat6q3pFeWZNmcY78kJibELUO+gTAY1DC45S9g3LHRB3HPDYG/RMAEQo4gB9xw\n", - "GrId2ZYlvZe67NqXdZtzjnsaY1WdkNg6EHOQV6vYULuovdcac4zx//2eZ+yv2dy8gKLbzkRr1uVE\n", - "UorT4T2ygpu65iHPjsfHI8O04+52y/qUOe+fmU97XNfaSe/u75nGDfN+RilNFokiFMFHFAbtDErp\n", - "j4H3Vsxw9F3rPAtZGwbxwxVGlQgtEQiUbci3dtfdSESyNpr/Vt3w/v0jMUk0msE5+tz66j7MgEJp\n", - "eL//Cv3F36CtwnaSimDqtwzdlpdX3+Dh7jWff/6IjzPCtFaesQYjRiiFGtvcIfrWfhNIUI4cBefD\n", - "gt45VNHMOWGNolcdur7gKZ9ZRWlZ6iqa+cC0jVHJ7T2eC6RcCD4w2h55qTJb07cCTLUgKy+mDdvp\n", - "ijl8SSoeZEURyLJiddvFWqeRMreadS2XO1Ao5YxSQwMeqwqioK1AiBXnRkr+N4bbY4z8/u//Pn/4\n", - "h3/I7/3e7wFtd/nmzRtevXrF69evefnyJQCffvopn3/++ce/+8UXX/Dpp5/+i9/3h//rW2JNxJK4\n", - "+9Ty8lcEVEMthZgEVUeEVReat7oEsFeUrszr/jItBmU007Bju7nllN5SCVijOK73TE6SF0WuLdxs\n", - "pCXXgJKVWh1VrNw//YSzH9gNtw1cIQ1CJEQphBRQyrDbXiHERF41JVQonkWciKLhvKw1CFVZjgdi\n", - "WNogR0iMNjjtMKZvRCOhkUpSLvoNUQFRkKK0BlOBVFocxcgOaL/QIvPlcnxl9s8clxOje4EWLW7j\n", - "zBUvdr9ByoXT8p5KIMTIqGWjVYs2IMrZYoRDyg5YqUJgNFg9oMUARmPLRE3QiQEdO6ZhwKoOsmEY\n", - "d7iuY3vlGKaev/+7v2e3u8ZYx7ysjNuOEAPr6Uw/NobmujRYx+3tLc51CFF4fHzPOLZp+jRNbXep\n", - "FKZ29H1HLpHT6ch2uyOlALWyrh5rLc/Pz0xTc5nHED6S32spl7ZKQCuFjw3m3BnN4WlPCSs5htbb\n", - "lgWRweieYbzhvMz0zmKcJJemIckVRIwMux1P9+/x6wnbdWAT4zBy3O8JMWBy4Wq343n/RCmF1c9M\n", - "0w6hNUoYYggNM2gsOa9kUdoA0XtC9CjVfFG1aKiZrnOkmiklI7NoaZAKorQKrtIGkE1r4VQ7pudE\n", - "DgETNbdXdyzWsT8f2S8PjKnjED2lrgg1gGjYti/f/iNSKazrSXnlbnuHEYZBbunMSLWW6CObItGm\n", - "5XWFlKQkkFmRL3lNShvgODmQtSbkxNPxPb3Z4OiQ2aJ1h7MSJXr2cSaWBvsuQtJbjWZkCXsomVJm\n", - "cqio3CGqJa2ROezJNtL3V1gzIWTGdgNOOUa34RBfk+LCGmeKqJc6skBpUFISfCalSow0r3pq7xep\n", - "a8PAicRX/7Ty1U+W1s//r6yJv3DRrLXyR3/0R3z22Wf88R//8cevf/e73+UHP/gBf/qnf8oPfvCD\n", - "j4vpd7/7Xf7gD/6AP/mTP+HLL7/kH/7hH/id3/mdf/F7/4//8zfJpRBrJuWFXFdSWdCqxYtibHcb\n", - "QrYJtNL1cjdROPs9S36mzxMmdWip2W22PCwjtcyoAD6vPB/fMdoNPoJQ7TghadNUAeTY4B3ePxGl\n", - "QVjPcmEAlizQ3HF3c8fY3TVwh/QEAqufqVpSrKFmz0brtkusijfvf87XXv065yAoqtnu+q6HdabU\n", - "5mePRTQdgdJIIxEytyhEahPU6FdWAcM4UoS89LgFBcUaZ87+ieN8ze3uZfPKSIUSjk9ufpV8Hzmu\n", - "X+L9kSC3qOwoJVy4ghaKpaa2g7fGUvWpJROKpDcj4dAmlbJUdtOG1XtOpwd0sYgL0GEzGX70ox8x\n", - "jgPDONIPIz4lfPCICs5ZYlp5enqk70fu7l4yjVukhOPpCaUk0zQB7RSz27XBTtf1tLB3y69WEss6\n", - "s9lseHh44Pb2FiEEj4+P1NwWy+PxyMuXLy809ERYoSpNDGfC0hQpndGsK5yWGSdVU+4qWmSnc6zL\n", - "yuG4x6UOpzegHNYO+POeZVnZXd8yn54pue2Au2FouUc0i5+RznB9cwOykfZP85nOGPq7G8QaiOcj\n", - "KfiW8kiSkPMlydFskENvWdelmQDMCduPdH2mG9rPTMomA8Q6Pqh8MYUaEuG8UksAZZpHvCaS9yhn\n", - "wQqqKaAFKSZCWDG6Q0mNUvD5F/+M667oht+hlzOdcYxW851Xv8H+/Mhxfk+qnmnYYK1hWTzeJ2Ke\n", - "CUu7vza6R4hCyjQYi5asy8LRn+m3GwSSXAtaaqZuRPc9SyxU1zXOaxFICVZMnMuKXzPRV2qWrCVi\n", - "RLrIFCO+FHZXDis7qgAtBmy3xfY3nJY31PPn+HJoGWSRiaGgOgsIcmr5YWhai0qDfEAipsCr7zi+\n", - "+R8HlJCImvk//pf9/79F84c//CF/+Zd/yW/91m/x27/920CLFP3Zn/0Z3/ve9/iLv/iLj5EjgM8+\n", - "+4zvfe97fPbZZ2it+fM///N/9XjuQ4czFikKCkepM+ckiGmhkknRIGjw35wT2l7qZ7EQi+fLx58w\n", - "bW953qt2SS8zfW8ISyHXuf2Q54AQCSU7nvaK3Wak73vO54hfT0gSqkxIHS7cHIGolXUNdGbkV7/1\n", - "m/TDruUAQ+V1fssy+5bDTBXdSaSwlLDgtKJURxWS4/Kewd0Qz8fWuKitoytLRVfRKoNSkWnKYmpB\n", - "mBWnHSUbEIXKSqVVz1IGrSRGj8zeU2rgsL6j74fLfe1jO2IIy4urXyU/FaI/c8jP1G5Cp4qQBSkc\n", - "2hhyKtSqMGXCygGlM1Jl4joTpKIsgo2zHI9PreVhHUo259I4DLx9+0UjqovK8/MDX73+OV0/sd18\n", - "gh07UinUXBjGka+/+pSrq2uMdhxPe0KI9EN/OXpHaq3EGNntdh8BHfMcLsdzTd/37bQh5UdO5vG4\n", - "J/rQdtnOMc8zwziwzDNaN5htColaEufTPTfjhtP+EeUUFMnQb4j+jDaKsAREbazW+XAg65V+c0Pt\n", - "BnyKxGVFhMD26go/e7TRLbtoNLl4csnMMXO3vWVdA/2wxcT29efHR8ZpS5LtM9Cwd5okFbM/o4yk\n", - "5EqKsXm7bX8ZDLUHpQ8eJ1U7ndRMDhklaJ4JKRrwVwm8j6SQ8FWSlwUrC8ZoNtMVaz7g18ISPSmH\n", - "VnfEYo1GyMI//uSv2W6uGL/1PyDoMJ3gdvc1/uM3/idKFnz19GMEI+Nwze1uYH/Yc1LvEOKE92fW\n", - "/ICzFzygvOw8naLkzNN8pNs4pDQNENJptLPoc6Fae7kyS42BGUQLpqfmBQo+tCsrY1DWscaIkCfm\n", - "+8+53n7ClXFoO2DcyMYILA5ZBI/hn6mybT5yDm2hDyshFqQwH2lRSsumRFY09XcpiNq0M/LfIlb7\n", - "3d/93Y8oq//366/+6q/+xa9///vf5/vf//4v/EcBQig47dpCVUCJgiiJnCIV0RSvpd3N5JCIPmN0\n", - "m4zFUnm/f83d0xsm93XmpVUmye0NFXIlpkSshf3ZM3Y3lKgJtsNpxdhtmJdnUjzgOo2SrvnSjUPb\n", - "HiETV7trxqHj+uqWq90OqiNEeH3/jjXNxDxf2hodZmgEHlEFQsHZH1DCkmtFCY8VmlLSxXxZESRq\n", - "URin6VyrF8pSqEVSs0QbgXWCnFZaorhN86SwGJM4nZ64+frXOPnnRjLvO+pBIqTG6Q1fu/5Nnvfv\n", - "OK9foeUjgxyaAKt4Fu/ph5coeYWqE05YtPOs8YksV6TusK5HSIVUltubHRKFMztC8CynM1bDUtpA\n", - "x/uFnDxT/xKt4HTaE1LhfPZ859e+Q98PCCEoNeD9Quf6jz30+/t7hGhd664bPvbF5/kdp+MMyI8E\n", - "+PP5TM4fCEj6Y0BcKdWwc0rizzPdVraf46XYsBkG5vnEMA6cTvtWTJCCHFuGWYgmrjPKMA098zyz\n", - "vv+Sq5sbbq5v2L/9CttZ5uPMze0tx+MRZzTOdsQYCV6xzCt5J+j79m/UonheVl7cjPjz8UJNL5ew\n", - "+Bk/z1TRrlza/90QQuMoKGVw1l52Z1ByJoX2IPDzjFatPYMAbR3KGjrbcz4eeD6d8aWRiaZ+yznc\n", - "EvPCMkfWJTYfuJIUmQkRlKoUEj/6ux+yGya+/fX/jhIVWldeXL8kpP+erhs47U84c03fD+yuvsHx\n", - "4Ve4f/gJ++NXHM6PeB9wncbYDi070twUFN4vHOOxDXykRlbVwNG6UnXFWNG87qLVRMmKkgRaSZIE\n", - "WSrXV3dkekKa8XFhvz4xrzPIntF9gmFA5IXBbhCinQjW/Eyi5WLX1V/uvzPOfsgzf1BsV5QuiNbQ\n", - "JaRMZ3uQ/17RcOfMaGwjc9PYeLV4cu4oVUIW5MQHrCA5Z3yBVNtRu8SZr97/mE9fCKiJimKNz4S0\n", - "kGvB5+bXyyWR88zN9R2iWPws0dYyjS9ZQrvDsMqhVU8uht6OSJcY+h1Kdk06prbM80zvJl7dvuJ0\n", - "fI8SO3JMUCOhNMGbkvJSiSss8XyZ/C50ykINjbaUF9AOoVvOTSrDbtfjw8p5XcEU9AWYrKSCojC2\n", - "w2iHVBUZKynOlOxRYuR0PDQajNSE6HGuVe/udt9i6Eaej1+iZGQcBFIYivCs65HN+ALBgLFbjI4U\n", - "LGt6BBEQUrGWGajUOWDUwHwukD2H4x4pC1c3Lxj7Dc+lMPYtP/ru/Vuej0du716243e5AIFpQWVj\n", - "2uJvreX9+/eXhoy41DIVKSViiHRdj9IS7/3HAHvXtUWqlIyzjsfHR/SkLsf6jhQjSkgO+0e6ziFq\n", - "RgvB6Ximc5pcazPQxhN+nRnHER884FHVU0MgKUvXD6zzidPTezCK65s7jvsjt3fXxBSZthPrPJPi\n", - "mb4f2U4bttOWdfWYouiHphARQjCfT6ScCMljRcsQCpp5UymLD5HFR2a/MriOrhuoJbdrBaVJYgGT\n", - "kVXj3Ii5urqAMhQN1NVsrKob2AjJQmV92rPMR1IJ7Rje9YzTyLIE4hIRNAB3aSU6lNaczvf89d/8\n", - "b5Ss+PrLb7d2jFDcXO2o5lusV4HT6YC+xKF22xsqM6kcUVqwhiM+r0S/UomoqrDSgk7s/RGNxSnX\n", - "4LcopJaI4gk+UoQghJYr5jKEoxS6fuRq801GewuiEFLi7I+cl4hfV758/VOuxyt0jUQhkSqRksLq\n", - "TdP81pmQJRdv8uVqr/XV1eWar7ZdFsj2NakUVStk+TfsNP9bvvbHGacDV9cdRjmKTAwyEQ+V85KQ\n", - "uQnlc1kuR1RNSp5UC9oUtJY8Hx7oup/Qu5EqAnPZs/gjJTUFcC0OqWCNCz7OTHaklsQ6F5TpGPot\n", - "Ph7QemDsb7B2aMeldCDGxHz21BvFYb/ncDxxPjcV8Nh1aFGIoZBqpXHnWzNCqMqy+Eu8pznbawl0\n", - "tt1lxRIhFXrXQ8qkNaJ6h9EO1zUZWi2KnNs9kawNrzapAbSgUz3n5Z4YjigGCisCjZaegKfi0Moi\n", - "q2BSX7vcC74hpUpne4QYWVeNjwnrBDUbZOlRCHpjWOQjiQI54LRh9YE1eHq1peZGHdpuBlAdb+/f\n", - "4OxEjoJ3h7ec5hM3n3wNJRWd69vRNCWmqT10Qkht0v30TN+3qpq79MihkY989BcknL6I6Nrfcc5d\n", - "oNARqSQ3Nzc83L/Hdc0XFGNAKcm6BnJccVpTSiCXiPft3rBc7Jc5R87zM5vNFcEXVKcbbtCvdB2N\n", - "NKQkKWdCDOzubgn5kqm0FpcrNRfOxxkloO97hqHHh4WwJmTXkUtmu9sRU2L1C4f9kZrzZYCi0VLg\n", - "On1JBWTIzTJpO4nqDLU2JqUulSpbYFt+EH/FSK6Vai/RsdwIUVPXU64Fh1LZ79+jRaXTGzbjgq6K\n", - "02HF+4gVklASWVaUMdhcuH//M/7PH/0nfPZ848W3ccqhtWHbXzEOhdENHA/PZALaaLQZGadrQj5j\n", - "0SjRsXhPyAUtJKVUlNLUKnhaTxTl6I2mzw6pLqSitSnMvPctDlQTQgtyaMbLu5tvoUXXShI0OEp9\n", - "tvTdhLWCh+efoeQrSslYZ5CyIIzF6S2pKPyyknIml4y1HUqJy7C1zQjgQyIjooxDCkWOYH5xTPOX\n", - "iIZLkfl8YDM5hrEDmdAqYa4gh6bjNMYSM/gwk2rGmB6n5kbctiPGdZyWGaUkQq2kegbaNNoZSy2O\n", - "abJ4v/D+6QuGr18ha22MzFoROLRyl1qkoTcTZuh4OmWO85lKZv4nz83mU06nBUSl5hWlc0OvCYPK\n", - "iVxFIwApLioKhdKSdW6KjBAXIpWYC0JLYjpTo8SwQxSDjAnjGii1ArkmBBJRNGRLCZViKlp0F43F\n", - "wNPhLS+vu0akl0Cd0SWha0SpnpBadbLvJrT+hFoDUg50/Q6hAotfGIis89owZFJSssO5a4QplCUQ\n", - "14BxPeM4YVNPiJXr6Q5VC8fZ8yvf+hXevXnP+XRqLY0cWY5n3O2IVpV1OaOt5enpkZQCSld+/vN/\n", - "5Pq6NYKstYxj25WllFiWGWiLkD3b1pqp5eNdJ4BSbSciEfSuw88LSrQdU83LJXDdVCZaSaTRzOcj\n", - "cTkxdo41ZpSybUcXPO0wa3Fdh5Aa70/EGMi+0ZdKicTk2YwDawjEktsdWC1oVck5cpwPOGcxylKF\n", - "pdT2sDydz4zDyDhtCD4RvWc5zIS13dtvNiOqSoxqdk1pNNurO0w3kLIn54rWDmUciDa4pMS2U0WS\n", - "lxVBJWQ4nw48HA68ftrzbj7gkyeIRDG5/TwVOGOZz4G4JChdyzOGhNCOodO8efszUg6sv1759ovv\n", - "0HcO63S75pi2pOh53D8gnUF2EpcGtO/I3iNyRFJxolWXhbokGWwPUfO4PLJhRxKgZcQo00AePrGS\n", - "CNG3WddgqFIy9Fu2VxMSxTpLUo2EJ09vOzrSWSKjAAAgAElEQVTnmlCxZp4Ob6gioYPCWkcVCi47\n", - "6RAj0Ue0tXTdBqvatU7MzQrbGnQRoSD6hBQSK3qK+sXz81/aoqmlhFqZTytXu2us1cTSnMtXW8Vj\n", - "gZwCAtOo56WpGly3oTjT1AxjwVrTvNZGokoDq9bSlBVC1Qt6bCLlhbeHn7Ht76Cohk5T9UIbtyhp\n", - "2yW5qFg3cP/wnv3hnnX9O17efpMcaFRp2eqISjXcfwVUvdxVivYhp2Ss0qjBEmLEuYlcPRWIaUbr\n", - "ZtWTukns269BoXTziecUSRG0cKRcWVLAJok0AlEiJSV8mdmfvsLWgXTZhZTk8Su4XiOwkAWlOIxq\n", - "x0YhLEoqpiHyuDzy7t2XTOOZJVq6YUPJDZXXOUlSDWnXS0mMLdw6biZiSuyPDxg7cnw68vz8gKzt\n", - "vrTvNtxeX/O8f0Ybiw0Lm92WL7/6nOvra16//ooQPafzkevrW8Zx+phVTKl5fz6oMT5YLJ1rmubz\n", - "+dx2Bfm/MDq9Wojec8yBcTNhjcTatpNNutIZTY4eZzRpXTkdnrGuQ0nVMqy5otRF7LVmlFGM44jo\n", - "R5JfiSXhpMJeIk1Om1ZZzAnjDMopSrEcjnuO55mrjWn0nDQzbTacj0eSDyBFu7pRsu0wNxtiipxO\n", - "J6Z+YOgmXNdhhrEtkFKjPmgpmga16XoL7YGQMyBJoYW4s9BUJEIalNYIWQnLypJX/OTprEJ3XfOM\n", - "a8WiI/EUKKugSHFRv2is1ty/e8sc/xM5BL756tdQoX2m5vMJaRVCS/aHR/pBtkrszTeYl4Gnxy8x\n", - "KlFqBFlBZ6SthLDgbEUlSUpnghUYYREUSszUlFAUkvck2XgBrncM49DsnLLHq4CfF47HAzkVrO7o\n", - "rEFRKTUT80yh2TWUdK0EUAs1GbTaojAUb9D9gFEFLSvndGxBeB8oGVAtIlaVYKn/ThfNHI9gtoQQ\n", - "CCEwTA7NhoRnmjwRzfPDSsmghUAqS28t1gq0Nvi4UHxBd2CUwilATCQ/E3K41MzEx12M0gahInN6\n", - "i6k9m34HF8dPygZtRLt7y56aKyEk9qcHUjmy//k7jDKY3jDaHVaNzMcVqWjVthTaUSSLFh8qqWXY\n", - "ZGTsNaVWau2QqhJjZQkLvTYYs9CytVuCr9jSpFSyGIiBUDxCKM4pkTkzpAPWmuY5qonj/LYRmYrF\n", - "KoftDPO6EE8RUUeCV6hOI9DkpNqOUUpKjNxsFW/ev+Hx8AZ1MvT9ytiPaFnwteLcgLUghENpg8qw\n", - "PzwRvCfFE7d24Hw4YmQzgcYsub75GjFHpmni1atPmFfPmy9+xm5q5HTvW9TLdR1StshN8JFxMjw9\n", - "PV3yl+31AcDxYfhTSpOnTcPA6XxmK1ts6f79PUZK9scnbqeJnAO3V9e8ffMFXiRkbeFvZyRa0abm\n", - "Wrc8roSUVrpeUzIICjlGejsyXG9Z4kIJTbFbasEaw4VbRhQVp027q1OSw+GJ0/HIq699yuFw4N3b\n", - "t83t5DoO5yMhBtLlYaC0ph8GnGs09hhbttQiSDEg6oVxWVV7L1mHVB0oi46+pS1qq64GH0ihDTu2\n", - "04RPiYf5QCclOkXWOVOkQbu28NNVdKwImcA051b2hSpohW/gq89/wrwEYg584+V30KpQiKyp7Ww7\n", - "CeG0UI3E6R7Z31J3iXV9wi8ngo+X5Ac032ZsgjVdUbJgVNOMiOSpBQwtkJ5JpBwbxNrIS98+YK2k\n", - "zvmikPas3uC6DRh5GZY1sHEunkqhpEoMmZqb6loWSVojUQiU0hQRm0yvKkTdkM4BZXqKEFQ84r9y\n", - "Pv+lLZr90OP9E30/8PhwYhhU252oDauakST6YUD0hvPhhFGGrhsuDp2INY6YAn71dKYnZUsuLfUQ\n", - "fSHGjNECa8XHAHGpoETFGoEPp8tgInFa3qOtonNXH2VrStoW1PYNlNt3CWU8dph4dfdNBBM/+/Jv\n", - "ebf/ClmbyTKn0o7tSuC0xGhL13Ut2hJjy0ZagekkoiYkFS1qo7NUQwoNuV+rAjp88uTmfOIQTvS9\n", - "pB8dne2ggNAaH32DHaeKQ1KF5zwfSXFPyZqBLcpZQgItJML2lJwxquP2+hPun97wcHzGnheuNjcM\n", - "00iXHZ3u6KcemTVhXolxJYVMSTC4HTEG1nDk+uaalGDrOsZp4t27NyiT+ed/+DGuH7HWYTrL/PiA\n", - "URqjWz70eDxeXEqS8zk3/mXfcH5KN9ybMYZ1XS84OUEtGUTFOcu6rvRdj7aanBJSVR73z5hSwcgW\n", - "GM9ND5piJPuVvu8uAFt58XFnapXE+YyUCu16ZLdp/p5S6bqR3Ar6SGVJJaJMg0+XUvDBo7qO67tX\n", - "DNsrnt+84Xm/Z+x7us7h13AxcepmKTWSYwyksJKjp+s143aLVh1VgpECaRRVqubp0QqhJBUDCIQz\n", - "0PeNy3BxJclcyXElicLTwz0n38oRpWac6YhCQinEWkFJiImqE9ppyuovVdW20DQQh0QKx+P7e/7m\n", - "b/8zPp24Gq+RSiAu71XlWjIkIVC0qJAsDqc2SC0QKbLGGZGb6ydnqFUgVaW3rS1XayXlBn5JJSFk\n", - "xSrNEpvXKuWZlFekVvjYGkGf3L7i6fme/eEJ7QqmtpSJvLBfU84ocaHQy0ZCC0uiSgdF4FWh7yyS\n", - "1GJ3XGYfQbOGNixKsqJS/oVr1y9t0Zys4RQWlvM7jOm4f3/k7uUEWDp3g9GF2hX62qGLwJem1JVa\n", - "tKlXcSQRqMITsm/UHjRUDThO5yOCM65TTFOPu3iEetdjpCJVQb1kJiNn3j19zvUGet2DGpBCUbOm\n", - "5nY5LJxgMNdcT99mO37CZnjFze7r/PWPfsj7h59TRW0B4uSRMjO6yt3NLUYreteUDSkXpDSs0YNs\n", - "ts0aExrP7BM1FnKqpNqqc7m0vr0UhVI9i5cg2/VDpyRVt+ZUjpmcBDEDBGourEsipoUYMrbv0VpR\n", - "wkLXW3o3MqqRQXbcbF6yhsrhcEDU5/Zhu/qEECR56NGmwpKY1xNWOKRuFcnNZsfXP/02KWeq8Fjn\n", - "ePP6S5b1RD9MdN2G+XyiH0Z+9vnnOGXQUtJNY2u7SIXWmvP5xDgOWNsC3s65jznFD3Gj/X7fgtnW\n", - "EGKk63vev3+P1ppu6Dk8PGClQZTKaT6TXUOsHU4rRla2g+W033O+IOS6TpJyAsAZ1/QlpDbMk8NF\n", - "GZspa6RzhpBmqkxMw451CSBic/YkmOcjMa64vufFq2/i/YnleMRoST+OLMuZ4/lInBe6TtNPPTkb\n", - "zueZ4ANWWaYXV+3+rTRzgda2eZQuURwhVdNaI6iqIoYBM46UdcFYxW605KdHpDyzX4+c08KSMilX\n", - "slJUmSkioDqBUZJqNV0nWJc2/AqhVReLbzGdUgUIeH58z4/+/m/45qffZhpHxn7AaYPAst3eEtOK\n", - "DydKUYhqqNGSo6GESi3DZWfYiO7KSGxpKLZQfBt4iiYPTBSMtcS6oIUghDMxzfh0akT7rjE2x75H\n", - "ih1yaaQj1ztq1ZegeoMlR5/QyiCkwmjbZidrq0NXEUAketvwjSVWYvCIZC8Rx3ZdQ/h36j2vIjP0\n", - "A6dlJoVn6F7g54J2GmuuGDcCfV7ZoHBKcU6CnBacvsXYG1b/TEgr5XLEEwKMbXT3KuVHr3QRreMt\n", - "lMNoSQq0hpGUIETLsJUja/Q4s0HYgnEOo3uM2TAvM7UmYghYM3F39Zv0tqfmhCw933rxm8znPT4H\n", - "JJrgY8uUjltyEcRU2WiL1YoQKyk+42yliBUtFdoayIHJTCgcp/O5VUljAVqCoNZWH40hIoTByIEq\n", - "G3fRyFYFS6KBRmqK5NoiS/NpIaiKXQPCtjsmuwpeXX3CtmtQiERhko5jKfgQsOHMed1zd3tHiBqn\n", - "FdKMCF04HE6IAnfXL1HGcV5W3r774qPjJ8bENN0xTRv2x2eoojVpqsCLzO3dHftzq0d+sEs25rK4\n", - "HMWbgE1r3QAuOV+iSOFy55kv9Pf00Zl+Ph5RylCTR2uFs5r90wMvXtzSDz3r4YGH0zPbybEm0MoR\n", - "Q6HrLcfDkd12i9SGlAS12ksZQ9F3tu2m5xnnNCFmTqcTt3d3HPcHjO4oshDXM4PTxNORrFY2dy+J\n", - "OWNKRltDN71k/+4eZwe++vKnpBC4ubnBWktc1vb7Fhlte7a3r5C2mSflpScNgKwtIuQTMqbW/xYa\n", - "cmwnllLYdgP2hSQZOKfM87lQlcKpiNADj0vCqMCm2yBFpOQTw0ayrILj8cw8n5HFIatuaggZGaYe\n", - "USNvHn7OLlyh9dcbzk2AdGNLgNTAcT6gpCOUBtnI2beNRrGUBEWIdp2AQKhMEZW4FqSQpJKJoume\n", - "2+czQ2ktwef9G0LvuZpeUvHYrilobuzAGp5QQiNFBzQIzodOe4tTNU2IIDaepmmyt5RXUukaM0MZ\n", - "KB05RbQUGGu4dFZ/4dr1S1s0k8iMQ0c/3HHyJ4SZEGLT9JwBrOzppx7hA1pKBJFiDLa/xmiLkY6Q\n", - "YF3uyaygBFW15shuGljXhZTbMSWm1uKxxlKkbpI0UdD64kFXCnLi6XSPmiwpnUDAYCdm/UxJBb9K\n", - "3r2759tfe2QavkXOFSkyJQaMsmQyWktyGfDBE6KmRosIlXhKmF4jRW6999I+vKWeiRlUNdhO0Nlb\n", - "lNny9uH+Y/+4ikBOLbspJdSYqakSq8DUShIJbRTSgiYRsyHmhsRSKGpaSTWQciPrTOPAw9Mbuo1m\n", - "7HbIkjGiRX+SDAglCOXA4fSaT6b/QPYK6yaYoMTEzk0NxpwD7+/fUWtqbABt2F7tCCHhfWiWQQHz\n", - "6QRKYe3QQvxSfiSYa60IgRaOdhbrNMvSnO7QuAfjOBKCR0rFPM/t2K7bqUFKgZKNJZpCQEuHEbC9\n", - "vuLx8REZEzEGttuJ4+FEN4wfOZwpRsZxIKaI0rIF+vmQs227NKk1JE2uimHsiTFwf/+Wl3evOJ7O\n", - "KJUxtuP5dOb26opcM++++hmlVM7BU3NmGCc2V9cc90c20w6hKvM8ozyQMr1qDS1rm/q4TclXlO4v\n", - "u0xBFQahCnFdUGGFWSCsacdS27QYpsws5zNb2/Mru1ucsnw1z5xLIRvNQGINz+AGpk3LKgtxJMTE\n", - "vEZOx5XcrjnJaaUfR7b9BmMEQhTm84F1c8vmxR1OmLa25EynDaUfeNo/XBYiC0ZSc4Es0cIhUUhd\n", - "sNpSi0RZgx4reWmd8ErLU5cSL2UHTQwLylme956UVzrdkcWC7iVGTLiiqaIgtUZoSfBLi24BH8Dd\n", - "7f4Yul4DGefMx0qyEBpotHlsAiGRJmF0uRg2//XXL296bizKGLTpuBp7ioyE8oDjmiwcaT1jXYc0\n", - "Pesl/NpNO7RS5JyweoOSezIQlkAWK5PucHagc4VPXmx4MoXj6dCO7FExrwnZVbJIjTCUmlSpVok2\n", - "I+vqOfoDvag423QazlpKDZxPlefDwt/++D/zW5+ZVndEUOqMlCu9SWRfsbZQqEho9KJUWLwn1orU\n", - "DbyKaoMHZS0CxTBsScnS2Z6uf0mVjp99+VNiXtsuJxRSTGhVESLjwxFpB2QoCGsopSURjA3U2Mjt\n", - "qUY6o3BaYYwiCMNSDHHNZCk4HB5Y5xUh2xGp1thABxRInqent0z2BZPZtTiPMbhh4P2bB8Z+CxSU\n", - "smyGLb/2nc/453/+Jw7He4ZuS+d6brc3/PSffsonX/sGr9+94WqnccbRW3WpTY4s67mJ8IRsP8tS\n", - "Wq71MgD6EHgvpeK6vhGPYgLrMKp9sErwuK4tvg9fvaHvJeN2CzE2WIZSnOaZzWb70QETQkCbRhHq\n", - "ur5JxXKlFo8QpimgqUilMMZe/izo9cgyw+FwYBgG9od3TN2WF3cvORxOaKfYTVODLitNkYqUM0+P\n", - "73lx94IcZmZ/wtiOlANaKmr94KsppGVGmw0FhYgRTKUK26RqQmA3E8IbalgpORBTahKYbkQUhZZH\n", - "SGecKtwMlqoVr8+efQxQBIO5wtaBoRvoXMDIp5YjTQurt/iTwMqB/spwffUJzmqqDEhbkRLu379G\n", - "a8fd9pN2v1wjOZ4pdcXYTAhz0/vW0uj6SJTgwlsNSN02Kr3pQYS2PxQaUxMxL6TadMBSiEsN0lOr\n", - "4GH/JZ3ZXOJ8zask6RrxSemW05QTMQRO50dKiVAqRlqkikguIjvTYMZVRBCy0RxUQRuL0xatE1bn\n", - "prz4RWvXf+O18V99VaVAWarVbMaJUjLzfCRXg08Hamn+E1krSYEnI0tE1waWrSWyrivzOTRAq44E\n", - "14LgqhNcOU1nenYj+FXh14qisqwLvWuSeGj05pp0Cy3r5v9pwb9C10nc6ojF4+yGOK+8fvuOkP93\n", - "ttMNuaxAArmiRcV2IHOls5UYPbFYjrFFTQgLpVS0SWjT3ogld030Rs/V9A1EaRW/V3efEjx8+e4f\n", - "qaWFcEG10HcnUCq2iJVySBkRRuJkAxBEfXGvi4LtLBulsFaQlWGsEKpAZkGqmTA/Q1EsKlNqbCqN\n", - "GttRKwc+v/8x3/jkN0i1w4q+xaWMIeUASD799BsA/F9/+yPO8xO77QbjWiXy5z/9CeO4JXiP9yu3\n", - "d3e8ffuWm5e3TNuG9bu/v+f25u4CDzbMS9stlJIJIbDZbNrRSim899jO4ueVGCPqAhwRVTKfZ3rl\n", - "uNqNvH79c9bTe7bTNVE6jocjoiaiDNirzQUPlsn5kv+knci0MRjlCGH+2ELi4vVOObPMbYrvuo7g\n", - "M8sS6PuJZVlBSvrBcT7sSUXShhIJrTQxBISsPD68Y7vZ4lNEpYjrOiqFGgPNrVoRKJS2zQ304S5b\n", - "tGabVIJcBNJOVNEhZUaW1MLt8xnVDdgXLyh+YSkHAhmtNRsHPgbOWaDdyOReYTC4qcWpqJlUA870\n", - "HO7PiNzz4u4ThmF78RK10xpyxasTb17/Pev8wNV010hBok2tMx4pK7YzFCKB3BIJuplVUQ19mIkU\n", - "EZqqmdafrykTc7nASTS6Siq1UaCkYhCCHGdiLJixI4aAsj1KdBQEqmq06jA2kPKBXNcWXS8zri+Y\n", - "mljXREx7ktCEHBGlqbu33USphaGTaB2bjA33C9euX9qiOfvAOAi0aag0aQxVah6O920abUZCdZQQ\n", - "WrCVRI0Lvd2SS8FHj0+peZSrIgVYl5Whg4JGqRbYNWzxIpFkowgtKZDw1CpRuV4UqRZNh7UGLSud\n", - "lm2yLjxX04CslV5qzsVzPj/zOjxwb+4xNtFPmqFr1O1Mou8UWjtqtpeL9sA+Fjo7UWqLcZiaEVGw\n", - "mUZSquwPR5xZ6eyOlAqQuN1cc55f8Lh/wNBThUaKFWsb+LemTEwKZI8o7d42lUwRCaEqVV44jbJi\n", - "KDizwQjLyIhRjrTu8enAcTmQNVgh0GS0MlAbBWjxJ14//Jhv3PwHyJZu6jjOZ5xUjN3Efr+/tHhm\n", - "NtsbUvE8vH3N6eQpJeI6SQyBX//VX+ft29dY02Ru1jpef/UVn7x6BVUQY6TrCtZYDoc922nHshzY\n", - "TLtLlbRdrdRakDajZEsfGC3pOsvhcKaUFS0lN7sbnh6+QNTCZnvNZrtlXRe0s5TcFBBGyubsLhm/\n", - "zjg7UnIGKdGqhdOtMeSU8GvEOsuynqi1Y5pGqJEUIyRaHXOeyWGl7xpBvGSDQpBLxnUd59ORUFa8\n", - "X+mGvlkwz+0B0Q0jqHafVz6AeJAI05BtKmeogqQMJa9I27KE+IK4eHLIiTqf6LRlGHf0VO7ffcUx\n", - "nniKkUNacWZCY1HG4cyAKJ6huyHnzHl5xJlM303kMGGMwvUtu1yyJKXK4s8IUTBWcDw/tgGKAEgY\n", - "bck1YvSFwCRUg6aUAAiybKcHmVdkrcTiUFXQVsmCEAYpt2hVkKpeNCAFrcCo0qrDBXLNnNcFYyZk\n", - "OCGkoOsbGyGXQpUeNwhysq1LHs6UvICUCFXwoZBqRgtahFB1SKGJyUPJVDKF2OKCv+D1y2sERUkJ\n", - "le3VjkRE6UqVkseHZ4jw8muaki8O7ViRFUiZY3gi58TqC7mAFhZyu9soXrAuC73bNAmV0mil0Bdl\n", - "bcqFvliCbUOUvCZCWAgpoVXHdnxBpw0+nZEyo3XH1c6ghCEnxe1oefde8e7xXbPuBUFBQE4waobR\n", - "0VnZuvI10/ctUnOYPdkLZG2hapEkgzPMS2AcJ7yP3L9/y6sXV6z+YisUhc4aNuNI8hljJ6o4Y1UL\n", - "+Qt1MXHWDySkTCqSKhoGLuXEWhLe9Qih2ViHliNW7VDSUI3hKOG0LOSwYq1GVYmWilRWlKzNER5P\n", - "rPEA2mEojLdb8v7I8/6JfhiJMTNNI09PBw7HB+5uv8U0bqAmzucZKTWkipWKzYUyNZ/OKKm43l3x\n", - "7v7ho+N8XVeMdg2EIhukN6WCUpKu69r3EwJrNOfzEeU0QlQ2zvHw8AXbaUQIz3a3Y55nUlrRuqMf\n", - "24NAFHGpLRaMdnRdxzzPLMvyEa4thEbUQq0CbQ0+Rs7zievrLafTzMPDIy/vXvD4OFOK4Gk9s5sm\n", - "1tNCzqBNm/RKa8gRDscTY99zOh6J/szT8YneTtjLsV9oyTCMyFqoQiCMo4hmapTSgVLUmlDaoeQW\n", - "crhANwAfyH5FCkHIgZzB1IzTlRe7G/LxyCmcieFEbx0URUyZcRD4NSIk9O6KbX9NTM+MVxW/Loha\n", - "qdpRirg0sTy5nMkl0HUdJVuir+QSiHFFyMYjTSlQSiXn5q5PITUhmpTUoghhRTnJKldqoRVXmsUH\n", - "ozqEbBVG45rihByoObV7T1EJKbWHtp3p+x4fzyBKk/LVSsq+VZnlhFaOsbviuL9nXj1aWwalOC8r\n", - "RkqMdnARNFZhyekEuhD8ihT/X6fZ//P1S1s0t71jUAInM70dqFWysZLBXrHmt1hp0aLlwFKudELj\n", - "bE/RGqrA6cSgFee1Vep0EY0XGSvZO2Q3taiGjE1BimxPMilwvSWnyiIysVZE1AhhsWbikxffYl7/\n", - "b+beJNTSNa/XfN7269Zae+29Y0fE6bIxU296bK6n9EpOBR0qgiIoznTiTNKx4khHIioIDpyIII7E\n", - "kYXDohLqChctb1VyzVTzZJ5zot3N6r7m7WvwroyqW6VZhVLogphEnNjBiR3rXd/7//9+z7PnOD4j\n", - "J4+2mpubS6IzKDpW/UBGcbe/ZXYBKQoKgdGC0hmkUAhTSKma9YRQ9L0h+nolzFIiiq7umcmTS0DI\n", - "zOJ2LP7vWHVXuCWQS0HLTGcU2RhSSRg91Ou9ol7btUarjiUcKTkTS2UD6kZgh4w/FqaiSdHBfKRr\n", - "W5SJGCFJQK8bGtkQikdJg5YKkSW2saQSaewaQuFweoa+6DFqjUYhhwHKwjgfkFJxWhzOjzx69ISr\n", - "qytuX33E7Caur9+mbXrGaWK9vcD5wIVSCKl5++23efnyJePk+NSn3mOaljdELa0N2+0ly+Kxjalx\n", - "MmWwtiOnQAiBrushR0xjCcmTYu2Jn05HHt88JmVwsdDKTGvrh1dyS/3gbDooVcXQNSu8dOfZaV0S\n", - "SVn70KlEurZhnjPLnLCmwznHw8M9xtQigRCa2SX61YrgHcEtdH3PsjiWeSHFwKtX+3OgO5FdYHIP\n", - "hEZj275GqYxita2JhCIqsizODqEkYtVRlKFkWUEdWSNFQdiEED3KSJILLLNjijO7ZeK0OIrQrPo1\n", - "hyVhVENIYBC42cEago8UkbBWM6yumdPIEu/IzUJJAp8e0GUGIGSHaSJWgNaJFCaEsKTYknJmXmYK\n", - "qna/JW++RyGCKHUZUx/eWpIrVU2uFcklUq5tp5Qine1pTUORid4KiAnvF4KfCAGWpbCEfIZ5zzSN\n", - "xbk7tLGVwi5bYFWp7EniXSX7bzcVP3hajmjTUqIgRo3VCs4L1uDBn+pGPabp255d/3aH5tqwsRql\n", - "Ftp2wzQJSpkYuoGS12gpKTERz+FkciblRC9aaAaiTgghiWEhqyoTKylhZE/2hihNdWAz47ynKQUl\n", - "ar5xju5MeIGmM0QKvbUY0SEpDM0VMc3sTx+ChL59RKs3yGLpTM+0VIoRaaHESD7ToJdTRKSCtZpG\n", - "9WdToMAXhzQWYxQJIEsEhpg0+8MBoWd8zsjjkb69w+qW6DMajZamwouVAvmt3jRQSl0mKNBKAwIr\n", - "WpSEGD1DbyF6Tm4ha0EYX1GUpIjAut/i00JIlSWpkFhjsabDKEGRlc5UdEIBIXscR6zqsM0KHyKJ\n", - "qhA4Ho5El7h5/Ji+37J7eMY4H3n65G3mecY5z+X2CUJIVkOL0holBHd3t9w/3HHz+CnzMrIsns1q\n", - "hVKKZZkZhoHj8UROkdbWapwyAuVqVEkBCPA5I5SpfFBr0aIjRWhMzcVaa3HecXGxxRVPDJGcEkmI\n", - "c/8YTNuQU8KnRCqFxiqkqm/4cVxYr9ZvxHBdV1MAuHiuejqUUCRU9dwI2J9G+qZFSUmRir4feHh4\n", - "oDnHifw8UjAVXK01XhliCOhhoOjKU61KiwzBo64eE6aAUpnsApSq/CVDDAUzbBj6LfnwgMl18TJG\n", - "KNKCaVBG1LZLFizzxHF8IBaPX2ZcsJjBYNuO4nvwBecLKR1JZT5j9gyZDKUGe3RDbeyUttKCZAZR\n", - "HxSSW5BZosr5aZOAGAwogZAVWVZKZYj6kKr8LRaSN1jbo3Vt/OUSydSki/cRHwUuZsS5Mmp0tZ9m\n", - "GRi9QGaFVZZuuGTVXrNeXxOd53C8Y5qPZHGkbwUmRIoKLMHVqBqCXCIhwBwliK5iJvkXQoj//3w1\n", - "RtI2trq1FRhTryddq/CpJfpIjo5cEsvoKWVG5IK1HVIFCglrDaaz+LhQcq1MllyQGESxBC9Rsiea\n", - "zO5wpJG6ysaspaTKEqQoYtrhwx4hIvMUMUbig6vzE6tZ3IGry4E4S6weuH6UOExvc39KhDATfSSo\n", - "SoXPEaKtwXNFi5WFqD0u1ANUS0k+b4rJCkGllZMnUvZMywHPiChQVIPVfUX3S0sphhQkQhWgAmV9\n", - "PKKNIIY6P7PyrE5NESNn9oeZEDKpLNztPmHoPM5XdQKxkPSZ2t73KNVQVyOBIjM5T0jbkRPcPbxE\n", - "bS24QisLwgjcMWCUZnWxIqXCeDoxz3rBPMkAACAASURBVBNX14/Z74/1aq1tzVamVH/EyOu7ez77\n", - "HZ9hca7WQY97Hj16yv7h/owKzMxThWGAwuiB4GfOiRysEqQUiH7BTROXF5taywye7eWWw37H9vKC\n", - "02nE+wUhJIfDEagHsPOOTisWv9D3PdJISrbgPTEEjscJrQT9sEIgz2MGzpXfhbbtz0+kAqUkh/2B\n", - "8TSzGjoW5xEUFpY3/fPxcGC1WrP4hRQyTb9G5IigHhBKK5J3lJwpfYcwinKcEclTlCGdTuimrU+h\n", - "WpLvjmiREDKjiudwe0Q1HY0qXLQNThbyIlmK5ubyMSFN3O33eD+RpePV/oHV0BKEJ5eGuHiCzwQn\n", - "id4Ql8DiHVJGyLZmhRHEFBAo2tUKJSoo2OiCO39fJQqBIvuICoUewGqyKkQZ0SrTtrrelMjEGFic\n", - "Z/aFwV4xzwt9K8hFkEWAXJdMQRRiiZVupiRDZxCi1DHTmUlh9JpW3vD46nM82twwjoHCxNXmKa1d\n", - "c7f7CCJ1dKUWBq3eIBVLTujGIpJliZ7i2297dv3b1SgHiyiFFALH/Q6UQYo621S6kEX9Sz2Od+wf\n", - "DjS6oJuMloZh3VFE1c9WUrdF6Dp7CdEz+wNCGUw+E2SaNaNxjNNIdgIRBVJJ5iwIUZCF4XZ/y3a7\n", - "q8Dd0uPdQnChXne1ZD/usFim+QHw3FxeINSReWmrkz0F3OLqUkValDQYJRBaILNAy0QKM2Ahq/NT\n", - "UD0UpU6ktBDSkRhqK4LikaUgSyKmA0J1oCwpS+KSyalS6XGJfhgw1pJivW5pWQsB7YWmNz3TtDCO\n", - "AhkHUjGcXKhPivFsNrR1xqmlBhxG1MZMEZ4iCjlZnHPsDrfotkFjq6DNtJVlKgSSCiu5unrKadwT\n", - "YtV7vP3k3TpfzJlH6zXHw4lPv/cet/d3XGy3xBh58uQtUsx1JGEMOUVOxwNaSWyzRpy5h1JCDg6s\n", - "psSAVpLGKFLwrFYrlE44t2CMZVkiTdugtSCEeMbGVfSe1QrvPBfbC1JKxByxTVvbSEBWgtNpVxcN\n", - "7Ror1HlhmM864umNh72x9UPh9vY1fjlgm4YYI+Mx0bYLfdcwrHv2uwNKKkzX10WHqX6pJASpZHxw\n", - "WL+gF08p1aCZRK6HQ/S1zFAKClCbgTQekbkgbEtneg73d5yWE+nsFh/6Lct+BOnoW9jtT8jGs6Q9\n", - "Jln2YzVLKmUR3hInRXQDy5w5jJVNmXKC7GsfW0jadgC7xk2FtssIFWh7jy+ZEBYSpo6/tCKWQCFU\n", - "nq/MCBnq+Kfkao4MicUlTpOna5+y7t7i6vKai83A5F/zcPyYEO9x3hFLg24ErTL16+iqjZFKE0Mh\n", - "e4UdejbdJYNZc3XxDoY9tz5wOh14ON0RwoJuEiFONd8pQYi68Gy7hiQKiBUsmRj+nYbb297ApPHO\n", - "czq+xjSmxjWyZNV3yNJwmgKHybM/ZYwKqDnigudSdEjRoHSmUEg5gqgCr5Qz0/LA5CND+4SuazHS\n", - "0A9bTjnivEefq15zEAQCKjfEOPH8xdcpV1DGW3w5kUpkmjza1GaJYiE6U7FtMrNqVjTaMmuNDxM+\n", - "LMScCalW7YRq6maOgsypBsfDRI6ZVBqUsjTNgNYFkTuK2ODcPT48ILMl5UTIM0JrcpwRMiHP1/Pg\n", - "M7M7YpWg0R297VFWsQSH1LkKoyRoC13pWPWXiLhinBwhSHwSOD+9oUvtlyNm2FbKs4ykkojZV1e7\n", - "tEjdcvKvsdIi9ROUMhiRKEawGqo+t1n1+HFkWWZKVjx69JS+33B3e0+32WD7DlMK4zgikqQfVgxD\n", - "V0lFxyPbq2umcYQMKQSsaikxcDw6LraX3N+/oLOWHD3ZO/quw5fMeNzTtIYQJW4Zsaa67Y01SNmz\n", - "WV8wzyNd2xJDOh+q8/8JORaQ00xjLYg67xv6LUIIgq9KjrbTlKzIudAPHYfDgRcvnzF0PRebK548\n", - "fpvd3QuCTwx9j5tOuHGPnwTTNJNzOi8pwCiLtfpMbm9R0p4TFxnChMiauHj0Zo2QiuiOqBix62ui\n", - "PyF9QtkBSCQqLu+yHfDPP+R2f8uUAkEuZGUoZUbKiaZzTOEViQPBmRoklwZjesRi8D4zjrA/OvxZ\n", - "QlZvbhFx1geHxdNqiRYFtzikWghpJJexWjdjoSRLxqOQFGEpSiAI6BjBZ1xQeFVdSrFIVsMN7zx5\n", - "n6vVu2zWG1a9Yeh/AKnheHrJ1z/6W57tv0orAkpESqnq7ywlzkkoKyAyzyPvvbWpbaaU+fx738Wq\n", - "7fmHb3pe3H5Y4eQsKF2hI6UkKIWURZXO6ILKNbJozL/TnKbPdX7kCow+oksGpdGmpVUXQE/Ojt5O\n", - "3JUT2SWkj7gQCWWh7zu0qTQcKRNSFGRRBCdIrJn8wji/5C39Do2xGGMQ66dod2JZqlrVipZpP+KS\n", - "xwrLsowclxcVwyUKWmlSgcUHjLYcdg/4paC1odEGYzS26ZGqQTqF0IpCQmhLKopQMklqgqMK1BAo\n", - "Ua+WQtZ2itEKq6uymBKxfctpUszuJShIaFrTn22UkZI92qgabBYWLTuiU3iZsb1B0+KnIy7O5/mQ\n", - "QooNio5UFG3TI2UghD2NjlA8lurTnuIeEQM5LUThESajpKOUE0I2LF5xmg1t09HR0nYtXdtjTYub\n", - "Z1IonI4npFBcPnpUuZ+7B7qhZ7PZUHI6U6cSw7CiH3oohf1+z/X1FdE5RKo0odf3J64uL5nmkZIT\n", - "W65oGo0WEENiPj3QW02jLe54D7LQNQNzeYAigVIhLTEwng5n5FxmtaoHXt32VjlYXUBFSkp0bUfS\n", - "mmVxtG1DznW54X2g71bEWGNKSgha27DMMyXfsdmsWW+2hODZHY4VxiIV0XuGvntTj00xIQwYU3v1\n", - "QoiazTTVWipU5UnqbkXBgjJgRM1r+hmtFeRQbQdnW0DJGZEzT5++B9ri7l8Rhee4vCblhcXvCGXk\n", - "dDrizn3xeXYYtaFrVlgJKRZyjvgUmZaEoiLmpDg7dUx1HJ3GIzEYusFTxIlCpKSFrDSlVEXF6EFJ\n", - "UwWFIuKSRFCgKIzsUVGAkLS6RciOEgt913GxueHpkxsarTns93g1crN9j8yEH59jVSRmQUianFqM\n", - "3dD1F6iS2O0fuHvY812f+QL5jHzr9MC63WClrjsI6asvXNYuegoCimZJsRKvSkZbyPw7BXZEIkEW\n", - "5pyI0pKlQsuMLJGL1Q0hSBQXhLXguf6YXBQlJUpSnA4FONL1PTmPGFMDbp0d0EqyoBBpYjpOHOwD\n", - "rTU0/YDShq7d8iBecHA7pMq0zQq3jLRSI3Jgmk8Mmw7vBdZ2KFWVwf1gQQpcmPAxUaymaxuMWpOU\n", - "ITdUgnjyGNNV8nZMiMZizIY5PaBVgVIoKEqpbETnHJLK8gOBFANGXTKKHRBpdEtOLa1tyTrjYs1A\n", - "alWXFRVsIRHRkEZV86xCkkPBC8+q7UFEIhFtDZKIFhkjEiLnKuk6I9GWIFncEZjRtlBSoVMADqkm\n", - "pO5I4YiLJ1rVMHQ9Rq6IxSMULKcaBVmWzGk8ETNcXFxiTUsKgaI1Xd9xcg7bKEJ0SKrKohSYjgeG\n", - "vmVZJtabFTF5jBG0tscoECWTcsS5E0oVUnI1UZEWpDLVWEpE65ZMYZwmLjYXLG7CNvWfeqUOWVLK\n", - "GFPjXW8iT/PMfr+naRpWq4GU0huqfPCR++WevmvP1sz6d6+FIoSR/W7hcntDLoK+H7i/f8BqiSgF\n", - "v8xo3ZBSoJTacJJS1+9TLoRcKNqQpT4TlASibWrwXguU6hBSIxKk/R1Q21LFO4qs4JkSPCc3UWRB\n", - "Nw05BlycuN+9oGstrdnQMHLce3az53RyrPqM3mikFZDO/nFGjLXIXFMORlukqDPwlAohJKQQ5HEh\n", - "ixkIZAFBJkgLGQe2xZeCKpm1tQyqR5uhjiMSZBQx1kSA1pnFveTVvaiEMK25vlhjrELOBecWwhgQ\n", - "sSDIWFmXQEre0PVPCaXOPjs78er2I5689R6Prr5AUYW2s1xfrXi03xLSx0SRa65ZZGJ25ORxzuEz\n", - "JPzZDJvPJLV//vVv5wgKEzEbtG257K5IOVLKgpaWrunJJSHDgm0MRilCiQg6SkkIIlZ3qGKxSqLE\n", - "hAoZGQSbboPNhUZdcZyPLPmOw/GBTf8IoSRGrumur/H3/4U53IJd0+aWrlEYOVQOJ9D1AqvN+bF9\n", - "wC8nstJEoSBnTJEsPqNtpu068uQQwtW8aCok5ShJIl1EN5aGgWV5XbvEMiEIpNhwGg8cJ8fQXtI3\n", - "HSUvFDJWDUCkby7JyRBjQaqza8UkUhpBPDCHha5oYIVIdbM8xkxCkUtdhDR2oTW1nTO76i7q2hUX\n", - "2zVQuL+/I+uId9Xc6UMgLjPWgJszpqmdfiMzQi/kotCmo1jNND1wOFSlriiVQCWFpu/W9MOatm1x\n", - "s6dRmaF9xGH3GqF1rcXqBpEj0S8c3EyjdPUmiVxjN3Ehec+6a9jvXzEejzy+vODV4YG+lQgJ8zIi\n", - "lOJ4ONHHTJG1kqlE3U5zBoHM04K19o2TSBsNpZBTdY3Ps6NpW1JM3N3f0vcrbNvWLf0ZNt2d5W9K\n", - "ZdrWIpUEHXC61EP19R3DaqCEwFs3lxyPJ0JShHlkiieaRqHRGKXxbq5e7qahs7qKxUyd1UqpiKke\n", - "foWCaM/he+ERTUvyHt0aiqhzPZECx2VknE+83L0mGkFBsrhYYRrqCoWl1VfM44Hd7oEsOoRYY2KD\n", - "NqW2kETBohhLFewJoVG2RnwMFkpBSYUQ4MORfI6DZxRRxooaTQqlItdNw+PVmsthwDaSLAVzgNPk\n", - "ObrEcfKcUm30lfLA7vACNx853u94uVGYznKYXvL89h+Z3XNaEZCl7gckgBjJZa45UuERJhCOr/i7\n", - "r/3PXPcXyF5APBGCQ8tqQ4gEQGOFRaRMSaEWHtAI1ZKjQxlRuanf5vVvdz0PJ6Rs0KahbVq0lrip\n", - "QaCwpgEFJ39kH1/SrQXaQXKecv4ETOH8jywXhLFI4wHP0GoGtcblhq7tmZLG+z2H6TU3209hZUvX\n", - "bXmL7+Qfnx1QYkZbjdEdnemQMhNyouRSJV66buL9NOOWisQP2RNzoDNriO1ZfaHIxaAVLDEzLuNZ\n", - "2FZD901ziWots9tTyvyGAF8yTNOEWwpldQlQ65lCVqmbttj2gtM0VrhAUUjVsuo3iNJyyrecxiOl\n", - "hUb1VVtRMt4Hiqg09NRIkq7UGe8ybbeisxe0cottNa26ZjzesU/3BALBVSYnQ4tKESkbRMmoJmLb\n", - "REkHXFmzmyJ5dPXJRGjcOCGlYXt5jdEtPsSq3W07Lrcrnj//JqfjkSfvvQcKopuYjvszqXtFSZ5C\n", - "FXAe9g9Ya1itN+weHhASrFU4vxBDJGqJ946MwDYtK0TFi4WA0uCj5+pySwyetqnb0BTDGdYAzqeK\n", - "CHSeO7fQdT3OObp+4Mlb7/Lq9UuO00jfGPq2Qcq6aJOqRl4QNc8aWBAZjNU0na7Cs5TY7x5oVitk\n", - "yIhgAM8yzmiRSUnSNC0zdRHTtpG+ZKQSFFXfwMYoUg7ItgPbU3wi+wVtDUptIEdozxoQkbFNS7zP\n", - "HN3Ifl6QdkXfX7FeCkaBLJmhyWhtiCURYoUECypAJlMjfNZYErqOnKRGK4kSkkZZrGjRQuPLTGMf\n", - "M3mJW+5IsiYUdJGs1JqbzYpPXz/iyXpFv24RMnBYPHcnRwiB3RRZ/MJ4nPB+JBVouxZ1+DrNKuOO\n", - "EPeeyb3mxcM/kHJgZQ2gWfWSlBYSHb19St/0nEaHEBNN43jYfZ2//+Z/5en6RAwPhGhIImOaNSUL\n", - "/LmymZLCqh5tFBEFUpGwCBOqR/7bvL5t9P2jjz7iR37kR/ie7/kevvd7v5ff/d3fBeDXf/3Xeffd\n", - "d/nggw/44IMP+Iu/+Is3v+c3f/M3+c7v/E6+8IUv8Jd/+Zf/7NcOIZKLQ8hMzkv1nZfMen3JdvOU\n", - "pzfvMQwbRveMdhVYXRT6TcB2ASHrFSfFRAya6BRSdPVAzbAeOq5XF2yGnuv+mlV3we7wCgFo2aLx\n", - "PN58iveu36czgraVaJ1QytVIk9ZIaZGy5v+ktJTSkuJZbpfALSNC+/N1t8GqeoCWIhEFZJa4eUKT\n", - "MdpSksKaNav+hsZu0FqjZe31CmGYp4UYCyEJTvOMiwVEAwi0tFjTEuIJpQsiG6zoeXz5ad55/AVW\n", - "/ZaiPBMHTmHP4mfmZWaaPYsreJfZ7w8cDjvm6cBht6ttotRUOycN7z39Tj799HNsGougkqXisuBO\n", - "keN9rp4inyk5ktSBOd/hOKG6Ft30zC6wubzmydNPMc+eh4cHjDFcX1+z3qxxznN7901W6wuG1ZbD\n", - "6YG7F59gDXSdQYuq2kjeQ6r+nq7rsEaRo8cIwaprefHsI6wyiGSJMRFchALO+zMyrkNKQThrNZSq\n", - "nX111quk6Dju7vHzEb+csEaQUw0/q3MmtqB4/OQduq5nvz9wGkeUrmizGCO7wwEfIz4EcoL15oKH\n", - "w5HddMJ2LaJt0P2a3etbxt09IUfW6xUXl5fYvieWwuQ8Snwr9F0oySNLQJQAGpLpKcMlMRnSNCGp\n", - "+DhhWlIRFVySHFIXomlo+p533/4UTy4eY0zl0gbXsu4/xVtPvoNOX9CZgb6tbRmtDcfjAURkmiZO\n", - "y8R8vu73tqXTit5IOhtoDRgJuhSsFGyaLevmKZerz7HuHtOkjkH2XAvLu7blbWu5UILWSkRxhGnB\n", - "jQun08j9fsc4jZyOB+bjgbwkmiKxpUUjmdwdiz+yLFNd1MkGpTRTXNiHPTv3QFAW2RhCmXBhR9s4\n", - "lEooJRlsyzc+/irf/OhrfPTqI54fXzMGWK3fZbv5LEZe4JxEiZZGrmjyUOfz9DR6oATx/4bT/PZP\n", - "msYYfvu3f5sf+IEf4HQ68YM/+IP82I/9GEIIvvSlL/GlL33pv/vvv/KVr/Cnf/qnfOUrX+GTTz7h\n", - "R3/0R/nqV7+KlP/Ps1lxhZtmdLfgXUEWTQiRt578B9596wuUsuBS5sNP/jPez2hhSUYz2oCbKqHI\n", - "O4cxliIbsrYYJfDeE5zHdtC3A6fFMTQXqAj7/WtWj24Yx6W2ClJDay9rdCfkSvEuCylT4RpKkTNo\n", - "qWh1wyIDIS7YViMzhDDRdT2GprYTvMQvlc0nSsEKj3Mv6e3bKDWgTZ1P9U3H3eElTlbfjRCgVY8P\n", - "lbqT8j0Pty+xb71Ha3XtKDeKcYEYj6z7CyQNiUzXb2l6y358zuLuoHi6ovEuMnuP6HuKbmqQN1Uw\n", - "8TQGXvARZMl2dclquIQQWA8DJT/Gzffczo7jMiNkA3OkbQqrZoVSGm01OSRUabHa0AhLc9lQfOD+\n", - "7q4elo+vaZu+1lml4pOXz7m+fsJ6PfCwv8UYxcXVJdN0QEpJ1oZUMjEFvHdcblaEZaZvLG480VmY\n", - "TgtuXhj6nlwiKUPKmcOhvvkzXa2qJgelAmbHVJdPFXuSaZuG1bqOKhLgfKTtDEZZlNFEIjlESi5c\n", - "bC7Y9APjeOJ4mtms18gMGs04n2hNSy6F3W7Per3GTSMvnz3HGE3TWpRWzPOEpFCyrebNdsVqe1kV\n", - "Iqo635XW0DSUosguIMWC6K+QpgoH8zJRlrlqCbSEvq/+7qUS4LU1+NnhxolPferzqN0dX/v4GVoK\n", - "TuNIDg2d7ZicpzENmhZkIibPi/sXFJHq6MoKQvS0ZkEbRUaR0SBnogiEEsjyknVnKdFik+J6/S65\n", - "uUC4F6ysoMkZ5yIPuwPTMqEk7JfC3Tjxej7x4E64OZJDYtMKBivpO0XTF2g8BIjygAs13VECxKjQ\n", - "RuG8O2+7Z7aXAypIlATTSvQIRmmy1bi951n4BkJbHt2sgQYtOnLxqDKh5QLOIYui0R0uOiKe4AML\n", - "GlX+FcCOp0+f8vTpUwBWqxXf/d3fzSeffALwxg74f339+Z//OT/7sz+LMYbPfOYzfP7zn+ev/uqv\n", - "+OIXv/hPHJpbZp84+D3W9oQFJIahWVdBfFpYL9W5nZR6046RGlbrBqM2LCkyhxlphor3EpqlJJSb\n", - "yMqCsIAi+oLWAykVbnevkbmp4XEkKvYIM5HkQhARce7OFmS1I0qJwKKlZm0vEGEGlSgKYl5IxTH5\n", - "U53uiHqlL99CTmmDY8L5HW2nUXrAqJau27Beb/jG65dM4+35qtdiTIuUVQal1YlXt/d0dosT1WNz\n", - "dXHJcXpgnF/RmiusuaKcQ75XF29xeNDMp+fINCJUotEdRl3TmB7dZvan27MHBV69foVbAqerK1IJ\n", - "NKrQt1DiXDvaoiW7QhG1wx+cQkSNRmN1vY4XH3DRE1IkeY/NCmM1Q99TsuB4PNJ0Lc+fP+Nie0Hw\n", - "mXEckcbw+c9/jr/+27/h6aMrcsrsp111YC8zq6ElZ0PwkcM+IygYpRinkbZpWa17jscDQhj6Vcv9\n", - "rmC0rhSc3rJarzmNI9oY/DRhbfMGnpFFbWV1wxpx9svHDBAp3iEbQ46RFCLj4YG+X3FxdUmIBedm\n", - "tNL4eanlCJHIIp975NWImbzHjSeWKb+BYecYqlObgrK1hWIaSztssNpiuh7dr8lCIa2mNC1JCESM\n", - "KK2RwwXFebI/wTzXRc/1DdkH1P2O5eEV47Tj5e6WsOtYUmRZPHPUzCGw+J6SMiG56tRqMiUlYkzM\n", - "yz0+JhKZxjYIJRAFAgUlGwodStcMtRCKJR5psqRrLCIYNGtK9ljRYUUmBcu0X7gtRxyZLDPTIhlT\n", - "Yi4LQTtEThgtuegaOhPZXGhUA15kfKpqbOcL0StEbpFZE1yocbsEh3Jkt3/BzUoipSbHiCSQvSN6\n", - "iE4xlT1Stmw3M/msKslE5tlV93yWlBAJFBYSQUaibRBpg1Hffmr5/3mm+eGHH/LXf/3XfPGLX+TL\n", - "X/4yv/d7v8cf/dEf8UM/9EP81m/9FtvtlmfPnv13B+S777775pD9v79SEhi1wvsRNweCz6iSaZSm\n", - "1ZpkWhSCea6aValVte0ZjcgtBcNmteKqeco8T1WwhKIYSZQGtzhyWPAkQgo0XUuWksNph5VbEAJj\n", - "11ytFHeHbxBZcHmuaLhcnT/ZjKQEgS1aazZDz0Zt2c17TvGOKALLcsZJFw1FoduGWE6YojClkLIh\n", - "5SMhasQk6C+2tM0Vq6EHteE4ThWSoPSZZF5omxXHk2Fa7rnbPVA2a1IUNI1ECc8Sa5DZNjPdsEJi\n", - "0Wrg6fYRi+p58fHfgiv0ZkU7bOmGC5QtTHHkOJ8qs9IXdrvXTPMDBsXFdnOe9QREm9GjxCpDSB4p\n", - "E3lpKX5N9KDNiFEQciDm6zr8lxXV1qw65tnRdoqnT59wOB5RQvHq1Wusbei7NZ9+99P8t7/7GtdX\n", - "V3TdmuPhgYeH1zTdmuurS8iRaRpZrdbM85HrzTXeBwBWw4qUMlKqs8O8sNms6due/f6OEEGZHtsN\n", - "hBAZNmdVbIpIqzDKAoJEobGWzg71piOr/iLOrt5glKZvh7pYGyvbVSnF8bDDLRNWVUtmEYKEYOg7\n", - "ZlFIOVXqjq85wKZt8E6RSr2xaCUxuuaTtTrSX9yg2w5t69LHLQt62KJNDwSyc8hmjegNqlXgM3He\n", - "IfYH5OYKcWOxsvDJ6094fjowLq/5+otneODF7h6Po/AZTE4clyPOzyi5YLRAqkxafCVoISg5k4vk\n", - "NBXarFDaI7KCoklCY3VCNgdOfkY3BqRkWU40IhFFQUjBROGYIsfZMecavzO65iqNiBiR8aIS+41J\n", - "dH1Bq4RUdea8uMw4TixeELwm5ojRhpAkUjUEqWhE4vXtc4gnNufyAX7EAKdQiHFGiIAgcnf7Tebh\n", - "KTkmsnAc3T0XKjMYDSkhcmEUkalE/KK56a9Q5w/Bf9WheTqd+Omf/ml+53d+h9VqxS/90i/xa7/2\n", - "awD86q/+Kr/yK7/CH/7hH/6Tv1f8M5ilGucwqLJhXgJSVoxULIXZnwgxMs47Rn9A5IJoBFYKrOpo\n", - "9AUla5Jy+HikGQwlJ4zUGFVpLjELvJ84TntciVhf2GyvaTuDygqjNFIolLlgaJ9wf5gpeaKQ0BKi\n", - "jPicKSrSNnc04pKuu6YdOuSomV4/4L1jv7xEiRmp1hQSF72GkBBSMPuCy4IiMzEsRE40/r5GqmbF\n", - "oK+5uthyFw+IfCLnBiE6rOm5WN/AKfCwu0UJwaShT4XMVNWj/sjD8ZZtepvt+lNArZBerD+DfnfN\n", - "N/7xbzkd9vSPFG3XYVtFGwZkuWP2gbDEimqTkte3LwnsWPIDxobqZVlBn0ut1eWIEoWUFX4JFH0i\n", - "qAUtH2E4ouWKxqzISXF4ONK1HfM48Y/jN1BKEkLNOA7DQD/03O3uiTHR9xd47xjHIymW6q0uha7v\n", - "OR12lcK/2WJajVsqjs1acz5AyzlHCU1T42TadmhdAc/GtpWsriD4hGpqx9jljJCSMHtcEEgRUUbS\n", - "2aoqISWCd6hGUHRD3/QIUcHSylq6bgC3MM6vMUWhbIekxTkwZ/p7CpZiAinX5Y5pC877c44XbGvr\n", - "QqoURM4IUkUgCkW7ucaFgC6JTINIB3KYEHKgytUGlFmT7j9EHl6T+h55ec3b/+EDPvzPf0mW9T30\n", - "jRdfZ4wTRXo+fLbQiQaXAofTARc9UkuESNhVwQSNVBaihCxQtuaJBRKp2krRChmlIlLOWKGZ/TdJ\n", - "cVUXSrrGvJacOYXEXARzkYRcMEiKqu0+qUvt9KuEVpLcSGZZKusgBMZZMB4i4+hZXCb4ephmW+f7\n", - "wibSmVOaReRwuEOkiU27JkYoUWKCIMflHMWK+HBifviIlBNKZrTOKFtvCaWJpHi2N+RMYw1Jefru\n", - "X7k9DyHwUz/1U/z8z/88P/mTPwnA48eP3/z6L/7iL/LjP/7jALzzzjt89NFHb37t448/5p133vkn\n", - "v+5/+Z/+/kxoVty8teHybUuKmcU79uMB5wOH/S3eLbRGMS+JqDyLFqykp2kC2mRC9PgY0CgKgZjP\n", - "V/GcKRJO055AJkuDcQeU3JBKwrYDOTlKVhjb0OgLpjlgZQ26mk4QvScUj0gBGwXGfpqhu8Z018wh\n", - "8PGzr1AIuHjEWoW2mnlyaJ2Q79/8sAAAIABJREFUWlFK3WA7F9A6EOKBdB9ZNY8QZUHogKKwGjqS\n", - "DxSxME0FpSqceD0MjPM9u+MrtG6YXKaxEOJCjgHvPR8/+wrLTeDJ9feizUAShmb9Fk8/2/HhP/5X\n", - "9tPI6skVUjWo0lBCIXldFx8CSpbEUAizplvdMIdbpAjIRtFdaeJSmGeFNgNaX2MLZH9PbAIxHxFR\n", - "I1WHDoH5NLLpB4KvxCI7rJFS0RlDTInt1TW73Y5h0Ogz3m3dN9w/3LHuVmy3W3IOKKVYbS5Amjdv\n", - "vNM4s12tOE1HrG3Z7SaGtUBpzeLmKoQ7Pw1qrVmcxzYNIThs31XVcvJvspdNq4gxMR5nZMzAiuAr\n", - "EFcpW+G2UnI6nehaSzM0zKfT+f+rp5iEP3n6tkWYpi5nlqX+mecWUUqVFamVRtrqPEIpUlS0bUvX\n", - "dRUknQRlWtC2JwuDac5z2W4LpiPsvokpGdVsyCkjRQM3nyGPr1DffAGtojOC7/v89/K//M3/yn48\n", - "sJ/uSCS6wfIwP/BqzggMi3cou0HKUkc4rcVgKElA0JAkWRZEydim5leDK6QQiaoQVaAQSbZCkqNo\n", - "WChY1ZEIeLHgviUIjImYqjCuINFZo4yg6zLyXPcURZC9AxJ+VJyOiekUWXzVGIuUEHhsX53uPhRC\n", - "dCTVEMicyozKLQVFzJVQZa0iJJDKkDxM4YQ6j6W6tUXiybISx6IUuCXx7Bsn7l7cncE16l9+aJZS\n", - "+IVf+AXef/99fvmXf/nNzz9//py33noLgD/7sz/j+77v+wD4iZ/4CX7u536OL33pS3zyySd87Wtf\n", - "44d/+If/ya/9H//TBdoMIAzRC5YyIZC4ZWK3f4VLidP4gJERYwaQmhgLlMQpnghiRpZEKgkfDEZ2\n", - "CJmxskMKgVD1G92te+bjHdnMFAwpC5Q2zEtAm4aSJBrNevUIqzuaMjL7W0optZonagth8iNZjBhj\n", - "sKbn8fXnuL3/iHk+IpVCSiAJ/OJIOoCqylZRIrJJYBw6K0JY+Prz/4bWF2i1QPEY0RKyJ+WZpjEg\n", - "fKWzF8WFvWI8LpymhRAKMcqza71qZmMuPHv5dVJWvPP4u1D2hhI1Gcv25m1mvyOETG4ljeggW6L3\n", - "xGgYQ8SoHtE0ZG/IrmBMyywmRPFoCbLJaKno+2s60dPrDi8Fc/gYKffEPKBLICRXXeUkxnlEK8ug\n", - "NSllUilst1v+/u+/xv/wwX/if/vf/5qbx49oGsXXP/wqQiQutluM0qjGsj/sePzkKePphDEaHzJN\n", - "P+BToghJpLDaXOCWTN8LSnFI+a12jSblTNf3eOfQ2iCVQWtbI0kxYVqLDxkpC7KVtEaxe3jgYrth\n", - "ihGEZokZOZ1q9p+M8yNWGkpJBDKt7VndXNdyQdOQUgaqpiPlREn10Dge9nSdRat6GwolYDVkXfCh\n", - "epKQVG6mkYgYEcaC6Wq0SWqay7eJ+2fkIjFdS+aeUnpUs8V3B+bXn5BVYcyF9XbL48sbnt89I4hY\n", - "87O6oGxLTj2rvqM1LcZKpCq0rcboqu31k4JiaTtbCejLA94fmVnwpTCeIsUrsA4ZJ3Tj6Lp3adUF\n", - "OUHy4P2eafIsLlTsosi0ItF1DcZUkHbbdKTkKdmjlCVlT05VCZzzWe1LzQbbRqI0lXrkoWk6vPPc\n", - "LxNWSfrekohIlcgxsyQFyPqEGjOpVKhKCrXEMC9zfZ+KQpGZOUNA8vZ3XfDZ/whXqwFjFV/+H//h\n", - "X3ZofvnLX+aP//iP+f7v/34++OADAH7jN36DP/mTP+Fv/uZvEELw2c9+lj/4gz8A4P333+dnfuZn\n", - "eP/999Fa8/u///v/7PX8cHqgazyStnqJiyXnzBxOPBzu8b6a49Z2i25XhOgJYkHkiBSRJXiS32FV\n", - "T/ISZMQaSaIQ0gzFUHTLoK7IMjK6Awy26jCo/VifJTFmerNiMFcQJSVJlPUUuWBkZSDGVMgyszu+\n", - "5mb7HeTsaDq4ur7k2e0BXQSkSoHx0TN0kjALSiORsqX42oM2dmBynslNMM5YLek6Q87pjLwCY2oF\n", - "MJfIsLpg1fXEdebFq5fs9vckqVFaVeZhiAjVo2Th7uFjUg68dfk5OvUIUsCIguk2XF3cYGzDqZko\n", - "paOkhCaz+MDt/YG+axGy8iBLzmRhEDoQpcen/4O5N9mRJMvS9L47i4gOZu4WHkNmZHcVGgTZbIAg\n", - "9/UC9Ur5cmyuueGAZhWrKueIyPDJzHQSufPh4mpGc0EmF6xGpgKxCSDcAm6qovee8//fl8EEcHdb\n", - "oLQRwEYwtoMWWi2IKijlOa0r5EY4WJ6fX9jvd4Qw8f33P/DNN1/xL7/6B5wZtbrf/+636F55evyC\n", - "KUykkoiXiHOO82l4eHrvtDr6zxWF9YOwn9KfKDhlPPy0AVWJMRKCxyjLFAxVOmhNR4+5dqpM00KT\n", - "RK6J4+MjedvItbHFhJsCKW7Mflyha9koKJYlEHNEofB+wqBBm6ESL2UE3YWfuJzr7UzcVnRXPF+e\n", - "cd4w+YD3E7pXVM20nPACm9Ys+wfcvEBwo5LYG6bcEKVR2qN3T7TbiaYKegoYSSgtuG++5eVy5nb5\n", - "RHKKj+cX3p+eMc6B8ij1pwi6IriF4A+j666G/91Zj7dCr4ZpWjDaUWrGs2daPGcacdvopSC90BGq\n", - "BUO8q6UjvTukz6TYiWtmjYlbTIAaGpHeQBvspLDOYpRgldAESu3kMmJjIhWrh2TOK8+Wr2g/44Oj\n", - "d0gxD0RkNqzrOGA0SXTRzCEgTci5YJpDzDQQcn3g6FQVaImWhZsWrlbTZLy37U4IobMsBh3+v3Oa\n", - "f/ah+Xd/93c/gWH/76+///u//3/9b375y1/yy1/+8s/+UBj94TWfca7RdUfZPVPY0ZtmXdOgU5fG\n", - "tz/7D5SWOMcLyDO5faZTQBlogRiBJkODII7dsqO3kb0z2iJFcVy+YL87spUTWxQeDwGjZ2IWrLe0\n", - "BkuYmMKe9y8nagXXDeLiiGMoj9SNy/ojn86/Yjd9Te0NbMM6sDRaavTqUf1AXDOKMOaAknC8xbUZ\n", - "b2ZYAiU1aio4PRzXa7xhnFB1Q9kNq4VcGofDAY1i8hM/00/E9XXwIIvCujD84UaYvMd5TS03vnv/\n", - "jxz3X7OoPUYV/Lzjq6dvyaWx7TNbbKOrrAf8tbfKx+dnphmmaYjbylapJmG9Gg9lo7nF75kWsGqi\n", - "S7yfrByT93QanUatCaMZyYIyZoctJ7aSsNrivef50yeOx4Xv//D9eKMz/j/WbeNhmpA70GNZFkQG\n", - "kLjc2YcpJXbzQmmVNSWO+x3WG0KraGNxrt/9Phq/hCHOy4mmDH6aUDagm6F0jbYW74XaKq11LuvG\n", - "ljPv3r3BaMvlcsW54aWfpkAscq+0Dr1DrfXuENIoLeQUWXYHBMXL8zMljQ/eut0GacvNpLjS04aU\n", - "GakJ3x4IfiFMmVJWbB71T6MPEA7UeMVsK6IEtV9wDwd6LdTSMLpBE1CKL56+5uX0mc/PF7ZaWePG\n", - "tm5k08fpTndy6TQuI6tsPbkrdHXEJOwmhcjQPEwTYxstg7+QbhVaweiK6hX63TSqG0pXGmdiHeSt\n", - "XMqgcNVKz5mm1MjQWs1OHCg3oN3ajB5+2oh5wLp7qzjlRvtIKczkqBIQGf1w6dBqZ70lau3EaMip\n", - "4/w8yg73IH7NQ7ehlEFLH5BzaYgRck5ENKkKa804r9k9OoKFJSh2wdFaQ1r9s8+uvxwazjnS1kg9\n", - "YnxAKBSdudyeqTXhvCXXCBicmXncdVo7U7chdO8yqDG9empLBHugZ6EmjVaanM8Y0zFuR68BRWPv\n", - "h7K2l46yDW8tpVWsbeRypslGqRu39YRvCj9BZ/ws6xXNVT68fsebQ6MVR+sJa0H1hCh/Z2R6qqgB\n", - "WK0VVEMrQ6qdXirajV+msyMEj3SkN1rLoDOVCIyt7JY7x/ln0AXvK7/4m6+haT5+PHNLV7putAKH\n", - "3cRiPF51bmnlu+//Tx7nRxYd+PnjE856ch4PumYTfVfQSeMFUBrnMqfzZ7raY6XR0PTKuAFg8NOM\n", - "85q1vqfVTlkFPwV200RRrzg9I8rRm6XVisWQ8joUtL0R48qbp2/44YcfmCfH6XRGKQaiy4wrdVdw\n", - "Pg/n0G635/X1xJdffjWsj6fCNM+gFMoYKH0YI5WltIZYO/r3yoMa1BqAJh3nApZBaRdtcEGjtSPX\n", - "BsqwxZUUE8q6oQ+uMiAgOpJK5jDPpFqZlpnSMlPwo0mj9D1/fIfzKsWnjx8J0+CZbnFFeufh+EiK\n", - "ka7g+PSEFY2x5u52H7cKYYTzbcp4PyNxRT407ONEV51WNkzuML9BGY1uGz1HdBXaNfHx40fEzuS2\n", - "8Xx5j5squ92euD4TbxFo1N7RVHK6jat4y+RcoQq73TCCauUIITD7iUU5ZgsiJ/SdhRlQZMbcV1VH\n", - "T5XSLoia6WLvDSM9AOJNUAq6btTauW0rNozigWqVmjI5CekOTdm2lV1YkO4IxqCU5rAciCXS2jDK\n", - "tDb+yalTSkcpjXSLRsi5k3sbC0Pt8C4xW1i8wUil2g1RmtOlccvj2h72GvyKd37YTdNoJ7X8V4qG\n", - "c2FHrhfAUnrGGs/pdObhcCOnip8VKZ1wxtEqxL6CgmnxQ78rHdXGcBelqNmA7dziCe/f0rumcyNY\n", - "cO5Aip7SE95CSRWhIDqPq5WFLV5ptbKmZ863Z3ZlnGSV7gPApRQ9Cj5ETrf3g7zeN4RBnDEujU1c\n", - "H5zEIh1rhFYrNXYOh4mSIg5Hr3chFgOH1824iqzxmUwgeINqhnW7UQ8Nz8x+djzME7vpHYf9O/7w\n", - "4+9pl2eul/Gh/+L4gBVFsAe28+/59OkHvnr6hiadmCOlFc7XDzhT8AcLixpX3tzwzbDfPxKmHdIL\n", - "pDNUQy0a/7CgWNjNe1p+5fPtA7k70mU8mGpfCbawVw5pFmMMPXd6r9SsaGosdq7nC252XC8bxhiW\n", - "ZRhInQtsMfP09oHT+YXH4wMxRnIuOO/ZSqcINEA7RxVBOTs6/jLc7uDoArl1nBvE/lwaunQwmi4G\n", - "Zx3KeLQzpFTv4xAhpcYWV7a4skx+LKrmiS7g7IDS7uaZUitGxod88iOS0nsfriYUSltSSnz3u9/w\n", - "b//Nv+Hrr3/Bjz/+BnTjiy+/wpiRJHHO470bD5SaENXJvTPZUVtsqaD8DTm9EqNhevcNHWiXFeff\n", - "gJkGV1QXsELKkefXD7zPGZlHfXQrG4kbpd7G+7s7QJN6YgrDytNrQVqktsjrueOdwXrNLVVs1zz6\n", - "Pcl5TBgYD20K2gjkgbpDOYIa8jltB8XeaI3TI2/s7EZXI+erlIx54zZKJaWPU3LrkLeC6IW0NqR0\n", - "Jit4Y/B6HC4SlpJBRKGVxehxeh6KZ+550/GQa02Ry8C8Od2Z95rFrrQ7sT/eOi0Pm6qbFNoPepNS\n", - "jVYNRSlqG4zOP/f6yz005wesFIx19GqpqXLcHXF2QmvL+faZ18v3iOlM7BFtx8JFZjQe4xV0oVHJ\n", - "pfJ6+xGjHtArHB8LQWucsmxboZYXlHioig0hx4gJjU6lScHaDe8CMa+IGTf/2iupjCFyF0XXCgPk\n", - "2NCS0Hp8AJZpJsWI6Z3gFKVrRDtKL3Qaxnms7uSWsQooFYWjNQH00AAohTUeJzPxDFkrdodHLrcb\n", - "f3z/ax53C99+845vvvwFD8cHHrQhTI7+u8Yy7yFXelcYP0LM+/2BXDK5V9a0cr48U6VzXj8RwsDR\n", - "YRgf5GaQ5Hk8vkOapddE0itdPL2AlQVd9uSbY3ZPvNnt+fj8StwivSd2e0tbMsZEFAmn92ith7iu\n", - "Fba0sVv2LHs9xFutsBzH0qd0CH5mmie2uDJNM1uM9AYPj2/oSpFKHw+TpihlXL+rVGwIpFrR2jNN\n", - "y/jyFI3xI8NrrMXNilbBGwvaYZyn3Te71lpyznf1wn+mqJ/Pr6ScefPmDet2pbdBRSqxsJs1LXWs\n", - "1njrEOnEmO5kp8jkA61XfvzhD3z19dd8/fW/BaUQ1bB+GuZJ7bHOjcC+M7h5ZpoPzMsB4xe6UpSU\n", - "MRpsTNRPH3GPj8jjI42CloluHmii6Ndn5nnP8eGJf/iX/4Xn93/EmsZuObClMyEkSsuk7LDG4OyE\n", - "NdPYWDNcVUggpzxywKKwNhCmGcGSRWFhLGiUGspd5ehFE28VoxacdWA9AjQp0CsKIdgwyFqzwnlF\n", - "CBZnFBpNbR26RpthfC250prmst3wjzO5dRA9mBK6k1MdOc5eB63egg8WYwVQ1NIHPakWcrYEzVh0\n", - "6UZxnRwza4VbKSQq1iumxRB8I3hP742YKq1rRCzS/0rJ7U077HRAq8zsZ3KvfPH0JUYpemsEtZDi\n", - "iDCINzgmnA/jgxRP6K6xxg0Ule4om1jjCxpDv67sl4XQdhgZbMRa4sig94G50tqOrZwSWjszzxb6\n", - "gJlao+mtUbvQRaFUgDpIKVcK5tHjvdC7EPzEbgqslwgWKp6qHOZ+klB6DMOnMLGbZ/J25XrbqAXQ\n", - "4CaLNwatpmGvrBOaPb3N+DlRz3/g9eVHlnnisMAXTzPHnceiua4nvn//gd2bA1MIeOOJsWDCwu4h\n", - "Yr0CW7mtz3QVWKYv2C2vxPiKnxpOCcaD2x/Z72YkG3pxpO2EC4qmDfEcMfOMrgYzWVrzLDaQ1Hu2\n", - "mDFGoRVUK2O2qTu9ji53b8PvPc0T5+sz1gbmeRlRkA5Ke9Y18fbpie+++z273Z7gw4gN+YnaNKVW\n", - "pAqIHle02rDmDnVBsN4Nin8D6zytgzaGLg1hxMmUsQgWZfRYggUFfcBMjDFsqRKWHefbjTVVpt2R\n", - "VDo1VXoflUolQtwi1mpKE7yFECZqrVwul9GDr5Wf/+xnbJcTeUtMjxPGegwd0YpcK34ariitNdOy\n", - "sBwextbfW3Iu2DCuyD2X4QxPJ9qm0buvIK6IrKjpAWccEma4PuOsHeOTlyHY29k95vgLrK4oc+GG\n", - "vs8y1RgnyZ3VgB32RV3Gybffb0DaAoGtZShCVwXNAMH0IujukdIpq8YuC10P1GGTQuuDNWrQGK2w\n", - "QQiTxShwWg0zwjTTBbw2gGeLK70m1nPldo4sy4GR+7MjXqXymG0CzgXmec962+hSaE1Ri7q/N6A3\n", - "OwDINlH1MGLm0jldOtdN0Yxi2WvCzjCFjrSVpjS1C6VYtBrM0z/3+os9NL01IybCkLYb78nlxtOb\n", - "J2rtvNxWbudMmAWxYCeHtjOmG87xhC6FyVdSLpSc7g8gAx3QFTGKTEGVTFegzPAblwI1Czlf6G1g\n", - "uIy1XM8JEzKVhhaNsY6qBK8ciKPrQhXF7RLZamKeZp6O45erDBwf91AOqIcnfHjAqMp1e+b19oHZ\n", - "WeZ5D01hQmC73bBuIlcNbUCN7WzQCLrPTPOX5GLGKfSp88fTBekG3SeoAas9wWfeHB95ef2MOGGa\n", - "lhFGVgWdGn7nx5zPlLH0SRXfHYfpW9bbRr6dmQ8TlEzVnVITxnhs6zwePJodtyKct8TL64nZK9Z5\n", - "YvIPtCYs08PgErYMd2+Rc6M4UHXGKk0Feol8+nBBgKevfkbDoMxCmAMvrx/52Zff8sfvfxwZRm3I\n", - "tXE47FDGjkhVjHhn0UrTWiN4R64VY8CacdtQxlJKxPtxTUYrSgXrJ1BmnOzU2FDlPh4Qt22jtE5p\n", - "DWUMcbuODnwFby3r7QXJmeAceS2INJyC2jKZxGwDKY/TNL1St/HFPNnA49OXAzCtRpyJOzfT0Gjr\n", - "mZRvzPsdLQpFG4yzFOn4w5ekmKjbjWl3pNsZky60mJDtgvIzkm/0P/4fyPQWezgSVeX5dEW2yHZ+\n", - "ZuszyI5gF477RJPfoXpDZKG1hrIRo4/oCns9+KpbHtdcYxzWTDg3k5uQG7QtA4nJzxirsLqC9ohq\n", - "9GLp2YMYel6RlqhS0V2wJqKsYl48ypQxRtEapRxzWDBGEawd1U06JVWMM1y3zjxZSnPM3bHYTm6G\n", - "VjOTdxg9YZVn3h8oNVLbSk2dLoUUy1j+6jHbzkAqmetFOJ8FUY6wWNwsuKlgXMegKUnIfWhzQCH1\n", - "r3QRVMuYWcl9EaKsofTMNV6IceNyW3HGs5sDSge8d7QeUUoI1nHdMrSh37TGIaqhpTPUW42crmjt\n", - "ccphfECJHpY8IxQjGDvRkqGXQkp1IPprGTESA62PbzZlBO80UjRvDm/4+Td/wzTNaNOhCS7c56yS\n", - "CW7iyy//luPxC2JK/PDjd/z695bz6zM5rkNI3zqajh3GdHppJKlYZfF+wYig1Mpu9wWxJKbgOe7e\n", - "4MzMPL/BqB1KAjnf0JQRo7gHko0CXeH48AUprShVqHWj1Igxuzv4WKAaugTWYlmCR+lGca8UmQkd\n", - "5skxhwdCE6pe2eKVz6eVfRHK3FHWoy1oGT5yuqL3CREH2qJ0RekRwSmlUGseDvNcUaaBqvzmt9/x\n", - "9ddf8v2P3yO9sdsvtD4WI85P1NrxbnjBrXMIf4IVN2rNlNrorbHMCwc/0dCIchjr7wWHgFJ37FkT\n", - "nNOU2n6KBLUO1gZqPQGG2mC7nam1st1WbrcTuzCBGsQkWsHcDZGX9IL0whfv3nF6fcEpNUAtkwY9\n", - "tM3T5H/qthszTl0io0NfSqVfV3aPM6Y3jAo4/wjdMC2PbJfPlFJwfqHPCsoNtZ3BHVDLzxHZ8/rb\n", - "f+bzP/2KLob3z594//KRy/VK1lCbsJ92NBzWO7y6Djd69KMFZzqiLcoY9kbBmtniddy+zKid9ju0\n", - "ptQ6NLeto5qMLyUzbk/WTAiW1jNZVaQP06OdBR9G5dlODu0sCk+lI6rjvGM3Hwhu4eHBYtUHav6B\n", - "OAvbrZJLRuvx+xoUiEapBW0NIQSkWqyxOGu4rnc9R+1IuzvWReiiSWVcu1MeYBcfNPvZsgudyXno\n", - "id4b/Z55blJxZsb8P6ckf3r9xR6aqEbv+k6zHkT2qi2xVEobG7XD4ZFlDihrgKFBqG3FOo3JhpQv\n", - "aGtwRmGdoPR9Y9ehtYj60/bUGIKdgAPbdiXnQi1C8w6p4HKjI6R+oUqixEIIO6Rrbr1QneLt48x/\n", - "8/P/jv/2v/rv+dt/9wuss3x+/cQ1PpPWG26C3DYel4nDMiRlwU5oNLftihFFr6NO6Ztl9o4sjIhI\n", - "S3gtaDK+Grb0wu6gueULVW20vBEOD2htqbXT+9hSeiyLm/l4u3G2it20sJsfUXpmtzRKfSG3C7E+\n", - "Y00DL+g0FCG+30+F10pvmcYNqxWeEcTWdOadZ+qOx/7AWRviekE0zIZBylEdqZ0wz9AV0tSoymmL\n", - "2HFV6q3B/YPY7vnQ3333K969/YLT+cJ6O/P27RPazcQ1sd/vRyiZP+Udb0zOUWvBe8/1dkKAdU1Y\n", - "a6ldc7psKAWld4K1pNvoVrfWMcbSu6I1iDGN8Hkbm9dSCqVUSmlsa+Xz51e+eHrL6XxBpDIdJ3JJ\n", - "tBJx0ri2+1IoR1pd2S2evN3AGLzzlJqZd/4u7ZL7hl3d7aCjWitWMc07nLdjsWEsYhyXFAl0gvP4\n", - "p7e06wv9uiIHg1kOSK9Qb4h/pO++4vHbyH/6n/4j//M//AO4M9fyabjLS6HWQGlXOpW1FppdmafG\n", - "pHf0OqEoI73RHEV7Ql0oNaOVQ0RRW6U3RS2ZnDPoERa3SmGNJUxDhWH0WDDltpFawWiYZo/tA+Tr\n", - "gkWcR9shPs850aVj3MTh+MTXX/wtzhx4c3jl4fBb/ln+kZM54e2Edp4snZYiXYReKjFtLOENKEMf\n", - "uGqUsrSqqVkjgOl2JDNEaNVy2xqpNFxwhAm8TUx3m2vpnVo11niyFrRMd57vX+tJ8543g3ESUDSc\n", - "TOymhWI1XZ/RZUQPVFekkjFW44Nj1jOtVXJ2pH5jbQUjDi0aZw2iG14rrC4oveLtxG5+xNsdwS18\n", - "ev4j1gveeFp1EAYo0xZDa4WrnEl5xbCguyG2xBY91li8cjg14MfGgHeelQvX15WYIzVr1tS5rJ0f\n", - "33/m5flCiiCt0krDNs1kNK00tm1lNUJxYL0ltYoWg2qZ6+U7KkLqCS3C7fXEef+CF4NSAa+F/fSW\n", - "4+HKy7aybitKK7x9Ox6cCJITKT4jurGVThNDVxvzPmAy2KbpzpPFjLiWFk66U0xlaZGpFh72Dqsb\n", - "1u3YLkJON6Rluil4v0PUoJ13pWm609Wg46AVojaUcfTcsZOllcjlU8SGiV4759OGsZqUG751nBrz\n", - "59UnShdyrSNTWBtNIEwzCkstiVoax/0D223FOYc2lnkaCgWFvnfSp3GyZhgpY4zj/dY7Ip31toIo\n", - "Ut643D5hnaVLG9AMXbhdr5S0oiXzeDxyO50IZNbrhcl8wac/vh/2yZTYHT26O2LMLMtEznXUaMVj\n", - "TP+JdQB2RKMYlUJjA8YEWi2ktdJaY3n7Du0P6ByRpun+3gGvAv0MeofeP/Hv/uv/wD/+8Hv+99/+\n", - "r3T9ylpWzmuhiUVrR2/Cml75+tsvMbqgJkWJjV4r8IQyDqOuuOZweQHGKFHQxBKJWyKWfJf5VbzX\n", - "xNqY50GfN3ocerZSSWnkenEW43fYZcb53d0h3qk1oSTj3XDDa7ND2z1xSxhr2M3HMfOvt3Ejkk6p\n", - "ZXiU0jCBSm9czs/jBN7Htr60ipLhgNfOYK3+aVufa6InBW0sjp3rBBfAdjQNozphGl+qR5ko3dGK\n", - "DMHjn3n95cjtMeKMwWlzr7Q5THBcrxvWCloguPHQjPFGLBFRsLSZMGkOuz2rrtS1UHulS0fLoHJ7\n", - "C0YYw3Rf0KZx2O+w6oA2ls+nD6y3V5x2KNnRdUfj8GomxYbRltpGONvooQF4eb3yL7/5Nc7suNTz\n", - "YFheTpQ2rI3X24mPn36NcQarAqfXxIfPn1jjlWXeMS8LSsCUglUDRnBrmdjHA0Gb4ZZWtfHghg8n\n", - "aQVdY5ipW+Ny+gy9UfQjXz88sMw7nt58yefXZ9Z6GVGq3WBySu+kaqmtoVoD8dTSaH34fIqqdDO+\n", - "YLRW6BAQZcapq8hgN3ZB3bONvloyDjfNKKkUqdC2QQdqCuM0hULFI8oiUmm9jTZPH4AQcR1piilM\n", - "nE4nhi3MQlfUNmZZ27Z0IWaHAAAgAElEQVSCunC+3vjyqy8HWehyuecazXCPp8w8zeMa1vv9RDkY\n", - "q3/qfY8H47h55DtV9k9+oD/9meODmVm3G406tueXC4/7Hb0UtFbUtOGdovaK0JA2ImatVopsTPt3\n", - "aFHEuKHNTMuRVQYF3ShFanVwWY1Fa03YLfhl5rBMVKNBGroLc5gpKaNrpX7+hFkmZHa02pCcUfMC\n", - "0zRoTXpDWmc7XxBG8uLj68aWO7dYQFdyuRG3wldf/pyD/hanT5jpwq2/0kxFyQL9LVrNGNMIYYgO\n", - "u3RqKZSSiDWTa4bcyCkO17sx1NbYz46mGr0X8jWTSqJUUPPCPFs6boxQSgUKva1UOZNLosY9f/yY\n", - "sbYT7ESqhZg/YU3n4XHHFjWtCm6294fb2LTnpEgp3rfcBqPGOMRqS1EdxThl1gopCzEVchLGokMw\n", - "xoy6pWWAebzGO0tKZahpRLHWjub/R/f8v+RLaATXMKJHBrI0UhqnhtIyOZ7Hxls7YnolVzWO5a2j\n", - "ZMZO4M3E5CP5ehuqXOtxXY9YRs3k3FhvV3IJPB5W/LKH0jG2UdXr+FbtZ6RbSt9jJQyStnJoBUYH\n", - "gnN4O1F741e/+z3/8uvfop3CTJa3bx55+/gFh4eFUjZu6UapFxwzt9fGLV2xFtAZBSxhRk0GKYmq\n", - "wfSArgUboDFmf32r7H1gsYbJeow2bDKheuLy+n5kG6eJNh/wy8Rxf+Srh3f87v2FRiTnlZjPKJ1p\n", - "94pbqwktBZqjlkpKEe9nuvVIzdA6k3M0IJhAAbZWKWvG+U4XQ1MNZcrY9IuhlkypeXTnjUc14ZZH\n", - "TW5nFE4pHGNAPyJIldzbnULUiDFhrCOlzPLwSO+dDx8/cpwWvv/+B6YwUVNhrRdu68rueMB7T9o2\n", - "1nXj8dEPsdm9315rxTlLrZVa68C2CVwul3tL6D9L1FobN5zWGtfrdbBhxRBzQovCu5lKxYVBUerS\n", - "cV4zLxZjLct0pPeKnSdaqWitkNp5ef0BxDDNHWsNlQGyLoB3jjBNxNsFowrOdMy0oEyFlkltVFKV\n", - "tlAvUAqiH4aTJwQqDTEOI4JeV+rrhfcfP/JyXVmvQ3O8RiGn0SyrTXg4vOXbL/6GhQmLIpYzWkew\n", - "ClUv9KwxZsFPE6WPnUAtFd0rVerQUqfR66dq1hgxdqGlMm6B2g2mahq3rOY6giJYj5Kx2LHGsPUT\n", - "XRVEbvSWSOtGjJ+J2zOPh2+Zw0RMCR8c662jVccEsPZuFVVQ+zCmClDzaGUhFSUdLaOiKqLQopEG\n", - "25pIqdA6GKNw3ozruW+IdcN57jRVMiP8L2wJtiRM4V+Jp/mv/XrwDm+5K2YH7TnmV0ryvHnzjsUu\n", - "fHx5z7a90EVRS2ErK7FmuiSWOjBbZWtQzAiktj4WI1XoVdOSI7WMtMQn/xn9zlNqQklCqzG3EN3o\n", - "oii1ULrDyILHD7ivVZjgUNoRBIyZuJzPnF5P5Jz58Mdn/v2/V0yuE/yOrA9svY9N/tzYK4NqwqQ0\n", - "Ttvx0DAWpgmsEFTAtoIymg4oZ8BXmgMdZoyzhFLoUpE64Llbu7HGV05x5th27O2ex8M7fnz5nmu6\n", - "cr2+J/jOYdlBqdjm0c3ff37lzfwWdQj46YAoxWU7QT4RtMEoD8ZyjYlSE5f1RpOCNhZtLDY4HIqq\n", - "QXV9l4BB64muNbk0ok4EPYbs0jXUBikNrQcOJZrb+TNu2pNTZtk90NPGrVSU0ny6vhBzxBrN9XIe\n", - "UZ6Scc5wBtZ1Gw/h2snlNnK0XVjcbniRRKi1Ms8zp9PpThsadcd1Xcfv/P7vtm37CaY99LqZ/f6I\n", - "UqM9Y5TCTWPkQ4M57BAl6DDes61Vcjoz+QnpQ5d8OX8ibpUw7/BuT9eakhPJW6TMWGvoTlNTHn/f\n", - "wRBbI5aRzQzeDjZlqZh2pXmHnhxmWmgNVG+U68avfvN7/uXD77muzzgdoAYkJWY3Y51BGcvXX33F\n", - "7BXOCVtq3HqmGcHYhFIXtHXjz1SeZV4oudDKqN5IbtAVGktPI9LVyoCj5MVwq1fmeWQca2koMQQL\n", - "SCSKRvWIlUJsbewhzNAvCwPZVrZGo9ELNCMcDo8oPJftB4xrhBCwviKS6EWhzUJOJ4yqgELJilEe\n", - "pQKixjiuGwNWUyWSa0VQ+ODYLZ1lhmmx5JagZkSpkW+WTKuOUgZYZkBF/krD7UErjO33DXojpk5O\n", - "K0/Hbzkub0Y2Us/84z9/pPU0HONKsa5XttuJh/2Mtm6ItupYAmQlOKOQqUEdgeheDFvLnP0ZZyeU\n", - "AtUnAoEQMjFnYumjx91nYAZG8K/lhBiPCWPp4Zzn7dMX7HY7Pn/8zHU7cT4/8+44MVuP6tC2Sjea\n", - "OczsbR3+6zxO0s1BkYauAaU0Ljgs4NQIuucOvSRQQlGB3BvKWqxvGNSY23hPlsI5XbmkA0fj2IWJ\n", - "p2XP6+U9qRRiFmb/DmeHL8mat7Si2amGNxPz/oANe2La8BfD5VO+iw06TRJIJOc0gt6pYIzCTIFv\n", - "3h7ZKU3SsJZOukW0K+zDI4ufccaNXnDPTK3fg933LwR1n5eJkOJGRzEvO9bbhWW3ENeV4+MT6/VG\n", - "SRG923G5XNhi4njYk2ImbgmlNdZYXs8npmkaWDPpdBG2OGAfXYSYEus2HrC993tVbxtvejvaO9fr\n", - "dWxjz40uHRTMywwyfN/r9cThuCdtEWc9pQhKM+qTrXK73FgOjmIq3i+4NjKWNVWomc4V5WdCCOS6\n", - "sW7Cw/ENohy1DR2LcTswBlVvpG3F6IllHgUBNOgp0BGUDVg90Z8/cPn0TDeGuml+/MMHrvUT3k/0\n", - "3tHGMoXAl199ibUORedlfeHDyw80fWJ61BxnTdcRpS/jRF4UGoc23Jd7g9Kkm8KJRoymls6YFiuk\n", - "CjoMK6RSo+mk7EgIaFvB3mjK0GrEOIULhclorJ6hCqUWrPd4Z0cypQbEafYPE08yE/OFsBS0SShR\n", - "pG3wPL9498DlFeJWUVSsHp8jcYJhFFCSLvRaUQaUUYRZERaNDZbSOp2OypbWG0oNpTBMA1NpwQTB\n", - "yl9pjTKtlZ11dFNH1hGN08JuXpCm6MoMC2QB5zyT9xgKOnVi6WyxjhwiHiWayc+4YEal0baBi5KG\n", - "t51eG6VuxHTCe4cRC0mz5YR1liUEeh6/TGTF6BmnNSlXIhFrHEoP4rbWGn98YFn2bNuFGk+DuRiO\n", - "HN0RffS83k9oIqAFnA3U7BBjcXbw/oy5S9qATsEog6pCkUpRnbMUVJNRF9SKZADdmQyUllm3C9tt\n", - "RvuFTEdC4OndA0k2QtBYC9buaWVUDKedQjEBit1hzIK6DJJU6wVVG8YplO5oE8FEzAQOIXiNdwnL\n", - "mf3uiK6VnDI9bbTkaaIJy8wuHPA6INlR9YZ1imneU5Wl5xNKN6RrvLVYI5R44+HNlwOWvD9wev1M\n", - "q4WWxxzw/YfPHI5HjBlX8E+fPvL27RuUh3LLPD48sm2RN28ef7pm7/f7n+aZOWeUUsQYUUpRSvmp\n", - "CTQ25xmRTrlHXJwbMaF1u6HkhlWBh+ndUHtojbYBoxXH/UJNkZYL/t6AyjlhreHx+ESO86gKqjbi\n", - "Odpg7Iy1HtEOUYppWTB+GsUBo5hbQ/WKiKaimINHMCjrUNOC6ICoQNeW//Trf+KfvnvPh/NHVKiU\n", - "tA3KlGkIwuPbr1h2A2Rx2VY+f3rPFiO4CQXcqmCnjHURzYLCIvThTxehlIpFERglDzEK5UHyIDz5\n", - "YO+Nm3FCV25kjMV2mlKUNFzsSnsmPEo6vYEOink/IfWBXBP0QpMzxweHkjL8RLPGBM9l/YEuheAe\n", - "SUVRu4yR3tKGQTIPp7xIRWlFMJZbzQgNpTpKKs4K1irknrm2MuwOufWfHvYuBJwarTyRAbBx/xrk\n", - "9v8Sr8slY50mALlVSjOkuPHp+Xt+9tWBVDJxPWHEsw/CbjI4q7FWeLlBRqOVZ/Ka2XtM0MyHHdZN\n", - "lL6RY2S9XkjxOnKIchotcbE03Jhn1PvpsFd6NuRN0ck4Y+5XuvEQli5o1dniRpiGqc8FP5iYhwOt\n", - "NXLqGDE8zE+05rhsz+Rshgb48RHvHI0Vra9YX5jDhG2jlXGTxDW+4MwdZ6bicDxrj9YzRjvcpoib\n", - "kGVDtcLna0QrxZvlgFiFXSbeHt9R6ooLmqZPoFa6CMbtKd2gdR2LktsLVTSnS+Ll8wtsDe7+GusL\n", - "k+3kVunsKJPGqJFr87OlGTC94k3BecV2U9xuK/UhY/WEXyaUHREQXTJKDwyc9g8joF4bQqO2cYUu\n", - "dR0qZxO4pjOldcJyIK15zKna6HbHkng5n3h4HPNPay1GG968eTMeinDPVJbh/aljoztNE9u2jb//\n", - "+wzTe8/lcgHgdrthZHhxlNbkFDE0nA5My3Fc+Vvnej3z+PCGuG2U3hEFT1++o1RBGYPVHWsUVluc\n", - "3yFaKDXfm2GVLiN/+vTuS3YPb5kPB9x8RIkaUI0uLPs9vRWMKFAB8QaMHZXHsg3FcRPCwxf8b//j\n", - "f+TD6df0vv6UQDjfVp7evmVZHEoUrQufP30iniKzHW2p2mHtiakr+pxYpkingezo3dK74Gj0ejeS\n", - "unGSVxoIgrEN6z27aUJJZasNVYcfyyuDVxaqJhfF5B26KrQH7S1NC0lFgrfsd/OoZPaVXIR5emB2\n", - "FpigVGb3htPpmddPL0gFbwIOi9WabhTNa0pTNO3YO4uqFacVVVtuUimM6qyzjl5GGqOYjLJg/HBK\n", - "WQPBarrKlNSJK/SiMGn+s8+uv9hD85oyNgq1e5oWam5oBc+ff6BmMyJJLWFlRffApCec7lQ3Yy3k\n", - "VkZ9TMHD5Jh3HrfMGLejmQNXdUX3Caf2bOmVLpFcL2jjKHQipyGtCgFTO11VttypWZhnB6JxRvDe\n", - "EoJlmhYutwvPn39ktxzY7WfmcP+Wlooylqo0cY14M1OjpfdACID2I3RdLsR6xkjENU+wTyixOCX4\n", - "vlH7GRcssx6dd288qAEi6C1S03nMlKqm4PlwvbDFA27aMQWDMeMq6MLQO9RUOKdniM/YkUYnpcSH\n", - "l5VShM5Mq56p7VmcxVhN5ca0CNYFzjdhuy1j6y6a2DSua4ybsF4xz4MzGvPGc7zidxkphtnNeCzW\n", - "avLWcfOE7ZaaEkKjtYa3Dq0UIo15suR4ozUZAj00r6+fefP2iefTK49vj2y3iDXjoTgAKQO48adT\n", - "Jff67Z9etZafTpatNZoxrNt2r9BqYtxYt43eCiOUNFpNKWXePS4/PTRKSdS8spv2aDXmluvtAtKo\n", - "1bBf9khrTLMHYbjCQxgErjLmarMfdkNrDfv9E8e3XxCWI9rsyLWjdb6XPDSH41ukVKp07HxAlnkU\n", - "BWIlv5747e/+wGVd+earb/nj8+85XzeMgRwLtXQeH49wd/Cs68Z2Lez9AUenqs5WM68fG8dumCWR\n", - "7DOTeUPTHtTQjKlJYaqm9ErpY9bX7VisFQ17Y9Cljk1+7WgpBKPwxuE6ZEbV1iuL3DZqhGYbehKy\n", - "1ci8koxBh4CzgbgmSnlh8gNUbO1QZtvDzzkaOH/8gVqFXtdxJnZHlt1Eah1FR0pEK1i8oxlBZ0XR\n", - "E7FU8pboRqFswYWCt5rJg7YN26HmSC2QN01ZHSp5YvsrnWkuy0KpkdZWRBqt2tHzlcTp9Y/3VH9F\n", - "W02siTU5fLPUPkK1qmpqVxhbocURTm+Cs+D6xBwCNMgxo9lTsuf0ciHvRlddazPcLzIUGZ17xMhW\n", - "ctpwdqIrPYbMYeC83rx5IuXILV9YX68s857DdGSZLR9Pn3BhgipjaeKF7bIyLTNh3mF04LJ+4PVy\n", - "5XROHObC23kiqJlqCwozlBRYTO/obuhVYa0Qe8HQ2DtN1oMGX8qAGcd8xeU9O79jWjy73YS3O1Sy\n", - "vJke+eoX/wPPn37g0/M/0dSVlBSXS6ErS+fGXsFxbsxmJpeCWGg1oq1nN+2gdza5QWtoNZHFIKWA\n", - "DYSjwklGutDymdf1PVZ/g4jgsfTOYCcC3LvD3rkxrG+dXjvzztFyRCvN3g2cW1pfCdPCbT3z8HCk\n", - "10pcL1glaKXotXF6eeXd0zukjzd4yRljx/Z8IN7+L+beJNby9Sz3+339v1nN3ru602EfFEMikygB\n", - "RYQBEkh0Uq5kGBnBFfKYKQMYMopspgyYRCA5ygRmWBlEYWAREUXhhoT45vrS2DH2aeqcOlW7W2v9\n", - "m6/N4F217atgBiAFtlQ6Vadqr1q191rv937v+zy/R+ZSOWdijJJ/DsQo4vbTaSKlRCuvt+2KkgtD\n", - "H/AuUHVjjgu6Zoy2BH9maDY4nQ5YGipYliYi/FaFx6qdRnmPswb9WhbVKn3XMwwD3f6CrBxUxXq6\n", - "5jid0CbThxHnAiUXnO9oztGspSkL2gMr3lhiyfy7v/33vLr/iN1uy5yP3J9uqWvhU+/8AJ3XeCNJ\n", - "qofjAWt6eV2WlVwSuSGw7MXhOk+ZC2VzQtuK6zp8UZxSIqtCMZpSC2luFF0fJEeuKGiVEhNaQQBs\n", - "p9G64XUvwG01YDLoWjktjdwSTWf6QdFSo6nCEg+0dqCzju3FwHYfGIeA9wNX4wZCY3GRwV4S14o1\n", - "A9vdFbYfhczeCnGdSYtEcMeUeHl7R06FORvm0jAm41wRQ4yz1FpIs0C8VYOSLGV2xFPDrB6ve0z7\n", - "Fyo5Gi4uuJuusSVTcgYiqIR1ipKKdHraURCR89204r0m58S0JqoRH3BSlpNu3N4vdMkS8oIxHQZD\n", - "w+K9YT5pWnLoOpIOBWUzxgaqWSmqkJJGK4PrpOdo1cDZ5ulMYwwabR3abPj0O45vf/gNTvPMy08+\n", - "5tRdc7l/BDTmm48opfHo4ilPn7zB0I90YeAHnn2GmDKn4w3r9E0Oh4lbNLf9S56MG0n266C6LfME\n", - "QWU2WiDGs8nMJEqKjE6jq8dr8G1hVZWsZiiau2Ml5Z6SC7p0XF5ese/fZdvt+KG3/yte3H6H//1r\n", - "/wN38TvEtWPJkRAayWmqkhmiAnJRJG2gVjoFbhzoQ89xOgrUYI6yVTUa4wyDC5AVLQTmNbLkGYMi\n", - "GI0xBqcDLWbmdcF7D61xup9wVok/fbqnlIzzHSVquu2Iao1x9DQUlxcDS0xoMn0X6F3P3emO0AXm\n", - "VYrjZr9jXVdcrcw5nzfZ0mEus6DoyrmY1lq5uXkFWoAqmgYt01plCAFn5Vq9HTa8evkhbz15yuHu\n", - "Fu+9pFI6KwuPWijrBGdKToyZYbCgNUZLOqf1DgUyp14X6Hqs1eJkKglrDa0mjtMdwfb0u0EWG95R\n", - "fcBUIc7raojHGz54/1u8uHvJ9f0Nz199R6j01uGc4eLiEfvdgLOVdV356KNbTktDI26XhmEtM80o\n", - "rOlIK8S5yb93XQkdWCNjmOg10SpUBEcilYpKGl9hcAaSjK600mSVcd5RKGjnKM2gtEWXgi6NnAo6\n", - "F+I6EXae0hzzqbKmzHyKrLFi9cLjRTS4p+0rri6u2A+DxHB0mkfjO/Rhiwt73GbABY0xhZRX5mXh\n", - "+vqOV6+uocHF5R4bNsS7W1TJdDtL7zpay6y5EY8rLTYohloN61xpc6bXjkELWMe2f6GSo87vOc6F\n", - "lQnlLOhMipmG+I21kZAsVQotruSaSfNJgsCq0JnXCjfHhbuT2KSmkOk3hW6IQnFO5iw9qEK9WSva\n", - "GVS15LWSqRjv0EY6unHTaFVRqmT9NB3RHu6mD3j2dEtJjS4MPL18i/fXvyPrwu31zHRcxdNeV1pT\n", - "XG7fIM6Wd978FLvNFbvxgike2fR7rNow9oabFwvHm8jBRC52HVePB/RgqRhul0obAiEYjAsiOM4z\n", - "sRS6rsc6y3T8BF2PaF0xulDaTC6NnC2n48J0es7gnvLOm/8xb1y+w5uPP8Wn3voM/8u/+R/52l//\n", - "T6yHzLp05OVE3xl6s2JdQNWOPEWWtkBXCFYxBCGK53Vlzo04SdTy2G/orKKpTDYGFTpaS5RUJJzL\n", - "K8iKkiJ96Mgpcjyd2O53jENHmheO04EudMSc2GxGXFBSdFpiv93TGUUsM2NQ1FpJ8Y68HNlueu5v\n", - "biT69h7iukrn2Bpd14MSmnoumRACy7JwOp1kZJAWjHXn5UcVmIZS4g8vgn5TJTEEz3S4ZV2OHA+e\n", - "0gqXF1tKOkEsOCu2Q60tznmWZaF3Fo1s2FVDiE3G0YwE/SkgpUVI8GEghJ6UhbS+2xUI4rVXm4GS\n", - "gWWlDoaM5q/fe59/+81/y4fX32SOJ2Ku1Kp548ljxrHSBUXOlVcvb3n+4hYY6IIccFrbM81HijUq\n", - "sy7SYaMbxhSMWUFl2R1o4W4qZTCjpy7g0QQaRlVKOkvrLChjMNbTqkXRYVPB1oqJCW01oRsIF5aq\n", - "K3OEnCPxpFiPjiVXmlnAXkNvqaFhjpW4WjZ+w0X3BGsD7ZxqmdSM0x4bBI49jFsuL57wxpuRTz65\n", - "44P33iOfPmG3UzzqL1FBYYphmRPrfOB0EzmdGjVFKJaaITToOovqAkJs/Bdqo2xoaB2d71AqiaTH\n", - "DOSUiFFyzp13GD0Ql0CtMh9bU6KzjjUlcVykTFpBH1Zs0PRzYdxXxsHTqohVU2nCUlSJuTRUajit\n", - "UFiWVLGuoh0YW9FaydDeKVQrhDFh9Mpx/ojBvcsyF7TSBNsR24q1lWUR4nethloa1+M9bz1+F3Lg\n", - "8cXbjJst6dUHaOUwvrAbetYJXnx4YIqRVhMXfWDjOprSLLVxN50Y7Z5td0FvLe34ipom5tbwLbDt\n", - "34DlFuc1zjlims/QAkVVmrQm/upvvoYLHeMw8uTqMS51/OCn/1OO80u+8d7XONwt5FQ5qsSuOxGM\n", - "p9Mb5iyzoLu0MnpLPwjBPaVEzYgcrCpS1phFlgepSIqn7y3OB4oxnEpCL5FRaZZlYl0Wrq6u8EZh\n", - "VAVvGVpHzZntdqTrN9Si0V7Thw5vDCUeCUSosjBap2uCNaTpnhYGTscD/bgTwIVzkrJpZCZean5g\n", - "Zq7ritYwTUe0aajqaOcgNHWeIUuMq0dTWOYDeZ2YVsl3WtdZ5ERF5qStlnOeU6WWgtGgqJS4QgjU\n", - "1rBKYYyhs4EWDEVDSoKHG1xgniM5icbXW3k+Xntq06jUoB9pcaHe3VLWirM90ymTJ0U+Serpo8db\n", - "hsFgHVRjubm/4eXdidOcqesEO4cxFutlCaRMwKoZYw25emocSWskuogPoFWl1RWnNZUKVRH8GdJR\n", - "FMYKvKPVJjBjqvhnlBZdrtISyZETxjZ8Z1EGtLKc0ip09amRbgQKgo0oV+l3FuMNWgeWKPpNoiYd\n", - "EyHMeKso9wsLM6YVhjGw216x3TwiBIczPU8eBTbDnqvbF1zfv6KUxnZ8QlpmDm3F5owK9zy1PT6c\n", - "YT7aYrRlMIqh6zDeiPyMr33f2vXPVjSXQ5acaWAcOqiZFCGlI8ZkrLayJOlGrNqIb7hvGOWpDaxL\n", - "6NZYlWexiXmeOR4jaVXUOlNzwzuDq1ZOKISEVFum1gIUNp1GNxF9l1ihNpoS2rc3UgAiE8503E8f\n", - "oLqOMnfkUtmNjzHW8uLlR5RpZp6gFYPWhu988G12+0uc2zDPE873rOuRu9PHXGz3krD5ZkeeE+tt\n", - "xVlHKRODGtHN8DJ51rjS2sowBDbhEp01Lz/5K7rtBp0qtTRGu+Oi30q6Yp44rkfmGJnyRMmam9MN\n", - "f/6X/yt3t/d89jM/gtUGSmO3fcKn3/407/Gc29uFqiprToS0oPyGzfiIQ4rUGkFV5uWeJTdKtTJL\n", - "MgmlBKRyiAttlYOk+gVdgKywxeMqhFY5pMJgPOPFSO87ghdyUErnRFDr6PoRb3qqnUgx4ozDqkxK\n", - "K51dUbaS80IrYgGc54zfVJTuuD0cqC1RDwJ12Y0b7m7vcd6xLKLNXBahlNf2mmozUUo9098tuSa8\n", - "s8AEGskncobpFMnLiYvNDmca03Tk8uIp0+GOmO7prCXHRFpnlAmyFFSNblOxbgfKsdTIfvMIrQ2+\n", - "GyjKcThNxHXC2kAXenRLaDxVWZQt4CTN0mNJS+Rb732b++PE1vf0xjP2yDLSyra7ZMf94cR8TFIc\n", - "tccGxKBhOoxR37Wdnu3LffDUmolFU6dCLQYQNia6Uo2makfTYABt5UqulML6RpY/TamKmjWqaZRr\n", - "oHvsRtN3VojwRnYRap5I8wlaxYxKlokjmJ2hHzWh02KAqA2Fx+pHBHeJtwMxRo7HE/Oc0UZzGg05\n", - "yt7j0m0Y+g3BJoIt9H7PW49/GENHa5ZaDCUq1rlQP6MYnKfzHdbJLTMYJ7Q0ax++Rv8N//33rV3/\n", - "fDrN5UDKB0kyZINqipxWpmmm1kjfR7p+g2pQq6LmLATnM3WaJqZ8ay0jSmJyqcSaSathNivFiqBW\n", - "a08fgszq2kyqCe00uMS2M5wmwzppdNbiG7YVYzPNOppuxBwxBF68eg/PHqU3NGkthIjtelaywGyD\n", - "wxnP+x98h9AN7LZbDtOR+/mG+9MNxq4EFeid5nK/55hmVFPo1jHHhc4lnqrK382J2Hl2/SX7/VNm\n", - "ZZluPySeJmaibHudx7nGZXB4N2JjYjsollMjtoK1ntPxjv/t//qf+Xff+Dc8urxku+mwNjP0I48f\n", - "PyWmV/i6iAf6rEft9Y43LwYOp48ZvCLnzBAMJxZaE37omgpzOUkKpEnknGk4ks4Y1VAtE7Qg+fph\n", - "wGW5dsv3fmWNM85ZpunEMIxst1tSLCynhbEfaeWEVoLlc26LNaI7NCVxfX9iXjPKG9CF0hyHw7Wk\n", - "AAw913c33NzdsRlH1nVBKc00HSlF5EhKyespJSEntZrpQ0cXNIOz9M5yf7pjnRZyylAq83xiWRrj\n", - "uKVEobXXgFCeBs2yLgzWA41lmmhV4ZTFKI33nhxXjA8YZzDGMyiDorEsq6Qvup7aCto7SmuoBr4k\n", - "yjzz8ccv+etvfIO//MZfcHf6gOYXHj/a0myhtcLpkFnTkVOurKVgvKMbPZTCdjcy9h2aSlJnVcbm\n", - "Cb4TbaZzmlgaWicutht6N2LoUCWgm8XQU2qmxInj/TUxLijl2G1HlIJ1Xak0tPUobfHdQN+PDIPH\n", - "aehCj7EdtSliTGwAOkkAACAASURBVCzTQorpLMTXkhHVa7qz80ocQw5dLVY5Oj/gnDBnVRNHkYxh\n", - "BDOnbMPj2bstu80gB+W8SsxMbnIo6gBFY7XHKY/ukSz6c0SH1eZBp9lqFiPJP/Dxz1Y0a5uxOhHr\n", - "wuE+sq6VFtND91nmhTxG5tmiULQzubupDMrRcOIjVwpbIZhG8g6jPSYvlAWqK6gQ0dbQSsIahx3E\n", - "RdR10A+KYB29hmM9Qlppi2KKhUV1pDUJ+aYWrK2ouhBLxthKwZNyQilN8IHSe5SeUUWu9sYUvvP8\n", - "Gyid2Q2PyO2e0+kTXIhol9G5YzAGtxnIqbImQZyVjcMY6Cx0fsvji0/x1tvv8ol5j+PL73B3WGml\n", - "cDyd6IY9YdMxnTLDtmfoCqWeaAFiabRS6XqHTolPPvkOH37473l8teGNN58w9I8IYcPVo0q8+wit\n", - "MzEfGDcDkQmtd2wv34R6i+saiix+9ZTJRlHNQqmFTEZViYNdzcIyZ2JJGBVQYQsEbINge2qTQ26Z\n", - "pGDe39+x3++5urrieDwynU6otjDsL7g93NNdPEYpS+i9CI9z47TO1GJI6Zq4HInNsKZMWTKzUjQt\n", - "9KKGQtXCmuUNmlI6R3CUhyXR667Ce8eTx5dsvaWlmZwnliXy6PFT4hSIy0Q7x15QIjku+H7EdgMt\n", - "ZVQteJSwJ5uj1gz1nrsScRaa3mJ1Y7vdcDzNlJZIVVB1ApJwaO0lgaCumM0jeY8c7rh+/oIPn3/M\n", - "x7c3nO6OaGcwwaNolFyIEab7RsmKYbNj8IrFNHQY6Hzgan/FdhiFSmQ8wXdsLzZ4L8mfKQudPtjA\n", - "dtyIy8p38r4IHVppUiwcTkfu7m5Zo5Cp+kFuRcu6cjyJv38cekLoCEG6Z9UUygguUJ0txXFZiSmz\n", - "pgWrDM7tGMeK7x1WG3I2olKgoXWjKY03Hd45tFYYbUFDbN+dR9faRGRfNUTD4EY5TG2hGTEtdGEg\n", - "GI9WiqLyg5Y3p4I6w1QAsO67P/8+H/9g0VyWhZ/6qZ9iXVdijPziL/4iX/ziF7m+vuaXf/mX+fa3\n", - "v827777LH/3RH3FxcQHAF7/4Rf7gD/4AYwy/+7u/y8///M//vY/dOw0hgKrEXEgZ5lJZcoECukLJ\n", - "M9oIfaUh80bJc3a05mhrJcUV7wLaefY7OUW07mlppuaIpkIR6VDJMj/a767w3jF0AdUiqEzIlVA8\n", - "g018eEicUqYUxTpHmd7rSeI1cqPxglgcnLfE/TBgfcVNQqxxvWPcdmz3T1iWlev7b1DLgVpWbIzM\n", - "rDwO9tz1OIKrtBJRduSYEl1o7DaOZ88e8/jxUy67C9buFlXAlkKrhUe7LcoM1KgZdltyitg+QKr0\n", - "pZDVyoSilBVrGvvNwP1d5MXHL6jMPH2c8DawsYWTs7RSqWVhmV+gxyfUXHHdTlIyucUYj9JwStco\n", - "Y3k0BjCa6bByHQ/MLROaENKXNRKsA2/Zb67O2DdNcJ51mUkl4rVmMw48unrGy0+eMy1HnLVc7SQG\n", - "dzNusVYWGN6LXY7acH3A24BWjpf396Qlsqwr83EFa7DBEueID4776YCwpBMgkFmQhVLOQjGy1nC1\n", - "v2IIA0ZlirHM94l+GIjrwnZ/xW1NqFow55woQ8W2iqmGaj01rSilKXVmTSuXF5fM00xL99xdZ+zj\n", - "T5PKQNMQOkHxURVGa3JKZ2dKh+o8ynmq38nz5IZP7u+4Oy08uXiM/6H/jGm5p5HwrsPajnlNxGfL\n", - "OQGhscaZXCpaeTb9hmEYHqyk47hjsxnZ9iPeiGhdW9n0O+dQSjosbRRd1xFCh3eeUhIXy8DlVjp3\n", - "5zzb7e7MACikuJJLpgudbNJzIedyDj0E5+SK77Ulzok1r2dDgqYbAn034jvRaFI0OS8ykz4nWirV\n", - "MEZUB9Y6ikIKcFwpJeGsoZ7/LmMUIcgSucnRiTL6HGanRaifG6Um1rgQ10gqAe8lu0lrJSO6f2zR\n", - "7LqOr371qwzDQM6Zn/zJn+TP/uzP+MpXvsLP/dzP8Zu/+Zv8zu/8Dl/60pf40pe+xNe//nX+8A//\n", - "kK9//et88MEH/OzP/ix/8zd/8/dW7poKYRsoNWK8JNNRZPifFsGKtdJoWUuIVMs4ozGl4QdLaxXj\n", - "DZhA5xzdxjNsAkoXKopaxE2tamNNEwUoxUFRWLOhZkvJCkVgXQpDq2gmLjaFu9g4LE10m6YHKrVF\n", - "lqXQsqbWTG0S8qOdQ3fgg8HZXmjqzvHG07f4of/ov8Bbz7fe/xbf/Luvs5wUoUmM6ZRAG8/2Yo9K\n", - "lbzcc7idoFdk3bBDwPhKrZHDceb6+sjLF3f41qgGlKlsdwFthUpetaWVcqbTa954uqdUwzFNHE43\n", - "ZBaGYHF6ZDpMHNwtu81GFhVdRzxmsIaqInF+IYmH6xPG/m1iseR6h7MeZ7doneiDpRs2dDoSE9yc\n", - "FgyB3vf4UlHNo7GkXLCt0azjOC+o2hg3e8iJYeu5u33Fzc0Nl1dbtv2INrJcCH4khI6mDCF0D1dq\n", - "aHTjwEWqJCDWW6YFUUmkxGStZLyoRo4J24UHGLGz7pyD03AorFUMw0DvPYf7W0o80PU9SlucMUzH\n", - "e4YRnB8gr7LsoFFKpFWPM456pp1H5Yhacr5zruwvLjmd7uhCTyurOE/WBW0CuiIdDlbwc3GlbXaY\n", - "MNCsh7SgSiXlRjfs2I6ZZiTMbVn2dEPg0aMrNuOeGhuH21vpuJTiOJ9Y14jVrylBomGNMaFaIS4z\n", - "t/OMtZ7NMOBMwDYjh0op524uMPQD3ovqIKUVrTQXux05DyLIV1qusUZ0qb3pqa2RYjrT+gW113Ui\n", - "9NdnorrtNLaN9L1Yer13aO/wzsuN0jaJm2lGtJXGnIt+oVWkm7fyWqi1YJ1wPY0xZ3aqzKONMd/z\n", - "uZWS8tm2LJg4CTMUghTnAltKQimLUv9EneYwCJw0xkgphcvLS77yla/wp3/6pwB84Qtf4Kd/+qf5\n", - "0pe+xB//8R/zK7/yKzjnePfdd/nMZz7Dn//5n/MTP/ET/9+iWSo6V7yFOSqcC1SfRPisFceoqFWL\n", - "ayTLBlRZ2QR621EoBN/jrcUbycbJNVNSQmdY50qNkOsRnCfVTMuB1UtnO44bSgroalEUTmlB94pW\n", - "DugQSFlRasZZyTQZbEdqiftjJldDQ6AAqTVaPREGJ5BTU3Ej/MCnfojPfuY/x6qK046PXnzE/f2E\n", - "jtJt5AQXuz1WW2wtlGZJC5KP3hJD0KQ8c3P9Ia/UHX/34q/48Po9Ll2g63uqipxO94wXgeN0j/eO\n", - "lGa0KoybjkeXT3Buw/NPPiTHE24TKN3EkgI5J5blBV3fcHpg8BvcbsAUha6Neb5B2yNGPcFvR3a7\n", - "d7m++xZ5XdHtEqvv6buesd+zHu+oMWN1xVnLRe8QjH3FdT00QzCw5sQ4bER6NE9opzkeT9zdv2QY\n", - "HZvNjqv9hlfXL7GqYLsgXXgIkrfjHFiDaQrvDP1mZFMzqSTiWjidEsfpAKeJvh9IUZZltsnIph8H\n", - "KlYOg1JxWrz/4zCgyHLVX2dQsiGOayL0O5EJaYO2jtiaSHRaIZfI8djo9wNKnWMluktyKnir0dbw\n", - "zqd+mGWd2T96xnD5DKUDx6UyV1BG9LY2eJzWGKVpzlNNQKV7VAGtB7zf0IcTyzpRjaLb7ri8uODy\n", - "4pJh2EjUsdH0XY91jmVZKFkkduK3j5xOJ+b5dPbbJ6ZpIsY7DqFjt9uy2Q74Jn7rLnTs93vGcXz4\n", - "fHDnrtxyOk2Y2oQUdWZUil9dxiDi61+lUaqglIwBpkmwj9aKPMsaJ4qF1sBompJIihZlPCdxx3JV\n", - "zqpRqiZXYQmQwHmPMkY6RO8enGEpJVSTW7LW8n1QTUAx2hpZMBswRRZUtVbQ5gHqYq196Lj/0UWz\n", - "1sqP/diP8c1vfpNf//Vf50d+5Ef4+OOPefbsGQDPnj3j448/BuDDDz/8DwrkO++8wwcffPD3P25u\n", - "lCmTnae0haABbSjFY3xgbZNs3LSi7yWC1DqHU2J5lEJZaGRSEYJJmRN388I6LTgsJoM1nuoKWIVu\n", - "hbicOByO3L4K9F0QMSuNViOxBrQJVLPQbRSHa0dFY7qKbQHvOmp/4hQTtXYUVYi5PhTYMCxUr9mr\n", - "C9544xlXF48peUVVw37c8qJlNBIYVpwE+pg+MKnM7f2R6/mEMQGtQJnCqb/nRfiAOVWu779NtzfE\n", - "lgBDsCMFQ1wWYrvHWk8uiZQn3uQtSiiEccUHUQ+onOm2PV2J5KKobZIfOKKSuU9RlWUqnBbP4fiS\n", - "Z08fMQ47jDOM+7eYDq9wppBOirwo7lMUJF+16Ozo+gGvBjm9rSOYLRvTY6rlauOo6cRyuiW4jpvr\n", - "a4xpPHr8DtRM3/XMa5ZD0Y84789dj6YhBPccFYYGRqDD8mc7XBfpw0zKhlbzeSYGnKHUm82Wcbcj\n", - "OE9MkZqLLIBKRut2lrkJF7SVhu+Eo9n3O6gRawu1NXqlUTHRvCKnhXW9w/pLbNidA/ok3qLre7zx\n", - "mK7nnTffod9foL2HohiCJc0L67LQWmW730BwYBzkKDPArMhzZl4i5ew4AmRDHDw0zatXN7y8vqEV\n", - "yQH33uGUYxwHWoMQgiyrajkXzZmU8vnAXB6893LTkKu5UiK3m6bpAfrcmowyrLXM88yyLNQqEi5j\n", - "DKVkEbqfIz2kKFoERSPFS2l9ZgVovHN4f54tCpdOCEVnGVPOhVrb+eov/NOmhVXwmkxkjWZdV/kW\n", - "N5lnanWmWdUm+EctexClGhr9kDBbUkZ5f44i0UJ6Nxqjzw2aev3M/wlFU2vNX/7lX3J3d8cv/MIv\n", - "8NWvfvU/+P3XX+zv9/H9fi/mgtFZgAQpYpXHGk2KldYK3pxD0Kro/5SRWYvSQBEhfDWOWh26JpZD\n", - "4nS98vIwk1Oh6xSb3lOb5MEoLcuAJRaq0SRWYrQsrifYQBccL68n+gtHVY1hyJAr8ZSgBZR1WNfh\n", - "ioZyJ/nLFZSy1JKJSyG3SquVzeaCNx5/mj4M3OSZD6+/jfeZ7a5nmmdMMmBlOuZ8ILuMTobB9ejU\n", - "CQxWWabVYA8n1nQgzi9pZkFZQ26RYHrB6ulMqxPTfCShOC0LLb6grImhsywqSd702KFMorkisGXj\n", - "KK2iW08rnqaCDNO1Y+su0N3Eegf2kcOtmlI1Y318BpPs6JqjJbA6wcUbGDXSeUPvvPBPK5hShF41\n", - "DKzTkRQXvGrc3L5CO83F5QVxbXKFBeblRIorm8ExDAO1NmJcQMm8TClNy8vZtpjovSU6z6bvuTN3\n", - "0hUpiylFdILG4IxArrXWeCMAZBUsYFC2QVlYzjnjm80W5ywxR1RTnI43XG43KNtBNVir0F09P2ZD\n", - "58Y6RazOWCdSHKWNiPODIww9aANGgzHUVMklo2qWZMscictEf3EhDiWdITbJVsqZw/0d02k6LyKl\n", - "2PT9wLIs3Nxco5S8P/tersDzvJyD3Cz7/Y6uCzLiOHfIr7u3lArH40HspmfqfWuV1uB0OrLMH3N3\n", - "d0MIgRDCAyFKnb338nfIFbaU190mYrw4X8VlJKcEuXj+tTHnYLRzRyiFT50PSFHECCSnUUqm1Moa\n", - "V6qpGCVhaspYVGvUKs+n1so6L7RaH4qsMkayl16zCUomrvVBOUFcsNbx+pruvQdtaFqTW32AVP+j\n", - "i+brj/1+z7/6V/+Kv/iLv+DZs2d89NFHvPHGGzx//pynT58C8Pbbb/Pee+89fM7777/P22+//fc+\n", - "3v/99Y9x2tMMXL7lePo4Y7xnurunFnFoNK1QrbEulWwqpSgpKDnSqFhbJbK2VMzicXi62lhyQhfO\n", - "GdgeTSLHRq4Sp0qsZBw1Q5xXJn3eghtLjoaLC4+34AbFXcncn+7ohx5rHf1wyWEqrPEezvFOzhla\n", - "c+RsmOPMxXjFhd8Q14nnn3zExzffQrUZHxw3Nzc0IxDbJ7uACZ5NcFjXuDkcZJ6yLmTlKcawpoWa\n", - "Vkzw9IMQw9c5UrnD1o5QJdEztpk0GVzbcIpwrVZM6XH9QB+8EORbBCO54NYYKJqaDE0HIY6PIwyW\n", - "KSzU8QjFoE4Kq3qGbDC6EW0lqgWDJQSPs45PP+lQWEpJ1FqYl4n7+xM0MH3HEld5ATfLcT5Ry0IX\n", - "NixRiqqyclDdHu/Y9p1kmbcGCKbMe0MrIm+J64RzIqExquK9xmnYbDYsuXB7d+B0ukcrwDlijKzr\n", - "AkfN1I6SMW7FF99q5GLbCexht5e0TC0Sq85Z1ttb2sZBbfS6x/WOlFdsU+cCsaJapTTJZu96j8Kg\n", - "zsTx7cUe223QSuyVpVWOcSXFjEfRB4vTDWKhPbmkWYM+rqT7I8dZlko5SXSGtU7kXTRyyec3/NmS\n", - "mTPT8ciyrkIpcpZ1PjJNJ7ou0JBu8fX1WOHOM8DK/f09SqlzMauU0liWiWUR2+v3Fs1hGCSUz/uH\n", - "AtT3g8iBlOhAjTFy/T5fc9ezU8taKbKvwc/LspBWuW7HlOi67mGjXYtkyOcsW+5qGt5KAR8Gj7Fg\n", - "7fCgiihFkkm1MSitqede0Z4PyTXGh9uHMQbTmmzw14WcCzFG/s+vfZ3/42tfFylj/Scsgl6+fIm1\n", - "louLC+Z55k/+5E/47d/+bT73uc/x5S9/md/6rd/iy1/+Mr/0S78EwOc+9zl+9Vd/ld/4jd/ggw8+\n", - "4G//9m/58R//8b/3sT/7YwO9eiz+2dFQ6wlyxnfw4sVKcJqu81hgjSvT2vCqoFRBGY0yCjU0MBFl\n", - "PM5ruVoFUNbiOivZ5VU22spZgoOyFqa1YKyXZYFqpFLRLZ+THg22NvrBUEzE+QzOoa1m2z/CqoKu\n", - "N0x3M94CZ4+1NWBqxXaG1CIf3X1M5yZefPg+19cv0eZIaRptM7nOzAvczgObNHDZ7zCdYiqVw3xA\n", - "GYM2nhCs/Ht1o9MObS0xrqAVORcMwhztzCP6TpZSzmwJYWQbthLmZQyoSs1gDOfPUZAanRHKN0bh\n", - "tccFT86J2S/kNGKMdAutKbx1YjXsM3ot0BReW0LoZCanFUUZ5lQQf4BcjzQKpTqSgiUdqLVicDgV\n", - "HsAI3nqm5SUpVfzl5gEILJ7uCBV678lpppT1nJ8tbhurKtZByRO6FayGHItsU62jtQLos/0246yV\n", - "DHNj8WFkmSe0Llxfv+TyYoe1IosxJlApxCi55sO2QzdF7zpqLuTWsF3AOYFatNbIpbDbbjHeo6zn\n", - "1ctXPH3mqOMWVRqtrJSYUaWQ64o1PdpqYKZZi7IXKDdxP7/iww+e8/HdNUkW/jjvscawLoaYkyw0\n", - "tGFOK/bsA0dp3BgYXYeicXNz89Bhei9xG4r4sJUuRcj7OWdakw16CBKXHaMkUU7TdP5//gF88vq/\n", - "IJ2usQZjNOsaWdaFnGXMIrIhucKv6/Ig88qlkHKkFkkCNdayrAGjDbkVSqr44Eg1c384UOpKF0Z2\n", - "ux1d19O7QMqZw/2B29tbDqcjxlr6vuNif0EfgoCUUeQYUUqMCih1llFJUsPhuHB7e0NOmR/+zNt8\n", - "9j95F+dFq/zf/nd/9I8rms+fP+cLX/gCtVZqrfzar/0aP/MzP8OP/uiP8vnPf57f//3ff5AcAXz2\n", - "s5/l85//PJ/97Gex1vJ7v/d73/d63vyENZFtuGQ2ilLPGcfaMs+Z+5tCMKBtorcBXRKndcEogY+a\n", - "rHCDY+g8JSlcsNDg0lqWLI+XSyO1QisyMxuCFkZhtZJvU62QT8iCu6cxFQM5syaNHQuutyhAtRVq\n", - "BiqVxjIlqjc0I7EYncl0TvNocwWp8sHHf4WzG56/eJ9WDPenhDXggmE6zhjTeHX7kt4KU9N6RNQb\n", - "PZ0bCf2Oi2GDM0DNkrnjLWsEUc4UvB3RtcNqATPoWvE+0PUbhnGE1yf9OqNR9L4HrTgdjszLRNKJ\n", - "ru9ltjNaaJW+66BJvLGz9uEaVasUoteZ4UpBU4p5mriLws0M3p+hyg1rRcQtHmxJeu/GkRotnRH5\n", - "WEqJp0+eMM8zHz3/BOcNRgVSqVhjOR4OpDQzhL0AOYzMvDVGYieA2haM0fRDx4tPbkWW3JoIxZXC\n", - "KI2zjqurJ9BWWhbijjOWOC+0GllOB5Z1RqvHXL98ydh1TMtECD2lJHrvWeMJ66BhGEJ4GMUY00sQ\n", - "4HlGti4L237EauiHDdZJHC3NYEfHlStCrm+Z0PWEQUTyqhlQAeUtZvOYqX3C7TFyuLvBe8/FxQXF\n", - "WpLWaGPZbHfU2ui0wbuOoI3okd3rA0ZE7q+v0n3fY85zP60bzjmGYWS3u5CRgdbnua49E8gkvdOd\n", - "O8bXWUwCdk4Piph5nnHeS4OSBe5Mk830OA6M45bLqyvmaWJdI6VkOqupteN0OhHTkdPpwLJIcbbW\n", - "ncEflZgip/lETiu1aVzo8NNEWuezA/DI8XhkXiPuPCstVSj8RhtqFfeQ83J4euvgPH+NecV5z+XV\n", - "pcwyOaMFjcK67h8qi6j2OiTl/8cPpRT/9b9+xFX/Dt5uyQ5iuWcMEZrjcJ/45l+/YDka9lsnp38p\n", - "FKvIpSCjUINVme2mI3QjmoqKjsNaOcwnSaOLlTjNDL1hM3rGvqOawhqrJBfOhWUuAv+gULWCUghK\n", - "M3aO4aLhR40OHYO+4HLzg3S2Q9dCigVnDJxPcnFFaC4vt2x3nmEXOM3w6nrioxfvcThd03WGMfTo\n", - "JvT4YB2d9+x2O3zwpCrdo9eGYRwYepGElJwoWb5NiiKFq2XJX4mggWA6cbycN/7aSAcQzydtP/RY\n", - "Y5mWmbvbe3lxlYo1hmHo2WxGxmF4mG0dj8eHjeL3pjvGlKA1Qghnj3dmWibB4VmLbrIFfb0o8F4C\n", - "0JoGciEtM6ZFSly4uhg5He+5vX9B73dYp3j25BHeBfb9lo8+/g7WFcYwsNtfCuyiNpSy5FpZU2Wa\n", - "Fw7LwifXB97/4GOub++JWb4G+/2ex0/f4PLJG+wvnmBVY4kzrSJ59Icb7u8+oKYTTx5dklfogkbY\n", - "QpXdZqTkiNVGDudc2O+3gsKrhZQSwYqbZLe/QBspMGM/0Pee8fIZ48Vj2pOnKLOhxkTLneSo20Kz\n", - "vciMjKFph1YOSuTmo+d85+/+H24Ptxxu7x6u4bVU0Ss6j3UioUI1lFUM3mOwMkP1RmakSa63nfdy\n", - "SMT1IS/JWodzDucsrXGe47XzHDk+gJ67rqM7y7YOh8MD8b7WzLKs8pjneAitxf0UnCyRdhd7nj59\n", - "xnZ3KVfumOWmpCrLsnB3e8vxcORwPMjV3srn2xDIOXN7e8vLly9JKbPZbNluZZmnkATS1mSL7zrp\n", - "hH3weOdECtXAhwBnFUEuhVYboQt03eZc4KUZUKoS1zMFC0VThv/yJ3+R71ca//kgxEeFzge2fUdd\n", - "M6d8g3GOjfU82ffMn7rk2397y2mqDIOh2zhqSOjiME1hKhh1doqgaBoh6yCnfl5W5iliUZgGHoXX\n", - "imYsuoN1bdQSsa3KqZwbLUqspwma4iq5NS7CFbvxMY/3b3K5f8p+vKKzYvJ33uOtxxpFzHIN9MHi\n", - "g6FSybvKm/uFT10+IpcsWDAjsNqaC50PKNvYDJszYl+uuaa91ir6c4aSzNliEgtaWiJNV7rSmNoK\n", - "iODdOoMGefyWWE8TxmhCL9rQZZk4HO6JWeIdxl5ebM77h1iI1xKSnDOnaZJFmhbi+rzMoDV9CILN\n", - "01rI7Naizz9qqSgthb9RRXCuLaBIZaKoxrrOOF14dfOKdZ7o+w3LtDDaAE3jfeDlzQtqbVgrS6uU\n", - "qzzXM1Vf5k6iLWy1UVOmC5a+C5S5orREGQybPdZY1vnEVCGXjA+S0ClBa5rgNwQ3QlmE4k/jcrsB\n", - "LfTzoR+pqklUtFLCyqyiHTRao7TidDyw2V8IP1QbjPOoZTnfbJqMKvQGNiNGXwKysGhny56iUXNk\n", - "eXXN6e4gB50L2P2FJD2WfN7MB9koo2i1CB5PVWZnqakS15Xt5Z7ddk9wjqYNnCU3uciBWEsl5QXO\n", - "xeT13FGff52LBJuFcWDcbc+EKrGc5pxoSjrMaZo4HA7c3d09LGGs9egQ2GxHfDeQcuF4f0Ab0Mgs\n", - "/fV4oWqF6RyX/ZXcSM4jl5ST3Dy1kg6ZlZYLeV3xRrSy5pynDkriWrSVOBWQvQWadT1RaiatmeW8\n", - "bR+Ggc1GvpbLPBNjkgYq5XMBVees9u//8c9WNH3bcbrLtOW5CJq7ws0nmv4J+ACf/oFHGAzPn9/i\n", - "vEH5c+yqq+xtx4gGa7g/LcR5ohs7dE2oktGnBZsye2NR/ryFL5XjdMQag7Yeby1mdDhvWJaVtGSc\n", - "h2RX3NjRjY4n+ye8ffGDvH3xKXYXe2H6WQ1O4a0sQTabDS4IJ9IqGUKXlCk1k1MieMX+SSDHldqg\n", - "INEBSiuBV3SdbBfPL5h67mCEd/td3ZhzmhAcMWWiX86uliz5QylTS5brM5KSmJOMw5WW7Pi4RilC\n", - "zsP5DeD77sF3W0ohnfWQ4qaQN8b17Q0pZ7quE4huEOdE04pMo2mFdQ5jxaJntEafdW+vO1SllAjN\n", - "ncNkQ7MG1SpLPKF15XQqOGfYbnag4P7uFqsbm82IUvUsp6ronBnGwOmUKCUDlvo9XfAyz0Ja8oHQ\n", - "Dbh+wzQvLGsidCOpFtZ5ZbMZ8EaWNY0sgXBnneG8TDy52pFjBGvpg5C3cl4ZN/1ZfuNxzrMuC7rz\n", - "cjA5fxaEe7SVyAu/20O/QdmRPCW0bhBGtOlpVQvLE6gVlBbJzauX13zw4YdM6wQlM08nTtOdzPL6\n", - "Ea3V97hb5HaTUsYax/1yYlkL3amiRkNOSQomfE+scXsgQb3+Xi/Lwv39PdM0scZIN/S89dZbDJsR\n", - "4yxxXclrZD0rEow1DMPwsF3f7/fAdztN+/pKDMynE7fLNSEEodpbKzCQWumdZQi7h+0+CAXKoCg6\n", - "EZyHYaD14/nP6PMySyRCtTWm04lY8kMXXbKMI4a+l9exEnfh60VRjJF5nmitMc8z6yJLSmss1snz\n", - "s/9Si2Zve7RqlHRkCA7V7cWXvESc9+xt4AfeucKFjhc3L1FaYZtiXVZSD+5iQ3/G498dFkhRoku7\n", - "TB4LtjPUmMG0eQAAIABJREFUoqnKEquiaocLms4HNv1I3/f40KO0YskLyxSJKVN1A5vpg+fZ/tM8\n", - "uXiT/WbDMPY0XUhkbLUscSJXi1kVpUgGuFyZemouaM15+9hByyyLZV1mbGuyMVYKdb4G6irSB+et\n", - "ZFub72ZzA2c9nAzvu+AYh16uxdMk/EFlRcQ8zdze38pGlEbXS0Lh8XiUF9w5GO615lUhOrq+7+Vq\n", - "fZaGvC5C1lp22x2lVbq+Yxz+X+bepGeyLM3r/J3pztfM3smHcI/IqYrOLkSjVrNEQq1GqFnxXeoT\n", - "sKL2tUbs+RT0gk2rQSWoJIvKqsoks9Ij3P0dbbjjueecXjzXLCIFFBIIZdomIjzcX39fs3vPfZ7/\n", - "WGGM6PVe9nuJOCsr6rqhyCu0lptZJEHyNUIMhLAQhQznHPIsxXAHCldgjBBKRdGilLx3m82WcehR\n", - "Sg7FvMxWHd+yfo+JkIJgbnoWZllpwuJxrqAsWsqsJCjFOAWS8uz38t5UVc3tbie9PhaGqaeuc5Yw\n", - "0hQ5hc0YTkeCNjRXV3g/MUynNeszl4YAl2GcJXhP7iqZdqNMuBZNVVaw3ZKymuQK3GYrlsnFk5jB\n", - "ymYBSph+FMZktO0VRfnEkiLRzxwO3/D88rRKeewq2xF2Os8zMuOIRIpM/N7ZbkueWU7dHhEQuMsU\n", - "dy6VOz/Izoeoc46721sSawBHSrRNg9WGw+FItz+s+K3ARvJgFqZbGPSSIi/QRkuYxuIFikiJU9/L\n", - "A9l7yrISJUP6Nq8ykYhB4JxEEv95Euy0LkvaugZlLrBCjBFFwqzSp7KssOuD89xeuoSAD5Gqqqjq\n", - "mmLViV5+Zq3kvSlydGbXe0ykT0WW4/TvbAixJnoPPqfKKrJNS+UyhrlnmSPeaqqq5v3bjMwq9i8H\n", - "liWyLIlhWhhiorKGMgcdCvzoJaGncTTtNdYUQo5Yh1M1xhU4aynyirKQMIMsK6Q3WwdZyxbpd344\n", - "fiSGhev6hqou0U6zxLA6HNSao2mZpp4YZrF/kciLmk0JeZZTlIUUh/kZP0uWIwhulFKQkquQ6PoR\n", - "SFRVCX5ZL3AB2ZVi9eAuaGNBrZKKtbLWr5IMEDYzL3NKX9P3IwuBarNBh4SfZiIwrDILCfOdRBSs\n", - "pZVzWgXMbuXtTOZothsaJdqtlBJKG8bJczqdAMhdTeZaNs3u4txZ/MwSIxE57Bfv6U8DIUiwRfKB\n", - "yU/4JWBciXMF1mXcXr+WsrtxRqnINI0UWc4wdaAWrLLYPGNaZpRWFFlJ52eWBMZklJXc0KdpkYdp\n", - "ntFNkTQNWJMx+wWlJNxDjxPj1LFpDP1hpMlyEZv7marekOJCUZQcDnu0u5O2x2WCxRExxEzj/Uy7\n", - "2TF0J2JCFB2ro0XXGSkvya6+ItgG/AI5glkOMwzPqDojZtfEpDBpQUnjF80XX/J3337BMhz5qz/7\n", - "dxzHB2KeePz6nqfD1xibc321u5AuVlnqqqGtagJyUJ2hlixzvH37PUzmmP24fo9CjhVZxjSK5dI5\n", - "IZqauqapRQealoX+cGCaPbP3KK0IIRH6k9T4xoRf2z6dM0xDj1Ia5ySVPsRAWA9VpRUuUxLfFwPH\n", - "/UHE9SnispykzGXyzeoSvSzUZXN5mH9XWnTeXmKU+u+m3pBWXaa7hG2k9UGcX4YPpZSQv0mhjTQ0\n", - "GONQqIsSIMaIWUX9f9Prt3ZoLnFBK4/NDCoWVLrCqIG0KI6nhRQHqrImBEXmSvIs0HUvMsGlDOcr\n", - "0tLQ1huuq4wY9Lo2OZQrJVUFhTIGZ3K0cVhjQYmDIHPCEtZ1KxPDClQPfU8Cjv0BZcSVoIgsS7gI\n", - "+ZVSq0wj4iexeCYSKsJiLYVzpBgIyyzZgSvZkueZiHaDpLOEEBjWbm45KBUi8ZGJKqZEiiKCzrKM\n", - "oqwvTPY0jUyT4HLLslDXNUVRURQ5TVOxhAVDoqgKMmfxy8Lce0IKAlFoI6ttWC5TkmBS9rK2GWOY\n", - "p4l5mmTiU5ZxmIgxUhQVNrOU69pujWFaA3/PjO15Gk4pMs8TQ7cnLTNKGfKspLAZdVHJzzvPpLSg\n", - "Y8QYBFLw4qBSZMwhYFxiGnuqqsH7URKudIQo4vQsd7RNQ5HXmCzn48Mzh9ORxUc2mx3vvnjDbrOh\n", - "73u6voMAVZGRuYx5HCmcxRkLSVOVkjTfDz1KKdrtFWGWNsNpGkQGVor10DpHWVUYZ3BlQZFl2DUo\n", - "JGnQRU1aRsKxZ3g8rY2hGcX1jG2vSTq7hJFZq0kYrLvhi9/7MU+nF477gapqsZklzwqKPFuvnZ55\n", - "nkgxME4js19YlgljLLMf6Too8ieKsuTUHUgpkWeZEILrwdD3PVlWcjqdZHWGy8bhXEZVlRiV8OMs\n", - "Ns3ei6xodf+UZUWM/jt4oGwBXXdinuW6PV9XRVGs15ambdtviUb17bqfZdkFVz8fpHKvpQsp6b24\n", - "mqyRa1ivv99p0FYmdgkcyQVKAiB9+3UwKCUHrXYZyWppnV0DPlD/AylH/zNfh9MjTkVad0sKOfMx\n", - "oFxiGRfSHPn0zTObNtC2DZkp2ZSGuQukEHl1/Zrr3WvyesMu22BNjlaigynyAmMLlEbSVpLIX6y1\n", - "oGRN8OvqIAeX9EVLWnPEWk1T1qsVTNaIZQmrmV9d7GXTPENKmJRYonxf+ECVZXijSXEhLdIzlOXZ\n", - "Kr1S+Dms2ZNizTPWSsuhkTCJuMo6Yowi8rbi1sA4gFU/N6EU6+Ela5ExhmHo6LpOMgE1pCUwLx1+\n", - "WZiC/AwaefLHFPGTX8F3LeRRFCLhzHzLf8t6RQIfRkI4C38FY8ryXHzh66/F+K2j4lw/odbg2vND\n", - "IYSIQZJ9hmmQWgilqVxJXjgWP5BiZJ685DK6XJLTrSIGYT2VAhVEwZAZS68TEHCZJS8KglJM00w/\n", - "TPhp4XDoqKuCGBOnrictmmxXoEt3mVwkT9ThZ880B6q6YRwG8ixDJcNmc0VcEnYVfC9BbtgYI9ZZ\n", - "lLVEpaluXxN3tySbo7oeUg8qI/jIX374OUVmuKtaYcVdSary79wZUnlMgs3NG7549yO6pwOFK1Eq\n", - "SZV6pqW1YBIcrxvkM86yjKqqxdIYJ1lXh4G2kmSjYRhIITJ6SSoyRg7Hvu9Wd1BYlRSNaC5Xq+cw\n", - "dixhoWkbGTwiNM2GqtIcjwf64USMyyr7yUlJrlO9ypjkwZku4vjCZes1I8RTiCJ2n+eFuo4r/qkv\n", - "EMAZKsoy+XPnr51glXrJQzfME36Wo89PI5MThcdZ9pitzqNgFpnwo8HEGWbNWVMqldN/8+u3dmjO\n", - "UyCoRGkUySjmaWHqRvrxBb8EZj/zsRvxc+Lu9jWmKtlsDUVW8e7mHbv2FrQmNxlKJ6zREuu/AtUp\n", - "wcSCw3CJl7IGa40kq6yyC1Rk8eKYALAObu82aGNEgBvlaTyO4wVXSUn8yrIeKYw1+CBss589duvE\n", - "MWIsWV6gjVi2/DIRkwR9kLToKp0jhcA8Txy7E+MwMowDbdNSqeoiJHamurgtzo4MEePL10BFEfCu\n", - "MonMZczLjJ9mhmkErciMIXOWuOoXTQZunTq/a3ubVveE957JB/F5a0Nu5UIOIaCtpmk2NHV7kRWF\n", - "EDiFI8t6A5+dFUI0yeQQFvGDn1e6wuVYbSizjLYueHr6CNGxq0tO/oWKjBQ8y9hhq4qqKAhLIM+E\n", - "UQ/TgnMFmQs426MmyfkMFKAMVjt0bqW6+PM9dV1TFgXGyEOkLFrCPFO3GxSRoqqZ/TOBGT/1oGCe\n", - "J9qqFnmZFU2fNo4UDTGuh8PoubpuqauKJSqy7VswLWSWw4e/RqcjPnlMNAyHgU45XB1YhpGs+vY2\n", - "lTpiLg+Zm1df8Oviz3GZY5h64hIwVuF9ICoo6hq9NmXmeS4tkSHQj5AXEv12GDr5DFCUeU6TlRdn\n", - "z3kbODtmzhOhXTW6j4/PdN0JbRREST5rNzV5YdEm8fT4wsdP39ANJ3bba7768h1lXtKspBgK/Cwb\n", - "zjRPdF3H4gJ1VVG3LfXaR39evc8PWuCChYIceHVdy7UGoA2ZFYkRJIJdBM+Sd3EV1cfLwQ1ctKXa\n", - "aFKEQCCayELCL15yDmKicNnfeHb9FomgDc5pMlugtbyxi5/RSTpG8BIq6k+BpZYUly9ur2nrK7b1\n", - "TmK5UhC8hUQyCjLQWhG9BJRao1mSRitEl5bpyxt3ZohTko4Xu+IhLsukSN7KCL8sM2UpxMs4jhd5\n", - "xrmHxmZ29UUrTl3HN58/scTIZrsR3HQeybIc1hX+PKGldT0/rxoX7EULk33qTvSD1My2bSvryGUd\n", - "EtC77/vVoWFZwsQ0zWKxXJn1EBc04jcW94fGZTmgICWcXTMMUWi9dgBF0QE65zBbwzhLXUSWyYrc\n", - "nXrGcaKuazabZvVcS0NvjCIFOq9Z5xtAJpbl4i1OUTqDrpqC6COb3YbSWvpTR4oJrSKzHykLwTy7\n", - "/sC81vzqpIhKcTx2FIV0gqu157vKCoZhZhoGfFJorajrEu8DSsmNOM+zrGEuUVcbwjTJpK4NRV6y\n", - "Px3ohw5nG0l2dw6rBWtdXIY5k01Wo9VC5uThYIzCLyN+UZR1Toi9TDA6Z/P+K8bDE/7lhW8+foMz\n", - "gaYucbnF5AYIkIwM4knaMaOWKpa8bAjW0r/sCSmwPzwTg5Aq2+0V1ze3sIZshBDo+46UEnVZ4ceJ\n", - "/ngi2+4omxpbS6CH2B4lQrBpGm5uJPT4fA2KvEmz2Wx49eoV0zSITzzB1dU1VV0SwsLsPVXdsNle\n", - "M82B47Hn06cHrq+ueHV3R71piSlRpMQ0jpKb6ztIMiUGoCqr3/CrT9N0aQ09r+TnCfOynodlleEN\n", - "xBjIs1xS+6MoR2QTU6uMz2Dtmv4UemIUPagxFqs1uRFJol88AZlcx3WA+q+9fmuH5tWmZOo9MSwM\n", - "hw5jwE8LyinyvMItmsXmuNQQBrBVw1V9x6bOsZmkqYdF8MHMalH0L4F4PpBSXHG7sKYxi9XrPK6f\n", - "ZTaSr6jJMrOu3oLJ+CVAEv+rXV0SRZbz+eH+kuSiyXHGkjvHvHhM7ng+inSjrCqxfeVyMAlzZ1as\n", - "UA58s7KBXd9jnKXJCsLK9AlQnqjq+nIhLWGhLAu0MnTdSSRHrpAkmjBLZmDiAp6b8wQZpAoEJd59\n", - "rQTrVYq18iH/jZCFFAJ1UYhAvGlWYfTMYerxheCnu6tbqqoGIn6Z6PsRP01oLe4TQBhz1CWsoZ9n\n", - "LJEYFEVeQ0pcX2+x1jDME85qJj9ztWvx84DLNNMYGYYJZw3TNK6NjoIpS6yXIsQIEYzWlNYxjjOn\n", - "3uOniW4c8CESl8DQd8QUCT7w5Rc7UqhFHpOL373relymyLKckBJd3+Gt43Z3Rbc/kpU5S0oYgqRN\n", - "BU+7uZJA3wh1VWOyGrQ4gcKi8IcnPBkuA11Zrq5b/vwnf8qmbvDza8oUSGsaE8iEuQx7VLklJWF4\n", - "v/zRj/j4lwv744GUIqdjx+k0kJLGaEtdlJTOUWy2PGnF4+MTY9cT5gU/TizlTGa27DYbrLMSkhOj\n", - "sNbzTNvUVFV9WdG11mtAh+bqakeMLafTEaUUd3d34iJaFvq+o65O5HlJ07Q8PT3z+PTC5/vPfHp6\n", - "4Pbujqvtlm2zo212tM32ou8U0tBzCke01pdUJqXTSiiZ1RyRo/X5wZ/our1wEVXNHAPBB/GwG4X3\n", - "C113YpommqbBGHtJdYor6bksC/Mc1nskUXgJGZnGEW3MxXb5N71+e8VqemZUPYtfyJaAmjXJTDgN\n", - "RhtsUZLbK7K8pCwKCmtxdiZgCLOsEiHKSqqdQa+xVj5FjDMQICTBmvLcYa1MQpAuIl05MLlMmSEE\n", - "5nmUcf68hi/yBmuV8F6qgeOqlVu0WlnjtDohMkyDaB+NxFHJhybd203TMI6eGPuL5kwpWLynO504\n", - "cE65VhR5ToiR0U/MYcFpg8NyOp4wWpo6i3ydGgHWEAaRDpkL5ikXi8DcahU653l2cYGM47hitiv5\n", - "FANZlvO83xNDpCpFdTBNE0HJBK9NRuaKlRyTG+ywfwECmSvQOjEMo4ivh55plp75dnOFigtFkVNm\n", - "iV2dEUbP4gdcXkBYeP/2C+KS8L6XzMruAwQoXcWSojixnEaz4JcRl9cYrVAssOLaPniGceI4zvTd\n", - "RAiCi0nO5ExhDJlVZIUjq1ucjnT7e3Z1ydPjC29fv5Y8xqComwpjDXld0U8T280Oo5xYYo1hmEbK\n", - "pqZsasYp8ub1DVy/JaQM5XLy3Zb+4RP3nz6TOcvbt2/59//u33P/8sj7sUO/PNOWLcnWItVWwGJQ\n", - "pxdSs0OpjPdffJ8Pv/hLDv2Rtm6piw3jPOD9zNPzJ47OkdmKmzu1TtQRYxXbqw3zMnE47tlebZn8\n", - "SIhrkWBcUAmU1pAEHkopSVp7lq+Qll7rj4cVzrIcDge6rl8Dhguurm/ZXd8RCPRdz/PzE49PD3g/\n", - "iYzHOGIA0LRtQ55XpKSYppE8zy4yojPeWOQNqhCrslRcGLxfmKYJBeKcI7IgZo5+HgnzWc0i4Sze\n", - "L2v0nVrdTIEQ4noGCHzRdd0lA/RM6PW9pD45+12M+T9//faIoP7E5AdKlwguooJCe09MkTLfosoC\n", - "Ywrx1TpxgsxhIU6TlCKtk1GWief0zGivDiohWLQiz865ghHvJ2G8/bcHyiUVfF1pl0WyFe2Ke6Yk\n", - "2OHxuK7Sw4DLheE7O3bM2nuTZr+ub7IizPM5czBcJlxJwvYXllBrzTCMeC/+2YD0dmfWiSc4QZFn\n", - "FEWJ0eYC2iv4DiOZ0XWdgOyrpSyEFaNdGVH5uycRDxsJgvV+XqUZkl0ZY2LoJ2IKl/W6Gwb6oWee\n", - "PdZpbF7gssTsZwhyYE/jyDxNdP2RTbtjWcIK7HuOxzVFJ8u4u7kis5aizNg2FXVVCFZaiF729PyJ\n", - "w8Mv8YcDc9IoNG2bM55GbL6h84noJ2LI0MqKgN8EXJ6TxwI7RwKzWFo1FFlO7qR21/tZxP6xoMoM\n", - "bdtgtcUoxTwsbOqa0+FAWTl89EzTgM4MHgW2QmtEZRE1KnMkrcmaAqst4xy4zgTP9OOIRaP1DSF6\n", - "dJrFapkUx+7Ept3xB3/wd3h8/JquHzD5iDsdKHclKhkUAW0d3edPVDZHlY6sqrE2x08Tg19IC1zd\n", - "7mStNdB1HafTI58eP1EWJXmWUazGhbquUEpRVZIxMPtZ7voUZejQjmEYOBwOxBi4vZWKFdHjiuPn\n", - "PH1qLeLw4/FZtJ13t/JwTlKS5rRm27SUucXPM9Za2rZBK/F+T9MorbJ8S8qcmwMuye7WYZ04dM6u\n", - "IMlFVThrYSUV1QrjOKVJRki/ZTVhxDhwOBzXjZL1vg5r3qdZN8V2Jak6nh73DGMPCGRF+TvKnqcR\n", - "ESMrUM6RaRiGCR8WlrGndRtslmNNgbGOkAIsGkXAGntxCACXD/XsASclafjLS6rvaL2ka8Rc1g9Y\n", - "Q0xXMa0EBujL106KNQ1mIS5hxSSFlT9HZpWlxPwvK5bitEy9uctIiouo9ltWWUrIziSJfF8SbWat\n", - "JcQomG4EqzWFzSgr+Tnm4HGupa7ri697s9lewHytRdtaFPmqC12ra5dFLs7VSdL3PcMgWOU0DAzO\n", - "kWVigVuWxPEkSfBFWTLNM9o5cmsIfmJZFvwsaeDGKDSKvpcAhU8fP6NwZJlnWWaOpwPzMlJXFUVu\n", - "icFzc3eDtYZlCey7EaXhi3bL9faaN6/f8Xh/x/7+gWo+kcaJ/f091bZk9F6G6lkMAWfLqSYxLjPa\n", - "ZGA9arUY1k1NTYExUltytqEGP1KXGVVZsGtaupdnmrZlmjqKssT7yH4/EKKmrHLy8gadXVFVt6Ak\n", - "eYswsIye/bFn2265vrphnALl1pJttlJ9y4RCM+/vUVNiu71iel6Y55EYpJ/o6fEJbMb27g1EL3AS\n", - "kIzm9HykMAfM+w1oQ1ltyMuS3S4j+cSyPtjyvODrD595fPqGGBM313fc3t7y+PxMW0vL5zzP7Pey\n", - "1nrvwUDbtiglXUDO5uvDe8D7wPF4vMh+nHPUdU2MC13XARITmWXiXX+8f+DTpw+yTWWObdPy1Vdf\n", - "0r55K06j05HD8WF1Ckkk33czCaZpRmu7CtVzyjKnH06rFCojhcg0+TU1aQ2YDpEUSoGB1jXf+4Bz\n", - "UmqntWKzqfF+4vNniaIry5K2bVeyaebx8ZFxnHDOrvDCZiWa3O+uTtPEDOMVKCNd5EoKtJZFoW0F\n", - "WYHLLc4K0aC11HpecDrkzUerywFkrcUqIYOKoqCupaojBE9KiAsok1FcyIkkuHtiDSYoiFFWORGP\n", - "e0L4NhzgzOD5daJVSuHHia7vGY4dmRNMtClKiqJgipIeY1dbodZKAlFXUbDRTjInnUWv/dAoRVrF\n", - "vKz4Y4wLXX+6iG/zLMO6HGsN4yhavaqStUowWfEYS32tiHeXlYW3VtjgruuwmSMsnvG059T1LEvE\n", - "ZmIPtNay3W5/QzOX55Ksk+LMNIm+b5omZu9ZQkClwOnwJAfz0JOSNP0p4yQY1hpO/YncOUyW0TQb\n", - "rLYsQfHwsse5QFbUXL91vHaa0/FAXjfsXx4Zu0dC6DExoDOJnlviggkGFmljTCEJfItDkeOTxypH\n", - "DJL8bZyE8laZo6xyen9iAQ7Hg0yJGspNw7a9JUYYl4mb2zt22yva2zuBd1JCDSOLn2jaLVpBmgeK\n", - "jdRzLLYQh5fWpARZvaUfn3Am4/bqmsPhhcEPzPPCz3/+CxSK7//+75O0k68NLENPvWsgh6QCCsgt\n", - "/PD9V8zeczoeOXQHpmmgqSt+9L0vsSry+PyAXyZAc3V1g9FCvC0xrA9qgUaSMliTA4nuNFKW0LZb\n", - "rnb1mskpwSBVVZDnJUopjsc9XX9gHCeuru4oipJhGJn8gnEWF6V2YkmBj/cPlE3D7etXzEHkXt1p\n", - "WLFKt96TgaKQa9b7hXEcOBxeqJucsfekGKlva5Q2pCIxDiOPT0e60wltNWVers2ZjmmaqesaEDIu\n", - "xPFyXy9eMMrDfuR4eEFrzaHr6LueLHe4cofNc0ku8zMYTZP/jq7n169v8VNkGkeiTwyLx6sBHcRW\n", - "Zs25qyOuU1Ip4vXsnA+YrSkt7nJTn2/wlL4jDVq+c0iZ6mL9OjtYRK8JWtnV52xpmoYQI6dOBL/S\n", - "sLdcIIGzjCHpRNAiV9puWvJM8J8lSHXo9fZaLtKUmGbP6XhAK2Es86ykbRpJYylyAqITDCs84MMC\n", - "IaDVWZs5X1b9GCPTNNB1i4Dn68SrteF06pimiboqGMZBNG3GMPtZ+sankaEfsCv7b5xcAn6eVjxH\n", - "ft6z/XKz2aCUtA6e8VMFDONpxTRXPawPjOPE6fiMso5p8VxVLTEEnl+eKd+8Is8ykYFUjt3VNWVV\n", - "UxWVuFNmzzCd6PYPnA5PEEautjt+8O57DO+/Ii2a//ThF8TjC/M8UBYFyzzQjyNLWr83ZQlrMM3p\n", - "dKTcVORFQYqRXFUoq8iNwSlDSgshKRIZ9W4DStFsdnz1/d8nRkVV1fT9kdevXrPZ7uSzAsZhZPHS\n", - "VomC2jn8KORDkWmMyUg6kdSEMRuGx4+kceLr0wOzX7hqS5bVgRWXSFVXzLOnRLIG5tOe51/+Bdu2\n", - "wm4qYZpVYNuUlOYGH0fKMqOdpRRPA3nm+FvF3+Lnv7B8un/k+fmB7XZLntfEGKiKkjyXNVyj6XyP\n", - "Topm2+C0Y1p7hGT6i4Q4k+ctLjP4ZeCwP/L49CAxcC6jyItLy+XpdKTdbMgyx+l0knzL4+kCB4ht\n", - "1zJ0vRSs5Rlx7VgaZ4VZZpZl4nQ6CEz1QaIIt1c7bGkoixLWskDnMvK8pG7KNekrokIU6G6Wa1v+\n", - "TrvKCAPWZWLVVIa2btBGcX3zCpc7zJpBavMMozUhCsxQFL+jh+btF28osoKnw4n7j585PA1inTMZ\n", - "tXOitUSBVpRlQdPWWJPjMnVJoAYuZv8zmaNUuuiyzuvH+d/PLpUzYXLGGF1WkBc5i5/x80yWFeRG\n", - "rViIsLQ2Ly4+2XEYGIee66trEQMXcmANg3xogx9YDp7MKqyCpC3d6cTz8wtfvntLXVXkRUnbbDge\n", - "j2RFQZY7lJak6a7vpZaBCEmmzvOheT70x3lmGAaaprlINc42TWM0p+6E956Hhwe0MXTTwDgMWG0w\n", - "SuOXBd+dVhVBlCoKl6NJGCsuisPhcCGszsnd54fUsixM034lnOB4OrDfH3h8fKSpa3RuMVGRVSW3\n", - "uxs2my1ZkbFta3a7G6pmR1GWGCX95C5z+JAzY3DGsn/uUcuCWvbUu3coVfLV997xfN+ilUiI5smj\n", - "D88s9585hYVpWfAexmmW6LbZc4onMSNME0VdUDStuE8Kmdqb4payraiqkvfv39O0Ow7HA8vKwFq7\n", - "XmtKrrslLmirxGmVF1BvMCiKyRPTQAgDOiSUySHNBDxZ2XJX1fzk3/xb/NzS9z37/Z6rZkOe5/ix\n", - "o1x6lMk4PN8L4280b5XDKo1KnqvrLb/65SPT2K2rbCl/1ntUSmy3G7Kywv3VL3h6+sinTz273Q0x\n", - "BjZNQ5ZZ6rrmuD/il4XH+ZFpmWSbsIa+P7E/CN44jtJL3zTthTQ5HjsUllevdmts2+OKIeZkueCm\n", - "0zRR1xUhRP7kT/6EP/3TP+XHP/4x0+zpxp4iL4h9T4wzeZ5d/h5JaNe0zQ0xCRmaVTmH08Tj05FN\n", - "XVJVFW1b0TQVXXciRqjrnM2mxdiceJZbxcg4S47mVbMVuWCKLOtkq5VaO+DNqj6R7M5IosxzMZro\n", - "39H1XCmDczk3NyUQ0FnkeFAEH7E6J6LJy5zd5opms6XZNOTrSnp2qyzf0VOF4MkywS+/i/mdRbtn\n", - "nPIcTHHWgInk50heOPIiByVumRDkSSZhxoFc2YuXGkRcneKCHwdZ0+O0Jr60zPNI13e87F94fHkG\n", - "lRj6kbKocHm5WiYTrnBUqabrexILeV7Q1jVxmXl4eJQbNSvIigKz2slUFAD/bJ2c5/miH1XKsN1u\n", - "sVYzjsI4ZllGUorKVGItMxY/ewY/oUlkRhK5+yUyDEeybOLq+oZN26JJJKU5nU6Xaf6svRzGQdjK\n", - "Uf6LLWYlAAAgAElEQVTex+dH9t2Rp+cXulNHXhTYt2+otwVX11dc7XZCQOUFxlqsSVS5BNs27ZaY\n", - "FK4UVn3MwcQFtZwYDs8Mx4GivmbRkbjk6GILNuLMQomimwbSwwt+karaFCMPj5+wx4If/eAHl/Vc\n", - "o1j8zDAPlM0NeVniikxcTVkOSjP0A8EvzCHgQyIc9lSbjYRIjKO0hxqHcQU6q0jWkrRDZS1qGVB6\n", - "QesKEPIjb24ZP3/i48NHvDb8xV/8nM/396QFfBE49Cc2w8j8/Mi8eA4PnxiXhTSOPPz6F+yu3+CH\n", - "Pb4/cjj0EjOnxBhxtuFaZ9iUW66tRanv86tfOT5//rhKdfI1/s1TlusDMATGeeZl/0K9afneF1/g\n", - "/czxuGcYOmL0zLPn/v4TXdfTdT3eB65217zs7/n6m18SI7y6e8ubN29Y/MTj0yOn0wHnpNI4z3NO\n", - "pxN/+pOfiHTKWdqqxqCwTkNYyLIKm+cUdbtWZGjyvOTq6gprHX3fryVv35JFz8/PWFtRNzkQ6YaZ\n", - "rLAUNqNtM1giWbkQl0hW5NLSmTkSCa3MCi8FhtXtpKORBCStUTERU2T5b2iOfntEECXeG3Kn2VXX\n", - "GBzzkMCBI2e33XF7fcP17jW77YaiynBOHB7nKfNcFTqvnuez1quu68t0dsZQzj7Yc9/JOS2nKKTD\n", - "Zp7nNSDArL0yE33X4WfJGYwhMa9C7127ZZwGrHPc3tzIwTVJEnSWiYD4ZneLyRzH7shf//WvCDGi\n", - "jOXj/Wc2VcGXX30PgHfvvyCEwK9+/Us+3X/kkOUoJG1GaU3V1CTiRQTfdT1aq8vPcy7SynPBrE6n\n", - "wwWOOE/ZMSUqJ1FZcQmkCjI/s/hAXdcEv1A3JcfjccV2Bcaoqopp9pfAYRAm0ntPdxrI85xpnOjH\n", - "gY+fvuHjxw88Pwhb3jQbumGmaXbcXr+T99UPhJTT9x1h8fh55vr6GpcLARaOnqurW+Yiw6RI/+J5\n", - "+viRcd7zVXVDCIldozF5ZAolKRNFRGYbrOlYgidFD1EIDJc5SQxfN4+4RGydUVUtZV3LgzfEi99e\n", - "4sImqcXNHE1TrVCIhF/0/cD13Q1125JcQTQWyTQya15mJcFF0YCW4GVtMvy8sH945Pj4wsPXT0yn\n", - "Weqf/cKnrx+wtuB0OrI/nHh5fqRwjrhpef7FZ54//CeywnA49Rhtubq55tgdmH2gbVuOxyMpKZ6f\n", - "n8St07a8e/fFKsEZaZqKupRJLYRAls3cvXmDyzJeDns+P9zz/ov3tM12TVAf8T6QkmaaPMMwApqq\n", - "koHl5WV/SYoqy5LNZosxihjF5eX9xDDMNI0EbvR9j1v7fbz3LGFhiZolaMl1tTlX17dkWcbxKH71\n", - "h4cHlFK8evWKqqp4eXlcZXuSYVpWFU1VMS+yyjvn1i3KsqkacqtghY1iCMyT3D/F6oTqlxHnrGQQ\n", - "nE7UZUVd1+R5Ljbk/0Yu+2/t0AxpISKgeZFXWFUS3xZM/YlaVby5e82ruy9oipq8EEYanyBPl7gr\n", - "1oiqM3N+tvJ1XXfxp54tYdLaV14sW8B6EUly+tlNsXgpp1rWN9yt2KpKkXkQkWy9tby+vcNZtx5u\n", - "8gEPw8DD4yPv33/Fm7tXUkZvv+TVq9c8PT0xzJ77h88kXbLZbkgxsd/vGaeBh4fPgjkaReYKwHA6\n", - "ndgfXyTZPROc5RzY0TTNd6AGuaG/G+R6tn5m1jJ7z9j1qAQYOYjbrCYlzdiPnDpJuznfCCmxlmFJ\n", - "x1CxrjIXC6XWXF1dMa0Ppbws0MawaVv2N0JSkBJN3bDEiePpEaVE8L4sHhY4HY9U1bhiX0qmmWmi\n", - "dBZlSurtDj8e+PXHT2TFDbbaoSyyEptIlVXERRN9pCsjKd2vm4NnXiJFWWKz7BKUa4zh1d0rnJMY\n", - "M6Mcr17dkGc5Smu600BTx7MLlTwX1Ua2BleUVS3/zCrCojDOkDAoVZEQuCAlSbVHF4A4epIzfNg/\n", - "8f/+2/+PD998IKCJfqQuSmY/cBr2fHr6mqou2DQ1db2lbAQuaOoaP0387K//gk/ffObv/Ph/pe8l\n", - "iKZpNlxdXVMUBT/7iz9fRd0DTdNye/uat29fs9+/YIzhZb8X4s9avvjiC169fo1fAtoaxmXhl7/8\n", - "FdYYnLPU1Q6tBfcOiyZGzTh2PD4+StRaVWDXPM2UEsfjYb0XDX5OzD6gtSXPhRG/3l1T5jVFVZGX\n", - "BdPipWFg9my312SZoyqrS16rQFzfJg8NQ8fT88PFw+6co2l3XO+uuHr9BaeXPX/585+hSbRNy+Hl\n", - "hbZpycqC4CUYORAxxooJZjkHWK/KGaSl4BwbR0qc1nrj/9rrt3Zo3t8/sGkmRruKzzG0141UQsSG\n", - "XXvDtmkotCUCfpRwglIlZtZCpzVXkRDxa4rJsiwoo4khUq/OlHPIhjFu9UBbskyCMJTSoq1MC2kJ\n", - "4EXCEpcAfrm4hwCqoiTGhDUZuStYQqAbeqq8FDfOSshkmcUVEiwQxgmrNTdXUk5XOccw9Nx/vuf2\n", - "assSPC+Pj8z9RLbKOwCU8gyjIgTNPC8CboeFLJfq3yWIHVBSXixl5ZjnhXx195wTZMqy4unpiaKU\n", - "ySMlOB06rBV87qwiyPNMCLAQmfyCKwumcea0P2KMpWkqxphEYO69YHda46yWpKNXd1xvNyxfLKtJ\n", - "QDJGq7IUW+QkkpAQ5b3U2nDqO0IUIXzhMtQKxGtt0NuWvN+RFa/44d/+3zDlTpLZ2walZNKeiUSX\n", - "oQqLBzSWmAL9OEiuwBLopxlrxVgQ47zqV8WWmzl5EDlrOa4Gg3zTYLFYZRiGgWzNHd1sr6QzaehZ\n", - "lomca3S5Idll7UDSoC1nhV+CNagEfvQH/zv/6ee/4jQOtE0tU/cyMQ4dJlP0/Yk8y9nubri9ueUc\n", - "5qu1JS8L6sctX35ZUa5OnKquIEV+/eGXQpLmJWFJtM2WLMvoTh1FUXFzcydSo6IQm2nV8vbNe77+\n", - "5gP3j4/c3d7yvbfvOBz2F8hrGAbpVHp3zevXr3l4eOSbbz6SuQ7nrEz722vubl9dwjPOYRq3t6+p\n", - "65qqKlf5kl8HHHNJOPLe03Un3Natw4oEs3x4/MA0DRgDr169pmkaGWJmj06ah8+P2Czj/Zc/4G53\n", - "R9k2GOeot81ls+ymkeADjAPVGqtY6vKSraCNYVomdNBkuRB2LneMU8fz45MMNGnC9/8DbZT/M1+/\n", - "/tUHmjpDZZYyL6jKkqooyLSjqm/RFgkpjp558sR1/XaZ/U6auWiqtDWYFEkhkrmMMs8l629Vult3\n", - "nhYDmdMoDGktcwshMg+C26QkB3BcPOM8SYHbGk+V5zm3t7frwRLYv+zp+452u6GwGeM4UlQlN19+\n", - "eak0PtvSxnHk4eFhLbOqMKZmGgY+r/0q4zhSlRLndr7Y4FtJlbgwugvpdXZInH/+cxqMnwO6lYi8\n", - "tt3S9z3eL7jVH332rc+zZBNaZ3nz5i0g/eJCei1opfGTQBhXV7sLC5pXMoV2XUffC9t6PnSLorh8\n", - "3+ccRFSJ0VZY+FamfT/NaGfxi6fdNChk4o+sh6VWGKvJ7RV9deQP/u7/waQMZbtBWYXSGWVRofTA\n", - "dDqt33Mizxv6IfD80l1i82JMKxar6fuB4/GItQLhVGugsjESfgFwGnpcnZM7R54bCu1gncBimFkW\n", - "RVoWMpOhokYKdQORhcXPZKYkGSUh08ikJOk+G/7P/+v/5u2rK37603+HsYbr7Fp0kJmlKmtubm7X\n", - "JPSSw+GF4/F4iUu72l5T1xXGaKbZo5VmGEWQvt/v2bTXK+Qkh1TbtlRlKY4aIh8/9WilKeuKx+dH\n", - "bK7ZXskWMA/xAvecw6oBHh+fmaYB0Lx69YpxnMgykQVuNpsVd5TjQ1Lly4uape+7i5nj7LRLKXE6\n", - "yQR37j4XJ5D0FMUkxpKX/QvHriOzlqauiSHyV3/1V2RZxve/9z22Vxv6sWcYOlh10K+ubjl2B+7v\n", - "H9i/vNDnZ9jKrCYSe7FRyv3rmWfhIEC63vcvjyRlJfvgdzWEeH88Mc2iQSNIjG/b5Hz55gdE84qX\n", - "pyd0DNRFBepb50BdVaJnRMI2Fu/JraMtC+k39h5rDFldSTXEPF1shHrtdRbyZLhE5KdVxmNWvLTM\n", - "C7nZMs1ut7vIm25ubnDO8eHrD8zBU9QVZZXTHU7c3N5we3vLw8MDnz59wlnL/f092VoS9e7de4wx\n", - "3N/fr/F0E3lmKcpC+kvSt7UN5ylRGSFhznCEtZaqqhnHkTybmP18CWfV2pDl2XphavHTTtMlmV0c\n", - "PmnFRIUQOHXdhXk/43bLEvh0/0jbtmw3rUxhxz3GODJbgIKizDBWoddE7XntlT7fKMMwrCYCdZF8\n", - "nQ/9LMvwSSo/vPegFJlzPD0+sWlb+To2IyxQb2+ZZoULkWgUS4gok+gmcVAtYSEsC8M4EJWlGxf2\n", - "h46uFwunwDBiebXW8fLygtbuO5mNEa3lgPzVr555/fYNGsU8e2bnycqC3Dlub28pXM43H37Nq1ev\n", - "sFVNyguCtuhkUWnGkljmIyrP0bpcxVmyyQTv+cu/+DPmZWK33RFTZJonbm9uL9iftW69iRXb7U7M\n", - "A9rQHY9kdg3sjoq5H3jqj4yr26wsK3G+5Tmn0/Hi4ImLvDcxRNp2Szf03D/c83R4pMxzkZut3u5z\n", - "XsHNzc3l2pOHsagHzBpLaKylyHOqqryQqPMsB/X5ofndjNdL1cmykGVO+n6MkaSjxfPpc4fWSmSH\n", - "MbHbXTFOE4fjI6fF8/z8QJFJJuayBP7sz/4jP/Q/4u76ltNpz+H5hbKsKeoKZwwWRZ45lEo8PT1y\n", - "f/9A359omoa2bWnblqcnh1KGzWazev6lffLNmx+Q5zKV+rj8F06sb1+/tUMzTp7oEqV2LICfF44v\n", - "PeE24pXnef+AX2bu7u5oqwbjDNoq1BpSEFPA++VCWFT5ObjiW7wyLAvjMBBmKas/J8HM87eHTYzL\n", - "mh5UsiyR56cnttutTK1VQZ6L62IYBu7v7+WA8UK01GVF6XJCLvjfsizs93uO+z3v3r1DAc9Pj/Rj\n", - "j3WaqqrWsFa5AH0MTMcjLpPDuluxRa01TV2vpU8JZw2PDwL03968wmhL22zWFKRpFSHnjOPEp0+f\n", - "eX5+pq4ltm0YJo7HDpd7hmGgO57ouo43b94wjxOHNT6r7wf2LzIJhKVj/zwyDSdcVjL7QAhHUIrd\n", - "VmpJhn68HPLnGLGzjEOcHhNdf6IsKspyxNiMdp34UcJi+7Xcarfd8vXXXzMOA+/fv6O2goe5rES7\n", - "gnaT0w8Dv/jFL/nxj/8XdNSXz88vC90wsz88S8p9DGuOPr8RzuL9zPF05Pvf/6GErxQFIUWeXp65\n", - "2u1YYpAwZW0ZhxG9zfnw4QNX2x13r19jrq/45k/+hKrOuaozlNuArlEklrEnxp6suiElK7imAtZl\n", - "/bR/xk8vDHMvkJFWtHrL8bBnHEf+3t/7eyil0Vrx8rJH0v2hH0aWxXM8dvTDns2mpa52GJuhF79i\n", - "c4oQFowRn/iZBBzXg+v29pab3Ya//cVb/uOf/5Rjd2QaF6Zhkv4nH3jz5s3qmCmwVrHf79e+c4GL\n", - "lBLr7bHvsNrwZfkeQDDecg2RXhsGnHMiL8vkIXU4HJimidPpRFmKGaIfB5pGjCfjMKOSyNuGoefN\n", - "my949+Y14zjwk5/8hIfPz6T1QZc7xy9/8SuOTy8ENRPnyDB5nv/6F9zdvYIgfEc/dMzzxPX1Ne/e\n", - "vUcptfIC2SUrFmRj894zTmInPnvp+R9xBI3jyD/4B/9AXB/zzD/5J/+EP/qjP+Kf/tN/yj//5/+c\n", - "u7s7AP7ZP/tn/ON//I8B+KM/+iP+xb/4Fxhj+OM//mP+0T/6R//Fr711mrKwuCJn6AaMsWzaKyqX\n", - "EyaxsXn/LIxgVYuX1lqWMBMneRKcw3q994zr0yuFQHc8Mq3s+TRNK3Ypk+l5tT8HG1xf3VDkBVlZ\n", - "rFpISTmXJ+S8kkPzWoCmLqvnmW0V3+8J75dLK19elnz6/HmdAIWgenp64v7zPfMc1sNGQhXOhNVZ\n", - "oH6OwBI8LefVKwmPuLm5pShyhkH8u0rpdT17YbPdcrXbkWU5N9evKIpa6n/XiLePnz6JBU4rXOb4\n", - "YvvF6sO1F6PAm6YhIgkz83THOApB9Pj0dLF4mtWOejgcLqVa54MzrK2G3yXmmqYlc7LCo8xlXSIo\n", - "xnFgHAdubmTyff/+PX/5Zz8jRiHy8jzj3NEdY2C32eKMY/+yX22PE1M/4OeZcZrZn07s93vJN13r\n", - "D7RWFzIwxsD33nzJZtNeDvTT+tm1bcvt7a0c9uNEkeckIl9//TWvX7+GmIjHE2VVULcbIk6cQHRA\n", - "Jg9BJV09KCWw0OWV+PjNB/Yvz0zLjO8n2m1LW1WMQ09d17y8vFDXzSV/IMZA3w9SgUIJaG5vb9bM\n", - "R3kQvLp7cwmdUEq2haIoePv27cXkMIwDc4h87/aGjx++4fF5j19mdu2W7//w9/iBgo8fP7IsC5vN\n", - "hjdv3lw2quPxxDgOa2NnxGWKq2shnmJKxJU/cM5dAmnOao55ni+xh+dfy/NixdQThXXsH17QCsq6\n", - "BqUvyUn/4T/8e1KSMPG62XB995ppUdRVvUICmrE/8vL8hLKJrNjwt7/8PkqLPLDveqyzvH4t70MM\n", - "CevMeg5IWZ84D2UzatsW6/K1PG8hKng5Pv/3H5pFUfCv/tW/oqpEgvL3//7f51//63+NUoo//MM/\n", - "5A//8A9/4/f/9Kc/5V/+y3/JT3/6Uz58+MA//If/kJ/97GcXnOS7rzc/ekvegDGOeUqM0wiqZEgL\n", - "0zwzLwmtLNM4ixxlWSSS30BKatWDWbS2DOPAab9nXDxLiujIhQwBVmY9XjCXb+1b4mm11uGsHFbb\n", - "7Xb1Zce13znhsgzvA09Pn/m93/t9irygH3oOhwNlVnBADq8YE2VZSBJLWBjGkc2mZbvdroeLoqqy\n", - "i9wJIpvNBq0Vx6P4bZumYZ5nPn/+TJ4X5FnB1dUVV1c7jsfjJWjEGFa/uGPsRn59+oaskPqIZQ4c\n", - "/AmXOeZpYrvdrO2AmnHomceJcVoL1Yzl7u7uEq2lV51qDIHD4UCzaTgeO8ZpYleVon2rK6zRssau\n", - "DPrGbSTCbmXxf6P50Gpenp5JUfCsQiv68URbNSyL5/l5L2RNW7N/OdBuRB4jSeAFz4cnUJof/ugH\n", - "fPPNRxLQHY90vYiuHx4+8+HD1+wPB0DjjMVmmbR+rnmikrLTMk0yifXDwDB2fPXVe0CtUWJmfU8M\n", - "Q9dTFDmbdovRBlxGXZfkRUVwBUnFy0SLUszDTFGumZiSvS7/PyW+/8Pv8x/+zf/Dp4dPfPn+e7KS\n", - "VzXvq3KtghBNYoiBzWZLdxpXaCNQ5Bk3t3cUecniPc8vj8QI87yg0KClkgQFxlg+fPhAWdacTife\n", - "vXtHXpR8/eEj33z8wNu3b8iLDIJe8dKM6+sbwiITq9GGxZ+j+ypOxx6FpW4l5tBHCZeeh7VqIsbf\n", - "cKqdpX9nmZ8Et0yrplqMH8fjkVPXX/Jhn08dh8OB3Xa7Sqa2lEWDMiBd6ye2t6/Z7bY8PT5xtd2x\n", - "BENQRqbL6Ng2t1inuX/8mru7W1K6FeXJy4GmbJnDxOl4RGnDZiNe/M2mvUBeZwWKGEQSN9ur//5D\n", - "E6QnmP+/vTONsfQq7/zv3de719a1uKvc7sXddrqbWJiJNCLBMv4QcDKDlAmMDBJBIyHlQyIURXwg\n", - "0XyIDYlQFCJFijSJBJmJYBSNFESACRqwcGRmIKaB2J0Eu6nGtXUtd7/vvpz5cN57bSdgjYPcnrTv\n", - "/5O7qlz3PVW3nnPO8/wXmO0erZb8hj+Ky/SXf/mXvPe978UwDDY3N7nnnnv45je/ydve9rZ/9rWL\n", - "W4tQCtJcIKwCPXLRCw1TMUizDFWzcXQDDUEax0SViqfUpxJISRGaTELyvJhRf1zXkxPP6sQx3bnz\n", - "PJ2djmSPUNpGaYpGHGfs7r9Io9nCUA10XcMw7KpQTXBdj8XFJRYXF+U1MoxI04h6q06Sg6opqJpM\n", - "YQZkVo6qIHQVNA3XsaTyyFBknEWW0Gw0MAz5S0vTHFDodDo4jgz08jyHNMkwNJkfs7e7S6/fl62D\n", - "sqRZ8zF0Dcdz0XSdIs3Jk5SQiKN+j3ASsLqyjOM4LC0tSR/GyYRIFGiGSrPVlAFbtoWmKRwfH7K2\n", - "vibDqLKCNEmhLKXSqlQwVZnWs7KwSFCpjWzdhKLErsxLdEXFNS1UTSWKYylzw0JRwbJ0+qMuYTLB\n", - "UBWKPGdpeZnWJEAzjjE0CJIx/fEQzVpHrVQdUmig0OsOqNV9gjTi5s2bmJrN4fEtgijk75+7zuHh\n", - "PmmWUhY5mqljWtJkNsvLyqZMYzRMWFz0yIocVQgc28Vzahz3jlE1DcPUSdKI0jChOnWXoiArMyxd\n", - "QzdN0iLG0CxIUhRNA8UAU0X3bMpogrAtNLWOIgqEokGZIKIJrfYCt05u4Xk2/d4J0WSCaeqoik6k\n", - "V3+8qo7wXRRF4PsuigppGmNpWjWE0cny2ox/W1SeqVJmbGG7tjwhRhFbd22ioFAIwd7uHqe37iaK\n", - "Yxp+YxZp8o//+A84jixUmia9D+qNBoICTVdZXOrMNvJOpyNFDoDnurPe6VQpNhoNXxFNkef5zBRm\n", - "yhmeDmNazSaWbeF5/ks867KkLIvq5qXTaNQpy5JGvY6uWHi6Q211TQ5KhYpheAwnI6I4JAhPKPKc\n", - "5559FkVR2Ni8G89xEWXBsD+k3mphWVL22e+NKMqEXq+H53kcHh4SRBMajQau69BudzBN45/Vq9dU\n", - "NMuy5C1veQs3btzgwx/+MJcuXeIv/uIv+MM//EM+85nP8MADD/DJT36SZrPJ/v7+Kwrk+vo6e3t7\n", - "P/obFwplWmCqKkqpkedQMxyMUpN5OQDVtS+O5S7l1XyKQiEIEuI4qBrOBaKUsjbPdWchTi+3zIdy\n", - "xtecksKnV2tDN9BUDdev0e33MVA5dWoVVZX8LTllVRkMhhwdHRKEkbyOmRpZJk/Bg8EQ3/VRFaSP\n", - "pBC4nosqZG9JKnxOZn0VebIcyZ04ilFUBcsyZ30fyRkNKXJBkkykebCi4tebmI6DgiApCkRO5QSl\n", - "oZYKlqYjNDi1uMzIkiRkqYgSM+9Cmb8iLcN0VUU3DZI4ZnNrc0Y7qdXrpGmGaTu0SsHaqmzV9AcD\n", - "ut2TKsTNJo5iGna98izMZ7u3HATJDawsBGVekFJgmToH+wcMqudKspQkTVjsdKh7HoZpsvPijnxt\n", - "w3wp4EqBLEsZjV2G/Yh+f0KR9tjZf5GbOy8SBmMMS3qT6qaL0JDZ1aWCaWsomo1pGNRrPmE0YTwe\n", - "oGoqnuszGA2J0gyBDJBrN5uYpjFjGARV4JiuG/iOx8lxj1auoikCVGlCoqgm6ThCVwuyCXgLDqgG\n", - "eTpCIyLJQu4+fZrhZECWFdTqTRm4Z+g4tidpcFUkbxznNOpt0jyVw47RkDwfYJ9InqTvS8ZBXhb4\n", - "joxDcVyXRr1eOfbYjMdjklSuJ8tLTp8+XWWlK2TpVEWncPXqW6Q8UpV2hMdHR+R5Vskk+7iuR6fT\n", - "Ic8z9vb2XsroqVo7qqrOONHyZ5bOhoLyNvRKcx0hBPV6g2nW1tRVo16rzXrUpmnNLA+n3OAoTEn6\n", - "J9i2hW7o5GXE8cGLmK5NnKQcTvZo1OtsbZ0hTiI838ZQocgEuiYQRS75vQg52dehXvfk4amKvuj1\n", - "BogSwnCf/f2dn6xoqqrKd77zHYbDIY888ghPPvkkH/7wh/mt3/otAD72sY/xkY98hD/5kz/5kf//\n", - "lOP4TzE8OMEoFTTboshV0kFIpsa0G4sYrklZOedkVRaP3LUEmipVPZNJIE+WTk32UyydaUjYNJ9G\n", - "atDFTCNrWZYMiE9ShsMRWZbRbNSp12vEJzFFWrCxtkKWptiOVUU6NOh2T8gyWbw93yVJUyZhRF6U\n", - "lFlGp9NB1wyCSYCCilcVvna9jqAkiMKZRdeU21YUBWEgaQ9mFXCVxBlBEc122yiJSfOcRqNBrVbD\n", - "sixGozH9fg9d19na2iKKItIkJs4KDFW66+i6hm2Z5IW085q2Kaamq9P/Nj0HTYVGwyeOYwYDOTxo\n", - "3tOSU99CzHTmQggajQaqptLtdqnX/Zn/sWlq2LaHqsqTmm3XsSs3KU1RsEyHuIjJ8pjlxTa94YgX\n", - "X3yRfv+Ek94RC50lXNOVvc4kYjKOcF2/YjokZGQIBUxdIwozjm7tQ5kwDkJEkeN5LqapowCqrmO6\n", - "khNIKR2vDFNm51BmFEXK0fGR5KaaNmUJSZ4xmYzwaz6OY6GMod8fMBgN6PZ60tg4maCbLkEYkWeH\n", - "Mi7athGKwDYddnYPGE4GGKbGVq7QXt1ClBl5FCCyGMs0+Jm3/QxRGGLZLkE0piykiKJm1Wg2m9Sa\n", - "dbpHR7iuQzYaUq+3WT91F25Dtj7GgwFJktDpLKBUzAVT18mKlF6vh2mas+GL63mYrs25s3cz6PUY\n", - "DeR8oFFvUqs1ZZ9fVXGciGAyQjc0VldXGQwGFEXB5uYWw+GwGuzU8Dwfy7bpdruVc5daiRKMqhiF\n", - "M8+H6aFF0+RAT3p0LjAcDmfSXmDm4yl9YOXpWc5Pplf6HNt2KQuI4ohBP8C2LKLxiHrDp9XpoKoq\n", - "7UaDtNoM4lSG6UVBUPVbR+RijPey/KHd3X06nZizZ89y7uw5xpMQXdfZ39+nLAu2tu7+yYrmFI1G\n", - "g5//+Z/nb//2b/nZn/3Z2cc/9KEP8e53vxuAtbU1dnZeqtK7u7usra39yO937W9uIBRVEmkXa9h1\n", - "jTITOK6Pm9tkSUoqBGYU4ft16cdYKhiG/KW4nqRpOI5DHMfEYUhncVG60wTR7A9+agRclvKXJF2A\n", - "5IDIceRkuNuTxhMbq6uziVqSxBRlzvGx3OEkoTqu9Oc5WZyBphKnMVm/wDJN8qwEpcSw61iqVQ2I\n", - "spmfp+yzyo2gLEDVYHVthTiSlIt63ZmpHjRNoxCG7HPVfExTFvzxZIzt2CwtLhEEAVE8kXZnjbLz\n", - "7sQAABS1SURBVBq6rkoFi23LgZMQuGHIYNgjSiJsx6LpN/B9D+nKLY2Iy6IAzcR0StIg4PvPP08Y\n", - "RTiOg2NLCWWjVZdOR0qJZRn0ej35eqY9k1aapkK9Jk+XSZRyeHjIxUvnKUWOnlk4VhNF1+h02tx7\n", - "Zou8FPT6PQajIZNxwGgSUYiCW91baF0Nrer76rbJcDRmMplI8reuYFpNNNuh1miiaCpZFuPXfFaW\n", - "V1CQPNM0TUiLrIoCKSkKkxLoj4YkYUhZyJz7JAmJwwiv0SAMYrI4xTQMSlRe3NklL0tcQwNVY39v\n", - "n87yAnla4Dg2QihMJmPiOEEoGpPxkCSKuU8rCcMJaZzS9F1M10EANc/BshxMFZIsI8sFmq6Q5zGj\n", - "XopjW9ju1LFqQJJGHP9A+lGORiMcx+HGD27gux71Wo3dg1s4tk1vMsJxfZr1Fo7lUQppuNvvnlDz\n", - "fY4ODyjCEsd1GQdjPNcDkaOoKfVGnfF4VFGBcpIoZtTvM5lMuP7ss+iGhuO61Gr1WR78dFLf7fbI\n", - "85x2u0Wz2azaeQJNk5zkvb09dnd3uX79OisrK6ysrCCEYDAYYFnWLMq3yEtM06Ld8un2jmQsRhCR\n", - "eQWqpaHbBn7TZzQaozkOHiqW4Ujp61jGbsdxTDAZg6LSPTzk+LjHoD/E8W2WlpZYXj7F5uYmF+49\n", - "x83tHX5w44eS9O85/MML2/zvb13D8zx5S3kVKOJVhJYnJyfouk6zKdUsjzzyCL/927/NpUuXWFlZ\n", - "AeD3f//3+da3vsWf//mfc/36dd73vvfxzW9+czYIeuGFF/7ZaVNRFK5eWiDVdDQ1RzEVUAWuarG5\n", - "djdtp0MqMur1Jq1ag1ajKRv0ponnWnIwk6YkaVpZ4kvS6vQUN3ULn8bHyqFEWcUeSFPT6UDF932C\n", - "IKDRaOC40lBYVTR0XZ15WiqKMitmYSgLpygzDMsgy3PCIKh2SkGaTknhrdkpuSikxjsMQ05OTrDM\n", - "qs9IIbOGFANDN0krLf2U/Nvt98mynHa7TSkERSn9ESVkw73daZGmsoFt6Ua1liZJlnHSPal06dK2\n", - "azQaInIZcFZvNKS5bCG1vOPxGKFKXX7veMBoOKbVanJ6c4NTp5akd2LF+5TXyITvf//7tNttZK67\n", - "h2XZGLo0k+73huztHXDu/BatVh2lmp6HYUiSxNTrTbIslSeCKsZY6CaObUu/yLHspcVRTElOWcL+\n", - "3i2iOGJpeRnTMMgpEaWkmUXjCXt7u7TbbU6dOgVIR/lS00mSSMbyxgV5npGkUUWDCTBUg16/S5RE\n", - "aKpBGIU4tsvq0jLNepMomtBaaEvKlF9nMOwhKPFcl3q9gedIAxbdMFjfWKXdWqIsBa4rSfR5lpLG\n", - "GVmZS1MZTWYCaZpOXoLjyGKUZtKYOE3SSmUj7fjyXA7EkiSlVqsxGAzY3d3Fc10Wmm3JsjDl4HEw\n", - "HmHbNqurp0jTlBs3trEdm7P3nGEykUyBhYUFoODw8JAkkX4LyyunCIOQZ555RrYiTJ1mo0UYBtx1\n", - "12nCMGU87KNoAsOQUcZxHFNWrTPTNKvY3+rmZBocHR1Tq9XJM8luGQzl9bfRaMiN15ZtIsexGfQl\n", - "XcwwTYosmzn5D4cTlheXeebb/4fzF+4lCkMG/T7Li4uMRgPKEilQETJosD8cyBtRrUGWFZimg2Xb\n", - "LHTaNBsNms0mL9y4wXg0YmNjA1XV6Pd7CKWQ6tdqeOl5Hm99x7//sRr0Vz1pHhwc8IEPfGBWYB57\n", - "7DEeeugh3v/+9/Od73wHRVHY2trij//4jwG4ePEiv/RLv8TFixfRdZ0/+qM/+rHX8zCrMskNDQdF\n", - "2u8LQZ6XaLrK+tK6lGRZNrbl4DkejuUgtIKkSm/UZnSSkigKCQJJT5k1yqveoDTx8BmPh7hujVpN\n", - "XjENw5jZq/m+z2A4pLO4wEmvS6PekNfw0bDK9kkBBde12dvbp9mq4egOjuNWul2ZeOd5Jr1ej/F4\n", - "TKfTQWZJyxPJzZ0D1ldPMRwGlWdnKonDQqm04/JnNXUUMg2DOJb5J8PRCEXVWFpqzXps04KMIsjS\n", - "DMuQOvo8l9ng7XZjRgWR1mAOJ8cn2KZJs9mUlne6zBV3a4LDw0NqtRqnVttYtmQcBMGEOG4xmYTS\n", - "sEQBRZH8vLvvPsPJybGcrGbZjN1QFPIk0em0WF5Z4Zlrf8dbLl+cTaeHwwHD4U021tfRmjWyqi9n\n", - "VEoX21LQDQ/f9xhPSjTVI45TTp9eRVF09nZ3cdpt/FodpRSEcYSSF9y1cReOY+H7Mj42iiKEqqPr\n", - "bcnJFZXbu6oShNJ0OUkzGa5m6Hiey3Ak7cXCQMol1/0NGWan6SRxRMdewLJs/MoVve54LCx2sG0P\n", - "TbeYBAMc10RXBE/9zdO8/d/+G0ChbtewdIPxZDLzZjUrPwRQsA3zJRvCiqeqajrxJGQymWCaJtvb\n", - "22iaxtbmJsF4Qppl9AZ9FpYW2TxzN8PhgJs3b3Jj+wf4nk+r1UJRBMfHJ6BIu8DReET3pMvKygqm\n", - "4XJ0eIJAY2lxgUuXLkkjj/GEIi9ZaXZ4/sY2FBlLCwusb5zG9XxGowFFXhDnOb7vMx6PuXbtGvff\n", - "fz9FUfDF//kN7rv3LCcnJ1y98tOMRgFRlFV/kyVZGpGnCadWVzk6PpJTa0WgqALP9+l1+5imxeLC\n", - "AqPREN+v0T08Yn93j/2jW7Q6i3i1OrW6PxNkLK+t01hYoOZLgUSeFdTrTdI4IYrkoebo6Ajf8xCl\n", - "nMrXfJ+lpSXCKKRW96WjkmnQHwxerSy++knz9YKiKJy9ryG5kqqOqkqChqtrXDh9gbtOn2G9s1pZ\n", - "vKlSgaLJAhmGMt7Td1yEKv0wNU2dWdpPdclBECCKEsd2qNfrDAYDdMvAcWwcx2UwGGCa0nFH9kKl\n", - "EsSy7VkzW0EOogxNq2z0pXFvmmdYtkmr1aIoyuqNJzi1eqq62mez06uCwKoiND7z3/+K//Dv3kme\n", - "QxgG2I6FIgS2ZaNqKqMgRFU1mYUiAEX+ca+srJAXBYYpd2d5QpUFtihkYmVcxZ6qKtXVKauu+Wol\n", - "p3yJMzeNDC6zHN+X/bIsTZERvDmmacnTqyJjUGu1Gp5XI8sjhCgwDAsFjShK2d7eZmlpgaLIK1MH\n", - "j6OjExQFao06a6vL/LfPfYFf/U//kaIsqujiHBmRLKe7eSl3evKMJE6lLlhAEAbouoJluoxGEzld\n", - "jXMKSoIgYG1tjSAI6HW7IBQsW/a7a7WaNF5OY0oU2XsUkJclAkGRFzJgTjdpt9ugarNJeZ6nFFmG\n", - "oRtQpZnGUQIls/eY79dwbJtms0m/35e8zhKai0v0eodEkzGdZptP/Zf/yn/+2EfBdtDSALUsSfMS\n", - "XVEQiiJjjwvpoqQgA/lUVWM4GFCUObppYJjSeUdVVVRFkrJty2Q0HKBouixyg151xS3Icpl1vrq6\n", - "ymQ0JkkixkGE63qsrp/iH/7+OUajgPZCh431DTRFI02iio6nMRwNiJIEIVSWV5bZ39shSzLCioJ1\n", - "18YmJSmWaZGlCXlWMAkCbt68OaMf/Y+/+l985Fc/RLfbw3EcVpaXGY7GaJpBv9fF81wGvZ60tdM1\n", - "XN9mOBxQZAWKqlCictztcXrzbmmVWEpHs4V2mx/u7mO7HgiFTqdFs9GWswJdpds9YjTsU+YyXtg0\n", - "DO7a3OL45BgA13E4PDzEsm2yNGV5eZlSCIIwpFZvoKgq29vbWJbBw49+4F920nw9IXR5ygSBKKTf\n", - "ZL21xOm1Le5ZOY1bd9Ffpq3WNJ1wPCGvNOhJkhAmEXEczwYl04IZhhF5Lh2MVEPn4OiQJElYtBdJ\n", - "05w0HVZX+YQwnFTZKXLCfOtgf6b5XVhYJIoiojgmz2A0GWNZFkvLy9LZfTJBVZXqelWQphlHRyc0\n", - "GvVZM9x2HZI4ks5BRUkUpViWJ/O8JxGqgDTJqDVquK6DYTtyQxCCsnwp3waUmaRS06X7TFnKKWYY\n", - "BNVUXE78pS7doiiimRVeWZazdsuU8J2Uyex6VeYFk8mYZqOGYVozr8Y0zbjnnnvQdYMolgYUSZIB\n", - "ZaUx1smyHNe1pcoozVjotCnyArcuixfIZFABGJaJKeTQZjgaUSLwPGl2a3g2nqdUfD/ZXlE1SJN8\n", - "1isbZTJlsLXQYTgYzKwAoWQwGOH7VV65qlIWAtd1CCaBbCvYNmtraxiGwXA4xLJMWu0Gw+GIosjJ\n", - "y5I0D1EKmEQBqi7dx1uNJqZh0e50pMFyxRCwHIvT9bswdINBv8+ge4v+UZejky6L7VUMw8F06jJb\n", - "qdBJ4zFJEtNqNiRNLo6q946K6zhkeY4QKq3FJcJwxGQyJsuLiucrebOKonDc7fPCC9/n/IVLdA+7\n", - "2JbFwkKHZrPF0VEfr15nd++HxEnEufMX0DUpI93d+yHrd22gIBkmt24dMB7LALJWq0FWZLKdkOSc\n", - "Pn0WXbOp1Rs4ls2g1yOMQ3p9eUCYjCf4ns808nppaZmDg4OqlRdzeHjEysoKQTDhu3/3DO3WAr7f\n", - "oNluomsavYHCwfERq6trGHYLX5PMl6WFRXrdAVmm88Mb+9z/Uz/FxvoyQTimUW9g2XWyskCIovLa\n", - "lMFrR0dHpHlOrdGh3zvBciy6xyf0B99j8+4tAJI058rVn+ao2yWOY+rtDnGSoJgmYRThui4bGxvs\n", - "7+++au16w4pmreGh60BZEIcFtaUVrm7dy/rSCl6rhaYU5EU2kz4C5GWOIhSiMIKyQLfM2VUmz2Vc\n", - "7LS/GUURvX6f6NYtWq3WzBRV6q5Vokh6JjqONdNfT6WAU8PTKIro9/tEcYLj13C8OkUm6UOyd2MS\n", - "BBMWOoukWYmqSgMM2duRqh4U0KtpoaEbNJsdRCmwXRttouPoJq12E0UTREmC6XoyKCrPMQ1JjZr6\n", - "F05lgZqqM+gPsG0bRdGwLCkzS9OEZrMJSFMNx5FXyKIyofU8f0byL4qSZq1ZDXFyTN2i0aiTFxmK\n", - "Ap3OBnmeMwkCjo6O8DyfUkjFlNyBS7yawXgsOYRT5+68SNBNhUv33UeYZtWUVVKbSmRftsxSTN3A\n", - "cR1pPlsZiliGPCHrukmSZKiqShyHM5ux8XjMYDTAr8sQrJ0jqeMPwpAiz9nc3JTvhYporWoa44nU\n", - "Hi8sLlKW0nW/5rvYy4vcOtzn5g+HaIpNmsbYjoPrtXANB9/3ObW+ShyGqBVHWNc0dENGnwghUBUV\n", - "BBwc3KIscwbDIZbn8lOra6imilAhCodYliLzrqwGTmpRqiqCosqNl3ScXAgs30WUgjAI0SyDmlan\n", - "yCQLZDDoV+FoDqIsOHfPGVRVkfaDFdUtjo+5ub2N5dksnVqlGAkmQcCgN2BjfR1RFCRFgaELXnzx\n", - "RZaXlzh79ixpKk2l8yKTPFdF5dTqusyo0oAyo+Zt0Ov18TwHMIh8GW2xvLqK47jkWcpdG5sMBgPW\n", - "19a4994Llb/tJp2DBZ599jlUxeTy1fPs7u1y7XvfxbJMTno9ScYfT1hbXyMYDUmTAFUTPPi2n2Zx\n", - "cYXDw0Nc1yEOU8qSqkefYlk2juuSxYJWq85oEMrsIieh1+9hVhtqWTIz25lMJrQ7izNnr2bLYDQc\n", - "UPN8OVQimhnu/Di8IdfzK1eu8N3vfvd2v+wcc8wxx/8T3v72t/Pkk0/+yM+9IUVzjjnmmONfK149\n", - "FX2OOeaYY45XYF4055hjjjleA2570fzyl7/MhQsXOHv2LJ/4xCdu98u/rvjgBz/I8vIy999//+xj\n", - "vV6Phx9+mHPnzvHOd76Twcs4YE888QRnz57lwoUL/PVf//Ub8cg/MXZ2dvi5n/s5Ll26xH333cen\n", - "PvUp4M5fdxzHPPjgg1y5coWLFy/y0Y9+FLjz1z1FURRcvXp1pgZ8s6wbAHEbkee5OHPmjNje3hZp\n", - "morLly+L69ev385HeF3x9a9/XXz7298W99133+xjv/EbvyE+8YlPCCGE+PjHPy5+8zd/UwghxHPP\n", - "PScuX74s0jQV29vb4syZM6IoijfkuX8SHBwciGvXrgkhhBiPx+LcuXPi+vXrd/y6hRAiCAIhhBBZ\n", - "lokHH3xQPPXUU2+KdQshxCc/+Unxvve9T7z73e8WQtz57/OX47YWzaefflo88sgjs38/8cQT4okn\n", - "nridj/C6Y3t7+xVF8/z58+LWrVtCCFlgzp8/L4QQ4vHHHxcf//jHZ1/3yCOPiG984xu392FfB/zC\n", - "L/yC+MpXvvKmWncQBOKBBx4Qzz777Jti3Ts7O+Khhx4SX/3qV8W73vUuIcSb631+W6/ne3t7bGxs\n", - "zP79qtZxdwgODw+l+zewvLzM4eEhAPv7+6yvr8++7k74Wdy8eZNr167x4IMPvinWXZYlV65cYXl5\n", - "edaieDOs+9d//df5vd/7vVeYi78Z1j3FbS2aP06H/mbBy+OAf9zn/7ViMpnwnve8hz/4gz+gVqu9\n", - "4nN36rqntom7u7t8/etf52tf+9orPn8nrvsLX/gCS0tLXL169cfKDO/Edb8ct7Vo/lPruJ2dnVfs\n", - "QncilpeXuXXrFiANUKZqg9dio/f/O7Is4z3veQ+PPfYYv/iLvwi8OdY9xdQ28Zlnnrnj1/3000/z\n", - "+c9/nq2tLd773vfy1a9+lccee+yOX/fLcVuL5gMPPMDzzz8/E/d/7nOf49FHH72dj3Db8eijj/Lp\n", - "T38agE9/+tOzovLoo4/y2c9+ljSVphfPP/88b33rW9/IR/0XQQjBr/zKr3Dx4kV+7dd+bfbxO33d\n", - "JycnswlxFEV85Stf4erVq3f8uh9//HF2dnbY3t7ms5/9LO94xzv4sz/7szt+3a/A7W6ifvGLXxTn\n", - "zp0TZ86cEY8//vjtfvnXFb/8y78sTp06JQzDEOvr6+JP//RPRbfbFQ899JA4e/asePjhh0W/3599\n", - "/e/8zu+IM2fOiPPnz4svf/nLb+CT/8vx1FNPCUVRxOXLl8WVK1fElStXxJe+9KU7ft3f+973xNWr\n", - "V8Xly5fF/fffL373d39XCCHu+HW/HE8++eRsev5mWvdcRjnHHHPM8RowVwTNMcccc7wGzIvmHHPM\n", - "McdrwLxozjHHHHO8BsyL5hxzzDHHa8C8aM4xxxxzvAbMi+Ycc8wxx2vAvGjOMcccc7wGzIvmHHPM\n", - "McdrwP8F7/c7xJLyUh8AAAAASUVORK5CYII=\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "input_image = caffe.io.load_image(IMAGE_FILE)\n", - "plt.imshow(input_image)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Time to classify. The default is to actually do 10 predictions, cropping the center and corners of the image as well as their mirrored versions, and average over the predictions:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "prediction shape: (1000,)\n", - "predicted class: 281\n" - ] - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEACAYAAAC+gnFaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAG2ZJREFUeJzt3X9w02WCx/FPnOaOG1xRKmJJulNoCgnQ1q4pDMsyU1dK\n", - "B06ytDo7XRn0dnvawUF393bXvX92FrxZseM4t2Jv5rqcv3VL//DGuh7magczQBVyCgyO9UfLtWcI\n", - "1mWBrvxQS+Nzf9TGJIX0BykBnvdrJtN8v9/n+ebJY/L95Hm+3y86jDFGAABrXZXtBgAAsosgAADL\n", - "EQQAYDmCAAAsRxAAgOUIAgCw3KhBEAwG5fV6VVRUpIaGhhHbW1tbVVpaqrKyMt18883asWNHfFtB\n", - "QYFKSkpUVlamRYsWZbblAICMcKS7jyAWi2nevHlqb2+Xy+VSeXm5mpub5fP54mVOnz6tqVOnSpLe\n", - "ffddVVdXq7u7W5I0e/ZsvfPOO5o+ffokvw0AwESlHRGEw2F5PB4VFBTI6XSqtrZWra2tSWWGQ0CS\n", - "Tp06peuvvz5pO/erAcClLW0QRKNR5efnx5fdbrei0eiIci+//LJ8Pp9WrlypLVu2xNc7HA4tX75c\n", - "fr9fW7duzWCzAQCZkpNuo8PhGNNO1qxZozVr1mjXrl1at26dPvzwQ0lSR0eH8vLydPToUVVWVsrr\n", - "9WrZsmUX3moAQMakDQKXy6VIJBJfjkQicrvd5y2/bNkyDQ4O6tixY8rNzVVeXp4kacaMGaqurlY4\n", - "HB4RBB6PR4cOHbqQ9wAA1iksLIyfj71QaaeG/H6/urq61Nvbq4GBAbW0tCgQCCSVOXToUPw8wL59\n", - "+yRJubm5OnPmjE6ePClp6IRyW1ubiouLR7zGcH0eRr/97W+z3oZL5UFf0Bf0RfpHJn9Apx0R5OTk\n", - "qLGxUVVVVYrFYqqrq5PP51NTU5Mkqb6+Xi+99JKee+45OZ1OXX311dq2bZskqa+vTzU1NZKkwcFB\n", - "rV27VitWrMhYwwEAmZE2CCRp5cqVWrlyZdK6+vr6+PMHH3xQDz744Ih6c+bM0YEDBzLQRADAZOLO\n", - "4ktIRUVFtptwyaAvvkFffIO+mBxpbyi7KA1wOJTlJgDAZSeTx05GBABgOYIAACxHEACA5QgCALAc\n", - "QQAAliMIAMByBAEAWI4gAADLEQQAYDmCAAAsRxAAgOUIAgCwHEEAAJYjCADAcgQBAFiOIAAAyxEE\n", - "AGA5ggAALEcQAIDlCAIL7dwpTZmS7VYAuFQQBBb6n/+Rvvwy260AcKkYNQiCwaC8Xq+KiorU0NAw\n", - "Yntra6tKS0tVVlamm2++WTt27BhzXWSHw5HtFgC4lDiMMeZ8G2OxmObNm6f29na5XC6Vl5erublZ\n", - "Pp8vXub06dOaOnWqJOndd99VdXW1uru7x1RXkhwOh9I0AZPgX/9V+qd/kuh24PKVyWNn2hFBOByW\n", - "x+NRQUGBnE6namtr1dramlRmOAQk6dSpU7r++uvHXBfZwYgAQKK0QRCNRpWfnx9fdrvdikajI8q9\n", - "/PLL8vl8WrlypbZs2TKuurj4CAIAiXLSbXSM8YixZs0arVmzRrt27dK6dev0wQcfjKsRGzdujD+v\n", - "qKhQRUXFuOoDwJUuFAopFApNyr7TBoHL5VIkEokvRyIRud3u85ZftmyZBgcHdfz4cbnd7jHXTQwC\n", - "TD5GBMDlJ/VH8qZNmzK277RTQ36/X11dXert7dXAwIBaWloUCASSyhw6dCh+wmLfvn2SpNzc3DHV\n", - "RXYQBAASpR0R5OTkqLGxUVVVVYrFYqqrq5PP51NTU5Mkqb6+Xi+99JKee+45OZ1OXX311dq2bVva\n", - "usg+ggBAorSXj16UBnD56EXX2Cjdfz+XjwKXs4t2+SiuTIwIACQiCCxEEABIRBBYiCAAkIggsBBB\n", - "ACARQWAhggBAIoLAQgQBgEQEAQBYjiCwECMCAIkIAgsRBAASEQQWIggAJCIILEQQAEhEEACA5QgC\n", - "CzEiAJCIILAQQQAgEUFgIYIAQCKCAAAsRxBYiBEBgEQEgYUIAgCJCAILEQQAEhEEFiIIACQiCADA\n", - "cgSBhRgRAEhEEFiIIACQaNQgCAaD8nq9KioqUkNDw4jtL774okpLS1VSUqKlS5fq4MGD8W0FBQUq\n", - "KSlRWVmZFi1alNmWY8IIAgCJctJtjMVi2rBhg9rb2+VyuVReXq5AICCfzxcvM2fOHO3cuVPTpk1T\n", - "MBjUvffeqz179kiSHA6HQqGQpk+fPrnvAgAwYWlHBOFwWB6PRwUFBXI6naqtrVVra2tSmSVLlmja\n", - "tGmSpMWLF+vw4cNJ240xGW4yLtRVTAgCSJD2kBCNRpWfnx9fdrvdikaj5y3/5JNPatWqVfFlh8Oh\n", - "5cuXy+/3a+vWrRloLjKBqSEAidJODTnGccR444039NRTT6mjoyO+rqOjQ3l5eTp69KgqKyvl9Xq1\n", - "bNmyEXU3btwYf15RUaGKiooxvy4A2CAUCikUCk3KvtMGgcvlUiQSiS9HIhG53e4R5Q4ePKh77rlH\n", - "wWBQ1113XXx9Xl6eJGnGjBmqrq5WOBweNQgw+RgRAJef1B/JmzZtyti+004N+f1+dXV1qbe3VwMD\n", - "A2ppaVEgEEgq8/HHH6umpkYvvPCCPB5PfP2ZM2d08uRJSdLp06fV1tam4uLijDUcE0cQAEiUdkSQ\n", - "k5OjxsZGVVVVKRaLqa6uTj6fT01NTZKk+vp6PfTQQzpx4oTWr18vSXI6nQqHw+rr61NNTY0kaXBw\n", - "UGvXrtWKFSsm+e1gLAgCAIkcJsuX9TgcDq4susj+8z+l22+X6Hbg8pXJYycXElqIEQGARASBhQgC\n", - "AIkIAgsRBAASEQQWIggAJCIILMbJYgASQWCl4QAgCABIBIHVCAIAEkFgpeEA+Oqr7LYDwKWBILAY\n", - "IwIAEkFgNYIAgEQQWImTxQASEQQW4xwBAIkgsBIjAgCJCAKLEQQAJILASowIACQiCCzGOQIAEkFg\n", - "JUYEABIRBBYjCABIBIHVCAIAEkFgJf6tIQCJCAKLMSIAIBEEVuJkMYBEBIHFCAIA0hiCIBgMyuv1\n", - "qqioSA0NDSO2v/jiiyotLVVJSYmWLl2qgwcPjrkusoNzBAASpQ2CWCymDRs2KBgMqrOzU83NzXr/\n", - "/feTysyZM0c7d+7UwYMH9Zvf/Eb33nvvmOsiu/73f7PdAgCXgrRBEA6H5fF4VFBQIKfTqdraWrW2\n", - "tiaVWbJkiaZNmyZJWrx4sQ4fPjzmusiO4RHB974n7duX3bYAyL60QRCNRpWfnx9fdrvdikaj5y3/\n", - "5JNPatWqVROqi+z4/PNstwBAtuWk2+hwOMa8ozfeeENPPfWUOjo6xl1348aN8ecVFRWqqKgYc10A\n", - "sEEoFFIoFJqUfacNApfLpUgkEl+ORCJyu90jyh08eFD33HOPgsGgrrvuunHVlZKDAJOPq4WAy0/q\n", - "j+RNmzZlbN9pp4b8fr+6urrU29urgYEBtbS0KBAIJJX5+OOPVVNToxdeeEEej2dcdQEA2Zd2RJCT\n", - "k6PGxkZVVVUpFouprq5OPp9PTU1NkqT6+no99NBDOnHihNavXy9JcjqdCofD562L7GNEACCRw5js\n", - "HhYcDoey3ATr/PGP0tq1Q89375aWLs1uewCMXyaPndxZbCFyF0AiggAALEcQAIDlCAILMTUEIBFB\n", - "AACWIwgsxIgAQCKCAAAsRxBYiBEBgEQEAQBYjiCwECMCAIkIAgCwHEEAAJYjCCzE1BCARAQBAFiO\n", - "ILAQIwIAiQgCALAcQWAhRgQAEhEEAGA5ggAALEcQWIipIQCJCAIAsBxBYCFGBAASEQQAYLlRgyAY\n", - "DMrr9aqoqEgNDQ0jtn/wwQdasmSJpkyZosceeyxpW0FBgUpKSlRWVqZFixZlrtW4IIwIACTKSbcx\n", - "Fotpw4YNam9vl8vlUnl5uQKBgHw+X7xMbm6unnjiCb388ssj6jscDoVCIU2fPj3zLQcAZETaEUE4\n", - "HJbH41FBQYGcTqdqa2vV2tqaVGbGjBny+/1yOp3n3Ifh5+clh/8kABKlDYJoNKr8/Pz4stvtVjQa\n", - "HfPOHQ6Hli9fLr/fr61bt068lQCASZN2asjhcFzQzjs6OpSXl6ejR4+qsrJSXq9Xy5YtG1Fu48aN\n", - "8ecVFRWqqKi4oNcFgCtNKBRSKBSalH2nDQKXy6VIJBJfjkQicrvdY955Xl6epKHpo+rqaoXD4VGD\n", - "AJOPqSHg8pP6I3nTpk0Z23faqSG/36+uri719vZqYGBALS0tCgQC5yybei7gzJkzOnnypCTp9OnT\n", - "amtrU3FxcYaaDQDIlLQjgpycHDU2NqqqqkqxWEx1dXXy+XxqamqSJNXX16uvr0/l5eX67LPPdNVV\n", - "V+nxxx9XZ2en/vznP6umpkaSNDg4qLVr12rFihWT/44wKkYEABI5TJYv63E4HFxZdJH9+79L69cP\n", - "Pd+9W1q6NLvtATB+mTx2cmexhchdAIkIAgCwHEEAAJYjCCzE1BCARAQBAFiOILAQIwIAiQgCyxEK\n", - "AAgCCyUe/AkCAAQBAFiOILAQIwIAiQgCyxEEAAgCALAcQWAhpoYAJCIILEcQACAILMTBH0AigsBy\n", - "hAIAgsBCnCMAkIggAADLEQSWY0QAgCCwEFNDABIRBABgOYLAQowIACQiCCxHEAAYNQiCwaC8Xq+K\n", - "iorU0NAwYvsHH3ygJUuWaMqUKXrsscfGVRcX33/8h/SnP2W7FQAuJWmDIBaLacOGDQoGg+rs7FRz\n", - "c7Pef//9pDK5ubl64okn9Mtf/nLcdXHxvfuu9OGH3ywzIgCQNgjC4bA8Ho8KCgrkdDpVW1ur1tbW\n", - "pDIzZsyQ3++X0+kcd11cfMZIsVjyMgC7pQ2CaDSq/Pz8+LLb7VY0Gh3Tji+kLibPV18lBwEA5KTb\n", - "6HA4Jrzj8dTduHFj/HlFRYUqKiom/LpIjxEBcHkKhUIKhUKTsu+0QeByuRSJROLLkUhEbrd7TDse\n", - "T93EIMDkSg0CAJeH1B/JmzZtyti+004N+f1+dXV1qbe3VwMDA2ppaVEgEDhnWZPy03I8dXHxMCIA\n", - "kCrtiCAnJ0eNjY2qqqpSLBZTXV2dfD6fmpqaJEn19fXq6+tTeXm5PvvsM1111VV6/PHH1dnZqauv\n", - "vvqcdZFdqecICAIADpP6U/5iN8DhGDGawOS5917p6aelwcGh5T/9Sbrttuy2CcD4ZfLYyZ3FlmFq\n", - "CEAqgsAyxvBvDQFIRhBY5quvst0CAJcagsAyqSMARgQACALLEAQAUhEElmFqCEAqgsAyjAgApCII\n", - "LEMQAEhFEFiGAz+AVASBZVLPERAMAAgCyzA1BCAVQWAZDvwAUhEElmFqCEAqgsAyTA0BSEUQWIYD\n", - "P4BUBIFlGBEASEUQWIZzBABSEQSW4cAPIBVBYBmmhgCkIggsw9QQgFQEgWU48ANIRRBYhqkhAKkI\n", - "AssQBABSjRoEwWBQXq9XRUVFamhoOGeZBx54QEVFRSotLdX+/fvj6wsKClRSUqKysjItWrQoc63G\n", - "hPF/KAOQKifdxlgspg0bNqi9vV0ul0vl5eUKBALy+XzxMtu3b1d3d7e6urq0d+9erV+/Xnv27JEk\n", - "ORwOhUIhTZ8+fXLfBcaMEQGAVGlHBOFwWB6PRwUFBXI6naqtrVVra2tSmVdeeUV33323JGnx4sXq\n", - "7+/Xp59+Gt9uONJcUggCAKnSBkE0GlV+fn582e12KxqNjrmMw+HQ8uXL5ff7tXXr1ky2GxPE1BCA\n", - "VGmnhhwOx5h2cr5f/bt379asWbN09OhRVVZWyuv1atmyZSPKbdy4Mf68oqJCFRUVY3pdjB8jAuDy\n", - "FAqFFAqFJmXfaYPA5XIpEonElyORiNxud9oyhw8flsvlkiTNmjVLkjRjxgxVV1crHA6PGgSYXKkH\n", - "/rY26euZPQCXsNQfyZs2bcrYvtNODfn9fnV1dam3t1cDAwNqaWlRIBBIKhMIBPTcc89Jkvbs2aNr\n", - "r71WM2fO1JkzZ3Ty5ElJ0unTp9XW1qbi4uKMNRwTkxoEf/xjdtoB4NKRdkSQk5OjxsZGVVVVKRaL\n", - "qa6uTj6fT01NTZKk+vp6rVq1Stu3b5fH49HUqVP19NNPS5L6+vpUU1MjSRocHNTatWu1YsWKSX47\n", - "GA3nCACkcpgsX9bjcDi4sugiWrZM2r07eR3dD1x+Mnns5M5iy3DQB5CKILAMQQAgFUFgGc4RAEhF\n", - "EFiGEQGAVASBZQgCAKkIAsswNQQgFUFgGUYEAFIRBJYhCACkIggsQxAASEUQWIZzBABSEQSWYUQA\n", - "IBVBYBmCAEAqgsAyTA0BSEUQWIYRAYBUBIFlCAIAqQgCyxAEAFIRBJY51zkCzhsAdiMILHOuEUEs\n", - "dvHbAeDSQRBYJlNB8N57jCSAKwVBYJlMTQ0tXCi99NKFtwdA9hEElsnk1NBnn11YW4BLjTHSCy9k\n", - "uxUXH0FgmUwGweDghbUFuNScPCmtWyedPZvtllxcowZBMBiU1+tVUVGRGhoazlnmgQceUFFRkUpL\n", - "S7V///5x1cXFRRAA53fy5NBf20a7aYMgFotpw4YNCgaD6uzsVHNzs95///2kMtu3b1d3d7e6urr0\n", - "hz/8QevXrx9zXSQLhUIZ3V9rq+RwJK871/mA8QbBcPkvv5xYu8Yi031xOaMvvjHZffHXvyb/PR9j\n", - "rqx7ctIGQTgclsfjUUFBgZxOp2pra9Xa2ppU5pVXXtHdd98tSVq8eLH6+/vV19c3prpIlskPeU+P\n", - "9Prryeu2bJEikZFlxxsEp08P/e3rm1jbxiLTX/jjx6XL9Xh6JQbBREeTmewLY6SOjuR1wwEw2ojg\n", - "hhukhx7KWFOyLm0QRKNR5efnx5fdbrei0eiYyhw5cmTUuleSV1+Vjh0be/nJvnZ/zhzp3/5t6Pnw\n", - "L5ef/vSb7ffdN/G2DAfBo49K55vxGxiQ/uu/xrffiRrLL7N/+RfplluS1/33f0slJZPTpmHR6LnD\n", - "93z6+qTu7slrz2T661+lL74YvZwxktMpvf325Lcpnf/7P+l730s+6A8/P9+IYDjA/vKXkSFyoXbv\n", - "lqZPz+w+xyon3UZH6rzCeZgLHCOtXn1B1TPis8+GPqDTpk2s/quvSgUF0oIFo5c9e1Zqa5MqK4c+\n", - "WH/zN0NfjA8/lN55Z/R2dndLpaVD0z7Dj3RWrvzm4D3srrukZ56RzpyR/uEfpL/7u9HbPezMGcnj\n", - "kWbMkP75n6Vdu0a24fhx6c03paoqKefrT1nixyT1I5O6rbtb2rPn/HUSnx84MNSe668/f5sPHBj6\n", - "m/hZO3BAOnx4cj9/r7469HfVquT1if2V+Hy4/N///TfrPvoo+aA5lq/bWL+SDsfQZ2rq1KHP4ES+\n", - "yl98MTRNuHu3dN110tKl37Sho0NavHho38OGD6b/+I+S2/3NPhwOacqU9K+V+B3p75euuUa6aoKX\n", - "vPzlL0N/V68e2o8kffLJ0N8HHxz61Z/oxImh91NVNbTc0SHddtvor3PihPS3fzvUx+l0dw+VXbVq\n", - "6D0lTj+lPs84k8Zbb71lqqqq4ssPP/yweeSRR5LK1NfXm+bm5vjyvHnzTF9f35jqGmNMYWGhkcSD\n", - "Bw8ePMbxKCwsTHf4Hpe0IwK/36+uri719vZq1qxZamlpUXNzc1KZQCCgxsZG1dbWas+ePbr22ms1\n", - "c+ZM5ebmjlpXkrov13EwAFwh0gZBTk6OGhsbVVVVpVgsprq6Ovl8PjU1NUmS6uvrtWrVKm3fvl0e\n", - "j0dTp07V008/nbYuAODS4jDmSroICgAwXlm9s9imG84ikYhuueUWLViwQAsXLtSWLVskScePH1dl\n", - "ZaXmzp2rFStWqL+/P15n8+bNKioqktfrVVtbW7aaPmlisZjKysq0+uuztbb2RX9/v+644w75fD7N\n", - "nz9fe/futbYvNm/erAULFqi4uFh33nmnvvzyS2v64ic/+Ylmzpyp4uLi+LqJvPd33nlHxcXFKioq\n", - "0k8TLxVMJ2NnG8ZpcHDQFBYWmp6eHjMwMGBKS0tNZ2dntpoz6T755BOzf/9+Y4wxJ0+eNHPnzjWd\n", - "nZ3mV7/6lWloaDDGGPPII4+YX//618YYY9577z1TWlpqBgYGTE9PjyksLDSxWCxr7Z8Mjz32mLnz\n", - "zjvN6tWrjTHG2r646667zJNPPmmMMebs2bOmv7/fyr7o6ekxs2fPNl988YUxxpgf/vCH5plnnrGm\n", - "L3bu3Gn27dtnFi5cGF83nvf+1VdfGWOMKS8vN3v37jXGGLNy5Urz2muvjfraWQuCN998M+mqos2b\n", - "N5vNmzdnqzkX3Q9+8APz+uuvx6+yMmYoLObNm2eMGXmVVVVVlXnrrbey0tbJEIlEzK233mp27Nhh\n", - "brvtNmOMsbIv+vv7zezZs0est7Evjh07ZubOnWuOHz9uzp49a2677TbT1tZmVV/09PQkBcF43/uR\n", - "I0eM1+uNr29ubjb19fWjvm7WpobGcrPalaq3t1f79+/X4sWL9emnn2rmzJmSpJkzZ+rTTz+VJB05\n", - "ckTu4YusdeX1z89//nM9+uijuirhInAb+6Knp0czZszQj3/8Y33nO9/RPffco9OnT1vZF9OnT9cv\n", - "fvELffvb39asWbN07bXXqrKy0sq+GDbe95663uVyjalPshYEY71Z7Upz6tQp3X777Xr88cf1rW99\n", - "K2mbw+FI2y9XSp+9+uqruuGGG1RWVnbemxFt6YvBwUHt27dP9913n/bt26epU6fqkUceSSpjS18c\n", - "OnRIv//979Xb26sjR47o1KlTeiHl34S2pS/OZbT3fiGyFgQul0uRhHvvI5FIUpJdic6ePavbb79d\n", - "69at05o1ayQNpXzf1/9ozyeffKIbvr6dMbV/Dh8+LJfLdfEbPQnefPNNvfLKK5o9e7Z+9KMfaceO\n", - "HVq3bp2VfeF2u+V2u1VeXi5JuuOOO7Rv3z7deOON1vXF22+/re9+97vKzc1VTk6Oampq9NZbb1nZ\n", - "F8PG851wu91yuVw6fPhw0vqx9EnWgiDxZrWBgQG1tLQoEAhkqzmTzhijuro6zZ8/Xz/72c/i6wOB\n", - "gJ599llJ0rPPPhsPiEAgoG3btmlgYEA9PT3q6urSokWLstL2THv44YcViUTU09Ojbdu26fvf/76e\n", - "f/55K/vixhtvVH5+vj766CNJUnt7uxYsWKDVq1db1xder1d79uzR559/LmOM2tvbNX/+fCv7Yth4\n", - "vxM33nijrrnmGu3du1fGGD3//PPxOmll4gTHRG3fvt3MnTvXFBYWmocffjibTZl0u3btMg6Hw5SW\n", - "lpqbbrrJ3HTTTea1114zx44dM7feeqspKioylZWV5sSJE/E6v/vd70xhYaGZN2+eCQaDWWz95AmF\n", - "QvGrhmztiwMHDhi/329KSkpMdXW16e/vt7YvGhoazPz5883ChQvNXXfdZQYGBqzpi9raWpOXl2ec\n", - "Tqdxu93mqaeemtB7f/vtt83ChQtNYWGhuf/++8f02txQBgCW439VCQCWIwgAwHIEAQBYjiAAAMsR\n", - "BABgOYIAACxHEACA5QgCALDc/wN1ylfVql6MNwAAAABJRU5ErkJggg==\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "prediction = net.predict([input_image]) # predict takes any number of images, and formats them for the Caffe net automatically\n", - "print 'prediction shape:', prediction[0].shape\n", - "plt.plot(prediction[0])\n", - "print 'predicted class:', prediction[0].argmax()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can see that the prediction is 1000-dimensional, and is pretty sparse.\n", - "\n", - "The predicted class 281 is \"Tabby cat.\" Our pretrained model uses the synset ID ordering of the classes, as listed in `../data/ilsvrc12/synset_words.txt` if you fetch the auxiliary imagenet data by `../data/ilsvrc12/get_ilsvrc_aux.sh`. If you look at the top indices that maximize the prediction score, they are cats, foxes, and other cute mammals. Not unreasonable predictions, right?\n", - "\n", - "Now let's classify by the center crop alone by turning off oversampling. Note that this makes a single input, although if you inspect the model definition prototxt you'll see the network has a batch size of 10. The python wrapper handles batching and padding for you!" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "prediction shape: (1000,)\n", - "predicted class: 281\n" - ] - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEACAYAAAC+gnFaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAG6ZJREFUeJzt3X9sk+eBB/Dvy9l3vYUNSppCsDMZYoMNJGlWhxztRXJb\n", - "kghWvCStqrSI9raIWkxpt2ldK92p16S3AtGENGikXcpBV0ovRLpKBFWpL4uoB0sJVht66S3QOlyi\n", - "GtNQDsiRhLYm5rk/vJjXb+CNE+yY8Hw/kmW/7/s8r5/3cfx+/bw/QBFCCBARkbTmpLsBRESUXgwC\n", - "IiLJMQiIiCTHICAikhyDgIhIcgwCIiLJTRoEXq8XdrsdNpsNDQ0NE5a3traioKAAhYWFuP/++3H4\n", - "8OHYMovFgvz8fBQWFmL16tXJbTkRESWFoncfQSQSwfLly9HR0QGTyYSioiI0NzfD4XDEyoyOjiIj\n", - "IwMA8Omnn6KyshJ9fX0AgCVLluDjjz/GggULUrwZREQ0XbojAr/fD6vVCovFAqPRiOrqarS2tsaV\n", - "GQ8BABgZGcE999wTt5z3qxER3d50gyAUCiEnJyc2bTabEQqFJpQ7ePAgHA4H1q1bh127dsXmK4qC\n", - "tWvXwul0Yvfu3UlsNhERJYtBb6GiKAmtpKKiAhUVFTh69Cg2bdqEzz77DADQ2dmJ7OxsnD9/HqWl\n", - "pbDb7SgpKbn1VhMRUdLoBoHJZEIwGIxNB4NBmM3mm5YvKSnB2NgYLly4gMzMTGRnZwMAsrKyUFlZ\n", - "Cb/fPyEIrFYrTp8+fSvbQEQkndzc3Nj52Fule2jI6XQiEAhgYGAA4XAYLS0tcLvdcWVOnz4dOw/Q\n", - "3d0NAMjMzMSVK1cwPDwMIHpCub29HXl5eRPeY7w+HwKvvPJK2ttwuzzYF+wL9oX+I5k/oHVHBAaD\n", - "AY2NjSgvL0ckEkFNTQ0cDgeampoAAB6PB++++y727dsHo9GIuXPn4sCBAwCAwcFBVFVVAQDGxsaw\n", - "ceNGlJWVJa3hRESUHLpBAADr1q3DunXr4uZ5PJ7Y6xdffBEvvvjihHpLly7FJ598koQmEhFRKvHO\n", - "4tuIy+VKdxNuG+yL69gX17EvUkP3hrIZaYCiIM1NICKadZK57+SIgIhIcgwCIiLJMQiIiCTHICAi\n", - "khyDgIhIcgwCIiLJMQiIiCTHICAikhyDgIhIcgwCIiLJMQiIiCTHICAikhyDgIhIcgwCIiLJMQiI\n", - "iCTHICAikhyDgIhIcgwCIiLJMQiIiCTHICAikhyDgIhIcpMGgdfrhd1uh81mQ0NDw4Tlra2tKCgo\n", - "QGFhIe6//34cPnw44bqUHocPA4qS7lYQ0e1CEUKImy2MRCJYvnw5Ojo6YDKZUFRUhObmZjgcjliZ\n", - "0dFRZGRkAAA+/fRTVFZWoq+vL6G6AKAoCnSaQCmwYwfwwgsAu51o9krmvlN3ROD3+2G1WmGxWGA0\n", - "GlFdXY3W1ta4MuMhAAAjIyO45557Eq5L6cHRABGp6QZBKBRCTk5ObNpsNiMUCk0od/DgQTgcDqxb\n", - "tw67du2aUl2aeQwCIlIz6C1UEtxjVFRUoKKiAkePHsWmTZtw6tSpKTWirq4u9trlcsHlck2pPk0N\n", - "g4Bo9vH5fPD5fClZt24QmEwmBIPB2HQwGITZbL5p+ZKSEoyNjeHixYswm80J11UHAaUeg4Bo9tH+\n", - "SK6vr0/aunUPDTmdTgQCAQwMDCAcDqOlpQVutzuuzOnTp2MnLLq7uwEAmZmZCdWl9GAQEJGa7ojA\n", - "YDCgsbER5eXliEQiqKmpgcPhQFNTEwDA4/Hg3Xffxb59+2A0GjF37lwcOHBAty6lH4OAiNR0Lx+d\n", - "kQbw8tEZ19gIPPccLx8lms1m7PJRujNxREBEagwCCTEIiEiNQSAhBgERqTEIiIgkxyCQEEcERKTG\n", - "IJAQg4CI1BgEEmIQEJEag0BCDAIiUmMQSIhBQERqDAIJMQiISI1BICEGARGpMQgkxCAgIjUGARGR\n", - "5BgEEuKIgIjUGAQSYhAQkRqDQEIMAiJSYxBIiEFARGoMAgkxCIhIjUEgIQYBEakxCCTEICAiNQaB\n", - "hBgERKTGIJAQg4CI1BgEEmIQEJHapEHg9Xpht9ths9nQ0NAwYfk777yDgoIC5Ofn48EHH0RPT09s\n", - "mcViQX5+PgoLC7F69erktpyIiJLCoLcwEomgtrYWHR0dMJlMKCoqgtvthsPhiJVZunQpjhw5gnnz\n", - "5sHr9eLZZ59FV1cXAEBRFPh8PixYsCC1W0FTMofjQCJS0d0l+P1+WK1WWCwWGI1GVFdXo7W1Na7M\n", - "mjVrMG/ePABAcXExzpw5E7dcCJHkJtOt4qEhIlLTDYJQKIScnJzYtNlsRigUumn5PXv2YP369bFp\n", - "RVGwdu1aOJ1O7N69OwnNJSKiZNM9NKRM4afjBx98gL1796KzszM2r7OzE9nZ2Th//jxKS0tht9tR\n", - "UlIyoW5dXV3stcvlgsvlSvh9aeo4IiCafXw+H3w+X0rWrRsEJpMJwWAwNh0MBmE2myeU6+npwebN\n", - "m+H1enH33XfH5mdnZwMAsrKyUFlZCb/fP2kQUOoxCIhmH+2P5Pr6+qStW/fQkNPpRCAQwMDAAMLh\n", - "MFpaWuB2u+PKfPHFF6iqqsL+/fthtVpj869cuYLh4WEAwOjoKNrb25GXl5e0htP0MQiISE13RGAw\n", - "GNDY2Ijy8nJEIhHU1NTA4XCgqakJAODxePDqq6/i0qVL2LJlCwDAaDTC7/djcHAQVVVVAICxsTFs\n", - "3LgRZWVlKd4cSgSDgIjUFJHmy3oUReGVRTOstRWoqADY7USzVzL3nbyinIhIcgwCCfHQEBGpMQgk\n", - "NB4EPDRERACDQGoMAiICGARSGg8ABgERAQwCqV27lu4WENHtgEEgIY4IiEiNQSAxjgiICGAQSIkj\n", - "AiJSYxBIjEFARACDQErjAcBDQ0QEMAikxhEBEQEMAqkxCIgIYBBIiYeGiEiNQSAxjgiICGAQSImX\n", - "jxKRGoNAYjw0REQAg0BKHBEQkRqDQGIMAiICGARS4lVDRKTGIJAYRwREBDAIpMYgICKAQSAlHhoi\n", - "IrVJg8Dr9cJut8Nms6GhoWHC8nfeeQcFBQXIz8/Hgw8+iJ6enoTrUnpxREBEwCRBEIlEUFtbC6/X\n", - "i97eXjQ3N+PkyZNxZZYuXYojR46gp6cHL7/8Mp599tmE61J68PJRIlLTDQK/3w+r1QqLxQKj0Yjq\n", - "6mq0trbGlVmzZg3mzZsHACguLsaZM2cSrktEROmnGwShUAg5OTmxabPZjFAodNPye/bswfr166dV\n", - "l2YORwREpGbQW6goSsIr+uCDD7B37150dnZOuW5dXV3stcvlgsvlSrguTR+DgGj28Pl88Pl8KVm3\n", - "bhCYTCYEg8HYdDAYhNlsnlCup6cHmzdvhtfrxd133z2lukB8EFDqMQCIZh/tj+T6+vqkrVv30JDT\n", - "6UQgEMDAwADC4TBaWlrgdrvjynzxxReoqqrC/v37YbVap1SX0ouBQETAJCMCg8GAxsZGlJeXIxKJ\n", - "oKamBg6HA01NTQAAj8eDV199FZcuXcKWLVsAAEajEX6//6Z16fbBICAiAFCESO/uQFEUpLkJ0vn3\n", - "fwc2bgROnwaWLk13a4hoOpK57+SdxRJj/hIRwCCQEi8fJSI1BoHEGAREBDAIpMQAICI1BoHEGAhE\n", - "BDAIpMRzBESkxiAgIpIcg0BCHBEQkRqDQGIMAiICGARERNJjEEiIh4aISI1BIDEGAREBDAIpMQCI\n", - "SI1BIDEGAhEBDAIp8RwBEakxCIiIJMcgkBBHBESkxiCQGIOAiAAGARGR9BgEEuKhISJSYxBIjEFA\n", - "RACDQEocERCRGoOAiEhykwaB1+uF3W6HzWZDQ0PDhOWnTp3CmjVrcNddd2HHjh1xyywWC/Lz81FY\n", - "WIjVq1cnr9V0SzgiICI1g97CSCSC2tpadHR0wGQyoaioCG63Gw6HI1YmMzMTr7/+Og4ePDihvqIo\n", - "8Pl8WLBgQfJbTreMQUBEwCQjAr/fD6vVCovFAqPRiOrqarS2tsaVycrKgtPphNFovOE6BPc2tx1+\n", - "JESkphsEoVAIOTk5sWmz2YxQKJTwyhVFwdq1a+F0OrF79+7pt5JSgoFARMAkh4YURbmllXd2diI7\n", - "Oxvnz59HaWkp7HY7SkpKJpSrq6uLvXa5XHC5XLf0vpQYBgHR7OHz+eDz+VKybt0gMJlMCAaDselg\n", - "MAiz2ZzwyrOzswFEDx9VVlbC7/dPGgSUegwAotlH+yO5vr4+aevWPTTkdDoRCAQwMDCAcDiMlpYW\n", - "uN3uG5bVngu4cuUKhoeHAQCjo6Nob29HXl5ekppNycBAICJgkhGBwWBAY2MjysvLEYlEUFNTA4fD\n", - "gaamJgCAx+PB4OAgioqKcPnyZcyZMwc7d+5Eb28vvvrqK1RVVQEAxsbGsHHjRpSVlaV+i2hSvHyU\n", - "iNQUkebLehRF4ZVFM+xf/xXYsgU4dgz4u79Ld2uIaDqSue/kncUS4oiAiNQYBBJjEBARwCCQEgOA\n", - "iNQYBBJjIBARwCCQGoOAiAAGgZR4spiI1BgEEtu/H7h6Nd2tIKJ0YxBIaHwk8MYbgN+f3rYQUfox\n", - "CCQTiQDXrqW7FUR0O9H9JybozvPKK8ChQ+luBRHdTjgikMzwMHD5crpbQUS3EwaBZISIHh4iIhrH\n", - "IJCMEDxHQETxGASS4YiAiLQYBJLhiICItBgEkmEQEJEWg0AyPDRERFoMAslcu8YgIKJ4DALJcERA\n", - "RFoMAsnwHAERaTEIJMMRARFpMQgkwxEBEWkxCCTDEQERaU0aBF6vF3a7HTabDQ0NDROWnzp1CmvW\n", - "rMFdd92FHTt2TKkuzTz+r2REpKUbBJFIBLW1tfB6vejt7UVzczNOnjwZVyYzMxOvv/46XnjhhSnX\n", - "pZnHICAiLd0g8Pv9sFqtsFgsMBqNqK6uRmtra1yZrKwsOJ1OGI3GKdelmccgICIt3SAIhULIycmJ\n", - "TZvNZoRCoYRWfCt1KXUYBESkpfs/lCmKMu0VT6VuXV1d7LXL5YLL5Zr2+5I+BgHR7OTz+eDz+VKy\n", - "bt0gMJlMCAaDselgMAiz2ZzQiqdSVx0ElFraILiFrCeiGaT9kVxfX5+0deseGnI6nQgEAhgYGEA4\n", - "HEZLSwvcbvcNywrNHmYqdWnmcERARFq6IwKDwYDGxkaUl5cjEomgpqYGDocDTU1NAACPx4PBwUEU\n", - "FRXh8uXLmDNnDnbu3Ine3l7MnTv3hnUpvRgERKSlCO1P+ZlugKJMGE1Q6jz5JHDgwPXpzk7ggQfS\n", - "1x4imp5k7jt5Z7FkmLlEpMUgkAyDgIi0GASSYRAQkRaDQDLaf3mUwUBEDALJaHf8DAIiYhBIhkFA\n", - "RFoMAskwCIhIi0EgGQYBEWkxCCTDICAiLQaBZBgERKTFIJAMg4CItBgEkmEQEJEWg0Ay2h3/v/xL\n", - "etpBRLcPBoFktEHwxz+mpx1EdPtgEEiGh4KISItBIBkGARFpMQgkwyAgIi0GgWQYBESkxSCQDIOA\n", - "iLQYBJJhEBCRFoNAMtr/mIaIiEEgGY4IiEiLQSAZBgERaU0aBF6vF3a7HTabDQ0NDTcs8/zzz8Nm\n", - "s6GgoAAnTpyIzbdYLMjPz0dhYSFWr16dvFbTtDEIiEjLoLcwEomgtrYWHR0dMJlMKCoqgtvthsPh\n", - "iJVpa2tDX18fAoEAjh8/ji1btqCrqwsAoCgKfD4fFixYkNqtoIQxCIhIS3dE4Pf7YbVaYbFYYDQa\n", - "UV1djdbW1rgyhw4dwjPPPAMAKC4uxtDQEM6dOxdbLrjnua3w4yAiLd0gCIVCyMnJiU2bzWaEQqGE\n", - "yyiKgrVr18LpdGL37t3JbDdNE4OAiLR0Dw0pipLQSm72q/9Pf/oTFi9ejPPnz6O0tBR2ux0lJSUT\n", - "ytXV1cVeu1wuuFyuhN6Xpo5BQDQ7+Xw++Hy+lKxbNwhMJhOCwWBsOhgMwmw265Y5c+YMTCYTAGDx\n", - "4sUAgKysLFRWVsLv908aBJRaDAKi2Un7I7m+vj5p69Y9NOR0OhEIBDAwMIBwOIyWlha43e64Mm63\n", - "G/v27QMAdHV1Yf78+Vi4cCGuXLmC4eFhAMDo6Cja29uRl5eXtIbT9DAIiEhLd0RgMBjQ2NiI8vJy\n", - "RCIR1NTUwOFwoKmpCQDg8Xiwfv16tLW1wWq1IiMjA2+++SYAYHBwEFVVVQCAsbExbNy4EWVlZSne\n", - "HJoMg4CItBSR5st6FEXhlUUzqLgY8Pvj57H7iWafZO47eWexZLjTJyItBoFkGAREpMUgkAyDgIi0\n", - "GASSYRAQkRaDQDIMAiLSYhBIhkFARFoMAsnwfygjIi0GgWQ4IiAiLQaBZBgERKTFIJAMg4CItBgE\n", - "krlREDAciOTGIJAMg4CItBgEkrnRTp9XEhHJjUEgGQYBEWkxCCTDICAiLQaBZBgERKTFIJAMTxYT\n", - "kRaDQDIcERCRFoNAMgwCItJiEEiGQUCk7+rVdLdg5jEIJMMgILq5cBj467+W77wZg0AyDAKim7t8\n", - "Ofp85Up62zHTJg0Cr9cLu90Om82GhoaGG5Z5/vnnYbPZUFBQgBMnTkypLs2cU6eAM2cmzmcQEEUN\n", - "D8c/y0I3CCKRCGpra+H1etHb24vm5macPHkyrkxbWxv6+voQCATwxhtvYMuWLQnXpXg+ny9p6/r1\n", - "r4H/+I/4eQ4HEIlEX8+de33+dIbBXV2pPZaazL4AgK+/Bj77LKmrnDHJ7ovZLNV9kWgQPPUU0NKS\n", - "0qbMKN0g8Pv9sFqtsFgsMBqNqK6uRmtra1yZQ4cO4ZlnngEAFBcXY2hoCIODgwnVpXjJ/CN/+WXg\n", - "n/4JCARuvHzJkuuvpzMiWLMGeO216bUtEcn+wv/614DdntRVzpg7MQj274+G81Qlsy+++Sb6PVD/\n", - "EBo/NDT+fDPNzcCbbyatKWmnGwShUAg5OTmxabPZjFAolFCZs2fPTlr3TrJvH3D2bOLlL1yY/nsl\n", - "+gv+88+BZctuvOwf//H666kGwdhY9Lm+Hpg378Zlzp0D/v7vZ+ak29jY5O9z8eLEef39wO9+l5o2\n", - "jfvmm6nt8L79FhgZSV17Uqm7G/if/5m83LVrwKZNwH/+Z+rbpCcQAAYGgMHB6/MmGxGk8tzBf/0X\n", - "sHZt6tavx6C3UFGUhFYibvHbvmHDLVVPipGR6M7ku9+dXv333gNMJuC++yYvG4kAXi9QXh7dSXzn\n", - "O4DBED108fHH+nX/93+BTz4BHnoImDMHSOQjWr8eGB2Nn2e1Rg8PjYwA//APwN/+7eTrGRcOA2Yz\n", - "MH8+8N//Dfzwh9G2qH31FeD3A2VlwN/8zfUdtfpPRTtPvayvD/jwQ/0y468/+ADIzwdUvzsm6OmJ\n", - "Pm/YEA2Fu++O9vXgINDWlvi2A9EQ/6u/im6/ep6iROdnZESfAeCPf4wG1cMPR6fHP6+bfW5dXdHP\n", - "+NFHr89L5O/iZoSI/r1du3b9oZ0Oh6P9MTYW/Ry/853pvdd770Wfx9suBHD4MFBSEr0SZ9y330af\n", - "//mfgX/7t/h5d92l/x7qvvi//4t+X7V/e4n66qvo8xNPXP8sv/wy+vzSS8C998aXP38eOH48+r0F\n", - "gM7O+M/pZi5din4HMjL0ywUC0e374Q+vz1P/3d/oO5A0QsexY8dEeXl5bHrr1q1i+/btcWU8Ho9o\n", - "bm6OTS9fvlwMDg4mVFcIIXJzcwUAPvjggw8+pvDIzc3V231Pie6IwOl0IhAIYGBgAIsXL0ZLSwua\n", - "m5vjyrjdbjQ2NqK6uhpdXV2YP38+Fi5ciMzMzEnrAkBfX59eE4iIKMV0g8BgMKCxsRHl5eWIRCKo\n", - "qamBw+FAU1MTAMDj8WD9+vVoa2uD1WpFRkYG3vzLGZSb1SUiotuLIoRs99AREZFaWu8slumGs2Aw\n", - "iIceeggrV67EqlWrsGvXLgDAxYsXUVpaimXLlqGsrAxDQ0OxOtu2bYPNZoPdbkd7e3u6mp4ykUgE\n", - "hYWF2PCXqwVk7YuhoSE8/vjjcDgcWLFiBY4fPy5tX2zbtg0rV65EXl4ennrqKXz77bfS9MVPfvIT\n", - "LFy4EHl5ebF509n2jz/+GHl5ebDZbPjZz36W2Jsn7WzDFI2NjYnc3FzR398vwuGwKCgoEL29velq\n", - "Tsp9+eWX4sSJE0IIIYaHh8WyZctEb2+v+NWvfiUaGhqEEEJs375dvPTSS0IIIf785z+LgoICEQ6H\n", - "RX9/v8jNzRWRSCRt7U+FHTt2iKeeekps2LBBCCGk7Yunn35a7NmzRwghxNWrV8XQ0JCUfdHf3y+W\n", - "LFkivvnmGyGEEE888YT4/e9/L01fHDlyRHR3d4tVq1bF5k1l269duyaEEKKoqEgcP35cCCHEunXr\n", - "xPvvvz/pe6ctCD788MO4q4q2bdsmtm3blq7mzLgf/ehH4g9/+EPsKishomGxfPlyIcTEq6zKy8vF\n", - "sWPH0tLWVAgGg+KRRx4Rhw8fFo8++qgQQkjZF0NDQ2LJkiUT5svYFxcuXBDLli0TFy9eFFevXhWP\n", - "PvqoaG9vl6ov+vv744Jgqtt+9uxZYbfbY/Obm5uFx+OZ9H3TdmgokZvV7lQDAwM4ceIEiouLce7c\n", - "OSxcuBAAsHDhQpw7dw4AcPbsWZjN5lidO61/fvGLX+A3v/kN5qguApexL/r7+5GVlYUf//jH+MEP\n", - "foDNmzdjdHRUyr5YsGABfvnLX+L73/8+Fi9ejPnz56O0tFTKvhg31W3XzjeZTAn1SdqCINGb1e40\n", - "IyMjeOyxx7Bz5058V3P3mqIouv1yp/TZe++9h3vvvReFhYU3vRlRlr4YGxtDd3c3fvrTn6K7uxsZ\n", - "GRnYvn17XBlZ+uL06dP47W9/i4GBAZw9exYjIyPYv39/XBlZ+uJGJtv2W5G2IDCZTAgGg7HpYDAY\n", - "l2R3oqtXr+Kxxx7Dpk2bUFFRASCa8oN/ucf9yy+/xL1/uZ1R2z9nzpyByWSa+UanwIcffohDhw5h\n", - "yZIlePLJJ3H48GFs2rRJyr4wm80wm80oKioCADz++OPo7u7GokWLpOuLjz76CA888AAyMzNhMBhQ\n", - "VVWFY8eOSdkX46bynTCbzTCZTDij+ieGE+2TtAWB+ma1cDiMlpYWuN3udDUn5YQQqKmpwYoVK/Dz\n", - "n/88Nt/tduOtt94CALz11luxgHC73Thw4ADC4TD6+/sRCASwevXqtLQ92bZu3YpgMIj+/n4cOHAA\n", - "Dz/8MN5++20p+2LRokXIycnB559/DgDo6OjAypUrsWHDBun6wm63o6urC19//TWEEOjo6MCKFSuk\n", - "7ItxU/1OLFq0CN/73vdw/PhxCCHw9ttvx+roSsYJjulqa2sTy5YtE7m5uWLr1q3pbErKHT16VCiK\n", - "IgoKCsR9990n7rvvPvH++++LCxcuiEceeUTYbDZRWloqLl26FKvz2muvidzcXLF8+XLh9XrT2PrU\n", - "8fl8sauGZO2LTz75RDidTpGfny8qKyvF0NCQtH3R0NAgVqxYIVatWiWefvppEQ6HpemL6upqkZ2d\n", - "LYxGozCbzWLv3r3T2vaPPvpIrFq1SuTm5ornnnsuoffmDWVERJLjf1VJRCQ5BgERkeQYBEREkmMQ\n", - "EBFJjkFARCQ5BgERkeQYBEREkmMQEBFJ7v8B+P2XH1cBu2AAAAAASUVORK5CYII=\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "prediction = net.predict([input_image], oversample=False)\n", - "print 'prediction shape:', prediction[0].shape\n", - "plt.plot(prediction[0])\n", - "print 'predicted class:', prediction[0].argmax()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "\n", - "Now, why don't we see how long it takes to perform the classification end to end? This result is run from an Intel i5 CPU, so you may observe some performance differences." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 loops, best of 3: 355 ms per loop\n" - ] - } - ], - "source": [ - "%timeit net.predict([input_image])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "It may look a little slow, but note that time is spent on cropping, python interfacing, and running 10 images. For performance, if you really want to make prediction fast, you can optionally code in C++ and pipeline operations better. For experimenting and prototyping the current speed is fine.\n", - "\n", - "Let's time classifying a single image with input preprocessed:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 loops, best of 3: 210 ms per loop\n" - ] - } - ], - "source": [ - "# Resize the image to the standard (256, 256) and oversample net input sized crops.\n", - "input_oversampled = caffe.io.oversample([caffe.io.resize_image(input_image, net.image_dims)], net.crop_dims)\n", - "# 'data' is the input blob name in the model definition, so we preprocess for that input.\n", - "caffe_input = np.asarray([net.transformer.preprocess('data', in_) for in_ in input_oversampled])\n", - "# forward() takes keyword args for the input blobs with preprocessed input arrays.\n", - "%timeit net.forward(data=caffe_input)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "OK, so how about GPU? it is actually pretty easy:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "caffe.set_mode_gpu()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Voila! Now we are in GPU mode. Let's see if the code gives the same result:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "prediction shape: (1000,)\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEACAYAAAC+gnFaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAG2ZJREFUeJzt3X9w1OWBx/HPOtk7O1hRImLYTSeQDewCSUzdwFDKTFoJ\n", - "GTjYkuh0Uhn02pxmcNC219beP52CNxUzjnMV05lLOX9rQ/7wxlgP92IGd4Ao7CkwOMYfCZecy2Is\n", - "BVL5oYasz/0Rs+5uYPODDQs879fMTvb7/T7Pd5993P1+9nm+3y86jDFGAABrXZXtBgAAsosgAADL\n", - "EQQAYDmCAAAsRxAAgOUIAgCw3KhBEAwG5fV6VVRUpIaGhhHbW1tbVVpaqrKyMt1yyy3asWNHfFtB\n", - "QYFKSkpUVlamhQsXZrblAICMcKS7jyAWi2nu3Llqb2+Xy+VSeXm5mpub5fP54mVOnz6tKVOmSJLe\n", - "eecdVVdXq7u7W5I0a9Ysvf3225o2bdokvw0AwESlHRGEw2F5PB4VFBTI6XSqtrZWra2tSWWGQ0CS\n", - "Tp06pRtuuCFpO/erAcClLW0QRKNR5efnx5fdbrei0eiIci+99JJ8Pp9WrFihLVu2xNc7HA4tW7ZM\n", - "fr9fW7duzWCzAQCZkpNuo8PhGNNO1qxZozVr1mjXrl1at26dPvjgA0lSR0eH8vLydPToUVVWVsrr\n", - "9Wrp0qUX3moAQMakDQKXy6VIJBJfjkQicrvd5y2/dOlSDQ4O6tixY8rNzVVeXp4kafr06aqurlY4\n", - "HB4RBB6PR4cOHbqQ9wAA1iksLIyfj71QaaeG/H6/urq61Nvbq4GBAbW0tCgQCCSVOXToUPw8wL59\n", - "+yRJubm5OnPmjE6ePClp6IRyW1ubiouLR7zGcH0eRr/97W+z3oZL5UFf0Bf0RfpHJn9Apx0R5OTk\n", - "qLGxUVVVVYrFYqqrq5PP51NTU5Mkqb6+Xi+++KKeffZZOZ1OXXPNNdq2bZskqa+vTzU1NZKkwcFB\n", - "rV27VsuXL89YwwEAmZE2CCRpxYoVWrFiRdK6+vr6+PMHHnhADzzwwIh6s2fP1oEDBzLQRADAZOLO\n", - "4ktIRUVFtptwyaAvvkZffI2+mBxpbyi7KA1wOJTlJgDAZSeTx05GBABgOYIAACxHEACA5QgCALAc\n", - "QQAAliMIAMByBAEAWI4gAADLEQQAYDmCAAAsRxAAgOUIAgCwHEEAAJYjCADAcgQBAFiOIAAAyxEE\n", - "AGA5ggAALEcQAIDlCAIL7dwpfeMb2W4FgEsFQWCh//kf6fPPs90KAJeKUYMgGAzK6/WqqKhIDQ0N\n", - "I7a3traqtLRUZWVluuWWW7Rjx44x10V2OBzZbgGAS4nDGGPOtzEWi2nu3Llqb2+Xy+VSeXm5mpub\n", - "5fP54mVOnz6tKVOmSJLeeecdVVdXq7u7e0x1JcnhcChNEzAJ/u3fpH/+Z4luBy5fmTx2ph0RhMNh\n", - "eTweFRQUyOl0qra2Vq2trUllhkNAkk6dOqUbbrhhzHWRHYwIACRKGwTRaFT5+fnxZbfbrWg0OqLc\n", - "Sy+9JJ/PpxUrVmjLli3jqouLjyAAkCgn3UbHGI8Ya9as0Zo1a7Rr1y6tW7dO77///rgasXHjxvjz\n", - "iooKVVRUjKs+AFzpQqGQQqHQpOw7bRC4XC5FIpH4ciQSkdvtPm/5pUuXanBwUMePH5fb7R5z3cQg\n", - "wORjRABcflJ/JG/atClj+047NeT3+9XV1aXe3l4NDAyopaVFgUAgqcyhQ4fiJyz27dsnScrNzR1T\n", - "XWQHQQAgUdoRQU5OjhobG1VVVaVYLKa6ujr5fD41NTVJkurr6/Xiiy/q2WefldPp1DXXXKNt27al\n", - "rYvsIwgAJEp7+ehFaQCXj150jY3Sffdx+ShwObtol4/iysSIAEAigsBCBAGARASBhQgCAIkIAgsR\n", - "BAASEQQWIggAJCIILEQQAEhEEACA5QgCCzEiAJCIILAQQQAgEUFgIYIAQCKCwEIEAYBEBAEAWI4g\n", - "sBAjAgCJCAILEQQAEhEEFiIIACQiCADAcgSBhRgRAEhEEFiIIACQiCCwEEEAIBFBYCGCAEAiggAA\n", - "LEcQWIgRAYBEBIGFCAIAiUYNgmAwKK/Xq6KiIjU0NIzY/sILL6i0tFQlJSVasmSJDh48GN9WUFCg\n", - "kpISlZWVaeHChZltOSaMIACQKCfdxlgspg0bNqi9vV0ul0vl5eUKBALy+XzxMrNnz9bOnTs1depU\n", - "BYNB3XPPPdqzZ48kyeFwKBQKadq0aZP7LgAAE5Z2RBAOh+XxeFRQUCCn06na2lq1trYmlVm8eLGm\n", - "Tp0qSVq0aJEOHz6ctN0Yk+Em40JdxYQggARpDwnRaFT5+fnxZbfbrWg0et7yTzzxhFauXBlfdjgc\n", - "WrZsmfx+v7Zu3ZqB5iITmBoCkCjt1JBjHEeM119/XU8++aQ6Ojri6zo6OpSXl6ejR4+qsrJSXq9X\n", - "S5cuHVF348aN8ecVFRWqqKgY8+sCgA1CoZBCodCk7DttELhcLkUikfhyJBKR2+0eUe7gwYO6++67\n", - "FQwGdf3118fX5+XlSZKmT5+u6upqhcPhUYMAk48RAXD5Sf2RvGnTpoztO+3UkN/vV1dXl3p7ezUw\n", - "MKCWlhYFAoGkMh999JFqamr0/PPPy+PxxNefOXNGJ0+elCSdPn1abW1tKi4uzljDMXEEAYBEaUcE\n", - "OTk5amxsVFVVlWKxmOrq6uTz+dTU1CRJqq+v14MPPqgTJ05o/fr1kiSn06lwOKy+vj7V1NRIkgYH\n", - "B7V27VotX758kt8OxoIgAJDIYbJ8WY/D4eDKoovsP/9Tuu02iW4HLl+ZPHZyIaGFGBEASEQQWIgg\n", - "AJCIILAQQQAgEUFgIYIAQCKCwGKcLAYgEQRWGg4AggCARBBYjSAAIBEEVhoOgC+/zG47AFwaCAKL\n", - "MSIAIBEEViMIAEgEgZU4WQwgEUFgMc4RAJAIAisxIgCQiCCwGEEAQCIIrMSIAEAigsBinCMAIBEE\n", - "VmJEACARQWAxggCARBBYjSAAIBEEVuLfGgKQiCCwGCMCABJBYCVOFgNIRBBYjCAAII0hCILBoLxe\n", - "r4qKitTQ0DBi+wsvvKDS0lKVlJRoyZIlOnjw4JjrIjs4RwAgUdogiMVi2rBhg4LBoDo7O9Xc3Kz3\n", - "3nsvqczs2bO1c+dOHTx4UL/5zW90zz33jLkusut//zfbLQBwKUgbBOFwWB6PRwUFBXI6naqtrVVr\n", - "a2tSmcWLF2vq1KmSpEWLFunw4cNjrovsGB4RfPe70r592W0LgOxLGwTRaFT5+fnxZbfbrWg0et7y\n", - "TzzxhFauXDmhusiOzz7LdgsAZFtOuo0Oh2PMO3r99df15JNPqqOjY9x1N27cGH9eUVGhioqKMdcF\n", - "ABuEQiGFQqFJ2XfaIHC5XIpEIvHlSCQit9s9otzBgwd19913KxgM6vrrrx9XXSk5CDD5uFoIuPyk\n", - "/kjetGlTxvaddmrI7/erq6tLvb29GhgYUEtLiwKBQFKZjz76SDU1NXr++efl8XjGVRcAkH1pRwQ5\n", - "OTlqbGxUVVWVYrGY6urq5PP51NTUJEmqr6/Xgw8+qBMnTmj9+vWSJKfTqXA4fN66yD5GBAASOYzJ\n", - "7mHB4XAoy02wzp/+JK1dO/R8925pyZLstgfA+GXy2MmdxRYidwEkIggAwHIEAQBYjiCwEFNDABIR\n", - "BABgOYLAQowIACQiCADAcgSBhRgRAEhEEACA5QgCCzEiAJCIIAAAyxEEAGA5gsBCTA0BSEQQAIDl\n", - "CAILMSIAkIggAADLEQQWYkQAIBFBAACWIwgAwHIEgYWYGgKQiCAAAMsRBBZiRAAgEUEAAJYbNQiC\n", - "waC8Xq+KiorU0NAwYvv777+vxYsX6+qrr9ajjz6atK2goEAlJSUqKyvTwoULM9dqXBBGBAAS5aTb\n", - "GIvFtGHDBrW3t8vlcqm8vFyBQEA+ny9eJjc3V48//rheeumlEfUdDodCoZCmTZuW+ZYDADIi7Ygg\n", - "HA7L4/GooKBATqdTtbW1am1tTSozffp0+f1+OZ3Oc+7D8PPzksN/EgCJ0gZBNBpVfn5+fNntdisa\n", - "jY555w6HQ8uWLZPf79fWrVsn3koAwKRJOzXkcDguaOcdHR3Ky8vT0aNHVVlZKa/Xq6VLl44ot3Hj\n", - "xvjziooKVVRUXNDrAsCVJhQKKRQKTcq+0waBy+VSJBKJL0ciEbnd7jHvPC8vT9LQ9FF1dbXC4fCo\n", - "QYDJx9QQcPlJ/ZG8adOmjO077dSQ3+9XV1eXent7NTAwoJaWFgUCgXOWTT0XcObMGZ08eVKSdPr0\n", - "abW1tam4uDhDzQYAZEraEUFOTo4aGxtVVVWlWCymuro6+Xw+NTU1SZLq6+vV19en8vJyffrpp7rq\n", - "qqv02GOPqbOzU3/5y19UU1MjSRocHNTatWu1fPnyyX9HGBUjAgCJHCbLl/U4HA6uLLrI/v3fpfXr\n", - "h57v3i0tWZLd9gAYv0weO7mz2ELkLoBEBAEAWI4gAADLEQQWYmoIQCKCAAAsRxBYiBEBgEQEgeUI\n", - "BQAEgYUSD/4EAQCCAAAsRxBYiBEBgEQEgeUIAgAEAQBYjiCwEFNDABIRBJYjCAAQBBbi4A8gEUFg\n", - "OUIBAEFgIc4RAEhEEACA5QgCyzEiAEAQWIipIQCJCAIAsBxBYCFGBAASEQSWIwgAjBoEwWBQXq9X\n", - "RUVFamhoGLH9/fff1+LFi3X11Vfr0UcfHVddXHz/8R/Sn/+c7VYAuJSkDYJYLKYNGzYoGAyqs7NT\n", - "zc3Neu+995LK5Obm6vHHH9cvf/nLcdfFxffOO9IHH3y9zIgAQNogCIfD8ng8KigokNPpVG1trVpb\n", - "W5PKTJ8+XX6/X06nc9x1cfEZI8ViycsA7JY2CKLRqPLz8+PLbrdb0Wh0TDu+kLqYPF9+mRwEAJCT\n", - "bqPD4ZjwjsdTd+PGjfHnFRUVqqiomPDrIj1GBMDlKRQKKRQKTcq+0waBy+VSJBKJL0ciEbnd7jHt\n", - "eDx1E4MAkys1CABcHlJ/JG/atClj+047NeT3+9XV1aXe3l4NDAyopaVFgUDgnGVNyk/L8dTFxcOI\n", - "AECqtCOCnJwcNTY2qqqqSrFYTHV1dfL5fGpqapIk1dfXq6+vT+Xl5fr000911VVX6bHHHlNnZ6eu\n", - "ueaac9ZFdqWeIyAIADhM6k/5i90Ah2PEaAKT5557pKeekgYHh5b//Gdp1arstgnA+GXy2MmdxZZh\n", - "aghAKoLAMsbwbw0BSEYQWObLL7PdAgCXGoLAMqkjAEYEAAgCyxAEAFIRBJZhaghAKoLAMowIAKQi\n", - "CCxDEABIRRBYhgM/gFQEgWVSzxEQDAAIAsswNQQgFUFgGQ78AFIRBJZhaghAKoLAMkwNAUhFEFiG\n", - "Az+AVASBZRgRAEhFEFiGcwQAUhEEluHADyAVQWAZpoYApCIILMPUEIBUBIFlOPADSEUQWIapIQCp\n", - "CALLEAQAUo0aBMFgUF6vV0VFRWpoaDhnmfvvv19FRUUqLS3V/v374+sLCgpUUlKisrIyLVy4MHOt\n", - "xoTxfygDkCon3cZYLKYNGzaovb1dLpdL5eXlCgQC8vl88TLbt29Xd3e3urq6tHfvXq1fv1579uyR\n", - "JDkcDoVCIU2bNm1y3wXGjBEBgFRpRwThcFgej0cFBQVyOp2qra1Va2trUpmXX35Zd911lyRp0aJF\n", - "6u/v1yeffBLfbjjSXFIIAgCp0gZBNBpVfn5+fNntdisajY65jMPh0LJly+T3+7V169ZMthsTxNQQ\n", - "gFRpp4YcDseYdnK+X/27d+/WzJkzdfToUVVWVsrr9Wrp0qUjym3cuDH+vKKiQhUVFWN6XYwfIwLg\n", - "8hQKhRQKhSZl32mDwOVyKRKJxJcjkYjcbnfaMocPH5bL5ZIkzZw5U5I0ffp0VVdXKxwOjxoEmFyp\n", - "B/62NumrmT0Al7DUH8mbNm3K2L7TTg35/X51dXWpt7dXAwMDamlpUSAQSCoTCAT07LPPSpL27Nmj\n", - "6667TjNmzNCZM2d08uRJSdLp06fV1tam4uLijDUcE5MaBH/6U3baAeDSkXZEkJOTo8bGRlVVVSkW\n", - "i6murk4+n09NTU2SpPr6eq1cuVLbt2+Xx+PRlClT9NRTT0mS+vr6VFNTI0kaHBzU2rVrtXz58kl+\n", - "OxgN5wgApHKYLF/W43A4uLLoIlq6VNq9O3kd3Q9cfjJ57OTOYstw0AeQiiCwDEEAIBVBYBnOEQBI\n", - "RRBYhhEBgFQEgWUIAgCpCALLMDUEIBVBYBlGBABSEQSWIQgApCIILEMQAEhFEFiGcwQAUhEElmFE\n", - "ACAVQWAZggBAKoLAMkwNAUhFEFiGEQGAVASBZQgCAKkIAssQBABSEQSWOdc5As4bAHYjCCxzrhFB\n", - "LHbx2wHg0kEQWCZTQfDuu4wkgCsFQWCZTE0NLVggvfjihbcHQPYRBJbJ5NTQp59eWFuAS40x0vPP\n", - "Z7sVFx9BYJlMBsHg4IW1BbjUnDwprVsnnT2b7ZZcXKMGQTAYlNfrVVFRkRoaGs5Z5v7771dRUZFK\n", - "S0u1f//+cdXFxUUQAOd38uTQX9tGu2mDIBaLacOGDQoGg+rs7FRzc7Pee++9pDLbt29Xd3e3urq6\n", - "9Mc//lHr168fc10kC4VCGd1fa6vkcCSvO9f5gPEGwXD5L76YWLvGItN9cTmjL7422X3xt78l/z0f\n", - "Y66se3LSBkE4HJbH41FBQYGcTqdqa2vV2tqaVObll1/WXXfdJUlatGiR+vv71dfXN6a6SJbJD3lP\n", - "j/Taa8nrtmyRIpGRZccbBKdPD/3t65tY28Yi01/448ely/V4eiUGwURHk5nsC2Okjo7kdcMBMNqI\n", - "4MYbpQcfzFhTsi5tEESjUeXn58eX3W63otHomMocOXJk1LpXkldekY4dG3v5yb52f/Zs6Q9/GHo+\n", - "/Mvlpz/9evu99068LcNB8Mgj0vlm/AYGpP/6r/Htd6LG8svsX/9V+t73ktf9939LJSWT06Zh0ei5\n", - "w/d8+vqk7u7Ja89k+tvfpM8/H72cMZLTKb311uS3KZ3/+z/pu99NPugPPz/fiGA4wP7615EhcqF2\n", - "75amTcvsPscqJ91GR+q8wnmYCxwjrV59QdUz4tNPhz6gU6dOrP4rr0gFBdL8+aOXPXtWamuTKiuH\n", - "Plh/93dDX4wPPpDefnv0dnZ3S6WlQ9M+w490Vqz4+uA97M47paefls6ckf7xH6VvfGP0dg87c0by\n", - "eKTp06V/+Rdp166RbTh+XHrjDamqSsr56lOW+DFJ/cikbuvulvbsOX+dxOcHDgy154Ybzt/mAweG\n", - "/iZ+1g4ckA4fntzP3yuvDP1duTJ5fWJ/JT4fLv8P//D1ug8/TD5ojuXrNtavpMMx9JmaMmXoMziR\n", - "r/Lnnw9NE+7eLV1/vbRkyddt6OiQFi0a2vew4YPpP/2T5HZ/vQ+HQ7r66vSvlfgd6e+Xrr1WumqC\n", - "l7z89a9Df1evHtqPJH388dDfBx4Y+tWf6MSJofdTVTW03NEhrVo1+uucOCH9/d8P9XE63d1DZVeu\n", - "HHpPidNPqc8zzqTx5ptvmqqqqvjyQw89ZB5++OGkMvX19aa5uTm+PHfuXNPX1zemusYYU1hYaCTx\n", - "4MGDB49xPAoLC9Mdvscl7YjA7/erq6tLvb29mjlzplpaWtTc3JxUJhAIqLGxUbW1tdqzZ4+uu+46\n", - "zZgxQ7m5uaPWlaTuy3UcDABXiLRBkJOTo8bGRlVVVSkWi6murk4+n09NTU2SpPr6eq1cuVLbt2+X\n", - "x+PRlClT9NRTT6WtCwC4tDiMuZIuggIAjFdW7yy26YazSCSi733ve5o/f74WLFigLVu2SJKOHz+u\n", - "yspKzZkzR8uXL1d/f3+8zubNm1VUVCSv16u2trZsNX3SxGIxlZWVafVXZ2tt7Yv+/n7dfvvt8vl8\n", - "mjdvnvbu3WttX2zevFnz589XcXGx7rjjDn3xxRfW9MVPfvITzZgxQ8XFxfF1E3nvb7/9toqLi1VU\n", - "VKSfJl4qmE7GzjaM0+DgoCksLDQ9PT1mYGDAlJaWms7Ozmw1Z9J9/PHHZv/+/cYYY06ePGnmzJlj\n", - "Ojs7za9+9SvT0NBgjDHm4YcfNr/+9a+NMca8++67prS01AwMDJienh5TWFhoYrFY1to/GR599FFz\n", - "xx13mNWrVxtjjLV9ceedd5onnnjCGGPM2bNnTX9/v5V90dPTY2bNmmU+//xzY4wxP/zhD83TTz9t\n", - "TV/s3LnT7Nu3zyxYsCC+bjzv/csvvzTGGFNeXm727t1rjDFmxYoV5tVXXx31tbMWBG+88UbSVUWb\n", - "N282mzdvzlZzLrof/OAH5rXXXotfZWXMUFjMnTvXGDPyKquqqirz5ptvZqWtkyESiZhbb73V7Nix\n", - "w6xatcoYY6zsi/7+fjNr1qwR623si2PHjpk5c+aY48ePm7Nnz5pVq1aZtrY2q/qip6cnKQjG+96P\n", - "HDlivF5vfH1zc7Opr68f9XWzNjU0lpvVrlS9vb3av3+/Fi1apE8++UQzZsyQJM2YMUOffPKJJOnI\n", - "kSNyD19krSuvf37+85/rkUce0VUJF4Hb2Bc9PT2aPn26fvzjH+vb3/627r77bp0+fdrKvpg2bZp+\n", - "8Ytf6Fvf+pZmzpyp6667TpWVlVb2xbDxvvfU9S6Xa0x9krUgGOvNaleaU6dO6bbbbtNjjz2mb37z\n", - "m0nbHA5H2n65UvrslVde0Y033qiysrLz3oxoS18MDg5q3759uvfee7Vv3z5NmTJFDz/8cFIZW/ri\n", - "0KFD+v3vf6/e3l4dOXJEp06d0vMp/ya0LX1xLqO99wuRtSBwuVyKJNx7H4lEkpLsSnT27Fnddttt\n", - "WrdundasWSNpKOX7vvpHez7++GPd+NXtjKn9c/jwYblcrovf6Enwxhtv6OWXX9asWbP0ox/9SDt2\n", - "7NC6deus7Au32y23263y8nJJ0u233659+/bppptusq4v3nrrLX3nO99Rbm6ucnJyVFNTozfffNPK\n", - "vhg2nu+E2+2Wy+XS4cOHk9aPpU+yFgSJN6sNDAyopaVFgUAgW82ZdMYY1dXVad68efrZz34WXx8I\n", - "BPTMM89Ikp555pl4QAQCAW3btk0DAwPq6elRV1eXFi5cmJW2Z9pDDz2kSCSinp4ebdu2Td///vf1\n", - "3HPPWdkXN910k/Lz8/Xhhx9Kktrb2zV//nytXr3aur7wer3as2ePPvvsMxlj1N7ernnz5lnZF8PG\n", - "+5246aabdO2112rv3r0yxui5556L10krEyc4Jmr79u1mzpw5prCw0Dz00EPZbMqk27Vrl3E4HKa0\n", - "tNTcfPPN5uabbzavvvqqOXbsmLn11ltNUVGRqaysNCdOnIjX+d3vfmcKCwvN3LlzTTAYzGLrJ08o\n", - "FIpfNWRrXxw4cMD4/X5TUlJiqqurTX9/v7V90dDQYObNm2cWLFhg7rzzTjMwMGBNX9TW1pq8vDzj\n", - "dDqN2+02Tz755ITe+1tvvWUWLFhgCgsLzX333Tem1+aGMgCwHP+rSgCwHEEAAJYjCADAcgQBAFiO\n", - "IAAAyxEEAGA5ggAALEcQAIDl/h+B3FfVQOwSzQAAAABJRU5ErkJggg==\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "prediction = net.predict([input_image])\n", - "print 'prediction shape:', prediction[0].shape\n", - "plt.plot(prediction[0])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Good, everything is the same. And how about time consumption? The following benchmark is obtained on the same machine with a GTX 770 GPU:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10 loops, best of 3: 174 ms per loop\n" - ] - } - ], - "source": [ - "# Full pipeline timing.\n", - "%timeit net.predict([input_image])" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10 loops, best of 3: 34.2 ms per loop\n" - ] - } - ], - "source": [ - "# Forward pass timing.\n", - "%timeit net.forward(data=caffe_input)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Pretty fast right? Not as fast as you expected? Indeed, in this python demo you are seeing only 4 times speedup. But remember - the GPU code is actually very fast, and the data loading, transformation and interfacing actually start to take **more** time than the actual conv. net computation itself!\n", - "\n", - "To fully utilize the power of GPUs, you really want to:\n", - "\n", - "* Use larger batches, and minimize python call and data transfer overheads.\n", - "* Pipeline data load operations, like using a subprocess.\n", - "* Code in C++. A little inconvenient, but maybe worth it if your dataset is really, really large." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Parting Words\n", - "-------------\n", - "\n", - "So this is python! We hope the interface is easy enough for one to use. The python wrapper is interfaced with boost::python, and source code can be found at `python/caffe` with the main interface in `pycaffe.py` and the classification wrapper in `classifier.py`. If you have customizations to make, start there! Do let us know if you make improvements by sending a pull request!" - ] - } - ], - "metadata": { - "description": "Use the pre-trained ImageNet model to classify images with the Python interface.", - "example_name": "ImageNet classification", - "include_in_docs": true, - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.9" - }, - "priority": 1 - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/examples/detection.ipynb b/examples/detection.ipynb index e2a981a00d7..6a03c996245 100644 --- a/examples/detection.ipynb +++ b/examples/detection.ipynb @@ -8385,7 +8385,7 @@ "pygments_lexer": "ipython2", "version": "2.7.9" }, - "priority": 3 + "priority": 6 }, "nbformat": 4, "nbformat_minor": 0 diff --git a/examples/filter_visualization.ipynb b/examples/filter_visualization.ipynb deleted file mode 100644 index 6d629c5b635..00000000000 --- a/examples/filter_visualization.ipynb +++ /dev/null @@ -1,13214 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we visualize filters and outputs using the network architecture proposed by Krizhevsky et al. for ImageNet and implemented in `caffe`.\n", - "\n", - "(This page follows DeCAF visualizations originally by Yangqing Jia.)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, import required modules, set plotting parameters, and run `./scripts/download_model_binary.py models/bvlc_reference_caffenet` to get the pretrained CaffeNet model if it hasn't already been fetched." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "\n", - "# Make sure that caffe is on the python path:\n", - "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", - "import sys\n", - "sys.path.insert(0, caffe_root + 'python')\n", - "\n", - "import caffe\n", - "\n", - "plt.rcParams['figure.figsize'] = (10, 10)\n", - "plt.rcParams['image.interpolation'] = 'nearest'\n", - "plt.rcParams['image.cmap'] = 'gray'\n", - "\n", - "import os\n", - "if not os.path.isfile(caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'):\n", - " print(\"Downloading pre-trained CaffeNet model...\")\n", - " !../scripts/download_model_binary.py ../models/bvlc_reference_caffenet" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Set Caffe to CPU mode, load the net in the test phase for inference, and configure input preprocessing." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "caffe.set_mode_cpu()\n", - "net = caffe.Net(caffe_root + 'models/bvlc_reference_caffenet/deploy.prototxt',\n", - " caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel',\n", - " caffe.TEST)\n", - "\n", - "# input preprocessing: 'data' is the name of the input blob == net.inputs[0]\n", - "transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})\n", - "transformer.set_transpose('data', (2,0,1))\n", - "transformer.set_mean('data', np.load(caffe_root + 'python/caffe/imagenet/ilsvrc_2012_mean.npy').mean(1).mean(1)) # mean pixel\n", - "transformer.set_raw_scale('data', 255) # the reference model operates on images in [0,255] range instead of [0,1]\n", - "transformer.set_channel_swap('data', (2,1,0)) # the reference model has channels in BGR order instead of RGB" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Classify the image by reshaping the net for the single input then doing the forward pass." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Predicted class is #281.\n" - ] - } - ], - "source": [ - "net.blobs['data'].reshape(1,3,227,227)\n", - "net.blobs['data'].data[...] = transformer.preprocess('data', caffe.io.load_image(caffe_root + 'examples/images/cat.jpg'))\n", - "out = net.forward()\n", - "print(\"Predicted class is #{}.\".format(out['prob'].argmax()))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The layer features and their shapes (1 is the batch size, corresponding to the single input image in this example)." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[('data', (1, 3, 227, 227)),\n", - " ('conv1', (1, 96, 55, 55)),\n", - " ('pool1', (1, 96, 27, 27)),\n", - " ('norm1', (1, 96, 27, 27)),\n", - " ('conv2', (1, 256, 27, 27)),\n", - " ('pool2', (1, 256, 13, 13)),\n", - " ('norm2', (1, 256, 13, 13)),\n", - " ('conv3', (1, 384, 13, 13)),\n", - " ('conv4', (1, 384, 13, 13)),\n", - " ('conv5', (1, 256, 13, 13)),\n", - " ('pool5', (1, 256, 6, 6)),\n", - " ('fc6', (1, 4096)),\n", - " ('fc7', (1, 4096)),\n", - " ('fc8', (1, 1000)),\n", - " ('prob', (1, 1000))]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "[(k, v.data.shape) for k, v in net.blobs.items()]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The parameters and their shapes. The parameters are `net.params['name'][0]` while biases are `net.params['name'][1]`." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[('conv1', (96, 3, 11, 11)),\n", - " ('conv2', (256, 48, 5, 5)),\n", - " ('conv3', (384, 256, 3, 3)),\n", - " ('conv4', (384, 192, 3, 3)),\n", - " ('conv5', (256, 192, 3, 3)),\n", - " ('fc6', (4096, 9216)),\n", - " ('fc7', (4096, 4096)),\n", - " ('fc8', (1000, 4096))]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "[(k, v[0].data.shape) for k, v in net.params.items()]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Helper functions for visualization" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# take an array of shape (n, height, width) or (n, height, width, channels)\n", - "# and visualize each (height, width) thing in a grid of size approx. sqrt(n) by sqrt(n)\n", - "def vis_square(data, padsize=1, padval=0):\n", - " data -= data.min()\n", - " data /= data.max()\n", - " \n", - " # force the number of filters to be square\n", - " n = int(np.ceil(np.sqrt(data.shape[0])))\n", - " padding = ((0, n ** 2 - data.shape[0]), (0, padsize), (0, padsize)) + ((0, 0),) * (data.ndim - 3)\n", - " data = np.pad(data, padding, mode='constant', constant_values=(padval, padval))\n", - " \n", - " # tile the filters into an image\n", - " data = data.reshape((n, n) + data.shape[1:]).transpose((0, 2, 1, 3) + tuple(range(4, data.ndim + 1)))\n", - " data = data.reshape((n * data.shape[1], n * data.shape[3]) + data.shape[4:])\n", - " \n", - " plt.imshow(data)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The input image" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvUmwbll6HfSd9m9u997Ll01lZmWqVFUulShs2S4ZN2CB\n", - "JGMKg4PAxiGHAxg4gjEOIhgyYeSJTQQaMWNAVIgJaECgMG7AgZsQ7gLbQq1VqlRVKjPfy9fce//m\n", - "tAz2Wvtb+51f5fAly9fA/gbvv2//5z9nn92ds9e3vvUV8zzPli1btmzZsmXLlu2f2cr7rkC2bNmy\n", - "ZcuWLdv/Wy2/SGXLli1btmzZst3R8otUtmzZsmXLli3bHS2/SGXLli1btmzZst3R8otUtmzZsmXL\n", - "li3bHS2/SGXLli1btmzZst3Rvi8vUj/3cz9nP/RDP2Rf/vKX7c//+T///bhEtmzZsmXLli3bvVvx\n", - "WetIjeNoX/nKV+wv/+W/bO+884796I/+qH3zm9+0r371q5/lZbJly5YtW7Zs2e7dPnNE6ud//uft\n", - "S1/6kv3AD/yANU1jP/VTP2U/+7M/+1lfJlu2bNmyZcuW7d7tM3+R+s53vmOf//zn4//fffdd+853\n", - "vvNZXyZbtmzZsmXLlu3erf6sT1gUxT/1mPbiwvqbm8/60tmyZcuWLVu2bJ+5nT3e2s0ntye/+8xf\n", - "pN555x374IMP4v8/+OADe/fdd5Nj+psba84vrL04N7PwYrW5ujIzs0koW0WJl7JTLK7KX9iKqgq/\n", - "rf3AqZxwDgHd6gLH2+K8c2HL42Gl+bXGYQjHjaP/djiGMjlfxeNsMvlxOB8uUUsFhvinnHeW38L4\n", - "olpOsxy3bCB/ofVzxPbEdafJv5umcN1h8LLjgWW938KIdpWbnYz36m1XlaGR67qx3cd7276xiXVq\n", - "Vz7sVqsmHI/+XK1W8bumCcet1q2UhePbulmUVdJ3Qx/qtNvtYtnL64OZmV3f+mQ4Hgd8HnF9r1tR\n", - "4R6rWGRzEe5/ljIrQzvJkLSmDedpZIZxbE3TIPVEPTq09dz5aXHCufAxUc7hXicvshljYZ68UkUR\n", - "LlyV8lvUr2287VjngkuBD0Qbh/Bld/T6dv2IMhm7uIdpmqx/drTm4crYPeu1N0C9Cudrtl5WluE8\n", - "BT55TTOzecRxcl8z5mIhYzcO//nEJk42dnFGyLxiO3JsjoPMP8yTqtJOxHfSriPH/SydwuuOMjc7\n", - "jJ3Jz8d5t5I2aTdhvG/OQiNuL338b8/XZvZKu6I/dT5zLtTnGzku/Ob8wsvaszWq6XXf7cL8uL0N\n", - "c+fZR8/id598/Dx8fve57b+9s817WysPGKelt/XE9Wnweg4Y47M6QnhZGXcz1phq5rjz7yqs9XVT\n", - "SVn4LCtZ66pwjVK6rvRF3o9Dh3ajrpMtfotzePPb6jxcrNn49Vdn4e/tmc8rX0f8WhOuoWvsgHm0\n", - "v/aym5dhLZoO4be3z/fxu/nIeaLjP5RJ88exO0vbTRXnmh/HdbeUH5+9dmZmZpdvXsWy57/2ib3/\n", - "9ffj2tH3/kzgGJ5lrL/EuvvkVz+NZTXXGKkn5z/rFu4jVHCeCjkundvbjf9/sw7HV3JMVYb6VbWs\n", - "NTXbxNcztmPXe3uOUzjf9ZOj3TwNz4xq1dp3/9En9tvZZ/4i9fWvf91+5Vd+xb71rW/Z22+/bT/z\n", - "Mz9j3/zmNxfHrS4v7fzttz7ry2fLli1btmzZsv0/sovHG7t4HDYdzcXZP98Xqbqu7ad/+qftj/7R\n", - "P2rjONqf/bN/NkfsZcuWLVu2bNn+P2mf+YuUmdk3vvEN+8Y3vvE9j1ldXiSuMMLtiZeK8LgWAvYr\n", - "BB8kfKngX3RtCYxJ94GfNsFCl9d65fxm7rIqBUYfcB519034TSneOda5oGuhEDjZlrAr22c+6cbQ\n", - "egIKlTLWWRFR93IUr3y620kh1BrQ9iSw94wKTiYuqBPdNMFVMI6VVZsKLkHA4YW6L8OP2pawuEPG\n", - "Ba5VdnI8YNfS1I2FsaPuxmlOPrVO2p595zBvuFe/VhE9AdpO0RcWrUTbpfTA8J9J2xjjZBRXFWHx\n", - "ccTYEPdkQf/hvLyvxI2F7+dZ27Vc1LOFO6huZNwBPu8PaIfefwDvdPw0M+uOcEF69xuHR1mWVm0a\n", - "K4rSyuLEeI4D2st4H/Gqs7rWC709/I1+nXXp6nF+LykxJ6Zk7bCFzQXdp/hd7ddnv+okKjBM50qO\n", - "o2ujEBck6yk+WHoqC51PcIcce2/kHu6b421o5Jc3h/jdo8ehLueXfv3NJvx2vXUf1AYuve3Ds1i2\n", - "PduamdlqLe7zdbihTtzNZQuqBO772Hlnn/U7HH9uq6q29etr63fhfvYvvZ7z4cQ8aUKdB3GjFLG/\n", - "pY2LdH1qapkv8RilgIS/a+k7ltF1ZGZWYt4pj5dLgdI3uD5M6JtK+xWHVeKzb+A+KtW3jzVO6Q4l\n", - "x5q69uDu7bVNOO4xdkqZRGNB96D0FykD2tgV55XcP9tE6knXXi3u/noVzte0Xvba+69Zs2qsxpho\n", - "Gh9Dw7ikhbSHMGaalY/Jucf1a70+6ibPwrJcugC53E9YJ3uZV/QKtuLGKyK1R8cVn3F+2uj6lWvF\n", - "Z4e0Uylr5im7N2Xz1eXlfV062z9nq7ffl/f1bP8CWrXJff3/F1u/vr7vKmT752QP331431X4F9ru\n", - "bdWby9L0NXAelm/fkbxWKfqA72T3XeB1Vd8ZeeZR33T53ohdeBJhSJQo2f3yh0LiBDuyFmL7CmTU\n", - "budoSiRoK3LAHQF+OunOnIVy+KiQXazUq5UzK4ox+SqxYvlGzt1yJe06jtzByb1idNST7yq4wy4E\n", - "OYroh7yXFxElU1Z2sKFXVj7e/jucTyGMI8n5eg/oa0FOeraFoAQT+njodadJ8rTvsJ08TwRDdlUR\n", - "kfAqkeRayE53xMirZQfH/tEdEXe4AojFdq8i+CTnwIGFTNM5DppTKK305xzQgVXtD7tmg11i4/05\n", - "gjze4BpdJ2gd+qkTRHDsiuRe5FbToX6inWoMqCrFjsNvB+7CZf7PRKSk7BSsVBImEgL8yPVEyeZF\n", - "8mkmO9KSbSfrCom4gojMVfheqhkRjFK7jlxzIeVPLQnYMndxuekgKNUeyOW+x//lWkCuus43ohcP\n", - "Qh+vLhwl2KBse3Hhx10FdKp0rrk1dRgLtZDsud71YxhD+50Q4bfhxxdyD/t1qCcDR8zMXj4FciVr\n", - "4gzieTlq8ADnn1++IrI0cwzJdyURFJlEBF8VQcAJZYmzMiJLlZQxUEMQwRFE5Qpto+T0+EiSc5TL\n", - "Mcl1sizlXnFcKWgWg5KGUZ8dOJ5dIqRrPhPLZLWnh0PqecIjw3bV5x6RuGLl9bx4EEjmjx74GNts\n", - "Q9/OxXJd4z20EkRxBIrabKUCXGsEEuLUnpOoAJSdCqLCb9VLxNW8lLW7RJvNOp+BWBX6nMBvKgne\n", - "YCBXIfNe/z5lOddetmzZsmXLli3bHS2/SGXLli1btmzZst3R7s+1Z0VKhCZkp1IsOEAJwywrTr0C\n", - "qiuM5Oli6UaIdUjI2YBd9ZjoR1QtHmpcOBRL+PYKulhmZj20pY63TsCM2h/FksRIHZeEX0d4Um5r\n", - "JIlc4NFIkE5clfgQBHwq+NslFH2SiEcSZ+OwNyHrXqB94rMKY8f+kcqXEbJVsifcIvjBqCRKQLBH\n", - "cY/QzTWIa7EiiXyQ9sR5R9UMOuHSLAq4D0/oWLUrtJdo1hhcuqMQ5tmPyVCrTkDLhS2OYzsVdG1p\n", - "Z7OfNGCBjZgEIJSvHmYtdKw2F1IGvZtiVld1KOt5felDjuGuE/cUbkddbHS3VEL25RgvqyUkPsp8\n", - "dlI470/cmNBdS7Z7JKfr8KOOll7kFRK5mRNUG9EgI/GV3hMljFeRFKt9wt+pewjjr9FxOi2OmzFP\n", - "C3Xtom1PcOztCAJyNXp9D7eYf8XLWDbV4bjL0dcfCpjVZ+KyAIm4Fl02Xixxnx+4duJ4cfustiCg\n", - "y/yvIy3Byy7rQGzfPXU3+u0nYS0sVBeMpGx1waLdyTKodE1iYImM4QZjTInVJzjETjyX38alU11V\n", - "dHdxDosbe2BghxCrG/h01WUd21MGYKRUyLW4xjWyxnTUOaLbMVlDUHZCHy0xrufqMWO7yoQiLaXd\n", - "bmNZu0LIf+vjZL1Z477C/0dZf7ronvdrVRhr662vp1NHd+fStZY8dqktpVp5RfqH0iNI2ThIUMSI\n", - "e23kXvkYrxOqCPX2vP2bFvejbuETz0y1jEhly5YtW7Zs2bLd0e4NkaqryiZFH4j0CNk5hpomauN8\n", - "S1cC6pT+wMwiiTXZur5CXksgBO50FK2grILsIEhOE2ZpDPUu/I14jV1cWzjZd3cIrNEphtzreQnX\n", - "SBgs1Za1zgzNVZTiRFqeKRJ19Ti86cera7gwkQ4lsYNELSTOmbczOGN1Gr5HqG+ym8KOqBDUoSKh\n", - "OpjudEqcd5At/OEQdrWKHK4Mys5CbObubxY5A+4qzs59515DgXjEcWvZhbUb3I+o7nJ8Kl9+Qv0m\n", - "3VXxb9nJUDW7kLETxZjR75Ps9MuRv/X2IsI2JuHiAZ1TZeeLK6hjPzh6PWtcf/TdJ1G6EcjccfA+\n", - "PB5YJyWA45rJrhoEYA2rPpGVgH2io5Vfx5DvZA6Tga+h4YTwFH3l/CsWxyXSJSCbakj2QFX+k1Ir\n", - "XGuWc3LSDASM1pa1qwA6pYhozbGt6u1Es06sRTXGYrGXrfHIcHnv13He4l4kAOJE8MqAazVKtsX5\n", - "Rtn+E+GbcPyg998CVVgvESkBmqytuav3tu6x3h+e+LpfUc5E1nier+J4nSQ0v/HVK5bh70rlZBiA\n", - "oerYcTgt+zghu7MuDBiQtqnR2Z08u/oOaLqiGpGUfUJFPxmTmDsiCdACzek7egT8O2YU0Pl3Kspo\n", - "TvDpYGxjJc8ze0QrcgYroKgalNIAuaKERauINI7vdv78W6Hf1xKA0Jcn5nOsu97EEmGOMiYYk5Pc\n", - "X4Vn9jR6neKSpe3EsSbwr3sJpAxVVs9FkrbihGVEKlu2bNmyZcuW7Y6WX6SyZcuWLVu2bNnuaPdH\n", - "Np+nlMB1wo1FCDQFKQs9PDkuOf/EBKFetiSMKTm0Qr3mxbcrgf2I+lZCNm5JdhS15QnJZ1WBdwXF\n", - "4AHYoSZIZRLWMREZWhKQxSkgf1EfR/1N/E7g/omQOTVGlkRI1eypQbqr116nc2gl9QKjdrsAc2si\n", - "S7pWJtGMcRVhMWp6MYhAvqLGU3IPgFgrSYZKt3DVKj4PWDzRB1nuGy7Ls/QaCsVzDInLrIc+U6Xd\n", - "FJnSkgwTrp1C2olq2Er2nqlHxrHT62iHxkyhrhD8ITpmJVWJWyHAX4UDm3NxQeP+xQNt1xU1yADP\n", - "q4x59A5JnXgPUkbCrNVLyFybnE2RxITEa5zQjOH8r9ztEF3bqhlT+C9eqXoy56uGLhtlqnI9Wa4r\n", - "nAvqbiyje8wbcY76NOJaYPJpcdlE/Tj1GJTUwBMXMFw5FRPU6iIGwu7ZmbcJExlXrQRbDMs5WR3C\n", - "93vJSsB23N+6WNVxF4jsh10Y60PnSb5nCy7FVrpkOEEBGPF9X3mwzeYKrv1OAhp2SPgtA6WkS49B\n", - "LJq0my4mZSIb6Q5L13Li4mI/JnpDqK/8li5NBko0jdSNQTGiTt+jY7dCAYh6d7rGx4AqCd7oGXgk\n", - "7n6041BQi1DPyzZZBtEk2T6wJpXD8tlVSnLlAsr26j6kizLJSgA3c03F8CRjA55nos/KgIZGyeZI\n", - "gp0kI47P3RNZGdSlzLkz8l6V2oNzJXpfJNYvNSiVKUStRM1LHoMs6oRtbt/LMiKVLVu2bNmyZct2\n", - "R7s3RKqylJzL3HSqOuox/LYoS6iZ8fvljlRJZPF0kViq5wWJVBXTierorpK7LyEWxk2v5nrjxj7J\n", - "k8bd9Jz838wJjrVsiSMRNoHkGP55gpwnv42brySvFHNIFYtrebi6F7Xr8B9Vfd1eIqxa3tapIn17\n", - "7WhGB1XyQULnRxCpx6MoZRep/MFJ4qSgZAOVnSvfaTOcXQnoNXaTutOoqqVMAwmFRAYUQbw9hp34\n", - "DvnFzCzm65qT3FCQEJi9TjGsvC4WZSYolf/N3FCy++SYUHVkyD6cyU6PUMdrrzmJfmyemplZu/Xf\n", - "rrHrf2l+P6+v3jczs+++fMKT+fVP5DCMl5R2LSqGdQtKFkPSJf/kRFKwjkkcT9Vnma4T6qK7yjEq\n", - "YSuxfEkUZz/WKl0RiaU+TmuQYrn+KCDs59OdPuopav8ckxo8Q3QukWkBiqjEYua4K9cK3ZEoj3tV\n", - "VJeI7JkQhiFxoDz9AYjJ8SA5MUHK3d06Uf0ItenDjaNOx+OL8NkFlKqf/fiIagj6ssY6YYLSUCFf\n", - "kduaUhyap5GZIgSlIhJJEnGSxYJ9qMT+7/FXisjHi0bj2pL4Khj4ERF8R3AakKfLjbd/HZErzWyA\n", - "ekg7cXiMIp3A3JVHWSePx1TtPA0YWpKeT8mqWMzruVT7TsYpAnX0xxUDgARhrGuu+0svCeXja80K\n", - "ARL7euPrFFX5x8HXSX+OLfNUJsZn1+kHRPhI1imiyRqVFSNlYhHzCUoXW0uSvSChJ6+7uFq2bNmy\n", - "ZcuWLVu2f2bLL1LZsmXLli1btmx3tHtz7RVVkbg4COeOAqGd1phASQJ3xpPoFfDv93AVqitspo6U\n", - "nBhYsAKhdIcpZOtHCAGcWixCihxHurtIRNeaheObWhKEtoG9t9s7YZPkRb061b4TtVdA30qKLOAi\n", - "imKyAnHTBabodL0KFVyfO4twew7IVtx9JHlvzv1aNzfQjLl2t0AHaLevhJS9Z9ZWkij9+hP9o6f6\n", - "Wmw6oSNEN5+253rTLs9HBfyS5HjRjIF7RtVx49fixYtSUMlIAVRdqGuJY0xJsXQBAU4Xwjzdsjok\n", - "Nxso8QrZuIG2zuOHV7FsRYL2hZ9vBfx69/EHfo0DScZwWSVkcxKwl27sSly7dbXU4jmlBVPTba/k\n", - "bWq1MIuBuux4vGY7OOXHmLwHaAyoULI5v01cAMUra4K6B6MUvyZt7nCYaDHRPam0BJ6nVt8W3Niy\n", - "UDWrE66SgVphdO2J3h5+u7qSROI13cJ+3h5BC3vR9jkeoBUmrr2bm+Dm3V+/8GsgAKFC8MJQ+jkG\n", - "C+OlWIqjR5K4mZOnax0Alxgn0v8N5v386YlMAVQCL9Ttc2KtjV0oQRye+dbrzgTliVYgMyr4hB6N\n", - "cxJBLKXf7ArzbnUhLnNkEShLv4cBfXb6Wktl9V4Sg1NLLmphqRJ3qST7WPrqrcZxrUEcdOkNe3F3\n", - "giJQSfRAHTtN2pjPEdyrks2ps1WemFeq4t7CjXYQCXQnzcsaOzDwyc/XxXkHl+Wo5HTcv061ht/L\n", - "mhCDBvxaVRXqpBktfE3283XzqXZ3y4hUtmzZsmXLli3bHe3eEKmxNCs0Nnrmbk0svuEK2fgE+sAd\n", - "5iToC3OGlYlSN99cl+S0kuGS+hpKsrm8QQ94E+9FnTuiU0kI55JQzuvGt/lJSZRAi/zqcYd7cekk\n", - "YpJHD3vJK4S8f0V5grCX7NwZ/h2u241C2MZXrexMKuSa22xE6gFK4FvJ4RVlEiRMuG4Dinatufb2\n", - "+I3kKRzG46tFfi2E0I5dAkmYmVkv7dqiHcdJiLWxPSVMliHBte7wSN4PFZgUplsCKDbjWsr17yCJ\n", - "MJojh2XcsvuBDVCqUhXYycZlXi9VDMdxrSAdq4uwg9rIPRA5rAUl/V1f+t1mZvbp4bux7KOXz83M\n", - "7PX1o1j2BOjE0JGIqjtoIFJK2KfUhEwTDjvu7sKNULpCdppEiTWiAf1UFikKYGZRkmRSxWrOyT7Z\n", - "fvOiizLdpcd+nEQSA+0YLyH93x+B3AzL60+S/3ECIlhKrr1yImFXyjieVkIAXp1S4AYBfSYRXtCa\n", - "er28VkHpFJ9Eh0Mgjw+CZvWHcJ79C5E6uL4xM7Ou97lTrXD9GuerhRzcABlQbwIA67X52lEA1Vqt\n", - "/fokzU8S/l/vcJ699DvaNqKJieo6ScdL+ZM5yatJRFrQH1SlF0kC/naSfIZUhV9vME5lrhGtWNeO\n", - "Um0gDTCVIlMCJLw/ysKG58hK0PwJZP9K81/iuRSHuAYRDB3uT05LD4Oir1zX5LiSJH6Zft3AAChd\n", - "gLc4n6ydBIenEwR4o9q4F/aQ/1CUnpJA8yRjgsi1PLttZFkSFRDOwbVe+nCGxEPCK0fARp2gxAxA\n", - "Em9KRB0VYceYkMZrcq69bNmyZcuWLVu274/lF6ls2bJly5YtW7Y72r259myeXskhTBKpEtzgCtOE\n", - "gadIoXQLJGTfxenkp/PiOxIgR4H26xNaHIT2O4H9ontA6jkBMlV4coywJIiI6saJuKSSXcNnK8Te\n", - "1VWAXZls0szsJRRjeyUKR60sgWdjEla6UZQIPyefZmYFINBKGOgkDNLFZ2a2vQiQvgigWwWl3KkX\n", - "DSC4wIbe69RCP4cepUYEPaipVLWS+JKaPdInw8BErqI2TTdape5G6L2ojhH7p1rqlBA+VtfKAGi7\n", - "H3WsoS6NNAAUoJOgBKoXJ3g7VcGpT6Rqul1SbzNXr56Fxfvu4zfMzOxy433y0bMPzczsx374345l\n", - "v/ndv29mZr/R/lYse/5bvx6qtD/iWqL7MqUETzN345WVli3JmTG5rwYACPH21eMqqqLLnCC0Xoor\n", - "bjK6DOQcr5xLS1VHiIEnehSJrQxYGDqZLxi7lew3o96dXgmXGNW1jzFeynyi50f7rowaXBp4A1cF\n", - "XWziMo0k+rUcT1H8Qcb/AcRmIZvvXkKD7aWTzXsEskyDu6Xp2ltDM65QCgKDIrSMel+NJzKv4O5T\n", - "FX1qcI2jamBhnbyV+czkviOCaJTageu2qWgS6qEEaOj9DfpbrH8yx0acZ9Dk0tA+imudrH8kOSsR\n", - "mut5tRISc8PAHvU3gZbQuRutZNJg0aWax9BoHdYdPUdM7i1rSAyUGtUtj3GdiBDSjaUBHeFTMwVw\n", - "vdOy4wB3MNbnQZ41A4j6o7jbh56ahfpMwkcSUcR7UL255fOZen+cp6Wu4VG0axk8posSA2Rq8W0y\n", - "yKg4EbxQyHO3yjpS2bJly5YtW7Zs3x+7v1x7VqbqxPi7lN3vXJOcqHm1ljvNSFQvFf0In4MSC3E+\n", - "SgKowjLf+tPwe4bLaqgzQojlTZvES1VxnqlKq2G1JIVzpy2v3EUkJ+sOYklYbYiqtNtYVkFt93bn\n", - "u8rDMexqetklxA3GiZBTCgUfRGrhfLoMv5N6NkCi6rW8reP669rrtIXyct9/4nWiKrnsZrZnD8Od\n", - "gog5JKHBJIL6Dppjoj94Rx1JmpfdZws0q+j9tw27QlCvGjtC7oiU83gEwrXbuxL4HmXd6O1UMKw9\n", - "yfVkKFNV8mCV7Ig4tjhyNF/YDE0KBamITm6E173FjvmL5+/FskeP3jIzsx9+44di2e/90tfNzOwf\n", - "/8O/G8v+4d/6C2Zm9jvf/7KZmf2fv/Rh/I4KCp3soIsWu1q910ieF1I061yoAvuSUE416Bq7/0nz\n", - "a5HYLWM4EouTfHlLqYW4i09231hjTiAX7PhC1gvmjkvydRItEkRg7FhRVSDH9yJnEb/uhZTcMPDF\n", - "r8EhE/N6Sh60AqhnUes4CWWdBGUcj2F8HnY+/q9fhn7cP/Xx3KI9GyXFVww8CGW1oN/M/FBLG67q\n", - "sE5sVz7/DVIIOwnA4PA4CAG72qDt5KcdCNi2w3rdL1GVUQnLMTecNiLWH41TAZo0JvlUR62amZk1\n", - "MXcnVMzluULkQtF/yqSYjB12XiJJw+eJorSUXxEF/hKIZYOxMe69D4nIpDlhEWyigRrM3apBKehH\n", - "JVtTpaWXQAUGIR1677sZausTsgLUkjKCiPQkQVnziTnp+Sw1UCw93swJ5bPOU/SdS6jIeRmAIGsn\n", - "vS1p9pBws+3KAwWYoaNWaXNec9KclBmRypYtW7Zs2bJl+75YfpHKli1btmzZsmW7o90f2bwfTCmb\n", - "UYdU0Fl6DFSxVlWWaRPxSU3QeEKdlFoVFfVsxI0UXYUJsZI6Jno1wM2DQ32EqivVRwIsOCo8atSH\n", - "gRbJRlwBNYjFhbidmPhVbmIuCEV6112UIEUKKZtuPiYPNjM7wM3Y96yP3D8TdQo3cL8LBz545Odl\n", - "k9Tibqjr4L7ZCLRfQg34jdf9fGwKTULLOhdF+O1RYH8Syw/uiYg6P0PnhSNuaBANpAruiV7kUXbw\n", - "964E769JyoyQvffrfoDGjmrxxESiAs9HHRslMaJ/pO+IvKureI5QNeB8hefLJRTOWIj1VgjI6P/1\n", - "6kEs+wNf/FfDdzvpUJBYf9fv+WOx6D8Gyfdv/O2/ZmZmH18+j989uV4qmw/lEffsp2U99f6jGy9x\n", - "QYBYLWNntQWhmc0wKZwPIrBKzJwg+1JvaFZea3TLicuAARUy7uNI4HVrpQcs3YMkwqobg/N57pdU\n", - "gbETFxRcNfVK1zCsSXW5KIs0B9UYQl+r7k1U0RZtpwGu75uXvv4cn2JN2KveHlxL4qqne51yV3qv\n", - "Bcb1du3adg/Ogy7ZZusukxIu4FXjrt3n0zMzM9tXQizGGidT12qsDwMzAYjbkW2sLmBOp8K0nUI9\n", - "VSuviG7BRBgulIlXbg9ttc1ZuB9hUUQ3n2phkdCtpHT2v+rCTewznf9GV5lfo8fSARmxSEkJN8FM\n", - "DFqnIvnOzGyGq7BV1x76WGkZTEKsmQo8KEMfnuFjZLCPciDw5TCKAj4DVZKoDFJwJACAa2uxXE+V\n", - "llMjomKMLlUlkS+DUuj6nYTE3kKVfS0q5qvVkoDP5+5RngV9cr9Ly4hUtmzZsmXLli3bHe3eEKmy\n", - "KBIiWNx1a1inf7v4a1bCWvxuuSPUEE6+6cY8PUpijztcDVfFDrpYvpmnoZbhfEpA5G5Wd9jTQDkF\n", - "EKFVagEhzqXsVolEKTm5AslPiXgF3vQbCZM/K0IoctP4LqHGtq8HSnU4usJxvH3ZQtzehB3s7a3v\n", - "tM4uww5vM/rukwhLLWq/3Dmfn3n+t8ePDfW88eu+ErrcbgT9AWF+nK9jGQm1qmLMndAkoeskRXZy\n", - "P3vc5ErCrxmVUAARmI/eJyTF9xqai/oqIhhlJARV4A4qkV8ASqK5xghicqerCtdxRyjE6glj8sGZ\n", - "q5PvkYcLafg3AAAgAElEQVTqzc1bsezwcUDsPvjwN2LZi0+Cynm78R3Zj/8Hf87MzL72tX/NzMz+\n", - "q7/4n/m10IedBBs8eRmCB3QHFqeuzJ2pXN5rAeV7KtabuZwDibKaG5IbV82r5deU3feJbAen8u/F\n", - "3HW6TkTtBN7D0uYT/0uvn36aCbCdbsnxsSQKq0XUI2Z7UPiPHzKGiCZL2x2O4e+DyB9QDb6QMHnm\n", - "/5xk7ZiIBOL41hQtCH13uX0Yy167ChN7cyaINPp6s7qIZQPOu7t+6vezQvBGK2tnRGljxEL8jn/V\n", - "CQEc8gNC2K6AdK4EpetvQ6cUnYbO81PGBNaH3W2o2/pKZB0o9SHzmgElOiYYxJCSqCHTIkgLEZlE\n", - "uQa/oUqGLGsROVLHDIeYDn/mlaukX5mBomol2AMoTZIUsaAUjo+dDnIeLTwmpc4rIPxdtyTFJzI1\n", - "47JN2KNJUE5JlMyP6oDsRk+ASq0AfVSUsMGzaLWR5xQWlLb1svUaCK/OMdRPHxPDoMrvS8uIVLZs\n", - "2bJly5Yt2x3t/nLtDUPyZsqQzCnhPjDUWnPIxRj+WFbE4/38zLWU6JEVFJPD27Ls4LhznkWkkq75\n", - "4kTm5znhY0F8TZCjKRI7VDoB54Pvtdv5vdZFeJtfrTTUeLmrjvWVv3lZFUnjEYpmtahAxdx4Epp+\n", - "QH2HTkI+sSN99sx5Fuvz8JuLS9n9na15F3517Fw3wgO7ugzolKJu+/0ed4hdmGwDIqfkoKHBx+T4\n", - "cN9ABAVNYq6nUuUv0J6d5A5bAwkk+jMk3Afcj4aGU9SuXob/aqq5uDtVfhO1N2VMkK4Vh5huK5kv\n", - "cNRdXejjC5GauECysytz9O8f/cP/w8zMjjtH/zao4L57Gcv+yn/7X5qZ2e//4/+JmZn9qT/95+J3\n", - "f/Gn/wszM5sE/Xp2+5Q3LfeK+5J5ynxlOnIpJrkRRMxDkbnj1PmyxIdOoT/kuSinIx4n5xj5vea/\n", - "BF+riqK+goPjHlWQl6SqROgzZp+XsRPBRN3pgt+jYr4ME9e8o9x0c/3T5GgRktIcZvhU8V8MrEk4\n", - "Wiwrp3bx20Rflin2sBSUwv26fC3w8M43PiY264BOXV04R488uKr0sdZhbdmd+/x7fgicvMYpV9bv\n", - "IRNz+O2lLsiBMnMk8uxCELEzcl8cTTo8AB/pmZ9vfx3WExWTpLBmiWGqyExBpFkRGcCPnZwjjiNF\n", - "idCfg+bzJJqqiBgQGXKfas2ht6VcyylUR6U+IGuxFuQM634hyLmDfuqJCR+Dhv/HMYBnSKXPZKK0\n", - "trA01yyRUxXfJOzsv6HXZRQ0MYKUzImanJdf6vEQOhX0aQVuVCNc4k27tleN7wUquq3z7ZRlRCpb\n", - "tmzZsmXLlu2Oll+ksmXLli1btmzZ7mj3RzafUhxwpgK1uscYfVwqZAoYU+WeoSw9JkR1qsgq3E/8\n", - "MHxWAmcS2i+V2M3vy6V7JuGk414GkzxxOGAsFYIMzT2gHqW44o77UHbTepfU+DvJ4TQAqhQ30hjh\n", - "fm1Tku3FBcAcSsaQfw3XD79tJNfagFDX461D8bfPQz8dHsq1Xgvn6Y7issBpGlGR3V7AVVKLCwJ+\n", - "BLpFylKUsGNOQA/Jp/tG8991dI+ofwLQrvb/Ciju5kzcAg0IqGxCIZFOAwnQfnwF2FdzWFVos7rx\n", - "dppjmPoS2lZlZfdL41Ni/Rm8sF5d+jmG0BaThHV/9XO/28zMXnzoquT982vUSYiVbfCf9ELU7+H6\n", - "+YW/9E0zM/v6n/nP43c//mMhT99f+rt/PZY1m9CISQ5Bqn2XEiaPtpvE396C0Nqu5Lc1QvdRp7ZV\n", - "lwE+E1cIXXFSRJdZMimxTqi7mcfpNIErcRlULW7J6VSpSA1gDBfCjmWwSTMIsZnK4zLEJ7qyK3XV\n", - "Yd5TpkXdSDPDz/0czAAwdnIc3NzzUZZ45vo0JwVzQRs87sTqhuN+KauwgqzJ5tJJ5A8fvxbKVuIm\n", - "QTeOMk+PXXABnm/c3Xy4QDuJAnoBd/81Mgqs9tJgsSpCLIbMf3Xh9WzPQ11aDfXvQtnmTO4Hyu/X\n", - "15L/Dv4u5v3U/KukW2j+xX0f6ltpYEVFt5y3P6VrGgk2GLkWS1lZc+3GuUTCoIqZEIQWUjGwRcYa\n", - "/qyERkGJjUmpCnRViluekgGjaFIwu4UHgHh7UYnchBbB4JFExZwuO1Hgn0Fpocs0nPuEu5vSKaQU\n", - "jEqBwXguRaYHruWtSB1suU7P/tsG66MGL01Ys9c6do9Z/iBbtmzZsmXLlu37YvcnyDl3CWM0vswL\n", - "0sQ37PlEnptEkI0Ij37P7PMiksnrUUyylPMWcziuFiJeBCcEVaCYZBKSTOBK0QyQkftedzokpeIY\n", - "2VUOfKm+cYLfbbF8q7c2HFgpEY/EZ80Jxu2M5qliDqOB0gyC1hFpUUkKCOdprr09iKC3t76r3SPE\n", - "+qJ2YicJe8Xku9Szdfh71B0Zdr1HZK6vRNSuOnSoR5LsDL/T/sf5L/z6JdChVnZkW+xEW0H4ihYo\n", - "0UAEQ8Ti0D7aT0SsVBKjrBlWK9dnAIJyx6P4nxCgGYDAHZciKBh3w+y79cdtIPlOL70N3/odYaf/\n", - "7V//pVjGnHwrQRh3h1szMzs793pugVI9ffGxmZl99Lf+p/jdn/wT/6mZmX347X8Uyz7sXphZmpst\n", - "zjW52ZF5tWRQrrahLpXusCl7gMPmUonVEF8VcuqpHF4W829KEeumxxkFOXXegyhLwrag34TE5xMk\n", - "9kSQNAqyShmQg0kDQAYQhWVOzhQJlUFWVmmdikQmJrSPIiJDnLsa1s/caH55VjohwKOlRgmooWTL\n", - "hJD3SdbktgmE7oszR0mvrsL42258rndY0PS8m80ex5152QGIxCwE4DfCuevhUzMzuz66+C6DEQS4\n", - "tHVEn/wcLfJ/UgbAzOwS434QkeJ6C5mGC//tAbIHXMNUQHZAEEs1O9I7Y3wmdOSJx0teQaBTlSAi\n", - "nuPTfz0gGImipoUICPMchVytYl5RGZQUn0zy6kWBWX3GMZ+gyung8wTMQimSIlnDGewjiDy8GaUG\n", - "agDZqyX/5AgpDiXbHzFndN7F2B0WyfUNa7cGjxGJX4mH5+x8i09fE2OOX1l3KFKqGhNN9b0xp4xI\n", - "ZcuWLVu2bNmy3dHyi1S2bNmyZcuWLdsd7d5ce9MwJLoXEZiXfF2RPC6wmqsoCxQefyvHxTKH+wjP\n", - "lcBd61a0Q0hiF9InuaPlCcK66ogQ5qwSLxrP55DxQMIe/n+Qc0x7KHHf+vVvQAoVL55tN+H6a8lr\n", - "VVUBUi2F2BgJgArZR5cePhN9IvpW5L7QFQr77vfBzXT90uH2Z88CefRs6zpGVLaehQBZocorIQD2\n", - "Y4DlO7g0E8Vy/K3u0W6Ca1OUeLfnoUXPNssAhO25t0m7RTt500VF3yKq3i+V5RNpJ0DAlSqWw42m\n", - "RHnwVK1Scano2hNtnwJ5AuHGq2u9GHI+jZKvEf3z7hs/EstuPgrutlbzH+ImVR2YbqFCGoC5Ax9d\n", - "BHXq3/rg1+N3F+//ipmZ/eRP/plY9rd/JmhLDZW7cdg+N+IyovaPukBr+GPUtReHFvWMpLHpZh4H\n", - "9a0y2EBoAWiTMsk2QL+YlOE3q7XXPeYOiy4IDSyBK0yV6GNevyXdQB2JFd2NmjsQXvtqKBdlbSvu\n", - "PurdUUdMrlDAjaJaPPQ9FxI8wmCbqtE1AWc6kWNUyc70RlY93bMSbIFJTBdfqHsY99utl1E9nC57\n", - "M7M1cnHWquMT+0I04ODufPR6GJPT8Vn87vrDoEul6yrXqWajgTrINbeVOYnAl/bCx38N1+L+1utJ\n", - "vSWyQtTtxKmT6A3ia6UscM2ckjUWQQmabaOia0ncbaBUcExWQphn7FBRqruV2lJST65Jsv7GHHpJ\n", - "nBe1ncS1howSSp9hG9NVqC57uvY0r2TUR1PNKLpAewlKiZkiZO1CAFB/QiuLCvTqdozK8lJG1+b5\n", - "hbuR6XpeyfirG+Z69d9SN6yUNmnqpNEWlhGpbNmyZcuWLVu2O9r9kc2n2bOrmzkRUvOa8S094Uby\n", - "3U+VZckA1V0qd8RyCewiSMRN9ILxFtwIOZG7ikpRmoKKvarAvAyenpHCWyUWBgvbma4gmU52MEA4\n", - "+r3szBDCXEho7oQQ5+7gZZRJKAWlYU4mlYRgPC2zn2v+IBKgC6lvCVilELI9SX4vbm79Wk+emJnZ\n", - "Gw9f90tNlB8QdVzc7yw5sYiicQd9PDqJve8D0pVkdcf1NUz+7MEZruk7nc1ZqHuzkXyGG7SxIjwY\n", - "XMydN6g6NbPPq7IwkRbZEZOoWMoutag2OE7yWoGMrwEQYxXq0pfYrSqJEu11PjuCssFuaiX5sqKc\n", - "hmhiNFH2wM9H4uU8LAMwiPoWtZ/j27/4t83M7Ef+0J+OZV/5Kz9oZma/3Em+NCAIjchf9FXo9yR4\n", - "g4iZyhnEXTJJ5zL+iZzoGD6RV68oTyxjzBcmZNc1dqRvvP6a1Cn89snH4X5ublyJO5JdE6RruSMm\n", - "YqO7b27hSwnoiFIcSiwn6ia733pKCbCzZlYgYp9skEn2FwQBO+jVVtA05B8bZZweIG2iU7xHeDqR\n", - "kLOtE8vrljnMFJEkWiA14nhKSPFYYytHhDYNAlB0LaTKPUjhFw/8+HIfZBf6nRDQB8o6+L1umGtO\n", - "gk1aoPiVPBRa5GIral8TqlVYgwastbMgLaylyjpUkHNp1SNQEJFRrILEflljmL3h3NuzwW9WR+Zw\n", - "ldD8qDQg6A9up0zUxvmHIux8xmpPAeE9Lp+7nVwj5ufD3C1Uagjzvz+IhAdU0QsNKItBFksF+F6n\n", - "OPux1nvE8yRmB9DMIrwTb+vNWUAiN1tpVyCSKvHDeZJkWSESvF+i3r+dZUQqW7Zs2bJly5btjpZf\n", - "pLJly5YtW7Zs2e5o96dsPk8JYh+RukrcI9Ri0eTCdA8luheA50RZldoaSgov59RVIAiz1YBYG3GP\n", - "lYD9alsSzVKifHCHKPxHaLcQuDW6OaJKrEOMJIw34jLc70LZUWDXESTXQbRFZriFVMeKhF4lG5I0\n", - "T9Kpkp7p0ZuVnAz4OnUt0LXoLrgXLwLZ+eNPn8Sy119/Mxw+iYoyPEorgVuZaHkEoVzP2/cn9ESg\n", - "sXN+JVpI6xb3J2TTNRKUigtsrqnsLmTb2GZFcn4z1RgRiBfjadAghqi7IomMZ7b/copVQhQl3ExX\n", - "3Sjtxetv5b7WSDT9cONZXncfBRXzTULAhWtFFIipHqzjlC6aDppda3EtNkiq/UJ0pP74N/5DMzP7\n", - "r3/2L8SyPeZRIcltOe7WogvW1kz4upxPkQctqsd9Rz0lcaPzD9Vsoo6TFqL9G9GRubwKbqHtmY+/\n", - "cxCkL7ZhPD156mP4kyeB5Nzr+oOqJ96RKHKj2mZLbZ84x9zbbdOKxGZfjMYKQSbxh348p/Ms+kRs\n", - "H3VZMRjl/NLnydiHsTPs/bfXTXCR3b7wcReTO6NKmllhuw1udA3AIYl60CwKTPwqSdAP0IMqxLW7\n", - "hvZTrwEIeCy1D9F3ByHCvwAtoXcp9qlDIlvxD3HetStNkA26hayT1C0jOdvMrNmFOu12wd03ShAH\n", - "KRDJGEbHKmHck2WrGwuf0nYNg1c04Tfav0QfnlVLKoQOQLrD1d3FdbUXRe4ezwzVsYtuMVmTqAel\n", - "fUzP8wS9L3XZTT3XcHFZM1OI0C16PEeKJKCJbmGhr7BOyTKR6lfpM5nPs3OZ11toRam2GAMQCulr\n", - "agAmpHg0j9ICeqVDnLCMSGXLli1btmzZst3R7k/+YCoiwdhMUo0pSlLE1+VYFlW2e3/TjMK7SU4k\n", - "vMHWunVNPqxqRAkVO6JWVZeBYBSy0+NOs9Iw6Rjq7JcaUfdqEsVcoG0NEKyyEtVbbP8mkV8gEnIQ\n", - "Eh93cMqv3QHF6XZLEuFKdlMkEg8T0S9/Mx+AhDTmO2NyoutEbZqv64IcgPj+wdOPYtkbrwUphKPm\n", - "v4tkaNlhWtixdn2He5WdJkiWGn7coC82Euq8wk6zETSTxMtayNPdHHbEMpxieqhIxBSkMZJ9hRwc\n", - "OZyygxoxjWRDFsNldUyQvF4K6sU8WXXD/Foy/hAOsRFy/lkRdl0PV4/9+kUgSs8aVoyw71nIpi3Q\n", - "oec7DxSYoV7NMf7suYear9/4ATMze/JP/kEs+4M/8R+Zmdl/93P/TSz7LaCJhXnfEQlar2RHGLnb\n", - "gjBFMm4aCGFmNvVUFpdGnJch3BGJUpAA93q2dUTm/DKgKUqUXmOXerYhEdnPsUPo/vMn3iacVwn1\n", - "FDviWeVXIjqlaAZKVFn8iOAVUcmYsGOO+dKk/6codaBke+QplN33qg79fynI5aYJc3IQ5P76kzAW\n", - "vl06Ejcg/HsDkncrO/2rCxDPZRIRHVf0qcfft7c+1nb4u++9rIw5KeV8QIw4d6+uPK/f8Rr33Xm+\n", - "vhGI1LjzOTkMRDA0JxtQQgkzYlDOthLvQM3Ai/B52DtadzgElGqSNixPKOsTTlH0i8hJW3t7VhMD\n", - "FXyMt7w+A5skOSPR9KoQdwrarhWpC0qG7I9Oon/xHAR9cRIcse6u1z5P+DBOMgpgbWHbTeoRmRkc\n", - "IM9frI+tyKQwiKCQABQG6GgGCKr2Tyrdw+c5JWmktS9R9+2Zt9PFFfLqSZpGeidU7b3ChNfAN5Ld\n", - "Z0Gkpinp3YVlRCpbtmzZsmXLlu2Oll+ksmXLli1btmzZ7mj3RzYvRvUORThNFVsJ6auycISUVR0W\n", - "TLhJtWWodlqI+wynrqkcLGgdvytFnpzus0TZmvowJwizSmKjCyqBR6NrMdzDkJAIQWLuRDMJUPSj\n", - "S9dxoT6QQuEXOPHuxl0rz18E6HsvcHcN/SrCzkqfi+R40UchYVkl28uGquiacTl8HA+u7XKLpKWt\n", - "tAn1oCbpE8ood1BM73qF55H4UvyYNVx6640oFuPrplFtJ/SxqNdbx+SymsgT7c7Er0IEpmZUKe5e\n", - "KlpPg5f1JNmKsvrQUwFYCOhw6ZXqgiwJN8MVKZB9ib44u3TF6C+MXwnXvBYlZo51ceMalbcFkn5x\n", - "G8bEw0dvxbLrZ8EtuMKYaFcOxb+8DUljX3/dx9/LXwtuvn/zR/6NWPYzf++vmpnZrbpgC7pbvUqR\n", - "ky3HMWikB1G4E1LnjLHWKhGWhHYlu45LUnpRhvY5u3C1/YtNcAGsZUxSP2xFPSGZVw+eB7fYTe1u\n", - "pO5AsqsknsV41nESCdtKNqZmmspoTUsdGy44BdT5NWk31x91LTUoayt3z1xcBa2sBxfed5v6Asf7\n", - "GOvOQt03Z/7bpy+Cm291Hs579eCRXwvHqWYaMyb0e3cj3dyGv188u45lz56H8XQcfJ3YrkIbK3ug\n", - "wZjouF6Ie/oM834vrqj+ABL1tfusGsyPYu26YOdVGAtTKcRmzN1W1g6u9xXmUCUq9mXH7BCqMcQf\n", - "+j1El55SBeDGq1VvkNk2JNtAi7/j+qPrVRyfSbSDmaXkaGr2rVZ+3kePwm9vb/05YbulpuAMgvis\n", - "Lnio8R+wQM7i2uuh/adrYoVnzdh4/zdwPa5auVcmV9a1i97bhADOSA1onGnSauhCnZ+7C/gCf282\n", - "vnby+aABIP5o8RMeQaXRhNtV/b0xp4xIZcuWLVu2bNmy3dHuj2w+z68wRrFbV0kEoiOjvv2Ht88i\n", - "IYcF0zfNOaIfiWRq+MBPFemKMglSAVeZVnXY5b3E3aQyi6P8gb6lh/PEl2954yf/WN9sV9h9tY3v\n", - "vohINUKirqFY3D/s5bcBafjkw09j2RFEyWIkwU5IfyDla74kkvMm5YuXJPtJPbHDKEUeed+FneDm\n", - "7EEsm0uE5ErodgfUiTuiQRApT5e2lJDQcGXmTFS1aQYlKMLQAXXS++Y4GUF6rqSvGVassgpEUyYh\n", - "0fdg5U9CSq8h8aBtQtK+EiULogNok6L2XTXb9Sgqzm98AarcvyC7b6AquiMlUVKHP/NKSZS6TZQY\n", - "wdxRuZALkDc/eeJj6OwsXP8n/+C/F8v+h5//X8J3QorlPErkN+LoXgZqkIivORSdgC1lxh20oKTs\n", - "H7nXISKNfrMMhW9FEqFZAyVAG7ZXPq8evR52tU+fu4r7MITdfCodAvRRdq3FSKK82pIUT2QjIaBj\n", - "XRqx7qmswRylUySHIYMSBKUlQfvh1SMpexiOH/3+b14G4nfhQKRtLqDyj/l6ceE7fa6xoywKHdCJ\n", - "Y6fE5hc4vxP1jwgkuT06wse4+s3Gc6Ix/pyzaZJ1/Yi51iVi9+H+e5FJePkUgSWSAaFdBTRlJbo3\n", - "7RrPE1nYawy8pkEexpWSuMPfhzl5UIV6KCJEBXxB+Kl2r1gSf6M5KWO2BdQzyaFXEelWIjY/l0rc\n", - "84msHOcXjtIMGJO7naNUzIahBHg+2gZkheiOEmyDoBBVCFgDnW0UfaYkj8q5IP/ixbmPUwZ59abS\n", - "GWHMnEp2ssYzcSNBJMznyv418ywGda3rOdBUyQnJYKx+8DVWAylOWUaksmXLli1btmzZ7mj5RSpb\n", - "tmzZsmXLlu2Odm+uvaJItRnqeUm6nF75NHNIc1IvWnGCgAdXwShEQXiRrG6oEyGK4YAxhdfpLsMi\n", - "AWNxfSFlR2Vr1WUak+PNXHmcRFV1RdIVUlUKRdMV4a69NcqUWN1AIX2Qe6UEspI4P/3ouZmZ7W6W\n", - "CSUrQMbC63TXmiRUpVC2apZs4cZanXnZvnuO84k+SUX1bncLUCGciTxnTdAZ3R1KtgVhXNXGUWd1\n", - "o7BPelHKPgKenUTHaYKbc5iK5HdmZnXR4BjVAoK7L/EYI8mnwN1V4W4OL0Oggqidsy5ThNN1DEHj\n", - "SFw7N09D2z0UYmc3kYAppHy68aStmSz59vpFLDu7eIQ64VwHJ4deXwf3bC3n/e53f9XMzH74i1+N\n", - "Zb/3C18zM7O/+ct/N5YxQKAUt6wHDai7G+M+TiJxxWGeHjUAIgabCBEWY6iUNmGyWJKezTwxbi1w\n", - "/xrK4hVc5aosz3H95udcs2uag1ba0Os4XdxWdFkNou1l0Eya1LWLuvcSZFKDeF83J/a5MWmzuOXp\n", - "ChI31gr3+OCBJ2g+fxjcZ61oxdXQnipEx6pck+we/n8pWlwt1slGkjGPIBs//9RdoNe3Yexcv3ge\n", - "y3Yo24uOFDMZ9EJebmu6u7FeiHt8ohK1zr+JGTD8/m+fH3F/omL/EO7WQX+LZ4H0HfWmuF5pMmAu\n", - "SZpkecC6ksREof8rHRN4uOiyT1d1pesZxsTAhN5KWeBYlwagmzeJV+DxcnneRyGBAufnDLIQt+gt\n", - "XGtCs1gE5eizBo3SStL0Kkm+Hqwuwzhate7G3a6D23gtQS6kNOgaX1w8RDVAo9BgM4wPJdavkO2i\n", - "WauKOaqr2SswP1Wzikr9SdmQXXvZsmXLli1btmzfF7s3RMrmVEDA0SfNtQdUJSGW9/jUvEYkBUtZ\n", - "JNtJWc8cUnjj1Ldq7FLGRt70SfaUVjqRQsn4PjqO/aJMdwncfbBGjZDeRqiy6y6UpMezMycHrtvw\n", - "5r7e+C6xxqv2oDstvM1rmDRDWK0Iu0Sq9JqZFQ2J0MscRtMkMBXPl0hHhN+cbb2eBqL6ofcdfosd\n", - "HpWTzcw6IEYkOUt1I9mWqudmrkDfy81G4rmQ2K3ocC3ZVWDXOw+yw7QU4dB4gSrusGRMjsxX6P1E\n", - "8nLX+fX7bpmvqgEpWHPtDSBXz0A4NDR9vw/3eGXeru+89raZme3qD6VOS8V4ju1ElR/3dhBS8Ar3\n", - "RvkJJWd2OE7R1zV2tfvv/los+1N/5KfMzOzv/V8/73W6QE422f0S4dA8ldz0FeibQrINEParpciR\n", - "Q9nB4xxTEhQCZee9E/VfQv7hzUcuiUACagy20MAKIAgrUdG/ehx20DtRuyZgrWsXkfBK8g9yrA3C\n", - "lCYpuUrWuHR/q7vvGv2ZgOQl87/J2oE2Xj9wlOASiFRCIq4wtgSm6UAyPwcysB38vh6BWH/zwtuV\n", - "63QtKF2PEPvDtcsP7JFr7yDyB0TxRxkT5+sQoMKsEP3RidD9RKTd+2SAVPck6B+DR148c/Tr8jr0\n", - "e9X6elLsR5zDxz3BfsqVqKxIzGFZJgu7foTv+ewSqI/yHKPm+ozsaenjIn12KTIUc+NJf3EMJzI9\n", - "VK45gZxrYYm1fSvPE5LNi8Lb/YD1YQbqO8u4toE5TAWRR04+E0SoxbPrfOvzb70KY1LRdFa+kbLN\n", - "9pwVNjOzfpIMGEhe2Whe2zXXWpFkKSkdovkHoYovTPk4juRhVFffG3PKiFS2bNmyZcuWLdsdLb9I\n", - "ZcuWLVu2bNmy3dHuz7VnsyVJhulSEsZe9IqoPoZRxXhZ9Ukg6Ei30wS1PYmdcCcJFjsQgR30+vQ7\n", - "+HF0S6h7whMeym9PaCDRLUj3WSO6M7zDWRWLmUhZiOWXD0AYbdzdU8O1NYxJRUPdBILtjgGyPPYB\n", - "Wq9WQhiNCYLdXFney0jKH4XY2dbQAjlzyJZ5OZUoSe0lhaqPUCWOLrhZ65smNDZzzRiFgo8HkOcL\n", - "d7fMcO0lfEm4Cga9yZi0F8lT1T1M12avriiSopWAjnsWtxxvQ4MnOhC/C9VAgpuxaHldTWga/n7n\n", - "rS/6ve7CfZXiWpigxFsL2TJyt205xh488H4q4dLdQ4PncO2ukMePAsFzJ0mOOXe+/Uu/FMt++F/6\n", - "M2Zmdqb+XihWz6W7ceiXGJUoSzcH1cHFtR3J4dJfY3HCt+4pA5Ym4+njZ0Gx+/133vDrwy84g+w9\n", - "CTm/aOF2W/k51tBYarbS1zPV/r1fh5m6aOJugmv9uFcNJtAMRO3eXakIAElUtJdJm6n6PIoLlsTb\n", - "WrSl1tDZGUW+nz+5rXzuvIO+e3gMv/3B7cP43Qbz6SDurh7z9FclufoTBF58uvPghZmBQr26FvHZ\n", - "i7u5Ceeju+UoZHPqknWaNBwL1KABCLjF+dbr9PyjEGSxvfTggT2yQbSayTwGA9HFJvpwNV3BQvbH\n", - "WlhKPzHxbjlrsAVcSzL+e/Rd17urqoB+0YSAFXU3U+28kXndIDH4Zi1BBBXrrq59BmoJLYKfrZ9v\n", - "M5JSnTkAACAASURBVJLsL2sXXNkj6REaRIH1cRRqRc+MDYMERUEXqxLRsgIuQKWU0B3ailZipF7E\n", - "5MXisqsZgCXZBpaSbdGllwQq4D+j9B2fhVOStPjU4uKWEals2bJly5YtW7Y72v0hUsWYKDxzV5eE\n", - "BoPYOKs6KsN/zd+Io0zBiS2pEjWHHmgGfloNfvsVdoaam41SCKpYO+JNW15g49/p/WBHICTCcmZe\n", - "JYTLy06HpEvd/TB3Vy27hTVCkc/OXG2YkgkaQs236t3adzpb5MnaHhh+6t/N3Mwo+lfwzVxVX7kj\n", - "kN1PCRVvGU4b5MJqhLw/zWGHNcjuk6TsnvmNREJgOIAIqCrS6OJBdv9R5b7QENVQduwUJcA1pT9L\n", - "UESp6F4KsZ7k3fGo/QpEUpFOm5Lvwm95nKjXlyRAKnK0wnHYrU2OND58EJCBj587qvNFICGjkOgb\n", - "KN/rTrepmWtS5hPQzlshYK9Amq/X4borIUy/vA5ogqaZYrs3Z96GL3/p75uZ2R/71//dWPZXfzkQ\n", - "z/uVEOsH7qYldx53f1TsFnJ8jfpKbIDHEyix9kT+Ocok1IKcHEFa/uDpb8Wyt8qQi44In0qdlPjt\n", - "5lLQpxrh0ooIYP7NSiKeqIDv9dxjV9+pJAfG+/7oyA2Fx4ngKKrL8V+eWBOnBLkPNogiM3+hyOkV\n", - "ENaHg6M0b2Mx2AJ96Z/5fK2AelwNUikg0mPp6tT/ePeLZmb2WORPnu4hEyDzZIAXYTg46nnDeTKF\n", - "ayVSEx3Qd0E/jmhkDbaJQSF7b+tPvxtU1i9fl7XzjFIHEngD5NpaojoqYQFiv+Zro/yA5oajTIGg\n", - "aRbztFbL386KpoTr9pQakGcYA1r20iblIdRld/BznCFAYtVIXkU2kDxjGhDAlYDdtgxUEgX4OvTj\n", - "YUbwgHg/iMSOvY+JDvc977xdd7tw/bOt5H+tgCZp3llC0IoCMbgHk6EXVH+FYCtF7pgp4SjjhF6k\n", - "WdsT8++wU2J9mKdDIsWzlHNQy4hUtmzZsmXLli3bHe1+OVInEKni1LudOjXjb1Q5c8mvslekBkIR\n", - "ffTYwUoYLHkIvYQmM3SykLfRAjvSMvGpl0nN9H5SKgfeuuP5ysXxmhuOh9XCZSJfql1LvjCEKdeC\n", - "pu0gdKe8mRo+5BbHJ9nCx6XvmRuCQSCBCmHCq/VWfkulM8m1NjInoslxDDGXfsffPflbB++THn74\n", - "QX36DeskHAVKPUhjc3M4yRAvHc7y43CTA1CC6SC7JbS1cjrIkUjyWpXc6UidcK1a+G2UaSiE39Wu\n", - "gNy1AX1alc4fmLvQxg83Lqo4dmHn3o9+3hlCm6Z5/WJOShHJK8NOfBA+xg5h6utzhLV3wtXA+Y57\n", - "31U+fi3U5ebonJrzDz8wM7Of+NE/Esv+t1/930PdSh8TE7kvo/92oHApaU6K0nJOyk6T/dUp+sS5\n", - "I2N3tQGqIYgod98vdiJIug/3vY4512S3jn7aiKgjB/QgA7vFoCxL4YOgr0eBSa7GgH4dZIzd3IT+\n", - "XHc+xw7I53c05qQTpAtr3CRlRPEUuZjAZRn2Pp9e3gQ04WzwNeGdp+HeNk80r1lALD+CXITu4Il6\n", - "TSL18u4775qZ2XtvfM7LngYe3vObJ7GMAsQ6nwqieTKfDhifBa7RCadsOCD/pKwhRCJGRWnoERBE\n", - "kJ6Na0F4rzAmVBCUAqA1ARzlXk1cw1QnA9dU9PkE55ffuzCtP2NKkR0pgL6UWAsPsibW5FzJWGd7\n", - "jTInDXykWnhTTQP0WybUNCznTgWOUiXo9ArjmWjyQeU/IhLlx/fwGM23jki+eHqDc7kgZ43nSS1I\n", - "cFWyTuJh4TpWLp+/fHbPMicpdTP28jzHWFOOWHeETMpO8r/Ci3E4yv0o2faEZUQqW7Zs2bJly5bt\n", - "jpZfpLJly5YtW7Zs2e5o9+jaS4nhDi0KORkQnJITT4V1j4nrLz2f5pOL6un4YxB4tgcE2FbiMhmY\n", - "h8evxRxXmuuPecKSWuC44lQZxcHVPYFfq6oxXVWafy8Sv1XZlu4mIUqTZFtLSCiPoyqwKmxHIrQq\n", - "YUPNteuFCIk6na3P/bcFCdsiCQDkdxRS5gQXYX8QWJ5h57gdzVcXZSpklBKy1fuPYa+Jsj2uKdA+\n", - "c+ZpO7HfSSgXXn3sOx1rdAEo2ZSqxEn+J5G9iIcVzKslLgCMt3UTXAy1uvZw/OW5SF18inBphbYB\n", - "1aurtgDxvpUIYrrqVBW/rKmeH+D2Q+eNzbyWoyrw4/5bce3ewD34tozTd87fMjOz75qTqF+C7K0B\n", - "FdFVhP5KcmMiAGDspb/2J9ziqGcrN8sMAcLrj0rVkyjQU/mcEiaNkNOprK55LdlOvdISTsiE1HCf\n", - "t5JDjG77c7nHGnVuDn6P6z64O17u6LLQscZgG/VZcbB7/x+RG0xJucWnoT3ffCZE+Y8/NjOzT0Xt\n", - "vhi4doY61bImdl2Y2JUQpr/zQXDtvt/6mPjqa18xM7NffPYbUifSN/y3McdmmjzPzMxKRPsUtayT\n", - "/KloYnDeKWE7Bh4oVQFNcXvtY/Lhm6Gte1G2LnBuz2KhcxljSOkeJJGfkE4pZPGqW1IrNNcjXcoy\n", - "xzA+mk0YQytxo93CFdxJf63hvtPAJib5myR35cUFggKOogqPOaaEfj6LlL3CtYPPk/XKx8SBwRM6\n", - "AdDsvVAFdtfhuGv5bR1pET52BpDcV52s8Zvw2waZD+ZSgihi+4uKPDNljKfcc17PGAAiLnC63kd1\n", - "9x6zay9btmzZsmXLlu37YveISL2yC6HJDiLuIJPQQ2TG1ojU8hTZG+TphNAePgeQc2sRlRwh+jhJ\n", - "Yi/mxJJoYSfFqkrgiYzslGJIyNZEMYhIpTHci3sgKTwphXCh5jUaEa6ryJzviPytmm3CtEF1Izst\n", - "5rCS+4r59wS5OoLErtm6SU7UVINEpwa5xyN2Lt2tlCE8uT+SHCjEWuwSR810X5HEuxwT6baAec2U\n", - "qFsurhHF11B3iQK2ETsTRZC4w9HdJ8X8FISK4nsKXcbBo6HrFF3d4NOJmES9jkIOPd6AKCtzgn9q\n", - "WD3rN6r8AcoUTKO0B8Uvq9p3y/0BaI2AHzuIuWpisQ65Ew+/4bICP/YjP25mZt/8W/99LCPYc5Sd\n", - "3jAy2AA7yIPOP3xKCLvnSZR1gicWMU9GS9e6wkH0spJl78WLgE5ssFvdbGRNgPzKWel9wlyElWhC\n", - "MK9akusS7a7BHlwnBiGKX1yFAID1me+mb24DKXw2Cuj68Ydxl5zLTBAEJQxzXD33Sfk25tiFjKcO\n", - "/b+ufD6XqHOH62q+thZSLLOI5PK4Dz/4Tix7+KVAPN93TuyeOSZnnaiR0e1FmITlaolIMfGils2o\n", - "oMqaRH1TQdgr5mSVMuZMXAvqSHQ8gkmzojUMtVdfA+aVzJOakhxyGMeCIsJrBJtY8jhJ+/P8gaM1\n", - "Z/tw/IsXz2LZLZBefU5ugHqp6DSR81pyR9aQRzjeihQO83RK4EXM3Ye2KzX3XAnpILlZroWV5s4E\n", - "wngrIq183qgg6QbCsSsJslqfo2wTjm8kril21ImgNJUOiXn1RiWbd8l3ZmYDnjuDkPyH/TK4QC0j\n", - "UtmyZcuWLVu2bHe0/CKVLVu2bNmyZct2R7tX156aK5Yvy1LYk7mmlmRPO6HsqwrEJMxVJLgqmawm\n", - "PK8+Q8KYqliN86qyNsne4oKrSio1C3md2kbF0sVD95QWkWNfColwhlbNKH60Hi4oJZYOYE33o8CT\n", - "hnxJVCfX3IAVyeaCBZMcLW6MqgKMK9BuSbL36GXDEfC8+IBubgJBcncjrirod+xu4UaSPiHJW3Vc\n", - "BpDDa/FPzQxKUGI7XZtCFGWuwVIgaLr0yDVNyLm8ZkKiJOnRi+jaVNEa6sxU4lvq4FIpa1G2Zv5B\n", - "9Mm2cRfLBpB1Ke4uCmn1ogRNd6cq5a/RZpWQXeeWJFrRLNqFdn/ySdD7efTA1am7mbkBfaydnW9w\n", - "X46tP34cctf95recWPzVn/jD4fi//jOxbA/35U7GJDVb7EgleglEgLtPxLmjK3KWccVceKOS/WOw\n", - "wTJQ5KD0Aajsj1Bdrgt3uzBQZWhEbw5abZW0IV1LqoRMDaym9rFODTKd422LeSftaUUI5GDXPRf3\n", - "3AR3g/Z1g/yMm8pdkBW0fd5/6fV8HW3WTUKsxvpUyhzr0Y4bEKF1rVvB3d/JnGDO0KeHm1j2mkHH\n", - "SOgD1S1cK5q7bqS7z29/hgtoh6CASubrSGrDJEE0XLsSnzV1pKSeZ8ynKcdhHZ3UcwMXMTXo0vyb\n", - "/EvGGhMryHEjggE2jY8nutGq1ZKArmsH11aqfqtmWIt7WJ37PdxAlbsTHamWzyRdk3GeM1m8WNZu\n", - "ZU14CZqFqIIXHqoV7rmS+2cGDnWj1tWibIY7VnNCPn/+Ap9Pve5wPV5eXcaySwvuzQ1oLKvR27AH\n", - "RUdz8/GZLZJ9nkVDXeVw7failTdRv1DI7v1R3YZLy4hUtmzZsmXLli3bHe1+lc2Lk6WLvxPcJiqA\n", - "L9Gc2U68NSahw0RimHJ8SfqdBJEasNMqZJdcE52RV1CGcNeC5hTzqZ0WVYlxioScToKfVn4Z1szM\n", - "8J2SsvGpufb2+0Do28sucQ/F4oHZxVWxnERdJbFSiVe5nthh7g5OIr28eoD7kvDrA97wJay1R5bw\n", - "vbz9U9Gct9gnYbjMuSTEajTQIDsitqgiZ6yKbMhcRV2uQTmDaeAOdtmulaJv1bKsH4hmeD2pyl43\n", - "SpQG+iTExm4fdpO3beins9WVV5i7eVFxZ1i3kthJ2NaM9DdHtLEQ5RuoCCtR/OphQKAuLsJ1R9ma\n", - "zwj5rSTX4+4Q6rs/ODmUisqfe+f1WFY8+8jMzH7fl/9ALPsff+Gvh3tOdoQIHkGuxWk4cV+a629a\n", - "zv9xPIG+QepC0RTmM5wSpXCgD+ivTtDCFQi7k6gjU66jkKAUIsKdoKkkwDeq3UHUQfO0Yeeuat+c\n", - "gjXUqR8KSji9QHDGrY+hLcZMI2Hl//IY5t0XGvktLrHfOZp5tglkd80KUAP1pDSHIuKMACAh2Mxs\n", - "jzFcytqxacL1SwkKmbjeakBHTPYgc4wID0W89QdR9kHmxAmAf0LhLEz5mkiQSFwwaEiReP4d1z95\n", - "AnUnFM25TpXC7OY6qesE5UkUuZpLSncIwsYbLzmupb7MtiHq4BV+O02OfnHc96LOzaCIUp57W+Ru\n", - "3UuuuakK81mVwldou/4sjLt59iCKYVrOUz4nGw1owveaJ5X11Hy2E/q4G/w5cTi8mjtTJFQ4AFaS\n", - "2aFlBgq/PK+VeKIocSTj/4j5fBRJBJVHOGUZkcqWLVu2bNmyZbuj5RepbNmyZcuWLVu2O9q9ufbm\n", - "YkwI4/xTYc8I+wk8RwVuTaTJ70+59krRwogK6RXPK7AzrjUKPEtXTDEJszjWX4jl8wm3EN146heb\n", - "ScojdLs4bZKMkXUa5F6PUIotRLKZZHtNbnnogmvv2DuMT62OA9wyrRAhqQqctCDbVbnOJd1jkngW\n", - "hGnV2mCyWCUWMtHpoDpCaOOo56SKwayGajEVdNlIPasTLgPWXTRDiMrP4qpZuPSm5RhSMTC6D1sd\n", - "J0xkqkJa+HoUzR6Op0qg9QFsyN11cJXuK9dYadahTqvxodcX96P6NHSzKor+1lshufDzp5/GMrpe\n", - "6q2P5z367LXX3+BB8bs2Jq31ezjsgsZRv/d6rlbBtTsIKf7Zh0FT6A/+/n8nlv2NX/g7Zmb2ya2P\n", - "namj+wKuosldxhW00sZECZ7+HpWsR2OIH30cmIRbldrhFtb+R59RF6me/FpnW7hPxLU60BUt56DO\n", - "0050vMY5uCWmc2nPTWj3eiXE8jiQZe3AnyRZV5Uff7YJbjwlTF9Be+y96UEs+9rD3xHOKsOZyW0v\n", - "ztx93IFQuznzTAWsUhnXWnGPRW07HxOrNqwja3NXzEUdXIatiPANzJ4gASB01ZKcHOqc0hymRG+P\n", - "gkaagWF8pUZmM3Xx1GUHN/tmK0moqWKuek8cb1xDlJtO95CsSQ2DklQJ3MrFcfxtL0nTKwQvtJUk\n", - "l4fafUzyLAsw9d5WK6dMVJj44yzzCuO5FWJ77FfxUlGrbl14m9zuwzOjXKkuIdrusl6ct2pYTwmA\n", - "aDh21QWP42Weko5SmYo1BlP19mGA+xLJ2FXvj+Np0mAzBoqICJ63vwRvTMsy/jkIwXw46ANnaRmR\n", - "ypYtW7Zs2bJlu6PdGyJVFkXcyZtJvjpVkS2XSMN8KjcTj5ddGnefyWEUFmdovEr2RkBCypDjq698\n", - "rzNNVLHWUHu8VWtIPt7ONUyfJPeoNq07kyjOKm/VICLuj04E5AZvFhldhjofDoISMddWJ7sUSCIw\n", - "vHiUMPQxqumKwjHbS/NVxXBl/+2zFyF0frv1XRI3J4WQh/mbwyDXBTpFxXBFsMhxVWX1+OqfCCGD\n", - "gD3qDop/qCo5PiWs9VXBjERFnyTWJK8W7l+2RBV2taUo8RYlUSpV8R5Rt+UOm5IEHyuJeh9Qpcu3\n", - "3vXjISGhKCWV17ved3CffhqUj3/g/S/Est/49V82M7OV7JLX5wHt+uTjgCBdvfZG/O6td98zM7Pr\n", - "ly9jGdHUQ6L2Hs739NrRzy88DHVfXXuww9fe/xEzM/sHv/k/x7ILKDvvQfLeiAwAQ7N1/FFQWqcp\n", - "FaCLhG0MSQRBiQYgsZ2Mv2rguCNc+SJ+9+j1gPAUK0FLMMZGDRgASnV97XPtyfOQw+7Rax7CvUbu\n", - "tO2FI8HnZ2HOrIQozoFKAqxKstQYlI/XjlI+RBDBT7zzNT8F8lkOkuushWRAX/r51hvMWYFdaqBD\n", - "RCtmDVjAeJ0FuRvBDl8V3ndEvTetI112eG5maY7PuJ5Lpgb2I+d1sttnNQU5LeNjTNbEaYlcVisQ\n", - "6xv5bVTsFuSSiRIw1pXqzmcHCfnhHmxhcUyqRwJ574ZJ1uk+nKcTjQ+iODW8DqXkS43yH7L+l3ye\n", - "yLpS1WGMjUI2p5dEG7TA+bSaXMe1TscprC1Fwet7f23Qnyqnw8APdSY0GNeDqMJHB5QCPhinhQR+\n", - "+HsB5BokswblN9SbE3PtSv69kc8/8RxEsnkvz24i0JO2+/d+VcqIVLZs2bJly5Yt2x0tv0hly5Yt\n", - "W7Zs2bLd0e7NtTfNU5LQNyYXVtVh+IfGxGVX8g+32b9dlElRVCXnd0kySsC46h7CLwrVrIAboxBo\n", - "u8Tfs+j48BqTJNes432gTNjBUWJGE3TO1NNwKLg6kOwokDUItZ248eiqUBmbFiTGrgGJ96hKzAH2\n", - "HIUISpfWrLonaLNZXFb7482i7lT2nUSDhtDqIAlPe/wdSdk6JgCnKrHQ9bZExwltkfTdSFV00SeZ\n", - "lxB41CWL0Q4mNi3KWBfVACMunSQtxn1PQtTuOibNlF/ib5IuFYrfbIKrZP0578Qdie3isqTezyAB\n", - "ANRA+eSTj2PZg0cgoD9399W8D313dRVcRepu/+Db3w73pdEGcAcXQo69vglunNc+9ziWfQyl9M/B\n", - "nWJm9ju/8jvNzOzy5/9aLKvrANHvDqFOqjtTQ4toPLjLsowuU3U3L8dOVKzXDAQzXQDiMojJmlN3\n", - "kpkTsRXip1cgyYBAzTJxGT/5KNx/L3W/OA/38/K5993Vg+D6u7x0FyB9RR3cUqUETGwRIHImrqUf\n", - "vwrE8vPRXev7PvRrIYOyRrLcRl2g6EfVUWpjNgYQcSU4JLaTuEJakOeLvbt2X74Ibjwl5W+RGLkr\n", - "/H64PEzibiQBPbrHEh03lIk+GzW9KtGH4jImzWQ1ElIXctxmDRdYsk6AZE/KgKlBz6hWVyzOr2zz\n", - "mcra3q4N/ta1c+xCm+xnccFCqX8NpfpanisxiEbacIJrbZSgKAZFlK2SzUmsFmoD1k4lZdPPV2sS\n", - "8DXcwnDx6WOqQVvo2uGJn+XZgTEza6ACXG+T6I2VxsTgWqcp+W0hz5WyXGYWmfj800WZbmnTABQ8\n", - "Y0WD8Yi2299IBop9OgpetYxIZcuWLVu2bNmy3dHuj2xelqmKNhABVbGlYmoKPgFBkB25v4kKIlGQ\n", - "qKjq4SAF1yTdLY9PyN54Wy+VbI2dhor9kqCsb+Sen29JQCcBTnfGDOfVcF3eq6pN9wN3zrJLByI1\n", - "6a4i5vry8222UGrGOfZCeiTANQoRN6I5SZ1wD7W0CXaQtztHOqhOOwkpn8RGJTHGOrPpBOkjciSn\n", - "iOjDfAKl0tsfqBR9AvVM+ORNZKXbqz8g6FQmOfxiwkQ/Drs1k101v01yHbLvZIc/gSBedFTR9/M+\n", - "Ain5XELId9hi6/gnmjcp2RRq5MylZ2a2qgMiVbce/v7gUVC+7hAU8PLJR/G7tg275fUJREDV4dll\n", - "+52T0i/W4beFoKlffO9LZmb2o5//Siz7O9/6FTNzknkvQQzMF9bLrrIHiqrBHuxrzY11BMm8bZwA\n", - "vd5SsdrPN46hfQgwTDL+jt0tzq8SFkt27Lgcatagfw4vHKWZoJgsigx23KH/Zy9sgcodMMivpF8f\n", - "YA7/vofvxbLPtQH1uxbFcsqj1ImcCs4v+R85ZhpNHglEhm2sit0c2ZqSswPxvlEEA2P8/NwRyQ2D\n", - "YQSRZt7LufT1LK7BVCGQdaqsiaDJutou1/MJkgjbcyf222pY3E8kKKs3oeRzB4R9UTWJchoagEJS\n", - "vjwnVhh3KpNCr8csQUb7YwgK6eV8lOnZcJ7KGF5hLs6NrwlUxx+ERH2AjIgG7/SUE1CZHq5JglL1\n", - "BlK2rGcl1skSx6v8AZXoNVPGCDQ1eZ6UDKyRfuJCXiyf04r6rc+wPjLYRN0UrFu5fCZpUA7fJyT+\n", - "yeAkSBDWGFCl2SPSlCMLy4hUtmzZsmXLli3bHS2/SGXLli1btmzZst3R7jVpsaqDJ74aGLWlNKEg\n", - "Ud9RlYABBabgG+FWdd+lKrbzieMLTYaJa6iKdiQlL+WGIsHNzOVLlBTbwN1CWHTdKnQZysSLElVs\n", - "lTA6gpQ3CIm5VlIerIQuSivXIDpJt4ySSKeOejpCGJ/jTSzOP0v7k9CnxOp+poq5KpUvAwri35EI\n", - "KBAr+0LItjOynCaaQcxMrPxfuBtKUzcGYeRX1aPMyoZ6NuLGQieqsrfBHTtq4lkGJcgY7iuOHQ2U\n", - "wPeD90l/xG8RADBJluXtKsD3e1ERPyJBcKFzIkrmnBBNq/xaL26C6+fNt96JZc9eBnfs+UXQTPoc\n", - "FNHNzA641rp1N8KTTz8xM7NNK76dOVzj+TOv5/mbgSi7v3V30wqaRn/46z8Wy375k98ws8hhT5O8\n", - "FqFNVpMQoeHavD2IFkxPDTBJOAw3QiP1vICrtFm7u2EPV2EJd5eSoyPpe/JrzdGNL3pfuO4oZH9S\n", - "lNWNMO74vf/2cKR+lrtFWyQE7pE89nJ299Qf+sEfMjOzt0t397zcBzeOuvbpvlN9pMi8ljFRRl0o\n", - "UeqmUjbmXV2pezBcQ519dAvOk4+TFq63tnYCfF1y3RMSL9xBnSYtxkRmT4x6NczFUeZJXLLE3Vdu\n", - "cP0rGTvQAyslUOKIa6m2VXTVwcU2yvpDBfBa2pUBNbWsSet1aJNmLSr2XH/F3T1CsXslbqz5GMpu\n", - "r4MrrhEV8wI+1Vrcs1GrSta1ulnqONXon0EZIFjjqtHbZIV1bGxE28uoM0gtPA1AAjldE/8ate38\n", - "vAws0mcCm3YlUVExaEAzn2Adb3Bfldz/gPlZSFAItdA02wGpJbNqG+IZKKLs1rN+4m5s1Jd9wjIi\n", - "lS1btmzZsmXLdke7v1x7ryBQfCHUt3rukpaB5vbK2yp3VSeuo8hVkRLblJzG7UKSaq1Idyavntnr\n", - "SaK6oDQgL+r5KA/AHUQjaBEVjlsJV6VSuYZaT6fuEWVKzmM4cym7SaI47Ro7Pgk5PUCaQBVm+TKf\n", - "hHpHDr30E9XJRQGebZ20XNxoiCr3K2/604n/FbL7n7lzFbZ/DGs3LcM9aIPN6a7KzKwCkbsoKYPg\n", - "h0fFYCW2MlxXQ20Zpl5IDifev+xqItoi42kEebMH+rPf+251hfvSnFMxh1ci7b1U9mUI+UbQh3Ub\n", - "UKKbWw+1fu/9HwzXB3nz9saREZ6PyJSZ2cVlIA/vbzywYIVd4iy72t0+XOPqysnGu5eBWPveD3w5\n", - "lv0rrwfS9P/6LMg0VKpEjNxh7fosll0jn+RRdpUD5lUrYe1nTUAOmo2fb3MOEu/G67m5CPU7YuAf\n", - "hbBtVOLvXZ196rnTVUSKCO9SfkSV9QvMz5V5nXZo25tPhah/Hs73vA8SCn/y6/9W/O7tMiiFDzIm\n", - "qCxfJ5LVuLzMQJLsVytHuIhwttImA9adqiSqqqHmWFf8SpFQfZDcZETVPjo4SlkBnSmVbAxCs6ap\n", - "tCH8hvIrisgbFNBVfoSEYg1AWJ2HNl5fOSLEcP5So1cop1DKPWJNOh6Rf1HQJ+bJbKROa9xXU3sb\n", - "RpROCPg9UPJKNBlqSJzoGlsAzadi/lHlP4rwnCiSrCD4lLW0xnNEAyWiFINIjDBmpJV6RoK4BoOh\n", - "fYj0KHLeU4lf1r9hXAZgMcsAvQqhLNSvV6V2rCeKAlHigGtoXetCTSV+HZV4duvyj6bQtisxF6cT\n", - "OflGkZhYXwiyeMIyIpUtW7Zs2bJly3ZHyy9S2bJly5YtW7Zsd7T7I5vPdjLx8JRoS1EJdWkK7Y6E\n", - "EW3520p1VOwVuFEzNc50uymJ8YQ+1anKxGvKb+E2U2VX6n0UTQpTmjmhcyXuvg0g49tbdy10gGq1\n", - "HoSK1bVXLPl6NuD6NcmkjeOe1ICZZoU4cQ+CrJOgfqqf1C9I92V5gpQ9ywnJD45KtYnuDVwmfvl4\n", - "PwoZF1HbS+BunkMjBWIfS1HUjCHsLxo3TFqqyTDRZoUq9gIzrleSIPeEBtaAeqpmDCtKAmQhxNqq\n", - "p56KuwwOx2tW3M87LIn1TsoVZXW4nirpu2fPgrttDyX0afbWvr2lu8nHyfvvvW9mZt/59NNY9uhh\n", - "0LupxS39HC7C7bUTZSu4Ox6998VY9vgy6Fh9GfVU1XtqkJ0LxP/rw9Nwr2u//10RXB/Xo2gR6dpt\n", - "hQAAIABJREFUFeE8733OkzA/uf3AzMx+UHSsnu/CfTxHQl11hc2Ya+Ps5+26cI/l6HONrt1B2jWS\n", - "l08kzd6cuWtt9yy4QFfi7i1fBLfpT3zld5mZ2e99/f34naF/xs77adXCZZZo1vH6Mp6qpT4OXVCJ\n", - "+47tjXGqLiPq/qgbhW02ymJz/igEL6zP3SXy2jqMhWdHCUAoGTyTLFThg/6+SpXoWUc/nGvXLFJY\n", - "a5S1rZ+3AQG9bHVNxtohARV07VR0MQmJmaTo89aT5q5buva8X8eZgVI+ngu42TvVlsM81aAoPqf6\n", - "Lnwed97X6xU08ySwiarstarTo07qgj5Qo60SsnVBbT1xy03UO1RtJdIi8DtZVyfMk0Mnbjz4DOW0\n", - "MSikO7gLvAV5P2HPFNR79D5hnaMGWKJsvsxiMWI97SRTBNtzEFrA/haZNUZdz3Et1c9bqXt5aRmR\n", - "ypYtW7Zs2bJlu6PdI9m8MKUikyisb5VEeF4lppulBOQKx40JXIQdQapdEM7H/8s5BOqQOi5VjHmO\n", - "Qnd/JLadkETQF+26oSovQzhlC0XyouwCmGNpe+ZkW4MS8kHe6iOyJ9dn+KvuHFrUZoCK9NAI0taQ\n", - "bC73j7+HUXc/86uHeaS9NBNDnVWpPraJoFQknjOfn7YXJRw01J+7r7HXHQQ+VW2cStEJixU7rcZ3\n", - "kwXIrkQia1F4jl0isyRGTsuujrta5bWX3JFOOp6haF8sd/MkYDa1H//aY+SuE1Rjswm7+uvnz/yu\n", - "QFTVXI8zJAPq1hGhi8sHKPP777GbfPj4Ee7V23BzHYjNT37rN2PZL//iL5mZ2ftfcGXtf/Jrv2hm\n", - "Zo8fPYxl5LUeRBZ6Yj1F7fjz737ezMw+3QXUtdo6Of3hg4B0vXjm97pbh/H/WuX38BJyBp+aq7jf\n", - "lNhpFj5P3kI+wVbm+DuvB7mH7uOAAg299/8R46nrT+y+ZQK0NYMi/F4roHMCHNjcMShBxhjCyFtB\n", - "jh4BMf4Tv+cPh3u4ccL2DqHzrawd7MNa1K4b5L+rhVhOhKGUhYph9LPM8YJkZKKkys2m6rQSloEi\n", - "1kKiPvQBaXvz8edj2ZMpIFGdoFldzCjhF9khZ+jMxkvysDEPns4h3IvwgRtIh8jUiSjyrLlTqbY9\n", - "q5xGuO4WJ1xJqP0Z2ngtBHT2hcbNMFBK1wSiSKOi/gPzbwqawjbGwlNIEMd0wBrWyrOTnhWVOqDs\n", - "R+uNQtmbqfT5d8rfE5F9Rc6JpmMuDKKhQGV7GyTbwAGBMjtB346UHxBvwgron8iUcBhLUo7kOWL2\n", - "2wSASRmnuHouemTUOOwlryPq0glKNWM+J88Ckew4ZRmRypYtW7Zs2bJlu6PlF6ls2bJly5YtW7Y7\n", - "2v259l75P0G50k5AdidN3XJ0C3pRVEVXHRf+SVeQEqZt6UZ0VFDVqcni1gSJ1DtRbQu4G0VZNSrA\n", - "gkRXJM2/dAYSvqyEgNwAUh5Ed4OE+qpYkrgVAvW6g1gtx0eSvRDs5pJuN6+lN4kqxpOw6MeR0Fdo\n", - "PQGtV5VA9ewUks4FH6cbsdF2pdqwQMskvs8Jjs8P0bYitC8ugBJ1qSKJXE4BiLmsl/dQaKACublK\n", - "FOc9qLL5TKKy/5RK8myHragY1/Ajlv8UVd2iYrs6FH12Ec6zPXsQy8gFPexcR2qN5MJsw9uXHtiw\n", - "ArR9Ju42uso1A8ARejcvRINqu25xvM+nwxDccqMkN37v8ZtmZnb95MNwXvHPvH1xGeq0ddd21Nk6\n", - "9+tfw1Xy+Y27Z16CxNubE5vPHwZX6buvubL79TGQ1x+cBbff3D/3+8dYO5i7x26GUHfNrHAA8XuS\n", - "cfoQunDPd6L3hLajnpCZ2cNtaP/3H3o//ft/6MfNzGy4Di69QZJ8d3SVigs2utREHXqOBFyZa1R7\n", - "lzlObaExCaih3l4s8Gvh+E6CAug+acVlvt6GNptvJOEuCODrSdw9hxZ18t82Fcjb0CUaB6/vQM06\n", - "ccUw0XQtWkgF6jmXup4yeEYDing+zUyMD9y2Jn6vPWuu1wku66JYtrUG+zCRuyqb99RWEgoG69nh\n", - "OXErum9VFcbVRnIxj1zDJAMA18LNxtuf6/9ek7tD+0ua2NcRWU9Jm+DQSBgztqRxMLn8oMR60Bdm\n", - "ScI+ct3bitp+TJbtF2ngXmUbKz0kBgfI+ke6w6DP3yiups8JagVqAAaeu+K+blbfI8rMMiKVLVu2\n", - "bNmyZct2Z7tH+YM5QaUY8pmG8PIIRZ/wsVQuSMM1qYpenSoDwVCuX0QEa3GpVB045oTT8P/l9U/V\n", - "iaGWwwPu6vX6p86BN/NKkaMOn35cU4bdXEpiZgX8GjPezslnThSGI0wnlSr5nSir86U+QYmm9Acm\n", - "bZ10VJF+mqNpUSZBd0FVj3rrtYjgKNJGCQOVsXWMk0byfiGseOZiKyFdMMtOv8QuZC50pzsnn+FA\n", - "trXKX2CXZKIYTeXnUfJ0oU+2yLX42sO3vL6I5x4l119L8nDxNJaRJ6wh4XEjJsReEnCvzh1hur0O\n", - "CNSL50EGoBf0Y49zXGwdJXvxMlz317/1a7Hsy1/9YTMzu37+JJZtoCh+OPhuuq4CoZ0Kx2ZmF2+8\n", - "bWZmb34rkNjr1tGnNW6sERL1V98Oxz+7dmL529vw/Xjl5/0U97FZe1sfIW1xMTr68agK7d2tqMTu\n", - "uQafHcP9tBePYtmHCJNWVG8HqO985eeNa8zR++4AAvobK2//L7zzOTMz+8mv/Z5Y9iZkAkYgF7dH\n", - "2S3HAAzZkWP8r6SdWgQUqNRBeQKl4s69OCEBzewEk+zqmTtSz8HsETrVG4zTRqQe1ljHup0oqyPI\n", - "pRcF7tIhXnzKnDyxrlLRvJK5XrWUWvE6UWKhTLJSEImSMhK/QdgvJBOCRfRbECRIbYySazAmWy1l\n", - "7QSKp4h8h2CIUcjuRCwPL6F6v3cEd98HhPOy8MCO7TmuK6jKCtdQhHuzxVo3iOeiK3ANR2LLgsFQ\n", - "jmaN+4Ds0vsyqWJ5LNN1EtIRa2kTjhPpJ/K5awl8IupZVvp8GnCNZf5bHpVw4xkUJST+oV9KIgyQ\n", - "hOmOvu4xFqcVAvz6LMsfZMuWLVu2bNmyfV/s/hApSxGZGe90Y/L9ki/FnYDuCGIuJkWTmNbslbDJ\n", - "tAIn0K9EEQFl8ro5xbjKJUqlFZhiiZcdDxBYA8+jvxBfMXYJvYRaMxS9EV8teU2tZisnmDPpLpHH\n", - "i+8Z3d2xdnL/lJA4yg52ZA4laZRJuUHxvJQuUL81SU/qN6cvW/P/8STc1S7rdJBzGEP8hSPl6JvG\n", - "yyKrufAmDDucUtAk7lirdZH838zBnEnzOrI5Vf4gHi/hvxR4E94K80Vp7rot0J633ghIyHnliAzb\n", - "pix8B9+02MFKqDH5Tf3Rd7XX/zd7b9Zr25JWicXsV7Pb059z783bZE+TFK1dD1UWNoksl43JF3hA\n", - "VkquQvwBC+QnLJUsJb/B4gGVGwlZFsaU7KKwhCywiwskCZVk3uxvf/rdrn52fogx4htzr5WZ1k6h\n", - "g0vxvey1Y801Z0TMiJgzxje+8a39DnMlofP3XvLoy1mjYfq+QWNwWh68bPyhd99+xznn3LNT2a0C\n", - "EcmlrTfveJ7TuUgyEB1R+Y3pvpdTKAZohj/PIbhavYQcdxuKT1pf3z/0kgh3D41TtMIOvhCC2xwh\n", - "9NnI+q7POP5s3lHEdv3Un+Oks/566abnaK0LO+/pw8f47lYoq5H/72Bku/816lwKSvkcu97X96xO\n", - "P/n6J5xzzn3ivvX7Zu2lGC7BjRkJIri6QP1UfBHf54UhCOQ+ZYrmcs4ompy0W0Wcp2GtkzW0bchR\n", - "UX5pgjbbrp7yJ9Ppnp239+hnKfekWKxxfcknybxq4H41veYw9H/7WslHRH+U4Ih2yb3mOtFIXrUg\n", - "LCzPE6bdW4GjNUqtX5uCc0fQLyAxXWf1ZP+vN1a2bvz9nNeGpna1R3pqyVNI+YUl6plmdv0FZCXS\n", - "Sq6PNSOVe0IUVzlK7M9MRaIpRKz8OvaxLvVYGCmN0AnPj56OtQhy0mOQytypkLsu0+dO+FoQSSKn\n", - "g3E65JLu4v7VgnRzSGyk/ylmrWgWx0IhgpvkSKnnIi++96tSRKSiRYsWLVq0aNGuafFFKlq0aNGi\n", - "RYsW7Zr24lx7SXIFO9w2fjsgNpKArW65HZ+6XaRkKpt324q9u8jZJpOg1QYpXdW2mZNKiL0D5uWV\n", - "up+fe2i3FDiRhMlacMeDKUjkctqc/4gLxAUVbalTIIhq3/E7yhqoG81/LsU9sGEOQ3Wj4iTqnitJ\n", - "ct1BYtXcfayLqv02qEtBuQj1xKaEh62I3TNQVoa7oW0GWLT/rRIWIWPQS1nCHINwBZQC4dKNqRAv\n", - "3a2ZuGzobtWwZtf7e5c4qzy7ZzI29939O57IfOeGd+2NE3OFlFAvFq55CCvWQUF4fj1bbB3Xi7T2\n", - "+akniu8fHYSyMYjndNltGjueY3G10XBt71pQcvI777ztnHOuGpsL6gjyC3uiyn+G6+cKo8MFQhL9\n", - "UkjHrWOovbl97t2+jfpqrkES+0U6A+6oy6X9dlwVW79NEYqdHnoF7nc7U3E/Gvt78Y1Hj0LZP/7k\n", - "jzjnnHv0+Gkou3/X12l/z9yND9HWUu7/rdb33afumCr8j8O116xMpmG5Ye5EuLZnJkkRsiJIbjhm\n", - "SOh2EctlTSjg0tGAnq6ju0NI0R3n/Y410V11+5lrr5G1q4BkRV9rUAwVwG2OhXx2pbpbIRMC93Uh\n", - "NAaqguu6XpSUFVFcAGucUhUoNSKk6MAQEEI93UcLuJuK1NxYCa5fDsYQ1rWNKGbDjbtsLChhtYH8\n", - "h7hK+9D/GqjCddJfa72yMUyv/HhsbvQRAipKCTbo4GbbrKxORbWtSj8a+Xuy0PynHSUhVOJhGFCg\n", - "z8Qg56GZHXiPlaoBGkGa2oEkluciMUEPvboqSZ/RXLg0ynW04rJt6PrdQUBXukeGDBnqAS/GvgLC\n", - "03eZ5v3bYRGRihYtWrRo0aJFu6a9wFx7/VWoZ8dB/s8gXxl2PzuAo6EgJkPipYxvrOmOt1qWNAMi\n", - "LK8vxxGJ0EuR/yy7NO6ONSSTZ5zPGtTDdiv85cGhvfnyLXwy0rxe3NVZG0g8bnVXGRA5e9NvuJ3p\n", - "mQdqAP/gKwlDxS4ll91Kj3YVgtwwg7xmH++wm9kISsMQX800H3YsRJ8EVciByJSyW6Mgn1Y9IQFW\n", - "wK8gvyDEyiBdIJIYJCBTJkPJ5n3WbB+PXWqaa1uxg2yF2I9tle40HcbfzSMLXb5/0xO1p1DY2y8O\n", - "w3d7IIAXC2vsDIjRwbGhSpfn56i7IA1AAgbEXtyfVCC+9973CMwdCGM+bR6H7z72CY+WfOX5v7X2\n", - "oyrLpSEo+zO/O/7pf/wfhrJvf/kv/HmPra3PnnvSerO0unctdukgu+4d2Dbw8ROP+qgkA1uoopaT\n", - "sUfVliJcyPHfLA3NGY896lfL4NlHSHgOAviouxu+O8J9SuZ2rRxSC3uCfh6g7vuCyE0xZyaZha5v\n", - "0I4ffvCJUFY6X7/FxlAHCgvWIBZPD21MrM582VgI65QOqCpFFXz9CiFbJ2h3XookxBJzUtCkFgRl\n", - "yq5osAkh4052/0Rni9zkH9ZALoup5HqDIGuqwTNEeCV33D7QrM75cyzlftVYpxT9D3NRYAVKQihK\n", - "QUmSRhQpW3oYpP0jrLGUPVhuRMKj8+1pJdikTzGGVcwZv90oUZ6yEgLdNAhK6FU4kmLKDCgRRLoB\n", - "gnVyZuN6/8DPp5EEO5Cw3qxs7BLFUyFoemKKXF8FgLBv7Ldcd4lmqlpGEB+VUxAJzMRzUiQM9hBE\n", - "EvdfESne2oEnBs+7xHSCtq41fIXAmtwrcghETKVrMD438tzL8H2mQqxZRKSiRYsWLVq0aNH+Tiy+\n", - "SEWLFi1atGjRol3TXqiOlHq9djj27AjB7Mg/a/TX27JI4YwDF1BwtzFhkEDB1GLKtn12gxxCOxjo\n", - "1D5SHSVCpkP9dn7pj7u8FJcFCNCFKLyWhFt7yWtVwt2juYYASzbiRut7wJIDZXeSSHcoAaNM0EwH\n", - "Idigq+Gcwf3U33HOuRGIonkvhEGows5ru8Zq5T83TupJuJl9mG7D84kQu7OC2lbSTx1dm1JPuNS6\n", - "HUR5dfemWTsoUxV3jpcBjk29s3b7vqapaNag3UriLUBYPD4yAvbhgXdLTUFAPxiLy27h3Wft0qbp\n", - "0bF3T52fG9m0hZurkfxnKQiTWssKas/52FwwH7tzx7cVfXhxdh6++9svf9nX8Ya55+olFMBvWD3v\n", - "ow1/++W/tHrC9fvBB++GsgO4qOZad7h7qLZeSw61xQLkeQ0KwViYzc1ltlr58bQWdeIVCLqJ9MBi\n", - "jTKZEwtoei3Rrr09uzcVPt+/dSeU8Z589KWXQ1mNsn3Ja7a35/unkhxy5xf+uONDUzZPoGztEiHZ\n", - "Y+KNQR5eXFhbR3BjXkpOxNEedYRExwx9oR6JFK43HSck73aiS8a1g7o8m1r0kXB8Wao+k//tdM/G\n", - "RApl+2ZmvyVFIJM1brLn+6wXtfnV2vfTBArwiawrLU7Xisuqq6ltZW2oqaItrr0+BM9IXwd3k+iX\n", - "0c2Deb+Rc8yhFVWK36mH3lQv7eL9VGI5ifJKn6AGorIdQu5WkOJ7+ZLPv9Xc9M7OofN2IBkLlvPV\n", - "1rVCTkDpzxru8LVo24XsHfqIpfvMpYP/nZPABjt8kDM1HMe1Ptluv9JtgvdOgyL4fKCe1SDXH8aV\n", - "BiWg/wtxwboS7l7Ru6I+lAbPUHk+TbbH+HeziEhFixYtWrRo0aJd0/7eKJsnOz4F1dkd2NUw/12y\n", - "4zhKm2+H/4e3akWViD7tCOvt5G2ZSIgqcKc78u+FMN10+808iOnKbmE+87uayVhkBTKiH0r2xGch\n", - "jDJMVTOyJyDWKdmyBtk85DpSpCWhhIMVhTBZISfnOxCpEMLubEceyIOy+2cm7n6jTEWQLa3i4auw\n", - "M9Ss6o5EQDlF5f/RjPA9dnNrudYuBfoQVsupoGOCJPId+Q9blVDANlFRMpIyU9HqJxlzPLGdzt7U\n", - "fx5N/I580xmxtR/5Hf7qwsqOJ15R++JCxgkI5fVTy793cfoU9RUVc9Tv6LYhLE8eesToI294AvSd\n", - "O6bYfX7qkaNbt61sAaV05aYm2OFrmHaBnHX13EjpizmI1bKd7DF2jw48WrW4NKRljnx20z0jW1PO\n", - "QHNonZ/5dqti9Qjk/Y0QZi8hI7B/aKTcp8+RTw+h2dPKxvAK9T0WYn+BsbYWcvizS48Y5bJOVDjP\n", - "89pU4UmiLoVYvZgDpXBmHYi9NdpTCYLYoL/KSuQPuMYoYZbrpITkM8uAqjQvF8jdKUEpHDNEKTSI\n", - "paeEQq1BIVgTZE1e4xKaQ65He5gHzznnSpynHVt7xrXvu3rjx44qcedAjgT8cyFbnqDfAc1WVIXN\n", - "UGVv5vrUp1FA7nEuQV8IZtQ6hoGSJyIXEHLHSVYGkpcVYaLaR9/ruuf/NpQw0WAblKWCdD1/6ufp\n", - "eGRo6vHx0PvgnHMbZD7oa0GTsLat1yKxEDIfKAHb1539qehfQJOkLEMAhnoEOGL6HQi/ol+UKZCq\n", - "hxyTfCYMEKwdkgxGNpexy/ZIPXl/SnmeGnImwRsDXZ5ti4hUtGjRokWLFi3aNS2+SEWLFi1atGjR\n", - "ol3T/t6QzQnVqSsqQHuiREtYMFFto5ZkQztft0tb4qprp9t2zwy8XZQ4UtiVpLeBC4paRHKtkPhR\n", - "WkkJquBOElcgiJ3rpUGRi4Kwv5LY14NrOudcQiVageDZxr5TtxT79oomhzRWIVMK0KqyMCFWPa7M\n", - "Pc5eCtk6gwuwlGvsjfz1Z6pATc2ahP+LEnnHcwkBXfFeXqugZpJq4cAF16naNftn+xzkWhZCOk1z\n", - "QOuqxQV9JiXMJgXuSSt6Q8xuPEg4jTEpSu3F1P9TghyuY22x8q6tO5UpZnPcP7h3P5SdnXvX0vmp\n", - "kZLXK0/Uvjw1Uupo6t1dzx8/tHrCpbVAMtxFZq61Q5CHG3HZjY+gWG5NcCfnT/zxE3NB5RgnrSgC\n", - "r6lAX5urkqOIhNlTIbtTx2YyNRLt2Tnql9q93gN5e3ZudX+OvtjfN3cHieyXl9YeksxvQzE9ENyd\n", - "cxdwS2oyYvZXI4vNFNkAWlGFp35VK6rwr338k865ofu8JZF7R+RNDvfgWjSz9iZHOER1d0DY1UTq\n", - "1FsqrO4JXDYrcUEFVXKlADB4Ae1RzSauz726drmOSuLbp2uMJ1Fs52kaUa+nBpBMU5eDFFxN/PmW\n", - "F5qgnOdSaoPvw1QeZ+Z5l/UE66N6aYLOnLqloHzdY7yq7lXPZMiijk0FermouTR1nU64Jml7EAAl\n", - "lbqagaJTdXCssY1oq7WdH7PPHj8LZTnWLLqJnbM52StVApetNbkv3Naqd0W3WBp0twbOaJx/m4A/\n", - "WGsTulHtPoVHvPYJHsJFoVkhhsE9jcw1urbVBUtNR31chLGjKupBs0qpOld/8d2C4cwiIhUtWrRo\n", - "0aJFi3ZNe2GIVNq7gXSpqZPKrqrfJoeRO6ZE7R0CA4ZE7VJAJcFwIKuA3fKA9LZ9Bf6m35FLr9W3\n", - "9HT7HTbsGHFifasnOrW4tDftccUdoYTQUp29s10qX5cbIVZn6XZOKu56crzp69s6+z1VqQH0UyM7\n", - "WJoq4Y6Qw6zKjAEaQCwlylPtV8mbrDPzBbYi9RCI2kpspKyEIoLop1x2bqhe0uh9IAFfQn03ULtF\n", - "u0OOJie7VSGMOoTTalgzm6p9x7aqsjwBu8YJKRs727QCqtlJyC0Aprs3jeydjPz5VpJXLyjgS/j5\n", - "08cf+rJ9Q7NmIGofHpicAcfp+cmJ/+62fTdfelQhEXXmT3zc55p7+tbXQ9negUd9Zo9MFX0FiG88\n", - "MuwqA2JXy27ykCjZmSfM1oJWZEACnp/bTvv2TY8crQXVYji3opXFCOiYTEkSkDX/3wKoE0P99foX\n", - "qFN108Z6NfFj/OyxkciZbWAp8gtp7u/nK6+aTMIe8g+endpviSZpiD1HVobohEllSF+N+aLE9hRE\n", - "2USCQoisEkFzzkjLaWt9t0GdlQC8BtpBZCob2bwmcDBYV0gAlxyST4GInpzYvWMuuI3cO6JEmuOR\n", - "ZybqPRHF+BWQ4MtLQ7qIurcaxBJcAoKm5dvPGK5Tuk50wBcKqmmLij3R5F7uF4nXKidDNfhMCcsN\n", - "8//Jswtra9or+sJAFbRLCdPwKmSJHu+vO59Zn5wiUESRFuYw3PWQU4Rr3VCpXfMvNoNrab5KEroH\n", - "GUDYsUr2xxjLdmQWaTRQiI9JmYsV0SzKdch47ZkHUFBa+6weGRD1xcNBlQZdp0OlB/l8I9k8WrRo\n", - "0aJFixbt78R+IETqtddecwcHBy7LMlcUhXvzzTfdycmJ++Vf/mX3zjvvuNdee8397u/+rjs6Ovr+\n", - "J4sWLVq0aNGiRfv/mf1AL1JJkrg//uM/djdu3AhlX/jCF9xnP/tZ9+u//uvut37rt9wXvvAF94Uv\n", - "fGHrt/1V11cydHs5Z8kwlVjNTwNSOPWe+m13WycwJhFFEtfSQR0AD6o6NznpqUCx1LjYQXpOVYEX\n", - "biklyQW3YBCSEoId4Om1JEhdT6DxIm3ISgqZSDJK6Lj0jeit0LWlLkgSuqE3pS0IVZKy4KmSc5DQ\n", - "l4trj2Q/VYwuSNAUzZgW7saxkOJbEGA3EGjR+8U61Z0dTyKqtouJT3tNUFnhOHEZuNrXOVNV3jUS\n", - "lKYkggqMXrMTRQsF1+8k8SUTVAuy7NrEw+OjkSSNBRm1bo0U3ackwIIw2xhkX7b+t31u15+de/he\n", - "E/SuV749q5W5+/qWWkBCgAcpeu/Q5uv5wpO79+Biu3Fo7pkJtZjWdt5v/tVfOeec++TPfCaUPf7L\n", - "L+ECmuTT34u7Lz0IZR98w7sD1d3UYs4soGatyXA5P6lc7pxzKxBhb4m7c45kyJpcd4SEz8cTcwu9\n", - "9+EHzjnnjm7axm4fausPHz9yzg1d1i368EiU3Z888e7LtdSpPITukejzZNBvyoSAvEKi50GMB8e4\n", - "jNMSbskVEgoXonFD/bZUMsRmIPSra5m9qAt8ARdhK/Wkm0m6PfRBXVNHStpFjR2NrAFVYFKaC/Dk\n", - "3PfTydOTULaH8TRQIIebfa0u/Y4K3AzsEWI/3IfN1Pp1fenvf6JJizO622ysJS0T6Vp7Cuq9abZy\n", - "BkVgLcpKde1vaxZy3euEAtHQs6W6hKSPiKswUB8GXkkmkKc6tyQZZgCUBmAxUYesncuV709qp/mq\n", - "+9+MhIJBUnzb2DrBAKBadAnNLbe91tPNXEoEAt2j6sakBqCOJ2a2UNcuyf2awJ7uZhLQeyXxh5M5\n", - "sy7fun7QoBy8J+DZqfeTz8JhpJr7XvYDu/ausul///d/333+8593zjn3+c9/3v3e7/3eD3qJaNGi\n", - "RYsWLVq0v5f2AyNSP/dzP+eyLHO/9mu/5n71V3/VPX782N29e9c559zdu3fd48ePd/62u/IKl4Zc\n", - "OlbWBClyIX3hTTgRtdfw1r+DKL6D8211GISmguyrOxOeUIiIzCHUdxpCTIRLtnVEvZRseOWlU3da\n", - "3K0oie7i3L+FN6J2zpD8emR1KrETzHNN2MSti95itDHdJpY33CVoHYMkgoT/8nhpvwuXks6m2rnk\n", - "XOJuaiV5sgqgJDWUdYXf6JoN+jrblsQoBBFiWSfIUSAUJrpzIUolO3e2g+NFdn9tvWP8YQeZV5ob\n", - "iv0pu+qcBGgrm2In2EigwKz2O8aDzBPF23M7/o07r/pjFiYJ8OyRJ+8qIrtAXq2NoJRkfrai7E0F\n", - "/GfPn4ay1z76Ef8B7T45M3X01HlZAZWf6IEgnD80CYVFx5277CCxI374zvuhbANC7UTu3Rq73snU\n", - "t//h+++E76jAnZZGWCeYqSjlBrvqRAiwGVAVnf7TqUenTk4s19/h1KNzqxp9LB17/4FH0+aC/hHN\n", - "mYliO+s5EgVyTqPFhd27aoLcbXKbFnOP9lWl/XYDdCDdgdITfdf1hxkLUkmsR+XrRsLTq78IAAAg\n", - "AElEQVTfSYbO5Frc4V9I/kPOgRHkFza1omUlK2JtxVib7Bn6962//bZzzrnT53bebuTPk1c2xxpK\n", - "kuSigN4z7B95NRXB7hgab22dQDF+JR3LwJoklc7G+pz1itwDkZb2BGVrLAqNSrIQpVJUEdVLy+37\n", - "pKH+fVh/7bdFBoRNUGfXEPX3desGSuBEyQXpQWVKCUpgG1ci9VFWCFSprayqruSfdSbjoZIEJHnT\n", - "E6Cp9DjXMkV/KMnT6UBhvwpyiPvUKnKH39Sdob4ck5T60UCtID8kCJbJ/qhHKhn8HZhKh6Ssp75j\n", - "7AppM/uBXqT+9E//1N2/f989ffrUffazn3Wf+tSnBt8nSTLUKooWLVq0aNGiRft3yH6gF6n7970o\n", - "4O3bt93nPvc59+abb7q7d++6R48euXv37rmHDx+6O3fu7PztTMOHp6MgFhgtWrRo0aJFi/Yi7eT9\n", - "M3f6PhHl7y1/cO0XqcVi4dq2dfv7+24+n7s//MM/dL/5m7/pfuEXfsH9zu/8jvuN3/gN9zu/8zvu\n", - "F3/xF3f+/uDu4YAcGuA51ZHagWYl3baOhNtGwF1Q9h5g0Dh8B3QXEhkPEuTyr7jn6MZQDayE+iBy\n", - "eRLb1d8Y6kk2m8CTgTFohy8vPASbt6IEW/KnQuyDm0PyCAfiX5IYtJ3B9VG3hJjt+k3ofztHv4uc\n", - "11J3RGD08XZ7CItn4j4kabISsvGmGKonC//etUyyqaOUysKStJQk7oECfE8oWgjQVOVttjVg2Ebx\n", - "GIV7p4q5OaDwXvqOUtWZ3ACSgRNxIxAOzzNJWgpC7zL1Lr7bvRHBKyZjXoq2FC47Fx2pxaXXe1Je\n", - "Pd3ItcLzcJFMJ9Z5l9Bounn/JeeccwdTu/7TJ16LqpCxPgLx+esgnTvn3E/+o3/knHPuK1/8olUA\n", - "fXx+am7Ej7zqlb3V3UJV6PkCCY3X5jKbpvs4xtpQlL4vOiEWE+UvhSi+RMLhaWYJjw/2/fk24haY\n", - "Lfz1mOT42dMn4btb97xmlY7/i9kF2mDXv4Sbr5Ib8NIr3i07n5lrjy6by3MrIwF83Yi2GcjjCdqT\n", - "ijo8gxK0/Qz8UG2zntkTRIOu5vdL6U8m0pYswA10hGpQGtSNk1KrSob/AQjgyZEp0L/11lvOOeee\n", - "rm3DvBz781aStLsvURdxbZVwETMTgQZMtFj/k26H20UzW1CXSNzdxYjaTnZchbGV71LRZuJzp0Rs\n", - "6gg6Maz/ooXEZafTe4KPeaLBFnRf7tAgRABOnouOV5DnljUJLt2qMDCCGljpoE/aKydxbg2ahZKy\n", - "GwRZKPUlXBadp4RxUj96fU5yzsrzlFpRw6wgrJPVk+5zDWgKQUD4o1lBjG4iWmQM7HLbzyTVFgtJ\n", - "kJNt+sjNlyfu5ssTfJ+6b79pNIWrdu0XqcePH7vPfe5zvgFN437lV37F/fzP/7z7qZ/6KfdLv/RL\n", - "7rd/+7eD/EG0aNGiRYsWLdq/i3btF6nXX3/dfelLX9oqv3HjhvujP/qj7/v7pB++VQYEKdkqGhb2\n", - "DH+XHQlJxPqWSvRHL8p/uu3jGeuvCqYddgbdANYDmjVAn5iwR45iXjW9POtOxVpVx6WsghL28Na/\n", - "Xohicse3f1WW9d+Pnez0AilT377rQT1bIex36ItOw5p3aSJQCVdUnGsQi8eV7ZyI8KVK9qNisITJ\n", - "8zNz82W6W0H/NGuRX6Cyu6rYgryskhph95NqG4kcyl0Jt4Aqwttqtor+ERwsldgYNsSSa5B/ldCP\n", - "j3qLm9qjGRuQ7u9MLIfeAqjKgSiWn4x8OPlyboTR2SWJ0tb/AUQRmJQ7zIszQwnu3P+oc865S5DM\n", - "kyMjdldQtCbi5U+H0HghAL/5J/+Xc865GzdvhrIC/bhY22+zIFOhuQuBfkAJPZeAhctLT/I+lLB6\n", - "hkafnFgbctwnRRqnQJg0d16FXIDzpaE/N4BSrZBPcP/ApBFWUDsvRX5gA/J2IejjpvHjP89MOmIO\n", - "lGojoe6LDZTiBU1YQ86hEzmDBHOc6M9SVKd7qo1LTkiHPGlrkamYQr09S+1+9g6yJzLFA9ldiPpV\n", - "NUYbFmiXjesCc1ylNkYjZkqwE19c+PY/F/mDixEQ6am1tdwDcltZn0z2IOdQUv7G6suAicQJYR4p\n", - "Ay5WopiebCNHjMVRJD7HmlFKWVgngBxtZKyTuz9U5waJXdbklCryqqLtSJjekQEh3UZJiCppEtcQ\n", - "WCVrGD8lqpiOZ0cj4y/LSMrWa6EFMnc4xtXrE65REOkXEj3zmg6Qph3eDD53BCXnc0eDzMwTot4p\n", - "oJTBm+LEtsUHQj8NcuiBFC/reZazPYpmWU3CcSp8vsOisnm0aNGiRYsWLdo1Lb5IRYsWLVq0aNGi\n", - "XdNeWNLi3l1xe1GLSAq7K64w5yRpYTc4EB+UbEzytLrA6O5xO76De6jfdvskAvsGCFKwyFAkeGOy\n", - "o+7BpUdi90D3iteXMlZDiKVJjeS6Q9+i/04gU3oetD0km+8i24f2pAqnUrNGXGtUHRYYl1BtuyOR\n", - "5yBBKD5mAlVTFZwJOjXYgB3AhLLOOZfyHkrdKdTbCYk5gZttUCe6gLRP0Da6vXq9h/ic51ZG3mcu\n", - "LtOQeFhI5KYKr+3xbW3ELViD2Fkt/XG375uKdn3iic1dpYRZf2MLIexzXA1JuRhjmd5jVsnKlksq\n", - "Bvv/H77/XvjuNlI7qRtjNvfuqVLcsxu4546Ore6P3vdE9XJsBNgG92wFwrZzzo0KKnVTn00DO/zf\n", - "6dRcm5s1XSHWrzX0vnpVB3dUG5dgi2ZbA+4Ubk6qeU+mRpgmYXspumct2rBZmctysufdaMuluZYy\n", - "kMhLITGvQmJ2W3brpXeRZSPrpxL3bAlttWpsdapbjlebk/XCXzeTcdpAeb1dmlswh1u0lCTEE+hC\n", - "taJivYSbk8nKR9InLdxcuRDgC+p9TawNb73ribmX4pbMkLUhn1v7pxvMsamQfXHv9m/QLSnzD23I\n", - "Jdokm8AFN7E+ObnA3ClEbw/EbtbXOecy6PL1sp6WCIohob8QcnKgfgzWX0YxqRsL7WnELUc3lkzJ\n", - "nOuUjGe6GeuSmkma0BnrqugDpkHbUAOwGOyitcSzYxDk5D+vVpKgGPdY3WdpuF5y5a+wB3bk/VVS\n", - "OrW9+kFQEs4/WPYZ5CPrPk6T7UiGbGusVJhrvGYAgJtV5Q4Lat+l28+dRAMFvreMVESkokWLFi1a\n", - "tGjRrmsvDJHaSl2DN8hmQE721klMPN+gUw0hDclx9PTbyqZER6ic2u0gpyuCFBAxeat2VxRenTNV\n", - "9kxQMr7fa04ivmmHdiXb13LfJ4dQgxxeaaeKuTyJvv3jOyEMEkVJgSYIqBDyOul52V+6+6WsQC9I\n", - "R7fd/eG6ej9JBlcCNncJWTr86yuD3bduB2rsPiVclbIGGtfcUyJdSZm8/4omBkkMIGOiuk0wIS8F\n", - "wcJGuJDdvymbW99V/L7Ylr+oBSWra+SuwuEjQbrG+35HfnFiauMViL+jysZ/gXxyy43l1WqpjqzB\n", - "A1QHlhvfoJ86BAwUkhvu2YmXLnj1Ix8JZW9/5+s4zvpkMfPE4re+9rVQ9uC+VwU/PtyX4zyKowrs\n", - "RGyY12whgRVU+1ZUbQ6l8EyUrZvaIzJTCeHneZ/OTc6ghOzDuBJS+MLX6ejA11NxhjUI8POZEds3\n", - "GyBIIsFPdf5e+N/7+1524dlTU4A/OPbSEsuZSTyk3XZOzhrk9Zt3fIaIrrN2zXrf1l4Iy4FQryTm\n", - "HjIRjaFkM0hMFDOr6AK3sRK18fMzf9wISvCVoGVnZ14u48H9u3YpXlfU/on05RKAwhUiFYS9B++/\n", - "LYXQXUPZut5WbKd0Sq6PLqA/05Epqy+Aqs1bG2sL5C48PJYbhQpkiaiCZ5zPQD91YaPEgbQhiI3v\n", - "CJRS5DTHPc4k2CLDnGwFiW2RyYFIUy1EcKKpu7w0A2I36zmoE705qhTP4/U4rEnSoILBDXzWbTfV\n", - "NZpXDwjzgABvvptQFq4xcEXx+O0gMy6duv4yeGgYgOYtE+SOkj3zpa2Th8gtqvk/DYkTb8b3ERaP\n", - "iFS0aNGiRYsWLdo17cUhUi4ZvEHvlCtIySnafjNUNIlv/QNRM1g38McOUaqB35Ooyo4Xz10SCsku\n", - "nYZWOTLbaA65VjxqmBk72a5vAKmUewQ/t+xSkP7sSv6/fKtBvF62I6+h7Qj6reOVt0Q/uwoCMp/X\n", - "oE5AEdNuu5+UI0XEJMcOphBOyajyO9H1QrKq47oCSLlA7xikScTObcARgo9cNqTkSwUBQ5kRxRh1\n", - "qmQHWVCmQRApiAnmkmsuoFgiNJgGZMvGyWbjPy9ajxycPDf0aa/0SIDmcJshd5aOqwL9NNm34y5O\n", - "/HGrtYT63/Kcp0Z26S04LAzDzzVfJHZkjx5+EEpu3b7nnHPu9MSQnsN9IBeSw20MbtSTRybI+dJL\n", - "Htl6fip9AnRsg7GTCX+FAnsnp49CGTl1N26/FMqC+KjwfD74kHW2ftpAsoMcIOeszzJwflZL428V\n", - "GAzrhZV1yDtXjQ3V4rozklxzS9TlUHhjz555NEdlQsb7/jwbQSmmE49E1msIUm50Xvt6EgVzzrnq\n", - "GDkRhbfTQui1T1XM0bd7LMgNkeOlyETkue+TUenrputvjbmuiOgSl3369rdCWQMh4FGpSA+Ea2VK\n", - "NoAYChEdZm67BThnRaljHfOvs3tNNFkFHDOGy4skBJei5dx+uwdESJfzjogQUI9U5holFHoh2iSU\n", - "9RA4k+K8qfQd0aeRyJQQiEo65W1d4fIp0kKgXbwPvD+K3DJfnqI6DcukoiHvp0g8sJ4DNNvRYwCk\n", - "SelguGzdXz3a8vA551wBNWnN00rOnUpnUCZlmAuXMjnJVruCJJGcg12mMj2XZ5eDujnnXD2G/EWp\n", - "yqWBkGVFA7XtbYuIVLRo0aJFixYt2jUtvkhFixYtWrRo0aJd016c/EHfD8Kq2xAaLGH1gOxzgewI\n", - "4zcDTjJI4SpnsON8ZoQCpT5u2y1ozq5tWQV1rRCK7dy2r3Cn+/BKLifnnEvoslLCeA+ypbrWGKa/\n", - "I4S0k/fiDUN9xS3Fb9nvba8uFg83d+IeCGhmru3ndeUdHCq+6u7soajbirIuyZPJwKUJtxTcDbkq\n", - "hoNYPytERR34cbMWqLUGiVqI2kCnByG8dBs1GhIfUHacTwizKYjiuYRQp+yLXnMY+r9lYXUnVJwq\n", - "1xbuU1U7JqF2BVfFfGHk4Bv73hV3/txcS4EIO+CQs/9VideX7Uv+s03rr5EKTE0XzbymOra5AjMQ\n", - "z1s574cfeLL3Ky+9bBUA2ftQVMG//fVvOOece/DSK6HsyRNPvD6+8WooWy68K7OCrMNeb+fYMIRf\n", - "ZB1WcEWUM5MfqEjKFQL4Bmrfk4m5sajYvNqIAnji3WgzSDK0IqFQ4B4+f2bu1oJh/4kphudQAl9t\n", - "rF8LqIifXxpR/QDBAypTkUCVe28q7jb8pRvl5g3LF1hjzZhdWBvml548m3bbrr2us/vZtZA1sKLQ\n", - "T73M06MbtwffNZd2rcQqF8roCvr9P/yDUDa65dtaicvOIZAjE5kQBq1oTkqucRvM/yYzcjDUCtwo\n", - "s/6nyrvOP9ZpkCkC8295IcR2uMU7IRbnYQ2AXIPMf0oHdJn6sdAuCeLowd7OhewcaAzS1hpzsRjk\n", - "bkXgFc6byrpKV2EmZWRUtM12TkJ9/lDqpJdgFzLpBxIvxTbNhFQG83ppsFMgq4QyBlLlqsAP9fCR\n", - "lDWklMgznu5efT7z2U73ncrf9OgnpfZkIWOGHTdCMIrKHpXImsDx4pxzLdbiLFUOSHTtRYsWLVq0\n", - "aNGi/Z3YiyObp8lO+YFdNpAJoKiZao+FN8xtAvouong4x47vdtZDSfFb17TwSz0h8/gNBNG4EeBF\n", - "lIhOQU5FyUIE64BFPayIkxxjuv0gT1EQHgIhKUis6VjDgHeE0LJB8jbOUOBBNwX5CfttkGlQ6ITt\n", - "kb5jbjWoALjRyMipK4Tkl6WhNPXMn7cVciYr02teK+wwNK8WUUrdfbBreZQSVoMUguw+ExJRZUyW\n", - "I3+SciLEWoRzJ7LT61JfpjudZuXPN4aY4VLIkWenHv2RU7iLM4+c5JmiX35XtR4Z1FA1vkzF58oR\n", - "+loIuMvZqa8nx5+G/GLs6JCYIhT+5NRQmpfveAL6c5FpeOP1j/k2C/rF7PAh56NzLgehnkjvoRCh\n", - "33/fI1j7En6/mTM3n6EK+7c8YtNIWDODMlSQ9fzC1+/WvXuhLAWh/Xy2RJsF1Vkh2EFyuB3f9/kE\n", - "CyGMUx5gs7R+ZUh6JcdR9kDFFJeNr3Ou+QQpU4H7vqztvFyyUwkKGGMeLwXNZPsHedUgK9AI6kjU\n", - "aTQS1AvIRo0ABKJbzjk33vdt7QS523/ZI1jffPftUEbFglyI8uTTJ4PljETtXeHvFFC275YNxF9H\n", - "KmvDoBgrq0BsziT/pUOd1ys7bg5ke1/Q7BoBGBXQx0QiWxh2vxJyNlGnQhdv1DmXuZ6hTgpuYDkZ\n", - "PAvt2caFbfCwwx+RVUg5r23tYDBQqygl7oUKdxIdzwSJT9JtfIWBRBSuHSBCDF6SuZYG9F3uCfpz\n", - "8IRhOwaDgh4THRNDknky6GqUqZg0BZ7lvo6O/RjPcn1PYPCUnS+Hd0YcNu77YU4RkYoWLVq0aNGi\n", - "RbumxRepaNGiRYsWLVq0a9oL1JG64nbb6VLzf5TmRSgwVwVyFxhw9lNqIOlx7ZAwNjzv/7d6EkYc\n", - "eNFauoyU7E73odZz+NsBsdttKxwT9u52uPb0uEAG3qHjoe7DIGgLf08jUGyR0mUgVwo6VlZGN1M2\n", - "yEnH84kWCXRUBmRz/ESJjeE7uqrkvKOJ17EZV+ayWBfePdLVio+jrwXGJaSbi29L3TxWeaoY87fS\n", - "ruBjULI/PutYC0kE5bzlUHfFXwqkSM2dBVJk0cAFIYRl5rBbrsy1s0L+Nc2/SLdYJq7NkmrL4qpL\n", - "MUAODo2oS7J7CzVtnQctCNNKBCbsXYkS8CkI1S+9/FooW0AxfCJ6S5PJAdpl97OBi7aF6vDekeXV\n", - "27vhlcBL8c6QWNyKFpbbQTZnTjzVQFrC9bZamquqh1t2BlflWLSgNrjXqm3Wdf5zI+6WAkrpmZLi\n", - "cZ96VaWGr2AjufvG+76984WpnTvnP+eVr281umXXAilf71OHca2unZ7uucbK6NpSd98cWk1lZf2e\n", - "YfDQe6ok6smeHzuJEIYLqMI7dXfCpZ6JBhS12gZ5Snlq5WqQPoA26rLd4beX6/NQVvZQpZd7UpWc\n", - "/7Imr0lAt+NmM7qstnWhkg3bIMFOmGOF3ACuhdkgKGnQFP85Ya47KzPSuAQZdcP1uVXXXjixPLpD\n", - "AJToQzHYZ5B/j+uPjb8Urrpu4Mdie3UtpLYT8v8N3H/Jlb/mDlUKQpJt57/lbwb9RDeeuMBD3lc3\n", - "fIb7WtK1p+cljUA0wAIBfRBltvXb0MVKn/neXPOISEWLFi1atGjRol3XXhgilaTJUPU7vPEKSkMe\n", - "miICPF52BPx+EK4JJKDbiUIMrzmwgZoqDxzEYTrnrqQGYkjsIE8edsQaEuooXcDjZLeE0M1UNx/Y\n", - "QQwUy5PtsNaUpOBWd3/+L0nfvs4g1mEXkkkOOar3KmGPO8FU3tZJItT+Z16lXpALdkVdq2Iu+852\n", - "swlUfgM5X3NTgRRYlDZMi2Jb/oKRsyorQJJ5OthpUBVeiKLsO0cldN2t8L7qxa6w050qutvun7ne\n", - "ZEPmktSjHa3IL8wXfmc9Kz0ioDvtdOaP69dKACeJ1NS5c8gtTwSRmxyCFCwK0BuobddCHuYUIMFZ\n", - "d2vjyqtyV6UhWATYMiGRtggK+PADU0A/gtr2RuSOb1bICbiyOq02Hn0Z4RYvFtauV172+fouZ1Z2\n", - "vnzfn2Nh/TTKvGL6xcb6lUjbuDKiusMO9+DYJBbe+c47+IFHZsb79l2G0PhENCymB/4+7Qty9sFD\n", - "r1heZDauSqI6a6s7d/NlZf25XiEoQaX6cVPyMSRBJDiC6uy9zKtnj6AyL+OUIe6KyKWQ7Ggkr1sK\n", - "+YUk216niFyPRJ2d46QTpPUS5PXDe4acHc6BXAlKvd4Q9ZT5lHGdFAI00YSQ106UsPF3mYokA9YT\n", - "iaB3TKe4v7bCGc6nCCvrVItMQ0G0F+T8ShC5DHMsKVRqAoiQLAokoKsXJMjNKLrRbq/nfWg2kEaR\n", - "NQgPHpXJaSgXIGsnif3yiK9bBgDJ9SHT0CjZuqN3QhG2ISKkzzoG7ySJJuxDddVLwEAdechxnVbE\n", - "h48xlY7gM9PeBTRQa0egFHPyytxJdzw7TYpo250TpE6czInvYhGRihYtWrRo0aJFu6bFF6lo0aJF\n", - "ixYtWrRr2osjmydJcF05J245JaIFDE5de9tMMDtKiN27lM2vvjbuOIe68Xa5EXf81GxwXLJVpyQQ\n", - "yndpNm1fq293uBEB3yc7fpuqAjzVYcW3RFJ8Tbi5ViI8tai0LkyeKf3UM/GoEAHpbhokEvYwby2Y\n", - "cVDFTQQyvXKPdyWD1uSZo4l3s7Qrc081TFDs1BJ3tZBjJ5OB0BJH5uGNQOYkqioBu6UrRoiYxZVz\n", - "OXMpqsskJNduxLUCd9DDi8fOOeceHN4N3x2k3j3SOIP2R3DLMrGs/wx9Kklu3ELFWt3CdBGsRG9p\n", - "DVdRBYVzJfbS3dn2RoRm3ccjc21N4Q47PbVExqPRFHUz1xoT+WrCW86Z5QVca1Nzo9HFUVXWruND\n", - "72a6PHsWymYg4w8Tmfq6L5eSoHjq67yWsbO+8Od56Y1POOecOzi6Eb7LMGBv3b1tdcKadfLcXIv7\n", - "SNpcr0xtfQXyuLqsqsq7O1cbI9tzDUhk4h0f30XdEUQgOmp56vvzQgjzUxDWFzO7T4FSIG7kNca2\n", - "JpLlepvKOkE3xhQk8nJi93CCezc5tn762gfv+vP31tdUuW/WVidqqnXCtq6DT0czKqBPgoySyviD\n", - "sC/XGmOeFKqFhN/ujWxMNPh+LfOUwROtXKPFGsuMGcIEcFnKIBJV1sbfQTJgzDtpawc3WqqBQs13\n", - "X2M3Ld1u4kaje0oI41x3Wlm7EquUnZdZMVQrjkmId6yTiYogJnTpkQphnRKIKvJ85Xn12RWU59W1\n", - "F5IFy5q4ortPokyumKrYM6Cp1X6iinyhrzik1lgJ+y6RbPVcuweJ6b9XNJqLiFS0aNGiRYsWLdq1\n", - "7YUhUl3fD4jA9ja9A/0ZqC0z546ejF8q+mO/vvpp11HJ9uFGxB0QlnGAvmpTFVrz31FtdSBBvk0U\n", - "tEttE+aDiq3mdSLpbxCSjzd4JcThrT/dQQAnOTqrhYgIsmsiO7MM6sm5vP2z/1VWIiFKJu/lDL/V\n", - "3WdT8xpGNg4K9DxO0CeS51VCIAeJO1cpWm7OdKdXk2xuh4WcgK3eJ+xSOkpNyOE470aIvbzHqtie\n", - "IDdVLcTqNWQMRqqAz/PKvWsR/83cXRvZaS4WHmmZSvz/auV34szb5pxzI6iBtxLqXuP6qjTRLlCW\n", - "G+pDhJOAxP6BKVxTWf1gz9CnMfJVUf3ZOecuZ/7z7duGpu3veUQiLQ1N4vCoZxK6jn68xP1XYu14\n", - "5Nu9PDVUowQ6VZaKapHsauN5tvCo2ygzNOXBy17R/N13vhXKplPfj3fu+LqTYO6cc+vnJ8455w4P\n", - "jGzNKVzI9WdnXjpBkT7Ws5rafZqde1X6THbkmw0DKkx24Ry58yhxMdmze3KBHIP7h4YIrUnel2WC\n", - "aMblXFTRgTArAZjrycWl1f3B0T2cjgiuoAVo/6Wsf2++/WVf78YQOWYqmEj7exB/N6J23jFAQNCP\n", - "HAEPHYnISuIG6lMr+oMgj1LIwSXm1XQiKvJAOpZzDSjydWkGyzSQM9SpGZDIgcgI+uN2kZjR/7r+\n", - "ZXiO6fJP5L5vFc7xdV5hPg9yrXKZ1McEg61UsZx1Gkgy8NmhDzle146rsQb1op5PaQfLCiHrL6Ur\n", - "BNUkKb0Q9JkZILJcyeaUqbA1KYdMQt/IHL+KBEqfMLCkyO34aqRJTlkn/hWkiZ4rkfNgnTQoSZHt\n", - "XRYRqWjRokWLFi1atGtafJGKFi1atGjRokW7pr1YZfNdhGnVVgqZd7cVw1X2wRIUK2GPJDLRsUiG\n", - "EKi+RXZBd2KbYNb3Ss7bVnENv021nrvcd9/dWN+BjFGyrQ+SFYCim8GBg3M4Z64qdYFS5ZukSOGh\n", - "Bvdpniuxk3CuXB/wrfY/21rvSOTZyoHUwFGvXAVXCu97LZUyd6/qWDFppti2tIjL4KIUL2JIQllv\n", - "FJbvBz/NCzvzmr49GRNsT9+rPpavU7Mnrr0l3ZJSd5D7OyH5Z64YXD8ZyKOD9CqQ+TE0fRTap96M\n", - "kl2ZyHizMdcOoWodJyVdWdTMau1ad27fd845VwvETd2hQ3EtHh5619+Txw9DWQ33zQ/9+E+EsgsQ\n", - "ylezi1C2QELgA5CTO3E7UUX6SHSfzp97raqm3lYiLsUtF3inokpOhfLLS3Mt3nrjU84558bQbErF\n", - "jb2BK0zd8z00dhZLIXa3fpDtHZoLsMb8vDyztvY4biODcn/iiezdYET7zzdv3UT77Pp7e95l2LR2\n", - "jtMzn3j67n1zrZ489+5G1dGhRtp8ZmNiD7pYo8raPb/wdZ4c+3t8IO2aYH58/dzI/u+tfJBBL96U\n", - "Setdqkx87JxzGd086kfLSdUQzSAG5fB/oSdkPfTZ7AwhoCKtJBk2urMUsvn0ACr2ostm3SOuQuhC\n", - "FQXXJrsaKQuFjJMMg03F2YN+mtSdQT4qGVajLuIpdx014sL6b9eiAnurNBY+a+Q5Rc0qXWupY6YE\n", - "7EDoH1BgGKgkrlK42an7pGsN1cs1i8QEyeclTsQVlT+vjrUESZ21nuMJNSAl4fOVJORaX94nTRDO\n", - "Z6ZKALLOOid4H9NBwmNvGmQwkoCLXRYRqWjRokWLFi1atGvai0Ok2k5TmIU3405eTbfJ4foGvYNO\n", - "Ltt0koj1TdfOlAz+c87eSNNBDCfeflWBnaRI2SUMQ/av1FNRIpLHA9Klar7bCCxA7ycAACAASURB\n", - "VBJDSDVauee2R8iZ3OBpuiRKIWS6I0X/BJBOVXdDu6T/SUQWlMbCtaVOgUUthVRAlyHWksS40u0X\n", - "yOtoqxKmSaxuBur0vL6S7aldIGRzoo6d7Ag3HBOy++B9SrYVlkNsgJJjQ2OFMIwcXquFjJMKoc4y\n", - "TjL2v6go97gHVeERkaN9U4ceg4Ccyn0yqQkJP2buPhlrVFTu5bcFdo7cLfr2DPMJqlwFB8qRENCJ\n", - "TuVCgF+DjH/r7oNQ9vTxh8455549NUmEmzc9wnX2dBu57QOqbOfNQ75GQcQwnj/5qR8JZfO1R1hU\n", - "sb0qvfzCbVHbLlDnVEjJhwjjz0GKL2WsX2QYr43Vl6hWc2nXKie+fyrp18XpBc5nZQn7TFXBzz1B\n", - "OxHUc7LnZQdOLzzSNBpb/29AHs86G0NHQI7G+3ItdHsva+JsBkJ5I9Ihjf9NvRGZgNZ/X+75HX5x\n", - "IHn4Ej8/FyePQ9kScg6alYAoTipIU83FWNpKIvsgKIfn6IiMaP9jTZQxUWDel4KcF4hAaYTYTC6y\n", - "kp0zoDONBADUIKpnVEKX6+fMdZrqnPSmLQhL+yDXqS9sBBFvkdBwU+uzAGsRUG/NIkCVe1Vnbzn/\n", - "pZ6OdddnYkpJIMHzuJ7LcRzHmpWhgEwBgTiVsCHSqUFJRM6SXLI9lNvPEz5uFTna6c1hnlb8QI8p\n", - "QBTXRze9T4neV+bEzRWRZ53lPjF3qWbZSL73q1JEpKJFixYtWrRo0a5p8UUqWrRo0aJFixbtmvbC\n", - "XHu9S4auiG1kN8B3uxRGOyG2EUcdqLPiNwoZd3hvpGZRn+xwWe3wI2aq+ktIURI07iIKW5lAsMGN\n", - "gmv1+h6L80lRBqg2zQc+M1RtWzG8E3IcYdS8EB0TJtrsqZ0ksPt62xUFhDu4yXwbtsn+JIqKpzJA\n", - "+4o2Zzh3o2rLULumAntdGzl1ufEuhlQalgLGV7I1PQZKSqWbr1FiK0je7QAWxm+Da0kVi3liKaOb\n", - "UcZkDd7xqtpOxpmJv7UApF2koo+CKZigbmVipMYSmVcLSXxLnaVMyZZIkNsIiZbaO6qFsisAY2/i\n", - "3ULUu0mEiEqtplYIw/cevOKcG6qNc04qKbzBAHn722+HMiYfrkRbZgNXLr29B8fT8F3LZKwSANH2\n", - "vn6zlZG9STbWJOgV3GiXQmzPQZ69f/8Va/+RrzNdPEshkc+W3u1WZdauy9mZb+uRudv61PfFam46\n", - "SpOpLwvuNGd6a5uV9edoCnejuEqYNYBuRPXZB/22RNTuoZW0XJgC+vzCt2M+F2VxuNbHE3HtQlOt\n", - "Wcn54CJcnHtS/kRce+XY1/PJ238RygJ5uZfHSQq3qCZSZhJ0WWSpFTWkNMB90zPYQlx7nIs71m49\n", - "b0igK+ukufE1CTLVtu36TDxQw32vc43J3VtxxXHtGq7nvJi4sdHFqi3FpSgdUBUYAEO6iRLxqe0l\n", - "7rGMzwRZu7lAKu0ELttB9gqse+XI5uQYGRIkV7yjzFIJjadCEznjsyrmZ0ExXe/JDtwGibQ12IDr\n", - "uQYeqTv8qtWYH1onjiGlhXCc9JrwOfBR9DmNeyzPnUEQ1g6LiFS0aNGiRYsWLdo17cUhUn3iBpRl\n", - "vi3KMUSCBsRm/E0l1jQQVuXtm/nUWqdvpFfI5gNUZZsySAK6vkinQQFbdgQJd1UaQrktyRC+77av\n", - "RYRJCat9wrxugiqRlC1v1eST14LwkVBZlEKYK5inCSrajeofQLFXk62l2zkBgwKv7LRC6Kgid9gl\n", - "ZBJCOxp7tGUj92mx8LukFnIBrdSpAYlZyYEk22v+qX5DJVwlUfprNBq8wJx8iRLgcZ4SocEqfwG4\n", - "ar3W9nMHK+TcFUKYDXxwCVFSGX8NiI1tZjudo30fWv7SyP+9d3QzfNcBiVJiOT9PD0wJm7uuXHaE\n", - "m5b9r0RdkIfLbZmAgP4qWod8eeN9U9HegMRaltbXC6AZq7URyx/cf8kfV5lMwle+9pZzzrnDA1FW\n", - "x98U4yQv7LuGyvYy13NIHBzsWZ2ePfLE9pXkn6sQrn3r2CQBNo3vz0MJ52fwQOhDGa9F6ZEo3emP\n", - "c98nZWrHzTCfqpHdkycPfZ00JHsJUryOiSyd4vp2j2v258rDAGUpUhto/3hqyF299khU3Vr7Ly+8\n", - "KruiWSuoveeVEfBz7LpbUdTPMuRJZFh7Ze1KkddP898t0K+qSs953ApMTRKvBhRx7VT1cgZ8MFND\n", - "UiuqgVyTzvo1w7o6eCZQnmQQ0LQdlEK1DVH9sDp1zDUpCBrO0UgZwLdBoFLa+/u0lmwHDKzpWi2j\n", - "N2U7YGmMeToIGCLQ1Olzip+sbIR5pKgO54R6glLkHxyNrT8n5bacAUF0qvIP2sqgKEW/GhLLDenq\n", - "gI43Ih2TZxXOKwEIISeprHtXnkWDZxLq1EmwAdXRu97az/vZSbqHhrkO5bj+yvH+8w6XmVhEpKJF\n", - "ixYtWrRo0a5p8UUqWrRo0aJFixbtmvbikha3/SDxa78TiiXpUMjGIAcq0BYSBGuC2ADFaYJOamZQ\n", - "i2LbjadupIyquzsS6bYCzzYCC9r5diSyBLRNwFBdi1RlZqJW51xIVtxokl1yLaVddbMNDydoRymu\n", - "PXotOsDyq5W48aAYrJAxyY5a1oAcPNACgQtAFWPpMqqKbdfSuDQYebPxCszLmSfFtjsSBCei+0LC\n", - "rroi2P1KAA16U4OtAl3F2wRYdtN4LBAz+ivJtpOBruZ2fWpl1TNxAcBlogT8ch/XrOwaq8S3++jw\n", - "NX8uIaKuVt4V0yxNiXs89idZCzl4Hyrj54vTUNbyBohbKhDEZdzxntXUkapVx8u7ig5HRoA/OvYk\n", - "64szu9azJ96NdXZqatdfx318+fUfCmUf/dhHnXPO/R9/+Aeh7Md+9DO+Sgm0YMZ2rTWDDYQwWoEU\n", - "uxTC9s1j7w599OF7oWyyNxm22Tm3rr0LjGRa5+x+buBGrSR5agISeSeBJSO4KtVlfRvX+vDdb4ey\n", - "PZDNz05PQlmDgJJDSUJc19TlEpI/hsdq4evUiRtrhHVClc3HCBjYXIi2ElwqF3J9/jYRHa3ZpSfP\n", - "371r7r4EY+LOPSYvligWfFeJPtbs0vfrem11WtAtrZkKmKBXz8dFUKJHGri7WsyFTOa6Y7JoGcOk\n", - "OwwT+eIwjT/Z4UYM+e41Cbyx4n19ZP3NSQsZJEegivYuCoQdF7JyyG9DpgiZ9ylcVCXWSw0AYsNa\n", - "eSZy3afWk3PO5Sm1kOyndC1mIyF2s9m5PgvQ70Jyp1ZXklY4v5y259+BjLo/lXRUFhIPi6uSwVOd\n", - "ukURZCWL92ozVLvX9Z/P87XQPUrMp9RtPxOa1gIwsppkd9EgKxg8pZqK7ntaRKSiRYsWLVq0aNGu\n", - "aS8MkUqSK8reIfzcrHfbSEtvewg7V/is4d80CYlMSEoHYS3TXYD/O1JEAuTdVvLatTuuT56c5usJ\n", - "REnNycfQffxANxoQVnZ52UoZ83rZcS12c6mG1Vf+GuvB3cTbv4bkZ0OEKc2NCBh2i72U4f7kA2J5\n", - "P/jrnPTrICTfn6eSsFESGpVrWXeevLpEzrVapejRdalIOHSoJ9VsnXNuE9AfhVpCrPNWkZbxHoym\n", - "vvPGBxpC69s12jPC9OVzkPidXZ/oVLuyuhNh6EXEvZ35+uVCwHywx9x5vo+Xos7NcVXKfSKhXAnz\n", - "z596VK8YkCi35SwCUVdyXTH/YcKQe2dIQ7309+RSZtM73/qWc865k+eGdHz44SN/3NJyuOXY6n7r\n", - "PSOg//S//w+dc8597GM/Gsref+Tr/tIDjyptZK6X2NWPBK0hYXt/avfk9InP8Xd8w5CeENcha8zN\n", - "G56gTqTNOSP+jg48EraY206fyMh6ZVEEJQj4N25aUADJ3geSj+vRc9/u0UjG/9TXL0sNYaIiyWJh\n", - "fZcC7aWK9SCH52Z7rq2cv/7F6Vkoy4AEH960fhqPPHl+pmjeLd8nG9nNHwBhKyd+3K1nhj6Wt3wQ\n", - "wfu45845t7i8QBtEpmPt+3gjfU0pmlzWSYf1ocvsOAaFUM6kFbV9Bo9U6iVgrj1BMNh3mbgEcsDO\n", - "qYT6U+IlHz54/B9K7ajaP54nGmzEjAXqpXA94X9bADoqpmtAS8eAIiHgBzCLgU0KawEtUvkfSiKo\n", - "sjtQx2Fggz9xPtasBL5+a1moEkpirA31KXM/tkc5UFqF1ZjXT6UekA0g1XQXVJGX7BUZ77EgrOuN\n", - "76flytpzBhkP9onmcHRBJkKfU0DfJACna6mUb/1ZYi2uZEyUIf+jBnltBwOoRUQqWrRo0aJFixbt\n", - "mvbicu25ZMAf4kv3ANXB23eSKfp05QfOhe2nyh/09OnuEEkL4a3iv2XocjVWlAy7D0FE1kt+lh0J\n", - "/dyCEuU5Q11lR8Do27CrsbfwETgVxVh2ASPwNwZ8IIbwC+bWISN6LtwDCj0O3qqxcwrZvW1Xx5xY\n", - "A94YWyooQcj+7SSsFEemmZWNx+hPQY4mU7+rUXGzEruUNXb1z0/tHMu536UqqkYxvUL2AOUeuE9L\n", - "FQ7lzl3FXP1fFVil6tz4JkLN94V7glx3bW3n2ABVSgc5BBEmLTvXPUCMeSloEnaixxNDTvZzjxKU\n", - "4Nwsa+NDZeBBjYSPwrovRGixQ+r4RtEv1IXjyjkRbhWRRMptcJyuVjLWoZK5kNxgF9glvvvYUJqv\n", - "v+2FKBdLg04J4j5YWp/M//jfOOec+9mf/Q9C2Xfeft8559y9B75dz58bqvIqEKSLpZUdgw+kpIUU\n", - "6MtmY2Pn8ABipsIboUjv3rHxgfb3/XEd5vrJuaEvNeZCLetKBX7VRub6euPvxfmzp6FsegBRQ5FJ\n", - "2JAjI2OS4yPfGCJTVNi5t9uIGPk4uvteYu6UA/QLvLkTXWT9tbrWREonBx5ZU93a0dSPe3JOko2K\n", - "D9eoo42rDZDI5cwGYAskqt5IrjUioTInAuosc7KHFEQC9L0XAdsa47TVNQmIaSq8tbDuq5hpuo3m\n", - "8LOiFH2oCua6IEghhF67td1GP+ogZ6EyPbh3bgdHSNdz5tNjnrhB5P0unhXOJWMiJw+z1WccUGfr\n", - "piBmmQmaRgQsl3vSBumYbaHRBvIwtfBbG3CacuHoUhB0PBY0tfdrR99YPWcbf+7zczvf2WzYn/pM\n", - "yoHwltL/SyBWs5Wtp5xPKolQYf0nCuucc9UIkgzC7x08M3ZYRKSiRYsWLVq0aNGuafFFKlq0aNGi\n", - "RYsW7Zr2YnPtXSlx7oqCaDL4812tC24c/Sl1AoTsFnyJIN0pOQ8Ez7EovPIUbWvvmy2g5W6jZG8o\n", - "Vg/yL1GSQcm+/i/dHhotWk6Y80hcVqhKLqS7eltpwWUIzxcvmkHmSlSFBC/JdCtBKzv0U66hqYBv\n", - "B+rs+E2mBHCS0gd5AtGf4loawS1SCbY8haum7uAK6I1EuO7h0qj0PsGNl0pIPFDfSvqOObS6gSz9\n", - "UMXaOeeqqT9ufOy/OzgUIjCmx+pSJBxK3mNxmcJ7sXewH8rG1RjHGwG5g6L5sxNzH/VwgbQg2+c3\n", - "ze10q0KONyHWruDGUXJyizIN3jg89L9dKSkTLuJqo6RcuGVxT/Lc7tey8XX/4Im5gr6K3HmlkL0/\n", - "8iOfds45d3lpdXr/0bvOOecenls/PXnmSeF9/v+Esk//8Md9GeZfNbK8bhtMwNXK3EMQAnep9H+O\n", - "QTkV6QTOrVxC/TO4lFTZnNIlPfLE5YWd4/LCuxRHItdRQAqiHhBm/fUPxWXYIT9mosRyuBYWc3PV\n", - "bUDKnojEBKMiOoz/XnJ+bRp/L1QJegTl8URdYAhaOJAxefLMj4WJzEkS6m/cMqV4ho4HcrK0v4ar\n", - "5N0PTOphPffnqBdCGIerptM1kefRWHJQDzJ9FCVQgGcbxRXHwJJOgojCdE53uOzk+pxGGqjSY+1M\n", - "i+11Inj0BhI2OL/0P581bS1uxNZff6OyBgw2Ut0b9EUmi2fOBKB8/skDkHln1bXHnHCqYt6PKKEg\n", - "P8ZY7+R5VjBThqyJzFmotBh+buHmH+SGxPlU7b3F/NBcpwkmpRLQmXazblXiiEEWQtUJbjmsV9L/\n", - "G7gUlYLBc0xyW08u4SJfSwaEtkSgkEgiVEtf91TuSTbQkdi2iEhFixYtWrRo0aJd014c2bzv3YA6\n", - "zlf9Qbbo3g4NZYECHcr44qohmSFfjqIpV3YYqSJSlX8LzSUzPXcwrZBzlzUFxJSUvUP8k+RBuQZ3\n", - "MT1JsYKWZAVIf4WQLnN/XCaSDMxJVyqJMSfZe7vvOkHkSIYkiXA0ltvPN34hFge1NnkbT0tuybZz\n", - "2DW1oR8NdklKLK+C6KjtvnMgIbc6hNqvL8N3M/fYX1N2nySWak487laKsYqP+rZtJE8exQTbVrKU\n", - "g/g4OfC/VfmLBDvMXHZ1+Rg7ONlVEqSa7BthcTL20MlIRErTwn9fJ4bcHB95dOQYueNakTXYgDCe\n", - "pbaDaoA0bKSvmZPRya5yA/LyYmn9WQPNmKbW/wy7Jul5b//l8N2tex4t+sZ7XwllBUL4byGXnnPO\n", - "3QAp/KOf+Aeh7F/89//COefcLP0wlC0vfT/+zVtvh7I3Pu5FOhMgM5/+hAl4Pn3+gW+/rAmUFell\n", - "B8t51Qlh9eZdX89c0M8gHCsocbnn0ZlmjXmfW792yVCY0jnnFhhPeq/XGCeHL3/UyigZIDvnFsTr\n", - "9VJQQgohym6eqPDhoUf9lgtDsLg+KIKTI2BjKvILFFp99wMTSS3HlHOx9k/3ffsnE1v3OCaIqvYi\n", - "4Hj+3Lfr5NzG1Xx2jjZrYI1v93RqiMAR2qNikhSkVeCYMiYt11MJzW9I2Be0JAgHyzOBihm6Tqxr\n", - "ilTacQ1J5pp/j+tpkFCxurmQ92/bTzLQo8Tc7QX9CcNYBF53Ecq5njrKlei6zurq+o9r1BIAVDdE\n", - "pFTiB6LLqu/ZbQuMtnjglnLdFCLOWcM5tI3INfL85bq/XFun1GvmfxWyN0RHlSifoh1K7242RIz8\n", - "vOtVEgnPGkUVMyLR0q6bR36dmk5sTJ5d+vE8kD3BOiKqM64sIiIVLVq0aNGiRYv2d2LxRSpatGjR\n", - "okWLFu2a9sJce2nWuqYW6DDdzoOWBM0I+10SNKNE94NK5YOEOIAgBTIkZMzzleJGKyoQDAfK4syD\n", - "JK69BUnM2yrWreCjLaBnJanx2xyYYdKqOivgTNFCISlR8+9tUM9uo9BqjzZIR6GthahCZ+B6puin\n", - "SvmtgHHXF+pu9W2k1pP/TLK3tbWBq3K5lBxGGUjkewaZloBbNa9YVYIoDLj1+NgUo8/W0PgRtW/m\n", - "pMpKhYJ9f473xN02gd7SSkiJDTRwRhJQwOPH3n2gavddTdeqkXNLQNW1YMYjagGJPsseXCbjyq7V\n", - "w1VwLq6aVevdfA0VkNNtzSglxzd094muyQrq5Jlg9heX3t3SdtZ3NfSA1ksju4/h2joc+/t1//VP\n", - "hu8uEw+Fn0v+vYNb/v68/Z33Q1k58e7Jlz9yP5R9831PNt/Mjaj+o5/2rq/vvPVWKHv40Cukf+be\n", - "K84555Zrqy/Vy9eSa5BabfXaxtUaed0Oj0yfi+6+MZTInXNBvjpXtxyV3OGyLid2vz71Qz/inHNu\n", - "fm46VrOZd2nNz6xd470S35mK+/G+7xMlBRcTf9xIlO0XPJ/MnQ3GO5cuXUNSupun1q7JnieUj8bW\n", - "rhKk+dffsOM+eM/rXCXibjo69N+3osBNraoSC8To4Ch899Zf/rlzzrlnTx+Hsgp92HZC2AVFYiLk\n", - "/RHUsSuZfxc1+s5JAAbWTrIn0k7WH6xT6vZhXjkV+2a+wLywG5BS20iDcuBaHZCJA6UE46Xfds/p\n", - "s6YhBUJz7ZGon6rPkq5KqWia6B//mfQFuic1D2FLWoiegmR3ef40DHbQYCdmgNDsEb4zWn10wlWm\n", - "NAMGZSzRAZUQscvM39dpImvd2s/ZVW/aclR+bxpz7W2wxnaJlVGOT/XWqIE4n/v1MpMMDBPonk0r\n", - "G+uk3lSVurt9X9we2W8fHN9xzjn36MTG8xkCKjLpuzSJrr1o0aJFixYtWrS/E3thiNTe3shdXqg6\n", - "trdkQDanhMBA2nXrOIbnp5p/qSdytZ22OcHuQ164yUN2WWnXYoh/LyxCKuCqYnUgCg52Fdv1TK/q\n", - "OQjpkzuiXEhtCdAp3S0x/H6tGcnRP3UhIazh+oLS4HxFHrZ61gTUqRXCdocQ3kLJ1jl3UEqiB3Ii\n", - "ytIXp353euNAQk2h5J5JiD03aVTYLiuDdaiOvhKyNcmjuSB3JfpkJDmkChBk84mVrZZAmEq7PkNy\n", - "meMwl/5qsPtVcmwLkn1X2A6eea1UMXi6B/kDGZMNfrsn7Q9kWPRxoeO/Z84ruxbRik7UpgtcWHd6\n", - "K+Q9KzJF/zyy0LSaO86jPkdAhNKphcGffjjDNe1at2955PDhE0Ok/uyv/q1zzrn/5Q/+VSibXfhd\n", - "nSpbn0Ee4aWPfDyUPTlFSPLc71zHgqrUaPdMELy7xx71SuWelKlHZJQQOoF6fF0bSpKjrUlhyFUO\n", - "bKPufb/evWuo2le++BfOOefee+edULZc+HYtLuW82Oke3bAd8Ruf8mjW7VsmiUACeC8IQ9lhjNeS\n", - "UBP5Ljl3M5HQaDacQxIuHyAWGztrBBvo+vPyq7f9teaSE6+B2vTI+j2sCkQ9WxtXHz729/0TL71m\n", - "ZTN/vq+dG9I4qXBPBP4pMRfGgnBvnG/bqrEAjBLQeQdlc0WaUsyJdkBsRr9KUFBohUb/Ax0q5IRU\n", - "u88yfRTieYJnR9Jvz8l++5EkgVDyLFKgix6WTtb9dPsR3AEeSlOSs+34HM+Mjahzsy4bCcCoG/bT\n", - "dg6/QZ2vyBo459wSMhaNoHkHB358ME9oIg0Ln6RfKwT0TKXuK9yzVurOB0/vhICPfk8HhH4GNJFt\n", - "Lyglxngp/T8BYptLZoEK4yodZCVBYMdLRkD/4NSP8dOFBGp8nzeliEhFixYtWrRo0aJd0+KLVLRo\n", - "0aJFixYt2jXthbn2RuNyoAUyB9ys5PAkJTlcFFMD7Kdka8KDohmVbP+WkC1JfIUkVKTLLs0keWRO\n", - "96DqPfmyWojyJdx8qm3DBKpDfRTWggRHYXsTxlYl2uDa1GSUTPIrSrAJNahExwXQcppbn9AFNap8\n", - "3VT3g7obnTPYP+3Gg++ccy4HFJpJX1PvpWmsnrMTTyK+JUrd1DSaiCo2BUxIIg6JTZ1zI7hims6I\n", - "vUF3pJMggpwq6kZ2JNm1FFI+3Vyp9DuVoktA0Jm4MRK4T9a9uRYzuB4LIXZn+K2SzSnBohpIlH7v\n", - "RMcopwJy6102q9RcHBuqswsBO7gW9Ly4FZ0oYNOlvRK3YANi58v3jdB//95HnHPO3XvNk8y73Prw\n", - "/NQTxo9umLtvCZL1SgjoLYidJ8+MsMlp/E/+s18IZb/2Tz/vnHPut/75b4WyJ2fv+eOpsC4uuwzz\n", - "OpEAENeAxDy1zl6c+3YtRFk7hz7YnpDHkwkTk5sLLm3oMvD99d63vh6++/Lffs2fK7Ux/OEzf/xy\n", - "afU8QDDIRrIdnJ3838455/7Bz/xoKHv11U/4a/XbCa81yIYJpDlyxxNTJ18VfnwUos/GT5u1zd0c\n", - "86gQNzbHSX5o82+N8aFrDBPUTo+8u6NfmGbUzSNfl6IQwvjck9iP9oyUTkXzfE91+eBaE3dPiVaW\n", - "Mp/GHVx7dNnIGtbCBdq2QjcPbk65Vgj8EWoHM2D0uk7CtTd4nvB4UED0EcL1asDOBt1AHqcc/4kk\n", - "ks+obN5tP5OUPs+gqCzfTvxLBXBFQNZYO1qhsdRBWk6eXXRjynOCGl2ZdhOCqxailD6dog5wnw9V\n", - "tNiv1taqoDq5qOKv52ifuCV5z6Sepvxu5yMBnpqBibhii6DLZWtSDzL6wYES0KEZJ8E7THSsGmR3\n", - "QEAvxbW52FgwxC6LiFS0aNGiRYsWLdo17YUhUkWZu33ZVSUg4i4Wgghg565IU0BpBmcjciO7um6b\n", - "bEiZAL7h843fOVNiHaAKqJNKLYwgiSAv3y7LSQoVsjN2Xaq2TrRtsdjgux3nyO2WJBZrG8oqsN5W\n", - "glwlPSUJRM4BO4JcdnMdkJWOZHuVf8Bb/VSGRBnIeduk+ESkHrirVcLiCpvYcwkTn839bna6J6gX\n", - "4n65wVNyPK8xLo0IWzToYyFpFiBAjlVWYezLNoWQGNe4J0Ie5a6XpGMn8gdERKVbXYJ8hdVEyrBz\n", - "KTJFn4A0DJTNcZwQhY+BjqUghy5a21WN8bnrtQ2+bDKxnRZJ5o0oe2vKStrdB/fQBisrRiSREgXQ\n", - "tm5HUcyQh+ryYiEH+jZqUALH/bvvm7L562+86pxz7uj27VB29tSjXkQ9B8gAlJgHAQBcCySHF+s+\n", - "klx7+1Ax7lZGCp+OPGLSjwyR6TFQK6DK3/zGe+G795/5a1x0T0PZ4U2P5o1v2jkuZh4leXpuffIA\n", - "6Ne3v2qk/GrkJRH294RQj3aUI1Wb93+JVm1koaBifiO5/pbIBrC3p/IP2OnrzWZQiqCUlB+pGxtj\n", - "h1DbryCr8ESQxq+87VG6tz98N5SR0Hs4seufQdm9LHVNygZ/nXOuIiLVGpq0BrJNInSq62TiUYVE\n", - "6puNIPUiGgI5kNWRxARtOCedhORjbhWD/H/D54k+fzivBNQI6KA+k6ieXurzJKUqv4xnIHdK3ibH\n", - "v2DOP5Gm6HGOWucE9QIE6SbC1Qpy1rIjhetNFHugdp5wjbfOW2HJnpTb44rZBnTutiFfoeRVbSC1\n", - "kRhy7BBIlKosPEwDdaZjf43ZDIFFKmGBc/Safw/DY9PaPD0ce4S1EdUhyvhkEhQx6f3YaSXvp3pq\n", - "dllEpKJFixYtWrRo0a5p8UUqWrRo0aJFixbtmvYCXXtZIPo551xOpereoPjVCoTtQYJiJP5V3wU9\n", - "YJ26hbb1jqjRtA8157wyyJTnVYFbQuEKT5fgztVr1aKABpC4Ks1VpRgkIGPAviL747KMiRKLq4eH\n", - "BJj+tzyvHUbXmyqxjkGyLUTviDBuCxw3z4wIWFYtjldyIuor5Ni8oMtS+KXqfgAAIABJREFUyMZ0\n", - "QdVyTwDLr+YG416cez2gycTIqxWUv2ucoxbXFt2tWS9JjvHunyZCIoT7rMi2XaCdkE2pCt3pOAmQ\n", - "Pv6KbysQUQVGp+c1lftEsnuu+HhwqSqxlXC3jBO4DSpg1aNaCLMbuKI18S1w/9VKiNVwFVbi2izy\n", - "Ka5lZculd2ns3zDImqRtErA1sILaMRdftfu1jyS0lbigZ+hD5d9yPn3n638byv7Vv/zX/oO4qmbL\n", - "Neqxh+trX0Ofad9cRoFkL329WnuX2u2DO6Gs6beDTYJ+mfhb+rk/7vH73n334TNzz80xP26+aq5I\n", - "V/t++uuvvhmKXr7j3X2vfebToeybf+21te6/ZHV6+tS7uQvVVoILfrOyxYBuhhzuuaFmm//bido3\n", - "lap1nchH25o5LiiWW98xKGY0NXfj3j5I5nDZfulLXwzffXD+yB9TGIm9QhaDRBbPBjSCRvwodIf1\n", - "nbWfnu9S1iJmKuCym8paw7mjbqQs2e4nZlHQQBm61GtZO87g2u3F3UmyfYbxN5AixPqQiY4RMwro\n", - "2sm6V5I0mG1VvT3X8llgrsoc504dXZGyhqGNhegYktLQtLr+8hqitg76RtvpQ44ZQIS+kfP6EpSD\n", - "ZN2Lla9TVSkFghdQbS//txa6AXXEUnGZpaWfE/rsqPFg1OTS1chfZMrsALL+jJCMuxxtR3ZdzEWB\n", - "H3ps40J4GZwfsnTTzd80NiY32XY2DLWISEWLFi1atGjRol3TXhgiVVWZK2VXM3Ek7Nmr4dmZ3y2s\n", - "V7bTMhK55oTbzslnpHQhikP5ejyFwq4Qdl1CYvlGyvhXVJRH3EGKdADDejWvU8jrp+H3vr18+1+L\n", - "YvcYuebyXNTesdPsB7tqIDKqzotw1VyJnejaTFSEKRmQp5RwsPqSnN3LTr/lLkHVcfH1gNgM4ud6\n", - "LWhCBeSwFkmES787ne8b6sidwxphzSo1kADiKGScpIGwqeGyVNvV3EjYkaZW994t0BxBbkBkJ5jY\n", - "yW6RStS5MEuz0rehEpmAFAhCVwtKQEanENCDtIcoW5O9moBgO85sp8kdbiayEqsASdg5VgvOE6v7\n", - "CGM7Hdlx+whFZw5J55w7efLcOefcSx8DiXVl9b13wyMtz589D2WvfOYzzjnnXn/9QSh7+uZXfX0n\n", - "toNdQ7LhlddfCWV//ua/cc45961vfyuUZW6IMBXCIl2BsNwJgsBu17yCRK4UETsGqtLIUMv2QXZd\n", - "CVEZZNh33vFIy1981er2xme8dMF/+fl/Fsr+1//tz5xzzn34J/86lH39K99wzjn3HwtK+emf+DHn\n", - "nHNfeesboewXPuERK6reO+fcau7z86kqPdG+DORhIm7OOTcZM9uBBDGgUzpBUxkmXkiuxxqoRyJh\n", - "5WNkFJhKTrISY2e59nV6dG4BAwxKOb5xHMrOZ/64VgJbiDDOGyPq15AWqQVNS1K/3o4EEaFS/IhS\n", - "N5IyoG4QHJAaqjFmDk/pf/Ku94TEX2BNSkXZ/rj2n5+eWj7FOZT0N61fk1Rqh8hZKYhQ4nxZVamH\n", - "BXk9hVhNz0UueVpTEJs7CZ5IAuruz5EK2z4FmjLIPzvxdakl2IdOhFSzQgAdawX17yEJkMsaO0af\n", - "pU6CF7juQ35hLnNofwIEayzo1y45H0qcCHLJcdyK54ZSOGkpCBeeI5TuqSp5/jIrRa4aDsjJKXI2\n", - "7z/9jnPOudfufiqUVVhvN40FICR4ZpSyFpWiRr/LIiIVLVq0aNGiRYt2TYsvUtGiRYsWLVq0aNe0\n", - "F+faG5euKpQISMjUykgyPzsXLaJLwNPJ934HJGm1qERbCHBgnm+2rpUGZXMV4IEbSV17IGrmhR4H\n", - "CFYgyySjKroSxQlLwmUj7iGi0oPzdr5+6u7qgnq6KOEGxXaDIkdw1aWZkT2DYi5ce50cn6XQZ1Fi\n", - "I96zlQCcgMRYN6r3hfNpJk+QKBMl4G+oY2N9skpWOJ9vY+22NaaCJo5zLkP9NgKFk0SYyZjogxaN\n", - "uECYoHgQUeD7c4R7UYt7JKgnC4kyBcZdSiJZKsbXci0S2nMRr6eicCtCLjmUfzP8thd4ftNSn8XK\n", - "qBnTCTm1xnHTQ1OWbtk/g2AHf435TDRRJr69X/rzP3HOOfeRN34yfDUd+7b+zA8bFP7ec0/efOVl\n", - "c+3NLv18enxixM67H33DOefcT/2EKXs/fuRddU+fmLvnxz/xKioMOL9VwrCv+1oI00xQmwg5uOQ9\n", - "GZl7IrgMRIG7ZhJucQGsFr4f3/3QJyi9D/Vx55x79PAD55xz/9V//c9D2cNHvo2nT42AzyTAf/M3\n", - "XwllFZKmHkuC5jqDu7GR4A1+p1pFmAst+mQk69QISZ3PL8wVVRbUDLI+4fBIVuJugpu/79UthXVP\n", - "E37f8ImbG2hw3TgyZfdHp94FOpbk5hnc6CtRws4htNatbAJkCHxJUht/TKCuOkplDZpHzwAYIR1j\n", - "LRjJmkDy/lhcexUIyJWogmdjPz6ykbmKRxhHlSTLPgWl5PzCu7Q1EGDEa4lifAl3WyUu87LyN6AR\n", - "33KCtU2GuGuRIUCT63YgjTNZcjdQYseYkMTnGbM4yNOc2mN5anUP8l16/YYZJeTZhWCAtJcE8ghK\n", - "YQ+vJIiAyZLXK3HtjpkgWugeHJMy//gIKlSXCuttKe7eCn1ycMTAAhkvdPerCxRjspfO3kAz7Pnl\n", - "w1B2/8Y9VEozNfjPqdRzPNZ1dNsiIhUtWrRo0aJFi3ZNe2GI1HhUhR2nc84V2FUqSkUkqOkMkWE4\n", - "5UpyXQVJBEVEKF0gob7lCATMkuRseTOG/IBG8PPNXVW8ExAFcyFxc/efZPpG7K/b1LKbCEgIdgvy\n", - "Vj2eMNRe2lWQgG+7jxnIg9kgJyEJ+Lr7BCIjIaQd3s75oj/SkE6EveelvnkzXtlKNtiJKDmWXOxu\n", - "sNUC+iUhwVMqlAuatMF9JHe8kXxxE8hU1KoOj9DgToICSArXPI0ZiZpS+YJK9kIeT0D2ZA47Rb/C\n", - "ztDJbh2fR6Up5pJEWibWnx3Qt0zI5oEfLERx7khJilS0oMe462sZ/8yN5swmUNFWRJSyEiTuOmfk\n", - "5UzIxivkP6R6/hkQB+ecmyAk/mf/oaFK/93//HvOOefu3LWw/k9++qPOOec+1n8klL3ysv/85Int\n", - "XL/2lid7ps7a82Of+SHnnHMtiL3z2Uza6uum8iMkTKuKfIbggclEFMsxyGX6uREI1b0Er7zzzbed\n", - "c879n3/qifAf/4mfDt89Qx7AP//iX9u1sPes50YA/x/+p//ROefcP/un/0Uo+9FL38b82Or+DhTC\n", - "7+xbP50/97vj5ZmhdC1ykZVAGvYOjdjdYO043Df08fzcIydKQCcZWdcpjoUis/FMFGt8YORtB0Xz\n", - "dOPv3UgkNF6+4+/7QlDlZ6jT3sRQnScgyBe1ho2TPO22ynIJsmDaiBHqPi5lrauA9Euof5oB1RH0\n", - "m4iUonl97utXbCQnJ9a7slbU04+TqvLrz2omEQuYi6NKnl0lx594OIDENI0ESqB+i0uRqVhiHRXU\n", - "m0EjBXO9thocgLUmVc8N5nUmkhSVv0+rxpT6M+fnVpvZHGsRcDQSNLfH+qwZBcZ4ju5Vfo6tOuvD\n", - "kws/dhO5sSkDmVKr+6jkM0GlFuC5UPkB5s5dyvWRz3LE9wNBy3hdVVFPg2SOPDt4zwTNn818Tthq\n", - "ZO3p4XVJpf1F+b1flSIiFS1atGjRokWLdk2LL1LRokWLFi1atGjXtBfn2isyNxKNDyowC4rpxoDb\n", - "Dg4Nsl+C0Nhp4scN5b6FAI2/rbiK6O6ia29saKYjebsXsnEKYl8iuj/U9MgrOy+VYntxmbRwQaoA\n", - "+6b2ULkR61ULh8RSg4ypPF6rwit+M0+N7MpkjcUAxmeFRYGXekslXUYGexYZ1YQFCgfsv1Z14qCP\n", - "JDcKMKsS1RMkC55Iew4OvS6JKnVnINcvqQUm+lAZyPZdoklGoS0jbtSeZPx+W7FWBHBd2TJQQJSd\n", - "6aKAa7NT1d+Erj3tJ7igRTGZiHEvxO42oe6J7lWomCx9h1M3GNcXomM1QvvztZDDG45JO+9y4d0o\n", - "o7HB07z/vQQlbODnWooq+gSVnx5799HDt98K360xdl59wxS7f/k/+Y+cc8792Rf/KpRdAgrPxLX+\n", - "zb/xiub1xtwYP/NDnlj+Y5/5+VCWgdh6fuoh9vVtUT2GSzcrdbxAxXltbdjf8+6TWpS9O7je9pC8\n", - "2P8IpNgL68+zOYjyl97d8WlxDzUgz6rGUUPXnkzsjyIZ83/6T/7zUNYiy+taCNjLuR+T031b92aP\n", - "fftXS3O3cHu7XPtxv5Q+vHET7nlRoKe7txPNNKqiX16aBtgB3IHVaN8uRQqA5uyFm3m98EE+pbhC\n", - "MrR7s7IAoDuTu845585b0UxquMbaItsgsETZEzmCXDQoh24k+ifHlbqxcH5RFk8zJq3V7MZIhiyL\n", - "fFb6cTKa2DxZIbijqO0ed+lieH1ZVzn/OtEnIh2lFGJ7ApdVJu52Bu8UclyPR/BG1uIatIAlaA/7\n", - "h+LaxDNuNJI+AR1gH/fBOeeYF33dmY5bUvgAhVVrbuQ5iNV9b+2ZInuBE/26CjQcskFKWSf3pn48\n", - "P1udhrKsBjldgqc6ZM9QtXe6numedU7I9ZpRA31HScNE7n/fUzNS7hN0n0g6d865tmFieqGl9NAK\n", - "SyUqCGt316u21I4s8GIRkYoWLVq0aNGiRbumvbhce0UWcoQ5Z6HuTgheJRRwK5EwYJhmsme7/9mF\n", - "f3NsZKNPsh/fVnlN55wrSyIDoo6Kuixnu0jMmv8OYdqCKnQ9w48l11RNhEMUwLFjYt1KCWFNqXpb\n", - "2m6JIa6KiByAgL1aGSI1n4GArrsfvHyrJEJ4m8dxbSvoF8PwBVUhmrPc2LUodZBJWGsKNfZCiP0Z\n", - "AmWPbhpRdg/IgeaaYvWYk6sX9I2E+k6YiOxOJZaToD7IyQVoU9EMShf0Tu4xOopgiuZ1TIDSZSqJ\n", - "0TOEXtTRM+Z/1OAJf58qIaV2/Qz1lR0pVeZJNhUS9QTTMxVUL8VvF3NDMKhi7lrrJyIMvY4/7PRm\n", - "Ih2wXEFRHujj/Qe2gz0Acvrud74Zyu7c87IH/95nPhbKGPY8E1JuAaLunoyJpvY7/UsharsMCuyY\n", - "1+uFjbUx+m6zFrV55tAb5J9E/kdVkcc6slqIKjiCHS7O7BqXcxKg/Y60FRX/4xsewdF5lQAJ39sz\n", - "5Oz3/uX/7pxzbn5h92T/GEiL1DPkv9yzeh7f9lIDq5khR0HaALeuFaTv2VOP3N27J8r62J2r2nW9\n", - "8fc1KXTugMQrmNAYMh46TkjGTYCS7R8bgnVW+3ruCyJyWvv6zvSe4F7sCXK7aEZolubT9Pc/l6wQ\n", - "45a/AbF6oCKO9Vdz7WGeqkegBnk8FRLxCErVvaAPRc35ZOhDA+SCsg4bgRuY17BvVLEcf2VN5JLV\n", - "iYo5x0KWbHs9FGGkdErbUB1cZF3gESil/6cjH8KfOkPkGdDR1nYcJSmK/mYoqzdeWX9dm5zG3p5H\n", - "tjol4MPD0GfsG0EpIesybhVp89ffyJq8x3GaSQQIELZM7n+BgZ/Ks4Bk/ND/EoDmEDCk85TRS2uR\n", - "kyEZvZc5zlyXTWdrFz1hq/Ugeaj7XhYRqWjRokWLFi1atGvaC0OkksRQGOdMTEs5RWXObOX2vjdi\n", - "GKLsCPb2/RvkfL6dp27wUstwfiAMvRID0u08QMzhN0SksCMQP/cGQp+t5JVrgYi0wuWqUSd+V400\n", - "YZJvVyEKjgV877287x5AGG2ztvDnzcbvJopSfM/gQeXCJWrg503BfdHM6CWECztBBMnDGcmubrn2\n", - "u1SVNRhBfG0ufXL3luemEIVyzrhJ6QD1wX1qCrRBdtq4vqJEzKHUSbhwQ+6Zitoxg7u0h2hnL4OM\n", - "yB03jhpCSymErtL7un1ejrFOULIcu16V8+iwY06EX3G58DvhCr8te0WwCCFaEyinoPzCCfLKaQxx\n", - "QuFKZ7uvDnUvhHPiguyC/24jaOFNcCVy4dmdPfPClf3Y7muHcPUHwm9qEuY/s/t5fuJ3fRMRM5wD\n", - "WVsAkelviNQHhEP3hdPCHI5LQdVGqMtauDwddv8Hx1bPNZCes0tFqZBVHsjZam470/sv+Z374dQQ\n", - "mefgcmm4/hf+2//GOefcT/7kj4eyozte2DMTRPgWZAUOblsOs9HK7/7bhSECHXhtcwhCav8zr2Qt\n", - "vEXuhxXhzwoip8J5DIQ84TKiu9NMeUB+bU2R/zIRjti48v15uj4PZRug49OJ8dGICAv24DZAxPKx\n", - "yBQUlA6w9azLPf9qufT3Ipd1LYGXQkV9Q2S6rAk5kWbpuxxSCKWIb66RM64XflcfZCe7wR/nDFWq\n", - "VVQ3g/xIrki7b2sr3KcWqFOq3B/MWeWNpi3FlJHDUNaLCYRee2cctXLkUc1OtD7Ide2E85qmvp7r\n", - "zrhMo5KcO82T6e/tZGxCrG0DHh74erk+k+Ex6oW3tAIi6jTXaUpEVFxHWHhVkHUMGY31cnvdbyDN\n", - "kLpCvkIb5HCC/llv10ocpWP+X/bepNmyLK0S+05/m9e4+/M2wqPLnoAERFKQqIqCMpHITAMKmcxS\n", - "lpiJNNCYCQPAcsiE5A+gEZLlRBjITKIxTSisJLCyGiCySAoIKjsiMiK893D319zm9Brstc63bj6v\n", - "TLMnS7lUtr+JPz/33tPsvc8+Z6+1vvVpnVygf97E1vZgR9TNZ9CRfD4iIhUjRowYMWLEiHHBiC9S\n", - "MWLEiBEjRowYF4wXRu31QzfVfDMzSwD3DQLFMYVVHXtLQPF9p3gr0lQH/15ds66aUDAQWRaguxJ1\n", - "EQdUr+LgjsdQZ/OUNeR8G0WMm/68KFCpyhEpox1qo7Wd0BOEIkXEnKJ2VCHdVMBtumlcxE0ouhtc\n", - "RFtVTJOXWnusq5SBWlAbAoijW6kNRaG+ut4OEBGqs3mxDPs9vOKQ/bVrgRbZqXWFfswE7iX1SfuL\n", - "onTYPeFva0lDBaU2iDt5BxG30iisWZdVtfwWbSIUANnlaYssLVJQoVrXkbYLpaREk4LLRdieA+bO\n", - "BYI20Cy12Ofvod0JVWejWPzCRT3VY1FYL6nerGdYSQ2xAWNXIXOjY7akhDeoNTcgXfj01GH/5X6w\n", - "HdFU45cOw2+Lhe9jfnAtHF9qoh1eD6L19an33Sncu4fRx9jpSXD7LkDFdI2P180m/PZo/+VpG+9h\n", - "FUc3DRILZD5ZrVe4Bm+TDu2+EVH4tWvh3H/q06HG4F/Dfd3M7PJRqBf4A5/0+nt/+VdfNjOzWtzR\n", - "f/gHgz3E7dt+npcuhf2uIQ43M3vjR384XOueU3sNangtD/08F+tAkSZIvxYNt3UYa6cnTu3sgdot\n", - "pP5jkjKtXMYfxnMrNEWCe2YQV/L2SRAgd5tAgV5a+lyz2gQK8sbgtM8MteYaoZZPcV+vxNZgDzRv\n", - "tvBrXRbh3Ku506fFIlzHsyyMl2bwMcTakckotd4wj6YiWO6m4zot3OP+y4QCnS/D/npJ55/kDXDM\n", - "zySFvtmSivJgbUSTMUmbglRq3fUUVku1AQrpS6EviyLcWyXupzT1vmaVjUFqkjZDuIfmpTvms+5p\n", - "IeeeQAw/iCt4hwoIiXyvht3KKOn/BpnDiIoStGgwMysw/+yJ/UqCMdaI/RBF9KOppAT1D6VB04QV\n", - "DaTuKvo970nFSmUR0KeJjDVmVhXS1l41Q1978DxPVRZEqty/10l1iedFRKRixIgRI0aMGDEuGC8M\n", - "kRqtmWpKmZmNNIFrBEHI+Ubu2woIu7WC+oA0UTW4TLA6SgX9YOr+JHDbQWRoainnOJl6KayE76uw\n", - "DSscTdek8FOFzQnejmkSqiLCAULEXVFb2J/WATKsHA4PPYV1PgtCzW3jq9+0eIpj+jmVEHbT6iDP\n", - "pDYZEDRdwTR4C09SR86ona52rB7CNe7f8hXxEgLgvPLrIYqiK8J6FY4xYLWWqyVEwnaVVUW3wfd9\n", - "tdTg+NXgxx+Qkp+Vfu4tUma1P7myyiZxtsckitwRsfIvqaGYsK6eyffOIwJpGtq7FCR0BnH9sgpC\n", - "3VISFhZAoupjR3C2eVit9bL6ZfKCCoY5tOuNo5TbbUAYUlFR7i/D8fs6nPxy6WjJ8VlYCb908/a0\n", - "rSDqIEuwA3RZL0L9Zw/vmJnZ2bGLqBtaG+ysHEP/XDkKCMezJ4+nj67COkOruh8/CftTS4Aeppdb\n", - "WTXy3lrL8dtNOOnm1Ntz/zAgR//VT/+ImZlt1n78p/fD/r7v+93qYTFnarSjWq++8oaZmb10yw0R\n", - "v/n2XTMz++FX3U5i/6XQ/71YEkx14swjAz46R+3A47PzwvKNJAXsAS2Yzb3viOwrSpsTkRE7AQqE\n", - "d+wEYMRZYAwvxYzwShHOaTETmxogTY9OH0zblhi7gybv4LrKpSclzKswd5WVJBTgPGfzcKy7d/9x\n", - "+qw3mM/K91ewaUilrtsIdmIUlsKQyLEVk1RarMwXPncQfWBOhFrIrDEnjGJWOeQwddyxOkCyjyJS\n", - "QPPVdoe2D7kg95MVxMjaqGoITQRZkZ7QJr0gVzmQ7l7sB3og92pcXSHxpEgdkZzhOaogzCTKBhKY\n", - "jMr00JBZkD4yO3746VmYDmLJgGdRKQ/eFAlXY+/37pgRiUf9XTV/ppm2sBQpnvU75XcTovRitQBz\n", - "0HZ7PsmqEiamlKSN50VEpGLEiBEjRowYMS4Y8UUqRowYMWLEiBHjgvHCqL08z6xuHB7PQOPsiJ1p\n", - "oyOUGRHAXnwsCN8mAq2W8AzZcfuGz0cyUUwidmcNPdk2dNiHUAuk3tKd+nv4V52VKZTPhcaYKBWK\n", - "2QTin67fsdCRLs5yrAww+kz8hugEu1x4d1LP3I1C91VhYw4YNzOn9hoIgAsRjPYr0Ei9QNE5ayid\n", - "d/bdUwf6YovzlXMaKFT3PjmFf84c3i6JiLMLQOpNr144gLTV44MCRPEnoSi9qVVYG467Fadssnwp\n", - "+jWR8VLAg6UvxcUXkHHfizs6+jMtdJySKhZfKog9z7a+v00f7oES1O4oNsr1Kcap4tO4KeaVw855\n", - "CVH4uKPYNDOzVj2DsgCZJ71TRWtQqx2up1xJf4EyT1QcisHeCz3y9F6gsRqhsUvcC8tD9weq0CYn\n", - "K6GqcEO/f/9euC5pr7M1KCv12ClY7cCpmGfHgcYuhTKm2LaXvn7760FIvlNrbnjMH5iZ2X/zM5+e\n", - "PvvyW980M7N3HjmNfP16oAKzxMXWiYVzeXDX3clfhaD/ox/y7119JbTF+qnThz3O/fjMfZkSyBFK\n", - "0ONShsyGhoJl76fTs1P8zvt/Caoq2fGFC/9eFm+v4iDQp+rAPtRhLthCsN+sfU7eQ78m2v7rcIKZ\n", - "eIuNSMrQagOkjCR3wWbzsJ9F6bQk/ftKeNCt952e/uCDO/hLJQOYO3fq1VHsrAJ0ehDJPI25c+iU\n", - "7sO4T0DFiY8gqcBcePwGMgd1bCe1Z+ribfTxE7kFnmMLmbspaB9w/J2EJZz7IGL7DXyf2kZd7OFL\n", - "p3KXNPSj+l0xuWqQ8TR2EKCL2zolLRUSC3o5KVaK0GQP0sKjzP9FSm8z9YACtSzPDlaFGEQWkVi4\n", - "T+qGNKrUWp3qiurzF+2kxXtJLYqzPP+sZD6dqpHIcy9SezFixIgRI0aMGN+jeIGIVG5bSWtvscLo\n", - "encd7iCAVrfpgkK8YUftbWZmlSBCOUXTIh4vKorXKQQWZII6dEGfuHJITERnFVPYpdI1UKcd9Csh\n", - "IiUXDQdWvv1qaaAEbrdaVZwiw7r2FeGVxUv4nrfTbEFnXRcMNkCszmRFzrYr8yBsViEmVx9166tl\n", - "nnvXKKoGpEVWED1Wc4UIBrMKwsdEXITrsLJsBc1p4J68txdQlUJdnDOetzRiTbsEEcdyxSg2BUlO\n", - "+wlZzmHV3YlQM0XVc9awm5Wy8sDKWGvtMZ1W9O9WoKEUEaA9Q7tT1TysIrvR++5kuG9mXn9uP3HB\n", - "8tUCgn1BC7ZYda8730fesCbkc+p1yaoqQ+28XlDPlkLtbTi3S5dECI9xupYaerc/9nEzM3v4+OG0\n", - "jXtb7DnC2aKv14I+rU4D+rZt1EWayBltTfyzG9fC2JnNfL9bIHJyWVZh3ClK2EMp+/ih3ONAdrut\n", - "o7R9E/q7Wl43M7NrR57EUW/DSv/jrzmC87f/EFCqB8987rp6OXyuqMKHXwtWCJ/40e/zE30c5ozN\n", - "Q69deAw0b7vx/mwxT+zBvX4pdUXbOlxXLfd1g1qYmcx/bFd1lqezdyJWByP6eNw4IpbmrDIQPmtk\n", - "/iFinEpSzKIKCN+p3idJ6Pe5JIBsMY9vekeY8vw1M5OKFebO7jPYeaQ3fVxvgL5tGxci86etVJEY\n", - "cH8QwTAz65KACCajjzFO9+0OcgF0GuxI3fr8TxftWemC+Qwo/lYSAOr2GOcmaHZO9EufJ2AT9nxb\n", - "24Zr3ACdHqSGZtvDbV7YBIOIfcgE6e3JyPhvC8yTqUlN1JT/qig+NOg883HSAdmvYLFBuxQzswZ1\n", - "+hJhM2ZgGHqpdZmkZA4ETeLf4vY+TkiYMDFkUZB4Nsqxxj6M8VTsPwa4w/OZb+ZO/W3rY6IsYO0h\n", - "SVZD/xx7pPE7vypFRCpGjBgxYsSIEeOCEV+kYsSIESNGjBgxLhgvjNozSyxNFB6Em6oaTxiL/Ao9\n", - "AU5lEGFpAZFvXqoJFIpBFirsg98QINZMBIsJBGalOOEmCaBCoYfoWZFLMcge9BDFxGZmBu+lVFxk\n", - "05z+FBBsC4tEkfOgRWYncbbvd10Hr5ayvOY/hthxPvfrr0BjjKkXEh1IYxHGzM6L3QWdnkSvqVzX\n", - "AFhcBZN07E3EWZhGW10nxU1BW/adQ6b0ORmTAxxLi3yGf4vcYWwmAwwC+9JbzBLxIMMaYRTBZAf6\n", - "rhWvJgr1aWyc7Xgx0QtFfMxAe+RCC7d9oDETEZaSjhatq1MKkhSRQXm7AI1RiWMv6btG+n9kH4qw\n", - "nEzlptFEhXDgs7XTKCz0PJOixXtwyl8ehDZ+8swTQBILfXfp0J0wbBE9AAAgAElEQVSt//bv/tbM\n", - "zN74kHsrHT8N37t+w+mOzTqcX71ybxsWI101DvdvN/DsAQU1l3u4BH3SZU57ZKA5pVltQF83a++n\n", - "09NwToVQRjkKE2cC0++Ro0V/5lIg+fb3B1ruwVf/Ydr2T34oUFGpeLAlqGxweNm37cED6uSBO6V/\n", - "8P47Zma2fuR+SyO89PKZ3Lv4bd9SMiDXilMvRNqwbVjw3cfJfHKZFgoOYvDiSOYOHGuE67yZWY65\n", - "oABVnI3nKUP1fVogaeZgLf0EkfOpCMDn6ONCPADX2zDeLu35OXFqL2ZwzO79s4+98UNmZnb/obfr\n", - "ww/CPvJS6CkU5h2FAu/W8EBaigO8MQFJqCVIOWr8NhMqbESbdI0Iq8d9XLPek0xK8XYdjZ510qFo\n", - "23ImlTIWpFZRMUNo3H6LOaxUF3XMiZ06gYdtWSfUHuQYnbSJTYkk+jyFzKRVqQaouo7POi0aDcpU\n", - "E7CYADX3uWNISHeKZ1RC/0RJ3sHYVk/FFufM+VQpyyTBWJS5M8O2QiqV1HBlH8THrm5YcFsexi36\n", - "UedYncifExGRihEjRowYMWLEuGC8MEQqSfwN3cyshTi3V4EZ39zV7RtIRya1kSqsNHNJU6WLail2\n", - "BkxZZRpm0msaZGiKXhy7s4yrLn37B5qVyLFSugj7eeZwTB1EAJ1jNUNhZVmcP7dx8FX1FvYQuQi2\n", - "19uQYl0duCiWCFO6o17fFbabmdVYufLtv8h9VdmNrFclacUdU5jFRRqIgDq2EyUaxTGXyJpaUowU\n", - "RUqdqIxtkBDpOv/m7/1gVmFV1YtguyjpACwrx8n+wffTA6VsRdBM1K3AZ7ryKLA0zipP66agORG3\n", - "fdYOHMzRlz4JvxlFKFoCfUg0dZvH7Siil+8D1crE1qFHTa5a6sW1ELErIrGByJMopJnXq+pl5ZgT\n", - "zcGqV+sKlrArOD52VJHj6u1vfXXa9JEPfcLMzJ48vjdtu3o5rFKXIso9gUP3vtSa2zShzUak6R9e\n", - "d7uA+QHQVHUCB6qXa2IH5oQd5A792AiaPaOzt1z/6VkQnr/6SkjiaLfeh8uXgmP59dden7adPQvC\n", - "2pXUJLyyCEL1euMi9odPQxLB5sy31R+ERI5U+rPF6r9vfNt6FYT8TB3fX7pdA6fstvXv78EmgEL0\n", - "8Hdo68WBo2SzReiLTKoiMGsil/u5Rdt1QDgVfeYqPRdEbB/3Z1+piBiCXhHs1hhrhfTd8SbMZ83o\n", - "qNMiw3livO779GfWhu/dOtKkkHAvnNbf9E1pOH5Te/t3HcadIGJ5iQQUQZj8cYPrEqQ3H4HMKFox\n", - "Mv3fnwl7s9DGaj/S9B/g+yJsRySSzs/6ezZV9vA+7JAcMkhiBV3OC0HzKexuW6lKUSPZQJDzHvdM\n", - "WUr1DPRTojYBSDJgnUatV1oBrcp25trQJ8kgiRLG2oWSFETWSRCpoWFNQE2KUaZq120+n/yH9P7n\n", - "ecqxwIAlcv91OO629udJCfd+k3MfJZHheRERqRgxYsSIESNGjAtGfJGKESNGjBgxYsS4YLxYsbnQ\n", - "GMkEJ/q2nCK684yVDamKjeE2OwoFADhafZzos5JkFCerwBDi5Od4bHRCNxL3HQelAOlUroUUAWOK\n", - "j0gJCHwGylKpPVpsD7LfyStKHZtB46237ve0qG6ZmVndOmRbzbFvccqmyI7UViK0Z2vBM6UX2qko\n", - "KMoUsSmaYoeW7Sjic8quHcO17omLdAKn2nornjGrM+wDgu3UfZQy9GcqlOmsDHRPrYJJenapK/vz\n", - "xIGTyFiuB7BwOrHIQk8Azh1HpYAxTkUwSjHuIP40Np4vTE23ZUGWbQEK8HAZritrxNsLh83FWbw/\n", - "A8QtlCkpnfVavYXC341UHt0/DMdYC1XXrgJVNbn9Cu1SbwI90kkx0MNLgbK7+fLLvm0/UDGleGZd\n", - "QsFhekeZmXWg9hqBydMy0AKsRJAmTqN2EH1eExH3GnRnLjc2i8GWQlk1KCrMAqhmZgn6vdm6B9HB\n", - "MvwmA8Wx3XrbDO8F+rI7cXrooIS3lyR23L/zdTPbLaR7/CyM56tHTmOmly/j+9+atrGAdSWu4MtZ\n", - "+M0Gcw2LcpuZrbfhWjfiwUdB+Z7Q+KuzcP3LfT9+sgDdLJRJBgH2jlM/bwZ6domLfYJz0iKzpF0q\n", - "oYLmuNfaxM9pi3shLcVHCe1+evzetG04CEWy96swrgqlnTCdtL2PqyU8wLJK6NHu/XCsrbdTD6+u\n", - "XPyGuoEFb6VSBuj4LGWBaim8zXwRSeJxvznfVOC6E/H7641t7ec0ThSZiPeR8NDhvh57b68OxcV3\n", - "ki0oUdkRYCMpJhX5BqUaMnfQxy9PfZ4e+dwVCUaCe3GqwNH4GezNMf/KvMrhNAziGI9na995342Y\n", - "JyuhRZlIpN5erB7A5KFS2j/FM3anFjorReyI6Oe45vMu9pvakwKyOaVCPk7GPorNY8SIESNGjBgx\n", - "vifxwhCpYei1XJqnlcuqhiLiRoRmFJmqJQIFzepAnQPFEV3b5Pw81WaS1FDWXxpEdEmd4CDNxPR8\n", - "rRc0EGKQV+JJJy/u4aytR7QslZRbo7OsXANXjq2gGgmWZCsRtpZ5WGkmYslANGXoVVgIYSURJEnr\n", - "Z00oRXL4Bt/LPuZwMe7EbZtv7lqvqkStMRUvV8UM+5UVFlAcrjD7wVcrvC5F6VIgEYXWhsKqZhRh\n", - "tX8myCEQqzLZ8Z3gmeD74jCMa9TEgjQ/j2pNoswdE3XYOvS7IkkzXxmauXg0x/UvRxEWDxRR9+e+\n", - "v9163w1YuW5FbNwh7byV++TpaUBJZjNpfyQ+jB2tMfyemAPBOhVhezEPKEEvbv9rIG3FwhGhu0hJ\n", - "v7TvYvMbt+Gon7sr+ntf+0czM8uAXD19+O702RKI6ckHr03bLl+9Gb5f+GqxABI0SFJGVwTkbD+X\n", - "xAbcf2cr9aQIx9isAxK1vPXK9NFQhzHx9NgRpE1GBFXGOuakTtr/6tXQFvfvOtLSAh1US4YCiEEq\n", - "CRXbbjfxYlao/QesTiSte6qJKI79FCwvl4505ai/N669Pweck9p+NN0G+wjbNnIPD7QrEWH/Ekiz\n", - "iqgXQHjyVOckICKCSNJipl456nOWBmuDzfwSzsP7Oh2ZlOHjrwJilZXeTsOWyLUjjB1QymTj9xhd\n", - "1HNhR1i7s+O8ImL7DfZXyDxNO41RrG4SJO0MCpxjbqHlgpkj+yroT7BtAWuKrvX+IjnR7zhtcx9S\n", - "p5TVFnaE3fxXbIcaWEKY3OOYnwdJxhoxJjP0V9pJmwBp3tv39ud46pVhIUq049ROhN3vyQEo7ZCI\n", - "AL2noH6BK9Zai0wUkmcnfitOO9b1YGIEkUtS2l/4sbZNSBSZlYLSCdr4vIiIVIwYMWLEiBEjxgUj\n", - "vkjFiBEjRowYMWJcMF4gtdftiM1zQNtKTyXwJarEn2Toz0OhI6DSQkSMacrvqY8E4E6jsPu8iFiF\n", - "xdN7psKjU3FjOT4Ei5mIx9MtBHjqHk7PFvjiKJyeZBAni+8KvUCGzqFtgyg86b2dTuE7c5C5AG8L\n", - "gWqv3k70VqIvSipFGSdYVOBRIKBVIUYuaLNKXsFrUK8KgRMCHkQwmIECSDNxCgct00Morc72PV1v\n", - "e6XikDAgFNQk6Bdod4KR1f6D7vVKLX4btJ4J3dqjDRNxdicCraL0aXiojwp9TAb1kQHcL9QGWdMR\n", - "9KEWnuYYNqG2s4yeNQLPgyqsROxcwlttVFq6ZJKDb3uCIrAsGt2LP9HpNvTJ5eueAJDjGLfFW+mV\n", - "1wL1tt74ee6j4e/fdW+pGy8Fgfri0L+32Av0zVf/5itmZvbhmz6GZyg4+ujuP07b7nwtfE+9qPau\n", - "B3FyufDflgeBUsyFxq1A8136kJ87O4BzjXrcdCz8m/n9Vw9hHyyybGZ25VrwvlJh/d27QeysdPey\n", - "YhFmp9sa3GSZjF0O7Rb36fGpC2Gn8e9bJuorE8qETvmJzD89fcm2MiecIaFAKwBgbNcoZJ2JsDy1\n", - "827r7YZj0sf6gvOp3BQHoDEX4guYIsnmTKgV0nxP54FiEb3y5Jmn80QGul0L6RZIMugkAaZvMHdu\n", - "xAEc97sUO5ikBA2Sd5RG6jH/bkXEvqhAaYlUxDCfW6q0POZkuf6pCLQUnGYiRQ4KTr0Au4YJMFLF\n", - "Ay7eVelzB4XdiSSqsLixJkrRR8lGv54Mz6dR+Sy0rYvT/SMWNa+Ebub1pArVYB8qC2GSVS9UcUMK\n", - "ThK1Jtpy4ie9/ytQuo1Qy5xju176vyeNJ8ku9JssZE4eURhbflsVWiT6fEREKkaMGDFixIgR44Lx\n", - "4uwP0nESeJuZ5ajDpBACnboTsSno8SY6DP4GXQNF6sRtmrXw0kRF6ahT1J133TauDETEN6Fe6o46\n", - "MDVUxYF0bBX0hdYCgiZltotSJamK3uiYLuLogm6yfk4d0mnHHQF6WAmrULqH8LGtReyMtutTpjX7\n", - "GzetGHQFSdRD61AlKZEeOafJEkIdqCne98OXJfpHrAMo8isWSEPtVtNnFWwqRhHRUoCf57LSmlAd\n", - "WUHh71TGU4dVjabJFtOYIdQoQnAuhWWlOaL/M7EJ6CFYHGScMCV6lAbou/PJAxS59+P55IgK4ukh\n", - "FQRhDruAWlKT0Sd14xdGt+Nerr/ZhrFzJjYJOUTbZ2dBiD5IskdJ8W7mosvv/8FQf+7wkjuQP3wS\n", - "EIT5ngibIQb+/k/9iF8QEJFWUN8Pvx7O/e77of7cl//a69pd3Qvfe/2NS35OQNOSmaBEQBhONu9P\n", - "2/bSV83MbLGQ9GcIrwtJHi8WEAATYhEX9dmN4HZ+dOBI18Ov/52ZmY2Z1zA8PQlWJFpC7TL2u1qJ\n", - "TQUTQKTvmLTSy49n89Du1f6u67yZC+bVdXq7CgLoRtAXgglzESCn23DOiViSZJuwrTlxp/YcNxSd\n", - "1TvT+4815PxacyARR7nPCR+sQzLMQmFaVhYQRLhKwpic9Y6mtGkYi0+fvYPviyVLGZDIvpFxDaRn\n", - "MJ2n6dguySOb0O+JIOI1kocSQdPohk3bh+1K7AqASCqqsWno4u7HYqKO2t9UQDE7tf/gPKHJM7QC\n", - "Ql8XM0nYGTHu9f7H84dVH8JO0E+dVmAA+i8u4gmO24lNQ1uH6xhHn4uJUiasdSlif85ZJ2eeRLKY\n", - "h/NsB99HD6RplOceJ+Nhxzkcg7fXZzHaZJqn/Z6oiTRKAsw4VdYQOxv06zAIIllgnpTnVD69bwgT\n", - "Jm3xvIiIVIwYMWLEiBEjxgUjvkjFiBEjRowYMWJcMF4YtZdbYqrOnSgt5TZISyjdxa8JPGsQBWrB\n", - "2R6fl5lD2xndZnHZjcCZWXoedp3cxkUwTS8U9ZGaqD9RgJYZqS2huxIKgEmZqZswqDWBjEkB9gqF\n", - "9uehzRQC5G3jXizleIhjCY2Dc2KzqhcOCxir7xUpPWERLDWKPdUfK/y2qb39N5vQ/ipA7FCQOZVi\n", - "kPQ0akB71SjKbGaWNMGxOBVRfA9hdSIu8pP30U5iAV3xBbOFt5ImIBQF+wKFWsUxvcH3xTJlKpaZ\n", - "KBYMwWK/I6w/Lwqe5PwqigRt11mgWDaNFOME3aoFRTtQn7l4EW2ptdfzRKHlpQibj66E9jy87FRV\n", - "h74gmi1ac7t0PXghbUWcmwOyH2X8z+HKfef+g2lbARrv3fvud3Z0FOjAW7c/PG3bOwzn9I1vBb+l\n", - "5thplOZJ8G9arX1bdSmIyB88cqj9/XtB0P6JH/jktO36frjGS5f9/rt6FM7z+ImfUwNq5crRR8KG\n", - "0ovnjnm4h9JDp8KuXAvHvfeNL0/b7jwMlEYh/XoAv6vFFf9tC7f5WlzJC7Td/ODytI02+2UV2nCm\n", - "TAioEE2ioIt1v/U2GUCjdTPvJ5LhfS3O0qD+19LHpKDnOZNzZA7DnKQFsqmAGGQ+L3hPCo+egtrp\n", - "hapOMY8VsqanyH8zhPGUD077HR8/wzaRMWDOLir1BQz3zCg0zgjqs6uFpoFjdy7qaYqx6ffWdDL+\n", - "jf5YalAIat+ExoJ4OytcgsCEgrI/71VH3zczp+UreIGNIqzOc3pWaYF2JMyIt9Uk3k6VMgvH0L7L\n", - "2Z8yxlo4j1MIb2bWYRJ0d3If6zmSWKzzcU35QidzIqsM5Jlfv6GSQdO63xe9DFO9RshwWAFlJ7EH\n", - "xxIFiPX4z6Dfo6O/FhTBOMnkGTsZ+0uSwaAC+edERKRixIgRI0aMGDEuGC8MkcrSdMfZm2XiUrUE\n", - "4MtnorWJwr+5ICcVVz+JiiLD6odoiZlZib+7Bt/PfKXBlZOKk+kKrm/wfCMfxJ2ajuVa621yoJWV\n", - "i9ew+jbhnPlbdbbTI0Tkzm8aRQDqNfQE4UKbqdsrBdA8pczSb//IZAFhLY6RycpgAEpXygouRfpt\n", - "Ju252dLOQNoJIscy9RVmWQaEYTkPyMTj1l2kt1ilaPo5haAm6bJsMxXgMlGh11UaTkWtA+iGPyas\n", - "jSeO4fhpIzBNMcCmQ+oU0oF6B6QCcpinutKke7xYPMD6uLaAxGltwpo1ERMfw8ujgBLNj277PpA0\n", - "sF47msa/T9Yn07a3775jZmYHJ476LYHc7B0GRCQVC4UnjyGilmSP8gpsBdRqBB2QykqT+ytlfwn6\n", - "5P1HjggVWDH/05/+qXDMe15DchwD+qDO9hvYitx8/aPTtjd/4s1wfFl9l/uhz45uudt6voTFw5m6\n", - "IqP+VhXQpwzjMJwwxnXiwvLqZkCa0vv+vTkQs0ru/w/uB+F7Iw70y324eG/FsRkIqKJUrEW4twzf\n", - "ny889bp/jtUIV9+1JI8cXgnIWi+CXSI3w+DnVCLJZzEXixP8hnOSupg7wuTHpxDZ1P6EtUsFkcpo\n", - "nSD1Hxe4P/b0t0A7B6AQ69ZFzF0bxti21ZqstHpQpJkO2H5PDEzyUEQOk6Hc9hNjMSXRiLKe898o\n", - "1z+D7UCaevsPTAASRoB0Si4WP3VHOxdhOFgTEq7jWsOTVTRyQbo4ee8IqykK1zKxRjuL87Y/CrDV\n", - "LZISRr93J5uInqyGsATbcNzF3L9P9DWVenUZrjsvlDlAklXu8962DvP+kEg/EW5PWO1BLFSAvncC\n", - "yXcNGAnpuxHoZyKvPUyaSsQmJeEzVmC6Qdir50VEpGLEiBEjRowYMS4YL04jlWc7poo9kQs1pExo\n", - "6uVv6z1S0pXTpnHZViCBDKvoXDRSEzqFFW4y+iqMJlxq0sl6aZm8raZIsRRPQ8vyGr8V5KIk6uRB\n", - "bQ4RrEQsBMbJfFIQnIxIj5j1EaUT6IiV27sdlCxcdyPuBzTgpCGc1lKqe3LKatIZ/i4T19kYjPC0\n", - "rh21acops83qzlfzLVZOpaAurKdXZmHVvZi5+eMHz2DmKOfkthaygpgsDFRMQo2S1i4Ewibmd2xP\n", - "atR60ch1WMGqboh1BzPRKFGvliaK0gB9EqO7MeXY9Z8SHJhBe9QI0vjSrWBgOeulDhu0LMdPHVV6\n", - "fO+OmZmtT10jl8Ee4upNb8+r18J4f/qBo1QPH4bf3nk/1LgrFn5PVFjpXbvqVgdPTnmN3tbsu1sw\n", - "3DTze3Z5xa0LLu0HdOjRB66laoGw9NDq/Of/4qenz/7V//zVcB6CqkwyGFnBF0BVNu3dadurV8K5\n", - "UCtmZlYeBRTp2tzNPHsgp/n8MnYr93pxvg7c6eNw7vcf+jXYJmhjnj72unr7y3Ddsz0f6zksGxb7\n", - "YqbKtPLExx1Ruho18QbRo1SzcH5dLZYAGFD717yvDy4FpJE1L80c6Wklnb8G6qH3E5HtBqaTozhi\n", - "5gktac5rStpWtE9MVxdLEGpeFoI+GawNlqJRWWFeSjGHFjLXtAnnTkHTjVYjYknSs/6aH4rnl+rc\n", - "hcOqvpbaoMGA6nfn8YZUkPaeBsszmadxXYnc/zQ2zuRYGyBSvTiCVhh3tPhRVM9oxCnPSc7raknD\n", - "61EdbIo5IVGBHfWqidgpENka/TypQ00L2iD4/ZegfbZitTODRlIdGYgmqUn19LwRLXGeAU1MHIkb\n", - "0Rccm2or0fIa5D2Bz9NU0D+SA0JITPVnR3nuDz37Qt47FJV9TkREKkaMGDFixIgR44IRX6RixIgR\n", - "I0aMGDEuGC+Q2qvMTAWDSDXfSSGHEEzT/wkPihMwU+KFAbMS9Yno5mrm0O+0XxNqDxxYkqhdAA/p\n", - "xypz7FfgwXJGEblQdXk450bddgmLg/DrBLLv8L1UhMVDF/7O5RoyCPAGSYnt+/Niw7Mzp9Smc0pI\n", - "N+FfoQLJgCmNNWmME61NleJ7Qi0UtHqQ/aUUtoqLOSi1InNqhemndPguRXQ49qCvRERKLk5rHfL6\n", - "UxF2jwNF5JqmTfpU0olL1B8DLNwKZdEjXXqn/iL+1HpZPD21riCn0InYlWbsbeON/Ortj5uZ2X4Z\n", - "qKh+6+LM+98KItv9uUDWOEQmlOXyUqCs8spFydeuBmrpm994e9rWNIHGu3//zrTtU//kn5uZ2esf\n", - "/SEzM0ulrteDh4Gq2khdsduvBeuCt7/x1rRtexporuEdH/97EEhfuuZp/RR0XrvmFgMTHYQ+vPry\n", - "K9NnP/Av/kszM3vrX/8f/v0siN3Lfd9HNg+/vS00Ju0hnj0VweoqtHsi92S+DOOtIu1R+ZxAQXFW\n", - "iOgWXhNj721yH+L5mzdenbY9e4rUfWm7Cu7dJ2d+Tnug+7alpsSHYxwehmu9fOj3SwtR+lz66dlx\n", - "EOirKH15GETx7Z6myYdrXBz4eGpPwrk0vafu895uQfvlMtdONTQTsVroSZkL3TbyXvd7Z44J+kxc\n", - "uTtQZImoomdj6JMO82mdixIc1gU7tySooL7XexJJIeZ9R/F8L1UxOI8oLUl6n5UadpJYElKGMlGC\n", - "2pstnEaiyH82lwQoWJeotOEQNdw2x/7bbgs7B1hjdDJfNTh3SgfMzDq6l0v9vZa18WSOL/C4z6Wu\n", - "XMbajSIAH4Y5rkG2gcovMtKDMq+jMxqRpbANO32eYHyMUj0gZbUDTfJBAk6vlCaqXJQp7Rf8WG2K\n", - "sSiVPUYI5VUwP5276m1wXZ3WP0x27S9wAvadIiJSMWLEiBEjRowYF4wXhkglaTq9IZqZJVhNqFki\n", - "RYSZWiIkFBv7myaNNVXDyDfdUapff7uZ2SirIKIZgwjsKIorVNgKAXhRnvckWCzEwKzFW/Wg4nmK\n", - "vZFeK6gO34hzEbglSCdXsT2rmu+IoiEo1FXVtMLU+nMpUTeY1YkUfjyvL7QtBK2tGpfmRPXki1h1\n", - "qpcpjU3bVt/qw7bVxlPcKWgmSqTooxtRiogTK61RkCPaU2iaMFcaQ6+i8PMmdQlXWkhhrhtBkJCo\n", - "0EpqejpBkSKY5PdlVcP6ZFrX6epRqN22uOmoy9nTgByePQvozzL1tPpLlwPqUsmYIErQCvxaYYFb\n", - "Lnyl+813glB7K+aDFI3/xD//Gf/e2/9oZmb/5i/+OOxr7uLsNz4WUKqjK24h8JWv/E04zz2//974\n", - "yMfCsWT5yVpoWv8sRfvfF+NOooQNLAR6cT+d74f2Osv8nG7fDm13cMNF7MvLTCLxlTvR3mbj98Rm\n", - "BZRW5pNFS0QijMlrYuGQzMPcUcwdJVxevmVmZh998wenbTnQoUFqKB7cRF9Iqj9tLw5KRcKZ0KA1\n", - "LoHEQAi/3Z43Di5KHxOH+wH1m+95m4y4T3Mxvx2PH5mZ2dmZ729k/TOZpzLcd3tlaH8V22/bMJ60\n", - "rhsRK507aeLZ6PXDsLcQOH/Oe0ascM4Mdeqwu05S3SckQtCnHPdzIipi2r5ko1qnwHRY5ol0Ml3W\n", - "NkFNNiR5qBUj66mmYhK9gXi/lBqCy4Pn1HqFQFprks6A8NlcLBGYcMLz7RzB7IfQF32vDzueuAim\n", - "IdRWUKXrgEj1wgRheKjYOkto8SIJBehPInJqNcHP5oXYdOBe2IjRa4Jkr52xTuNi2d/Qw/Zhx34A\n", - "6DDGSSYZO9ttaJ9SE4CIRAojwee/1s6l+Wey85jif3zcjTvPlvMREakYMWLEiBEjRowLRnyRihEj\n", - "RowYMWLEuGC8OGovSSwVj6eUQrjM4TR6zKjvRAGXa/UxScYA/W9ElEfmI09V2EYX0/Cv+oOMrEOn\n", - "Hj8D6EHxWBmN0LqIGAGLp4V6cYRtxSguxj3dYfk7P1jTkNp0KJo0h2qt8+fUcGsn/Fb2N5CWc1ie\n", - "tFQx0XLqmYV/W4GHCXsKFDvDdeeFOHaTxhEMnH5cWhOKliYrceDeX0I8OtWrE8oqpbO0t0kHylIZ\n", - "Q7r9aqOkGak12ciaVALLJzxPsjJyvhkotVJMhFO4tydCrRWgW9QJdwuq6M2P/uS07ew4iOfv3XMB\n", - "+N48CIqrkskRfm41and1G6nXhc9TOSfSvQ/vuoj8+q3XzMzs6LLTfe+/G9y2//c/+V+mbUvUQnzz\n", - "Rz4dzueyi8P/6st/bWZm+/ve/nkZaL7P/Bc/PW3rmvP13xpQLzf2va7fk6dPzcxsu5b6Z/S7qSEE\n", - "F7qbY3h+KIL1MtAH33zb6cFb69B5t645BbhaBa+s5Z7TLZfo47T0c2rT8HlZsg6nDGLQEq2YTudH\n", - "Qfh9YC9N217CfNI8c8f2GlkbnbiN56AZ1iunW589CdfRrJ2+WS44FrAvcafPQR8VMq/tof7g8kBo\n", - "LIp3N05JtOinmQjbWePtVOg+3qisJ1poHcAR9KHQ3UPLKgpSbYF0vAiQ91E7cNv5OdEOS2ucLkEV\n", - "rikY38pzAofYtE/9nPowJuYzmadZxWH0bftVGLubWrzlYORWCH3cwtuISSGNULak/Vgj1Mysb0BZ\n", - "roRGgnh7Nne6i8yTyh1aeHRlqe9vBqq4biAjyZyyXQ1hjA3Srm59ptUWpoJxU0yC/kQf+3RvF0kL\n", - "qzaIUJyi9FmxxPfFMR8eWGptVSJ5Yyvj5OQ0UMuzTiol0G9R6i+O047ExwryliJf4F8f63wn2Ml1\n", - "mt4ZfD6lZ6HYohlfAdTbjzVTE9WqaEM+JyIiFSNGjBgxYsSIccF4YYhUN2aWy1se3zi1Ns5kOyDi\n", - "MAIMOwJwpHNmta+q6KLQZf76OYkBE66gRQgIUeYoCBLrJDzea8gAACAASURBVKnVAlN800SFfeFz\n", - "OpGbmfV5eBPXBqbuckJLxHW8b8MbfC8oXYsfK/rDRYfWRmKK7079J7jjprL66Iawihsn51p1c6X9\n", - "hNSmo4u3pDATTRvEaqDenK9hNLlYSEpuzppsIop/chzcqPdQ62uQlNscabKFrNao/1MRNdOkU6n1\n", - "N1ULF1F8P61+/XoqrLon2w3pV6bBFtKve/uoyVb4qrppA+pX5L76vXbjI2Zm9o/f+nf+W9Sdm4l7\n", - "dgG7h6kM2OhV0K2DiDN3cTITNLgyNDP74INgk/D6G15/7snTsPr7+tvf9OtpQpvdQr04M7MfABL1\n", - "lX8XznPz938zfbY8DGL3JHFU6yd+/MfMzOzRI69/9uhJGFdXLznSk6LN7t27N20jwnl25n1XTHX6\n", - "Qj9oCnsHIfbxI3dx7157PfxOUqifnYQ2o12Fmdk+UtEfPfHjHwBZ2b/kY/L6DaA5qMNXS2r+fC+0\n", - "u6JkdEIelo40XMI99lDu5xwC2JNjR6noEC63k12+HNCGZ3KMBKtpIvHrMz+nrAz70DGUoe1KQUnY\n", - "dom4eJf76EdZkrfPwpw5avo/Ei6Y2GGCIBFhSWY+/oYSte7EVmBCcxT1RuJFIyJeXvYOcwBUvAJi\n", - "X8hEeQyx+2br7dpYQPXUOmUgIyD3ZJLCvV6eHW1/hvPQOp18jkCw3frxOccNowqxgSBt/RpWqOdY\n", - "yvHzwxa/1fqbFK+LdQ4SpHIyIQKXLIqANG8Tv/+GISCWpZbbgAC8KqVdKRjXZ0dC5sC3TVUetHYf\n", - "K1pAxJ6q2Dzh+co8nRD99+SZdR/uxfXGEVZaHKS5tDF2XWYy75Vgooyskorjw5jMdmChYWf/Yb+w\n", - "6ZA2MYx7fcZNlT92qqzYd4yISMWIESNGjBgxYlwwvuuL1C//8i/bjRs37JOf/OS07cmTJ/aZz3zG\n", - "Pvaxj9nP/uzP2rNnrsP5rd/6LfvoRz9qn/jEJ+xP//RPvzdnHSNGjBgxYsSI8f+B+K7U3i/90i/Z\n", - "r/zKr9gv/uIvTtu++MUv2mc+8xn7tV/7Nfvt3/5t++IXv2hf/OIX7a233rLf//3ft7feesvu3Llj\n", - "P/MzP2Nf+9rXdryhGElS7LqYTz4iAkUm9H3SQr6g4MQDqijCtio/mLadbcLLXZI6LE7vFXo1DbKP\n", - "AZSWGtZS9KaO3XSv7nageIiN1cUcdFReqAJ791hq8URxZtvIdaFJOqE7ChG++nXBHbYRwSB2MxNR\n", - "3qYPkCphTPWM8nNRISa+IJhpB3Gmms4Sxu3EM4biYR1iJfxz1G14CzqOXjBl5sLWxSxAtk2t/QS4\n", - "u/d+bdBmWSWu9ClpSTW3yr/tCs3qpt45N6U7WfCyEtffDJQhKUEzs+UiOFong4+/t9/+OzMzmwvd\n", - "Mg4QNAu1wqLGCTxYcqEdsuy8ALuHOHS18cXLyygW/N7770/b+JvLB15weLMNx/jEh9yB+//6t38R\n", - "jot2InVpZjbgXP7lz/3X07b/9X/7fTMz+/Ef/4lp22uvvmFmZo/ue9Hgli7O4gqegb5Rp+wVhNcN\n", - "qKiTp05t1qegnYRuPjkJXlBHUlx5YJ9JUkiPeWS570Ldsy2SJ9aSlPI4HK8DjVouZLxOygIfEzkE\n", - "zcNainujssHRq+4P9vReaItLncsN6jNQGpKUMJuRFvMxtt0EuqluSc+JiBn9qkzDogzjLqm87/JL\n", - "8EASH58UIvJGqDqKgeuNn2cBD6oG1R4G8XabfNHUgw+O+umOODjso5z5/EP/pFqKkHN0NOrfhnl/\n", - "NlQ4bxeWJ7j/txu/r8qMRdv9vuIzQf2GEtB3UlvXsnSJc/fjJ7jGFPeEjlfOxepxlOB66q1fP3OR\n", - "VqdCrWJ46rzbgDZMtbjwCKoKvaxeiPP8EMcXCQpczgdRh9N7cVaJ3KRBMehUn52oVNHqMxrzaS4y\n", - "j46+VOH+WxTer6T2Mtk2ggtra6FRt4H6T6VPBvhiJb0+90k3iqAeHlRJcv5dguep/c9n+w4lh+dU\n", - "Lb5sNWjGQcZuDgH8jnpexuzz4rsiUj/5kz9plyWTx8zsj//4j+3zn/+8mZl9/vOftz/8wz80M7M/\n", - "+qM/ss997nNWFIW9/vrr9pGPfMT+8i//8rsdIkaMGDFixIgR4/+XcSGx+YMHD+zGjVDX6saNG/bg\n", - "QRD73b171z796U9P37t9+7bduXPnufvom84GqWvH+jsq4uNCXAVj8yKsRBtBmoj+zOb+XrjCCndd\n", - "u7CNaE45CXUF6YCwfAd9wraNeWoyBdN9K2/1SL/sRSjMNN1SRWyoWZfAbVdrU6U50sAFfWg7IGhi\n", - "YZDQsV2F8khXHTqBuPB5UfibdDEJv1lr0K+hwRv5uANTQVgv18C/RhFndqxhJTa663W7831ckZmZ\n", - "lYpQ4hq327DCKqQPE6y6ChGRtkiTTbXW4lT/TFbEuI5c66qhvbtBxfNYpXGFLc7aPEYhrstFGRCU\n", - "mdS1o2XFw5OvTdtmVVh8qHh624RxlIijfw/xbJmEMbmc+QqOY7EZXVg7r143M7ODQ1/9vfet4E4+\n", - "NFLrbhlWrgJw2Qz99I2vvzNtO0AdNwqVT04crfiXP//fmpnZ//g//Q/Ttv/uF/97MzP7yl+5KP3x\n", - "k4C+HV31Bdcbb4TzfPTAx26PFd5X/4O3U1lSqBraeiUyAabpv/qJj0/bzk7D/dyLTcFrcDsfpFDk\n", - "k21YOV+75ijN9ZeCyH5vz/uO99MApFFFxwMFszKuhjUSVfQ+rUOb9Svvp/2jILLdu+Rt8u7fBTuJ\n", - "9pkL4E+Q3LKUGn9ckTdApJai4T28HNDH2x/6Pt+IdPn2zOef/gTVHgTp2rB6hCAy3Tacu9bprGGF\n", - "MK9Ym0znOlRbqAQ5pf2HJuCgzWqxf6Arf6WoLywOhlLQdDwWtsb7WhNgwvkKIGY955CNz9NtG+6P\n", - "qvS+npAWqV1KR/NBmIBJ7cyEFUFmeGAVZxvQrL4XAX6L+2/m89Qp+qQofZy2eI4MgpJUEO9XeUBT\n", - "U5nDWlpTiCXMhvO+JNvQTiEt1P4Fc51QIUQYtZ7oZOcj/T6y7ijGU9N6wsj+XkhKWYqFBCmOs97H\n", - "5ABU6XSrynbcY9KgKR+ekijWobZlWaJdpdYgE9W0/m3XbXc+MzNrgL5qQlWN+3gUhI/JCOlOQcfv\n", - "jDn9PxabJ0myo6B/3ucxYsSIESNGjBj/KcaFEKkbN27Y/fv37ebNm3bv3j27fj2svl5++WV77733\n", - "pu+9//779vLLLz93H1/+87emAjcvvXZkr3701ed+L0aMGDFixIgR4//NuPONE7vzTTJaw3f87oVe\n", - "pH7u537OvvSlL9mv//qv25e+9CX7+Z//+Wn7L/zCL9iv/uqv2p07d+zrX/+6/diP/dhz9/HDP/Wx\n", - "qbComdkKsGwlNtIUO46JQ5YVFNiluPOmoNsWAmPWs0AHHW+d2muHcIwMUGgvjUMKRosMUxSeyfHp\n", - "gZHMRewKx2B1R03ofSUwKs8zhS9ULp5JM9BIjVALLWDxQkR0pKcSFQySqhIPqo4QtAj6yfMkINw6\n", - "LQZszwuK7aXIJa4hz0WA3rEY8/m2Uwic27SQ5rajeJv/dyi4KgK0PYgXDm1ZZmJB36Dw8aZzuJlC\n", - "+UGdqtklcj0jXYwp+pTzbWF7u1g4PZCl4e/Z3Mff09NAVRXimbICZaCUCUXRG6E7MtCdOUSvdevw\n", - "+BwU8Kx0emgGsfO9e75gWcAdPRMOaIR7soptT0CbVUtxwJ4FuH3VBNj7k5/6p9Nn/+df/GszM/vU\n", - "j/5n07Y/+ZOgh3zzE29O2y4dBbH5t955d9p25/0gtt5unSo8Pgn3zkYomEt7wSGclQIKobsLiI6L\n", - "uVO7BUTmrXjGvft+aIsbN9zHag538NONFPcemYAibsegvpeLMNbKudM+HNeF0AOsgHC28uvq4KKu\n", - "g/3kzjvh+HL9tz8RCh2fPbwxbXv03t+amdnTJ04LVihuW4Di6VRsDsp6I35XB9dDG6aSbNI9C22s\n", - "lEm3hlO+3DubTaBAm617QFUYMxTg5jKHsTC6+j5Ns4eMdYrNUy2Gi787kQ9sMD+3Jr5sOB7zVXop\n", - "Wpzhfk5FgkFPo9XGv7eYgype+fyfTVUxxFsP4vW6kUK2BYugo0C7+i6VTNTx9jfcp4V4e434bSWu\n", - "5AmOb+K31bXBI63r/DwTFm1mMWxxAqd8YSd/i30s9BM9yLK8Ovc9LTg/sj2FF8vwnOgHn0/pVUa5\n", - "S5op3YokptLnP8oSMqVsce65PJI2qJqRyzhh4kkuSR59HeRDszmTzbytO5xTLwlIXUcaV3jx8bwA\n", - "nT5bwyCifJzfrQ8d2a0PBTf8xEb7qz91Sv7b47u+SH3uc5+zP//zP7fHjx/bK6+8Yr/5m79pv/Eb\n", - "v2Gf/exn7Xd/93ft9ddftz/4gz8wM7M333zTPvvZz9qbb75peZ7b7/zO70RqL0aMGDFixIjxn2x8\n", - "1xep3/u933vu9j/7sz977vYvfOEL9oUvfOG7Hri1s516aTnektte3anDv5vWBagFijPN5x+atjGt\n", - "WooO2bIK+zs5cwfYnsgJ0mV3XJT5mWxjhmsjKcys8dd1KkrFKqH15uQp7WRfEhGhwE5WcHlBEbms\n", - "jIDwqE1Ej7fqXN3G8b1S3K47rDB72d8kBuUCRkWHI0SnKpuDOLiTmoT8bVlJWjH3Ky/NdCXvajkG\n", - "oCgV9DNlOIFT+mie6pzCpmJRiYtzElYOlfhAzHqI/c1RwnE4xvUI6pYxdVyc8qc6gmwUv9S+C224\n", - "rv3712+9bmZmJ8fvTNtYC6sWFW+KFdOQ+qquYRtrokIfVkzbhKJzH+tnSEm/8arT3g/uBNRnX+rF\n", - "GepePX7oqMb1oyAAPVbx9hy1pmT1RSHvzZcCqrQSwfLZOqyWj3pH5N54/cPhWI/dbfzhw7Ba/MEf\n", - "/CE/z4f3zcxsvfLVN1f2N2+6JUOKFfHhIWpoHTn6dvosjIW5WBJcOriE8/T+PzsL6Mu9e36v334N\n", - "bVb7WJtB+Ku1HmeXQ/uPI+1P/F5bQ0R+9cgRpBpp4Fev+DXc34Y2e/db35q27VdhTF6d+YD6yr/5\n", - "V2Zm9urH3JPv8OatcHxBeJJN2B9d7Pev+Er/4Ch8//DQ+78H6tJK/bNiHkS5J8+8TZZImtisfUzm\n", - "rD8qTICLbNEmouwmwqrp/znQDE1N5zyqGt0ZENO28TY5QDp/0TsiVaAvWqAUH4gTdgWR9VxgDVpd\n", - "dJKU1ACx0zkuMQqQxWqC9g+CEg/4Xl5RCO3XkDxnnKRAcGaSAFNBjL8R5HSOOTsXt/OBKNFOpYSA\n", - "Eo64/qJwRLYBq9IrIkcnctk2zXFap3V6Psr3UlrSyDam+gvDMaJteyS05HMRcQMJbUqfu/OUiQp+\n", - "/Om5J+eUoX86qZM7WUKYMxFMJHt2HJLXZpU/68aEz3MZpz3uTyUkcPxeq5fgeT7siO3DsbTKRiaV\n", - "PJ4X0dk8RowYMWLEiBHjghFfpGLEiBEjRowYMS4YL6xo8dC3O/bYpNZSoWcyCJpTEWA3LaiCxKFQ\n", - "FqtUYTML/eapC2vbNkDERRGgWxVR851SrDMmYV8isB6Fba0U+aQYcxzEtCcnVaVUIWBEUFwUn5u5\n", - "i/lOdgCd0AUf7UYK8QSKB7TbboVGQnvmIvZj8WdCnOo7Vab7uD4t5ExnXxGMgvsaGhWA4jy08aZ3\n", - "dBE2wsdKRZn076rpxSN9nSSBPipzFwzOQel1o0Lr7CfxlkLBU9ErWsYz1ZqVON7kldMrFYljHvr5\n", - "3r3/lpmZ5YW3dTrs4VrEC4hFOOUEWo7xHWgbwt4kjOuTZ378H/r4PzMzs4d33LF8MQvUV711KqKG\n", - "t9GNa9embSwWPLn0mlkJYflyT3y5WLQTYu+78KQyM/vUp4In3N/8zb/340PsfXDgLu7MzH37nbf9\n", - "e/Nw3x0euth2C6+cVCD4fRbSxbhuRJx95Ur4bCEFgms4dS/nR9O2w8vhe/fv3p+2naKQ8dU9pwDo\n", - "3r4vPlJzJA3wHlLaZwZvrdVaEiDglP70gYj9kfhyIAko7XEYu48bv55b1wMd9/T9r/r1H4Z2vHTN\n", - "6btsBC2Bwr/Xrzm1uH8Z37vsfZ3UpKz8nujgGZ48eTRte/QACQBSgYCeQoXMMfR7yipWgJg+mrzv\n", - "slwlA6RsfB8s1puJiLiHRCETyoj5Qa0mxYDameHxdFB4fw2Yu85q/36NEyxURA4KNuv0EYd5r9d5\n", - "gv6B4u2E36ZFOA91NicFrLKMSQyfersysWdQIzc4gPeD0318ZumzK2FFDRRU3ooXWDMG2k+rXSR4\n", - "1iiN2cH3qZDJLmPx81GpWtKyPp/3PQXlMlFBDjDm9FvT+T/s7+mJ08iXDsKcMEiiVocqDoP6N07X\n", - "JufeQlCuFU3Ir9KXqhd6GnPXOPqznk7siTyTcwjvR3lOtZBvDDIndfAls973Z+Lb9byIiFSMGDFi\n", - "xIgRI8YF44UhUlliO6t1uolqfRuulmZSw4crjXYQcWJOREBcvFumekqaPtCHdnJAFvQFb6ma6kx7\n", - "hFFEZw1WTnnqIlouuhKpVzSlieaCZlFsjZffHQEb3HN7WcENPZ19tdYV9i9ic0Zd66qCCJ+4CKM9\n", - "uejOU3H9xY6TUt7MIXbNdxAcpPWr2BGjaGjl+LA1SE3e5Ec6qrvYeRKNA01ScWaOFfmpidj0MsSR\n", - "4tieUPjZejvRqXeQ1VyO61HrCI6PDueu9RKrMSAdSeuIGFPn00LE9gPHjjjmos127RfQJokmJRQ4\n", - "9bD6/Pir/2z67OvfhGN4dXva1tVB0Nlt/Twv7wWU4vFDXxFeuRyQk630CeuPbTc+dq8cBWRnA7To\n", - "1k0/1nvvBmHnqyJ2p4j4vffe8eNfRg2tnWQDVAAQ644GSMdS6n8x/X4OpOtIylGtUYdvNnP0iQiG\n", - "JizsXwqC5UxWmhscK5fxPFucT1Ony/kWCN8g99BsTqsFcT2GTcRSUKIPvvUPZmZ26/br07bjgjX5\n", - "HM1q4Gy/d9PRpLOTkAyQS0LFZYjLe1RxUKuRDMdVS4RiEdosGUWwjL8XV1+atuUQ/p8++Pq0rcKc\n", - "kM/E7R3C8xHzXyYoHcdQuoNgAU3W/kctSq1KMYnWFTlpMZ+YxxJz8IjvHUoK+xMwEkRQzcxSuGyn\n", - "ktbf16y/5/dahvu/EZTQUCkhl/uZDADRSXV2J/oySpsMGd3WHSXhPJ5ljv4Sdc93rANYE9TbhOUp\n", - "6zOIzgVp7CHyJ+JkZpZAqJ+pTQdT/WU+SzHvDjuidFxr5m3cjugTrX+HVwXOobW4k88KJmB5uz49\n", - "DohtXog7esI5Vl3EcUxFLjFOsl4RMbj9d7TVSb/9o12HAM77khQxIKEgE1d0qtH7QZ8d/MPHWPJd\n", - "MKeISMWIESNGjBgxYlww4otUjBgxYsSIESPGBeOFUXuj9RPVYaYOpA77UZyb504PNSguWYtQegRF\n", - "Rt8h3Y/CfYQ7JzGdFKMdKYBT3w1wWqP4s9A9tRHfk6nwZK2VNOEZUvXyW1CFdN0WyJbCc3WiHht+\n", - "LlAwzLeGRAV7OMZwHjJOxQOqgvdTAfF217kQtwdVmifi2ZQHqDoRf6Q+obOsVD6FUDARwWAC2nYQ\n", - "upMOwKO6HbOAKKDyqnA4dQunYh2k63U4z+W+uK2DisikaG+zxfGl74gjqyg9zViEFo7Raz/fl49C\n", - "kdvjUxd7L1EsWLSmUkBX6Eb0bSKi+AxtsgO3Y0eXlh8xM7N37//V9FmVBcqqa079YICbZ5lTMRRo\n", - "X7nkwm6ywUojFmjbS1JI9+wsUCXPjgNleOO603jHk1eWU4EsYH2kfk+n4fyqyu/TGhSt3pMU9HZC\n", - "wZYlqM06jLUs9Wugs/9m615YVy4FGrEWL6QUXjDXr3uB4iS/youeth3sH+JfFdvD2RyCdoX4SUvO\n", - "9sUJHoLZMnO6cX4UjjV84GL3K6+EQsrP3hVhMeaxPPExfnQ9iM0rofZS9G0GumnvtQ/7OZ2Bnpj7\n", - "9w3zWbd1GrU6QFucSnFlUJsLoUrpsl0LLUNKq6A/VKqSBfwr1GIFmk3FyaSMRmVR8J9BJBWc71qh\n", - "gEmtkQo8Ec8mzn/zmfc1XbnVl3DA/L9RHzEUvFX5yLbG2BUD7CnJiZcjoucpoUZpzATtL+7kOe7T\n", - "uvN7h7WvEynM3sE9PE39+nu0cg4X9a04u9dbUOaJVweoKs5nOv+G/hzFi4k9pkkBk3+a0Gie8CNz\n", - "11QVg/O/H2u1WmObyCjw7CgG9RuEtMRk7OL4LHwfvgdJiVDaTNCygpSd76LZ8jxF2pNx/he/s4Ly\n", - "GTkWT0N+686Cfk8MkdqLESNGjBgxYsT43sQLQ6TabmWpoB8UKqqwnOn6naxqMnwvS3wJwbfFRBAZ\n", - "vp2OO/X0+GYP0bG4yQ7jeRFlMuL8VBSOFX7dampm2E+99uvJlxBvN7Ii4Js+bQ1kuTbmVKDLm3HK\n", - "lY6sfiiiFgF4D9SjF5sC6ymU9GOkcLEtDQ7X8h6dIDV2spcwF5b28ma+AKrVSFsPSKEvVLAI4XUj\n", - "6b9ziGcXpffxPtLPtxCMqjiR7S9OE1bD9Xm+9BVphZXLUtC8NUWhrdRQIrLWiU1BhuvFyuiqiJ0f\n", - "PQ7i7cVS+pV2GoL0jGlY1erqJ4OgNOml1hVTx1NBRCCKPbwekJhu4+jLAijtKCvoHk7oc7EwePYk\n", - "/KaRlXsDpGVvz20Knj4N32sbb+O9/XBtBcbuyYmny1+/HpCWWuq6bSGYXYljOVeaw6go6fnxTDFs\n", - "NZPkjS1QR9RG6yQNfQ6ksRNxcIaVZtv7/XflCkTZmSOsJcTrxdzHWoHxUcx8G8HJbBZ+m0tyQFnx\n", - "fpIaarivhrU7u1+GoPuxOKZv8fflV79v2nZ6/51wTKl/VlVInihl5Y5pucK/w6m3fw5n90EQpPUK\n", - "qIqgD+uvBZf1cs/Hc5nh/lv49XDspFoTFIp+VlHQOmxMjihKreGGc5P7j6hWvXHkcAAD0DaC0kzo\n", - "i8wdSBQ4bUIbLgqxxMFYUEuWyT5d5tOiCP2zWfux6oZp8orco9amFABlgkiPOayQOamf6gqKiHog\n", - "Iqf2A5gTZEyskWK/7fy3Rc62FoQJ1jYt2rORGoIjkLtR0L8BzxVaqJi5ZRCF42ZmYxL+LmVOJkvS\n", - "y/OsAduQl/LsGkP/JECOhlZsYvhTffziGOmgzzMcS2x/+gzXo84R+Fym2IkJKvDg00M1qHWrSVn5\n", - "DOeeCNIH5qgX66Qe19q3kpSF547OZ53Ue31eREQqRowYMWLEiBHjgvHiNFJjO6FAZr6o6IRnTcH5\n", - "DrL6nNIeBabK8GNNNZ/SdEfVTYGjTfjGqahSWFX0vXL1hm3K/WJVpfXvsErIJCW/qfljNf2k+xrR\n", - "IuG0+aatKBVW9U3tb9AVVpONrCBYL6hXUzusCBWky8Zdfrss1cAMxxX6mteTCPyVsfq5rOBaLCdU\n", - "j0VpSiNF0qmNEBmKlSX1IECmal9VGdKJNdWWPHwjKekF0DwaTpqZ5TXM72T1N/YBxeml30voUFj/\n", - "al37yjADWpCmmgYLVENNAqkXEzSzgiGnDGdLx4AOzCuv07aAncOju3fxmXfAugNa0PnxmRreaa0z\n", - "rI7X0nZc1aXiXXHtMKTV37vrNglPnobffPzjHzczs3ffc6NJ1k5biiHmCfRQWkSNmgtd6VPzMhMz\n", - "VZp0MuXdzGyGPjs7C3199UjqpQFBPlg6+nYG9EV1DtSZsb6ZmdmCppty/XMcP5X1I03/qmnsSGo4\n", - "kM5RkD7aBGiqfwPd3tVXXctUA32y0lGyvRuhPmi79jFGs9FiJvXUcG/nsE4ZVoIqzMI1ZgvXki0x\n", - "r23vea2/GaC2d//+307bbtyAbuup10RjKnwplhQ1UJ9KGAM/t9DuiSAiNC4dBSdYo06kjgmCOHmi\n", - "+sZw3BNpE+pgZrBO2Yim7hDnuRJ96TOgr7mgRDynVmp9bhsix4IIAX3rGp13w78p7jW9h0fUaVO7\n", - "BA6ZVlANWiZ0YhzaQeu0ES3bFdR6LARh6w0oHu0MRJDZ0NR5EC0rER5FyWA1M+zUlQv77aXWJvtf\n", - "50nWnRNvXCsyTORsjNHbtUHtxMXc73UinFq7dsJt9AHQE2FS3SzPXeZp6AsnA1PZR4NnV1OL1QHs\n", - "IbJCkKaM7a59jblLnnE1agcWMnclOwYd5yMiUjFixIgRI0aMGBeM+CIVI0aMGDFixIhxwXhh1F5e\n", - "lZZIGjz/kjJQVhWEB9XtHO9+Wn8PYjyFAilarWYuVNx0M+wPu9AydIBFc7VEgOgvUXQSMZdUb8sC\n", - "jN21Qu0BWh1VxAa6LaeYTpx4mRrei2NrS8hS9ruF7cOobsd4H9b6TwPEcZ20Uw/ItgRkrHWI6Oit\n", - "NdwKiMxTcVHvafsg0DodgwcRNqZoO3WWJwRN2NnMrIVlxHLvEP8XypICQ7nWBvD4vBXKANReJvBr\n", - "RWftXujjEXTP6HYCPWD+w4NAu9179GD6rIR4PsvERZmUjtITSdjvpvf053kZaLROBlky9ZNDxntL\n", - "OJCfBRG91qFbgiqZpbembTeuBXro/rueap9MNfz8nBbzQCnRmsDMab7r1zz9/e79QOU9eRLonitw\n", - "KTczO1sFuoU0jZkLtm3HaiREJxTYlNbe+LZywXYUsSmohcUy3Kdncr68UdWJvAO1pKnRrBhQCi2a\n", - "oS1y+S0pvUTSv0np8nx7saswWmfkwo8nmE8qcZZes3alfy2fBwfyVqji+eWbuB4fJ13DWl9CVc/D\n", - "eOJRsxtOBdvx4/D91MXuBkq9FBF5swq/vnLZf3uMsa21xkh3qnyCLtv8dxR9QF5SguDbGtbdVBoP\n", - "92KZ+zihQ3oromzakxwufRtpYaakD+Li/XQdtqmtAB3tW2nDElKB5dLn/6YNVPm28fFMmn8QO5sc\n", - "yRAjqCKlLHnqrVZR6DH/qf0CE4qG87KUTJ4x2y2dzSXxilIRzLuFJCdwjGmyD60JNAGA+ygraVc8\n", - "XHsZqLQHaoQq47bMlAJkpQxa+Ci1Hr7X1L5tsQjtDKZ7rAAAIABJREFUX+be/nWHfpRnHB8teo/3\n", - "6G+V5Uzynek8xf4IbdHJM6FhFQmhNosS1Q5k/un4TlCLeH+kBEju++8COUVEKkaMGDFixIgR44Lx\n", - "whCpotyzRETcTKdUcXSHVUIhJo01TPpWG1+5zpBiq4IwpozraiqFwWEPEfM4+lvwgO93orZOsEoo\n", - "xvNCM32Dpog6ySStsuc+RJRMIfuE0uhqhSZ0fgyaVY6Dr2o3QN+WV2T1zVT/nVpjWM0NKiINq7hZ\n", - "EYSt5Q76hpWmWD1QgFnMRLAIdDApxKRuWh3INmwqRezHdNJMDAnbBisNoBmlCIbXrALenRf2b7ay\n", - "gsJKdzLcM7OKKKEYMiZT34qdAdLOV01Y4c91VUckMBdTQxjMZVrXCUajmUCX+RhWYpXYedDgLzNf\n", - "pa2ehjGzh/T7QcSxS1Qcb8/8fGlcabL6Zt5Bmfv3iCxeveKIxH3YObx0+5Vp29GVUPftCQTIr7zi\n", - "hpw5bA92kCaiFLpapflrqqgGVrU6xljPUlDiHvczzRwbSfYoMIi2W72vgNLNJYUbw76RVfIciGQq\n", - "ZpI02NWalLyPmw3EqaUYEyJNOhf0rR+wqhajVzZ7IvU/2wWMNgX92qwC6ljuuVDcVqHNtpImn0LQ\n", - "zvu/q91CoLwWrBbab3xl2jYCza2fuXXFuA59nYqtwqJirVGZJzHhjIrSYd4bOcYFaZrqxYnYuKqQ\n", - "xCHMAZHDRNEX/DaT9PfJJFLm7gLXPQPCPpc5cQ9WCBsxqVwPZCR8W455dzkTS4JZ2FGz8fv0ePXE\n", - "zMzK0g+yPQvnvrcfziNRsfdIM2c/J46xRuYkIvKW+DllNHgWRIYoSi/MAREwJj6psJz18lpJ4skw\n", - "/+r8z0QRcaSYEorUzJlzsaK0Xk9R69SGZwctBhL5bJySuPxYFGpXgoixhp4K0NM0jPtM0Ke247zj\n", - "+yOLQgshNdCk8H0UNJm2BnmqKCm+rmbKQB07rZPL85QxNl94MsjzIiJSMWLEiBEjRowYF4z4IhUj\n", - "RowYMWLEiHHBeGHUXjbmVogTcQ5BbyPC5gFwotYL6yCsU7+h9Rp+O1pDaNrJebdvg9i5UhgfVEkm\n", - "xzd4Z+Spn+cklFYo/DkeVBPbpXo1wr2k4vTcJqGwwJ4U/QkU7rikCmbP138qQZWoKHLA3y0ou7nU\n", - "fKogaFx24mcDvxOlVsmUtoNjy23HWksqFIcAV+DWzTZQFJ3ApB2cuknfFCIYJsSdqLNyF9ribKMO\n", - "7OH8KqHx9ueBslpl4vY7CfUVbqYvTLF7gaYUpHQiPk/k1ily+p3519KUdJ8Ly/cXENSvve0m+hpC\n", - "+ERoxPUKdKf4Y43wx5pXPiZJmY5CozQ9a1hpokYYH6szp4roizZDsTH156IXjDpR07FcxyT3UQg8\n", - "z+8VpYhCp2aUtptoPni3CGeyBO3WyhjKMa5ToTGLGcXZfqyzs0CHX77swnpSekqBdG3YNlGL4kVT\n", - "zeH2L+7cCcZELhT0AOFzLvNUlrKunNyTM7hY74idUT1g42Pi7E7wFLv84ZBYMJ76vNJuAwWb3HLP\n", - "quzu34d9iLB7W4U2Wb37H6ZtS9Ri3Mq9Q5F9IT5SHekbzE+Z3P8LtIkuwevmfF3TaZaSpIzZDE71\n", - "Mk+yzdQ9v2YfYE6ciYyihKP7sFXH8tDXudDyGcZHL4k6C1CQtXCFz1ApoV4LLY0kp2YL0bkYSfWg\n", - "9lmj08xdt/XZwWSIQeZ4Jp4UmSbAwDOpU18qeMWxooRMP3xmnQrd3eK3g1Qs4L2+41ifkMZVb6/z\n", - "spUMkpdc5lNW4ehwrV0v9wTG+sHhzWnbJH0RHq2Cp9pOUhaeCZn4aFEh0YpX4haTq8t31Fkd1KJe\n", - "F641k4QuHqPfSAIYZRZCt7JPdhzwu/PtpBERqRgxYsSIESNGjAvGi0OkLLc8ddFpgZW7ruq2cLTW\n", - "OjcU+Q5Sf+zkNAgGZeFkeUa3XQ+KGJnqv18p0hKOUQ+emjxYePvecQBvnpPqjDf3NpWVBt6IB0nJ\n", - "zNDcXLntuKXybVprE2Fdl6liEPW09G2ZgE0ib+QFVi5Skss6vOETpFIxXzFnuqxv61tW/HaUgmie\n", - "ptDyMnpBc+g822kNKxz3+MTryRUYAx1QnU7q+s1Qf6sVe/QM6EMjK8img02FODHP8L20FAH+KVES\n", - "R4lO67DCJ8BRqsMw0IJc0EcKS1tx1i8hKM91pTmJscVtvQgrsjqT+k/sTyRbdN3x9Nl8CNdwrfSV\n", - "3rNnx/i+rEiZui7jj+jUZu0rxxTjiAiCmQj1WX9OhmQ3paHLShffH3fuLDr1i/0EEBu1KeCxElm/\n", - "TZ9jGaqoYgmUNJcbm47VxY79CNAHTdTA+RGZMvOU7ExQLyKhFNHv1NeC2Fxr/XF8tCIOzjDutU0G\n", - "jI9Erqc7DX3XbryPq6Pb4Xr2HGHkyOruw4G+knTxxyEpYhSbihY3liZlDEi82GhNzJMw1q8dXZu2\n", - "PTsL813TKhIJOwUgoakgnQSdWzlWAuRoXgkiB/uBaiZJOeggTdRoBVmafou+YOLBVqDes23oz9O1\n", - "zyG09WjlGvKpTqLck0B/dd6lULuVfi8wTxOFUGE1q3G0Mq8TCFSrlwGIfSL3P5FzrRQxwDphdeLX\n", - "SMuGqVKHtNf0TFDmBp2SdGJ1QJeWQZMiwLpIUlCJZARFfXtWqtipnVnvHKuXZJcKSGtZeltXqJNZ\n", - "b/17A54FKrYf8bxX5KjA/dwKOr4Bwp5P96laB+H65DlZct6X94QEfTer/N6pUTVikDnBLVA0ySYi\n", - "UjFixIgRI0aMGN+TiC9SMWLEiBEjRowYF4wXRu31bWq5UDH0oEkTgewBz55txcUX4j1Sd2ZmJ2vA\n", - "3SJiOzoIztJF6j5OFWDMBNSG+mQQ4jSBhzs4dWe5iDMBY9crdSAPx22Fgqwy0n1aNBIOtFNBSYEz\n", - "QR/lImyknjcTGiHFbwuBHd2J1oPnaeJ2vQXMupgH2LkZXPSaDwFOViqmoKBWUE2izKl4QSXJGf4V\n", - "sR+dzdVbCefSCFUy5vCbgbfTOAjFwILCcqyKBVKFAk7g7KwC6Ao0WiEu6tvkjpmZdVpcNKV4HA7D\n", - "pQvhh2mdIYJNiMj73sfEWGywL/9tAa+uIvVxSv8aLVDa4RgZ6NOic7p7SrIQiH2xwLhqZEwAMtdi\n", - "qCyqqs7qpK3WQnfdvBEcuJ88DfS4+q5RnK33SZqRRhEBNO4ZpcxmoHlaoSDLit4y3ia8NHo85SJO\n", - "NxaGFbExOVhh8SZKWa81x99DJpQFtikpyeK7K7i3z+dOsbUQXWey3txCeN9Lge4SRZiHTP1xIN4X\n", - "sX9zRh8foe9Pw9xVSBuT3S4ugdqW8TJQxH7yxI+/DFTF42/83bTt4ErwsWquuyv+KQopL/d9Tuww\n", - "B2nfTfQ15slCfZ8y+HgV3ocZaByxW5oSMFK5d0gHjVrIFvNept5iG46Z8L2N+IPNIHa/NN6Ytj2A\n", - "B5yO6yoPlQp2KCAUEu/FKZ3C70Qd7TEoU9CCnQiNmfgySmUH3jKDFJwvce+mcvyUNNvgz7hmC2dx\n", - "lYCkdJanFETPDc8QEZHX9AIb9JwgrFZ6aqI5xe8Lz7hExi730/filI97fKLnxDORc/Fo3q5pGsZk\n", - "WQktifbRpKy0ZJKJyEIwdrYyJhv4Io4dinaraRXbWu6hDM9dmTqtKEOyRZV5Agr1AOp3x3mikQoY\n", - "Rf6dX5UiIhUjRowYMWLEiHHBeGGI1Ko9tUWprt9YrZYqWA7/lqWsVoD+JIkL25aLsPo43Tz0/TFN\n", - "ttD064BszIE6dJ0jMtmk2JbVB419E38z5Zt7JqvkmqJseatmim+iAuBpxQIxnVgTlBBl6spwTnGy\n", - "pAazFmAmSBMbahRR5rQfrX+F1XmDdO25+cqIIkp17J1qAYqLcQKEKROkhehYkYv9Aw47irNtCjdo\n", - "dZYd6NpMJEJWhiOE/fO5j5MRLr+XDw6mbW3LWnN+PSUckPsdYWNYpWxExJjNQttSsDurfL9T08mC\n", - "kBeW5ipYRv23rLFvjyRVB3CsiFUUPIS+oBN0abpaRVr1vJXvU+wpYnsgfOpA3uHkc02owPAoZRsd\n", - "zelOvpVai0Q6VcS7B3sKdbE+2A/3k9bka3A9lQj7KTLPJU1/as8JBREEE6JTTeHeIHVfBcAUym/k\n", - "+FOStKApa7iHLxaSPNLzLFDXUuwyWKezlrZePQtI0N5Vvy62u6baFwXF/j53ZLgXUnFR3qDG4ezl\n", - "N/w8n34zbNsDMrHvjv10IE9rRwS6dRCvLwRpOn0ats3F4mWA7cjpsTilQww/DOcREVpC2HN0ttr/\n", - "PeaxQtgECoAVfWYfsw6mmVmF35yJ6DxNd5GLUub6WQmk5UTqj8KeQq0GTlahXTP5bY25ZpT7NCvC\n", - "39VcH4W0LkByiiDiA9p/TAVVS9b4lcyTsDDQGnrjEMbMIK74U+q+/Ha9QgIEfppLe3FOEkcYq8Ds\n", - "KPo0WcIImJvi814Qvs0WSKwggg3mqU4sFjpMHkPH+9rbmlUGEmmTBHOt1tqknUHb6ZgAE6FicybA\n", - "VGLdg76gPYs+/2kj1Iv9TtsA6ZK5roDbvQKii0W47jbV+xkI++jnWRTK95yPiEjFiBEjRowYMWJc\n", - "MOKLVIwYMWLEiBEjxgXjhVF7dXNim8L9HEqI/nJxWm0BHys8msNbRp1I92co2il+QzVErqlQa00d\n", - "4MG9PYiCO6Xd4E+lkDWhPRH7EWXNSqHR8FsW4DVz+DTLRO02EkYHFScQI6FI9asg7K50H/2jWmXR\n", - "RNDt504PEt9Gqq7DdfW9OixTsKc/gD+NtDXFuIM4y++VQbw3dO7BNfYBCk06pRYhnhS6MaW3yyQA\n", - "Fd8TnG8q/b+EsFZFwSykqs72CYSVgxZSBty9PRMfn5xuw6DMpPBsASde9YzZgmbdMZtn84/eJhsI\n", - "FfOlQ+Y54OhRVLkZPIJqeja1Pib3svDbrdBDY0YvNHHdxVhnQWczp4DVuZh/VgJ3n56FfR/gnjg9\n", - "9WOVEBGrOJuC8V0fobDjwwOnoB49CgV0r0jRZNKRzyskTCG8UpbujuzHp+hUPWsaOmvLYOf5rdfq\n", - "Sg5/JPE7YtFYemYNpvcSPLMksWHAseozF3vvoUBxs/JjDbjHCqGAezr1q1N1G8bM43vvT9sOQQF2\n", - "cH22tVNm2cgKDL7fs+K8sNkwj+WDJkrAsVrkE6R0OynQOmLfpEoyof0o7Femgz53Y6fUDkTRQuMm\n", - "GasdaKWAcAx1L2f7JKCiZnOnXfJtGJ/Jzr0OzzyRapzgeyzQHj6HYNmERoRoOpVqB3S2JgWejir2\n", - "x7G0XemFJHRzkcALqvdtLb3iai0GjHEnfnsd5lZWCpC6y9P8nEvReBbV7tVFH0kZuYjiSe2tOqHv\n", - "09BO28bnjhr0+notzzgWQeYh5J6g8D6VZ90a/nzrtRZohohbHl7VAmNHa8BjzpZb3BIWZsazqBfP\n", - "LBa8HkRszwQB+s6Fawh/J5kktPWcE8TFHaL5mVbUyCO1FyNGjBgxYsSI8T2JF4ZIdV1vm0ZqflGU\n", - "KunKBpFf2zrSUeQQjLUiFIcY+srSV78nm3vhe7JK6+E2u23DW/go7qxMXVUR+TCGVcUob/B9AqRJ\n", - "xGlJGlYQlaQE11usPkY5BtxZJ6RNBHMlUBddaY1wVs5kVddh5aA1wXoIATMR5TJdtZXlfJEHhIW1\n", - "oVoRh6aonVTpdfG8k/OokoqIM6y6l6Lia2usnBa+rdlSqO5tTAQuHZmaPH1kPVZ9vdQGu3olrDD3\n", - "Kl9pLqvwo9Otux1TlVmlLh5PUTNxb+bIyQkQhgrX0Inrd1EALRscwWlrCCal/UekEFcLSatNQhuv\n", - "156SzVpjpqm+WInOS9pfiOgRK8JxKSvynmJXSQ2m268gVwn6cZAVqQFpWIr9wBptO3AM5YpgYBUq\n", - "ju1ERxcLRwRXK1z/gZwnUBKiWuEYcGCW1SdRJyJCqaBlRKu0NhxX5PO5iPJxTywXjv4RnWqkPxdY\n", - "nXYigG0gqCVKN4rVCFfme5LC3cFRPZf76gwC/T2xbmjr0BeKZvRIPGiOn07bMqaEP/i6H/dVCM9X\n", - "4bqXufdrewlJFPcFET4M+30k17XEmFmt/HuHh2HuPJXafT1dUuS+p0M0ETwV7NOdXhGJBEk8ZSWo\n", - "Cm0vBCWYarftWC1AUC/zNBGuGY5/78QR5Ltn983MbN2KszlrPIqtQIt6hm0vlSo4x6t1DBHDVJBr\n", - "bJsXYe7QGqKsYZnsYBBzfE/E0UC1ErmfM6DzvVRvoFB6EOsc1t2bNOFSc45WE6UI0HvOdbknG/CR\n", - "odUmDPdxKUzMGU6l7X1MMrdkFCuWFvYsCRihnfyDNoz/vvJnctewUoPaCkCwLue0xf25ECZmRL1R\n", - "dQQpZ2HbYiSr4J+xL7SGIWHsTKqnEGFdaAIO2r/ZyHMac7e6rkz2SP+RiIhUjBgxYsSIESPGBSO+\n", - "SMWIESNGjBgxYlwwXhi1N1hrTeu+Tx1osaETeBK+QO3gGFs3UOyrAmwUPBUKbAH6pm2dlhsg8j0+\n", - "fYT9+/mwyOVMhNsZYMxB6TnAg3nu8CSFr+qtwmK96sCclnSHxTFNBJb4fjbTa6VjtHdTC5pRrY2S\n", - "lII9gZaxv1QLCYM2Je2irtN08U3FY2UqULvjRQV/IikGWgD2VBolAVS9VbE3hIKJilcBwY6A1kcR\n", - "9ve4nkH8eWYFi1wKPQAMeKbQfhfokLmIDasx0IG9eJbM6U+CsajXShE3PWHMzDagkcZeKTN+T5x9\n", - "QdWenbkr/9gGOiwrRGyZh/NLRwr7va8P9gK1kIk/FgtI972KbcNv5+KPlMJbZhSqeAE/rs3a6R5S\n", - "eqRxtPAw26KaORRO9/BeONh9+EitVo63z+FAnYlgkwVHk+eIzZMdrgDXgO9tNz5ODw4Pzp0ni7yq\n", - "2JyU4k4xXhZNTvW3oU1ILVbiYJxDgKqO0cs9FM1upNoBzqXrXKpAurE+dVqKdMPy4LJ/70mYi1K5\n", - "o9vTx+F78H1qn97xYz3FnPSSO3uvHwa66+Da9Wnbyb33wvHlPHtQS1txwGc7dVrdHF2bTn0ngmHc\n", - "47OZSAZA/a23Wsgb3kJayJvyhUopGFL74mOFZBCOk6Ol0/NPcI89fOY0Ug1fvEYSBeZ5GBPr3sfk\n", - "iGtMRBRdFji+zLHFNCZJd/v59pCR9FKMOMO8OtQy19KfbNCBjXl6VAqQiT9aSByfdfRH8v3OMIfK\n", - "9DclnmSF0Kh0+zadJzFPy30yUAAv88mI6hrqt8QbdOrORBMLwhy2qX38t5vw/c1aqD08kxLxQOQc\n", - "k4p8ZLGEBCURCnokfQ/frd7n9dUKBaKVMgbdmnbeT3z+qKSHw06rDQwoJN+JAzuF//+xiIhUjBgx\n", - "YsSIESPGBeOFIVJjb9YkYlcwBAShbH31USLVWwVj63VYrS1m6nYd3o5TedOd5UCzxKm5A7JRA6Vq\n", - "RGA4h7KsEqQlx/FlQTqlGOsKgiLLYetfLGdIv2/1XTW8pSeTwFpEhBSljrrUYLq0n1OanV8lD1CM\n", - "DoMK2+lE+5z095Lon7gew7Fd38JTiP76RJE2OstLSjgEhVXhIu7TBunhkurPFYOiD0xTX+FfFfun\n", - "SCEu5/6DDUSkVeX9P4lic//tM7g3l7KtsLDSycWmILfQFus2jJdE+qSlFYK6I0PQq+7kxQz2F2In\n", - "wbqCWn+wgQBzX92+JzQV56boD5CYURx2DavqptNVLZ3t/WsJEIFCbQKQ4j6IJQhF2yUskBVVZCzm\n", - "IjrtaOuh4xTjX1bOiwVSjaWz6Sje1LoiBEqzpOtwf+77Tz9wqwG6bi+XLnafhOLqzg00ZZ6LiBrJ\n", - "GFUhqc5AaYiqqTs8r7AQVG0Fd/Rc0+WT3e+HHaNNWh9r3UlAPbO5I1IHQIROxL38DOLqZYX6l42u\n", - "zIPIOt1IZQXU3ZuL23QNNe7RZT/W4wcPcY2CHMH5XBEZjicibYOIqHmETqw26izMp3npfTJinhpU\n", - "MYx233E/mJJnfIwnGAMzJirs+TPhQ7AwyeWZkPUBsatrZzhaoFNpL87WBW0avE8K3Nt5rk7l+AdM\n", - "hN5Xk/BeEFkmMaWFJAARRR28XYlEKcNB93a1MyHrwbk+kc84PvNCS1CwAoV/L59qUgr6hOQdrVM7\n", - "DqzJeR7hH+TcqxmZmPB/tfVgAkhTu7B/vUKlgFquf2D1DGFieF213Kd7YRwllVpHrHGJYb+a2MA6\n", - "heqinkyoohwf3dPLe8eASho6x/I1Qp3SGxkzz4uISMWIESNGjBgxYlww4otUjBgxYsSIESPGBeOF\n", - "UXuJZTaKd8YW0O4sdYiNLqqF+JiwkOm6cRixhBg3EQqKfhuLygW4NaiNFD4+iUB3dABW2JEOq6la\n", - "KxMKHJSygcdG5tBukbBAr7go96RqQO2J7xNpN6Unree5OKw4wtOol+K+/VRQUn5Kx2IpkFmRooAr\n", - "7LxyKH6As/hGxKmkncZUbNTx57wQd9iB1KKfewk6aHMmMGoOF2HxZSLcSvaiFCEoxdujiK0fPwkO\n", - "0HuLm35KoOA6cSWn2/kqc7FvhzZpxRfM0I//N3vvEmtJllUJbvub3d/7+i88IjPyE5BkFerOboSQ\n", - "WqjVElMYIiUDJFJMGDBJZjmCESNGSEhMmSBGiBESUqtAqknT1VWpaioaIjIjIzI8wsPd3/f+7G9W\n", - "g7O27XXrOZnSk7K9u3T2xJ/bvdc+5xw7ZmfttddSQ+tDgqX7h81oVYvmUAtHCZOUxlQCKG3TFPTY\n", - "kuEntI9iqP2GpARfA7KexfZ9VS8OWXUX6VAm9gvuo5FSNhHUgXPSYNIUmJoBzxeWMtHxyUrUw+Q2\n", - "QClwHJ/HrjoQzEjbSdNhNaX2EuQKEqR9MrpflQjNOka6v4RSwJra49SitvViQcUrk6aTfU+J9JqC\n", - "zFK+/6H7w0RsiPt0JRFRc5d62u9I265XzTQbJ5vetfHuk/9o+zt9gmslvaHQpeVq1QwiF4EaKaX5\n", - "pRUxLJfu+G25pW3uum/Wpg/06Etfddtemop6hzmQU8B63RMRmK5BW/CgrzEW2Nh1mke5eIScJ6Zt\n", - "SDOONHZbjFO9h0ZKj2cYQzmN62Wu+nDW1y9uXfsMpE+k6fOM1a5BFO8ptdM2h0U+CVERVLNpGDi1\n", - "jZQZjasR919Pc+JkVkyPE6UlsNtBCNK4UiE6mpSKwo3XfW3aYurekVK6vcV4TkjbUHD8gO6nFM+A\n", - "kdTzK+g7ZpQ+nGE/M6SPIyrY6XDftQc0EtBCqHhG+zggbbs8O3bXFdszoQZFJsuPp21K+djuXPo2\n", - "ICJ6mmmf2KUGKLZhGS1VVmdajGpWcVGOIC184MpBKf/XhUekfPjw4cOHDx8+7hlvDJGKwlACsbdg\n", - "feFjD68kdiuDhN6009S9uZYleWhFUConmYQCBO2Q3nRzrHZVCbWllWakpfnMOUTZKxNr69q9Cce0\n", - "+lKfvDBiYjX8egpbJXUd/Mxu3XVVIaE/AmSCylAFiEDI5ECsiGoCiZLkLtlYm7GnVUKPFdYARCog\n", - "hdcEiEzZG2EzUEQuZpQEqxUicbetvtXTigjEakbd2gHXyysy9I+iakxENWK79dMOK7GqttW3kh0r\n", - "IgS2vSPlvrr+Yto2mznl+5KV8uFrlnSKSNIKDsGrRV24j6RYvVyAsCk2JkegjxH5OoHXa8igGPG0\n", - "ApqmflAipApOgzLB+K9KJkyqii8VD6gANZFNrS+onH1qYy0D589A2KWlnn6uKIiIyMuXL7HNCNOK\n", - "iLCyeTLJbtg9noHkrqhSTONqxIBerUzFXqU7EiKMq59WGPB9qmOGCbhADui3SazuCSDik9dfhNV/\n", - "3xjSpArH1ZZQotp9HlIByu2lc1ZYECn+eOUkC/aVjeeXQJa++uUn07YtENO4cWP4+qXJH+Snro25\n", - "1HuNY52cGrF8qN18Mp+RKwNQ7IwQyUDbiVbk2hatSr3QsdQ9gRFJlTpgr1MBwh2zh57OpyQxkUDu\n", - "JSPyfodzakHUvyEZ650it3RPqGTFERVF7IAq7ajYSPuf5Qy08GCkQp22cihe06BtCMFR+YMosOvq\n", - "kTGo+XmC39Q0UasrAjXn9GxpOTsChfxx0MISUuLHjV3SfrNUn12EtPQ6J1BRhKrIU5FREZ7hGmg+\n", - "xT2T0DwRQ5U/RsYgpcKGFukEsmuc0OGW0DSVP2mpoGmlpHBqk149awlNi4CONa2T9eDiAEWx24aJ\n", - "5W6/uy0jV+7fvGAPQfX4ZDkHSPzQmGTJiteFR6R8+PDhw4cPHz7uGf5FyocPHz58+PDh457x5sjm\n", - "QSBRTPpEg4PHK1KiTQcH1bZE2FZcNKKURYnfFERULgEzj/SuqGS/GCmukKA7JZiROPUE8Y2U2osA\n", - "cbYE9wv21xC2mReAsVnFFXDwybFLi1zfkjovSN4xE9ZBMlZY1e3X/VvVlNqBxkZAebGxV30YMo3F\n", - "tgB6SuNIaSSk76LI0ihV6/RpUtY4wd81aXEsQLbdkY5WC6JezebKKC6gbN+UZg0n+NzaWgnFCfXr\n", - "iBTsvjTT0ix1x2dtr6p2n++bV9O2cnTX0w02xobRpaBUW4VV5O0ciViMVEBHhHHdlrAqeOuOEVBR\n", - "QBSotg2RZ3uY0Oqm0NpLSaYRpVbXG3cNnMbS1FYv1LBoTxKxlkyVuonYqzpSe6gSsz6WajvFlApR\n", - "E+brayMx6z40Tef+zg7+FTHtoTRlHSuQWKEZNY6cnqvwHUvZFLgBON0evMbIWNOIA0Hy2ma3tzZ2\n", - "zs8eYn+qWM3fR7ozuUvEZmK7IKVyCzVxd93u35fPfmTHeviOO1+6xx8/PcM5GXn45Nhte/bSpezO\n", - "iLBfwoQ4IBLvHGnW9ZXpbdUgqOfElC5BPD8g6ud6/9nlaEpjhAJ+zBa1oxLwbZxstm5M5AW5CKQ4\n", - "ZyJ7x6nqCFEKRukGlFLVVKJuOlvYnBShYOW2tPbaY/67JBX5GppuQUqEYWhGzYnErPT5jBwlZsu3\n", - "RURku3Fp15tLm6eD1J1UNiMHCtAx9lQ8pRqZU8w3AAAgAElEQVREXChRqY4UEdUHEKBZvi1G+nhA\n", - "yjCitOu+Uj0l0rbDvBf2TC1x112StlMSq7YbqX1j/jkgyuvYDjgtrhpg0L0iGomm6plao84KARfg\n", - "BFq8cPd6TopTO08dM5SC7KH3l0b4XmjXpdSHOCFzeUyo3YGOI7TdRnt2KVE9pnTzRG9gHS3SSHtd\n", - "eETKhw8fPnz48OHjnvHGEKkwEBEiZ6coF+16W2lUlXsLTCMqyda3WZYpwAKv5hUB9hcHTNRWtVP1\n", - "K6LVZ4c37pBQjTXIlgtbriWQX2jprXYiyNNrqap9R6TOOq0I4Pk2L8wb6+LmhYiINK1df5Kc4zyN\n", - "xBwnC3xm57lD6Tot/mQQVQAmsjne/pOVI6yywm6Hky9iW9VvtlDWDchXDKjHdrRzktitdMeRFLBR\n", - "Ht61tHJPtb2JxJgcqp2Pg/VhjGKEkRCcyTuPVl/Sq4owXStWaU1vq9R279o2ooaKFBFD32S0glS1\n", - "W9b6DuCrFxFKGIqWGtv3aizxR0IOe9xuQ2Sk1AErt3BCuvho7nsloXrzpVtNxzkRhrH6ZQL6Zu/6\n", - "Z744m7bFKA9PMxvPV2v3PfXhYvmB1cohHZcXVmqvK2xGiXTbcmErfUVEBuq7ob9bkq2/6YDqaHm3\n", - "iJHNmTCeAPXiFaSiSUxsVyQ4YsLopApN7Y9dX128wj6IbF/Dw5GQlv3WjaE8IfkTkIIzIrFevXDj\n", - "bkGI0Pb6c3eNRw+mbTtIJsyp1HxduTGQqYTKia3Wwyt3r+33Nk+kmfs8ohW5YCww0qWIXU3IdYbf\n", - "5BkXj7h2Us85Rp9U9ZzlGtT4jVHSUdF0KrbQEvMgoj7WUnSSLpmU4oEqxoSqLtAXRyRrsbx1f89z\n", - "QykutUyekYYEitmk7D+Dj988IaX8BIUUR18TEZHyoSFSnz7/gTvdwNpV0dGRxtUGDhwhuWfo/H9A\n", - "bB5VRtsuUj370pVrp65nxwq9GFI7byB1Q8+zAG4LPJ+MqlRPkjiDzreEvkTq5BDR81Sfmb37rCGo\n", - "u2vcfmtSFtf7L2aoUzM8BGc1KBrqcnaqcEUTHaFpLe6JMdBnKKnDixaAMdvdnSfVtUivGZnGxl+D\n", - "648Lku5QT0hytIhCQ0VfFx6R8uHDhw8fPnz4uGe8MUQqjTJpCX0Y4H7OXmcN8txlR+Jj+uJIaJYK\n", - "otX09q1V/7y/EG/dmiPvSBogwht+R75Wmj+vtpTnXbi31SKjUmMANklsq3StZu0oz7uE2GEcuLfv\n", - "LLIV/NHSrVKfv/whHR+cIir1DYGYpYl13XYHNI18hQKU52eRrTQbIBx16VZLaWCrsER5OAG3CdA3\n", - "SuBPXBJaJW12bvWdENJSQopgGAkRQFlrlNP1YLkZiVsFzmaUi271molnhcYeSaRUxruCkOrFt6Ec\n", - "eQiuVUACo5ovHyFXMYyc53dtkWZ2/Ao+jXlOrvYonY6IU6ACbh2hZDHGbE1cugDIXgBn9JzK/4uV\n", - "QxqWkckKVBWEM6msXsuP29au6+TY/TYkr7kI3IvNllCK3I1JRelY1mC3A+rIihxYmR4f3+WZxITm\n", - "CeQ0Qlr96zGyjFACdFn0mjXdCsjpixef3/mMESkFWPj69VwikprQv89ODaVTccIc3oBNZW2jGhLl\n", - "1lBN5Qu+eGXntHrgkOXtNYlkAv1h6QydbpvW7pOTB+6+v3j+fNpWoE57KRgLM1tBZxBOXK9tH1/g\n", - "t+ckf7A6cuN/x4gIUMyEuHQhPNP2ld1PymFTj70DWQ2d2AgRVtCbeU7q9Skpj3/tMy4l198wmgw/\n", - "NRWaJW/ACtIRPF4y9Uml8aecp5ogiR733X5naPpq5VD/+czGxOmxE/vV7MPtxjh1irS8uP5o2tbg\n", - "+dQPhlqEmJ9CEp9UZc+Rrj8KCvyWUCKgs12l6B8JUic6rokPKCoNQJJAOifQ82+P/cbEuTQVS/K4\n", - "zN0xUkJTA8xjLea4gJDmBtmXkF4nVBCTpR56UZ/Suzzg263dO7lCkCNzqN22DL6r48jcN4UwaUxC\n", - "aDWluUYzRyxm3UK6pCfU+yh292RBKBkjdq8Lj0j58OHDhw8fPnzcM/yLlA8fPnz48OHDxz3jjaX2\n", - "YslkICXoQYlwRDpskfaoGkoPQMW7Y7Ix8MOAYHz17utIbXeROPg2h+dSyD58IOduiexeg9CWkSTA\n", - "gFRdSmTfZKEwMqnDQvm8JQJeD+L1AkrNOamuj737+/zkS9O2m53zxOKScE1pJXStMeD5kN6LFYJO\n", - "YioTVxgVat8n6VfsWuF/llHKaj6DrEFJvkpQXQ5i29Z3Dh5tOC2KNM5AfkUqtzAMXGKuCuhKbKdU\n", - "DGDscbR2HQMoUI+U2ovmd67/9Pg9ERFZI40pItL2Sopn+XoUFMTuuhoqTc6RHuRxGoRKNqeSeKQP\n", - "xwPCJsqPKY03wmstovLzGaQbMqTMciI4Qi1gKm8WEZmv3LU25FfXt5oCJkkGEK8HSvfK5Alo17iA\n", - "ArmmEziNq3urSIn7K+86BW5OmWm6oSL/ueMTl/pjFXM9bE5eZ4qoq0wCK9triolhfC024dSejqeG\n", - "zn1M7ioWz5RQTe2k+1G/uIEUu9vK9ftIUieb0hFgB952CTcAUpaePObIAUHviZr8LOs9VNGpAKKY\n", - "u3Rrc+PGa0ptWEFtu5jZ/BM3mm639i9RWJKxAjxK2DmNl6AUviWlbGU89DrH0v1qas8k9YG0ND9N\n", - "tPy/p3Sr3ncByZlohx8UqWPbpDYvd9M4fF0zHU90X2vRSk/nPqJsZE2p7bNGixy4yMKllI+RWp/N\n", - "jbKhabzNzu7hWmU9yH90uXDp3h3NPwnSnAkVT+k9npH/6KCedKPOK3YNKYoDMklpmzvuLGG/vC2u\n", - "3/q6f40DgvZimrF3Jjz5yPe2h0xDp/IXNIUOOJecikg6jImMpE7UlWKgcdrhOdXTfB7hORURzWIq\n", - "WkGbHD5DVNaAnjWgsTDXPVT3DLpPQ5VRCW1M7Cp3P2cJ+XQmXv7Ahw8fPnz48OHjZxJvDJGaRbnE\n", - "9GZ+0zlCX0ueRzHeiIfGyiBTCCiObIqnQSWhAtE74vpOpHQlVs/nVoZc4lxuyddJaycPBOlalF8T\n", - "cpAVQERoNdvpdZAkw9W1E8xbQPYgiOwtN9A3YxJaUxG0ngiDEYhyUWL7jbBiy+ntP5kcyS0UiYjw\n", - "9r++MYKrIggJCSgez93KbE6rv6ud+w2Lug0TKZ4QKfRTxNbpo5bfWh83DfoiVxE+IvbjPX8k/7sE\n", - "bVyVNiaW6MeQynrnOPf25BenbT969b+7/REBfmhUJA7XQEib6lDyCnIogb5VRkCOA4hq0jJNScYd\n", - "jz+M2Y7G7rZy434Q9YsyBHWe3e3/FgjX+sYQkWMQi3t2K8e/jEju4Tv2+MnjaVuj9f9AGmpCdVRo\n", - "8cG53Se2IqTrwtGePH5r2qIl2z05rSsQlGdElFdft0Yd38kFHqgbSy0EIEoPdAI9vB5VQFREpMVv\n", - "GbnqcD/zb1X8MQaCcX1rpNcGBNiM5pUGROWBCLNhhAIQLuxQTzgSDlUw52hlcgbVHtIJjLChLfIz\n", - "d0+WNzYnBWhP9bcUEYkw1gJhlBAILx2/AaE4pPFUoABmR96VAWCSFqh+TeintueM2lqlEKKUUHqg\n", - "f4xSJ6GSmEkSQT3ZmCiNcZIAfWGhxRrjb0sTe1IscUxCDTAX7GieSJEBiEkm4/LSkcYfn7xjv4XY\n", - "6emxa5uHKyv2aFp4eO5+PG1DnYp05LWnSEga2zkp2T0h9DEBAp+QSGtbYyzgOdWQIHCK8v+wpyIS\n", - "yA+wTFADf9KGxIdVCiikAqgIY5YRqQQipjwXjxBbHnG/9uQJG4YooiICfICxlpAnYYB2v+leTNuG\n", - "0SFBGaFZAbICTceEdswTexTlzEgSBW3ImYYSRUER3RMj5qmmo/E/w30ycpu4Y233z6Ztx6u7Hqwc\n", - "HpHy4cOHDx8+fPi4Z/gXKR8+fPjw4cOHj3vGm/Pak0HYrmqYUgak8TDCVyggZdcW/k+kj6ME1JBI\n", - "jCE0e0YizCm3PAUEvToyyFa9uV7dkmI6YOymt3TLLHMwctvYO2iKtBTrTkyQMqVWekDlz199JiIi\n", - "D84MHtV0R0gQb9cgPUQEfEH6jLWQikJ1VEhtGmTniODmGgQ8TTvttgZ7L47cdYVETk6gjp7NrK0b\n", - "pGzK3rRVAoWqAztWlAJSJR0n5fj1RKxsABmHUBGfHWgMKTmaNYNc+/REQN9Ujjx/unx32pZBe+Vk\n", - "ZWmsy+3X8O+/2DEACzcg2xakRK8k55RSi1nkyOFtzyq+7vORxm6YqIeZ9XFVq0+VpQWXkeo4YQzN\n", - "TQuoKTXdZfvYbOBrlltfv4Iq99GRaUBVE1HaYOzTh44oXpPaeqJpaaS4VGlbxIjFKaVsIuQ769r6\n", - "eg7tr47aRFNAEaURlCBKXO9J+0uJ4kl6N2XPautKQO+JgK3nvlnbeM4zqEgT2blBqoKJ+kqAV6rA\n", - "gojwL166duqF7j+kAAdKWc9w/5WUblkduTYpS0tZjTjnem/9r6mVhPznJo8/jKc5EctvNo6A3pRG\n", - "zj1euXlnu7V7IkeKviXNnBW0x5rWxsRuC7cDmk/VR1C1eDh0THQdj3+3LeNrENdPOSnVq4ccz4kj\n", - "UpQjF2+AqtDiPJoDxWy3D1b724C8X9O1NiA0d9R3W8x387md5xqp+hfXNiccn57i++5+Ol7aPfn4\n", - "ofPhe3FrtIjLly4F1A82/gZQOhLS0Qqhts0Or6rLFrPbQo5UlfqZkgFsvXdjd5ER3aBHupv8F3PQ\n", - "Dbj/m06pEuTUgbEbcU0EUltC/dniPHvoA3bUJykKO1I6pwDjhD0hUxRecKHOrn2OYzJRHNqCpHel\n", - "6Wh9JoyjtdcwpXnvkujrhp5J6oZCen/qxRmRs4B6AIeUFl1vP5SfFB6R8uHDhw8fPnz4uGe8MURK\n", - "gu6grFl9uJjX3cNDbSDCtvrpBPSmHQbqHM8HANktJVZs4N4wUzg550SwC4EM5DNDlSqsHEfymuvF\n", - "rWDa1lb/TQ0VVfLriUBsDIiArKv5V7cOQWnJL2gO76g0sLf6GPvYVbb66Xt4o9ES4vgYK6aW/d+A\n", - "yFGjKNlVHe5bggT3G0eEf3T+9rRNSbkFkThTECHbhkpd8VbP6IuuqntSJR+wIhuIqDiqTxzQipRX\n", - "IToY2MMLSsF1Z6u0Ye9IwQ9OvkrXCpSOVkmn858TEZFdZYTiEoUM6qvHMKn6inEBQBA45C4Qch/X\n", - "z1nZHNc9oxX5ogApfE99ApL5PHX77cnDKsbaNaLrV/8zlil4/MRJZlxeGUqocgLLY1tNl1pqT/IL\n", - "7R5yFiBUj8LjxX2PEZEAq9nNhlzlsdJcrkwmRBGLgKUWFm4cban8fD53v1FE7oAIrsUWVJyQJEqO\n", - "tv4vQFTl21+PcXJkCuwT6kXk5dtbN+4DoBoxee2tzl3bba+ohB3K8yxhUAJpPDp9ZMcCEhaR2r+W\n", - "pHP9wYBVb0/+h4vCnfPVhbuG2cquoVB1cpr/KkgdRIQ0aIHCjFDyauuuP0wJftCxSwTcLNX51LVo\n", - "vLLxr4rlxczuKz0ndacQERmx+qfulwEoAiPMOo8Vc0Iup/vO/RORr2GHz1YkHbPY4VqTL6ZtRzi/\n", - "drBrVcIye9cpEvTxM0McjqB2vliCnE2EfZVnWS2sAGMGsvtN+ZntN8Hzp6c5Ge3as3QPbvf2AGGF\n", - "ejfaKaEipmYHsndC81+D9iS3i8VEcqdCoQAZnoNiGxQ2kHehToE9SQH1isTq/UnzZBZoAZChr4vC\n", - "3TsBeZJqh54sjNhf4Px2pfWdts9AY1ybIAGqqSRxEfMT5AIMlQzSdwi3EYicWPvr+Mzo/tPMSszt\n", - "3lER2mvCI1I+fPjw4cOHDx/3DP8i5cOHDx8+fPjwcc94Y6m9chhlJC2mBCmOODA4rwMsHhG02oG8\n", - "zGkp1SVKSO9I/2QtjO3ewXNKWOsp7VUgtbJcWCpk3Tlj0oSg6E3tUgErIkXf3rpjHAdmfJkgfVKP\n", - "RDZFakuRxav1x9Nn4ehI0R0ZHweT7hPB00Clj4/sWHECE2ZKGfU1COWxHb9SVWCYonbU1qpsvN8T\n", - "YTd1+z1Qm4bCa0OpNdX9CAJL96lBZUgwahRD24eup2uR7kO6sSEScwKz1pFVlHEyTFiuO3fOm4rI\n", - "8/kjnO9dUviD1TenbZ++/L47j8HB3gz7Bw1Uv4nYr4ajfW/9lEZI45JpZhBpqpL0XqDsnrBSfu3a\n", - "LoHJ73JpaZwRar7kxS0B0lgrguKVWMuaTTFUefel9VMG7Z/dxmBqTRtd37i0IOupPHnidKFYxfx2\n", - "7dLdKWmW6ed7IqrnhTvPjDSDcqRZX61f3Pmewv5Mdl+tXPp8TSTyAqnSjlIh+0ELUDhl5K6jJl0u\n", - "lYOqm6tpm6pi75Cqu3hlad9EBxlRC4bWXevi2O6/eu9+W5HenWgBAqU21KCaVcm3a9wnpV3PBlpF\n", - "p2cufbQvqWAEOlZnVFiwR2qvrImCgDGzWpGOFtKtfD9rNr6j+3QHl4cOk42mDkVEchChSRxdBOMu\n", - "p0KJAYT2NOa0uJ4c3096ImQWDo0uNQoY6Z5Ug25OGc8X7n6aH1m6Lbr6kdsHmyGj8CYoqKABxOeR\n", - "6Osffvx/i4jI8akrzohprjnKXYHSMrR7OENqr6ZnzQrPtpAcMFpNn1IBhrpdTLwLERkHnfdBhI6o\n", - "iCR3fXGztTT+InftPuPcNlKrq4x0nDr3944MisN0Jv9tzBJ3jT0RyjV91lfqUG3jup3oCHavaccu\n", - "l5bG09Qz63gtg7dxjTZP7qEsvquYvD+dibsW6n8tjuhaIqD3+hkXKiFVndK7A/q9ozGplILugObw\n", - "kzEnj0j58OHDhw8fPnzcM94cIlWPk5eZiEgOsnfL/nsT6YxQAixrWH6gV68dkglQddaAVaGBOux7\n", - "tyJNa3obx0vyrCAV7RKrFVrV6qpmRyXsuorf1/aWXkDRdWBpa6xYVM1XCMHoIOtAfG1p8VrNKtIn\n", - "yy+LiMj5mZX1CwiV695WjmXr3uZ7Xn1iNT/27rNlzm/wbijc7olYCwSBVwZKOkxo9T+2d1XUdZHC\n", - "iyT1eBqorHpSyEUbNi2RiEGEDWjPw7Q0IZSudX1S1kaOrBr3d0KrnzBU8qbt72T1VEREXt7+s9tH\n", - "aW04E4e+sUyHUoUTUvEd0XYRrVJVRT4h8nKkJbvsCRZoUQBI9LUdvwKhOh1pTKoUAxHbX3zhihHO\n", - "zs6nbeod1pInVQ1iOSMiKjeiqMPbT9+dPpvPIfVAEhot2nqxMOkQVXRnrytFP1htnJXfLbCa1HJ1\n", - "kitQ1fOM1PZvrl35f0iQpMo5nJ4aSlQBnenJu1ERu4HkTEqQ0lW9n2zIjORPG3UM8/jX1tnvDaaZ\n", - "6zlTCbkyZss9qddDOkLlKkSstFtLtweSGgiBXOwIElJUL6V+VSmIhr63fOQQxu1LQwT7qSiHFeDd\n", - "332Jwh66fv2L5S96VUInEvVs4cZOzP6T0+RG9+TkpzhtkiED6gCUrqO2iXHvxtT/IcZOQPdVXMAv\n", - "riSiODwJD+Q/ADel5Im43ji05xMQ0E+XD6fP6hoyGXO7J7/26BdEROTVjSlhl7VDVR4uDGHWuWO7\n", - "sevZN+450tcsHZLrhYnI4X2VAeHqqDS/xH2yeg1hP6PCihVkbOLa+kkRKeLzy4j7NBIbTz2ed61K\n", - "Z/R2rBok/iCg5xmKcfr4pR1/7uYnldUREUng7nGc09yJ8dG1P7RjgDSuz/+6uivN0VHBhLY1FzvY\n", - "+bHXqsrp2HhK8ewOCKVleYrXhUekfPjw4cOHDx8+7hn+RcqHDx8+fPjw4eOe8cZSe5tqlIyIbiof\n", - "FJIWSojTW5ev7IdKjiR1XlXbbSrbZtkzu8QGaY5PLxwRscgMsm0aVf022C+F2umeNHs6pAX2W1IM\n", - "BmH3Zm2ppSRx6riqcSUiUu6dVoZ5oJJ2h2h6yK6/xjVGZPz4lS85LSQ2fk1AUN/vTQulRDpA1bRF\n", - "ZOrtGLB00LHCtZoG23WVtYNnq8ZgTW3NgNJzIaDSmPSWItWqsqNLrCrWgR03BXl1ABGSMiYTATwc\n", - "7fp7USVgMpFUdWQyTV5DK+rh/F07T1WMJsmQo5lLkdZIre4rIyJvAWfnBelY4Yqy2NJIg6ZxezKy\n", - "Dh2MncZEVMZv+5bHpPs3zVyqrFpbKkbTkikbfyJV9eLF57YtVKK2pQxeIn2zWFoK7vzc6U1VPafP\n", - "XD8+euSItScnRhhWQvlmc0Pb0oPPRESqCvcO5aAzKItHIbediw0pcD96rARh1zcdmQFXMFlOqYhk\n", - "vXbXGBMBXlN/rLatE8BI+xs1zUkw/nbt+jtT/TgyTR9jd+9ywYAKmtdkxqvsgYR06W6uPxURkZNT\n", - "02WL0BfVNRkjoy9WZIxb1Wr47P6dLexev712Y7IhysLJzM0119fcTyiAoHZav3TzaEIqzprtaKmi\n", - "QdPnquOTUtpPNb24ACSB0fSMNPhUsZ3TuRHGzEBt3ENZPaJ5NwxtvIscpt2ublx/lQM5UIB6MSdi\n", - "92ru2mRVXk/bXm1cu/Mc37aq7WVtrGTjjz/9zyIi8vbjd6fPZuc/786XcmEPzhyh+uuP/6dp2w9f\n", - "/Ce3r9BSe6coEJrndp9ejC4duA1t3tmBXjErdPzRvYY0akC6R+XWXX9LRREzzI98n8SgdhArQEKk\n", - "hUOhZxx2c0BLQZFXiOKJitLTAc4vLawN68Zd4/7GrquHAnuSWRqvKNy4n5OjRAyaR1vZPDGMjr4Q\n", - "YNwx3UDNoFs2Ep/Sc3axWhRzYCQeKnmeKTgonqJxOAQH/I474REpHz58+PDhw4ePe8YbQ6TaapCu\n", - "IIIXyqQHZkePqqZKqw9dLZFibafKrqSsO5VukrK2IlI3N+7tdndmq5VggrCIsIdX847Yxi3I0R35\n", - "yinJeUmeYMqZLmiVNMvcKul279CELCLVVyBn3WCr3xylq1wSH+EN+vjIkIMZSnJvN0ZUfvYF/J9o\n", - "pSEdCJhAi0I63+kSY2uvEoTtiIjV7eguLGqtTRItFz0oCgByRL5KM3h9hVQlO6FuuK6YVnoqJzAS\n", - "YXoI1cOJEIlU1b6p1B2Lo31NpfNzdx3bC0I98efJ3KE1EfmlVSp/QX2SgHTYEHKlXodxYH2Sg3ie\n", - "kPzCvnW/6cVQpzR2q/iqv0vOVkXjhMqfOwysJLR7R8nA6i8nItJhxXbESAdWeIywavufnzpkKDwo\n", - "K0ZpPh0rS9QVwI6lxOOAiN2pklyZ7QkUZaR73IoH4NdF6FMDlETRFRErYY5Y6gDXX5H/nBaZ9K8h\n", - "jG63dp8ssIpWwm5IRQx9wzX+Liqgn2lEiJSO+55W/1Bgv70y5HBx7O7/6EA6AirWhJKZjAPuDUIV\n", - "CiAIFclaKPG2IBX9Aavq7c6uYQHEqGX5ARB0e0KkmknuAK4DRITOIfsSE4l+UokYuXgG45RW/00F\n", - "pX4u9Ud7DqyADq83RYYiQgSL3N0Lr0htvsJ45nGVQs7maG73zm2yxXnY9SSp2zejmTrGBsDF//KD\n", - "/2v67ASK5nNyoFC1+7ceWql/F0I6Ym/tGkH25PzcikIyOCV8/uKfrAG08AS+diMVJUUoAEp4aGau\n", - "Da8bQyTnGH+MtPS418OY7gk4RXAZiCKRARH6g8llwX3GRTTHS9cmcUoq+g1kGqh46dWVeyblOaF0\n", - "yAj0RIDXIo9ZZnPXrnRz54DSDpa16PAsGtjrM1UVcxprotIZhFxN2haEUqJoQe9hkZ/+ouQRKR8+\n", - "fPjw4cOHj3uGf5Hy4cOHDx8+fPi4Z7y51F4zCgnmSr5ysDQrYavGg3RMNsYpE9lc4fuA4L4GJNqO\n", - "4GZN4+ygt/Tq9uPps0XhYDzWk6igxcRq12pGKqQArcS6R6cGQQ8gFFd0/BxQpRKhI4LHswRmuKQZ\n", - "pKK0aWyptRhptiQyGLUGoTyi7pyrWelgMH6HFEwIUjibJqcwvGRyaAsyetcZZK7mvjnJ/apSfDta\n", - "h8bJGY5lcGuA9/YFKSCH0IjpQBgMqU00PRsS2XSOAoWUFHuVT9/Upu2lHEPW7NEea0mxt5i7tsix\n", - "3/jY4PnrmxH7NXg6XYKwSNzEfelSBjkRQMcR50kpKD3qEBrZOIjVcNO1Q0nGm33o+npHKt713sH3\n", - "nJ55C9pPdWX9OYMuS0NpvOcv3HWcnpsCtJrPqkFnP3DKyl1PSlpcmna6uaE0AsjQ7CwQ63giAqiS\n", - "vCMyV9Xzi6APxPvokdJVMimf757U2dNjlypIYk7LuevYbGxMqEYc1RpMxPejpdtvVVP7I7XXk7aV\n", - "pttbIpsn6NmBdGwWSCPvNra/zY0rAHjwwAjotzcYOzMbUAVU6ysUr7BmkwYXBagbgBZuiIgUSAFx\n", - "avf21rXFjrTSctxvIY1TTaWO2NZ2dq0V0ucFpXZC9N1I16+p14GdAvAT1Q4SEYnn7jxHvqEC1QDC\n", - "9dDxC+hundK2zSs3roeKdAThRhFTUc4CBtnVQArwaozMOkEomlBS/rNn/zx99OGR0517793/YdqW\n", - "Zm4ny7mlgh6OrnhjX9j802E+TYg8vkBfryorXumRvsLUIDURq1VvjN0h1Nyd1bnXNe4PmpMizCMR\n", - "zZ0l5q6Q0s1aeNNRGwfaPpjrj1ZPps9WC6dtOJKOVALKwi2lltXw+uUrM3d+dOzSnDG5h0z0DnI+\n", - "yTK4d+DZ3ZGJ8Ch3nx06hpiWMGIb63JNBRWJfU8LJSLCmbyOlA8fPnz48OHDx88o3hgiVdUb2VD5\n", - "/wKkQFai7vGWOptZueTVjXurD8nrR8veO1ZOhncZqxiPIK8XM/eme7M1hd8gdETQILLvN4N7+29b\n", - "eqvGSzcTsJWodrs1AvIZVhojl1UCWUshV8ClmQUI47PCVpoVPLcqQhU2G4eSrRZ2nutbt3ItWeoA\n", - "5zSnFUkLKQZVM+6p+5XYycTGDUi5dU1v/zjljtC/AI3SECm/C905ZVRW3IG0GhXWx1GMslpd1ZJc\n", - "hRYeBLQtkQT7tfZPsMLaVhf0W9dnIWyA4DUAACAASURBVPkJyohVamwr8iCATEWonn/kl7Vyq8TN\n", - "jspwUWygCKKISInS4I6UnZU9O3Y2TuPR/YZsGqUBmjlg5dRHto+ydee5yljZ3J1vnrMSNRBZlhpA\n", - "YcHVhY3JUPuWVmlKGtf7juUKelwP+1XeXDo0bbWy62+Azpwck68gCNJM4tX7M6MVcT99rgrTtgpV\n", - "KZSRiKAxPm8IJVLkin87oh9bundGoCgdrfADlDWron1B57YGZN4TqqJK/AFLUuQotiDC9mavJe5U\n", - "ko623m6tAGJ1Cj9LKq/ugWLH8OtkErVWhfB1qfwD36cqmbKjdlL0o1gYcnL50vVnV5OfHWQnFH1j\n", - "vZAid78Nae7SAqB4RsUzOP5Iq3+Vs2FivU4oIyGxqsqtKAh7vk0EaCpAyTB24x0p0KM989TG6fmp\n", - "u65tSIUSQHEDGuM15owYJPKAniv/zwf/KCIiKTlgfPnRe+4aqLBmDkRYkUERkWvcOw2h5KJK7SQF\n", - "pM2tcyMjqCEUxQN6rmhyJCBU56p2468n9GvZu/6J+Jmk8znNcXpvtXTvBor2dm5/M8hLiIisjt2z\n", - "q2tYMRxo3sWn06YCnoA5OWrcbF0xRkoK7AmKNnrKZiQgfg9Af/vG7mEtSpmR/II+W3u6d3qM04DR\n", - "pUClc9jrEE4pPJ8H3At3wyNSPnz48OHDhw8f9wz/IuXDhw8fPnz48HHPeGOpvaHupQ+JxA2T0QWZ\n", - "PCqMF61I92bvYLmyNMha1cNrIqD10ILIKI2kkGUEyJbVeXs1vgyJbAtYPjrQ0VFtE4Ii8fe2tNTS\n", - "yYkzCCURX1EcVQ1vk5h0LwAdJqSmGhYutXR9a2aYLwYHlZaNwY5Br5o9Bq0GIJIPdIwI5L0AqaA4\n", - "pPQkSIRRRGTfmZL4aVuvaUFKmQBmD4iwp30RElE+gPZX3LOOicK4UKwdKe2Cdho6e9/vQJgMWG0c\n", - "fR2S3s6udGaZBSkLDyBDRgTVB0jbJinMQEceV64v5vNH9n0dV5lB20Hktm32RmxOYMgdlQQjx3q+\n", - "1p450tYd0qic4lksXbo7qKkoYebOKaFrbWEum1Fq5cXnn+NYpHdWun2fcqYIRO7N2p370YldVw2y\n", - "dVmSyWrp0lJ5bsdiQrOGkszZIHYGojAXheg9qFpQnE7QiCk9oSmtGaU721I1i+7qg4WUqlSibkKp\n", - "Ki0GqHCNPaURlQA/UMpGjVHjhG5sKO9nuaVn6tLth8n+vd7/OadPkUYisq+myibiPaXCyr07/q4m\n", - "c/dA9b6sTzQdy3QHNetmsv9kCM3m1kiH3ML4eLkkFwXMD3lO6WYocM+WVsTQD65P2HB90gqkPtEC\n", - "GJYbi5C+6ysdO9ZfGzwnrqjY4AtoSm33ZFoeoN1TKgBAoUJE+kjbtWuLek/9joILLViIYupXENr/\n", - "5YP/ZNcVuPv0ydlbtg+krzpy25iDjP78pZGtQ6ToczJBTis3J/Ql2obSUxmwj4YpC3qtZMYe4nu7\n", - "xsaJpv4zmn8TTcFS+rRBSq0kXb5E9cMwTudLS5lqsclua8dq1DWD+n+OIoacuA0VTLWb1vozhsp5\n", - "wu4VB0pXIk3NzzXQE2IbpxnaoqF0ez39bVSdiRZBQmaTkTwVVHhlcx8+fPjw4cOHj59RvDFEKs9i\n", - "ycjDqdyjhPehIRiRqmy39qa7XLq3yZpJrPCCYzkBJRnniSE8RQH0A2WdKa3MdNXHq9pYV07EM4si\n", - "RWnojRjICYlSy6tb5+eXkSp1CsJcBGPBOGayN0qO6c1bPb4qWi1c3zq/vs/l42nbMnfIFas4K7H4\n", - "gBQKUv4Isl3ICBaQgZ7UYSP8tiBic6uyE7T6VfXYsraS+BjkwX6wVeKANq4qWmFpyTZIpx2RY8NR\n", - "CYYWFVY6OY0J7bKRVt/rnVuljgmTkqGeTu1eQb1dUPIajLSq76Dmm1jHzkHUDQNCJOE7uCOfvJtr\n", - "109Vber5i8U59mttnGmpr/J6aeGlZO+M0IoYK63rG0M/iwKlxuS1pighl64/eQyvPS5/ByKWQB3+\n", - "6sp8LVVF+/raCOtaiv/ooa2+5wu3j4HgB/WzGgjpUGSXAIGpxHoOtKCsuDgEZHciseZAUAZakZYg\n", - "hTOJewn5AZZuuLhw13Y8IzRLfdpArK531jZawh/TSl8hFvYVVDeAlhSzC6A0C3I20NX3SA2QYo5h\n", - "lGQ6N9yL7OF3dApl70tbaat6+cnKrmu7d9dxfGRoYQnUk1fXA+5xPrqiVDmU0vfUrglQUlZbT3CN\n", - "vA8tReexPnGcCZFSiYORJC7UvUB9IHuSkNFd5ETiztVXcGdzTQOUsidPUCU053STjZN0gCG3ww5K\n", - "2RPZnd023LldXFih0vvR/yEiIlnyv9o5Ne5Y7GuoWRJGH3c7+HnmdozTIyctsI70eWXnpl6vWWzf\n", - "7zCHsEzG9NhjsjXQp4j8X/V5w3Nngrl429r+whTkfYxrJcKLiAShosrTJtkpwktyKnHkxiK7XcSx\n", - "ZiIMzdeiDX4+6xAYe32uMbEcfq0VIdKYuzJSxe9adwweT02piDAXr7l2Yj9LdtJ4XXhEyocPHz58\n", - "+PDh457xxhCpxSyQikouE+Sh96TSeXrm3n6zwFCdonCrr5xWf6UKRhKXIIKPHYv0aYl3jXzsSEKH\n", - "U16WkIYUfmk1oR+6cIxolaoePxEJRwbw4hoDFqmET5xyANiZHpyjYWD0ByX0JP65rdzqsO1sv1tw\n", - "c/KZvekfzx7hGOQcDk9AkxpgrAc+fCELaGK1SgsyQ6e4hNQdI46I84ZrS1MqXQdvi0VHdbWnKF1E\n", - "iJCWZA/Ur1pq3weG/liZNokpwhNwV5GonLjjFjGvZlwbbHcOrRhb+0w5B+FIIqE4REEcIend56dH\n", - "D6dNzy9+7I5PJekl+BKruR0Di1SZo3Q3TW21GKKcuSXPtzW4TB1JcuTgnjSENM2AurStjcmjlSs/\n", - "vt3ayn21gvgjyvWrve1XqYFcwq5IS0C8QeWNLJaG3H3xhUPkVrRNOYpahi9ipe7KjWK3+puNO88Z\n", - "lZrv4adXFIZIbPeujTviI6lgZE+r6kXq2vjm1lC3DMjZFm0cE/dEhTi1DF7EUKq2s3ZSLlOYkiAo\n", - "kLaE+DWLY3f8qrT2VwSYGRgJEItRfepY1BXyC2cPbKzdAEXsCE2egcOkIpwiIkfw2utGu0+6SrlM\n", - "jCaCrwlEIDkmr0/8y+hThK0No8TgerJ3o4puhsSvihSd6G2eEvDQ1Ap0uyPuTavZBOK5gbfFD7ME\n", - "k1bHWqYpBBkJidcfhYRcSaxjB3MHoTrKXwtpTv7hxx+KiEheGPr3zXf/R3e+JNxaA01iTzjBuKfb\n", - "eWr3HDxLFjCuA4i0kviowjUd+0QCCabbaRKVZES+h/xDT2Re1dXMaDy3QJYyiKmygKmKWhL1UEa0\n", - "MUv8rDdO/iElfqmOOn6eKtdXeXbuElViRn31bP7NIB3RESKHR6eE7N0a6G/p3Bs3FhvaX6jfY4mV\n", - "u9TNg/CIlA8fPnz48OHDxz3Dv0j58OHDhw8fPnzcM95Yai9L5lKTiniA1NbVpWGcx4DC44BVX+GX\n", - "RTIFi5WDdrc3BgFrGi9JmFjnPs8A8TcE+yuxtetT+r77eyDCXIWS1DwzyDCGengUEYwNaDUnxLpu\n", - "XApClZ1rSg9sSvfFglRfk8FtY0mEFrIH+8p+W4BZWGR2nkq2ffTgW9O2D37oSnY/v3ZE+FQMztTU\n", - "CqdscpQOszqvpgc4FaCq3PFAxPrOpRRCylloNenAfn4NCJVKqCfF+gZSBA2pLqvUQLkmrzeQbGdE\n", - "Ck8AXzdUFDCC+N63rJ6N/W3dWNT0p4hInoGIHVoqbti6/WXUJ6qAm1Ja+ASl4B+9/PG0ra6h4kxw\n", - "92oGRf8Aqb0jSmNdQ52dPLSUjF/kVn6ssHwxt3NK0WfHubXJDikl9iT88Q9Btj52BQunZ+fTZzc3\n", - "jijPqd0MxOKSSNmrhUtpDAOl25FmnM+JvI8+TohEqqTldpImoXsIwH9CRSk3N+7c0xXJhOC+C3pK\n", - "C8Knjguogxj9RGXVk1Iy5AQ47aMpu+BguXlX2bwDHSEimYa8cOmwgQirSigvqCqlh6J3SHmRRgn4\n", - "yG1tb21MLiEPM1tauicAsXt3ZR6OIUi8SzqWzhkR+WQWaNucnBpur12/NyBgq2+giMjRyo2PmiVE\n", - "MP5iGmst6BYRFftMBR2syp3j88jGc4e+iGuQyFtSAkdK7ZIU+yvMD1wok4Bk3JLETovzHEniRQR9\n", - "x5IUa9AHOhChqWBD1UQCKmwKcE7//MF/nrapOs4JKYBrai0h/CJDmr9pmJQPSkXjjpGKtY0g9TwE\n", - "TAFBKoq8U1ucO9dTKWuEKR1abCBEpu7Uu47Td7i3e1BKusHu/27UogC7rnnq5rWzhc0nL26dJEvZ\n", - "EKUHxVsJyQlp4VN74FSCIi/IBKV0v/TwxxxIwqBF+q6ImbCuqvi0W3yvJjkhvT0GIvQPBzSYu+ER\n", - "KR8+fPjw4cOHj3vGG0Ok4mCQZWZvobutE1A8y43YeH0NsunCVhBF5lZiaUZlrQPQp6W9parDN5uK\n", - "hyCN9p1KGBiq06D89oCcpiTj0VZVe6y0SyIRr4CI5IRSqO9XHJEnF1bOSpwbCC25wtv6OZWmClaL\n", - "Ifv8YFkRDCTgh9XEcm4l6auZc+SeJYYS/duf+1UREbn5PyEh0VtZcwdyeEWsxx5SB7OCiXiuQWdz\n", - "WyVVQBMyaux94xCjIuNadxDwexJEA4rQYWXeEelUyfgD+ZUFQKkY1Wogp5CQSGiEFUtAJFItxW9a\n", - "8trDUkIJ1Q35FTYVroFc7ROQXLve0M/jpRuzBZX15iBlnhSE8Ny6VXQcW7sXqZb9u2MsF4aWZIW7\n", - "ntu1SShkIMpviDB+duLQrxndTypOGNNq+urSkZIZ4VmtIGYLEvdua+NaQ6UJRAyxZMKqrtb2jFLB\n", - "i68iQU719WNPQC280PZfr61t9BhM2FUhyMNSb9fuuzWR7QEFr2+t7c6BcF9SkUuKFfESIoEbEnrU\n", - "85wREbZWRJqKDbrOndMQkNclhn1C7VSDDH9A1AXqExNyk8Xunq2wci+oOEFFUvtLIpYDdTp+8GTa\n", - "ppIFIS2/I4yPrrZ2ur5xY5zJ2wv03Q4SClVJJP65O18Wvx0VTSCUJkpUVuFuX7Mkhp7eGFFRispp\n", - "wBNzFRv6NtzifGkM73vMyVQ81GFM9iQ/0KnA8pzv5wT7s3l/NnN/X1059LNtrL+0oGEYiB0eaPGO\n", - "tdPHP/qBO/7TL0/bjiEdIeQrp9mWJaF+uz2QYPX/bAktQ/FQRwhK16JfW9tWY04OC9umno3NeJfE\n", - "zR6jHSQRYoKzYqDiTaMCmjaGmg5CtxlJF6EpGCU/BbI/EolcRaGZlK4VXR0VY6mwrspqsDffFkK7\n", - "PRVRhJgfYvJVVNkFnk8GeBeOLaNP2AeJWbNkwuvCI1I+fPjw4cOHDx/3DP8i5cOHDx8+fPjwcc94\n", - "Y6m9bVvLjHzYVMW0bY0I20IddiACeJw42Hc+IwVwQJqcWtkqzBvYtnnhUiC76hX+NXiyRWqJUxa6\n", - "O86saXquJYGSEjBikrGHFnQvCO1XAugALRJWca6QZlu25us2wuMuIGJhnAAeJf+zFkTFQKydFgX2\n", - "Q3DnCFj47QdfERGRj1788/SZ+h9VFXuIIWVB2lYKhSZErB3Rxgz3zibypm1LJl8vO0QgDtq+uQU8\n", - "23N6BGkfIqeGMT4fDIpV36UiIQI2COAxMaVVq6olmLYHRK7Zu57SA5OycmdjMgChP6ZmyqAiv5pZ\n", - "CmaGlFEuXIAw3LnGsnH9/vTx27gWG2zqIRWnlp69uXTpwfMT0xFSSeGLy5d2XSCehjR2ZtBeKma2\n", - "vx00mJTsuaE0oqYWWPep7rUowa5LCeKcljs+RjqGEHstaGD/O9U+MuievPGQbuT0mBLVaxqnFZS9\n", - "KWMmI8ixc0rBXVw4NfiTUyMA3750PpbXOzgr0PeVsMwpk2n/BwR8105ty9o60BsixaUZNLh2O2un\n", - "DEUxFXmH5idQm26R2icibo05I6NUXIn05WxlKTAVEGItnGNoT21emo5WeOrO/dknH03bqplriwKp\n", - "WPYL3G2gWVfYmCiWaE8qFFDy/EAaTEpeHkkXTpAqjeg8xxQFRRgbTCJXp4rH1Idb3E9XG9JsQpfN\n", - "UvvtBlNh31n7r+CPOI6kVTWHptnGXc/1jRHbB/RJRNSKASm9fGlpJHW+eHllvno5FOq5KCnGOE2J\n", - "7D9gnrzBuJaAH9NwwKDU4ggP03EgYr8S1um3AQprqCZjcg1grbg+eF0a61AXinUMr67dNT48+5Jd\n", - "A+afjIqyjlD4VVPxgHoCBuTooefC5HHFfNSpI6AKkADP1YTcAQLMyQM9//RWDLl4C9pnCT3k00yL\n", - "TIiUTx6srwuPSPnw4cOHDx8+fNwz3hgiFabBgefWCcqFbwlpUZFnXv0pUbwgNEsXQiO7OkOpNC6M\n", - "vJ4DzVG13Q25hZd4Mw2IbK6KuQtSVt7l7k283xsi1WNVsSPF4g4SC2PDZHP3bxThrZpU1wNc5M3W\n", - "Vj8rlAan5BdU4K1+T4hQi7L6ly/M/+nn33Urgq6z1WyE0m4lTMa0hI+BKuUzLhgHEZHkAtTjrCvp\n", - "TR/Xw25EHcpvw8Te6lv0XUQK5PMliMyhK6HffGEruB6ok6rEi4g0aPYoZhIlSOlETuy1TJ1K8hPI\n", - "TgwpkdfRPjVWLoy0hCjrDciHq6xUAdu+dw3F3iMqUw5Q2JDQ/hKspg+8zka3v83G9d2jxTemz5Tj\n", - "nOaGCCiakpOsR4/z29F4Vk+snIjiKrvA5c8xbp4WDcv9FYJYXpP8xBxK6HzvqnTIkhzhtRigmLHX\n", - "XIXfEnlXFc1B+mWkczdgLqDvK5rLRSQxvO6akjzJBnWQt++lIKpvLm/oex3O3aF0Y0vSHCrJwL5y\n", - "UHseCVbtgQhwSfzkNUgr4hboTJyw/IKLOaEZKvHw9IlDKb94+Xz67GTl5rPthtE/d+77yrY1IIg3\n", - "JJOiqvBHR4bmaNn9EamXa5vs8NuE2loLCw5QJSUHU6FKEsGTkuvvVTKClu89yujHHUG8kD8IQV4O\n", - "F6YYnmKO3xL6qUjHV8+tsOMTFGPcio2/GYjnazrPEHIuyyXJ3qB4Z4c5/uqaJFlKeL1Fd5Xgj+Z2\n", - "nmaPaN9TV4LTYysKSFGMNBLqluJBkadKLKcCKIwxShJIiPGXUOZGJQRybn887lNCOMfCXWPNINSg\n", - "mRN2hYCfLe5P7muFnV9efzJtmaGIZqBinwIP9Dinm1LtbFMbFCXmMX1OulCJAzxrIp5XQRints4w\n", - "1x5YWAKd60ebJ4IE8z7tL0owJ9EzRrzXng8fPnz48OHDx88m/IuUDx8+fPjw4cPHPeONpfb6YZAg\n", - "JYVpkC5PKRVRg+TLSrzj4FJmQ0dQKFJfNcHoynEsEtIlAmStsHNHRMgBkG0QGWQcpQ72zYnD9+jc\n", - "bXt1ZVB0r6rgncF/NVIElIGZ4FFNrTA6HkN3qKwNMk1DEIEpFaY6Rim1XQ2tnvXWfvvRJ05l9+HZ\n", - "V+0a9XJDEFZzItBBqyRLKWUBku2hYixMfikFq3DvSKrQmtoQMvyN8b2ctMJikM3zU7dtt7dz+vEX\n", - "H+H7BkWrBk1AKroR5NOblhVzdRwRKR6QNXENRWKVKoaKMkmxL9HxGcHOOQjYZUepCEDrN7dG9k5z\n", - "158djdNhUA0eguAB6V/duNTeIrdigzkGT0D6UDUUu/u9EeA1ZkQif+edd0VE5LPPntlvQWx/QKTQ\n", - "IyhlP3/m0keTAbSIdCDxsjq9pnZmM9KA27lzykgBX41+mahsJFIbY5pKVX0ylhFXrZiGDFong2Ai\n", - "cffQhUmJlL69dum7oTdSrBLg9z0p5eO4msab53YNGm3LRFN3fmyaPCKpTVlcaeGawGlMS0fc1VZi\n", - "c1/d99WVS/MvqIhhC0X/k1NLY6n2VUHaSgOcHwJWFsexmOx+dubSfE1F+mGq7aZtTP3VIT3PSRcl\n", - "tAdkRjzNcZRaDyJNgZIrhCqvl6xt5Nqux1wYkGZQhGPElJ6SEXqDVOxzHkDHbG1zYonU/yw1Un4q\n", - "7p7JFjZ3h9AN1EKMkwekLYZ0V0puB+dnjsSf0/UL2j8msnUN7cGLS0vVPjhy93tA43mALlMAVfb+\n", - "gLIC43caV5PRNz0nA8yTIc3JmirLaEyMmqIkU15Vnq9p7oqCQ01D1gILAndOOyqe6lpoplF6LAGV\n", - "JSVl+RhzHDsAxBj/O5rjmvbm4LrZ5DiCaBWbdgueNey2MKUniVqRxuooYm2SJA3Ol8e9/MTwiJQP\n", - "Hz58+PDhw8c9440hUp0EEsX0Zoy31eXKCKvlpCJOpalYYSbklxXDf6ij18IKq+kZlclHWDKqN1ld\n", - "2UozTO6qqSphNirsdXSJVZ8hHiK7HeQMdlSS36qKNhEwR5RVgsw2ULl0CFIkE8DzDOgblaPmIOrF\n", - "e+u6AghPeWsrpw8+ctIGa1JxHsStGMJQyeG0CkiB9MR3icA9aThsUC67oDVpCzXsJCMVZSXsDdZP\n", - "YepWkRkpFWexWxGPuMYnj74yfXa1ceXqbUuohhIhiW0cZ6q2TX0dqXQErf5BSkzYkyrW8lusIKmE\n", - "eybqYXgXkSoKW8GqoHEb2oqsvHGr/pqKF9QnKxjvkpLr3v32YmcFAzJ3K91stNVvGLo2bDvylcTq\n", - "/Mnjp9O250Ciqr0Rqx8/fCwiIiP5VH38I+e7+ODcqeK/vLTjf+29XxARketrWxmeA4mak9r2FTze\n", - "CMySCP3DfpZaks2rWfXEVCI8K9ZnhftMfRBFbPWdMtKiis2ENJ0cOaTjk09s9T/HCnO1MuTu8tKh\n", - "GSGO22U2XrU4gREZJbsyIqP/y+i3bePmqTBgNN39m9IYU1+9kuYpRWCbTv0/6b5CX2/3dl9nkC7Z\n", - "r21M6D3eU1sr6sXtdHXhUNTTE0O4Pn/h2qzI1FeTETmUyzOqiEuMEhsTiioFNHdpUQITewegeUFm\n", - "RG31XY1x7j0V8Uju+i49O5s2NZB/2FFRiEp3zKitb3DZcUAyJSnQJFJAj5eu7dQbtSG5kixwbRwN\n", - "Jv/w4NzNvymlHxQ5GkbOnLj9XlyY1ITgvufiEUWRukElTMh/FSz2jjQMFOE98HrVuT3kLA1cIcgB\n", - "QhHeIaPvqZJ7x9Ixbt8R5i5GkHpIARUkIdDjOc3FO6oQn2YsyQDyPj28w8iN8Twhj0V9LmpGgtCn\n", - "xRx+qSUr22/xL8lv4NmRkkySktxzyjrEKLiJSTqDmuy14REpHz58+PDhw4ePe4Z/kfLhw4cPHz58\n", - "+LhnvLHUnvSh1EQEKwCtdgQjp4DKn18ZiTeAgMZsQWagQCVbUh9tkUbp6Rgj3hv3IDGOdPmKVJNg\n", - "+QTtzgdijCvsmJKKLdKBGZGya8CDFSm2DjinCTIltrmSrhdErI5B4ksTIrYG7gSPSbNkB7PUqLXf\n", - "rrcO7n7WGdk4gdHzYuWgzXlORHxRg2JKO8FQU02BRUR2UGDejaxZAriZjJwThZtjO/cOZPzN1tSz\n", - "i1NHtmxbNYi2Dnh05NJNn778dNqWgZTPAiEJdISKgq5HCcLUd5FqkFAKsEK6U5Du6tnkVTmcwqko\n", - "1+7xaPvNkUZqdhfTtnpw19ixYjUuMSOy7YgCCT3Wq8uPp8+OoB4dCaWxcY0JHV+1xS4u7fhKFF+s\n", - "LAXy8TOXxjs9NbK5ppKDEHpKM0utX2N/GRGwM2ggffHcUmZffvddERG5urI0YgaCfEzEUtWRIlFo\n", - "ERQNaEovT20MqxL6nFLGDdK8yxmZ/CLdsbmxFNCIioJTUvu+XbvrOT6y+3S1cv3Z93cVnkXV8Snd\n", - "HmHc1eSKkOdI84xMI8D5UUGJ/nZPelfaTmpGLCKyWKiAnmp8kfEzqAU9pbsbjPViaWOihfZQQAa1\n", - "EegTHaVAdtCWamiePDl1bbbbIj3JaXTo4yWUMlOWPad7AhQAjZ1dl6pi91RsoUa/UW7zzqgafVDA\n", - "jniehsZQSppdK/TxFaWR1xs3Fi+pXTUtGlMBSop5nPjHkiUuVbecuflsNbPnT/akwKmRkXeu+6fi\n", - "KUwZNQk0KUUhTS0FtoFuYBnfbRMt2IiJHtBPhUq2jw4PLcq2SoeUKhdlhRgLPVEF1NKB96eOGilR\n", - "MKJE7w+Q2CllnMLFImiIgN67MVPSMyFFMUrfGFUgxr0b05hQJfswIw3AFgUd0CIribKgOnoj6b01\n", - "FWgURO3Q/mEjY03pj0QpGEBL6YkCEghPWnfDI1I+fPjw4cOHDx/3jDeGSMVhIe2eSNwPHImQlVC1\n", - "FLqubVu1BkpEK2f1ogpoRajeOXsqiVcCXlnBVy/isnoQ+0jBtK0O1VRFRIJpBW9vqAXeqnNqzhwo\n", - "FS20plVfC9Xh6mC15FY6p0BhRKyEWgJb/aZYsZ8ckzcQ2uyEFNi7Z1AAJmXjGuR2LSHlzp8fu9+m\n", - "RLrssMJISB46AyK4L61dYyBXpHUuqaIoO1sRL7Fy3O7snIpUVydQwj0gx+J3JImhvmcpMZvDGF5r\n", - "dEGxKgCTT5+qMbcdlc6PqlQMwjJBkhVQqoT8Ghdo/yI2RDCCdEIRGmFXUc+BiNJanh+x/56qp2NJ\n", - "nJBcR1m5VVeUGbE1xmq2r21MruF/VhABPEafXYMILmJK8ayUXwUoyYYP3bvvENn/1hHmQ0JkFJ3g\n", - "cu148lWbNk1k9M3GUCKVM2DQJ0anNUB/DqQu9uqDSIggVp1NY/2k4yQgRLqG7EIQ2jZdkbZESk6A\n", - "sAS4hpjIsZMig52uzOZu3lHJERGRGvIMaUoorZaJE0qjyE1MatMVxsl8bmP88tKhmW89dgrYF0Qs\n", - "X3fuuEfU1zV8AseA5k60cUQyKWv0J/sP1nt3/JbmyS3mWJVhCInErIr5rBitfo4j3YD68UgOFIoO\n", - "RIRwjSrxQaTsUQtegOYw+qZIa0sE/FDc9R/RPLHDPBHdWl83KgUwEClaYRzanxL0ZyDA53S/SIr9\n", - "hdZek/yL8PNEBzl54mF88hjvR5lqxwAAIABJREFU4Cdb13aeOu9H8BVl+RW9d1iRQ+dplvvX8cyF\n", - "Qj2eSSWN3RxFW+FB9QT6iRAeBSCzApkj2q86PzQHjg0owKrZV9TNMTN2W9i4dp+TdIuS5wMiyseQ\n", - "m1A0KSP09frazXEJne8IFFt9aEXoeT9wNsPtt2mtUEOATvGzIAkpK/Wa8IiUDx8+fPjw4cPHPcO/\n", - "SPnw4cOHDx8+fNwz3lhqL0lEjkgLKgI8W6RkfAqy5SI1wmwXf+x+HxiMriTOkJTKC5Bc45SVmvE5\n", - "INOGoFAgwUJelJKCRdiVlEaKkGbhV1DAmPHIWhhI2ZAxsaYbVW6qZu0MkFNTuv6z43dFROR6/cNp\n", - "29A7qLigNF6OdFA0EIkQJ/jhJx9MW7a1S7OonkdDRMh5r8q1RKydDG05teNOPididwtTW9YnUp2T\n", - "ltJiqlrOOiafvfxYRESOFg9xTgTxAyrOidjaTyrqto8M6RnKQMiANF5OattV664/ILXfrlUFYvf/\n", - "OCciOrRgQlIxj0GALQKDfScCMLE9c4ydLY2JGOlgJs8qkVnNbdPU0nibrSO55rmlDIvMQeAhDcCq\n", - "2+D7RuJUlL3tDbJ+64lL29W1fW8H0uZbT50C/qsLI6wfqbYQEVFV5fvJEzNeffnyJc7dUhZqkMvk\n", - "bU0VsCq4GiIrJ5TJoUoE7ohsrVo5I6XMVIsqpNRSCQPfjtIYi+URPrN0S4zzm8NcuSODZtWUS1mx\n", - "GuMqowKQGiTetiFdOpxnRPdThfRNnDCxV90OiBSLuUv1uQ7TaFDWJ2LvbO7OvS6NApBhflDCuIhp\n", - "+lxevLLrxz3bUapUk/QVtNVS6q8K5OHV+dv2ddyTIc11/R6adUSsHucgoJMGkrbT2LPeG+ZOGKiH\n", - "nfVrA02zDTlA3EArryHdoyJ3bZKSQfQO2l6c7t+DZrBYkDEx5sUEadHF6uH0WQdz5T6zdtV7bOyI\n", - "bC+qd0epfcwtccxq29BFCsiEHKnFqlEtKrHvY/5lcnSj2of0TIyVosHEfjzkxoxSgEjLthUXZemY\n", - "JE1DUGlUF6zgFHzrjlFXlsbX1KPSaEREUsyTHemYJbHSLewald6RZ0Z2H6HbOIJa0tX2XJnP3N+s\n", - "mdbu3DgJ+ZmEYqecxqm+AjB9p93BmJw00LqA74+74REpHz58+PDhw4ePe8YbQ6TmeSAr8hBL4JfD\n", - "b7o3W7ctIw8tRWxCWumqAndHr7X6VpsRSqWryAZqqjWtwgZ9WyfSY4DVZzAQqtW6t9+MyM77BiW5\n", - "VEKcYKXVEwVbzyQGeTAlxewCq9SQasMTqFgX+em07Xr7oYiIRJ2109HCIXZja+d0DlmBF6RU3Sdu\n", - "5aREwYFK6KsdVoFExCzQPyzOrQrUjVBZP/qMyeaCFXbfW99ttg796ENbzY0D1OuxWoyFFauhRE5F\n", - "AYG++1NZ/USKpFWFqjGz15ISiYPA9jcDKVHbZDG3VdhmDW88QpWG7RfuvA04kgSq+M3AysruX/aE\n", - "S0BaZfKqKvvWgjah1aoSNpvRVnpd6MZwQihFD4RtILXfPZCI83NbTav8xyvy+nr80Kmh34CwuVgY\n", - "+qvE8oQUu2dAbq6vr6ZtF1cOxfo3/+bfTtuuLt2K8GhpCGuP6+lJKbrFPauuAyMVOwTRXUkCRUxj\n", - "gmkUm+AVtBK/h5pWxCgnr0liJcbqtIQkQULHV9SLj6+SDAnPSUB/GJHSwpeAFbMjRYJtRT4rHJpa\n", - "VYSwZoc+hTEdq1b/OUL/eqA+A5lIblDkMT9A/9z9N5vZ4L25ccT2orDf1pAYUOA4JPR3QBFHR2zn\n", - "dOXkAug2kQDzGRcljLhnB0KJApi8DSQnoaj3iKKQgyKGB64Yp7+1IoprEIprQhACoDNRRvNEr0iL\n", - "7W/yiZxbH5e1O5cWKt4xef1pwQTPKzUKAFq6/xQ5YZ9Svf9shhVJ8Axg71QtUBghScLnq+hsQAhe\n", - "jGPU9PyLdMxQn4yYobkAQmU31FdVRGSPv0OxsXMMLrgWzPD1t0B62tY6qsZzl2UVFFqNSepB4DZQ\n", - "0niKRjxPSKbgZOFcGVbLB+4cdzYnbiEhsSttTlrA47CLbL8VnjHsqKLX3VMB0h5SCxJZhicJfjLm\n", - "5BEpHz58+PDhw4ePe4Z/kfLhw4cPHz58+LhnvLHU3mqZS0Ygp2rrxBHB+PibBGMn00bVieEod2Ru\n", - "C8BflXjd/pSU52DJjJS9a6QFgpGJoFBxpfMMkXpqW9uWQltlfUmK3ZMsNpH9kCpUWHQYGXZ0qZCu\n", - "M3Kiop1MzlPCap4xORPJjcGg2DnUkR+cGSm4vQQpE8abLZk2N0pKpPRIAN2pjAiLKdqwZPJdp7pc\n", - "Npx6VawmaD8EoXIk9fAWqb2qgvExQcER4NQ4sPSQGp7GAadbUWxAuiOaR+16Mo1O7iowZ0gVz2Yw\n", - "dCXNmgGpgJbUySsQS2+2RsrukY7tqZ+C16SqCuinhAGPJ7dvVSKOQtoH4P7La1NWzk8cxh5QylS1\n", - "zTi1sFy49A2bcPcb18YnJw+mbbdrR8puAXEfHbFqkp673ZPPP3dpwS99ycjGIa71xQtLGT565FKG\n", - "tzekdp7qvWNHUIK+Gi8L6wkh3coFEAHunZrukw6K6culpayuLt1xV0em99VMjgYWqtmjysoNpecK\n", - "pM+YMhCEarxq4y+BCWtAxNYG9+l2a3pDswKm3ZSWK0HK5xTYFmmLAoryrC1WgPj+6qWNiRppyYzS\n", - "WKqfU9N4UrPmyxeW7l9gnGwoVZKlOk6VCE1FMbEqq1v7T8TqlbW13CJVR3PcgLaN53b9WqAy0H0X\n", - "Ne4eC1D5U+2sOKIv3XGT0O7hIxhpM19+g/n58YNH07b9Z+4aS0oj9pgf1qTVNcApYuxdH3ekDt41\n", - "IOdXVNiANGpIRSw2xbCRLxS7A0qVz/U+tVGp5us6/gN6TEfY30j6SBnuIU4PdpgLB9IW0/ERk97T\n", - "iLzpjjQNIXMoy9zup0oLNFQzLLTGVnPllsSoVBU8I2L7AqTwkO5AvbaIfptCM2qeW999+a2fFxGR\n", - "NcZVRhSIaIlCpZY1u6DsTs+pGUQdY65KUvcCunekc3831Mb9gZrc3fCIlA8fPnz48OHDxz3jjSFS\n", - "xTyWiMrq1Wtru7bVh77Vk2Dp9PdAb7Wqsn11YwREfcHsxVbEp7qI1BUuvQVHKE1nNdUBvm9Vwyq2\n", - "bjXBSqdpBqQlsVLz7d79TVx3ibGy3OMteBhtZXaLVdeTh/ZWvSsd6tH0jFKh/JYIiLcoe88DQ986\n", - "rDCWCyLstW5Fui/VG8/OV1fQrPq7TNz3Y1qRBliRxqQEO8CvbhhJWR3SDhGxovMU5ayBrXS6BCgZ\n", - "CPshUdaVsBsSgtUNW5ymoW8DSKENldqOk08Skc1X7riqxOx+DDQL17XMSf7hyG3bxdb+u41r15CI\n", - "iHusXLqRjo9+GglNUC8o9i5LAiWqgxzPhGWMMVbn3ZVuPKeRSSKoTEhC6KuWR0eHtfM4d1q59tgf\n", - "ZCLy3Mb1buf6+IxUtI+P3Oe7va3qj44d2Zh99RIgsQGjSTj+Qak9bvJsruXN5A2mw47kJ9K5KjFT\n", - "H4LY3JF0hkoxNCSd0EJlmZErnQOGyWvPxpqivxGtRnOQ7XsqP+8w7jLy39QS/0hYEsK12Wpp30sS\n", - "TEpEaI8xPtWbUPtBxBCk+cL65OKVQ5gWvfWdqkOXe0OaVFF6sSKy+bXr/4L8FNW0LdTJllbwiua2\n", - "jNwCVQsrzhK4vztqzxio60jZhE4RgQXdzxsUeaDf8xMrgNhcu+u53RixuMR9F8fUrziXJKbCAmQp\n", - "opTcHga3v+2ekHNI18QR+rqiEvq9O8+KXDmqvSKtNq5HFJ7w+I+AehYkcaJSC3FC0imFO2e1RKxJ\n", - "riMC6s9FEeoxGxw8J4EmcoZH56eBfBpr96MtOVDMZ++IiMjx4p1p24PTYxzLPWuu1h9Nn1WQU+no\n", - "2aH+e+yKEUPqIKL5V9uHAE7JVy5LMKd2Ws7dfBf2rr++uLD5Z712Y7glX0dVhRdCE0XHHz0TVCak\n", - "p0KFmXoRVlQowUaGrwmPSPnw4cOHDx8+fNwz3pzXXhweeJg1W/fmvN6QWBx4CENnb7Vz8JEG4oio\n", - "ON16Z2+NKXKo+9oQqSB3b6kRVvrsqj2VOjOCgTL5mtAX6PzJcmb52wGCkbO5+QXdgsPRs69T5b5X\n", - "QrhN5RVERHqUs768+GTatsjh1xbb27d6TdWM5o3u87r/fNrWNsg90zJlrs7t4CXsKFdet24fHSEC\n", - "A0RSg9BWvw2uK3qN/2BNTt/D6FYVMfEBVDgzJtXTEShWrR5qrfHMFJxqB3KQ1xJq4j6FEHZlUbW9\n", - "CgIGzHlxq8nVsXE5SiAWKv7Z0wpOVReKwa5hOXP5eALzpITvXcMwIVbkPYmJ7tHGq9SQAy0ZVt5Y\n", - "L8Q9geN6QH5l13vXx3lhqzUt649YkmKm6JsdPwFvbntlq3lFTs4eufJi9Y1zxwWngvlA6KeqtFXt\n", - "fOna9elbxsf77LNPRUTk5MyQs/UNkFNC6ZT/1GFJmhKqs9u5m60gQcwBq/6MYGpFApvGOiVBX+92\n", - "dq0hSq33FaM0rp1yIDID+fCp/1mW3+U0MaqoTvfdSP5/oZakk+jt7Bj7JR4cdpOT/EDbjDg3d9yb\n", - "Gzvfy1dOfuPs7PG07RTCqZu1zXXKkVOxVhGRBjygq621k857jGak4KulkDoIhFEFnTsJfdM5s7T9\n", - "dkD/kpPjaZsiVwEhrOnKoU3Djd33gcqDqDcjrfdXj9x1bT+1uabaut9uOpsnB6BJw2Dfy3I8J2p7\n", - "xvSj+7za3c1OxMhOjI09a7bwhrtak4dfC04TzeeKCIchPWKBHC1m5FMZ6XPH5rMOqMsISZSIZACG\n", - "Wn39aKyNmBNZV2HAPE18xBrzYxsxmuX6oihM/PLtx++JiMj50ZenbSt42x0tXH+Gyf8yffbjZ/8k\n", - "IiI/eP4fpm25Xg/xBlUSoqfBVjcqBE3yE8gwvXVu3NgSCPhXn35dREQCylJcXv3YXQuJ74YQTI0T\n", - "4lzqWKc5scXzTOcGEZEYz2LmHAr7WL4mPCLlw4cPHz58+PBxz/ipL1Lf+c535NGjR/KLv/iL07Y/\n", - "/MM/lLffflu+9a1vybe+9S3527/92+mzP/7jP5b33ntPvvGNb8jf/d3f/WzO2ocPHz58+PDh4/8D\n", - "8VNTe7/zO78jv//7vy+//du/PW0LgkC++93vyne/+92D777//vvyV3/1V/L+++/LZ599Jr/2a78m\n", - "H3zwwQRzczRde6AYXOPvPcG+mkbQ1JGIyAwE6H6wdMc8VzkBI5vXKO1v2P/olYNbFwvAzuQDFUze\n", - "WHSSgPjazoiQO6jeSmCQeQFPqIR0GlYrB72rmreIyACoOO7hw7azz1IQ8DZEolRFYy5hjyNNNxIU\n", - "mbq2224MHleyd55YykAVZaPYwbMH9LlaCfi2dRB3PS31Uw9YtCcYW9McTGxuUVbbU7pLy04TVraF\n", - "anyC0vDbziDrPnSpgoFSwDnSgz2RCHuQJ9nDbPI6E0uBtbXb1u2pPZFGaPYu7RRkdnxNbaSZpWxD\n", - "nO+YEgEXKbU6tL5TlXUmz2uBREkyBT1yhKrAG2fUKyCCS2iw/x6l201iqZ0Y5MjFwqBwTTM3JcsE\n", - "uOPvqCT/7MylKpX0yeTgkyO4CHC/oiSbvR41tff555ZaXoDQ3ZV27jOkCLeUWjo/c6r9O/il5UR6\n", - "1nLugIjde6T74hmpDiPd21O+tVi6lNFu5DSy4HpoPCvxHQrnXOo+R2n6bkv3OtKMTDbXlHJH2xYg\n", - "dkeUglTyOCuVT2XalJbW6y6RiuNqbT279a2NtZWSc+fW/7fo45iI8nqt6isoIrKGJEZCB+lAJFdv\n", - "tJhSsSrrEbCzgCp/UxorzkHLoHzTmLk+Y/mTEYRyLn8PVB8jvlucMSK1++iRyW+UaLuyskKlqwqF\n", - "Oq1tGwI3Fvc7SguiZH6/5wIIkPILlRrhMYQ0Ms8/+DOgeUofea/z/9xT8YBAbifOSvqeyk6orAC7\n", - "I7i/t0Tt0IIFLpSqUIwRkpxIBPmZiFS8NY0ZEn1gQIUUe2I+eOCI50uMnRuSZJnDeePB8q1pW1s+\n", - "c+fEUjdIQYYHMj0uLZ3SfXINl4WQHC0iPFvVPaCIbR85zv2aUrsj5tMgtNzmqHSL9jVpWZZuEJVE\n", - "kDu//dfipyJSv/qrvyonJyd3tvNLkMbf/M3fyLe//W1JkkTeffdd+frXvy7/+I//+NMO4cOHDx8+\n", - "fPjw8f/LuDfZ/E//9E/lL/7iL+SXfumX5E/+5E/k+PhYPv/8c/mVX/mV6Ttvv/22fPbZZ6/9fT82\n", - "IgG/Qbt/B3oL7QMV8LI3yBXKIEsqTTyaY+UU/8B+i5UQcadlv4XXT+LeXAMi8en7cEwviPMExEYW\n", - "qYT44nZtq5rjpVu5zJaGXGgpbkirlFfwaUuxwotpFZABrQj5hOEc3rfWTVmmb+JUwquIFa1cSnVH\n", - "H8klG4TWNHLnduANhVfqjnzIQpTr9j0TsEHKJeRoelt/zcs1b1LvsIgRSpUfAKE9TowIvq/cym1O\n", - "S4MRxO8sszapcC7DgYcaCJhEtlSn+5HE9GotfwfSNnC5LKQbophL8kFYpEKFCKhCOjJKoT8g6Qac\n", - "p6I6bptDWEIQywdefcJrKyD5hRDnVNZEmEaZ8IwI6JPDPZHn9xDfXFLpvJbkB0AJj1a0aFKUhOQH\n", - "IrRhFNt51rUSxQ1pzOHPd3tpKPEcKBZLHHSTJ6L7d0YEzxqyAhHBxA1Qp4H6XwVzWRAxCFRMl9FH\n", - "1z4NFY/kmfvteuOQixmtwnW8hrRa1gVkzygx7mce17e3INaTnIQKaw4HpdTuN3sqP49iN04U/TqQ\n", - "kBj03OwaVImC0Ty9jusrQ6lzILa7yo6l5P6W6s8VAVKiNJ+tCqgKy3ooeZfnSfh0joT+hRgfTF7v\n", - "kTkYaIxNXGQgaD2hCiHafUMFA5FmFhpr/7p18/Nub4hUCq/VVAy5e3Xp5slrEnMu0CYZ4KT0AG7A\n", - "2A2tvSbZDyrrV08+RmTUO7MlhKvCGA9J4kaJ573KhfRMdEa/U1FGi/lnSYj8PHb3eJSyxJD6vxLZ\n", - "utEsBXnNVU5O4/LG5okM93MaOjFf9ah05wfkjISLBRkTSohM7ZQWVqgVYr4fyKe0wBzwyfP3p21P\n", - "nziBX0WO5nO7r85O3D5utnZdmjkR8lXVsduTdEcPIdSqvzvHhiSJMIl5/ytxL7L57/3e78mPfvQj\n", - "+f73vy9PnjyRP/iDP/hXv8uTgA8fPnz48OHDx39PcS9E6uFDc5T/3d/9Xfn1X/91ERF5+vSpfPrp\n", - "p9Nnz549k6dPn752H//h330qgbgy1KdfOZOT87PXfs+HDx8+fPjw4eP/zXj14528+jHsisK72RaO\n", - "e71IPX/+XJ48cZoxf/3Xfz1V9P3Gb/yG/NZv/ZZ897vflc8++0w+/PBD+eVf/uXX7uN//t+eSkck\n", - "buncqRyfWGqnBdwfjpQygAZPQ6kltXhLyOtthC5EMNhvA6SgUqhiB6SOHEdIOzVE+gQ8vSJPviRy\n", - "qY9Na15r12v3QniyJMgS53K2spfOTefIwzsowSakxZIDWk1J9buHPlYxt/NMEpAII/ttDZh/IM0O\n", - "9bgjCyepALemUO/OqP2HACkeUidXv6RxNOAyULJfamnM7R7EQtbWUZIr5fa2e5da2lNa6mjuiO+B\n", - "wteDHSsLHQRfZKZF08FDa6S+y0LVUTEIfF+6lEY7rKdtEqpWEF0PyJglGqojEn2duN/OCoN1c6T0\n", - "9gRjtyAZL2emmbRcuXF6RZpNHTStmtp+qz596jV24HQHjZmYUkYJ0ozDQWoJ6RlKY+1uHRm0IRVp\n", - "1TuiDIzkGbwGWdlarwtptKOF9fUGukxJRvpgSKM2tZE9b0DoTA8KTVzb5VTkoenODON6t7VU1B6E\n", - "6cdnlm7U1OpA16rX2FKbBKUbYwERuwOkmYKDaQ/pFozrgcj+qiLN6TlNafRkGKgpTdWdEhHJQTa/\n", - "urR5YgkvuvhAWwdFBlyAgXPSO2c2IwqCqv1TyrhWRXFSdtYufnBiaaz1Dimj1vqkRAqsIK2wbCL2\n", - "unQHe5KmaM+AtIBUsT8aOWWrPqn22wHXyOn+MHV9xt51WjwzIlXG3nAV7pMtKbbfbHGPUbFPhblz\n", - "X1ubLDHv55HNJ7uNS2OVtbXJPHdtluDZEZHuXQIfvJiuoUPaJyT/zyiFd6YQKV/7jlKAI7zgOnru\n", - "dOj5QRNGKX2GJk5jG+tPlm5cPSTF/hy+cjXlZTfQfrsmVfYWPpI7und1nq5La2MBKXtz63QOAzqn\n", - "568+FBGRm9pAlBmuK6JiAx2TQ2/HUo28kTTwAmg/PXv+T9O2y+tvuOteQUeLiggiPHd6ola0oAMl\n", - "4d13jJ7SeF2rqvik1QUtubfeXclb72Luiyp5/98bTeG/jZ/6IvXtb39b/uEf/kEuLi7knXfekT/6\n", - "oz+Sv//7v5fvf//7EgSBfOUrX5E///M/FxGRb37zm/Kbv/mb8s1vflPiOJY/+7M/86k9Hz58+PDh\n", - "w8d/t/FTX6T+8i//8s6273znO//q97/3ve/J9773vZ964Lq5mkppRURikONyXulCFbsjFeUEq7+U\n", - "3rR3a+c6n82pJB/s9aEh/zOsBHoopSdEmAuwmghiJtZCLmFmaccCsgtxSeqsg1v97ypDH06XXxIR\n", - "kRk5aD86/qqIiHz0/D/i+LaCTRKgL1TWOQB9YAkBAdIW0+pL7dnahoiNkB9QJXQRkYW6g3c5ro+u\n", - "FY7X4QFh3e0joRVhjCETEEo4zx06uSsNTRgCKMaKreYVMCi3tiKJBKs+JYJTuXoUqlu3XWuGAoBd\n", - "ZWRbJa9GhPCt4Ml2S5DcGlIUY0Hlv7gOJSK2hDRMbTfaCmYAobOuCblEHxeprXTnQOySM9t2e+NW\n", - "v9veVnqKhGy3QL/mtIJFHzPpMcH4jFIq4R0hobAn9Amr37wwwmgJhEdRKBGRFVaziqqN5E331hOH\n", - "pn7x3GQNFLBbPiACOPqi3Bn6tzwCskyKwMpTHgm5qLbuOo6PHep0cWFl1SorcntLqteYMypSYJ+O\n", - "SchZj+tXVFnEZAUYYekbdakHEb5ncrDrm57Wglr+PraE/u1cf2opuYhIiPF8cvpg2vbq0l0bK7sv\n", - "UE7OXl7RhKxjpU0o7YS60HkWMx0nJBMA6GJPauMZULKAkLseF1fvyTsTh8iAxJU7m+tmMzd2IvI6\n", - "DbVgg1ByRe4Gup8F/odCThWKxCY0TrVCZMzCg/+LiMSp+trZNVzBp7TPbK6ZYc5uCX1Tr79ZRp6U\n", - "ICWPdD0qRRHgX74ElaJPGOlEQU/EkhBKVCf0KYfaekyP3RbEcnZFqOHK0OH5ENXWr8vISQ28TZmb\n", - "r527TIj6YLofuf5/tbb7WSUbeip22eq9u7V7t0db9NTuR83Hbh8btD+hSl/c/IvbR2Pz2oD7LiX0\n", - "OcS1BoEhzKuFe3bs6RkfwAGiyO0e/+jT/+L2i0dx09iztgGqxl6jWiDF42QEOlYk9oyNJp9Ce551\n", - "6LMg5AKIn0wn98rmPnz48OHDhw8f9wz/IuXDhw8fPnz48HHPeGOmxWEwk7oxImCag0RKxp8d4M7Z\n", - "zCD7o4VLN+Qzg+w+AiktmxsUFyfut13JpFT3bw+183Ek0itSgVlKmkVIC80oPVCEC/zW9puJg1tv\n", - "N0YsfXr+CyIiEtD3zpdP8T2XilxvX0yfRSCPRgnD2O64FSkmK+eMjRdFoLbckeEt0l0HRo4rpFRw\n", - "TllEaR+FagNrwxCs5Lq1fsqgQRQQAT3BfuYFqSODsBiFREAFyXsgtrMq0KeZatxYimF1pDo6dKXQ\n", - "AtqKQbsRdKa4KGGZO+ibYdyb9cfu+JFdTwmyc43BURFhWMneIWnBqAL6SCTKBinQs4WZfKrIdkxC\n", - "Ku88cmagr15+NG2r9i5tFWFN01XWXhuoFx+fcmoXKZPcoPVycPvII4PMZ0iVlDv73sOHDkYfqO8u\n", - "ofN0/tClB06ObR81SPEXV8+mbe/93C+5/RI5dQ9T3dNHp9O2FFA4jz+Fx6vSfnukKUCMyYjo9nOY\n", - "BX/0wX+Ztj04cfc/p8L0FmNlcZXAynMiACMd8/KF3XdH0H6bZHRovz3SAjVda4b0IFMQdiBxL+bk\n", - "GgsyNve/qsj/V/bea8eSZMsS267FURGRuqpu3Wo53TPE9ADkL/BLCRD8AxIghgIzGBIEBzNkN7v7\n", - "9lUlM7MyQx7hWvDB1va9TkfOfQjgIl9sv2Skn3NcmJuZu6299lof35u2nmYM1mtL1ajO1D1Ux7dr\n", - "owfo2ndNaczvvvtWRERev7bCFrVomHo7foN7PdPcscH1D1SU0LQgGyPNvVrZ95fUO1EGVKwvJL7F\n", - "lCBlmdgjZkKBBrESJEQ6fmL18E6NZHEMSsUlOP6bl1YNfl27MXlPBPCxd9f/4spS69K71H5LFIwC\n", - "9/FIKe0jlOxHFMLUDaV4QK0IKbVXiNIiuCgE18pq56o3R9/LEzdm+onS0kipta17npRkfP4K+lQv\n", - "qBELnEpAafQOumQtORvcQ0eOr6eFyvpEBTAp+mwq1sebDs4PIG931F5atBWRsv2xR7qbtL1WmUtz\n", - "pyTM1YA0npK5cFC7v9e53fe3734vIiJx644/xDYmk9i13WptyuoJtOJubt/ZNqTMUy4ACNQV5bHL\n", - "SUtjggtZPhUekfLhw4cPHz58+HhifD5Ean4h02AljFoGPRBhbQaztaBy1Tcv/1xERJrBlMWfX7jV\n", - "dN9Z+WUMFKkiZWdYty2rn54UThe/KDbYwSq1b+17+dq9ueak4hwF7i15jozEe4Rn3jo3smmg8gOB\n", - "e9POiBwXLsRG8sYCcsZcc5UimFkmAGXFR+HVP5RlSZW5A4lPycY5EdsTrJKUuCcikgAKioVQpcGt\n", - "kvLE3v61xDkvqEwcv73v7T5NoypVE9l30tUMZC3onhyO7hrWCa0qU3cuShwWEenQZ7alISKKNma5\n", - "3ZMX2TciInJ7MEQgGN1fztrEAAAgAElEQVQqLceq6kikxxAwxZwwiVjL5W1FpHIGH2+MlP3swrXP\n", - "xcY88ULISTx7ZsULB6CTSgRviOw+q9fjyvpwAaQpzoiwC3/KiFR8k9D1iWxn2xqsTvkeqyZcAfkD\n", - "9ot8+86d22ta/U/wNVSSuIjIJbzeTkRYVn78SAhPr6RsKl4YOi1TRltTaXJbu209+W+qT9tE6ui6\n", - "WjycbO7YAOGZCeEaQOwfqI0rnPOs5fqkop5pYQu5LShaxOekKstMbO9BqJ/J10vR5DdvrD0Ph/3Z\n", - "NYiY80GEsd5SCX8AImxNHoYbIFa3Hw0RzyBnwAU1R5UYIaVsLWRg5Gy3dvOpIngR9Yl40ZohWGlS\n", - "xwAbE7Jy816YWJsEmm0gr8cZ7R2kbGwGQj+I8sFEStQoHprJbeEvvnHo/99+9/tlWxQommjH2uIY\n", - "Mc3xem9jvsdon5sH154jSW2kuXoy2n2NM/Qnkt9R38EptDHRod9F5GhRoI8lgx3/CsjKgOKFMjIi\n", - "eI7+1xCCdAOJlXRvz4RbZGLeU1u/rxwiV5GKe4w5ebe2frIu3X6yNaGEkBMYkJ1oqIhL5/WRJCRU\n", - "Kb1qeey6fVzuDOlSe0BqkuXZEVGfVMT+/b1Dx8uVIbhbnHsc2Fwf4/sR+59izo4IfYoxT7aUCVNS\n", - "/jDbSaVBISLmnPLPwyNSPnz48OHDhw8fTwz/IuXDhw8fPnz48PHE+GypvXkqhDh0sofJZ0aKqT0I\n", - "4K8JCrzYubRIRSTKMncpnYi0HpJZYVGDJ/M1oPrYpYoeaoNMF7IZEeYGpCAqJtYhVRUR2bBqkEaL\n", - "LVV3qvG9wCDIUWFOCLWohpKIyAwTzCHgPB5I8UzOBszP6bEQ6Yt1atDmCeTxkMwoRxhDjoAxjzVB\n", - "t7jWiUikQajGk3at3YyUApt2wngyJR2Zi+cufdHdmi7Qdf0B50RKyVCqDwCxhoG14S00hZ5v3yzb\n", - "Bqg3q1GvO2d3rQ1pi+Tpa+zPYNwI6rWXW0u33b111xHN7n5dsEEtUrUFGSmrzlhDhRKq1PzjT5Za\n", - "Vrg7o7YroIoeBVQAMOu/Dtrva0pFoz8PRNgMke5mdewYx5gIRm+QUhqZRIp0cFkaZK1964gUQECp\n", - "rRwmw0Lk9P29Sw/81b/662Xb3/7d/ysiIr/4wtr1VLn99ZTaG9B3n5NSuWpQaYrv+QX1YYyh9cq2\n", - "zUjZsNBvUbq+c0dsY9WRyXNKt6F9itL6WN+4c8o1LUf7HTGuWNl80RYi3aEBxwooZRhjcpsojdbB\n", - "LDimuePyCvNZRWmxWc/N9TVVCXfn5NozJ9Na1dbi/bYnpIrJ2iIE8Xsgg+BQiecRE8rhsoB0b17a\n", - "WEvQFhG1oaAvBkTsV+2tgHgJIX7LrgRTg6IU0iwKdq5/zIW77+M7G1cVvv/21goGZui4sbZYD62q\n", - "kdpuwFw40hyXo0AgJrXvDtpCqovXkO5S2mDuTmhM4nIiepwGKEqKuCgI96LuyXB8jfacrZ9GMJVP\n", - "U2jLEWF9Rgrw/t76y8/3SFmT2v0RafE9pSAbnbMpLb6GptraupNcbFVIjMyVZ01pq/GvfX8eoME4\n", - "My0FJG4yIx4n1yfr9n7ZludoHyoUUAJ4R4UqY+vapJ7dbwcSd7tcvcS5WbqxRRp/7G3HCea/iagN\n", - "+nFLrhgzCiAicvkIqc0+FR6R8uHDhw8fPnz4eGJ8NkSq7ToJCJERcW/aXWevui0Qk/CsXNS9LQ9i\n", - "b/BDr2+/tjf1M8oY9hr1N+6zVy++Wj7SsncqYJYJS42RSIQdVj09SQ10eD3PA1ZHdf8+HIxQH2Jl\n", - "kSeXOG97Wz/1IALPhnSEQGmEVnCzYAU/kTprCE9AIuDl4j6/b42AOgRACQb3PVosLyT2KKMuAeQq\n", - "ZZkIEEu7/pZ+67atLozsvV67v3+Z2jnd7qEsfiYVDbIpliRpbGXAYewQqbu9tWEwuZXwurT7H4Ox\n", - "WNdG9h6xcirX5NOGldMqNYQrf+6u9/33Tm0+m+z60wISCqRsP0Qoqz1+tGNhtTKRAvG7D9+6/RFy\n", - "eIVS7JTU8wNFqUAKTmhtM0M6Yqyp/B3+iGPHqvjunDq6T+OIsn5CrnIoP9PCUXoUErx56dCkn6/t\n", - "ujpoOPD4e/3qF+763hvS+Po1yMmh9f+fbxyhn5XVL7ZbnJt1vAwohh6DVfwVdboiSYZTA8I6ISiq\n", - "xv/iuXldtkCaBiKvpyiGmE62rQBRWz3HCkKwlFjNsgp57lapCZGtVf4iprLuEWhSR3IaKZBYbv8K\n", - "UhApFa8c9+p15sZrQu0aJerNaPOkKrWPI5VwQ4F/pOMnKNCYiGytqFtESJyei0pXFDkplgMJi5PH\n", - "8+8ZqqDeZVSSH0CSQAqau6BePldGihZIdgQbN4eEz+y+1r91/fPmZN//ESTz+8bu69t7hyYVa2u7\n", - "aev2dyAHhh4Id5yQAjaQoxGFJ4xqz7MqZtvFqppHktK1giA/TVSAA0++ILVMSAXv0DKxOabGDkug\n", - "wwMVTOjdfKDn5AOQ3pGyKRGyA0FIfRdzURdQKT92neekrA9HjZnmrgHSFUdIfTStHauBZEtMUhf9\n", - "qJ6QjJy6bdc3JqcSXro5pqQ+HuizlVwpFnI/5HnG3trw+v69O1/K3PTjEd8zsn+BZ1s4PM7EPJBM\n", - "kfq5PluZd2qUevkDHz58+PDhw4ePP0r4FykfPnz48OHDh48nxmdL7U3jcEaOzEHUrhsiHUKBmpV4\n", - "W2ghtQTjHqFU2zZk7gqV7YTMCIvcpQgmpG+6iRSLVw6qnintkEKdN6CEHzh0UtUGLR+QbuhH0zu6\n", - "QJorHClVBGhftUvmwjSmjoCbRzKDjEGUH4TU3kE2jUc7fqlmnKVBkVsoex9/Nhi7Rirxvn2H/dvx\n", - "Z2ilbLaUHoKyc0OaLZ2So4mwOoHE2E9kfDpAn4g0wHYbRx493JG5MSDwEIq5q9JSgW3n/r69v1m2\n", - "aaqqG+1YYaLpULv/d/vv3ffonJ5d/Jm7LiK2bkqofb/8GxER+d2v/x87FnLFBaUiRpDRI0qZnaB9\n", - "RbuVALD47a2d+xi6FOUgRrZMkHpW8eZxMji9H1QfyvY7DJpatX6ixrBshqqFDGlqaTGF24Wg7WF0\n", - "bffdj9/j/6TYD6h+RcraIUi297d2DV984XRvJlLA1/TEdkfaXviXx72m70qk3dRsWUSkV72bmAyi\n", - "U00F2jZNS7OOmbYdk9JV0T0j8ngOAnIYqXYM6eNM6oCwbJLu6Pp6mhCPAIdgvaUBmnGsGK5mxEVB\n", - "qVroTQXUnzKk0gaYQDeNpVtTmHYLaVZJBsoAXVePOZP1kTS1EhNRXdWbQyqyiJEWXPzLiWytulMT\n", - "pZZCtLs6F4iIxKLFK7RWx3w7U/GGmjsHG9OlG26+FRGRqLrF/u18n//FvxYRkb97/+2yLUJb/PTd\n", - "r5dt91Di3lPxxgyiektzV4U04jix3hdoBhj282RtGCJ9zmmkBGnmkFJwAegW42DbQk1zRjR28byp\n", - "SKuqQQpUPbCjwK7/AEK1zWoiLc4pIoNkHTNTb/1UWS5BZMfSdG9Heouq49RTocoJmn7HB9dOTOzX\n", - "tFuasxk0FOsjKmzoMHeFNk/s9zCtJlrKOODZTe4RgmMoe6GnlN0DHEIG0mILkdJcpcz3ASmf3EOU\n", - "STDRvLf0/5i04jbExv9EeETKhw8fPnz48OHjifH55A/GQSbydctAgOzpJXQC8VqVRkVE9lilHUnZ\n", - "t6qUjGw/rkEA7UMu9YUqdu4+o8p0aeCnlRBhb5xRriyGSOhifhhpVVM7RGom9Cvv3SqtIPkBVWpV\n", - "AiyvAlOU2o9UVh+CCJyT19UBx23o+FHg3rCT7C+WbavUkRef08rxdz84JGjCyjAjv6IQb+Etqbgr\n", - "/3Ukvzz12uoZORjd9bOyd5k6RErREhFTry5yfn93K41a5SKoDVfwWBxnO8/9yV1DbQsi0Wr+nhCR\n", - "AavoDx+JqI6y4he7v1y2jegz5cXXIiLy7EtbmVw/OML0VUyrOhQUBLTSntBpW1K7TgExDb3tb+yA\n", - "upCifatyGoXbx5pQjcMB/SRhxXiH8MytoXoD7v802fXH4o4x0kqrq9z+Nlz+D9J6vHJtnZIStpaO\n", - "M2FcizIyQkROWmp/srZO0NfXhGbFGAsdE+Uhf6GVy0NPRHCU39ekmK3ntKZ6bUWkei5TX1Ss7Xp6\n", - "ELQLRq4gbZLhGlmJfUYRAUudqIfeac9jB2OBizLQF1gpfkb/r2juKkG2n1i9W6UzVuhDpLqcJo89\n", - "/LTUmwnwKmEQhjb/qExDQr/NcE8mKgAZ0bez0rV/ltv8JyghnykjIEC9EpKumDE/BYX5/w2VQ9ai\n", - "ztCEOVY/TUJuLl0RULDHfHL33g6FYoA//+LPlm3/+3/+v0VEZN/YmOgwx2ZEgH57/w7XSkRp9Kcw\n", - "sT4e6LxbuHaKCSWegKrwvVbf1ZgkEQr1ST0RiRlz5pywxAykM2Y791Eg54Dvh1TE1IcodiLu8wjU\n", - "qafnpIK4rOwfA7HKc1KlT4A+EaZSAbEbOrvG5uT+roBMNZQ5UomdkNDXbOXOmQHJEfdkpPZvUZRx\n", - "oue0AE0f6ccZiOKNPoCpAKCBdAhLkqSA8WN61kxApEYqCmnbx0h0nmC8pSZTwSjep8IjUj58+PDh\n", - "w4cPH08M/yLlw4cPHz58+PDxxPhsqb3j8U52GyMit4qok4ryCGhzICPb/dGRd4+U2xmR0kliUgqP\n", - "lFBuUP0BBOUychBjQJ81QO6m2VIRynEPQoO2lbDHOjYzUoZzwgS8I7aR3gggeDXNDAjiXJUX2L9B\n", - "luHgrnUUTllEOE+DbBXGDmL6HkxLn11+s2z74d0/unMD6XwmcnYA+Lpnsj+IpSHBowE0syY28gQ8\n", - "39QG2b+9/j2+R5pJUAyOSTOkRponTR4rS0cg27Oy9X6PdC+p006TGlRSGkeNqYkB/uO7fxARkSK3\n", - "fpeuHMl1hgZPSppRJfoLG8pqejaaCW7vVFvMjt9WOHfSJZo7pJtIvb8LXap6Auk4JNQdPs6yWhlh\n", - "O4diMqdxjuO37pwmNoh2JPNuolQZSMZ1S2RXQOXlFikbIlavobr84aNpRv3iK6cjdVMZAXp34dIi\n", - "3/7++2Xbm5cuPZOepZuQsqJUUYe21YKSgKYkVfGe6b5O2EfbWd/NFKqf7V5rX+A0lpJRIyLWqkac\n", - "EsVZR24WvV+2j67XMWHfU9VjNhdfJHBIl2xE6oM1m2qYyyZcUYB5SZ0VdkzYRz9NiIA9LIbndgKa\n", - "Up+osKA6uf6cZtYnooXKQG2CfqwpsIlUt5WIPZO2WIT0YcBq14vOG5HYS9cnxwejAESrHPuzNMok\n", - "bluIgpnmg/W/ce/mxImOf3HhxnNGzhKDXg9RC/Q302j9b4cCnZxU2UP0jwLp9pTSs32dYrf2/TRz\n", - "329pTOj8P5CO1gHq6Ww4LymcKnIapyhuyULVOKP0PFTRq8oaWw2EZ0rjlriGrGAdJ3eMnKgF4+jm\n", - "Lk4Bq/I7TXtGaVnmXSKn46EYUVHIhHn3PAXtjv9ATiEdUnYzOXrEeI51NBmNSKVqKnSmcTVpYQOd\n", - "sM4ZFZnQqxzjRM+9Cj8JM7vHSep+k+X2PJ8Cn9rz4cOHDx8+fPj4o8RnQ6TGYZKqthLqOHBv4XNA\n", - "PmAjFHZHezO8e3Arkobe0pUgHuRUOo9yyYFWaVHg3v5PuiKnEvJgwmppthWEAkZMLA/h4ccE4MtL\n", - "t2J8IMXc5NJdDwFXMoE0Ch68RLRaKgu3qhpbQj9yfV0mEi9WDiO9VSsp/ngytfGLtUMEEiLWXT1z\n", - "56lKsCERTJWczWXA6uc30GolAuqnnnciIgkQqRMRZq/vILFAC+2y1NUJ+3q5f1NVXZ7o+oHcXT0z\n", - "lGiNVcKP775btk1YQYesxIv+MdNqWuBF9d37v102BRBNLqNX+Iqt9NZQAt+uDRHQkvgoImLt4Fb6\n", - "Efl63T+4FeluS6XuQF0Y9ZtAZA4SEDypXbXxQlKb1/ZkBXBtzYhWTYvEA62IR7RtTwUIShq/v3Nj\n", - "8eLCxtDNtetPX//SHAD+8Vd/LyIif/VXVtjw/bcOfVR5CxGREoT2lojlDQjKq5WtiK1kHytN9rrT\n", - "En5ChGRZEVPfBcLKKLFy7FU5XMRQqpBxpwzl7CCvKkldRGTAMjxkpBvzSrkxBf4JBPx3P5on3Osv\n", - "XX/qiCgfgTTcEXIbAJ3ke6zXY9dNpfYYQ4zIKpowMSKFv48nU4CeMSZu7m2eKko3dsuMJBGANseY\n", - "Y3ie6tBfk53Nf6IeelQ8o+M4GmiOBRI9l4YI90d3LunW9heiACVQJepXJo3w/lfO17FJrU2uH1zf\n", - "jQn9TEPXxwJCOhSBTzPrp3kKBwCS2ElAGi+AUjDaEKnXYEDq8MgIvNjaeT4cnXr36UDEerTj2FHf\n", - "1RL7mQt6cP2iLgZ2Bl2tPoDsrKFIq53nhNsZkbNHisxCTGNMJVNYEmZB4Ak5C4FEJsiICLlihJAC\n", - "SdhrcdTzJRI5np17chaY1pr2sXYq0cYjKZurTMSM7BD7+sWYd0eS6ZlAYm9Jgb5DW/T0nNLihZR8\n", - "BTNIJwUxIVIMN38iPCLlw4cPHz58+PDxxPhsiFQQRFKf7C00RU6XqkolhO9aQKWOLRCbkd4qd2tX\n", - "YjsQH+cA8bVptLz1JFjt6wpuIEJKq6t/e4PNt4oq8UrL/Rv1toIrQqxqEvteVbnjry5spaU5/E45\n", - "CPTGncTue1o2LyJyB8+tkPYrqXubJyqLBLie+9O7Zduz/kv3PRaTi3XVj9Jk8mGaBwioDcQzaJH7\n", - "5pW+ngaJv2WKJpaUD6/B+aFVggoSMuqlnKAgBs+LbMVXa7ffmPgjz69cW+/31q4n+D/JSPcTPIuZ\n", - "+kQO3lhCCNv769+IiMjFGvwB5j6g3V9cvl62VZWWHzObBtfAPAOs4G5IfLRcuc/TgkqiUR49wn8v\n", - "IPQjAvx0as3pXt3SA+r/ipwkGSE3WFWPhPCNQKLY4zGD/IDyXHpCkJRz01Cp+zPwUX74zvhQKXgQ\n", - "LGrX1iorYPdJUZKe0JSyhNcb+kbb2spPeRllwfIjitgRRwM6JhFtUy5PQMKJysNj8csJ16aciogQ\n", - "KeVShOS1GUG4c2IyGVb4H28JEX7mkL2ZOEoPKNPOid8TqMcg6wZCAkTvTcuinjingBBpBYwYTXt4\n", - "cCi2+uWJiAwQWIyYiIf2qY/GUVIBzgDcr5DGelm6c+lJpiLrgDpFdp9C8HDGyhCxEEhHQNIV6abE\n", - "IWmeUJQGbZeR0GMAlczD0cbVEZIxx8qeJy0gk4w0bjqgidFsXMII7T/QNXbg3yj3jO1HlcMbECKm\n", - "aMVMc11zAveIEDGZdN4llAacHxWEFREZIbd5gvxA29t91UTMQFIHijDP/DhDe27oXoeYRxmRVcHY\n", - "jp5FoyKxZxxaiGTiWZysbK5pwFEOAuJDou06EkTtcKy6JjQJQyEj3qhyGWeWmNFxjONz5mClvCkS\n", - "6W0gdULgu1Rosziz42/XuMfEZc6BUg8k3NrXniPlw4cPHz58+PDxRwn/IuXDhw8fPnz48PHE+Gyp\n", - "vTwNpe05ZQeCJZVGj4Dn1MtHROTh4IjSAaV7lGScEwEwXDmo7lRZuiuCOqnClDF9v4HHXRoaOXhE\n", - "miEtufzZQeYpqR1PWtZO8GwK5t9IpPgY0GOkZE4iR/YotQ9DLpd1sHia2rYE6QtO2URIQQ2pwe23\n", - "e0d8TUIiSosqIOP9mdp1BHQ6U3pMFZOjs0QiIF6CR9uTlu5TqTOkC4QUY9VHbSTIVCKQ3AHF832t\n", - "Qbwus1/a90HKfPHSSNG7zpFHP/xsxQta/k0IuKQJ/Pzo3ql3408//5OIiLwk/8PNxhUgZFRY0KN5\n", - "OkpPDiiXjWhdkgAqDwnG3+9d6mcd2v5GpIVGQPER4fMJCMAR9Ynj4NTW+4pSW2h3EnGWJD7oh8u2\n", - "edB+TLIfIEOr/11zRvZ3x//40dLjGbD4oTfMPEbqd0vE+gaSJTGl78PwcTpUFbjNh86+YwroBPHj\n", - "9FKWldC+Q5UNEGyWhNINWrxQkU+YKo8HscpvkF8c0kKcxdO5pjpaeqiGXxtLkmjZf0xp8RZODSmV\n", - "pI+z+vnZ90oUiGgqlDLGS8okoPPU1GtHyvr6W1WiFxEpUTzR0/XHSAdnkfXJCGrwKvUhAY9/HJNS\n", - "hinS8SEpy09ILYYF3Tv0tbAjSkHuUvUhSbeMGJMhxkR3S9IIkRKWiRw9uXlyXVr/O+2dZMJEKcge\n", - "8hikfiEjPh8p3aUOBTHmxHJF/Rbjc7WyY+VIn7GKfiBwxSD6RI5x2pylzLBbSm0O4q53cSeY7L4G\n", - "GAssoaEpUHag6GCKymnhWKVz6Jx6jFMu3tKamZEoACmI7ylSoQGlu1WJn2xql3HK0g3qhdtR+l5V\n", - "zoPZ9tfj855kEqRXUjikCWiuK2O9fitsGHDvHo52rBZzcra2H4exKuBT8UBb4xooVdgwbeRxeETK\n", - "hw8fPnz48OHjifH5EKk8k45WS7rqYgFFXc1f3xiJc0TJfkYrHRU/Y6HHDpIJGfkKRQnenIGSRLTU\n", - "Uzdv9mFanNFjdoTHeY62Skoyh2LwW6u+zZ7JFMRKVAWCQ6p+NYigTOI8wP28pDd9XRFNXNaLF+cg\n", - "ses5QIohJZSsH/GmPQMtoHpZJdTO7LWmlakkvjkpxDMz/AEHb1r9B7qsCZi8C+SMVtPH+gHHcr9N\n", - "ya9qOLm/08BQygwiiWVq5/ls44oN4ti+99MHh9xU7eMS1ozQjBIo1eHuWxERuWnN12sNRKqjlXYH\n", - "KYyht/u/3kIsridiM8p6UyKl5/Czi8lPcMDqa+6x0jvzkHPnuVlbqf3p4BDWE60Wo86tjqOIvAZB\n", - "bN1GJP8wK3Jq90mJ/x0UaU+DIS0XFy+xX7snJyBM642tyJV4HcUsUuj+romovoHv3ulkK8erZ04Q\n", - "sYLHIwsjxpBmYAmTECjuSFITYaRCi48J4BH1cV1FB8KIaKQ7wX9JmBHb2FdsRh/uCFU5Vq7NCkKa\n", - "TkCsCioAUN+zmgj9+jkjDEqULRY/Q5qncIkTo2Q4zx9/MPmFF89d3y1X1nfG1p3TsxeGuqrAIQuX\n", - "5jhuIIp+2bHUkyynPiQonhlHku64c/1kCkxqIMxQzn+ysRNnVziGHSSATI0iYfeH6+Wzn1G8EZb2\n", - "/QpIVyuGfg4Qoh1akokAUbkdrf8VOUQv6Z70g/tto/8SYTkBqvRAHnobzDsDCV2GqfucxR8DnYtp\n", - "Pm8gZ1BGTNQGwg2k5QzpDh+P4RSFKqRmsxRbNIy+ArIeZy5UgP8lCVyrIKr64IksdoqSALnmAqwI\n", - "RH1G/xVp5vPUQo2YvStVOJaQ8B6du+/se7q/BOhXsaY2Cdy5s3B1ixoHqmuRCITyIKUsERD2mao9\n", - "FDDre5KdGBhtfhwekfLhw4cPHz58+Hhi+BcpHz58+PDhw4ePJ8ZnS+2FyUqSkrQZQFgMSDtCANWr\n", - "craIaVXc3JtfU9U7uDcPSW06UlIepQp0m7INSXdC4N11Dy8/EZG4cZBtT6qzOeDRmPQ5Tgdomkx0\n", - "niC0Vx2TIjW1hhQfQdEFYO+6I9Vj3B1O98WL3gVrFiE9RNy8oUB7zgZjK7SbQzF5JNhbee8hkV4H\n", - "tN0cUBoJqT9OrQRIxwY9pxsBmU5E1BxVMZa6XeO2nfbuXHpKhUzQc/nVb3+9bHsNFfmvv/xy2bbb\n", - "OuJ5ubU0Ros2CzlVCeJjnBmxVvvbGkrcx5OlJ1qk8Y4nI7GfGhQFRNYma6Qj5zVp4SCNMJ3s+Nvd\n", - "M5wHparQtgH0q0ZKD8aTu56hsTbZZG9ERKQiFfv6hFQA9edpAwXqwK4nREorJ08y7QNa0MHpsRHX\n", - "PxPErWMoYRX5URXTrT+tL925s/9bi/Q1k7c1paaE2pnWdj1SqiHpLikHoDsju7v2iVkzCOMujVnZ\n", - "HunjnMjeIKAqsTpkcr4WYND4jxctNNK7AgVgtbLU8v7gcgs9+bolaLuqsnuyKPq3lEYBGThTFXGq\n", - "IqhrFGCUVJSzKFHbfPrxnUttv/7iF/a9lbpH2A1YlW7OjFPbX4TjLmrWrKxfurGWFpSyQ3qcVey1\n", - "QGW+Nb2n4BlSxUTUVv9FCa1PTurZ1rrfbjfmbHD/7W9FROS2tfm/RIHSQ21zdxS5ea8mHbFQ0E8o\n", - "3R3ieRKz/yL0BTWl3DbMrYAWHGl2haCUtNQnYnyP9bA1GxYMRB9BSp09KVPMz4GKLFH314IdHhOa\n", - "KotICykDzSNhzTKkxzjdFaqHHZHteyWq0/MkVdcEFBFFpLulRRwNpQI1Vct+rjrtT1RQo9cxkt6a\n", - "UjA6UnS3FDSe4QmlApGCJVMQaXTuopRxXgRn5+F2jHQvzV3jpEUmTED/w69KHpHy4cOHDx8+fPh4\n", - "Ynw+r70wljCxVYiWa2eBrVZaEPq2VNY6gtEW0qkf4ac1ElE5RYl5lNhvOzDQQiiX8lt9ECk53BAc\n", - "XYkM5AO0XbtznkbaL1YVPZX1a5nqROX/EdRRFcwaRnvlb3O30mQ1VT29iTyPejAKA0KOFKWbyVet\n", - "haJsTKQ8LZ1eY0XYiq2MZ7RdTyTyNlAPI/IrxOo4IljhEmrXbUUl4Vg5U/WrrED8T4hsfgGyqZa3\n", - "hmKo0py7Y53ufr9s+3DrSvEvdkaYffPK3euLwlYQ1SunRl43do3FWhWjDeHpW6x00MdyZoKiOOBw\n", - "NPRnwL1Yr58v25rakWETIjHmIDFH1HfXQBEmRg4712ZB4lCSjhCpuYI0ApXVD0AuSypXP47O16sm\n", - "FWF1Yu/YQwoeXuNsiIyWP+u4KkvykMP354GIpViJh6H1kxQr/IlQyrv7W3zPflsACUxJqVrBlAFI\n", - "WEDWBuqvNdFqVd3kzyQJsG1kTzogmxNti0Il2xKapcTqQN3lHyubp6RiXdUobKFlbQP0a0Vk8wor\n", - "3KwklAxQQE99chk7rc0xGQjNClzmRJhPgFycSFaigYr88+fWJ++vXdFES15/2dodK2HkUuVUSOJE\n", - "SfMhVvPrnUmNpK/tydQAACAASURBVJDkYLXxFkTlnPzyBpxTNNt8Np4cYhS/Mu/GCQ4UVHezFA2p\n", - "mjUTlrPctcXx1vxHc6B6l8Ur2y+KgSY6fle7Bo35OYH5rGfvRs2KNOrXSbIOS1dklNQdv6V5skN/\n", - "nqhdFW2dBpsnAvWTJbXvBMU1A+Q8BiKHj5O7nxEjUngWRrmdp6pzJzEjckBzCJHXqoVcyCcPz8CG\n", - "JCZOB6jCb9xvJzp+mCiCY4jkufeGixUKH6aDPSf0+Uj1PDLhGTcOdgwdEzOI9R2hxOoNuD+RrIsi\n", - "zbldv47FPKPiEWTCSNjdiOWEMEr3hzEnj0j58OHDhw8fPnw8MfyLlA8fPnz48OHDxxPjs6X25ulc\n", - "CXYWBxmGBLEqeZSNJzXNdfNAcCsUU+eYUgCR6l2QuW3l4N4QxFYS0V7IqQGdk5o2shnihL97goxV\n", - "02mmc29A3u1JxbXXNM5ihkr6PLjEiGDHAXhnQmmUETmNmDWb1HCWoOXbvTtWR9t2SEvOo0L2lGI5\n", - "OWh3lRmxU9N4TW8w+rFy8PzFzlJAei4hqaJ3SO3NrGYNGDkhHSdNt4Szg7OTxNITA1ILL7cGGd8i\n", - "jTv31CaDEkZt227jzq8sSBcI6rUhmWAHKe4FbkVaEhFSSa+k2aWeyhfFF8u2n2AuHVP/C3FPZkpj\n", - "aoogIvLwSnWT0McPpE90/+BI7qvO2isDYXigttZ0HBt5qxwbdZ3FBHfsWFvnnNDaNpYyOhzc/q5e\n", - "vLHvo/AjjEgzCQr8L67s3t3eO6Pl7e5i2aak9HXGyt74rFeDXDLIBmTP6uA92ieh1FqE33AKeg50\n", - "jLHhOIiyCWtFKckcRSRENq8ql57i9EwLtWU2jY2hn1XVTAvAfELEbiXvs2lsD5I5mysPSLcO+Cws\n", - "qTgAGkjsDqDabqxEvbty4zigOSlL1bSWpdKRUh3tt+0Rad4V5gsikY9K9rc9SFy49Hx1MH2osnAp\n", - "7bPUqqa0WLEa7TPdmwm2JI7IHpaunxxAnBcxE/Smtn7ajW585In1tc3KEdvb0ZwtEuQPJ0rZzCCl\n", - "x2Jke/1rQkq7I9XxEBQQJqwH6DMdteEA4nVIdAtNI7JSvZLdZ0pjCRwIwKGWIKD0KOYQ4pXLBL3F\n", - "PLO+G4OMHdLBQqQgs4zMpfEx63LNSCU2J3LZuHN/b1daHEKm9RifqskkYq4krBiu7X+xYWqBu4/z\n", - "YGNHx8nQcdvpXOz+YWL/EZny+yOrw7trXZMqfZypfiRL22N/VAA0gjYTsn7dxGnLx+ERKR8+fPjw\n", - "4cOHjyfG55M/kMlgADGV75lKeBXhGYmw3bTuzbWjcmFVew2prFL955goqIiFEjWL7LH3V0RlsAuh\n", - "jxCJAcuEiVYaIVYnMUktCFRciScoAd6SB6g9t6S6XcMHMCUi4oLmkIhwqIgUrciVRF4WtnK92H7t\n", - "jknXk2P1vd05ZGKmdeXumUM1Xr7+F8u2FATo9x+s1Pi33/0DDmqrygHeWDMpoCvaF7EqMxCDiRjo\n", - "KXzsFAgoCRHqgLqoIraIyGl255lQCX+syud0/3VVFZLa7YjuHhLCGWB1XALBahuWB1YjLFInXgij\n", - "9jXB6qw9cqmta7sgJ6+pRBFRW6UpP77InBL1SKXxR6y6r29JbRynEqWGtCrxO6XrUo/DeSZlbS1a\n", - "YBVpHWMgdLetrQy1GIPJsYoYXd+a2vTLlw6R+Omdrf5joHkBrdxVUTkk5FABGz0llh/QMnDuV81J\n", - "feUIJYA/JiPcCk4lpLbe4TpyQkSV5BrhROaJESQUm5DUgmqSUJMQEk3+kyCU10QKnzFOSvITbZWU\n", - "TWXiEQjCRyCd25X1dfXVC0aSVcG2M5kCtKPKK4hYdw4JildwNhjtggagaSedazI7vn6voLkmROFD\n", - "QFIbWngQUvHC2ACxqqx4I7r4BjsxlOL+979x54GJ71DZPHl94xDxI+QlRETaEPIndK/DyLVxltF8\n", - "nmiWgBBxXD8BgpICbV1h7phpTCr6H525A0DqIGDkFP6Pn1AbDwilV8SYUepxsZSAD2lkfUOfO1Fm\n", - "E9AKLg8Zoe8BSNkBuX1o8QQjVzkQ5ohkQjqorR/JuzXC/lo8d/n6E5xvRONUnRUykslQYn3GaDJ+\n", - "c6I2VvI4S+cowjyhGKqmMVkDpe7ouVKs4N1JnrCrVLMfNCcDCR+poEazPgnfp0+Q5zk8IuXDhw8f\n", - "Pnz48PHE8C9SPnz48OHDhw8fT4zPltpzsCUThmHyODGM7mDHI2mhdJBbZRLppnSphZjJdosCt+0v\n", - "UoNCpBhaUh1XxdSECHOBkshJtGaAOnlGBrkZ9I5SglFHwJiqsCtiirETYOeECG69qkPPlsYZlABP\n", - "ub1B1ZZDS8ut1+74f/nmXy3b/ua/+q9FROQK5qUiIrf3Lh1TdY7EnJHJcTu6FMSrC4NiFdI/neyc\n", - "NLV1OJACO8jrPZFIC6SUAmq7CnBsz9pauLYQMG7VGLF9UCXeyY6fIn0SRpyy0r5AaQwcIidS/jWM\n", - "ZFvSm9L0ZZaCnE5pjG5y7VT3pM4M9Xw2iFaV+0yM7DqecN0jaXtFJ3yPNWOU5OzatVzbua3QnANB\n", - "1qfK9ac8tL6TI803U3omw1iYJ14ruW0R/VZJ1mOviuVU2AE4u6fjV41rw5nSndfI8nW9wfOrrdP0\n", - "qUgp/gJ6RJyWV+J/j77RksbSopnEqRWkTxqSXU5QMJDQtaoCf0CpQs3G1zXNCYuRsRqvksIx2vNM\n", - "Rw1w/9n3MCb3DzbWNX1zPNo4yZN/lscUkRpzWzASeRwaWKop9+NPdq2pXs+ZZh1UrBMmFsujWNLd\n", - "5MqgKtIhzXs6JhZSPmt2IaXTUJtkIArnl1ao0sFoOCEj97BEOpry4jMI2mP6ctm2funa7H/7t/+L\n", - "iIi83f+8fLbvoI81WJ9odJ5gg/LQ3eOOUqBJ5vYbkJFyMEPZnYzpo1Gv27VD09FcM5//K0IpYBJD\n", - "6pEyYheHaFCiOqWv8RzjIged7xtoYbGLRKL6UKS3lqO/zJTG1UItNvzWYo+QnEKunjuHiKudKeBv\n", - "S3fvouDv7betI/yn+C1fV415n2ks+uyaUnLPAB2Di32UbD+R47KaBYc8nwfnHbpvqbALx4rJyD4D\n", - "sbykAiBN33ecl1f9LCoKCUDRiYmon6/IIeET4REpHz58+PDhw4ePJ8bnUzafx4V8LCIygWQ+0TZV\n", - "Oc5zIxsneHPviUS+cMLpTbdp3OokJWVTJV4WeIPvBiMs1pArYBJdDMJ6QGTzBO+ecUCrWnhjrQoj\n", - "VkYgYE7TezpP+P8ATQlopZ9g1dEP/KbvVlAdlTWHKM5lwnYOkunFytCnHc7lcmUoyVJ+j/Lmh72R\n", - "PjssJ45EjhXISjzck2I5SsJPFZG4gbSFdE6rXD2U7Ny7EMQ+8mnqQMqMRqygGiMxCxYBHZWedljB\n", - "Mym6OjoUKyMSr6ptb1ZXy7aPx2/d9RzNO+9q7ZCTVeHabia/xA6k2JGU7bUWYqL7n69AouQS5kUc\n", - "2dCEDovoKaRChQxfxKqeCaO7S/QTsf5fgYAstF/t9yEhojKrTxwrK2NFelYUAaV8IBLsAxbg+xOh\n", - "H7cfXV948dJUpA971z6brbWdErB5TCpRNYxsf4MSO6Ewzh56K4xX3scAD8WcSrh1vyOtNFdaoEAO\n", - "AHpOTEDX5lH0qSW0TPfHbaiSCCNJISuqVFXkgAAF6LYlNA2/SQkuGoDwZSy7gnvbYH9TYde6ee2k\n", - "KOqOFPvhl9dT2yVF8ngbEL5zhA0o/ZlSN/oT0LqEnAC0eKDrqFwdSCQXhaSYswNCieYAiBQhIqI+\n", - "ogn5iW7cmP3ym29EROQ//I//YflsSN38sG8Nud6f3LaU/AJ1nHY0d19AaiQlArqiWKEYEh3FKIAB\n", - "OZu9XhckklDFAQfTZ46ISIN+FFNBk/reTVRYkOn4pz6hWZSmV29KQp/x/ZAyIilkbeLEClAm/Gai\n", - "+5RE6pfH/p+uP82T3eOicM+M51evl23XN9c4l8cFYAqYBROjam5/p6M9O0rMkw0z+9VJ4gziQ9Yh\n", - "IZkaVeAfdJza8dWfNKYiCkVnGWnVNEVASJMivBF5/PbaFoywzYxiPQ6PSPnw4cOHDx8+fDwx/IuU\n", - "Dx8+fPjw4cPHE+Ozpfaq01HigFVP3TvdQErgJbR4mhOltiKFW4nsC6iyJ/J4A+h7pjRGnqvaqYNC\n", - "9wdKu4BEHhCENw9K4rTzVr2XkJTNQxAbVyuDtuMIRO3a0of7ysHRqSgRltWZ8QerrYO82BKJW5Vq\n", - "GRzdw1Dy3QfT8Xnz2pEHA9LR+HjnNFgq7K+q7Vrfvf9WRER+Li0VOUI9/Lsfbb8Pe5cWK9cGIyc4\n", - "+TixlJXexQOlNqolHUZ6N4CAY6SPClbxxfdaThnO7rj1g7XrQ+6uKyJi4xWIrbudEWCTnx1hcmLN\n", - "HEC6mhYcifQ4fYIwrmmufmCyM4xP6XuRFi9QGjNAakENekVEjrjHIb6/IjPODP21WFERA8YMK1F3\n", - "ULtOCbIecYye1koD+ukUUAoOBQ8D0j1MWJ9xF3sy1I2Qbh9aItZ2rk1qMl7N1zBDJfJ6A7XnY23p\n", - "2/XWpaXWSAvd3VvKJkZKicnpHY67Xhlh+HB0pNyIUoAT0mg8Jygpm7MISjZXIq7qNImIBEjfBJR2\n", - "6VTlO+DUHkjBZNp6goF0SfpAM7R1WkoBqo7OTMbUqgul6uVpbJSBDnpfAbWrKpWzOrqahnNaVPvx\n", - "SAasqhAfp1SAgbZVE+aJ0mMhzrMgHbMZhObm+sOyLVPtK0ptDWi7pLB5ctaigNlSUCqupDUR60tL\n", - "z3/79rciInLqrE9U6FenyrYdD+76v/ryl8u2EqnvuDQF9v24x/EttSeTS/MHIOUn1DaiKvrUiZRY\n", - "zmlpm7s5jYi2ppTVDP5CkNk9mUCQb2uYdpPen1JGVitKY2I887ECUR1D0vtDIVPd2Hl++OgM4Z9f\n", - "mFNDDzP7YaBUNdL2VYfUXmd9IgXJu68i2oYUMI3dBq4J01lRCFJw3E8xZ7ECvKbXe6Tx2obnZE0F\n", - "Usp6ETKkOQFjNsupoAxzXEBjYsY7QM/PgrMn7uPwiJQPHz58+PDhw8cT47MhUsMwLN5DIiLKCWMe\n", - "2ojVZBiRrx7etIealFDxm7o1YlsLUhqTLZVQqDIJeWor8+bkVikDrWDjFIqtROKdsaqraEU+As0K\n", - "uawcKxdeffSzroTc9ydS4p4GSCIQgqYVn7oKERGJQVTP+E0bq9p/+KffLNt+eudKhjMqpy9Wbj+b\n", - "zQ4HIF+3g1tNzne0qjq5hlXfPhGRRAn4tCJbFTg/QmREfcUGO36IlQMfdyHSg6i527I6L1bas92n\n", - "qgP6Q75md3cfRUQkL+1YL0DAXJe2+r3auJXm9clQtwHehhMIvhOt4LRyeKRSd+2eXChRA3Vjr79R\n", - "VYyJsKiIUUoGeEqKrdF2U81wif5LREf1BhTqk+jjHZWER1pWTb5SVX/EeVq/y0DiVLXfiRAxRRo6\n", - "KqEugFbs90bYjzGOTtRPtpduf8fOVv8xOvQDyWlsgFzUKk1B5OQV7mFLJF5VW+97W+nq9TCJWtGk\n", - "kRA2/TzPyScQ56Ll5+ceeo8lEVQLgCVBdL+sWK2yD9vnhohqqbuQd90A9EHdBkREptp9noM8PRPr\n", - "VYtMUiLMHw/3OE8qilFfNzYUxfVEVErOVHyN5gTUOQfpnEvzQYQeaLWuZOuSSNHq5ykRkbhx70ZS\n", - "wJbEjc+Q5umpcm378wc3h7FcxekEVLOyY7VAH0cqQMpjt9/nK0Nacjw7xtHQ7AiSJHFk93Nq4J25\n", - "yEBQSgL9qiNETMngHRWAaP/k5q+AmLGKuCJ8EyEi6p3YQ8W/P3M2VESQpDYwdgM6mErGjCSnM+Hv\n", - "nqRDfvqg3pE0dwCJa3v7rbonxHDKSMibT7NEbGGnvq9M4lZ0KiafzhnP6ZAQ2RT+fDHNkzP2o6h2\n", - "2/JYx790AlofEZMp4Qz9k5Dupz7PRyoAaoDS07QjBRUyfSo8IuXDhw8fPnz48PHE8C9SPnz48OHD\n", - "hw8fT4zPltrbxGuJI4PTVGyaUyGaMukrg4LVmJcVm6sOMCYp5jZI/U2UgktAilNgkZVYQ+yvIxJd\n", - "DwiaDULnUYntpBgLEuntrSlgX164pp1GUgAP1PBY85iU4gE8280G+yoRm00WIyWHZmS8if21RJT9\n", - "zfffish5aiMH2fmv/+VfiojI1Xa3fJYkjtB6bAn2ht5Kllhbq9xNQmTbdtBUhJ3TlLrPI8rV5r2q\n", - "stu2aFFZxvVTenSbuTs1kGZTAl2wsbJrrQFB16QtNYwupbJKjZR8sXbbPjx8v2xrGpfGqGqXHsxS\n", - "gqyRlhzoXmv6NhFL46xzp7tSrk2zq1e4v7I+sYJSdEAEdEWom9qlwDTFLCISLKnvx4UVTMQcVTOK\n", - "lfJRDNGQtlWC+7RhuSmkERRaD2kMLeRZUlGeYjeuItKxOTw4va3N1kjBAa7/wLpk6DITpQqPB3e9\n", - "SugeKD1cQxX8gQoLNjCXHkgzStP3IaXWLC1Hejc4Lqf7NW2nn3WU2leC67mK+fRom5LYe0rZqd5d\n", - "FHFfd38PYr9N0SdiItuOSD0oAZyN1wV/s8mqat8dSAG8wvdWGxvjo/ZnSu3kpRtja0qLjzCc7lt3\n", - "j9OQTJ4xZ3MBSKbFFlyA02p/IhKxFqiw4TqKIgJKy7770ZmkvzuhiISdJRpoMVFqJ0WqjGkhX712\n", - "it1lSsRm0Caalo3pNS9kbTKHUO+HQFJGc22PuZbvvyqajz2lxWclRVMKEM+YgXTxItUqK1g/EX2x\n", - "dr+dEk5Pw/B+JLeJCer4lDJtoYqeRkysRn/u7Lf3R/fbdWKaUWsQ2Vdr0yWsKuj9RdBxI707CVuc\n", - "p23qe9WRMgpACCrL2fNMX0GI0pIt2nb0fMSLQd2CRG+Hkhwp6PWKdKRwy3pKtyqjoaFxqqfStGwa\n", - "rQR46qcsKvWJ8IiUDx8+fPjw4cPHE+OzIVJ5HApxXhf13JlWqweQLhN637vcvBARkWll3ky/+/H/\n", - "ExGRurLVvK5OGyq///DB/X2xRan7RG/wjXvHbWkFu5SEZ0SOhPJz31BpJMiQD5m9fScg1I0Dkejg\n", - "KxSD4FzXtjLoQc6OZioNHtSbyPYxK4k7MERAwaG8MGLnixdOsfb6o5WaHw5A7vCWHoxUwqxKwKRY\n", - "ngMR2hIBXNA+GZdrY1XXE/oV4PwSKuuNFaWi61E0ZYTaNavZ9pOWZltHSXD9I9NkQUqvekM/9kCn\n", - "XobWnrvSoRkpoUlt5xCjBp5gSWil5qoivMrf2OUD9dkWdk75yq36o8yOdagdSvNAKFmAFS5Ld5xA\n", - "8uywcn14sD6kiEhS2n16fenOj1EdLBZlJLVrLeQoaDUt6M81k7cXhW6gJYy0KImVvNnaGis88ibb\n", - "LcULtk78+N5JTewuni/b7g9O2iAhEmkFHz291qIwIur9/R3Oya5VSb4tqf0rYpCw/5eW/5N0gRLV\n", - "93ubJxTsU3I6q5OrEnhI+1Cl5oiLPRRFI0SkBNJzLifhvpdmXGSi441L4oFmh4rW2H47KHpnmfUJ\n", - "9b/jwpYOc0tX27VmkCdJIr6fINvTGl+dJLTdc1L2DkDAHk6kbI75ZEeyBno9MxPLNRJC0/G94cGQ\n", - "2woFB3cf3bn/9Pbt8lmKMdb1dF24/7udjV0tgJnF5rOf79wxToNJbJQAkdOIJGaAus5DenaOIiKT\n", - "3ndCVZTjHJKKfgz0iT3iVA0/JOhs6nGPU0KkQvU/RMFIwkgrENTQ+mmrHnohZ19QlECFSgE8BEfK\n", - "sAgKGmKakwYU9JQru+/rHWQaIGFQrEjqBQT0riZUFdI5WkQlIlJBpofPU31KZyrUwe5kIO/IHues\n", - "j46IfPWKElIzJPXTYUzSlCQAsySkZ0ff6/0kOREgsmlqP2Zf2k+FR6R8+PDhw4cPHz6eGJ8Nkerb\n", - "7sxdWQ17ePWnpbabtSEtwaxu7YaShKGKKdpqfoW8/TzZ22+N3OhRhThpValu0knGZY7unKZPlFXr\n", - "W6uIrTBayr1W9QPOk/yCOl2luNVCTmXFY6hCZ+Thh2PQoaSDmFoW27FSlHMzcrUq3XXkvzBX75sb\n", - "x6G4A0p1QSWdK6BPp8i2zbMKhxJHB6gapZ5lAL8jIb8wLZOduf4X7+1RxB6L7vMGXIkTrZZa9Uai\n", - "pb6200CrhXwRxGTxN3COaKUzY+nIwqkPg2uLECu9mMrKt2uHtIzEx4s37honEtXc7lz/DIg3NM6O\n", - "13NgrzfluhCXJIL/4hS4+9lPVNYfKs/EkMsM/SlK7Dw7IEwHEq4N4L+YEcKzLt31hJ21iXpWKpqT\n", - "EarQtFj1EySitycl/sARUghvvvqTZdse8gBVReXX4OYkG0MO7oASbMHXY2HKmxu334JWxooYbS+I\n", - "j4YxU5Y2TzzAk3C9No6ctn8/POZBdYuoaP3os/hTSBeNNfU1436aqncgienOvUNxXjw3lE55jRPt\n", - "L4bY5Tp3+6gOhqAEs3rjMUtEvT7tWvWMJ0Ldw0hX2tZ3lOvHEgdKtdPziGhOjIH0ZIRcKq9spHuX\n", - "wc/0LO2gWYeIvQ7d3x8/Gr/rh/fubwUia0Ka5wDisySqqDy0i0vjgynqsCfO4fVHSLzwUw9jNiio\n", - "nVJ3vGBh0z72a+T2nwYt9adnAnbH/m8D2j+i/pRi7opp7tRdq/9lyGgRELaeEFkVMBXyydTnKKNp\n", - "GYjIY2vjqVXuD3HEihVQbxJJzSF3EOAeVq3drxzPjJEaViV5ktzm+hWeE+qN576IsUP9X2VChjNu\n", - "oJqcun9jeoYEmAsnep9QeZ6e/XyxbSaUMFPeKj+n1buXeFFx/IcxJ49I+fDhw4cPHz58PDH8i5QP\n", - "Hz58+PDhw8cT47Ol9prTKAGnTBL1t7HvqE/U/nC7bNuuvxIRkZFSdur7VVL5/bp0vy2onP32iPJP\n", - "YHcpSQ2sNgpjG8S32q5xLIOxexB6TwcjR6qOQjdZanFQPz2WMwCkrV5axOFdfP26htSJY0DmBBlr\n", - "+oB9nRQqPksPIN2XE1H71UuQpgcH2fYEsRaJu/6XF5ba+fnOeewNHaVAAXeucit1T0COTBNLi2Ql\n", - "UpABpVZwafveUhXqE5avoFgt7HWmyvKk7A6S4Vg9JiIOJAD88d71mYhSa1qJvXlBatMggCr/dQqt\n", - "r4WA9qOYfLgWry2D1nv0j76x67q+dtB3Uxk8niG1OFMfS1L12oM0wY6KCKBovE6JiImUJntohQGU\n", - "9VlZuFbFcttYIAUeEVG+R+olRFqaM7GqFM2pLS3Fngj2XqOvVY2l8QqQoU+VSRcsHoOUAhpRvLCk\n", - "Sun4t/eu/P3PLv/Uzhf9PqOxHhXuutjXS9NyLZX6a7qjonuipPETpBY4xaAq68NZGku3PSYbc8pm\n", - "VAI6zVPTwnxlORGQbWdOQbh/tfx7TTIlfatl6KzO7I5RUGpT1aEHLttGemSgMn1NwWwvbJxuL9zY\n", - "TlG8ogrfIjbvRCQ1YarPNE8piZhShqJpdqZKIFUTruzc//1/+o8iIvJx/zsREUmIiN1AiuRI9/Cr\n", - "L1z7cHqs69x+b65tPEcoEJooBd9hyEZi6cM00D6m3oSUnoXLAtM9QrR/xs4Gk0pd0LXGmCcpTVRi\n", - "7GSUvms6TWNhrNOgyNCeM6XxGvTFbcYPFNAiAn7Eu+OXK0utrzUr2Fl7ToFrszSlwifQPBaaAz27\n", - "P/yMuVasn6jUAU01MmIuHqjv9Op1Sv0kXNqWcB51+YAUT0xzok5xA3uowqFhjjg9F539KyKSp0rf\n", - "sfm8xtwZj5aC5mfLp8IjUj58+PDhw4cPH0+Mz4ZI1X2/kH9FRNIab6u0IlUiJhM2V4XzSWtopTmi\n", - "xPysXBGrzzmzS0waIEJ4cU1IrGwHsnW5tbfqFG/uM60gjnCaD0Z7g65rh0QFAYm0gWysZEoRkR5C\n", - "b4p6RcwvxNs0cV2ljYA0kFhZilVqTmTjAud+IGLveHKrpDWt9NR/KwGaNFEZbodVDZMT4wkE9IaQ\n", - "JoifxbmtaqbBIQftYIhchpVuFPIqFagfCWy2nfttivuUhIzIuTZmEu88uX1MRLasISHQ0yrpulGR\n", - "Oiq1BQE4pFLWcuXQqSRjPzXst8L1ULm0YKU1jLaCO8D3q6Uy/Uqd3un+Lx5nEfVTOJZfBO7cHvYk\n", - "PojS6CEiQUSsDHMq/81SJXbatR7h9XYgSYQNdl2QJEWK64mAJvSEjJTw1esJ6Qm0iGDklR5W370d\n", - "q8jcb0dGbkDkZ5HCLY5RY6xnRCw38cvHoppCSNtybvS3yqiwTIR6vR0ORkDeKckd18++ig3OqSwM\n", - "EVWBW/b6U+f6MzQLv71csa+au/6Ofjugn6Y0TnU/+r2WxvUFSPYqFikikoGUzl6PERDmnPqaegJy\n", - "kY/upywN9bp87pDrfOsEGVl8tcf5TnT8BPMPTb8y4dESkHTHgk7R9dd3rtjjcLJtF5fuuP/0Iwp2\n", - "qFx+xJgYz64fY4z6hPansba+U8AzlbvO8ejmkYr9VEN3jXHi5vAossKGDkhHED7u/z3V2qteKnU/\n", - "mfAcmWP6Lb4XD/ZbJaqHQEkSknBJRhWVJaFjyFVIReMUSE87MpoKOZ/SUOIkdf0uIpRGxawDwlki\n", - "3LsigPxFbxkJgSTF7QcjoKeY12K6T4pSMSKnCYOI2jMCmlZmNHcC9WvE9fWeGnYGwtpS5ijK3d8F\n", - "zZMpxFljEsRVJKqx6VzaE9C3jseOlz/w4cOHDx8+fPj4o4R/kfLhw4cPHz58+HhifD5l87yUbjDI\n", - "+gHwNaHjC1Q9kAHfu3eOgMgEcFXPDSndJhM8+ehdMUlUKRhpJ1KMTVTbifDpOXJwIqvDTpnb70jp\n", - "oQHkwLq16zkcHFaY5USADfA3dD8mIkJruoch6x7aNgVBnCNgyTAhaB0KzJutpdvev/vRnRuRkneA\n", - "6pVsVxPpNEgdZBu0pBmENA+nO1RFmUmMqtXRdOSrhuuJc2u7BKnEkNJ9yaLfhHtCnmMhtJVSgsKV\n", - "WJmTErFqRlj1vAAAIABJREFUyxwotdZC+fh9S9pipVPF320sVRGlqkDtricl1eXVhfOf+uG73y7b\n", - "0tTB3k1rqcUDNJM6SpWqr9cmMmJ7iX03g6XAglQ1kNz3h570mUDADinr2EOrZe4pZQqvsfWOUnZr\n", - "96NTZ0UR94OD9IPB+kmMdFeAdA8rdodIfY9U2KByLmVmKbihc8fa7CwF0UNHLaeUgaZU2IFA01jr\n", - "nUstnfaWRtXhyX6RquM0sWL4rBp0RDZWUjQRwFXviNN9qim1+PXRBKQpxZb8OqtPHL8ftA9zrv6x\n", - "ZtO8pBFsnMQYC0yeV3L73Y3TPVrRZw28y7ifztB2Czi1B+Ix699o1pZTkEWpvmrWJwLsO0K/2u8t\n", - "FdRhPjkjB2OOjUmzTNB35pRU0dU7sKX5BM34d//0j8s2TZtu1i599P72Rzs+vBtfvaRiF7Vrs6PL\n", - "CWMyTYiAjzmpJa06Td+0B3J0KGJ85u5XnFFxAtLoASn7DygKmokq0uEe9uR/GYAoPXGxAVJGHVFV\n", - "1GtPPefC2J4hZeLuVx+wFpibYxMS96v2quxv80SMwquQxxPmzo68+9YoHmjXNsftUIwVo09ckrbj\n", - "BqnHHfX/m2vXT8uVzbU5vDhD0upTtgP7hKqP6t3RzmmAA4LEULZvaQ6BK0a2IloKuicjRWOn6X6i\n", - "CrTuGw2zN054FpJWJesGfio8IuXDhw8fPnz48PHE+GyI1LPLS/l4oDdDlJMP7MwM1ClgZWV1zqYX\n", - "xBCr6YYUix/wVsvu621z7vQ+kIP4gLfp26O9/WcoP08TdnoHKZpkFeYj3oQHKyHuUZ7PjuAxCKAT\n", - "1KyJ17uUlSYG4Cx25hMpdmdYLWYJqbOCqF3GtqpsLt0b+z25b1cfnGfV1c4hUxmtlu8rh1zMo+33\n", - "+TOH4OiqVURkB6/DF8+/WLZ1b93K4e21rbSvP7j9HEsrP35euuNOubXJGKuvl7vWjBqlAOrVUftX\n", - "6mpOjNEEq7M8sRXZAJJlH1jb7UEeZ++2Ev3t+YW7rlX5yq61cKTbL//13yzb/v73/05ERB4Ov1q2\n", - "NRWUdYlsGgIJiGnlmqIkfJrtPGtFndCh1+SNpyTmmkq9Z3H7aEgnRFGUuLB2yoB2TlQSrUrlHZWz\n", - "xyFWX1gaxlTE0AI5YZRKh1PLBQhARNsTe126excySRPLxLKg/QH1XcFNvqL+qs71MemEnIBI9ESi\n", - "Bf93QWZFrE2U9O22Qb2dUBKVTDC5BOsvigjPtILVvwNCxEMg5hPdk7JUWQO+fKgoc1X3QqgnAiy2\n", - "hfhi21BpPqQ4avKaC8SNey0EEREJgcRxm6iMRUeSDKoUndB9j4Ec1UBJBqr91sKabGvq7Ev/IFeK\n", - "SQtF6Pq1hH4mZu++dmhXSwT0n26+xY7Rr0lZXbMJlzsjxyt5fv9gsEJTq0wDFS8AsWsHcgDAOJ0G\n", - "QpNalUSBN2Fq56vNmVLBRqN2bXRfY/SJjp4xsWipPymQq00jSYLoL3JAbfOZryOKfQrbR4xjzDSv\n", - "TbXbcSd2rUoUr48ktdC7e1xX1v8eQveb119cLttmOC5cothhnRNagwGYhXafXl25uXO1fbFsS1BI\n", - "EhLEXkMy5f7WUM8jigsuM1KqR/98e+f6/ZxaY6/WWmxBKHGHAgAqYpBB/XypUGwPpXTKBKwxx+ZU\n", - "ZDF8yjOSwiNSPnz48OHDhw8fTwz/IuXDhw8fPnz48PHE+GypvSxaSZhSiqOGeWHIZG8HMc6Ej4e5\n", - "kmMtBRKoBgzBwyeQgUOh1Aag+hA6TouCrIjcAO4OCOLNQTbNCoNH1dx1IGK7GiMztBqqufJEsKxq\n", - "oCgRjvRcEkDMRcHpThyrI3g4cdfQk7ZRqirjdE6vX3wpIiLVyVIwJ+g8vX37g4iI7HYG3TaDg0zz\n", - "1EiEV6NL3339xTfLtgKaIZcbg/Zvi4/uWmdKmUAd9sPB2q5LXZpvc0FaXRt33XWtxsPLRxKBZD8Z\n", - "iiydEuAp3VLCXDWhex2ifWbSoFH1/LalVAmud3/vtuWJtfXXLxws/frqm2XbF2/+hYiI/M//7r9b\n", - "th0O/9ldQ0WkbKR+m9TOcxWp2jgR9ZEXGJHi2pLuzxaGu5wy6CrXnl1t8HiKlMWGFIs1o9cTAbmG\n", - "MXfP6XOkYBJNKTZETkVKIaB+ejy4/rTdkNo7xknVPk73sQZajsKDkcbzBsT/Elo8OaXMJ6SCBtqv\n", - "mrweDqyF4/oTm4ZrSomJ6iUMmSfSpRpAPM5x/e9uLRUdYCcdGxmLGmkT3QBpxoII+KJFIUTsHpEq\n", - "25JW1hHk+oqU+rcbd569FgBwB1BiNxPbcYzxLN2Nj+iXmmdMWKkexG+ei2akvtSEVvXnRERm1Uxr\n", - "rK3XO+gs0X5lBY4C6SNpV2ipKOU//dPfiojID+9/vWy7OzqagWnb2X5ffQVaQk4aeCgUeP/B7l3d\n", - "uf7HYt+CoiFWG9cmi8hIuUPqMUYhSExppDR2fSGh58+imE0UFE3zJ0QtKSAuldN9srSxHSMAeX1p\n", - "T1KxH6HFlFB2NgKlhZgiUiJVnrBBPOaChu7d6eA+r0+UbgeVIogtzX4JOopErm2Gzjgom9jd/1fP\n", - "jO4xD2j/Nc31hbvGnHTZLmb399WlFeX8/MFpi33//Xu7bjxjnz+DGTiNvwTzykTPyeboxtXxgdJ9\n", - "SPNrYZGISH9yn18RpUI1Dc+V8skk+hPhESkfPnz48OHDh48nxmdDpGSOJY2oXBqITBDYm98EpfA5\n", - "tBXMgFV1mhOJUkttGyI74q2zJWXbCArRXat+YbYy2B9Q1nu0t9B84/ZBVlciWIg3Dfv6YJWa8Bss\n", - "PLEIkdJFn5LcQ/KQ0srtvOQSaqz+iESnKr/p2q61bt0bfBFv6LcgNhKhHDxdGbFKvLm+WT5T2YWK\n", - "EJFv3rjfhpOtIL589Y07D0I6SijrRlRqXYBQ/O47W80fQVj8BS2d3qQOTVOOe9VZyWsIxeZ1aOhX\n", - "ilVff7Ky/hFk5KKw/lRhlR4S2TIR9XoiUnrvEBEldP704/fLZy+e/1JERL7++s+XbZvIdYb/5t/8\n", - "t8u2unXn8rsffr9s64CIHicqIUYZdZrYeUZAWw4VVJxJnXyH/pSQ6nKPAghVWBcRmVHCG1Cpt5Lt\n", - "OyrASNH/Yypdn4Ec1VjxxezhiA57eLB7sgPZNCdvsAFIcBnxStv9vSHkakJBRUwSFyXQjrFxiGgR\n", - "dvR99299NMXkAsTjoTYCsBZ0DCQdkuK62H8vw6qzJ/K0qoersjkjOHUNsv2ZrAGOOfK8ghUsoTrR\n", - "rNvsnNTX7vrjWzsneGH2jDqjaCTCvJawKSdwh5mlNjB2xo7U1rHqD4kArrIHq4z6CVDas7ZTJEyL\n", - "PQi5z8h/bTmWImIhkah1QqO+NsB3MSAC+AnI6oe7D3aFWP3P6MNvXtoEnEJOJqBim7sPbr8391Qu\n", - "37kxsyVJmAiFHyPhBzMQoyQiVwoUvgyN6+t9ZmM4VoSHnlN6j6MzRNC1xeXWkI4JhO6IGPh6jQH9\n", - "VntbCAI6y+QEQN0jKkCa0Yfzgsc1xjpd6wMQc352yd61E3vXdijQ2RE6HMXunnV4dlQzIf2x2/Zx\n", - "svbPM9fup4OhWlEFqQ96dqsDQpbZM+bli1+IiEhZGEr1/dvvRETkw63rJ9uC0HfIKdzdULELUhv9\n", - "3vqkyhilgd0TAZ98Qw4oBdwWYpI4Gkmy4VPhESkfPnz48OHDh48nhn+R8uHDhw8fPnz4eGJ8ttRe\n", - "05ykY2YxUnEJsQMnVaCdDVoPAMEyZJlB7TUJDbJWRdlpJrgbh4s0fUCGsiqj3JDGiZLT2aBzVmNc\n", - "ItEu+ijUnEGiujSkI4QUXYpUQUumiLMqqpPu0QxYPs0MYlSDzDm0lFnduhRdEphmR9+46y8Ixl/D\n", - "mLQbHCmz3ts+phGGskTi+3jzTkREnm1NWykCLDqQjo8qVe+2pPcCrY79DaVRHkBipaKACOm+DPfu\n", - "piVi5a07v+ILa+sSqZ2Hg5HtW5BS58bOKU/ctaqhq4hInoOoXF0v25R3rLozqn4tIvK3//B/ueNT\n", - "yuwXX30jIudmpC+e/am71tpSpR9/dmmhjr44AA5PSCU3S5CORRqpJz2hA5R9O0pBm2ev9YkQ6ZOO\n", - "9Y6WdAwlq6D3Ms52jBZqyAN+m/GF1VCY3hiMroTqkPqJGm4T/3VRNE5jSm0s6TNS4EaaY4SOXE6G\n", - "1iNSgO1AqVicXkNiTEEEsjmde31Os3bnXkFZm7TKOh3juAZ2TOiXtB/NSar7dOZGCyNZ+m0BUnzf\n", - "Wbqhwz0eKbXYIKVyubM0hqpyrzeuDzeUHlFSOPfTCWNxpjRyh5RxSGnJHGm5iQynN+AtsHCzNk+n\n", - "RrE1aXFhTsoy2++IH0dErA8wt49kWhyhz16//7hsi6HKXoaWvosGRzLebEDOJheDGCTvE431I/rp\n", - "QEUcapbNKVBVFJ+pb8RqpM5uC0jzqN4QpzbDhWbBDYZCJVLWH5CqiyllqIbc9DWJ8T1W29ZsrGb7\n", - "qFstrhAtpQIvMNbokSTpYiRO4xT/jrX15x79frWm679w/WS9oZTyfE6LCclIuYJ+1DxREQX0m+72\n", - "RsGYMcYvr4yC8uqVO+nLS3LAQLp/ldv3vv7C0SueXTm3iXkkZX88u55TrceXWxT2fGXbCijvR2I3\n", - "QNP9GanSazHGRH1iGAf5H/77fyv/pfCIlA8fPnz48OHDxxPjsyFSp+pBevKyOQHVCCNbmaiH3bFq\n", - "6Jfu71VJJNaFtE1oBlaTCb0rDlj9Ktk2JKRJlFg32xt8DaJqS6ufOnVv1QmrPSsBMLdX4qZWQjut\n", - "sEEUXUMVl1XEFbmaeyLxgsTKMhEq3dBTCbcibLcP5kkVTyidJ0+8onTnFx8eH79GGSiT3X/48ScR\n", - "EXnx/Otl282DQ124JP724AiAGZV/pyBIPrsylOqhVWKnfS/EymqD1UpC9+RY6arO9lHmrvy5TQwl\n", - "qUC2Hycq6wZKwHIOSsYfqXa4hspuV7k2ZCHunz84kvP/+n/+T8u2P/ulQ5/WJXmIoQDgDSQnREQO\n", - "B3cvkpFJrCAK08pxjetpVu6ziBBJhQYYfRqBxJQl9Wv0nY6/p6gHkaIDeBbGLDeN5W6MtgupYKBc\n", - "u1VnSOCLqoLv7w3VW0PCgNWpc/h1sSdc0z7g+FRkAXRAzzwghe0RZdqblW37+aM77o7KlUf1KyP5\n", - "kQoq60w2viflaw2VTBhRYt4SIq1r+IEI+Ipgsdp7gHEdUpl6qD6ddD0zytrvb41YrertO/K66zHv\n", - "RdiWlbb6H4HOJYQ0qU8giZjL6egI2Ow1mKqzApGIG8ytu0uTQokKqKfDL5THuqIFCZHYI4znmY1S\n", - "IRkQEXLWAqX49U/fLdu+fed8LNvR+tOzF+66Q5DDw4lQ7ZM733uSpFjQHyIxRyhUykgBPMF1zCRx\n", - "M0GmIi2oUCdUtXegigOhv1AWZ//VbA3CNhUbBYPrn2FAzw6g6CN5NxbwsEvOED7IGeAec79KcJ5F\n", - "YfNaCSmINT1/EiDdDT0n9nuHdPbP2afUnXua0TyBrBBZPEoMhDVA9iUm9GmVumd2nlO7Yv79+iV7\n", - "x+KYJNQQYsyGo83xF1CtX5HNR9uo7A+eq1TEpahiS5IwAqkJVvYvkJ3ISH4h1qKkkDElzEkMBfKc\n", - "+YnwiJQPHz58+PDhw8cTw79I+fDhw4cPHz58PDE+W2qvHTuZhYw6ZwcjP9yToS1gv56UWAfo4syk\n", - "u6KaLgERUDWjMRIsrzCmkg5DIl2mqtnBWlBKcqeUQQMtjiC181T4kN9KVQGcZalTpCCjwv17QanI\n", - "g+KepLp6Dy2qrifIGAgjI5GqwDx2RnZO1UgzMAh4UQpGWiJJieDXqRI8a4e4f3/3wz8u2zZIaYVk\n", - "/HqqbrE/S4vEoYPnS843rHCedI0HaKvs8NmW8kiHHkTE9Ztl24tXTj13IAJufXLX3dRG7J1AKCzz\n", - "i2WbavWkpLcVRO43AeD7jooDchhzPpCO0f/xH3/nzuOMMOnSIjGZXG4voUHzYCkLTQGGpE8yIS2x\n", - "Ld11dYOp+UbQzCopY9Kg6bj/H5AWnYioHWUgdhO03yGlVpN6+aipDaQCRiLnqqNARJphqo/FkPnd\n", - "nSOU7iiNliHNsN9bOi2DBk9A55mCyB9D44rH8Lp039/Xpk8TQauqqUzZvMc01lEKfsAE0PaWWjse\n", - "Xf8sckoZ9CC551Axp1SUEs/DiOcVJdvathiaRs8u7Ppz1S/jtBRSdhdELB9ad059a2MnhaL/iLku\n", - "JA0bNR6OiILQglges/EttLVOD9ZOMdo2jS2NV5aYE4mAr3pUeqyaNLtipH4jSs9PILmHifV/5ULP\n", - "Rzv+x/eub3/300/Ltu/eOu21MLV7HKdagODOo6qtrY9wIIgotZshtRNQYUlSunN/+cwKcNbQKiJe\n", - "t+SFO+fNpY1nLYqYkZ6aqLDgcuu+p9p5IiIZ5pOM7pMqn1eVpSAf9m4uqKk/p7gO7pMVTMq12Cmj\n", - "9Liqgq/Xdvw8VX04KnZSRXV6/nQoGmhbeu6O7t5FRJ8oQDwvSuIgYD8DqCchjdOlAIHPU2keXJMh\n", - "quNFautKX6DUWYa5oCBz9TUuTSk7XJSj4yO/sDbMoXsV8BuO6q0R3UGvg1P1OhQCKiiIkj+MOXlE\n", - "yocPHz58+PDh44nx2RCpSSZJSB1ZVzpta0S4hwf3d1fbqi7QN2wqIVYCJi00RLA64zfSCZer5ZIB\n", - "lbUmWpNKaIF6YnGpd4i36YiUXRO8EQ+0+pzBKF4RiVFLhkso0KaE/qTwhos6lgtw13XkctXOrVYi\n", - "8nCaA0UV7K26qRxKM4WkFA+0Qd++1xsmTOM1nN7WcxA1Z0IQfvPjr7CNVrAD5BcyWs2D2KnkTBFb\n", - "YTAS2ffufh7VXiq1VcAlVjXPrwyRen3pkJubwry5IKwrBa0LAOZJOtqqSrvWamvXPQ9uxZjBY6+q\n", - "aAkF9GO7spXWXe3u048//HbZFsauJPdia15Tl6X7zV1FKsq47raxkuD0EqW2o1thZqUhaGHoVq4z\n", - "EdYTIB0j9bUtZB3qxla/DciZIyOX6P+no11ji/6cF+58L4jYrB5vTJhuQPINSEJBuciXl6ZA/+OP\n", - "3+Iz66cXWPUPhJIlQIljyCTkBam4A3WLuYgDl70/GkpSA7FuKuvrUD+RKOUxgQ5AJNK6Q5sB4Zno\n", - "uhSJYK/PT8UFiNpahi4iMnWu7e7vDZEpIAWQkbJ9dUCZNqGOMVbCqvCdr20OiTBndhU5AASKFtj1\n", - "hxgL/Wgo7V4cmlMUdp7qWVkSAff+6Bq5g6xBTIrlWqgTsdIz0ISACoBmkIGbB0NYfwIixb/9BdwD\n", - "WrF2UiBApWZOkzlbbF5iDiNEVO/PTFUcKyhmX+wMJdRnR0kOCOuN+96arl9RUZXJiAmtyIFqsdp9\n", - "hvG3JgJ4DBSXnQWur10/2RNKt0KfyQh90d6myFSS2rWqU0DIhSW4TzMjKOj3EWMlOJVTa31C5REy\n", - "QhNL7aeklB7ASWHAc5eV0HWccK2BSggouioiEsChgewXF4kRlgSZ1DuQMkYxCPdZuX10rcEiyfEY\n", - "uZ1pH+qX19I8qWAjz3GJ7ocV6P/wFOARKR8+fPjw4cOHj6eGf5Hy4cOHDx8+fPh4Yny+1N4wyYpU\n", - "bwdRIq59px9AGCOT0wGE0vFMM+axCbFC9Ky3kqqmCGD8nnRv1LS2IHh6u3InMxMUPTdID4wGbfbQ\n", - "nhkD0rECZF5sXtrxAd/mgMcbSmNmgJOz2NIez6BPcrg1yF5E04ikWAsdqZ5VbJHTGWeDcRUqLwFP\n", - "5yvWvYHJqTDZ2p3vn/7JXy/bVEfkd28ttdYgy5CTsnCk7c9kexAqZyLWKme2gpFzvrHvX2xVM8VS\n", - "awMU2/uKdE86hbZt2+WVI/Syts2udND6QG2iBPEI9zOkdGeD/VWNEdtzEFrH3qDwm48utZlHrM7r\n", - "rqMg0+gBxPostvRRB22lWVRPxlJ7XQ8SMaWbE0Ds82h9ooQS825txNqba3eNH452rRv0nYkI/QmU\n", - "6hXaj2gA6sjpx8d6KgmNie3GpUrub41Yrlo4q5WNpwBjLCe18xRpESV0JyReE0HjK6D08Auk0Xoa\n", - "/wcUGXQ9KbYjt8tpkQEE1cPhdtkWqrlxj7HI+Yl/luLhj7UQQUSkQNHG8USE6VhTdjQnYEwweT/S\n", - "og2aT9RcOFTdO05jgKuQ59auDcjL00B9onT3s++ZggBzYRp/qpUzdDYXlejjAXIwdPdlQlo2pH4d\n", - "IC02kQNFiN4zUVosBAH4amt9PAm+ERGRrqf0Hcb9Cmnu+mjn1mjhEVELDujjrGWv5G1Oy6kGWJpa\n", - "++fQu0rovquRdJzov9Yn9Vuc7k1BLE85PYfPQ6KAXO7cdW1Y7R3PgozI8z0KHlaYf7m/KAF+pPlf\n", - "DY8TIpsnqpVIRRE9KBplaKniLm5wfOunqscVky7gspsGf1ABVIK+EHJ+emkf0pZC8czQcgGGu59M\n", - "lFc1fm5j/VzbibXNdLzw0B0XvSlrp2kp0CD6Rnh+biI2TmOSoI95558Ij0j58OHDhw8fPnw8MT4f\n", - "ItUPMtGqMgUReyZUJVLVX3qDr2e3Sm9YsRmox0iy1NP8uKxRdHUID53NpamoZ3gLzkgxWktI+ZzG\n", - "DjIJxJgbgQipb5mIyIzS3aMQAVVLy1XCgeG3Qd+CjQi3Qt37+IGYbthFQqufJIJPXkteWw3OnT3B\n", - "0BSdmg6GtjLIcij2Jnas7YVbEf7Lv/g3yzZVYt7T6vvbO0ee7FtS5wVBNSeZhI2uogkluL5xvlsq\n", - "zcCq36WgDY8m63ACsf7th3fLtv7gvheQirESCtdXdo+1nHpkj0eQJlOsqp5dkecZFIg/3tP3gRIF\n", - "hOYN2MepMuRqs4ayd2r3f9AiBxp1TePaLo5BgB3t+FfbPxERkZvDr5Zt0QyyK6101UOKFePvQ7fC\n", - "TwMqCcfnFxd2Tu0JRGGgvmdEcKzIzrzZ1q49545QUqwcb+/snmxA4r26sFL7unV9Jjlb6bo2SRIl\n", - "nZNfmsov0OpTUdLN2hCZI/r9w8HGTg/0gcvPUyAMPRWZqBegInEsNaD805l90LAyzYkAr+T12xsj\n", - "Vqs/YUx9vYGyd89zFzrDHNLKGcv/CfeYybEF9sfjP8K964lsPuCeXV5ZAYAW8rCf6Rpee+xTp+Xx\n", - "qrCRxey5hnFKKFkI/8upY6QZaBa5DWxRsl9TQc0EGYFnl1fLthcvHIp/sXPb9jeGIGpfGwl/OoKU\n", - "zXNdAISBi5e0L4xEAD/cuz55T9IxK5yn3sOyPCtjEhFDYUSsiEDHoYjIvcp+BNx3ocBN7gU63lg9\n", - "P9YsyiL3b8ftgbpWlSF4Uagq3uTsMD6WblACfJqSe8EEJJoKvwKMk4RkP3rsL0RfUxkSEUPuztAv\n", - "zLEt3WvRAimCb7Jl7qJJUZUbmOGt8gsYOympveu1jmd+hf+sDYUI6zR0F99Fuk863ZDCg0yebO7D\n", - "hw8fPnz48PHHCf8i5cOHDx8+fPjw8cT4fKm9rpeRVKRnQIYTKSuvgcF1BE+uoNXBcHewpPEMfysA\n", - "2WcpE6qhQQLTToYH9agtGUoO0BRqSe14VlVoOvdRCeKk7RSAovnQmyp2C+i7UoIhQ+ZIGQmRndvx\n", - "HudrKbPqCFV2IluukI5gZd19AM0MVpGd9HpUM8cOr2m+mExrL65cau/LV79cts1IH1xtLWXw29Ep\n", - "nyucLyIyq+EmFQqMgNt7gtbr2v09LIbGBgUXF+7vmztTQt43zvD0vrM00jw7+L4YTR9GAJknn9BW\n", - "Ckmldh7cPXnxzPWrTWZEzDBy+31/Y+e0gsTuOiR1bJhlDhORrSfcY0oB5Gq+21k7qeHw6eR+W+SU\n", - "ioXG0nbzlV0DvscjN5g1jWvH0tQzK2bHgNGL3H6ciRY5oABBLBWoqYB1ScbDSOkyr/TjjUuLrFbW\n", - "/praCyg9EOBYMfV7TeUpKfiM643fplSwMCH1zPo0JdJsZWmprQp6VzxPqFbMOD5OGRTQz0o4Zafn\n", - "QQNFTy+n9NgEojRnIjSNVJAuVoa5iwnws2paEc1hxr1TEnHbWRonAbUgiq2tNQWR0bmX0IpiHa83\n", - "L5ze2WpnabQAOncB17PohWC88PyjekdclDBpuoeKPSYIecWfImDTnLQCaT8nbSulUhyRHuuJiK8k\n", - "+i0pgatWFKcblXhdN5baOxxcGl31mUREWnzO27QTKlGZ9QE1jcYkdiW2pzTW0/hcd0nEUl+cWtSm\n", - "7okqogUC2l7T/PizmIqolL7CxVPBFJ19JmJ6SwXltpRQPZ0VVCCNRs/dRaNMVb9pAoj0ukKa10B3\n", - "4AKwONAxTmk0/JbbTmMcWW/Q7U/T8nytSqzn/erYCZnao9qGn2gTLigJP/G90JPNffjw4cOHDx8+\n", - "/jjx2RCppp4kX7GvHsiupDqc4o2wY3nmxdeHyorlsQJtshDm7KczJBampayXVjBYYTW1bXu4cauU\n", - "e1JRVqSrIPQpUvJeRmrfeIOvJ/vtae/KdNUvaUVEZF1gTETYi1CGmq+oXLQGYZmUbaNllUhv2rqa\n", - "FG4AqCJjxTdxXTN84AJaaT67dCvYNSEN93u3gptolVaqAjqtNHstNaXDx/Dpq6hNmgw+XYNrk6E3\n", - "9OO4d/u73xrSc2xcGw4jeYiBdzyQKnWewjuOtnWT+00w2TEOkB9IQnduGV3/EIHYmBGqougIr8iA\n", - "5szEbByAvnVEgEzweU8IR9+qJ51rk+c7WhkOiqBa+8dY9c8DoZmtO6eOrjULHcn75frVsm0LZKkk\n", - "NG2CenEOUrqWcru/3c3bP3xcthUYUPcHa/+r589xLXZKumJuOjsnRSezjI4Pomgn6uFHq1XRMmjb\n", - "h/6dnKlNK2HVpB7U54ClU9pWVZTtnmyAeumY3KyoNFyJsoQ0qaPARIUlKmOyIv81vf6YJyAQZZnQ\n", - "HwNFjogAnChiBiJ6QIUF1cFdY0oFA9GyIrdDKRJQkExCDESs2FoBxvwpYq3eSKAprBif4V7PvNAH\n", - "qjtKlSLqAAAgAElEQVRTFcXYuHPeUz8ZR1WKt9+WpWtvLvG/v3djcilXP2v/x2v/AOOqKMnrcueu\n", - "cUv+j6rePnIBDk7m4cHmGPUWVESCMx16Loxgffzosg4sYaCoxkRjfUSfYeRMJTmYqK1+sto3mHSt\n", - "13AGkASPj6XoDCM9hcopfOJYA3nXqQQJt7Qq5Suhm6+hgdfiHBGqunC4yYED/7aEEi4oHZHSA3mM\n", - "/igqF8R6T+jsgFwFdF2d9uGePDE/IQmhf7JPoN67YX6czfkvhUekfPjw4cOHDx8+nhifDZHqZDzL\n", - "/Qa6CqO3QF2kTGIrMs2b0sJ12cZcKhVsY1+naRHpQrkkcSVaCPINZPnUPeB7NZUGwwsuXpNIGvYT\n", - "EMKjPlXzQCWh6n49ogw3I6FFrP6pqlW2L9wbdEmlqfMapfa0+NYVdkrih2nu+E19bb5u2sYqCMrt\n", - "3zbK6bFjvbr6Uv5/9t6s15bsrBL9YkWsvtvt2ft0mSczT7ZON2kKU6qLRFkiLV3pykKyZF2QkCX4\n", - "AwgJjPzkN9sPCOGryxtClniBJ+AFZHElQEKUTZVNYZw2dqYz8/TN7lffxn2YY8Q3Vq7tdLGr8MHU\n", - "/F7OPrHWimbGnDNijjG+8ZmZpdJNjvphf8Opa79aSPV//Pig2JblME4TM03qYeqymt5KAnKSz7Ba\n", - "WPjKZJaE1Rd1VGZmk1FIhU6lJt+CKI2s3ItagCv+iuEGjcUmYj4N7X7rQUBdFqKHoyVHRVa6WaGN\n", - "EU0HbvwKHz9nDq/bGSRLaJQETe1shr83q1jhDqX+5Dj03frSEZw60pVnZbUpoG7O+1p3i+NJNYIw\n", - "UxSYsDcY49xw3VLxfQSnVXE/sDPoVir1dY1Mkqn2IezntCf9BFoS1QhRazEFqqPoZzFOJTWcVgQK\n", - "9FTRrxqSfp4VprdaOy+MuzwXbSZ1gzi+6ia5+k4E6XWgVVbkWGFv7jjSk8L+o9dzpIOWFWVBn4gS\n", - "VMp+j4miVrDOXZrWhgz7mMoKvpZReyJaJqAjFbmfFeiQFoI+0HQxL61rZIjSq4CKZ76sab+Cpmbg\n", - "3yM6WxhomutQKmK6ShsJNU6cAjlk38gE/R9D86YIEpGYutTLI9JUFePUOQ1LpYYa0dFOR+oZYhxT\n", - "X6UI2hKo4mjkqEq/P8A+HP1i3TdFk4jOlGX883uKeKTpqploSY0h0dd1DFHLOF+x1Qj/ls7RIy3k\n", - "e0Ogb4r6EdlJZD7h+RHBmco8SYR1kYqZM9iWspqZUkMlliwpjpFIO7F/qiVEjj5WJ0rnp1s8/4tr\n", - "kfNVk1LaFCn6xnuyYgiKi1Qz24navZwTEZGKESNGjBgxYsS4YMQXqRgxYsSIESNGjAvGE6P26puL\n", - "FYEja8NVxcWcoseFOMGewh24Ji6urKc3GjtkN4DYetYXwRjr+QEqzioO3VGAVxMocgYIfjwWB3Zw\n", - "imkq9fdwfovlqjzPzAoX8xCo04aPBlIbiwK7qoguK7AiaLfEHRfXPa4IZI6f1GsOT48nYePRgTv2\n", - "lkoU4DI1Wa5hAcGqiPhKAFB74th9926wIjg+c/sBA/S8EAH6CLW7pkLV0gF3q+p0F2HmEe51PpE6\n", - "cKDRFrmnsLPG2zJxGpP3VQWgw3ngPjOhanI426eSTr9RDtQirQEaFYfnm6AKykIPLIsUb3HHhqCz\n", - "nCllRQGwiB0BaWcl398AafrLCt2ZfR+VBSw8Ft4nWKZusFT7D4htJSW8gXGUiXieda1GE7GEMPxN\n", - "+xExcc5xnqIXL1K3E6UxaT+ingj4fCx1tTa77nLOIKVDeH4p6eK0q5jPnUZhu5YE3E9LrGunNinh\n", - "fo5GTgHRdkMdoAuxLRIwToQyoqA1EyqGniGNmt/Xdjv0xbMzHyctuGOLrtWyfD3VeoZ7Us+EWmKt\n", - "sTnrBXp/yUCFLaT/zWEPsCFCeR5hNJZab6jJWCqr2B9jXEThE1DpGfZSkWs1Uu9NHye06Vge3Cs2\n", - "3X8QKN1TocDodr2Q65+gLypVw6QVUloz4ZZJqc1lXk0wZ+ZCWT14EM5lxWoCx1W6bzjgWPBrpGv4\n", - "GYT9Sg+RiqyKhQDpxl7P9Rb9PsTe0nd4H9WSoLD/0GOAbqTbvwq7OV9m6ToVVcqVbkYFBvMg3bVK\n", - "WbHag1jSgNKsyXzi42SOc/IgpUbLAzOzei383e16XcUW5qRU2rrfD/IBdWqn5ESrB9TQPkxO0Tac\n", - "YO7QcZUWiQJCy2O/A6nKQamCCtA5n6vFw/tLzSMiFSNGjBgxYsSIceF4YohUeWNpiQp7IU6el2VV\n", - "BaPL7qa/GR4cYYUjKdENvDnmYtzGRaym6ZdY9RuIVLPlqwUaoqWiYq3WwrZW4iuYEk39lop0QdhW\n", - "9eZs4s++lBriMRIcY7oitofoVVKjz2A1kC79zXxWwWqhIWJ31JCrSVp7HcaFo4GvCCtMT8Xbfa5p\n", - "2KzXVPJjPToJqFNJzP8ePwyI1FhSWIv1SSp2FkA6DnpeJ2sbYsyK7C/D6ms4CCviNPHjb0CIma1U\n", - "P4f5ZuorHaZVV6u+SqbYsVFx9IviTbUzSIFsNZthf01JF+fKeTqTNgRyUxNhM5GOmbR1uxaOn4hQ\n", - "toFzSuX41PaPp7DrEPPDMVbfJb1+oj9iyJfPWQfL9zsZBaRjVpKVe0LjTjXTg6AVu9O2LqwbZGWW\n", - "VUL7NHS1ChNbFdv2escr5xuOT4RRxN5YYVP/OxW0jKjTSr1IohVqlofVpDSJzSAezwRhnU9pdOnf\n", - "S3AMJqVUa5IGTYGt3EOa3o6GgnTBkqMsFeQTzE/5TOr/cV27lHuH05sJ6sZ+YhXWH/R5imbCuo8S\n", - "hd0iQN9q7+L7fj3zIWod7rqZLk+5oYaYU6KjRCZ8TCQCzhXb0iCyn5W9TY774bfv3L/t+8Xlt9o+\n", - "x1fGmItW0vlx34u6eoI+AmEuCdJcR91FdSkYjcM1TAciyifCIW03gwdMIpgCBeDtPOz3PPPJmqD/\n", - "NfQZis7NzJZLoonrps8zNXhmToim2lMoXyQneb+idUAqVhNEsxTB4XnSmDacE+wnVpTlfO44wzEB\n", - "KqymlymOUdS/lME2wlgbjRyRWxC5lUSdxRxjR0xyHz9+ZGZmxyeO5nIMbmz4HF8YazMBZUXEH/5V\n", - "k16iyFVhXSbTcNyZXGtaMEwyntCRtE6m/n1eREQqRowYMWLEiBHjghFfpGLEiBEjRowYMS4YT4za\n", - "S0olM/WdqAa6ZyYGUQt4C9W6Dk/v7wXI9NEdqY2E37TEKXyEWnczpQUAN2aAjksLP1YHwuJUvXAA\n", - "Hy/Fi4Z16rT+XgkeLGJsXtBIzY5DhlOodsejsI+awLMT1nUSeeAIddiyxI/Voi+TnCch7Zl4MNFb\n", - "51J317eB2uRpZhURtqMNr+7790uAdg8e3fJzGsHtuO+QaYL6eNtt/y205tbKGrINsGxDfHTyAJFf\n", - "bcFjqeKQOaHduiQALHBOZRWR56SAzL9n9CCSpATWyTKFaXEvQFmpYJztmYjvCeuZVUUcegRXcopp\n", - "zcwOh4HSbLb8+lnrrSQ18TIK1QuMX2g01uuaie8Jz1poWcLS6i1Ed+ZcfGRqhUBWaiLSKyldnwoo\n", - "lK/V3R9pMQn0xVSOv9EN92wm1uZHh4HaazSdAiwEnWKLPRr1cSyKWdfr8JXk/pNtVBE/e7SKstkm\n", - "i/nI3hvqos3fkBbZEHpyjDqF6hhNz5zx2GmMUT/QElf3rhbbTkBVNMRvifrwqmyrkDIRWQLrnqW4\n", - "dzMR4M9nEOJKUg5FwUsRZS8hwM0kAaZcCzR3onXNCid7mQuSNs4TNI7Mq/SFyyXZI8d6vNz0fpLg\n", - "nLTW3hz9M9X6m2haHc/VagO/xf0XGqmBvqD3P0HtTKUHKZ9QfyLWZNR5IlmwdqFcP9qni+QI9RDi\n", - "IVScPJnQsd+vtXKOsHwCT62BCKtnI3qbiaAedRrpWaceU4XY2i+hSCzZ2PT2b3fCuY8GfqwJ/PNy\n", - "oaA5Z6gA/ezsDNu83/F6mu3Wyu/MfJyoZ1i5Ej7v9V3YPR2vf4/JJurjRRpNqTq2wRz9ekWwz3tt\n", - "HgnaU9suRwfpdH2Ml+htJRIECvVN+mSW+hx0XkREKkaMGDFixIgR44LxxBCpYb9UOAebmVWRmr8Q\n", - "Iewcq9SWuJNf3Q8oxcljF2cOsThst/239QbEZnqFU6T9s+KzIAiVJlIeBSVLiFzIm/kMb8T6Bl+n\n", - "/YC8E9fwBlsqSZ0wfJ7D9XoykrzyxL9VRMrabHIJQMeaDX+D72CludH29PKtVlidvHz92WJbscIv\n", - "sYaZH2sJQWWrJRXk4d4+EQf40rXwebcqKwgI25tVX7mW4MmgtevSLHyv03ERIc+lqMOW+bs9V5Dl\n", - "iqxq56z+Le2KtFtN4Z0BkRyKJUZRETz3TkFB+YL1ouReF+64IgAvIxVc03XHRAJlWUIRt6If+Tni\n", - "ad4DikL1MwqqVWzKum4arQbE+1prrVg6+7YJUQ+t/1X8QRdvsWvAKnQu/aSEBJDpxBEZpj8fHLgl\n", - "RhPi5ZKgD9yNVhTg6rfZDP0kP6c2l9aQZPso+kLrkJI0QPWcavJELFQ42mp38X0iQ4LW5etC1PE4\n", - "3PeJiOLpYq73ibX7tE5gC6v5RIpcFjYqIsAnAsMEkJmk+pfQX8eSws3vVURsXCBSspLmeeZ1QZMz\n", - "XH/N0eSsKAoQ/khkXBv2sVIPjeJkqRhAke/lS17rsT+gi7bMO+iLivAwKYK2Hquu0rgueXSVYA9S\n", - "aUmyDZMhpK/TTmAkNin8OFmsoz5EvTQBg3PCVOafpa07lrfbSKyRfjjAcVUUzmsbiSs36xMOTwKq\n", - "q2gZ3dtbgvRmQG5KMneyOZttRw4pop8tvD35DK5KUkIbyQCJZGWk70FOx9L/mSAyUUQqC9eTyX0d\n", - "rZgmhCjc6/UaURO0WpVxj/tO1/NE2ByK95UlYu/sdrf8Gmh7pNYtOCetdjEDc6TI3WIea+3FiBEj\n", - "RowYMWL8q0R8kYoRI0aMGDFixLhgPDFqb3C6tJlU+a0sA2SeCxXWy4Ngs335SrGtVQ+w3LUbTmPd\n", - "eit8b750eLIBN/C5wIkNCCUrQOz0M0J75ZpAhhQbzwTuB1Wk2yja1gKReQGtr4t9ZzPA8gInV1Dc\n", - "eDR2ainbgBN3U+BpQLuXO88U2/a2r5uZ2XbXPZMa8DmpimCvDrqFxV2V2itRbKc9ApvG4k68UQ73\n", - "6XJLnY3xdXF7Z9vVxcejgvZvVKW4aIn/hJ0sRFjLHdfFs4lnrLTwaBjOb6zUDmjZXGDsJeiT5Vwh\n", - "a1AwLF47FeoM7dOQYqgL0MMKY7O4pkL2bfinqN8R6WAtmkk6gF5Y/b5TZuPZepHNFAJcdTGnsF69\n", - "ZQrvGxHqVsoU2/r1V3ht2FQS36UFfc9ScUKGeDuRcXp6FvqEehH1IXLd3vRxSlf6wdBdtDkm6ugT\n", - "U6HbKbZXd3p6wSiPSeG9UmuktirqbI3xWSqr30zok2NQq+OJCHFxv1QwPitEtn78TSR06H1aoN81\n", - "1ZeqRPd4pfFAn4pX2Qz7oShdqU1SajW5Ll63OnAnLG4rY3KJBBVRL9gCySOZiNdLHG/0dMuVRsUm\n", - "oT1moKweP/AC1dOiuLK3SQlU0ULoTor9m0LLkYOlEHnacxopxxx/duYVGxag2a5fu15s45yhiQJT\n", - "C9eqxdr552y+fk6c907P3B+LY10LBJdxjy9f9edUDQXkNSml8HGSPtG0QPdOxu6tRxotKWQP3tdY\n", - "8LkqBeprcNFfyLWeHYdnotJ97EdLccXnDa025dnZhgeeFjwuEh/WpS0diPKzktPN/KU8/gpPLXV7\n", - "534mQl/PZiwWLfektIr5LEbS/yB3GYm3oY4FBun+vtDi42HoE7mM5yxjEXjfppKf8yIiUjFixIgR\n", - "I0aMGBeMJ4ZIVaxudXHiHsPZmim3ZmZNOFUPTkXEuB3exK/v+Up3jlVkb+hvpEsssaeycmhDvNbB\n", - "2/dCkkiPT8KqKhWUKIWIepL78etwB6+3fKU3x0prIDYJiyKtXuoF4fiNrW2cm7+FD/th1dXsSP27\n", - "8hLbfB/Xtm+Ef7duFNt2t4NTcVlSjbmIzWX1wTf9pIHvrTj2Fr/066LVgKwGyvWw+qmLiHI64UrP\n", - "r79WpiuzuL1jlahpqrQbWLopQ/EZ64DpyojCT7WuSLE6a9RVxBnOqSIiyiVU+zNp9wFSXZnOqyJm\n", - "ojMqROS5ZCs1tGDTIce3RK8S+4N4dV1y6VtHgv71RwHVaTZ9tdrG3yqALlbTK0JxoK/S/4hIaXsW\n", - "1hF0kVZUByt4RUQyFPvLp9qGYezOU0V6wn1qNtbtBKpSPYCICRHGiqSQ87q0rxGlWEq6MjuUXhdr\n", - "92mVrApQr1bL08TP4EadJKHddQydQOy7IenSzDsopb7fHuwPtsSJeTgIfWZTkJYBhPVbUn9sTJGx\n", - "oPMl1DgkwqVi5zmQXr3/7ON1QU4plC43vO+U2kF4W6r78Zn2vchF0A6UhH1iBWkHWrSSag70l4kD\n", - "ZmaHp+Hv0sKv6z6qIihK3kR9wMUKIgSXf8whdUE6KUDvSmIN7UFSSWwpECNBn+ZAWNUpfjIh+uHf\n", - "I7KcVzH/y/jvn4PINDqhvdTtn3Ute8fHxbYCaZTr5xyj00WrFdqEDvCKrvA8M/0BTr1/6u1P5FQt\n", - "GXjd6nSSACVrqMUIE3DE4oSJMku2tTwnakC969vOiBDhX60rCKRH5inON4qSn50GxKh35ug852zW\n", - "7qsJqlfDXKzMAdtV6zoOca+n0teWsC7KFLmH7URd2u5HRUSkYsSIESNGjBgxLhjxRSpGjBgxYsSI\n", - "EeOC8cSovWpaWYHs58MAt7XE+KkCqHyRixBzFt79GgKPXr2+b2Zmb9+9V2yj34rNxCkczqo72wEC\n", - "bJjQUyhoupCCijTPbXTEiRt+U7l4Ec2XKKRZcQFgqx62dQRa78JbpFYPkO1crmtML4yxQ8asKDoX\n", - "avHKZvCFagndQKueeSoFmgHZl8SzZoFj9IbwsxIvlBRwZk2ugS1XFyEqi7xOJ94mhKxrJaFgAAuX\n", - "hMiiK7mi0oR7HQIWJ+iM1J6+79P4Rag9iGgrQi3xqCu0YCN8Ppm4Z8sQAkUWzazXhHaoUgjq7U/K\n", - "ainXRSh8KTDyDDSiesAQ0lYBOotf87Ou3NdmB27rMk7ojj4Y+DXQW0qLwW5uBBpHacES2nZFFE0B\n", - "bOEEvC7EVdqDcP9YvHjoc1QVWswdw0UUPw+/UW8d9skFKCstEEwbG/VwIVVMkaiZiHOln7C47XLh\n", - "Y6wGaq+SiUsx7+ci/HYgTtB0J1faYasDIa5QhizgykLNZmZt0OeZyAdGpOqERpijWLGL6M3GIzg1\n", - "g26pCrU/IRUo/DDpEXWbbqBodrUpxYiRgKKu9OU2fJ6mLsDN4ZWV1EjxiYg9Xx9/Gejj3Ssutm7A\n", - "If7RXa+KwFM+PHSh+P37QaCuCSUVJO8UVJTMF5xD06r2tfD9o5NH/kUcjH5OGlpwlxSd+mL14cbN\n", - "fq8JC1c6l81stWg9JRLqAXcEL6hRz/tTVojItSoFqhJM/N4tikQJehF6v+Y5Tc/xk5vJ/XfPNvHb\n", - "wxjvnfq9ppQhWxGA0+1c6WbMXUXbeQfcgbREVBE2F/G4HwvPhFSlGvB7VPoW45gUp5kXRubc0Wj4\n", - "c6rB6hCp+k4xe0bmExacFgqQ/ThJdDzzWShedDIHnhcRkYoRI0aMGDFixLhgPDFEKitllkpK4RLi\n", - "sEomwtoGU6L9TXMAe4C5LCrrUIDud12AeHAQap0tRZRMiGk4DG+ftYa/cW5DPL6o+AqGK5dSWRAZ\n", - "1KbSlOy0xLpS/lZNEbU6LNPtl2/TWktojtT8haR/n/bCivjw9HGxjW/JJXGdZdprMvW36gX2p2Jv\n", - "rvqXWC3oO3YthzVCJs7mWM02G1IvDyJKPX5i4XOtCVbiSl9W84NR+K2u8EpErs5xOJ4CrUhEiMtQ\n", - "F2dWnpqKAJoC0bNez94bKsolYtOBw3VaFWd1oInVzPfLtO6+OJsTnJhrqjeQtrk4pbsAXhAm/M3r\n", - "SSRdeQ4rhuVSEwbgLDxWZ22IPcVtvtkI16M2CfNCKLteO6wQuwsiM8ZYywXVKUTBJXEiBtJRq62j\n", - "r/Olt12O5IGhoFktrERZp1DroFEoOxQXZVq2q2B3PAifl6X+ZBMO/Wcjv9ZWK4y7nlQUGB2H1PYM\n", - "aKYiGGUgArqqX0KUrWhuA5YpKkCuwVE6F+SqWg37U7Hrgqn+cz/PSoK2w3G1XlwF97Mk45qIXCqr\n", - "72LVn8nquxYQ/jQXS4hluBeJoFSzMwrFMdYb7g7NunolFfsD6bt84wX/HsTBU6lJeDg6MLNVO5XJ\n", - "PKAjtZJP6DPMXWcnPVyXz/8l9Lvx0UGxjUiwInK0FXlKKjsMUCdSlfJl7K9Zd4RjOAjHnQAl6nQ8\n", - "OYHjRJMyiNLOJP2eFQ2qMtcRaVGLE6I0ihITdeY8PR6tJ9vMpL+MYN1RLkufADpTFqyEKJqK5/lb\n", - "fU4keLY1ZN7n30TdFOknwqN17TgW1OpjXgjLxU6jQLq07mu4/r1dd8Wn7QsTENSJvbCVkGfSlNco\n", - "95r2IxUR1vOdIJV5lwi0WsFY8v6YU0SkYsSIESNGjBgxLhjxRSpGjBgxYsSIEeOC8cSovclksALZ\n", - "VgDtLWdSZHMJL4ipuFj3UFzVHO6vQViZCYxdhwfVZHhUbGuUA/XQygJk2Grs+GcpoHgpmkwPnky8\n", - "eBJ4lag7Lh2bV4XFcFafz9e2kVpqthxOLuBp8aKaQ7A8WhGgh3+UxiLMvCq2RcHT2brobwbxup4b\n", - "i3bOqwKxT8LBRkrj4RqUnuPfc6EHuG+Fe0npKLVFUTApPT0nNrGWiyyoRaFWSVnOF+vUnsLI3HdN\n", - "rjHP6V9EwbK4vfPIqnadL1d+Z+YC9FzIUtIM9L3Rz1dE6YDvCWcrPTEB7K7i/Ol8/d6V4RivMDZp\n", - "JPWg4bGUbiVEz+Ouairhti70KJuiJC7qbRShLslvSRkk5m1dySjs9O+RPiFUP5M+VKlwTDgVWKYT\n", - "vVAGmTGxQQqO4xjqtk5/oKMDd6o+OArC5xHE68/fvOnfRxv2e+7Pk1lo/62uUCEsmqz1xjG3JSI2\n", - "J6Wg1AoLqW5IVQIWTWVjj8YD+f56MeYaJBAlGVcNUNa50D0GijYRv6UEIvfTBz5PDgZBUtDsh/Zq\n", - "OsNipVaYM7WbFLdT6Q9IBK7ffLnYdO/eHTMza0lVhBZcuVUCwXs3RFKAzmFMrJBuUrS/Ujb8niYP\n", - "sDC0Fv6eY3xwrJk5LTcBVTcWyu7wMFCKOoeRFtOx02yQ7lqv1KDJG+Mx5Q4yJzVAs2Pez2W+YKKK\n", - "UmYUx6tnE/tfRea6ZpPPSe8TnW6gLdXHa2nvTQDyqDeYbOHB7y1FlsH2SWUb5ywt+M55X59dc0gP\n", - "SqZzd2iLFJ0jl2ug75g+azI8Y5OSXgN9rKT/I8lq1faP85Ru/J8Qm9++fds+/vGP2wc+8AF79dVX\n", - "7ctf/rKZmR0dHdnrr79uL7zwgn3iE58oslvMzL7whS/Y888/by+99JJ99atffd+Dx4gRI0aMGDFi\n", - "/CTH+yJS5XLZfud3fsc+8pGPWL/ft5/6qZ+y119/3f7gD/7AXn/9dfvN3/xN+9KXvmRf/OIX7Ytf\n", - "/KK98cYb9kd/9Ef2xhtv2N27d+3nf/7n7Xvf+96KgJgxX05tMPCVRlKB2+7S3xaHPa4g/HtLvK3e\n", - "v+dvtZcuXTIzs0bVxa7Nanhznlb9zf363lNmZra1GVJY63UX5zaw0tWXcCJI1aojR8zJnojYlO+q\n", - "FVn95QahqLzVUjNc1JCa+kr7vPTzGuoKXspc7DmHAJSu32YuYtYgEjEXoSzF0ERddFWT4LibIrZd\n", - "UvQoIuoK0pTVHZhLMTlU4ZSeSE2uJhzIS7L6oMh4NF1f/fH7uYpoM7oei4sx0S/Jv+UKp7qyIgv7\n", - "W8pK56wX0InlnCnHvtIcAonROlCLwu3Zr5UiylRWRERMUkUEINBN5B5P0J8pjlREii7WimrxElfq\n", - "YKE5a1LDkCtcTbXmyl3bmO2jqc7v/b629RQWIirsZvsrSlQr023bEaElUv3VMZlu+HU4FWutxeUU\n", - "SI+sBlm7UpNIygWqKaJk/FmueF/jPJRLe05nRBjD/x8+9HpxbdhJzFbsInBOYvXBe6hIZ6UW+tpk\n", - "KHYqCVFarT9HOxU/zyruY4q0/sLfxFwAq+gHUV2T6ypTIL3pqHuSh/3OHz/w7zXCvDuce5+4fxBs\n", - "BK5thxqCtb4gYg0gZzKlE2ldQalyVmVwpG1/O8y7qaB07Pd0kzbzsVUBMrSQPZ9BqN1tios1a8ip\n", - "1Usxn3pfqwO5nWv1CjaZtDHHDudiRf/nqDXZFFuJFuaVhw/dfoGC8sHIrQaabTAiYvVAl30dJ0dH\n", - "j/FvQL90DtvYCN9PtE+gX+vcxTGuKD2njLIgMlUg8Tp2WPdzJtddCLCTdbTmvdUR9FxSSewhclUX\n", - "6wLO08oELDDu87VUGLeJmIldBJ8nOtcRfV6KrcES+8t0npim2P86Sl+WZ1yu3g7nxPsiUvv7+/aR\n", - "j3zEzAIE+/LLL9vdu3ftz/7sz+wzn/mMmZl95jOfsT/5kz8xM7M//dM/tV/8xV+0crlsN27csJs3\n", - "b9rXv/719z2BGDFixIgRI0aMn9T4Hxabv/POO/bNb37TfuZnfsYePnxoe3uBON/b2ytWcffu3bNr\n", - "164Vv7l27ZrdvXv3f/Epx4gRI0aMGDFi/NuI/yGxeb/ft0996lP2u7/7uwXczUiS5D2iLFv7/Nzt\n", - "eXUVuqN7rjBGk1GAFkciTpuAAlIfl6PHgZ5pXXcYu9kM0F616tt2t4Pz7kYzUGXqO0FqLdHCr6Q0\n", - "khVlo5mt1Idd+8zMhY8qImRbJOf8uGBFZB9tQMFKrdALRAWY9EpSZ1seaz5SHw/QV/TkUBoLjsla\n", - "oLcNIaLSU2lGHytxZ6agcsUdFte40DbOcZ5SBBQiT4pC9brSctjHSISgpOcmIhileDIV348+6I+T\n", - "MsQAACAASURBVIj5XIWa9IBRagUwMv5dCBUwwfcm4gVV0Gha5BPQst7VMs5FacykoJaEqgLNRVZG\n", - "XbTpgF0RiHmerxc35n5bkrzAPrNCAfJvTZTA9ygKXag49JwkhqzgviVRAbvLEu9PHcD3uVALp6dB\n", - "S7mzcanYNpufrJznaOjC7s1mqFiwEGqDNGIqlVcT9LGK+LhVsnD/l3PXb1IioO3PQrOzlB5bfl3s\n", - "izr+SB9VtZAsKAUF/xPc/4n4/TSqbH8Zk9NwnqWaU+ol0KZMDqipYzM94zQBAWN2Z8dptMKxOvE2\n", - "sSz8vax40eKz4yAyH/ddZmAzFnw/h87g+CitC5FXyD2cYEnuUwnicR2nCa51IjIHitYzzE/tpvTr\n", - "c9y+OZ9oIWsmCqmwvKBvpPFaoEDpT2Tm3k+L9vpcy8SeTO4Jxc5XLl8uth0eovDtSJKn0BYdLUKO\n", - "OT4pCQWFdj+DK/r82JMj6Hu32fHnMAX76nvEcx6M/NnJotK1itBt6NvqlcXxsTwnUWc0Hq99xueO\n", - "PtfoO7Xiys7rk25CCYrSaPR003Gav4+zePGsEwnGeUlWpC9zeZ4v0f/OK0w/ScTbLXv/V6Uf+SI1\n", - "m83sU5/6lP3yL/+y/cIv/IKZBRTqwYMHtr+/b/fv3y80SlevXrXbt28Xv71z545dvXr13P3eeuuR\n", - "GbJsupt1a+2vW/nHiBEjRowYMWL8uOO/fP3r9rWv/72ZrWYfnhfv+yKV57n96q/+qr3yyiv2a7/2\n", - "a8X2T37yk/aVr3zFPvvZz9pXvvKV4gXrk5/8pP3SL/2S/fqv/7rdvXvXvv/979vHPvaxc/f9wQ8/\n", - "W9RjMzOrYzW5XBFHByRCxYkl/J2LAD2FOy2tEcy81lh3w4XaG206n+MNdiaOzVjVrtTQStfT2r1e\n", - "0HpdtyzzbeVy6T2fukCbddo05ZTfT2QFV9g6qMEq0s7HJV/BUYw4FOTmvJRYAgsUxaqFQw/iyDv3\n", - "vV7hEKu5dstXUFxp6Crdr09QAiIcIkBm2reKnfmbOsSB6nrNmlxqYcA4Pva6Zh3U9VI04eQkfK5o\n", - "Cmtyjcd+jClTjPF/HTDniQ6JSGi9NIrIVYBehbA1XXHEBUohiFwV972BVXey4TshIpEJIjgAEqVi\n", - "U6Ywa72yHIsUXf1xVal1tZh2Pi7TMVlF50xKUCdifE8QhBQu462695My2mcxU5S0uLJiW60S+hMF\n", - "wFNd/c8hcJVrYB9a0fAX/ViQNgpwZUyOgLrO5RjlMs4T844igvy+zglbcMCfnZMUoe1/ehZQBHX7\n", - "X6DdtU5hG6JlrbVGFJcASy73iy7SOq6qEGqPJ44+NJtPh2td+JywBHJQ7ToiSNuPo0NHPW7dedvM\n", - "zDba4dzSqo7rogCjny9v7NTbZIlqEyVJHtq+EhbV9++9U2yjy/nRsTuVs5LClavXzcysK2gJ5y5F\n", - "pM94PwVNzpHEMpNKERuw6WgIwtUo0uR9nBJtYaq/VkJgu+vcTaRfv0ekSSsQEB3b23PkiqLsodg0\n", - "zDCMduHs/eCBi9jv3nuI6/I+XMFcozUkKziXuSLshXhc6gqC7VnIGGfVAJ3jiSxxfl61Pwj9oyb9\n", - "n/dppSYhfqSbyDCtzLu0DpJzHw34PAvfq4sTPbviamWL9bqurFRSEfSxQRsfQYk5jfz0a6/ZT7/2\n", - "mpmFxLPf+X/+X/th8b4vUn/7t39rf/iHf2gf+tCH7DXs8Atf+IL91m/9ln3605+23//937cbN27Y\n", - "H//xH5uZ2SuvvGKf/vSn7ZVXXrEsy+z3fu/33pf2ixEjRowYMWLE+EmO932R+tmf/dkVLlTjL//y\n", - "L8/d/rnPfc4+97nP/cgDN5qZjXpSwwzoUzIWQ0S8fWpaKzVHWUNq3ZUDX1yWy6lCD9CSKuFMxadx\n", - "pBpIcgWtr7BcdZQEfeAb9iJ3VIFIVGkFOQr7Sc/hVplKqRXH03NMPZkKrlqFZZHW69uIEtVEjzVK\n", - "hzg3rYkW2oIolSI9TaBOC0H6zk7DKlX5aSICJYFfsjJ1U5Jqj2Okso0I2EhW8+TIeS6qKRpC50TD\n", - "QT2+6qa46itJ/Tem/aaybTSg6eS6RogrUjWwLCwpxBCPtcbUTJZ6KNWNsGbiXEwiC+O6FZsGpvMv\n", - "sC8//ibQj4m0Vx/nonWwaOaYrPTdsL+emEmyPzdlRU4dFLvCiqkd2ma4Yn4Z2q4h1iHVCmxCZAU7\n", - "nqGGl/STKvrfSvp5FvZ3cnyCfYmtAFarWn+wZOtaNmoqFlITkG1REd3ISS+MCSJNZmZnqNPHVHdF\n", - "GhboQ7qPK7uhL9YbrjPKgL70Tt3Ukjqbupj5jqBX0VRqruYVpa1t4jc4l6mgGsQttrZcD0Xj3t29\n", - "K8W2BAbDqay+ORb6Dz0BKLcwJjY3vU8MoM05A6o9FZ1NCt1QooggELvFXI1GoXNJvE9s7AY7he6m\n", - "10TlOG03vT8RJXlw/344vrRNHUhHd8Pbn213KEarRDjUkJP72VCdL5CIuSCRy8JMOHymfbJALs8x\n", - "aFSUsA2UXGu4sU9q/b1WC88uGTv1BvtYE/tyRO4RErvuoG3MzEZAffcuuXPqFmwntjZ3i22cJxTN\n", - "5xyn8zktWFQHxucSbQUUQaJuLZE2YVuo0Slry2o9ywnaeiJ9vJh3BLnt9UJf7EAbpjZBrB2qJsVE\n", - "rtROBl3denOfE8cjMGEreixq4/y3qnU+L2KJmBgxYsSIESNGjAtGfJGKESNGjBgxYsS4YDyxWnvL\n", - "LLFBLjV3loAR5wIP9gLEVm2IsDwFtSdu43QRrgmNVwWkOs/FgXxa2EKHfcnVZ3R4FWqJlE4itda0\n", - "xhijBrGfZgTTlVodkEmbkFpKpV4caZ+ppGEWomh1py5SPSWtHx+vpHzi3CtlEZsn4TwJz6qwt4zj\n", - "lxv6fdg1yLWSRlNR8iZg9rE64XK/ogom9afCSqasVpGGrsLqJgSTI0mhJwSr1Bb3t1w4FEsaU9Nv\n", - "3b13ndrjvwrP++/EpgN/LqT93dHav0cxrLYTqVx14GUCQp/XINRaHwJLpX3SKmjZkkPNtKJQsT2h\n", - "b21r2lMofcm0X94HJimEcwvf29xyC5EKxPHthvfrrU44l96R1+RrQgC/nDhkXy6FY03EuoGQPimm\n", - "kkn9SbTTQi0xcAuHst8qzkWrEqQl1jXzbZQPTBbaTqgxCRp9sWLXEb7XEMf4Wg00ttI9oBaaFb+v\n", - "p8chUaJ71em2CSo5sG+aeb+brYiXwznU6hBHV/x+LSFPWIgAvtUALT/zbWUIype5OkuHvytNv8bD\n", - "O0HkTddtM7PN7fDb036gyrQPZcOwrdyW2nAYT2nZr2sBmjPdFAF0GfXnZI7to44gkw7MvD4cabTh\n", - "2Cm7wRB1PYVuZ9/lvTEzyyDiP+u5/QWH/1ykInMkm0xk7mCnyTA/H2ttSojtO22n24p7eE79U6WK\n", - "KeLWkmqHh6Gdul3fXwu0YHczJErt7Ttld2kv3JuDAxegs+5nVygzUsblslJS4dyrQlORWlX3dM77\n", - "Kgvhs4qJDWKiX1gDTEXYz4SOWk1tYsK/CxF209Fc78lyykQBfxby3I8hAVD7k+J3KzIkuq37limk\n", - "AlrrcjgMc5bKNwaQlGSSUKYJCudFRKRixIgRI0aMGDEuGE8MkRqPhjaeqjgRot+K1KZCPa1c3iCb\n", - "qCafNFVEiUr3Itgj6qN16GiSyYrrWi+OKe4rtfEgNtSUaCIcVXnT1rRXRiEszUTEiDdmHkPRkgIJ\n", - "kTd9Vvo+34xMUkMhylNEiqnzan9A88E6VmuptOuUhnxyfKIqC3lbZzvpORFNUXEgkT1FmHi9Kp6m\n", - "sJApxCpipLC4LoJZms9VzjHQGwzE1A/RXlmlhbY4PXWxYbPYHyuIi2ARK63zxOF9qT82m6+LUile\n", - "pzVDOAZWblNZ/aDtap2wmh+J6PIEBpYTSY3Ppuh/Tb+vQ/Q17ZMUVmpa/clpQEmyy/69IWrBcR9T\n", - "SWGvAkHY3nBxMKvaNzTVGYjs5es3/XsQD58cuij28a3vmpnZrOfHaLcC2jXG8Ss1H0uDMUwypV7Z\n", - "Bs8lXzffq0pSQgqkYWHeJwiENAVhagHZpFB1Iegni0d2W/591ikrSf/n/DMTYW27G/oVzXLNzGaY\n", - "T9TOZVkKK11FBFLU/cTC3PKpj/WtArmQ2nCwjlFBLG1kSqnfp/Ek3P/yUhBWjDHWsDMze/GFF83M\n", - "7PadN8PvBGmp4horbRkTOc5F5preURA0b7S87ySFSbG3J4X3xz0XQG9sBSSuizp0iiAcow8/eOT9\n", - "ahc1AVNhDjg/bYqw3REWv3dMma+1vO2YKJIB9VCrhTGQ0EzYhK3tHezLx9qkMK4sNhXovPYxPp/0\n", - "twPW+MSx1EKAfX17wxEsPlfKkhSVY3yMxyK2xzFWEjXOSYYqEnBkW0aDYTzPxmoIXBgtK0uSYh9S\n", - "/5E2Meo0QHZGUPrJlDYtPp9WcMtOTwI6ORj4nOC1Fn3HfD5URNjP54SiWadIqNLkJdYsrVYVOfZz\n", - "OS8iIhUjRowYMWLEiHHBiC9SMWLEiBEjRowYF4wnRu3NTueWTwQ8rMOfR5yI0xpqPo0d2h0AFu2Y\n", - "CAtZw0nU3hQlqysyxc7uQSHCdnpGiWcMP1W6rw76pF53cSRFhCpUplePQqeEVt8rOtff1kSI6m7L\n", - "4iNFt2n5LcWWJXUxZ02yc9zGeTVKsdF1V72A6PorTIB7UMnx+XGrKQ7AoLvU24lRF6E4hdpFHSa5\n", - "1hKE8hW5rqyoF6ciTgohN2Vb2G+j4SJBirYz8XYhVUl6Vr3ASKkt5b6Sbmw2/RqOATePBR6meFJ9\n", - "nJzS9b7bhz8KHaa1/iG9uGrSrsuiT6hjPN3O/dxJBygt0jsLlEGv6eJd0ut9CIu1v7Dvam1C9n/1\n", - "YBvCe2wq/jRV0DeX9p/236KNB0J3Dc7Cb6aPH4T/Tx2yZ8JEvvSbMuJcIP2PrMBcKDD2olxuaIp5\n", - "YkMSVVjjjP1uKk7kS1Q+6LT9Xrdw30cDv9ekzDPxjKJgvJL5tiVqEVaqTvdmtUBj1UTMSr+d0jwc\n", - "Q32UZqDRmrWWbMPVytyRsK6YzH8Z+t107H5X2ztByHx49KDY1kNf4Jx4R8p+bcBte8UJmjSjdMDZ\n", - "GM7SI+9/OeiRujjgk/reFVE6Re6cY2pVb/+jw++FzxKd/8K4n4nYvgoaTZNSfPyLVx89/caaAILE\n", - "I7Th9rZ7VtF3Tft/QTNJY3MeVxH5yckR9uF9rA0fKaVlSV/dv/du2CDzXxc+Spd2fFy14It1cHBY\n", - "bDtCDcUVd3Jw20ptcS7S6ymV1hNuang+F3Tjihcahd3+OwrKxwOnMed4/rWk1iC95bTWHR8BKktZ\n", - "LsN+WqDZJ5JsMplQMC/vDniOD099Pnn0OAj09XnagVSg0/F7zGe37k+rFpwXEZGKESNGjBgxYsS4\n", - "YDwxRKpcq1pr6W+cREQWUpm5DFfcRER0KYSVmYgzqWdWcVwJv80EpaLYmajTefXidC8UICey+iHS\n", - "oSK2KVb1ilzxe3qMwsW6QKTEVuEcETuFzwtBzigsVwE0d6P137ISanLlmhIaYgyh9OBU0tUh1NXU\n", - "+A7dzhWRQmPnK/XXUFdPa21hRZImgrBgRVSRNOUSjsdDzAX9mcJZNlOkBSunhaYk08VaxIF0p+31\n", - "HH0hcqerVHfAhTh5sZ7CXBHB/ISIiNxrCqVV7M5rpJjbzOwAAtxc0r+5G/aTLRF2c0WulhxczauL\n", - "7wR173SluQQiosJSpumfnTlydIpUbNYhLOlqlQJ86X+sIVeVBIud9g7OU9oJh+0duot2DQLdtqTa\n", - "b2wGRIJC8cP7j4vPDg/uhN9JUsicbSKrVToQ5wtBX5es9Sh2BphvenNfpbaBLPNel+RYrOfVEKuH\n", - "8Rw2FWJ/kaLf63jevbJvZmatujuQ2zli56efecbMzMo1RcnCv8uzdWd/zntLSeuvAC3IS97/KYZX\n", - "B+6EY1ZQYrp4NwW5nS7DPRtD9DuGm7aZWb4IfUgdy1nXcSLoa2c7IDGLzPspe3Ga+Bi7Bjf2nojd\n", - "R1MmeYTfXtpztOD5Z583M7M33/7nYtsQyQiX968X25iMoBYvBKI1rZ71TMuCHHJuJ4I1Lfs+mk3W\n", - "9VS7hNCu2q9p59KX6+oP1oXNHdR/1XFK5//2RjjWios35rBbd31cfeTDHw7n1vJ7eHwcjjsc+LWy\n", - "rp/axGQboa0rYpPAuZCVLczMev2AcM1QeaTb8WttN3Ce5sL2Hp4tDx440slnR3/o46/6HkYi7Bv7\n", - "k2fXYkF7ElgjqLAdv+6f+fnyb60cyqlA24lIsM5xUzx3q6kivPa+ERGpGDFixIgRI0aMC0Z8kYoR\n", - "I0aMGDFixLhgPDFqb3N3pyi2aWbW7we4s3/m8ODRNPxdTlVYCspIRKSEPlNx8abIuCzbWECSzq7l\n", - "yjrtpgI3UlFK95BuUcEaaRal9gijqtiXIkZSe4LYWhVeNCpsLoTn4rFBl+flOZRdvuLAC2f3scO4\n", - "FJInZTpWS+FVwP3Dobf/EJTF9rbTE2xXpZYeHwR35FpZfZTCOe9duuwnyPtU1W4XzpP+KOot5gp0\n", - "b3/C7Sp2J82pDuS8Dk0KaJDGkXYawQ+FcHut5n2CLrrqRM7vqds4XXyVxh0DAl+heymeF1FyCXTX\n", - "ZLpejJmiR/WY4WXrtdIBX6klipyn4gF0ehyoFy0QOgRVsAnKYiptwwKhza4XeW2gT27uuNt5FRRY\n", - "R+g+ik3zhcPoRweBjhj0XOy82Q6f78JNe++S0zOPjq6ZmVn/sVBLTDKQ/t+DG/ti5vdkgX61VLd5\n", - "tHFFncVB5ZHSngvE3wBVrPeQc0hdvJBaaKeGJAU8/cxL4TxkmJJGroksobMR3KtbIjYnHbWoh3tS\n", - "ke/TFX3eFQoY/aOkHDivQ6QSrGxgo4Ni2wMkCFSl309AUVNEvb/jztqep6OO/XAAh++UmVkN8+im\n", - "jn/8dks8kPoQ+0uOUeFUzzlUxfaXr4RzmQg9d/9hEBEfHDiN1O363MZoQuSstBzdyHuSPLCzE+4J\n", - "pR3q7UYncPUs4qOoUhNvN1BrR0dOo/fh1VcXGpdSjpVi7WV4qlW9nRiPHoVrXSx8nn7zzdDubSnG\n", - "zJ6wkOQJw/MuEwd++saNpy5L4G+GY992egaalxUbzIshT5YYV5n3Uwq1d3Z2ZRs8A0XYzr5dEUkJ\n", - "5R2avEXZwnKBZ3hVMSAk8ci82kFb6POcvlAr/lh8JkoCEvtpplVB9GF9TkREKkaMGDFixIgR44Lx\n", - "xBApyzK7tOurqhZSl+/dvlNs6z1GrTFZfbQaeOuVN3gKTxV9aGJ1qKgT35Ip7NY6SBSg6xssEQb5\n", - "WvF5RVIjqRg+z4Fc36oprCMitZJWDkHpbKpO6PidIB0ZVmmJoBTFOcvdpCh6JA6wza2w0mL9o0Rc\n", - "pJl+qg7LA4g4K2fe1qznptdFwfLe888V21i7T529j7H6LZ+zSmgkWKVJHSouDRK5sPeievq3tv4Q\n", - "yI6uHGeo4zgeq9v9qgOuurPTdVzRvx6E5bpCSeHiO9Q0dSKH8r3pBMiRCKC5iGJfG664s6PWnPST\n", - "bhfiTLW/wD2Zz13su6xRbO/bTiF8PT6RNPFmOIFhFs59Q4SYG1jVp9L/ulthzDZbvlpu8x6rTcQS\n", - "Lu5l7eNAM0cuwB2jf/azcE9q7avFZ60WUrMnl4ptlQprTUpSgIVVel9S7SdAHaYTaf8Z7SzWBdBs\n", - "TxWVtoD+qDi1WgtfaNUdkWtCeLu/7+e5iZX44aGnpE/OsRhJkSCSiO0KQJoCOVULjwToX2VLaqNB\n", - "FD6bOvqRsa6jSVLMHGJcQQ42MSe8+b3vFtuOT8J+WLEguyx2AUSM547S5Eu448vYWQL92dT1P0S8\n", - "zaYjB/fuhvHOOohmXju1QKTEnb+7Gfrk0yKYn2CsHZ840kbbFU0UKqONNZX96CBc60zG+MFB+Htv\n", - "L6Bfijb0++F8dV4Z4LpVWM4xeyKC7eU8tEVD7B9OUJNRk2xYIYEVA7QSA+epicxhX/va18zM7OWX\n", - "Xi62TZg8M1+3MljmMv9hvtc6tby0etURrk4b8zTsPzKp/8h6gUndW6pSCfdwc9P3yxqDq3ZCvFZv\n", - "E8Ke45H3pxGed5z/O2IrwWuYyZxApCmV/sfn5CrShRq3WhMR7a8VCFZ8lM6JiEjFiBEjRowYMWJc\n", - "MOKLVIwYMWLEiBEjxgXjiVF7k5nZfO5wWbMeYEQVQM/zACMPBDKmO28qnkldCC/b4k7agkC2fA5V\n", - "V3jGqOoMkQvESwfslhTepGA0EQ6ALMuKKzd9oYQqe68ofSrC6sUi0Gw1gZ2Hw0AFTFQcCfhytlCH\n", - "DIi4VSiP62jK/gg3L2YQogvEWYYAf0OEoCNAqwrZ948CjaLOspVyDecmyloWfE5829ZOEK1rwckJ\n", - "6K5OK9BDiTh/9OB3VG04PUgn3JkWCAWNN1+BZ0FfCrTbhyh5MnYIOO2y4CXpsXWxv3q8lAG3K9K7\n", - "xG/6IkqtgTZdSJuc4D4OBbKmy3sL9JEWHu3B70uhcF6DUoZ9tKcKVgcQrB6K23gfBUx7R05B0FOL\n", - "0HpdHLO73dDuWrAzx9qrJEWzS/QME8qKwt5sKL5MGQppL73fz/qBjjk7CP1q2BN4HnR3ljrFsEzC\n", - "+ZYqQg9DKJ+d+XXNl4FGWAjcT5HxwYnTLZdeCRQdBet1cZiegoqbzpwC72wGKqxUlmKsLEYr9+T0\n", - "JNAxSuMysWAgRXBnGIMDoYUpfKd4PSmLn00ZnlEydecQvmfiBZTQPV/6aaWBAtGn7lR+7074ezzz\n", - "Lz5+DC8vGMgNJAGCXmnVw0fFtpOj0NYjmafmZ2Hb7X/+VrFtE6L8gXhgcciWU5dlcB4lZX0q/kCb\n", - "8KfqdPz7N24EL67Fm0KZgwKrrCQUce72vsMi6EOZi5ncQd+jpy5fKz47PAptc3ri44pzx2Dg/Y+U\n", - "3nDg93UTfefg0EXxJ29BFrHnx7j53E1cd6D9Dg/dW419TSUrpODf+sFbfq2gNjuSADGfsE3EKw70\n", - "1VIehs12aGNNiuCzs1sUDfe2boNu1nmK858+42ZNfubzCT3A8pKPU47Bjjx3a/RUxHyaibSG1F5V\n", - "nnWkdlW+w4LTep4J+lpNxO7nsXjLc94VNCIiFSNGjBgxYsSIccF4YohUmlVtsZR0SbwFdptbxbbF\n", - "FKuvpQs2KxbedLe3XezJ1OnNDUekWBNMURqKF4lSTEXETtsBdQImItEUJ+zZfF1sTfH2WGoCunjc\n", - "37S50iFapTXnFuekfLJi2FQsFCZI10/yta/ZSNJV6xAP6ps267h1kRqq1gx58ZbuO97ZCm1cveqr\n", - "mlOIl999951iW4YVxL2HvtJ64dlQCyoRm4ounHpLYmfxzruhntQZVni6WhiNQ1tXGt4mYyBY04m3\n", - "a69HhGt9KbFqSRHaRJFDChopRC7J+brFgIgopT8V32Naraz0auXQZiqKZl03vcfsJ6zrV84U1Vlf\n", - "6dHqQZHTElbYar9A5PLszIWqFPsP+lKnCqv+0t37Zmb28ksf8AvDCl77VRko7bEgXRTWX7lypdg2\n", - "X8BWou9p2hudgEgmsko8HoeV+z0IVi9f83RpriobDbH/wDnlqSNnRCTLqdYk5HhylITt2BIH6lMi\n", - "B0BdFRHsYmXeajkiyrkjERd3Jpso+sz7NJur2L6GY4h4m1Yok3MEwEDV88yvy0qcw3QNTKsD2cb6\n", - "hCsTRdh2Ksjd3du3zMzswUO3pOifIP0elgjHksL/7jsYr1IxgONP0T+K2I8fuwP3tB+u69Ghi8K7\n", - "nfC9ckXQ1GGYl3Yuh/lHEewTWJJovbwa0Ilr1x3VYV27dsvvdR3tqnMS79lTW1vy23CMR0Dmdjbd\n", - "/oXzjtqK0Dxd0afpBLVOpVIAUfSxINxElqtSY5PPqe2t8FxTwfgQiRrDoc/dbSB92v+qlfBsSSWt\n", - "n+M0l/mE3TMVhGsTqJPWc2Xy0hGSJ+pidcJ7/eCB32vOGSoYN8xTXbFTYZ/NTRJ6UIuzIwL0jAhj\n", - "E7YmgvSzhp+OtVYj/HalTiqum6i+mVfo2BDxeq0e2l/7XelHWJtHRCpGjBgxYsSIEeOCEV+kYsSI\n", - "ESNGjBgxLhhPzkeqNFspqJvPAgRXFcfgnc3wdykVZ99FgPj2xG13uwt/JHHMzgGHajHCFNA/gc1E\n", - "9drnBIXHKg4mPFoRUSrFi7UVaDXAg+f6eFDgJuI4+tgonEhHdTUxT3A9ZYGMKSxXCtAAs1/e3y82\n", - "0TPpDL4kG5su5psDblYq6Pq1p8J5yrXuXQrtviE0KqmCW3ddxEr4OJPzJGT7SJyqWfA3By2WlfxY\n", - "ORR+t4RGLLxdxEfmvOSBskDlxTZc/2jkdBOpNcLpR8dOcTQAX69QqywaLcLiOqD1dkPoJgjaj49E\n", - "WIvzbAndQOp5uVyH3d97fWYCzwvsTgpQXeHpcnzjxtPFtu3tME4eP3RqZQYXY3qwnfacRh+N4CMl\n", - "95AC4Ik4JvO61AG/8NGS7y3m8Hariy8T2uzNdwIt8PSL/7H4rNImZSGUXUbPMKfFpyMULU783Eso\n", - "Vq4UKMdpRWikCUTe9AzbEEfsFDSaUqbddmjDriRlsE2OD53uothe2eYaqGWtwEC6YWPTj0t6dzKE\n", - "Y35bxObGfi2TwnkFigtKb32tPJWx8a3v/JOZmZ3JvEPxdGMWxuJ86ZTVcBbaqfnQx+nlS2GO6W46\n", - "LdtqISlA3LZv3wvzw/fedlH0f/hgC5fg17gBUTZ9x2pCI927F3wGdQzv7wf39A2hjBIkuYykaHgP\n", - "NK7ODR/96EfNbNWBnmNrjPv61ltvF5814aPUbPj9z9Iw7jT/ZwCa70xc/Onp1umcN/79BDgH8zym\n", - "UqB3iTlRXcwZlU2/rlYt0NFt6acJEjSGUjQ4g9i8XvPxRI9EpRunNXFIt1XJzBB9ZywSAM71mtC0\n", - "sxOoylbHz2kDflPf+u//1feNLqvzbrUUxkSD93gmXlB4dmhiQYZxNTnHM2oloasX+tFMyxsv6QAA\n", - "IABJREFUiltTyK8z8VgSic6LiEjFiBEjRowYMWJcMJ4YInX7zm3b3RJ32MJh1d+CKZirNfxNs2Xh\n", - "TbvTdAFoHW+QihJQHFcWAfAUyBLfTMslf6teonaUomSsp7Zc+vEpIlWxHS0RUnmD95pokqYNUTpr\n", - "4ukbb4GqyDXMUItQkYYcLsYKv/AXW931VW2lvG6/QOsIRcvmSGHXlQ5rDc2k1t0AtRC1/lUlDefy\n", - "zDWvk9bHm3635StH3p9Rfyi/DW1WB+qwXHGHx8q4KUgPRLlLSaHPUGNMbQq4OlJRKms9lSV1nq2Y\n", - "Ia241ZK6ckBpTuYutq01wz40rXcMm4qZ2CqwPbX+WqmEVbrcuwnuZwmoR//UhcAUNnMVbGY2RD09\n", - "TRToQfhbEZsCwpht+S1XaVrrjPtZ0HW6Jv0FK+FU6lqxy6SCCFKoPxFLCo4tFe+zjVNJ50+BTr38\n", - "wY+F3zUcJa2gTzRkBUu0ZCTi7AWXsHJfF0jdnwkixjqGOnZZR43zTpr6vZnNx9i2nrCh9Q/5i7ls\n", - "MyRWVHK/ftqP5CIAp8i9K9YttBZZApFOBMGqNOls79vyhJYUfu+KzxSlwplefcorELz20f/DzMz+\n", - "6Z/+3k8d6BgR8flcxhrapy2p6Zf2gxu99mvOZ2WZz4liv/TCK74/urYn2u7h+t99NyBXisi34ai/\n", - "u+Mu8rwDWg6NyKKKjZtIu683fIwT9f7Od75dbNuFK/0GkhJmNXHRxxw6Ehd9JiVdvep1BYmOKHJe\n", - "Ql695hMxQWNHalcyKYLWJCv1QomgC0p6BvRH57q09MMTUDJ57LMmXa22brtz+6EzDFPUsdzdDW3T\n", - "kHNivx/2fF4/eBzQ4Wdv3iy2XdoObEK6kqgxX7v+Xp+CekeBpikabYhKAPLwbEMcrs//WWGX4DBh\n", - "usSYEauPDPPTgwf3/Lfo72qxUy1Lwsc5ERGpGDFixIgRI0aMC0Z8kYoRI0aMGDFixLhgPDFq7+GD\n", - "Y5sNHOPM6hCTSfHENiiduoi4d7sBApyLP8xisQ63s5Bxte6/paCYdINC9oRTtXgl+bmWCPEKXyBR\n", - "J5YgXlWqjih3tSy0yDz8TapsMXHYccCCl+qYDQGiCuEoTq2KAJxUxf5lh5YpFDyWIsBnRwFupbfK\n", - "UgR7HThrd0WATmj54UMXh1MAeSL7JaRfqymNFa718SN35WUD5dJ2pEUJ46o7+Xt+Zmbu+6PO8qQq\n", - "le4ipJuJLxPpBi34aQ060INGkgKx9BvRflIqxKFyo3LcT6EW6e2iHlDT6RjXqN5G+Azn1BBvsSxd\n", - "p8dYBFRpNJ6nHouUEYXoZk7BKSxPOpBO2FN10Ue/U3raXbz9Pm1uBbpF7xPvo/piLXMmavjx661A\n", - "wexeDaL4ilx/rTh3pcfD9Y+mLuz281QaI5zNyYkLa+eg1o4loYD9iFSMJluQUqlLv+Y9UWplhnF0\n", - "Ir9t74TraghlUiG1KRIAFlInjWfmVAm9yDK5LvJcee59bQFRdCLFiI33TChAekrRYd3M7D/89H8K\n", - "HyU+dh7BZb5eDfdV6SHONdvbLiznGFNalGLjXETUGc5p/5InCnEAKAVDCorFk6cyT/J+aQIQkxzq\n", - "Qkt7oohLEO7eD15p14S+P+uHfrRzyX2kmPjB+SKXsc6kBBVbs/8dibdahja+JnIHJj5osgmlFDru\n", - "OceyrfX7vBc6/5Ke03mC428p/YT3oiHUNqlfnXfpo8Q5zMzs0ePQju/eeiech9CIW6BsHz1yt3sm\n", - "Mm3viAcXKzvcd78pPjsakmS2rIb2PHzo++Nz7+BReBZpZRPOe/pMoLcjqVAz97RqyJzIe3d6LAWv\n", - "i+Q2789ZeT1pTCMiUjFixIgRI0aMGBeMJ2d/sCyv1CarzMLKse8LM3uEFeS1q+5Yu18N4jytP5RQ\n", - "2CjC6pT1qmrrq2+uzHRVz7f5zaa/hbP+1nlu5yNBP+ZTrohFAI5zn878TX+IOlUTIBNLWQXwl6ms\n", - "FgvBuCAiFQgmtwQ5SkrrzsoU0Y5kRdaByLgMFGgpd/8SbAXu3BUnYgh6z0599c+3/005Puvz3b59\n", - "p9i2BDozFfSlipXQWFCPHPduXqz+fAVLh+femaMKRFM0/b8LV9rRSJyFcW8nWtcMx61UvY1ZT/AU\n", - "lhBEXMz8fmm6bLPcxO+873Llqu1P5+9U0ByeS0lWsw+B2LE92y3vr/1+OCcVrCYQTJbUsR3Xs2KT\n", - "gc+JDJi5PYem8hbnglX3VETcvH5F9SjeFfChQL80Tf0hVv9tSRRYLmEJIohkrRmuu9II55QJgnOG\n", - "/babvt6bjlBrUly0uZoey3iewvm4P5TUfaCeS0EOOe6Xy3DcqoijT0/XXbQL1E/anzU5NQGB6Etf\n", - "nN2r1XVnfYqih9LHWQut3GVxMrUEAYKY+3WlsEJYzGVb2VfdxW9pgC7bvvVP3zCz1fbstoNQnn18\n", - "c8PnRCIMilIRHVf0owaEV8czkbaFIOwp2l/rqZ6iFh8ZBEX/aDtDKwEzswHnaTnW8VFAHSuZ38/d\n", - "3TDHHZ86mtMfhvGhbULkqLhfAkZwnOo9ZJ9Q9JdjRpFr2q9UBJFst/kbSUDBs4UI/1LGy3AW2klZ\n", - "Cvb/uWwjOq5VOZjW3x9oAhBrjPoxRvi8KkhsFwkfR8ehj/XE2X6Ie7GQOfn+/VDlQqt9vPpKqJow\n", - "Gvmc1EfyUqvjyWNFO2n9O4yxh4/Cfh888CoaRJ9UsN7B/k7l2bW9FfrudOrPXd6fjU2vytA4JwFi\n", - "kUREKkaMGDFixIgR418lnhgiVV+4kZ2ZoyTTXFMYw78lOc1FAk7zVPhorFh2t/xNvzC9EykLVw58\n", - "W1denqvOstZa02U3zwlv/Zr+PyrqdPl5EulQM0UiYFwRK89OPnwiiMAEteZ0pVVuZGu/JTpzKiut\n", - "Qksk11PhKgkrHEXwuArqC4LBGmbKvfdQ4VyPb3hbn2n1d9o5yKt6H8Ztuppd4r4vptBvCCJEBCuT\n", - "2nBcTRAtMTPbQa1Fq0mqfYGieAfowMxN0Zzjk7Ca4gq3WhGNGNAUrc00wgprIEjDECu4nV3XjYzR\n", - "drr65OpMHR4q0ND10J+1NhUXibksidkmzbpy/2LEinCkRRAB1p+TbfybKNVG16+fyGF7pYYhtIRS\n", - "p5L3WDWKrCN5cODag1brKXxf0BwgsNQNVQQR+u73vmdmZh945eViG+tpKZrLepY9WWmPiUTm63o8\n", - "1ZLxXNifWaPNzOzGjWfCZ6LH4Jzw6LHrN3ag0dmUem2sBaa6rcEgtLEaF165FtD2uYyn8VkYuw0g\n", - "QYloxCi+XAjSmpQwn2S+qn+/OJJzT0uh7dR2hufOe6jXeuVqWLmrTQgRnH7f+wTvUyoTwAD9tN/3\n", - "ubsN9CtV02Wizuh3ir5w7qycY7g7FFSLz5bGtiOiN5951szMvvPPbxTbCh2k6GtoMDybhvPcV1Nj\n", - "mKrqnPgIuh1Nyec1JIpI45zKMk9S/6TPCSIi1OMqgloDSqY1BIlIKfpCPVJP5imiyQOZY7rdDvbh\n", - "50QEXpmIDGjO3nbQ4VYzR47v3wvo82LpDdDGPJIKIvj228HYdLbw+bxWDtdx977bD1Bfpfd4AANW\n", - "PjtefPElPzfM9aqHsqImpm85rz9xTpyXRPOMMa56zXrN2/u8iIhUjBgxYsSIESPGBSO+SMWIESNG\n", - "jBgxYlwwnhi1162XbCEi1noXQuSBiHhRV0pr2C1BQY0kSz4rBwhyd9OhdQrQ6FhuZjaZLLGNNYzE\n", - "VgAQ7EjogUUh4nPYky7jmmpPkanSWIR+Nf2b6cGEIjc7TqNUAUtORJxHWHYi4mAKlvsi9iMEz1pi\n", - "Zi7AzkS8ToiYQsEzcdHmNoWsSfsMVZyMz+dSWIrCv+lEaCRAxZnYP7DNlG5ygSbciQV2JSq7KXXI\n", - "hqDMOm2nMUhLKS3KOokHj52qGaEm27ZQMC045Jfgtqv2B0VqrEDcXHuUhO6h7cRA+g77rMLTrM+m\n", - "7u0zUJWs+fbo0KkwUlBKhZKe0jR9pvPqvWPb9YSWJN2odC9/w/ugomNej15DHWLwiVDb7JNaG4sO\n", - "yI/uuXXGnE7dU60JF860Xl+nTNqtDs7DqQj2nbHQOKTMRzJ2aPuh1BLpez0GKT0mClSkrh/PSVPD\n", - "T0DBDgY+dth2TaFbSKOoJUgfv1mhpXA9o77fz50t9PcSv+fHz0HzJcoPwz19KfX3Svx4XZ1g47H3\n", - "U8oSTkQWsIG5o4k20cSS8yxBKD1QSxbOrZqAQep/c+MZ2Ra+Nxj6OXXa3dVtVXGsR//UMbEH6k2T\n", - "UiheT0Uq8Ajz1KNDr8nIPvH0FRcb37z5vJmZ3bl7B9fnbb2FuWNlTIBmVxH3Kawb1GqCjvHaT4qE\n", - "J7mfpJs5/tSJf4wxpjKKMZJsMrnWdM6/da5Bn5Rn0qO7oU1aLZn38MzUufDddwItxzlW3dY7W6F/\n", - "LMzbhC72LamrmaahnxxKrVUOreeec7d7UtU6F5XPwr6vXAlU+Oqzm3IDeXYktOSRdwfcR3Vx3wRl\n", - "OZbkISbcDCY+x+QyBs+LiEjFiBEjRowYMWJcMJ4YIrVxZcvSlh8+q9BUUeuAhbfAmYi+KYCVl89C\n", - "WKgiWqIfcxHF8i2VNgiZVrBmGry8mY6AuqSyrOMKVlcpRB905UpDTH375d/8XklXddhdKoL1Fuqk\n", - "VaVe4BLCTl1pVSBAPDxwS4inbwRhpYriT/qsPh5W+lxx6fU3Jf2eSr2h2ApsbnZx/VKnD+LURsPf\n", - "y3nYWs1XKdvbYTWnyBFXuBSvqmD+4cOwWmrUXdi6BzO/FZQMKI22fxnpslrpncaF9+77iogCRQql\n", - "tYYWgYttSavNgESNBX3pEx2S1T/7iRrSLQvhs4id2wnOPXToVBC8HmpX9aVaewdoQVvEvtRua6o9\n", - "j9+RtOJh0XdXfBLMzMeOCrGZVq6oTg0p1LOxIgjhXBSRI+pTFasJpjrXGj/cJPfoyNEC1i67c8ct\n", - "OWhPoaaaFMXelf5Mw0K9VKIYmdSuS4gwohGbDUcLmNgwXzGLDPf98mUXILMmpmjoCyRG244o3v6+\n", - "G+eWIHKu1TVNPbRJTjQjX19p68FoJ6Dor3cxRa7CP/t7Xqfur/8c9dRkjt27dGnlnKoyh9E4UlPt\n", - "KaheLDStHHYmalMCZKtR9zZmooYmKswwn1BkX5G5rgf0syrGzXfRPyaCUlwFwtQUO5t33w61+555\n", - "+kaxjdYhmXk/pQD56afC90qJ2l+Ef6cTn/9SIIfzqaOKlXJop+0dR/PyhIyECNCHrOco24Cs8rmi\n", - "VivpOYawtDDRpBM1zGXQEqcvtU7JLOQjnXcCctqVuaPTpcFsE9eyXi+yKVYn7Cdqa1FipxTjWFrn\n", - "ZKkY11ZDew+PXIC+jfqHfSQCqEkr6+muMgJAzv3ypY6snjsNVtetFjZr/i6itjDnRUSkYsSIESNG\n", - "jBgxLhjxRSpGjBgxYsSIEeOC8eTE5k9trgihxxDCLVKH7Cp07JZ6URQRZ+JjUQF8rmLXaUEZ+DEL\n", - "8ShEr8dH7mcyoehX9kFIW91hiZmzNpeZC4BNxJ6E9lUASB+LQqi49JNjDaNd8SKaTWYr523mPjsq\n", - "jtvbCzSDOuu+84MgDhyoiHUv0Ew9uPlq2yxzUEzi7ZXhGpOyekahTmEmdCcuUSkQCiQ7XW871kJS\n", - "nWxRJwvfLws90QLNmCVOz40Axb7z7rvFNtJXZYHMK+0AMzea4i0CaL001DqNoT89BKWUyrntXgr3\n", - "Yl/oOYo8BwOn2+i70mp7+5Oy8b5hNoA/0FVx6ifdOB6H73XkHuYLeGuJF1IN/Un7xAiUUUNrwmXr\n", - "nkkJ6BalOwvxMNZUqbiokz05lDpUw3Fv5bzD9VwN16c+TqOw34FQgDM4X2+YJw+U6K2F0+z1hMbA\n", - "uTw+cbpvOQxj4qH4Ux0dh8/f/v73i22sHqAUB2uMqdiWNBITRkYjpx3o7KyUFamqhvjK3DoO9Fha\n", - "8f6XjknZ+X1i11IH8DnOr9mV5IlpaLNOim1Cey3ZQWWcJDi95cwF8KVKoNFXROkQzM4HnjxBuq1S\n", - "8zahR98MVJD2lzHusdJTdUgQyiIs72AszJdOt02RIdQUGrPe4JzsNAq9v5b4njrLk5ZLZf49QRUB\n", - "dTHnJPOuVFvYQfUGddvegdhYveLefvOdcG7oLyr2pus25y0zs9GYPnKexHIGCqrZ9GslfaSiaF7b\n", - "SLydSHNyjJ8cu9yByRbaJqTWNImnoADFH4yJT7u7LlWgH5XSt0VSkHhbkRZMbL2yBY+fLP2eNFBP\n", - "syY+WsMBPPjm3icfHQYPqqNDp/FIgX/3je8W255+9jkzM9vZpDzE72GlcIz3a6Cw/NFjl7s8xpyx\n", - "teXn/t++8f+Zmdn+vtPdXQjl9XtpIvUuz4mISMWIESNGjBgxYlwwnhgilZWqNhv7SqtCIdpC0A+s\n", - "yOuJiFOx6liI2JtCWa2rxrpCiiYN8EY8BCKj4jy+zDclDZSpk5pqe17MsDpXASSBgMVcRYnh2iio\n", - "bosQkivD+1JDaBtv33p8Cg8p0jPzum4P5bcUo1abfk50e+b5zqWGUwoHZrVfYJp+mjuqMcNKQJ3l\n", - "uZpZSXXGqmoqYv/hOQ7wXDnxMxWi81rVVoErsZ1LLvblvV5Iumwf9zYt+4qMwt+0KjUR4Wj7FNJq\n", - "D8V+gBYDiYgTmSasiCQX/V1BFZjIMJU0ZdokaFovBZoZUsfr0id2d+k67v36MWpM6ja6IysiVKQz\n", - "C5rF9Gt19M+BiNBhej7z/jrDZwI+2m0Ie0/FAZ9CeUV/tpDCrskWt47DqvPyZRdbM3Wf44VosZnb\n", - "BQx7vt8zpK7fu+9Iww9uBfTVzkGfVZR9XrUDCpkbcFhuijvyYBDu/+mZCMHRn45PvP8T2lULgbRI\n", - "tV6vHjAeOup2ClR8Syw5Ds6Qup+i/qOgmkmKfi2C3eFx+F5WkaSALdz/TK1jQtuNZo5+vPz8i2Zm\n", - "9i1x+74MhJv3ROe1NEWijozhOj4numTmiOBY+iRFzoPhet/V8cQps8G2E1S1DISlLOOaY+hM6u8R\n", - "Wb8kruT1evjNSNq/QIcEuXvttY+amdffbLUdfTwEqqFO5EQsj469T1w5xxKF825DnklEkSpiHUGx\n", - "d4Hwy/VPpiqfDsE5VPfLbctc587QxmrJQysUdYXnPRlLkhGTMIhEKkqZsq7p2McuKwRUJFFqught\n", - "cSYIN5HF077PJxuo6/fqq68W2+qYz7LCVkiSLeasjehtyHbX5+/WNtzWBSUjm6N2CjMI2b//vbeK\n", - "bVqf9byIiFSMGDFixIgRI8YFI75IxYgRI0aMGDFiXDCeGLV3+PDAUvHiILQ5X4o47SgIAJOOC7Cr\n", - "3QDxLYUCojhPhdKEz5cLh2wpbh8CWlYRYUbIWkSchTu5FtldsvCh+J7MKA50aJHQqgoLHz0KIk8K\n", - "VtviuzHsBSiyWhbPljo9jnwfdJZWyPIEUKm6jdOV9vDUYWxCxQu0F8WXZmZnKN6rECYLmdYFxl1a\n", - "OG5dYORFUaDY247nTBrVzN1wVYDP+0NYWIWgZdASw4nD422IWN0TxCmD4dgFo4RsVexNF2fTIrQ4\n", - "5wU8a/b3vU3GhRO7tyvpRhVxn3evK6CR2uLLxd+yKKqZWb1GV3ruTwoKL0jB+n7pGHz3noszDZ4u\n", - "WgyYl90QX6SchTyr4otjQTRLuq8jlPEUnkntlvfr3UtBqPr22+8U20hpvf2OQ+GP64EqXE5V7Byu\n", - "rXfm9zMHtUd/pnmidHOC73sfPjsKHmBzuScZoPp6x6+V970sYtsahfwyJ7DLFkWuZb8UhT985EV7\n", - "KbbVQsKTorisJFtgzCwP/XoodlW6k7S0VmCgb9tiGWhc9ZujL1dJqhi8/W4Qu6v78rXrYYxfeur5\n", - "YtuUlNbcx1gDY/Jnfvpjco2hUQZIGJhOvP/VILLX4taMVLyoZpiftjZd2PzMM6HvLoVbPT4IdOOK\n", - "oDujL184ro6he5AvKLVIaUMm83Qdv6ETtpnZrR/8ANcgPkbdQKnW9l3SQTqc/lHzhYjTkXhyLDRe\n", - "F1TUaLw+17LChJ7z4wNPnuCQzWSe4vOGc8JQ6EEXVq8XbZ4JZb8FMby6zVMOoM+zcVGVwJ9nJ7Nw\n", - "bUrpcm6bTMI1KrXJ/lKWpKSCKhz790jz6v1soX26z9wothWVH4Ru7WNM9EG36rOeEoBtwYXoc6b3\n", - "5P79cB+fueHHeup6+LsqfeLunSAb0ISCcvn9X5UiIhUjRowYMWLEiHHBeGKI1PGtB5aKY2wFSEwi\n", - "abiDGVxsZ/5GvjEPSISKeEdABOay0mTdOV2ll5GeTCGu1gsiwqN19ehoPZMV2XwB9Eve/ot9iHib\n", - "KFlP3KYp5KZ48bSnTtDhPPfERZuCOU1r7UF4qysyCv/G8vadYRU7FUF9BUhMDxYCiTih5znruvmq\n", - "ogpUQVODed16fK6cZjMV74d7kZuvSPYvB2RREYk6nM95reo2TwFqMhB3ZIiip4L+DEfht1rDiufX\n", - "H7gAlQLkhazIGljhV4ASTKfS1ljpqLA+waq7IStoIoupIF1sk5WVGxIlMnF7f/fWrXCeaOOdHV0F\n", - "hXNTd+ReL3zvyhUX0VIgr3YiHB/lmYiCcc6KHI6G4Tz7sHO4fHVXPuPv/Phj9Ov9nZ8qtrHF7j+8\n", - "X2xj+vepoEkUhT547N+roJ+yssFcVqH34UC/J07cTaxgF+Ks34SwfSGoTgr7h6euP1VsY3KLrmaH\n", - "EEXP8O987veQp3Jy6i7q40H4niJSfViMqP0IEZmFODCnuD93E79+WowMpdbcvdtB0L+JdHq2m5kL\n", - "ZYdif0JH76Uk4NAmpNnwPnF8EhDxjiLnEAMrmsR+lJXCXDtKfVzzCNOpi5PLuIdVQT9LSbgnw7GP\n", - "P1Ze0DExAtKgSR512E504N7/5ru3/FpZB05qbV6+FFzMT6X+KMq62UySMoi2Hx76/WziGNlME2BC\n", - "36GbQmnh4/UAaJLO/8dIgEjkWfNP//iP4VrEfoV1F7e3fY7nfVeE++Gj0E5Mjrl0ycfk5gbHot9r\n", - "Vragm7+Z2Zvff3Ptezdv3sS5iyUFUPeyiP1LOBdlc4hAHh4FdFafCQleI7K6tCFQ77okb/TBLNQ1\n", - "UQAu9yNxW+fYnonFAWsSPrgXxs7Dh95f6LI+kiSGZ58JlT2uP+2I5D3UFbx/xytblGthPDUloYDP\n", - "iWtXvf6i9tnzIiJSMWLEiBEjRowYF4z4IhUjRowYMWLEiHHBSPJ8xfr2x3PQJLEPf+RZW4iwnCRj\n", - "STV0EP1d33N4/konwG252DpsbwSodGfTaRF6atQb6lSMIpDDHy4Y1iKvxPZ74nHB5lIaj0I0peAU\n", - "PmUQxia1oscn7VIR0RudnVXoRi8adSWniFoLHs9RSHUpQuUy4FbSPipYLwHan4i3F6klFSeSUlMv\n", - "KBb5vH/fKYtLu8FHpVIVqrBwmxcPJtARhMVXCnriWKcnTg9swm12og7sGQW43p4ULO7suD8PPa3S\n", - "xBuPflf0UToVyJq+ZJpEcADBsBaDpgPwjtCyvMcqou3R20T6yRk8gI6PAy1x/bpD0c8/H+DpgdA+\n", - "dFSvCDxO2PvO7dvFNorx63Wnm9yrR8S+h4EOOAA98fLLN4vPsveIXs3MeqDs1EeGPlsKxXM8JZk6\n", - "K4dtJ8d+P1kYl079Wgz1wYPQ1kNxfaY/z1SLsmKeUFH0/XuBHutIUsIekiv6PaElSIuDHh6NvP+T\n", - "AqQnkplTGnr4x4eB7tDxT88gJhOYmV2B91lJBPWFs3jV+8kSbuCzQmzt10Bn50Qo8DZE9kpjpmh3\n", - "9cUqxvhQKkDgGIlJEWKMHYrcS0IZd1G8dq5UB76vnkmUCMyFlmS/U1qe/kS3bjl9x6LaO6CxZnIs\n", - "0m7HZ07j0fdIx9q7oAN1PPGZcHTk1N4lFEE/PHK65+wk9PEW+g4L5pqZfeO/fQOXrP5s4TzV2+3Z\n", - "Z4IT98FjF5Yvlpi7hUZttSBUlzHOOZ7Xo+OvEJnLY5vJCSuVQsb0TPSx00QCUlYWYzjse2tTfMwO\n", - "1vszfbs4rvtS2eGpa8+Ymdnf/9e/K7a9+NLLZmb21ptvFtsuoxi2Pk/5DFrKmKB/lxamb3Aew2XX\n", - "pLJAG7TcnlCgfCZ897vf8fPE+FhK240w7nXe4dytzu5JKbH/61P/t/2w16WISMWIESNGjBgxYlww\n", - "npjYfDpd2FxejA0iyoa8ffPlT9Efikj3rrg7MmuMaVor6zmVJdV7yrpeeNOuSx0kvun29W0Zx60I\n", - "IkQnWK31Q2G5proOIFRWhOvRIxfIma2uNLiqOhV33gbetGfL9ZpH6uLNum6JvFVTeL5Y+gq71gwr\n", - "p041rCrHE1+tMHW2VvN3azp774sTNVO3V9x5kSa+lPMk+lStKSIRVgnTqdQaQ4p/BvFuKpBkks/w\n", - "HbXJCJ8fnfiK9Nq16/hMHHuRbLBY+PXToF1FoWx3IoipFNvb3Az3TtEfImYHUustRUq8tgmRi0wQ\n", - "mVIa7omm5O7ubeKcQjv0ei5sp/2COjHzPKtiU0FxrortiRjN5+oUD2GreVCgSkFr40fYWhAdffjA\n", - "7ReevvF0+F4mDtzo23W5J0RO220fp/Um/6Zjt6dc7+8tcb6+0nzwMAhG90QIakA1T5c+di4BRajV\n", - "vf1p3aAJKAmQ1a3NMHaXS/+M31Oh6Rhp4pOpWl2Ea9zY8LF+chrufy5z19lZaGut/8ikBUUpaZPB\n", - "sdYSm5QNON9fvebXX62Gzydyr0tEmASR5ip9Kfeki3POVxJlME/i/4nC36w1Kog0z1dT8inG1tV/\n", - "H3ObupJ//81QH/GKzDFztPEiZ3KC20987GM/bWZmtUNvw1tAYnWeoKCbc5iZJ9T0h46mHLwRhN0q\n", - "1N+7FM7lCKL0plQbePHFF8zM0Sozsze+E67h6rUbxbZ/gNi8If3vBbjIqyXEo8ehP48FJScC+eZb\n", - "Ac3RMclarIqq0brgQx/6SLHt7HQdYeWtOJO58+mnA0pDFMrMrQ7UYqS7Gc7p4BEAE3lRAAANxklE\n", - "QVTqGkof6uG+0nLHzOwBKiB8/5//udhG24dNEdvTDV/n/aeeDdeodj4V9N0JUOemJDYUtRal/3Fe\n", - "u3LZxwmR/S2pE8gxrnVSOT9LQY8oNo8RI0aMGDFixPjXivgiFSNGjBgxYsSIccF4YmLzFz9603Kh\n", - "nUjtlZR3gEPNzf0bxZYXXgiFDJ/edREh3YvrAqMS5tOijYRA6fujUDjpPoWxWQRRPUNYUFIFy4QK\n", - "T04dRm5BAKpC8SEomhQiTvWOIVWjLuYUe6pjNoW9CjVSvFqSc6IAuSTFHVkYlZTRndtOzzz73LM4\n", - "llwr6KmG+G2lOFZVBOiEYFUAXhQaLgktC1pAnZ1HBY2QYP8iTsd9PREn8D2IQxVoLYpwJr618CWa\n", - "+fEb8A8byP5IFbO/6PXTRV6FlRRgqo8WnYeV7mVx7eQcYftMnKVr6GMFnC4Uyyb6VbvtlPFiSUGr\n", - "UFBJuP4HDxyepyu6UoCP4NBdrzssfnwcKIIuRPzPPXO9+IyO4Uo70QFdnZg5aFUUTKYkF1829u2q\n", - "3H9S6TUI+kcD9WyDm/JI+hXajg7vZi5yPj11yqIGbx2l8dqg2fNcqeVwoqTn5nKt/Gsmrs/VcjjP\n", - "bSkyzLlLmHqb4dxzHbtIHlFqmXNCIjwC+30HjtnqT0V+RvsVk1IqQhk+uhfE1jvbTot24eKddf3c\n", - "S5PQ/uoZlOM+JizuKufLpACdppl4oj4+dMDOhAJihsx8ZT4Lx1BaZgRZBAt5n5y5PxLH30KKa08h\n", - "WL523ftuH5SeioiPjsK2my88W2z79rf+u5mZye7spZdexMHwj1BMLbhyn4i33MlpON+nnr5RbLtz\n", - "OxTSziXnaIykhRtPPePXk4e+VVlxGw/bDpEA8uD+A/l+OKlLl9xbjdSvejvxcy0CT5qzJm7/D5Ag\n", - "pM+OOioZnMl4ytE/SIX3paDxjafCdScydy/wbFW3+SESmVIRxV8FRZ9L/+PUcvv2O3L8cA8oo9Ex\n", - "0erA70zE/qxAsOJ3lfCYV4ttx7hG9ZTkmfwATvhmZjduPGU/9/P/ZxSbx4gRI0aMGDFi/K+OJyY2\n", - "XyRzyyQ1nqnrKnocDsPr/O6OCxGfvRSQqEbX30iZkqnpmnxzV6EuV8IU3WqqexOCvo4Ixpn+OJa3\n", - "bwrQ61Iv6BDCNk01pZB9InXiKoUD+RDn6ysdLtK0NlwPK7GavC3T+VpFlGOs+s8k/bgJd1a9HiIr\n", - "dMzdFNHjHKu6E1mFUDCub+FliGMH4qzMVfJUaifWkPZ9cOSi7DJRR1nh0pIiA4JQrzhawbaYik1D\n", - "4Xor/YRp6lonsUDsBCYYoX1a4mI7ACJCVIPO0Waedq/oH9FJbX+uJrWtT4/CvdNkgzkQmVz6KYXs\n", - "7FdDSc2nE7HWvJrOwvWMxaaC+Jwip7xsXemz/paAtLaBc25jVbdQx37ODoneL1hYyNGLVV1jvV5Z\n", - "RYTS1MyOZZVMewB2iWrV91wxCEwHjkjswOX88JG78lOw3ZJVKu9dTdqumB9kUck+ztV/re7fp1BV\n", - "5xXWJqP41sysdxbu2UzQz+kC40OgjiUQ+DTzFfnOVhiDusImcsx5TZGBzc2AxGkSwxEcw49FlE3r\n", - "iGtXnyu21bsBnVoIEj9fAmHou3i5hbmrmJ+kvXhOWpuMaf81uYYSUuwHA5kTafEilgxEERdLh26+\n", - "9+Z3zczs6Wdu4ny9Dbe2wvUrSnt0HMbwZOpI7xnqBN6QumpPPxv2dxtokZnZiy+HNP2ZzF0Hj0N7\n", - "9jEn1CRh5vgstBcRNzOzUoLEmqpf/waseJS56MEB/6zn/ZkWFwtFwtFOtGQ5PvLvN4GqH4k7O6tY\n", - "aN/9/psh7X97y5Er2gSonc39h8H2YVcQrk4N9e8q3sc3gQAPe+F+Hn3nu8VnJ8ehLV5++cVi23AU\n", - "7km14vd6VqBKilxiPEmizD2gZK2Oo87s4xmeDw8e+vi/DuuQctn7JFmPS5LEcHQUUMSyWJLsIlHn\n", - "8MhtKjgWte6qot3nxRNDpIa90Y/+Uox/F/HmW2//6C/F+HcR//itbz/pU4jxY4q/+y9fe9KnEOPH\n", - "FN/45jef9Cn8m44n9iI16o1/9Jdi/LuIN38QX6T+d4l//NYbT/oUYvyY4u++Fl+k/neJb/7DPzzp\n", - "U/g3HU+M2qtUMmt1HGIrWYD9hn2HOF98LkCFN/ZdHNYAFVFK/HuEllWUXRTNFVieYmCKKasCMZMW\n", - "mYnYm34S6phLleWt2+7ES+ErxelmLkrPxFtnOhti27rAkiJniunMzDJ8roJ1Xuvjx06ZteAAXBMR\n", - "8RDQtqpCCXfSz2dry6m9BdqLxSnDOU1x3uJ2jgKeJRFbVyAerIsHFanCre1tqzfqtrW9bVU4mnc3\n", - "HAIfA9ou49xW6NFK6B/qt0XPGnVbztA+uQh2e4CglcarFM7q4tlC6o3uzHJ8UizqIkxaajVRINx3\n", - "9aJpXA7nrv0pbYfz3Cg73cc+e3U79HF1R6dXlVKGBn+gkhT8XkLRWms4LbmESZu2HV3kz8Sr6iMf\n", - "eS1cD/xZyis8DoqXimCX51sWYSmh8Fq9buVy2RqNetFk5ayy9tuaTDtz3MfxOLSniuMJpw/G3tbd\n", - "HM72Iuwn9dYTuvXKlUDL6b2mz5BSdRPQN6Q2ajKGR6AHtWjy8XEYpyqETVBmIZPEjloj3GP1p9mH\n", - "952eE/8urxQhD/sjpbwprtO8nY8fOY03RnH3kdDtr7z0Svi+uFhPpigMXhKncIydDRHPU1xNylwT\n", - "S2aYp5eWW45/qxC5a2JHCbRsw9a9+kixmJmdwaG8KZ5+T8ONPIM7ejL2/sf58bF48r17693wu+ed\n", - "xqzgPt5/4ELt/UuUj/j1k3rsS3H5BvrzM3AnH419DI+n9PHzOfHSTnCsV8Hyxkag9ubi1Vcuh23q\n", - "SzhDkXR6IZmZ7SKhpgqx/c6WJwxwTnjuORfMU4LSEgd8jvt7d7zaxH/8T8ED6+79u8W2xyeku7zf\n", - "d9rheTZTmn+5NJvPi2LVly/7Ob366qs4N6fH+MzUOZlF3acD3y9d41NJFKJ/38mRJwW1OmHcPwbF\n", - "15ExwQSdnV0fp6Qvc5n/9vbDnNCQ576/H0iyBebJtniF6Xx/XkSxeYwYMWLEiBEjxgXjidgf/Of/\n", - "/J/tr//6r3/ch40RI0aMGDFixPgXx8/93M/ZX/3VX5372RN5kYoRI0aMGDFixPj3EJHaixEjRowY\n", - "MWLEuGDEF6kYMWLEiBEjRowLxhN5kfqLv/gLe+mll+z555+3L33pS0/iFGL8K8WNGzfsQx/6kL32\n", - "2mv2sY99zMxCpfLXX3/dXnjhBfvEJz5RVOaO8ZMVv/Irv2J7e3v2wQ9+sNj2fvf2C1/4gj3//PP2\n", - "0ksv2Ve/+tUnccoxLhjn3evPf/7zdu3aNXvttdfstddesz//8z8vPov3+ic3bt++bR//+MftAx/4\n", - "gL366qv25S9/2czi2P4XRf5jjvl8nj/33HP522+/nU+n0/zDH/5w/sYbb/y4TyPGv1LcuHEjPzw8\n", - "XNn2G7/xG/mXvvSlPM/z/Itf/GL+2c9+9kmcWoz/yfibv/mb/Bvf+Eb+6quvFtt+2L399re/nX/4\n", - "wx/Op9Np/vbbb+fPPfdcvlgsnsh5x/iXx3n3+vOf/3z+27/922vfjff6Jzvu37+ff/Ob38zzPM97\n", - "vV7+wgsv5G+88UYc2/+C+LEjUl//+tft5s3/v707dkkmDuMA/r3htta8Du8FQSsq7G4Qmpqq9TJc\n", - "bBAHW9qC/obaI5qiwK2msiGjVVpcdBdSsEsdoqUabHga3t57qzcL76WTk+9nU0/5wdcHHzh/vyeG\n", - "SCQCVVWRTqdRKBT8Xgb9IPmwf+Hs7AzZbBYAkM1mcXp6Oohl0X+an593Byn/0SvbQqGA1dVVqKqK\n", - "SCSCWCyGcrns+5rJm8+yBv6tbYBZB93Y2BgsywIAjIyMYGpqCo7jsLb74Hsj5TgOfr2Z0m0YBhzH\n", - "+eIdFCSKomBxcRGJRAL7+/sAgE6nA037fcicpmnovM53ouDrle3t7S0Mw3CvY50Ph93dXZimiVwu\n", - "597qYdbDo9FooFKpYG5ujrXdB98bqbcnLdPwubq6QqVSQbFYxN7eHkql0rvXFUXhd2BIfZctcw+2\n", - "9fV11Ot1VKtV6LqOzc3Nntcy6+B5eHhAKpXCzs7Ou1O9Adb2d3xvpMLhMJrNpvu42Wy+624p2PTX\n", - "adujo6NYWVlBuVyGpmlov45qaLVaCL2ZNE7B1ivbj3V+c3ODcDj86WdQMIRCIfcHdW1tzb2dw6yD\n", - "7/n5GalUCplMBslkEgBrux++N1KJRAK1Wg2NRgPdbhfHx8ewbdvvZdAPeHp6cmcMPj4+4vLyEvF4\n", - "HLZtI5/PAwDy+bxbqBR8vbK1bRtHR0fodruo1+uo1WruLk4Kplbr79y2k5MTd0cfsw42EUEul8P0\n", - "9DQ2Njbc51nbfRjEP9zPz89lYmJCotGobG9vD2IJ9AOur6/FNE0xTVNmZmbcbO/u7mRhYUHGx8dl\n", - "aWlJ7u/vB7xS8iKdTouu66KqqhiGIYeHh19mu7W1JdFoVCYnJ+Xi4mKAK6d+fcz64OBAMpmMxONx\n", - "mZ2dleXlZWm32+71zDq4SqWSKIoipmmKZVliWZYUi0XWdh84IoaIiIjII55sTkREROQRGykiIiIi\n", - "j9hIEREREXnERoqIiIjIIzZSRERERB6xkSIiIiLyiI0UERERkUdspIiIiIg8egFnCUKNTa56BwAA\n", - "AABJRU5ErkJggg==\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(transformer.deprocess('data', net.blobs['data'].data[0]))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first layer filters, `conv1`" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJNCAYAAAARaCA+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXmQZVd95/m77737ttyXysyqytpUpdIuVkFjNrEIjKch\n", - "mMF2e6Lb45ihZ9x7G7dBEkJGgJBEY+PGbUfHTAf2KOwxmIhxNNhWu23RIDAGyVjCgCRUWmpfsir3\n", - "fPu79775Q27s8/t+K/L1RXbi8fcTURF1fnHufeee7Z1893u+JxoMBgMTQgghhBD/XRR2ugBCCCGE\n", - "EH8b0SJKCCGEECIHWkQJIYQQQuRAiyghhBBCiBxoESWEEEIIkQMtooQQQgghcvCCL6L+4A/+wK6+\n", - "+mq78sor7WMf+9gLfXshhBBCiB8IohfSJypNU7vqqqvswQcftL1799pNN91kn/70p+2aa655oT5C\n", - "CCGEEOIHghf0l6hHHnnEjhw5YgcPHrQ4ju0nfuIn7HOf+9wL+RFCCCGEED8QlF7Im509e9b27dv3\n", - "vfTi4qI9/PDDQZ59+/fbmdOnX8iPFUIIIYT4a+NyL+1e0EVUFEXb5jlz+rS997b3m5nZV7/yZXv1\n", - "a19n1XJ4XVzE+xQL+ADFYhjr9vuQp9tNINZph7FuykqKP9JVS2F1/eInfhHy3HbnB/FWruitZgey\n", - "NBqbEEuzsJylEtZLpVwOy1itQJ5i4S+f5at//FV79WtebaU4vC4yvPc9d98NsX/+z342SPeTHuRp\n", - "tdoQ830jLmH9Fkj/qZbjIF2pYJeN4xhiBX8r0jXv+bcfh9gHP3JXkM4yMnBIbJCGsbT/l53qK3/8\n", - "ZXvta15naYp9MUnCWNbHe/f7eF1UCOuPjb1//x/+HcRuv/X2IF2KyRQAlWdWqYT9ZXJqBPJMTI5D\n", - "rNvvBumz55Yhz4kT5yG2tdkI0rHr52Zmn77/U0H6Qx/8wPf+/8UvPWRvuPn1lpK28lVVrmD/qVQx\n", - "Vq2EY6tYwjxpgp/n27jb7UKeThtjH7zrw0H6bqIxLUZFiJXcmCmR+TSOsT59vUQRmXPJu4te+/k5\n", - "4IEH/rP9yI+8zXpdnBMGGfbhn3tf2Bc/Rsbj1uYWxJaXVoJ0o9GEPFOzUxibCvtnrUbmyjLWZ9IL\n", - "n6fdxPktSzOIffTe+4L0e9/7XshTrtYw5tqmVMQyFf6iTR/8oz+yN99yixVIW7UaLYg1m2FsQMpd\n", - "LJA+5TrHPZ/Atnr/7bdDrBi5DlPEcja28PuwPjoapOcWJyHPdx59Gj8vDevuptddB3n+5OsPQ2zv\n", - "3n1B+sMfuAvyXI4XdBG1d+9eO/1XfmU6ffq0LS4uQr6vfuXLZmZ26tRJ23fypB298uALWQwhhBBC\n", - "iL92XtBF1Mtf/nJ7+umn7cSJE7Znzx777d/+bfv0pz8N+V792tc9/5+vfNn2HzjwQhZBCCGEEOJv\n", - "hBd0EVUqlexXfuVX7K1vfaulaWrvfve76c687C/edCwuHrAsNeu4X/OyGH8zHhnBn87HJ+pBulbH\n", - "PBn5Gdn/pLm8jD8Zd8lrFcNfPoG0hz9lb66H99/YwFd3RdISk9PhK5Ndu/An6lqt7iJYd4PBX8au\n", - "u+E6m5mdsV4vfPWZJlhPjG4Svvss+J9rzaxcwZ/Jy+61UZ28LmHVG7ufssvx5X/a/qsMBuHdCoXh\n", - "9lD411sZqRf2Cixzr/OSv/Le4/CRw1auxtbr4hOm7lVykuIraf9a18zMBv6Zh3u+tuv7Efnp3r8q\n", - "NDNrF8NBSt742RR5nTc3E/4MH5ex7tpt/Dm/2w1fmbBXxJ5C4S9/yr/i0BErFMpWIq9/y64M/lWl\n", - "Ga8X/1puda0BeTbWMdZzrzRT3+hmVmDvmx0ZeR2cDrC/ZFkYy8ir86SPrw99GYpMVkHe5/X/Yi45\n", - "dPCA9Xtd65M5MOlhOT3sFX+3hX2j3wvroUIkDKMj+Jqs5mKDDMdjl/RFP1f2yOt19jrP4+ckM7M0\n", - "w77Q7/dcHuyLxcHzsX0HDlgvSSwukXFMYgOnLclImSLD61KvSWGwV7298PlGKlXIMz2L7ffNrz0V\n", - "pBcXXwl5bn7ryyF233vCV/wvevHVkOdlN10LsUe/9l2IDcsLuogyM3vb295mb3vb24bKu2+/foX6\n", - "m+bw4cM7XYS/cxw8eHCni/B3jkOHDu10Ef7OceSI5pa/aQ5dccVOF+HvPHIsF0IIIYTIgRZRQggh\n", - "hBA5eMFf5w1D31kR9HuX3x7+37hI3jlPz4QajD2LqBnaNT8GsbGJUGs0Oj4KeVbXiE6qtf17/eYW\n", - "XtduhVtwxyfwHfCevbMQ239wIUhPTk1jmZw/w+YabvfdWMfYIAnrM0uGEHwZan9iojlh6qbIv4sn\n", - "egSmD4Dt2UQ8FhGdRjQIYwW2N5tQrYbv7Jm+o1zCMvit9BnR8DDdWc+NhW6PaDK6pN8VwjIMmBUD\n", - "oeB0EkkP69xrf8xQF8LG6Mw0bkOe3TURpHfXsQ+3iA6l1Qy1RRd6q5DHs7GFdT4A7ZhZw7VNt0N0\n", - "jES3uLq8Ft6ngeVmlgrj46FucXoa55uxcbSM8MREi9cnWiM/1oyMNWZpkjofnIj8jc2sZjIybj19\n", - "ogMDiA9PYwvnro6ziBifwjm+Pua1omaxsy+gxSYaz34z7B9U/zTE8GN2AiCKNLOBsxMoFIgG09UV\n", - "+/gSmSt9H2oRixoik7J0iOcrEgueyC0xzp66BHle9cYbIbayFH6P/sav/ifI85kvfwJiX3zrN4L0\n", - "Jz/ym5Dn1x74MMQee/RJiA2LfokSQgghhMiBFlFCCCGEEDnQIkoIIYQQIgdaRAkhhBBC5GBHhOVV\n", - "Z7SYZaFQsNNGseTGKp4DdPLkxSD9zDE0WDt4aB5i+w6GIu76GFbD2AgKE8sRGtR5mLhu74G5IH34\n", - "yr2Q59BhPB5nbDQUTF5aQtH6uRPnwjwXVyBPcwvrbjAIxcP+HMLL0U+80R0TWZPzmJyg2QsjzcyM\n", - "nP/kY8yssUjMIXtJ2IdK5DpGrR62e5mcyxcTYXniDPh63kH2MmROWNrrkfP1mCDVGXCmQ5j9mZlV\n", - "3Dlx/vPNzHrE4HB5eSNIX7yAZ+Cxc9wm3Xll+w/ieDx0YA/E/LlfXSau99e0yVlhRPy95cZDq4Xj\n", - "utfBWOSeb3pqAvKMT6FofGHPjLuObHYZxfkGIIrfAjNLdCE/Zs3MMuKWmrm/qZnwOk2J8Nq1DRn+\n", - "1h3CbLPTQpFzl5zD57sZO/twdBSF+gO34cWbWpqZpURBDeJ98nxFchahh9mpMiPdKA1zsqmy6OYg\n", - "tgmA+MVa1ZkzJ6SxEnIG7WCIjQFd8r09sxD29XViUPu1L38TYv/zP35nkP7i7+J5d7/4wV+D2D3/\n", - "178M0jf+1o9Bnv/ymT+B2I03XAWxYdEvUUIIIYQQOdAiSgghhBAiB1pECSGEEELkQIsoIYQQQogc\n", - "7IiwfHyy7tKhGLNNhJ5Fdvr76VAYeOLkEuQ5cwadjvee2BWkD12xC/JMTuNp0/UKUeo59u1bgNhe\n", - "5zy+n+SJMlzPfvfPTwfpRx/Bk6ZPnzgbBsiyeHQcRavjY+HzFUvDCcu9AXREBKqlItZT2TnlMqF3\n", - "IcJYyQkoC0wtSfx6/Yn0XhR8OfyJ8APiEh0RpSe6fGO9FEi9DJxDMhORMhdlf/+MylaRqtswQQy9\n", - "rd3F8Zc6Yem5c+g83GyiY/jIaLjZY3ISRdVT7uQBM7N9+3cH6bUNFKR6xkbwJIBqGQW/s7PhyQYj\n", - "I7ghpV5DsfLYaDhmxiZwXE1OoaC5PhLGmFi6tYl158kSIvglwnJ/qoANUBScDbBPZS5fShTUJTL+\n", - "vKP+gPTFfh8F1B62eYA5nZcrYTuMEFF+tY59oeeE5P0m3rvdIptwnMI+IvMUG9ueiLi9MxU+1jte\n", - "F/l5mHx81iebDlw5S2TjDDuxIBnmRIQM2335QjhP3PjyI5Dngd95CGKPfv2xIP3eu38a8rz3H38I\n", - "Yv/wn/1wkP7XH/qHkOcP/p+vQ+zHrrgZYsOiX6KEEEIIIXKgRZQQQgghRA60iBJCCCGEyMGOaKIS\n", - "p7moOU3C5N7QnM7MbNccnhA/vzvM5803zczOnkJTwIvOODBN8N3xwm5ipDeO79nhugXUV5WLoS7j\n", - "iW+dgjyPP/YsxJ74VhhbX8WT5cenQ73F4r5ZyDM9gzqUSjUsU5Jub4ZnZlYohuvuAtHrDIr4bjyu\n", - "hF2tQrQqzGzTnzpeIMaazP0ucvmYISej6oz7+sQzc5CiZsBLw2KiNfBlMjMruvoslVDckBCtiK+H\n", - "ghdJXIbYtTs56B2M/MzMer2wjldWNiDPqVMXIPanD38nSM/M4ji+/kWHITZWC/v13MwU5PHUatin\n", - "6nWsz7rTy8yQ8TE6iu034bSbI2OopSqQv0u3GuF8d+k86smWLqB208MMVVnfKBa8WSMx6SygHihx\n", - "WqqI9KmsgPfquPk8MqzzPjGR9XTbqAvLiGaoOhJqoiaJeWmlgn0hc9qmlGjMeh3URHnhYJHoJIeB\n", - "jdGUaI1Sp01LEmyrQtHVC9FksXKmWagLY2WK2JwOEWRiAtvhzInzQfrc6XOQ5/Vv/SGIPfyVULf0\n", - "jv9pN+R59ZteB7HPfurBIP2qN78I8nzjAH63Ly9tr7m8HPolSgghhBAiB1pECSGEEELkQIsoIYQQ\n", - "QogcaBElhBBCCJGDHRGW99qhWrffC8Vu7MRoJo4+enVoWjm3G0Wri/tQ6H3+bCg2b26gephoza3Z\n", - "3F58vbqCArWlb58M0t99EoXlx59GwV05Dte4h47iaff7nZHn6DiKXZlgGwSb/eHMNivO6M4L1M3M\n", - "EnJie8mJXeMSrt+ZkNULtLl+mtyr5AXbQ/694OqFCe6LxBGz5ITe3lzU7DLidif6Zc/nxedmKPQs\n", - "ETE/wxsHsnuPT6BhpP/ARhMFuOtruPHh1MmwX3/7sWOQp1rDDRtjzpC3VCAbERyjo0ToTZ5v1Jly\n", - "VqqsfrGNV9zznT6Lm1aWzq9D7OLSWpBuNrDuSkOYwWbEBDElMYO+TsTLxIjRC9fTDOfhAemg/W5Y\n", - "BlLl1u/jvTztNs7DRTJux5ygf3SM9FfyzK1mODd3Gk3IkxJT0ILbGMQMf9kGGywRGaNsbnbff30y\n", - "nxaK4bxYImbJbI6FjTN9NNZlfT8l4nZPi9xrwRlLnztFvueKOP6vvD7cbHLq1HHIs3sRN1Gtng83\n", - "vLTXsY33HcCNa1uN7c1uL4d+iRJCCCGEyIEWUUIIIYQQOdAiSgghhBAiB1pECSGEEELkYEeE5bFz\n", - "RPanmm8sozizT07XnnTux6PjKDDct4jupKMjoTBw+eIW5EmI0DpiR947zpxagtjFC6GwFE5ZN7Oj\n", - "1x6A2P4D80F6bgFPuy+4FvQnqpvx09H98nlYF96aE5KXiTN3MapCDK4rk5PQifC64Cy12UnoTOiZ\n", - "OHFmXMZyMryIMyOCWOYA7U8+7xM35DRD0Spo1Ekd0Gd2QlYmymf03Y6JuITXVUlfmJwO3br37EVR\n", - "58qlNYitXQqFnmfO4fiYfhbdyBd2u9gQwut6HYXlERHc+9ZbXUdRaauJIudGI4ytr+Emks0NFLL6\n", - "TRwjo3XI48cHg80bbDuIFwF7p24zswHZHNF3ouqUbPBh4ui++zxium/d/vabclrEsbw+gm06Ohpu\n", - "MmLzRpOIxleXw/65uYHzfrWKc1epFM4dbLMCqU7MQ1prQBzL4e5kvkndhpcsY/M3EcC7+bREjiyI\n", - "SBuzsns65Hum5L5r5/fOQZ71i7ghpRuFfWr2mnnIM7cXy/6tR8LTAFaXsE9NTOP429wc7sQOhn6J\n", - "EkIIIYTIgRZRQgghhBA50CJKCCGEECIHO6KJ8u+UK5XQbIsZyG1u4jvudifUUk1MjUKeOjlpfaQS\n", - "fn4yhnqERgvfkSbp9roTZog3Mho+39Q0ardmZlEXMjYevp9PEjQz29gItWLspPeImcN5HcGQy+k4\n", - "dvcaoG6CGTiWnFDC6+LMuK4ndXoA9nzkYHnL/HXkNHhG151Ib+yUdXKvJA3b3WukzMwyci+oF6Ix\n", - "Y3izPa91uBwgwSLXMY1JzZVzYQE1Uc0jqD84Vw37fkba79KlVfy8Wjgma3XUqniOP4dGfutk3th0\n", - "Y4bpmFpubjFDrRHTxlUqOJfM7ArHdpXUQbO5vdlfm2hOBqQvekNVqm0iEpfEa6nI8xnRhSZOq8Xq\n", - "ZUD0OZ7MsJxjY2iyXB8J+4LX+Znx74uWM4hlKp9ijO1XcHMV05MNZVVM5reMXenqLyH6ymLJzxNM\n", - "x0QLEaRiuI9ZuYx10Cls3z+rZE7vNsP5tFzGfjAxh7rlC2dWgvTpZ3BsH776CMTm94f3Ov70Bcgz\n", - "txdNuTsV1DcOi36JEkIIIYTIgRZRQgghhBA50CJKCCGEECIHWkQJIYQQQuRgR4Tl3r8wcsaBJSLO\n", - "ZAdgJ06gubmJ4jd2+nTViXcrpBYGZfzAdpucmO6IKyicK9dCIXmdnFpfruLnNVru1PEuil29VrlI\n", - "xH3MjNKLnIezajQrOXPGiIhBM1LnaT8s+4CYIDKjSW9GlxFRJ/Nh9ALmxAvGL0O/5wTi5FT3iEg2\n", - "vUlnQswF2XVeWF6uYB7WppF7aLZ5gNHvhs8TkfosFYgBpxskY2Mo9F5cRCM9r2DeWEODw14XjS1b\n", - "TmhdHsIslZlfdplpbhTea3pmGvLMUOPXMB0TU1Jm6lpxdVcg9cvawdPp4bgqkJHrNzWwjRB+zjUz\n", - "6/V9PiJWJtf5okfM5JE5cDqqxHB0pIYbg7xbaruJRszMbNPr+StVvDcTWg9jpDnM/FkkmziyDOcl\n", - "PzezDSne4NQbpZpxAXyx4Od9LDkzUPbzFIX0M//M7DvMyEakXbvDMbl8AU16z51Asfmeg7vcdRuQ\n", - "Z2MV56Bh5pfLoV+ihBBCCCFyoEWUEEIIIUQOtIgSQgghhMiBFlFCCCGEEDnYEWF5mnqx8PZu0gWy\n", - "3vNOsszZtdlA0WpW9SfZYzXUiLNqkbhzewZwRrxZxQlQmRC63cZyps55mLtLhzfzJ8abcfdsv35m\n", - "LtWMSiUU4BWJg3EUM2FyeF05Jp9H1JklJwLOSKaI9J++y8Zc8BnebZm5L7OCRk4szFx/M9J9okLY\n", - "Z0vEMZkYMkMZmPiU4QWpRCdMHaBr1TBjuYQXzsyMQ6znBP0x2VCAgmazbi+8jgn1PQcO7oZYXEHB\n", - "qBcPV2pY50UipPVDhImJu0w46wS+Pb+zxsz6xI3c0+6S0wGISL3jNsD0UyY6xut832B/Y0fsNAI3\n", - "L2Vsz0hxe2FyHOOGm7FxdLOOS2F79cjpEhEru+vsbMMGcxWH3TtDbIBhMLf+LGGbVML2Yt8pmatk\n", - "VndlIpL333Vs/LPvELY5yTMgfdGi8PmKZDNGh5wOUHb7ViZ34eaPfge/M9eXw9MPxifxFJN+B/sL\n", - "G5PDol+ihBBCCCFyoEWUEEIIIUQOtIgSQgghhMhBNGCOXH+dH8jeOQshhBBC/IByuaWSfokSQggh\n", - "hMiBFlFCCCGEEDnQIkoIIYQQIgdaRAkhhBBC5GBHzDbfe9etLhIKttjJ5BSn82K6rwJzE3O3p4Ix\n", - "Eis4o7l7P3gv5Lnt9tshFpfDD6zXRiDP8adOQ2xuX3gidX28CnkunL0U5qkyczpirNcPjcpKxAH0\n", - "7ns/CrHbfu7fBOkucZBMiXFg5gzjiOeiVYjBqa87ZoxaJEZzqTMTTAfYDz7yIXy+O3/+/UF6QPpi\n", - "o9HGcjqTTHYifZah6aE32xsQQz5mCug3aCTkuvvuuwdiH77rg0F6ixjPdUj7dXrO+JWY79XIM5fj\n", - "MB9pYqsRkz7n0UdnhNs//KEg/d7bfxbyFItYpkIxNCGMi+wEd2aoGNZxkhKDPtIOA2d2WSKGlcUC\n", - "XnfX3eH88v7b74A8UYRl7yXh2B4dxzrYXMHT7Su1sFyHjxyEPE89cQFi586EBoeL+2YhT30C566f\n", - "/8CdQfruD/085MmYyaPrL8xIt0sMY1MfI98NpQLO+xHMjWSMEiPkj9x1V5D+wK13Qp61VWyH2fnQ\n", - "IHL3gV2Q59nj54J0q4V9cWpqDGK9btg3ChnWrzeHNkPD5o/ei3PL+277AMRs4Ps+juQ0RbPNipvz\n", - "4hj7TykmhthReN36ZhPybJL5u1YLv0M+/nH8br8c+iVKCCGEECIHWkQJIYQQQuRAiyghhBBCiBxo\n", - "ESWEEEIIkYMdEZZHoOx2SSLqZk7nPsLN0Ilo3J24PayHuheWMhJyYvpEPRT4NTdRSMdOf981Nx6k\n", - "1zYakKfXCss0NYliu0G/C7HI10u0/bOZmRW9SL6Iou7qJArnq/VQ3Fofq2GeCopkMycIbzexfjtd\n", - "EnMng7fJSe+Mdju8bnwMTwGfn69DbG1lK0hvkbYaGcXrypVwCCZ9csI4EXqXy2F9VojIkuGzjdZx\n", - "CmAC/4ITY/Z62F8arRbEatWwf6RkkA5i/Fuu6sStw/y1FxGBelxiG0vC5ysW8XlTIhC3gYuRsc42\n", - "pPj5LGP7WIgQGiDPlw7Y6fPhvdgmgK0mttXEbChgro1gf126sIafloYPNDs/BXmanS2Iefp9rM9S\n", - "hQifXd8vjaLo2JfJzCzth3XVJ22csTZ1AvSI7YoZ4tyPao1sNulj/7xwdj1I7zu8G/JMzobz0sXv\n", - "nIU8Y6T96vVw3m2sYz8okjFaYOMIwL6YuY1HfdL5C0TMH7t5o1LBNu738PNarVA432x2IM/A71ox\n", - "s0ol/1JIv0QJIYQQQuRAiyghhBBCiBxoESWEEEIIkYMd0UT5F8j4Cpbon4YQLjHPTHad1yiARosX\n", - "wQbDlIHopur1UCN05ukzkKdIDDEnnenayefOkw8Mm7BWw3fHaw3UI4B/YzRcVxgbD/VdcZVpFlDb\n", - "VCyEMTSwM1vfQF3Yxnqo59pYQ6O0HtF8eXPPlAlRCLHTW6wsXYI8YxNoYjczE8YaTSxnmxjiWSVs\n", - "9xJ5N58RwUXPmaUOCqi3YGSuHipl/Lxqhfxt5bQ3zRjLlLWx/VqtsG06Bbx3kmEZvMlpdQjNF5Ms\n", - "ZmTQgrSIlIndjKid2Afi57n7s/nmMgfEh9exPOTzvDYsTVBTlxKj0LmF6fDWfSznmRMrENu7by5I\n", - "T82gjnDl2YsQ8zQbqF8p97Gc/U44tmojzIgR56CC033GxODUm8qamSWDsP5KGfYX+h3iqIzgGK0T\n", - "ndQzT4XzfLuB4+rgofkgferkMuS5tLwOscW9YRvXyOf3e9hfCgNmSBuSZsRk2WnMmJFnrYr62Imx\n", - "cRfB+u200Eiz3QzrqkXmpArRgcbkO2tY9EuUEEIIIUQOtIgSQgghhMiBFlFCCCGEEDnQIkoIIYQQ\n", - "Igc7Iyz3WkinGWPGmpk3ujOzwhBq8wG5jt0fL8TQMOJBerK0OyV+6QKKlY/ciIZq9XpolnbuNAoF\n", - "5+dDUWdMToinBnLl0MxsONm1WZI44WUHn7e9yQwxQ4Hf1iaKwdfWUAC/teXEpkRdW69jGcYnQrHi\n", - "CBF1MrwZ3WgdRY8Xz6O4dmsjFDlOzKD4PCZF6DpT0GIBRbL1OsY6nbCd+z0UUDISZ2gYE2PNGjE9\n", - "LRXCzREFYqwZkemkkYXt1+5h32CGkVHkN59sL/yMSN9nBpx++Bcicl0RnyV145+NqwExecTNJkzo\n", - "vb0ZrBfbmxndOVN2Ze91iWCbbB6Yng1Fx6e+i/PN0ulViN30qhuCdH0cDXg7Xdxo4WFmm2xmajnD\n", - "3XYL+/7oKI5bb6hYLGHfr5KNFl1XrgER8w+o6WlIVsbvov2H5yH28Je+FaSPEyPNI9e9PEgv7puB\n", - "PE89sQSxDTefTpB6KhIx/zA7HzKygcEb2bKNT2NkY0DFTZbrW9h/VtfQ0LjVDL9XemReHJ0kn0fm\n", - "vGHRL1FCCCGEEDnQIkoIIYQQIgdaRAkhhBBC5ECLKCGEEEKIHOyQY3kohgTNGhEPM1Gljw2YPJo4\n", - "FnthOdfMESfgIfToTDjX2gzFbetbKNg8cPQlENtcD8V0Gysorjt6VegOnA5Q3Dcgp2tHzkU5TYd4\n", - "ODOLBuHztZsolmRCz42NsOxr5PTwfh+vi8thuSYm8WTy6Vl0SPZOwMUhNgWYmV04H4r+p6fxRPpr\n", - "brgSYpurG0F6bR0FuCnpU20n0G400IV31y4UjZadEJI55TO8g2+JOPVWithfqs5RvziG7VAsEHG7\n", - "E9xmRoTlCZa952ODIYTzRETONqTE7kR6alg+wGDRnTbfJ1WeJFjOQRpmJGb9lg0hTKYnMpA+lWXh\n", - "vbp9nBPGJ3HMlEvhmDnx9DlWCojsPxxubumnKGRvEwd/D+vB/YS49ffCnH4MmZltbuLnedF4nQia\n", - "q1UUxReLzgGeCsu3H38bW7hx5soXvwhiU7OhW/effvFxyPPaN98YpPfumYA8p0+hi3ni6rPXxX5X\n", - "KGAHZeMIriMbNGq1cH6pVYm7PByfYdZz5dwgwvJLy2ukFGFb1Ufw3mNETF8oDLu1CtEvUUIIIYQQ\n", - "OdAiSgghhBAiB1pECSGEEELkYEc0UahJylwarxlutbe9sR7LxvJQndQQoqix+gjEzp4KdTZxBe9z\n", - "8Iq9EHvkoWeCdLeDepKZ+fBdeLOJRp7kFb4V3Hv+HjEJZFy8FL7Xb7dR/7C5hRqFTivUZRSK+HmT\n", - "M0TvNBPW5+g45qnXUNfT7Yaf1yOnszN2zYX6oz9/7AnIc+y7JyH2qle8OEgfOTwNefoDot1ohPV5\n", - "+hS239mz5yE2N7crSFeqw5mJdl09tFqolykRY8txd/p6nZh0FonWx3vPVsrYDlstNF7NXKdlOhRP\n", - "qUjqgOqWwjIUSV+khopJOP4iojUsED1n6ua3lHTFNBuif5J7Mxlo3+njiFTFJidRQ9NwJrlnT6Op\n", - "7PQCagR37Q6NZS9dwv7K/H49SYqNVSoRLax7nm5CzH3b2KfWXTtUN7G/MM1OzWmnKsRQeRhN26Ul\n", - "rM/yKDbOD73lZUH6P97zWcjznUdOBOkXv+Eg5Bkfw3GcpmHZEzJACmTMVMkze5hxb6Xi6q6CdV4k\n", - "Gqymm79XVjYgT6OJ3z2TE+H3w8QEav+YJop+SQ6JfokSQgghhMiBFlFCCCGEEDnQIkoIIYQQIgda\n", - "RAkhhBAHr2CGAAAgAElEQVRC5GCHzDa9iMulqX6bmW3mxd9ryDsNYTjGnPQuXQzFwvsOzUGeWg0F\n", - "08e+dTpITxKR3K75UHh97s+ehjxFwzJFkTvRfBjlp5mtr2+6G2HdlYhZ4675UGDIDDJnSGx8IhSt\n", - "ZqSYHSJubzvxMBP8MubmQkH4j/6jH4Y8v/PbfwSx//vX/1OQvvbqqyDP0WsWIXbF0fAU98X9C5Dn\n", - "6SePQ+zcmVCkykxBGR1XL9kW1h317RyEYsyxMRyPcRFjdWdsGVXJ4CZ/yvX7iUtv334DoqDOyMMU\n", - "3Hj3QnMzs4yInDNXJqbYLsYo5vUi+YyYi/aJ6SFAjIMtIuJ2J3IuEFHwKJlvLp0NzQtbxODw4BU4\n", - "dxWdoHhtBU0lC4PthcnjU+MQKxaxjv3GpKSPddBu4CaObjcUm7MexUyd+24nQKlEnoU7NodlIps4\n", - "nnkWN6m87ObrgvQf/r97IM8jXwkNOK952X7IMzmKbby8Fo738ghuMOhsYPtlpB08JSIQj1yfjUj9\n", - "NskmgGVnLL2yisaaxKPTpp1R6dgImqeWyRhtt7Y3g70c+iVKCCGEECIHWkQJIYQQQuRAiyghhBBC\n", - "iBxoESWEEEIIkYOdcSwHHbkTmxGNXkaPMN/eQXxAbuY/j51QzY3Ot/+8fg9PcW90QpHjdX/vOsiz\n", - "sYbXnTl+IUjfeNNRLJMTcW+to0BuenYXxPpe3DqEZt7MbHraOYhPovvryDi6/k6OhQK/CnEZZ463\n", - "fefSvr65CXkaDXzmxD1feQhhpJnZFx94OEj//R99LeS5+5P/CmIPfO5LQfoLv/co5Hnov16E2Le+\n", - "EYo/r3/pYchz8KoDEKuPhO1w4Sw70RzxIuB+F5X6W6Q+s8Q7iON19TqbTsJ6LxF38EoB28Y76nsx\n", - "MYWMYyZnLrp7eaG5mVlGHMQLfppiUxLbAOOHGhGtD3NgwIB8YIHUS8GVoVwm7UKuWzoXblYoV7H2\n", - "FvahE3+7HfaXjQ0co1XiVO2JSZ4SE5a7WBmnGyuX8V6pE4iz7xS2EcHPJRHZQBGl2/fPehnnymPf\n", - "wU0jN1wfbkr5e7e8CPJ89fcfC9LPPHEO8kzOT0JseflUkC6Qib9E+ks/xe8nT5F9cbsv+24P5411\n", - "srnl0upqkO718fMnJvF0kJHRsDPURshGD/LM7S6K/odFv0QJIYQQQuQg1yLq9OnT9oY3vMGuu+46\n", - "u/766+2Xf/mXzcxsdXXVbrnlFjt69Ki95S1vsfX19Re0sEIIIYQQPyjkWkTFcWy/9Eu/ZI8//rh9\n", - "/etft1/91V+1J5980u677z675ZZb7NixY/amN73J7rvvvhe6vEIIIYQQPxDk0kQtLCzYwsLzpoCj\n", - "o6N2zTXX2NmzZ+3zn/+8PfTQQ2Zm9lM/9VN2880304VU5N5Few85pitgqz3/Spvqn8irangVzkzs\n", - "6Ptdks3R6qCepOrey+6an4E8zzx+CmL+ZPcrrtkLeVYuhVqYXgffOVfq+C5+c7MRpMvF7TULZmbj\n", - "ThNVrWHLVGJiWNcN32m3iEFmkxjkrS+H5ey08N14qcz0VeHzJEP+uTA3H5oJfvyOX4M8tzzyKoj9\n", - "2E+/JUjf8GLUrz3+GBrrPfFnzwXpP33kCchz5swFiF11/cEgPTGFRqWMWi3UpiVF7C9pHzUDTafr\n", - "62fYDuMJmvvVKqGupkCMCr3WyMwscqa1RDaFEF1flqDWwUuSvCGgmVmB6KsGbjwmRP+YEL2Tn3CY\n", - "psaS7SeXQgHnJKaT8o9TjXFsNzaxXjY2mkF6Zg8auPrxb2a2sRZqoLpkjMYVnIM81KyRTs1O00p0\n", - "TF43ZWZWjsOvO1Z37F6xiw1Inox1YsfUOI7Rs+cvQezZZ0KT5UPXo9nms0+Ec8mZM8uQ58oJvG60\n", - "GrZD0kGjy2IR59NkiC+/ATGaTtzE20+G02D6fOPj2O9mptGcdWIinINi0g9abeyf7c72mq/L8X1r\n", - "ok6cOGGPPfaYvfKVr7SlpSWbn3/egXl+ft6Wlpa+39sLIYQQQvxA8n0tohqNhr3rXe+yT37ykzY2\n", - "Fh7PEUXRcDtqhBBCCCH+FpLb4qDf79u73vUu+8mf/El75zvfaWbP//p04cIFW1hYsPPnz9vcHJ6z\n", - "ZGb2lS/98ff+v//gftt/CM/9EUIIIYT4QSbXImowGNi73/1uu/baa+1nfuZnvhd/xzveYffff7/d\n", - "euutdv/9939vceV57c2vCe+XpxBCCCGEEDtIrkXUV7/6VfvN3/xNu/HGG+0lL3mJmZnde++9dttt\n", - "t9mP//iP26c+9Sk7ePCgffazn6XXw0s+d8o5ewtITey2ST8fZNd5RToRZ7JbDXFSNxNMz+4KTc8K\n", - "AxTunT72HMTmdocnbE/OoHD3xLOh7qxGTmf35ntmZt5LsDCcrtzMma61NtGUsLmBl3nDunYHha3s\n", - "NPbI9Y1SjM9Xr6Pb3iByBnlElMt49VtDY7sDV6CY/zP/8Xch9tjDT7r73Ah59pJ7/dCbbgjSW6to\n", - "tvnUEyhIP/702SA9txtFwAxvpFckwss0xrrquY0BzByy2UVxZpqF969VsO/7jSZmKOwuDLZXHhSY\n", - "MJm1u7s3ExMzkbovZlTE6bMYESNNC/t1gQhwIyLmB9izECF7FIV1NSB1xzZoRKUw38QoinkHxGR1\n", - "cz3c/FEgXyvU8NORUZdlDJUKYTD27s1mlpB7DVy7U2F5is8HXxcZ+YIifc9TJwbDFSL6P30iNOVd\n", - "WMCxvefIQpDubqFAfGsTBdtlJxrveNNlM8sGZB4eQvjDhpEfDkxYnvSZca8zzaxi3Y2P4maFcjFs\n", - "h3YL66XVImbCpF8PS65F1Gte8xo+8ZjZgw8+mLswQgghhBB/W5BjuRBCCCFEDrSIEkIIIYTIwY4c\n", - "QOxN1fy76gJx1iuSd87+hSJ9x00+H/Nt/z77L67cNkdKTPpmZkNN1PqlBuS5tIJCogNXhmZp/V4T\n", - "8jTdgbz1EdQHdTuo0/LL52gIszgzs8iJYaKUtQvWU+q0TcUCvuOuj6A+oOIOJU3JQZ8R0aH4thpQ\n", - "Q1XkCw8+FKSvv/FqyPNzd/+vEHvymyeC9NJp9EhbvnAMYnE1HILTs2ggt+8g7nLd2gzNL9tEj8Tw\n", - "Y496Q5JDgovOJDPLME8/RS2FOa0Bka9YHBNtkeuPTDcFH0V0dnRke01USvR5rGJcmdhBwn4uMzNL\n", - "+uH9CwV83mQIyR77i5f1/JIrZ9rHm7fbqAGJ3Lxbq+F4pM/XDWP+882G+2vd15MZb7/ECXQi0qmY\n", - "2sTnKrBysu8ZMEsl9x7mAHci9q1WsY67zVDH022jrqc+Ec7zGWnjJtEDxUV3MHuM83CX6JaoQawj\n", - "Jdq71H1f9InudUC+70dcvdQrmGdyFL/r/CHI3S7WAWUY0ddl0C9RQgghhBA50CJKCCGEECIHWkQJ\n", - "IYQQQuRAiyghhBBCiBxEg2EcJF/ID9R5ekIIIYT4W8Tllkr6JUoIIYQQIgdaRAkhhBBC5ECLKCGE\n", - "EEKIHGgRJYQQQgiRgx1xLL/1fbcGaX9CfH28DteMkhPFU3fyeYe4NvcS4oLrXZt7eF02QNfWcjV0\n", - "SL3n7nsgzwfuuANi3U54/5mZUchzYRldzL376oGD85Dn0T9/JkgfOrgH8sQltNg9dWo5SC/Mo1P2\n", - "XXd9GGK33ha2HTv1nJhZW8Wdrl0fwTauEPfepBfen7Vns8naL0yzjn7fL3wMYrfffnuQ3lzHE7/n\n", - "d09DbGYhbNOnnjoBeToNrKvFPaEbOTvYOzG8zjv/RsTb+b57sH/edtudQXpATmxn5vV+Q0iBOPyy\n", - "voAbSch1VLC5vQX0vR+7N0j/m/fcSnIR93x3cn1KnNZ7PeKs7O/DPo08S6kUuTTWQbWCPfQTn/iF\n", - "IP2v/+W/wg8kgw3ahpSpQOaEQjksQ22kBnn8HGhmFhXDz+v2sB+UyhWI/fx73xuk3//+2yFPRk8a\n", - "SF0efL5yFT+vUgndub1Du5nZ0rmLEFtdDk+T2L1nAfJMT+H8+f73h98Fv/QLOB47XayrrUbost1s\n", - "4/zWaIbzEjuxoFpFN/Kp8fB7dGYav1fLFWLJ7pzHf+59d0KWD9z5QYhVamF/KZWxTOx0gF7Pu7bj\n", - "qRvNFp7gkbmxnCQ4SitlckKC68Of/MS/gzyXQ79ECSGEEELkQIsoIYQQQogcaBElhBBCCJGDHdFE\n", - "lWvh++r9h/YG6V4b32OeeOYUxLYaW0G6OoLvwWt1fIefWfie3b+3NTObGJ+CWKOF72U9EdEa9Nx7\n", - "2TJ5J+t1GmZmBacnmZhAjUJzI9RS1etYB1Tz5fRkTKfBKLq2y/qoWeiTE+KXL6yFZepcgjyTk2MQ\n", - "W9gzE6SnprFdJiZQE9HphO/LW43hTvMeHws1Akkb2+XPvvwExN7yjlcG6Vff/FLI8we/+8cQO/Hc\n", - "uSC9f/9eyFMkp9THtVBbsNXYvm8+T3ivArk388MduGPqmWnuUD665POKpOt5LcyACe0c/T72c/Z3\n", - "Ys9pdpiOiX1a7MZthYx1puXyWr84xjKViuxe7s5EO2JEQ1cohKWPiMiNtXs5Dp+vVEL9SqGIc9fA\n", - "1xbRyzHdGWYifYN0qkEU1lW/hzrJVg+1jPFkeN2uhQnIs7i4C2KPf/vpIH38uTOQp9GYhZgnJX24\n", - "SNrdSXatXMY81X7Yp6iGL8W6gz5E6rdAyjTM0M6IXjVLwnt53Z2ZWbWC/azqxky/gnrZmOir2u2w\n", - "3ZM+lqlcwjIUmBB0SPRLlBBCCCFEDrSIEkIIIYTIgRZRQgghhBA50CJKCCGEECIHOyIst0G4dnv0\n", - "698J0ufPXoBLZhfQ4PDK6w4F6fExNLEsErO2yIkjuz0UHZ87eR5ifSJ89AwyImR1RmgjYyj+bjZQ\n", - "FFurhqK8sSkUXl+4sB6k63UU4G118fn6XSdE3P7Rni9TJRThj4yjKL9IjAMn5sKynzuJpnbPPHsa\n", - "YsecaeXsLArL9+9Hg9Hx6dDMs0o2DzDa/VCYePTGQ5Dn6SdQWPr53/yvQfpn7v5fIM9r3vgyiD30\n", - "h98I0qvrm5CHiWunZ0IBPNtQwMB7EUFzhGJlLyRPmRnmgFznVbLk3l60bmYW+b/vhtB9lkrY95kA\n", - "3pv7MUF8HGMfrjjzwgqpcy/qfr5c4b2oHJ2YAnp6REDtDXmfD4afUCKfSLTfUA9FIsCtlLGOU9d+\n", - "KZlzsyE2BpSIgLrfI/3FzcMZmZe7bZzzttbCTTgdkueGF18Jsde98aYgPTb5JOR54lvPQMzDtMsx\n", - "MRiO3Xzd62MddPvh5oitLTSeLJEdG7VKWIiIDKwyMUYdJLhZCCDP55+Z7Z+IS9t/R5fJxqcB23Tg\n", - "Nol0ye9ExGPVCkNurGLolyghhBBCiBxoESWEEEIIkQMtooQQQgghcqBFlBBCCCFEDnZEWH5paSlI\n", - "T+4KBeE/9OYfhmvm5mcgtrK0GqTPn1qBPKtL6xA7fyZ0y95soJh3bt8cxPYcwNO7PSWiHvROyhOT\n", - "KIBvbqLjdL0WiofHx9CxfGsrvK5SQ1Hg6sYaxPwJ5lFxOMfW3nr4eeURFEbWiAPt4tXzQfqGV14F\n", - "eZbOLkPsiUdDwebZZ3DTwXe+cwxis3OhAH1mFt2JGetroQv+0etRCfnGd74KYv/u9l8P0l/4na9D\n", - "nrf8g1dD7MChsE+1tlDs2muhqHP1UiiSnduDgntG0Qm9swzvzRyuvWCTuXwXiJAVBOnkOoorQsSU\n", - "0P6SmAhUidq14sS1zK24WsM+XHYbJkplMmaYk7tLJ30UkVOBOFyHbeVd1HkRmCs9aSs/J5BnyUj7\n", - "ec04bSqyecBTIALjkQo5ccLVX4EohVNSx0vn3ffFGZxvNpYbEHvl624M0jfddD3kYS70n/mtMM3G\n", - "B3Ujd+7c3S7Wnd8gkpK+keI+BHDr921uZlYhTuBGxhZ+HtkcUQ5jGRGoD/zmEzMruQ0abHSw75k0\n", - "CfsLG/+MiGwIGRb9EiWEEEIIkQMtooQQQgghcqBFlBBCCCFEDnZEE3XNdQeC9MxcqHdavbAB13zu\n", - "D78JsUtO75SSU6uTAWpMDl61GKRfTTQuk5NobHn6mbMQ82TkHWyahu+BqyN1yNNs4Avseech6TUZ\n", - "ZmYdp5cpM40EeaOMdTXcu+OGM4MsbeLnrZ1HDdaa06Htu3ov5Dl0BGOHrwxj552uwczsuW+fgNjK\n", - "xbAPbbbxVHdGsxH2l2efOgl5fvidN0PsRa+/Nkg/+ABqoq5/BerAJkZDfVyBtFVhfARiF8+GfX99\n", - "A832GAMnYEkyos/JqYliYhivoQETTeNjxuD+22sWyhVmrIex0mg4tutEl1IkGpc4DvP1iL4jSYYw\n", - "Ic2IxoU5AMJtmAkqeWYfI9omVi9xHGpxwCjVzDJSBt/GKTEOzdLtzUQ7XZwDR0dQ9zK1K9Q3sp7R\n", - "buK8nyTh/Z/41nOQ52tf+TbELi2Fc94tf/8myHPNVUdIKTxYd6zZS87otUj0qgN3L2ZmmhEdmq9j\n", - "No59Pzfj49aTJth+Sd99P7RwHo5I2Quu7EVifkvNRKsuH6kDPndhaFj0S5QQQgghRA60iBJCCCGE\n", - "yIEWUUIIIYQQOdAiSgghhBAiBzsiLL94LhT9PvLl8FTsJSJMHiNC78WjoUB84dA05Ln+5Xgq957d\n", - "ocHh49/4LuT50uceglin2YMYQJalqTM0LBChYK+P945LzhiRiOS86RoTzRWZmHcQCj3ZSfYML4Rs\n", - "d9EktE/MIc+fuBikjxEx+MIV8xA7dE0oLN97EPNc+6IrIHbpUii8Xl7CzQqMyYnQtPLRP8YT2735\n", - "npnZP/ynPxKk7/wn/x7yPPYwmoIeviHsw/026/tosjo5E4rN223irEdIvAiYiDoHTBwNp7ET0THR\n", - "a/r+yAwcC/Q0dmcmSATwnjFi/MqMQ0uu7DEZjxn5PF/OmJz8nqVE/F0Ip9msSETAEBkONm69aDwm\n", - "5olxjLGSm2/oBgNSBv/MzFCx39u+fzLt+YULuJGk1w5F44sH0QT5iiOLELvmhnCemN+7C/J8+Qu4\n", - "gembj4bfDwlxsbz5LS+HmIcZlTJFcxSF+ZgZrDeRpMJy0qkS11Z9sgkgIQ1RGmJjR6+LYn4/tOKU\n", - "GHkyYbn/PPLdl5FNFX5BU4rYWCNz3vehLNcvUUIIIYQQOdAiSgghhBAiB1pECSGEEELkQIsoIYQQ\n", - "Qogc7Iiw/JIT+c7tDcXCr3jzy+Ca+UUUjdfHQpFaTBx2n/n2aYj9nx/4jSB98tg5yHPDy45C7LpX\n", - "XA0xDxPlVsoVl4coKAcoViw5J+VOFwWblWp4anWbOMIyN2QvSGVuyIzZhckg7U8FNzNLOnivei0U\n", - "R69cRAH18cfOQOzUk2HbzC3OQJ7dB1EgWndi7Ani+s2Y2x3e/+nHj0Oez3/6CxD76Z/9iSD9RuJq\n", - "/MzjJyC2eGQuSGcptlWngYLNuOTEypXhTiH3ouosI0Jv4gQ88MJOosNkbtYoGmf9jAmYvbiWXObw\n", - "wmgz7ugdWTj+0pQ5+hNhuRP4luIq5MmIYNuLqr1rvBkX8wKkiZko34v3i6Q9SyVysoGrq4hWOts9\n", - "ELYp9BUzS5PtN+WUyrgxwFp43fHjS0H6/LlLkOfo1ZsQe8Vrrg/S/+M/eAPkOXAYT034wu8/HKRP\n", - "PIcnV3ztK9+CmCclmw4GbGOAa68yc9QvhReSbk6dwL2I22/geD7GbpbPcd47+FdizJP2MZY59/Nq\n", - "DcdaXCH9xfV95pTPxzbW8bDolyghhBBCiBxoESWEEEIIkQMtooQQQgghcrAjmqgj1x4I0qPOOLDb\n", - "QV3P49/4DsTOHV8O0s9+GzU1p589D7GrXxyeuP2zH/1pyLNrcRbvdRz1VR4mLSo5nUS3S8zMSsT8\n", - "rhg2T7PRgjyj4+G74m4H3y8XSDOX3EndRMZA6biMZWJwODqJz7JrT6il2t/bA3k2lrcgdvHCSpBu\n", - "bKBG4vRTSxAbdZqo8elRyMPo9sI6ftHLr4E8X/vyNyD2p18J++er3/gSyLN0Fo0DV5dD7UZETCz7\n", - "REtRcLGY6F4YVX8aekpMM6n4xuUjxoHEE5DInZgGA++FUp/tn8/rKMzQ6PL5OznDUXbSe4rl7Hj9\n", - "CNFy9IhusePMIZkxYjTEAKTGmqS/eC0Ty8NuBoampD6Z+MZrTFKi+RxOsYe5pqbHIVavhRrT0ydx\n", - "jv/yF/8MYsefPRmkb37zKyDPNdftwzK4ueRrD+F30XPPoq7W4/VBZmb9PqkrVw1Fol8rOwNVr5Ey\n", - "M4vImPH3Yvqgfg/n2GJ5+/FHHgVMpHtEN9XpoOazWgmfr97FMjED7igK+3pKTKyZEC2SJkoIIYQQ\n", - "4m8WLaKEEEIIIXKgRZQQQgghRA60iBJCCCGEyMGOCMvXN0Mx7cnjp4J0Yx0F1L0mCtKKpVDw99JX\n", - "vxjy/JP3/yOIHb5hf5B+6vFjkOeL/+XLEGtuYLk8WYblrJTDam43UOzGDNX8CfTNTRTcj0/WgzQT\n", - "rUfkRPqiO0meaB4pTSeSbbU6+Hnk5OySEz7XiXna5EINYiNTofldu4F1sEkE916L3VxtQB5Gq9kM\n", - "0rtmcYPB4SsPQOxrXwrFpq+5BYXlh6/aDbFOO6y/sSk0Be10tu8vaYqCZsaIM6gbEBPEHrmXb1Hm\n", - "x2fGzC4jH8B7M1E1iM23P2WdmQSmpGMXnYg0GhAxPylSpx2O7U4PBbGtFsa8iaU/2d7MjPiEAkUm\n", - "ECd401FvEmrGTR4zN2iiPvYDNk30nXg3IYJ0sncASMl1xRgLOjUdCorro3XIc/I4is2PPRVuDLq4\n", - "9EeQ56ZXXQexw0fD74urr0XxuZE5D7KQ2IAKu8N6YBsRKlUnvB7B+bTbxvbz4zEhanAmdh+mf8bE\n", - "LDXpbT9m2h2yGaMTfmf2EjK/RVgoL7jPyNxCv+rorpjh0C9RQgghhBA50CJKCCGEECIHWkQJIYQQ\n", - "QuRAiyghhBBCiBzsiLC82wjFtCMjoVBwftc8XDMxiY7T9elQhFsZxcc5t4Qu47//0VBQuL60AXl2\n", - "70UR8J696LLtGRCBWuyE5ZuNJuShjtruXq0tFHF7kWWXuL9WCihMjJ0wcQhd5PPXOeEeu6xIBMY9\n", - "Jyhc20Ix+FYbRc4VJ0iv1NANfbyMYuw0ca7UxEWZ4kTGa2trkGX/Fdg3TjrH4me/i+7545NYzpWe\n", - "O20+IwJHUskDfxr7kH8PVZ34s9PB65IUP9BrWzOSh/WFge97RCQ7IJ0vcjJcKj53dPuk3Ewg3g3H\n", - "UZ+oyHvEjdw7TidMgE/c5at+rBF3+WF0rSXiXF2MyUkHsf+8IQT/hJRUXkKez48tL1A3G05YXiyQ\n", - "vkgExc1WuLmkWsMNKVdctR9iI2OhAH15CU8Q+PafH4fYRff9cOAgjv+ZGXRW9/gxa2aWkHmp54Td\n", - "5DKL3QkXY2P4/VGIyCYH1xd65PPbZB4epNvPLyNjOL91ndN41MG+2G6SjWRufok6bHMUbjKq18Lr\n", - "CiXm2o5lYBtQhkW/RAkhhBBC5ECLKCGEEEKIHGgRJYQQQgiRgx3RRPl3p94zKxnge/CzFy9ArH82\n", - "1DY0iYnloIcvlBd2hdqma6+9GgsZ4TvSRhPfwQLEPK1UDE8dbxNtU51ofRJX9gZ5vmo1bMKkh3VX\n", - "iisQ8wqWlL14J/jT5jOmmyB1V4rDcrJTs4nMxjquPvtEXMHUHWAwWBzunXfs3pd7LZeZmWWoaZtb\n", - "3OWuQ01N1MFY2bVfPx3OiNVrKQpDGjHG7l4lohkoG+mLvt6JgeuAqKJ8O2dDXgcimmj7v/cuLqO2\n", - "kchzrO0MYpnOhxkcFl2fGh1Fg8OI6C18HVcrOO0OY/WXkrpjVeeLXmJ1x9w2XYjpmApEt1Rw+iqm\n", - "bRoMIYqKiQspaz+vLWps4XisjaJO6sDBcN6fmBiDPKtrWxjbDOeA9MQS5Nk9O4EFdVCzTTbvurpK\n", - "e9junW44lzBtFevX3sC5T+7dbuP3U5HMCZ6RcazP2Gmi4iq2C/suaDndW5sYv/Y3UUvVcbrIEjFr\n", - "rVaYjjD/Uki/RAkhhBBC5ECLKCGEEEKIHGgRJYQQQgiRAy2ihBBCCCFyEA2GUfy9kB84hMmbEEII\n", - "IcQPCpdbKumXKCGEEEKIHGgRJYQQQgiRAy2ihBBCCCFyoEWUEEIIIUQOdsSx/J+/52eCdMW5hc5O\n", - "o/vr9AzGppxDKjP03VhHB9pWK3SgXV1Bp+NWC11bvbDsl375FyHPv/gX/xpi8wszQXpqEk/8brfQ\n", - "qfq5584G6fV1LOced++ZGTzNe4a46S5dWg/SK+v4vJ/8xL+F2G3vuy1IM/flYhFj5Wo5SNfIdeUY\n", - "nWsHbpmfEkf4hMRSdxJ6p41u4Xf8/Icgdvtt4fOVSsypFzdHRC4WEddmxiDafl9HMkDn4YF3jid5\n", - "Pnb3PRD7P/73fx7em5xe3m4zZ/7w+SbZGJ2dhNj4RHg6QZk4Ayc97PtpEjoUJ31svw/ceVeYvv02\n", - "yFMs4ecVimHblMlpAXQDjOtm3v3ZjDv4ewvxbp+4tpM+/KGP3B2k7/uF+yDPxmoDYufPLAfpSox9\n", - "cXFxFmJF1xfrI2XIs9ZAB/+2N5MmfT8iotyP3f2RIH3r++6APIUS1nFcDtur28G5K+ljn6rXwucZ\n", - "HalDnk4X22HDuZjHpL9UqngqxIfvCueX226/HfJU61jHfoyMjuC941roll8ibu+dDo7jdtePK3QC\n", - "7/WwD/s+e+9dH4E8d95+K8RSOIaCOd5jzJehR07i6HawjVvN0MWcicGrpK3K9bAv/Mp/+AXIczn0\n", - "S5QQQgghRA60iBJCCCGEyIEWUUIIIYQQOdgRTVTF6Uwmx0PdxNx8qPMxM5sYHYFY6vQcyxdXIc/S\n", - "EsaWnR6o0SSnVhO9w/gklsHTaqNmoNMLYzHRAxFJBLzz7RDdVLkcvt8tkVPkjehuWp2wTO0Oak4Y\n", - "XacZ6BNNTZZhOaMofD9fq6KuIC5j2cuVUDNQLmPdxTHqCoqxO807G66r91xbsXfqXv/0POHfI0xT\n", - "w5XGl+gAACAASURBVNRPJafZYRqQiJz07rU3WYaaAcbGZqihabZQN9HrYV8YqYenrxdJPxsdwxPa\n", - "R2ph/yyT61oJfh7VFm3DFhnHbFylTjxZLBIt3oC0n9N3pESHlpH+EjutH+s9rD7h3kT0WSX6HN/R\n", - "ekRPxgrhtWKsBTpdvFcvCT+wXEPNyWCY/kn6fqWC92o0Qt1Ls4Fa0SmiA53bFerAmJ7s0tlLEBvE\n", - "YbnGZ1HTmpAx42k4vY6Z2amTFyC2vBQ+z9oKlrO1Gc6xlRjraXoONYoTU6H2pz6Gc+f4BNEMkfna\n", - "MyhinszCdi+QSZBpC32/rpDPr9WxnP66PmkXMmwt6eH39rDolyghhBBCiBxoESWEEEIIkQMtooQQ\n", - "QgghcqBFlBBCCCFEDnZEWD4+ERpCzjgjzZkpItwjgsaVi2tB+szJJchz+hQK9zadMLFSQXHdNBEm\n", - "MoNBT6+LomqvZGPGoVslFMVubYXlZMahcSlcB9eIeVuVCPC8+NSL9C9HxwnSmdFlkxjygSCViKX7\n", - "CROfhqLDag2fjwqaR3xse1NLM7PElYGJyJkQueREuUy4y8XmYbmiwhD3NrOsH7bXgMqVkY1GM0g3\n", - "XdrMrFrH+qy6Oh4hdV5jJnZOVF0hz5IQk9V+3wn1mULcQwSqWxsoyt104vok2d6s1QybtBSzzREY\n", - "GxkN66pGzBOr5F5YACLAJXNX0fWhDjGjTFMc73VnPjk6WoU8F1exvyROcF9hZrRMUezwhrxmZm0i\n", - "xt7a3AzSk1PYFw8f3Y/3Wg3r4bnvnoE8fSKAP3j13iBdq2O9bJBNDZ6rrzkCsdk5/K6bmAljRTJm\n", - "Wo2wDy9fWIM8K8v4fdFx5SRDhpr7DrMvgLWw36xgZMMG5Hk+6u6N15WIqfOI26DRJ5sqmLB8q4H9\n", - "bFj0S5QQQgghRA60iBJCCCGEyIEWUUIIIYQQOdAiSgghhBAiBzsiLJ+eDIXl486NPOmgiu38GXSS\n", - "PfbdE0H6uefOQZ7lNXSzrTvR8cg4nuY9OTM6VMyTEcG0FyIzwWaXPHPTiQAbW+guHbsTv4vE0btE\n", - "Yt4lNh1GuGtmo85dvttBEXlGRKveyLlDHNJ7Xbyu3Qrvv7mJAs6NDRQFjo6FdRyXhuvqiRMUsxPG\n", - "mUA8i8LrmOixQATpkRNVFsl1RSK89s70yWA4x3IvZK+AAN9semYKYrvmwlMExsbQvZ/VcakQPl9K\n", - "hJ5UxJ1tn8dz9XWHINYlG1L8aQTMKb9YwGdhjuGeuEQE4q4P+ZPmzcwS5iruP58oYqsVnEuK7nky\n", - "1IJbu4XjaHw87AtV4hJdJALxnqvjkREUiBeG2PiQpNiHV9fwxIm6mz+vvv4KyFMh7fe1rz8RpE+d\n", - "wO+L6191DcT2HtoTpBsbWKH9IebPp/78GYgdIz9jxNWwrnbvw/G474qFMH1kGvIsHsaTPzbXw763\n", - "fHET8mysYv9sk81CHubW7xkMyCYOdiJDGvapAZmH2Rj1luiFmFQw+bxCcbiNOQz9EiWEEEIIkYPv\n", - "axGVpqm95CUvsbe//e1mZra6umq33HKLHT161N7ylrfY+vr6NncQQgghhPjbyfe1iPrkJz9p1157\n", - "7fdeb9x33312yy232LFjx+xNb3qT3XfffS9IIYUQQgghftDIrYk6c+aMPfDAA3bHHXfYJz7xCTMz\n", - "+/znP28PPfSQmZn91E/9lN188810IVVxuoGkF74LP0eMw777+LMQO/ZMaJa2soK/fBUr+F5/bHIs\n", - "SO/Zvwvy7N4/B7GJCTRG8/R7aLaZuve7JfKelpmJNRqhBqrdRh3DwOlzmF7Ha0DMzCKnjfFaoMsx\n", - "604GZ6eX93qobeh0wnppt/Ede7NBDEc3wjro9/He7F18yemPWL0wvHloKUW9TC/DNk6isFy1KmpV\n", - "IvLevexMFmNiOMhOsveatm4y3CnkC7vDk+zLFdREjRHN3pgzjKyQPtzroJZi0Cu6PFh3XWIG6bWF\n", - "3e72z1chhpWjxBhxbNKZShLjUCbvaDhDvnYLn6VPzHY7rq8zA0lmpOnx88jz4PN5TSIz1mRzidc2\n", - "MVPJQgnbvdMOx2iaYn0WSziOPCvLOO9HpJ95DdTsNOqBvvT5r0Hska9+K0gffslhyPOy196ABXNN\n", - "89yxU5ClQUxdPUx3c/7MCsROP3c+SJ85hXrgtY3QSNNrJM3MZmfx+2r/4VBLtXf/LOSZJEbTIzVi\n", - "2Ozw3ylmZqnXEXqxo1H/TS8jtAHRA6YZxgpRWAYiMbVCRHSnRDc8LLl/iXrPe95jH//4x63wV4Sj\n", - "S0tLNj8/b2Zm8/PztrSEDuJCCCGEEP9/INci6vd+7/dsbm7OXvKSl9jgMor8KIqG/utfCCGEEOJv\n", - "G7l+w/qTP/kT+/znP28PPPCAdTod29zctJ/8yZ+0+fl5u3Dhgi0sLNj58+dtbg5fiZmZ/e7vPvC9\n", - "/x89eqXdcP21+UovhBBCCLFD5Pol6p577rHTp0/b8ePH7TOf+Yy98Y1vtN/4jd+wd7zjHXb//feb\n", - "mdn9999v73znO+n1b3/7j3zv31VXXZm/9EIIIYQQO8QLYrb5317b3XbbbfbjP/7j9qlPfcoOHjxo\n", - "n/3sZ2l+73W1vh6K8s6evgDXnDqD+qotJ9CsjKKgcXYBDceuui4UFB4+shfyTEyiAWefCKY9EXm7\n", - "6U9VZwK8ARHJDdzp6Mz4seRE+uz1Knvj6o0f2ecz6iOh2DQiIuRKZXujwiYR13aJAWfDic1bTRTu\n", - "tohxIHz+kGaivm/2EmxzVldF9+q6QNq4wI5Md41TraKAs1pDY0svLC9n2ws/zcyOHg0NKUdqOGaS\n", - "hBlihuLoEnlVzwwxG+1wbA8SrJcuEWP7XL1k+/757FMo+DUihK7UQvG+N5k0M4sMPy9xAu0+2VSR\n", - "dLG/+HmjS/JEhe3/nh0Qk8BSzIx0vYEr21iCn+c3bdRrOLZZzD9flmI549r2XzXMD/fI4YMQW1wI\n", - "NwI9+fBTkOehP/xTiE0shKaVb/2xN0CeK69Fw9av/MHDQfqM29BkZja/CzcneW54Of5g8MM/+jqI\n", - "7dkbir2rdfwuajdCw8+L59A089IF3Gi1cjEUsjebaBzaJps4BkMYzTKjYI//vnr+OhTF++8s9r1W\n", - "IH04G+J7rEDKyTZRDMv3vYh6/etfb69//evNzGx6etoefPDB7/eWQgghhBA/8MixXAghhBAiB1pE\n", - "CSGEEELkQIsoIYQQQogcvCDC8v9ems1QCLy2EoriLl5C59oWOY19ZCwU3M3Mo3Pt4asPQOzI0YNB\n", - "emIcRWVd4qi9vrz9WYBMIFp04s8+EcmmRPhcKociPOZ46wXTXEBNXMy9wy1TxBPiUnivSgUdtiem\n", - "RyE2Ph6Ko+MYxYRJQk74dmJe7+JuZtZiTudboXC9uTWco3fmnHF7RDxsRLyYOqE305B7Mb+ZWdkJ\n", - "ySPSfjFrd/f3T4G4dTPm50JxbYU4HXeIg3i7GZaLOY9vbuBmgZXVcMx4cbYZ3/jgHZhLQzzfysoW\n", - "xLrE4d63KRNes7FWLodl8n3azGxkBGNxOZxfiLbWOkRc72Gi2WKRbDYhMc+A2ET7jR3e+dyMbxrx\n", - "04vfRPJ8lu3nl6mJMYyN4Vxy/IlQ2P2H/xndyftkrL39XaGI+1VveBHk+e6jxyD2x05YXi3hnDe3\n", - "ewpini8+8AjE2qTd/f6h8Wmsl8nJsE+Nkr5Yq2DMt3u3g23V75PNScPsyyHfIQO3QYPaSpJNKv4U\n", - "CnYqhb+3mVlmfjMW2VRB5uZ4iDFzOfRLlBBCCCFEDrSIEkIIIYTIgRZRQgghhBA52BFNlDfXXHan\n", - "d7eJDsXrn8zMJmfCU6oXD+6BPIsHFiA2Nha+T2428ATutZUNiK1eWoWYp1xBwUPZ6TnaTXKCOtGY\n", - "jDhjy3aTGCq6d8XksGtq0ld0op1SYftT1s3MLp5fDu9DtE2bW6hN2bVrwqVRQzBK2tjrycbG0Bix\n", - "1US90+hWmK/THs5ss+AEK1mP6bQw5rUGvT62Z4HpwFJnVEh0L0znljo9QGkIozszs7rTsBHpjxUq\n", - "2M+yXvg8G2vYxpeWcXysrod6xwH5uy0mhpF1ZzBYrm+viUr7RKtG2m/Daae2iM6usYX6Lq9zqxET\n", - "xBFi+DvmNJeTE6hVGeYUeaZRYjGvNxzGyNPMLEu21x+CYMfMYqcV6xPTVVZOzygx8ly5hCaSj3/z\n", - "mSDdJlrK1/zwKyD22rfeFKRXL6HG9fc//QWILZ2+GKTf/D+8BvLE9e3nz6PXHIZYcwvreOl8+H24\n", - "fBLr4PRT4TzMNHxVMmbGpsK+NzmFfbFex/FfLOTrn56U6fpSpvUN86XkOywj/Tp2jq0DUqaUmAkz\n", - "neuw6JcoIYQQQogcaBElhBBCCJEDLaKEEEIIIXKgRZQQQgghRA52RFjecUaWXjLGjMOYkebUVCgs\n", - "n5xCY7ZqiZjKtULR6MYqisjXiOiwRQThHiaSjZy719YmnpzdIuaeXkzf6WC9eHOxhJyg3iOGgx4m\n", - "TGRcOB+KLLvEBLVPhJ7+FG4mwJ2ZnYDYhDPgq5PTtpmJ5cC5w8XEII9RrYV13E6x7rIEY4mLsVPH\n", - "S33sG6m7rt/H+ux2iFGoM4eLhjSLS1xf8P3HjAvnvRFjq4VjodXGWMd9XlzGdmBGod6ENCZid0+N\n", - "CGLHJnBOmJ4K+xkTQndIv06cSL3VwnbpE9HqYBC2TbdHxLXEoBJvhGOUmcFGbjywzR8lImT31/XI\n", - "OC6QDSixMwX2hrV/cSWJhaTEhHhteQViPTdmrnnZVZDnptehkWbm6uqPfudLkOe7j6HZ5stf/dIg\n", - "vfvQPORZWl6GmKc6hnWw+xBufHrlG64M0pUqznlxHPZ1No631nFzhN8c1STfO12yySkl48HDNjBE\n", - "mc/DTDMRb7ZbJv2HzRuJm7sGbFyRcRSVZLYphBBCCPE3ihZRQgghhBA50CJKCCGEECIHWkQJIYQQ\n", - "QuRgR4TlmXMfrdVCkVy9QIR0xAm8Vg9FquUY14R9IrxsboUO5RcvoNMyE41mQ6w5yxUUznpt29oq\n", - "OqRT1+3RsB6SBE/z7g/hMlytYjN7R9ghTY2t5ESq/vPNzJI2ChMbjVB0fGkJxfzPPn0GYnEc1ufk\n", - "JIrrp8gp52POFXpsFN2lGSXneFsignTmzNvzMaKW9P3eDIXeHSLOjqioMiwnc/RlbG6Ebt2s2Qek\n", - "8Jtb4WaINhG7E72mVevhBgImLGdjpuo2EBRL2ztCT0+PQ6xSxw0MExNhXxgnG1lKZZxvvPN/SjYB\n", - "NMjmk46bg/xYMDNrEedqgGhke0Tw60+pr5A6LxKBeGThhaxMXbKhoOJE6kWy0SNlncPRJvOGFwqb\n", - "mY26DUT7r9wPeWLSX/70v/5ZkP7mn3wb8lz3oqshdu1LjwTpzQa69bPvC8/SeRTJHz9xFmL9Tljv\n", - "CXHTTty8OyAbirz43MysPhL2hSoRrRdL+H1RHsKxnM1BaRr2zyLZc5CS0xZKTujt+7SZWdobor+Q\n", - "DT6RP3rAzAZyLBdCCCGE+JtFiyghhBBCiBxoESWEEEIIkYMd0USVnHbJ6ySKxPixGGNspBbqFmJy\n", - "wnirQQzHVkI9ToPkMfIOOCbaDU+NaCmKTmuQdNCssddmZmbhdf50djM0a4yIiV4hwusqzqjM6xou\n", - "x7jTGo2OYbt4E1QzM/+6nJl0tprYDm1nBpcSA8C1ddQodLvhdf32EJoTMys7DVZWRU1NRgzcwICT\n", - "vcQnuhCvLSqXUVvhdVpmZgX3rn9A+j7DG+l5k1AzMyIZAMNPIjWw+gjWVcXVQ7mMOo1SCceMN+5L\n", - "hzghvlzGOkj62KcuLof95RLxSYyILmzg5qUqeZYC0eKUnOaDXGZFogOFPKRPJT1sv4EzuyxViCaS\n", - "6FdAF0L0jnVicFhzRqhdMkaTIdovYUJCoq9a2D0XpEdHsO6efeJZEnsuSC/u3wt5bnzpNRBrbIbf\n", - "F8vLa5AnrqGuzlOv4fiojqIZbOTmiSKZvz0llifCduj7eWOA83BG9EFeD8goFLFveHFoZMRolsxv\n", - "A/fd1yemx2zG82MkInorOjcTjeCw6JcoIYQQQogcaBElhBBCCJEDLaKEEEIIIXKgRZQQQgghRA6i\n", - "ATtu/q/zA5moSwghhBDiB5TLLZX0S5QQQgghRA60iBJCCCGEyIEWUUIIIYQQOdAiSgghhBAiBzvi\n", - "WH7HHR8I0t6dmHnbbq03IJZ2QxfTvXumIc/EBLrZbmyGJ9JvkhO4iyXiTu408ffcfTdkufOuu/Ay\n", - "J0jb3NiAPAMiuN+1ayZIV2r4LEsXwpPB280m5Bkfq0PMn97d7qCj9333fgxi7/m5nw3SzE27HGM5\n", - "C4XYpfF52ZaDknOOj4kzb5E4gZecA22tjm7BP/2efwKx973vfUG6sYX1yZ754ME9QXqM1Pn62ibE\n", - "NrfCvre8gnnaxN19YjSs47FRtMG++557IPbu/+2fBulmE9t9cxOf2TvMFwr491ccY73U6q6cpF7q\n", - "dSx7zcUqxHX7no+Gz/fhO2+HPBnpVQXnYpwQZ25mnu377MDQEToqYr1kfXeqADNMJo7JH/zwR8P0\n", - "nXdBHuY4H8G92Kn1xHXfzVOs7qISPl+3H/bhra11yNMiJwb81q/fH6RvvRXbr1zGMnjz6siw7grE\n", - "vX51eTVIH7lyEfKcefYixCJ3wsbEDM4lW1vYh/7tfeH3w/tuvwPyFCPsaOjqTdrBzXkpuU9G2soq\n", - "YaxExl65Rk4QGIT95YP/9P2Q544P3gqxgrtugrRnkQi2250w31aC3ykpGUelKKy7QYTtkpLvC+/g\n", - "/wsfuxdvfhn0S5QQQgghRA60iBJCCCGEyIEWUUIIIYQQOdgRTVSWhS+1i8VQfxSTk9DjMha1sR6e\n", - "0H5pGfUk9RF851t1sfUmnvTe76JOqlwmOilHlqLWYGMlPPV7dBJP/N69ex7L0A/f3T75zacgT6sd\n", - "asWue/GVkGeE6IEuXgj1AexUd4Y/IZ6JR9IMdRpJGmpq6MnkRCySRV4AgdelpOx9V0x2ejgjroRt\n", - "3FvFPkXkJFZwfbZMNDxML+PrLyE3Zyeo12phHx4dxTZmECkT4DWKZmZetsD6C+tCSRrWe7+P+q5+\n", - "gp9XycL6y7Ltp6o+0TZFBbwudaKaJMWCF8kcNHCn22cwFswGKetn4f2LEavfYcYfKSfRFvoxSp+v\n", - "SOZY1z8zptchfTgdhPcqxZinOkCdjadENDxMu1Vw9Zem2KfG61MQe27tbJCuEO1PIcZ66fXC+ozJ\n", - "8w0yLAPcm2mbmPjO94+M9DO8EYFc5/RAdF4k83e/12Ef4K7DtvJ6pwL53SYh43+jE8baZN4vFdl4\n", - "8DGiiSTzW4Fop4ZFv0QJIYQQQuRAiyghhBBCiBxoESWEEEIIkQMtooQQQgghcrAjwnKvm/OaMW/Q\n", - "Z4YGa2Zml9LQtHJjDU0CW3MTEJudHw3S4x0UBa6v472GWXI2GmgKOjkTft7CIpq8XTy7BrEn/vxY\n", - "kC6VUfz22lteHqTrNRTSP/HoMxDruGee2YX1xPD612KRiDOJyDFx4shkwATU+HyZEwaXytg3mODW\n", - "i7G7wwgjzSxyYtp+HzveoITlrNVCQfrIKJpKbm5i3zAn1O20cUNDp9ODWFwJjVirxDSP4Q0jC0Um\n", - "vMTrfL0wYTITFBMNNbk3EUe7tDeCZKQkD53g3Mexz2c6XfDoGwwnhPbZiuzz2EYLR0rGBxMd+w0a\n", - "zNyTuol6ETDb6MFEzk5MXyljX4zj7YXlGSlTgWziGDjj3mYX585DM/shtnJpK0hXa9g7YmIGuXIp\n", - "HJNX1GchT5Li5iQP68ER+1LxGUkW2L9A+n6RfmGFz5eR7740ISJ5tpvGUQJRt1nVzTdV8n2x0sY6\n", - "bzix+YB8qVSYHzZshiDjES8j1w2PfokSQgghhMiBFlFCCCGEEDnQIkoIIYQQIgdaRAkhhBBC5GBn\n", - "hOXe2tiJ1gpFFC9O7RqD2PkzobJs6dQlyDM2MQqxKSf0npxAEXBzi4iAk+3Fdd4N3cxsanZXkH7u\n", - "ydOQ5+TxsxDbtTgZpF/6iqP4eU6Y/O0/exryNDZRHD27MB2kE+K0zvDu8sUCOfGbiPRK/tTxAXHF\n", - "JbsHvJg2JsLEEvlbIHJCxIS4SzPSvhOkd5kTMQ6bgmsHnzYzy0g5e/2w3tfXsd8xYbkXWjNRN8M7\n", - "cY8QQfqAOWMXvdMxCj3LROkZl8P2qlax/WLiEl0qhnXsBfEc4qJOBLHgyE5F60RU7ccIU2wTVX7m\n", - "+jUxELcBdbN3H0f6MBObFwpFlyafR+7lN38UDduFib+923qJjFH2eZCHOeUTkXO9GvazixdxzEzM\n", - "4PdFY81t2iBC6PFJdP7/zqPng/TY5FWQJ0kuQMzDujDveWE/Y3XnT3wYkB0cbMRETpGeEpf/FKcb\n", - "i4Zw9C5HONaq7vthkGE515p473W3D4js07EC2XXgxwgb2myoZbBrZHj0S5QQQgghRA60iBJCCCGE\n", - "yIEWUUIIIYQQOdgRTVQvCTUCJaehScip3GPT4xCb2x9qjU4+ew7ynD5+EWJ7F0M90NQ0vgevEX1H\n", - "gxiTeeojqME6dTx8X762ugF5Dl+7ALEDh8Pni8k74NNPhzqwbgNfAldqaFDZbIXmcKXy9mZ4ZmZF\n", - "p7fgPn4k6g0ASZ4SM+Tz8jnycSkz6XO3Z+aewzAgWrEBPZE+/ECvBbpczJeTmW0mRItXqYT3KpW2\n", - "N2s0M6s6U1BvEmpmViM6qX43HCODIU9H9w8Yk3IWiHEnyI2GkCwwzVBUwHuD5ovqPbBPeR0Y1VuQ\n", - "Z/EGnJnXhBrX0MHnM+dSokMZuFGSEhFWgZh7+vsznSTxFwWzUq/Jer4MeB2WCRs5zXDOrbh5otnA\n", - "PONT2K/7bmhtbuJ1i4dmIHbp7CNBul4bgTyD0vZmjdTAlWrawkpmZrB+jmU6RjbHRk4DVSCf7/Wk\n", - "z5dhe01UlWjMyqWwrTp9XHIsNVCE5a2RZyvEbJNop735bDqs1mlIzSxDv0QJIYQQQuRAiyghhBBC\n", - "iBxoESWEEEIIkQMtooQQQgghcrBDZpvh2i3thYK0NEHTxUoZxYqHjuwJ0qefPQ95Tjx1BmIXzq8H\n", - "6alpFINXKiiu7Q1xkvXWRhti7XYok9t3CE8B3zWL4u8RJ0ROGlgH546HIvUzZ1fwPnN47yNHw7qb\n", - "2TUFeRheqOuN9i4X8zBDvigjBodgnkbM4Yhkc+DKmQzRds/f35WdiKWZgNqLo0skDxNV+1Pcez0U\n", - "WTJhqTe2LBHDSsbISOhax0wsC8QsNXXliogwmZul+nszE1IifGYi9W2ghoPsPt5UklzHyunboc82\n", - "K5C28k/HpK7s8zAP1jnTo3thuR9DZrx+I3eztI/C6wIx4PR9vVAc0lUS8rA+hXVccHNHt4XlLKGu\n", - "3Kqj4Zx+9sQq5HnRS2+AWMsZLyddIuIeor8yQ8cic+B0oZRtRPC/f7B+x8TSfk8FKROfv7d/vjrp\n", - "jKnbhHNhC69bbeHnTU2HS5PRGuaJyTzV92VnVUAE8GxTw7DolyghhBBCiBxoESWEEEIIkQMtooQQ\n", - "QgghcqBFlBBCCCFEDnZEWO71bu12KMaOq+S0+7b3MDUbmw3F0Fdcsx/ynD6xBLFTJ0MH8cV9/x97\n", - "7x5s2VXf+f3W2nufc+65t59SP/QACzBtIYE12IZ4SCjMMC3PeMYeykMpg11lFZ6Kk8IeG5sBCYEw\n", - "IECNMUQxtiszHuLSjCsGqpLBpGqKOEplGKeCwY4cYwJYGCShV7cere6+r3P2a+WPdlFZ39+3OZtt\n", - "7Cvw91PVVdpLa7/WXnuffc/5rO/yondR+WMol6vl3eXSi+XHr8hnFL/ssJ+Sen3uy5rNXMr7/f/5\n", - "j12dP/q//zxbfulJL0aefPVLXdnhQ7lM/+n/9KeuDgOVvJ5IiJGl52JiOZ3SnEiO0Fc68/IyC9Pt\n", - "UfodIraaWQKJc1L5W4QlMhus15LZ0ZcLL43XyzxGOaGJbWZGUrAxOb5j6xEmkHTOZHdMQ7+4g7zd\n", - "CyLS4kwEZmZ1k18HNmv8ovZicMK+MODPPdanejKgAGXasvDXuCBlTcqPM5L47p6kg2NCOV47M5+G\n", - "zmA1epI4jTBpncnfKCIz13aIfsv6cEmkeHdM7CZlgn+R14udr7O7veXKjj87/7x4+MGnXZ21uR+E\n", - "M9vI+8L2pr+PK3KPIoGcH0v+R7GbXT+3JSKRsxTzAi4qG9RBH5UDHi+BvE5sLvL9ndn0z4g49ed3\n", - "KP/ItFnh1+trX4bNwAblUN+eyPtD0TdRQgghhBAj0EuUEEIIIcQI9BIlhBBCCDGCPXGiKgjOPH8u\n", - "94jOP+09hgPn9rmy+f58Nu2jVx5wdY5/11FXdv5M/lv4E09e8Ps74L2QOCBEcv/cN+mRw/mxp9a/\n", - "u37l80+6ss/+wRey5fu/5sNE/9nP/YNs+af+xT90dR5/9LQr++i/+d+gjm8Dzuo2wLC/i4VwzuQ3\n", - "aDajOboi9Ddu4kn537iHhakV4IpMJv56zma+b6Bi0rXe82nAf2Lrra97JyOW/hjQZaI+CQF9p7WZ\n", - "D5VdX19zZQVsn4V0NsSFWSxzf2Sx49uATbTegls0zFkYFirpgvWYJEGC/AK4KWxme+YIoifFglhj\n", - "JB4awB4/GNZ6cWP5YkHajt0N3YBA2kDapQUXjrlUJUsFdZATJP5Y0+f31sb6uqtz9snzruyyK3IP\n", - "9PRfnHN1tje9e3v5lfuhzo4/zCHhsKxPkVNGl4mod64vDPXX0MHqWNAt2SEL4EWa3q93bpHfIy1p\n", - "p/0b/j7aN4O+2JMgX/K86SAMdnCEJnN0h646ek0hhBBCiL/F6CVKCCGEEGIEeokSQgghhBiBXqKE\n", - "EEIIIUawJ2L5bJ6LgPP1XObb2fJBaWcf9TNur0Mw2qFjl7k6J6692pV9fjeXW88RUXBtvt+VFeVq\n", - "+fPI4UOu7OyZ7Wz5kYe90Hj6tC/bfzw/hrf+0j9ydV75j2/Ilj/7qT9xdf6HD/4vrqypcwHvHsR5\n", - "dgAAIABJREFUFX//Ja7O//TvXZETZ6nvS0RdDJobOms2zo5ekOC5hojleAwoBQ/dH5udnQUVtiA5\n", - "NiQIjomQKHpOiLQeK1+2hIDK2dQL4ozpBMTyNS+yr8+9WD6tQGQnYZQ1OeeigPDZngjpLQnEhPPr\n", - "BoitbedDEGPh2w692brxgwAiOaYE4mxL6vREZS3LSbY8KXybswBOt21i4MforwNW6xIJKiTHziRj\n", - "fwzk3gYpl93ZccC4gNT5Y6rIM3cJwctzIpZvnt12ZfsP5tt6fOLv7adO+8+CwxCWvLXrt10OCNtk\n", - "wZrBiMwPzxw24IYN7HD7Y+HFKKST71FYP0urT8/qRJ4JsL+y8ueyMff7m4W8XViAa6ICPJSxoFI2\n", - "kmW4gu73OXpNIYQQQoi/xeglSgghhBBiBHqJEkIIIYQYgV6ihBBCCCFGsCdieQsC49pGLrLWC58a\n", - "e+GcF/6eOpPL2DOStHzZ4Q1XduhIXlZ3XrzcXnjZdD5b3VyPn/FJuU89laeBl2Sm8O996fNc2TUn\n", - "rsyWLz/iz+/f/vonsuX//d9/xtWZz7wk/4//6cuy5WI6LPF6WPYxSxXHAiJZMvkbylgidNf5sgLE\n", - "S5wZ/VKgwMhmZ8cUdTOzrc1cNo1EwF3sePG5b3KBclL6/ZUTL9c2y3y9neDvGUYP59cTmbegidp5\n", - "32diuQUiiIMQjonwF7ft94fJ9EPGISzqXVfWBX8fuzpEso5x4sp6lOJ7f62qau7KJkUu/Vdk2yWL\n", - "pQaYBNwR6RjTl9PAQRzYyOye6dhIkoT3DEvYXz0oh81GwIR7fF6X635QxfaWf6aX0Pc2Nvx6Zx/3\n", - "0viBA/nzs63JAIYh14+cHxuI4J+NLLLcbX3l/i9uGqR1OlCApZiv3nbN+icsz6dEIo/+WgXoe0yu\n", - "NyPPZmjjnq5HPnuobD4MfRMlhBBCCDECvUQJIYQQQoxAL1FCCCGEECPYEycKf2ovJ/lv0/MN7xXs\n", - "kEDMc0/krtH+fX69tQ3vRF1xPA/EPH/Bzyy/bPzvtDGy31dhvdavd/TqI/kxzf1v8R1Z7/QjZ7Ll\n", - "z/2xDxx97KG87Hu/70WuznXf+xx/nE0eaPrAVx5zdRguiI14TCxIE30nlhXXslnkYX8x+N/Bi4Jd\n", - "l/QNFy8JOB8sjHJt5q/f+iT3XKhLlcj5wezk04m/JcvKlzXL3MtoSbswOnCwcNmMh2YaNHFJmpzO\n", - "Gp/QUSC+BVkTQ/N6PADCDjnuQHzHHq5DQ+71MnqHpyrz6z6b+JDHggSjTmC99em4sE3mqtGw27D6\n", - "njESXtphkC7ZOPOk8KhYfy3K1R81HfHzYkk8IvQIiW7V1SScEdzJ+bpf8fzTPuh5PstdVHbP9MT1\n", - "Q5rWtx1/Tqzu6xjcyVYh3cXwQUgfi+QaM3cK2SWOUgOeZAx+O1VBTFt0mWhYMjl6WI8Gv1JHcOgH\n", - "BNne6DWFEEIIIf4Wo5coIYQQQogR6CVKCCGEEGIEeokSQgghhBhBSENTCL9VOxwa/CaEEEII8Qzg\n", - "Uq9K+iZKCCGEEGIEo1+izp07Z695zWvsBS94gV133XX2mc98xs6ePWsnT560EydO2I033mjnzp1b\n", - "vSEhhBBCiG9DRr9E/cIv/IL9yI/8iH3xi1+0z33uc3bttdfaqVOn7OTJk3bffffZq171Kjt16tS3\n", - "8liFEEIIIZ4xjHKizp8/by9+8Yvtq1/9alZ+7bXX2qc+9Sk7duyYnT592n7oh37IvvSlL+U7lBMl\n", - "hBBCiG8jLvWqNCqx/P7777cjR47Y6173OvvTP/1T+/7v/36766677MyZM3bs2DEzMzt27JidOXOG\n", - "rv+2t9yaLVeQVN2ThN269ynRNUSysuTqKvkZt0tIXw0kmbc1n2a72+cJxR94/22uzpve8RZXhm0f\n", - "yPmxQFg8rEBSjRNUSiSJOJLo2s4gpZn0j7ve+R5Xdttb3pqv1pF08tIn+mLgLGuDuvXrVVW+/Yak\n", - "Uretb7yDhw5kyzvnL7g6p37l/a7so2/88Xx/M98wX5r4BPgvVt+dLT/VH3V1ji2fdmUvaP8iW15P\n", - "/jjPFwdd2QLuh4PB/3T+tvfe5cpuu/WXs+UykBnpSRx53eVlDZn1PJFr6v9o8n0R+7CZWYFZwyTi\n", - "/n3vuSNbPvW6d5P9uyJ/j7D7kc1OAM8XTD6/uCmSKj4gJZq13dt//fZs+U1v98+b2JO09z7fVmhY\n", - "HfJMgHs5kATqjhx9mkA7lCQlvvJt9avvfG+2/Nbbf9nVSck/h7sW0+x9HZYOjs/BRFLwE0nULgs8\n", - "9sbVCdGf8/vfnffHd97yRlenJ/2azmyApPyjO/X+WrHPMCzrov9cbZN/LahTnrL/m+//WVfnp3/V\n", - "Xz+DJPeO/PbVknsGLrF1pC8aSTrHD9KCvPiU7LpD0vn/+LN3uDqXYtTPeW3b2r333muvf/3r7d57\n", - "77X19XX3010IQd86CSGEEOI7llEvUVdffbVdffXV9pKXvMTMzF7zmtfYvffea8ePH7fTp0+bmdlj\n", - "jz1mR4/6v8bNzD71B3/w9X8PPPjgyEMXQgghhNg7Rv2cd/z4cXvWs55l9913n504ccLuueceu/76\n", - "6+3666+3u+++22655Ra7++677dWvfjVd/xUvf3lewCaeFUIIIYR4BjPqJcrM7EMf+pD95E/+pNV1\n", - "bc973vPst3/7t63rOrvpppvswx/+sF1zzTX2sY99jK6LOkVf5IdR9/6wdoP/7XZRTLLlGP1v1Wuu\n", - "xGyj38mWJ4HMHk48jTqubi4mn4WIM26T33LJL5/4c3mf/PkVVf5bMc7EbmbWB/97fUK3YfUk3ZQQ\n", - "iXtAZibv2/wYevNtnsi2AngMVeF/549EKEswI3zXDTvBBH1hp/A96MHyClf21fK52XKz9P31RPOY\n", - "K7umfSjfP/GRHu6vdmVPlYez5SrsujqMBmSDydRfq0g6A2oLrDmJJuW+6qZqJvvZf0R/jOQACnZQ\n", - "QEdcSqL6WQcORiJORkf6NTYenUOePRMAcnsYU7esyysWrX9uVaS7FC3cW8SNackO8W/gbsoc09Xn\n", - "1/b+3u7JhejgcdZhgXkP1cwswLHT/sqeQVAvsSuI0ichkH7G+n4AX5U93wLcIG2cuDo9a8+AnxfE\n", - "OQv+uqe0+vw2Ou9Xtj06Uf550/T++lVwz7TsXuvYtcrLAul35BFrRtzCoYx+ibrhhhvsj/7oj1z5\n", - "PffcM/pghBBCCCG+XVBiuRBCCCHECPQSJYQQQggxAr1ECSGEEEKMYLQT9VcCJLwGxMQmeNltGWau\n", - "bMvmsF1vjC2JHIkuX+y3XJ2CyOYVEbQdRAKMIOrRgDWaCgiSHAnkQ9u0I/vvmbzo0y/9tgmhQMuS\n", - "BZf59ToIMysqIogTeXBtLRe0z2/5a9UTixTD56oBgwLMzDZjHtJ5xg64OmfDZX7FJm/P5yxOuyo/\n", - "sPM5V/aSNi97aHaVq/NHEy+3b8a8rBsgtpqZRfi7qSDhrJMJCRwEYTrVvg4Vg+ERg93HjAxyuHig\n", - "3zSBBEiS0zN0ZDtyP7YYIGlmzaxfWacjz6AC7q1AEgcDkb+RRExodn4RBg8US7+/2Q6RzXdyOTl0\n", - "JMCxJANu1vPjqslxsmeQ2zZpl0RCMwN0jkj6PtsdSses3xUkmBiDGOkgoAEfpZEEciZyoAUERBfs\n", - "gQrP/YYMxmKN0EHn78iArbYnkvqA61d5r9ywOVv2EUYaFIdQ9aROTyT1APcfE8sTEdLpAI2B6Jso\n", - "IYQQQogR6CVKCCGEEGIEeokSQgghhBjBnjhRCX4aRmegMv/jKisrYPLEmrhULXGp6naZLfckHHJi\n", - "C38MvS9DmLfU4e/65AdYNrkw/vjOJhJu0d0i59KQMLoC358HOlHJ/T5PfBKyPzy9UBEXgPkI0HZn\n", - "Hz/v6hw+ut+VVdO8L9Q7w370frrcyJafjIddnY44A1fWT2TLL13+mavzssW9ruy7Qj5J91ea57o6\n", - "O8XclWG7B+LwMVrwhnrir0yIm1Y4F8bvb5tMdNujp0T8IxaS6cMnV4c1Uq2QhCdicF839X1jd8Of\n", - "32KePzfamQ+/ZQGcBQT5FbV/7DJvCWFhm0Y8MJyUuCIiSkWcqPULeb2yJq7KxJdtQWBj7ybsNesG\n", - "fdIM8JHMLMKFTiT5FQOOzXwPos1Jt4VHudpf5bDnsL82BUxAjJ6PmVmfYD3mhbL7KuXPrt6I/0Qm\n", - "LkanlVE1JNgS2671bdAQ9y5V8JwiYbRxYHipW496hOOlKH0TJYQQQggxAr1ECSGEEEKMQC9RQggh\n", - "hBAj0EuUEEIIIcQI9kQsj6D0VTAN+EHbduscKi+4slnaly1vwbKZWU3EuQ4COJfmA8cKMrN0HCQP\n", - "EpkPwz1ZHbLtEiVxklSIvl9LtkODPLFsYFijCyojaX/JvKRXzXLBv+28fDohgZhb53ey5Z1tP/38\n", - "C5/1PFdW1/n264UP6WTsFnlfWEYvdZetP/Yr26ez5efVD7g6+8KmK3ukOJ4tf9n8uTwdfbhniPm2\n", - "JgPF8t0FyMPk76j1qS+bFPn9UEW/v0iuO4rPLDSP3Q9Yj0rVQEvuD3zWmJl107xsscbEci+N7+7P\n", - "y9o13xf7CbmPYVPFlh/sMiXPqWH4/fUJpVx/PUsSbFnC2J0JGSjArkMNAnrb+m3XLAwSYMeZku9n\n", - "eAiRDsphKasQXrzyiC6xKfY4HdA/A7s/2LMSQjlT79ugRyGdHFMXfJvjZ19L5XPWp/z2kYo9gkDY\n", - "Lsk9WrDwSxhQVHjX3UgXdmG3gXRYMvbDAjmGoeibKCGEEEKIEeglSgghhBBiBHqJEkIIIYQYgV6i\n", - "hBBCCCFGsCdieQ/vblXKBc3L7Cm3zmWtL9sBCfiBdLWr80j0ZUvLxc7dtO4PknhmxQB5t2Cvpc7K\n", - "I7Oxs+RvtMaJEdejmMgE9ZLJg3nZEHHwIiik+xWnE28BRkgQrreWrs5kw3fHp5/KBxQcPnrA1bn6\n", - "mitc2af/j/8nW079YI00h0jkbODD8S5PLN+IXmR/cHbUlX2+vC5bvrd8oatzofLtchVsf70dJs63\n", - "bS4w7zb+/HZrf03XZ3nZ+tTXaUmKuYHo6fq0EUnW/P1AB0cgJCmbXfYaumc988e0IGnki/V8xoJm\n", - "w89gkEqSSl3nD4VZIlI36WcIe0YwcR7t756lthMBHssiuVYYlH0RPHZyTEMeMPQSs+RxkI7J+fVk\n", - "4EqEh3PHjolJx3gIbPCOX83vn2akk+sOU3qEAQcVWNo7KcPP3kQtefL5NOTrFnIqOGiEhK/blJxf\n", - "BRU7fztaSwYUYDi/+3w0PjNGGP4B6NA3UUIIIYQQI9BLlBBCCCHECPQSJYQQQggxgj1xonZC7mWs\n", - "xfwHz0nyvsxV6WFXVjbgW5TEqUmHXNkyrWXLdfJBd0X0bsPM/HE52MTSUNiR39QL8qNzD75RR2aa\n", - "xm2R7DQ6AzYGYg7+SRhn5Sbhaewn/OUyT/JDP+FS6+FxPv/673J1zj9BQiwfeDJbPnGtX48CM4qX\n", - "xA/Y1+24sv1d7m5txjVX58tTfwz/Z/kD2fKD0de5rHjclR3tz+TH1PvgR0YLF3Br198zU+Jgzaq8\n", - "XdZn3keomH8AZYl4fakbMIP6ACcqJbId4vCgktQV/l5vJ17waKv8OdVNvKiRMFnTzCKEHnYLv7+e\n", - "+Fwevx7zXgLMbt9Xfr2F754W4To0JHSVOmZr+BwmLhUJZ0UCeQYyZydGDBNlzhAL7oR6JMiTukXQ\n", - "r2hPHBDETJ020q/R+RqyHt099XPzcw6R3DMj9aDYkSBN3BbpQAW5fiWEXXekDTryGd2C/4vLZj6Q\n", - "08wsxZHOrOmbKCGEEEKIUeglSgghhBBiBHqJEkIIIYQYgV6ihBBCCCFGsCdi+bnp5dnyTpOHXU7N\n", - "i8JH0mOu7DKQeVk4XEHEvQj2NcqvZpeYkT6QxC/cHw2Hw2A0ZlCzYwCBkoq7eC7DJMveHdOw92nf\n", - "nP58ezbrOITfVZUP5Gxqv976Rt431mdTV+fL/++Drqwq8+1PN8g04ISF5dtPJBhxH+mf85AHcD49\n", - "9QMavlg915U9WOVhsD0xRI+EM67sWH82Ww7esaSgpLpo/flt7Xobez7JB1+w+6MnciZmsbJeVrBQ\n", - "QLhHUbZlsGvFZqR3ZSSskRT5LE82jTxpA1wv0GNafQFp4CEL4MVQYH/LWE2uX1fkHwdF7/sBc/cT\n", - "iOT9jAjw5WqxnA24YR2mTzgohonXfj3ceiz8x18i0jFuiw6mGeAl00E/7HHtPpaJHD0gNDOQgQhF\n", - "AYMjUu3q+P2bFSRU2a3HPjKhrOr8dmZLf5zTOl+RdHMLJPy6hgFLy6k/l52J79c1GUwzFH0TJYQQ\n", - "QggxAr1ECSGEEEKMQC9RQgghhBAj0EuUEEIIIcQI9kQs34bE8vPlRrYcib3IZjk/GvJU6qfCYVen\n", - "D14oLts8ebyqSGJq8OnkBUt3dTtcLSZSQ5SkNmM1JqQGcOQSSydnM8QPmpabrAZmectmSycCJYrk\n", - "zCFlM6+vz3MrdvuCFyHPPnnelV1+9GC+P2YKEzpo0EnvpcdD6YIr24h5ivlTcd3VqfFimdn+kB/7\n", - "IXvS1Xle+poru6zJ67XdhqvDmE8hlbolYjKJ+V7AmIpJ6fsPmVTd9WvsP2aX6LNg4Q4ILDcWgs/u\n", - "WDzM0PkDLxu/w8kSkseJLJ0av8eqy9eLC7+/yYBHC6b3m5lZQeRvSAfHmQ/MzOqSPEtmsB3y3IhU\n", - "YHb2sKvTDfikieyRxARxfMYyY5v1Mzjlng7wIbNJQF+PRq77gMTyzvzMGIEMKCgGDKpAsZwOjmAD\n", - "kdp8f6X5wVI9O7+4+gIWZGAHppEXRCwnIf9OLF8jg45K0nYt3A47rT/u2M1c2Q5JWx+KvokSQggh\n", - "hBiBXqKEEEIIIUaglyghhBBCiBHsiRM1KfIZ5xcx/43y8faIW4f9JPt0m4d2st+OifJh82qRLQfz\n", - "ns209E5UYElzbofEI8Cfr8nv9YGIRE2d/+Y7JDg0EbGgJ79Dd/B7eUWFBE/Xo+Pi6wSyreRm7yYO\n", - "GNlfBHfrwoUdX4fIMPsO505SS1w1RofGDPO7eha6mrdxS/yHisw6fqzPgzS/Kz3k6jy7ecSVrXf5\n", - "th7p9pNj8syrvK8v15iLt9q9WZLZ2EvqoUBgLPFXWNArDTRcCTkXes/ky2Xt74/pggQOxtzPa1h+\n", - "JOmLBYRylsSJqpYDzpfdouyZBPdfX5A65MEYqryev2ep8umeu4H4Od2Q60mfr8T1KTBokpwLlejS\n", - "yjoYRnsReObRQOPVTlRPP27JRcV7hGw7goCYyDOehm2CA9UnJjKywOjVYanssYFuIwsX7QNpF3DM\n", - "YufPZUL6cAmpnB1JAK3Jc7gd4HxdCn0TJYQQQggxAr1ECSGEEEKMQC9RQgghhBAj0EuUEEIIIcQI\n", - "9kQsX7c8YDCB4LcovJS72fmpyFPMZdoJEekmJEwswMzVBREvexZsOSTwjzqHubzHQiVj6S8Fhmuy\n", - "TLkEIjSbyZ6F7bltkSBIhs/oZHImEfxBuJ+Q822IPIjt0iz9IIDJ3PeN6Voe7rm1s+XqMNqU972W\n", - "zGR/IezzK8Ipn0te9GZBc4chuHPDFq5O1665stNtHiz7qF3pj4kwm+b3w5zI2C3ze/G6k2TNklz3\n", - "uoe+TvonE9kDhm2m1WJrT8V2UtbmZWXtnze2Q2T3Ni8rJuTxSWaWx2dC7Py2y3r1o7gf0E5mZuiD\n", - "hyH3v7Fnia+DA1kurocH5ddj18ZtmwyuSYVvlwTPU+pGM897QB9iA3xQXGd9qh8wcIX4zC7c18ys\n", - "A8G+IMI9PudxAI4Zd91dERkEwAZ60M6Am2JiOXZGcrHY4C+4Rd1AKDOzjsr8EO5Jnt8VCdItSfjs\n", - "UPRNlBBCCCHECPQSJYQQQggxAr1ECSGEEEKMQC9RQgghhBAjCGnI9NPfyh0OsbOFEEIIIZ4hXOpV\n", - "Sd9ECSGEEEKMQC9RQgghhBAj0EuUEEIIIcQI9iRs8+d+5dZseQL5iWXt3+2qXe9Sre3mh7+25YO1\n", - "ptv+FCdLKOj9/urKFdlykv8m+saPvsXVefPtt/kVgYKEtZUkVK7rcSZrkma2A8GhLCeNXOUOQuVI\n", - "E9id732fK3vbG96Zb5v8ThxJt+r7vCyQ4LnQkWA9CE+LbDZx+lM1nBBJgnvXv7rVld3+9rysICF2\n", - "kZxzwmtFAvLYtiooakloX0dCAhs4v5YkHL7nPb/iym59x5uzZQyCNeNhe33fQh0GC17FWdxZiK0/\n", - "hgTheokE673vXaey5X/2wV92ddZJsOXabr489/mtNsNnhJmV3epzaUnw4wKeG/XEt9Oi9Mf5r992\n", - "e7b8plvf7ursBB80u2v5w2s3+bDWJpEHHFyrKUkOLpNvmAnckyW5uVl/+c335n3xTXfeQg6JrYnX\n", - "wd8fidx/+HBkWY0lCWdcXsjPZ385d3Xi0h/nO97/jmz5jlvf6Opg8LOZWQXtWXU7vk4Pz336EPR9\n", - "qot5WR99P+iCL4tl3p5veM9vuTo/9zO/TY4hP66W3euBXCsIrY2F71NFQdquXMLyrqsTSeppFfJt\n", - "3fHeU67OpdA3UUIIIYQQI9BLlBBCCCHECPQSJYQQQggxAr1ECSGEEEKMYE/EcpyNvK1wxnYvyVU4\n", - "rbOZhQXOdu3rzBpXZGu7KBgS0RNnnzaznsx4jRTEg0RZmDmPfU+2DSJkRd55dxcgIe6fuTo1Ez2r\n", - "/NL37KAIAWVTNlN48vuLRX6cfeHlxb71giiKyYHtsCONDn0oMCGd0IFh35G+wSaNj06YXD3zuplZ\n", - "hHoVGRkQOnLsODBg2OmZwfnQy06M2xjz80OR3swssD4c8fqRv9uITA+rWT8gpHfK7n8ygGFW5/Xm\n", - "O37/811/LtMuL8NBD2Zmu0QaD9B2rAm6uPoCrkcv0kZ2raCtOtI5OvI8TXBgrG+wJ2CPgwBI3x8C\n", - "DqQxMyqW4/OlJ8+bggzUQSE9dWSASOOPfQ3k66r3217sLsj+cto4cWVkvIsVKf/Q6sw/K1EkDz15\n", - "xkff0RJ8rnXkipKxGGZkAIqvQz5s8fqRe5R93scib5hAPsPK4PdXxVwsL4K/Z5iQXpJ6Q9E3UUII\n", - "IYQQI9BLlBBCCCHECPQSJYQQQggxAr1ECSGEEEKMYE/EcgzLTZBO2hLRrCHeJQrpPdqoZhaJrFg1\n", - "UEYkcpbnWw1pLSbAgkzHhL+eZPqur+WS+PKxC353y1y4i0RMZr6mwTGgwH0pAqYDkzbvybt5KvP1\n", - "qNBI5MWI9Yj4GYnoGerVgxUY2M3c/s0skbbqQG5P7NYifbiEc46Vr1SRNi7ASB129czw76bA+isR\n", - "vVNYPRhj0KZIHRShzUga+IDLVxEjtlz6FTGN/MCO3/++LS+tzmoQmsm9dt4HiFsHA1Jqcv9PBjxb\n", - "psHLy33w/aXGPmVeaGYp8Tiogj2HA0ndL1BIZ/e/K/GwOrxfw+wA5P6oSt+gDXyIJDJgo4r+AsaQ\n", - "t1+9TYRmNuUD7p+koZekPfHjKZI62Fb0OdX548R7jd/H5P5vV1/BnvQpHEiSSDslMmALn0tsAEUo\n", - "/PmVJSS5l/6eKaJfb0K2NRR9EyWEEEIIMQK9RAkhhBBCjEAvUUIIIYQQI9ibsE0I0nJhbcSRaEhg\n", - "3GKa15vNiB+w5t8Ta8jVKskM3ESzsVCsDpFjoZXoJKFfYmZWESmihHyxC09tuTqTNfgNv2ShaMTw\n", - "gkNgwXMM59CQtLhEfl9Os3z7HblWLTl03HxckPf+Hb9igbPbN8OsIe9qkb7BJDNwC7qWzKDe+utQ\n", - "N3m9SALrphO/v97yzlGwmdAJPUhKkQSAskC8iEGFLGyT/E2GJR2bsJ0k1GI/Y/tDSuLLVeS6r0FI\n", - "78bm0tW5/IIvW4cHx4I4UemAD7tdNnn/XJI2wEBexoy4HKxVGss9kJl5z2dB/JyAfYG4oixIEx9n\n", - "zKkZ8vc6zXhkQawQXso80IY8z+pl3n77J75dysa3y85mvt6s83VmYfVH6TJ4N4191uFlSMRNS5Yf\n", - "EwujZE889Jb6gX7uIKhnB6GgdNPMico/HyLp+1Xp79Gy3IFl4kQxl4q031D0TZQQQgghxAj0EiWE\n", - "EEIIMQK9RAkhhBBCjEAvUUIIIYQQI9gjsTwXyVoM0iq8dNwzcQ+kw20SnhbZbOUp39Zs179LtiQA\n", - "rGYJnCuOycysAOEuEfl8QsLh+idykbzf8ZLc5PjBfNtzv5126aW5CLIiEzgZHUiHPZGQU0nabr6b\n", - "r3fYn0uabfoyMPybzTVXpzi7zx8oSNyhHdbV0bNkYa2RiNA1JOTVJPjx/DYJg8QwuuTl0wPsQOEY\n", - "wsBZyPG6B3J+iVxTHDARyaODC7A5zCtNJEjP/Xk3ICyV5JTajDwTZhC6uFH7+2N9a9eVre3mZXHm\n", - "xeTtNf+QKEB4j2TQAfG1/XaSv8ZrpEExzLfu/LnsRjKKwwUhsmBN354lSMAFu57kmYfQ4EdW0T27\n", - "/P7aJRmgAc/Y+cQPAtg85/tCs5WXHZ77a4yDgBh19Pc2C6gsoR0qUgdt/sSCZjEY2chYgcIfU8sG\n", - "iJDPQ7dtNvgD9scHJpDPJxDJy4JI5IXv11WVf66U0dcJ5PPJyICeoeibKCGEEEKIEeglSgghhBBi\n", - "BHqJEkIIIYQYgV6ihBBCCCFGsCdiOc7a7J04ltDsJbk0g5meSUptaIlsDuIec46Z0NiR2cL9ikRS\n", - "h5jm+czL0WtEHtx8GsRysvvqsv3Z8pZ5Qa4jMdGY8ouze1+Krssbix1TVxDRcy2/DuWBJ12d2cHT\n", - "rqxvQCy3Y37bO749ezi/nqW2E3A29Ipc88gkWRC9G/LnCc7Obmb2FEirPUkQZ0rnbJrXm9Ckeka+\n", - "XsEEY9L7UwdluGxmgfR9NKaJO8ydcZBUMTGdUZE6JXkmlPBIKBr/jChakgCNZUQQD0RkDyjlk2Yq\n", - "WCEwJXJvn/wAjRISw0kIt7VOIjfbhgvRk4TtSGTlCp7NkcwuwZ6LbtukDibsm5HeSfp9re9GAAAg\n", - "AElEQVRPRQZ/zMr8fJZbZNaELb+/Nbh+R8nggW0/JsbR4SwKZmZkFgx8VnXJ98U+5nVSQdLCO983\n", - "MNmczZ7Bvlthz3kEP9cv7m/1gIJY+PMryxqWvSA+mfgyl1heeSHdyMAHNhZiKPomSgghhBBiBHqJ\n", - "EkIIIYQYgV6ihBBCCCFGsDdOFP4ODL+b9ux3WvLbcYLfd2vy4/g2ma0cnagZcXgK4jsQDcTBMisr\n", - "CHlbI7OH12f9j+qLrfz33dkRH7sYNvJtNed3XJ1Ijqks85PpBoThmXlvIZGNp0iCGCN4E8UFf0zF\n", - "Wb8eeBldedDVIXmqRDwZ9vcC9oSOCDtMjSuhHdYr76YdnJMQS3BTOtKe5Fd9K8EZwoC+S5Iw+JVJ\n", - "Sr4owHEyV4WFbeLWexK2V1Tk2sCKPTXDYP/kmFiv7sD/a4hPtpyQ0FoQ3eqpX29REp8E7n+ivVka\n", - "4o703h1hTTcrchcGA1bNzBJxRScQcLhMPoyyI/2lhIvFwjZZyCLCshqJXYUfF1YRn2xSeW9pcSE/\n", - "v3lY98ew4z2bA7CpIxs+3PeJ01uuDOlo2KY/aQw0Lsnnk3NTiQ84oWGp+dOEqbBUjx0SlkpCsrEv\n", - "JBbWWvoQ2aLKP8cmU/+5Nplsu7IZ1AvRP4cTOcGOOIJD0TdRQgghhBAj0EuUEEIIIcQI9BIlhBBC\n", - "CDECvUQJIYQQQoxgT8RyFLQDiHMtm+mZyOapyustmRxGzMQCAvhQejYzq2oiRw4wywMR/IoCJMCF\n", - "F+mW57xoHWf5etXhDVcHg0qbhdeQJywQE86PSbmMAqxOJgoWHQmHA1E/LHxAZtrx0njXgQi962XX\n", - "gkzAjTLtkNA3My/OssnLG9JWGHBYERn0wMyXVRB2yQZVzCq/vwgC+hDx2owMfGBieUsEcViR9fMh\n", - "MGm1Z2mbUDbEm09EMGahp0tozwtTMhBi3ffPapJfq2bNi8Lb637QyAKCUWtyTO2AtD8miJfB339T\n", - "uCcLUidg4qiZTeG5uBv8fbzsSGgtPnfZ82ZAf0mkDg4CMjOLcK8FYurXCxJMCmm3BRu/tPQC8/Un\n", - "npctd1t+QMGZJ9jwj5yGfNwGUtbj5wV5CDHBH2ECdQUDS/A5YubDYc3MIukLbr3o60Tse6ROWflQ\n", - "0OkExHIikU9KX1ZB2Cb7bO+Sb/P4V3gV0jdRQgghhBAjGP0Sdeedd9r1119vL3rRi+wnfuInbLlc\n", - "2tmzZ+3kyZN24sQJu/HGG+3cuXPfymMVQgghhHjGMOol6oEHHrDf+q3fsnvvvdf+7M/+zLqus498\n", - "5CN26tQpO3nypN133332qle9yk6dOvWtPl4hhBBCiGcEo16i9u/fb1VV2c7OjrVtazs7O3bllVfa\n", - "Jz7xCbv55pvNzOzmm2+2j3/849/SgxVCCCGEeKYwyqY6fPiwvfGNb7RnP/vZtra2Zj/8wz9sJ0+e\n", - "tDNnztixY8fMzOzYsWN25swZuj5qeSjABSLEscDUACnmbUmEXyLlNlOUh4m0zoQ7Nh061iF+aAES\n", - "YLNLZl4viXS4v4JlL7suQFLvFkQAJAIsHmgshnWFBKnJTHYNDRETt3PhtiuPuDo7u/78Isj8YdOn\n", - "tselP78Cj6EbJpZjHHlgieVU6gSRncy8PiX9M4S8T7Xu7jAriViKci0TRBkFiOvYNy9FB3HSLOk8\n", - "sNnRXbXVErmZF9eHzCLfEDG5It16CaL35oav1BDruOryPlyTOos5ScqG501N+gFLTUdIyLhNS3Id\n", - "oI1nRgZ6kGPv4W9qNqiCiewdzFDAhOZmQCJ0JCdYFOz8YFs4usbMmi0/eGejAul/28vgzzrkB+9c\n", - "vp4PePkP/+l+V6eOPv0cSeQ7CyaI9yh/k3smxXyATU2eN2yqCrzVCjIwKJD14oDvWyKRxgtIDI+F\n", - "b/NpRdLIq3wGj9nE1ylL/zkai/wYEmm7lpR1w8blUEZ9E/WVr3zF7rrrLnvggQfs0Ucfta2tLfud\n", - "3/mdrE4Igb4MCSGEEEJ8JzDqm6g//uM/tpe97GV22WWXmZnZj//4j9unP/1pO378uJ0+fdqOHz9u\n", - "jz32mB09epSuf+/vffrr/33F91xtx1941ZjDEEIIIYTYM0a9RF177bV2xx132O7urs1mM7vnnnvs\n", - "pS99qa2vr9vdd99tt9xyi91999326le/mq7/ff/k72bLQyanFEIIIYR4JjHqJeqGG26wn/qpn7If\n", - "+IEfsBijfd/3fZ/9zM/8jG1ubtpNN91kH/7wh+2aa66xj33sY3R99EwChKCRzDwaxIYhb+y3YzaP\n", - "O+Q3WkN+dzeiERXELUDYT5ihh9+dO/87dJx4J6ItIIiReAy72/lvxcwhiMwrADemH+jGGGyrIMGT\n", - "ofXHGbbz3/D7jsxoXnrfKUFTla13TuI2CU/DcM+Bp4deT2Ihr3RG87wea07mUuEM9In8OB+YLoM3\n", - "CQusJBQJvRfiHzJHKWEdv23WLAlCR1loLrtv0cEaku1J1Bh6by9KuMYz4tQQR6mAY2rJ/ViT58YC\n", - "2qAj63Vx9Qkuzff9gjxL8GIxL4SVlfB8mxA/r6UGSH7sLfGfygHmSMBrbmZl9MewaHLPhuVAzsl6\n", - "6zFvv9T5lN7DG4dc2Z/fl0f13H96y9W56oWX+4MAeuItJXbd4dBZUGkK+TMvkL4RjKQQw0c+y4+O\n", - "5EYu4+pXhaLwHloJZUWx6+pUpS+blPl6MfhtByLt4XOpIw/PloRtdoncuAMZHdP55je/2d785jdn\n", - "ZYcPH7Z77rln9MEIIYQQQny7oMRyIYQQQogR6CVKCCGEEGIEeokSQgghhBjB+KmL/woEJ7OC7MoE\n", - "VRbACdthaiYTNosy3183IWGGxMlLzFwFmByZQCxnIXYNsenbSX55CmLzdm3eWEXlRbpQ+LIewyiH\n", - "ho2B2E2lRyJHxw5mJvc5aRaYAI/iOkr6ZhYbIn/D/qjpTeihIVo0282MuPTWgcxbkL9PqEANAx9o\n", - "e5L9YcZiN1AsbyCMNRIJuCVhqSibJ9LP2Q0YIeSUSfIFWbGAgRYdE6iBJZGJY8VGqeTH3pMbsib3\n", - "PwYOpuDbqS18WQ33ZOMdYD64Bbfd+uNcsoEsUK0kz8BAQhZRrWWBqokEqmJ4YU3E3SEDV0oy6KBZ\n", - "+gsxgU40IUHFWMfMLO3m58xCgc+e8wLzQw/lwY/Ty3wg59ErfZnbPzk/I8I23losCDLCR3csZq5O\n", - "y54JsPGChKeW5LWgZSnSuF7pr1UJ4ZqTwj/4ZySAs7L8OkzIADH2eejeLVjIa09ee4ak+V4CfRMl\n", - "hBBCCDECvUQJIYQQQoxAL1FCCCGEECPQS5QQQgghxAhCYvHEf5071KTEQgghhPg24lKvSvomSggh\n", - "hBBiBHqJEkIIIYQYgV6ihBBCCCFGsCdhm7/3z38iW64wvZAEey1Ln1C3OZlmyxeqqauzQ9ZbQvgd\n", - "mx29Dr5p6pDXu+vd73B1bn7fL7oyzH1jIX2JJRXCFNusTnAb95shOWVWQAjZhISN/au3nXJlb/3A\n", - "h/LdNT48rV/u+B02eaBau/Azd/ckSDPgjPSdnwkd65j53Me29evd9aF/48pOnfpgvj8SVMhyJkvo\n", - "UwW5s8qKhErG/JxL0jcCmf29x/ZsfJ2f/8V3urJffMMbsuUFCTPser+tqszPb33uw/021ueubH2+\n", - "li3PZr5O2/jrvljmZXXr2+X2t78lW77tX/68q0PvBwg9pLdM5/fXgxMRmCPBQoEh7JYFTwbyvPnV\n", - "D7w/W/6N229zdRqSxNgnCBOmjxYyu32Rr3eBBJw+emHblT345Nls+fyuv7dnM4zyNPvsR/5dtvxf\n", - "vedOV6cg4aUBAnAjOcGCtEsFqbVT0u8mLNwT7oeKhV+2fltv/NB/my3/0h0fcHVYIGYPYaV9XPN1\n", - "4HMN+6aZWYgk1RWenyUJ24ws0Bg2/9/d/t+4Orfe5vtnNcmfE9tbPliz3n3SlV37PSey5Qfv9/1u\n", - "0VxwZZcdzvtZ15IwYZZBCk+B9935Hl/pEuibKCGEEEKIEeglSgghhBBiBHqJEkIIIYQYgV6ihBBC\n", - "CCFGsCdi+QTEtTWQ3RKbtp7Iw9t9Ls6xicIbMkv2Muby2dKIZEnWa4n8icTCb6sHeTiQOpGJ5VAU\n", - "k3/n7bESaYSCzBAfwJ8skz8mBsrfbe1nPY84UMD823pB2qAkZSiNh5K995P9wSnXA0Net3fz8+nI\n", - "3xmBtGeJs6MT2bWi1yZfLxoR55MXPXuQYjsiljMubOcDARYLf/3a1su1KI2vzZgk7++PqsrvtWnl\n", - "60QiOXd9fgxs0AHCgnwTu+4gljOznPWzCKJ1JNsOcfU9GkmfSnhMhLbxB9oRgRqfn2xwBBv4gO1S\n", - "kfXmMy85b8w3suUmeKF5vuYH/TjQXjYzdnHwbiePRfY0tR4H6pDPmTKtFstL8vEUSZk7psWWKytI\n", - "f7GYtxU7zmgwsIP1/d6fS4A+HAJ5bnRkPdqiOT0ZkNK2+fOlIo139NnHXdlTj+eDkx596DFX5++8\n", - "xK/XwQCUp7b9uZRkZEAsx4eA65soIYQQQogR6CVKCCGEEGIEeokSQgghhBiBXqKEEEIIIUawJ2I5\n", - "Jv0WII0GIgoviT2YQDpkEvmi8Em5WyEX92qyXiLCH5OM3XrMiYdt9US8Jt68FXDOdBJpjM9mkixZ\n", - "sYTEciaDMxJKxyTVOJBI7wTbL4nZymbJTpDWTeVhkraODRFpLrVnewGDHMhgglD6MvDDrSDHVLJr\n", - "DDItcXktkk7VNVA27PLZDojkW9skXZ71lwkkJBPRNJZeEMek6unUS8cscR6FaRRGGYn0u0ANalhv\n", - "ZY2L4Pmxe5auFyGxnLUdS5cGWD9HWdrMrIN7rScH2jPpGKuRfjcjAvzlG/uy5f3r+10dTPRndGTb\n", - "TBpP8LEVBg5EijCAiQ0MqMiNNIO2KlnkdbtaTJ6Qm7slx4CnzGYswOdiH9lgJTIoJuT3f0H6QST7\n", - "G3KT1I1PI3/uVVdny1/43JdcnfnsgCvb2c53ePU1B12d2dyf831fOJctr+3zfdEKP5iGCv4D0TdR\n", - "QgghhBAj0EuUEEIIIcQI9BIlhBBCCDGCPXGiavj9Fn8rZoF1DfEtljCT9U7pvYLN0jtRO0UeVNaS\n", - "/SXiLTCXAYnEWwjwwz4LzQzsfbZDr4fUwZBHsu1IZqSfQD026zkjgQOVSAhiR8IaI3g2HfMY6A7z\n", - "ei1xsJhH1CUMBR0WRrm7RJ/EH2ciwZaxyftnJLPPlxXxpKDLFkQ+KFmoI4SjMg+NEWD7LPSUdfMK\n", - "QjKZ48K8AvRVenL9mCPofJwBYZtsJvuClOH+2POG+TLO2SPbZs6e3x/zn1b/PRuIu2kkiDVAeDAN\n", - "BaXhs3nZlAUOMzlmmj9jE/HQIvEI3baHBKNeLMyXEvEridtUOE+KuDGkf07gfp8QP69n8hbSkv2R\n", - "oFkUHFmdHp7XReU/59g9E/vcW4rkmLg/utppu/yYD7988CuPZ8tbF552da7/4f/Mlf2vn/iTbPnI\n", - "lf6e2d7216Ht874w3yDvEiy0doBzeSn0TZQQQgghxAj0EiWEEEIIMQK9RAkhhBBCjEAvUUIIIYQQ\n", - "I9gTsRyFcAzbS2Q2763KzwJ+YZIL4hdAGDcz2y78rOO7EMBJ8uqMpYvFATOtV4nMSF/n22K7Y/Kw\n", - "4bZYkCYc/JRthzjVJYjI1RAx0vyM4igqm5lFYno7mZ7I7ixMFCVZI6I3mz3cBdYNGBRgZlY3q4MK\n", - "WxZQB0maJPvOYuPbuALZPJLp4CfsLoX2KwdGRs7m+f1QTLyQymTzfbBeNTAsdVnnbdWRoMLFwl+/\n", - "ps6l2OXSC7AeFtbKghhX9wV2LijFswENRiRg3F3HQkHpxvCYyAAYcn7Y1+m2mWyO9whZbZ30jRIO\n", - "K5E6LLzY1yGFTKqGY0+JifNssBAOViADEcgghwmUVaTOkGErNNCYtHER837Wkc+UHgMx612/P/Ls\n", - "CiCbM4mchZf2AwZ2JPJ8e/D+L2fL//S//C9cna/++eOu7C/+/MFs+e/9w3/g6nzmD+93ZbO1/HlW\n", - "Vf64t7d8GQ6c+WbQN1FCCCGEECPQS5QQQgghxAj0EiWEEEIIMQK9RAkhhBBCjGBPxPJdkLha8OY6\n", - "IiGiRG5mdqGaZ8s7sGzmJXIzs2UBM9IT8bKwgcnKQGzZtOOrxXKWNI5eYE9k7BKTx8nWi57IoLCp\n", - "cpiXbAlniGdtwsRZlBXJ/tj5IZG1Hl0NBfhh9JBc2wU2g7rfWgdqKU2gJ/0MA5ID2XZion7I7yEm\n", - "5TMO7N/It0MkYCZZTqGsKvz59eS6b23lCcl952d6Xy68qI/J9NjvGCyxnEmyOBtBYrPdMyEd+z45\n", - "htSR6w5tl0hieaDJ1QgTy1nPztuhJzI/3R1si4negVz3EiTuntzc7YB7m10/FpTdYjuwZwkbZOCa\n", - "is3uQGYMgL5YDuiLDDbjBWlOlzQeycCZCY45IuI3m8UAB0wEOmPB0IT7nEceetSV/d2XX58tnz/n\n", - "B4j8/n/4rCv7sde8LFve2fHPja98+RFX9sobb8iWnzjtjyn2bDDN+O+T9E2UEEIIIcQI9BIlhBBC\n", - "CDECvUQJIYQQQoxgT5yoRZn/DlvDYdQkqfACCdvEAM4dEgDYYBKcmTXgXPVUK/CFZbH6d+EJCRxD\n", - "l4LtMJIsswKOISTvUkTYFrugJfE78ChZMBujAJ/MovdZWDO5jEwWdEeuuwsTJDoCC0ENzkMb5jGg\n", - "C1OQvzNK4hG4QEPaBmxW9XxbVD1gjhnUiyzdk7D/YO5EzWc+jHZC0j2x/ZqFdxt2ibewtZmHAO7u\n", - "+jr1kvUh6NcD7j3mZAUSzup7P/GmyLXCwMGe3Mfl1PsW5WxfvveJb3P0tBgd8YrY2aGPR4NDqdCV\n", - "HwPRg6whbdzCs4M+Twd80gTiwtKnEhwD7fvk4DHwl2Q6W0H2iAGc1YDgSQbrw6yfRcNQV1+naPMy\n", - "9nyjbYdtRSq1LNQ1+M8e5MjRg66s3s3P+fN/cp+r87JX3ODKDhzKHeh7Pum9qRte/N2uLBZ5u5x9\n", - "asfVufrZh1zZ9u62KxuKvokSQgghhBiBXqKEEEIIIUaglyghhBBCiBHoJUoIIYQQYgR7JJbnkloL\n", - "yW9MLN8iYZs7EFq3JGJ5ywIOXVabr4MzhZtxcRWZekfWJtDMsfbbmXREUoUyDNa8eFD5Ip1Ynp4f\n", - "SLLlsDhKFKgjkUEDs1bhlCO5LnTmdZjBvGvYtsl1caL8sPPr21yYZs5qQQRRlHlZm7PjRO+ZieWR\n", - "BXDCtpyAfwnma/l9tG/dS87zub/XMAh1y7yIicGaZmab27lY/vTZC67Ogsjmkyq/t/et+4El7hhJ\n", - "N2CDDlzSJO0/A8JSo5fIq43LXNm+y67MlouZDwWua98Gfv/sb15/7J0LVBwmbLv7j7Yd64t5GXt2\n", - "BpaaidshvnYgR1piWOqA+8rMLPa4TKRuduywYsCEXOMhua5O6wdjsCuBInlh/kMl9ljGhxi4vaX8\n", - "s6iP/jOzCL6s68gHG65HnosPPHA6Wz5x/XPJUfr2/PT/9fls+bnf8xxX57KjG67s85/7UrZ85VVX\n", - "uDodaU8eWjsMfRMlhBBCCDECvUQJIYQQQoxAL1FCCCGEECPQS5QQQgghxAj2RCzfKXJxtQGBcUlm\n", - "Od+KXiyti1zs7Ngs5wPeEwNL605+5uwBE1nbhMiRM0jPnRFHb6Pz4uWkydebsHPBQG+WMkykwwYk\n", - "2XqgV4epyYOcbmNtxwROcn6wg7IiXZZJpDgjPTtQRgfyJ3WOSaoxypgktpm6yigBs8Mk54cyZiJy\n", - "JqOC9pvOiBw98fdfW8P9QE6GDbzYhWTzzW2fILxc+BtiNsn3N5sOEJNRGDezRIXm1c8Edi44yGEy\n", - "3+fqzA8edWWHjj9r5XoXNs+tPKaOicLsOkCHYbI0e5gFTOJndejgDxw1QtKtByTqozBuxgXx1ENf\n", - "JANupmRwS9XnfbEkYjnOWGBm1kN/aYmM3Q0Q58swUGhGadxJ5GYRHwpEdmfXD/sGE/fZR8GACQNs\n", - "d3vhyq64Mh9okcjn6oNffdSVXf3sfDDGdO6fU1/98oOu7PLL8/2Vle8bF877Z1BZrk5kvxT6JkoI\n", - "IYQQYgR6iRJCCCGEGIFeooQQQgghRrAnTtSyzHe7hN+Tl4X//bMuiKcB61G3iQgleNLMI2KzebPf\n", - "j916DQlPQ7cJ0z7NbJ3MOj6Hn49L8nt9AW3AZllfkt+zF/DLd10PC2vEn9lpRtkAeYy1JPOWEroN\n", - "LFhvwLaGKlEYYsd8Ejb7OwaM0t/Y2Z8s0GcjOZuCrOj0sYEn2EM/q5fet2C3Udt033DZzKylaZd5\n", - "/4ykXWLhPQkM7hviIwbm3RBPKsDGetbviOMS4blF3R+yP2yDQEKBA1vPH4ArapMP6US3sGXKJw2D\n", - "hUXiP7HnCz6HmecTWVAwULJ7u/PPJeyfLPxySo6zavN6LLy4J9d9EfLPo5p+zqw+v8p8P09kW/g5\n", - "E0kdPErWvIkEGkdYsyd1eubeDfnsw/vjL7f2/+fpJzddjUOHD7qyySw/oUcefszVWd+3Tspy3/r8\n", - "035/VeX96kgCaYeib6KEEEIIIUaglyghhBBCiBHoJUoIIYQQYgR6iRJCCCGEGMGeiOULECSXMBt6\n", - "QyTLlpR1IMUlYp8yWbEHCZhJq0zwHTLT85T4d2sgaLL56Jk0XsF6BROaIWSRhaIxSb4A+ZS6koSy\n", - "zK9DRyR5Nh17D2UsRK/DED3zYnkgAwVSR4JRoT2bevUs5GZm1ueBcSzEMrUs2A5uJVInlCQM0rU7\n", - "C99jbYyhp74NGMvdPHCQXYem9G2FIavbOz5Yr176WeoncM77981dnR3SaWeTvD0ns9VheC1rJxbg\n", - "CtIxC5B0ErmZRRjcEomUWy93Xdn5s09myyUJHF0sfXsixZRI+aTvR5T5SZ/q2YAJOGcmpJekrTp4\n", - "LrbsOUkGBiGBXL+CyeY9CuLk+UbuvwSDKlpiYy9t9YAQ9qFZ0OEtsF7rrzsbi+EG2LDnIj5j2fOb\n", - "BbEGHOTgB3GxAVpDPh7ajnxmwglO5/7TryXnd+5C3lbr+3xAbTX1V2Lz/Fa2PKn8+ZWlP87l0M8H\n", - "gr6JEkIIIYQYgV6ihBBCCCFGoJcoIYQQQogR6CVKCCGEEGIEIQ2e3v5btMMh0cNCCCGEEM8QLvWq\n", - "pG+ihBBCCCFGoJcoIYQQQogR6CVKCCGEEGIEexK2efub35Yt13X+LteTsLZAEir3X5EHoxUTH9q1\n", - "s7vtyuo6r9e3JIyOhEgWEKj4K+845eq85Y7b/IFCyFtJAiPZDN8Rf4IlyWw4y3kkoaR1z8ryELLd\n", - "1jfwBz9wuyt7w2/8i2yZze7NZiZ3l5Rd454EAMI50/nTaQhqXtaR4Llf+/m7XNntt7wrX2/iAyTb\n", - "qS9LM6gTSYolBnKamUHfL5f+OCdLf/3KRX5+ofFt8I5f+2VX9u5TP58tY1CimbkgTzOfn5rItWLn\n", - "h1vCoFszsxh9wGGLfZ0kzd55+wey5Tf98hv8IdEQxLCyDvMfMLczRH9dAgn37KDtahIEWZNj+I07\n", - "3p8tv/2Wtw46zuD6ng8SjOR500HyalP4Z0I/O+jK2ph3/knr74/p9pOu7J3v+2C2/KY3v93VKUka\n", - "bIFhiSRolq0XMPCXZYK6h64vo+sVfn//8vb8+XLbW8hnAwkmjnBN+44cU8qvadg95+rMGh/8in22\n", - "m+53dVpS1pX5Nb7jzne5Or/0xjv9MWzlz4TZ+Zmvs+kDMSOcczP1fbje78uajWW23M7Is9rvzhq4\n", - "qB885fvipdA3UUIIIYQQI9BLlBBCCCHECPQSJYQQQggxAr1ECSGEEEKMYE/Ecpy0PYBI1+x6ka5v\n", - "fNl0M9/Q7ACRCYno6bxZItcyL3jIK2fvPUHrYXbrOHCWbJS2mSKbQIijjjWZrbw3EAzNS7KMHo+J\n", - "nIsXW70TH9j+mKzs1iPXkzQeeqVDM167KhcR6/nC1VnOl66sA6ERRXMzLmMXi/wW7Hf8imnL36YJ\n", - "ZryvEpl9noAzrXfkmPre7y+CmM8GFGA/N/PhuoEMfGD3DHbkSGZeR4pI7mN20+JNQvoP9nMzs7LI\n", - "jz2Rmw1nrTfzonBV+GMKZOCD2zbpxOTWdg8KFKrNzHojZbD9pvAGblPMyQ7zdpl0Xua1hb+P3LbZ\n", - "vU2eE4s6v7nLwvf9VKweqIOfOxdXJA9+fJbgB9jFFUkZrFf69kytl6NTCc9m2vfzg2JCfL9NpPwe\n", - "2qX3z7LUeSE9kXsLqUh7roEgvm/b97v953wbVDW8E6z7c7lQ+bKtCaxHnsMtuR/cqJFvAn0TJYQQ\n", - "QggxAr1ECSGEEEKMQC9RQgghhBAj0EuUEEIIIcQI9kQsDyCpFSBotksvjC2IkLa2kb8Drq37d8Ky\n", - "IJJszOW6zjuIlmiy8mp5MBLBEAVGJgFWgYiQTtom4i6uRsTdJSlLfS5j9mmYWJ5cEjiTiZkpDNeG\n", - "SuRELG3zskjXI22ObTdA3DUza8p8vXrNX5f6IEkxP7CTH9KcyLXEWY27uWzanmdiq7cjiya/fmU3\n", - "7FYOKGyTlHE+GAOT8YkcPUByZnI9Xc31fTbSI4f5t0z0xv6CfdrMrCRtgHdIi5KumUWyHh55ZPfx\n", - "gPML5LnRkfUKJ86SBHoyIKQOeV+s5z6dvJ9f7sribi4nh/asq1M2q8XynrTdkg2KgT7bEVE4EEF8\n", - "As8l1u9YHyqxIksZH/DZYOQzJRApvofPrFStuTo1PNNj5dPlE0blm9lkcT5fjyTXlyThnqXeIwXp\n", - "Z25QBXlWT0giewn3bcc+j9nAAHi3YANg2CAAdj8MRd9ECSGEEEKMQC9RQgghhBAj0EuUEEIIIcQI\n", - "9iZsE2Zkx1m5S6LntMSJWmzm74D7Dvp3wmpOyvA3ZxYOSX7jTiyIDQjsN1j4vbUg/hObdTxCWU98\n", - "khaCEfvof2PfbUhZm6+3PdCJcqoR/cmZbQuOvSPv741fr1jknkbB1iPBgQmuX+7RqhoAAB3KSURB\n", - "VBrY07Gp6sq7AN0+X9Ye3M6X1zZdncB8oMlGtjzpfSBfveMPvprm9TqfmcdxQbO+SiKuAbpFzCGg\n", - "igJ4Lqy/sP1h2CXzO5BJ5ftG0xAPxYVtEmeIRdvCeiw0k2X2tRgmTFyqYlDYJnH/yHGiB8JCQbvo\n", - "+9myyvtiPTvi91ftc2XFVh7OWJJgzaJZ3UFb0jc64nO2cD7s1q5YMClsvyDPDeb1lLAiC+6NAz4b\n", - "euZuUT8nfwh1LPR0ml+HsH7A74+5jRcgpLf1wZoshDT0q50oL+ia9RBMWs/8MW1uuCKr+vy6L9b8\n", - "Me3MfNlyCvca+ShibmEq5EQJIYQQQvyN8g1fon76p3/ajh07Zi960Yu+Xnb27Fk7efKknThxwm68\n", - "8UY7d+7c1//fnXfeac9//vPt2muvtd///d//6ztqIYQQQog95hu+RL3uda+zT37yk1nZqVOn7OTJ\n", - "k3bffffZq171Kjt16pSZmX3hC1+wj370o/aFL3zBPvnJT9rrX/9668mwRCGEEEKI7wS+4UvUy1/+\n", - "cjt06FBW9olPfMJuvvlmMzO7+eab7eMf/7iZmf3e7/2evfa1r7Wqquyaa66x7/7u77bPfvazf02H\n", - "LYQQQgixt3zTYvmZM2fs2LFjZmZ27NgxO3PmjJmZPfroo/aDP/iDX6939dVX2yOPPEK3EUH2Kie5\n", - "fDabehuMSZwYylnv+m++ZhMSwImzlbODJPLgkJnWWWgeip6RmYlMjoaDSD0RZ8GYXjY+dG2z9mFt\n", - "iy4PcEQB8FIkkMYjsUHZzPKhAxm09rJkseWPfbKV1ws12Tg59n6Sh10282HfiqYC6pFZwJvSB2nW\n", - "VS7T9pWXawP5m6Voc4m0JrPPE6/UoDmtp33K00M3oxI5EZF9YiS7QcgOQbhlwnbPjHR3vw/QN5O/\n", - "kyNZL0Bb0cNmpxfxPl4d5Gnmw3WZwtoPCPtjYjJrOrz/UvSP+WVJAhxnl+X7m/mwzViTEMudPMBx\n", - "snve1akGjHxgIa8dG0wDYZus/3QuGtUMW74kocBTIh3jlnDQgxkPUHV18OYzM0sk6RkDYoMfGGQg\n", - "lnezQ65KIoMHnP+++6SrU5BrxZ4TSFuRYOK1vF22D/p2WvrHvgX4FauZkG2v+7IGwpETWc/IQDIc\n", - "iPTN8FcSy0MI7oGE/18IIYQQ4juRb/qbqGPHjtnp06ft+PHj9thjj9nRo0fNzOyqq66yhx566Ov1\n", - "Hn74YbvqqqvoNu75j5/6+n8/95rvsmdf8bxv9jCEEEIIIfaUb/qbqB/7sR+zu+++28zM7r77bnv1\n", - "q1/99fKPfOQjVte13X///fblL3/ZXvrSl9Jt/P0fesXX/z33mmvGH70QQgghxB7xDb+Jeu1rX2uf\n", - "+tSn7Mknn7RnPetZ9q53vctuvfVWu+mmm+zDH/6wXXPNNfaxj33MzMyuu+46u+mmm+y6666zsizt\n", - "N3/zN/VznhBCCCG+Y/mGL1G/+7u/S8vvueceWn7bbbfZbbfdtnKnOCNzAdNkT9b8F2Qb+7xc14Lt\n", - "utglSeBr/hRjBXI0kTp7Inr7meU9JUnY7QxnDycpyuSFE9OIezqjed4uO62XCc8RibuBSz8ZKtZh\n", - "YjgTaZnLB1Hg1bY/ptnT3jCcP5WXFUvfD1jabLORt93WwQGJu2ZWgLxP3FOLxDoOXX7d05JIskwC\n", - "XubrFS1JNUfR1PxXyEPETzOzZpFL8T2LciciMm4/EJk/lOSPJjgsmvrPBmzgvTYgUZi57h2515xK\n", - "ztKt2Yz0KKSzHbJrDBee/W3ZdQP6J2tz2ix5n+pwJI+ZteW6K+uneep1IHL2dPG0K5ttPpEvL8+5\n", - "OuWA50tPxOsused+3l8imSEBU80vkpcVRGRnydxYjQ68oPuDbZO+H1iKOfSXfveCq9PCcz+Q0SeJ\n", - "zF7RwWCBtvUSORP8bUBieUcGwDQxX6+vyP24j8wYgs888pjqichuFbRnJIMxyOwgQwaNXQollgsh\n", - "hBBCjEAvUUIIIYQQI9BLlBBCCCHECL7piINvBR38Nhwh4HBCflud+Gw4CxDEhu6BmVmz9GXupMnP\n", - "9Wx2dFaG4LldXG8IxHeC39k7UqcFH2BJHJeWeFoYUDck7M/Mh2Yy1QG9IjOzAO5PueV/r18jTtSB\n", - "0/O8ziZpp6lv883L8+VlNewqFA34Ftvk74wLvj3LCjooma0cg0rNzIpl7qbEXZLuufDXtK8h+BFd\n", - "tUtQL3IHomfOUMkCI8EnIeG3ccDjhKkHGEb7l4X5eiu3zB2lgnlEA/52ZN4bHgQNCSX3P/pkg7JF\n", - "CSxQlfk5EW7KnjhRkTg0BXgocceHZs7OP+bK1iCwsex2XR2bkX4NlKxPER8wQRnRFq0mhW0B3mLv\n", - "nZpIPDC3P+ZEDsjyZa5RZJ0B/LhJ648zbEMYZecDgDsI5DTz/i/zpiz55zC9R5GS+EfQF2viRKHb\n", - "bEYCcYmciu8Nf7nHFctmgZTRe3kg+iZKCCGEEGIEeokSQgghhBiBXqKEEEIIIUaglyghhBBCiBHs\n", - "iVjeQtgmhpAxxatgYjCET/YkkK9rvJDmtsV2SGeyXy2fdURQQ3kQhfGL65HZ7VGcZ3qtK/IS4ozM\n", - "ZN2CiFxRSc+DQZqRzLIeWyJQNhAqWXuBc7Ljy+abedn+cyTEkvTiZgqBqoeGdfViN19vWhEh9oK/\n", - "xjUY0+Xa3NXpiHAf63z7020vdU52vPw5qSG8tGWz1ntQEI0sMJKURQjEZYmRfU8E0YiC6LCASuzY\n", - "LIgRKckzom9Xh22yY2IiratG71kmsuaUJJS0I0Kzq0MGJkRi6vvBAn69QNql6rez5SkJAF3bfsKV\n", - "Ve1OfpzRS+s9DrwgsDBKFkxcgGScSH/tybMSH80dabuG9DMcVMGCPCMJzXT7J4J/R1bD84udf35P\n", - "+q28DtlfzwRqCNKNrJ3Yx8yQMFEiluN16II/FxpsDYMMCtK+bFAMCuKRfqyxExw/u4q+iRJCCCGE\n", - "GIFeooQQQgghRqCXKCGEEEKIEeyJE9WDG9LC75FM0wgkADC18Psn2Vcizk7fYRlLACQ/Vg/62ZT9\n", - "xgx+Bwt0I1vC9RKZgDjA78lTnIDR+O/Qqcx/LC7JRI2MEn4bD8QBYXPFYjAqm6uW9cYEQZqhIs4Z\n", - "8bkwVI799s+YLsClKr2jxEJXC3CSOhIql5i/AhMVT8kEy2sL4o+5iYtdFcpknrtagfgrPPkR/EMS\n", - "zhqJ8+GCJsmWWdAdBhP2A5QvOoEt6Z89TmBL5z8eMtkv6+js/s/7Qs8COYd0TzYxdOu9Jbx8PXFq\n", - "rFu4oil0orXltqtTLTf9McADu6nI5MazQ/4YgIK0Z0m8lwqeeSwnkURIuqTXxn0OmFWkjdG9weey\n", - "mVk7IKyRTSCPwahmZgkDk4nYg65Y7PxEwqnecmUFOp7kuOmpDMiiZBP7uhncyYOfTXSNE4Azb4oF\n", - "PWML03mFaUguqTcQfRMlhBBCCDECvUQJIYQQQoxAL1FCCCGEECPQS5QQQgghxAj2RCyPKI1CSF8i\n", - "wl8ghlgJPlrH5GEmzjn/bdjs6KzMwUIIcZlsp2bSOArpLBAMiopIgtmIlFuC8FcMDNtEd5D4xRyQ\n", - "I1sSzLa77iXZCwfzg28L0gZk0MH2oXz7y7WBYaIgeidyi4TO76+CSdRbYj2Gwuuu2NdZCGm5YCGd\n", - "UIbLlyDAIRAXnI7sQEGcz4S+2m5nAz0wkNPMi6VssInbP7mPye5cPRa2iYHAF1eEwQo0OJQ8b6Aa\n", - "u4+7AWGNLHiS3YAYWskk+Yo8J2KzhGUvkQciOffTXFauJ14s7yY+fBYpSNuVRCjGy8weyxWRnPE6\n", - "dyhwm1lNAkYLuEnIx9OwbyPI+fVsVEMBgZisDojkBbv3iGzeF/m5MEmefh7SBwXAJHm35dWBvGbm\n", - "g60HDsbAQT/sM7sg9wyV4geib6KEEEIIIUaglyghhBBCiBHoJUoIIYQQYgR6iRJCCCGEGMEeJZbn\n", - "ywWKc9TpJGKZMzb9eh1ZL4AZGHCGejMrSOx2P0D+LEhieA9SfCIpykaE6Q4E5r4nMigIfxUmxJr5\n", - "1Fgzi6D8lXy6awfKn6n3bccSqFGA7XwQuLX7/TEsQYAtD5EsYiJHNuv5tnY2hhnwxRJuCdIsZe+P\n", - "oW1ys7wk8mKXvJyJgnZsfHtWnV/PBcy3w/4eKqDdWaIvkyxRCGcJ8EyODjBggg1EYLcDVuyHiJ8s\n", - "MZ2k9UcQWZlcyweRQN+nbefLeliP3R8sAd7vncm1ZMYAt0zWMy9Qxz4vi0Q+t4lPuO8g5TtVa35/\n", - "A0YGsMEK9HkG7ccGFLD0c+xobL2G3RAsGhur0JR/rOSLaDg49OOeDGSJeJVXjzm6uG334Uuep2QW\n", - "Azawy22bDfpxR0HnLPBrFfjc8NvGz7CLW8LBH35vqSXPkmKAOH8J9E2UEEIIIcQI9BIlhBBCCDEC\n", - "vUQJIYQQQowgJEzR++veIQ33EkIIIYR4ZnKpVyV9EyWEEEIIMQK9RAkhhBBCjEAvUUIIIYQQI9BL\n", - "lBBCCCHECPYkbPPUz/xkttwV+QzfSzIL+GJ+wJV183z2cBZGV5CwTcxOY7OjJzKbd4AQtDvf8U5X\n", - "593v/llXZpaH1hUl2Z9LTzQLEDQX2ezTEEJG1TcSVNZ1eaAamyn8tlv+e1d2yy23ZctF5deL5FyW\n", - "Td6eBzaOuzpf+erXXNn11x3Jljef8AGAW5sLVza/PL9WDUl0PHXHna7sttveli2zGb8jmVkex0vg\n", - "bOJmZiUNYszbryXBmhi6evHAYH/J99c77jzlym75lf86W8bgyYs7ZAcKs7+zcE8SJmoYTEq2TbqL\n", - "u0c7EvZ353vz6/fWW273h0T6fg9Bfj05gJ6F5kJZs0b6+Zrvn2mSn0ygYbT+mfCv//mv+3pCiGcU\n", - "+iZKCCGEEGIEeokSQgghhBiBXqKEEEIIIUaglyghhBBCiBHsiVhuO5v5cgXi5dSL5XEyc2U9zjad\n", - "yKzjnZeOrc+FUDZ7eOj8tno63XxO05IZsEHa7lsiJpPX2RKuTiQzr6OQ2vd+Q03yl7npYJbsftgs\n", - "1rHM22C+5q/Lw1/zgvhzr31Otnz2oU1XpyqXruz4scPZ8hf/8EuuztHn7HNls438fBZnSdsREhjN\n", - "Hc56bmY9EYNxFvdIBjS0RLzuU75eTSRr5pUH2H7JhxQ4cObzggjwfSTnjH9vEeGeFBkOdQhoxF9i\n", - "PfSsC7IeUrb+XIrGl7nLV/h7pp35NtgBCb9nsy8wtx7E9UieIx0R4IUQz3z0TZQQQgghxAj0EiWE\n", - "EEIIMQK9RAkhhBBCjGBPnKi03M2XqzxsMxH/yaqpK+rg8EPvhZJI/JUCPI1E/BUWljjkjbMnbhGG\n", - "TzJ1pCBbL/rc42EhnXiYiYVDEgejAE+r64c5GdU0D088+8TTrs6+wxu+bH4wW/7Mlz7t6rzyn1zn\n", - "yh5/aDtbPn3mnKvzgz/2PFd23xcfyJZTmrs6jCFmUSACW8L2i8R/6vztttvl7bls2TVmfRh2R0JP\n", - "GXg79MxtIsGPbgbzgiaHOgpw9FJHwllJAGdwt/JqJyoufPvON/3+pgsIqK18G2wf8Me0nMB6/iCt\n", - "JYfZgnNVsWDdYUqbEOIZhr6JEkIIIYQYgV6ihBBCCCFGoJcoIYQQQogR6CVKCCGEEGIEexO2OQNJ\n", - "fAZieeUDK3ui/MaAQX7EbE1kNnYQrWPBEvKIcOtrkW1Xrix0KLL79UjGohVweXqSuogieUrkvbgn\n", - "lxkE+NT542bsbO5ky5OZb7sjVx5xZZ+/9yvZ8mVX+kDVq6866sr+7cf+Y7b8ov/8ua5Oij5I8/TX\n", - "8jDP57zgsKvDSCBV02tOChOEJXatvw5btW+rczuwHhmYMF/zvWMNQkFLEpDJgeMi++vJPWNptSCe\n", - "kr9vE4TPVq3vZ6n22wrQnti+jHLX73/jrK936Hzedv2UBYf6e2ZrDvfaAd92LRmkgrB7nVr5Qohn\n", - "PPomSgghhBBiBHqJEkIIIYQYgV6ihBBCCCFGoJcoIYQQQogR7IlY3m3sy5fnuWTcBn9YLjHZzEIC\n", - "oTi1vk7vhU2XWE6EbfZ2STbl6xCxO3S5gBp6lnjtyxoQ3vvOi6yhWC2WdyQpu21BWh/4Pj2b5OtN\n", - "52uuzqMPPkWOM19+wYue7er8yWf/wpVV83wQwrV/5ypX5w8/5dPPjx87ni0XxbBI6BBAYCY+M1Yx\n", - "M+vg+jVE5t9a+rLz27lmPCm9drxOwtax3pyl2RNcP2N9kfSFhI8KNoCiJTMNgFieFn69uGSmfl4W\n", - "42qxPBJBfW3h19vYyp8TaeHbbnvu16vqvA2Kxj9vqoYMZIFk80hHJqxOZBdCPPPQN1FCCCGEECPQ\n", - "S5QQQgghxAj0EiWEEEIIMYK9caLWDmTL/RTCNpmH0vtAxYgVOxJjR0IzE4YJRhI42JNtxdXvnO6Y\n", - "zJwQRA7JutZfCtxWQ5wvgxnhqTnCdBkIWQxh2Pt0KPP1LpzbIbV8e1559cFs+fGHHnd1lsSXef4N\n", - "z8mWH37ga/6YuqkrO3JFHq555onT5Dg9Pbo4JOS1I34e9paatHlPLsQcgh73+QxSO7Dhr/usyPc4\n", - "rQaGNYLLxPwn3odgvda3uS1IH17mTlSs/Xrlrj/2COIZuT0ciclqgQWHgkdItsXaADdV1r7OZEmc\n", - "RLzXSDCqojaF+PZE30QJIYQQQoxAL1FCCCGEECPQS5QQQgghxAj0EiWEEEIIMYI9Ecv7KpdL+yJf\n", - "DkTqLjoiY4IMzYI1A5GAUfQONFHRy9GJK7dwUGxG+vwYWvMCdUvCGXuUVAPRT+GQiuAl5DKSEFJQ\n", - "WcOAMEMzs7bNzwVFbDOzQ4e9Hf30E0/mx1T5Njhy7Igre+ThR7Plo3OfPHno8oOu7Ny5zXx/cVhX\n", - "T3g+RFZmAwN6uBAFyU6cT/312z/L+/rG3NdZm/jrV0BfSGwgBCF1eZ9i4ayW/LWxPg/SZMGasZu4\n", - "srDMt1Us/P6mjd9fSnh+q8NS+4lvg8W6L4OsTatLv+0dnyFrBkI4uSzWLX1ZAX2IBdtGcgxCiGc+\n", - "+iZKCCGEEGIEeokSQgghhBiBXqKEEEIIIUaglyghhBBCiBHsiViOCeGo0rpEcTOLRCyNEVKUiXgd\n", - "AhM2QUgnad19IhL3APezI5JsH3Lhtu69ddx0TDYH4Z7573DOMfq2q6K3XcsyT4APLA2dkh9ENfXH\n", - "vdz1KeYo728c3O/qnDnzhCvbdyg3fCO5Vjubfn8bB3PxOQ1Imzcz6zq4yGS1QPoGitCRJGXPKt+B\n", - "ZiD9zwu/7Qnp1zjOYtkNGxgQcFBDN1Qshz7bEXO+8cdQwHHFJTnOmtzb0Nljsfr61Wu+nbb2+223\n", - "0/zaNJXf9oJsqwNxHe89M7OSDGTp4dZiz5uOPW+EEM949E2UEEIIIcQI9BIlhBBCCDECvUQJIYQQ\n", - "Qoxgb8I2McgSfRLiP/FATAjkYz4CCb+MBQRGkjnU+czuq72TvvOz1PdwPok4J6klLhX6Kz1xTty5\n", - "eLepJUGaCVyVshz2Pu0VM+/+sEzQqsq9sN3dha8z8Z5NNcuPa+vCrqsznftkRNDurN4ZFkZZQltF\n", - "4tSxXNIS9hdIDyrJtkroe6QJqAzXQUhmx0JlCRH7EPHzAvnbqgN3KjbkHu1IX0iwfRSEzGhArWF7\n", - "klBXd4xTv//dA35/C+j7dUH6RrXaiWIWU2Bhu7D5yNxNZW0K8W2JvokSQgghhBiBXqKEEEIIIUag\n", - "lyghhBBCiBHoJUoIIYQQYgR7IpajQ4k5cz0xNmP05qWb2Z3ImZFZwDDjfUIL2cyMirqr3zlZaKY7\n", - "QRZmiBK5mQUINGRhmwlSF2NBpHUi6mMjd+3QsMZvvGxmlkiYYNPl4Z7rlZfBm6UXfBe7+XqzmRf3\n", - "myUJVKzrbLksB3Z1kH4D0YeZbI5mMAsFDUTCx07bkOvQEam6xWvK+jkDD531DXLOPkTSn0tB7tEQ\n", - "8qDXNHFVrCfn5wY6kG07SNBsM2tcWQL5uy/8/d8z2bzEvsHCRclABCjqC79eTwaNCCGe+eibKCGE\n", - "EEKIEeglSgghhBBiBHqJEkIIIYQYgV6ihBBCCCFGsCdiOcqtOEF7oBKpFy8DmNY9qZOIpR4DCtu+\n", - "GRKTZAekJi9rLz4XICu3nd9f25NjgLTnRNsgP052jExy7uD9mZ0vI8H2WTJ31/mU6Mlafn5168Xd\n", - "Zesl4H378/bsGr9eS0Kwp1OQhwcmeqN/XjGxnJwzNnFBkuMjOQYU1xP5u6bH1G8zCyCSJxYTT8BB\n", - "BmzgBSZsX1wPBmOQ3fVMuK9g+6QvpoIMDEh5+7FQc4SJ+2y9BNJ4x27rgs1iAG3Xk/2xQTErls3M\n", - "uoH3nxDimYW+iRJCCCGEGIFeooQQQgghRqCXKCGEEEKIEYSUBsoi36odssRIIYQQQohnKJd6VdI3\n", - "UUIIIYQQI9BLlBBCCCHECPQSJYQQQggxAr1ECSGEEEKM4G/8JeoVr3jF3/QuhRBCCCFG8Y3eW/7G\n", - "R+cJIYQQQnwnoJ/zhBBCCCFGoJcoIYQQQogR7MlL1Cc/+Um79tpr7fnPf769733v24tD+I7noYce\n", - "sle+8pV2/fXX2wtf+EL7tV/7NTMzO3v2rJ08edJOnDhhN954o507d26Pj/Q7j67r7MUvfrH96I/+\n", - "qNn/1969vLSxhmEAfyx1JYK0aLSOgogmjpdq8QIuG4IgGq26UEFBxY0U2tK/oUmKC3XhShBEoXFb\n", - "Sg0agiB4gZIWxQQUSSAadaFmoUhj9T2LAzl4ij2Qk5lA8vx235dZPDwhkzcXZsDOtRaJRNDT04OK\n", - "igqoqoqtrS12rjG73Y7KykpUV1ejv78fP3/+ZOcJNjw8DIPBgOrq6tjenzq22+0oKyuDyWTC8vJy\n", - "MiKnJd2HqNvbW7x+/Roulws+nw+fPn2C3+/XO0bKy8zMxMTEBHZ3d7G5uYnp6Wn4/X44HA5YLBbs\n", - "7e3BbDbD4XAkO2rKmZqagqqqsavzs3NtvXnzBq2trfD7/dje3obJZGLnGgoGg5iZmYHX68XOzg5u\n", - "b2/hdDrZeYINDQ3B5XLd23uoY5/Ph8XFRfh8PrhcLoyNjeHu7i4ZsdOP6Gx9fV1aWlpia7vdLna7\n", - "Xe8Yaaejo0NWVlbEaDTKycmJiIgcHx+L0WhMcrLUEgqFxGw2i8fjkba2NhERdq6hSCQiJSUlv+2z\n", - "c+2cnZ1JeXm5nJ+fy83NjbS1tcny8jI710AgEJCqqqrY+qGObTabOByO2HEtLS2ysbGhb9g0pfs3\n", - "UUdHRygqKoqtFUXB0dGR3jHSSjAYxPfv39HU1ITT01MYDAYAgMFgwOnpaZLTpZZ3795hfHwcjx79\n", - "89Ji59oJBALIzc3F0NAQXrx4gdHRUVxdXbFzDT158gTv379HcXExnj17hpycHFgsFnaug4c6DofD\n", - "UBQldhzfV/Wj+xDFGxDr6/LyEt3d3ZiamkJ2dva9xzIyMvh8JNCXL1+Ql5eHurq6B29Wyc4T69ev\n", - "X/B6vRgbG4PX60VWVtZvPyOx88Q6ODjA5OQkgsEgwuEwLi8vsbCwcO8Ydq69/+qY/etD9yGqsLAQ\n", - "oVAotg6FQvcmaEqcm5sbdHd3Y2BgAJ2dnQD+/vRycnICADg+PkZeXl4yI6aU9fV1fP78GSUlJejr\n", - "64PH48HAwAA715CiKFAUBQ0NDQCAnp4eeL1e5Ofns3ONfPv2Dc3NzXj69CkeP36Mrq4ubGxssHMd\n", - "PHQu+ff76uHhIQoLC5OSMd3oPkTV19djf38fwWAQ0WgUi4uLsFqtesdIeSKCkZERqKqKt2/fxvat\n", - "Vivm5uYAAHNzc7Hhiv4/m82GUCiEQCAAp9OJly9fYn5+np1rKD8/H0VFRdjb2wMAuN1uVFZWor29\n", - "nZ1rxGQyYXNzE9fX1xARuN1uqKrKznXw0LnEarXC6XQiGo0iEAhgf38fjY2NyYyaPpLxR6yvX79K\n", - "eXm5lJaWis1mS0aElLe2tiYZGRny/Plzqa2tldraWllaWpKzszMxm81SVlYmFotFLi4ukh01Ja2u\n", - "rkp7e7uICDvX2I8fP6S+vl5qamrk1atXEolE2LnGPn78KKqqSlVVlQwODko0GmXnCdbb2ysFBQWS\n", - "mZkpiqLI7OzsHzv+8OGDlJaWitFoFJfLlcTk6YW3fSEiIiKKA69YTkRERBQHDlFEREREceAQRURE\n", - "RBQHDlFEREREceAQRURERBQHDlFEREREceAQRURERBQHDlFEREREcfgLd2vbS3y+X88AAAAASUVO\n", - "RK5CYII=\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# the parameters are a list of [weights, biases]\n", - "filters = net.params['conv1'][0].data\n", - "vis_square(filters.transpose(0, 2, 3, 1))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first layer output, `conv1` (rectified responses of the filters above, first 36 only)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvWmMpFd1Pn5qr+6q6m1mumfp2ccz3m083mIb8BgMRkQY\n", - "J8FsIUAQIkokpEhByodIAUWKiBIJKUo+ZRMghLFQiBEIh0VgYztj43Uw9tgeL+NZerae3qura/19\n", - "qDynnvfeU29V95iM/3/d50vPVL31vnd/733OOc9JtFqtlgQEBAQEBAQEBKwayYtdgICAgICAgICA\n", - "/68ibKQCAgICAgICAtaIsJEKCAgICAgICFgjwkYqICAgICAgIGCNCBupgICAgICAgIA1ImykAgIC\n", - "AgICAgLWiN/KRurBBx+USy+9VC655BL5u7/7u9/GIwICAgICAgICLjoSb7WOVKPRkH379slPf/pT\n", - "2bJli9xwww3y7W9/Wy677LK38jEBAQEBAQEBARcdbzkj9cQTT8iePXtkx44dkslk5GMf+5g88MAD\n", - "b/VjAgICAgICAgIuOt7yjdSJEydk69at+v/JyUk5ceLEW/2YgICAgICAgICLjvRbfcNEIvGWXBMQ\n", - "EBAQEBAQ8HbAu9/9bvnFL35hfveWb6S2bNkix44d0/8fO3ZMJicnL+iepVJJlpaWRESk2Wzq5wMD\n", - "AyIikkqlRESkWq1KtVpd1b137dql5azVaiLS2eglEonI8wB8b7mXZTIZvcYqSzKZjNQjkUiY98lm\n", - "s5Hr6vW691sLqVRKGo2G/h/3jtu8JpNJ795xz8BzRCTyLGBwcFCfu7Ky0tf9eiGdjg7Ver3uXVMs\n", - "FmX9+vUiIvLmm29qOdGvXHaUj8uVSqWk2WxG+sOqZy6Xi/yW+xDParVakXGEzyzgfjyON2zYICKd\n", - "8Tk7OyszMzMiIrK8vCwi7bbFGOP2QFsNDw+LiMidd96p/QAzeyKRkHXr1unzREQWFha0jO5fvm+h\n", - "UJBSqSQiIsePH+9an5WVFa0T0Gq1ZMuWLZH6vvHGG949Nm3aJNu3bxcRkcOHD2sbuCgWi3q/w4cP\n", - "6z2t8YbvCoWCzM/Pi4jIyMiIiLTn7dmzZyPX33zzzVIsFkVEdAHldr7yyitFROT8+fMyNTWl9QMw\n", - "p7773e+KiMg//MM/yGOPPeaVf3FxMfJZJpPxxqyFgYEBHQv79+8XEZHLLrtMfvSjH4mIyPT0dNff\n", - "XnnllXL55ZeLiMizzz4rIiIvv/yyd91HPvIRXc/xly0MvL5gfKCNCoWCVCoVEbHXCYzPDRs2yJEj\n", - "R7zv0f9YU/kaXq+wVvJ6u3v3bhFp942IyPz8fKQMiURCUqmUlhX3Gxoa8sbZyMiIbNy4Ue8jInLy\n", - "5EmvvNwfQ0NDItKeq1ZfYk3A+Fu3bp3ZBsD69evl3LlzIhK/pieTSW+96fYOi3OPRptym+E+/xfp\n", - "edPptLnGu0gkEtp3KCvGi4j0nEe91mbgr//6r+UrX/lK9/L2LOkqcf3118srr7wib7zxhmzevFm+\n", - "853vyLe//e2u17svm8HBQW9hWVhY0MbCwra4uKiDFt/lcjkZHBwUEZFyuew9A2i1WjrpX3vtNRFp\n", - "T2o0JiYLvwz5t3GNjs7EQGTk83n9HM/IZDL6UuKFz92EJZNJfS4GijVI3MXCAl4oaLdkMqkv2n7B\n", - "z8GGljcYqF8choeHta+thRblTyaTOqmsOqE+iUTCeynzIoL6tlotc3FB3/ILwSoXb5b4bzf0+h7l\n", - "Qh3r9boeHPAiWl5eloWFBRER/dvtXhhP+Fuv1/VFj3qnUilvjFp1ZfDiam2g3v/+94uIyKlTp0RE\n", - "5LnnntO+2bRpk4i02yKfz4tI5yXHwNguFApaT2sDBUxMTOimk+tnAS8trBt873379nkbqYMHD8rn\n", - "P/95ERHZvHmziIh84xvf0O/xYjt9+rTZx9zWIiJ//Md/7G2kJiYmtN/R1/l8PvYFgM011i4R0bL/\n", - "6Z/+qbz44osi0llP8vm83huoVCq6RsYdPo8eParX9bIkuHN0aWlJxzbcPWq1mo6Pubk5EWlvpLAp\n", - "ff755yPPFulsisbGxnTMcNti04J3Q6vVkldffVVERA4cOCAiIo8//njknYD+cg9KKysrej+sYbOz\n", - "s1qP0dHRrvUfGRnRsYXf7t27V+eK9XwcjoaHh6VQKGi7uXDfid1gjf9kMukdMBKJhLdRSaVSeh2+\n", - "67UJKxaLMjQ0JIuLi14Zu5UlrswYO1y2uEN7q9XyPue5Y5EPvHmy5q21ufryl7/8f7uRSqfT8k//\n", - "9E/y/ve/XxqNhnzuc58LEXsBAQEBAQEB/7/EW76REhH5wAc+IB/4wAf6utY91S8uLurJAqfTmZkZ\n", - "3VFi15tMJj0z1PLysrIJvIt1Tx+5XE5PBzgFzM3N6UnE+i3Ap6K4+nQ7BeIzPn3g5MgMAk42KAub\n", - "qPqh/bshmUzqDt7a4WMHn06nvZ05n1xx3cjIiLYHn/T7wdzcnHnKdc14iURCy2qdINgkZqEfkyh/\n", - "H3ddOp3W71HOZrPZk80RabOtYExR1kqlouXj9sOJFkxDuVz2mKhCoaD3wxgaGxvTeQMGZmlpyWOQ\n", - "Go2GMgJcdsy9sbExEWmzLWAruR3xbzzrHe94h+zZs0dERA4dOqT3Q1thbCeTSZ3DPI7BdoG5ajab\n", - "sUEquN/k5GTfpgYwpxMTE/LCCy9EvuvGep0+fVpERK666ioRiZpY0B+9nv83f/M3IiLyta99TRmS\n", - "hx9+WETaTATYE2D37t3KrHK5wORZp3r04eDgoLpSPPXUUyLSHmNg7TCepqen1ZQHBsQy97z++uvK\n", - "DqzFTIL+h1nwpptu0vmK/j1y5Ih85jOfEZEoIwWgfQYHB7UN2GQIVgdzitePn//85yLSZsSYERKJ\n", - "sh4wD584cULHCQNr3DXXXKN1dU1xc3NzylihTCdPntQyu88XkQgDZPUrkMlkvPdJv2g2m9omzH7j\n", - "M24v9xnFYlHbFX+5f8FEDQwMeKyXZZ7rtQZbc4nXJ7YqdLu+1/Os3+C+3dx5eiEomwcEBAQEBAQE\n", - "rBG/FUbqQuHaWnft2qWnP5yo0um05+Ar4jsh8ykLO9tyuay7cJzGkslkxG9JJGpDxd/z5897vhbV\n", - "atW7bnZ2Vk85eAafLi07uOX7wuwRds1gs8rlcsTmLdI+taFcFtvTa7eN31jsDrMx+MvsHDM0+N5i\n", - "g+LYwlarZToZolx4Bvd5nI+H5fieSCT0fpZjfrey4i98wVZ7QoQzu1tmOLJi3MG5WqTTfmCeGI1G\n", - "w/PrmZ+f1/GB+iwsLHhOsPPz8zreeJzgezBSZ8+e1RM6Ttb1el1ZD/ivbNiwQc6cOSMiov5YuJbr\n", - "NDY2ptcB7DuIub+ysmL6hYD1QvmKxaLJYljAWB0aGtK6oF+vuuoqj9kQ6TgVY77Oz88ra9av38qT\n", - "Tz4pIm0/nTvuuENEOv5NFgtx5ZVXavkOHjyon2O8WU7Je/fuFRGR//zP/zTHJQILMDbeeOMNrS+e\n", - "tXXrVh0LLiPaC5lMxnM2txisxx9/XP8NdufEiRMaBIH+terIjM6OHTu0HuhDjPFGoyH33nuviIjc\n", - "f//9kXoz9uzZo88BOzYwMKDzkMc92goM1y233KLtzD5Qd955p4h0gjrYwuK2D8oq0n43gGXFOsXj\n", - "sBfz4voai0TXMWuNZJ9MwLUGWGM8mUzqGoj79muN6DeQgoFnZbNZjxXj94UV6OH+5TIzLjgY6oJ+\n", - "fYHoFTkAsFMlIj3m5ua0gePQarW8xqzX6160Rq9NBzuxY0OEQbdx40ZdpNlpG5MTL2O+Dp3JgwNI\n", - "JpP6YsFvl5aWPPMmmw/RjtYGjevXLZrM3WxasDY47LSMejSbTV2MrAFqPSPOzNhsNte8eWm1Wt7G\n", - "kjc0vIFDGbCAJpNJr28ajYZZBrRBHD1frVb1t7yY4EWGhTSVSulnExMTItJxzGVY5ahWq/objM9T\n", - "p07pmOWIFsCl6lEGkfYCiegpzL2ZmRnPDP7UU0/FRolh7Fjjc2BgQNsZL3CrHXm+Y24dPXpUzW+9\n", - "gBfxSy+95I23u+66S+vOmxfUGabAarXat6nLxfe+9z35wz/8QxFpRwSK2BuG//mf/9HnYmMxOzur\n", - "JkUgm83qugRH///6r/8yX2rYyLLGn7vmnTp1SsuFtv7JT35i1gVjAmg0Gno/jI3p6WnvIMJr1nPP\n", - "Paef4TCBtZ7XFdSH10qYCoeHh7353Wg0dAPl1p8xMzPjObkvLy/r/fbt2yci7XmJzTDAQQPXXXed\n", - "iIg8/fTT+hwcMF599VVvM5JMJrVfYV5dXFzUNr/22mtFpB1Nifp2W9cBy9TV6xDroluknBXR3c/G\n", - "iSM58bx+5wyiKlEukfYa4gZF8aEY4GCiXhskjDGs+Ty/+3HXAIJpLyAgICAgICBgjbiojBSzRf1S\n", - "a3wy7zdk39qdYhfby7EYu1OcZvlUhO+mpqb0ZAhWodls6m/w2alTpyLO3CLtHTrYB2Z0XLZhYmJC\n", - "WQXslOv1uoyPj4tIx2xoOYSLRE8q/TrquVoibF7EDp5PcFw3i27F/Ti01qW7c7mcnkSYyo9jotjx\n", - "2Q2fXV5ejugaifQ+FcWdtnK5nI4ZtMvQ0JCWLy5EnE2eDJw2ccpuNBqeOfj111+PLTOQSqW0DKjH\n", - "2bNnvTkwODhoOr/i9Myh7AhXB5uaSCRk27ZtWlaUvR/Jiw0bNnjaQsPDw2bAAOvRibTHD8rSzaxm\n", - "aQq5sE6a3U78Vki6K1fQLx599FG55557RETk7rvvFhExQ6rZ+Rzze8+ePR4jVa1WVQph586dItJm\n", - "UcCeWGW3NKAg7XDq1Cn9DRiiboCpEGg2m57ZhTWyMCbHx8dV4w2oVCp6XZz+V7Va1bUUfbhu3Tpl\n", - "sVzTmIjI7/7u74qIyA9+8AMdsxhD09PTXkQ5r+8vvfSSiLTHLMyQYNG2bt2q45MlV8AwwvRoadY1\n", - "m01lomCiPn/+vDK6WJ/e9773ySOPPCIi7XXA1WTrBUv6xXKqRvksyQFrzWLzH79LLA06d61llorX\n", - "Svd9wSa7OD2pXs7hXFbXDabRaHiO9GtFYKQCAgICAgICAtaIi+5sjh1oL+Esl1VwFbxxvcWyuDvg\n", - "Wq1mPtcV8ywWi7HsBYuDuqf7bDarz2Mnc9fJudVqeWwGi2/ibzc/EDju4iReKBRWrSZuqeHm83k9\n", - "lcApOZlMahvxKcFl2azdvaXgzPdh9sxty+HhYWUiUSa0PZfPYiitcdIvrPFkPSNOMJJhicflcjm9\n", - "p8Xo4FTcL9LptI4JjN1KpaLzp1+VdfTlwMCA9gc762McsDN8HCOFfhsZGfHkD1qtlo4ZFka0AB8v\n", - "+IGdOXPG9AvpV7EY+M1vfuMxPiIdBocZ09WK17rPEWmzDSJt5ieuj9GXroO+CzDE4+PjyipZ89/6\n", - "DMEBe/fuVd8s9NGOHTtM5XlcZwHzYWhoKOLTKtKe2+5n69at0zUQrNLCwoK2M+qzsLAQCRgSaY8n\n", - "937cR+wb5TKhpVJJ+wMM0szMjNxyyy0i0lGzP3v2rNfnzJZym2LeYL3m+Q6fq5dffjkSvOQC8+gH\n", - "P/iB+qKVy+VVsyY8B/r1GQIsYWdm1tz7MNMEWMKY7uf4DusDvsvn8x4jlc1mPemeXoKhcYFLzPDh\n", - "s0wmEytG2g1vm40Ub2xQAU6TgoHMGyrXkU3Ed6ZjVWwswjzROLrM0hlBhB6/yGGKw2cTExM6IeK0\n", - "nrjjeIF3B2qr1fJo3Eaj4dWX78EUZb/mUmuiAZbZp9VqxZrHrImOZ3Qzxbi6INVq1etDNueyGdQd\n", - "8IVCQc0YTE2vNaVBq9UyTUUYg5b+Uxz9bh0SxsfH9X6uRs5qAAdf1oeBKSOdTmu/oR/K5bI37vbu\n", - "3aumJNTt5Zdf1rGAct5xxx1aT5goepWZN+D4Lebj2bNnvYwAVgTrwsKCft/tRe6mz+i379988011\n", - "xMZLcmVlRc1G2LgnEom+ndstfOtb3xKRjrP5e9/7Xt3AQZG8UCjoC7RXRCLGJe4xOTmpmlH9RlJx\n", - "tBs2LYhE4wMLIy7QB+N8dnZW+wkbpHPnzummBfN6aWlJ+8kyxbCmHsYixudzzz2nztnQzWo0GjpO\n", - "2NTmbghHRka0r2Hie+ONN9T0d+mll4pIezMWF6GJjWMqldJ5ZgV1YMN82223qckuDul0Wsu3lvy0\n", - "1jsmzmTXz33wW+sa9AkHSmFd4N+gbTi1i/s+6RZI0295mZTAZ64pk7NYWKm2VoNg2gsICAgICAgI\n", - "WCMuOiPlgne/FoWOz6xQTVbtBprNpmlOc1kP3jEzM8D5r/Bc/JtVpV3zlrWzbTQaEaVyfBan5mo5\n", - "5GFHz8/oph8Sh7jTOjODrKtlMVFxDFgcM5DP5z2NJ5H4sFPLKZhViQHLoT6ubzjPFOcidJ/HpkIu\n", - "sxuqa8Fqn3q9rm0aZzJiJ3fuA5z0Oc8hmCg4Ih8/flz1gLg9oAUFZmBlZUWdX1GfyclJvY7VvaGn\n", - "AwfZXuZNlHlqakrZJuuE2evUCYYEbeWOqzgF/DgsLCyoPhQYnePHj2v/wyE7Tt6iH6B+X/va10RE\n", - "5Pbbb9fxiCTCN9xwgzLccYxUMplUduxXv/qViLQZLsyHOGzcuFGZF+D5559XGQWMCctcOzY2Fqsv\n", - "xWsRfo+kyk8++aTHDDH7YDnIx6lTN5tNLzMEM00oy/79+73nsnmO5QxgRgUTxq4FbNVwWarBwUEd\n", - "f1gHSqWSx65WKpWIPALgrk+JRCJWFb0b3FyqjUZD23CtjEs3oL84byf6vNFoeBadbu8QgIOYLJke\n", - "911jmfXZwZ/fs5Y58q1qj8BIBQQEBAQEBASsEW9LRoodDruhXq+bsgGW4JjLTjSbTS+f0vLycuxz\n", - "cWqqVCqmOCJOKlZeIN4J43tcz+GbbuZt/owdla0d/Vr9gNzncDnBcuB53ZiuOCaKv3P9jVZWVrxy\n", - "s58TQqzr9brZ5gjRZibKtY0zI8nt6kox5HK5iFK9C4yNarVqMkeoZ7+OyKj39PS0KRUBwPepUCiY\n", - "ztD4LY9ZtJub00yk0y6lUslzcp+fn1emAfODpQ7AYBw6dEjlGPo90bEQ6Vqd/5klhdK0i7X4koi0\n", - "/bTAdoHhGBgY0LbEHLDysFm48sor5ejRoyJirydwgn7jjTe0bXDvkZGRvtp1fHxc+wSCoddff72y\n", - "AOvXrxcRMcdNt/UC0gQYE6xSD6RSKa0bYAVm8P8xrq6//npP3JIBJm7Lli06bjlfo8sQt1ot7S+0\n", - "8xVXXOExao888kiEWRdpj12LMUcZ8H6xmGcLCwsLOl/ZkuGybE8++aT80R/9kYh02rdcLnt9Xq/X\n", - "1zRX4nKprgVuG7FEBOpUqVS856VSKU8ImN9dyEuYyWR0jLJfn+s3V6/XvXdlIpHw3k/8zuH1He8z\n", - "fGb1K8s4uNk04pBoXegbeA3otdjFpQOxYDkExym4WpFcQ0NDHo1tJR4eGBjQ3/YyQ2AiWuYrRq+I\n", - "RZH2IsJRWP3CHRS9cCHRC0ytulpLfG8sNpYTOavOM/A92oA3er02L3B4ZcfHfkyU/HKw+shSxWfT\n", - "0lpf6lbZ0+l0rHI4UCwW5YYbbhCRTluxYyucyaenp1e90PKYxMvBjYTqBU7ZYzlDu5GzqylXs9mM\n", - "jKPVlKvbs5F8HdFdlUrF1Gxz8bGPfUzNbW5S4l7I5/ORw6GInQFhx44dukHBi/ncuXParnAYf/bZ\n", - "Z71nFAoF7UOOCISTO+aUa/4Tia6fvL70E+Ry7bXXehvMer3uRd6l02n9jE13bjqY/fv3exuzUqmk\n", - "dePyY1PMaYiwFrG53l1/ukUcIwE1zNwi/ua1VCppWfm+qBv0v6w+6ub6sNo13XrfcWR4HLpdg00/\n", - "HyBxEOG2dBO8p1IpM/mx61aRSqW89YHdaoBqtWrOw7j3/1qA9bxbewTTXkBAQEBAQEDAGvG2M+2J\n", - "+Ka4XlpAbC5jxgK/da9rNBp6IsCud35+3jPtWaxFt1B3lBU79aWlJVOd3A2d5rpZZcUpj80DvNt2\n", - "mSvOPbQaHQzXJFatVs1EmC7dmkwmtZ0sCpaB7/nUiROGdeLj9kBbgoVqNBomE4VnoJyjo6OxjCDX\n", - "0S1z19OHw0S9VaceC/0yKxjPoMtFbAdwsC0sp9GveY7bA/Ngtck+manjMcRq/d3AJ0KeAxyK7yo4\n", - "W+1msTsiNgsGBg/z71e/+lVfJ3nOAWchjk3NZrPe2mGV9+TJkxr6/6lPfUpE2kreME3hOwtLS0um\n", - "mdI12aVSKW1Ld211YSlgu/354osvesncRTqmc6wN9Xpdnf7ZdOfKpVjyDMPDw2oyg6TF1NSU3gdO\n", - "/YcPH/asELlcLrIGApwkGXj00UdFpCNlcfDgQWWiUK6FhQXTZQRj45VXXunaVtVqNTJH1hrowBkp\n", - "Vqsn1Q3u2E4mk2ZOQViLXHV3kej7wjJHWu+2OBkKrmPcemmZGS2475I4BEYqICAgICAgIGCNeFsy\n", - "UgB26JaDH59OmZFyfXN4Z8qyAW4468DAgJ4YeMeKEz52whxG2Stnl3s6Pn36tHkyiDs9s2CoxYC4\n", - "DBE737n25H7Au/+4nbglvdDLZ8xVr200GuYJw22PZDLp+R5w+VD3wcFBPcnjWefPn/dOXzye4k5o\n", - "mUxGxwKzFVYYrRUosFZw+K4lOuuWUSQqPAe/GW5bViAXafvIgJHA6b3RaPRV/m7SI1YbcjizSJuB\n", - "QRl4PMc5yOIe3B9AKpUyc3+xAKHlBGuF2VuAwzN8WQ4dOtRXTsHnnntO146TJ0963+OkXqvVvHbr\n", - "dn/2lxNpMzWQq4BqNo/TXn5mmK9wTl9ZWfGYBpZs6dcnkYM7XF+VlZUVncOoz9mzZ5UtgmL96dOn\n", - "1SGf/adcAcXnn39e9u7dKyIdcdjjx49r22Ns85jFvGB/V5bTcJ3SFxcXdcxa7QehzT179qgA6JVX\n", - "XikibZYK92ZfXvyW12hLQRxoNpsRiYHVoh8Gylrzu81rl9XppqLvvhMsOR8R3584kUh4rGwvBinO\n", - "CsICpHyfOOFOVlTvhbf1RgqwktvygO/XCRvXsQnQ6hw2VSE6CM/ismCR6EbPWxsLd3NVr9f13lbC\n", - "YetFzxELcYkdV/NStzZNVkQLK+PiO+vl5ZpnBwYGvJdWt80aPsPCXa1WI86bIlGaHPW0XkCWo2iv\n", - "TQnXEWOKaXXLBNhPW1sOuVx/PJ8nLsrSbWxjrGKcLi8va1nQVuzgDefaoaEh3XDx4oaxjRc0b8wA\n", - "a8HauHFj7IaBTYHuhrob4BzMGm6oG7+IuG/iKH2eN/2aNlxl81Kp1NdG6uDBg3LFFVd0/Z41ilw1\n", - "cZGOSQqO4BzhinaZnp7WTSbKtG7dOt38wbQ7MjLimXk5StXVHXKBtkY5e22keExb7Yz5iOdx+TDn\n", - "OXqX5xY2NNA2e+2113QjyHCjOlOplM4HRCYODAzoeOcDGJ6Hw9vU1JS2gbX+WAmXsaHiICb8NpFI\n", - "eBGzuVwuEhUn0h4j/E5YS8aDfsCbCdcthF1FuF/dKFZOAMyIW+/Qb7Ozs2bd0Nfoo8XFxdh5a63R\n", - "vXTlXDImkUhEMqqI9KeoHkx7AQEBAQEBAQFrxNuGkbIcmnknbDmZ8olGxE4OXCgU9Lc44cSxUAw+\n", - "CfH3rDwrEg0lZUdFKxzYZS4SiYTuePl6Vy+DKfZ+nZu7sSSuEzlrLfVyrHPLxf9G+TnsFSzL0tKS\n", - "l0uO2wVUfC6X05BlPvni5IOToCVNsWHDBo89WVpaijBbqKPblsxS9GJK3Ho3Go0IY9kNuVxOrwMb\n", - "kE6nIw70KItristms2YoOpgSpqZhCsFvW62WPg9sBU7MjEwmo30ERsrKK5fP5z2z0cjIiMlIueZ5\n", - "K6+We2+UHSd4tOnCwoKZ5NV6nmUSxToxPz+vZXDD7l2gHdysAv0AzAfAOT5xv5mZGe+ehUJBn4vT\n", - "8auvvmqaUaCQjX5i0xzaatu2bR4jVSqVlOXtd7yvRc7DWms4F5+IyKZNm3Ru4rNt27bpeo3vEomE\n", - "fo96b9++3RzLeB7WlYGBgYiemki73i67try8rGOHTcZ4LsyICwsLHrPKcwJtC1YLvxGJZlHgHJOu\n", - "CXB5eVnZx0ql0reG2WrhsjL9AO3L4w2MJZzvp6amvITczHChTYvFovY1v0fdNaZYLHosEb/j4hTw\n", - "LetHNpv1+pDzq7Kjfy8ERiogICAgICAgYI142zBSAIdCW7Z2ZkKwg8d37C+BHebi4qKXMX5ubs47\n", - "EWQyGf03dtScf4nL5zIXLJyGzzj0k3fN7q7fytDNz7BU0fl6V1E9mUwqS4HTjAsrD53lZBh3Hdep\n", - "W+46kU578IkL2LRpk7ImEC3s5iDvOsFWKhVtL7Qzs1FgM4rFoqnObPVDHBvHDAcYJMu3gOGGag8N\n", - "DXnOsqVSSdsKJ7TBwUG9DnUbGhrSExr8KrZv364nXvy2Xq9rzjiLpbBC8nF9Mpn0fLIsBfFkMqlz\n", - "iaUHXHDoPK4rl8vmyZH9oESifnG4vh+RzjhmFewEC5u6ucC6Ac7mTz/9tH7GvkoWXEXzj370o/KN\n", - "b3zDu44FMUXajuMQAMX8Zj8iZiaRGw85+SzfQYtF6+Vkz0C7YV2JC0EXiTql89osYvv5zMzMqJM5\n", - "6vbmm2+qPx/GO7fBU089JSJthgh9yCw4+gTz/NJLL9WxzBIgGCfXXHONiLSDBNBuYLCY/ea+coNi\n", - "NmzY4LGyc3Nzni9vo9GIONWLRP0iu/WX5fAeh36tDLyOdROwRrkB957sA/uzn/1MRNrq9JbavRtI\n", - "UyqVvDke51u3FlgCybVazfR/WstzLvpGyopUsPRtXPpxYGBAXwpxjuPJZFIbC3+tSJ5isaiaMdhA\n", - "jY+Pe4tcMpmMmAhEujsBWpsOdsh24ZoMGey8zguV+1mr1dIFo1sajX7QyxmXkzS7g5FNGECtVvMm\n", - "5NTUlDqNIurIpYIBON/it+fOndN24mdhEcILxUrPYTkldotEc6M66vW6FxnYjRJ3TQRDQ0ORMSjS\n", - "3jS55p58Pq/1wIsjnU57Ts7FYlHrx5swfMZmMGjy4LparaaLN5TQT506pYshXuQMlLlcLuuLAOYG\n", - "OGUzRkZx6FrkAAAgAElEQVRGdA7wixL3gSmAzX18gEB74AVizdvt27dHFmuME1cPie8t0nlx9TKX\n", - "QDUb43R6elo3UK7yNoNfvqjvpz/9aXMjBSDJ9Mc//nH50pe+JCKdsc16SVjoR0ZG5JJLLhERkX//\n", - "93/Xz1zzdiaT0aTL/KLvJwovm82q7lOc0+369et142utbXHOxOVyWfvrs5/9rIiI/Md//Ic33tk8\n", - "ibHz8ssv69hGvdFXIp1x97Of/Uyuv/56EREzRQ02op/61Kfkm9/8poh0xsvIyIhu8HjDjfcFNlzW\n", - "+yebzeqc4nUdGyhsUufn573NVTqd1r7evXv3qhXy+01aYrmgcMBNPya/SqXibXxPnDhhJi12x511\n", - "0OVIaF4/sbZxlGW/9VxtEhccxuPSAgHBtBcQEBAQEBAQsEZcNEYKNK3lWI6TKGvQuMxVpVLRHaOV\n", - "ywhoNpsmtQpgtzszM6O73FtuuUVEoqY9VmPGSZ9ZIGvXjvuxRoZrjuRTAMw009PT3q69Wq161PrY\n", - "2JiWBdclEomeDrRxsJz+gUwm46n+sgI62tk64bZarQirI9IeA6xhJNI9LxROo+94xztEpH2yxkkB\n", - "7EI3R2aXObLYNmvssKaI1b+9Tmr4Hv2Wz+c9FpNP6mzOw+fo34mJCe/kffLkSe1jjLHh4WFlUXs5\n", - "Zt91110i0mGrzp07Z6qhYyxeddVVItI+0bvOtBbjwLnvwBLk83mdr7jv8ePHdTyBObEkJVhzibWl\n", - "mBG68cYbRUTk2LFjWgaA6+Y68zOgfI1EwCIiv/jFL0SkPbZhCo1Lqs7tgXFw+PDhWBbzc5/7nIiI\n", - "3Hrrrd53lrlh8+bNWgYwTfl83nvG3Nyc6hphvOzevVuZD/xllh+o1Wr6jDhn85mZGU0izqZHi/XC\n", - "mLDm4U9+8hMRaTOL6EMLYHk4mTfuu7S0pGWFttS1116r6uRgpHh9AyN+33336WeXXnqpiHTvN5dJ\n", - "OXfunLdGcx3xPK4bW1OwNrDeFObAsWPHZM+ePV3bg8EJeN0yAJYOI6PX2uYmtOe1jYE5x+8IsFQc\n", - "yIJ5DysK51zlAJK4OvUqZz/SCXxN3Pz2ft/3lQEBAQEBAQEBARFcNEZqdnY24kfAIow4veB0VCqV\n", - "9DpmHFwlcsvPhX+DXXEul/OYhmw2q45uYKLYL4nlF6y8S8iaDlu/lSGdVZ2tEzxOViIdxofZNJxy\n", - "sMs+f/68d+JrtVp66mRfIEvhlU+YcerqQLcwadwnLoyafdUAi/1gpWrUadOmTeqH8Mwzz+i1cfmZ\n", - "WOS0Hxt/IpEw25LLhev6FTq1gibcHHXlcll9bvCMYrGoYxFlWrdunZYLjBT7wHF4ueuUncvltK3x\n", - "3NHRUT2tw/didnbWCxEXEbnnnntEpHNSfvLJJyNq8i7AFE9MTGh92Z8RJ3kwCHySRT2svGrZbNYL\n", - "4FhYWIi0L3xn3NxtIlF/KMw/tFU2m9XvLSVjHkNg/Czn9ziH7D/7sz+L9QVEe1h9cN1110Uc3UXa\n", - "7QbfNJYHgZ8Y1qdjx47JTTfdJCKddcqSRKjVaqbwMdY0ME7WOsuq+HwPjFmwKUeOHNG2t8YO2MXl\n", - "5WUd+2gXi2Fnp3msL5VKRcfs9773PRERefbZZz1LRz6f1zkE9vG2226TRx55REQ6bNaOHTuUZeNx\n", - "4DIchUJBRVgff/xxrYer7p/NZj1hT2YDLWavWq16chrd0M96x3OG/V3de1h5+kR8qwPPBczBa665\n", - "RqUp0HfValWZKA5AYEZVpD12XCtUt3ysrtgnB0pxOTHeUDdmqS409+BFdTavVCrexF1ZWfFMcUyx\n", - "8XduhF4ymYyNDuHnWsD98EKrVquedP3S0pJOXnaGw2LDL2N3Q5BKpXTAQSdmeXnZo9N5M8kvcCwU\n", - "+M5y9Ma1ItHBYX3Gk2m1iXdZuytuELKeF/oRE61er2sbwbzEm1OAKXQeC9CSYSdM1CmuXbjenJjS\n", - "HReZTKav9DfdIhwBTh/jfp/P57UMGBvT09O68KBt5+bmYk21KOfc3FxfQQatVktTcABwFmXs3r1b\n", - "2wUOuSKdDQPGgRXNKtJ5eaAPl5aWtJ7WRgQv97m5Od3Q4G8ymfRMoqlUKvI8lJH7Eu2PlxcDbTAx\n", - "MaHOvtYGHy/DgYEBLwCFgXm0bt063SBy+fBicVMeiYj87d/+rYiIvPOd7/Tua23uVlZWNHoNa8Ls\n", - "7KyapHguuS+q5eVlbyNjHRDYBITxl0qlzGhN19zLdcMcvfnmm+XgwYMiEu1/V1+NI/QwLtmVAQ7w\n", - "vOlEfRYXF+XQoUNafpFoEA4/w00V9Mgjj8j+/ftFpBMZyOPOCoTitRAbZWyk+HncFldffbWIdPqI\n", - "DxPYQLEqukjvwIhu4M1Gt3Ek0n2N44AckWjdORsE5hna0op6F+n0Ccbi9u3bdU7x2mW5/bhreFxa\n", - "NRfWeuOaq63oct5gdkMw7QUEBAQEBAQErBGJ1mpjAt+Kh/5vaGOj0YjVunApUQbTy+ycZ+Wys4DT\n", - "Cytv45SFHbV7IhBpsyk4YbLiLpcBz7d2y26IaDdzpItcLqdtZTFq3fLixUkq9Arfx4nBPWm4sE4q\n", - "bnkSiYSXq4tDgxk40eK509PTesqAU+LCwoLJ0KAPURarbvl83vs+nU577JOVsDORSHgaT1wHfMbM\n", - "Kvo8nU5H5AdQVzzX1b7B80TabArazZJ7YFX5OMDss3fvXj35stQB5hwcrqempkzFcpiI0Fc4vTOs\n", - "wIFewPOTyeSqtI5E2mMNZhF2ZMU4wneW6Sybzcq2bdsiv2X2E2Hqo6OjptSDi6uvvlpeeeUVEbHX\n", - "r3vvvVdERO6//37vu9HRUXWax6necnzdtm2bmpIwFx5//HFl1jAW33jjDXWQx3gulUo6juH43K29\n", - "XQtBKpVSBpmTArMmn4jNwBaLRW1nduYHMI4nJyc9U1apVPLWXs4ZCHCePjYpgqmDNeCxxx6LOJQD\n", - "rlUjlUppAI8VwHHnnXeKSMdRXkS8RMouXLY1l8tp3ThvIlgUrqOb5UPkwkxTnJTazWXJQN9wrtq4\n", - "5w4MDChbx/XoJ3ddL3D7oczswtOvWnucYz6bNMGGddsuBUYqICAgICAgIGCNuGg+UmCjXMFD7P5E\n", - "Ortw62TbTVnbdaRmxoeZE8te6jJD8/Pz6giM6/nUxv5QLhPApwUuO04bOOHOzMyYzJD7mcVCsN8U\n", - "/85ywgZWs1u3mC+c1lhKwm03tsNzWVxnwVqtpv0En5uFhYWIb4UL9AOf0JnpsuzbrtMy++axU7qL\n", - "ZrPp5cFrtVqmAKzLSPK9+bmuZMPKyoq2s9Uf+O38/LyZ86mbCKBIp11mZ2fVPwjjbmVlxRNuTKVS\n", - "ct1110Xu4fpRiURD7ONChFfLRonY7I2Fbky2dWJEu2FcWSfLer2uTFO3cHGR9ny1+tq63pVnYUBI\n", - "0xL9nZiYkDvuuENEuvuZiLQZmtdff11EOvNn//79Wg+Mq9HRUWVCUZbTp09r0AzGRDdGyu1HVgTn\n", - "z9ycpxxMxN+599u4caOyo5DJePPNNz2BSnakx/XLy8uen9Pw8LD+G+2zY8cOHct/8Ad/ICLtIBZ3\n", - "fO/atUvLjHqUy+XYQBowUQcOHJCf//znIhL1K3IlY7hd8FmtVtM2ZcV89I01hlbDQmG+8rsDayX6\n", - "g9+J1vzC83iNZdV7sMlgsHm9Z0d7MMO4N7PHLNIKcICJm2uP5yCLiFpw86E2Gg1vLPK7azXM2UV1\n", - "Nu+mSuouVIlEQl/gVkSVpU7NukSW6QnAJKxUKvobNr91S/8g0lmgWbGaX4qWHpKbsFOk08GcrJJT\n", - "vqBubhoakeiGDM+1oiyArtSk85tUKqXlQp1Y3ygussmqe7FYNKMuUH5Q5oODg9qWWFCq1arWz6LW\n", - "40xAVp8zNQ3wy5XV5y1TmRsZ2Gg0zEnnUs5LS0uefpGlvdINcQsnmxuZgkc98Bw4tzabTa8/eLML\n", - "U5G1mc7lcrpoHj9+vO/yu+AUP9ZBBGOM5757AHIPWfie29mt5+TkpC72aKNCoaBtZLUzm5L6WWBZ\n", - "1dlyToeWkfXd66+/rmVAuio2GwGZTEbNhzBhXX755bqmPfzww/od2oDNmqgHTF0nT540646+5nlm\n", - "XeeuCZlMRscPxtPw8LBGLLKqN0yF3Fd4wWI9XlhYUDMkXsbnzp3z+uPkyZNqWsO4WlhY0Dny4x//\n", - "WK91NffYbMtK6G6gjLXmPPvss/pvBBVMTExo+2HuVSoVz7THaz7GISdh5whygJObc8RaXHox63Bj\n", - "HQys9wTmSiaT0XmGdblarXptkk6ntc15I+0mXx8dHfXmNb/LeZ3AZ+w87x5EmaBhssNd8y2Cxprb\n", - "1rvORTDtBQQEBAQEBASsEReVkbJ2mCKdXaGl8MrO5K68AIfTW+Yry4SGXTQny+VQV+RTglNlMpn0\n", - "QnUtzRM+YTPb4+6Ua7Wad+rn0ziewTtlvh9OBFaiUHYw57Z0zam4F/+GWSVOQOzS1JZDdqPR8EJG\n", - "uyWcRf1waisUCnotU77cNiLtU6p7guOk1RZNzWY83IfVkAGWMnCd9JlF5VMeym8loUZZWAF/Naq5\n", - "gEV7o77us0Si4x3XWQ7yABgCkY4T+cLCgsfK7ty5U69lR/U45jeuPhbrZVHsXLdu5mlXa23btm2e\n", - "UzMnngZyuZwyMyg/s5+4LxgMhnWyPXfuXNcE3CKiJiALKysrytqAeWFApbxSqWjboKzJZFLZGAQA\n", - "lMtlM3SefyNis0z5fF4d1cGyiPgm5bGxMWXXWPsM4xz9VSgUlP3hUHdXFoZ1szhDAOoLVmPPnj1m\n", - "rjs4ecNUOD8/r/XDenHgwAFtI4tpAmuYy+X0e84k4I7bmZkZue2220REVIvq9OnT2odswYBFgtd1\n", - "1/G91Wpp+S3m18qo0Y21dtcJ/h2/b+MYGXzHQWL4y0mV0Zf1et1b5/h9wZItcWx7XAANu0uw+4Wr\n", - "I9XtPcWO9rjONRv2w0AHRiogICAgICAgYI24aPIHLvpx4GSwn0uc3TqVSpnhopbzIIftitjCjfl8\n", - "Xne5uEepVDIZBtdhz9oVc6gul9n1kYpzgOVnuCcl1+8H14hEw3sBZqFWm9eoF1zGotsJaK2w2hef\n", - "819LNVck6ogpYo9FFtDsprSLZ+B03Y9ApgtXZX1wcFDvB6auVqvpvEGZGo2Gngzxl/1wUF9mjcA+\n", - "TU5O6ukZbfCb3/xGw9Dhx3L55Zerrwr7lICtwVx4q8ZNv2AGEWvC7/zO78hPf/pT71qUlRlfOIdD\n", - "2oEFSIFCoeD5ZPQax+ib0dFRz8G/G9773veKSGeMQcRSROSzn/2siLR9fcDGgHG6/fbbNSfir371\n", - "KxFpZ1sAgxMnSthqtTypAxGfKWFgPF122WX6PfsdWUrucZI37J9q/dayKkCYF6LIzCpgfrA0Bufw\n", - "A7OKPl1eXvbeRdy/cOovl8ux4xss3tTUlCd8Wi6XPSmYer2uc56FbdGWhUJB/frQbplMxsueYAVS\n", - "WIwp//atmKf83mFha/c9m81m9Xm8BuE3GMfMoqPt6/W6+T7kwDKRKCPlqp7zdYlEIjaIgJ3cwcJ1\n", - "2y5dNNMeNkKsIi4S1bLgDQg+YzMTgI0Ib66slCdoVDYLcmeyTopIVBsF11kvT95E8UvbihYEmBJ1\n", - "HR7ZNMYOd1YnuoOoUqmYqsNANps1o3Dc8nP0JNO4Li3L/dXLpNOPY5+FdDptOlBiMeLvOHkz6uMu\n", - "GKwcj3br5lhuRfy54PQy/L11P1cpv1qtev1q9R87S2JhbrVaXiqhoaEhU93dOhxg3OHlUK/X9YUL\n", - "0wM7huKzX//616bTvxuRGJddYC3otmGxohnR18ePHzcT5/IcF2m3FeYx2sOac0tLS7qhRRv0Gsfu\n", - "2tUPsInjAxBMergP9wE2hAsLC9r+iHBbWlqKTS/CdbReLGgjN4qOwWsg67thc8ObEzzPykzAaYPc\n", - "MZbJZPRFy0Ea+D2+s9xERDrmMUQrTk1NmQdgtz/5/7y5ihvfODyxFiFrKrmHtsXFRf2M3zFxQR/W\n", - "+8D6zHIw537G/LDWIgvWwXtlZcVbK633geWiwuudRYbwHHCTlvOab61xVrnj3lN8GF/NIT+Y9gIC\n", - "AgICAgIC1oiLxkjVarVIokbA2hU3m02PYUomkx4FW6vVzNOnC07cy1Sx64jXjamJUwTHPer1urkD\n", - "xumO8wTi1MGaRe69W62Wp/RuUZiDg4MmfW+1C05AKAfuib/uCcNKEMknJYt2tZyGuSxxbQlmgHWf\n", - "2OyG04tlKmBnZCs/k5tclvuI1dE5pFYkmlwU/VGtVs0To6X9gjbg8efWnZlagEN6cbKtVCp62sXz\n", - "+TTLY8PNI5lMJpWRQh9xYmyYA/lUhjFisVEoI9+v24mdy8D35e9E/DFhsSWlUsl0pMZ93nzzzYjZ\n", - "G+XCvWBK4jkDNmF0dNSrazKZVKanWzuI2BkL4nL0uYCDv5XYF+WzTtaLi4uahw7zY25uzmTtLFhu\n", - "EhgTcc7zJ06cME2Aro5UtVrV/rLYfbTRFVdcEQlkEGk7r8M0yqyg6+RcKBQ8S4JIZz7gHuPj49qH\n", - "lpnWzXQhEmW6LVxzzTUiIvLcc89p/THGwOiuW7dO+xftPTY2ps9lawTm0sDAgPdOY2dptGmlUvHG\n", - "RTKZ9HKt8lrZKxsC3hMol7WudZMyctcxy0K0vLzsBcNYefXYuZ7XYMsc7TrDN5tNz12G7426WWbO\n", - "fpjkwEgFBAQEBAQEBKwRF1X+gGUDWGiTnbwA1zen2Wx6zm18HxYltE4nADtXW6wIdqOWaiozMG49\n", - "LNFHLgMzHHEq0fwM7MLZvu7KR5TLZZOhYZ8gtG+ckq3FPnF9+NTkKniXSiXtGz7tuHIVIuIxPlxm\n", - "68QKMPPGob1u+1rMWr1e9+7N7ByXD23FJyFX/oJhnXYY7oknl8t5DCKzngCXGc+wfFVarZaORWbg\n", - "cGJlIUCclPm3qBvaoJtshQueZ3HsR6FQ0FO45XhtjZE4lnllZcX0ZQBLMTMzo+OWmSu0Lxzt2RcM\n", - "Yf74jjEwMBDLzAAs7QKsxqkXOSWZ9YKTNPrQWmPOnz+v7btr1y4RafsGocy47+LiopdBIJFIaLsx\n", - "CwMhSQjkdgOYKDjrwz9KJLr2oh8wflnZHDhx4oTeB/5dp06d8mRLWBwSqNVqsX4wmBfHjh2LCDLj\n", - "fhjHqC+3BcbgyMiImeGA6ywS9SFlILABa34ymdR6wBft1KlTOrZLpZLJUqOsvJ7hOouN4d9a/3Z9\n", - "B1utlrYN19PK8WlZF6x3KuYz+0fH5fhjuM/g9RhjotFoeBYWFiq2mPK44LM4h3Tgom6kRPxCcsQF\n", - "JnW9XtfPeDC5m4h0Oq0UMhaJXrQlbwgsp3DXzMcRet2i3dx6Wfe19I6wcExPT+vvUX52WrTu3Suq\n", - "D2i1WroBYK0nd7JbEyCTycSaY1BWK5kwJ1C20MvJkZP3irQXDtcU242Cdb/vZk5zwWPRipAE8vm8\n", - "XhdXD97EsvI2R6WItNvZGkeWqj/fW6S9YLhKvM1mU18YuG5gYMAzXXD/9BtdBtTrdc8Z3mrnTZs2\n", - "qVmVTV2u0jPrnXG/uubjbgsv5j9vSnnji5ckIrk4Qg/3thxf8/l8X8mU+92AMlDOSy65RPuYD1eY\n", - "/y+++KKItPvQfc65c+fUbMTO5rj3n/zJn4iIyA9/+ENvI9VqtWLNlbiv5ZIhImpSxGZiZGRExyy/\n", - "6PEMjspD8mWY82ZnZ3Uji7bYt2+fRvAhgm1iYsI7UPDYYf0qa5zjM1bexhzBBm5sbMxrl0aj0dea\n", - "u7KyohF8eIEvLS3pv9FHx44d0/kIzUKu7/T0tDrJW8/jNSEuNRMTAmwyAzhiEHDNy7VaTb/nd0jc\n", - "czkinjeHIr03T/wM1wS4vLxsltlFr2ew6wPq0c8GSn/f95UBAQEBAQEBAQERXHRGinPmiERPEzht\n", - "JRIJz9E6k8l4lH+9XtdTFlOnLh1cLpfNEM04xgQ76oWFhUi4KMrnKq+L+ExUIpHwqMl8Pq//xkmO\n", - "tarw3Pn5edPEgXvj9DYzMxNLp1q/FemcVHAyq9VqegK22BEgmUyaVKlrTms0GrFaYXGsHfe1lZuO\n", - "6xanu4V2Yfqe6w0mjZlOi951xwnX31V0Z7CqsxXqzOV06Xk2ebMJDfXkhJyuOXppaclT/M5kMur8\n", - "ijmzsLDQl/mJZQF4PGNugv1i6Qng+PHjnjp4Npv18k2Oj49rW2EdGBwc1PbtlaOQ6wH2iRkwsBgY\n", - "75dffrkqoPN64fbPzMyM5rV7q4E5vH79elPDyk3mjrIzyuWy1vPWW2/Vz9EP0ALbuXOn9jszOmh/\n", - "mH35Ozh4W+vA3r17PWf6bdu2yaFDh0SkrSIuElV0hwbZpk2blInCeN+6davH/FnrM5sjmdlFW6G+\n", - "Z8+ejWhUibTlP9wxxnUHC2Wxb91cQRAI8Pd///ciIvKlL31JGSYORMI6xZpWyKKBz1566aWIsjlM\n", - "rIDFTLP5Gs+rVCqRRL2Aq91UqVQikkO4Po5dZRbddauw5EN4TeD3C5fBrRu/Wy0mmt+lfA+uRyaT\n", - "Ma1TnGGE/64WgZEKCAgICAgICFgjLhojBbFLSzzQ2sW6dlX2HWDZAOxe8T07JXO4vMVcuP5GHDaK\n", - "nWoikfAc2pvNpse2cPgzsxoWm+EKcnLILDvUu2KTpVJJP8Pp0lJKF7EdqDnPEH7DedXcOmUyGU/1\n", - "22IwLCdYdr612CcWLXQlHZrNpp5e2AmSxeAA9AkLLbrh9olEwiuDm08OcOthqdgnEgltqzifPPYd\n", - "4/uCMcHJ18opx0C75PP5SB4/kbZkhOuztrS0FHFQxncoA9q2l58a2iyTyZgnXFdl3bpfpVLxfLgS\n", - "iYTWA/fL5XIe09ltbPP9oFTNavLWKRNM0yuvvCIiIr/3e7+njBTGhHUSbzab+r3Lkl8oMD7Pnj3b\n", - "lx8WmD8XWAvYwRw+RX/5l38pIiL33nuv3HLLLSIi8r3vfU9/i7XI8jfcuXOniLQdwd05MDU1pWPi\n", - "+uuvF5F2rjr49YCJuvbaa+XZZ58VkU6/jI+PK2uDMXPmzBntf5YUgC8VcumdOnXKE7ccHx9Xdgys\n", - "q0hnnMNHb2VlxZN7yOVyykThvbK8vOytF9Vq1RNmZXzlK18RkbYv2gc/+MFI3YrFojJNzDyCifrQ\n", - "hz4kIiLf//73VUSUmTcgnU577zHOtcqwHMHjfAFXq3Zeq9U8/zD2w+pVJswhFrS23gNxsCwjzGBh\n", - "neiV5xaI8/lycVE3UqwFhYWNNyDuBkOks0Fat26dDmB+ebnOd+Vy2dx8uSYRa5NjdZzlmJdKpTyF\n", - "6VqtppMPCwY7a3OZUT8sOm+88YZnushkMl5EFV9jvUAsZ/NMJuOZ1qwXweTkpPYJJ6uMS8FimQDZ\n", - "uRq/hUni/PnzXt9YiurdAgFcMJVsUb9WdB8DCxXaeW5uznuh8Bjijaa1gXLLbG3CSqWSZ1IUiUYR\n", - "4a+bvJfHIm+4rdQ/ACfidKP7uoEd43FfKyoT85Wvs9rZHdt8DytCiFX7rc2NZaJGdNrJkydjTRN4\n", - "9tNPPx35jUh3h3FE9V1IeiOOjkIfY5y+9tprsSYGV9HfBdoL5XznO98p3/nOdyLPeOCBB+QTn/iE\n", - "iLTNmiIiL7zwgm7CLHMKxqm1rvC4tvoDv3n22WdVoR2bCGguiUjElAWzHDvFwwS4bds2EZGIYjva\n", - "LJ/P69jmlybGJZu53TmysrLivXesg2G5XI5VNsczvvnNb8rVV18tIqJmztnZWR07CHaYm5vTdfj7\n", - "3/++iLQ3pEic3Gq1vGhRJg4YLiHAawyriWPs8zjCeszZKjBm0H4rKyseSVCtVr33HT/PMvdZ47fX\n", - "ZsmtG7sysEK6awbnLBA8b9GmlsnQdZGIQzDtBQQEBAQEBASsEReNkQLFD1qRHcWws2Qmyg3fZlMM\n", - "zGCsMA3afWVlJWLmE4meNK0wftZPck9flgMtJ1jE/XjHDzSbTTNfGj4Dvb1jxw7PsdCiThnsmG/p\n", - "+FhsEefLQ7uBrgaljO9F7FxlnJiSQ2JBnzO1jueBSSwUCp6UBOcZ5H6ICzW2lG/5GvcExGrnrBzM\n", - "ZRWxld9FosmPAcuchTHtspWMpaWl2FMY09Fx8gcAj208n8OVUfZisRg7nhiuCalarZpsjGtS7AVr\n", - "PgKW0/7CwoIZ7s3tB/aCHcJ5LXCBzw4dOmQ6kcPsiueeO3fOlPdw0S2BNoBxun79emUBwCb3cniN\n", - "S9LOjvvM5Nx1110iIvLggw+KSLvNn376aRHpyK688MILpio2M4Ioe1w+T55Hlq4bkiqDkbruuuu0\n", - "LLzugBmCySuRSKhpD789cOCAmg1x/ZtvvqnsPpI6s2M5wG4abB7Eddb4ZPN13LhFve+77z75whe+\n", - "ECnL9PS0p4G3vLwsN910k4iIPP744yISZeqKxaLnftBtHXDZorm5OZ0DmKMsH8NWFEvLEGAdO06c\n", - "LNJeE6xx684BdpexEi2zc7gLKyvHysqKzqW1SI7EsYpWhpNuCIxUQEBAQEBAQMAakWj1k+75rX5o\n", - "zEl4bGxMT2bY/U9OTkYyhIvYonClUkk/45MVhOJwIrDAJ0h24HOZBg5Nj9up8i6bTzb9+Pqk02kN\n", - "hYW/hoViseiFZ7vt4vobDQwMeA7j9XrdPOnDfo+TEF/HSvP9DCFmyfBbi7Xr9RuGVeZ+EfdbyzeP\n", - "y+SWxcqr1mq1tN+5P7gf8FvXPm/Z8K2TEwsFMkOIsrAvGgCmcGJiQn2V3HxjDJYqsAQNGfAxQlmm\n", - "pqbMa9Gv8IGpVCpeW6dSKY8JbTQanmMxB6ww04hyFwoFdTyO8yfJZDJm6DX6ECrhzz//vBdGfyHY\n", - "s2ePyh7Ah6bXyRrK1yxrAWSzWbn33ntFpOP0/cMf/lDXkwceeEBE2uwC2Gf4G8EJvBsgLFkqlZTt\n", - "wtpwxRVXqLO+BYzFlZUVnQ8f//jHRUTk29/+tubpw9rPsgtgBZmRQdnL5bLOJfx2cHDQW6eq1ao3\n", - "vonXbbkAACAASURBVHn9YfbYYu9dX05LpJNhvSNuvPFGEWn742Esct1Q5t27d4tIx8dNpM1cos3d\n", - "Nf1CYeURZUXwfpiZbpk8VlsG7jdXEoV9s5i5ci0O2WxW1zmsWUtLS7qesCwElx+/xTMwNrCmxr3r\n", - "LpppD53mDjgenKjIq6++6jkXLi8vq4M1GotpSTT0yMiIt4FiapI7zorkczuOZfnjJORbrZZJwXN0\n", - "Gl/Lz63X67qBwgS2EmcuLi56mlaVSkXvbdGj3SKMrAHipm3gDYMVsWKZZ9E23L5WGhBLR4xflu7G\n", - "h/sQyOVykee54P5yqeSBgQH9LTtmuqmJMpmM1tNyEufNXzf9Gf4NRw7xBsodW9YkXllZiWwEcL0V\n", - "UQdgPLGWVtyCzOaPuM2/SKf/2VHVAspnpbgBWq2Wzm+0wfT0tB6KcI9jx45F2gUbBiyS09PTXjlY\n", - "Awgv+C1btkRMKQA2Naz34/ZrN02hfoH+7/dFhLpbGmQcgYty1mo1ddKGM/fhw4e1Xdx5LtKZo5de\n", - "eqma0eB6cPPNN+umD3jhhRdk7969ItKJqGNtLjfZrEh7AyXSdmXgRMd4xsGDB0Ukuq5bh2I4r8Mx\n", - "m1N2sbnZinDD2GfzJUfF4jveQHF9ugG6WT/96U91s/TEE09EniViJ1VGO3OEo+t2INLeXOH3nAbN\n", - "rVM+n/fG1uLiopdGhTfwHPVswT3gsesJz0e3zdn1hNvQVVnn5NHdkpqL2H3YaDS0vTjrCW+MXFg6\n", - "UquJyg2mvYCAgICAgICANeKiMVLLy8uRZJWg4hYXF5U65902mCjsEqvVaiTUH99hR4ud8vnz5yPq\n", - "tiJRtsJyWu3l0GqFebomO9a8YYbFZQuYXsY9WJcIJ6FMJqPf8w6ZzWSoN/7NJwxmx9CG7ICM3T/v\n", - "wl1WhE9PYKKYpWKq1NW8YtrYMgv20hGzkla7obW9nJxRj1QqpaYfPimjDEwB4zesWWUxB64ybzfg\n", - "OpR9fn7eNOW4Gl6tVsszM7Nkh6WsD8ZsYGDAy1HFUgJxTNPy8nJPJkqk3VZWgMFqARaKgzAwb7kN\n", - "XN0hAIwbTEUPP/yw94xSqeSpunMovBWebWmA8ck6zgQbh4WFBWWW4jIIcN0sphlIJBL6PZiQyy67\n", - "TH70ox+JiM1iYQ1mFgB9bjmVDw0NaVkY6H+McTb1YR3bt2+fziWYrrhMcBI/ePCgF9Y+OjrqWRe2\n", - "bNniJQpmrTL0R7PZNGVw8BnPQZeJSKVSkYS4Ir3dCbjuMEnChMvzA/d7//vfL//93/8tIh3rA9e1\n", - "Xq978gdursRu6GWCZtkXl2Xn4AVev9GunOMTn7FOl5uTj+UUAA5osNwbALYGsSUBZe2X0cU9rrji\n", - "CmWwkdNwaWnJdA/qhcBIBQQEBAQEBASsERfV2dwSqLSc1ro5JeP0ihMN/w7f1et1PYHgZNPvrrhb\n", - "CLNr9+2WDR0niF5h63HhzJZjK042zWbTc3js5WzeL6y684k1Dt36y/JBc1mvXC4X6wwY5/+TTqdX\n", - "HYIPdHMkhA8NQsQPHTrktWmhUNATLUs2oO8w/jZu3Kj1YMaUyyAS9XPAmE0mkx5z1W9/bN68WccE\n", - "Z03vx1k6m81GfPe6YXx8XB2y4dx99OjRvnyHxsbGvPZbi9gly5X8+Z//uYiIfO1rX/Ou27Rpk7YH\n", - "swOWz6M1ZsH0oD3m5uaU2VjtaXZoaEgZczAX3Rg9rGlgEKzgmaGhIfnsZz8rIqLh9C+88IJ897vf\n", - "FRGJ+CK5rOfWrVsjvmDdsHv3bp1nOMnz+sLCwmAG8Vx2mnaFORnbt2/3mCaRTkADHN+feuopvQ/a\n", - "gy0VaDN2cmcm0WXcWKLGcnLHbzdt2mS2v+vze+mll3r+XyKd4AXkG8xkMqocj7F25MgR+eIXvygi\n", - "Iv/4j/+ov41b05PJZMS3S6Q9ni3xzdUCbVUoFHT9Ytkdt3yW72AqlYqscy5QdhYWjnsHJxIJ7Se2\n", - "xKC+6PNcLucJo/Yrl1AqlWR+fv7t6WwuEl2wrA0D0+V4oWGRSaVSOmGwAHIUG75Lp9O68cAETiQS\n", - "nvmu2WxG0ruIRDsa1/OGizvLovZdmp87AhM8kUjoyxRtkEwmtZ6cGgWDhynd1UaujYyM6L1Rj1wu\n", - "p4PKdYYW8RdckajKLTv54TP8hpXr3QmRz+e1jXqZRtzNdTKZ9Ewh9Xo99gWGZ4yMjGh7oS1444W6\n", - "DQ4OalvjurGxMR1jqA+bU3kT626uWbsFm2ZuE0515JqoLfS72UilUpF0MXiGG8XCDrm8gbPMQS5a\n", - "rZZHsffaRGFOLy4uXpBKuIU48+LU1JS+7HFdLpfT8rATPEzA/HLGixWbBNaqWy1qtVpkrRKxX0oi\n", - "nfaMM2G0Wi15xzveISIdx/t/+Zd/MaN/0ebYlPAmyl0zGW4EtUj08AQNvFQq5b2sOHqKN1Csri7S\n", - "3oRD1wtRio8++qjWA5snvg8OOzzP0Lb5fN402brpvsbGxryIRPxepNM3U1NT5tr7rne9S0Q6KXEO\n", - "Hz6s6wnq+OSTT3p9WKvV9ACC74aHh3UDtWnTJjVnc5nQh6wZ1+8GgTMQiLTbzX2PpNNpT0fMOqRa\n", - "7x82eQPc9nxIsQ7PeB/iO06qzoFIbrJsC+VyWYMXYLrtN9Kwn7kdTHsBAQEBAQEBAWvERWWk2BQD\n", - "5oVZG+xOE4mEnhyZuXD1fmq1mtJ82DVzmCfAu+e4BLp4NqPRaHhh461Wy2MOisWi7p45Nxrq6zrK\n", - "cxuI+CxQIpHwTu3sWMpO0xa7g93/7Oysp89j1Z1PcEyjovx86nGpWnYKZFbGpb0rlYpn1rQ0mdw6\n", - "4zq3PdatW6f34bqjLTEOZmdnvf6CeUWk49zMwD0sTabFxUXTOdetRy9mxzrpWadePINZSj41oU1x\n", - "v5mZGe+UmkqlvCSerVbL026xxqlFcTO72O+JOI416qUM3gu//vWvY793ldPr9bqeVBluGXl8grm4\n", - "9dZb5Wc/+9mayrm8vOzlVdy1a5eaClnbCeWLY/oajYYqh+P6Q4cO6dqCOcjJ3PGsqakp7xn9Sjtc\n", - "e+21qsgN/bmZmRkNEmKLA5IlP/bYYyLSZs7ARGEeplIpdUbH37vvvlt1sH784x+LSNQEyHIPYLHw\n", - "brDkZhice9WyjqCPcN9cLqcMEb9fwETBBFmr1XQ9YROfq5u2bt06T7n8yiuv1OtmZ2d1veEyYRyz\n", - "ic1lmlkWhoNX+P0q0raSoK/Z6dxSp3fBek5WzlALlqsNfxbneoDrs9ms7gPwt1arKXMZp7bebDb7\n", - "dr/phcBIBQQEBAQEBASsEReNkYLTITMgIlFfJSCfz+tpg53RsGtmQUPs6nHKGhwc1OvYl4flArqh\n", - "12ksbofO7AOey74qfA+cRGGzrlQqXrlqtZqyBPDlOHPmjLYVvms0Gl5oqkhU9RVlwH2Wlpb0FIa6\n", - "zM3NaXmszO5s37ZUva12Q3sxM+U62HdTWQesPHe43j3R4VloozhFemahcL9yueypwDO4j618hHGC\n", - "rRYwZrdv365MCMYu9wH6LZFI6LzgNsN9LJ819gN0/eFqtZrnrG/1AX+GOg4PD+tv3wrF5Z07d6rv\n", - "A9c9jqFjIGebpUCdzWY9po1zPMKX5ejRo+b4BNuAE7MVJLIauBIg27ZtU1aHGSnLn8/F2NiYsvK/\n", - "/OUvRSQqiYExwX5E7AeFUz3Yj2az2VduQThNi3TkFPbu3avinPDDmp+fVyYKOHPmjGzdujVSluXl\n", - "Zbn77rtFpKPG/sADD3jO60ePHlWRUTh/J5NJT+2c5VKsNQQol8s6ji1mH/5zyWRSxTktPzIwIhs2\n", - "bPCEStlPFWvs9PS055d2/PjxiNUF1zKstdcdH/1KcvA84TmF+zFjy/6hItE1jv1nraAul7my2OdE\n", - "IqHtzwE6rhh2Pp/X9QF9Xa/XY3NBcvt0C1ri8vWDi7aRwmBx9T4Ylno2U+0Y8NZChsblFwZrgLgv\n", - "iFQqFYm44utduOkHMplMbDQZ7seO2VjsTp8+rQtoLwod1+EFs379em0b60XPAwFtUK1WdRByW1qb\n", - "ELQhJtD+/ft1YWfzpmuKbbVaEb0vXG8NTEvB200e3Ww2dZywJhc+YwrYnQSc0gcbbk6C3MuEYekU\n", - "ue1SqVTMl1vcBsqarFg4zp8/bzoHu4q8CwsLOvZ5I4f2sBw3WafFUoFfbeJP1npyTagW+jUVLS8v\n", - "m6Y9y6RoJTjGM6zvNm/ebDqQor3wUu+WUopfFCLteYRxiXbuZ/PRDevWrfPMOPy8ONx8883qdI3o\n", - "vbNnz+rmD5vsl156SduS11ccDq655hoRieqIxW0Yz54967lacPshui+VSsnv//7vi4jI/fffr9/D\n", - "0R39NTY25qWsKZVK8sorr0Q+27dvn94ba+r8/Lw6vCPdyuLiYqS/ROwUW3Nzc9r2UFE/duxYJGhG\n", - "pL3hdDdQk5OTkaTLaBeMDbQ9HzQuueQSEWknKEa5sDE8fvy4BiVZSZLT6XTEFAbgM/xdWlrSzdxt\n", - "t90mIiIvvvhirDmaxxrWOWttYE1CbFBxXT6fj0QJi9gajrxesKaiq9eYzWb13+yWYm3W8BnavNVq\n", - "aXuwCRBj1MpmAlhriItg2gsICAgICAgIWCMumo4U9B+wq7dUZ4FkMinXXnutiLQTPopET7Yc+onP\n", - "rDw5OEnW63VPxZrzufGJYTUh5iIdhi2dTusJl9kb1zHb0gJKJpOewzDnMmK9KzyPQ3utfzPL4zoZ\n", - "M52NHf/g4KCert2w227Afev1uscmsInFyqsHcA44pnHBXHECW8CioS3AXHLq1CnPyZCTc/KJxGKO\n", - "4kyE6Dc2nTBQd0ubyTIP8jNduppPiHHyEYlEQs2BlgNnv3niMH9yuZwnFTI5OanlhvljLZIAVk5L\n", - "IJ/PR+YrrmNJB7Q5nILPnDnjsVgbN27U8luJZ+NC/xmo+549e7z8dv2qTlv48Ic/rG0JRfJ+cd99\n", - "98mHP/xhEemY5+r1uq6vcPSGinY3gJFKp9N6akfdmG1jTSNrroABeeSRR0QkGnLOSYvd9Z/NX3F6\n", - "UyISazqDSXFlZUUtHGC/kslkxIwPWPMbbBfKefToUV2TeP1GG8BpntdOPH92dlYZQjBYlrM5z9ty\n", - "uazPcSUAeqFbAI/rVD84OOjJQTBbBO2rubk504LRL1xtNtaTZGf4OHAWAqzrccnJuwH9yeZei3mF\n", - "Rl23cgVGKiAgICAgICBgjbhoPlK5XC5yasNJhMNysbtPp9PKRAFDQ0PqXMancDevHmcgt1RY2U8E\n", - "u1LOQO0inU57+ZY4hx4zYNbOG89jxsxiz9zT/MDAgD7XYslwYlpaWtJncLswU+LmM8rlcpEy4j6u\n", - "/002m9VysWyBe5osFoueXACf/K28euz47LJZrVbLUyVmuBnQRaIMDcrKJ2k3E/jKyor+m0+kbr4v\n", - "y1FZpMPW9GIwXbaNwYyU64fTaDRifRTigiey2aznJ8bh/mjbRqMRy+hxFgK0L06DpVJJ+2G1TFQ2\n", - "m43k2BOJ+h3xs1xmzfW944ANvh/XvVqtmkwUgHVpx44d6mtjAc/dtGmTp/BtnV57SXvAd2N2dlbv\n", - "t1p88IMfVOdsnlPoE8xpzgVq4bnnnhOR9riCzw6UoQ8fPuwxbtxWrNqN+wCpVErXJ7BUuVxOy/ee\n", - "97xHRCTivwNmjVmbu+66S0REHnzwQWWigImJCWWkwAhls1kdMwgmgMI12gPt4/oElUolfS7uUSgU\n", - "TDkTrF1WLlJmlMBEoW13794tDz30UORerVYrwqzF+d3BnyuRSOj6hP7lMceSLaiLK6EjYvs5ckAB\n", - "7sMZCdzcp3w/9jNyZXXY2sLAmob+mJ+f9wIGarWaMuCc/QLPYz9bvKdY+BbtizYaGRnR+4BB7Mdo\n", - "d9E2UljosHhgAS+Xy56Zol6vey+CmZkZpUfRkOl0WjdQUMXl5JEc2cbO14CVGNd92fCgtMwQVqQW\n", - "L2ju/cbGxrSeMClwJB/uU6vVdPDiZcJaG+ycjO+xuRKJvtxQbjcljkh00LjU78rKippM0OaJRMJ7\n", - "cS4uLup1XF93sqRSKXMT5Jq/WPMIE9eKRMK1ItENBSYQoon27dvnOa1aaX6SyaSOS1cZXCS6+Pbr\n", - "pG1toDiBMWAFIKBfeaPMUT8A2oAXEyuFEdoU881ycLfAbY96Ly0txUYH7du3T0TaYxKHHYy1oaEh\n", - "T8Npfn5e64bysR4W5v7ExISuISKd8WaZHtB3tVrNW2Ms5ejt27d7GynLQblcLmvboczj4+MRhXSR\n", - "3iYHvCiPHDnStzkd2L9/v4i0+xQbFMxBaDmJdA6YO3fu1Bcj2uCyyy7T9ZIDZNwUXJOTk54DLh8u\n", - "cN+bb75Z1aSBarXqRd598YtfVAVvbKC2bdum5cY9hoeH5dOf/rSIiHz9618XETv4w9og1mo1rRM7\n", - "1GOjx/MXfYjrRkdHPYd7V7EbwIEA44+T6lobL2yojh8/ru8sKMdzUJQ1N9lE7aqiu8D7BGXYvHmz\n", - "lgubPusQNTQ0pO8BbJ4rlYpXFyYJsD5w3+BZqVTKTA7ublY4NRVrTLrpb1jDj9dK60DbTwAIB2Bh\n", - "/sZFAALBtBcQEBAQEBAQsEZcNGfz8fFxmZ2djTWF4MQ8MDDg7Sb3798vTz31lPcb11Fwx44dykRY\n", - "J2awFeVy2czFZNGLrmO2WzeRNtOEU0mc9k2hUIg1M1wo8EzWssIO3govZ0d0Kx+cBeT0wqmoW4h7\n", - "nD6U5aiKU5SI39aspM3mFLes3RJK9wsraS3AjBTGBBKPvvLKKxekp4RTO8b91NSUOs7iZFir1Uyz\n", - "MJhIDh/m/FIiUYV7MJ1WDrVMJqPfo08LhYLWFyzq4uKijndmJ+DcjJD8YrGop3/8rdfrygJwzi2M\n", - "RXZi59+ItMcB6nTw4EGVLnDD0F3glI12K5VK3jx897vf7ZlbeDxhbBQKBY+V3bNnjypux8lBHDhw\n", - "QPvhwQcfjC1zHD72sY+JSNs09s///M8i0jlRz83NeW4NV1xxhZ6+0W9jY2NaN8x9zqjAquguyzIw\n", - "MKBtyrnPYHJiKQT0Na4/deqU51B+7bXXqvyBu76IdBzMZ2dnvVxrpVJJxzu+s9aBG2+8UV588UUR\n", - "6TD2zKKAITpy5IiOX7Rpr7yecYnoLxRxSYvXr1+v44kZnX7KMTo6qn3DmkxuDkjW+uuV/9Eysblg\n", - "+aC4hMYMzL3169dHtCVF2uOUdaZE2v2BMQi2N5VKaflw/fnz5z15I5HgbB4QEBAQEBAQ8FvDRWOk\n", - "3H9j59hoNHRXzPZK7PA5bx0Ap7B0Oq32VPhNWJncWUARO1Erl51V5m7N5YoRcl493mVbOb4AnO6X\n", - "l5fNE4TFPljg66zTC06C8Ll58803tc3ZV8B17E6lUno6RLsWi8WIwJ1Im0HoV83bfS6fEizByDiJ\n", - "AK47fstsB8bJ/Py8l3tqaGgo4ujsgscOgDKMjY3pCQ73wAmG0St/HMb4xMSEXHbZZSLScYg9ffq0\n", - "SoCAQZidnVV/IzADLBHAOSh5fuF+eB6+A3Mr0hkbhUJBP8d9R0dH9bcYD/Pz8+p3xuMTjASHiqMN\n", - "0fY85pj9Wu1pvtVqaZ45hLjPzc3FSqsAzESA1dq8ebPmjwM4GAbzI5fLeXNyaGhIv7fYHeDAgQPy\n", - "7ne/W0REvvzlL+vnvca5i8985jMi0mZ0nnzyych3vRzL3XKLdNalbr5/qBvLULAjs0jUnww+XE8/\n", - "/bS3Jn3iE5+Qb33rWyLSaftjx46pjxfGy4YNGzTvHmPbtm0iEvUFA9D3KysrujawdeOKK64QEZHf\n", - "/OY3Wi+XbRkfH/dYL5G2tUNE1I/OUtHn68CScoYLtOOGDRu0rTmgh8cO5iSeYbV5N+A6tkwAeGf2\n", - "u2Zb2LhxoyePkUgkvHHC6ztLz+A69HUymTQtP3HZIuLej7lcLrL+i7TnJdY+fldbbdmLkbqoSYuT\n", - "yaS+5DhyCA3CgwQDCoOSK4uBxRpJvIFCx1nOZqyuGrdZiktXwmlS+DpX06obHYxO5EgYTBr8dmpq\n", - "KuKgDuDFjPbo5ljMzrUYSPg7Ojqqv2dK2n3pN5tNT+2ZNx24ByeSxDOKxWJkoyXS7jcsHljAWYHY\n", - "VfIWsV8w3A9u3fnFF+cQPj8/r/1lbSpRj1arFYn+Qj3QXzwuMekx/oaHh7VN0YfFYtGLgEulUvoC\n", - "wKZp9+7datqD6W5mZkYXXZT97Nmz+gx2wsXCwxs+1zmUgfm2uLgYSRAq0p4rHFGLtrDGdjd1cL4f\n", - "J6B2nftduJGV7oYVcwgbzLm5OXUAZpO2e3/eZKF92dEchxyktsK9RaILt5WNASYiEfE2AidOnDA3\n", - "1/1uoKDcjUg0OJozum2iLLM1qz6jHHF6aQz3Jb24uKhtDzeMm2++WQ8HmF/YRInYzr7A3NyceRCN\n", - "0zRCn3NSXYZbN+vlPzc3p/Oby4exbZkv+d3lBiwkk0ntN5jTua7oy1deeUUPKuVy2YwWZqV13Btl\n", - "5PriOtSNN7msfYV1hzUQMZbjNlp8CGOdQLQhtynr0Ym011aUgcckxiXWx2w2G0mwjO/QLqwr6Tq5\n", - "r6ysqEkPawOrxfMGzu1rtEkcgmkvICAgICAgIGCNuCDT3o4dO2RoaEidu5544gk5f/68fPSjH5Wj\n", - "R4/Kjh075P7779cdnj70f3eVrOqNzwYHB/UEhV1ntVrV63hX7CZitcCK1Xz66GWqc8EaU66irUX5\n", - "WWacyclJ3YXj9FKtVns6cwNxitqAq1Xj0uiW6acboHGCuh87dswLU282m9onOKVyGD+zOy4tm81m\n", - "9bTBv7FOytZJP84RnNWp3RPG0NCQ59y4vLysz8DppFQq6b/BEPSi0IFWq6V1wzi+7LLLdMziM54D\n", - "OB298MILkdyDIu2+x7PBiPTKBYm+n5iY0BMfn5pRX7RjNzVu9BvnCoNTPZ7x61//uu8sAKsFxtXQ\n", - "0JCXc5GzGUxNTennzFyi3Gi/XC6n94xjM9jcB2zZskXvh7HIZh9WzwcOHDigz2LtIlwPhe/vfve7\n", - "ItIxS64G//qv/yoiIg899JB885vfXPXvXbBeD7e1C/Q/m7d7AY7i6Ldz5855a1E3zS13DeQ+ck1t\n", - "jOHhYW8ui3TYQtzj9OnTWnew5JxEHuZ1zgOIzw4fPqxO8+jnfD7vyZYsLy+befUsWGs+2nx8fDyS\n", - "bB0A4wI2S6RjulwLXI28er2urC3mQCaT8ea/9e7tN9emSIeJwlrd7/rCSuloq8HBQdNlA8/Ae212\n", - "dlaZf6w1qVRKjhw58ttzNk8kEvKLX/xCnnnmGXniiSdEROSrX/2q3HnnnfLyyy/Le97zHvnqV796\n", - "IY8ICAgICAgICHjb4oIYqZ07d8qTTz4ZEX689NJL5aGHHpKJiQk5deqU3H777Sq8pg/9X2GtbgJ+\n", - "cYyEdXrGabvRaHhK2alUytzJuo5piUTCC8G22AeLaep2eurHYdT6baFQUBYAJ9zDhw97rIx1YhaJ\n", - "+kOhPVyfJZGOL0gymdR79mK7YPvnbOjoExay61egMi5MmIUlUQ/05eDgYOSE5P6GT0BAvyehOFiC\n", - "jIODgzomMBYXFhZ0jMEZdnx8PDLeRNosFE6V6EsO/e/3FMY+K5wZXcTO4zU2NuY56VqOsgMDA57T\n", - "7/DwsDoFQ3zxtddeM8c7518UiTr1oy3YXwvjnn1aWFE9LizacvDvBjd32tLSkne6TyQSnmJ8MplU\n", - "poLHJMqPucdj5NZbbxWRtjyDOwZHR0flk5/8pIh0/NfYZygOo6Oj+pu/+Iu/EJG2zMRf/dVfiYjN\n", - "OGM+JJPJSLuuFWiDQqHQ95x3cdtttykjw2ySm6XCgpVztdt7BZIi8FPjscTyCyy7I9Jex8E6Infg\n", - "Y489pnOey2mJTQLMkruipOl0Wq9lp3Ks2yxUzQKVGItoA2sdLRaLOq/4t6gfz8d+10i8BzB/5ubm\n", - "IuLRLli82nU2F+m8O9AG3Ic8p10x6dHRUW/tGBoa0vUOn507dy6WWe2FXs7mF7SR2rVrlwwPD0sq\n", - "lZIvfOEL8vnPfz4yuVutlkn5srkCDWdpLLE+kOtEPDw87JnYrISsFuIahLF161YtOy+MHAkiEnWa\n", - "R1m6mYAwEJBGgZ1P+UUUF53AcPWXCoWCtlU6ndYyclu6UXHu9yLRBcByvu4FTHr8LRaLuliy7od1\n", - "zzgTZr9lsTSeOHoy7hm8iXEX52KxGDFNi7QXEVyH8p0+fVpNDVD1PnPmjOcYubS0pC88a9HldETu\n", - "Is0v8NW+DG+77Tb97euvvy4i7Y2cO8+uu+46pbqBoaEhLReS6i4sLJgHIE6WjXphbvSr79XLDM+b\n", - "nX43UjiU4CU4MzNjRmbh3piPlUolUhdcg4Wbx6VljsbL64YbbhCRtmI1NKCwFtx333191eFd73qX\n", - "PPzwwyLS2SR88IMfVD0qbJD5sMVtaWm3xcG6Hn2ydetWnd+cqsNa3612sQ4OGE+ckQJjFuMqn8/r\n", - "5gEv98nJSe/wzug30g3Ys2ePOirjWcPDw95GlfW1sBnitrfSFnFZ2L2FnwW4azO/P91r3OcAvd4r\n", - "rIOI8mHMsoq623b8XsE9+P3D6yw2fyhLrwTIvQgJfp5Iu11Yj06k3RaYrxyA0A+BgN//1qL2Hn30\n", - "Udm0aZOcPXtW7rzzTp3MQCKRuCBRwoCAgICAgICAtzMuaCOFk+qGDRvknnvukSeeeEJNehs3bpSp\n", - "qamIwxsDpj1strDT66VEjd1pMpk0nWPdkHkOmcSuk3VfsDvmXTHYhampKd29shaNZU5z6eRu2iM4\n", - "QeD0uX79ei0LTglbt271HE4thXarrfgUY5mF2Izifs5/2akcp2zOpwSUSiX9jENYwQ6irLOzsxGn\n", - "YRGJ5BNjUyv6GM+1HLIHBwc9E1E2m9UTHtph27Zt6mSIMlntNjQ0pOOEtV1cc1e3Uyw+5+9hEoMZ\n", - "aXp62lPuXVxc9E6V4+Pj2kZArVbT8XQhSu0wyeVyOVWRRptaOaU44THmz+zsrGeOFLGd/vEbp7zx\n", - "hgAAIABJREFU1MdKBC7SOcGjnwcGBvS5bNpx2ale+m8WBgcHdZxgfFpzFeXgv41GwwvLTiaTXlh+\n", - "sVjUtY/HEPoOdRsZGZHbb79dRER++ctf9lV+OKdv3bpVGSk2EeGkjzpyHyFI4LXXXtMxCPNRr+CT\n", - "uKCYs2fPxppOmFXghL4i7bmAtrRyn1pmHmZqMaYwbw8fPqzaXEh2v7CwoMwwJ4RGImY4h5dKJU+K\n", - "g60GkC0YHR3VesC8zWwkjyf0w4033igiIo8//riuDRwAgfoyw4YysOQItw+r6+M6913EZnKrb9B+\n", - "rDAO5txii9xyiETfK2CzZmZmTAbHtRxZrgfJZNJTaO8Gt27d2DZrvwBGmjM+gBFMpVJSqVSkXq9H\n", - "NN4srNnZvFwuRzKK//jHP5arrrpKPvShD2lCya9//evy4Q9/2Pw9FqZUKmXq2AQEBAQEBAQEXAwM\n", - "DAzI6OiolEqlnhupNTNSp0+flnvuuUdE2ieKT37yk/K+971Prr/+ern33nvl3/7t31T+wALn8hHp\n", - "7Iq7nbZxgmPBPteunk6nvVORdb+VlRXdvGEnzA7NlrOi5cTHPiHuqf3MmTNaPpxMjx8/7tnnz507\n", - "5/mWHDt2TE9oqK8V0mvZdbds2WKKILLjpBUGyqJsImJmn0+lUp7/2vLycqyjPfqmVCpFFGXdcnE/\n", - "4WSHU5YVWlsul72TEYvHAax2zKHp+C3s5hyuDrBvH/pt/fr1OmZQ5uHhYWVUuG5oZ7CLr776qtn2\n", - "AAc7uD4Zq4GV3wr9hTadmprSsYW27RaUgTZkts0VSxTp+ILheu5Tno84/WHO7Nq1S8sMf61Wq+Wp\n", - "xbv/tv7fL3AItEL2mT3B/TF26/W6d1Lm9QTjKZFIxPoegRW5+uqr5frrrxcRW1HfAoIEXN81kXa/\n", - "oK+5bq6AKoN9YFymntkDFl+17uH6sORyOc+Hj1ltrF8scoo6TU1NeeKQrVbLtBDg31xWzBvMy1Qq\n", - "FWGiAKw16Dfuc/Z7xXMhoLljxw4d55whAGsD+2hi3kAlf3x83Jw/eB7y+h05ckQ2b94sIu33o/UO\n", - "cMV3RToCoRhPrOCNsTE8PKztHyfmnM1mzTx4mLtgn0ZHR3UN5TUY7Y/2sxzamalnJ33MKTCmHNTD\n", - "vstxewf068DAgPYJynLu3Dllu3nOY0x0k4OxcNFSxGzcuNF8eVlRcblczlS7dhWXu1H8bmTYrl27\n", - "dMHGdyMjI6aWR5xWURwGBgYiCy3gKrhmMhnTqdB1cmYKG53ODr4u5Q1YKWLweyxaZ8+e9crA0TCY\n", - "zCdPnjTr6jrfp1KpVTsSA5lMRusJZ22YoHohk8lo++L5cdGh3YAFLZ1Oa1lYPb8ftFot3Vi45lwX\n", - "rlPtasvLGBoa8gIf+ICB+VOpVGKTZaMdb7rpJnnmmWci5erWBtdcc42IdMbJ3NycjjWUqdVqeYlO\n", - "U6lUrAYRO5PGBV+sJmrPxeDgoOcMzHMOqFarnplyenpaN4eYK0tLS1rPuHb+3Oc+J3fffbeIiHzk\n", - "Ix8Rkd6BA4gc27lzp6cZtXHjRi/VCLcL1hWen6hHq9XSvmXzOsYCNlz80kZb3XDDDbqeY5NQq9XM\n", - "9Dyuw3MqlTJfhu513aKjAT6kosyf+tSnRKStc4bUOdb7AqTAD3/4Q+1fTnXivlu6rSuuQ/7IyIi3\n", - "QbYc1a333o4dO3TzlE6nddOC9t2wYYOWwQo6wcFxaWlJ298KGMDYYPeGuE09vxus9yPm+rZt23Qj\n", - "g+ueeeYZLQtHkLruISMjI3rdagNprHHSTb8K9QWBwMr22JDOz8/LSy+9FJIWBwQEBAQEBAT8NnBR\n", - "kxazcxvAuk+8e3ZPEfl83tth1mo1b4fMzBefWKyTEr5HaPLp06c1ESvLC4BpwMlgenpaT1JWqCaf\n", - "rPqRNbCcoXslvAU4t5xIVAVXpL27dnf42WxWmTkwA8ViUU87qHsul9Py9xs6jH4rlUqmQ6F7Aq7V\n", - "amY90V/4m0ql9IQMlXA3wSw/R6RDM5fLZa0bnjsyMqJlBaXLfcCmUQCnttHRUR2LnJMPCXQxrp5/\n", - "/vm+282qg6vqXSwWIxpqIu124cTZIu25gjbFaTGTyWg9mcJGW91xxx0i0u57nIpRdtaMAXK5nJok\n", - "wOxaCbAzmcwF6Ra5yOVyeu9yubxmRoo12axTNpsewOpgPJ05c0ZP1xgfxWIx4pwvEp3zGMcHDhxQ\n", - "duKhhx5aVZknJye1rWH+SKfTej8+lWPssP5bPzpNGC8itvM3M95slkNZXDmA+fl5LxktJ+dlk2Ic\n", - "e4J1aGBgoKeTvEjboRm/QX35/YHybd68WZkf9Jul9caMFNYfZlU5wMR1X2CWymL7+V1nSTVYVgY2\n", - "3fezxvRi9wAex+zO4W4bRkZGtD/j3BFGRkbMZOVxwBgsFov6WzfHqEinLcvlsseoZbNZNYljvWPJ\n", - "CU5A7jrDb9iwQc6cORMYqYCAgICAgICA3wYuGiN1ER4bEBAQEBAQELBq/NYEOS8ELqXWy2zVz3VD\n", - "Q0NKK74V6UAuBIVCQZ39jh49KiL9KwiLdMya7HS+mt8DLg3MIqnclm77dlPIRXksVXSUr5vjrlu3\n", - "oaEhdcRl9XHWiHHLx/ezzLigfnHfbgmlXed81s2Kc5TfuHGjasSwwrDl5B9nZmL63lLuhhnCdZ5n\n", - "rFu3zjTjuCYRJBUXsR3Z40woXA+0N9cVZo1EIqFlWW1SUitzAZcBiV27JfNF312IaW816Dfh+WoT\n", - "o78V+L86pLprCJtYOQAmriycAsj9Let18XXsoIxnuOOTIyaxHljz0VpfuCyW6Yyf5aatqtVqXn15\n", - "7gG1Ws0zjXOgDNBsNiPrN8oFs5U11t+uJMVq50IqlfLS7Fh161bftc69bk7pve4TTHsBAQEBAQEB\n", - "AWvERWOkRKIOtNi1FwoFj1UQ6S/sfH5+3judsG7JaiUMupXZ1VKynObuuOMOdZKDQ+hqGCU3RNz6\n", - "LUsFcHhurxBxVwCVlcOBbs7tODWB2WCnSz61WcwWAEdMS0vFCizo5hjpli+fz3uSGtlsVn+LNmXd\n", - "L74ujoniE7j73LWwn3wPV9WZc4rBIbher3v9Oj09bQZNWIAi82/+H3tv8mtZclUP79u/e1+bfVOV\n", - "VemqAhurbAa2EBJCsmTBBAkx8k+MEAz5CxgiJnjMgBlIngEzkJCMkEH2wCCQBTbVuai+yaysyqzK\n", - "fPm623+DpxVv3X1WxIl738t6Zb5Yk8q675w40Z04EWvvvfbLL1f+Vsfi4DTmHdvNTk7Ha2trwVEY\n", - "bWMnYMUoq5yP6rl1p0E/lstAnVx5Hvs65DJePGeXzWm3CjxjYqYZl9w1sO5En8M0qeuYQeK1GvVj\n", - "xgnzjOebl/Hg9qo1xzPZdW1oNBoLCe9xnX/HW62WZJAwxmocuN1+DY6xS/zvnLl3GjYqN6DJ32N2\n", - "3HYVaLUqM1THCtUFhPg+VxYMVb9V9wjntpGCbD0+HvgYs9DmKgsQ7kUUy+Hh4ZlECXGHo85KkR2b\n", - "hLfffjtsoFZ5PtqRuvfq1avhZcemsy5ig01ngJrkMYrTT7ROpxPGDnXmqA3VDkT33Lt3T26afH2m\n", - "02nyJUDEoTL9PP3000FEj+GfMZvNkhtQToybApsIU+DnczSP2aKGC8b1ueeek4KC6mPtx206nYaN\n", - "FrS5WNzPR1GZ6QUQY8Rzg9P0sPih2eJGCptFPnSg7nWZDTgJt1oLlMhkLtQGKrWBy/0gbG9vh3fx\n", - "LKMUGWqjF6vfsh+IZT986uPl/526zoNNZ2xqU6Y9tM0fPs0WdfuUqYjrhb+pjU/K3QAkgNrwsRsB\n", - "/82bD/m62AZvVbN1rrkv5eoRA9o+GAykFlzK7Ja6Rl3HSZqVua/ufU21hdu7yuavmPYKCgoKCgoK\n", - "ClbEuTJSo9GoskscjUYVM9OVK1cqTs7z+TwwH9hBPn78OJz+YklIl4VP/cL/5t98yhmV7HEZ5Jxi\n", - "+/1+6KtV9ImU8zCbsFTb0f8qIaqidnl8cXr57//+70p5wObmZuVkM5/PA+uEdvKpjlNOeIYL9Yy1\n", - "nU2V6gSi0oGkACVf1BH1xzO9aYL7VrFd+K3T6UhNGWWOVCwg2LpvfOMbZqZTDjHgRM7zWDn9si6R\n", - "T8vBABN14cKFML6s5ZXSV+P2quuWzdUZO6F7EyEzoaylkzqpYp168OBB0K3BXGSz82kc0VPmyFar\n", - "9URNiP55ADNNfI2va4wF8s7rygGdf1Pl8TvqddO63a5k7/zcYXV3nu+e9ZzPT9LVcJ29yZHnlBov\n", - "/v9UUMxpgihyGZ+Y+SsFn+DZTDPEHJC0CtuJe4GUyZafV/csxWYpJrQOhZEqKCgoKCgoKFgR5yp/\n", - "kKuuysq7vDuEAi0cct95553KqZ7V01dxCs69J2cH/+KLL4Z/w39qNBplK7x6DIfDbOZN7dBxWuK6\n", - "8w6d822hDDACHNKLU59qBzMHYDlQZ+XcqE4Q6oTTarVCmxRLBGaIGRXuA58rSjEhrBKeqgufJnm+\n", - "+LbwiY8duFk53kwzU6l8bR6oI/qFc1Ui39gv//Iv2+uvv25m2gcRrJJiVrlP4HP1+uuvB0VgzAPl\n", - "Z7e1tRV8pzD2zEDzKRD38vgqFWnFqOY6QzNUP6RkLVQ5PJ85YbbZ4nxX7yGzlKl1Rz1fndqfJNTc\n", - "Vo75KUZF9V+d9IBiELzfDPcd+qPb7UqJF88+MOvFUPVXY+mv57JS34hYYAPff9ayBqn5WydHo9h2\n", - "3Is+50CvFGIsb6q9uX0Z+3uqfM+O5uDcNlKgzWGuYOovFT3Fjccij8X1qaeeCgOH8o6OjoL5KbVh\n", - "iUUseHNVzAk7B5PJJLQX2jiTySR8ONHujz/+OOulqctO/dxzz4V/L+tUCxMFYz6fh75WaUXqFnGf\n", - "AFY59qlkmRsbG5XfVeQdp9bBs5CuwkxHiamIL3YexZxAedxGOJYfHR2FslMmVt5IqcUJgQoq5cV4\n", - "PK6kXlDRlmZWCYZQ8xoRdr5NAA4vV69eTW7W+V3wqTDMqg70jx49CgcgzCHlRLq+vh7eOa4f/s36\n", - "aqnN6yrAWMc2NMqEhd+479EWzKfLly8vzEdAuQqkUKf/pkxEdR8e1a5lr2MTF65TprNU2SmoAx+3\n", - "TfUf5stkMgnjwBszv9FrtVrSod07ss9ms4rWWyxi0m+q2EGe12DvDM8RwqeJTGWoMUT91foUm5O4\n", - "H++KcvDP2UT5utTVPfXu5TqMp76Fy9SHUUx7BQUFBQUFBQUr4twYKSQY9sk02+12xbF3bW0t7P7Z\n", - "ufmpp54ys5PTNTNOKqSbodRmPdrtdrgOu90rV66E07VPbliHt99+eyFprNkxg4FTLH7L3RHzyR8M\n", - "F2QfzE4So9ZBPW9zc7OiyWR2soNnc0tKEoC1WJTWEf6ea5JQDtfAhQsXQp+ArYzpQ6VCsJna9U7p\n", - "zABhzh4eHiZNhAyvM8On7GXp6tg8QR3AHjKbhzr/9Kc/DeZPxWxibnPSWswtZszAVq2trUmzpx/X\n", - "vb09GQCAdxh13d/fD6wTl4E5hHqtr6+fSRYDxSrlgs19alwxHnfv3rVbt26Z2aJUh2dKcp/PzAbr\n", - "iaEclFtXXso0tcpJnVmWlNQAl+fHkM1ainHk+qW09nDvZDKpMEcxc6Mvp9E4UUrHWjKdTgMDyxIL\n", - "yglaOZbzuqja78s4DdMa60vPZrLLQy7QL1y/lFN4zJybY0ZTZvWYvIEKcljWfLgMCiNVUFBQUFBQ\n", - "ULAiztVHajqdhh0hTk+sRI3d7OXLl8N1OH1sb2+HXHZgRHZ3d8PpAOzUw4cPw+4UrM14PA73pBSh\n", - "J5NJhfl47733wkn+W9/6lpkd+1H90z/9U22bh8NhMnz+NI6icF6/c+dOYA7ghO+Rw2zEdureTyd2\n", - "rQ8DZmkCRkr9GdfzGDLr4U8xXD7KWV9fD6dIrieu5dOikm/Ab8oHgOeOUv1W8HVmZ3OwQMr3aTgc\n", - "Vk5Z4/E46QuAune73dAmfj+++tWvmpnZj370o2h92T8KTBT7TWE+NJvNhXfYTEuZzOfzCoM5mUxC\n", - "HzCzkmL3MKYbGxvZvhgpcP+h30ajUbbTqj8hq0CaK1euBCaKZRxy6h/L54g1kufiqsyaL3sZpJyx\n", - "zU7Wcvb1Uc7aKV8vbi/3vfevUxiPx9KnSTEc/lszn8/D+8Nrg/dzZPkDxcSpf6ecyT3TeZrMHIrx\n", - "83XMHXNmkDyTHLtOoU7aQX0TcuuogphyhUBXwblG7TGViIVxOBxWBh2bBNxndtxRd+7cMbOTCJ7x\n", - "eFyJNGOknM0bjUYwhdRFSMEUggioVTSccoFN22effVbpF6aSWdMEC6hyWjZLRyXA7MIvBkcTeXNm\n", - "u92W9VKmVWzw4Mi8ubkZPgBqA8JK2vjAKnPqV77yFTMze+211yo6Qzw2/AxfF7Oq/lKz2QwffeXs\n", - "yY7o6NNlP+qz2SyYqdDng8Gg8hE8PDyUZtCUY7FPHO3rh/mhNpBcP7+gKVMp1wlz6NNPP5UbKYwD\n", - "l4txgrl+Pp/XOu7j3rPYSDFylcjrNlleK+yTTz4Jm9dXXnmlco9K9wSoyESzapTVMhGM6sOSaxLJ\n", - "KS/2bOWA7k12/Fz+4PsNSG7dptNpJQij1WpVymEHb3YxUWOiHJ9VxJ8yQykHdH8vO00v01b/jLqD\n", - "cm40Hl+Pb2Xq8B/bRPl5znMW83gwGNSmvfL38DdHfePOsv88immvoKCgoKCgoGBFnCsjxWAnXOxY\n", - "/YmE72MmgbGsJhPCszc2NqJlxpCT144R29niZA7nxY2NjbDj5/BxmFO4r1R+I+zMlf5WnQMjfuOc\n", - "h3wa86GmfJr0z/fP8JpEzGxwud6xu9frSeqYmSiz45OOPwXFTiSexdjY2KiYLWezWdIcCbRaLTlX\n", - "czCbzQLblpL9GI1GFaVn9Szl5MzjByr+wYMH9tJLL5nZsanObFEqAkry+/v7lfbySZHrAgaMpRVU\n", - "/VBHOJOziR+M4/Xr1+2NN96IlpOafzlYVsE5FyzjgnpxX3omilkIHqdcNkE5EavrFHJM+rmMVIyN\n", - "8u3gseZ7lH6Uv46ZbhXqngKb55gRxVqjTI4Yj5iJVzFNKUZK/caK+R7e7Lesgj/3n3Juz/kmqPdj\n", - "Pj/JKoI+YkZNmWzRz+12WwYn+Xtz2Si0hf/Lz65j9HISGeegMFIFBQUFBQUFBSvi3Bgps/jpA8KE\n", - "YGWazWY4qcIvaplnpHaW7HvDoptmZteuXQuMT4otiAG+LyhvbW0t7LS5PJzMcXJdX18PO334Y21s\n", - "bARldDBh6sTOatwxNkbt1r2sQbvdln4B8EHyeaYYjUajwvi88MIL9uabby78xkwHxoH9EVJK32ZV\n", - "fyl1Or1y5YpkGjEOOJGovI9mJ2OjfLNYQXzZ0yIDcwzjr+rBzsuKKVSnKIzV2tpa6EPuc5zg4BPI\n", - "z+BnpZyWeT6g3jit1t3LZeA6jMvVq1eTUhfAqozSsvflMlhqrfFSK75cz/ixEj1fp5yDU4KcfJ2a\n", - "H/5e5Q8Te7+XZbNiDuX8X19n/1uMeUqF1qvrsDZBgsdskRHzbFGsXH8dM9Ncd+XPlXKQX4URqYPy\n", - "ZVqWaeTAMF8e+z4C3W63Ih+kmKbBYBCeg3WK81yehjVWbVSBCnX31OHcNlLKi95s0aEZDsEbGxuh\n", - "wcoZGuj3+3KToDZBMGdgkT46OgobOJjYut1u2MxxtBg+8Jzqwk+iXq8XJhva8Ru/8Rvhg/Gf//mf\n", - "ZnZsTkEd8AF6+PBhRUl3c3PTfumXfmnhGdyHqJNahJcBmyYUvGlPmRTG43FlMt67dy84EnPwADYF\n", - "eMH4o8OpBnyb1tfXw6aaaWtf7y996UtyI4V6Y7N7eHiYXMQZ3rE39kLmAnOCFYb9My5fvhx0vdgJ\n", - "P7XYI1CB+5vT/eAZvHn2v/F4pD7GZicmPd4YclJjXI++wtxWjvz37t2r/KawiobUKtkJVklJgfHE\n", - "WsXXsYM/+hWbdrVeqUMRO1/7v6X+HWtTnSJ0qiz1d/V8H4lmVp9Ghe9NpZRa5QOYE/GXW4Yyl6nE\n", - "w7E21pkoc0yYCssEC/hr1b3j8biiBacOOypqdzAYhPceB0f1La+LUlQBMrnm/rPcoIZnn3mJBQUF\n", - "BQUFBQX/P8G5mvbU6YRVZGFyGI/H4QTJWiBeb4pPtilzAO/swQINBoPARGGHPB6PwykRO2B+DnbU\n", - "BwcHlfpdvnw5lI3cYsxcYbfdbrcX9ErMtCnr8ePHFbPmwcFB5Z6UyriHYhZYqVadTnHKrsuHqEJ5\n", - "vbP55cuXK6ranOiSnQi9mUedRJV5jR3IlSaLcoyso37Vc1c90fIpEGxRr9erMH6s08RMTopZwdzl\n", - "tvH4+vyBk8kkzG3/LAaPEfq31WoFRheM1P7+vt28edPMTsaNc5SlGKm9vb0FxWjAj9sqp/Q6NmrZ\n", - "kHO+Bqzc7u5uhR29dOlS6Bs+SatnqLyF6rm4jnOM+rlT596g9LDqrssBZwZQzrzK2byOSfD5/Jap\n", - "z5OCqgvPT+/oze1QTB3gzbRPup2x8lW9vKtAbC3yzDoHgzET5SVWYnV59tlnzexk3WG3ipSZVLWD\n", - "53vKDJ6T57AwUgUFBQUFBQUFK+JcfaT4vwA77MEH6ejoKOwKWcQLLBF2sbnCmP1+v5LRfjQaSVst\n", - "To7wc+p0OsF/AyfrTqcT6owTItcHp8of//jHC+Khqv2A931aW1sL7cRufFUhwpTonmJZ+FQBFkPJ\n", - "TPDJwN/bbDYr8gJcBtiTGNCXqDvfi3HgUz5kI15++eWggA9GjJkCFb7LfeHnFDtQ8ylqVQdRddIc\n", - "DocVB+Xd3d3gr4e5qxy5manF+7O1tRX8xPhZOCWy8zo7zuK/3g+LT2g8j5m1BcAqs08DxppzpKlT\n", - "pWecFXv7JE7pMXYyBcwF+HeqcX3w4EHlNw4EwDrR6XTCv5XQJgPPYwZLKaCnkNuHKd/BGIunxinl\n", - "PJ7qbyVEGiunrl5nASWqqXx0PUs1nU4rjJS61/vAnQfzpurF6zvA/mFcZzVvU++6AtanVqsVsnW8\n", - "++674e+5/lA5/aesCzn+lOdq2lNA6hgGfyCZJsXihQ/MwcFBRb12bW0tDCw+LMtqTfG9DCzqvV4v\n", - "OC1zCg6f+uPw8DDL9Nbv98NGAHV//Pix3OitAhVZon4DeDFnKhe/Abx58vooKp0KjwOuOzw8lFFp\n", - "2MjiHt5E4t9scmL9rZQ+GC+GfsEzS+uqqEVu2ei9mIMvm2rMtOK/Ai9ImHcqmTDK5GfkRtkdHR1V\n", - "Eh6r6DNca3Zi3uaoTF6Y8W9lUkS/jEYj+fdVnXBzkPOumFU/BLHoOY+jo6OK2ZqVmdm0q8xaPsE7\n", - "gz9YytSeQl3E1FmYAJWpi5+rNha+/rFNb8oJn69fdXPCquiqfqnNZGxTmdLSytXLUlDmrdi4Yq1Q\n", - "/auuU1kWeNzUPMK/8d0ej8fhkM3PUw7lyCbC7VFuEMsetFLX5/R7Me0VFBQUFBQUFKyILxwjVQc+\n", - "lWMXy4lT/c4yxj6pnfKXv/xlMzN77rnnzMzs5z//ub311lu1dWLzD6sYAziN93o9e/31180s7RTe\n", - "bDYrelN1bAQYmIsXLwZNJuUkF2Of/Aml2WyGZ/KpA/WGeUYlMeZTAu7d2toKDAmX55kNsxNNKZji\n", - "ms2mDA0HO+HD6c1OElS/8847UpqC8+mZacdyZrhYmsCblOtkCBjqJKdy6AE4DW1vb1cc89V16vlq\n", - "jBhwkO71esFsyO+RelcUU5fL9KLvmXlEeYqB4f5Rp8PP0+ShAjTqFOa5/pyU2ey4z7F+sCZXiiHm\n", - "svFeqPVEsQBcXooxWyV4ImXu499yGKtWqyXr7O9Vjtt1ZfM1KcmTVBksa6Dq559jlmbRYvdxO3Pn\n", - "ueojXxf1zPm8Kh+j2mGmGVjPdvHagXeg1+sFBta71/i6e1Y+1n5v/VB9pfYGsW+h/y3LJFh7RUFB\n", - "QUFBQUFBgcQvHCOVwjKnqGeeecbMTkK1NzY2QmZ27HBjKuqcod5fF2NozI5ZlxwfqToGgQHfLLBe\n", - "g8Eg+ATV+ZHgXmYSwJjwvRzKi5MI7mXgGVtbW8HJmMPplV+VclDGiQWM1M7OTkU6wSwdKsvlepZQ\n", - "MSvqFMP/74UqzU4YCeXPE4OXHDCrqsWzwzizbTdu3DCzxZx4vi4q3xTXD473EPfkZzBYLA99iXru\n", - "7e1V5nGr1UoGeyjfMcWych4+PANzbXd3t1LOYDDIzjqQctytc+pNsTbMnuDvzGZiLPv9fuhLDt9G\n", - "2angEe4rZlHRR8sGO6jrYjIevmw+3ftr+N8xRipH6sDsZC3i8hQTuiojGfORWpb5UUgx3Sq4h/8d\n", - "87PM8dVZxo+qjnFDef495fqzzyLWSKwxd+7cWWCYAe/r2263pTBqzve8zh9O+YSl3pVV59Iv9EYK\n", - "iz0W0mU2UnAe5//+y7/8y8JvCpcuXbLf+Z3fMbMTavLf/u3fkkrM2GipNCOnBTZBdSZITHh2JoZZ\n", - "gDdSKTPT5uZmJUqI2+Q/EnwdR4QBOzs79uGHHy789vzzz1dMkv1+P2zMuJ54IbiuWHy5XF8evyy4\n", - "/ujoKPQR61f5DVSdaUIlOV4WaoPx6NEju337tpmdbKSU5hZDmYXVRgpzguvOCx/afuvWLTM7Tk3k\n", - "N/tbW1uVjZQyoTJSixZvWFl53bfz4OAgOK3WQY27Msmy+TXno68+5rwpYu01ZFRImWnNFvWo1PO4\n", - "XNTVLF/TTH3MY6YubwJU4M0VR+oqh3EVNaw+pLjOb6j4utwPpOqXVT6aKYdw/j1VF3Yc5+t8m5rN\n", - "ZnJDpnCaNvH93hzpgTHmeY45iO/d9va2/eqv/qqZWUgP9uDBg7DeQGPOzCoBQeq5Tz/9dPg2wzRe\n", - "Z55TZrw686ZHTgBRMe0VFBQUFBQUFKyIX2hGahkTmAdMeowUEwV87WtfC9f967/+a7gP7A6H8WMn\n", - "+ySYqGWhdtUqZFo5yXptIbMTNtDshO1SZkvWxvFQ2lFvvvlmcMgFrl27VmGu2HTHjBTjQgJJAAAg\n", - "AElEQVR+f+2118zsmGXxiTL5VMwnKtzLzArMSihjfX294hxsZhWFaYVWqyWZPs73Z3Z8KlJh/t45\n", - "kxNUKyiWCnXf3NwMbcI8YKkQJZmgxgvXX7hwoWJ+5dMe3tVLly6F69SpUyUqZrkEjBG3u87JfVnd\n", - "mtTfFJQJOBYcAv0bdhLH/dx29JcKTuDnKi2wZevMUMy1v6fu1M4aZEovya9Fy5ij/L1KhkAxDnX5\n", - "/FZBronIs08qAbW6jln3XEaqzkTN13lTYqNRTTavsExdfvSjH0X/rlxnvPyC2cm35tGjR5Vk83V5\n", - "C+tkDVJ9lHr3PAojVVBQUFBQUFCwIn6hGSkFzwzU7Sax2+31ehU/HLOTkx7suf/1X/8lmSvv9Gl2\n", - "diefswCzRWBA2H9F1ZWV280WWTycmGOnGPQDGARmDeD/wX46GIfhcBhOHRjLl19+uVJ+q9WqME1m\n", - "J8KdqB+frFn92fugtNvtCkPHEhAA/z+324tb4n6zRZ+HXL+qFJvEz/cnrzophjfeeMPMzG7cuFHp\n", - "P+VLxSyYciZP5aHqdrth3mE8rl+/XmGu2JcK4zUYDMKcYZZEMWU8bin/Gx4P1JsZE+VUvay/kRo3\n", - "rEHdbjdcx+sFfkP/7uzsBIdcvKu8jjH7hDrnMlG+3mYn7W232xWx1NiJXY0DM1H4ry9H+TSp9yIm\n", - "taH8ulKsAv5W9x1AnevGkqGc6lXASkoWgq/3zBpLLHDGjxRymRfVp9xHdePv2SweL/zGTuXM1Kp7\n", - "ECyFbzAziGx5SjG+XGe1DvA89+1V5SzDTP+f20gpJ0SPRqMRBg50eqfTCfdgMZnNZgsmLLO4+U+p\n", - "sObCbzpikX2pRLLLwCuL86Tl9B1qoUAd4Vy/sbGR/YHFb8rUiTrt7+9X6PvhcFiZ/F/60pfsZz/7\n", - "2UL95vO5jCYE+GPjn6Femn6/XzEf8/jyeCiq3n+sx+OxjFKE8zjSH3zyySfS3IF5oRYT/s1/5FTb\n", - "OKEwKHZ+Z7DZ4eg5bKrYyR3z5bPPPqssXpzWBptwHgO1YOHv/BFm+Lnmk6WmPhjcPrUQe8folJk7\n", - "9gxAfSzb7XZ459SHCo65P/3pT8NvfABRa4z6YHjNNZVQVn1cU/3o4eeUMrHxv1MmKjb3pe5dxgS4\n", - "LPj9zYlc5AwcShOOr1fO0DlK8948qNqv0lqpuvu5zdexDpOK/vVtU9ks+NDBfek3pdy/XBdPYrBD\n", - "voog5Hv9dzE2hkDdBmklh/2l7ygoKCgoKCgoKDCzXxBGanNzM5zGQBfGdpWeEWq320H1G6fdg4OD\n", - "wIoofSIGGI533nmn8jfslC9evFgbzhy7t9vtBnVvsGMfffSRzKuHHTc7Y3NouNnxKTTlMGxWNQPE\n", - "tDtUHq/UKRZgbR/W+PGnHT4po+2PHj1aaAuAUwfMGmCjfJ0UY6hC2JUpxFPO+/v7FSdeNgtxecpJ\n", - "WjGHKXMB5iSzowCbUNlECShHas436DEcDgMDBhwcHITwfDj3X758OTBS+G+3263ILgyHQ3mSQ13B\n", - "SN27dy/0Myeb9qddbhubxvy4KUmEHKTYXT69ezmQunBr/k1lC+C/++e9+uqrlbrgnmazWVnb1Om+\n", - "1+tVdLVYxiNl9uXfFPvF75G/n0P1uTxvAlLMBecCVH2UYqSYqeH3V5nTcsLf60y5bKLE3FFsGvdV\n", - "iklT84Cfwf2hnPSX1VpSba8LIuBkyzFwPbBmzud5SulswlT58oAYY5pSQOe5o2Q8Uu9ynXmTURip\n", - "goKCgoKCgoIV8QvBSK2trQUnYvgsPX78OPgPYKc6m80qO3R2ZFXOyXVQDugAnhVjo9SpF7v1a9eu\n", - "LdTR7IRB6vf7kkXwImi8s1aq2Hx65xOpOiXgtAOfoG63m3ScBUajkTztqhOrP/1Pp9PgzwE/nX6/\n", - "XzlR9/v9wMKx87N/7s7OTkXYzexknPiUHRPK8+UqR2WFHL+1ZrO5IJyI8rzo59raWiiPGTHFRAHK\n", - "QRr/VUzOcDgMDBgzV97ZeGdnJ8xvxVAC7NfHJzmMq1LR53FJ9R87wyqH8FWQG+atxgtIObeqecJs\n", - "pfK/UiypEj5UzrLeid3Xry4UHtcpBX9V51gZDOXQbJYWtUyxRfwbMz7KSdvXuc5pWjEXKczn84Xv\n", - "Dn7z7VA+XwqqLzwj5e9Xfarmp6pPbI1WfoLLMDNmi/PYz1X+rqjvFxALNsiti++P2FxMlbuMr9Qv\n", - "xEZqf38/dD42UlevXg2dj83O0dFRZUCW0ZpCpNILL7xgZscL30svvWRmeqNSB3z8sSmazWZhksHU\n", - "0Wg0wobLO4F7sOK2B8pQ0Qn+HjW5Fd3O5gyzRUfRVOTD4eFhZROpkpDy/Zj4vElAGp/33nsvbKQB\n", - "djwELl++XNmAxqJw1IfCO4dz/XyCZA+lNp3a+PCBwJfJH0P+GzaCaAdHsfmUMma24BDuP9KtViu8\n", - "N0jw/PDhw9B/KFdFFCqn/slkEvoIY8nJiAHe6KF+vV4v9JV6X3lR9Au9nwPKITZF+XOb1PVqDFOL\n", - "Lo+HN0nx2Dz77LNmdqwrpdqA304TWMJmSf9h4YAB7lOf0iM38pg/+uojrFCndq82IwD3rTIBLusw\n", - "XLeBSx280GftdruykWYnfP6bb1ssQnSVDcCyY+fbk4McjaVOpxP+jvV7OBwmI0y5r7x5ue5AEAss\n", - "ycEqDuaMYtorKCgoKCgoKFgR585IgbVhbSPsQLGbHY/HgaXBKXptbW2BhTFbpOKVrgV2uLPZTDIS\n", - "OA3jVP7+++9Xdty5bFSn00nSkHjW1tZWODnC9DgajYK5hTWc1LPRJjAc7XY7ae7odDqVtk+n00od\n", - "VZ4xdWpSodVmVT2v8Xgs1Zc5Ia0Hm/HQX+q0hTKUWY/VxLn/VDkwM9axmGgbm2qU+nvKLMRaO16d\n", - "ejweL5izAMxLlklIPYPNDJ6pYZmEVJ7Izz77TI4bv5seeFa73Q5/x/u7vr5e6V9lkldOrhcuXAhM\n", - "Lp/oeb7nyBPU6UNx2V4fTL3LPIYq7yOb4lFXKJz3+/2K3Alr7aAM7vtcswbXxbPLMSd7pX2mAh98\n", - "HWJh/r7OyplXmb9S7Itvq3JyV7ILqrwUo5NqG9/D75QyPfrrYybAlFkw1oYUU3ZW8FI2k8kkue4A\n", - "PMc4CCjVLi5HaTPmIsUGA0phPuZwX4fCSBUUFBQUFBQUrIhzZaTY8Qw71l6vV/G14NBv4OjoKCpc\n", - "6YFdpwrF550qTs1Q0j6N3XRzczOUlzpJHB4eBiYEzMpgMAgsAH5rNBrhJM8MhncObTab4R61C9/c\n", - "3JQO9Ow7YbYoMskicylGivvU+wVtbm5WxBR7vZ4U8wQwvhcuXAh9qdoEcdUPPvggWhZDnbLZGV45\n", - "3/IYqjorQU6Uh8ACZn7ALrFzPViHTqcjGSmMjQpEYMdtzAX0X8w/zrMofC/+tre3l2RFYiduPMu/\n", - "t4rt41Byrqf34Ynli+QTc45obd2JXflZpXx3lFoz+wSqPgdGo1F419H3PA5cp5SPpGof5y1TJ++U\n", - "wGKOPETd7zxeygdJvTNnAWZ8Un5TMUdwxbalwH6lPjglVpecstW9p4ViwOqgLCF1OSU9VG5JQNXl\n", - "NLkRua9iTFROucv4mp3bRqrRaFi32618lI6OjrL0Q04LjmgyO55guY6dqUkETaher5eMEkSbODUJ\n", - "Rxh4h9zJZBKeC9PSo0ePKnUejUbBTKaUvFVUh9oMqboqcym/ZCkH6sePH1cit3JV4FUQAUNpR6HO\n", - "3G/s7Kmcx9Ff/NJzOSjXv/QcgKDmRGpeqXaNx+PgnMltw7hjfFl1HKij2FHGZDKptGM4HFb6JZaW\n", - "RX1oVz14TKfTYKJmM6w3jcUWbd5IeW0fdoKuWxC9A22uCZAdt7lNHt1ut+J6MJ/Pk863dXpnvm0q\n", - "uEKZTtgRGKhzck/pSPFz6jYKKsJRmXtSZjLevPh2xp6pVMBP62TM5fGGum4DpDSccsyldYhtkHI0\n", - "o9S4xUy7qQ0UO4mjTBVNqlTUU6Y4vkd9iwB1L/eLujdVXg6Kaa+goKCgoKCgYEWcq2lvPB4naXQ+\n", - "8XHiUrN8uq/f71fMJHwSy6XLgbW1tcC8cJ4+nyT54cOHSSYCrMfGxkZQV+c64O/on/39/XBixo5/\n", - "bW0tMAzol5i5E+WwWQj9opLv8klEsU98IgR7wg7jXrF8b2+vcgpSJgx20kcZdSbcVNLkWFizYi4w\n", - "x9TpiR2uof4NZ3hlOuOyYUpVp8XxeJw0ozA7hv5FnzabzUrfjMdjqbIO1AVLoA7MzijmAvViqQ7P\n", - "DHS7XSn9oODngWKIh8NhUo4AdeO6xORKFJOT0rJRUI7bqZybnL8SYNYBdeJ7weKORqNQP5iy79+/\n", - "X6ljLFzet5frzO+bWo9zQt1jJt4cJoR/V1Ir+Bszj7xuez0nZbLL1XNahaFKsXMsdaCu5/op7aOU\n", - "+ZOd5ZVeUkozKhYw4O+N6aYBPDc4UwHgMwPw/anAkFgQk3onU4EqXK6vv3JVUb/loDBSBQUFBQUF\n", - "BQUr4twYKZxovYSBOvVwbi/cN5lMpP8Ass17pW4zvQNeNk8XMwCXLl0KdWefEjMtwshQuegY3k7b\n", - "brdDX0FputvtBvYh5RBolm4nn07Qv9y3zMaoEwYYOvjz8ImAM9B79oT9l1R2cGZqvO8BCx4qxkrZ\n", - "vFOMz3A4lI70qB8/wwumdjqd0F9gJMxOmCMwSTEHX6VejWco/6RcJ13l06LmgfJpwPiqkyGzAArM\n", - "sGxtbZnZSR/wu5w6/a+vr1cYtcPDwzDXuB+5Lt7XT70XfJLnOqsTt2cLe71eGGtVfz6N417UYT6f\n", - "h/FMMTTc55h3s9ksvIecSSFXkDHnlK18X1TOM4WYY3RK3DLGnuE+5dOC/kv5YeX61NY5JedCtUc5\n", - "ufN/U76oXK7yffPPrauXesYq96rxZX9CH6zDeTDxLphVrQGKMWMpiWVZwjqpA/V+pFhXL/+gcG4b\n", - "qa2tLTs4OMhK28KbISxi29vbYWHBgttqtSrq4LmRfbloNBpBcRuT4969e8lEwKtAqZv7QWbNLbR7\n", - "bW0t9IuiZRnKoRnlcL+hbeqj2u12ZRSZN88pMO3tTbf8Gye15M2GV1JmejnlLMv9gv4bDAaVucha\n", - "S8DOzk5F/VtFfqq2DwaDyrgqHRyzqmM5A2Vcu3Yt1Jk3u3gfsEkcj8cV8wdDffjYEVRFpKnnAhjT\n", - "0WgUzFAcAPGVr3zFzMxee+21Sl3wLHb05wUcawHaFkt5lIL66CsTm4om5ChBNqcoU6FK5ZQyQ/uF\n", - "nn9jMzibN9VHJqX7pDbyPNaqz3MOm/yhUhsgIPaBTgUW+TnJ/1Ybqph5S+EsnM0BjtrjoAL/Ic6t\n", - "s78utSkF2JSt2l7XXuXgX2eWNVsMGFBrOc/tVLAWr6k535BYG3xduTx+R1PBRMs8v5j2CgoKCgoK\n", - "CgpWxLkxUjHzQKPRCCaRFFulQt6n06lUtz4NsLuGSWFnZyfsaJGQdW9vL+xeFaOSUn9eW1sLO+BY\n", - "jr0cpMLGzXSoKZshcMJnc4p3qt7c3Axjwrt71JsdoxUUfepPBHzyxn+VGnuz2YzOH4bS8+Exwrgy\n", - "68nmF3a+N1scIzZ/KSdjr5l09epVe+edd8xskVXAPOH+Qx+mKOcLFy4EbSq0SUkxKMVldixWJnKl\n", - "3g4wja9OqSo8n/GlL33JzDQjxayGP9myeaCOaVZsiBojrr+X54iFkvt5xyaMuiAHXx4HqqRO6lxn\n", - "mMvrzBVAnTk1VT/VDs4WACgWjU33XIZ/R3me8N9ywtDrzLSxtqj/Py0Ue8NZCpjd9uydMgGaLTJv\n", - "OSbLmNxHjkRAXZv4t9i1ZovrCcutmMWlYPy7WSc9opB691Q7zKoscExSpA6FkSooKCgoKCgoWBHn\n", - "xkjt7u7a+vp6ELDEbn1vb68215lZPDwy10HN+xHF/CxwHeeyQ74vsDOxe1M7WbBu+/v7wSH31q1b\n", - "Zmb285//PFn3OoFBxSIwO6b8oHx/9fv9hVx3Zscndd+/k8kknCaYRUGfsA+N+g1tZ5FO376YYJvy\n", - "5/AnHnZeV06D/Azl7wOgng8fPqz4linmSoEZVp4zKOf69etmZvbRRx9VnNfVHLt//36FseI5ocQy\n", - "mWlCezngQTmlp0LsFZidUczRD37wAzMz+/rXv25mZj/72c8q13S73cr7MxqNwnrBDtcKdX4o6tTp\n", - "xz0W5u2fEXNoX5YBUQEIqUAJRur0zlkKuF+Uj5//mwpbV+2N+TmlWABmSdW77MtQPlx17IgqL4Uc\n", - "JisG5Wc3n1dlPFqtVjL4Q9WH+ygFJW6K37ledWXl+iUpBpGZ7hz5k1arVbE4nMbHuI7dU1IRKjDD\n", - "B4ukcG4bqdFoZKPRKHQgR4thI4WouPX19aC15NOkMHhjhkXx448/Dh2S+jhsbW1Vym61WhXdKu78\n", - "ug5OKRZz2hXoDN24ccPMzL75zW/aG2+8YWaLuk/4mKMuvGGCWaLZbIbfmUrml1lF3rEZzezYhImX\n", - "gE0ePpmq0sZhB2XVZvTL+vp6cELmRLxedZ77kRdS3w5l7ltbW1sw1Xhw2di0qHHjvvKO4DEK3Ues\n", - "PXjwoEJh80uPDRU7pacWvEePHlVMsryQsqlIfQS9bhZ/CNh8BKh3IPWhZNV+BvoX7/Tt27eDyRPg\n", - "SE02v+JdiZk8vXmM1d9V0mUeD5WIVUVNcmCH2XHfq8ONMiX68pSek1l1bBTqPjbKVIg6m+mIYR/t\n", - "qFTbfV3xDLSNMwnkbCbZbFW3AfZ1UTpNCjFT65NGTC3eb2h8hB6gHKPr4DePvC6mgk1iJsU6kyOQ\n", - "+h6ehYJ4jDwB6qIUVVR26pCYm+nErJj2CgoKCgoKCgpWxrkqm5udmHRYNwdMFDShjo6OKnpJsTxt\n", - "+B1sxqVLlypO3/v7+xXZAGZRWBWZmSPUM5VoF4gpKgMqcTCSJV+9etU2NzcXnvvZZ59VQuH5tM1O\n", - "0MqxXGky+fry8+7evVtxvuW/oy87nU6oA5+AcxKxcv+gDHYyTCnbqv5VJzZWz08pXJvpXHsA1x0O\n", - "3urEl2KuFObzeZjvYGhu3boV+pzr58djPp9XAhS4n8GI8VzjfmZneZTn+5yZP1azT52OMfaTyST8\n", - "G9jY2Ajvz4cffmhmxzIOvg+YaQBTzExdjIVQ5kAFr8IcO3krEwz6jdcB5bTq5zuPDQcY+IwLSrE+\n", - "BsU6+fWu0WiE68CSKckSBXUqVyzVbDarzKdGo6rWbVZlmhTzx/cqVoHLSEkncHln7Vyu4J/RarXC\n", - "O5AK/lBlMAu1St1zzYf8PPXt8Ca72Wy2YL739VNsMLtXKHZMmXa9XEFMW8oz8CrIISb34Zltrt8y\n", - "iZkLI1VQUFBQUFBQsCLOlZFiBzo+0eNUiv+anZzGVS4zZpqUo7q33c9ms1AedrZKamE4HIbTHU6f\n", - "+/v7SXVoXN/tdlcWBf3444+DX8i1a9dCW8EssL+L8iNSdnAwegcHB1LETTndw2/p3XffNbNjhgPs\n", - "CrMjGENm9/zpcG1trXJCV9nBue7qFMGsiEdMlZYFRT2Ug2/MmTb222w2k1IXcIhOyWCotrz//vvh\n", - "38w4geHCbyx1ofyS+GSlQvaV879qYw5LxeCx8n2p3oV79+4F9ozh5Q8ODg5CXb0YL+Dro4ISer1e\n", - "ZSxYSZ2vZ3babHFuKP+xlN+Skl04OjqqzMtYGf4d6HQ68lqlMI3fVP8rnxz1XA7pV2WknMgVW8Tt\n", - "UQKKgPK54mehnFR5dbIPddcqKNkFzwJx/dR1XJa6rs5xX9XJX8csP89txRamrADMKqmclvgGwvcu\n", - "97sXy42XWnMVM8V/8+3gfuFn+fWJZWGWYQHPbSM1GAzs4sWLYXHBJiFGo3kTRqPRCIup0kBicIoG\n", - "s+NFE52ZEyHI18XUWLHo42O3traWdDbHpOt2u0H9mTdIqB/6h5PbotxlFJ3xUefNEBAz1XhNLn4x\n", - "eDJiU8V96RcF3jTxBMWGkcdObTyUA7Wig9UCpZR2AU79gTmGMWQonSvuM7SDTSbeDNrv98MiA9Pt\n", - "48ePQ9uV0jxDzW82o5ktOhCjnIsXL1ZMyWoBipmjlS6ZT8Xi/43/9w7Nk8nEdnZ2zOykrzqdjtRQ\n", - "w1jz9RjDmzdvmlm1T9AfqUWcNzQ8DgDGjU0T3F8pyh9zR0XE8geD3x+OCMV1ftHnezGf2cTCdfem\n", - "Mx632GY5Bt4g5SQv9m1Tz/L1q0tDoxyueXPnf4tpEOVE8p3G/Kc+1rHAG7XB9L/xhpA3PkCz2Uyu\n", - "lTzXvJl0Op0uHY0LqHmvkpujjmaLpnRldlvWhKn0oXjzWmfmxb1qbJZVUjcrpr2CgoKCgoKCgpVx\n", - "boyUdxpN5d3Z3t5eMPPhPq+AzWDnSpXfLKX0C4ZrMBiEcnDyZZ0j3s2qRIwpp3Rc1+/3w6kYv925\n", - "cyewCakQTHbcZaA85QzrnX99fXgc0G9gW5TekJlVTGfT6bTizM8ndA5nR72UxAJDMSA59H3sROjB\n", - "c4hPap49uXbtmr333nsLz9ve3l5gEwCYRu/evWtmWsbBbNE0bbY4rnziVDm0/Nzu9/sVljXWnz5Z\n", - "MiuHp+5nZ2PV5xhzPn2m8tc1m82FoATci/mGfmS2L3ZyVWuBv5brr0z6yhlWJUYGmIlI6eYMBoMw\n", - "rri+2+0GXTpmC/yJmllj7w4Ra6ti21ImLmaf+PqUXhaXsSzDoxzG66DMVp7NyNWbWua5Hqq9dTIO\n", - "6rsBKHMkm6jm83nl/VTmz1z3gVarVWGuWKFfmcGUKVsB13GCb2bx6+ZtCjkO4Mr1IMY++XawidWP\n", - "WwqFkSooKCgoKCgoWBHn6mxel1sOJyDPRsWgQuebzWZgO8A07e/vy9MV/o7/NhqNCus1m80qPgPs\n", - "fIe/KXkDBvyibty4EXbt8ElSqs2tViuwIxAdffrpp0PfwO/p6tWr4YT75ptvJusAdLvdyg6fHZSV\n", - "Izif/HEK4jBf9jMxW2THwJiwbwwLBXo/Dvbd4ZNLjs/GfD4Pf1d59RheQFHlFOOTJq7nUyD3EXIV\n", - "gpFiWQiM1/r6eqgPO1B7/yrcz1A+Tfv7+wvipijPO5Rzv/C4qT71zsusjs/X+dNdzCco5Zeo5Ah4\n", - "7sAHCazghQsXwnxHu8wWA0uUcCvAYr2KjckRElSn6U6nU5mzSrV/NBplh1mnciMqMBOlnpHD2pid\n", - "yNBgTeO2ASocnZ31UznjlI9mzN9R3euZnpiUhcdp5QUUvDyDYqZUAARD+S+y9ANw4cKF0Gb1vUk9\n", - "IxZko5imXJV9z5gxO6sCH9QzUvNTBTTExi3lNA8o64Zycs/xmTq3jdTOzo50zO10OtJUhH9j0WfT\n", - "Hho+GAzCxw0bjL29vfBhwYf08ePHoXOwyWKnZEyAmFYVgOdynVn1OLVRxGboypUr9uqrr5rZyQeX\n", - "2466X79+PXww8NIgzQ634+joaEHHw+P+/fuVDcPR0VGoN5v41MYjlZhYJavkxdybGnhiozx28GWT\n", - "Av7N6WhSiy9HEKI/MHdiH3Jf3sWLF8NmBPciUbXZyRip1Dl4tod3tOSNlNLaAVhDCWDHbdY28s7y\n", - "R0dHydQQ6KuDg4NkGp1UpB6Xw2YrH8nDDvfAcDisqMBzFB2vE/4djY0lf9B8fVX0XKxN7Nhttphu\n", - "RV2HjwR/LFKbNbPqmKh5HHPmBVKbMWVOiSU8VvPYf6RZKR+IbaSU07yqn4rG8nWJjZHacCmoflZ1\n", - "zkHMLJja6KU2d8pEyc9QG0vlatFsNivPq1N/r9u8xNrm4TdIFy5cCO8nJy32c1VlpOA6xP7fA2sN\n", - "uw+k1rPYprHoSBUUFBQUFBQUfI44N0ZqY2PDer1eOIHi1NbpdCqaTEdHRwtJbc2Od6dgOPg07p2v\n", - "O51OYBU4nB8MDkLO8Ryz/Bw7OEW32+0KixJzOgVNjrbdvXs3MDRge9rtdmBAcCJ99913Q9tYTwi/\n", - "QSeKd8+sucWh9YrxUyHu6vTof4vlP0KbmP3y1K8yJcUSKadMToo5Q502NjZCXZSjPfpyNBotqH6b\n", - "Lc4XjA2zgPw8JeMA9orZCt9XPE/w/EuXLlXM2Upu4uDgILA1t2/fDs9nZhNA/2Hs2eE6dRrvdrvh\n", - "HmZxFdvKrI3Zcd/7EyG3F3N2b28vOwcdM1ZmVUYqZXLkcVAO1J71nEwmFVaa+43LS60ZdRpTyqSI\n", - "eYn+4rxgSu6D32WsS5x/MfVMJbGQOo2nHI1RL64n38OOwMoU5x2g+TrFLnICYGZvchgmxXrlIqbX\n", - "5FXAuc7KvJly9Oe/8/2Asgqw60lOG1BHM61YP5/Pw/vAeRi9Iza3E21nkzvDz6nZbCbzUuaODdZD\n", - "1s9TARmqPKVPqAKv6lAYqYKCgoKCgoKCFXFujNSDBw8WbOgcuorTPxgEKGt7eCfn1DUe2L3ihMtl\n", - "sMhhSkAP+cGazWZgxyBbEPPdgFL5s88+a2bHKtY4WWBnvbW1FU6T8E9gBkC1CSdX9rlhKEVm5XDI\n", - "pxwfGu4dewHvH8InG2Yk0JaUPxwrkTOU4CWH2fvfgIODg4W8Zh6eSeQyRqNRYE1YxBT3cLt9DjW+\n", - "h9k+tE35kAE4nfl6si+T2THLiPnG/aJOpJ6RYn8YxTyyfIgfD35H1akYfbGzsyPZMW4T4BkuZjCZ\n", - "OcM6EXO4Vn5EynHfn6jZj4Tr5fMb8jvDJ1vUVfmlsL+eElD049XtdsP7rE7qKIPbyu+Z9+tSId38\n", - "TMUCLStKqHxpOMReOfMqR+zUdYppUs7BuVIMuU7puVB+Ysw0KT8xVc+YunzKGlDH3qigCcDPF4+U\n", - "ry8/37OYsfr561jkmOd7SqqD/6bqV+fEH/tt2WCmcG3tFU8Io9HINjc3K8lDOaEwDywaBSftvb29\n", - "sGHIjWIBeEJiwWq32+FjjQ0Sm+xYhfnGjRsLz93d3a0szLFNBzZSTL+jHcpUxKbC1MuOwY5FJLIG\n", - "UUqzi/Hcc8+Zmdlbb71lZpqqnU6nYROJPuIUHBy9501n/DFHnZSWkdIC43u47z8SOMUAACAASURB\n", - "VNFONo2gfvxRZ7OS2bEjvDczj0ajUB5/UDn5qNliJApMt1wOm2dwj9LmAo6OjirO19xO4PLly2Ej\n", - "xe9AjuMmX8MbYP/x6vV6lc2eMtNye/0YxK7jzQTmBkcX4l354IMPKm2IHZD4I26mTR1qY8EbxtQi\n", - "zdS/MjMrcCSiMgv6DwuXxRt0/M5mMu/Mb1aNcuboOYb/uCozEuuw8XV1JjNcl3JeVubb1OZKbSbU\n", - "YTwXp9k8qU2T2WLCZv935UReVwc+7PhNV2xT7+sQM/fhMKS+typtVCpogr8rPHf8u97v90OZnNge\n", - "9/C74jf4ygTc6/WWTsFWZ07FM3wS7hSKaa+goKCgoKCgYEXUMlJ/9Ed/ZP/4j/9oV69etf/5n/8x\n", - "s2MTzf/7f//P3n33Xbt9+7b93d/9XQjD/vM//3P767/+a2u1WvYXf/EX9tu//duy3MuXL1u73baP\n", - "PvrIzE52191uN7AFOG3fuHHDnnnmGTM72RW/+uqrUtUbjIB3TmeoXeijR4/CPTgJX7p0Kex2wWps\n", - "b28HtuCdd94xs8WQ+DpAPwr3fvLJJ4Ht4PBNsACo/+bmZuUEoXKy8SmZTUSsRK2oVVUW9KyYbgWT\n", - "gjpMJpPKaZzNaSr/Ho8157Az02aVyWRSYR2Z3VEULMbo8PDQnnrqKTMze/nll8PffXn8XDZLsixD\n", - "DL1eLzyb+9HPMz5Bct/6Ofrpp58uMFtmmkn85JNPsh0jUwmKuY24zrNuOfAyEzGmGO+S0r7hezAO\n", - "KTOimWYxlCmb2U/fLk4ArQIuWIEf7E9KY4qZK5UrTumDpcLL1fWxpMV1Ughm2nE7Jt2RE4auTIXM\n", - "oiizIbMLfoxiZjxfh/l8Ls2WnuE6renOj03K7MR/X8bxHfAyIur5ZsfvGd41fLsU+8R9BLRarco8\n", - "ZvMcr4E+V6ma29zn/HyU4zNExNqMe9mhPdV/LIPDzJFKtO7/nTsnzkT+4A//8A/t+9///sJv3/3u\n", - "d+23fuu37PXXX7dvf/vb9t3vftfMzF555RX727/9W3vllVfs+9//vv3xH/9xdgRBQUFBQUFBQcEv\n", - "GmoZqd/8zd8M7AnwD//wD/bDH/7QzMz+4A/+wL71rW/Zd7/7Xfv7v/97+/3f/33rdDp2+/Zte+GF\n", - "F+w//uM/7Nd//dcr5Y5GI9vd3a3YVQeDQUXU7u7du+E0yv4aXrGchQf5lJ9ytGPgefDJuHPnTmAG\n", - "IIy5sbER6oJTgLLnKly9ejXUBaeB+Xwe2BOwN8oB+fDwMPjLKGdkhVj+OC/YWeeQr3bz7HOldvaQ\n", - "W2CVdu/PweyDCulGn45Go8oYst+U8glDH7bb7Qqb9MILL9gbb7xhZmm16Ha7XQk5Z7AflvL78Q7o\n", - "4/G44pvF5bJfFPzR4I939+7d0AdeHd3sWOXe7FjNXjFCqBfGRfX94eFhYBzZ586DfX34tIh74GPI\n", - "8hEMlTMQYDbl3r17ZnbCMo9GowVRXV9/LpPZpZSPFDNvKoeev5d9ppR6Opfh71USFoeHh5JV5ICM\n", - "WP1YxoGRygWo+oolFJZ1MlfgNUL5Pvl3Oebn5IMhFIsWE4xM+Vydpk2qv5VopmKkYg75/hnqfVB+\n", - "OqPRKLzHqg4ppffZbLYgOWR2vF759Y7FV5VkBs8hJYngg4SazaYsL+XnzOUqWQPFQgMsR6Gc/lPZ\n", - "GJbBSs7m9+7dC+ava9euhQXvzp07C5ump59+2j788ENZRqfTsbW1tbCwo/KPHz+uOODu7OyEdBus\n", - "CYPJheebVZ1Dr169Ghb9mK5FDLPZLJSHj1y/37e3337bzBZNEzkv6ZUrV+zf//3fzcyi/ZKDOsV1\n", - "BX5xlWaTv46db9HnzzzzTEjNAShNjn6/L9PcYFz5Q8+bJUCZWPzkZmdn/ohh04Rxu3Xrlv3kJz9Z\n", - "uPeNN94I9/OL6TcgrVarEhm4vr5e2QiqFBcM7iNsoFAu38cRpCgbCxH3Ad4ZHj9+B3CvivhS85QV\n", - "57Fx4mAI/+Fj53qUx9pS2GCqOcB9gE0lb4rUh5zfW//hiJmdUs7fMedrzCMVDcrX4Bk811KbFwVO\n", - "H6NMov7jwPOfN+be7OLrEGujUidXyX79v1PwH0h1KEq9J6gD15PB9yoHeV7jUmZNX99loDZ6nHWD\n", - "9aP8ddy3PjE2bzD4v2z2zY065ChRf52qA78reHextrBjvNLGUuZZ7nvvfqPM4CqVlNrQsEkRaxt/\n", - "Q3zgGpdXp6WmflvGLHxqZ/NYqKmvTEFBQUFBQUHB/zWsxEhdu3bNPvroI7t+/brdvXs3sEVPPfWU\n", - "vf/+++G6Dz74IDj6euzt7dlsNgt59HAqvnjxYtgh8+kEDt18evUOdIPBYCH/Ga5ZloligH1A6Pxk\n", - "Mklq46TwwQcfSKfuzwOK/mSTqN/wKrZqZ2cnMFIsz4BTBxwK+XSszK6cl9A7S5pVZQMYOIk8evRI\n", - "nhjApHhtLrMTk9ODBw8qprhms1kxV7GcgqKUGalcYiiDQ9i5XG8W4lORcsjmv/uk0Ep5mxkONgcC\n", - "aBtrkOFU1+12K3NBsT08r1hhWAH1T5mRYhQ7J5SuK0OVaaa1h5rNZphbPBc9S6lO2zzmKvCB56nX\n", - "8+K28G/eVYATi3OQBSvVA54tZLajTuk5l6VR7E6uE693LGfNrZS6N7MeXIYyv5/mAK/uVW3yfToe\n", - "j6V5SbE3uX3PfZrj9G9WNXHFnqH62q+5sTx4ytXCs6LMrCsotqjORQa/8/qk7kkFgqRkKBQzaGb2\n", - "p3/6p9F2mK3ISP3u7/6ufe973zMzs+9973v2e7/3e+H3v/mbv7HRaGRvv/22/e///q/92q/9mixj\n", - "fX09JBlWGkYFBQUFBQUFBeeNuo1U7Q7m93//9+2HP/yh3b9/327dumV/9md/Zn/yJ39i3/nOd+yv\n", - "/uqvgvyBmdlXv/pV+853vmNf/epXrd1u21/+5V9GTwZwRPX211arFSQCwCSx/wcj5QgKQF5hVXg/\n", - "rGXFPxlnZeZEnW7evFmRDWD7MDul885b7daVr4X3sbl9+7b97Gc/W/jt4sWL4WTODt54Huql/Bba\n", - "7XZlzGICa5gTSvKC2+FPacwAQqiw2WxWnsvOiBwC7H2ZuG5gg1IOxnUYj8eB9YDvE7NQas5w3VEf\n", - "78TO/1Y5tBgYy6tXr1YYqc3NzaTgHasiY76kcv2xbw4LtLLvo9lxu1OSF+iXulMvs0WpEyv7QwJc\n", - "h7rcc6gPM43e16/RaFTYApa1UI7R/F7607MKM1eIzclVna9j/jqKGVC+TLgX/aMcrlU9lW+R8tfx\n", - "f4+VG4PyJ0r5V+FZdd+Gs5Ji4PI4UMBs0c+tjqnB+oW/j8fjbNbLzym2OCi/V36ulzpotVoyswa3\n", - "M1aXWJ+roITU2sxiwquMT2N+VqO6zEO/oH5TfrFsNBqVD1S73Q5RRCk9J4ULFy5UIg3b7XYoBx9Q\n", - "Nr+wA6z/cKtNhUcq2oTNW8okgd/4hfMTnZ2MleMkq+z6xV6Zb3Z2dkJ/MM3MZjm+n59rduIsiedy\n", - "H9VFb/p0IGZV046qM3/M8dzJZBJMnZgfSjOKNznYiEyn0zAOUPK/f/++1ENS8Alv+Td2IgUwzpcu\n", - "XaocWra2tirmQF7A8X6Mx+NgVlXRengGpwVSzuvA5ubmwsbcTGtDsXmLP3hq8VXjrz7wdQlUc6OA\n", - "PWJRQrkfL4DXKb9mtdvtvJQW7XYlYppNbCkoJ+fBYFD5cMci3LyOFEc9MlS/qE2kipSLlbEqznoT\n", - "lHoG/79qk9p4p+Ykl8MHQ29mjpkPfRYDtdlQm+tOpxPWHV5DfF9y1gt+1/2GazabBZcSXsdUm3l9\n", - "MFvcJPI3KZVSiq9HBGps/IuyeUFBQUFBQUHBivg/5ZzUaDQqYe2NRqOSmDa2q1RqqOwobHZsTgNL\n", - "USdh4JXIP/vss2CuhHzExsZGRR/o2WefrdSl2+2Gnfcqzu7YybMukEriit06nxKY1cHfUee9vb3K\n", - "SUqZDJkdAYuhNIp2d3cruk+9Xq+SPyzG7oBNYAVdXy82EfHpBEwUn4o8dazmTozR8/fyKcs7sZvV\n", - "q/B7h/YY+6CYqpQDf0rF/OjoqKIszn3Azu6YY5gvSl+LT7c85zwjxTnoFLPB5hQ234EtVgEm6uSq\n", - "xpPzfSnTkNLQAXjdSelI8TxgrRuz4/H1c0GNNScFBiaTidQ088wVm1jrFNCV7pNHLJQ8ZapjpiGH\n", - "RavDk2SNPg/DjTIpAjH2U5nvUmZI7ueUUzqXkTIbq3uB6XQqg1v8tWqNUfUzq34z+N3n9QJzWpn+\n", - "UtIniuHKYZ4LI1VQUFBQUFBQsCLOzUeqTrAuBvidbG9vV4THptNp8KtQjESqvNg9eAb8P2azWXbZ\n", - "169fN7OTXXbufYw6fwwvRtbr9UKbBoOBvfbaawvtmE6n0t/I+4UwIwV0u91KaDXXgU9UHE7q6//c\n", - "c8+Zmdlbb70VfmPbd0ptXOVsAm7cuFFh6zikX0HZy9kvyjN5uWJ/7IAMPwFWDlb3qveB+8U/t9fr\n", - "LTiKpsqF/xf6lFWn8dx+vy9Pclx/tA1ADsz33nsvzHeMEeYeo91uVxyplYMp+xNxPVN5/JRTsHKC\n", - "Vj40sbntwSH4QK4EgwqtjrGKilXyYP/Es4DqlzqlZz+W/JvyuVH3fh6IBR2kruV5t4rT+pMC93ku\n", - "k+d9B5m1AWJ9pAItUA4zqzl+U2bVbw2/A6mgDl57lfN6XV/k+pj668FSpfYs52baW3VC4gOauylp\n", - "Npth44ABnEwmQfvq+eefNzOzH//4x/J+DA42aDk0JwATFhyGL126ZG+++WayrmbH5glMKJgoOGkx\n", - "Pjy7u7sVNebDw0OZYobVk/3i2+12F8wZ/Az+zSzPoZM3YWrRUs7I+EDu7++HuiKKjZ35+WXxzuF1\n", - "Mhrcf74vOWEvq2f7vppOp9mK4R6xj5LSMsF12MCtr6+HuuC64XAodat8nThKEX22sbER2gtT3HQ6\n", - "lRsUjA0nOfV6LmYn48CHE4/JZBLmLN/L6uoAxpP1x/xGyfdpKmIJUA7oSll/Pp9XHF4nk0klWTaD\n", - "x9LPMd5cc1CCOmxgnUHfs7MsK6rj32wuy9Hp8nX1/aL6jz9yft6x3pAqr25z6q9b9aCdQu47quqS\n", - "Y955Ek7uKbCrgO/7GHxksvobg6OZ1caSv4d+XVQBLewuwa4vdfpraKNPcXV4eJhMDePN5lw/3048\n", - "IydoovK82isKCgoKCgoKCgokvtDO5ss6D7ZarXCCw8m70+mEHSgnikXZYEdiWlUAl5sjd3Dx4sWF\n", - "ky3qkqLsORwc9cJvjx49qjy33++H3TjKa7fbC5oYHuvr6zL/kT9d871cf5wEYOpUfaEcmlutVqgX\n", - "sw43b940M80w4sTCz+DTAfpGhdjiWWzWY1MSM1Fmi6d3jPVkMqmcSljtPJdSVrnb1OmenW89xZ0y\n", - "T3L9+PTsqWyzE9ao0+kEUxwSOO/s7NjHH3+8UK7SkWK1czbpYF6BRe10OlKtXTEWOM1ibjCzwm1U\n", - "5k2ebyk2hNcT37/MbPF4plidFDtqVjVZNhqNBadWs8UTv7/WTJswuVyvYbS1tZVUlldO5HiX2UFf\n", - "saMxZ2QzvV74f3uklObPmtFRrGWd03yK1VSoq7NiNk7bzlT4Pj/Da5rFTGf+/VHrEwc5qOCalOM4\n", - "vwMcBKbqo95bfAuYOfTuLY1GY8GFwdeTofID+sCrHNN9YaQKCgoKCgoKClbEF4aRAqvQ6/XCDlD5\n", - "+gCNRiP4ObFtFqcx7Eh3d3cl+6MkBGB/xY50d3c3yBR8+ctfNjOzV199Nas9zWZTOtt6cTOFOnaM\n", - "nZix00YfIPzbTJ9mO51O5XSihA7NqpIJR0dH4bdlcwayDAXXBQ7vvOuHT5kaf/jfPH78uNJ2FV6+\n", - "trYWylH+N8rRGfPgk08+kT4tAOafZ3E8WH0+xXDxyc+L7rEwnprPfLLyJ0jO0wZw/j0g5k/EdUWd\n", - "wNqxer7365pOp1G/Cy5vMplkOU3zyRp9NhwOF/wfUixhysF7NptVpFNGo1FgmtCOo6MjOQ6ov2K9\n", - "+PSe6xzsMxYwM8QirZ59UOHmZlWRVu4DZoNRZxUIwGPp51OMVUhhWUFThVgwwVk4uS/LFsV8pHL8\n", - "9lbBYDAIfY6xjPn4qDVDzXcPlXVAlcXMqlpTWZYEdcW3ZDgcVmSGmJEGw9VoNML8VWOdUpZnx3wl\n", - "K4H3jefxMv7Q5xa11263bTAYVDSDzE46hF9wLB5w4DY7WbzQufv7+6eapHB4/frXv25mxxFJMH/8\n", - "8z//s5mZvfTSS+H6F198MdQJCxU6/9NPP7VXXnll5boAoN03NzfDBwobAlY2RgoV/ghPJpNwLb/k\n", - "3ok7pkrrk/hGVV2d46nSkWJdIF5w0W+YB48fPw6bpfv371fqzKYfvIjsBI2XBf22u7ubdOZmWjhF\n", - "TTNSlC8vYvg3bwxZRRhlpT5AeNZsNqvQ0LF7lzU5YlPU7/cr75TZyRhydB8OLIjA5END6vl1UWBs\n", - "7lGbVx+1xx9S/oioduZuYpTmWh1SSVL5N6xf+O3g4GBhjFFfr3bPTu5cfkrVGX/b3t4ObclRco6B\n", - "zZJeCypmojxL1AW9pJyCY3VTiWxz63JeEXyq7YBKmdRqtSruBas4xvM8SWmo8W9+reR5okz7GI/D\n", - "w8Pkd4Xh03jxe1G3GUrVj9dytDn6DUw+paCgoKCgoKCgIIovTK493n3i1Imd5vr6etglgrpWpomz\n", - "xo0bN8JJLkaZmx3XF9QlGJY7d+6cSYJj7NRHo1HoD/w2n88rJhG/a/enl+vXr4dEznxy9Tvzfr8v\n", - "ncaBVP4zrgOHtasccDiho5zZbFbpN9zn7/Uh83waY5NcKjyW66o0ilAO/qZCZxUzwGYopqtztIrY\n", - "7MKMnlIJRzmqjao9KdXrtbW1LBaG63fr1i0zM3v//ffltcrxNeXozfAhzEq1m5lTPikr5XA2FXhn\n", - "+bp8k8BkMlnIiRi7Xul01SGlGcd9pJy0+V7PIHIdWc4B18WCIPxviklgc2lK+XxZxNinlMO2+ltK\n", - "C0ppgqm2qfacByPlTXa9Xi+827msK78fnvVkORVmeTFPOHDEJ5weDofBDI53ixPQ1wUd+LWK52ed\n", - "Rp6qH4Bvx2QyqVhYcmUt8JzCSBUUFBQUFBQUPAGcGyN1XvblgoKCgoKCgoJl8IVUNvc07LJ0W7vd\n", - "rjjfcsQSaMbJZBJNQcHPZefglK6LmaYpQXGm0ptwObmOnUqWf5lNaIr2VvXy98WuO81GWKVlOQuo\n", - "iZ67aa9z+l4WbGZSqEsB4s3bKqqt3W6H61JRb7E0JLnw6vnKvLm+vh6c9GF+VXWKjUfKNMGmbPVe\n", - "qXc41Y75vJqY9LRIvRcwX3v9ttPi+vXroY8xJmpsFNbX18PcQdCJ6pOtra2kW0Pu+pJC7ntbF6jA\n", - "cyhljlwWp1kbVlmTYsEs/nunVNhjdVDX4XcO4ML7p4JNOOrNR/KyCZzXtGWd+FHOYDBIzruUGZy1\n", - "qs7q+1JX/2LaKygoKCgoKChYEV8YZ/O66/w9aieqQj9VeRziiFMZh06r0Oplk83y39WJIPdUvgoz\n", - "xc9bJl+Qf56vT+wk5euTywLdvn07nDo+/fTTrPp9EZAT+lvHSAHNZrPCTvFcQxADS1kwfK614XBY\n", - "qUu32w2aVx988EFWGxVY/0kxaXDsVHn4GP40i/DiGNjh38tHMFSf8/9z4MZZMFJKzVyBdZ88VmFe\n", - "IAUym83CnMAcarVaUdkOxvr6eni/lSYcytvc3AxMmlJ+r3P0VurUqesU6hK3+zqPx+OVmXOuS+q5\n", - "p2V5+Xlm9TICXK/cPmek9MGAtbW1cN0y0h8A5jnuVe9/LC+m7+N2u13RBxyPx9lK7h7NZlN+j1Pl\n", - "8fjXJS0ujFRBQUFBQUFBwYr4wiib827RszCxE6vfuSs2am1trZKPinehamee60uRYmBUZnguz6s7\n", - "M/hEykJhQJ293p+olgEratfl6vLPi/1/DB988EFgXOpOnbmnUnWfv2cZsVGP2Ik1Z36q32azWTi5\n", - "Qc5hNBqF35D/7Kmnngrzl096rHwda+9oNApM1Le//W0zM/vBD36QrKdqbx0rin+rsHoOsfblsb+j\n", - "kofw4o/LgMtJ5YzjcHCGV3BnVjBX3gRlKF8bFoKtg8+KwHVBm/r9fhYjNZ/Pk2KFHP4OLOsnlFoj\n", - "YmDfJjXuqXUA7el2u6H+nDUAf08J6qq5gTLN9DckR4gyhhiz6sFSAgpsbfGK5QcHBwt+xGaaUePy\n", - "wS43m83wHnOfq/4H46pUwlVd1W885rhXSbyw3ySuA0PcaDTCu6HmEPszq3FS610dzt20pz72p6Hd\n", - "U6rEnrLj35TejEKn06m8pKxRwlApInLQbDZDebyB4qS2dfcDPtVILurMC0CuGe+0kZq5OinLKhXX\n", - "baRytUxyTHucFJTrqT6u+DsWsXa7HeY26nJ4eCjNQmojw383O1YkR7Ji9Xf0d+wj79WEuX+wIex2\n", - "uyEFEHDlypWQkJuBD1VKZ0u9C/5jnWtO9QeabrcrddOuXLliZid9mXKAjQF9denSpZD+iR34/Tit\n", - "YjZCZoNGoxE236dZR9lknHJgf1LO5maLplg8y6/RdUFAQK7D+GnMjPyMXE2w3IPcKu4amGNbW1th\n", - "bvNmqS7gxSw+F9E+3rSpFGA5hxNex/i95rRxZscm6NxvCOYvJ2n2a5bZ4jc81saibF5QUFBQUFBQ\n", - "8ARx7qa9nHDWbrdb2TlynjneJaac5FKUXUw52DMcMWbCn+R597qswjn3Sa5SLecsVMmIl8VpmZzU\n", - "PeoZdacjr8wca5tnGlQS39x6zufz7D7M6Qees6xOjOfh1Kj6YDKZVMLn2SzEQRG4X+UMrOsD/B2n\n", - "wU6nI98pvENwYn/w4EHoK1aaB1OCYIKDgwMpB+ATUDcajQpDNJvNsh28c9rI7agzKXNd/LpT16do\n", - "G7+jrDDuwetdLmAi//jjj0Ofs3M7m1ZjaDablbbFrgerwMhZExQzNJ/PJSOpWGWVQQBzEH2mAlfU\n", - "ms8K9ylTHNcZOTwfPnxYMffxvak5wX9T7iFqvVrFSR/1+eyzz8I798wzz5jZMbvj14nDw8PKvIuZ\n", - "MH1AiWLH2Omf24H+8rlNcQ/qjncO/93a2lpIiJ6CMoP6tnW73coaOZ/PK245Od+NwkgVFBQUFBQU\n", - "FKyIc2ekUsAOMmajTZ0m1a4eu+NOp7OQ2y12HTu8qbKxc+XTky/XI8cJse6kwScDXJfKi7cKlD9C\n", - "rA655Xk2ie3vuSfw1HXqVDedTitMY90JQznJ1jnZ5/aHH/fDw8MFXwaUoXxx/L3K+dvspH0p59T3\n", - "33/fLl26ZGYW/JiYlUVI/M2bN0PZOA3yvIO/04ULF8Lf8dzRaFSRbNjf3w++Xvwu+Dp3Op2Kv+N8\n", - "Pg/zHCdsJQmxCgaDgWRflJSEd8TOZTofPHgQmCPcq97bXAa70WhUHIsPDw8Da8fICTxhxq+OkYIE\n", - "w2mQ8jE00/3g2zGbzQKzyeyseg89662EIxV6vV5gQPEs9mPluqV8M1NrBK+3SvYn6psj+kMB9eb6\n", - "g6XE+1Xnc8XvgP/exb4XXj5IMZJHR0eBGeL8qf663d3dcB3Whr29vUq/8bjim7O2tlZ55zh/Lffv\n", - "KpacL/RGKoXYxz3lpY+OrFuo6qLVfBSgQqfTqWhVDYfDiukp9jH2arKsfaUSip6lKjeQE7EYg1oA\n", - "vHnuNOUph2HWAuMIndQHr87JMHeDtKwjPZeL+mHzsr6+Lk0xqY1gzERktjhPOckodF+4DP+MO3fu\n", - "hLmIjddoNAobPVz38OHD0A5eDJWZ0psKm81muAcLPWvG8AcQz8MG6rR6Puij9fX14KQN9Pt9+WHM\n", - "CR5R9drb27Pnn3/ezE42r2rcYto2fo5x1BHfqzY/OZF8eE6sDkC73a481yzvHeD2Yh0Yj8eVOtcd\n", - "JvmAg01OXfQcR/D567g89fEHUgmtOZmv6j9+Xsp8x87karOpwJuJnG/BbDaTm3j1DF/X2HcvZ32d\n", - "zWbym4X5if8OBoOFZOX4r7+O3wH+L/6Oe/f29kLbsAk7ODgIdcbBoN/vB9Mw2plzCCmmvYKCgoKC\n", - "goKCFfELw0jlUpgA61KpHXpOOH2n05EaFinHaMUCpBxV+aTB9fS7/hgDp+QN/IlqFdSF6J6GoVGn\n", - "OqWenmKDuH4pU9wquQrZFHgWCtgKilkDRqNRUm5B/abahDnEYchKL4WR0ueB8/LVq1fDeIENYEf6\n", - "Oo0d9UwwXGCmdnd3K0rE7XY7qS1zGigWp9VqyVN7zjNj7IHX/YrNL5gAU3nwJpNJWG+4Tmru5EqU\n", - "5DBSUHpeBblrCLtu1JUD8NqrAotyctWp9/Hx48eVdX19fT2Y4u/evRuuBdvBavGKgfHPYOXt2HW+\n", - "zWxi98/ie/k7lnrnmS3iv+EeVkf3DvZ1ayWbjBXD41nqumASfn8w39m0y7p6ZsfzGe3gZ+E3jNej\n", - "R4/CGHpGLFmf2isKCgoKCgoKCgokvpCMFOe/AxT74EOIlVwB/4Yd9Xg8rjA5aqc+Ho/DPXBym81m\n", - "Fbao3W6Hv6tQcWWTV6wHi5ylwpRTDNFZsSjLsE/Lgk8TOKmwc3Uui6H+DSh/BPU3xiqSDqfFbDar\n", - "hOC2Wq1sVmFZvxTGnTt3zMzsxRdfNDOzl156KfyNmUJ/ov7444+lj4y/l+un/M6YwfIMAoem1zkF\n", - "r6LgD+BdPjw8DH5pzLZ5Vmw6nWb5oCgmtNFo2Icffmhmi4EFqfvr3mXv99ntdlf2l+Rca2Ddm81m\n", - "Zb1bRo0d4Hcr56Qfa0OqP3hN9/3a6XRCm8B2xPwKFWvo2zsajWQf+PU/VwiU678KlPo7MB6PpRUF\n", - "31n0lXpvFbM6nU6DPAqzQV7wejqdVt5rnp/sBwwGFnV4+PBhUiiU66mYOmCVb+EqeQa/kBup3JdU\n", - "6ZEAbN7yTnwxxVUAH7bRaBSegUX26Ogo/BsTcTAYBMViBaVbo/7mtTk8W6LZwAAAIABJREFUlDnA\n", - "f9BWfRmVMvdpy4iBtZRSDpR1UT258BvVmPlQOUb6D+mTMPWx6crsePxT5uM6s5Df+PCcwMaV1YTf\n", - "f/99MzO7du3awsYCz1Lvo5pn/nDS6/Vkegn/PvLHBovYpUuXKhGdKlIq1Q/LgAM81PuHv+W+X4PB\n", - "IDjOc7AJUGcuyFFQZ1V0fPw3NjaSZhHMscFgIJ/Bax+Xy2g2mxVNszqc5uO2bLStWh9Z0yilqXV0\n", - "dBQ+6gg+UOuF2UnAQ0p3LuZakFpvY+1NHV4A/t7VRUByIJNZWuGcwRs1RRKodwR9rYJnNjY2Kk7k\n", - "ue4XZnnfndygFO5jNZ9iKKa9goKCgoKCgoIV8YVkpICULgU7IzJrkGJUeOftT5iz2SzQlcrBlE95\n", - "fnedq2WTqzPSaDQWGDBcrxwUlclzFfbmLMxZuRIG3A52ykQZqzi3m9WbNZVJIddp/kma+zDf2Hzs\n", - "tcrMTuqNuZsbcMGmGMxjPqFhDHZ3dytOmpcvXw7sA96VOkdQ/H1rayuccnMlG4AHDx7Yzs7OQv1i\n", - "ARd1+jcpcF/myH3UheUDm5ubod8U85EqI1dHjseQfwMDlpI8UCZbdjZO5TxkKYHPA7nvXoolNauy\n", - "Mr1eb0GCAdeAiUpJFGxsbFQSGPM3SQUzsZk7tf6flmFFOfiezedz+U3zGop1lhq+z2dUWFtbqwS0\n", - "dLvdpHUJz42xr6lMGAy/ZrVarYrjPucq9d8cxqoWncJIFRQUFBQUFBSsiMb88/SsxUNXOEE+KUdg\n", - "nMAajUatarZ/fl2dcuuc8sNhvx5fHtvDY0g5DX7eUH4/KUFRdSJkm7xqm+8P5cwfE4XzyJVi8Pfg\n", - "Gav2uQqF3tjYqPilsEN2rBzURfW9+k2dpL0Plxo/9f6sra2FUyAEKBXbkho/My0potrJeRVz1wk+\n", - "zXrH2GazGXzK2AE5x4fzueees7feemvhN24n96Wf5zyuqm9wfbfbDeXcvHnTzE6U5s2OHXb5Pt9u\n", - "z7a2Wq0gP4FTe4w58fcuM9dPk/tyVX+YXCZRMcCqLs8//3z4O3wMc9mMVqtV6T81Ho1GIxlIU9fn\n", - "aAuLQ6eCmFL1NVsUCo2xw1w/rgO/W5yP1izfN6vT6SSDMJS1Cmg2m4Ghg7Vnd3dXzhPAW0RSc+gL\n", - "bdqrW2BzwJNImcGUzggGmhfMVMQUvwS8SKh7OCkrnuHrxZsmpS3C9fXPZTwpDaRVoSIlmQbGNV4r\n", - "yExvuFJKxkoPhxeCnKjNOtPiWWzu1cupNmEq2e9wOExuCNm0pxYr9RvK4cUT9VNq8Tx+fsNzdHRU\n", - "od1jm7ocPazYQrbsPOcsAf6/vlwsvvgA5Zq01HikIklRL3+duofNb1Cbxwbo9ddfD/2rnNy5bR6N\n", - "RiOYWVJz+rSHWfVsv7nKDQhhsLK1Xz85HQiPIfoIzz86Oqo4dfPGB337xhtvhE12av6pOZsbkbhM\n", - "P6v3h82+aDv+y1kg+Ln4PimTPG+A/GFiMBhU3g0eL1Uvrrs/APF3m1P6YA3EdUoTijXteOMFlwPc\n", - "02w2K++h0hbL2SAX015BQUFBQUFBwYr4QjNSqROcOrXP5/PKqa6ONuSTEP6tcpOlQmt5x6p2r7iu\n", - "1+sFpz9lIuT/T1GXSkFamb9ywmXPEnUMTY6jvTqNM4OkyuNxyDk9LOvEnlPOquXlmiuU/pJqr2KL\n", - "Njc3k6aaOkVoVRfPKo1Go4V5bnbMhLDjuZl2LJ3P55K58uA1IFa/3P7PZRNVvr8c1AWgKNOpYmK5\n", - "nt7MyKwCn8xRR7BUMXMO2gSogJbPCylzlWKpADbdK7kPBszMWN9Ho1EYh2vXrpnZokq5si5wX6qg\n", - "C2Z8lsFZ5UpVVhzWaeO/q75G+1ij0fcrMzno+4ODg/DeA5yMHHONsxNwwmPffu5nldwcf+f1jt/R\n", - "nO+Fmu+z2axielS5YT0KI1VQUFBQUFBQsCK+0IwUwAxNnd9Uzs6+3W6HXSY762KHzCdq70vDjqAc\n", - "Wunr12w2K+GgfILhE7g/idY5eKKenIVdMQmft4N5zKnVTPuMsVMo28iVOr0H90dqzFWI+Gl9PM46\n", - "8KHO/87suP/AcoBpUKzHdDoNzAXm297eXkVOg4ETunJeV5ISPEb+2WZW8Sviupgt+lrhPu+bpTCd\n", - "Tissitny83yZ0z/qCtauTvoBqBOs5FO0Z7mY8WPmyvv/8W+qXsqfi/1Ac/zEPg/kBnUoRkpZLWLt\n", - "YGd+/BffAWai/PxoNBph/HFvLGQ/Z61R34vTMlKKxVTfSuWQrSwrPHd8vzJrw32N9121HWvMbDar\n", - "zMtms1mRdOHAEa6Xn+e8DuE94jVLsU+8tvpnzOdVUdUcnNtGyr8UatC5E3KiRHhy8IKBDmbnOv/B\n", - "4PqkdF+Ojo4qE2UymVQGZDqdho+XpzJRB/6vagv3wWQyqURATCaTz1XPZRl4R0alKTKbzcICBZNn\n", - "rpaJ+pizeRbPXUYzytedzW5chlr0c5Jgxw4BqUUX7RgMBmERURsoLgPXqYSdCjB5qP6Ltc3ryMzn\n", - "8zCW2EQonTN+z5TJhg8nqi9zTWtnBe/wmgsVZcu6WsrEr6A+RtwvUOFG5Bgjlfg61wxuVg2QqdPc\n", - "WlZ5n8dfuS1wub7M7e3tYNasi0jFe6M2DqnI0Pl8Hn6HCXAwGNhHH30k24d7YuDvRV30W050sb9X\n", - "bUC8+bPdblfWz62trfB3fAObzWZ4/7GJPDg4SEYL17Xdg6OoeY3klGlcJ38voMyWHLHtfzvLg0Mx\n", - "7RUUFBQUFBQUrIhzY6S86YIZJ7WjBpilUrpKOD2hjMPDw6xd/Xw+t2eeeSbcY3asyeI1NObzeXCc\n", - "ZcVn71Q3m80qO+hOpxPKY10aRVf7XbPS6VHodDqhPHb+O2tzVK5jOaBOerPZrOIAGjv5e1ZkMBiE\n", - "PuSTRc4po05TJuWMrjR0uF4pzOdzeVL2813Vbzgc2lNPPWVmFhLfMnvHemOoC/cFJwM2WzTx4USv\n", - "wsbn83kYI5Sxt7dXCQdXDp5KEVqZshX4bym2b5mksKsA72tu9gKA8+Bhvbhy5Yq9+eabC9epNl26\n", - "dCloQDGUOjXMuJ9++mnlb2xmWiaUm8FmF5WgVsGvmWaL7hLKnAKk5oSqO9eF64m6grHjwIdYOWbH\n", - "7CzeB24jykbbtre3g2bXKvMvlaUiFzFTZ530Bt9vdlL/3d3diqtIo9EI/Yb/bmxshHmHOc6mOLge\n", - "bG1thfdGzWcGxgvveixzCcDWHqXCryxEKYCR5Hvx28WLF5P3mhVGqqCgoKCgoKBgZZyrj5TZIuNi\n", - "pjNLq5N1DMqOmlLNhmPswcGBvffee2ZmgZmK3YtQcs4SnqPSyiclgMPaeUftWbSY06KvH1+nxMpy\n", - "FX7rsIq/kRpP5LWK3WOm/aa2trakg62/N9ZeX5fc7ODsC6RkMlLCmMw0Msvi/fqYWeUTHxgJnPiO\n", - "jo4kW+N/4z5IhfJygAQD8x257/jUziyA93fr9/sVFiX39K4cX/m5fN3ly5ezylwFq74r3I+of13b\n", - "wTju7OwEJfgUmJVlxu80wo4KLBeQU6aaQ2ptYxbCB+YoqGdyQBCXj9/U+pKCWjPNTtr+zjvvmNmx\n", - "r5R/b9l/kqHWd7+GxBg+nxPW/035KqaeC7DPLdclxSoDe3t78nvtrSgfffRRxT+Z6wKmu91uhzUm\n", - "1y+Slf+9LxU7jPO6jH9zoBezrKgLgICCWGAB41xTxOTSmXWRejzZVDqQXHizx/Xr15MOhVeuXDGz\n", - "4/QX6jkYOJTLLykPmP+4NhqNyoaQ1Wn5Pv8yc3kq2nGZjVRdBE3sbzH4MVEaILljePXq1bBIphSy\n", - "Y9oz3jynovti7ctpu3JUV5u1tbW10AdqwVB9wJFtyvSY+hjh3l/5lV+xl156qXJv6v3i+vl3ZX19\n", - "veKAyjpHKPfKlSsLaUw8UhGJZicHH9TFBxPg7yln2DrUBQ7kbpo91MaS8c1vftPMzO7fvx8+2IA6\n", - "TFy4cCGYHbzJsA69Xm+ldCEevIHDPFFmfD4Y4APqN8WMTqezoDMEpBLLcySZ1yVTddra2kp+JOs2\n", - "SOp6v1blvlO8NvD8SyVOVg7UMaTmLMaj1WplbRrUOqbafunSpTBecEfgdZG1pVhZ3iw/g4ACK9Gr\n", - "fuENlw+GURv+Vqtlw+Ew+e0spr2CgoKCgoKCghXxhU5arPLesLoz/r7syWptba3ikMvl4fSiukYx\n", - "CE8//bTdu3dv4TeVLLfdbof659a57nSc6/S9iqZULuuUYoFUGUpNnmUSlPOgP4nGZBLUCc7XQZ1Y\n", - "FAuVe8KMmVOQB40dgVMUN6CYy9j4exMBa6OkTnXb29uB/fnggw8qf3/66afN7Jie91pfMdVxOFXD\n", - "sVSN0cbGRmg72qmYmu3t7UD3q/kCMFswn8+D+RH3MpYNJWecdbCGwvPPP29mZm+99VblOSpp9ebm\n", - "Zsg9xjpICp4BqWNjcpHLSKlciz4kn7G+vh7mBM83rAO4Rz2LGRNcv7a2FhhsOEpPp1P72te+ZmYn\n", - "DOj7778fXAaYxU+9U/yOrjpPclhwz5ooqQCWEgC4fzmXXp30Qk59U/n36oC5e/nyZbtz585Cea1W\n", - "KxkcAJwVs1oHMGmFkSooKCgoKCgoOGOcGyMF++6yfgYp8E6cVVuXPYFyCCbKxOmo1+tlO4/m+GnF\n", - "/MTU6TmVbzDmZHgaRsqX55+Tqn8dEwUsyxKwn1hKuVnVifNgKd8ioM5hM4eBY/VfdsL2obxcT7Ap\n", - "+/v7C1nL/TO8cjm3LeZXodqRIyL64osv2ssvv7xwr2JHuF4sHHnz5k0zs3DiNDs5FaO80WgkHfhV\n", - "OwFcP5lMFvwclCI4UPc+pkQZU38zqyqy93q9irih2ckpnPsv9Q5gjAaDQYVB2traCuPKDJzqNzyX\n", - "GcIU854LnvfLrtvsgwSfO2YmVUCI92lhR3W+z8vRTCaT8AyUu7+/H/6O37a3t8N4cZ+C2cK8Go/H\n", - "WRkY6qDEN5ktV3Mjd00/DYuqHLdzwb5FagxzswPk+jmn8ngyvP/kMv1Sx0id20YqVqk6Z2h2VMe/\n", - "V1k0FbDowxm2Ts0Yz9/c3AzUMBbcs6Ibub0pBzrAbxzPYiPFdWEqv64uHv5jtLOzU9EXYZNOrA5m\n", - "x1Q9m/nMtDYT17FOTVhtrlIRf758s0VlZqXJBKQ2Mb1er6Krwh9wdqpN6dH4yD8P9VHnSNScugJs\n", - "LsWCtb+/H/oDZsSHDx9WdIbYLJRyElc0Ps935eCfi8FgsBAh6bFs0mJWoldQ/Qysr6+HvkSfqw3c\n", - "xYsXwzPQl6PRKJiKWeHeJzzOjYRWByXeNHKAxrKRY/wMtRlR885vXnq9XlZggWoHmwB5fHMPd6zd\n", - "Fru+bg3hduduzJZd0xXB4OsYe15dQBje9X6/X4nGPDw8DGsQ1urxeLxAVJgtzm02++Z873xdc65X\n", - "h7A6FNNeQUFBQUFBQcETwrk6m7MTXyqMvw51Zg2PujBkgE17OL3n6pLEdIm8/gYrUfNzvRN07LTg\n", - "6WAuS8kfrIK6k2bK1FV3uvOKwXWnSyWTkGJelGm3jvXMPZGmWAplZooxeqnnMYvnTTadTkc67Prx\n", - "YCZHvR8vvviimdmCHALq1O125buSCkNnZWCMpxojDlHPcWiPlQOchpFaX1+v5Chk+YZUGLqCSgDN\n", - "eO6558zs2LHc4+LFi6Hs1Hqzvb0d2ERO5uwTLXO/8HilnJJTYPaJXSi8Q3ZdGDpD9a/6zbNUnMOz\n", - "7r31itUxHTZup9kxc54aB17LU5pWCqrOpwkgin072K0hVbaqjw8OYNmAXMCsalZd4zkbR651idcn\n", - "3yb+NgAxiwPWEzxX7SHwHS2MVEFBQUFBQUHBE8AXWv6A4ZkXdqQGYuHq2HXyThg7ZJxs5/N58pQN\n", - "dDqdsLvH84+Ojlb2D0CZZmn/Cw5rV9mr8SzeoU8mkwoDkuuXtoxwp68DP4fZxxyWjeuK6+vC49Up\n", - "qi4kOeWQXSdyV+drhb95Rornp8p5V+fThLJ5PvO4+3tZ+E7l3/NQLMr6+npgwlJCmniOf4Y/jSs/\n", - "p3a7Heqv/IoUa8BMnWKQ+N4U44s6M5uA+cS+G8v6VfR6PenMjb5EYAE74QP9fr8i4st1wfh3Op3A\n", - "SOF6VrtGP29sbEihQ7QJ7YmxAcpnx8+306zp7A+DcsfjsVwfctjidrsd+igl+pkLJTOg1hqzah8y\n", - "e1c3b1LrIrPPSjg4tw3MDPF3wtevbk1V9VP593J9ClE2+1Qty3oB6+vrMncrO8Hjb+hrXgeUP+IX\n", - "1tncLF/ZPHZdymFvWY0M9YyLFy+GScGJXRVdjefyIPmJzhS7eiEBjk5ZxrFctcknfsxF3dikNo78\n", - "u7qOX1KvQDyf66SbHsqZN6Ytpeq87OYqtgEF/N/5GWqDhL/1+/1KO+rS1dRFs/mFoNFoyKgogHXO\n", - "UhpAvIFLbbw5FYOn7LvdbvhNjRXqORqNKvNPRQtymiSOYuWE3f5jz5sNb/Lg9irzBh9OAPUext5N\n", - "tYH2aDabwRldpc5ARoWHDx9WzHhra2uVSL6tra3Qb9ynuCeV2FV9lFqtVugPzCeVropRF5nonb5V\n", - "PzP4XfWaRiroRK1l6l2pO+ykEDPn5q4rqbWm1WpVvgm8/iiXhxSazWboL+5zf8iJBRukxhqEBNcV\n", - "v/V6vTAX8Sye25wNxGuFKfKEVdF5LHMPxQpqHIqzeUFBQUFBQUHBE8IvrGmPVY7VrlPpm7Az5LL6\n", - "RWx+4xM8nrGq3EGK1VgGMYfHlGPisjojp6krs0U8lqnw/RSUiSimb1R30jPTeeHq7k2BGSk+2fry\n", - "+KTJZljPiii2VfVBnUk2ZT5kkxI71/rcaHXBBPy+KTOZuielm8bzISV1wWMIbZmDg4MKu1cXDl7n\n", - "gLzsXFBO9XVQbAjqde3aNTM7yV9mdtKmfr8frgNj2W63A3PE64FvJzsl47derxfuYfV8P66cLSLV\n", - "p0rDjRmOHKkNRmxN8vpQZvmSNChTmR5TY9/tditmN6UqruqhWOgYM83rhK9Pp9PJDtwBuL3of77X\n", - "9wdfp9TngRhzxfItsXuXgWIkcy0Ovk7z+YmeF8oYDoeFkSooKCgoKCgoeFL4wjBSKRuvOrXXla2E\n", - "EVN+LjEWYhXhSTPNrMQcNxVSJzN2fAViTtNeVqLOT2tVBiYHvi9ZVFWdXFJ9r2Qy6mz3dW1bdp6k\n", - "/q5C8ZfJC5WSC+D+U++Kn2NqbitFaF+O2fG4sM8TfsuZx8z8KGZq2aCDOjYoxgIqqPcLdcTfTiOq\n", - "q6QuzPLWkUajIYMHwESh3I8//rhyLwcHsIO58o1TLKBScFeBOQC30fso1YlgqkCU3PWW64464946\n", - "JiblYxgDf59y6resv6VZvXo+gPv7/X6lrdznPiiK/53bv8zGKdS1yTODn0dePM4qwPXza1bsu8Lf\n", - "E7PjcTk4OEiuP2356+cENvekFvXYR9ZPlPn8RM6eF8i6xRdQC0uOwzUvBKrcXIc3jnpSNK+n2GN1\n", - "8hslX5/URDrNBqrupfJOkuwoqsBmCPw7tcHkjz6/SD4yI9Z/ufMEUC8pwyuHs3N9nbkKCw5HkuIe\n", - "b2pjTKfTyiaM+wD/rTNp89+VM3LKTMGHGa/MzXpNqs+4XPVOqcha1lDyGzZuuwo24N9yzPxs1uLx\n", - "UibbnEjJGNhUZ3a8OUA5qY1Co9Go9FEsGk/pq6m65tR/Pp9X1vC69SV1kON/c58qp342Ofoy+Hk+\n", - "SpFRt3ahbbluKeq6OpcBX3//bfJtVzpY3LZc86jSIOMDeM66GDss8KYaz/Lfw9x3T6HRqGpRDofD\n", - "ShCJWm+VqV25B2VpTq5U+4KCgoKCgoKCgvM37XFIslk9rbkKcBIBYiHeKqzUO7k3GlUlctxvlm+G\n", - "AF0+Ho9rJQy4XF8nT+N6Z05/Go/VK1dZ2J+WYs7hKZOpYqQU+8RQwQYKqfKY7fBs5jLO5jnmT3Za\n", - "xNweDodLh+WyqcqfjFjTLGW6idHzygyeC6/JEnunkGMvlT9RYX19PakBpBix+Xy+cLo2i7cptSak\n", - "zJ87OzvhmamT6ipO6UCv16uwSsPhMPQlnq/6vNfr2Y0bN8zM7N69e5V6spnWt03Jh9QFFqhgFiVN\n", - "wHNRrbM5jHNdnzKzmyNdwGbwlIvBk4BfW1UwTqwuqs/V+s+WCc8cLcMCoV/Z9KjmSaye3Ca+VuXI\n", - "VCxlnWkc93IydNQv9T1uNpuVBOqx+VKczQsKCgoKCgoKnhDOnZHyYIEtVI0dxtWOVDmqs2+BbyKH\n", - "/rINN9cRXLUn557YrtjngFInXXbSzK0f+zzkyh+k/L5QX7N63zHV58pXRYFPr/46pWidUuRVzq1c\n", - "Hp9icxgzVQ77pXGdfZ8rhfZY3kfl55R6BxRDw4rLPh8V+1zUBVek/M5SecbMqv5c3W7XLl68aGZm\n", - "H330UeV6Rsr5VqlJMyNVx65hfUA7lVgq+zkBly5dsgcPHiTLXhVgUQaDQehLMHkqs4H/N+p869Yt\n", - "MzPb3d01M7NPP/003MtMzbK+W2qdVewIwGw1swq+7jwX6wSVV2FPc8CWEe9zxVI7dX3Gyuxm+Wt1\n", - "TOpAsXvcp778GKvo+382m1WClqbTaUVhfD6fL+WUf1osG5gRw/b2tpnZguxHKiMJM2IqEwIsFrHx\n", - "PLeNFJw2vfNr3cd1WedQRU3zc1ahdNlxzqw+EkG9DLmmHUbKbBWbgKmFLrWhWSZSElDtTNU1tlFT\n", - "G1r/gZzP57UpVQBfF160ltWtUVEdau4oh2ZWMedNAl56/I0XQugh4aPI2NraqvxetyDzfPdtV475\n", - "uUrJ6lm8scFzh8OhPfXUU2Z2srl6+PBhpQzVjsFgED5yMX2d2AfdTJuo+W9+nVAm0Tr1/NMAG8zZ\n", - "bBYCFNTYAEpJu9ls2s2bN83sZG6/88474e9QTI8l4U29D/wh8us1Z2NY5qAH5NxTpzHH6zsCPdCO\n", - "8XicdBtJ6Vzl1MtsMS2USk3Cm8UUIaDmF9+D+nW73aXnoloz63TVfP1V1oDTgAOpVjGtel3H3Mjg\n", - "WPACojqxPsGFppj2CgoKCgoKCgqeAL5wpj2zk9M6nxLUztfnaZtMJtlO0wCfspQjs6JEVXuWZZjU\n", - "aQztZidyNs2lTDoqQaoy7cV21SrnWMpBWZm6lKNgirVZxlFd/S1VdsrZlE/ydexYzniqk02MHQHr\n", - "8Omnn5rZolP15cuXzczs/v37lftiJkBoC8Gx2CyPVcg9eeeaXRT4vQATwmaxb3zjG2Zm9pOf/ETW\n", - "08+DyWQSmAb0hZ+vyrSHBMGK+cI71+l0wjjUJRFPsYRA7txhkx3MoKPRKOnIzmY6b3ZpNpt2/fp1\n", - "MzsxX7755pvh75xYVullpcypWGvG47E07aXeR/Rpq9VKvnspM3On05EMO8Y61+ynshmwq0dqni/L\n", - "3nDb1Xzid9XrtcXmH7OAKDulRK6sN51OpyIN0Gw2w/jnJlOvWxN8UIqS9lGoc4NRZSAYYzqdVt6L\n", - "tbU1qYOGeuG9ePz4ceVvCJAojFRBQUFBQUFBwRPAuTFS8MFhFsbseBeey4SsitzTYi7qnM1TJ7Vc\n", - "NisW6qqcTfm0qE5wuYxPrpJ2jpp4jFHzUE6psRxlqh2pEzVf7+9V7Yg5qvvxjDFSYEKWDf2/cOFC\n", - "OFGllM0ZOI3xiUq1g+H7KuYz4JnaVUL7MWc3Nzcr/jm3b98OTJWqPytX46TMTCz71HGQCaCUrP2p\n", - "vdfrSbkFNce80KpC3RrDfh2eiWDxVQWwEPP5XDrGwgcNjMbDhw8rzOza2lroQ56fqWAN1Y8pRirm\n", - "bH4aqYEcf6NutxvmNNo4mUxWZlZzHMH52WaL649n+1OBK2bHAQ1mx35sKVHTRuNEfJXZE4x1bvty\n", - "pCLqUJelog6+H3L94ZQf48bGhmSsc1TW1Vjj2/WFdDaHc6LvLFXZ7e3tsMDi+pijpaL+lAnQ062n\n", - "TS+yKmIbKdD8aGOsbin9jljUXo4jeCwKa1mkTK3cl2rDp5zNmY5OLVCMZR3K1WKYE71ntmhe8Kkr\n", - "hsOh7A9fv8uXLwfzHtrNiWdTGAwG4UPHWkSpyLvcBN5c97rDgdlxv/hNR8xZG+YyXKcW0e3tbbkp\n", - "5T5XJmplWvE6TTHTqZoL/rfY4ptaK9CXvV6vYp6JOUWjXzkyTPUTTHso7/DwMNSFy8ZGH/NFRcLy\n", - "OsvP9R9NNrupOcZAcAVMoyo6Mhe8aQJOExBwVodstY7lrq0qPRP/2x/uUv/Gc33/qj5qt9thU6VS\n", - "J6mk5fxM/1xuZ6p+uVp6des7rltfXw/fT+wb2AzPgWv+26GiYxuNRlAOKKa9goKCgoKCgoIzxhfG\n", - "2ZxPkl7qIHaS9MwGm10U26GYg9SJ2t/j/1534lxW8ZuZCbXjTzmJxxyLvVpuzLGzLkzULN5XqT6q\n", - "M1uq3T+Qa3oE6pgSdppUcwfIZWi4Tr6u3KfMYOA3nPyU6vR0Og0h7Hfu3Al/h6M6TlnMDHhdNN/u\n", - "VJjysu1VUMwAg5mpK1eumJnZJ598UrmO32/l5Ipy8Bu3l99/Pv2n2AmlR+Xbxc+Zz+dZDGe73U4y\n", - "pSyJgfJSzutmi0lUzeJq9nDsx/M/++wzaZYDI8Xq6aqeSrbEB5aw4jveZZ6fioHFWO/t7SXXHRUE\n", - "9P+x92UxtmbXWevMp8ZbVXe+PfimY7uhnbgbMHFEAgkKAfGAEykKUh7yQMILeULwZonIeSDxWxSi\n", - "ICEBUp5IJCTEA6IZMxEbkBNb2N3BduKhp9u37zzUfKoOD8W36zvr//bwn6rqaif7k1q3+vzDnve/\n", - "11rfWouhLA7KVOS1aJ1OM75SLMPBvIhpK32/sEWkNLI5zzEFrJWdnZ2gBQTu3buXJMHzvEd5WI+D\n", - "waBhOlPzhKklAFNPfHtK0NYsm4onifqY6UTl3D/Yz6tGqqKioqKioqLilPGB0Ui1hcqNNxwOk5L3\n", - "vPnkYr/lcBLNlX8H11WFF+CTdYwMmirD34dorv7ZVFtShGz1jpjka0iCAAAgAElEQVSt3dclRnxH\n", - "GbEAdny/mY6KrjRSOe1cieaG64z3rKysBG2SkgahIdjf3w98BEUEzWltPIcnpy0CYtySEndwlRuL\n", - "JVKus492rviOufIV4Xs6nTby0Zk1M9CrOWEWzxfIKA2TUUrIX15eDvNNEe25DCbGm2my+2AwCH2A\n", - "Pr93717goCHsxnQ6bcyTUo3keDwO9+JZxZHhNaCIyBxZW2l0AX5vaYgDr6k1a+4TMRJ5KdQ+oTTs\n", - "ao/ze/ny8nIYT6XxVJktTvId5bArmCeDwUBqRUvI6N1ut8FPVETwGFJ7bkrD1QbYc5UDBM9FdYbI\n", - "aaSyB6mf+Zmfsf/wH/6DXblyxb785S+bmdlnPvMZ+5f/8l8GFf0v/uIv2t/+23/bzMx+6Zd+yf71\n", - "v/7X1uv17J/9s39mf/Nv/s1moZ2Ojcdj6aHH6ko2D3mPC467URq3iMs/qyTJvAhKD2n+2mg0Coue\n", - "2wGVPRZUauMFUE4qdQbI/2bx2CUx5Ly62i4C5ekT+3j5Q0QsrUmJ+UtBHf5KPeCm02nYgFQU4dT8\n", - "jCXsTXmL4XAS2whKosD3er1sDBuzdh8gjrtjpg9cPG6eBG52HF/ryZMnof6KhM/kdrxTmb9UdPpu\n", - "9ziJ7zxCU1vzKMeOQl1SSZo5dRbmsUrd0e/3gwmYTWfoB+6rFJQXKMpdX18PnpfcZ6rf8AyvvbYm\n", - "ZCV0KFOl8mZMefGeFnjs5y1PCWj+gO4PX/1+P4wTytvd3W0kSx8OhzOOB4A6sKEMtGN3d7cxV5aW\n", - "lsJYnEa/qgMKx5Hjg5kSgP3+znsOO3KgzqUZMRgnNu39vb/39+zVV1+d+a3T6dg/+kf/yL74xS/a\n", - "F7/4xXCIev311+03f/M37fXXX7dXX33Vfu7nfu5UwwxUVFRUVFRUVHyQ0M/d8Ff/6l+dydUEqJPZ\n", - "v//3/95+6qd+ygaDgd28edM+/OEP2//+3//bvv/7v79x787OjowwnTvhqphG3jWe0el0Zk7XqDtO\n", - "p7koxikoKZRP917qZVUnS2roA1yLRZWFFMiSoSeKsiaE35PK2cUSXK6dXuo8ODiYiVpsNtuXJeEX\n", - "+FlGKhL9ZDIJbWfnBKX6R3lcP5+wM5Yf0Nch1k9q3kJqxnsV4VGZ+zY3Nxtj2Ov1giYK7VhYWAi/\n", - "sTYDSWvffPPN8FtqfrPkV2JmVuFDYvdjbaC/l5aWgvkA7zA7nr8Y09XV1dAvHOndRylfW1ubkbLR\n", - "Xz4COmM0GjXIsir3YAxKywaNYI4wDmAexOLmAWqt5PZItB0Yj8cy0bJ/N2tCeWwUITuW6zBWBv/b\n", - "VuOn9nXWRHlNM48PJyD2c5vzAyoyPDsLpLTjKmwNTKkqS4FKGH54eBg0iKrcyWTSKPvg4GAmqTV+\n", - "82bXmKbT5xsdj8dhP+GQF9jHsOY2NzcbOTR5LFWeTrW2+Lvo36Pm12g0khk8eC3xv9wOBvaabrcb\n", - "tLfox/39/bnOBHOTzX/1V3/VXn75ZfvZn/3Z0MHvvPOOPfvss+GeZ5991t5+++15i6ioqKioqKio\n", - "+EAjq5FS+Af/4B/Yz//8z5uZ2T/5J//E/vE//sf2r/7Vv5L3pghxfFrk07Y/ETJZVrnT5giyOIGy\n", - "7Rhl87Pe/poLFKdcPzlSu+I5AXjvZDIJWid27faRrRcWFkL9IGE8ePBAhnvwAfRQR9yXIoAq5Dhe\n", - "vv9VcENFQDdrZu7O2a2VZo3HIRWBmCVrJdV7CVlJSoycZA0NIngMh4eHjXIVKZrnJzAajUI78czT\n", - "p09n+EO4Bk0Uk7q9NMsSuiLLKpdz1qaWkNIVF3EwGEh+i+eWxDQ7ENqwZu7cuTOTjV5lqPdQ/Mrh\n", - "cCh5GphP3DY8Aw3C7u5uK76F2XFfKg4Kl6ecIVJgjhSI5bHI+pgfGEtug9LkYb4rblYMSkvgnQ1Q\n", - "by6DtRlKC8T8Q08iPjg4aHC81Dtie7vP3deG04W+4T3Wj93BwYHcg3GfiorO65/h90Cz5vfTZ7vA\n", - "PbiO9j59+nQm3yP+xd/o0/39/bA/MffWa4a4fal92dcfdfa/xdYYuMM8z7EGMMc4XBI7IGCN4LfB\n", - "YBDq2oZLNddB6sqVK+Hvv//3/779nb/zd8zM7JlnnpkxJ7z11lshXYGHn2Bcad+BPLEUkVFNJr4H\n", - "HcNqfAVvhlLxSGLAfSoCMt4bW7gYqNSA7e7uyo+hJ+FzeTnVJD+rPOW8OlaRdA8ODhoTjk2AAJMC\n", - "uf5437wfIrzHLB9bJJVupdTLKlaHFNBXPDf4N3+IgCMG15M/Xkghce/evWA6gMmLU2GkyMsxz1Vv\n", - "clAbGh8wgel02lg/bNpjsyWADfDBgwdJc5VStXP91dzJffx8klJOWqzKSMWEGwwGrecvoObQ4uJi\n", - "eDfqxAJQrq+82ZrbxQcQ7wXGB0wmkftxzfWt2jNZwMRHmGP8oC6oX8z8DjCVAYe+nOeVghdEl5aW\n", - "wpxQ5iNuo1oDvlzeW/3zZrN9qcxQLHB7EyvvWbxG/L6vxotNWPwb5goOVCsrK+GwgT2I5xjPxbZ7\n", - "aur7xKZ2rNXJZCIP8T7llFnTpMqONGo+8Z7lU8h0Oh37zGc+E62r2ZymvVu3boW//92/+3f2vd/7\n", - "vWZm9qlPfcp+4zd+w/b29uyb3/ymff3rX7fv+77v0wVTgLSKioqKioqKig8KcFju9XrZg1RWI/VT\n", - "P/VT9ju/8zt29+5de+655+wXfuEX7Ld/+7ftS1/6knU6Hfuu7/ou+xf/4l+YmdlLL71kf/fv/l17\n", - "6aWXrN/v2z//5/88elhKqe1SBDVIsaPRyG7fvm1ms67QXj16eHiYJI+pJLnKnJGCihnU6/WKXEM5\n", - "tw/ayyYgld8MYHI1u4iqurOU6CXMmCaHE36iTaw+5zYw9vb2ZBwpr5GLkclTKn0l7aYkIFbjsnbE\n", - "zwXWmClJNBczJqW5hDmKTdTKNA0p78mTJzIMAMYDxOErV67Ye++9N1PG4uJi6OdS1+SYZBZrz+Hh\n", - "YUMLyX3PGmL0P8zWLD3ibx4P1W52W/YRzWOxryBZq4jRSsumzEzKuYLbycme54WasysrKw1tknJ8\n", - "UFhZWWloMT1pGVAaEG+KYY1KqYlL7TsqyrsyH7LzkU/6rRIP837G893P/YWFhcYeyQRu1IvDPeSi\n", - "jvu1Esv/6vfbXCgY9d1jpxSg1+uFbxv6cjAYNJLz7uzszJiuUBfUgccBexDmHRPLmarC31z86/v3\n", - "JDGfzI7bz2b+XCYPsyNtGsrGGuC5w5ouH8ONNVfqmxpD9iD1b/7Nv2n89jM/8zPR+z/96U/bpz/9\n", - "6WzBFRUVFRUVFRXf6Ti3yOY+2jIH1fISZixAYYoMmLLh5jgNbfP5MEqiwHqkAi22hQ8L4TVbseEu\n", - "6ctSV21VjpK8S6OE55Cqu+KOcV1PMv1T71BaSubrQaNzeHjYmO+rq6th/njXYwa7A6sAsyqoYqrO\n", - "rPFRHKlUXymXbp5/wOLioiQgq6CpV69eNTMLmmeUY6aD8E4mk/A8+r7X6zXW4ng8nuHYAHBZBxTh\n", - "nceQNRIpLXpKI64cVW7cuBHGjMMWlIRnePnll8N+8vnPf97MjuYY9qVUKA6uK2sXUxoG/La6uhr2\n", - "6FgAXVxj0jLqooC6ol/6/X7jOxCL2p8KjJkaD3aUUftZaq+5cOFCkvPJHDfcl6pnrG1eS55D6T6r\n", - "SOn+ulk+eG1pGBEGj7GZ5korrKyshO/mPLxZgDXsivuWC8h5bgcpP7g+2ajZrBcGSOtoJCdz5fv9\n", - "wK6uroYBVV5CKjIvq2KVWhZIDdZgMGjEuWIPHfba8B+g6XTaiM20t7cXzB747enTp42yfb/6RReL\n", - "Su3bwiYT5fGn1N4M5fHgN7B5UjSkiKzqYB4zb7Yto+34M1mf+8e/Z3FxMcxL9mbz7+b7GEhGCvMH\n", - "E9XZI82bodpE4EY7cv2roDz0MI+91xCD5wZ7s6YIqtPpNMw7tFOZj1ZXV+UhKUVuVkAfsHlemQNK\n", - "o13jgLG2thYIvimHAYUf+qEfsnfffdfMzL761a+G3zkNiFk+3lWuzmqvBFJzjPcLdaBRXmA5KHMw\n", - "6oNre3t7MnmwEu6Ux6p/LxO1c+PqnaJGo1FjLXO/sJexN93xe9grluujkmDjOr6jm5ub4QCi+i3X\n", - "91hnLKh7IYa/5eh7ThifWl/s3csmSrwnJpT4uqOeyvSoYnMxFYQpJrmDVE1aXFFRUVFRUVExJ841\n", - "aXGMKOrvU+a+NmYhuHJCUiqNPlxKfDab30SU08qkJIRutxvI95Aqtra2JKmRpedSdacqu1SjATNJ\n", - "KVEwJwm11TCxtOvLjUkWiiDv7yuNkMzkdZbASs24eAYS9ebmZnhWxf25fv26mR151MKMo0i4LEmW\n", - "9EHsN0DFBFIxdGJaW7QnJaViju/t7YWxVLGRptPjWGUqyj7n4vKmF9basXSfMmHwGHkNQ5s1g/Iw\n", - "vt1uN5hyS/c4aCb/8l/+y/alL33JzI5j5HCfKg3hSaDMTG3NKrE9KfWelKYzl1+RNcXKmcTHeGLz\n", - "JjAYDMK4Yr1xrj04UsTapfaQFIGawx9womO0NdV//B1Qe3DKsYX3CcSsU9HaY9o974gxj1Y7B/8e\n", - "RTPgvQFzZ3t7W/Y51hKHxrh//37VSFVUVFRUVFRUnAXOVSOlflNkzhxJmPlVPpiWAsewKpW8czjJ\n", - "s5AIUPfxeNwI8Lm8vBz6ARLQkydPgsYHQRr39/dDXS5dumSvvfaamc32eUmwTMWH4rpyfsAUeZP7\n", - "pURS5YBobfuSw0GwpFFKfiy5T0m2Kq8f8/WYe+PHUBFtNzY2gjYBGh+zWVd4wC/fj3/84/Z//s//\n", - "MbP0nOR1pvgwXGe/VpRkpoixo9EozAnFqUv1ARPfFZCK6tGjRzMuzimydApra2uNqOndbldqNwDM\n", - "09XVVekMUILhcNjIWr+7u1scugK4efOmmR3tE1/5ylfmqss8YN4Pxjr1SVHaGOb/qbk4jwOP+k54\n", - "zUuMzK34nam9gZ0i1D6q1mEpSZu1Y3jGa0n576WlpYYjRbfbbbRT8QRXV1flfFe8P+YSoazUfo19\n", - "7PDwsFEGc8E4C4l/H3+3eR/FuGLu8DdE5fMEVlZWQjtgIbh165b8jn1gyeY+aikGOrZYfJRwjkAL\n", - "8EBj8g6HwzBwqQ85x6DiD6UyKWKhpdTjvV6vkfZkOByG0PV478OHD0/Fcy2GlIfHPLGRTkLiLk10\n", - "W3qALt2MUvVTBH+OKl5iclALTB1OVV2Gw2H4UPDGdu3aNTOzQBxmcFJQbCKoy/b2dpj7THL1GynX\n", - "GXVaX18PBzggRg5OmYiY4OmT+fL6hilrPB6H9zDx3h+KOSErp4JB/be3txsk2Nh88vfxWsd4TCYT\n", - "mSKG+4brMg8uXrw4k/JnXoBEfP/+/eTh77TBc0glc07tubj/xo0boQ8wT8bjceNwGnO4SKF0jHLp\n", - "QDgdkNl8Ht0Ar715PMTx7MrKSmgfhKyYEOhTJu3u7oY4XaiDX/seSIb+1ltvNfa7hYWFhoOH6nN2\n", - "/mKnGOXUhT0G19ocpE8blWxeUVFRUVFRUXFG+MCY9tiN08c+ysUv4vfiVIwylpeXw8kXJ2XWPgFt\n", - "Velcv5NIJzFAmwBJyGvfSuEln5xGhyW4lKo51eZY7CZ1n5JEVMLWeTVhKjZSTAPn28tkybahFVil\n", - "Xzo/FEGfE9AqYrcvfzgcNsxpbD5KSfTD4bAhVbLbsCJzprSM3Pe478KFC5KsyhpkLp+RM6tOp9OG\n", - "6ZnfyftKakzUOJwGlLniypUroQ2sEWgbqgPOBiosTOw5/27eP3lcvSPFcDiciUdlpnPKKWcipQm9\n", - "cuVKKO+tt94ys6Mx4MTUvlyMZa5/0B42l6tYSakQL1xn1lyVOI6w9SWX+1TVnSOqow6pHKmj0SjM\n", - "d/TpkydPQn9ByzMYDBoOG6urq2GP4Uj4WAds2VGR8rnNZvGxKaV4lNAHYsAaZrN/W3DGEcSXqhqp\n", - "ioqKioqKiopTxrlqpBYWFpKRYHHf1atXw0n67bffDs/iOgfcbMtXYJdIlcvI86ZyUhY/q7QZOVt8\n", - "DFevXg2SPNeJNW9mTc2V10j1er3icAueX6AkeR9J3ayd5KWkE0XYVM+pugC4xpGKASXZqHHt9/sN\n", - "gqeqM7+P+Thw22euR0mgzUuXLgVpUZWLflZR0bkOStOYCzYIadZr8fz7PIbDYYO/xHXFs4oQ3u/3\n", - "G/yHpaWlmSB+KXCdfaDd9xtKU8bu8b5ea2tr4Rms71xYGAbeDU7dG2+8MaMVRZ28VklFsR6Px40x\n", - "zGlTUxzMNvBzlrUtqTAd7Nrf9lOW0jDEoHLtsXOMz3PHcxf3dzrNvInKASoWEoH7HHNHhZ/At2Zh\n", - "YSHsQVyf0+D4AUrTyG2aRyMUK8es/ViPx2MZDgYaOJwvJpNJI5/n4eFhcLr5wJHNAWx8iFGxtbUV\n", - "DgOlKT9SJiheaDmUpBo5PDyUql9AlcWT3W84pWZLX47Z0SSAWhl1X1lZCYuGD02pjU4RctVmzkk5\n", - "ua9KIkLHCJYpNXrpQs85EaBe6qCXOshFF427rsrY29sL97F5jqN0o22IaM2qdrSdE7eyyRHlAuqw\n", - "we0t6UvlIGFWbsJGO7ApcWqXHFi4MjvaB3w7h8NhOHTyfOHN+qQf9BjYo9YLf7mYURjDJ0+eNPp/\n", - "aWkp9BsSUM9DFXjhhRfMzOzb3/52+C21j/HcYcJ92w8eO034w5f68KjEvjGobBcpwQEfRY6AnVrL\n", - "ly5dCnslHzBTh9iUB6Ha39X3J/ZBLt3vTuvw2hZ8eEV/zUNv8R5/vG5Lv4UQHPr9fsNRbX9/v5Ec\n", - "Xplx1YE2hko2r6ioqKioqKg4I5yrRiqWjJjNUGY6uWlptVdWVsK9MPGoXEcMZR6ImZfM8lHPU+8w\n", - "a2rU+v1+w92WXYvRjsFgMGMyUXXwWjOlGeI2sFrWS0YqH5TSKrHZjeut4oKwictsVhOhpAkFpZFU\n", - "8WiYROzNZJysEuWp+ami5nI/s8u+nwNKc8V9wuZZJcl7KcssPQdTccD29/flnFESd2rNKSma8/+x\n", - "GRL3YWw4h5bXFsbMW6l4PrGQEymo+cmEa9QbdYmZxlUfcewcM02gHw6HQRsP7Uipiz/PRWik3nvv\n", - "vYbWLvW8WV4D4nPFsamQCfxYw+grRQxWJqCc6R5zstvtzmhyY7hw4UIgSHNZSvvt94Ht7e3G3sH5\n", - "K7FGHz16JPeQEnDbVLgZFa6DwRr7ttpLlLe2thb2Nq43xpAdTDyxPKe1xLzi2IdMOfGaZt4reU6w\n", - "ttNMr58cMDYcZgZR57n/ct+aqpGqqKioqKioqDgjnJtGCtKUIqMCnE3a828WFxfDqRmS39bWlpTa\n", - "Y+X78hRwGmcp2kuMV69ebQQUPDw8lLZxzycaDodB+uccUL7+bXILAhcvXgwEViWpp/hBrGVht/u2\n", - "AS8BRUaOtQmcEUgxMUlAcZ5QFx5fFWjTk6oVuX5lZaVB3l9eXpbuzr5fWDuS4xH46zGSewqlXC+0\n", - "W2U5Zy0Ua0S99JzjHWL8RqORDHXgocIkqByJObTRSHmS7jzkdNaUeGl9OBwGDSi4T7F6XLlyxczK\n", - "Qxdw7kFoFcAZ2dnZCdoYNd84PIRfA7GwEKn1zVoD34esMfchNE4KDnOj3q000qXv9c4zKiI5z0nW\n", - "uqJcXktes8J1UnM8pynE+xYXFxvrZjKZSM0/yuGy8Qy0UJ1OJ7yvVPtTqtWEJm97e7txL9YR6mp2\n", - "tCdgHucipuMZ7MvzzDG8o9vthjZhrRwcHNjjx48/mGTzwWBgo9GoOJqv8pTC36mNdnl5uSj668WL\n", - "F+3evXtFdWm7wSvw5sQHRrP44gdpGRP/yZMnMnkrwxO3Yx/z1GbJnoYgzqY261KPuphptxRqEftI\n", - "+ZPJREbhTh0I+f24zoe71AGFo3Cr2F2+LP748+FPbbrY+NRmrlKwpMBRxzGHOE0KoFK19Pv9GVNI\n", - "DIuLi+E+9H3swOIPz7E6+zXHXo+lBymVkiIGjAPApmyef75do9Eo3JdKrLu4uGg3/396l9dffz1b\n", - "dzOzD3/4w2Z2ZArEQRVj2el0kpGlU7HIGMrkBLC5hz3MUuaRlEcvf0jniV6tzMcA1vloNEqaWBXU\n", - "OsdYfetb32pdz1LE4lP5eFQnJZuXpN7hQxgfNrwpjs2f/E2ax5nH3weqwObmphxjAPOg1+uFtvG3\n", - "H98BrMHHjx8Xx2espr2KioqKioqKijPCuYc/KNHGxMwp/n3T6XRulS6/B/+ya2Xbd7DpUUmmKSwt\n", - "LRVLTznCuw8R0SbnlJdelbZD/abiKrHmjV2TlYlVxWfxUkxpPC9Fruc8jZBO9vb2ZN+o+cRkau4H\n", - "/nd3dzf8jT5VBG/WsigtGWvTSl2NvfSfMxUyCV9phlLlon6Li4tJMx63DX/j38PDwxlir9mRlKwk\n", - "V6VdZBOVktK9xq/T6SRNeZyHD+VBalfxejjUBZObU1sr55l7/vnnzczs93//96P3M777u7/bzI7C\n", - "S2Bf5Da21ZRz3ZWjD5s48Jt3BOK1zPGQUtpYXvtKuzxv5gjWiGOtbm1tNcZcxXAbjUYNCoJyvOF2\n", - "MAnfmxlHo1FjfZuZNMmpvQvga2cV/qDX681YDmL1yqF03NrGsRoMBtJ0epI4WH7f3t/fD3MG7dje\n", - "3ratra2qkaqoqKioqKioOAucu0bKY21tLZxkwcNhqR3PMnchxXNgPodyt+TopSUn2+Fw2CC+l4Y6\n", - "GI/HM2RU1F1FQFenejwDG/rh4WGSq8T1KJVelJSgNAMpLWAs6J5yF/Z8gFg+pZLI3DGkwmkwvEZI\n", - "cb04Yj0HyPTvjPF1lOaCn4ndl4sqz23wz04mk2REfVw7ODgIGhhoIQ8ODhpzgkMGsDs41wv3eScS\n", - "nz+M3+vrxCRos9kxh+Zqd3d3JrK173MvYeM+vz4XFxdnQhyYzWqaTiP6s9nxuCLkwcWLF8NaSfFu\n", - "WFtw8eJFMzsisatclaXwUbg5rx6DI7PjPkDNY6XhSgX6jcFrrg4PD6Xjg8plh+vglT548KAxhuvr\n", - "68EVPlePFHeUeZEKau0prVxOk+Pbubi4GN7DGlPFoUy9L+U4xOOlrAscgBhOEGhHzMnChz8o5SlO\n", - "p1M5d9qGy2EHMowZny9U/+c4Uud2kOp0Ora4uBg6kzdi5VGjyIpMUjSbVSXniNtqEmHC49rq6mpY\n", - "iCDhIkUN3zcajcKHB2Ts4XAYTB3zRCr2RDtPAk4BG+2TJ09kqg8F9VFTfV5iiu10OmFsONGljwuz\n", - "s7OT3GRSZjw+rJV6k2FBMmEY9ecPNz5yMVMVRyoH/CY4nU5nvEnbQJkjDw8PZcoeper27WVvHJjx\n", - "eH4yMOZMyCxB7qPEY+oJ1zHwgc0snkgbaOO1x+Z7gL06zc4mGTmAeT8YDIodblJgMymQizemknT7\n", - "GEbcp7EPDN7l46tFzSAF/RvzIDxNDIfDxjpT+xDHE8tREEqgUo/xR53jNqlDItcZa4k9b725iuvF\n", - "z7KjgG9bacy4FD70oQ+F7xf2htu3b4c99+rVq2Z2lHAbZWNP2N7eDmeCeRyS/EHv4OCgiKbT6/XC\n", - "vskHtM3NzWraq6ioqKioqKg4C5ybRuociq2oqKioqKioaI2qkaqoqKioqKioOAP087ecDU7DdbMk\n", - "MOb7YWv35ZnFA1WWkFfniWIe64sU2bxtNOzJZCLb5XNxKaK62WwuOcAHhYvxg1Jgl3gfuTsXNkCF\n", - "N2BiuyKoK+4YB6vDtdN2Tz4JVJ6x09QKn3SdlYx1rs7z5Np7PzAPEdzj/d7HgNxelHNmUSFPSsJC\n", - "nJTc37bPY04fAIfEKHkvl+/DQrTNCuGRI/gDZ8X1ez8sSuxgptpRyotNjWtuTXG5ufae20HqNKAO\n", - "UH4h5iaRIoyXQk3e1IeqNLprbhNRUcLnibKuPAKVV4Qim/IBxCd+NGt6qgwGg3AAAVR8MNWXqi54\n", - "p9ksmRtxkHgslWeT8pQEmIRZ8mFGpH6z8sSlJ0Fu0/dQnpBtNsKSzf4kG2vMU0ZF1D4NvB8fAi6j\n", - "NB1VCrF4TP6jGvUqmvNgEduLSg+sqb1MRU/PxWsqTVHF3mQlYOFN7Xcqur8SHP37Op1Otk0oN5WK\n", - "ib3xUvWP1cG3qdvtNpIRl4LLOsnBV+1jPA9SczaVpJ37jfs39T3md/jvWclcr6a9ioqKioqKioo5\n", - "8YHWSKVOpJywkc0pJad/s6Z55vDw0P7KX/krZmb2uc99rqh+qRg/bGZQKth51LwpN2QFdu1mKCmC\n", - "k+16qNxOLOl5F3yVn63b7YZwAXDZffr0qYzx5FW5sf710uba2lqjDNSH25uL1svhN5REm1L9n6VG\n", - "SkmxJWrtmCYx9l6PEi1GKgZWrn6nNd9LcRJtXKk2i++JaZNK6sL3pZ45i/5PoeQZpZU7ODjImtNx\n", - "ny+r1Lz50ksvNfIWxsbN90HpXOOYVikMh8PGnqDMpSpshdfYlPY5P+N/5zXl689R3fma1+5wX+J+\n", - "pfXOjVduHvN7Yu1R66zT6TQScrPWM9WPpfd5nHtAztPgD7yfUIMUQ4nak+OvMNqq4GMbvVeZdjqd\n", - "1nFPUly0a9eu2bvvvjvzm9ooOCGuSpzKXCkfG4X7WdnLOcAbxoZ5WD7Nh9qUWP2tMqUzfJJUfgZ1\n", - "PQu+TslaaWO2Om1eRcoUlzsQnMY+cNp9zpngWZgo/aCdhkmv9CA1T5+exvtyHCkFH0eMny3dm1L1\n", - "U4eX3Ee9NBE96scmu5Okt1E0jdyzbftc7ce5+dl23q2srIR9kQNp+1hxav0o06OCSloee1+KD5Wb\n", - "22ofw++xtVRNexUVFRUVFRUVc+LcNVIliHmOgFiMU+pkMilOP6DwiU98wszMbt68aWZm//bf/tvk\n", - "/aWeA6zB8GrKTqeZQDXW3nkIo/4UHpPMcB0mKo6UnZL0FhYWgtShpDq0dzQazUQ5N4tLHygPkuvW\n", - "1paMcg0gmvzDhw8bSXeXlpZCW1iCVMmXS1MM+LQ2SlI6iZ7LRPIAACAASURBVHbktMnQ3F7UaTwe\n", - "ZyOLnwZKpFl1nfugVLov7fNY/6bSMqVIy2pNDQaDpLk89h5f/km0dzmnhNPSAvqyUmWotafWT66e\n", - "3FcpArqqK7/Dj1usz1LWBd6bfHTymIk3Na9i7VEmtrZQ5apE4Apsfk2txcuXL5uZ2Z07d+TYlWr/\n", - "SjXw3qOyVJteuufjO1o1UhUVFRUVFRUVZ4Bz10i15WRw7py2PA7lbovm56QiYG1traHhyBGkc1wp\n", - "aFSgRcnxAzgHUG74SqUXpQUClFYpFVuq0+k0pI5YPf19PA4sPSFnE+dkBFgL5cdVkSDVWPf7/Ybb\n", - "a0x6Rhkp7ef7zZFS15T0qWJglZaRu99r6uapc9v9wEvqJ9FIzct14VyQfH/q2ZO0nZ/18ctiIWFO\n", - "K+kyym+rHVGaHp6Lvu+5DOZ3lval4o768s2O1wjKVWM/nU4bGnHVz7kQBly3VC5SXrdqn22rkWrD\n", - "S8J+rMj+/vnYNeCjH/2off3rX2/c5/uc/05xYA8PDwO/NpefslST63NUpnhpKY3UuR+kTgKf2b0N\n", - "454PZHgW77t+/bqZHRGHY4lrY+BJ4jevq1evhuSNufgmqSBkauJzEl5exG1iYZjNfkzwYQQpnPvU\n", - "m9AYsQzvJUEhh8NhuI/Ni94rjp+9cuWKmR1lG1cfQ/8bJzzmcv2YqA8QmzJT953FQeokUAco1Vcl\n", - "H/iYKcuPeRti9mkQqM/iIFUCbjs7TaikwCmCsqpfqbnvueeeMzOzN998U7Zr3oNUjsw7j5kpZ/Yq\n", - "qTPK6/V68lDj9wtFNuZyeaxKzLlmltwfGSXrR93X7/dnDsjzHqTUu/n5XMytUhObjxMYS2hfYmIt\n", - "LZfv4/OAItezeRn/luz5SPBcTXsVFRUVFRUVFWeAD3QcKYBPgiw5qFNsqYINEiSkD7PjEzTMRzHz\n", - "B6ROnFxHo1FQNaakmMePH0vXeqVZ8ypiVmtzfCgljc3juq7iIHmpk6HamTIbsSYnZWI1s4a2SMWl\n", - "GgwGtrq6amZHmiizWZdkvs/XZ3FxcSYljS9fkSHVb+9H7CiFtm7t7NDAdVYSv3c/z8W8ASaTSaPc\n", - "eTRJbd3t51Gox55JvTtXfyCWHslstt9K0q6YHY/X/v5+0ky+vr5uZkcaKa99OE2zXqz8HLj//PzJ\n", - "aepSrviTyaSh4WIzM8cRUvVX5i2V5UG1OaWJUu1VWiHeM/17ThI2wyP1rcRersypyjRpdrwfov7b\n", - "29uNb8JoNLLv+Z7vMTOzP/zDP5wp0yxvSlflpr5TqbXHZnA243pt1sHBQbG5j1E1UhUVFRUVFRUV\n", - "c+IDyZHyUkeMc9PWhpq7D0Q2TybPYTgchpMypJRcHp8csXQe0q1Zs40l9vROpxlkVHGGzNIhDlBG\n", - "TJpMaXqA4XAYiO6KvIwxOjw8DO9JBUtUfKjFxcVQhgoOWqrx8YRRbs95Ji329W+TnLMUJc+UBsFj\n", - "nETbwRrOk2Aewr3imZxGImaea6lwFS+++KKZmX31q189tcS/JSjl6+TqdBqhGLi/fTL0WJ1UGJS2\n", - "oWfm+Q55UndMK6v6bR6OVArzODkwAdzXC2jTv6mQCKX9m2pHbi9S8Fq51Fr9QJr2fGVjJrbSSV26\n", - "OH3S4rW1tRBjA+a+3d3dGQ8zs6PNsyQ55nA4DG3JEXz9ZBiPxw1V7DxtVOh0Og3zlPog9Pt92c6U\n", - "xxBIsG+88UY4bHJWbxyWEPV8MpnMpJDxZWBj3NjYsDt37piZSY8+RVjHeLFHIo+5X8zqENbr9UI7\n", - "VNwVzJfzhJ8LHGuHVdicnNlMj7kyl84TJThlEmuz4XqUEtrboO372GwAsBeoQupDr8jcpTF3/N8l\n", - "mOcQM28ZqryYSakU3nORvYvVfYCaX7lkuW2hiO3sMcdQ5SkvxlJwqqu28RVVvbn+qu98xPoLFy6E\n", - "lF1ArH9TjgCp7zxf53f4MtSBr9fryetzzcHiOysqKioqKioqKmbwgTTtATjh7uzsSFIgkIuNU1IG\n", - "SzAw90wmk1MlErdx8y5BidR+EjWwl/RUosucKzk0TqwtQp8zgZaf85oSpb07PDy0ixcvmpnZvXv3\n", - "GuVztF7MDybr+jmT07LA9DmdTpOhHdDuvb29czEzqWf5b7SRtW3cP8qpw9chlrvrrLeSnOs0a8Da\n", - "4iQhAmKSbSrcB7vYpzQ0gHK4YJy2aa/0HW33l06nmevzJPuiKrff7zfWqKIqjEajMA7Y/5nknDKx\n", - "lSZQztU5NeaxMk7DtHeS9domCwTv9WazmlWOlK6sGilTZ2n5/C6/56v9IuWIUsMfVFRUVFRUVFSc\n", - "AT7QGqmTICdRKU1UKfyzLO2UutPPgxICpce80ktplN4Yv4U1Mx5w1UZwUjMdhVuRB5kPpZ5JBeRU\n", - "dvDSQHBK66nIl4o8+n4ixzfh39QaUEEBuU0x5CT0tiEbYvekrr/fGil2nT4NYjfPIT/fYlpA3Act\n", - "+oMHD07FCecsNVIl2ieltVH3dbvd8De4iwcHB41I88zrSbW72+1Kp5lUO3LvO03NFf9d6rTFnCHW\n", - "5Pho7SrkQCmXazweN4LSjkajwEFlbeo83zH/LN7XhrgPqMwg6n4f2Dq1/3xHHKROMhnxvNnxJGI1\n", - "OeoyGAzkYag0VlDOYyB2zexkauPcRD9NDw9OrZI6RMS8E7HZo5/39/eTh1JAmTVipg5/uHrllVfs\n", - "S1/6UrZtuY80mwpLFimbxE4Lbc18qXhdHNeLxy9Vhjq45g5rp9GOHNp6SrYxa8zrrcVrJbX+Ywc4\n", - "/7GJfbgvXbpkZhYyMMRSXZVGSC+5xjjN/cWXX3JQibW3NN1PaTsxx3BfzlmoFLk0Qqp/U6TqUsTW\n", - "QEn2iZMeDr15W2UBUW1nk+08nsapuuRQTXsVFRUVFRUVFWeED2T4A4/YaV2ZZ1KulQATPPkdKieS\n", - "0nooU10qcS+bg1KJZDnvn4Kq81kqFH1fxuKr+PrGEraiP6DuVW7KStLb3d1thDhQfeRjUpmVJ3GN\n", - "9SPGhkMdsNbJl32a0Yg9SsY6llPMY3t7W5owVNuAVOiLmDYrFQcnh5S2i/+/bZ/nVP9AqZnHP+Pr\n", - "mdPWeDPe0tJSIxRLrJ4q+bYyxZZI7ixxn6ZTzEmRImTHNE6cdcIsblFgBwr/Pl7Tao6ltFQp8BpN\n", - "rVWep7GcgvOORew5P0/Ufby/q8jsHBmenVvMZs15qZBByqqyv79vzzzzjJmZvf3222Y2a9r14S3M\n", - "yjMIKO29ui+GqpGqqKioqKioqJgT3xEcKYY6OfIJOBUckssvJVjiN2hEOMBYyg6POqqyzWzm9J4i\n", - "qreVAr1tuUQ7kaqfWdoezfVPaaFKNUNra2shOCekHdYMslbOt20wGDSCbl66dCnwR7htqTax9FQS\n", - "wVfhLMnmJ5kTQI5EnsuHmJL0T0tz0fY9bfq8lNyectVPrdecdoexsrJiZmZPnjwxM81BifFSmLtn\n", - "1o40r4jbqRAgas2cBkdKzc8c2VxdU/XL8fpOEjpn3lybbQLaKszT5/PsGan7S6woS0tLM2ElPNB/\n", - "e3t7Rd9jznCixvo0wn7EzgY5jtR3hGmv1+uFgeUPMhrFE7lEhc0EafZiwADwwQwfZh+h1UwPWGxC\n", - "mR19mL3nCC/w2AB65Ih2pYuAN48UYZz7yt/Hh1e8l8cDiYW5/1T56CPuUxxonjx5YhsbGzPv4QMr\n", - "e+14T5AYKVQdkPCbIvjmPrjvpzySM7v4w6syZU0mk8Z9qr2xD7M/2E6nU/nRagt+31maktTB0h/2\n", - "eU8oeYeZzaSKKfnQdbvdhnk7R2XgctfW1szs+CDF9U3FqorVP4WTEHsZvi6xfc+bSZnKwDHu8BvX\n", - "D04suC+2z5bur2p/9GuA35fao2MHUdUfOdNeifl7Om16W/M9vH+rda1QcvD05mmUob7bCtzXvkym\n", - "33jTqjLxKYFQ0YPUt0G9z6Oa9ioqKioqKioq5sQHTiNVSpY1m402bXak1YBZKKe1UZKmV5NfvHhR\n", - "nqp9xO/JZBJOsRwp15sZFxYWQv64UtOZQuq+EikTdcUJX5G0Y9FrfcyO0WgU3sMSBswVOU0UJEdo\n", - "nN58881wjSUwvAcS+MOHDxum3a2trRk1sH9H235WkpwC51CcR2ovNTOVEIBZcmUpOqXtTCWTZq0s\n", - "X1dj2VYjldOSpMwfKvJ6m/JS/ZYCS6xKe6s05oAikXO2gFQYithcTOV2bEvwj5nTTjOqd6wuam2m\n", - "ylDaImAwGMj4gH5/N9OUgxQlQ8Gbf83yWmPlOKTAGuTU9dxvvo+4rvj74OCgdQJjVX/08+rqqr37\n", - "7rszz6WsIDHg3UwjST2b60v+f9b44X3ealRiKqwaqYqKioqKioqKOXFuGinPSWB7eOr0zM97yRfa\n", - "KDNNoAQGg8EMf8Ts6EQKKffatWtmZo3TNN6HkyryyHU6naBpYkkI7wbXh/PNsXRSKt15LQCT70q1\n", - "Af1+v8EjUmEUer1eeDdLY54Hpd43HA4DcZaB9125csXMzN57771wDX3DJGjWcF29etXMtFZC2dq/\n", - "93u/18zM/vAP/zD8xu3wEp4KBMr9ywR0ry3I5UHLIaeJyt3DUJJmDJcvXzaz43nOaxLtXlxcnJHg\n", - "AcWRSOVNzGmfUu1Uv6U0PzGouZPKm5jjIPL/l0jyq6uroT9UVGdoZ7GX5NDtdu2NN95o/D5vKI5Y\n", - "P3qNSy54pEKOVO3fqTTiOaI/oOq3sbERtNo5TQjWxZ07d8Jvik+YAvbj3d3daGiDWP1j75uX0N/p\n", - "NKO6mzXzg8Yim6e0a0pbhP1ia2vLPvGJT5iZ2R/8wR+E5/CM6n/FfUXf7+3tJaOi5xxk1H1q3nkn\n", - "HGWx8Ti3g5Rf5Mrbzh+ozNKqRBV1WqmoVQTkTqdjjx8/NrPjQVIEVD5g8MENpiw2l6GOfIDCROBN\n", - "KfXB40HndBFmR33lD1C9Xm8mtL3HcDhsbAaHh4fJjYI/Nr4/eNNXMXQYIJTjANXv94Op7tatW+E+\n", - "HFD53RgTNo34cjhaNzz1UA63gw/X6gCKDxr/xmPEhGJfp7bIfYByH5HSj5cyxcETFQcpNpPhXz5E\n", - "qcMk19MnQeaycoemkxDK1cchl67GlxeLR9TW5JTCw4cPZxKxe2C+DwYDu379uplZOCipmGvT6VQK\n", - "TqlYYEAs+4AaG7/vqP2KzST8G5BzIvC/sZmplJANHBwcNMx49+/fn3Ei8kDaqocPH4bvAO8NKScW\n", - "NXdjfRSDEjr4GeW8wPudX7e+PNXnPpaVgvJcVc/s7e0FLzwkk79//7594QtfaLwP4H0i5T3Jwmwq\n", - "rQzqxAIwl8tKE9UG30YA8yCFatqrqKioqKioqJgT5xpHKhdziVEas0O5OKoTdQlYpcfqvo9//ONm\n", - "dizt3Lp1K2glUifr0WgU3pOKlKtUjvPCmxfNdB/6nHfqVM/qcaVi5XEt6Wv0ldmsudKbEG7evGn3\n", - "7t2buW9nZyeEVlDkUbRnf3+/0dcsyTFQf8y1mPRTYm5ThNJSU1aszNJ7vXYxFsJAmYC81mF1dTVI\n", - "6Ez0T+E04rkolJgZvJOBeibm0OIlVkX65r5kTU7bNvN689qT1dXVkEPvG9/4hpkdaXMxH3NllJj5\n", - "VXgT1d4csZz7paRPlRnvpGbBFKAF39zcLDa/Yo9J7RFKs8au+F577Ouqwu+kTLLsqq80V0CpI0Bu\n", - "Lak6+3K4/gzu89Sz2GevXr0a2o75zmeDVC7F8Xgc1k1KS6nKZ009kIqAn5qnVSNVUVFRUVFRUTEn\n", - "zj2yeSojN9/nT77MX2pLruRnWarACZlzwp1EuvaulaXRvc3SxHLuF1+G1yJheFP8ACb4p/qQicde\n", - "g2WmtYZqfJkDBa0StB5sB8ezq6urUguCPlLkReZrzRvp2UyTTP2SUbZ7xRkpLVeVUaqRimka1H1t\n", - "Ca9ty8ghpVXgNVrqks2hCZj/k4oS3jbyPteL2+75PDGSqyK3QrsLCV6V20azXhKtW3FGlPt7qcMA\n", - "a6RySM2ZmAYndh/v20BMq1CyvtlxpHTe8TtS/Zd6n+LjxrRLqD8Ht0TbVB1inNC24WBKNYMpjiE7\n", - "daWyIsSsGqngz/yO0j1NzcVYaJTUe8/tINXWtAGo9B0xoqgqN1ZmrvMxATudThg8/MamOCa8pbwT\n", - "uO7eZKIWFdevzQJQKmYPVR4j5SmRqxdv6my6NDvqP/VOPIN+Ye8ZgM2MvDmoWDEp8DikUhKo9gK8\n", - "UaUiW5d6HanrubQSsTYB6CMQzFWfxp4FeRTm1ZgnX1vMswf4OeYJyF4IYy8hLlcdIvxHVY1/znTS\n", - "9uM0HA5n4vigTiUf3xh8O3J1Th28YqR0oGR/iUF9NOfJ2pD7mAPYx0AsZwcX/y7/PlWWL1d5g5uV\n", - "CRvqoMzfyXn6nOvnHYFyh/Gcw4WCaiengeG6l+C0Ur6gXHXALBUmq2mvoqKioqKiouKMcO6mPfVb\n", - "ThKIYX193R48eGBmmsiu3qHyyEGqWF5eDqand955Jzwzj5SI53wZbI5gScRLEDGNkYo6zO320guf\n", - "qpUkmpNEUqpwfgeeYXNfSuXM7YDrNyRG1phxzj28D6bCx48fJ50SUhITx3vh+aH6KDWP2ClhHim9\n", - "LVRdPNl4fX09hOfguEP4DSalmBm0ZL6reRAzC+U0w6lrObJ52z7n8krMuKqOpaaEmCYshba0BbWP\n", - "xrQdqX0AyCVBVkTr0jqW3p+if/D+yTQHzjBhNhvaQ5XLVAXcx5r4XOgCs1mtNu9xOYtEKdQYto1E\n", - "jnbkTNQ5rQ07D+DflKb+5s2bZnak1UaMQey9Ku7gYDAIdU45TSjKS25e5fZvZQ3A71UjVVFRUVFR\n", - "UVFxyjg3jZSPJK1O1jm+k5KoSsjr80TmBRYWFsLzKvs32/1LpMgcPykFlhZjLs+ev5TjETBynCfA\n", - "a4GYQ5OTAr2L8Xg8DuWhLazJy+VqKuFIKU7TZDKRBG9AaR9SkvxJNFKxuZjiBynk3OC9toPHgyXO\n", - "lETKvJ5UJOpc21Io3QeYB9FWW9QGJaTl2H0Aj00J+VpxPHLg+1OardL+Vc8oPk+OJF6yztrk8/P5\n", - "P7mvoHXloMj4jXNz4jeVkYHrrDTeap2rfTbFx1GaP/+N9N8vzrLB5SoOVckaUJxARmp8e71eY188\n", - "ODhIzjfF10pZALjseTTXOQtM6v4cR+rcTXsg/sEkF0OJKpHfnVr8/JHj39RGBpUv3neS2EI5sBea\n", - "SsvA5Haz/KbNRFv22ivxVDCbNROi3NRGkpu8KY8L1GlpaSl48KnNDWUNBoNg0uPEyMqbEFAHi1zc\n", - "r1TcslQ/lpqZ5jELpX5TGzL/hv6ZTCYy/U3J3FAmKpVe4iTt8Ne5fDNtgma1PJD7OAA5gSZnmiyJ\n", - "ycX3sXNK6XpsaxLNjauiFKTMM8oMyl7FsfhHDNUe1aaYSVF9+EoPoh4cIw1Q0cKVUBT9oLrviloX\n", - "fOhQH3B1AObE43xgwd+lJsJSk2JqTvJ3Jffdy5llzeL7bKngWDK328wnda2SzSsqKioqKioqzgjn\n", - "rpHyGoGYVJRy28S1fr/fkD5LJVKUY5ZWnXPMoJw2AxoQaFRiZNNUeAF+nz+159TueD+Xx9Gfc2Yy\n", - "JWWXxoriOprlVbCqTqnyldp4PB6H31LSMRNUY8Rzs1nVespNnpHSjpTitM1fag2wBiZHNvYmu1gc\n", - "Nn43UBILits7j2aXtYA+Xhqvm5y2uiTido583bbOpSY7VReen/OYG9X1UocQ7zSj6A1tyOSnkcmB\n", - "657S6PlcmQye2yrkTa783Bj6OqWeje0DynSXcxLyexFrlRhosw/JwWXErEGA2k+UNaAt4f4k2ns1\n", - "j6fT6cw8B7zmD31VNVIVFRUVFRUVFWeAfv6WswEi+sL1WvGXcPpTgRtZMmQJA7wZvEORB/k6nzBL\n", - "7K9cD6XRQTt2d3cbUgy/H+8bjUaNtilegpKIYiRWJWlxOAL1LhUQT2lcvPQQ0/h5LZvKoTedThv3\n", - "sWSgykdZMc1GKpCpkuSAbrfb6BduK3OMPCE7p6XK8Ws8YryY1LNKg+B5LAyuZ4prxxwPjI3iAXFE\n", - "ZdZSlEiduTUI5CI9K+R4hCm353kkYH6H13DG1koJZ0yNP/epqqcKyMnvaMtVS6HTSYdYiD1jNssT\n", - "43lXwl/h64pLo9qrtCK4puZLThuVimyu+kUhNq/bhjdQ93J/5DhLKoh0qebIh1NhsOOQn7/dbjdo\n", - "rHgcUG5pMM+UZj1niUntQSVr4twOUgcHBzMdnpooPPHZtAPwhoGPnCLJASqSLh/W2FToVdfdbjcs\n", - "HD40+UFXpEWzphedIlzHNkg8wx8vv7mmYm7gGdUvivzoPwQIlc9gcyp7zPnxjE1e9HlJolWun/qo\n", - "qmdjhxIk1gTZNNXu2PtKNkhfbtuPV2qBxz64sftLyvDzKUeq5fngxyNnAuB3ldxX4tHr52dqH+D3\n", - "MJk39fEq3cxVZHv++LPgmCJzc3t82erwpxAjdacOa+pZFV2b/z+VSiYVFR1t8fD9r8zMMSJ4ifc2\n", - "m7dU/5WanNQa4L285D0qgrw3Pan5W+LkwG1LmftYyMb+eHh4GL5jXC+193mlhdqj1Zo6PDxsKBOU\n", - "QiD2HVUCnB/PmBBzGmZ6s2raq6ioqKioqKiYG+dKNocWwuxYm8Anx3kjiDNipi7vpqpyrc1bntlR\n", - "e1KqxpTrr7pv3mFS5ixvTut0dE6nlJZItU2R5rlPlYarRBOmsLy8bE+fPp1pG2saU/2mzIxcVyWl\n", - "srYN0ppSYXM/tiWbl5rxSlyK/XtLyNw5zVCKzMumdp4HfixPSixWITkAlpRZYm1LAE7tA7k8mKnc\n", - "jXxfbo6XOITM05dtY8cpTYnSKsW0ffPEvPLvyyVULw1NUAq1T6VyAab6dB63e0aKgqL6KGaS8+/p\n", - "9/vSRJwi6bOlJuXkwM/5Z/lv5USE8CxPnjyR3wYFpUVVNASPXBgK1Gl/f79GNq+oqKioqKioOCuc\n", - "G0dqNBrZ3t5eOOGBJP706dOi/FIcPZuD3OEkioz1t2/fDs+wlKdO0ilNFD/L0bBxTXGUIE2mgqop\n", - "rK2tBW1LyjWZpWO+xoE9PTqdTtAYsQbG38v2ctZMqYCXuJ4isff7fUnmVu9LhatIRSBW2iU1hwaD\n", - "QbjO2rOUdMX3+Xaw1pO1rAol2iQl+SjSPCOlUcm5yat3KKT4Ndwe7h8/ljHpslTzivvm0RqnpO1Y\n", - "2/x4tekjxRkDsCfs7u42NCBM0uf+823OhRwodajhNp5GGIKUJiRXrrqf9zg1/vPy8Pi3VEaEHM8u\n", - "FxVb1cU/oxwCfJ2V5gVzJ2YFMDviO3nteezbmtoX1Dcux+8s5YRi7sc4vP5Znife0Wtvb08S7r3V\n", - "JaaJSzlApRobxRtvvDH94R/+4elLL700/djHPjb9lV/5lel0Op3eu3dv+jf+xt+YfuQjH5n+6I/+\n", - "6PTBgwfhmV/8xV+cfvjDH56++OKL0//0n/6TfK+ZTTudztTMpqurq9PV1dWpmUX/Gw6H09FoNB2N\n", - "RtOFhYXpwsJC9N6NjY3pxsbGzG+9Xm/a6/WSZZjZtN/vT/v9fvj/VDn+v263O+12u6GswWAQfkvd\n", - "h/YNh8PpxYsXpxcvXoz2gf8NfZj6jfvczKbj8TjaXjObDgaD6WAwmOmvTqcjy/L/cZvUu31/5Mad\n", - "719aWpouLS3J+1Dn0jFfXFxs1KX03bH7fLnc523/K+nreZ8tHUtuT+rZ1ByPjWlJHebpA9XnpfU/\n", - "rT5PzTvuE+xnZib3ND/v/PxuM678u7pP1ZnvS72b9xc17v5ZtDk2RmpsUvNJ/cd7Zdv5rtpxkrmx\n", - "vLws+5nnnf8vN8Z+T+f/FhcXi97H+xh/k9T78Lfa0+f5z7/Hfw9P47+1tbXp2tqa/DbM8x/6O4bk\n", - "UWswGNgv//Iv22uvvWb/83/+T/u1X/s1+6M/+iP77Gc/az/6oz9qX/va1+xHfuRH7LOf/ayZmb3+\n", - "+uv2m7/5m/b666/bq6++aj/3cz93KhJORUVFRUVFRcUHEimNlMeP/diPTf/Lf/kv0xdffHH67rvv\n", - "TqfT6fTWrVvTF198MWijPvvZz4b7/9bf+lvTz3/+81IjFZMw/EkV9y0uLs6cjjudTuMUq07LSgLi\n", - "E7CSdiAtDofD6fLy8oxUwf/hxN9GWlL1g0aKf3/hhRemL7zwwsyJGnVtIxl46cX3V7/fn3Y6nVAO\n", - "a36uXbs2vXbtWrh/MBg0pByuN9oRk4a4PFzz46okUP8M6qLayxrB2D1cHv5jCQ1lKQkppjH07eA+\n", - "n0cqPs3/eNxUXVK/xeqdktpPQ3Jt01+oS04L2Fb7lFvXqo9ykrXab8bj8YymWNVPadZK29FGI9VW\n", - "w6i0I7E17OcEl9tWI5HqA+7LeeaYqkupVgzPpvaQ3FpBWdwOfg+Ab0+3201+p1jbqcpT3zF8A/v9\n", - "frAaseZKadTUXE/tBak9ejweJ60Qajzw/VlfX29cV+X0+3051uqscSKNFONb3/qWffGLX7RPfvKT\n", - "dvv2bbt69aqZmV29ejXwkN555x179tlnwzPPPvusvf3226VFVFRUVFRUVFR8R6GIbP706VP7iZ/4\n", - "CfuVX/mVQPYFmMSlELuGzNae9MZBJkHcXVpasnv37s3cNxUB4BQBlYmvitjM9Zz+fyIbPwNiHciI\n", - "0+m0QSBMkeJz4LJAHNzY2LBvfOMbM/cNh8NQbirwGL9Hkb+Hw2Gj/fwOkBIvXbpk7777buN5Xx4T\n", - "D1UIC+5z1JvDB4CUCbDDADCZTGYI+2ZxQjqTeGPwZfr70UaeT5iL9+7da4SF6HQ6kqTq34d7+d9Y\n", - "XjB/v7oWcy/3z8T66iSBJ5VLfGodptqhrufK5+dU/VN55mKu656kW0pL4Lqqd6f6xcwazh/qPi4D\n", - "f6f23dyzJfU3i2dCSCEWdBEAmRf9s7W11djL+dug1g9+U9+QnZ2dIueF2DVF6seegb5Q5eJ3s+O9\n", - "IZf1QM1P7C87OzvJEDQc7gXOSQrb29uNkAO9Xq/xdbyGBgAAIABJREFUG/cHjzmCFjN8qBgGOzup\n", - "TBipfQnv3d3dnZkLXE8ut9/vzzxjdtRXmGMoQ+X9m0wm4T2oc7/fT+7lMWQPUvv7+/YTP/ET9tM/\n", - "/dP24z/+42Z2pIV699137dq1a3br1i27cuWKmZk988wz9uabb4Zn33rrLXvmmWfkeweDgZxYKysr\n", - "wSMLHc6HqI2NDTMze/DgQfgN93W73XCIwLvZi40PED6cfafTkRsYns11ro92zhFt+ePpPxQcmRUT\n", - "4datW6FcvENFSuaJj/ZsbW0lNz7uA35fylPu0qVLZmZ29+7dpOegqhf3Pf5Gny8sLNijR4/Ce8xm\n", - "JzcQiwWmUPLx29raarRDRW3nAyG/12+WDCzqGPz455Lgpg5XsQMBf2RwzXsVKs8Wxjwx3Eo+WrHD\n", - "f9tDZK5M1J8Pm+pe5elZ6hGYa5PyvPP9qTxvDw4OGv2vUqZMpzr5tkKqL+fhsfp5zvOYy0plR+D1\n", - "5r3ccod/zGPez9ShOJciKFUG+mVxcTHsWWp9cxv9oYTbq1LJcF3wG3vgpfa9nFckyptOp41DU+kc\n", - "HwwGoV4Yk/X19YZiA/fyfQqpa1yvDnmuKoGB40T55OvT6bQRKX00GjXm1nR6nEEAv3G52Eun06l9\n", - "5jOfSdY7adqbTqf2sz/7s/bSSy/ZP/yH/zD8/qlPfcp+/dd/3czMfv3Xfz0csD71qU/Zb/zGb9je\n", - "3p5985vftK9//ev2fd/3ffLdo9Eo+9GpqKioqKioqHi/0aHAnrmDVJJs/nu/93vTTqczffnll6ev\n", - "vPLK9JVXXpn+x//4H6f37t2b/siP/IgMf/BP/+k/nX73d3/39MUXX5y++uqr8r0mSGNM8FLktStX\n", - "rkyvXLkiyXeerOnfj79z5HCQ33CfIsktLi6G8pj8ze/G+1MERSbheUKeIsjH/kuRNNlVluuC8nIk\n", - "U9WvnhjPBEdFsGQ3bz/mTIJMkWdV6IfYfyXurnxdkTTRP2ruqPFS5fl5Pu8YqnnMdTrt/it5n7qu\n", - "SKfzEOzbluv73LvMx4iuar6ftgt2ai6q/lJOJ3zPSUjQbUMIpOYd14X3dO/Ak1uH2PO5TaoPuC6K\n", - "3K/23tP8L0ea5/+w36UcGzyJPDbnuB94TgPLy8uN/sC+FesH3o/V/Lxw4cL0woUL2TmEfROEcDXW\n", - "ykEi9m2bd+3hnaPRKLtWUg5m3Bdqj8EcjyFp2vvBH/zBqNr3v/7X/yp///SnP22f/vSnU6+tqKio\n", - "qKioqPhTgXPNtcccFGXrZ2I7eFO5qOfKZuzt0WwzBiltb28vlF1i62XEeC6eIB3jUShyo7o3xZFi\n", - "gOC9v7/fIH3v7OxI/osiNXK0eQ/1Dh4bNQ5+jBWRldueGusY0TrlUKCeZf6aJwXz/GSeGPoF13Z3\n", - "dxtzhudYiscQmzv+mdycyM13Bf9sjq/FmIdDhTJL24H5gn95bqq5MZ1OZ+Z5qrxUubn6c3kxxPqS\n", - "ia5mOsJ97N2+z3Nty6FkP+EyVF/xNbWHM1cN1zwvxUzv/34sudxcvkvflhiHy9dTOX8oHmgpb5P3\n", - "mhyfTbVJrTM/HrH7GKm9HFBjrXi9OQcE/pbMu09gjpiluXRmx21nXjFzC08KkPpT6+3cDlKrq6v2\n", - "9OnTBiHz8uXLdvfuXTObnejKU8qTbnlygwDI74599AE/6OpjzQtSpUJQmwSXmfPIiSE2iL5fbty4\n", - "Ye+8807j3XxwxCJQH2nuA38oKa2Dmdnq6qqZHXt8sNdhKn0LI+V5FeszVRf/DB+QAE6jgHKHw2Fw\n", - "MuD3rq2tmZnZw4cPw/MXLlwws+MDP8+Jth9rBj9b8p7YARMCA4996sOX24BK7uP5ospS7VGJrxmp\n", - "98yTKJo9RFPJedVHK3XojB1A/JxW4xXzCCs5XPP7+ECdc1AogSJL817IDii4LyUMpZKcs9MEtx97\n", - "Etalam+bj6evn+pT3i9Sa5C/P6lDkxrzjY2NsFfG9kVFjE4J61BEsMc0Dhvdbre1N6bqX3iz7+zs\n", - "yH5XTj2evK4wHA6lsAFwu9XcBkr3XjVP19fXzexoT0daudh7atLiioqKioqKioo5ca6mvdXV1Uao\n", - "Awa0GuxWyupZ/8zS0lJ4N6sw/amUEx6revHJf15tAkuVpUk8Uwl5FVQySga77aLc9fX1mdARXF+z\n", - "4xO5SnTLcUtS8U2URH3hwoUQ6oAlUa+14XAVKr4JoKRElna4XiVSEUuJ7M6MMcF86pAnh+orIGba\n", - "S5nTUvfFNE2lSMUW47H38WGm02lRouXYb0BbbUEbsxVrR7xGKmeuTGlAfH081P056kFJ+JCTaKRU\n", - "XbrdblK6LwWX77XK3D8ot9PpNLQObcY1pdVRe2Vq/ikNoVlTu6j2Pda28R7i1y3vjwCbwXhuQJOD\n", - "slKWETzrk+2yOZW17bie0/hjT+D3KU09WyT4/hjUuKHtvV5P0nnmnZedTieYLdGXvMcpjbOax8CU\n", - "QnYwPQR7ctVIVVRUVFRUVFScMs5NI+Wl+Hk0PyDnKS0UtBqdTmcm4raZts2WSvw5iSqlqTGbldbM\n", - "jk7leB8TlVOkP2UTZo0D/+2fee6552aCppodaYhUADMvSU2nzWjy0+lU9qvnVyleEpfLZEilQVJS\n", - "kNeysLYoJTWtr68HaS2l/RuNRqFtmFus0WPJFpINB1ct4euoeXcSZ4MYudVLiTmybEqDFFsrag2X\n", - "cFAYpdpbBdbkASyht43CrNDtdpOSeWr98xrIOWaUagFL0MaJYJ4+x3NewzGZTIo4izyf1P2soU7x\n", - "YZQmpC0PsJRYHtMaAtA4KctHbP2Uam2ZBI+/FfcNdWCNj+ILA8vLy+FZjmaOvRn7rNIgzeP4wGtV\n", - "jSssF7jGjlI8njleZUn5ykLA45HTSJ2rac/suBNUJHJW0YHgCzx69KjRqOFw2DiUmB13iA8bz3+r\n", - "hcGbZsprQplxTkLqjCHlbceHML7fH3xUaoAYlJnCq0JjGzSi3b/33nvJ+qe8SdRET21QMbNl6X3+\n", - "YMbmSG6DH0f1gdzf30+mUWCUmMlyh6u2ZrCTmOliKImyHSNhnwbUQUqp9s2aQhU7Q+TI/N60a5b2\n", - "MOS9waek8F6HgPLgKj1wlXxYTktwZJOS309yxG2upz9AxQ76fo2yMJYyX+eg9hpAHUQXFhakZzDa\n", - "hL4dj8fhvpgDEu4v3Se8iWoe5MYfptO9vT3ZnyUepG0O8KUo2TOU8xQ/Mw9dopr2KioqKioqKirO\n", - "CEVJi88CMMMoqcnnJhoMBjOu5mY6lgVLMNCI3L9/P7xPaTGUFJNzXfUnW5aKvLt37D2QXFhCU32R\n", - "yo2WI5vH1N8pF12Y5A4ODqRE6FXJq6urQQ3MUrSqlyfx9Xq9oIliU2BK6lBaNJT74MGDhqSkJGCu\n", - "WyrHn8Lh4WFD4t/f37fLly+bmdmdO3fCvSWaFyXlKGeI0vAHOVI0a8nU+/ycaEOGT8XDUnXJadty\n", - "xO0UclpgH3YlRzbn93GMG8CXo2KVKVM8O7QwsEa8eaEEsbhrXIfcu9pqC5V2TplfeE/hZ/xew//P\n", - "+wprosyO1qCyYKTMh6nYTApqf2RtFGvJ/R4eM58rrWbbfYKfUXGXeN75+3gNKy0qUx7g9MW/qfmk\n", - "tFT+fr6eattwOJQ5cttadVIUBLUeJ5PJXFq0qpGqqKioqKioqJgT58aRQnDKEmkcz5hpIitwcHBg\n", - "Fy9eNLNj7RO/i6PsQtPD1z2nZTQaNSQKlYW9pL2+7ilwpmpVBiSg3d3dxunZc728rTim2Shxy/bB\n", - "Pv2zrKkr4SsoXgK79CrJmoNhqnHw5XI7XnjhBTM70hopkrmPwqzIsqyhYelUSWglHAYljXU6zWCz\n", - "pc8yV6Wt1qENfym1BpR78TwR0/2zJXwdL2Uroj1fZ9f1WCgPBoeISAUXzfEvUlw/BeWW38bZwCM3\n", - "x9oSn/l9irjLdblx44aZHfMn2e2etZCeJ6YcVvwzvtxUm0oJ0jkHAwa0KHgvBy9V/c1OKqWEdhXG\n", - "gYHfee8q5S/5PlpdXU1yvDBGOzs7kqTtMU/Ef/Usxnx9fT3s9bBuqP6NaXRzzmHAB5ZsjgWPiNCe\n", - "1MsYjUaNOFKDwUCq0wEedFZn8jvMjlXE7InA11VHqw2eI8bi/lRUdPbe815FiiyXIspyO7xq2S+6\n", - "paWl0BZ+nsProzw1NqlNnFPT+A1gZWWlcXhRZlKz9EdG1YnHPbXhfeITnzAzsy984QuNODR8AMl5\n", - "/vkNXm14fIhIbdzqt1gKhpKPm+rT0yKqp57NEUtPy+EiZypUH5ecB6LZUZ978vBJ+jJGXvZ7R+xj\n", - "6ddzKXE3Fg9N1fM0xkS110fb9vd78xgTt7nOqn6pOiuzW2qO59LGlEKZrdoKEGZlWRn478FgILNx\n", - "eKeJbrc7Q5Mx06l1GKkUPP1+P9QrFZ281+s1+uHg4ECOoeovNrf5aynEaDX+wL20tBTWVy7jQiWb\n", - "V1RUVFRUVFScEc49/IFCadLglPkIp/vRaBROqCCsd7vdcOJWJh48y6bHtiYWszKybCyGSqmElNMM\n", - "sPSCuqTyfSmpbmNjw8yOiPvcN/iXXXjxr9IqpRIK50yBkGJQPkdFZ9Mi6sB1Rl1QT46RArBmQM0/\n", - "lbcKYLMLwjk8efIkOc9z41uamy6loeF3qcTY6pmSeaeIu2bNNVIaoTt3jccjlX+RSbXqnUDMJOa1\n", - "T6wZxDtGo5F0CikNV+GxsbFh9+/fb/w+r0YK9zJiz51G+AluL68R1CNl2lehT1LhUJaXl8Pv2C8O\n", - "Dw/ld8JH/D5JPK7hcBieV/OZ12qJyZvDYAArKyuhbUqDydHVfUYHj1QdsC/2+/0wtzhvIe/rbbC8\n", - "vBzGve2zpXMb+wCewb9ohyK+K4uH6h/1bWoTR6pqpCoqKioqKioq5sS5a6RSHCAm7AHQLuzv74eT\n", - "OUIdMLGUA0EC165dMzOzd999t3EtxtdR9yluFksbqIsi7voI2Dmtm4Ii0LE2iwmynsQZsxmnAjWi\n", - "f2/fvm2XLl0yM7O7d++G+1TeK3Wfh4qortp5cHCQJJEDrBliCeOv//W/bmZmv/Vbv2VmZlevXrXb\n", - "t29Hn83VRV3z48l8nVzYgFKOyllFu55X+4n3mOUJzbzm8Xcuv1iJZpqlxFKCP4PL9e1TvD4VpJXb\n", - "lBpXJdHG3lca3V+hVJup0HY+cXtLnuE1z2MFCwFrotAHHN7g5s2bZmb2rW99K1r34XAY9olU3rfS\n", - "qPIxYv5JwnOU4EMf+pB9+9vfbvzO1odUcOCU40YbsHYfWF9fN7Nj7b7KRMB7NIdfyK1ntM3XNaZt\n", - "9yE91LNtAtCqsf7Aks2VeQnXfCesrq6GhVEatZbf7zfkfr8frvOiThG8FZk7RdyMDaaPH8J9gfvZ\n", - "W5AjZZcc9Lxniz/MKc8XRW7mwxgI3vfu3QsHGvTHo0eP5ELzfc79q9T36qOJxb+4uNj4oKlQ/v1+\n", - "Xx6GfByUWP+pjbHkYx6LGeTVy3y9dNmphMLzeMDh79JEoanDXxt40qrygFLkUDVPecx5PbKX52ke\n", - "pNS64LhpKVNrzGzpTe0cAT9FjPV1Ve+Olauu51KclCLlQcbR4nkfA1RUb2W+SQlbnAIotz+WzOOc\n", - "Ga+UoA9BcmdnJ7SZ6Q7KDK4O3qrtucNr6oCXMkMuLCw0PH5ZyIZA/fDhQ5lSDM+kMgRwWhvl1IUx\n", - "Ut/5nKdpKfiw5mNW8j7LwnE17VVUVFRUVFRUnBHO3bR31lhcXAwEMiUVtUXOBKSgJKEU8ZrBmjoV\n", - "lTinKUtJjDkNjCeMcyR1nNpHo1G4rrQ3XBfl3ot+gAQSi5uFMjgxKurN7/XarrW1teBkkNLoKA2I\n", - "Uk1Pp8dJmlW4DCBmZio17aXGhjVxSur0Gk6uM9oYi8njTXGlcdNipsJU0uKURmcwGCRzreHadDqd\n", - "IfirmD25uDZmR32VCruh8iYq6bhEa+SfLXWuOa0QEnhXqanDfyK8OdXsaFyUNsGPMc87brfPg1oa\n", - "eoTRVovH4EjzqXnC5HW1nz377LNmdrwf3717VzrKqLqrvYaBvRLzs9PpJPuN2465Dezu7oY2Yf2w\n", - "RYEdeZSjCt6nQunMY0b01I3RaDTjvIR/1btZy2o2GxqJ90BvwWBLUiocCb69VSNVUVFRUVFRUXEG\n", - "ODeNVKfTsUuXLs3kJjOL50Ty0sb6+nrQNOA0a2YNImPO7fEk4JOtD/oZIzJ6KYbrznmk0M4Uj0Gd\n", - "nmORzZV2hG3BzM8y09G6n3/+eXvjjTei9WF4jRvzJVLETeZLgNv0+PHjGe6E2awElIpOyxopRspd\n", - "XWn5lLu10iTgPg7PoMB2eh/cTpHwmUunNBeqzopHxJJcShOiuBQpDkosjIcqw8+rHB+K36Gke1zf\n", - "29uTvLQUZ4Trir8Vx0MRlFXg1hwPR9XFa7tOsiXHeFgn2ftSWtSS/cVMR5Wfh/isophjzbEmUQUY\n", - "Vih1aPBjpLQjinvLOeNYi4b9Ee1Q5XtNPMaQwxWoPeEk/VsKH/KGSeQ5zqAKIuo5pu/3sSTnOPCB\n", - "JZsDHN/IbNazjVNx+CSe/PFXGxrewQTk3KHKx1/hd7Yd4FinK2I2P5MqI5Uygz8C/JuPg8MHi1Kv\n", - "k9RBJXbw9W3p9XrhYPTgwYPwPLw/+DeA1b18qPLgQ5tSdasPFRPU0TYfNX04HDb6JmfG4UOi/+Dy\n", - "fdynpYec1PxQZaRiLpXO41ITUIy87OeOiorMBG42r6m6qphlqs+BXq8nYwnxdSC11tXc5o9YKm5R\n", - "KkUNv48TKadMYoA6cPM45BKBl3qBpg5h6iBVOheBnFmdvbj98wsLC2FuqQNtjpwcywih6sj1V/HE\n", - "mHCN8i5evBj2E9zPsQ1VCjM8G0uXljq8cqytnPemf159e08CZcbn+iu03feYpM8ONf6b3+l0GueE\n", - "Np6wlWxeUVFRUVFRUXFGOFfT3srKitQwKJS4dLIrLJPNVM6z0pxIXkpQpjiun3LtBJiozu+FtgVa\n", - "NyV5sdReKkVxfZDMWWnCYiiNRA6tg3d/jYEJxSl3V2BlZSW8G9IWE99ZioGLLscR8wRVjg+kXGHV\n", - "b0AsSrhfRjGyuUJp/jVFIo+9IwY2fXltJmscuU9LtFjz5ILLQfWLbzuXq/q8tDzWipSGMEhpzGKm\n", - "fa6X2SwZnq+pMfaIRUX34xkzu6Y0ZTHSsgf3hQppwxpfs3hSbU9e5gwMrOXhcTc76u+SkDixNZVy\n", - "MOD2pL4/THLGnswOKeoZH9NQhdpYWFgI72P6CM9T7G34TVkNcnP2tFBCAWAg/iCHiMgBfYBv4NOn\n", - "T+X+he8T7t/c3JTaLqXhxvs4DEbVSFVUVFRUVFRUnBH6+VvOBtPptFgbpbQFfDLM5Qfyv7NdVQXB\n", - "Y5url8ZYwuC8czHbv5nZ5cuXzcxmomlDonrmmWfs7bffnimDeSRo5+PHj2eIzLjPBxRjqZzrpCSV\n", - "nJaPc2ahnSqYZurdrCHwZMQbN24kIxSzZIPyVPksYfgo0YrnxME92TkAUg7mhAoBobggDE+KV+3h\n", - "Z1nKBpQmTIW/YC0K6qzCcyiJNMbXAnIchZSWQkl+KQ1XTLsYCyvBdWIttEJMgvR1VBoY9d4YqRbg\n", - "ZzB3lKu+Gn8mc5doDNiFPdUHw+FwRrMBpDRMjBTXj6E0tX4uqnnV7/elRgjzEtcUn21paSmpkYJW\n", - "fWFhIWjveI2mnuVvTkq7zI5BKT4pQzlXAIpPxN8ihppbav/07+v1eqHMXF39+2IhgEo0v6wd5X3Y\n", - "z2O+D9+SpaWlsL+r7w/v1XgPZ8JAn/M3xJ8r+H2+/SmcO9kc4Eja7JFhFt8k/EdOqZIVyYyBRbWy\n", - "stLK7OXhyY39fj+oLnFgzHnPKKItBp3Vn7yg8AxPLBVHCiYv7yWJ+/00UKRF3vRT6QdiJkxApY9B\n", - "nRcXFxubw9LSUnieD3dqPF966SUzM3v99dfDb95EyRsjH5phYgUZP5bCJuUwAMRMe7GI/lwXM30Y\n", - "ScXc4jFX3melKVj8Zt3pdGZMa6i7Mrv5D5+KYm6WjgXEY+X7iuekMjvnzKlc53ljDqmPSCwdDA7m\n", - "XEeUC6EoFg/JE/JjKI1BpaC8D0sPzX5P5TWV+qSwB5wS4NBn/A5O91JiVu/3+w2vPR4z0Bzu3bsX\n", - "fmMPZvSlipXHccp8Wqj19XXpNOPLYHMk5kG3221QKLy5D+sLv62trYX1EEvRZBYfDx+7CX3Pv7EA\n", - "Vwqek17wVYfSXDw8vuZ/6/f7YS/AwWxhYSGMScqRiueOGn9GNe1VVFRUVFRUVJwRzjXXXqfTaRAP\n", - "1akvFhtlXvBJP/c+zi9kNnt6ZkKoiricAqSLxcVFGedIoYTMx4Rcs1mCvVk8onVJriN2x2WzZswE\n", - "YqYlfnbz9poNljqh0ev3+0HSS5FDzY4SEpsdm1FZg6BCLUA7sr293Vo1zeTvErK50lwokinqbTYr\n", - "SSsNrdfM+PFHuUqrVBpbKJVHkqXa1FjyNa+RWlpaCvcxWdfvDdxXrBVUufYUqT7nDu4ldAVuU2qM\n", - "mETOfQCpH9d8DkkgFe6D4bUOrEVt64CgwkfE9jFPfL548aLU0KZCj/C88/NYaZ9WVlbCdaZXeA3h\n", - "xYsXZ7RNvi4qxxtbMNT3Z21tzcz03oF5rDTYPOasfeT9GOWjfqjTZDKZCRGCtnNdAdaUpcJ9cHvV\n", - "fpwC2rG7u9voo1wsOIVUCCJ2Eos5bqHOmIv4XvA8ZOJ4SW7JhYWFMCa89qpGqqKioqKioqLijHCu\n", - "HKnBYNA44bFUydoiLwGp0+54PG5omJg0zZocH0JgNBo1cqj1+/1iQvxJwBIIyvfEdyaMMo+FpQSz\n", - "ZrgHr5Eya0qJTG5WQfzYNq+CgirOg5fuWXJUQeHUNHzllVfMzOxLX/pS4xpLQKxl8ZI8E3dT4QI4\n", - "6Cvz3JiMjt9UxnBF8PTSPYdd4P5RWoBUv7A2RgU+BVLSYEq6MpudB34slSs5a4uU1hDvG4/HQapX\n", - "bVRaHn7fCy+8YGZm3/jGNxrXNzc3wztR3s7OTqOdsZAIpURhIKfN9tc5OrXiubGEnuLxAIrrleMn\n", - "xojMuM8/E5snnkivuGmlITFiZfi2ra2thXWdqx+AtfLgwQOpRUG9S8c853gDpHiAvV6vwa8ymw02\n", - "bXbURqy9yWTSyInX7XaTfLNYvVE/zEHPSeb7Ynyj0qwIvm1q3cUClGJs4Kz19OnT8A1sy9uKzZPS\n", - "cBA5jdS5HqRisT1S4M2uRBVvpiPGerOBmtAcFTnllafiPq2vrwcPA/7I4W82jfj6YxGa6YWYApP5\n", - "2HQK1fSjR49kv+U8rYBUTC6F1IedN31efCmzBk98f4hU0YZjdfJ1iSVTVeX6g4Iyp/DhqhTcB6mP\n", - "ei71i8fS0lKoK+YfH+qA4XAYPl4sfPj5wn2lxkqZPDn+Wsr8DfX8kydPGuOwsbER/kbdOVI/H0C5\n", - "//xmWfrhVve1OYT5D63K0KAOL7H3YazZKzfVtpQZnO9TfQXEPg/IAoC+Z1OsQmqexszbvl94v+Cx\n", - "4jmD96kPc0ldFhcXZ8xtZkdrAWOJvrp//76kL6BfONq6P9guLS2FuqqYgBi3w8PDGQ9t1AGCCB/I\n", - "lPdZ6SHrtODX6/LyciOhPdcnd8j2czuXSqaUqoD5sr29nUyxxg5QT58+raa9ioqKioqKioqzwLlp\n", - "pM6h2IqKioqKioqK1qgaqYqKioqKioqKM8C5RTZvyx85a/xp1ZJ5QqnqdyaMl5IuU+CAeCpPX1tw\n", - "cEMmh3r79s2bN8N9t27dMrMjjoQPfslctZTLL8J0mB3b+DlAJfpsOp2G93AQTM/X4fvaotPphDqA\n", - "73b//v0i/kOv1wukWw7ICn4T+kJFGlaR1weDgb344otmZvbss8+amdmrr76arAPGZW9vL9QfoUX+\n", - "7//9v/L+v/SX/pKZHUer/8pXvtK4bzgchnc/evQoSno2O+ZkMMcr54KtrpdyM08Tyr2c+RzKeYHH\n", - "LZVnTHHCSvkmzLNKub8zXyuVlxTtWFpaCtwy7ElcBvhCT548CX+jHTs7O8HZAHPtzp07jbUSc1gB\n", - "bty4Ecr1GRguXboUSN+4786dO2FOoP+uXLkS8ukBCwsLwZkA/Xv37t1GmBZ2lOp2u2F9Mh/OB4Jm\n", - "xyH1Pcs5o6DfwCPinKXzoITMrbjSy8vLYY9BH3z9619P7p+lc5bz8KU4yFgzscj7M21IXv0OQVtv\n", - "GwVOjBuL7XIaKI3tclbgDzwmXo70zwcC1JvvBzkeH+bDw0MZx6UtOM0MNij2ikNfYrO8d++eHDsf\n", - "L4XniYqvxWX4RLYqvVDucMTphRRSHz7ExXrrrbdCvUE2HY1Gjai+Cs8++2w4bPBBitMxeKhsABxv\n", - "Btf/+I//OFougz1SOYJyDAsLC+Hjm5pL+/v79vzzzyffxR6mqEPuAAWoMeOoz2ZxL0t8YN955x0z\n", - "K0+grIQ6FfuK35WK/m0268WMuqTmbQkZv+R+1AVjzoINDkAXL160b3/72zPtuHDhwozAYKaT0vJB\n", - "Cs/u7OzYM888M1MGz3tey74P2CEA6wz14Gc5KwPatri4GOqAvVA5v3C8Lp+FwOz44DAej0P/Xb58\n", - "Wa5x763b6XRC2Zjjm5ubM+R3tJOv+7LRb88995y9+eabjXJLoeaFX3sqOvnTp0/DuoGn7vXr1+2N\n", - "N96IloX3Mck9tX4XFxfD2CJNGyOVCqrRpuwdFRUVFRUVFRUVEn8qNFJ8sp3X1ZOl7NPQcMUAKfss\n", - "tV45eA0J9xnarrQGnU4nSFjQQnW73SC55UI1QJ2NMm7fvj0jqeJ9XvLNaXLQl7HxwvPqOpsXcupn\n", - "syNppq02MaeRggQJCYjNH5Cst7a2gmTOZkT0KcNH2X/ppZfsT/7kTxr3Ybxg9mOoNmLMO51OkAw5\n", - "Kj9McZBg2SzA2k8gpS7v9Xoz0mkM4/E45G4sxcHBQSM0gArF0ev1GhqL2BxR5k9I1D/0Qz9kZma/\n", - "8zu/U1Q/VYaaO7HI4NBm+phV/EwsunuqDhwziESDAAAgAElEQVRvyM8Pte9yuagfP4u+vXr1atBI\n", - "AY8ePQrxgz70oQ+Zmc3MYX73tWvXzMzsy1/+cvgNmtKf/MmfNLMjjQO0Upzfztefo6fzv9izPvrR\n", - "j5rZrJkZzz7zzDNhL0T9YCJjcDYI1iTiPdw2jAM0RAz+3qUS1D/33HNh30YfbG9v28c+9jEzO9J2\n", - "m80mfMd9GxsbyZhY2LsuXbo0E9stBT+XOYwLz2OYREs1/8DTp09Dv6Mv1d7/4MGDMBd8CA1GyZmi\n", - "aqQqKioqKioqKubEnwqN1EkCjjFh2AeyOwuN1ElyBJ4GcvZetJnbDmmMg6oBKtt5v99vaJUmk4nk\n", - "ukAjwIRRz4dS4PxxqczhV65cCWXgPuZDQRqPaT04VxPfHwPuN2tybpi8zvOAo1KbHfUJ584zM/vI\n", - "Rz5i/+t//a9GeZ7wPB6PG5rVXq+X5OaoOQkJjaVU5pMxRwTl/sW/+BfNzCSPAe0YjUbhWcXNAra3\n", - "t+2b3/ymmaU1UpcvX57Rcnkw34iJ0V4bxnXBePksAR4qIjvu4z4t1USp4IwMNZ9UwGDFh+IsBrg/\n", - "FZ06lSszppFN8T8h6V++fDloGjB37927Zy+99JKZmb3++uvhmg8Oa3a8Tyi+lCoXWqqPfvSjQcsC\n", - "rQeTjaF16fV6MpApygMBmjVSeMe1a9fCPECdmV8FTCaTmSCyqBP6CP28s7MT6qXmxGAwaATdVH3w\n", - "5ptvBq0t+IQPHz4Me/f3f//3m5nZf/tv/62xl6r8iQwE4t3c3AyaQ69dLAHax5YQ9A002xsbG42c\n", - "jDGUWnx8JoR5LUXfMQep0lDubaGSjJYednJ18h80jlR7lkip6tn7iz9A3uuMoQ5XTLiFeQmLcGtr\n", - "a8aLxOyoD/A3+mAymTS85/hggA2SzS4qtQYDfc3pFHAvFstoNJLphVAHbF4LCwthM8XHPFYuDh7q\n", - "sMkRjdEHbBJLmdhwkMEm5eEPGd1uN/QB+u/u3bshibNS0/PmgTkBkjsfpPiAizJgfnny5EmoCxN7\n", - "/bM3btyQh29/QN3c3JSmBPQRri0vLze8ohhqbfI8xgeGD4acXsYT1flvPlh4oYvnLObE8vJyo+18\n", - "GMK6UIl4VVt4fvq0Rfwb15k99PxHk6Pd8/rIJQoHMN98Si6z4w8uTEFmx1HAt7e3g6caAx9V9pjD\n", - "+mPTjZpPADxCf/qnf9p+//d/38yO++j5558PcxXzc2lpaUagMTs6IGGOxcjjZkeHqx/4gR8wM7Pf\n", - "+q3fMrMj72GsEV4Xvi+XlpbCPEG/3L17N4wDr0OAD8OYs7u7u/KQ4QUfbjMOrxsbG2H81TvQLxsb\n", - "G2E/YWoE2pf6Lg6HwxlHAQDtxLxfXFxs9NH9+/cb5t6vfe1r4fpf+At/wczM/uAP/iD8prwZGWhH\n", - "W3qARzXtVVRUVFRUVFTMie8YjZRXG5+WZorf47UNq6uryaTFKp4Hv8O/r9PpnCmR3dcrdk2ZxDiv\n", - "kNlsbjRoGvb392dMV3gfJEKOQaPaB+lJxa2BdLS8vNwwu02n02TMHtR1bW0tSLGQdliCRJ2UdMfA\n", - "9dh9KA9SzNLSUng3a5p8vKnBYNAIxXBwcBCkSWiLWJ2O+pfOl8PDwyD1w6xw9+7dMIaK/MpAHTAP\n", - "GKjLzs5OIPh+/OMfNzOz3/7t37b//t//e/S96IvV1dWG2QjtN0ur7MfjcXCFhrvy06dPky7ROcDc\n", - "zKE9UAfOAae0uyoHHMB58DCfY5oTH5dqb28v9D8nafXm5a2tLbt+/bqZHcdN4zWdMs91u92GhP70\n", - "6VNpOikN2YB3oz1Ke8MaM+wHKysrUlvgf2OtMb/Hk5x7vV7YB6C5/JM/+ZNQns9ZyGXt7u6GdY91\n", - "9PLLLweN1Oc///mZcsyOye6vvfZa0JgweH4Dnty8ublpN2/eNLPZdZta/zzHWOvpwwscHh7K/RO/\n", - "Ye50u90wdtD87u/vhzJQlydPnjS+MZ1OJ2iQVMJtYG9vL5gXWWMO8N7/4Q9/2MxmQ6xA64V/r127\n", - "FrRKwM2bN4MWU5m+OQemd7745Cc/GUyTGHPOfRtD1UhVVFRUVFRUVMyJ7xiN1FllsGZpy2sLSqOv\n", - "M1GdwWRfvO8kka098TVWbg6K9+HBrt+s8UHZqSCJ3KeQ6gaDQZAOU4HOdnd3G1GnmfcD7s7CwkKQ\n", - "8CGdeMkEKOXXld4HSU4FcVNgDaAn7vf7/RC4MRWosrSs4XDYiE5869atBlE4FhwSv0GDdfHixfA3\n", - "S7VYj9CcHBwcRPuf0e12Ax8G47a0tCTJ30qjC6kYayEXckOBtSc8NqxhMotHLvfzhLUFnEEA70Gd\n", - "VXgW1rayBglrAHVi7TjPT8V98Xwofoa16ABL6F4juLS01Ojj2NxBnVM8QdYkod2TyaTRL6urqw3+\n", - "3+HhYYO/dPny5QYnr9vtNur8uc99zj75yU+a2XF4jjfffLNB8FcEc9bOs7YYcwfr97XXXpNkZUUA\n", - "5wjjHhgDDhURc3ZAHTGu/X6/oeEcDochi4DSXEIDtrOz0yiHg81CM7O0tBQ0VtDajMfjMF4pztpg\n", - "MAh9CI0TRw7HHN/b2wuaqJRTxO3bt0PbwYcbj8eNbzi3Vzmv4Hu2t7cXHB8wN9jKEMN3zEHqrMAb\n", - "jN9s9vf3ZzaZNhiPxw1SKh+G5qmnJ3Cf9HCpzBWY0IpYOplMisnyXh0cM5F6UwIvFixqrgsWbq/X\n", - "a9TlwoULYSPjDUEdjNShiU1wZkfjpj7YODygzqXjsLe315gTvV4vbHzqcIpNKTf/8N7xeNw4APT7\n", - "/bAp4N/9/X1pLkA7UZcrV66Efub3+ojAMYK0go/GzKpzlKE+Ptvb2yGWEOJrzbMG2Lyt5oGKfJ+K\n", - "sRT74Pm1vrKyEuY3j6dfzyrq+OPHjxv0Br4vlR5DUQ8ODg4a5iXen1CXzc3Nxoc5ZupTcel8nfmw\n", - "jXLX1tYaB5DpdNowrR8cHIT5i/2EvfG4vcBzzz1nZkeHJqQzgil4Z2encZDa398PcxsfUOUty2C6\n", - "g/rYY01xP+LdPL+wn+Cgcf369RDjKQeeV/hmoW3379+fyRIBsPMN6oA+54OZ32en06n9uT/350Jb\n", - "zI7G0sev4yjxXE+0Dwel8XgcDi+o5//4H/+j0TYFXovoZyVc3bhxI8R1S+HJkydhvP0+n0I17VVU\n", - "VFRUVFRUzIk/8xopSHJ8smVpFa6okKx2d3eTkbKhzeBccCwFzKuRMjs+mXvCdxtwXUrNgmhTm9AN\n", - "yuzhESOlp6DCNHD9UuZKjhXkNWG9Xm8m+jLKgHTDIRR8NOF+vz8zP2Jg8xHquba2FuqlzDSlOQuZ\n", - "nAxp/c//+T9vZkdmEk78apaPAo9/33nnnYaE94M/+IPhb5A6S6O9TyaTUDZL/pBmYbqNSY/etX7e\n", - "cCIq8bDXnqgI3rE8eMr84PuYTR4cdsHnPGSND2tMvCYo5djCYG07a0D8uE6n0xlHEMAn4uVQMaoM\n", - "bje0jfgtli/OjyPfh3V5cHDQ0A6ovTDWF//5P//nmf+/fv16cJ/n+QAHit/93d81szhlwNe10+lI\n", - "zTG0T2jH9evXg4kNfTYYDELft8nx5sHfJ2gcp9Op3EfQl6jf9vZ2Q6uo5vve3p599atfDdd9uVgL\n", - "V65cScaUYjMp1nsJsTsHpR0/PDwMWjSVJB3odrtz7S1VI1VRUVFRUVFRMSeqRur/S1Z7e3szOfvM\n", - "jiRSH/BuOByGZzjKrnLZB5gc7kmX83A8cNrm03MpmGsF9Hq9GekF9YKk3FbqjwUF9JwYzgQPrKys\n", - "BII6RzbmvG0AXL9Rv0ePHklCvu9rHkPUZTQahbFml3Mf+XZ7e7vR591uN6mJAtiFHfXkHFqpSN8x\n", - "gq/ndTGfDITQr3zlKw1SqpkFd2sOeAhAWmXJDlqvZ5991r7whS/MXC+dI6x9Qnvv3bsXfvuu7/ou\n", - "MzviOajwE8zxwvtKwRonxbvw4So4snkq7IrKycfA2AwGgzA+0D4uLi6GflDcDvRrjHyvNE0eKro7\n", - "R/dHG/v9fiPcA0v3OQ2YL4OBEAFqrm1ubiY19Zh3m5ubRfPswoULQQPDdYHmCFYGXm8Yo93d3WIn\n", - "IwAaq+eff74xH9nBAGvqYx/7WNBIAd1utxGewbdVBez16HQ6je/Yyy+/HCKxK81xymEj9n3xhPKN\n", - "jY0wTmjbgwcPwringuaW1mU8HifHH98wDvqK9XZ4eBj2FkBppnLc2hj+zB6kFPnOdxybYrza0mw2\n", - "sjHex2p6v7nxJD4NL8SS+C4KyjThyeC5tCJKzQ81O3sn4gM5Ho/DpMZi4f7A5sZxXNjUho8+PqSj\n", - "0SgcrnhR+zovLCzMmOoAb2KIpQbAs2xS8oer0nHgZ9k7Dgs/lZpoNBpJ0iPex95niLWEcYGXktmx\n", - "SYk3Gz4sYB6rOsDz53Of+1z4YGDMSzcdThTKfe49165fvy4PUrieiu8WA/pIpQgya65TZdpTODw8\n", - "TApGylwGKJPd2tpag4zMf/PhKUV85/v9sxyDiFPiqJhWCr4tqi5mZUTdra2tRtwy9hbkvRcfUh+T\n", - "jvGRj3wkHKSwR/CBBu9l8zFMchcuXLA/+qM/mnkfR9lmUyL6BoeE9fX1xrxS9bt//35Yo4iBtbu7\n", - "20gz5PtOHTbVnMJ4goR/48YN+57v+R4zO05QfP/+/eI1672J+/1+w4R5//79YKrH2Dx+/LiRmubR\n", - "o0fhujrsptDr9cJhUqWuYeEKfckx3HCYfOWVV8zsaB7w3sjlMEr2gGraq6ioqKioqKiYE39mNVIp\n", - "NbRXeZvNuiYr6Y6TH/v3qoSoHwRwO7yJgLU37FoPaYk1UmxGM5tVSTMJ20vAo9EomNZ8dHQz7fLP\n", - "rrqchBj1hJTIdVa5AkuRigGD982jXVTxuLgdbFrBNSXdc0RmsyMtGeLaqPaCzP3ee+8F8xLa2O/3\n", - "g5YN489jifufPn06o0EEVB4/j93d3TB3lDkUkqaKrM7Rk1OJinPguc3zza9rdc3/jv/HOLBGR4Ur\n", - "8Dg8PGwQ1dn8yaY2HzpDmSEODg4aDgVsFlTP8rgpYrmH0j4xbYGfQZugHWFtG7C3t9fItcfjj71h\n", - "bW1txgxpprU0MPlzHzAwVkqrORgMghbLm6DRTrQL2hb02be+9S372Mc+NnOfwu3bt0P4DobPxsDx\n", - "q8z0fsjZJGLXvva1r9lHPvIRMzt28OBwC7yv+P7lfZtpKdhHmIiPdY/I5ltbW6Evsa/s7e2FdkIr\n", - "zqFseP75LBWbm5uhDn/tr/01MzvKq+ctHJwjk8cf2ieUsbq62nA66nQ6jX6v4Q8qKioqKioqKs4Q\n", - "f2Y1Up5YGoNy8/USpiJ9MgGVr5Wcbt8vKK6FkqRY0zQPud3sSDJQbrQlJO3BYBD6XN3PweO89KSi\n", - "7HY6nSDtKCItwBo4lmzm5bcpDcfu7m7gWEDLs7q6GjQvIKMPh8MkLwjvW15eDnVWfQXJ7+HDh0Ei\n", - "hKSbC+OAPuj3+6EM1j6VkHS571hLgr+huVBu7aw5ZR7QPNqpkkCbqWuoN7fDbJbr5Z/Z2dlpSMCK\n", - "9H1wcCCjnat8nkDKGUJx8xgYQ3ZeyYVTUGPtf+NxRRkbGxuSwO+1AHfu3Ananddee83MjrRATAo3\n", - "O9awMNjhQoX78IFIGTyfVZ5F7pcf+IEfMDOzL3/5y+F9WF/QqG1tbTXqsLW11Qh10u12G3uVH4OU\n", - "Rp3Xkg+qurW1FbQxnGsT8xf5Ae/cuRPGBFrK3d1d+c0CZ5WBfkf53W63kRXh6tWrMzn7zGbDh7DG\n", - "D3WAhv2dd94Jz4DHdv369RDYk4Mcp0jp0Iju7+83LA7T6VQGo87hz+xBCuCkj5h4PBHYRGR2NOg+\n", - "USR7uOGaUn8Ph8MP1EEKKD0ccWwsZfLynnBms2Rt/3EuLVd5RPHG6+OvxOrH5fpNklMroB2x6N8n\n", - "gVLF+wjuy8vLoQ99ShkPzDfc1+/3wxxTh0iORI6DG6dHUMRob8pcX18PhzrewFVfeXLoZDJppGLi\n", - "6MkqThgOk3xIYEFonoNUydzL3cMemH6+8YGRY0Gxuc3sqJ2KqK7Iyt48Z2bBJIYxZAGO36vMjN6D\n", - "NLZm1KEzZqbMYXNzM8xtFgzUx8vPbfaiTAkLHA1cHaRia8nsaI75bBZ7e3vB+wxr6uDgIBzi2AyJ\n", - "yPuI1P366683HDim02k4EDCR23/8d3d3Z8aw1PHB7zGHh4cNcjY7BLE3M+qIsel2uw0z6vb2dvib\n", - "D6Uxhx2z4/V8+/btxnybTCYzacjMjvoZBx41XhC4ePzxN6cNwns5vRSX29ZDM4Zq2quoqKioqKio\n", - "mBN/5jVSQKfTacTxODw8DKd1SA6K9Nnr9RqSvMrndZKI5B8U+DaxJgdSx/b2dpBivKbBTEvAkKz3\n", - "9/dnYn/EUGISRD19Pi3WrKl3lpruWFuE9paGQlDSJRPGfXyomDTqzUss7XL8Ik8ev3HjRkMCZscB\n", - "SNkc+whQGpirV6/KWF9Km+gJrTE1PJs18RwkZmjd+v1+Mv5WDKUJqn3mAxVKQIUN4Hqzy74i2vv5\n", - "ppIb43mz4z7tdrtBE8WOHEqb5dctz1M1t1KOKLFYVSlCO8Bu/tweFdUfmiVoTh89ehTejfmpknm/\n", - "9dZbYT9hrSznnjM7Cueh5izezeRuhP7AuO3u7ja0NzxuKpYR0O/3wxh6U68H6ry5udnKcsD/MtD2\n", - "CxcuhDnLoR8QcoQTUGO9og8mk0mgI+TWnp8z+/v7yXyEnCAZ9UrFaFM5KLe3txvhMZaXl8O70dcp\n", - "DVpbVI1URUVFRUVFRcWc+FOlkSoNoMfAiZVP74rrwTnSIElzlGCACZT4Haf20wjCeVLEAucppCTL\n", - "nITh2zoYDBpRqS9f/n/sfVmMZPdV/qm9uqr3np5uz4xn2p6xPR5P7PGS2CJWzBA7JgRCpCwiUQQP\n", - "IQ+8RUECEQkwL8RIIERYJBQQL0H8o0hkIZKJIRhHTnCM7dhWbMbjbezMjKdn66V6qb3+D6Xv9HfP\n", - "79xb1W3DxNH9Xnqmqu69v/3+znfO7zuzeoQYluPZs2dd5fDtio+i7OVyOZJPT6TfRyxnEVdHBqzo\n", - "YrEY8bvjHhgTgyw0L2bDlqHVagXxK3FWmR3vGxsbGmeAv9VqVeMNEJ+ytramljQs8Hw+r58hJuS1\n", - "114Lnlmv1wMrcHZ2NlBr5npyvcHQePOB289j5Wz7Mmu8HSTNAWaQkw43eMHhPCZs37RaLRUDfOaZ\n", - "Z4LnWeZnUJm73W5ifNOggHo77nieceygt0ZaRpe/44BwzAv0/8bGhn4PRiCOGbIHLlj+AsHOcYci\n", - "7JiYnp4OGIipqSn3uYAn58H1RHwQ5szY2JiuY97BEI41shIMY2NjOsc5Rgv/Xl9fDwLy3wpWVlaU\n", - "NcNzPVaQ2xeq9Pv379dyoT9YtBTf3XzzzVrnp59+WuuUBHzPQfFe9gIW1LZr99raWsD0eeK+Hlhi\n", - "A+8mLkscfqY2Uvl8ftsbKf59UkJXDiLHAoSB02q1Ii8jkWhqkmFOwvxfYVhXRiaTCdoyl8sF7gWv\n", - "vUulUqBHk81mA6Xic+fODZ06AAsnFqClpSWdJNyudgIxrb7dF26xWNT6oi/X19cHLgZJ92M9FQAb\n", - "TB5P9mSoVRcGsNijP9bX1+WGG24Qka024EUdixzrvyAwljdXSYrla2trwcvec1tnMpmIZgvqbdMu\n", - "iUQPeKC+aAPUrVarBXOI1djjkBQsnWQkdDqdIPCYjTX85SBdL4sB+iiTyegGioN07cas1WqpFhI2\n", - "p54rml22nmtxUH29JMi231utVuDeLBQK7hppx2qj0dBycVooO5aLxaLbR0jpgVNZlUolOM3oGS6T\n", - "k5PabjAmrr/+enn88ccjv+M+uv7660WkHyyOzRX0kNbX1/UzfqmjrfDZwsKCbqT4JKzdiDYajUjC\n", - "bpH+eMBGj+uEeXPu3LmhwxmGBZ4H1fE33nhjqOveeOMNLRfWRzZYUffXX39dXazWjcg4evSoqo7b\n", - "ssWB1w4+jAAkHeriTSDWY7yb6vV6oIA/TFqi1LWXIkWKFClSpEixQ/xMMVJvZcfOUgee9cYWOB9d\n", - "ts+2AesiW9bTICZjWDfT24Wk4FFO2AuUy+UgpyC7ujjHkg0o5aTQ2y3fzMyMWsCcH4utobgyiyQf\n", - "745TbkaZtyt/EMcciURzcQFe4ulMJqNlwJgZHx8PpARKpZLeD+XM5XIRnRSRKNMAC4xx+PBhEelT\n", - "99CU8SzCQ4cOiUifIQADizb1XCTsRka7rK6uBswgs5/M3mJOYXx5fTU2Nubqc3FQtXXBs+vUyxkJ\n", - "tNttbX/Oq2mf1Ww2Azbby+02Ozur9/Pal+tnmVqv7q1WKzhI4bV5vV4P9Jds3QEeRyJRto0TvFtw\n", - "MK8n48B9ZNnLS5cu6fcsGwDWjo+rA1aLiHHVVVcpIwUm23OLMVN79dVXi0jfpf29730vUs9cLhdh\n", - "cLncjOnpaXV/4fmVSkWfwwH/ds7zuOJyoa12Et4wCKzxJyJy1113BaxdHFBGLxsD/8bLaQngXbJr\n", - "1y65//77RUTk4YcfjpRtGGx3jeb3sH0nMPu0nfZOGakUKVKkSJEiRYod4meKkRoWcQHX2D3D2u71\n", - "errb5ViEpN0y+8FhEXKgMnbAcUraIn3LK2mXPezRbQYfB4W1yXEp+DfiVzwL0suh1mq1gmu57DZ4\n", - "VWQrXoJzIjHwPFiRKysrbnsw44JneO1qn+H1fyaTCeKXvJgqjsOLC7CNw+joqBvQ6cV5wFoD05PL\n", - "5ZQtAiOVy+WCo9XValW/Z2sdMTdsjWGc43ftdlvjQk6cOBGU5d3vfreI9BkpfIZ7eOKf3BcY2+Vy\n", - "OYg54HZEn/OBgCTZkEqlEomHSArYZqFKOw/Z4se1HOvniW+y8KEdn71eL2CLLl26JAcOHBCRfvwI\n", - "yoL7cH94Ae025rLX6+m9PQV0ZsltMDzLGniMLceB2bbkY/JApVLR4NwXXnhBLLyYFhZ4BDiw14pI\n", - "NhoNjW/BdzyWMH95Trz66qsiInLttdcGcWTMoh48eFBEojFQ+D1ndMDf66+/XvsQ4PbDWNu7d28Q\n", - "eH7ttdeqcCcQt5azcOd2FbeHfU+A/Ww2m0EM7LDIZrMaZ3by5EkRiYp04vAKzx+MiVdffVXHAPpw\n", - "enpa62vHwduJpPgnux4k4R2zkbJ6OrwQbBfeiRovzYN3CrDT6ehvETBYr9cjAZZcTjxPpL/Y2Xqw\n", - "qjNTv0nuqDgdl6TfscsDA3jY4Gt+SXguO6u/lMvlguBhTn7Jgbl4cYNab7fbusjgfnGbSpsEeRDw\n", - "shkZGQkU63u9nk5Y3G98fDxImeKl4CiVSkOXxasLXqDYqLZareAZXtoDb2HN5/O6WeLf48XH4wRl\n", - "+e///m8R6S9e3gKKDRwDfbNv3z4R8U/3MTBn9uzZoy83DxgPi4uLOnb4pW1fDpcuXUpU2eZNM282\n", - "+FAF/54/s8rSIr66NrtOeWyj/VGnS5cu6UbaUzPHJuKGG26QJ598MvIM3tRxOe192BVnQxX433wC\n", - "0guaZ9hNBOs5AZcuXdIXKQPjCRpES0tL6p7HS3NtbU3d1jw2PDVuPNcLk0B9WVsKm5hnnnlG7rzz\n", - "ThER+eEPfxhciw0UzzuUr9vtBhvHZrMZGJYXL15UVyJcfJubm8GGet++fcFGiscB2ur8+fP6XFYT\n", - "HxasuTWMZhK3N6u1J23gOBMB2vq2224Tka2TeiJb74vdu3frHMC1XpB7vV7X92vSITCRrX5nVXQP\n", - "2OjDJbtdXa4kpK69FClSpEiRIkWKHeIdw0jZxJ5xgWDD0JmDWAN247ElivtyYmKRKKsEsPXAFp1V\n", - "wM5ms0EQZy6X2zbb5lnWbDXybh6Uta2byBZDk8/n1SphNV/c03PzAZ1OR60IlIeD0lnDCdYBB25a\n", - "VVqRLevw1ltvFZG+pYkjs0l9PjIyos9ltyXXCWW26s8bGxtaBquHIxI9cj6MG2pzc9PV18IRYVif\n", - "cUHunlsQAJuRy+Xco7+wuMGO3HTTTWoJMkMQFzQuspWcVWRrjqDs1sIWibIoCNa99tprY+sgsmW1\n", - "8/xhloyZUJF+vyXJlfR6vUDHLU5vzmOJkgLjWRbAMsLdblfLCkufj7hjPPP90Q8bGxtBWZiN4vXH\n", - "lq/ZbAZH6/k3zELZ+eJJcjQajSB3WzabDZ7b6XRcKRMvPyDYJLjpRLZyMkLqgMuPecaJu71Aec4u\n", - "sXfvXhGJslNgejz88z//s4iI3HffffoZAsaPHj0a0f0S6Y9ne7DkzJkz8tGPflREthippaWl4F11\n", - "5syZSFJjkSgbxP2Audzr9QI9o0G6iey+ZlY0DiyngXKVy+WAEapWq0GC4unpaR0n+K5arep7AvW4\n", - "fPmyylp4awar2GMtGBRMjufi2lqt5npbsH5ibFy6dGkoaYNhkDJSKVKkSJEiRYoUO8Q7hpECBrFJ\n", - "22VyvOA6WBq5XE6tJlhHnU5HrQkOlrRWWy6XSzwybUU9GTtRavYYOu+zUqnkBoBbpsyLfRKRIFDd\n", - "i1XjZ3jZuYetC98X/YNARmZn+Li3tTD4aDpYAGY72OLzWAXuT1s+DiK1TAmDpQxsDBJnJYdFhczl\n", - "jMuXLyfGxqF8XH+PqUMfjI2NKZsEluSVV15RyxVSB2fPnlWmhKUn7Hj3LDseN6j3oMBR9OvExEQg\n", - "yJnJZIL29eIdGax8zHFsXgwiM1b2O/7Msr+5XC4SV4nf2bWlVqtpvBn3Mdoc/bC8vKxj1ZMcGKSA\n", - "jrWKWY9BCvl4FuqE/uS4KY4Js3IC+XzeVbYHOCcgys9xTla9mtkMDv5HG3lzHv1VrVbduYLyMTtj\n", - "++iNN94YKhNFp9PRYHOWBbGsMSvvY419+eWX9fAHrz/4ntvCk93hMgyD9fV1ZbMQJ1Sr1YL1uNVq\n", - "BYLG9XpdxxGvhVbqgplsTyoCv9+/f38sey0SfR/i30kxUocPH9aDMZxDEdd6quhgKcfGxlRYlPPv\n", - "oa1wj2Ha+R23kXq7kBSJz5osXsAmOrgay6EAACAASURBVBQDjE9U4LtSqeS68YBhE61yOXcaXM+I\n", - "28x4wdIchCoSv0GywbyD6FK02/T0tG5a4dZaWloKFrDZ2Vn9nhcqq2gdd2Jv2PQAANqiUChoG3jt\n", - "xpuYpBcUn+S0aDabugh5WjcYJ5ubm5EAUHtvvJQymYz2F2s3AVgkxsfHXVfMjTfeKCJbfeglha1U\n", - "KkGKCA/eAuRtEj2srq5q/3qpNfACjJsTfCLNO2Vpy+alRxEJlfJZb45PtnmLPdqG3XToJ2h3nThx\n", - "QjcZ6Jtms6nP4/lvN3g85tjVZU/R8jWcpikpkTHQbDaD5+bz+WAst9ttPY0LsGuX1b1tm05PT+u8\n", - "Zq00ezjl8uXLQdqWQqEQbKTiDk0ggP+zn/2siIh8+ctfDsZBuVzWzS42BJ67m09WY36Vy2V59NFH\n", - "tVwi/bXTO9zDSbfxnTdf2IDbaUYFka2TeXv27BGR/lhDW7POFcrF4xnjiDcd3rzDmoB6Tk9Pq/GF\n", - "eR83XzFO5ubmRCTq2ktaW0+cOKGbQ4yhyclJXUs9dz3GFZ8qxNrKm3VPMT0OqWsvRYoUKVKkSJFi\n", - "h7jijNRONJHeDnjHy+3Os9lsBlYbH4nGd7lczmWf8AwOruaAzbjnJpUzDt7Om8Fshy1Dt9vVcns6\n", - "V7C8ms2mqxyNf7PlgM9gffZ6vSD/HVvMHHgKSwCurtXV1YDW9Y5qVyoVrb9nXSdJSoiE7TKsK7Ld\n", - "bgcJqr378v3YsobllZQgVyRZzwv1ZlaA2w9gDR2PObQHArzxtLGxIdddd52IJAfADwKswGKxGFDw\n", - "rAmGscQq0UChUHBdz8wW2Vxxnkub9Zfw3EKhEATu87jia71E257SN8oFd8T4+LjWifsVfcdjA8/m\n", - "53pMmA2G5+Bw7nN7LJ/BLi97P5aP8K4BZmZmlJHgdkvKg4ZAeXZlsz6UF0Jhsbm5mXjog/vDrhOL\n", - "i4v6DHbZAZ5rFowV54xj2QebpYCfy+8Nuy5Vq9VIWyUFXVuNMRFfSR39kcvldIzBxV+tVuXFF1+M\n", - "PGtkZCTI2Tk6Oqp9zWs46gdJlHK5LLfffruIRMc7B4WL+G7BiYkJHZe8tg4KIRDpu2dRJ/zl/vLe\n", - "qcwec6LoYZHISP3kJz+R48ePy0033SRHjx6VL33pSyIi8sADD8i+ffvk1ltvlVtvvVUeeughveaL\n", - "X/yiXHfddXL48GGVe0+RIkWKFClSpPhZRCIjVSgU5M///M/l2LFjsra2Jrfffrvcd999kslk5POf\n", - "/7x8/vOfj/z+hRdekK9+9avywgsvyJkzZ+Tee++VkydPJsYDYSe9XSXVtwuehelZsxynYWNzstms\n", - "fobdcz6fjwRnikRjrlg6YdigwSQMClBntsNjz6xlFqf+7ln19nf5fN4NprdHlguFgraD5/9Piqfx\n", - "rDO22j2wZW3rwWJ/+MsWNsdN4RruN3zG49iKkjJ7Z8cQ3yPuMxuXxHIUnP+RJSfwF+0Fi+7ChQtB\n", - "jFS1WpXTp0+LyJYS+vz8vPzkJz8JygXm4Nlnn9XPkhgOD3ys3YLXDC/mJ44BtHF9Xo5HHtteH3oM\n", - "KzM0NhiZj40n5ctkBXQrCMqoVqsa14f4j0ajoe3Ac93ej5/Nf+1zisViIDXBB0e4PjYmLC6fJdhJ\n", - "lIXlAWDdT09Pa1CwJ6XivSs4+NcGvk9OTgZs5rlz57TdPHzjG98QkT5bYcUbT58+rXE6NuZLJPlA\n", - "yNraWhCv0263dd7yGsd5SUWiTAh+Nzc3pzIKHlhhHmOiUqmozAPmcrvdDuLSOp2O9gP+Tk1N6bxH\n", - "YL4nKLq+vq5K5ZjD3I547uzsrLYT+vjVV1/VeiZ5WziulQ91eED/o0znzp3T8mCdmp6e1vJ76wjq\n", - "sba2pkw5SzEMQuJGan5+Xgs3OjoqN954owafeo3wzW9+Uz75yU9KoVCQhYUFOXTokDzxxBNy1113\n", - "xT7j7dhEvB3g+ngvPg5eRYeymwsdwpsmb3Nj0zJ4gZv/m2BXCCeIBfjFnBSQm4S4TZ2dEKz+zOWz\n", - "7hl2sXA/gbbFwL9w4cJQ48mrb6VScXVLbFAzuxcGwepDvVV4CbF5UyoSfeGiLUqlUsQ9KxINIkf7\n", - "jY2NBfX1xubs7Ky7wOOFN+xGCuWr1WrBBqRSqegLhTWjAEv7A6g796F1e/MJTXYVWVeil+aFy+i5\n", - "1ZKSYHP5UJeVlZUgGTVvLPjfKD+fOrPGnzc2vXnLmQaSTvHGrWF2MzU3N6duIwQ0eyemPAOMxxi7\n", - "+AHrzmV4bsJut6vuIj65aNsZ89MCfcSGBq/XcVhaWtLy80bJu8Z+1m63Iy9zkX7f43ee4cgn6jhc\n", - "ApsgbCIuXrwYUcgX8ed1nCK4l9IJz8Bms1KpBAdPLl26pBs4BKqvrq5uO2ieQ2OSgD6fnJzUsrAB\n", - "hLrzCUG0Aydzx33Y5TkIQwebnzp1Sn70ox/ppugv//Iv5ZZbbpHPfOYzOmHOnj2r/lGRvq/UO/WT\n", - "IkWKFClSpEjxs4Chgs3X1tbkYx/7mPzFX/yFjI6Oym/91m/JH/zBH4iIyO///u/Lb//2b8vf//3f\n", - "u9cOSvg3DMPxdsM76tztdoOAPU7mC3AyVXYFWLdAHGthg7WHSYj4diBJi4PL7+UcA1jrJCnAnF1n\n", - "HGxuaXmPPWLXFKhVzlHI+jG4HtbRoLHEVqVNeBxnJSW5nFllP4ml4ntY9V92CwHsEmFr0DIz3rXF\n", - "YlHbCrQ6SyJ4bQQrenR0VJ+NoE/P4m+1WkHCVpHQJTrIXY82t6ySSJR1g9XIgdksw8HWvQ2M9nR8\n", - "ODjcSwrMLIyXsQDP8OYSjwnPFWfZrHa7rQwJrx1emwDMHHiMkaeH5v3GO3BjD8h4v8vn88FzvWDy\n", - "5eVl1y0EwA3GbjIe+5ZtGR0dDdp8cXExYFl4XnB7o8yeO4rhaSOBUUkKoajX6zru4F5bXFzUunM5\n", - "PTeVlT9ZXl7W+7GuFtBoNPQ5zAbZrA38b87QYNvSc5MOAspUKpWCvu52u/o96jE7O6vf8yGQJNYR\n", - "4NAYb71FXy8vL+v8YnV8lAUMU6lU0rnsBZbHjQ8PAxmpVqslH/3oR+XTn/60fOQjHxGRrZMImUxG\n", - "fvM3f1OeeOIJEelLr3M8xenTp1WOPUWKFClSpEiR4p2GBx54IPH7REaq1+vJZz7zGTly5Ih87nOf\n", - "08/ffPNNDUr7+te/Lu9617tEROTDH/6wfOpTn5LPf/7zcubMGXnppZfkPe95z1usws6QxMCwYrXH\n", - "DHnCmTZIXCTKZllLmL/3dtHe/f434cX9cIAygDKWSqXAOmXrntsLlhTHjsHygaW0k8MESSrY3lFi\n", - "htfmfIjAg8ekeHIPsJS9uC1mR5KOz9rg5LiyMCOCfyMWqdfrqZgj2mBkZMRVjuZDECL9PrWKxa1W\n", - "S5+Ba722jWPvuAxcxzgwK2xjvbz8j+Vy2bVcOa7GshPMnnhsAgdQW2Vz/h514v5g1ssbO7ZvWVDU\n", - "W5d4vcB98JcZBCvnwP/2WErvcAVf68mCeEHznpwDwPFEYAG63a6WmdkK3AfMADNSzALYmJtdu3Zp\n", - "IDMHZts1iduAWSqMHcS+xMWmep9j3iRJNzQaDc0jB0aXJSr4vjbnHYv/8v1w7eTkpLuegDXzAtoB\n", - "L/5vYmIiCJhfWVkJBE9FtvoO606r1QqYq2azmcii4vmXLl3S+3DMLNhJfm/Yuc5eI29t4bLb+cWH\n", - "xNBG5XJZ48gwB5aXl93+f+CBB+SP/uiPYuuXuJH6/ve/L1/5ylfk5ptv1mSxf/zHfyz/9E//JM88\n", - "84xkMhm55ppr5G//9m9FROTIkSPyiU98Qo4cOSL5fF7+5m/+5v/MdWUxbJoV3ijZl2Y+nw9OXnmn\n", - "WFiHib+zJ7Q4USjroNiFzKNd3yq4LMNsarzBVCqVAp0hdkNgkXmrJzCTEsoOq56+E10yz03mbb7s\n", - "Ap/L5XSx8V5GScjlcm4gMBYbaK2IbC1uBw8eFJFo0k+UvVAoBMrmm5ubwVgsFou6+OI7T2/KG4ec\n", - "zNuWG98nwW46+BnY3PFCjs+4LQBOAcNl8F4snuvOM3y8wwj8ArUuJ64Lb0A4Cbl9rgdeB2z5vXHl\n", - "3a/VagVuXO93/HLlQwlJCv48p7yXJn6Hcbe+vu6ms8HY9soFNz2f+GJY99za2lqwXnj9x2NskPFq\n", - "jederxdkrvCCq0X8uYn2wLV8chHYtWuXm2IH13gnW6+66iq9BuPE60NvM7y+vq5uQWzGer2ejjvO\n", - "ioC1Fn9x2IHBoRtJ6Ha7eviG1ySris5ufIADxj14G01+H2PcYS5vbm5qnVDf8fHxYNwhxCQJiRup\n", - "u+++27VIP/jBD8Ze84UvfEG+8IUvDHxwihQpUqRIkSLFOx1XXNl8GHjBjYOwXSYsk8kEsgb5fD5g\n", - "qfjob1LQNLsPAc+1x/pFnA/L0yV6KxiUtNQGCnuWaaPRcD/36G5rOfBxa3ZNWJdOLpdzNYLQ/4PU\n", - "ZllaQSQ+cTOXC9d5yvbe/e3vOp2Oa53aMcjX4rtisRj0CVt3Xi4u1InbnettZRI4XxratFQqBS7K\n", - "Tqejz01yycbNLfQNLL84QKcHbhqG51ICE9VqtQKmptfrRVgnT5fMMkLz8/PqiuLneO45227tdjvo\n", - "a09egPua5zUsYO7XJO0pgNucx0ZSsLmnc+XdD3VkXTLPbcgJy725YdlEri+PVbArniwA2paZfzwf\n", - "Ad8i0Xyoln32+s9LHM9gFsqTg7AJlHft2uXOebA1YKZOnDihEkJJ7nwvUTFL0Fy+fDmQhmAGCeN9\n", - "kJQOu4fBRHEOPWanAOvuW19fj8gZ7BTo/4mJiUDnrl6vu9IjSfI2HgvN71GrX8bgDAJWC2wYOZc0\n", - "116KFClSpEiRIsUO8Y5gpOJySiWBg7+TLD3eeVvBSI59SvKrs4XjSSLw/a21w0wYLJbV1VUNgoM1\n", - "PqxwaVx92XK1wmRcBi/A2xMoZQvOE0xLCthkkTkbBO0JmQ5SLGfYmAyvHxqNhrIiaFcO/uSDALYs\n", - "cUr0XkyWZc/m5+dVVw1tHxdHBSvIi0vBmGBGgi1vjnnBX8u2ViqVQBCx1Wqple0xf16sD89LlmXA\n", - "X48JscrLDDAXLG/BAcNJx55Rfy5roVDQtkTA+Llz5wLrlWMHef7b/ucYlCSxTl4T+OCAjdPiIGOO\n", - "n7TP9cZJHMNtGZdWqxUwCJ1OZyhBUY5VwfO8wOJMJqMHkJCbbt++ffpvjiuDpe+pjzPrZRkuZqTw\n", - "2ejoaBBgzfMT5eQ6egwDr7d2fnOfow2q1aobw4XP7r33XhHpM1KWXeb+wb83NzdVgxHzgiU5NjY2\n", - "gtikCxcuaO4/jO0LFy4oI4wyT09PB1kMeDwxq4RAfHx/6dKloD3q9XpwCKPb7SayYbwW4d5g4dbX\n", - "13Xeo8/j3h+Yc15QPebMxz/+cfna174WW5YkCZi1tTUdn8PKuIi8QzZSmUxmx8HXcUq/9vRKp9MJ\n", - "Tgx5C3ev1wt0pOy9udwi0VQs1vUUdx8Mbj4tlLSZss+KA7srk2jZyclJLRf/zkutYelzbgNvovFL\n", - "wgaPDwoSH5SCY9gNF07VMDCZWO8KtLbVfxLZepFms1mX5rcHC1g9l9vCujLZxeKlMEH5ZmdnNdgU\n", - "n42NjWn/okzsrkDgZLPZdE/3JbnQ7QZNJGpg2ID2XC7nui2T1KExDnbt2hUkRPZemrYMtt06nY6W\n", - "l/VrcB+8QNm1khR83Wg0IsriItHNhhfQjvvxxtc7Mctj22rtcKgAu8PtJoyzBfDmBeWDunen0wkU\n", - "9/m0LbC6uuoefLDzbGRkJDA2eY55ekjssuMNHu5v14Jnn31WX/Q43eeNB0794p1C816MnE7HzgHP\n", - "DRq3Tj3//PMiInLgwAH9zGYBmJiYkKuvvlpEJCIXhHKxawlrRrPZDMrFfYjTgoVCQdsE97t8+XKw\n", - "KdjY2NC2RL+22229H8aJiLjjyep0VatVXT8xLzzNtVwup/OR72fXLA/tdluf6ym0o5w/+clP5J57\n", - "7hERkUcffTS4j5d4Gm22e/dudW/iWcOECaWuvRQpUqRIkSJFih3iHcFIDdI8GfZagFWHmUVhut3+\n", - "ji0WTxHYUu8eFe9JLHhUPD8PO/RByY09BsNDu912WQfUGW6XpaUlN18RgHYZHR3Vz3HfYrGobgMv\n", - "aJn1XmxZPBcq18k7ypsUWD4IcBcwe8IMIihn/sxT8EW5vWPKuJZdCqylA5bojTfe0O/xXA7+Rflg\n", - "QYJNYYyNjalFCKttc3NTLXM+ip2UT80DuyM9GQpm3FBmD3BdeEfFAa8vW62WO755/tjrPFap1+tp\n", - "WZmJQhuh7ZkZ5PuifWGBx7E2tkysg8NzxZMpsM8dGRkJAp6ZpffcdJh7uVxOrXB28Vi2hscYM1O2\n", - "Tl6QO7MUfB3YFYQMcDu++OKLItI/xg9GCnVbWlpS5g/1qNVq6v4C4+SVZWJiQr/3xiCPWdQTbcCe\n", - "CYDrhX6OY/PRbw899JCIiBw/flweeeSRyG8uXLgg1113nYhEGSkweOzyRNuPjIy47xSM1RdeeEFE\n", - "onpT6POVlZUg/+Hy8rKr3I05jjY4ePCg5lBEP8zMzASs19ramr478LfT6ehcQdnr9XokmTruO6xc\n", - "zTB5aR9//HH57Gc/KyJb7ff000/r9/jMS2R88eJF90DLIKSMVIoUKVKkSJEixQ7xjmCkGIPihIbd\n", - "2dpj6L1eL1H9Ny6g3F7Lv7G/42BtvhZWAFs+NvZhEGswLENXKpXUEoDlwkHwnGSag4bxDFyLnbyN\n", - "sxAZfCAAdfesi2Hr4TFXzBZ6IqgePMuSrXHLcGQyGdePj3InCTeyT57lD2y8FseRWDE/vh8zoSyJ\n", - "gLKA6VpdXdU2QH9NTEwEMVxxCvE2Tozb1DsmbWO5LGDhIk7k6quvjljmIn1rEOMO7eiNNRGfyeEx\n", - "ZtnnQqEQSHawJAKL76JNWIjWSiyMjY2plcvsLVgvfpadx81mMzjAwfMR4P+Dqbl48aI7Dzx2zNYt\n", - "l8vpGPNYfk8qgg8beOwI2oMD2zF+ef183/veJyIi3/ve90SkL4eBWD+sL61WSxkVPghi5/Lhw4fl\n", - "xz/+ceQzZhkH5UtDW/E1llnjdsE48JhHka3YIjAgMzMzQRB5o9EIDjZ0Oh39N2IDefx1u91gzE5M\n", - "TARzguvBYxd9iJRty8vLWlY+YIRnYOyurKzomMZ60m63lXXCvM3lctomPFeS8lcyi4+1IimXHjOF\n", - "gwLAv/zlL4tIXwtTpN8PGEcssYDycVxaXOaGJLzjNlJJ2ImadZJLjN1unvYR/86e1uHfcICpl3LE\n", - "lpv1Q3ZSN+uO5PKza8877cSwaSpY0ZoDs7d7EGBQYuQkeHpedlMskrzxzGazEfetSH9Bta4zkWhy\n", - "WfzeJreO2/xZ9yZvHPmUJP7NitAAFjTv5KJV9eb68bWlUilIEDw5OakLtjdegLGxMb3G02dh4HnD\n", - "pj3CInzttdcG37G71HMLx40TWwdepPEi4JcPFlDvJJ9IcjA66lur1dzgV/tS4hehVw9eQ2wqDL4v\n", - "+m1kZCSiAYbP7EveC1SPc4PzeEO78ObGlpWBIF0EMYtsvaSxyV5dXQ1cuWxIJB1EEAkV1b3fr6+v\n", - "6wlCTy0cqFarrmGbFCIwSKXeGmYnT55UHSkGJ9MV6a8RdlzxeCmXy8GmaWVlJTDWeLzbwxoiIq++\n", - "+qqIiOzZs0cNGi4fNlze6W2uG1yFfJjIriOcHJxhk9fzePf0vLwTycPiscceE5H+BhLzm0NWMM7x\n", - "mbc5HQapay9FihQpUqRIkWKH+JlipHYC1p2xGjT8PWuAJCUjtteJRAOVAb6HtRK3s+v2jvd62il8\n", - "bJe1UESiOl1gRRqNRpC4lq1ittqtBcX1ZPrWHnu2/8bvbf1Z5yqJBRqWtet2u0GeuV6v59L1Htvm\n", - "WaNsmQGeZcPSALg/WA9PywptVigU9N4oE5cNv2fmhPN0oe/Qz6yRlaR6z+woJ4dN0mIBhu2P119/\n", - "Pfgsn88HVio/A/WwyV8tut2uWv3oD9aygdXuSSuMjY0FyVkzmUwkiB+w44QPUnjK/0lzwAsL8PTE\n", - "vHHIgdSezhXDBqgXCoWALeBgeJSBE5ozrCL05OSktt+hQ4dEpM9qIHwArBG7vPm++B3Xw7rVz549\n", - "GxyGGcRqAaVSKVjzOfzCq+MgPUOwrEePHhURkR//+MfuvEI9OBQB/cmJjzG+Z2Zm3PUE1zMDZ5nV\n", - "+fl5Xduwnpw9e1brCRaqUCgEDCy/79grA3YKbtzFxUUdJzxvmXED7PuQxx3AEis87rCOJamNHzp0\n", - "SJk3sKPnzp0LxjGvK0myC8MgZaRSpEiRIkWKFCl2iCvKSA0KDt+u1MGwiBNutP5vjpHi4G+bj4rj\n", - "dfheSXFOnuSBjYsYBp4Ctc3nFXdPvhY7fY+VSVI273Q6anHjeeVyOWCz4tgOK4LKbelZ7W/XWBjE\n", - "ZAAoC+II2K+OupXLZb0fs3be2Ia1iO82Nze1zdnatQH5vV4vovosEm1TtrJwLazjq666KhCy46D0\n", - "OHV1kSjr4al2M2CdbjdYs1wuB+OYcy6iXVZXVzXIFeWK60cOckW5vXgnVkq2zEatVguuYcFLgAUl\n", - "OVbKrhO8nvD6Y9c5jnNBmUZGRvQZ3O9oG09CgfPR2d83m80gBoXvC0t+dXVVy4W2RyyUBVgnMFK8\n", - "loBN4XUR8Uuzs7PKSnmyC8xOWObg/Pnz+lyoqMflvrTwFNq5DB7rBBY/DpivCJQXCZnDbDYbrLO3\n", - "3367PPXUUyKyFQC/vr6u45vlShhYe5kNtvPv3LlzOo5Z0NSuT5lMJmBgS6VSwOjityJbTHw2mw3W\n", - "GH6/e7n5mLmymRfW19f1M/wuLrOBRa1W09+h/by9Ri6Xk8OHD4tIX4Ee2L9/v4hE5WgG4YpupAY1\n", - "ytvx0oxL1eI9i0+04Hd28HKSYS+5JW+8LD3vqUD3ej2d9DvRQUoCT2Dv1CFrQXEaDpHoIsjtYTc0\n", - "xWJRr8HLcG1tLQigbjQawYJSLpd1sUoKDu/1eon6QcO6kNCXvDDj+a1WK3Alzc/Pa7t4Qat8msye\n", - "OhEJXR25XC7QKuIy4CXnuc44sJgXf9su7CLAPWZmZvSlit+vrq5u+2WTdDCDF9ztbqS4Puyq5g0U\n", - "gPb1lOlFtl4UvOijHfCS4GS6rCCOdmNXEq7BC6NarQZBvLzB402GFyyLNuRn2PHLc8HLLgCwO5LT\n", - "L7FGFeCNT4APa6CeuC+f1EXdSqWSu8nwTkAB2CjxCU30O58+RHtzPfhZmAOsTo3Tn9hIeSrgHtbW\n", - "1iJK74BXN2vwxQEvYdRxeno66LtcLhfMb14P0I7s8j59+rQelgC4/9G+XtYOEXE3SPbUdLPZ1BOh\n", - "WMvr9brOEdStVqvpaUisgRykjQ3V2NiYPsM7oe0dXkDd2Zjg0ALvIIs1gBYXF3UMcpkwjrHGLC0t\n", - "6TjBhqper2tf3HzzzSIi8txzzwXPtEhdeylSpEiRIkWKFDvEOy7Y/O1QNo+DDfaOUye3LhZ2H7AG\n", - "jQ3c9HbTce7N7bItg8BMCKxhlIutd3Zb2ABvDtLlgGdr7eZyOb2GXTb2ucMqajNYtsCOgWKxqM/g\n", - "HE+cv8uWiWH7h6ldT2uJlc0B7i+wFLDMWR+ImRAbRO65drit8JnHKDWbzWDcMqsAq41dO2izuHyB\n", - "NjDWQ6VSSXQRemAXhlWY5n9zni5YwnHBvlY3iJkyMAMe8+v16+TkpFr8sFI3NzdVroEDWsHWeBIL\n", - "3lrF84zXDJFoX+PfzEhinPI9+OAA8rwxo2EDkJmBYx07OwaYveNDJZ6bCW3PDCOSg4NB5HbGWOQg\n", - "ZzArrE4O1ogT6N56660iIvLwww+749b2sZdAWyScwzz3GCjfoLCLd7/73SIi8u1vf1tE+mMDUgLc\n", - "B1aeAcrkqCfgjSdgfn5eWTiAc1nieUtLS4FMQqPR0HcC/p4/f16fDXmDsbExVaDHenjs2DFluFC3\n", - "yclJZbMwrhqNhjJRXpuy3hzWAlYTxzhHG3hudZGtPuH8hZY1ZvcxK75jjmB95DAI1A1jOAkpI5Ui\n", - "RYoUKVKkSLFDvOMYqWGZKC8/3LBgBsmzwj2L38YOcdAvx5hYSynOyn+7mCiA41Y4gFmkb3XCYuGg\n", - "b8RJDauuPuzvOKv2sHFhNk6H+5XlHoYVB0XfwJfebreD/FGMQSyGB1sWPjYMcA41T7bCUwaGVclB\n", - "msy6wcLEZ5cvXw5YOY6HwXM9dtRrC89qr1QqQf97By64TmBYvNgHZkKATqejbcVB8xzzxuUR6beV\n", - "jf/jtvSENIG1tTX97fXXXy8ifYFFe7SaWTTOGWdjyrg9eH1KEsnEPTiGhqUzLDqdTkROgOsistUu\n", - "XF+v7pwbzZaBpTMYp06dEpFozkXb/ysrK6quDXmDqampIPiay8TH5HntAMCYcHydlX7gXJrMLts2\n", - "3LdvnyqQe/IxnpQFAyw0+pd/j7WGY7M49hLzAs8X2WKiKpVKUNZarRaJFRPptyXqjDYYHR3V9mIm\n", - "DOMWfVmpVLSNINbJdQLr+swzz+i9AR7b3PbsGUgCGCEwf0tLS5H1C/Wwh3V4jQBLduDAgaAe3A9g\n", - "3brdbpDl4/Tp09o3uBZsWRLecRspVKrZbA6VwHAnQCe1Wi03fYOnEmwl/wuFgpug2F7LJwy2izi6\n", - "2gM/1y6CnU4nUZcDGB8fD6haTnHjuWfYbWCfwfQtn3DyTjtxWUX6E48Xe4C1sUSip6fYdYJ7ey+d\n", - "YcEqvN6GISl9jp3AIlFNGCywvABgcWaXK/qDXyL2hXzx4kVdHDBeqtVqkL7D2/x7L45qterqJuHe\n", - "/PLy2sWmP7L/FumPG29M2vqKRF/c1oXFGzKeKzY5a6PR0Pvg9+12W9ebkydP6nPRZ3ySz75sWEMJ\n", - "4EBg7zSkF7bAIQM2PZOIr2tkle25D3kTbsMHuK3wXG+NiTNmbcqZSqUSuFg6nU5w8u38+fOBW2hj\n", - "YyNwfx06dEhdWXzYgJPQohzoV84iiAAAIABJREFUN+5LgA/P2LVw9+7duiZwmw67zmIziXHKp+l4\n", - "s+idNsV8RH9NT09Hkj3b+bC4uBhot9VqNR0TaLf5+Xnd4HuHZvg96iVd905p2hOhfLoTrjA+XMHZ\n", - "Pbx5bdNBZbNZnT+479raWvDOr1arej+0b61W01OCcAsykcDPt2XxDpgMo3SeuvZSpEiRIkWKFCl2\n", - "iHccIxWXLNKCLQjrihvWncQWPyucW8qeWRT+zqrmsg4GdvLbzVPH2I7bki1MTwsKFgPKNzMzo8F7\n", - "wCuvvBJYBFwnrzysqI3nern+gHK5HLgemdlIchsyNc1WsxfEC8Dq6PV6QRsUCgW1aPg4cFL5OQjX\n", - "O7LOR4P5viJbtDsncWXYZMTZbFatRU8TzKsvPmu1WloGPi4PizTJhc4BrfyXA7JF4sf2MO7yQqHg\n", - "uudxLefL4vtZ6QW2OD03Hn5/yy23yLPPPisiW5ph586dC8a0F2Sdy+W0H5iZsgmUmeFOYoFwT5Go\n", - "y9Zaz3yEnTMIePITSbn2UKZ6vR4cCGk2my5T5h0sADuCcb9nzx7tJ9YC8rSbcD/W0kNQP+YC9zMf\n", - "BOG1DUBbeQmck9bNcrnsfo+6J117/PhxLRd+t7S0pOwIz0eoiXMwvm17ZhK9+ciadmj7RqMR5Ow8\n", - "d+6cuqHf8573iEifOUMZmEHGs22iZQsv5ABlxHN37dqlcw6fLS0tRSRxUE8wbxgvY2NjWmbOWYpn\n", - "oD9brZaum2CSNjc3dQzC9Tk7O6vjB9fm83l3jUYZ8G6I081jpIxUihQpUqRIkSLFDvGOY6R2giRG\n", - "wvudxzTgWhaKY2bCi4fiIF78tWzWWxUdtWWOU223x1/jAOvz0qVLierfrKjsHceGFYayxIk02nbw\n", - "LL5hBTnj6uZZFF6OQq9sNhYgLp7NSmKI+OMIFlpSHi8va7tIOI6ZFeDyJTFR+Lu6uqptAOZobGxM\n", - "rUUICnp15LKyhIIV1Yurg9cuVsVcZMsiTAr+Z1FX1IHr5AVVe7m9nn322SD3GN8HiFN3xtjjeBL0\n", - "Nc8L2+9xSvhWRZ4D6nE/vhbzY3Nz02Wc7f04YBzPrVQqAQNfqVSCeRUX+wag/zlgGc+qVqvu2LJs\n", - "ZrFYlJdeeinyG7AWItH1BGsbMzhgHcCqD+vJqNfrQbxrp9MJMg14uPPOO+VLX/qSiESZMBbaxX29\n", - "9R/zHvNyY2ND477iBFnxOQsLY91mUUpISTz99NMisnVQQsQX2sX9OCaQwdk/8HubbaDVagWxSrw2\n", - "YK1pt9tB/lCvvl68XiaTUcYS44BjyxDvVigUIrF7ItH284DxZAPrPbyjN1JJGx+G1UuJmww2maEX\n", - "WM5S/Uy7cwCjiK83xfcedPpjWOB5LMufdNJLZGtg8IuKlYxxH5ygYO0RLw2IdTkUCgWtH5+y4cTP\n", - "eFbSBinp5CW7dNjtikUoKaAwn88nbqA8DKvCz/WJK7eIH8CIzxqNhrYVFlJ+QbPrE32JhdFzCYpI\n", - "8HLd3NzUxRX3KJfLrioygAWIg/XhUuDAYu8UHcDZAnh8WlcRnxbjcWDno33J4//cD/ZAA/cLp4NA\n", - "G/IL227C2ZDCS5r1mlD3bDYbJPHmwxUcFmDHOW82PSOF54fVcOMk0577zgt29xLL4sXHAcODkqpj\n", - "TWB3lQ14LxaLOkbhktnY2NCxj3Qvr732mo55e7pUZKvtX3nllYhrUiS6+cNf3rwkGVEXL14Mxkkm\n", - "kwlOuHlYWlrS58HFW6vV9GWNzRXPLcwZ1gnz3k/efFxdXQ1c8XxQBWVutVo6x1GWq6++Wt2QuPeh\n", - "Q4fUlYe2X1hY0OfhfpwSiceTPSm5urqqv8NGdmZmJtj8lUqlYH0qFovBJifOyLYGpve7VqsVHIbJ\n", - "ZDJaPxwS8DDMQazUtZciRYoUKVKkSLFDZHpvt2DRMA8dInjr/6oMXvWZQbLWrGcZ8lFiDnxkyhy/\n", - "t8F3mUwm0DfhgEwupw1U5wS/Xn2y2ay6KWAt8PHTJEX18fHxoY59MlD+arUaMG5e3j9+vsdSDAvP\n", - "XcHfXYEh7iayFvGPpAOcIBdWM6z2l19+WT8DC7S4uKgWFQIt7ZF7ANYw+qhWq+lYxHetVkv7PMkt\n", - "WSgU9BrUp1KpqBXLFqlFNpvVa5gRgGXNeRvxPAR/r62tKVvk5bdkFzueUSwWtU6YA6zqDuzevVvL\n", - "j7E4Pj6uz+Mxa3WQbr/9dnn++ecjdWfwtTaoml2HSWsSB6V7uftQn7GxsSAJNjO/ljVg5HK5YB6O\n", - "jIxEpCRE+uMEaxr6eH5+XiUJvABvgNsZ+OAHPygPPfSQiIjcddddItJnpHA/jPGLFy8GrNf58+cj\n", - "mRdE+qwHuxVForngOKgb7c/sPCeyRn2sq5jlLRCYXS6Xdb318qeCzd/Y2AjWqfn5+YhLGWCpExtE\n", - "Xi6Xta2ZDcb6wKEZ+IxZxRtvvFFE+rpQuJ93WAcsIcocx95YTSsP+/btU5Yd7Nfq6qqb5xLq6mDO\n", - "3y4vzk6A9TzuXZIyUilSpEiRIkWKFDvEOzpGapiAYZHQ0uN4DFjAvV5Pd+t87N7G9bCvnQPncA1/\n", - "BouQn2fz+LGgJft6YTHy870jzDamJS7fmed3hzWTy+UCP/MgNgp147gaWAyDAjs9NsHLb5ik9Ozl\n", - "t2Mrz2O40M4TExNqoXGMkY1HaTQaem/Ez3Q6HbVEOV8erM2k+CCRLf89ypfL5bRvmE2C1cbB12AB\n", - "+Bk2SNdeI9JnPdAnsOS9nIqe8F6pVNI24KPWrIYsEu3TOCZKpN+OlkG4fPlyEA+VzWYDUVDOD8b1\n", - "5TlnVdM3NzcDFjCXy2kboR7nz58PYig5VornNyxuMBFPPfWU/g7PajQaroCmzavI8SY8ti37XK/X\n", - "XfFNO0dqtZqymGApOp2OG2tl2alsNqt1R7+ura3p2Odcep5qP7OdIv1xYgUxvTHG6zfa9uqrr1ZG\n", - "yjJEIluCnBwPhbJ7TDCPEZTpjjvukCeffFJEouPJBlKvra0FivBcFoyDp59+OvAQMEPIc9/KUGxs\n", - "bARrlg3qt/Oa13SsP6z0Dybp7NmzWl5mxcBEcbsgTyPGfj6fD/L5xcFjomxM4OnTpyNi1FxflAEA\n", - "q/jT4MEahHfcRsrbvGACc9AaD1T7GVN0XnA4axbZjRQHcwKc4oInEv7N98BkYnee3QzxwGENGvsC\n", - "4sS9fCIpKXksB7IOe5LFgz1lYWFPbrESOX+HCc5t5FG4NkUMLyIc1I/y8GKEa/ESzmQySnvjPl4S\n", - "WQYfJrCHDdjFMiixrw2O5sWRU5hgw8PJTPE9U/YYR9we2CR67egdHMBLwqvvgQMHVNXbaqWJbLVp\n", - "3AlPq3q/uroaHMJgdzPGZrVa1fHJLy3WS0L9ue7WZZLL5YKgb3Z1cV1wH97QsDsQ94cBAtfE2NiY\n", - "9kPcBs+CFaG9QzD2s9HRUffkq90MTU9PR05N4TcYOzzn0dZWDV5ka5xUKpXgUALr6wGXLl1SdXK8\n", - "UBuNxsDQAxGRH//4x/oZ2uy1117Tzzx3tXWvMvjUq103GMViMUhAXSqVgtOMnMYJ4HGG5/FY84Dv\n", - "RkZGgg1wu90O3iv5fN49ScfwMk1gA4I5sn//ft0MJZ1SE4kenHirKJVKwea/0Who+bDutFqt4MAF\n", - "byJ5zGD+e2mIvLbnvQHanMcuxiyf9rVr6jB6jalrL0WKFClSpEiRYof4qWOkmMlhi9Vq5zA9zwrC\n", - "lqVi1W5mn6yFxDtWpnaTGIYkBVxWQOe62eSXHnOVzWYTpR2YwsZOHn/5956C8LCq7iJbFiiOQnN+\n", - "K3xWLpcDpqLRaAT91Ww23bxXKGPSEdNqtartxhaVtWI6nU6Qj65erwduV9bVwe8mJia0H7hvbH8x\n", - "C8gYRg/Mc69ymXGke2lpydXG8tTd0R6sFmzZkUwmo98zI5GUUNTLm4g+7/V6ykTBkltcXHSZA9QN\n", - "DAu7rfFduVzWenIyYg92Plran1XJUUfLSDPw2dTUVOAi4gBl1rlCG/Ixedu3lUolVjvN1sPLH4Z2\n", - "5/lj16xisRjonG1sbESOlaN8dn5xcLOnw4X25/FntcgYnU5HrwUj1Wq1dI1Gma+++mrVkULbg/ES\n", - "8VlXjCt2g3KZwayiHbk94SL3NOYuXbqk1wL5fD5Y1ycnJ93xiGDoJKyvrwcuO9ZDYuacMyrwd0CS\n", - "BqD3nkIbDeuaGwTWNMN4Qvt5TBe/e731EX3DCu18CMNT1LdM8vT0dESyR6TPrGLMsEo8WCw+1INx\n", - "lqSZOAxSRipFihQpUqRIkWKH+KlhpFhQ0opz8b/tTh7XiESZBo5ZsSwVW7HMpthd/aD4JX7+oPgm\n", - "kb4FiR0353izO2qWU+AdOCwMVlr1FIs94bykY/fValW/Rz9wQDGshWuvvTbi1xbpW1woFwebD8PQ\n", - "sAgdwIKHDGvxeFIH1WpVrTlmRwapq8chn88Hlnwul4uwK7g/LG+OebLxAVNTUxrEySKDtl8LhYKK\n", - "5XF7g6XgtvVYAstwlEoltf44pgRt5fUV7sF5ujB2e72extWApVpdXXWZLVs+jvuAxcmWtpUCsWBp\n", - "EpF+G3P5wbKw1cmxLiL9cWqPaq+urkby34lExwsr71sG2ZNE8dhHjk9kxtmOE+9+zWYz+B23N1Ss\n", - "mfGzMV8M7zDJ1NRUhB0SicZmoQ08hWkRP+YSc8XGLvJ3zFyg/zhGhmUfrPimyFY/gY1k6QOMU1sv\n", - "kX7fQ5AV92UG1ovr4tgsPOcXf/EXRaTP/Fjph263m3hoBuB1kNfvJFFiVvAeFmjza665Rucd5y3E\n", - "vED7cp+iHbjtk2KuvBhjryztdjsYq+VyWdsE68/o6KiymXguZ2jA79rtts511If3Aaj33NycvieS\n", - "FOuHwU/NRooXVxu466UI4cBt/swGN3on0jhwG2g0GpG0EyLRRRoLgbcosQuI3XOWmqzX64FKb1yK\n", - "CC9Q3abl8E648YkfnsA8URHIzAlCUUYsSisrK9veeHjAIBeJbpZFfDrV20R5pzK9l7+3CPLpL4Dr\n", - "mwTvFCBvrrFoxpUbwAI/OTkZbLg7nY5ObA4sxwIA6txLoBsHu6GZmJhwNzkYT0m0di6XUxcGNmGj\n", - "o6O6UcFCe/nyZf0dv8jsRnRmZsYNfLa/Hx0dDU7ysZsW9WGXiEh0AyUS1V/CHBgdHdUNFPpwbW3N\n", - "fVFgo+htPAYlHOcxIxIds2wA2bHI//fSxjDQNtgotNvtwN3iqclvbm7KsWPHRCSqI2TLzmuAVw+g\n", - "Wq26p7ZsH7PyPso+OTmpYQMcuG3B85vnAtqFP8O9Uf5msxkE5l++fFnd6Qg6f+WVV4L6ch8g6e/X\n", - "v/51/YzTrWC8eGObtbc4WJrrYJ/H2l3eOmbH+yDgfXPixAk91QedrkuXLrkJtIfB+Pi4XsvzAp/h\n", - "PcB9BD2qSqXiZsewrt+9e/fq+OD3GSeUF4mOT+/d4WUuwYY7m81qGRGIPsypwdS1lyJFihQpUqRI\n", - "sUNccUbKHmf2FKGZBfDkBfhYvQ1u63Q6usO02h14nkh0F82qyNjB4zPPCuVjnrDkCoVCxPqzz0O9\n", - "y+VyQCtyQDMrvlpGgo/2c7t4LkwGB42/nYBlVqlU1BKAJc+sohcEzzoowzIvANo8n89HAphF+tbM\n", - "MLmSmClB2fkAAlv8wCClXfT1TTfdJCL9RMAYPyhznAQF2ARm8ZKU6JMORbTb7YB1Onz4sFp3SbT2\n", - "7OysloHlEvA8SCOIbLFBVlWawZIASXo/rH3E7I09mm7ZEbRnUo46DgDm3+NeLAfgMVG2rflatIHn\n", - "SmIcPnxYRPrMgA2g9YLIvQB0DtJlBgdjh12BNt/o2NiYMlFevjGPkUC7eG1y8OBBee655xLrDKD8\n", - "YGI9lt9TbWdgjeAsCmDE2JXNDBjKz2MC6zr3l/Uk8JrPuecATq5sXVk8VsB+bmxsBEH9XEcOuPZk\n", - "XoC3Il8jMnwQOh/wEumvAyw/ItJfP7H+Y1xxOyd5Fbx68DuA1wzoXJ04cSK4Bm09MTGhDBjnFsW4\n", - "he5XrVbT9kf5OGQE8ibDIGWkUqRIkSJFihQpdogrzkhZwTRmpDyrk4N5+Wgw/nrWixc3ZRkuZho4\n", - "OJzzMvF3FlYVnZkhji3wBEOtwKMXZF8oFCLBmXiWZeA4SI+tIbAJ3lFSDgqE1eFZEMViUS09tMvG\n", - "xobGIcCqi7PGYaF4FiH6kNuX46tgmaEeo6OjAWu3tLSk1k1SjEKr1QrkGbw4Ie8eIyMjQT+Njo4G\n", - "SukiWz52T43bkzIAWP6CjxnDguc2SmKivFg0BMvefPPN8h//8R+x1wLz8/PKsvAYh0I1sxioU1LG\n", - "gXq97s45q57d7Xa1r3l+W/FIFuHlMjCsACgzNAwbgM4CqhwEa4+hMyPFeek8JhTBzWxRW/HNer0e\n", - "xCOtr68Ha0ej0QiCkVmyAe02NzenLLQnEcAClgD6kGPHkoLN40Rd7cGCTqcTUU0X6TNoSTkAPUV3\n", - "vq9d8ycmJjQOlBkpjGPUt1gsKjP4+OOP6+/snOL1zKsn8iyKSMCYMlgqhMU5RfzMBDzetxtUvhPk\n", - "8/ngYBa/Y9DO3lp58eJFLSvHSiblnsRadPbs2eDQFLcfxzajDaHez/2Le6ysrOgcwP3YQ+TlCuTx\n", - "h3HiHVyKwxXfSFlZf95ssIvKLiJ8egbwdKR4knkn2zhwG/9G5/OmzXPTAVxmTjJpF0OmKHmz5KWX\n", - "wb/55WUHtJf0l9uFn4FNwdTUVIQWF+n3gUfXY9DihdZqtXRRSXIHFYtFfUbSi35mZkbvg3Ytl8v6\n", - "QuMNGuqEcvJnwwZG8gsw6TQMnxJBG+G5PHGBer3uvoywkcKYaLVa7ibXolqtRvRPRKJBkMPCewbK\n", - "tLGxEQS8ejh06JC6itjN7J3WsSdS4zZSduyUy2UdYxhfnEEA/cYLvb2nBcpQr9cjbn6ReL05u2Dy\n", - "eLFrA8MzwjiND14wzWZTT0h5Rh3D6pzxIRIgm80Gp9JarVZEwV+k/+JGv+MlyCdmOaAcGwU2IryA\n", - "e6va7r1s+IQmtz0nbBfpj1MvZMIeEmJg/nrK8PV6PWLQAPbwzPT0tAabM5LWE0/LCe1YKBQS3doM\n", - "jBMvzIHXbR5HduwdO3ZM64R1qdFoaB96p0CBfD6v7zfUqVqt6jX2JPkwQFngfltYWEh0waFurAXF\n", - "xIBt6xdffHHosthnxR0MQRlYMxFGIt5DfJggDqlrL0WKFClSpEiRYoe44oyUpY2ZGWL3i0f5WY0n\n", - "1hkB+Bil9zvW0rG78Fqt5gZCWrar2WxGcgnhM9ZkwvMtS+VJNuB6C8vAcPAh7uclMhbZYpWWl5cT\n", - "c+3BSuF8UF4+qyQMOhYOMEXMrhM8jy1DtCH+VqvV4Ej3oOBJ7mvLHExNTem/0S7QLIm7D7uAPXcV\n", - "mAFmP5NkEqx7izFMwDzgKQIDYES63a5arkkB681mU90KPBeSZCo8qx1lajQaQb+Vy+Xg6Hy73Q7G\n", - "Z7FYDFguVm3nujCT56mhs+q3SH8ceElv8Tu0P+ddY80g637igHYOWrY6bB7LyIHlQK/X0zaEe/3C\n", - "hQvBWOn1esG9Obdk0nF5j30oFosuW23736uHx1qPjIzo+ODn2TWt0+m4Ol0Az0HrPlxdXdW1gJk4\n", - "aFQxOM8fYBkufidxYLlFHGuM8Yl8flwnnqM24Tb/jssAPPPMM3L99deLiETkSNA3LJeDazmUBvOZ\n", - "XfFJ69OwgKvznnvukYMHD4rIVu7E8+fPK3uPz44fPx6EqGxubuqY9Vxx20UulwsC/BuNRuDqLhQK\n", - "OkfBTIGRTULKSKVIkSJFihQpUuwQmV5SsMb/1kPJEsGumVkZT/3XskDM5ABsMXsxCHytlSHg2CJm\n", - "eiwLxMdyPXBgK3bXsHBYXZUDxq0sQLfbda1Day00Gg29N8dmcfvZoDsGi35uN/4mCdlsNoihaDab\n", - "Wj/Er6ytrQ0V3xSnpJwEjkux/crB9YME6NDXYIuazeZQx457vZ4KHl5zzTUiIvLII49oHAGex+3E\n", - "rGJSWfhaOyY4jshjpHAPWLAifiArrNS5ublAAkRkK2CXmQ0wJWBJvKWFmR/Ak3bgz7xgY6BYLEaO\n", - "OHt5ytDvzBraIF8ODmcFd0/cFuDYIXs/DlQHdu3aFaiSM9sCSzhO3NKqZjOSpAJEtvoGfc1zCoHZ\n", - "LIuCsnAdPMYU7TM6Opoofuix5ACXhZ/rlQHwxgQzzmiHpHvs379f64J+a7fbAePMYwMxVcxWe8/g\n", - "eySNtUGAYj3HYKINr7rqqogSPOpuxwLHXLLyvhdre6WBOTU6OqrtluRpKJVKbvYRb61AG6FvWEQ0\n", - "SaEd907KvXvFNlI/TZ2XIkWKFClSpEgRh6R9S+raS5EiRYoUKVKk2CGuWLC5dTXxcf8kdw8o3ZmZ\n", - "GfcoOgL7oA8ClVX7bNDZcE3U63WXtrVuIS/HH8PmrxLZyrV27ty5xEBgT38Hzy+XyxGXg8jgJLyT\n", - "k5NKXXuuvSTXqXcN78a9PH+sxWGp90Eup0FIcl14x7OZTrdUPVsWNrCUn5XNZtVFtHv3bhHZCkAc\n", - "BD5YwO3mJTf2+hGuSZQ5LnCXc8WJRFXxd+KuZRexSL8NOJkyvrPBytPT01oWjF8+2MD38/qf743/\n", - "o414rHmuWIwxdolzjjLcJ0mJPp/P64EMz9WJvGSbm5tDHb7Yv39/JBksAFcN6rG2thbM6263q+3B\n", - "Lopf//VfF5Gt9emRRx5xn21dGN1uV6677joR2eobL4D3pptukrvvvltERL7yla9Efs+Ym5vT8Qm3\n", - "iydN4R0W2dzcTNQJhAuSE3yzKxF9hN+dPn3aDZC+/fbbRUTkqaee0s8GuYhF+q49lJsD1dGW0AHj\n", - "nHxYG1ZWVoL1nedtklaWyFa/YU0qlUr63M3NTXXpWg3EYTCMi5XvN6zHiPUH0a5ezti34oHisg9z\n", - "Hw4twe/faujKoOemjFSKFClSpEiRIsUOccXlDwAvONTL7TQolxV2xcwI2czTIyMjykjxkVjLcHFg\n", - "LAeHA5wbC5YDP/fo0aMiIpHAZu/Ysa0vW4EcDA9LxTuOzLCCfIxBOdsYVrSQP0N92eLylIf5/2CO\n", - "hs1UvhNrBkxUnPhp0v3ssXyPCeHP2eJOYhoZNth4ZGREg3jRLr1eT9kTqASvrq4G/c7WPf7ycXCM\n", - "gxtuuEEDYVkgz2tfW/5utxswZp7Y4eXLl4dSX+50OtpH3L6W+Wi32wGDtJ3YSsz1TqcTMBC5XC4i\n", - "IYDngW245ZZbRCTK+IB5ueGGGwJxS5RNZIvF+PCHPyx/9Vd/FZTLY2G8HKAYi5yf7d///d9FZCso\n", - "fHJyUuvBR+utCGa5XNYxlrR2cFshgNpjpEZGRoIj4cxqc242MD0e62oD4Pnfs7OzgRDi0tKSPhes\n", - "XNx8Qz/Ay3Dx4kUdT1hHmcH08pOifxcWFuS+++4TEZEvf/nLwbOwFs7MzOj7hO/DuUAB7+AIyoU2\n", - "Z+X6YYPTWdaA36nDCLyKhGtjJpPRa/i+VqKIn8XB98NkXoiTwWBGVaTfRigL1jPODMKC1Z4gtM0Z\n", - "yOBgfCuD5P3e4optpKwuBg8sTBbvpAVcK/l83n0RWNcPJ11FEsJutxsk7uU0Ct4mgelU+9xutxss\n", - "OCMjI9qZWDB4A4FnVCoVHQBeMmE8Y3Z21j0NhZcl63Cg/Qap7HJbeakc7O9GR0cjKTBEfF0ge2+U\n", - "2dus2bQcIv5GJelUF5+4sBsQ1vjx3GOeLhk/A+DNlU2mKyKu+2iYjeDm5qYukkh7kMvl1H2Ev1df\n", - "fbVutDEHWq2WO0cAjMmnn35aP3vPe94jIiLPPfecPpfd1sPoyMQpJWOceydheHH1XGw2eXmn0wmU\n", - "/D3XA6d+4Pt4qZD4/9g0YUysrq7q+vChD31IRPrtZjceJ0+eDF7wfOoML/B8Pi933HGHiIg8+eST\n", - "+luUldvQc1ejXHAFZjKZYD4fPnxYjh8/LiIiX/ziF4N78EaFN1pxWF5eVvXopHEwPz8fjDse48O6\n", - "UTA+Dxw4IK+//nrkuxdffFHuv/9+EdmaA0tLS7Haboy5uTl5+OGHRUTk05/+tIiI/Ou//quOOz5d\n", - "asdyoVAIxkuv15Nvf/vbsc/DGvbmm28Gfblnzx5tK17/7e8WFhZ0vqBdWNtwEHitQd8NMpTs9/w7\n", - "GDuFQkHLj012LpfTNR/ExuTkpI7ZpD7i1GmeAcHltHWP0ye04411JwcZLElAOYcZz6lrL0WKFClS\n", - "pEiRYoe4YowUaFWrNtrtdhNdBEk50gqFghw5ckRERJ599lkR6Vtjdgc6NzenVg6sfGaD4tSGRfrB\n", - "jtYF6O2U9+/frxYI675w0KVIn/L2rA5Y5rBIa7Way6jA+kC75HI5Dcj0GKmBQXOkvG6t+zhl62HV\n", - "cMGoITiz1Wq5ejlgEJm5YA0okSgjNSj/Gtgz9AOzoTw27DjxWA0OBGbgGVxmqxXFAeawmJrNpo43\n", - "7i8bmPr666/r9WAcWaGdNcs4D5lIn93AtT/60Y9EpD+erbpyJpNJTDichHa7HeSoOnr0qLI8GDt7\n", - "9uzR+c3zHP2bFBDuWZJ2rqKtWbMM9+QxgXZgbSz8DuX6wAc+IF/72tci9+/1esH6tHv3bq07+vWF\n", - "F15w8y96rjUvAavNPcauDtR5aWlJ1wcP0C+7fPnyUDngzp07p/2eZIWPj48HDBKXmWHzel5zzTUa\n", - "qI32fv3112Xfvn0isuU1EBH57ne/KyJbbbB3794IG2uBcceuZwTN//Iv/7L88Ic/FJGtPuDxAIaS\n", - "c3hiXee6ch8gpxzCOaanp4Ok2rOzs1pWL6QBz61UKgNDNpIUtpPcdOVyWZkjlGttbS3QcOT1BH0T\n", - "l1sWwBj3xjrfm8tkxwmv5ezuQz+yRyFpfQAGMU7s4rNlGRkZCVTWh8EVjZHK5XI6mL2JgUEpsjUA\n", - "+GWExkfFb7755sgpDfzGJgXmDQnuy+KGfJILAxCf8WLnCbEtLCxomeBj540GXE4nT54M6svAhIXP\n", - "PW5w4EQg6ra6uuomimS4cAaRAAAgAElEQVQkuZw4Jsv+nj9DnXkw8iJjn8HxZnjBc/8i1cHJkycT\n", - "k7jy/716eNnS7diqVqu6qfI2ZrbeIv6pvqTyMbj/cS3HwMDVgPHiuRxEoulHRKK+e2/hw/gsFouB\n", - "m8y7P9cfL4nV1VU3HhEvfz79ipNg2BxfuHAh2BCur69rufnED8qKl2Gv1wte/sViUdsK9VldXY20\n", - "L8Yi7jc9Pa3jjeuMdYQ3jPg3yj/sZrLX6+mpOGxszp49qy8XnPiLExbEyxRuQU5bgjbYvXu33Hvv\n", - "vSKylabkxRdflD/90z+NLRdezMePHw9O+FWr1UjqGpH+2LBinzfffLN+j/K/8cYbgTHpvZQYaEuu\n", - "2w033KD388IarIGWy+V0LsNYZPcxv3Dt2nDixAmde0mJh8fGxoKXPxvKWF8+9rGP6bzARuvy5cty\n", - "0003ichWmpRnn31W9u7dGzwPZeUk3dhsesbl5OSk3nu7qNfrQXqcXC439IbBO7lu4b2/OT1TkgGf\n", - "z+eDd3O329V+4ncN+p1js6xoLoeReKKjbERbN+N2DUit646uSpEiRYoUKVKkSHFlGSkOKGWAbsfu\n", - "n3fT2J3u3r07sGIQKCkS1WSCVYxdr3eiot1uu5pCoGOZVoXl6Fk4YLg8qjOTyQT07ujoqD6P0yR4\n", - "ejmeFYb286j2OHiJk206jnq9HuzmS6WSWm7sSsRnSYHblUpF64m6MUMApsF+Hnc//oytTz7lJOIf\n", - "BPBQLBZd16kHz4JLCvoGeKzDyt3Y2NDPMWYPHTqklirrgHFCTwvWoEH7eSkrmJHCeGcmFm2Fv3v3\n", - "7lWLGmOsVqspI4E5OD09rcwL5uva2lrQl3G6Ovic2S/LKrAbFGW3wcGoC2va4DlYV7rdrtx1110i\n", - "IvLYY49FrkO5RZIT1DJYlw5zizW0vGS5DDCRYLW8RLrnz5/X+f8Lv/ALItJniDwtPQBs1rvf/e6g\n", - "LQuFQjAvvPQ9lUpFTzGiPp6b0DvdNShIF/22f/9+dfeBkRwbG9MAeazRrMuVlNLj3LlzwVr+8ssv\n", - "y/ve9z4RkUgSbowJZoHQzmDJX3rppWB8njp1SsvMqXuQiJdhdccKhYI+F6xhrVaTa6+9NrZOu3bt\n", - "SnT9eQcxPK0/II6FsifUOOXYoBCOYYLIRcLT0a1WKxgrhUIhONXXaDSCfueTfJwkHPMf146Pj0e0\n", - "5UT6bW41EJvNpn5m18fEug/8RYoUKVKkSJEiRQoXV5SR8liGbDaru0nPokEMArNRbI3DmoS1NTo6\n", - "qiwLdvSsacJJTr2dJ5gStu5hgXjqwEm+4F6vp3VjzRXsfNnaxmewgKrVarAbL5VKQeCrlyx1EJiR\n", - "Yq0TWxeUScQPrmaJAGuNxB1dPXjwoIiIPP7444llTJIwAHNZq9W0DOi3ixcvBuPIY7xyuVyg/htn\n", - "UXl12a5yL7Oj6Ff8LZVKyk5hrA1KqgkLc2NjQ6/hoHNvbNu23NjYCPR0zpw5o3MJjMnGxobG4aGN\n", - "Ll68GLCwHHfoSWSgH3bt2qWxfmjbV155xbWaWbspCahbrVYLGO5ut6vjF23FTBgYJA589oD7cjAv\n", - "UKvVAs07llhhYA4jkPrnf/7nNRgebdRoNDRGCXGWxWIxdl6JbK1ZtVpNWRbMhYWFBY3jSVLPf/zx\n", - "x3WOg5n02PZOpxNJgi4SPYrPQFnA6PR6PZ2viBdjVm7YoF+er15drJ6gyNaYZk8B5hrYpdHRUS0z\n", - "mKt/+7d/098jXrBWqw219rZaLX0HsdI93ifweBw8eFCeeOIJEekzahwfbDEortSyO97axqy3/Vwk\n", - "9GTwd5zJAfOiXq8HLBC/Z5NidVutVmI2C47HTWKMWCInaQ3FeCmVSromWA3JJPzUCHIC3W43CMQT\n", - "2aJZPY0KBMYy9Ytg00KhEGw2WA8J8Gjt8fHxwB01OTkZlKFYLOoijQDKH/zgB+4JQ5QLE3d0dDSg\n", - "ynO5XLBYeRN0165dAW3MG6E4eBpPVujMg+ciiwsytM+YmpoKTomJhG6PY8eO6SkYfvlaypmDW3kz\n", - "hzGTdMKFdX+AuIzxSZOZF6c48VP+y/dImvyNRmNoN6MHGzAcB++whFdPjFXoUZVKJXXBoO0bjUZQ\n", - "J/5/0kaTN2FYeD2XXKlU0jJj0xGXJonTKLH4qUj/RYW1wtuI4IU2qA9gWCwvL+tLF8KNP/jBD7Ss\n", - "g+6D9kWZ5ubm1OjDunfw4EEd23A5eoceGNg48CYB82h5eVluu+02ERE9zRYHHIy58cYbY+vjaRVV\n", - "KpVI6iIAmyZ+saFcGAf8DPQbj1OsDQsLC7rB9NycnCrqoYceEpHoCWxsJtGXV111lZaBjXLodSFo\n", - "n11KWMP4hCgwMTGhfQn9saWlJW0jlI/XH3x3+fLlyDtkUH+LRNciJhiw3rHLC/dmA5LTaOEza1jm\n", - "8/lA9DObzQZpnjqdjrYH7lcoFLTvuCxYr3G/9fX1RCMh7r2D+9lDPe12W6/x0tGhzPV6fWjx08iz\n", - "t31FihQpUqRIkSJFChH5KWSkstmsUqUIbs3lcsoC8Y7fuj3YArZy+4zdu3ertQEmiYMN8VmlUlFr\n", - "A64HtiaA6elp+cQnPiEiIl/60pdEpL/rtbvmsbGxIOkt07WwYNnK9lwiALNRnhZNHCw70Ov19Nlg\n", - "M9i64sSZgMdcJdHGCwsLamVyW7O6sUjUbcAsD9gJPLdSqQQSBvzvJDqW3Z9of+6rpCBNZts4uNHr\n", - "H+/or2WpqtWqPs8LIodVNsiNw0hKzurdG20/7IGFRqOhfcgWM57rJQrFfMxkMvpvj8Vg94F3KMFD\n", - "UgoHDmRFfx08eFB15rz1AQyOx1yKbLEIzHrhGvTryMiI1hOMeK/XU9cVs+cYTywbAeB+hw8flu9/\n", - "//sissW6DgrmBvOyurqqLiTMr1OnTqmLEIH3ce51qy0Wd3jDpr+p1+suo2vXjj179ui1nmaTt56g\n", - "L+MC+fFu8EIQwKYuLS3pc8EkPvroowHLWa1WA+aKGVhmOuEOtu0tsiUVUqlUdO3Ge21qakrLijZj\n", - "uYz5+fmhUmt5DFLcOBl2PbFgDwGvcWhjZpLtmpbL5fQankcYU3xwabspwrxMHV7dPTkaHmv4fjvh\n", - "GikjlSJFihQpUqRIsUP81DFSuVwusIzZ1wqMjY3pzpFjQqw1zrtuHC/lI6ps/cFiwO70zJkzrko0\n", - "gISYd9xxhzJRgMdQ8G4XFhUzVJ5YIn4/NTXlMjBgojw2A98NA+t/LxQKEbV5kShDlBSU6O3kV1dX\n", - "XUVwWI6w9FiolK0JW7+9e/dqwLMX65MUl8Lt5zF+sEi9WC9PCT2bzSbGPHlHk/G3VqtpzAgrsNs2\n", - "jLMe0abMBnrxWgDmB+d4xNj+0Ic+pGWBpfzaa68Fqt29Xi84wIFn8+/4EAP3zTByFDMzM9qH+D0z\n", - "REmJlhncXxhDnU5HYxnBDMQFvHqwjFq32w3iNE+dOqVyEGC42+22Hq5gRioJWAu++93vajtwrKEn\n", - "2WLru7a2pmOLxwbkBX7t135NRPoB3l7MGdowLlG8BTOSeB5iYFZWVnQ8gZF48803t9X+IlvrFZf3\n", - "2LFjWk6W6rDgQ0LoIwR18+8RF1UsFuU73/mOiGzFOXkCvZ1OJwi45mtQby/pd7vd1nWMY3rBnjUa\n", - "jaFjd5KCwxlWDqjT6QwloMnfY/yxgjsOVHj3aDabQzNhVt6GwXW09cvlckEb8LuHxwzGNvenjTEb\n", - "hpnK9LZ73OhtQNJC7/2Oi4hBmc/nXQXYJFdYEoU9Pz+vA5wnmlVmFklOU+P9Hhu0xcVFnWCsoeEB\n", - "Jzf4pWMn0r59+4ITX4w9e/boi2JQm9uNlLc5qFarkZeaSDRIkoMW0WdIB1Ov17WMvPFhbR+R/oBG\n", - "e2FB8dxu119/vW6kvD73MssD3mkyjxIf9gQk3w+IS9I8DIrForYvK3Czmw/PQNtw0l+0KasFY8OD\n", - "z/h0bBL279+vbQm38fLycuJGFa6g2dnZIHB3O0A90efNZjOihi4SXRs2NzeDNmdXAv7u3btXjh49\n", - "KiL9VC4i0Y0NByh7wPcoX6lUUtc+XDvf+MY39Pfvfe97RaR/Sg3l43HJqTxE/Lmcy+V0LmHda7fb\n", - "EQ2jOOzevVvbDe4hHtcf+chHRKT/ov/BD34QXI9nAPws1ixKypQAo259fX2oDdnCwkJwKpqNZ+4b\n", - "nI7EZm3fvn3qBgWOHj2qh3qSUpDl83l1v95zzz0iIvIP//AP2tcY214dcrmcprrBMzY2NrQNOLga\n", - "v0tK8Ds6Ohr0m0jyBiMOXjLvncLLAhEHGBGoR7Va1fUV42h9fT0SJiHSr6M1vLeTxNkDb25F+v0x\n", - "7P2wnsfVO3XtpUiRIkWKFClS7BA/da49LxltJpPRnS129XE0p8dEIfAP9C2D1ZgRuMi7dzBgsAg2\n", - "NzeVBeAElaBgPZaMrXdosYD+7HQ6bpA5LBrsypk9AFvVbrdd6xXW07CaOyJbLAy7CmygqCetUCgU\n", - "tH4eg4i6cVlgOW5sbGhbctA9yoDfccAmgv5PnDih1iGsax47cLt61uewMgSDkl9690gKfB4WTH/j\n", - "3hxsjr+s68VSEB6T4gW/2iDibDar1j3G1RtvvBG4oXK5nLIn6KPNzU29Bvfj9mOL0yovM3vHbgar\n", - "Tsw6bNuBtdxPnz4duJxmZmZ0jMJNF5ezEu2L9q9UKrpOeDk0MT84Vxw+W1hY0OeydYx5g3WOFaZh\n", - "WddqtaGkLrLZbGKgMuQP4qRTML84GNr7rRdYjjqhjvv37x+Kkep2uxEmX6Tffh4TirphXWQ2CgH1\n", - "zz//vFtm60Fot9sa+gHXJ6vnc9nhEv1//+//aV0xvzAHyuWyy1ajHt5BD6whuVxuaCmTJOTzeXfO\n", - "cXniwIr1DMt6e3IFrOsIxI1DjBnO9erNdctccc5ALrPn1hwm4TGXYTvMX8pIpUiRIkWKFClS7BBX\n", - "lJHyfI5xfnZYRTZGwv4OO1swOSyI5llMuN/a2ppap9htnzt3LhKPYO+H2BEW/WPgPrwLR8A7rHeP\n", - "QWCxNy+GilWs7bM4R94geEHQw+QV4t8xk+QFKiLAstPpaKwFP8OK0ImIG1QPsEWKdkNb8e/xLBZf\n", - "5YBsL2bAMmo78ccnqQ97GBRvgPp6ljhnuffagDOle2rUNui72+0GTOjIyEigxt/r9QJpAs9q43HN\n", - "gny4j3ct2rxUKg08vj0MOp1OxMJHPRGbgmdPTU0FTJ+nRM4HEFiA0LYbA7E5nL0e82J9fT1gnxiY\n", - "15lMRsuCZ3gxfKVSSccg5lGxWAzmJgsQI/aNmUagXq9rnzBDaH/HMYZerCSuPX/+/FBxXW+88Yay\n", - "yoDHZszMzOjnrESPGCS0PccTcowm2pzZWbwTONME+o3Fkz1mjTNqiPTfDd6aYL0aDLT3ysrKUCKc\n", - "g8BrwiB2xZM1sOtwNpsdiilrNBpuHjxvXUedk9Zcj32Kk51Juk/SoShWd0fZvTltccU2UvYF4lUO\n", - "n3FCYUxIDHyRqDsKAx4LjOdqE9kKAOfJhwnGWkx2U7KysqInb5DiIJvNugkl4U7Bon3bbbfJww8/\n", - "HPzOTrRsNpsYzIvfLy8vB+4ZXL9TJG3C+Dv0E5eTv+eFBMBk4knobaTsAsWnteAi4JQu3osWffir\n", - "v/qr8o//+I+R57darUA3y9vQxG2y7MlQzx3N1wBJiZctvE0/XkD4bHNzU3+HF1uxWNQ2H5RWBuAX\n", - "ud28cNsmLU7DnvJhg4MD3+1G0Bv/rGa/HeAab2xjfdi/f7+6NfFsG5yKe9hg88nJSQ1a5+TbAF70\n", - "u3fvDjZLFy5c0HbgoG6sX3gWa9+hT2644YYgwXGj0VD3N8b2xYsXNfSAN00WnU5Hy88B8Cg/q14P\n", - "c/KS04bwyT+sDUmhABsbG7rZ5I2XvV82m5WFhQUR2VqPuX5J69nu3bsDV5zIVptzWhMPOMnH18F4\n", - "wLrMRjbq1u129TPPwGHgJf5WMh0wBs3TYeYXnwzmccQq5yL9+eFls/AO0vA1Iv1xZzNXcD94+n+8\n", - "3ib1u7dGc8JtmyZrGKSuvRQpUqRIkSJFih3ipy7YnMGB1jYnDrsNsFsvFouJwdewAubn59Xig5U3\n", - "PT3tUrV2Z3v06NHACmSLmnMQ2d19XLCjtVK93XuhUNAdMizNSqXisk+DAnKtJcg7b/7O1n2Q289T\n", - "uWYkuSthwVWr1SD3YJyOiP08n88rMwPrFNoytvzWvcBWiscGJTFNDO47a/15ulRx8H6HsqKt8vm8\n", - "9jUzf7B8Ud9ut6tua7R9t9sNNFaazWbEBYf6eP0FVoFVrFFftio9t7VnYQ6DbDarQd1gj4bJLQl4\n", - "1jjKsrS0pGMC94xjC1Bn9MfCwkIgEcB9jXZmloWZZA4bQFls+TwG6ZprrgnWIr4G4JyRzDR6jBDn\n", - "IRPps/1ga3DtyMjI0My1daGzAjbGSbfbDQ6dbGxsRBLJikS9EFgzL1y44HodrBbhgQMHtF3xjpia\n", - "mgrqsbCwEKw/9Xo9eDewFAzGJM8TlI/dr/CWxKmxe2DF/+2M9Tjw+8JqLXW7XVeTybr7+Hdxeoki\n", - "8QfCPLbbXsPXot6FQkF/NyhxvGWaOOCe64Hyb3ctskgZqRQpUqRIkSJFih3iisdI2UBQFt3juChr\n", - "FXuKpoVCIaIELtLf2cJygAgfW3E4Mru8vBzc75ZbbtGcXLifZwFWq9UgRmpmZiawUldWVvQzWCn1\n", - "et0VlISVgOdeuHBB4xe2I2vgwQZTcl5Az9LkQHZPrNDGkrC1y4AV4QV6498c2Ie2arVaykAgXsML\n", - "WpyamlKrHnmq/uu//ku/Zws8iVXy4iu4zJbZKBQKWrekwMS4gxT4nC0/1M07EDAoPgVjC/cbGxvT\n", - "PudxirHPBw3ACMAijLOCkwQ2cb/V1dWA3fPYLQ6GxvM5HoqZNbBEcTkZLcbGxoLAWC/WamlpSe8D\n", - "8chyuezW04oyvvjii/Lxj39cRLZirvL5fBDjwTIpEAf+l3/5F22jpJg2j3WJi3fx2Cvcm+cAngsG\n", - "s9VqBUrP9Xo96LNcLqfrEsNjuLCGcztivcCcGRsb02B9zO9qtapj0GsXG6cqsiUtwzlIf+VXfkVE\n", - "+u1nWSovV+mpU6ciuVZF+syjl1kB8ggYB8z22FyuIslMVLFY1PaD8Ora2ppev7KyMhSbPejwincP\n", - "Dq5Gf3HMIvrJKqFboP44JNBqtbRfeT2znolut+sKcrIUiv2MD3rYucx7g0GMk1cX3BvzfJj4tCu2\n", - "kUKHYnPACwU60zsZwC8qmx5hfX1dT2vgZbK+vq5B394mCJsSfmEgfQReyvxvz/3HHYmXU6VSkRdf\n", - "fDHyu3vuuUf+7u/+TkR8ipWBTuQUMsNsoHiRi3sJ2kA9LzkrT0g+hYNJAr0cpvm9vmFgYWRa1iZb\n", - "HhkZ0bqjzU+fPq16K1hoPe2hlZWV4KQPHxzgl3rSosTBhmgDdnXZhapUKmmdkk6Y8YbBS67slQm/\n", - "P3DgQJBgm0984uU0NTWlLwjrgmJce+21+iJg4Br0wejoqL70cWjiueeei7SHSLRPPcoeyOfz+plH\n", - "0/O1SUmQGUkvjrm5uaD+rAsEZDIZfWFjjL3//e+Xr371q8E97Yt9Y2ND/ud//kdEomMcQdCs0I12\n", - "u/HGG0VE5JlnntHPuD+svlCtVgsOljz22GNune2J2maz6eqp8QtKJJo2CNfaJOv4HW9CROLd1t7a\n", - "ZpW+l5aW3MTI3mYJmwy0y+TkpK75nPoLwFyJS8iMsqC9FxcXdRNk1xwRUdXzI0eOBJpho6OjOjb4\n", - "gIOX7cIexhkfH1fjAO+YXC6n5ffcZMOeeh8Wg5TDvc2Id1DCS37Oa683j73PUBcmGgatBagH4G3u\n", - "2WC1+lV8EGA7mnWpay9FihQpUqRIkWKHuKLB5l6gdKVScXffVtNhY2MjYFwWFhZ0NzxsUlPkU3r0\n", - "0Uf1s3vvvVdERP76r/9aP/Nyrh0+fFhE+laFVfD12KPnnnsuUCdmdwp22ZOTk4muE9R7ZGQksLZn\n", - "Z2f1GUwlJwWRe66AarUaHLcW2bIIYY2Nj4+rvg0Hg3oWA8rNO33cD8zR3XffrdYj3wMWHLv4wDTC\n", - "Ymw2mwFbwOOALSpL17J1xznqgCQ1dB5fSVYbq8Wz5ACuYbqag25FolYejreLbDF/YKZqtZpey4Gq\n", - "YEcwJpj9gEV/+vRpLR8zA9/85jcj9alWq8HxfO5TlCmTyejnaL/tBHVaizAu9yEYZAbGC+cttKri\n", - "tk5oQzDXR44cCVzKIuF6MjIyouOXmR8wKsxIgYEHa7x3717X8n3Xu94lIltrzHe+8x0dM/gbJ+2C\n", - "OQB2PI6VBTDPS6WSsieevhEwPz8frDt79uyJSMmI9Mez/R23M9Dr9XR8oo9OnjwZYaJE+vk1rcYc\n", - "s8GecrUnYcG49dZb9d4iUeYqiVl58skn9TOMEY+Rq1QqgRbZ+Ph4JBhdJOqqRn94B5H+N8DeA7Sl\n", - "F7jNTL2dz+ypwXtgc3MzYJ/jgGv48IqVSWD3J2ezwGcYu5xBAH9ZT473HUnrEp4/jEs1kZGq1+ty\n", - "5513yrFjx+TIkSPye7/3eyLSXyzuu+8+uf766+UDH/hAZJH54he/KNddd50cPnzY1UxKkSJFihQp\n", - "UqT4WUEiI1Uul+WRRx5R3/ndd98tjz32mHzrW9+S++67T37nd35H/uRP/kQefPBBefDBB+WFF16Q\n", - "r371q/LCCy/ImTNn5N5775WTJ0/GCkRWq9XAqtrc3Az8vCx0xhYprBgEFjebTTd+xRPLhBXBTNSH\n", - "P/xhEdliolj9ly2rI0eOiMiWJfz1r389uP/U1JTu0m+++WYR6Vs7aAtYfBzngh1zrVYLrN69e/dq\n", - "XAKsGC8Is9PpuJYqBw9ay81j7DjQNslXzJtoZra8MnjxEtbqnJycdAPfwRIwm4AYBn4W/v1zP/dz\n", - "IiJuNvtSqRTEjHgBsnEip7CQUBa2Zti6syKybD1jHO/atUvLwgxcEnNjc0KKROPhbH91u11loDB2\n", - "brvtNnn66adFZEuUNpPJuM9FrBrm0fr6emDdTUxMaP9iXHa7XbXqMN8mJycj7JlIvx1RfsyL5eXl\n", - "gG3b2NgIssmvra0FsYhcrkwmE7Cj8/PzEZYGv7fW/6uvvqqWMsZ5nHAr8hHiHuVyWWPKONYH4/ip\n", - "p54SkX5sic1lyNdwvj8EqvMBFA8Yl2Cz4gSGbXD92bNntV2x1njxky+99FIgb1Iul5Vtw3geHx8P\n", - "mPn19XUdE8yOocxYy7mdMWZPnToVjG0WB+W6oa0eeeQREemPO7QHYqkWFxflmmuuERFR0V4G5Ap4\n", - "nWV2EcBcjssNB1YM7dxqtfSefNgKcUZ2jRDpB3BbL8V24qG8d7BlJzkGyXsO3hOZTCbCOgP4ftBh\n", - "GPQn6ru4uKhjDGOoXq/reuN5NzhLBTDouduVONhORoWBrj1UutlsahLfb33rW7oB+Y3f+A35+Z//\n", - "eXnwwQflm9/8pnzyk5+UQqEgCwsLcujQIXniiSc0WNXC0xrq9Xq66KIhC4VC8PKfmJgIBhbrf7Di\n", - "s6XyOeAV2LNnT/BSbzQaumhhU1Qul+XOO+8UkWhyTACThgOvUc5KpaLtyYk4k1yPXlJLHjBY6FGf\n", - "uMXVG0Sc9NeeHIwbdCgHKxADgyY2qFeU33PVfPe731Wam8eH546x7odcLqdjxnMBAbOzs7p5sAcW\n", - "dgJeTHjB4rljn4G2On/+vG5U+LQbwHpJNnFqp9OJaPGI9McdXJ4chM8Ut0h//GFeYszw+Ecy75df\n", - "flnbFAtfsVjUF6SnXI9+7na7urFAmXlc8ZzGv9FWc3NzugHgcWXnfDabddcRtGGcZhleqtioeK74\n", - "5eXlwAjj+Yr5Mz4+HmyG6vW6ur/RzqOjo3oKGKrYt9xyi3sYAC97DurG+MGYGAT01+7du92gcbQr\n", - "p1OxL6NsNhu4Rjm1CvDyyy9rv2PcLy8v6xzlpMC4D1zU9XpdN1DAkSNHtE0xrrw5vbq6GoQmLCws\n", - "BBvltbU1ee973ysiogcDZmZm5Gtf+1pwT8wbtMubb77pHjKya8fc3Jyu/9hwXbx4UTdrKBOPYYx7\n", - "Trnj1bNWqyUG7gNeAHWn03HdU0kuK3Zr2fcTp4gaBNQLZW82m1o/TvuGeT+sxpanfeYlj/cCz1lj\n", - "inUfB/0+CQODzbvdrhw7dkzm5ubk+PHjctNNN8ni4qKmWOF8VGfPntXBJ9IfiPZ0R4oUKVKkSJEi\n", - "xc8KBjJS2WxWnnnmGVlZWZH7779fqVLAU5i233vYt2+fGxwoEg26FfF36MViUXevrG3kqTV7dbJu\n", - "sbNnzyqjhWsPHDgQWErvf//71ZpkBgwaVc8//7yIbFllIlsMTCaTCdSSPTaKVWz5GQgehQXb6XRc\n", - "95K3QwfYoubjz5b6jaM14a5A8mUOWmYLx6rJe3Xd2NgI3Eb8G1w7PT3tHt+2fVMqlXSs8NFke9SY\n", - "3WBsdWC8eQwB60R5DCc+4zaAFQvmot1u6/dMTaPuME527dqlLJGXqJX7l/P9ifT7LW5eMc6cOaNG\n", - "Du7HCbnRr8ePH9f7IcB2c3MzYIFarVYQpD87O6vzAPdbXV1VS95jA9H/Z8+eVdcK5vfq6qrW1wbU\n", - "x8FjaJeXl9V1BlbEs4TPnz8f1LPdbgfyIpyclcuDOcUufjBSGGNra2v6bJ5T3/rWtyLPwHNEkrXK\n", - "OAQA97jhhhtcRgqAa3RhYUH7nw+aeArYHpsBloKZHIwdtMvk5KSOaazBV111lX4Gl9zrr7+uZcC6\n", - "x8C6Ua/Xdc7v2bNH72vXs3a7LX/2Z38W+YyNfuADH/iA/NIv/ZKIiHzuc58Tkai7ng8f2JyMi4uL\n", - "8v73v1+/x192zwJ33HGHiGzNqXq9Hqwr8/PzOjaWl5dd7a6k8T9obthg7m63q/2V5E4rlUpuJg+r\n", - "5L+5uekyV55LEcwVvms2m+77y5MzsDn+PBbNuzbuHeep8Q/C0PIHExMT8qEPfUieeuopmZub0w5+\n", - "88039eTV3r179U99RbsAACAASURBVEUr0o+9gEiaxcrKSqL7JUWKFClSpEiR4krjgQceSPw+00vY\n", - "bl28eFHy+bwGiN5///3yh3/4h/Kd73xHZmZm5Hd/93flwQcflOXlZQ02/9SnPiVPPPGEBpu//PLL\n", - "ASuVyWQiAeSMcrkcxHMwwC6USiWNa/CO9NpcarhGJGoBI2B9aWlJj8L+53/+Z/BcBJhfvnw5sF4P\n", - "Hz4cfMZMAmJWBmX6BkZGRoI2YPXsJLAVIxLm04s7UmslGCYmJlw2BMDmmS1dDs70GClYQOwvR3Ah\n", - "rABmENCvs7Oz6j72AkD5954lai2MOIbLgscot58dt+Pj41oejLF6vZ7I1KKc2WzWtbzQfrhfNpvV\n", - "scwBquhL3I9jqfD8uHi3JObSA6zx9fX/3963xUhWXWevqq6ue1+qp6d7Lk3TZgZmmGFuhjDEMcEI\n", - "gxNZwo6ILCyFoMTJQ6Q8RIqiJJal+CUXR0okEiUviSNZeQiOH2xsyWCMhAE7MjgGQoDMBDEDzEzP\n", - "rW/VPV3dVV1V53+o/1v1nb1Xna5pE9pO9vfSM1Wnztl77bX32evb67Ka6Ihp3RcG1ezsrGfhcY1E\n", - "9M0KENkMnKSVGSt3HSmVSvoc6LHLbop09BVy5TXDrTqwsbERCxQRifcd/ljHjx+Xxx9/PPaMgwcP\n", - "6voAmb744ov6PWdyRlvBpPRKMunCyu5uIZ/P6zhAfvPz8yo/MEPsT8brC+SCOVqr1bw1a2ZmRhk6\n", - "a4zxjMXFRS8DdiaTUXbXSnmwmb8jxgF/v/GNb3jX3HPPPVoNgduO9w7+8hp7+PBhEemeRoj4jJML\n", - "Ts8h0tFTVx7lcjnmT4W+4zOW+WZsocsgXY8jtQt+LtCL/QLDCAaY/eFApGyWXiApqSYnOeZqDG6m\n", - "9F4MG+RvsVmcjb3dbidmjU882rt48aI8+uijOjiPPPKI3HfffXLixAn5zGc+I1/+8pdlZmZG/vVf\n", - "/1VEOpuNz3zmM3Lo0CHJZDLy93//9z1fJmtra2ZECL8cLKDDlnMoH1vxwgFhYYKvrq7qM+AUWCgU\n", - "zA0UJgRevL2OALDpwMaAYS1ikMvQ0JC+hNE+LoKcFDnHLwTcg9tnUcG5XE77zk6kGAcrGsP9Pfrs\n", - "gvMwWe21lBmLBxwyr169GnN0FolPUt5IuRvodrut3/Oi5E7yhYUFb9G1nP6z2azKyp2sDF4IrH67\n", - "RT/dNrvOvFzigDOX4wgBR8WtVsuTARcetnLBQD/5GPzee+8Vkc7CgaMnLETnz5/Xe/PG2i2fwBsH\n", - "XoDQBstXEi+TWq3mOZFbGdBF/AjCXuBII3djt7q66kUYisTL04h0dM0yJtAerEETExM6hjjK5P5i\n", - "A7S2tubp9qlTp+Q3fuM3RCS5DMz09LRuMt56663EvrtgR2VEjl26dMl7gVnH8KVSSWXEpYeszPCQ\n", - "G2TGR2LQuytXrqiRi7nEGx/oQbvd1usw1u12W3XG0ifch4+osWm6cOGCHrHxHMacwt8LFy6Yczhp\n", - "k4bAlX379mnAxmZO065uW/p87dq1GCFgRaX1m6epn4zgFlKplFcaBoFnIt25UigUdA5AVhxBbuk2\n", - "roNOikisQDZXscCzXOOQN9IwAprNprdOc1AKl6tKCjJyC3gnIXEjdeTIEQ2RZoyNjckzzzxj/ubz\n", - "n/+8fP7zn9/0wQEBAQEBAQEBP+vY1szmVuZqtkzZ2maHU5E4fYfdZzabjWVzxn2x6+RdsRvaWK/X\n", - "TasDNDScZcfHx/WIznK4Bk2/sLDghYNb4e/NZtPLJt3r2BPWOBiuWq3mUY2cl4hDdq2+QeaLi4t6\n", - "H7S1H4dl3NetH1csFhMLsDLcjPDog0jXamc9YUvYtRiazabpIJgUHpsELqaJNlj0rnV8KOLr9ODg\n", - "oJeuYnl5OXZ04bYTWFlZ8ej0drvtHTNxODhbkmATLCb3W9/6Vk8ZjI2NKYuC1BeXL1/2rOOBgQGv\n", - "Nh7rGpjCgYEB1Us+osARAHSbLUp28HVTMTQaDdNiZJ1xWaxms2mydmAi+JiUa+IBrmXLIe7MbAAI\n", - "4280Gh5TMTQ0pH11i5wz1tfXVUZ89GfpHcD6h35iHFKplMfqtNtt7zq+Bp8tLCyYIfGQh3UEyKws\n", - "2GzIamBgwKwmgPFi1wjObyXSGSN3rdrY2FDHczBEO3bsUN3CKcTRo0fltddeE5HuerewsCAf/vCH\n", - "9XkinfHD2FjuGVwvDwBLxVHtrrxE7GAS6NfExEQsW7xVv9TSY+saa45AhlZBdl5HkxzPcR0HXGDc\n", - "2+22fgbWaWlpyUsHY+Xm6tVXd23k9ZjXDOgTnl+v1687S/z15J0KtfYCAgICAgICAraIbWOkXAdI\n", - "a9fLSQZhMbA/ieuXUKvVYqkQRDpWoBum2mq1dFcMS6PVanlRhHfddZda4VZSODBRg4ODasWwtQgL\n", - "0rI6OFwd/YTlVavVTAsTfcL17DgOWfRyaIdVzr5Nlh8UZ+m1WCyXXavX615GYw7PtlgWWPxRFKk1\n", - "AZaiXC57Vdyr1apaaWzRW3WSkiwvvo5rNYnE/T64fa5est8UV7F3s3CL+Mkj+dwfKJVKsWSFaG/S\n", - "fOAwZDfhpUjXSmRfD1jL+IytM4zf0tKSJ7+FhQV56aWXPBm4fiStVstjBjKZjPaJGUo37LpWqylb\n", - "DDmWSiWVAWRWLpe9rOgsD5FuzTROf4E2wCo+d+5cot8DvltcXNQ57K4raKNIRz8x1kinwI7CsLgv\n", - "XryobQGDWKvVdB254YYbRMR2Dk+lUqabBe6TxJQwMO6WH1A2m9V5bWXCZt8xi9lMckrH+BYKBTOt\n", - "DcbdkjP6xnMU16XTaU/vOGEoaqlaFQ54LjKz48q5XC7L9PS0iNjsCbPqbjqNy5cvq9zQx1qt5rW5\n", - "VCp5jtH1el11bHV11fPn6eVjDP2FnC0nbfbDZEbc+g3WfHwGx2v+bbvdNqPw8Qwwa9lsNvYeFum8\n", - "v7E+Id1PvV7X9SEpSTSn7sG7htftftMCcZCK69Paz+nMtm2k0Fg3+7OIP5k2NjZi0RzuPXjBcBWL\n", - "nW/xwrhw4UKsZAo/S6S7ELz88svaLkwkzmCMRWxycjK2gQI4J4YLznPllhJhhUQ7R0ZGvEiz9fX1\n", - "2IIi0hl8dvYFeGJA5pzfysq7hSMVpqbdBXZkZMRTNL4G/+ZFkDPvuhvGer2u48lHE7xpSYLlZNgP\n", - "RWsVsrSO//j+3Ca3gLZIdwHixcal4HuVNeAC0HgW7gN5W1R2r74mHbVCryqVih5Xcx4rPg7C9W60\n", - "EGdPdqNeXLhH2QzeoLvoVcibZWoVqcUREb/Q3Ptz5CUwMDBgZld3c1mJdDcN+Cyfz3sRiHz8gQ3a\n", - "xMSE3tsKrgBqtZq5eeGM2P0Ac5mrAuAeQ0NDOu5WVCteckNDQ6a+A1bAC9bttbU1fZ41l1gn3Gjn\n", - "gYEBM/t/Ui4wbIosfXrvvff02BqbKmtDevfdd2s29CTUajV9d2B8r169qrJGH60Nx/r6upcF/urV\n", - "qzr3SqWSN196OY67R+zW3LR0zJqvVukk7osVtYl1IpPJeJnDG42Gt4avrKx4hgNvCJOiEPnYku/L\n", - "0a64B9oA3eX2WdUn3tfM5gEBAQEBAQEBATa2jZGCBYDQYHaqc3eszMZYIeQMDrMV6ew6saNkx0k3\n", - "vFyku3u1QnCtwqKwEKzMtePj47qTx7P4SAR/BwYGdBfMfXOtMW4nLBfePbO1gn6wtcq/h8WCfvZy\n", - "VLSse9cqKhQKXugutwv95IzGjKRss2wJWfSqyypafUmn095nfCRqUdlu29xnWg7t1lGIa8lls9nY\n", - "saxIxzp19XhjY0P7tFlWXZcZKBaLseNKPIMZS7TXZfkWFxe1mC73F/3gwIzrBebl8vJy378HK8dH\n", - "s1aaBB5/OA9bwBpi6bXFSDUaDT0OtNgwyJ5zt2HdaTab2mcOmnHn3sTEhM5nZrVc1sJ6Poem95sT\n", - "DLpWq9US84yBCYmiyGsLOyUDe/bs0bWB1wOr7pvFcLjh9CI+O5TP501mFXMJ7Fe1Wk1MK8Cywv0s\n", - "dhQO6//xH/8RqzDRC8ViUXWMj5vcNrCDNDO67nXMalr95pMEzju4WUZzwD1y5DxsWBN66ZMVbNCv\n", - "c7abmZ/XP06d0O864a6f/M7nvYTLjm3GmPeT9kB/0/eVAQEBAQEBAQEBMWxr+oOxsbFE5z1YGtVq\n", - "1bOoC4WCxxjceOON6hwOWD41bH2yMx8csmH9NZtNM5mmlR3WdcyOoshjUay2tFotPeNnJsy1xorF\n", - "ot4P13ECOK6yDauXLRx+tuVQ6lqYqVTKPINP8lFip3PXz82qD8ZWjZWJfjMLB/dMSqppoVgselYx\n", - "18uD/CwrtVgsahvZJ8CyXlz/kEaj4TES+D0jiiK1mtlvAuMBOa+srHg6xvf6SbIXA5aFOzg4qOPL\n", - "NQbxPKtyPPvcoE9uHTaRuH+kJX83pQQzPyL91cWyfN9arZbWOoQfUb1e1zFGYkdm7KBDExMTytpw\n", - "slTIAz6J6+vrusbgunPnzqmesB+Ji5GRES8JLvcV/oybVU9gHzQ3GSWnh8G6uLGx4TFSnAgYmJ2d\n", - "jdUXFenoAfrJjBT6i7bUajXvGRMTE9pf/HZ8fNzTxdXVVX2HWCHzFjDOzWZTn8GyhP4msVC9HL2x\n", - "jvFv3WzxrVZL5QI5Dw8P64kJz4GkkP0oijxd6bXOWswgZLlZqTZ3rDlIyPWLEoknCcWYcLJb18nd\n", - "OoXYjA3iUx7IHPfpJTP3nuxYzuzX9TBRwLZupPiFi4Go1WpmTilQzTgeajabniJbOTfq9bo6AELp\n", - "lpeXVeF404ZFiAtiuhsk66U5PDzsLRjtdjtxEqDfXOzVou+x6Fh5lrCJEukuDu+++675XJ5wmAT8\n", - "mSvLXC7nvaTdkgW4DkiiYjd7qXOmdzdDsgUuo8NtwaLA9Kz7ck2KiBOxIzTdY19GFEWmzLGBYuda\n", - "yJz1ynr5o424R6FQ0Bctv1DdiMnr2Tyxw6ZIvNwCl1hwF1rOhO861Lv/xvd40V+6dKmn07hId3NV\n", - "qVR0bvKxBufkwrN4k8Y5pwCrSKqLKIq86N61tTW9N+YcA2NerVbVuRht5jI6HO3GhptIPEIXY229\n", - "2HrNLc583wvu8Sf3WaRrxLAc2XGbHafx15IH+muVhwLYeEvKlM7AGnjmzJnEe/d7FIS+tVotL5Bi\n", - "eHg4Vi+2F6z1Z2VlxRwHvE/QPtZnGGVsQELe7E6yY8eOvpyeuU0cxebmfWLHfWBgYEDXJXbgtnTH\n", - "LTnDecT4vknBIxaSjtWsgCB2Xkcfx8fHtc3svuIeZW8WuOSuj4nt3vSKgICAgICAgIAAE9vKSKXT\n", - "aWWfYO1MTk6aDoLurnhjY8Oroce0NpxEr1y54oUN5/N53dFa+XTYMnN30hYFPDY25jkDMnPFzr9u\n", - "ugV2CGeWAv+GLNhRnXfmYNv4SBNt5PBsBvrEx2mupddsNvsq7NsrxwY+5wzUgGVZwHLI5XKmVec6\n", - "VTKDADAF7RY8ZVjWEWeTZ+vYzRxtOZin0+lEJshiq9CGqakptcyT5M1h48xg4jdsPeF7yJELXkPO\n", - "Vj6sVqsVc4IX2Zzh4r5ZbAG+Bwvw0Y9+VNsAx3DL+uQ0JxaY/bB0i2sy4v6QB+fuApaWlsys/m71\n", - "BAaYkoWFBdVzrDvnz5+PORLjenducj68XkfJvZ4v0l0Xk9IgPPTQQ/LVr37V+xz3xPrIQRjMGros\n", - "ZbPZ9MaM69sBfDwHFAoFz3UjiqJYjiWReE0+Xtcx1mD28vm8mRbCXS9EujJHP3K5nH4G9wrUmmSk\n", - "02nt72aOyBazduedd4qIyHPPPRe7J/9tNpvq3A4mqlKp6DyYn583M9+jL6xPVg4lFyxzzgxuzXfc\n", - "m3NHJaVR6Bc8DphzSewX1810Hce5H5sdbwMc/MM1Zq1AtM0QGKmAgICAgICAgC1iWxNyjo+Pe34w\n", - "Vl2i22+/XZ08Ofkadqe8A4UFZzmxJ9Xzi6KoLwZGpHvmDb8kzqIMq5f7BUvCCmFlK4CZEteZt9Fo\n", - "mNnJcU9mY9gRzwJ27nv37hWRTvoGi5EC2NpxP+O2gB1bXV31wrHZouaM9W7StV5WgMswbWxsxDJ8\n", - "c9vd690UC0nV3fk6K0twsVhUqxlttULnGRj/sbEx1Qv8lv36GJAvWNKrV696rESlUlFdxpizn1iS\n", - "jx7XeORUHFYINr7vt8I82KB2ux0LtxcR+f73v6/Xs1O62+9UKuUxh/v371fmGu10xxIW/OHDh0Wk\n", - "M9exFuB5KysrXiDA+vq6ri08d10nXfbnwWccls8O3GBccD07KEMe7LthAc/PZDKeLjabTe2Tm8CV\n", - "ceXKFfnUpz4lIiJPPPGE9z2309WZm266KVZLFLCybLuIokjvDdnyunzo0CERETl9+rTeD/1IpVJe\n", - "WwqFgsoXa/Xq6qrKjxlAl1nJ5/PeOtxut3Ws+b3Dfq78F/cR6Z0cFvMalS5efvllrWWJ98/4+Lhe\n", - "BxYyk8l46/Xi4qKu0RcvXjSz3SeF8qO/HKjEfXfX2oGBATPx8Wa+RICVAd1NL8OfWW3n9AcW65XE\n", - "skE3crmc14/19XWPVeSam70SI4v05yO1bRupVqtlbppGR0dVST/2sY+JiMgzzzyj37MTJC9QInbO\n", - "ExHxonFE/CObqampni81F9gkYAPFR1Fu9m4RO8cQUCgUvM3kwYMHvdxUmUzGe1nfcMMNGulhTXZr\n", - "49NoNGIFbkU68rOOu3hjhN8CVlFY7udmC45IR1bucSpvDhhWhAxk7ZYr4M82A57PeoXJbEVs7t69\n", - "O+bkj7YA1lhbDqVANptVB2n8XVxc1A0D2jU6OqovFi4LYzkvW4VM8RnGKpVKeZsmi6a3sk/z8SF/\n", - "b0XhAFa5oSNHjmjbkdUbOlYsFtXpFu3ENSLxiEgrgz+Oum+99VZ9eXPBaBQZ5iNEXMcvUuglDLSp\n", - "qSm9Nwy4AwcOaAZ09G9lZUXXHW4b5hy/xJI2vHxEBd3qVfxcxHYsf/bZZ+WP/uiPRKSb6ZsdqtGW\n", - "vXv3ekeqCwsLXtFnbhewtLTkRR9fvXpV9cQybIHh4WHtE7/QOHIQ7YROsNGLzQYi5fiIko943QLk\n", - "HH0GcOkURr8Rga4Rc/z4cS14zdHWMEDR36GhIZURlzzjQvbuyz6bzapO8AYEbUhadwqFgr4zIPte\n", - "OajcjSpHhrOLzPUWBQbYYN3MKd0tVM/vPY7aS8oLaDnFA3yM209BaP3dplcEBAQEBAQEBASYSEX9\n", - "bLfe74f+/50e1w8CM1CtVpWSZKbm4x//uIh02amRkRHdAVu7WNyjXq971CRn2YaD3+zsrBYNhbVm\n", - "FWfFs/m5g4ODPXf9Il2ryGLgJicnvdB1PgJwGQeRrmUwPT3tWXqFQiGWR4prIQHIJg+riC04foZL\n", - "cbdaLS/fUyqV0s+Yqk06PsN1rVZL8/OAgePafZCBZSVajBSrclKYNKdxYOuP+45+u8zl4cOH5Y03\n", - "3ujZN86RYh05us6qVt03ke5RCMad9csdF5EO8yLSkSPnWhOJ09oMK3+Vi3Q67dVhtK7L5/M6rlZu\n", - "FsDKcD86Oqrt4zxMAGfqd+cZH7Vax2R79uxRpgJzfXh4WPWNGQsXnIEaDNjw8LAyUjiqSafT+j30\n", - "an5+XqampmLXDQ8P65xLYmgGBwe9Y+t2u20eP+zbt09EurLuxarjPr/9278tIiL/+I//6M35PXv2\n", - "6BoF5ufSpUtmIWGA1xekRHDTOTB27dqlhaWff/55Eekw627KgYGBAWX0sA5wniu8LzKZjMqU3SEw\n", - "ry12G7Iol8uqixYTwylAcG9eJ9yjrMHBQe95v/7rvy7//M//HLtOpFtcG2s/u6fgPTQ4OBg7VkWf\n", - "4VzfL+uez+dVP9GPd9991yvSznrHdfpchtNas3iuQC6NRiMxjUFSVQl+/1gMN+5RKBRijBru5xZG\n", - "73V0586zXulosLb02i4FRiogICAgICAgYIvY1vQHvLvDzjyfz3sW6y/90i/JU089JSJdNqhXLR73\n", - "PJ8d+BCafPHiRb2OM9C6/lWNRsNkEFz/kJWVlUS/FDcE2IW74x8bG1PLgS1X9AXXv/POO1446Nra\n", - "WmLYZqFQ8NpjWQ233HKLWu3spO/6RgwNDXnWfLlcVvaCGT83vNyqL1WtVr20Fnx/lyESiVuEzGL1\n", - "AvcBY57L5WIy5L6gXSK9k4TComHLB20FuzQ/P+9ZV6zD8PXYuXOnnD59WkS6Y81Wu2U9v/nmm/pv\n", - "sJicdRxgPe2HjG6327HM8Xi+65vBMkObU6mUjiGYJEt+S0tLqu9uygCRrkVaLpe9eebOWU5+KhKf\n", - "39Y8BJvKyVKxTlSrVb0/2BXoA8tjY2ND74N+zM/P65qG3xQKBa82ooVKpeKlZ+nFPrhZnXsBY/i9\n", - "731PRER+/ud/Xp599tnYNdeuXfNY3sHBwb7DwNlnTMRmg6vVqjJRgJVEcmBgQFkl9o2DfliBQVw/\n", - "0w0s4tMP6E69XjfnkptsspeDM55n+a4BzzzzjLLFPEcxl3luYiyZneM5108wVCaT0TnASSvhw2cB\n", - "1/E4sJ8Q3pWQm8Xesm+e5SvF8zYpaAXXcfogZpc4MbZIZ/5btVTxDrHaivFi31Zu8/X4RgHbupHi\n", - "RRA0OFPTeAFhEyXSpT1ff/312MZIxHbIq1QqSlfzd+4LfHR01MtHwo5nwPj4uD6Pv7NKrHDBXpHO\n", - "YuxuzObm5ryjMesIkCMcWcndbM2cDwkvMRG/nAqD8wxZiwf/2/29VUiUFZTz22DR4mdBluxUy5S6\n", - "SFy2lnJbGWhxD4uOrVarsehP9Av0N7843N9y4Wt+Ph9/ArgP388ty8EbC9zbesa5c+f0OADy4002\n", - "vrOie3qhH4qdwX2DrDkTOX6PPkVRpPMMz9qzZ48eLaMfb775pt6HqXY3ympxcTHxyFbE1m/3pVqt\n", - "VnVOsqxxHV5Yu3bt8kpO8RrBmzls2Pbv36/fY95w8WX3qL2XPqN/1hwA0um0bjaSqgAwXn/99Vhf\n", - "GYODgypzzMtsNuutsxY4WAfX8XrL8w19v+eee0Sks7m78cYbRaQbJNBsNnUDhbnC1SzQ7yiKvHVl\n", - "aGgoFjwiYgdFWA7kqVTKM9bS6XRiGZWkjcHs7KzK+hOf+ISIdDZX1uYU7UKQz/z8vLaBj7CBUqnk\n", - "GYy1Wi0xwAeyHBgY0DZYJc8AnsMMNyK13W57LgDuffqBm4Gd/221z4o0ZMd3fFcqlbyM5tb9CoWC\n", - "tx72U4w5HO0FBAQEBAQEBGwR28pIiXRZE7Z2YHW6VoVI16JyfyPSORKDhQkrkNkdK9cJnCo3q78G\n", - "62Vubq6vooZRFKnVa+VQAsrlsrnjt/LcYGds5cOCY2Ymk1EZMFOEtrDDJlgbthytYyBuv2ttWLLg\n", - "HTwseM7SCwwNDWnf+UgOz+X+uZmKrfpcvbKnu2i3295RCTs3MmAFsszdsWEnfCtHGay38fFxPf4A\n", - "68HZ/RGSz+kAmIHhfGUiHesJv+Xv4JTK2YI55JvlwBgYGPDqUeFz9BPAv6FD1WrVux+zgbjv7Oys\n", - "Vwx2fHxcr4O+1Ot1k13iMH+RjqVupT/gtsMKh37UajW5+eabRSTO5LiWr3UUyH20aqZxxnowNHwE\n", - "yOkdRHo7wfKxDLeNMTw8rLposdhJsObHxsaGpqT4t3/7N30+ZJXESEVRpEfTWH94jnLlAsgIuQHH\n", - "xsY8B/5ms6nrDsZ6bW1NZYn1eHFxUWZmZkSky9BagRluW7lNInG3CVeHMpmMOX8ArE38Ww6iwRr3\n", - "ne98x/stA/3F6QyznzfddFNs7RaJpzphvXQdrfkIk5kwl4lKp9Me08RzEDprFVNOp9Padw6QsJh6\n", - "wM01KNKVr1X9IpVKmYEv7juJ07Ogb9YRH6eeQT+td3E/CIxUQEBAQEBAQMAWsW2MFOowwWLA7nlg\n", - "YEAtBfbhwLkxh4m6zsiXL1/W+7Glh10s7/DdVAe4P4MtqiQWin2pLOs9KckY74ARPlwoFDwLc3p6\n", - "Wp0V2WEVfeNK9Baw62dWBBgaGvL8ahYXF5XZ4BBh60zeBVttaA/7awHr6+uezwufZTMs9sQN3+Va\n", - "TOwgbTnzu9b1zp07EzMHQz+uXbum/2aGDYwg39fN6s3V3Pka6C/X+bJYR+gsO27DwoTfUSqVMtkJ\n", - "Nyghk8l4fk4ivj+AlXqCnfqtrMSQPetBUk0u1ke2UjGX7rjjDhHpWMQ/+tGPRERiLFOSFbl3715t\n", - "D4dlW755rt9KKpXy0mOwJY77sQ8NmMaZmRkdO/xtt9uJzAbA7LjlfA8MDQ2Z9df6Ac9bWOVLS0s6\n", - "hjwOkK/LxDIuXLigTuYAtxky4HQUPN/ctCoMjAvXRkMbstlsoiyxhq2srHgyjKLI8xNMpVLe6URS\n", - "2LtIfLwgI9bJJLYQ8t65c6fOA3Y2h8/d66+/7mU+twJGmD3bLADBrTPXbDa99ZxZanzHfknMZrlO\n", - "61aABMuS1w6XneqVgsBlnwYHB7130tramteGYrHosb8bGxs6n5MqU/SqEMLYto2Umy+GIy4Afnm6\n", - "k6BYLGrn0VErM+uOHTu8AqwjIyOqrIhIsApf8sYBL7bFxcUYleu2mZ+PhTapACsrIDYs6XTaiyDi\n", - "iA+0eWlpSU6cOCEiIi+++KJ+Pz09LSLxYzx+KcF5H8+1NhHz8/N67MnjYDmb4964Rz6f1xc76HZr\n", - "81ev13WDxQ6j1hGsu2liyt5yjMffbDbrTdLx8XEvAqbVaiVmOeZJ6L5wd+3a5R1X4XORrn5cvnxZ\n", - "+4Z+82YS911fX1edxeZ6YWFBdRb9OXDggLz11lsiEj+GwgsN13MRbCCpJALDMiB6ZS5PMhhuv/12\n", - "Eem8UBGRCMzMzOjY4Dgsn8+r3Fi3AbyYBwYG9GVpYXl5WTdD7Lye5JBvbRiweW40GvpbrFlciQB6\n", - "cOjQIS8X2LVr10z9dcG5bJIMuGKxmPjSsoANfyqVUtcJ1oV///d/F5HuXJmZmdGNwGZOt1hvOHLS\n", - "lWU6nfaMvaZTKwAAIABJREFUp1Qq5Y0Hb7jw3JGREW9+NxoNc5PJ74QkuEfZ/eais1CpVHR8sVG3\n", - "CjeLdI7qRLqyOnPmjEY4c+4oLv3TTzss1wzWDUufkuYtvwNZHq5cLd3gNZ/Lbrkybzab3u/z+bw+\n", - "1zLWk3LV5XI5Xe+wR1hdXVVZ4r327rvvJm6ggH7kHo72AgICAgICAgK2iG1lpEZGRkxa3rUERkdH\n", - "1aKBRc+7bIsud7PAinQpzF27dulzredz+Cl2vriuWCx67Bm3Bb9dWlpSCy3JKmq321rgEv39r//6\n", - "L/2ej4p++Zd/WUREnnzySf3MdUAulUr6XGYh0AZkQu4F9Hd0dNRzbuRcIbj3xsaG17/h4WE9LuB2\n", - "uRncRboWAxia1dXVxLpWlpNsEu3eaDS8I2CLql1cXIzVTMR1YInYYnbTE2QyGTOjtBsswblsWC/x\n", - "GfrNLCUfe7FeinSKvYL1wLjMzc0p48OOo1adLnwPuTBbYB2RA1bm/WKx6DkWb2xs6NjAsVhEvHB6\n", - "TuMA9qjRaPQVduzmInMdnqMoijk6o5+Qr5V2BddxPyHzXbt26Tig3adOndI+4Vk8bliz1tbWtH9J\n", - "dclY16wjXmDnzp2x48V+AHaJdR19tIpvX716VS14MCucmoKB+Q35TU5Oeu2+cOGCN1/37t3rzZ9L\n", - "ly6pnKEHPM4PPPCAiIg8/fTT+luMwdWrV/U3m+Vecuu17t69W4/gmYlwWW12rsbfcrnsvXeuXLmi\n", - "98bae+rUKdUDDp5y2ZXx8fHYcb+LbDar8w9tbTQaOnfR1l6sJtrA7hD4Nxf4Tko/AFipgvh6Pgp0\n", - "r7NkuVndvqR3qhWokk6ndS3DXz665+NQyz1nMwRGKiAgICAgICBgi9jW9AfM7mAHaSUe4/9jB760\n", - "tBSrwSXS2T3DImBLxE2CyUn2ePdpJRTj+ncinV2+u6PmjMWwRIrFojIhYNOs89yDBw+qBcRWrOvk\n", - "WqlUtM4gcOONN3phw6lUSnfc8K/hNnCWYPSdZYVduMUGsCXJrJHloAjfCPdZDK7xx/WSks6k2bpP\n", - "uh/DtdbZSubxd8e1VCp5df+4/qJbX68X2Dkd4wo9rdVq2vfN/JagW3BAPX/+vMd6MYuSlK230Wh4\n", - "SVjZUdX6LdgqtjRdK68fcLJH/MWYWP4QbrZyRiqVisnfZTOr1aoyFWhjqVRS1sfKNI552Gw2Vd+w\n", - "7ly6dElZQAbaz+sA+sf1+lwn3YWFBW99YmANGRwc9Hwtr127pgyS5VfIgG8UWCVr/lhzlBli6Ozc\n", - "3FxsbRGJB7FYqWfw2+XlZWWz0B+LDazX657fKmf3R4Z21neAx62fVDUi3fXWCoqxTk44ASUHXrgM\n", - "UqFQ0O/h85VKpWJMFJ4BFhVrJ6+Dlg9is9lM9L9lYEyga6lUSnUAcy6VSplMjqsXnGQZa0O9XvfW\n", - "WU6WmpRBnhPQAta48nPZyR3sKpjToaEh7Rt0a3V1VZ/Hmd+xpkBPrOCafrCtGylr4Hgh5QXw6NGj\n", - "ItJdCJaWllSYWLx6OfYhzwic+CzKkTdSliMql70AeAHEgobvp6en1QE1CePj47oZghO5RaGWSiWd\n", - "NLju3XffNYtzYjFyC4GKSKxNaCtvSq2IDywuqVTKy/vkHoeJdF5e7rj2OsKFIvNEcl+YHKHHZWbc\n", - "NlsbMKvEBR8lcVRUEnWNiZbJZPQ3aOfa2ppZXBry5RcC9NvaMPBmB/+GfpbLZR1rbJ7y+bxu0rAI\n", - "N5tN77jKijriUhI8BpApL4pcUkOkI1PoIGQbRZGXZTuKIt104O/Vq1dVjyEDK/9XPp/3IuWGh4e1\n", - "DVZkoIhdDBjXuptike6mtNFoeM7NfC3yAv3whz8089u50WScdRz927lzp1deKpvNqixh0PBCjvtW\n", - "KhXvGDyTyejx+2YbWWxqrE0zUCwWzRcz2oUNUKlUMstCuTnSeHPFhqj1DAQjYM2y1vFKpaL95DbB\n", - "jYD7k+R8n1Tk3NrY8trFwSL4Hmvvjh07vGhgPrZKcmyuVqteJDkb49ZvrdxR/G8uFdWPU7XlImFt\n", - "RFnX+MjzekurJG2yeCzxjuFyVZwnKilXFAPtstZogPuLtbef/oSjvYCAgICAgICALWLbGKl0Oi2z\n", - "s7O6s+S/2OHDKjl+/LiG5TLcAsVsSfJ3sESZfXJ/K9K1kK2jBOzumfnBTrnVaqlFg/ueOnXKcxS1\n", - "mIHR0VHdkXNb3FpYvGu32syA9e/WCXP7xLWpOHO7SJzmh/x27tzpMUssD9R7O3PmjEddcwZpy+EW\n", - "loFlKbPVkHSE0W63vXw06XRarRh21sY9rUKdQLVa9VivnTt3xrLNo2/u8ZFI15KBTuTzeW0LjkYy\n", - "mYzqOaxsDvPG/ZaWlnoW/GVEUaRMFI5T6vW63odrKbr52oaGhlSfksLvNzY2VAaQY6VSUZlz2DXY\n", - "G2ZxrDHE/Oe5ZznSu+Asxr3ai8+QkoODBdDWo0ePmiksMK8hK8shW8RnhK5du6bjDoZhcnJS2RP8\n", - "3bVrl8lcuvfNZrO6JnAYN36TVAyZj7whi1KppG3AeOzYscOs8whAN6x0Ke+8804s87VIXDc575Ob\n", - "2qVUKqnLAa8vrtPva6+95gWKpFIprwbp4OCgypRr/CWxxmiTG2ADuDnSeKwQ4GDVL6zVanqa8p//\n", - "+Z+xdorEcyFCpjiiWlpail3LR1sicVnyOoZ/87sBawFOZ4rFour02bNnRSSeVwv6sr6+HqvPh8/c\n", - "NBTMvAGc6mCzmpGug7xI/NhQpCM3qxYsdB+y4mNX6Eu73fZqX2YyGdVVtI/zDia12evDplcEBAQE\n", - "BAQEBASY2DZGiuvniHQttEuXLumuE39//OMfq/WCHXypVJKXX345dk/elcOymZmZ8fwm8vm8fo/d\n", - "9traWuzfIh0rBFaldWYPX5Rz587pDh4WzdjYmPYJO/+xsTG1ZJDK4NVXXzV9e7iWmEjHQddNXsmW\n", - "FayYq1evmkyUG+rK2LFjh8c0cRgo5MrsEzstA7B6/vu//9vz5+AQfFh3Vg3CwcFBtRi4VhwzVtxG\n", - "Fxx4IBL39UHNsPn5ebPWmZsYc2Njw3NertfrJgtoWbLweYDfBMvYYpeg45yxHM/fsWOHytpK4wC5\n", - "TE9P6/O4TS6zxoDseyWpxHPwjFwuF0seKtI7zBwMIeTMliGHHrs6VqlUEpmofpHL5VTWlh8RmO7J\n", - "yUmPzWTfPCQ+3bFjh+piUkZ1toqBM2fOqNM3vpuamtL5arFpWJOYBUD7Wq2W6qKlT0AvJ3I3YePy\n", - "8rKG6L/99tvebyCLWq3mBaMMDQ3p2HHmatfvR6S7JkDebgoXkc64uSz/+fPnvQCJSqXi+Sqx7y0n\n", - "trVSSIAZ7sVEidhBLBzuD5k9//zz+j2S4p4+fVr9Uq3xZXYTY4gx39jY0Dki4q/dvd4bVqAQ5udm\n", - "6SAsWIEJrjO/5edkfTY4OOix3VyTj9Gvz5YbDNNut02mDrA+g47V6/W+0q642FZn88nJSVVQpv4h\n", - "GFClXNIBf0GnithHcW4hS5FOlJtIfNKwklglIly6nRdXN3W+SHcz0Ww2YxlqReJ08N133y0inZxQ\n", - "7mLDLyp22naPFG644QY9ruA8PRaw8KytrXk09erqqucAurGxoX2BvJaXl/X4jhc/LIyvvvqqfobF\n", - "AG1mR1Euu+PS9/V6XRc365hss4gK6AB0hycjRwe5L9VeRyOQEfp46dIl79peWb0tZ39slrAgXL16\n", - "1cuGLNJd4LGJ4GMn9zhCpDsfXnvtNf0Mi4NIt79ou5XJXaRLe2Mxqdfr+hwueYM2Y2NQrVbNfDPu\n", - "5owXemtDCrA+QvZ33323HkMg038URYlBAoODg/p7nvdYdDEXTp06JQ8++KCIiHzzm98UkY6M4IyO\n", - "jcWVK1fkIx/5iIiIfP/73xeReBFsyJRzaHFAiHusPTAwkHgsx8D6hbafOXNG176kzeb6+rq3RvLc\n", - "wwv8ypUr6lSPv7Ozs966Yx1tcrkSPmrhIuMiHZni91hfOCru/vvvFxGR7373uzqnrJxVx48fFxGJ\n", - "GdNWeRasoxyhheuazaZ5nArddstviXTn5cjIiOoElxfDPOTs/dbagGfg6LHVamlAAL+HOKO+lasO\n", - "suENN2RubYDYKML3uAfnWsJ4NRqNvqsb9GPsbla2httpVbNwy9Dw/Od3gzuGHMCD/g4PD+u8YZ3B\n", - "mnDrrbeKSJekSEI42gsICAgICAgI2CJSUb+xiu/nQ1MpL08ELDW20GDNMtX20Y9+VEQ61iDqFcFB\n", - "cvfu3V5tt2azqTtM7LLZosYOl8P48bxeu2dYJdjdz87OmvmrAD52A6MDK39gYEAtOS54iqMEMASp\n", - "VEq//7mf+zkREXnllVfUqsDOe2JiIsboIUs6hx9DDhz671odXNSWj8tgqXIahcOHD4uIyBtvvKHP\n", - "AgvAebXYMVGkd/bapJBfq7ipFXbLRxTusRZT9fxb92iXYdVfgxwzmYxndUZRpKwYWJuVlZXEIwRg\n", - "x44dnqV88OBBZTj5eMMdtxtvvFHbbx1Ho7+5XC4x3Qdf388SUSgUTLldLyBTrr9nHVXfe++9ItKp\n", - "HQl9+cIXvuDp7Pr6uh6x4358xMMFe++77z4R6Wabvnz5stx1110i0plrIh12Ab/BGjM3N2cenWKd\n", - "wNrw9ttv62dog5XJn2sjQva7d+/Wccf8P336tH5vHY8B+Xxe9aTfunEua90LeH4+n4/lWhOJF3MG\n", - "UqmUzk2s2+vr64k6hnnUbDZjRXxF4gwnxrxSqXhpCPg6rMHFYjHGogNuBQE+hWBYa+FPgqR8YgzO\n", - "S5Z0pAvk83mvQPn4+LiOE2TVi6F2j6OZbcNnuVxO5WsFEeH93m63YycSIp1xdWtQsvM615PEGo31\n", - "OJ/P63vCWu/eL4DR6qWngZEKCAgICAgICNgito2RGhgYkGw2q9ada0G418NKwN/Tp0/L9PS0iHSZ\n", - "i6WlJbN21rFjx0RENOssWxhgOLgmFz5rNBqeRbZnzx5tM/w0OAwVuOmmm5RBYBblC1/4goiIPPbY\n", - "YyISdxj9nwCGF8xWr2e5vkqcYf6OO+4QkY5jrsW8WTUAXQs9m816dY1qtZpaLGyFcfZdbpML14Lj\n", - "0HRUUp+dnVXmEuNRLpdNx9MkRsrNNM/tE/GtuSiKVKbcN1cGlUpFP2N/PviAoM0WO1cqlZTtxD2g\n", - "k/0AjAr6XSwWY9moXfCYuoEUzHRC9gcOHFD2BPP7a1/7ml4HH4RMJuNluU6lUqqzeG69Xlc5W+1k\n", - "PwhY2+x4DFnlcjnT3+Thhx8WEZHHH39cP4PTMHw46/W6WujMlMFCdp2cRbpr1vLyssoGsmen7kOH\n", - "DolIR2ddlnD37t36mw996EMiIvLee++prlqpGxiunwczo6ynrh4zM2AFieA7ZtY57Qcn/RXpjCUY\n", - "JmZ3sZajykMmk9HrOHErM4i9wD6L1rzFfT/84Q/HHMRxPfoHefPaznVgoQeWLiLBKNdcxTwrl8vK\n", - "nmH8R0ZGlOHC/dg3OIoi9YeF3vVKOuqmFOJ5k4ShoSEvDYG1Tg4PD3v+S9a78nrASTfR5usF1okD\n", - "Bw7oeKN9zMBjfLlvnOATuoU+gjFNYqS2zdm81WrJ2tqal+NpcHBQBxGUfbvdVqcwOFyKdKPmXnrp\n", - "Jf0tFJ2z/4J6teh3XrDw26Sjjmw2672srCKu7GjOL+a//uu/FpFkR1uR7uILJ7hekQ2uE2mvIxb+\n", - "zKLt3c1KuVzW53H+EmtiYWLzfa3ClFBq3lzh3pCHVdSSN0i8eXKVmqPY2HnQdfq3sqJns1lv8vIG\n", - "mRct6Bba3Gw2zRw11ni5496LjraOHFysrq56TvP79+83M6BDzvhseXnZiwJbWVkxjxfcbOdcYoX1\n", - "Bv+Gk/25c+e8skbZbFaf++KLL+rnWEjhIH/p0qXEqLjNjkEwbuz4ihdaOp3WtQPjf/nyZfPYFX3h\n", - "cePoMJHOSw76yflo8G8+puWyGC44sha/xcuz1Wrpixt6Xq1WTSdzyBDjNjc3573M+T44brQ2Y+zo\n", - "zXmEXLTbbTWyoJPr6+uew/jKyoqZ2Zyj00Tikbo8B90N1ODgoG5iMZfq9boafzBOarWa5xbwwx/+\n", - "0DMgR0dHVQ7WMSg2cnNzc/pvbHx4zDF/d+3apRs33Jc3XtDPcrksP/rRj1RuInHdTqVS3lrBfeci\n", - "zVaOJ+gEnNtHR0e9414OLEhyCt8sgzhvzN3IULj1iMTfF1xmB4CuchSjWzx6fX1d5wXu9+6773qb\n", - "f56D0AOrRB3fG3+tYAcX4WgvICAgICAgIGCL2DZGqlwux6xZMCacIRm77aGhId0FI8z/pptu0my4\n", - "vIt12YdecMMjOfeE5Vhs0dqw5NbW1mK5U0Q6LIAbDs7h6Ax3lz05OenRxeyAzCwULDlYPXNzczHH\n", - "fYDZG9eKt1I6MNPBcrBybGAc2ILjMHuRjpwxrpBHLpfzauhZlhDrCZiflZUV7RMXm8a4WjmDkjJg\n", - "s+M2ZGBl2eX7cI4qi2Z3c3dtZslBPz772c+qFYagg9XVVc8hc3l5WR38IVsuSv2TgNMDuDWqmC3A\n", - "dTt27FDWA3IbGRnRcHDOeu3q8fj4uDJlOHLbu3evsrKQAbOq/RajZQaMf4sjk1/8xV8UkY4OuQVn\n", - "8bkLNxDAKrA6OTmp8rCy51vtx7FWLpdTdgfrDgdw4K/L4gBYCzgjNfSDx8FNa2EdXVSrVS8djdVf\n", - "ka5+WMcySSz/0aNHte9AqVTSdkGH9u7dq8wg0mBsbGx42c5FuvnBwDxabWg0GqqDOC61irrz+gNW\n", - "aGpqyqyE4R4lcqZ4jEc2m42dNIjYebsYURSZNUhdlorzoWGMqtWqMnn9OKczisWil8qGK4NANry2\n", - "4bNcLufpGH+Pv70CIDDf8TeVSulzeSytY3q3IgGDGXgX+Xw+lv3dbXsvBEYqICAgICAgIGCL2DZn\n", - "c5HODh0+ALD8Zmdn33fna9cfZnR0VHftnDQR58fYtbMFwI6FSKoIpuHcuXNqlTAz5P52cXFRd998\n", - "Poz2sROm5QPCWd1FOjt5DtEV6bAAcAQfHh5WyyepGjpbDpY6JDl49sqk69YZzGQyKiO2EpjVQd+S\n", - "rFcLXOUc/2b/GsifK9Fbfh6cpsIFO6K7VcGz2ax3vyiKPJ3I5XKaXZ0ZO8ijn3qSInGmkXVBpHdK\n", - "CResD+y/kJTwFM9NpVJmrULMC+j2e++91zdzlATIft++fV7yytHRUW3XM888o0wO9CqbzarVzuPm\n", - "Mir5fF7uvPNOEemGs7O1byX9BVge6O/hw4eVSWOLGwwJ2mKldrjtttv0Phj3SqUiJ06cEJFuzbbL\n", - "ly9rP60aeVjjxsbGVPfBGrEvJRifxcXFWJoUkXimZ4wD+3Dhfknri0hXJ4aHh+UTn/hErM3PPfec\n", - "9hdzde/everfhPWsWCzqnOPM/xYDhiABpIWIosicSydPnhSRbiJbK2GxSHe8kA7jBz/4gX7HKXnc\n", - "dU+ky44wE5OU4oV/h/5yzVBOOeHWhesFrOHoh5WIdDPwewoyshJHu4yTiM3qWIwfA3Mdz+2VXgUn\n", - "SOzzh88wz1dXV3Xc8XezEwLGT62zeS6Xk9tvv12zA28GjpbohVKppIMCRU2n054D3fLysklNc4FL\n", - "F3zUhkFip3M3UkKkq7x4FredFY8dGNEP0Ip4qXOpG0sB0G+OpttMUbgAZFLRSCtjLJd0sTZS7ma4\n", - "2Wx6OXQY7Pho5YVyFzc+ioPMV1dXzT7jBY8x7HVf9yXNz0hyzO/1EsHnGJMoihKjqxC51G63la62\n", - "HK75+W5/C4WCbiZ4oeLjVJGOXmFT0K8ttdlibUXeYqPHRgpelmgnzwu80Pj4CAuoWwjbAu6NagFn\n", - "z571Iuos/VtfX9f5jJchL5xJfees3sDy8rK3VpVKJfMYwkUmk/GOrdvtto4djoFWVlbkgQceEBF7\n", - "I4V5mcvltE/Y+FgVHVjfOdDE/U0mk/Gc5dmgwneVSkX1lzcx3/nOd0SkO+67du3SMcEctSLhLAOb\n", - "C4EDt912m6krMJQ4sAVHiiwPaz1zqzww4G7C5WoYrh4UCgVv3nLxbXZ2BtGwurrqFUXmfnMhXrdy\n", - "QBRFZnAI5iQbuG5h32q1qmOD+WgFC1jIZrNe2a0oirxoXHbJ4ChADuZhOXH78vm8tg/Xz8/Pb6nM\n", - "i/sMN1N/EsLRXkBAQEBAQEDAFrFtjNTw8HCMjbLCxwH3+AefIT8Qdubnz5/X3XVSltNyuexZBCdP\n", - "njTpTpd+3Ldvnzq0Y6d64MABzSDO1q5bhFLEZ70mJia0rUwLu7XR3MLLLrC7Z+dYdrRk+W5GqeI+\n", - "bmFKEfGOtaIoUquDM9H2W5/JcnzH/Th0mnMJicTHkC0+lxk4fvy4Z1Ewg8Rtcpklps7xDCtnGMuR\n", - "5Z90zMbH2/g9O9xCF5DuY2VlRfUTMmNnfVica2trJjsB8PjByoajLddrRE6btbU11UWwCqlUynNq\n", - "B9so0mWPy+WyHq2wMy36gesqlYoyEJjr+Xz+uo948TsRiRW+5gzK6LsFMMLQMS4y3m+NMDDJzDx9\n", - "+tOfFpGOnnzrW9/q6x7umletVnW9ZLm4WdEZXFjanWeVSkWZBTCme/fu9QoAr6yseK4RnIkaYAYA\n", - "OjY3NxcLjBDpyADtx/yoVqse2wI54DcinXFz83BZx69WaolCoaBtxrNarZbJorrr4szMjK7bYKQs\n", - "xnR0dFT1mF0B3Lqfq6uryjRhHbh8+bJZl9A6HeH+4p7QWU49w3ru9imfzyfeG++uXC6n7xEr1xK/\n", - "r9Fu9DeTyZjv1K3MawB9gn5auaB6sVFYo/D80dFRZat5/eQ8h0n3YwRGKiAgICAgICBgi9g2Rmps\n", - "bCx23mwxUUAqlVI/Ily3urqqVi7vvF2HtNHRUbUOLMdM+FRMT0/HEgSKxH0B2PLHDh1WOULQXbg1\n", - "m4aHhz3Lq1qtmk7YYATQ1kajoTWqYN2x1cu+HLBOuP4WfEZOnTqlfUnawbMDtVWHkENDXUdbtlbB\n", - "Oqyvr3tn66Ojo9pWjFuz2TQZH9yHq5cDPOZu+LFVx8tikDY2NjxGiutCAalUSi0bMBjcXr7HL/zC\n", - "L4hI3JcOMsJ9LX8dbpelW5wg060ZODIyovK36j5yfyB7ZqJwb+gO+8BxAIWr21ZiSJGuXwonu3WZ\n", - "RPaHgXyWlpb0N/AdYwsXzES5XI6lPOEElnge7pnEEHIyX1in8LO8Hlh+PFi78HcznDx5UhluME75\n", - "fN6sp8d110Rs/5WFhQVPz4rFoufQvrCw4MmAGXOwfOVy2dQtAEwnJ+Rk5/8k303094YbbtC+4B6N\n", - "RsNk5rFGw7neSmOxtrbmye/ee+9VnzxmTjBOGEsOMEH7LIby4sWLnq/P+Pi4rknMOFsnJlhneS3n\n", - "Uwq8q4B+A0symYwXym+tO5VKRfsJxqler/fl1yfSXTuYecM6jbGx9HNoaEjfgRw0A1mDMc9kMtou\n", - "9ofCb6z3GPxjBwYGlH3E2nD58mXPF8+qX8oJqXth2zZS/TisYSGbnp42nQfdRYSzf2MhWFpaMqPN\n", - "oLR4AX3ta1/zrtmzZ4+X3+RDH/qQ5jABekWuYePDRYmxiHAeDig1Jt/evXu9ws0idvkPt2Bws9nU\n", - "ScMbGuuozd1Q4fcinYXCjZDhe3L5BCtqxo3+EfFfMpbcrGCCWq2mfcKEvHbtmhmAcPToURHpZC0W\n", - "6URUutmkeTOB+y4uLno0tFVaoV6v68sa4Dxc3B9E9kDXOBjCWsjQlmw2mzg/MJaW8WHpejqd1vHi\n", - "uYKXARboZrOpY43vepVqgKxwvzvvvFOPCvDCWltbSyzSjP7efPPNKje81Ofm5vRFYeXG6nVflJ3B\n", - "PIuiSOXERboBK8oKuJ6oniRg3t51110aJeYabdy+iYkJrxoDOyMzOHN3L1y7ds3T/Vqtpi8IyJwr\n", - "TQC8bnDEHxtXLqAHY2NjOsbWEQ/usXPnTr03jBRrzNlI4f5gTWCdwLoIveJCuygZdvnyZa9dxWLR\n", - "m0PWC7dcLmsbID9+CWMTYBkYN954o75X0BZuP4zndDodW0/cNhw8eFBlbc17GDutVsv7fmBgQI0c\n", - "tHl+ft5098C7yi03JhLXCbTVGmtez6B3HOjj5lxsNpu69lgbY/RtYGBA78O57zAm1tEtSAWR7thB\n", - "F1utlvZjs0hURjjaCwgICAgICAjYIraNkXKpTexSK5WKV/jTYqPGx8e9zKdMdXINI1id2Cmvra15\n", - "hSktMBv1yU9+Uu/nWpO9nNFgjYEGz+fzHvVbrVa92m3nzp2L5bcS6ey8QTnjvrlcTpkodtK1rFNY\n", - "LsViUeXLjJTLBDUaDe+YjJkN7OR7ZVfG55zHyirsm2RJs9WJ9sEayuVyXq0o9IX/tlotM9eNlRcI\n", - "/94s1QYsQ4wbW1Rswe/fv19Euta1lQdlZGTEy3xuySSbzWr7kwp6TkxMKGOG57333ns6B6yw8s36\n", - "e9ttt4lId0wbjUas1pWIaEg7Y2pqShkGWKTr6+tqHeN+b7/9tscI5fN5tTo5UzOsdViQQ0NDsbUE\n", - "cxa/yeVy3vgXCgVlepjVc49remXwdtErlxGAWqBXrlzRnE1W3U/ozksvvRRzxMd1+C0zL1xfrhfS\n", - "6bTHNPQbwm4xKtYx+OHDh5Ud47pvFjCHcQR45coV1aOk/Ea9nKcxb3hOo384FuZqEZgXfNT3kY98\n", - "REQ67hJgMfi43GVAucg90G63Ve+471i3Mc937dql+cOsmpqc1R5tsQIQwFqKSKzmHk4xkmTZy5Ed\n", - "eocx4txykLPF1PJnWC/y+bye3nCBdOgH5nK/6Vc40MfqG+ZAL2d2rDfuu9VtP9YstLmfo73ASAUE\n", - "BPyPoF8fjoDN0e/GJ2BzvN8JnwMCti2zOSyEpKzZfIYK51LsROv1uu4UOVwZO1ZMFuvMd2xszLOW\n", - "2Krk2lLIWot2/su//Eti31B1fGlpSe9n7YAB9q8B+KwdVjlbGpa/E2fvxtl3s9lUSwqWEg83rPGh\n", - "oSGcRkuHAAAHZklEQVRTXq4DYLvd9liqoaGhmKM44Dojl0olz6dnenpaLV5e3Di5nEg8KSWH1sMi\n", - "ZCYFdZLgINlqtTyLhzMGgxFAdmpOfFiv11UXWBaQEde+c5kLZMJlDA0NeX5nmyW5tIAxKBaLno+P\n", - "xSAws4J0Cvv371eLFKzm6OhozIlbpJNFu1dGYfcZkFsvB/r/KXBiv9/93d8VkS6L/eabb3psQiqV\n", - "8lJsiPg+dMyicuh8ku+UxXQm+WFt1ieM1+LiopdYNGldEYnXhExKZMxJdt30JtZaw6kTcF0vfxK3\n", - "7tv6+roXrHE9wLiBkSwWi54fzPj4uN4bOrlv3z7TxxRAtvXTp097zJWFmZmZWIJnkc4axnXmRDrj\n", - "iHUv6VU7Ojqqz4PMNzY2zAoXuM/o6KiZsNcF67GV7Ph6USqV9D5ra2uaQBa608964QJsK3R8bm5O\n", - "1yfMKc6oz36v0AXMs0ajYe4DIEP8ln1W+RkYL+h4s9ncNLO5RNsAEYn+5E/+ZDse/b8SQZbvH4Is\n", - "3z8EWb5/CLJ8/xBk+f7h/5Isk7ZL4WgvICAgICAgIGCL2JajvY997GPy3HPPfdCPDQgICAgICAi4\n", - "btxzzz3yve99z/xuWzZSAQEBAQEBAQH/GxCO9gICAgICAgICtoiwkQoICAgICAgI2CI+8I3UU089\n", - "JQcPHpSbb75ZvvSlL33Qj/+Zx8zMjBw9elROnDghd955p4h0kr/df//9csstt8gDDzxgppIIEPnN\n", - "3/xNmZyclCNHjuhnSbL78z//c7n55pvl4MGD8vTTT29Hk39qYcnyi1/8okxNTcmJEyfkxIkT8uST\n", - "T+p3QZa9ce7cObn33nvl8OHDctttt8nf/M3fiEjQza2glyyDbl4/1tfX5eTJk3L8+HE5dOiQ/PEf\n", - "/7GIBL008QFFDkZRFEXNZjPat29fdPbs2ajRaETHjh2L3nzzzQ+yCT/zmJmZiebn52Of/cEf/EH0\n", - "pS99KYqiKPqLv/iL6A//8A+3o2k/9Xj++eejl19+Obrtttv0s16ye+ONN6Jjx45FjUYjOnv2bLRv\n", - "376o1WptS7t/GmHJ8otf/GL0V3/1V961QZbJuHjxYvTKK69EURRFKysr0S233BK9+eabQTe3gF6y\n", - "DLq5NayurkZRFEUbGxvRyZMnoxdeeCHopYEPlJF66aWXZP/+/TIzMyODg4Py8MMPyxNPPPFBNuF/\n", - "BSInPuCb3/ymPProoyIi8uijj8o3vvGN7WjWTz3uvvtuTfgG9JLdE088IZ/97GdlcHBQZmZmZP/+\n", - "/VrqI8CWpYid6C/IMhm7du2S48ePi0gnqeCtt94qFy5cCLq5BfSSpUjQza2Ay0K1Wi2pVCpBLw18\n", - "oBupCxcuxCovT01NqZIH9IdUKiUf//jH5Y477pB/+Id/EJFO/TRkNueaUgGbo5fsZmdnZWpqSq8L\n", - "utof/vZv/1aOHTsmn/vc55TyD7LsH++884688sorcvLkyaCbPyEgy7vuuktEgm5uBe12W44fPy6T\n", - "k5N6ZBr00scHupHqVUYgoH/84Ac/kFdeeUWefPJJ+bu/+zt54YUXYt+j1EnA9WMz2QW5JuN3fud3\n", - "5OzZs/Lqq6/K7t275fd///d7Xhtk6ePatWvy0EMPyWOPPaalVYCgm9eHa9euya/+6q/KY489JuVy\n", - "OejmFpFOp+XVV1+V8+fPy/PPPy/PPvts7Puglx18oBupvXv3xupDnTt3LraDDdgcu3fvFhGRnTt3\n", - "yq/8yq/ISy+9JJOTk1qX6OLFizIxMbGdTfyZQi/Zubp6/vx5rQcVYGNiYkIX1t/6rd9SWj/IcnNs\n", - "bGzIQw89JI888oh8+tOfFpGgm1sFZPlrv/ZrKsugmz8ZRkZG5JOf/KT8+Mc/Dnpp4APdSN1xxx3y\n", - "1ltvyTvvvCONRkO++tWvyoMPPvhBNuFnGrVaTQsXr66uytNPPy1HjhyRBx98UL7yla+IiMhXvvIV\n", - "XTwCNkcv2T344IPy+OOPS6PRkLNnz8pbb72lUZIBNrh47Ne//nWN6AuyTEYURfK5z31ODh06JL/3\n", - "e7+nnwfdvH70kmXQzevH3NycHoGura3Jd7/7XTlx4kTQSwsftHf7t7/97eiWW26J9u3bF/3Zn/3Z\n", - "B/34n2mcOXMmOnbsWHTs2LHo8OHDKr/5+fnovvvui26++ebo/vvvjxYXF7e5pT+dePjhh6Pdu3dH\n", - "g4OD0dTUVPRP//RPibL70z/902jfvn3RgQMHoqeeemobW/7TB1eWX/7yl6NHHnkkOnLkSHT06NHo\n", - "U5/6VHTp0iW9PsiyN1544YUolUpFx44di44fPx4dP348evLJJ4NubgGWLL/97W8H3dwCXnvttejE\n", - "iRPRsWPHoiNHjkR/+Zd/GUVR8vvm/6osQ4mYgICAgICAgIAtImQ2DwgICAgICAjYIsJGKiAgICAg\n", - "ICBgiwgbqYCAgICAgICALSJspAICAgICAgICtoiwkQoICAgICAgI2CLCRiogICAgICAgYIsIG6mA\n", - "gICAgICAgC0ibKQCAgICAgICAraI/wdvk9M+hXkCqAAAAABJRU5ErkJggg==\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "feat = net.blobs['conv1'].data[0, :36]\n", - "vis_square(feat, padval=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The second layer filters, `conv2`\n", - "\n", - "There are 256 filters, each of which has dimension 5 x 5 x 48. We show only the first 48 filters, with each channel shown separately, so that each filter is a row." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXuMr1V199fMnDmcO1c5wAEFFfBuVaiXat7GiMb+YWrS\n", - "WhtvpcoteI2gomKoaETF6FFMuWgoaY2paVrbNKmttrWttRFbQ1VEBZH7RZCLcO4zc94/Tj7Ps3+f\n", - "51nnR0d8533frO8/M7+Z/dvP2muvvZ+91l6Xmb179+6NQqFQKBQKhcL/GLMrTUChUCgUCoXC/6uo\n", - "g1ShUCgUCoXCMlEHqUKhUCgUCoVlog5ShUKhUCgUCstEHaQKhUKhUCgUlok6SBUKhUKhUCgsE7+S\n", - "g9RXvvKVeNKTnhTHH398fPSjH/1VPKJQKBQKhUJhxTHzaOeRWlxcjBNPPDG+9rWvxZYtW+Lkk0+O\n", - "L37xi/HkJz/50XxMoVAoFAqFworjUbdIXX311fHEJz4xjj322Jifn49Xv/rV8dd//deP9mMKhUKh\n", - "UCgUVhyP+kHq9ttvj2OOOab7fPTRR8ftt9/+aD+mUCgUCoVCYcWx6tHucGZmZmqbLVu2xB133PFo\n", - "P7pQKBQKhULhV4LME+pRP0ht2bIlbr311u7zrbfeGkcfffREmzvuuCOOOuqoOPbYYyNin9XqmGOO\n", - "iZ07d0ZExOrVqyMi4pOf/GRERJx++ukREbG0tBQR+/ywDjrooIiImJ3dZ1T7xCc+ERERr3zlKyMi\n", - "4oEHHoiIiCOOOCIiorOS0cfFF18cERGve93rJtrR73333RcREQsLCxERsXXr1oiIeP3rXx8REdu2\n", - "bYuDDz44IiLWrVsXERG7du2KiIjLLrssIiLOOuusiIjYsWNHRETMzc1FRMT69esjImJ+fn6C9re9\n", - "7W0REfHwww9HRMSqVasm2m3cuDEiIj7ykY9ERMS73/3uWFxcnKBzw4YNE8+kb2ih79nZ2bjmmmvi\n", - "xS9+ccfTiIhPf/rTERHxjne8Y4Jf/B9+c2DeunVrnH322RN/Q9gYLz+Zz3POOWeCX/yf7/ETWt7+\n", - "9rdHRMSBBx448b2HHnooIvbJC32/5z3vmejjF7/4xcQz4OmnPvWpiXH62QcccMDEuOHj+973voiI\n", - "2LNnzwQt27Zt6+bpj//4jyOin0/keu3atRPPWFxcjG9961vx7W9/OyIi3vnOd048E8BX1gUBHO9+\n", - "97sjImL37t3dM9asWTPxXfjy5je/eeLZVngYL+O84IILJmi+6667Jsaye/fuiIj4/Oc/HxH75Iu/\n", - "8R1kZdu2bRNtmSNoYI6QNfjI/MMXyyJo19GrX/3qiIg47LDD9tv3lVdeGRERL3jBC+I3fuM3OlpY\n", - "N8gJfLnooosiIuKtb31rRETccsstE89h3S0uLsZnPvOZiIh4y1veMtEHsgJf+MkcnXnmmRP8g2b4\n", - "ytzS/rzzzptoR/8zMzODfZE1xP7GOPnZrueIfr9AzgHfp/3HP/7xibEeeuihHS3mJXsu+/k999wT\n", - "Eftk6wUveMHEWoro54h1xPi3b98+wT/6Z6zsLxs2bOjoZ6/wXsTe9eCDD3bfiejXGry95JJLIiLi\n", - "3HPPnRg//Wfr4gMf+ED3frj33nsjYrgnsV+89rWvjYiIzZs3R0Qvq/TNM6EdvtAfz4F2+r/44ou7\n", - "fY53CONljq6++up41rOe1fGc9yLPNK+9151xxhkTtPidtbS01LX9/d///YiIeOxjHxsREYccckhE\n", - "9O9s3mXIFu0ZF30CaGO/+IM/+IOI6NcRNLfrgv2f+YfHtJ2dnY3bb7+9W+fXXHNN7A+P+kHqpJNO\n", - "iuuvvz5uuummOOqoo+LP//zP44tf/OKg3dFHHx0vfOELI2K4MRYKhUKhUCisFLZs2dIpBv/HD1Kr\n", - "Vq2KSy65JF72spfF4uJivPGNbxyN2Jufn+9O+2gLPoEDTsWcsBcWFjqthFM44LtoO/yfZ3HiBE96\n", - "0pMiIuLwww+PiF6j+vGPfxwR/cndtDz00ENdn1iYOO22Y2xp4qSdmQehFa2GMTBu+gOzs7MDK4D7\n", - "AGg5aFz33nvvhFXCffPM9lntT8Ye0fPkkR6IoQ2+oWmgiXr+rSWiRY0BuqHP828wbjRL2vHZc4p8\n", - "8D00sJ/+9KeDZ0AvYLytZaLlM+1//vOfT7RDAzMtyNPi4mLXD234H2BubLHK+ILlgX6tBXodzc/P\n", - "d/TDc1uYPU5ohabM4uQxMTc8p+XLkUceGRH7NsGI3pKGtmu5XlhYiJ07d3Zzw7h4lvmDrGOxRg6Q\n", - "0Za/9OX1zndMiy3WPMtz6X4YG/vFhg0bOnoA84flnX2NcUyTXb5v+QHQzHPn5ubSNQRY78wBfY/t\n", - "cy3gC/OPxQ/w/XXr1nXPyOQcnvNs9lE+ey9iTnk2c+v3BDj44IO7NnzX8g/YW7By8gxk2GAf9G2B\n", - "567ty+Pi5/z8fDeHEf083n///RExfAebn7Rv96SxdhG9BYp3ErLFe8HrxZZZ5pR5b+mO6OfQNM3O\n", - "zg5ki3HBF/qyJXYaHvWDVETEy1/+8nj5y1++3zaY9QorBzbVwsrB196F/7PgwFVYOdQcrDxqDn45\n", - "/EoOUo8Ej3nMY7qTJfDdN+AU2d5fWpsD+NFweuVUinbPT4A1jFMsNKHdQRNotWhOsZnGCI32t2l9\n", - "ZMZAe07L0GZLzPbt2wcnbMZjixSaBX+fnZ2NLVu2dCdvWxjgE2NjrGPBBNk4Mi3QGpo1b2uBreYa\n", - "EQOaWx4wX9ZqzHvgZ03TotH+oRl+bty4cdAXn20VazUvLCgtbYzHFhrzGVp37NjRaaHMk+ffMkp7\n", - "+GUNjGAQZI9x26cGLC4uDqyAlimAFQ8ga9Bk2qGRMZj37XNowzP4TBvvGz7Ioh3b9xDwTKwHtky0\n", - "+4u/C4/tj2f87Gc/m6AVechk0pYZ5qwFvpHwhTWVWQGYZ2hufcDa7wP+znO2b98+8IEEyAk+ptwG\n", - "ZPsIfLSvqa0fAHlZs2ZNRwO8sZxn+wJ8cXtot5WU9t7z7rrrroHl0H0AeIeVkLmCBo+TfvzMsb/b\n", - "z4rPjHvz5s0TY2W9YKGxj6HfO/DBty5j+ymyg+Wd8Xp+gZ9JX/RtWYQG721LS0sD62Xmb8l4s3OG\n", - "USViCoVCoVAoFJaJFbNIRfSnPTRRToPW5Gy5aE+VPtWjjaHt2E8hs3Y5coxTbOY7tG7duk57zTRp\n", - "+4hMs0g5wsj+Xz5Nt3e+9Jn5glkLhg98Ns95lu/1/ycwTS3dLfi/o9MAtPl+3mNoYc0rgzVLPmfa\n", - "MXNsi8zS0tLAf8QWM/swWF6swfM95iLzHZmbmxtEGZkn0EbftkR4Tsa0ufansbS01GmvnqdMFjO/\n", - "C/PW//eabWm3v54tRRktjNORleaLfc2ydi34n9fqmAy1fVu+rR2jibfReozF8su4aWuNO/NLgxa+\n", - "z/e8F41ZQDN/GmiwFWvTpk2j7Xm2LW2ZNb39P22ydeu9hjmalsbHFh3T2razJTWzcvB/RwT6FsW0\n", - "eg8fuyHJ/PGy8frdla1N4HUBDX6PRAytm8AyBPxMr4tsr7bv2Nzc3GB+/H6DXsab3TYZZZEqFAqF\n", - "QqFQWCYe9Vp7j+ihjyBpZ6FQKBQKhcL/LciOS2WRKhQKhUKhUFgmVsxH6v3vf3/nA0SkGd773LOS\n", - "ZZesrPhtzMzMdLk2uP/84Ac/GBERb3zjGyOiv1/Gb8O5WciaSnZg7oSdXRVarrjiiojos0lv2LCh\n", - "u0d1lI0zchOdwH0skULcT3/gAx+IiD6zsSNNiETkzpcMwe9+97sH0TX4WfGsq666KiL28bvtwz5g\n", - "fKZvssPCN2dv5zl/8id/0mUqto+T76PJyMt8wnP4w/fgD9mkyVRMzUbm5Ljjjuue8973vjci+gze\n", - "bT6biD7PC/N66aWXRkSfZRta+YmsIZtk5aV/Z23euHFjd8fP/MNznn3nnXd2bSP69BNkqkcWAXLF\n", - "M8i/QnuyD2/YsKGLImM9QJ/lnPE46ziyTGZjZJFszPgcQgP8IYv3e97znoFvB3NA36xRaIEG5ABa\n", - "kAP4+KY3vWmiP/vKIIuf/exnB1n2Lef8dHZoR1gyTnD++edHRMS73vWuiWc6wnbPnj3x2c9+dqIt\n", - "8sraY58DyBYZ3OELkcOM1xnfod1RnXNzc90zWc9knobHzoeGjLLPMUesF/ZFZBF/JrLsk/EdjX37\n", - "9u3dPLJ/sZ5Z/4yTdWP/rc997nMTfcNzovwYI7TzvmBNb9u2raMb2SE/GmuIvQWwbpyHy+NE/uE5\n", - "zwF/9Vd/FRH7ZAAZJB8U42YfYC/i3cI4aWffMWjh/eIcXswBc/3hD3+4W8/MJ3vs3XffPfHML3zh\n", - "CxHRr3/7DjnTOXNKJQT83ZiTVl6gGzm37xhgXr3/w2v7vUIL6w4+Ok9l60uFnJ922mkR0fMOXjNe\n", - "xgHtGcoiVSgUCoVCobBMrJhFau3atXH99ddHRMR//dd/RcS+3FIREc973vMm2qIVoy2++MUv7k6t\n", - "3/jGNybacgpFa+HkTR4l54WyJuHM3Y7G4eR61113xU033RQR/QnaSUYd+fC0pz1tok++Dzj9Yqmg\n", - "P/qxJvuLX/yi44nrlmGxA5zGqR3Es+A5mhqAZmix9bC9K3bUJVagLCcTPGdeoeWoo46a+D5wHSyy\n", - "0cN35Cii135p6xpKjoRE24fWH/7whxHRa8fUgwRoUfCXRHb33Xdf/PSnP51oi0XpRz/6UUT02trJ\n", - "J58cEcMoPHhKrUo02BNOOCEiepkGzM2mTZu6vpBzZ1pGdhgP/8fqYViLI98VfHTulpmZmUEeGEfC\n", - "AniOzN58880TzzrxxBMn2ttKxPegYSxijr4cCWRrFvKBdaDN6xURg+LqtEdzRQaxNrbatSPC2jqX\n", - "7XgA/EKO6BOasjXtnG8HHXTQwBoMr57+9KdHRMSLXvSiiOj33h/84AcT7eEba5Q1iwxmkZXI7LZt\n", - "27r17Ag/5AEZc/Zs70X8/ylPeUpERFda7D//8z8joreqAPhw5513djxirTgKi3XDPPMsaHckrvcq\n", - "5pS93O+A3bt3d22QHayBrhbA3k179jJn2we2mrHfjGXlZn5YW6wpxos8G7bsZhGHjI1bA+QAPrW0\n", - "O9cfFjXkwfICbF3OsqdnlVFmZ2cHEX7wkGe6gscj9ecui1ShUCgUCoXCMrFiFqn77ruvO4Fyisc6\n", - "Ym2XEzna/0033RS33XZbRAxP35z2OQlz+uWU6uzgrteDBoKWYwsGmstdd93VnWZdrRs4Rw1ay1gW\n", - "5Ihe43zc4x4XEb1GgrZozf7AAw/sNIwbbrhh4rvWpJxFlv+j/bk92rLrCLoKePs7mgG8Hmsb0c+B\n", - "76PRGm1hYA6Yk+9+97sRMcxaHzH0z7JWZwskGkqrSUf0PkHmOXONnLXatTVpZA8rCJYFaLLs0t4Z\n", - "kPk79R9Bm+GbNozflhesodDIM/hs64mziSP38Nyy/sADD3S8c50+W4XgLdYw55qxlQzarB264kHb\n", - "NsujZTlHBhnnt7/97Yjo9xpru/YVYQ+z70j7OzKG7GQ1JVmb0A4N7IvW1O33x3O2b9/e7X+A+cea\n", - "gyUC66fBfoGVBHlibr2mkRfW9gEHHNDNBZYSYHoZp+ueAW4VsEh961vfiojeuu51B+3btm3r9g7G\n", - "YYsE64D/Q3NWP/Xxj398RPT744033hgRvdWYtQ1Wr1498M9lHn07Au/s55pl5Ud+nDGfMbf9Y0lE\n", - "XpmTti5hC9e/pK/WJ7SF91W+P7ZfOP+bLU1+R7O/29fQFTKA+dVWN/Ae4vp9vIOyHGgZVuwgtbS0\n", - "1C0QFqkPPYBBcVhYs2ZNmqSQz047z6RlBQ6ZHF7WWcFRJv2www7rXghMwlgJl/bZdvT2xsgiRCg5\n", - "eJlGcMghh3QLgv858R5AgBAUC6X75vvwkQ1mrAQNffuZWbI3xsNLzEkxvSi5XmDzt7N+ewiAt5jH\n", - "4TEy5YXBeHj2E5/4xIjo+WhZZNxcu/Cc9evXD8bJBu+iw5ZJAG18jxeMX94A2nbv3t3NZ9Y3mzPz\n", - "yTiQOW/qdmD1YcbrrnUu5tm86H2QgmfIHId/5o45AZZR1qSLgfv3tm3mqIpswR94npV/cvJDJ/1r\n", - "+cK4nYCV8RvICfsK7e2MDXxozA6LET1vv/71r0dEf4Dytbz7Zr9ANqE94wvKwpo1a9KSH8gQyogV\n", - "sOzl9c///M8T/2ddWL543pYtWwZXNgZtffWXuXZAI+4E7GUuAgzWr18/KMqbJfNkfl042QcCgMz6\n", - "MDSWTBpFiGciY9NKZ0ETfU9LJsrexd6eXRlG9PzwVb/BM7M92fCVX+tq4PdcljSbfdJ7UYa62isU\n", - "CoVCoVBYJlbMIjU7O5sWUPS1hEtrtNqOzXqcKF1cNTvV+9lOB+D+oWXt2rWdFp+VWbBZ087Xvtpx\n", - "KDpaACf3sRIRtiS4aCSww66tZ1lBTGhCE0VDaWl3CYtpjnpYO7JnZhYszOe+Smz5wnzCc2tWmUbi\n", - "ucpk0cVMWyuT6YbnLhialc4BmOHttJ+VwmjHl10bY3lBXrBEZWUrkBN+Oi2ILRit5mmrjS0G9JVZ\n", - "ajOHcDuvZwWqI4blaTJZxGLB9Rl7TCYvgH6xGrTWQQB9WXmazIJpN4RsPUEb/GqLuvuqFouEr9td\n", - "AgjYWoR1MbNIwMe2wDD0ety0dXmdzArIHsR42T+gPbvBWL169UAWTb9TdGTlWIAtci5MbywtLXVt\n", - "/V1bDl0SijXFuLPyNubnWJAHcon7iK2dWQkZ9gkHkHj9s0/AP34y5rG9KysR5f2CcTLf/l4mXx57\n", - "xNDCSB/MBRaobF1kKItUoVAoFAqFwjJRJWIKhUKhUCgUpqBKxBQKhUKhUCg8ylgxH6nTTz99EGLJ\n", - "XbDT+JPyvw0xto8K6eTPPffciT4ddUbfpHx/y1veEhH9vbWj+/BzuOSSSyIi4qyzzoqIffew3K8T\n", - "wfHUpz41IvqSL5SIcDkO7p25P/7Upz4VEdGVt7CvAN+Hlssuuywi9pUIcBQVd9N8h1IY0I2vDH44\n", - "9Ml4GSdp9p3CwX4KH/nIR7qU/9BgfwPuqCmFQWkD/DDgg32emFPmyOVb2vB3eMg4ofsZz3hGRER8\n", - "73vfi4jen4JSKKeeeurEswlvJqyZuaIsB+3xfyJqctOmTZ08UKoCHjKfWVgzck4ZD6eawKeINCG0\n", - "pwTNLbfc0vlTIGN8hhZK/hCtA+AHfgXwkVIY9udz5CFlPC688MJOXgk/Zx6JWvrQhz4UEf0cwVvk\n", - "hBQURFC5pBD8wx8DuWFtb926tStt4XXBT6LVvvSlL0VEX67C4d+OOPN+Ab+gvV1HyArr2Wk+XCqI\n", - "Mi6M0yU+kB9ohBbGylrEz+s73/lO9ztlMxgn65e5coQgfVMSh3ERzYyPDWOhPXsdY1pYWBjIO+WK\n", - "XH4E+knmyL7gvQtZhR/ew+if90XEMDGtS9tQCoc15iSvpKygPeWwnOLDEWXQcs455wx4bn9cxulS\n", - "W/TpqE/mFHlhT2du8POBr1u3bu36ZvyOZuWZ0IKcA57NumAOLr/88glagPeL9evXd/sWbR1hbn8t\n", - "xom88HdSe7BfQLtLswH6X79+ffdM3i0f/vCHI2KYoJjxsY4ob5WhLFKFQqFQKBQKy8SK5pHCCkC5\n", - "gi9/+csRMYzCcAHiO++8sztZOhmbEy+SvBFrERoG4OTJMzhx89N3opyK77///vjd3/3diBjmoHJb\n", - "omqwipAHifw5AI0TrcGlc+xbtnfv3m68JKejjROmOQIMTRS+fOc735loj3ZALqtXvOIVEdGXUGlz\n", - "4TiPlCNZsmgjAO3Qdvzxx4/SAr+uvfbaiOjzSj3hCU/o2jKfLjuB9QPtDUArMgc/sP787d/+7UR7\n", - "+IosYvHctm3boISL8//85Cc/iYhec2ReAZon/TDev/iLv4iIXmMHaFE33HBDPPe5z42IiN/8zd+M\n", - "iD5fEGD8yD9JXuGPLTIAWaSMC9Yg0/6zn/2sswxAp/OEAeYfXr7kJS+JiIjPf/7zEdFrmgAZhwZK\n", - "BFHu5J/+6Z+6ts4t5Fw1pps9CLnBYoUsYh0zLfQH35hTZDliuA7IsXTddddNPBOw1yCjPBsLQxb1\n", - "Bz/R1B/72MfGX/7lX060hV6spqx3ZIg9CTiPHOOCRvMFsC/s2LGj2zsoLg5sYXnmM585Qb/Lfrl8\n", - "D2s7y5nW7i+0gS6X2XGCSmhCdl2Wi3UPTfAFvnrfXVhY6MaLrGSJRJ1Ml3Ex3qzkECWFXvziF0dE\n", - "L9P/8i//0rXF+sU+wLvKJVKAo1IdKZvxHHliP2W9OUo8Yhid6ShUwGcnVSXnG/sCsDW6vSFxtCFr\n", - "jfea90FbNDOURapQKBQKhUJhmVgxi9QRRxzRlXm5+uqrI6I/odoixSmYn/fee++gFAzAEsXJEs3J\n", - "GYiBc2/Y98GnY06027dv7/xojjnmmIiI+MpXvjJKt0umcEL26dh+WWgg8MkFMWdnZ7sTP1oL43Tf\n", - "aB5Yb5wPyAUw0USc4ZixfPOb3+zaukCsNQtbpKzVYeXISmfQH5YO5oqxtH4/Hg90usQBcBbh73//\n", - "+xHRy4+1RueuIbfVfffdN7Be2iLDZ/sbAHiNXLk0gmWRsRx//PEdT/HxsoURGhgP7VkvzuDLs/F3\n", - "Mt/GLJ7wvs1uHTEs+YRWjPWHigVo2LYaM99YTewr01p2XCbD1k9r9cynMxk7j45BO/7Pemr5Ag30\n", - "zU94aosUfbAHwQfWOFozaK3jERH/+I//GBERz3rWswZWIGfBtiXW+XLsn8Xe41xXGS133nnnoGA4\n", - "cHUJnsV3vUd7L2ZtY01w//Bx27ZtXZ981/OPvCBbrEmKe19zzTUT7eGT/bvGLC4R+/jHfGPdyApk\n", - "A/YH35YY8JxqDM431soX+x+0THsGcoKcI4vw3uvK2dWRYd7T7R7gvHFgLCN7Oy7Gi4+h5Qg4j1br\n", - "3+v5t5zzTmG87MXTUBapQqFQKBQKhWVixSxS999/f3dfbd8iTrGAEyqn6C1btnSnTt9hA2dydeZd\n", - "4Bpc1hKz+mZHH310fPWrX42I3qfHEVHOqkuBYf6Olgg4HaO5YKnxKR9s37690xiwdsAX1/NCk6Id\n", - "GhT+RtZI+Yxm+7WvfW3i7z7ZR+RZsg2sIGiazDdWL8+pLTHwZcziYe3VGcpNm33GoA0/nayA8lg2\n", - "e1teXAgVrT6zAtGO8WGBw2fKmhpzceSRR3Z9MU9Z7Sz8KejT0TXABaFdMwtNH7RFank2GqP90my9\n", - "4Rlo6LZIIav8HUsW/GnXNONxxmIXeAXQYMsE4/M4eRZy4CjYVr6cbZ62fNdWPdrZEm2/HoAlBnlh\n", - "3Vx//fUDHjJuMpxj5WKvyTJ6QwvrA356f2G/habNmzcPIoIB84k84ztKO/up0DfryTUWXd2Bftev\n", - "X9/tX74VcFv7JfFMv4ugAX6xZ7GmnZU7YuhXh1Uv80uEx8yNC7ED1j83IlihPYa2D3hmH0/vi84m\n", - "zvigzfVQacfY/J5t36P87lsQ1680XJ3E/AGOBnS1ixZYlFkP8A75zmo0GmWRKhQKhUKhUFgmVswi\n", - "tWfPnu4kyamQ0392mm1/cmq1Vm+LEtqa63oZPq1i/bGVAczOznZ9cqq3v5ZPs86DlPkZoC3Q3nmn\n", - "wNq1a7u/2QLjU7o1cvPPmhdao/22wFiF+exu29YuR1byOatB57ljbETatNoUMmIfsKx6Oc92DhPn\n", - "cAGuJ9hqx55PxgHv0MDgneUDntuHztYh0Faqpy8sDpnPm+vTITfmOc+yRdbWhPbv8IY1wzNsSeVZ\n", - "9IUWO80nxJYu+/20vzuvmqNWAfPO3EFL6ws5BltgaNfyy/LKGnOdQ8BnrH9o3PTtiEPGRv98b9eu\n", - "Xam1k3GyL7p2JGAuHJELbE2xNXr16tUDayBg3qHJ1hJoM5h/59mzFajlq/dD84Vx839Hn9maBo+R\n", - "YecdNJ+WlpY6GWFN8tmWWkecmqemxTcePBvZbS2e9p/iWVhcvZ/DB2h17dpsX/Rcs0bbvc55ER2B\n", - "n/mb8UzfBpgW+EG/8GHnzp0DOYeH8Jx5hz++DclQFqlCoVAoFAqFZaJq7RUKhUKhUChMQdXaKxQK\n", - "hUKhUHiUsWI+Um9/+9u7e1nnIeL++TOf+UxE9LV5+PuqVasGEUKutcddbebLkNVacw01rGdkl6Zm\n", - "UUR/1+toCurVUWvL/jqONqMGHe19P82dsGvWUd+q/Y5zq5AtmrpvjAe/LvjH/TQ1oqjNBp+hmTHQ\n", - "z8UXXzyYH+AMs/T95je/OSJ6/tmXgvFS94lxcr/tWnU7d+4c1OWyj1NbpzEi4mMf+1hEDGtEAfhC\n", - "P9RDo46T62E9/PDDnQ8E46TvzK/K46R9lm+Mz9DCWGdnZwd+Atzxsy7gITJknxGemdVmy3wFqJ/1\n", - "1re+deBn4txt1PGjdpb9uDxO6ptR98850uyn9fGPf7yTrWmRP6xR5rOt2xjR+2nQD3uR68SxX7R7\n", - "2YUXXjhBt31enE+M+T/ttNMioucXPLfvi2v5uV7amjVrur/RFtmyTyV0IwfsLeyj3tto5zpx8JHn\n", - "tn5x/I22niP7vvFM5p9x2qfWexhzBN/bmw/7I0IL44THrp1ItKLruDnyDL64Zt1pp53W8TjLFs4a\n", - "pXZmmwer/WzZZU07Nxhj4Huf+MQn4m1ve9vE37xfsOaozQkPWQfeT5Ej3i/0Dy3MLX6w69ev7+im\n", - "rfcW9w0ttPe73BGkruXqKh/bt28fvHNZz9DgiD/kmD09Q1mkCoVCoVAoFJaJFbNIzc/PDzKPOvqg\n", - "bRvRaxW7du3qTrqZ5ukMx0SCUN0ZcBLn5EnmVzLaPuMZz5ho3+b0cHSAIxYcKeHxOtoki+JC83I+\n", - "mb1793Z9wTNO3FlOK0C0Blqgo9k4ocMXa+xtZKWrmjvaxM+2BsW40eqyGmTOOo8MtNov8+kIQOTA\n", - "VgznJrF11LTAb/pDc73++uu7mmHuG1qYG/p2FM4Yb1uaHEHWtqeNtVIAH5gbeEdOJmfN9zOQ7Szf\n", - "2uzs7KCiPPPpCC9bNZk/W14BPOeZbm9LaPs/r8Es5wxwlu2ssoGtS0TUtXsANKAROwrXdbz4P3LB\n", - "M8iz5/qLvAWnAAAgAElEQVR2jGWsPqj3IubGkaNZVDK0M3do/bTPau21+4Vr6mUg55WrJwBbZqGB\n", - "CFXyKLn97OzswMrptWVrod9BXkeOMHbWekc/z83NDW4usjx7yLmj8UAWWWcgV61swwdHb7qKhmmB\n", - "P75VyfIOQiN5+Ki32NaVZXzwhXnP9q4sOhOZdDS7ozvBzp0701sT4HmflhMRlEWqUCgUCoVCYZlY\n", - "MYvUjh07Br4UrncHWktUxD5tmhO1swO7/haWGbRAn3ZdJZ66X1k9LGhbs2ZNd1J2zhXAZ5+C0WKt\n", - "eUED48XfCf7Yp2T16tUDrQUN0jXCrO3wLGcJNzIfqTYru/N8ORdTVt+Qv9uildFiC51pbGmwr4Zl\n", - "CDj3kflkC5b9+MgUPjMzM7AYetzMN/S6b/gADdBkKwho+etxTouMxQcQuKag+ZjlPGvb20LkPEGA\n", - "8Y3lHhrre+xZLcayD2d92grovGquveX2fMZShTWEz63V0H52rlDgtcvfae+cN7aeAfsabdy4cWBJ\n", - "s4UOLZ615Mz19Dkt2zSwP+S6deu68fi7rtjw1Kc+dYIGMtYDzy/7om8dQGuN9q1Bti5M47R3kfnI\n", - "3uw9emZmZmD1yuaxzQvX/vR7EjiLv63OLd88F86vldWta/2S236ydx00YdHle+0NidcFdNqfFfgd\n", - "b0un36/eX9ubEvM+8+e0v+c0lEWqUCgUCoVCYZlYUR+pTDPzCdOnxY0bN3YatLVVfD/oE02av9tH\n", - "ypEi+DqgHdmy0568nf3Y/gbWGGgPbVndJ07afEbrtXb00EMPDZ4J76zNWhNBQ2Dc9tewP5dP961l\n", - "x5qQv+s5so/UtCzbre9HxNBK1mpTtm7ZgmYNw5XS4bEzgANbftCWNm/enGbNBXzHVkFgHyloQha9\n", - "TlrLTuZXATz/aM6sI2ukrBvPKZ9NeztWa+3mg+ua0SfznFWFd4b7sTHDQ/vE2NLo9pYl5tm0IBfI\n", - "/09+8pOJ9q1FylY9fiKLmW+H/fuc8dq0w5c2gtAZvJ1t3lnhPf88m3GaD+7fY4joZch7FN+lT24B\n", - "+K5rrzqKjfHaHwm0e5V9PDOLlHlufz+QVU5Afmzx3rlz5yA63Xuqx5lVhMgqPoAsmjVi6F9pq5At\n", - "zoYzuWdWIJ7D3s7+0rbnWTyb+YYvvnHIrEK+0QDIlzOk79q1K+WZLW32lZ2GskgVCoVCoVAoLBMr\n", - "ZpFavXr1wNM/u4/3KfKAAw4YrXAdMTxpoyHwLPsO+O6Y+/tMm2qj13ynbU2Acfk073t74LtuNEzG\n", - "5Er0c3Nzg7ptjq4DWeSIfRuAtX37b7Uaqq0WzmtjLTCz8vgZ/j/Yn3aJFuK6bVkEof0R7O+WWUf5\n", - "ibVocXFxYO0EjoCy3BjOk+XIGdOyd+/egUUtizbimVhaM3+czLpmayOYmZkZ8Mz17tyXc9q0dQvH\n", - "2vNMxjhGCzzJ/EUsW9OsqV7/zl8HrbZUjNFi2HfMecZsqc18zUC7T9hi5KhFLKmOWgVZTcrMl8Y+\n", - "ZktLSx19ma+Xo3VteQSmzRZpz1Hbnj5d39F9eX/0T+A9zXvTmOy6j8zKwTpxxLSf7c+OJOb7LV8c\n", - "ETvN2uXbIsu9afGaxBI1tu48/7bUef69l9tqaP4io/Yxa88cwO9c8y5bu0ZZpAqFQqFQKBSWiaq1\n", - "VygUCoVCoTAFVWuvUCgUCoVC4VHGivlInXvuuYPIGtfpyWqt7d27t4t4wbp1xRVXRERfU8p31Y6E\n", - "ct/cATuPDHe/F1xwQUT0Nch27do1yF/iWmjnnXfexHj4vyMkXDuJe1v7jHCHfvnll0dExDnnnJNG\n", - "XbhG3DnnnDPKD/uxUFOKWkuu8+VIq61btw5q7fHT+aSghfpWzvjtaD7mCJ47ooLvzc3NdbWT3vKW\n", - "t0zQ6Xt44Bpk9u+CBtdagy/IRRt5xThdI9K+cfCHyDnq1VEjyn479stirK2s27+M8Vx66aWjtBBd\n", - "g9zg60V9K+qh2VeG7zHWlhbLkqNt4TlzZJ8q+0B5jrymPbeXXHLJoHaiNUjXQrPsmud8hhbWUZZ/\n", - "Zn5+flBrEWRRV9BCPUx4zP7iOaU2G3y0/9uqVas6eUAWWUMAueVZzD+1FqHF/jyObkJ2WdOtjDvS\n", - "9xOf+MQEX1z30eu/reMYMfS1c644aGcfXVpaSqPvqPsIX+CdaWI88JG6b64Ll62jt7/97QOfIJ4B\n", - "ba5vx7xn/n7so14XrkXH3y+77LJub3HEsHPbXXbZZRHRy3nmz+t39Hve856Jv9N/G/3qNedISYCf\n", - "ErUWzzjjjIl2fM+54rzvjkVJZu8Wv7uy2owZyiJVKBQKhUKhsEysmEWqjeTgBOo8S8B5mLZv3z5a\n", - "ZTyiP61a4z7qqKMiYnjSRMuxtkCeFVud2ugeok2IgMkyLkODa2KNZcFtafD3bR1YXFzseEIeKD4f\n", - "fvjhE23hEyfu1poz1rcz+zJfY9Estiw6z0+WmZr2zp/izObwCb4xN4zBfGyfzXdcGw04d5ejsLKI\n", - "QWu6e/bsSbPgI2Nor6YBOLLKFhdrbm1Eoq1dzlTOHCCzRIDSzhFhXovQzmfnV5udnR3kmMnqVGVy\n", - "4czfwHLiHGFjeXOsWWa+DciO884xZ1ndR+Sf/HRktR+TRVuLPb8epyOsXO8OQIMzPdtyEzFc9+Tq\n", - "Ye/yOG2J8po2xnLHZfl/rP3Dw8c//vETf3d774e2epjWxcXFQeSWLSvee/w5i15kLqiA4fxjoH0n\n", - "OOLNvGQencMrW0/ZOmqj1EwHvIN+vus9ifEzHr8/sqhQkFmP2r9ZPpyjz+OxtZBzg5/N+wEa2nqy\n", - "WUYA5J91kUVtZlixg1REzxA2dZeMADZD3n777R3TSVcAnNzrhS98YUT0G/+NN9440d5lGSi2iKC5\n", - "ICab9p49e7rDi1MQACaFjQL6t2zZEhHD1PcOZyWcnsV97LHHTrSfnZ3tDowcGCg+awHw5uVrRm9e\n", - "NgE7iVw7Vpuqs3l0ezYKxsBLyN+jJAQ/+R78aF9eLvkCxl5wEUPzr6+u/JLm2YyRjXTTpk2Dw4vH\n", - "x0/aeY5YDz4ouvgtaEP7GQey6IMRGx+yyMZJUkOnBaE9P+EDBwa/eOfm5gbJWrPSSYDxIbusUSsv\n", - "3tRZd/vbpP1SYg05/J29h3lkzT7taU+LiD5BL2DOmCP4x7prXzB+iWfh2sDFmfketGWpO1hPd955\n", - "Z/c/FxVm3vn5hCc8ISJ6mXKKAicqpKRQlkSZuWxLLSErTplghZESMczjzTffPNHeSgJzxMHLc8QY\n", - "d+3a1Y0vK1rsslTs+y7r4nHynkE2mX+vu8XFxYEinaXisSuHFYbsEOsQfieZjejlnPHx3jzyyCNH\n", - "+3SaB+Sa8WeHZF8rWgFv++BvGDngh0sEOX0M/ICfPrx6DnyIbOE9yy4vY0raGOpqr1AoFAqFQmGZ\n", - "WDGL1MLCwqDcgstuALQ/tITHPe5xnQZgTYq/UwJl8+bNEdFrObfeeutEe7RbTrecSNF2bMmwFth+\n", - "19cdtEVj4uTNd9E0TQvaH/xAexwruIqmgAbKKd9p9m3CNE99ineCSiwYYwV3rWFPM4taU29LW0QM\n", - "NS9fz5qPHmtEP29Z6n/A57bYakTPa1te7BiPvB1yyCGDqxdrv8wRmpetI07yaOfrTLOfnZ3tZC+7\n", - "ZobnLuKdXRu5PBGWF9q5/dLS0uC6PUuC6msT1ge0WG6ysi60by1YLnzqouTum3GwT7zoRS+a+P8t\n", - "t9wSY/CVxx133BERk2va18O2rNmCDT/YD60lZyVRsMAgL495zGMG+xb/wxqOHDiwBcBzl45yfwC+\n", - "YunYuHHj4EobwBfGg6U5S2jr7z/72c+eGIv39NYq62TPpnva9aqtHdCCzPkGgLGAubm5wTqGpiwh\n", - "s53us2tVJ1e2NbrtnzbeQ33VB+yGYvmw1dj8tWWnpZ29h/lHFnkn+drQ7wUnrPVtioNe+Dk3N5fu\n", - "LfTBey4r+ZOhLFKFQqFQKBQKy8SKWaQWFxcH4fGccjMnVDT6TZs2dVpYpjHyf/s++FTPKRhtAUsU\n", - "p2ZbDVpfFDsB2gLh+2e0O07cPuVba4AGh9qCbdu2DdI0ZAUbXVgZTWzMwsT42v/bktMWwXRKBDv4\n", - "ZiVieAbjRpvxOHGcRw7gI9pf6w9lh21rROa5HRIzHyOApk97NJgHH3xwYBnz3b4dVV1I1MU8XcbD\n", - "fl+tP5AdmD3/9GlLBTTbGoBlweVb7HQOFhcXu2dkzqQAGpFvO6mbL/b9wMcMy16rNbosiX00LItY\n", - "3NwXhXRdQJf9AprxqbSfX9sXMmIa7NDNZ1sgkLVMO+aZbdkfz7+tvi6ZkpVZYZz25zGcguEXv/jF\n", - "wHcS+JnwlGdYRu1rhWxSMNo+NR5j+7stUi29Ef1agwZbO7zuGRvraKyklItKZylrsoLJzHuWgoA9\n", - "Dv45WCGit/rQxmkbvFbNJ3iKjLk9/LN/FrLe7un2ceK79oEFLmvjkjiZNdXlz1atWjXom/95n+P8\n", - "kBWBN8oiVSgUCoVCobBMVImYQqFQKBQKhSmoEjGFQqFQKBQKjzJWzEfqrW9966DMAverLoVBuYr2\n", - "Dt1lUz72sY91/UYMo3fsZ0H6eVLnOw+PkwCSfv7000+PiH33tvTJs1yqgHICPNP3y5xuP/jBD0ZE\n", - "xFlnnRUR/d0vtHOXzHPakhLOj+LknZSfIRU+98v0DW38nVIYtOduGz4zB9CydevWQZp9l9fgHprS\n", - "BsynfYY8ziuvvDIi+pT/8AXfIfzBHn744a7MAuUh6MvRWuahyxU4ioPvUzqB9oypbcfv8Pzss8+e\n", - "aOP7dpdZYf5p71IRwKVTtm3bNsjNwjxRIoaSH/hr2E+Lufrc5z4XEX3JD/xRiKzDPw2fkA9/+MMR\n", - "sW/dwSvaOHEetCAvXv8AWXR750xzzqgrrriiK5vC/+yvx/qmjAuy6PVgvwvmiLJPwHKze/fuTraY\n", - "f/sKuXwR42QvAl5HtKe8yZve9KaIGPp5zM7Odr+zz1HCAx8fxkl+IdZ3W9okYpj7iH2FOWWsp512\n", - "2kS/bbQr4/De4sSU9o1lT6d9FmEHbdDerjv2XEeGU66GNWdaHfkGz5l/fKjYg/DvQXavuuqqiNi3\n", - "juwDDBj3Bz7wgYjoZRE4Z1dbCimin6M2b1ZEz3vk4vLLL+94iN8uvCb3GL7En//85yNiuEYBvKZv\n", - "+Mh+wbqBD/Bx3bp1XWkj3ov0kUXYsuZ453r9eM3CF7932/dSW9oson9f4KfldxDzXCViCoVCoVAo\n", - "FH5FWNHM5o5SsgUD2GK1du3aQdZn4HxBttSMZWSOGGpFttQYS0tLU329fHrPopKAs8K63I1p2bt3\n", - "78By5ig+4DIjtiwZjqhxfpA2ssbRFC6zYj7BD/rIMnaDLPs6mlj7d7Qy58kCLoVgyxM8d/4pt8ci\n", - "00YFWracHR3ZyvgCnE8qi4KD5oceeqjjkTP1A8sJwEJhbd+fnfl9LB+XrT7QkMkiliv6Riaz6CRH\n", - "DrbROMBryMiKmQNbSbI5ckZ8VwyI6OcHnnk/8N4Fn2wVtQULmF/wfffu3YOoPct5Zt0Dnks/2/vG\n", - "WBUDl40BWaZuW5hMO/2wxl1Cx+0faXmPiCGPs2Ln8NxZtuEHe1I7JngMz7Os2VkhbMZtK6krJ5if\n", - "7Zwwj9Cf5c8zLRmyOXJOq7F9lLasY1vezBfnQOQZ2V7kW6j2BsiyCE/56QhL710ZyiJVKBQKhUKh\n", - "sEysaB4p5zIBWcZfTtPr169PtRffi9q/wH3bL8saqDWtNg+FrV/OUeFCmP5/5jNjTT6rWdfWN3Mf\n", - "Hodz/ICsIKZpdRbdlnZO+bb+2AIDsEA50282p6bBeZba9llGXhd2Ba7jyJyN+Xq0sBwdcMABA+3F\n", - "4+Sn5R14LmyJsqbW+hRYm8syT/MMaLFvIMgsumDMyujcMZks0hf+JTzL1mBgzdvZp1u4uGrmh+Vx\n", - "wDcsdFlh4Xa8LQ1jfnAurmtfF2eqt0XK7TNfsjGrvNeQ+WJLimWLv/PTuYmyAtptnc1sPoH912jn\n", - "Ner9gX69VkHLP1uzzUP70rpvryPndvMcen9ta7L6GVn9T9c5hEav0bEbivZnO1YXIbfPaFY1wcgq\n", - "RPD9rDh0O6eZRd61Jk27ZdH1YoEtXD4LtHA1BlsaHynKIlUoFAqFQqGwTKyYRarVaGy5yOqhcdJ+\n", - "+OGHB/V4gP1KQGZZsNZnLXl/GKv0PfbZfhuOIAGcyK3tZtFbCwsL3Umfvqz9mhZ47MzPWX4MaHGk\n", - "RHtiN13QnWn11vb4vjM7A7dDA3EkYdvGGZlba+YYMt8IW5mg0b4xY9mkbe3Msm6bdmukmSy2z7Y/\n", - "Vka3LXVZXUR8zKyZZb5Hq1evHtQKyyyVYxXhW1heMiuCM6JH9DJhK06mKQNbAbNIMkeBZj50LX20\n", - "da099215sF9bZsEGLc1ZjThXNLDvpPuy1SizvtsPdGFhYdAHsLXTPlOWF/vD2g/HaNs5W7hpsXUE\n", - "Whx9BohyNO/3J+u2AgHTYh8gz1F2MzHN3zWif6/ZB9BRmcCWPFu092cFbGnO5rTty/tmtsf4vZm9\n", - "uyxfra9e5q9nyyztMou0URapQqFQKBQKhWViRaP2rO36JA7s5d9GQlgjdGV5R5BlkSKcmNEKfKp1\n", - "/63GNe2U7oierGq1T9quGWVa9u7dO9DWp0WqOKIh8wXIrErmr39vacj80lwpfJofiy10+7PUMD7a\n", - "WFuzpu4oRtOcaeq2viwtLaWWF+h0lEnmx2Z/NFsFPNYNGzZM5bl9Wxytl/ml8T3XQxyruG6raBZt\n", - "yWf7iGT5dmwddLReK/PZGsvWP33CD9plvmHeF/bnY8nvtpxkfknQ5tpqmUXKlor9Vao3X8C0KEfL\n", - "TRbl51uF9v/eH7JI2cxH0pbabD8BLQ2ez8xqY3+bzPLmmxBbycyX2dnZQc1U5z8D9lvye8P7nX3L\n", - "HCHX8gWrnn0ksxsMz9G0SGPftnj9tXzJouzG6I4Y+kRNq+Xq90krf5kVMMtpVrX2CoVCoVAoFH7F\n", - "qFp7hUKhUCgUClNQtfYKhUKhUCgUHmWsmI/U29/+9kG+Gde5or4NdXy4t1xcXOzu6rO6fIA7UO6I\n", - "2xpxEX1NIfKDOGcNn6mH1dZmsv+Qa0qdeeaZEdH73/AMaKFv1wiifXZvTy2/c845Z/A/TsyuhcU4\n", - "s8zO8InaSdRmc1RgGyEXEfGhD32oq2+YRcbwGVrOP//8iOj9DRyVc+ihh0ZEX8fNfITv8G9hYaHj\n", - "IfXn7BPhDM0XXnhhRPT1qhwR4igv+ocW+7ksLS11/kO0pY4T47TvG3451EOjb+ffcQ0q6mExRw8+\n", - "+OAgrw2fP/KRj0REL1sgy9XjGoT2vULeXD/x/PPPH0S8OjcLNSUZZ+vj1baHNmqtUd8sq7HH9z70\n", - "oQ9169MZ3plf1hRrCNm1H4rraFJrkzpulqvW/435p29HBgHvc/RtnyI+05697owzzoiIYSTezp07\n", - "u7+5Lf460ORM3PDFtTbhPf0yZ677Bj9Wr149kHu3hQbzkLXLHo0stvt/xNBHBj62+wVywPybh7xb\n", - "GB/teBb8Yo2+733vm2hnHyLGQvt3vOMdHa+YH2e6p+0b3/jGib6cu4vvU/cTPpKnyjTTz8UXX9zV\n", - "WgRZDT32f8uifYb4CR+pcWkfqdZ/i3qFzOdBBx000YaISOTF8+9oZ9fFo06o30etD6VrLTKfRCnb\n", - "fxP5Ye/KUBapQqFQKBQKhWVixSxSu3btGmSsdR4lMKaJOhoPZLXzgKNwnC3XEUNZtu72u1mmYsZH\n", - "n45OyOpb0Q+n4rvvvjsihhEjMzMzg1wajoBp20YMIwAzK5Jrcjmipq2Pl0WVAM8Bz8QShdZrPrl/\n", - "zwVyMRa1ZQ3UdZ3c3tFrzogP6I//t1aGLP8V48y0V9PiWnW2poJ2TtHmoO/ggw+eaMs44IMtl1le\n", - "nMyCab7s2rWrmw9HY2VZgl2/j+9nuasYG+2h/bDDDhv0nUW6OiLMEXLw3vuEv+9cRmN1vxzh6P3C\n", - "PM9qhDl6E/D/ww8/PCL6/eK2224b1PN0HqAsAsq0MyfIoKOagSsI7C9Ky1HOtjCb987dxRrOIkjb\n", - "tWueGq7j570oqwTx85//fOKzc4SBtg4mfWa1Vp3LyvXqsnx90I51kXbtunBeLFv1vLdMy3mW7dG8\n", - "o+jXlp2WFubVecSQNeB3ld9ZWaS6190BBxyQVvCwxfqR5o8CZZEqFAqFQqFQWCZWzCK1Zs2agUUK\n", - "bcAayVg19KyOm/McobVaSwb446DV0R8na592scTMzs4OqthnmpGzpNqnAdgfadOmTRHRaxrmy5o1\n", - "awZ3u1nWX1f9tqaW5cByJuwxzc5Znp0F2X17vtFAnIcIZPUR0fBaLcN+NvZHMP3wqfW3an86v5Yz\n", - "pCMPO3bsSHNO2ZKYZWR2n4wL/mQ5w/bu3duN0/4UwJq3/c1Mk/nAHDinF9izZ08nI86WbAsTz7ZM\n", - "2f/K4+T/tvC12m5WK8vjd9+M3z6AXnP4n/DMQw45JCJ62W+tDZZ7+DKtpph9fzLN2xYd5GbNmjUD\n", - "q4fz+eCfkuUR85x4jWYZwqGlzbbvtuxr8BrrqWUMuO4f37OfEuD78/PzA/+0LI9WlvuM+QW2ogMs\n", - "L2M5jex3l+Xiym4q2vG0cMULaOd90a4LW4u9jr1fOGcf46Nvy5f911x1oh0TsgdvkQdo8q0Q+6Kt\n", - "fdBi+cos4GvWrElvXuCPrcaV2bxQKBQKhULhV4wVs0jt2bNncB+ZVf+2n8OePXvSTKucLB2txwna\n", - "p1XuujkxZ1Ee7bNpby3PbX2azawi7vu+++6boAWY9l27dg0yLWcZ2bMMrVn7zHdqrLK4NWdbuTIf\n", - "Kfs8uNYUyOrBjY3NfaMRZb499gWyP5ZpsUbeZtvP/CmsrWV12iw/WBjgz/58R5yh12soy+ifzf9Y\n", - "TcWWds/F3NxcmpHdbW15AfbbAM4+Dx8c1dSOw3sL6z/r21Zj2ltesD5nUYFtJmxbGOyPlNVazKoM\n", - "ZGsRqzRYWFhIZcsRgK5N6L6dwT+zMoE2mtpZ0QH02seJ9s4mbgukI0in7afteKbVcbTMei6gxevA\n", - "6w8ceOCBg0hA0wRaC/PYOEwr/fJsfjJXLR+did9Z0L1G4S0/mbNsX7S8ZNU82r5s/WVt2UfKtVgz\n", - "XzngW6l23bktsA9htuYylEWqUCgUCoVCYZlYMYvUWG2usUgo2kZMnnqzE6NPxI7Kye72fQLnBO/K\n", - "1G3/1jizSIasvp3BXTHt7bfj/vfs2TPQYrJaUvYrwpKS1Yiincdgf4W2DzCtFhKwVsQ9vK0g1oZd\n", - "NX6slhJ9O+Llf6oFemyuyN5aKK3VuUYYtNgHCri2IpobcpDxZcOGDQOfpsznwT4jWUSQ58Z+fdYm\n", - "V61aNXgGMpTVmrPsZVYD+oNvjkxt+WjfBtNvWXS1d1u6s73IvpRjlejbHGMtndl6sCbtObHV0FGu\n", - "WNG2b98+Vc6df86gT/xTePaYX2L7uY2Umrbus2jMzDqe1az0umgt47Z22SLh9QCfPM+Ado68RTbt\n", - "37NmzZpB7byxeqXt5yyyLvPvxM8XOAfaGF18zuo++p1r62G253sPG4sKhXeOIMYSZct7FsXq9yPw\n", - "fgLaGxxgq5YjjT3ODGWRKhQKhUKhUFgmqtZeoVAoFAqFwhRUrb1CoVAoFAqFRxkr5iN19tlnD3Jv\n", - "ONcFdXyon8W95SGHHNLdr9KW+nYXXHBBRPQ5Jnxny50otdbo2xEPZIom58XHP/7xiIg49dRTI2Lf\n", - "3fLRRx898SzuX11TCDgikGdSD40aQa77xx0wn+HL+9///i7qELrx2XjMYx4TEX29MuoyMS54Tl4c\n", - "7syh5fWvf31EDHN83HvvvRPP+fKXv9zRneWN4jP1jVz3zREe3NtTO4v2vodv+2c+mR9ki2e7rt8X\n", - "v/jFiIh405veFBE9j+G9fSuuuOKKiOjn1NFdLY+QRdd9dEQZvEe2XIOMMdh/D76cc845EbHPlwpf\n", - "Fvs0uHYafbJ++InPE7L7ute9LiKGckL/8OXyyy+PiH11BfHpciQQ88n8QwvzCK3+PnJ++umnT/yd\n", - "NQkNRLleddVVgzXnXFxZTUF4Dh9Z08wVdb/gORFG9r1cXFzs6nJS8w3esT5Ys3wX2aJv1qjrW0Kb\n", - "6yfaf2337t0DupFF1jl+NbfccssELbSnvqHzkznb9kUXXTRBe/t/5oW+kXPopm9k0r4v1DdEXpwj\n", - "j/5db5Ual7Ozsx3PPF/QTd1PqkcgY/AcWeO9wn7B32nHnLHGkYFTTz114FfG+Fh7X/jCFyIiBvXw\n", - "7BPKOL1f0A95mXgO/N26dWu89rWvnaDbdV/ZH6+88sqI6GsQOooRPjIm3i+sI+9VvD/WrVvXyS10\n", - "M67NmzdHRD8H7ps6fuafIydZ08w/e1WbS9B7NO9/5Bu+2AeW+cywYgeppaWl7qWMMLKg+AnshLpj\n", - "x45u4u2AZydhmM7G6DIuwI6OLKgsjUDrXAvzXQCUyXDyQ57lpG5ODukFh1CO0eOkbA5/ZzwOlTav\n", - "wZFHHjnxf/O1PSzZ+ddFN7Owbb8oMmd8hJ+Dtg+DLV+YXzvL8/csWRtzYmdTO1UDNhReinNzc93B\n", - "2uO047ILgAIX/WXe/fICLY0Ow8+cQVlz/MycsI844oiJv7tUhGV9ZmZmEBSQpatwCLWThPqgzPqy\n", - "QzB8siNtxDC5px2bgZU35IAXjHnuUGyH+Lfryeveh66sFIZLAmUJXLPkgatXrx7QbWdo5i8rP2QH\n", - "Z77PeC27rIM2YMYHAfftpL/wy2vOCTitYFrOWJuto7cL3JqWLIQ+S0nCfuIEl95fDjrooIESwny1\n", - "ZbZaGl0qLHN4dsCD+23XNPu55YJnZHxxIFhWMsZ7VluWJWJyjbLG6IMDsdNiAAfSuByR5QuafRha\n", - "vXp16mzu1Dt+h01DXe0VCoVCoVAoLBMrZpGKGF4BZEWLKSHQlnHIkr2hYTnle5ZyICs7kJVaedKT\n", - "nvggY6MAACAASURBVNQ995hjjomI3iTp06utI2irY0nKIiJuvfXWCZpM+5gVAB66yGYWWk9fPt27\n", - "yK1Lbbi4bctPh7jaMpUVlvZ1apaQkDl1SQBfN0T0V5pZiL3LtfgqB2sXc2Ur4D333BMRvdaLnK1b\n", - "t25QNsFaHpopz/IcwTf+D63w3usCbWr16tUDS4Etr9CJ9gecsgBw9eNyJnympFILZCazQAJft3s8\n", - "BrRYrlirbfi3r1HGUqe08DwyZ9m6YPwO2Wdu2/7hEfyANsbJNQuAVmQus7YDl+Bp5S9L2wAPuQay\n", - "1Ry4LAf/tzUB2Pq8bt26NFQe2lpLQQvLC7T6FsLXMaBN2WLLWlbGK0s8aplkTqHZhYhtZdy4ceOg\n", - "KDNw31j12j0lopctr1HkJLOyttZR9kWnO7H1BjgFgy1u2X5ha/NYOTRky1Y91oP3Lt+K+GbHc4qs\n", - "OsXP/Pz8QBZdOs3W3SyRtVEWqUKhUCgUCoVlYsUsUuvWrRuUs+AkjZYI0NA5oS8sLKSFH/H94CTJ\n", - "qb0tNtwis1ygHdj/Atp27drVfQcrhTUD/m7HZ8Zt7SUrBeISAOCBBx7o6EXbye6wOXkfddRRERHx\n", - "s5/9LCJ6nttfi89oAbYatnPk0g4uFZNpr567rOSDk6W5IHWr2WFRYt75LvNonjupHePKaHHpIfo9\n", - "5JBDBpqU6UWDgk8ev7V/P9taY5vQjmfwE/kF1qx4hhMvAvhgh3f4aetI65NnB1Vr4vZftDbo9rbg\n", - "wSe04lZ2ocsWOng/LWGtEy16zVljtV9XO0f4fLj8BLQ42a8LZbfJLVvaAHNjf8g9e/YM/oa1Gzpt\n", - "WbbvpANo4HGWqNJjfPjhhwcO+xkcCGTZuummmyZoHSuV1aJNOpoVTPfnzL/T7bHoYqmEP+wHpuWh\n", - "hx4aFNfO1gWy5P2u9fkaGzd7EGvURb4j+v3edPMs7/9eP6bJVkAnsoY29pX2vYus2f+O79x1110T\n", - "fXutuYC298Vs756bmxvw0H05ie402e1ofEStCoVCoVAoFAoDrJhFqj2hcqLmDnxa+YGZmZnudGoL\n", - "E/fJ9p/J7nbRCq0d2KdgjH6+a98dj8vRSWBa+YlMKwZzc3ODIrp818+CVrQVLDbWONrxtTTx2Zav\n", - "dhxoBvZ9s/Zqvwz6Yn5tNULzdjuXZ2jpQ5b4HxqX/ZjsMwJNaIHZ/Nsqcthhhw3k1qWBXF7H2o4j\n", - "aGxdyTTxtWvXDqyZmd+JrUUuuwIclWYt175mLW32j/A4bYFwGRfznHGytl3WqW1vixEy4igigO8I\n", - "33OkVObfhT+H00i0/UOfaYGnlnNbMOE5fdtSDbAy8L1777134E8J4APW8rEo3PYztGYlZ4DThhx4\n", - "4IGpDwtw+RmsyW5PP+ynLhRsawpreffu3YOi5Z5/xmU5yXzq7MfIszIfzB07dnR92PfVco5MmZax\n", - "UkgtvEdj8WnfR07/Yf8k02JZdSklv+syy5VLEkUMi9q7FI7H6ULRft94Tx8rZk77zDru8l1Z0fIM\n", - "ZZEqFAqFQqFQWCaqREyhUCgUCoXCFFSJmEKhUCgUCoVHGSvmI3XeeecNfAjsS/LRj340IvoU8e0d\n", - "qaP2KCdAKQTfv/ozKeJJhe87dPv7kK6eUgi7du3q7pndN6nwKW1gnyHnqrr44osjYlhShjFyPw1t\n", - "tD/jjDMGPmGOhKRECH1n/jbQQhmPs88+OyKG/kj2Kbjooou6vp2Z3H5Vl1xyyQRf4AcRJdAELZR8\n", - "YE6dTwV/hJmZmY4nLj/gPEIunWKeA0crZmV/2ggR5BZZpBSGM5zbjw1aKLVjvxXPLbTQfmlpaZDl\n", - "2WUzaIvMEtUHbdAOLS6dRDt8Q/A9aefIvg72q6DMgksEeY4AsgjP6ceRVcjdpz/96W7+ga3fLstE\n", - "e0eY2lcG2UUWs31i9erV3b6VldmwTwelLVgX9hFyhnCXThobK3Qhi6xn/KnYW/CnQS4s5/Y5gz8u\n", - "h/W+971vgsbFxcWB3FJ+htI5ztlkHznaI4vA0X0uKQXfZ2ZmBpGgXhd+t/B/+8iZL/jSsAfhp4Uf\n", - "F7S///3v73x8GK9zIPIugi/wy35njJe+od0Z050T65Of/GRXNsVRx/Clbdvy0L6zjt6GFpfxcf6u\n", - "+fn5riwPbe0TjExadk877bSJZ9N3ttdRxscVJdo9Grpd2sY+U8wVtGT4pQ5Sxx57bGzatCnm5uZi\n", - "fn4+rr766rjvvvvi937v9+Lmm2+OY489Nr70pS8NEs8VCoVCoVAo/P+AX+ogNTMzE1//+te7yIWI\n", - "fRaKU045Jd71rnfFRz/60bjooou6k2iLnTt3DrIwZzmNHLV21113dadNW1b4jOZMToonPOEJEdFH\n", - "6QBHp5G51gVR2zFH7LOOOOOqIzZcS8i5NZy7x1Eabcbmtj+wadOm7uR8++23T3wnq1eIxuRMxkTM\n", - "+FmOlGCO2rFmmdqBI3wcXcJ4H/vYx0bEMNqCOcFy9W//9m8Rse8gHxHxlKc8pWtrq4VrrjmazVoc\n", - "P/mec5QA/t/Ooa0fPKu1nEX0da8ynsNPIquYY8sutG3YsKFrQ7Sh54L5vu666yKi58fTn/70iBjm\n", - "NIKGG2+8MSL67P0nnHBCRAxl84ADDujm1cXInaOorZkZ0c+r82gZjrxlPbVas2tlQUsWEeQsyOSh\n", - "o08rgdaCWdtjkbW2JJnerF4Zf6eYKxYs59dz9Gubp8prjnEgUzfffHNE9JUaeBaw5Zk9Psv1x9iw\n", - "dCwsLHQ8dc4hrGL833mCvP6dCZ5nw3vvddB4++23d/sde0gWtYdMMU7453xs8IO8XNBAnU33v23b\n", - "tkFhYOizbPHZUWd33nlnRAyrLHhPh8+st3ZN0/Z73/teRPTvx+c+97kRMVxztuZ4zXqOXJuQsYxF\n", - "Yvt9ccMNN0w801UTnNPpyU9+8gQtrFngqEdke8+ePYOzhSNqvY5tPc7wS/tIecP+m7/5m3jDG94Q\n", - "ERFveMMb4stf/vIv+4hCoVAoFAqF/yvxS1ukXvKSl8Tc3FycccYZcdppp8Xdd9/dnQA3b97cabJj\n", - "4NRK5lo+28rEqZCfa9euHfgCAbR8TpannnpqRPSnVluNfC//3e9+NyKGGbEBn9esWdNpddBga4dz\n", - "bjz1qU+d+Gxa+P5hhx0WEf0JHNrHagpdf/31E99Ba8mqXDsbsmkAzmXF6d/5qCKGh+lpNecYB5qT\n", - "K8s7X873v//9iIi44447IiLiqquummj/93//911b50lBA4fntuowHvhGe9dHBM4X1PoB2arjrMEn\n", - "nnhiRPQ8z/ICOb8WNLt9m4WXdWYNC7AunvjEJ0ZExAte8IKIiPjhD38YEcN1xLMe97jHRUTEe9/7\n", - "3ojoLZ98r6UFrRN5tQ8hQItHRnkWtSuzHFjMxW233RYR/Zpt6+E5fxwWBfhjvvB/xvWMZzwjInqL\n", - "m+cU2rCiQbPzbbWAbvY55N1t7TOE9dDWIUA/8BGa9u7dO6gR6IoPf/iHfxgREddee21ERPz4xz8e\n", - "HSeyyj6T5Z2iHWt/1apVnezYz4Y2zvSNTNlSx37B/xkva9SWfb7/7Gc/u1s7yJytwDwb+pkjW6gB\n", - "+wP9vfzlL4+Inve21O3YsWOQew++eN90hQxbRb0XMX72ftbFWLUC9lqs+L/zO78TERHf/OY3IyLi\n", - "lltuGdAdMcyTZgsecM68H/zgBxHRz1W7pvkba5I1lOXsYxzcWPz3f/93RPRr1xZPaIM/P/nJTyJi\n", - "3xq1VY+2rp0JvVn9T+OXOkj9+7//exx55JFxzz33xCmnnNKZiUFbVLdQKBQKhULh/zf8UgcpfD0e\n", - "85jHxCtf+cq4+uqrY/PmzXHXXXfFEUccEXfeeedolfiIiH/913/tToMbN26MI444ojt0WZty9exD\n", - "Dz00vbs84ogjIqI/jaI5cPp1HR9HL/n+2vSjdT/44INdW9fbAmgK9EGf3/72tyNiaAWwtuv6SNa8\n", - "7r///k5L4SdaTZbBG80E7YVnEhEHfACG92O0oIU4woe+rb1y+meu4A9akS1vz3zmMyMi4pRTTomI\n", - "XlO/7LLLImJSO6Jv/2T8+BsAxsHcMWdYJGzZg8+2VOzevXugecPDk08+OSIifvrTn0ZEL4uMH6D9\n", - "wGv4hp+SLVJt3Ts0LfvwAMaHNvwf//EfEdFrjvg+AWoywg+sr1j/nDl7165dndaaZWYGXg/0ldWO\n", - "gx+uocXctbLLOsZ6yTqAJlu72CdOOumkifGyb1xzzTUT7W15YmyMfSyLN+ODfp5hvxTWJnPnDPDW\n", - "vNmL2MNYByeccEK3DwDohedYd77xjW9ERK/tAyw30M6zuW3ILHWM7YEHHkhvIxgn/LCvlK3GjJO5\n", - "fc5znhMR/frC4gDaCFPkwJFzANlybVHamRb+jm8R/PnOd74TEb2vFNi8eXOamdz+V8gDvGyrJkQM\n", - "bw+QbfZN+wG2ezhyzvz93d/9XUREfOtb34qIfl8wkBu+z/i8v8AH1gf/x+fM7/SIoVWf79qPCSsf\n", - "703+730EYH21z+lhhx2W1isci6i+9dZbO/mZhmX7SG3fvr2b2G3btsU//MM/xNOf/vR4xSte0V29\n", - "XHXVVfHbv/3bo98/6aST4vnPf348//nPH7xQCoVCoVAoFFYKxxxzTLzgBS/o3CD2h2VbpO6+++54\n", - "5StfGRH7tLLXvOY18dKXvjROOumkeNWrXhWf//znu/QHY9i4cWN3UudkiUZqbRctgf8/9NBD3SkV\n", - "zRlwwuQnWpGjCVo6IvpT8fHHHz/xzKym2MzMTHc657Tu6CSsPo504eDoyCeAFoDFzzWawMLCQtcG\n", - "cKq3ZoT2Ah/gG33bguWcV4zRUZER/SkeDSOrCeW+GT/jggbzBa3gRz/6UUT0mhxa1OGHHx5f/epX\n", - "I6KXETQiW0ds7UCLs8ZKVI7henltvS9ru7ZeMT60f9dx4v/Ov+NcXqCdI9o4F4vpRntlXUCLacci\n", - "A++JlGRu8WsAe/fu7eQaCxEy4vpWrvcG77EW2/KK7DFG15ZrI4IcycTewmdH+LieHfyhnS3Stgqy\n", - "5nluq3lDF3sJcg3d9qeBRkc/MnfeX/i7rfB33HHHYP7Z55gLxvdrv/ZrE32ZFvZLfjoqFjB+rOir\n", - "Vq0aRG65b2hiz2W8tmRhbcUyw1xhibI1Df620Yvw3lZj2tI30d383e8iaGF9MN7jjjtuYmyglTfm\n", - "j3m3lcZR4IB9weuCNcuax3o2VsvREXKM62lPe1pEDPcW9nJHsyE/jmbn/4wfPkJDa8G077DfsTas\n", - "wHP4g59Xex5o4XyDbX5C7/8gy2X3SAu/LPsgddxxxw3M3hH7THlf+9rXltttoVAoFAqFwv8zqFp7\n", - "hUKhUCgUClNQtfYKhUKhUCgUHmWsWK29M888c3D3a98a6ltRJ4i75XXr1g1qYlEL6bzzzouIYWZy\n", - "2nMvT00h6hsRMeEs69BIHZ8zzjgjIiaziuM3wX0wbak/RR/cw+K/4HpV1JSiP2cV5/754x//eETs\n", - "q7WV1SnyOOkb3yj4RnQO/KE9NcWg2Xzhvv+KK67o6jJxWqdv10SjHh5zZB8SaKYfxsn8u7ZWm03X\n", - "43SEF/4arlf3ute9LiL6+3bmlHauzUidKNdP27lzZ/c7dFPHyXXwAH1k9Q3t58W44SO11g466KBB\n", - "zSzmlTX07ne/OyJ63wjn4vH8U1PSeYPa7NkRfc2qt73tbQOfL77jepWnn376xPgdvWaeUycQuBoB\n", - "MnnJJZd0dLu+JbKDbMFz2jtSCP8VnvXhD384Inr5cmRUq6nCc/YW+/5ldfyQLfvhuQIAdb/gI2ij\n", - "vVyvlDWHz47l1/XqqEEIj+1jyN9ZR9R9Y48+4IADuj7hFfNJW1enMC+ZI/ho/zfLz4c+9KGI2Fff\n", - "LmKf7wzfoW1WgxA/HGfRZu5cm9N1UL224eN5553X/a/13WrBuuDd4lxwznhP3/DR+aVoh+/Q1q1b\n", - "u/mkL/ZzR6szR+wtXve0Z79xLU/2cEegR/Q85N3iOrheq6wL3i/wg//7PeN91+/RhYWFjjf0DQ+9\n", - "5mjHvoCcZyiLVKFQKBQKhcIysWIWqZmZme5Uy+mPU7KzifJ/Tos7d+4cWC8AGgLRRpyIaZ9FlPF3\n", - "8l4QteVoJk65hx9++CDiz3B9Ir7rSDLA+KEZzSuLlJmZmenoRtNEO7OWAi2OrONnZk1wezSTlhbG\n", - "4T7QODxHfjZWQzR2WyjaqIuIXkvIarJF9DyD58iO+cI4+Tt9thmaWzAnjJn+d+zYMZgf2hKFZBlz\n", - "BAnPchZ5Z5kHWCqOPPLIjm5HpQEiWeAdMkaf5mUWgcnfHYk1OzvbWbv4HxFv5ovnne+R48a0wKds\n", - "DbdzlFUZyKJ1GA+8JnKQ+bW8IIvIOpYMvtfOEePG8sqzsHaZJmeB5v+u/2hA05YtWyJi39xmPHed\n", - "S0fjGa6V1mbTb8HYsII89NBD3Xp2tBk08JMoLaI4s8g6RwE6/xCAjw8++GC3jpFFy45rcjr3mfc0\n", - "v4uQG6L+xmpzet7oO+MhYM06uhPAJ57tCiAt7dDLd2yRzqKZbaHLMpvzLPqBBvjVzmmW4y6rb0pf\n", - "rp9JNQLv0XyGpvb94/m3lZCf7NHTItBBWaQKhUKhUCgUlokVs0jNzs52J1HnkfIdsvNO7Ny5sztl\n", - "OtsvJ2esXeQc4rTrkzQnTmta5OTIatHNz893+UvQpHwydm4ftEA0NWsgjNOnenJCjVmwnDerzeI6\n", - "BvpwNXhrR/ALrchZlltasszm1mJAZonh79ZgAfzB2oi8OHdLRD+fyAd0Z3W50HbgNdpOlmWb7+GL\n", - "tLCwkGppzhuEbGVWE/uCTKtA/uCDD8bjH//4iOh5Y9mib3iINQhazBdbHm3pGbMyMk6sM7RFuwPM\n", - "N/wi35pz0QBogPfkHWKsrQXLewXyi7w6I7cz4GM9pB+vafteYamBhlZebO10RnPz0NYRaGecbu8a\n", - "bjxnfn5+YJnkuzwDKyB8Gss8HdHzgX3UViS3a2tPZlYdeMT4+D8WNedwQ64YL/UiWU9ed9AyNzfX\n", - "rU/+Zlm0nyt5xJBdaAL2uXK+JWNpaanjAzzns+XcFknnE/Ne5GzsrGXWUyu79rOypcl7kX3K2ozf\n", - "bT/A8k8FibHKGTwz46H9FenTcsJazqzw9Nfun37POY8ga41cVZaXDGWRKhQKhUKhUFgmVswitWbN\n", - "msFp2NYlwKmxrReFpcinV98bu+aUT6SOznAkgO/r0Q7uvffeQaZi981pnkg5PnP6tabGM33itr9S\n", - "O1b6zLKEA07naJZt1tuIoeWNsXDadzX4Vgt0hBvw+ADzyXiYK/ox7a49h9UIbbP1QUCGMq3HVj1X\n", - "f0fLxWJnbccWz9bq6PEzTlcc51meT+bINbP4u/mJFemee+4Z+CLYr4L5pi9ngzbPWVe2njqCDMzO\n", - "zg78sDwHwLXjyM7PuLMs+/CNeUcG27HyTGTCdeiyHHZYxV07b8wvMWJo+bLGH9HzGo0arR1LhLNm\n", - "0xeyhWUmy1bPXuR9Z/369QMe8izoY7zek4AtDvZ5yeYIq0hLk60dzD/PdE3OLIqT9lhcWFeWRdBW\n", - "vchuFhy1iAy2vl4tsiztyNuYlZF5ok1mQWGcrd9lRG71gk9YUaFt7B1gi6ErWkzzkbJvoHnu9jzP\n", - "ctP2ZWs3vMxuDVgXWLwzf+DMH3JxcXGwF8FTZAlLGueGzP/ZKItUoVAoFAqFwjKxYhapubm57jTI\n", - "CZ3TrE+YY7XGOCk6IsL5dPAdGbOkRAzzI7V5gSKGWmCbV+XHP/5xRPQag61XjoygPpn9E4AjQujX\n", - "eUXasTqSYSxKAnrbvtEUfG8PbGWyljRWx8l5YMaqkEdM5vWI6PnjvCmAz/Ce6C4sGq1VEllx9B3j\n", - "zKL2oPnmm2+OiN4S4zmyj1RrbXJNOebAljfGk0Un8X9bdGzZauUCy0vmCwRtzL9rLbo9fIF/niNb\n", - "gmdnZzseYu2w7xxwfiysf/Y/AV7/aODQZFraZzDurG+DNQo/bZmhH+eCA62s8zvP9By5b/sUolkz\n", - "BluNbNHHgrVhw4bUX5O/s4agzRZMWw2wYLKOTIsjDOfm5gaWZ+BoXvwRve+ZFs8pe5L3l3aO8XXh\n", - "HZNF+PEewKKG5dXrwnudo1vH3kfQy97jiF9gywu0OgoNsMfBH/wevWe33/XtCWvKljZHFmaR1+04\n", - "I3p+sKbhY2vZ854LL1nHfkczHmhiLln/WX4+Rz3Pzs4OeA4NWNM5L0B3FilrlEWqUCgUCoVCYZmo\n", - "WnuFQqFQKBQKU5Adl1bsao9yCBG9SRJgFiQVPunqCdG98847O5MkPymFQMkHl+VwuPrll18eEX2K\n", - "eDvJuWwNZTkoPxDRm6T9ncsuuywi+jILTkDItQpmQ0ohUArFjsyAMZGW/8wzz+zMxb7+4lmf+9zn\n", - "JnhIH9CKCZPP0EJaftqTwBHzOyHo733ve7u+XfLBVxSUHyCFP8B5kJBql7eg/ABywRVJW+aA8gAu\n", - "m3HttddGRMQTnvCEiIh49rOfHRH93NA3ssVVFvyDFnhOqZWxKyOXNqEsB/MMr7mSdLkK+OLrNjuK\n", - "0j9jWLt2bWfu5ooGE/VFF100QTfw9RJOln/6p38aERGnnnrqBK1ceT7rWc+KiP6agvX2zne+s5NX\n", - "X6NjNocWSn4wTtYk7bgCveCCCyKiXxfwGkdQnoMsXnTRRd18uowE40TG6BueI0vMiXlPeQtKitg5\n", - "me/fd999naxQTgY+wEPWPz/PP//8jocRw3WP3FgWWaP8nbnftm1b90z2OdZom0Imol9T8JLSGbS3\n", - "CwXtCAtnj4aP7Me33XbbIFDB5WrgNWuO77rUFnOaJcNkjmgPLW36A67FkdsLL7wwInqe+yrLASHs\n", - "6W7P3nXiiSdGiw9+8IMREfGa17ym4zF7CvJN0Axr0yVfeHe1KVYiIi699NIJPsI39mj2R65jP/ax\n", - "j3XzCXDYf97znhcR/bXaH/3RH03wELg0DPJw5ZVXRkRfDs2pCriG37BhQydb9A1vuS62mwp7ut/p\n", - "dqGAT95HXZpt7dq1HV3IInsofcM79j2ueikRlaGu9gqFQqFQKBSWiRVNyMlJGyfJ//W//ldEDE+c\n", - "nHLREq699tp46UtfGhG9Y6vRnkIj+pNm5phoRz5OpHYIRlvauXNnpxE985nPjIih0yufOb2jMTz3\n", - "uc+NiKEjo5/NsxweCmZmZlLNm5M0cEhsFmoKmBu0YWj5rd/6rYjonVUjhkUn0V4Yvx08XVAare7k\n", - "k0+OiD4cHjgp4E9+8pOIiDjllFMiYnLu/Gy+87KXvSwiessUcCg27bGOWF7sCM73165dO0i1AQ/5\n", - "O3Py5Cc/eYIPwKHJBDM87nGPi4ihozzrZHFxMW644YaIiDjppJMiYqghM/8u/Mz4LAdOH8BcHXfc\n", - "cRExdPB8+OGHBwWwsV5lyWHRVtGOX/WqV0XEcC0is9DOWJ/znOdERM/PiGFIPDzCYueUAy4zcv31\n", - "10dE76RsB3+nVzA/2zWKrGDtg5anPe1pE88ETjCJDGLZGSvLE9HPIfvLpk2bBnSz13gP4bNTFJh/\n", - "/MQS1a7/Fszlbbfd1o3TDvl25IeGsRQSEf2aRv55D3gtgjbJ6k033RQR0b0vslB5O+63yU1bsE8g\n", - "63wf64+d8BcWFrp5ue666yKil/Nf//Vfn2iL5cqlosYcttv/83f4ioW2DSCCLvqyddzy0hbAjujn\n", - "hHXkOaU/9l36w9Lfyp2TgSL3rDmnv0DO2aOgCVp83ebgLMa4a9euQVAV+0FbbDuiP4tk70ejLFKF\n", - "QqFQKBQKy8SKpj/gZInGhRZgK5DLt+zdu3dQlBbYOtJq7RFDjYzTLKdXtDsX1jX27NnTnbo5taKN\n", - "mW6f3jm1Z2U8+J4T8ZmW1atXd+OxpmQrgMNcXTg5S4JJv4wVC+BYUjmXhvHfgRNNMl4sk+aLS8jA\n", - "P6wkY1ZJtHksM/SJ9Qs4RJ1noWFi/QIugwOfxpICum/7m3mcTqhnPz1ru22hUOQgSyRqCxQ8hH6n\n", - "1nBxZj5TQmGs7IvTV/CMrJg1mqf9VzJZNC1Yx9rQfSdvZdxZKg6Hg0Mbsma+0G+WqLDdu/gbGjHz\n", - "CU1Y5KbR4tQlHqtLCo2Ve2EcLvyNJcEWCad38Jr2HLmcycaNGwcFjwHj8Hy6YDCw/6r3Rc9Ra5Hw\n", - "PufbDuTBqVuAaUFmee/ARyyZbSkU+nXqjawcD/D7wUV9TTs0IV98hqb22W36nojeb883GLbQsK/Q\n", - "t+XBKRrgM3LVts/KtNhnzuO0xR4ap5Vaavv3GkKmvJ6hIUueapRFqlAoFAqFQmGZWDGL1OLiYnfS\n", - "JnoFC0OWBAvN7oQTTujuhTPtFfj0m6XC52Tqop7WSForGtochS7tI8Up3do70X7WpFzkk9M8J29b\n", - "6jZu3JiWNsg0RifDhOe21DlyhJ/f+973ImLcv8uJ9uxHA3iWLWzQjpZk2tH28HNC0219k8w7aMES\n", - "ZT8Da2poi5kswjcnS33wwQcH1g5ocKmQrLCwIy/REq3lAeZ+9erVnVXOET6G7/yRE1tN6RvLJjIM\n", - "X7yOZmZmujYucZIlEoXXzOtPf/rT/dLiyDrmtG2fae3mNfD+gH9eph17PbjA+Bjd/KTPG2+8MSL6\n", - "uQKsiyxqLytvxb7Q+oeZh60vX0tTts+x/p3cMEtUyPPYo7ds2dJZXrPSUcwn+1tWCsmJKl0yy3xp\n", - "o7/wL2TPtfy7QLAttpn/DbyGJsZq2jds2DCwLLH+s6S5LlNmi4xpgR/sAWPJZJl370VZomrT4gLc\n", - "nlPauczbWPJpW6/Y55ADW43Y580X+Or3DLT5Vmp2dnYwTm7DoIH55j33SLNDlUWqUCgUCoVCYZlY\n", - "MYtUqwGh3WRFTu0PtWHDhtR3iT78/6y9T7M8yxYa/z9iWEzTp3GXCLE2ZK2eZ/I9F4I02igEvgMN\n", - "PtU7OgVe2ocE2KcCjJV9oM+seLH7QBNzKRlHa7TjbJ+D5QMaWj5Ct6OpeEZW8sUWvczfhHZjaIOU\n", - "CwAAIABJREFUvhPZPFnG7AuX9e1SMuZjq6E5ysYWGPsruUCsZTfzP6FfWyRmZ2e7+c98VkBWAiIr\n", - "+WHNHNjXrn2Wy0/YEgt4piN9nFfItI75KxrOe4Q1h/m0vGdlbLACeL+wrDOWsb2ONcd47H+XjdNW\n", - "cs8tGIuGhq5M/nm2fWQyK5D/Dv+yMi6zs7MDK6Z5m/nYIucelyORmVusqmNFbu2f6shiYAuj5zEr\n", - "5uw8Y/xs17SLlmNpZpy2dtPOc+d3NcjKgI0VloZ38MH7Xlbkmv97bWfvmzH/1+xGKlsHjxRlkSoU\n", - "CoVCoVBYJqpETKFQKBQKhcIUZMelskgVCoVCoVAoLBMr5iP1tre9bZCThc9YrD72sY9FRMR73vOe\n", - "iJi8x/R9OnV5qIXFfbKfQRQBNahOO+20ib59N849NjXr2vpZ9r/gM3X5qBHlO3LuaV0jCtodAeQ7\n", - "3yuuuCIi9tUU8v0w4FnUN3JNQUdAQOOnPvWpifaOsPAYPvvZz3ZtDfs2UCOOcTprLrS4Nh98NNp8\n", - "NNBNnSXnbrKfDTXC6NtRO4brPtqHZnZ2tqOb+XGttSyvlGtE+d7eUTsf+chHJmhvabaf4datW0f5\n", - "Yj8VaEFeqCnG/x0xar68+c1v7v7m3Er4VVCvDlpcx81RWNR9dN0vgOwz/q1bt3Y1Ag37YfzZn/1Z\n", - "RPQ8tB+GfYqy/YL2rW8M65kaYQA67euB7FpenMuOOWBOvS7a6CTWBm2pV5jxAx8axknfll3n2WJO\n", - "WRdj/mrML7Lypje9KSKG/jf264P2ti5rxHAPYgzUw4Pvs7Ozg7VmHiK3ziPleqHeXzxGZ+v2umvH\n", - "SxvmizUHLfaVc9RiVoMwy9f2qU99KuWh4fXsvIp+70K768qC9h3Ae5G6fPj+2b+TSgDe5ywfrkpC\n", - "e+rhOndeRC/n1P1kzdkvy3nhGGeGskgVCoVCoVAoLBMrZpGK6E97aBacHH06dEX21vPeJ2BO2s6X\n", - "4iguMC2iKjvl7927d6ClZXmBiKpAo3DuEuDoGyxT0OSov5Z2R9NlFbJ5hvMnOdok4yvfG4tSAtN8\n", - "4PxdR1ra+mENztpCy0drKeaxkUVzZlna4SNzBE1zc3MD66BlaBpfrNUi7850bhoXFxcH0XhZLh7X\n", - "Zsxo8/gdQWq+jUUreVymxRalLOrMsuefbf+Ots2sAAB+YKnms61ChvMyZbm+2v/Zv8J7TxZhllVZ\n", - "gFb2Cfi3uLg4yLDt745lfR6j2VGvznUGbNlaXFxMZZHPWR4gR1bZgud1n31/ZmYmjdIC/m6WswmY\n", - "D75N8d7VRrNCC9+1rPg9Qp+ObvRYsrXZjs3r3zy0fNhCR3tnvHf/HovXeEuna7M6yt1w5LmtZX62\n", - "q5q0tWlNt+Xa78dpKItUoVAoFAqFwjKxYhappaWlQT6I9n8tbKlZWloaZAsG1ATK8kBZq/dJmxNq\n", - "ppG2vjb2k7F2Y98p+rSWDMhIS6Zun6jHMr5b68tyMfke3RqHtUbTvD8NxBp39gx/N8vtYi2AMfp+\n", - "fsxqmFkQMmQ+IBlfnMm61QJNt/2yLA9ZTit+Op9Ypj0fcMABg2dZ8/IcWOvN5te+NPuz1GRybbpd\n", - "ky/TKIGz99sS1X7f68F+Epm12z6S3gcA+4stv2NzmvmXWOZMu8ef8QkrGrLY7kcZT63VZxbmadmi\n", - "s/2i9ZHK1r9z3XkPdt/+vvd25wbbnxV6Wn5B712ei8xym1mNIoZWYGcLB7ZyZjn8gLPsZ9bjlk5b\n", - "A2nj+c/ezVlON/uisS7GrEtYS73WMot9Vu/R6wrYgtn6nGb7nPmTrf8MZZEqFAqFQqFQWCZWzCLV\n", - "VsWeVpttzJ8jswK50rija8ZqhLXtXO/J7du7U9Pl064jo6wNun3rbxPRa17OtgtaTYz/OSOxx+lT\n", - "f9bec2Pa25N65gOSwb5O7sdwhmRbbFptylGJ1tKyGnTWwDx3pt1zNJbZ3Bq2ZdbtM9oyf62xaB1H\n", - "mwGsFtZiM/8bZ5O3lpfVfWvpmZY125pmZnlhTpz52XPbPjujJbPUZdZEw5UBzI/2e7ZEuA/DWfZd\n", - "13HM/6qlvd0Lp9Ury3xjTLutqJYHtx+TD+8LWdRdtn/Yb9VyYr60n215y2Qx840yTbYmuQrB2Fgd\n", - "MZj17cz+tsRm8w+8Ltq14D0TmrL5z3zm/D417bZw2uoY0cti9t7wOKdVGfD32QNt6VpaWhrMgS3W\n", - "+/Pt2h/KIlUoFAqFQqGwTKyYRWpubm5wHz0t0qrVjnxaB458MjJ/HUenZFYj0NJgbQ1kvkPZONGG\n", - "8MOwtc1awMLCwiBaKLMYODeR6x1l47RlArQne2t7WaSjYb5l9/LuDw2dn60WaV8F9z3NXyurc2da\n", - "yIHS+txlVkDLeabl0Bdz4/nfn/XAeW8y+belIvOBs1zYZ2DM8uPxZTzPcvtMg9dk5jvR0mmt1LzH\n", - "Am3LdBY5ZIuOx9TSklkkPX5gqw7IfKegHato1m/7N1tekAdb3h3laN8ot7ff19LSUupPhcUg8/mb\n", - "Znm1LGY+la2vWJZryVGa5v00y2RWw3GsrenOIsiA58xwP56blr+Zr9e0GrS2XGe+Y7ZgOiKvfU5m\n", - "BbcPGcCanvnlWV5skWqjGDN/qsxXznKeoSxShUKhUCgUCstE1dorFAqFQqFQmIKqtVcoFAqFQqHw\n", - "KGPFfKTOOuus7nR36KGHRkSfAZz7Vdc3wydg7dq1cffdd0dE78tALSRqCjnP1H333RcR/V0odZmo\n", - "+8M9Kzkuvv/970dExCGHHBIRfd03+p+fn+98Wu66666Jvt3WvgzQ3tYIi+jrG5FHhPbUHuLvtD/3\n", - "3HO7O17fI/OTWljUFILn0G4fAeqbudYePkH333//RP+f/vSnBzXFssgH6GY+fedN5IfrhEE7c00e\n", - "GuZ0fn6+m3/qMmVReHymXhV9A/hCZAlzhyy6PfJxzz33dHRTl8m1sPg/9RsBc0QNMuaCcT744IMT\n", - "36c2XztW/mefFvhinsMfeM4z3Te0wxdyF8HHtr39UCyTrsvG3+n7oYcemvg7PKeOl6OZmKN2rGee\n", - "eeZEG+CooksvvTQihnUfDz744Ijo1zR9my9Z5uf5+flu/XsN4ftInjj45dp59i1jTpFFaGG/oB/2\n", - "rnvuuSfdF+E137nttttG+/YcwR/mn/5NC2M96qij4sYbb4yIfi7MF/ut2TcGeYF2t2ddMCbkBRlY\n", - "u3Ztx3P2UNNCLTz7ryEvnn/4Yln0u4s94Oyzz+7asJ/7XURb6IbXhx9+eERE3H777RHR8xx5gY/I\n", - "CXs0+0srX65vyU/oZjzwhXFCO/zwHLGPskYBz4aW2dnZri218OD1pk2bIiLiuuuum/jMfJ533nkT\n", - "7dlX2r4j+nf6ueeeOzEmVy+IiLjyyisjYriemSPv0cx/hrJIFQqFQqFQKCwTK5rZ3NrOWF6YiGGk\n", - "wJ49e9KIoP1ld91f31mNnf1lNndUyrQsuW6fZTZ2xECWZTuLzNofLY50yiIkrWlP4+MYxnLrtN/N\n", - "IsWyvp0DZSxCM4sQyz67b3ie5TiZll9rrE9H1WT16rIswhnN7bpw1OG0LMGZTGbt/dORUm2lgiy6\n", - "pm0bka/FjOeOchqLlMoigrKIUGvaaOD7i8KKyCNR2+dOk8Vp/3dkWCbLltXdu3cPIuIy2WO8jlJ0\n", - "VFdWtcBj4bmrV69O13O2D2b7RbbPZeuj/Xv2DNOdrfdpa++R7Dfer7L8R1letWk+xY5+HYsKdwSp\n", - "rYDZ+wL5yPKHgYxGR/G1fWRZw7McVu4TZLm+xvaA7Lzgz2PRhvtDWaQKhUKhUCgUlokVs0itWbOm\n", - "O1niC2L/C+DM3mvWrEm1EVd+5j41yyPjmmPcM3NPa00NP4R169Z1dPs+FZhGa/XuGx8otAA+M4ax\n", - "HED7y6zcwvXNshwuIMt5NcZHaxDTcnDZauA+M837kVgN8ZfI6pxZw6A9lgn7+ZhPzIH9e9pcTsB5\n", - "rlzfynDOFmvJ+6s55ramO8szNS23FTRbQ/VY165dO5hXfJiyNec5yaxGzpLszPBjVoOsL8N9wlP8\n", - "tTzOLNu012ZEv+Y8/1kuLq9/18fzM9h/QJtl322ztZXVFDM/nFU+W0eMYc2aNd3vlkX2UGhxn1ke\n", - "KQCt9mMy7e3cZ1ZgyzewxdZ9M7fO3D3WP315fi2bzvDOvp9Vn/BeR/+8j9r+nf0+W1PGNMssQE7g\n", - "J8+271j7P3gF3fizWXazChBZ/rnM4tfmXQR+/0PLIx03KItUoVAoFAqFwjKxYhapxcXFTtMiiiXT\n", - "YDnVtlmlM98da5K2jvhESuQHmiU0ELVjTe2OO+6IiH2nabQS6Dfd9A1NWLvIvOqsqT//+c8jYhiF\n", - "4SgP8MADD6RZwT1OZ+y2lpPd9VvzHjupWwOw75L5Yr8i10HLfEVci8qfI3reehxZ1twsUzV9Z+A5\n", - "PBvtcawP17kaoztiaD2jHd+zhQ8a9uzZM/Crc9+uQQmydcHfGZdpdz2sMX7xHdPiOeJzxhfGZFrH\n", - "xmpZsi9LVvfOmbwzrZY1CvaX1d88p42t5IB9DhrhCzRYU6e9fci2bds24DGRwrZIYL1gjzLt/ISv\n", - "jn4EfB+aIvIbBmgBtjBkfGGcWBGgzfto25/fA1mNOPMwWxfwiznkHeAIMtDKgP0qvZ9jkbGPT5ax\n", - "HhocgTsmX46gZf69jwGvd8+737vMtffwMUsd7zNA3+27dez//pzVbPUctnObWQH9nbH9fH8oi1Sh\n", - "UCgUCoXCMrFiFqn5+flBvafMX8P/n5ubm1p/KKv7NS1qw74k1khb/4ZptQHtTzEtasft0Xay++u2\n", - "3p/rdGUWpkyjMD/Nhyyq45Egi86yT012L40Gav+fMXnJKsRndGfRTVl9J/Mxq9EVMYx4meaPZL8s\n", - "+2Nl/i0zMzODec/WkCOBMsuLZZFxZhXo2zU5zV/P8zctMsb+HWDMRyKzzE7ji5HxxbK4v3WUyVYG\n", - "88HrInvWtH0oovdhsU8UFonsu95Pp2Gspl225jJreLbnOsI6m4N2j8v2O7fN9s1sX/Q49/fu8h46\n", - "LeJv2nsCTNvbWlrsu5S9J7NnZtGbGe37kxdooU9kM7MCgmyeM0yr4dr28Uh9KjNUiZhCoVD43+y9\n", - "eZDmVXX/f7pnejYGYdiGZdi3AUHAfcPEGPUPS2JMhRSVlIgCQqIIFZFF+aoIBSiUEkVFpIgmKTRl\n", - "ErHirkHFBZEoYlgHHGTfl2Gb6Z7u/v1BvT6f+7w+n9NP09Hq+Kv7rpp6pp/nPvdz7rnn3ueec89S\n", - "UVFRMQS1RExFRUVFRUVFxe8Y83a1d8IJJ3RCI0mJz7UK5UpI+Y4ZevHixY3Zjuuvs846q+m3BCGi\n", - "APMh7SltkDk6u0QA6eonJiY6zr+mhdIpOBfyuZ2szznnnIhoSyHYjGpHxrLUhk3NXL0Qxgkt9E0f\n", - "9IlZFQc++qZcAeZ3+Eh7+HXuuec2pQoyx1uX/IDnWCbhS+moGtGm/HcZBydNXLZsWZx55pkR0Zb8\n", - "wPmV71CGCL6cffbZA30jc4wPmuALtLsEEXxctGhR8yyXNnG6C1/DUpYBOacMD+MjzJ3vn3vuuR2+\n", - "eN6Ri4985CMR0ZZCYA1RCgU+ZXJuZ2NfmZZlnBwq76ACl7ZwmQ07NNOeOQWMFZks5Qu5JX0Jz7Dj\n", - "NuN873vfO0CjAc+RL3gOv3wFvHTp0obnlBNiPJ5HeE+5GnjugBDAM9kvTjrppAF+lM763iuYf2QP\n", - "x2aXCIJ2SoQgJ8iiHehdOol2W2yxRdMn36GteejEw54jaMnmiLX60Y9+dKD9E0880UlrA08pnQMt\n", - "Lp3DXgRt8BFZZJzMJXx06ZyyjJf3atbq//t//y8i2jmys7hTtCAv/L4w/wQ3UbaKub7gggs6+xz8\n", - "gDb4xG+u15yv+gF8ZK9j3cFn5n7p0qXNbxGy4j0XmngG+xzt6RN+lOeBiO7+YveLxx9/vPk/ZXng\n", - "i106oAW+QHuGapGqqKioqKioqJgj5s0itemmmzaJ2X75y19GRBsWu+uuuw60RTvgtLhw4cLYaqut\n", - "IqIb+upwfU7EnNLtAIqW6LIF1113XURErFy5cqB9WVKCPjkZZyGTfI6lAeuINU4nE0VjgYay6CJA\n", - "6ygThZZ0ArQ5xmueZknv+B4hq30p/51IEmTlU2jnciyMwQ7NLphr2tGCyr7gMRo18+kkhowTXt96\n", - "660D399xxx0H2mcJ3cbHx5s+gMeB5ozc3H///QOf22rG3ELT1ltvHX1YtmxZ853f/va3ERGx2267\n", - "DbRx8WFbJhz+Dl+QJ3if+QhMTU018jss+auteRS3Zf49TjRz5o55RybLNco4oQGekrbA4wR8Tt/I\n", - "jR3ava623377gbGUewC8Y/xr166NiIgddthh4H0Ajxk/37/pppsiop0rgHzZgXxqaqoTuMFag054\n", - "jSx6XC4IjYbuAAhQav0REVdeeWUjg6b7wQcfjIh23bLG4LXXhdNd7LTTThHR8sX7TpkcknEwL06C\n", - "zDOdWJU+PE4X8YU/yJn5uHHjxmb/d3ob86VMsBvRFitmzngGYH3BZwoz33jjjRERseeee3b6Ri4Y\n", - "L+/b0uj0QrwyZx4nY4NWaGOuynQc8JS5gKY1a9ZERMQee+wx0Ld/05Fd5IbC2+6fMTHGVatWpeuf\n", - "fXGm8mMzoVqkKioqKioqKirmiHmzSD3wwAOx9957R0TE+973voiI+Na3vhUR7ckUcArmVHv//fc3\n", - "GgYaIchC6bNCqWha9MOzeEVbBmhFDz30UHP6tvZuWoDDfW3B4JRvDYZTva0pGzZsaPqErlWrVkVE\n", - "N6zbPmD77bdfRET87Gc/i4iupoamhXYMzXfccUdEtFpBRDfZncPbPRfwHA0cywI8z4p5wl98Afba\n", - "a6+IaDVceFK22XbbbSMi4pWvfGVEtNoaYNwveclLIiLi0EMPjYiISy65JCIifv3rXw+0p38nSR0Z\n", - "Gen446FxMo/QmYX9k5COfvbdd9+IiMb6evvttw+0L62xaHH0TZJYYJ8IeA/PswKiWHb4PnPghI9T\n", - "U1MdqyUyaL4gg/vss09ERLzmNa+JiIj/+q//6qWdcWKJRHavvfbaiBhMkskaYt1i3dh5550jIk/f\n", - "gJy4LIct3ryPfEErVqZy3bEusLC/4hWviIiIK664IiK61i60ZfYVvofFzRZv7z/Im+cmop1nngEN\n", - "zMF222030J41iMzZtw5LFkBOnv/850dExMtf/vJmfmwFQO5vueWWiGgtL/SBvAMXFGfc/H7YglWm\n", - "G4An9jsFyAuyZUscfruAPdj7blaId8GCBc1eyTzyDCd3ZZ1gSWL+sbyV+1xEe8MBDQcffHBEtHNV\n", - "+py6zBo85DfItyO2VNEX32M/MO1Yz7lduv766yMi4kUvelHT1mVp7Avmkmv2R7zmmmsiopUTzxG0\n", - "s9ahYauttopddtlloC3ygIzaAl/edsyEapGqqKioqKioqJgj5s0itWzZsvjmN78ZEa0mnmmwnFjR\n", - "0B988MGhpS1855klluPZaEfPfe5zI6LVcmw1QGvadddd47bbbouIvFQBf7sAKPA9MzQ6oorTsbWd\n", - "TTbZpHkPDQCLkS1S9MU9OrzEgoWGDdACsQ7Sznft5fg87gyZH4pLqQA0FD6nfI+joCK60TdXX311\n", - "RLTaoGll3n/+859HRMRf//VfR0TEQQcdFBFdC5b9u8DixYs7lhS0HZ6NVocmaVlkjugH+ULzQvYA\n", - "2uRjjz3W0I/fgP0prOWhaWFFMs9d3sOvfRZMJ4d1JAxAs0ZTPOSQQwZot+XNRc2xdDgSK6JbTBZe\n", - "811bXmxhxTKVlf5BvmhH/32FYtkXfvGLX0REO//2gQNYxbFU4FMFbVnRWvjAsycmJjq+HewTq1ev\n", - "joh2/qHbEbPID5Yn+JCVWkGOkMMXvOAFnZIngHnGtwd5YA/LrKnQYr54HcG/DRs2dKzcvgWgD5d8\n", - "cZkmwJxhBWHNsh/Y4vnYY481eytWS/Y970XsNfSJ5RWa+B7gtuDmm2+OiIivf/3rEdHOMb9tEa0s\n", - "OrkttGWlU7D60S7bu6CFOcdXE766LFAfTchiZtnnN+iGG26IiNby5pIzzAVWaPaCRx99tGMFhA+M\n", - "iz55ZvWRqqioqKioqKj4PWPeLFIjIyPxvOc9LyJabQhtPysFgXf+pptummp1nN5d2BYtx35GaM18\n", - "D62AU7KtQGgqU1NTzckfbdeal6MTbM3wOF2MEW0qu9+fmprqaMicqE0L2hync2vHHic0owVx6keD\n", - "K/nOs+A54+or4VGOk+9Zo7ZG4ohKNFrmovTBQMthPtFinLsJYO2BP1/5ylcG3rcGC6C5LAJq6wXz\n", - "yJy4ZIxpYdyW0Sz6kX6f85znNPPJPJmHWdkWR84AR+04EsY+FaOjo808ISN819ZOeAuN3//+95tx\n", - "RHQtb8gLn0ODc6FFdNcWmjJzYwsD1kLGX+4x5bgBY0KDxTIBv8qxwlvG4/xgXv/MDX1Cq3O3eazs\n", - "P8hqWb4KuAA2Gjc8zcptQJPnxrKOdYl9qLw1cHSaraPMEWvQVh2sCNBAO5cvAqXlJisQDFzEF17T\n", - "pyOl2WucfysrLL3FFls0cmCrh+efvQqfMebTVnYAn7BcYYHit65s76LzzKNzeAH2k//+7/+OiHbP\n", - "ZbxeR96jkAfkpJxzr02exZ6a+RaztrAqZyWGAO3LKFjLlqNSAePMypYZ1SJVUVFRUVFRUTFH1Fp7\n", - "FRUVFRUVFRVDUGvtVVRUVFRUVFT8jjFvPlLvfve7O7XYXJOMmlJHHXVURAxG6XBXzX3q5z73uYho\n", - "6w9xcqRP5+6hjo/rfgHXc6OmUNnePkGu4wQtgOgU7pEZ50UXXRQRbU0hnu1su9yVU/fn6KOP7vhy\n", - "OecW9aeob8f4Xd+M++RPf/rTEdHWIOOOm/6dN+XCCy9s6hU526+jFJlPasoB+21AC7W5qJ/G5/C5\n", - "jNa4+OKLI6Kt+eQ6fgY8pKaUs2f7/h15oT337tD6+OOPN+OmFhZ8sV8C8u6acrSnHc92nThq8zFH\n", - "k5OTDU/wq2B9UFMK2ULmkCXXxaPWFjynP3wcGC9yc+mllw7QXtLvnDXwkJpyrkEJmIszzjhjoG/4\n", - "5ZqVyOhFF13UrDn4gWzRJ/5b9E3tROYOfw3miD0H2fV+4azi4+PjnTpuwP40ruPFumCctLMfG/LC\n", - "/DNGvjc6Oto8C1qOPPLIiGjXJHQjW8gD8w9fXBe0jAws+zffH3300Wa9ZvVQXXPO1SiobwfPHTHI\n", - "s5gjaIEvCxYs6ETV8Uz2OfZF+0rZR4r21PFz1C7fY/9Avk455ZSGV54n5qKsV1nSYprgC+vfv4sA\n", - "PiHLl1xySbOeM98f/M6oKUluR/sEIpOsI2ozumad/b+efPLJZi+C566EAE3wyTUoXe+z9FeOaPcX\n", - "1pH9oRYsWNDwnvnk98JyDk38ZvMbnaFapCoqKioqKioq5oh5s0iVUT5oOVl9GzROTpgjIyNNhtLM\n", - "w999onk5Cgttz5mMswrsfH9kZGSAnj5a0GZ431pdFrUFra6G3Red4kg/TvPWOHg2GpMjiJwXyJY8\n", - "5+cpsydbK+dvWxrdHpqZX3jrSBnG5HpQ9F9avujD0Zq0zTLhu7q5tUHTQoQMmtnSpUs7PIcua4jQ\n", - "6Nw9PBva0Ybolzw0oKw4zzhchR4gW/CDSCiirCy7tjyROd117krabYFifFndN+bfWYWd64l+bRW1\n", - "ZSqiu+6RmbImYt84+Z4jwiy7yIP3JPp1tGRE1xKBzGRRu8B7kqP2bJFjbU9MTKTr2eMlGstRe9AG\n", - "HxzF6bXIHPK9zTffvDeqNqKdN8bLXuT8Ywa0E5WH9d2Wh7LqAOPMLCX8bUs+smuew1fyDDIWIufI\n", - "cQWefvrphgbWHK/Osm2LNXxhzTqbPOvF/OT7Zc1Kr8mXv/zlEdHmWjLdtuQyl1kEOe29zvqi3pyr\n", - "y781XkPQzrMdSew5Yk5pV94YeT07vxj0wsvZ+nNXi1RFRUVFRUVFxRwxbxaplStXNtlP/+3f/i0i\n", - "2ppy1AwCnA4PPPDAiIg4/PDDm5o+//iP/zjQFu2HEyZaGqdZ5zBBs+JU63t7W8do99BDDzU5p6hX\n", - "hXYH6AtthRpKX/7ylyOia5HgtIx2hI8B4ye/CHj66acbTYI2BxxwQER0LSmcvMkwi7ZDTh9nwrZ1\n", - "ECsROW76qnmX1ecjujWyABoHn1MXzZYpgMZJ1vk3v/nNERFx1VVXRUTE5Zdf3rRFI4If5AXKoi2s\n", - "zZE3hTwotmC5Aj1z+uCDDzYZrAF8QVbRRMkXY9i3DE0U65frPpW5oWjDfJa1EMvxIUPQDS1kCwfI\n", - "z+te97qIaLOP/9M//VNEdLOPL1q0qKEfGcNyYF85ZMgZmVk/Xv/OQ4WcoHGXPiLOUcY4bJkArFH4\n", - "wFomQzeZ74Grw9N/X341+EEmfqoKUEPNFkZbS9gfyXXFK2C/oD/k65ZbbunUq7PVD58pxkH+NPcN\n", - "kBtk0PsF/IMPa9asaaoiOCM3e4krNjAOWzH4m/FTtw0af/rTnw60Zw9YvXp1Mz/sEc5/ZR8grMDI\n", - "qMfJ7wVzSS5BaCRTPthss82a/Y7Prrvuuojormf7xNo3zns6e5Et+exZpe8hvzXM/6te9aqIaGWM\n", - "KgOA/ZLxsgbhhy2e/q1y3kbnxovo+iUh/9n8s3Zpz5iy32hogW+Tk5NpPjF4hTWTv2utvYqKioqK\n", - "ioqK3zPmzSJ11113NVoAWuD+++8fEV0NhrpwnA4vv/zyplK8K2KjnVq7y3xebE2xJuaIorImE/Si\n", - "jdnahVaIpnDllVdGRKs5OuOvrSOMjVNyX007Z4Pl9J5lZOWZaHd9Pk/l347AQgsq747tP+E77L6K\n", - "6OWz0ZLQghyFgoZFP2iXl112WYcW13RyjUBrJMggvN1rr70iovVHsDUNjZvvMadPPfVUGj0DD9FM\n", - "ebXlDX5lz7RVrYxMw5rDOG3FcbQNMoVVzxXUsfageRMV+73vfW/g2WBkZKQZJz5O0GJDBPnNAAAg\n", - "AElEQVTZwkJDH2j1zPMwrRHtlr/tI9PXR9aWeUbz/vGPfxwRrUZtKzNgruxDVK5RrEDIBRYoeJv5\n", - "DtIHfLRVHbDGsSqwz+y0004dSwrjgA9XXHFFRLQWWO9z/M2aY276LNIR7b7ImO+7775mj7HPG33y\n", - "uaNU7fPiuqlYMqHBfOR34u67725kjfVgvyR4yv7GnsTatC8Ya5pnsN/Qvy2Bk5OTzV7Bs5gLr/+s\n", - "HqBpNZAXfieRTazxEd3s6ETb8htjC7YztTOHyLLniPH7ZqfPH5D59xry76fhaFbmwr+j9pNkXSxa\n", - "tKhjHfe5gHXDOOwLmqFapCoqKioqKioq5oh5s0hFtJYnayyc4AGnXSIlRkdHO/WZvva1r0VEexpF\n", - "e0FT4kRsaxfaHidVNFZHwwFOvyMjI53K0W7LSdjRA0RKGPbXYgzQ2FcnzbXCHHUGrO1yv9xnYYro\n", - "1hp07qM+i5f7sGUKOGIQTT3L+cSY8FdBAyWSrLR4ua6hIwitSaOJ8Op21rx439Gem266aWf8fBeZ\n", - "s+xZXhwpBl+wBmRzVFqw0OpsvWJ8WOhcB81WMOYZvy/4SHtrx08++WTzDLR1tF1r9dBGX2jxfeMp\n", - "aYdmZNjRYBFdXyhH4dg66hp0rufocTLv0MAr+0wp664H6txdli1HMdE3/LNPpX1noHlqaiq1pOCn\n", - "w7ORLctmNgdY6ky797qlS5d2rBygrAkY0c5BtrfwLNYe68bWJFCOHZ5jrfH8A/fJrYH3Lr7P747r\n", - "I5r20jLMbww1ZjMrEPNvC4yjOi0froNZzqHXOd/FQmernuubMgfsL5YP2sNv5Il2JR/oI/OR8s2L\n", - "nwH82wT8G8j3lixZ0lnP8BT59e+jfeoyVItURUVFRUVFRcUcUWvtVVRUVFRUVFQMQa21V1FRUVFR\n", - "UVHxO8a8+Ui9613v6txt24ufOnGu4zQ5Odm5/6TODjWCuNt0fS76pi6T61txf+u7bvLnUINqcnKy\n", - "uTd2Vmz6Pumkkwbed0QDljnGSd0f4IzpjJ/aTCeddFJzzwzdjkKgrWtnufYUr7Q/7rjjBtrbb4PX\n", - "j33sY01b31U7eoIaYdRa8ufAdcJcU4y5Ke/MoZu6XKYB2vib9tSIYo7o274Ubg8tpW8B9HziE58Y\n", - "aEuf+GEg99BC7Szam+fmK+0Z6/T0dIfucn76aMnyLMHzk08+eYAW+5ZBE3N63HHHdeq3OToz43nm\n", - "08C6oL6h/d08t+edd16njpvllnF7XTjbPnz0GjUfXV9ybGysmR/XTnPuKddxZP3bV8j+eK7l6P7L\n", - "vrNaePaVcR1H+nY9M+8vrm9W7pseJ3XZaMsezXccrQbtniP7s0Fbn3xltx+0hS/0aV8p70Uep/nI\n", - "KzULy3qLtmZ4L0JevB765DyiXf/2B/Q6+fjHP96pb9kntxHtfLpOJO28TqC9rPsZ0f4eIQMLFy5s\n", - "2rK30Iezpvv3Itu77FNL/6wj+i9rF/IM5tO19hx96300Q7VIVVRUVFRUVFTMEfNmkZqenu5oFun9\n", - "ozTy0grgaANr885tZA3FGVldqds0lf1bS7NlxXWKsvp32VgcpdCXR8aZlkGm/dg6Noz35ldfHSza\n", - "ZNqf33c9xKx+EzD/0KqyqMAStnqYFsuJtaOsb1s8yrpehvseBs+Vo1v62jlaNeO5I4GycZrnw2S3\n", - "pHOYPGQ0+nPD/OibG2vOWV3LjGbXi/S6svZvq3TJl8zimtHv2qOe0yyPmOVqbGys8x7Pcn1LRyGW\n", - "fZTPthXY/Tv79NTUVFo7Fdiq68oIpt17crZHl9bHbB903xnc3pF1w9Z2yYfMYlS27XtW9rnf9z5R\n", - "0u42XoOmxdawYX7NthayRzsbefl/r6XZ/v67H9OW5duanp5OeZo9Y5h8NO1m1aqioqKioqKioqKD\n", - "ebNIlT4ozllhjdSaV5nDxH5WzuvCyZjnuT15mOiT3DTklchomZiY6Giz1hhstTCyzMaZZtGneTE+\n", - "XhmfaXHdpsx6Zjg7eZ8Fy3TZQjdMYxjW3loxY7VVpfy/5y3LTcK4kJdsDgG5YMzHjRs3dnKrDNOG\n", - "M7lw31l+rZJvXkOZtmuNui8jdx+t1tz6LB5uY4tsBvvpZdaULDda+b41aFsvsr4z66jliDE65xs5\n", - "gcp9zbJjn43MOmKfKF4tT94vyhptzlHmcfEd2mVr1HwwnwC57ko/xmwt8jd77bD8Qa57Cu+hPbNI\n", - "lc/KrN5+f7bWdfsKZZap8nm2dpoW5zIE9DlsjjKfqj76hq1J+wpmOZsMW6a8tiO6+bPYe/lOtk/y\n", - "PnxyPjLTQE4r73l9fWfIrONGtUhVVFRUVFRUVMwR82aRKjX/zBIBbPEpo/Z8eucE6TvsPutFRFcL\n", - "QvufjY+E/UiyzNa2GmX+OvyNRmrN1JltSyvAsHFa05rt3be1pj7areUafp/x2D8ju6/2PbstNH13\n", - "4h5f5mdkC1um/QOezVyWGqnnx1F3w3zeMl8K+854jNPT053otGxeod+WqEyrs/+KfchKWjJLi2He\n", - "wjfXwXL7zGpQ0mJZ9Hczi4TXKLBGmq3dvooCmc9LJueOcoPnrmVp2u3Xaat7+R7WHFv5Mv/MzEpk\n", - "WlwJYP369b10lN/NLO5ZBn9bLjzHoLRgZxZ4w7KUWUHdzvvLMIt22WaYT6Wzx7uvzBLXZzVyFCKv\n", - "2bqwJTK7mfGz+R5z7+jX8v+2TPJdrJvAEcmONM6sxraiTUxMdHiaRdL6N2kY5u0gVTLW5uXMfNhn\n", - "lswOLxYqGOWwdooS2vRJ+5kYSVubQU0Lm3MWzg58YMgcRMvnZ2HJ2SYGX+wcm20Y2ULrw7AfPOCF\n", - "YPNvdlWYlWvoo9vfyX4QfHj1uH048uY9mwPpbK8ZfY0626vABQsWpH0CeG6nYW8gGU1ZAeqSNrfN\n", - "5NyHvWE/EFkKi74DvJ89THGgD4diu7i52yMvXrMlLZ4T7yVZiRi/P4x2H3qffvrpNAgHeL/InMef\n", - "bb7mklYfSt2Gqxn/WFtueJ/DGmty2H5RwkqK37eMzeSwXPaT7R9gcnIyVYAM3s9+e2br+Nx3IM0U\n", - "o2EH6eyK2+19uPU6LMfCPDoFz7CAIP+++HfVtPSlPsmUGx+gnu1Bql7tVVRUVFRUVFTMEbVETEVF\n", - "RUVFRUXFENQSMRUVFRUVFRUVv2PMm4/UCSeckDrocer75Cc/GRER73jHOwbaTUxMdO6mKZtQls0o\n", - "X7mrxaH1nHPOiYi2XAn3qSTotM8UqfMpV7BkyZLOvbtLPhx55JER0Tp48jkOv/gIfPrTn254EtF1\n", - "MuZO2Wn8TzzxxI4/he+2XU4gKw3icgWk/Df/oAWfkgsvvLBTTgD49E5a/ve///0DfZgW7r4pKXH0\n", - "0UcPvG952WSTTRoeepz20+BZtKdEAM82zxk3pTOQl5n8npBbl+Ww3x7jcIkg2jlJLLRTgoYSRGNj\n", - "Yw39TuNxwQUXRERb8sc+QP4b2Tr22GMH+mGuoI11Ah/f8573pL4gyD+0vP3tbx9oZ78K1gftKW9h\n", - "R3fKUMCniy66qDM/Gc+ZI2TLtEA7IdQu++S1XwZQMJ/HHHPMQF9Zws2sFAbPdhoJ1gXt7f/2+OOP\n", - "N+P1vkgb9kHWB3sRfbPPuT17EDyn/RFHHBERg3489k9EVujbco6MMW72LuY/K5nD+/D9rW99a0QM\n", - "7j/2CSzltqTVDvzAZXyQPQdIwB9oP+aYYzrJW/1bhJy7FJbLeTEe5pRyaF4/8JHv/cM//EOznp22\n", - "A7485znPGaCF9vYVtJ+Wy/LY964MnDn77LMjouW5y9TY74x9jr0LGfW+Alyai/6hpaQduin540Sz\n", - "LkdG3xmqRaqioqKioqKiYo6YN4tUCVsmhoXcTk9Pd6w2wNYhlx2whcIe/2gaWURRqfkPK4mRJRLN\n", - "QosdteAyDW4/Pj7e0bhdAgSgxfG+rVxZlNJsE5L1tc34khVMhib34xQFTrJaahpO0pdZgwB9WIvr\n", - "K/lRwknixsfHOzy0BYLP/SzTniVgnSmalXlnPE4R4XXA31nYP/3x6jnrQxbhmSV/taUWjTOTRctJ\n", - "n7+CLQqep2HpD8yfYWs6+37ZBzz0d7yevRc99thjEdFNLAhsZSstelmkrK1EWYJGv0/EMHLVl4ql\n", - "bDc1NRXLly/vHSfILBJe//DRVjQwUyQmvGH/s2zZosjnWQJX02RroWV9/fr1HQtTn4Wk7JN9INtP\n", - "/Tffw3o8U9RiFhGa7S3eD0GWwgQ+OEFr2d6Rg9nvm2ln3SMHWXRjFoG6cOHCNJ2J12+WHDRDtUhV\n", - "VFRUVFRUVMwR82qRsh8Sp0DnqnFStcnJyeY71rxt1eHuNysnQIkYl0zghJpp9uPj4813spwTzpdh\n", - "7SfTAuyfM1NJCU7nvLp8AkBDsEUhK52DNgktvPp7M9E57DQP36Dd99LAc2Jtoa9EDPC9u2lC20e7\n", - "eeihhwY+9xzBx76cYZn10qU/stwkjM/avpPnAeZoeno6zY8DbO2xb0dWWDezWMyUt4rPLIMgK76b\n", - "WY2h3SVH6Kcci9erLZLD4Nw0w/Kxsb/0WUdtebZ2bnmBdicazNrzTFtyR0dHO3xg3s3LzIqYJcnN\n", - "aPHf4+PjjXXK1gwnhbSFwbRAM3PB2OwjVz474hl+e6/1emYN0ZfHk82RrW22roINGzY08+M15TXo\n", - "OSPHYWaxcdkv7xMl3+2X5d/a2ZbtgkbvNzyLOff6KfluH2FoYO/NinlntHhvypJrjo6OdubHlnpk\n", - "qS//1UwYapF629veFitXroz999+/ee/hhx+O1772tbHXXnvF6173uqYuXUTEWWedFXvuuWesXr06\n", - "vv3tb8+KiIqKioqKioqKP0QMVdOOOOKIeNe73hVvectbmvfOPvvseO1rXxvvfe9745xzzomzzz47\n", - "zj777Lj++uvjS1/6Ulx//fVx1113xZ/+6Z/GzTff3Gt5mZiY6PhGgEzz6ivDYMuAyw+gnaAV2CLh\n", - "YrU+iXLvDMpMr77T9zh8j+6ovSwtf1auxJr66OhoMy5HMvmUvm7dugFas9IfwM+yT81MpTAynwXg\n", - "LNLAhaaBNS9rV6W82IcD7STzebK26AKpHgvyYItln1XIFoWyfEb5OeBZpj3zeyoz3TsC1tqrLbJ8\n", - "174NAD7YHw0LjK0M5fctv+7bvh22lrhvF/udyXdsmLU385GAt7MtoO21aT/Psi/6dqSk5wirhvci\n", - "a83ZWErLnn1h3Mb7o+fIVuCM94DnMdaFCxemWcKzig+sRfPFvmK2eHq/6LshgC7/XtiCb7/GzFKX\n", - "ZdM2Fi1a1LG0s29lFihHGALTwp5u9GUIt2UoiyAF0GYLU5at3nscv0N9Prjw3OWqsqhsQDvkJPOl\n", - "tJ9w6feU/c7ZKp7Nf4ahFqmDDz44VqxYMfDeV7/61Tj88MMjIuLwww+Pr3zlKxERcdlll8Vhhx0W\n", - "Y2Njscsuu8Qee+wRV1111awIqaioqKioqKj4Q8OcfKTuu+++xrdo5cqVcd9990VExN133x0vfelL\n", - "m3arVq2Ku+66q7eP6enp5vSX+TkBF+9ctGhRGk3mSABO1C4yCdBEHNWR1c8ra225rbUS50ey1pvV\n", - "t/N4s8iJkgeZNgt8EueO30U3s/aO+is/z+6ws9N8ZjXxnTbw/Tt/l9ovsLXPOXysHcM33t9ss80G\n", - "3s/40lestC+qMqJbUyzzS3EOlmHWkVLe0HKzyCdoySLF3J75pl9owSrgNbt+/frOWsnq8zkPEJ9n\n", - "kZVeV5n1qHzP/nqMf1j9Que/yaKcbF3qs764jqWtGX0+j+V47GNlebGfS2nRzLR6Wzuy6KQ+6/9M\n", - "tPh7pf+PeWw5H1ZrzXu5965sjFNTU50C8JZF+8TQLotStXwM8wddtmxZ57eE/cBrCCsO4/M6MWyh\n", - "x3+zz1LnHEzD8kPZmoqc2HIHXDDb+26fhRj6Mj9Ew+shs6baWlxaU/t8+frofbb4X0ftjYyMzOhU\n", - "XMvBVFRUVFRUVPz/FtOzwNq1a6f322+/5u+99957+p577pmenp6evvvuu6f33nvv6enp6emzzjpr\n", - "+qyzzmravf71r5++8sorO/1FRP1X/9V/9V/9V//Vf/XfH8y/DHOySB1yyCHx+c9/PiIiPv/5z8eb\n", - "3vSm5v0vfvGLMT4+HmvXro01a9bEi1/84rk8oqKioqKioqLi/zyGXggedthh8YMf/CAefPDB2HHH\n", - "HeP000+Pk08+OQ499NC4+OKLY5dddol//dd/jYiIfffdNw499NDYd999Y+HChfGpT30qvdr7u7/7\n", - "uyZtAveSW2+9dUS0d5zUw6G+Fd76k5OTHf8TaqFR84m+8Om47bbbIqK9E/2Xf/mXho6Ibk4ifGWI\n", - "0oIWai1FtNEk+ANAC3WZqPvF+Pic6AxoueSSSyKirSnoPDKOCqRO1Dvf+c6GVzvvvHNEtL49PIPa\n", - "SdCy/fbbR0TEDjvsEBERN9xwQ0S0fhmu44VfAnfjvr8/77zzmr4dXem8P9QUYz7djnt2XmkPz+07\n", - "xBgnJiYaHtKW8TD/zkVGLSzmn2g05vLuu++OiNZHgPmnZpn93rbbbrt48MEHIyLizDPPHOibunTI\n", - "wf333z8wDtfDQ654hqNBmf93v/vdTT/2M2C8lkV8G5lXeMjcUYOOWlv2MSFSCD5eeOGFEfFMzSpH\n", - "wGW10KDbkT2Mk36ob8ecOi8VNCE/5513XsNzxsf80zeyRd/UN3MNsi233HLgffYX1gXPxi+F/WXp\n", - "0qVNW9fxs38Zz2KO3DdjYC9jrlzfzH4eGzdu7NSrYz55Nq/ILH9TUww5tx8rvGZfRBbpv5QBr2v4\n", - "wvxvs802A30h915z1OaDVsbJHoYcsV9Q4/Dxxx9v5oe9g9+Qiy66aIDuLbbYIiLaNYmc8yzkhdps\n", - "9rWxbEL7scce2/hhOds3r5/73Ocioq0RyF7kqFdeoZ39gn74zbK/47nnntvw0PmxysjfiJaHzD98\n", - "YB2wP/Is17fj98ER2MuXL4+zzjorItpae661aL8tfosYJ3KBvDBO+IWsu35qOZfQx3yalswPlTWa\n", - "YehB6tJLL+19/7vf/W7v+6eeemqceuqpw7qtqKioqKioqPiDx7xmNt91110jotVibrzxxojoes5z\n", - "okQj22effRqtzZmo0W4feOCBiIi44447Bt7nRAo4BTuLbJYJnRPq7rvv3lgW1qxZExGt5gico2dY\n", - "Rla0IUeSYW1y9t3R0dFm/NCJ9SOzBMIXNAa0vCwjOM9+5JFHIqK/Hp61nGxcwDlH0G7QLKARoIEw\n", - "V8gN/L7zzjs742S+4Qd9OvdKWZ08orXY8D5yYTC3e+65Z/OeI6UYd5mBPKLVfk0LfW677bYD32fe\n", - "3b7MfbXddttFRDufzvYMsAJvtdVWERGx4447RkRrUQHOxs8cIbumZXp6ulmTw3Lx8Pcuu+wSEe0c\n", - "sY4yvtga6hxvEd0IT9YHPM9y80Dz7rvvHhHPWNcjugojsu39oS93keWecdgKBKxhM1dYR007+wT8\n", - "wNr82GOPddYEdN97770Dz0bWDOc0g59ZnVBHpJb5kzxPjirDEoWcO1KSdvTN9xm/97oy6pHUPVgk\n", - "HUXOPgENtqpncwStrAvky/vF1NRU0wdWQnjq/dxWP1v/LE+Mc9WqVRHRyg17dWltYk0hKzvttFNE\n", - "tFYyIu8B7dhjneMpy7LunHDO01cC+mhTRuWX8PwzFtcmBI7+LKPhPZ/wlD0IHsKPLGLSqLX2Kioq\n", - "KioqKirmiHmzSK1bt66xLHCaR/OyBstpF2vBqlWr4p577mn66WvL+7TDcsDJE/iu2O3te0K7O+64\n", - "o9Hq8aewLwunXzQnNNEspwl8OOCAAwa+jyZ+8803D7Sfnp5uTszQjWblcXIqR+t3rUJb6tACbB1z\n", - "Vtqyb8NZlA2sBWiJmdXAGhq0QmNplUTbQ0vBaoi2g8YB0EjWrl0bEa025zpYgLEiB8jZwoULO5o0\n", - "NOCHBj9cY8rjXL16dUS08s7cXn/99b3tH3jggUZrxYqRZf296aabIqJdazzDVgNoZL7pd6Ys27SF\n", - "h9DH+gBooNCArKKxm488k7mlX9fHimg1ZfuLZBY61iIaKOuHV1tHoRH/Hiwel19+eUR0LRgReRbs\n", - "vrZle6xHjBOfIOD8ZPB5+fLlnflBnpFXLBJYBW+55ZaB9vCY7zGnyInnFL5gZXn88ccbnmf1SukT\n", - "2GIPkOUXvvCFEdGuK68H0zIxMdGMF8tLdiPB/MNL+2MCfptYD8wRMpzlTItoedYntyVtzD+0s9cg\n", - "0wBZ59YFvtiKXI6DvZJn24cUIFvcSOy9994D32d9AFtbWReuMxnR8tB7tWkF8MX5uOjbPHe1D+Z+\n", - "cnKy8yza8rto65d5nqFapCoqKioqKioq5oh5s0gtW7as0dSBI2wAGgqn4LIYMlYMt/VJOotS4CS+\n", - "2267DXzPmVoBmscjjzzSWArwM7C1wzXSnIHYlhw0evjiukbW1JYuXdr4RVj7M92c3g888MCIaDUw\n", - "+OI7bzRRNAz45vv+iMFaRn3jy7KD04d9q6yRoFFAw5VXXjnwPD6HJxGtFuMMxOaL/W7QMNEGbdlD\n", - "U+WZ1157bUQ8o8FYS2e+rSFlNeUY9ze/+c2mz4h+nke0fN1mm20a7R66MisAVmDWUp+FsRy3x+Bo\n", - "yLJ/5gNZyqx69O31XEZAlnA2bawBzGlJi3nMZ173Br4gaNysQWukrEmsw/CF55XWV7Ry+xlhBTTP\n", - "+S6yh7VoWJZy1s0VV1wREc+MObNIY0lDzvHp8V5kiwz9OVu727MGRkdHG+uV93PPJ3ICXzILxa23\n", - "3hoR7Rwg6xktm2yySWMhY5263Bnj5naBvpHlrMIDfknMP+vE1pFNNtmkY/Xok9vyWTzb2cUzvyT2\n", - "OPvMlXxh3Ox3rkdneYEG5Nw1WW3Bguc8Gx891k9pCWT8zB/PhhbfSCFz8Iu+oNHtAWMs60VaFqHb\n", - "8+79YxiqRaqioqKioqKiYo6Y16g9TpacnF3PJ2u/bNmyNHrA1hHnqPDp1bW4fO+anXZXrFjR+U5W\n", - "GRuNy3WarGm6/hXgRN5X94/v2NplWlwxG03BWhBw/SbaZ3XfoKfsE2S5OeALp37nzwLmM9/rs6ZB\n", - "n6Op6NuyZflA03StNmANFE12amqq4wtmHyFr4uY5tGNldY1F919GRTFPWeSk14u1QPPcNSiB5ayE\n", - "86n1+UdEdP0zsAbb9wFAG++jXfdF1DAetHNHzpqHWE08n7TP9hfze6YadPDFNTS9/p3LznnYMgs2\n", - "7/OcxYsXd/r23oGVw7w1LbZMZXucrZHj4+Md+t3WdTGxHmWRUpklxygt2+xbWTSzfWJsWcraOx/X\n", - "TL54tihl0ayO7qa9o2EB/PLe5bxTJejDkePIEvC6cW67YXs6/dOupAVeeY1llld4zpy4dmVWJ5R9\n", - "qHy2ee7obvZe0zgM1SJVUVFRUVFRUTFHjExnJpff50NrIeOKioqKioqKPyBkx6VqkaqoqKioqKio\n", - "mCPmzUfquOOOa+7Qs2yj1CyjNlt5f+2og7PPPjsi2po/gHbOnkqtPer4cD/LnbozO7vW3sKFCzt3\n", - "tvRBTaGTTz45Irp5b7h3hXZqkNEe4AvCXThjoO7P8ccf3/TljM6uhUb9KVsDfWcOLfCczxkjvjO8\n", - "nn/++U1beEVbR2FQC4k58l03NLsenvunPTRMTU11aqHRN6/OYA4PPf/2kYCvZ5xxRkREnHLKKb20\n", - "PPnkk804Xa/MecNcQxHZok4ctDjqjfdpT52o0dHRjp8hfzOf1JTjc9dBA9Taom/XtATIEevuuOOO\n", - "a8aJLCGvrEHq+L3vfe8beLb97nil1pbrmzkaFD6ed955TX27zPeLOfjsZz87ME5rmo7yo6Yc8uV8\n", - "Q4xx4cKFnZqSHle2/l3fjr7tf1Wu/7I9+8VTTz3V4eEHPvCBgT6ggXFCP+Nkv3BknH0qGSv188r6\n", - "kI6E8hp1xCNgvPCF+Ue+TINrs7KmFyxY0FkX8Mo1JR0h5/XNXsT6B4768u9R+TsH7EcFz4866qje\n", - "vgH9wEdk12seIOsf+chHmvWf9c28ffjDH46IZ2rsluNxtCbtv/CFL0RE97fLud82btw4UH+wbOOc\n", - "dbxSPxXZBfYVY/4/+MEPRkQri2WdP8bCvFJrD1n0GcRzBO0ZqkWqoqKioqKiomKOmDeL1MjISHOS\n", - "tDXAsFa5cOHCjoXBbTmlO/+NT+2OkOAUm0WngMnJyU5kgr/jCLFh0QmuNQQ/stwt5bPNI7d1zhme\n", - "4ShH4MhC194qx2ZtzJFzRmYNyebI/VjT7cvibb5YcwSWQbTeLEeJI2vK5/k9W8NcA8pwtM0wPpbP\n", - "tnUmowXAhyzrvK2JzoXVRzvPpu8sLxifI0NZLjPTYhnvi361xmyeZ5GPbm/raEZL1i6iKyu2pDki\n", - "KIv69LhNe19UWJZlP4ugy3hP+2F5hEBpLcoigh0hx9rMaPQcOqLKvC/3NEenmeeOzvbcZFnpHXmb\n", - "Zfyfnp7uyBjIqg9klv2sHZ/7ZqTc68xDr+dMFrN59liyfcc0lnTxW0IOvGx/RDazyhZ9NWgjulF+\n", - "o6OjaV1G0z8sR5VRLVIVFRUVFRUVFXPEvFqkfHLONFhOrpwwly1b1qkEDnznzymW/BDWGFzNnKzJ\n", - "2f19+Ty0HZ7lvunDGpg1B0B+FF7xT8hqM0Xk2l52qrcWl2mi9hHxHXLZf6ZBZvPJnNhamFmqrBVk\n", - "NEd0eWStznyx3w3wXAHnsCppy7QX+2fYZw5k/LLGCUrN3HLcVwuv7CPTxE2z12aW02zJkiWppcV8\n", - "seUq8wUBmeWBsZTt7QPmHDSmzTnebEXK+OhalVgyy/b4etjS6nxCwHm0rBV7/tmbGAOa+lNPPdWh\n", - "m3xZmc9blqnaczWML6WlLsvdZSs3dNuvBtjKyDPYP8zH0rKVyQ5g3hifb0eyNeqxZTcZ4+PjnbXn\n", - "cQFkCQsLfMjySDGHWe68sr1/JzMrL7CV2HOY3ez4b8ZU8gXeMU5eybeXVXCgL0CBubIAACAASURB\n", - "VCqIUHXDvxfAOcSefPLJzu9a5kOb/UZnmNeEnN4wfPgxYMLExES6oTNwmE0JFR+w3Cdg84OxWWHR\n", - "9evXN4euviu3iG4SSG+o3sy82dG/k6OBRYsWNX17czYPnWDOJlcvUpuuae+ki+V3s2uULKmd/3bi\n", - "QuDNOzuYlf/3BgqfssAGX/05UScgMR39Y5bebLPNUqdZH7SzqywnJuUgjVxkB7Xp6emGDvr0ZuSN\n", - "E7lnk7a8WE7849dHi8eZHUbdlw+a2UHSV0UOlCi/67IS7guw3imV4mCDviS4Ea2c0H/fdYrHO5Pc\n", - "RnQPafCzdOAu4cAPSstMT0+nV7tek5lMWUl08sRs3y33DQd8mO7MJSBL9ujDTnYt1SfT2T5nGp1w\n", - "N3Nspp1dB7xflA7OjCtbFw7WsKxlV9tOBkr/ZTJdX8n64GBZtIIBmLvMFYRDEX+zPkpa6JNybMi1\n", - "A8IAxc3ZsyzDppF+eC2v/rIk2F572fkiQ73aq6ioqKioqKiYI/5POJtbK/JJ3e02btyYmtycun9Y\n", - "qQTg0g++IjDGxsY6ZVfct7U5axrWpCiYigUCYPJ0/wsWLGjMlra8ZOPLeJtZgXw1lmmZ5Xey1P3A\n", - "zrEO3x2mkfoKrGxvGoYlf3X5FZvuLZv87SLRo6Oj6fVIVrQ6uzawdpRpXmVJIWvQmandGpdDyoGd\n", - "0X2V2XdFbitGFiSRWUsyc7odQo2yfXb9ZxM+sPyjibvgKbC8OFijtBplVy2ZNcjWDxdBz0on9TlQ\n", - "2/JqixHavcv5mHYXge67Ti1pKANkHFQAvP7t0G459xUnV4G29JuW8sobOc9KhPlqN7PUQWNZCLcc\n", - "S5811YE9ICttYovusCAVMNP1mwMeTG9mqfFeNSxgyjT20Y5ce76zK2wsSsgsn2c3GL6Opt9Fixal\n", - "bgbmS/Z7maFapCoqKioqKioq5ohaIqaioqKioqKiYghqiZiKioqKioqKit8x5s1HivIJEe29NHfe\n", - "3EtSfoDSCbyPX1BExP333x8RbZp90sNzn8p9LHeh3PWTwj8rncIz8JUgRTztJyYmmvtUl/KgremG\n", - "Fu78eaX8gMssGNwFUzrhPe95T3OvzniJ9MMPAb5QfsS+PY6AoXQCZRaYE/hGO+61zzrrrIZu4Pv4\n", - "slRBRFsihM/vuuuugTHQ/p//+Z8H+ALNzA3fW7BgQSMrLhHEHMF76Eb+KClCqCxwJOlnPvOZiIg4\n", - "7bTTIqIb/bZx48amb+afchL4vBFVZX8T5ujtb3/7AM32qaM95Q3gy5NPPtnwzD6CWbkiotWYX+SI\n", - "vinjsHLlyoiI2HbbbSMi4r777ouINvSYcjinnHJK0yeRjdAEb5FzxrnddtsNjNcRtS77BP+QWVKa\n", - "EBl0+umnxxFHHDEwTkeb4V/DHFF+xMld2VfwmSzHWdJq36Knn366WUNHHnlkRLRy7jB2ZPL0008f\n", - "GCc0Oz2E55/+7Xu1ZMmSpi08L8umRLTRzIyT8TBOaEH22FecFJF1x75YRlTZb499C7lF9rxPuNTS\n", - "3//930cJ5Al5cAki9rqFCxd2EqYyn8gWexHj45W58b7IOmIPgs+sC6I/KW9y4okndsp3sTbpm/JT\n", - "rDlgnynauxSOfzfpn+eec845zXyy5nbccceIiLj22msjIuK2226LiIhLL700ItryM/SF/65/P9i7\n", - "XDrngQceiIhBP0HKlUGL5RtfKPpm/pGt0tep5I9LBMFH5oi9esOGDR3ZYv2zRzu6G5mkLE+GapGq\n", - "qKioqKioqJgj5s0itW7duuYUiIZOdFoWzcBpeptttok1a9b09uucRFlBVOCcPXyPk6nvRNEKHnvs\n", - "seYz6M+iTbbaaquIaE+3aOymhffpD82Lk7qjX9avX9/0OSz/iaOvnPvJgG/33nvvQDssE8xFRDcn\n", - "if82X7KU/mjJ/hw+OKKiL/oJLRUNCp7R9y677NLbt/MAZdFJ5GuiXzTziG6OKmhxKZSsXA3v8z0+\n", - "R34MZPbhhx+OW265JSIidthhh4hoNU6ABQnZcsK8LGJs1113jYhn1lxEV/MG09PTzXq2NdiWJnh9\n", - "xx13RESrUUKz5YW5wOIFDfCnnFNH8mSRfqDUVstX9pwy/01Eu86Yd2hzpG1JryPksPJllmcnqmRu\n", - "2B8A7zuScHp6Os2XxLqlb3L09CX7Ld93BOqwfWNsbKyTiw6YH8yZE22aBvjGvMPzvmhmxsz8Ma9Z\n", - "KRR/nq1/sNNOO0VEO8fsC+7/iSee6JSRgYe+yfC+UEblRnRlGUss68jroZSBrbfeOiIiDjrooIE+\n", - "s1xcnjPnp7PsMqdOQu0yahEtz1y+x3nlAHODhYnP6SfL9YZ1sYwk9XzSFgsatKxatap3nBmqRaqi\n", - "oqKioqKiYo6YN4tUmRmcUyCnXWfw5US5YsWKiHjmZJnleXA+GPq29Qug1VvzBD6RoomvX7++sRRk\n", - "JT9cANe5fKw1Qgsnb5dAsAaz+eabN+OxZcraS2aByIrXctr3qd95U8r3XCIkO80zDqxEAM3z1ltv\n", - "HXjfuZ1crqK0BNm3ie+gMTEeo8wKHdHNWA3s54JcLV++PM0mj/aPVQfrEFYzwHpwpm/GaxnFQvHY\n", - "Y4+l1gmApSrLk2TrGGuNdjfffHNEtJqbLRj33Xdf8x6WZeTYFkZkE2sIMgzPSx/I8llo/ba+lhYs\n", - "+8Ix31n5HWv7nl+vUVuJXAGhXHfInC2M0Oi9yFaQrJQScK43MD093ZlPLChY/e68886IaPlUWlYj\n", - "utnj2ZucdR24nMno6GjHugcYP33ax8cWSdYN7W+//faIyLNvsyZHR0ebcfUVz41o93PGhdwzN7bU\n", - "7L///hHR8hFavP5KWjILm2kp/S3L8bkMjceJfDHWvuoWe+yxx8B70M13LUPe983rrJA8a9g55Up5\n", - "cX456EUu+ip4RLQ+kYzbmdwBc9dXLNptGT9t2bvMy2GoFqmKioqKioqKijli3ixSm2++eXOqtQ+M\n", - "T6ScXO+5556IeOb0y4nZp3ROqS4YygnZ969Zvacsc2tZUNg1nbJTemb18WmXk7a13Cyz85NPPtmp\n", - "sZYVI0abc/2mbLy0QwvglM9rSYstUs4Sm/lTMFeOgPP8ozXAPxfCLLUpPsOfwlEm5iHjwRrkiDrz\n", - "0bX2wMTERMfy4uzBaL/24wO2xKCh8X0/k7GsXLmyE21ii4ELhKLloS27Jh3rBKsRcwCf+jKI4z/H\n", - "uKDbfUMjssU6cr0uj5N+Xe+xHGtWzLxPViK6ma1Ni+HIQct6KS+ev6z4LmActuRl1QccWQTt9qWK\n", - "aP3KHKWX7XPsn2jm9nfymsZqVEbiZfsioK1rlnqfxAqKFQX+IVee09Iq4kz+XkPIPzz3nmXaoRU+\n", - "8sre7d+XpUuXduYdntMX6MuOX9Ls3wv7Flp2S0sYvCM6j9+NzP+Kv22ZyQpFuyh4Vuw8ol0XtHFl\n", - "C8+nrb+2uGVzCkoaskzl3I7gS5ZVH8lQLVIVFRUVFRUVFXPEvFmkFi5c2Jz+0ExcSRtgqShfs9pZ\n", - "1s6yGkvAGizt0chMC/1PTU11NKjMquPq1lmtNecA8im/D9ak4ZH79p23eW1NCiuhtWqsAaXm7Qra\n", - "rq+U8d615exnAXhmWWux7L+UAUfOoVExB+4bTRJ/N/iQ+bE5n1bpF2YriC2W2bwD+1nYQpv58S1Z\n", - "sqSTO8ZabZ8lcSaasEQBLDH2JQKbb755JwISfpiHtMs0T1uwGBNaIzRgRSjH6lxk9o0yLdDqWmuZ\n", - "7LoGXaaZR3S1eVvSMp86+69lkWPQauvi2NhYar10tGkWnQyttPP+MMy6/sQTTzQyYkua8+jZmm5r\n", - "qi30nktbILC+r1+/vmPt8LrwPEOD5Qg4Gti3CObjihUrmra+/TAtyLNpyfz7HBnniOxyTrBI2hKZ\n", - "0W3fW9f/NC2Zb2FfhLp5zt+Z1djzbB9C72n4uTl6/Omnn+6sC37fsI6bFu8XGapFqqKioqKioqJi\n", - "jqi19ioqKioqKioqhqDW2quoqKioqKio+B1j3nykqBMU0b0Ldt0vavOUfgnOtUMtHOo4+T6au17u\n", - "RM8888yIaOs40d7+OrR3LbfyXtY5rajjwxiz3DVY5qjjRG0+A9q4t4Yvp5xySkOnfXug+5xzzhmg\n", - "2+0A9/PUZjv++OMHaHQuE94///zzm7pMwBlq+ZtaSPDcNaR8p02dMNrbkln6P9C3a+3Zl45xw3P6\n", - "tl+Gc/QgX65BVkZBmofvfe97B+i07wO+QLSHFmi0Txh8gRbqfm3cuLFztw+QW/PctOBnQT1E5tQ+\n", - "AvapQRZPPPHEjq+Cc8vQN7IF7OvmWpvmuf3TeD3//PPjne9850AfribAd6n7ZVoAcwBfqBMHH00r\n", - "NCxevLgZJzXf7E/kyFp4yH7hNca48Vc699xzB2i3f1tZB5S9iPpjjqRjnOwtrkFonxrXO/3whz88\n", - "QHsp6/Y/y/Y5y5jrRNLe+wp8ct2/vpqlzJd5zjiz6G36pjYfPLfvlGsvwsfjjz++E9npvYj1zJpz\n", - "DjzAOmL+qRdqH7E++YInjozz3mR5Ye7wmcPXttz/S76wP9g3bcWKFc1vEbQwPkcO8sysjh+fe8+m\n", - "f+onOi/Zhg0bmveob1nuoSUfHCnL+s9QLVIVFRUVFRUVFXPEvFmkyrvGYW5afbmPskg2W5acRdXW\n", - "oez9LLKqjH5x/b7MYmJa+3JrlH1nmcJN0/j4eJolN8uXkfVlWIuaCTzLURgZLbaKmCY/01qTNdNs\n", - "rH3I5MZZ511pHNgSxZxNTEx05sCalvni9o5i9DOyqNDy/1nOGfeRVQYw3K/5U/afjdPIMnTbGmBk\n", - "kXIlHNnFd5yZH6Bhm+dZHiFbwvl8WG22vr6ycWTjzyLxzPeZ1vZs54h2ttRk0dLOGzQ9Pd3Zg903\n", - "sPXQ69/r3bJolBFplvc+uTXdZftszfZlze7D5ORkh2fD1rOt4VkEsb8/LMqvD8OqT/BMbok8zwBL\n", - "lH+P+vie/T5kayiLYsz2uqwW6+TkZGodzn6jZ4tqkaqoqKioqKiomCPmzSI1OjraOaFnlhpXlC5P\n", - "4lmOEvfVl1ujfN+5Puyn4P4nJiY6Wonz32TZgxmHNQxnenWuD2fCnpycTKt0G9lJPMts7my8mYZe\n", - "wppUVgvMp31r0ln1b1tR7P9WjtNWrswS54rrINPc3V9Wq67sI7OOZtpuaeUqn+ncTaVm72cZ1iQz\n", - "yyzIMh5nlqypqamORTWzXtknKtMKM9pmso45B5vnN5tP84/veX/xvLPenMun/P9s8wJ5/LYGef5p\n", - "bx+Zvr5dg5PPnf/Hz56NNbTve+Pj46mFOpMtr2vg9U+OJ1c6AH259DKeZxapbL9zriOvZdMyMTGR\n", - "Wof9/jBrybBciDPlesosbn17aDkO5IPfNlvNTUN2C1PSzjidPzKzjtkSPeyWyb/55R6Q3XZkmd1r\n", - "HqmKioqKioqKit8z5s0iNTY21rFEZNq0rSYjIyOdDOaAkzQnYrLcOhuq4dMu/WSZi9evX9/RRoZp\n", - "GPbXsPbiLLIek8c6MjLSeeawU701j8wXIPOl6dOKMhqyO3prRbZguD9rgb63LzME+9m2NJj+rDZd\n", - "JouZH8/SpUs7/lTW+tyn22djyPzVyjka5vuW1UPMLJLmubOtW45GRkbSepWZtdNRTJlmav810GfB\n", - "srbqTMue/7JSQdkODZzoV4CsOarHfpwlLZlvT1+0Xd+4svWE7OLnVdLUNz/lK+NgXoetf8M00l9p\n", - "yXFGd7ellqD3f69Frx9oZo7cf7nXW8695jxH9gnMLBX0C5+zuoILFizoyFZmqbMlhf0tqxDA31mG\n", - "71JeTDey4z5AFlGXWXCyfbSvogDzxVzQhnFadgF89M2N+ZLRWvo1u89hvnTDUC1SFRUVFRUVFRVz\n", - "xLxZpJYsWdI5UWZe+5x2S98in6iB/ZT8eXaf6oiRrL5ZWU/MGqa1HWihb0cODau153w55suiRYua\n", - "0/2wunb2HXEuliw6DQyrtTQTMh+ZzJLnvx1B4vp/5RybR3yW1XECzCtaUebHZAtHKZuWlcwq4L4A\n", - "1lP7hMw0/7S3xTWzXjgCiL+t1QP6Y2yZH9PY2FhnPdtqAzJfr2H17cBMUWnWsD1f2fqn1hZzkM2/\n", - "ZdG+NOVYrXHzWVZDj/0Crd71/1ybjRxHtopNT0+ntfPsb8errePec0FmwaA9/JuamurUFjXdmYXG\n", - "8mGZppZaZk1jLkva7Rtmui1TWaRcdsuQ3XQsWrSo06bPn7KEaxRm+yTjd3411mFJk9cBz8huMPx7\n", - "aBrMR+bUlrw+PzZkxH3h2zYsOhFkVkDvnyVNmW9otp6rj1RFRUVFRUVFxe8ZtdZeRUVFRUVFRcUQ\n", - "1Fp7FRUVFRUVFRW/Y8ybj9Sxxx7b1Gt65JFHImLwfj2irbXm+llLly7tRJFRC+n9739/RLSRLNzd\n", - "PvjggxER8eijj0ZExKWXXhoREcccc0xEtHe43K/yN/fN1Ik66qijmn7xAYBefHeohUTtpCw3lWsK\n", - "UoPIfj1Et0ATNYhOOOGETvQi333ggQcG6Kam1Lp16yKi67dV1iuj74iIbbfdduBzapbhr/GBD3wg\n", - "reNmHwZqIcFz+3wwR1tuueUAX5h/R2sgPxFtbavTTjttgA9r1qwZ4B1+KIzzLW95S0S0PlKOUuOu\n", - "n/49p/izbLPNNg1djBO+QAsyyRysXLkyIto6TkcfffQAjfATPuFDQG0u6pstWrSoWUPQiyxSO8tz\n", - "xPjuv//+AV4yzg984AO9NMMf1iq0n3DCCc179Mla4n3opgYhNDDvzpdEe+p+QSM8hzZ8Zs4555x4\n", - "xzveERGtzLF2dtxxxwH6qbVJ3/Cc9vYhcd1P+IjvEf0+/PDDzfqkFhrjevzxxwfGzfseJ7LK/mJf\n", - "qQsuuCAi2lp+0I78LVmypOER88kaYr1vv/32A7x86KGHBsaJbDFOeM0zGPdnP/vZiGhll3U0MjLS\n", - "ieSiBiH7nGUV4PtyxhlnRES7d1k+4At8Zd+F9rGxsWa/QkbgqWttMi5klvW0zTbbDLR3TTn/hjFm\n", - "+Hj66ac3MnTXXXcNPIvv8jvnOqHwbeutt46Idv0zziOOOGLgmXffffcAzfz2fexjH2vGiXw7cpL5\n", - "RBapV8f8u/4fc2T5Yq9jTuDT4sWL4+KLL46Ids/1vPs3lz2a3wvnn2IMyBHrDnlhbGWtWtdaZI2y\n", - "fpnHbI4yVItURUVFRUVFRcUcMW8WqUWLFsUdd9wREe1J/eCDD46IbpQPmkiZfXz16tUREXH11VcP\n", - "tOUkjCWFU+xvf/vbiOhGp6DVEOmBxsLpn9M94JS/ZMmS5sTLez5hOz/G3nvvHRHPaK0lTR4nWh20\n", - "3nzzzRHRH1mFtsOpe+3atRHRWgE8TjQzW7kcGQHfbrvttoiI+M53vhMREfvvv39EROy7776dtvRF\n", - "35zu4Q9w/hv6vP322yOitVAAvg+/9ttvv4ho+fHDH/4wDDTsK664IiJa7RaLJGDO0FSuv/76iIh4\n", - "wxveEBGtZQ8gm/fdd19ERBxwwAER8YzcIHuAv7EYMCfIrCNIaMdcYgV64QtfGBHtXIAy4++VV14Z\n", - "ERHPf/7zIyJihx12GGjr7Pi77757RLTa/b333jvQHlqZk5e+9KUDtH31q1/t0OIcMsxvaTmMaDVJ\n", - "xsMz/uqv/ioi2jkAjjj88pe/HBHR7AF77rln09bRha7ThrWzpDuilZeDDjooItq5MC3A0T533nln\n", - "RAyuO56N3LIPvOhFL4qIrmwxN5ZJ9iTz0VZ05mbHHXfsyDn00je0XXXVVRHRXaOu1oAsY+FZtWrV\n", - "QHv4yHOXL1/e7J3sA4C9ZquttoqIlvfORG3anZ3/lltuiYh2vwTI17p16zpRauxNpgWrz29+85uB\n", - "z9kvAXzi92G33XaLiIivf/3rA++DxYsXN3RD76te9aqIiM5+4ezjrB/G4HFCC/sEv6PIcCkvtrA/\n", - "73nPi4iI6667LiKi2T8A42DdMEesceYOwHNe4SdWsr48UuylzEkWte/cV9C01157DTwDMEb6h29P\n", - "Pvlkw1PA/LPGbrrppoho5d7zn2HeDlKLFy9uFtib3/zmiGg3lhtvvHGgLYxlsx8bG+uE0AKEioPR\n", - "j370o+Z5ERH77LPPQHsY61BThJKNAyBIm222WdMXE+lFZDMx48uKrzrkFtoQNG+kk5OTzbjuueee\n", - "iGgnnh8ZQB8sKK6V2DjcN8+G53/2Z38WEe0BtTwE2tzLouM1+1H3hvEnf/InEdEK9Te+8Y2IaBcO\n", - "Gw/8fOUrXxkRg/ICz9nQX/ziF0dE+wP37W9/e4AWFj5zwwER+YKvgIXnA+lDDz3UKW3j6x/mJCtL\n", - "g2yVP0YRLc+5MnP/Tz31VDNOXn0YhdfMJz9y0OZrVuYIXl9zzTUR0fKnr/gvmw/rwpsWYH65duUw\n", - "utNOO0VExA9+8IPe73HgesUrXhEREYcccsjA+32AZyhtXv++or3hhhsior0KRJ4AfGSOkBtflUe0\n", - "ssGh+41vfGNEtHLswyv7hw8vzKV/YJxEkv4eeeSRhpfAyQzZ35DjTHnlR8ipW/yjTv8oicuWLYtf\n", - "//rXEdEtYWNakDG7VQArfezJjNeHQNrffffdzRUm+2RWbJm+OSDC86y8DUAZQBlk/N/61rci4hm5\n", - "Qs6RU9YzP9qA+YfWP/qjP4qIiG9+85sDNAH/9v3t3/5tRLT7cblHs79DLwrmS17ykoho5fjHP/5x\n", - "RHT3IOSBdp4jlxJCYaF9aWRwyo1sPwR2FcFYwPhs7HDhZA51Dz/8cGc+WWPQxxUlMsa+MQz1aq+i\n", - "oqKioqKiYo6YN4vU1NRUc2pFu7n22msjomvyRBPj5HnLLbc02i6mVcApHc2A72INyEqEcKLmtMwp\n", - "NksONjEx0WjzaEY+7dokjeWE6xdbgaCB8XNdgLXAWuPY2FhDD9+hT2uBLseBZoU2aA0TPuyyyy4R\n", - "EXHggQdGRMT3vve9zljtZO5EpE6SCt+wEqFxYQXYY489emnne7/61a8iomvhiWi1MTRtLG9oYFgs\n", - "TTvjRbOkH1tH4R9jQnMbHx/vmIHpE00S8z/jzJL4YU2FNqwkto6WFqnnPve5EdFeRXGNAJgLxvWT\n", - "n/wkIloN3NfS8HzXXXeNiNYitfPOO0dEyyc07+np6WZNwjM7ywJkB2sBMsYVtmXXcoUsMtaf//zn\n", - "TVsnb3Tyv4zn8AerAFcXvn6zwzM0cVVaXmPxTKxDtP3lL3858Ezg4Az4g1XA+wv7gp2vH3744c41\n", - "qx314TH7Z5Y0l33FlhzPEWPhOVtttVVDly2pvmZiX8ey730RWtijoAnromWX/pctW9aMlz3aLgz8\n", - "7Xlmn3ByUP5Grr773e9GRMSrX/3qiOheBY2NjTXvYc3NChzbeZr2WGBswSxvRyLaPZ09ukyey3pm\n", - "LWJ5wjrGngMcCMCc0I9dR2jPLQR7ARaw0hLs0mDw1IlFgRN3QgvWIluksgSoExMTnd+5bF/Emsq6\n", - "HoZqkaqoqKioqKiomCPmzSI1MTHRaGhoz3ayBNx58/luu+3W+K5klhdOrzikAd/Dor34Dt2Ov+5/\n", - "48aNjYXAFgTACXu77bYbGAfWsqxcCVqxQ/btQDo1NdUJBXUYPHApHDQHTvf2kXHRSiw6vI/D7CWX\n", - "XNIpv4DlCJ5mafnRarAw0De0mR9Yl+ysXPLdtNi/Akf1yy67bGB80Ir1B63XzsnwD7njddmyZc28\n", - "AuhEo2KukJssuRsy6SLW1o4Z45IlSxrrJXRjMcLPzP5a/O0AAUA/aLBY//BL8LpYsWJFszaQQeTW\n", - "ZWXs4IsPCTLKegFo3vARixf94lz7rW99q1PgFvnG8mI/RpfT4BXriB2lXTrC6UbK/plHtGB8pbB2\n", - "ZeWrTKOdkIHLO8HvBQsWdHx5GIcderOyJcwRew408X1bcFwGZ926dQ1dthiYfuQaa2dWQJd1wziR\n", - "Xe8X8AlrS0Qr9+YLz0beWc8uc2SaeTY+Rsibf4/Gx8eb+aYNltTMLxFrzhe/+MWIaHlvvjj1za23\n", - "3hoR7boqbwLgHesB/1Lf/gD45f2T3zpbPF1Kxj675U0A47ScI6Pec225Q06Qq8yaDr8yv67yPXiI\n", - "lYtzg/17M1SLVEVFRUVFRUXFHFFLxFRUVFRUVFRUDEEtEVNRUVFRUVFR8TvGvPlIvfvd7+5Eb3Av\n", - "z9+UQiC3A1iyZEknOuess86KiDblO/ev9q/ge6STJ80+7bif5W6cO1Snwl+8eHEnGSb0U06AUgX4\n", - "xjgXi9PsUzrD9/TOF1OWiPDdNH1CP6nwKW1gvtn/hlI7lAigX57DXTv8vfDCC5uyKdBnXzHGTYkI\n", - "SmHgO8Kznf+D9vCxLIHh51BOgPk3r/ku/geUQqDMBu38yrOQL8Zq+ShzvFx00UUDdAPGaV8HeE57\n", - "eM74aA9fXMYnohsJxXgZJ23pA7qdeI91QRkP88G+NJROOPbYYzvRY/Yvoe273vWugT4tizyD8jaU\n", - "fAD4lkAz6+XjH/94I+eOrnOkELJF315j8IVnwUdo99yUfzM/Lm3Sl1g4oi2zwvp3KRn6Zg2yXyC7\n", - "9rUq+c5eBN2sMfcNmP9Mzvk+46ZcCfJVykfWN+OED54bl+WhvAm04LeDvDD+z33ucxHR7tEbN27s\n", - "yArf+cxnPjNAi8dJe2jzOL2/eM8uy5vBK8sivEK2oBtaXL7L+//JJ58cfWCOGOsnP/nJZj6hxfsF\n", - "YJ9j/TuiDt7zN3yEFvgGH6B9amqq4QmJd112irb4dpF495RTThmg3T6DPIukyy7NVc4R32VvKX/P\n", - "I1rfMOeXY01nqBapioqKioqKioo5Yt4sUmNjY82J0jlc7EPFqbk8kdpyADgx+1TuMhOAUyunYJ4N\n", - "bY5OoJ8FCxY0p3o0K9Pi0znfZbyOIKEfZ/625gUWLVrUjAdafLov25bjp0+PD1jTtoZWjtUagu+R\n", - "s9wtHhd/u0SErQU8r48W/u8SISDLl2ONyyVV/H0Xc92wYUNvCZ+SFr5rEskLHQAAIABJREFUixNA\n", - "C8p477xDtNu4cWPTFhmynAOXRKBv89xz6bly/6Ojo01fjI/veA5smbOGbjm3VcFz3Ac+s6x4/om0\n", - "ZO9xln6vUfPDEbblHNm64XnP1omjsXjf46Vfr82NGzd2eIhsOidPxkN/7vItnlNbqqanp5vxmYem\n", - "oSxsW/ZheB2ZXzONw30A+vItAfPbJ+fl93yb0reOvI4z3iP//u1xOSLgOfCeVLb37Yn5Yh66tJLh\n", - "cZaWp/L7tqaXNPDaR28ffF4wP00br+U+k2VP9zzSzha7DNUiVVFRUVFRUVExR8yrRQpYG7Cm7pP3\n", - "2NhY2jbTJMgOnBXnJacRp2IsE87dU2ZKdtFQ1+VijLTDJ8inXpDlrPKdOVi0aFHHf4I2fdarsi8X\n", - "dpxJq4voamIlX3x3PQzQ5jvu7N7eVgWPqczHwjicNwvtLrN22LfIzwLWuPje0qVLOxncnasHHtqS\n", - "aThvTMbXcqy2dmU5p2zVQzadY8UaZZbzqBxrlrHY82n/EvM0G6+1YNqX7zOf9GEabO1ALmjvcWUR\n", - "xvaLpN/SKgldpRV7JtgfxRYpWweclbnUojNrheeTds5UbZrI1eP8acAWuZGRkdTC6Hm2Zcl7ka0F\n", - "8Jj1Y9qZw6VLl3Z8dbIbCX/XvoFu77xZyJ1pWbBgQSefXmYtz6yg2Y0EyCz8JR9tMfPeYp4zHvPP\n", - "1h4An2w1ol1Zd9N+yyCzvJnmYfunKwEgL3351bz/2ye4WqQqKioqKioqKn7PmNfM5o5KyzQYZ5+e\n", - "mppK6/Jk9Xs4lVqTsoXGvjJG6VMEXbyX3Sf7WZkvkceQWQPAhg0bUr8LW1QYN+PkNE/f9pXKsuny\n", - "PGelLZFleAfWMKHFUVjAlh1bsErrC3T5Hp3xeZymxfJjzQu5sEV0yZIlaaZ6Rw7alwHwLFsL+J4z\n", - "IcOnkZGRob4gmdbqWpOAtWj5ymRx/fr1DU9ma1EzsvaeU/jkKLiIlleZb1RW385rDl7bImE/Fvdb\n", - "WpWhi2c4ciyzSHuN8jrM97CUG4/TfoY8w5Z40wLtyD2RVl5H8K30OcysfMi9rcTZ3mK/nsz3DpQW\n", - "T8utLbWZz5AtlW5vq5grRoCJiYnOvmU/POBbA/svmnZHOQNb48u+MkuU59OyaHk374nmtnW5b0+3\n", - "VY9nETHvPRd5gVZH1nqO8Hv0Dcdjjz3W2efsSw1t/r0chmqRqqioqKioqKiYI+bVImWrgbVm4Hwa\n", - "4+PjqSbtHEOc4q31AEdtuE5PlqNlamqq449lzSCLTnJfAB8bxovWgxbY58fi3CuOzgC2uFgbympz\n", - "QROn+z7LjnloDPMzsW+Aafe47XNSWiScg8cahu/VnR/Hls7M18S+AhMTEx06bQ3xszKfL/MROTIt\n", - "1obL72bRKba4IIPmi6PenPsoi34q6XFUGTBfbEVye6wh0GxLZp+VGGRRrAAt2NZx+zcCywUWHc9t\n", - "RKtJMy5k0JZIwOf2FXKOIsCzzefJyclOBKl9IlnXjpxze487W+v4pZQRZ/DIllRgP6TMUgdPXYs1\n", - "s0y5xmXZp606WdQq8J7OXNi/M/MdW7x4cad2pmkCtrTaN8hz6hsc+/eU/fs31jUGTUtm0c2i+TKr\n", - "c59lz/U+7UtoZFbwzKfSfClvHbKbGmTRv2+ZH5ZRLVIVFRUVFRUVFXNErbVXUVFRUVFRUTEEtdZe\n", - "RUVFRUVFRcXvGPPmI3XcccelGX4BNYWoQdYXMcDdJnWZyvpjEd38FtyXUjvJ9aoyPx/qW7l+Wvkd\n", - "6HJb0+3Mvq6dZb44CqOsQWXfJ0epfPSjH42I6NQgy/Jp0Tf18DLQ/pOf/GRT28j8ADwTnlPHyZEg\n", - "9j+BL64T15eNmL6pnWSe+29qkGV88TNcD8v8Hh0dbeaHmlKe/yxPCu1Ni79nvlA/rQ98hxpRzFHm\n", - "8wBcU3JY//Dl+OOP79BtnwfXTszWP3JA331rrvw+7c8///yOLLotdLvu30yyFdHdXxytV66nsv7g\n", - "TCjXUES7LuzrAlwn0LXZSvBdaoohW1kknfcixmn/G79SJ7JvrJZbxknfzvXlXE/wnH3R0W6mhbGW\n", - "8pLtvawLatBl0amu5WrZBc67Bu3vfOc7h97AZHOUyaTHmUWBl+si2xf9W9RXx7OE5QFZpB5etq+M\n", - "jo7GmWeeGRHd+cz449qMwFVKmAvm6LTTTkvb850PfehDEZH/Rnv9s6YzVItURUVFRUVFRcUcMW8W\n", - "qRLWFjOrUHnitqUh68vRR7PNr+PnzASfYvvoLZ+V9Z09y7k5yveznE2Ousmsflnfw6Kd+vpw9uxs\n", - "PMPqwA3jubNz9yHjbRaFl33PfLPlqtQeHQk57LvDaM60JLefnp7uzFcme36dzVrzs2bqv/zMuWuG\n", - "9Z0hq02Y9Ve2ne2eMmx9ZM/K1ttcMNsM72CmNevPhtUcHOYqm1mD5oKsjmNWwcAyC4ZF1pafZXtS\n", - "Nv/QNGxP99990azZb5WR7UUZjZnVfTYY1jbrO9s3snqifVGeHuewvevZ0p5Fx5f5J0HGu2F7tVEt\n", - "UhUVFRUVFRUVc8S8WaRGRkaGatp935np84hurg5rLdaOsxpBWSbkMp/KTBWuZ6LTvgPA2YftA9KX\n", - "G2hYNu2MFvMl85nIxlBa7rLs8hmG1VQcpgXOpu9hPlJ+Zvb3/wYezzAriTVPW94yH4hSFjP6s77B\n", - "s53/meZ8rnnFMpiPtlD19TeM/gyZtpwh860rv+t5z3ygyKfjdZ/Jy0zr59ladbL5HEbDbJBVR7Dv\n", - "Z7bOh9WYy24Ryrkfts/NxpJS/m3LU/b7Un5/2Brt87cr/872dD+7b11ke03GF2OYVTijqe/5rn/p\n", - "uoX+LjnPnJcsyzvHbzr9krdq48aNQ9d3xtNhqBapioqKioqKioo54v+Ej9T/xkow7K52tsh8SGa6\n", - "U5+ttmsrQKZhWIMd5s/Td/+e3e1m/Jgtn2aak2G+YMP6nK2/xrC56etzmL/WbP263H8fbZlfmunO\n", - "fEFM02yfPZs2mZUr84UbZi17Ns8YZmEexvthc9f33rO1SGYybI3UsjeTb9T/1tqZ8dP99VnfZuv7\n", - "Nsznza+ZpebZ1FX0Hm05ebZ7d8aXku7MUpLN3zDLU4Zn4/+XWRhnu58Os/7M9OzZ7ncZstsUWzD9\n", - "vPL/9lvOqol4DoftRbZ0lc+ZrWzNxg+3RLVIVVRUVFRUVFTMEfNmkRodHX3W1oPy8+xk6RPksBOl\n", - "NRKf/v15nyWGZ2R5X4bl7vGz3T4bQ8kDf2dYNOOw9s/GUjNbCxTIIopmaw2aKVrFWvqzjRBz37ZI\n", - "ZHl4pqenU+12thFhw3zHMixYsKAT6ZVphNbWhkVtzlaD64vay6rce5yznaOZ/C4yzFamhu05wPwy\n", - "n0qaMt+gZ2sdyfYX0zTTe9kzh0Xx2YrKq31HZ7IOD3tmFvHlfob5iIG+dZTRMkz2spqSvwsZnas/\n", - "Y9aPZbB89lx9gYZFO4LZ+k6V/7dPVMYr17uzH6znyPXzSsvUbG8/QLbmjGqRqqioqKioqKiYI2qt\n", - "vYqKioqKioqKIciOS9UiVVFRUVFRUVExR8ybj1RZmwtwF8r7F154YUS0dX+4U52cnGyiBFzfjJo/\n", - "TzzxxEBfK1asiIiIp556aqC9a4o9/vjjEdHmnthmm20ioq3NAy0bN27s1GOCfmpKUSPIeS64T4Z2\n", - "6sSVfZdgDDyPOk7HH398Y92D7s033zwi2lwbH/7whyMi4qSTThrgy/r16yMiYrvttht4v6zjV9LK\n", - "s53L6vzzz29qhIHMX4c6TtTlIt8Hd9rkF8nqftkvo+SPawpCLzSQowfaqBF24oknRkQ7R74T531o\n", - "Z6y+lx8bG+vUN3QdJ3j5nOc8JyJanrvWlv2Z7DvndVF+h/Ex3nPOOSciWjmHRl6Rc+YA2k8++eSB\n", - "fpl3RwSVNQ5pyzrYbLPNIqJdc9TOor7dML8Vau3Bc8YEDc6I/fGPf7xTCw+eIe/IGDxnXTjCB5pZ\n", - "R/CFdcGzH3744Yho19HExERHbr3e7ZeCLLJf8Gx4Th4dxuQ1alnfsGFD857rfkKDecczkBdoR/6Z\n", - "0+XLlw/wi32UdVTuF3wHWpAV6GacjGvlypUREfHoo49GRLvmkF3Tzuumm24aEW3dt3Jd8B3mnz3H\n", - "bemLdYDsMgfIC7KLXNg3iOdR9+3YY49teOX8R4A5Ys15P2QOeOX3Bdk1P/ge/D///PObvpE9+MHc\n", - "WBZd99VrjrUIX+AjtPPsbbfdtnme1wXjca1F84X20Ayt/I38XHzxxRERcfTRR0dE17fwiSeeaOi+\n", - "5JJLIqK7RzM+5IRnsHdlmLeD1NTUVMcpDIbyCrwBTU5ONgLuH1cmhx8pO0fyTMCzeX/dunUR0Qq9\n", - "D3vlwoQefhh9YPKzhpVt4XMn5mSsbBglLbSlTeY0aMc7BJ325rk3Z/5GEMvNwAenYWHMXrxOzJc5\n", - "1zNW+No3VqcWoC0HBujP+oSPbOqWLx9Yyh9o8xD6fCBi/JnjI32CzOGxLGvEOPxD5z5ox8EbWHbt\n", - "4Alf7CgKFi9e3DnwsRllTvXwnM9RdrKSMj7sMJdl+yw4wH0BaCgPIeU4zXvGxCHAiSv7EnJ6nNCd\n", - "HdrdV5ZaABr8AzM2NtbIO/B8WSHy3zybA8VDDz008AzLF/sm/SxatKjpg73UtJjuYY7/8AvZzfY6\n", - "DmKTk5NDHZM9B7RHIWXcwAmcn3zyyYH33V/p4DwsNQ+yBy/ZTzjkZnsR8GGx3OuyfZE23ruQH9qz\n", - "r0Cbec/apb9HHnkkIlo+MicRrYzw+uCDDw6Mj2cBJ6r1b5j5AL8AY1u4cGFn/v17xp7qPoahXu1V\n", - "VFRUVFRUVMwR82aRWrRoUXOyfOyxxyKiPSVbI+EUzIm7tAZl6Qm23nrriOiaAbMSMZxMOeVCC7QB\n", - "TsWPP/545xrFloSs8CWap0/HnNCxpqF5ZabPUov0NZotDDZFcyXBODNrGv2ieVlz6YND6z1OF4hm\n", - "HFmiUvhhDX8m6xjaDW2gH1kCWPmYu3vuuSciWi0JTQtAK3KCprV48eKOtYtxYjngb56VaUeMwaUU\n", - "LIvldSR0Qc+wEkHwNLMwwSdossXTFoyNGzd2QuSh3+vCtPD57bff3vu5rxVpbz6Vz0ajNg9NN+0Z\n", - "L/zzNSxgLml/7733RkS7j/Aa0fIU7Zb1DO+9lngmNEIzPEfLB3z/gQceiIjWerL55pt39gqeyZpj\n", - "PQDLi2V3WMJfrAj0+8gjjzS8tCXdVlHkOtvnaMf4bXmxfG211VYNrfDuvvvui4iupdWgL8bvdQEf\n", - "6df86bO++ro4o4Hv+mbGe5bbM3fQZotf+X++Aw2+NgTe/y2b/h2lPXOOTGLZL8G8ITOsMebIv+ms\n", - "ZWix244tWIzV+8bSpUs7libvWXwnm88M1SJVUVFRUVFRUTFHzGuJGLTdnXfeOSLa0581b+7p0Ww2\n", - "btzYccAGWF449doiZU2MfmjPidVWE8Dpef369R3LkU/p22+/fUR0tT1O7/ah4mTNCRzNCliTmZqa\n", - "6viPZHTbJ4ZxZAn5XEjSTrtl/3aetX/JsFO9/Q5skdh1110HaLEVrdRgoM+OjDzDGiYyuO+++0ZE\n", - "xHOf+9yIaLVHLFQACxX8KeXMPLSFypY3ywvtrbFl/ZVWkMxyBLbYYouI6FouWS/WSPFtsD8C8N/T\n", - "09MdqwVrzfIP3WiryDt9YuUp+47oOtMy1nJN0+b+++8feBZr1Rrp7rvvPjBe+IP1w2sUPrN+PIaS\n", - "78gQ72Elt4wC5oIxeNy2jiEf+++//0C/69at66w5gmZ4pq2kWYkgt2dNex2xV7GXr1ixolk7tqTx\n", - "LPhBXzzDoB38sH9aaQWMaPm4cOHC5v9Zgln76/AK7V5H8DwrlGwsX768oaH8/YrIrePMs53TSz+j\n", - "iHZuaAefWB/lWC07XnNeo7Zq0Re/zV5HLhDMOuHmowT0uhixLbjAt0nwCVpswWJubJnasGFDp+9h\n", - "hcNnW6S7WqQqKioqKioqKuaIebNIrV+/vuNL41Mt8Ml9yZIlnagygHbKSZjTaqZ5Z2VdHDEDOD1v\n", - "ueWWjaXM980ArTiL2vCzHc1lHyD7VCxfvrw5xdt3xad0RwSBLPIhi9abTTHH2Rb69Pih2e1vu+22\n", - "iOhax0D5t/2MrN17/MwR/iVobrbYAPho37rp6emOlSYrvpmNE5nle2hcjv4DZeSl5yfzQ/K8ZhqX\n", - "LRa2LvbNv7U5R8IALE7wnPVu64H7Rf6RA4eHR7QWg0yztJxff/31A7RCSxa1B9BsHXna56/nSGL6\n", - "tGwxHr4H7dnaZV+09X3BggXpvgVfsFBlFmxr7rY62yKFfxsWvCVLlnSs/QCLAvun11wWtWpLhq3s\n", - "4K677mr+bznwuoDntqRk68IRx/6tMt/vueeezv4N77KoO15Zg5lPLd+nX55N+9IKZWsf33VEPGCO\n", - "eHVEnWmBX8gVYK5KqzHjYz0gH8yn+7Y82P/VtPNM37o88cQTnXl19HrmYzwMQy1Sb3vb22LlypWN\n", - "+Tgi4oMf/GCsWrUqDjrooDjooIPiG9/4RvPZWWedFXvuuWesXr06vv3tbz8rYioqKioqKioq/qAw\n", - "PQQ//OEPp3/xi19M77fffs17H/zgB6fPO++8Ttvrrrtu+oADDpgeHx+fXrt27fTuu+8+PTk52WkX\n", - "EfVf/Vf/1X/1X/1X/9V/fzD/Mgy1SB188MGdEPB4psfOe5dddlkcdthhMTY2FrvsskvssccecdVV\n", - "Vw17REVFRUVFRUXFHyTm7CP1iU98Ir7whS/EC1/4wjjvvPNi8803j7vvvjte+tKXNm1WrVo1cF9d\n", - "4h3veEfzfw5q5JEggoYU8cccc0xEtD4je+yxR3Pn6/IT73nPeyKi62dgn4+LLrpooG/u60lpzx0p\n", - "+TBc9mPp0qWxww47RETEb37zm4ho74/POOOMiGhLoRAxRXt8Q8hVRCkEUuHb/wK/J+6QKRFw3HHH\n", - "NeM64IADIqKNkMHfpiwnU46T19/+9rcR0d5L0ze0O2LyzjvvjIj2frosEePMxPYXoEQEPOTzl73s\n", - "ZRERceONN0ZEKwcXXHDBQHvmZO+99x6g/amnnmrKplDagLt6t8WXg75drmLVqlUDfOR+Hr689a1v\n", - "jYhWRonauvnmm5txUn7g7W9/e0S0crHHHntERMRNN90UEa0yAi3wnLlAbhzFiqzTfuHChU20IeNk\n", - "/uELbZF/ohRvueWWiGh5+9nPfjYiWj4SCUQ0Fu3xzylLZyC3u+22W0S06wK/GeTc88+6YK+ARvqG\n", - "dtA3/4wVWcT3AZpc8oM1etRRRw3QsuOOO0ZEG7UFLZ/5zGcG2tMvc8QY+0phOMcU6x/fFvYWaMcP\n", - "Z8stt4yIdg9yCaIjjjhigBZkccOGDY3vH/NJ+RlkC57fcccdEdEtKcR+wVqmBA60w3PmiDmFlu22\n", - "266RQXxhWP+U8EC27CPDHLF3uaQI43QpHcrVUMZlfHy8iZx2niPm0+WqaH/33XcPPJP1D+3I0377\n", - "7RcREf/zP/8zQEu5p+PTg2zBQ/hDKSTodhkWV4zwusBPa5dddomIdi+in09/+tMN3cjUnnvuGRGt\n", - "jyB7DL+L/D6z77uSCL5EyCK/o3xOFCdyODIy0vDQey57CzS4dJbLG9nvkfcpb0OZOGf+X7hwYTP+\n", - "008/PSLa8kPIFHN09dVXD/TNms4wp6i9Y489NtauXRvXXHNNbLfddg1j+pA5Gl999dXNPzbEioqK\n", - "ioqKior5xp133hk//elP46c//enQtnOySJWe+UceeWS88Y1vjIhntBw0HAhB8zFe9rKXNZo6ViBO\n", - "pPbSBzvttFNEPHOCvfXWWyMirxHmIr5onI74QoNCI7EWlWVC33zzzZvvcmo3LZyY0Syck8WHTNo7\n", - "o3lWV3BqaqrR6miT5fngWfAH/mWRkmjanOCxGjo3R0Rev8oRcwAewje0f+f+KccZ0S3I3BfN6Hn8\n", - "2te+FhGtVYg+gKNNiPTg+x4bfHB+oiVLlqQ85DvwwZl6AZ8zPtqhwTordymLjuxxDirGyfvIgXNX\n", - "AfiA/GM9dRQsWLx4ccey4AhHgGzCF2TYVgOA3DN3yI35HdFdK1g32ZecT4dxODKSv007NJe5ikra\n", - "yzUNfY6QzObfkXVZ1mngjOFYCZ944onOZ+w5rsWYVWVAFpkr52zL6gTy+vDDD6dRdVhzWGNEdMEX\n", - "0w4tfI/1zrrI+Ljppps2bV0IGDhS2nuvgQwiF+xd9O91t27dunRvyepZOlKO9o44g1/e8+inlHX2\n", - "cb6DVZzfC3gLeDbv833mCoud2zN+/u6rQ5tFPrPPe10zN8w3z/atADAfyog87y3+LaHv5cuXx+rV\n", - "q2OfffaJiIgrr7wyZsKcLFJlksL/+I//aCL6DjnkkPjiF78Y4+PjsXbt2lizZk28+MUvnssjKioq\n", - "KioqKir+z2OoReqwww6LH/zgB/Hggw/GjjvuGB/60Ifi+9//flxzzTUxMjISu+66a+OHse+++8ah\n", - "hx4a++67byxcuDA+9alPpVd7m266aeNv8+///u8REfH6178+IrrarqvCn3vuuc0p9DWvec1AW57n\n", - "PrJcTGgk+MSsWbMmItrTLtoy4HR87bXXxg033BAREa961atm7Jt7aLSAAw88MCK6OTc4maMVYQXg\n", - "5G6n/8WLFzfPJAWF78ABGgJ9wnvaWevlmaSwuOaaayIi4i//8i8jorW2RHRzy7juVmapwwLF3far\n", - "X/3qiIiBVBsR7X07B/hPfepTA+3Lw7q1tp///OcR0d59lz58Ea28MP9f+tKXIiLioIMOiojW7wBY\n", - "Ey35mGXZ//GPfzxAy1ve8pZeWhknfLviiisiovXbIMM7KPMM4duCj9cf//EfD7RFM4RuLHVvetOb\n", - "IqJrecVCgd/a9773vYiIeMMb3hARbUZwsGDBgsYn6ic/+UlEPBOoEtFdQ8gHfiX4K0ELvmQAPmJV\n", - "Oe200yKizUL/kpe8ZICOiJZnzDs0ubIBcoy2+/3vfz8iIvbaa6+I6Grq9lshmIYx4UsU0c4va2ft\n", - "2rUR8YzCWdIKkB/ybPGKxZ61DZxDDqvbkiVLOpZXtHzW/3e+852IiHjBC14QEV0LNuNEg4d/0MIr\n", - "wIrCGNesWdOsIdPiWwOsXOzp/s3gb9ber371q4ho5cHywj551113xY9+9KOBNr4hcf4v1urq1asj\n", - "ovs7YovOpZdeGhGD/oolttxyy2bNsbew5+LXCry3uMKF87E5+zi+k+yLJd/pi9+i//zP/4yI1s/O\n", - "43ROL/rKsonzO8Sefvnll0dE+1tXypdvh9hbeAZrFvAsZA6ZZb+xNRXa7YO1YMGCTqUC6P7Zz34W\n", - "ERE//OEPI6L9neurFdiHoQcpBKXE2972trT9qaeeGqeeeuqsHl5RUVFRUVFR8YeMec1sjkXmL/7i\n", - "LyKi1ZrR8gEnS07Nr3rVq5q2+KgAtB1O4Jxmaec7bEdEoNG7/hso7+uxblh7c1s0Ck63nMh9OrZf\n", - "lrM027KzcePG5jtEMmVZf/kumuMrXvGKgfGjkQM0d7QneM+r+Q495bjsbwJ4Jjz+m7/5m4ho+eQs\n", - "vGhBaJpEzjHHaEHlM/ns8MMPH3jfWfKhFRpf+9rXRkSrHZkW+Gh/nU022STNPI6cH3bYYQPjdg0y\n", - "5IfPiQjib8tXWf8QDaqvzlY5TtPCPFtemF8sO0TxQIsjCaemphrZIwoTDdI8ZNxYWKDF0buAOYPX\n", - "f/7nfz7weelrgvXLtSGZL1teGDdrjTWNPHiO4Bd8hmYsW+Ua5dlYQ7ByDaudxjgZC+Oz5m2/pbJG\n", - "m3lOH9DN+odP2bpAu///2HvXWE3L6v5/7T17z5lxhrMwnAURlEJt0Dba/nqg6ZvaNiamtlpLFLCV\n", - "KRCUg6iAQqCIQaytoBKkaZPWV9U0adqYpjZVYxPPCsr5zACio8xxH2b/X5DP/VzP577XPPz2n2b/\n", - "+8/6vtkzz3M/172udR3ua617rfXFA5nxZ3I/PHLHHXdc188s5tVce/THc5cxoh3zHXofRa8bN27s\n", - "vDO0nemQ8cbL6SrhgHnPOrrqqqvG+uB9dM+ePd08/7Vf+7WI6GcpAjN9mFvQnjpnpv75n//5WDvt\n", - "mKITPOxktjF3HPNEv7/xjW9ExMgjyfPRnhrGmucDe4C5btu26R+xz+jQzxZX+Hc1csPMIMRKTU1N\n", - "9fZodMpeiyz0z+siQ3HtFQqFQqFQKCwTK+aRWlpa6k6emfXfXhsxOokecsgh3anbljEnYn7DdVgF\n", - "PsU62wbLNOOUa2tSYI1yavX7cU7ClsmM2gBZaQfrESvY7S8tLXXyYcU6Ow9wnT0wyGDLi+uQ/Vd+\n", - "5VciYuT9aa1p2sBy4Lf839mG5pDD64EebakhO3+ZL8yfIYsX+bgGWTI+PGe6ZJxyXMf3zKu5ubme\n", - "HIwbcTZYOcS+eC6iR/TnjKmML+u5557rdEib3AM4q4/rGAtnp3ltYslx/ZA3lf5jtXIvW3Wea3iu\n", - "GBvr3HxdeAMYi5ZhHh15rdE/e6SALdXWim3BuPPXlnk7v9ARsrC3ZB4as9abH9DrHz3ZqzI1NdWb\n", - "58629G+9RkHLLRox0oszSL0u2rbtvXJsoD0U1rljLp156H205Xh0PI7lNmcr/WQMrEf2JuYTMlDr\n", - "y7LPzc1193CNQnuvaIs4Lu6RcbkiMx5cvCnI3urdvH3OqPb6Zz44K5y+ZPOFz1ln7COtXuin+S2B\n", - "93/z5Lo2pWOTkYGxZE/ftWtXb67gcaYN9i72FHuNM5RHqlAoFAqFQmGZmFoa4nr5n75pkslXKBQK\n", - "hUKh8P9FZMel8kgVCoVCoVAoLBMrFiN18cUXd54p3k86NgIeH/jzwMzMTC+25aabboqIEb+ZYxn8\n", - "Tvezn/1sRIy4k5wph2y8v73mmmsiYsRZtWbNmu49sLMKrr766oiIeN/73teTO2L0jpj31NQAgmuL\n", - "7505yH3o6yWXXNKLN7C3D34r+KqA66eYa8t1Udwuv7/lllt64wMXvJyeAAAgAElEQVRoG/nhzoJS\n", - "iDbdPwC/kXm/HEs2NzfXXQtHHG05y4i/1Fwx75tjH+gDta58fVvFnTnG+HAtbWWeWGSHa8sVrgHz\n", - "Cx6vdr5wb8cGZtxptO1YQPjKzG+XAT2269lcWB5/xojvnWnI7z2mrlcG+Pymm27qOL8A4+m9xTxe\n", - "bgvZ0Dl8aKwj1q5jq1atWtVxijGejnm0njxGXMdf4lvoQ7Yu2Kvm5+d743nFFVeM9Q+ZvA9ce+21\n", - "Y/20PvjL59dff/3Y9W1fHX/JumDeAu+H/M7cbK6b5Zgh2m/1MhRXGpHzfvpZ5HXE/u915ow7rn/X\n", - "u96V7qFcSx1Gz13vd6xZxh89opcsbumGG27o+sk923i6iJEu4f28/PLLx9pw9XHisJhfHn+ub+cL\n", - "z1Cyrs30AJDNvK+Wxc9Tnxc816emprpr4drznuu4Va6nnxnKI1UoFAqFQqGwTKyYR2pqamosu6L9\n", - "a3Bde7LkM3sx7Knyqd6WKb8355Z/18od8cJpOqvACzJPhOuEgOz//D5rf6hf2bXcm+/5nbNZgK0+\n", - "W7AR/XHL+ufv/X/X9MquB8jsvh/ot5M8eIA+WS9ZrZuFhYU0q8r9yjxwHhNbxe5n+/9sPRjc21lW\n", - "2bqwB2Lo3vzfnpZMFus8u/ek/w+tC1vck+aivWa2vD1fuI75YdnavmQeaI+r2/bek83RbB6tXr26\n", - "N2+drekstmzv8dzNxhS9tZZ9Jp8/dz+z5wCfu67egfZhj6/bHlrHEX1vOrBeJ8X7Tk9P93TojGng\n", - "uWv+R+/FfhPi9dDOxRe7DkBWbymDvY+eP+3+4X0QuL+W3c+wTHbLlK3l9hrPvSxrP0N5pAqFQqFQ\n", - "KBSWiRXzSEX0379n73h9XURec4RaI7b6bGkArEbHMWT1MrCGVq9enVqUGXyizrxIfE79EMeztLAV\n", - "A9y2PW2OHcpO9ZmXoZXFp/gX65HKrFtbJENWTdv+gSwvx0pltbuMzCNpPYI2bs9tOJ4is3LsRfXY\n", - "ZLFBQ97R7B5uM7O8+b//Zp6JpaWliR7V7HPr2P+3l+hAntzMEp6kD2BvoH9nffh3Q/3gHo55MxwD\n", - "xF+85ZnX2Jb81NRUGuthbx7IPM8g8yIA7u01cCB5s7XneW6vqOP8rPvMUxWRezOymlSZ18i1vQ7k\n", - "LWnHZahN3yvz0E7a0w/0DPCay9a1f2tPTfZ2xOvsQF5C17RzDatJXvUDvZkZ+jz7PiL3SGbfZyiP\n", - "VKFQKBQKhcIysaKVzTNr8MW8r590urcV66ws35MKrFh9ZBJk745b2bN4Gv6fWSuGrUX3e8jycgZL\n", - "5jFxDM2kasJYhR6ToT7Y2zOpnyCLFcg8FJlHopXd4z50zYFksOWVxXe44vH09HQ6bzN+MluQeEN9\n", - "XeZNbWW0NyuzpP3/bPxdLRhkMVPt/z1nJnmcsv76ess8FGvkcbPuJnlMvC58vauve921smRzx5lS\n", - "wPGKfJ95ojyvWm5L39t7UcZTBrJYwEnzCxn27t2b7nv/t3Eorsbtiukeo3YsJsWZOrbHbzAMz6NJ\n", - "byVmZ2d7HiNnhFpue+yztw4Z995QvOQkT9Ikz8yB4hKH7v1i1l1WyT+rVG6YSQNksbNDnvtJfH0v\n", - "tuZleaQKhUKhUCgUlokVjZGy9ZhlHvlU22YITXpvbGQnb59MOdU6rsEei1beF5ttkHlu/E7XdWcO\n", - "lM2WZYb5e+t4kmcvywRpZZmUvWj4/bxlymKhMmty6N6ZdTcpBmKStWy9tfWbbDlNyogz7GHI4nFA\n", - "y4I+KdPNFvekLCyQeY+GLPHMU5Rl59hjZc+DZfc8OZCn1/2ctB9ksTLZmgbemw60Jr0Gs1hA928S\n", - "H55rQrVtAXvOQBavlM3dzKM1NC8yj1oWU5mNlWXPvEGWcWlpqbcPTNK5ufcMtzPJ8zszM/OidBWR\n", - "xwwC38trOot/a6/JYocPlH3a3jt7vtrjiZdpKBMvq4+V7bmT4pS8Lg6UFZ09F7OM6kmeW1AeqUKh\n", - "UCgUCoVlorj2CoVCoVAoFCYgOy6t2Ku9yy67rHOfUbLAJQhcxr+lTuC1Bm1Qwh2KGNyGBI3jasTF\n", - "eMcdd0REn8Zhx44dY/fic8rVI8u+fft6BeIIZDflh18zIEvWttN76SuD2NJbOFUaN+fzzz8/1jYl\n", - "/Ll3lnIK/Qi0DLRLQJ9fO950001d29krKX5D2/QTih1k8usEy44s/A538p49ezr6EVMV2HXNfLjh\n", - "hhvGZAHozzQ9H/nIRyIi4sILLxyTYagoJuMPVYFf5QzpMGJEhcK4+9Uu/WWuI8vatWt7/URu2oZm\n", - "gbbRA/MEoHNoNkz1YJc9spj2o+031zL+pmXgFQX0TNzT9CNOJPArr49+9KNdP9EHpQMOPvjgiBgl\n", - "lbC3QMthOiYHwEKFQ/vck/bBwsJCpxMoopAXqhfuxRy67rrrIqKvQ79uok+mt/G6mZmZ6XRlyh90\n", - "jNyM/6T1jz78Gsbj376+pJ+mn2Lecu2mTZvG7kF/aZv5wpz9+c9/PvY72snosCJGOkeH0Il4X/Rr\n", - "N9Yg+ws693OFZxj6bZ8BfhWJTlnPtI1eaPPlL3/5mP7ot2UHDkehzzfccEM3Fx3gzb7+spe9LCL6\n", - "FGEu3Mv/mf+f+9znxq6nj8wrrlu7dm1HP+PnHNe4MLf3IuDkLvppGifLsri42I0ba8jXWgbT8mSo\n", - "V3uFQqFQKBQKy8SKeaT27dvXneKxErEwbOXZK3L//fd3J+QsVZITNpbo9u3bI6JvgTtIlHtxEnWw\n", - "Ge3v3bs3fvKTn0TE6PR6+OGHj13rV5g/+9nPut+2bQHTd/B95j1Ys2ZNd2/0wOkczxpwUOyWLVvG\n", - "+v3UU0+NXU//bbnQzjHHHBOGU1yzgD1ktbWbpTPbi2Yv3BAlBL/BisuocBygSb+ZP8xNwHXMXebX\n", - "IYcc0s0H99NBxsi0efPmGAKy43Fxv0E7f5hbfIa3A9AGFjP94178dT+ZR5NkaVPN8byga+aa2+Z7\n", - "PK7cI1v/6O+5554b+74lPWX8WBe0zVgwXoDP6T+yIbNT1NEfYAy5D/OiBd95TVoWF8tlnvD5oYce\n", - "OnY9c5c5yths2rSpt1d4P2OsPL6AttDLs88+OyYb8we4HEQb6O1SIXx+0EEHRUTEscceGxERP/7x\n", - "jwevZz789Kc/jYiIp59+euz3hxxyyKAse/bs6fpHf70uLBPwugf83qUYMnqT1atXd58hC/J5/2ec\n", - "DzvssIiIOO2008Y+p9/uJ/OAPeCII47oycI16JD93EHkwEHXfnvkNcp8Yc7yvEVfrd6Rm8/4Lf3L\n", - "ShTZW4wsft3Gmvaa3L9/fy95zJRy7C2ZxzlDeaQKhUKhUCgUlokV80ht3LixZ91zYveJlNMyVsLe\n", - "vXs7a87eC06SnEo5lWNJZpYXJ3Xa47SceQEOP/zw7h6PPPLIWD8A/eNkzD043ds68jt0rOLsdDw9\n", - "Pd31h9N86zFrgazoEAvTXjCD32Etcj8sj1bellQ6oh8TBBgLPBcA2TMqFOYH3jPuh2Ua0Y8PQAYs\n", - "DesFMCb2KhmMJfrC+tu8efOYTlr56CdegkkFFvGwYPUju3/X6p1+Y5VmKdTokPE/8sgjI2LkDQbI\n", - "wJxGb8hgb9qmTZs6XSPDJILboeKFEX2PhFOT7ckaSlF2XBFjk9GPZEVwM6+B95chfTPPHdPlODPQ\n", - "ltJo2+R6e0nwKrAvnHDCCRHxwtz32kIGPAWOBWUeAHteHOdny5750q5R5oG9V45fnVQM0mn+zD17\n", - "ESz74uJiz+PiZ4tjoRwz5uvtdWV9eA8Ea9eu7fTAtfTH+z9t0PYTTzwREaP9zWOKbN7zua7dF13W\n", - "gblE/y0L/WdenHjiiRER8eijj4793rLQN55drIG2fZNO02/mg98y0bbjlnkm+bnI/2m33atanbRt\n", - "e43awzoJ5ZEqFAqFQqFQWCZWzCO1a9eu7mR5yimnRMTIkvUpkJMop9yZmZk0zsjeHxdk8+nVcRku\n", - "N2/rqLVckQuLyxYmp3H+2lNjWbBY7E1BRlsBCwsLPSs3i0tx/BG/s7UH/H8sClMBtHJmhdQcK9Zm\n", - "UbT38rtz4Fgx/g7Fsdm6xXPpuCqAbLTJHMQazLyGyMT1jz/+eC8GxkX77HGydcTcG7Jq23u7/dnZ\n", - "2S5+xvFGvtbfO1PK/ST+xNmMnrtzc3Pdd7SVxRk6Hs1xCl7TyI7eHFPTtu+CrPYgZJY0wCOJnux5\n", - "Y4zwcKEH+t5607g3bdg7Zsvb3i1k45721Dm+E9kXFxfTfczZvawP69wFFpmrWaFiZGjndFZI1J4Z\n", - "9gPPSWBPDN5TPs/2rnXr1nXxRvZmAPrhmKGMasqeKmemDpHcszbtObIOHaf3ox/9aExmzxdkRibG\n", - "Eg9dGyfHPEUW77leB5aJ5ymyeX7Zg4ssQwVcuRaZHOuVrX/u7b74TZCvbz13WRFs9nnmVuZ5zVAe\n", - "qUKhUCgUCoVlYsU8UlNTU91JkpM2J02fAk2guXnz5rREP9e6DP2kDBKfQJ31AtqTOPfA42RZnOGA\n", - "ZZq9fzXxrD0cQ5lVtO134LZe/LljQjKdc5rHwzVEkTNEKt3+zWJlbA1k1AmA60zf0XrCHDdDf7Fe\n", - "MjJSW9qmLwC0x/X83b59ezqerqeTUZtgiWFpE8eUZT/S15mZmU4uLPCM2oR7OGMyyyAFmVcV7Nmz\n", - "p2vD9X3skbTnra01E5HHJbQeuIjRemplNYk33+GJsteUMcq8xJ6LJsx1val2jNrxiRitIbw22Vzk\n", - "d65t5Rg5e9/suWlhj7y9hda5ZcfDwOcZaW27pjNaJntDkDvTh2s2Od7JY8q+OzU11fNEZXMrq1E2\n", - "iSKJuW4PHti7d2/vjUqWQey4O5DJAlhPrAt7eiPy8bSnGjhrm7hUP18zGR3v146Rn7nOnB5689K2\n", - "4We791H64tjilloO0D90jwfe63oSyiNVKBQKhUKhsEwURUyhUCgUCoXCBGTHpfJIFQqFQqFQKCwT\n", - "KxYjdemll/ZqkzhrB26et7/97RExese8tLTUvbvkN3BhXXHFFRHRr9XBddwTvqLLLrts7HpnYfB+\n", - "Ht4veH8WFxd7bfIuFh6f888/PyJG71+JM3Elb3OQAVfuNtfWe9/73p4M5vH68Ic/HBERV199dUT0\n", - "4xEcMwMH3XnnnTcmC+/MkYX7fepTn4rLL7987DPAGPH3xhtvjIiIP/7jP46IftaR64r8/d//fUSM\n", - "+BPRr2MjFhYWOp3AV+WYFcffwMvFuPJeHf04pgzZ4axCf20mHte+//3vH9Ohq88bt912W0SMeJ+c\n", - "tWm+K/pK+6tWrerFyNF/1tA111wTEf2MKVfEv/baayNitC6c7enxh8vvbW97WzevXUWfeX/nnXeO\n", - "9RM4awfZ4c664IILxj73XOS+t912Wzc+9MuxX9yDfjK3mCdZjBRcWx/84Acjoh/HQV9XrVrVzRXz\n", - "PnJvZ+fR9lVXXRURo+w799dzMePmbLN54SvzvHUsCzLC+wfvo+PzHAvDvssYMY+mpqZ6WWWf+cxn\n", - "IiLiQx/6UEREr+q4ZWKNXnnllRHRjxF13SHahfdt7dq1nTye98jNfuEYL4As6BH+TPTo+CTGouVy\n", - "c1yq+8H48+xy3KLjr7gefkPHf3E//v/xj3+8e7Zk2ZaWheecYyu9RuFDRC9tFfGI8RpQ5v107S3H\n", - "PbN3sS6y2m78n/GHF5W9vG2fezLPf/d3f3dMZ44d5nOeRRnKI1UoFAqFQqGwTKyYR2p2drZX4ZrT\n", - "n0/JrmC9fv367pTuatLORnE9GdcRwfqjJo153cxv1dZfcp0U19ZAXtdqyWraUI/Knp2sHsvi4mLP\n", - "Qmx5plqgLz7n3kOVZyP6DOvOamnbt0fJNWtco4TMMtcooiaTq4vjibQFyn3bDEv6SX/MvO74PMYd\n", - "S4p+83tzq9E3y7h+/fretXAvWnfci/4Cc0rZ0rTsLccj93YmDDAvG3/tsTX4nMr5mVdt3bp1nQx4\n", - "deinrXw+tyfKnheArMwXZ6q213sO2tLMuLZYq6xBPBT2HjA/0AdeFX531FFHdddyL+Q1x6Dr33gO\n", - "DtVmamE90Pe5ublehqdrNZkBImMfYO2ae89ZXmRQttla5kYD1Dl64IEHImK0l7BeYAsArDV705m7\n", - "1k/7BsAeRj8v6JfrgWVZePb8OqPQWYG7du0ayyKM6HsB22sjRnPK9dhaTsmIfsY1c5D2276yj5u3\n", - "0pXcgTk4vYdltZ6GWAbavrX98jPJ2c3+LePvrPDs2eXn6+LiYq9tnu/sLT6TwAQwCeWRKhQKhUKh\n", - "UFgmVswj1XJ72Yq2dcxJm1PjmjVrulOqr8V6cRXszOLmNIwVwAkcL4itKeTes2dPr65FxuNlPics\n", - "CVsv3MuWZsYsvn///l5cgWNeAPfCGqS/WJbORoC3y1YfJ/VWn7TtmAh7gwD8TUcfffSYrFgScBca\n", - "js9xPZFWFqwRxzK5n7aaXV3YFi3tutLvUDbHySefPNaGvVlmcwfWo70sAAv+8MMP73RIP22N2ZPo\n", - "Wk626qnsTjtcn1Vl37p1a28OskbtHTUHpeMTrUvWPd4e11dqLW8zwrv6ta16rx9gTwNg/Tz55JMR\n", - "MdIPfWp55Vg7rvfkGEnA/12jCn1advptz0Ybv9l+FtGvm+VaXsAVwbHkszEdijHKav1RH81vARxL\n", - "CpCZPcveIq/RNhbNXs+MfcJvLszXBhz/l3lswI4dO3pVzx1L6H6a0SJ7dr385S8fu96VwltPrdsE\n", - "XJONJx4re/Q9F9nTuZ5150rhbVuZB8o6t6cWZNysGdPGqlWret7uX/qlX4qIkReU79mjX2xRg/JI\n", - "FQqFQqFQKCwTK1rZ3PE9nNQzfjtO5ktLS92J19V8OUHyFwsBS9FxJpyKecfPSZzrfYJtrUlb0j4B\n", - "O57AVbEzlntiZ1yVd6gqa/addehsLlsUWfVxc+thkbfWARaFdZ/x2z322GMR0Wevx8uDpWrZMwxV\n", - "K7bnzDxwwJmUzsC0Xp2N0nJLue2HHnpo7B60jYVlrxFzMMsgtSy088QTT3QeIn6LLgHjRRvMLbwm\n", - "GdeWOfaQcSjW0JZxNs+xUpkn9MMZpMB6c0Xsdr5YV/6/rVePI/3KPN54qmkPPeNdbT3tzG97Rew1\n", - "A5mnCv3Za2DPXMsk4PHh//YC8H/r/JlnnomI0T7I75lH3nddtX9mZqZr2/1hzuH1Ys6iW8e80M7W\n", - "rVsjYjQmzLNW521fZmdne+s+4/30/MgqoLNmXbE7i8HcsGFD6pn3vmZ+VNZTtjbx0DkbcChei33b\n", - "2cxZjBxxvZ4f9mRaFu9djg9r23Q2eva8YD74eZjFazkDt13bnov3339/RIzmO3pgXeM9nYTySBUK\n", - "hUKhUCgsEyvmkWotZteoyLxAxJQsLCyk73z9G06YWTYTFrZjTDILFkxNTfVqTfiUbqvN74/tNcLa\n", - "4UTtzES/S96yZUvvnb2zMgAWBm3Qti0TgJVvjw59HtKL+ZUy0E/HUqEXZzM5k9LWUesds1xYM+b1\n", - "A3yONeh4C7dHXBL6bGvg2JLiPTtz3fFYHn/6b8+M5xVo49sco+J5Tv/s9coscPOCeX4N8efZC2jO\n", - "OIOxwDuaMR4gA1av13I735y1O4m93bFD5sH0XHYWK/PB8SkRfS+nuSezuCz04mxNr1E8VM7y3L9/\n", - "f8/jbL24//Yaslc5li7jIHO81szMTDcffE88UfYGmhsN0Bfvi9m+23r2/LbD+6LXieOSPH8yz1MW\n", - "g7lhw4aeZ5lrvC7of1svMaJf8w9kXld7bCJGunL/XVcMmJPRz9GMP9NvZ/jb6pG5ksUMu21n3rru\n", - "VPaMdh8XFxdTTxp//Wwprr1CoVAoFAqF/2EU116hUCgUCoXCBBTXXqFQKBQKhcJLjBWLkfrABz7Q\n", - "vX/kfTzvOokpgZsJriXebz744INxzDHHjLVn/ilOjmTTEH3Pu2+4kP7kT/4kIkbvcKlVw/Xck+vh\n", - "N5qdne1iedq4gIgRXxFcW7RN3JHja+CUgivIMVHmGKKvF198cZfhd+qpp0bE6F0vOoUj6txzz42I\n", - "Uf0f6mY8+OCDETGKnYE7CT3yrpzrnM3413/913HppZeOycf7ctfRMi8T2XtnnHFGRIziNMgwgWvp\n", - "T//0TyNiFDtgDqXVq1enOnd1bd6B+3rz9wHiDBijd7zjHWOy0N7u3bu7NmgbTiniM04//fSxfjP+\n", - "cMrBb4XOmYOOETEf1rp163rV0ondgVOSa9ExsT7oxRyEXI8eifdijJGJMT333HM73f3qr/5qRER8\n", - "7WtfG2sDfjP0wlzi3s6YY+4yF7mnM5D4/JZbbunG07E/zHvkh1PSbZsrjN+x5syfiJ7bLCXzftJ/\n", - "KnmzJ3Ev5jncnMh81llnRUTEd77znYgYzVHaNx8i82XNmjXdHoPc7FvojHuz7oH50Ji7rFGynIhz\n", - "vOuuuyJitEe3fWWPRlfMRXNnspaQnzZYF/CEMrfZ44i1ov/MRbg/p6enu8rU1CJjnFhD73rXuyJi\n", - "NAd/+Zd/OSIi/uu//mvsd/ChwrXIHoR+qJDN3t3uAa407tguxt98iK5hxlgxd1mjjud1JuFHP/rR\n", - "bnzYcx5++OGIiDj22GMjYrRn85xj/DNeO/TFGHE97Zx99tkREfGNb3yj6+vtt98eESMeR+BMaXPQ\n", - "8rygn44lNjenef/Axo0bu9+yhpiL1MHi79e//vWIGO1RjFGG8kgVCoVCoVAoLBMr5pFqq87ylxN3\n", - "VsG05U/Dasu4fTjVuw6Ss1OcGeV6Mln14R07dvSudVaNK7hmGULuJ5+jB+un7aPZuOl3VkeK6zO2\n", - "c4BV6Otc6bht05Xps7pAzozh/0M1R9p28BZimT7++OMRMZ61Y04wcwY6mwlgYeLtwGNniwyLy3xg\n", - "P/3pT3vjY2T1ZNw27Zg/z79rK4hjeTPOWFa+Ft1NyiDinngLnDHnddTWNMNLgzcn445kDjn7xusI\n", - "ax/9MFbop70+40rLqh3TJt4N9IPl6vF3xqXXfmsFZ1lJ5iIEXMe9nWmbca25mv3+/ft742PvH/Mc\n", - "ZDXw0A9MB9RG81ykXWRcWFjojQVwhW9+y/7uPdfsAWYvcCYufW+zmu0lB66A72eN9yI/L9iDsjU9\n", - "Pz/f7T0tT2tEv/4V/XaFf9ag9/TWGx4xGlPWMt60Vl7aZD2zRq1D12G0V9wZ6eyzrlbv503bhueH\n", - "xwC09SPb72nbsvhc0e4BWTV5PmdPybg5M5RHqlAoFAqFQmGZWDGP1KpVq7pT6/e+972IiHj9618f\n", - "EX2L1FbDc889150Y7Rmw9eJTvy01LBVO5Mcdd1xEjKwGTu4Aa3LHjh09T5Hfadtb5Arn9tTQP36H\n", - "TMSn2CJZWlrq1Shx5V2D64nToJ+WHUvl0UcfHbv3ULVin/JtCfh7PjfTNnXCXOHXNWyIoUP2dr7Y\n", - "s+LqubYwuJ5xRn/IkNVXwUKD72rXrl09jjB7kvBAZLI4/oA4N8YWDwUY8oJklcqRgTbwvDhmCtC/\n", - "bK4O8btxz1/4hV+IiIhvfvObY/cCrt123333RUTE8ccfP3Zv4PpBtIf+WlmYl4y79eC5SBuMq9eN\n", - "axq5ho3jXdr5gtyOX3P9H8A6Zz2cdNJJERHxrW99q9f2kMx4BYY8o/SbOYVMeDHsBbB3mBhMYkdc\n", - "Zd1r/Wc/+1lvrwV+m8Cc5f/2liEb4w/PITq3N6UdC1fazvoJzjzzzIgYeZrQF2C82YuQFZ3bE7xh\n", - "w4aeZ9nzACCj9ZG9HWHuUpWbuT7E4sC1ruHnmlWt3BH9twaZ19g8sW984xsjYjSn4e6MGO01rtjf\n", - "vnFqwT29bvjcz2j6z32slxauXcg8v/vuu8f6PwnlkSoUCoVCoVBYJlaUaw9vEqd5xxABe2I2btzY\n", - "vf+1xemMLn7LydinUmeaZZxBoI1zcAyE4QrMfv9qL5Ar/HJiN98Z2L9/f9cGVo5jggD3pH/2Etgy\n", - "83tmx2u0VoDfeXOvrF4YOkQf5tiz58WePWJmLGvEyILMeArNQWePHhaVs9kAY0GGEe3u27ev571w\n", - "1iIeN+aiPW/uLxYaY+NYgDa2DC8O68I8fp6L/Na6ddusRdbZgRgFkO+73/1uRIys+iGOyIjRumEe\n", - "MKfsYXC8EvE+/K6du652jkzsMd5L+L851+hvxinHPV21vm0/47fMqkPTNn0gs8oV8d1X5jrekA0b\n", - "NvTGx+PsNZvx1dH/H/zgBxGRe7zNr7lp06bu35bFWc7cwzFElp32GBvLDBib9evX9zyr9gLTJrol\n", - "sxIPir2Gnj94pNmz/LzYvXt3z+ufPVvQh59FrEF7ahyD6zne7tH2buP9Zc+yhxEwrpOeyc4w/+EP\n", - "fxgR/SzYiNFzzXpwxXpgjkrGFNksu2N2+d2GDRt6cnMN+jGjR8ZBa6zYQWrXrl2910Uoxg9SJlDr\n", - "Es6CXk0F4olg164DNh1Emk32xcXFXul6v9oxLQODwoLywmAwkcE0LkMbDK/gTErqyZgdxrIy+3bl\n", - "Zu7liP6m6gdE9j2y02bm8mbhoI8D6cWvgbxxZskD9JPNyPcEzAf0zN+NGzem9AsEX5vqxvPFr2gc\n", - "jGlZkH316tW9A4BfSTB+9GsSIbIDX92noYOXDzZeW8A0LA5892bnQFmu537tRuogWdM4Za88TX3S\n", - "ltZowdj4oe5XG20//RrQ5R58Pdf5cOcxykihV61a1ZvnpghB7izA22PH4T+TxQ+viNyoQ1fI5CQb\n", - "70Xoj7nLGs1ekbKvTE9P96itvIeavoeDog0qy8L1WRgCmJ6e7iU+eA0C03VZFq8LGyQmIm8NDOax\n", - "5zljZL2YSJj+ZhQ5loH5wuft62bTzpgIPSMtzozBLFwDvbf0QBlxNG0+9dRTY795scXD69VeoVAo\n", - "FAqFwjJRFDGFQqFQKBQKE1AUMYVCoVAoFAovMVYsRuqiiy7qBT7yTpd3ni4R35bOd7EyqBCgTSAI\n", - "lPfLeMF4Jwr9xIUXXjh2He9dibto6Sfa9vfv39+9u+U9MxZNWrkAACAASURBVO9msxL+gP7RB2gZ\n", - "oFpxcKHjtpDl/PPP7+IBeCdNWQPScimFD0UE790J2HZgOzQO7373u8f0RTwKcRv0/dZbb+3kdrwB\n", - "/aQ/yI3OAf1zmvDHP/7xiIjYtm1bRPRjy9oicegQuXlX78BE+mlZkJlgbQLDTREE1YILFq5ataob\n", - "f9PsuKgdYK6ZroLrCKp2WQxT0ESMxsPFDrkWWRgLF/lDFnQOvYkDQh3XCKXMu9/97k7HyO9YBfSC\n", - "zh3P6JR71v8FF1wwpjfaZ2xa2ekn8mYFM6F88Bo1pRBzkn6aOqNNNqDP6BAqDK8xgExc/5GPfCQi\n", - "oiuuyr0dCwMVRkZvtGvXrh61zVVXXRURo/VPm6xR/jJGjD/XITtjZaoVrm+D1Pkt/WBvgWaFvYQY\n", - "mUceeWTsHuzR7P+MCdd5D0OP7fxyDIx1znpGL06qAPQTWYADp3mOtBRUjtd0LBx6Yb64rA6yIONt\n", - "t902dj37A/pgDNibbr311t6+xV9kQ+fMLe+jjiVEn9C+8FxkPdBu+xzmWcSac4kFAr0zKiT0wtzO\n", - "9miud1zcjh07Op362YJu2XMdE8a6yFAeqUKhUCgUCoVlYsU8UtPT093pkIJ8zoQBjtZ//PHHu1Op\n", - "rXysHFKH/8//+T8RMfIaOZ2Z07BPuRmJbXs9cpEK35bkjxidiF1qwOn7wMUBOaFnmTLr1q3rUlzJ\n", - "dEQfTvN3tgUycA9nbaAnqDPQD5+3mRIeH8bRXgGAhYoX7UClFVqZXdCUdlpLn3+7n5PKWZBZhO49\n", - "B4H7T99f9rKX9UoOuMDg1q1bx/6fZVbau4RsTn8HGzZs6JHyejzRB1YqhLiQ0GZUOPSJ/rJm3f7a\n", - "tWu78UdeewOAywI468Zj1N4jYjRfGOuhonmZHrICe4wjBWgpzGtZ6D9UKZC+unBhRN8zy5pk3rrf\n", - "zAvTk2SZkswv1jyemow2K2LkcWO+ZHOKucl8568LUhr06f777+/GyeufceMvWa0Qo3vMnHHJnmXP\n", - "rTE9Pd3pHA+s91D6xTxnPCEWz8qfuFRHRhGzsLDQ80Q5s7i9toU9mBldDXMSfSNbG89jWp0sexU4\n", - "+5u92tncgOcuc9v0La3s/JbCqtaPyxnwf8aGOdyWNWiBXpkXbQHnrBSHPdB+jkxCeaQKhUKhUCgU\n", - "lokV80jNzMx0XiOKnxHfYwuD0yHF0nbv3t0Vn7NHCksJTxTX0UZG+UJcwr333hsRo4JlPu1yQt2+\n", - "fXt3uufETHE24JotWA5ZsS+/h8ZCPfHEEyOiX2Rx/fr1ndx/9Ed/FBGj0va2btApVgyWN2261gt6\n", - "QX8UVwSt1YtObHliEflUj1XA9xRmZWxs7WJ54PGjjD9F31qvARaU55CL4QE8bvQHK4nfWxbGDg9n\n", - "S2uQWZhYUugSz4GtQo+RYwbtaWg9m4xXVosH2d7whjeMyYIOLTtzEZ1jqWVFc2dnZ8fqtbTyW+eu\n", - "l+MCjW6be5tSCBnb2k3WA/PWxT8BsuE1ZqxM0groEx4OewLb/YXvuAdzxoV5gb1feMfZX9gfAfMF\n", - "ryJ9OPPMM3t7Cx4D1g79uueeeyKiv3b5PXuQ6/ZZdtcvm5ub67UJGF/2WChOXBQX8Dlz9eSTT46I\n", - "0RhYb3hm9u/f33mWWKcef/rB+DFf2AfYH4A9c8jCGFjvCwsLvXg0fmuPE3K7jhhtWp9t8dOIkdfI\n", - "NdSQI2K0ZzC/mWOe5/Ya4gVEj35eMKZ4au0tbdvHQ+S6V64TZzCWjA1jmcnOs5G+b968ubcvOk7T\n", - "xOh+a5ChPFKFQqFQKBQKy8SKeaR2797dWW+c1I866qiIyCkC2mq8rhIMbOVzqieOyZ4aTtKOHXDV\n", - "bYD1s3Pnzu47rBbHPDhrZdJpF4uCv3iwOC3bgtm1a1dnQWNZQOXgd972rGC9ZpWt7ZFx5kkb9+UM\n", - "B1c5tg5dmZr+2tLw9VhsXIcl23oNnSFl2onsHbmr1DMfslgQQHzH888/39M5bdOfb3/72xGRV10H\n", - "zNms0jegndaCt3VvWajci+fVhKHA8Vquum49Li0t9SgusDxZS5bFFEv8LqN8oD3HErb6YV7aG4Yl\n", - "7jXEembvyahf3L49UXjVW68B48gcwjp3thIwLQu/wyuYxTHSBzzia9as6Xne+S37oKtIe980pRb7\n", - "QRY7aO/Jxo0be/QrgP/jMWC8MxoXdIu+2PMYS+akZdm7d28nv6unAxOI02/WbEa1hf7wYDEvhmhr\n", - "uDZjjwDORkVPzEnPF1Ps2KPb6pFxob94mJjf1ovJ3P0MzuYisnIdbxvaZx3jjSysY+aY9zvaRmbG\n", - "FA+t5xfXcx+eo5s2bepda0YIV0P3mGUoj1ShUCgUCoXCMrFiHqm5ubnutHfCCSdExMg6yuKYiOuI\n", - "yK15v3/GU2PyUsA9sTA5QWf8Zpya169f36vv5JO0M//43jV83CesGn5PH4ZijWjLcRKOp6D/WMOt\n", - "LlsZAad+Yqgyz1V7ra/BarGnhu+xhnwPxwJgqWF5cj19aNu3pc08QNfup2On+D2Wlb0jyGyvwp49\n", - "e3pyM36OpWOuWZf8n/k+KXOkrTfW1rNq+2PgkTJ/WcZBaBJvjzWYnZ3t2sIjQD+ytepMt4w7ztmg\n", - "ttjbMfJvyb7LuNZcX851hDym9Im9C88V7bSWt+PV7EX33sKcol/EENF/980xhuxtWO4t2LeQiWv4\n", - "TbZGadtz2Z4pZGQsjjzyyF7tOWDeP9ey8hj5jQX6YS47W7pdFyeddFJEjMbAe67j9OzlzPTiNxkZ\n", - "f15Ef62go4wonDYYbxOvA3v87S1q++psS36TkRbbk8c8AJ67Js72/Ghlt9fObwPsBab/2dsi69z8\n", - "sG3sqT1M3lMcl1pZe4VCoVAoFAr/wyiuvUKhUCgUCoUJKK69QqFQKBQKhZcYKxYjdd5553XvRrN6\n", - "Mtdff31ERFx++eURMV5niXf1vAe+8847IyLi2muv7a6J6HPn8f9Pf/rTY23zPSdO3h3zf/iQ/vAP\n", - "/7CTkffivKPnvfDVV18dESNeJjxwjgFDxs997nNj1/t9PjLw/hYOoquuuqr7zLFA6JBr4XFzPR1n\n", - "lMDNhV6Q0VWa+XvdddelnIIG/FO03cYXtbKZ3xCeKGextdkfcD7BP2bdOV6Nts8999wxGbmO9/j0\n", - "Ex40uJmc7REx0hV8Vea3cjYe90AW+K383p71QUwAvG/MF+ZAxCh+oB2fiIgPfOADETGaJ14/rC3r\n", - "EbT3iBjp8Y477uj6ynhwD8eTwVcFXx0yemxYo3DtwZ3FfDHfH/q5/vrrO/4xjz/z27xstA0cv0Rs\n", - "IfsLenGNtJZnErnhtzQzATJ4PM8///yxe9MmcZD0F17Jd77znWOfs2fNzMx0/UDn7KXmQCOLj3t9\n", - "/vOfH5OdecKYOvOw5ZSLGI3p9PR0L2uPfnq/cDwN85415/WP3ugj7bPXwbc4OzvbGx/6D9cicmex\n", - "Q8jGvnjNNdeM6YW93PphHV166aW9Kvt+NvEsgiOQ/nNvzxfGkj2ddtA9Gaqsi2uuuaa3Lzq+kHsw\n", - "zxkj81marYJ19L73vS8iRjG6Xh/r16/vrj3vvPPG5HMmJDLCncdcdJ1F9GM+PPZFxyZPTU1111pu\n", - "68WZwYx/hvJIFQqFQqFQKCwTK+aR2rlzZ2ftUR8oq93kk+uqVau6k6NriHAK5STJCTTLYuJeWb0I\n", - "Z+20FX6xuLI2kNeM6VldKKwlc8nRV2d/zM/P96x42nR1YCwEvjcvmmW3Bec6JK0+kSvjmzLMwUb/\n", - "7EUAfO+xoJ2WP9EWNDLRZlbri7/oI8uss37bvniO2Vtor45lcbabx8Y8kW0FcVuMrlFmj6U9LlnF\n", - "X3tH0a/rsSwsLPRqd2XZrNwTa76t8zJ0vT16ztZp9W4Pq73BnkPsH66TlMVC+HNkGOIVdM0txhWv\n", - "hVkZzK3nNev176wt9os1a9b05or1MWl/dOYt48688bowp93GjRs7XTurKqszh/zZPuKxdJ0u0HJy\n", - "so7RpTPCkc318vjr8fb8RwbGbIgvj/6ZWzLL2vNehSy+nn7iVeI6Z5628mZVwC23x9dvi7J6jK6V\n", - "OJTlay8h677NtmxBG/ylf5ksxtC9DXvoMm7WDOWRKhQKhUKhUFgmVswj9dxzz3UnbqwYW8HAJ9ep\n", - "qakeBxDgt/akcBK1t8txGlgYfu8MWqvbnjJbmD6Nu3KtvWlYT+YUy7iWNm/e3N3bHpis/glwRVt/\n", - "z7tus3cjWztG3AvLwBaYYUt1Uu0jrjMXFe3DBxYxGj/kxdthTj3Q/rZt27FygPaYs1ioP//5z1Om\n", - "eDOm27sHmMvEOLiumMcf2ffs2ZNynwF7e2xpW3Y8NMxJ5gE1zbJq1RH9mCCDyvTI6Lgu8yQyphnH\n", - "Xut9yzxSILMwbeWCTC94YMCQ5e36aPZIZNXn6Q8ezMw7hj7YV1r9eN4Sx8k+Yc+9PTXoDxn5iyxe\n", - "2+wXLY8g/fG+6Hva++X9n/XAPakm7lgi0NYMdG0qX+uxyTzxgPF3LSzGyvPriSee6PYtKs+7Lp5h\n", - "dgZkzp5F9mDRp5atIJMbeJ57b7L3MKv1hax+izD0LHCMk+ca8PdtLGBE/80O+rO3dUgGexjd7+yZ\n", - "ZJRHqlAoFAqFQmGZWDGP1CGHHNLxlGGROlsFcGpsPR9ca44wx19w0uQkbmvHFU3N52VrEI/EzMxM\n", - "d6I2t5jl5sQ8ySNhlnh+jyxD79+R21lJrh6LByWLL3E/+T+WrE/z7Ri5ajh/M+8Y/WJMkC3zAnpM\n", - "7XXA4mt/i9XHd3zuuYWninHld86UBOiPMWo9do5LskXuftlbwnWMHfPKenVfN2/e3OnYld0BHGL2\n", - "LNBvW95kczneKfMar127tjcPuJevxWtBFWR74LLKxvZIDsWa2BPlPcVtc529R85OAvaK+T7tGLM/\n", - "ILe9RLZ22Qf5ncfQXkDaQ4bWi8yaAngBaYP54HkAXE3aFfCzKv5tPB9rJKvITduOdbJe2FcdfwO8\n", - "LzI2c3Nz3TxGl67ITb+8fzrjFNj7gd6Yk5atnW/8O/MwIgu6NLuCf+dsTo9RKytyORudtWePpKvw\n", - "m2XBa5p7ek93HHH7mT1GzrIzXJU/4zD0WubeS0tLKTev9xJnHU5CeaQKhUKhUCgUlokV80ht3ry5\n", - "O7Vy4rZVDDihcmpev359ahlzGnX9oCwbx0zR2btfgDW9YcOGXsYDFiEwb4+9RJnnxfFcfJ5l7bRy\n", - "O7YBcHp3hiG/syVlvZkHaWissrgsf+5MMHOSGUPZWW27Q+++3T8s8Mw74jg9xo75BOg/1jZ9WLNm\n", - "Teq1s66wCj1GxDFgBdsrlulxw4YNPU9j5gVAH55jbtv1huxNNaanp7s5Zst7Uj/5Hp1mMRJc7wyi\n", - "A1n9bQ2ZIZiTES+JayABW66u29Z6ahhn5hjIMsJoG1mcITrkBYwYeQHwSOzbt6/neXGcGchiyRzP\n", - "Zd43712Og1pYWOjF1QB0OylLFzgrzbyI2b4xNzfXW0tZdiIYmlNDMLcgv7Nnb926db1aTOwp3lvs\n", - "ec7qjrVtR4z04IzDdkzQeebNG+LOHOpvtqYta8Yj2/7b/ZnksfO6yd5gWaY2Yzfbv1zLzl71SSiP\n", - "VKFQKBQKhcIyUVx7hUKhUCgUChNQXHuFQqFQKBQKLzFWLEbqkksu6d6V8l6VGCPeY8KHdOmll0bE\n", - "6L39s88+G0cfffRYe/APwYXmd7TEJ/GuH64dOIieeuqpiIg44YQTxn7Pe2x4nGh/zZo1XdyBs7L+\n", - "8i//MiJGnE/EXRCn4xou5hRDD8SSbN++PSJGMSLIcuGFF3bxM7ybJ0PogQceiIgRjx88Tq7ZAoiz\n", - "QBZ437gn17vm0yc/+cmUU8xxN3AhwZ316KOPRkTE6aefHhER991339j18D7Bh0SsAfrgvfbmzZvj\n", - "hhtuiIiICy64YEwPjpEhDue2226LiOi42RgLridbkVpNzBdkRwayXhYWFrqxMI/jgw8+GBERZ511\n", - "VkRE3H333RExip1BFuYL405MoDMOkYUxPeigg3qVpbkWXja4Ir/61a9GRMTv/M7vRETEvffeGxGj\n", - "OCxkMR8i68CZMvAKXnrppYNxY20/zSnH3HL2K3OL9Q83nysgoxd+94lPfKKbi1l2Gf9HH/Qzq8mD\n", - "jHCsXXXVVWMysKaZL88//3y3PllDztaz/PDVwYf4ve99LyIijjvuuIjox2lwPXpBv20NPPM4wv/J\n", - "mjvllFMiYjRWnufokXmFHohfYk9j/FlH6GHPnj29+DHrnLYZb2eQshd96EMfGpPRcaDmCWVdHHro\n", - "od289Z7EHs3+75gyx9dYloceeigiIk4++eSIGK0f9m7W0Tvf+c6uX/TT8YzMF/jtWvaMiD4HKTpH\n", - "j6w7xubEE08ck+nGG2/sni3MV8aTuWluRsaT/js2ENmzPZ15gD7Wr18/9txqgdzspcgN1x77omOF\n", - "0QeytHtRxGjP4rodO3Z0eyvzHJ27Sjxrir/FtVcoFAqFQqHwP4QV80itWrWqs5qeeeaZiOhnwgAs\n", - "Gq5bXFxMa4446+oVr3hFRPRZ7wGWCB4uLK1HHnkkIvpVlpFlx44d8cQTT0RE37oDWOS+Z8ZNh0XJ\n", - "KRhLhn47U2bdunXdafwNb3hDRETcf//9ETE5EwaPCnWUbDVzL2f7IVNbdyTLjOK3kzKm0N8Pf/jD\n", - "sXtYFioa02fGBiui7QdeDtficj9dZd21qpzlwRi5ku/OnTt748PcwjuGFYhlfdRRR41dz3zhdy1n\n", - "WCsjaLMZqZfDeFpuey5f9apXRUTE1772tYgYWYOA+cPcQyZqP3nuLiwsdNYuc406cc5aY41xT8YI\n", - "/dAOyNbLUM0sV9d3lmpWo4ZxxYJmP7BHi7lMH1/5yldGxGgOtrV7nPnqueU1Sht4FbGkkck1jVyH\n", - "5/vf/373ezwCALkYx9e97nUREfHv//7vg7JwPf084ogjxv6f1TRDP88++2wvSxkgg2veZfEnzAfG\n", - "0nOQtwmg9VTgrTG3oOXmutZ7EdFfo/aK8Abjv//7v8faA5s2bertmfQjywjDU8dcZU1nmbi0yx5w\n", - "7LHHRsT4XOTf7D2uVeWK71zv519W6Zt54SxQ/rbtm1WD/QD4eekaefSb67ynm+WjrfjuWn/0hzpr\n", - "zIPXvOY1Y/eahPJIFQqFQqFQKCwTK+aRams6YKFwMvUpECuAiqatVWnvBW1h5WBZfutb34qIvD7G\n", - "McccExEjy9QVbgHW9f3339+d5s3a3vYxYmQx8D2nfFsk3Ou1r31tREQ8/PDDY9f5NL2wsND184wz\n", - "zoiIiK9//etj/Qe0gdWL7KeddlpE9C1MW2783/E77W8dh8D/LTfWC140rHqsQVvetGPLi7HGYmuv\n", - "xdKgrawuCJYS7/axBrF6rRfax8rBKnrZy17W8/oh7+/93u+NycTYeJ7bG+rq09YjXoennnpqoucF\n", - "b95v/MZvRESfU9LWLp8zT8z3N8T7hQzI5XpBwPFowHEpwF4hfjfEcm/vlbk2bVEzh7BI2WvwRGQ1\n", - "jdwXPHetrIwFbfCXucUYADxPeGiHYp9aMAasB+bu6aef3pu3eCJOOumkiBhZ7T/4wQ8iYhTrA/ge\n", - "PSBzxg/HWPD9zMxMtzcjH0AP9ryzlrwu0Pnxxx8/9j2fZ16mnTt3powNwJ4T+PBo2+sCPeI1ZN+g\n", - "j8S1gdnZ2U5e1/0yEwZjRluuk5Xx4bkW4hAfInuRvcaMr73G9nYCdOuYMv7PcwhOTsdURYz2eZ7n\n", - "zD32PdckA+ZYzWCeVfRx0EEH9eR2tXTAXpzNd2NFD1Js0jzsssEzgey6det61B+AyYQrmldYLADc\n", - "noBJisJ4NcaDw4psC5gNuVCHwObOZGVCeJNGFl4ZEjDuIFuwd+/ebsC/8pWvRMTo8EXAITCdBJtS\n", - "VuyyvUcLFkjrfnUpfm+E/r9fcfznf/5nRIx0a1n4P4e4rVu3RsRIn237tMHc8uE8K96G7jkEmFIF\n", - "+PVbm3BgXbmY6Ze//OWIGG3Wpp8xCSuvpR3oD9pXgLwmcwFNX8uG8aUvfSkiRhupDwjcCwPDND7G\n", - "wsJCN6cA+vD4MwY8ABhXDhJ+eNEXk/jy/3aN8p1pmRg399P0M/w1lQ4wNRX6Zp/hwBHRL3bLA8KF\n", - "aIEftCQpZOSsxqmnnhoRL+jPewUyMCZf/OIXI6JPZgzYizFSWA/I7n3Xv9uyZUvvdQ9wUUfGLyMK\n", - "Njk5v2csbXih19bwyA4AtMGeYqLgbC9Clscee6zrb0R/v2z7w4M9KySJbl141hQqgO/Z23EaeI63\n", - "16JLZOHZkhnSNkgdMO8+OixhyDhCPhujpnMDnpvs6aZnAvyf/YHfb9q0qXctemHdskazfmaoV3uF\n", - "QqFQKBQKy8SKeaT27dvXK0/PidSvpbBoWpLGzKvjkzeBiJw4be1ymsfC8GspW15tqia/RRa/qrCF\n", - "wV+8GLYC6B9WDnoxkWoLPrvnnnsiYmRJ+RTP/wkARgb6ayvAVoNpCNpXGMiHzkwQmwWm8jqEMcLS\n", - "yIKqsY7Ro9OD23/bQsIit4XJ507FZ5ztBfKrozZo023j3cD9jzcPz40tRzx1ppDBYssCQjdu3Ngb\n", - "V1tSrCk8C3hQsEztHfNraHt0/LptaWmps+bwMPAbe3VMDUKb6NzX2yL3+Leu/uzVDXrJ5jn6Qcee\n", - "P8Dzgb4yd9v9yMkWftXpvYV+MCdd0iJL2vD6WLVqVS8A18HnzLVs/J1sgieTzy27yW3Xrl3bC5MA\n", - "phNBZ5nnzUkl3pPcfhtywXeZt4vPmRd4RTPyb3vwTG7sZ0D7+pZxQr4sUQrvMh53v6YG6ANPlIOy\n", - "27WAHniLwpzKKIJcmsiyW+dcbwoa+ui9q/2N9zfL4mQbk9tnYShc3z7TLTfXcD5wCEzmeTXKI1Uo\n", - "FAqFQqGwTBRFTKFQKBQKhcIEFEVMoVAoFAqFwkuMFYuR2rZtWy8rAU+VKWLOPffciBi9h25TSmmD\n", - "UvWUn+ddqDOCOFFSIh7KBxdmdPYT10MRs27dul42Fe9ioeWAZoG2HY/AvaBOoFw9IM7BadKf/OQn\n", - "I+KFUvjEpfCu3+m8UKdQwp9YEGIkeP/M9ddee21EjGhZ+B6ZHWvwqU99qivh73fVLotACX+PkVP3\n", - "0Sc0DtAVOCaiLQSKDqF8cGq8C+khi+lnTMvCvaA3QT9ut23D9BOeH44JhMYD6hTG3e/zAbJAhbBp\n", - "06ZODscw0DY6p2107jFDjx5TjyX/Z41ec8013bXEFzi+5LrrrouIkc753jExXqOsC8dGOf39r/7q\n", - "r7o1x2fowfFU6IX17FIdTn+HroL2vW7a2Bj2IveTMXIcHzr88Ic/HBHRizVjn6EvXAdFDO2xtp9/\n", - "/vnunuwVXkMAvTB30TnzHH05A5N2oJ6BDod2tmzZ0qP8QhboSrJ4NPrLGLH/EweILOiTe0JBgl4i\n", - "RnGKxAZyLeP5wQ9+MCJG693xePT/Ix/5SES8QPkS0c8cM5D9kksu6caCtdeWjmllQS9Zlh6yMEas\n", - "f2KpnMLfUhChE++xbpu5y97lthgrxgDZeY76ecFc3rt3b/csom3kRoeMkfcur3/A+Jsihmed4zh3\n", - "7tzZrVPk5lr0gdyOkft/RRHz2GOPxa//+q/H6aefHq9+9as7QX/yk5/EOeecE6ecckr89m//9tjE\n", - "uOGGG+Lkk0+OU089Nf7t3/7tgDcvFAqFQqFQ+N+MA3qkZmdn45Zbbokzzzwzdu7cGa997WvjnHPO\n", - "iTvvvDPOOeecuOyyy+Iv//Iv48Ybb4wbb7wx7r777vjHf/zHuPvuu+OJJ56I3/qt34p77713sIDW\n", - "/v37eyfGoRocyBExOnnOzs72rDrgE6WtHZ/yOdVyksYayKgkWuvC/bJl7boYfr9q2fne1BJZ7Z7F\n", - "xcVe9kiWbcLnzpDK6ArsechoYIaQFeb095bNBJnGpDozrZzozNadf+uMKsbKdVCA6xS1GSSZR873\n", - "or8uPOcsR9dy8fxp74c87RppwVyyF9i1jYAzRSeFUu7ataune9cuA4yBvWNZnST6wrzgPkNFcz0G\n", - "Hv8sg5Df8T3rw2PkdWEanzbLLys4mq1n95+9yfcEjBFj29a+yvbWrKaT23ZmmQubeh1Z9v3793dt\n", - "ZGsO2PtnWfD+IGtGig4YA2cutt9ln5uc2x485qD324z25/nnn+8VkkRXWV045g16yfZo5qYzKe35\n", - "buG9xW9iDM8PE1EDk8I7u7u93pRQkwqP0n/Ww6R90Zm5YGZmJt2jTfGEbC9JHakjjzwyzjzzzIh4\n", - "wQ33qle9Kp544on44he/GO94xzsiIuId73hH/NM//VNERHzhC1+It771rTE7OxvHH398vOIVr+g4\n", - "iAqFQqFQKBT+/4YXHSP18MMPx7e+9a143eteF08//XRXOfyII47o6uM8+eST8frXv777zdatW7sq\n", - "3cbatWt7Fib/9+nYsTQLCwspkSmnW96NU1uFOlGZNWhrkZO1ZWnpGmz5ZDVKXIMjq5fj98+O87Cn\n", - "ZseOHT1rhdO4rTGsAF7Dog+svawSNid1/qLfVu++ty1LW6DIknls7AWgfcYmI7Fsv7MllXkwHQPk\n", - "elPZ+EPjwDzZsmVLj2aBd/605UrEWS0WrKFJljd45plnesTW9oYw99A93zP+Q9Z7xPiai+h7BcDj\n", - "jz/e8yzYYnabXO+2s/gNZCd+cahqMm23RKXt5x5/e1oZE9eIA8T9OD7S92mvsecsi08jxoX1z5gi\n", - "Q0adZC/a6tWre3J7TvGbLGaG+c1853rG1B4JYlF5Lhx88MFp5WnqxnksaNufZ4TDQ8wG7pOJa90G\n", - "NftM0sw+Z53TF8ekIrvXdBvPa0+U1wVtueaXK38D9iqev8wXe3pauKp+RsuU/T/z7MII4jp2zItW\n", - "LzA2UE2e75B7ktfQzxfPRfTseTE/P9/bt6CGQsf28r7YOlIv6iC1c+fOePOb3xy33nprj6l5amrq\n", - "gK97su+++tWvdgo44ogjOiqKQqFQKBQKhZXE008/ywDnigAAIABJREFU3QvgzzDxIDU/Px9vfvOb\n", - "4+1vf3v8/u//fkS8cPDZvn17HHnkkfHUU0912RRHH310d8KPeMFKpeqqcfbZZ3fWwdzcXMzNzXUn\n", - "SJ92fXqempoarGrc/pbvsV6zGCnHADhOyWgzjZCHe2WkxQCLIntH7jgtvxP2SX3jxo0979bQe/G2\n", - "P/b2YNUNVapuP7dF1x6QudbWvSvXWxZgi93X2zuEXlx9uf3MHoJML64ePsmCpT2TIc/MzKRV8+1R\n", - "zOISGBu8Hs6osteozVxlHLPK07aCPR+yOCZkt+fO8+Wggw7q5i9/s6xD4CrI2fr35xnpcSun5ePz\n", - "rAoy1ztOw/ewx5O/rM1Wdq9n6y7zpHAdWb6Z18iVwFuPVxbT5j0ki0tinni/oE9DpNURI4/33r17\n", - "U8JXvBTmQxwioY4YrQfWnLkWM89OxMjrOcTI0LbJbxyf6vli75jvPRTHRn8cA5XF6zjDPIt7tAzs\n", - "AYxZO1+85/JdthdxL68L/u8xsufuQJ/DqoA+kM0efMueZQ5n54Us7ndIPr9NmZ2djU2bNsUrX/nK\n", - "iIj49re/Pdg/cMB3BktLS/HOd74zTjvttLHU/De96U1x1113RUTEXXfd1R2w3vSmN8U//MM/xNzc\n", - "XDz00ENx3333xdlnn31AAQqFQqFQKBT+t+KAHqmvfOUr8Xd/93dxxhlnxFlnnRURL5Q3uOKKK+It\n", - "b3lL3HHHHXH88cfH5z//+YiIOO200+Itb3lLnHbaaTEzMxN/8zd/k77am56e7k635s3zidTvcaem\n", - "pnqxCYCTsuORbIm4bX5na8FWYyuD4xCybDRnTGUxLxnfld/bg9ZC8SncFoNjR8wl6H5mfFaOsWiR\n", - "eaR8revHHKgmz1C/HTs25B1z21lcmjPosDgnZavxuzYewXJyb8/zSXDcxaQYqdnZ2Z4VmsUZOcYl\n", - "yzbKMk0zPqw25tFezMzCdLZZlrVry9w1n9q56xgw17ayVY8+Ml1nni17/sxF2cppr57jq7J+Mrfs\n", - "BQPWV+uF9fjY4zApCzfzDmd7mD2We/fuTb1A9t4xfubrA461cl0mw/vJkPwgi5k0T6LhtZ7ti2vW\n", - "rOmNf/Y2xfOZ77NMOe9xxAW7zl57TRa/6rZ5Fjn+1fygwB4u9DAUY+Q6YHgu+TzLdgXInnnqnFna\n", - "jrH7aY8r8DNqEg54kHrDG96QNvSlL31p8PP3v//98f73v/9F3bxQKBQKhULhfzOKa69QKBQKhUJh\n", - "Aoprr1AoFAqFQuElxopx7V100UWdZ4qSCm0dlIiI66+/PiIizjvvvIgYj/L3u01zirkSq2OB4GWC\n", - "98eZD2Sf8B6X6+HmmZ2d7ep9EJdBDQ14eVrOp4h+rAz9h9/sggsuGPuc069jgqDq2bZtW6czV2Km\n", - "P3AKwZ1G/9G5M+ssO5+7xgfxDJ/85Ce7RATXPfJrYcYIDjJXk3UsmfnQHO8Gt9jq1as7Liy40Fxx\n", - "2pWZ0SF6oT/EGTi+A54oc9Dx/dzcXDde6Bwdupqw47CQhbno2Afzm8FZx/WLi4tjnFYRo7lz6623\n", - "RsSIr4rYB8adcTXXGuvI8QrIzvXM3SuvvLJX58sxIS3/WNs2ay6bi4wp+nIWT8sTxrWOT3Lb8BXS\n", - "T2epOhYK/kTG3zVt2vpa7BWeK1mdHHT43ve+d+xzrmcPYn+57bbbxmRn7NHjnj17un4yV972treN\n", - "3Zvv+Q0y3n777RHRn4uOrWGskcX7y+bNm3sZvvD3wSnHXPV6YKyYi+9617vGZHStNH73mc98JiJG\n", - "626onhb9Zj2jc9f8cryW+8lYuAaS59ef/dmf9TLBPcfgZvV8QS+OMaRtc/Oxp5uD7pZbbum4EL0v\n", - "cg/LjSx8bk5X7skYsae7r9xv586dPS5E9v8tW7ZExGg+mCcS2R0b54x777uuv7awsNDJg9wf+MAH\n", - "xtpiPSAL5wD4MDOUR6pQKBQKhUJhmVgxj9Tq1at7XDlZlpfrpSwsLKQVlm1x0aYzhNw27ZmjLavd\n", - "0RYizTjlnF0Askq9rpdji9uytHpwhkKWjeIqyCDTub1itNv2KRuLSeF35qvL9JJl8w15vpw95X5n\n", - "dWGAMyd9vTPMWmsx4060foZ02Mpujq2Mo43rd+/e3Vs7GedcJkOmc9f6yTA/P9/LBMuyDbH68OR6\n", - "H8jqq6Fzcy4OVTa3pyirJ0a/3HZW8T+rUzWkR69j1xHyfHF9qUnVp52p2WYeZ0lCrnuVjZWzHifV\n", - "yLO+9+zZk9a/ok3XG8v2EX6fyWxZaLflImWteE/yenFNwCzjEK+P34wMZRyznp1Z7X5mnrasdpsZ\n", - "NVwrcWj9ec9xtiXIPPrZGHnOkok3lBXoLE1+w76Q6cXP8KwCuvva7n1ZfDY6n8RBm6E8UoVCoVAo\n", - "FArLxIp5pGZmZnqnWNesAD7BtrUsXM/DtSUmMW47bonTL1WFfeptubjMy5OxVnNv10/JKvLaInG1\n", - "dsvefpdZUryHzngNbb24BpDj19oxsufF/fHn1pO5CG3l2YtC5V9kaOeAdUvbrqMFsOoYG88bX+8a\n", - "SW3Nl6zKvj2umZVj1nZ7omxNcf3GjRu7a7K6KHxvDsUXm0HL+LuGE2j71DIQtHIaWeVmzxd7ZB2L\n", - "1fa59Ua012SVzR1j6LgLeyxd6dlj3HqCkMUeNPcLOF7N897wXG+rVGfeUWRxnSBTf7nf9thn3udW\n", - "f1kVdO+b3Is2YaMA1oe9TPYa8v2ePXt68YbuF7/le3vJM08d7aJH15Vr+4pu8GJla455zNq0hz7b\n", - "//kd96Ev7Zq03OY7zZgtHDuY8ad6XdijeaB9hjgknlHZWwCPYfZ2JfOiTU9Pp551e+aYs1mtst7v\n", - "X9RVhUKhUCgUCoUeVswjBb9eRJ9TLouF4bS/b9++iRWc/Y4z8wI5JsrZBvZItezvtjR8MnZlc8ex\n", - "+JTumAJ7brL39W1b9Ns69Ht6fptVk7ZFby9J+07dcSmTqsF6LGwtZeNvXjhnZrX9smXUVlxuYSvP\n", - "fH6ZN8XVh1evXj2Rl81ZSR5/e30m6RUZ165d25uLniv2Apgh3W3bS4Bsng+Wpe1vxilnr6nHwB4p\n", - "Z0i50nWr9yyuxB4EYE411lzGWcg6sh6GYskc+5XFTLqfrqqcWd6OjQGLi4sT40yyuQoYT/pniz3z\n", - "rrWyZ94L+mmvt2Na2v5E5ByM7v8QNyXjYo8EsnhvtgceOMOQ+cDvPZcj+hlvIIvvpQ3fO/OmZrG1\n", - "Q7yPjqfLPO/2zPK949QAMVGeu97zIvreK+9vHiO8Z/bsM0c9X+z5a72LnrdZPCqfv9gym+WRKhQK\n", - "hUKhUFgmVswj1Z6uHc+SXdvGZWSWsT0FIGNzt8VlDrrMCmzjEDKOQMcumGMpy9qzhYGMQxkX9rhZ\n", - "BmDLAAZ2YA4lx/PYarQcEZNjYowsG8lWgL0p9o61Y+q2svlhMFb2aGbxOvY2zczM9HTPNc6myeK1\n", - "QFYDKYs1a+vlOFbOsthTk3mBAe1m3hWwtLTU0102Zxzz1HLEtb8DthazjLy2LXvFsng9/p/xdRlZ\n", - "RtnQmnZMF8h0znXofFJ8J/C8GpKduWarPpNlSLft50Pj38o4OzubrrWsJpW9IMDxOY5Py+I7W09t\n", - "xiln+b0u3E+vTXuk/Lxo43I8RywL13lfcNwfcGYd7eF1bT1g9kTbO2pvmWu1Zc9J4DV8oH2Fz1wP\n", - "yny3wOPv/SPjoB16HmXZhn5+Zp63DOWRKhQKhUKhUFgmimuvUCgUCoVCYQKKa69QKBQKhULhJcaK\n", - "xUhdc801XQac3/Gb9+s973lPRIy/53ekP5xi5p9yhg+A9wtOIb9/t9fMvG9TU1O92CV+gyy07dgO\n", - "xwDAtQbvj+MQHPfScgo5W8bxAvB4mffP8UYtL1NExOWXXz52vbOawM0339zxm2Wg34wnegHUsHEs\n", - "ANxcXO/aRW1MDv00/5T7Z347rieugPF31qe5HF1/ZnFxsRs3+KrOP//8sf5lcVjwfn3wgx+MiH5M\n", - "lbPcaL/lQ3OcALLA48W85TpfzxzjetacM2y8Vpnr27Zt69Vkc9wE/bz00kvHPqdtxoD5AtdWyynY\n", - "Xu84tZtvvrnHneeYDvMhMv6W1bEecO3RPu2xz7QZpxmnoOOTADxu5557bkT0a7U5Nor2r7rqqojo\n", - "xxi1axQdMv6MkdeFxzPbL5wF+bGPfSwiRvtFy8VGP+kHbTO3HLdkWeA3Mx+mx5TfweWGLNPT02lm\n", - "G+sfHldnBnuNonOvi2zfZa5feOGF3XzNsljRodeFY3DpL/PF88v1pNDXLbfc0o2n9y2vIdY/e5fj\n", - "1tzPO++8s+tnKyMZ9u26gzsTuT2OHl90bv5Mr2Xvi6xp67mNMXPbjreyXuByzVAeqUKhUCgUCoVl\n", - "YkWz9jgV22vkzAcqn7ZZcPzb2TbOBHG2QQZXH/ZpF7SnZ7dprxf/z7KzbGlm1XSBPTKLi4tpPZAs\n", - "q8b6yTIlXG/nQHxYWUYUsGVA23hB+AvXkkGtF1cpHsqUIoumrWs0JEMmo/VmvZhDqvUaeDyR28zi\n", - "zgwCztKzN8ig3Z07d3ZrxlV9AdWikZGszSwj9JlnnomIfj0leybAnj17etk4nq+AtljXWSYdcEaU\n", - "eTBb2bP+8JuMI8/rwlWigTPohmo4+d/OpstqMXkt2kNvuLJ3m3nr3/z4xz8eu5YxytrO9OEsSIAH\n", - "gnb37duXVs+flEFpvXjcnbHtsW7fXNBfV0MHWXars1XBT37yk7H/b9q0KSKG52LEeMV47w9ZxXfP\n", - "yWzvYv0wB51p1uoXubNK754H9m5N4trLuPXMANG24VplwGPC/82LmV2fZVq29wY8i/gN88NvDyZh\n", - "xQ5SU1NTPdJNCm9lD5j2lYfLFIDsQcLAesKwAXgSZ4cCFsbu3bt7BLZDfRz6fyaLJ0zm2m9ld1Gy\n", - "7EBA+X27ujNCYO7pYqNDD/fM5ZrhkEMOiYjRQcNFMA3mg9N60U9LEcJhxfQcWTHEbMPMrme+IUtL\n", - "ueOHLnK1B562PxmljF+/ZTQOhx56aES8MBZsZNmmyzxHH+g+m1v0hf7Z0PC627JlSyeDdZ6RELs4\n", - "ZCZLRubqh3zbtl/RZtQmbtuHdPfTDwYOC3412H6WvYry3Nq6dWtEjB56k1KwPV8831ogF+POes5o\n", - "VjhoM2dd/DR7wNDnww47rPdKCrCHZqVGhkoItHAZmSylvX3GZHQ1UIFZL1k5GQ5OjDvXu8AtWLdu\n", - "Xe+1WEY/5DnKms3KH6BHQmQYK8/99lpT4GTlUtAT48newzzwXoQeMdj4a+OwbdNrya+dgQ0zxiDT\n", - "uV+lt892X/vyl788IiKeeuqpiOiPqw/eGerVXqFQKBQKhcIysWIeqSeffLKzFmwVZkTBrZXMaTMr\n", - "JOnTfVaQLaNt8V/QBsjaDZy92rNl6RM5wCPj4nlgiOSUE7M9BllhTvrvflsWTv18biuwle1AhQCH\n", - "wHhixdizYD36daWDdvGERPTpATICbIDl5FcWmccTmZm76KUl4QZHHXXUmEwZeS144IEHxmTGu5YV\n", - "n6X/GzZsSF8Tg8MPP3xMBuvYMuHBdAG/LGB206ZNPS8m8LzFgrYlOun1K3PyQAU/22Dn9t5ZsV+/\n", - "XrRHyr+zF+1AHmx75Px6LKO3csAz8D0effTRMZmw3Pfv399r+4gjjoiIfgHJ7NWePfWMWYZHHnlk\n", - "rL2NGzemlB/2yE0qKIoMmcfNY/Tkk092/zYZs/XicAI/N3z9YYcdFhF9b8hQoH/EC69Uh/bMiL5O\n", - "2cfQoZ9J2R7dvk6NGJ7rBx988Nh3TpCy3KZOcR88RuglK2Td6tGeyqzIMfCe5fVkWTIarCGPFDq0\n", - "N3TSmymjPFKFQqFQKBQKy8SKeaQi+gHhWYqlg9JXr149kfjXlBlZ6rGt/Ywqw2hPqsiQlarP6EYy\n", - "rxHgBJ5RCkxPT/feuztt3/eyRWK6FWA9HMizk3nv/L1/aws0C/DPSC6HaAgy4uNsbmUEyFngv+NS\n", - "Wusoo7YZillovwdZ6m0WdDoU3+CYBmBaBXtcMoLsbD69mCDMjPLCc886z2Ie7OEYIqK1J8FjciAP\n", - "c/t95j20Ryoj923hvSqTLYvrzGQHHsP9+/f3xtNxd9l+4Da9LrJx95psZcgoghyvk/XP8TrugzFU\n", - "wiab5+6PvYX+ns/xAnmP9lzfu3dv7xmTeV5dJsHIxshjNRTXk63fzOOSzZPsues+WMZWpiyQO9NL\n", - "tlc5BgpYxrYUiu9JbJzPCS82Sa2T8UVdVSgUCoVCoVDooShiCoVCoVAoFCagKGIKhUKhUCgUXmKs\n", - "WIzUtm3benUkeAdKjZ477rgjIkZl/HlvuXHjxl5tDcrPX3HFFRExOjk6/sKl8N/97ndHRL+ekrNa\n", - "PvOZz0TEOF2BaVPox2c/+9mIGJXN93tiZ865XD3fu84WuOaaayLihVL7WRE3+m36AfqZ1cuAlgG6\n", - "GsfWuH7SzTff3KM2AI6BgTaBtj02yELcATQOF1xwwZhenGkxPz/f9ZO2gYu48dcUQcjKX2RCFugn\n", - "6KvjEHbv3t3NZ+hEPvShD43pxfMb3UKdw3xxjIQzSm6//faIiHjf+97XtePMV2J3oOV473vfO9am\n", - "5w0xH1AhQOPgOesxov0rrrii52l2QUZTp5jeiLbJZmIdQfngeB3+T5zDxz/+8bj44osjIqcIAsxz\n", - "y+J+mq6C6x2H0cbBQVXBXMnqhpGlxdxiPInXQMdtZmjEaC9iv/DYt/LTNhQh6MO0TPTj6quvjoiI\n", - "K6+8sutP2zbzit8xd9lHQRsrQz/vuuuuMbknxb5AhYIegQva8n/mLs+LtWvX9mKZqLXE3KJtdGid\n", - "IwvzheeLx8T1ldiPLr744l6MF7pk3tJP06wYps7xGnW9PWT81Kc+1dv/syK/7NHsuY4hdewpcxG9\n", - "OAuQtbx27dqOlok91+vfz17mFvMFHWcxh9Ahcf0Q3RPjw3pmzTFP0AvzxOeFDOWRKhQKhUKhUFgm\n", - "VswjNTMz07MSOEk784Equ1hR69at61ltgFO+qS3s/QCcarG02krVETnx4dzcXHfaRhY8JcAZHvwd\n", - "qsjc3tO1nZDd9Xnm5+fH5Gl/6366Pgb1c9zfTBbGht+1cEYH8maVql3Dym1nVXNNw8Dv2utpwx6l\n", - "rHq2M+KoK8U8cvVhxprv2+rDWUYY94B2hTaY18DZfa6fklXxX1pa6saXqtj2wJg6h//TBnVmLDv9\n", - "BKZ+aK9HfjwQ/HUtH89F6EtcA8z9dJbmc889N9ZeK7ezDTPPlGu82dOQ1XqzN4S52K5pZxu6mnRW\n", - "L4e20Av38nzx/GD/mZqa6rXN2DBfTbY8KTvJ8ybLKGyJq+mvdWi6EpNVu5+mHrKnG30C+thm0mZ1\n", - "5UyYzLOI/tIW4HvmnOsYDq1RZOAvbWRZeM4czLLT/FzgL+uufR6hc1OD0T972O1FM7uIn4voF72w\n", - "19FXqva3bXAPV/z3s8uZka7Gb1kygvWhrD3qiCE3+z9ye+/KUB6pQqFQKBQKhWVixTxSzz33XHf6\n", - "48TN6S/jfeI02XqkfHrFsqYyMxYIp3Rfb+6orGYTePrppyMiYvv27V3bVHW1R8qVZzlJ+x22ZYeL\n", - "jt9RqdfVYufn53u1MjIdcsI2N9jRRx8dEX1LDQvGloz5jtq2JpE4A8dZAbjj7JGw1YgVgT7b69ER\n", - "90APyNvy8kWM3uEzrujxmGOOiYi+hUl7yMrcfO6553pzC48Jc4+2mC+uqoxuXVU4s6bxFu3YsaPr\n", - "N/20h8kekxNOOCEiRvqwt5O5icxegx7b+fn53rxGR9Y5emFuIVO2jugnc5j/D81F10uaxG9HxXd7\n", - "YJ999tmxzwF9ZKy5D2PZejDwKJkwlzVqDwM6RS/cGz3imQVUzufezJsnn3yyt7a4N23Qb8adMbEs\n", - "3jfpn+euPTfz8/MpL5tjYeA7Y55kBLr26ON9tjfFRMIRo3VuDzM6Y1xZc+jcY8SYMk+QDX14D2i9\n", - "xfZQez1ntQwneUf9loC13fbVnlT2/aziP+Npr445VwEy4Ini+hNPPDEixj076MrPKPrv9c9cNW/i\n", - "kEc6ou/xbe/j/iK3GQ6QwfM6Q3mkCoVCoVAoFJaJFfNIHXTQQZ0lwUmb059Pu1gBWJc7duzovFlZ\n", - "1VwsSiwNc3AZZgfPKtUi4zHHHNPxV2Vce/aa4fVAJls79IkTNhb4E088MShLRJ9nC1nM44SHgrY5\n", - "3eNpQCbA/2kfL9lQ1VxbWv5/loViSxP92cIw1xR6xXJvPXvIR9v+bcYpx/WMr/VlYMkyRvv27Uur\n", - "INOW2+S3vj6LEcqqtW/cuLHrB+NkD5O9o/TXnjjfkz65AvCQNemsSqxQy8Ln/LWH0evIHjlk5/ft\n", - "mDrbzpWZPX/xuHAPx2t6/PGa8bnjPNp1RL/wAqH7LIuPuYenyXFM9mCwL8K512ZI+Vr6z1jcf//9\n", - "EfGCZz2ivy86Vox9gna9d9mLOjc314uFBOZ99Nr0fPFYOLbK6wJPxdTUVPcb+mfvqKulM0b0lz0G\n", - "0H97/vFoeF38/Oc/7z3PuIf3c9pkDtr767noeWVPXPsM4Dt7zhzrCZhbwOwS9uwBe0/Z89oxNS8h\n", - "a8fjCvByOUbSXnPg2MS2orzHgv6wb7KPOk51EsojVSgUCoVCobBMrKhHytlefg8LXMtibm6usyDs\n", - "kbL3itMop1afSDmp+7SbcQpx4m6zlIAtTCwje7cyziWsA07qnOKHYoEiXrAunCGXeVD8fpl7Z4zh\n", - "fo/tWk8tMus/g61adI5VZ2sXy4o+eIzaMeXfziLJvGNYIK4FxlhkHk/XnVm7dm3Pw4TV5loz6Nyy\n", - "OGvNVl+WcTo9Pd3Jja4si7NY8cTQP2enZLGD/N56mZmZ6XHrYVnawmTNOZMOr0bGh+Z1MMQ16D3F\n", - "PGdes+jc+4Pj8oBr9rRZar7eWWaTGB2cYejaPc4Qo/9c32aQZhlhjmOj36wD4H6hN2TxPsB6afs4\n", - "Kd7U12XcjBn/GfuBPV6t1zTzoAHz2w3V5Grh2n7Wg9fswsJCL6Mx431FFuaYn4uZHrmeuTzkwXLN\n", - "rizeFFhfzK3sOWqPFvdjzrZz17LQJntX9vywp8kyAfMEtnuX16CfIcwddGfvaIbySBUKhUKhUCgs\n", - "E8W1VygUCoVCoTABxbVXKBQKhUKh8BJjxWKkLrvssu5dJu9P/c4YPpxt27ZFxHiWh983w8sDL1dW\n", - "HZXfwRFmriV+RywB78TNWbd69eouDsXxWMj9nve8JyL6cUjEo5hrDY4o2iOTwJkncApdcskl3Xt1\n", - "Z+u5bfTiGht+vwxPGDxOjmNyHNunP/3puOqqqwb7CfgNOkcvjnFAdmSCUwo+JOLfaO/II4/s+v7h\n", - "D394TG7670rX/IX3Cdkdf+EsJ8YfDipA5ub+/fu7OWNeNvrJHGS+cy84BeEJ5Hv04VpYcPnBKdVW\n", - "smZ+00/zODK3yKqhf2SMwp117rnnRsRo3JlfzEmALNu2bevFVbUVpiMiPvrRj0bEiPcPWR0TaK41\n", - "1r9jhxijdq7DV4bOnPnEb9E53HxmRGBv8tzleuA9a/369R0v1+WXXz4mg7POzONoHj9nHXmvQ4/m\n", - "bty/f3+3xyALXGjMLWJjXNGbvcV6dB0i74tc38bGoBuuZT2z/q1Dx+NxPTpn7OibY0rbfTHiBX23\n", - "MYytLMxF84Q6W9l7OnORWChiZsl+JcvvzjvvjIgXeOXcNmuJNrxfeL93tidzketdnZ72+f3HPvax\n", - "jguRtpxBjC5ZFzwvmB+MEf9HL8hiPkxzcm7YsKF7tjD+lpffMOe8dzkWzNl+jL/bb2NqWd/0Ew5K\n", - "1pYzg83NmqE8UoVCoVAoFArLxIp5pCIiHnrooYgYWUlYGs4gIJvr5JNPjogXarlQJ8oVeTn1Y3Gb\n", - "vyirssvp9ZFHHomI0QmVqrsAS+6ZZ57p5OIU68wFZMGTgPVi3iKAbHhaOA1nWX5tVgbeIDwL5qsy\n", - "izv9dWV0kNWJGeLksvWRZUwB39v8cK5syzxBL69+9avHfv/UU0/12jY3GPD4ZzVp7MEAjB31hMBQ\n", - "vRFXAaYeClaR+0m9MNe8aTnUWrSZg85K9Fxhnbzyla+MiJEHAks6y8I56aSTImJkyaJXZAVLS0u9\n", - "jDnG3bphTBh3Z205s841bJDBWTntPfmNudHsgUUvrGtXhDf7APOEtWx+vPZ6ZyNh9Wc16pyt5bVs\n", - "T69rZnHvlt8NIMMZZ5wREaN58qMf/WisH4DxdnYv/fZ8Qc/tWLm+EeBe6Nye/awukNkqmD+umcfn\n", - "bX012vYe7fUyxFvYgjlHxW7ude+99w72dfv27T0PLTJ5j/Y+yDOM3/ktiz00fkvTZpxxz1NPPTUi\n", - "RvOeemLO8s147+wNBuaP5d6McbtG+c7P6KziuzOxvUdnGYeWddWqVb1nEW2zJ5mLMqs7aZRHqlAo\n", - "FAqFQmGZWDGP1LPPPturweHq4uA1r3lNRIy8AM8880znhXCMAqdQn4TNRwQ4QXMyx9I+/fTTI6Jf\n", - "CbflrHOVV592qeBrywMLyt4S4m04BcOxR/u2pjZv3tx58fDaIEN2qrc16NgnQN+wkvjdUF0WM4o7\n", - "1sFeLPRBm1RXPv744yOiP/5nnXVWRIz0iUx4JbH02344xsGVmoEtd9c8srWDZce921ooGXci11K7\n", - "6RWveMUBZeF3rrbt8W/jvuwN9Lr4zd/8zTEZvvKVr0TEyONqneP9xcJG5z/84Q/HZAKLi4vdfEZH\n", - "zDGvPeYW/eF36MO1eJANS9bMAK3XwJ5Xfut6SACrmHXumBDPB7yiyG6+wFYWW86sE+Q2X5357eiv\n", - "vV8AWdlH25g0r+c3vvGNETHS7ec///mx33qfc5ye2Se8dzvGZPXq1elcpD+OdeEeHn8qvbPX4dlF\n", - "T+4r86ittm9vBqAftMVexdi0e0vESI9c/+Uvfzki+tX8wfz8fDfHeH5lbyT4P+sfPrysyn5Wlwp9\n", - "tGv0da97XUSMvJzIzT2Z15aFOetnXcaTh4cpxCPxAAAgAElEQVQbPbLXD3lq2SdcP877ovdw103z\n", - "vui4Xv6/efPm3rPIdQMZ96zuWIbySBUKhUKhUCgsEyvmkTrssMO698yc5jPeJ6wi4peefvrpQbb1\n", - "iNFJGauFNrFqbL1w8uak+ou/+IsR0a/0CzgtH3rooZ3cWCe2djjl4pHg3lh/9gJguWNJ0MesmvTa\n", - "tWvjwQcfjIiRjmD+tqfF1jB6M+s1oE/A74xby/v/9vROPx577LExWfA42duBLHjdsMyGPJj0AyvQ\n", - "MmYVv23dOA4HYHEhE/NkaWmppwcsKPrJfMeqs7XLvdvq+REji81jxBisXbs2rQYOHn/88YgYeaLQ\n", - "NX893nfffffY5+aqcyzIzMxMLxbE8TWA/pMBaNntBXJlc9Zg5k2NGO0DzjL1mmPM8Cy5irSv5/uH\n", - "H344IkbzxLE4rdwZD6LnC5/TL+vH8Tr83mt+x44dPZ3g3f7Xf/3Xsbb4reGYUsdMZZyVbTyX5xRg\n", - "Pjsmkv54PjB2jBHcgplHAiwuLnY6YQ56XdiTyHrIah0SW/Qv//IvY/fGy+wxPeSQQzqvLzrLPGno\n", - "jvXPOmDPcpVtx33RF8dmRkR85zvfiYiIb37zmxEx0kP2FoC2XfkdmexNdQVzvGlDYLzpl71eHiNn\n", - "1OL1Y53YO+Zs12x+tPc216IrnE9CeaQKhUKhUCgUlokV80hNT093p1vXeMosVE6HBx98cJoR5uwL\n", - "PBN8bq8OJ28sKlvTPpG2sTa2tLOMME7vzpCz1eOsHp+0fb+f/vSnnW6wAMx75366fsxQFl4ru78f\n", - "ytrwGEzi2jOIHXDmB2AMsBZsHbf3c00qLA2sGfen5eVqZQC+nuuIKWhr/ng8neHFXGRu2oNpa4h+\n", - "Of7JsqxatarHGWdrF48UsiC/YyEsu72njjkBa9as6a611yIbz7YunPvTwvFOtOe/rXzmhqQNx7yh\n", - "a2S37r3m7DXCi2AuuvZax0SZ7xJgqbMHedw9RrSLF4Drd+/e3ds7yM6jn4y/66YBdO1abxlPpHkT\n", - "20y6LIbJXo+h8YwYeXDwSHnteR2xl69atar3jHEsmPkwXUfQ6//73//+2P/Jas0yVDds2NB95kxg\n", - "x7Eit2vB8dfXe7/kr8c+IuKee+6JiFH/2YuGro3oe42o4Ye+hrKUI0brIeP/i+iPlz3Mbtt7ENdl\n", - "5wV7pPjd3r17e9d6z/G9X+zblvJIFQqFQqFQKCwTxbVXKBQKhUKhMAHFtVcoFAqFQqHwEmPFYqT+\n", - "4i/+oueZ4v0771nh8YJTiPeXzz//fJcBxTtYOKW4lnf1xB25OjBca/C4tXw8EaNsP95bw4d15ZVX\n", - "RsQLmTG0TdwJ72KRhbZ5L8s7fjJDuCfcWfA+mScO8Dk8URdffHEvZsnVnuGrgmsJWXn3TUYh/YSv\n", - "CA4iw5x0n/jEJzqdt/VbWlmQEa4l83g564T4CnMn0R51VlpuNsaTa82Z5po16JzrneXFX2RjLiI7\n", - "Y0cswWOPPdbNyeuvvz4iXpjjrSzEXTgDDt4nz0XgOD3mItfv3Lmzk5M5iY5uuOGGiBitC8cIcS/+\n", - "wikF76MzR5GFv7fffntEvMC15bgiVwumn/D4IQvxGm6bfjIXPfe4jvV03XXXdXIzFx0Tw29YF4wn\n", - "stOWY6vglPO6YE4S57dnz55ubjH+jAUZsq5VRT/hzmNtsibJEDz22GMjYpzfsNVLG2vEXPO+ZT04\n", - "po69BW4+ZHStOGJlzM3JmO7du7cXf4VekNv7BX+RnfXPPGcNo2vHQXqub9iwoVc1nXuaa49ni+uQ\n", - "MQY33nhjRIx432jHY8ucbzkLHfPqeBz0Aqcg64W4JPpAFqf3izZ2OGJUC/GYY46JiIirr766p3N0\n", - "lq1/5jnjzhi6/iDzC15JZPZ1mzZt6sYHnXufcDwrsphrEbD3kkmJzuEsdZ21paWl7t/weCJ3G1/Y\n", - "ykZtR9ZchhU7SM3Pz3eKI3jw29/+dkTkKccoZvv27V3gHR012EB/8IMfRMRo8Tkt3gGA3tRdNLNN\n", - "MWXCOpgcMGlZGAR8MjmPO+64wX7Sfw5eTs0FbeCcg6Z9CPP/X//610dExBe+8IWI6AfVOTibPlqm\n", - "Fl6U3NPXmtgSOOAXZPQ+Jt6MGI0nmw/zhGB8DsiAfjMXGSvKSrg4oBcnhVvvu+++tDisdZtRoTid\n", - "15QJGRn0rl27ujXEQZngcl/rAFUH/BoZGfLQOnJyRRaw7ZITpgqxLMwLNulTTjklIoYpQtC1S4+8\n", - "6lWvGpMfuP8uiumDp9OlkYGU7Nb177Ru+s3ByDRD6OuBBx6IiFERRQ7o9AUgK+3zMF+3bl1Pbq9F\n", - "P/BMjWPDEpi8GPgB3e6P3ucA/WEeYOxmNF701wcHSpIYMzMznU4ZJ3QJfKh1ur+LyToY2foYosOi\n", - "X+jS6fyGDUWKRXv/R0a+f+tb3xoRo2dWW37CAemUw8gof1xg1VRsXqPMK+5JH7hPW4KA/qMr+snB\n", - "yM8FEyYzluwLlt2FPdsxnHS22Lp1a0REfPe7342I/vM/Q73aKxQKhUKhUFgmVswjtX79+s47wCnQ\n", - "ZL0Aq4kT+T333NP9lhM1cCl73MScRH2q5wTNKfa1r31tRIys6CFyVtr5+te/HhEj6/y0004bu5YT\n", - "N14zv2YybP1h5bg8BJifn+9O5egjo6XBYqCo6R/8wR9ERMSZZ54ZEX1rFyuA0zx94/N2jJALedF5\n", - "VubBXgF7GlzszSS4LS2LgQXFXzwzGYEq446X4Oyzz46I0Vx0uiztQlFEQbutW7f2CkkiN3PMJQRs\n", - "1aNT7olemD+eu+hx06ZN3T2Q3x4p2sZ6R+6sUKWJpfG4mCC1BZamaVToB3BBUntDTLPBPdE9axPv\n", - "Ap7eiD6xLZQY3MuWNNfRX6eY2wtoQm5kGeoL16Bz5p6L4wJT3rDWKJqJJQ7QI/MCj/5zzz3X24tc\n", - "agJZ8OZ5v6Cf3IPv2Q8yWbjPQQcd1PP+Ar/ys2xZuQRebbkEg71vLT0UnmjWR1bOBqAX5hFkxJaF\n", - "39FvE3aDqampXrq+S2cA5gWysjejx8xrRJ+Yg7xt+I//+I8wXHqDtWUd2luMR8oFrNt+tjLyO/62\n", - "Y+q5wvMfGez1Y83yrGev5pnlfdF7Fr978skne3sNOqQtqLEosOq3DBnKI1UoFAqFQqGwTKyYR2rV\n", - "qlXd6ZAiZ5wgbalxUudUe8IJJ3TWv707WAbEW2DN0YYtEE7eWPCmqfFJvbVIkR9Z3DaWAm06SNLW\n", - "kS00vE0uvAdWrVrV8/a4cB5At7yzxpuGDPamYFlgDaAfe4UiRrrCokQm/mbxWrTNdVmRN+6FJcN9\n", - "0EdL+8K19Je/9M8eBxOl3nfffRHRj5UD9J92mbvz8/MpkStWPJ4ax0AZjLu9qg6cbgNieafv+CNg\n", - "yhPTS5iuxp5Hy+rYkdWrV3f3wItLf23VueglXiP6l80DZMWrClovE3PRJNuZ5e1YOsYVb0FGy8Ea\n", - "Zk3zeevBtJfPcSfWKf8npoi5xVzMCt+iP/ajhx9+uKdDz3vkpn8ef8eMsW/QjsfUSRozMzOdN8Ky\n", - "oAd07SLCWQFX0zcdyFMf8YJnBy8WusmKPTJ+7NWsvayfjqllPlj2xcXFTl4XlrTO+RxCYbzG7jdg\n", - "HeGF/ud//ueIiDjnnHPGZIwYjSfjZ+Jo68XE8HjF6WfmHUMf7A/ovY1jtGcePfAbt+3kK5IukJ35\n", - "D+g3suNlXFxcHJOjvZaxId4MuTOaI6M8UoVCoVAoFArLxIpm7XEyNY2LwamR97SHHXbYICVD2wZ/\n", - "fZLO3r9DLEm2VlZuv00Dx3Js0/BbmC4Ba5j+ZHEpWFRYRQcqYIqVyql7iMKl/RwvAVa9s9x8PZaL\n", - "T/1DwHLkt/THY+R+Yw0ciIQ2Itdz+77eqcV4FkzTALDq7IHiXtYj7XM95Nhr1qxJsw2xbuxZzWI7\n", - "uA5LFL14jNpUbeav47GAvXn0y5Yq8O8Zf6fat3Bmp8m6Da8HYD16vPGm0Nf2esbPGbAZ2S79ZqyQ\n", - "nf9bLybvRh9DcW/MNfrpFPJsL2Lc8dhgsTuD1OuL77ds2dKL7UOHyMC9M6+h9xGvmyyzjvvMzc11\n", - "/fQ8dxwjY8Y4ZrFjlpnrM+qkXbt2dd5c9gGvIXTo/hDXZy9w5kV3TCGYn5/vZd+2tFItkIFMYOKz\n", - "2Gu8F6Fz5gl6IX5zqHik4/Uycm6A1x/PHmORzRfGnLVpOq+I0biZGiojIWYusydPoqkBtM/e5bXc\n", - "9oeYOPZzZ8ROQnmkCoVCoVAoFJaJoogpFAqFQqFQmICiiCkUCoVCoVB4ibFiMVIXXXRR+h4Sj9Wt\n", - "t94aESPqBK6bnp7ufssJEaoCKD8ch8L7Zd5lU5YfOgFX8n700UcjYvQO9W//9m/Hrl9aWure1fI+\n", - "nd9Cm+HS9s5KoT+miHGdFN4d0xdK51900UVdv3wtbUMnAEUA8Qiu2YHslPznekDchuMYbr755k4n\n", - "IIsXYIzQi2vyuJ5M28/2Ot7r05eZmZkenYAtB9ei4nrmlr+nbV8P7Qfft9V4uZZ5a7ldZ4t39lyf\n", - "0RWhc8bAtBz79+/v5qKz0KA2YW61WVVt28wXrjd1Tlb5HtqHbdu2dfPbsS/EmVjnrgfG9dzT/UQv\n", - "zu7j+ptuuqmjfEHX2RxjntO29yDHEnku8v1RRx0VEaPYk127dsVnP/vZsWuB43BMnWIqHMdt8vmn\n", - "P/3piOjTuLTxTF5D3kMZI+I3+S37BbKgN1cRZ6zvvPPOiP+nvXeN1bSs7rjX3nv2DDPIwQPnAQZn\n", - "QM6HlqAfahqr0DZpaBut0aRGLRZDqEo9lKChgoKAllBAqoDU0pgo6QdrD2Loh6YaquIB2gpVQAcY\n", - "h4OFjjJ7DnvPZp73w+R3P9fzu581m3e/w+y3uP7JZM9+9v1c97rWdbivte611j+GVDttxi4ycC3z\n", - "3DRLZGERU8ccvvXWWyNiF/1Q2w5xOMie7eltvxxnhSzsc45nI8YHPUEp4rnoKv7ch3VBX1s4htT7\n", - "hTMDvZdBh8Vex/Xeu5DtU5/6VO9Z5JpW7X4eMdznHANIzBTfs16Qhb4xlsuWLevWHHRlvtaxUzxH\n", - "kcV7lfck9EhfPSZTU1Od3FxryifadtY+6yhDeaQKhUKhUCgUFokl80jt3LmzZ/VlGRQ+WW7btq1X\n", - "LRa0xJ0RQ0uKbJwsg8zkrGRMuBJqK78zOLLYL2fjZRmHrhPCaRgrYHcZBOa5yzwy/J3TPTI5O8Xf\n", - "Y4zM2fR84GwTE6AyhuZI8vdd24jf22wMZydlfGeWhf5hmboela/3z5mZmbQiu63djIMw80T5Xr5+\n", - "x44dve+48rDrqNkj5fHPiLMzK3kwGPQ8qVmdLK4bVyW//b77ac417wvj5HebWc2hhTKA3E5WR2gc\n", - "v5m9xZnHlnnM52RKUdvGsluPJnVuYc+cZcp4QvlJP82AYLRz0ntGJhOeN/Y574POuHR73kdbz7+9\n", - "ov4uOrN+mFuew56ryOwsUdB+3/tdtp+7Ppa9yG4Pmex1bdv3HPEaMuw1s2dqoTHg3s7Abdtw7cKM\n", - "ZYF7sz7wvnuv9/WWZTAYjF0bEf29FWTX9657XlcVCoVCoVAoFHpYUo+UrefMavBpcdu2bd2p1qdR\n", - "TrOutMqp3hWZ8ThRR8Lv0s3NRvuzs7O9Kq6W05YUsrquitvmOvqY1Z1atWpVT1fo1JYTsnKa53Sf\n", - "VZMFttTGYRzjeSu3rV33w9W1fb09Uo4JaGXPvJtZ//jcNarswQPMF4/R9u3be3VK2nfz7XezfmbV\n", - "9+35BK0eHfPmuehq6ng7qOScjaHnrq1ksGrVqu4eePGo++a27dVyxe/Ms5uNSbsHML8dl+aYkKyf\n", - "C81d1/air+aus1ztPVxPCDA/kBW+r3vvvXfkc4N22jjPrI5cVg3cY4QsfM58IXbU4z/Og5N5XFyz\n", - "jb3XfH5Z25m3HbQxqebj83giC2MCb1u2jjyPmG94Ij2/BoNBz9vtPRjwO9fZg+k92BXyHQ/cjoVj\n", - "hP15Vi+R/tI2uvb8Yf57vrAHtPf1mvN+ntW0s3cUb6C9yY53bmMw3XbLyxgxPIPYW7YQyiNVKBQK\n", - "hUKhsEgsmUeq5WKytZBZAe3p0XE2wKd5LG6sHHuDsLA4OXMi5YRuPqSWJwwrJLOU7ZHwe2cjq+js\n", - "bAywdevWnvXRZrK1oB/8nZO5ec9AVgF8XPXxrFJvxrVnay+LAQJ4ARzP5cy6VhaQ8ZNZRmczZfOL\n", - "WDvug2zPPfdcb67g5eIe/J3Ps3f5jkvIYl/aGMMsGwc4s8tteLyzmKIspmLz5s29uDTHuhiOFcnW\n", - "hWPHbKm3MrVZQu1PrFJbmtw78xZ5PpnjEyZ6uCjHWbLjqp5H9Oc7exBjgacmq/jP9xmr1sOfVf93\n", - "RXZ7HAHz3HOR/mWevXa+uAo8YIxYD/fff39EDPfqjPcxm8MGfV+1alUnlz2J7if9Qvf8vpD3C2R7\n", - "18TEROrt8fp3Jjpz0R4ZYC+qK4W3MvkZ5IxKr3/HjppdwXrg+cp1jCHPyPa5S9vIbU5G64uxQHb2\n", - "fc9lgIzOvBsXS+ksRMeZPd+al+WRKhQKhUKhUFgklswjNRgMeh6LjMfLGSaDwaCX8Qcy748tT+B7\n", - "c1LnnW8W99LGeGWZTJZxocw3c2ntjteM75u92lZKe23blvXhk7czjjjdj4tT4BpnwCyEcRbC7j63\n", - "l2ScJ8seOo//QjECjkfyfHE7zJPZ2dle27bSPdeeL5hnWVzKzp07e9lXHk9kwTpzfw1bjfb+WJZx\n", - "fIeO8TPsycwyBY2MHb6FPS327vq75tYzZx8wd59lafu6kIfacmdZec72BObibOeXPQxZDJg9DsDj\n", - "7vpxWfxXO58yD7xj4fhOxvtmnXuf8Zi2+yt6yLyjfBevCLKh83ExT+1Pzy+vp3YvzDjkgOO5nJ2W\n", - "ZVZ6Lo7LrMv2RcefWm4/u+hDxr3oLHh+trI7jnmh/dH7yO7WXPt3e+omJiZ6a8j9BllGYIbySBUK\n", - "hUKhUCgsEsW1VygUCoVCobAAimuvUCgUCoVCYQ9jyWKk3vve9/Z44syPBacQPD5tzBDvl4noN0ec\n", - "M4KcnUTbGTeX30tzPZxlc3Nz3d+c6QNfEW07JsLZR5/+9KcjYsj743o8gAyTlieMd75kHyAT3zVf\n", - "GVkU6I132NTm4Hpkcf0QwP1uvvnmuOSSSyKin1Xo+JNrrrlmbNuOQyPj46abbhqR3e2277vhQkLn\n", - "rpLs2iJwhMHjxfzgeq4jTsEcVM5i3GeffbrvMFe4Fji+ijbgN+N67unrGTP48NDjqlWrenEG9J+5\n", - "BY+fs274HllNjBE653rqI3l+wSt3wQUXdPFizpDatGnTiF7MhcV4MxeRCe409JLFOzJmn/nMZ7p+\n", - "ss6zGCDWEJyCzA/H7/C9T33qUxExnF/oj3vT54mJia6fH/nIR0bacKV79gXGEz481qjj1LgH8wXZ\n", - "GYs29oS59clPfjIi+ryPrD3HgsFBhs7NCOAMOq879Lds2bJuHOkvOmTeeoy4F/2kbdao90/muJ8X\n", - "tL98+fLuO5bb45/FApk/E1msN9as9XLeeef1snQd+8oaGqfD9h7ck34yph4bx45de+21HS8jewjr\n", - "mtha5jv7BevfMaRch+7Zo70vOgN95cqVPa499ous2j7zhf3COvczGg5KP4/a563H8/zzz4+IYQ0z\n", - "MmUZMzJpkT1DeaQKhUKhUCgUFokl80jNzc31eN+wSHfHKcd3s5oTrjVEm5zE28rDEX1ONmeS2BPT\n", - "ZrnZy2XPCt/l9O+Tt7M28Aohuyu4+pS/devWnnfGHjjg2k14AWxRAWQ49NBDR2R3vZC2jazCbJYZ\n", - "wT2wArIsL8bOdUPQd+uZcv/5LnKbUw6dMlZYMc5uA+aRw0t4wAEH9HTojEqqRfP5008/PfZ6e/I8\n", - "JwF62H///bt7oGssKWArzrWJ3DZekZ/97GcRMfQq4S0wryA6iBjOW68twOeMCXORz/k+YB7heXGN\n", - "tzYjy1a5M5gsC/1Bf/TB9XCAa9q5Zk87d50h5Zo13luYe/6JbF7TjIHHZHJyslfPCh26po6tdmC2\n", - "CWdaeR+lT+hj5cqVnS6cMef57cy3LGszk9lZXq13ybrLKlajF3uwLIvHEL1krByzs7Pd2nHF9oMO\n", - "Omjkd+YQ85zxzDLrXOPLHtoWjJffGiB3VjU/qybvTEzaRT/mh23HyDUMXdsqq0fon1mmpNduyzPo\n", - "fnJPnnNUtmesnm+F8/JIFQqFQqFQKCwSS+aReu6557rT3kIeKE7Yba0kVyIFtorh/MH6xzsEzDi9\n", - "UPXx9r2srXl/x7xWtnZsYWIV8ZNTPTLb4/Oyl72sV+XVsQAAWTmlcz3WAVYtgJHdngesiNab4lgH\n", - "xzJk9Y+A66fYI+EaX263tXb4Lh4VqiUzh7L6R64LZUvTsroO0/bt23tWG/3BwrTV63nPWPA5czm7\n", - "vuV5Q17GxXOl9Va012WeGvTl+YI+PF/22WefXoyLvwPGcSRGDOe5PQz2QLoGUjufshpt2Rpl/bzi\n", - "Fa+IiKFO6T8eR0DfXAF7XCYy401brsVk7wBwVWn65/pK9gq1cVrWIbLQhr0WWV0g9pGFane5xk87\n", - "P+zVQxa8puxz47ycEf29yvFI3uvQ6/z8fM8z6XlOW3zHbwuytwyA6x3XCJ577rlO1+Y1dQwsc9DP\n", - "LmTLPJKOGUP2VhYzfiBvts+xFltdRvSfUW7f3lR7Ktv/04Y9k9kbCa9tx+CB7Fk4LuPOb0XQvd/+\n", - "LITySBUKhUKhUCgsEkvmkVqxYkXvJDquCmpEvwrrxMREWgWZ0yvXEuOBZenTKxaHLQ9nEABOqjt2\n", - "7OjF4yxUeRZgDdjKy6yG3VUM96nc3jvD7/Jd0RlgPTkzhvf9tjIj+laqq20DvutsRqwY7gFcZRaZ\n", - "+L2NTXL8BV6dLEMQ68UxUrRpPWIl+v37YDDotU0/aJPvuL8ALxr6sh4yLwJzvL0mqzzN/OW7WKS+\n", - "HusY2HODHtq+2ovBT3t1zCGHzPY4AGSzB4bvtXq0Z8FZSdYh+mBs2D9ox9fbOkav9pZG9CvvO14r\n", - "i0sBji/xGNlzBebn51PeR2elZswGrDHmib3O9uzwO3N227Zt6b7Ftc6UZF64P95HzQ+XsTjMz8/3\n", - "PGUZ3yH9dWad4UxK2kcW2gFr1qzpeQMZV68x1glzEo9dFjvEevDe5UrxrbysB3RuJhCAR5F7+6c9\n", - "Nnhy7KFz5fiIftZqlr1pWcydB6zzrDL89PR0b/z/53/+Z6RfjAF7seNYM5RHqlAoFAqFQmGRWDKP\n", - "1OTkZC9WgFOgYwEcczM9PZ1aGP6d0ymeCVuYjh0xp1yGFStWdCdev5N122bz5tTueC1Ox5zAOWln\n", - "74JXrVrVfUZGmC0OwPt4PncskK1jTuJ8z16hcXFt1n2WfePaNI7zsjWNnrl39n6+bQtZyMLAgnI/\n", - "HQvhelPO2nCmZuuR8Ly1Zch8dw00gznqGELPyTbuC/mdyeN+0hZzc5wnJWKYUeR4vYwnbuvWrd24\n", - "2bplXQN0xjx3DNC4OJNWRnM7srbba53JlGVh8TnWvfekLPuN+9hj2bbP/z1fs2xG1pq9HRkHnb2M\n", - "rdfdbRvj4staZHMZuE/MP2f5ReQxUuPmUNsWsLfd42+wF7Zyo0N7O7mX54fj8gAyM1Zch2zW+6pV\n", - "qzrPkz2M7byN6Huo7YnKPJLIxJq2lzRiuN9n+1/G++e43uz56D3amXWtLNlzwlmuIHsjkcHes3ZM\n", - "vTehc2dUsu6zjHOjPFKFQqFQKBQKi0Rx7RUKhUKhUCgsgOy4tGSv9i666KJeYChuR35SZp+S/20g\n", - "IG5R2oAKgfLzuPMIfiQYDrcyZfYpEc/nvG6wO5rS+VAKTE9Pdy51u4e5Froa3KFcj/ubn5TCp4y/\n", - "A2Bd/A+9/Omf/mnqJscNevXVV0fEsIQ/srocALpFdsrsA6es4m6/7LLLOmqD7BUM44nO3/3ud0fE\n", - "cExwOwP6bdm5twMat23b1lGbQBHiEhOmI/jYxz4WEUP6gYUO9wvRVbSvgNAhctut7qDZq666aqRt\n", - "F/20zpnrUIq0r1nsUr/iiitG+sn8NiUG94IKB/oJvwo0Pcull17ate8UcORiPOknY8Q8d/IFc5Ex\n", - "gpbJrnp+5/rLLrust1fwCgbXPfP+9ttvj4jh3uK9x68TMnob+oBeJycnO8oX5HYCiKmlrrzyyojo\n", - "UyEhi1/5ZPRWfiUYMbpXRPTLIHiuffzjH4+IiIsvvnjkeocVoF/mF3pkTq9cubL3Woy5xbz1qxq/\n", - "dkN25gvj7nWELOwXLe0Lc9G6Zy6yRl1qAHAPUyehF76HDMyzyy+/PCJ2jZFLALDv0Y+PfvSjETHc\n", - "cz2vXdCZfrJf+HW0X8tec801XT/bIr5tPxhfZOE56mKgfp1qehu/Um8TDqBlYa6wxthb2v08Yjhf\n", - "eF44QQLZ+d00bk6smJqa6uRhbmX7ImOFXtB5hnq1VygUCoVCobBILGlBTqw5B5n5RG0rYTAYpIFp\n", - "LrC2u+KNEUMLihM6gYELBfhNTU31AlGzIp4OUDahMuAEzXUEn3PytuemDbp3ILODCl30kv4RCOzg\n", - "UfffZRDaoFpb8QvBdA0ZBYqBXrjPOG+cy1Z47jjA08U+AbJ5vthL2Hrf7NVyMDCwBwE46J7f8apk\n", - "hU137NjRC5b1eLogob2pni+07eSCcbQ8Ebv07TW30HxwWQgHwLdtt/fkd+ZD21ff20HzbamIiP5Y\n", - "YP1nSRi0gwwmx26Dz9GdCypmCSHuA7A3BZiWBlkmJyd74w9cYDMrweC9ykH8C+118/Pz6Tyn31zr\n", - "sh/e5xzwu7uEl/bv27Zt6+1X1ovLH9h7ZJ177pm0etybAZfp4LuUewBOwskCw/17VhaiLfhpD2pG\n", - "0g0c0O+917I5yScj3G7bcKJPtm84gN1rL6OIGVdsOHv+L9S/hVAeqUKhUCgUCoVFYsk8Uu2p06f/\n", - "jGqjJe/lZJlZ3lg1WLvZ+2NA23ikkB8Ai0kAACAASURBVMXkr63XzBanU6FNOutChbYw6BOWiuNv\n", - "xnkN/P58XJHKti2sFzwzJgIGJrm0N6C1diyXvRUZ4SX3duG5rKSFqXJayiCAvFxra9bzxaUGHCuR\n", - "peKPo0zJLCksbs9NeztduoA5mRFLm44hYqgby40lyk++Q3mIjECX612I0utox44dPU9aRoiazY+s\n", - "RIU91xltSQuPExaxx9/FLk1GmxWZzWKwWi8TctNfl5CwF8Cxhdw78y5Zv/Tx6aef7o2/KTv4DvE6\n", - "3otc3sN6MbiuvY+9v8C6o7/oMCMKdhkZrwfQ7rv28mZeQBf5zWh5aIf9BZlZR17T7TjY++G9iWeV\n", - "97esOLSL7zreqdWj3wIsRIHiOeUSPBmBuj2XptJq/+aYt4zGx94xy56VBQEuANsCHdoTuRCBtrFb\n", - "j9SGDRvida97XZx00klx8sknxw033BARu4I6V69eHWeccUacccYZceedd3bfueqqq+LYY4+N448/\n", - "Pu66667nJUShUCgUCoXC/0Xs1iM1PT0d1113XZx++ukxMzMTv/qrvxpnn312TExMxPvf//54//vf\n", - "P3L9Aw88EHfccUc88MADsXHjxnjDG94QDz744Nj36dPT072Clc4IAiZx3LRpUxpP5QJiWC2mDgFY\n", - "KFgWDz/8cET0yStBW8AQYl8X82r7GDE81Zus1bKbxgSLxIXcwJYtW3pZN84mA/xOoU3u5RgBg+8t\n", - "RLjcymfPomUxPQHWHdZBVgwQC5fCg+OKIpoKgTZNWWA4Xot2nL3pDBn0MTs725vnpsign7bEgCkN\n", - "3E5WyG56eroXR+QimFm8ReYFwlvA5+gHfY6bXy5OmHn1MkLdjLQ2GzP3JaJvvUNa7bgcgHfQdBvj\n", - "ihpGDPXg4qHMzXbvyuIOM+ooe6SYL543hmU9+OCDe94Le9i87u3dsQfCsUHWI/pt95UsRspUKL6n\n", - "4xo9dvYKuX3m0bJly7p+M84m2wa+Z7bPmTqFecMzwHN1xYoVvcKzJjEHjo2lsCjXWUY+txcNfbQU\n", - "U+gE+ZjHjL89daYOwuNmzzRg/pgyxwTjrdzsE8Qt0t8s7jkrmuy9K/NUT01NpfF6AB2jl8wDa+zW\n", - "I3XooYfG6aefHhG7BuKEE06IjRs3RsT4QNKvfOUr8da3vjWmp6djzZo1sW7durjnnnuelyCFQqFQ\n", - "KBQK/9fwvGOkHnnkkbj33nvjNa95Tdx9991x4403xt/+7d/GmWeeGddee20ceOCB8fjjj8drXvOa\n", - "7jurV6/uDl69GzenxuydKBj3LtXxRsCEiFncku/FqRfLwiXvjampqd774oUsRnt1stghWx67y2bj\n", - "xOwsm8w74racMeF72qs0juQ2e5+c1WayLOgaC9Vj6jFzzY/WsrXuAPJaRmRwphCwpW79tVZRJrct\n", - "ame4uC3TuWRZkW0mKm3jvTWcPWPvqOsEAdP44OkaV1fIFnJGiOuYDhNH26p3VqczUMdZoM7YyTII\n", - "neXqsXI/Hffo7KRWdntz3UbmaTNxbhYjA5CRdTA5OZkSv3v92oOQyeLYl8xryn47Ozvb042vdfyV\n", - "MwSNcVRh465v17j33Gxv9VhlWYm0be8I7Y7LCvNay+aWM0LdB3uwPKaOY2vfMlhn9kxllEJ+22Kv\n", - "KfCYeq3ujjqJe+Ohcj+z54tr4YGM1mf58uW9a73GTLy+R2KkwMzMTLzpTW+K66+/Pl7ykpfEBRdc\n", - "EOvXr4/77rsvDjvssK4A1jhkD9O77747vvnNb8Y3v/nN+OlPf/q8hC0UCoVCoVB4obFx48b47ne/\n", - "G9/97ncXvniwAObm5gbnnHPO4Lrrrhv79/Xr1w9OPvnkwWAwGFx11VWDq666qvvbb/7mbw6+9a1v\n", - "9b4TEfWv/tW/+lf/6l/9q3//Z/5l2K1HajAYxHnnnRcnnnhiV0o9IuKJJ57o/v/lL385TjnllIiI\n", - "OPfcc+NLX/pSzM3Nxfr16+Ohhx6Ks846a3e3KBQKhUKhUPg/i93GSN19993xhS98IU499dQ444wz\n", - "IiLiE5/4RHzxi1+M++67LyYmJuKYY46Jm2++OSIiTjzxxHjzm98cJ554Yixbtiz+6q/+Kn219853\n", - "vrMXz+Fq2nCWwW/UvkP1e1Dzj/HeNasPAe+P+a14Z0z7xB3ccsstETHkz9t33327rIg2cysi4gtf\n", - "+EJE9Hm8XA+Dz+Hag2uJ9+30lywP7vOXf/mXEbGLJ4r37MTyuHI5HFHveMc7ImJYJ8uVubkXHERw\n", - "baEHYmMcC3DTTTf1uLDMocg7aspnwBGFromrQBb6Au8XekHfzuKYmJjouLPe9ra3jfzNmWDmQzR3\n", - "Vha/BH9axoe2fPnyng6ZK44B8zygbTjCHBPkml/mZtt3333TOlGet8C8deieuYXOyYxCn+gF2ZDl\n", - "fe97Xy/TD30A1qj58LIYoM985jMj13ss6Str4LOf/WzXT2eEMseQn35iILpKtGPmzLUG2Ktavk3G\n", - "3xyRrslFv2+99daIGPIbOuOUtskgRS/eL2h3n3326XGKwf2GPljP9Jd7si8yF72fmO/Mc72NLXGd\n", - "N9o2dyKyMKfQE/00p5xlp/+f//znI2KUJw4ZXC2c/QKuVcbblb6RhT2a+WImCWTg+y2XK+NI/8g+\n", - "Z+6YxxNZXQvP+ygcdGS7cW/X27vhhht6PK6Athln+slz1BmkzmJjTN/1rneN9BF9tmOETtw2mY+O\n", - "x2PvMk8g64B9kXbg5mONoo8205C2mVtciw797KU/7F0ZdnuQ+rVf+7WxwVa//du/nX7nwx/+cHz4\n", - "wx/e7U0LhUKhUCgUXgxYssrmW7Zs6U6BZBJlVVedhTA/P99Zp842yPjvOBA6U8LZBZxEs2j9tuKr\n", - "q6JmPE78hPfLFmcG11VxXycnJ3uZIFnVZz5HP+aryrjWnGHE2LTZKbaYsswI4CwNfmJh2OoxrxUy\n", - "HX744SPttX9jTh155JERMawn5LpQrgvk/i+UedhmlGR1njznMr66p556KiKG84P5kmUctp5QV6B3\n", - "tqG9YMiaZW2x1tAX90LnRrtmnY3ldcFYHH300RExHCP675pmnqOugdSOkSv8O6PLXi9Xwmfe2Atk\n", - "uHr0uMxadI0XGLkJjfBehQ7RFzJl2X+uZdZme3qvoE2ysJytnNWdAqy9LIOM+nTUG9p///07GfA4\n", - "WBbvXfTXurRH1j+dQfj4449HxK51xHzlXs5CM5ec27Qsfu7QXsaf+Oijj3afnXTSSREx9NZQTwu4\n", - "7hr3yHg/vd+i52xPa//Gd2HR8P7vLFRkyuqIcb3f5IzL3HR2YevNjejvXVkNNPTn2mD2mrd126xD\n", - "dMc699xaqIZdd8/ndVWhUCgUCoVCoYcl80hNTU3FIYccEhG7Cn9GRDz44IMR0ee3o/Lp+vXrI2KX\n", - "RXPmmWdGxCjnW8TwJOm6J9zDdUQ4zWL1cELHaralxun58MMP7066VEPHorLcrk31yle+MiL6lhon\n", - "bKweLLdxdUEidnksqIKLNU9/jzjiiJFrsYrpL/fCwrCFiR6wXF0Jt9V7VptpXG2diGGtI8YCXfO7\n", - "LRIszB/96EcRMfRknHDCCb37IxdejjVr1kTEcCysc+6FfhjTxx57bKTfBrIyti9/+ct7MTyOQ6Kf\n", - "eGJd4wyrHplZH+iR7wNknp6e7rwcXGMdohf6Q8kRZLHljQeCuc28YR2Zuf7QQw/tdGtuwcySXr16\n", - "dUQMLXW+3yaztPfG28H+8OMf/zgMx/TYyrX3gnXAOqJ/yOZ+AsbOnql2LrKn4FlElkceeWTk3oD5\n", - "4nXPXHNMqfkhmX+Tk5O9yvbcmzlGvCH9dEwY/XP8FfuBvQCsA/q6bt267rseJ/ZQdMuektWdQg+M\n", - "IWNF+5al5Qn1/m9PCrrDg8Lcy7hcmYM8q+gbLBfed5966qlOt+z7a9eujYjoFatGt8hKvx599NGI\n", - "6M9d2mVeIAtru50vXPvQQw9FRHT1HdlD0YNlcW0rxzEBPmesWKOey21broaf1Uljb+J6eygzb6r3\n", - "tOXLl/c8b8xz5m/GXLAQyiNVKBQKhUKhsEgsmUdqxYoVnWWR8TwBTuhYyU888UTnYfBJGsub07s5\n", - "k2ztYIG4eionUnsksJ42bdrUndq51jFPyM1pnVMvXgOf6jMOLk7ejtfZvn1711+/23XMi9+3u7++\n", - "pytY2yJpkVUuzjiP8NxlVbjtNSTOgfnCmOE1aj1B9BOLyDq19Yo1hNcLK9mcS5bdWT0TExM9HdI2\n", - "Vo29BJ4veKAcQ5ZZR21fzQ3lcXIVeay7cUzxEUM94WGg3xs2bBh7/czMTM+r4VgFwHWsYXSfVXxm\n", - "LPCmEM8wrso+enD/+dyy4LnMKv8bWTVux320cjMXkXNcbFf7uWNBXKUdMJaMDZZ6y7oA+C7fYQ/C\n", - "e+N4GvYq9hfv0Zlnh/ZaT4zHAm8Y9+QejlMCjkXl9yx+5aijjoqIXXphzjgbD7Cn2NuRcS0iI+uC\n", - "NYs+vMaPOeaYbh7gxXKsH0Dn7Gtcx/5mbzp7D31k3tAHfkYMdcxeikz8zGJHQRb/Cpi7rlbuZ2Tb\n", - "FroyZ6rHlfnv58K49d+264zKwWDQ8zACxp/voC/HvGUoj1ShUCgUCoXCIrFkHql99923O/1xgswy\n", - "JTjtYgVE9OMHAG24lg33yLjTzFgPsmyGmZmZziLwO1u37bohtlrcNidyn/J9mv75z3/e81ZkFrXj\n", - "VVyryO+Z0RMWCFYRVkNr2Zl/KcvoAOY3w3LN+L6Q5dhjj42I4Vg5u7OVl3EkdgzLghiHTDasO2Sz\n", - "zjPev8Fg0PMw8TteLqyczJImzoJxb7nTInIOsunp6ZRRHhCPw3zBG5jVcGJe2BvMPLCnbseOHZ28\n", - "5gb0mmIOMQ+I10AvWPmAe5rnDNna9eSsRHt3bFHzd+5JH7D+Pd6OKcz4ztp+42ng2sza9b0ca5hx\n", - "s3EfPHzT09O9eBrXpHLGdMYth948r6xH1ih6aN8aePztYbTXwl4jZKdPzB/05X2A2MEDDzywu1eb\n", - "ydfCWdte9+4nfUJWvF/OmgX7779/93xgnuLVtdyMid8CmD8WoHP+zpp25lzbf+QmXmuhtyB+Vjl7\n", - "D/g55LqG4+BnkucsYC3SNnsPczfbF+3RXbFiRbr3Iqdjw/Yo116hUCgUCoVCoY+JQXYMfCFvmtTm\n", - "KRQKhUKhUPj/I7LjUnmkCoVCoVAoFBaJJYuRuuiii3pZHWS3tNxZEUMOqjYewVWjzZ1H1gHXOZsP\n", - "ri34ihyfhdeMd+pw7cDNtHLlyu49KvdCFjiC4MLic3vieIcNB5F5v3iH7BgZuJYuvPDC3rt9VySH\n", - "xwn+KcdGuXbLTTfdFBHR8ecR30NfyZjj/f11110Xf/InfxIR0cscc0wQ/FZw6GWZg8jE9XBzOQar\n", - "rRVGPz/ykY+MyEt8DfEYjBXj/853vjMihnFaxLNxHRlR6IX54rGfmJjoPmM8L7vssojo8xM69gHZ\n", - "zbVnjka+R/uM6QEHHNDVryEmzLx/tG0uQWer0TbcXOZiJP4EWRjLyy67rFeZnrgsMoLMtecaVl7/\n", - "cHiy/om7IFaS2CPuc9NNN/U43xzLxE84xdgvnI3p6vOM/9vf/vaR68bVyWF9fuITnxhpi3gTx50w\n", - "RvCVOYsJ/fB5y+PW/h3s2LGjkwtZ4DczS4JjIJGF9e/9gjnJWmdM0WMbI0bbfIc9mnnr+Mw2lqW9\n", - "njVHe8xZrkP3jCn7Rfudtup720/k5t7EGTlmFj2yJ7nyf8ZBeMkll/QyOr1/ITf9BN7vmP/Iwt5F\n", - "fB97NXsdslx77bXdPegPa8YctJbF1faRgf7CE+ox9V43MTHRzds//uM/Hukf42iuVcuSsXWgV9pn\n", - "7rri/3PPPdfJBdfqxz72sYgYPqsYf2LKWKtwbWYoj1ShUCgUCoXCIrGklc051bpSrStEY6G2WS4Z\n", - "G7XrKOFhMH8VMGs33+NUbC8S1vDOnTu7E685kty2rbisJpOznGgPi8OW7KpVq7r+0k9O0s6qcEYH\n", - "VgtwNiP1dfjeD37wg4gYZlC0WT4Zrxlw5gPWHmNCJW8q11NnBriCMfrDGmyrrNMmHiaqSNNfvCAA\n", - "q582aJt+ei46m5ExO+CAA9I6UrTBmHi+A/rDnLNHzxYZ3qHDDjusmwdZbTZ7Flyh2ll7jBF/p33q\n", - "D43TC20yN9Chs5PsuSITCv050wc94HVjDTsTqe0HMpivMuOr4zp7gS0L64e5zvowk0LbBv2iPhBw\n", - "Bpkzh5zV5DHy563+PP7MLTMTIGOWWem5h9fQGaqujTUzM9P1x/20t89calmVfdYP2a1ZHaG2thtz\n", - "JasTxn5AG8jM3HVMDHsT+uN5QCbeuAxlZ1Wij4wjDl0iE/u/ZWHfxBPF2wLzHkb0s9bRB5/7Oco4\n", - "+vnnNxkAGfxsoy/t88jeXLMuLMQp6XmVxVy7huSyZct6z1yec8xJ9jeqwz9flEeqUCgUCoVCYZFY\n", - "Mo/UQQcd1FlJP/zhDyMi4vjjj4+IvGYJXoZVq1Z173h9esUi54TNidMVzN22PVFYC2YL50Q+MzMT\n", - "999/f0QMT/62dvguljSneKwa83hxPbKceuqpEdGPwQLPPvtsJz/WiSvLAk7t1OxBBld2dj/hZvqP\n", - "//iPiBhWxh1XH8S1Q8x7CLDeXBUaXres9gifIyvxQK13hPHFE3XfffdFxLDmkL0jjA39/fa3vx0R\n", - "QyvJ1bodc0Edmc2bN/c8Uuiafrpmmecu3g36x5zF22hZ6PczzzwT3//+90f6v27dupFrmUPIQk0u\n", - "rFfPFyxV1gG6Z83aI7Fx48bub15THk97cbAC+dzWMf1nzn7nO9+JiKH+Wn4zx9053tD1r1hzcI4x\n", - "RvA6eo3SLrLiHcHb1K4j1hzzlDkJ15rh+EaATJ679uS09Zayas+Mxcknnzwik73deHLsHUeGrKYR\n", - "ennooYfSiuy0gYx4Vj12AH3gNUB/cMu5fdrZb7/9ujmJvJabdcE6QDbmveciXiV0/apXvSoi8lpP\n", - "MzMzvQr09pYC7mkvKm3aa+j4z+9973sR0a/DFjEcZ+YzMuF5M2etPa/MZXuagOs1tmMQMfpsdHwm\n", - "19A/vzVyjKjntsff3I0tq4Wfof/93/8dEcO92nyobXX43aE8UoVCoVAoFAqLxJJ5pObm5jqvEqdf\n", - "Z6cAVyf+xS9+0X3m98ycuP1e2bETAIuSe/PeFevXVgOn3TbGiPfkmdyOH8Cz4LaxMOypIS5hnAfD\n", - "7PXAMRJ8FxnwLHFPn+rvvffeiBha2liyWJytheF4Cu5Bv+0FdJwWsjueDbiaLu0ie+upwQLF00Cb\n", - "eC08RrRpHiv6ab3QV8YGPW/atKkXN0SbjBGWFxa4YY+TM2Qynsgnn3yyu9cpp5wSEX3vKDp1Negs\n", - "LonfXREbC919nZ2d7dYMOms9RS3wAqAX7oHX0F4APDqPPvpoRAwtVrxurTXtTGDaYj44zoh70t+M\n", - "Bw9gqeKFdnZw+z3uyfpln2DPsnVsyxwdey37evMrzs7O9uYtcvPTmXKeLx4jV4D3GCFrW70947ez\n", - "15/fzZEG8Ao4c9BrELTrxPPUexFjRH9pk/HN+ELxYLCf2DvY3p9rkCVjqqB/zGH2ReaJ28Y7Rmwp\n", - "c5D9pdU797LHiH3OsrDPMYbMLXt6ATIyd9HHOK469ECb7F3ZePJMZ/0gmxkgAH1ztuOyZct644nu\n", - "2EuZa8zzrBK6UR6pQqFQKBQKhUViyTxSrVdp9erVEdHnSQOcCtv33Zza/T6dUzinXNrC6vWJ1JaE\n", - "66z4RI3lsnz58i4+hpNvxtOXcchZdluF9JcTuNvZuXNnd4+2nlHbH9+L/mCBcHp323gXOKFj5aCv\n", - "cTx3fieNXiwLlrSz/fjcemH8HedjazOin4WCRyrzdjIv+Iklko2dOR7tVR0nNxYV8rquEMDT4gwi\n", - "4PmFbMuXL++8P3zHnhc+N48XstAPgBXHHGwzoca1Pz093fWzjUmI6HsBnJ143HHHRUSuc2dxMkbs\n", - "AW28VhbrtRC/Jf1Hpiw2wlZ0yywfMRo74uxUrznvRc6k5DrHngH0ZH7AlStX9nTYcoRGDOexa7hZ\n", - "FjwWbsdjih7G7XW+1txqzCV0l8nC53gRgO/Zxhg58zHjTkMf5liz7KwL1mimB7Bt27ZufLgH89ae\n", - "Oj+rHGvoty+0S3ut5yVidI2yzvksy9K1LN7Dzafp9pGRZ5br7bX3tl4yTsmsNhXXeU+3d7iN1bPO\n", - "/XaI+Y78rdy7Q1HEFAqFQqFQKCyAoogpFAqFQqFQ2MNYsld7l19+eeeCc1poSz8SMaROaUvmO9jx\n", - "L/7iLyJiSCeB29AF6HDhQRECnYBd3A6ao/w8dCj77bdf50rFxUg/aPvP/uzPImLoHuS1A+5E+sn1\n", - "0JuYngC4vP0HPvCBTl6CJnGl4mo1FQpAH1yH7imF/wd/8Acj9yT40q8Cb7755p4O7fbmJ3Jfeuml\n", - "I587NZtxRhZK/rt4YvsaCzoBxh8dM/7cg/6aZoVXgNkr0SuvvDIiIt7xjneMyM7rrGXLlnX9Nl2N\n", - "aSSYN8jGGF188cUj/WvT2SOGcxFaDsZofn6+e7WHax1ZWBdQYWSvQein6YpMy4HOGQv6eumll3bB\n", - "scjN6zG+Sz+RBfgVGHqi7fPOO2+kT4ytX1dcd911PXoIFwflNcFnPvOZiBiuf/YL1ijrg7nI/ILe\n", - "BriI5IoVK7p5y3giL207SBa9vPWtb42IftAw+jN1FhRUyNomY3j82bdayo6I4Zziu+gFSiEC5WmP\n", - "+U5/oc6BOoU+PfPMM73XaVCbIItpR9jDTG/FfGnXWsRwTFnbyI5etm3b1q09lzNAL6x/EhpYawQ2\n", - "cy/ahjoJ+LUSY8te9573vKf3+hdZPM9Zcy76y/cZM88X9EjihAOkr7jiit6aQw9OPvFz1OUPnJyA\n", - "7NC+uNAzMi1btqzbW5CF9esi2ugFiiDmi0NfGHf09PnPfz4ihs8LQN+2b9/eXfu5z30uIobrmfAB\n", - "+ofcHqMM5ZEqFAqFQqFQWCSWtPwBFiunQFIQHcjGqZgT67PPPtsFhTko1IGXWDmcLB2gbHJi/o6F\n", - "4qA8ZHvFK17R3Ru5HRTLSbu10iKGFoOpE+gnVo1L5rto2s6dOzudYAkgv4NEXdQO2TPqDGTjc9rj\n", - "fllacNs/e9SAAxcdTOvAbe6J54LA4KOPPjoiRsfU48j4MTYuMUA/8EjxPYqDZoVKkb2lRMjGk7nI\n", - "uJKkYAuLftIO84c0ZxeHpC9zc3M974WDRx1sTOE5ZHEgq1PqTYHiQPi5ubluvF0E0df6czxZWJhe\n", - "o/ZUYS2OCyDP6FXon5MkbPW71Ij3F8dIeD608Z/8jXXrfnpu2fqnnw4+Bi5oiMyPPvpoz/PYUrdE\n", - "DPdFEn08F7mXg21NRAxol79v3ry5R74MGE/GhHnMvPG+4VIN3ouyfWZ+fr5XcNZrCL3wd1PiZMlJ\n", - "1o+96e31fMb4Z6V7aJO/ozfT3ADu6ZT9cQWcve85KcclB0yV5LmZFUH1dVlZiPYa+umSLO6nC3ly\n", - "Txfw9Nuldr/x+nehXuT3WCyE8kgVCoVCoVAoLBJL5pHaunVrj2gVK9kFCzkdtjFJftfva7NTrU/e\n", - "LgKGNwTLBW+A25+dne3FBGVlDmjTnhZbavbQmJR33Gna1ljmYXIRPPrHSdztYPVhyZgUOSMojuin\n", - "d9url8VQYSWbWBggu63f1rJzGQvaxCuUlZxAD3wf3Ru2VNvYKnsrTA1jEl9biXwfjxtWo+P9QJtO\n", - "TQwb19pKw8tj7x/X2fNiq5i1mpGZzs7OpuTK9naYAgMLmv5lHgwTTOM9avuKnOjS8mZZNxlRrj27\n", - "Jm1tY6MiRteFPansb+wpnuf2anBv9kMTqTLWzJe20KH3ChNh46lhTlKg10DnyGp6H+A1uWXLlm58\n", - "M8on9IJMGYG2YwYZ92xdoPfBYNB9NytnA+wdy7yeJrN30UzP3bm5uZ7nxTGPwPGnJr22zpHZxXLH\n", - "efYcV+oyP57/jjF0QWfvo/YWsR8xd9v9lO+abNv3BujFsjiWzO3bi758+fI0RtTzP5snGcojVSgU\n", - "CoVCobBILJlHKqKf7WbPk8Fp+OUvf3nPCgGcPmnDpeqzku+czJHFxSUB9/3Zz37WtZ3FMJg+ACuH\n", - "ftgK4HcsS5e4t7XTntyxFDM6ERea83t0e2BsgTi+o31H7vfibsOy2Bqif+gxo9qx9eCMw3H9Anhc\n", - "bAXSJjFUxMbRjscoozPauXNnz9uBDC60yLhlxNIm50Rmx1SAqampbvyYv7bqTNfjwnNeF1mh1qwI\n", - "3vz8fOdZoO2MTsL9s07tqeP7zBu8ovbQtP1wYdqskKwzqrCgkSnzGjrbcVwsheM1nX3l/cL0Q6w5\n", - "5q6vNwk6c3Z2dnbBWn14Ur0eDMbShNL2YDseZd999+36Y6+e41CQ33GHwNm9XO+xBu1bBmdfZeS8\n", - "6Bi9tBniLRyvxPezwo2Tk5Pps8d7C3/3M8hxitn3WRfjZHG8reW2Dr0X2cvsvc7UUX5Wte270GhW\n", - "PNbXuxho9nzh747bGrdG6R9zFPl5Fj3fgpzlkSoUCoVCoVBYJJbUI8Up1t4Cn9zH1bDgpOhTOidt\n", - "003Qptu2RWqy08xi27FjRxfzsBC1AW2afDnLrOGeJp+0VbBz586ubWdtZaAtWyLWIzLi6cAaxFpq\n", - "4x5s/bvNLPMhsyxsaTFGfI4HCxnbOAaTzjrmLYvtyqh2sngfUy1MT0/3+tlSuLRtZXPKVj4eKO6Z\n", - "eaQGg0E3F/Fi2CK0J4WYl4yWAVmwAl0TyPNscnKy0xnjY4oTYCuXeIoszsT3pD1nTLVtWN5sDpp+\n", - "wnEV9o7wuz28vq79G7o0iW/mHfXexZobt/7bPrSUMfYYZN6vbP3TpuNTsmw2r/2VK1f2SIYBurKX\n", - "0Nl5wB58x6R6vxjXT9PRAL/BcNym47tMP+JaSNbjYDDoxWdxjT219IOfzHNk85pzPLDrarXryG9c\n", - "nu9zIotBzq7PCKTbMfJ+71ipfK1bWgAAIABJREFULHbMXrJsTXO9PeLT09OpZ81esiwGO0N5pAqF\n", - "QqFQKBQWieLaKxQKhUKhUFgAxbVXKBQKhUKhsIexZDFS73vf+3rvvA34bd7znvdExOi7YmcnmWeJ\n", - "96L83e+Gb7755ogYcif5HTrvafn86quvjoghj0/77tuZTLfccktEDLn2XG3acTzIAgcR93TmIDLB\n", - "QXT++ed3cTN+xwvQCzp0jIPfeV977bURkXNz+X32bbfd1vEyOc6Mn4wzfFzwW5ljy/W26CccVG2d\n", - "nIhRriWuhTuJuBTXZOHn7bffHhER733veyNiGE/g+ATGFJ6oD37wgyPXIcuWLVu6eAr6yXgybsQw\n", - "OBaQec5c9N/pCzqHyw29R/RrM3Et4894Eo/k+jf0B46w888/f6QddI0+iLG69dZbI2IXNxtzhDaZ\n", - "m8gGXx38dvZMsy6YY6wLeN8A33N842233dbNc9e08rVwxJnfzONPO+YgYx4x5m0M2hVXXBERw70C\n", - "ebNMIDjCmFuOqXRdHGRhvtA+smzatKmTh3WBDpnnyEJ8Evdi70IvrvnmGBN43z760Y9GxFDP27dv\n", - "7+2l5s5jniC3nwfMF3hCkd2xL+wXjCnPgOnp6a4txhNdoRf2IvM2Ov6G9c/8QmYyR/mdrEB4BT/4\n", - "wQ/2YnxcBZ9rzUHn2DfWB9fDQekK9/SB+3z2s5/tce0hN/0kxtbrwhm2wLyvzF3HHPH7ypUru32R\n", - "PddtAcaVtnmO0h/HnqIn1gXPALM7rFy5shsn5i37omOjmefse+glQ3mkCoVCoVAoFBaJJfNIzc/P\n", - "9ywSZ8IArEUsuccee6yr+3DYYYeNXOtMMVtz5vHi5OksraxCesY1FNE/WZtjj9/pD94BgGzUSVnI\n", - "e9SesKluTD+dyeJK1Vg9yGa4xgeWhbMi2785u8pj4H6iDyo9H3fccWNlNxfXI488EhH92i+tLHi5\n", - "0As8VGvWrBlpGwvaWVtZdhL6wzps/55lRuENZf7iqcnqSLXZVxFDq9BZe60HEN3YSgNYnMiCRXrk\n", - "kUdGRD87iXtzHf096aSTImLI0Qamp6d7HFiu5+K20QeyMy/Mh+Y6Zcgyrq+Zt4LfnRGEFW8OOnvT\n", - "AGPqqv3jqjRntb2Yt85OpB/031mp2XxBH/wctzfRH65hXNE5nIvAnHJeF84wpY94Onfu3Nn1w1Wi\n", - "aYN1bQ+K5Udf/N0V0z2meCJ+8YtfdPsbe633XN/D93Y/7YmCZ/X000+PiPEZx2ZXYNxdTdvZuejt\n", - "0UcfjYi+B9deVHsAx+H++++PiKEuX/3qV0dEv77WuP0tIs9+9P7hWmHj4LpZ9Ntt8RzBC54xiAD0\n", - "Zu7WqamptC6gs2+z/T9DeaQKhUKhUCgUFokl80i97GUv6yytH/7whxERcfTRR0fEqIchYuhVwNo5\n", - "+uijO++FPSrmGcoqswJOzsiCxYJXyNZ0e7pdv359RAyrotrywtOCRXLEEUdExNDitIWBxcLJ/Nhj\n", - "j42IiI0bN47oAUxOTnb1g7DuzQQPsFI4zdMWenIFZ76PTFgo69at68nuWjO74+Fr22I88W5gcfjd\n", - "NmPxox/9KCIijj/++IiIOOaYYyJiqN+IYf+xtOk319oitZcHDjI8OJ43rlOEVfnwww/3eLlaD2p7\n", - "bVa5H7iSM3rxfEHP++67b/z4xz+OiKGH1tx5rIuf/OQnERHxG7/xGyP3YB4BdEr/f+u3fisihh4s\n", - "LPFWZvrLnEK3notY5Kxd8715jByPhkeS9TSuvparh2deXfP9vepVr4qIoWeC+QDQl+uxMWYHHXRQ\n", - "TwZ7d5E78xy4ZltW8RsZmfP0bfPmzb01yHgx/ieffHJEDNczY+C2kdk1u2zZM7/8liGiz4VHP7jW\n", - "lc09dxkjWAeQmf3WvJItowAeaHRuWczX5r3Ha475QBVx1gVj6XW0ZcuWbi0xrshkrkXuxd5sT6Y9\n", - "mHjZmdvsM+N4ZRl/1tC5554bEcN9n2cMQA+u4ci+mvGn0j4yjGNacIwj+mEM7JF2TS/ulfHEuqYV\n", - "86mN2wOOX6YtziAZT6RRHqlCoVAoFAqFRWLJPFJbt27trH6/A/UJE8sDK2rNmjXd6RtrBriCK6dS\n", - "Tpaussx1WAuunmyPBNevWLGisz7NjQfMPeZTut/HO8YKjw2eL/OEbdmypTutc4rPTtCOn8hixgDt\n", - "YMlhDdHn1hPoCrVtte9x/eJ6LAU8Ull1YK577WtfGxFDzsIf/OAHETFqkZqvEc8lY2Gvnq/nXq6e\n", - "Dvzu/+GHH46IXdagvXrogc+xcrKq/PxuDyfX29pt5yYeN6zU1ksXMbTSGE/m90MPPRQR/RiJV77y\n", - "lSOy4OkiNsSemomJiU5+2nLWoWXhHmvXro2Ioc7tNaCfzHE8kszFdl2gK77j+Cp7jZ1pSr/Qi61j\n", - "Z7E6TqvtK54yZ5s6cw54b6It+uK1TV+Zo1kl+YjhHPyVX/mViBjGuuGJsGffnjp7GrwvmmFh2bJl\n", - "3bhkfKXOpDRfKEDnrHvmCR5/vzVAv/vvv38nL2vHunFGnPlNHY/DmLIXsV/gobJe9t9//26eOiPM\n", - "64J+o3OeScxZy8IaN0cr/W/3AN72+DmBh9I6d2Y5/XTGHPCext/Zm9vrvVaQm33D698ePbMxZFx7\n", - "9jL6+dn2D3147804fY3ySBUKhUKhUCgsEkvqkTJHG96C7J06J8uHH364xxwPOI1jUXDa5VTr99Kc\n", - "XrGkzJKdcZDNzc11p3vHhgBO3uazco0bYMuK99p87nfkBx54YGeNcqJ2bJhlcVZjdvK2d4G+Mgat\n", - "N8XZeY4rcD/5HY8EIE7DdXZcCwZLlPu0MXVmCscSIr7CcUxcbw5B1zQC/p159dKXvrTXb3SLfPZ2\n", - "+nrmGh5Ie3TskWBebN++vRunzAtgnkJbu7bqPP83bNgwIrsxGAw6q9Vz0WvIliT9YP2PsxwjhvPC\n", - "vImtRzLj6TL3HrD3FL3gRfD+wn7i2KtxWXv2gvE7XvRsv6AN7pXNRXt0+Ll8+fI0Lo028USx5uyZ\n", - "Rl/omnlDHxyX5P1iMBh0e4W9uubY5Dtcn2X5cm/GKOPya2OkLIPXkL/rmCnLgscCDzBz1tnNYHp6\n", - "uvcZ45956uwlt2fT/XQM1bg9mn6jB/ZQez3dT64336Fj5Fwby5m7bV+51rFc2fODtvz8zLj5vH+0\n", - "12dzBSATew16WgjlkSoUCoVCoVBYJIprr1AoFAqFQmEBFNdeoVAoFAqFwh7GksVIXXjhhT0+O97H\n", - "8k74k5/8ZEQM+XDaTBy/g4U7B04h3qeSjUKNGt5Dw+MDp5AzCVwTietbbh6+Q5wBcVZwCtE2/eS9\n", - "K++yuRc8Tuag4t68t8WTB2fVhRde2OMGc/yI+a24J7Lyvp7+wuNEP4nvIGOGKrvIeMstt3Q8S85C\n", - "c7wRY3TxxRePXE/MA3WziDtAj8jiuA9icmZmZrp+mjuN+AEyIJlbcCfB++RaJegF/cJZB08c793b\n", - "TENz56FzrmH8qYODTOgFbjbHBBILQH2lK6+8cqT9Z599tsvGc/0juPDgFKN/3Ns1qhh/eNxcndwx\n", - "ZS0HoeOzaBtZ0CE8fsRhoGtkYH2YDwuYLxDceOONPR6vrKI5XGtc79gIZ1jB+9byG0b0ORzn5uY6\n", - "nXj9O3vI+wVzi7a4Dj0Sj4de4CBD320WH3FHzEXzYQJXl2a+sEYdQ0NWKLEj8JuZy21ycrKTH1no\n", - "pzlI2UscM2SuVcdUOePO+2jbZsv5FjHkq/Se6yw1+uB+MqbsVewrjAF6/NCHPtTd25nT9J91wXyx\n", - "XhzXg15YF848QyZiqq6//vpObscvMqe45+c+97mIGHLnmYvT8bBwszK/zCfIGt++fXtvjwa0jX74\n", - "vX3OjWvb9aLMt+qYw8nJyW4N0k+vZ9Yk17E3ffazn43doTxShUKhUCgUCovEknmk9tlnnx6/DZaG\n", - "s1n4OyfstgqvszA4WbuGD6f6LDvN2TuuPwPabDBOrRn3D9eaWZp+uu3sZM73nSmxfPnyXmYgFoPr\n", - "axnOXrM3yVWZnVHpDMKIvIq0LU3zn5kHi9omAD26XpfnRfs3rEAsbeZBlvlmtm9nWgLXxGqtTWfV\n", - "8DvzxBlf2Tx3VhNWnXXecs4x3tzLcpo7Cp3y054KVyfHcmUOj8vMxBqncrM9q4B+ICM/8QJ4jZo3\n", - "Dw8XMraZdZ6DwNlEAB1zj8yDAbIYCfrUZjXa026+OuvFGafM1WyMnM3U1vjxXGFu0V9n3Xm+uE3m\n", - "IJ87s9Z6m5qa6tVPytp25qPhLE9zGBqtBwIdsv69F1mnzMGF+olMzEVksR7n5+d7bxTQR7a3OOsu\n", - "q93V3iNiWOON9tt1wVrheUHWJp+3Ffkj8mxXcy8CZDRDiL2lEcP1jXz0128cAP12ZiR7U8Y+wj3b\n", - "moC+hzMFWTecMbI5aZRHqlAoFAqFQmGRWDKP1OzsbK+SKXEeruBsy27jxo3dZ8SbGJw8ie3h1OsT\n", - "puvEcJLG0rBnp/VoUJuIqs9ZRV5O71yP9cL7WOD39PbQYBWCqampTg9Ue+a7cK8Bx7q4YrG9KdQ+\n", - "Quec0O0Ba/sH/C7bViAWJfFrvNNGt1/72tdGrrcX6YEHHhiR5dRTT+3dm/4yjtR9cQVvV42Gxw3O\n", - "NVu9rsOEfv73f/+3ZzE6JubNb35zRET867/+a0T09cL13IMYIGSx55MxmpycjHvuuScihrGArrKO\n", - "9UZsyznnnBMREd/5zndGZATME+5J5Wb0cdRRR/Vkdw0216ABtm65N2NEVXGAlchP4vSI12k9HvbS\n", - "uOq+axq13ou2n9zLlc3tcWDeoKdWj/Zu25L2eNpb5JhBe+pYR8wXan0dddRRvXlu7x+Vrr/5zW+O\n", - "9BdYj+bzsxeAudt6Df0dYJYJe5p9PevKnku8pPbs8vvy5cu7PQbdZv1kjrJusppW9hL+zu/8TkRE\n", - "fOtb34qI/n6xc+fOTh6eJaxnw7F07DHMQT+70Btz+j//8z8jIuKEE04Y6VvEUHeMCXOQ+W5+W8eA\n", - "urZZxpxA/1/96ldHxJAftX2bwljwGfewBx/Yc2nPdeZ9ZqzZJx555JHeM9pxZbBlmFtwIZRHqlAo\n", - "FAqFQmGRWDKP1IoVK7oTN6dbMzADTpx4ZNasWdNZ1vaGcLrl5MmJkirh9kABTrF4MLA4fIJtT+Tc\n", - "K+NlsrcH6yjLUuE0Tz/pN5bKuCrb6A4OLaz5LEaCUzwyjIt1ioheNiD64PrW2rFVD2yJA8YXnjq8\n", - "QIyp20HPWGZ4XbDAW704lgPLy+/wAZ87Pol54krefB89tJaa5xZjQ7/w2PzXf/1XRPS9Oo6lAHgD\n", - "LTvXTU1N9eKprENbkGeeeWZERHzjG9+IiL53lO/zOeuijctqsWPHjs6DRpuMFxak+2lGAHTtNY1e\n", - "GSPPxdbLlMUTOrallbuVEZnpp71AzGXzv7G2W+8p1r/5xviZeVIYV7wF9Derwk176OPlL3/5SBxp\n", - "KzcZgGeddVZEDOeiPRLIwpg6ztNz1HyCMzMz3T3Ny0h/GGdXrPbc8ud4GPAiZF6GAw44oPMCOWPO\n", - "YG09+OCDI236LQDrCN2jx+9+97tjr29lY47QhucW85y/M4ZZfB97G/plzrfV5QH/h9eUn+xNlpt7\n", - "em9nLOzB9psbPFG033rIGR+zjXAPjz/9or/eHwz6yvfaNe+YR8adt0WsOd502SOdYckOUlu2bOkG\n", - "CZd++7cWdv1OT093Cx/lAgaJQTG1hR8YgE0KRfJ9t98G4RJUy6SzS5JB86Rj0/bCQHa/CnRJhnG4\n", - "//77I2IYcMgGD5i0PmgguzdG2kEvftXXPgR8YHIwuMF4ooe77747IoaL0a+lHKTNQjvyyCMjYvR1\n", - "HW1wb/prVzXgIcc9TjzxxIgYbmoZ4bLJsScnJ3vX+rD6z//8zxEx1J03BH/OK+MsaJ8xXbFiRZxy\n", - "yikj/fWDFBnQ1V133RURQz35EMjnPKzom0mswf777z+S6hzRD1gFJoilTfpjvXA9uuc1Nn3BSIrI\n", - "H5Tozgdj1hxzClkdfOt20BfjT7utXtjH0KU3cR/qnHrfjm8rG0DP7DvtwdwPNh+6WHP0x2sOXfO5\n", - "CZI9/rSDjAcffHDXHx8YXZKCuWrdAgf+MydpJzsE/PznP+8ehONIpdt7uowF/fC+SL95+P/Lv/xL\n", - "RAwPM6a92rFjRzfO7KG06bnKHGJe+0CR0VMh0+tf//qR69q+so9zmGPN8DzMDG+XdbDufT1jYYdE\n", - "a2D4dar14X2OMWGeO1jdcJJX+yzzGmJO8SxHfsYgC/A36tVeoVAoFAqFwiJRFDGFQqFQKBQKC6Ao\n", - "YgqFQqFQKBT2MJaUIob3pryX5N0o70CvvvrqiOjTG0xNTXVxFARDfvGLX4yIYQl/3oU6ONg0K9AP\n", - "8H6Wd+m8O0XGj33sYxExTNWfnJzsxRcgH9Q2lNnnnS3vyh3b8Hd/93cj/cwKc1r2iy66qPcOl37y\n", - "+Z//+Z+P6IXPkcFxR7QNRQTvxvkeeuF9/qc//emu5L+DSBkDdEjb0JXwjtuBzfT7iiuu6PrZ9p+x\n", - "4n3/k08+2ZUU8LWmIaK/UD4wnvQP/TlFHVkyKoRW7r/5m78ZkYV+cm90SGwI1Aam2nHKOnEI0DJA\n", - "ndC27SJ1XIssDqbnd4JCoatAFuuc2ArmxT/90z9FxC6qFeTmWtYFOjKFh4OkHQsBpQg0LtaL+3r1\n", - "1Vf3xt/6od+sUahwnHrP+iDW44477oiIoc6zOb58+fJObuYK/TI9B21AywNFDHPOemTeXH755SPt\n", - "gzbmBJ1AJ+Pxz4LuGX/Lztwmzod2LEtbFNSxnbTN+DOfTc+U0VuNCx5uQV/R4+zsbPcd5ivjC0UI\n", - "c8vxXCS0MBehlHn3u98dEcMgZJdb4XrW3cUXX9yLnUXXfAf6MdObAX5Htttuuy0ihs8uB4AT38N9\n", - "rrvuuq6f6IN7E0vHuv7Hf/zHiOjvo8AJEx//+McjIuKSSy4ZuScyt/sva462XQzT9DPsi36mu21+\n", - "Z0/3Hk0c47Jly7q2b7nllogYzhUnshCnyPmBuZuhPFKFQqFQKBQKi8SSeaR27tzZnUApwEmGnTMf\n", - "nK12+OGHdydLp3VzOrUV4OKfAGvIHgusXWcQtCds7oEMpOVabqxgLEsKCjqd3cUDsRoozOlCpTt3\n", - "7uy9s6WIn/sPnGGIZ4nMqbbtiH7RNGRuM5BsUSCTs04Af3fBTqwAZ5BwLxcHBC4+GjHUHbKRueF0\n", - "VvrnQnuUZnDBV1tN4PDDD++8OsDUHswDMsKyNF57AR577LGIyDNUI4ZWOpYlcyZrG/2cdNJJEdHP\n", - "2rLHhbmNF5C1CtosHuRGR1lKOLrH60OWqte/vcTolfXQFs3zfHXquLP2TIXEGPG5M6U8p50m384L\n", - "r3/2CbwAHiPrnAwpU0UZptraunVrmhHINYwnxSHvu+++sbKga/TmMgruK7LOz893NCQuauhsTpO5\n", - "u3SFiwkzD0jhZ96AliaI7zgDGphAGO8F+4VLd5hQGi86RYG9LtpsXnSPLFnbgPnCmvPeZQ83MpHB\n", - "7fIqbT8pyEoG7Ne//vWR61zmw29TvEf7ecPvyNzuXawHe2b9/DB8vcscAOuxfZvifdu0TTzf2Ms9\n", - "RhnKI1UoFAqFQqGwSCyZR2rfffftvVfmBO46Uj6hTkxMdNaI66W4/ocJH7PTLtdhkWDt2lKn3enp\n", - "6a4tTrG2vE1tQ20nxwIATtbooy24GNGvmzE1NdWjE6C4pftJv7BeTM9hz54teq7j89YbMq44Y/vd\n", - "jLQWmandhez2jrk9PFJYus8++2xHkeKaXQAvkGv5uC6OC9G5HpNjaVrrJysk6MKc/LRnzZ49y5IV\n", - "6ly1alWPTDSrl4PO7Zm1FefCm8y9tWvXjlz/7//+711fHU+F5b0QOW9GDA6wit1HEymPa8sFei0L\n", - "nhbTj/DTenQfXIeqpQhBbq6xZ82WtGu7mYw2I5b1XjcYDFK6KsfdsYYWKlSMHvC4eI06dmZ+fr5r\n", - "03uR6/x4PmT15/ictYpHz3sXMszOzna65jte/yZzZr5QUJJadW6bezLerItxbwJcJNbjBkzO7rps\n", - "1gufM+78tAcsYuhRQj5q1EEnQyFS4BpPrg1nWTIaMLyqbV1Dxyt6L8q8vvbMZjFztIs+23VmOR0b\n", - "xd+ROytYbZRHqlAoFAqFQmGRWDKP1ObNm3vZWq5CbWCxPf300yOeoRa2grAYMk8Fbbp6OqdkWxht\n", - "zAVxBlivPkmb4BMLHe+YY6psPfM7mYm2ptv74dX53ve+FxF965Vr0Rc65921rSP6beLHcRWC6Z/f\n", - "cWc6d/V5UyIsVNkarwrewrav9NOWB5ZoVh3aWYnHHXdcRPQtL3sJ+f4zzzyT3tNtYO04dgR9mbwY\n", - "WQxknpyc7LKpsNIzuZlT6Pzb3/52RPT1BbgeTwT3JKsJ7Lffft240i/GwqTTjqFiHDNyZvpCe+wT\n", - "fK+VvY2PaX/PaIzsBeTezEF7mV1VGcubOdnuR6aZIq4IubMq7LTNvsK68Nx1rAk48MADe2sPfbTE\n", - "7xH9WElgD633JI+pPR6rVq3qYnTskTL1lb2oHiPaNFUWJL32GjNGs7OznR5YFxnll6lvTDANHJ+D\n", - "d/nf/u3fYhy2bNnSq+RuJg9gkntTvXic7dlEVuZX6x11zBsxoMRfeb/wWxDHs2Vj6njQcd5FrzXa\n", - "zjJKXXXeFGveuxh/xz/Pzc31nnPokHvzXESHRVpcKBQKhUKh8AJjyTxSmzZt6t7TmqzQMVKcFvk5\n", - "MzPTe88OHMvjekL2YDlbwxkl2fv66enpnlfMVqDjabhH5gXiXr4n7drj1VpcjnGwxej+79ixIzZs\n", - "2NB5MmypmWvIBKPj4Joqjm0BjI3rnriumGVHRiwze6raa21J24MEXOvIdbk8Fs4UaT09WYwc9+bv\n", - "jP9+++3XZXC2/Xd8Qhb3hLU0OTnZs748F71e7CW1h4n+ubabY0za6z1OeGC85mjDNWfskQN4RzK+\n", - "xNY6xlp1PIozYsFTTz0VRx55ZC+GzB4ZYH2Acdxs1pX3Jq85e31Y03hTLIut/jZjzla9ufLsUcji\n", - "+zx2eJmy/YaY1a1bt/b2AfcTfTzxxBNxxBFHdG1mhNPonCxP1q69Ri1v4jii9xYeZ3uBrBfmh/cX\n", - "Pnc24z777NPbgzLPCx5IPuenn2Eg05NrBLb99pzhmbRhw4aReDB7gZjLGa8s4O+uU9fK7lg4xz4t\n", - "tAdn88kymPN12bJl6bxlDnkdP18WliXzSDlNtLD3UWOw9KC0QWFpUGtg6cFrxsLSgYSGwuJQXHuF\n", - "QqFQKBQKC6C49gqFQqFQKBT2MJbkIPXrv/7rS3HbQqFQKBQKhf/X2N25ZUle7RUKhUKhUCi8GFCv\n", - "9gqFQqFQKBQWiTpIFQqFQqFQKCwSe/0g9bWvfS2OP/74OPbYY+Oaa67Z27f/pcWaNWvi1FNPjTPO\n", - "OCPOOuusiNhVYfvss8+O4447Ls4555weZ1Xh/xv+6I/+KA455JA45ZRTus92p/Orrroqjj322Dj+\n", - "+OPjrrvuWgqRX3QYNwaXXXZZrF69Os4444w444wz4s477+z+VmOwZ7Fhw4Z43eteFyeddFKcfPLJ\n", - "ccMNN0RErYO9iWwMah3sQQz2Iubn5wdr164drF+/fjA3Nzc47bTTBg888MDeFOGXFmvWrBk888wz\n", - "I5996EMfGlxzzTWDwWAwuPrqqwcXX3zxUoj2osXXv/71wfe///3BySef3H2W6fz+++8fnHbaaYO5\n", - "ubnB+vXrB2vXrh0899xzSyL3iwnjxuCyyy4bXHvttb1rawz2PJ544onBvffeOxgMBoPNmzcPjjvu\n", - "uMEDDzxQ62AvIhuDWgd7DnvVI3XPPffEunXrYs2aNTE9PR1vectb4itf+creFOGXGgPlFfzDP/xD\n", - "vP3tb4+IiLe//e3x93//90sh1osWr33ta+OlL33pyGeZzr/yla/EW9/61pieno41a9bEunXr4p57\n", - "7tnrMr/YMG4MIsbXg6kx2PM49NBD4/TTT4+IXZX4TzjhhNi4cWOtg72IbAwiah3sKezVg9TGjRtH\n", - "ytCvXr26qtruJUxMTMQb3vCGOPPMM+PWW2+NiF30GJARH3LIIR1dSOGFQ6bzxx9/PFavXt1dV2vj\n", - "hcWNN94Yp512Wpx33nnda6UagxcWjzzySNx7773x6le/utbBEoExeM1rXhMRtQ72FPbqQaoqmi8d\n", - "7r777rj33nvjzjvvjJtuuim+8Y1vjPx9YmKixmcvYyGd13i8MLjgggti/fr1cd9998Vhhx0WH/jA\n", - "B9Jrawz2DGZmZuKNb3xjXH/99R2fHah1sHcwMzMTb3rTm+L666+Pl7zkJbUO9iD26kHqiCOOGOG2\n", - "2rBhw8jJt/DCAYLogw46KH7/938/7rnnnjjkkEPiySefjIhdxKGQoxZeOGQ699r46U9/GkccccSS\n", - "yPhix8EHH9w9vN/1rnd1ry1qDF4Y7NixI974xjfG2972tvi93/u9iKh1sLfBGPzhH/5hNwa1DvYc\n", - "9upB6swzz4yHHnooHnnkkZibm4s77rgjzj333L0pwi8ltm7dGps3b46IXSzwd911V5xyyilx7rnn\n", - "xu233x4REbfffnu3wAovHDKdn3vuufGlL30p5ubmYv369fHQQw912ZWFPYsnnnii+/+Xv/zlLqOv\n", - "xmDPYzAYxHnnnRcnnnhiXHTRRd3ntQ72HrIxqHWwB7G3o9u/+tWvDo477rjB2rVrB5/4xCf29u1/\n", - "KfGTn/xkcNpppw1OO+20wUknndTp/Zlnnhm8/vWvHxx77LGDs88+e7Bp06YllvTFhbe85S2Dww47\n", - "bDA9PT1YvXr14K//+q93q/Mrr7xysHbt2sGrXvWqwde+9rUllPzFA4/BbbfdNnjb2942OOWUUwan\n", - "nnrq4Hd/93cHTz75ZHd9jcGexTe+8Y3BxMTE4LTTThucfvrpg9NPP31w55131jrYixg3Bl/96ldr\n", - "HexBFEVMoVAoFAqFwiJ6dsjvAAAAYElEQVRRlc0LhUKhUCgUFok6SBUKhUKhUCgsEnWQKhQKhUKh\n", - "UFgk6iBVKBQKhUKhsEjUQapQKBQKhUJhkaiDVKFQKBQKhcIiUQepQqFQKBQKhUWiDlKFQqFQKBQK\n", - "i8T/A2aklexSCttuAAAAAElFTkSuQmCC\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "filters = net.params['conv2'][0].data\n", - "vis_square(filters[:48].reshape(48**2, 5, 5))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The second layer output, `conv2` (rectified, only the first 36 of 256 channels)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJNCAYAAAARaCA+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3VmQHWd5//FnbO37OqPRaKSRtXgsy0tsAQJMGeMFXAES\n", - "EuLEkISCcBOqcoFTgRQ3mFQlOBdJqkKKqn8BqSJcEKiQ4FAE4TLBAhvLWizZ1jraRtKMZkbLaN8X\n", - "/y+cefXrV9Otnvf0ds58P1dP6/Tp7tOnT0/rfd73eZvefvvttw0AAAAjclvZBwAAAFCPeIgCAAAI\n", - "wEMUAABAAB6iAAAAAvAQBQAAEICHKAAAgACZP0StWbPGOjs7bdmyZfb3f//3WW8eAACgEpqyrBN1\n", - "7do1u/POO+3FF1+0trY2e9e73mXf//737a677spqFwAAAJWQaUvU+vXrbenSpdbR0WFjx461P/qj\n", - "P7Lnn38+y10AAABUwpgsN9bb22vt7e1uecGCBfbaa69F1mlqaspylwAAALl5+OGH7aWXXhr2tUwf\n", - "osp+QOrs7IwsHzlyxMWDg4Ox75s2bZqLly9f7uLdu3dH1jt16lRNx7do0aLIck9Pj4uvXbsW+74F\n", - "CxYM+54kmqUt63uZM2eOi/1zN2bMjUtv0qRJLvazy/q+pHM0a9asYbd38uTJyHpnz54d9v3jxo0z\n", - "M7OrV6/amDFjbMqUKcO+Z8KECZH36fLAwICLsz7nEydOjCxfuHAh0+3XK71e9DszMzt//ryLW1tb\n", - "XTxz5szIepcuXXLxnj17Uu23ubnZxXrtmZnt3Lkz1TbU2LFjXXz77bdHXrt48WKqbcyYMcPFei78\n", - "e4beh06fPu3iEydOpNqP/xut9Vr3P6/eN/Q35dPP6//Old7f9fPqfcLsxj3A355+Nz69J12/fj12\n", - "vdmzZ7tY7+dmZm+88caw75k+ffqwx2NmdtttN5JIzNyWn69+9atmZva1r30tdp1M+0StW7fOnn32\n", - "WVuzZo2ZmX3961+32267zb785S/f2GGOf9DHjx8fWdabY1r6Az527FjNx1SWoh6i9OZgFr0h6kPs\n", - "aBByzvVh0szsox/9qIt//OMf13xMn/70p128a9cuF2/cuLHmbSdZsmSJi/WPweuvv57pfvSc+30v\n", - "r1y54mL943nu3LnIevqwldZHPvIRF585cyby2iuvvDLi7RXp7rvvdvG2bdtG/P6sH6KqSB9C/f+w\n", - "JP1nLo7eJ48fPz7i94+Gc15FQ+e9qakp9mE10z5Rq1atst27d1t3d7ddvnzZfvCDH9jHP/7xLHcB\n", - "AABQCZmm88aMGWP/8i//Yh/+8Ift2rVr9md/9meMzAMAAA0p04coM7Mnn3zSnnzyyaw3CwAAUCmZ\n", - "P0SVKaQPlK+e+0EVRTvf+50zt2zZUvTh1LWrV69Glnfs2JHp9rWP3+HDhzPddhL9LWb9meJ0dHRE\n", - "lrXT///8z/+4+PLlyzXvS+8T/ndYdSH9oBpFS0uLi5M6rWvfzpA+UGbRe2NIPyjUB6Z9AQAACMBD\n", - "FAAAQICGSudVnQ77NjPbu3dvSUcycvPnz3ex1sh58803yzicytOis2Zmhw4dSvU+LUOQln4fflmJ\n", - "b3/72y7+0Ic+NOJth0pbzywtHdIdN9TYrwGmw8pDUzJxNG3t1zmqGv/4sj4XWsNMayppWYlQmhLz\n", - "6wBu3rzZxWkr9WiKV1PdZmYrV6508bp161Jt75FHHnGxXyrDLzSNxkRLFAAAQAAeogAAAAKQzitQ\n", - "1s3oRdKRXUWO8krrsccec/GLL75Y2H790YlD/PRd2ikqQiRVhtfq3HFT3pRJ0yG//OUvY9fTdM3k\n", - "yZOHXae7uzv2/Vn89jRtpVWsqz46L+/7jl7bWU9HpFP0+OmykMk2Dhw44OKlS5dGXtNRi2mn2km6\n", - "ZhHOn8mhqN+Yv980aIkCAAAIwEMUAABAAB6iAAAAAjS9HZJYrmWHo3j26XHjxkWWs6icHEe/1kY8\n", - "5+95z3siy9u3b3fxmTNnij4cM0t/zn/7t3/bxT/96U9zPSY1fvx4F2dR3T8Ln/nMZ1z83e9+d8Tv\n", - "13Pu/750WfuGhWptbXVxX19fzdurV/6fDC1rkHXflZDK4X4/Rb8vVZXFXWP+OW/Ee7p+b/51lOff\n", - "yiRD572pqSm2Dx4tUQAAAAF4iAIAAAhQSjpvqGps2mGkGLmqp/NWr17tYi0H0NvbG/ueNFWry5T2\n", - "nOtEuX5arVHSRNo0n2c6pcjrXL+3pHIKWgm7ESc09397OpuBVikvMoWq1cz9c16178BPO3/wgx90\n", - "8caNG108ODjo4kZN52nZEJ15QUtRlIl0HgAAQE54iAIAAAhQSjrvgQceMLObJ6+teuXfWs2aNSuy\n", - "rM21WYtLc2jzqVn2FYbTqvpIJ61cm/a6DEktTZs2LbKsKe6yRqTUEz3n/rUd113An8h2586dqfY1\n", - "b948F/f396c9xEq74447XLxv375U7/H/ZOhI2U2bNrnYH02n5+/UqVMuTroH6fEdPXo08lpZo3Dj\n", - "6OhXs+gk5EmpzTT3v0ZN582dO9fF/vdbBaTzAAAAcsJDFAAAQAAeogAAAAKMfMriDAwNZfQry+rw\n", - "2Ebkzz6fZ5+oOGX1gfJVsR+UKqp/nn/Na785/a7K+t5mz54dWT5+/Hgpx6G0hIDyZ2DXStpXrlxx\n", - "8f79+4P2q31eiirhkLcs7rl6H0uqKj5jxgwX63e4devW2Pfo8fn9B9P2ibrtthttBdevX0/1nrTu\n", - "vPNOF/t9erR0S1VmCKiaKvaDGilaogAAAALwEAUAABCglHTeUPN3o6fvfJpSAIajqRGdfLUs06dP\n", - "jyynTecNzUpglv3MBH5afMjZs2cjy1OmTHGx/vZCUytTp0518eHDh4O2UTVp08SaEvP5Kd8h/pBw\n", - "LdmhJQ6SZFFtPOsUnl7bu3fvzm0/qA+0RAEAAATgIQoAACBAKem8MkalVYGfbsDoNHPmTBefOHEi\n", - "dr2kkU5FSVvF2pfn5OJpJyfVCuZZ/PZ6enpcnJSar3o1fpU2tZmUqtJq3JrC27t3b/iBlUyvHT/l\n", - "mee1jfpDSxQAAEAAHqIAAAAC8BAFAAAQoOntuKmJ89phU5ObubkRqpWa3TwMPG747rhx4yLLOuQ3\n", - "a/q1NsqM32np0PYi+6HV0znXc2RWvf56Wm3cLL4PUhXOeVtbW2RZSyHs3LnTxUuWLImsp5XOq953\n", - "Svl/MvI871qlPO+SOB/5yEdcvGbNmlz3NVJFnnPcMHTem5qabvoOhtASBQAAEICHKAAAgAClpPOQ\n", - "vyqkOYr0vve9z8Vvvvmmi+s5nffII4+4eMOGDZHXqpZ+K0uR17mmlhYvXuxiv4q7HpOWqfjTP/3T\n", - "yHqvvfaai9euXZvZceYt69SSTrptFk3dasoztOSHTnys+2pubo6st23bNhenndy4KFVJ5+kk31r2\n", - "olGrtZPOAwAAyAkPUQAAAAFKqViOd2gz88mTJ0s8kvqzfPnyyPKOHTtc3Ciprl/+8pcu9kerjWb+\n", - "KNei6IjG+fPnu/jIkSOR9R588EEXf/SjHx32PWZmv/jFL7I+xErxRy3HVfrOegaLT3ziE5Fl/e1o\n", - "FfV169Zlut/R4OrVq2UfQuXQEgUAABCAhygAAIAAPEQBAAAEoE9UiZJmgsc74oYkHz58OLJe3tWM\n", - "R2ry5MmRZZ3pPgTXyg2TJk0qZb/aF0urkmsfKDOzD33oQy7WfkHf/e53I+tt2rQp60OsFH9GhkuX\n", - "LtW0vY6OjsiyliHQ72Pz5s2R9bq7u2vaL5CEligAAIAAPEQBAAAEIJ1XolpTPKNBa2vrsP9etfSd\n", - "b9WqVZHleqpInTU9Fxs3bgzaxsyZM7M6nGCaWh4/fryLb7/99sh6J06ccPH69etd/KMf/SjHo6ue\n", - "CxcuZLq9pLScXzU+S/73G1o5HY2JligAAIAAPEQBAAAEIJ1XIp1EsuB5oOvGqVOnXNzX11fikYzM\n", - "nj17yj6Eyujq6nLxypUrI69t3bo11TY0fVtWOmVgYMDFOvLMr6Cuk+a+8MILmR7DHXfc4eJ9+/Zl\n", - "uu3Rxp8F4LbbbrQp6EjCrK83v4tCPd3XcDNaogAAAALwEAUAABCAhygAAIAApfSJGhqurEOBRyOt\n", - "ZqzDaPMcrltv9Bqpp6HFvb29he1r/vz5sa/5ld3LoP2Z0vaB8k2cONHFZ8+erfmYQuh3evLkSRff\n", - "ddddkfW0enbWw/ynTZuW6fZGM+1fZma2a9eu3Pa1aNEiFw8ODua2HxSPligAAIAAPEQBAAAEKCWd\n", - "51eAHa20qV9TALihXqu6+8Pe/clYs6QpT3/YdqNoaWlxcVnpPKXXpV9N/erVq7ntN8/rqEialixy\n", - "9oG5c+e6WMunJPG/35BuKAcOHBjxe1AfaIkCAAAIwEMUAABAgFLSeceOHStjt5WjKbxGaabHO4r8\n", - "PjUtnPVosKqoclrXP+da2TyLtJVOfFzkqM88hZwLPQ9m0WtCK4wn0fdoZfkkzCYxctqdodH/ttES\n", - "BQAAEICHKAAAgAA8RAEAAAQopU8U3rFgwQIXaz+KIof8oj6sWrUqsrxx48aSjqQc/f39ZR9CrL17\n", - "90aWx4y5cVvV4fGhv+sPfOADLn7++eeDttEIsqj0nbYflJo0aVJkWavV49a0pFE9zTqRFi1RAAAA\n", - "AXiIAgAACEA6r0Q6NLqvr6/EI2lcfnV8Ha58/fr1og8n2IQJEzLdnn9eGrGZvSj+hOGTJ0928ZUr\n", - "V0a8PU3zm5nNmTMn7MBGkbvvvtvF/m9l06ZNI97ekiVLXBw6ibdOmq0TEPsVz7UrR6No9LIGipYo\n", - "AACAADxEAQAABCCdV6Jdu3aVfQgNr97SVM3NzS4+cuSIi19++eVM9+OfFx2BFDKCCTeETFCrfv/3\n", - "fz/T7VWFpjm1cviUKVMi6+lvYN++fbHbW758uYv1HIWm35TOJhE6C4C+b+fOnTUfE6qJligAAIAA\n", - "PEQBAAAE4CEKAAAgQCl9om677Z1nt7yHmDc1Nbl47NixLh5Nwy9RX7QfVJE6OjpcvH379lKOoVba\n", - "l8YsOtRd+8ycOXOm5n0N3cPMsrmfzJs3z8XTp0+PvPajH/0o1Ta0OrpWTT969GiNR5fetGnTXDxj\n", - "xozIa34piCFnz56NLMf1QdJzbmbW1dUVcoixVqxY4eKsS4qgcdESBQAAEICHKAAAgAClpPOKqhSt\n", - "Q2d1SO1oM3v2bBfHNaljdKvXFJ7ySwPs37/fxb/61a8y3VfW97B77rnHxYcOHYq81tPTk2obOjGu\n", - "n/rKk1ZU1xkB/HuNVsmfO3eui/10Y1xZkrz/bujnCLletCyCWXzaWO/HZtHyIv53j+qjJQoAACAA\n", - "D1EAAAABGqpiuY4MMYs2H2fRFNze3u7iLJpd4yr4Zu3ixYuZbu/BBx90sT+SphHSQmgM+hutehX2\n", - "e++918U/+clPgrYxfvx4F+to5CxGIybRkYD9/f2x6+mEvKdPn871mELUmvK9dOlSqvX8NGetXSw0\n", - "DekfQ97fPWiJAgAACMJDFAAAQAAeogAAAALUfZ+ocePGubi1tTXymlb+1WGzb775ZmS9K1euDLvt\n", - "BQsWRJa1n0Fa2k/LH7qrw3y16nHc8YRK299Kj9X/7PqaVld+7bXXajy6arr77rtdfODAARf71ZWr\n", - "TvsFxg0drzd+38chP/vZzyLL3d3dBRzNzZYuXeriPXv2pHrPW2+95eLQStxLlixx8dWrV128a9eu\n", - "oO2lldQPSsVVIm8URc6E0dbW5mL93v2+v1u3bnWxlsCoCi1DVNa9VWc20fOaFi1RAAAAAXiIAgAA\n", - "CND0tpaYLWKHTU1W8C4BAACCJD230BIFAAAQgIcoAACAAKWMzuvs7DQzs7vuuivy7zox47Fjx4aN\n", - "zaKjjGbMmOHi++67L7Le2rVrXbxu3boRH6dW5jYzmzVrlot10kitxGsWHf23d+9eF/vVZFeuXDls\n", - "rJXMzaIVgXWSS39UjI6+0KrHOvoA+dHm3rLOuV6XZtWv1B0i7j4xYcKEyHo68kdHq506dSp22zry\n", - "r8iq2jryN3R0rt6HdKRY1qMy/bRG3LWuI6f9Y9LvKu2MCv7IKR0lvGnTplTbyIJ+3vnz57t4YGAg\n", - "sp5ec7VKe87zpr8prbKvs3mYRauw68wBu3fvjqyX9aTS+rcyi/OfpusRLVEAAAABeIgCAAAIwEMU\n", - "AABAgFL6RA31afD7/mj/jaNHj7p4x44dkfU016lVybU6s5nZtm3bajpOv9Kv9lvS/Pfg4GBkvZ6e\n", - "nlTb12qyfX19Lvbzy5qH1kri2j/KrNiKuUg2fvz4yHLaGd5rVWQfKO1/lfd+tQp4XAV+v++P9stI\n", - "K+t+UIsWLXKx349FK+HPnDnTxUeOHAnal1YEb2lpcbHfVydr2i9Iv5szZ87EvidtPyjt4/KhD30o\n", - "8pre78vqE6XXXJZ9oKpKq4rrdZrUF1Pfk3UfKF8Z3wEtUQAAAAF4iAIAAAhQSjpvqMnXT3HEDdv0\n", - "hxlq2kpTZ3PmzImsl9ScnIY/IaI2FWqKMYsJgzX14JdM0OPQFF5zc3NkPS33gHIVlb4rU5GpwzQT\n", - "+WpKzCzaJaAsK1ascLGm5c2i5RmyPlZN4fkTp2c9wfnhw4cz3Z7SlJ2WNDAz279/f277TUpVa0oq\n", - "afJl/XvWiLN0aDrPT7Hr32i93vwuPHqfrNd0KC1RAAAAAXiIAgAACFBKOm+oGdYfTaejPLTp20/T\n", - "aepLR2/cdlu+z4RdXV0uzrpJXJt+tTK6WfRzaYrSP39+GhColZ8ivv/++1380ksvxb5Pm+31uvRn\n", - "H8iSPyJSj12r+RdJj8k/l353gbxkfa9KknXFaK1s7n+Hed7vsjj2hQsXulhHYjYKHclaZHX/qqEl\n", - "CgAAIAAPUQAAAAFKSecNNf3pRL1m0SZUTe1pQU2zaJOxpgf03/OQZ5OlFuVbtmxZ5DWdMFXTeTqx\n", - "o9nNE7CiPP53kba4YAgdtZQ0Wkj5qSVNlWgq7rHHHous9x//8R+ptq+jc+KKY+ZNP6MWoixy5KTe\n", - "n/zfa1n03qrXSxaFEDWFtW/fvpq3p5NN+2lJ/buQ9Ui4LAoXN2IKDzejJQoAACAAD1EAAAABeIgC\n", - "AAAIUEqfqCH+MFKd8FeH9fsVY3XSR10v78kN86QlHfw+G3GVYf0+YH41WJTHrxKdZ5+otP2gVNKQ\n", - "f73G0vaB8uU5rN6v/D3En/hbvwPto+ZX+s+6r5KWNdB+QWWVWfBlXWFcS634k0DXSvsm+aVutBSM\n", - "ftdMxI4i0RIFAAAQgIcoAACAAKWm83yaxtqyZUvsenEpvDxTJnnTY/eb23WiTT1HfsooLs2B4tU6\n", - "+fVoNHfuXBe3trZGXnvrrbdcnLbSt6YUNc77u9FuCnlOzptEU/t5l5jQFF7aYf06kXrS96H3NP/+\n", - "rqlSTdH6ad1GpJNtnzhxosQjAS1RAAAAAXiIAgAACFBKOm/atGlmdnMzc9qRHXGj8Op5EsSBgQEX\n", - "Dw4ORl6La+72R/ssWbIk+wNDkEmTJkWWdcRQyOSmfgV0rcYdMjov1IIFC1ycRdpk3LhxLj569Oiw\n", - "cb3JeoRaCH9y8qppaWlxsf93QO/vmqrasGFDZD2d5aGzs9PF9ZbO03OhfweSPProoy7We4GO5Pa3\n", - "19fX52L/nqG/w6Imxq6KWifNpiUKAAAgAA9RAAAAAXiIAgAACFBKn6ihYfpV6DtQFSHDro8fPx5Z\n", - "zrNKNEbGr7JfK394d5H9oFRIfxMdfu732aC6dHa0greWgSlS2tIFBw8edHHSTBNJfbve/e53u1j7\n", - "IL744ou3PM4iaOV6/W60b5JZ2L3i7rvvdnFHR4eL/XIHu3fvdrGWCUmaBaQK2traIst6PWvf5/b2\n", - "9sh62p9Lz7M/C4iWU9H+YL29vSM+VlqiAAAAAvAQBQAAEKDUdJ7f5FzPEwiXwU/f+akSIE/aJJ5U\n", - "kqAK16VW92/UtLemdbRMyrFjxwo7Bk2/+WU+NIWUNo2rfyP8lJMOR09bEuPhhx928dq1a1O9J5Re\n", - "Z9OnT3exn84L6cqh29BzuX379sh6e/fudfHWrVtHvJ8izZs3z8X+ZNOaptR0Xuhn0meNWmf6oCUK\n", - "AAAgAA9RAAAAAUqdgJj0XbbqeQJm5GPlypUu3rFjh4uzGI1TT1XFGzGF50/SrDMY+KORinLhwgUX\n", - "J6Xz0tJ7mv/3QiuYb968OdX2dIRa3jQV6afwarVp0yYXa8X3nTt3ZrqfrGkXALPo71JT7n4Ve628\n", - "/vbbb9d8HDqy3R/lPlK0RAEAAATgIQoAACAAD1EAAAABSu0ThWzpbNSAWfWHNWcpqb+F9hdKS4dc\n", - "m5VXJT6O38fo1KlTsa8VRftiJfXLmjx5sov9/i9qxowZLp49e3bkNe3Lcvjw4VTHp6Uf8tbU1ORi\n", - "/W6y8Oabb7q4nvr7+d+1Xqchv9EqoCUKAAAgAA9RAAAAAcj/VJAO9TRL31xbT826QNb863/BggUu\n", - "DkkVVC1958s6RVSkpBSe0rSfP7muVkcva8LlJHnej8u61+t51u9GY7Po96vlVMpKM+epelceAABA\n", - "HeAhCgAAIMCoSeeNGzfOxWknv/QtWrTIxdpcmTTBpzZ/pq3QHtpUqxMzAo1KRz0pv5KxTuyq6QZ/\n", - "vUZMMWQh7jwX6Y033nCxP1pSRyPzHRajra3NxTqpsk//htVaEbzqaIkCAAAIwEMUAABAAB6iAAAA\n", - "AoyaPlGh/aCUDpPW/hZJdBhu2j5RoZL6ZgETJkxw8cWLF0s8ktrEzeI+derUyHJPT4+LdZi137dm\n", - "4cKFLt65c2cWh1iK9vZ2Fy9evNjFfl/JLVu2pNqenme/7EqW0pZ08fs9hfQB1b6x/nVEiZhbO3To\n", - "kIuvXr3qYv9vW6P3g1K0RAEAAATgIQoAACDAqEnnZUGbk5NSczo0uMgmYpqjkSQkhTd+/PjIctKk\n", - "smXzr39N4Sm/Ermmk2bOnOliP2Wv5Uqy6B6QNe1u0NnZ6WK/mrR2Mdi0aVOqbVeh+rb/fejniPuu\n", - "fZrOO3v2bKr3ZG3ixImR5QsXLpRyHLXq6+sr+xAqgZYoAACAADxEAQAABCCdNwJpm501BaLvSdvk\n", - "jOFNmzbNxVRnz49Wgq5i+m7+/PnD/rufYk97vWhaQkcc1RtNd23fvt3F/mjEgYGBwo6pVpp+87/f\n", - "GTNmuDjtyOSyUnhKR4Oame3ataukI0EWaIkCAAAIwEMUAABAAB6iAAAAAjS9HVf+N68dVmBm8Lzp\n", - "ENayhq/q1zoaznkVVPGchwwD12PP+/agv5UHHnjAxTt27IisNzg4OOz7k8659k1M6ts1a9asW+6n\n", - "nmVdpsK/JuKu9enTp0eWT506VdN+G4XfR80vuTGctOcc2Ro6701NTbH3QlqiAAAAAvAQBQAAEIB0\n", - "Xg50ItS0ExVnrYqppUbHOb+1jo6OyHJ3d3dN2ws5562trZFlrVh++PBhF9dzuYOsaakBPx1Yr9e6\n", - "VqA3Sz9B/KJFi1x84MCBTI8pDum8cpDOAwAAyAkPUQAAAAGoWJ4DnfCzrHQe6sPcuXMjy0uWLHFx\n", - "V1eXixtl1Fit6TszsylTptT0fiZOTUdTRlWccFmFzGagFc/N0v/Gar3+0FhoiQIAAAjAQxQAAEAA\n", - "HqIAAAAC0CcqQdaVfgHf0aNHE5dxszlz5qT6d+3Hk7afjNJSJf72GvFe0NLSElkeGBioaXt+KYk8\n", - "+6KFfL+h1X1CyhrMnj3bxcePHw/ab1H0Orhy5UrktUbpm5klWqIAAAAC8BAFAAAQgHRegtAm+zQT\n", - "SuZBSysAvgkTJrj44sWLqd6jk/OahTXn6zYWLlwYeU2rRmu6rL29PbLeq6++6uJDhw4Nux//99rc\n", - "3OxiHa6fdiJcv6L14sWLXbxz585U70tbBbsKak3f+caMqfafl9AJkc+ePTvi92gpkyqm8/S70omj\n", - "dYJws+iE5nQ9eEfwVd7R0WHTpk2z22+/3caOHWvr16+3wcFB+8M//EM7cOCAdXR02A9/+MObanEA\n", - "AAA0guB0XlNTk7300ku2efNmW79+vZmZPffcc/b4449bV1eXPfroo/bcc89ldqAAAABVEjwB8eLF\n", - "i23jxo2RUQednZ22du1aa2lpsf7+fvvgBz94U7M3EyfmZ8WKFS7etm2biznnxch6AmJ/dKhKm2rW\n", - "baR9j45yO3bsWOx6mj5euXJl5LW9e/em2katmPS5eGknw9X0sVn6FHLVaZr4yJEjhewz7wmINQWt\n", - "Fdn9e5Cup6l9fxRfo8h1AuKmpiZ77LHHbNWqVfatb33LzN7JqQ8Nj2xpack8xw4AAFAVwX2iXnnl\n", - "FWttbbWjR4/a448/bp2dnZHXm5qa+J8hAABoWMEPUUOF1ObOnWuf+MQnbP369S6NN2/ePOvr64s0\n", - "ewIAANSLZ5999pbrBPWJOn/+vF27ds2mTp1q586dsyeeeMK++tWv2osvvmizZ8+2L3/5y/bcc8/Z\n", - "yZMnb+pcTutUfu69914Xv/HGGy7mnN9w3333uViHyp87dy6yXlyO3x+yrsOBT5486WK/NMDq1auH\n", - "3ZffT+m1116LPXa8Y968eS7WKthc58UI7Z8zbtw4F2s5i6rz+/vpse/fv9/FefYLSjrneq/xyzZc\n", - "u3Ytt2MaDdL0iQpqiRoYGLBPfOITZmZ29epV+/SnP21PPPGErVq1yp566in7zne+40ocAAAANKKg\n", - "h6jFixfbli1bbvr3WbNm2YsvvljzQQEAAFRdtUvKYkS0aRnv8Iu9alrtnnvucXF3d3dkPa06f/Xq\n", - "VRf7E53Onz9/2P1qms/M7Gc/+1m6A66Y97///ZHlV155paQjuaGsGQFQmyqk8LQC94ULF2LXW7p0\n", - "qYv91PzGjRtdrGUcxo4dG1nv/Pnzwcd5K0uWLBn2GE6cOJHbPjE85s4DAAAIwEMUAABAANJ5DSRk\n", - "YsyZM2e6WJu6Dx8+HHQMkyZNcnGezdlp+aPfurq6XKyjaXp6eiLr6Ui7BQsWuNgfnacV+5WfHozj\n", - "p/1CJ0WNo6N4QiYnyDt9p1XP/RGSqD86QW0WI8NCJs1OkpTCU9oNwL8udRuBE37UTGcE0CriZR3P\n", - "aEZLFADlD3hmAAAgAElEQVQAQAAeogAAAALwEAUAABCg1D5R/rQw2ocmpH9PFrSPUNJw0ba2Nhdr\n", - "XyIzsz179mR/YCn4w/mH6Kzc/nmdO3eui/X78Kv0aq5dh/zPmTMnsp7O+t3b2+vizZs3R9bTPkd5\n", - "0pIGZtGhwdpv6e67746sp+ds0aJFLj548GBkPT1/yp/BXod3ax+GLPpAab8q3bZZ/DXsnxf93tau\n", - "XRu7L50jUz+jP5u99ofRod967ZiFlSvwZ5ZHuRYuXOjiadOmuXjMmOifF+2PmNRfUu/BKqlP1IoV\n", - "K1y8ffv2+IMVfukC/e3ofdIvzTB16lQX+yVPyuD308ySfz/RqvNZ9FFLS68lvYf71fL1mNL2S60V\n", - "LVEAAAABeIgCAAAIEDQBcU07TJjIDwAAoEqSnltoiQIAAAjAQxQAAECAUkbn+T3qkQ2trH3o0CEX\n", - "Z3G+Ozo6XHzgwAEXp03N/tM//VNk+ec//7mL16xZU9vBJZg3b15kudbJa5MqjOu5yPsa15GY+hl3\n", - "7tyZ6v06isosbJSRjpjxR90VpaxzrtXuR0Olda0s74/w1RFbWrHc/63oejp6078WdeSzjuz0f7s6\n", - "ckxHivqjvpcvX+5iHRXoT9iuv+Wka1tH7ir/Xqij+rTKuT+6VK+fY8eOufi3fuu3XPyf//mfkffw\n", - "N7QYaf6+0RIFAAAQgIcoAACAADxEAQAABCi1Yjmydc8994z4Pdp/QPs6+BWFa63++sUvfjGy/Lu/\n", - "+7up3qd9MUL6nvj9KLT6uPZT8Cuo+1WKh/gVxuOqxGtfDrNoH5oQfnVl/a527do14u35leZD+kSV\n", - "1Q+qLFopeevWrSUeSfGSfnvab0QrRvsVrbUfj/aP8q8j/a3o76unpyeynvYf0m3rb9wseq3r/UT7\n", - "ZfnHoZ/pzJkzFkfvi37/Ge2npb+vSZMmxe5XZ3mI63uFaqElCgAAIAAPUQAAAAFI5zWQkHSeP3Fs\n", - "UX784x+nWk/TCKtWrXLxli1bIuvpJNBJze9ankH5w441JRD3HrP4iZRrTd/5/Mlc49KNae3bt6+m\n", - "948GfkpWly9dulT04VSWpsiSJtTWdFdLS4uL/cm/BwcHXawpQT/9FrdtTfOZRScNv/POO1189OjR\n", - "yHp79+51sd5P/Anm9d6gaXX/XqDXiL8vpek9vcbiJg/Pwr333htZfvPNN3PbV6OjJQoAACAAD1EA\n", - "AAABSOc1EL/ZuV78xV/8hYu/8Y1vxK63cePG2Nc0haepubRpF389TeHpSKJa02gjoVXis04P4tb8\n", - "9FFc6rZR6e8oqUK2jqCLq9JtFq1mriPX9Do3i45K01Tc7NmzI+tp6kv35Y+Se/nll4c9Bv9+6R9v\n", - "HJ0NYvHixS7W+4SZ2YYNG1JtT0dC6znXc5S3ou5xmsY1MxsYGMhtX2m9//3vd3HIiGNaogAAAALw\n", - "EAUAABCAhygAAIAA9IlqIP6s6VnS/LxfibhW3/rWt1z8j//4j5HXtF/KX/3VX6XanvZvuu+++yKv\n", - "vfHGGyM+vpA+AqEVy7W6clwl4yJpWQkzs507d7pYh3cn0SHhU6dOjbyWtvK39mVJGuqepevXr0eW\n", - "0/aZaRRp+xPqta59XvxyB/ob0Nf84f/aV0l/D36ZD63if/jw4djj00rnv/71r108f/78yHq6L60w\n", - "7vex0uteP7vfxyqpH1kcPed+2ZU0pk2bFlnWe4j2vSqrpEGRfaD0u0m6/77yyis17YeWKAAAgAA8\n", - "RAEAAAQgnddA4tJOWaRCsk7hxW37mWeeiV1vwYIFLvYnI40Tkr7LQtr0nZ+C1bRp0mfUKsf+ZNFZ\n", - "2rRpU2TZT23EaW9vd7EeX1L19yRFpfCS+Ok93EzTef5EwPodakkSf4YB/e3o0Hv/2tPK5nrva21t\n", - "jaynvyNNxXV1dcV8imgqra2tLfKafkbdr59S1HSSHpOfJtXPoXbs2BF7fHGefPLJyLKmFP/93/99\n", - "xNtLa+nSpZFl/U6LTOHp/VOrsj/++OOR9f72b/82s33SEgUAABCAhygAAIAApPMaiE7Wq7QZ3R/h\n", - "ElKhNURodWCVNoVXRZqW0IrMftN+2s+YZwpPpU3f+bSqcxIdYaXiUhxlSvuZRpvbbrvxf3G91/i/\n", - "eU2DHT9+3MV9fX2R9XQbWhHcv+b1fXof8+9xOkGyHqt/fDoZu/4um5ubI+vpNavpI39EbtqK4zqi\n", - "rru728Uhv71XX301shwyKX2IPXv2FLKfW9GuIevXr3exPyl1lmiJAgAACMBDFAAAQAAeogAAAALQ\n", - "J6qBLFu27JbrZNEH6oEHHnDx66+/nuo9eZZIqCKtfmwW7QOSRX+fPCvI50lLM5hF+7/4Fa5RHUnV\n", - "txcuXOhi7Rfk/wZ0Pa1cf/Lkych62vdMywv4fZO0/5D2B02qXq6lN5L6RCm/3572b9R4xowZkfW0\n", - "b5b2AfX7gGXp4MGDicuNTs+5/q3bt29fbvukJQoAACAAD1EAAAABSOc1kNmzZxeyH03h+RNe6sSd\n", - "KnSofNb0eDVFEZpK8tNTQ/IcUmtWXyk8VVRpBmQr6fervyNNM/sTVOvk1Zqa6+joiKyn14j+Lv2S\n", - "AWlLCCithp62krZ/zfqTaA/xP69WuNf37N69O7Je3L0n7t6CeEWV7FG0RAEAAATgIQoAACAA6bwG\n", - "EjfqSytk+03OSifDTZveikvfZUVH0IRUOffp8Wr14lB+deRaFTXqbv78+ZFlHSFFyg0joSkyTZf7\n", - "1fi1qrWmu/3Rb3H3IT8NFjKxbX9/f6r1dNJ2fz9639DRef79V0fk6mfUyY397SmttI7qoiUKAAAg\n", - "AA9RAAAAAXiIAgAACECfqAaiOXiV1A9KVbFidJ5DVnUIsj+cOG2/oLg+YX515bhqyL4FCxa4WCsb\n", - "a0XmLCRVdQZGQn9HJ06ccLH/G1Baldy/trXqufY5yvo3kET7kfr77erqGnY93+XLl12sFbO1v5W/\n", - "Db3vZPF5s+5TWjX++U/7ty5LtEQBAAAE4CEKAAAgAOm8BqLN4PXKnxS0qCborIf1p03f+TQlW2T6\n", - "AgilaStNE/uVvbV8h6a0/N+KVkfX+4FfoTzP1I2WIfBLEmgKX2O/qrumIvW8+J9j7ty5LtZ7eFxl\n", - "9JH44Ac/6OINGza4OO8ZFYriT3JNOg8AAKBO8BAFAAAQgHReHdOJP80aY/RF0mcIqaheb3R0E1AP\n", - "dAStpsWvXbsWWU9HUmnaSiuem0UreGuqr8j0tu7XH02ny5rO0/SdmVlbW5uLdQTj0aNHI+vp549L\n", - "ZYb62c9+VvM20vCrzut3mGfqsLu7O7dtp0VLFAAAQAAeogAAAALwEAUAABCAPlF1zB9S2+iy6AdV\n", - "VAVff2Z2Xc6zCnvW/OHdly5dGvE29LP7ZThCtodqGRgYcLH292lpaYmsp0P7x4y58afH/x36fYuG\n", - "+NdO2t/vzJkzXRzS59Dvi6W/icHBwdj36fB7nYnAL3Ggv4HJkye72J9FocqSzkOjoyUKAAAgAA9R\n", - "AAAAAUjnNZBam3+1Qu6ZM2dqPZxKunjxootXrVrl4o0bN2a6Hx3SPNxylc2bN8/F/f39NW9PPzvp\n", - "u8ajpQz093XgwIHIegsXLnSxprT8EgdadVqHx6edkWHatGmRZd2XVgfXYzWLpgc15R43yfitaOpw\n", - "0aJFLvbv0/oZtfp7Pd0z0vJLIWj6Uielrie0RAEAAATgIQoAACAA6bw6piNczG5uKh2pRk3hKR3R\n", - "qCk8HcFjln4Uj181Pg1NN4SmCtIKSdEy8TFGIm60aW9vb2RZf1N6Xfqj1TSlFVLt2h9RqsuaEvRH\n", - "0CpNKYaOgtZRi5ra9O/Tev40pdjc3By036rRkYn+iMp6TeEpWqIAAAAC8BAFAAAQgIcoAACAAPSJ\n", - "qmN+X4TRXDW2ViGVjM3C+kvk3Q9Kad+OtEZD3zhkR0scKL+chS7rdTllypTIerfffruLtd9n2kr/\n", - "fskE3YbGWlHczKyrq8vFWc8Gof3DDh48GHkt7n4we/bsVNueMWOGi0+ePBlwdNnTqvP6Xed9fNrf\n", - "rKi/h7REAQAABOAhCgAAIADpvAaS54S6GJ42pVfRaJukGsULue9oyi1tKt0v6aLpPS1doJOMm0VT\n", - "S/oef3vnz59PdRxp6b40jZX2N5n2eKqSwlNa+qXI4yujSwstUQAAAAF4iAIAAAhAOq+B6KiWeuVP\n", - "MuqPtEF986tJ6yTQx48fd/HOnTsLO6aq8Staa1rHnzR3NPGvHZ3UV0f++VXO9R6iqT2/Yrm+lvV5\n", - "DkmrVzFNl9ZommicligAAIAAPEQBAAAE4CEKAAAgAH2iGkgj5KHrrQ9UPfdbKMPkyZMjy3v37nVx\n", - "f39/0YdTSX7fxqr3g8q6NID2i9T7gV/ZXNfTqtj++dLh9lrWwK/mP2nSpNhtlMHvs4V8aL/My5cv\n", - "j/j9fEsAAAABeIgCAAAIQDqvjiUN0UV2dCi1P3z63Llzme7r4YcfdvG2bdti95s1TXNoyu3UqVOZ\n", - "7odJsm/t6NGjZR9CqeJS+v7E2Jp60XuhP4uATuSrKUD/WtQyBJoCLKvqf0hqqSz+ZM7ataTqE5pv\n", - "3LixpvfTEgUAABCAhygAAIAApPPq2PXr1yPLBw8eLOlIGtuBAwdc/Cd/8ieR1w4fPpzpvtauXZvp\n", - "9tLSyVInTJjg4qzTeUAofxSgLuukw5p+NzNrbW11sV7bmuYzM+vp6Rl2v3466tq1ay7OM9WXxUjl\n", - "mTNnuli7HmSdKvS7G7S3t7v4ve99r4tfeOGFTPdbBbREAQAABOAhCgAAIAAPUQAAAAHoE9VA/Iq+\n", - "Q7QCsubzq2jatGmR5dOnT2e6fR2Kq9XGW1paIutp9Ww9Z9/73vdit9cosq5AnZZ+90nfe3NzcxGH\n", - "gzpy4cIFF/vXjt4XtZ+Rfx0dP3582NgvJaP9B8uifZ1OnDgRu17Sa3k6dOjQsHEjoiUKAAAgAA9R\n", - "AAAAAUjnNZC2trZh/33+/Pku9ofkp03vaUXrPJuzs07f+eIqf/f29ma6vSSaHvDLVNRq6tSpkWWd\n", - "SDXtkOmyKgyn/e71ekYx6mkyXP8eFzeTgz8BsV73mtLO+jeahbLSdI1IZ2gImYGifn4ZAAAAFcJD\n", - "FAAAQADSeQ1k0qRJw/57yOiIvEfJqeXLl7u4q6srt/1URdbpAZ1wVUccZkEnbDXLpopyrbL+jLg1\n", - "TXnUm+7u7rIPoRJ0RJ9OEGxW3ojcKqh1EnlaogAAAALwEAUAABCAhygAAIAA9IkqkJYJMIuWCtCq\n", - "ulp91yy+DMH9998fWc5y6HfepQZUnv2g/HPS19fn4jxnYE+yYMECF8fNHO9L6puUZx+hKvSB8tEn\n", - "qnhVn+kAt0ZZhHzQEgUAABCAhygAAIAApaTzHnnkETMze+ihhyL/PnfuXBefOnXKxUlpqqTh4po+\n", - "0+ZoPx2gqavW1lYX79u3L7Kevm/ixIku9ssBaCXcpqYmF/uT1eoxzZ4928Xjx4+PrKdpJ03r+MOO\n", - "H330USva9OnTI8s6jFYrBS9cuDCynp7zTZs2uVjPq1m0/MHrr78eexz6HWia1K9erNu7fPmyi/Me\n", - "Bv3YY4+5WNN5/jW2ZcsWF+s5yjqt1tnZGVnW7/G1116Lfd/73vc+F//mN78Z8X7nzZsXWdZr5L77\n", - "7nPxW2+9FVlPv58iU814hz8kHuV6z3ve42L9e/GrX/2qjMOxj370o5HlxYsXu/gb3/hG7Pv+4A/+\n", - "wMV6L9S/CXnTv01pu1coWqIAAAAC8BAFAAAQoOntgocoNTU1lTYqCgAAYCSSnltoiQIAAAjAQxQA\n", - "AEAAHqIAAAAClFLiQIf9Ix+av9XSCn7l6yNHjrg4qVxEnKQSB4sWLXLxoUOHIuv5Q/uHaOV2f/s6\n", - "27ZfVkKX9bP7VXr9kgdxJk2a5OKpU6e6+MyZM5H1brvttmFfq/o17pfRmDBhgotvv/12F/v9ALT0\n", - "SMj14tMyHRcvXozddlx/BP33qp/zqtDzlNQ/NW49/z2c9/z551zv6cePHy/6cEaNNP23aYkCAAAI\n", - "wEMUAABAACYgHgU0daNpKjOz/v7+mrad1Mys+4pL3/m02vtwy0M09WMWrXytzduhk26eP39+2Nin\n", - "qb564legLqsitaZos6bpZP2e/IrnBw8erGk/msI2S3/NPfzwwy7Wavx+yjhkwuokmtLXqv36G/Jf\n", - "Q7X43xXKQ0sUAABAAB6iAAAAApSSzlu6dKmZ3Txiq9aUwqxZsyLLOuIo7aisRqQTHWfdDKyT/ZpF\n", - "UyU6ci1rfjpvcHDQxXmmiHx+6gXVceDAARfrde+PKK1V2vSdTjJuZrZ27dpU74tL4d1///2RZZ28\n", - "Oklcmo70Xf3Q0ch6D4rr/oD80BIFAAAQgIcoAACAAKWk88aMeWe3fvN2SMptxYoVLh5KEw63vdGc\n", - "ztPRZX76LW3hvTh+amRgYMDFaUfkhVi1alVk+Y477nDxm2++6eKdO3fmdgyoH1pANG1xwoULF0aW\n", - "J06c6OJdu3aN+BiS9qv3rj179qTaHqmb0UtHWOrIU38kcRYFcZGMligAAIAAPEQBAAAE4CEKAAAg\n", - "QCl9oob63viVfrU/jQ7LT7J9+3YX+0ON+/r6Qg+xLjU3Nw/773ous56s0v+erly54mK//1WWlixZ\n", - "ElletmyZi7VPVBItgeGXTEhrxowZw/67P9GznhcU78KFCyN+j07OnWSoj+eQzs5OF2/dujXVNtL2\n", - "gwp5j3+Nnjx5csT7QrXobBB6n/XLymhf4JA+r7g1WqIAAAAC8BAFAAAQoJR03tBQYa26amb2yU9+\n", - "0sU6NPN///d/I+vFpaTyTB/lbcqUKS72Uz9pK7mnTT9kyd+nlkzIWltbm4tbWloir+k1kbasQRbH\n", - "GreNBx98MLK8Y8cOF586darm/WaRikSytOfVL4WQZ6X+tDo6OlysEzGbpa+UrrS8A8qn15hOMO+X\n", - "NNAuMzqrQ5Jay96MNuX/2gEAAOoQD1EAAAABSknnDVXa9dNvOoFwa2uri/2JNn/xi18Mu12/2Vqb\n", - "PHXkX1n0M5lFP69W/vYn0D169KiLQyqv63n2JyDOetLRrJt/tTn6/e9/v4u1ArWZ2UsvvTTibYeM\n", - "2PLFpXw03ZYHUnj50JRxf39/5LW4EcN5VuZPoik7M7Pu7m4X6/1O/30kdIRpFr8VZEfvs9r9wx95\n", - "GVLVnhTeyNASBQAAEICHKAAAgAA8RAEAAAQopU/UwYMHzezm/jha3VeH/OsQziQbN27M4Oiypf0K\n", - "/GH5mr/Waut+f5e0Q1Pj6PDkuXPnRl7TvkUhM9On5Vd1TluOQvu5aR+3DRs2RNZLWxk6TtI1ptep\n", - "318grq+I308mi7IGyJ9W9+7t7a15e1rqYtOmTTVvTyX1dcqiD1N7e7uLh+7ZqAbtn6clCfyZEnQ5\n", - "6/6veActUQAAAAF4iAIAAAhQSjovTbOiDs0MGaZZFTr8dMuWLaUcg1Y891ODRVVXDq0mf+DAARdr\n", - "+sKvzBvHr7Qcl+ZIWxU+LdIf1bVq1arIsqbttm3bVvP2P/vZz7rYL5MQ5x//8R9d/Mwzz9R8DGlp\n", - "GttPad95550uDimtgvxo94/Tp0+7+MyZM5H1KIWSP1qiAAAAAvAQBQAAEKDp7YLLk+Y5QS1u0K91\n", - "NJxzHf1X1kTUo+2cV0HIOZ88eXJkWVO8adPEWfj85z/v4rvvvtvFX/ziF1O9P6lieZ78Pxlc6/nz\n", - "z/m8efNcXIXZOBrV0HlvamqKreROSxQAAEAAHqIAAAAC8BAFAAAQgD5RDapq/XO0Ar1ZdDj18ePH\n", - "R7w9rbTu02q+RaraOR8NqnDOJ02aFFk+f/78sOv5JQSyLqtRFPpEFc8/51pZn9kQ8kOfKAAAgJzw\n", - "EAUAABCglIrltZo+fbqLacqsrtWrV7tYh+SaRVMeL7zwwoi3XVbKDvD56TudBUBLJvgp7XpN56F8\n", - "RZbiQDJaogAAAALwEAUAABCgLtN5jZjCa29vd/HRo0cjr6WdRNIfJVQ2Hc3Q1tYWeU2bo5cuXeri\n", - "PXv21LxfHS1U8OBTVIiOhktKnTU3N7v4yJEjNe83LtUSMgoVGA73teqgJQoAACAAD1EAAAABeIgC\n", - "AAAIQMXyCvL7D2l17mPHjrnYH1o9ZsyNLm5XrlxxcRXOufZ7MjN74IEHXKyX4Ouvvx5Zb+/evfke\n", - "2Aj5VacvX77sYu0LU4VzPhokVSyfO3eui/1+hghHxfLi+edc+79euHCh6MMZNahYDgAAkBMeogAA\n", - "AAKUUuKgtbXVzMz6+vrK2H3l9fb2Br3v6tWrGR9Jdg4ePBhZvueee1ysTdMzZ86MrDdx4kQXV6HZ\n", - "mirT9SPrqs5xlciBonH9VQctUQAAAAF4iAIAAAhQSjpPR45hdPCrqetIwv7+fhf7o/GqkMJDfTp7\n", - "9mym22v0FMr8+fMjy4cPHy7pSHArdCuojsSWqM997nPW0tIS6b8yODhojz/+uC1fvtyeeOIJO3ny\n", - "pHvt61//ui1btsw6OzvthRdeyO+oAQAASpb4EPXZz37W1qxZE/m35557zh5//HHr6uqyRx991J57\n", - "7jkzM9u+fbv94Ac/sO3bt9uaNWvsC1/4QsP/zw0AAIxeiQ9RH/jAB24aLfXf//3f9pnPfMbMzD7z\n", - "mc/Yj3/8YzMze/755+3pp5+2sWPHWkdHhy1dutTWr1+f02EDAACUa8R9ogYGBqylpcXMzFpaWmxg\n", - "YMDM3smfr1692q23YMGC2KH6VR6Kj3xo2tfM7NChQy4eHBx08YkTJwo7JjQ27TeiVf9nzZoVWa8R\n", - "q5lPmzbNxadPn071HvpAASNX0+i8pqamxJL/TAcAAAAa1YhbolpaWqy/v9/mzZtnfX191tzcbGbv\n", - "zPemrQs9PT03zQE3hBFXAACgyp599tlbrnPLCYi7u7vtYx/7mL311ltmZvalL33JZs+ebV/+8pft\n", - "ueees5MnT9pzzz1n27dvt0996lO2fv166+3ttccee8z27NlzU2tUU1OTzZ4928zMjh8/HvjRcCtJ\n", - "E7NWgU5IrOUPduzYEVmvnsphVP2cN6K051xfK3jO9YbDBMTF45yXI80ExIktUU8//bStXbvWjh07\n", - "Zu3t7fY3f/M39td//df21FNP2Xe+8x3r6OiwH/7wh2ZmtmLFCnvqqadsxYoVNmbMGPvmN7/JFw0A\n", - "ABrWLVuiMt8hLVGFqHqrCC1RyAItUcWjVaR4nPNy1NwSlZeiHp50wlC96K5du1bI/hFvwoQJLp4y\n", - "ZYqLly1bFllv3759Lr548WL+B/Z/qjbxMW5t0aJFkeUDBw64mAenxjZ58mQXnzt3rsQjwWjD3HkA\n", - "AAABeIgCAAAIwEMUAABAgFI6liOZVlc2i+/D1dHREVmeM2eOizds2ODiKp7zqVOnuri1tdXF2snc\n", - "LFrp/OzZsy72K5vX2s+tvb09sqzHsWvXrlTboGN58TjntdHr/Pz586neQyfn4nHOy5GmYzktUQAA\n", - "AAF4iAIAAAhQSjpvqPTA9evXi9y146fLtBRCkXWJhuplmb0zYfMQHa5rZrZ7924XJ02WOm7cOBfr\n", - "5KtVb/rV8zB37tzIa+PHj3fxwYMHXZzFRMWa/vTTgSHbJ7VUPM558fw/Gfr71cnEUZuxY8e6+PLl\n", - "y5HXuNaLQToPAAAgJzxEAQAABCglnffQQw+ZmVlPT0/kNa00q6Oy/BSbVruePn26iwcGBjI91npW\n", - "T2mOMWNuFM6/evVqzdvTEUczZ86MvKbXjqbsskhD1NM5bxR6zrXKvFmxFe5HE/9PxpIlS1ysMwwg\n", - "O4zOKwfpPAAAgJzwEAUAABCAhygAAIAAY269SvaGhrG3tLRE/l1LD7zxxhsu9itGa18H+j3Uv7T5\n", - "/RkzZrhY+8yZRYcDJ1Vh7u3tDTlE1IGFCxdGlru6ulK9T0uKaL9MpNPX11f2IQCloSUKAAAgAA9R\n", - "AAAAAUpJ5+3fv9/MzLZs2VLG7lEBd999t4u1WrhfpkKrySdVGNcyGMeOHcvsOFE/QlNx9ZrC04m7\n", - "zcpLq124cKGU/QJVQEsUAABAAB6iAAAAApRSsRz5S1s9W0dE+imyPGml+VOnTqV6T3t7u4uPHz8e\n", - "ec0fhVcGKpYXbzSfc3+i8qLSklTPLh7nvBxULAcAAMgJD1EAAAABeIgCAAAIUEqJA5Rn3rx5keXZ\n", - "s2e7WPsZ9ff353ocaftBqcHBQRdXoQ+UmdnEiRPLPgRUzKxZs1y8bNkyF7/22ms1b3vChAkurtfS\n", - "DEAjoSUKAAAgAA9RAAAAAUpJ540fP97MzC5duhT0fm3STjsBsU5Qq1WwfdOmTXOxP+Rf3zdmzI1T\n", - "5w991FRV1hMk6yS8mjYwM7t+/fqw79HKxlop3OzGZNBm0c9x4sSJyHpaSfzQoUMu9ksN5EnLMeRN\n", - "r7EpU6bErtfc3FzE4aCOaNo561kZipxwfebMmS727wcA3kFLFAAAQAAeogAAAAKUUrG84F0CAAAE\n", - "oWI5AABAxniIAgAACMBDFAAAQIBSShyMdAbqSZMmRZZrrVbtz37e2dnpYh3O3tvbG1mvr6/PxSHV\n", - "gh966KHIsg7Z17IB/rD5TZs2ufjKlSsu1mrjZmZz5sxx8c6dO13MjN/F0Jw557wYWZxz/R1duHDB\n", - "xVlXxQ+9j40bN27Y+OzZsyN+v5nZ5cuXXbxw4UIX+9X3d+3aNez2/L4hXOv588+5lp84efJkqm1M\n", - "nz7dxSEzRphFryW9jhqFlrYxi94P4tASBQAAEICHKAAAgAB1MQFx1s3qfipO02VpLV++3MVdXV2p\n", - "3vPyyy+nWs+vPK7V1jWd51cLr8qkvMg+BY1b02r+ZunTHDpJsP721q9fn82B/Z/Qa0BTKDrjgF9F\n", - "XO9Dev0l7VdnjfBnQNDUhs7QgPLp95v2Og9N4Sn9jR05cqTm7VVNyIwAtEQBAAAE4CEKAAAgAG20\n", - "gdKm8EJ0d3cHvS/NSIKhyZ+H6Mikw4cPj3ifS5YsiSzrCEZNI/gjf9Ica950Qum4yZtD3XHHHZFl\n", - "TSo+yQwAACAASURBVIfs37/fxVk0seMdK1eujCzrKNwDBw64WEeumpmtW7fOxS0tLTkd3c1Wr17t\n", - "4j179rj42LFjkfX0t6MpfH/0sEqbOtSJxTU2M1u1apWLSedViz+KrCgf/vCHXfy9732vsP0uXbrU\n", - "xfpbyZr+TUj9nhyOAwAAoOHxEAUAABCAhygAAIAAJLo98+bNc7HfP+KNN96oadsdHR2R5dC+TyOl\n", - "+XO/GvrBgwdHvD3NT6cts5C2D9SiRYsiy7r9tBWa08qiH5Q/rH6I3/dMvwO9xrRqvVm0hIV+3rgZ\n", - "xHHDjh07Ist33XWXiz/5yU+6+Cc/+UlkPf1d+/2C8qT9jJKuxWvXrrk4i/4gbW1tLk7qV9XT0zPs\n", - "MaB8ZX0fZfWN09IeefaJCvmbQEsUAABAAB6iAAAAAjRUOm/q1KmRZU2NpK1E2t/fP2xsFp3AMW7Y\n", - "sb9fVVT6znffffe5OG5S0VvRUghaqfb06dPhBzYMHYo+EjqRqn5vfvOzVn9OW+lX6TWQtA1/v9Om\n", - "TXOxpvD8dJ5W09cJPrWyNIbn/w51hoD29nYXVyU1mnYGA72v6fWWlHpYsWKFi/0JiDXNuWHDBhf7\n", - "aRL//ofqiPsbk7ek9G+WOjs7I8t+df68hJSOoCUKAAAgAA9RAAAAARoqnXfmzJlct6/Vpeup0rSm\n", - "OfxJRvVzaLVWTd+ZVW+ySb869datW4ddT1NiZtHRg/p5k0bJKZ0M2sysqalp2PUOHToUWdY0nY5U\n", - "9NOBekxlNdk3oldffdXFWsncLPodpk316fWS90gpvXbSjh7S9MfVq1djXwtNn6NcOgFx2msx5Dr3\n", - "7du3L+h9I3XPPfdEll9//fVC9ssExAAAAAXhIQoAACAAD1EAAAABGqpPlN/fZ3BwMNX7FixY4GKt\n", - "0lt1frVsHeavDh8+7GK/ovjy5cuHfU/aWeDT8r8bXU5bgVbLSsT1gRoJ7V/i94mK62dw7NixVNvW\n", - "cz7cMoqVVF7kwQcfdPHmzZtdnNT/SPuk5N0XM+01p/r6+nI4ElSF9mlK2ycvi9IeeVYLV1OmTIks\n", - "p53xogy0RAEAAATgIQoAACBApdJ5Wpk3ZFhvaDqv1hSeppnMimt69IfHx1XPTkrNdXV1ZXpMcfzv\n", - "Iu13o9KeV01R+uckrlQD5QRGr71797o47b0m7xReGbS8hllyuhvlam1tdbGWsAmZhaEe6PNA1dAS\n", - "BQAAEICHKAAAgACVSudpE7lWzPbTOHHpqaJGDviySN/phLV+hWGMjDZvV7kZGNVQ9RSITooaUlE5\n", - "raRUZt5V2TEyM2fOdHHVU63z5s1zcdpJrf37dpVnCKElCgAAIAAPUQAAAAF4iAIAAAhQqT5RSvu1\n", - "zJkzJ/Ja1tW0lfbF0mPIG/2gslPk96bV7oE8pL03tLW1uViHwG/cuDHzY0K59G9i1furhfTjq/pn\n", - "UrREAQAABOAhCgAAIEBl03kqZALOUEWmgoqildz9Ssu1VurWKvPDbb9eafVmbTr3K57HDS8OrZ6P\n", - "fHR0dLj40KFDkdeqnjrQdJ6m7Hp7eyPr6W+5yhO2onbNzc0urnqJjpDj86/tKqMlCgAAIAAPUQAA\n", - "AAHqIp2H2qRNJWllWT/NpyMiNYVXZPpu7ty5Lj569GjsetrUHTfh8K1oReCkbRw4cGDYf+/s7Iws\n", - "6yTXBw8eDDqmRuBPcjtu3DgXjx071sVawd/M7MSJEzXtV1N4VU/fJfHT50qv09DrHqgCvV9WHS1R\n", - "AAAAAXiIAgAACMBDFAAAQIC67BPV1NTk4rffftvFkydPjqyny/QRuLW0M2xnMXxaK8Mrv8SEfodJ\n", - "/aBUFt91raUutGK0WfSaTRryq32EdObyWktRVMX169cjy1rNWPtE+SUi9JprlArI+nm1VEbS5+vq\n", - "6sr1mFAf0l7PSSUxqsyfpaTKfaRoiQIAAAjAQxQAAECASqXzVq1a5eKkSTM1hafOnTsXWb506VKq\n", - "/WpTug5tz7tSug5X1nRNSLoirenTp0eWNWWUp/Hjx0eWtblWU3Z+mi/P9IV+1/7xpU1txpk2bVpk\n", - "WatO62v+ZNq6nqYARwNN9fm/Af1+8vx95Mn/Pn/v937Pxd3d3S7esGFDZD09L346FKPT2bNnU613\n", - "+vTpnI8EtEQBAAAE4CEKAAAgQKXSeUkpvBA60knTJD4d6VDkZMdFVfueP3++iw8fPlzIPs2iaTo/\n", - "1bpr166atj1hwoTIsqbI0o7Oq7UKdhK/MreOxJo0aVLsepqC1tTN5cuXsz7ESvM/byOMTly2bFlk\n", - "edu2bS7eunXriLen15RZY5wjpON3F4hTrxPC19P9jpYoAACAADxEAQAABOAhCgAAIECl+kSllbaP\n", - "jz98fLQqsh+U8vtB1WrixIku1v5uZtWrSO/3ddJh+Zrv1zILZvGlLvzt6XpZn+eyaFVyv89bI/T3\n", - "8X+HaYepx9G+dWbFlStB+apefVzvVyFlOdL2+aoCWqIAAAAC8BAFAAAQoC7TeWWlp6rOn4C5CFrt\n", - "3az2iV797S1ZssTFOqnvr3/965r2cytaUT2p7IU/zHyI34StzduahtEUpVm0orxWuJ47d25kPS2F\n", - "sGXLltjjqydJlbmrOIHwSNWavvP51f3j0nlZ/0ZRPj+9XzW1Vtb3J3Cvsmp/EwAAABXFQxQAAECA\n", - "ukznpaXN2NqEPWZM9GMnVTOvJ2WM0mpubo4s9/X1pXqfpiKOHz/uYj/VoCO2Dhw44OKsJ2L1R/ul\n", - "rVwfN2rMHzmlo02mTJniYj+dp59XR5f616yO3NOUYhVHsekIRP+3puddz5mfmtbvezSPQtPz5f/2\n", - "9u3bN+x7ykrfJV3bqE1HR0fZh5CrgYGBsg8hNVqiAAAAAvAQBQAAEICHKAAAgAAN3Scqri9A1n2g\n", - "/OGmWffXKYr2IfMrRmt/K+2fk7YPlE/7QSU5dOhQ0PZHKutZw/3zp+dW+7UkVeZOGvL/9ttvu3j8\n", - "+PHDvr8q9Pehx20W/Y3qa/6w/Hrtt6i/lSw+g16nJ06cqHl7eaIPVH788haNZseOHWUfQmq0RAEA\n", - "AATgIQoAACBAXabzpk6d6uIzZ86UeCTvqNf0nU9TK0nlEkLSErNmzYosDw4ODrueXwG8rPTUvHnz\n", - "XKznxW9Gj/vu29vbI8uahtHP6KcRT5486WI9R37JBP0Oql69WMsx+JOCa1V2LWtw+vTpyHr1Osly\n", - "1uUF9Pqr+iS0yE9/f3/ZhxDELyUT142i6qlqVe27LwAAQEXxEAUAABCgLtN5VUjhVYFWgjbLfoRZ\n", - "luLSd74i03dJaeG45vKjR49Glv2qzEO0QnnSev5+u7u7XawT1vppRE19xU2CXEV+6lFH4Wlqr1FS\n", - "5DricPXq1ZHXdFTl2rVrU21PJ6LeuXNnjUdXX5hI+YaXX3657EMIUuR3ppO55znLAS1RAAAAAXiI\n", - "AgAACMBDFAAAQIC67BMVQvtilNXfYsqUKZHlJUuWuLi1tdXFflXnV1991cU69Fv7R5jdPKt7I8iz\n", - "nEUW/a/iqjL7fcDihvn7Q/kvXbrkYh0O7Pd7SiobUDVJ5Qm0j0RPT08Rh1OadevWRZb9avVpVLEK\n", - "uPb/0+866ZoN4d8/8+znUnXbtm0r+xCCFNknSvuh0icKAACgYniIAgAACND0tp87ynuHMow5iTbd\n", - "6lBvs+hwb20e1GrPo51+rWnPeT3xUyG1pgqyoOf8i1/8YuS1ffv2ufi1115zsd+8fezYMRdrOs+v\n", - "+K5pHU1zNkppgLQa/TrPg5YK0FScn1qOS734fzK0mn4W6UadLUCPyd92wX+6SuV/Vq71W9N0cmjX\n", - "jaHz3tTUFHu90RIFAAAQgIcoAACAAJUdneen8NTx48cLPJL6oc3gRfErUGvaSVNTSTo7O12cVIW5\n", - "paXFxf7IxK1bt6baV1H8z7Fnzx4XDwwMpNqGVqD3R5foa6MthYfaaJoui4lesx4xWK+T6/rGjBkz\n", - "bOyPWtQ00YwZM1xcxv28KubMmRNZTvu3RBU1+wUtUQAAAAF4iAIAAAjAQxQAAECAypY4qCc6G7tZ\n", - "tOp0kXTWai330IjnvIr0p7Rs2bLIa9onCtmpYokDvR/oMYWW4Zg8ebKLk6q/F4Xh9uloPyi9Jvy/\n", - "F3r+9LvWvo6HDh2KfU9ZtF/q0aNHM932qlWrIssbN27MdPtpUeIAAAAgJzxEAQAABKhsiYN6Ulb6\n", - "zteIE3JqZfIqVCVPS6s4m0Wr7GuJDk3BmkUnXNYyBn5Tsg6T1mb/pOHhOmzYn8w55BrWY9Wh2f7x\n", - "6VBjTVf479MK7T6d0DltOQstt+FPCJ0nPZerV692sT8BcZwHHnggsrxjx45sDqwOaXV1v5RH1SqW\n", - "+yUJ9Hi1ZI+fktW0n6bpkn4PWVTjrlWe57+szxSCligAAIAAPEQBAAAEIJ2HSvEroIek8DQFEDeJ\n", - "6q3UOiJq4cKFkWVN72nl9fnz50fWmzhxoouTUmx6njQF4E8iq/S8+KlfrVyt+/Wb7HXC2sWLF7v4\n", - "6tWrkfW0OV7366c5NZ3pTyqtNDWXNJuBKjKFFyfp+1D6fba1tUVee/311zM9pqL4o9A0vZWUttLJ\n", - "5/Xa8VM8R44cyeQ4s6Lpd7P015/+3vR+5/9WlN6fdCR23vT7uOOOO1ycVFFc7xn+OYq7v/tV3bOm\n", - "15x/TCNFSxQAAEAAHqIAAAAC8BAFAAAQoJSK5VUbmgoAADAcKpYDAABkjIcoAACAAKWUOChj8kSt\n", - "jHz//fdHXnvppZdcrMPPBwYGgvalwyd1X+vXr091fP6QVa00nTSUtLOz08Va5XjmzJkuXrp0aeQ9\n", - "2kS5e/duF6cdmu3TIftawbe7uzuyXtrhv4888oiLt23b5mJ/eLOe846Ojtj10g4H1uHF58+fj11P\n", - "vzctE1DWBKE6KahZdLj8li1bYt+npRUuXLgw4v22t7dHlv0JU9O48847Xbxr167Y9R5++GEX62+3\n", - "CpOyjgZ+WkPvL3od+eVF9BrRcgV+JfK0FenT0nuSlsrYv39/ZL2QUiZ6b/ar9uusAKF/S4YkTfoc\n", - "N4GxWbQkgfLLRWhJAS0hkrZEjM5eYBb9O6rH5N+P9e9MyPn3S+L411Kt0nQ9oiUKAAAgAA9RAAAA\n", - "AUZNxfIVK1a4eM+ePbHr1drsamb25JNPulgnl0xK5yWlmdJOLPzQQw8N+++a6vKbP7V5NTSFpw4f\n", - "PjxsHOqXv/xlqvW06mxXV1fN+01K4akiqwWnoc3oZmaLFi1ycVI6LySFp9XGe3t7R/x+X1IKTyVN\n", - "soziNTc3u1jTPzrRtln03lrk72bBggUu1qr4aa+3JEmfo6iJ6TXllLaaf9b8Cc395bxknb4LQUsU\n", - "AABAAB6iAAAAAtRlOi9kclhtWg1JXZjFj2DS0WBm0dESP/rRj4L2pfyRFHG+/e1vu/hb3/qWi7UJ\n", - "2x/dV7VJPDE8fzLSuHSjn0JZtmxZbseUNs2ctSzSMLg1TddqtwSfjgDV67Snpyeyno7IzTPtpOlF\n", - "s2h3Bh2tlkUqSCfe1ol2zaIpraLSWygeLVEAAAABeIgCAAAIwEMUAABAgLrsExVS2VT7Ufn9RuJo\n", - "Lt0s2g9Kq9N+6Utfiqz3hS98IdX2tSTByy+/nOo9IbSPlt8nKu1QfoyMVgA2S9+vTWk/lLSVg/2+\n", - "K1q5HtWlfXXSftd5076U/r1QabXq8ePHu1j7VJkVV9bALy2gsyWEVONOy69YrudMS7D4ZWZ0pgPU\n", - "H1qiAAAAAvAQBQAAEKBS6bysm7R1qKsOw01Lm2B9H/vYx1ysk6CORNYpPL+ZeIgOw61KqqAK8kyh\n", - "hKTvfPq9aezTFJ5OsGpm9sYbb9R8HGrlypUuDpkoNnTCUB0+rhNb50kn1jUzmz17touTZj0IUcXf\n", - "pVYY18r3Ph2+r9+n3+0ipBtGCL/0RlGlOPxuIvqd6mwQaSa1Rf2gJQoAACAAD1EAAAABmt4uuG1R\n", - "R4rlTavnJo1C00lbs5iAuAr0a9VRNv7oraKa2EcDPedFXuc6OspPQdc6CerDDz8cWV67dm1N20tL\n", - "U61m0fOpqT1NoeR9zvW3k5RebRQ6Q4Om8/wRn4sXL3axfjf+tRdX9fzQoUOR5SwmQi+DpnvNotej\n", - "jsALSd36f6bjrnU/Ba2pzCpM1ltvhs57U1NTbBqWligAAIAAPEQBAAAE4CEKAAAgQKVKHGQtbsi/\n", - "r1H6QcXRvgl+VV2tKqzVzJPKO+CGIvs+xcl6hviOjg4X9/T0pHqPfx5q7Wqp/RnNop9xcHCwpm2H\n", - "Gg39oJT2tdO+Tj6tCK4Vy/336KwR2n/IL8tRr32ipkyZElnu7+93cVElLPzfHf2g8kdLFAAAQAAe\n", - "ogAAAALURTpP0wtm0eZj5Tcfv/e973WxDvVct25dqv0uWbIksrx3795U78uzZMLSpUtdHFI12T8e\n", - "HRJ7xx13uHjnzp0BR9eYQiqb+8O5V61a5eK0119Z5s+f7+Lf/OY3qd4zd+7cyPKRI0dqOoasU5RZ\n", - "0HSNTmRbbzT1mpR21e8wadJ2/X1o+igp1a2prno+l3PmzHFxa2tr5DX9XDqDQZ4ptqImeW5U+n2m\n", - "RUsUAABAAB6iAAAAApSSzhtKdaQd7ZK2ad8f1fHzn//cxX4F5DiPP/64i19//fVU7/FlncLTUYZZ\n", - "T3yqlXQ1xg1JKby4dIifgk4a3VQ1aVN4mrLUFKBZ7em8KqrntJMKGTkZV23cLPr7iJt01yx6v9cR\n", - "ljqjQr3Rvyv+aHBN/+po5yqmqvEOHaGeFi1RAAAAAXiIAgAACMBDFAAAQIDEPlGf+9zn7Kc//ak1\n", - "NzfbW2+9ZWZmzz77rH372992Q5r/7u/+zp588kkzM/v6179u//qv/2q33367/fM//7M98cQTw253\n", - "3LhxZpa+T5Q/vFZzz2mHi6Ydmr5169bY/ap7773XxW+++WaqbYdK+xm1WjDKpeUizPK/Rsqgn7Gv\n", - "r6/EI0He2tvbY1/T6vJ6T584cWJkPb1vh5QNqSI99osXL0Ze88t+DKFPVGNJbIn67Gc/a2vWrIn8\n", - "W1NTkz3zzDO2efNm27x5s3uA2r59u/3gBz+w7du325o1a+wLX/gCJecBAEDDSnyI+sAHPhApxjhk\n", - "uNEdzz//vD399NM2duxY6+josKVLl9r69euzO1IAAIAKCSpx8I1vfMP+7d/+zVatWmX/8A//YDNm\n", - "zLDDhw/b6tWr3ToLFiyw3t7eYd9//vz5sKP9P1m3cD300EMufvnll2PXW7BggYuT0jM6ZNdv4s2T\n", - "TjSMcvnXuFZobhQLFy508YsvvljikSBv+/bti31Ny3cklS4YO3asi7VkQj2XVtHSBX5JB51k2U9t\n", - "onGMuGP5n//5n9v+/ftty5Yt1traan/5l38Zu24VZrgHAADIw4hbopqbm138+c9/3j72sY+ZmVlb\n", - "W5sdOnTIvdbT02NtbW0ZHCIAAECxnn322VuuM+KHqL6+PjfR4n/913/ZPffcY2ZmH//4x+1Tn/qU\n", - "PfPMM9bb22u7d++2d7/73SPdfCH8ptW4FN7UqVMjyz09PcOuN2PGjMgyk0Bi9+7dZR9CLrQS++TJ\n", - "k13sjwwltdxYkrpQaDpP01vTp0+PXU/T3foesxujt82iVeJDKq3nQUcWaorSH22ukw4zcro++Nmz\n", - "oYeor33ta7HvSXyIevrpp23t2rV27Ngxa29vt6997Wv20ksv2ZYtW6ypqckWL15s/+///T8zM1ux\n", - "YoU99dRTtmLFChszZox985vfJJ0HAAAaVuJD1Pe///2b/u1zn/tc7Ppf+cpX7Ctf+UrtRwUAAFBx\n", - "VCwHAAAIEFTioEpCyglcuHAh1Xrve9/7Iss///nPh12PPlDVon11zp07V8oxDAwMlLLfvM2bN8/F\n", - "+/fvd7HOWG9Gn6jRRPuYat8f7TtkFu0/tGzZMhf7fUq1L9HBgwddXJWq+Pq5tFp7UuV1/Ux+X1sq\n", - "mFdHSL87WqIAAAAC8BAFAAAQoO7TeTqpZRbuv/9+F7/00kuZbhvFKCuFV0/8atJpU+E7duxw8alT\n", - "p2K3h9FD01M6S4VfpV/TVlruwE/naSq4iqUBNG2npR/8Ug36Wtzky6h/tEQBAAAE4CEKAAAgQN2n\n", - "82qdzNi3ZcuWTLcHVIWmFNKOnktbjV8nlMXooteIFlg+fvx4ZD1d1lTXihUrIuvpteRff1WgqWut\n", - "yu5XLNdj11SmP2MGo7vrGy1RAAAAAXiIAgAACMBDFAAAQIBSOjIM9c1ImhkcQLYWLlzo4u7u7lTv\n", - "0T4fZvH9Nzo6OiLLW7duHdGx+dra2iLLOnQe1aKVyLW/z7hx4yLraT+8np4eF8+ZMyeynvYl0m34\n", - "5Q6qUBVf+zr5pQu0+rXOojBr1qzIeidOnHBx2lIjqA5aogAAAALwEAUAABCglHTe0KSNZ8+eLWP3\n", - "wKh0+vTpVOstWrTIxUklRDRFoROxZoH0Xf3QCd21erk/m0RcCtlPEc+dO9fFmk5ub2+PrLdnz54R\n", - "H2sWtJTB4OBg7Hr6+bXKuf93jxRefaMlCgAAIAAPUQAAAAFKSedVLY2nFXL9qrNAo0ibztNRT0eP\n", - "Ho1dT0fQ+WkNHaWl6R40nilTprhYv3e/ir2OwtNrzL/n6og3VZW/G3rsSSME9+3bV8ThoGS0RAEA\n", - "AATgIQoAACAAD1EAAAABRuXU6zrTuBn9oDA6JM0QoEPJ+/v7R7y9soabo3xaokCrdPuVuU+dOuVi\n", - "vXaSymholXK/ZAJQBVyVAAAAAXiIAgAACDBq0nk6keXly5dLPBKMBjqJqln8xL1FSkrnnTt3LtU2\n", - "dLLZrIecUxahuvwuEEqvA/3e/OH/cRXLJ0yYEFnW34qWT9BUIVAVtEQBAAAE4CEKAAAgwKhJ5xWZ\n", - "wtNJOOOq72ZBUytmZr/zO7+T274wMpqaMqtGOi9J2hGqV65ccXHSKL477rjDxZoqHBgYiH1P2hTe\n", - "ypUrU62Hd+jIS7PoKLkkt99+u4vf9a53xa6n6TytXJ82/eZPwHvw4EEXz58/f8TbA4pESxQAAEAA\n", - "HqIAAAAC8BAFAAAQoO77ROnM4MeOHSvxSG6odXj2woULI8s6NP306dOx79u+fXtN+x0NFixY4OKe\n", - "np7c9pO230nV+X274q7ttra2yPIf//Efu/ib3/xmpse0devWTLfXiPR7W7RoUeS1nTt3ulj7ivpl\n", - "OfQ+5G9DaX863Z5/7WgfTu1b59OyBtqfLm0lfaBItEQBAAAE4CEKAAAgQF2k8x566KHI8oEDB1ys\n", - "zcy/+c1vIuslVWjOU60TGusQ35GIS+dpM33Vh9pnbebMmZHlJUuWuPjEiRMuTluxO62kSVXrSdrU\n", - "tH+ed+zY4eKy0uxp00e18lNden8qi/7m/S4AmmbTSuT+/VJTc0ndCA4fPpxqvbSOHDlS8zaAotAS\n", - "BQAAEICHKAAAgABNbxdcBlabj5cvXx55TZtxdWRIc3NzZL2XX37ZxdoEXdbEwu973/siy35asQz6\n", - "tWrl4fHjx0fWY6LX7Og5T5qwtSx6TEk/e/29pU2t+CNKQ1PSI5V0zmfNmuViTdf66fZr166NeL9p\n", - "z2Wj6OzsdLGmas2qea03Gv8aG83nfNKkSS72/57pb1t/136q+rbbbrQfadcLfzLsob+PTU1Nsb9z\n", - "WqIAAAAC8BAFAAAQgIcoAACAAKWUOHj66afNzGz//v2Rf+/q6nJx1Yfi6yz1/vDuqtF8sN8HasyY\n", - "G5dAraUZcENHR0dkubu7u5Tj0KHu9957r4t/9atfxb7n7NmzLvb7HFy6dGnY95w5cyb0EHMzODiY\n", - "27az7gel/TyqWB6jCmUbALPo7yPr34o/80IatEQBAAAE4CEKAAAgQCnpvIsXL5qZ2bp168rY/U1C\n", - "Ulo6ZPqnP/1p5sdUFP28kydPdnHWFbxHm/vvvz+yXFY6T1O5Wlk6iZYG8CtQx6XztPp7VeRZsTzr\n", - "NHgVU3iKUig3aMV3HRJfxd8ARmbv3r0jfg8tUQAAAAF4iAIAAAhQSjqvr6+vjN067e3tkWVt9t+3\n", - "b1/s+x5++GEXr127NtW+dBRf0rbV1KlTI8tFjXwihZedtJPurl69OrIcl+LWUXZm6Uev6ui6PXv2\n", - "xK7X0tLi4oGBARfnOXGvWb4pZJ1seufOnbHrjRs3zsWa/tT7glk0zdna2uriKVOmRNbTKu9aGVln\n", - "DjCLfnZND/rr/frXv3axpg79idkfeOABF+vsDf4oxbiJynt7eyPLmp6aP3/+sO8xi15jceneRpL0\n", - "XWH0oSUKAAAgAA9RAAAAAUp7iDp16lRZuwaAuuJPoAqgGpreLngK8qHZkJ999ll79tlni9w1cEtc\n", - "l6girktU0Wi5LoeeW4ZDOg/A/2/v/l3S+eM4gD8P9A9oyENUuEDDBAtB2qKgNFokF0kapGwpmmpp\n", - "rJZs7gdENDiVLWWLh9NFtLick0EOBmYmtEUNkvAZgoP66vfz4fh87qB7Pia9O7jX8OR4Hm/ujoiI\n", - "dGCJIiIiItLB8OW8iYmJP349ABEREZGZxsfHoShK132GlygiIiKin4DLeUREREQ6sEQRERER6cAS\n", - "RURERKSDKSVKlmX4/X74fD7s7u6aMQIRAECSJAwPDyMUCmF0dBTA57fGIpEIBgcHEY1G//g7dUR6\n", - "LS4uQhRFBINBbdv/5XBnZwc+nw9+vx/FYtGMkckCuuVyc3MTbrcboVAIoVAIhUJB22fFXBpeojqd\n", - "DlZXVyHLMiqVCk5PT3F3d2f0GEQAPl+ipigKVFVFqVQCAGQyGUQiEdzf32NychKZTMbkKemnW1hY\n", - "gCzLX7b1ymGlUkEul0OlUoEsy1hZWeEbzemf6JZLQRCwtrYGVVWhqipmZmYAWDeXhpeoUqkEr9cL\n", - "SZJgt9sxNzeHfD5v9BhEmu8PqF5dXSGVSgEAUqkULi8vzRiLLGRsbAx9fX1ftvXKYT6fRzKZhN1u\n", - "hyRJ8Hq92g0A0d/ULZfAf6+ZgHVzaXiJajQa8Hg82n+3241Go2H0GEQAPu+qpqamEA6HcXx8MuSB\n", - "aQAAAd9JREFUDABotVoQRREAIIoiWq2WmSOSRfXK4dPTE9xut3Ycr6FktL29PYyMjCCdTmvLzFbN\n", - "peElShAEo09J1NPt7S1UVUWhUMDBwQFubm6+7BcEgZkl0/0uh8woGWV5eRm1Wg3lchlOpxPr6+s9\n", - "j7VCLg0vUS6XC/V6Xftfr9e/tFciIzmdTgBAf38/4vE4SqUSRFHE8/MzAKDZbMLhcJg5IllUrxx+\n", - "v4Y+Pj7C5XKZMiNZj8Ph0Er90tKStmRn1VwaXqLC4TCq1SoeHh7QbreRy+UQi8WMHoMI7+/veH19\n", - "BQC8vb2hWCwiGAwiFoshm80CALLZLGZnZ80ckyyqVw5jsRjOzs7QbrdRq9VQrVa1J0uJ/rVms6n9\n", - "vri40J7cs2oubYaf0GbD/v4+pqen0el0kE6nMTQ0ZPQYRGi1WojH4wCAj48PzM/PIxqNIhwOI5FI\n", - "4OTkBJIk4fz83ORJ6adLJpO4vr7Gy8sLPB4Ptre3sbGx0TWHgUAAiUQCgUAANpsNh4eHllg2IeN9\n", - "z+XW1hYURUG5XIYgCBgYGMDR0REA6+aS384jIiIi0oFvLCciIiLSgSWKiIiISAeWKCIiIiIdWKKI\n", - "iIiIdGCJIiIiItKBJYqIiIhIB5YoIiIiIh1+Ad4CxRoGhD90AAAAAElFTkSuQmCC\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "feat = net.blobs['conv2'].data[0, :36]\n", - "vis_square(feat, padval=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The third layer output, `conv3` (rectified, all 384 channels)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXmwZVV1/78t4IBoolFRmbqlabqBBoFuhqAFBBpsgxTG\n", - "ImpiRDEOIWUoLcuRxEfwJ21MaZwSE4eExCqc4gAkEhAbFLBpgZ4YuwUkCEqMZnCIcQi/P6jPO+9+\n", - "31u99zn33Htfw/r8c/vdPvcMezp7ffdaay944IEHHlCSJEmSJEnSmkdM+gaSJEmSJEl2VHIilSRJ\n", - "kiRJ0pGcSCVJkiRJknQkJ1JJkiRJkiQdyYlUkiRJkiRJR3IilSRJkiRJ0pGRTKQuvfRSLV26VPvt\n", - "t5/e9a53jeISSZIkSZIkE2dB33mkfvnLX2r//ffXl7/8Ze2xxx5auXKlLrzwQi1btqzPyyRJkiRJ\n", - "kkyc3hWp9evXa/HixVq4cKF22WUXvehFL9IXv/jFvi+TJEmSJEkycXqfSN17773aa6+9pv/ec889\n", - "de+99/Z9mSRJkiRJkomzc98nXLBgQfGYRz7ykfr5z3/e96WTJEmSJEl6Z5999tG3vvWtOf+v94nU\n", - "HnvsoXvuuWf673vuuUd77rnnwDE///nP9djHPla//OUvJUmPecxj9KhHPUqLFy+WJP3oRz+SJD32\n", - "sY+VJJ1xxhmSpEc/+tGSpOuuu06SdN999w18/sqv/IokaaeddpIkHXnkkZKkqamp7d7zr/7qrw78\n", - "/u6775Yk7bzzg8Xz9Kc/XZL0r//6r3P+nuPOOeec7V6P5/nxj3888P0ee+whSfqv//ovSc3zR3Cf\n", - "r3vd6yRJ73//+yVJxxxzjCTpe9/7nqQHJ6yS9LOf/UySdOedd0qS/u3f/k3Sg+XO/++888763//9\n", - "X0nSM57xjIHn2nXXXSVJp512miTp3HPPlSS5e51fr8STnvQkSdK///u/z/n/lCOfxx9/vCRNK5zc\n", - "3yMe8aCwetttt0lqJvOPetSjJM0uzyOOOEKS9IQnPEFS87y77777wPUiqC/u//vf/74kabfddpPU\n", - "tNP/+Z//kSTdfvvtVc8HO++8sx75yEfqJz/5yXbvI+Lggw+W1JQL9/eKV7xizuv1Dc//5je/ec7r\n", - "Ue5+f8B48d///d8DnxG77LKLJOltb3ubzjvvPEmaHlvawj393//938D3tLVf/OIXkppnWrt2rSTp\n", - "qquuktSMPcuXLx/4/caNGzvdD0RtZVTM1+vttttuevzjHz895reFvvvKV75SkvQP//APkqT7779f\n", - "UnnsjfD2AYxBb3nLWyRJH/rQhyQ1Y33tWNmWSdXfZz7zGUnNGHTIIYdIkk4++WRJ0qc+9SlJ0gc/\n", - "+EFJ0lOf+lRJTbkxUXnKU54iSXrBC14g6cFJjCQ9+clPlqTpOcY73vGOgd8DY8i3v/3tTs/zpCc9\n", - "ST/72c+mx55jjz12uo/PRe9LeytWrNC2bdv0rW99Sz/72c/0qU99Sqeeeuqs43bbbTftuuuu2nXX\n", - "XacbW5IkSZIkyaRBGJAaIz6id0Vq55131gc/+EGdfPLJ+uUvf6lXvOIVc0bs3X///dPKAQoL3HHH\n", - "HZKkH/7wh9PHStK+++4rqVGMmM1ikaIYuSJV4nGPe5wk6YADDpAkLVmyRFKjcERKlP++xBOf+ERJ\n", - "sxWpH/zgB5KkX/u1X5NUtopQPvz3t956qyTppz/9qaTZihrXR5HiOKxwP39knXOe//zP/5TUKBB8\n", - "usIQ4RNo/kYhdK6++mpJql4Wjo5zdYDyXrVq1cD3rrDRXr/zne8MHIeSxydWL+XI71DwKKeIX/zi\n", - "F7MsrDaggFH/XQ0V+iXWcy1uZaPEotCh/HF/3l4oH87jitTSpUslNf3oP/7jP2b91vtYLd7WgT4+\n", - "81pSU0YHHXSQpNl9t63igMqJClzblyYNfrF77723pEZRuOaaayQ1Y44z82VVw6Me9Sg97nGPm65n\n", - "xrAI2hrvEB9bqE/qjbZFW2XsLwW308d9LJ3pLyw15YLCgrrOfZSeB1B1vT1OGur5u9/9rqSmvFGG\n", - "+J7y/uY3v7nd8zCGczz9ArxeePcPq0j7dUr0PpGSpNWrV2v16tWjOHUyArzzJ0mSzEfavuCSZByM\n", - "ZCJVC7NJfHXoJG6lMGvlE+Xm0EMPldT4/mD9YdXVgsV71113SdK0b8pMX6+5YALiClHETJ8wqXlO\n", - "rB8Untr7dVCmsFKwlikPPz9KhVtBN910k6TG6lm0aNHA/6O8+Kyf8kchpH5QJLAutmzZIkmzojmx\n", - "MiMlCQVj2EAF2h3niaxifPawjnhu2gf1CDwP9YOfDNYn5ROpHn3B83GfXa/nSlStFYxiCa4OofRS\n", - "n05kpQLlOFf/7MvnxFVExiZ/9uuvv16SQp+dxz/+8ZIaPzx+T514GeMvSFl3VdbGDc9B33b1uy2R\n", - "GvqIRzxCP/3pT6f7XknBcYWQsQjwK6W+qRfUfRQtxgKUFcYC/FF5Xu6LekedBt5dKJy0L94BPA/t\n", - "jT6C0sIYTjtyBYZ2Myl4PnyZGNO5v1qliHLjeJ7b37V+Pq5PedZCeaMYQq1imlJEkiRJkiRJRyam\n", - "SO2xxx7Ts2/3kWJdGYuedVUsbGb7rMdjmUYKQxQtB/wOazCKInNQdFCCHKwFjsPvBcUGawvrBJ8w\n", - "52lPe5qkxjcnmiVzHPfDbJ3noRwhsg6wyrCWXDlwKy8qV67H/WItRD43JV+clStXSmoiO2g/ba1e\n", - "2lupnlE3sFYoD65L/WJ9uZ8D1hgRJFu3bh04blS4KtNWkXI1Bkr3jTXsSl1EVz+w7fkN9ZVWxZ89\n", - "yoVXih5DncTSpYzoe1Gbn5TvS1ufJfxWGZsZo+gb+Ge2jbKjDXn50HdRimgL+NU6PjZ53+A6jL2s\n", - "bnA+xmY+eedwXzwv9eUKpo+xjIkoW4xBvsrAOwI/YMbOb3zjG5Kadu7n73mjktbgY3b44YdLat7l\n", - "+++/v6T61SL6G+VDvdOP8F2jnGlnKFYoWIzFfNK+OY53JWM1c4tobhKRilSSJEmSJElHJqZI/eQn\n", - "P5me9blSgqWK8oEVwbon69Lr1q2T1Mxaicxw5+mSnwHWVNu8PaV1WCIWsGaYDaMQYFVEShRg3XEe\n", - "nyX7bB2riueOrHS+ZzbOujTXY3be1koFj3Ys+b7UUsorVMKVqKjeaZdYfZQz5cV9YBX7ebAOKcdI\n", - "OeP/h32uiCgnEs+B9Us9Y6VzvzwXx1MO9DegnErBCyjEHF8bqQT4p/j5Zt5j23OOCsqSMsc/LIKy\n", - "49NVu0gtbAt1zpiChd7WmZsxGlUWVZwIaJ7/iiuukNSMTRD5tPk7AWjLKDSMsZEiFd0voBLz6X2Y\n", - "sfmWW26R1LR5b1/+jkKh8rETpYXjIrUYxas2YpZ20TVarS8oXxQ36on2hnJUC+XO77y8GDtpt/yN\n", - "8ovvmitP9Ee+511Jv+P3tWp+KlJJkiRJkiQdmZgi9aMf/Wh6tscsmlkhs3Csgcj6IkcJ68icb9jI\n", - "HWb3RKsxy+4agYIVg+LDrJnnwn+gpHD57B6wjig/zkt5RNY569VYdTynz85RqCYN1gQ+Z1jTlJsr\n", - "FVjDUbm6wuRQzpQf1irnKymJWGVEbEXUbKs0DK5IYiVTz5Qn5efRqPg9oHhu27ZN0mxFCvXE2wvW\n", - "H8rRzIz6UndFivqZ2R/GrUiV8tbQViI/Soe2wHldkSJjtPuAUMel6+DThOLD8ZRh26gv2gDPj18r\n", - "SgDn7StSlchq2lRtxLT/HugL+D5RjihcHh0YtSvaHW2cT8/hRr36GO5jV1tKCuWw+ZVK5wWei7GR\n", - "1SOPVmUsKb1TKRfqwdVurk+9cH7q1X2iUK68X3Ed96WqffelIpUkSZIkSdKRiSlSj3nMY2ZZKSgM\n", - "KDSlWTazSmabvmdeW7AiiDRAsdmwYUOn8wFWALNbnhursqRE+Z53rrgxm2Z2H+XnWbhwoaQmigwr\n", - "iig490vAnwO/hwiskFFtRO0+Yty3ZxR3ovtBGeR8nvcIUKBoZ219mPCd8uzGbo1GEUqjwv1A3Mqm\n", - "3aOAUv+028h/hfL250NloV3y/yiz/H9tFm/f03AmUduPiLL310IbinLAoUj4s7kq53l2IuWAaDXa\n", - "LGVO2+R7+gQRzVyPto9SAChL+Dq1hfvAl4U6xh+xq5rv8E6gT5Vy/TlervQF39/V1eySYkRbdEUw\n", - "Glto8ygfwypSEO2KwaoNMKZRnihGbcdwL0/f5QLVm0/eYbX50agP+rwrSbR7vqf/U3+uNNHuo3Ly\n", - "VbJUpJIkSZIkSUbMRBUpZvtYL8wmWT9ltlmavTKLRJGK9mqLYNaJJc5smhwhXbML+7ot5/FZcinP\n", - "FdFvpefzHBrA82GNeh4lrBL3lfG95iL6VqKi7LVYHaX8XRDlKaJ8UObwAXKG9eugHaPsUM+uCPE9\n", - "9YTVVvLBGhVebviL0C8iny6+d0WK9kE7ov6ivfRKUF7c50xFt62/2bB1XNrHkGf369D3UeVQI92H\n", - "xqO+PPu/56ajzfE3YwplzfE+xkLbjNBAW6WtoBRx/bYR0RHc34EHHiipGbt8/8wI7+uUL+2G8vF2\n", - "5L43XNf9DakXX30AL2/qpeTPWYuv4vhzecQ490+fqt1dI4L75/y0c94p+PihrHoUp0M7jvwpaXc8\n", - "J+0MpZn7QImKVH/fL5fr1vqUpSKVJEmSJEnSkYkpUo973OOmZ+G+NxgWuUejORyHguGe+rUw62TW\n", - "ij9DtI7quPXCbJZZN8/FrJpZMbNl1vuZXbs/AVYECgxKCqDkcb9uVXg+I/cxAsqT2Tn+DiVFiuf3\n", - "/apqYf0eayaK+uL+aDeoAXxfa/V6/iKu6+oCShLHtbXW8DehPZUy63Nfo1aiKF+3RrkuVrNbgx5x\n", - "E+1jFimB7uNGubfNcM590u9p113ONSw8C9FuvmcaZUhbcj9G9/fiOB8Dgb6M4kNd8Xvfo819SO6+\n", - "+25JsU9OVz89+j4Kg/vK9A1tz1XSkl+tZ9Z2pY42jF8gkbf0UX7vyhF9mzZOeyi1R+532I3juW9X\n", - "VsAjbEcF1+d5qCdWP4jq5B1WUqQYq3g30z/A80ZxvEce0y/oD95OOA/9gvqunQOkIpUkSZIkSdKR\n", - "iSlST3nKU2ZFnjBr9Sgwt/KA/Dy+U3rX2b3nd6qdjbpPjysMbi15PiT+jqxB96HyHcVLvkwoCczq\n", - "sbYoN6xUIjcoP8rb14lRqlDI3PeH+uK5seJcueP4KAoM3KrzrMyUXym7MVYJPmJEh5Jb5tBDD53z\n", - "uhxPOZZ8ejiecvYIKWdUGc0jqHfq25VI9ztAWaU8IsWM9uvWHlak+0qhLNKeUO5KOaBoT74fmdRf\n", - "viL3WYny3tBm+J4M2e4bQh9lzzHw3F2es8yz8OO36bsEUBacx31jINozEGr3GY1gTIt8sIbFdwFw\n", - "FbukAF199dWSpBNPPFHS7EzX7kNEW6aN0vY4ztsDfeOmm26SNHvfScrFVym6+uECv/cxdtx771EP\n", - "PBfvCMqDdlobDbdp06aBzyOOOEKS9NznPldSM3ZxXlfTGdM8xyJQP/w/73L+rs1Hl4pUkiRJkiRJ\n", - "RyamSH3/+9+fVjKYveKDgm+JZ5UFrB73QUFBKkXtRRESWCclq9aj21yxwfqM9mXi/jgPx0XWoFsr\n", - "W7ZskSQdeeSRkur3Crz++uslNevTWHe+0zzPHylyWF2e7RdryP1GjjnmGEmNlYcCtHnz5u3er4Oy\n", - "g1Vd61/A/dBesFppb5FihNLB8bV5jlCiqI9SjphhI2XawnNQfvztEWNYdzN9kKRYkXJrHiLrDnWG\n", - "fsD1IiuQfsuOA9TbzP7qEYNd8az5qOeuQFB3KERRHiHf15Cy931CS9CHnVHlcKuFvuU+XuyVBrQl\n", - "xhZvWyVQPf/+7/+++83OgPtkTInG/mXLlkmSVqxYIakZE9hdI1LV/R3Du652taMtozpvLex/S25C\n", - "uPjiiyU1yl9XX8b169dLahQp9wt2nzzeza5E+b61npPS/bZLpCKVJEmSJEnSkYkpUj/+8Y+nM4Zj\n", - "4WK5Y3WU1ieZ/fqsH8v1lFNOkdTMPrG4fV2c3+N/UFIQ/P991orVEVnHrkAwK458V7DasHqi9XTW\n", - "8SlPFD9+x99YzVwXXzPui/NzvCs+kSLBLB4rACuVWT712tYfgPryCBDui/olczv3Qfl7VJr78rjK\n", - "wO+4LtcrWXv4P/B81157raRybhiUL5QhfJIoN99RPQLfucWLF0tqlD+PYvXIFo+6pFxQiNy/odQ/\n", - "XB2hXXq7d3+EUrSiR97wu5nZzMkvRFl5RCj3gH+cjzFLliyR1OxJx/+j4rrPD3553oZ4Nlek+PSc\n", - "cIwhlMGwGde74pnhUZi4H8YoxjjKlT5GW+U5eC6PvIVJK2lf/epXq467/PLLBz670lZ9pv1QrqUI\n", - "6lJes2FBbY98jkpjZN9RtbQf3+WCMc7zSgHtmHcH903ORt5htRnnU5FKkiRJkiTpyIIHxu3Wrwct\n", - "36mpqXFfNkmSJEmSpDVTU1NhFGQqUkmSJEmSJB2ZmI/UOBQprjEu9WtS1/va174mafa6NT4ve++9\n", - "t6TZ/iGsp+ODhS8LPlX47OAX8tKXvlSS9Bd/8ReSGj8Ij1pkXR//D47D1wi/C37nUYP+fA+1+sOX\n", - "6qyzzhq4nudPK1GbzRl/gLPPPluS9M///M+SmggY6gv/FXzI8NUC/GE8FxE+WGTo9wintuWJH1Ft\n", - "DheYmpqabrP457mvAz5H+DwRVYYvBWXpfov4UPAs733vewf+HjVc52Mf+5ikJmKRuqMOPFqKOsD3\n", - "w325KCfKnPM9//nPlyR99KMflSQdcsghkho/PDJS33zzzZJm5wrDJwofNf6mPvBZwefnuOOOG3jO\n", - "UcN1LrroIkmz83fh48Z9Mybif4hvDfmNGHtpV/RN+szv/d7vSWr6+Pnnny+paWful0q53XrrrQP3\n", - "RblxHuqLsZvnOP300yVJH/7whwfum/bsu4bQ1zmv5wT0qDbKhfojgvwd73jHnMdzfd8TkevyXPgp\n", - "R/Cuev3rXy9p/O0lIhWpJEmSJEmSjkxMkZpPHHTQQZKaWfRtt9028P8ePTXfwNpGYcDqxtpxq4qc\n", - "N0Q28PxYBaVoM5QLz91BxBTliHWMUnHYYYdJapQu9gtDGcOKa6tEjIpaxact0V6QWGdYiVibUcb2\n", - "6L4oT6xF33/rhhtuGPibKE7PgVS75x/X4T75RA1pyzD1/4EPfKDzb2ugb2HZjxv6DKAuR0R5p8Bz\n", - "qHF+FCnaBG2WNoGSh4LAp+fJ8hxlKC5E2I56X8kSN954Y6vjGUOjfEilvQoZC3mX+DuFMRWV3iPC\n", - "aX+M+ZQ7ecg8Yzj1yxhNNKtHIvvej1F0IQomY+PMXQWk2eXB+V2JAlY7oj0CnVLU4qRIRSpJkiRJ\n", - "kqQjqUipsSKiHBys/89XRQorDyuZWT5WA34LKEJYKVg1HEc5cD7Kw62TKFuv58jBGuV7/nYrmfV9\n", - "FLHS3nTjYlQBrZGK4HmiIt+xEp77BP8YcJ+2pB5Uw0lZxr6rwqjxPQBRSfEFijKD0+d9H06UE/wE\n", - "fRcKFBtX3sYNzxXtXhHlQyr5OZZ8gKCtKut7xoErVCiA/i7z3R4iOJ/nfOwKSphnJI/oOnaRK5Hn\n", - "52/2mS3t91oiFakkSZIkSZKO7BCKFFYR1lgpU3RbsH6iHamH3Zl71KD0uKKGdYG1iDXJOjdWCT4t\n", - "WCVYU1iLbi1QHvhNuPWFVYb1VcrIzX1hnYzL2u6bWrUA37W+wV8BhTGyfqm3UakqbfdPgz580obd\n", - "y6vEsGXGM9K32qqO4+4b9HUig7HkUZjwtfEx2X3JUBJQWjjed3/wzPGTgvtr2xZLEbeRf6TTNqN9\n", - "pNSg9rOq0tUnjfv2veuGzUzP/dTeV9froYTiA4biOKwSBalIJUmSJEmSdGSHUKSYnfetRDnMtlGm\n", - "sKawukYFihuz5bZWGcoDvjdYvYAihDVNLhmeL7IGWP92Rcr31PN9jLBeUF48GgxcQcOfgs8dBcqH\n", - "SCSP+nQi5fNJT3qSpEZJxFqvbfccx3kABRLYT4499PqGdtwW6p3yIZKnpGjOZFRKFHTNceWM+j77\n", - "ApWT/FHcd8mnhv9nrHBfKMYOj0ob1uemL0blHzmqeqc94isFtFf3l22L763I2OTXi0ARY/WkK7XR\n", - "fY7vJ0r7o32nj1SSJEmSJMmEmJgitfPOOxdn5+w0TWZuFAyUF/Ih9QVKytKlSyU1s+5RK1Iobl39\n", - "A9xvI7Km3Bop+WdwvNcTVg7lhZJAJA4+T9RbpEjh74GihZIy333SHJ6jdp3fywO/HnyLsPpQDFEc\n", - "SxErWPP777+/pKYduB8K1xsVXaNb/XfzRZ2YCRGlXS1j1DrGMhQZr1v6VG1faKuU0Xf5jOqMtsP/\n", - "cz8oDJFf27777iup8T+lLjkfqmNttNZDhVFHzPoYT70wxuIbRL23fbfxLmAM8bElgnbP2OZKJLCK\n", - "EfX9SM0v4e2bsfWUU06R1GTw70oqUkmSJEmSJB2ZmCJVs1bM7HT58uWSmtl8pHAMC8oO+0ihsPS1\n", - "vjsq3CcqIlKgUJCicvXzo5xgTfon1kdtdBr+Exy/o1mpWGW11pmXJ/4n++yzj6TZPnNYmUSelKDd\n", - "omq4YhlZgxGchz5bihybL5FXo2BYHxcUAfzWaPOevT5SovBJcb+52jEAaBOl33m0HXWP0sFYgILA\n", - "nmoc73v7MZZ6m2oLvi0ohNwnY0kpH9KkGNW7C7w8XQHzsbWtIuUKVy3ka4pgrCu1x2HrFWWK9s+Y\n", - "O+w7PhWpJEmSJEmSjszrqD38CLDWNm/eLGn0uVSYtbIe67PlUUV0dAWr0K2/Ep4bJMJzmuAfQvm4\n", - "zw2z/Vr/DhRArO1R+6T1TdtIGN+njb+pR99ZvW3uF9QKPr1+anMXYXWSzZvnnHTW6UkybB4p+gyf\n", - "tVFPEEVwcl/UWW0eotJYynlQejg/ChS/Z6xGNY3arPsDdo3QRVV1v8quPjTjYtwZ8VEGUYn93dYW\n", - "6htltW2+q9J5R717CAow7zwUzWH9clORSpIkSZIk6ci8VqSwbrCgWb/Egh/1erhHT+F7UuurMi66\n", - "+hm4ddn2eliTKHV8z3lrfaTIE0S02Y6SYwdQKGuj4dwa5HlRJyg3zovV7XvmRWAl0i+8HmojhzgP\n", - "1lpf1ueOzLD5o6hjPmkzqN5dLXLqFKXAdyk48MADB87/rW99q+q8rhTQBlyRoq1GChf3hWrOWEpk\n", - "dltQWPikT83X/VBh1LkQHeqfPuzKZde9G2lfbX3zSvc5amiH+Krdfvvtkobv16lIJUmSJEmSdGRe\n", - "K1JkGyWqCbB+Rh2ZwSwZRWw+5rWR2kdhQWkWjpJBRIP/DivalRiOJ5fMFVdcsd3rEOnzzGc+U1J/\n", - "Vs64qfVlcl82rGraM+0Mq7Ft9mCs/ai9ogLURhChiI064mhHwLPGt4W6RE3Hsq/10aBuI39IVGKu\n", - "QxvyPd5qfak4D9Fe9HXfbSIaSziesYScaKj6w5YnjDo/U1+0jXZri48Vnol+2PtB+eN8O0q5A+2P\n", - "5+7LHzcVqSRJkiRJko7Ma0UK7r333oG/x7UOjvI1X5UowEpldo1V2nWnb3A/CFixYoUkadGiRZIa\n", - "JYXcLuTmYP2dvz2XCPf5m7/5m5Kkww47TNKOq3zUWjce9cm6vUfb4ZtX63uF6oBage8Z54e2ETvU\n", - "f63ySTuAtpFk85mnP/3pkrqPCdQNeaSo69pIYK9LBz9SypqxgfOX8vk4jL341hBth2qMCupjNKAy\n", - "++oBKuyoI7DnG6POkec+WKymeN9jDGirKHE81xm3v7CvTg1LbQRziVSkkiRJkiRJOrJDKFLOM57x\n", - "DEnSXXfdJanxZULh8N3uH+qgPGB1DKtEOe7/cOihh0pq8km5VeORPHvuuaek2dbwwoULB77Hyv/K\n", - "V74iSTrzzDN7uf9xgbXZNicJe0ZSjyiulGtbBYl+gfrh/jFtreK2e1ri8wbjVKJQ70YV+TlsniLq\n", - "BDW3rUVfirbzsm6bWy6CMQVFjL9LihLqsmeMRt0kjw+wP6dnRmesaRtBiiKGWtyXT1ZXxv1uisqp\n", - "L9+mcSuKw9Yfiirtq6+xKRWpJEmSJEmSjkxMkVq4cOF05ApWmWddZf0d64X1fvaGwzrB2inlRcJn\n", - "h9m4W634pPi6aWlH6knj6+KUq6+D81lSrNgzjnJ2ReOmm26SJG3YsEFSY1VSvu6zRfSlc/PNNw98\n", - "jgueB+t62BwigBpS8j+gfoDyxrrj75LfDNdDiaW+8EeJfKvOPvtsSdJnP/tZSc3zc19EW6IsYUXT\n", - "z+gfXG/Lli0Dn6eeeqqkpl+XfKQ4D9Yi7Qg1g/uL+veSJUum/z3qHGSoc9xzV1CW5tsuCRG0Zd+r\n", - "jLE5GiMZm2hb7mPlvlVEnaFMMZaQY442sXbt2u3eL22WvsF9EGk8LrwPPu95z5Mk/fVf/7WkRmmj\n", - "b/D3smXLJDXlQZ/mk+gz6oHf1eaa6wvP1M47Gx84yp9yaBslx1hN3/cx1ccMjmOVivKivTGWMHeg\n", - "3fLu9yjUkk8ipCKVJEmSJEnSkQUPTMAkWrBggaampsZ92SRJkiRJktZMTU2FCnIqUkmSJEmSJB2Z\n", - "mI/UJz7xCe21116SmtwsrKOyDn/rrbdKatZB8dlgHR7fHKKQWBflfOwvNS71i+tccsklkpp1a3xe\n", - "8IsgF8bSpUslNeuyHqXFOji+KZQLeXqOO+44SdIHPvCBgeMcjifigXKi/GrzNvF8fPJco9oniev8\n", - "6Z/+qaQmWhN/i/vuu2/gEziO9XLKBd8w/GgoF9bPX/3qVw9cN4J1c9bvyZPVdt8mrnPuuedKmu0v\n", - "w/3hV8B983z4gdBuiNajf7i/kNcf4F9wyimnSGraCX4cQAQU7fOGG26Y87mOOuooSdJznvMcSdJ5\n", - "5503cJ/4TeBf4XtZ4oMH9KPIt492+La3vW3az8wjIGkL9Cl8Uo4++uiBa3s0GcfRxikbnmHcY0vX\n", - "60V9lefwSNNS2+wbrveJT3xC0uzdFDwSlYhfxkDG1vXr10tqfKGod9oFf7/2ta8duO6o4Tqf//zn\n", - "JUmbNm2uRtxUAAAgAElEQVSS1LRtfMB4DtojY90tt9wiaXY+Lt6N+CTRl/CD/OQnPymp6TvUP2Pi\n", - "ypUrJTV9+pprrhn4m3c072bOQ1/mHXbiiScOPOeomNnXJelv//ZvJTX9fPfdd5fUjC2UK2P1unXr\n", - "JDXlxlhKudx4442SmjkF5Xn66adv975SkUqSJEmSJOnIxBSp+++/f3rWi6LA7BBrwrOyYjVhXRDR\n", - "wOyYWXbXHcX74vrrr9/u/2/dulVSOfIk4s4775TUWGOREgVEzUXRc22h3ryenLY72mP1eFQb9Y+V\n", - "gHUaKRQofKgPDlYp6oIrICVQLfgcds/HyNqP6ov6R0nsev2DDz5YUmP9r169WlKjgKFUYZWedtpp\n", - "kpry2rhxo6TZyusLXvACSU1/9UgbVz9QGYhUclAAsRpd8ZupshAFduWVV0pqxgosUM+JxblQZq69\n", - "9lpJTVsjqodnoM+hdo8K2mZfUYiRalzKeTZqJcqj2ihvxnDaIvePUoOqj3LoSiP1zXGMFdu2bRvB\n", - "U9TjUWvcl78zGFNL+Z48j5OPxbfddtt2f48yxrsXPNKbCFyPEK99pzBGUC++awhjB0qSX4cxwJVK\n", - "z03o70LKm37OJ+2FVQTmEvw/SpbnOYtIRSpJkiRJkqQjE1OkZlo6WNSsY2KVHHLIIZKaWbdnMic7\n", - "MLNYrJu2maWBfDTMnlHKImUjglk3s3m/H3xbame7DuUD7FHH+u6o4blK+xS13RMR6zvKNVKrHJXq\n", - "C6sVa8Tpug/VuBlWCUNRw6eQdkq94f+AYnTxxRdLavJFUT5YiZ67p20/xK8JHyvaA8omStz2cuV4\n", - "DjpA4WDcueOOOyQ1qpqDIkVWftQ/nm3UYJGjnnbFfYXwpYnAXzCi777BWAsoDChHlIMrarwTUHQ8\n", - "RxnPSb4vxvJhd33wsbdtbkGUTPou7ZG+SLtFneWdhx8mz8UYyf0wlrVdjeHd6WMu72Luh3JzpahW\n", - "seT3pfJHBffzth1LaveyROmi3XMcChxzjBKpSCVJkiRJknRkYorUggULpmeLzEJRcrBSsAZRbjZv\n", - "3iypmUUze8Q6wkrpmoGc87IOz3nbKlJYE1gJeP5jVTFbxppAAWC9mfVaysXXd13JinZed7BKKTes\n", - "y1Fng26L+0g5XRUPJ/IbGbcShVWEVdo3bvUD9Y4/Du3Os0/T/qN+gH8D7ZP2yPe1oHzxO/o//cOj\n", - "M2EulYixhWeg7Udl4eBbQxndc889khrVjKgxzsfY0dfeYygB3jdLEYwO90U0U0mRKikMffcNvx7K\n", - "Uuk+fYxHQWRMIzM6qxQlP9IS9FFUWhSctu8afPSisYtIXfqA7/6BYke78Ihr76PUe7SnI32dd5H7\n", - "v3qGcIc+Oiy86+jLUT9ynzrq3Xdn4DkYOxjbfDeLaMxltYVxoEQqUkmSJEmSJB2ZmCK12267TVuJ\n", - "zDI9Dw6zYazBaAdxfu/77bQFpYfZeNed05nlR7N4coJgdbiVx/o0s2uszyg/Ue0O8u5HMKwSNao8\n", - "Um51kD8Ma4V6aqtIEYmBqjCsotUXkVVEe3YFti3R71yR5D6wBkuqAFD/WH9Y6/hruP9B1G54XtQk\n", - "cuq435O3d9QhqWkbWO6eM833BnOwzLG0PWrM+6Cr4X2B0uD7XPqYUILnZQwtEe3PGMH9lco1wvsg\n", - "dcmqAHVd8sf0evH7oV7b7vUGrDLgc9W1vvHzc1BM/DlpX6ixvJt4t5TKHR8fypE+xv2j0LhPEX6I\n", - "kQLJfbhPnfd1YFWGd7u/i7gfj8jnfhgziCAGxgaI3rmch3cJz80qV0RtP0tFKkmSJEmSpCMTU6Qe\n", - "+chHTs9qsXyZjWP9+WzXLVnfuRlro3bHZgfrCOXLowlrra7aWWyk5DBr59N3LK/18xg1o8ox4+VC\n", - "PVM/JV8irGr8A/DZQeHAGkK5LEUqTYq+VA6PtAHaEdY8qgWKaWQ9O5Q3Vq/fNz5Y9E+seu7LI5Gw\n", - "mj3TPwoXyhftYaaPlEdD8clvSmXKtbgn90fk3mBUfm2ekR2GVZGJ/vL8O+AKWASKAWXPmOcZxPFh\n", - "icqJ8wBtg/ugbfkuBSWI8KXNMIZGfaEE5cU7qracHPoc5cQ7hXbF2Oftl1UOV3IcH8tcqfP2z9jo\n", - "ebhK0D591Yb2xVgL1APlVlpF8XrivhjTHfot5Ri1N88j1xepSCVJkiRJknRkYorU97///WlrhNmm\n", - "511ito4V4koFs2msHuia6wXrh+tgBbSNzPD7cYjMIJsszxFZiczyOa4U1RaBVVdrdZRoq+RwfRTE\n", - "yLp0qwnr0r/3aDfqz/OPUW59+7HsKER+DqgutG/+bptrh99hpXo/pZ9TP1iltB/3xfIoVKxNrHna\n", - "z1yRcljg/Ia+iA8Iv+Ha3JvnpmIM8r7Ste/Q9mmztTnW/Hq1/oj4k/FJG9h3330lNUqbW+61kZYo\n", - "BpHCw317PbhC4uXA8+Ej5n60/ne0SuCqM2NmydcqArW0q48VRH3LVz+IFuN+a/1gfZWg9l1Yq3T5\n", - "+f0d4KsnlD/tr6v6z+8jhZb/p12Qr+vmm29udR2UM9phbX9IRSpJkiRJkqQjE1OkZloiWCvMLpmV\n", - "8xlFD2Ed+Kw7im4rwfoq98E9tvVLYNYe+VYxa8daLEUHUj5koO6qSFFOWJHD+lu0zSnj/g8RXl6R\n", - "kuTHcV72l/KIIKxjfK48B8vDDerfrXyPjCmBqkOkG/Xs1/GdB2rVFdoZ/QqfK+pvprKJakVb52+U\n", - "IJ7V9w7z/RPJQ+QWaddITyz+YftcrSJGWaNA4VvC2PP1r399zt91zcEX4TnrnCh6K1KqOL5UDrRB\n", - "InVpQ6W95yYNYxr7sQ7rg0dfRpGlfrkOqy6lCF3K0/e/jRQvX/1AZe6qSLkPGTD2cF7eAV3znXnm\n", - "+tpM8alIJUmSJEmSdGRiipTUzB6x0rAOUWqwJrE4sUBdoWDWy++6RlRgbWK9drUemSVzHz6bxlrk\n", - "OLfgwXOfoFzhA9QW1ueHfT6otY55fqzSkmJYe16//5L1hnWOtYfaMF+iIMcNChI+R0B5oF6U/HlQ\n", - "iKJIM/w/fN+0tu0PK5N98mhHM++fe0cJ4RjaFGoun/R57tktabegu+ZLgq5qOdB3S2qqPy/5hLj+\n", - "sBnKa/0t6fuMhfwu8hVyn5eovEtth+vQ1nhnePkzxvatxA2Lvyv8Xdk2gtx9iKDWB4h3MAoW5eh7\n", - "Wkb9hn5WG+ntqznUH33/uOOOGziO6/GO4Z3J2FDyjUNZI9oQP2byTpVIRSpJkiRJkqQjE1WkmC1i\n", - "PTCb5HusS9YpmY17bhdmk1jYZMVtC7NaZtnMgrtab+6XgNWDVYDvE/4YZFlltu/WJxY9mbm7goJA\n", - "3qBR5YMCj/gY9fVQ+Nxq98gsrL75kuF83Pg+ZOz16PtuRdB+PSKN9kW/QXlFMWyrRHEdV5lgZnui\n", - "LrkGfZi6pm14H8eSZszhmh4huHz58lb33je1eZB87KLssbhrfW8ixaZWNaZtUe6MhSglvnpA+ePT\n", - "Qz1Sx7VRd9Qf5cBzeN6qrnmlRo3vs9rVV4r+QHm7kki5RlF5wFjAJ+9cj9JzRRHajvmRf7G/+1HB\n", - "99tvP0lNu6Gd1+7OQHuhvfJ79sst7bmXilSSJEmSJElHJqpIuU8Ss1ssWmaJ0R5bwB59nAero3bn\n", - "ZmDWjBXq+xzVwmyW5+M8KCLkj/JoJFcAfCdvGFaRcmVmVHgOEY8Y6ev8bh27EoV140qGKyoPFTwz\n", - "eORTR3tDrcGvAKvS99/yfcboX54PjnKl/buaQT+lHZQUKs8mDihqBxxwwPR3+DbwHZY8Odr4G4va\n", - "fTl4NlRtz8NUG8UTQdnw7G3zUtX6WGGJk4ONMearX/1qq+tRx8P6ENGGfHUBnxtgrEV58Azp1Hmt\n", - "qol/HsqFK1B9jUV9w/223fvQ4V3GXoGMhZQv7Y8+Sfun76Nk4UuFny6/a5tXq3Z/1qidu4JJf6bd\n", - "MBbx+1JORxTQqD3V9reH1hskSZIkSZJkjExUkSLrKJElWImejRilitm1Zz5mFr1ly5aB78luCrWR\n", - "JkQG1GbCdkWjlKsEXxSuw6z+oearU5vzZdjzl1i5cqUk6Zprrhn4ftgIqr5A6fH8SKgl7hdQ4tBD\n", - "D5XU9Bue36GfYaVjBaNmoMJwHJ+usKJ6AFbeihUrJM229vgbtQerMorkIuLMs1RTXlxn5j3yLLQR\n", - "LHssavq29znaxBVXXDHwO+6N/z/llFPmvNcSKDzUccnnx8cWyrZ2rEDVRglwVb+k8HjEJiomz1Gr\n", - "bqPCH3300ZIa/0yHsXDYHG9R5Oi4mdk2u9BXZLX73boSy/cLFy6U1LQL+rrnW/N9cv16DkoS/bOk\n", - "SEXP7XmegDHSx0rafeQ3SyQ3+4s669evlyQ997nP3e79piKVJEmSJEnSkYkqUtF+TezQTDQbs+PI\n", - "ZwiY5aIInXrqqZKkJUuWSJJWrVolqVGEmE37rJ3ZMLNZPlnPdwu67To2Vh6WvCsj5K7AYke5i/L0\n", - "OKUIjBL4maAQ1u64PiqwgttGT5IJflJ77GE9UQ+0N48cov3RvrDasOJofyVfPdQKzu85e/A14nwb\n", - "N26UVO5XWHOcL/I3gUsuuURSY41HUbC1+4fRv1CiURf4XLdunaQHc8ts2rRJUqNOc888O2VDGaCU\n", - "UAf4H3Kv/J66YOwAng0fIsYO+iB9iOP8PlyRoq0ThYRSALQNFAHOQ5m6xc35I+XroIMOGrhvr1PK\n", - "iQzhlBdjxLZt2yQ1fqGMZT420gcYmylnng+lilUIyguFqrS3n0P581yezwqOOuooSY0S46or5cn9\n", - "Rv6EvGOI6qR+fGynfimXrmNT7ZhIH2HsQcnkHYbaix8lmdCpV37PdYiMRxX2HHy0D/6f+vJypX9G\n", - "94+PovsUen8o4Xs3OoyBw5KKVJIkSZIkSUcWPDDqpD5zXXTBAk1NTY37skmSJEmSJK2ZmpoKV3lS\n", - "kUqSJEmSJOnIxHykxqFIcY1xqV/z9XpHHnmkpMaPwX1TPBM169oedXfOOedIkt7xjndIqo8o4fxR\n", - "zhHWvT17L8/1vve9T1Ls5+Hr6R5JVOtPEJWn509qG11JtCnr9fhPvOY1r5nzeqOC67zzne+UNDuH\n", - "Dn4p+MNQjjw3/j74fXhOGeB5zz77bEnSe97znoHrRfm88A3En8F9wqhH3ylg5vPxjFFGbn6L7xP3\n", - "gq8RuxHQV6I8Q1znIx/5iKTZkcR9w/Xe/e53S5qduT0i6luO+8+94Q1vkCR9/OMflzT63HM833nn\n", - "nSep8RHDp4k8YF6f7vNEfeGjgw+Y+zS95CUvGbjuqJnUu4GxGt8mfLPwQ4YTTzxRUlPua9euldS0\n", - "a/yVGQPcT/Gss84auO6oqS1PfOB4fvKo0U7wjaN9M/Z4hH/pOqlIJUmSJEmSdGSiUXvjhkgTLG+s\n", - "FvJNocRceOGFkhorlVwTWM58T5TVF7/4xZHf+zB4ZIXD81133XVV52ub26SU/bZkLZfyRaGMRFBf\n", - "nhOnFtoF6gXWe23EDVY0ikrXvSBPOOEESU2Oo65EKgvRmddff/2cx9Xms3LlsLTfFeWKAhVF2KAo\n", - "bq8esbhRnogC43vqgDqhLqhTLG6imYjSo827GonyNWpFCtqqobWZu2nLrvCMaxcEoI6JGiupyNHz\n", - "oZSgZNEmS5muH2rQbonMjcasL3/5y5Ka9s5uIRzvv7vzzjsHzu/wbiV6kv7nuyyggKIEU0+MGdQf\n", - "12nbHskDxXl5V6A4sTrjY07b3IepSCVJkiRJknRkh1Skop2hSzDb9l3umW0zi0a5wnrBYuaT2Wrb\n", - "jNN+/8cdd5wk6dZbb5XUWA1EBrTNmxSBBb/PPvtIasoNJY7nrVWkOA/WwqhxK9mh3lAhUMBYF6d+\n", - "axUpz76L1UR74bxYMVhnWF/klEGlwJpCGWubCwVF8bDDDpPU5LTheqtXr5Ykvf/975fUvd14zqW+\n", - "9yHDdyrydStls/a9G+eCsqbsKXPfU4tzcVwUjUNdoT67IkTenCgz8rD4/pttadsWShmnu1I7Znsd\n", - "oxC2VeJow9QfmdSjfRsf6tCO/J3m+C4Fnhmc31OOkSLlmeTpJyhT7pNIfaOKe3+Ndj0owbv69ttv\n", - "lzQ7M39fORJTkUqSJEmSJOnIDqlI9WUpe0Zy1k+xYrCO8N0gcgGfHs+AXgv3j3LCrJzZMhFDfYHP\n", - "C1YACk3Xfa26WgddKflYufXj+0V5hEoJt9ZYr/csu76OjlJHe+D6tBfOi49eLZT35ZdfLqlpj8ce\n", - "e6ykxoerVn3A2uO8KFvct1udbXd4jyj5SkVQXjzf9vZNow+hsmJx4hPFs5OBGsUDxQKV1bOwU9dY\n", - "5oA6OCq6qouUA32BfT0hUpWjiMrSvpREx5EZm9+xKwMqZEnF9z4VKVGo0FFbiFTokro9arqupgxL\n", - "yQ81ApXfy7utQshz0w587z5/53p/Y2wq7U0Zwf1z3q7PEZGKVJIkSZIkSUfmtSKFVenKUFewzrBw\n", - "idjxvczwh8BvAmsMKwtfD3xl3EqthcgUlAGs5ZIvSVuidWb2vWrLsDuzt6U2+T4KUFe/CqD+fcdy\n", - "2qPvB4bawSeKovtWYYV19XvxHCc33nijJOnrX/96q/N4O6B8seKxEsknxSf+RF0VU99RvhaeGxWF\n", - "+5/rPHznOa74nmck+ueAAw6Q1ChU9DmOI6qH86HeAf6No6JrlBnPy/O4pc95SznW/HkjGDsPP/xw\n", - "SdLSpUslSRs2bJDU3Z+UPuS+W/RFxl7apkeXuSI1aR+pcStRwFhG/ddGXjM2UN78XZufzCPGUYJ4\n", - "x1E/7t/qeyUOuwELiiljCPf9la98RdLs/GRtSUUqSZIkSZKkI/NakcISRfkhQzZWVq1li/LErNeV\n", - "Jnw3sJrc98nX7Znd8+mz8lq/AldMmOVjHZPbY9Tg14CfyI6K1y9/o4TUWmFYS+4zxHmwsojO4//x\n", - "Q6F9YkW7ooli1hZvH0R50n7pL8Nab7RL/Gd43mEjXFALIpUB/P95Ht9BfnuUos+oK/Ll4P/IuXlm\n", - "6pJ78PPW5hLrio8hriyVoE0wVrmlTw65rVu3zvl7VNTa61xwwQVVx0dwf1F5A9/zXFE9uNKwPf+6\n", - "YfBI1wlsYbtduL+2/q2UF2MNvkb425YUKY5nTEHZRUFkLOQ4VmloB/gPD5v/6+qrr5YkrVu3TlKj\n", - "ZA6rREEqUkmSJEmSJB2Z14qUR7c9/elPl9Ss13rOiwifzWLVge+hxiwbZYK/sTKw5rCG3MqpVcrc\n", - "qsQKxperb18pB4WlbV6j+QrlST1izbfNxI71Rj1i/bry4+XmOVc4jvblUaJtwaeNSDGsOdb/8dmq\n", - "zQdWAgWqr1wrEKkMlM+yZcskNX43KIv4rrUByxllxXN54aPh+aRGlUtrWCgjv6+SXyDH83va6tOe\n", - "9jRJjc9YSUUfNbVKDmNlW+Wn6+4GKCaM+ayO8P3mzZsl1SuUvIM436jKHf9M3iVdI67xx2RPvlIe\n", - "Jt+9geM8Uzr14fu/Asf5O7srvAtKu2G0ZaiRfeHChXr84x+vnXbaSbvssovWr1+vH/zgB3rhC1+o\n", - "u+++WwsXLtSnP/3p6caWJEmSJEnyUGKoidSCBQt05ZVXDkStrVmzRqtWrdIb3/hGvetd79KaNWu0\n", - "Zs2aoW6S2SizaazF2j3PUBawxjwfEIqP+z5xHNYs67Zcl9m0r7N2zQ6MJY6V1ZcSFfkI8fe4MpSP\n", - "GtoB9dT1uSgXFC7Ox/mpF8qVKDaUU4/WA77val3RLmmPnJ/23Vcm/Enh7ZFyR4lyf4ou/i5Y/vQx\n", - "6tDHmLYq5rhgrGV3BmgbhUU5oLb72DcpqOtSzrGNGzdWnQ9lBAWiq38i0V70MTJ100bb5mlibOFd\n", - "QfTksPuCOrRvVnNQLFGIan3tOJ56QRH09sL1aKe0s65jHvXVlyIVgTJLv2qrdA59d37Biy66SGec\n", - "cYYk6YwzztAXvvCFYS+RJEmSJEkyLxlakTrxxBO100476dWvfrVe+cpX6v7775/2tN99993Dtc82\n", - "MGt35ag2x4nnqkBR4vd8YhWgVHneKp9lYxl3jdDw9XY+h82X5UTWKtYf5dL3dceN+7cMC+XmWa65\n", - "Du0GXygUKfJMoWiicrjvVluoL/x7ukYlzndQeHleyhlVoY0SRd25r1RbS3nU/oq1UOf+PCVVHmWG\n", - "yGSP5mPsa7tLQ98M60fo9JXzzn3s6Mv07dp3gL97UIRoX1E9oj63jTLjPhm7XCVvm9+L6E76j/vq\n", - "UT4OClbb/U5pt7RTV2L7gqjErgzVaq+55ho97WlP0/e+9z2tWrVqOgkbLFiwoHqykyRJkiRJMt9Y\n", - "u3btdv9/qIkU64pPfvKT9fznP1/r16/X7rvvru9+97t66lOfqu985zuzvPe7wKwXZartejS/x6LF\n", - "qmSWzPn4HivBZ9uoa3yP9TBsbhKui69N31FSEUxyh52NzxeoX4/0qPUDAH6HwuO5bdyHCiURRQqr\n", - "kfO4AtVVkcKaczUFK3DU+76NC88kj/JLZF0bUFhQCbHAUc05N32bOnUlfb7kBXLfmlpQMVHVGbtd\n", - "9Rt1XqwSffkGgau0XfMGoehQTuQ78jxjJUrlG+16EN03Y0AUzclYQblyn213V6AfuaLmChfXpw97\n", - "bj+PZC5dj+dijJuUH+jxxx+vq666Kvz/zj5SP/nJTwaWLC677DItX75cp5566nRStgsuuECnnXZa\n", - "10skSZIkSZLMazorUvfff7+e//znS3pw1v+7v/u7Oumkk7RixQr99m//tj72sY9Npz8Ylq5RcMD6\n", - "tmfpRfmpneV6Do5hlRxm7ygaXRW3rvSV1XW+gbVDubbNGYKVST1gDWHdYt1Tfu47Vco91DUCBeuS\n", - "ve94PqxCFLEdHZ4TqxfrtosPGHXDbxkDqANyb2Gxf/Ob35zzPKPKiO1wX3ziOwOLFy+W1Fj67tNE\n", - "2d18880D39MnaCsocSgE/G7SPlJ9R2d51B67OLTFI0lpV23V7sjXjrGmbU4/+kbpncH9oii1VVhR\n", - "MFFyUWxd2aKd+ViJr1ZteXH8nXfeKalRToedC4yKzhOpRYsWzRmC+sQnPnFsW5skSZIkSZJMknmd\n", - "2bwr5MwowfqrR+tF4LPBrBylYthIAqxirJTIKk62D0oNSiP1QxbeWh8b91GjvrGmPGKKPQprrbxh\n", - "rW6UKJ6nb78S4D7xJRy3gkm2bcq7S1ZmLGPP+I2li89U14zPfUMb49OjqlAgiLBFYaCMiG7CJwxF\n", - "gN0S3DcFpY3rtPWdKdE2ovToo4+W1CgotDkUpdpVgAMOOECSdOCBB0pq+qj79NRSun/6ysEHHyxJ\n", - "2rRp05zHRVGftL+27bB29YL2z1jRNgiMdoQixPkiXyfyTXE8ymetIoVyV4pmnC/kXntJkiRJkiQd\n", - "magiRdZSIkmYxWKFYEUxi8Yq4HisKc+R8eu//usD18GC33PPPQe+x/pCgUBh8Igd/BKwBvEnwBoc\n", - "dmfqYa1Bsux6TpNanxnWnz03COU57v238P+ohXrAv4MsxPzdNj/W8573PElNO8Mao/2hIKLUoG5g\n", - "fdGufV8n2jfKZlfwf6H9960iANbjpHzpqD/acRfVCB8Zz+nFsw2rRNEGxqVofeMb35A0u2/7bgz0\n", - "WZ6TfRppK4yF3rb7iopiTFm0aJGkWKFx6CPUPc9Dn0Z15rkoB1YF8OXZb7/9JDXP5VnzUb4Y23lH\n", - "cBw+ZChZt99++5z3i7LDrhSUKwqV950okhjVnPIvrXL4GMc7LFLOuG7XPGi8o/gsRZajHKJIun9y\n", - "idp9PhlLeWe7is67gf6Bgsd5+T31Tz9G0a1VUlORSpIkSZIk6ciCByaQIGXBggWampoa92WTJEmS\n", - "JElaMzU1FfrBpiKVJEmSJEnSkYn5SI1DkeIal1xyiSTp+uuvl9Ssl7JOftNNN0lq1qePP/54SdIt\n", - "t9wiqVlXZ90V3xR8YvAlet3rXjdwXdZd8fnB1yvyXfIcHRFsxfOiF71IkrRhwwZJzbo+GdJZD+f+\n", - "iew56qijJDXr8KxnEyHBujL+E0RckDfs0ksvldSUj2fXZdbO9fAb4Hv8Blhvx1+A9Wj8K175yldK\n", - "Gn1b4b7POeecsVwPuM65554rqSkf93MhAgk/issvv3zgPPw//hqeQ4j6fMtb3iJJ+tjHPiZp9t6R\n", - "+HIRkRNFseID5lmMydGDn8vv//7vDzznqJmamhr6WvRBxoKor3KdcbeVyy67TFLT5+hb1D15+/Cd\n", - "oQ54nq985SuSZkcsM3bcddddkqRXvOIVA9d1It+wtj5j3jY/97nPSWoiUrlPfFYYQ2lzjBW0Zf6f\n", - "tsmn+4++9KUvlSR94AMfkBT74tDWuR73U7uHLPX0J3/yJ5LatxfKk7G49rq17ZN3Ie+o0t6EtCue\n", - "i2g6rvM3f/M3khq/VN6B+CZ5lCHnoV749GhPfNmIaOd6vONov1yPv9esWSOpGRNf/epXD5yPdz/g\n", - "b8xYS/viXReRilSSJEmSJElHHpJ5pByfxWOloFB5jplrr712zt9F0WulHbuxBkuz/ZK1wWzb12k9\n", - "Fwz37/mOUIK+8IUvzHl+rK99991XUmMVEnGDIkU5oDyU8Gg2otwisMLGRZeM2X2CNUi5ejujHp/5\n", - "zGdKaqxn2hMRSiiPlHOU64X2giLZNluw9xd+T2TYfN6onD6JeoZFimVOGVOW8y1b/N577y2piYZD\n", - "iaFPMdbwyfMxZrBHHFFmlAPRS7XPGylObaMXvW2iZLhCxH31vddaaQyjrXubh5IC1zbzuXPkkUdK\n", - "ap6/VpGqhdUJxoTSO6o0VngEsUeFuiKF0ujPxfGMfbRPz7HI/qIoU1u3bpXUvCu9fv/xH/9x4L7I\n", - "VYcC9Ru/8RuSmvKojbBORSpJkiRJkqQj81qRIo8UPj9difbJiqwM8gTVzv6xEh3PyxTt0F2CciBL\n", - "r+c0ueaaayTNVlba5u7Aerr11lvnvI4f58oHSoQrZrXliDUzqR2+a8GKYn3fn6+tnwjtAWXKc71g\n", - "NbIkeY4AACAASURBVN14442SGj8e3ycOFSVq1+A7wfcF7WI+K1KAosM9k5dnyZIlkmb7TswX8FHx\n", - "/Di+txmW/5VXXjnneagj1EzO4xY8Cp1vB9Z2t4AI8j759bZs2SKpqR/aPGNSrYpKeUXHMyaXzkd5\n", - "o6ChVOCjxupGVyL/2FFvt8bYwyrE5s2bJTW+QtQP75gSKJy0P3zLolx00bsBHyfGxGisol0y1qK0\n", - "0h8Yq8kHFimu3AftgHc3ymhpD8RUpJIkSZIkSToyrxUplB5ms1gFbfe243e1CkHJQ9+J1pU947pH\n", - "QxElh7IQ7bGHIof15LNjIgt8f6q2YBXhR8H5fG84skVjdXi2aN8fzMH6RYFCOeO53K8gUromBfWI\n", - "tQM8T9t9oTg++h0KFVmtsZpoN/wdZS2m/QP1POwekQ7tBGtyPuCKBGW2atUqSdKZZ54pqfGpuPji\n", - "iyXNVlp4pkjdriXKbF0LUXX0OeqSsaN27zX2I6VcfJcIB2WAMQilgb5cq7L78e4LhY+Ut2UUBuqT\n", - "scB3u2As5rhI5YWSao+PjvvcUI/46ESUlAzalftFosxRr76fJoog30djvkeMO7RzxnRWPdgzMFqV\n", - "AFefade0K8a02ncS5eqRwVH9UT8oSihO0WpBBO2JCHhWFQ499FBJqUglSZIkSZKMjHmtSN1xxx2S\n", - "uu8PBG6RQ2n9vJZotu3Wq1uLzLY9d8VVV1015/mwTvCZAvwcsCa7rtejULDOHfnaoFjhk9MWjywC\n", - "rGy3zuaLEgUogNQbVhd5mNr6wHnOFAfla/ny5ZIaq536wsqP8PZdOr4rWIfjjrrcHv7s/O17baGw\n", - "RPsWDqtEARb7sP6AtDnGxlolCrg+ljtjIcoEuG8UdC0P7xv+d7QaUOpTvipQUmlrQdFB2eA+ahWW\n", - "kpIRlSOrFaeccoqkRvm58MILJZX9IP36KGrub0w7ItIbRYf+EanWrLI4lDvKXe19Av2Deiv5W+Lb\n", - "xdjJ9XmX1F6ffkh5uKJZIhWpJEmSJEmSjsxrRWrYiBBgvdVBAcK66Gq9REoCyko0q2e2vHbtWkn1\n", - "ypiv+7L+XZp9Y23iF+A+Y+TgYF2YWblbTUSRdaVkhQ+rEI4arCZXF7r6vZTyWGEFowBSf7XXdR+3\n", - "trl+aqH94Yc0HyF650Mf+pCkRokinw6qGn0FlbFv6ANtIzw5nvumr2C5e+64CMY6nhPVHrV5XHC/\n", - "8/V6qOFdlUPqqS0oRJHfZK0iWGq/vpsFY1FpTOLd5sdRvq7EtVVMo9UKh/rh/LR7xsy2/qo8Fwqe\n", - "j50RqUglSZIkSZJ0ZF4rUl1BSYFoNkx0mSs5noslAiswUrxqrcO2CoyvG+Mzw/e+9x2zcyJ1sGZ8\n", - "ls96MLlRWE93qwMfm7az/VqidfG+fNqGBSuvq1pRa+UA/grRfmAlvP4in8G+mHT91OD5ZD772c9K\n", - "ko477jhJjf/bqBQp2vghhxwiqcnTU/IHxGJmbKIuaVO1Yw5+lERp8bzDZuIuQR9mzMTfEPie8omi\n", - "zUqgilIu+Ox4pG0J7oOxkyi9Wr/Nrn0h8tXrG8b6ww8/XFKjhLE3HXmk2I8VIr9O3p3eLqN3aeQr\n", - "yLuFd1KkCNKeuC71Sz/g3Y5PF59RNCKrR5SLzyUiUpFKkiRJkiTpyA6lSPlO3JGF7tZCtL4azZJr\n", - "13O5n2jWOqoM3Z6nB+uT9W7wSBesjMhKIirMlS33K6D83Wroaj3WsiNkzK4hUjDHBfXl2Zr7YlRR\n", - "gePA2/6oIE8PSketystY5qozv6dtee49H9NQEhgTsNxLeZGGxX26vK0wdnOcKxY8b+S75P/v+Yza\n", - "7vbgufQY62sjc2v3I3Vq30FtfewcdrHguVBkeG7PuI5iSXvxfuLtMtqfFjg/qyrA/Xj+Lq8/FE0U\n", - "Kdo/98FzsPpUUvVdSatVaFORSpIkSZIk6cjEFKnHPOYxra0D1jdLmbN9FhlZl8w+o1lzKXIHqyRS\n", - "YvpWpLDeyBsFzN49u69bt5EShVUM1113naTGGuC8QHnyifWH9ejWZsm6wqri91Fm7Lb5mUZNV2tw\n", - "3HsJeuQQ9YIy1VaRKilZXa3wSbL//vtLatp0X3mjHHwv2BOMKMLaOqCvcZ+ModQpfRVFKqoL310A\n", - "haq2j3XNg+VqrPvr8TyRDxLquO93yX3zvDyPP3+011oEYynXcd+lkk9a23dcW4ZdBXAliHeB+8ui\n", - "XPq71f+m3/Dc/H+k8ESR5rQTjo/KEV842j3tgPaDYkU9lvZcRCGjfzA3yMzmSZIkSZIkI2JiitQT\n", - "nvCE6tk6s1msDGarkdXoeWz4m+Pd14rZq1uFUQ4QjyQgO7KDtYVCw2zYrT4UJaybyIrkd66g8XvP\n", - "SM56N8dzfna6v+222wbOgxXr5er1RPlRXu67RD3Vri9Tnig7XXOvjJuufgldfb2wkmjPHkkT4ZE1\n", - "tKNSrpiIknoybDbpSUCZooaOKp8Sajp9saSuO1jYjCXUIf6RfPL/RN66KnzEEUdIavJnLVq0SFJ9\n", - "3XVVVVH+GGNckSpFw1FulANjB+ejPFGLfSwddpcElA9yHJb6kKv5fdPXrg/4QBFFyphPe6iNPqQ8\n", - "UMpKY3m0WkE7oZxRhPxdhJIE1LcrUhCp6dwn9XXYYYdJahSq0vOnIpUkSZIkSdKRiSlSixYtmhVJ\n", - "4bNT1ms9ssWVFMetPHKksHcf18EHilkn/899MatlFsvsl73uWHfFmnP4Hb5dKAG+Ls26e61vyebN\n", - "myVJq1evHjgvz+2RPUA5R0qUz8r9Ph2PcPD1ehQp991yqA9+39ZK39Fou/8UoJZgZaFI0R6xyl1R\n", - "dKsVP5Ha/cIeyqBc0FYZY4bN3h/hY0vbTNuoydQdfYe+y98oRlHUHn0Mix9VO1Kfu7ZZhzGOscWv\n", - "V4oAZmxjLPZcedRfrbJWG7lKtJfvRVhSKtz/tC08z6j9Q2kvX/rSlyQ1Y0pb/0naJ+2Kd0O0J6SX\n", - "H+1w7733Hvgef92vfe1rA99T/9QjYyTtivPx/1F9+7sHJZdyj1adIBWpJEmSJEmSjkxMkbr11ltD\n", - "hQKYHTI7ZZZb+p3DbBsrkM8777xTUmPNue8RPkaei+Smm24aOC5ap2YWzmdkfZZybThuxTFbv+GG\n", - "G+Y8Hp8cv08iX/APwcot+d6wnl67bl6KLHFlpGsG73HjebawWrBm+o7OQ4lCHWCvSBRR9mx0/D66\n", - "+kaVQE2YdJ6sGmjzixcvltSMKW3HllrooytXrpTUlFXbvs9+mCg6rqTVPgeZnVEnURK++c1vSpJO\n", - "OukkSf0pUcD5wcea0ljB2Icq77swtM3MXutjxHG+z2mJUrRXiUlHKjO2+apM1C5YXUG5492K/y6K\n", - "FO9Qry98o+iX9BNWNVg1ApRj6p/+xJjHahD1UFLYmGNwX8w9WP2JSEUqSZIkSZKkIxNTpB796EdP\n", - "zzqxDj1rLJZtZOFi5TFrZrbqs9xIGcCaQVnA2mA2jeKCMgW+55v/f4RbF8x2mW3ffffdkprZM74u\n", - "Pvv3SBDKDysUPwSsVJ4PxQTrivVkZvPM1vEbAY9Oa7t/1KStqlHhme09K3bfihTWEkoi9Ut24lpG\n", - "lSGe5x33XnsepVsDlivqp+9XWYv7/9F3iJ6jjxEFdPTRR0tqogI5HssZyz3Kg8ReaH0x7D6Ok4Ix\n", - "xRWEtqC8AYoXYyFjH32M67q/IsdRn/x/lBNvXBx00EEDf6MooRzR7smVSB/mnQDsyUi75t3EOwtQ\n", - "OlmFoV48/xblwv9zPsaOb3zjG5KaTPuUs/vt4u9Lf+G6jM08D3sG8i7lXc/vUM54PuqxVpFNRSpJ\n", - "kiRJkqQjCx7oKxFFm4suWKCpqalxXzZJkiRJkqQ1U1NToU9dKlJJkiRJkiQdmZiP1NTU1LSPEOvz\n", - "fUWI4DP1pje9afpa44DrXHjhhZKkZz3rWZKa/bRYh73lllskNREH+Efw6RnD8YVhPZkorWc/+9kD\n", - "1x0V+OT84R/+4ViuB1xn1NejfN/61rdKkj70oQ9Javxe2Nswyl9GxBP+LKUcNvjAvfGNb5QknXfe\n", - "eZKa+iYaj37hkUz4upEf7frrr5c0O5cOvn74GVCOX/7ylyU1kU/4heCfcPLJJ0tqfL8uueSSgeuv\n", - "WLFi4Hqe5Rn/o7e85S0D1x01U1NT+rM/+zNJs/PV4DNBH3NfC8+U7Xu24QtFH3zNa14zfc3twVi0\n", - "7777Spod8VuL9wWex6OUqDPqnroBxqCSPxvXOf/88yWVo51e/OIXS2rKhbF33bp1kqSlS5dKasYu\n", - "ovU2btw4cL33vOc9A/eHHyxj0KZNmwbuGx8nfFquuOIKSU2f4Xf0ScprXGMLcJ1zzz1XknTwwQdL\n", - "aiKW8bPleX0fWNqR+wDx//g48U4988wzJUmf+cxnJDXl6btj0A/wDcKXiOhKjnd/ZKI9Kfezzjpr\n", - "4DlHhb+L1qxZI6kc/Ypv2DHHHCOpGRPxqybfF2O+n6/0XKlIJUmSJEmSdGRiipQ0uuzBo95xuwTr\n", - "qEQqYAXzNxERWLtYz1hZRDAwi8Z6wSomE/u42FEyjXfdkd6tcqxZzlPKpO+RKxEoV57jh+/Ja8b5\n", - "PHoSaAdYjx4Vyd9YXQ5WXZRJn+clgozjUdKIkqOcaMddM6WjxGHtRvtv1eDKCedGVaRvuiJFXXuW\n", - "ffouilXXnG/Lly+X1ChCW7Zs2e59l4gyjhMViIX9yU9+UlJTDscff7ykRtlAMQIULaiNYkSF/63f\n", - "+q2B++M+yJ8F0Zji6ijP59/DZZddtt37qt2PclzQ/lAmfayK+qxTG2XJ+Up903MeOihQzrjftd5u\n", - "avsjYxTReq7UojR3dRlPRSpJkiRJkqQjE1WkJg0WcN+zaqwgFAasW6xdzywd+YZxHLNlFAQUgmQQ\n", - "1IPa7NTUv+9JiJ9M3+2C+vS8XL5DOfdF7pabb7554HcoQ5FViupBeXg25pISjCKGNUv747pYc1xn\n", - "2D37sAKXLFkiafZ+a/iP1ORrcwsfhYW8NVHm7KgPoqygDrdVpIA6fOYznymp8W/DX7Kt7xQ+MQ75\n", - "qVC48JejHLDoOc5xxaft8+LvhyqKIoWPGG0xyn0WKQKU/7B0zbp/wgknSGr6Kn0o2k2iROR36eov\n", - "75LaXHxeX9wvv5/0ag2+X+Rw9EzlJXw1huer3ac2Wl1AMWZV49JLL211X6lIJUmSJEmSdORhqUhh\n", - "nWFRM1tHCcAirs1Y7mBNoAhgJbTNvsvs26P58F1pC741WN9t/TLmO/gUoUgRaYKV7cpJZJ2VFC38\n", - "RrBeaveu83V54Dz4HmGt8TftAKseqxp1xfdKdJ8jh8gefk85YP1SXq7u0G6wKqPy65JpXGp8A489\n", - "9lhJzXNccMEFnc4nNX0bNa9t5nLfvSDyFSlBhCRqH306Upa6guKEysrz00Zpg94XGLMY+7rCc7Jr\n", - "BX58KC133XWXpLIK7/Tlp9k1Mhx1lrbtmbrbEo0FjO20D95VvkchuK+c91miJPtSpKJ9W2vhndNW\n", - "iQJX4WuVqBKMsR4tWtvfU5FKkiRJkiTpyMNSkcLK9AgF33enK1hfKAtcD6uv1h8ChQXrEuujqzXk\n", - "SgvKQkmZIm/RfIfn47nIGYL1E/nyYP2BW3VY6Vh91ANWi+dyaas80g6xtsjpQjtBOcIfgPaJnw1K\n", - "Dr+nHUdqB9Yk1ik5h7gP2ivtDzUHPxW+d6sU6zmKNixBNCsK1MKFCyUN74MlNWXTtm/3pYRQp7Q1\n", - "FALaWq2/Jn3RFQY+UUzc74/cZPQNh7L233kbqIU2yJjHeWkzqKu1yoSrzeOGPn7jjTdKanzPuhKV\n", - "J32I85f2rXSFzX0AUVLdT7IrE9gIZYBa9b8trhC2bWepSCVJkiRJknTkYalIRaDM+M7XXcFq9Mgh\n", - "8gaV8g9hbfB7Plm3xcoc9v5KDKvQ4ZOD9R35BwyLW3lY3/vvv7+kRl1w66ykIGHlocj4DvGeeb4t\n", - "bkXiq+TWJtelfaKURVF4UT6mrVu3DvyO+/byQyXhe6xB/DWIyIJI6W0LChtZr2l/XSPmpNiHZFxQ\n", - "JvRhlBrKrKQ8AH6OqI2RH5srafiAoOzw/x5RHEWwtlWkvI2innJ9z1cVwX2j8jOWMAbyGbUNroeK\n", - "zBjcFsqJvs75UGjalg/KpKut/E09lpQkxiT6preHUY21k4J+0zdEzxJV25ZUpJIkSZIkSToyLxSp\n", - "Wl+dUUEkAtbKsBY166vkSsFa4Py1kUP4dZCPCt8orNdhFana9e5h6wXlI/LP6BsihihvrMVo3bvW\n", - "mvT1eX6HLxxqQdv1dbemsb59HzVUAz5rowu9nl2JjJ4/iljBOqd8PZdL3/3Yo1+7QFm44jJuKKOu\n", - "2dtR53gOouJQKyO/OPZjPOSQQyTNVjBQx12xaau0OPj54U9IbjSUJc/rw3GMde4nisJS67tGX6Jv\n", - "ds1HhYLmYwCKWVdFCuWJ5+W5ajOX43uHkuVRl7XtHYUNdZr74bPWTxEVm99Fedsi8J3jnedj16gU\n", - "KcqdcYLr1N5/KlJJkiRJkiQdmReK1KTzGTELrfVTKIHVgq+HZ8quzeWBcnDPPfdIaqwYz9Pj6+S1\n", - "1EYK9RW51Fc9R0oL1iy+O1g1WIu19Yv16cdzXT6xljkuUojwD0Hh8dwnqAzcJ39j7eIzVasg0h6w\n", - "Vr3+iPzC1wm/D4/Qiny+aNf4b4xK5UFFQFUYJvIIy3LSYw3X76quUSe0Qeq65MfoajbqMIoI5/GI\n", - "4L6itGhrjDnu9wkoYjwPn9xXW7UXxY3ydlU82rPQIfqNPsUY3LYe6StEylIflINn9S+1V+6f+3K1\n", - "udYXjec//PDDJTX1Xtpn1KF9Rv63UXnjm4TC6pHI4NGSffhPSs19U96MhalIJUmSJEmSjJh5oUhN\n", - "Gmbtw85qwTNfM7vn/FgztRY2Pj/4Ffh+Q8zSS4qU5ybBOigpUrVWzbiIrGRXArGKsP4OOuggSbPz\n", - "eB1wwAEDf0fKFdflk3qO6pHrUe8oLFGuHpQqngPfI35fa41H1n6ERyLV+nuQ7Rk1g/LwvQPbQr+h\n", - "/GqjS7cHPklds673BYpMVx8p2h5tlLoqjV38jr7hvkL0AfffRCHi97TNtnWCWkxb27Bhw8BzOPio\n", - "8Ml9oShF5YdCgcJAH0BZ8HKi76FElMZQxkqUEtTiWnzfSlYZKF/GCJS022+/XVK8euDn83ptqxa7\n", - "Gt+2nXI/0RhN+VNPRFSz1x3tM/IjHtZ/uQTP3Va5TkUqSZIkSZKkI6lIqbGu+vIHwPrCimCWjTUV\n", - "7YEWwfFYKT5bxxopWQ/8jnVorB+UkMjKnFTuHcCKLVnBlPOqVaskNdaYR6I4ns8La8kzmkfK3ZIl\n", - "SyQ1WY/JE8Z5SpnssYKpZ4/yxJquVaR8v6j77rtv4P/dqsO/AmrbE9YbVjXW8LDKLvXN8w67r9lM\n", - "+vKD7EpXJQpoI7Qt+jBlHuXLct8V9z1h7HNLfNgoQ9hvv/0kSStXrpQUZzSn7dN3faxDXY5y/VEO\n", - "HEfbxMfJy8VV4BKcv60S5fBcqMD0Se4HP08inqOxh75Kn3EforZ7C+LH2TU6rtS/KH/aI8/HWEd0\n", - "YBQx7Ipb3/3Zd3eoJRWpJEmSJEmSjjysFClmvVhlzDo9Y3UJrCUUC8/dgbVItBTWF74jbZUvrC9y\n", - "weAj9Qd/8AeSmiis0k7VWJt8ch8lpacPH5U2+Lp+2+tv27ZNkrRs2TJJTbmsXbt2zuPdavP8TR51\n", - "CSg9KD+0L5THm2++uep+8UugXqlPlCKsZXySgOPdRwtrnP3TPPKE+8Tq5Pk8E38pGpTzo5L0ZR1S\n", - "zihSfUYFTjpqz0GRwB/Mn93bJj4zWM4oF4w5KDCuXnquPB8rNm/ePOf9RX2vViUGng9fGHyyPCrM\n", - "VVjuMxprI1B2UDwYi13RaKu00RY9CrIW+grlR3uk3umTe+21l6TGB46x32Gs477wOYLavFkcx2fX\n", - "XRpqYYykHRPVSXnyPJ7PqWsesBL0Q8Z8xrzanI+pSCVJkiRJknTkYaFI4UfgETOew6MWZuueDwju\n", - "uusuSbOtwq47l7v16AoE16sFK2dcmcbbQt6lrvB8lFvXKLLaveOw5sk0j6JUu7M9ihbWvVvdnisI\n", - "ax71wdsD2Z9pp+4jtWjRIknNc2ENY43x/1jdfL9p0yZJs/0wUMqw+oeNjMMKxVrH960PeCbP19MV\n", - "+hD3jBrIfoau3Lga7ZGO1DFjkrc9/ztSKhyu03Yf0UhxaasSc54vfelLkqRLL71U0my1k9xv0dha\n", - "C6qy++v59ag/+hL15yow/0+UH30Gn56TTjpJknTkkUcOPIcrXvyOvuSZ6PkbZQ7VFx8vV6Xpm3yi\n", - "UEFtBC67MzDWRPt39oXXi+8JSH8iUp298Px5+vLfZVzgXZpRe0mSJEmSJGPiYaFIMfv1CA3WRVGs\n", - "+MTKqJ3Nu/UUKU+eObovPFss1izWllvdWJPcJ8f7PklYz31GTdXQNVcISpBHwqAUkY+L9fhhOfjg\n", - "gyU15YsfCFGRKEGl6xE1SCQQOXbwk8BKJjqQqECsXfdlQtVwJQouuugiSbHVTzug33gmeay1yK8m\n", - "2u/Nwb8H5ZB26XsKOlF7r2HY6DOHuqEseRYUBZQv+j73Sp2j1FBmHiHa11iBOtnW98VzjJX2gON5\n", - "PZce+47y3KW25/+PvyD/H7VtIFM2am/Upo466ihJzdhAPdHWqReem/uiz9HXaQcoRn5/9FmI+ggK\n", - "C+2I5+Xd5IqU55fq6gPI7hnDKjz0acqR+2OMRD2nXUd7Ax522GGSZo+BtbtscB7ug3c67RL/UsZM\n", - "3h0of6lIJUmSJEmSjIkFD/SVPKnNRRcs0NTU1LgvmyRJkiRJ0pqpqakw4j4VqSRJkiRJko5MzEdq\n", - "LkXKM1GDZz2tFdG4Rlv1i3Vv1rVZNy1FvJSu1zb3iv+O9VzKh+v85V/+paQm0gHfFo6r9Vlx8EvA\n", - "18ifj/Vwz4Tt/gGsSxPRgm8N9c36NOvSrKefffbZkqT/9//+n6TZEUS0i67+AdwX/g5ve9vbBp5v\n", - "1ETtBX+I448/XpJ0xRVXSJodvVbK80T5Evnyspe9bM7r4UtHe6Gca3dWx+8HfxTu//TTT5/zeqX7\n", - "LuH9iHp8+9vfrs985jOSGp8P/o9IxI0bNw6ciz7OcbQ9fDdoy75v41lnnSWpyVpP3VBmtEmPxqNs\n", - "iZIiyuq6664buC/yAZFn6bWvfa2kuG2639iwcJ3zzz9f0ujyb+FD9cd//McD1x0VM9tKzfVo29Rj\n", - "yUcsgutccsklkppoS3/n0e5Wr14tSfr85z8vaXZfKfl7dn33deXhcr2IVKSSJEmSJEk6Mq+i9qKI\n", - "EizQUbtzYSl7xudhIxmwRokewyqqjR5D+cEq9H2envzkJ0tqlB3ut21+KTj88MMlNVbYlVdeOedx\n", - "UeQM1jRZmKm3devWzXl8qRyiXDbD5hfivia9/5qD0kZuleg5S4oO/amkpLragEKF1UuGdqxz8nzR\n", - "vlBDPON/RFclClzRnTku0PaJcOTZUZp4Ji9jnoHvyRvE3ygRnrMLRYm+QJmjOPE7VEGUKr8vz+nG\n", - "dUoKiJc5Y2XXyFenpER5rrG2tP0dkbG0Ic+MXqLtO4Sxoa/oSW+79ClX44F9Q1Gljz32WEnNagFj\n", - "Z7SakzxI34qtk4pUkiRJkiRJR+aVIhWBNcesG5+lvmbhKC/4eKD4oAQMm/0Y6xYfIpQpLHuy4EZw\n", - "X5GvE1YxygHHl/bei8AXzfNJlUARO+SQQyRJRx99tCTp7/7u7yTNzv6MH4v7WPWVrXZHwX3RaA9t\n", - "fduwusidgm9TW+UO65j+te+++0pq1BnO53s3QtudAvoEpefAAw+U1Cg0WKLkpeEeURpos/R18gXx\n", - "7ChGtFng2WmzKBiePwnlgDrhfKi3fE9ut9rs8L7LwrjLnvKhTXT1x6yFckLld2r9+qDWX498SJQ3\n", - "yibXc9+7CNoffqLRWHf55ZdLkl784hdLkl71qldJasb2q6++euD4USlRbcuzFi93z1XXN7X76HYl\n", - "FakkSZIkSZKO7BCKFPv+uLUTzcLZn6gWFCkUFKwrFAJ8QfBXqI26wzpkto3SxSwcpQpcmUCpIZtr\n", - "tP+R+/gMu4ceil9b65LfoaiceeaZkppoPay6z33uc5Ka56QeH25KFERZnqOdx1FZsOo4ju+ph65E\n", - "2brpF7QvsgOjYGK1to1K7RPu4YYbbpjz/3k2VFwUKBQj2iQKFj440TPhs8NxlA1tObKEV6xYIamJ\n", - "GiRqj9+jwhMVWMIVsXFBXx/W760WxlAURKetchL1MYc2DvjWtR2z3McOlddXD+hrF198sSTp2c9+\n", - "9sD1WH3g/jlPX8oU7bBvJQqOOeYYSY3ixfN69GpfUC6o9ly3axSmk4pUkiRJkiRJRyamSD31qU+d\n", - "nhViZbD+6ztB1yoj+HRwnlo4Hr8E9lDDmvzwhz8sKbZKo73o+N4VAhQm3zfII23wGYr27gOUCaL3\n", - "PCKpLVjpKHW1VhuwH9SWLVskSaeccoqkxsr+6Ec/Kqmx8qi3HQWiKEv7fdXiVi1KJO3RI4Zohyh8\n", - "1HttFCgqCvmeqCfqm/uhXXEdrDmUKP4fK5t6R/WZBJQdz0Lf878dxhjfaw0fKMqc8wAWO2MFf0fR\n", - "QZQN/oQoEYyF/A6lp6QwEB3IfdGXapUs8D3bahmXEgWUD5+0ffpK2yi+rgpe1yg+v17pPPQpfO2W\n", - "L18uqWmfvh9q27HaoX3yDtm6detQ54ugnRFtyt6IJUUK1b0trP54dG4qUkmSJEmSJBNmYorUox/9\n", - "6GkrDCuy62ya2ThWSVsrA2uTWf8tt9wiqbHusNDdauP/meU6zLa5P7dSa6MOsYqZjbsPFFYhn1Fu\n", - "mrbZid3qqYXr8twobyhr3Cc+ZFgL3Peo1uX7IvJp6gvqOVIHKFcy8LtKAp6xHFA+XbVwRZR6IdII\n", - "6x8rGiXK81QNm9+rLTP7H9FUjClAG4zqjr6K2kYbpI/yTK4+42uFokVdRH6KHPf1r3994N65LhtN\n", - "GQAAIABJREFUX8aayB8SqAvUdM6DSohfInVKm0JFdZV7R8s/xHNQr4wl+JlSXz52RasHXcEft5Sr\n", - "DfwdVzsm85woqkRL0k5557kvV1tovyg2o4qmW79+vaSmfx111FFVv+vqf0k5UT59rSZAKlJJkiRJ\n", - "kiQdmZgi9cMf/nBaocFq6pqN1yNkPNdLCWb7nr0YBYpPrD2sH2bT0bqtR+1hNWD1HnHEEZKaWbbn\n", - "EfJ9vlAI3Np1axbfKqwI7g/FrnY2Xjv757yUH4oTVgBWOz5bnkPHsyO39e8YN8PmFStBO/HyR4VY\n", - "tmyZpNmKn+PZtaE2vxjWPdchUz39IFJ+/b49Z0xXf5yImTmFeDYUF1c36ZPcOwoW/mL4a/oYQnSd\n", - "q8r8zTOibJXaCGMMipL7OJV+j7LGfdPn+Zs6oy74nmi3tWvXDpyv6z6V0FWxcOWwBGMZzws8H0oK\n", - "vjZ9RzQ7KHmct1SOkXpcgrGTMYBchIy9vDuG9TfFz5LrjHo3EcovirItQXnSH3h+2iefo9orElKR\n", - "SpIkSZIk6cjEFKm+vOVn0jWSIrLo3dqLzh9Z5ljH/v9YvVizWLFYy1hdvj7NZ2TxY+HjL4GVxH23\n", - "VVIinzXPduvn5bk3bNggqVEgiIgi6o0oPhQyrPTSXm0PdVzlANoR5Y0fSOSThD+OqyiuVEbKI6oO\n", - "fZX2hdJF/8BvwyOIgHZE++5bkZoZ9Ujb82fCUkXVpY2hSHHv+G44d99995zf8zvORx3VPhu/QwHw\n", - "6L+oz2Jh4/NBGfN76hZLnTpDDUfRKEX2Rm2EukRRY4xpOwa7slSC52Qs4fqUH8pMNCb3neGadlWr\n", - "eDA2d/U98ihP+lpfUXswatXd3yGo1b57QgkvP8ZMz+c26ujSVKSSJEmSJEk6skNkNh8XWMpY2kRF\n", - "RdYoRJEgWL/uk8LsmOhAlBl8UDgfVh/WYBRxxHVYb8ZKGnYWznndz4R1eZQOruN7r6EwHXDAAZKa\n", - "vQWxcrE6UASxjkdtDc03Ir8a2gHlS3nRbrC+KE8/T6QOYM2XrD73O8CfhfNHezF6e+H+scb55PzD\n", - "ttOZKoOrXygT9A3+pqzYtaBrpKH7I1InPGOUA46+haJC2aLWMvZceeWVc/7efT94Pu6H61MO3If7\n", - "bZbwMQj4m+t2jYZrq6B4Xi+i19yv0P0ugbY/LCiZbdsu9UM7od5ro+1opx5dGq2qdGXUe9P5GEE9\n", - "td0r0sc4b0/jyvSfilSSJEmSJElHHtaKFLNXPP9Zt8VqYZ2Vv5n9YgXhd+D7J0EpNwuzZaxHrBJm\n", - "57X7OGHVYIXhJzDs3nVRdmbPSuvWKIoFz0cWZ47HKiNvF59ds9bu6ETWPO3To94oV35H+yErcSm7\n", - "c9u9DWn/+KFg9d9xxx1zHu/WMWqNt4u+/BZm+qfQF6IIYPoY0Wv08ZIihU+RH4eyxCfPWjofYw5l\n", - "S13gj1aKvuI60XPSx/A5YeyiD9YqcJQnfZ62Q5vk76512TUqDIUNdZxypDxYXXCVty+1G7/OtlGA\n", - "1G/XvE+0M/wSu+5eMV8p7eJRgrFg3HtOpiKVJEmSJEnSkYeEIuUZwlk/BtZdsVpQknydGvDd8EgM\n", - "LH7PmxRZd6UM3fzedxJvqyRhDXo+rGGJrDeeCwUPq5frUx8eTYjCRXmhRGE9jNuKmBQejRdZpZ5d\n", - "G2gflCftutbaLuVr8+g6v49h/UxGmdOlNo8OmcNXrFghqezjE1n+XI8yq/V5oa9QlvQllI5h1VlU\n", - "Q+4DFZ2xrbatMNYxttIW6PM8f+1+qH1DvdFWWR2Inq+vDO5do+OivR5rQbFxH6bIJ2xHY9j7p13S\n", - "DxlrSzsFDEsqUkmSJEmSJB15SChSRLpgjRDxAsxKmc17Flisrv32209SozwxO8ZKROnh75JfAFYC\n", - "s2OsOawivi9l8va8UL6OzH250lDKE9QV/C/4jDKlU+5Yq1hx+Gu0zSEzLmr3QCxBZnB2NifajnZW\n", - "S+k+2lq5qCB8Uk/0H9rLokWLJDXWPtCOa7M5j5qZ6k2tGsveaChDkT9gCTKgo1ihTPGJ+k0d0lco\n", - "M+7D8920tcwjRYLrcJ9tfZlQPrxcKa9J+zX+y7/8i6TmufveSy+C52/bbjyCO4qIjXAlCv9TMu93\n", - "zZwe0ddYOC4oR8berj5xrmiVSEUqSZIkSZKkIxNTpBYvXjxr52rWN7/97W9LKs/22Xnb96lyHymf\n", - "xRMpghWDYtLXOj/+Dp7jhO95LleWsGKXLFky8DfH8Xwe6YISRUQOChYRHljdtXsZoujx+9rIElfg\n", - "UKDYv8kjhygfyoP7LPmW9Y371bATOUqPR1fSnrhfrHyUUb7n+VDeovrzqDz3+4isKtSAvfbaa+C6\n", - "Ub4xIK8X9YragNXpVi3KE6oL16GdoGChtvRtFTtLly6V1LSzYVSRrkoUuF+fq3PeN4E2UFJl6YOO\n", - "58ui7dF23H+TvjdzX8IaSjn0+la7a6HPUH6UA21j06ZNE7mvEowhQCQs9UJb5t20detWSbH/KO2L\n", - "MZN3Yl+0VaIY4xgbeBfTTvikvtjlg3cc7XflypWSGlWc791X0d9RjH2Up+9gwJge5eyjXzIW1/qD\n", - "piKVJEmSJEnSkQUPjHp757kuumCBpqamxn3ZJEmSJEmS1kxNTYV5z1KRSpIkSZIk6UjRR+rMM8/U\n", - "P/3TP+kpT3mKtmzZIunB9cwXvvCFuvvuu7Vw4UJ9+tOfnvZvOv/88/Xxj39cO+20k97//vfrpJNO\n", - "mvO873vf+6p9diLwE/A9ydgr74/+6I8kSe9+97sllf0hfAdtj3Dhe9ZdWcdm3fecc86RpFBt8x2v\n", - "gb32mO0SYRPBOvpb3/pWSdKf//mfS2r8JFgv5v494oZ1a9a/Pf8T6/asD7Ou/IY3vEFSE91FxBHl\n", - "QbTjDTfcIKlZlz7hhBMkNRErrIdTbuT4oFx4vuXLl0uSLrvsMkmN7xz/j78BfiDUj+fK8R3XIx+e\n", - "l73sZZLi+nOe9axnSZI2bNggqWlf+DaV9qviOnzi68TvKC/qwZ8PKHfaL346lDO/e/vb397q+YbF\n", - "n6821w1Rjvj1UO+0z6hcp6am9JGPfETS7D3niG6iTeAPSdulb/I7vqcMOZ4+9qpXvUqS9K53vUtS\n", - "4w8H9BmP0uI4+hhtn+vRNukb3M9LXvISSdLGjRslzc5eT1skApi+xBhIm/zSl74kqdnXk0/2/KPs\n", - "DzroIEnjbyuf+MQnJDVjDL5BPA8+MUSpUW4c79GPtCH6DGMs1/urv/qrgd/TVygPz9IfjeH4bPF7\n", - "39ORsfO9732vpKYtM2ZQ3/gW0X5cAfE+xPVoTzznm9/8ZklN3+F8jCX0i3Xr1kmStm3bJkk6/fTT\n", - "JTVj9zXXXDPwfLw7eN/zrqE+Su0Ff0ui6jzimP6Bb14UZcp1PvrRjw48J3B/XffQBJ7r5S9/+XaP\n", - "KypSL3/5y3XppZcOfLdmzRqtWrVKW7du1QknnKA1a9ZIejC8+1Of+pRuueUWXXrppTrrrLN2mLDJ\n", - "JEmSJEmSthQVqWc/+9nTygNcdNFFuuqqqyRJZ5xxho477jitWbNGX/ziF/XiF79Yu+yyixYuXKjF\n", - "ixdr/fr101FQMxlWjZJme9iDR8PVRuaULGWu5ztOO575HMii7LlnsEJr8wGRmwZQJLCisG6i/D5Y\n", - "JW4tYyU4HhXFHmtE4zFZxlrHyiFvEgrhV7/6VUlNfa1evVpSY32sX79eUmP1oEhhTROl5ZFHHlnk\n", - "GehpD9Sf5xnzcuJ+S/s+YdWde+65khrrjHq84IILJM2ObMLKAZ6PcvG+gbXpeccoByKVUFuI9IEJ\n", - "uEEOcPjhh0uSli1bJql5HvrHtddeK6lpvyeffLKkphwYf6hPrGM+yZAvzY7q4Rx8T1mgCGC5YtnT\n", - "FlAioig8QB1DCaCuvW8BfSfapxAlgDHLxyTuk+dA8eA5rrvuuoH/p4xpmyg+tF3KkOv1tRddV1xJ\n", - "cniOzZs3S2r2TEQB8gzWjF20Ha8XH6MpN1eiIIoojpQTL89SBDRRbBHeHrjfKOL8C1/4gqQ4f5UL\n", - "HbQPjySOcMWtBP3J+xX1QzuO+ocTvTOHVaKgFLUKnXyk7r///umX3e677z4ti953330DL/k999zz\n", - "IbepYpIkSZIkCQydR2rBggXb3Xeo655E8xGsuJLCRe4LrB33uWLWjRUbZTb3fa6whl2R4by+Ph9Z\n", - "E6yz+6z94IMPltRY78zG3XrguZhAR1mOeb4PfvCDA89x5JFHSmr8Vlz58fviPrgeCp5n3AbycGE9\n", - "YuVhhfF8WF0oUBDVr9c/9YHfBkoffixRjh23KlE1or0WsWpRsvbff39JTT1zPM/Vt6rgqof7I5Tg\n", - "+bg/1AasSZRNzks7Qbml/aHWeJ60mvuJVDnf9SBSIoD8N4DPB/dMGXnfp81GShWgWHC/7g/n+yBS\n", - "Fnzvz/nOd75TUlPm3Cdlh1rI73meURP5y5VyoDmo3lGeJfpgpCTRZ9uukNBuKK9ozNhjjz22ex7a\n", - "Bc9d8iOMVjsiaB/e7o4++mhJzdh45513Dvx/bQZ8H+NKux0gwPAcz3nOcyQ1+a+4D/KAle6D1YWS\n", - "X/Go6aRI7b777tOD4He+853ppZQ99thj4IG+/e1vFxtSkiRJkiTJfGXt2rXb/f9OitSpp56qCy64\n", - "QG9605t0wQUX6LTTTpv+/nd+53f0+te/Xvfee6+2bdumI444Ys5z7LrrrvN2r7UIIlnwQ4jAF4rZ\n", - "NBazKxhEKGAtMItnVo8FjkXP+r9n4sYKxYeGvyPrkuvg08SnZ92NAgUOPPBASY3CgFUSWXV+Hnxk\n", - "sKrdqnFly/0m+OS+nauvvnrO77H+XAFyRSqyprB6OR4r9OKLL5bUqA+oG1j5bi1H1iT158oU/g+U\n", - "G+d9xjOeIakpHxS7UdFGAZoJ5Y6yRfn+f/bONNjSqjr/TxuoMomp5JsDNDZDMzQNDXTL1HQAS3CI\n", - "ElJqJ1QZFRA1DtGIGqqN1CUQ0USMJkaNCXEWtYwIUZFJmrEZuoGmoRtBqxONmsFPKRItE/X/wf/v\n", - "vvc8967ee7/vOfdcdP2+3Lr3nvMOe6+9372ed621PQ4G1QBvlM9hD9w3/cdxF9pfzWOJStRW048q\n", - "mdMm9KF/Do+buD9sgFgfQJmIbBCPnbkAJxZVz4nGJNfDddAXHK91P8jamBqgndwGandRgEiJcqI9\n", - "+EpKlCuK2GCk6juluFtX4KLPM+fUKlHge8XxNoN4WI7H24Eo5ohnA9fnWZSAwuf2S3/7rhC7d++W\n", - "NF9RqlUKF0uJOvXUU2fjwheiuJA666yzdPPNN+v73/++li9frj/90z/VBRdcoI0bN+ryyy+fLX8g\n", - "/WzriY0bN2rVqlXaa6+99IEPfODn6tVekiRJkiTJXIoLqSuuuGLBv99www0L/n3Tpk2z9Y32xGKq\n", - "USXvtLa+DatqlAB/rwzUeMHbQLlASWK1zU/iKmgTvAS8A7w8lBv3+vAOfA/ByMvm+Oy5xvnxErwG\n", - "j3tdeGe0R2tf4j2Tpeft7vuSkZXG9dFu/rkIrpcYI2KuuC9XwDxuAWh/FCd+4lXhzRN/wHFdFvY6\n", - "SChzfJ/zewbSQw89JKmzI7z3STsrxFwRj9IK9+exgtF1uzcbKZ5k+c09DiqsZ6PRZtgMYx6bKmXi\n", - "1hKNha1bt4787pmjEClRwJyD7XlMVS0oK9y314RrxetwlcreRO3N+VuVKQelhOvouycgc03f62lV\n", - "kCJKGcQRft3YF3Mw+2MyRplrmXvoT8YRShZjmFgn8GcT446fzKk8W/id8/MWhvtl7qlVHqdFVjZP\n", - "kiRJkiTpyeCsvccDeBWuMPDemdgTqvxG4EXxPpnYFVc0qGvjMSsoEXye1T7HweNmdY4ywWqcz/t7\n", - "b1b7eJl46FEFaP6Pd4H3xt+5DpQiV6Tw4mlPzkPcRSnzCcUOJYz2JObKlTTun+tEiXDvme95PSZX\n", - "vPCiomxD2r82g4h+watfv369pC57kDpJeIOebUj7oUBG3pfX/qFfsGPahZi7SFnrC6oHWYPRePEY\n", - "Pkqi0H/ENdTG0wDKH7FxjGuU0YWuFWgz2gLbo02xFc/K875oveaIUvZehMf6YNutmZrYJHWYfAy0\n", - "wtwxtADzuAo4Y4PMCSWlL/o+9hBVLi9V0Ob/kya6DrezqO6UZ4FGcxBzHePAnzGuyNKfbp/MvV6D\n", - "kOOiiC11JQpSkUqSJEmSJOnJL4QixSrcY6Hca4nA48crKVUO5+/RXoAeK+JeA6t33zvN95ECVu2s\n", - "7vESIkWKz+Ft4Y26h8//vdquf4/rbPVquU/iRYhv8XgGlD0UG+8/MqZKsVp4QSiQfM+Lxroq0QqK\n", - "JHW5jj76aEldfSnO75SUo1J9K68vVtrrry/YicecgatBXB92Qr+1xnZxPyjDKJJzlcloTLpN4YGj\n", - "lnHN2GTUF6U4ygjUQcYex8HmaxWlqM2irLSIaD/Gvvc3rhiz2nag3aiWjwrOHFFbFyqqe+RKCv3H\n", - "HIcNo6azVx3twBzimcWe3RhVGAfGDooTn/M5mbFfO6YiNZ63BbVKkI/11lg0YriYG2trNbbCfrbM\n", - "FYx/7tOzZ1tJRSpJkiRJkqQnvxCKFKtbV6RYjbKqjqrGkk3F6t3f37o3ESk1eCEoJ6VVv3s34F4A\n", - "98PnS3EceEF4ccSscB+0F+3hXosrVh7DVfKygO/h7RHj4+3CdXI8FDzaoTZrkLgA90I9lg2vxe8v\n", - "2vnd2bFjh6T52X1R1mVfsC9vf5hUfEFpP6xIkcJbxp76xo9wHI67UIxUCTx6VC76pKSI9I3hQeHy\n", - "/REBj7xEZDt9+5o5gzE/rj3KSnhdIqjNPmRuQlEkXq9VUSvFTvnecNgsaixznStyUX8w9zAG+N0V\n", - "NN6CoP4yF9FurkhF2Zt8368PO+b83EdJCfL2GrqPp98HBbx55o6rNh5zOgoh8cF9YxWdVKSSJEmS\n", - "JEl68guhSLFqdm8Ob5TVKp6t75OFF4IC4IqVe0F4G3if/OT7nLdUYwSvgVU63rIrRHgVXEcpXgLv\n", - "mPf6/M4egZ61Fr33doWB66M+VbSHIBArRIwUv7uX41mA0T5kJfh8aUdv4hhcCSwpUp7xQhafQ+2W\n", - "oeCN43WW2nso9BP2WxuHwvVhn7Rv35pFqAHYS+0O7QvBvbRmdUHk8Ud4zbfW2KYI9+xrwcbpC5SA\n", - "STNUnWUM0W994wH9LQVzLf3pKi8xUdheSdF45JFHRn5H+eG8PHNQArELzsOzhzme38lgZU6j/1wJ\n", - "Y07ifnzO9gzmVsaVZQm1Owy0wtxN5jBvQcZVzzIVqSRJkiRJkp78QihSrL6jzAy8So8PwDtAEcGT\n", - "rvVevZoy3gReGNlieBFRpXBih7hOx2O+gPuOFCX+zmodL4jr2LZt24Lf4/94O+zozXXWxqyQzUa7\n", - "eNYZuNfD7329l1IcTOSNluJH8FLpB88GBK8D1he82r7KTiuoHq0xSa56UL0Y+1m+fLmk+n2ziC9i\n", - "hwH3+mtAXUPdQs0r2QaxFf47tlgbq8Tno76L9q5zBczPx1isjS2hDVEm2AswojZOsMS44veGVg73\n", - "LDeUGf7O/bqayu8lJTDaxYDj+lyK/fGMQUHxOEN/CxLV7vM5jGcax0Hp8l0Uaonm7L5g130r0Ue4\n", - "EjXu/UlTkUqSJEmSJOnJL4QiFSlIrErJ5or2M4qykyLwHvDaPDaK99p4ZaUsN7wuPHYyOsBr4JT2\n", - "MgOui+PhHfG9SDkhNoZ2RYlCWWh970wND2Jd8BrGDffJ/dE/1KIB38PN64Z5PS8UF47P51E98Pbp\n", - "X1c1+oIdlSrJjwviZ/rW2eL+GR+0A5k0JUUKNQb7Ik4Er3L//feftVnf+81tnT7xCtYOn2ducFUY\n", - "FdLnklLsD9fMPTjR90888URJXYyQZ2txH4zRyLP3uE+UFRQKzyqEScWwTAtvZ1edaQ9sFvpWlKf9\n", - "sCff5QJ45jDnEA/J9dbGNDEHeTwp9wV9Y8wi1b0vXssQ+8TO+86d7FHpMXG+B2ZfUpFKkiRJkiTp\n", - "yS+EIlWi787aJfBuWAXjLXuGj+9Ij9eCt0scA4qNe0GRd8P3I8WC62P178qd75kGN954o6SuMjg8\n", - "9NBDkuq9m6985SuSOu+a73ncge8hB9G+YxHez3hlvD8HvHG8P1QJ+onqyfQH3g73gfJyyimnSOqU\n", - "HPphXJlR46qBUoL2QTlqjafYuXPnyO+oJIyD2owz7OPee++V1PUD2ZHHH3/8rBJF9pXXRCNGhXNy\n", - "bZEa7Dbj8WFef6mkRGFLjDVXjEoxSFzPzTffvMfzlOB6b7rpppG/33nnnZKkmZmZQccfF6jCfesV\n", - "oWCglrdmttI/xNKh5NF/JWWIeEBwZSi6L+Zu7A27bc2SixQc3nL0rWQPbqc8g5greObRTthv9JaI\n", - "dua+Of7QWCzman66IjeUVKSSJEmSJEl6koqU6r0ejxFB+fGYHqrsAvEQUcxRVA8Jj533uFH1Zd4r\n", - "o1yxmsc78DgOlCbOy+fxdvgcq3YUIYjei7e+Z49iz1xpIpvQFZih3hRe0T333CNJ2rBhg6QuboVs\n", - "MOIjaGeUp5KSefXVV0vqvDPsAHXknHPOGXT9i4Xvh1XC+++qq66S1B5P4mCXKID8nAvnIFaJsYpt\n", - "Epfo1fxr8Rga1DA8ZxQLlAyPfYlshlgW1FBskyr5MHRPsFaYOxgDKH3E7NDezAmRjaDMrF69WlI3\n", - "5/qcwRxL/3m9n9ZsP1RkxpzPZSV4JjAXtGaIluL+ojkM9ZqffTJTpU5hjBh3JXtqCKJa177tIduU\n", - "ZxL3O3TOiOhbNy4iFakkSZIkSZKeLPvp0M1y+px02bIl8w4+SZIkSZJkT8zMzIRvrVKRSpIkSZIk\n", - "6cnUYqRmZmZm4wlY5RGLERFlb/H+3mOQ/uiP/kiSdMcdd0jq4iGICeJ9+8knnyypi3cgpuOoo46S\n", - "JK1du1bS/D3qyPxhj7o1a9bM3ttciEkic8T3BiMripgk4gNKcJ4///M/H/l7qY4T8QleVTnaL4xY\n", - "q02bNo2cd9Jwng9/+MOS6veowx5qa62Q2fKGN7xBkvTRj3505HzEaRDPULvHHNDexAEQZ/KCF7xA\n", - "Utyez3/+80fOe80114z8/7zzzpMkfeMb35A0PwMLsLtzzz13j+cbN5yn9Xz0Bz8XioWaC/Evr3/9\n", - "6+edy+vG9MVrvXGeyy67TFIXv+UxP7T59u3bJc2vW1OqRD733iTpoosuktRlcUV7wa1YsULS/BgZ\n", - "5hhispjz9ttvP0mdzf/Jn/zJyH1OGreVaK4fysaNGyV1sTxLfSxM+nzRbhq1EDd6/vnnS5Le//73\n", - "S+qyUxkPpVgx7JJnje/2gX0Se0g/LnZ7RqQilSRJkiRJ0pOpZu2h+OCxk/kRZShE3slJJ50kqas1\n", - "4YrPddddt8frIBPGs9HIaMBbRJFy5aukUODFRrvUl5S4EmTCkIngO4M7KIC1O9Z7bZxx7bdVC+2N\n", - "11LKuGjdydz7D/WCdhrqFbviWlvDhP7zzDIUTDKcvvSlL1Udp5WhNXwcz8iKeOYznympu+9IkULN\n", - "mWufvhcdthrZBKosHjC25UoWn/O2LI0h1MwoY5e6OZEi5XvJ0ReRgkBtLX463B9KFPTda80hy4/7\n", - "RbUv1bRzUCCi2nGuMKIYMrZQQvzzfSt4O6017JYqQ9vD7Z8sO7JlvUZctIsHdulzOwoUStVSbedU\n", - "pJIkSZIkSXoyVUVq8+bNkoZ7vihJrIZZBZ955plV349qk+DN+t5sKAt4k9OGVTr1ivDQqTTuRIoS\n", - "XiOxKSiD7j24NzZpuE6vg+XX5XaEGuAqAt4y/3cviIrt405oxfurrWGCIkpMFRA38OUvf1lSuTJ4\n", - "a60kwJ4YX0OVSFeiIpWC+mKR2nPggQdK6rzehx9+ePZ//p2SOokteZ+45xspSiWoUeZtxvFK+2GO\n", - "G85bqsDeCjFN9CUxWMwlrfcZKXSRIoGNu8KCjfC9vuqsc9xxx0nqKqWP67iLzbjnOGL3UM19biKe\n", - "uHb/WhRmj51aaqQilSRJkiRJ0pMlUdl86KqYVa/HE0TwHh3PPvKWiJ0h48A9arwRMkAi8IqGrqYj\n", - "JQZvl+t1LxzvEE8eZcErRPO9krfaGoM0lNosRuwIxSxSzri/qOou3s+4q99C7Xt+FBvug/7H3mv3\n", - "qKuNhXNQL4455hhJXbuUqiXXEtlZqYI6/bxQ/6Gi1WZ4Rtfgyg3Hbd2Xc9euXZI6xYaxR8byXXfd\n", - "1XS89evXS+qUF+Y8j7/Ek+f6iTUZtxLFfpLve9/7JEnbtm2TJG3ZskWS9Hd/93d7/H4UL9jXZh3m\n", - "XNq99f7JmiQLknbl7cfjVYmaFDyDmLN8zzwUSrL6SuOJtz88Q/neUiMVqSRJkiRJkp4sCUVqKLVK\n", - "FFBnCCWq9H28OWq08D1Wy1HWHt4W3i1KUmvmAUoA+1t5FhPxBFFMFN4AXhXvsaOMCt+Rnr8/Xuhb\n", - "7wnI0KIdxh1HQH+WwHvGq+Z7rTFK0f5iUQwZoHIQI0XWXYnaGLq+8UHYI+eZe3+HHHKIpG7M+Z53\n", - "3CtjAI+ZOcH39sIW2APPY3BKmaQoK+vWrRu5VuacKLsughgkbDsam64AcP/R3mUoNhHEvGCTqNLc\n", - "D0rB2WefLalTECJFymurOX1j0hyug35stTkyy5m7eTtB7bZkFOwxynTGbsnKhEiZYozTb0P3BuR4\n", - "PMujfWNbeXw9IZMkSZIkSZYQU1WkUEi8pklf8L7cmyEegdUsnjjeaklxwWvCq0GJwjtzD5zjkW2F\n", - "V8p1tdaN4r08WYKe5VSqc4QXcPfdd0taONtJijMj+mZ9RbRWm26tVD70+1zfpLahrN3RHFUBe+qb\n", - "NYf9O7XtgZ3Xxh1F/epZlX1VB8YhCi1ZlnPBllGcsHkUJVeWGGO0NWOAOYMx7DZRiqNjjuE4KFBR\n", - "TbkS3GupEjXX73WyIko2xZhwm/n85z8vqYsXxdOPan/52I/qV6EY0o+uktfC9zlva4wqnCKPAAAg\n", - "AElEQVQU9sBxWmPkftGgnRlvjHl/C8TYZ26K2hU7YfwNfTvC8calREEqUkmSJEmSJD2ZqiLFe/dx\n", - "7YeF91mqe0RMUVRT5aCDDpLUKVGsrskeQ+HBq2W17efDy0OB4DzEVdTG4BBPwX2V4hkieK9Pu3t7\n", - "Ez/S9/i1tPZzrXJCduIznvEMSV37o6TgNZeojWGiHbGPce8LhheGF9fXG+M6nXHHCZSIVAHUh9oq\n", - "y6grC1W/pi+wYfqSc/pYc4UqyoxFUapVEx12G6jNQI1o3RMNtX+oqlxSYlC3XeV2asc+Y7evEgXM\n", - "abVj2vG6WONW53/ecDWfdudZy9hlbqtVCLEHlOOlRipSSZIkSZIkPZmaIrXXXnv1VqKiHatZ5XoW\n", - "Ep9H2cHrROlg1czf8b7wPslI4XPUFiHrzeMkOA7n5Xe8XhQGfrqSESlUxFb1rUeFNxVlVdEP466f\n", - "NC7FsQR1svBaiL9oVRFK8SL0GxlLpdghjw1CgSmB8omd943PiKp0Y8fE7dT2DwpXa6yfx6qhzLbu\n", - "g8Z44brntgu2y7HoS2y/5AFHigP36v8vxa3x/9o+HzfjUlCGxim2EsXPcR0oVbVzIXbROneiSBFr\n", - "5grL0LpckQLqTKoi/bghTtnHoWdPMhcuFN84F7e7xa5hWEsqUkmSJEmSJD2ZmiL1xCc+sbe3FHl/\n", - "UT0cV4A4r8ccuSIFrIrJ9sOrwaP2Wih8nhgUz9zBy+F6a7PDWM0P3esuirPgOsa1nxFeOO0x7hgi\n", - "h0whzkO8BjFvZD2WMqZoZxROV+g8g6mkpHj/RnZPO3E+FM8jjzxSUmdn0T5kEdS+8fNjf61KYV9F\n", - "Cq+Uccb3W8/vNaHmzgcck7HGGB2qCHE8Hzul2l78va8a68rM0H1J+9J3f8W+RPWemEsZo6i2pXZh\n", - "LLeq06jN7DKAPfFzqEIUzQW+68ZSVWIcnzN5ljBH0o70U2kNwH27IrjUSEUqSZIkSZKkJ1NTpH7y\n", - "k5/09nJalSxWw6yCvaYMq2gUJAevkOtF8cAb8awoYqr4PF4sq2nf0RpQqvz+/D360Kq/VKgmg6g1\n", - "E6gW2nfSWYCA6nDsscdK6pRFr8ZcgvaNVASO11qVGiKvmJoqnkVHLBP2UqtI0e5kMQJ21Pf6a/f4\n", - "c7wmED+5P+ylNL5d8Z2rCKIcEQ9JG1Bzqi+Mmb5zVt+941zxWGwlqvW89AlqYd+5JYrTxDZQZ1Gk\n", - "aq+P7LtaOC42jxo9NJuwBO2G3fEMGNcehJOC/mEu5lnL/ZA5vnr1aknds7B0X8zFmbWXJEmSJEny\n", - "c8bUFKn/+Z//6V3dt5XSnmusdr3mCF4Hq2Wu171SrzTu2VwoCCgOrTEurPKpg9R3x3HfeR5va9L9\n", - "0HfPu1bwgvBaqDOEV1+rpBBTNKkMGeIEALXk5JNPliRt375dUuc9n3HGGZK6vRS3bt0qqYvZ8/pS\n", - "7DeH184OAk5fdaU1hg7F1uOUvMYTdo4X6+fxGlF8b248je/FRVuvXLlSUhfbEu1L6RBXt3btWknz\n", - "22zaCgGxNECb9FVMyLpysLXSXmfMLa37nzqMYd8rkb5G1eV8niUG2Bz/r90v0mHO5njjiiMtwflQ\n", - "whbL3ohJao0po9/Ym5K3AMxZ2CdzbG28L+O2NrN3sUlFKkmSJEmSpCdTrWy+WKtLVxbw4Fnl4qXg\n", - "OXvmAd4syg0KFErCmjVrRo6P8uH7SPWtA8QO5PDNb36z13GGxoksdfBurr32WkmdwuG1TRzsAMZd\n", - "R6vE8ccfL6lTFzwGbvPmzZKkq6++euTv3JcrinfddZekLlaPmL7TTz990HVGNZMYN1y3qxGoBq7c\n", - "evYgRN6+7393xx13SOrG1Zlnnjkbb4VysXz5ckmd+oWnXar/xOeZC6gQ7mOYuaSUlTcudZMMVK6f\n", - "NnWVm/tmTBAPF+2ZB5F6XFKiGEOPPvqopOE141atWiVJeuCBByR110s7ev0h1FeeKdjiYYcdJqkb\n", - "I6X7KLHYiojHeS4WfWPxfC5gjHucr88RzFVPe9rTJHUZ2K5EDt0ZYFKkIpUkSZIkSdKTqSpSDu9X\n", - "8T5qs/MOOOAASd2ql32tItwr4X2t19uBKLvp61//uqROwSA2hVgOKm3jBeIN33vvvXu8PuC+UMRY\n", - "nfv1177PZtXvewNyvNa6QIsFmUB4udwnXg/tSz/grePduDLlXrcrUChEKCC+1yGgpOAt0t9eCd9j\n", - "6/CS4ZFHHhk5HuoH8T2oLHj99Dd/d0WK+0QJ8n4lZmr//feX1CmcjDvul+9jH95O9AufY/y5okR/\n", - "ufJU8rJpR1QhV6QWYp999pHUjRWuGeWGsYmywzEZ43jUxKdhW9iUq4VkRKI+0zded4o+cSWIPvbM\n", - "Xz5HjBYwR5VUU+IzPYO4L7SXx+MRO8XcjSJFe3FfKAz8HVv2Oeukk06S1NVOo1+8krlnbx1++OGS\n", - "Olv3duc8bptkj3F/nI+f9AM2GLUj7Rxlhrfiyil2yHkmvT9m37pVvD1hrubtDGo7zzQUU5RUnnEO\n", - "z3Lac1LQzszxXq+sRCpSSZIkSZIkPVn20ykUJlm2bJlmZmYW+7RJkiRJkiTNzMzMhLFjqUglSZIk\n", - "SZL0ZGoxUpdccslsbRbep3pWnMN7Ys8IodYG7495L/2Hf/iHkqQPfvCDkrr33Lxv5b057/E9Bqc2\n", - "84Q4h9e+9rWSNE9t4/0r74lbs/eIaeI8vOc/77zzJEmXXXaZpMnXGOG+FktN9PPRjl492duT+BYy\n", - "ecjwwX6Im6A/sLdzzz135HyThvNcdNFFkjq79OrA9CvxKevWrZPUxYEQa8T/iaNxe5hW//3DP/yD\n", - "pPlZrEBcUynug/ps0Z6NMzMz1ffmWUQRPucQ97Zp06bZcy4GnOeSSy6RVI4vw8bPPPNMSdJ1110n\n", - "KW5jsuSIcXrb2942ct5JM+25Bah/RPwgNut1x4i/JGYqmtOJvXrJS14ycj7mMmJx3A7PPvtsSV0G\n", - "MjFv4HOh1wRsbc/f+Z3fkSRdeeWVVZ93ovNFNeGGwnk++tGPSuriSh1qCfrcQ4wd45rrjOKES+2Y\n", - "ilSSJEmSJElPpqZIPf3pT9cpp5wiqcvoYDWNUuD7NLFqZBWOF0C2HF7ENddcM/I9r7HCcfAuyTrC\n", - "gy8pUXizKFmlbDm8Fn565fQSZFBw33hDMFSJitq7L5PyQvAiqIdF9p17g3jr/N0VDNqR+mGt1Xsd\n", - "svzgzjvvbPo+mVlcD/aHwkpdKBQ4sgOxW7wxMspQI3bs2DHy+7SIlCiozUCKlKiFoE9Q51C9sE2U\n", - "JmwKW8WzZ4ySfcccdcQRR1RfwyTgupiDojnkla98paSu7UttvHPnzj3+n7kOJaR1d4ZaGAP0Exmk\n", - "2DBzlCsJ1BlyVdez/EqZyZzv4IMPHjmPwxxTmjPJanRKWZT0KzUKXZHi+4x9z6YEVPlSf3mF/HFR\n", - "+wzg/PysHetRBi/jm7meeYDx7c9M7Ia3AK3ZlqlIJUmSJEmS9GRqitQ3v/nN2febrAaj2CjAG8IL\n", - "YNWIp07NCV/tezwEq2R+UuuC40dwHDx/lIzWGhd4G14FFoUhqlzO333PsqGMS4mCSe1DRTvjtUTe\n", - "CP0U1f/CzvByh+5d+OxnP1tS56Xef//9kupr9+A1Yg98D++JWiZcJ5XOiZnDe0ORxavnd/eqUfSI\n", - "HUP56lt5vxbqV0XxDPSH731Jf9OvNQoife/KDW2Nh089JuLqaAN+YmPMNXP39ZsGjH1sD4WF66Pt\n", - "Pv3pT0uKa+PhqRN/WdotgfNEig7xrtu2bRv5O4pM7RjzytXcJ8dhbPB31Fn6G+WQfmIM1VY0ZyzQ\n", - "jswVtDt/Rw2P5jrO73XHarnpppskSRs2bJDUxW49/PDDkuaPpSjWr6REUc/r1ltvrbquKE55KDyD\n", - "Wp9F0eepU0VlfNrxlltuWfDz2BExgq2kIpUkSZIkSdKTqVY2Z7Vc+36W1afHBaBERTUeSpk5eHMo\n", - "QsQg4c2iWKEYuOdONlEtrOo5HjFe/M7/qXjtDI3pacX3+msFr8ezJVvBG0WBibxcr1LreGxc36q5\n", - "XM/ll18+ctxIicJLpSI54N3yf1cs8cZRUbBHfgKZV3wer9EzvPz3oVWva4mUKKC//D7IOGuBe0cx\n", - "4B6Za+h7xhjKFJ/je/RFa6VjBxtjbkF5aY3FIIYHW3GlBCIlCriOUgXrkgLB3PCa17xGkvThD39Y\n", - "0vy4vlpoJ+ZEFJhvfOMbkjqFh/vn+MzBKFLERHnMVKn/GBu0s9837QGRIsWzqK/aTb985StfkdRl\n", - "6qIkMof6mMKua6GdSnGM0KrITipeFnwtwJzBnMp4xt7JnnzBC14gSXrHO94hSdq+ffuCx6+NL01F\n", - "KkmSJEmSpCdTU6R+9Vd/dXbPMbwzFKcoYt9XnygPnsVVC94pq2y8Ft9pHK+klMFRix+P7Cq8rVIW\n", - "nu+zVYpxwWtlVU48CHEFeHsRxNz0BW+R9i0pUpHXiLdBe/M5vDTux/eei45PjJHHnPF3FEm8S2qS\n", - "kAGFvflO9BEoTFwv+Pex89YMEq6T68LL5H7AY8fGHSPXF8YjXvaQnd49pgRoG2yIjEnmHGIkiKVi\n", - "bPWN4QA88pJtlmAsMhZ87LJHHUoAc+NVV10lqVNDUU9930/fw66kSHEclKljjjlGUqdItYIaSf8x\n", - "Bn3PO1Ru+tH3e3QlyLMBI7A9H3Oe3Vn7rGnNqKZfyQ5lzuQ43Cf9unXr1pHv8/dauB/aM9rDkbmr\n", - "dT9W7CdSpIjRo94ZsWGepRjhGfCRAkh9LNqP+l5eH8yPV9vPqUglSZIkSZL0ZGqK1I9//OPZVR9K\n", - "DB6pv1fFK2TVzCqR1TurZRSX2ve9HB+PndU8sVvuPUar8dqMEIeMEFbHeB8lhcO9pVK2FZ+nXWlH\n", - "FD28La+gzfVE2W+1tO5U7ooV/Uv/cH2oA3hR9H/Jm0GR4vPYF+C1837d4yK8LlgtrgYAXhn27JX1\n", - "axUp7JWd1LGrvplD4wZ7o788phEVyJVgr/0Sec1zoc04FooGY5hj0vb8RC2kzfBwGeOlzOJJg7ob\n", - "XQdZSoxp7gubI/Yn8tzd1kpbsTLXovyVKkwz9qK6VcSqRDEr4FX/UeaiuEjUzZLKSbtxHPode2Cu\n", - "4D5K6nqrIkW/3HbbbSN/px+5bxQ7xxUUV5q8FmMplo775S1GqyJVmiMZl8RBtiq+/pYqqtHoClNU\n", - "qZx2rq3xCKlIJUmSJEmS9GRqruoPf/jDWQ+a1TKrbbwBvAOvJsz3WL3ynpP34LUxKyhSnB/FgOvg\n", - "OB4f4DVKSlmBEax6USK4nlJcQl+FAa/R40Ycr5IbKVKTqinioGTQL9w/akNtHTJwrxQvxP/vSl8p\n", - "jqCEZ5I43A8/8YZREUrgldNeKK2lzKxJg52UvFPqb+Fts/MBcTwtda44J33l8W54/qiXXJt79MRU\n", - "lDJBa+E68PBb1VrmHo6D7fM794sSEtXNYa458cQTJUl33HGHpPnxnth8FOPC3HDxxRdLiucWsp9q\n", - "a+CV9kJEOWvNeizBmPNYKlc26T8Undo5wZ8dtXBefvJs8jpdPtapjP71r39dUpcNybOnpEjxjCV2\n", - "jf4d95zfV+n1tymuJPE2g/YuzYV95/ZUpJIkSZIkSXoy1eAJ37Xeq/N6LIXHmOBNsppFSXAvhlWr\n", - "14gBPH5io1ilR6tuYjnwxoZWGmdvNtrBs9w8i3FSNTnAvdIormCxFCm8Q5Qj2oWYOpQKj/uI3pdT\n", - "dwwFx1WB1izMWrhOj5HC7vk/dur1oGqhvhTt1NfLGhettWe4fx/fULNXpdfkwnZcecLjLsWy4Nn2\n", - "Heuo5R7nx3lbK3/jWTMGmOPoe7cZFDXuH6WtVCentuab12bzuNFWJcar+S82kRJGu2M/pbHl6j73\n", - "T7t7DTnGvGfrOcxZnmXpqi92QP9wfFfcUIMd5kKfk1oz5CcFz+KonRj/vltERCpSSZIkSZIki8xU\n", - "FSlWf6x6vcI5q0m8G1afeD2e9ed7lflxSkoO+01FmQl4De6lucLQF2JaSvv+DI0LoJ1pl1YFBu/W\n", - "lYZSXENf8ILINEGh4zqirEnsxeMAUNK4f1f8vH4TdjN0nzXuwzNTOD52xe945a31pLg/jjdtRarV\n", - "vsj8ijLAajJqsAna0vuStsFWPe7Oz1WqJVcCBYC+95ibWqJYkmjOQgnzODva52tf+1rT+SMYiyef\n", - "fLKkLm6VeFbakbm7lPW2WNX2wWPPiA2Lssiwg8huIHo2+JhEKfFdDSKlBTv2uEFXmlyRovI7dk8d\n", - "tX322UdSrM6TVefX7RnNi00pyy+aM6NnlY9vVxQjUpFKkiRJkiTpydQUqSc84QnzqtMSA4V34HEA\n", - "eF146MQosTqPvIJaj5zvR7vU40W5l9CSTbQQnI9sJe4v8shbMz4c2pl2wzt1LxBvwyubc35v16GK\n", - "TYTXdMEuUO7wIlDw8EIir5b6SmSDek0blC+PA/D92lprntCObqd4PfS7ty9efK0ixXkYXyhhSx28\n", - "e7zqIcorYxIbj3ZLgJJy0Fe9BWzJFbJWhatVneS+S9lv0FdhIJuLMeoV15k7mbNLY6e1js9QGNMe\n", - "uxbh+2VGqrgrRNhZdP8+5rmeUm08Pu8KJzFmHAcFkM+hRB188MGS4ixSn+tb7XBS0C7cXym2DuWU\n", - "uaYUA1j7tikVqSRJkiRJkp5MTZH6yU9+Mm/1jPfkq1yUBjJvyHigNgbU1tuJqPWSSu/FW2G1715N\n", - "5JXVnjfKlMEr5mek3OAt+3viSOGbVPYeNVu4TpRJvA68R8/ui2Li8J557++V8Kl4jqpBjNUBBxww\n", - "ch63vwhqubAPmV8X3h1eJfaF1+sKWKm6MPePIoXX2ZeaLLlxgF3T/qgXfc6L7dMGjAHuhTbyscfn\n", - "qehMnB11e7ymXS30nSsDreBR1yoBrfGKfccwYzFSAu6+++5exx03UcyLx+fW7ndamou9/Uu2zOeZ\n", - "W7A/oEI8GebRswOYu1BqXGUng7m136etRAFzmz8TIog9i7IO/dleG6uXilSSJEmSJElPppq155Hz\n", - "vsoltgMvjNWmx+J4RfRIifBaMBwfhYtMkyg2iT3MUM7wWtxraIXMCWJ+WAVHcR21tWxQTtwLIkYI\n", - "L33Lli2SYu+1tfryuGH/MLwmvK8HH3xQ0nwvxKv9RqAyuPfp1XzXrVsnqVMzbr/99qbrP/LII0eu\n", - "y/sD5QuVgv/jbaKO1GZ43XXXXQv+PdpfqsSklShiuqiR5Aoh4x+7pb1oT7ztuRDzwdgm9ocxwXcY\n", - "Y8xFVH6m7/FM8VRb4+KcvkoULJX6PQ71sWp3lSiBYhjZPHOgK4uMZf6PGoxNRTEvZEPW7hpRe59e\n", - "56kW5mbfVYK/k+Ht1+HPRp6Fkd2UYq+WOvR3aVwdfvjhkrq5w+c05gfsg3FfG/ebilSSJEmSJElP\n", - "pqZI/dqv/drs+00yPFi9s3rGa/TK51F2me8WD3iny5cvHzkOx2V1j7dKDI1XI+Y9LO+nuT7PzIgU\n", - "Ea9c7soY3lfkJdA+tYpUpCTg5XC+cdd9Gjd4Byh//MRb8EyokhJFf5Kd55/HuyVuAiUT+yKOpgTX\n", - "h724+uFKpvcX/RTtdThuuF7f4Z7xRQ2a0vc93gSOOuqokf97XA3jEHUAJYpsVrxPxj/e49xMM/qU\n", - "+DLiKz1GCSWDscs9cw3YEmosNnjrrbdKkg477LAF7xHb4DwoYh53h0LCXIASwnm599Y6U9z3/vvv\n", - "L6lTbbFhzu/ni+D6OS5qMHMQP6Mxh02g8DG2mOMihc/7lv7ynz7G6CfiGek/4mfp5wieHfQf58dm\n", - "sUH+X4qR8v9zfs/09tgc2hW7oZ+YI6I5aGhG9+ONyO6wV+yecUTlf2BNwNzs9ljbnqlIJUmSJEmS\n", - "9GTZT6ewhF22bFnveI0kSZIkSZLFZGZmJlSoUpFKkiRJkiTpydRipGZmZmYrerMfU19xjPflvM/m\n", - "vSmqV0n9IhuIjJ0vf/nLI//nvTbvr6P3srXni2itT8V5LrnkkpHvEdvFe33PQly9erWkLkvR253v\n", - "e1Xk2vsj+5D4BI9pIy6ltPfh0PYs7ecVne/jH/+4pO69umcCec0W2o94jVJNFtr3Na95zch5I8jq\n", - "5Octt9yy5xsJ4DyXXXaZpPnZiuPaK5FYvvPPP3/kvEPrr3ksJHDdF1544diUbu4haqMLL7xQUn/b\n", - "bKU0FogNGxpPxxx41llnSZLuu+8+Sd1cQAYqY4NdAbBN4tmoX0T9KOZQ4hOJXWHupobaO97xDknd\n", - "3BXVR3K8Zl5UQw+i9iRGjhgzYtWiMeexYsQ++RzHed7znvdI6uxqUi+EON/FF18sqb5OVLTnXu35\n", - "+Mkch50w5rFTnvkRxOYRs8Rczrh8+ctfLkl697vfLWl+zB/PIM5fOh9gl16rrzTOU5FKkiRJkiTp\n", - "yVTrSEX1mlppzWxxqO6KJ+51bYbupVeCyt2sgls9dv88WU+Rt0MmTwQZLq3KhGeyRFVhyZTgfr0i\n", - "vVcfLtWUiZQUMltaa/dw3fQ/7Ti0hhCUMoccvLNICSUjCq+zVHE96tdxZW9GVaGH7gTA/aFM0e8l\n", - "ZVPqlIXaSsVk/fi9LNUMV8bIUMgSgxtvvFFSN4aiGmpbt24ddF48/qjyeImhyg5jjExaFKUoAxWw\n", - "Pd/3Exv1rMhSRvG4cSWqtEvBuGoGMnei1PkegiWFyOte+fchmtt9/9RaeCbx7Kjdp3eqC6mlAsZG\n", - "eneUWtp3s1q+x2THQodBizHUHrdU5G3opMLCjkFVO7nxkKmVUXlI+Ssbf1iVHn7RRpV9twxCfmbB\n", - "FxW4rH1F6XIx/V8Lrzcix4MFyiOPPFJ1vKW6GKiFyZRJbm77++tDFgYspBjj9C02Q9+cdtppkuaP\n", - "dUqU9HX+eGXG+Us2w6spCgmWwEbYQsSLmpZgDNFOQPhFyflqxcsXAGO9dsEb4WUtSq88eXD7NlOe\n", - "Lu9gZzjjPDuYQ6IxOa7X6CW4f+y3daHkokIrLCRZwNHfkXMclYeAoXZRS+0CCvLVXpIkSZIkSU+W\n", - "pCKFB79hwwZJnRdH4c7SlhUucyPTo3jgdUVeCqtnX5XinSJX1m7cyPf4PAGNz3nOcyR1XglbtXCf\n", - "EbXbDkTBuSV82wEvONoXvI1SYUendP1DN0t2xS3amsepeaUkzbejVqWspILUbmMArfYbEdlXVDDW\n", - "t8jp613SfgsppX4tUZFbivQyN1DQkSDjG264QVJnC751BNAGjOloTkEhqrWZtWvXSqp/FYSiFm2B\n", - "UgJV/JprrpEkHXfccZLGtzG70zccA1tHlYy2PiltFwauDHF8fn7zm98c+d3Vfi8iO7c4rBS332Kp\n", - "wiiyjL3WLWFalShXnPzVG8kGJC3Qf7fddpukchjNUtks2UlFKkmSJEmSpCdTVaRYJXsqKKtavDs+\n", - "F3nenoLqihReCcpQKVU4CpaFvqti7g+vhe0ruK8odobPR5s7Oyg/eKdDU6L7ek/cF4Gc7m20lieI\n", - "GJps4PfXGl8SQZxNrQpRAu+ZOBiUqlJwuTOu5IlICYwCdGvVFb5PKv2999674OcWsktXDDyNGfCA\n", - "SdtnzKBEuWoabVJLG5TGWKuy0xq8zfGjmB7iMVGzS6o3oNRNilIwt8OcghJEDA9KC3M37VFSf92G\n", - "2LKH/mZuYuxhX8cff7ykbm5DycPGS7FVi4UHl7tiVgvtwrMnmnNpD58beMvE/3lG8yxG+aJcho9j\n", - "zr9U4ztTkUqSJEmSJOnJVBWpyEONVs1RJD2rZLwVj53w87S+Jx43eHm1ShHKDd51SYFBAfF28Pf5\n", - "tZRi0iLwKlwBoQBq30yQiFJq72IzrnIJgDfGfdZmDTqlYoVDac14cWi3SIkaB1xjlFXFmOPnUFWX\n", - "uMxxqZMRZC0y9vH4N27cKKlTLyNFytV8VP4oFmkorTFdjIHaDNVWW/cN3YHrREEjszmK90SRQfGc\n", - "FihB2Dt22PpWBWWP++ZZ4vGb2J3PATy7sD8+x+/8nzISbp+1b2NqKZXUaSUVqSRJkiRJkp5MVZGK\n", - "ammwiiYzg+yekgeO1+FZQ67M4LX1zWoDVrWtq+RWJcBjtlxxwTtAeePznm03rtX3UNg+Yqhy4WAv\n", - "vE/vW5RtqVPrjUdMep/yvnEYSwEUB+LQiJVpLdDnlOIuh8L1UR+L60bdQ4UuKUA+R7TGMLXWR/I5\n", - "atxqaetxaC+eOcTnPuMZzxi5PuoxRRm1zMW1GdaTguug/z1Wj/561ateJUnasWOHpC6GEGhHlKMj\n", - "jjhC0vz7pz/pf9qTZxZzchQXSyyfK1JcN8/uobRmOpdIRSpJkiRJkqQnU1OknvSkJ81mypAlxSqR\n", - "1SxeHF4gq/so64jPudfo8Qkcd2j9IeIPWjNyWr3bSLEDvAX+Hm1tM66YHTIv+sZNjFuJAvp1UvEc\n", - "fcHLmnQG1FLBM+X67giwGDCnEAuFbeMxL/aWHn2hjfH8GWPMNSgNrTFJrbW+WrOqXAGbtFpaItrS\n", - "BQWKuZ4425JNj0tB6QvP1lJcLPXTeEa6IgX0V5TFir3Rjv7sjZQo6kuhADr0w7i2QhqaKe6kIpUk\n", - "SZIkSdKTqS2Xf+VXfmVWkcJTJ7aC1SerW1a1pT3f+Fz0HnjcGTMcz/enKtH6fpYYKLw1YoDAY74m\n", - "DbVbuI9Jb+pcy2JXvcU+af8oBm2pxQz5fnSTBi9yUopU341upfn7YKLotLYNSg9zwVAli+uqvQ5U\n", - "WH66uk/NOt+U2PG5ZdJ1e9wmorjVvvGsfI9+6Rsn+vDDD0uqjwGj/6atQqO4RooU97Fr1y5JXTuV\n", - "NvmO7gtlFzv0OdJjBckCRJGKjotSNWSsT5LiVZ1zzjl68pOfPBtcJv1sp+59991XRx99tI4++ujZ\n", - "YmSSdOmll2rlypU69NBDdd11103mqpMkSZIkSZYARUXq7LPP1utf/3q99KUvnf3bsmXL9KY3vUlv\n", - "etObRj67c+dOffazn9XOnTv1ne98R8961rP0yCOPLLiK/MEPfjDrbaG44C3gFZHeBHUAACAASURB\n", - "VKIwEIsUVYtlvyy8D69PxHnI5uP4Q72UaE++ErVxB56lyA7vDn/n/iddJ4j2QpnC6xhazRevY9xx\n", - "KXjZtXvo1UK/ky0Y2dFSi9liHEwqk8wVuEnf/xDVhLmHOYGfZO15zTnmougahsZd+m4PfT1wxj7H\n", - "Ya4rVcFfs2bNyO999+6rxTOsmUtcGUTh4Xpq96sk9oe5isrZ4HMlY5m/u+1SA4/ri7L26LdpxwVy\n", - "PyW4j2c/+9mSOoUoqjdGf/gc4tl1jAvai3ZhjkAJxg6iTGvG1biz7cZFcZRu2LBhNgBzLgs9pK+6\n", - "6iqdddZZ2nvvvbVixQoddNBB8ww3SZIkSZLk54XeMVJ//dd/rY9//ONat26dLrvsMv3Gb/yGvvvd\n", - "787uQST9bFVLtoPz67/+67OLMbwlYm1YxRNZz+ciRaHknaAAoUzss88+I8dlh+9aWG3j5ZQqMPet\n", - "QB0pUVHGwWLViaId8Z7pv76KFO2JEuW1ZfrC+3q83ElR8jrHHbuF99b3uOOOFTz44IMldV4tv4PH\n", - "+RAXMYn9yFozBFEssBW+F6lcXuEcj58ximJCPSfusRTrxPmf+cxnjlzHgw8+WHUfEFVsJjYqqsQN\n", - "njXVmrXXijvpKH60KxmgKBKuWJVUVRQQni3eD76/a6T6O8x5PAP8Lci4s8L6Eu0e4bFe2Nkhhxwi\n", - "qRzXGe1hyTM6eiZzXMYH/cH1RG8jlkoNxIheuvEf/MEfaPfu3br//vv11Kc+Veeff3742aUqxSVJ\n", - "kiRJkgyllyLFKlySXvGKV+gFL3iBpJ8pPVStln5WawL1x/nXf/3XsBaFg5eAF9D63hkPHiWF6y95\n", - "ZxEoKF4FN8IVAPcayaxgVY7SEO0Z5+c74IADJE2ukjcxaIDXwHXg1ZGF2ZrF516itxfxKqgNZNCU\n", - "WLFihaTJZ85Mumq1M1ThOvzwwyV1tWCwZ7zJ1pg/vE9UA7cXp6REoZ702ROzb0wK58LG7rzzzqrv\n", - "8flDDz1UUjfHoLTceOONI8d3mIuISaFPGEOlNvB9F6O4T5Q03wXB+5r6QcRKcT9D9xqM8Ov8l3/5\n", - "F0ndfTOnoGRwvbVjrnYXgNp40qG7Ckwar0QfPWNdcSWr70Mf+tCg85fiUGln5iDmsqGxheNmxYoV\n", - "+sEPfjD77Ljpppv2+PleitTcifDKK6+czeg744wz9JnPfEY/+tGPtHv3bj366KM69thj+5wiSZIk\n", - "SZJkKsxNhDj11FP3+NmiInXWWWfp5ptv1ve//30tX75cF110kTZv3qz7779fy5Yt0/7776+//du/\n", - "lSStWrVKGzdu1KpVq7TXXnvpAx/4QPhq75d+6Zdm33eXvEj3PlBuTjzxREmdF8Zq2DMN+D8KD15F\n", - "Xy8LJaavouXeD23Ee/XW1Tn3RUYJq2jOE72vj7L7iNfA28WLBd6Ps7M5ihLKEV425yVOjv4mDoP/\n", - "e/97TBOfjzKO8Fo5P8dFGYm8JM7j56vNesQOUXT4Hl5z39i4qM5TVKuoNS7IM2D4ifrgcY3YA+3L\n", - "ebke4jCYePp6l5xnMeMhUNPuueceSZ2nXAtjDwXJY2wiRYm2IyaIz5XmJNRn5h7PNvS24/iMiQMP\n", - "PFCStG3btgWP7/WGOB99znlQ1ZmbGUO+KwW2jE2w+wJjx7PK+Bw/+6iSv8j4HIAqT39gB+PaXaJ1\n", - "L0bsg2cw/Tx0zgTmMmIfeVbVZnlClI0ZUVxIXXHFFfP+ds4554Sf37RpkzZt2tR0EUmSJEmSJI9H\n", - "lv10CpsbLVu2TDMzM4t92iRJkiRJkmZmZmbCtxRLs956kiRJkiTJ44Cp7bU3MzNTrDhdiv3gvTzv\n", - "Uz0TAdXrPe95j6T5NSqIreH9MTEevGeNamU4ZJS8/e1vlyTt3r1bUhdrQkwVGRS8fyWmacOGDZK6\n", - "OAvagzgK2oEYErbeecMb3jByn5OG87Ser/a99+rVqyV177Nf9apX7fF8vP9vfZ8dwXnIXCFepW82\n", - "YgT9yivw1vYs7feFXXmsIOf56le/KinOTCOwkn544IEHJHVxMWSYEb/iMYzUiDn33HNHzttKbUV6\n", - "rustb3mLPv/5z0uaX39p/fr1kqRLLrlEUjd2uLcXv/jFkqTnPve5kqSLLrpIUpdFRlwacXfnnXee\n", - "JOnd7363pHLdoBe96EWSpM2bNy94Txw3qo/kY48sQfq4dW/AaBcB5pq3vvWtI+dzPPap74sNnztv\n", - "vvlmSZ2Nk9iErRGDdtRRR0mSTjjhBEnSfffdJ6mr6YftECtD7Bg1AynZU7LNKIOUOFCyM4ktox0Y\n", - "m8SAnX322SPnYy6vrTdFf7NnYhSHyPXUPhvWrl0rqYu580ruzFVRBjm0PhuwM/rv9ttvl9Q9K4lV\n", - "pN98jvfzEcfLOODZHc2R2Af/J0YLu/Zahq973ev2eD+pSCVJkiRJkvRkaorUk570JK1bt05Sl0HC\n", - "qp5sMBQHvBTn+c9/vqRuFfrQQw9Jml+pPKqW6gpD30wB9w6oDstqF2/GvUb+jhfAapzPUQEapYxV\n", - "fK1SBieddNLIca6//vqR/z/5yU+W1GVfjTtsrrZdURHI7InA+2jNxKgF9QHGpURB5N1Rcy3aDQCl\n", - "CS82yvCK9seCb33rW3v8P+MRJQ7wDkv7tc2tJdcHvGC89pIiNTdTLaoEjsf7+te/fsHPMUcw16BE\n", - "UeMNhcj7pjbDEDXabQv1DzX2b/7mb6qOxw4SrbsyQKTy19Yoo49QQLgvv55STTCfO71GXVQb7/77\n", - "7x/56XC+oVl/KBd+HOwB+2COcAUnmqtrlSjal7m/lBFbmrt524KKS1Yn/fRP//RPkjT7bEb5Q8X2\n", - "ulS+9yR2wBwe1fDD/hhPrhwxF9KePEOiuYDzoViiGNJPPk5ZW3A8rhMlFNW9pMRBKlJJkiRJkiQ9\n", - "mZoi9dhjj82uch1f1UbgBfB+s+SJ98W90hKugPHe1b0FVuVf/OIXR/7Oe3VW+6yOUapqd7vnOCh9\n", - "3AegUK1cuVJS5wW2Kl7jpnT+2usj7iRSrlDi3GvCK6H9vVq019qJwCvCm/L4AweljesmfgewK5Sp\n", - "SJEq1cEqKXmoEpE6gT3zs3Y/NsZz1H8ouXiVnN/vh/5AxWlRZSLF6tprrx25RiiN+Vr1lni03/qt\n", - "35IkPec5z5H0szp9Uqe81I5tlArGcKuaTowU30cZqL0f5i7Giu+htmrVKknd2KpVhuhr9mvk99b2\n", - "GRdRvSXmVh/TtQqGxxlG98Xei8RGlSgppDwDsBfGIrFS7FLC2NuyZYuk+UoUChlzAPCMQvEq7QuK\n", - "uu12x9sRlCNilnwvSPBnv1fEd7Zu3brg37nO0lztpCKVJEmSJEnSk6kpUnsCD7cUGwG8R43Ay8Sj\n", - "b40Bwiv17DO8Eo99wltDueB+5pac3xMcl+vEG/FMAmDV7e/P8ez5iZLBcU4//fSR77liUFvhe7Gp\n", - "9fpKykvkbdZWrEcZiRSZaOf1CGL8omrBHK903FJ/EXsXZTti36gJfp/E9VCdmHiiqCI7lJREYqJo\n", - "f7xKvFC+z3VEXuUQomtEnSxVhI7GInz5y1+W1ClSKEFf+cpXFvy8V90HPOYo/rMEbT0UFBCP+eG6\n", - "S3O4z2lk6aG21u7HGhFlJ5ZAHY76sbRfJMzdl3ah75cUtn/8x3+UNF/5AR9zJWWSdmBMc36UWlTw\n", - "kupO7JiPB66DOYrriTKNmas8tox+53tcd6S48WzleIxXroefvvtEKds1Gn9OKlJJkiRJkiQ9maoi\n", - "xWrPV7VR7QiH1atnIviqdVwxP77a9321gNU+ylStkgCszrkvvE/uz6nd28zfI6MkQOQtOKX6Xlw3\n", - "/VsbQ9NKX28Tov4j/qT0npx+5vO1XmoE7T/UXktZmHh5tXj/EUfg7dday8hhHsCbJFYsysxaiJJK\n", - "2JdSPBptWjsWiQ8lZsWz+SBSwKhVN5TWWBAHZctjyWrjVX1Ooz2j/mOvQM67ffv2BT+H0kUs0q5d\n", - "uyTNHwsoT67A8Dvtz3FaFbKofVv3o4zGVuuYo13IiuO+aO/atw8ojZ7ZC7VZieBvGTi+P2Oi+8WO\n", - "mDvJHOYZwVzCWxfuN7JT5qBor2AnFakkSZIkSZKeTE2RevrTnz7rOVOVFsWH1WXJq+TzrDbJGGmt\n", - "HRIpYyWiit0oYlwHcRC1NVrw9PFaWIVHGQhObdVcPH2ypfAuSl5XpEQBXs2klCjoq0SVoI4Z3g1e\n", - "jSsw/F5SkIhNw8uN+gWlrzY7NMIzc4Yez6F6dMkOIqJqyYwTvPioHpVnis0df9hcdI5SDFMrQ1XX\n", - "HTt2SOqqwKOcPPzww3v8XhRHV4ur+RFRe6GgRXGbsN9++0nq1Fr6CmXA40aJD3WFBBvmd+YsFKVb\n", - "b71VUjeH83+eCVFdp1K/cZ2MYcZ8reISxSxNSjktQUwVzyhUa8YLSoyr2q7YMfapP+W0Vm53uB7i\n", - "OWmvqC6Vx+LR7jzTfE0RHQew+9o5LhWpJEmSJEmSnkxNkVq5cuWsZ8mqE8WGmBNWz3ioeBWsgnnP\n", - "iyKFB9taU8W9GBQgr0/jWWxcn2fA4PVwHFbTrkjhzVIrg/e1ZJsRB8H9R5kbnhGBV1Ebp4C32Ro7\n", - "s1ToqyhGYI+0X9TuUIorwPuj/yM1pOTd14L3jjfmXmEplgtvkIwjVyjx0qh6jJJUW18ryrpknBC3\n", - "QVySx0Vg53uy1+gc41KioDaGIoK+QInh3kuKFIpBX7CRKDYLovaiD0pjg7maOY25meN6VhTtgM3y\n", - "eb7vGZ1uM1wPtfE4flTLr6TW+l5sfVVYZ7GUKH82+BzEGCMemfZmj8JSRry/JUH54RnO8VrnZsYv\n", - "/U7/RlmQUdwucweKFf1dejvEnJ0xUkmSJEmSJBNmaorUj3/843negmcD8X6amA+UH37n+6y6WX1G\n", - "q30+558Hqqyy6vX3vO7NRBWgid3BC2B17llZrNLJnnPvj9U8q+LofTPtxyq+lO3oRDvOP14ghon2\n", - "HBo7hZdFu9YqdVHdrdpsPpQwvO2+lfrpR8aPqzMlb4zP057sxE6dK0AJjvZDawWvkbgWlNUoZm9o\n", - "luA4qI1bjGBOYP/DWlVv6FjF4x4aa8Uc6RnJ2IbH5EA0l7FbBT8jW0Wt51lAP3jMFXMqY7A1Ixa1\n", - "le8tdmX1WnhmebuiKPkzEeXI6yuh/DCnluYgf/uDPfF92p9neqToRbuHeLwwMXEO9ubH970xSwqq\n", - "nzfKlHdSkUqSJEmSJOnJVOtIsVpmFcv7bjxivB1Wm8QK4XXgtfgeclHMCt5EyatorUjtsPpntY+i\n", - "wX3UZo6wCvcqtI57xa2eOt4wsVpLtaJ5BNc5riw++h+vhP7DXvnd+63UXth5FMOHPRMrVVvPysEr\n", - "o/J4iSgzC3UEu3W4j9pK8yU4Hu3MOEFZw1utUQVQtThmVAeqFvrOFZKhsS6okPRxbSyJZ81FNhX1\n", - "LZ45ygFzRmmvNvA+Z67m+omxKdmGKyiMLX9bwee4D85Dv6AcuDrPWBiq4PXNPhsXpWzT6JlFv9Cu\n", - "zFEcjzmHzzHn1MYSusLDs5k5Azv1Z7bPad4/fJ+xXpoDOT73xX36XNH6bKzdjSQVqSRJkiRJkp5M\n", - "TZH6z//8z9lVMu9h3bvD22JViYfsXgveCTFO0wYvyOtZsT+R72kX7UOEd0iGzgEHHCBpfkzKuN7b\n", - "U1ujpKyQWRNVBh8K7VNL7Z6MtZBp5LVeStlmJXWCz0X7N3ksFbFS/ERlIVZpXDFCUWYKdhcpW9gt\n", - "2bMej9AXVBrsGoUKb9bH1Vx74V6o+4NSg8fed6xwDR6Dwd/79gXxZygrtTFS2BJzCm3jilakLNBm\n", - "fJ8x755/SZ1GocNzp31Rh6Mxw+e9MjbKCPdDe3u/oYQQM4Mtcv30OzbMecY9VywWfbNNPd4Re/Ws\n", - "TeyPtxNRxXLALvwZ4BnmHJe3RiiH9H9U85HrYs5jDiplrjO3+tqgNtuS73mMX4lUpJIkSZIkSXoy\n", - "NUXqe9/73mw2TuTJ4z34apxVL6tHlJ1Jx/SQRVSKt8A7RblhtcxqnNU58Qncv2cosIrm83hXXktj\n", - "XPWTaiuv42WMS5HivTze0urVq8dy3L71pfDWvU5YFCdBf+DNReBl1+Kf5/e+sVPgCmikpkTVf6n8\n", - "/uxnP1tSeS+81pg72p/+Q92I5om5f+cceOLY1KpVqyR1Ga2lmBe+h+cc1dOp9VgjDj30UEldX1I3\n", - "pwTXxZhttXHOgy1ESk2pz2hnFCDmLI9lcrhuV+Doe+bGSLFg7sFGaQ+v/TdtqOzeF+9nh7mYdnZ7\n", - "ZAxh78xljHnsGmWSz9XWzvN4X47rdcCwC64Hu/HYQ46LXfDMLNU984r4DjUmmYuIpXL75HfsLnp7\n", - "4KQilSRJkiRJ0pOpKVI1nleUQcJqtqQAAIrB0Gy8WgXG92NiVY3XSewXq/ko24y/33bbbZI6z79v\n", - "BonH6LB653paj0ssC8djFd+axUV7uUIHKHGukODtodT49Ze8dGKh3Pu68847R46HF+fXF+3fNWn6\n", - "KlFAu7XWG4PnPe95kjqvrjQuWpXiq6++WlLX7qVszLn9fOKJJ0rqKmDjIaOQ1No4fVuy5b6Zoqiu\n", - "qPI333xz0/exWRQLzyz1uDLuG5un71AEmGujvdMifB6nz5hrqJEX4e3Lvqu1CtvQuLw1a9ZI6uon\n", - "3X333ZLKsWrE7hx44IGSpNtvv13S/D3ehsYxlt4SMLaw7+jtDfbCdaHw8HevfVh6VnoWIHC/2BVK\n", - "J/bne/oRX8l9EgvFnI99RHXCgDhrV1Zd3eZ+eeZxH1E719phKlJJkiRJkiQ9mWodKeoWsTpmleir\n", - "RVbHrEZRmHgvyqoVRcRjmFiF854WhYjVdK1S5UoJGSPuvXA8VueuWPh1eBZfxNBaJly/30drfEUU\n", - "twC8h8ar8Oq59COKor9vv+OOOyRJp512mqSuJg3eHnYDvP+uhYwu4gLcXjz709sdb4t+8/4fdx0u\n", - "z3Aa6oXTnrWKFOoCXuEnP/lJSeOrhM84JyuVdvW6Urt27ZK051pHqJaMwXHtrUfbt8a5RTz44IMj\n", - "P1t573vf2+t7pbHrlaxpe1eOIhtnrJBZ3DoG6Ft+YnMoXSgY9G8pC8/jCT3m5UUvepEk6corr5QU\n", - "K1HM1VwXShbt5XW8sJNS5fuoPhTKKkoRionHgEX7uAL3y+e4Tq6vbx00lCu3C44fzS3+Nil6qxTN\n", - "6aV4aodnCkoU7UB/8pNx0VdBTEUqSZIkSZKkJ8t+OoXy1cuWLdPMzMxinzZJkiRJkqSZmZmZUGFN\n", - "RSpJkiRJkqQnU4uRmpmZmY074D1x9H6azxETRWwG7zeJOeL7rBpRvRZL/Vqq5zv22GMldRkpDllc\n", - "0ftq2v2Nb3yjJOld73qXJOmUU06R1L1Xvv7660e+d9JJJ0nqKnYTv0JMzBFHHCGpe+/ttWVe+9rX\n", - "Supipq677rqR41Nfixgij3Wj3hHHLcXC0Y5/9md/JinevwxoF2itq8X5Lr30UknSCSecIEl69NFH\n", - "JXWxUGR4ERtGOxBvQEwRMWnEP3jcQGQvZCMSh1KKo6mF83zoQx+S1MWmEfdBho7HPfA54hpoB66P\n", - "/ia2jxpR69ev16c//WlJXdt4rEYU8wNeeyyKBfK29M9x7dSJimKhiLXB1hiDvl/nUp1b+uKZ1Jzn\n", - "8ssvlzQ/RoZ+Ye656aabJElXXXXVyOdOPfVUSdK2bdskxVmVnO+yyy6TNL54vwhvzyOPPFJSZxdR\n", - "hurZZ589cn1kFDNmmYOIWcLeX/3qV4+cL6J2V4YSfn9k5RFPSnYnMUvMzYwX7J52OOaYY0b+jp0w\n", - "B27cuFGS9P73v19SN9exJqAyefRMw/74Hu3H3OIV/1/xilfs8f5TkUqSJEmSJOnJ1BSpfffdd3b1\n", - "GGWjsTrFW/MaFawW+Rx1jbZv377g8fB0UTwWu/7PtPjt3/5tSZ0CgHKCJ0/tmGj17ll9KDzXXHON\n", - "pPmV1gHv8Gtf+5qk+Rkn1F6hhovv+A2RV4mXFnmTpRo2ESUlCsZV2R2FDiXIs/LwWqP9y7BjfkZV\n", - "uCM4bt+aSCU8OxJlMspowjv2/uUn+9Nxn3PrgFGXKdpbq1QXym29NoSUz6EU4NmWlA76HNV9w4YN\n", - "kjr1uFRvb9zZhM64M1Ahuq8oW4t+ufjiixf8PsoeSgdzHd/zveYgshNs058xtEfts4MMdIfr970J\n", - "HZ6N/B/7Rkli7sau95TRuhCuRKGg8nfsk/uuzfCmXbke/140N9PutC/f53i+z+whhxwiqVOWPOsz\n", - "wvfxBZ5t2GEp6xJSkUqSJEmSJOnJ1BSp//iP/5hVpKjHBKx+USioBYLnyarU9+fBG4zwGimO1wqZ\n", - "FO4VtVYCb2XHjh2S5isoKB++ynei2hpU9UUJxEtC2br22mslxbFZgEIR7c918MEHS+riA8YF1Ynd\n", - "C8bO+tYUwUvE26ndmxG7i/bSq63kP9SesE/iEfDuIYqriGriAPeJShONV7zuCLxz+m1ubSDvs9Je\n", - "ZUNBTQTUcvocheRtb3ubpG4s3nPPPZK6+EFUcvrcd7MH3xuNPkLtjfZHjGyK+DpUPuIRgbGASosn\n", - "z+/0OfWdSjaK7fDT56RSzE6kZBEvST9HtdZoB2DO98rgvusDtdeYi6jAXnqmuH2AX180dogFcztg\n", - "jPPs5DqGVlJH4aSd+84lxN3yfRRTnuleqw9QorBj7o9+9bdXfd8q1dbiYzyXSEUqSZIkSZKkJ1NT\n", - "pH784x/P2/cG8G6odOwZNNE+P0NjPCatRAHex6S8ZOC9fhR3UHu/tLuDt0GGBu+x8UrJPiuBd0u/\n", - "4iVDVCW3pICUiJSPoV4dGTklpQ+4f89Omxb0a9Q+eJXu1UX9gHePnQD2z7il/z1uweE8eOnME3Ov\n", - "3c8BqGAcY+iYJ1OS47rHzDWihJx//vmSpC1btkiSLrjggpHPk51EzI+PBd/FgTFXiteL4ua4f/bx\n", - "dDxe0H9HfSW2hjk5mnNcyXKIt6xVX2l3xporahA9axhrUaVvrpe4W9q9NnbG9/EE+pc9Ibkuj3Uj\n", - "9gelDphjUJC4jyjmC2UWu+e+/BnKXDs0cxdFCXvF/lEAUVL5nI9T/l7aB5b28bnD3yrUzi3+9it6\n", - "9jmpSCVJkiRJkvRkaorU3nvvPbs69VUfMRSslonFoTbIFIqxjxXiG1r3iGuF97usrn1VTvyGZ9M5\n", - "0Xt+rh+v2RUo4jHw2qP4Dbw7aqK4IhTFWOFl91X2JmVHmzdvllTvtTq1eyqWaiINJfJuW/f6Q3HC\n", - "22Z8u7rBuPBYO4d4Irzwln5E8aBmF7aPLbeOSWyaa3JVjviyN7/5zSN/R0mIiDKPndr6R3jaPgYZ\n", - "a31VWGJpsBXUSn73mKaSEhjNERG1byG4P1dZ+X6pjhLtx7OKGDiyxqKYH79P5rjDDjtMUhfjgy1z\n", - "nX5ffn3YPGOF64uy6lDumIv5SaweiiYxe7VEzwavCel78DE38gxCmQPur9QvKL4obrQ37cizj7mF\n", - "6+K6fQ7imcUzLWOkkiRJkiRJJszUFKkf/vCHYewLq3Tq5+BFsurGa/QMknHDKpbztK7WIyatRAHv\n", - "j70mBooU3mwps8m9AvrDvQ6vCg1RLRXAS8Wr43ogUnbwxrifUo0TzwjC60AZHRccn9gd97ZK1No1\n", - "SpT361Cljf4lDoN2ol+Ip6EWjKsi3l8oUSXVg+OXYsS4P9qnpZ4Xah+2yzn72gA2TxvhEZeUolLd\n", - "JzzhSBWEKC6Navi0ZSk2pC9cH2MXxSY6H9l1UfswhmtjWhzmbK/qH1EbX4nSxhzCfdbG0ABzA3My\n", - "z0DsqPZZRkwYtQBRnKLdG1D6+EmmtY+d1rmj9Hn6A3tGEfR2j7JKfXy6woe9RAqnnx8lONpFBbC7\n", - "2rcdqUglSZIkSZL0ZGqKVA14FV/96lcldav2Se+L5Odv9TomXW24FlbVJUUEBaK2EjjZV3g/eAvU\n", - "WNm6devI56PsL/rTfzp4g+514A1FSphfL9dJXAzqhNcxGwreIbF9tGut98v3S1WtITpuraoBqACM\n", - "L+wf79UzbrwCeXQ9taoCXmIpRozxWBtLNhdiW7DRWuUiwvc8K3m6tWDzJTU3AptmLirVO4ooKUiu\n", - "GHD/kULA50pzeF8FjbkgqhHn1MYXModx/dh+yX48247vuRJUWzEcUK7IrsNeaueMoW9XUJ397QFw\n", - "37SPZ+Lv3r1bUnf9kZ1jTyhWbldRjT4UYsYlymxt+6Ce1yqEqUglSZIkSZL0ZEkrUjCpPcBqYXVd\n", - "+74UbwrPmdXwYilptXA/rXWLaA+vcUNNmVrI2KAGDV6ZK1h4Fb5DOBkZpcwO9vLjulGkokrqQ8Fe\n", - "8WZKiqbHRNV6TRHEBWCHtUqYxwUQC0X7kqFEe7m3XTpuCZSzUn94rFWf+WGoEgVelZ824RpL9xLF\n", - "w3FPfetcEWfK9aBMRZXDowzQ0tjC1rw6f8S4Mkyj+0Bpqd1vstY26SfmHGy1FCMUtd+4MoZ37dol\n", - "qcsC7FtTrxXOU9ovE3j20Y5RJXmHz2O/Xt8q2gvS40Vpp9rx1JoJnopUkiRJkiRJTx4XilTfDI6h\n", - "4NXgiUfVfx28M1bDrUoUcReTVuJqs90cvF28Ue6TmKlSzBJQYwcvgfft7k2idPFenTgFrp/zRTEz\n", - "/J/aKe7FTKoOE3EL9GcUM+dqBPfPdfJ7rR2NS20BYq3od7xElMJxU/Kq3ft0ZVTqPGU8WWwDT5N7\n", - "8v06HWwHJSLyaMk2QimhbbwuEn/HJqJaWVxPlOlYGmOMFeIffY87VwAYGx5T5Koqtsh5ab9aD35c\n", - "caORgsGcUFLSoFYZIsbH270lY1Tq7Ii4Q+wSFbpVgaR/sZNxj/0StQoY/cG4jJQkB+Uv2iWDtYFf\n", - "B8flPJPetSQVqSRJkiRJkp48LhQpFInSrvDjhmyvaJf6iL4VrWGxYsLI7GnNNMJ7YrWPl4WiRIZF\n", - "lFHhUCn7oIMOkjS/Wq5ndOD9433STx5bRD/gNdKPKFruDY4LFBKvyF/rh9MsYQAAIABJREFUjaOQ\n", - "oR541uJQZZYYs9qsN66H/tx///3Hch3jYiE1BLUUBSWqeVaKk+Ne8agjz5bj0CbYqO/ZRRZcaS+5\n", - "aA5gbJWuG/WQz6PMcV133nnnyOex2agOEdft50MB4f8/r2BHzHF9VWzmIOyEuY45jDFZW+H9d3/3\n", - "dyV1Y/pLX/pS0/VglytXrpTUzTkPPPBA1fdLFfqB8cYc4koUyprbX6nyfqSIMSfQzq0ZzLDffvtV\n", - "fS4VqSRJkiRJkp48LhQpvKvFAgWM1XlrZepJVVrvC14PXiPtibcdVZjHWyF+AvBeOR7eAsfj91pF\n", - "Csi4IR4BPD7FlZDIO8RbefjhhyVJDz300IKf67vPWAQKEt5739pCqCD0DzVYUNj6xpu03q/Hph19\n", - "9NGS4vZ08ObxxqM4DuyU+BEydEpxFFyf1KmXnNP3BfRYIa+k7KBs8TkyTSOwRWwP24WhuxrQFigX\n", - "ePrcD2ObMUINM2zSs56AXSQiUHejvlgqGckoCCXFrxX6FbtqVTYA5Yeaex5nyHFvueUWSXHsGWq3\n", - "Z022vg1BCUJZqo2xoh1qFRvGAXaI3XK9tXNkKVOYOQTlkPasVaQ4Pt9nzi2RilSSJEmSJElPHheK\n", - "1GJ7O5HXVktfb6WWqAI4q368crwZlKM1a9ZIkm677TZJZS8A79MVIOowOSWvtgSKE9l84O+7nVI8\n", - "Ad5Ta22QvqBgfuELX5A0P66mbwwdx412XK8lymjy2CkUKJQkvEn6odbrP/bYYyV13m7k9XJc3xk+\n", - "UkxhbvviUTIGOSaeN8pCyWY4DrFKxGculCE4F4/ZQClAQYjGDmCrfM9tPqqIHcVKcRyUqb5KTUm5\n", - "q4U5ivbtU51+T8dt3YWidDzaD9VzaJ0m7pcxiArPM6e2f/gccwz2jPp+4oknLvg9ng2MZfCYuRKM\n", - "o2gsu71jPzxTmFtQfqLYPMfnrtNPP11S98xAkWVOiOKqUb29wjtzIG+VNm/eLEk65ZRT9nhdqUgl\n", - "SZIkSZL05HGhSPnO2HgLk6r/My5YdXtdoNbYFlbPrLIjrzjKcCBzh9ivI444QlJ9LFerIsj1+b5a\n", - "XBdeCP2IVxMpTtu3b286vzNUiSKOAYWE4+FF4iVxf9GekNz30L39hmbLoWjxE7vkd/qNivOoB16b\n", - "ifbAG46ULhTQWvC2a/eZm6tqoMxwre75YnN4nr73GX2I8uDZS33jNUtKFIxrTuP+du7cKal/xjN9\n", - "7bEmXn+LuYXr94xZstLoB2y4tQ5ThCtvtWDjKDl+PHDFL6pIXwI7YEzxVoB2JT7U3xbwVoEMY+JR\n", - "mWtQjaMsOt8zsTV+NSJSiyN7p7+jfm9tV+agW2+9VVJ5rj/++OMldXaI/fozulUpTUUqSZIkSZKk\n", - "J8t+Oq5Nf1pOumyZZmZmFvu0SZIkSZIkzczMzIRZq6lIJUmSJEmS9GRqMVJ7UqR4T+w1YCJ4L+yx\n", - "R5zDz8V71db36RG8777gggskSZ/4xCck1cdFlOB9LrFSvL8/55xzJEnvfe97JdXHG6xfv16SdO+9\n", - "90qa/16ZulG8pyeegXYke4z4C+IiduzYIUl6+ctfLknasGGDJOmVr3zlyHXTv2RzsY8Sx+V8tKf3\n", - "HxXQiX/xGKojjzxSUvfee+vWrQu2AzVCeC9/1llnSZI++MEPSipndvF57pusRWLEjjnmGEldLBXx\n", - "NcQnRPY5KTjPxRdfLKmLAyK+Ajsr3bfvfbnvvvtK6uJiuM83vvGNkqS/+Iu/GPk87U1G3IoVKyR1\n", - "49erepMBFFV95rxvf/vbZ8/lmZJ9Y1oivO+8fhXnX7dunaQuFosxg2fLmCamiTbiJ8f7vd/7vZHv\n", - "g9fVwaaZ26iq7/s+EvdH7BJtfu6550rqKmRP2jaZC8477zxJ0t///d9Lmh+Xh216Zim2QPYVsVrM\n", - "EdwXY5B4zAsvvFDS5O+P633zm98sSXr/+98vqbNDj7kjs5pn2k033TTyf9oliodlTnzLW94iafj9\n", - "lfbEw35f9apXSZI+/elPS+rmYOyM2ET2qyVW65nPfKakLkaMmCvGE3MUP8nOO/PMMyUt/twZkYpU\n", - "kiRJkiRJT5Zk1h41JaKdyt0rac2Cw4MelyLldX3GlYkCKEYoNu6Ftp7v9ttv3+P/adcoO+yGG26Q\n", - "FNfb+shHPiKpqx3iXhNK41133SWp83pWrVolaX4dqQiUDBQezx6L6nlxPqoLu0pRW2X3iiuukNQp\n", - "T4CXyXH4HW9x2vuSeS0c7LdUK+hFL3qRJOnzn//8yN89I8yzSr2+mdeewb7JZnRF6oQTTpDU2Y0r\n", - "UnPvxxUhmPRuAxzfz0Nfu9IEXqvtG9/4xsj/vS0/97nPjemKFwYlpDZjcii+zyW2RDYaY5yK8P55\n", - "rxzPnMQYJ2PZP1cLCl7f/U85P5QqhzNXoKg5hx9+uKROaXSivSD7Ugqh9jkDZYln7CGHHDJynC1b\n", - "tkjqxjLPBuZs+pm3RvQ//bdY+9C2kopUkiRJkiRJT5akIoVXt3z5cknz97rDS+tbFRcFh/fzvF9H\n", - "EUHxotprKWbLlY+hladLRPV6hkJ7E5cQeTf8H28rUjKuueaaPZ4P7xHvl34peVX0A9fr5y8pWnhH\n", - "eDeuErTWaYqUzaGV3h28MxQYvDfiR/AG3Wt3sE/26SKuBm/ZVRGI6l/htaOUuuLFdbEvl3vlqEhR\n", - "xX7iKaL74vtLkdIuCdiuV1iGoZW0W0ERwTYmTTSXcX7uP+p7YnA4Ds8E5iZ+xzZRhWvpq2RBa10w\n", - "j51CNSfmiHpWkSLVSikGCmUMO6UfmLNRniCqmYjyxHhgrv/iF78oqZvzfU6m35hDat++eGX6SZOK\n", - "VJIkSZIkSU+WpCKF58tqnPfmrO7xwPvCqphMFrwflK6jjjpK0vzMGVek+L57S+N+T71YoBjs2rVr\n", - "j5/zHew9iwui/b8cvMRab4Pj4r31rQaNt+ReVSv0P9mOpay3vhArxL5x2DFZg7V7RNJPxCLiBa5e\n", - "vXqP3yOb0WF8MC5doeM8/N/thSrNkcJMXEW0R+Hc/p/U2ItsnDmKDF1XkLgn5hZUN2wYjx8V1W3Z\n", - "26SkIAylFBvle9mhFHAfZF3VVoCPzsdcUMrcxnaZC3yvRdqPOb51lwZXu7FBlLC1a9dKkq677roF\n", - "v986F3C/ft9cP2N9XDAmo3hSzxIE2tvVa+yXuEfan3b09oyUWI5PnCnZmKW3MVF2bt9xU6vMpiKV\n", - "JEmSJEnSkyWpSHl209FHHy0priNTAq/Jd4RndYrHzE9isvAi8T6caBWPh+7/d290qVHK5ougPT2b\n", - "sgTKCl4l/YSXH9Ea5xBB/48ri27S/Yoyw16JJ598sqRuh/IooyWKPQIU4L7ebmkneFQaj3UEvO+o\n", - "HxiXNbGHk9p/M4qbw1P2DE0+z72hhLiN8Pfa62ZumZSt+X0yRomDQ8Xlc/yfmCRsk7cIKBbRXn+u\n", - "cKGKo5Qwl9BObuN8jvYjnhWbx2aiObyEKxges7VYMWx33HGHpK59apW1khLjzyjqimHHtGutwohy\n", - "hX2gIPH92pgl+h1lsqSc0d98DkUKhbpWiSIOFXuv7d9UpJIkSZIkSXqyJBUp3q96VhEVqh966KGm\n", - "4xHLxGqWVXr0vpX3tl4t12HV6ztuR94l79epreFeF9eHt8OqngyE0s7WJVCMvHZHK67w0Z68n+b/\n", - "/J0YGOJIuA8+h+IAVDp3aGd+oqRQ+bq1krxXox4K3hNeMFV/8YZKyk0J4k/4ef3110sq96N7gR5H\n", - "gF1GKgftjb16/Ebf2i7YB971ypUrJUnPfe5zJUm33XbbyHWiKvjO9eNSKPtw3333SSp77FEb0fao\n", - "36XjMBdMSpHy43LdPkYBmyfGy2PJ8OwjfK5E4aKvXZGgvXwu5boZa9gIn+ub4V1i9+7dEzluBNl7\n", - "jJlS7bfWmCD6GeWrtqYf+Nskxi5zVG023de//nVJ3RzBXB/N1awVGD+MJ66nlP3px0GZ83jgiFSk\n", - "kiRJkiRJerIkFSlioKIsoVY8toJVbm2WGMqJg1LlilT0Hpe/o0ig1OCFEX+Ad8X73aFKFJCdhjcQ\n", - "1Qsq4YoUXg/ekcdKsar3+4i8dPdW6C8UHhQVvF28FbwpzlvyxiLvpnWvR8fjY3jvTrv1VaScWkXR\n", - "FRuuA+8NhSuC9i55cxFRdqsrlw888ICkbjzRP3iTxEH43ppzM3TcNlvj9lqhDfG0sbna2Ao+h7Jy\n", - "99137/HzQ7MSo31JwesmtarWHmPVqlYy9zM3o7x4Zij9GlUO5zh8btyxTNhZa825oaDUkSFcUqRa\n", - "wT5qd3dwaGfGH3M5yiD9WBsrRTujFHmWn8fmYTfYMc9+v55I+eW+aefaCgGpSCVJkiRJkvRkSSpS\n", - "48azlvBgWR2jQOC1ej2eqLotnnRU3yYCz5zz47GzWvYdr8fFww8/XPW5UqYHXl6krLj3H63+vY4T\n", - "mT2eyYPyhPeBl8z18T7cszFLRLFs467Rw3mIO3CvKqpRNC48G66U/eb9j6rQN6YuGj8czyvbR/Ww\n", - "aEeUSa+aLM3P7mFsttaRqe2TqG5NLai0tZmjQ+tIlfYlHfeehMxxtVmJKCz0I797f2BTPlcyJ2ET\n", - "3M+4d5vg+JOq5+Vg88R+jXs/VyjtalGCZy1KEs8C+qF1jmN8oar7WwTshJ+ercn4Yg7DTtjFBHvh\n", - "bQYKKCp9bfxsKlJJkiRJkiQ9+YVQpDzGiVUySgerZN7DsjrF68D7cW+QCs59Y5h4j8/xeC9bm8Ez\n", - "KchYiKrOlrzaVrzGjHsBtAdeO14q3gexaq1eFMoa8Qbgx8F+6OdWLxSFxeMEAG8qun7+X7Izjzni\n", - "eO6Nt2b61No348njYlASvf4b3mHtPlrEb+CdYhd46wtdO0oI56i1kcMOO0xSd+++uwJgQ31jVbie\n", - "2rpAVJoeV9xkdPy+oCBgs4zZKN4wqnGGDUexNCiOtB+24/F+/N9V7qFgB7TXUGWyBPfB/Xnm6rho\n", - "jWnztzE8K2kX3zuvtR84Dm9tPB7ZM8U5j8ej0l+M10hx9v6rzY5NRSpJkiRJkqQnvxCKVBTLw2qZ\n", - "VTWeLjE7HvkfKRFRjZUSrKZZ9brXO+54jhJ4C09/+tMldYqB31/fukG1NUSi6sV4J8S0kemEd95a\n", - "OZ79wbydXQlE+eD6+95/VJOk1B7YZaRCcH1RNmqpls+4oF08SzCKkQIyZdw+sGu8SLJbqd1DP81V\n", - "UbwCNzbRqhQwJzBGoxifobvL02e1c0hrPCbUqpqepVQ7ZoGxVBsb5bZCf0WZz8Cc7m8F/DonnbVJ\n", - "7bN169ZJkj71qU9N5Dy06/LlyyXVZ1zzdqFWwXL7oEYfP7dt2yapi/M9/PDDRz7PmKVfGbNcP+p/\n", - "KVPYr59nsu+O4BXQ6X/f84+5gvGM/fjawOuO1T5TU5FKkiRJkiTpyeNSkTrqqKMkSffff3/V56N9\n", - "noD4BpQYvBjqE9Vmu7XCqtm9sFZliRiUvnV+gFU/q/G+SltEX+/dlSC8Cq6T47oaUcp6vOeeeyR1\n", - "971hwwZJ871YzltbU6QV+g9lhZ/EzGEP7j1xPdQj27Vr14LHZyeAF7/4xb2urzZTjOuhMjl4TRpX\n", - "DlEYuY+bbrpJ0ny75u/OXIWQGAo83r7ZTdS0Qu2LVF+PbapVRTkemYu1Hnpr5iR9VxtT5Spfa0wL\n", - "7c9YLNVic4WtdQ5jTNDuKBjMGaW5fyicJxp7fTn00ENHjs8c1xrDFil7pTFNe7Lv6W/+5m9K6pQw\n", - "+snnJGKZiI2jf7GrVnUc+0EJQ5HiWc14oBI6c7/HrtXWBOw7X6QilSRJkiRJ0pPHpSLVN0alBMoU\n", - "73HZuy3KXosg9qb0HhtvIFKi8EZ4/w6e9TVUifLrefDBB/f4OVb7fesKwXHHHSepa99vfetbC34O\n", - "ZYn3/HjX7o3ipaBwlBRL4ivw9lCk3AsnY2ZoVWniBqJMERRAlCiy/aLzomh6Rfy+0G5+PdhFKd6E\n", - "fkFdWb16taQuWy+KmyHWDS+Wdqq167kxWD430JZ4wrRppI7iQaNsoIqhtJTmnqgP2CON495yyy2S\n", - "uuyi2kzYVoWoNcOUzGWgPUoxZvTd+vXrR77HTxQDp28FbfCxiSrqmbiT4otf/OJEjstYxJ7Yd7L1\n", - "7YjbK3bMGI5i2Dgv/UbFfR+TXvONvfmYCzgP32u9fu4bhZj7OfXUUyV1/d53l44I7Kh2H89UpJIk\n", - "SZIkSXqypBUp6sOcfPLJkqTPfvazkuZH7o8LVs14uJFCUoKqqXgVeAEcFwWG9/f8ndU7Sg/KFpkR\n", - "KBmtFc/xCv17/B1vvVbRGHfFdfeKvLZM5MUMtQPaGeURamv6tBIpS+7leTVnlBze9/N33udjNyhG\n", - "KJz0q2fNRZk8URwBSh9qyNq1ayVJN99888jniCciJuv5z3/+yP8j7/faa6+V1HmBrTGCc/vLY2SI\n", - "u8KmyCKKYjsYc7Qtig5jo28MBSovChSKWKvCdPHFF0vqxgQ2Rd8TW8PeY9gW58eWUA64P+aCk046\n", - "SZK0ZcsWSbHq7JnO1HLj78SXYjvEyLjNecwPn+e6sGHUUfoNpRHlg3al/wDbwB68ltlS5cYbbxzL\n", - "cXj20J4oi9FY9N0jsJdadRjliJ/joqQEc53YE3aDvdS+PWH80G61tRxTkUqSJEmSJOnJsp8u1mZB\n", - "c0+6bJlmZmYW+7RJkiRJkiTNzMzMhDGHqUglSZIkSZL0ZGoxUu94xzuKVW9bq+o6qF4l9YvYjuc9\n", - "73mSuowajxkhZivK4iudr7XytuPViWvvb1ws1fO17jA/9HxDoR//+I//WJL0hS98QVIX70LlbuJe\n", - "iBEkZo9YKe4buyJeZefOnZK6WCniRN7ylrdIWvz++8QnPjHyd+IVaAcy1qLMtShLlFgx4p5e/epX\n", - "z7u3UkVvYnmi7DGOTVsSjxbZCjXu6BuynYDsNmK3uGfiJYnx4id/f93rXjdyvhUrVkiaX3/K4yGx\n", - "FeLaiJEh9gNb4/PY3Jvf/GZJ0rve9S5JXewM18txyY4rZefRHszptCexTm984xslSdddd52kLgaM\n", - "85EBSmVv5mCytegXsrmY04nj87jDCy+8UNLSm8seb+cjJu0lL3lJ0/mwm74xa9Nqz4hUpJIkSZIk\n", - "SXoyNUXqaU97WrGaL95iqY7TUOUK7wxvCu/LFSnP9MFbpTJ2Ca7TFSkyXvCePYsMhtYJ4r7w1mqr\n", - "KY975/RxM1SJikCBRPEhY8szt/CC+dxXv/rVkf979Wa8eaBfvd/JVPna174mqVzHqnVfrVpOOeUU\n", - "SdLmzZsX/D8Zb3j7Pk6IK+Dv3Beqypo1ayTFlcujjBuvXjwXlB/GVt86Rqh5kaLFmCZLiIxDr6iN\n", - "5/6KV7xCUmcTH/3oR0c+71l9USXraOx6Ri0K1J133rng5x2vEcZ9+/3TJ7SP17ZzGKPM6ShSUU08\n", - "zwL0WnNRFpfvO+kZoEP3I42IMqNbQVVGGYwUGz43tLbdUPyZFLUD13v00UdL6upDLRVQPIEs16wj\n", - "lSRJkiRJMmGmpkjV7GJeUqJQDNwD7su999674N+pSowXxXt5vLTaSutRxD/xC3htKBPUsiBOIPKm\n", - "qFdV2k8I7++EE06Q1HmTpRohU0jsbAJbQnFze0AxbN13y+2PdnZFiuq+Xq8J3DurtRcUz9o9D8ft\n", - "naIYleqpEbeCffnY5n69fVBfUPTY1+vKK6+UVL5vlLCF7htF6phjjpHUKVJRbFEEx4kUKZQjj/Pi\n", - "3gCFAaWFsUfNLaA2GrY8qf0dI1AVAZUVG45U/1pV2Pd+I3YJUBdRYmorn9O+qLG0r9te37cWJSIl\n", - "yhVFVGPmXK8Yz30Qa4dyg41jv74v5bTwfo/aATsqPUtq9/UcN7Q37YwihYJaYo+K1Le//W2deuqp\n", - "Ovzww7V69Wr91V/9laSfTRannXaaDj74YJ1++ukjD5ZLL71UK1eu1KGHHjobOJgkSZIkSfLzyB4V\n", - "qb333lt/+Zd/qaOOOkqPPfaY1q5dq9NOO00f+chHdNppp+mtb32r3vWud+md73yn3vnOd2rnzp36\n", - "7Gc/q507d+o73/mOnvWsZ+mRRx6Z5+VIo56Ix+BEq1G8NL7rigHeTGlfqFrwJlAG8EpRpPB6or3H\n", - "nCjWg/vAs4fa/bdYNRMfQNaWg5d3xRVX7PF4eOHjqvDdmq3Yuk8WXhDKE++78d6osjt0J/ioPVA7\n", - "+qoHeM0oOiiPtUqUX1+r9834pJ+wc8ZRpHQybj02i0ws4HiuHFHFGkVvx44dI/dRAnteSA3BJjgm\n", - "Ns0uAewpt337dknlOePAAw+UND+OLRor7G6AbbDv40tf+tI939T/B+WmbyX1vvhcPTQu03EFys/H\n", - "XOYVpVH4XNEC5uB77rlH0nxlhLHAMwRQNVGIIkWE/kSdrZ3zXYXlmYIyyX6fgAJ3/fXXS5r/FmLl\n", - "ypUj9zPuubqV2orhPMui60TFfsYzniGpG2dD92KshWcvz3bmtLHESD3lKU+Zlbye9KQn6bDDDtN3\n", - "vvMdXX311XrZy14mSXrZy142u3HjVVddpbPOOkt77723VqxYoYMOOmhe+m+SJEmSJMnPC9UxUv/8\n", - "z/+s++67T8cdd5z+/d//fVY1ePKTnzzrGX73u9/V8ccfP/udfffdN/Rm53oMrKrxZKOYDPdmnHFn\n", - "ZLDaJnaKzBvPrEEJcrgvvDoyFvBC8OBpPz7P8fG0XVnwHdrda2UVTXtwvNr9ktxriN4T8z4fJTDq\n", - "H7y72npPCymYNbDopz+IuXn00Ud7HQ9caeJ+jzvuOEmdsgKf+tSnFjwO3qnbSykW0Cl557VKFF4g\n", - "yh12ivdYimPkOvDivv3tb0vqYvv8c65IMd45L+MhikdysKOFMsb4Gyokbc6YIL6SuSZS//g7Y9Nj\n", - "XlAqGMP0MWOQ8/KT68GGUEjI+mOMlua6SdF37PXFFa9t27ZJmh9HGNm6U8qa87nNlcjobQj2tN9+\n", - "+0nqbNkVJcfbE9v2uYC/c55I8UJBw94YW9yXzy1DaxeW8PGwfv16SV0dMOyZ8eNzgNdmZA9Ibzfa\n", - "y2MPoVQvrgTtR3sxh9VmQFctpB577DG98IUv1Pve977ZBoFly5btMT0++t9cSfD//u//wkDdJEmS\n", - "JEmSxeS///u/ZxfwpaD+4urlf//3f/XCF75Qv//7v68zzzxT0s9UqH/7t3/TU57yFH3ve9+bjSHa\n", - "Z599Zr1S6WfeF5lOzlOf+tTZzBm8Mlbh/p66NpJ/aA0Ph9U9q1MWe1xPSVmJvB9XhmgzVtUoBFGs\n", - "kytveBusplESuD4ULFbzc/uohkiZqI0TaK3z1KrQAF7aAQccIKm731KNmxJ4ObQ7SpzvkF6bjTf0\n", - "emq98xLYNVmOeIu1O77zedQT7MTtIqqFdN9990nqsmJR9hhfxEeU2nUh+6LPGBP01a5du0auqTYO\n", - "jXtDOQLmMK/3Q9txbXyf2AvuleuJroPrnxQ+t0aKFPfN/dTGxrTifR3VJTr00EMldZXZI8WFOZzr\n", - "97mvdswS49aKH584TtobVZY3N8SGEZPH2wCekfzkWcIzAzshhgpQRnl2uSJEf9e+zfE4ZH82RHGi\n", - "PAv9mehzvccF0z5cX2R3QxWphZTrX/7lX54976mnnjpbJX8h9qjj/vSnP9W5556rVatWzZbwl6Qz\n", - "zjhDH/vYxyRJH/vYx2YXWGeccYY+85nP6Ec/+pF2796tRx99VMcee2yvG0uSJEmSJFnq7FGRuv32\n", - "2/XJT35SRx555Gx8z6WXXqoLLrhAGzdu1OWXX64VK1boc5/7nKSfxQts3LhRq1at0l577aUPfOAD\n", - "4au9Jz7xibPve1FgeN/MqhKli1UwsRglampU1YCahvfIatk94FrFJapTBVHWk+OrdrxhvBfay7Ov\n", - "+lKq6jyp2iytUAEctmzZIqmLuxgK3gneJJklvNcvQTtNqroy1MZFoBxxP3i7rZky3BfjwNWDKPuU\n", - "2DXUGLxN1AZi3K655pqm65E6m8XDJI7Qa4wxZlDnUJhoO2yce/M2jSpPo0R4W7jaV1JEJhXbAigS\n", - "XKfbJqou87grEUPfAnhVeo+jpP39PFzXiSeeKKmrx+XKHgrPYtfjiuA+GHOubvN3rhf7ZUyS7YfC\n", - "hv1hJ64G028eOsPx+cn/vf08HtOfJd4vZOB61iX3QUwUMVQlUNBKb4HIuqvNdPc5knpdxEHTDrX2\n", - "vceF1EknnRRO+jfccMOCf9+0aZM2bdpUdfIkSZIkSZLHM1OL8P6v//qvWW/EFQ1/H8oqvVYBWWjv\n", - "rT7wPh3PGS8AhWrc3mLt+3qH9nKvkdU03kxf5Si6z6WiRAFeBvEMKHx9q+S6183v2CXt4vZZYtI1\n", - "X2rt0mOk+sZu4X0y7jwhpbRXHvbre1f2jXeY+91ozzVAqWJM45GicGDjtZXQITofY3xaWXlOVG8J\n", - "iK9EuUOFZSzUZgIDigTt4woD2eC0T2TL9AfXV7Ldce8/2RfGPrFB/tYFeCvhMWn0l7+9Ae8PFEf/\n", - "nCtjwBzKTxSzKC7T+4eYPz8ucwSqNxnPKFhR3G7t25TaeF3gvrh+5kBiyhin1bX4ms6eJEmSJEmS\n", - "zDI1ReoJT3jC7PtZzyRglc4qFu+ldnU4rsrmrhzwHhblgZgn9j2qJaqn5IpHKxyX1TbeGu+Naz18\n", - "st7Y92tSGTrjBi/CK4Xj3bVWCndv3ZU/97pqFVP37qa1v5QrR7XxBQ5KLePD7cUrpnumEHZ6yCGH\n", - "SOq8wiHFfDk2c0vUtswVeKRRnZpWovPV1lCjDSalXkY255WcUQpQ7hhbeyp5syeY01H+PAvS+43+\n", - "YAwzJrEp4maZ84BnCzbO/xerUnYEyhPtR4wTdsj/6Rd+Ygdkl0Vj1RUp5kDPxsQOuQ7al/amvUpK\n", - "n9cw9CxZByWRTF0UodZMcqdVkfJ2oh2og0kMFzsflEhFKkmSJEmSpCdTU6Qee+yxWe/Eq/+izPB/\n", - "vIiSx0+WXVRNfShr1qyR1MUJ4D211j1i1e5ZXHhbfTNhvCI8XobMmIyBAAAgAElEQVTX4ijFYrWu\n", - "7pcqZIPineKF9G3fkppQUqKwa7JVwVWBcWVEEYMUeYfYBV5x35gk2pe4lui6uS+8Pz6HCsI49xi3\n", - "IZQqVaO+cg3jiq8sEanSjNGSEjW0bg7t4jbi50XJQDXkvFG2YgnuG1txZQulhfN6PCrKIbbD9aCG\n", - "MrfSjqi/jE2/v3Hvz1qC8/tbGOA6iYHimcfvPGuiucZj80r1l2hX7p/+od1a+5n+KL3F4Bk9LoWw\n", - "rz0CawcyhYmRrCUVqSRJkiRJkp5MTZH64Q9/OLtqxSvwCsieEYDXyGp+sbPGuE5/L/z/2jvXYL2q\n", - "s47/jxqnzoRRrCVAoyTmQu4nKQmXlhppAcWpFAzToUjLjKnOdMZWgRYGtXraacHWOkipVqelDoOj\n", - "7YdOAREiiqEkaWkICRASC7EJ5Za2I96KdUrV1w/4Ozvvc846a+313k7C//fl5OS8795rr9vez38/\n", - "l1j7LkesBYfljbUS32tH355Unqzoe0I7sXpLrVeUG6w7fNaOFvC7wDoiUqRU4Un5j+RqBabmI/1H\n", - "e2KesDiv+5WhP2cVEjGDOkA7mYe5+fIzP/MzXd9LZemOPmHMf+Yr2b75/YknnpA0WLWAMUR9xWen\n", - "39URUrC2cionEYyRXiIajyQ3R+gP+qnXaEP2JH7GfEOAjw5/j28ZYlRZWwUBhqVEQenbEtYmilSs\n", - "VlFKSvmKoATiU8aabbseSudHv3L79Qvyc3GvaOuzZUXKGGOMMaaSkSpSwNMwVgpPhVGRSlkvELMW\n", - "9xt8o/gJqVpikegjwk/ancqZwvF5aiaaDlDEsOCjz1bb2mwoJCgo5HYZFr0WsF6xYoWkpl/bZjXm\n", - "euP7+5jluhTUA5S+qAK0tfrwsWqbwwfWrl0rqfGVQyHCX+jBBx+c8fvkn0KRwqonoiinDsTxJUcR\n", - "1RO4rl6i9kqhzaiYqfqWOVjbrFHmHCobexxqXcoHirGIEcujpm3EaynRX5M8U/Qf48GexF6Hz1Db\n", - "XH7sDcOiNjdbKs9WW9rmJmwbJdrvjPG9+v7Vfv9tb3ubpGb9cQ8orZJiRcoYY4wxppKRKVI/8iM/\n", - "MqVCO74jVLBGWUGBSUXgYOHyvpwIjhRta8RhgeMLgiKANRt9pngqxvpB2cDPAOu09D0sVldKucC/\n", - "A6UMvwpygmAl83es3ZS1EvMxxRwkPKXTj/zkvHwvKmPRhyv6BkGtAsbxeU9PjpnSGo0RrguFlPkX\n", - "oytT8wjrhuhBxj+OY85PJfZbrRIFXA/zg/ak5gPriXmGlc240b9RqQVUBvqP/kIxJB8b/XDo0KH2\n", - "F9UjtUpUzLmWW9PscXHPgKi64yszLGrzQ7U9fio6kn6MfoTMVZSotsQ5n4O3AMx57lGor6xB5nRq\n", - "nNgDUtAe5j5rnL0HpZR7AP3C+eI9MY4f52eNs2aJUkPxyimO3FvxZ+QelqsLWwr9y97PvbX0Hn3+\n", - "+edLasaF/slF1DMv8F3Dd4s9t1RRtCJljDHGGFPJWGfY6ZT18lPzxMTEsE9rjDHGGNOaiYmJ5Fsx\n", - "K1LGGGOMMZWMzEeqH4oUPjb4WsUIF85xyy23dP1/bV0f3jfz/pr3qPhAcb7bbrtNUpMfiuy8+BDx\n", - "/pb3zrSfzxPFxPtifK74+5NPPilJuuqqq7rOy3tm2pfqF3y88NPg/TnXg/8C7+W57iuvvLLrfPiA\n", - "8X0+z/tmnt7PPvtsSc37bnxp8AvAJ47vk4/ot37rtyRJH/vYxyQ1vl70H59fvny5pKk+a/g5xMzb\n", - "cM4550hq+vNXf/VXJUkf/vCHu/qBfozRlqURVZwf3zJ8pejHYamznOdP//RPJTX+PfhH0D7qYdG/\n", - "+Ab+1E/9lKQmgz7XH+uc8fsll1zSdd5BMzExoTvvvFNS43cFXMOyZcskSQcOHJDU+FCwdvCJwe8r\n", - "FRWWGzvmPHN8165dXX/Hb4y9IRUpSbuuu+66Gc/Xb+L14SdKe1hLtXU4o+/O+973PknN3GSvS2Xn\n", - "x7coRiTj88IeECOQ8RG65ppruq6P/En4xOADlFIgok8P84R+wfcI/8LNmzdLkm644YauzwPHISox\n", - "FfnKvNq+ffu0f4dR7S3DPt9Xv/pVSdJXvvIVSc34pXy+8OniXhJ9I5lvp59+uqRm3TJfUliRMsYY\n", - "Y4ypZGSKlJTOFE3Gbyx/Mh0DVkesVRePC0QjlWZ5TcH5cvmsqPvD+XjqJUopFyHB94le4rwp6xgl\n", - "AeuJ/sRqi7XzUlFf9GOMlIiKA8RcN1HBilFZMXM3T/+oAihAqdwp9BtWKAoakTRYn1ijtCdas8wP\n", - "lLvYP1x/7Af6t21kU7+yUPcLrP3SWnb0e2rexvxtRCmOgqhEAW1nTFEcgDlZmyE7Qj6exx57bNq/\n", - "X3755ZIaizoFyseooR2o722rSqD40C+sybinxbWSUrxSufGi6sxelMsoTrvYU1CI4hpBmUPRePzx\n", - "xyU1ilfM8RbffqT2cPai1N8XLVokqYma6xXuGShmCxculNQosajPXBfrom1dWUCdRkmL/VqaGy9G\n", - "XW7dulVSuTIaM+tHOA71PktzMFqRMsYYY4ypZKSKVEp5wOJP5eDI1fOJx80pSCl4SsYa42mVn6m8\n", - "Tlgr+N5wHbGOUVRCIlFBox3RakHZiZ+vrSMVrytlfTJOWC1YayhD+IRhxdAerE76CWsspZCkrIKY\n", - "wyVm5U35NzA/UDrbZn5HEW2bzyk1fvjERWs9B1ZlLjP6oHMDRQZdYaAXyMsTFal+1+3EByvOwVWr\n", - "VkmSHn30UUnSAw88MONx4h4Yc+Cl5lQtqT23VomAuDZT7c3t1anM1cxxFCV+xjxBOVDX416EcoPC\n", - "xPyJ/qi16jPtS1XJQEHJZfsvzTTOnoE/5MUXX9z1k73lrrvuktT725zYLxyf/i5VXqMiVeujl6Nt\n", - "RngrUsYYY4wxlYxMkXrNa14zqcjEp1We+lE2IqlIDkhlzW0LVgdWbLSWsHqItIB4PXyvVBkjoida\n", - "gSkrDqu3bcb2UlDmUudFEYr9tGHDBknNOKFQ8feYIZ3vl9ae4/w5ZS9F2+y1kFKiiAjDxy0qp6nx\n", - "izX9SintJ5RCwM8Cv6FU9CHjgXVWWscq58eBShD7J7Yzqkb9AAu8X6R8O4gOoi84L3137733Fh0/\n", - "F2Hcay22SNzLhk3KbzY192gvKmj0NSqdQ/ggoWzhK0R7UA737NnT1b5LL710xuOi8ED0FYuk7mnM\n", - "r9w9pFYRw5eP9qGA3XPPPVXHi3C9+NtGxS83jxmXXuuwDgorUsYYY4wxlYzs8W4mKxyflVQETu69\n", - "aPQNStV0i/D+lfxIRDKQ4yVaAygq8Xyl0VAp2vojYPXGSvO0r63igaKH9UCumwjKAgohyhR+Fvj+\n", - "0A5+x6rD6mO8UUCiohitzlh7rjY5P+3ul4JJpEttnrJBEdWS0vkZayyWWrtRSY6qTexv1BvWHRDt\n", - "2k9linPFCNW2fnKQUiexoFFLOV+qHmEprBH6mN9Z47mI4AhjEetHAv2FwtPvCNSoBrOGYn3M1HlX\n", - "r14tqdkDUTm3bNkiqbxWIaorexWglJBbDmXsLW95y4zHQzmJSgtrIaVIReJeV/u2IUZ2RxX6vvvu\n", - "6/oZYa/nOLl7MMoWNf3IWcd54/hy3Hi9QB641L2o37T1PbQiZYwxxhhTyex84dhnUIxS79+Bp1Cs\n", - "G6LK4tM3vhz8f8xJURstF4mRDVg58fj4VPF5rEiUoZSVkYJ+wtpNVUwnk3jMAM55sbrWr1/fdTxy\n", - "f/B5+hMFLCo60XorzSieAyu0raKFLxRqBMoW1hdWMspbtGpSPmezjTjuqBU5azqqNDESKaomrB8q\n", - "rw8y7xYKUb/9CCMxQrVfYLEzZxmTqKS0JSoWgIrfrz0tEvfitnmzHnroIUnS61//eklNpHRbcqp9\n", - "rI7xyU9+csbPM7/+5m/+RlLjL9rWR4+9DqUO5bRtZGzM3Vca7RbvJeyZOb9UPs9ex9uc1NsW/EpT\n", - "GeuZ9/2KTs3R9jxWpIwxxhhjKjkqFalUVFsKlBze2/L0G+H9OtlqqfmGtRJr0WG9xafnttFzHA+r\n", - "D2UDuE6UsqjYoPSg6GAt4EeRespPwXVivaSsUZSEmKeI82LN0J5vfOMbXX+nvRwfX5joy1YandYW\n", - "/CdKI0EYJ6yraMXu3btXUjNO4+PjkqbmfqFfZjvM31QW4BSxP6PKkPKDGEYG+EFFtkZQ7VibpT4x\n", - "OfDRQTVGSSrNHxRh7TG3o7I1KCUqRdv8PezBX/7ylyWllZIYgXq0wT2PvbE2V1tKiUJB4l6BksQ8\n", - "w6+y1F+R87BX8nsuOi+lrMaamIOmNEIZrEgZY4wxxlRyVCpSWB1RyUmBooFyghLC03F8SuYpNEYX\n", - "YUGnFC3g+DlLnkgIopWwNsi3hI8N501Fg6G04WvEdXLdREygtOXAyuO4qWy78fPA+GDFfO1rX+v6\n", - "O9eZ60eIKgK/87M2uy3WTapWI/MqWmepKD/Gm1pz5KZBqWJeDUph6ze5CgIp4nqsrSwwCHrNhFya\n", - "JZ6x7rfyhX8Zewxzs9c5FVXhUYFylINxQGXP+TnWRvYOG66LPYZoNdZQ22oKpXB8Mrizh1HvtTT6\n", - "kfazt8a3IoxD6l7GPSyl4PbqC1hKW3XcipQxxhhjTCVHpSKFjwlWVC4vDh74vB/HmstlWc29h+bp\n", - "GOUGYv6dFEuXLpXUKFKxVh2KQK5OFNfH52k/VkEqSizlq4KiRP+movZSoDgRQYNSE3P4lLYH6G+s\n", - "/F6t/bVr10qaOv5YgVw37Yr+JLG9/L58+XJJzbhw3Vg5vdYtGxa1/jFx3UQVp19Rl/iNzGSll9Yj\n", - "HBTMFfqgbSbyuJcwJrGaQb98fwbtO9Yv2LtLfc/6fV0xt12/YFx5CxDzLg16fMhzhnIb8z3liDkI\n", - "uZeU+jalouViZPhsw4qUMcYYY0wlR5UihSc91mXbDOK8T+cnSk20GlGYeDrGSoiKBO/z41N0qXXI\n", - "8bAqsXLIX0Um8NLrQpHiulBCUr4uKWUARYzrapv1mevi+6U5QFLtoX+iEsQ8wNpJKROpCAyOF608\n", - "FDXOy3mw0uif2F6i+FDgyLNVWjNxtkJ/R9+7FPH6sE77bb2z/ttErLE2aGPbOo2pCM9Ufh7mVk6J\n", - "SkXW4rMC7An4F3IdnLdtRmZgLcSI4WFTuqe3zQxOVFqvikb0TeN4qaoZtVUTuIcMO8oQP9BaXyz6\n", - "GSWYtymsg1wtx9T4s+7wKx407HWlvnVWpIwxxhhjKjmqFCmecmuflqO1xk+sBqzBmP0YC5ynaayE\n", - "VNRZ6XtsrgPlAqUDReP2228vOg6K08GDByU1ERe1kThYV0TbYYXFWmgp6Ff6IVq51C5s2x6sA8YL\n", - "KyUXHZmyQp9++mlJU6PK6DcUpmhtprIg871t27ZJkh555JEZ2wW1KkIK6lHRP7WRLlinqCA5Xz2I\n", - "qg1qDD6BUJuFOp5nOoUspZ5RPxN27drV6pyptZ1SsWPUUmquplTfGDEbc+ExN2Put9K5RIQw31uy\n", - "ZEnR9/oFewvEvZ3+Y82n+i+l6KEap5SO2L+MW6r/+H98h3LqbL/zcJ1++umSpH379knK149tC3tF\n", - "SgnjLUdqHGKEM5+bN2+epOZtS1vfRd7+UFUC8Cvud7Qpe2hpJnorUsYYY4wxlRwVihSWJ0+ltYpU\n", - "tBpT/hHx6Zana5QDnoKx0KNVVQqZvrGasKKpXF5KtKpp/+7du6vaBVxv26g94Gme8cvVs0oR31Nj\n", - "5WHNEGWHlROjBPEfifMGpSVasW39ZuL3SpUoQE1gHsVoUNSHUusWaxKlEtUBOG7OzwQlKadEYSXi\n", - "C7Z48eKuv5ODBv+J6CfB9Z955pmSmnnLuJ199tmSpO3bt3d9b7r+yGUuJy9O7R6S8plgT2BvYa+i\n", - "7xkL5mYuQhWi6s33sPzpS+Y611Wau4ss/MyJUr/MFLSrtH+jwhBzA5YqLrS/rT9n9GnLVTmgXezV\n", - "qP9ta+i1hb2Ytw5tlSiuizUW5ytvH7gnRVatWiVJOu200ySl5xd7D/OS/nnTm94kqVEA43xNccEF\n", - "F0hq5hWqNuuGHIn9UqSoaXjOOedIkv78z/+86HtWpIwxxhhjKhmZIvXjP/7jxU+RWJel2VVT1EYN\n", - "YZnjUxOpVTCALK+pbK85yKcTawDy1I5SkLN+eS+MotBrHS9om4ukFK4nZgzHWktZbVhFzCsUxxxY\n", - "dfRv7v0+44KihwKUyqQP9DfqAxnSsbax9qLfyIEDByRNjdLEBw/6VfeNfouRS+SiiWDFRmt2zZo1\n", - "khrrc+PGjV3tZH1FRWo6cv6J/c4MjYJDH8RoK9ZenCulubSiLwpjSx9GtbetZU49UZQJ2stewE/U\n", - "UuYYigZ7BJ8D/CBz1xmVnNe97nWSpK9+9atF7addKGv0V/RxKvXJSc0f9kT2shjJHYl+nL0S/XpL\n", - "QRFFSWJvQVHjnprLbUe/7tixQ9LUSHPg/5kfwJ7LmmZPZD1Gf87Vq1d3fY+M/iiP+FzFeybKFesy\n", - "VtXIEatylGbatyJljDHGGFPJWGcERYjGxsY0MTEx7NMaY4wxxrRmYmIi6SNpRcoYY4wxppKR+Uh9\n", - "6lOfmhKRQlRPLuIklak6guqF5z1+C/E8qczfvI/l/S3vw/Fx4b05n8PH49Of/rSkJsIgZsOFBx54\n", - "QNLUjOb4O/Aem9wutB8/CHxJPvnJT0qa+v6Zmm8c57HHHuv6HFmTiVTg/TTf53p5j33RRRdJkm6+\n", - "+eau/68lF2HF+P3RH/2RpMYnh/flOXJ+ETFS6Z3vfGfXeSGVowa4DiKQuB58nPCriL5RnOdDH/qQ\n", - "pGZe8l6e9/Wxn7kucuykcr7QbtbJ7/3e7017fb0S1yPtev/739/T+XLRhTFiamJiYvJcublVC9d6\n", - "7bXXTp5zGHCetuerrTUYzxf7M0ZgYqnjJxf3dvYg9kD8VdkjL7vsMknSRz7yEUnNmmSvi/m5YP36\n", - "9V3te/jhh7uuN/po8bnf+Z3f6bq+QYGv1G//9m8P5Xz0M2v9rrvukpTPl8Z8pt8/8IEPSGrWND5J\n", - "rDnWwf333y+p/fwcHx+XJO3fv1/SVF8zovHw3Yr3+tr1UEvuPFakjDHGGGMqGZkiNV1W8NLcJ23r\n", - "JWEVYJ2ROySlREEuuomcNDH3Cnl3+MlTPOePUU3kBkmB9UZ7YhRdjEbEevvyl78843FjtCBKQlTe\n", - "AEWqVyUKxSXmcEmRy1yeImeF059to9hQxugfrHTmNDlfOG6sjxZVEqxm5mNuXnJduTpcKSu+38T1\n", - "WJtJPZIbl5kqyqPupiJtSyErP2NdmwstlTeKHGilKmtb2ipRKeKcZa9mbjPmqWoPzMG4V8Xxifmj\n", - "cnsEf0f15fsoZbG+ak6hJPqvbR1XiHmw1q1bV3WcWuJaz+0lsHXrVknSxz/+cUlT1zT9x72iNJot\n", - "xaOPPjrj33P3xNmGFSljjDHGmEpGpkidcMIJxVYYvjzk5dm5c2erc6WsoV7hqT1aVfhExXpbpYpb\n", - "6jxYs9HXKkXKPwJfHqxHrJZ+1W3CGkz1NzX7UjX3+qVo9AqKB/XZ8FnCP2Tv3r2SmnFGrUBlYLzx\n", - "Wzj33HMltc9cX0utGhHnTWkWbuD6B81M15dSolBQSpWl0vqCOWLfoZhh2Q9KkRo0KC/4tLStn8jc\n", - "ipTulY8//vi0/8/es3btWknl1QZy8yJXaw61mn45/vjji847KHhrkoN76nXXXTft3/GR4l4Wc9NF\n", - "2PNGkBRgJFiRMsYYY4ypZGSK1Le//e3iiBKUAKLL2ipSWBEoRTETNsR6TaUWfbSqeHrHGuF4pe+r\n", - "I2SnRTGKPlIoJ1wn58WqI/KBeknULiNigujBCO/7OS7Qj6mM7oxTSpHK+Tz16tdBu1Eya9+342OE\n", - "9YWagZWXsraiusD1pqxd/DIYR8at1jesLcz7mG0Y5RM/lJxiyTzhegZNqUJ2JMwNlAPaHOtv9su3\n", - "KAUZpXut1pCCaLi2ClFbqM1W61OUioTFr5S5F49fGpUZlaicQpQb99yajGsE362zzjprxu+lYE9o\n", - "m9Ec4hrJKUVkLo/wloH+IyN+ilIlircjfP6JJ54o+t5sw4qUMcYYY0wlI1OkpHKrDyWntqYdFj5K\n", - "ClZMPD9RQm3rI8W6QihAPMVj4bf1QcJ64PupfsB3jPpE/D0qQvgTpPwKAEWB/olWWK7Ces46ra0p\n", - "WAr+CaXzhX5OwfzhulP1tXKQ4yaCnwyKUIzKq1FepKnRhSm4nhhx1TY6E4UZ3zF8wgZFrNNWQlSA\n", - "onqYU1uHTW2tNmqr4Y94++23961NR8KY1yomEWqroRSmfJu4rg0bNkhq9qgvfOELMx4fRTIHamzb\n", - "NRAVn+jrxfWVRizTr/ig5dT1WDc0RhHW+izhJ0p/4Cea8ymjHzlvrAXZthZeCtYJ+al4i5CKIu03\n", - "VqSMMcYYYyoZqSJVCk/Z8Wm7FCx6rJacNZB7745PFIoTVmz8PtYAPk18DmUjpzTwFE/Fdd6Xx6g2\n", - "LHOsH3zASq2eSDxOJNfunN9Hv6IDc5RGZpVaaVGJolI9Ge3pNzLNR1LWKN9DEUV5ZL63HUfmHdZg\n", - "rrJ77TyJ0P6cAtaWVNRg22jC6cDvjba3VaJKVb8U+IjgSxP3nugPWUqsXsBc3b17d9fnatuPior/\n", - "Jj4zrCXmIEoBKivXw1qIezpzkT0vBVUa+FlKaXRkVNhQYLiO1Dzh+tjj495Su9ZK/Tyj4obKXRsx\n", - "DiiErLWUAokix72K/ujV35PjxdxxzCPmGVGFKSUKP2E+XxrNmcOKlDHGGGNMJUeFIoW1lMvUnYKn\n", - "Vn7ylFwbRYeVwdNx9GPAeuE8WAV8vq3VS6QECljKbyJ3PUTyAD5U8b1128zxbRl0NmcozWVSm6WX\n", - "rMXXXHONpMY6Jkvwvn37uj6/cuVKSVN9pWKkGFYr86YtKGczZf6uIZcfjHXar/Pm/JVYF0cqj7m6\n", - "iEDGchQhfDXa5o3qVX3D5ySlgrfNug/0HUoCkZkR9qjUdaQyfTNH+X5cY8xBVFHGkJ/sxamceLV+\n", - "iP2CdqKY0d6cL1icd7X3mFqi2s/49apIsS5OOeUUSc38itUV6CfuIXyv13xS7OXcWyEqfCm/Se6Z\n", - "tK/f9x4rUsYYY4wxlcwKRQqfn5h3KT7d12YmR3HAOuA9Mk/Jbd/f8j2sxeijwdM41mbbvFQRjs/T\n", - "eG2EDO2g3TmrrzZyJQdRjoxnLz4uM1F63NoILZQl1AysIyKJoiKVq/sWrSvGK/qxoDJgpaWs3tz4\n", - "xoieHIwbVmhKxehXZvOcr+J0f88pUbB48WJJzVrq1WKvpbZ2Xw7WFopRKjI1d92okNFvMo49e2xU\n", - "KPg95gzEhyXlA9YvP7teozBpL2usbbtqVeV+wfj1mp8JHz72HsY7+sPGnIrsMb2OJ3tjKhM+pDKu\n", - "s1fs2rWrp3aksCJljDHGGFPJrFCkeOrn6Zmnz5o8MdPB+1F8N3iqxW+Ap+VSaxZQsuL732gp83tt\n", - "tBoKElZhtPpKiU/rRDiksgSnlCiUiehbVQrvpwelRLWlth1EfNx1112Smjxe+BFEUupDzlqLfiyl\n", - "CmouhwoqQakihVWfq4XYaxRgjNJNHW86Ja40ko85z7E5Fz4lzH36ph8RgsOEOcJaxcep7XWkfGDo\n", - "N/YkoveolgDsqew1kX7t8SnaKlFxL+TeVPo2Iaq8o/b16leENOuB6MHUXsb1U90DRZB7Ra8+Y7m3\n", - "MaNan1akjDHGGGMqmRWKFGAFoEyR/6bXrLlY8ig7UXnqta5WfM/PUzE/eXqvtU74HlZm26duFASs\n", - "BPxD6Ie2uTRKswOnqFWySmE8aqMPY7Qf/Ye/Q4ykQuk7/fTTJUmLFi2S1Pi05fxQOF/KZynV37mo\n", - "RNSD1LxrqxzxedSFVP/26vfDeq3xq6DPc5YvysPy5cslNXsAY7xt27auz88WJaq09hpjH2vL5bL4\n", - "RzhPaqxZC+zZKYaVOy4F0Zm5tw45v7wcca3V5gHrFzn1uBT2IPaA1J7CPSrWf6X+aq+KVIweHbRS\n", - "nKvNONmOgZzdGGOMMeYVwEgVKfwSsAZ5n0rlbyztVI2yFDHTOFYV1ki0ymJUX1uFKj71Y4Xw9M51\n", - "1GYRJhsrT92lUXRY17Tn1FNPldREVVG5PWWFpTLJD6t+US1tlShqFQK+czHaMhUx8g//8A+SpJ//\n", - "+Z+XJB06dEhSeSQY85V5hKKDVZdSnGhPar72u14c6ygXOTNoTj75ZElN/bHt27dP/q3U4iVzNmuR\n", - "tYVa2mvem34R+7pUnadPYoRx270tt9aZ46yhVPReW/DtwmctZk5vC75Y/crinwK1FgVu/fr1Az1f\n", - "jl5zunEPYVxROlGYUnVbmae9RgvmSClRpW8DUrDuSqupWJEyxhhjjKlkpIoU1iCWOHWvcpZ2CixU\n", - "lBdAIUCp4PgoNZwfZaDtU2z0YYkZl7nO2krutD/lZ4DCxPVFHx7eZ6NkYS3m/Bb6XTMNRh0BFX2o\n", - "otWfsqZT8wJl7/bbb+/6vRSUo9jfWHUpFaJX3z4ozQaONYoqsHbtWknNutm7d6+k8vVTq9CiKM+k\n", - "LnBNrDnG9Oyzz5YkXXHFFZKaNYr/IIrWTTfdJEl65plnWrWt3/S6Rnbs2NGnlkwPY9CvmmWAMsjc\n", - "71UhLFWiUvUwc3APIIccSk18O0Ltw37Pq5S/ZMwE3paYexBSb0V6zduVorQaxsUXXyypecvy13/9\n", - "163Ow56EH3Gpz5wVKWOMMcaYSmZF1F6sFI5S0NYaI3oq1k6LCkPMpM57ZM6XyqsUIV9QzOSMX0H0\n", - "1WkbEcLTcU7JQlHhurgero96R9SC4/NYR5GYzbjXSJZIv5QolCXe12MFpeqlpbLs9urPAffdd5+k\n", - "qUoRkSup/E+DUv5yUPuP+YWSFtvJPEEdwFrD2sVqRdXJKWXM09x1p6IYWVfT5SBizfCZaKHjO/T1\n", - "r39dUmNZU4eSuT5qJapfsNbph9ni+8U45epcplTz17/+9ZN6kn8AACAASURBVJLq668CyuW5554r\n", - "qfFxYk/Ax4d+w1+VOU4UGW9DYmRvvAdwvaeddpqk5vo4H+dhTZWqu8zf6COIL2CvsKdSozLlO9dv\n", - "JQpSShRvnzgv67ZtBnPWCXtSzIeW/X6rTxtjjDHGmEnGOiMwUcbGxjQxMTHs0xpjjDHGtGZiYiId\n", - "QT3kthhjjDHGHDOMzEfqSEUKXwvem9dmRsYniPfEnKNW/Yo5QXL0er62xPOR/wifEiJPcpEUREvi\n", - "H0L/cf38/3XXXdd1vkGT6k/8DMgx8+STT077/VSGc3zauC4ihDgPPjyf+9znJDX9CvzOfMOniHbQ\n", - "3zGXCRFBmzZtktT4HHHen/u5n5PUROBs2bJFUuOX8Qu/8AuSpI997GNd7WHdkFn9yLxKRzKs+Um/\n", - "/MZv/IYk6cMf/rCkxg8BnzagsnwEH0R8pejnmNcLf5Jrr71WH//4xyU1fl/0Ob4PMav+L//yL0tq\n", - "/K2IcqONrCXWAmvjPe95j6SmL1P+XP1i1HvLsXq+T33qU5Kk8fFxSdLu3bslNXOKKE98dJgnK1as\n", - "6PqdvYR5EOtSvve97+06bwS/1H/+53+e9u/kTnv++ednvC72pquvvlpSE33KvCXDO75Ojz76aNd5\n", - "aT9/j36IMb8XvkS141eaqT8Sz5eKPGZ94xP54IMPSmrynm3cuFFSk6eM/kidL4UVKWOMMcaYSmZF\n", - "1B7WYq/uWm3rSOXoV32oXE20fhFzfUAukiKlAI66PlaE6DcUn1z0XyrDOQpRVJoi+/bta9vEIrgO\n", - "rF2sQKLmsJ4Aa3Lnzp3THg8rkQij+fPnS2oqBKQUqkERI4di1CdWNWpRiqefflpSo5imrPUjI7+Y\n", - "E6kIyQj5j+JYc25AWUhFJKayvdfmJYLa3HNHO9SrRGGI0W2R+DYiknq7EKte8JNxY1yZT/xMRQui\n", - "HKHY5DJ7o8igXsc5joKUi5xmDaxbt67r/1N7OO1DoQEU1dS8Q9GlP1OURr73WkcXUjnw2FMfeuih\n", - "rv+nji9RfiklqhQrUsYYY4wxlcwKc4en/9zTae49cvR/GDWxhhtPwZHa98SltPX16jel1kkOrEGs\n", - "prZ1pGI+p5SKkMue2yvRjwbFJVVZnRwuqfxYsSI6/g05q3FUROs/BeOVAkWR/is5JqAApFRHFKjV\n", - "q1dLymfuTq1dfK34e9us97N1DAcNyl/0+4ygujJeKUUqtfexF+Abh78hyia593K+ScAen/p83AvZ\n", - "w/DnRJ1GYeK6qW6RAqUu3mNirjbunVx3ql9ybzFy9Uz7nXswR7zH0Z9kmE9VS0k9S7TFipQxxhhj\n", - "TCWzQpHKVWznvTOVtO+8886BtOPKK6+U1FgnRALcf//9rY6DTxTWR0r5gFIlCgs9ZS1gZfN0jlXE\n", - "0zlP44OugB7pt3WC1dG21lz0qUpZVfgPDIqYCZ9xYr6VgjUeI2tyCtbRQmpfoJ9QfNtkpmcNsUZS\n", - "maNZS7m9CVK+UOwBtDkqUrnaa71WAUDZoF2jyqLflujHmFrrOWWFceRtRvQ/BMZn+fLlXZ/j/9es\n", - "WSOpUagijDMKJO3BdwviXsjcJWqM6yTjPvOU4+fGL6d4osBw/NTbgqhyR3J7Vb9qCuaiYelffOrI\n", - "uM552ePxq0UB5LpzPmxUa8hhRcoYY4wxppJZoUjlwGJvWz+nLV/5ylckSUuWLJHUWENtFSmi87BK\n", - "ctFJpeQikbDi4tM7Vsgb3vAGSU0kyJe+9CVJjdWdqug9W2mrrJUqF/hbDIpUdGmpfw9MV2vuaIL1\n", - "lYo2TYH1jHV+ZL/lImRj9FUKVPBSVQ/lA0WBNYhFG5UMlKJczjx8dtpC7bcNGzZIavagW2+9tep4\n", - "wwYlIecHmRtH5kpKsULxIQcbeyD9Tv8Bcy3mPuM8vH3gLUApqahQlBPUZ/awqBiVriWUGY5LPqyU\n", - "0pYi95ah7duCFPTnq1/9aklT71Gs96997WuS0m9r2tYAZPxSNQWntLPV0Y0xxhhjzCRHhSIFpZET\n", - "tZBTI+bWqCW+R069j24b1ZbLl5VSNvD9IrLj4MGDRefrN/2K4gP6GSt2tlS4T0EGdKzBYx3UEeYb\n", - "Kk2tvw7fm06Rw5JMrYFSyx21k+OlfKVQEogYjmowPh743tDmZ599dsbzQ62PFH3Nz9NOO63qOKMC\n", - "RYg1nfJly8E44ksT1WaUKn6iEDLu3HNQJlJZ+IF2oqTEqDD2Pq6P9pALLvo4MX74A6LM0E6UH46T\n", - "U8KY/7SDtcnxaC9/T/mRpiKbUbz6BWudyNyoSA0qUj8XlRixImWMMcYYU8lRpUgdLfBeP+YkSSkw\n", - "bZWZXBRgjkErUShE9EMu03Ut9ANRdqgBUSVoE9V15HEGRe3xiTziJ/1a+h5/VMTaeDFrNPOFiCdq\n", - "C2Ld33fffZLS6syRfjQ5PzPUMKJ88J2ISgO/5yzsGFUVLWQUDSzqqCanaoQBilavPPzww305zrAg\n", - "krnXahUxUjnlu0OephjVRR6inP8oPkxxz4t5wJhP3BsYd+Zhqj5ozA8VVXcUtVwmfPYe9uAYYU7/\n", - "pNoBqXFh7cZoxdq3SXGPxxcK6Eeua1RvI6xIGWOMMcZUYkVqAGA5836Xp+Z+ZTDvl5U6KGK9qkGB\n", - "8kR/4/eSiuTJ1eOCQefZqs1Wjf8C1uew84HVgpWIPwb+IKg3jB+Rb/iDMH9SViYZ3Nv4M2CJY4Gf\n", - "csopkpo1GfPe5KJ9GAPaHi11fE9QNiJEB6J4xLk5aHV0toIy0q+9LuVLw1rE94i9i70kpUQRdcl4\n", - "MxdjBHT0WeL43AtQlxln9ijmXYzO417C9zg/9TVzyhkqL75Y7Clx3uei7lLzkvXFuuhVIaIdqbcY\n", - "KHy9+kqhfEXV+8g6njN+v6ezG2OMMca8grEiNQ089WM589Re6tsTlRLAH+JYV6SgbeRDW7DqsCZS\n", - "OXdWrlwpqVE6/v7v/37G4/aaTTpHrzlW2vYr1jbkci31G7KJozCh1HJ+rocK7KyP6GuHlcv1sA5y\n", - "uYSOhKg5jo3vEmu9bSZmLHNUQuYibcuNFX3BNVmRehn2WpQ++pO50XYPZbyjwsha5++cN6dao2TR\n", - "LpQjxps1Hs/HeKOgMP+iqs7xmZfAmuFzKGFkEs/lwGM+8f3UXlerdnN9KGOsh1jntC2pe29p5YEc\n", - "UUlGGSy9F1iRMsYYY4yp5JhSpGozJUeo6Ue0F5Z0aSZprAasJp6ae1VoeErut+8R1jDWCtdda0Vg\n", - "heQiSNoS809h7fEeO/cenetcvHixpCZSp19ZeEthnub+jpUUow6ZB1ituZxEqWzAw1KkGBfUHtqd\n", - "ur5HHnlEUtMPROxgxfOzF18x5gRtqV2bKBKoocxRLNlcxChrObVWSn00jhZSvigpGNuYk4+5Uzr2\n", - "qf5F8cHHaP/+/ZKmqtvMExQk9kTGl/ahCDFno49TzHzOPETJiQon85L+4nr5f2oCspaJRs1B+1lj\n", - "XC/tYE9su1fE+U5/oCy2vZdwD0opbbSLaFyuh3t1vCfw95i3K94D2ipdVqSMMcYYYyqZUTJ45pln\n", - "9M53vlPf/va3NTY2pl/7tV/Te9/7Xk1MTOgzn/nM5NP59ddfrwsuuECSdMMNN+izn/2sfvAHf1Cf\n", - "+MQndP755w/+Kv6fXpUoILLi6aefltQ+DxHWD/3D0zS+VrV5f5YuXdp1/AhP/SgWpQoan4/KRan1\n", - "gNWMtYVSlKpvFYlWD9cRwWqM15XLUUI7qPSNNRdzp0DMRtxvcrlxUlmOgflZ6x8w7FwrzAdy4WDd\n", - "49eRgnmAtRzX4XRqBApPTqngWMz5mKenlOjvRZtzc4icWSeccIIkafv27dN+rrbW3mwlp0ShGKDU\n", - "MC5xL2GvYS7l9hoUoLinsRegclJbMSqUMQM6cH5+Tlf/8UhQrph/nIf5gLKCkoJqnmo/8w5lqm2N\n", - "v5RPIOPAvYF7YQ7uwexx0S+yLezRuXsRUYy8BYpKVPSjLa0sUNzOmf44Z84c3XjjjVq7dq1efPFF\n", - "nXbaaTrvvPM0Njamq666SldddVXX5/fv36/Pf/7z2r9/v5577jmde+65evLJJ3tOIGmMMcYYMxuZ\n", - "8UHqxBNPnHzXO3fuXC1fvnzyiX06q/aOO+7Q29/+ds2ZM0cLFizQ4sWLtXPnTp155pmtGhWzmWIF\n", - "xMiGCE/RPNXXgo9GLShQRBuRPwcfnbaKFJY7T/mpiBVyhKT+HrMo089LliyRlK8jFYmZqWPW3Bzk\n", - "0OE4zK2UVYWV3/a9fczRw7ikrCTm3aAgs/zGjRun/XtKiYJeoz6HrUhFa5b1nLvOqGShfM6kEJf6\n", - "zKBiYqH2qmYz96MSxfHXrFnT9fd169YVHfdoyRVWSzSyGQfUfJQp5mzMUJ5TolCKzjjjDElTlQiU\n", - "jpQimAPFhdpzjHdKQYlRfMwbFCWun+Mw5/EV4h6Yum7ylV1yySVtL6UL2tF2XcT8WYxvqjZfDt5C\n", - "5PyC9+3bN+Pf6bdcnq1aiqWip556Snv27Jl8KLr55ps1Pj6uzZs3T06a559/fvLCpZc7gZujMcYY\n", - "Y8yxRlFY1YsvvqhLLrlEN910k+bOnat3v/vd+t3f/V1J0gc+8AFdffXVuuWWW6b9bptaSTzFYnW0\n", - "rc/D03OtxU4ETq+5W3h6xmrgOnga5r0vn8MnhvNjfWBN8T2e6mszc8f39jnrJgffj5EppaTGl2zQ\n", - "EdpZqqjgf4ISyLyIFdOjgvbGN75RUpP1GgWL+cXvCxculNSMG3OdfmGcDxw4IKnp/7PPPruo/YMG\n", - "5TZGv7EOuY6U3wFw3fRX9OHD/4PPMa/x/0iBVU6uHJRPFMNecsigDMTaXbBs2TJJjQ9LTj1LgepJ\n", - "n2BossfkfDXarq3Y96XqMN9DJY70ujeyZmK0XYxKpB30G2ONDwxGe2rcIqjtsf4pMMeplYf/JXsw\n", - "48XaZx4wF6PCwRrnOo+sAzkTXDd7EgJEjBKkXfgu0Y9x7QLfT+2pMY8V44sSWFsjj/bVRsOS8y++\n", - "PaitCtGWeI/OkVWkvv/972vTpk26/PLLddFFF0l6+QY1NjamsbExvetd79LOnTslvbzhHem89uyz\n", - "z05ugsYYY4wxRwP/+7//q+9973v63ve+p61bt8742bHODOZ9p9PRFVdcoVe/+tW68cYbJ///8OHD\n", - "k0+MN954ox566CH95V/+pfbv36/LLrtMO3funHQ2/6d/+qcpqtTY2JgmJiZ6uERjjDHGmOEwMTGR\n", - "fBsy46u9HTt26C/+4i+0Zs2aSefI66+/Xn/1V3+lRx55RGNjY1q4cKH+7M/+TJK0YsUKve1tb9OK\n", - "FSv0Qz/0Q/qTP/mTVq/2jDHGGGOOJmZUpAZ20sTDVdustxGi2/D9eMtb3iJJU9QvfGfaRhLgy8T7\n", - "0/h9znPzzTdLanxLeC9PrhIya/MeOhUlyPVEHxyimK655pqu80UfrJR/RGmunRgdx/XF/ow1BNtm\n", - "CqcfYj9xns985jNd7eb6+B4RG7yP5/088ynWfeJ1Mz5O8KY3vUmS9Ad/8AeS0r5jMZIIv4LoS5Uj\n", - "1Z8puG78OdpGWZaeb+3atV3n27VrV9ff8aNh3FPt4Dwf/OAHJTX+Kqw/+okae0A0I/P+/vvvl9TM\n", - "Z9YP/iv4TWzYsGFoSneqL5ljy5cvl9RELHKt9On4+Lgkaffu3ZLSfn/Mtfe9733Tnm9QxOvDdwd/\n", - "w9Teed5550lqotCIUI0wtvhAbd68uet8/YJ28xNfm9xaWLVqlaTGJ4rxY87jq1TqQxTPR/UM8o5t\n", - "27atq33AWmfe4BfIXsmaYk/DHzPe+/h+rH1XG00X4Ty33XZbV3s4PpG29BftoR+45xN1SDuZb/h+\n", - "4ev1nve8p+u8jC97OtGx+JbRz9zTYtUO7h2cB989IuGvvPLKGRUpJ3gyxhhjjKlkZLX25s6dOyWn\n", - "BtZJfMrn6ZCn9ZSSgqN7rgJ2fArH6ovtiaCU5GrI5XJV8HSeq6NVWok+Xm8uUifVfzz90/7k03eo\n", - "cM918FTPU3wpfC8V4REjSfgc/491jzKViubC6omRIETqoEjlohiZJyif5AWrzd5bCuNaGolVC/M7\n", - "FamGMluaDZx5xLhgVabm/549eySl80WhgPGTebthw4ai9gwS5hiqbFxDMWN17oUAa6yUmCuuX3A9\n", - "KQUDdZC9IxeNyNrNZazmevDJRekqJTUOEfqZCFPOh0KCgoEaijrOXhf3DI7HnhUh6jAqZZFcdQrW\n", - "1Jvf/GZJ6TxmqPTMC35nLyy91+RgfLhX0r74Fop18OCDD854vNw9GRhn9gSuO+Ze5N7H/KP/+T7/\n", - "zzzYsWNH0fmtSBljjDHGVDIyRWq6J00sVJ6WURhKa93x9F9aYw6waFE6cj4+PE3Tzrb5bMh0niqd\n", - "s2nTJkmaTCuRsxbon5inp/Rp/uKLL5bUWJu5p/CYX6g2jxTk+hvFh58oJlh9ba1UrEuszpxVlIL5\n", - "Vls7sRTGFSup7fxuC/OJ/ok5aFgvuTxQEY6HtYhVH5Wv3HqPlerbVpSfDqoi9JrhHP8vfrI3xLWI\n", - "xZ4jp1pHUBx+8Rd/UVKzd6Aetp2rpVUEUDZy6ixrl+Pm+pv6oikV9q1vfaukZs6kwtRzfrf4xvBW\n", - "hL2QdqJcMOfZe3J+lCl/4NK9OQcKCwpX3BsYhzju+K71mjMxRbwnDssVm72B/ucehc8WvzN+7EEo\n", - "edzLHnroIUn5t09gRcoYY4wxppKRKVLTwdMgHvb4YpRab7VP+VjEWNoXXHCBpOapmveuTzzxRNf3\n", - "ajMrYx2mntKxQksrv0efJ66jbX9wnFqlDWLtvVKrJxdtCL36ChGFtnfv3qrvY7229QWrBf8TrPOU\n", - "7xLzhUgf1k30m8iB9c44sh6wvpkXKWs8zlsUUqxB2oMKhLVYWk6KdmFt96MoekoVRVFgL8r5P7J2\n", - "mZtEJdFXRCCW0tZHCrZs2SJJOuussyQ1Y9JWkSpVEvCJyn2+7ZpFGaLfGYcVK1ZIkr74xS9KauYC\n", - "Genbqrb0Txxf3h7w/6XqZ2rvZC2QTog9utf6rqVvbWBQStSoiQoie87KlSslNeuctxjc03lLAW2r\n", - "o1iRMsYYY4ypZGSK1NjY2BTrhad9LFUqdhMpAeRNSnHqqadWtQmrA6Xhda97naQmN0e/wPLGOsMa\n", - "oj/+8R//UVJ55Xf6CyUp+ifk8nORw4R24LdQ6h8RaatEAf4Jqei9Xut9YaVgfWAN0n+lYKVCSvGJ\n", - "0ZRt82sBCi1KGOsh5m9i3J988smu/y+t9wUog1wX84F1wTyK+choZ/R7IbqR+clxmW9cF+uN/0/5\n", - "rjF+KK/9SPqbinJj7ueUKK6BNc3xyInF2KBUxNxZKWpz6rFGHnjgAUnN2AyKUgs+RhXmVHciuFlL\n", - "rNXt27dLau4FKFClkaQRxo17EHOWtdAPPzypqW3HdeSUJGoM5lRlxjdVUy/Wp6ytRwvsKeQ6HBUx\n", - "6i764OGryJ6Bosn144fNfGRvRUFO9WfEipQxxhhjTCUjU6RmUjmINMHSxYpJWS+xUnMuD1AKrEqs\n", - "T55G8eGIlj6fb1vhmqdlrBN+jz5NsZI3xH7AOsCqilYO1g/+GzyVYxXTf7QHq4X/L1XGYvvaKkdY\n", - "XfF7sZI6f4/RWzmwWlBGiCJLWXspXzHOn8sKXKtAAePFvCCaMqeO4IfBOmirKNIvKJmPPfaYpKnr\n", - "gZ9EMjHv4vn4f9SVqDxHZQ3/l1Tleqx0+qVWtekncQ/AEo6RjW33plr1FdWUPmLNo0xEf89hEX2k\n", - "StcIn4v+gVdeeaWkRpmoVSfjPQT/wtL8SnyPPSOljKGcsefkfMZK/RtzkcvcQ9kb6E+OX+pPGzOj\n", - "t1W7eyVG0XEPiJnJ6VeuE2WTjPVcx9/+7d9KatYl0YxxPuSwImWMMcYYU8msitoD3vfy1EhOB54y\n", - "sdSxdPl/nqprrTierjkvljVRUJFUtFAu2pC/E7lBxAtP09TpwpqNFnt8SsbCT1k3+LagNFCfiad4\n", - "zsf17N+/X1J9P9I+/AxS9bYiKeWLcaC9HB9ro60yRX+SlylljaUib6IymSJGguT8LKKSBFxfabZq\n", - "5hf91dZqjHWxoiLEPOX6qCeXmi+ME+3CCo7+DIwz8y8F/QRtoxKnO2e/YK2x9plb9GXbaLLayFDW\n", - "MmNCny1atEhSs7f0Kxt/aX9yPhSk0jw9KVAjmYvMzdIIUPwu2TuZ622VQ+Z27vpRhlAGoW3dzEjq\n", - "vKx98irRX+xtKKf4FbNH4UPEvZZ+4SfRn8Mu1RszxUc1mvnFddNe/IBRYlPrCkUR1b90fViRMsYY\n", - "Y4ypZFYpUihRKCe8Z+apE58Mnv6xhHl6jj/bwtM1vhmnnHKKpMaK4CmX46esllzul5gZHWuO/ydv\n", - "UCpjeHxKLvULIPvt2rVrJTWKGIobNc56zTGCshQVmV5B2Uj5VdDvWN+MW6pCO/NnUKB4xYigCOoB\n", - "VjoKVFRI+T3nk8e8YV60zbOENZ+bf6UKMNYf6wZFkXFinTFOOSsQBQr1ocZHirWOnxZqX69+bVwr\n", - "beQac7XnUvSaAZu9bPXq1ZKaOdFvJYq9m+Pm1NPcWi6FNcZP1lCpIsXcjZG7/H9pP8Xca8zp6NPF\n", - "vEP17Vc+p5Qqz5rDn5N2Mj6MGwoTewv9wfWk1lj0E01VCIj3qFolK+6hKJq0j35FuYpqfkoR5vNE\n", - "7UWlMocVKWOMMcaYSmaVIoU1F58i49M2T5+8Z0YZKrVCcufn6ZynUs5fqnTlfFK4rmiVYE3xFJw6\n", - "TrTisHpLc51wfWTK5nj9in5iPIaV+TuC9VNq7faaGTuV34r8YzmFEusMhQUrMFptpZnu8U1jnsV8\n", - "VjlSUYFY/Vid5DvLEWsz0i4UL46HQsrnUvXhiFBifUSfqTbQFnJS5SIxU2AZM4bMPa6lrfJy8skn\n", - "S2ofMQtcF3MJX5F+KVEQ5y4qNErMoH1oUPVjxHEpvOV4wxveIKlREplbKIK5eqJcdy7vE2uBvaJf\n", - "e25uXJkPMeKZ32kv7WFNcd25SGGgH1CdmXdROcq9VShVThl/lDTa2VbJpd0PP/ywpGY/QMnNYUXK\n", - "GGOMMaaSWaVIAcpKfGpH6UDJSVkfWBm1EHGDD03bivA55YCn58cff1xS834WawbrIaUwReWjVKkA\n", - "IkSIyECRiRERvZKyylASS3OplML1EJmU80shX1Eqcqg0k3rq74xzzqpCNYh5w5jv9E+sTJ8CRQqr\n", - "r60vGNeDVcnvtJP2tLWmsRaZ31idXBf9jQqT8gXj74wb414DfdTrHKQtKBlcKxZzVJsjWMDsafRR\n", - "rWKBHyl7A2uhVuHKQT8ylrR7UH6I9Cc+PvTb7t27Wx0n5vJjrscot5iRPcK4066USsr40962VRVq\n", - "ibkFc36WqMFtfbjoR64fRar0OEQRlipgjA+R58zzlC9UKjcgeyrjE99KUaEghRUpY4wxxphKZqUi\n", - "FZ9eeTrFQs9ZVb365pBrAquEzM6llJ4fPwL8IVBSuF7qZOUozS8EMWM8ykNpFt9asNpz/gaR0npT\n", - "MfIqpwTFfEW/9Eu/1PV7r/4d5GbBKkvlFVu4cKGkxorjOqNPHpFA9GPK+qaSfFR42oKVHSONauuO\n", - "oRxhDTJOsZ1Yg7kcQzFHUy+kxiYVhQREvLJ26fsY2ZtTvKIFTh/X1jJD7UaxGXRGc+Zs9MkaFMwZ\n", - "lDzmTK52XQr2AuYk18HPlB8le1OM6E6Nd/QNYn6hZPWrpl+v1EYTonTVfp/rL92zWPvcQ5ctWyZp\n", - "qv8x6zcqUazfqGDFKNQcVqSMMcYYYyoZmSL1Az/wA63f/5c+pfaaewULfNeuXVXfL820jDVC3iys\n", - "Yq4TqysXLdj2erEWqbW3d+9eSY0VOyhq/VBK+5P+QvGqtU6htr3r16+X1Phg3X333TN+PvY7CiHz\n", - "gHXC/MCPAMUmVb+sXzmRIFU/rJTol8H1sc5YD/w/vo4ptQh6HecjifX9cv6R+FZQLQDlAn83LFp8\n", - "R1C5S/NW1daOA8aQ6wJqjtEelLRa9ZI52jZzey30C3OjNmKbvYU5xByNUWMoUygVMdqtdI+Kfof0\n", - "dz/n8CBhT4v+tdCrEllbJ5e3KcxDxm3Dhg2SmnXMXkME8gUXXCBJuu222yQ191J+lvpHW5Eyxhhj\n", - "jKlkZIpUiRrF+86YR2blypWSmvejpbXcIlhjOUWH99dEQ/E9ck9Ev4NS3xqsHzKK0ydYPbHOEfSa\n", - "9whyNc36Df2IVUYG92iVx7pTpdFzvCeP2XnxXyj1pSHzO/XIsErinOV6aD+/ozbQv219raIqEOcn\n", - "Vjj92K+oxxy9+ozlog2j9VejbqDSoQoCvhdk948Q3RbXGmOKL0zcixhrFBHGhjnLHGRNo1SheDDH\n", - "4tziOuLYcxx8p/B9Yq/ct2+fpGYNcd34huATgoLG37HQ20YADxr2Oq6PcaDd+JbRD1GZYA9lrUR1\n", - "vzTjfFs/1BRxbefU1n5B/7Hncg+jbmjuXsC85fuMy7D2nhQohazLuD63bt0qqVG3efvDXvOFL3xB\n", - "UrPe+Mn12UfKGGOMMWbAjHWGXb5ZL1tjExMTwz6tMcYYY0xrJiYmkqq8FSljjDHGmEpG5iN1pCJV\n", - "6qtUe45hqV+l54u+NRGisvDB4j126nzXX3+9pOZ9Me9/yUsUI0I4Ln4F+AnQ//gh8PSNP8ev//qv\n", - "z3hdxhhjzCsNK1LGGGOMMZWMNLM5nvFLly6V1L5OEhAhQyRLbRTfsMjljkGxQplKKVJAZEGMMEjl\n", - "JiHiJZVFtzQnijHGGPNKx4qUMcYYY0wlI1WkyPWRyqYb8ynxO3mBHn74YUlNfqF+5eQ444wzus77\n", - "d3/3dz0dD18lcpHkAiWpqUal6lpQ/GoryBtjjDFmZqxIGWOMMcZUMlJFCr7+9a93/Y6SErOnolyV\n", - "ZqOthVpt1J+qheg4ssJyPUTVkWWVCuZkOeZ6e61bZCXKGGOMGSxWpIwxxhhjKpkVihRRd9RBQkmh\n", - "PlQpvdaJIkoOUJRi/Z4c+DbhG0VepqgwoVShQFH5uFAhQgAACFxJREFUmuhF6l/RDuoAOarOGGOM\n", - "mR1YkTLGGGOMqWRkitRxxx03qSChzJBf6b/+67+m/Q6fW7hwoSTpiSee6PoeGdJzVeZTcF5+1ipc\n", - "sXI7v8dK2fh6oVwBitw3vvENSU30YKxcPihOPvlkSU0UZCqq0hhjjHmlY0XKGGOMMaaSkSlSxx9/\n", - "/KRCE6P0UqCUUFMO3yoUqV5r9RFN1ysvvPCCpEZZQpGKpDKSA/mmyHSe+ly/ibX66GdjjDHGdGNF\n", - "yhhjjDGmkpEpUkf6C+HbhG8S0WtAJvMY5UZGcxiWYpMj5m/qNcouZmw/7rjjejpeJGZAj8rc2NhY\n", - "X89njDHGHCtYkTLGGGOMqWRkitSrXvWqKbX2UJ4iKCb/8R//IanxOcI3Csi39G//9m99aSNKTK42\n", - "Hj5bgE9RVMx6heNynREUO/o1Rvmh/KHorVq1quvz5K8yxhhjTBlWpIwxxhhjKhmZIvVjP/Zjk1F2\n", - "KDooT7GWHn9H4Yk+VEDepRSvec1rJJXXsMspURAzokcfKRQ0ou9q80Fx/TFP1qte9SpJTZQd58Nn\n", - "DAULBQ9li+v793//d0mNYgXx88YYY4zpxoqUMcYYY0wlI1OkDh48OOnLhOKUUoDwVULR4WckpyCh\n", - "HBEdiDKEgpPKqJ5j/vz5Xb+j5KCw/eiP/qikRvnhek466SRJTVRfadRhVLR++qd/WlKjhKHooTCd\n", - "eOKJXec5fPiwpEaZo10pavvFGGOMOdaxImWMMcYYU8nIFKkjI+u++93vzvhZas3hU5VTUCIoXkS1\n", - "zZs3r+t3lBp8kI4//nhJjfJDtCDgk7RgwQJJ0imnnDLteVGIyHQewdeLaMXaPFhPP/20pKmZ3fn9\n", - "m9/8ZtVxjTHGGDMzVqSMMcYYYyoZmSJ1JETTpRSggwcPFh0nlb8JH6YlS5ZIanypfviHf1hSo9ig\n", - "NNGOZ555pqs9P/ETPyFJGh8f7/rckVna29BWWUvRa43BCD5d+HL1Ky+XKePQoUNauHDhqJth/h+P\n", - "x+zBYzG78Hi8jBUpY2YZTz311KibYI7A4zF78FjMLjweLzMyRWrjxo0655xzhnKuyy67bMa/E/UW\n", - "Oeuss6rONzExUfW9Wno939atW4c2FsYYY8yxhBUpY4wxxphKxjql6bv7yM/+7M/qS1/60rBPa4wx\n", - "xhjTmo0bN+r++++f9m8jeZAyxhhjjDkW8Ks9Y4wxxphK/CBljDHGGFPJ0B+ktmzZomXLlmnJkiX6\n", - "6Ec/OuzTG72ckX3NmjVat26dTj/9dEnSv/zLv+i8887T0qVLdf755zt31ID4lV/5Fc2bN0+rV6+e\n", - "/L+Z+v6GG27QkiVLtGzZMt17772jaPIxzXTjMTExofnz52vdunVat26d7rnnnsm/eTwGyzPPPKNz\n", - "zjlHK1eu1KpVq/SJT3xCktfIKEiNhdfHNHSGyH//9393Fi1a1Dl06FDnpZde6oyPj3f2798/zCaY\n", - "TqezYMGCzgsvvND1f+9///s7H/3oRzudTqfz+7//+51rr712FE075nnggQc6u3fv7qxatWry/1J9\n", - "v2/fvs74+HjnpZde6hw6dKizaNGizv/8z/+MpN3HKtONx8TEROcP//APp3zW4zF4Dh8+3NmzZ0+n\n", - "0+l0vvOd73SWLl3a2b9/v9fICEiNhdfHVIaqSO3cuVOLFy/WggULNGfOHF166aW64447htkE8/90\n", - "QozBnXfeqSuuuEKSdMUVV+j2228fRbOOed74xjdO1nKEVN/fcccdevvb3645c+ZowYIFWrx4sXbu\n", - "3Dn0Nh/LTDce0tT1IXk8hsGJJ56otWvXSpLmzp2r5cuX67nnnvMaGQGpsZC8PiJDfZB67rnn9JM/\n", - "+ZOTv8+fP39yYMzwGBsb07nnnqv169fr05/+tCTpW9/61mQx53nz5ulb3/rWKJv4iiLV988///xk\n", - "eSPJ62WY3HzzzRofH9fmzZsnXyN5PIbLU089pT179uiMM87wGhkxjMWZZ54pyesjMtQHKWq3mdGy\n", - "Y8cO7dmzR/fcc4/++I//WNu2bev6+9jYmMdqROT63uMyeN797nfr0KFDeuSRR3TSSSfp6quvTn7W\n", - "4zEYXnzxRW3atEk33XSTjjvuuK6/eY0MlxdffFGXXHKJbrrpJs2dO9frYxqG+iD12te+drIQsPSy\n", - "M9uRT7BmOJx00kmSXi4WffHFF2vnzp2aN2/eZPHmw4cP64QTThhlE19RpPo+rpdnn31Wr33ta0fS\n", - "xlcSJ5xwwuTN+l3vetfk6wmPx3D4/ve/r02bNukd73iHLrroIkleI6OCsbj88ssnx8LrYypDfZBa\n", - "v369Dhw4oKeeekovvfSSPv/5z+vCCy8cZhNe8Xz3u9/Vd77zHUnSf/7nf+ree+/V6tWrdeGFF+rW\n", - "W2+VJN16662Ti8YMnlTfX3jhhfrc5z6nl156SYcOHdKBAwcmoyzN4Dh8+PDkv7/4xS9ORvR5PAZP\n", - "p9PR5s2btWLFCv3mb/7m5P97jQyf1Fh4fUzDsL3b77777s7SpUs7ixYt6lx//fXDPv0rnoMHD3bG\n", - "x8c74+PjnZUrV06OwQsvvNB585vf3FmyZEnnvPPO6/zrv/7riFt6bHLppZd2TjrppM6cOXM68+fP\n", - "73z2s5+dse8/8pGPdBYtWtQ59dRTO1u2bBlhy49N4njccsstnXe84x2d1atXd9asWdN561vf2vnm\n", - "N785+XmPx2DZtm1bZ2xsrDM+Pt5Zu3ZtZ+3atZ177rnHa2QETDcWd999t9fHNLhEjDHGGGNMJc5s\n", - "bowxxhhTiR+kjDHGGGMq8YOUMcYYY0wlfpAyxhhjjKnED1LGGGOMMZX4QcoYY4wxphI/SBljjDHG\n", - "VOIHKWOMMcaYSv4PwNFhvU7XHUcAAAAASUVORK5CYII=\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "feat = net.blobs['conv3'].data[0]\n", - "vis_square(feat, padval=0.5)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The fourth layer output, `conv4` (rectified, all 384 channels)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXmwZVV1/78vgBE1JkGQoZumu2nophtsVJxBoQwmpFJE\n", - "qhRRUziVQzRxLMVgJbwCkcYBE0sxZcpYRKscq+KQVFAxCAiFLcjYzdDN0EwNOMUkmkRRfn/4+7zT\n", - "9/ve7r3PPufce1+zPv/ceu/ee/Y5e6+971nfs9baMw8//PDDCoIgCIIgCFrzW5M+gSAIgiAIgsVK\n", - "3EgFQRAEQRBUEjdSQRAEQRAElcSNVBAEQRAEQSVxIxUEQRAEQVBJ3EgFQRAEQRBUMsiN1IUXXqg1\n", - "a9bokEMO0bnnnjtEE0EQBEEQBBNnpu86Ur/61a+0evVqXXTRRVqyZIme9rSn6bOf/awOO+ywPpsJ\n", - "giAIgiCYOL0rUhs3btSqVau0fPly7bHHHjrllFP0la98pe9mgiAIgiAIJk7vN1L33nuvDjzwwLm/\n", - "ly5dqnvvvbfvZoIgCIIgCCbO7n0fcGZmppfPBEEQBEEQTAMHHXSQ7rzzzgXf6/1GasmSJbr77rvn\n", - "/r777ru1dOnSou8+/vGPlyT97//+ryTpF7/4hSTp937v9yRJe+65pyTpP/7jPyRJv/M7vyNJ+q3f\n", - "+o2w9uMf/3jke7OzsyOvOTjef/3XfxV93vH2Dj74YEnSbbfdVnW8FPvss48k6U1vetNIe23hhrY0\n", - "TK60P9evXy9Jc3Fxn/vc50beX758uSRp+/btkqT/+7//69ReX9DO2WefLamxR/oJ+/r1r3/da3vj\n", - "vr5ce7vv/ptl4bGPfawk6ac//enI+6V24+2l5tehhx4qSVq5cqUk6corrxw5j9WrV0uSNm3aJKmZ\n", - "/49+9KMlSXvssYck6R3veIc+8pGPjLSFbd1///0jbT7xiU8cuYYf/OAHkpq1hu/9+te/1kMPPaS9\n", - "99575Lh/9md/Jkn68Ic/LGl+Hz396U8fObfLL79cUrNWcc3//d//LUl68MEHJTVrF+3xesopp0ia\n", - "HlvZb7/9JM3v1xzM/R/96EeSGluY1FzYsGGDpOY353GPe5ykZlwYr2XLlklS8ofU+e3f/m1J0l57\n", - "7SVJev3rXz/SbgrmFr91P//5z4vac4bqT86L62MuTutaRn9yvowz+HineN7znqdLLrkk+X7vj/aO\n", - "OuoobdmyRXfeead+8Ytf6POf/7xOPPHEvpsJgiAIgiAYnOOOO26n7/euSO2+++766Ec/qj/8wz/U\n", - "r371K73mNa9JZuzh3fE+HvBPfvITSdJDDz008nm8R/6///77j7yicJR6Dc5jHvMYSfM9ZpQJlIjc\n", - "3Sv0rUQB3jPkFAK8KveSfvazn0lqvIpSUAp8fACv5fnPf74k6fbbb5fUeO377ruvpPpxqmW33XaT\n", - "9JvM0p1BP6IOoCrUKlEoJ4zT//zP/1QdZ9yk7Jx5+5//+Z+tjpdSelE1mMdr1qyR1PQb9ul2ine5\n", - "Y6gAY8TYYeMOClDqHN1GmEOcE6TCFPg+5wF4wJy7K1HAXEE5K4W5yXmWrlVtaatEwaMe9ShJ9ar/\n", - "0Hh/YU9t1yoUTX6TSmHtYdy9XdbwlIo/NMyD1No/bXC+/Obdd999I+/ztOzmm2/u1E7vN1KSdMIJ\n", - "J+iEE04Y4tBBEARBEARTwyA3UqXgtXHXjxLF83NXTn75y19Kkn74wx9KapQPYoZySkOOBx54QFJz\n", - "F4sSccABB0hqvJWhvLxacrEqeDEobiha7gWXkvNGOP4VV1whqfGuf//3f1+StHnz5lbt4cXWni8Q\n", - "/4J9peD6+vKa/bn8tJMb37ZKVA7mOYoUqgoKoiuwDnYlNWsJawa2wyue/j333LPTY7HGALEqqObg\n", - "c+93f/d3JTVrB7Cm8HnWmpRNM2fbJuYwdh4jRr90XSNr4Troh2mhtH/pT2yV3xx+C7oqGg5xxrSL\n", - "3aLuTwrmFXNz2sHeXYmCvsZtuqw6CIIgCIJgETExRerxj3/8nNflMTcoBjyHR4lyuNskdoK7ZJSX\n", - "WvDe8Ob69jbGDTE544rNQcn50pe+NPJ3LV2VKKiNK2ib3TjtoMzRr/QL8wkv+AlPeIKkZl7yuZxC\n", - "5F4+ynHK/pjnxIPwOeJ8aB81w2PVdsyY49xRlBgz1gbWmtQ5oTi5IkUbruh4DBZ96msW11I6F1A6\n", - "am2WsTvooIMkNWOWi9vMKUb0I8obmaw5GIcdM7qngdI1kXHjddu2bZKGU2awM283aEfXpxmlCmoo\n", - "UkEQBEEQBJVMVJHCs8RLJJaktHYGGRHEI6TiE3LgLS62WJa+yGWCtFX48NKIN3Fviloy487a85oi\n", - "OW+fbE2uhxi+ru1PWtnKZWl6XA0KFipJTpHy68t5g8y7a665RlKjQHEcxoH4FFeLdlSFmMt81zMl\n", - "WTOwaWJdUEpQGlKksrqAdliDmAOcxy233CKpXGHAVttCH6K8EX9GjE3KBlOZqR63hqffllQW5bTD\n", - "eLrSOKmYs1JQWBdLv3sGflewW7LzGC/GkTU9pUyWZmqHIhUEQRAEQVDJxBSphx56aO5uD4/UPc0c\n", - "fJ/n9HhLqZiqFHixeKnctXq14hR4fYsVj0HBe6Yf8BJKSdXc4W9q6YwblJHSTB3O173w2uftHGfa\n", - "a7BwfcxH1JqUioHXx3x0L67Ua+c4gDLmOxnsDDIKuQYfK45JDBFzvlYlRKlwdZOxRs1DEWg79iXX\n", - "vBCsgaj7Hv/WNvOS8+Z1sdRC6wvsBBvNZf72BWuVr8GpLLTU9/umbyXOFc++wP75LWeeonLn4jdL\n", - "CUUqCIIgCIKgkokpUr/+9a/nvMCuMSN4V147pRQUMWKseK6MAsHx8fJScRGTxp+Hl8bk5LwL9+pz\n", - "x+XznA93/yhV9957707bG4q2doEXw/V2VZL62qOP8+H1wAMPlJSP72kL8yI1zl4bKPe5nB3Svymv\n", - "tKT/cvFbgI22zchFYQKUCmzL/2bN8IzEHKihrtKVgqfN3GYs28aPpphUZe1JkasdmMoorcX3WmQt\n", - "LbVvmLaahw726Ipf37gCi/32FRcdilQQBEEQBEElE1Ok9txzzzlvDY81VcMlB8oRnmxbhYjzwEvF\n", - "M/a7ZZSevuoa9Q1386kMk1q89ktOYSCmhT312DkdhWfaasmk6Nvr7ttbxS67xkGkvGnPqk3tfZmb\n", - "D8zrnHfsqo6Tmtc11bJza0wqdsLVMu8zv1Y83raetscktYW5Rl+icBFrw3nVZnPtKopUacZ2TrXn\n", - "aUhpXG0O39+TSvipivyLFdYunloMpUh5fC7zu6/f8lCkgiAIgiAIKpmYIvXwww/PeTV4ttzVt33e\n", - "zD5EeF9tFSnu/vE2OS+PRelLURgK+rEvJQpWrlw58neuH2jfxxWlqq+98x5pYJ8offRf15gzVBTm\n", - "jasgXRUvvL+cIoXXyHzGXnhN2V3NvKQmlVfmpm5Tag3xueUZqvxNtfYVK1ZIklavXi1JevDBByXl\n", - "+4IxqJ0jqL7r1q2T1Hj6d9xxh6TudYUmXQutL/pS1vquPI6djDtLcNx4dm3f+3gC88kz0vv6TQ9F\n", - "KgiCIAiCoJKJKVK/+tWv5rw+nitz14hiURpRf8ghh0hqvKS77rpr5H2O50oJsB8VXiUePl7GtMcD\n", - "4PGvWbNGUuO98H+8mq1bt0pqvGH+T/VlnlPTn7zPcaFUMaTfUBjoXzKf8LqCMuhvr/PUVV3wGEXs\n", - "nva6Kpyl6oXH86DAlVaiXwjPZOVYVDrmfWyaGKItW7ZIaubSqlWrJDVrBbBm+XFcxWMN4tpyihTf\n", - "71pzjXao4N42/nTaScXvldJVWRtKXUcxwW6nJTN8KJjbfcWYOfQf48S45fo19toLgiAIgiAYmIkp\n", - "Uo9+9KPnlIr99ttPUlMjo1SJwlsjK4wqpniPQIxO7jkzd8OLzWt79rOfLalRfvDS8L65q8Y7JeYE\n", - "BQrlwffGYxz43rHHHitpvnKR2s8JL4M4FPq/6551tXCeeCV9x5INDSpFaZxNCld4UnEJeG3MM+YX\n", - "ypHHF6VIeevYJfPzgAMOGGmX88Q+8dJREVB3qKO1I6iofu7YvFf4PuywwyQ1aun1118/cjy+7x4q\n", - "x+Ec+ZsYLFQ1YpN8zqCkuNrGtZVWsE7hNfb6qiM1bXi217h2Dxg6zrN0jkHt3oyTZui1GAWatYv5\n", - "ym9+qj4X8zhHKFJBEARBEASVTEyRWrZs2ZxXdvDBB0tqPGyUEbw47sr9rvW4446TJB155JEj33ev\n", - "kb/xTvF4aR/vj+PzOY5HrBHeLB4x3qbXveH/KESpnay9MnTt/kV8b/PmzZKkm266SVJznbzP82Dq\n", - "ENEuShFKnNfV4npRpLgu+sUrynsMFePoe92VxiegMBLj1Ra8NOJfvI7VULVL+ob+RFGspTQLD/WC\n", - "cUOhbOuFr127VlKj6gB2gp2yswB2Qfte8whVh8/xfam5tlTFcubmEUccIanJqkOJwlb9XFGGqOfz\n", - "nOc8R5L0tKc9TZK0adMmSc0YcW6sXfyf+ENfY2688caR9phbKRWd62BN8rWP6yI2iv8ffvjhkpo1\n", - "D0+cftuxL6cZ5iz9yFoOpZmsrA385gD9gCJBe6zlvHqcKWtr20zX0t8C7MJrLvJ/VN2h8N9C5gPQ\n", - "vq8VfI95wfueGc8a4E9T6GffvzWH/zb7b1NOwStV/UORCoIgCIIgqGTm4QkUBJmZmdHs7Oy4mw2C\n", - "IAiCIGjN7Oxs8ilKKFJBEARBEASVTCw4ZByKFG187GMfk9R+5+za9j7+8Y9Lmv/8GIhvqI2J4rnv\n", - "u971LknSmWeeKampeE2tG55jX3rppZKa59JPeMITJEnHHHOMJOmyyy6T1MRjEC9CNiXn++IXv1iS\n", - "dOGFF0qSrrrqKknNc3HPjAL+z/Nyrpv/E5N16KGHSmriG975zndKStvK8uXLR66LatLge/ylapQQ\n", - "B/HmN79ZknTeeeeNnC/P52uz5Hjuz3UTT/Ga17xGknT++edLarLxUnW6vN4T50MsEbFqqUwf+vGs\n", - "s86SVF5LpRbae//73y+psQvGifgdvDzPliV+getOZfMS+/b6179+bEo37bz3ve+V1GSJYUucq8da\n", - "EaPEHN64cePI+4whtkfcIe3lrq/trhAOMSjvfve7JUkf/OAHJc2PH8XmmFNuQ7k97DgO8Zannnqq\n", - "pKY/ybLi+okL9HawIWzF96LD5nyPxLe85S2SpE996lOSpG3bti14nn3BuF188cWS5q/9zAniQFkz\n", - "iMFjrjNHWKO5bvqZcfmjP/ojSc1axhxiHLFL4hcZD7dH1mRinOgnxp2Yv5e97GUj11kK8wV7L11j\n", - "S+dDX2Tn3VjOIgiCIAiCYBdkcaQrdaTvfZBy4DV51V28Re7Ceb3lllskNd4EXkbq7ty9XLxPvFw8\n", - "dP7vNVVQnr785S8veHy8HTJ/POvwmmuuGTmuV5KvrcN16623tvo8/ZCqkI4CmVNcPFOp7/2eXAnz\n", - "rFKv54VC4xlb/N/tAu/W63vxeR9/z+IcGsbJ7TanEJdWMk9lxY4DH0v63K8VyM5LVSzH88cm21Zz\n", - "Zw1IrR05xcoVJD9O6fnkagGmVGSvZs/nUraasyEUGBQyj3HxDN6h4SkFayxrpZ8Ha8ZFF1204HGw\n", - "D1R51grmNopUbi3zDHZANX/yk58sqclK9Yzhrr+tbetkTSuhSAVBEARBEFTyiFCkSiul94XXBAG8\n", - "QO7CUXz8e159GC+T5+YpD9zr6uCN4F2UxogRx0EslVdXxnvBO0V588rTbSFeonTvuJx3XKq4+Ofo\n", - "Z+wGr9a9+No94Dxeg/Y9fqEUzguvFoULL7x2T8Oh9hED4oGwszvvvLPqOJOsA+Z9U9pXrvQwxxk7\n", - "VMTcbgxOau5wfI9tmhRcn6ulzCXWEuZYaveEUlJV/GtjyWpB0eG6vBZh6VrCbwVPNfhe2zhgzgeF\n", - "lNg06mGxhrhyCEPHHS8WQpEKgiAIgiCo5BGhSOUg8+OZz3ympEYRwBu89tprd/p94hog5+25p49i\n", - "hCJDzBSkYkyc22+/feR88N7wGvCCUFxSSgXP7fFCPKPFFRWuB+8yFZuVw3fozsF1dPWuXTnkelCI\n", - "vKI+XtqSJUskNeoC9uLXzfFTFd1LqzCXgtfdNdYLxYhXYuH68uKJr3DFte141uyrRkYqWUmorrXV\n", - "8yGnmKCs0IeontgU6lrt2KXU4FKVs23l6KFgbWLu1cbz8T36uVYtZ03lNwLIwiuFNZU1uTZzGzvy\n", - "NdrXshz0L/3DvECh2rJli6T0nBzXnobTTihSQRAEQRAElSxKRQoPua9sPI7H/lnsw8Vd/hvf+Mad\n", - "fr+tF4DXh7fE3f5PfvKTVsdJQb/48XiOnou74LpRCPz63ItCQfJ4BsDbyXnZpeOJgoGCR8xZbZ0n\n", - "98JTNYCA66N/UDTJliTDJRVb1TVbjoyf2j33SmsNYSd48SinbeN2cqTqrQ0Jnjxj3FemZq5GHLaL\n", - "6okywVz1bLUUKCTMvb5qglGLbtLQT6nYHNRdYspyKmbXDTzoV17ZH7ZtTUBUbJTH2vpVzEVeUVRZ\n", - "kyC3r6nHgfr+lqjl/N/V+b7ouqaVQjwm/cS86/rbG4pUEARBEARBJVOtSOE5c7eK99h3pgWxRV//\n", - "+tclNTFCpbE6bTNJ+roLdvDiyLjg/F3pyXlPZAVy905mCPh5czyel9Muf9cqRSnwrlCSuN7adlxB\n", - "y/UP3r9nWHm9sBSemdM2O66tAuq0nT9UL6Zf+H7f9jsJ+q4ZhlKEcuG2lMtyYq6iNKTOD5tBcWCN\n", - "ROnwOV+qnHgGZNdK6bV4bTeHNWDc2YdXXnnlyGtbUPxqsw8B5QaFi7XaySlxqMv8trIWEiPFmsRa\n", - "h133vUXv0EoUeOZ8X0+1QpEKgiAIgiCoZKoVKe4e8c6IHxiqkjH7DPG8mZgX7sb79l5TUK22bV0d\n", - "vGGe/+L14HW0fb5N/3sMkXsj7u3STluvyyvBp8BL9gryDrFvxDChBrgX4gpPrpYL3gyvnC9Kpvez\n", - "e/XubaMklipS46oG/IxnPENSo0h9+9vfljScEsV4eZxQ34rmkDAHarOxmDMphQGwYWwL20nN8dLz\n", - "cRssVaLYb/NZz3qWpCa26fLLLy/6voPStquB8pObwyhCzAXswnc9YM1hDfTYutLYJtZS1nLWQP7m\n", - "ONhbrX1PmqHWrlCkgiAIgiAIKplqRQq4G09lcPQFygLenseEpMg9z29L7V0z54/3wfmjKLVVpPBC\n", - "cgqNeym1z/9La5IwHrSTihnieT+KD/3gipR74V6pPXWerj649wbYB+16TFZb+/F2UhleXatBE7dw\n", - "1VVXSZLuueeequOUQr9zfXjlXF+fNWs8lgkbIt6uthp8110UUvsjOswBXrmOtlX2ndrzx8bIQuvq\n", - "+e+qihT95Cor18vTBHaXoB+J4/U9GJmjvjsClK792L/HIXtFfI7XNcZrVyMUqSAIgiAIgkoWhSI1\n", - "tBIFrmygIOS8w76rAddmonj2F15I7V5peCG566fdofc05Hzw2vGeqCflCgxeGupCKmPKvTWvPk2c\n", - "Al4k//c4Ao5DfxHz44pU6rpKKc3A6joeVNjvW3FNgQLF9WG3jEefGVooUihQZD/RZq0i1TWGBFWu\n", - "bVaUq7O1WVW1dYKYi9iM2x5jWxrv1lVZc4beN7IUj+8Exos1gvhY/xzZmfSP7yGIggSldsh5+VrP\n", - "XEQxCyVqYUKRCoIgCIIgqGRRKFJtq8fWwt0/WV4oBbnn/V3r+nTFFQO8FLyI0lgnJ5cJBF5HqpZc\n", - "zRr+z/kQH0CVYX9+X6pgpCqbc13uTeM9ej0r+tmzD90LTsVHQK4fuP6c6tDXfMHL5bpK921rC8dF\n", - "JaJdXtvuxbgz8OCZO4xJ2zgw3x+QDF+upe2cQxkjUzlXd8rpWt+nVn3EJlFMOA/PKizF4whr4Tgr\n", - "VqyQNHycXw7U7RTMWTLT161bJ6mxL34LUVQZL+wQ+4NS+0ut3fx/XHWeFiuhSAVBEARBEFSyKBSp\n", - "cdWs4O4ejxhFgLpSpeT2N3IOOuggSc2+Rm2VHbxBvFcUGa8w3pbrr7++6HPuPdbu94UXnqoLheKD\n", - "PTBejFOtnXiMEl4cx03F6NEeMVruTaa8QVf4XHlC4UopP66C9F1l2BmXN0ptnKVLl0pqlOG2Ow2U\n", - "wJxgbJkzbSsdY7OMBa+1WWesAaksrBy+j2dbPMamLaxBnuVV2q/UozrwwAMlNePCGnPbbbdJKrd5\n", - "vo8S1XUvwq6Uxi2iXDEHWBOJQeO6fG6mdp0A1g4UWfqR8aKfOU/+TtW9QiF7pBOKVBAEQRAEQSWL\n", - "QpHqCl5Rzhugojif526eu/KUZ+4Vz9sqBG3jIBxvb6gYFvBK7/zNc3v6OXddXnUXhcmvx+tB8Xni\n", - "L+644w5J82OiSvcJc6+/VNnie3jbtZXvXfHMjd+uHq9w9913S2q83bYV/muo3XMLBQm67knHNbdV\n", - "kbH1rvWXiAfsCiot6uK1114rKR+zw1xgDUDdrc1mhKHmTGnlcChd67lelDTsIZc1l+sfztd3D+B7\n", - "9BP2hD2gCjtkJvdNKi4aRW3aCEUqCIIgCIKgkqlWpFKKglclzpHzFrirxptDWfAMiZRX4+fnmS8c\n", - "Fy8A78Jjsfbaa6+R9tj7z70MdhBPQXyB1xjJKXJ4H3iRKHObN28e+Zx7lXiNqfHAu0JR8popfhzH\n", - "Y5bwUvg/7dLPbWv5eFwB+5xhF/QH4+bZerTH+OH1ET/D5zlfH0/PCuQ4KFNch2fP8X/+5nzwHrEv\n", - "z1Tab7/9JDX9hl1yHcwX91ZdKeP4ZGpxvK57AfJ92p3m2jWM1QMPPCCp2Z8T2+HceT+lNK1Zs0aS\n", - "dMQRR0hqbJmK1sCaxBqADbgyksoYdTgOx+0rW47zYs1sm73oa0GfVe37pO2uEcy13G8XazbHJVaK\n", - "rM5SFXzZsmWSmrXT1X3sDLvluLRLzJqvGYznoYceOtIe8wG7Y03z2nyp6+e81q5dK2m+EslvYwq+\n", - "T39hf7kMbn4z+e1GaX7qU5+60+9BKFJBEARBEASVzDw8dMrPQo3OzGh2dnbczQZBEARBELRmdnY2\n", - "GYMWilQQBEEQBEElE4uRmp2dnXue2jWmwiuLE7Px5je/WZL0iU98YuR9nodSt2br1q0j71NNlrtP\n", - "jxHieTKZKTxXPvXUUyVJ//RP/ySpyTYixobz5P88Xz/66KMlNc+VL7300gWvk+e3PP997WtfK0n6\n", - "53/+Z0nzY2noV7++E044YeT97373uyPfI7aH+AliY0455RRJ0nnnnScp/3ye75fGSRA/QL+ffvrp\n", - "kqQvfelLkprn6zzXJ66DOBKOf9hhh0lq+pf+5vNcJ9fFeb7whS+UJJ155pkj7eXweJVUhouDKptT\n", - "Z7E34hb8+LyfijHz9rAXjuPxNcRGrVq1SlITr8B82bZt28jf1GIie5N4lre//e2SpI997GOS5o8/\n", - "45iLX+Bz2D92wt/Y4emnnz53bcRW8FnawOaJ2fD9KMkK4pUYD8aWOXzyySdLkj760Y9Kmj8mnBu2\n", - "QR+zhx+xHsTjka3mc4oYl1e/+tWS8rbifVW7Zx3tcH2+fyW7CTCHeD322GMlNf1JLTquy2NjnvOc\n", - "50iSjjvuOEnSWWedJSkd37hy5cqR6/KsydS4pq7v7LPPljR/t4K2NemIiWOcaZfjnHbaaSPtDg3t\n", - "tF3LHN+lIdfeuK+vtD3mMxXuWbuIj83tAZlrJxSpIAiCIAiCSiaatddViQK/2/YsH7wXvBTuPlN7\n", - "6G3atGmn7eF90Y63h8fOeeE1eY0XPP+LLrpop+0BXo57YShweMucH/93qLvk/U8WFooX3rJnfXn2\n", - "X8prIVMpBe0xDoyT1yZhvFCWyCRBAXFvorQiewqum5ovqAqoCF7XCMUt1d9Qu2ckakqq4nvb6tdc\n", - "D+OFXaJcMr7YGwoe71PnCeXSs2hddaA/UW49y5D2UuqJqwWoLSjCO36Psa8N/cypeg6qOh6uZxcx\n", - "5tgItkv2FWObqh3Wtr4VY/nc5z5XkvTNb35z5P22NphSV6kw7nzrW9+S1IyNr1XOJZdcIqlRpHLn\n", - "RX9wHdgCWWXY5K233rrT40DbuZM7r2kjp0Rhp/R7n7sHjIPSOl6uerMGMl9zilSOUKSCIAiCIAgq\n", - "meo6UrW4Z4u3wN02XqffxebubvF+iElBAcrdzXbdK9A9eG/PY4RQGlL7Zt18880L/h/vGqWH/nKv\n", - "1L2WtjVe6GePP0kdj+fb9AN1l/AqUteTgu9hF75juntxeC2p66TfcwpcrR3kKp2XxmQB3pnvyehK\n", - "I/1z8cUXL3gcPo/deByNfw7lkfHnlf7zemt+PpwnSirf31ENwMMure6fmvNcE33l+zsCY+4KGNeQ\n", - "qhFGuyhVXmMOUipkCmyXWCyUIdYCYohyqnstXGeth496icKXep/+IlaL8bvrrrskldcYRBXn8/50\n", - "gfhW3vfzQglDvR7XvrB9wT6v9ANPU7zCvj+VmBba9jcV9sHjq2sJRSoIgiAIgqCSXVKRclxBScVm\n", - "5Z6z4kW69+Leb99eicc+OZ5t5d5uKSheeF201/au3fdp8kyk3I7w7pUTe4QSiHJRu0chXmYqzsMV\n", - "TVdSFjvErXgV7LZ4plLKTnyHAuzKd45HfeG4qUr8HGeh+Yp6yZzns6lYkdScxwZ8Lrt6mVJeaA8l\n", - "iJgorjGVeekZtrUe83XXXTfyN8pJTjWdNF652pU9+hWFhLUYRZD+SsVt+l6CfN6VRuyC/Vf5HO36\n", - "HnipNd9tfNpwdd/n6JYtWyZzYoV03dvSM8FrYytDkQqCIAiCIKjkEaFItQXvBOUERQUFCq+J98ly\n", - "y9E2Y8b3bAPPNsRL5nxQatruUYYXjzeeymrMwV1+KgMkl+HiKgFZhnjTpftVpSDuJeWFuMrA+dRm\n", - "+JTWYml7nNRelDl8n65aL4z4G84jVVcMVcaVJO9P/i5VGhcaD86F19o+Z+7gsfv+isDcdIWJ76P+\n", - "EYviMTXMEVdE+oZaX33Tdt/THB6DxFpEbBe2m4qhovaZ1wkCn9v87ftgYqvYEWs8Sg1xqbn4xGmP\n", - "mWJ+YNfkKbm1AAAgAElEQVTMVTJzp3mfyz5JxWWWEopUEARBEARBJY8IRQrlAe8J74+7bTxbj4FJ\n", - "edh4LcTauMJCBgTeCHEbZOzgHVLNOAXnxfc5rsc5cN5cZ20tEM7Ha9zUKjG1d/cOsV5cF16i1+Uq\n", - "hRg5V3aGgnHHm63NaHJ1pTY+AAUzV5k+B9dBbaSUqpJTKGtZKGaQsexrC1GPGfE+T2XVodCgSGFz\n", - "rgxxXNYSr1LfNs6RtQD12+cgWW6p+MC29KVE5Y6H7aAc5L5fOqdz2Z0bN26U1FSYHxeMH/ZVW6E+\n", - "B2uKZ+4yf0rrNC12uv5WhSIVBEEQBEFQyUQVqb5iR3J4HSDusvk/Sg+veJ2p6rg8fyejw+9mPRbK\n", - "MwPw3Hke7ftiuVeG4oW36pW/eR8vzL029yZ8rzkgboPrIj6krVfcN64U8jf9xnWXem1eu2fo+BTi\n", - "D8g+LK26PBTYJfZfW3GdCu/Mq5SddI0TYXxc0dqZl9yXB+1zxOdmqarH94itcVCdmdsoUm2VCK47\n", - "1efUYUJtbluDbFKUKk2shb62ptTQnO2ztqPgjSvmifMmBo/z4LW0TloOsg9ZC333AX4TsZNdXZmq\n", - "JRSpIAiCIAiCSiaqSKWq+XYlVdHbn7OjEHGXz9146fkQ/+DeAX/7XmZ4U3juXk8nFW+B15val4v4\n", - "C9rJxeCkYou8fZQUr+0yNF7rhfHkuvDa8Y5Q/Eq9dz6Pl+uKYteaIg5KH2rApPF+6uplY38pb5Xx\n", - "bJtlSCwXGVOoOb6f3Y4qkZ9D32Pp9KUMUFG6bSXzFLlYrlys0bTB+OXi7HwNz30+Z/veT+NSpLBp\n", - "zn+odvktIj4WtR97Yc4y10KRWphQpIIgCIIgCCqZqCI1VI2KlJfoVWbxVrnL5q681HtFyfA4CdrH\n", - "i6Adj80Cfy7t4F3yOd/JmvMv9WZTmTHUBaI9YnrGjfeP7/Tu2Ze8X5oNRz/xPVcwUzVFUrFlOTyT\n", - "atKUZqiUqjnEcdCvqCtAf7oilYtPQZHyGj+AUsX+atL8udFViUJFTGX29oXvTtAVHzsyR4l1QU1f\n", - "bLgt+VzkevtSCofKlitlXAoY/UrGNvaDCtw1w3dXJxSpIAiCIAiCSh4RdaSoistzczxiVwpKvQ8U\n", - "ERQbj0dAKfHn3K5MOanYLNrj1etWuULj7XmcADFGeDt4w16BOrfn2VC4N4n36c/nUUAY31LIkGLc\n", - "/fsoLGROEStGLRnG1ZWXFE960pMkNf2Zqso8LrAXV4SxZ+wTO0idL59HGSIWytUOjuP27RXqXT3K\n", - "1d0a0lunj6iM7Zm3Q7Xn11oby+R9+eCDD0pavDEu9H9tDbZg5zB3eSpBP3sl/2BhQpEKgiAIgiCo\n", - "5BGhSOHV4YGjPNXebeNB+w7ggKfO5/CcUUDaxm2QFZWqicLO3XgRrrg5nB/ngbeK8kD1ZfZbGrrO\n", - "l+PjguJBDBtxMFxnW0XKFRau//jjj5ckrV+/XtL8/sZb4+9SRYr4FFf+JgVVtF2RxC68vhvni0KH\n", - "3Xj9Lezd7SVlP57VynGZr3jJ2L+zUJxPW/UUJYi2+X4qjnCo7D/mqleSfvKTn9xrO/Rp7T6afXP0\n", - "0Ue3+nypComNsybSn7U14zgeleG3bNkiaf6cWKywOwFrHL+VPA14pFQ4Z354TckcoUgFQRAEQRBU\n", - "MlFFiliUvr0j7q4h5dF2jf1JedqueOCtdM2USe3gjjLmMS8p743MHa/X5FWOPQOqFGKQar/v2YJk\n", - "ZXl1X0iNby0oca44uaJZyr//+79Lmp74jlQmTtvzQ8njNUWqenaqxg+KGPW32tBWGei6V1zb2lgp\n", - "vP4RqlxbtdXPCwUGJSHVP+6JA0oMqiFzAzjP3JwgA9M/7zFgK1eulNTMPXZZoN4R/ZSyHZQTjoua\n", - "yv99jeQpAe8Tx4jtoY4fddRRkprxYC3n++NW7YG1lvZR71Pvc/6MJ39z/fwWs+bS39gH1+sq9q4C\n", - "a2DbtTAUqSAIgiAIgkompkitXLlyzvsh9gWvDi+Avz3GCK+Cu2qvfE1MSt9wXqm99WDt2rWSpE2b\n", - "Nklq7t6pSYPHjTfs3pBnzXksi++1l6vHhVdKf3u2GnEieJtds6G88rSfd06BTGUcjYvUXni1tVSG\n", - "VqLa7pU3bu+Z+Yi9e6V8+sdVDbdr5g3zheP0oUiWKivO0572NEmNgkLfMha8skbxvseHoc77Guhr\n", - "i481fcHnUWqYQ16Dy+eeK18eQ+S7BzipTFrGnMzL1D6JxBodc8wxkhpb4Dz4G1vIVSrnuOyN53jc\n", - "qI+TXw/nsXnzZkmNDfN0YNxzyW3fayF6LUGeCrjyh3LF9aHAsX8mT1U4rh8fpWrcGd3TSihSQRAE\n", - "QRAElcw8PIF0g5mZGc3Ozo672SAIgiAIgtbMzs4mYwxDkQqCIAiCIKhkYjFSX/ziF+eeS5NhwvNe\n", - "noeT6UFsEc/HeU7Nc3ue2/JKvMCxxx4rSVn1y6sV14p0tJNrj+fVnGdpdhvnSX/99V//tSTpk5/8\n", - "pKTmebXHY6SyBT0egufvxEswPsQ2vfKVr5SUv76+oJ2zzjpr5HxSYCe1lcNLxy8FNViIpcrFD3Rt\n", - "ry3T3h72TR0v4mO2bt068jnPCsVu3/Oe9+gTn/iEpGYMvDYVx2QtYS4ddthhI+97xiZtkkV20kkn\n", - "SZI++tGPjrRHOx7LxJrmsUasAR67w99kIL/oRS+SNLmxo5/oz9o1kn6kH+iXv/mbvxlpb2ho57LL\n", - "LpPUZJaSHbhq1SpJjR0QW3bIIYdIauY6GdPYIn/zW0SNv1NPPXWk3aGhnb/927+V1GRfspce53vt\n", - "tddKatYqxnm//faT1MQv8/9DDz1UUnP92PtznvMcSc1vkWd3em06WLNmjaQm5oz+d/g+53H66aeP\n", - "XOfQ5NoJRSoIgiAIgqCSiSlS999//1y2DXeZKcWBarIoJXfccYekJiMEL4dMBpSJHKkaMHgjtEeG\n", - "AnfNvhccd+/gtU/wVmkHxQhvBe8AhWjFihWSGi/J9/vy2jJktdF/eNW5fcE8A4a/PVtq0jt/l2aj\n", - "9VV1l/FDLcDLxAv3/kE5ZdxQxB544AFJzXhRc6W2vlaKVMX7WjhfMr7GlZlE/+Ilp6pQM29RSnfc\n", - "exIP2klltjKnbr75ZklpW2PMqMHl/8f2fAx8n0zmPmsUawTHoX2uiWy+trC2YINd6VonC7raPnOI\n", - "Na6rbXrNOGyeNdfXvlK1m+O4vYwb7Au7or/4v6vmjLPPI58n2HnpLg2pceIeIJctO6k6XaWEIhUE\n", - "QRAEQVDJxBSpPffcs7gqLDVBUvv9eK2SlBeHV4jSwN00d+V4gQceeODI+7RPdVeUHs7Hq7tSkyPl\n", - "BePteE0X7vo5j5T3416SKxL0a1/1izweoq9qzn2TUs4WUi52hscF5GKdaPe73/3ugu/TLq9dq2lj\n", - "b27vXSvng++z1RX6n+smToPzTc3/lLpD3BDn2aY/U7Eapaqnfy6l+jInWWu8kjR1lnz/TZ/zbWu6\n", - "sUZRJ8gVKdR2jztbLDB+Rx55pCTpqquu6nQ81mBXRGrXTuYi9lW65gwFMUw+l7yuVCn85qHCu2rc\n", - "di/DtjUCfTeOUlgzUzFYXQlFKgiCIAiCoJKJKVJ77733nLeFF1ZatRbw9rjbxKtIPbfFc+U43F2j\n", - "OPD/733ve5Kau3Y8X68mDK5YcF5tY0z4XCrOI4Wff+p5M9lQq1evltR4pd///veLzgvGrUThzddm\n", - "CrX1CvuKNXJyFehz0A+uwHrMXl/4jgG1uP14de9SmFeoOsSulRyHvkspUqV4X6P8ED+JjfqedX7N\n", - "rHlcE2qbq4BtbZ6xuvHGGxd8f7EqUUDcKGsYWWTEIrUd19R+jrVrXF/7xvouF/vvv7+kJqaotJo/\n", - "dshvn2e4twXFDWXHlS2vxN8XnG9tHCzzbChCkQqCIAiCIKhkYorUQw89NOd9+T5PpR6w12rhbjUV\n", - "24GH7TuD+/5YHIfzSe1/xff8bpcsQr6/ffv2kfe5u2ZHcf4mFsu9277wWJ2hlIzFRu1z93GDvXZV\n", - "tkrB7rvGxHkMU+35M984H1ScHRXHVAYjcymXyZrC9zgDr2nl+4LSZ3jyKFisGfQN32ct5PyH3qdx\n", - "seKK3rp16yRJ11133cTOqU9cRUdxazsHsVfsF7usnQccz/e9BK8flQN7z60JtSo2EMdKtiy/fV3j\n", - "VSEUqSAIgiAIgkompkj99Kc/nXvOy10yd7ulXphn7aSq7vpzYc/e8895BXX+5hWvl3bIYABillIZ\n", - "CdxV8zmq5XJeeB2lNWBKnxvj1aTqYU0rXWOkUHJS17tYvP6U19Y17ifFUPbhXmwpeOnEoTAPd4xH\n", - "ysW31caG8D2PAfG1wbPvvCIzyhQ2SU08vu+KQ20NNypPs7Zs2bJFUvssqWmDNZv+ZC2j33jakKtL\n", - "tNioVYO9kj9zxn8LS5WZu+66S1KTeesZ620VnnHF23LdKGCsGcxTYu9qCUUqCIIgCIKgkokpUlLj\n", - "veE91N6d8j28Rc+i4y4U5QiPmLtUPO9Sb81rwvhdOUpbrgbMTTfdJKl5rszdse9513dMzGJRoqCr\n", - "10Icy2K77lI8Vi9X92rcUDOJ+edxRW2zJFFgvZ5WCfRNqiZdCjxtjy3xa/A1iM+ThcXnyRYjQzcV\n", - "s1Fb74e1jDW2r2yyFCgbjC39WrvvZQr6g7Wb66K9obLGxo3PkVpQpLAvflMYL5RL1F6UUn7DfM3E\n", - "njhu1zje2littnhcMLXoWEO6KlKdbqSWL1+uxz/+8dptt920xx57aOPGjfrxj3+sl7zkJdq2bZuW\n", - "L1+uL3zhC/NuNIIgCIIgCHYFOt1IzczM6Nvf/vacxylJGzZs0PHHH693vetdOvfcc7VhwwZt2LBh\n", - "we96hk3Xu9tUrIhn93EXzF112+fpfD51N13qIXtVY+A6hs7Sosox7d15552Spk/R6Mpijwsppa9K\n", - "5H2DGkNcAn/X7hGIfWK3bRTLrvsx+tzwvz1rD+WLVxQaPsdawue9ErXHX7YlVSepb1DSiAFjdwgU\n", - "lb7i9zx7y20eVXZcma1D0bZCeAp/2uP273HFvJ+LJeS3s6ti1tf+qDn4rcZuUgpzLZ1XXr8J+OpX\n", - "v6pXvOIVkqRXvOIV+vKXv9y1iSAIgiAIgqmksyL1B3/wB9ptt930+te/Xq997Wv1wAMPzO08vu++\n", - "+yYzzx5++OG5u0GPA6it7cDdt3/fvRi8Pz7Pc+NU3ESqjg7eqN+Vl9bd4XktXqfXqRrKm8RbpDow\n", - "z4eHqug9adruV7ZYcKW170ylrtmSwHliX54x1DZr0uM0xuXVSo2aBqkMROY+fchcZq1Axef7rE0+\n", - "hpPeq60tvtsEa1tpJe4cKE30F7FEfe8POWn6iudkPHyOMBdZO7BLlLBcrFnKXtuCffAbnMt4r8UV\n", - "UeZVX09fOt1IXX755dp///31gx/8QMcff7zWrFkz8v7MzExSOvvpT386Nwi77757dVpyEARBEATB\n", - "UFx88cU7fb/T3Qv7/+yzzz466aSTtHHjRu277766//77td9++2n79u1zWQHOnnvuOXLXvWOl866V\n", - "lN0r8YwOPz7VhlHGSj1cvNOuz1mpFYOnPfRNJedLxsu9994rafx76AXdwIvDXr1CP9R66X1V1kd1\n", - "cUUKNaGt8krGDSoEtZjafLd0P8v99ttv5DW1b6BD37k6zrXzPn3j9ZBgsSlSnC/XPVSNNlfz2Z2g\n", - "a8xO39TOPa7PVWFXoXOk9oX1pzPYHYpU6W9aX2ow7Y2r/ldbxe+4447TJZdckny/Wgf9+c9/Pjdp\n", - "fvazn+kb3/iGjjjiCJ144om64IILJEkXXHCBXvjCF9Y2EQRBEARBMNVUSx8PPPCATjrpJEm/ubt9\n", - "+ctfrhe84AU66qijdPLJJ+uTn/zkXPmDhXjUox6VzHDhrrjUuyC7je+xnw54HSlUMn+eT9aa414i\n", - "32fn8eXLly94PqVVibl+zofvs8N236CkoRCUVlAPhsErr7tqAe6F8j5eJhlT/M3xiImbFB6HUVP/\n", - "aUdQHzjujsc5/PDDJTVzmc8wZ1euXCmpWSv4nGcQok4zN1FWXC1uW3mcsfF9L1Nq8NC71vcNigLX\n", - "NVTcJWokNs84DV0vqy21Kn9KDW4b7+mKae43JWfP/Eb7Prm1sEZh5+OqK9U31TdSK1as0LXXXjvv\n", - "/3vttZcuuuiiTicVBEEQBEGwGJhYhDdFPKVGIeEu1+s95WI18HDxKvFYAS+UmAzufjmuZyw4nlHA\n", - "Xf62bdskNd4qdZnaPn91L+Oee+5p9f1S8NpcuRhn1lMNKH6oB4yHZ+4sXbpUUuMF3nDDDZIaLwp7\n", - "In6D/nB7GTfE7WzdulVSY4eMC6+cP/bu3ncqM6qvjKlaiP9hnuAV19rdpk2bJDXXv+P6gGLksTnM\n", - "Ve8zbMnnLMoK8YOlsIYxVtgex/N9Nvk8qiS2zPk/6UlPatU+eDbU9u3bR9rrOx6S62UODq0seOwP\n", - "ytdiVTRSoKRi12SzldblQo2mfhlKK8oTa6HbI5/jt4k1ilhB/zywluZi41h7OS5/Dx3j5nGl2A1r\n", - "KufRtiL/rpErGgRBEARBMAEmpkj95Cc/mbsbxEPl7rbtc/XUvj/HHHPMyPt45nhj3I1TR8k9ZJQB\n", - "r5KLN8BdvXsHpd4e1+v7HQ0Fd914E4slNgo1AXw88NJQFRhHvKlUXAH/97gAvC7ssu9K76gO4PaC\n", - "14QXipfE91AUb731VknN9VOXCXWD4+6488CO4L1j56gmuR3hsSO8SdpnHqFKgPdf12xAxn+hcU3F\n", - "OQJj7Xvg0ac59c5jpOgLr7LONeLZ8zfn7J93W2VNueuuuxY8Dzx/xgybZ03hvOgr2mOtKVU2OB42\n", - "5Gst/XbwwQdLauJT6UdsgX6nv7GJXEyOP62gv1A5eXVKlZFpx+tm+XjldgfAPug/j8ddKM5Qaua+\n", - "2yn/57w8yy63VrI2cR6enVg7Xswz30/XY/ZSFe+XLVs28n3WstKYu1CkgiAIgiAIKpl5uK9iMW0a\n", - "nZnR7OzsuJsNgiAIgiBozezsbFJND0UqCIIgCIKgkonFSJ199tlzz/F5/k6kPM8nSyFWw+vxvO51\n", - "r5OksalftPPpT39aUhPf0HdWHM+TzzjjjJF2gf4kTsDjLF7wghdIauITiLXheTjH98wO2jn//PMl\n", - "NTFEPF8n/oJxIF6C59I8P+eunnHyveI4j7e97W0LXt9Q0M6//Mu/SJpfO4g4AyppE79BZgyfp1I3\n", - "cQBcP8/f6a83vvGNI+0ODe184AMfGDkv4HzZsYD4i9tvv33kc2SSET9w9913j7yfs8+hmJ2dndcW\n", - "5+IVnH3XeyeX3UY755xzjqTyisycB31buq8o7fn1sSsDtkgMDTbI2kPcHXF2niFNDAn99Za3vGXB\n", - "9oaCdt73vvdJKo+TXbJkycjnS6vk097nPve5Bd8nU5gK+Lyypq1YsUJSM37MEeYCawZr8aTmeq49\n", - "fiOwc9ZkrpMYODLJPQYKu3vHO94hSdqwYcPIcfl811g1Yrqw3z//8z+XVN6fuViyHLl2QpEKgiAI\n", - "giCoZGKK1C9/+cs578Gr/bbFvZBaBaivTA8yVoaqz5QLa6PdVC2Mb3/72yPH8fPEG0l5zVyfZ5D4\n", - "jt38jULFK//vOxuuL7huzs+VNK9K7fuL0S8oUHh71Ejpa2f3WlKZK6gTuTpm119//U7fn0DYZRLO\n", - "pbTuDpRm3rbdG4w+bqtIpWDtyykx2N607UXntFUM2tb5cuh/sr5QYHi9+uqrJTVPSXi95ZZbFjwe\n", - "2WKo8yiQ0wq/dVwvaxNrnteZcvw329fMvuB4tZX+h6qwD6FIBUEQBEEQVDIxRWpHUIK422y7Gzzf\n", - "b7vvlUPNk5tvvnnk/8QhlJ7XuHds5/pRktauXTtyHt/5zndGPp+6O0cxOuKIIyQ13ojXcaI/qJbs\n", - "4G37zuzEEtEOx+3qlffN5s2bJZXvdZgab6+IP237gE0bbXe2X8z0rQwR88T+n8TwoP763oN9Kwep\n", - "GBR2lfA4u2nB1zbWUPqp7W8Ra9tQFeT7Zt9995UkPe95z5PUzEFiwm677bZWx+sai5Sj9jeecaVG\n", - "IEocMYG5+nM5QpEKgiAIgiCoZCoUqZSyUUqugnUpHhvCXSzPz0tpG4/RFWJeOE/ab6v08Jycytb0\n", - "R+m+Q57151WH2UtuaOiHtvErUPs9oB9Q7rZs2dLpeNNK3wqS74k47nm0mHHlA8/78MMPl9SorFdc\n", - "cYWk/pQoniKQnYZNoD6n4vGmFda6WiUJ20UJbPvbMW44v6OPPlqS9PSnP12StHHjRknSWWed1ep4\n", - "Q6vJteOCUsZuJ4wTMXahSAVBEARBEEyIqVCkahUEPFjPtqu9a/VsPerpQC6baVxwdw30H/3gO3eX\n", - "giKFd8nzfhQqSO3Rl9oPKsVQz9OpbULGVtvjo0TiVbbNtOL6+Tz9yfFqsznx8om9In6h7fF8v7W2\n", - "YGfEwBFP0RXmc9vxYrwfyeBhU8fI91kktiSnRBHbUwoxWdgm0P60ZubmqI3bZBxQpYfOFusKNQa/\n", - "8Y1vSGoUxNrM4mmNbyTelXhW9tbrS/UORSoIgiAIgqCSiSlSMzMzc8oJygcefGnWG554ql5PLXjG\n", - "PP9HAegbPHvu4ku9IL/r5/zwzDn/tufNXTvHoWqwK3VdM1E4r6HqbLWtjO9QPReFlP7EuycDKee1\n", - "8T5eO96+VwIvBftYtWqVpMabaht7llIdUOIYb66fecC442VjL8y/rlmzrAPYRamaMe21eoYEW0V9\n", - "xUaovo9tMOa5vmob00N8K2sFsVm0h01dc801I+fZlaGz4ujXtooac55+XCyKHLs58DouUO6Gjodk\n", - "XpDBjoLKb11XewpFKgiCIAiCoJKJKVKPfexj55QJ7kp5bVuHiee6PJ9GQehyblITE4Vy1Dd4+ryW\n", - "xmC5IoUH79l6bb0h2keRQGlAKegLYs+mJebMoT9RXhgf+gOvm9igVD/z/kEHHSSpu7Lpe9uhOtQe\n", - "x2HeuXeIiuHX2Xf8B0qixwDmKK33NQ30nenox0upvMQ/sr9pqj5Q2zGlztLll18uSVqzZo2k+QoV\n", - "CoDv+9kWfiOYS0NVakehoJ3S7ENU3K6Zv4uVUmWHNZV4TX5z2DVjKKgbxuvBBx8sqbFPrytWSihS\n", - "QRAEQRAElUxMkXrc4x43p/TwXJnn53gd3LXiDZA9xv+5e+3rLtbvpr0OUt/gge+9996SGkWtbRwB\n", - "3ijnzSvHa4vvX9V170GHfp3W+AG8SfqVv4kBwuvPqQrYLbVpul4v7XWtx5XyllNqxLhqAfm8n7aK\n", - "910YKhYERSZniyhXObW+VilDzWQtR/Wk3b7Gkt+A2rg4xiFH7EJQR+kuI6yFKJpDxSHnYC33zPS2\n", - "hCIVBEEQBEFQycQUqcc85jFzmQ14MSgo3B2izBBZTyaFZ0vh5eFR12aGoOR0zT5qi8fitPXevG4U\n", - "508/tH3O795z31lRfStcfYO3RP/xN/2KnZbW3EGRikrdO6dU6VuMDDX2pX3F52ozRnOwxhBHCChm\n", - "XWOZWIP4bShdo/ntQDErjfdkTW4bO0M/EIu2WG2ZOEXstjSbre1vBf087n5ye2q7p6ITilQQBEEQ\n", - "BEElE1Okdt999znlxWN8UERQArjLR4nyvd8We4ZEVwWMzBi8CO6yydRBQbnqqqt2ehxitdavXy9p\n", - "/rg8UuB6PQOK/kA5zClSeOeMB9mK017tGLtJxYlgT3yOGEXib2rrgy32atjTTOl+mbV4prDv+1lq\n", - "8zx14DfA42ZRlEprxbnS4Wstc5nzxrapGUfGLbs55Gxz+fLlkholbLHaMrFObZXEthn3vmvEuOCe\n", - "gjWra5x1KFJBEARBEASVTEyReuihh+ayw1CU8GK4S8TLmdRz1No9AMcNigf9Q3+hmJTG8qAIcBy+\n", - "N1S/44WghFF3Ca9uUqxcuVJSU6cJO6A2Ds/X8YpTMW2+5x/9ecABBwxx2sXgbbsXxvWhnJEd6HWa\n", - "GC+nr0r1067YBfNh7SAOExtru2cbihNziuPxf16Zk7l40lz7rDUoVa7A+L6ZKYWJ80K5YveDxQKK\n", - "n9eMa7v218YCjjtDl99MlLeu+76GIhUEQRAEQVDJxBSphe7YU1VhJ5X5MK1KlO92j2LA832y4lBC\n", - "Sis/o1BcccUVI8fzCuReqXvz5s07PU+8DfdW8GI93qGv/bhqITbowQcfHPk/14E3k4sf4PvuFXet\n", - "WdIWt5dUPAAKsdcRcxifrnsa9kXflfcXgrlANtauimfdlYKKy76SxM+1rRTN3n1OX9l/zq233ipp\n", - "fhwoShhzJRcnyhxvq8D1Ta52YKpWIWvzPvvsM/J3raIIrD0oXqjWtJ9SwJYtWzbyfdZSlM5aUKDW\n", - "rl0rqZnPHLe2dmQoUkEQBEEQBJVMTJHaZ5995rwWanVwd4qiwt0hni93rewovnr1aknNfj0pTxov\n", - "CWWGGA8yDPByeD7qz0+JHeEuGi9r6dKlI+cJZJ649+SVm1P1lDz7js9xt+7eRGrfrFq+//3vS0rH\n", - "vFBzI+dt5jI4Us/Ta/c76otU+20VmJQX6/EA++67r6Qm7gNFzLNWsVvsg5gr/x79TqYW8wzcK83t\n", - "j4VXiLfq2aClNVjwAplPnC/zlvaZh1wn85B2ieFK7Q04BPSVZzKytnCuxMiwBjA2d955p6R0LTff\n", - "Q444UVfAvJYefcFawRqXq12GzaEud83MZc5gE1x37X6Q4yJ33UNlLJNpTX/x24cdsEZgT8D7jBvj\n", - "zxxmXIE5yxzFTlJKk+/bmoPfMmCusmZwfZw3axh2zm8bv5XYN/ONtaF2H06HfuUpCr+pXdX1UKSC\n", - "IAiCIAgqmXl4AgEpMzMzmp2dHXezQRAEQRAErZmdnU3G74YiFQRBEARBUMnEYqTGoUjRxmc+8xlJ\n", - "zXPQVBYbsVc8h+V5Mc+veV7O9z2GiPbOO+88ScPv2Ud741L3Flt7xAcQ18Jz/1TmyqSuD3sh1o/M\n", - "JTMqscQAACAASURBVOIIeI7PK58jlojPE5dAfAr2ynW+4Q1vGGl3aGhnw4YNkpr4CDJwOH/OFzxb\n", - "lrgJj+Ui3oFMobe+9a3Ja0vVzoLSmnHEmJx22mmSpHPOOUdS0/cew0EcF6+8T7wX7REjwlqD7RJP\n", - "9id/8ieSxj925557rqTh6vwwF8844wxJ0vvf/35Jw2e/cX1nnnmmpOF3b6C9888/X9L8jGAHO6F/\n", - "iJnjNbXrAHPlbW97myTprLPOktSsHbl9V4mxSsUO0T72y+f+8i//cuQ6+8Yr0NPO1772NUnNdXH+\n", - "2OuNN94oqVk7nv3sZ0tqYrPI2uR9YrmI26a6wItf/OKdnl8oUkEQBEEQBJVMTJGSmgj/VPZaKdy1\n", - "8+reBXexuXpKvh+Ve8DcreYyGvCQXUnwukq11815BDsnldU16TpVDpXO8aZcFbn77rtH/l6zZo2k\n", - "xg54RVXxWjLjyGrbGXixzC+vHkxmGtePl8j6wP/JPHJvfsfj0RZjzNx11csprRnnNblQqGgHm2Pt\n", - "ILuKtYdzR/1GeeF9xgqFatK2OrRSk6pnNC7GvY8oNo0doDzxm+G7VHB+2AtPQVKKlEN2IPaNPfI3\n", - "cwp7Q/lhDfFdLlCi+Ny4MqxTFeVR55/ylKdIkg4++GBJ8zPdeTpE/2NnrC2sqaxFXGepEhuKVBAE\n", - "QRAEQSUTlTa6KlGAV5Py3lLPg3O4t8JdbG6Xe+6CUQrwOnjeXOtlpvYDwpuZdFXdSYMX5TFE7s3k\n", - "6iaNG8YVu8CuUlW0r7zyygX/v2rVKkmN+uJxN23By6MfsS9Ul9L6Ubl6Ylw314vXiNfse0jujNSc\n", - "TFXMzkHMSYqcyo1n67XqUrsB4OnT16X7ZDrPeMYzJDW2j9LB+Vx44YWS8msRtjmuXR5QXmrHq2+Y\n", - "O6jGKBvYdNs1xNdo7IF2iOXzeEnWtpwS5XOdmEDGkVgir5XIeWzatEnS/H1WuX7mKL9ltb+tfeFr\n", - "OfOMewv2b73lllskSTfffLOkpl+8lh6KlsdkZc+jwzUEQRAEQRA8onlEBNv0tSs9d/G5u9RST70t\n", - "KY/8ka5EAcrc+vXrJTXe4zXXXCOp8ao9C3PSEDuEF4rXx2up4ujZbLzm9t9KwffWrVsnqbH/m266\n", - "SVJ/dk68CNfp8Rgou7U7s3cBDxcVmmw6wMPn1eO38Hxzqhxj3VeMEH3JHnh42jfccIOkclU8d94O\n", - "e/Uxx0pjeaBUifKK7LTT11MOwAZpDxu86qqrqo6X2jeWuYodsBawhtFurj99rnNcfgP57eK42Ddz\n", - "O6U8plTtofcNzT39Yfy5LtZIlDL6m/dTv92sZSh3tFtqT6FIBUEQBEEQVDIxRepxj3vcXEbB1q1b\n", - "Ox2Lu/dURkNfNVCGqqUS9APxFex/xj5V7PfF374T+aTxmCPiD1BmsG8yZFJqAt4W9o+91mZ5opTh\n", - "1RFPMVSmDsdFBeD6iUOapPKKp+9xa2T9cK47yyjcEZQbamtxjbSDwlWrUF199dWSmrEn9oaYkaHA\n", - "kye7sa0iVQq/HbRDvaC+FSnmIrFDXa8nZ8PsLcdcxp5cpUZx8TXMFRfsDPvEnnhljfA6Sm53vs8l\n", - "djsUKF0oq8QsuULK9aP8eqzUPffcU9Qe/Uy71G8r/Y0IRSoIgiAIgqCSiSlSj3rUo5LP33ke6zUs\n", - "vDIy4DmnntemnksHuxZe6RvvzjNLPKuybVYbChHZcV7nqS14f8wHvGCvrI/37c//ge/jxeGdts38\n", - "Qg055JBDJDXz6v777x9pp29Q2lAVUlXIxwkKANl79C0wBql4MRQm1i6ORywGY8m18vlczEoOYmA4\n", - "HmOGDQ2l7rEWD632oi577M9Q9KWs5WLTuC5eATUYO+K6vZ/9qQlzmfHHLphjXm8JRZE1x9thHrB2\n", - "kgUHKGC0g73nslsdj1Xiun3N43z4HPbua2oO1jbOFwWs9LchFKkgCIIgCIJKJqZI7czb5K7dM2Tw\n", - "prjr5K6du9S+n48Hiwu8issvv1xS4827IuVxK23jULAzV3pyFfZT+B6AgHdZmq2G97V69WpJjVfX\n", - "Vn3A+6R9FDf3PodiWrIppcaTRvFwD5WYo5QC44oUni7fc3Wdta8vxYjjsUaSxefn0RXfC47+Kt0N\n", - "oi0ogJz/JDI6ayh9OuJ7P2InxCql7MPnDn/zyprF2lCq3FCHiZhAlCD/zfU6aChUbRUpr+ye2h+V\n", - "9rzuVerzObgvYZ5jzzlCkQqCIAiCIKhkKutIcReKksDdLV4I2VlBsBDuveFFoVh1BXtEISWeBQWn\n", - "rRfE54lnALzStt42x/OaPqXQHgqU7wDPdXO+ffUruHrhascksvdQWNgNHnKxQF4NnmsrjX2qrUrv\n", - "kG1F9Xuupy9FirhBj3Mb6inBpCtq11I67kuXLpXUxBqhIPHbWLrGsIZgp6ndMXJgL65MeWwaf7eN\n", - "UXJ8VwNi78jGg1TtPP7P2lxqL8w3lNRQpIIgCIIgCAZmKhUpSHmeQ2doBNOFZ3Hm8OfqZGK4cuLx\n", - "Am3B2+H8auuMcZ5e2bt2T0a8ObzR2srmrkShQOGNjiurzqsXTxOlMUCopKh5qbHFBrCtrrE/jP2B\n", - "Bx44cr59K0VkyFKviv6Ypni3LjDHeR06JsvridXWvsPeWDtZ61gb2q6tfM/3kQVX3EoVKV+rUeKw\n", - "H+4FfA3w7ELaZx7x9KpUkSIum++RLZkjFKkgCIIgCIJKplqRgrVr10pqdkxfrM/HgzpSikpODfB4\n", - "DcCLaVtfyeG5fVfvlPPwPQDxsjyDJwdeFd5UV+WI9qkmjRfaNhOnlmmqA8eea+A25LvRA2OJh56y\n", - "PfqWsetas8uVL2JM7rrrrk7HTcF1l8aWLBZYa1B4XK0tpbSuEp8jzpPfPMYPpcpjhLzOGXbEWgVc\n", - "B58vtbMnPelJkhrl0Wvo+RpVmq2JnXpsFOdHP/h1sGZ6lihr4IoVKySV2zvtMQ9LfyNCkQqCIAiC\n", - "IKhkUShSKFG1cPfel5KVUwiIIeHu2e/Kucvl7jfqX+2clPKEF5N6H2/MvUe8HV5rqzD3VeH7yCOP\n", - "lCStW7dOUuN1up1t2bJl5G+HfqDGC8/5a/faA28PL5jj5hS52pou04hXuHa1LDWniXmiz1IqG0pF\n", - "X2ofnjWeO+c1VOzSrhYbBYwbqiwKUNvfFN9b0eG3g5g22sPuLrvssp2263OV47HfKL89KEqsEaVr\n", - "Ge0yl/t+OuRrMe2wlpOJDF4/irpSbRUlYFyI+Yu99oIgCIIgCAZmUShSgIcOnp2UunvES+zr7jkX\n", - "q+L7JDl4a6FElZHK1srFzqDsDBVTl4qHcfCiDj30UEnNTvWAF3TnnXdKarxdV5Jy+6+hBnzrW9+S\n", - "1KgQxFscffTRI8ehX1NKEbVs8GqpRUTMle8FyPkTfwHEN6BckYEzhGpROia1kE0ErD2prCJAJeT8\n", - "Unu3EVvU1151eObbtm2TVL93Xym76prGGkL2ZW2Gbi5Wh9+O733ve5Kk5cuXS2rsCqUkha+JW7du\n", - "ldScN2sNv4ltlc9/+7d/2+n7XSvZu91zPBQzf/+mm24a+T+KFGsUtSdL40ypncd8Zr4/73nP2+n3\n", - "QpEKgiAIgiCoZGKKFBV2pcZTxVvj7pu7TO5uuYtOVWnFs3YPO7L8HlnglfCKkoJygneCt+EVxQ8/\n", - "/HBJ0pIlSyQ1cQp4Obxu375dUuMtoYAtW7ZMknTYYYdJaqo+e/VnwAtK7WVHjBHxDBwHVSOlXnhV\n", - "YEAhI04CxcqVKm8fxYlMHb6HcpWqf+XVjr1KM2oNShbH8axIr13DuO1Yb44+YiwYc49NYcy8Oj2e\n", - "O8oQahy4rXAuXCPH4ZwYg1z19wMOOGDkeJxH2yrujBV9iHKSUor4PP3EnAH6h37wvc0YG88qoz2v\n", - "h4TNEfPidYiYOynlxmu3gcfKoDz4PpZ8vxbiLWtrs2HrKCXgSuQ999wz8lqLt8Oca6tEcb2cZyou\n", - "knnG+PM3a5VXJgfmttfU4/uctytdKHcet8nftRm/bbNaQ5EKgiAIgiCoZObhCaTSzMzMaHZ2dtzN\n", - "BkEQBEEQtGZ2djYZTxqKVBAEQRAEQSUTi5EahyJFG7Vttd2HiHbOPPNMSU0VWM+U4Hkxz3HJaiJe\n", - "gOfaxOL4fj/EpJx00kmSpE9/+tOSmswc4hqIFyEWiOvh/zzHJh7D4wuIJyDOguv77Gc/K6mJPaJ6\n", - "LMe96KKLJDX1v17+8pdLkp785CdLkr7xjW9IauINiL+gf4g3Wb9+vSTpM5/5jKQmXiCXGZV6Du/Q\n", - "TzxXf8tb3jJynUNDOxs2bJCU30uOWK1cvE2uPb8+4ksYB2K/vF3iFahJQ1wMdkt8x+rVqyVJp5xy\n", - "yoLtDcXs7Kw+9rGPSWpsm3PzKvdts/qI7eH7p59++lyb44B2PvShD0lq5tp9990nqYlZ8dphnkFM\n", - "DBJzPmVzXdfOFF5TjDn7tre9TZJ09tlnS2oqU7MGcR0e68W4EGPGWostegYpa8Ob3vQmSc3cI26S\n", - "WC76pzb7zLPEhurPFG4vqTpRnCd2Qz+X/uYxnmeccYYk6YMf/KCkxh6H2pNwUv2ZIhSpIAiCIAiC\n", - "Sqa6jhTZRV67ZVx03eMLpQYPHy+Lu34UJM9AQanBq0IJIGPCvSyUIbwtFCtePfODCtp4KWQ+oDDg\n", - "ZVD3iIra4BkwZPJwfe6NkH3Fca688kpJjQKFl0wWmO8Nh/eaU2xKlSjg+j1zaNzkrgtqlagcqDOu\n", - "RHm7qfbd60xlH44D1DXPzmIuM3dStpKq48T3ahWKvsBmU9lTnqEJKC2eGZ2DuZ36PBW4WdM4HxQi\n", - "XrEdX4u8VhoKCWsDa2NK2UDd990KXGHCHnzcuS5e264hKYau11VKrmI554my2RaPGeJ4u1pl+xyh\n", - "SAVBEARBEFQy1YpUX0pU21inHMSS4A25t8Td+A033CCpUVjwylB+iIXKVULPVbOl5gVKFq+33Xab\n", - "pPleCbFLOe+UWBivZcPx+D+Kjtf5AWKmUBg5P5Qo/7y3h9LF+FHPCLru5bbYvaddZS+75z73uZKk\n", - "Sy+9dOT/K1eulCTdfvvt2WMwt3hFicDWc5W3UzW5mOOTVqTagirt1fNT+O4RHrfoUNOM76HooC7T\n", - "bqoekitoHIe1gvZZM4jXJG4UxYzPsaay5qPWszbVqrqpit2027be165KXxX5FxuhSAVBEARBEFQy\n", - "1YpUX/SlRAFeUS4jAe+Kz6N8tFVA3BvyuAK8Iif1fLw0kwJv3pVBvA68fvqX/+NNepaZe214k/QP\n", - "7bhqwPP7lOJCf9R6Q213CJ82ul5/33jMXynYB0qlx9eUgM0yx8hG4pyYK2RlleLf74vavck8jtBh\n", - "btEPpbs7eGxPak85r3Ttu0qgRLXtZxQq5iSxaa5cpdYSlDPfo42/a1VbzsOzAYeK32XnD+zulltu\n", - "GaSdoB8W9y9IEARBEATBBHlEKFJ9U+qF4B3h1fHaVgFxb9XjFXIxVrWk9mPCu8M7x4sljsH3SkyB\n", - "koV3Tf+44sb7qfiWUoWPDB73zoeqdTIupkWJAnasbwtqAXE9Hh9TAnWFmDMoVBwLlRTVdOvWrUXH\n", - "9f1A+2KomCtsonSPtBQpRYqxIn6T/Re7Qjyk19bzfVUdXxNRclibfC+3thAP6+0NNX6ldtkXZGgz\n", - "X4iPHUpxY3zIIOe3YNOmTYO0NzShSAVBEARBEFQSitSApGKz8I5zGUQp3Atyb6kvUrVQ8MZQgmgf\n", - "BQsFKVXTBsjkwVsmE8e9/r4UI+IoSuNFphX6Czviemq9Y69sTvxJ25o6eP3UFmoLGWCHHHKIpEZV\n", - "QZG69tprs8fA5rBJroUK2tRkQ+Hw6v0piPXBhrqCIkYcWN+1t1h7chm/XcEWDz/8cEmNzfCKbaXU\n", - "bcfHifEhTq5UnWRtYvxRKj0rMQd2gpLJcVBUrr766lbHm1boL+bc0LUbsU+UR16JBVts2bGhSAVB\n", - "EARBEFQy1YrUtNfHyZ2fe694VygvKD5tY1xqs6L6wiuXo6zRD3gTuRorXD/xFSgRHiOVi48ozcpM\n", - "7SG42EDFQEGijlhpdhvjQj/gpfN3rhpyCo/HaQs1gDx2rk3leY+VYczxsD3TtLTCd+r4paBooNzw\n", - "N32G4pXLxps2sKUlS5ZIauYU/d42Y9orjWNLuTpNrInYCudB/Ch1rdqeD8dDZSVbD1v1ell9k6q0\n", - "3zfjjsnyjHaukzjWvirMj4tQpIIgCIIgCCqZakVqWpUoyJ0fNWyA59B4n7UVtV2xGTfEPfhzdbw9\n", - "vP/Sar9eh8q9fhS8VExZaS0evl+rmJSSU9C6wnWyd2HbGDm8PuJRiNdhHOintjF8jF+tonXTTTdJ\n", - "ml8Lij0rS/CxRanARlCkateW2qwvbAIFgzHARvqKvWqLz+W2sD8j30dRo7/b7jnH2sH3ec2dH+Ps\n", - "SofXqGurQjMujDvKDbFaKHK021cGNfaBvdDetOzh1xWvUchv4lBrJkpi7dqUIxSpIAiCIAiCSqZa\n", - "kZo0XZ9Pu/eJ99fVqyhVVLruMYiX5efrsTW8z3mRgVEa70G8CAqePx/PKVtt1YWhMkLGpRR2zcTy\n", - "PRF9PzXsdqj6ZClQi4j9QilrM19cMcL2OUZbW2HOEiNTm/FJHBu2zvmg+g0VY5Oj6z6TZEkyd3mt\n", - "3dPOx4v+R5VOxagx7j63UV1Zg9v2M0oQ14OCwnkwnthVX3OGcSF7kbU1t1fiYoFx8Bg4/mYc+4oN\n", - "G0qJglCkgiAIgiAIKglFagHwqnheW3tXjCLkO9Bzt932eX3bfblQHPBu2iphKSWL6/G6THh9VKbG\n", - "eyPDJcVhhx0mSVq5cqWkxnv39ugvHw/6FWUl5X3gtbZVzEoZd+0T3z+M15zKgB24V+jZe7V0rf7N\n", - "OOONt/HyuQbfA84zCkvnNH1JX3e9NhQc5hZ/l8YTTivEoGA7uRpyKRgn+oc1DFvwOlJ8ns+5Yuj2\n", - "UAuxUdSRwi5QpvpWipgDXE9ttmhbavd+rIVxwW5qM9knTShSQRAEQRAElYQitQDcFddmEKDMoJDg\n", - "veBl1Xq1eAlkyuToWicp5ZUQF0DcAgqQZ8jklChA2eJ4xMYAMTNe5dj39Mt5MXitQ1WCHxfU7KHf\n", - "8CJvv/12SXlFirgcFDkyZlAVumbOUO35BS94QdX3sR/mS5uaMlw7toQigWdfaisOtc5qs/YA5YLz\n", - "61ovp+86Q6jJbWGtaGs7XmmctZe1hMzUlMpMPF9KjcbWWTO67mrgKnbpWlxLbWxfLeNW1ffff39J\n", - "zbjdeuutY22/L0KRCoIgCIIgqGRRKFJ4XXibvA51l167Bx7g9RDrs9iqFecghgzv1RWk++67T1Lj\n", - "LTJevn8TXjkKF+Ps8QB4m+7tovyVKk27Sg0Wz9pbvny5pHJVwvsRL7Qvpa5rP6NGYEdt5jlqL7aG\n", - "bXk1d6Av/HspW227V5uDysY11da3Ya7k4hjpS+Yo7aUyP/3/XhNtn332GTl/1FHiDlGhU3GMZNFh\n", - "a8Q+AdeD8sfnUjFCvrefwxpE+22q5JcwtIKDErqrwvgutkrmTihSQRAEQRAElUylIkXsB94f3o3H\n", - "HKH84J3hdeB1TQrOk/NBwfG6S7nMFr5PZWe8NDJHJsW1114rqYkPwCtz5Yn/p7x4Pk/cCN4sfx9x\n", - "xBGSmuwyXjkuXmrXuAcH++G4xCC1jf9AFeirJopnKKECYF+oCd5OVxUlB+eBd4lSmMIrl7uCxf/J\n", - "1kNN8axCxn9HxcpjVugT5hIKFXWh6CtUY9rwavrYXteMRjJ5saVUTbYcOVtizSAGBVhzUoqUq39P\n", - "f/rTJTXKlis8jBWKAtfBnoJcH2s0Kj0KnKugKFQch/7yNYC5kIoHRC0nvpK57HOYfSuf+MQnSmps\n", - "GdvzbEpirbiugw46SNL8yvXY7ObNmxc8P0DhIxuxVH3lvBkH7L62ZqAzVPae1xrEbvg/CmfXWnk5\n", - "uD7mR1flLxSpIAiCIAiCSmYensCGdjMzM5qdnR13s0EQBEEQBK2ZnZ1NKoahSAVBEARBEFSSjZF6\n", - "9atfrX/913/VE5/4RN1www2SfhNP8JKXvETbtm3T8uXL9YUvfGHu2fA555yjf/zHf9Ruu+2mj3zk\n", - "I8laMueff/7cc1Kej5LRQQwOz7UPPfRQSU1MBM/ZeS5NRWziGnje/MpXvlKS9KUvfWmkbZ7Dc7w7\n", - "7rjjN53x/5+bUmmbWJ/bbrtNUvNcnmsllovzOPHEEyWpWG1rGxfh0A6vxMoQd8D5ES9AXALP0+l3\n", - "4kZ4n7tuxoPjvOxlL5Mk/d3f/d3I/z2GjRgjsq7oH86DfqdaMNfP94gbOPXUUyVJZ599tqSm/+k3\n", - "rzzP+PG5tv1KP2Iv2BPjTY0T6jURq/anf/qnkpr4je985zuSmrgS+hc7pV9e9KIXSZLe+973SpLW\n", - "rVu34HUSR0DcBv+n/z0ugvfpd+I4nvGMZ0iSLrvsMknz+5/r5PqI81izZo2kJl6CWDbOhzgixpe/\n", - "3/rWt0qSPv7xj0tq7NKrhfv8Zzy9DhnXlaqPNjs7Ozal2+fertreP/zDP0iaH7NCjND69eslNbbB\n", - "WortEePE91lbmDvE073mNa8ZaRd4vzYOkjmMjTO3Tj/99AXbK8WzIh3WYmLSaOeLX/yipGbusuYu\n", - "W7ZMUjMniROlHc6bNY+5wJrrMVovfvGLi66Pdvne9ddfv9PPO6zZ73jHO3baHufvig5rPefPnPds\n", - "WtYMrvuv/uqvdtpe3+TaySpSr3rVq3ThhReO/G/Dhg06/vjjdeutt+r5z3++NmzYIOk3gXWf//zn\n", - "tXnzZl144YV64xvf2HlTzCAIgiAIgmklq0gdc8wx8/YR+upXv6pLLrlEkvSKV7xCxx57rDZs2KCv\n", - "fOUreulLX6o99thDy5cv16pVq7Rx40Y985nPnHfcBx98cK6iMni2FKSqnXLXyl0sGRW+wzd3+aX7\n", - "FeUyBny/J+7m29J3XSPPAiTjJNV/eP6pjIVUbY9cvaFUxkduzzT6A8UG8FZQLryGjiswPj4pUFy8\n", - "ZhD95sqlZ4SR6fWpT31qp+2QYePHB/rpuuuuKzrvUlAD8OpQpBh35hn96NWp+RyZLd///vclNQot\n", - "XjcKFPbnXjr9m6pfRf/maimVVOpPeb5Oau+2YBTWVIexQMHwtRV1caHMSqmZO7kae10zcnM1AVmr\n", - "XF3Prc05WyRb0Ndkzgdbp3/5LfTfrlQ7zB3vH1/LcjAuT3nKUyTNV6SoUZfaS7C0/llqPrIWorz5\n", - "GuFCzLTWAqyKkXrggQfmDGXfffed+4G87777RrYYWLp06eBpjEEQBEEQBJOicx2pmZmZne4/1WZv\n", - "qrbVfTl2rh4Tz5Hda2pbKwPlwyusd90RvvZ8ppXa80/Vacp5pV4jKAdKTQpihFAruJ7avQvxMvG+\n", - "77nnnqrjlIJih9179ehLL710we+594ciSVyH4+Oc6h/Op+vej15leyFQQtyzd1CReUW17htUT1RJ\n", - "1iBUwGmvXI1SkFJ2UHK4LmyIv1NPAbBN4mT7hrWU+lCucoOrothqV1L1nFBUsE9smf7oSttadYwr\n", - "ayxrI+PK69BMq9JUStUdwL777jsnSW7fvn3OWJcsWTKyMNxzzz1zBbaCIAiCIAgWGxdffPFO369S\n", - "pE488URdcMEFOu2003TBBRfohS984dz/X/ayl+ntb3+77r33Xm3ZsmWuMm4JJR7njqS8T1eIuNtH\n", - "ESCTw2NDcnDXzF16rrpuW2qVHM6H76eOUxo/4ky6UnwO+j/ldTqMey6eoG28gUN/exxECtQLlBu3\n", - "KxRRMl3wHokzoB3PWvRK46gwOdUmBfbA4/3cPlmlsYk5StaF0msi3s33iewbFA5UQdasm2++edB2\n", - "gUxQQizajrlXeAdsirUVW0PZyKmPKCddq/2nYI0rVTpYM3NqdSk5dZY5xG8Vyl/tnKyF6/7Wt74l\n", - "af5vYi6GEOWvFP+Nx1763p3CYc2j/7kXKK0Ef9xxx83FhS9Ethde+tKX6pJLLtEPf/hDHXjggTrz\n", - "zDP17ne/WyeffLI++clPzpU/kKS1a9fq5JNP1tq1a7X77rvr/PPPb/VoLwiCIAiCYDGRvZH67Gc/\n", - "u+D/L7roogX/f/rpp8/V6MjhNULa7mmWunt3BQXvhLt/vCDujtl3qzReAQ+b5/tdY6Tw7HkMirfq\n", - "2V0puF5uWlPKR20R+677i00rqTpeZKn5nm9tob/x2lEjUl4yj8hRwmgfr4n5gb0yfzg/FCmvNeNe\n", - "NrFkPn9Kd2Dn+DmFDfra/6tPxuUJE795yy23SGo8/XHtdo/NlMaOOanP02/YWNt+ZA3OKR4oCNh6\n", - "KvbKlQ5srm3sTV/xqalYK86T8eA3py9ljuMCcz81B1lj/DeXfvPjOW2FEs6n9ulIV7w2XV9EZfMg\n", - "CIIgCIJKOmftdYG7f+7S8TpKlRgndfftFa9p17PvvApuykvwjJPa8wUUhVrlY6i7bOgaKzSt+HiD\n", - "Kzlkk9aOM95eqj0/H+yRecH58D5eIvWcqPSfws+7a8wS51/q7TNf2mbl7kqgvLgH7llvfUNdoNrY\n", - "n9x55epA5fA4QNR9bB+1njXcbYjYF6/5RmYsc4ZXr4vllbP7Uk85L8/GYy7SDsqkV/nnfIjhS9Xu\n", - "c2XHf7Ny10M/8zSEtZ7flNya11ZJ65q5W0vpU65aQpEKgiAIgiCoZKKKVF8ZEp4J4XfhxPigeNEu\n", - "d/mpoqHc7fPqx8HbaJu5sNjo6i3nntN3pfZ5e67qMeeL11arSNEOSlIqDoP/0w79TvucD8ejYn0q\n", - "a5R+8fPuq+5ZKW3HnXlV099da7G5QtEXKdtkzRpKkaLdaa1N5/GXvosB44n6iS1h295vKEEeZ4iy\n", - "4xmsjHdun862axj97nWYmLt+fB8fvpdb0zgvvt/26QHf47eQuMehsiknRdenRjlCkQqCIAiCIKhk\n", - "olIKXgAZH3gjbSHLClxp4O7evZFU1hbgDfDqe7v5XmbBKNQ7YnyH8grwatseP+Vd+vP0rt4ZO26j\n", - "pQAAIABJREFUShRecaoSP/EDxIG4902dLM4n562m6rL1VUV5KLqoM22VF5QPMiHp46EUImArLcYC\n", - "JWGxV3hui9tiqp6T74mH7aM4eSa2j59niwHjn1Oc2qqqtJ+KCUpdn1daz9kh55+rIZiCtYbv7WpK\n", - "1LiIO4AgCIIgCIJKJqpIec2P2rgEFCHu8lGMwLMC+TztcleeyyjwGCm8iHHVhJkUtXWkhs4mhFql\n", - "y9UAwC7wzrrWGqL/nvCEJ0iar5jiVXrtG7zE2rgdj7GCvhRUjrPXXntJauaBe7Vt22Me+/UOEWtH\n", - "jBLnPi4l6uCDD5bUxGcuViWqa0yZ11vieB675Hv+kQVJv6FQkUnNODK+/Na4YuO1BbuOA+ebitdl\n", - "LvqcqI1h6ysLbhprvS0mQpEKgiAIgiCoZKKKFF4G3gN36bVZWHgD/tyddjg+XhCfy93V++d9r71J\n", - "1cYYF7UKRpfsqx0hxqhv5S9VlZf2fEf72n2w6D+8Ts/kwRv2eAVXWFP9mJovrvhCbn+5XOwgHH74\n", - "4SPHQ9mjdhHQn7ksSWC+ubI1xHZTXesgtYUxJEuqdH/IaYX6TKy9bfvTbRbb4//8zVqCTbst8H/W\n", - "YmyIuYbtuXLmGbEcl++3rT/E04qDDjpIUpNZC8ztobZOq3164FmSQ2e57WqEIhUEQRAEQVDJRBUp\n", - "VzrwgL02Rg5qX3gFaUDJYF8jj4vIed54xtyl40Xi5fR9946XlKppMm5qY4S8SnFtddnabM4cKYWL\n", - "8URhwR5rq1BTZZk9FFPX49l8eMk5xTM3X2j3hBNOkCStW7dOUlMZHfCmiXnauHHjgscjG3PFihUj\n", - "x09V5m8b/5GaTyXHaTtGVM5mDRl67y/fdX6xe/7YHvtEtlWkfEy9cjnj4qoma6M/hfBxzK1d/nQB\n", - "PG4xtVuGnz/tsXb4+DL3U2tA15iz2linVCZw33XVap82oUx6hv60EIpUEARBEARBJRNVpNwDr401\n", - "8rt+j2VBieL43GW70sPdMoqWe0d4L3greD8e89IW7rZRBKjOy3XkFCm+l/K+8H5WrVolqfEaUWSG\n", - "ivEqjYlx/Dn/uLL/AAWpL7wfUsqce2set+DjhB0To+QxUby6Qrtp0yZJ0vbt2xc8j1xMHOdxySWX\n", - "SKqPHSslFTO1EFxrTpFizpBJ6Woac5o+JBsstedZDhQVroXzdLV72sipydjesmXLRv6P2pkbs1RN\n", - "NWBvPN8jr+1xUqC0sHay1vp+lyhP7OnHOPo+l3yOOEFfuz3jO3U+taQUKZRD3/eS81m/fr2kpp9Z\n", - "G44++mhJzVMY1o4U2HVKEWyrRHE81sb99tuv1ffHRShSQRAEQRAElezam8T9f9xb8cwPr2Ce2qU+\n", - "5cGnvN+2z4O9rlVpvEEuDoDrpR/wEmuVKLx1vFG8KF7xrvmb9vGKiEvBO8KLQ+FzBcX33/KsNtrx\n", - "rE/P+HHlkP5wb3vovQFTuJ1wHh6vwfly3SiLqfN1Re+KK67Y6XnkvOK2SiMxiag5qXgMV4Sxa7z3\n", - "EkXKz53YHWwDm0eJAt83E9vxvdq87lEpHo9HHaRpJxfXuG3btpHXvqD/qTjPXGBtREHk/yiGvg+q\n", - "r31+PakahqwVxANim/yfNcgzijnv1G8ICpbbH3A8r0PFXGEOpZ5S5Cqz+3kxx773ve9Jmj/HiH8s\n", - "tdfly5dLavqJWDHGh+P4bwLjhR3x/SVLlix4HG+PNY74TuYpaxW/pak4S8aD62e+l+6jG4pUEARB\n", - "EARBJTMPD52mslCjMzOanZ0dd7NBEARBEAStmZ2dTT5dCkUqCIIgCIKgkonFSA2pSB1wwAGSpNe9\n", - "7nWDt7UjtEPWF8/ViRki1ufLX/6ypOZ591FHHSWpeR6/ZcsWSU2GyOrVqyU1GQvEaq1cuVKS9LWv\n", - "fU1S85yX9nhuzH5ePC/m+Tv95PtVkTXnlbVPPPHEkescGto555xzJM2PT6nNCuS6yI6kv0477bSR\n", - "dqlZQj8SR8H3UzE7XhncaxsRx/HOd75TkvThD3945PuMD+NP3ARxDsQRcDyqKHuFdOJCuM5XvepV\n", - "kqTzzjtP0vxqz9gncSnY1+233y6psWv2iaPfsEeP26Afx2kvH/rQhySlY1ToC9/lwCtp830yEt32\n", - "3vOe98y1OQ5o5+///u8lNdlVZMsRA8KYEivisTVArAmxIH/8x38sSfr4xz8+0t5nPvMZSU1sCzZG\n", - "rImPuccz0n5qrzufC+Puz0984hOS8hXmWRM985s13rM7mRvM5b/4i7+QJH3gAx+Q1PQT/c+awlzj\n", - "+KzRzFHWIsaBtQW75vWUU06RJL3vfe+T1PQ/awlxql55/aUvfenIdX7nO9+R1MSAcZ6cPzFEb37z\n", - "myUNP3709xlnnCFJOv/88yU18bWeyexxum1rAHp7KUKRCoIgCIIgqGSXzNrL1Rzpi1QV5a9//euS\n", - "5tcowVtw7/Cqq65a8PhkeODF3XLLLZKkO++8U5L0hje8QVKjUHDdtIdX4V4j3jbHg1QVW8+iGzec\n", - "f18V3vEec7VnyPjy5+J4PynoP7xRFB7GBy8T8HqwD5QoMllonwwWvErsADvES0UN4NUzXVAByIQB\n", - "vLY77rhDUqPOPPWpT5XUKHSoNPRfblxQXG+44QZJjT15/3P9a9asGTk/1BDfG5P+3bp169wxch6n\n", - "17wqrbpfkjE4Dnxt8zpGkMv4ZQ3yV4d6UKWhtPRj6S4Gtbsm9EXpXoee4ZzKbPV+TNWRYs6ztru6\n", - "zvFzNe0YFxQwbw8FCXxvQYfzYVw8W8+VxnHPC7dDP7+u+6Lm2ksRilQQBEEQBEElu6QiVVsdlue9\n", - "eAu5u+2U14XX6N9vW5cI74G7brwNjzPwCth49sRJoFzk+oUYLc6Tdmpr54wbYnqI2elasZ2K+Kgc\n", - "Xi8rBeOe2k/NK4cTf4BSSBwEn8M7TLWb21/Oxw9FjHY5P9/PjNg6+hV78urIHo/k14dimlMWiUNB\n", - "QfNK7SiBnO9Ce/u19ZBr93+sZenSpZIatc1VwUmR2neS8/WYsV2FvvYBLf2+11JLPQUoraTPWs9a\n", - "5+PjayBrS2q3CBTOlFo/bRX4+c0b9zx2QpEKgiAIgiCoZJdUpPy5cClkveEB56q5khngXgCxNXjM\n", - "qQyXHMSSeFaUV8XlfF2x4rVUoeP7tIsyUfscvO+dw3PQT56xURtbRb/i1bUtuUb7qA54l5wfoPSg\n", - "KNHfeLu5/svFBaWun+PjZRITRfuoFN/85jdHvvesZz1L0vw9EcHPt9SL9dguYsWI9/G4H7zRVLXi\n", - "Handdb5vuu7j2FVByR3XoW8n7fEPBWpu2+vL7UeZwtfS0lirFAupsjXwm4l6XDKnpoFpsctQpIIg\n", - "CIIgCCrZJRUpv8sv9eKIwSj1WlN37Xj2eMGQa5+sLN9TzRUFPy6KBB468QwpJcn3bvNMB88W4++2\n", - "oMwddthhkhrFiP2b+gbliP4gq6utIkV8AvW7UBE8likHMWdku5GxQ1wDMA6MC+df6hX6Dul+fm53\n", - "V1999YLHSWUj0n/Yl9fTylHqveOFX3fddZLm762Iksc4MK9L+mnSSlRfYDuMFWpm6b6cKVizHNTE\n", - "oWJjapUd8JptbandT9PrE00Lvp8oaw/KFXOGV9Ry+iGV8c7cZ076fp+PdEKRCoIgCIIgqGSXVKRq\n", - "vc+230tV1ub/OW8Hb4rK1HjcfD+l3LjShIJR6qHjtaBgeOYQXgbvp2JhcuDd0K+pzKC+ob3ajCi8\n", - "W6/e29Y+UAlQDVJxOnh5XjGddnMxUChv4IpUX1mX2BWZPaX1xbxaeIpUFiBQjRlvGKV02jKJhsRj\n", - "mdpWak6Rqufk6nffpGKzSulaW27cdaxYe5k7PAXoGpOE+u1rAePHmo69lK5lHI/fMs6fDN9c/zG+\n", - "/Ia0/Q1g7aB/ahXEoQlFKgiCIAiCoJJdUpFyxl19FQ8ZLwBFgGw7FCc8bJ5jEy+QU1Lcm+AuvdTb\n", - "yCkD9BfeXtf+6yuzZFwwfniLjFdbRYpxwQvDe3MvHCWK42MHeK05L47vpeIVusahOCht7POWy87s\n", - "Kz6JGCraq83OnSTE3/GKbeWq5aeoVeN8zFI2Vqpmog4yJqVxhKiuk2JS2Zz0e5vM051BfKjHuqUy\n", - "z3NK3vLly0fOj90DsDf2fc0pRF4pvS2MS2o3hmkhFKkgCIIgCIJKFoUihZdT+nzUPfBxexupOkx4\n", - "AXgPKDXc5XPevE+GDteN9+RenO/b1BXOm/MtrWni8Dyd4yzWzCn6FyWprXeF/aa8e9732DTsAW8M\n", - "xdHnQW2dslq84niuunBf4+7HT2WaTSOod3j6jDF1e0rp65pdPUypzqXxkZ5pXEoqznRcoKSNK1aK\n", - "ucCc57eidI1Mqb+pfmwb44Z9HnnkkZKaCug77mcpNap0brxLd4NIwfGnZa/LFKFIBUEQBEEQVLIo\n", - "FKm2kfrTWtuCmBuP8cBr4H3uvlEivBL20NeHwuD1g9rSV0bRuGF8eEVJqs1g4jioCV6Xi/FEWfK9\n", - "Hl2Z8jgBvLZUvEztOKS8X+yW+IucV+oKcVuFOcWk1Yw2oDLTV/RB25iPobLoUnO87a4Iiw3m1LgU\n", - "KeY+7aJA+W4CgCLI+DCX/HP8RriCSMYwNfzA5yTfX7FihSTpwAMPlNT8JtG+K6LjqqM17U8zQpEK\n", - "giAIgiCoZFEoUpOiNqMj5d1wHM+yI2uP/xM7xd2+xyi5V5qLjSq9Dj7Hc3u8ELILHymgFngdqVol\n", - "EG+d8XRvkAwnFBbGwWOl8Ab5nMdUpdSKWm8bbxbvF68Zr7pUHXG1o69aMNOeybMjxJpgW4xl24rk\n", - "Q+2B5vWHACWtlJzC47W/sLFJ0bWOVQ7PLGX3CuYEc9mr9gNrMWtESl0+4IADJM23D3aXcEWKNR0F\n", - "i34gG8/jMlHlUao4/xtvvHHB83mkEYpUEARBEARBJaFILQDZclRvbZtZUxovwOeoFF2KK0vUpMFL\n", - "8FgrrgevJuXVeqwW5zeuiuTTAv2G14xX7nWeShUqrxHk3qF7mR43QfYj3vzee+89cn54l6gbqdox\n", - "4DF6qYwYrg/1hM9RD412safbbrtt5P/A+fo+Xrl+zO2jNu1xEwuR2suslL4UKRQGxjSnzLC2oCBh\n", - "s55xzFrEnPGxdTVy0pmX2DL7afaNXy82e++990pq1NTUuHr8ZIrULhip3QcYP5QwFCjsgt+Au+++\n", - "W1Iznthv7W4JbdfOxUIoUkEQBEEQBJWEIrUA3G27cuDwvBvvAtp6yl33CsO7SMUzlNaBwktYrBk4\n", - "peB9ofSkauUM9fzfK72nvE3iTHj90Y9+tODnbr311lbtk5njXqZ7iagU9JPvmUh8h3vzrrqkvP2c\n", - "V5qzw9Lq2YsJbBE13Ofu4YcfLqnpU2KbGCPfHYHjMVZLly6V1KjPqIjYhEP8JsoVCofvC4qCwVrm\n", - "MTaeecz1HXzwwQu2Oy7aPm1oi8dIbdq0qdX3U3O+lNT1YVduXyhozE3/bWOca2mrRGGnqPGx114Q\n", - "BEEQBMEuxsQUqf/H3rkGaVZV5/+ZRCpJaSr5q0GUAWYYGIbhjggogxQBvEQhRFMUpCRGJV4RBRTl\n", - "orSAMCiIBoXSaOGtolKViLdQISBgQLkqIAx3BpCLVvxoVapMqvh/sH5zpp+e1Xuffc7bb4+s35eu\n", - "7n7fc/bZe+19znrOWmu/8IUvnKP88DtP8WQ58RTLU6nHrHgsBe+94YADDpDUve/FK8Nrw4vC88eL\n", - "4vx4V3vttdes85IRce+9984630JXYe2bWTMpfM849z6Is2Ac8ZYZd8ahpNC1ZlPiFdNOlKDWGDDs\n", - "gp3XUQOeeuopSXGGzaQzhUqgQpSI4nn6ZgGilgB2QOwev2PHntHkyhQqDLFYQxXdIeywww6S5l4L\n", - "bUctjOrtYDOsJStXrpTU2YireV5hGlWOMaFPOB5zhb5FgXAV9Jprrtlk+1A0aKdX+Ueh8jHmej2+\n", - "ju+zNkxaESrh/cA4sjbRfmystCciawz3FsZhsRFlV95xxx3zfo9+YXxrawxiP3zed+OIlCa/l9RW\n", - "2l9oUpFKkiRJkiRpZMkzU0h9WbJkiWZmZhb6tEmSJEmSJL2ZmZkJ34KkIpUkSZIkSdLI1GKkFkKR\n", - "4hylcxFXsGrVKknS9ddfP+h8F198saQu9sbfw1M9NopBIe7A9xLj/TJxGUcfffSs806a2v4c+3zn\n", - "n3++pP6xYMRteKxd6Xxr166d9XmPbyHjiDiIvqIucRennnqqJOnCCy+U1MVuUXeJuAIyZYhncPug\n", - "X4jPoNaPV6v+m7/5m1nXORbEuBHnQLvPOOOMiZwvYmZmZsFt8yc/+Ykk6a677pLUzVFiiMjQZM4z\n", - "dxm7devWSepszXcTICbk9a9//azzLlu2TFJXg25oXR4ykIlHO/744yVJX/3qVyXNrXBNrFWpqrxX\n", - "xCZO1eNIo7XFY2ta93YjJoc14UMf+pAk6eyzz5YUx+gQb8t5PVOUOccc9Oti/DjfBRdcIGludiPH\n", - "Ze4zDowr9sR1kE2JfXF++uvkk0+WVJ57HrfaukvAWPeGUvwr8ajvec97JHX3BvqN7FPmldfUY+1m\n", - "XB955BFJ3ZrMcZin9C/32ohUpJIkSZIkSRrJOlLqnjqjWip4f48++mjV8Uq1P/CKosyJqK4Qf/e6\n", - "QaWneLwUvCevBYJysVjr8uy8886SuqrJKH1kx/meeGQ20V9423hdeB983pXBKNsOJYj20I9UFcbL\n", - "wQuPFEevqeP97uNDO7meKGuO7/n3GX8UqbFxL3yaVYsjNXdSXHfddZLKNa+wSc+6i3BPGkUKGGNs\n", - "uTVzF1ulv3zt8b3xUFhKNfYA24iUqKg9fA5b6ls/yNvN2uj9xFoczanSWl5ScHxNRnXmunzuc53+\n", - "d28f18Haz3XW7n8JjPe2224raW7tPLIO2TVhUns9Qknd9/72vQLp36gfuHd4pjbzl7pZZPbXzqtU\n", - "pJIkSZIkSRpZFIoUT5HTrlqKgoBSRE0Rr07bCt4j1Xx5X4u3wfvaSBEB3uP6cf14eJn+nt0p1Ttq\n", - "jUsYC7wh2sN14bXxu+//hPeEN0z/oMDx/9r9z7z/8OIYD4572223zXuc2torgKKG94WdMK4oTtE4\n", - "uUK00KpNLYwf44RagJdYE4u20DW6iP2pVZrGYmiFaSCejrnkNbk4Dx68VzYv7euIily7u4IrVigL\n", - "pXsEc4Q6XLxlIFYGIvtgDpeupy+ujHB90T6SteMaKSWtSfjMtV122UVSp/zQX6X6WUAsIPbkdcyG\n", - "3uOxJ6A/Wfuw36F7OLJG19aETEUqSZIkSZKkkUWhSI1dyqqvxw8eA9W3gnMJvA+8Jbwfnt5rY0v8\n", - "KRlFqaRkRQoE3qXHA0xbiQKqO//3f/+3pM5L8jgCz/DBrvg73hDH4e+1oIwRE4UXh5KCd8/xI/ra\n", - "lVfyRknj+n3vvhLEPSw2RQq7du+1z/rAGJWI4hP7Ql/6XB5LXe9ro/Ca17xGUpdNSDyh47bj6jvf\n", - "Y23i99q1oTULDFCKojm10047SZIOP/xwSdINN9wgaa4SBW5Lvp/l2LhyxHhi66ivKH60D/W5NkbH\n", - "M4n7sn79eknd+HMv6Xs8xoufzEfufWO/dfJ7AO13ZZV7BrFzJaWNeVG7a0IqUkmSJEmSJI0sCkUK\n", - "z9730Ov7fZ6ivX7OYoOYD7yQvllOrXvD+fvjHXfccdbfh+40PinwHkre43bbbSep80rIbsT7G2sP\n", - "xCiOgVisEh7LFeF7S6J6UDuoVTFE0fKaR9Pcs25jJq0SSN010xelrLsIxmKsmCUnWhuiGBv4u7/7\n", - "O0ldTbuDDjpIUqxMoYB4RqmfH0WhNnurVYFgDqMcRooUsVf8v7SP5ELvg+q4Chyt5X2zMFvvCa5A\n", - "saa0ZuexRhFLx1rn2ZitRG9dsFPWDFemua5ahdf3Ay2RilSSJEmSJEkjU1OklixZMifbjKdYnsZ5\n", - "iix5i3gtPPUu1h2igaddno77KlJD6/TQn0O9j4UCr6CkmLCTPJkjk7ouquuihNIuVA6PCwD+j72W\n", - "4LjEKbjX2IrXDFrs409GFkruGNRmkZUgfm+hKa2Jl112maSu3lMpdgylwJU1r1FX8uhZy1njsF1X\n", - "IlBbI4UCJatUu48Yl3/7t3+TNN0aZpsj9PNY6q/HCKKUjRVvG8U/16rYtfHErIm1GfupSCVJkiRJ\n", - "kjQyNUXqj//4j+dUbMY7ccWkBE+/KFx9q7suNFzftJQAvEGUu9b36wtF7XjiZdRWoG8FJQplCjvl\n", - "/L5PFl4NilTfWkd4WVHcRClexlkssVC1oEixPtTWtHk2c+211876WSJSJ4mZYo3AdlH/PauLz/nb\n", - "BlRQ5ggK11hrNUoIc61v1lsyDszRsdRzp5SRP1btQ2oLesxgRCpSSZIkSZIkjUxNkdrYU8Djbn2/\n", - "7e/18YIWK0Nrq9RmEkTgrdHvfesQ9YX6R2QF9lXi8DJbY8ocvBrspG+2Ip/Hm8b74ScKqWfERFml\n", - "JS/K9wZk7vB3KqxT38rx9/yl+IDFAnbjtV/GgDg6xnLa2VyLFcbAY11QZT1jGlBHGTsHG26tkxXB\n", - "3FssShS15Z4tYB+TilWr3atxrDjS2goCqUglSZIkSZI0sijqSI399LrYY36GMjQrEa8NJQ+lg2q0\n", - "tXvP1TLUO/AaIEPthdgmrztVCzFGZH6RbYr3QvuimCWviUMWX9RPeFnsSI5KgBrA99mDz48z7T0s\n", - "+4J9s6+W76c1BoxRVNX/2QZ97n3saw22iM2VlB/fDzL6/+8rY2WHbi5wD+Gegj3V7jhQomRvYynL\n", - "XsesRCpSSZIkSZIkjSwKRQr6Zh89WxlaRdkVjRe84AWSupifsRWpF7/4xZLm7itV663RTrwd2oky\n", - "1FeB5Lxcd6tigwKF18Lv2G/0ft3jRkqVzmkv/YgC5vvFLZa9EYdCvA3jy+9jZusxh1AnFyrLC093\n", - "oVXC0t6C2GRJzewb37jQbweYG/Tz2Ofve48aex/ZhQbFtjauF+WRNQ17IVasrzLl/e32R7wpawX9\n", - "zdreqjSz60dtXGYqUkmSJEmSJI1MTZF6znOes+Hpte8+OI4/tU6qjhTH5f0v72NLMUtje6FDvWZi\n", - "T3iKp9/GrBy9MShK9Jvv2F2Cz/uO6a3jjMJx9913N30fL4X4joceeqjqe3j9xGaB77/lcN2cZ8WK\n", - "FZI6u+vbn16/bSh4rdjR0Ewlz7yZRN0ojk1fsIb0nVuuspYorQHYFmvGWPuGlio+R567q8asGdgk\n", - "/Uc7+9ri2DC37rnnnlGPi3KJms8uCozn2LXZUBBdadlpp50kSffff/+o58P+uR7sevny5ZKk2267\n", - "reo4ZJR7JjNrRF9FypU/V0w9vpR7G2ttqyJFBjT3mDe84Q3zfj4VqSRJkiRJkkampkj9yZ/8yZyd\n", - "xFvrBW255ZaSuve4vB8F6uywLxZPzSgTeFeliH+edvFa+TznB/f4F1vWFDuk423S75OqpYPSxbjg\n", - "/dTiXsXQOlwlUHpQ0vBKXBHDW3JvFPsiXoPjcN1eBwzvCXv0jBdYtmyZJGmXXXaZdVxXB0pK0557\n", - "7imp86q9/bX7bmE3BxxwwKy/j5WlOXas3qbAllrjDrHpsWJxvO9aVUPi6VDzWtegSC2tXTP7MrQy\n", - "tWfEOn0zdIF7Ee1iLpeUqNbaZ9jVvvvuK2ny1fxf85rXSJJWrlwpSbrxxhubzkv/u5I5qTWb87AW\n", - "164ZL3nJSyR14/nrX/96k5/LOlJJkiRJkiQTZmqK1J/+6Z/OqViMh413SF2ciG222UaStPvuu0vq\n", - "lANXPPDq8Co8G6gEXkz0fhfPHrweEwoEShbtob3uddJ+YmF+8YtfSOriD1ort/OenxgW+p/23Xnn\n", - "nU3HLUHldPpxofd6K2WeuL3ssccekuYqPNgL4xh5v147h9/9+8B56B/3gnxvRNqDPfB5vCzaFcWk\n", - "Ec+Cwor3y/zj+6gRnJd56fuloTj6vDrwwANnXRfVxImBQrFjXOgXjzvxebrDDjvM6oeNFT7P1vH4\n", - "Sa+ZxneZi9Ec5zj0EUwqrhBc8aGdJU8ZRYrPP/XUU03nn1TWHf3pe5mVlCiuy/dnxTZLCopnzNb2\n", - "J2BHtD9SMqC0N1zE448/LqmbC8yBSdU7u+qqqyR1byvWr18vqV6dBvoFZYvvM04+t1kbPN6VWDDW\n", - "Bj7vcdT0L+PH8TxukzWY8fdnD5Qt2se6UJ2tWPWpJEmSJEmSZA5LnplCoYslS5ZoZmZmoU+bJEmS\n", - "JEnSm5mZmVC5TEUqSZIkSZKkkanFSNUoUvvss4+kLkaIWJu+5yida9WqVZK62hF94X3sSSedVHU+\n", - "3r8OrVDu10fsE8ctZT0SJ1J6zx+db2y8ujTnOffccyV1NUM8I4SYGa/n5O/diW/xGCVidT7wgQ/M\n", - "Oq/HSHm8De/ryawhVu7pp5+W1L1/x4shRoiYpfe///2SpHPOOWfWeWhPqb4UNW2iecH/aS/n+8Qn\n", - "PiGpiwegn7Afj6ch9or4lNtvv32T52P8iOF75zvfKUn69Kc/PetzjKNXdH/00Uc3eVyH7EXfx+vD\n", - "H/7whmsjHpCx4LO0jbkR1T2K6iLRV2eeeaakzla4djJ4OT5rlx+XNYCxIRYJW+H/9P2RRx4pSfr4\n", - "xz8+6zzYTN+1ETw+lZgQruuzn/2spPo1IqJUEdzXligDlbi+oXvY9V3Ltt56a0ld+/v2R+l8pcr6\n", - "zJUoS5L/s6a/4x3vkCRdfPHFkuLYKtYuxj26BxKzROa7x05xXZdeeqmkbr75OHlMk2eTsjYwf6L+\n", - "4Hyf+tSnJHVrZW2mf9+dDEp2kopUkiRJkiRJI1Pda4/IeTxwz7hAWWn1tmrZf//9JXVP0Z4tSN2e\n", - "qFpu3wrbeA0HH3ywJOnb3/72rP+TjUh/uBfndbIAhaS2Dlerl1nyKrw9pXagdHCd7iXghUVeKIoE\n", - "XrVnlQGKi2daufIT7Uvm3iDXddNNN22yXZ6BhDqBWgJeobykREGpZk40b3xPwJJ3hkLB0qclAAAg\n", - "AElEQVRV2l+M73sWpCuv9CP9UKtEAZ/n+xsrW2T30Dc+BvRxySYjpSqKkeA8nsEbHZc5xBzxvqXP\n", - "vC89S612d/oIr0DtWVFj7d9YW2+K87sSxRijoPzwhz/sddxWfPcNMlGvueYaSePVRyopI6XrxC7d\n", - "PkvtQ2EqZXWSxVeyB9oZZcSX6qKx5kb1t3wXEeYHn4/uaa7ojb2n5lQfpFj0onT40tYbdKIPbt/4\n", - "+bvuuktS/Epj++23lxQ/SNWWUQCu67jjjpMkLV26VJL01a9+VdLc1wFOZGRD5fdaeD1RktdrZVY+\n", - "Fx2vNJ612w7Uvg7gwd4fpEitrb2uSI7347ZO6tp2OP7gz/n977w+4jpq7avkWJRSwjnvy1/+cknS\n", - "rbfeKmnu/PRNozcGJ41r81dmfbeqKNG34KVvz+RwA49sAxvydH4gLIJXm7VlGtym+q5tEVGR2dL5\n", - "gTnEjT96sPBXpox763XQHh7Mv/vd70pqL7Q5KXhA8YKUtD96VV1bFqP2nsqD29Dtp3iFyzxlvH1t\n", - "YZ6UnEq+z+d5duDBbOh6kK/2kiRJkiRJGpmaIrXllltu8PwJhOtb/M29OV7tcNxaKH7mXgseeEke\n", - "Lb3yiPj6178uqXs6rr3+sWXJvoxdMcODsh28EBShyNtBQYy8rNpCoJF3gpeEXZQUIdQCxhVvyBWU\n", - "sTYPrqV0Pl6BosQyPrQ/UkxRHQhyj3Av39lxxx0lSa961askdeN/xRVXzPoc9rCp+RepZyhHYwUt\n", - "t1JaM2oVFO9DxuCwww6T1BVG/PKXvyxJuv766/s0c/CrPX/dPhTuFdHraG/vWOcF7Geh1mDeVqDE\n", - "9WWs7clq1/yx1jJeXbP2oCh5O7D/vm8/GL+xxjEVqSRJkiRJkkampkj93//935yg5aHgffT1Qkht\n", - "5WkVRQLv5r/+67/m/b6/t8Wj53hRmQPeZ/d9Pxs9fdcGd6OA8ZTfGmvjZRw4rm/yG3lFpKJTPoL3\n", - "+B7/gH14IKyDEoWSsttuu0mSvvOd78z7PY/ZieIvuC6C46OAZnCF0Tc+7UsU5xCBYuObJEfzDfWA\n", - "mCgPjC4penijpesjmN7LHwAbpv785z+ft73e7hpYG1A0KEmBbbVupTIp+q5lXBdjtXz5ckndRtWR\n", - "IjW2cgRjH492YmOuKHDdHqRfW1Kklb7p9A5zges79NBDJUlnnXWWJOmnP/2pJOmiiy6SJN1xxx2b\n", - "PA5Kq1O7ZkSMrZqzprz2ta+V1CXssKai2Lpy6/3beu8am1SkkiRJkiRJGpmaIvU///M/G1KFfSPI\n", - "hd7cFuWAGBveS5PNV3rqdY85ep/rEMdRKlbnRFlPtU/nrTFd4BkPZBCRbYUXTGyZe098jzIPHtvm\n", - "3iTUKjmUryhteg213hbjSXtdIcJu8Zp4v+/t7rsRKPT1KvvGc6CMEttFu2lvbbxFqdAsSiSxYrSP\n", - "eCXsozY2kTigGvgOcVwUGiTua7EpUn3BRn7wgx9I6sbQs7kc1NaS6jtpSsoRikU0hzwdHpsdK1Yo\n", - "gnb7Zsq18Hl+UhKH60BpisaHucQaBH03ZY6Oix2NVW6CfqKswuZOKlJJkiRJkiSNTFWRAjx8vAkU\n", - "l2233VZS99Q6VEmJKBUEJOYGb7X03r+vctD3uiZdhK72/CgyHqOCF4PCB17Gn/EeWutloSBjCG+q\n", - "NrbNFceFztJzZbdU54lxaFWEa71/Pw9xIvQXf48KpKJ8tagojB0Zu5u7EuVQq47ri+pNAUrGtOsj\n", - "lVRn5lBUo414QK6HtXjScw6lbOz++9a3vlX1OfrB5wjjXlLB+Rz3XIpBsx0T9jT2vefuu+8e9XjT\n", - "IhWpJEmSJEmSRqZa2dzxLCee7smqw7taaI+ep3BiO6atnEw7jsGz/fD+iPki1gXvhiy3e++9V1I3\n", - "fl4xm+/13XJnoegbc8R1LpbMEih5lUPbW4ptQnGif5hP2JHXdmIrmMir9q2l5oNYFuIgUSyGZjUt\n", - "NLUZuig8ZMaSUexqKp+b1Nwrbbrr7YhABafW2AMPPCCpu3cwvpxvqNLYN1N2rC11+sK90mvUecxU\n", - "hNfo4y0BqvC07jm1djNtUpFKkiRJkiRpZFEoUpHCg7dVm301Np49FNW9WWiirLaFAu8MLwEvjPEi\n", - "FopNc/EKydLE20HZ8RixsSunj01przhYLEqUe6WluAk+77FO2D/XHylzpfHDfomtw+v1Pf/IAi3t\n", - "VFA7Hhufm2NOq7J5LShnjmfMliB2KKqQPWklZSxFgfFiTWYcsSFsdixlzeP2JhWnOxTWXL831PYD\n", - "18XaTv+i9E1rLWON8LcYi42iIvXWt75VL3rRizYUN5SkmZkZLV26VHvttZf22msvXXnllRv+d955\n", - "52nHHXfUqlWrdNVVV02m1UmSJEmSJIuAoiv3lre8Re9973v193//9xv+tmTJEp100kk66aSTZn12\n", - "3bp1+ta3vqV169bpySef1KGHHqoHHnig+f0qisa0IK6Ap+Fo/65SRszYLNQ+T8SERe/ZIyWRmjyM\n", - "u+/EDmTBTZu+41cbdwAoJtgR/bpQvPCFL5z1e0mRirLuvNZNK08//bSkTiVxu+B37KaU2dNnZwA8\n", - "d8YQZWexQWxOtHb2zagk62paEOcW7a/Yl/vuu2+Tf0dRGUu5wAZRR6N9JmsZWgG9L7X7t6JITvue\n", - "67AWsSZMKwatRPEJ58ADD9xk2flNyfff+c53dMwxx2iLLbbQsmXLtMMOO+iWW24Zp6VJkiRJkiSL\n", - "jOYYqYsvvlhf/epXtc8+++jCCy/Un//5n+upp57S/vvvv+EzS5cu1ZNPPjlKQ2ug3lNrTJXHhuBF\n", - "oSRECkrJQx97n6dSBslY7/NrvZnoe+yV5nu9DYUszrFsy717FJxIgaxVWD0+AWXKFbCh1YdLeBwQ\n", - "SitKzthVn1FTIpgvJXWiVCEdonHaFMwJFAG3pVa1bey96pjjUTzkYo8jBJQcbGIsRSqCtWeszG7m\n", - "bN+4VCrnu8Iz9lxD3ea6h8bPcr1kAQ7dXSTa3aGWhdrdJKIUnwlN79ze9a53af369brjjjv04he/\n", - "WCeffHL42cWayp4kSZIkSTKUJkUKL0OSjjvuOB1++OGSfufdbfwO+Yknntjg8c3HH/zBH+gP/uAP\n", - "NngRPMXyNIgyRCYBMRbOUIVixYoVkroMBbzT0sNgKWZmaA2Ovt7uYskswWsuZUahWEUKhMcVTNqr\n", - "xWuMau5EMTlRHIh7xz6Ori7U1giqxb1Bfh/LO3Yl9wUveMEox50k7JZAjTNUyGhtiSAWh5+1c7R2\n", - "Tk+7vhXqZak2mMPazff7qIZDGLvGIGtp33pU3Duive/Gwt9y9B0nB4WrVUHyXQhajxOtvUNh3jEu\n", - "paxX1rRrr7123s813eE3Xmy+/e1vb8joO+KII/TNb35Tv/3tb7V+/Xo9+OCD2nfffYvHm3aBySRJ\n", - "kiRJko157nOfq+c+97k6+OCD5/1cUZE65phjdP311+vXv/61ttlmG33sYx/TddddpzvuuENLlizR\n", - "8uXL9fnPf16StHr1ah111FFavXq1nvOc5+iSSy6pegJ3L4I92njfy1N3yVssKTEoXbwH5v0rtVp4\n", - "6OMp9eGHH571uQj3KvHIUeNad7jGm6Mf8HJalQR/n75YIH6CfnSb8QyXSWdulBQ07AUVg3HBG0Nh\n", - "irxwP74rbiR3YM/E/mG//MROOS+KLPW6PFsQsKfttttOUufFYq94bb/85S83+T2Uw6222mrW+bne\n", - "jRXr+eBzeJ8PPvigpHr7jvZ6nA+PT6MydiuMfdQGxoC24gnzs6RITbtmHGNbq3Rgy14rLBpTr8Q9\n", - "FiWVG1hrmFNRfGmtys/3IyWF4zD+rBWt6vPYMVfEAaOw9n0bUtseYsi4ft+doFaJiuKPuXci0tB+\n", - "zlcbY1irpBYfpL7xjW/M+dtb3/rW8POnnXaaTjvttKqTJ0mSJEmSbM4seWYK6R9LlizRzMzMQp82\n", - "SZIkSZKkNzMzM6GSlcFJSZIkSZIkjUxtr70aRSqK8YBSRgnnmLT6xfvk008/fdb5SvWIxj5f32yv\n", - "2vpWfr5zzz1XUherxDgR20PcSG0dIOIKiGvgffaJJ54oSfrCF74w6zyPP/74rO/zvp3+vueee2b9\n", - "n2w6Yo1uvvnmTbaDfiTmj/f9vgfcNttss8nzEO9BjBzfJy4CO91hhx0kSUcddZQk6bLLLpPUZfsR\n", - "rxH1H+NGzJtnqxJ7RH+SSfuhD31o1nVyHq6HmKja/dsA++B8XPcJJ5ww63wloj3+apmZmdHHP/5x\n", - "SfV76dGHeJq+lnAcbI9rfc973iNJ+tSnPiVpbowNx/GsO47DNXLNjBnt4HPErJxyyimStOH6onpX\n", - "URxoXxizT37yk5Jim8B2oorfHjNFf3D9vrZ85jOfkRSP29577y2p2zPQY2u8Xdg0/UX/EH7yiU98\n", - "Ytb/x9oT0KE/yf569NFHJc3dO5C1gTntGbasdcuXL5fUXR/1qogBfO973zvrvBH0J+fxXQRWr14t\n", - "qYu7jOyA83z5y1+edTzufYwzayH3dOyUtYPvcS/Bfv2e5tfHPCKmq+8aBtgHcE95+9vfPu/3UpFK\n", - "kiRJkiRpZGqKlNQ9paKk4A3w9FmqCTJWpfChRF7MtttuK6lTKO6//35JXXbUAQccIEm6/PLL5z1+\n", - "SZkDnsbdC911110lzfU2avvPFQK8TLwH2uXKSy18D3vwasDYR7QnHt4ZWWiuFL3iFa+Q1HnFt912\n", - "m6RY+SBjJMrUWbdu3Sb/jhdU8ob8+/Qf41YqB8K4ReNH/5f29WKeoYJ4NmAttJfj9N1HDKUQFeH6\n", - "66/v9f2NoS9d0fD6NlDKYEUdpa+8ajtzjvP5/pIR9BXtpU4RY4BS5h4ya0G05qxcuVJSNzc9K7Fv\n", - "fZ6SLZT2nsMWIpvw6/DrdVAIo9p91AWj/7x9nvHLOExKiXJQGKO1kjkd9ReqdbQnXvS9KBuRTHhK\n", - "GHH8NWvWSOrWpGjN83FAKfR7lfe7v03ytzYol9gD7Y7sg7W8VYmK2llrF6lIJUmSJEmSNDJVRcoV\n", - "gb61NMaq/DwU32mcp+af/vSnm/z8kUceKUn67Gc/K6mLj+B3h6d7Yn2ip273DlBw8MYjr7yE93Pk\n", - "xUeKmStq9Jc/7ePNOLQ3Umrw5qP+Jt4Abw+7i/a4K3khePXEM6A01saE+Tj5PBi6v1Sp5gvn5zqw\n", - "Pz9vbcyS1+Lx/ivtJcjemH2VrE0RVYkn1qHW9qmRhefPcakhBihS/L+kRNHXeP7eV3jEzF33kEt9\n", - "hNJELT6nVCmduQqluMtSvSaUB9YerwWIigwlNZv4xqifUV5qK9TX2hyxRNEaUwv9H9UdQ3GL4ldb\n", - "73lR7T36iTnKGo0qXIrv9fZgP9yriOHyecnaE423K7al64Do3lJag6J6WbU1F1ORSpIkSZIkaWSq\n", - "ihRPs5NWlqKn1LFwj52n2+jpmQrOxEahaJQo7THnigJP8zxVt74/dsUtglgwbwdewPve9z5Jnbd8\n", - "ySWXSOoyQiLwJqLr9yw+h5goJ/JOuI7ofHj9eLOHHHKIJOlf//Vf520HuL14O0rzoaQsomYQIxWd\n", - "n/nAePF34oDIEMJLw64feuihWcfj/5EiWVuqru8+d/PhMUb0Bb+XYmNQNrB9FC2yiYCx8jHlPMuW\n", - "LZPUxSqV9mxDiYjiHUtw/Og8pTXQx7A0dsR7lhSp6P/+95LiUFL8yIYbG8Z9//33l9SN749+9KNe\n", - "x2HtiMahFP/YSmkc++4lGB2XtYC57HGa9FuUbekwr/rGCXv/0g6UMu4prKXRPbi0jy6kIpUkSZIk\n", - "SdLIVBWphWLSGRn+VF7KPLnqqqskST/84Q8ljbdjOUoE7+Hx7vrGnnAc30OuBN6i7+mHV3HNNddI\n", - "kv76r/961vEd32sPVaCkqLXuVO+UYoIY77vuumvWz1ZQgNw7j7xv+jfqD+JWiMfxvR7pT+zU42Dw\n", - "3vg+3mDktaLekD1ZGys2STy2wT1iFAZsxT9PvJ7Hqtx3332SpEMPPVRSHOvCHOo791C+gCyvaVFS\n", - "MkpzEluM4h+937G9SJFhLWIcmTv0c0m1r1XXHTKBV6xYISnOYnM805jzR7FqHqPWF9ZAKMUGTRpf\n", - "w4iNYl65uh3BPCuNX9Sv9APzCTsrKZiZtZckSZIkSTJhnhWK1KTxp31XVGq/1wrvfT22xr1v3s+X\n", - "Mnd46kfRqn0q53x4D5GXT+ZL9P7Z/06cSCk+Ai+D62vt36G1SCKiDChUCPqL//v1Ylclr5V+oKaO\n", - "qyYch89xPH7Sb3j7qApA/5LRRjv5nqsqiwEUC9TGUgyKxz5Fn/daXIAN0feoe6XYENRpr18FUT2g\n", - "WrCJseLRovhElBiyHL2GXUQpJoy1ibpdpcr1Tqv6T/YZ2ZylbDbmmCtSKEZRHS/W0NoMa19T3F6m\n", - "pUSxlmD/zB/6EUWKeNSS8sr3o7jPEt6PrTUUI1KRSpIkSZIkaWSzUKRa6x9Ni9J7esD7QIHhKZ2n\n", - "9lrwSlAQeLp3b6j2/TteW9+qv6V4ELL1UNCIN/Dqw97ukoIGxOZ4Ndy+1H6P8cLLLGW+RNl4jD/j\n", - "GNXLYjxKWYr0J+qDe1+cj1grFCdX8hgHPof9EFfk1ZVRW1BfpkGk+pU8S5Qe+saz8yIPNlJQmDM+\n", - "l1FUyHbzStBetyo6biu18Y61eD8TA/O6171OUqfMlOpNRcdzSjXSSni/lqr/A/1W2/+cx9vr6q6D\n", - "PdXe67y/at+GTBrsOcrCbM1OHKPWXB/IXC6RilSSJEmSJEkji1qRYudpvBzqDeE9ogAMrQQ9LfDw\n", - "UQJaa4fgxbJnGV4W3jneFIpQKa4gqlZbAm+T8XHI0GDvO/ZWc9yLqVUkWxWoVujPWsUswvfdKsVx\n", - "lOqi0X9k67kag9qCgonihP15tifXxzigKDq0v7b2yiRACeibrcQYsNYQ51Wak309ZMaMOetjzf+j\n", - "Phxac2/MWl0bwxqx3377SeraT7/WKlIlhipSjtf8i5RL1p6+bwvcPkoZ3ajbfK9UWZvj0f6hWX99\n", - "KSlgrfbKGkcMVd9+7wvKk6vstQpuKlJJkiRJkiSNLGpFCqWJp27iCviJN1GbEbLY4Gm7pGhE+y45\n", - "XnEbLwVvivOVMn/ci6r1KnwPO4f2uALiuNe5WN77O8TCRQpcLSiHXGdJcUJJQlmMVBfa5f1H7BNq\n", - "CPMMb5bfqbHCdVKlOwI7cfuZRoyjx8nVVkbm86iNjAFquH+/NqvHKSlZKGNj15Eaq2adg43xlgA1\n", - "FNWZPfUmVXm8FeYO9sFcjOZe36w6t49S5XbmdO2a58db6DjikuLbam/e/668RXi/RRn1/J01EpUd\n", - "xZR1IOtIJUmSJEmSTJhFrUjxNI8HTdwCtUn8febmRm1sV23slHsj9B9P2XhdfWOJ+n6+5IVQg6U2\n", - "3qE1dgzvEq9j7IwPvJqhcSv0A/ZQUriiGjROVHUbr47sPvoFJYx2EE+Dt4ZKEmWl0g8eg0fM3qTr\n", - "c0ldLA6xJihJrCGlqvcoKMT63HvvvZLmKhEwqTo9JXW3Fdo/djwhnjtV/hmTVatWSZJ22GEHSdL1\n", - "118/6nkjahVIYrlof2kusxYxR/vaNHOH87pihX1Sr6pvTFmtYjOt+lJ9ITYKFT4aH9aYaO8/YH7T\n", - "r9tuu62k+N6YdaSSJEmSJEkmzKJWpIjp2WuvvSR1T6M777yzpPrYqKHVgEu0ZimNnW0Yvc/lqbxU\n", - "jTeir/dS2iMOvH5ULcTIPfnkk5v8P3aD98F5x/aG8R6HKlJeN2osO0W58vHDDrA/6j8Ri+eKEl49\n", - "as+DDz64yfNFak9fr53sU9pP5hLXMV81Z1Q1V45qx+jlL3+5pE5JufPOOyXFHmttDEXffSCjelhD\n", - "qVUzW2GMUC+JjVrobLLa2Bw+V9vPY2XoRvuRonxSA46acbVrcFSDjrnNvZDYO+yS629V/6E2lqkv\n", - "HC+61/rbBt+Tj3Zhl/xkvrPbhlP71iQVqSRJkiRJkkYWtSLF0yDeJb8Tt3DNNddUHQeviHgJjocX\n", - "UKrV4fA+lve2pf1/ovfhC1X3CC94aFXkvtA/K1eulCTttttukrrK13j7fYmUKIf367Wf78tYakGr\n", - "Mleitho3dhHVF8NO6ce+ClNtbBpKI/FJjB+xkOvWrZM0f7/7Hm++tx1tdw//gAMOkNTZKLEsZJ/5\n", - "HniA0sLc5icKALaPSoqKzudoH/+n/SgLk1aQJgW2hAr8yCOPVH1vUopGRN+1f6zzRWsxihcV78eK\n", - "ZYoqidcqpLWMPW7cW5l/tfcw/xzzFEWO+QnR261ahS4VqSRJkiRJkkYWtSJ13333zfrZCpkKZP0R\n", - "6+ExGLXgZUaKlu/fFEX+89RMfR48cJ6aeRpurVUDXo9rKKUdu1EA8d5RXFADaIerBVTc5r19K0Nr\n", - "76CIUPOGmKLacUBVoBYRCgrjHdU24brpB8YfbyyyU4+rAOIEUFWGUtpDErtvtTPm47XXXiupLa6G\n", - "vr3lllskzc168rWAPqfN9BXqF1lokQrGWPN9zsdYczxsiTWBSsqsRYwV30eZ8L4cq0L4pMFmmfuR\n", - "8uFjXFI0+saatYKd8LNVffaYnigO0eEewFrrGdjEf7JGcDzfp3ShGTsrkOuOlKgoltCzXbFH5iMx\n", - "UvRnpLLT/yVSkUqSJEmSJGlkyTNTKCixZMkSzczMLPRpkyRJkiRJejMzMxMqbalIJUmSJEmSNDK1\n", - "GKmPf/zjE88iQ/Xqq361Zo5wns9//vOSpN13311SFw9xzz33SJJ+/vOfS+re6+69996zficmjPfr\n", - "ZBIRe3T//fdLkl7/+tfPOu+k4TznnXeepK5ydimWq7Y/iX8gjuDtb3/7rPNOGrcX4laIO/AYpZ12\n", - "2kmS9NBDD0nqrp8YJ7wXst74yThznosvvnjW8YmD4Xdin4ibieIrqE1D3AkxS8QLvO1tb5t13knj\n", - "/UlcArFjVE5nHcDeuQ7iF7zGDvOJ8aFfjz76aF100UWSujGgL8j8ow85V1SdntgIzkHMCm0+7bTT\n", - "Zl0btss1MnbRWGHjxC9yfjKKOS/tP/744yVJn/vc52b1AbZCVhx73QHHIZbEM4WpOE57iGs8+uij\n", - "Z12fQ+atxzkydtT64/9R1h5z65RTTpEkffGLX5TUxY3S7h/96Eeb/D7jQj945XBqkrFW8X/Wlksv\n", - "vVTS3LnHeGBHDz/8sKQu1oY5RfsYN85DPzN36c+1a9dKimN/1qxZI6mzU89spj2MU5QRy7idc845\n", - "s9rtRBnlEXye/sG+fD5MGs5zySWXSOrmmfcn9k173Q6JNeN7xClH54tIRSpJkiRJkqSRqSlS8+0h\n", - "teeee0qS7rjjjk3+/9BDD5XUeYcoPTA0Ow0vyRUUvCQycHga96dgvNk99thDUudFkBngNT3IMnMv\n", - "Be+WekyrV6+WNNfrXGjw4vFi8coi77tW2RurUvhYMA5RthzKoBP1Q2TzeLHYAf2FV//Sl75UknTj\n", - "jTdu8vivfe1rJXVKJzVoUKTYK68vkX33BfugH5mfnl2J4kpGHZ+nP/DS+R7H3XhPQZQBV5o8Oyyq\n", - "VM5c9UxXbD2yTdqCohHtIsDxSvVpUHw8C8vr6eBBR550aexQU10BKuFKFLALBf140003zXsc3w+S\n", - "vc8OPPBASd043nrrrZLmKjCMn++7yjhh+zvuuKOkrgYh+Pe8H6PrpF2s2axdnk3oa0epUjZzN9pH\n", - "lrmPnZVqtJUqvPfNCPfPj70XZES0dyKZvtF1Mk6RIsq9upSRXCIVqSRJkiRJkkampkjNp1JEShTg\n", - "zUVP97X7LEUQm8H7dzxkrwkSeXt4CexJhneJJ+0xNRF4H3gneEeTqtRdC2PH9fi+ZniZtfsUOUP3\n", - "e1qsRBkfPp54tSifeEv8nf49+OCDJXX7wl155ZWzjoMd9q2OjSqAIkrMXut40l7sPfKi2XkAL9f3\n", - "ZnT1CNVh4+PRx7SVz7iK58dirnNujslPYqCiMURtZk64DaMmEzNDzA3KFZ/nfFEldRQtFDPWoNa9\n", - "+VBsmMNDK31fd911vT7vtkn76U9UyNaK2cwdFLJS/SYHVZfxd6UIJQ/FhLUd+tbEY85HMNexi2nX\n", - "E1uo3Tmie3rpHso8i2A+D31mSEUqSZIkSZKkkUVd2TyC9+7R0/5YMTZ4j7yPrvXIecr1GBDPQqo9\n", - "DvD0P7TS+VjQH94v//iP/yhJ2mqrrSRJX/rSlyTV77f1bMMr4bsqElVxJkZw6I70DjF5ZIahfLFD\n", - "Ovun1YLqgTLFddFun6945fQLqgvxQr6v3cbKlceZ1eKZlU5pP0TaGH0OpYI+JZsITxhFir4gVgal\n", - "zM+DkoVC1epR8z2UmoVSGCJoD0oSNoLi1hrTg831VXBcmXTIQOU8jD/9OHZmOnNo2krUYoG1JYpl\n", - "c8jiRP1mDY2+X9pHF1KRSpIkSZIkaWSzVKQgetrHox6Kv4fGKyrVRcKrJMYEr9JjrErgpXI+FDjf\n", - "U60WPHcyWOgn9jarhXgA+oN+4PpQVF73utdJklasWCGpq6USsfXWW0tq967JwCBz6Oqrr246zkJD\n", - "DB5eEeNM1lyUpVmKJaQ/iA+phSxYvHBipogPYa/JBx54oOp4nB9l17NVo32uXKHzelNk0m18ffwP\n", - "2x5brWuFOcJeX4xxFL/G5z0rCqWDNcFVvr748cZaO1thbUGNxzZas8PoR2yPzNCxIAuQGDNX9Fr2\n", - "i5S69lKr7vHHH5dUnvMOazT3oFY76YtnmxLTB2Qik6HP24t//ud/ljRXIYoyiGuVZxTgt771rZK6\n", - "NY74z0iR4rwlUpFKkiRJkiRpZGqK1BZbbBEqSlR3/cu//EtJXVzBZZddJkm67bbbJHVP1zxt4w2M\n", - "9dRN+/AOePpFQYiUArxivEWeamvftzoeW9XqNZKRg+LT6q27YoS3SPv+/d//XVIX20N/8X46ipVC\n", - "AURp6AvKxEEHHSSp6//vf//7TcdbKFAw3ZuttePIW2NcWhU+xgn7Y3zIQKuF757PlOwAACAASURB\n", - "VBE/QjyOe6mAWoPdEA+EPXGdXN/GSq/XOGPODo39Ke1qX1shmjnINUV9AF7XyePFUJJ8DayF8zN3\n", - "PFNyoaEfWSu5flekandLwNZQZ8eue0T/1SoXtTDnbr755kHH2VRm60KAEhfFd3IPO/zwwyV1andU\n", - "AzJ6VqiNFePtEHGeKHul+Re130lFKkmSJEmSpJGpKVLzZTP4flh4qGRI+Pto98KG1oQAvFrOT72f\n", - "yCsFvCm+z3W0ZnCQWUA8xdCsvb7v2Ut4f5ChxM/aGi7EzLR6jR67RUYHdjPtivCRquHKIF5Wrb34\n", - "PmOAt1VbrToCu2Pe9d05gJgo4l1QETy+Z99995XUxfBRAwZFC++QfkSF2Xg+8FnmzFgwpyMPtnZO\n", - "9q1j5EoCihFzirFFEYkqbJfwfRmnTRQHR+Xx2tgYr0PVN5szqqgNzAn2bItie55tlOwPtZsMb1cO\n", - "x4ZnBOI6vd7XUFKRSpIkSZIkaWRRZu2xh9mPf/xjSV2EPe+L8dJaMyJKcFze4+JtepZaBJ62KwF4\n", - "e143qARxFSgOrRWmFwqPF+nrhZcUvwjeg6MgkqmBPU1bkUJBcS/VVQ7iGkpxORDt68ZxvRZRLXiH\n", - "KIWoA56RUwIVoeTVoyBiN6gJrjjTH2PHRM4H11yKqZjUecFVQfqCMWbN4v+om/Q96qVnIrfGJY4N\n", - "14cay1zAFqM9BUtwHLfB0n6SrNWoqV7zjP6P1vbFkjW62CBe0tc2xr815i8CJQr7H5tUpJIkSZIk\n", - "SRpZlIoUist//Md/SJrrmaMY4aWMHQ/h1YZRoPAOS4oQT9N4eyg0PA23xqxsLu/b8YbxcvvurN0a\n", - "A4ZagLfNeJH9NW24Lvf+3Uvue/0lxaq1P+k3FFayZ/sqUqWdBvD2iUFcunSppLLixN8XQqHtq6qO\n", - "hauJrCFeZ4k+QJ2MatahmDAm/F7aa2+hFDkUNcaedrYqCbSbOEl/m1CKCSspSvyfe5Lb4tiVzX9f\n", - "KO1ZOXaF/VKF+qGkIpUkSZIkSdLIolSkHH96dcVoKNHO6ez5hVezfPlySZ2HHsHTNEoMCoTXlaqF\n", - "73Ec9glarPDUj4LRN9uw1etFiULZQLEcquQRc0X7o0rcJfBOI69/UrTuPck4ohL0zXjqe37UFyrc\n", - "M7+pMROxEHtPTmt/S1dEfLd6bIo5U/LkXb1323aPPVLhh8awMCe9Jh5rHYoaqqjHqdbaFJ+LsvZa\n", - "bRr8OlrjO5PfUZrrY7HllltKqt+jr0QqUkmSJEmSJI1sFoqUw/v8sTIiSu/J8fbwimr3zCNegads\n", - "4iz67tyNN0jW2bp16yRJRxxxRK/jAE/jXDc1Wth3aCx42u/rzbd6idQuQUmk36P9zPoed6wYtb5x\n", - "E0P3jWtVbrF7VAsU0do99qC26jfqBnE77PHHPmPR9W9OmVHE+tSq6h4/56omfdY6xk888cSsn762\n", - "oUjxd2yC/T7pezI7a0FZ8nhRrsPjS2lfX3WVtfOKK66Q1PXnbrvt1us4EcwJ9lBM+rFs2TJJ3bi2\n", - "jnMt3Ov63oNLpCKVJEmSJEnSyGapSLXGqETg/ZQ8ZryZ0tMstU54qsarG/qUTcwPilwrKFJ33323\n", - "pPHeE0fnIWZp0hksKE+33HKLpM4bHVrZG6aVgYMS1jc+BGoVVId4Feye+I++yiXtd0XX5xsV9zkv\n", - "daVKcTjTil9qgba2xhYxlyYVZ+d9ydix5vJ/VN9WuH6vBcheaFwfc3hoLBNV8seGNWHsuNVaFXdz\n", - "Z6gd9WVS2bepSCVJkiRJkjSyKBSpVk8b8GB539rXW6tVGmr358HbIsaDGBe8O+os8V498k6p1P3K\n", - "V75SkrTHHntIiuMRSlV6yaIjvgEvjf5vVfp8/BgPMntcmZo0Q2OiFhqvIA4oMuyvRv8Ss1WaL/T/\n", - "zjvv3NQu4hX8eH3xzLDSfOO8jONC2c1CMDSeixgPFAt+sqbQZ7X1clijItV87Bp9DvFwgGKArQ1V\n", - "gbE9GDv2hrcTffefLEHsFeM4VJGrhf7qu1fjtCjthbhQpCKVJEmSJEnSyJJnplD4YsmSJZqZmVno\n", - "0yZJkiRJkvRmZmYmrBOWilSSJEmSJEkjU4uROvvss8OMBN4PU9U2iuwvvR9F9frkJz8pqYshirLu\n", - "DjroIEnS6tWrJUk333yzJOmuu+6SJO2yyy6SulgPYlqoF3X66afPOu+k4Tx9z0eMFO0vvX8nDuMj\n", - "H/mIJGnt2rWzvkcWIZ+L+pf9rqgVw/t/vs94M/5HHnmkpN/ZilTOYNlqq60kzd0hnhgu4kD4nfMT\n", - "p3HSSSdJ6vqTdvl1ErfhMWXEOhHn4fEYxI5xvve9732SpLPOOktSFxdSim/hONEec/QDsYJc7wc/\n", - "+MFZ1zcpmJdnnHGGpC7Lj6w8vDquY/fdd5fU1acic4uaS8QYEoeCfTGfjznmGEm/G1+/tu22205S\n", - "t0Zg8953xB7xd7cNxoZ4tbe85S2S5vZlKdvq4IMPltTVY2KNcZgD2Nqpp54qSfriF78oqYsjo130\n", - "EWuRH4f4SPoBG6UPaTf9QJ9Oey1jTcCWPWaK8WWOekwXNsbcJYbszDPPlNTdG5jL9Ce2xpoRVdzm\n", - "uL4WEN9IzNGxxx67yevDnjhf7b6kvv+s4/0ZxSHvuuuukro12e+1tN/jaH0covFjLaCdPi+wN+6t\n", - "N9xwwybP7xm8xx13nKRu7eS6OF5rdp6PP+095ZRT5v1eKlJJkiRJkiSNTE2Ret7znhdm1/F0jDcY\n", - "PWXWhnfV1hG6/vrrJXXKCU+leHF4M7SHv+PtbS5EikmEV/R2b55+KCkp1KtyBRGFAQXCx6u2loor\n", - "UcDx8OJoP144mUuOe5ml+mGl6s6c1/cXYxxqM60iJQq8H0rZdn1r1pQ+7+NLvbKo/tSdd965yb/j\n", - "nZe89EsvvVSSdPLJJ8/5Hxl/payeyINF6WBsUHiANYLPRX2ydOlSSdLRRx8tSbr88svnbQ/n8+NF\n", - "mbWuRAG29Ytf/GJWOyM1v2RbkwYFwtcmV0AYBxSVH/zgB5s8HmsXCqDvk+r9ieLBvYWMY1ekOK7X\n", - "wQJstlTDjXZFx3FoP0oW7eIeFGXbRWs9ClS09vD24v77769qH6DUcV3Yldsz8y6qzI8iGO33SX/Q\n", - "j6x12Effiv/c26G2AnoqUkmSJEmSJI1MTZGqqfvAUz31k3hP6jFKtU+NpT314Bvf+IYkac2aNbP+\n", - "zlPv8uXLJXV1oGqPu1jo63X65/39PN5MaS+60pjjVY9VMwW1gHZGNXxKdadcdaiFfsI7Qhkba8++\n", - "WsauDN63Fs+kqgnDfF7n0Poy3jeuOnocXQRq7JVXXilJ+uEPf9jrvICHTp9Sa452EaeHYoGSQ804\n", - "vu/txUbdIx8KigTXU3qLQLuYO9Gc5bgPPvjgvMdjbeprB7TX1WPwPQ8jSmsLx+m7V6GvIVEMV4mS\n", - "YtNXiaJd22yzjaROIXrkkUckxWsR8ZMO6jpvifxe62sR9tM67/ke41K75qcilSRJkiRJ0sjUFKk+\n", - "VbSJoSCGhqykWiUKRaGvZ0wGAd4aXgpeBt5Sa7VispXuueeeWcdf7OBluFI1dE87vKPW6sN423hD\n", - "KFy00+MsiF8oeWVcF95pabzxlmkPqsW0qu/2VUyJU/nc5z4nSbrxxhsldd7/NddcM+/3fS/ISe3k\n", - "DltvvfVEj78xHktSe214tldcccW8n4uywMAVEtY0jo9tRhm5tN+VIeZAbUxJ7W4U2HxtHJ6vKfSH\n", - "Kxms/aV7QGuZRGJvuOeUsuQivHJ7dJ7atwR8blK7N7Sq74A9YEf019B7A7Ffvi+s2xP90roLg8+7\n", - "2vmdilSSJEmSJEkji2KvvVrwPnjKrX16xptp9Yx5uqa+FApVlElQC/WpyAzxp+3Fimei0A+uuJDx\n", - "4bV5St6XZ0bVwp5yb3jDGyR1tXZuv/12SdItt9wy6/N4M1GmC94w7S21G6+LWD7UAffeFzozqq8X\n", - "TX8Qt7By5UpJXW2hm266SVKsmlDbB0pe+VCGbM6wYsWKWT+JCXnssceqvl+r4DBHiGny46N8uG34\n", - "XCDWBPzzpfaMtZEFx4n2iXSYA31V99b9P6FV5UeBYm1nfPq+1fBsPF8LSvekkmLVN+O2BG97Hn/8\n", - "8abve/wy9zT60dvrylEUQ8Va6v3AvEKJ4vio6rV1uYDxYt65uh6RilSSJEmSJEkjm5UiBcS67LXX\n", - "XpLmVgd2L2CsLDBqbuy9996Sxsu+2lyUKPCnfrwLjx8hdgWlCEXxe9/73rzHr62p4qxbt05Sp6Bw\n", - "HGLQ+kIGE5k5XCfZm4D3QnYp3jr1k2gHCuqkY4bG4sILL5z1+6pVqyTNjTVzGAfw2j1j4+PRB5So\n", - "V7/61ZI6G61VpLwyeLTWlOIpa+M9o+O75zxUySmBYkP9okiR2nPPPSV19bz6KgRObWzWUFD2uK7W\n", - "zFMfB7IpPbYtYqeddpr1+7333itpmM1vCtbMl73sZZI6+6edfddQ1kC/PtRpKtbzuaeeemre46E8\n", - "+XWj/jMPsYvWGCnWapTWUh0wSEUqSZIkSZKkkc1akYqykTxWx5WjVoWKp2EUJI5b8tB/36AfSrVh\n", - "8Grw7mpjg1q9LRQx6oANBa8GRSWyG1QNqizTft7bc93YS5TBMjRjZtJElclLRFW3x6KljhvV7PHE\n", - "iQl56KGHeh0HD7hkI7VKimeG1sZgYXN4+rQjWpuiDFQ8/BJcB2sAe6WhPBELhqrLeYYqUtFaM6m1\n", - "uFYpjPDx7ru2kYFM7BKK1Ngwh7zSOfbUF5QnX/N5i0Glf+Joqcl42223bfJ4rI0oRcC8o3+492Nv\n", - "pRgzYt+IC0WB4zz8v0QqUkmSJEmSJI1MTZH6oz/6o2LF5Qi8jlrvhqdZGOrxkw3Gcf34v+/U1kOq\n", - "3SvNGfv9f1+8ZkypFgreDu/X8baoJk39pShTBfvB+yvFC/RlaA2XoUx6PFviV1BeUFDw9PvW52Et\n", - "Ka0pjDmxTJFK17fWmGdB4YmXlJlI6eob94ltEyeIZ4+Sg7LRGrPiRIpUlLXWt06Tw3iU6ntF1Gal\n", - "RbBH4tVXXy1prp211rcC1iyUQ+YDcaE77rhj03G5TlfZqcCOYkXFcuZjpJT6HpEQjTtrHtfl84Pj\n", - "kWGMHbNWcc+iFmCJVKSSJEmSJEkamZoiNYaXXPv+Gq8AL80j8fvW4KDt0Q7tyTCmHSOEF+XeT5TB\n", - "Qe0hMmzIVsQrw14ibxT7nJQdTTtLsFV5rqVlLSEbC8WB2JBJgWdL5iO7Jjie+epgK8wRYk5QEGqV\n", - "F2wUBQ5PvK+6h21Ftdjw7MlWmxSRjQ+1fY8H7RuL1Xp+1h7icX1cUb1Rr1Gk+tZsw/6ffvppSZ0C\n", - "NrTfUNe5DuwKRc/3dsSut99+e0ndbibA/PG1hDWZ47r6jWLHPKF/UKb4vn8Pxbb2bUoqUkmSJEmS\n", - "JI1MTZEqeV411O6YjcLAU6tX5cUrq33PTCVynqpra85EDH3P/fsGmRxjw/twvK9I+cKLwvshnoVM\n", - "pAiqTuM94f0sW7ZM0txqvzB0z8bFzqSzWvE2+4ACFXm6Ea1V2hl7drNvhZgf1gpXSkrXwedY+4j3\n", - "hLH3g6R/ae9YlbhRMErXy1xuVblRgojdQamptenWel6MA0qjgyLl49da29DvYdyT+o4TyiPZbvQ7\n", - "dsDxuHeiJqNgUZfMY9u4R/tbAvqJ9jMu3PP5P+OG3bPWEsfq0E7uFSVSkUqSJEmSJGlkqjFSpfew\n", - "Y3kvPF17zQieVvFuauMLUNN4+h36PjmVqNm0xlN43Se8uTVr1kiqVxDxIj0bs+RdEiuFt8j7dewY\n", - "e6vNBEnqqInr8awrxhabqVXI/XOMJWtHaS2I6lSxNqF4RZ4wa47vXYZnT90hPG6PI8Wjj5SOvuph\n", - "KWaIv6PosBZHbxNqY5BqFUTWgtbMUdZmzldb6boWYuaiGm3ebsaPWCYnilWD0j2VtwEcp6+ixnFR\n", - "8b2WHlApHXsgvjTajxTlzfeexI7cXiIFks9z3rHeAqQilSRJkiRJ0sjUFKktttii6FXgxeA91So3\n", - "7jVECkTklZWofW/6+wpeQW3V5b60KjbYE14osWy082c/+1nVcbA7aqjgPeGt4WV5zaH99ttPUlfl\n", - "mfageqAOTLquknudXg14odlnn30kxVWLS6BQRvO1JkbKPWs8WBSQVlWYtrWOKbbGHmeomhHU3eF8\n", - "eNS0H9UzymhGUYuyFPvWxCvFVHE+fpYUjtYK5Sg1vttC37pgEZPKPHUFE0WS7DXqm/G5M844Q5L0\n", - "n//5n5K6uk+1UAE8+h7nZxx8D8cSrLWlewPj45XDS/bkx22NOfQagUNJRSpJkiRJkqSRqSlSNR4H\n", - "niZPjbUK0qTrOpH9xfvW1vfm1NDwGA8UhNqsxFaIq8ALwRsoeV9kr7k3hbfD9fjxfT8yvCIyNfAq\n", - "3Svuu+M7ihleO3Epte/78fLJwsObRomMjkNcwK233ippbq0ir/kyKciA4TpqM3lcyaLa8ND90Xbb\n", - "bTdJ0s9//nNJc+0LleXVr361pM6+GDf2xVu3bp0k6fbbb5fUKX0bV1/2a/XsHVctUT+xPWzVs5b4\n", - "v3vMqJSMdRSbwXG9QjNrHBWfS568x/8xxqwlzJG+yg7t4Di11Noy7S2tzbXKHvtaomgQQ9O3HhgZ\n", - "tcQEsdbQz9TbYk1h7rPWsUcjdY/8+kpz74EHHpj1O3OQe8Ahhxwiqetn7K01G7CkYHFcriOKxRoK\n", - "/ed1oLgXbG772KYilSRJkiRJ0siSZ6aQMrZkyRLNzMws9GmTJEmSJEl6MzMzEyqwqUglSZIkSZI0\n", - "MrUYqXPOOWdDvEHfGBgnqnaK6vWNb3xD0twIf+ILyJwhQ4FYlug8fB7IkDnzzDNnnRd8B2yyybzC\n", - "teMVz71mzOmnny5JOuussyR1sSK8dyfegc8Tw7PDDjtI6uIDiOmh36hFw3trMl8++MEPSpIuvPBC\n", - "SV2Miu9kv+eee0qS7rrrLklzx7V2vOlHfo5VV6x0vi984QuSulgj+sV3RscOiKPAvrAT4jeI+SH+\n", - "gziYf/iHf5DU9Sf9TTxNFAfB+aJ4B85HfAHjdPzxx8+6zknDeS699FJJXW2YKNaROBRipsi2Ja6J\n", - "+UnsFv9nfp166qm64IILZv2NvvbYJfrE48BoAz+Zo8TJMSeZ65/4xCckdX2NzXhm77777iupi8Uh\n", - "loc+wWaIgSFminbTl//yL/8iqRt7j/0itobrYu76WkOtM9rDT7IQTzzxREnS+eefP+v6+8J1MecZ\n", - "Q/qL8eH61q5dK6lbu1ij+RxrE2sB101/+Zrie7kxfu94xztmnXfS+Fq22M9H7GApZo1Ysg9/+MOS\n", - "pEsuuURSN15RHSxi8vpmVRI75fc+7Ar7pV1R3TbmN/aAPdIu5g8Z26V+TEUqSZIkSZKkkakpUhtn\n", - "v+BdtCpSHAulxb0vfscT5qmW8/H3UlYg5+m7Q7pnq5Wy/Ki7Q9YYT+0oMZ7Vhgf/ile8QlLnpXm9\n", - "JxQOvGCUNK6b6rIHHHCApE5puvvuu2edr7Q33B133DHv9UXjTHYWmTDOpLMxgf7CS2G83D64fq9K\n", - "jNfFuKFUYXe+XxvePv1SysgpZdG5l9eyF53UKZZ9M6Ec1IIS9LtnMgH94vu3bZwFSF/iCUd1kfgO\n", - "Sgy/R6osx/UYCfe4oxpzHIe+8MrNnLeUJcXciHZhIHuwlPHre7SB2/jQPVE9y7G05x3XFfUjay+Z\n", - "07SPccbWXWlbqLVjsdGa/VabPelri8+jCOpk+VrF2hjZnV8HayZrMWtvZN8QZcdif6W3RU4qUkmS\n", - "JEmSJI1MTZHamLFqRbiXCSgzvjeen5caFrUedC3uxeJt4fUS07Jy5cpZ/4/eH/vTvtcp4mmcuABX\n", - "OPi/P7Vz3fQfMSh9n86d2piovlV6JwVxFXg3KFL0S8lb8/HxWDf3yvEaS14c9N3JnvO3svfee0vq\n", - "lCDOf8sttww6bl+89gwQcyjNVR6i2KhoreD7qLXY7lCItRhKaQ5F9a5aQSGgXzj/WMdHra8FJcH3\n", - "agN+r903tRZicOgPjwudNJyf65vUrhJ98XsDylBkp9iNv+UgJmnnnXeWJP3oRz9qak/tWkf8arQD\n", - "QF/mXSV+8Ytf6OCDD9Yuu+yiXXfdVf/0T/8k6Xc3+MMOO0wrV67Uq171qlmNOe+887Tjjjtq1apV\n", - "uuqqq0ZpZJIkSZIkyWJkXkVqiy220EUXXaQ999xTv/nNb/TSl75Uhx12mC677DIddthhOuWUU3T+\n", - "+edr7dq1Wrt2rdatW6dvfetbWrdunZ588kkdeuiheuCBBwZ7dXz/r/7qryRJ3//+9zf5uSi+wP/u\n", - "lbnxXsZWoiCKJaJdHqcR7QQOrqTxlI+SwtM9cQMoKKWSYRyH46Pk9a127NTGwOH1Ev8wLeg/f+/u\n", - "ewCiJJVi6zgOXpCPw9A4lBKtlfeJjeInewhGMUwRKEmt+2KRCUc1ayqcw8ZxUK5+YrvEDDGWrAEo\n", - "VB4HhuKATQ7NLB4L+oK1yhU4FBPGHJUbBaDvnoD0F/3E8aMYJldfI7CJoWqpn2dSa/hRRx0lSTr2\n", - "2GMlSV/72tckSZdddtlEzue0VjJfrJXBXTFkvt18881Nx2Mtju61zAfuaSUlivWhdjeVeZ9wttpq\n", - "qw2p7M973vO0884768knn9R3v/tdvfnNb5YkvfnNb9YVV1whSfrOd76jY445RltssYWWLVumHXbY\n", - "YcHl/yRJkiRJkoWiOkbq0Ucf1c9+9jPtt99++tWvfrUhnuhFL3rRBi/gqaee0v7777/hO0uXLh0l\n", - "7uXd7363JOkNb3iDJOnqq6+W1P4enKfRkjfkNVA83sLrQ0WUvNnarEHwdvM0/+CDD0rqvDK88dri\n", - "9Xgvnt3o8RBcNwpLKYaqr1cUKRdjx39EYFcoRYwf5+3r1QNxDrV7343FWOcrxfl4rSDoGwfjoF5Q\n", - "E8bHfz6ly+cmnj01wFC5UINRWqIYlCgLcKHg/FEWmnvkQx1Z5gJKlCte2JbXh/LYM4c1JnpbwXk4\n", - "/1gbcFBnqC+sdcQLPvzww5I6ZWrSa9KkYT5gV61rHPbZ997M+LLGl/Z7dbA7xpe1m/nPddXeY/vW\n", - "t6p65/ab3/xGb3zjG/WZz3xmTjHKJUuWzPtAMlS6TZIkSZIkmRbXXnvtvP8vKlL/+7//qze+8Y06\n", - "9thjdeSRR0r6nQr1y1/+UltttZWefvrpDVkzW2+99ax4pCeeeGJDFeb5IPYEL8e9Kqr1Uj+HGJYo\n", - "JsornbtyVBvngJdBfADVgIm34H1rqWbL2PEV0cMp/cN5Su1yPJMJJcEVJfqTduCN+nt8Hrqj99YR\n", - "kcJX6/XVVkBH6XDvA6/Fr7uvl+TgvUexVlzf2NtftsZIlfCaL7Tb7XyoIkVMFMf1/tvYLvzcke2h\n", - "Yt12222zfi/RN2NybFiDhtb2qoW1j7nEHOd3fjIGtXOUtSOyTWxm0vGDtbA7Brs1/OQnP5E0nhJV\n", - "+3bDawOOxZo1ayRJK1askCRdeeWVkjrlrdQewF5a3xbttttukrpYqb5rIf1X6kdiDVn7S/fmgw8+\n", - "WNdff334/3kVqWeeeUZve9vbtHr1ar3//e/f8PcjjjhCX/nKVyRJX/nKVzY8YB1xxBH65je/qd/+\n", - "9rdav369HnzwwQ1bIyRJkiRJkvy+Ma8ideONN+rrX/+6dt99d+21116Sflfe4MMf/rCOOuoofelL\n", - "X9KyZct0+eWXS5JWr16to446SqtXr9ZznvMcXXLJJVWv9ngf6xWf4Zvf/KakLp4BhcoVKb7vXkJt\n", - "LE8EygReg+95x1N4RF+vBUWNp2R/Wo6enlGAhipgVA+maq17jXhDJa+I71F5PdrD0GlVZNinDG+o\n", - "VIHeK4oD7Wa8vbp1hNcocrguj7PBPlCmxlY9avu9FuzM+43rc2VyaE0fP09r/MamKClRk97fsS+u\n", - "AEwabJqx9fg36LvGMUci2+i7e0Tf8/YFO2nNPC1RmvPcR1FSxlKk/O3N+vXrJcVZmcC9we2hNgYp\n", - "grWq9R5Qmqdk46Fqj1UPbN4HqTVr1oQ3YwK+ndNOO02nnXba8JYlSZIkSZIschZFZXOIPP77779f\n", - "Uld5PMqcib7vMRV94WESbwSPGG9q7IwNjlcb24LXiFLH763xBZ5J05owQHYkP1v3faoFbwRlirpH\n", - "xI5hRxB5T16dF/sp1cgpebuMh3txUcXzsSgpOLXxGYA3WpuR26oulPbd2hS111JSDwE12yueL3bw\n", - "vPtmHznMBWyf/TCHMi2Fb9oxbq2wRpSUolawExSa0j2NONrWfTwjon1Wa/HxRXEj5o7fx1S1pdxr\n", - "L0mSJEmSpJlFpUiV4KmyVGnbFZWS91PrnfpT7KRrh9R6bfQHXihKFjU1+r63JguTDKGhe+1BSYnC\n", - "60V5dKLYL64XBYN2o0gRS+eKVIRXLKcf6V9Uib5eNd7SpOI/IjwOwsHbrVUM+9aG85jC2ti9SIki\n", - "axelcWNqd1GoVUXpm0llPvalNsaHGBpXUbFhbLAUi4LNEpuF2osi8cgjj1S3fWOwtcUSe7a50Brj\n", - "FWVWcw9jTeNz22+/vaROoYpiiYbGRE0azybF7oYqtU4qUkmSJEmSJI1sVooUT8WlzBX3eEvvxfHY\n", - "8VKnvZ9WX/CWUezIqsIb5Wm8dr8mvM5ly5ZJkm644YbR2jofeMdR/SuvUcL1esVwxpGYtqjeWATH\n", - "w2vxDCPOgx3WemW+g/tC4UV0HfprUqoL/Td0XmGXL33pSyV1Vbs3Vkw9CyxSwfg7cz9aI7CBxVJY\n", - "uLY2HHOJ+D7G2Gt+1YLCRYzOUDWe+oJ9a8wNZWhNs80N1PRIkQKUxZ122mnW3yO7L709WChqYyKZ\n", - "/9jx2PXJUpFKkiRJkiRpZLNSpKhwXKrb5JSUmNadtWvpmxXVFxQSYqU4D3EMfbPkUCZqa4qMTdRe\n", - "shJRIGgn7/dRLNmTrRWOS80WMrdQA7A/lB76ueTl4w0tX758UPv6Uqs05L+doAAAIABJREFUTSpe\n", - "xeM6Wuuc7bPPPpI6FalGnaGvvUIzx6hVZmo/h+IxtHZWRGm/Q28HtsrvfXc7oAYcqisKEmPY93pR\n", - "SJhbC60QDd2dYHODe4JnIHvNOhSau+++W1IXb1q6124qTnEhqb2n1lY8d2rXzlSkkiRJkiRJGtms\n", - "FCm8nr7e3tj7EvWFp3+8WjIiarPIHI95wUukKmxfr9NhHy8UHvfG8UZ5WncFyWvOoGh5bBGZQ3y+\n", - "5C1ynlbvwqEGiu9UjzJD9iJeHN4d3hrXQX+UaqDg1S+0F16rpqA+ML+ID0K9ieJi+B4qg/cD/UM2\n", - "5RNPPFHddqnrZ5RdVJkaBS3ak442Da0n41lxk1KioFY1RGFgzrWC4sC+lGRMogL3vV4+T+YnCtVC\n", - "sVizBFtVWvqPtcl3MSCG6b777pNUtnfWdNbG6F6Cvbdm7a1atUpSOSuwL6zNrNlR+0tvifg+b0FK\n", - "pCKVJEmSJEnSyGalSDmeUUAsS986PUP3pitBDBZKEj/xFn71q1/1Op57cTx1R8fhKZ2ncLxVvA9+\n", - "p12PPfaYpM5L8EryeCM8rePl8TvfQ5nwyt0oT65w0B9RjBTjjTfD+3u825JXg5eFUoZ3TVwAEBsW\n", - "2QNKFUoNx0VxYRyi63DFhkwZvkd/o6RyHN9LEbUBxQ+vlB3US+0AjhN5aaUMLcYTb9gV05UrV0rq\n", - "skA5fqk+GeNM7SOyL+erY+XqWaRAcEzUNI7ZN8OQbKiS6s35YOw6Ng7XH52ndv9Lz/aDFStWSOpi\n", - "0H76059K6sY0UkFZuzyb7NmC17xjzUPNZc5GSiqw1vga5HOd8WUeeMyPzw/WAuyZ/3N85jKKpCtS\n", - "zP1SNiYK2VBYs1jTsSuUVFekPL6VtQg7ZN6zlta+zUpFKkmSJEmSpJElz7RuszzkpEuWaGZmZqFP\n", - "myRJkiRJ0puZmZlQaU1FKkmSJEmSpJGpxUhdcMEF4ftH3t/zHtlrwNSC6sVPsn94D0oGA+/7ySaK\n", - "sseITeE9LO9neR/70Y9+dNb5Jo1fXwT9OLSaa+35xoLznHPOOZK6ceI9PrFNjANxIXvvvbekblzI\n", - "yuM9OPEIjDdxBSeeeOKs8+F9eBVmj10iZgo89od4BmL4yFx605veJEm66KKLJEnbbLONpC5OgvZ7\n", - "ZlgEcThcL9mBxOideeaZkqTPfOYzkubGElI5nPlBfI3HXZDRwvwh7oJxYZ6ccsopkqRLLrlE0tx+\n", - "4bqIVaM9feuecd7TTz99w7UxRvRZKc6LayhldRErctJJJ0maOxeGzjX6jtgZruPkk0+edT7iEek7\n", - "YkGiuj5R7IrbJrsBHH/88bPOB8SYEFtS+0KDfsH2PVbnjDPOkCRdfPHFkrrr53vMVY8DJTYG27/j\n", - "jjtmHf+Vr3ylpM5GiBn627/9201eH/cI5jyxc0MzvznPueeeO+u6/F7EGsDcJS4Qu+D/XC/xrNg3\n", - "MUs+92g//Y/d0J9cL+PpsXPYB/bC2ks7TjjhhFnX2ZdS5XWgH7jXnnXWWZK6+cBxaL/He65evVpS\n", - "F0/rNQk5DvcI4k/f9773zd+uef+bJEmSJEmShExNkZqv/ghP55F3iBdSqtvj8HTqWWg8vZbqGOE9\n", - "0C68vFL20bRx75gK0Xhbk6pc7nvftYK3hYLhey0yrngrVDYnswRQPFBasDMyX4DxxTvjc1E2aGn8\n", - "8abxglwdwYvES3VVAQWo1ltDNcBeXTXw60BhpR9KexPSH4wH/cVPz8SK+od2tVbgh42/h+LSdy+4\n", - "2vpCpTo8Q22dsWDsouwnbKGUqcz/fS4AtukZvRGtlcH9uNH4cN3cHzif13oD7gF+L2A8mUvYtvcT\n", - "awmKDf2AIsb5x6pFyJzh+nwOlbL12N2DrLJShno091zZ414QVfLGfrwumdtDrbLk1H7es2lRiN2+\n", - "ovpQrG0+r+h/+ovfa+vMpSKVJEmSJEnSyNQUqfk8Rp5+oxojxHK0KlL+tNo3ngHviKfV1sTH3Xff\n", - "XZJ07733ShruzdbCeWqVKK8LVAvj595wqVK2g9KCchPV+MG7K1XbxevCjtw78fEca38uqkNHtXuI\n", - "T3G4fpRErypNP1Mp3/dBczzGiXGIVIsI7yfUFJS16HzO0GrgG9eT66tE9cXVS2fo+Wtr4LGG0Xd+\n", - "Xjz1/fbbT1Kn0kbxpqxpkTKAUsOYD12roj36/O/MPVTWvms1n0dh8jmBYofixNrBXOxbhb8E10M7\n", - "mDP8vfZeUmsnzD1imVjzWSN8HCNlFiWK44H3J/38yCOPVLVvKKzd2Adre2RfpfpW4GtjiVSkkiRJ\n", - "kiRJGlnUlc15f+07mT/wwAPzfq92x+ZayMry981E+PetTA7Eeu2xxx6SpK997WutTezFnXfe2evz\n", - "rft1ucJx0EEHSerGr1YRYzyJd4i80pe97GWSOtXghhtu2OTn3Isvebm1XkwEihFeYOTllLwo5sOe\n", - "e+4pqeu/H/zgB7M+75lArhBxHP7fN54hgvO6ssZ5mL8lhQ8vvXYfLzKQWui7qwEKRl/w1BnL2tiL\n", - "SFWkvVEMDOpnpDw42GS0dqKA+W4SQKY1NllSViJbJ34xshG+RwYvCkpUKRsFzpUL4DxcF3OV3znf\n", - "WDFS7GLguwlwHsazr/JGxXG/N3J9HvtTUlYhirsE75colg08G3IoHss0dO9MxqFv/6cilSRJkiRJ\n", - "0siiVKTwoNnHiadh3leX9odqjemJiLy+obEdKDY77rjjoONMmrH2BeM9fd84EuI98DaiWJ7ttttO\n", - "krTLLrtI6t7Tu73gneOV+Xt/BwUnirErgZ2UYrxK/XLddddJkm6++WZJZa+J6/MsVbdblNVop/Ra\n", - "Ssod/VhSpPoqZEOyZvvur9mqdpf2oIsotS9Smh588EFJXRZYyWaxCd8T0Inaj23XXl80h5mLvueb\n", - "t/Oee+6pOg/H4a2CZ/x6hixqKMojCkurIuXKD7bNcVFUSjbPGhgpPlF8JfdOn/MoTaUsO+wvyhz2\n", - "uRzZGd8/5JBDJHX1vu66665Nfj7C1fWx8X6KFFgnFakkSZIkSZJGpqZI/dmf/VkYA8FTMB463sD6\n", - "9esllbOA3NuJdrUfSm0MRwQxPGNnhiw28Iqo4dHXq2CcSwrM97//fUmdd1ZSLqPjeVYhKkStd+Lg\n", - "deIFRtQqdbXv7zmeK0XuVdbGgHnNnb7UqhWTzrwbQm29Kac1s7fvmuUxX7XfxxNvjQEbK86O9qKU\n", - "DI1NQrGjX1yddfg/cx6Vu7XWnitSrWt9KfYo+j9zyZVNX0NoJ3Pc76EoqiX7iN7SoAxSmZ17eF9F\n", - "qnUN7ovHsJVIRSpJkiRJkqSRRRkjxXtXnm49vgBFozZCf6iH2zezpy+larYlJt2+VvAqPWOJOAy8\n", - "z+j9PtQqMHjFP/7xj/s3diPwRrAbVIjaGJ8I7NczhyaN24XvK1erWgxVB4YquIuBVmVpoRi6BrRm\n", - "6I4Fc5i55rsjRLFCpdp0rLHLli2b9/zMbXYhoNZcqxrbGkfLmkm8L+2Pri9SUGrvfbW15FCS+JzH\n", - "DEZrCXOf2L3WNXRoVl4tUQ3LiFSkkiRJkiRJGlmUe+0BMS48zeKN9FWYeEpv9Q54Oo1iSSadSVBi\n", - "0kpUKbYngvfZtI/9ofDy+lbSrmVo1WW/XuwGr88VnVpQoqZtL5OuoB/ZS9/4hqExWZOgti1RnaRJ\n", - "gzKD6ts3o3Gh1dIIlAfmGjYbrXUlRQoFy7P0HDKUWeupID6WDdbu6sAaSUwR1x1VDHfFDsa+N3jN\n", - "RM+CLEGdK+4Fk6bvLhqAslabpZuKVJIkSZIkSSNTU6Rq3pF6/SKefnm69P2YInivW/IOo4rKeGmu\n", - "SJXqD9XSt5LzQsHTfKuXihe3evVqSdIOO+wgqXvaH1q3aFKgGBGbRVyM/94XFK3WzK++4J36/Jh0\n", - "nE+kSPX1CheTEgW16uxQJYrz9I1Zoo+ZY2RZ1aq/Y1WcHoqv8RDFyNTG3JTUWFRT5s7QXQ0cj7+M\n", - "YPyYq0uXLp319yj7L1pTPdasFV+7+lYA57pRbFHcyOgem9b4aOysNlYqFakkSZIkSZJGFmXWnsPT\n", - "q/+s9bJqK3NHihDeAJkcgBc0VGEgM2OxKVI8zQ/NeiQTh37Cyxvb22vFY3f4HSUOLw5vsG/cAfEA\n", - "KKqRWkEsH95jVJunNkaL/nUFyuuqoawOVdyAjKPfRyJVeuxsImwsUoNLmbrYGGp3LX0Vhlaiitoe\n", - "h8jvXKfbfF+lpWTbKFG0j/4fK56zbwYyc5SYN/qlth4V6jo/W3epYE1kT0WUy751zlCZGc+x6kK5\n", - "gtuaFQi19aM2nH/Q2ZIkSZIkSZ7FbBaKFN4VGRTE7gx96nRWrVolqVMOUL72228/Sd3+QDBWrAve\n", - "FPtBoQDVeg881eNtoYDQX63wlB/tQF8LNVBoZ2sW4KRwLxXvzWuzkAFVqz6whx1eLdftmS9Qq3jV\n", - "2l3kffvxuR6ul3GKvE2PvfJ5OGlllfHwHRCmwaTr2kQVq0s28sIXvlCStNVWW0nqFJWhaya27Mfx\n", - "NaIUIxYpSCh82DhjG9ly35gfjyHienxPPpSTsStpu5KI0uRrPVl7xJfS36wpN910k6SywsW9gH7k\n", - "enkLgsIa2QXXT4V31GYUKc8SLIGShuL3+OOP9/q+w7MA9oIC69mqzAdfO6Iahn33VV1cd7QkSZIk\n", - "SZLNiM1CkQK8qpI39hd/8RdNx1+xYoWkzishNqr1eLWgULTWJ+J7tdVpa6Gfh3rdvO+/++67B7dp\n", - "IUCRouYM3gxKS9QfeG/RvlV4vaXYsEkrLNHxaXfk5eLF4oVGcRqebYd3TYwhKgLerSt0keoBfI//\n", - "962V1AIe9NZbb930fWJLqI2HZ7z99ttLku67776hTZwFfUpfYcNDs/KitwFk5HJdKD+PPfbYJo9T\n", - "qoC9UDAXuJ4777xz1v/HyswGr2kYvXWgAjj3JOYU/Vkba+VvK1xtRrHi/9gNyhl2z5yP5motfd+2\n", - "OF5/yteyaC1A2WU+jLU3JKQilSRJkiRJ0sjUFKn/9//+3wYPd9ttt5U0t04UT5G8x+Qp2d/z8jTN\n", - "03NtNVKHGChqr9x7772SFq4SdWvMFe+vUTrw/KO4AvqN6yKWyuMNSsqAHw/lDiWnpLzgndEOvu+K\n", - "j9fZ8qyzWvCmURzxStwLxmvz+AjiQIhT4Lo9m5T20W+egVOL17PqC+1zokyn0nlK8RTgWXtPP/30\n", - "Jj/nWbDePvrf42361JxhzWCN4ZprlRnWEtamVnWa8zMmKAx9Y0xqbR81mb4fS+V0T5727LLLLpI6\n", - "G1q5cqWkrv+iitwRrD2ePdU305e1kTXE+w3FiXZia/QfSiL3lvvvv3/W5/pS+z0UvRtvvFFSN+f6\n", - "xr1yHM8Y9nbw9oXrZBxZG7Efv7e6+kxMHmuhZ+lh77WZz9gBn++7Bx4w7qW1w3dTqI2RS0UqSZIk\n", - "SZKkkSXPTGE78yVLlmhmZmahT5skSZIkSdKbmZmZ8C1PKlJJkiRJkiSNTC1GapKKFO9VTz31VEnS\n", - "+eefL6l7H966xxvvZ3m/TCwHv3NN/OR9Me/1/T18Kc7Bd5Dn+8Rwvfe97511PvAMoVbIxCGu5C1v\n", - "eYsk6bzzzpvVfuIYoh3aPXPE/06/8l6a99Qf+MAHJPW3FcbZs9A8Jojx4+cpp5wy63yl6tFQu58Z\n", - "GSd87swzz5QkrV27VtLcuAXsmLgCYsfoR/qf+AXa65lB/P2jH/2oJOmCCy6Q1NkXsUq+D1hUEZ2/\n", - "l2r40I+f/vSnJXWZY4wz/RDFjUQ7t9Nuxpn6b6961av08Y9/XFKX7cQcvPXWWyXNjfEh3s2r+Hs2\n", - "En3INZ944omSpLPPPnvW5zzOsVT5vDZT19eWPffcc1Y7yTbzviRejTlFVhPnoy+xMWzq7W9/uyTp\n", - "8ssvl9TFqTKXauP2aB/9QNwr52d83vnOd0qSLr30Uklzs8PYk43x8pp+HJ//kxVGbJHHop1wwgmS\n", - "4rWldu6X4kiZM6eddpqkzl44bumFUBQnyVz1NY74z3e/+92SpHPPPVdSt/bQXsadmCviWoHjRFlw\n", - "9DPfZ2357Gc/K6nrf+Y814t90t7I7n1e0A/cM1irP/axj81qb1Sjz9vd9xmgdA9KRSpJkiRJkqSR\n", - "zaqOVC3uHfAU2/cpdO+995bUZb7wlM1TMseNsgTxaqKaFSg+Dz300Cb/jxfh9Xe8BgdP616/aCh4\n", - "557V5v1byuKKvC7+7t6WZ4L0Be+/5FXSn66seIZL9H284Nr2RspcpMjQr3iLeF0onK7UuNcH7o3T\n", - "Xv9cSWHqm3Xo5+tb3yzKNPPMo40zwrxuEpm3PgeXLVsmqZu7eNa+xxu2Sb2nqC4SfexZVRwv8vD7\n", - "Zuqifu6+++6SujHzGm2cN6og7bspLF++fJPtI7uxtb5TVP0efG5FNki7ovpDzPlI+etbt6ikRKF4\n", - "Mjej66N/AUUEpaq0Z16k/EVrl48fChT3CPoHu4vuXaXsQL7HPcf/Tv9hN30r6vu8iPqBtbQ2m7Pv\n", - "M0BtHbFUpJIkSZIkSRqZmiL1h3/4h811k6KKyJHXF3kppT3p7rrrLkmxZ1yqzRLVz4FIiQK8KPc6\n", - "XNHgaZ+n9rESMfFGPV4EL5fzlvqhtEM7la8Zz7Fq3tTWKnFqFaa+Fd8jr7j03p44kl133VVSp2yx\n", - "31bJG0NNcZh/tfEgtfheinjDpXbyPa6TPRqj/eZgY7tCefrJT34iKVZ8iB/Eg3YbxxapP0RMiStb\n", - "zAVs3GGtYgzp46iGVgna6/tW+nXye6l+E33stfugb92mvnitMxQA5grKDf3L57n+vuq1Kyh9wQ5o\n", - "x8MPPzzv531c6OdSO2rnpMfROnzf32bQf9GaXFKnWftdpcbOgXvS2PviOpPa87L2uKlIJUmSJEmS\n", - "NLJZKlKRgtR3z63SU/JQZWSoMlT7FE98Bt5qayyLg1eCVw5476Wndb6H9xPFyOCd8dMVjVqIWyh5\n", - "iU5rJXyH+BX6pXYciOeJFCkypqKdygGFFS+VcYoUHR8fn1etldW9GjBeccnL5u+MI+oEylvExvtv\n", - "eUxIlB3kY8PvXrkc20DB8u/Rt1EfM6YoK0Pj/4C1BWVrqJoYqdn049h7k4ErKR6LRX/zk9i2PfbY\n", - "Q1IXG1aKNcImPeYFpQv78H50m6W9njXosJZF94BSRnXteJbuEVyXr7GtldkBFd3Hi3swawnxpqXs\n", - "1UmDUoYiR3vG2pc2FakkSZIkSZJGpqZI9VFN8Brw+HmqLsUglZjW03HEYYcdJqnzdry2RwTeLv2D\n", - "lzA0viHau5Cx46ker83PV5vpg9eEl9S6nxL2gBdEu0vtcLUCRQe7i/qxVnFzPB6Hnd5bYdxRDTg+\n", - "akikrEbtpQ7ZmjVrJEm33367pHqlzxVFxhOFszT3v/3tb1edBzaO50Dde/7zny+pU2xKajU24Kof\n", - "SpPXHAOuLVJs8MxRJoYqAZ7JSRzjUBU6ah9q96QUKd/zsLRmsVcatl2rJnN9bpusndH1uTLEXGOO\n", - "rFu3bt7zeSyc92dr7BBKodeDcjzzuBT7VEt0Po+d4nrpL+KCh86DvnD9ZOJz709FKkmSJEmSZMps\n", - "FnWkeIrGC2uNoamFp3281LFijkpwHpSOSJFyLwyvmTiHsZQ2vAuPefH+L2VVlfCaJq3tH1thLHlv\n", - "KF1eK6aEe6Gt8S2oLmS5oWy5HWDPteBN4631VQi932or+beycdwRfYk6WaqHA1GFcdQ8+tKvbeut\n", - "t5bUKSWlejcRKAteYd2hfV7lvpQZWwKbdLW0No61VOF7LJhzrXWtXFHsa5PMBdZA1G+PfaPf/Hz0\n", - "k6+pfcHOqP/F75HSg5147cPWOOWSQsl18vYIu/TdQPrSmnWJIt03jrqWVKSSJEmSJEka2SwUKWes\n", - "ejcRfbOUxgKvtlRN1Wuv4B3xtB/VvOkLx+V4Tqs34+Cd4C1NenxL9PWWhnqXHmdTqy74/mh4gR47\n", - "2Neeiet44IEHJA2PI5j0eG6s9pSUKGJiyDryvcfuu+++TX4v6kPqNJUyfFFqokxIz66KjoeSQHYh\n", - "32NN6FvBG7A9rwNUm2U4aSVqKPRbaU4xl7EHHydiumqVTj8f9ob9eYxYXxgfr+3nsFZ4RXSP4XO4\n", - "F/n3WHN87eP/tAN77LtHY8TQtXZSpCKVJEmSJEnSyGapSI1F9H57WpAxxB58Ee6tuhc7llLEcT0m\n", - "i/4aS2nAi1ms3kYEMUpLly6VVM6Si4gUxpL3jL3g5UWxan3tgfNS9TqilLEGk87Q2ThepqQU4Enz\n", - "HcYQm45ifZgDPra1Y13KAMXzp8p/pIwRP0m7XUlqVaRon8/BxZbZDNG+lRHMAY+t8jWM43FvwA6i\n", - "+lLRvQPlMaqTNdbuDeyhyBqycU01qVOisC/sn+thDlOHy/uT+RCtRf55lDzsnP4ZKz5yrF07xiYV\n", - "qSRJkiRJkkaelYoUcRJDFSm8w9YMEoenfrwK2ulP895eapuwP9hYtUK4Ps/koV1jKQ14w3h5C5Ul\n", - "ORTPmKrdU85B+eP7qB+Mc+SF0f+lcWC8xgZvvRTXM2mlsaUyPUqLxy7huY+VWQme+RjVXCt53KwN\n", - "zEnmDO1uzcYiZmdSttJKpDxxnfQHv6PIRWuIH4e1M9pVIBr30j3D7zHAuI0dhxutOVwv58POUKpY\n", - "u0p2V3tP8aw6xmFolmB0/MVCKlJJkiRJkiSNLM7HuwnDU/LQ2Cie7sfaq42nfo5b6wXglaII4P3y\n", - "e6v3Q2aQe3ce0zT0vXVrXMe0IR4HdaPVDvi+7wM1VjxAlHU5lNo4j0ln7W28P16r5+t1dqL/t1Ib\n", - "V1iqyeYxKFwnf0dZ67u21dpuSX3si5/Xx4/YH+8X1rhtttlGUjduKEHEDjk+vtHbhNpdJSJc+QGu\n", - "p7TX3lgKDnZCPCXKG2sMbx2ifTD7xshxPM8cRpnjXtJ6TxqrhiTHwR6G9nMqUkmSJEmSJI08KxUp\n", - "3lPzlLxy5UpJXf2cyJuJYH+vsSjtLO5Q5wdvgmrLeFWtT/9UgXVvEK9vWvW2Fht4562qhfcvXmAU\n", - "I1ci8uodVIxJZ9WV4lCGsrHK4J4l1x7FkPB5st8ipWWoAjNWZjBzDjWU47J2tZ6Hekae9eWMpUTB\n", - "ihUrZv1OrFa09qAkUNEbhYz2lzJIfY6OfT2O1wSkfaU5jV1GdcegtqK8xxYxH1gDUM68Zly0prGb\n", - "wt133z3r75GyyXmG3jta1W2PP6W/uO6ha1MqUkmSJEmSJI08qxQpvFO8Njx/fm+N1RkrS64Vnu69\n", - "eu9QxYj36s6LXvQiSZ1y5zFaffHsx9b34NF+ZdTm8ff2Q0FpcXuirhS1WUpEdcGw11pvac2aNZI6\n", - "L5Wd1qP9pfDG+ipSJZXHFbAo0yaKtynFh6Akc57ddtttw/+op4Tn2vfamDujx1AEMSh9P3fPPfdI\n", - "6vrssccekzSeqtj3OltVU1i/fv2s30trFv3CvpLY0FiZ02Pjdc1od20/l/qjtOaytrImuWLJ2hKd\n", - "x8eVLD/ewniWp18v40MsGwpjawzatttu2/Q9FCnWRpTBsVTyVKSSJEmSJEkaWdSKFE/T2223nSTp\n", - "3nvvldQ9laKI1CpC7kHzdMx5ogyFksJQu++S05qZ4e+h/f04+3/5+22u02Nj+npznJ+fPO1HsVSc\n", - "16sL0w73klrfgxOPgGJB3ETf6yvFJfB/FCn2SOT6+u4wvmrVKkmdQkS/YdfYJe3hOvEO99prL0nS\n", - "fvvtJ6mbJ8S7REpr1E4UR9QYvNLaGLBIqUIZxB74nfZRzbsU7+F7DG6sYDJX8dRd8YhA3SIbjLnB\n", - "74ytq7R45owFnrYrBbV9x5yIqv1zHjIVaSfHJ1aK31EESrXNiFXydh9yyCGSpIcfflhStwbyuUiJ\n", - "Yg4yl/mcH9/ra7HWoxTwf2w+2v/T6yTx/2XLlknqbMrbiy15pXjGkfMRR0v7qdlHv7IWeIyR2zKK\n", - "CNfD2teqKDLHGXeH6+Enaxd2Rb/V7pXotfL8XkS/AP2LPaBMYResQYxL1A9Ds0Vpb+mtU61yPOd7\n", - "Ta1KkiRJkiRJtOSZKWxes2TJEs3MzCz0aZMkSZIkSXozMzMTKsupSCVJkiRJkjQytRip+RQp3m/z\n", - "Hpn3psQpbLnllpK6miNUifX3n2eccYYk6VOf+pSkOJvNK3hHMTV8Lso44Jr4yftwMomIr/D30Vwn\n", - "sV/Rzu/EDxCTddJJJ0mSzj33XEnd++OhtTY87gK4rrVr1876nEPMT3QdtXh/Rhx00EGz2nPzzTfP\n", - "+j/xL6WqwqXzEUcRvWfnPT79H40D/fyhD31o3vOV7K0WYp7e9a53zTpfabwd4nNqYxJrx8/pGw9B\n", - "u04//fQNc93nHDESYwnwXNN5550nqRxjgu1tv/32krqMSq97RKwNawFZeh/5yEckSWeffbYk6SUv\n", - "ecms45EN5rZNDBdrEf3BWsr5DjzwQEnd2nLooYdKki688EJJ3VgQK0Rc3jXXXCOpixPcaaedJHWZ\n", - "lI8++qgk6bbbbpPUxccR28NYv+lNb5IU2woxXMQC+RpNXSNidHzOcD5iro477jhJ0qWXXiqpi1Xi\n", - "3uNxiYcffrgk6YYbbpj1eWBtJkaKmCDiRk844YR5r28ozAE4/fTTJ3o+h/Mw/0oV+oF7XxRDB9g7\n", - "nzv++OMlSV/60pckzbVr74/aGDDg+8zDY489dt7PpyKVJEmSJEnSyKLM2ivtao/3gzLgdYMioqfS\n", - "PfbYQ5J09dVXz/t9vJmSQuBVXPk9Oj/eT6TgcJyoFgj/x7vjJ14BXiftKNWHImMmyvQpZZgMVaL6\n", - "7vCNFxqdl+su7W9VopTxUaug1NbcqfXqSkTj2LfO2Fj10krZqqV+xNtHzdlY+aPPmCsoU2P1pVPr\n", - "6TIGd95557yfQ9FAOfM+8sxQVEXPFgNsluO5Ike/oER59pfbDkoQawRrMTAXUcJQovz7tKNUSR24\n", - "7mhtIBsMpc9hzvned6xlnt2GcsYc+d73vjdv+/y89JvXWYogi45cf65JAAAgAElEQVS1Kpqb2DX9\n", - "QW085qb3J+dnjngdJUBJxB64RzDXuOe4/WB/gIITVTyn3by14HyltZnz+9rJ9UdrRl8lCuiv6v1u\n", - "m86SJEmSJEmSTE+Rev7zn7/hKZWn9761NEr7KkHJG8X7QHGqPW6EK2p9FRbHY7e8GiuKFu+b/Xx4\n", - "q1FVWLwcjoPXxlN53/4gtoe4EI7L032pmmzfyub0c1QDZGiM0djU1g0reVNc74477ihJuv/++zf5\n", - "ub47uLcSzR9XaIeqQ15/bOP+ZE1Zt27dJr9L9XdigBZb9jDKBPGfHgvE9aEs4MlHY1yKl+T/KEv/\n", - "v71zjbGqOt/4c2JJajK1WFsGZGwGuch9oBBKPxhrBJMmDdpAGm2wNGJMjEljNbb9YjO9qLVJS5G0\n", - "sRdNSBqt8UNLmwoxTfBSEjpYII1OU6QMBhCxgk2gjcE2+/+B/+8cZs2sWXvvc9kzw/P7MnDOPvuy\n", - "bnu9z3rfd6XU0lChCKEv/vWvfx32eZj3Cd+uvKT2Ety7d++w64fQJsNyChUHyjflS5d6V9B38yoi\n", - "XC+mROFj9ZnPfEaS9OCDD456HO0ivE8Ux7A9cDx7F4Z9KlQQAeUrVNxifZvrUP4cl3csiB3H9WO7\n", - "Q6TKP9aeef68Y7UVKWOMMcaYklSmSF155ZV1z3giHlhXxapYvXq1pMascd++fZLiUXVYc0Ujc/Cj\n", - "IBKFyIyQouutKDL4C/BcRRUClIeYNYaVkdr5HSUo3DGc2TzKFdZjrBxT1hgKUFklqOi+XUQGlYX2\n", - "VZZ7771XUiOzOBElKeusWW655RZJjWjCmCLVKWLtAT8KFNNmI+ioL6zsi63G1O7y+IKsX79eUmNM\n", - "+cMf/lDqXsruThADS5ooJXYpAK4TqvnNQt2FvlZhpCZjSEw1jvm38v8wo3fe/S9TYxttIZZhHMI2\n", - "FyoZlG+s7zL2kTGdqMqQsu+iGChA+LGGGcQh9H8Nn493RajY7Nq1a8zrU67UO+UQlhO7jYSE91HW\n", - "XzVcbYmt9uR9h6RWwVCGU1iRMsYYY4wpSWWK1D//+c/6LJVZbjg7HBgYkNTIE4Ri9OKLL456zrKz\n", - "f2bx5GKJUXSnaKwILOiyvlLh/kyhgpKyflCYYopBaMWkZvNld3ofr6Ss3RRYsatWrZKUXvcvG0kS\n", - "Qr6svJFPVUH5oBKh1Jb1lWLcoF8UiSakzFCgmlXxQpWtWcII3BixKKqyhPtmAmMLz4k/aZinJy/U\n", - "GWN92fOEoBxw/pgiFUI5M6alcpjNnDlTUtpvNNzrsFnI3ffyyy9LKr+/LIR7OMagvilfokXDaM0U\n", - "4f6sKQU3tuoRqvnh2E15U/6MNbFySEUIxyLcQ6xIGWOMMcaUpDJFKo81ynru7t27xzwu5bOTmpWy\n", - "o3kqwgWrJe+sGh8hFIiyFji/5/5CK471a74PfchS68BE6eG7xSw9pnSlZvGp+iA78qFDh8Y8z3gH\n", - "6weF9Iknnujo9fEzGO8KIe2Hdtjs/YZ+NRdbqai1sWzt+GE+/PDDktJKEgpN+AzQ6rKnD6b8C1Hx\n", - "Uz5BeWHMwJ8TeL7QJyZvzrSQ0D+O85aFul+xYoWkhoKQ1wcnbB/smkF5hGNYUb/PMG9VWXjn7Nmz\n", - "p9DvWI2g3TKm51W0wnKIRcdBbDeGlO9iCOUWln+opIXvbO6HfsHfsrkN8/ZvK1LGGGOMMSUZl5nN\n", - "i5Jar07NKvl93vXsvBE6zL7zrkfHYNaNNReeD6s5jOTJu+ceVhhWHFbHjBkzJI30DUv5ZYTZc7nf\n", - "tWvXSmr4GWAlxSI9xjuUd7OZ3Ft1HzGabX/NgnrCfcSiVmmHWNGxdhH2v4tVItp8qo3m9WlKWdCt\n", - "8ncD7psotNR1UdubhTKMKVuholFWkeJ31GGr7h8fnli9x1YRQmWGsS5Wr6l6CWlVNCcKDe+oEydO\n", - "SEq38/CdVtanLm9904dRpIgoxscuFnEfgt8n5+H6qfunnXKdMFN/UfLmNLQiZYwxxhhTksoUqQ9/\n", - "+MOFM5nnpejOz1gheXOa5PWR4rhWWa34J4QWfahYxZQo9jcibxb5l7jP2HlTikcIVi3KFJm3yawe\n", - "ZiKfqLRajShLSjVpNnIIaxLrEp/CvIyWgXw0sLq5HhFCqXHi4vYettVm8/ngw8M9tEphSNGsJV2W\n", - "WAQrYyp/i+7TGBJGV5WFPkgmdRQu8nChstO2Ur5kYRRfs/fXqqg9FBnGbvJIpXydwvbabN4zovhi\n", - "fTK2NyTlQD2k/IUpf5RGlKm8exc22z4hb87Hif0mM8YYY4ypkEp9pMKIglZRdJf6opnGUxEIWLE8\n", - "X9H8UxD6tnC+0L8DayXl94EvD0pQat+sspnJUQiwXrBG3nzzTUmN8s67Xm7GJmXdNWsVY8WW7aeo\n", - "BCk14B//+Iekxr5fqB+p6168j1uoEnJtxoSiliq7LtBnwl3t20XeaKFmo/XyghKCwsB1UQ/LjqGt\n", - "grZDxvHY+cMcfGG+pzCPV7NjFFFjzYIyw33hF5t614XtnectqtRSLjwPvmKxDPZh+XE99nVlNSTW\n", - "bg4fPjzq50VXR/KCTxbPxXWc2dwYY4wxps1Upki9//779dkts9dQGWEWy2yR4/CdaBXMmvHhSUWR\n", - "paxarLRUNGEKrGksbqLoml3/xZrB4o8pWaG/QFE4PxEmKFyxfb1Me2i2vdA+yraDMBtxzBqO5WpK\n", - "cbFyG94jClVZf7bBwcFSv2sW+nrKb7Ns9FyMUEFhLAvVQcaksooUbYrnbBbqHTU8VJ5QGlBEIOYr\n", - "hALXrCLVKl+3MDI7b0b4sK/ljeQOoXwZy2l3odpNuwjLlevzLi+bQ7BdftXhGMX95/WbtiJljDHG\n", - "GFOSMRWpY8eO6ctf/rLeeecd1Wo13X333frqV7+q/v5+/fKXv6xnMX3kkUf0uc99TpL06KOP6qmn\n", - "ntJll12mxx9/XDfffPOo5+7q6hqxdxyzXRQLsuwyy2VWHMvmi09OWSsCK6TZvEZYAc0qAfi+MDvm\n", - "uULlLu8sPVxfx58A6wIfJmg2Ko1ZPvVq2kOz7T4vZdvDmTNnhv0f6xS/o9BKRt3I238utn7D34T3\n", - "TFnRt1q1V12rwCeL+8xrEbeKcExF+cAXB18Zxuyy0V/U8dDQUKnfh9CGwgjmkFQbjvn+lKVVfZL7\n", - "IU9TXh8z3mm0ozBqL6zfFOE7pLu7e9j3vKvDfsX58X0qq6Q2uy9qjNg4kFfBG3MiNWXKFG3ZskXL\n", - "li3TuXPntGLFCq1du1a1Wk3333+/7r///mHHDw4O6tlnn9Xg4KBOnDihNWvW6NChQxM+zN0YY4wx\n", - "ZjTGnEhNnz69PqPt6urSggULxsyoumPHDt1+++2aMmWKent7NWfOHA0MDGj16tUjjr3iiiuS+yEx\n", - "GyR/DbP72Hp82dk/s2sUthixfYRCsBZSlnfR+0OJC/enyjtLxwpg3T6mRKXg+VI+M62yNltF3vor\n", - "Cn0k707hrQa/j6qiILFSY1ZmzNqN9YeivnN5fLfog6jc/L9opuqQOXPmSGo8e+j/l7L0Ua+XLl0q\n", - "qaH0kG+H/EhVESpjPF/ZsSykWdWe8kMZoS/Eyi1v329VHqJWQcQ19583Epx3Bf62+KShHIXRqChV\n", - "4fsdpZTf8w5hVQliCmreXT64X1YzQjU7dnyz/six6/DuTZFbKjp69KgOHDhQnxRt27ZNfX192rx5\n", - "c33QeOutt4Y58/X09HhZxxhjjDGTllxRe+fOndOGDRu0detWdXV16Z577tG3vvUtSdJDDz2kBx54\n", - "QE8++eSov43NQPPszs06d2gdxCzfMBdEXrAa//KXvwz7nNk6s+O8/hRYyFgBYebwotFPYYQGCkhZ\n", - "mt0bjujGWK4PqNr/BPUB66nVShQ5RrgO7a7TGc9Tyl+zuWyuvfZaSdKRI0ckNaxA2nFKdQnzlWHF\n", - "MjY0a01eHKFFXwkjZxkzyDfUKkK/Rcokr+8QfSTsSyhSeeG5GbPCNphSxVFrw9+F0Vn8nv+HCgZq\n", - "NWNfTDnh9/j8lIW2GNuHtCiM1bE9BVEoaHP4LjG2Ux6M0WHfK5pZnNUYFJOiqjP3F0YxMhbSzhBA\n", - "6DeUJ/VJOeNbyO9jeaRCwqhBxk6ei/bJ81LOKUWK9srxofJFu2Zsjo1Vsc9RZFMkFakPPvhA69ev\n", - "18aNG3XrrbdKutD4a7WaarWa7rrrLg0MDEi6sBntsWPH6r89fvx4fYNaY4wxxpiJwtmzZ3X27Fnt\n", - "3r17zONq2RiyQZZl2rRpk6666ipt2bKl/vnJkyfra6VbtmzRvn379PTTT2twcFBf+tKXNDAwUHc2\n", - "P3z48AgroVarqb+/v4nHM8YYY4zpDP39/dFVljGX9vbs2aNf/epXWrp0qZYvXy7pQqqDZ555RgcP\n", - "HlStVtOsWbP0s5/9TJK0cOFCffGLX9TChQv1oQ99SD/96U+bllqNMcYYY8YrYypSbbtoraapU6fW\n", - "ndTxbWJ9k3VW1lFZZ2ddHX+AMPKAdWqWEzdu3ChJdfUr5icQrkOH4COV8n3hOj/4wQ+G3U9IGOWU\n", - "un4Iz/3Nb35z2HXbDdfhb97oPSi6t2J4vRR56ynv9a655hpJjQgs/AbCzPCxve7wS6Ad0O7wk3jo\n", - "oYeGXa/dFC3PVl1v27Ztkhr9GDU7lrMH/xr8Gyg/yp9yp9/w+b333qvvfOc7kloXVRajbFnybKl9\n", - "MWPX+/a3vy2p4bNCGRAxmuqLlB3DfszflOt973vfG/O4VsH1fvzjH0saGbkZGzt4HvokfZ+xie/x\n", - "ScKwv++++4ZdN9WnP//5z0tq+Pbu379/2Pf4QoX7SlLPsefjXcDz8Q7kfnk38i4Moyd5Hv7S7rne\n", - "E088IanhC8WuILQT+hb3vWjRIkmNcj548KCk+NiKT9XXv/71Ydct+m4oms8qb/+j/Civsrsz9Pf3\n", - "j6lIOcGTMcYYY0xJKttr7+KZHREv4WwUq2D+/PmSGhYsyk2oYEEsmixmpaaUIHKUkPGc2Tb3G85S\n", - "U/sghfeRV4mCmKKD0kEkTGhFtjpqrejsvl37JEGro+UuDpy4mNBqjBHL71U2G/REJVzeT2WPxopH\n", - "QY5FKhEZhTUvtV+JapaiSlQIYw1tq2imZxSQvHmS2q1EhcTaROxzxuDw3VF0LOD8sXLhnRKLeEZh\n", - "SuVAC88f1mcIfSUWic7vY0oJfSeV4452uXfv3lG/j5VnbNWFd1HeHIp5lajYdWJjat4I/jDqryhW\n", - "pIwxxhhjSlKZInWxhRHORvFNYV33pptuktRQVPbt2ycpnhOGWWqrCPfeS1kBYS6V0Aptl9XMrBwl\n", - "j3Xh6667TpLq+yH+6U9/ktTwVeH5YgrMpRowgF8A7TOst5gi12wm+5BO7aXXLshRg/VK/4ipDJR7\n", - "6nlp32NtQRXz7VixYoWkkbnjJjtXX321pPz5tFJ+h4xx+AhRF/SN1F6B4Z5x7VatQ1Ai6OMxBS6V\n", - "ew9fIdo45RauTuA3SXmG+ZnKkvIh63Sm9k5dr1l1n7kC70h8wopiRcoYY4wxpiSVKVLTpk2LKiDM\n", - "Elk3JtoHC3Tu3LmS4r5QRWep+FpgTaWyrqfWc7Fq2pXhOuWDFWaKxkoiM/X1118vqWEF7dmzZ8zz\n", - "VZ2hvFnK7sdEO8Jqzfv7mBIV25MuZfWj0LZqf7hOg+pABnj+H/MnydtvKMexlL/YuVauXCmpoRC8\n", - "+uqrktJ1XFadDVWzVqmVsbYTRnOFY2qrIaqMXQ/wyaGOYv6ZVfsLhsoQSkrKNyyMKA99hTgvUWNA\n", - "fUFKiULx42+eHUEuBqWKd1ZZpYg+S31VVW/h3n4pUmo+UYphPRXFipQxxhhjTEkqU6TG8mtgXZ1Z\n", - "/ZtvvimpMbv+1Kc+1dJ7YX0fK6PorD+E2W+7fKGKRjgQFYgC+Prrr0uaeMpGWbDKi+YqwSrNuwN4\n", - "WVIKTCpyZ7xD+8N6p58VrY8Qyq1MbpiXXnpJ0sg901IUVWex5L/2ta9JauQjIh/UH//4x0Lnw8eJ\n", - "thBTGPB/RIFC+Th16lSh66XaJv6f+JaEPiYXR1SORqhslM2zVZYw/xLKXUqRiu0hGBK2F/b9TIFC\n", - "goJFvrDYuynWfskb1Sxl8y+1mlDRS5GqR9pbsz5dVqSMMcYYY0pSmSI11hprzApi1p3a7b4oqdwf\n", - "RRlvuWxCv49Q2SAT/IkTJzp2T52krF8ImbWxBv/+9783dR9YR0X9bDqdy6fVhMoRz4PPWFlFinaM\n", - "olyEVBRWq+CZd+zYIamhhMXy9aTA9yg1xjSrqldFp5QooC8W9Z/MS9i28yo74RidygN1qVA0cjml\n", - "NKHQkiGgLFakjDHGGGNKMi4ymxeFCJBW5ethvbtdES3jnaVLl0pqWEGxbLUTnbztJYzSI/KjVf4b\n", - "Rdv+rFmzJElz5syRlI6yHG9glaNAhVmk8Uvhb1F/jKKRPFXQKgUs71g3XnKP4dPS6fxQeaHtNJvH\n", - "KUarcxpOFJrd9zRGq1d7UG6J2iyLFSljjDHGmJJUpkg14/eBf1XMsi/qg0L0UFElhj3tWhUZ0WmI\n", - "AMJaHCuScjJABFGqnomYIdoM/wQUlbKwDl/U+uW65JOaaIpUqj+WzU1DfV6qmffHolUKEGWbV0Xl\n", - "eBQJlDHU/rCOUznx2k27x7xOR9qOl77QrhyKRUmN+XzO6kNZJW1yvzmNMcYYY9pIZYrU1KlTkzlN\n", - "sMRZF+UvuV9ivipFfVDK+gThMzPRFCny+PDcg4ODkia/j1jRjNn46rTKui+bYR1FjP2gyE00XnK7\n", - "pOA+6ZcouZRr0f5HOaImTHYltQytUgQo25RaSOQkdUMfSv2esXyy0umI23DvwkudvCo3ylVZnzaP\n", - "QMYYY4wxJalMkcqzNs56bxht1a6dpZnN59nDS8q/gzoU9TdoF3mz8k40UkoNvk+p7MJEOtHuqK9m\n", - "6436L+oLRH4vrKbFixdLkvbv39/U/XQK1JFQWS7rHxMqeqns2aY8qO7k2kNBYgwOM4KHe/qlxuqq\n", - "fXrGu6pb1GdnvPgmjRcoDzL9s3rEGEx7Zh/Q1157rdR1rEgZY4wxxpSkMkUqj18R+WfCPD4oRkRE\n", - "5J2Fx/IIsa5PJmv29stLXquqrKKBr9hEz3Ddbsj/RH3QLsi/tGDBAknS73//+zHP0y6rrqwvHtYT\n", - "GdbxlZooihT9lj002fOR50LFKKrU0Z8nUq6eqvM7Fc2FRp0wBhHpS1sOVVbGOMaqVJtPqf60eSJo\n", - "myX0IWLM6FTuvJ6eHknS8ePHcx2PPyvvS78DyhHLNUe7btY/2IqUMcYYY0xJKlOkilj9oQ9E2X2R\n", - "QusHBYooIjKmF1WOsNLaRausEKyvdvmYVU1MaaT9/PnPf+74PUkN5aRsRA3WFOv5fX19kqS//e1v\n", - "kqSDBw82e4tthczsoWpB1F5KHaEe+R3td9WqVZI6n6unDLTBZiMMUSjK+jkWzcofHn/o0KFh/8f3\n", - "JFS6WE1IjaXhPqf4zeX9fVFCn6h27bEXo2hm7om6Z2K7KNt/Yv7MtL9m1X0rUsYYY4wxJalMkZo+\n", - "fXrSTwDrBGsHSxSrDIu27M7YWHX8LbuPD1FVUNbno9VgBYd7m0008vp1oNzRPmhfhw8fllQ8HxRR\n", - "ftRnKtovBu2qbHtg/f65556T1PCzafW+U+0CJY7M7ihslAeRSXxOPZIBnt9TDnyPf8PF7QLVjmO7\n", - "u7uH/Qalg+OoW/y2UnCvecGCnj59uqSG6l0Wxqowc3i7ctnFosYoe3yLwszljN2UO+VM+fP/3t7e\n", - "YeflewjVRlYPOD8qO32b+zp69Giu50uNCYwBPH9RX6pQhc77+zBH2kTxjaIPoyTSHsKI6aJjIe2c\n", - "MaTVNBs9akXKGGOMMaYktayCpEa1Wk39/f2dvqwxxhhjTGH6+/ujPntWpIwxxhhjSlKZj9Rzzz1X\n", - "92FhHR7/AXwjrr32WkkNX5DQjyH0ucAfgnXYO++8U5L03e9+V1Ijeyl/WRcNs5mSd4h18fC67CvF\n", - "+jX38ZWvfEWS9POf/1xSPOLiRz/6kSRp9+7dkkbmNVqzZo2kht/B3r17h31PlODdd98tSdqyZYuk\n", - "hk8QvlGszxNZw/OEfhr4ILFuzfesS7O+zfMZY4wx5gJWpIwxxhhjSlKZIvXuu+/q1KlTYx5z5MiR\n", - "Mb8PIzrIFhtGA6K0cD3WOWP7LBHlFSPMfYKCBqncH08//bQk6dVXXx31+xUrVkiSnnnmmVG/D3Of\n", - "hM9BJAp/iRSJRX6QPTiMfqQcO5X11xhjjJloWJEyxhhjjClJZYrU+++/X/cxIidI2T3OUpmN8aHi\n", - "/Py/VTuPh7llUjt2x5QofK3wjYrlhgn3BQpzr4SkAjPxQcOnKlS4Uuc3xhhjLlWsSBljjDHGlKQy\n", - "RercuXN1JaSsEpWX0Men1b4/KGpQNoM1vlbbt2+XFM+6G+52n8p6m8q0zucch1JXQYoxY4wxZkJh\n", - "RcoYY4wxpiSVKVKjwS7vze7IHe5vBKFyxHEoMEX3YuP3+FxBs/si4QMVU5Ji0YYhPG9ehYzyn6h7\n", - "8hljjDGdxoqUMcYYY0xJKlOkrrjiihHRdq2KDgsVG5SZMEqPKDl8pYoqUmQEZ8fxGEQn4hOWgkzi\n", - "KENlfa74Xeq65I+66qqrSl3HGGOMuVSxImWMMcYYU5LKFKmPfexjIxSpUEnCR+gTn/iEpJGZt6Gr\n", - "q2vY/8MoQJQuFCn2okNJCq+DQoUixPnDDOb4MoU+UiFcJ69vE+dtVqFDicqriNk3yhhjjCmGFSlj\n", - "jDHGmJJUpkhdfvnldWUo5puEgpJSSj7+8Y9LavgEnTlzZtTjyIt0+eWXD/uLIoUShe9Ub2/vsPOG\n", - "ihTKVyofVV4lClJKVJhJPUVMUQvxnnrGGGNMMaxIGWOMMcaUpDJF6tSpU/VoupgihYJEJvIYZ8+e\n", - "ldSIokspQCgzXB8fInyZiF5DsXr33XfHPB+/7xRhPqwU3B95oigf76FnjDHGNIcVKWOMMcaYklSm\n", - "SL333nsjMoCn9oSLcfr0aUkNX6qU0oIvEL5D+Grhk8X1jx49Ouz8MVL3i88VSlBMgZs6deqw72PH\n", - "EdWXFzKw40t2+PDhUY/zHnvGGGNMMaxIGWOMMcaUpDJFarT96Mpm8Ia8UWcch+8TihF5rdjrL+Wb\n", - "BbH8TB/96EclNRQkng8fJ/7iu4Ry9K9//SvXdfPyzjvvSEr7jlmJMsYYY4phRcoYY4wxpiSVKVLN\n", - "gC8VPkUoKShDeRUdlKJwT7uiGb5RngCFC2WL85IBfdq0aZIaiheKVCrPU1m4H6IQYz5YlGerFTFj\n", - "jDFmsmJFyhhjjDGmJONKkULZQUHBtyfcOw+Fh73xyJNEdF2oEMXOT74o/LVee+21XPd59dVXS2oo\n", - "TDNnzhz2fUxZQjkjGhDCPQdjcN+xaL4Yn/zkJyWN3GMQTp06pcsuu6yujFmRqpahoSHNmjWr6tsw\n", - "/4/rY/zguhhfuD4uYEXKJDczNp0lnGibanF9jB9cF+ML18cFKlOkbrjhBt14440duVZ/f3+u4zZs\n", - "2NDR67WKZq+3e/fujtWFMcYYM5mwImWMMcYYU5JaVkHyoM9+9rN66aWXOn1ZY4wxxpjC3HDDDXrx\n", - "xRdH/a6SiZQxxhhjzGTAS3vGGGOMMSXxRMoYY4wxpiQdn0jt2rVL8+fP19y5c/XYY491+vJGUm9v\n", - "r5YuXarly5dr1apVkqQzZ85o7dq1mjdvnm6++WbnkmoTd955p7q7u7VkyZL6Z2OV/aOPPqq5c+dq\n", - "/vz5euGFF6q45UnNaPXR39+vnp4eLV++XMuXL9fOnTvr37k+2suxY8d04403atGiRVq8eLEef/xx\n", - "Se4jVRCrC/ePUcg6yH//+99s9uzZ2dDQUHb+/Pmsr68vGxwc7OQtmCzLent7s9OnTw/77MEHH8we\n", - "e+yxLMuy7Pvf/372jW98o4pbm/S8/PLL2f79+7PFixfXP4uV/euvv5719fVl58+fz4aGhrLZs2dn\n", - "//vf/yq578nKaPXR39+f/fCHPxxxrOuj/Zw8eTI7cOBAlmVZdvbs2WzevHnZ4OCg+0gFxOrC/WMk\n", - "HVWkBgYGNGfOHPX29mrKlCm67bbbtGPHjk7egvl/siDG4He/+502bdokSdq0aZN++9vfVnFbk57r\n", - "r79eV1555bDPYmW/Y8cO3X777ZoyZYp6e3s1Z84cDQwMdPyeJzOj1Yc0sn9Iro9OMH36dC1btkyS\n", - "1NXVpQULFujEiRPuIxUQqwvJ/SOkoxOpEydO6Jprrqn/v6enp14xpnPUajWtWbNGK1eu1C9+8QtJ\n", - "F7aJ6e7uliR1d3fr1KlTVd7iJUWs7N966y319PTUj3N/6Rzbtm1TX1+fNm/eXF9Gcn10lqNHj+rA\n", - "gQP69Kc/7T5SMdTF6tWrJbl/hHR0IlWr1Tp5ORNhz549OnDggHbu3Kmf/OQneuWVV4Z9X6vVXFcV\n", - "kSp710v7ueeeezQ0NKSDBw9qxowZeuCBB6LHuj7aw7lz57R+/Xpt3bpVH/nIR4Z95z7SWc6dO6cN\n", - "GzZo69at6urqcv8YhY5OpGbOnKljx47V/3/s2LFhM1jTGWbMmCHpwqbPX/jCFzQwMKDu7m69/fbb\n", - "kqSTJ09q2rRpVd7iJUWs7MP+cvz48REbZJvWM23atPrL+q677qovT7g+OsMHH3yg9evX64477tCt\n", - "t94qyX2kKqiLjRs31uvC/WMkHZ1IrVy5Um+88YaOHj2q8+fP69lnn9W6des6eQuXPP/5z3909uxZ\n", - "SdK///1vvfDCC1qyZInWrVun7du3S5K2b99e7zSm/cTKft26dfr1r3+t8+fPa2hoSG+88UY9ytK0\n", - "j5MnT9b//Zvf/KYe0ef6aD9Zlmnz5s1auHCh7rvvvvrn7iOdJ1YX7h+j0Gnv9ueffz6bN29eNnv2\n", - "7OyRRx7p9OUveY4cOZL19fVlfX192aJFi+p1cPr06eymm27K5s6dm61duzZ77733Kr7Tycltt92W\n", - "zZgxI5syZUrW09OTPfXUU2OW/cMPP5zNnj07u+6667Jdu+tes7EAAACgSURBVHZVeOeTk7A+nnzy\n", - "yeyOO+7IlixZki1dujS75ZZbsrfffrt+vOujvbzyyitZrVbL+vr6smXLlmXLli3Ldu7c6T5SAaPV\n", - "xfPPP+/+MQreIsYYY4wxpiTObG6MMcYYUxJPpIwxxhhjSuKJlDHGGGNMSTyRMsYYY4wpiSdSxhhj\n", - "jDEl8UTKGGOMMaYknkgZY4wxxpTEEyljjDHGmJL8HyFOTlbukMv2AAAAAElFTkSuQmCC\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "feat = net.blobs['conv4'].data[0]\n", - "vis_square(feat, padval=0.5)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The fifth layer output, `conv5` (rectified, all 256 channels)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAlIAAAJOCAYAAAB8y+mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3XuM3Gd1//HPEN/vXtu7vqzjTeI4xiShoSFQCUpTCBVS\n", - "GwUh0oYKIqBV1UoBmnJJ3RYGihRTFaFfC0H8gUQqJEjUKoR/QCFVSJXQYG5pEjuO7ZD1Zb273ptv\n", - "sZM4iX9/ROeZM/HXOzPPfG8z835JKF+eXe88Ozvzne/3nPOcp3Lu3LlzAgAAQMveUPQEAAAAOhUX\n", - "UgAAAJG4kAIAAIjEhRQAAEAkLqQAAAAicSEFAAAQKZMLqR//+MfaunWrLr/8cn3lK1/J4iEAAAAK\n", - "V0m7j9Qrr7yiK664Qg8++KA2bNigt771rfre976nN77xjWk+DAAAQOFSj0jt3LlTmzdv1tDQkObO\n", - "nas/+7M/0/3335/2wwAAABQu9QupkZERbdy4Mfz/wcFBjYyMpP0wAAAAhZuT9g+sVCqpfA8AAEAZ\n", - "bNq0ScPDw4lfS/1CasOGDTp06FD4/4cOHdLg4GDT/37hwoXh+MyZM6nOzVSr1cTjIjCXZMwlGXNJ\n", - "Zo9f1Dzmzp0bjv/hH/4h1bnYjWdMOWvRz4vHXJK1OpeLLrooHL/66quSpEWLFoWxBQsWSJKmp6fD\n", - "2GyvHft+Sbrjjjtamssb3vCGMJ+zZ8829W+aVaa/0bve9S49/PDDF/x66qm9a6+9Vvv27dPw8LBe\n", - "eukl3XPPPbrxxhub/vdnzpwJ/wOATnD27Nnwv7SdO3cu6iIK3emVV14J/7PXxgsvvBD+Z+xrjV47\n", - "L7/8cvhfq1599dXMXvdlcv3118/69dQjUnPmzNHXv/51/dEf/ZFeeeUVffzjH2fFHgAA6EqpX0hJ\n", - "0vve9z69733vy+JHw/FpUDt+5ZVXwphF9V566aV8J4bgd3/3d8OxhcCffPLJMEbkFZ3kDW94LYlh\n", - "KaW8XHzxxZJUt5DJoi/PPfdcGPPprF7iz/tTU1Mt/duYSBTq0dkcAAAgUiYRKeTDFxhatGPZsmVh\n", - "bN68eZKkiYmJfCeGRHbn5wuTiUihrJKK3POORJnLLrtMkvSmN70pjFnkxUdgejUihWIRkQIAAIjE\n", - "hRQAAECknkrtzZnTHb+uFXz6IvKTJ08WNR3M4vHHHw/HviC0V1kKetOmTWFsyZIlkqSZmZkw5nvR\n", - "oRhLly6VVF8uYOceXy6QR3r6V7/61XmPa8Xmo6OjmT8+MBsiUgAAAJG6I0TTpG6JSFmxsu9Ie+rU\n", - "KUlx3Y/T4OeyevVqSdLzzz8fxny0oZcQhao3f/58SbXXiCT19fVJkk6fPl3InJDsxIkTkuo7adu5\n", - "xyJTec/lqaeeyvVxMTu/4CmpBY9lSrr9PEhECgAAIBIXUgAAAJG6I9fVJL8PUSezULulSaRaQejx\n", - "48cLmZMP9Vt6sQypVEtF+P43RYeZN2/eHI7tOdqzZ09R08mV9dLyCyWOHTsmSRofHy9kTphdr6bl\n", - "G/E7S9j7uNcW/fi079DQkKRaql6S9u3bJ0k6cOBAGOvGfSOJSAEAAEQqPmSAltlyY7/suOho24sv\n", - "vhiOJycnJZVjDydbWu8L34uKSK1bt06StHXr1jBm8zpy5EgYs8LabmSRKLtTler/NkXyEVSLYFp3\n", - "b6n4SCbKxb82LDvgF0z0wuvFPwf2GeDbUdhxN0ahPCJSAAAAkbiQAgAAiNRTqT3bxLfTWZjUF5YX\n", - "nUbzYewyhbSLLpT1xZiW2vOLBGyTVZ8a7QVlSedJtV44K1euDGM2v6SeOOgefpFMqxsy+zSelVYU\n", - "talzUfznjm0e7UsTeuW8RkQKAAAgEhGpDlZ0FAqN+SJL27vMF2jaXW2v3Lk1y56jPIpU7W+wfPny\n", - "Qh4fxUkrgtRrkShz9uzZcGzvGX9+Mz4K343nOiJSAAAAkbiQAgAAiNRTqT3b2BfIS1JHdV+MyWsy\n", - "WREpNd//ppP5BQ5Alnxqz3rE+QUatuOGL6shtQcAAICgpyJSncyWaEu1wj2/15NFOfyycrszXbx4\n", - "cRizOwj/b1etWpXBjPF6hw8fPm/M70HVq+y1aPsiSt3d3T1r/nkEsuRfa0l7wNpni/8+2/mimxCR\n", - "AgAAiMSFFAAAQCRSeyXS398vSVq9enUYsx43fX19Ycy68fpCZkv9+W7nVsi8YMGCMGab+PqOvlYQ\n", - "iGwNDw8XPYXCWdh/zZo1YWzTpk2S6gvMLbXni/Ht+fOvV1KA5yt6A/Nu5HsjWb8x/3q1rve91k/K\n", - "Py/22bJ27dowZs+V7wLfjYhIAQAARKqcK2CdcaVSUbVazfthAQAAWlatVi/YloWIFAAAQCQupAAA\n", - "ACIVVmxeZGrPP3bRKUbmkqysc/na174mqb6oPw2+G7XvDGysM/D27dsT51UE//j//M//LCl57nnO\n", - "pejnxM8hZi5pb5Zcxufly1/+chgrauP1Mj4vzKWezWHHjh1hLKuFFL5o3i/OMp/73Odm/fdEpAAA\n", - "ACLR/gCz8l1qbWmvb51gXal9RMW+fubMmfO+b86c2ksuaW+zpLuBMsnqDrpRJMf2sSqroiJR3Wbp\n", - "0qWSurutQ1FRKHSmRuc+++xp5xzk9wK0n+OjVI0QkQIAAIjEhRQAAEAkUnuY1Ysvvjjr161zrXVl\n", - "92M+dWdpvpmZmVl/Xtm7MvtNoTuN75i/YsUKSfUbiB47diz3OV1IGuH6TtTo/Qb0GuuYLiWnvC0t\n", - "50tJWuXTePYebKXMhIgUAABApI6ISPniZitWLnvxba+wInKLcEi1O4jx8fEwZlf5Z8+ezXF26bPX\n", - "XycWzPo52/HixYvDmEUDi4oK+rvCuXPnSiIiBfQ6v5DJFmPY+UGqnTdiIlJJi6Xs5/mFVo0QkQIA\n", - "AIjEhRQAAECkjkjtWf8iqZZa8WE3S0V0etqoE42MjEiqLyK30GhS928LpUq1UKxP3fp+HmXUiSk9\n", - "44vJkwrLW+mb0i4fmreiTp/G868JAL3Ln6uSOv773oStsvO5/7l23EqanbMVAABApI6ISPkrTrtT\n", - "LcMyeYuKWQGcVJufj9B0c6TMruib7cTsl5RaRCop4oj8pbW/WzP8eyLp/cHr4Hw+itfN5xS0zkeT\n", - "83wf56HR79NOlmC29xERKQAAgBxwIQUAABCp1PFzKzxev359GLN00KlTpwqZ08DAQDheuXKlpPrU\n", - "lPVOIvSerFERcdopWytub6frba+wtGsZ0uadXNSfFZ/uzOP8Yue3VatWhbGxsTFJxZ1/kcy/NmzR\n", - "hv9cwuz882fPWysLn4hIAQAARCp1RCrpirpMnX8tyjE9PR3GTp48WdR0OkKjvfbSjkSUKRK1aNEi\n", - "SdLp06cLnkltoYTvSG93ZdbSoldYJ/6yR1nyjnLbudbvUFD256hX+c7c3RbNTdrxwO9sYpGjdnY7\n", - "Seqe3koLFiJSAAAAkbiQAgAAiFTq1J6FKH04uehNTH2YO42QYq/p5QLIMqUZ165dK6m+0/zzzz9f\n", - "1HQuyBd8ZvU+65T3b94pmzKkoNEc/7nYbX2k/Dkqq9SeTx/az2vls4qIFAAAQKRSR6SMLwSzpbg+\n", - "SlXUFbgtF/f7/tldXNGRM5SDL1i0wm6/ICHPAmL/PrLXrI9ylGmhhN0h5hGFKWNEyu8AkNSWIs8W\n", - "FX5peLcVMrcjaXl8Ua+lbm634xfEGH+uSmOPUP/zLDLvI2GNEJECAACIxIUUAABApI5I7fmiR0vj\n", - "laGgzsLcfjNRUnrwfNh58eLFkupTJZOTk5LyKcL3r017T/kC+DKl9sr0Pi9CUWm8JKTzkpUxJdyN\n", - "jh07Fo6TFkCkfd6yc3Erf18iUgAAAJE6IiLlrzjLdNfM8uDes3z5ckn1dyuztTXwhZIWnfIF6M1G\n", - "oqz7dlpsz7SYaIMvhI61Zs2acGwROh+9s4LP48ePt/1YADpXURHZVgr4iUgBAABE4kIKAAAgUmGp\n", - "vTlz5tSlCCxVYgW5Uq1Phy82S9q02P6N/3lTU1PnfV8rfSGkuBSM8T17LHXh5+5/zzKyOeddaLpp\n", - "06ZcH69VlnJq9nlJSvvFFKkmbRZrr3cfgraC8ka9f5qdv70H/OvfNvVs9H1J7N/aBs5SraeVf16a\n", - "TeEnzQVAe3xvxKTP3Dx1wm4YRKQAAAAiVc4VsL64UqmoWq3m/bAAAAAtq1arF2zHQkQKAAAgEhdS\n", - "AAAAkQorNr/vvvvqOi1bUa4vzh0fH5ckLVu2LIxZMbLvLTExMSGpvijNioJ9Abr1qfnbv/3bMFZ0\n", - "itE/fpnmsmPHDkn1naWtQNgX+NpzfuLEiTCWVExt/8YX/NvfKKkw+rbbbkucVxH843/zm9+UVN9D\n", - "zIq90+p3Ys/HwMBAGBsdHZUkff7zn0+cVxHK+Noteh5+DsylHnNJxlySpTEXv+ir2V1H7DPKX4s0\n", - "mgMRKQAAgEiFRaRefPHFukiE3eHbnbc3MzOTePx6/urTP07SMWaXFF2x52+2v0ErP68TWZQ0SxaV\n", - "GxkZyfyxAKBbxex9O9tOFRdCRAoAACASF1IAAACRCkvtHT58uC7dk0YH7aQwXkxoD81bv369pFrh\n", - "uMRGs2XV398fjm2BRgFt5ICWrV27VpK0YcOGMGbd7/fu3VvInABDRAoAACBSYRGppL3D0HlsqWhS\n", - "tMPvAXf06NF8J4ZgxYoVkqQ3v/nNYcwWZuzfvz+M+WOgTGwvx7lz54axvr4+SdLy5cvDGNFwSLVz\n", - "nn9t2GdQo2Jy2+O3lT1RiUgBAABE4kIKAAAgUmGpPWTDh759ai0rBw8elJTc7dx3/0brrBO/1F5R\n", - "+LFjxyRJ//d//xfGLLU3NjYW/XOBvFjvOv+esPNMHuc5dBZbyGZpOqmWHm7EUsatnBuJSAEAAEQq\n", - "LCI1d+5c7iTa5Du5r169WlLyHnBZsjtE/1jWsb6VYj2cL+3WBBaZkvjblF3MHmHdzAqE/aIVPj96\n", - "l9+zdcmSJZJqi5ykWkTK72bS7Pl08eLFLc+HiBQAAEAkLqQAAAAiUWzewXxhuaVt8t6Y2cKqK1eu\n", - "DGMWcj9x4kQYIz1RPEv/SrXi3ZgNOpGdBQsWSKpPXdh7my70pPNeb/PmzZLq39tPP/20pO7uqeU/\n", - "+6yUJEnMe8bvuNIsIlIAAACRCotIcWfRvpgr56z4uwKLivmlp3lGPnw3Wyuq9sXV7UTHrLi+E6MD\n", - "fj/E+fPnS6pfEuy/jmIkLdu2u28WCOD17H1s+w5K3R2JMv76wbfESIN/LptFRAoAACASF1IAAACR\n", - "KDZHWywM6ov/LLXn0195psQs3C3VUiVpFbtbf5+XX345lZ+XJ78QYWBgQFL938O+3om/W7fxCzVQ\n", - "k1Rk7EscOjHl3o5du3YVPYVC+FKRVatWpfqzY1LoRKQAAAAiEZFCW6zo79SpU2Fs0aJFkoq7U7Q9\n", - "uKRal1r/+O0U7XbyHa8vLLeC/DItWAAa8a9hi07RwqO3pR29pf0BAABAjriQAgAAiERqD6nwvTys\n", - "K3NRIXffD8mKqtPqkdQtHdotHO77sVBkjrLzmzlb2t5v1M5ruPeUYWEGESkAAIBIRKSQCr83mEVt\n", - "/J1innwk7NChQ3VzKivfsiGpM3waXa393+PgwYNt/zx0N4v4lKnjvY84WVEwUSgUjYgUAABAJC6k\n", - "AAAAIpHay5EvlPS9jtLk00GWzsoyrbVkyRJJ9f2VxsfHz/s+3//FZPUceGn/7lZU759n+938xs2m\n", - "0QaY9vxZGsX/m/7+/jA2PT193r+1fl0xKdQ8nvtOYX8/npN6WaX0/Hmw2fenvT8WLFgQxlr9e/n0\n", - "OTpHUtmD18550Lqi+95Rdo5vpZ8UESkAAIBIlXMFtGquVCqqVqt5PywAAEDLqtXqBXe2ICIFAAAQ\n", - "iQspAACASIUVmxeZ2vOPXdQ8rMD185//fPRcGhXhtaoMz0vS4991112SpGPHjoWxNPoqJfFF5LYp\n", - "6mc+85kw9uUvf1lSfcFsGs99s8r6NyrLXIqeh59DmeZir1vPv9atYNd3ibb+TCtXrgxjVoDbqBDd\n", - "3jv+HPXpT3+6bk5FKuPfqExz+frXvx7GrKg/acFLHnNp9nnxu2usWLFCkjQzM5PqXC6EiBQAAEAk\n", - "2h8UJI2l1nlGQoo0OTkpKZ/l6T7SlRT1srt0uim3J+2u7Zhd0uvVj822dHxqaqrlx7M9HP1ejugc\n", - "p06dCsettAEoki8EX7ZsmSRpw4YNYcyirT5K1ag9TbOISAEAAETiQgoAACASqb0WWSdUqVb8XPYN\n", - "cTsdnae7hxWBXn311WHsueeek1SfQrKNpwtocwf0vCzTebYQIcu0r23KvmnTpjBmnyNZ/G5EpAAA\n", - "ACKVOiJle5f5fciOHz9e1HQkxRVeoj1EJbqHtY3wxc32/vbLl+2OEigD/9q85JJLJNXv+zc2Niap\n", - "vRYBZVqA4X/ftM+/1hIjy4iUzXl4eDizx/CISAEAAETiQgoAACBSqVN71lF33bp1YcxCniMjI2Es\n", - "rV4QKCeK+dNn4fW8e5FZapwUOTqJFUhLtS7wPrXX19cnqT5l3WpRc9JiGitv8fLoYefTjGmfIxp1\n", - "xe9ERKQAAAAilToiNTExUfdfz98NAGhs+fLl4XjNmjWS6vcvtA7yAOr54m+LNCVFi/zegq1GpBp1\n", - "n89Tlgt8unHxEBEpAACASFxIAQAARCp1am82RW2kaIWGUq0Ij2JodALr4STVCluLCrNbca5U6w3H\n", - "+6j7+FRXt7BSE592s67Z/vOh6J6H7chjs+klS5aEY79JciciIgUAABCprYjU0NCQli1bposuukhz\n", - "587Vzp07NT09rT/90z/VgQMHNDQ0pHvvvTfsr9UN/F2IFRtyJ41O4KO44+Pjkopbirx69epw3N/f\n", - "L6m+oNdamiQtNEH5WbsA3zagW5w4cUKStHTp0jBmkSj/+9rnQ1EF4+3IMlJtz5FfMNbTEalKpaKf\n", - "/vSn+s1vfqOdO3dKknbs2KEbbrhBe/fu1bvf/W7t2LEjlYkCAACUTdupvddfuf7whz/UrbfeKkm6\n", - "9dZb9YMf/KDdhwAAACiltlJ7lUpF73nPe3TRRRfpr/7qr/SXf/mXGh8f18DAgCRpYGAgpBC6kS/e\n", - "BcrOF5AmdVHOk08zbty4UVJ9X55Dhw5JIrXXqey1lkfRct4seDAzMxPGrKO5T093YkovD5baswL9\n", - "btDWhdSjjz6qdevWaWJiQjfccIO2bt1a9/VKpVK3izQAAEA3aetCyvbAW7Nmjd7//vdr586dGhgY\n", - "0NjYmNauXavR0dFQSJoWiwIVVeC9cOHCcGwFhv6uqxvvwGL5Ow67i+vGrradyLqc+yJP+9vk8Rr2\n", - "j+GXQSd9HSgjvwedBQzOnDlT1HQ6Tiftt/nQQw/N+vXo2Nrp06fDyprnn39eDzzwgK666irdeOON\n", - "uvvuuyVJd999t2666abYhwAAACjU9ddfP+vXoyNS4+Pjev/73y/ptVzwn//5n+u9732vrr32Wt18\n", - "88369re/HdofAAAAdKPoC6lLLrlEjz/++HnjfX19evDBB9ua1OutXLkyHFsaYHR0NIzlWdTniwkt\n", - "deWLZElJ1PiCZusZUlRHeiQXm/vXbp7pcv9Ylg6x/jySNDY2lttcgBj+NWzHndRT0NKRixcvzvVx\n", - "rTC/m3RP2TwAAEDOOmKvPd9B1vboOnbsWBizWq08+Lt6u/vwUapO4Tvw5hFFIyJVTn5vMItS+SLa\n", - "rKxfvz4c2wIO/55mUQLKzn8u2SKodorNfWQojx0HbM7d1IagKDyDAAAAkbiQAgAAiNQRqb2DBw+G\n", - "Y+t4nFbov9W+VN3SrTbvovhO35SyG/jmuBbO9ynePAtlh4eHw/Hhw4cl1ad9u+V9hu7lF0ekIe9z\n", - "sr3H0v49ehERKQAAgEiVcwVUdVYqFVWr1bwfFgAAoGXVavWCmTAiUgAAAJG4kAIAAIhUWLF5kak9\n", - "/9j/+q//Kqm+F5SF73yfECvM8z127N/4Il4r3vUhwKQ+U/PmzZMkbd++PXFeRfCPX8a5+M1t8yxe\n", - "L+vzcuedd0rKp+9To7l89atflZS8CXI7mu13ZnMp+u/j58Bc6jGXZMwlWRnnciFEpAAAACJ1RPuD\n", - "LM0W2Zienm7qZ/g772ajA+zJ1zof+UNxkagkWe0u0GvvkxUrVkiq7/JelFZbwwBl4z8zslxXR0QK\n", - "AAAgEhdSAAAAkXo+tWcdnm3D1rywKWvr8tycuhPYJqd5bHCKfFg6zVJ8Ui215tOceWz+feWVV0qS\n", - "1q5dG8asC/3TTz8dxvI+dwLN8puj2/nSl+xMTk6m8jhEpAAAACL1fERqzpzXnoKkFgVZ6rbC6fnz\n", - "54fj/v5+SdLo6GgYY++09HXbawi1InMfsS4q4mORMIvaS7X3ea+99vzvu2XLFknSpZdeGsYsQvjE\n", - "E0+EsampqZxmh9eztin+c92ivb6lSlqISAEAAETiQgoAACBSz6f28k7pmW4rNt+6dWs4fstb3iJJ\n", - "evLJJ8OYHZep91ESH/a1tG9Z5dndHfkoU8+mvXv3SpIOHDgQxmx+ZZpnEkvjSNKCBQskSWfOnIn+\n", - "ef58PTExIUkaGBgIY5Z+zSJthOb4FLSVl6xevTqMWdr8+PHj6T926j8RAACgR5T7ljvBqlWrJNX2\n", - "qpPqi5pRjH379oVjuxv00Sd/h1hmfok5y7rRyyxan3fUfvny5ZLaixzYUneptmdqWucgWz7/2GOP\n", - "hTFrV0GUuDj+fJ0UIbSFEllEU4lIAQAAROJCCgAAIFLHpfYsXZRWIbCF/nzY13qC+MdIuw9S2QuZ\n", - "W3X69Olw/Otf/7rAmdT3fLEUcEyRe9kLapEOey8uWbIkjFkawG8eXPaFEt0ija7tJ06cCMf2Pk47\n", - "Rel/3tGjR1P92c2y1ywpxXpjY2OS6t+/7Sw2aISIFAAAQKSOC4vYlXdaV+AWsVi4cGEYszsYWzYr\n", - "pb/Pm1+qmcbPoDC6xkekiCKgEYs2+6hz0oIJ5CPt57yb96IkEpXM2lVkGYXyiEgBAABE4kIKAAAg\n", - "Usel9tJmKTGfGrOUmS9AtxRgWgWLafwc0nnJeF4Qw6dJum3nAQDZISIFAAAQqecjUlaM5qMYVuyY\n", - "1CkVQPdLu90JgO5FRAoAACASF1IAAACRej61Z5J6l/gNbAEAAF6PiBQAAEAkIlIAoNr+ev44787m\n", - "1nqFxS3pW7x4ca6PZ3s4+lYatrfrihUrcp1Lr/ItjLLcO5WIFAAAQCQupAAAACKR2gPQ02zD8vXr\n", - "14cx6yPl0wF5bH5rKT2fkkhKEbW6M0JfX184np6ellTbrUGSli1bJkk6duxYGGu1l5ZPjVoazT+G\n", - "8ZuKZ9VB3m84v3TpUkn1z0Eekp4/ez2NjY2d9zWfely5cqWk+tecvU79a+PkyZOS6v9us8njuS+T\n", - "LNN5HhEpAACASJVzBVyWVioVVavVvB8WAACgZdVq9YJRPCJSAAAAkbiQAgAAiFRYsXmRqT3/2EWn\n", - "GGPmYr1IkjqvW2GqVCsmbFRwZ8WL//RP/9TyXLLS6X+jrDCXZPb4Rc/Dz6FMc/nGN74Rxl544QVJ\n", - "tULlvOdSpufl+9//fhiz3k72/Ei1Iu4jR46EMSv0t+JvqXbe9X3H7Dy9ZMmSMLZmzRpJ0pkzZ8LY\n", - "hz/84bo5Fcnm8JWvfCWM+blmbdGiReH4s5/9bN2citRoDkSkAAAAItH+oAPNtgdgq0uWpfa6KFs0\n", - "K69lpqiZrQu2X3be6lL5Rvzy625gy+PzjtDkyf/NLFIC6fDhw+F4z549Lf3bRpEae9/5FgYTExOS\n", - "yt+5vqjzedrnqrwQkQIAAIjEhRQAAEAkUntoq8MtKb3izJYeyDJE3m1/c+sivW7dujC2d+/eoqaT\n", - "iaRO2pBOnTqV2c9OSr2XPaVnikqx2XPWaTpz1gAAACVARAodexcApMGWuNvyd5SP7UPnl8dbEffp\n", - "06cLmVMSPz8r6j9+/HhR04nm9030LR1eb9WqVeHYiu/b+Xv49j2dhE9QAACASFxIAQAAROrMOBpS\n", - "tWDBgqKnkJlKpSKpvqDeOg1nWWhaRr6X0MaNGyXVd3Hu1YLkEydO1P0X5WNp1w0bNoQxS+09/fTT\n", - "YazVYm7fU2u2/nzN8mkwO/d4SeejMvJd22dL7fmi9DRSrGV/Xi6EiBQAAEAkIlLoakl3OFYQ2msR\n", - "KV/Iac9Bt7UyQHqWLVsmqb5Lvr1nfCQzDyMjI3WPL9UiSO20FGg2AuLfOxbFSups7t9PZSqCb1Wz\n", - "7Q8a7QZgETgf+ZvtZ+e5r1+aiEgBAABE4kIKAAAgEqk9pFJk2Ul6tajY94axkHyvFpiXlaVAyvCe\n", - "tAJvXzRddOol7Z5MzW7y7nvtWZrPjyWlF5PShp1STB2TlrSeUv71YqnOmZmZdCZWUkSkAAAAIhGR\n", - "Qt2y+F6QZ6Fssx2C82DLxaXio3K+5UbehctlZnfwaS/Lj2HRH19A7V9DvcQXSNvz0Sn75uXF2sr4\n", - "iFS3R6IMESkAAIBIXEgBAABEIrWHujQC0uXTeVacWlRKgJ5R5WevjTKkjTpxs908NPs+sl5tvijd\n", - "is2LLtpvxJd7NPv7WuG+T9v3StkIESkAAIBIRKRQirvfXsDzXEN0rHP4CIO9hpvtfN3LLBLViTso\n", - "+Chas+9Va5fR398fxiwCNz09neLsyoeIFAAAQCQupAAAACKR2kPP9oZBcZrtKJ0n26RXklauXClJ\n", - "mpqaCmOdmKJJg+9j5Tcwxux67fVi/aN8CUOvpICJSAEAAEQiIgUgNc0umy7jnmMbN24Mx8uXL5dU\n", - "33W91yIMxv8dy75sH+nwxebNGh4eliQdOnQojPVKCw0iUgAAAJG4kAIAAIhEag/IgBXl+k2LrWg3\n", - "ZpNe2xC07KxIW5ImJyejf449f3kWq46NjYXj0dFRSeXqfzNnTu10XVSxvhUUt5Oa9WkjSwX7gnb7\n", - "PX1KMY1UsH/+suI37C1j+rpZ/rxlfwf/97DdMPzva+/VXikw94hIAQAARKqcK+CyuVKpqFqt5v2w\n", - "AAAALatWqxeMMhKRAgAAiMSFFAAAQKTCis2LTO35x85zHr7Y0Y7vuOOOVOfSTkGqf/zvfOc7kuqL\n", - "Dq3g2W+JEOp0AAAgAElEQVRK+ctf/lKSNDExEcbe8Y53SKrvy/PII49IkmZmZs77eZdddlkYsyLj\n", - "d73rXefNy3r7SMn9SaxwNa0Ncfv6+iRJn/jEJ86bS1GKeu0mKeNcip6Hn0M7c7FiXqn2eo7Z9Lrb\n", - "npe0MJdkzCVZozkQkQIAAIhUWETq9Xs2ZbVkcvHixeH4xRdfzOQxmuUjRFktX07r59py5AULFoQx\n", - "uzP2S5V9JMr87//+ryRp165dYcxHooxFmPzdd9LPM4265KYViTJpLH33rz/2NMyej4LaOcW/Luwc\n", - "cPLkyVQez6KqaXc9X7RoUTi2SFRac0Z77Hzlz4PobUSkAAAAInEhBQAAEKmw1F5e3U9Jp8QZGRm5\n", - "4NdWr14967+1VEpSOs+zv43f5NIfdwNef/nyXbOt54sv0k47HWOLMdJO7SUVm+fNyi98ev/EiROF\n", - "zGXFihWSpGPHjhXy+B4pvdaVoSt/lohIAQAARGKvPSSaraCyUdF3sywq6e8yu/FuBfnxkRzbB8za\n", - "Yki1KFXMfodJrNg8rZ9n2tmnMC2z7Z3mI38xbRmacemll4bjbdu2Sarfv25qakqStHfv3jBWpr0R\n", - "UWMRRakcr+20EZECAACIxIUUAABAJFJ7TbKUge8LZIWmvgDzzJkz+U4sI/b7+kJXC+GnVWx5+vTp\n", - "88Z8USLQKt8rzl5fPrWXdgrOFhP0Wkra0qZS+jsKGN9rcNWqVZJquw1I0tjYmCTpyJEjYYzUXjml\n", - "/b4rGyJSAAAAkbj9b5LdHS1dujSMWUTKF2PalbcviuxEdnfp99qzu/20i0v9nacvYgVa5aNPFjXx\n", - "kZK0I0cWne21iJRvgWLPQdrRIN+C5dlnn5WU3H7BR6kOHjyY6hyaZZkKH1FPa1FON0i7PUjZ8KkF\n", - "AAAQiQspAACASKT2mmQpO19Mbik9X+Da6Sk9Y+kQH6peuHChpPr0WxobqfrnLI+uwdapudsLIHuR\n", - "f71aWtq/ptLecNZSekV1H8/D4OBgOLbn179ns+oj5c8tu3fvliStX78+jG3YsEFSrRBdqpVe5L3B\n", - "sz0vvhTCjv3nA7oTESkAAIBIRKSaZHecvgu33YlldUdWpKSib7v79i0g7E7MF9smjc3G38XlsTdd\n", - "N0cPOkVSUbh/HdhrqNWCXR8psWM/lnZ7jawi0H6e9vzkvcebnQN8V2r7G/l9NPOIwluRuT/3LFu2\n", - "TFL9YpVFixZJyj8iZcXU/m9kkW8iUt2PiBQAAEAkLqQAAAAikdprkU/j+e6+3cZSC/53tOJ6C1n7\n", - "7/NpvFZTev39/WEsjzRp3ikSnM+nV+114Dccjl0I4Hu6WbrFp57Sfs9m1T/Kz7Oo16u9F32azNJo\n", - "/u+XtKlx2uycs3LlyvPm59OMefYr8ulXex343Rp8qhrdjYgUAABAJCJSLfJ3ikuWLJFUf/fcKYWF\n", - "vmgzac52h5VUvOvvkJOKd5stNreCYysQleoLW9Eb7PWXxnvHRzST9trzr/tYfiGGFTxPTk62/XO9\n", - "MkVN/QIQHxEyeUSk7G/oo+EW8fHPfR6LVZrVKZ8FaB8RKQAAgEhcSAEAAEQitdciX2TZiZtSWirC\n", - "F3gn9VzxvVmMpRv8c5DUk8lSH/5nJIX/bWx4eHjWn9cLkoqgfUqq1zbFjeWfM3sd+iJ2687fDp8+\n", - "7MYecq/nzw9WzJ20w0OW7Lzgzw/29y1qNwnekzBEpAAAACIRkSqIv3M2rXYEj2Edgv1detJdtY0l\n", - "Fb02KqJs9g7Vfs+jR4829f1lYpE9qba/ly/EtTv3AwcOhLHZ7pyvvvrqcGw/x0f0ylREW2b+tWfH\n", - "SWNpmZ6evuDXkpbHp23t2rXhOKlDfBpsUY1Uew3781ceUTl7T/iIohWepxFlRO/w0f+0oplEpAAA\n", - "ACJxIQUAABCJ1F5BkoqqLSSfZWrPwuA+xZEU3vQdelFz6aWXSqpPu1kfsaTndNWqVWEsaWNT66Hl\n", - "U0S2iMH3K0p7s91uNTU1NevX8yiMNn19feHYNjv37zV7L1q6PYbvwWbp+rS7t/vntNHzm5WkDeIn\n", - "JiYkSYcOHSpkTuhMWSxOICIFAAAQqXKugLWjlUpF1Wo174cFAABoWbVavWA0i4gUAABAJC6kAAAA\n", - "IhVWwVpkas8/dtEpRuaSrBPnYv2kpNqCAd8Buh1WbP6P//iPYexf/uVfJNUXT1rhuy90tuJ1v4jB\n", - "fp7vhzVbTyTPCuhvu+22MFaWv9E3v/nNMGbzHB0dDWNWkD0zMxPGrPjfLyCw58c/t9a3yP9b4zfb\n", - "/tSnPlU3pyLZHMo0l+985zthLGlRhr0O/Y4Httn0Nddcc973+WJz63nl/5YDAwOSpP3794exT3zi\n", - "E3VzKlIZ/0bMpV6jOTSMSH3sYx/TwMCArrrqqjA2PT2tG264QVu2bNF73/vesCJFku68805dfvnl\n", - "2rp1qx544IH4mQMAAJRcw4jURz/6Ud122236yEc+EsZ27NihG264QZ/97Gf1la98RTt27NCOHTu0\n", - "e/du3XPPPdq9e7dGRkb0nve8R3v37q1bxh3Dd+8dGxs77+vWZbdX92krA/837oX9x5Ik7VmYlqSW\n", - "GBZ98uwO3y+BT3r/2c9rNgrlFbUEvhn+ps6en2b3xGzUAX226KJ/3G5h7RnSiqqagwcPhmM7V/gd\n", - "AJJYZ/9HHnlk1u+zFiM+kmg7McS81oFmNLzCeec731m39YUk/fCHP9Stt94qSbr11lv1gx/8QJJ0\n", - "//3365ZbbtHcuXM1NDSkzZs3a+fOnRlMGwAAoHhRoaLx8fGQdx4YGND4+Lgk6ciRIxocHAzfNzg4\n", - "qJGRkRSmCQAAUD5tF5tXKpVZO+mm0WXXb5q5efNmSfWpDgvdJxWBIh9btmwJxxs2bJBU/zfatWuX\n", - "JGlycjLfiXUxS18k9TaxFIeUbzfvGFYY7DfSjt2k2W+o3Whzbcwu7ZReHuzzxr8n2PA7HxZE8ed9\n", - "K3fwuzmU/XwUIyoiNTAwEGqVRkdH1d/fL+m1D1C/guLw4cPhQxUAAKDTPPTQQ7N+PSoideONN+ru\n", - "u+/W5z73Od1999266aabwviHPvQh3X777RoZGdG+fft03XXXxTxEHX93bdEp25dOqr+TRTF8CteW\n", - "ifu7QiJR+UoqRC8TKw2QpDVr1kiqX7JurycrG2iWj17780avswU5UvGLclavXh2OrQA8rf1FbWGF\n", - "X/BiLT6ITGXLnnMfcerkhUe22EKSrr/+ej388MMX/N6GF1K33HKLHn74YU1OTmrjxo360pe+pDvu\n", - "uEM333yzvv3tb2toaEj33nuvJGnbtm26+eabtW3bNs2ZM0d33XVX6htoAgAAlEXDC6nvfe97ieMP\n", - "Pvhg4vj27du1ffv29mYFAADQAQrrbN4KH963wnIfdmu3T1UrfBrRuu36otZOLNBMg++h9Pjjjxc4\n", - "k95RwH7jqZmYmAjH9trx7+k0+jLRX67Gl0KcPn26wJnUd4G31I9P7VlqKGae9lng08SWSiS1ly2r\n", - "m+7kdJ7XynUFe+0BAABE6oiI1KJFi8KxFZP6O5g87zj93mTWqNS3XejViBS6k0Vgfa2jX8ocy9+1\n", - "WuQhjUiJjw4TiaopOgrl+b+L/b3868uiZ/5c2mz0NWlpvS28KNNz0I1skZFf6GLvc/va67+eBtvj\n", - "NO2dJVpZAEFECgAAIBIXUgAAAJE6IrXnQ8EW7vVh3zRSDc3yYUnrgcJmmI0lpUFRfnm+t9JAu5Xy\n", - "8+k3S7f5c/ycOa99LKW1mMJ62HVjR+2+vj5J9YsJRkdHC5mLlQH4Xm72OZ3W39JeG0mLE9LWys4I\n", - "RKQAAAAidUREykeB7ErUd+q1q/E89tbyS2hZTjs73yrCFgzkHZGyFhX+rqXToixoXrcsvU5Spu7k\n", - "7fDRiaTfI60u58Y/b93GPhvLkBWxYm9/3rfnPo12JhdShj01iUgBAABE4kIKAAAgUkek9jwrNrOU\n", - "jVQLD5chxJcVX0xoz0HZU4s+heY3Nc6aPT9S7XXiUz7dltrzv6+lRXzRdSd3QG9VnrscSLWUddoF\n", - "r/79vnz5cknS1NRUqo9RFP96TeJ/d9Pqud0Wt0jSxo0bJaX//JXhPVam3lh2jvWpvbRT0GVN3ROR\n", - "AgAAiNRxESkrrvN3LWW9Sk2Tv/uxfaTKHpEqir8LskhBN0Yrbemzf/1bUad9TapFAPyela3qlLYC\n", - "a9euDcf2/vCRCLtb9jsU2F19o10JLDLk33f2b9N+fvx+dLYHYbdEpPxOFUnSOJ/7n2H7s6YdHfG/\n", - "h30udfIigLT4z+a0o/9l/awnIgUAABCJCykAAIBIHZfaMxaulTon7dAO30sr7U0fu40v/LSUXllD\n", - "wu2wlN3Ro0fP+5pPA1lKqh2dUrDun4ukNIulGvzz02yBuj/nvF7az49/LHsNd0vaqFHPozTSQf75\n", - "m+3v1g5fVG2fQb74uxvPOc04cOBAOO6U80a7iEgBAABE6tiIlI9CLViwQFLjYtGsWDGoVIsW9cqV\n", - "eNqSlj63o6jXRB5OnDjR1PdldUdeRjHR2jJGDnw7hU6ORPmojRkbGytgJunzkUzr4O27qJfxdZWH\n", - "Tv/ss0h/K5F8IlIAAACRuJACAACIVFhqb+HChXWbU9pxUpdm65vkv+5Te3a8Zs2aMGa9XnxYfOnS\n", - "panNX6r1ovEh3E4PazbDpzLTSJ35LvW+IzFm1ymLDvzf1N6r/n1p79WkzWr9+3z9+vWS6nssNeqS\n", - "3an8OSWNFFFRXbjT6iNkPZv8Z4Gde4rqEVeGjYKz4j8r7b3qC+kthenff3n8HQYHB88bs9KemZmZ\n", - "MNZszzUrJbn88svD2Lp16yS1tnk2ESkAAIBIlXMFhFAqlYqq1WreDwsAANCyarV6wWguESkAAIBI\n", - "XEgBAABEKqxSs8jUnn/solOMnT4XK/70fW+KmovZunVrOB4eHpaUXJhtRYWSNDo6mslc0sZcktnj\n", - "Fz0PP4dm52LFslL6CwjaeV6skLiVotus5pK2Vufie0al3R+q6OfFL0T4whe+IEn64he/GMaKWkBV\n", - "9PPiNZoDESkAAIBI3bl2uEfYcnBJOnLkyHlft67C/g4q7S7JtrTd37Uk7f1mc02aZ9oOHjwYjpPu\n", - "Hu0OLK2l2UA7fDd/W0JeVBTAz6XZyIsthU/73JLU4qaobuEbNmwIx6dOnZJUv9zerF69OhxPTk5m\n", - "P7EUJL3WOrGNj88wWEuVZnd/aBcRKQAAgEhEpDpYo+iORVz8nV3ajh07Jql+jylrntfX1xfG7DiP\n", - "iJRvGGq1W76Ga8mSJZLqG8yhOBs3bpRUey1J0smTJ4uaTu7KtBdiTFPFrKIX/ucWHSE5dOjQrF+3\n", - "c4qd+6RaRoDIdz78Of7SSy+VVIseSrWaPx+lSuvziIgUAABAJC6kAAAAIpHaa5It8//ABz4Qxqyw\n", - "0Idu77vvPknS+Ph4jrObXZZh8dlSAX7Z9OHDhzObw+v5ItCk4lR7PvySZuTL75e3efNmSbUCUUna\n", - "uXNn7nNCnKIKwMvEUkg+leTLHZA9n1a1c7ylXKXa3ohZLALgkwQAACBSR0SkknZ79wVjaTeDTGLL\n", - "932zx5tuuklS/RXugQMHJEk/+tGPMp9TEn8XlPZy5Fbl8XdJ0ugO2d81Il+2EODiiy8OY/beevbZ\n", - "ZwuZkxW7+8URtnt8npFUz5/zLOp75syZQuaCOFm1gyi68L6sfIbBFqv4KJWde3yLj7Q+o4hIAQAA\n", - "ROJCCgAAIFJHpPY8Kx6zFJ+UXOiXNuuW/ZOf/CSMWW8R/7hJXb3zYKkA30Nptv3jgCJYempiYiKM\n", - "2cIM30cqT5YOHxwcDGPWA6io1J7fcy+tve46me1H6FMxvVbkbgueYnp99QL/OWwLV/xCMNuFY9Wq\n", - "VWEsrX51RKQAAAAidUREyheWWwGfL6pOe8f0JHb388gjj4Qxf1wEv6+T3a2UqUsycCE+Wlp05HR4\n", - "eFhS/XvHt2IoQh7ntE5i599ei0J5RS3e6RQ+op1U6G+LwrJ4bxORAgAAiMSFFAAAQKSOSO35cG4v\n", - "bWbaiC9CteeFQkQgju+Ij3IhrUX/qEaa7duVRT82IlIAAACROiIihWT+ytq63gIAkKRMO190EyJS\n", - "AAAAkbiQAgAAiERqr4P5wnLbiNH6SUm1MC6bnaJTWUdrid5KKAfreu8X+9iOEqdPny5kTo3Y54Pf\n", - "xJfFFekhIgUAABCJiFSXsL0HbT8hSXrDG167Tvado/3eQ0BRhoaGwrHd2dt+kVKta7/tZylJzz77\n", - "bD6TQ+ksW7ZMUu2cJtWiP75oOo8Caov09/X1hbHFixdLqu3JKmW3R6JfWNRsSwSL7CbtR2sRtm5n\n", - "v2cWn4FEpAAAACJxIQUAABCJ1F6XsNSeL861MTriomwuu+yycLxq1SpJ0vr168OYFZaPjY3lOzGU\n", - "kpUs+NIF283Bv0by2Gx66dKlkuo3jTdZpfOkWkpvzZo1Ycx+30a/t6VEk9JaS5YsSWuKhfKF9JZ2\n", - "9alg+xz0pS5p/b2ISAEAAETqioiUXX1OT08XPJPi+CtvY/tTZXmXVHZ2F+ejcrZU2d9R+qJmZG/v\n", - "3r3h2O6wfaGuLc1+5pln8p0YSskiLr6VixWb5xGF8iYmJiTVF2mnsRdgo67jdg47evRoGLP3jj//\n", - "21zsPCfN/hx1SxsEH22b7TnI4vOQiBQAAEAkLqQAAAAiVc4VUIlcqVRUrVbzflgAAICWVavVCy7c\n", - "IiIFAAAQqbBi82YiUn/8x38sqb64bufOned9n3VJ9stgZ9uXyz920ZGxtOaSVFRd1FzSwFySdfpc\n", - "rCVH2gWf9vhFPyd+DsylXjfPxfay8/ufzsa3HPj0pz+d6lza0Sl/ozz24LRu9ZL0mc98ZtbvJSIF\n", - "AAAQiQspAACASKXuI7Vx40ZJ0gc/+MEwtm7dOknSvn37wtjv/d7vSarvBfTAAw+kOpfrrrtOknTi\n", - "xIkwtmfPnlQfox3W1dWnTJoNMwN56eWeZuherZ5rkzYPRvOS0nlbt24Nx9dcc40k6dixY2HM+n9Z\n", - "/zGpthF60t+vlf5kRKQAAAAilToi9dBDD0mqj/xY1MkXm61YsUKS9OSTT2Y2l7e+9a2SpLe85S3n\n", - "zeWnP/1pGBseHpYkjY+PhzHfjTcreXf3BWLMmzdPUuNO0Fa8a/vwSdKRI0eymxjOY4t4/Lm2TFH4\n", - "ovnO5kl72CEfy5YtkyT9yZ/8SRj7/d//fUn1i69effVVSdJjjz0Wxu6++25J9fvvxSAiBQAAEIkL\n", - "KQAAgEilTu1ZGLlRODmPcLMVqp08eTKMWdrBNo6UpMOHD0uq70GRR2ovT5aekWq/uz0/UjobeCI9\n", - "y5cvlyRdcsklYcw2Od2/f38Y8wspspK0uXYSK/6kOD1f/lxmvXPe/e53h7Hdu3dLkr7xjW+Esf/+\n", - "7//OZC5+E187LtO5xRb4SNLx48cLnElvs7KWycnJMLZr1y5J9SlXe237MhhfjN4OIlIAAACRSh2R\n", - "alYed6333XefJOnee+9t6vt9IWK38c+3RTHKdKeIenbn/MY3vjGMWQGxX4adR0Sq1aLcbovmlp0v\n", - "LB8cHJQkXXHFFWHMopt2PszSK6+8knhcFkSh0tPOzhz22vjOd74Txmyxiu2kINWimv48l9ZWw0Sk\n", - "AAAAInEhBQAAEKkrUnt5aDUl0c19Rawfh5TdhpFIj/VI+cUvfhHGLEWTdwq61RSN70Lcqyzdlsd7\n", - "ze8O8Z//+Z+S6vvkWao1qwJz9KY0Umz+Z+T9uURECgAAIBIRqSZZOwM6iNfr5shbt/GtDjqFj34i\n", - "X9/97nclpVeQC3QrIlIAAACRuJACAACIRGqvSdbnIub7uzk0br05ytjnBZ3PiuKlWgFpry1wKOr3\n", - "7ebzFpAmIlIAAACRiEg1yXeAbkav3M3Z3mlEpJCFvr6+cGzvwV6LSAEoNyJSAAAAkbiQAgAAiERq\n", - "D0Bp9ff3h2PSx+W0cOFCSWwwjd5FRAoAACASESm0hc7TyMKqVask1b++JiYmipoOXmf9+vXh+KWX\n", - "XpKUT0RqzpzaR9bLL78sSRoYGAhjk5OTkoheIl9EpAAAACJxIQUAABCpI1J7c+fODccLFiyQVN/X\n", - "ad68eZKkF198Md+JQUuXLpVU3zfr+PHjRU2nY9nzKEknT56UVOvRJXVfCjUpRePZzgAnTpwIY6dP\n", - "n85+YgjsXLtp06YwZilXKzCXpEcffTTzuSxZskSStHXr1vPm542Pj0c/hv28Rn3K7LW5aNGi877W\n", - "7Kb29vugOxCRAgAAiNQREamzZ8+G47Vr10qqvxuwO9qYiNT8+fOj/+1s/Py6+U7aCk17pdt0s3sL\n", - "WpTUL9+346To0szMTDi2iFS3RaG8pCiUZ0XDre4o0MssUpLWrgr2nn7mmWfCmJ0v/V6iebz37XVw\n", - "6NChMLZy5UpJ9e+ddljmw38WLF68WFL9Z5BFk/w53p5zH2k1vgjfzpdJ0bQy8Vkg+8z178VWn3N7\n", - "HiVp48aNkqS9e/eGMXs9deoiASJSAAAAkbiQAgAAiFQ5V8DuupVKRdVqNe+HBQAAaFm1Wr1g2pyI\n", - "FAAAQKTCis2LjEj5x252Hs0WGecxl6wwl2SdPhcrfLdC1yLnkhV7/KLn4efQ7FyGhobCsRVuj42N\n", - "nfd9vgDYFz+nOZcspTEXKzCXaot4YhYKNTuXwcFBSdK73vWuMHbgwAFJ0iOPPBLGrH2JFVJL0u7d\n", - "u1OdSx46eS6+oN0K5J999tlU53IhRKQAAAAicSEFAAAQqSP6SDUrqTt0Wiw9ksfGnI1YmtH3LJkt\n", - "vL1s2bJw7DtFozc0mwZCvtasWSNJuuyyy8KYnbd8bybrV+RTe5Ze6jVp9Yxqlu3SsGvXrjCWlHa1\n", - "NOP09HQ+E8N5fLf9P/iDP5AkLV++PIz9+te/zuyxiUgBAABE6riIlBWU+aJv65KcdhTKK0Mkytjv\n", - "3mzhO1Go3lZAhxM0YWJiQpL0xBNPhDHr6O7/Zvb+9XfcyId9pjz++OOzfp+di5OiVVlK6rJ+9OjR\n", - "XOdQFn6P1+HhYUn57WlIRAoAACASF1IAAACRSp3a6+vrk1TrCSHVeuGsXr06jO3bt0+SNDU1ldlc\n", - "strcGOlZsWKFJOl973tfGBsYGJAk7dy5M4w99thjkvLZFPgNb6jdq3TzJsRonS0W8SUJSWlYe908\n", - "//zz+UwsY7ZYRurcTWqL5BcnXHvttZLqS09sk2m/2XQv8ItqrMdXXp/XRKQAAAAilToiZcuDt2zZ\n", - "Esbsjs0XlmUZiTJEosqvv79fUn0E88orr5RUey1J0t69eyXVCnuz5OeSFIHIczm377q8atUqSdKR\n", - "I0fCWK8WqRbFFslUKpWmvt93bu7k6JQvAD516pQkIlOt8K0xbCGCfz34Nhm9Ku/PayJSAAAAkbiQ\n", - "AgAAiFTq1J5tOOjDdBbe/u1vf1vInMrAnoMFCxaEMUsX+W7n1m03Dz5tZP1uDh8+nOtcLGVnixSk\n", - "Wl8XX3iZR0rPCmr938h6vfi0dJ58l19LK/n+MzZXnzpA9prtPN/J6TzP/76k9Fo3MjISjo8dOyap\n", - "/j3rU8DIBxEpAACASKWOSNlds3UpxWvsjs5HO+zOztpD5M3fBdniAL9M93/+538k5XNXbe0NXn+c\n", - "J/t7WPdqqbZQwgps82YRXqkW5aUlA/KWZ6Q8L7Z4w9qtSLV997Lsdm6fkb7AvEy7cPQKIlIAAACR\n", - "uJACAACIVOrUHpJZ+i6P/lnNOnDgQDi2AmafNioq5Vi0LDfSbhUhfyA9fhPpwcFBSfWLbmzhT5ap\n", - "PXvclStXhjErPB8fHw9jvsQA6SMiBQAAEImIFFLhox379++XVL/PnBVf256FEt3iAXQuvy+iHfvI\n", - "uxWCZ8lamviFPdYp3y9GIiKVLSJSAAAAkRpeSH3sYx/TwMCArrrqqjBWrVY1ODioa665Rtdcc41+\n", - "9KMfha/deeeduvzyy7V161Y98MAD2cwaAACgBBqm9j760Y/qtttu00c+8pEwVqlUdPvtt+v222+v\n", - "+97du3frnnvu0e7duzUyMqL3vOc92rt3b12KB93PQss+jbdixQpJtY7fEuFmoBf5TZp9eqzT+G7i\n", - "di7zqb08+mVZeYRPIy5dulRS8x3z0b6GVzjvfOc761YEmKQ3wP33369bbrlFc+fO1dDQkDZv3qyd\n", - "O3emM1MAAICSiS42//d//3f9x3/8h6699lp99atf1YoVK3TkyBG9/e1vD98zODhYty9QmnwhnS2z\n", - "79Ul9mVjheerV68OY3b3VqZ2AEDZ2HnN36ha12o/1sn77ll0WpJmZmZye1wfCUub7Xk3b968MJbH\n", - "rgH2OvCtDqyj+tNPP5354+M1UTm3v/7rv9Zzzz2nxx9/XOvWrdPf/d3fXfB7s3zxAgAAFCnqQqq/\n", - "v1+VSkWVSkV/8Rd/EdJ3GzZs0KFDh8L3HT58WBs2bEhnpgAAADl76KGHZv16VGpvdHRU69atkyTd\n", - "d999YUXfjTfeqA996EO6/fbbNTIyon379um6666LeYg6Po136aWXSkrepHHv3r1tPxbi+HC9FZT7\n", - "1J51/D1y5EgY+9nPfpbT7FA2PgViUWv/ni5qY+ci+PfOm9/8Zkn1PdgspeffO5zrWpdlYbv9DX06\n", - "z1JsWRoeHq77b16sa3tavbLsHFDWxQfXX3+9Hn744Qt+veGF1C233KKHH35Yk5OT2rhxo774xS/q\n", - "pz/9qR5//HFVKhVdcskl+ta3viVJ2rZtm26++WZt27ZNc+bM0V133UVqDwAAdK2GF1Lf+973zhv7\n", - "2Mc+dsHv3759u7Zv397erF5nyZIl4diK6k6cOBHG2lnmuWrVKkm1zttSrXDQS/sKvNv09/eHY1vl\n", - "uW3btjBmkUS/ZLgX+GhD0uuqV/n3m3Vn7tWFCP51YZEmO99ItUU0x48fz3diGWl2UVBSmwQfybRz\n", - "cbNF3T6zkTZrQ+Bf13m0PyhK2gGSskaimkWDJwAAgEhcSAEAAESqnCsgplapVFStVvN+WAAAgJZV\n", - "q3b7suYAAB+fSURBVNULpiCJSAEAAESK7mzeriIjUv6xi46MFTWXpKLNz3/+84XMJQl/o2TMJZk9\n", - "ftHz8HPoxLksXLgwHFtbmSR+H00rtE57LllKey62aMkvCGh2YVInPy9DQ0PheLYWDP77Dhw4IKlx\n", - "gXmzc7HPsix3Nmk0ByJSAAAAkbiQAgAAiFRYaq8VvstvHhtB9gIfVuU57T2LFi2SVN+DrZ1+bOgO\n", - "s6XzpFp/K9+FvtnUXqtshwSp9npN6jW2ePHicGyv4bTTPP4zyPoa+l6GdtwrfQYttes3S04yMDAg\n", - "SRocHAxjY2NjkprvKdjo8z/LlF6ziEgBAABE6oiIlL8KTbojanQXlZXNmzdLqu9e/dxzz0mSpqam\n", - "CplTs4g+9B7f2XnLli2S6t87Bw8ePG8M+bK/kX9/+m7ZRbOISx57Ifqo+RVXXCFJWrp06Xlfn5iY\n", - "CGO//e1vM5mL7+SdFBXrtfNps1FIK763KJRUH2lsRloZE9tBIYsdAohIAQAAROJCCgAAIFJHpPY8\n", - "Cy37or48+kgYH5a0jXgvv/zyMGYFdGVP7aH3+OLOxx9/vMCZwPM93aw412/UbqmIkZGRMFamTV4t\n", - "7ZX2nPxG6OvWrZNUX7Rsjh49Go6zSkv7vlndvBlx2uyc49OvWS1OaGTt2rWSaik+qVbO0C4iUgAA\n", - "AJE6LiKVJM/lj77o0BfvGloJoNPZgg6pd5ZzF8mfv2wZvR+bnJyUlG0Uyhbv+Mdo9m+fR3TMIk37\n", - "9+8PYxa18xG9rPjzfpnY381/Ftlrp6jIT5IsCryNdZW3FhmSdOjQofO+75lnnpGUzeuFiBQAAEAk\n", - "LqQAAAAidUVqL08+3P3II49Iqi+K3LNnT+5zQhzfkyapN0yvWrZsWTienp4ucCa9Z2ZmppDHte7R\n", - "ZUrl+t5Dlq7yr8c1a9ZIqu9sbumdtAvCn3/++VR/Xlqsf1VRfaxsEYBUK+L2ryFLsWWZZrRzt+/n\n", - "aD0efSrYNFsK5EscGiEiBQAAEImIVBvs7qgT79p98aTvEt9LiELVu+yyyyTVd9LuxNc2WlemwuQk\n", - "Sa9DW1K/cOHCMGZREVoU5GN0dDQc20KJvKN3FmF69tlnw1gaiwNaic4SkQIAAIjEhRQAAEAkUns9\n", - "yvd+KdOmqMiX771iKRLfKRooO784wtIxPuWEfJSpID/vzv9EpAAAACIRkSohXyiXx5U1Eane5Yty\n", - "jxw5Ikk6duxYUdMBmmZtD/xuEuws0Xt8+wuTd3SMiBQAAEAkLqQAAAAikdorobxTe3mw38m6EUsU\n", - "NZcNPaNQdr7nnW1a7BdMkJbuPZbGS0rx5YWIFAAAQCQiUim46KKLwvG8efMkSWfOnIn+ed1YMLlp\n", - "0yZJte63WWIPPaC7WIsDv6/p6tWrJdX2CZSkU6dO5TsxlEaR7ReISAEAAETiQgoAACASqb0U+D5M\n", - "7aT0upk9L1kWNK9fv15SfafjPXv2ZPZ4vcSnrxcsWJDqz7Z0uG0+2g5fcFqmTsv2O/pzhc3VP7fW\n", - "XX5qaiqMJW0obOksXwZgCzraWaDi02Q25xdeeCH656XFNiO2jbWl2lx37doVxsbGxvKdGCAiUgAA\n", - "ANGISCEX4+PjmT+Gdeb2ku7cu8XKlSsl1UcR5s+fX/c1qRaZGR4eburn+oJeW1puS82zkEYkypQp\n", - "CuVZpOn48eNhzH5vi7ZItWiqXzBh0SnbR06S5sx57dQ9OTkZxtJoleLfJ2Xa8eDQoUN1/5VqrRDO\n", - "nj1byJxQLv68lUZrHd+GqBEiUgAAAJG4kAIAAIhUOVdA6+xKpaJqtZr3wwIAALSsWq1eMH1ORAoA\n", - "ACBSYcXm7UakVqxYEY6twNQvI7YCxKSCSf/YRUfGmEuyss7lS1/6kqT0i9dtqbk0e/F1zPNiheJp\n", - "dX22IswvfOELLc8lK/b4Rc/Dz6FMc/nqV78axpK6/bdTuG2vL3+3boseZmZmwpi9Xsr0vDCXep04\n", - "F3ut2YIOqbaDRtJ52u/X2OzrvdEciEgBAABE4kIKAAAgUsf2kTp27Nh5Y/QTQday6keVZi+l1/P9\n", - "h2Zj/Yx8r6MkaaxP8X2p7Nj3RGp2zt3AekJJ2f3ejTbvbufcmZQyLms/L3Qfe8/43mtDQ0OSpNHR\n", - "0TBmvQz9az2N3QAkIlIAAADROjYiBbyedfi++uqrw5jdLe/fv7+QOZVBs3ulNYpEpemKK64Ixxs3\n", - "bpRUH5HavXu3pGz3ZiyLXoq+IV1WOL1hw4YwZgX+eb6fi2QLyvw+i3be8Ds8rFu3TlL982L7WLbb\n", - "xZ+IFAAAQCQupAAAACKVOrXXzRvOdgsr1rNeHv4479CyhbnXrFkTxi6++GJJtb4iUjobWnYiv7mx\n", - "FWYWFf73BZ9W6On7wNhmyWVK7eVxPrL3ji9Ap3C7XOx1cOmll4YxW/zk09N5sNfi+vXrw9jatWsl\n", - "SY899liucymaP6fYcaP3jn1mkNoDAAAoSKkjUmWKRNmdor9ytSJRH42x4rVeYdEEX9Bc1HNgj7tn\n", - "z54wtnXrVknS4OBgGOu1iJQVc7///e8PYxap8x2v/VLhrD3xxBPnHS9YsCCMNVsgn6c8tiXdtGmT\n", - "pProoX89o3j2uVSGBSz2efSzn/2s4Jl0prRaJhGRAgAAiMSFFAAAQKRSp/bKxDZE9pvLWrfgXkvn\n", - "NZJHCmQ2hw4dCsdWTG0FmL3IOpb/zu/8Thi75JJLJNX3c8oztZekjOk8L4/X9d69ezN/DADpIiIF\n", - "AAAQiYhUk06fPl30FBDB2h749ge95qmnnpIkfetb3wpjVqT6y1/+spA5AUDW/KKNpMVr7LUHAABQ\n", - "MC6kAAAAIpHaA3rEz3/+86KngA5ifb3KvggAuJBGvSjTWkBCRAoAACASESkAwHnS6voM5MHvT2m7\n", - "juSFiBQAAEAkLqQAAAAikdoDAJzHis19L56XXnpJUv3m7QsXLpRU2+khy7lQ+I4LWbJkSTg+duxY\n", - "ro9NRAoAACBSV0Wk5s+fH47Z/653+TsTW/5KZ3qgNfY+GhoaCmNLly6VJB05ciSMPfvss5nPJe/i\n", - "YXSevKNQHhEpAACASFxIAQAAROqI1N6yZcvC8cqVKyXVig+l2saDU1NTYWxiYiKn2aFsfFp3+fLl\n", - "kqSLLroojD3//POSGne9RWebO3eupPT6IVlRtf1Xqr3W7DVVVvZcSM0/H5bGW7t2bRhbv369pPpi\n", - "8927d6cxxVmR2kOZEZECAACIVFhEqlKpNL3PjY9IrVmzRlJ9NGF6eloSUSi8xt9xnzlz5ryv92ok\n", - "KiYq0Wn8gpO09tF6Pb/Mv1Oex5h52vl0165dYWx0dFSSdPTo0XQmhqb5z0Fz4sSJC36/ZWokqa+v\n", - "T1L9e8JaWaB9RKQAAAAicSEFAAAQqXIuq/j3bA9aqahareb9sAAAAC2rVqsXLBcgIgUAABCpsGLz\n", - "IiJS1jrhk5/8ZKHz8PzjtzMXK8L3BYatFoSmNZc0pD0Xv19Yq8Xm3fy8tKOMc2l2Hv71YNJahNDq\n", - "XLLEXJJ121z6+/vPG4tZENBtz0sjze7h2GgORKQAAAAicSEFAAAQqdSdzbdu3Sqpvt/F5OSkpPow\n", - "/KJFiyQ1DmWeOnUq7SkWyjoPS9I111wjSdq/f38Yo9dLTa/2jupUtmHu4sWLw9j4+HhqP3/OnNqp\n", - "j346Nf55KVM3ceuo7lMw1j+wrHPOk38O/HERcyj738Bvam/HY2Njbf1MIlIAAACRSh2RmpmZkVTf\n", - "kdmWH/qiar+32mw6pQtxs/zv/ctf/lJS7S4Nr7E99vzeYCinD37wg+F4cHBQknTfffdl8ljNRqEG\n", - "BgbCsb2Wjhw5ksmcpFoR/HXXXRfGLJL+1FNPZfa4xu8j6Du4F23evHmSpEsuuSSMHT9+XFJ95N32\n", - "W+2197t/TVqmwvYZlWrPVdrs7yJJb3nLWyQlR3f8WKPC7qz5zFRamQoiUgAAAJG4kAIAAIhU6tSe\n", - "bZq5efPmMHbxxRdLkp577rkwZhtp9hqfniCll6zXQvxpsN4qUr5h+NWrV4djSysNDw/n9vje0NCQ\n", - "pNoiDqmWPskytWephsceeyyzx5jN6dOnC3ncRux14Aup7TXCopp6eaZkr7zyynD81re+VVItLS/V\n", - "/m7/9V//FcayOqf4tHTSZvXGn9/SWmhCRAoAACBSqSNSdnfmrzSvuOIKSdyFlI0VGkrSpk2bJEm/\n", - "+MUvwtjhw4dzn1O3swUXaW2XuWHDBkm1RR55++Y3v1nI4yaxyIy/e+629ilJ8ojgzp8//7zjEydO\n", - "NPVvfXsXFG/dunXh+J3vfKckacuWLWFs165dkur/bj/5yU8ymcvll18ejm2RiC8mf/755yVJu3fv\n", - "DmNpRceISAEAAETiQgoAACBSqVN7xhfPWZH5s88+W9R0kMAXqVpB6IoVK8IYqb30pZHSs10BpFoY\n", - "nAL9WunAj370ozDm+9l1K9/12fruNdunr1k+3dKJXeUtHenff534e6TBFoRJtZIAX+i9atUqSfXl\n", - "OVnx57Jt27ZJqt+c3NKMSRuWt4uIFAAAQKSOiEj99re/TTxGeezZsyfxGOXmI4llXfqeBb8zQrOR\n", - "vTx3RoiZXxp8NNLPIU3+eWz1OS3qefEsytLX1xfG8ug6X0ZPPvlkOLZdCPbu3RvGLDvhO5tbRC/t\n", - "SKdviWR8MbnNK4vzHBEpAACASFxIAQAAROqI1B4ApKmotFCzfEFsnsX/s3WELpIVwfui7qIKvCcn\n", - "JyXV+hL1Mv96sf5QTzzxRBizPlM+hdvf3y9JOnToUKpzGR8fTzzOAxEpAACASESkAKBkaEFRz4qW\n", - "X3755YJnUouE9WrLgwux16zfi9KidmvXrg1jvrN9tyAiBQAAEIkLKQAAgEik9gAA0ZYuXSqpfgeK\n", - "tC1evFhS/W4J1kn7+PHjmT0u2mO9onyxeVGbomeJiBQAAEAkIlIA0ISVK1dK6s476nZYtCjLiJTt\n", - "c+i7iSe1RChr+4ZeMm/evHC8evVqSbWWEZJ04sSJ3OeUNSJSAAAAkbiQAgAAiERqr0QuuugiSfSQ\n", - "QbEWLVoUjnthI2NLRTTqC2QpLFJ7tbSalE8/peHhYUnSxMREGLN+RJ14vrS+WN3I9/qyVGs3pvM8\n", - "IlIAAACRCrssnjt3bt2SyCR2B/jqq6+GsW4uJuzEO6te02z0Ig+2H5t/f7TD7vCtsDctFmmVas9f\n", - "Wu/jSqXS9s/w+9rN5vDhw20/VrfwEamxsbHcHtfvb9eJe93Z8+YLstthr/8y7R3pz0dTU1Nt/zz/\n", - "Hm/n90z7fFn3s1P/iQAAAD2CCykAAIBIlXMFxAQrlYqq1WreDwsAANCyarV6wdQiESkAAIBIhRWb\n", - "FxmR8o9ddGSMuSSLmYst2097yX6Wz4vtU3bq1KkwNluQuNP/Rlmxxy96Hn4OzKUec0nW6lz84gjr\n", - "HO4Xb7TTYb6Tn5csNZoDESkAAIBIXEgBAABEKiy1N3/+fL344otFPTy60NatWyVJ4+PjYWxkZOS8\n", - "77N0WpabrDar6Dn4Hk959DGztIT1iJOKfw5Mr3V0b1ZafXyQDt8Hyd6zy5YtC2NFvZ+sD10vfq4T\n", - "kQIAAIhUWESq2W7CQLP279/f1PeVJQJSBnl307e7abt7lcrz90ijS3q73vSmN0mS3v72t4exp556\n", - "SpL085//vJA5+S7cvRhteD2L/vjIkF8skqc0Ooe3w+8ZuG7dOkn1ne5feOGF3OdUhFmvZg4dOqTr\n", - "r79eb3rTm3TllVfq3/7t3yRJ09PTuuGGG7Rlyxa9973v1bFjx8K/ufPOO3X55Zdr69ateuCBB7Kd\n", - "PQAAQIFmvZCaO3euvva1r2nXrl167LHH9I1vfENPP/20duzYoRtuuEF79+7Vu9/9bu3YsUOStHv3\n", - "bt1zzz3avXu3fvzjH+tv/uZvMtnXBgAAoAxmTe2tXbtWa9eulfTaZotvfOMbNTIyoh/+8Id6+OGH\n", - "JUm33nqr/uAP/kA7duzQ/fffr1tuuUVz587V0NCQNm/erJ07d9aFqU03bD6c5SaIaN2JEycu+DUK\n", - "ZstlcnIylZ+T5gbLZdgE1+awcOHCMOaPi0A6r95s55les2bNmnBsKb1eSed5TRcqDQ8P6ze/+Y3e\n", - "9ra3aXx8XAMDA5KkgYGBsErqyJEjGhwcDP9mcHAwcdUUAABAN2iq2PzUqVP6wAc+oP/3//5fWDpu\n", - "KpXKrEWa7RRw2t3m2bNno39GlohEdQ6iUN2p296DVrTsF06UpRgfeL2ZmZlw3IuRKNMwInX27Fl9\n", - "4AMf0Ic//GHddNNNkl6LQlkYb3R0VP39/ZKkDRs26NChQ+HfHj58WBs2bMhi3gAAAJl76KGHZv36\n", - "rBdS586d08c//nFt27ZNn/rUp8L4jTfeqLvvvluSdPfdd4cLrBtvvFHf//739dJLL+m5557Tvn37\n", - "dN1117X7OwAAABTi+uuvn/Xrs6b2Hn30UX33u9/V1VdfrWuuuUbSa+0N7rjjDt1888369re/raGh\n", - "Id17772SpG3btunmm2/Wtm3bNGfOHN11111tpfbKmtJDjfUO8YW6loooazrNunnn0UPJF2NadNbX\n", - "DU5MTGQ+h26Wdx+srNkClsOHD4ex48ePS6ovrOfciFZk1XW8l9N53qwXUu94xzsuWIPw4IMPJo5v\n", - "375d27dvb39mAAAAJVdYZ3N0h+npaUmdtUQ6jwJlix5s2bIljG3cuFGStHz58jD2yCOPSOq+yAri\n", - "HD16tO6/Xhk6r6MzddL5uROxTwsAAEAkLqQAAAAikdpDWzoxZJxHEbxt5ukfy54rv2H36tWrJdUX\n", - "nXdbbySko6yLN9C7FixYEI77+vok1W9kbK/Z0dHRMPbyyy/nNLv8EJECAACI1LURqTy7oi9evDgc\n", - "29W2jzp0w76CaE1SYXDSUmHbKcCWJ0sKTW2JQAAoM/85t379ekn1EXVr3eE/I22smxCRAgAAiMSF\n", - "FAAAQKSuTe1lldLzKZiVK1dKUt1+gtbV26fz/P6DaVq1alU4ts1OrWu3JK1YsUKSdOTIkUweHxd2\n", - "+vRpSfVhbgtv+7+bpfasH5ckHTx4MI8pAkBb7Dzn+RIGKzy3zyKJ1B4AAACcro1IZcUXzS1ZskRS\n", - "/XJP23PuxIkTmc9lcHAwHFtxs9/b7aWXXpJERKpIfqmvtTq4+OKLw5jtu5d0ZwcAnWLevHmSalF2\n", - "P+b3juxGRKQAAAAicSEFAAAQqbDU3pIlS0KBtOeLpcu4kavvm2GpPd/de2pqSlJyz6C02eNL0sKF\n", - "CyXVb4j7xBNPZD6HVvn+Sr3QJ2l8fPy8Y58ets1puz30XQR7f/i0qaXhLe2N7mfdt/M4J/eagYGB\n", - "cGyLrvyYdTv36b6nn35aUnft4EBECgAAIFJhEakL3R2UMQrlTU5OnndcVJTl0UcfDceLFi2SVOvo\n", - "LqWzzDTt360XolCeb31hCxF+/vOfhzFrl2H/RXv86z8p4k0kqnX+ObVjf/5uJ7Jg5xd/XrBIov+5\n", - "1s4mpq2NXwyEdB07diwc/+IXv5Ak9ff3hzGLUnX7XqJEpAAAACJxIQUAABCpcq6AXEulUlG1Ws37\n", - "YQEAAFpWrVYvWJpCRAoAACBSYVV4RUak/GMXHRnLci5WZOm7axc1l1a1M5e0W2h0y/OStjLOpdl5\n", - "XHnlleHY3h979uw57/v83pr2Wmr0fmp1LllKmou1cMmy6NeKyK2ztST9/d///XlzmU2z72NrbyDV\n", - "fqdGiwrK/jcqis1hx44dYayothFlfF4uhIgUAABAJC6kAAAAItFgo0krVqyQVN83o4x8Z3MrjMtj\n", - "A+UsJfWaSdJqvxjfHyemPw06l0852Ubf/n1i7/OtW7eGMUtx7N69O48pZiaPPj72XvW7PrTKb8A+\n", - "NjZ2we/bsmVLOLa/4fDwcPTjlp3tYiFJZ86cyeQxmk3n+T6D9p5q52/eqYhIAQAARCIi1aRO6Yjs\n", - "u5lbV9lOj0g126Gj2aJ6i1z5uynkw/bemp6eLnQev/71r2f9ut1dWzd6KZ/9EK243e/HaNGxbuwI\n", - "PZtGOzNYZMbvOZrGbg5ll1UUKobfe9ayNn5+nf7Z0ywiUgAAAJG4kAIAAIhEaq9Jp0+fLnoKLTt6\n", - "9Gjmj2HpMV/waamI8fHxzB8/RrMpwDSsXLkyHM/MzOT2uJ6l03wBqR3nnS76wz/8Q0nSc889F8Z+\n", - "9atfSaptvC1JV199tSTpN7/5TRjLs4jVUvnPPPNMbo8p1X7Hdn5Xv4giiaUNfdqyTOyc0qgHnKWQ\n", - "/EbynZLa8z2yOpn/G9n5ftWqVWEsj55lZUBECgAAIBIRqS6Wx5L+q666SpL0yU9+MozZHeL27dvD\n", - "WBodxjtRUVEoXwS6dOlSSfULJuwOcdmyZWHM7pKznLO9DtavXx/GLCLlX6+ttrIouzzvzBstzrCI\n", - "QZYRKSsAP3XqVMv/1ubf7GKQvXv3tvwYRevm8+HU1FTRU9Db3vY2SfVd7y1ilrSDQbuISAEAAETi\n", - "QgoAACBSd8XPkTvrB+QL260Hj/WxkqSDBw/mNidfyDk0NCSpvgA3i9Bu2fi0yMTEhKTkBRO+z0se\n", - "BbCHDh2SlJx+8qk9S/fluTAgS3kW2zZ6zprty9aOmJTe61lKWqq9j32PojzPKegslrb2JQJZLr4i\n", - "IgUAABCJiBTaYt2eq9VqGLNCyqKiCb6Q0yIufm+1XtNs6448CmBtIUKjhRAWefBdq9OIcqC8bQ9e\n", - "z/+9LbJQpq7eKK+nnnoq18cjIgUAABCJCykAAIBIpPaQijy7TrfCCq17jS82t41wy/A3stReo03A\n", - "bc6+M7ylpPIolu5mnZLa8534x8bGCpwJMDsiUgAAAJGISAFdzpaRlyEi1WzB+MKFCyVJy5cvD2O2\n", - "h+PJkyfTn1gPKcProFv55fbd0roDjRGRAgAAiMSFFAAAQCRSe0AX8mkFX7RbFitWrAjHlrLz3efX\n", - "rl0rqbbBriSNjo7mNDsgjn8N20bVjRZWoPMRkQIAAIhERArocmXsCJ50l75gwYJwbHfzftn71NRU\n", - "9hMD2kDn9d5ERAoAACASF1IAAACRSO0ByF3SRso+3WfpyOnp6ZZ+ri/2bbQxchF8n6FFixZJqm2s\n", - "HcNSoFJtY+4yLi4AuhkRKQAAgEiljkjZ3dZFF10Uxsp4lwn0Oou0tNPN2Xfctj35kiJXs/n/7d09\n", - "TBp/GAfwLwNTdahRkYgJCYKveJAQnYwaX0Za46KDMald3JoY48qi1cHBNp0aTdx08mUQ4+JbujAU\n", - "F11MxAQRHUwHqwPWPP/BcCn2aPM/4S7g9zPB3YV7wpcfPPkBv8vV+0N6Zus5j/f7+1ZFRQWAzOcn\n", - "/f6mZ0aqvLwcAPDw8KBuS89E/X6dRS3pVePz+cPo9PIW6aUtnis925brpQQqKyvV2+nZTyNWJC8r\n", - "K8vJ47x69QqA9vPCz0rjcEaKiIiISCc2UkREREQ6WUREDD+pxYKOjg50dXUZfWoy0c7ODjN/QZj3\n", - "y8PMX5aXlHcoFEK2dokzUkREREQ6mTIj1dnZib29PaNPS0RERPS/dXR0YHd3V3OfKY0UERERUTHg\n", - "V3tEREREOrGRIiIiItLJlEZqa2sL9fX1cLvdmJ2dNaMEyjOn04mWlhb4/X60trYCeFzwrre3Fx6P\n", - "B319fTlbrI/M8e7dO9hsNni9XnXb3zL++PEj3G436uvrsb29bUbJ9AxaeYdCITgcDvj9fvj9foTD\n", - "YXUf8y5s8XgcXV1daGpqQnNzMz59+gSAY1yTGOzXr1/icrkkFotJKpUSRVHk+PjY6DIoz5xOp1xf\n", - "X2dsm5iYkNnZWRERmZmZkcnJSTNKoxzZ39+X79+/S3Nzs7otW8ZHR0eiKIqkUimJxWLicrnk4eHB\n", - "lLpJH628Q6GQzM3N/XEs8y58yWRSotGoiIjc3NyIx+OR4+NjjnENhs9IRSIR1NbWwul0wmq1YnBw\n", - "EOvr60aXQQaQJ/9j2NjYwMjICABgZGQEa2trZpRFOdLe3o7Xr19nbMuW8fr6OoaGhmC1WuF0OlFb\n", - "W4tIJGJ4zaSfVt7An+McYN7FoKqqCj6fDwBQUlKChoYGJBIJjnENhjdSiUQCNTU16n2Hw4FEImF0\n", - "GZRnFosFPT09CAQC+Pr1KwDg6uoKNpsNAGCz2XB1dWVmiZQH2TK+uLiAw+FQj+O4Lx6fP3+GoigY\n", - "HR1Vv+Zh3sXl7OwM0WgUbW1tHOMaDG+k/nVBTSoO3759QzQaRTgcxpcvX3BwcJCx32Kx8LVQ5P6V\n", - "MfMvfGNjY4jFYjg8PITdbsf4+HjWY5l3Yfr58ycGBgYwPz+P0tLSjH0c448Mb6Sqq6sRj8fV+/F4\n", - "PKOLpeJgt9sBPF71vr+/H5FIBDabDZeXlwCAZDKZceV1Kg7ZMn467s/Pz1FdXW1KjZQ7lZWV6ofp\n", - "+/fv1a9ymHdxuL+/x8DAAIaHh/H27VsAHONaDG+kAoEATk5OcHZ2hlQqhZWVFQSDQaPLoDy6u7vD\n", - "zc0NAOD29hbb29vwer0IBoNYWloCACwtLakDk4pHtoyDwSCWl5eRSqUQi8VwcnKi/puTClcymVRv\n", - "r66uqv/oY96FT0QwOjqKxsZGfPjwQd3OMa7BjF+4b25uisfjEZfLJdPT02aUQHl0enoqiqKIoijS\n", - "1NSkZnx9fS3d3d3idrult7dXfvz4YXKl9ByDg4Nit9vFarWKw+GQxcXFv2Y8NTUlLpdL6urqZGtr\n", - "y8TKSY+neS8sLMjw8LB4vV5paWmRN2/eyOXlpXo88y5sBwcHYrFYRFEU8fl84vP5JBwOc4xr4CVi\n", - "iIiIiHTiyuZEREREOrGRIiIiItKJjRQRERGRTmykiIiIiHRiI0VERESkExspIiIiIp3YSBERERHp\n", - "xEaKiIiISKf/AMt+wa3UEUvkAAAAAElFTkSuQmCC\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "feat = net.blobs['conv5'].data[0]\n", - "vis_square(feat, padval=0.5)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The fifth layer after pooling, `pool5`" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAlEAAAJMCAYAAADaNPObAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XuMHeV5+PHneO/3+8X22izxbVkbsI0hlLTBYK0JCBwS\n", - "KLkpsQClUmmrgNICUlUJWiU2StuEJM0/FaVWknKp2oKLEos4yTqhDhBDiAO2sU28eL3eXdt7v1/P\n", - "7482/sV+nzXvvvOemTlnvx8pUvZhzsyzM3POeTz7zDOJZDKZFAAAAMzLoqgTAAAASEcUUQAAAA4o\n", - "ogAAABxQRAEAADigiAIAAHBAEQUAAODAexG1Z88eaWpqklWrVskTTzzhe/UAAACxkPA5J2pmZkbW\n", - "rFkje/fulaVLl8q1114rzzzzjFxxxRW+NgEAABAL2T5X9vrrr8vKlSulsbFRREQ+/elPy4svvnhB\n", - "EZVIJHxuEgAAIGVuvPFGaW1tVf+b1yKqo6NDli1bdv7nhoYGee211z7wdQUFBUZsbGzMZ2qiXXCL\n", - "qqALkktlZaXVcsPDw0ZscnLykrk89thj8thjj6XlfvEtSC7XXXed1XKvv/56ynPxLS65RJVHTk6O\n", - "EdPeV0Fy0V5r+wcD3/tl0SKz42N2djbluXzkIx+55H8/efKkLF++XA4fPmz8t97eXq+5+GabS1ZW\n", - "lhHLz8+3imn7IC8vz4hp37NaLtp5/zszMzPnc52amppzuQ8S52N0qTy8FlFcZQIAAOmstbV1zitP\n", - "F/NaRC1dulTa29vP/9ze3i4NDQ0+NwEAAJAymzdvls2bN5//+fHHH59zWa9F1KZNm+TYsWPS1tYm\n", - "S5Yskeeee06eeeaZD3yd7z/dZWd7/bUio11K1363wsJCI6ZdCj579uwlt/f7Jw0QhHb+rV271uq1\n", - "Bw8e9J2ON0H+XGErqmfCa//g1T6DtM8R35/hGzZsuOR/r6mpkYaGBuno6DD+m/anrHQ0MzNjxEZG\n", - "RqximvHxcedcPui8t/0TbybyWm1kZ2fLt7/9bbnllltkZmZG7r//fu7MSyMUUQDSAX/hQFx4v2Rz\n", - "6623yq233up7tQAAALHCxHIAAAAHFFEAAAAOMqMD+yKZ0liuzf/Izc01Yn19fUZsYGAgJTn9Ptu+\n", - "hFOnTqU4k0vPMfl9YTQGv/HGG0Zs1apVRqypqcmIHTlyJCU5hU2bSbNkyRKr18a5sRx6s7lvtreX\n", - "d3Z2pjYR0ecYat8xQ0NDKc8lKiUlJUbs+uuvt3rt3r17jVhUN0+kAleiAAAAHFBEAQAAOKCIAgAA\n", - "cEARBQAA4CAzOrAvspCnp4YpTs2BxcXFVstpTfi+XX311Ubs8ssvN2LaZOVMaSyfnp42Yv39/RFk\n", - "Ylq6dKnVcoODg0Ysk5uHw7gBxNbbb7+d8m3YPlxZeyasduPE6OioEdOmjqcjnos7N65EAQAAOKCI\n", - "AgAAcEARBQAA4IAiCgAAwEFGNpZrU73TkdaoODk5acS0Jt4wdHR0RLJdTRgN47a06b5aY+bExEQY\n", - "6URCO09fffVVI6btFy0Wp5sY4iIrKyvqFBYE7XN4fHzciGXyDU3ad8w777xjxLT3fVVVlRE7d+6c\n", - "n8RigCtRAAAADiiiAAAAHFBEAQAAOKCIAgAAcJCRjeXDw8NRpzBvzc3NRqywsNDqtdok6LGxMSO2\n", - "ePHi+SeGedOmFGvTr8+cORNGOpHQJjpv2rTJ6rUDAwNG7OTJk4Fz+p043RARRE5OTtQppDXb6eRl\n", - "ZWVGTLvRQTtvM4XWWF5TU2PEtH2lNebTWA4AALDAUUQBAAA4oIgCAABwQBEFAADgIJEMeRRwIpFg\n", - "+jAAAEgLl6pbuBIFAADggCIKAADAAUUUAACAA4ooAAAAB5FMLNemwqaa1hQWRR4i8c8lPz/fiGmT\n", - "aFetWmW1jd/+9rdGrK+vz4hpU9bjtF/Ky8uNWJApxVlZWVaxiYkJI2a7X1auXGm13PHjx62W0/ZL\n", - "drb5MaJNbddov6/m4vXF/T1km0tpaakR06bbh5GLb1ou2pR1bRp2GLnEab+Qi56L9r0zNTVlxLTv\n", - "Do323ab9vtqU9blwJQoAAMABRRQAAIADiigAAAAHFFEAAAAOImkst1FYWGjEtCbU8fFxI6Y1nsGe\n", - "1shcUFBgxEpKSsJIJzZGRka8rk9rvrZtyPZNa7jU3lsa25xtzxetwXR4eNjqtelGe69lsjCayJE5\n", - "tJtWtJsTbBvLtfXZ3twyF65EAQAAOKCIAgAAcEARBQAA4IAiCgAAwEEsGstzc3ONWG1trRHTmsds\n", - "m1+DaGpqslqut7fXiJ05c8Z3OpHo6OgwYv39/Vav1Zr5tFgQWuO7xrYBUZOOTbHaJHKtiRzRsL2J\n", - "QxPkXNb4nm4P/7Smak2m3FylPdkiSCN4Km7m4UoUAACAA4ooAAAABxRRAAAADiiiAAAAHMSisTyI\n", - "ODXQZfL0Ya2pemBgwOq1VVVVRiyMGwKiok3b14yOjqY4E5HLLrvMiGmNy9o09vb2dq+5DA0NWS2n\n", - "3WjiU3FxsRHL1InoyCy2TdVx+l4MorS01IhpjeC271/thibbGznmwpUoAAAABxRRAAAADiiiAAAA\n", - "HFBEAQAAOIhFY/nk5KTVckEbwFydPn3aiCUSCSNGc6qup6cn5dvwPb05CK2RXqM118/OznrNJS8v\n", - "z+v6fNPeR6lm+3kTBm16vHbMwrgRo62tLeXbSEe2NzqEcV4Fna6dboqKioyY7Q0qYeFKFAAAgAOK\n", - "KAAAAAcUUQAAAA4oogAAABxE0lh+8cRgrXlMaxROJpNGTGviDTIJetEis67UpnXn5OQYMW0aqtY4\n", - "Gnfa76HtgyC0SdpxV1ZWZsS0qe1BmqW1adoa7bzSjpHte6Gzs9OI1dTUWL1We89o7+nFixdbra+7\n", - "u9uI+WyQj1NjudYwHtU0f9/v8UwRp/MljEnk2nstqqdx9Pf3G7Eg3+9aU3rQ9xtXogAAABxQRAEA\n", - "ADigiAIAAHBAEQUAAOAgkdS6tVO5wURCbRAHAACIm0vVLVyJAgAAcEARBQAA4IAiCgAAwAFFFAAA\n", - "gINIJpavX7/+gp+Hh4eNZUpKSqzW1d7ebsS0ybva5NMgk6WD0BrU4pRLZWWlEdOOx+zsrBHTJtsW\n", - "FBRYLdfV1WXE4rRf6uvrjZg2sdx2Aq42Gb6urs6InTp1yojZ7pfa2lojdvbsWSNme7NHXM7duOQh\n", - "Qi5zCZLLNddcY7XcG2+8kfJcfCMXXZBcsrKyrJabmZkxYtr303ymonMlCgAAwAFFFAAAgAOKKAAA\n", - "AAcUUQAAAA4iaSx/7733LvhZayyHvZycHCM2NTXlvL6+vj4jZttsrjUtnzx50jmXOOnu7va6Pu0G\n", - "iNOnTzuvr7y83Iht3LjR6rV79uxx3i7gm/aZpikrKzNi2s0eyGwNDQ1Wy73//vtGTDuH5oMrUQAA\n", - "AA4oogAAABxQRAEAADigiAIAAHAQSWO5Nq0adrSJ1hrfTdBas7nGdnIs/NOm8h88eNCI2U4nR+pV\n", - "VFRYLWf7/ssU2pMoNEFuoElH119/vdVyr776aoozCUdpaakRKyoqMmJjY2PO29DWNx9ciQIAAHBA\n", - "EQUAAOCAIgoAAMABRRQAAICDSBrL4U6bxhtVo3B2tnn6aI2eiUTCiPnOuba21ogNDQ0ZsSANiNrv\n", - "q00dD8L3frGd/BzG7wbYOnPmjBHTztHx8fEw0kGMaDcvdXZ2Oq8v6DnElSgAAAAHFFEAAAAOKKIA\n", - "AAAcUEQBAAA4iKSxfKFNmfUpqkZKrUm7uLg4gkx0hYWFVrG2trYQsomPsrIyq+U6OjpSnAk0C20S\n", - "uS3thgjtXD579qwRy+QbIjJlErmtwcFBI6ZNMQ+ip6cn0Ou5EgUAAOCAIgoAAMABRRQAAIADiigA\n", - "AAAHTCxPMW26qm+5ublGbGZmxipmKy8vz/m1YUwsD4PW7FpQUGD1Wu33LSoqcl6f1jQ/OjpqxLTG\n", - "TE0mN+NebNEi89+Os7OzEWQSL9r5ODIy4nUb2ueh9rlk+z7QBPmsQrxox7K3t9d5fVVVVUZsYmLC\n", - "eX0iXIkCAABwQhEFAADggCIKAADAgVMR1d7eLjfddJOsXbtW1q1bJ9/85jdF5H//VtnS0iKrV6+W\n", - "rVu3Sn9/v9dkAQAA4iKRdOjw7erqkq6uLlm/fr0MDw/LNddcIy+88II8/fTTUl1dLQ8//LA88cQT\n", - "0tfXJzt37rxwg4lEWjYVAwCAhedSdYvTlaj6+npZv369iPzvoz+uuOIK6ejokN27d8v27dtFRGT7\n", - "9u3ywgsvOKYMAAAQb05Xon5fW1ub3HjjjfL222/L8uXLzz8LKplMSmVlpfFsKK5EAQCAdHGpuiXQ\n", - "nKjh4WG566675Mknn5SSkhJjo9p8IBGRxx577Pz/37x5s2zevDlIGgAAAF60trZKa2ur1bLOV6Km\n", - "pqbk9ttvl1tvvVUefPBBERFpamqS1tZWqa+vl87OTrnpppvkyJEjF26QK1EAACBNeL8SlUwm5f77\n", - "75fm5ubzBZSIyLZt22TXrl3yyCOPyK5du+TOO++cM6GwaTvANg9tyql256E2eVebjqwtZ5uLNsE1\n", - "yMTVIPvFNy2Xuro6I3bmzBmv29UmNQ8PDxux/Px8IxZ02q2NuB8jLZfy8nIjdtVVVxmxEydOGLFT\n", - "p0594HbTcZ+EwXYyvjbx3vYftz09PUasuLjYiA0NDRmxOO0XctFzqampMWLnzp1z3ob2pIepqSmr\n", - "XLT9osXWrl1rlcv7779vxLTzdD4XepyKqP/5n/+R733ve3LVVVfJhg0bRERkx44d8uijj8o999wj\n", - "Tz31lDQ2Nsrzzz/vsnoAAIDYcyqi/vAP/3DOZ03t3bs3UEIAAADpgInlAAAADiiiAAAAHAQaceCL\n", - "1si2ePFiIzY5OWnELr77L27m+rOnqzAameOkt7c35dsYGRmxWi4d9712I4LG9++WlZVltZzW9Ay/\n", - "RkdHrWJBaDdipKPc3Fwjpt0QoXn77beN2Pj4uPN2te+O6elpq/UFoTVaB6F9BmmN5ba0pm/b88/2\n", - "eMwHV6IAAAAcUEQBAAA4oIgCAABwQBEFAADgIBaN5XE3NjYWdQoLVhiNlJls2bJlVssdP37c63a1\n", - "qdZa4+3AwIAR47FQ6cf2BoZMVlFRYcQ6OzutXuv7BqS40ybcB9HW1uZ1ffPBlSgAAAAHFFEAAAAO\n", - "KKIAAAAcUEQBAAA4iEVj+dmzZ61icaI1UvqeAgwEFaeG1SuuuMKIZWebH0Ht7e1G7Le//W1KcoIf\n", - "OTk5UafghfZUjHPnzhkxbcJ4kH0QpxtotH0QRGFhodf1xQ1XogAAABxQRAEAADigiAIAAHBAEQUA\n", - "AOAgFo3lGttJy1oTqm9lZWVWy9FYLpKfn2+13Pj4eIozgYhIf3+/1XLajRITExNec/E9pRjxMTw8\n", - "HHUKKaPd5KS9X3w3ZPtm+/7jiQHzw5UoAAAABxRRAAAADiiiAAAAHFBEAQAAOIhtY3lVVZXVckEa\n", - "y7OysozYzMyMEcuUJugwpgrTWB5/WlOsNjn8zJkzYaRjCONmEcCW9j2hNV8Haa4vKioyYiMjI87r\n", - "0yxaFM01k6g+R8LClSgAAAAHFFEAAAAOKKIAAAAcUEQBAAA4SCRDHk+aSCSYiAoAANLCpeoWrkQB\n", - "AAA4oIgCAABwQBEFAADggCIKAADAQSQTyxOJROjb1JrCSkpKjFhubq4Rm56eNmITExPO29VeG8U+\n", - "EdHzi1MupaWlRmxoaCiSXOK0X4qLi42Y7wnHtrn4PkbaZP2pqakPzCNOx8c2F+3JDLZPTdBiQXK5\n", - "5ZZbrJb70Y9+ZMRmZ2e95uIbuegyJZelS5caMW0KfG9vrxE7d+6cVS5z4UoUAACAA4ooAAAABxRR\n", - "AAAADiiiAAAAHETSWB4Xk5OTRmx4eNjrNqJq0gvDvffea7Xcv/3bvxkx28b8MJrICwoKUr4N3+J0\n", - "Xvk+Rhc3kSMcixbZ/Zs6TudeVlaWEcvPz3den/a7fexjH7N67a9+9Ssj1tXV5ZwLdNp5Wl1dbfVa\n", - "7aaVoLgSBQAA4IAiCgAAwAFFFAAAgAOKKAAAAAexbSzXJvlq08Q7Ozudt6E1qGVnm7tEm1huS2t8\n", - "XGjC2Ad5eXlWy9k2tMed7xsgFpLy8nIjpp0//f39Rsz3+dPT0+N1fUG88sorVstpE9WDKCsrM2ID\n", - "AwNWr9WmUmtPorClTaoO40kAtrQnFfBZYN8wbntezQdXogAAABxQRAEAADigiAIAAHBAEQUAAOAg\n", - "kdQ66VK5Qctpt1oDndZE2N3dbbU+7desqakxYloT+ejoqBHTpp1rtGZ4rTnVdr9ozfCzs7NWr9Vo\n", - "+yWqicRBcvHdWJ4p+8W3uOQSJA/fjeVx2Sci6ZmLtu+DNPBr3xNa83Xc94vGd2N5Op4vGtunToyN\n", - "jTnlkkgk1PxEuBIFAADghCIKAADAAUUUAACAA4ooAAAAB7FtLPdN+zW1qehak3aQxnLbXOK0X8iF\n", - "XOYSl1x856E1I9tOqo7LPhEhl7mQi45cdDSWAwAApBhFFAAAgAOKKAAAAAcUUQAAAA6yo04gSr29\n", - "vVGnACBkK1assFquq6vLiNk2m9vKysoyYtnZ5sey1tRqe3NLZWWlEdOefKBNaNee4KBNGK+oqLDK\n", - "RWsUDnJvU35+vhG77LLLnNcXhHbcqqurrV7b0NBgxGybqtvb251fmym095FmZmbG+7a5EgUAAOCA\n", - "IgoAAMABRRQAAIADiigAAAAHkUwsD3mTAAAATphYDgAA4BlFFAAAgAOKKAAAAAcUUQAAAA4imVge\n", - "xTRVrSksqqmutrnk5OQ4r8+2eV+bSKzlEsZE2HQ8RmHQcrGddG071VqjbcP2fEm1IMdn9erVVssd\n", - "PXo05bn4puWyePFiI6ZNYw8jlzjtlz/4gz8wYuPj40bs3XffNWLae62wsNCI1dTUGLHf/OY3RixO\n", - "+0X7PcbGxrxuV9uG9jSAOO2XuXAlCgAAwAFFFAAAgAOKKAAAAAcUUQAAAA4iaSyHnampKa/r05r5\n", - "bAVpGA+D1oBYVFRk9drh4WHf6aTc7OysEdOayBsbG63W19bWZsTifsxhJ4wmct+uu+46q+UOHDhg\n", - "xLT3huaNN94wYrafudpnqdaU/s4771itL07y8vKMmO13R09Pj+90Yo8rUQAAAA4oogAAABxQRAEA\n", - "ADigiAIAAHBAYzkylm0zZDo2ltsKcjNBprKdRB4G7akEvm8osXXZZZdZLff++++nOJPo5ObmGjGt\n", - "0Xp0dNSIRTVdOwzaTSvafqmurjZig4ODRmw+E8HjjitRAAAADiiiAAAAHFBEAQAAOKCIAgAAcEBj\n", - "+QKSlZUVdQopozUqag2NYdAaLrVmYdvJykEMDQ2lfBu28vPzjZg25Xmhi1OzeVRef/31lG9D26da\n", - "Y7lG+7wJ8tSEONE+M7SnF9TW1lqt79y5c4FzijOuRAEAADigiAIAAHBAEQUAAOCAIgoAAMABjeXI\n", - "WFE1LcepCbi9vT3qFGKntLTUiFVUVBixnp4eI+Z7un2czpXu7m4jlslTuDXaZG4tlskWLTKvrWiN\n", - "5cuXL7da33vvvRc4pzjjShQAAIADiigAAAAHgYqomZkZ2bBhg9xxxx0iItLb2ystLS2yevVq2bp1\n", - "q/T393tJEgAAIG4CFVFPPvmkNDc3n/+7+c6dO6WlpUWOHj0qW7ZskZ07d3pJEgAAIG6cG8tPnTol\n", - "P/jBD+Sv//qv5R//8R9FRGT37t2yb98+ERHZvn27bN68mUIqRuI0vTpTaBOObSeWa43vxcXFfhIL\n", - "UXV1tRHTphRPTEwYMdsJ0T6be5ctW2bEysrKjJh2fHw3lmuys+0+lqenp71uN8gEb1vaNHZt+rfW\n", - "yKwtp7Hdf0FoDfcjIyNGzDbnOCkoKDBiWrN5GE9cSAfOV6Ieeugh+drXvnbBzu3u7pa6ujoREamr\n", - "q1Pv9gAAAMgETkXUSy+9JLW1tbJhw4Y5K+1EIrHgbo8FAAALh9N1z/3798vu3bvlBz/4gYyPj8vg\n", - "4KB8/vOfl7q6Ounq6pL6+nrp7Oy0fkAhAABAHLS2tkpra6vVsolkwD/a7tu3T/7+7/9e/vu//1se\n", - "fvhhqaqqkkceeUR27twp/f39Rk9UVFenbJ+6HQZy0aVjLmH0RGm9bHHaLzU1NUZM64nSctZ6ZDQX\n", - "90QFOVfWrl1rxLSeKG1IoNai4Pu8DdITFSSXrKwsI6ad32NjY1br03LR1hdGT5T2/gtyjGxfq+Uc\n", - "98857b2g9TNef/31Vtv4XZ+0Sy5x2S+JRGLO889LB97vftFHH31U7rnnHnnqqaeksbFRnn/+easE\n", - "oxKXPETIZS7kootTLmfPno06BRGJ1z4hF12cpn/Hab/EKZeBgYGoUzgvTvtlLoGvRM17g5eo6AAA\n", - "AOLkUnULE8sBAAAcUEQBAAA4oIgCAABwkPrRroqL717y3WxYVFRkxLRJw2F0/ufn5xsx7e4W33fz\n", - "2E4z1v7Ou2nTJiOmjavQ7hrTpkG/8sorRmzlypVG7Cc/+YkRKy8vN2K2U6O1O3w0lZWVRqynp8eI\n", - "2R4j7fzTphnbivNdKyLR5KLl0djYaMS0/a7dOWirqqrKan22+0Sb9q6xzTnI8SktLbVabnBwMOW5\n", - "aO/7IM9iDZKLdgepdrdfGLn4lil3lvo2n75trkQBAAA4oIgCAABwQBEFAADggCIKAADAQSSN5ame\n", - "WhukiVdrItQajzXaIyG0R3v4ZttEbuvw4cNG7P333zdits2uWpPoyZMnrV4bxvTc3t5er+sLcv7B\n", - "nfbe1R5hEaSxXHssz0KjPR7G9iYOTVNTkxG79dZbrV77H//xH0bM9rPFVpAm8oVG+6zXBHkPxg1X\n", - "ogAAABxQRAEAADigiAIAAHBAEQUAAOAgksbyOMvNzTViJSUlVq89c+aMEZvP5NO40KbETkxMOK8v\n", - "yKThILRp8Zowmv8RDW2qfhC+bxqIU4OtNrFcm0BdUVFhxLQbT8KwatUqI+a7sVyjPcFBo30nZLKF\n", - "+FnKlSgAAAAHFFEAAAAOKKIAAAAcUEQBAAA4oLH8IlpjnG1zajo2kWu0xnJtGrTWuK1NT9cmHDc0\n", - "NDhmh3SVl5dnxAoKCoyY9j4KY3K9jbGxMa/r095XmjCmZmvTprVj1tfX53W7R44cMWLaDT6LFy/2\n", - "ul1bWnM9dMPDw1GnEDquRAEAADigiAIAAHBAEQUAAOCAIgoAAMABHXMXmZmZMWLpOIVVmz5sO2VX\n", - "o+0XreFydnbWiGmN5YWFhc652Ir7cdMa+LV9tdC4TsefnJw0YraN25pFi8x/Y2qN8JlCu4FGa/DW\n", - "Pgt8025a0Y5vb29vynPRaNvlvbswcSUKAADAAUUUAACAA4ooAAAABxRRAAAADmgstxBkWrJts2FR\n", - "UZERGxkZcd6ub0GatLWG0La2tgDZRKOpqcmIac312tTenp4eI3bNNdcYMa2RN1NoDeOuTeRh0G6S\n", - "0GIa7SYO7T00ODhotb4PfehDRsz3uaKdt1pjvvZ+9k373bRm8zCa3LWnMARZDuHQbtzRBH3SCFei\n", - "AAAAHFBEAQAAOKCIAgAAcEARBQAA4CCRDNpVNd8NJhKBG7kAAADCcKm6hStRAAAADiiiAAAAHFBE\n", - "AQAAOKCIAgAAcBDJxHKbSaIrV660Wpc2Cbqvr8+IaU1hthNNfcuUXLZs2WK13K9//Wsjdu7cOa+5\n", - "+GabS0lJiRHTJhePjY1ZbVebgD41NWXEtAn3hYWFRkybiF1cXGzEent7jVhVVZUR046b7THSplBr\n", - "E7FtJvVrx2ft2rVGTMu3v7/fiGn7PS8vz2q72udN3M9bTUFBgRGzPW9tc9Gm9Gu0c1nT3t5uxOrq\n", - "6ozYa6+9ZsTS8Rj5FiSXhoYGI6Z99mmfLdrU+7jvl7lwJQoAAMABRRQAAIADiigAAAAHFFEAAAAO\n", - "Imksd5WVlWXEtMZU38rLy62W0xpWkdmGhoa8rk9rzNRoDb+zs7NGTGvg1Bo9NdpNG0GsXr3aiGnN\n", - "5h0dHUasu7v7A9d/8uRJIzY8PGyVm7afRkdHrV4bd1qTtva7BWkit6UdjzNnzhgx289S7fyx/bwG\n", - "RPSbdOaDK1EAAAAOKKIAAAAcUEQBAAA4oIgCAABwENvGctuGXa2Z1rfq6mqr5RZaY/mPf/xjI1ZR\n", - "URFBJguPNlF3fHzceX3aDRq+pwX/9re/NWLalOyF9j5a6LTzTIvNZ4p0plq8eLHVcp2dnSnORL8Z\n", - "Q6M1/9u+VnuSgPaZ4fsGn/ngShQAAIADiigAAAAHFFEAAAAOKKIAAAAcxLaxXJueqzW/zszMpDwX\n", - "2wnPvtlOUh0ZGUlxJva06ciavr4+r9utra21Wk6bjpyOtIZL7b1g24w7NTUVOKcPok3J9jkV3LZZ\n", - "NQjb89tWXl6eESsrKzNi2vR428++OE1et50MrzUjT0xMGDHtM1J7bwRhe4PFQmt8154gEgbf7/Og\n", - "359ciQIAAHBAEQUAAOCAIgoAAMABRRQAAICD2DaWa81jWmN5GKJqLNeaKzVxaizv6OiIOoUFobKy\n", - "0ojZNsB2d3dbLed7Ynmq1dfXGzHb94bWuK01ePtuwC8vLzdi2kRmLb905LsxPwzaeaAZHBw0Yr6f\n", - "qBHGJHJb2k0RmiA5a/tvenraeX2pwJUoAAAABxRRAAAADiiiAAAAHFBEAQAAOIiksfzixkmtUUyb\n", - "hqo1m+fn5xux6urqANmZSktLrZYbGhoyYkGm2Pqe6h2E1uyqTZW31dDQECQdg7bvF5rx8XGv6wty\n", - "7mqN7xqtGbeurs6I2byntWn02j5ZtMju344DAwNWywWhbUObzB3kyQzaDQK+p2vb3vSj3aSj/b62\n", - "DffaZ+Qbb7xhlYst2/NF+87y3VgehpKSEiOmffdqDeO+p4kvWbLEiGnf+dp5oN2MsW7dOiO2ePFi\n", - "x+z+F1eiAAAAHFBEAQAAOKCIAgAAcEARBQAA4CCR9N1h+EEbTCS8NzUCAACkwqXqFq5EAQAAOKCI\n", - "AgAAcEARBQAA4IAiCgAAwEEkE8u1CbqppjWFRZGHSLBctAmuZ8+etXrt1NSUcy7aFGmN7XIHDx50\n", - "zkXT1NTL6yctAAAgAElEQVRkxDo6OoxYcXGxEdMm72bK+eJbkFyWLVtmtVx7e3tK8/DNNpeysjKr\n", - "9QWZlG6bS15entX6tGni2mRubaK6bS62sSDTv21zsT1Hbc+1kydPOufim+0+1Sa0h3EzmO1+0SaM\n", - "a9872tMKtCcknD592iqXuXAlCgAAwAFFFAAAgAOKKAAAAAcUUQAAAA4iaSy3UV1dbbXcuXPnvG63\n", - "sbHRiL344otWr3300UeN2A9/+MOgKV1Aa4LTGj2DNGFq+vv7rbZr21jum21z/fDwcIozgYhIQUGB\n", - "EfvoRz9q9drvf//7vtO5wNVXX2213K9//Wuv29UaxsvLy61i2vsvCK1h3JbvJmNtfVE91cLmpgYR\n", - "keXLl6c4E72pOsh+sX1t3J8okpuba7Vcfn6+EdMay4PiShQAAIADiigAAAAHFFEAAAAOYtsTpQ1F\n", - "1GgDtTK570UbtqnReqeCsO2h0IZohqGnpyeS7SL9NDQ0WC3nuycqU/jut9Ro/SyTk5OR5KLRhmj6\n", - "pvX+BOlly2TT09NWy9n2U80HV6IAAAAcUEQBAAA4oIgCAABwQBEFAADgIJEMebKW7dOqS0pKjJg2\n", - "3FFrIteazNLxqe8a343lmbJffCMXXVxyCZJHRUWF1XJ9fX0pz8W3TMlFawDWGsvDyMU321yCDNvU\n", - "vis12ndl3PeL7e9m20Q+Njb2gbkkEok59z1XogAAABxQRAEAADigiAIAAHDgXET19/fL3XffLVdc\n", - "cYU0NzfLa6+9Jr29vdLS0iKrV6+WrVu3en9oJgAAQFw4N5Zv375dbrzxRrnvvvtkenpaRkZG5Ctf\n", - "+YpUV1fLww8/LE888YT09fXJzp07L9xgzJvWwhAkl6KiIiNWVVVl9Vptym6m7BffyEUXJJfGxkar\n", - "mKa1tdVbHr6Riy5ILuXl5VbLDQ0NGbGZmRmvudTV1Rkx7XNY+3wNcpOTbX7a+mxvnujt7XXerm++\n", - "z92cnBwjNjU15ZSL98bygYEB+fnPfy733XefiIhkZ2dLWVmZ7N69W7Zv3y4i/1tkvfDCCy6rBwAA\n", - "iD2nIurEiRNSU1Mj9957r2zcuFG++MUvysjIiHR3d5+v2uvq6qS7u9trsgAAAHHh9ADi6elpefPN\n", - "N+Xb3/62XHvttfLggw+qf7aL6rIgAACAi9bWVqOFYC5ORVRDQ4M0NDTItddeKyIid999t+zYsUPq\n", - "6+ulq6tL6uvrpbOzU2pra11WDwAAEInNmzfL5s2bz//8+OOPz7msUxFVX18vy5Ytk6NHj8rq1atl\n", - "7969snbtWlm7dq3s2rVLHnnkEdm1a5fceeedLqufU2VlpdVyWrNcptCmsBYWFkaQSbxoVz3z8/ON\n", - "WHV1tRFrb29PSU640HXXXWfEtAn84+PjRsz2X4XIDLY3HBw7dsyIjYyMeM1F+8zwTZvCbXvDUJBJ\n", - "7ulI+76rqamxem1HR4cR05r/58OpiBIR+da3viWf+9znZHJyUlasWCFPP/20zMzMyD333CNPPfWU\n", - "NDY2yvPPPx8oOQAAgLhyLqKuvvpq+eUvf2nE9+7dGyghAACAdMDEcgAAAAcUUQAAAA6cJ5Y7b/AS\n", - "kz8BAADixPvEcgAAgIWOIgoAAMABRRQAAIADiigAAAAHznOigrh4uvSf/umfGstcf/31RuzgwYNW\n", - "6/+Hf/gHI6Y1hWlTrv/sz/7MiG3cuNGIaVOu//Vf/9WItbW1OeeiKSoqslrOdmpvkFx8IxddOuai\n", - "TdbXaK/VJjWfPn3aKY8wZEouTU1NVssdOXIk5bn4FiSXnJwcI7ZokXn9YWJiwogVFxcbsaGhIedc\n", - "fIv7MSooKDBif/EXf2HEPvrRj1qtb//+/UbsW9/6lhEbHh6eM8+LcSUKAADAAUUUAACAA4ooAAAA\n", - "BxRRAAAADiJpLL/YT3/6UyOmNS9qDd5R0Zpfs7NTvzttG8Z9W7p0qdVyHR0dKc4Ec1m8eLER+9jH\n", - "Pmb12qefftprLlrjrYanF0Rj2bJlRuzw4cNWr/3CF75gxL773e8655KVlWUVm5ycdN5GEIWFhVbL\n", - "aY3l82lQXkhsm9fHx8dTnEnw71SuRAEAADigiAIAAHBAEQUAAOCAIgoAAMBBIhlyZ2ecpqFquQSZ\n", - "CK5Ntp2amnLOJQy2uZSUlFitT5vG6zuXMKRjLmE0ltvmojUGa2ZmZoyYdq5dfF6l4/GxlZ+fb8Rs\n", - "G2xtc9Eay0+ePGm1DdvG8kw+RkGQi76N2dlZq+Vsv7e1z6DBwUEjpu2Di2OJRGLOm2C4EgUAAOCA\n", - "IgoAAMABRRQAAIADiigAAAAHNJZfpLi42Gp92iRabX02TWtzvTYMtrloTfMarZHedy5hIBddGLl8\n", - "6EMfMmIXv9+6u7tTnoetdGws19h+ftlaaOetLXLRxTkXGssBAAA8o4gCAABwQBEFAADggCIKAADA\n", - "QXbUCcSN1jBuK+QefSDtVVVVGbHa2lojpk02z1S2TeS+aZ9fS5YssXrt6dOnveaSnW1+NWnnika7\n", - "6QBIFa5EAQAAOKCIAgAAcEARBQAA4IAiCgAAwEFsG8uXLVtmtdzo6KgR6+npsXptXl6eEZuYmLB6\n", - "raawsNCIafmlo6KiIqvl+vv7U5xJdLKysqxi69ats1rf7OysETt48OD8E0sTWrOwNpFY2y9nz55N\n", - "SU7pzPc05zVr1hixhoYGq9f6bixfv369EdMmuWtsG8tLSkqMmNZcX1FRYbW+wcFBI2b7pIc40b57\n", - "tRuu+vr6jJj2PaGt79ixY47ZxQ9XogAAABxQRAEAADigiAIAAHBAEQUAAOAgkQx5zHYikWCyNwAA\n", - "SAuXqlu4EgUAAOCAIgoAAMABRRQAAIADiigAAAAHkUwst5m0azshe9Eisw4cGhoyYlpTmJZHQUGB\n", - "1XbHxsasltPY5qJNw9amPmtT1ktLS42YNlHXNpcwkIvONpfc3Fyr9U1OTqY8l1SLSx4i9rls2bLF\n", - "an3Hjx+3Wu799993ziUMQXKxnRKuTc0OksvnPvc5q/X96le/slru0KFDzrloamtrrZY7c+aM1XLp\n", - "eL5UV1cbsY9//ONGTJuK/rOf/cw5l7lwJQoAAMABRRQAAIADiigAAAAHFFEAAAAOImksv9iaNWuM\n", - "2BVXXGHEtGavV155xWsus7OzXtcXxMzMjFVMozWRZ4rVq1cbsUceecTqtdpy586dC5zT71u+fLnV\n", - "cidPnvS6Xa1hfP369Vavfeutt7zmAtPBgwetlhsdHU1xJtEpKyszYgMDA0bMtmHct+9///uRbFez\n", - "YsUKI7Zp0yYjpt3ktHv37pTkFAfa+dLW1hZ+Iv+HK1EAAAAOKKIAAAAcUEQBAAA4oIgCAABwEIvG\n", - "8iB6enq8rk+b/h0VbWp7fn6+EdMaC8NoTt22bZvVcj/+8Y+N2MjIiO90IqFNldemxceddl6Nj49H\n", - "kEnm6u/vt1rOdvI8otPc3Gy1nDax3Jb2/tNuGMqUz1JbU1NTRkz7jgkLV6IAAAAcUEQBAAA4oIgC\n", - "AABwQBEFAADgIJHUxoCncoOJRJibO0/7NeOei9ZgWlJSYsS0hlXbyeZB9ovvxvJ0PEYa7Rhp6xse\n", - "Hk55LgUFBUZMu3nCdlJ/XI5RXPIQIZe5ZEou2ntoy5YtVq996aWXvObyqU99yuq1x48fN2IHDhzw\n", - "motvcc4lkUio+YlwJQoAAMAJRRQAAIADiigAAAAHFFEAAAAO0mpiuTZVWWuInZycDCOdlNN+D98T\n", - "2oPYt2+fEauurjZi5eXlRiyTp+wODQ1FncJ52jR7xIf2mZadbX4sa02t6fgeqqioMGJ9fX1et+G7\n", - "GVnb93H6jtHOIYSHK1EAAAAOKKIAAAAcUEQBAAA4oIgCAABwENvG8ubmZiOWk5NjxLTG2aNHj1pt\n", - "o6qqyogNDAxYvXZ6etpquUzW1NRkxG6//Xar1/7N3/yN73RiQ2uk16bKLzSVlZVWy/X29qY4k2ho\n", - "58WGDRusXtvR0WHEbD/n4k5rBNc+6zVag3deXl7gnH7f+Pi4EXv33Xe9bsOWdh5o++rgwYNet6tt\n", - "Y2pqynl9UU0iTwWuRAEAADigiAIAAHBAEQUAAOCAIgoAAMBBIqmNY03lBhMJdQIsAABA3FyqbuFK\n", - "FAAAgAOKKAAAAAcUUQAAAA4oogAAABxEMrHcZlppdraZmu3Eco3WFGY7NXXlypVGTJs+fOLECSPW\n", - "09PjNZcgcnNzjdjExEQkuWii2i+aTMll/fr1VstpE5i191Zc9ktc8hAJlkt+fr4R0yZBz8zMeM2l\n", - "oKDAan1ZWVlWyw0PDzvnom3jox/9qNV2z5w5Y8Teeecdr7kUFRUZMe27SHvahfZki3Q8dxsbG63W\n", - "19DQYLXcK6+8YpWLdjy02kCbXF9WVmbEbJ9IMp+b37gSBQAA4IAiCgAAwAFFFAAAgAOKKAAAAAeR\n", - "NJb7pDVLa01mQTQ3NxuxZcuWGbHx8XEjpjWWR8X3fgFgT/usWrFihdVrDx06ZMSCPPnBtuFZu7nA\n", - "dxN0TU2NEWtqarJ6bV9fn9dctEZ/ral/cHDQ63ZtlZSUWC03NDTkdbttbW1Wy2lN30HMzs4asbq6\n", - "OqvXFhYWGjGt2fzkyZPzT+z3cCUKAADAAUUUAACAA4ooAAAABxRRAAAADmLbWK41PmqxONGa4OJE\n", - "a2xdaLTGTN9NmHHy1ltvGTGtmXnJkiVG7L333ktJTguVdmNHb2+v1WuDNJFrFi0y//0cZCq6b8eP\n", - "HzdixcXFKd8udIsXLzZiWpO29h2tHcsgtO8x7WYH7QkimqDN8FyJAgAAcEARBQAA4IAiCgAAwIFz\n", - "EbVjxw5Zu3atXHnllfLZz35WJiYmpLe3V1paWmT16tWydetW6e/v95krAABAbCSSDl2CbW1tcvPN\n", - "N8vhw4clLy9PPvWpT8ltt90m77zzjlRXV8vDDz8sTzzxhPT19cnOnTsv3KDnabe2tF8zTrlojZ6+\n", - "Gzi1hryJiQkjFqf9Qi7+c1m3bp3Vcm+//XbKc3EVlzxEyGUunLe6TMmlqKjIiI2MjKQ8F227Gp+5\n", - "JBKJOb+Pna5ElZaWSk5OjoyOjsr09LSMjo7KkiVLZPfu3bJ9+3YREdm+fbu88MILLqsHAACIPaci\n", - "qrKyUr785S/L8uXLZcmSJVJeXi4tLS3S3d19/rk2dXV10t3d7TVZAACAuHAakPDee+/JN77xDWlr\n", - "a5OysjL54z/+Y/ne9753wTKJRCKyS5QAAAAuWltbpbW11WpZpyLqwIEDcsMNN0hVVZWIiHzyk5+U\n", - "X/ziF1JfXy9dXV1SX18vnZ2dUltb67J6AACASGzevFk2b958/ufHH398zmWdiqimpib5u7/7Oxkb\n", - "G5P8/HzZu3evXHfddVJUVCS7du2SRx55RHbt2iV33nmny+rTQkFBgdVyY2NjVstpV+18N5ZrE5N9\n", - "a2xstFqura3N63YX2iTyIE6fPh11CsAlrVy50oiVlpZGkAnmEqRxO5M4FVFXX321fOELX5BNmzbJ\n", - "okWLZOPGjfInf/InMjQ0JPfcc4889dRT0tjYKM8//7zvfAEAAGLBacRBoA2m4a2cmiBXorRcsrKy\n", - "jFgYz+LzvV+CXIkKkovvK1GZchuyprKy0mo57blucdkvcclDhFzmEiQX7UqUbXvI/v37vebiG7no\n", - "FtSIAwAAgIWOIgoAAMCBU08U/AvjT3eZYsmSJUZMazo9evSoEcuU/aztg4qKCiOmXdLW/pSq/RlW\n", - "20YQ2sR8jesNEL4nKAdRVlZmxPLz842Ydsy0Pxv09PRYxWxpT0jQjs/4+LjzNoJYsWKFEdNyHhgY\n", - "CCMdxIjvP+cF/fMlV6IAAAAcUEQBAAA4oIgCAABwQBEFAADgIJI5USFvEgAAwAlzogAAADyjiAIA\n", - "AHBAEQUAAOCAIgoAAMBBJBPLXSeElpeXGzFtou7U1JQRm56e9pZHUOn40Mcw2OaiTS6+6qqrjNjw\n", - "8LARO378uHMuvh8SrU2I1qZ12+6X4uJiq+1qv4dmcHDQiGm/r+35cuedd1ot97Of/cyIXfww5HQ8\n", - "b7Oz7T5utc+qILlo0/xtPzc12nmmncvaRPW4H6MwBMklyAPefefim20uy5YtM2JVVVVG7Ny5c0ZM\n", - "e6j66OioVS5z4UoUAACAA4ooAAAABxRRAAAADiiiAAAAHETSWH4xrVFY09/fn+JMRPLy8pxfOzEx\n", - "4TGTeNEa/LSGVc3AwIDXXHJycozY8uXLrV5r21iuCdJErtGayIOoqKgwYl/60pesXvuXf/mXXnMJ\n", - "orCw0IhpDaGppn0uBTkHtIbxpqYmq9ceOXLEebtDQ0POr9VoN2xkspUrV1otF+SzxdaSJUuslrNt\n", - "LE9HXV1dRizKp6BwJQoAAMABRRQAAIADiigAAAAHFFEAAAAOYtFY7rthNwhtmrMW890UHHda4542\n", - "0ToMWgP/2NhYBJnES1lZmRG75pprIshE98ILLxix/Px8I6ZN045ClM2qiI8wGsZt7d+/P+oUIqdN\n", - "1j99+rTVa1PxnuZKFAAAgAOKKAAAAAcUUQAAAA4oogAAABwkkiF3T2qTr8Og/ZrkQi5zyZRcPvzh\n", - "DxuxmZkZI3bgwIGU5+JTXPIQyZxcfDf5Z8p+8Y1cdLa5ZGfb3Q+n3bCmbcMmlkgk5mxK50oUAACA\n", - "A4ooAAAABxRRAAAADiiiAAAAHKR9Y3leXp4R0yZap2MDXRgyJZfi4mIjpjUWjo6OpjwX38glvnmI\n", - "ZE4u2k0IJSUlRkybDn3o0CGvudDkHo50zKW8vNxqff39/d5yobEcAADAM4ooAAAABxRRAAAADiii\n", - "AAAAHNiN/vTs4mYxrWFr06ZNVusaHh42YkeOHHFLDGlLa0TVaM2pWgN6psjJyTFiU1NTEWSSerY3\n", - "mdiqrKwMkk5s2J4D9fX1RmzJkiVGTJt4rzWWBzE9Pe11femotLTUarmhoSEjpp27Id9DljJBGsZT\n", - "gStRAAAADiiiAAAAHFBEAQAAOKCIAgAAcBDJxPJMaXADAACZjYnlAAAAnlFEAQAAOKCIAgAAcEAR\n", - "BQAA4CAWE8ubmpqsXtfb22u1nDaNV3vtxXmERWtQs81l69atVsu9/PLLKc/FtyC5ZGVlWS2nTVv2\n", - "nYtvmZzLQw89ZLXc17/+dac8cnNzrdZfUVFhxLRz6vTp00YsyD65/vrrrZZ79dVXrZazzaWkpMRq\n", - "fdo0bFtB9stHPvIRq+WOHTtmxM6cOeM1F9+C5KJNkM/ONr/GBwYGrGJB3kcbN240Yl1dXVYx7ckR\n", - "vo9RcXGxVUzLbz43v3ElCgAAwAFFFAAAgAOKKAAAAAcUUQAAAA4iaSy/WF9fnxG77bbbrF77n//5\n", - "n0ZMa6DLFAcOHIg6hfM+8YlPWC33X//1XynOZOHRGi5tmyGXLl1qtVxHR8e8coqjyclJq+VuuOEG\n", - "q+U4l4MpLS01YoODgxFkkp60GxvKyspSvt2WlhYj9pWvfMXqtX/1V39lxH70ox8553LVVVcZsbq6\n", - "OiM2OztrxH75y186b3cuXIkCAABwQBEFAADggCIKAADAAUUUAACAg1g0lnd3dzu/NpObyDW2U9vD\n", - "oE3KjYrtJHLEy8WTyH2znXisTVAOw2uvvRbJduczkTkK+/fvt1oujN9j3bp1Vsu9/fbbKc5EF/fv\n", - "wIKCAq/rKywsNGK2x+iNN97wmosIV6IAAACcUEQBAAA4oIgCAABwQBEFAADgIJEMucPQttHTN+3X\n", - "JBdymQu56OKSi20etrkF+RgMsk+ysrKslrO9ccI2F9tm37GxMavlguSiKS8vN2Ja87/tDQFBcvHd\n", - "WB6X95BIsPPlgQceMGLazUY//elPjdjrr7/unIs2nfzyyy83Ytq58dZbbxkxzcW5JBKJOT8juBIF\n", - "AADggCIKAADAAUUUAACAA4ooAAAABzSWR4BcdOSiI5do8qioqDBifX19keRiK4xc6uvrjVhXV5fX\n", - "XDZu3Gi13OHDh42Y1gy/0I6RrSC55ObmGjGtwVvz7rvves3FNxrLAQAAUowiCgAAwAFFFAAAgAOK\n", - "KAAAAAfmeNEQ5OTkXPCz1qCmGRkZSUU6saBNLradUoxwaOfp5ORkBJmILFpk/vtndnbW6rV5eXlG\n", - "LD8/34gNDAzMP7H/43sits8GU+131aYbFxUVGTGtsTyTaU3ksFdZWel1fdr7IOR7wy5J+44eHBx0\n", - "Xl+Q3zfIZ+R8cCUKAADAAUUUAACAA4ooAAAABxRRAAAADiKZWB6nRjgAAIC5MLEcAADAM4ooAAAA\n", - "BxRRAAAADiiiAAAAHEQysbywsPCCn22nFgehNYX5nII8H+Sis81l48aNVus7duyY1XJDQ0POudgq\n", - "KSmJTS5BpuPb5qJNC9amN587d85qu655aLRJ5BrbJyQEyeX++++3Wu6pp55KeS7aJHvNxMREynPx\n", - "LUgupaWlRkybfD08POw1F+09tHjxYqttdHR0eM0lO9ssFRoaGoxYV1eXEdOeBhAklzDM5+Y3rkQB\n", - "AAA4oIgCAABwQBEFAADggCIKAADAQSSN5RfLycmxWm5qairFmei0Bj+N1mwI/44fP261nNboGdW0\n", - "fK1hPCq2TeRB+H4v2H5GpJuCgoKoU0BMae8h24Zx32pqaiLZbjrgShQAAIADiigAAAAHlyyi7rvv\n", - "Pqmrq5Mrr7zyfKy3t1daWlpk9erVsnXrVunv7z//33bs2CGrVq2SpqYmefnll1OXNQAAQMQuWUTd\n", - "e++9smfPngtiO3fulJaWFjl69Khs2bJFdu7cKSIihw4dkueee04OHToke/bskQceeIAeIQAAkLEu\n", - "2Vj+R3/0R9LW1nZBbPfu3bJv3z4REdm+fbts3rxZdu7cKS+++KJ85jOfkZycHGlsbJSVK1fK66+/\n", - "Ltdff72x3osnlMe9aZRi0H5Srjax1ncz9+DgoNVy2mRuTZBGa+3cveuuu6xe++///u9ec4k71+nk\n", - "In7fg7aTyMNge5OEdp75vtHGdhL5QmP7eRMn2vT5IMe3r6/Pajnb6eSZZN49Ud3d3VJXVyciInV1\n", - "ddLd3S0iIqdPn75gDHxDQ0NkdxIAAACkWqDG8kQiccln20T13BsAAIBUm/ecqLq6Ounq6pL6+nrp\n", - "7OyU2tpaERFZunSptLe3n1/u1KlTsnTpUn+ZAgAApFhra6u0trZaLTvvK1Hbtm2TXbt2iYjIrl27\n", - "5M477zwff/bZZ2VyclJOnDghx44dk+uuu26+qwcAAIjM5s2b5bHHHjv/v0u55JWoz3zmM7Jv3z45\n", - "d+6cLFu2TP72b/9WHn30UbnnnnvkqaeeksbGRnn++edFRKS5uVnuueceaW5uluzsbPnOd75j/ee8\n", - "IA2SUTWlFxUVGTGt+fXiJvp01dvba7VcVBPBNWHcEBDk/Lv88suN2HvvvRcknYyVqQ33F9/9LEIb\n", - "BILzfZOA9tSO5uZmI6Z95mqfaQMDA34Si4FEMuRvPd8fELZfYpOTk15zCVJEabs8qg9O21y0uz00\n", - "Qd68vveL7Wu17drmUlhYaMS2bdtmtd0DBw4YMe0DRzuv4n6+LJQ8RNLzvA0DuejSMRftc853ERXn\n", - "/ZJIJOa8QMDEcgAAAAcUUQAAAA4oogAAABzMe8TBQrRy5UojVlVVZcS0qa5Hjx71msv69euNWE1N\n", - "jRHTesB+N2neRTpOM46qyb28vNyILV++3Ihp59B3vvOdlOSE9BGnmzOAuZSUlBix3NxcI6Z9d2RS\n", - "YzlXogAAABxQRAEAADigiAIAAHBAEQUAAOAgksby4uLiC37WBlLaTigOMu3c1sX5zmVkZCTFmYhU\n", - "V1cbsbKyMiN29uxZ521oA86CNLv6Xl+cjI6Oel1fpuyXKGjvU+0GCy0GfXCxFhsfHzditk8H0D4L\n", - "bAcX277XbD+vYU9rIl+7dq0Rq6ystHrtO++84yexGOBKFAAAgAOKKAAAAAcUUQAAAA4oogAAABwk\n", - "kiF3sl7qacgAAABxcqm6hStRAAAADiiiAAAAHFBEAQAAOKCIAgAAcBDJxHJtam2qaU1hWh7l5eVW\n", - "6+vv7095LraWLl1qtVxHR0fKcwlCy2XRIrPOz8rKct6Gtj5tgnXc90vcc9EmF2t6e3tTmsfGjRuN\n", - "mDbhf2BgwGq7b775pnMuGt/7SctFe7/YThi3lZeXZ8S0yebafqmvr7faxoc+9CGr5fbv32/E0vE9\n", - "VFBQYLU+7YkfQXLRtqs9GUR7eoaWy+DgoHMucTpGc+FKFAAAgAOKKAAAAAcUUQAAAA4oogAAABxE\n", - "0lgeZ1qTMUSuuuoqI/alL33JiJ07d86IPfLII87b1Rr8pqenrV6bnR3N6V1RUWHE+vr6Ur7dyy67\n", - "zGo520bPIDnffPPNVst1dXVZLffKK6845aE1gmvWrFnjtP65aDcw+G7mzsnJsVquoaHBiJ08eTKS\n", - "XDS2Tf3pKMhNMEEaxoPQbgiw/T2CnAdB3HjjjVbL7du3z/u2uRIFAADggCIKAADAAUUUAACAA4oo\n", - "AAAABzSWX2R0dDTqFOZNm0QelaiauVesWGHEtCbHI0eOpDyXMJrI425mZibqFObl3XffjWS7rhPb\n", - "ReY3VTnOioqKjFhVVZURO3XqlBHz3SDvW7q9D+ai/R7d3d0RZBI/XIkCAABwQBEFAADggCIKAADA\n", - "AUUUAACAg0Qy5O7ERCIR5ubO035NcgmWS15enhHTGhBtJ4wHyaWmpsaI5ebmGjHbJvx0PEbV1dVW\n", - "69OmyvvOpbGx0Wp9/f39RkybsP3+++9f8LM2dT3uxycMWi5ak3aQhvYguWj7JT8/34iVl5cbMW2C\n", - "t+20c9/HyPYGGu2zL+7nC7mYuSQSiTlv5OBKFAAAgAOKKAAAAAcUUQAAAA4oogAAABwwsRzOJiYm\n", - "ok7hvLNnz0adAn5PW1ubEdOahZcsWWLEtEbozs5OL3ktRGE0kQcxPj5uxLq6uiLIxJ72NASN7U01\n", - "SF9ciQIAAHBAEQUAAOCAIgoAAMABRRQAAICDWDSWL1pk1nJZWVlGbGpqKox0gLQUZBJ5ENr0Zq2h\n", - "dqLs8QcAAAYuSURBVHJy0mp92k0CPT09H/g6rdnX9jMjyGs19fX1Rmx2dtaInTlzxmp92jR67ekA\n", - "moKCAiOmTf8OQrtpIAjtaQO254+t2tpaI2Z7PGz3X2Vl5bxy+iBFRUVGTNsvfFeGhytRAAAADiii\n", - "AAAAHFBEAQAAOKCIAgAAcJBIJpPJUDeYSEjImwQAAHByqbol0itRra2tUW4eF+F4xAfHIl44HvHC\n", - "8YiPhX4sKKJwHscjPjgW8cLxiBeOR3ws9GNBTxQAAIADiigAAAAHoTeWb968Wfbt2xfmJgEAAJzc\n", - "eOONc/7ZMvQiCgAAIBPw5zwAAAAHFFEAAAAOKKIAAAAcRFJE7dmzR5qammTVqlXyxBNPRJHCgtbe\n", - "3i433XSTrF27VtatWyff/OY3RUSkt7dXWlpaZPXq1bJ161bp7++PONOFY2ZmRjZs2CB33HGHiHAs\n", - "otTf3y933323XHHFFdLc3CyvvfYaxyNCO3bskLVr18qVV14pn/3sZ2ViYoLjEaL77rtP6urq5Mor\n", - "rzwfu9T+37Fjh6xatUqamprk5ZdfjiLlUIVeRM3MzMif//mfy549e+TQoUPyzDPPyOHDh8NOY0HL\n", - "ycmRr3/96/LOO+/Iq6++Kv/0T/8khw8flp07d0pLS4scPXpUtmzZIjt37ow61QXjySeflObmZkkk\n", - "EiIiHIsIfelLX5LbbrtNDh8+LAcPHpSmpiaOR0Ta2trkn//5n+XNN9+U3/zmNzIzMyPPPvssxyNE\n", - "9957r+zZs+eC2Fz7/9ChQ/Lcc8/JoUOHZM+ePfLAAw/I7OxsFGmHJxmy/fv3J2+55ZbzP+/YsSO5\n", - "Y8eOsNPA7/n4xz+e/NGPfpRcs2ZNsqurK5lMJpOdnZ3JNWvWRJzZwtDe3p7csmVL8ic/+Uny9ttv\n", - "TyaTSY5FRPr7+5OXX365Eed4RKOnpye5evXqZG9vb3Jqaip5++23J19++WWOR8hOnDiRXLdu3fmf\n", - "59r/X/3qV5M7d+48v9wtt9yS/MUvfhFusiEL/UpUR0eHLFu27PzPDQ0N0tHREXYa+D9tbW3yq1/9\n", - "Sj784Q9Ld3e31NXViYhIXV2ddHd3R5zdwvDQQw/J1772NVm06P+/HTkW0Thx4oTU1NTIvffeKxs3\n", - "bpQvfvGLMjIywvGISGVlpXz5y1+W5cuXy5IlS6S8vFxaWlo4HhGba/+fPn1aGhoazi+3EL7fQy+i\n", - "fvfnCkRveHhY7rrrLnnyySelpKTkgv+WSCQ4ViF46aWXpLa2VjZs2DDnU8I5FuGZnp6WN998Ux54\n", - "4AF58803paioyPhTEccjPO+995584xvfkLa2Njl9+rQMDw/L9773vQuW4XhE64P2f6Yfm9CLqKVL\n", - "l0p7e/v5n9vb2y+oXBGOqakpueuuu+Tzn/+83HnnnSLyv/+i6OrqEhGRzs5Oqa2tjTLFBWH//v2y\n", - "e/duufzyy+Uzn/mM/OQnP5HPf/7zHIuINDQ0SENDg1x77bUiInL33XfLm2++KfX19RyPCBw4cEBu\n", - "uOEGqaqqkuzsbPnkJz8pv/jFLzgeEZvr8+ni7/dTp07J0qVLI8kxLKEXUZs2bZJjx45JW1ubTE5O\n", - "ynPPPSfbtm0LO40FLZlMyv333y/Nzc3y4IMPno9v27ZNdu3aJSIiu3btOl9cIXW++tWvSnt7u5w4\n", - "cUKeffZZufnmm+W73/0uxyIi9fX1smzZMjl69KiIiOzdu1fWrl0rd9xxB8cjAk1NTfLqq6/K2NiY\n", - "JJNJ2bt3rzQ3N3M8IjbX59O2bdvk2WeflcnJSTlx4oQcO3ZMrrvuuihTTb0oGrF+8IMfJFevXp1c\n", - "sWJF8qtf/WoUKSxoP//5z5OJRCJ59dVXJ9evX59cv3598oc//GGyp6cnuWXLluSqVauSLS0tyb6+\n", - "vqhTXVBaW1uTd9xxRzKZTHIsIvTWW28lN23alLzqqquSn/jEJ5L9/f0cjwg98cQTyebm5uS6deuS\n", - "X/jCF5KTk5McjxB9+tOfTi5evDiZk5OTbGhoSP7Lv/zLJff/V77yleSKFSuSa9asSe7ZsyfCzMPB\n", - "s/MAAAAcMLEcAADAAUUUAACAA4ooAAAABxRRAAAADiiiAAAAHFBEAQAAOKCIAgAAcPD/ADWWZox7\n", - "IqDoAAAAAElFTkSuQmCC\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "feat = net.blobs['pool5'].data[0]\n", - "vis_square(feat, padval=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first fully connected layer, `fc6` (rectified)\n", - "\n", - "We show the output values and the histogram of the positive values" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAlgAAAJPCAYAAACgtar/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3XucFNWd9/FvK+zmyQoGjAysmMUgBAWEiSZmEzVDcMhV\n", - "g4svozE4j5dsHvPkoibe4maDuegYV101vjbGNT6sPjFhn2yQZBUjwfaCAYxCYryEKKCAMxN0RG4i\n", - "MFPPH2MPPT3V3XU5p+pU9ef9evFipqfqnFNVp6p+fc6pUwXP8zwBAADAmP3SLgAAAEDeEGABAAAY\n", - "RoAFAABgGAEWAACAYQRYAAAAhhFgAQAAGBYowNqyZYtOPfVUHXHEETryyCO1YsUKdXd3q7W1VRMn\n", - "TtSsWbO0ZcsW22UFAADIhEAB1le/+lV94hOf0LPPPqs//OEPmjRpktrb29Xa2qo1a9Zo5syZam9v\n", - "t11WAACATCjUm2j09ddfV3Nzs9auXTvg80mTJumhhx5SU1OTOjs71dLSoueee85qYQEAALKgbgvW\n", - "unXrdPDBB+vss8/We9/7Xn3+85/Xjh071NXVpaamJklSU1OTurq6rBcWAAAgC+oGWHv37tWTTz6p\n", - "L37xi3ryySf1N3/zN4O6AwuFggqFgrVCAgAAZMmQeguMHTtWY8eO1fve9z5J0qmnnqqrr75ao0eP\n", - "Vmdnp0aPHq2Ojg6NGjVq0LqHH364XnjhBfOlBgAAMGz8+PF6/vnnjaRVtwVr9OjROvTQQ7VmzRpJ\n", - "0pIlSzR58mSddNJJmj9/viRp/vz5mj179qB1X3jhBXme13D/vvWtb6VeBrab7Wa72W62m+1mu8P9\n", - "M9koVLcFS5JuvvlmnXnmmdq9e7fGjx+vO+64Qz09PTrttNN0++23a9y4cVqwYIGxQgEAAGRZoABr\n", - "2rRpevzxxwd9vmTJEuMFAgAAyDpmcregpaUl7SKkgu1uLGx3Y2G7G0ujbrdJdefBipV4oSCLyQMA\n", - "ABhjMm6hBQsAAMAwAiwAAADDCLAAAAAMI8ACAAAwjAALAADAMAIsAAAAwwiwAAAADCPAAgAAMIwA\n", - "CwAAwDACLABoAB0d0iGHpF0KoHEQYAFAA1izRnr55bRLATQOAiwAAADDCLAAAAAMI8ACgAa3cyfj\n", - "swDTCLAAoMG9+irjswDTCLAAAAAMI8ACAAAwjAALAADAMAIsAAAAwwiwAAAADCPAAgAAMIwACwAA\n", - "wDACLAAAAMMIsAAAAAwjwAIAADCMAAsAAMAwAiwAAADDCLAAAAAMI8AC0LCWLJH+9V/TLgWAPCLA\n", - "AtCwLr9cuvDCtEsBII8IsAAAAAwbEmShcePGafjw4dp///01dOhQrVy5Ut3d3frMZz6jF198UePG\n", - "jdOCBQv0jne8w3Z5AcCYQiHtEgDIq0AtWIVCQcViUatWrdLKlSslSe3t7WptbdWaNWs0c+ZMtbe3\n", - "Wy0oAABAVgTuIvQ8b8DvixYtUltbmySpra1NCxcuNFsyALCMFiwAtgRuwTrxxBN1zDHH6LbbbpMk\n", - "dXV1qampSZLU1NSkrq4ue6UEAAsIsADYEmgM1rJlyzRmzBht3rxZra2tmjRp0oC/FwoFFbhSAUAm\n", - "cfkGzAsUYI0ZM0aSdPDBB+uUU07RypUr1dTUpM7OTo0ePVodHR0aNWqU77rz5s3r/7mlpUUtLS2x\n", - "Cw0AMKdiBAjQMIrFoorFopW0C17l4KoKO3fuVE9Pj4YNG6YdO3Zo1qxZ+ta3vqUlS5booIMO0qWX\n", - "Xqr29nZt2bJl0ED3QqEwaOwWAHM8T9pvP26QUX3gA9KKFQP336239s2NtXNneuWy4aGHpJYW/7qy\n", - "YYP0rndRjwCTcUvdFqyuri6dcsopkqS9e/fqzDPP1KxZs3TMMcfotNNO0+23394/TQMAZIlf19jy\n", - "5dIbbyRfFgD5UjfAOuyww7R69epBn48cOVJLliyxUigAAIAsYyZ3AA2Lwd3Z8dJLaZcACIcAC0DD\n", - "IsDKBs+T/u7v0i4FEA4BFgAAgGEEWECG8dQXALiJACtnNm5MuwRIA4EWALiFACtnDj1UevzxtEsB\n", - "ZANjsADYQoCVQ9u3p10CIBsIsADYQoAFAHBaqQucrnBkCQEWgIaV1RasrVvTLoF5y5YRQCFfCLAA\n", - "IEOefFI68MC0S2Heccf1vRMRyAsCLAc98kjfP6Aeuk7Mc31fdnebT9OVljzX9z0QRt13ESJ5J5zQ\n", - "9z8XGwCV9rPwtZhrDWAeLVgAGpZfy40rrTnVuF4+AH0IsAA0rCwGKzZasACYx6kKABmSxaAwLsYa\n", - "IosIsAA0rCwGK1ksM9CICLAcxUUUgB+uDUA2EGA5Kk5TOM3ojYOuk8ZjYwwWQRtgHgEWAGSIjWCI\n", - "AB0wjwArh/g2CgSTxXOFpwiBbOBUdVQWL/xA1mTxPMtimeOihQ1ZRICVQ3v2SDt2pF0KADY0YoBV\n", - "QqCFLCHAyqHzz5cOOCDtUgDuy2KwksUyA42IACuH1q5NuwRICt/ozXN9nzIGC8gGTlUgB1wPClyV\n", - "xdYgG2XO4n4AXEeABQBlXA82aMECsoFTFQAypBHnwXK9fIAfAiwH/Pa30m9+k3YpgMbjemuVnyyW\n", - "2RQCLWTJkLQLAOljH5O2bh148WjkiyiA6qJeGwhOgGTRguUoLobJevNN6amn0i4FkpbFLzKMwQKy\n", - "gVMVkHT99dJRR6VdivAIxM1zfZ9GDQqzGEwCWUaABUjauTPtEsTjelDgqiwGHY0+TcN73iPdcEPa\n", - "pQDqI8BCKJ2d0rp1aZcCsCdLwUYjWrNGWrIk7VIA9SUaYF13nTRnTpI5ZperF/mZM6V3vzvtUgAw\n", - "yfUWUNfLB/gJFGD19PSoublZJ510kiSpu7tbra2tmjhxombNmqUtW7YEyuw//kP6r/+KXlikb+vW\n", - "tEsAE7ZvlzZsSLsU6XP1i0wtjRxsNPK2I3sCBVg33nijjjzySBXeuhq1t7ertbVVa9as0cyZM9Xe\n", - "3m61kADM+vznpXe9K+1SAEB+1Q2wNm7cqHvvvVfnnXeevLe+PixatEhtbW2SpLa2Ni1cuNBuKeGM\n", - "LH7jz7Oo3+hfecVsObLKrz7TSgLAhLoB1oUXXqhrr71W+5VNvtLV1aWmpiZJUlNTk7q6ugJlxs0Z\n", - "sIOgIJosXpOyWGagEdWcyf1Xv/qVRo0apebmZhWLRd9lCoVCf9ehn3nz5vX/vH17i6SW8KUEAFhD\n", - "0NbYCgVp9Wpp2rS0S5K8YrFYNb6Jq2aA9dhjj2nRokW69957tWvXLm3dulVz585VU1OTOjs7NXr0\n", - "aHV0dGjUqFFV0ygPsOhJBNxAi1d1BBvuob7a99xzjRlgtbS0qKWlpf/3K6+80ljaNbsIr7rqKm3Y\n", - "sEHr1q3TT3/6U33kIx/RnXfeqZNPPlnz58+XJM2fP1+zZ882ViAAQHUEG0A2hJoHq9QVeNlll+mB\n", - "Bx7QxIkTtXTpUl122WVWCpeUQsG9mbz5Fg2bqF992A99XA3ali+XHn543++ulhPwU7OLsNyHP/xh\n", - "ffjDH5YkjRw5UksiTKXr8sVsxw7p7W9PuxT7uHohcfkYAo2gkc7BGTOkXbv6/sGuRqpXSeFVOQjF\n", - "1cCvUUU9HhzHPkzTAMAWAiwHcEFHXDbr0DXXSD099tJPE9/aAdhCgOUoVy/8rpYL9lx2Wd9LvhtF\n", - "I9bxRtxmwDYCLAdwcUPS8lbnAr4ONRcascW7EbcZ2UeAFcCPf5y/G1JU7Ae4ZudOacSItEuRvEYM\n", - "Ohpxm5PCtd28RAOsrB7Ap55KPs9GuJB0dkrbtqVdisaUp/q1Z0/0dbN6TTItT/UBcAUtWAFw8bFj\n", - "zBjptNPSLoV9vb3Sn/5kJ23qZjw8RYioli+XNm9OuxRwGQFWiv76r6U//tH/gp6lb9azZ0t/+Uuw\n", - "Ze+4Qxo/ft/vjTB4+j//U5o0Ke1SAAjr29+W/umf/P/2938vffnLyZYH2UKAlaLduwd2P86eLa1Y\n", - "kXw5/uqvpOefj77+PfdIjz8ebNklS6S1a6Pn5apt26SHHtr3e/m7Q7dvt58/rS7RZOmLDJL3ne9I\n", - "3/te9b9z3qEWAiwHlC7y99wT/YXYmzZJL70Ubd09e6Rnn422bpYVCtLvf28mre9/Xyq9L7S7u28G\n", - "amST60GXjZt6I24zBnK9DmQRg9xz4uijpQkT7Odj6hiedZaZdKK66qq+/6MGpZV6e/f9zM0ASaCe\n", - "2cc+Rhy0YDkqbCDz+ut9XY62xb3glNa/8874ZYnjmmvspc1FGbCDcwtZQoAVgO2T2i99LiSAfXFb\n", - "ZDdv5lwF4K9hA6xXX5WuvjrtUtj19NPS5ZebTTPuDYluYrO4uccTd5qGUaOk//gPc+VJC/UIMK9h\n", - "A6yFC6VvfCPtUvQxEXT4XSB//GOpvT1+2ib85S/Sb37DhRz5E3SKEiTLxAvKG+l6xZdf8xjk7ihX\n", - "91XUcl1+uXTiiWbL4qo0LsqNdCMwydXzrBaOdX3r10tDhvRNZPzDH6ZdmnR4nrR1a9qlaGwN24KV\n", - "N1m8UWTNo4+ynxtBVo6xyUDL9W0Ou62vvtr3/3/+pzR/vvnyZMEdd0gHHph2KRpbwwZYQS4opSZm\n", - "vjHu08j7Iug7KYPsow0b3L+pAa5p5OtPWBs2pF0CpBpgvfFGMlMLRPH0031NzEnI0kVj/fq0S2BW\n", - "WkHOyy+nk29JluqcTQS5AGxJNcA67DDp1FPTLEF1WXtHHjfMaLK+38rL/+tfS9Onp1eWvMh6nciT\n", - "tI9FGvl/97vSsGHJ5wvzUg2wurqCd7vkGd+iYcL99wd/9U+Sde6NN6S2tuTyC4NzD65ZsSKZ95dW\n", - "4lwwr2GfInSpLCZkZXvS/kaahEbYxjDWrs3HXFHVJH3uleqXyXpWLa0XX0z32pKV6xrgp2EHuddT\n", - "fsHhhplfebmAh62j1Ok+tuagywu/Ob56eqS/+7tky5HnfYz8Sj3A4sRpLK4FNHmqf3naljS5VkeT\n", - "EGabd+8295J0DMZ5nB+pB1iuSvIia+KE4qSEq4LWzWIxm/W4EQOypFTWh6TrRxbrI9yReoDlysXp\n", - "0kvTLkFjaIQLVlrbGOZccuW8KzdjRvIPvbi4H/LsjTeCP4jRqEzUyXXrpNdeSz5fDMQg97fcccfA\n", - "35O6SRYKZvaLS/s2S7K+34KMFezpkZ57rvp6toXZxy4E4C6UIa+uvTbcVCJZPz/T8u53SzfemHYp\n", - "kHoLVhbYvOCmcTG/6aa+l13DDtdu0D/9qXTEEenl79r+KJflG3gS+9V0Hm+8YSadLB83NA4CrCrS\n", - "PoFt5v/Vr0oXX2wvfT+u3mRdLVdYtbYjyTl1Nm+WXnghufxM27kz7RLUZ6POun4epD0WC4iCAMsB\n", - "XCySl8d9nvaXAkn69Kelww9PuxTBle+z116T/uZv7O/HQkH65S/t5pEXeTxP0TgIsKrI+4n9/PPJ\n", - "5ufCzT/vwtRZW8cjjRmoTdm1q/4yfufNxReHf7Huk08O/qxQkLq7w6VjCuene1avTjY/6oB5DRtg\n", - "uVKZXClHoyntdxv7PwvBua0y7pfzK8qECf4vqH/lFTPpb95sJp28qDw/s3BumdLcbCadmTPTC9wb\n", - "XepPEWbhhLE9yL18v2RhfyBfPE9av95MWvvvbyadpEQJsLN+jj72mNTamnYpUI3p+rV0qfTss2bT\n", - "RDA1A6xdu3bp2GOP1fTp03XkkUfq8ssvlyR1d3ertbVVEydO1KxZs7Rly5ZECpskWpbMcvWm5Gq5\n", - "gjJR/scekw47LH46UvwvUS4cDxfKEIRfOTdtkr7whdrr/fKX0pIldsoUVG+v9Pjj6ZYBsK1mgPW2\n", - "t71NDz74oFavXq0//OEPevDBB/Xoo4+qvb1dra2tWrNmjWbOnKn29vZAmfldfF0NZLIwWSSiy8pN\n", - "NAkmx01lrYswi+dbrbq7eLH0ox8FS+ePf4yXVz1HHCFdeKH/3+6/X3r/+6OnHZbnSR//eHL5xeFX\n", - "J7/5zWw84YqB6l4O3/72t0uSdu/erZ6eHo0YMUKLFi1SW1ubJKmtrU0L60yq9OCDff+7dFNz6cLq\n", - "0n6xpbS/XdvWvIzBcmW/+nURZn2G+bwp7eOpU6OtH7SuPfdc3+uP/PiNY6uVV9z63dvbF3xm1Xe/\n", - "G28GfFeuD42mboDV29ur6dOnq6mpSTNmzNDkyZPV1dWlpqYmSVJTU5O6urqqrr9nj/SRj5grcN5U\n", - "u6GEvdEEeQIK+3Ajt8OvBcvli3uWWtVtMhXIhM0PwdneZ41Y720bUm+B/fbbT6tXr9brr7+uj370\n", - "o3qw1Bz1lkKhoELAI8Mgd/+0/Qa5Z2G/wF8jH7usdREivCRvxI34FGG1bYyz7QRP6agbYJUceOCB\n", - "+uQnP6knnnhCTU1N6uzs1OjRo9XR0aFRo0ZVXe/b354nSZo3T9q6tUVSS6wCN6J586SHH+57GiSr\n", - "ShcHTvR8a9QAq5G7hU3q6ZF27Oib8LWWRryO0IJlR7FYVLFaX3ZMNS+Hr7zySv8Tgm+88YYeeOAB\n", - "NTc36+STT9b8+fMlSfPnz9fs2bOrpvHP/zxP0jzNmzdPw4e3DPp7ox7Uavz2x89/vm8cW9a5clNw\n", - "pRxxRd0OW9sfdwxW0rLaqh6Hy8fjyiulAw6ov1yej1FaxyfP+7SWlpYWzZs3r/+fSTVbsDo6OtTW\n", - "1qbe3l719vZq7ty5mjlzppqbm3Xaaafp9ttv17hx47RgwQKjhUqCKxeZQqExKrYr+xt2ZW0MlilJ\n", - "1u+4+9OF41GtDH/+c7DlksS1C1HVDLCmTp2qJ33e6TBy5EgtMTSRigsnkIv27JFWrJCOPTbtkuST\n", - "zYtmeZ1esUK66CJ7eVXLtx5b298IE4364TpmVx6CyrjqbcM//ZN02mnSUUdFS59A0rwGHTERju1B\n", - "7tV+P+44e/maVu/kzMMFLoof/UjautV+Pq7s37gXaVe2o9IjjwxuXcmqLN1Is1TWtH3ve9Jtt6Vd\n", - "CpRL/VU5nEDZ2gfVyurqjTENaR3PLNUjVwS9Jp1wgnT66fbLkxYbT665yOb2LF0qffGL9tK3jeuH\n", - "ebRglWlvl/77v5PNs3J2XtcredQLlMntuvRS6cwz46WRVKtkkjeorL2Sxk+cehJnm9askf7lX6Kv\n", - "n8Z5a+MYBknTRL5xH85w8Tp5663Sv/2bvfRtn7OuXhOyLPUWrLT4leXyy/umREjSeeclm19cLhzD\n", - "H/9Y+slP0i4FXGHixnDzzdL116dbBhOSvJ4ksc2mWtbyMIeUK3UMwSUaYPlVECpNY+0DV7Y1qUHu\n", - "ti/OLrQo1uNyy1oWp2mIWz5XAoa8MVVvsvAe3FdftVeOPKGLMABXu3lckuQgd5M3CFcDoCi4cdqV\n", - "1XMzy0zX6SjHkPNqsHe+U9q4Me1SuM96gFX+6hcGuedX6TgvWSJt21Z9OVeOdx5fSeRqS5HLL3uO\n", - "kp/fvnOlXgfhQlmT7OKLu37QdU3t16w8SPTGG2mXwH3WA6wjjrCdQ/aVn1AuXPxqqVe+1lbpX/+1\n", - "+nquXSTyIokbSBi7d0t795pJ/wMfkNavr79cmq0TjVSvXdhW16+TNriw3xGO9QBr7draf3e1v5nK\n", - "HF2j77tG335Jes97pFNPNZPWihV9/6oxvb+zcvNOu55laZB7HEHrQ9rHA+4J/LJnE7Jy4YLbTNSj\n", - "UhrUSTv7YP36fS1YeZHnG2hWuswbYUZ3VxsdEF5ig9yzULHLlVe2JOcfydp+KqFFMB3sV/Pq7dO0\n", - "x2Dl4SnCpOttEtM02NivP/yhmeCX60Q6Un+K0IWTHfFl7QTOyjf2JNjaB1nYt4zBCs/F7jmbgm6v\n", - "qf1Svs3nny/19ppNH8lJPcBKi6stLi5cUGoJUr60v+GnrZEvhGke50be77bU2qc2WlRcGHOVR0HO\n", - "y0a6Ricl9QAr6W9Df/lLevlXQ8UOJ+15sH75y76n5FziykzVcSdZjbIdrmx70ly4dtlWbRvDHrc4\n", - "LdZJ15G0jmsj1KekJToGy4WLWWdnsOVcKKuL4r5DzJWTOM7xPflkadGi6n/Pw5g6P489NvD37u7a\n", - "MzpnYdvDzM3nWh2OKkzdv/lme+XwE+eJvbFjB7/b1bSeHv/PN2+2m6/EGKwsSv1VOVkIZBppkPsf\n", - "/1j7mFT7WxaOox+br5pJ+1hW8/vfSw8+uO/3oOX80If6gqqS5mZp2jSzZctqPcqrBx5IuwQD1aqr\n", - "mzbZeYVLqU7+/vfSkCrP3Y8aJd17r9n8Ktm+nnDumZfoNA0uSHrAYtbUm7esmiSDxFoXggULpH/4\n", - "h+oXwhKbXQVJvoswisWLo69bvm0vvTT471maNDer/OrujTf23eTjplmZtq13NQYda+VSHXr55dp/\n", - "37EjmXJE4dJ+bCSJtmC5cJBLJ7ALZfGTdrnqXSSili+peac+8xnp8ceDLx+mPEmPDwqbvs3WuKD8\n", - "ypPUK3xM7Wsbx+yKK6Sf/9x8uiUXXCBddJGZtJ58Utq6te/nWnUjS19C89K9a1Pa9548Sn0erLQr\n", - "fNr5m2ByG3btMpeWnzzs73oaYRtdktQg9zj5XHWV1N5e/e833hg97bDqbfPRR/cFhEGWNa0yP1OD\n", - "3LOkcpvDBIdx7rNct8xL/SnCpAVtwUryBHbpYhFlksUgy7h28rq0z02Juk0uHZu0b+hB2NhfF1zg\n", - "RjlKXHtK1q872gULFqRdArgs9S7CtG50YQKJJG9ALt3s/LgwyN1Wl5bpNJOuN0Hzs3ms8hi4muL6\n", - "ue0n7TFYJZUPU+R5stM4g9zjXJ85d81ruBasSi+8kHYJ3Lrwxp2GISuyMB9OUlwPWOO6//5wN568\n", - "Huco0h6DZXqmfRfrZz1ZLnujy/QYrK1bpTfeiLZu6cSdODF6/ja40mVRTdxB7q6xMQbH1PHo7e17\n", - "F5lJccfYzZxpphzV2Bjk/txz0dMMkn5QrpwDYcrhSutNSSMEGUnOkF/OlfqZJ5luwfrbv5Vmzw63\n", - "jisn6Ne/nnYJ/Jk4yVzZx5K0bZu0d2/apQjmG98YOO/Qpk197yKrJeyUEP/jf0i//W31NOr5/e+D\n", - "L+uKsPXRxDhEm+LmX2v9tKZJqNZKk/a+BuLIdIC1Y4f0/PPh1nFlmobrrtv3c3lZ0r6g2Lq51Frv\n", - "pZfsHY/hw6V//ufBn9s8/lH30dVXS9dfbz/foG8ziCLufnW9BTevwjytF2Z/VxssH7dHI+qrcrLM\n", - "9hgsmNewg9zDyMPJWU9SN0a/fblhQ7y860lrnJ2r9abyWMU99mG/5LgkC9efapKY9yzu/nnmmXjr\n", - "V5OFYRGm8mMMVnal/qqcpLlQhko2m/zDpPHkk9Kdd9ZeLuoTLkm+oDntOV/SegI1LVOm1P57UhON\n", - "RknT1Bg8F45zb6/5NJMe5G47mHHhONnk6nyTjSq1Qe6liwEHfqA0v1F/7WvSQw/FTyfsDS3LrQiu\n", - "SPM82rMn/Dpvvin9+7+bLUdS+8DVa9Zf/mIuLVe2Meq1weS+SJor+x7xpdZFuP/+9vNauHDw51Te\n", - "dCTZzJ12wBZ24LltLj6ZtXy59PnPD/581qxky2Eq4HfhONtga7tst7R84hPm003r3hHm2nnLLdHz\n", - "yWsdTlPqg9xtHtRVqwZ/lnaAtXp1+nPLIJmLSZjJP22XI818w+zrzZuj5xP170n53e/MPNGaxHQR\n", - "td4dmmQ3brWnCvMcDMSZaDRsmrAr9UHuWWDygvLUU4M/i7tfTJQvaBmCPKUStjxhtz+tqSTiDOS3\n", - "xcR2BAn4bczNY1qU17uECSBMjMGq153q8ni1JPK3Lc75ktX7F9LjzESjn/2sdNxxyZUjTyeLiYkU\n", - "4z4eneQg97Rk8YaSpqSP+cc+lmx+eVKtbu+Xeh+HP9Nzm7kk7cAZ5jhz+tx/v7RsWdqlSMfWrft+\n", - "jnJTmjrVXFnqceFEdT1Yc2EfhWGrvJXp2j6/n3wyWDni8kvP9Top2W21DStoK2EW9qttJsevPvOM\n", - "tGVL/HQkaeNG6bzzzKSVV3UDrA0bNmjGjBmaPHmypkyZoptuukmS1N3drdbWVk2cOFGzZs3SlgBH\n", - "7eGH4xc4rjy2YGWBqUflTeH4J+/ll/f97EoQ6lo9CLNfdu3qexozLBeGJCA8E2OwJk+W/vf/rr1M\n", - "UPffL91+e/QyNYK6AdbQoUN1ww036Omnn9by5ct1yy236Nlnn1V7e7taW1u1Zs0azZw5U+3t7ZEK\n", - "kNYFztWLhKvlKglyvFzfhnI26l+1b5xx3wNYL88kJp7009sr/eu/xkujXNS3M9jm2jxY06dLJ54Y\n", - "fPksPB1ZbZJNU7JwbbK9z3futJs+9qkbYI0ePVrTp0+XJB1wwAE64ogjtGnTJi1atEhtbW2SpLa2\n", - "Ni30mxOhTFLdEFnNI21pzuRuK68g5QhTnrj5TpgQb31TokyuWW8//fKX5soQpVWm3JIlA4PZLM3L\n", - "FmaS3Jdf7nsq2aaknngOWs+i9kD4pdveLq1cWX/dUl5Zvg9kuexZFmoM1vr167Vq1Sode+yx6urq\n", - "UlNTkySpqalJXV1dkQqQ9IEPeoK6VCGTmlLA5vq1tsH09qUdzFdbbuNGc2Wpl1fSaYSdbNRma1Br\n", - "a/03EtQSZdoHm+fom29Kr75qL/1a0h6DZdPll0vXXptcfkFVm5oi7XtST4/02GPpliFrAgdY27dv\n", - "15w5c3TjjTdq2LBhA/5WKBRUSOlrn2tjKOJKat6ZSja7r8rl7Xi5JM0XvUad38nzzL0rsvw8CfLa\n", - "mIsvlt4aUuoMv3P9wguld77TXB5hpuVI+3y1MSdUWG+8UbssSUl7Hqz77pM+9KH46TSSIUEW2rNn\n", - "j+bMmaO5c+dq9uzZkvparTo7OzV69Gh1dHRo1KhRVdaeJ0n67nclqeWtf+ZEfVy3XoVL+2RK2mmn\n", - "SS0tZtLyOyZJXhDjTqQYV/m2ujAnVr0ns0zsg7ABVinPZcuk448fWMby8vyf/xOtPEGOwaOPRku7\n", - "Xn6m2X4ZelgmtrX8gYdytlvMsjCfWxh79vRNpWHizSj19n2UV2JlQbFYVLFYtJJ23QDL8zyde+65\n", - "OvLII3XBBRf0f37yySdr/vz5uvTSSzV//vz+wGuweZKkK66Qvve9wX91vX/bb2JQm1zdDyVZeALJ\n", - "lX1osxzX87ezAAAgAElEQVQ339w3WPXcc+3lEUati2/5fvjRj6QdO6Tm5r7fd+yone7ZZ9fP2+/m\n", - "Wf7zJZfUTyOItOpuGvmWzvMvfEG66KJg64QRNGhM81zu6Ukn3zAD/SdMkN73Puk//7N2mq5cE13U\n", - "0tKilrLWhSuvvNJY2nW7CJctW6a77rpLDz74oJqbm9Xc3KzFixfrsssu0wMPPKCJEydq6dKluuyy\n", - "yyIVIO6BNzHYsdZyzc3pV84stKZloYzlkhrkbmu/XHKJVH7KLV0afN1qYzxqLVtvPwVtwbrwwuo3\n", - "bJNsnrNJXg/++7/7/iWttI0HHjjwd9PpB/28ks3rzbJlfcHV44/bzXPIEOlf/mXw52H2zYsv9r2C\n", - "CW6q24J13HHHqbfKgIYlS5YYK0jUypt28JOELGxjvS4Zk4PcX3ml9t+THphba7mkjt2jjwYfg2Vj\n", - "/0TtIjQpzuuaqqWTtMpyf+5z9ZcJK8pTpLa5dI077jjpF7+Q3nqGy4jvflc66yzpXe/a91lPj/TE\n", - "E8HTiBOUZu0LcF4EGoOVBFdP5KRP/PITIU8nhcn9WBp0akKYffzFL5rLN6qlS6XOTv9B3GmOwQrL\n", - "xnllKrB16WafFr9uqkJBKhbDtZaaFnUsVdj1THcPfvObffvviisG/+211/qeFB092myeSF/q7yJM\n", - "Yv6lri7p5JMHliPoIPekmsbjLot90v5GZ/O4zZkjnXnmvhcbR8krrXr17W9X/5uJYQ+2AyyT++36\n", - "6/2f3K0XDJsQJ80rrpC+8x1zZaknT18yq5k1SxozZt/vYSdbzdvkz3nizLsIbXYRrlwZfiLEtOYe\n", - "SXqOnbBsTAXgUpeMSbfcEn36AhuqPTlpay6tys/++MfqX3AivghiQD6mugiD5hdn3a1bw3UPJSXK\n", - "+DwT+UTJP6jly+OnYVNnZ7DlbN+LXLrP5EXqAVbSgUzakXyUSpx2mcNKqrzjxknr1g3+PKlvdH/6\n", - "U+3A4qKLpD//OX4+Ut+4s02bBn+e1pNOcQVpqYnzUtqsnTMlSbRgRZHV/Vli60uEDUm0oCIZqQdY\n", - "cWVhlvOoablycS0X9eS3sS0vvij94Q/hy1IuTrkmTZIefDD6+mHMmCGNHTv481tuCZ9Wtf3j99qV\n", - "oF+A/FqR4ryGpqtLGjEi2LK1ypP0uiasXJn8uZ/2NpcE3e4sPhQVNW8TZTZZn66+2lxaeZf6GKyS\n", - "pE6YsGOwkpZUN0dJUpPH1dqW0ja//e3JlKXSm29Gby3xG3Af97jNmCHNnTvws2pPTpY+jxNUln6P\n", - "8w7AsNtcbzbxyhfShm2VtD2I3lYanif9/vd2yxFmXybVw5DWkIwwXPzCG5TJusu0EMGl3oLl6mDj\n", - "qOsuXy699FL1v5ueS2n79vDplbz0kvRXf2WuLCVR952ppwPDzOQu9T0d+IMfmMnbhGJRuvfe5PIL\n", - "crwql6n24uqwU1kE/cKT5NO/Lt1Ibb9pIC1Rn3hNMxAr5Rml1ViK3zrnwnFDOKkHWEnO6RJl+bD+\n", - "/u+lM86o/vegXS1B15kxI1i5/Lz2WvR1KwXdr0lcJMLmsXZt9Lx+8IO+V73EyT+OtC66zz8ffFmT\n", - "rVtB0w+bZ3mAHeUcNcX0cITu7mjrBnkQwsVz2XY6kvSlL5lLy0/YYRhB3rsZRNheHZe+iLgq9QDL\n", - "prRenGxKkAoc5kZnQtSTyuREoyaYqgeLF9d+p53tG0SQb/Qmgt8TTgiWRthv6X5PNnpe/P3m6his\n", - "MGlv3RovvQULpIMOGvx5lC7CpKR5016yRDrvvOp/T6ts9Y7BSy9JjzxSe5m8toS6zpkxWC7nGSSd\n", - "J56Qjjmm/nJpzKK8YYP0kY+YSatk8+bkx4sFlfY3K5f2hVS/26XeeCip/rvjarVwpPFFx9UxWGGU\n", - "XlMTVdDH/8sl9QRb3Hyq1dk5c/bNERc2/dtv7/tny4032kt7/fraf3ftmtQonG/BevTRvhfEmmb6\n", - "Jrx0abB5baIM9o9b1uXLzT3tVip/rYt32Jttnpna3moT35bv16g3JxPHxq/Fo6Nj8GdBylgoxJ/O\n", - "JKs3lHrBsJ84DydUk9Xz9PHHpVdfHfx5lHGGUdKoZfPmaOu9/LKZ/E3ze+oYA6UeYNU7kS++uO+N\n", - "7jbSzoo0u0sqhd2npYtDrbKYPk5Bb+K2hL3RP/JI35QTSXHhQl0ZMEZtDS2fByypACvJ7sd69XTH\n", - "Dultb6u9TNhJlqVgXYSmx4v5ycs1PIzKbZ40KZ1y1HP//WmXwH2pB1hxvzWEvQCkfcKGeVoq7bL6\n", - "CTOT+9at0iGH2C1PVC4EGSUnnCD9z/8ZbNkoT1UlOTg16VdQDRniP5mrS8c3DBMtLZVKrwkridJl\n", - "6/f3z3xG+vKXw5UlrKS6LCV3pu6xsc1hn6yGGbkbg9XTI91zT/W8077whsk/6bIWi2bTK59jK8mT\n", - "N+0LRRpBsudFf7zbRBmj1lW/Qe5hy1PqerE9JjDta0eSghyDe++V7rrLbL62u+lcffjBNhNlz/L2\n", - "pyWVFiyTj/xWXghWrpRmz/b/W1RpV6y0A4Yg6gWxJp5yi1KWtEUtS9D1qu333bulk04KlrbJbqCw\n", - "48BsdTPFeXQ9ze7FKGOwbLL1NGHS56hL14So8rANjSb1LsK4F5AgNwcbA8ejitIMHffEMrmtnOT1\n", - "2WgxrXajq1bHN2+WfvUr/7T2C3HWP/VU8GWDCHrDdqHO257w0W8wtitcP89rHd9LL00+zyzmE5ar\n", - "5XJZ6i1YYZ9gMjWpWlrC3FhsV+gbbgi/TpAyzZ8f7hU8prezVnr33y/dfffAZaLMIG/7nWkm90mc\n", - "tD7xiWDLRZ2Sodo8WNWWS0Jl/rbmmvv0p+vnbWO7g0zLEfRz00xs7513xk/DT1L7IO1jcPrp0g9/\n", - "mF7+eZJ6gOX3Wa3Xv+y/v7Rp077fXZvA0iTbFXr+/PDrBBnkvnlzuu+rqrXfzjpL+uxnBy6zYoXZ\n", - "PGwOwK01w3bUCUXTGB8XtiXXxuDvoEqvBUpiHEux2Peia5vKn7ysxnadCBpEmGpFtNXVmSelff2z\n", - "n0l33JFuWfJiSFIZhanYw4ZJu3ZJf/3X/n/fsmXf02lBbnQunVRRLlxxL3ZRAohqoowNkuyMucE+\n", - "YQK+KMFLnPyDtGrFGeTuWp3q7JRGj/b/26231l73kkvqpx93e6+4Inge9a6hSXWBpy3KpK2mubIv\n", - "EJwzLViVF1VbXYFxJzCMK0xapoKS666Lt34QccbU2P62nHRLZpgxWMuXm8vLBtvBl80HXmypV74x\n", - "YwbP/1YSdnyQK9vUCGrtgylTst8jguSlHmBVCyLCjHG55RZp2zb/v1WmFXbMV9LCPmqe1oUxqZvg\n", - "T34iffOb0fIqcfnm8fd/H2y5JFpjTaRd7/15Ns4/0/vGRNlszK6eJFcfAnrmmWDLmfbqq+Hr1wMP\n", - "9E1lEZbthyuicvWe6bLUnyKMW2k8r+/t5n4VOUrapbFDtipzmIlG8yjs9n3nO9J3v2u+HEHHAkVh\n", - "4kEFzwv2sl+/PCvVm2jU5DxYy5aFW97EPFiVacZVrzusq0vaubN2Gr//vZmypCVoF2EYxx1Xv8W2\n", - "Xj4tLdHyDrIdpq8Fn/qU9MlP1l7G7/U5NsdwxpH3e5MNqYzBCtJFmNcxO1G2JwsD+SvLsXSp9J73\n", - "RFu3FlPdnS6Ozyv32mt93RIl1QLCUlf6rl3VJ30M2n1rqy7VCp5KeW/ZMvAz0+dJGPXynjq1bxbz\n", - "n/60+jqnnOJW3frCF4INbg8rzD4vD76D7puoD27YYKp+bdwojR3b93N3d/D14myjS3WxkaTeRVj5\n", - "WdiKECT4yGrlynL5r7lm4O+mLk5f/3r9ZZIIOoM+6p7UsSsW7XRLBX1BbdBxVlGDuSDLJ3melF5k\n", - "bZupuvyjH0m3315/ubSnCAiabxrlMZHntm3SoYfGT8eGKHM0orbUuwgrhQ20oj4uH6YymTyZw1TS\n", - "LAVWcQa5m5ZEXq4cG1vlWLKk+kBtE2oFWoWCnScdbbLVrWlj4uEwksorCw9rmLB3b/R1096GtPPP\n", - "osS6CMvV6iJ0pf/ZVmWKckGNk14WpPnNyPYYrLCqTXoa53H5KN0sra19Ew6mIc7+e+WV+sts2iQd\n", - "eGD0PBqR6etMWi1TcdK39aU7CYWC228OyKtUXvYcpIuwcpnS0yOV8tZFGGR8mgtc3qdBuu9c3KdS\n", - "31iqKNI+Hia79qPq7ZUOPrj+cmPHSm1t4dOP2loeNU3JjfmXXJT0XG6m8igpH78XVNwxWI8+Gn19\n", - "ROPMGKx6f5s82f+9aGHTSvtGFEaWAkSXApYg+8vmIHeb3/ZNzHCeZqtdZZ02Pdg5qFqzpbt0viX1\n", - "arBqdSTth0Fcuq6Ui7s/rrzSTDlMcKm+540zY7CCnNC7dydXHhfkseLncZtMitpFHGY92+9RrMVG\n", - "S0+UNKOss3Zt+HVslCMJleU68ECz72Sstt22xt5lZT+bWtYGV4Ndl6XeglUvsDLVZ16ZXpjKUu/F\n", - "xb/4RfC08iqJVhIbXAoiaq1bb/LBMGOwwuYRV61ub1uTKsbZlih5Z6W+x2EywIx73KPeJ1wbg1Xt\n", - "IQ8/pu+FYdNNO8DLotTHYFU7UWodzPL5gcqtX++fVtyL34IFtf/+D/9gbgBhmBMuTVFPNhe3JYok\n", - "5+fxvGS6airT/vWvzedhootw3br49SipQds21kuiDvgNTzCZb5Trftqy/ERl+TUkL9fgLHCmi7Ck\n", - "VuWqNffMc89Jhx0WPk3X1Grd85OHkyWN4xN3fJuNAc+SnadIK5cJOst4mC8NQeuoiTFXGzcGzxvR\n", - "uN6qkYWnrV2tl1Gf4MzDvSZpiQVY5a+WCHJz8ry+V4U8/vi+v111VfX1/B5vT3sOmbii3Dxti9q9\n", - "5NqAfVfKUclUwPf009WXrRY4/eIX0qhRZvIP+jc/WT9vw8jSdtkoq43XNkVV73VNaU/TYKvb3PVg\n", - "OssSC7DOPXffz0EvxuXBVb319vPZkrQrxJIl0g03xE8ni98cKrsWbB0LvydLbQz4DrNeraf+pL7Z\n", - "nKuNZ4kaXFSu99GP1k7Tz8MPB5+53aYkzlvTeWTxHA3C1tjKynRLX5CT7GqtlYZfemnfT2yO+0qj\n", - "HI2gboB1zjnnqKmpSVOnTu3/rLu7W62trZo4caJmzZqlLeUvEqsiwCKS7PfFJ9kPfcUV0kUX2c8n\n", - "SdX22wsvpDPw9JvfNJteUHG27Utfkj772XD5VZtWwMT54mJwEObGbnocU5Ljoly5WQVtLbdV3vHj\n", - "wy2f9v5O67jdeWf8h6pcqXONoG6AdfbZZ2vx4sUDPmtvb1dra6vWrFmjmTNnqr29vW5Gb3vbvp/L\n", - "D/CLL/Z9oy+JOu9LVgaH1+PXTO3iCVFZpq98Rbr77mDLZpHJbaj1ZSNsPia6kU1/+6/1tyDnZBJd\n", - "hHmok0mzuc+CfgGPqlrZ/+u/7OZr2llnSeecE23d0j5YuND/c5hXN8A6/vjjNWLEiAGfLVq0SG1v\n", - "TYXc1tamhZVHrI7KA3rFFYP/tmvX4Fmta12c/cZnudjMW4+tp3aS8Kc/Dfw9KwNgTUsyGDCZVxL7\n", - "zcVxhWn63e/Cz++X5P6x3ZMQVeU7/aKmF/ULfZj8gj5UYjJPF9NvRJHGYHV1dampqUmS1NTUpK5a\n", - "0yK/pdYrH8oHqJcO8oc+JH3qUwOXa9QKkHbAUC5q90mt1rigaXZ3B8/PNFtjUVwSZ79FXddvP95y\n", - "S183qk0rV1b/W5RtiVofPvQh6dZbo62btCSuv0GDERtTiJjyf//vwN+nTzeTrivBbqPeh6OI/bLn\n", - "QqGgQs2ryzxJpdaNFkktgb6R//nPcUsW7D2FpqR1w3X1Rl8o+LfGxTk5Dzoo2HKlAeQf/OC+slRT\n", - "OXdaULW2o/ICm7agT3imwW8//vCHgz+zUUaTacap1y69oSLKo/rd3dKwYdLQoXbKZILpsb210vnc\n", - "56Qzz4yfDpJRLBZVLBatpB0pwGpqalJnZ6dGjx6tjo4Ojar5bPe8QZ9UVqp//3ep1AtpssIl2UVo\n", - "8xHmpLqIgogyLizpMs6dOzDfWvl/8Yvm8//3f9/3s4k6aLtbLQtdD7W6ztMY8Pzww9HXddHrr/t/\n", - "HuRp4IMOkr7+denaa+2ULYgkrjFhA/JaYwlNP2x11lnRyhPEzTdL//iP7n6Zj6ulpUUtLS39v19p\n", - "8EWRkboITz75ZM2fP1+SNH/+fM2ePdtYgbIa0ZuqfGnPtWJSlCftXN3mqF2Eti9KroxpSuNLwAMP\n", - "xFv/pZfMlCMPvvGN+svUOo5h96Wr53kttr/8J5l/mHS/8hXpySfNtwI2groB1hlnnKEPfvCD+tOf\n", - "/qRDDz1Ud9xxhy677DI98MADmjhxopYuXarLLrssVKbnn1/9b7YP3k03BVsuSDkWL97XWmKKX75Z\n", - "/+YQJoCy2RJoUpxymixP1EG6fpJ8F2FYfk/XzpoVL82XX463fp5E7aaMOnmlizfpMPU/avn9JsQO\n", - "m2eWemEaXd0uwrurPHu/ZMmSyJnWerdfrYNs4gbwq1/FT6Nk/nzppz/t+zmJwGDmTOk3vzGfTxiV\n", - "21nrMeco3WM2B6jfdVf0iTRNdkPVSssvYIrbSpXEexPz8GRbUunHlcRDHH6fh6nLUcZy2RQkOEni\n", - "uAcdm2WD6/U6jzL1LsLf/tZcPiYG/iZ1kSjtk6VLk8kvjDlz6i8TJqiyeRG47z5zabnSqlhvLIcL\n", - "F1XTY7CQniRfch5GVvJ74YXa6+/YUT8NE9eesNfc8lfdIbhMBViNxuV9YaslKitdhJWefTb4sml9\n", - "e0+L6fwr91/a25cHQVtJg+7rel3XWTxmYXsPorSWHXDAwIm3/dYxse9KPS9BnXji4HKgPmcCrKiz\n", - "ltt4l1zQciR1o3SltUSKP04hjZPTRgtK5e9xX19RLd1qn8VJLy6/qS1sd73k6eGPSmm3Dtxyi/TY\n", - "Y30/16rnJp8cDjk3deL8rnPXX7/vZ5tfIJOYtqN8TsG8nU8uiT0PlilRo/Ooj2ybrlRZbXkJoqtL\n", - "2rpVmjAh2vqeV/uikYWnCG2zeaxNp+03GaRr46JMbXMSN7t//mf7edTiN6nrbbdJH/hA9DTrHa+g\n", - "r8Z5800z+YW9v6R5HSp1I1Zjq1EB5jnTglWSpRts0mOw0vKpT0kTJw78LMgYtvJylybfjNq1+Mgj\n", - "tderV5a4ok7TYPuCXnrIoFqXTNp1x5UyhFFe3qgPReTBddcN/D3McTT5dGselfblqlWD/1Yt+Ix7\n", - "HmXxyc6sy12AZWM+qnJ/+7fSv/3b4M+TfLInadu37/s5SkujiWkaTjgheH5B04wjaJqV79OMkm75\n", - "i9KrcfnbqekuQiSn/Ng9+6ydQe4ujde0nfdrr8XPM+3eF1fuS1mQuwDLz6OPmitHR0e0WZyPPNL/\n", - "20oQLt5c4k4dULJ6db67CJ97bvBnST4qHmZgsi3l+ceZB6jExfMhSUGO52OPSRdcED+v8ll6rrjC\n", - "3CB3E0x8cUtaabxdrfKkVb9XrRr4ZRrxOTMGq8RGM6jfKxySHnj77LN9gd6BB0ZL3xVRylS+b+o9\n", - "hmxrLNvRR/fNRlxS7UmdaqJ2ESYl7RtIkmOwoo67jJJXVkX9MlfpiSeiredqC1bQdQqF2sMSbHbX\n", - "Jf3u0FJZLr1UeuUVs2k3uty1YCV5cQz7ZNNXvhItnzQv+OVBiRT/wlmv9c/Gtq5bN3g70lTrAhl1\n", - "+2vNg2X6gnzRRf75VJOHgCXP9t/ffJpJBFg2eV5fwFFNT09yZSmx1UVYLsgrj1w8Xq4iwKrChRaK\n", - "tCvy66/3tfzEFab53sY2r1wZPw2TrSY2gpEk68rateGWN91a7MK5WU3a52xcpsqfdBdh0uI+/BCl\n", - "BSuJ7f3Zz/r+r3XNdPn8c03uAixTJ3aQclRrwTJdAdOq0LX2pakxWCbWQXWujcFyMT0TXCxTUGFa\n", - "Y1wd5B70S9zll0fLK0lpdRFWqvaATpbretJyF2AFWX/jxvBPd6XB5W8Kf/rT4M/Ky7t7t/Sud/X9\n", - "nPXuAj+1js3UqdHXzcr2V3Kti9BWC6PNdbPAxiD3JFtt77gjWl4m8g66/n5V7spJdBGWc/n+kxUN\n", - "GWAdemjt/vWgkppd2sWL9ty5gz8rL2fQCQIr14s6mPyll/omQ7UlTBeh374Jum5U5WmWT45pYwyW\n", - "a/z2Z163edUqM09impal1xcl9b6/Wvz2T+kzV+vuxRf3/e/ysXVNQwZYUrw+9P/+b+ljH6tfhrhP\n", - "3LlWkR9/PNp6SWzH3/2d1NZmP58g0j5uixYFX3bdOjN5utaCldZNyva2vve90g032M2jlqDjgypb\n", - "sG69tXqaF14YrSxRp2n44hfDpZ2UtKaaqJZu5efVxl7a/GKbdbkLsMpP7N7eaHNg1bNtm3T//QM/\n", - "q/WNJIzydfbu7ZvV15VvNLNn288jzvEvf7+WaWFa1uptg9+6Ud/F6Zdm5Y2nVprvfrfU3h4tz6BM\n", - "3BjCppHnF2pnYXhD5f74X/+r+rK33BItj//3/6Kt95e/RFuvnCsPY9lUrYyV59brr9svS1blLsAq\n", - "X/+hh6Tjj7eTj2SnizDMN7+siPMUYRYuRJXifBONur0bNkRbT+o7T8qZvoFnrQUrSnnffLNvMuEs\n", - "1lcbktgPL75oL+00vtTWG7eWdguW7XLkUeYDrMoujsoWoKTYHAdSmXbSs+0GPSbf/nZyeSGYKGOw\n", - "onTZRD1uH/94sOVK21AoDH4Bswt1ZsuWvsmEs85UN1V5sJDE9cqFOhCGX3nDdO2b8rvfScuX+/8t\n", - "a/vURbmbyT3Jl4xWu3HF6e6pt84DD0izZiVT+U09tWL7KcI//jH8OmEl9SSkCxe1zk6z6Znepj17\n", - "6i+T1zFYrqo1yP0f/9FOnmk+nWzjmlgay5Rky9H73lf9b0FfIO/KEBYXZb4Fy/T6YSTRRViZz8sv\n", - "m8kniKQeC447sL/etAhJcynAcuGGn+UxWEHzTXI/B8nL1k0vyiD3jg47ZUnzyW0b96mkrrdBuVKO\n", - "LHMmwCq9ZdyVAMv0GK2g/AKsp56KX5YoshJgJSHM2DBXt8Em1/ZH0gFW1OXzqnw/2BqUn+a+thlg\n", - "BW05so0xWPE5E2CVuNJFGCSdWk9uVX4WlEuVt7QPbAe95fvape3Pg7zsz0Ih3HllapB7XvZf0sr3\n", - "W7UxPrbyi/L3SvXqTxoBVklSXXJBt5EuwupyF2C51IKVpXwrvfpqci1Y5a/qcGX76zE9G7tr3QNh\n", - "JdGClcY+CttFmNXjF1S17as8H1x7F6Hp4xJ3+2qtn8TThEHSCHqsly+Xhg6NX6Y8atgAK0yrStT0\n", - "4k406qdy/i1bnnvO/6Zho1UuCy1Yrgxyd7XLKokAq1qLqqlzDwPFqfNJPoQThOmAL40xWK52ET7x\n", - "RLJP7GcJAVaMdGw0I9e7ECxe3Pf/li3S8OHh0w8jqW/lWQiwwkhz8K2pdUwy3YIVtvveRJ5Bl0t7\n", - "X8dVr/xB92vSLVhJfGEO8/co6Sc5BivIcTzttGBpZb3O29Sw0zTUq2B+LzOupbzclWmfcEK0dPzs\n", - "v3/f/x0dfTPK2+R3wttolctCF6ELLUFRyuHq/oyiVA9tB1hRWmzDBH9xJXVMk56s1abKyXTjinuc\n", - "o7Rgff3r8fIM6ze/8f88jdbKrKIFq4ogL4OuN01D6e+PPBKsTEHKVR6M2JZGC1alpLt6nn9eWr++\n", - "/nK19omJV3FEybeaJPah7S5Cz3N7DFaY4C+PXB+D9YUvhEs7zUHuWdOodT6I3LVgJVlJbcyDZbqp\n", - "u1z5k1hhymL7mLjURThhgvSOd+ybNqSaO+/0//zRR6O/W00yv/1p70+TZUhjDFbQspe++NSrN1ln\n", - "6gusCXHHhsZhswUra7Ja7iTkrgUryWi6Vlkvv1x64QWzaQb5e9z0/Za1fSFzrYvQb96eynJ1dfmv\n", - "G/WF00EDAhf2j5+wLVhnnx0u/fIvB66c4+VKg3zf9S57ZXGZ64Pcy5mYl6teHdy6tfYbB9IOsEzm\n", - "5eo1yQXOtWB94xvx1k/yG1Z5Gj/84cC/tbdHS7PeiRu3i3Dt2vBlaaQWrLjitpw0yhisIN2wlcJ0\n", - "w8XZ7ihfKBrlKSqXBrlHVSxG+/Jbrt72nX9+7b+nHWCZPD4uH+u0OdeCVXpKLioXvgWYurj7iVuZ\n", - "wwRofi1YNsbzZCHASuobuokAK2rZ0tqmsOm4cI5L0osv7vu5UQKsamq9izCKiy+WVq+uvUycPLZs\n", - "ib5ukLzrdRWnfZ2Lcx9hkHtwzrVgxZVkNG0jr3ppxs0zTIBkqksmqacIOdEH87zo3ZZh84nytzCS\n", - "asEKms5RR+37OcgLqE2xWc+TfBNGLf/yL9Kbb9ZeJs0xWDZa9ZMM0k3eu7juVudcC1ZcLozPMNnK\n", - "U+3bwhtvmMujXt5JPkXoanNz5T4I+tLbuPlESb+ybJdfHr08JthuwbJZP2ulXT5NSl5asOpth6uD\n", - "3E2rtx9szOT+1a/GSzNu/i6klTeZDbC2bvX/POib202cnGm0YJVaey65xHzelUwNcg/T7RnnRhVm\n", - "Oox6LrlE+v73zaVnis0xWK5/E63WgmV6PMuOHcHSKf+bX72tdo1ymalA0cS1Mc3Z+D/zmdp/Lz/2\n", - "UaZlKa9jSaisx7RgJSNWgLV48WJNmjRJEyZM0DXXXGOqTIEceKD/50lOxlatYr3+ejFympUVv9r8\n", - "MtWeYqsnzDfQygDr5ZfrNdsXI5WpvItw9+5ISRh37bW1H1QYeFyKxvLN1sWq2P+Ta12EcXR27vvZ\n", - "v+zFQZ/4BSaf/rSpEoUXdZ/X7uosOvW0a3JdhMVBn5TXwYsuspm3HcHOoaLvp4zBCi5ygNXT06Mv\n", - "felLWrx4sZ555hndfffdevbZZ02WzXnVKmmcACtoF1HUpwnjDnKvfWIWa6YTpExJjmWpxu8mUnsb\n", - "ipZKMphbLVjFQEvNmRM2XX9hugjjXPTrz29XHPSJX4C1cWP0MqSlXoC1bFmwdLLeRThQsWbeWQww\n", - "gp3wnLAAAB85SURBVAZYQbaNLsLqIgdYK1eu1OGHH65x48Zp6NChOv3003XPPfeYLJtVJiqFjYoV\n", - "9GSNmnfcACuKMF2ELgRYaTI9TUNSkihXUi1YUR668AuwsnjjcamL0Oa5ELe+ZvHYlgtafptPLTeC\n", - "yE8Rbtq0SYceemj/72PHjtWKFSuMFMqUWt1Ntbq6qj3CW/l5tTRqBQn1+t4rB69XWz5IH/7OnYM/\n", - "CzrT9LZt0l//dd/P9Z7mqade7/H27ft+7u4euJ/j5B31UexSnrt27Uvj9df9l6lUvi3VyuQ30WHp\n", - "uNfb3iA3wPK6EWYflM4Xv3pTz549/nnFfRy+ZPv2fcegsu77nQs7d/bV9aefDl+W8rFTQcdR+b0X\n", - "9PXXzW2/tC+tIOdE0DE+leUrf+I0yIScpWV27hyYlonxZ/Xq4fbt1c/PesqXL6UR5sGh8uPtV84w\n", - "2x/2Gld+XfLj97dt2wZem7ZuDVY3/Zap3E+l3z0v3XFzLip4XrT48+c//7kWL16s2267TZJ01113\n", - "acWKFbr55pv7lzn88MP1QtwZ3QAAABIwfvx4Pf/880bSityCdcghh2jDhg39v2/YsEFjx44dsIyp\n", - "QgIAAGRJ5DFYxxxzjP785z9r/fr12r17t372s5/p5JNPNlk2AACATIrcgjVkyBD94Ac/0Ec/+lH1\n", - "9PTo3HPP1RFHHGGybAAAAJkUeQwWAAAA/FmZyT3NCUiTMG7cOB111FFqbm7W+9//fklSd3e3Wltb\n", - "NXHiRM2aNUtbyh6/uPrqqzVhwgRNmjRJv/71r9MqdmjnnHOOmpqaNHXq1P7PomznE088oalTp2rC\n", - "hAn6apLvg4jIb7vnzZunsWPHqrm5Wc3Nzbrvvvv6/5aX7d6wYYNmzJihyZMna8qUKbrpppsk5f+Y\n", - "V9vuvB/zXbt26dhjj9X06dN15JFH6vK33qmU9+NdbbvzfrxLenp61NzcrJNOOklS/o93SeV2J3K8\n", - "PcP27t3rjR8/3lu3bp23e/dub9q0ad4zzzxjOptUjRs3znv11VcHfHbxxRd711xzjed5ntfe3u5d\n", - "eumlnud53tNPP+1NmzbN2717t7du3Tpv/PjxXk9PT+JljuLhhx/2nnzySW/KlCn9n4XZzt7eXs/z\n", - "PO9973uft2LFCs/zPO/jH/+4d9999yW8JeH4bfe8efO86667btCyedrujo4Ob9WqVZ7ned62bdu8\n", - "iRMnes8880zuj3m17W6EY75jxw7P8zxvz5493rHHHus98sgjuT/enue/3Y1wvD3P86677jrvs5/9\n", - "rHfSSSd5ntcY13TPG7zdSRxv4y1YWZ+ANCivomd10aJFamtrkyS1tbVp4cKFkqR77rlHZ5xxhoYO\n", - "Hapx48bp8MMP18qVKxMvbxTHH3+8RowYMeCzMNu5YsUKdXR0aNu2bf0tfWeddVb/Oq7y225p8DGX\n", - "8rXdo0eP1vTp0yVJBxxwgI444ght2rQp98e82nZL+T/mb3/72yVJu3fvVk9Pj0aMGJH74y35b7eU\n", - "/+O9ceNG3XvvvTrvvPP6t7URjrffdnueZ/14Gw+w/CYgLV2s8qJQKOjEE0/UMccc0z8PWFdXl5qa\n", - "miRJTU1N6nrrZYEvv/zygOkrsr4/wm5n5eeHHHJIZrf/5ptv1rRp03Tuuef2N6PndbvXr1+vVatW\n", - "6dhjj22oY17a7g984AOS8n/Me3t7NX36dDU1NfV3kzbC8fbbbin/x/vCCy/Utddeq/3223frb4Tj\n", - "7bfdhULB+vE2HmAVGmAq12XLlmnVqlW67777dMstt+iRRx4Z8PdCoVBzP+RlH9Xbzjw5//zztW7d\n", - "Oq1evVpjxozR1772tbSLZM327ds1Z84c3XjjjRo2bNiAv+X5mG/fvl2nnnqqbrzxRh1wwAENccz3\n", - "228/rV69Whs3btTDDz+sBx98cMDf83q8K7e7WCzm/nj/6le/0qhRo9Tc3OzbciPl83hX2+4kjrfx\n", - "ACvIBKRZN2bMGEnSwQcfrFNOOUUrV65UU1OTOjs7JUkdHR0aNWqUpMH7Y+PGjTrkkEOSL7QhYbZz\n", - "7NixOuSQQ7Sx7K23Wd3+UaNG9V98zjvvvP5u3rxt9549ezRnzhzNnTtXs2fPltQYx7y03Z/73Of6\n", - "t7tRjrkkHXjggfrkJz+pJ554oiGOd0lpu3/3u9/l/ng/9thjWrRokQ477DCdccYZWrp0qebOnZv7\n", - "4+233WeddVYyx9vI6LEye/bs8d797nd769at8958883cDXLfsWOHt3XrVs/zPG/79u3eBz/4Qe/+\n", - "++/3Lr74Yq+9vd3zPM+7+uqrBw0UfPPNN721a9d67373u/sHzGXBunXrBg1yD7ud73//+73ly5d7\n", - "vb29mRkQWbndL7/8cv/P119/vXfGGWd4npev7e7t7fXmzp3rXXDBBQM+z/sxr7bdeT/mmzdv9l57\n", - "7TXP8zxv586d3vHHH+8tWbIk98e72nZ3dHT0L5PH412uWCx6n/rUpzzPy//5Xa58u5M4v40HWJ7n\n", - "effee683ceJEb/z48d5VV11lI4vUrF271ps2bZo3bdo0b/Lkyf3b9+qrr3ozZ870JkyY4LW2tvaf\n", - "wJ7ned/73ve88ePHe+95z3u8xYsXp1X00E4//XRvzJgx3tChQ72xY8d6P/7xjyNt5+9+9ztvypQp\n", - "3vjx470vf/nLaWxKKJXbffvtt3tz5871pk6d6h111FHepz/9aa+zs7N/+bxs9yOPPOIVCgVv2rRp\n", - "3vTp073p06d79913X+6Pud9233vvvbk/5n/4wx+85uZmb9q0ad7UqVO973//+57nRbuW5WG78368\n", - "yxWLxf6n6fJ+vMs9+OCD/dv9uc99zvrxZqJRAAAAw6xMNAoAANDICLAAAAAMI8ACAAAwjAALAADA\n", - "MAIsAAAAwwiwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsAAAAAwjwAIAADCMAAsAAMAwAiwAAADD\n", - "CLAAAAAMI8ACAAAwjAALAADAMAIsAAAAwwiwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsAAAAAwj\n", - "wAIAADCMAAsAAMAwAiwAAADDCLAAAAAMI8ACAAAwjAALAADAMAIsAAAAwwiwAAAADCPAAgAAMIwA\n", - "CwAAwDACLAAAAMPqBlgbNmzQjBkzNHnyZE2ZMkU33XSTJGnevHkaO3asmpub1dzcrMWLF1svLAAA\n", - "QBYUPM/zai3Q2dmpzs5OTZ8+Xdu3b9fRRx+thQsXasGCBRo2bJguuuiipMoKAACQCUPqLTB69GiN\n", - "Hj1aknTAAQfoiCOO0KZNmyRJdWIzAACAhhRqDNb69eu1atUqfeADH5Ak3XzzzZo2bZrOPfdcbdmy\n", - "xUoBAQAAMscLaNu2bd7RRx/t/eIXv/A8z/O6urq83t5er7e317viiiu8c845Z9A648eP9yTxj3/8\n", - "4x//+Mc//jn/b/z48UHDoroCBVi7d+/2Zs2a5d1www2+f1+3bp03ZcqUwYlrcPJ9G+H5/Asc66GG\n", - "b33rW2kXoeGwz5PHPk8e+zx57PPkmYxF6nYRep6nc889V0ceeaQuuOCC/s87Ojr6f/7FL36hqVOn\n", - "1ksKAACgIdQd5L5s2TLdddddOuqoo9Tc3CxJuuqqq3T33Xdr9erVKhQKOuyww3TrrbdaLywAAEAW\n", - "1A2wjjvuOPX29g76/OMf/7iVAiGelpaWtIvQcNjnyWOfJ499njz2ebbVnQcrVuKFwqCpHAqFgvrG\n", - "kg1ammkfAABAavzilqh4VQ4AAIBhBFgAAACGEWABAAAYRoAFAABgGAEWAACAYQRYAAAAhhFgAQAA\n", - "GEaABQAAYBgBFgAAgGEEWAAAAIYRYAEAABhGgAUAAGAYARYAAIBhBFgAAACGEWABAAAYRoAFAABg\n", - "GAEWAACAYQRYAAAAhhFgAQAAGEaABQAAYBgBFgAAgGEEWAAAAIYRYAEAABhGgAUAAGAYARYAAIBh\n", - "BFgAAACGEWABAAAYRoAFAABgGAEWAACAYQRYAAAAhhFgAQAAGEaABQAAYBgBFgAAgGEEWAAAAIYR\n", - "YAEAABhGgCVp+PCRKhQKA/4NHz4y0HJhlvVbDgAA5E/B8zzPWuKFgiqTLxQKkvyyHLxsUvzLFK/s\n", - "QdMEAABu8ItboqIFCwAAwDACLAAAAMMIsAAAAAyrG2Bt2LBBM2bM0OTJkzVlyhTddNNNkqTu7m61\n", - "trZq4sSJmjVrlrZs2WK9sAAAAFlQd5B7Z2enOjs7NX36dG3fvl1HH320Fi5cqDvuuEPvfOc7dckl\n", - "l+iaa67Ra6+9pvb29oGJM8i97nIAAMANiQ5yHz16tKZPny5JOuCAA3TEEUdo06ZNWrRokdra2iRJ\n", - "bW1tWrhwoZECAQAAZF2oMVjr16/XqlWrdOyxx6qrq0tNTU2SpKamJnV1dVkpIAAAQNYEDrC2b9+u\n", - "OXPm6MYbb9SwYcMG/K00kSYAAACkIUEW2rNnj+bMmaO5c+dq9uzZkvparTo7OzV69Gh1dHRo1KhR\n", - "vuvOmzev/+eWlpbYBU7OEILGiIYPH6lt214b8NmwYSO0dWt3SiUCAGCwYrGoYrFoJe26g9w9z1Nb\n", - "W5sOOugg3XDDDf2fX3LJJTrooIN06aWXqr29XVu2bMndIPdgn/V9ziD3fRp52wEA2WVykHvdAOvR\n", - "Rx/VCSecoKOOOqq/Refqq6/W+9//fp122ml66aWXNG7cOC1YsEDveMc76haUACv/QUYjbzsAILsS\n", - "DbBiJU6AVXe5PGrkbQcAZBfvIgQAAHAYARYAAIBhBFgAAACGEWABAAAYRoAFAABgGAEWAACAYQ4F\n", - "WEP6X7lT+jd8+Mi0CwUAABBaoFflJGOvKudO2raNV9UAAIDscagFCwAAIB8IsAAAAAwjwAIAADCM\n", - "AAsAAMAwAiwAAADDCLAAAAAMI8ACAAAwjAALAADAsMwFWMOHj8zVjO9xtydv+wMAgDwoeJ7n1V8s\n", - "YuKFgiqTLxQKqpyx/a2/+HwedP3By4Utp1+awT6LV86422Njf8TlYpkAAKjHL26JKnMtWAAAAK4j\n", - "wAIAADCMAAsAAMAwAiwAAADDCLAAAAAMI8ACAAAwjAALAADAMAIsAAAAw3IbYPnNcM4s54MxEzwA\n", - "AObldib3WvkETbMRZnJPcmZ8ZnIHALiMmdwBAAAcRoAFAABgGAEWAACAYQRYAAAAhhFgAQAAGEaA\n", - "BQAAYBgBFgAAgGEEWAAAAIYNSbsAtQ15a9JKU8ulLSvlBAAAcTgeYO2V/2zqUZdLW1bKCQAA4qCL\n", - "EAAAwDACLAAAAMMIsAAAAAwjwAIAADCsboB1zjnnqKmpSVOnTu3/bN68eRo7dqyam5vV3NysxYsX\n", - "Wy0kAABAltQNsM4+++xBAVShUNBFF12kVatWadWqVfrYxz5mrYAAAABZUzfAOv744zVixIhBn3te\n", - "5XQDAAAAkGKMwbr55ps1bdo0nXvuudqyZYvJMgEAAGRapADr/PPP17p167R69WqNGTNGX/va10yX\n", - "CwAAILMizeQ+atSo/p/PO+88nXTSSVWXnTdvXv/PLS0tUbJDTg0fPlLbtr024LNhw0Zo69buRNYH\n", - "ADS2YrGoYrFoJe2CF2Aw1fr163XSSSfpqaeekiR1dHRozJgxkqQbbrhBjz/+uH7yk58MTrxQGDRW\n", - "q+9dfH5Z+n1u+rO+z4OVKc00B6dXTbV8klo/Tpoulh0A0Lj84pao6rZgnXHGGXrooYf0yiuv6NBD\n", - "D9WVV16pYrGo1atXq1Ao6LDDDtOtt95qpDAAAAB5EKgFK3LitGBFLjstWObyAQAgCJMtWMzkDgAA\n", - "YBgBFgAAgGEEWAAAAIYRYAEAABhGgAUAAGAYARYAAIBhkWZyh+uGvDWFQbmhkvakURgAABoOAVYu\n", - "7VWYObwAAIBZdBECAAAYRoAFAABgGAEWAACAYQRYAAAAhhFgAQAAGEaABQAAYBgBFgAAgGHW58Fq\n", - "azvfdhYAAABOsR5g/cd/HFX22wbb2QXgN8u5a2lWSy/Ls7Hb2O8AALip4Hme3/TeZhIvVM4evkrS\n", - "e1V9RvEgs4/H+SwraaZf9jjVYvBxD1Om4HlXy8dilQYA5FihYO4ewhgsAAAAwwiwAAAADCPAAgAA\n", - "MIwACwAAwDACLAAAAMMIsAAAAAwjwAIAADCMAAsAAMAwAiygzPDhI1UoFAb8Gz58ZNrFAgBkjPVX\n", - "5QBZsm3ba6qcHX7bNl7xAwAIhxYsAAAAwwiwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsAAAAAwj\n", - "wAIAADCMAAsAAMAwAiygriHM7g4ACIWZ3IG69orZ3QEAYdCCBQAAYBgBFgAAgGEEWAAAAIYRYAEA\n", - "ABhWN8A655xz1NTUpKlTp/Z/1t3drdbWVk2cOFGzZs3Sli1brBYSAAAgS+oGWGeffbYWL1484LP2\n", - "9na1trZqzZo1mjlzptrb260VEAAAIGvqBljHH3+8RowYMeCzRYsWqa2tTZLU1tamhQsX2ikdAABA\n", - "BkUag9XV1aWmpiZJUlNTk7q6uowWCgAAIMtiTzRamtm6unllPx8SNzskYsigYzps2Aht3dqdUnnC\n", - "GFx2aaikPQM+ib895vfR8OEjtW3ba0bTBABUVywWVSwWraRd8DzPq7fQ+vXrddJJJ+mpp56SJE2a\n", - "NEnFYlGjR49WR0eHZsyYoeeee25w4oWCBs6AvUrSe1U5K/ZbS/t8bvqzrKTpZtkDVJW+JQcd9+zk\n", - "k1TZ/VTLO06aAIDgCgVz19xIXYQnn3yy5s+fL0maP3++Zs+ebaQwAAAAeVC3BeuMM87QQw89pFde\n", - "eUVNTU369re/rU9/+tM67bTT9NJLL2ncuHFasGCB3vGOdwxOnBYsx/MJtz4tWNHSDIoWLABIl8kW\n", - "rEBdhJETJ8ByPJ9w6xNgRUszKAIsAEhX6l2EAAAAqI4ACwAAwDACLAAAAMMIsAAAAAwjwAIAADCM\n", - "AAvOGz58ZP8bA8r/xTPEQpqAPX7nwfDhI9MuFoAqYr8qB7Ct7/Ux1aaYiGqvhTQBe/zOg23bqK+A\n", - "q2jBAgAAMIwACwAAwDACLAAAAMMIsAAAAAwjwAIAADCMAAsAAMAwAiwAAADDCLAAAAAMI8ACAAAw\n", - "jAALAQ1+tQyv6QiGV5y4g2MBICm8KgcBDX61DK/pCIZXnLiDYwEgKbRgAQAAGEaABQAAYBgBFgAA\n", - "gGEEWAAAAIYRYAEAABhGgAUAAGAYARYAAIBhBFgAAACGEWAhhsGzuxcKcSdtHJwmBvKbjbzajORB\n", - "Zy4PkyYAoD5mckcMg2d37xMnKPJLkyCrnN9s5H2fD95PQWcuD5MmAKA+WrAAAAAMI8ACAAAwjAAL\n", - "AADAMAIsAAAAwwiwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsABkGrPQA3ARM7kDyDRmoQfgIlqw\n", - "AAAADCPAAgAAMIwACwAAwLBYY7DGjRun4cOHa//999fQoUO1cuVKU+UCAADIrFgBVqFQULFY1MiR\n", - "PK0DAABQEruL0PMGP70DAADQyGIFWIVCQSeeeKKOOeYY3XbbbabKBAAAkGmxugiXLVumMWPGaPPm\n", - "zWptbdWkSZN0/PHHmyobAABAJsUKsMaMGSNJOvjgg3XKKado5cqVPgHWvLKfD4mTHeC4ISoUsjC5\n", - "ZXrlHD585FsTg1YaKmnPgE+GDRuhrVu7EylXEvy2PW/bCGRNsVhUsVi0knbBiziIaufOnerp6dGw\n", - "YcO0Y8cOzZo1S9/61rc0a9asfYkXCho4w/IqSe+V36zLUuWyNj7LSppZLruNNLNc9urLVp56g8+X\n", - "MMuFSzNM2U2Os6xV9iDbHjbNqPvYhrh5p1l2oFEUCubOqcgtWF1dXTrllFMkSXv37tWZZ545ILgC\n", - "AABoVJEDrMMOO0yrV682WRYAAIBcYCZ3AAAAwwiwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsAAA\n", - "AAwjwAKc1jfrevk/2Dd8+MhB+71QKGj48JEBl/2rhI7b4PrhV0YAyYv1qhwAtu2V/6zrsKnvlTaD\n", - "Z3Petm3wvvdfttps+aYNrh9+ZQSQPFqwAAAADCPAAgAAMIwACwAAwDACLAAAAMMIsAAAAAwjwAIA\n", - "ADCMAAsAAMAwAiwAAADDCLCA3Ehv1ne/2czTn1E8C7PgDy5jsjPBm+dmXQCSx0zuQG6kN+u732zm\n", - "6c8onoVZ8P3KKCU3E7x5btYFIHm0YAEAABhGgAUAAGAYARYAAIBhBFgAAACGEWABAAAYRoAFAABg\n", - "GAEWAACAYQRYAAAAhhFgAQAAGEaABaQiC69xkfzKGfy1J3G30e81MjZeIROmnFk4bv6v3/E7bkFf\n", - "axP/9Tdx6lG6knr1D68Yyp+C53l+72kwk3ih8nUPqyS9V+FeDWHys6ykmeWy20gzy2W3kWb6Za+8\n", - "bAw+183kk/80ky170OMWdblaywZd3zVhtj0L+aC2QsHcPqcFCwAAwDACLAAAAMMIsAAAAAwjwAIA\n", - "ADCMAAsAAMAwAiwAAADDCLAAAAAMI8ACAAAwjAALQEhZmM0cg5k+bv4zxsdZv9rM5WnOph5n3Wpv\n", - "H2iEmeDT3h8uYCZ3J9PMctltpJnlsttIk7LnJ003yx59pv645Qw3O3xSs6lH30dx1w++ja7NBB93\n", - "f6SFmdwBAAAcRoAFAABgGAEWAACAYbECrMWLF2vSpEmaMGGCrrnmGlNlAgAAyLTIAVZPT4++9KUv\n", - "afHixXrmmWd0991369lnnzVZNkRSTLsADaiYdgEaUDHtAjSgYtoFADIlcoC1cuVKHX744Ro3bpyG\n", - "Dh2q008/Xffcc4/JsiGSYtoFaEDFtAvQgIppF6ABFdMuAJApkQOsTZs26dBDD+3/fezYsdq0aZOR\n", - "QgEAAGTZkKgrBp2Abfjwk/p/7u19Xdu3R80RAAAgGyIHWIcccog2bNjQ//uGDRs0duzYAcuMHz9e\n", - "L7zwK5+1qwVnfp+b/iwraWa57DbSdL3sV1pIM+xnWUnTVD5X1lkubpmytj/Mpen/BfpKDdzn8fMJ\n", - "nvf/b+cOXpr+4ziOvyYKQYQn/WoscEhON+f2jaXnXEuoZg095MGDShcv6tF/QKUOsWinIBAP1TUi\n", - "I8tJpqjQNoYiGDRhggqag5pKqe8OP9gPqd+Pys9n+/309bjt+xW/H58D92bb9/O7P3sUR1nnUdd+\n", - "1L8xV41+Vb6fy99XWVmp7Hf98U7ue3t7sNvtePPmDc6ePYv6+no8fvwYNTU1yhZHRERE9H/0x+9g\n", - "FRYW4sGDB2hqasL+/j66uro4XBERERHhCO9gEREREdHPadnJnRuQ6tfZ2QnDMOByubLHPn36BL/f\n", - "j6qqKly5cgXpdDqPKzx+UqkULl26BKfTidraWty/fx8Au+u0u7uLhoYGeDweOBwO9Pf3A2DzXNjf\n", - "34dpmggE/rpRic31qqioQF1dHUzTRH19PQA21y2dTqO1tRU1NTVwOByYnZ1V2lz5gMUNSHOjo6MD\n", - "L1++PHRsaGgIfr8fS0tL8Pl8GBoaytPqjqeioiLcu3cPCwsLmJmZQTgcxuLiIrtrdOrUKUQiEcTj\n", - "cSQSCUQiEbx7947NcyAUCsHhcGS/fMzmelksFkxMTCAWi2Fubg4Am+vW09ODq1evYnFxEYlEAtXV\n", - "1Wqbi2LT09PS1NSUfTw4OCiDg4OqL0Mikkwmpba2NvvYbrfL2tqaiIisrq6K3W7P19JOhBs3bsjY\n", - "2Bi750gmkxGv1yvz8/NsrlkqlRKfzyfj4+Ny/fp1EeH/F90qKipkY2Pj0DE21yedTovNZvvhuMrm\n", - "yt/B4gak+bO+vg7DMAAAhmFgfX09zys6vpaXlxGLxdDQ0MDumh0cHMDj8cAwjOxHtGyuV19fH+7e\n", - "vYuCgr9fIthcL4vFgsuXL8Pr9eLhw4cA2FynZDKJkpISdHR04MKFC7h9+zYymYzS5soHrP/KXhYn\n", - "ncVi4XOhyZcvX9DS0oJQKIQzZ84cOsfu6hUUFCAej2NlZQVv375FJBI5dJ7N1Xr+/DlKS0thmibk\n", - "H+6BYnP1pqamEIvFMDo6inA4jMnJyUPn2Vytvb09RKNRdHd3IxqN4vTp0z98HHjU5soHrF/ZgJT0\n", - "MAwDa2trAIDV1VWUlpbmeUXHz7dv39DS0oL29nbcvHkTALvnSnFxMa5du4b379+zuUbT09N49uwZ\n", - "bDYb2traMD4+jvb2djbXrLy8HABQUlKCYDCIubk5NtfIarXCarXi4sWLAIDW1lZEo1GUlZUpa658\n", - "wPJ6vfjw4QOWl5fx9etXPH36FM3NzaovQz/R3NyM4eFhAMDw8HB2ACA1RARdXV1wOBzo7e3NHmd3\n", - "fTY2NrJ38ezs7GBsbAymabK5RgMDA0ilUkgmk3jy5AkaGxsxMjLC5hptb2/j8+fPAIBMJoNXr17B\n", - "5XKxuUZlZWU4d+4clpaWAACvX7+G0+lEIBBQ1/yPv731L168eCFVVVVSWVkpAwMDOi5x4t26dUvK\n", - "y8ulqKhIrFarPHr0SDY3N8Xn88n58+fF7/fL1tZWvpd5rExOTorFYhG32y0ej0c8Ho+Mjo6yu0aJ\n", - "REJM0xS32y0ul0vu3LkjIsLmOTIxMSGBQEBE2Fynjx8/itvtFrfbLU6nM/u6yeZ6xeNx8Xq9UldX\n", - "J8FgUNLptNLm3GiUiIiISDEtG40SERERnWQcsIiIiIgU44BFREREpBgHLCIiIiLFOGARERERKcYB\n", - "i4iIiEgxDlhEREREinHAIiIiIlLsO5hP7FaK+KtUAAAAAElFTkSuQmCC\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "feat = net.blobs['fc6'].data[0]\n", - "plt.subplot(2, 1, 1)\n", - "plt.plot(feat.flat)\n", - "plt.subplot(2, 1, 2)\n", - "_ = plt.hist(feat.flat[feat.flat > 0], bins=100)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The second fully connected layer, `fc7` (rectified)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAlcAAAJPCAYAAABRvvFyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XucFOWd7/FvJ5BNToAEVAYW3AOiKHKbWQ14XHGHKESO\n", - "eGExboiSeQmePWtiEqNH1M0mDm5UWDdrEF3DcSNhQw5KLiAxMl6i7S1RohlcE+8KK+LMKMLIDCiX\n", - "mTp/tD309FR11+WpW/fn/XrxYqan6qlf1VOXXz/11FMZy7IsAQAAwIiPxR0AAABAJSG5AgAAMIjk\n", - "CgAAwCCSKwAAAINIrgAAAAwiuQIAADCoZHK1bds2TZ8+XePHj9eECRN0yy23SJIaGxs1cuRI1dXV\n", - "qa6uTk1NTZEECwAAkHSZUuNctba2qrW1VbW1ters7NQJJ5yg9evXa+3atRo4cKAuv/zyKGMFAABI\n", - "vH6l/jhs2DANGzZMkjRgwACNGzdO27dvlyQx9igAAEBfrvtcbd26Vc3NzTrppJMkScuXL9fkyZO1\n", - "cOFCtbe3hxYgAABAmrhKrjo7O3Xeeedp2bJlGjBggC655BJt2bJFmzdv1vDhw3XFFVeEHScAAEAq\n", - "lOxzJUkHDhzQ7NmzNWvWLF122WV9/r5161adddZZev7553t9fvTRR+v11183Gy0AAEAIxowZo9de\n", - "e81IWSVbrizL0sKFC3X88cf3SqxaWlp6fl63bp0mTpzYZ97XX39dlmVV3b9rr7029hhYb9ab9Wa9\n", - "WW/Wm/X29s9kg1DJDu1PPvmkVq9erUmTJqmurk6SdMMNN2jNmjXavHmzMpmMRo8erRUrVhgLCAAA\n", - "IM1KJlennHKKuru7+3w+a9as0AICAABIM0ZoN6y+vj7uEGLBelcX1ru6sN7VpVrX26SyHdp9F5zJ\n", - "KKSiAQAAjDKZt9ByBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAGkVwB\n", - "AAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUA\n", - "AGAQyRUAAIBBJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAA\n", - "gEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRXAAAA\n", - "BpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhUMrnatm2bpk+frvHjx2vChAm65ZZbJEk7\n", - "d+7UjBkzNHbsWM2cOVPt7e2RBAsAAJB0GcuyLKc/tra2qrW1VbW1ters7NQJJ5yg9evXa+XKlTr8\n", - "8MO1aNEiLV26VLt27dKSJUt6F5zJqETRAAAAiWEybynZcjVs2DDV1tZKkgYMGKBx48Zp+/bt2rBh\n", - "gxoaGiRJDQ0NWr9+vZFgAACI0ltvSV1dcUeBSuO6z9XWrVvV3NysqVOnqq2tTTU1NZKkmpoatbW1\n", - "hRYgAABhOfJI6bbb4o4ClcZVctXZ2am5c+dq2bJlGjhwYK+/ZTIZZTKZUIIDACBs770XdwSoNP3K\n", - "TXDgwAHNnTtX8+fP17nnnisp11rV2tqqYcOGqaWlRUOHDrWdt7Gxsefn+vp61dfXGwkaAAAgiGw2\n", - "q2w2G0rZJTu0W5alhoYGHXbYYbr55pt7Pl+0aJEOO+wwXXXVVVqyZIna29vp0A4ASJ1MRvrud6XF\n", - "i+OOBHEzmbeUTK6eeOIJnXrqqZo0aVLPrb8bb7xRU6ZM0fnnn68333xTo0aN0tq1a/XZz342tCAB\n", - "AAgDyRXyTOYtJW8LnnLKKeru7rb920MPPWQkAAAAgErCCO0AAAAGkVwBAAAYRHIFAABgEMkVAACA\n", - "QSRXAAAABpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAG\n", - "kVwBAAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXNl47jnp\n", - "xhvjjgLw5+23pZtuijsKAKheJFc2fvAD6R/+Ie4oAH9+8hNp0aK4owCA6kVyBQCApJ07pS1b4o4C\n", - "lYDkCgAASV/8onTUUXFHgUpAcmUjk4k7AgBA1Nrb444AlYLkCgAAwCCSKwAAAINIrgAAAAwiuQIA\n", - "ADCI5AoAAMAgkisbPC0IAAD8IrmyYVlxRwAAANKK5AoAAMAgkisb3BYEAAB+kVwBKdXennvJOAAg\n", - "WUiubNByhTS45x7pW9+KOwoAQDGSKwAAAINIrgAAAAwiuQIAADCI5AoAAMAgkiuk0nPPSS+9FHcU\n", - "AAD0VTa5WrBggWpqajRx4sSezxobGzVy5EjV1dWprq5OTU1NoQYZNZ4WTL7aWul//I+4owAAoK+y\n", - "ydVFF13UJ3nKZDK6/PLL1dzcrObmZp1xxhmhBRgHXn8DAAD8KptcTZs2TYMHD+7zuUUGAgAA0Ifv\n", - "PlfLly/X5MmTtXDhQrW3t5uMKXbcFgQAAH718zPTJZdcou9+97uSpO985zu64oor9KMf/ajPdI2N\n", - "jT0/19fXq76+3leQgB0aTwEAfmWzWWWz2VDK9pVcDR06tOfniy++WGeddZbtdIXJFQAAlerUU3Pv\n", - "+vzLv4w7ErhV3OizePFiY2X7ui3Y0tLS8/O6det6PUlYCbgtmA7UE4CkePxx6cEH444CSVG25Wre\n", - "vHl69NFHtWPHDh155JFavHixstmsNm/erEwmo9GjR2vFihVRxAoAAJB4ZZOrNWvW9PlswYIFoQQD\n", - "AACQdozQjtSiQzsAIIlIrjx4/32pwkadAAAAhpFc2XDqKH3yydLxx0cbC5zRoR0AkES+hmKodE63\n", - "m954Q/rww2hjqST790v79kkDB8YdCQAA4aHlCpG55BJp0KC4owAAIFwkVza43RSOV14xWx4d2gEA\n", - "SURyBQAAYBDJFSJjuqWJFkYAQBKRXNngog0AAPwiuUJkSFoBANWA5AqpRYd2AEASkVwhMiRDAIBq\n", - "QHKF1OI2IwAgiUiubHDRBgAAfpFc2eD2FQAA8IvkygOSrmShPgAASURyZYPbggAAwC+SKw9IupKF\n", - "+gBQabZvl/74x7ijQFAkVyVYltTaGncUAIBqMXu2NHFi3FH09p3vSF1dcUeRLiRXNvItIj//uTR8\n", - "eLyxAHDnlVekBQvijgIIZv/+uCPo63vfk3bujDuKdCG5spHvKL1jR7xxoDQ6tKPQunXSypVxRwEA\n", - "JFeIEMkQAKQTfVy9Ibmykd+JSAaSjYMdhdgfACQFyRUiw8UPALyhr1M6kVzZyCcBxckALVnJtGcP\n", - "T7IAqEyHHSY1NcUdBbwiubKRT6JIpswyvT3z5Q0YkHuaBQD8SPq5/t13446AOw9ekVx5kJSd67vf\n", - "la67ru/nGzZIe/dGH08SvPZa3BEgbkk5PitFd3euVRiAdyRXNpJ+kv6nf8r9K3bOOdJPfxp9PG6Z\n", - "3q5JrycgzZYvz7UKV4Okn0uSHh/6IrlCZJLe9A7gkDfeiDsC5HHuTJ/UJle33CJ98EG0y2QHTxbq\n", - "AwCiQeuZN6lNrr75Tempp8IpO0k7kWVJTzwRdxRA8iXpuAVMYt9On9QmV2FyahGJYwd//nlp2rTo\n", - "lwsAAPwhuUo4xm9yVpjscosQAJAUJFc2nFqo8hfwd9+V3nknungAAIgTtya96Rd3AEnm1BoyeXKu\n", - "RamtLdp40Fth/XDgg33ALFqDAf9oufIgf/JuaaHlqho99pj0wx/GHQWAasMXh/QhuSqBHTo9oviW\n", - "feWV0iWXhL8ct9g/EaZK3b8OP5w3OiB8JFclJKFZ3CmGJMQWt0o9+bvFPgB49957uaewK8WAAdKD\n", - "D4a/nGo/33pFcmWjXId2+BPm9uPAB/sAqtGePdKmTXFHgWIkVwnndMHgQkKyCwAS58IkSnVyFfUO\n", - "FUdCU0kHTZjbr5K2EwAg3comVwsWLFBNTY0mTpzY89nOnTs1Y8YMjR07VjNnzlR7e3uoQUYtDa1C\n", - "JBPV5733pMJDLQ37KYB041rjT9nk6qKLLlJTU1Ovz5YsWaIZM2bolVde0WmnnaYlS5aEFmApYV1c\n", - "ktSJvJIuoKa3X+G2qaTt5OS446S/+qtDv3PS660a9gFUp3L7NueC5CmbXE2bNk2DBw/u9dmGDRvU\n", - "0NAgSWpoaND69evDiQ6Jes8h4rVjh/Tmm3FHAaCa5K9BJHDe+Opz1dbWppqaGklSTU2N2mIaqjys\n", - "yiZxSQcOdqBynHmmdMcdcUcBmBG4Q3smk1GmSrKRJK0miQUq3ac/Ld1/f9xRICr33SfddVfcUaAY\n", - "1xp/fL1bsKamRq2trRo2bJhaWlo0dOhQ2+kaGxt7fq6vr1d9fb2fxTkKO9lhp0KSJSnZD8Pevbnx\n", - "e77whbgjQaWptHN7pa1PVLLZrLLZbChl+0quzj77bK1atUpXXXWVVq1apXPPPdd2usLkqhIkaQeu\n", - "9AurG9W+DZK0PyZBte8PqFxx7tuV3OequNFn8eLFxsoue1tw3rx5Ovnkk/Xyyy/ryCOP1MqVK3X1\n", - "1VfrwQcf1NixY/Xwww/r6quvNhZQknCyBoDKk7ZzeyUmNpWubMvVmjVrbD9/6KGHjAeTNMU7dNoO\n", - "yEpXWD+7d8cXB2DCuHHSrbdKp50WdyQ5XNDTI8y6Yj/wJ9UjtIeFJCp9NmyIOwIgmJdekh5+OO4o\n", - "kERck9In1clV1Bk1GTyShBNub2wPs9iepX3jG9LFF8cdRfgquc9VmFKdXIUlDSeVNO7oYY7QXo3S\n", - "uA8AlWLFCulHP4o7CiRVqpOrqF9/g3TIZKTnnos7CiDdKvk8WGnrRp+r5El1chW1JLWUJCkWt0zH\n", - "XOqgf+01s8sCAMCtVCdX1fD6G741VLevflVauzbuKNIhScdtJbDbntdfL+3cGX0sprGvuMc1yJ9U\n", - "J1dRS9JOlqRY3EpjzHG7/Xbpttvs/5bkC0R3t/TOO3FHAdP+8R+lX/867ihQLIpzK+dvb1KRXB04\n", - "IO3b1/fzJF9cTKmGdfSLbZNcd9whffRud6QUF9PkSMII7fAmFcnV7NnS+PHRLzcJO5VTDGlMLNIY\n", - "c9IU7g9J2D+dtLTEHQEAxMfXuwWj9oc/SDt29P086osLyUEwTvV18KDU1SX92Z+ZKc+UX/0q12J6\n", - "3nnhLgdmcHyaxfaElOwvcUmWiparuCT55FJJO/yXvyyNGhV3FH2df770xS/GHUVvSd4nkR4vvyx9\n", - "8EHpaSrpHFOs0taNPlfJk+rkKqwLTb7c4p2JnSsczc1Sa2t45R99tPT22+GVH6XCfTDJiRbHSrw2\n", - "bSp9TB13nNTYGFk4VS+TkTo7447CH45lf1KdXFVzpSf5wurGvn3Sz34WrAy32+D116UXXwy2LFSW\n", - "ffukSn73/NSp0oIFpadJ68XehDjOn++/H/0yEZ9UJFdJSaLSntAkSVNT7rYbvCncB5NyXCSFl+Nz\n", - "9WppxozwYkmCoPsH57v0YIT25ElFcuWkmg9+dvjwtwHb2L+kb7vu7rgjCF9TU7D5k16HQVTyuoWF\n", - "beZNJMlVV1ew+ZOSRLFzAQC8eOml4GUwzlX6RJJc9esntbebL7caXn/jJA0xJkklbq9KXCckRyXv\n", - "X1Gu27hx0S0LyRHZbcFyj/0CXpU6QVbyhSEN4vi2S53DrUprjaHPVfLQ5yrByyu0cmV6RueOSqlt\n", - "UKnbh30AUam2/Wv79rgjSLZq2x+CSnVyVU0WLJD27o07imDiPDjff1/6xjfiWz6A5Cj+ovz009LI\n", - "kd7KqJZko1rW07RUJ1dRPy2WpJ0sjla073zH3DYIe1sWb5/f/15avtxbGUmq77y03PqK4th85JFw\n", - "l1Ht0rKvmbB7d9wRlFauLpJ4rqp2qU6uqlkcB9P3vpeeR9iLt0+lXCg4ieZs3Sp9/vO9P6uUOo5K\n", - "Ne9LJs4PUe5vcdZVNe8nQcSeXB19tPTOO/7mDfv1N2k8WSc55sLYTMSZ5HWNQpLXP+wTclqS/CTo\n", - "6vLXMsNFtbRS26ezs/Ie4mJ/8Cb25Or116VXX/U3b9S3BZN8McuzLGn2bOn+++OOpC/T9VWNBzsj\n", - "tCfLdddJX/ta3FGU9v3vS5/5TN/P03A+C0vxupveFmPHSrNmmSuPca7SJ/bkyo2kVK6JOB59VBoz\n", - "pvdn77yTe9eZF6UOtl//Wvr5z73Hht6SePFJyrFQzQrfybdsmfRv/xZfLG5s2eJvviTu/6aYOI5K\n", - "bZ+WlmjfZ8p5IXkSkVzFcRDfdZf0938f/XKzWemNN3p/VlMjXX65t3IOHsy1+jkxebBZlvS735kv\n", - "N++118yXaWKf4oTlX6WOc/Xuu9LAge6nv+kmacWK8OIJE/t/adWyfaplPU1LRHJVjtNJM8jJ9Lbb\n", - "knXSe/tt7/OsXdv3szAuMM88I518svlyw8QJwb3W1spupTDJ63Aoixbl/iFZwr4tWImczqm//710\n", - "xRXRxpIGqUiunCo16gtoHAeg13XMT28y1oMHzZVlUjWeEE0/FCBJu3aZKSftdu8Op6N83Il+3MuP\n", - "woUXSj/5ifvpw74taGoZbsU5QvvOndLzz4e3/LRKRXIVtWq8aLsV5ThXmYy0Zo2/Miq1DtNyoUxy\n", - "nB98IB040Pfzz3xGuv326ONJqjQdQz/9qXTnndEuM8p9PMl1YVnJji8uqUiuklJxldqPJMmeecbf\n", - "fGl80tOrJCcwcXBbx2PGOD/h9+ab5uLJi3vfc1p+uf2H/SuYuOvdFDf7SaWsq0mpSK6cKrcaKtTr\n", - "CS7sbWLqhFsNdReGTCb3JNLcuXFHkl4tLXFHgLiZ6HOVpHNYFIlwqe45SdoWSZGK5MpJJX2zMrVz\n", - "VtI2CaJ4e/rZLkls/bIs6YknpF/+Mu5ISmM/TL4k7M9xMXFsV8s+TsuVP6lIrkxX3JlnSjt2lJ8u\n", - "CRdXv8ushgM/6vpI2jblhBa/pO0TxSxL+uEPnf9WCvsX3CC5speI5MrvUxd+K/S++6SXXvIeTxwn\n", - "0qSdvP3E8+1vS4MG9Z7XxHp5KaNSDv5KWQ8v9uxxN101bpswJe3cY1JaXr+VhDpw+/ARektEcuVX\n", - "YaWfdpr5x0GTtsN42clNxh70AN+0SeroiGfZlcayDm0Tr9tm+nRp5UrzMdkxVW/PPisNGGCmrDAk\n", - "4Rwxfry/110lIfa4RPHlzsQytm7t/Xt7e3jLKicpQyKlRSqSKzcngYcflh56yOxy/ew09913aDTz\n", - "OET9vsVS9uzJJVV2CV8aT+xpjLlQNpv8vlrF3Ny+r3YvvOB87it1vIbxrs8PPzRbZlTsju1t29x9\n", - "YXdKeEwoHLfwjTekwYPDW1a5GEr9Pe3nxjCkIrlKkzPPlL74xXDK9noyfOCB3Os6gnJz4OzfL11y\n", - "Se/PPv95adw4++ndrktUB+1tt5UfSbtavqFt2CD97GdxR5Hz8Y9Hu7ww6jit+43XY2/VKulTnwon\n", - "lrDZreusWdKkSeXnufBC92UGictv63+Y/uVfpHPOIbmyk+rkKsoKnTLF/cuV4zyZFm6TL3xBuu66\n", - "aJbb0tK34+xLL0nbtx+KyfR2MVn/S5bk3gOXdFG0/v3t30rnnx+sDFN1/TEPZyhO8H0FqQev85Z6\n", - "12nSuNlX7AaaLZTfPmG2XLndp+MaoT3fEs6x11eik6vVq3MXvSD3ev/wB+kv/iJ4LL//vftp40yu\n", - "knRbsJSoX6xcbnlu4knCCaTamuCjbrkKY9tWU32V8utf51o5wvKnP7k/JySlNfHHP86929NJXPvO\n", - "rbdKX/96+enC6ONbKRKdXF1zTe5fEL/7Xe7euRdBd5SwDlwv5Sbl5CHZb88kxedW0mJOWjx+HDwo\n", - "Pfec89+9tFyV4ufF6G7EVQft7d5fIl0s6gviXXflbjmH5d13cw9ARMXE9rvoIunf/i3cZfhx8825\n", - "BKuQ3b5OcuUsEcmViVaFJKmEi56TtK5bmsf0SfuDAIUWLJA2bjz0++rVUm2t8/RBWq4ymdzTVh0d\n", - "0ogR/stJosMPl847r/x0UXZoTwK/HeqDDCIa5nZMQvLi5h2uaT8vhSERyVU5aXv9TZwtV363yXvv\n", - "Ob9Xze/6FD7pUkk6O3MtLlExPT5YFJziXLmy9wt2P/igdDlB+1xt3x5tXUWlq0vasiXuKOJ3xx3S\n", - "zJnBywlyjgo6RIGb6ZL6HkiSK2eBkqtRo0Zp0qRJqqur05QpU0zF5FpSLzRp7HP1P/+n9N//e3jl\n", - "hyHK9yju3HloeQMHSlddFe6y3UjyCS2ODu3oy02rQ5qtXSs9+OCh36NcJ9MP6mze7LyMONFy5U+g\n", - "U1cmk1E2m1Vzc7M2bdoUoJxgf0+aJCQgXrfZzp3hxCHZxxJVh/YXX3RXVql4urulww7rvbzXXnNX\n", - "rmlpOxaCSnpy5aY+knA+sOP3VnmYb7AIun93drof0b/ccu0+u/126bjjcj+b6mpgWbkW3Lq63O8v\n", - "vNC3jCQc96X6XKGvwKcuK4IzR5BFXHqp93mCfiNJQof2Ug4eDN6xNJOR7r3X//xRXXBMDJqZpItj\n", - "Gm8RFvNyQg76tOB//Vew+atZHCNyuy374EHp5Zf7fn7GGbn+dZ/+dOn5/SYFDzzQd7kmtkd3t/3n\n", - "hXHG1X+Olit/ArdcnX766TrxxBN1xx13mIop9fzs6Ka+DbrZyX/zm0OPRJcby6W4zHfflWbPzv1s\n", - "olWonKiGfkjLUAxOfv1r6ctfLj9d0CfM3IpjyA67aS+4wNvy0pqwOknSbUGT2/bOOw+1IBV7//3y\n", - "+3kSWtnykrjPeR3kOcnnxrgESq6efPJJNTc3a+PGjbrtttv0+OOPm4qrl7gqzu9y42y58voEyyc+\n", - "4a0Vq7k5dyEPKk0HYxRPBQX1H/8hrVlTfjq3CbEkDR0aTt+yoAlTkiR5nyjHb+xOddLV5T+WcmUX\n", - "i3q08u5u6dVXe39W7rxgct9watkyob1d+uY3nf9Oy5U//YLMPHz4cEnSEUccoTlz5mjTpk2aNm1a\n", - "z98bGxt7fv7tb+s1d269p/Ljvqgl4bZgFDutl6eOTLXKJembo9uyknYhDXuIhnfflZ56yny5SduO\n", - "YfNTNwcO5F4pVe72VjlBtrXX1nQTCUBcg4CWq6O77sq1gp57rtnlSmaeFiznySelqVOlfjZX/N/9\n", - "TrrlFmnZMu8xpD25ymazymazoZTtO7nau3evurq6NHDgQO3Zs0cPPPCArr322l7T5JOrxYulk092\n", - "LstvxSS1Qk0e+FFdiNI2srEU3Wj0cazzM8+4u2Wbl6R6kZIXj2mzZvUer8u0//W/pJ/8JHhrUEOD\n", - "/3krvQ4LlbuW2LWUhfVar0Juz0Hl/n7KKbn3hboZG81L2WlPrurr61VfX9/z++LFi42V7Tu5amtr\n", - "05w5cyRJBw8e1AUXXKCZNgOOeLlof/ihtxd/JvXgT/o4V1Ftt7AOvM5O98s24aWXzJXl1rRpzgMi\n", - "xt2iG1RYJ+IoT/BNTeGW/+KLZlqC7r47eBmmlKqft96KLg5T7I4/P8ekm47qJvYFpy9rQZ4CzD/N\n", - "m9bkKky+k6vRo0drs93AHA7K7XS33y597WvJuGAk6fU3XmPxO3BnqelNrY+fcuzeu3X99c7T//Vf\n", - "2y/LT4f2/GeTJtmXGQenx8yTdHJrayvf4tLSIg0bFk08YUrSlxmv3O4zmYy0Y0duOJKwFPdnSpOg\n", - "rf5R3BYsLOPAAal/f+/z2Ul7y1WYQh9Fxu1O8cYbfT9La4WZ7Hzo99H7Uq0bUW/XIONcrVnTt6Vq\n", - "/37n6R97zP5zE98oo7xIJvWCXOztt6XLL+/92bBhuT4cTjIZ6c//XFq/PtzYomC6nm64IdzOy6tX\n", - "HzqevIzT9M477peRhn3XxNPBpsbvM9Fy5Wabd3fnrrOf+ETvz72Mx1WM5MpZZEP0lat8u4525SSl\n", - "Ql9+Off4b16cJxfT2+Tmm3N95vLiaMXy01pjsuUuqcLu0O7Gr36V20f82LHD/vO1a3PvIKxWXo4N\n", - "r2M3z58v/fzn5uMonD6K81/QZXht2S5VhlMsxWUG+YJnquXqvff8x2AnjefNqCRm/GM/gwUm5RvS\n", - "ccdJX/3qod+TEpcJ3/1ubuC8vCBPC/o9EJ2SKy+D6pkY5yrKeg3rpJWkfdMplhUrcu8g9Cq/zfxc\n", - "QIrLMO3//l/p+efNl3vddf7nTeKFMW3D7pRi6k6D17KCxvPv/25/J8kOLVfOEnFbMJPx13Jlyttv\n", - "Bz/xFd66MjmIaCG/9+aXLpX+4i+8lePF3r3SK6+Un87vcvft8zefF3EkV08+mbvdUl/f9wXGSUqC\n", - "wuJmVOo8L9vj8MOlZ5/1F1NY/vf/dp8I+bkoe1F4Ic9kzB1fJlpZ3Mw7bZr07W/7X4Yppp4WLNX1\n", - "I/+7ieuj29vNN91kH4Mdkitnqb4taMqcOYc6LZuQtAtjNitt21Z6miAxX3tt6TfTBz3w/DSvh3Gw\n", - "O93G8uuUU6RvfUt69FFvfVryCrdDqfX9xS+ke+4pP50XBw5IX/+6v3nzT7C5uZ3id79sb/c3XxJE\n", - "NcRIfhRzp6dSg5Yfliee8DZMSVgK19NN4uKlpb3485oa93H5Wb7f+UmunIWe0ritULvbglElKcUd\n", - "pNP8bkG7nfz118tPEySG3bv9l5cm5RJUP9z21/ArX05xJ9ag3n5buvVW6Yc/9F9GvuXE9LT56Yt/\n", - "dlNG0r4YhWnVKrPlBR2LSUrWRbrUECy//e2hny0rWOuf34eWgizH1HwkV84S03JVqs9V2iouCSfo\n", - "wm1musXFK9P1F8b+ENc+FqSPRdoTBdMtV3Fsj6T31QlavhfFsbS3++8UHzWv9bh2rb+6/4//kOze\n", - "ElfuPGAicXVqXStO7tx08cgjuXIWanJl91j8yJHSN75hE0iJSJJ6wDm9Y6843v37pT/8wUxM5dgd\n", - "jHFfZE0feH77niVRmHHanUyj3i6PPppr4bITVp+r4jLKzbt3r//hD8JojUlCohREPqbBg3OjgidR\n", - "cZ2YHkLBafqGBunSS3PjvBXeIXFKotwu4wc/cLf8cuy6J9By5U+oydVf/3Xfitm+Pfcuo2ImKsft\n", - "Ew5uldtqX2UMAAAgAElEQVQZzznH/vODB6UHHzz0+x13SCecEH48QcpJ8sERxQUkrPcflhPmbcEk\n", - "1PPVVzv3zfKSJIfZkvfpT0vLl5cv36+k3eqJsttCS4u3eaPaP4NuAzfJe6l12brV/vOw95Ug5wT6\n", - "XHmTmNuCJjh9Qw5LqXX6f//v0M+mO4yW4ndgO7e3p/x8qzY94r2JAQCjdvCgdP/90iOPuJveTWf1\n", - "ctMUtsYksYXDS8uVV15bbk1/MQsiqqcF/Sq3P4b9tGBauF0Xp6SnsIx333X32i8/8QS55ZjfF5yS\n", - "xWoWy1AMzzyT+/+hh3L/J+1CGCST97usMIcCMNEEHjQGk5xiuPTS8tNE5e/+rvd4S/37S2ecIc2e\n", - "3Xu6MG9xxr0NynGTXJm4YBeXlXRxxOk26ZfC77vW2Zl7hVJaeEmiyn3u9GX2y1/OPdUehNeHQtzI\n", - "l/fww2bLrQSxDiI6Y0acS49H2Imk3QEcpPXJRNJnuuXKyW23+Y/BdL3ccYf01FPlp3MaX81E61xh\n", - "8pK0LzCSt9spYfa58lJ+0hI0Uy1Xn/988PGugiTCha3c8+bF997JoF9k/K67m/mCPpjkdjl28zlJ\n", - "4nklKUJPrp57Lvd/kAt8Oc3N5soqZOIJDRPzxCkJ8Zq4LZiE9bDj9Li3m9uChQqnyX/rD/MddSa4\n", - "Sa68HINJeXpy0SJp6FD/84cdZ9S3BQcOPHS3ohzLyg3zEZegyVGp+d38LczrZNDzQRL6cKZJ6MmV\n", - "03vHTO40f/mX5soqlLQLsolOvWHE4LZVyNTtrbBvSySN1/XNH3Ne+x1Jue0QVR/BMJ8WdFr3e+91\n", - "v8xy5Tr53e9yfWT8CrvPVVBel9nZWX7E/DCOv44O7/ME3Z5J/sLtdFswyJeSJJ834xZbh/akJS6m\n", - "xL2zmd6uca8PnJWr67S2XLmZxk8CYlm5EfEriYmLualzhonbgiYNGhTN8v3ebrNbfpjXSac4gyyD\n", - "64Oz2N4tWNyc7/cptzD52enCjNnP7TE7QbZ1uYOzVMuWqZarShpE1A2/sXm9tRg1Ey00Yfbb8rK8\n", - "IB55RNq1K9xlFHK6gHtp3SxVbpov1n773gW5LeimQ3uxffu8b+cwxnKLu76SLBHJldN0cbVuBUkG\n", - "TL3MM8/rweq3A7qJFgI/y/UzX9KSXhNKxeclgShkquWqtVX64x/NlFXIbr1Gj+49OK+Xb/ROfbWS\n", - "3kr++c9L3/veod/Dvi1YPE9+P/GbWJTi9rgzfd70KmirW9DE0ut8n/ykdOed3pdhuhEj6efVOHFb\n", - "0LBq3NnKdUA23XKVZnv32icqQdfx1VdLl1n8/sznnpMaG92Vff750sSJvkNzZJf8eR0vx1QiktZ9\n", - "zGRrXBi3tsJI2MLk9otMWIm8l+vka695L7vcF+tSLb5+v8xXq9iGYojiVk8cTIxY+8orh56uCeOR\n", - "8qVL3cdS7qm7/fvdt5CYOoGm/bbg/fd7m95NbHad0EvVy623SosXu1t+0Ef0nXjZn4P2ifGyTLdl\n", - "+VXugYGkt1yFeazEfR3w04Lvts9VqbKjuHPg5jztdXlx11eS9YtqQWlsufLT/G2i2fW006S33jLT\n", - "UdJONut+2nL19md/VvrvkvRf/+V+eZL0y19KI0a4jyEs5Zbzgx9IX/taboDQMD36qP3n5eJL+jFm\n", - "ImGKus9VUO+8I9XUxNuK5pRcufX++6XL9dPCkZTbgn6nN3Vb0Mv8TvVQbhlelZqv1DuBq11i+lwl\n", - "kZ9vkOVO6mGPjp7EbxJPP5373+32nDtXWrDg0O+m95VPfrJvwuJnu33rW6Wb5sPom1JuWYXLdHPR\n", - "fOEFadIkd8uYP1/as8dbXKXWy8s3aa/7vlNrlVM8Ub2Vwev2KyeO24KXXmo/IrfbcpKa+Er+Yw/a\n", - "Z8tp+aXKu/12b8vp7vZ+nvnDH0oncUm83iRFYm4LxmX79r6fmejQbseypAMHvJcZVJBt7XUwTjfL\n", - "ymalN9/M/Wz3FvZyZXo5oLu6+n62b5/7QQ2jEnRf85tcPfFE7r2HbmJYvTp3y9oLUy00Jlovozrn\n", - "RPVGAq/TOt3+83pbUHL/ehqv2yKui7Xb5CjI3+++23meqBohvJZ3wgnSNdc4z0ty5SwRL26OM9Ea\n", - "OdJseaUSs5/9rPdTQW4Eba4OymR5+bKmT5e++c3cz3bJj6mYfvlL6dpr3U2b5pPEW28d6iTvtX+R\n", - "3ycKTb1cOeio6lH12/KyvKQuI39xN5Fc2bHbzl63fdxfuv30O3PbcvXtb5dfZpjr77dfWPHDMMuW\n", - "SSeemPs5zefNsHFbsATTLVd2T3R54XebRflevTDq1anMcn0OCrd3WC8szbfAxemqqw797LblqtSF\n", - "sFC5MY2C6O72f9H1c/vGS/lu7NvXe3wqU8Jqudq92/5zU8lVXhrO7U7C6JcUZH6T29LNbUG75RV/\n", - "du+9h0bcJ7lylpjbgkmsJNPJlen5TI1ZEtbJ3NS8liX99rdmxm1at87+c78X4zPOCBaPaV6/BQdt\n", - "GQq7D2G5FoH857W10rZt9mWbarl67bVcK2Hej39cOqYoeFnW3/+9/Tymto+J9Y77tqCf6ePqc+Vn\n", - "OeW+QHldXhKv20kRWctVqZ3G7w50ww25e8JhMZVcmboAxfGN0GQLQJDk6q/+Slqxwt/8hcv+m7+x\n", - "/3uUwzv8n//T97MwWg3CePTa6/x+Bkf147nnnF/gbmo5xxyTG/Azz2v/Sb+d5t98U9q82duyvJQf\n", - "5m3BuJnqVuF2iJ2gLV9x3BYsd40pFRvJlbPEtFz5aZX4zW9yTzMkQfHBF+TbQBBumnWDlBdHy1Xe\n", - "V7/qf14/jwzHXW9By3GzLxQed35aMIPEHeRpQS/LnzHD/bRemLpwl5tu9myprs5MDHbCvC0Y9sXX\n", - "VLLjtoXU79/LLTsptwW9IrlylogR2j/8ULryyqgi6ctp9F0/F5sox/2I+xui10eqTfRnCGudwzxJ\n", - "fPBBeGVLztvHLnkxMcht4XKC3FaM6sXSL79cfpqwb6d7lY9n7lzp+efNxuCn5WrhQu/lJkFYCbBT\n", - "h/agwm658nO8lpqH5MpZIjq0Fz+NkBRBbgtG1RLhtPxyn3n5e9zivjVqx8s2u/nm8tMk4bagl2Z/\n", - "Ey1XbubNT3PXXeXnDdKKUS4WP0+1umE3FEzhRfCXvyw9v4nkyk0Zv/ud+3KTdLyaarkqNyRNGlqu\n", - "vBxvbiX92hGn2G4LPvfcoZ+TegAGSa5MlVdunrffDv5SXT8tdE5eesn8crwmDH6WZ+ok0dHRd/lu\n", - "Wq6C7BtB3nNWbnuWK+NrXyv996eecl/2e+85T5vvjF2ujFKCnGd27Ahent0+ZjcUTNDzodcWQRO3\n", - "BS+7LDcgbVCmW5pMlec2MQ9ad8XHi8lrY0eHdOGFpacp1XJlWdI//7P00EOH/kZy5Sy2Du1/93dh\n", - "LzlaJl9/U6hcn5i/+ZtwXqrrhl08tbXepvfK7YXD6+CnpgwaJD3+uPdl+4lv7dq+87pNRP/930vP\n", - "W04YdXnnneEsJyxBLtzlBmMNMmJ8uTsBbltdSr0DsTi+ZctyT/Q6xRQXp1gee0waOND7ezNNtOT+\n", - "53/2nTc/36xZ3uIp9sYbh96IUezll8sPB1Qu/nwd55FcOQs9uWpttf/cKWlobfU+CnRQJsbysWtF\n", - "cLucUn8rdYHcs8f5QPLCywFi+jaQm2Z4PwmAZYV74JeKw82o80GsXJn7/777+v6t3LbyeksozHGu\n", - "gtSRn9swSbrol7rN5qUPj9c+MnacWq5KvarHbUtO3CO0O8X59NNSZ2fuBeaF07m9LVi8DK/7o9v3\n", - "Anqty3POkU46qXxZv/qVdPnl3mMofpcsyZWz0JMrp28zhUlD4c+zZ0vHHht2VOExvbOVSq6uv97M\n", - "Mgrr5te/dn9Amxql28s0fjtBOy3n+utzyVCYF1677XT22b1/97L8pibn8sttq1Itel6SMVPJlYlp\n", - "8kwde24HBg2rf0rYtwXDrNOgTMdQrry9e80sP2jcXm5H+l1W4X7xgx/Y9wUtV/YnP9n7d5IrZ7H1\n", - "uXrjjUM/F1a66RebulG8Q/nplF58W/DgQWnnTu/llIotigN/9uzwRh33e6Lwsw3cHvT/+I+5gUUL\n", - "90evvL6dXsp9cywUxj5ios9VmIIsO0gftUL5W1+F+8uQIe46sAeJwW+LoZsYysXu9EXXVGJjV05Y\n", - "F2FTr09yWy/lzmF+9wkvyZVffr/MFG6bfv16/y3/dDxJVl+xJVeF4jzBm1J8W/CnP5UOOyx4uVFs\n", - "mzhvC/rtfOt1Wdmst+V4UXwb0MQJ0WtfELtl222rUrcF3VwUTT4N6+b2l5e/u4mpuJtCvhN98cXV\n", - "73G3b1/pW6luLuJubws6TRNFh3a3D+6E1brnltfl+01ygrT+lZrHLlEO80u23/oiueorES9utjsZ\n", - "FD51FTaT/Ur87mRO42P5HeSxUFg7vokTV1QtV4891vv3NWvcleO2/KDCaDUI42QadD7TZRQqVyfv\n", - "vZfrZ1NK/mJWfE5yu+9+8pN9OyzbzVMuuXJy7bXS3/5t6Wm9tlw5xZSE24RBmWohLDW926TZKa5S\n", - "ybTdtbHcE7pulullmsLPnL5skVz11a/8JOGzOxkMGhR9HMWC3Ba0+1spbpIrv5LyYmYTyZXb7fHx\n", - "j5f+e/7Fo3kmt1Fjo/cyTdz+LZ43zNffmE6u7r/f/nUy5VoSSp34i7lpDQyaXEnOt4kzmeC3BX/8\n", - "40O37QvLK+S1z5VTy5XXVk67v8U9OKvXZMdpetOvvXF7HrOb7oc/9LasPBPbleTKvUQkV3HfFjR5\n", - "vzvMliu/gt56cRJHh3a3sZZLroIqFcef/lR+mlLlRZlclWsZDbMvSOGyzzjD+SknU9zEnI+p+Auf\n", - "qXNU0JYrN+vgdcBTp3Ur/tzkedqyorkge91PC1/+7bYcPy1Xxced03wmB6+1W8Y770hnnll6mlLr\n", - "RlLlLLG3BeMU5NuW352tMBlwutBG1crwyCPhXFT9fMv2O72b1xCVG/26lDBvmQQ5oZq4jRyV4gvs\n", - "wYP20zjNW+rvduxGQy+W335uEgs/t8WDJldupjXVclVqGwQdLLnUNCb7gPq5TVfKunVmynHTMmo3\n", - "XRB2ZRUO5l0qDie0XDmrmg7tpcbOCrvPlV05F18s/exnh36P87Zg8d8vuig38rvk7+lNL4lZWLcF\n", - "3Rzsc+f2nX7LFmnDBm8xmVBYnqnkKowO7aWm9aq4jOITvWlnnFE+BqfbgiaSq8J5TLUWh9nnym/L\n", - "VdDkyiRTXxJNj3Pl9kuQ6dZCP9PQ58qfyG4Lxt1y9fzz0tix3uYx1efKzo9+JG3deuj3wuSqsIwk\n", - "t0SU+rZld1vORHJl+ptosSuvlH7xi/BupbopL8yWq+JbEKbHDfOieNle+lyZUjwkhpfbgn4u0E4t\n", - "Y37L9dNyVTzKdr6PWLnkytStaxPz55nuC+WX1+SqeP+KouWqcBkPP1x+GjskV+5VTcuVn2b4/Odt\n", - "be6X46VDe+FynfoIRdHnyonfC4rp9/+ZSAZKyWScWyycmE56o2q5Kv7c6wUzaMuLXVlB5g16wf/q\n", - "V3v/nh85vbs7957Mf/iHQ7+bYPq2oJ1y+8+99/b+Pf/KlWpqufI7ndO8XucvrKNS85rscxX0i1Tx\n", - "bXyJ5KoU38lVU1OTjjvuOB1zzDFaunRpoCCS1ueqWP4WmRv79mVdT1t4UDndFjR5EvJSVne3fUtC\n", - "od4HVLbXvG6X77XuwzgpW9ahJ8m8X0CyZecp10+jWJDjoXDeFSv6/t2ygiWG+Xl///us59jsYjEx\n", - "jUn5l6B3deVeM3TjjcVxZHumjeO2oFN5krRkifTAA/Z917yWJRXvh733c699rr7zndzYf/Zlhyf4\n", - "crKSzCdppW7P5/30p9LGje7Kc3L11dLvf+8+Nrv9vBSSK2e+kquuri5deumlampq0gsvvKA1a9bo\n", - "xRdfLDlP3LcFpdxtOD8tS15OhKaTKxMtJA0N3ufv6vLWwdguuSoeqyzKPldet1X+ZbduvykWnoTK\n", - "zZN/etBdeeZarn78Y/vlmGi52rQp6ye8XoIMFWE6SSnm3GqTDVSu6ZarwmmvuUb6p38KPgBtV1fu\n", - "5ePFyVWQbR3GQLtuWFbuy3G599WWO6+VOiYLW66WLZMWLSofl5uWqwsvzL2mJoilS6Xbb++7TCde\n", - "v0SQXDnzlVxt2rRJRx99tEaNGqX+/fvrS1/6ku655x7fQUSVXDm9RDqveEcJ+wRQOGp4WB3aDx6U\n", - "Hnoo97OX9TlwoHzLlZPubve3FMPqc+WFUx+3UkzfqgwjuXIzTZwth2Ee90Hj7O4uv1+YbLkyuY/n\n", - "X+njVX65Dz8snXpq5dwWPOMM5/fVuo0j/+XLqYzCcm66qXx5bvtceWVXTuEr2fzMb1dWflqSK2e+\n", - "OrRv375dRx55ZM/vI0eO1NNPP11ynt27pfZ2+78Vjpps960r/5nT/IXy01x22aEmfinXiuI0OnPh\n", - "yai9Xfrgg9zP+f937y6/vL17cz8Xn4Da2w+9HLT4JaGF9u07VFbh+ha2/rz/vvM2yH+eX8f8sjZt\n", - "OtRysmtX73dDFc5TvN137rRP+ArXwelJQqd57U5Qhdu2cN0K66RwG+za1TuGUvtUqe1dPG1efp3K\n", - "7Wv5fSM/bSbTd4ycjg53+6zU+/iwe3FwqXKKYyll797e5Zfblh980Lsu8nEW7y/llutUdrmnUQuX\n", - "U1hGfp8oPOYKp/X6hofifaVwP2tvtx8YtNy2y3+Wj2Xv3kP7e/G+UVjW3XfbJ0jF271wmvx2/OCD\n", - "Q6/08Sp/fsm/E7W4bgr3m85O5zp//31p4MDcz9/8pv00u3b1XpfC81Z+vdwcO+USyfZ2aceOvuXl\n", - "z0X57V5qf7ar/z17Dn353LfP/hrx4YfurnmF+4VXxXHaXSvz9Wh3bS2Mo73dPo78fLt3997eTU2l\n", - "k85ql7Es7znzL37xCzU1NemOO+6QJK1evVpPP/20li9f3jPN0Ucfrddff91cpAAAACEZM2aMXnvt\n", - "NSNl+Wq5GjFihLYVfE3ftm2bRo4c2WsaUwECAACkia8+VyeeeKJeffVVbd26Vfv379fdd9+ts88+\n", - "23RsAAAAqeOr5apfv3669dZb9YUvfEFdXV1auHChxo0bZzo2AACA1PHV5woAAAD2Qhmh3eQAo0k0\n", - "atQoTZo0SXV1dZoyZYokaefOnZoxY4bGjh2rmTNnqr3gcY0bb7xRxxxzjI477jg98MADcYXt2YIF\n", - "C1RTU6OJEyf2fOZnPZ999llNnDhRxxxzjL7p9PhQgtitd2Njo0aOHKm6ujrV1dVpY8HofpWw3tu2\n", - "bdP06dM1fvx4TZgwQbfccoukyq9vp/Wu9Pr+8MMPNXXqVNXW1ur444/XNddcI6ny69tpvSu9vvO6\n", - "urpUV1ens846S1Ll13de8XpHUt+WYQcPHrTGjBljbdmyxdq/f781efJk64UXXjC9mFiNGjXKeu+9\n", - "93p9duWVV1pLly61LMuylixZYl111VWWZVnWn/70J2vy5MnW/v37rS1btlhjxoyxurq6Io/Zj8ce\n", - "e8z6wx/+YE2YMKHnMy/r2d3dbVmWZX3uc5+znn76acuyLGvWrFnWxo0bI14Tb+zWu7Gx0fr+97/f\n", - "Z9pKWe+WlharubnZsizL6ujosMaOHWu98MILFV/fTutd6fVtWZa1Z88ey7Is68CBA9bUqVOtxx9/\n", - "vOLr27Ls17sa6tuyLOv73/++9eUvf9k666yzLMuqjvO5ZfVd7yjq23jLlekBRpPKKrqbumHDBjV8\n", - "NBR6Q0OD1q9fL0m65557NG/ePPXv31+jRo3S0UcfrU2bNkUerx/Tpk3T4MGDe33mZT2ffvpptbS0\n", - "qKOjo6eF7ytf+UrPPEllt95S3zqXKme9hw0bptraWknSgAEDNG7cOG3fvr3i69tpvaXKrm9J+m//\n", - "7b9Jkvbv36+uri4NHjy44utbsl9vqfLr+6233tJ9992niy++uGddq6G+7dbbsqzQ69t4cmU3wGj+\n", - "ZFUpMpmMTj/9dJ144ok9Y321tbWppqZGklRTU6O2j972/Pbbb/capiLt28PrehZ/PmLEiNSu//Ll\n", - "yzV58mQtXLiwp/m8Etd769atam5u1tSpU6uqvvPrfdJJJ0mq/Pru7u5WbW2tampqem6NVkN92623\n", - "VPn1/a1vfUs33XSTPlYwwnM11LfdemcymdDr23hylamCcfCffPJJNTc3a+PGjbrtttv0+OOP9/p7\n", - "JpMpuR0qZRuVW89Kcskll2jLli3avHmzhg8friuuuCLukELR2dmpuXPnatmyZRqYH2b7I5Vc352d\n", - "nTrvvPO0bNkyDRgwoCrq+2Mf+5g2b96st956S4899pgeeeSRXn+v1PouXu9sNlvx9X3vvfdq6NCh\n", - "qqurs22xkSqzvp3WO4r6Np5cuRlgNO2GDx8uSTriiCM0Z84cbdq0STU1NWr96OWFLS0tGjp0qKS+\n", - "2+Ott97SiBEjog/aEC/rOXLkSI0YMUJvvfVWr8/TuP5Dhw7tOflcfPHFPbd2K2m9Dxw4oLlz52r+\n", - "/Pk699xzJVVHfefX+8ILL+xZ72qo77zPfOYzOvPMM/Xss89WRX3n5df7mWeeqfj6/u1vf6sNGzZo\n", - "9OjRmjdvnh5++GHNnz+/4uvbbr2/8pWvRFPfRnqLFThw4IB11FFHWVu2bLH27dtXcR3a9+zZY+3e\n", - "vduyLMvq7Oy0Tj75ZOv++++3rrzySmvJkiWWZVnWjTfe2Kdj4L59+6w33njDOuqoo3o6yKXBli1b\n", - "+nRo97qeU6ZMsZ566imru7s7NR0gi9f77bff7vn5X//1X6158+ZZllU5693d3W3Nnz/fuuyyy3p9\n", - "Xun17bTelV7f7777rrVr1y7Lsixr79691rRp06yHHnqo4uvbab1bWlp6pqnE+i6UzWat2bNnW5ZV\n", - "+cd3ocL1juL4Np5cWZZl3XfffdbYsWOtMWPGWDfccEMYi4jNG2+8YU2ePNmaPHmyNX78+J71e++9\n", - "96zTTjvNOuaYY6wZM2b0HMCWZVnXX3+9NWbMGOvYY4+1mpqa4grdsy996UvW8OHDrf79+1sjR460\n", - "7rzzTl/r+cwzz1gTJkywxowZY33961+PY1U8KV7vH/3oR9b8+fOtiRMnWpMmTbLOOeccq7W1tWf6\n", - "Sljvxx9/3MpkMtbkyZOt2tpaq7a21tq4cWPF17fdet93330VX9//+Z//adXV1VmTJ0+2Jk6caP3z\n", - "P/+zZVn+zmOVsN6VXt+Fstlsz1NzlV7fhR555JGe9b7wwgtDr28GEQUAADAolEFEAQAAqhXJFQAA\n", - "gEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRXAAAA\n", - "BpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAGkVwBAAAY\n", - "RHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGAQ\n", - "yRUAAIBBJFcAAAAGkVwBAAAYRHIFAABgUMnkatu2bZo+fbrGjx+vCRMm6JZbbpEkNTY2auTIkaqr\n", - "q1NdXZ2ampoiCRYAACDpMpZlWU5/bG1tVWtrq2pra9XZ2akTTjhB69ev19q1azVw4EBdfvnlUcYK\n", - "AACQeP1K/XHYsGEaNmyYJGnAgAEaN26ctm/fLkkqkZMBAABULdd9rrZu3arm5maddNJJkqTly5dr\n", - "8uTJWrhwodrb20MLEAAAIFUsFzo6OqwTTjjBWrdunWVZltXW1mZ1d3db3d3d1re//W1rwYIFfeYZ\n", - "M2aMJYl//OMf//jHP/7xL/H/xowZ4yYlcqVknytJOnDggGbPnq1Zs2bpsssu6/P3rVu36qyzztLz\n", - "zz/f6/NMJsOtwxRrbGxUY2Nj3GHAJ+ovvai7dKP+0stk3lLytqBlWVq4cKGOP/74XolVS0tLz8/r\n", - "1q3TxIkTjQQDAACQdiU7tD/55JNavXq1Jk2apLq6OknSDTfcoDVr1mjz5s3KZDIaPXq0VqxYEUmw\n", - "AAAASVcyuTrllFPU3d3d5/NZs2aFFhCSob6+Pu4QEAD1l17UXbpRf5DKjHMVqGD6XAEAgJSIrM8V\n", - "AAAAvCG5AgAAMIjkCgAAwCCSKwAAAINIrgAAAAwiuQIAADCI5AoAAMAgkisAAACDSK4AAAAMIrkC\n", - "AAAwiOQKAADAIJIrAAAAg0iuAAAADCK5AgAAMIjkCgAAwCCSKwAAAINIrgAAAAwiuQIAADCI5AoA\n", - "AMAgkisAAACDSK4AAAAMIrkCAAAwiOQKAADAIJIrAAAAg0iuAAAADCK5AgAAMIjkCgAAwCCSKwAA\n", - "AINIrgAAAAwiuQIAADCI5AoAAMAgkisAAACDSK4AAAAMIrkCAAAwiOQKAADAoIpNrgYNGqJMJtPr\n", - "36BBQ+IOCwAAVLiMZVlWKAVnMgqpaNfLl4qXH29MAAAgmUzmLRXbcgUAABAHkisAAACDSK4AAAAM\n", - "Kplcbdu2TdOnT9f48eM1YcIE3XLLLZKknTt3asaMGRo7dqxmzpyp9vb2SIIFAABIupId2ltbW9Xa\n", - "2qra2lp1dnbqhBNO0Pr167Vy5UodfvjhWrRokZYuXapdu3ZpyZIlvQumQzsAAEiJyDq0Dxs2TLW1\n", - "tZKkAQMGaNy4cdq+fbs2bNighoYGSVJDQ4PWr19vJBgAAIC0c93nauvWrWpubtbUqVPV1tammpoa\n", - "SVJNTY3a2tpCCxAAACBNXCVXnZ2dmjt3rpYtW6aBAwf2+lt+gE4AAABI/cpNcODAAc2dO1fz58/X\n", - "ueeeKynXWtXa2qphw4appaVFQ4cOtZ23sbGx5+f6+nqdffbfqKNjV69pBg4crN27dwZYBbMGDRrS\n", - "K8akxQcAAILLZrPKZrOhlF2yQ7tlWWpoaNBhhx2mm2++uefzRYsW6bDDDtNVV12lJUuWqL293VWH\n", - "9o5qW0QAABBCSURBVCg7mftdVt/56AQPAEClM9mhvWRy9cQTT+jUU0/VpEmTem793XjjjZoyZYrO\n", - "P/98vfnmmxo1apTWrl2rz372s2WDJLkCAABJFFlyFahgkisAAJASvFsQAAAgoUiuAAAADCK5AgAA\n", - "MIjkCgAAwCCSKwAAAINIrgAAAAwiuaoAgwYN6XkNUSaT0aBBQ+IOCQCAqsU4V2XnS/44V2mMGQCA\n", - "JGGcKwAAgIQiuQIAADCI5AoAAMAgkisAAACDSK4AAAAMIrkCAAAwiOQKAADAIJIrAAAAgyomuSoe\n", - "pRwAACAO/eIOwJSOjl0qHqUcAAAgahXTcgUAAJAEJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRX\n", - "AAAABpFcAQAAGBTqOFd//OMfwyweAAAgcTKWZVnlJ/NRcCajT31qhPr3/6wkqatrn/bseU29B/qU\n", - "pIxMhJAblb14EFHvy7IrJ6RNZEwaYwYAIEkyGXPXzlCTK2m1pAs++uQlSeNEcmVeGmMGACBJTCZX\n", - "9LkCAAAwiOQKAADAIJIrAAAAg0iuAAAADCK5AgAAMIjkCgAAwCCSKwAAAINIrgAAAAyqsuSqnzKZ\n", - "TM+/QYOGxB0QAACoMKG+WzB5DqpwJPOOjkx8oQAAgIpUZS1XAAAA4SK5AgAAMIjkCgAAwCCSKwAA\n", - "AIPKJlcLFixQTU2NJk6c2PNZY2OjRo4cqbq6OtXV1ampqSnUIAEAANKibHJ10UUX9UmeMpmMLr/8\n", - "cjU3N6u5uVlnnHFGaAECAACkSdnkatq0aRo8eHCfzy3LspkaAACguvnuc7V8+XJNnjxZCxcuVHt7\n", - "u8mYAAAAUstXcnXJJZdoy5Yt2rx5s4YPH64rrrjCdFwAAACp5GuE9qFDh/b8fPHFF+uss85ymPIX\n", - "kl796Oej/CwKAADAuGw2q2w2G0rZvpKrlpYWDR8+XJK0bt26Xk8S9jZX0gUf/fySn0UBAAAYV19f\n", - "r/r6+p7fFy9ebKzsssnVvHnz9Oijj2rHjh068sgjtXjxYmWzWW3evFmZTEajR4/WihUrjAUEAACQ\n", - "ZhkrpMf+MpmMpNXq3XI1ToUvTv5oSiNPHuaWV1hO8e92n/Vdtl05SX8yMo0xAwCQJJmMuWsnI7QD\n", - "AAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYFACkqt+ymQyPf8GDRoSd0CeDRo0pNc6\n", - "+F0PU+UAAID4+Bqh3ayDKhyjqaMjE18oPnV07FLxmFp+1sNUOQAAID4JaLkCAACoHCRXAAAABpFc\n", - "AQAAGERyBQAAYBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGBQApOrfmVHKbcbyRwAACAJEjBCe7He\n", - "I7ZLfUcptxvJXCLBAgAA8UtgyxUAAEB6kVwBAAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERy\n", - "BQAAYBDJFQAAgEEkVz4UjxAPAACQl8AR2pOv7wjxJFgAACCHlisAAACDSK4AAAAMIrkCAAAwiOQK\n", - "AADAIJIrAAAAg0iuAAAADCK5AgAAMIjkCgAAwKCUJFf9GBE9oOJR5QcNGuJ5HrfzAQBQzVIyQvtB\n", - "MSJ6MMWjynd0lN+GfUeidzcfAADVLCUtVwAAAOlAcgUAAGAQyRUAAIBBJFcAAAAGlU2uFixYoJqa\n", - "Gk2cOLHns507d2rGjBkaO3asZs6cqfb29lCDBAAASIuyydVFF12kpqamXp8tWbJEM2bM0CuvvKLT\n", - "TjtNS5YsCS1AAACANCmbXE2bNk2DBw/u9dmGDRvU0NAgSWpoaND69evDiQ4AACBlfPW5amtrU01N\n", - "jSSppqZGbW1tRoMCAABIq8CDiJYeNf0Xkl796Oejgi6qSvXrtX0HDhys3bt3xhgPAADpl81mlc1m\n", - "QynbV3JVU1Oj1tZWDRs2TC0tLRo6dKjDlHMlXfDRzy/5ChC9R6dnhHQAAIKrr69XfX19z++LFy82\n", - "Vrav24Jnn322Vq1aJUlatWqVzj33XGMBAQAApFnZ5GrevHk6+eST9fLLL+vII4/UypUrdfXVV+vB\n", - "Bx/U2LFj9fDDD+vqq6+OIlYAAIDEy1iWZZWfzEfBmYyk1ep9W3Ccil8EnHsJc/FLmaObpnj1c3F7\n", - "n8ZuWV43bd9yw425XHxO8YS0ywAAEJtMxtz1jRHaAQAADCK5AgAAMIjkCgAAwCCSKwAAAINIrgAA\n", - "AAyq8uSqX88I884jzbuZpnzZgwYN6TPFoEFDfJTrfdlmy/aueD2dtgcAAJUg8Otv0q336Oc5xYmI\n", - "m2nKl203snpHxy71HdLBBL8xh6PvejLSPACgclV5yxUAAIBZJFcAAAAGkVwBAAAYRHIFAABgEMkV\n", - "AACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAAgEEkV6mTrFfb+Ff+9UAAAKRRlb/+Jo2S9Wob/8q/\n", - "HggAgDSi5QoAAMAgkisAAACDSK4AAAAMIrkCAAAwiOQKAADAIJIrAAAAg0iuAAAADCK5AgAAMIjk\n", - "qmr1HendzyjpgwYNMVKOKcXxMPI7ACBqjNBetfqO9O5nlPSOjl1GyjGlOB5GfgcARI2WKwAAAINI\n", - "rgAAAAwiuQIAADCI5AoAAMAgkisAAACDSK4AAAAMIrkCAAAwiOQKAADAIAYRjUxuRPRkcxOjqWkA\n", - "AKhMJFeR6TsiupS0BKQ4Rrv4TE0DAEBl4rYgAACAQSRXAAAABpFcAQAAGBSoz9WoUaM0aNAgffzj\n", - "H1f//v21adMmU3EBAACkUqDkKpPJKJvNasiQIabiAQAASLXAtwUtq/gJOAAAgOoVKLnKZDI6/fTT\n", - "deKJJ+qOO+4wFRMAAEBqBbot+OSTT2r48OF69913NWPGDB133HGaNm2aqdgAAABSJ1ByNXz4cEnS\n", - "EUccoTlz5mjTpk1FydUvJL360c9HBVkU0MegQUPU0bGrzFR9R4sfOHCwdu/eaXz5psoFAIQvm80q\n", - "m82GUnbG8tlpau/everq6tLAgQO1Z88ezZw5U9dee61mzpyZKziTkbRa0gUfzfGSpHGyH6W8eDRv\n", - "pqnGabzuirl9zN+yTfQV7Lt8M+UCAKKXyZg7h/tuuWpra9OcOXMkSQcPHtQFF1zQk1gBAABUK9/J\n", - "1ejRo7V582aTsQAAAKQeI7QDAAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAAYBDJFQAA\n", - "gEEkVwAAAAaRXAEAABhEcgUAAGAQyRUAAIBBJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRXAAAA\n", - "BpFcISH6KZPJ9PwbNGhInykGDRrSa5owl2WiXLuyi9fB7PKrA9sQQNL1izsAIOegJKvnt46OvslT\n", - "R8euXtNIfhOs8ssyUa5d2X3XweTyqwPbEEDS0XIFAABgEMkVAACAQSRXAAAABpFcAQAAGERyBQAA\n", - "YBDJFQAAgEEkVwAAAAaRXAEAABhEcgUAAGAQyRVg89qaTOYTiXq9SvErX6KMx9TrZuzKSdp2hnlx\n", - "7rtAXHj9DWDz2prcq3XCeEWOP8WvfIkyHlOvm7ErJ2nbGebFue8CcaHlCgAAwCCSKwAAAINIrgAA\n", - "AAwiuQIAADCI5AoAAMAgkisAAACDSK4AAAAMIrkCAAAwiOQKCdV31PR0xtPPxTzFZX/C17L6joDe\n", - "txw3I6IXl+M35uLP3Om7nd2N6N3Pxzxm+Bl53u+o935GOzc1wr4bdsuqFlFuZyRfxrKs4iGTzRSc\n", - "yUhaLemCjz55SdI4lRuhue/vTFOd0yQ9vvinKT50c8dcfOWEOU1hjH3jsy8npFNbH37icZqnXMx2\n", - "deN9Hnfz+ZG0uolSlNsZ4chkzNUXLVcAAAAGkVwBAAAYRHIFAABgkO/kqqmpSccdd5yOOeYYLV26\n", - "1GRMAAAAqeUruerq6tKll16qpqYmvfDCC1qzZo1efPFF07EhVtm4A0Ag2bgDgE/ZbDbuEBBINu4A\n", - "kAC+kqtNmzbp6KOP1qhRo9S/f3996Utf0j333GM6NsQqG3cACCQbdwDwieQq7bJxB4AE8JVcbd++\n", - "XUceeWTP7yNHjtT27duNBQUAAJBW/fzM5HZguE996l/Uv/9dkqTu7g51dvpZGgAAQHr4Sq5GjBih\n", - "bdu29fy+bds2jRw5stc0Y8aM0euvb9YHH2wumtsuMSv+jGmYJu5lJ38a+y858ZUT5jR9Y/S7XmHx\n", - "E4/zei5evNj1stytp5ttakrS6iZK+fU6VH+Vu66VZ8yYMcbK8jVC+8GDB3XsscfqN7/5jf78z/9c\n", - "U6ZM0Zo1azRu3DhjgQEAAKSRr5arfv366dZbb9UXvvAFdXV1aeHChSRWAAAA8tlyBQAAAHuhjNDO\n", - "AKPpNmrUKE2aNEl1dXWaMmVK3OGghAULFqimpkYTJ07s+Wznzp2aMWOGxo4dq5kzZ6q9vT3GCFGK\n", - "Xf01NjZq5MiRqqurU11dnZqammKMEE62bdum6dOna/z48ZowYYJuueUWSRx/aeFUf6aOP+MtV11d\n", - "XTr22GP10EMPacSIEfrc5z5Hf6yUGT16tJ599lkNGTIk7lBQxuOPP64BAwboK1/5ip5//nlJ0qJF\n", - "i3T44Ydr0aJFWrp0qXbt2qUlS5bEHCns2NXf4sWLNXDgQF1++eUxR4dSWltb1draqtraWnV2duqE\n", - "E07Q+vXrtXLlSo6/FHCqv7Vr1xo5/oy3XDHAaGXgbnE6TJs2TYMHD+712YYNG9TQ0CBJamho0Pr1\n", - "6+MIDS7Y1Z/E8ZcGw4YNU21trSRpwIABGjdunLZv387xlxJO9SeZOf6MJ1cMMJp+mUxGp59+uk48\n", - "8UTdcccdcYcDj9ra2lRTUyNJqqmpUVtbW8wRwavly5dr8uTJWrhwIbeVUmDr1q1qbm7W1KlTOf5S\n", - "KF9/J510kiQzx5/x5IoxPdLvySefVHNzszZu3KjbbrtNjz/+eNwhwadMJsMxmTKXXHKJtmzZos2b\n", - "N2v48OG64oor4g4JJXR2dmru3LlatmyZBg4c2OtvHH/J19nZqfPOO0/Lli3TgAEDjB1/xpMrNwOM\n", - "ItmGDx8uSTriiCM0Z84cbdq0KeaI4EVNTY1aW1slSS0tLRo6dGjMEcGLoUOH9lyUL774Yo6/BDtw\n", - "4IDmzp2r+fPn69xzz5XE8Zcm+fq78MILe+rP1PFnPLk68cQT9eqrr2rr1q3av3+/7r77bp199tmm\n", - "F4OQ7N27Vx0dHZKkPXv26IEHHuj1JBOS7+yzz9aqVaskSatWreo5aSAdWlpaen5et24dx19CWZal\n", - "hQsX6vjjj9dll13W8znHXzo41Z+p4y+Uca42btyoyy67rGeA0Wuuucb0IhCSLVu2aM6cOZJyI/Ff\n", - "cMEF1F+CzZs3T48++qh27NihmpoaXXfddTrnnHN0/vnn680339SoUaO0du1affazn407VNgorr/F\n", - "ixcrm81q8+bNymQyGj16tFasWNHThwfJ8cQTT+jUU0/VpEmTem793XjjjZoyZQrHXwrY1d8NN9yg\n", - "NWvWGDn+GEQUAADAoFAGEQUAAKhWJFcAAAAGkVwBAAAYRHIFAABgEMkVAACAQSRXAAAABpFcAQAA\n", - "GERyBQAAYND/B6hFJTD2mK/NAAAAAElFTkSuQmCC\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "feat = net.blobs['fc7'].data[0]\n", - "plt.subplot(2, 1, 1)\n", - "plt.plot(feat.flat)\n", - "plt.subplot(2, 1, 2)\n", - "_ = plt.hist(feat.flat[feat.flat > 0], bins=100)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The final probability output, `prob`" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAmEAAAJPCAYAAAA0UwMNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3X9w1/Wd4PHX1ya37flbpAoJO1ESSayCbAPW7TGTdkVO\n", - "d+XE/lhaV52WWsYd225nu+3dzXWqnWsrs9u5teX+YL3a7a9B5q4zYndozqM11dpCzmIPZ9EKLLQh\n", - "iroq/gAV8/Vzf3ybCCF8CZDw/iTvx2Mmk3zz/Xy++YRPQp55vz/fdypFURQBAMAJdVLqAwAAyJEI\n", - "AwBIQIQBACQgwgAAEhBhAAAJiDAAgASOGGHd3d3R3t4ebW1tsWLFikPuX7t2bcyZMyfmzp0b7373\n", - "u+OnP/3p0H0tLS0xe/bsmDt3bsyfP39sjxwAYAKr1FsnrFqtxqxZs2L9+vXR1NQU8+bNi9WrV0dH\n", - "R8fQNnv37o2TTz45IiIeffTRWLJkSWzbti0iIs4777z41a9+FWedddY4fxoAABNL3ZGw3t7eaG1t\n", - "jZaWlmhsbIylS5fG2rVrD9pmMMAiIl555ZU4++yzD7rfWrAAAIeqG2H9/f0xY8aModvNzc3R399/\n", - "yHb33HNPdHR0xJVXXhnf+MY3ht5fqVTi8ssvj87OzrjzzjvH8LABACa2hnp3ViqVUT3INddcE9dc\n", - "c008+OCDcf3118dvfvObiIh46KGHYtq0afHss8/GwoULo729PRYsWHD8Rw0AMMHVjbCmpqbo6+sb\n", - "ut3X1xfNzc2H3X7BggUxMDAQzz33XEyZMiWmTZsWERFTp06NJUuWRG9v7yER1traGtu3bz+ezwEA\n", - "4ISYOXPm0LXvx6vudGRnZ2ds3bo1du7cGfv37481a9bE4sWLD9pm+/btQ9d9bdq0KSIipkyZEvv2\n", - "7YuXX345ImoX7993331x8cUXH/IxBvf3MjFfvvSlLyU/Bi/OXY4vzt/EfnH+Ju7LWA4c1R0Ja2ho\n", - "iJUrV8aiRYuiWq3GsmXLoqOjI1atWhUREcuXL48f/vCH8d3vfjcaGxvjlFNOibvvvjsiInbv3h3X\n", - "XnttREQMDAzEddddF1dcccWYHTgAwERWN8IiIq688sq48sorD3rf8uXLh97+/Oc/H5///OcP2e/8\n", - "88+PX//612NwiAAAk48V8zkuXV1dqQ+BY+TcTWzO38Tm/BFxhMVaT8gBVCqR+BAAAEZlLLvFSBgA\n", - "QAIiDAAgAREGAJCACAMASECEAQAkIMIAABIQYQAACYgwAIAERBgAQAIiDAAgAREGAJCACAMASECE\n", - "AQAkIMIAABIQYQAACYgwAIAERBgAQAIiDAAgAREGAJCACAMASECEAQAkIMIAABIQYQAACYgwAIAE\n", - "RBgAQAIiDAAgAREGAJCACAMASECEAQAkIMIAABIQYQAACYgwAIAERBgAQAIiDAAgAREGAJCACAMA\n", - "SECEAQAkIMIAABIQYQAACYgwAIAERBgAQAIiDAAgAREGAJCACAMASECEAQAkIMIAABIQYQAACYgw\n", - "AIAERBgAQAIiDAAgAREGAJCACAMASECEAQAkIMIAABIQYQAACYgwAIAERBgAQAIiDAAgAREGAJCA\n", - "CAMASECEAQAkIMIAABIQYQAACYgwsvLZz0Z87nOpjwIAIipFURRJD6BSicSHQEYqldrLm2+mPhIA\n", - "JqKx7BYjYWRH8wNQBiIMACABEQYAkIAIAwBI4IgR1t3dHe3t7dHW1hYrVqw45P61a9fGnDlzYu7c\n", - "ufHud787fvrTn456XwCAXNV9dmS1Wo1Zs2bF+vXro6mpKebNmxerV6+Ojo6OoW327t0bJ598ckRE\n", - "PProo7FkyZLYtm3bqPaN8OxITqxKpfbalxwAx+KEPTuyt7c3Wltbo6WlJRobG2Pp0qWxdu3ag7YZ\n", - "DLCIiFdeeSXOPvvsUe8LAJCruhHW398fM2bMGLrd3Nwc/f39h2x3zz33REdHR1x55ZXxjW9846j2\n", - "hRNpcCQMAFKrG2GVUf7Euuaaa+Kxxx6LH/3oR3H99debXqS0RBgAZdFQ786mpqbo6+sbut3X1xfN\n", - "zc2H3X7BggUxMDAQzz//fDQ3N49631tvvXXo7a6urujq6hrl4QMAjJ+enp7o6ekZl8eue2H+wMBA\n", - "zJo1K37yk5/E9OnTY/78+YdcXL99+/Y4//zzo1KpxKZNm+JDH/pQbN++fVT7RrgwnxOroSGiWnVh\n", - "PgDHZiy7pe5IWENDQ6xcuTIWLVoU1Wo1li1bFh0dHbFq1aqIiFi+fHn88Ic/jO9+97vR2NgYp5xy\n", - "Stx9991194WUTEcCUBb+gDdZaWyMGBgwEgbAsfEHvAEAJjgRRlZMRwJQFiKMrIgwAMpChAEAJCDC\n", - "yIqRMADKQoSRFREGQFmIMACABEQYWTESBkBZiDCyIsIAKAsRBgCQgAgDAEhAhJEV05EAlIUIIysi\n", - "DICyEGEAAAmIMLJiJAyAshBhZEWEAVAWIgwAIAERRlaMhAFQFiKMrIgwAMpChAEAJCDCAAASEGFk\n", - "xXQkAGUhwsiKCAOgLEQYAEACIoysGAkDoCxEGFkRYQCUhQgDAEhAhJEVI2EAlIUIIysiDICyEGEA\n", - "AAmIMACABEQYWTEdCUBZiDCyIsIAKAsRBgCQgAgjK0bCACgLEUZWRBgAZSHCAAASEGFkxUgYAGUh\n", - "wgAAEhBhZMVIGABlIcIAABIQYWTFSBgAZSHCyIoIA6AsRBgAQAIijKwYCQOgLEQYWRFhAJSFCAMA\n", - "SECEkRUjYQCUhQgDAEhAhJEVI2EAlIUIAwBIQISRFSNhAJSFCCMrIgyAshBhAAAJiDCyYiQMgLIQ\n", - "YWRFhAFQFiIMACABEUZWjIQBUBYiDAAgARFGVoyEAVAWIgwAIAERRlaMhAFQFiKMrIgwAMpChAEA\n", - "JCDCyIqRMADKQoSRFREGQFmIMACABEQYAEACIoysmI4EoCxEGFkRYQCUhQgDAEjgiBHW3d0d7e3t\n", - "0dbWFitWrDjk/h/84AcxZ86cmD17drz3ve+NzZs3D93X0tISs2fPjrlz58b8+fPH9sjhGBgJA6As\n", - "GurdWa1W45Zbbon169dHU1NTzJs3LxYvXhwdHR1D25x//vnxwAMPxOmnnx7d3d3xyU9+MjZs2BAR\n", - "EZVKJXp6euKss84a388CRkmEAVAWdUfCent7o7W1NVpaWqKxsTGWLl0aa9euPWibyy67LE4//fSI\n", - "iLj00ktj165dB91fFMUYHzIAwMRXN8L6+/tjxowZQ7ebm5ujv7//sNt/61vfiquuumrodqVSicsv\n", - "vzw6OzvjzjvvHIPDheNjJAyAsqg7HVk5ip9Y999/f9x1113x0EMPDb3voYceimnTpsWzzz4bCxcu\n", - "jPb29liwYMEh+956661Db3d1dUVXV9eoPy4cDREGwNHo6emJnp6ecXnsuhHW1NQUfX19Q7f7+vqi\n", - "ubn5kO02b94cN910U3R3d8eZZ5459P5p06ZFRMTUqVNjyZIl0dvbe8QIAwAoi+GDQ7fddtuYPXbd\n", - "6cjOzs7YunVr7Ny5M/bv3x9r1qyJxYsXH7TN7373u7j22mvj+9//frS2tg69f9++ffHyyy9HRMTe\n", - "vXvjvvvui4svvnjMDhwAYCKrOxLW0NAQK1eujEWLFkW1Wo1ly5ZFR0dHrFq1KiIili9fHl/+8pfj\n", - "hRdeiJtvvjkiIhobG6O3tzd2794d1157bUREDAwMxHXXXRdXXHHFOH86UJ/pSADKolIkfvpipVLx\n", - "DEpOmHnzIh5+OMKXHADHYiy7xYr5AAAJiDCyYjoSgLIQYWRFhAFQFiIMACABEUZWjIQBUBYijKyI\n", - "MADKQoQBACQgwgAAEhBhZMV0JABlIcLIiggDoCxEGABAAiKMrBgJA6AsRBhZEWEAlIUIAwBIQISR\n", - "FSNhAJSFCAMASECEAQAkIMLIiulIAMpChJEVEQZAWYgwsiLCACgLEQYAkIAIIytGwgAoCxFGVkQY\n", - "AGUhwgAAEhBhZMVIGABlIcLIiggDoCxEGABAAiIMACABEUZWTEcCUBYijKyIMADKQoQBACQgwsiK\n", - "kTAAykKEkRURBkBZiDAAgAREGFkxEgZAWYgwsiLCACgLEQYAkIAIAwBIQISRFdORAJSFCCMrIgyA\n", - "shBhAAAJiDCyYiQMgLIQYWRFhAFQFiIMACABEUZWjIQBUBYijKyIMADKQoQBACQgwgAAEhBhZMV0\n", - "JABlIcLIiggDoCxEGFkqitRHAEDuRBhZEmEApCbCyMpgfIkwAFITYWRJhAGQmggDAEhAhJElI2EA\n", - "pCbCyIprwgAoCxFGlkQYAKmJMLIkwgBITYSRFdORAJSFCCNLIgyA1EQYWRJhAKQmwsiK6UgAykKE\n", - "kSURBkBqIgwAIAERRpaMhAGQmggjK+ILgLIQYWRJjAGQmggDAEhAhJEVS1QAUBZHjLDu7u5ob2+P\n", - "tra2WLFixSH3/+AHP4g5c+bE7Nmz473vfW9s3rx51PsCAOSqboRVq9W45ZZboru7O7Zs2RKrV6+O\n", - "xx577KBtzj///HjggQdi8+bN8cUvfjE++clPjnpfSMVIGACp1Y2w3t7eaG1tjZaWlmhsbIylS5fG\n", - "2rVrD9rmsssui9NPPz0iIi699NLYtWvXqPeFE018AVAWdSOsv78/ZsyYMXS7ubk5+vv7D7v9t771\n", - "rbjqqquOaV84kcQYAKk11LuzUqmM+oHuv//+uOuuu+Khhx466n0BAHJTN8Kampqir69v6HZfX180\n", - "Nzcfst3mzZvjpptuiu7u7jjzzDOPat+IiFtvvXXo7a6urujq6jqazwEAYFz09PRET0/PuDx2pSgO\n", - "PzEzMDAQs2bNip/85Ccxffr0mD9/fqxevTo6OjqGtvnd734X73//++P73/9+vOc97zmqfSNqI2Z1\n", - "DgHG1J/+acS6dRH/+q8RU6akPhoAJpqx7Ja6I2ENDQ2xcuXKWLRoUVSr1Vi2bFl0dHTEqlWrIiJi\n", - "+fLl8eUvfzleeOGFuPnmmyMiorGxMXp7ew+7LwAARxgJOyEHYCSME2hwJOzZZyPOPjv10QAw0Yxl\n", - "t1gxn6zofQDKQoSRJTEGQGoiDAAgARFGVvwBbwDKQoQBACQgwsiSkTAAUhNhAAAJiDCy4powAMpC\n", - "hAEAJCDCAAASEGFkxXQkAGUhwgAAEhBhZMlIGACpiTCyIr4AKAsRRpbEGACpiTAAgAREGFkyEgZA\n", - "aiKMrIgvAMpChJElMQZAaiIMACABEUZWjIABUBYijCyJMQBSE2EAAAmIMLLiD3gDUBYiDAAgARFG\n", - "loyEAZCaCAMASECEkRXXhAFQFiIMACABEUaWjIQBkJoIIyviC4CyEGEAAAmIMLJkRAyA1EQYAEAC\n", - "IoysWKICgLIQYQAACYgwsmQkDIDURBhZEV8AlIUII0tiDIDURBgAQAIijKx4diQAZSHCAAASEGEA\n", - "AAmIMLJkOhKA1EQYWRFfAJSFCCNLYgyA1EQYAEACIoysWKICgLIQYQAACYgwsmQkDIDURBhZEV8A\n", - "lIUII0tiDIDURBgAQAIiDAAgARFGVixRAUBZiDAAgAREGFkyEgZAaiKMrIgvAMpChJElMQZAaiIM\n", - "ACABEUZWPDsSgLIQYQAACYgwsmQkDIDURBgAQAIijKy4JgyAshBhAAAJiDAAgAREGFkxHQlAWYgw\n", - "AIAERBhZMhIGQGoijKyILwDK4ogR1t3dHe3t7dHW1hYrVqw45P7HH388Lrvssnj7298eX//61w+6\n", - "r6WlJWbPnh1z586N+fPnj91Rw3ESYwCk1lDvzmq1GrfcckusX78+mpqaYt68ebF48eLo6OgY2mbK\n", - "lCnxzW9+M+65555D9q9UKtHT0xNnnXXW2B85AMAEVnckrLe3N1pbW6OlpSUaGxtj6dKlsXbt2oO2\n", - "mTp1anR2dkZjY+OIj1EYcqCEfFkCkFrdCOvv748ZM2YM3W5ubo7+/v5RP3ilUonLL788Ojs74847\n", - "7zz2o4QxIr4AKIu605GVSuW4Hvyhhx6KadOmxbPPPhsLFy6M9vb2WLBgwXE9JhyvSkWMAZBe3Qhr\n", - "amqKvr6+odt9fX3R3Nw86gefNm1aRNSmLJcsWRK9vb0jRtitt9469HZXV1d0dXWN+mPA0TrO3y0A\n", - "yEhPT0/09PSMy2PXjbDOzs7YunVr7Ny5M6ZPnx5r1qyJ1atXj7jt8Gu/9u3bF9VqNU499dTYu3dv\n", - "3HffffGlL31pxH0PjDAYT0bAADgawweHbrvttjF77LoR1tDQECtXroxFixZFtVqNZcuWRUdHR6xa\n", - "tSoiIpYvXx67d++OefPmxUsvvRQnnXRS3HHHHbFly5Z45pln4tprr42IiIGBgbjuuuviiiuuGLMD\n", - "h2NlOhKAMqgUiZ++WKlUPIOSE+bd747YvDniwQcj3vOe1EcDwEQzlt1ixXyyUhRGwgAoBxFGdlyY\n", - "D0AZiDCyZCQMgNREGNkxEgZAGYgwsuKaMADKQoSRHSNhAJSBCCNLRsIASE2EkZXB6UgASE2EkR0R\n", - "BkAZiDCyZDoSgNREGFkxHQlAWYgwsmOJCgDKQISRHSNhAJSBCCNLRsIASE2EkRXXhAFQFiKM7Lgm\n", - "DIAyEGFkx0gYAGUgwsiKP+ANQFmIMLJjJAyAMhBhAAAJiDCyYjoSgLIQYWTHdCQAZSDCyJKRMABS\n", - "E2Fkx0gYAGUgwsjK4DVhb7wRsWtX6qMBIGcijOxUKhEPPBBx002pjwSAnIkwsvTGG7UXAEhFhJEV\n", - "S1QAUBYijOwMRpgQAyAlEUZ2KpWIN98UYQCkJcLIwnPPHRxeAgyA1EQYWfiLv4j4+c9rb5uOBKAM\n", - "RBhZeP312kuECAOgHEQY2XjzzbfeFmAApCbCyMLgyNeBS1QIMQBSEmFkoSjeGgkTYQCUgQgjCwdG\n", - "lyUqACgDEUY2BsPLivkAlIEIIwvDR8JMRwKQmggjC8OjS4QBkJoIIxumIwEoExFGFkxHAlA2Iows\n", - "HLhExeBtEQZASiKMbAxfogIAUhJhZMGK+QCUjQgjC1bMB6BsRBhZGGmJCgBISYSRjeFLVAgxAFIS\n", - "YWTBEhUAlI0IIwsj/QFvAEhJhJEN64QBUCYijCxYogKAshFhZGGkJSoAICURRjaGXxMmxABISYSR\n", - "hQOnIw98HwCkIsLIghXzASgbEUYWLFEBQNmIMLJhxXwAykSEkQUr5gNQNiKMLLgoH4CyEWFkw4X5\n", - "AJSJCCMLVswHoGxEGFkYvkSFZ0cCkJoIIxvDrwkzEgZASiKMLJiOBKBsRBhZ8Ae8ASgbEUYWRlqi\n", - "QogBkJIIIxtWzAegTEQYWRhpxXwASEmEkYWR/oC3EAMgJRFGNg5cG8x0JACpHTHCuru7o729Pdra\n", - "2mLFihWH3P/444/HZZddFm9/+9vj61//+lHtCyfKSEtUAEBKdSOsWq3GLbfcEt3d3bFly5ZYvXp1\n", - "PPbYYwdtM2XKlPjmN78Zn/vc5456XzhRRlqiQogBkFLdCOvt7Y3W1tZoaWmJxsbGWLp0aaxdu/ag\n", - "baZOnRqdnZ3R2Nh41PvCiTLShfkiDICU6kZYf39/zJgxY+h2c3Nz9Pf3j+qBj2dfGA/Dl6gAgJQa\n", - "6t1ZqVSO+YGPZt9bb7116O2urq7o6uo65o8LIxk+ElatCjEAjqynpyd6enrG5bHrRlhTU1P09fUN\n", - "3e7r64vm5uZRPfDR7HtghMF4sGI+AMdi+ODQbbfdNmaPXXc6srOzM7Zu3Ro7d+6M/fv3x5o1a2Lx\n", - "4sUjblsM+4l2NPvCiWDFfADKpO5IWENDQ6xcuTIWLVoU1Wo1li1bFh0dHbFq1aqIiFi+fHns3r07\n", - "5s2bFy+99FKcdNJJcccdd8SWLVvilFNOGXFfSMGK+QCUTaUYPoR1og+gUjlkFA3G2nnnRfz5n0d8\n", - "73sRF1wQ8eqrEbt3R+zcmfrIAJhIxrJbrJhPNixRAUCZiDCyYMV8AMpGhJGF4Svm+wPeAKQmwsiC\n", - "JSoAKBsRRjasmA9AmYgwsuBvRwJQNiKMLAyPMNeEAZCaCCMbwguAMhFhZMF0JABlI8LIgiUqACgb\n", - "EUY2hi9RAQApiTCyMNKK+UIMgJREGFkYPh0pwgBITYSRhZEuzAeAlEQY2Ri+Yr4QAyAlEUYWLNYK\n", - "QNmIMLIw0h/wBoCURBjZMB0JQJmIMLJgxXwAykaEkYUDl6gYvC3CAEhJhJENS1QAUCYijCxYMR+A\n", - "shFhZMEf8AagbEQYWbBEBQBlI8LIhiUqACgTEUYWLFEBQNmIMLIw0jVhAJCSCCMbnh0JQJmIMLJg\n", - "OhKAshFhZGGkFfMBICURRhaMhAFQNiKMbBy4QKsIAyA1EUYWRhoJA4CURBhZMB0JQNmIMLJhxXwA\n", - "ykSEkYXhI2EWawUgNRFGFkZaosJIGAApiTCyYcV8AMpEhJEFF+YDUDYijCyM9Ae8BwYi7rkn7XEB\n", - "kC8RRhaGj3wNvv35z6c5HgAQYWRj+BIVEaYkAUhHhJGFw62YL8IASEWEkYXDTUeKMABSEWFkw3Qk\n", - "AGUiwsjC4aYjrZwPQCoijGwcuESFkTAAUhNhZGP4ivmD7wOAFEQYk97w4KpU3rrPdCQAqYgwJr16\n", - "13+JMABSEWFMekbCACgjEUY2Dlyi4sD3AUAKIoxJz0gYAGUkwpj06j0TUoQBkIoIIxumIwEoExHG\n", - "pFdvOtI6YQCkIsKY9OotUVGtnthjAYBBIoxsHLhi/iDTkQCkIsKY9ExHAlBGIoxJb/h0pJEwAMpA\n", - "hDHp1VuiwjVhAKQiwsiGJSoAKBMRxqTnmjAAykiEMenVuyYMAFIRYWRjcIkKACgDEcakV286EgBS\n", - "EWFMeqYjASgjEcakV2+JCgBIRYSRjZGWqACAVEQYk55rwgAooyNGWHd3d7S3t0dbW1usWLFixG0+\n", - "/elPR1tbW8yZMyceeeSRofe3tLTE7NmzY+7cuTF//vyxO2o4CiIMgDJqqHdntVqNW265JdavXx9N\n", - "TU0xb968WLx4cXR0dAxts27duti2bVts3bo1Nm7cGDfffHNs2LAhIiIqlUr09PTEWWedNb6fBYyC\n", - "6UgAyqTuSFhvb2+0trZGS0tLNDY2xtKlS2Pt2rUHbXPvvffGjTfeGBERl156aezZsyeefvrpofsL\n", - "V0OT2JFGwnyJApBC3Qjr7++PGTNmDN1ubm6O/v7+UW9TqVTi8ssvj87OzrjzzjvH8rhh1IYvUTGc\n", - "vx8JQAp1pyMro5y3Odxo189//vOYPn16PPvss7Fw4cJob2+PBQsWHP1RwnE66aS3Vsw3EgZAGdSN\n", - "sKampujr6xu63dfXF83NzXW32bVrVzQ1NUVExPTp0yMiYurUqbFkyZLo7e0dMcJuvfXWobe7urqi\n", - "q6vrqD8ROJyiiHjb20xHAnD0enp6oqenZ1weu26EdXZ2xtatW2Pnzp0xffr0WLNmTaxevfqgbRYv\n", - "XhwrV66MpUuXxoYNG+KMM86Ic845J/bt2xfVajVOPfXU2Lt3b9x3333xpS99acSPc2CEwVgbHP06\n", - "3LSjCAPgcIYPDt12221j9th1I6yhoSFWrlwZixYtimq1GsuWLYuOjo5YtWpVREQsX748rrrqqli3\n", - "bl20trbGySefHN/+9rcjImL37t1x7bXXRkTEwMBAXHfddXHFFVeM2YHDaBXFW9OREUbCACiHSpH4\n", - "6YuVSsUzKBlXzzwTcf75EdVqxP79Ef/5P0f81//61v379kW84x3pjg+AiWMsu8WK+Ux6RsIAKCMR\n", - "xqQ3PMJGuh8ATjQRRhZOOunwK+aLMABSEGFMekeajrRYKwApiDAmvcEIG4wtI2EAlEHdJSpgsnBh\n", - "PgBlYySMSW9wJGyQCAOgDEQYk95IF+MfyDVhAKQgwpj0BiPspMN8tRsJAyAFEUY2BkfDTEcCUAYi\n", - "jElv+EiYCAOgDEQYk95ghB1uJMw1YQCkIMLIxuEuzjcSBkAKIoxJ70gjYSIMgBREGJPe8Agb6X4A\n", - "ONFEGNlwTRgAZSLCmPSMhAFQRiKMSc81YQCUkQhj0rNiPgBlJMLIhmvCACgTEcak55owAMpIhDHp\n", - "iTAAykiEkQ0X5gNQJiKMSe9II2GuCQMgBRHGpGeJCgDKSIQx6bkmDIAyEmFkw0gYAGUiwpj0XBMG\n", - "QBmJMCa94SvmGwkDoAxEGNlwTRgAZSLCmPQ8OxKAMhJhTHqeHQlAGYkwsuHCfADKRIQx6ZmOBKCM\n", - "RBiTnulIAMpIhDHpGQkDoIxEGNlwTRgAZSLCmPSMhAFQRiKMSW/4ivkj3Q8AJ5oIIxtGwgAoExHG\n", - "pOcPeANQRiKMSc81YQCUkQgjC9YJA6BsRBiT3mBkiTAAykSEMekdaTrSNWEApCDCmPT82SIAykiE\n", - "kQ0X5gNQJiKMSc9irQCUkQhj0nNNGABlJMLIgmvCACgbEcakN3yJCteEAVAGIoxJz7MjASgjEUYW\n", - "XBMGQNmIMCY9K+YDUEYijEnPdCQAZSTCmPSOtESFCAMgBRFGNg43EuaaMABSEGFMesNXzDcSBkAZ\n", - "iDAmPdeEAVBGIowsuCYM4Ojcf3/E+vWpj2JyE2FMelbMBzh669eLsPHWkPoAYLwNn448+eSD73dh\n", - "PsChXn01olpNfRSTmwhj0hseYaeeeuj9ABxMhI0/EUY2Xnut9lqEARyZCBt/IoxJb3AkbN++2u3T\n", - "Tjv0fgAOJsLGnwhj0huMsFdfrd0ePhLmmjCAQ4mw8SfCmNTWrIn4b/+tFl6HizAjYQCHEmHjzxIV\n", - "TGj/7/9FvPHG4e//l3+J2Lat9vbgdKQIAziyV19965fXY3HXXW9di8vIRBgT2sc+FvGLXxz+/hdf\n", - "jNiz5+DpyLe//eBtxivCBgYienrG57Enm8FQBsrjtdeOL8L+43/0vX0kIowJ7V//NeK55w5//4sv\n", - "1obTK5WI118f+c8Xjdc1YT/7WcT73mek7UiKImL27PrnETjxjmckrCginn++9sLhiTAmtOefr//D\n", - "e8+eg2+/4x2HbjNekbR/f+317343Po8/Wbz0Uu0/+meeSX0k8JaBgYjf/Cb1UYyvrq6I/v7D3388\n", - "Efbyy7VfgEVYfUeMsO7u7mhvb4+2trZYsWLFiNt8+tOfjra2tpgzZ0488sgjR7UvHKvXX4/Yu7cW\n", - "YffcU/vAg9n7AAALaElEQVQ7Z8O9+GLt9eDo12CETZ361jbjFWHPPlt7/Xd/ZzSsnsH4EmGUyQMP\n", - "RHzoQ6mPYvwURcSGDfWnC48nwgbjS4TVVzfCqtVq3HLLLdHd3R1btmyJ1atXx2OPPXbQNuvWrYtt\n", - "27bF1q1b4x/+4R/i5ptvHvW+THw9CS96GhwBe/752rMg1649dJvBkbDhEXbgD/zxjLDLLqtNS/6n\n", - "/xTxv//36Pe9//6Ivr7xOa5BKc/dgUYTYa+9Vv8JGDkqy/mbrHbsqL2M1/8Pqc/fc8/VfpEdr5Gw\n", - "wfgqy2UGr7wSceedqY/iUHUjrLe3N1pbW6OlpSUaGxtj6dKlsXbYT7p77703brzxxoiIuPTSS2PP\n", - "nj2xe/fuUe3L2HrhhYi2thP7wyrlfyQHfpNv2xaxdeuh2wyOhA0+zfrf/ttDtxmva8KeeSbiz/4s\n", - "4gtfiFixIuJrXxv9vl/8YsQPfjA+xzUo9Q+BQaOJsE99KuKOO07M8UwUZTl/ZfPqqxH/5b8c/+P8\n", - "9re1H9zjNZKT+vwNxtdoIuxYQrRsI2EPPhjxmc/UppnLpG6E9ff3x4wZM4ZuNzc3R/+wM3a4bZ58\n", - "8skj7puLN9889Nqk8fDzn9diZNOmsXm822+vTaWNlzffjPgf/+Ota6eO1uBvWM89F7F9+6HD6r/6\n", - "VcSWLbW3X3qp9nqkCBvPkbB3vrN20XlExCOPjC74qtXaths2jM9xjYf/9b8iHnro2PYdnLYdfD2S\n", - "n/2sNj00HnburP/b/t69tW2OpKcn4qabxuigovZ9vHjxxJ7KTnHs998f8ZWv1P5PGMnzz4986cJw\n", - "v/1t7fVozv1ENPjj+MknR76/Wq39Ql+pjO4X+8cfj/jEJ9769xrLCHvlleP/GfrII7Xv87JNyNVd\n", - "rLUy/Glkh1Ec53fa1Vcf1+6l99RTtUD4d/9ufD/O9u215Rc++cmIGTNqI2NPPx3R3n74feqdusEf\n", - "qv/n/0Q0Nta+eM84I2L69Le2+c1varFzLF58sba8xH//7xHTpkW87W1Ht//TT0dMmVL74fzGGxFP\n", - "PBHxp39aC5033zw4Rl9/vfb6/PMPfZyVKyN+9KNj+xzqefjhiGuuiZg1K+Lf/Jvab2BXXll7u57X\n", - "Xqudx56e2uczym/Do/bEE7VjHK1qtfY5DH89MFD7+n7HOyLmzRvdY73+eu3C3SlTal+3Z54Z8Z3v\n", - "1I7njTciNm6MmDu39m8xZUrErl21Hxb//t/XPu5IL297W+1xTvr9r5bDv7Z37Kh9Xwz/9//Zz2rv\n", - "b2kZ+Vj/5V9q38MLFtSmiBsbI84559DtHn20tt1vfxvR0FA7juM5d48/XvuBdvnlBz+hZPDzeuKJ\n", - "iP/7f+t/Dw8+K/jll2vHdOaZx348R2vnztq/x3veU/t+3Lev9kPwne888r7PPx9xyilH/l4Z9PTT\n", - "ta+Vwem1P/iDiD//89r/K8Nt21b7Wrj88vrnZ+PG2v5/8RcRM2cefN+bb9Z+qF9ySe3fNaJ2Hp56\n", - "KuLcc9/6Ghy0d2/tuNra3nrfSN9/v/517f+o005767yO1euI2tduQ0Pt8+7vjzj99Ij/+T9Hvi6s\n", - "Wq390vq2t0X8h/9Qe/3ii7VzMtIvs48+WjvuRYsiLrig9oSks8+u/d+6a9eh29cz/Lxs2VL7Zf2S\n", - "S47ucQ60eXPteD784dq/cVEc28uYK+r45S9/WSxatGjo9le/+tXi9ttvP2ib5cuXF6tXrx66PWvW\n", - "rGL37t2j2rcoimLmzJlFRHjx4sWLFy9evJT+ZebMmfXS6ajUHQnr7OyMrVu3xs6dO2P69OmxZs2a\n", - "WL169UHbLF68OFauXBlLly6NDRs2xBlnnBHnnHNOTJky5Yj7RkRss5IbAJChuhHW0NAQK1eujEWL\n", - "FkW1Wo1ly5ZFR0dHrFq1KiIili9fHldddVWsW7cuWltb4+STT45vf/vbdfcFACCiUhQT+bJPAICJ\n", - "KemK+RZzLbe+vr543/veF+9617vioosuim984xsREfH888/HwoUL44ILLogrrrgi9hzwtJWvfe1r\n", - "0dbWFu3t7XHfffelOnR+r1qtxty5c+Pq3z/7xbmbOPbs2RMf/OAHo6OjIy688MLYuHGj8zeBfO1r\n", - "X4t3vetdcfHFF8dHP/rReP31152/kvr4xz8e55xzTlx88cVD7zuWc/WrX/0qLr744mhra4vPfOYz\n", - "o/vgY3Z12VEaGBgoZs6cWezYsaPYv39/MWfOnGLLli2pDocRPPXUU8UjjzxSFEVRvPzyy8UFF1xQ\n", - "bNmypfibv/mbYsWKFUVRFMXtt99efOELXyiKoij++Z//uZgzZ06xf//+YseOHcXMmTOLarWa7Pgp\n", - "iq9//evFRz/60eLqq68uiqJw7iaQG264ofjWt75VFEVRvPHGG8WePXucvwlix44dxXnnnVe89tpr\n", - "RVEUxYc//OHiH//xH52/knrggQeKTZs2FRdddNHQ+47mXL355ptFURTFvHnzio0bNxZFURRXXnll\n", - "8eMf//iIHzvZSJjFXMvv3HPPjUt+/5zgU045JTo6OqK/v/+gBXpvvPHGuOeeeyIiYu3atfGRj3wk\n", - "Ghsbo6WlJVpbW6O3tzfZ8edu165dsW7duvjEJz4xtIyMczcxvPjii/Hggw/Gxz/+8YioXWN7+umn\n", - "O38TxGmnnRaNjY2xb9++GBgYiH379sX06dOdv5JasGBBnDls/ZajOVcbN26Mp556Kl5++eWYP39+\n", - "RETccMMNQ/vUkyzCRrMQLOWxc+fOeOSRR+LSSy+Np59+Os75/UJJ55xzTjz99NMREfHkk09Gc3Pz\n", - "0D7OaVqf/exn42//9m/jpAMWLXLuJoYdO3bE1KlT42Mf+1j80R/9Udx0002xd+9e52+COOuss+Kv\n", - "//qv4w//8A9j+vTpccYZZ8TChQudvwnkaM/V8Pc3NTWN6hwmi7DRLgRLeq+88kp84AMfiDvuuCNO\n", - "PfXUg+6rVCp1z6XznMY//dM/xTvf+c6YO3fuYRdTdu7Ka2BgIDZt2hR/+Zd/GZs2bYqTTz45br/9\n", - "9oO2cf7Ka/v27fH3f//3sXPnznjyySfjlVdeie9///sHbeP8TRxHOlfHI1mENTU1Rd8Bf6G4r6/v\n", - "oIqkHN544434wAc+ENdff31cc801EVH7rWD37t0REfHUU0/FO3+/BPbwc7pr165oamo68QdN/OIX\n", - "v4h77703zjvvvPjIRz4SP/3pT+P666937iaI5ubmaG5ujnm//xMEH/zgB2PTpk1x7rnnOn8TwMMP\n", - "Pxx//Md/HFOmTImGhoa49tpr45e//KXzN4Eczf+Vzc3N0dTUFLsO+NMAoz2HySLswIVg9+/fH2vW\n", - "rInFixenOhxGUBRFLFu2LC688ML4q7/6q6H3L168OL7zne9ERMR3vvOdoThbvHhx3H333bF///7Y\n", - "sWNHbN26dWh+nBPrq1/9avT19cWOHTvi7rvvjve///3xve99z7mbIM4999yYMWNGPPHEExERsX79\n", - "+njXu94VV199tfM3AbS3t8eGDRvi1VdfjaIoYv369XHhhRc6fxPI0f5fee6558Zpp50WGzdujKIo\n", - "4nvf+97QPnWN4RMMjtq6deuKCy64oJg5c2bx1a9+NeWhMIIHH3ywqFQqxZw5c4pLLrmkuOSSS4of\n", - "//jHxXPPPVf8yZ/8SdHW1lYsXLiweOGFF4b2+cpXvlLMnDmzmDVrVtHd3Z3w6BnU09Mz9OxI527i\n", - "+PWvf110dnYWs2fPLpYsWVLs2bPH+ZtAVqxYUVx44YXFRRddVNxwww3F/v37nb+SWrp0aTFt2rSi\n", - "sbGxaG5uLu66665jOlcPP/xwcdFFFxUzZ84sPvWpT43qY1usFQAggaSLtQIA5EqEAQAkIMIAABIQ\n", - "YQAACYgwAIAERBgAQAIiDAAgAREGAJDA/wckYxa5Es1/mgAAAABJRU5ErkJggg==\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "feat = net.blobs['prob'].data[0]\n", - "plt.plot(feat.flat)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's see the top 5 predicted labels." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['n02123045 tabby, tabby cat' 'n02123159 tiger cat'\n", - " 'n02124075 Egyptian cat' 'n02119022 red fox, Vulpes vulpes'\n", - " 'n02127052 lynx, catamount']\n" - ] - } - ], - "source": [ - "# load labels\n", - "imagenet_labels_filename = caffe_root + 'data/ilsvrc12/synset_words.txt'\n", - "try:\n", - " labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\\t')\n", - "except:\n", - " !../data/ilsvrc12/get_ilsvrc_aux.sh\n", - " labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\\t')\n", - "\n", - "# sort top k predictions from softmax output\n", - "top_k = net.blobs['prob'].data[0].flatten().argsort()[-1:-6:-1]\n", - "print labels[top_k]" - ] - } - ], - "metadata": { - "description": "Extracting features and visualizing trained filters with an example image, viewed layer-by-layer.", - "example_name": "Filter visualization", - "include_in_docs": true, - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.9" - }, - "priority": 2 - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/examples/hdf5_classification.ipynb b/examples/hdf5_classification.ipynb deleted file mode 100644 index e98d13dd501..00000000000 --- a/examples/hdf5_classification.ipynb +++ /dev/null @@ -1,6290 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Caffeinated Logistic Regression of HDF5 Data\n", - "\n", - "While Caffe is made for deep networks it can likewise represent \"shallow\" models like logistic regression for classification. We'll do simple logistic regression on synthetic data that we'll generate and save to HDF5 to feed vectors to Caffe. Once that model is done, we'll add layers to improve accuracy. That's what Caffe is about: define a model, experiment, and then deploy." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "\n", - "# Make sure that caffe is on the python path:\n", - "caffe_root = '../' # this file is expected to be in {caffe_root}/examples\n", - "import sys\n", - "sys.path.insert(0, caffe_root + 'python')\n", - "\n", - "import caffe\n", - "\n", - "import os\n", - "import h5py\n", - "import shutil\n", - "import tempfile\n", - "\n", - "# You may need to 'pip install scikit-learn'\n", - "import sklearn\n", - "import sklearn.datasets\n", - "import sklearn.linear_model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Synthesize a dataset of 10,000 4-vectors for binary classification with 2 informative features and 2 noise features." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAiMAAAImCAYAAACB54oCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXd4HPd57/uZme2LbcCid5AgCPZeVCja6qIKrViWbcmJ\n", - "jhLLshM7Tuyce+95ro99zuPclOPYThxbyoks+cgy1TslFlFi7yBAggQBEHXRge29zOzM/QMURIqU\n", - "REkESUv7eR4+WM7sb/admd2Z77y/twiappEjR44cOXLkyHG5EC+3ATly5MiRI0eOzzc5MZIjR44c\n", - "OXLkuKzkxEiOHDly5MiR47KSEyM5cuTIkSNHjstKTozkyJEjR44cOS4rOTGSI0eOHDly5LisTKsY\n", - "EQThF4Ig7BIE4ZfvW24SBOG3giC8LQjCv06nDTly5MiRI0eOK5tpEyOCICwBrJqmrQEMgiAsO2P1\n", - "94A/aJp2vaZpfz1dNuTIkSNHjhw5rnym0zOyEth6+vU2YPUZ664D7hQEYbsgCHdMow05cuTIkSNH\n", - "jiuc6RQjTiB6+nX49P/fZQawEVgH/EgQBGka7ciRI0eOHDlyXMHopnHbYcB++rUDCL1v3U5N02RB\n", - "ELqBYmDkzMGCIOTq1OfIkSNHjhyfITRNE863fDrFyH7gW8DzwPXAE2es2wcsFAShBagBJs63gVzf\n", - "nM8XgiBc9nO+ceNm9u8fpapq/pQ9Hk8r11xTwW233XTZ7Orp6WHfviP4fGFmzCjnqqtW4Ha7L5s9\n", - "F5Mr4bxfarLZLEePHuPQoeMoSpaFC2exfPlSzGbzR47ds2cfGzcep6ZmMaIooWkaw8OdNDQYue++\n", - "L18C6y8On8fz/knQNI329nb27z9KNJpg9uwaVq9ejsPhuKDxiqLwr//6GOl0OW53GQCZTIrh4SP8\n", - "xV+sY8aMGdNp/lkIwnl1CDCN0zSaprUAKUEQdgGKpmlNgiD82+nV/wT8PbAH+E9N05TpsiNHjgsl\n", - "lUpx6FA7FRVzpn40giBQUTGHgwfbyGQyl8Wuw4eP8NhjGxkasiCKs2hpifGb32xgbGzsstiT49Oh\n", - "aRovvPAazz9/mHi8FEWpYcuWbh5//GnS6fRHjt216whlZXMQxcnZbUEQKC9v4OTJIUKh0IeOz/HH\n", - "xzvv7OTJJ9/B53MhCPXs2zfBI488dcHnur+/n0BAmBIiAAaDCZutlv37W6bL7I/NtKb2apr2fU3T\n", - "1rybMaNp2vdO/x3TNO1mTdNWa5r2xIdvJUeOS0MqlULTdCSTKUZHRwkEAqiqhk6nR1UlUqnUJbcp\n", - "nU6zadMeysqWUlBQitmcR2npDESxim3bdl9ye3J8egYHBzl6dIja2qXY7QVYrQ6qq+czMqJx4kTb\n", - "1PsmPR7DtLe3TwnPbDZLIpHGZLKctU1BEJAkE4lE4pLuS47pJRwOs337Uaqrl+NyFWE251FR0UAy\n", - "WcDevQc/dKyqqng8Hk6cOMH5Ll1mcx6BQGSaLP/4TOc0TY4cf1RYLBYG+zs4fmAAh8GMomlIdjsN\n", - "8+dit+vJy8u75DZNTEwgy0aMxrPd9253OR0dO9A07UNdnzmuPAYGhtDpCs45bzZbCe3tvSxduoR4\n", - "PM4rzzxDsLcXqygSVVVKGxu58557qKgoIhicwOUqmhory2kkKUVBQcGl3p0c08ikCLUjSWffqgsK\n", - "yjl5so11684/zu/389Lvf4/i9ZJOJGg95CGT0jN3/gJEcfJ7FwqNs2pV5TTvwYWTEyM5cpzmSFMT\n", - "lboUmpjAaarBYrQx5B9h3642/vFnP0QUL33BYqPRiKbJ5yyX5TRmsyknRP4IsVhMqOq5U36ZTAqb\n", - "bdLjsfWNN8DjYXV19dT64+3t7Hz7bW6++Voee+xVVDWL01lIIhHF6+3gjjtWYjQaL9l+5Jh+DAYD\n", - "mna+70oSq9V03jGapvHyH/5AUTxOxenvTyKWZmfzNgxGPTPrZzExMYheP8GqVTdPq/0fh1w5+Bw5\n", - "TtOyZw83LFrAnVfXYjEN4Y8cobIwwpIZFoqKCi+LTUVFRVRW2pmY8Ewt0zSNkZEOrrlm0WWxKcen\n", - "o76+Hr0+TDz+notcljOkUsMsXjyPWCxGf2srs8rKzho3u7yctkOHqKio4KGHvkRxcZTx8b0YDB7u\n", - "u+86rrpq1aXelRzTTFVVFS6XRjD4Xo6Hqmbx+bq56qrF5x0zPDxMZnycisL3rlnXL5nPumWFeLo3\n", - "MzGxjzlz9Dz88NdxuVzTvg8XSs4zkiPHaRKxGGa7nZqSEmpKSqaWNw0OXpZ4kXf5ylfu5Pe/fwGP\n", - "ZxxBMKNpERYtqvjQm48sywwNDaGqKhUVFbkn5iuARCLByMgIOp2Or371Zp57bit+vwWQEIQQd9yx\n", - "mqqqKvx+P3pBOMcTp9fpEBQFWZaprq7mwQerz/9BOT4zSJLE/fd/iSeffAmPZwBBMKJpIa69tpEF\n", - "C+af8/5EIkFnZyeRcJisqiKd/g7pJIlls2dBcSHf+3//5lLvxgWREyM5cpympqGBkb4+Kovem4tP\n", - "yzJJSaLojGWXGpfLxV/+5YMMDAwQj8cpLCykuLj4A9/f29vLG08/jSGZRACSej3X33038+afe/HK\n", - "cWk4eOAA+958E5uqogCq3c599/0JiqKQzWaprKzEZrMB4HQ6EfLyiCYS2CzvBar6wmHsJSUXlP6b\n", - "47NDSUkJf/u3D9Hf3086naakpOS8sUGHDx5k75tvYkil6Dx6lNDwMGtWraL4tPdjxOejdt68S23+\n", - "BSNcqXnegiBoV6ptOaaHy113YGxsjGcffZRyUaTY6SSWTNIVDLLirrtYtXqym4Hf78fv92Oz2Sgt\n", - "Lf3Q7cmyzMDAANlsloqKCiwWy4e+/2IQiUR44uc/Z77DgcNqBSCeStEyMcFXv/vdDxUxl4vLfd6n\n", - "i3g8zsjICGNjYzRv3MjyqiqMej0wKSy6ZJlv/uAH5/VaHTxwgFcff5w6h4P6igpCsRh9iQR3PPjg\n", - "Ja0LMZ38MZz3aDTKyMgIBoOByspKdLor8/nd4/HwyqOPsqy8HJPBQEd7Oy0HDuDT6bhn3Tri6TRj\n", - "osjXHn6YwsLLM+UMU+f8khc9y5Hjj4qSkhK+9p3vcGjvXtq6u7EVFHDz+vU0NDQgyzKbXnuN3uZm\n", - "7KJIXFXJr6tj/Ve/ivX0Tf9M+vr62LBhI8mkERCRpBi3334ty5cvndZ96Ghvx6koU0IEwGoyUaLT\n", - "0XbsGMU3Xb7CbZ8nzvSEtLS14UgkSObnYzz9lOp2OBj0eOjt7aWxsXFqnKZpbN++i3feaSFiaODN\n", - "zh44uY/b7/gC9zzwAOXl5Zdrlz537N69l61bD6FpdjRNxuFQue++u67Ic3D00CGqrVZMBgOhYJBR\n", - "jwe7Xs/gyAiPvPIKN9x9N9/48z+/orOtcmIkR44zKCoq4vYvfemc5Xt37WKiqYlramqmMlg6BwbY\n", - "9MorfPm++856bygU4uc/fxxJrMVdWEpBQQGpVIKXXtpNaWkxFRUV02Z/IhbDrNMRDocZ8nhIxmI4\n", - "CgqQrFai4fC0fe7lYHx8nKNNTQQnJiitqWHRkiUXXJXy/cjyZMaS/rTn4tPQ19fHgVdfZWVFBUa9\n", - "ngmPB3smQ8v+/Vx7443oTn+GEUgmk2eN7ejoYOvW41RXr6aqSseCBWsJBMbwRQYu2KsVjUbp7u5G\n", - "URQqKyspOSP+KceF0d3dzZtvNlNZuRqdbvJ8hcM+nnzyZX7wg4cwGAyX2cKziYfDuE0mEvE4W15/\n", - "HcJhDJJERUEBdatWkQ0GiUajOTGS46PZuRP+4R8gEIA774Qf/hBM58/cynGJUVWVY/v2say8/KxU\n", - "2lllZew+eZJwODx1EwwEAvzLT3/KqcNe8oQgh/x+otksFeXlSCZ45eWN/NV3H542W8urqtgzMkL/\n", - "0BBOScJsMBDw+Tgei/GVtWun7XMvNadOnWLT739PqU6Hy2JhqK+P4/v2ce9DD30sN7Tf72fHli30\n", - "nTyJIAjMXLCAtTfddMGiZrIIWQKz2Tzlwj966BA1eXlTUzJFRUX4fD4Uv589u3ZRVFREaXk5IThH\n", - "YOzffxSXa8ZZdSXy80sYGBjC4/F85BTNybY2tj77LM5sFgnYr2k0XH01N912Wy4N/GNw4MBRbLaa\n", - "KSEC4HC48XgG6O3tZfbs2ZfRunPJ6nQ8/eyzBHp7MUSjVFksaAYDndksCZuNa1au5Njhw9TU1Hys\n", - "7cqyTDqdxmq1Tvv3JydGrgD+8IdJ8fGzn0F1NfzLv8B118HmzXAFZV59blEUBSWdxvS+pyFBEDCK\n", - "IqlUaurmtenll0kODOEdjjCRCpJJxYln9ZzwpXG59Gz43/vQ63Vcf8Na6urqLnrtkqqqKnp9Pqoy\n", - "GUrz8xEFgVgqhc5iwTsy8tEb+CMgm82y7eWXmZ+fPzUd5XY4GBgfZ+fWred4qj6IeDzOM489Rkkm\n", - "w3UVFWhAX1sbzw0P82ff+c6HPv1qmkZTUzPbtu0nkchiMAisWbOYa6+9mlgoRMkZcSB15eXs3L4d\n", - "aWKCOqB/dJQNG99EqarD0TCHW265cSpAOhyOYTKVnecTjR+Z0RWNRtn63HMscbuxnn6Syaoqh/fs\n", - "oWbmTBoaGi7ouHzeSSQSnDjRjt9fQCKhUFJScsZ3wXBZM+veTzKZ5OWXX+XRf/ol8dEBChMxaiZX\n", - "MKJplDgcWCYm6B8Zoaa29oK3K8syb7+9kwMHjqMoAi6XiVtuWcPcuXOma1dydUYuN8ePw/e/D9u2\n", - "wX33wTXXwEsvwapVcNddcJnaoeQ4A4PBgLu8nIlg8KzliVQKxWAgPz8fmJyeOX7oMC1tw0TiKSZi\n", - "BsYzxaiUgmLHOxEn6IXnn9zI44+/xYYNL6IoF7ctk9/vZ1FDA5WLFtGpqpxUFByzZvHlm29moLMT\n", - "VVUv6uddDnw+H1osdlZcDEBFYSGejo4LPqZtx49jjUSoKS5GFEUkUWRmWRmC10tnZ+eHjm1pOcqL\n", - "L+7DYplPZeU1uFxL2bSpje3bd1Hd0MDYGX1Dgl4vc1wu5JISjqfSbOgYplueSV9/Bb/5zSG+/e0f\n", - "09HRAUBjYy1+/9miUVWzaFroI6dbent7ccjylBABkESRKpuNE0eOXNAx+bzj9Xr51a+eYGgowalT\n", - "IzQ3D7J9+35isRiqqqJp4Y8MXL9UhMNhfv3r3/Hvv3gFS7qatFDLuGCkTRAYEkVUWWaR241DUeg4\n", - "dYrqWbMueNuvvbaJXbs8FBauoqrqWgShnqeeeouenp5p25+cGLmMqCo89BD8/d/D3LnvLRcE+MUv\n", - "wOGAv/u7y2dfjve47tZb6YxGGfJ6ScsyE8EgzSMjXHPrrej1ejRNY3R0lKbj/Vi1SkrydCSzXsyS\n", - "nYyqI5IexyjFqSlcTiAQobx8EW1tQVpbj19UOyVJQpAkFs2axZduuom7b76ZZY2N6HU6JJ3uM+Gq\n", - "lySJ7HmyMLKqiiCKF+xtGhsaouA8wcdOgwHv6OgHjtM0jW3bDlBaugCzebJFgMFgorJyIbt3H6Vx\n", - "7lxiDgenhoZIptP0dHcTUVXmzJtHIGvH5voitSXXUGirxO1eQDBYziOPPIWiKKxatQyzOcDwcBep\n", - "VIJIJEB/fxOrV8/+yPl+RVGQznN+9TodmSvoaf5K5rXXtqIoFaxYcStut4YoyqRSBg4fPkR//xGW\n", - "Lau7YjLStm/fQyTiJB0WqHAVY9XbydcX4pLMlBsMFIkiyUSCQCqFbDKxaMmSC9puMBikubmX6uqF\n", - "6PWTHqG8PCdO5yzeeWf/tO1PToxcRl55BWQZ/uIvzl0nivD730++Z8uWS29bjrOpqanhyw8/jFxT\n", - "Q3M4jD8/n1sffJAly5YxPDzME7/+Nc/++78THxllPNRHgdWOWYwj0otGD4IQpsxSTkaBhKyRzSrk\n", - "51fT1HTiotpZVFSEpbiYUb//rOVdo6PMX7nyMyFGCgoKsJeXM+T1nrW8a2SEOcuXX7AYyS8qInKe\n", - "m3RMlhF0Onp7e/G/7zjCZEPFSCQ1JUTeRa83kM1OXry//tBDFKxaxdF4nD5RpHTuXAS9nkGPB12k\n", - "h/DoDiKh4yhKGqezgr6+MOPj4zidTh5++OusWOEilTqB2TzMvfdexW23fXQWVGVlJQFNQ8lmz1o+\n", - "FAoxa8GCCzomn2ei0Sh9fV7c7nJMJitr1txEXZ0Zo3GUQKCV22+fz1133fqR28lmswwODtLX1/eR\n", - "XZg/DS0tHZSW1qEzGhgJDaBmxggoUeKKSlQQGNc0BrNZJux2/vRv/uaCe2uFQiFEMe+ca4Xdns/w\n", - "8MQHjPr0TGvMiCAIvwCWAs2apn3/jOU/AdYDQeA1TdN+MZ12XIloGvz0p/DjH08Kj/PhdMLjj8MD\n", - "D0Bray5+5HJTUVFxTjxCJBLhxccfZ6bBQEVFBdGaOk51DTM40YXJlIeolIKogeBjOK2gjAfQ2XTs\n", - "3LmJOXPmYbdPzvsePdpKZ2c/NpuFpUvnf+xAs3cRBIHbv/IVXvzd7xjzeCCZpGfCi+zMZ15hIbIs\n", - "X5SMkcuJIAis+/KXeeF3v2PC48EiCEQ1DXNlJWu++MUL3s68BQto3rEDXziM+3TMz8D4OLt6BnFn\n", - "jmA09qJpcebPr2T9+nVT9UCMRiN5eXqSydhZgiSbVRDFDFarFZ/Ph6yJCDYXlvIZ7Dl2FDEwykxB\n", - "xG20o2owkgoQ97dgNl+NpmlTIsrlcrFu3c0f2ATtgygqKmL+2rUc3r6dyrw8DDodw+EwhpqaXMG7\n", - "C+Ddmifv3oTN5jzmzVvJ3Lkag4O7Wbx4EZIknTMulUrR2nqckyd7SaVi9PWNYDAUAiKCEGXu3CrM\n", - "5jwKChzMmzf3E2d8vR9JElHVLK4iC4lmD0utTiY0gYnkEGoigc5iQSwqYvX69dzwMVL67XY7mhY/\n", - "pwlnLBaipMR9UWw/H9NW9EwQhCXAw5qmPSQIwm+AxzVNazq97sfAHk3T3v6Q8Z/pomfbt8Nf/dVk\n", - "zMhHPch973uTWTZPPXVpbLtc/DEUQXo/2956i70bNlDicKCXJJr3HCQZUeic8DIgOlCyZWQyetJy\n", - "CpujDqMlTsPsuVit+Xi9u/jRj75BW1sfXq8eh6OEdDpJIjHInXeuYPXqT95rJJ1Os3nzFl595R2s\n", - "eTW43ZWk035qakz86Z9+BdMVlKr1Sc97JpOhu7ubSDhMYVERNTU1571ZfBiDg4NsfvFFUn4/mqbR\n", - "H4iS1c9kzpzVU3Z5PMeZMUNkZl0Vkk5H/axZ9PcP8PLLh6ioWITBYEKWMwwNHWft2hmAxjvvnODU\n", - "qSBe72Q33cDYUWqiY2RTcXRiJTpjPo6CAkbUGBFbNatX5/Gzn/3kUwc0a5pGd3c3J5qbkVMpymfO\n", - "RE6l6G1rQ2cwsGDlSuYvWPCxj9N0cCX+3v/jP57E73fhdr8XROz1DlFaGufBB79+zvuTySSPP/40\n", - "w8NgtRawffsWVNXN4sVzqKoqZceOTUxMhLj66qswGkV0Oj8PPLCe6upPV8o/nU7z639/hF2bDzPu\n", - "6cAcSaClslgEiaziRbTqEGfN4r//7GcsX778Y3tEn332JVpbI1RUNCJJOpLJGGNjx/izP7vpU2US\n", - "Xa6iZyuBradfbwNWA01nrP8nQRCCwA81TTs2jXZckTz2GHzrWx8tRAD+8R9hwQLYuBFuv336bcvx\n", - "Hqqq0tfXR++pU+gNBmbPnTsVSDg4OMjLv/0tzvFxgpJEZ38/WUmiVDSh2gzIogb5KpGYH1EqJZ0e\n", - "o6ioHoPBSSIRxuFw09vbh89norr6vSh1WS5h06b9zJ8/74Jdq+9H0zSOHu1j0eK7MZnejYuoweM5\n", - "zqFDTaxZc82nPTSXHYPBwJw5ny66v7Kykr/467/G7/cjyzKPPvoMxcVnX7xjwQCbn9jEXWtWIOp0\n", - "NG3axIp167jjjiW8885hMhkRUZT54hcXMmvWDB599FUMhmpSKY2ammo0TSU43k9lQxnh0VPE42Ek\n", - "vYF0WiAdH8NWJvK97/2vi5JZJQgC9fX11NbW0tbWxu8feQRjLMay2bOxmkwcePZZPD093Pknf/KZ\n", - "mLK72KxffzOPPfY8g4NBTCYHyWQIqzXG7bffc973Nze3MDIiUlMzn8HBUxgMFbhcs2hv7yUYHECW\n", - "iygoqCORgJkzG4lE/Dz//Jv87d9+6xOfb1mWefb//B8so0MIvk6SQ6ewixI6yYBiMrDomtXcddNN\n", - "HB4fp7Gx8ROd5/Xr12EybaOpaR+gw2IRuPfe66Y1pXk6xYgT6D39OgycEaLJv2ma9j8EQZgJPA6s\n", - "mUY7rjgCAXjjDfjVry7s/RYL/Od/wp/+KVx77WRga47pJ5vN8toLLzBy9CjFJhNyNsvRt99m9Z13\n", - "snzFCjY++yyL3G5SkQhpv58lNhtjioKY78Qty9xcUYlYWUFJ/QLGxiyYTA7GxrzIskJR0SzS6UJO\n", - "nmyjru7seehEIsLAgI8339zEDTdcP5Wt83EYHBxElq1nCJFJCgtraGpq+0yIkYuFIAi43W6i0SjZ\n", - "rHhWbQmvd4hk33Ea7PlUFxVhsViolWUOvvkm933/+6xYsYxYLIbFYsFoNLJ581sEgzAychJZNqNp\n", - "KoIgYrbW4E300jhjEeVlEql0inA4Rr6umu/+fz/9xNNy5yOdTvPCU0/RtXs3pt5enDYbB/bvZ+my\n", - "ZSyrreVASwvDq1ZNa/G9P1aKi4v5679+gOPH2xgb81Fa2si8eXM+8KHg2LEuCgoqAUinkwiCCUEQ\n", - "0TQT3d1tVFRcTyqVJB6fLG5ntxcwMNDF+Pj4J87K6ejoINXXx/DQEMmxYRboRVySxJiaobC0HGSZ\n", - "8VAIyWL5xC0ojEYjd921jptu+iKpVAq73T7t3rTpFCNhwH76tQOYynXTNC14+m/3h6m2n/zkJ1Ov\n", - "165dy9rPSNGmDRvgttvg49xjvvCFyTH/9b/Cf/zH9Nn2WUdVVcLhMEaj8SN/qO3t7Yy1tLCytnbq\n", - "6aJGltm/cSN5NhtaMMjchgb2DA7i8/koM5uxKwqHhoaYvXgxt163huaxMSoqChke9pGfX0d+/mRG\n", - "RDA4wcDASaxWlXR6Mhhy0puxh8OHD+H1Bmlv7+PVV3fxrW/d+wnFw/ld4Lkn4kk0TWNkZIQBjwe9\n", - "Xs+MmTNxOAzE42Gs1knFPzF0CpcoYjZJU1NbBr2eQlGkp6uLVVddNdWGfWJighdffJOODgPJpJVg\n", - "cJhgMEB9/XzMtjzaByYY8vqoT7hZs2w29opyZjU0TNX/8Pv9DA0Nodfrqa2t/cQN8ZqPHCHZ3U2p\n", - "IGByu7FZLJTKMkeamykvLMQlCAwNDubEyAeQl5fH6tUrz7sum83S398/Vc3UYNARi01W73U63ahq\n", - "/+l3qoji5O8slYpSX3/xMnB6OzpoP3qcw4cOszCrYZJMqJkELr2eIx4vgl+mOfAWf/433/7Un2U2\n", - "my9ZY8bpFCP7gW8BzwPXA0+8u0IQBJumaVFBENwfZsOZYuSzxPPPf7KU3X/+Z5g/fzLe5AtfuPh2\n", - "fdZpazvJG2/sJBpVEASFBQtmsG7djR/4Y2tvaaHK6Tzr5m3Q63FpGh6PZ7LomdFIdUMDzQcOEA6H\n", - "0QQBnyRRarOhE0VkTWPJkkV0dLzK8HAXBQVlNDXtoru7j4KCQtxuC5s3P81tt91HPB5m+/YdCEID\n", - "dvtsqqvr8Pk8/OM//icNDfUYjUba2zs4deoUExMRzGYr8+fPZNmyJef0x6mqqsJgSJwTZDkx0cdt\n", - "t83l846qqrz52mv0HTpEviShaBq7RZGGpcvYf+A4Tucs7PZ84tEQanycq5ctO8etnj2jZoumaTz/\n", - "/BsYjTWEwzvx+zUikQzBoItAYBQYobj4OhIRLz7VxtP7R7lm7Uz+n3vvPZ0qvJ2dO1vRNCeQRdNe\n", - "Z8mSmRQUuKmpqaK6uvqC3fonm5qoLSxkIBhEPp1ZY9brsakqY4EAGU3DlOv8e15isRgdHZ1EozEq\n", - "Ksqoq6ub8ggEg0GefPIFJiZUBMGMpkUxGuNEIj7s9gLy80spLjYzNHQMg0FHXV0t3d3HKCoqoKJi\n", - "sp9NJOLH6RQ/VXrwkZajNB85RpGsYEJDp4p0KiLdSScGQzFRxUTAWMS///p1jrX2cv/9X5rWYmUX\n", - "i2kTI5qmtQiCkBIEYRfQomlakyAI/6Zp2veA/yUIwjwmU4v/r+my4UpkbGwyM+bGGz/+WIcDHnlk\n", - "MhW4tRXOUyIhx3kYHR3llWef5YUX9+B2z6N+zgLKKso5dqyLWOwVHnjgax97m4qi0NTZS//hVmKj\n", - "gzRUViIlk8iCQLHbTXp0lP2trZSuXk1ZWRnf/ObX2bVrH6+88hIDA2nmzFmBpmnodDpsNpWtW39P\n", - "NisQi9mw2UyUlZWg11soLGykr2+MJ598imhUoqtrjIGBKAZDPhUVBYyM9NLc3M5DD913liAxGo3c\n", - "c89NbNiwBShErzeRSvmprTWzfPmyi3h0r3wSiQTBYJC8vLypTIaOjg48Bw6wqqZm6iYfT6VoaWnm\n", - "a1+7m4MHWxkZ6aC6wYGUV4HL6aCnpxefz0844OOEz8cSoxG7w8G8efPw+Xy0t3vo6YkRChlJp63o\n", - "dBKp1ACJxDA2WzX19TZuuGEVRUXFhMMhxsebCJ7uGfL2221UV69GknSMjY2xZ88ge/Zs5JprvkAm\n", - "04IoBnE6CzCZjKxcOZ8VK5Z/aFaUIAiUV1VxzOPBkc1O3lA1jVgyScRkor6+/pIc+09KMBjk5Ml2\n", - "Eok0tbWV01Kt+P14PB5+97tXyGQc6HRmFKWdurpD3H//l4nFYvz4x/9MR4eG213OjBlFVFbOYWDg\n", - "BGbzEAMD+xHFfIqLC4A2CgsLMJkEdLokdruJYHAMv38MSfLy7W9//RPvSzwep3X/YWQkNEXFp2TQ\n", - "ayKerAOrVIMm6YlmNWYWz8ftdtPXN8xTT73FQw+Zqf0YFVgvB9Oa2ntmOu/p/3/v9N/pa85xhfPy\n", - "y7BuHZyna/gFsW4dPP00/OhH8POfX1zbPouMjo7y3KOP0nuim4aC2Rh1JnqPHCERjzN7zhy6uvYx\n", - "Ojp63vnb2YsWsbetjWKXa8o7kpFl+sJhju04jqNyDZ2HN2OJZNB0EBFkopLIYoOBkUyGVCzGA+vX\n", - "A+BwOLjZkGjqAAAgAElEQVTjjls5caKHWCzB4V0HMGiTxbtUg0BZjRFFGQNKEEUTw8MBvN4ANTWV\n", - "CIKNbdsOsnbtNwiHx6iuXosoSni9/dTUOPD7IzQ1NXPdddeeZX9jYyPf/34RbW3tRKNx6urmUF9f\n", - "f8W2Qb/YqKrKznfe4eiuXViARDZLzcKF3HbXXZxoaqLG6TzrpmA1mbCdLnn8zW/eD0y65X/zy1/y\n", - "mxffIC9rxjs6RkRLUTWrijl6PTv/8Aeit9/OjPp6urs9yPIs7HYnBQV5JJNhUqk8gsFxamsX0tBQ\n", - "hcViZceOfaRSIpGIl3/4h19RXV2G3V6DJOmQZZmmpjZcrgaiUT0g0t+vMjoaZvXqSioqZrJx40l6\n", - "e4e4//57zjvl1rh0KR1vvMHCmhqq58+n98QJJEXhVDKJSa9n/X33nbfT9JVCW9tJnnlmK4JQiCga\n", - "2L69g9mz8/na1+6etrR0RVF4+unXycubi832Xg2Fnp5WtmzZxoEDrbS2higr+wLZbJYjR/oIh6M0\n", - "Njbg84V46KEvMTIyislkZMaMr0/FmKTTafbs2cOGDa+TzeopLCzn6aff5M4717Jo0cKPbWd/fz/x\n", - "kRHSqRSDchJ3VkXWDKQFKxICASWLpWQeoVCCsjI7kcgp7PaV7Nx58PMtRnKcywsvwHe/++m28ctf\n", - "Tk7XfOUrk2Xjc3ww+3fsoEqno1vTkWeyo9cZqDYY6Dl1ipq6OkQxj0gkMiVGotEoXV1dJBIpystL\n", - "KViwgLf27MElSRjNZiI6HXGTg5KipTidhYiihCf9IjEE9EKcr990HYgisqKQrajA4/GwZ08L0Wic\n", - "xsYa2traaT8cptZZhiSKpFMJQrEwxw61U1RpQhCcZLMJNC1DNmugu7sPQRimrKyCZDIOOBHFSbex\n", - "1eqmv3+ExYsbOHGi5xwxApMFwv5YglUvpHOuoih0dXXR3t6D2WxkwYI5H9jS/fChQ3Rs28ZV1dXo\n", - "JAlVVWk/fpwtooiSyaA7IyAvkUrhDYfxh0JnFarKZDL4IiJ11z1Ay97tmMpczCmuJZb0MeIPUmaz\n", - "sun55/nmD35AJpNBUQRAhywLSJIDi8VCNltAXp6FWCzB/v1HSaetKIpKLBbj5Mk0b799gFWr1uN0\n", - "FuH3+1EUI3q9EdAzPDxCImGmtHQhw8ODzJq1mNraxXR0HMTj8Zw38HXpsmX0trfT1NtLkc1G8fz5\n", - "dIVCfHndOubPn4+iKIRCIZxO5yc6T9NJMpnkhRe2Uli45Izg6zra25tpaTnKihXLP9F2NU1jaGiI\n", - "RCKB2+0+p5rt8PAwsZiOqqqzizmVlMzgpZdewGyuRa+3I4o6dDoDBkMVvb29VFaWMTw8Sk9PL2Vl\n", - "pcyYMeOcQM+DB9uZNetmXK7J/kOpVILnntuB213wgXE7fr+f1tYT+P1hamrKmTt3DmazmY6ODtLe\n", - "UaolM1FLPhOJGGYtj4gq41dVdAUzKS+aQyIxTiTixWo1Y7O5GB3t/8hjFIvFOHDgMMeOnUKv17Fq\n", - "1QKWLFn8gQ8v0WiU4eFh9Ho9VVVVn1oo5sTIJSQQgMOH4eabP9123G7413+FP/9zaG7+5F6WzwMD\n", - "3d2sKiigyDnKWCCKM68AURAxCQLRaBRVjeJ0Ounv7+e5555n8+bDWK01p2MukkR9HVRY9XT7/aRE\n", - "kWU33shETxCnc7IzrNtdSXNKoEwxkZEjtBw4xuLFjaQlkYSs8dRTu3C7Z2IyWWhqGqGl+RjZuJ3h\n", - "jEIsEkZFh8lkIxP14e9OEk33EVKL0UkFaBKoYozGuTYkqZCmA2/i8YRRVTP5+WXIsoLP56OnR6S+\n", - "fvJG/e6FQ1VVTpw4wdH9+0knEsyYN4/lq1Zhs9ku5+n4QF557jl6jk+Wxq+bN4+1N900FRj6LrIs\n", - "84c/vEBnZ5i8vFIUJcTu3S9wxx0rz6nJomkah3fsYEFZGbKi0D00RCKZxOVw0N3SwuLrr6dn2zbc\n", - "DgfHenrZd2IYVbUxGAkQfX07paWlVFRUMDAwQDZro6qqkc6jpygrkIjEAwyOj/KbDVuZW+QCUeO3\n", - "gkBxcR6trf0MDiro9SWIIghCApfLTDzeQyikcrRliExSIBrrQc0O48qrweRysnfvERRFT03NpLCa\n", - "7EcTIJNxYzLZEQTQtPdiVETRydDQCG63G0VRsNlsCIKAKIoYjUa++sADdHV14enqIt9mY011NXve\n", - "eos3Dh7ELIpEVJXG1au58dZbr4iaI+/i8XjIZPLOyQJzu2s5fLjtE4mRcDjMU0+9xMjIZLaLpkVY\n", - "saKe22+/ZWrfJ3s2netlSiZTHD58nNLSfIaGBhkfN1NVVUV+fj6ZjMhrr72Ky6XwzjujRKPN6PVh\n", - "1q37InPnzsHtdtPd3U08bqK6umhqmyaTBZOpgqamYxQXFyNJ0lkeuu7ubp58ciOq6sZisdPScoyd\n", - "Ow9TWGjhp//tv5EIBggCAgITgCSYSAgKQp4Nd0HN6WwemURigEWLFhCJ+Kms/PAYlUQiwWOPPY3f\n", - "b8btno2iKLz0Ugu9vQPce+/d53jg9uzaxeGtW3EAMiDn5bH+/vs/VVB0ToxcQt55Z7IR3sWIHbvn\n", - "nsnqrE88AQ9/bie9Ppo8u514KsWSWVW8uLMdvc6A1WQjnVWYmOhm0aICXn11I08/vYmurggm0xIk\n", - "SSQQ8GGUojg1mYa5k9VVjQYD3tZW/EkDpaUpDAYT7e29ZCyNDIVOocYjBAcV3mprpby+mrzSeSxf\n", - "ee+US7y8fCZaxkU00ooolCFlzWgk8KU6yc8GQBUQ1SIEyYGs6lElPWkthX+sD+vgSarNLlLBEAPe\n", - "PvrzF6FlrdQWCRzt28upAxFamlq48ZYbuOmm62g+dIi+vXupy8/HZDAwtGsXTx07xv3f+tYVKUjS\n", - "J09y7WkPR39HB88MDvLAX/7lWcHFra3H6eyMUVv73g1Jlit4880DNDbOPutJX1EUUtEoMUFg1759\n", - "OGQZsygynM0yKIrc9o1vMFRby5bmZlraQ7jy6omqCjWz55FI2HjkkT/w3//7908X5RIAjWCgFzk0\n", - "ghyO4A+NUiplsVjLiClxXMEwwa52fD4boliCLAcxGPJwOCQEwUhRUZKD+58hErQjqBGM2TTV+kqE\n", - "eJpoOkE0z0dbm5n8fDPp9DgeTw951gjevl5icT16h5tFi2fg949isdgIhcb43f/eRl/3CD5fGJ1J\n", - "x7LVK7j99hu4/vrrsFgsNDY20tjYCMAffvtbTGNjzD1dbCurqrTs2cPhggJWrV49/Sf4AnnveJ/N\n", - "ZLGsT9bk8bnnXsPvt1FdPVkSX1VV9u9vprDwEFddNbnvZWVlGAwpUqn4lBBSVZW3396C3V6I3V5O\n", - "fb2L3t42urpi1NfPpL+/laIigTVrvobXG+bYMT/RqJ/u7leYM6eZm29ejslkQBDOveAnkzFeemkH\n", - "TU0dmEw6rrpqEWvWXI2qqvzLv/wng4NWVDWJw2GlsXEGr7zwJP4TW5BiYW4EjEAPGpVARPMT0rmJ\n", - "WkbQtBOMjrZhNEaYP/9mCgpKCQZPsmbNl857bBRFwePxcOjQYQYHszQ0NE6ts1qX0Np6gKuvHqKy\n", - "snJqeXd3Ny2bNrG6shL96YcffyTCK08+yTd/8IOpSsUfl5wYuYS89RZ8jKq8H4ogwE9+AvfeCw8+\n", - "CB/S7fxzzbI1a9j7zDMsq6nh9tUz2Huij87BMHKemVmzJnvD7NnTSyCQQVEM2GxudLo8/P5RtFSA\n", - "hDHChv7DzHTasZtFDHYr2fIqRkbacbnq8Hrj6M1l9He+Q0F6BFsEqsx5RIfGkNNlHMzsxl1Wweio\n", - "H1XNkkmLGJQMNt0YGTEPm6ijQA4QUxPEBAe1+hLMJgPxbAp/JkZCZyI9mmJGkY5MNES+aCCbCHOy\n", - "bwsmVzUZi5Vqm4mFtVfRNuHlrbe62Lx5BxWGJOuXLZu6WMyurKR9cJDmpiauuwJTsWaWvVfxckZp\n", - "KTGPh/aTJ1mydOnU8qNHO8jPrzprnF5vQFWdeDyes8SIXq/HWVzMW1u3Ms9oxHVagJVns3iHhujv\n", - "6eHeP/szfhGIo/NFyFpcRL0hoqMpRsayhEK9lJf/jm984+tIUhSPpx1zyks2GiWcylAhStRb8/CG\n", - "xnBWz6f71Ai2pIbNnMHlshKLxUgm+4lEQsxprEMZ76YwPIygjJNRFSyUoJMFdJIevaKAyYVODBGP\n", - "n8BgGKT75CnydS6MYho1MoFvVGRvdAGlFUESiQkGe3cwq2QR5kQFlcbZxOQY+3ccR68vZ3h4nG9+\n", - "8xtTT/1erxd/by9Xn1H1UxJFZpeW0rx795QYGRwcZMeOAwwMjFFU5GLt2pWXPNC1qqoKUdxMJjMp\n", - "9t/F5/Owbt3HL7g1MTGBxxOiquq9bBJRFCktnc3u3S1TYsRoNHL33TfwzDPbkKQSTCYrg4On0DQ/\n", - "a9feTkvLKfLzFzB7toXBwTaGhnZgsfi5++7/m0gkzMaNLyOKBQiCgRMnOpg1ayGbNh1h/fpVKEqA\n", - "8fFxotHJejR6vcbu3buYObORWCyP7u4Rjhx5ia6ubux2G8eO+amsXIRebySVirN1614mTh7AFItQ\n", - "C5QAJ4E5gAHoR0XIhtFFJEaUBHqjhcLCYvT6IDpdPw88cNt5K76OjIzw5JMvE43qaG1tJR53oap2\n", - "Zs+ehSAIpz1tLgYHh1AUhUAggN1up+XgQapttqlrC0CB3Y5pYIDe3t4pAfxxyYmRS4Smwdatk6Xd\n", - "LxarVkFDw2TdkgceuHjb/SyxcNEign4/+3buxAbU1JcyY9U8XCUl/P7x1/FOGEnE7JhMM8hkoni9\n", - "xyktXYWq6giHA8SzforyZmDRFxKKR5iY6CLc72XBKgN7977O4EAaOTTAAiOUmNyUGqwkMmmGExHG\n", - "4iG8J07R3h2lqrqeZDLG+HgQk6rQkAljkmSyQh7prEhMkAAROZMmq2TIqhqiBpmsjBE9PlkD2UKB\n", - "vRCrQSEZGcdHFqc+y4qGJSRTKRKD4wwFjKSzKnH5JPvSKqtWLZ16Uil1ueg7efKKFCPvJ99sZnx4\n", - "GM4QI6Ionnanvx/tvIGcDYsXs+fZZ9GfrpibymQYjURYuWQJnc3N3LJuHS6Xm8XL53DwYCvJpIFs\n", - "No0gKGiak/37e1ix4hS33XYVP/jWd3GHomixGPF4iBAaJqMOh8mAM9/BwEAEk95Mvr0IW2Ex4+M9\n", - "SFKGWEym/dhhrOkAquIGnFiANGZGtQkKFAsiYEybScVE+rraCQcc1OY1IKiQTCqMZ4Posi5inhSC\n", - "LgJkkVPlIIsgWLCYbRgUE4GxAEeajpBMzmLNms6p6rSpVArjebI3rCYTca8XTdPo6+vjt799Fat1\n", - "Bk7nMgKBEI8/vol77omxZMniT39CLxCr1cqXvrSWl17ahSSVYDCYiMfHqakxsWzZ0o/ewPtIpVII\n", - "wrlP6kajBa83cdayefPm8t3vumlpOU44HKO6ugybzUZNzRwymQwdHU1omh29Pk4iMYHV6mLfvrfp\n", - "7u4kHq/AYnGj0xmRJIGWljYaG6sZHZ1gcPAEJ07sR6fLx2DQE4n04nJV4PONMzaWJZnMw+9PcuzY\n", - "M8yYYcVun3M6ZghMJivxeBJrMoKChovJhm4mwAYkgSR6sriZUboMUdRw1y4nmx1ieHiIa69dOFUf\n", - "J5PJcORIC01NbSiKQmdnJ1VV11FdXY7fn2J4WKC9fQSn0z4VQ5fJxHhn8yYKslnygARwpKuLL8ya\n", - "xYljxxgfGkKUJMpraxF1OlKfojt0ToxcInp6IJOBT1m9+hy+9z34n/8zJ0Y+CEEQ+MINN7Bs5Uq8\n", - "Xi9ms5mWw4d548mnKdKVYjUrdAYC+DMhRElHNptHKjWOKOqJJfyUWiupdOoxSEa8cQNjkVqyBh8e\n", - "D8Ri5fi8bdhUEyEtToU+i2ASQNAgk6a3v4W0uhiz1UQ2cZSh8Q7SShpRquQocVzZIDMJk9TpQDOi\n", - "ynGiJMnLmsmioaBDyYJBTBGMSFj0DjIZGU3OYFJBL5voGYqwsDrM6IgPASt5Zid2s4vsaA/hsERn\n", - "RxcLFs4DJm/G5o9oQ3+lEEmlqHef3ZRr6dI5bNiwF6ezcEp8pNNJJCl0VqaAqqq0tbVx4MAx/KKN\n", - "5nAEVyyGLS+P2iVLKC0vZ//pjr+zZ9fwH4++TUdLF8m4Slazomg6VJ0Hnc7Nli27uXrlPBblWyk0\n", - "ieyIy+hpRMsInFSyFGVj5GfTaJqKotMTT4YJDnhIRMZJRuNEZTf5mo2oZENV8jEKcfJQJlMzcaPh\n", - "xa3LYzQSxBsfodS+nCK9DT1hfOE4dncpvmwFZjEfcypMaqwXq92KqLjpHx+jvqiIZDKJzxcG2cyA\n", - "ZwB/IMLAQBM/+tHfsXr1atxuN0lRJCPLGM4IMhzx+6msr0cQBDZt2onTOQeHY/KYu1xFmM1W3nxz\n", - "N/Pnz7ukzRWXLFlMWVkpra0nicUS1NevZvbs2Z/IhsLCQkQxjiynp27wAH7/CA0N53oLiouLueWW\n", - "yfiK0dFR2tpeAKChYTHV1bPo7j7G/v1pli//EtFolvHxUXp7Q+j1ZaiqQCYzgdWaQpKqGB4e5JVX\n", - "Wjl1youm2YnFMqhqiFhsDIPBjN1ej8+XIZUSMJlqiMdljh3bR2FhjGQS3O4ZmM0uTKY8gnIcAzAG\n", - "lAHq6X8xIIkdndFNvsvNWDpOIpHHyEiGSETHli2dHDrUS3m5kaamk0xMyMyevQiDwUFra4Z4vJWr\n", - "riqmunoGHs9ejMY6ensHKS0tJRYLMTTQzNpKO0vP8JAFBwbY8NJLrKuro9ZmI6tpjLW10a7Tccun\n", - "qJ+SEyOXiK1bJ2uLXOzil7feOtlwr6kJln2OykdomsbAwACBQACdTofD4cBut39ghoDNZsNmsxEI\n", - "BOg8eJBCqwNJdWAUZPIDcWKZJIrkJJkOkkhkyGYBScOkS+AwuPEnEgQSOiymUkYSw9jti8lmQkja\n", - "MDr0hDMGhlI9CIrCYDaCS5MpyWgMZfuIZMIEIhlkWYckOBGEEgz6LIH0ECeVdvRakjFkrFiYIEgc\n", - "C6AjTYYoAayqRlZ1EE2l0TIhyvML8ScESm0FBGNxWo8eBjnDhAYU1JInSSStdgS9hX7PKPPmTz7Z\n", - "HejspMxiYfu2bcxdsICioqLzHqvLwUQwSNG7lUyDQUJG4zmdZufOncvixT0cPXoQo7GQbFZG07z8\n", - "yZ984aw4mNdf38T+/R4cjlr0tiX45DA6R4Ib1izFZDDQNTzM7NMel+rqSib695KKglHfgKJmiYW7\n", - "0Gl+htuzPDfxFESuZ/WSJWzcvBNXwULMEY2ImGQ8EWE0A4eOH8GiVwjry4nFMhhCYxSlEqAWkmCC\n", - "oBBHogqDsYRUeoAYGdzECGMgSBS9miSqBHBbZZJpiTyDRDKZwmW24Q97UVU96WScwjwbemseNrsJ\n", - "/4SPVCJNKp0gFlGQdEYmIieIkSGedBMOW/jOd37FXXft4Yc//DYrbryRptdfZ5bbjd1iYTwYpD+T\n", - "4Z4bbiCVSjE6GqSqasFZx9tksuL1SgSDwUv+XSkpKZnqAfVpMJvN3HzzKl57rQmXayZWq51AYAxV\n", - "HeKGG77yoWNLS0uZO7eUEyeOUVragF5voqenG5erhgULFpFIJHjiia3odNXIsoSqgtFoxWLJZ2Ji\n", - "gljsEOm0hiQtwGh0YbNp1NU10Nl5iIGBfTidV5FKiVitk9csTcuQTlsJhewkk4MMDfVRUFCA3z9K\n", - "CJmZTJYxdzFZ3jwMeJFIYsQgmAgkwqjWciLBFFZrLaLoxWTKY3Q0wNatR7BaaygurqOjYwiTqR+b\n", - "rRaPZxi7fR8NDctYtKiRI0eaSaWyNDcHOXVyL6mRTvqGSshOTNC4YAE2m42KggJSySS+TIY8VUXO\n", - "ZgkBksFwjmckm82iquoFCcmcGLlEvPXWZNDpxUaS4KGHJnvXfF7ESDKZ5KUNGwj19BAaGKDP40Ex\n", - "m5k1bx4Ny5dz2/r1H1hVtaenh2w0SoHTxKA3RJGzgqL8MJFUgNGkF70hjqqO43aLlBQVUWmsRpFl\n", - "RsIJDNYiFEEhEzUwMuIjEw6Sn1eIlEmil40MKRqZ2Dhleh36TIZ8SUIyWjGYJdriWUTRiV6cSVrL\n", - "Ek6GMGolTBBCRw8y+RgoRyZNkBHSCMgo6MU6wnoNUzaAWbWQVCOMJ4IkDaUE4inCiWEGowkUnRFz\n", - "YR0ObyfeyEluWPc1etoPooaCHOnpYf/x4xTn51MWjTK+ezcHNm9m1W23cdXVV3/igLOLybDZTNfA\n", - "AAJgLizk7vvuOyfQVpIkvvKV9axY0U9PTz8mk4HGxlvOStMcGxvj0KEeampWI4oii1ZdzYmDB+kZ\n", - "TXKgrZ2CAhdJp5Nbr7sOgKHBQW5ZOIPH+/YhqyLhkJda0UC+3k1Glgj5IuzcsoXF995LACsmRSKZ\n", - "iZBKRNBUDc3sYiDmw2WSGY4OI0TTlGNAQSKlJTDrsihalIlMgDypDNCTQENAw0QchSCClmQWImLW\n", - "TE/fCdxFC5FTaSqteRgEHZnkEFZ9IRlJwihIOKxWNJ2HTDxMKDCGqjmJZscIphJIhoWgOjEbC1AU\n", - "mQMHArz88ib+y3/5Gg6Xi6ZduzgVCFA+Ywb3rl1Laen/z957Btl13Ve+v33Szalv54zuBhogAGaC\n", - "YASpQFGiKYvWiENpZEkuzYytcZjnmXpTU66penaVP3jKnueSnzXzniXb8liSZYk2FShSFCNIEIBI\n", - "ZBKN1Dnee/vmdPLZ78OFIFJMSqBsWetD172nT9/Tvfep3uv89/qvNYDv+xiG+hqdRhAESOm8bXbg\n", - "b4UgCFhaWmJzc5NYLMbU1NQPde/efPNNZDJpDhw4Srm8wI4dQ9x++wM/lAvqhz70ywwMHOTgwWM0\n", - "m200rcWdd36AeDyOED79/aN4nkuzqaCqLTKZfoRQmJ8/wMhIkkKhhhACTWujKA6WdYTh4UkWFp5j\n", - "c3OVUGgckNTrq7iuSyIxiKp2MTU1gW27zJz6Bl71BbbT2ZpxgZOABSwAaXzAxZQtmr5AVwfQtAi+\n", - "n0cIC9+32Nz00LRxIEkkkiYSSTM//yzr6y+i6z20WqdYXMyxe/cVXHvtbggucObAw1wvBBuKQrJc\n", - "ZrPdplGtcss730mrVmPb6Cjh8XHOVSrous7W665jK5BbX2diYoJ2u80zTzzB2aNHCXyf4a1bufPu\n", - "u990rH9BRt4GeF7Hwv1yZcp85CMdIvLnfw5vYzX1Z4Znn3oKf2GBAcAqFnnP8DC5Vot6sYg5M8Mj\n", - "UvLBj7w67tt1XR5++DGeeuooc8c36Y5CqV5BCI3xLSNoEQ2vsMjkdJxf/dWPcccd+/jTP/3/eO7J\n", - "RZJ6hHRPlpfmS9RqFwirFTZXjiLpRUqPTFjSCmo4QuL5kpgbUJMQEwpCq5IJd6M1m/hKFhl4KLQx\n", - "JCBUhIyhoJPWRon6AkVNoMk4bd9CEsELwjQZw4ts4pt5IuEtZCMqW7t3ML/+LP2KRa8QWL6DVV7C\n", - "9ptMjk0QCoWZuOp2UqkdhNNR9kpJTyLBMyfOc+rCIl67zqPffJjhsVFGJid55733svfWW0kmk687\n", - "5pcbn/zt36ZUKgEdb5Q3ys8RQrBly5Y3NHBaW1sDMpdaJfv7+4m94x2cP/sSc+4Fxq++msFkmoWF\n", - "BbZt24bZbNKdTrN1bJRzczClpekJRXBcB03x6E8kMUt5XjxxAs0IUzdDtKWGYUQJfI+kptO0daaM\n", - "DKZfwhE+VQS2v0G/kiQtdCpuiwIL1P0sYSwCFBp41KjTIxz69DhDepxl30Y4RWq5czgiSa20gaGD\n", - "UMpUAgevLnBKNi/nN3G9VQxRY9Wex2zbtAMLRR0kGc6Sjqfxg4BmrY4cHODo0bPcf3+LnTt3snPn\n", - "a6MAVFXl5puv5MknzzA+fvWlsV9fP8+uXWP/JLqvbNvmS1/6By5cqKIoKaQ0UdWH2bv3SpLJFBMT\n", - "4wy+QgT9g3hlZ9H38L2cmUqlQjKZZGJi4jWeGrquc+ed+7jzzn34vs9//+//E8PonCOlJJnMMjTk\n", - "srFRIZPpolzewHFKOM4Svr8P224BBr6fQ0qbctml0TCJxVRM8wyeJ9A0FVW1iUYTJJMhfD+GaRbI\n", - "rRag7RIiwKKzRZMFhuhYl68DJcA0ApJdQ0SNCcJqCNdt4DhzbN06hu8r6Ho3qrqJlJ1oAM/zKBYF\n", - "sVgay4JodIBIZJoDBw5yww09UMlxTSLBlT09HPA8FNsm7Dj45XInnC8I2LQsxn2f4aEhJkdGyCQS\n", - "nFxaIpZIEAQBD37hCygrK9wy2PFTWltd5e//4i/edI5/QUbeBrzwAmzZAper0jk+Dtu2daov73vf\n", - "5bnGPwVYlsWpkyd58K//miv7+phfXmbbxTTJwUSCtWKRwauv5tTMDJVK5VU+FU888Qwvvphnx473\n", - "UtuMEm238IJVYJ5ifYV60OA//ucP8W/+zQPMzJzhv/23P+L48XNUqxY5mSafW4dGntFIhC4Zxm7l\n", - "KIkNGgqkNQvpVUDV2XAhZ4RISR2p6nSJGr6/hMRE0qDlK8QUBV2N4EiLQEpULYaQ0FRCBEGbFjo+\n", - "ffjE8IWFToFIbAvxvgxePYdlLZIvVhmmynWZHtrtNr7Q8LwGi+0ipSWH5578O8a3jTM1dSMXTh6h\n", - "3w/44hMzlCoa6WCUlrOMrBaZ6moQOn+ema9/nbmZGT72qU/9TNw5v5ec+5PCMAykdF91LJFIMDg8\n", - "xOrqAseOF9E0H89bIRJ5ln37rqENbJ/o4+z8AhFNUHZNGl6AlB6DVos0Og+9eAq7YpKMxbADn3Yg\n", - "iYT6aNstIiJKwRGUmiFU0Y3rrzGERAuK1F2VNILdBJzlu4ToQUNHp4JKmSukQBKwhE3eN3l31xAN\n", - "isx7NUq+S0nC+LZtzJ9ZRMomuuFhe4KIMUU4Wuedd7+b/fv3Yy6fw9B9omEbVVFxPYtsNEy9WiUI\n", - "wnie96bjtm/frVSrdY4fP4CiJAmCFlNTWd7//jd/mn278OyzzzM76zA+3gmwW1w8w4EDyxw+nGfP\n", - "nuT92G0AACAASURBVOsIgiPcdtsO7r77XT9UEGSr1eJv//arrKxYQBxo0du7n49//ENvuNWrqio3\n", - "3XQln/3s1zFNjSCQNBobwDDRqEmrdZ5YTEfTWrRaIep1n2QyTbF4jiDoR4hehKhTLObYvXuC0dEw\n", - "8/MrpNPbqdcr+H6VoaHbEaLJlVdu5dEvfhFLqyEdjzowQSdxtkYnAnMQOI/gtmu2YQlBzpunXD5D\n", - "sbjG9PQ06XSWcjmHaSaJxzXAx/Mc6vUmQSDp7e2l3V4jmcwgZZGJiSm6u6GZmyN98al2x9AQR2dn\n", - "6fJ9/GqVl8+d41yphOG6RDc3aeXzPH7hAtM7d9JKpdi2bRsLCwu0FhfZ8wpDvuGeHlpra286J78g\n", - "I28DvqcXuZz48Ic7NvE/r2Sk2Wzyd5/7HGxs0FUq4VkWM2fOkN6+nVHDQAKNVosTs/OUXYfjx4+z\n", - "uJhneXmDVCrG+fNL7N79fjRN5Zobb+TooUNsboZo5PLsuX6KD//HX+Pd73kPjz/+FF/96kHm5mKM\n", - "jT1ANltgaelxMnqZvliIbCyO6/rIZpmk1QTNI6WnCcdVHK2HkaZCSJWoQoF2kzXLJqoETGZCLDZn\n", - "cYIdOGoXtmeiijZhBWL00QzqCCmpYSFIE2ENBROpxAmEiufWkH439eYSaXcTpxkQkg5zeKQjKYyQ\n", - "DoFgAJf5ZpHc6RfZtus2lpbCPH1gldzicUbjO7FrNfKKR8QvMxnup1K1uWFwkEqtRrRa5cTx49xy\n", - "6z99x9Z8Ps+JI0co5/MMjI5y1XXXkclkmJycJBR66lXJu77vcebMITKZXsbGvu9RUqsVOXToJYa3\n", - "bSPbbIK2wdl6jJDSg+3baDQIWT5Nr0ZghQnaTdasAzScHuKiiygtXHeJpCoou1GCII0SzLIVm0Fi\n", - "CEyissUskhiwEwtJlQgaYUUnCAIqqsIIMOe0GE/2kLNaFNwmG45KLJahX3OZn53DllOM9kzTbBQJ\n", - "C4nrBNR9OH78BbLZaylshPB9n3x5jZCxQTY5RjqeJl+/wNTUrZcyeV4Jz/M69uKtFt3d3Xzwg+/n\n", - "zjvLlMtlEonET0Wz8dPC4cMvMTDQ2YdutWqcOPESvb23Uq+vkUoNkEhs5dlnX2DbtgkmJyff8vMe\n", - "e+wp1td1xsa+r0vK5Rb42te+zSc+8cDr/kwQBCwuruH7EcrlFqbp0Gw2cZz9ZLPXMzCwHdetkcud\n", - "QVV3UCg0MQwPRWmgKD34vo2m2eh6k8nJqxgbS3LXXRkOHXoZx0kyM1NjdfUsmUyaI0deZrNaQLZX\n", - "0IAkYANFOtTJp6MfQY3RExpktrZG73CaHdndHDnisLBgUSqtEI9LcrnD3H33AwwMDHHs2BlKpRrt\n", - "9jk2cyGGsn2kkEjfpKdnBChihMMsLS1Ry+c7lcieHgqtFovtNqlolHdu3Up/LMa548fRgoCE4/D0\n", - "yy/zh//rfxGJRCiVSiRfp3ur+y0qbL8gI28DHn8c/uAPLu81PvShTl6N4/x8eo4cPnCASKnEjslJ\n", - "vFyOUK3GlZkMJ+bn6d69m6fn1zhTj9COhjhX2OCZM5/lttvuZWzsVjY31zl58gCp1CoTE1uQUuJ7\n", - "HtlojHCQYTKd5vyxY0xu3cr+/Sfx/R7icZV6vUKjVKSUs8l6PmGpIM0NcEziioGmm/iBhdmyqdsR\n", - "kA0GYhHWGnXafohQEMOTgpmWzc5EArfHxy5dIGZsoVRpE1VMol6A4UXxWcKlgiEGSMtFetGJqjYR\n", - "0aLqedQrPlY1QOKj4qEKA1Uo6L5CwzaJBzZbkxHyUpK3BTekxthcmGF6+gY02YVj9qLGHLKahi8t\n", - "pGXhJaIIVUdRFMxmk+2pFMvnz/+TJyOzs7M8/Dd/w6CmkY3FWF9a4tShQ9z/7/4d/f39fPSjv8QX\n", - "v/gtisUoQmhIWSEadbjiilf/XalUN8vL81x1zx4W1os4eoim72AoRbqEIKX2st6cIxNYbA8p6Gjk\n", - "nBongwomIYQdIalEqVo2LTeOGThMEBBCIPHQUfER9BJQAjJCJy49dMAMXGoElAKVYTVMUpi0cRG2\n", - "RcSP0a+GaPthLD+B726iBAbF/AK9oSiaFicUjrBcr7C6tMnuq28lbkCrVcf0YnjeJqpiUG+dYfsV\n", - "Bh/60D2vqRaUSiU+//mvUi4LoONKunNnP/ff/4HXWKX/rCGlxHVdVLWzXOXzK0AWTQshRKfdW1FU\n", - "YrFhTpyYeUsy4jgOx49fYHDwllcd7+sbZ3b2APPz8xw9+hIzM/PE4xFuvvkaxsZGOHjwEI8//gKt\n", - "FhQKVUxTQ4gIphkwNFSm2TyP6wboepZMJko+/xS23Y1hjCIlCLFBNpslk9lLrdZEVft573vv4oMf\n", - "/AAnTpzgT/7kc9RqAdFoN6urq2xUVhmghQ/00amMAGwAeTq6kVCki0XHpqz2E6kPk0oZTE6+D0WJ\n", - "s7Z2nqmpPnbvHmZl5RCRyPV0dzsIsYrVbHHD+HX0ZTrVSMtxOHX4KT752+/jW88/SXNzkysNg+5Q\n", - "iEouR83z2HbnnUQTCa6enERVOsnDtWoVoShk6vVLItVkMklbyteMe63VetN5+QUZucyo1ToJu5f7\n", - "/3t/f8dz5Nln4V3vurzX+lng7PHjXH1xn2t61y6OPvcc0WQSt1jkmzNnWTYH2b7t+k48erKXcGQH\n", - "58/nGBvbSk/PID09A5w8eZrR0RFmTp0i6brEsmncVBc3bd/ORqnEQ1/+MtCL53kU1ucx2g0yoQgZ\n", - "qdNurJAIAnqNGJoEU7jkfQtH0Rgf2k3ebOE01ik3Wuiih4QRQpeSth/DkU1qnkEm2kUiqaH6TZLh\n", - "Gm0zQJVRfHwEDjHqWDKgnxQRFboVMAKVrCo57dfpkQmW8UkSRhM2lqoRkmC7JmlFwyTCBcehN7WF\n", - "VCzFRjHPN77xNfx6Cz+IcHYjT69IoEiTSODiC0GrWWVtDcIjI7Qti/jrPEG/Hmq1Gi+fOkWlUKBv\n", - "ZISdu3YRjUYv4x3QQRAEPP7QQ+zOZEhfDCPLJpPENjd55rHHeODjH2dycpL/8l/+PQsLCziOQyqV\n", - "4nOf+3ukfLVlfgeChx9+gmYzy/QV76I+1M38zFHqzQIl0aBX08jIFF2Kw7plEkNhFyEKhAn7Fg2/\n", - "gYFGwW+iECeKgo2GiYOKQEUSBZaBuJTYgMCni46d94YiOO871AKbLXUPjX4UIsSlwHQtTvsenlAQ\n", - "FIh43WgxHU1TsR0Ty26iY3DqyH5iZoXheDfoOkv1Apo4SqZ7nDvedROjo682ipNS8uUvfwPLGmBs\n", - "bPjSsdOnT3LgwEHuvHPfZZ/HHwVCCHbv3srMzDIDAxMEgY8QCq5ro2n+JZ2Toqi47ptvR0FHKyKl\n", - "uJTx9MrrmKbDZz/790Qi2+jpuQnHsfj0p7+C6zrE40McPVqmWNwkk9lBJDKMZdm0Wh5Hjpxk377f\n", - "oKcnS6mU48KFOZLJDKbZQtO66ZCnQWIxg1hMo1xepVg0WF5eJpcr8PDDT6AovQwNhdjYeJFcbgmD\n", - "EjYdErIL0AEViNEhInnA0g3KJKjUfEqVVTY2alx11YcJhaJs2bILz9vkhhveyaOPLlAuzxKJ9NLT\n", - "M8HG7AUa7VXikTCqolJtFhhNtSjlNpjq68O3bVYKBRYbDdwgoBaN8sC/+lecOnAA3/dRO1kHZLq6\n", - "OvqsVuuSyd7k5CRPZzKsbG4y0tOJzag2m6y/xVbhZSUjQog/Ba4Djv1ggq/oUPXjwP8jpfzLy/l7\n", - "/Czx9NNw880QDr/1uT8p7r0XvvnNn08yomoa/kXDq1QqxZ477mB5cRHD9zlXDegamsaORBiZmqD8\n", - "0lG6uoYplxep1WpkMhmuvPJannzy2xw//iJHvnsCXXoEcoP7bh1DEYKh7m5OzMxgG2Hi8QxOeY2R\n", - "7hFAoCstPCQhBYRvdSyrg4C8tGgQodquo5g2JauGFYQp4qJqkr6IThC4BKKLiifoc2ysdp1SrQ9N\n", - "DhIOLBxKeDTRiBAljUIdHRfV3yCE2jETkD5RwghpMIaFQhxdRmlSRioSn4BmJMxSNMqOkRHadZ1i\n", - "s029pVGTHq1CDdfuNAqnEoPE/TCb7SJGZY0d3SobBYeoplFOJvnkxz72lnOxsrLCP/7VX9Ht+yTC\n", - "YU4fP86R/fv515/8JF1dXZf1PiiVSvj1OulX2FMDDHV3s//CBRzHwTAMwuEwge9z8LHHaJdKnHr+\n", - "EBuVpxgZvpbs4BDTO3eh6x1fiEolzfDwNKdOnaG7p5/l2AB1S0HRNuiP9OJVKwSKgiMhQxzvYvWj\n", - "iz5Cap2mrpGw1vBQKdNGI0IFFR+T1MX8kDLQRacq0k3HOXMJwYiqcNZtU5IhHD/McDRCygujS4Fl\n", - "13GECWICN9ikhI6wQsQUl7bbQBMFNHcC3/PQiVCzbUKyQVq36Y0nmNh7B74fpdFovEqEWigUWF9v\n", - "XrJHbzQaeJ5Pb+8UBw+e/CdHRgDe8Y5bmZ39MqurDqFQmEZjjiDw2LNn56VFsF5fY9eut37qi0Qi\n", - "jI52Uy7n6er6/lZUvV6mVssxOLiH/v5xoLOVV60aQDdDQ4O023Po+o3k86eJx6MYRgYpe7Htl8nn\n", - "F+jq6qe3d4R6vcjiYhHD8Gg0HCzrLJqWwnH6aTQCYrEShw9vcPZsDtdVWF5uEYlk8P11qlULv+mQ\n", - "wSagI1qVdDppfDri1QjQQBCWEIvtotHwsCyLcuFZjj7/bXp7+4hnB0ilFZaWltnctLn99vtJJNIs\n", - "Li6xpa+EIpbQ1XkCCTfu6GYgey0HZ2e5YWKCrl27yG9sUGu16MpmkZqGb9vsvOEGnnzoIc6fPcvq\n", - "0hKu55HOZJi65ZZLDyO6rnP/r/0a33rwQQ4sL6MJgYjHee+v/ir/xx/+4RvOy2UjI0KIa4GYlPJ2\n", - "IcT/FEJcL6U88opT7gUKdMb55xZvh17ke7j3Xrjvvk6q70/bz+RnjV179jD72GNceVEUFY/HGRwf\n", - "57qBAcbsMNnsHkKhMEEQcO78STzPQghxybFzaGiSoSGNc+eeo9EukTSiQIpvPL+OaR/k/bfsJRmP\n", - "k8hGOHWySDaq0WxV0LQQjrNGVhUUZUBTumgI8nj0IsgEHiulWRpBQE16eHSRYoiIjLDUblH3l+kz\n", - "ohhWnWY5h+n14mMToGMQQyfAZp3thMmicgGbLjZQ0IkHHkiHlpRItQvhe4CBSQILn3ZQJRAORaDq\n", - "+Uw7KuvrDUrNJuHYJG46hdMywWwxGArQZRNbXqAgQ7RxMJU63Ykhhnt7McNhFHjLdkcpJY8++CDb\n", - "o1G6L1ZRhoCFXI5nHnuMX/nwhy/XLQCApmn4P1ACdhyH9fV11nI5VlZWmJiYYG5uji/+j/8bvdJg\n", - "fW6ObYFL2NqksiGJSYfvzJ9m13Uj3HnnNbzwQgnDCKOqCi+9dAi/tUqvKNBub5KzLDLCYdP2UYWB\n", - "FBG8oI1BGIGO4hvU/RxXI2liUMRAwQQETSQ1YAPBAJIZYJQOv6wDFgElB1pMopJAlQbLlkeIEr1B\n", - "gINAlSGywkBVMlhBnU1zDUfx6YmGGdC7mDUrdIWytK0lNGudRKAwEBXEwxkqhXMMjV6H7/uvGS9F\n", - "0Wm1Whw9eopy2UQIFVV16esrIuXrO9r+uFhdXWX//sMsLXVs5vft2/Mj28xns1l+8zd/lWPHTrCw\n", - "sI4Qw5TLEl332dxcY3b2u/h+na9/3eHChUVuu23vmwqi77nnHXzucw+yttYgkcjSalXwvHX6+7vJ\n", - "Zgcunbe2toSuD+D7Al3X8DyLRsPEddNAnng8ghA2sVgfKyv7SSZVwGdj4zDtdgkpMziOQTg8gG23\n", - "qNePYVlt4vE+stlfZn7+ENnsTnp6JMvLZwiHt+O1N1DswwzgYdNZIJt08mhUOtqRCmCjcU1mFKGp\n", - "OE6eoFpgONlNw7KJeyYbM4/STMHyadCSaSqVGoqiE4/H0SIpIvSx7+otDFzclju3tkbf+Di1YpG2\n", - "aVK3bTLd3Qz197OQzxOJxYjEYjy1fz9b6nVu9H08ITi7vs65o0f50l/8BR/9jd8gFouRzWb52K//\n", - "OuVyGc/zyGazbxnIeDkrIzcC37n4+gngJuCVZOTDwJd5vVSknyM8/jg8+ODbc60rr+y0Ec/MwOt0\n", - "8P2zxp69e1mem+OF2Vm6dB3T86gZBr/88Y9z6tQMR4+uMDS0FUVRmJzcyqlTM0QiCVKpFFJK1tbO\n", - "EQ6Hufvu+/jHB78NLYOuZBeuZ/OtwwepN56i/8rt3HHjlaysPEI+WqTdstgsbqKFXNLxDMPNJmFV\n", - "5Uyrxe16BK9tsoyCEUjSCFqim4jsp0FA1XcQIkmYacrOIo6TYxMFHx2BgWSTJg4BYRKkieBiEhBD\n", - "Q+JjKB5tPJJCUg/AC3wkIaooaEgkNfoQJKRABxbaNhkdRlM9CE3hXHkWixBqy0R6JWJ+kelInGRS\n", - "4eVqHndsgi2jfdz/jmuRUtKTTnPm4mL+ZgtFqVTCLpXo/oHS/2hvL8+dPo3rupfVrTOTyZAdH2c5\n", - "l2O0t5dSqcThwydZKrWxBqf4y798lF27+jl99Ls05oukolliQZiknmRKVrngr2OVm4TNFrW17awu\n", - "JZmZOc3i4jrr6xuI1gwTQkMTKlo0xqZTQQibOgoKITxVkJOQlRFCqk7ed+gXkm402tInjUMbH5MA\n", - "DwMfHQuPHA5bUIgBOoIYkjbgkiVGmBoeURnG9gwco5eyt0IIBYUu1ECgoJMhSkwo6OoKw0oPZjhK\n", - "KqHRKB2lyykwhoLug6KmifguTmEVTbviNeLVvr4+NM3iuecO4ftZuro6LbGVyhKFQpXl5eXXzTL5\n", - "cbC4uMjnPvc1IpEtpFLXUCrVLtnMAzzxxNOsrOTp6+vi+uuvflNztWQyyR133M4dd3RI8fz8PCdO\n", - "zHD06HGEMNi16x6i0QSnTq3z8stf4lOf+sgbEpKhoSF+67c+yosvHmd1Nc/0dBd79nyYb37zCc6c\n", - "OUckEiMeT+N5Hoqi4fs2oVAIwwDHKaAo4Pstms1FhOiE+6lqnGZziaWll3GcDK47QDh8NZ5Xpd0u\n", - "Egr1EInswHWXmJ3dZG3tK0gZp1TKkck4tNsuzWYNzZ0nQ4UkPhadqlovnaoIQBvBIgq+0k/DdzAs\n", - "C8Uv0xuWpJMD1M1jrK29xKRmEDF16q0yipnl8Df/lszgToa3bSPc3U1hfoG2ZREEAaubmxR1nT03\n", - "38yf/97vscMwSIfDzM3OciIUIj01xbt37uTP//iPuam3FwVIaBqapjERCvGdSoXK+fMcO3KE2/Z9\n", - "v7L2o1RKLycZSQPzF1/XgEvLoxDiLuAZOuP7c6tbWViARgN+wEjyskEIeP/7O1s1P29kJBQK8cDH\n", - "P87CwgJrKyvEEwmmt28nHo+TyWQ4f/5LLC29RDLZSzweI5MpkU4HXLhwkMXFCwjRptHwEWKedNcE\n", - "NdmkadoYqkqrHeZbR5a4JbmdF//4H9jcPEd1c40tvVeyfXIPKxurzC/sR/V9ru/vp8f3odWiFvgE\n", - "SMIoCCWMDJJE8AjQKQOB9Gjjo1KmF5sJ+qhjs0IRm2kEDTw28LFwL37txsdEkA8cFBEgpSQMKLJO\n", - "R9YaJkKNrUgiqAhCdAmXiIgy65qE43G8SIJmPsBqLLEr3QOKhhEMs+7kaLR9MulBnFQfw71phi/u\n", - "6f6wEEK8cSnzbSrHvfe++/jq5z9Pfm6OU989iallUMd2snfvPRhGmGPHDnPk6UO8d+te6tUCEUUh\n", - "HIriui7B5hx7rxkiE+tnxnZ45O+eoGB3oRoW+bwgGmj0dsVpVdcIazqOHGC5vYAtXTQ0EsInFRpA\n", - "98ENfGq06EajIiGOQpQwHgHrNGgRkESjSogmghIRwGIUiUJAFZUmGRyySAJWRZUuqWE7PjY2PiFC\n", - "RC+eHcbGxQw86o7Dml9D2AHj268nUZ1jhybQAw+kjtZuc8FsMNabYXyw6zVVDsMwuOaaSR577B/o\n", - "6dmDbTcwzRKqWuCKK27l0UefZKS/i/zKCj2Dg1x3001v6uHxZnj00f0kEtNkMr0Xrx0mEknwyCPP\n", - "AfDccxvE41mWliocPvwlPvGJ9zMxMfFmHwl07sPJyUm6u7s5dmyWG264+ZLAdWBggo0NeO65w9x3\n", - "3y+94Wdks1nuvvv7e9rFYpHZ2QUOHVoimZxAiLOEwy3KZZ/+/nGq1ToTEzsplY7geU10fYggMDDN\n", - "lzAMSTq9k2i0m3Z7FdfNoigGrZbA88JImaDdnkNVRwiCJFKCaQoMw8D3MzSbDTxvjbD3NKkgRzcS\n", - "BXmpKvICCp2NtoACghyjpGPjVEWFO64YISoabEunKZUqFFsO10Q1JrLdXFheYHy0G9frYs1v0htW\n", - "yJ09y9g1V+N4KeY9j5W1Nca2b+dfv+tdPPLgg9y5ezeVhQUCzyMhBOVqlUh3Nz09PSzNzHB1OIwX\n", - "CpF+hQVAVgg8z2NhZuZVZORHweUkAjU6HUnQaY+uvuJ7nwQ+Rqc68ob4/d///Uuv77jjDu64446f\n", - "6i94ufH44x39xut0OV02vPe98Cd/Av/1v75913y7oKoqU1NTTE1Nvep4KpXiP/yHj3Py5EvMza3Q\n", - "1dXFpz71f1Gr1fjMZ77I9PQNDA1t5ZFHvsILL5ymv387k9PT5HLzbK6dpmGukR3YwbHDB8lIg0ar\n", - "TKGRwLLqRCMm6XQ/WmIHs2YFc32dwDQRUuKLzhOuED4ubWzaFBnAJ4mFhodEp0APKlEygMRGo4st\n", - "lDEQF3svbM5iUUaQwRIavfgkpI0rEwRalIrXpIBLHRWLBJOsIAjwFZ06kogQ9AqdZc/CiIyxY2yM\n", - "ldIJLDeEa7XxHIeG10IRKoofIh6NUjM32bPjqktj2LIsmpr2qqjw10O5XOb4hSXmDh5juLeb6ekt\n", - "DA0NsZDLMXXllW9Lhkk2m+WTv/M7PPPMM7xQEExN3UQ2O3BJkBiNZmnYGm3HQjfCNC5u69imQ9OT\n", - "pGMxcs0m5+sB20beQbjeRM2kWFnywE9TMDfYNjTI4lKFwIeMPsGs4mBZkqoT0NJsisKjiYmNT01K\n", - "hlEwCKPREagawAohPIZxCBEmoEGODAnyNPGoUmcQm2EMEggULJkixwUcJAEBCXx0FDzCCDw8JE1c\n", - "fLEbJ8iiyzSLZ1/gCtWh7fvEtSSaqqEYIfo0l3AsRDabpVAocOH8eQAmJicZGBhgbGyUa6/dhW2b\n", - "NJtFJia62bLlLsrlPM997Uvcd/MNbEkkKJ8+zVeOHeOeT3ziR95asW2btbUSo6O7XnU8HI6yudlZ\n", - "eoaGpoFOZ1OjkeWhh77D7/7uv79kWvdWyOfzKErqEhH5/j0yyLlzJ4BOFaXRaKCq6ht66Egp+cpX\n", - "HiaR2M1tt01z+vQCUmbJ50vEYjkGB0e5cGGeUCjNyIjK0tIivt9E03R03cUwBmg0FjAMD9dVkLIP\n", - "2z6HlN/rTGoC4/h+L6qq4vuTCJHD93OEQmUsKw3OOQxiSMawsClRwadIjQRxMixjU8HCQyUkrkGN\n", - "W2y9apCxsX6apSKubaLFHLYNpbh5oBvhOKyvq+wYG+bMUh6tEVBrlAhpEc6cepz/8/d+jVtuuYkg\n", - "CFBVlXK5TH1jg1t378beto1yqQRCcG06zYvFIrZto8dizC8vEzNNYpEIuqJ0th2lJKzrhC+Kyn8c\n", - "XE4ycgj4deCrwDuBv37F97YBX6Oz3SyEEM9JKc//4Ae8koz8c8R3vtOpVLyd2LcPHngAmk34Ce6L\n", - "f3aIRqPcdNON3HTTjZeOPfHEc/T1XUdPT6djYNeua1hZeYa1tQ3ajWWclReI1jdJKx612adxQgrb\n", - "tr6blyyboWgWW9ost9u85+67mdy7l3/8/CqDMYfVjQ2GDAO3VmPOdYlISUUGuJjE0HGJIolj4KOw\n", - "SA8BCdIUKOEzgIKGQRGFBlDFI84iJmklgittAlljhCghJQSE2BSCjFRRsVggShOVCmHUQEdQx8DD\n", - "pUYgNVbWX2J6yxbSEZd8vUjVddimxtAUhzqwaTpstjze/+EPULQsRD6P5XkUgoC7HnjgUsLn6+Hs\n", - "2bN8/vPfZmjre1myDmBvVpldfZHhrcv0X3UVd9911+Wd5FdA13XGxsYYHJq6NL/fQzgcI5TqYslq\n", - "MRFN4hhhqmaThUYZx9B5/ty5jr01CeaYoVSHeLtNWPcJ6gGu8GhcOIu0bUwRwdc1RsNZGlLBcQ0c\n", - "tUVN+iipEerl0+Qw2XKxIjKLSh2dAiECBohd3GxJEaeIziLLxAhTJ4FOCgUbSRQNSYowJgkinCOG\n", - "TwYfOMsmSQIGMFkBBonq00hVYrubaDJABi6+FsPQdOKZNP0Dg6y2apzNV8iXy3zp05+m5+LifsT3\n", - "2X3nnUxfcQXJZIjx8ZtfNXYHH/8CNw/0suWix0gyFiPVaPDkN77B1H/6Tz+SlkTTtNe1mZdSIqXz\n", - "mvMTiQwrKy6VSuWHbi8Oh8MEgf2a45bVIpmMsbq6yte//jgbG3UgYHp6iHvvves1xmbFYpH19Qaj\n", - "o7vp6YGRkWHq9TpBsA3PO8stt+zmD/7gz6hefKQeHNyOoqSoVApYlksQtGi1KihKG99vIETzovbm\n", - "e39rgo5DSKnTjaIaSJkGGsAatn0BDYU4XYTw0Qiw0XGIE8cEwnh0YTMAKASGx+Cwxu///n/m7770\n", - "NebmDtHMr7N3Sw/Dgz20bJtGpUI4mSQTj3PdthDN+SW8UJ7uZJy+niQDA3202+1LBE1KeUkzEQqF\n", - "GLhYDQuCAN/z+Me//3tiqspssciI41Cp10kYBjnLYikcZqTV4t49e36oeXs9XDYyIqU8LoSwhBDP\n", - "AsellEeEEH8mpfwdKeU1AEKIjwPq6xGRf+7wfXjqKfizP3t7rxuPww03wDPPwC+9cYXyXwTOn19m\n", - "cPC2S+8nJ3dx7bUrfOPrX4NckzEJEVWiyAhpvwSexkurR2i6HhGnSH9YI3d+gfktXcQSw/RlBggi\n", - "VZxcjgONBlHfZ0VGaZPGJkSAgskiLaoIugjRRCHAwkAhQEWn0/vSoBsbBQUJ2MRpU0YRvbik4vmI\n", - "zAAAIABJREFUOSlNSkhCgYMfSCL0EBc6NbmMjksNjSYQx6QbBUGEFSxEEEavbrCcn8VylugSJpPJ\n", - "LQivSVRPEBMqllUhe9VePvmpT9Fut1manaUnmeQ9u3a96QIgpeTRR5+lp2cXiUSGvr5RchvzNCqb\n", - "5NUCv/tv/y3xt5n9Dg0NoarN1yx2plnn5pt3YrbTzBdWqUZSrKzMUjQbjBseKT/O7vFxzqzWWZo7\n", - "iaenGRgYpCo8Cp5FsbVJIF0axDBlmIptMiI9Ro04OVnBFxBTNMr1BeJCEMgYZ3EpEwGGMQmQNIER\n", - "ipTpQhLFR7loedbAQCWOJEKaNjY2gjgeCgF1pjCJkSZHmG5sQuRZZZMAlQAD2/eIGSnUIM9QZpxW\n", - "rcZIIgmKj2W3yZULvGy38AYmOfP889x/443oF9uZPd/n0BNPYDoOzc0ZvnPyGFO79zEyMk0+v4Tf\n", - "XOXad73adTWTSOAsL1OtVl/lavxWUFWVW265iieeeK3N/I4dw685v0NSgtdYsr8ZhoeH6e3V2Nxc\n", - "vURKfd+jWLzAPfdcyV/+5T8QDm9jdPTKizqTBT796c9xzz13kEql2LJlC5qmYVkWa2sFzp3bj2U5\n", - "9Pd3Mz09STwe58yZw3zrW4fYuvVmzpwpkc97eF4Zy7qAEGOAjuf5OM4wrZaB78/RkZn2IEQeKXN0\n", - "pKdNoNNxIsQGkUgPuh4jkxmgUDiI18wQx0fBw6TEEJIwKVw8XCQNSkiGEWhoxiLvfvevUC4U2KLa\n", - "3PWRu1nJ5Th28iQzCwuckZJbpqfpKpcJpKRqmniGSrK5yQsvv8jAyAjf+sxn8ONx9r7nPWyZnKRU\n", - "KuEYBvlymb5XaD2WCwWCcJjmmTN8dN8+njYMnnnySezNzY5/TlcXN2/Zgua65NfXmZ6e/qHn75W4\n", - "rHqNH2znlVL+zg+8/5vLef2fJY4cgaEh+DG3Wn8i3HVXpyrzL52MpFIxTLNFLJak2aySzy2iSOhN\n", - "2gyZbbplhMDzaLUrZGSA7qtcKC+yJdqFBih+lF5bcP7Jxzjb8OkWeSKhEFl0MhGV/ZZHiwlahNGQ\n", - "OKQxKePTJEGSND2Y6LgUMPCJESApECaCgoKggUEESY00Pqt+BYs0DiPkUYnio9EmTBhLSsoECMI0\n", - "6WKOAkO4WHiYqBTpRZE2hl3jxMlv0NUVJ9lQSMgQrh7FjScQQrJ7yzYKro2maa+b1/FGsCyLUqnF\n", - "6GhnMQqFIoyN78QeMFlePky73X7byUgsFuOee27loYeeJxIZJhyOUSot0dXl8pu/+Zs88siTfOc7\n", - "a+T8JNGxG4jJIyjlPOVSjYTvU96skZHdlO0Cq4tzqI0mil+nIR2ajKGTxEFHJ6DuOKQ0jyF0THcN\n", - "Q8SwPBsFFRcHExUYJUCjD4sKoGLgEadNhU08mvgodKOi4rOCS4QGEbox0fCwkeiU6SeEj0qn3yZB\n", - "BB0VF1BIIan5BeqOyoCu0p3qZlXpoRXSiYWibFQKzBUr6GM347ZMcjOLXMh0sWPHdoQQKEJQvXCB\n", - "J+bnueuaa1hgkRef/wLz2T7ec+970a/fRfgHgvGCIMCnozX5UXH77bdQLtc4ceJ7NvNtJiYyfOAD\n", - "733NuZuby2zZ0v26brFvBEVR+OhHf4UvfOEfWVpaRwgDaPDOd16JZbn4fu8lvUoQBKyt1Xn55fNs\n", - "bLgXDcie4GMf+yBHjpxgbm6BbHaMZDJNoVAll3uRsbEEBw7sp1RK4DhRWq087fYmUnbTIRclVBVc\n", - "10DKMTqVDh04AyQIgs7jBjjAFBBCCAdV9YE1dF0nGtUIhxUqTXmxhdemC480Bk3AQyGJTh8eedYJ\n", - "1CS9XSEMNeDo00+zb2wMTVXJTE2xY3yc+fV1TpsmJBLkTpzg2MsvU2u1iEjJy+UyAxd1aCtS8o73\n", - "vY+//aM/Ij04yNaeHpx6nQcXFrjliivoTiapmCZmMknY95lIJBBCcOdNNyFrNbxqlcVmk+v27uWK\n", - "yUk0Xee7+/ez56ab3rTC+kb4uRWP/qzxdrb0/iDuuqsTnvcvHbfeeh0PPXQEVYmxcnI/PQisxTmy\n", - "bg3sJhndoeX6hBVB4Emark1EBERtE0tzsR0VRYtiNG2iso7u+XRFE1RdnYX2BgFZIsRQiVBHx0dD\n", - "MgHMYSPp+KWatPHI4WPQAGqYCMKkCaHgYBOjSBcRCjRpEEWwmzZFNFxUdDZYwKVJmyFUJhF4NBhl\n", - "mU001gkTIqVOYnEeQ28QjQTcdeutPPLY87zcLGMoKkmnwp5r9qAY0IhaP7LVt2EYGIZyqQphmk3O\n", - "nXqO+vocrcYKD/6N5J777/+pdWH8sNiz53oGBvp4+ukDPPfc83ieAvTyyCNPsWfPVZw8ucDOnbcx\n", - "PztD9aXv0KcKSsUS+WIeD4kqmoQTPVhBnYa7QVhWUEQvEWOCtuuhSUlVmhhkWTcvMKkFRGjj+hoK\n", - "EXwCemiycpEwRPGIAmUkDg0sokg8mlhIdqBSI4aBYIgWR2njUMYgdNHgO0mTNiFUXCQ6EQQGUVQs\n", - "krQJU8NGwRJtdOHiW2UGkiokB8nZCsueh9s1hKFGaVYXKLYCvv3tF3Ecm6uuuopCoYBdLLJl1y4G\n", - "ursZ6O5m73XX8sLiIvv27eVsV4zZ48fZPvz9ysXcxgajV1zxY2UW6brOhz70y9x5Z/GSzfzAwPdb\n", - "Z5eWXkSIBEHQortbct99P3q0eTab5bd/+5Osra1hmiZ9fX2kUin+9//+CvH49ys5i4tLrKw0yGS2\n", - "k0ymGRu7ilJpg89+9ku023D77b/E0aMn8P1hDCNGLlfh9Omv4nnDSDlFu12k3e5DyhSwRKfZ1sL3\n", - "Azr9Gg2+7wYyefF1m45F2RSKUiEIkoTDKlI2aDaP0W77VCoaqlsgIMsGfWh4pOm0f7epk8TARhBB\n", - "RcMlmbS5adsoseImC4uLqK8IjdQ1jW0jIywtLNA7Nka1UMB1XRYPHsQHMpbFuK4jazU26nW+vLmJ\n", - "EgRsLC0hJyfZPj1N386d5HSdvh07MEwTzXU5fvAgW8fHIR7H930Cx2Egm2W21WJxY4NQNMrU8DAh\n", - "36darf5YUQK/ICOXCY891rFn/1ng6quhXIalJXib14afOizLwjRNkhcD8d4I+Xyew4ePsrpaYHi4\n", - "l717r+OGG65jeXmFL/zZ/8uOaDe6KsnGPRKNCC82GlxoNrG8EKrQiCIoCxMVgRcEqEocPWzgSQtX\n", - "akRlkhZp5lp5ojLCphujiYaGRhONgH4UXFxsQMEjoMxZ4jRRLxINAwOHEElKhKkigCRhUqSp0MbB\n", - "JQU4NGmhUqOfFgY+SaCMzjgAgjohYgT0IokQZgMryKNHoIFCJJ1lbl0QTV9HyvCwnIBNc4XTcy/i\n", - "KTa3ffwjVKvVH8n2W1VVbr31ah5/fIaRkV2cPPQw3a0aXUjGd00zAnztr/6Kj/zWb9HzI3bo/KTo\n", - "6ekhn68yOnoLvb2dG35jY43PfOZvSSa3EY0mWDryNIbvYTdLjAuBisKG9HGkSd7KcUMmy3PFVUKB\n", - "oC2j6MIjYuiYdoMWoFInLOuIoEnIt6gIjxiDNC52N3RjUMQGwrQQpEmSZwOTFDoSSQwNF4NeHGpE\n", - "MJAMo3KWOD59qPQSEAEKmFQAD0GOCgFgoTGODmzQFFW6koJoJGAwYzIWDXG0OM9y2WOt7uCaPsGG\n", - "RiKk8bJbYDAeZfNb+/naoZfx/QDpNtj+inRmRVHoi0RYuPD/s/emQZad9Znn7z3r3febW+VWu0ol\n", - "FdoXEAKhFrLEFtjY4MENAxh3dEe3OzpiImYc/aGZDia6JyY6/KG7HeC2GzzYjWkYjBAGraBdaKtN\n", - "qj2rsirXm3dfz37OOx/ORVAWGCQklRTBE5ERmefeuPnmPSfved7///k/zxned+ed/H/NJj9eXiaj\n", - "KFhSkpid5QMf+tCvdY4qlcrPHbP9zGf+Cc1mi0Ihz86dO1+zAFpRlFeIr2dmqpw9u0mhEF+PS0ur\n", - "5HLT9PtnyGTi66RcnuaFF54lkSizf/9ustkcS0vHOXfuMI3GOs3miERCYzDYJIqSYyKiEOs/KsAs\n", - "cJyYnFxHnB6zQOyT2uanqTImiiLIZnu47gjPG6HrCySTU/i+TegfJY9DwDlMYIRLDoUSFhYqGsTi\n", - "ZfrctP86PnnHjRiaxtEjR+Jxe+DFs2vU230KaY26ElEMQ3bm85zv9aioKuFwSElKKpqGFQQ0XY/G\n", - "8jJXTk+TKxTYbxicOXyY6b17MaKIHz74IJ0jR5jQdZabTf7miSc4cP31jCyLQ6dPE7kuVV1ndmqK\n", - "2osvcurMGTLbt7/mCulvyMgbgF4PjhyBW2+9NL9fUeKqzAMPwOc/f2nW8OvCdV0evv9+Tj3/PJqU\n", - "iFSKd991F++46qpXPHd5eZn//t/vQddnyWTmuO++E/zZn32DPXu2USrluGHvPLuqVVabHQ4vn6DT\n", - "qjOyLCQKk0S4MuIUGkM1S0JYZJDoCFKKSbNnM3AdWkLBk4J2GJFkgINPBKQRBBTQMJGk0WnGpqkM\n", - "CdlEwUEjQ4hGCxWFaVxcKgwpI+gzoseALhZ7SaJh4NGnh80KAoMKGjoRKSJcEgzIEzBkAGQYYdOj\n", - "xpS0SdnQ0XVSoxQThd2kEz7Ly+dQej2ivsGFYZuPvO86dgQBf/Nf/yu/+/nPX7RL/WW49dZ3MRyO\n", - "uO++e3HWjmHmMszOlrjyysvRdJ2p0YhDzz3H+9/ktMYTJ07S6yWYn198+Vi1OsvSUp5a7SDHX3oB\n", - "v7kKzpARko5UGaAxRKUJ1D2NR08ss4CLH0XU6LDhdAlUjUD4aDJihA16wJnQZQ6F7dJgwBoWEp8c\n", - "LQQWm8A8BXIo47OWZYsAgUISkzQSE0EamxGQpIDOZZgEeEg0LGxsfGpozJCggAcE5HFoI5lCYyYr\n", - "+MgHdlJIpzl94gSPHzuB5sCiaSLUkHrUJeMLJqWCgkK9scS6mmOmO0lo6oyEwY8On2OqVMIPQ3RN\n", - "wwsCzGSSVCrFH/zhH7Iy1ojk83nm5+d/5emWV4ufNx33euHaa6/iqadepN3OUypN4boujlMjk/HI\n", - "ZAqEYYCqaphmiiCwACgUJgiCo0hZod9vEAQZej0D33eIh7IKxCRkCxgRVz62AceIaxld4LLx8SSx\n", - "VmQT2EDKPFG0iOc1UJRpVHULyxKEgUuGKTIc4vKxeLU2/hsSgCCiS4MBUEqWSCXy/OCZY1y1a4Zs\n", - "ucy9P36WRj/BoAnCl6yNagzCFTaLGkXbJrAskv0+IylpAH3bQwoNM5QoEWy0OhSrVWzbZk8ux5Gl\n", - "JdYsi8RwyAf27EERgssnJvhvjz3G6Ac/4H3XXkvVdRl2u8ht26hmMkwKwcGVFdxdu35DRt5K+OEP\n", - "Ywv4f9B6fVPx/vfHfiNvVzLy99/5Dv2jR3nn7CyaqrLWaPDl//D/cNm73s2tt97Evn37ME0TKSX3\n", - "3vswudw+8vkKS0vnWF52MIzr2dqqA2WOPPcAz2carJ8bMGxIhmGRFBFZ8owQRIBKgCVLuOYETfcc\n", - "RbtDB4O6G/tESOmQpkkeDw8TmMSmhsUKkiwBKSQdBMuopAlJ4uPQIk2PEVVmCGgjqQAKJ1mmzIAI\n", - "A48We0hjYuPSp4pJBp0+W7iYeDSRCASrZCmSJ0KjTZ8uggvM06OIzkBm2FfJMvA8Ov0tcpkptESC\n", - "tfV10kaCcmWWdx44wGS1SrrZ5JH77uP3P/OZX/mcaJrGhz98N9lskuNKnyt37ryodF/KZKhvbLze\n", - "l8IvxdZWE8P46U4/iiJWVlY5fPgc6+vHmCpvR3c18oFknSzn0AhRxxkyEh0d6ejomQ7VREDNiTjP\n", - "OjLcjmQCQZ2EsoUXOkiZJCRggE4DnRESFZNobP8esUKDDBkgjQPMUyNC4iARKAT4OIT0UWiRwQGy\n", - "KCQJCKmjUGMahQIdsnTpUKXFDjqUBGwqKkZ5J4fPbCC8IUfOrpDpDSlqJTQzQzqKmPPbFJQsiiiS\n", - "0EJwcxhoeAmThW2z2J0OR04NqbUeZHZiJ37gMKDL/zXu7QohWFhYeNNbbq83isUin/vc7/Dd7z7E\n", - "ysoZDOM8zeaAMKzy8MMPoeuwc+cOcjkN8Dh06GlMM8naWpdWqwvMoeshYZglth1bI27FxC6r8e1z\n", - "Hca1szjdJA3UiN0sOsSEZB+wSRi2sO0CUWQRRQ2k1Mavu06SDaYIiTDxyZBH0mDEBVwkKl3M+FFz\n", - "F3PVm2n02vzp3z6NPTiOK9NE4Tzz5SqZTIY9E9M89ux53OY5Fkt5aq4LQUAGeEJK+kHEjGqghBFD\n", - "BdpewJVrG2y6Lo6i0DVNzrZafPbAAZSx6LjvulxVLOKORrSiiGq1ypXz87xYq/Hs2hoTmQw79u2j\n", - "pWmv2cH3N2TkDcD998Odd17aNbz//fBv/k3syPoqxOlvCbRaLVaOHuWW+XmEEJxd3+CB589hu2Ue\n", - "e3iVrS2dqakX+OxnP0EYhtTrI+bnK/h+wIkT5ygWF1FVnXZ7jSuumKDW19lYcZhyfSZJoAgDW6aR\n", - "9PBR2BAZIjmJQMGy1nAweEn6iKGKSZI0AQKTNAkm2SCJx9LY6yPHWeqM8CnG+THkgQlc1vApoLOL\n", - "kBpdOsTjfXk8hkgm6ZJDZ8AUPRYJcRD06SLJoqJSxMNinQQNFFQ2cOnRpE8BiQ70mKHJIhptBLqu\n", - "k07pFBN5TiwdQle3kQxDqrrO3skJOt4Jjh08SPn225kpl3lkaekfdUyVUtJsNgnDkGq1+nKbbHZ2\n", - "ltP5/Cs0BO3hkIlL4LZXrZbwvNWX1/zCC0c4eXKNen1EtXoF7d6QhB8QkMBkG30sBIIFBBoRCi49\n", - "HFZDk1ZooWBSIIuNxMeibE7gRzY5/zTTuEwqBuejEW0y7CZJFpUuCg3SrCEx8BjgjgeuBwTsRGMF\n", - "mzOoFFBokaJNQBuPEBebEjouAW1KaGzHQKBgYGIwQqfOgKp0EVoKzxlw8ngDQ2qkXIvJMEDFJ7Q8\n", - "ZBQwJRXCyMaP0tjukISaoaIEbI3aeKM5hh6s1rt0hha6sYCRnWF6xw3ce+8P2blz52sSqr5VsW3b\n", - "Nv75P/80g8GA733vPr70pQcRYgfpdAXL6vHEE09w4ECGTGaB5eVjbGxs0Gz6GEaV3buv4cUX20i5\n", - "iqLMEoYp4jbMBjHRMIj/p03iSshPUmS648dyxG0cj3HGLkHwzPg5k4ShB5wGPAR1VEwSlEmg4CHQ\n", - "yCHosEWIYJEOgn2ZDAPb5shLJ0kONBJqAV3JYVs+61tb7MxmqXe7pKVPWpiYisJUKsXaYEAxiojl\n", - "6grroUsDCCOV96ZzFFEoaRpeGPLk2hqZqSmMn7lxtIdDJg2DdhCwa98+tk6fZqFUQisUGJZKvOu6\n", - "61BUlR83m6/5XL3NblNvfUgZk5F/9a8u7Tqmp2F2Np7quemmS7uWV4t+v09GURBC4Pk+Pzx0lkJm\n", - "P9WCwVK/z8LCVaysHOepp57hlltuRoiQKAqxrBFS6qiqPk72jPC8EUZ6nrW1s2QUiSc1hjLAIMuA\n", - "AbYwMOUCEoNh6JJgiiEeAosZTHRCXKCApI/JOiaLJChjAzY6KlXquDgozNIlxGCdHCNsygSM0MkQ\n", - "UUfiIsd74AIOKpINYiv5ISYmHtPYjLAZoSCQlGiQJ85M8IAOGUwKZNDG5X5Bgy0gTzEzja6F3PKu\n", - "6zn5oxcolUqUM1mi9TWGUYurthWg32djY4PpmRlUXf+F5fdGo8E3v/n3rK/3URSNVCrit3/7Dvbu\n", - "3cuOHTt4fGaGM+vr7JieRlUU6p0ONeD2669/sy6Tl3H55ft46KGnaTTWECLB0tIG58+fwXFaSLmD\n", - "TCbHyFth5PaYDk1cGuwlT5YkFhZpEpSAF+wG80RItUIqzBIg6OETSYnwkyhk8WkxiFx6KCxgINBw\n", - "iQc2F9BpY9NmDpV4jM5jFZUlVBR0ljGwMXCwSVNkAZURTVpYuIxw8JnDw0RDRccEhuhk6WESCZ8w\n", - "CrFr57CEyj5zmpbjUCGiF1q0hxYOGrqeJAp8FNVHR8P1XZQQtHQaqScYWTYlVSUlA0p0sVRBt5fk\n", - "8D0nWF/f4q67buW2296NaZpv+rl8o2AYBidPrvGhD32c1dUa9XqbiQmTUulqzpw5zCc+cRs7d97C\n", - "0aOP8/jjzxBFWSYnq5w8WSSKXMKwBjSIyYgJzBFXNVziTOYscYWkSqwfGQF7EWKElEOgCNjAJIaR\n", - "wvO2EU/dtFE5ioJHgiImCipgoKCisI5Biwgdi5IQhMMRjzz1d3i2wWXlCS50IzqjCxTkNLnAZHlp\n", - "CUdKqpqGFUQ0bRt0nbyikIkiWsQ1m22onCJigwiMBH0ZsGXbDBIJ9h04QEsIVvp9rhxPxRiaRtvz\n", - "8HSd7du309rYYGBZ+EC5UiGRSHB8ZYX973zna841+g0ZeZ2xtAS+D5dffqlXEldH7r//7UdGCoUC\n", - "wyi2Qq93u/hhGlNPMLBGZPOxWdHExCIvvHCEO+54H1deuZ1jx85SKs0RRXFMdadzHlUJOfzsc7Tr\n", - "dTwELVHCUEEKGyW06OGhyWkUoeIREEiPDB5O7KvKkAlCfBR6TBAi0cb7XociPtvQiUjj0yCizxan\n", - "GDKJwRwaSUx8bEak0XBxkASEXCBDQBaLgIAkHUaENHCYxSU7diJxCDGJpXAlwENhgMIQFUmauCzs\n", - "M2KCDYbsFSG+3yRfWCA/UWb73inEqM4o6FIfvoT0OqzZWYQwWBk+TXXnDNd//Pd+rijY8zy+8pV4\n", - "imBhIc4yGI36fO1rP+Bf/ss8U1NT/O6nPsVD3/8+T7z0EoqUFGZm+O3/5RdngbyRSCaTfPazv8d3\n", - "v/sAP/zhjzh37hiGkSKdPkA2u50oCglDyVDxWWkq6KGHisACQnQiPEChTICGIIoEAQJQyQLrXp8k\n", - "ERYK20mRRgFs8uPRy4hYECuIyKIwIgEkiPCQzAAvMc0KUwhKCM6SRTJNnAXtoOFjEuDj4+PgYI6v\n", - "NIkggcMAgceilCyEEQ0UlAg6bodQCo6LHMgyDjpD2oRBmwlhkjMEfmAjoiYN8uQL03Q6W5RkREMd\n", - "MpUsoHQHbJ58id7E9UzNXk8qNcfjj69Rq32bT3/6E69rYN6lxGAwIIoMcrnYQTWXy6DrGgcPHsc0\n", - "SywtHeHUqTN4nspwWKff76MoRSCLaYLr1omiIlJ2gCni/8rs+EsnrnCYxBM0GrF+JCDeRhT5iYgV\n", - "qhjGBGG4RRgmYPw5kQf6CMpEeCj4gI1PHR3GQYtlvUAlHQAK5/rnWWttMOmMIBzRj8Amie1M4Eno\n", - "CI9p1aPlqXSHQ3KALQSWlMwBqCppCWYUcLSzwWIuSytIMDU5ye0338yZKGLp2WdxazVm02ls3+fZ\n", - "4ZDfvv12kskkB66/nicfeYSz3S7vUhSev3ABc26OW34Nl/TfkJHXGfffH5OAt8L/8J13whe+AP/u\n", - "313qlbw6FItFdlxzDUdfeIG8aYKU2J5LzbI4cM0142fJl2+kd999B+32t1hdfRHD6HLu3IOEbp89\n", - "5VkKmQwH/cdQZRlFZCmmTUb2kJ5sY0ZDRlhEsoGFIElcnnYpkcbCQBCRwcaji0WAJDGemJlGo084\n", - "npDR0YEOgog+KjUEBUY4eJhIHBQGmASUOY+CjiCghE8Rh3PAWQJGRDSI918KMENsVewg8IBZtPHO\n", - "20WSRUEnIE2bNdakhWa7bE8ssKmqfOJ//RTPfOtbXDhzhqLicqYnaXQdEvik1RzZbMh16s8vxy8t\n", - "LdHr6SwsbHv5WDqdo9+f4fnnD/PBD/4W2WyWj37849gf/jBBEFwUUX8pUK1W+dznPomqBiwtOWzb\n", - "di2nTx8ek1OJ5zmoahI7NUQZGoT0UdExlBRO5ODLARCiIXBkF48ZsghAEuLg4lMmIIuCCWQJcXFQ\n", - "SRIhkONAvAAXgwEJ1sdWdwEWGcyxT64CSBIE6PgMmMVCw6BFEoskKkN0+gwpY2OPr7c287ikgL4M\n", - "cFEo4RNFIccxSMp5yoqJFoWEJKgrEjU1ZK7qM+h5LLsRAy2iuXEYLfBIiQE53SBl6YRKQFWfoNvZ\n", - "ZEOeIXXrZUxObuf06adZXV1l/h8EIr4dsLm5yTPPHGRjo8nc3AQ33ngtmqaxtPQi3/72A3S7Q3K5\n", - "KtPTV7C2do5q1ePFF01SqT2sr58nmbyRRuNBlpZ+RCIxj5QCITooyhZhqBGTjyI/kZfGPy8T+460\n", - "iXUjPWAdKRPELR0F8NH1AFWtoKoQRVso2BhSRY6fFRCSJ6CPQocUQ9Lk6VM1Kii6oNeukY0strkj\n", - "+g7oBFQIqYoBunRxpADpEckGfU2J3V6FYBQE2MCsqsapv6FCC40WOdLSpVTI855rrqE+GHCuVuOu\n", - "f/bP8D7wAe79xjc4tLJC/rLL+PznPkf73DleWFlBAZJXX80H3/EOJqpVpmZm2Llz5y9N5v3H8Bsy\n", - "8jrj/vvhD/7gUq8ixi23wNGj0OnAqzBOfEvgrg9/mEdSKY489RQ1e5OeOsEVN930cqrn1tY57rgj\n", - "1idkMhn+6I8+xYULF6jVanzzf36HU89sYup9bHeTA7uSHD3RZeiphK6JofYxpUvdS+EpDpooYUYu\n", - "aelik0FjSAIFlwuETBKh0sTGoMU2BAEhNgA6ET4+GZxxRFps2dzBYJ0sKQy2GKLiUyKgi4/LBBYT\n", - "2CRJ0iPFTnSWGTAkQkGhgqSHpES8645rPWK8z1bp4+JSIEsBwQCbHOvMYGoqD55uYOxcwwkCvvf4\n", - "U5TVOZbaOQL1ZmqySyRGFOUE82GZH/zgMd73vve8wqCo3x8gROoV5ySVytNodC46lryUKu2fg+3b\n", - "F9H159H1DNPTM6yvP0+n02QwCEmpSfZMZ1he3cJyh+Qji1BKhKLTDWEDk4AAkz6WOEdNTqChoeDj\n", - "MCSPTQ6Bhs4UBht0KCEJSBIiGNKnR4IsOhlCkgQkUaiNPTTnMckC6XHmjI2NR0SNCioTqASo2ARs\n", - "4I2nbRy6JOmSJUsLi7T0qSCwULDRcEgRsoEdGbjkECRJp3dQ3Kew7Fqkpy6n6OvIU0eoIgp/AAAg\n", - "AElEQVRJ2k10MWRHwqTjWYS2iWdmUdQshD7VZEi/12VycgIhcrRarbcdGVlaWuKv/urvx5N1sxw8\n", - "2OLHP/4a4HD4cJu1tRyKskC3u8HGxvcolfKsrXlcffW7WV1dwbIStNsOcC1wlCg6QRTZRFGaZPJ2\n", - "HOcIYegTVz0CGGcvwxCVFjoKPklCysApYv3IJDEZWQW2o6oeuZzJqO8jvGVytImADD1GTI2zuxU8\n", - "JAE9kiTRVA/Pq1ORDkL46EgaqECSJjZ7pIONg8OAOSTPATLSqGoafeJG0jyQiCIGSgaUHHYEaaqY\n", - "0ufJzRo3eB4d12Xoeezfvx/DMLjhhhsIw/BlV1zXdVldXUVKydzc3GsyN/tF+A0ZeR1h2/DYY/DV\n", - "r17qlcRIJuPx4gcfhN/7vUu9mlcHXde54667eM/tt/P+kyf51rceJgg6nD3bwXWb7N9f5aabfpqD\n", - "oCgK27dvJ5fLkYgcKv46yqDNO/bv5537b0H6p1lbb9IN+wSRJDDyJDKTTBV2Mah1wNEYyToOK2RI\n", - "EJLDIEKhDggs1giw6FDCRWCikSSBi4VGGg9BgMIkaQQ6kgGCAT4ONhXWUZBcT0ALD4cTrDFNkwlM\n", - "EgQkUDiPRglBTs1QC/tsjUPDJQoBKgqSHkMsUkCNOjUEgiwFCoaHmoqYiuDCw0+hbitS6dnUWGfk\n", - "TZBLlJFKhoF3gl4n4nwkabeX+Iu/+Bqf//ynLtIHVKsVoujgK87JYNDkuuteaeP9VsLu3bvZv7/E\n", - "+voKup5F0yICXyGp+uyfKrNtcorFyjzPHf0m7qiPEaXwjSLdTJXAapPzV9kpXCazNs8OTnFGaoRo\n", - "+CyyRp0CEgOfBhKLJB7DsbmZiU2WAAMdBQUDicGAEJcOi0gkAhuNMjarNAlwaCDQqRKhAAo5EkRk\n", - "iGiTpoQ/DkfssU6OJC4mppBkpUIThzxQJgN0sHDpUGHomvRtyd0f/DzT0/v50d99iaKWoVKa4sLo\n", - "Aomoz6wS4pkdhq5DE4e5Hdeye26eVq3G7j17APtNd9T9dSGl5J57HqJQ2E82G+++MpkCx441eOyx\n", - "5wiCOTQtJIpUdH0nnucyGq1jGDqbm6vU6x06HY0w1MjntzMceui6SxCcRIgpgkAd58xIYhFrirhd\n", - "s0meLZL4jJhEpYCPgkeaeAR4CchhGDOoqo9p9ogiCL1TzLDGLAFVoEPIiHUGmFgo6IQY5FASSTJJ\n", - "E3sgSCqCTpQgIQRJqZEkQw+XIzQpE1ISgrKUJIE9iQTVTIYFXWd6MODQcMiFIESPElgoSIrMqQah\n", - "MDkblfnbo0d5/223sf/d735ZxCyEuMie3zTNN2wU+zdk5HXEww/D1VfDq/CSesNx993w/e+//cjI\n", - "T2AYBgcOHCCZTPJXX/5zBhtblPJpgm7I1tbWReOH7Xab//If/yPHHnmEymCAoao8urLC1J49LMyW\n", - "qTfT6LZHJWmyNtwkIo2hp5gtjahv1FEBFZcseVpoDEmhEhACDjNEJBiwQZoyBgMqDIkQOKj0cEiT\n", - "J4WKgYlFir14PEtERIYUE7gUkHTQyQMShxE5AuxxYHwOhTMETIcjNFS2ABdJcaxHGKFQR0ejgkkC\n", - "lwEBK2SIqJLCtx2qjkqn5eIqHnvNDAXPpcM6ZlphaG8hxB5UNUsqNYFhGKyswBNPPM3tt7/35fdx\n", - "+/btLC6mWVk5zvT0LlRVo9FYxTTbXHPNBxmNRrz44jHW1mpMTJQ4cOCKVwSPvdH4ReODMzMz3HHH\n", - "Nfz4x2u0Wj4vHjxB6Bl49oDltR6DgUMlP8nsxPV0OsdYdbdRnruVkpknu3wP+AU26dIfjYhkSIUQ\n", - "E4FDmwidZQJ04rygPLHTap0cLhlMRqRYIcDBYxYPB0GLMh4hCkM8kjAe8F0hAThMkcXFQ8MnQaxe\n", - "qmACeSaQjNggQZ0BZVQEAlvqRHSxkFRRMYlJQxGBUEPCTJr2yimWlo6TSFTJhQGVShktjCgGec5Y\n", - "LRZ1FdXU0BMqZq7E3oU9eEGEmUxRr1+gUhFs/xlnz7cDut0unY73cmTBT+A4AZ0OeF5EJjONoihI\n", - "CWF4BYoCiUQHyzpPq+UTBFOoagLb9omiNsNhBSkjFCWBEJuoqoIQPmF4nthfpI3OMlVy1DBQ2I1B\n", - "dhwiMCJAJxa9KoRhklRK0u0cJ3KWKFJnhlgKqxOrT1zgGHHwX5oEkT6FktjGQB2io9H1AhgHa06h\n", - "YxCrTiwSdBihR9HLcz65KKIgBMlUCsW2ef/0NF9ebVAUVSqkURRBJCW+qpJSM0hrgxeOHeO63//9\n", - "N+eE/QP8hoy8jrjnHvjIRy71Ki7GXXfBv//3EEWxGdrbEbZtc/83v8lN5RLTe+IY81a/z3e+8hU+\n", - "9a//9cvhXU8++ijrBw+yL5fjeK1GRVEwheDoCy/gpbLUai3SWoKu7ZMOIyrmkPpKF0MpUVA0EBIR\n", - "pnBZJmAnkgl8Qlw2kGxHYRqBw4g+4XhAF8BBJaLAZWSI/QckKj6xiiLCQyOBiYNNiIKDQxoFF501\n", - "2mNlQnwzGSA5S4RGgQiNHn1cPFIIlsmSY5KdePSwGBAwIkuWLUZenrziI6RKRsBmd8iEmmLGSFN1\n", - "ezStZ/CjCSQZzKSJZW1yxRXbmJ+/nKeffv4iMqIoCv/0n/4uP/rR4zz77I8JgpDLL9/OHXd8giAI\n", - "+NKX/pp+P006Xebo0Qs88shBPvOZj77CAfONwNmzZ3nwwSdZXa1RqRS47bYbecc7DlxETO6++w76\n", - "vb/lT7/4X/AsgapcQTa1Hx2XjfYSw6GHH3Tj+DEp6G2dxBcOc26DoplBkSpppU4tdNhNih4RHbq4\n", - "eFj44/jDTRQMbMpEVNBIkGMDDZ0kDkUuECLQEQzJsYbCBCYGLn08pjDo4dPGpUNIEkHIgAYmEUUE\n", - "HRwkIQEqaSBDmxZpfEYoNNDZNjZWAw+JQShsksJhxT5DSkty9OiT7N59PYoWm8uvex2WnB5mcobD\n", - "/oAcEe/bt48rr7+BRw6fZLnlsmvblUxMpPjYxz72qgLr3gqIR9Qjoii6aErMNHWCwCGKJMNhHUXR\n", - "iTVnbTIZldGoy3C4hOdFRJFGFDVwnAtABNhI2UfKc0CRKBoSRVlihcc2oEKSLXxsIqYxSAEaYqwS\n", - "CsgS60nKhGGHbtdDY4VZWghiC7UesdIkIq6zFInlrw45BqENYYZWLkOjeQYNFw0dkxJ1PCI8bGL3\n", - "kwFwFbGU1heCpu+Tsyy2ul1soTJwfbJ6hEqbVjjAjTIYpJnVNHS67EgY5HSdY08+yU033fSm68De\n", - "XlfbWxhhGJuM/cmfXOqVXIwdO2K9yKFDcO21l3o1rw2nTp0ibVlM/0z/upzLUen3OXr4MO+57TYA\n", - "jjzzDLrn0W+3ualcxur3kZ5Hc2BxvjfinbkdjCKbvD/EUByGkU3WD1kVfUZyioJqIqI+WdmmRQIT\n", - "E4lKWinQiSCijU+fPEly7GLAJh08QuYp4uGMC/ouPeYZMBgbYqmM6NPHxUaQpk0ADJC4TALbiXdG\n", - "NiEuCm0m8NmJDrQIEBwng4fPBLMk6TGijYZHkYCALUaUMfCRRFJFkUO6PRvF9EmIJBoauuwy8BUU\n", - "zUBV06TMLjmzwObmMvEH7sWVhmQyyd13v5/f+q1/gpQ/FQv/9V9/E8+bYmFhcfzMGXq9Jt/+9v38\n", - "8R9/7g2dvjh9+jRf+cr3KRT2Mj9/OaNRj69//XFGI4t3vetmICau3/jqV9l47jkuk3BZqcCh+imc\n", - "ZILhyIBghk54AUMbkPRtNENhoZzi7GYDx/cIjTRW5NLxAypoqKh08JkmokAwNklTaKOhotClzynW\n", - "6JHAIo3BNA2G9GkzjY6NoE6ZHlOEbFJAwcFDw6OCRGdAB4eQNF0koBHRQqCPJdRFoMUMXbYD6XGI\n", - "3nk8VonYI3QM6eOJEaHioSlZpjIHGDoBrVaHe+75S3TfY7hxFtfWKRk5ClRoMsGK26aumwyjkF0H\n", - "tvPhm2/mxptuelUxAW8lZDIZ9u2b5cyZc8zM7GIw6HD+/GlOnTqIpm3R6+XQtO1IaSCljWUt4/s1\n", - "THMb5fLldLuncJxDRFEVRdk7DrlbBbJIaRIEk8A8qtomDH8iYi0RYhAyROATUwqQ2Hj0iTcn+fFX\n", - "AMwRITFosMhPnUhM4mi9gNhabQSMRJW0gLS6ytAR2Noilu+QJE+ODjDiFC4hPhKPaWI3kxzQ1zSW\n", - "whBnaKGrKj1Npeu67DVThM4IgzxdpU8PwZLvM1d2WFxYYM8NN+CHIcdefJGb3vnON+nMxXhDyYgQ\n", - "4k+JlUAHfzbBVwjxvwN3EdvT/Z9Syu+/ket4M/DMMzAxEd/832r4Savm7UpGuq0W6Z+zS8snk3Tq\n", - "9Zd/NlIpthoNbkgkKJkmYTrNS6vruKgsSA/LH5BCMmfmGHkRI6/LlD6BqUYcsRs0A5eE6OOINIlo\n", - "FNu9izKaomFLG0fagIKLwhYbuFSAnZisM6RDnYAkfaq0SRGyBej4QIMhOSJ2oKEhsOjRoMSQWUyy\n", - "hJiEGChUUVjDp06fkAANhRQZDNpjIaVDmxRJZhGoRLhxqixdgsinwIgkGYLQphcInJRLUs+gJjTy\n", - "aZd8TlAMz3L11DSFzgarZw+S21PFcZyfK0ZVFAXf9xFCEAQBp06tsG3bxTkH+XyFlZVTtNvtN/RG\n", - "9sADT1AuX04uF/+OTKaAYVzNgw8+w3XXXYNpmhx84QXE+jqLhQJntSyldJlux2bJfomBvBw/CpGi\n", - "zjQ+s5lJmlrA+vp5rMCgL0sY7pCiAFumKY2bMxKoIEkQE60aCg4q54EcKiY9II1CdkxfZqkzRYdl\n", - "JDMoLOBzgXXmadFAZ0CRiBIhJSIUzjIgT4oEfVYRJBEcwCBJSJcM60wSkMUkBfgI5tDYwqYnQ3IM\n", - "MRUfoUzS1jVcx6XjBSzuvJ1crkF9YwnXstil5EmGNv3BBUI9TWXqMsLKNt71yU8yPz//moLw3koY\n", - "DodMTpZ49NHv8dJLj7KxMUBVJ5mc3Em16tBqHSYMW6hqhiBojUlFhlSqihB5pqZ2U6upBEGaIGgR\n", - "T8tUiElHnbh+kUfXsyiKQRSdJgz3YLFIlg6CDUIyqBi4jAhIEtcrZoEd4+8bQIICgjQyTgcfr78K\n", - "nCPemDQwiGQeJdzE7dtE5hxCpMmIJo5UsMaZVIso48kwnwHgopNEJ/RDmobGXKFK03MYCIXFfJlU\n", - "MkPK7dIb2TD0aEZdFnQdkwRbQcBts7O0hkO6v4Z52WvFG0ZGhBDXAGkp5a1CiD8TQlwnpXx+/PB/\n", - "klL+30KINHA/8LYnI2/FFs1PcPfdcWjfpQru+3UxMT3NGd9/xfG2ZbHnZ1oD77nzTu79i7/AHH+o\n", - "bg2HDPp9NBlSUTTaThdThrT9LKEEU/o0vBqBmkaROko0ixB5PLlJngERL2DLPKOgjIYgJSwqImAQ\n", - "tehTHY/XDggpYiAZcBwTC5eQIwgsJCMS2GwnztzcREFg4JAcm5mpKOOUG4GNQEVDH1uEC3K4DNmi\n", - "yR4MNLqsU0RnGwIFlWBsxSZwyBARcgIfkz4OClGksiubYzJpUJkv85FPfIJvfPlrXFteJJfO4zgD\n", - "dldMKvk0zzz9NO993/suen/X1ta4775HOX9+E13XuPHG/eOEUvlzztJrs4D+VeF5HrVah/n5d1x0\n", - "3DAShKFJvV5ndnaWU4cOsVip4Ns2nVGHkRWiEJCNRnRYwTSmIDlHVfOYKORIjtoc6pxhJGfQlQzr\n", - "MqKLhouNRUiISwYYECIRY5niFCYZJDYtigzZGPvlCjQkESMiknhUUEkQcAaBYJI+JVR6mGSxUTAx\n", - "SLAHwZAOF3AZkCTERXKeEWkCukzRIkeSAA0Ln5A4lj6NwhpNtikgQ51e1MbxVUy6JM0cBjWiKE3Y\n", - "OMduvUJez5BWJAnPwxAe9W6D48+3+fFjj7HzVcQCvBVRq9X4y7/8Jo6TZ27uVk6evA9QufXWG5id\n", - "XeTee2Fi4gaWlu4liiwajQGuayDEIu22x9bWsySTBlGkoigm0CJWcATEQtUhcRNliKbNMD19M5ub\n", - "TxCGzyHRaTDEICBkmZAWHiHxXjsApol9garAS6hs4mBgj32FWsQaD5u4PaMS35g9TpNAI4gEoR3g\n", - "0yVDSJo2eVpMoJGiRZGAInAMA58iOUwMBWrRCMdIU5rZRckZsk1GWL7HRLHK4rRg69w5DMtlXzbD\n", - "CSlJ6jrnt7YIVJWrZt98ofo/SkaEEPuAjxA3xyCuIH1XSnniV3jtG4EHxt8/BNwMPA8gpQzGx1PE\n", - "s09ve3znO/A//selXsXPx7vfDcePQ7MJl8CT6tfG7t27eWpyktNra+yYnkYRgpV6nUEmw45du9jY\n", - "2CCfz3PDDTdw+a238txjj7FgmpzfrJH0QqQUdAERRbgIpKIgZZJu4BKpJqX0BBmviulO0g86KFjM\n", - "IElg41FniyZJM0Fo6uRDnaMjiUafLB4JTFxGeDjAAZq0CdgiSZpNuoTMkGYHOhF6LD9EZQODNCYj\n", - "HAI0JB4Cl2jcpdZJMT2e28gzwOEMpymg0aeDRp8ELjouBj5DTEIcVPrMoONTxmBENxAca7hct+8A\n", - "gZXl0KHT3PqOXUzrCYbDAfPzBRYWDhACJw4evIiMbG1t8ed//i2SyV3Mze3F910ee+wUo1GbWm2Z\n", - "mZmfKupbrU1mZvKUSqU37BrQdZ1UysBxLBKJn44db2yc49lnn8S2O1QqOdz2GrPVCsvLK0g1S7uf\n", - "IGmUwGtiBz6KukI5PY3vnWc0KtHuNkEWqSg78dUMivQZhjVsmSTPCrOE2HgYRNRRsciQI49DhCSL\n", - "TXU8E5MnJMNoPPKp0Blb19WJSFNCJYVOD4mLoI06VhiFgIKDjiQiwCeiSJIsYJFBG+eVOOgIIkIk\n", - "ESEGAp0eCn3KSHVANRTMq3l0LYOiZAnOv8R5w2IRhbShEqKCDBCRiumpWGGXcJDi0EOPsPvyy7nl\n", - "3e9+w87f6wkpJRsbGwwGA8rlMtVqlXvueQAhFpmbm8FxHDKZHeh6mrW1JRYWdpJOJ4EyO3ZcS612\n", - "niC4lcGgxmgU4vspXNfEdXtomkUQ+MRTMBXidN4ssJu4ZdPAcWxWVjYJwwHxwOw2QgJsNGLFRuwY\n", - "ErsE2cStmwRxTU1QYAdDAmx6hLjkkbjEtRdnbAXvIZkCdqGxjsRDxUWhR0AOl1kiVAIq48F/F5UJ\n", - "TGqEeEBG0SE0OdQe8dFdZVptn8ixCMIAhEZgO+xcXOT86iqpXI6qaXJFtcoTzz/PVXfeyb5L4Nr5\n", - "C8nIuJXy+8DfAs+MD88BXxdCfENK+R9+yWsXiKtOEGt0LgqtEEL8GfBR4C3iyvHacfIkWBa87Mf1\n", - "FoNpwm23xR4on/zkpV7Nq4eu63z8M5/h0Yce4slDh5BRxPzevUxoGn/zn/8zSSGwpeTym27iT774\n", - "Rb78xS/SPHoUZ71BOlNE9T1qvsMOJctW2EfxBxjCwFF07CjH2tAmFAWGREgEJlO08CiTJIHGoiI4\n", - "j09VRiRKkyTtGtXIpMcIjTIhAaCjkAHqJChikUOyjYARDi4eQ3RyaJTx6SLpEaBxHpcpTFJoWHis\n", - "oNBhigIKggCJi02RLnNIEqh0iN1QPDQMDNL4GHRYpYpKwDQKQxK4TFFiLdjEGUjSxSl0fYHVpWP8\n", - "1kc/eFEVY2BZiH+gbn7iiWfRtDnK5TjV1zASLCwc4PTpJkKscOHCAMMo4PtD0ukRv/M7H3tDr4Ew\n", - "DFlYqPCD7/0d89uvZmZmB83mJg88cD+7dl3Lnj23YttDjlw4xZEH/ieDlQ6KMgdqQNft0dEgl6ng\n", - "++fZs+caLpxwKYYetlAxtCQIBYmCo9mM/AxFuuSZxlA7OBE0ZYABSHQsQtbw6XMZISYRSUDikRy3\n", - "aQQRCpKTSAxi2zp1XCGzAY01aiQYoqCQIU2EQgcdcBGMCBlSIUeGAIsJzrLCTjwqRHRQuICgTYoc\n", - "RcJohogLTJBCRDlkJDGTWXAsVK9BtjSFNhhgez1GgUFCSzMMbDxsbthxK832gIe/9723BRkZDod8\n", - "/et/x/nzPRQlTRT12b27yoULDRYX41uMoigIEZFOT9BoXMB1bfbt28Ezz5zAslr0eqAoZaKoDqwg\n", - "5Q3ouo7vtwmCDnHlL0vcWomIw/AsYkKxAyGmCYI8se17GiF2IeUqsS5kknjP7RBXQgbENEMDhhhI\n", - "kqRwUXERNNERY1eZ3rgpu0EaSTg2DPCoINhkQIkKHgoO8ZRdHoss8ayOREWgoqOiCJVuYMdtPtfh\n", - "2PMPY6Wy1GRERVdZ1JNIF845Dvsvu4zOYIDUNGq2jcxm+dinP/26+of8qvjHKiN/CFwupbyoPi6E\n", - "+E/AceCXkZEesZYG4rN0UQVESvkvhBD/B/AgcRXlFfjCF77w8vfvfe97ee+vYTX7RuI734EPf/it\n", - "4br6i3D33fCDH7w9yQhANpvlgx/9KMGHPoSUkicefZSlhx/mnfPzaKpKEIYcfeIJdF3nj/7tv+V/\n", - "+xd/zDl9FS+dISFNiv0+qwE4gcF5LMqJJKEfUg8V3CAXm18Jg6IwkFKOiYWHADIiRxjYbERdFsI8\n", - "SblBAYFkRI9VfAxCfATnyRDRJU9AEZUWJdYoYREg6LOOyw4ieuOE3oAmaYZoY+GrRp0CKvMYBOM6\n", - "SoCBSUAWSYBGFp0hQ1JUyCIwCNkgRZMUBWALgYJGDh2LamBTXz3IqLfFgZtu4KwdUWs0mB6bxwGc\n", - "q9fZf9ddF73f589vUCjsu+iYEIJkcoKPfOQqVFVlc7NBubyDffsuI5V6pUna64XRaMQ3vvpVvLU1\n", - "9il1Tj/2/3LMyNCLVLZvv5kbb4zFq6qqMbQSHFp3KZBm2szg+i4NQ2V2+w3s2bvI8vIPqdefYhAK\n", - "lmQHMyEJFQM7aKGRJfKHaCJLXkpMIvJagaxS5Kxdw2b0/7P35kGSnnV+5+d57zfvzMq676o+pL50\n", - "ttQ6QAeCHTAQnB4OQQThMWu8G/ba4/GuZyYmdh2x4Ql717Ez/9hjMzMxnpXHgBkhBhAgECAJoW66\n", - "1a0+q++6q7Iq7+u932f/yJRAEgiN2FG3IvSNyKjoNysr336fqnx+7+/3PWjTpk2eNjtRGCZmG0EB\n", - "SYUYDYUsAh+V3sxd9GmNkhwKG6RxSCJpk+AyXUw0DDQ0DNrYqDSIGMdhm3Y/lyamtxWuElF7afwX\n", - "9AeEOToEfb2WgRBV4tCn22limDp5I4tjGdihhk2Zrg9e1GYt7jA6eRvTIzNUmhWuLq79na3f/594\n", - "9NFvsbqqMz3dW3MpJadOHWZzc4Xp6d6o0DAMxseLrK3110AIJibG2di4wupqkyDo4HmXSCYtOh2N\n", - "IDiGlCawARQRoo6Uo/TcVTV6FPOf0hvTuKhhGYHWp4yWkHKdXgHTGw8Likgc4Hy/vFBoc54YD7Vv\n", - "d2ci0MlSImCFBgAKOapohKQZYIMh9L6PjY7FGg4BCgpdYio0KOAS9s+wQkiLEB2binRw0TBJEsZ1\n", - "pv0Ol9s1Vm0bbWiI729uEAUBe6emsJNJCtPTfOj223E8j6JhMDg4+GYt58vwWsVIRG88s/iK42P9\n", - "534VfgL8j8BXgHcBf/7iE0IIU0rp0Ssff6ng9OeLkesZjz3Wk89ez3jve+F3f/etmeL789A0Dd/3\n", - "OfHMMxyamEDrqzw0VWXfxATPPfss995/PwcO3cuF46tETRdbxKSlgibSLCmQS88zPzDOyvoitnQY\n", - "kBpXpYslc3SJsKiRQaDjE6JTixxcDJqRQqrTRchekFWOLgYxNRo0cMmyE4McbSIEghybDCFQsZGo\n", - "ZIhZ4wwBXcYJWUYlZKrv6OrTRSHGQ9IgRqKTJCZEo4WGSRbooKNioLBOQBMLnUEk65jESDRUNMCm\n", - "iYaDgcqwPUgzdPjWt77J/n27OFmvU3NdbF2n4vuk5uc5eMcdL7vOQ0N5VlebWNbLSY1SdikUCkxN\n", - "TbF//5uz5j/6/vcxNze5aXYWZme533W5vLLCl4+d453vvO+lLs/GxiKOY6Eld9BVFFb1KVTNRsQW\n", - "mewQGxvr7NoxRtzc4Lzikk7tJ9RVKs02nUbA9ubl3phE0wiDJgkh8f2IpowoIGkhqWLiM4nBCAoq\n", - "Pl2gjcIeBKsobBGjYWOjUMRgkzIFQlqM4pAnjyQiR4xNiqsYGOzEoonHOmn20MbGpojKcWzWmKTL\n", - "eH97W0PiIMkBTVTGUVgmwENHETZCJjH1JrEaoCoKgSEJLRUlZVOUkyxc3KIZS9rGOKPqCCfPX0Ax\n", - "4IZd17eZHUCj0WBhYZ2pqXtfOiaEYHb2Zi5dOsrW1irDwz0O2b59N7K+/jhCNNjcvIqUbQ4cSPP7\n", - "v/9v+cIX/ncWFlJ0u116XKcxoIqUg4CGlOPQLyF7dNIX03lVEoqFqliEYe+mIKBLr3My2f/aS6IS\n", - "GMAyBTy0/s1GmzSCIUJCJII0BkkSCCLqJIBhyjQYo8UQGvm+saIk5AIeeTbo0mSKmClUyggEst+P\n", - "jdlCQ8NEx6aIxRZtxkWblKpwi2HyE1R2Tt2CKjwWWiWM6Wn27t3LjrExmt0uC7Ua7/7MZ96s5XwV\n", - "Xmtb+l+A7wkhLtEblkHviu8E/udf9YOllMeFEK4Q4inguJTyqBDij6WU/wT4f4QQN9BTNP27X++/\n", - "cG2xsdEb09x337U+k9fG5CTMzPQcYl/BU3zLodvtUtnY4NilS/iOQ2FkhNn5eVKpFFoU4TgOUrpU\n", - "2yGamiGNhyIMFoNNanGOu7NjSDdA1zUKwSqWmkONJT4+XbaxqSDQ+u6XPYGeSRYbWG0sYaDQxcMm\n", - "T0zMABp1gr4jqoWPjsY6Y7goBEjKCCJMGhTosobgDCoeBnq/dNDwSLDNNAEep6mh0SBHSIzFNBIf\n", - "gzQmMSXagCSDQYRkhZgWI2TpkKOFTYcBTAJCGqqBCDsMJYs0mhsEocU//v1/w4njx7ly8SKjIyPc\n", - "ddddr0poveee2/nP//lvSCYzWFYSKSWbm1cYH7ffFD+RFxHHMQvHjnHP2NhLx5ui6Q8AACAASURB\n", - "VCzLYs+OHaSPnqRcXmNwsLeRbmyssLFxmUajSjo9juNsoetThG6VS84WinaRfYNF9s7NsrzwY+Jq\n", - "k07gE1tpiiNjtGs+UilT76zQoMuadEkjGUAjIqRNREQXwXliygSEqHSQCKCDykCfWBwRcrXfiJdI\n", - "mmjYaOiE+PS8ZzwUYgwCmrRx2CDDIAomAZIECjFFAkrY/Xfo0hsavEjhLeNQJWQAwSKSddoMSR1b\n", - "WJi6QU2vcOuD92JpOtWVMhdrVS4KMLVJbh6bI2OY1NttLnklPn//B960NX2jcF0XRTHwPI9qtYai\n", - "CAYGiui6ydzcDIqyzPJyHdPM4Lp13vGOMd71rg8hhCCbzTI7O4uqqvyjf/Rx/tk/+2OaTZ84TiLE\n", - "IBChKDFxbCHlIvSj6ngpNaYDqMTYmEqxP9C1UWgSU+RFsqrCRWK2UWlgESLJEBGRRUeyhYJAkABs\n", - "LlJBIcJEYmLhExLQJUeIjUUdBwhJEGMSUn6pxwZNElRIs0qIShdJ0D8XhTZduvjMC4/5OIBARVc0\n", - "9Chkq1Hh3n134119ntEDB6gYBhsrK6SKRd798MPsuYYJr7+0GJFSflsIsRu4g16HRNIr/Y7+HAH1\n", - "NfHzct7+v/9J/+sX3vAZX2f4m7/pdR2MX5w5dl3hIx+BRx996xcjx44c4eq5c0zmchQTCRrLyxxZ\n", - "XWXfnXcibBvbtrl4bpVsRkf6Jl0ljxd1kSLA6q7T8hTc0GdMaZDTQ9b9daCOwQg2kjLQwUPFIKLQ\n", - "b8dvMYtPjMMyBa5Qw6bniujSpomFwhCCAUBBcg6FEEiTokmCDpKICB35UlM9oE3ABjEWJXbSU34Y\n", - "JMihsEyXMjoxWyTJ9JUaEmjjE3IJmxgVlV1IMqxzii4rxHQQwiNQDaaUFFHQoOUpaGnJ+Pgw5XKZ\n", - "F55+mpTnUV1a4pHDh7n5wQe578EHX+oyzM3N8ff//n1885tPsb2tI6XHjh0jfOQjH31Tk1yllMg4\n", - "ftV7CiGYmxmnVFoglxsijiMuX75As5kkn59EVWepl48TB98jpRr4bpdCqo7X0FioVhiO6lTKLWaE\n", - "xtr6eRYVFeE2sGNIiDQZCTkkEo0VBCY2PVaJh0kZFxeVAVR2YiCJOA8E9DJVu32L9xwOOWALQR2f\n", - "AXycvsmdCoTYeERcIk+KmAFKeKRQSRKQJEmVPBvUGURDI+QWerqOTcDAockSLTIUkZSkT0vEpGMw\n", - "opixqVHMhsulckx+7HYKBZV07RksrUtL97hSWSUIKuSTIaefP8bdd991XXuMFAoFSqWrHDlSRlXz\n", - "QISmnWX37hFuuGGWz3zmY5w7t8D6eonx8VluvPGGXyhXv/vuO7j33km+9KUfADegKGsoio3vn0NK\n", - "jV6Sy9307pVVeiTVZ4AtvDiFGmRB5BCygk1Ih2V66hv6nJCejV2RUVIY1Ikpsw2oJOnSoEGERGEQ\n", - "i54BW0CNkAo2LikkETo+Fj5tMoR0AJ8eiwVUKhhE5MlgkAKu0mSCTbK6jx/UKCIJUWijkEPBEYIR\n", - "06a6vUrXczCMDKpu8Y//198hCAIMw7jmCc2v2bCXUkb0xi1v45fgscfgs5+91mfx+vDhD8O73w1/\n", - "9EdvXTfWVqvFyaee4j13382FEyfYZZoMZrN0trf5ztGjfOZf/Sva7TaNusPM6BzLiz+l1ayT1Qwm\n", - "7DRbQmXnmEG0UiIRBFSlSV1JY0kFIf2+bmKaOtMo+BhUsFDQKSCoMUOFJlUaDFAnSdhvm8MeFEb7\n", - "YWcegmk6nCbBFnl8PAwgh0tEihwNuqQYQyOBQCeDTpMVZvARfVukGTR8TLo08an1Z8seKnUsIqpc\n", - "RbKPEIFGlYAibQSLqGiixoiapBE3sRXATrL/jvuZmZnkG488wk2ZDJmREQDCKOLIE08wPjXFzp07\n", - "X7rWt9xyM/v27aVSqWCa5ktOt28mVFVldu9eFs+dwwLW1kpomkqmkGX8ht3suu0Onn76MCsrm/i+\n", - "zthYGsua4eypH5NQbFRjjLSxwYEJk4yjsHbhAuPZLEG3y66ESqfZZFZYaEGNuoxpY7Bb2oTUSJPF\n", - "RyXEZRUISeExQx4NF4lHiMomw2xTpAV0cYgoM4eCiUD2H8P4VIlYQWGwf2/7ouamQYIWPlChCiTI\n", - "oqARUKNLnQidWdZQyRLyHGXmaZNExSJNTESdGhohczj4ikoxn2f/jXu489AhnnqhwsG5G1iqVkmO\n", - "DXHXnjt44fKzrDS20DyDIXsaXda58OQPeERReOijH2Xp8mVKy8sUR0e59dAhxn6uK3Utsb6+ThBA\n", - "HHdIJEYwzTTN5gZHjjzO5z73+ywuLvL0089TLtfJ55eA3u9ws9nkyJFjnDt3Fc9zOXz4MFE0wtDQ\n", - "MEEwQ7u9ietexTCG8TwX2A1cpjeaeVHw2Uvplag48goqHSzAoI2gQUgViwTTQIAkYICAXqquSZuY\n", - "IQyKqMSotAjJkUWiorFNSIhGgRYzxGSBBAFlHHRiXkzDuY1eN0BiMoxAsEGGNAoCjZgWKreh4KoG\n", - "nchjAsF5JH4UIA2DvJ3CspJsVkuU44jbhnvW+K/sil4rvIXZA9cerRY8/TT81V9d6zN5fbjxRkil\n", - "4OhReAVF4C2Dzc1NMkKwb24OU9c5s7CAU62iJ5PYY2PcdvAgi4uLdLeuYG3U2ek5GKpFGUk2kSWv\n", - "x6wBemqQ5e4GHZkiSBSY8bvgtVlXhgmiHCYKJiY6o0RcYJAcLjZXECgkuAmDFl1OodJj0O8gxkIS\n", - "ENHAArawSVLt+21m+h6NWYbI0aFIjQYTuLi4DACSASIcxvuamXbfvzViCI9lBtExsdkihYuNThsf\n", - "A0NpYGo2YRxiRYJAHWcxdin5SVRlmFB0MBSbnTmDmZlhttYvk/k5gytNVZnOZDh19OjLihHoKZlG\n", - "+kXLtcK9Dz7I//bVx5BrDYrpQdq+y5p/mY9+/tM89NAD3HPPIR555CtoWgMpTU6dOktK17DibRQl\n", - "YP94yAf37uTK5ZBTl6+wXAnYqSXpKia1UAFaZGWMIQRdKbERdFAw0XEJ0UnQRBJzAJ+YGk1idBSS\n", - "WJxgNz4xOjEZPAQ6CVrYZEji4ZPBQVKgzAajQEwHB5syKgF7aXKBHA08LpNgnIgsAR4V0hhMk8Ki\n", - "ikeVNYr91OYh8v3QvTbDaChMEFAmFLDS6PDA5AwrWxU0JY+qqBQsm0qrSbOxSRgNY4mA26cG0BSF\n", - "WmeAhlcl3Nzkj//gD3hw/36mMhlqp0/zleef572f/Sy7du1609ddSsnCwgJHjpzEcTxqtS0mJ29l\n", - "ft7m4sVztFpLjI8XSCQOcurUGU6c2GBg4EYGB2/A8zp8+cs/plqtcuzYAu12jjBM8eSTJ1ldbTM2\n", - "5uD7Ftvbz9IrOPYipdNX1bTocUXW6XVGBHAD9C3cNWxUQGEFjRE00gjKpNgmBgJssphEhJTx8VH6\n", - "kXc+BTRK6BiM0mabPD4hKgU0BkkzRatvi9Yrf1r0ei5pQEcli6DW19BNoFFCMqDY7FJD3CAm1HQG\n", - "7DSdboP10McESrrOhJmkqWoMajpXaiWyO3Zx331vrsPqr8Lbxcivge98B+6+GzKZX/291wteHNW8\n", - "VYsRy7Lw457l8s7JSXZOThJGEa1ul6X+rOz5Z5/lwECaU+fOMxBLkqqOHUtOrl/h9gM3oE+Msz07\n", - "xeXjz+HUEthRh3ElYFVJkhdZPBH34ruli0KHgJg2lX7WhGAHKZJorBCiMNRX3iRQMInRiWjRZRsD\n", - "hU0iGhh9c/kcaRIERKiYRGTw6ZBHRyKx0fD7f5IBCsv4eOg0cUhQRCVBmQ4wT4IEXa4SYxDJEWIl\n", - "AiVHU7rkbImq7kRTJoiiGDcWKJpPPq8xOjpK7Re0Y01dp93pvFnL+LfC5uYm+am70OdStCsbJFN5\n", - "3jG+g3PnzrC5uUkikeDMmfOcPduhUNiLlDl03WQ2O07CcLhl3MPSNFL5PCU/QcHIk9R04jAGmcGN\n", - "JcQ1pOyVkl1CAqCDS5cEoh9nqPQj7xxET2WlDqJEabo00MiQJgK6+NiYFNCRmHgUSFHGJiLJKjYx\n", - "gjoJYsZRSRCwRYUKg7QQdPFJ0SKBRpEkK8QEaKT7/jEedVKMYtDEYQADiY6r6fgyS8JOkXa3+cmp\n", - "GpYFbaeNEDblep2mprFa2qDdSDNkhmiKQtfzCDWdVHqaC5cvkwsC5kd7cu5sMkmu3eb7jz3Gjt/+\n", - "7ZflvbwZ+Pa3v8ePfnSeXG4WXR/guefOIuU673nPR7nnnp/xlpaWzvHUU8cYGDjI0aNnaTY9IGZo\n", - "KM1/+A9/STK5G9u2+clPnqZUUul0hqhUjqHrOkJ0iOMMQrjEscAwugSBx4vb/88My0xgEMk2fl8V\n", - "YzGCSREIEaTpcAWTbQSw3o+N8Impo5JAwcIggUBDwcYgRKeDR0BPbqojKfbf8Qo9r9YSPY3OEPS7\n", - "KjYWETZW/3NEwTJNVF2QQMNN6HRkTGJ8B6JTwzAVtGQCTcswoCVYdzukd97Ax37zN5ifn3/T1vL1\n", - "4O1i5NfA9ey6+svw4Q/DZz4D/+ZXCbOvU4yPj6MNDrJWLjPed3ATQnBhe5u7f/M3AbiysEDY6pLT\n", - "FXKxCjHoQmHEUPEiyFsGG0FIIjdGMjdAde00bac38ZcywJAeUKdNF4ckghRr1FBoM0HMVQxiEpSI\n", - "CFBQyRFRIqZAkrNkaWFSJmILC4jRMChgYCPR6CBxEEhi6giGkERAFZ8xOixgs8YgDQZQKRKxRIwk\n", - "QEVgYmETIbAYJGCNSBSRiiRj6XQcgRuWKOq3ki+OE6kqUwMDJFMuvm9gmiY1KYniGPXnNpf1ep09\n", - "99776gt+HeDkyQsMDs5TKIzA/E2USiVOHXuBjdXz/Nv6/8Hg5ByGsYPBwYvEccDo6Bztco1LtTPc\n", - "OuowlettXMvtNpnRvXie5HR1iSE1iy8VgkgliA3qwsJBpYyNjkaHKjp5WjiEmETERJjAKJJlvKiJ\n", - "JMAlhdnviZm0+zJviYdLhpCIGJNW3zt1gIAsEgWJjkcNQZUsETtQUJH4tDlPgAYYFIlRKFDDoU2Z\n", - "iCEkPuAge3RZEeJHXSJCwlBHlQncIGLP3EG+9tS38JsuXtfD0HVE0IIwpuW7XNlSGRwdZWZsjO3W\n", - "Gs16nZ3j4y+79rlUinBlhVqt9qbySba3t3nmmbPMzNyFovQUc3v33sEPf/g0KysXmZ/vSbmklHhe\n", - "Cc+D55+/DORotaDRaHHx4mm2to6xb988zeZlLl5so+s2UubxPBvP8xFiB0IE6LpOFHXwfeh1Ol16\n", - "xcgqPb8Qg16/QkOli4ZFAo8MXj9AMSRHng5NOmRp41Ghl2+k0cSmiECh2R/YNtlGvtRDTVCmhkkH\n", - "k95QSPKzNJsGPdGxQNLFwxQ6sRTUVJ2inqFDRBA7qBqkdbATSUgJMtPzVDodPnrffYSdDk8eOU47\n", - "bXH/nXu4885brzlH5JV4uxh5gwgC+OY34Q//8Fqfyd8Ot98OnQ6cO9cb27zVoCgKH374Yf76L/+S\n", - "taUlLEWhHsfsfec7OXBTT2cgFIX69haTI5MY7TpJ1UBRFcq+y+LGGocrVTxfR7oRg+gMxU1cp4KU\n", - "4EiTPGk2qaExh8oUPh4xY0Sk2GCFIaYBHZ0EHl0kGWJWSHCEYUzSSEyajOGzjWCTDnVapLDpElAn\n", - "0fdNjHEYYIUGs7jEbNLEZ5nRPmk2TYSDZASnf58OOgYxLhARYlLEVzcw1DqTgxOUamUKmWlUZZx2\n", - "FHHj3j3Ytk2jcRlVtUmn0+y86y5++swzzBUK6JrGarWKHB3lwM03X7N1fS0YhkYU9a7Y1tYWp599\n", - "ltFkEj2TZndC8Ni3fsDOWz7Ovfc+yMmTR9jeXsTK1vC9KkrC4NTWFk3XZdOyuPHWW1laDKgECkbQ\n", - "QAkFrTCkThKHAQQpVtgg0ZdnO7SoksQnQrCMxk5CJGChsYqkSoSNjoEALFRiVulZUaXxiBFUGcKl\n", - "iU+JGm1SBBSJMYB1soTMkiFD3PcocdkgJmACg1EiIKSBzmUCHKaULiEWRqzj4YG0SCk2jtwEmaaG\n", - "RmW7iucfw5Yha9VTFPQ8Y8URrE6DlCUoFnYQt9uMjI2haiqqqOMBozMzL7v2UkoiKTHeZIb+6uoq\n", - "QuRfKkQAxsfHGB4ucvLkEUZGpoiikHL5KrfdNs03vnEVxxlke7uMEEkMY4C1tefpdBJcurRGux2j\n", - "KAVUNYHnbdHTJY0hZQshAqLIRVFUgiBLr+joeY7QF1T3ChIHre/io9GgiILaZw6lCanh0uZGMkyS\n", - "xsWnQbOfNNXT4qSRdNEIcNkgYIiQMQRq38HG4BwCC8lOet2RAmBgcBGTGgkGCAnp0kwoDKbyCN8l\n", - "W0wxW5jkVCtHcWiInQMDeEHA8VqNsfvvZzEMOb6wxuhNH+D2Gw/S7bb4j//xv/Nbv/UhZl6x3tcS\n", - "bxcjbxBPPw07dsArbiSuewjRG9V85SvwB39wrc/m9WNjY4MjzzzD5tIS+eFh3vXBD6JpGo7jMDw8\n", - "/DJy5Z6DB3nyz/6C+cwIJaeFQoQbBCx0m3RbTebzQ4RhnWYo6YQGA9JkKIJFQkzKtPFwSaJSRKOD\n", - "LiI8qRIwT0AbiYWCjU6rr7g5xiAB0zSwiKjhYyCw0ZkixiXAY5UVAgJGiYiQNPv9kG0aNFhhk50E\n", - "1DBQyeID4OCgoPQlvh1qJPAJcHGQ+DhIkUYQMj88wg3T08yNRpTqJjKOUSOLOJY0GlukUjqXLp3i\n", - "G9+w2LNnnts/8hGunj2L57rsOnSIW2699RcqD64H3HTTjXz7249w4fRFLp8/z2QigUhYCFFhx8TN\n", - "jCxssn7lMvO7dnPPPf8DnufgOF1OnXqCndMmvu9z6MABHnjgAf75P/8/KQzsIZeb4/LCT1DEBhtu\n", - "CSfeiSkNNDYpopNA0sKiho9FkkmgQ4kuTVqYBIDHKgYGq8QIYkIi1ggpUmUMk4AyZQJ2YBAQo2NQ\n", - "YZsAA4mkt9HlKTKISRUTixYOERHDJFmnTYiHREEnQYiNKdaJTI22V8PF5hwRoyikZZmU0ClFZTpW\n", - "BksbZqORJGtmUZQFdg4H3DMjkXKc//rCJc6tB9TbKgvNMnPjGrccGGVy/zsIXlF0XNncZGz37jc9\n", - "Tt4wDF7ht4mu69xyyx48D1T1Kqoas39/Gtu2iSKHjY2zqOoebDtJuXyJbtfBtqdwnC2knCOOfTzP\n", - "Iww36RUYbcBFiGGkPEkUjSFljyTee4zRG5pcBi4BBSRVNMqotIgYxSQiQqAS0CaByjAqGiEKSTw0\n", - "AgqEwDJBf0SjoJBBsNG3eHdJk2eKJmlO0eRWfBYR1JFomBiMMo5JiWFKCOqyQireJi8D0gWTsYlB\n", - "fEXh7911F+lkksWlJbBthopFPv7ww3z96z/kroceIAwDwjBgcHCCet3k8cd/xBe+MPMmrupr4+1i\n", - "5A3ia197641oXsQnPwmf+1wvOO8669QB4HkenU6HdDqNrussLS3x6Be/yJRhsCebpb6ywje++EUe\n", - "+MQnXuqG/DweeNe7+LPdOzh+aZWBZI7TTpNlt4PWbXG7qjEoIIpDHF3nbOxgJzI4bZtiGBKjU4w9\n", - "mlgkEBj41KWKiUZvqpvBJcImQCcDXGGYGiMkKdKLwxtCYQOBh4qNQxKwiHDoAiYKQf8OOoPfN1Tq\n", - "0OIsHh5ZHIYRTPa7J+tABYMGESU6WHicAoZRGSCWMWG4ydJ2jGm1+cS7buX0lXWePf1T6h0bJziL\n", - "ZkEsBLfffhuOM8mTT66QTrf4/Oc/SS6Xe93rEgQBFy5cYGlpjWw2xZ49N74hhY3neUgpX7fl9JUL\n", - "FzCbF6hWBG69Sa0J5fJRPvmBe8ilUuyaKPDjhTLdbgchJE8/9SQXTh3GaV1ia2SAW3bPsW0YXBwd\n", - "ZefOcZ599jyl1YCh9ABbkYOdGUcPZpHeaSZCC5vBvq9LhTSLxPjkydLAwybCJqZECoM5bCwczrBF\n", - "Fh+fPG32ABYxCjpDwFk88kh8TJokCRmnxwQooNDCIO7nz0h0DFxUVHRiuqi0MBAohETArKnSikxK\n", - "ms1gHJEJI7Zp4ugpFKEQazpWaoh8/i6kVyZrRoyoBk3nCh3f5+iqT8efJZMcQVXaREYHmUlx19/7\n", - "AO9//3v56iOPcPjqVdJC0JESY3SUj12DD7q5uTlM83t0Og2SySwAURTS7a7xuc99jJGREf70T/8b\n", - "Z8+62HaCOC5QrR4jkwmJ4wz1+nls28Y0p4jjDRqNs0AB112hx8QYoJcdowENhLCJ4wq6bhLHJlIO\n", - "EMc+vaGJChgIzmGqOunIJ02HBm3afV6IS4O4P4oN0HBxSLDJFAoJJFkghWQFSYqIBXQK+DSpEmIR\n", - "YKNi02WBDiGGlUANfJQoCSRJEqEqBh1ZJJYjVP2LnFAiDu2epZW1uH/HDubHxlgrl5mensZSVbZc\n", - "l2azycmTF2g2V+jxYBzyeZM77riP1dUKruteE+v3X4S3i5E3ACl7fJFvvUWzhu+8EzwPXngBrrfO\n", - "/Pe+9wOefvoEcayj6xH3338bV8+cYlcqxXB/40tYFplkkqe++U327N2L9gpLWcuy+O1//a/5r//X\n", - "/013s8acOUb1/AlGNYXJVA5DN4hDj0QckYwCWtLFUnRMTaEkQ9Io6HEd6OCgoSIJiRFsoLONJKBK\n", - "Hh8bSJKnhkDDIcbGRidkgJAmgoiefdI2CjET2LQYo0WSAQQONUqsAa1+FqXODBKXCA1wMVSThNoh\n", - "CqrcKiNiHErkaNGmSwsbHVdJoaIyM7if58/XeN+hPTiNJ9lcWmAqP0mpUkUMzTIxPkcmUyCTKbC2\n", - "dpFnnnmO97//N17XujiOw1/8xZdYXvax7SJBsM13v/tTHn74fa9S4Pwy1Go1Hn/8Sc6dW0JK2LVr\n", - "gve977VNb7a3tzn/3HN87qH7qTab/PnXHsPqdvBdl6ee+wlLK8tksllClimVznPiuacIV5YYDWuM\n", - "Jy18N2ZlYZX9oyOc+e53yQ2OkErqVOUStpEmk1AppA9wcfUCNiEmNqrQCWQENBhHsE2MT5M5FDQk\n", - "NXQkNRxmMWigIdC4CmgUcDEBE4lLhxQwREyNHCUyxGSQDKFT6bvlanSBDAFdDDShoQAV2StthghI\n", - "oxEhWMWh6YYMWYPUZchYuoAeSZrSZ3p2iFQqxeELZwmCLNWtyxhmQNYUzE9NcHGhzLPLqzj+JLHI\n", - "MVrcTcVxmLlhN53OCQ4fPs+DD97Hp//BP2B5eZlarUYmk2F6ehpVVV9rif5OYNs2n/70+3nkkW9Q\n", - "LqeQUkWIOg88sI9du3bx1a/+Dc1mjrGxSUBwxx3v4fjxU3ieSz6fJZudoNOpomkuqjqD627R7bbo\n", - "mYcXUJQMUhqoagJF0dD1TeJYMja2lyCw2Ny8gu+n6A1LdISwSKi3Aav4Ypt9yTS+bHC1W8aXOlBG\n", - "x0QQEOBjU2UMgUabHBEWvWiAAXoeMUOEgGSELiW2WELiM46BQVNVKJhZpCwTRAJNiWkJ6KLjyYhY\n", - "SAxb4ebb7mbvbYcwjRXq1S3+6vuHWdsM2N528IM6jtbg3ZgsLraYm3vHSyOvZnOVw4d/yO7dWXRd\n", - "f9PX9pfh7WLkDeCFF0DX4Rqa1f1aEAI+8YleyvD1Vox8//sXmZg4hK4b+L7L179+lLh8gk/ffdfL\n", - "vi9l23RXVvjm17+OIiWjU1Ps3bfvpVHDnYcOYf7e7/LsE09Q2dxErJ5jXB3EjhVAxY1C1EiihT71\n", - "TpNhIVkNTTblEFmpkqBEmwUiZpCoqLQoUKWAR46QbTa5QhoTBwUdGKRLCpMGkiQeNUr4tIEWSVwK\n", - "qDiMUiXHJD2hXkQRC49FSsxCP7O15/b4PClsUvjo0SoDNPEViRJb2CQZRmcLiaHqxHqWLbfF4TMn\n", - "2T01x1d/8BSDUcSHH/4kiqryve8dgTjmp0/8v9z/4f+JbLbI4OAkL7xw7HUXIz/+8WFWVgQzM7e9\n", - "dKzTafLlL3+bf/kvZ37lh5rruvzZn32JdnuA8fF3IIRgaWmZL37xS6/5us3NTXKAqijUmk0yAtxK\n", - "BcNx8CsVNtpt2rbN5NgYMzMR5x6/yM1zO/C3BdOZArGUnGzXOHnmIrccPMDXvv1N4rZGNtBI+xpr\n", - "HQeh1VGVCkkjQsMjjrtIWcek3Y8xi9iJRg4TkAg8xonZ4BKTDGGQwaXJVl/10iFEEBMTkSImg2Ab\n", - "hQEKbOADl8mSwsNDJU8LlQwehjBxpIurhCzKHkW5hoIHdOmQpssQCpFUSKbyrEmfISWGUFIul1BS\n", - "KerSI0WTQtImlQ4pby9zPt7A1QRr5SaqiLEzBSqOw+DEBJZl4zhpHEdjdXWVOI6RUrJjxw5SqdTr\n", - "+t34u8L8/Dy/8zuf5+rVqwRBwPj4OMVikSiKePbZ45TLOj/96VEAUimNbDbDxYtVwKbVWiKdNhGi\n", - "RLtdY2xsB4uLR4giD0WZJY4dEgmbVKpAq7WOEDH5fJFq9QWGh/ejqi2EKCFlHphCoBPIAIVthnI2\n", - "9aDLQBwyqUaM6FlOuXkcWcVhCZMMCWLCvkNvkl4/lD5hXUFQQNAgIkajSIqQOovE6EywxQp5t40R\n", - "xHjUqcY+WyRwGQTmEFobTRmlXHYJQ0kQwJnlMrVlDbduoOkFfH2CREbjiSdOYlmzNJtlcrlhADKZ\n", - "Ca5efYEPfvC916TQ/GV4uxh5A3j0UfjQh67PEcfrxac+1QvP+8M/vL4M0CYnD6BpvY3NMCwmJm7i\n", - "qePfwfU8rJ8z51nZ2uL44cMUFYViLsep55/n2FNP8Ynf+i2y2SxCCG659VZuufVWoihivVTCff55\n", - "bEWhWWniRxIRBmwTYyg+1cikJAZADNCSklhmieR5hDiMKg0KhBQxyJMkoEaRgArLNEnTxcSkgiRB\n", - "gwxd6qwh8Pst3CpFBumg4zBMQMwFQiaJidBpMoVGmw4uITkcdGxCFkkTYUVdsriMaCkq0qdOB0UE\n", - "KFJHR+JrFlkzTY4ORjbLSlcyovo8/P7fIJNM8qMnnkBurlBID5Js13n2pSPT6AAAIABJREFU8T/n\n", - "4EOfIpHIYFmvn5R49OhpRkZeXrkmkxkqFZ21tbVfSYQ7f/481arO9PTcS8eGh6dZXm6+5utM08QH\n", - "XN/nxIkTvHNsjCOlEqbvo+s6lWYTY2KCd+3Zw7MvvMDusWkGMkNUaxsAKEIwqKps1ZucXlhgRkru\n", - "/8iD/MWXv8765hJhrcx2oKIoe2mKEgUdFL+FTYk0vbIwRGEQlQifGK3vKiIo0pNgg4NgAJsYhxZx\n", - "n9mTIsJDYQmfEj4KkhQaMQsoJDGx8VjEwqdFli3ZwNIlhcwMcWWbJJu0EBgoTCIYIUFEl9WgSyVK\n", - "MZhI0Q4bEHdY3NrgUm2RXfkBSsESqmgzHWe5cSBH2etQpYm1e45YzqJoYwwNjb3UnpfSBWy+/fWv\n", - "Y3sethC0gZve+U4eeOiha6q6sG37VRbljUaD558/RyZzL7ncbsLQ58SJx7DtaXbtmiKVStBuj7Cx\n", - "cZF8XmVoaBjD8AkCaDQmSKdn2dx8HkXp4PshUvrMze3HtiMcZw3LslCUMqY5jO9ryLjSy6OJVlFF\n", - "GVUOsK7ENFNZ/G5MUhlkxOiw3XgeSZOIFF2gQ4ORvmmZ0WeIVYjJoNDsa2NcbAxq5PBJIrFIMSYL\n", - "LEcNkkLHEjGKhAksKtRYZwFdFaTTk4yPH2Jh4QzT0yaT87fQdNt40iGRyjFaGEHXdY4fP0exWMS2\n", - "u1SrVxDCJI5dhoYy3Hbbq0fc1xJvFyNvAH/91/Anf3Ktz+LXw759kM3Cj38M11Ny+IuFyItIJNKk\n", - "hqc4vbLCbfPzCCGI4pjHf/hDDk5OctOOHXiehxZFLC0t8YPvfpcPffzjL/sZqqpy5zvfyQ9XVri0\n", - "tYUuQjxdckVAx0qgCR2/O0w6TuHLAKEm6CoJkHvI6ReYSLjMt9rEUqURdYmlSgKfKVzOY7HJIApd\n", - "ClQBjU0cJClGGWedNabwGCZFhwY5TFR8timhkCWNQYcYjTY6Dh4KClWmcUgQs07IClla4RiKGlEV\n", - "JdJykxaTdFHJmjm6YQ1V3UKVJpqlMDE1RiaT4cKZMxQVBbJJQJCyEhTMBOePfo/RXXv54Adf/4eR\n", - "lL/smde3UW1sbGOar+anJBKF13zdzMwMfirFuaUl0nFMFEUULAvDMBiYmGBHKsWypjE7NsYTp05h\n", - "Sw9N1/GAWMYoQsEPQzTDora9zYHZWQZzOd6xfyfPXnmMexIKT3sdrnjnaQcZVo0mY0qD0UihAtSR\n", - "uAjqhOgI2viUAQ2BIAQcgr79e4aQDVoU0Wlh0iSgTpcqw6QZpo7T33xUMmxjEZAlJujbdptEqNoI\n", - "iajLLhwKaLQJaOKTIw+4NAlZlzGJWHDz4E4qnRKXW8e40TLJqArzY0MEseTE5UXa0TgJK4sRN/n0\n", - "e+/hnOex6SbY2oowzV46daOxSDars7l2hjuyY+zrF5VhFHHs+98nk8tx+8GDr2uN3yycOnWGVGqK\n", - "VstD113CsIFhjOO6BiMjBu9730M0m02uXp3g9OnHMYw2mUxMMjnLsWPHKZVqQIiUdVw3iRBd8vl5\n", - "TLOMZdmsr7fwHA1VsVFxiZVtVCWHrqbwAp2rLgyk94OWoDimovlNVldPMEVMjphL1MjTG89CL1NI\n", - "ImnQY6A4SAIEaWKm8HGo0cFAkqFgSLTIIiHb7FJsFJEkRrAc1sgRURNVMtl72XnjrSQSeZaXt3no\n", - "oUNsbARoWsT0jt2oam9blzLGsizC0Gf//lswTQvXdTBNg25XY/w6U1+8XYz8LXHhAlQqcOjQtT6T\n", - "Xx+f+lTPPfZ6KkaCwEPXf9YBcZw2u/feSGGmyLNnz5JRFNYbDYRhcOehQ1y9usipU5eIY4soDvnu\n", - "6T/l5oMHX3Wn/p4PfID1CxfwSyWOHz2KmkySjCImu10iX2ANjNPwJKttMKWFVASBkkWY83S5hK85\n", - "ZFUVw/cIhaDthaxikSOkRZ3L5KgBGh0sTPKME1ElooNPmi0giUmDDhNAkjouXTwMrhCQZJBhRmlS\n", - "ZgKFMXxsDAwKrPdb9akoi8TG4xKSCzhKGs1rIKRHxhhgs5tECbZRbp7gwvo626ur7MjlSJsmJ89f\n", - "phIojMqYbuk80+8+wMGDt7/udbn99j386EdXmZr62V1qt9vCsrzX9aE2OFjA91dfddxxGq/5OsMw\n", - "+PBnP8uf/Pt/z3ajge55lF2XfTMzDA0N0fI8hKIQhCHjs7O4pW0a5Q3swiib5TX0OGKxU+Xu23ex\n", - "cPUq87t3E0URV8+dY9/wMKHrkg5a7EwKyo7NaghrUQWBQhsVm5gBdLYJSCJpouCSIaaKQ5siDj4K\n", - "MQ5FK8tWOEBF5GmHbXyZRiPLEFOUaWNzAEXo1GSbBHWmUNGR2OiUiTmKSei0mcyOoCZMgm6XUVKY\n", - "6CzQwURSRqejqkxKl5Xt8+jOJpNKyP1jY9TrNerr60SmyQ26ypnWOsPCQ1UjctkMe4E9O3bzxBNH\n", - "WFq6AAgKBYuhoSJpP8He6emXrrumqtw4PMzRp566boqROI45fPgIv/d7/46VlZgwvIiuj5BI6Hie\n", - "i6pqTE/PYlkWlmWRTicYGWnTaHgsLraxrN3Mz1ssLCziujpCVIA1stk83e5JNG2CVsukUb6AjLeI\n", - "4xU0ZRRVmSSIXULWMQyVlC1wvAaCNBdbFXLJVcbzFtPtkDOdDkls2rj9xCho0uOJhP3HVXrU2Rwx\n", - "ETEeMWVMVKPYC2BUJXocoWomMraI/QCNbs86TTq0/Dal0gnCcJtUyuNjH/sg/+k//TdSKZ12u0Mq\n", - "1SP8tlqb7Nmzj5WVS3S7uxgYmEdVI8rlC7z3vbeTSCSu0Ur+YrxdjPwt8eijPeOw62m08UbxiU/0\n", - "yKx/9Ec9Dsz1gJWVE4yPH8A0bVy3w8bGKT760Xs5ePA2Njc3qVardLtdDj/6KN1ulxMnrpDLzaCp\n", - "OmEUoVU1/st/eYx/8S/+4cv+2MbGxnj4n/5TnvrOd1jtdlk9fpwJwyAPNKI2p5urbPl5FAaJpYEh\n", - "A5CbZK0b2W5vMZrwmRMCU1XZ8H2WEGSxGSNFB1inRpOAEQIsBpCUaIokjpwl348+a9Ghw1U8OhjE\n", - "/QAtaDFBGoMGVf4/9t40SI7zvPP8vXlV1n13V98HunFfBMFLAEGIt0jJFoeWRIkKcSTRHtszkm3N\n", - "7tgTlr2anZiInQlHeGPWsfaMJ2zRq4OWLIoiTUokIR4gQIIQiPtooBt93133mXfuh4YoygSpwyRB\n", - "OvT70lVZld1v55OV9eT7Ps//345PmhQtGtiARpAufKZosSR0KoTwaSciqmQ0m5hcRdY6yetRuvu2\n", - "EYsJQpEQs2KF41NTLI2PYwuBlUxy99VXk4lG8RckMokwTz3+OH3Dw6xfv/5n1nzs2nU9Fy48zOTk\n", - "UUKhLJbVQIg899//oZ+rCG7DhvU8/fTL5PPzZDKrXiel0hKaVvqZ+3Z1dfG/f+Ur/Nmf/An9uo6S\n", - "SBBw3dXzpVZjYNs2Rubn2XvXXdi2zbPf+jb18RkuVpdYalZJZjNMVCpkNmyg7jjoloVZrxNUVUby\n", - "FbLpTjJKkENT80y5JvVLqqbtCIpwyTfGI4CHIEULlyIhsngEL3W9mDhMmAbLUhZHtIGiYdnn0bFo\n", - "sIJHCgRUfYMoZbqQSF9q9VzEZpR2FHIIVBbrGl4ohDBmwXPR8HCFTFXrR0g6iphFC7rIUon+uE7T\n", - "dokl4tQadVTbZrFaZ000TUwVhCNJIpkujh0bI7O2gztuuJZPfvLjnDt3jmKxSDabRdM0XvzGN96w\n", - "HBMJBqnPvjGBvFJ8//vP8Dd/8wzN5hDRaBIhXExzDEVJ4HlFurr6yeXa8C9N4y0vT3Lzzddz+PCr\n", - "HD9eJpGQKZdX6OjYhmGs0GqFwYdmw+bE8aNEQosoWjet5jwhbMJ0gNdEFicxpHZa4ioQBwkHNyHL\n", - "IUKyia0HKdZkbDOBonWQZ5QBoliXbkOyQA7ovmSbeQGPJXwal0wVLTwmhEwl1IGkWhTNFhnNo9I0\n", - "CITa8GwVW67jWBE8P4avdBEKr0VVg9RqJ/jyl79IW1sbv/7rN7Ow8AjT03N43mpNDCzQ1tbNjTf2\n", - "kUqFGBs7TDIZ4/77b2Lz5s1XLpBvwjuajAgh/pxVf5+jr3fwFUL8H8Adl55+2ff9Z9/JcbydfOc7\n", - "71/10n/KwMCqVsozz6zWj7wX+PCHt/P880cwTZ9QSObee29g584dAORyOXK5HJ7n8eoLL3Di+Gk0\n", - "LYEir34ZLlTzdA3vwDRjjI2NsXXrVpaWlti370VGRibRNJUPfGAb195solarRJeWCPg+QpFxvUXq\n", - "nk9MbcP1LQx/cVUh1fIIRfvQOqOcnptBajaZtCxkSSMr4iiySlxRCJkGo26dEk0SFHFFjGU/hMGq\n", - "uygIZAJYpDBpMEOQBhuR6EUlSIsCHrN0kgeCWEQwqKID8mpZJaaSIiBlMEUTLdnOXKXMxdYKUVUQ\n", - "0eI0mxdpT/cxMTLPqcqrZNNpGo0GPfE4ihBY1SrPjc/wwtlJzo+tsLYnzcX2FMfWr+cTDzzwloZZ\n", - "oVCI3/zNTzMyMsLk5ByxWIqtWz9EKvXWyyyv3/9zn/sNvvvdHzA9PX4pnlE+/el7+dM//b2fuX80\n", - "GuVTv/M7fP/rXyfS18fI6dOUl5cJpNMELIu8LzHx/FFkWWHD3psZSR3jpuE+dm3aRCwcxnFdnj93\n", - "jlcWF1EvjnMo3+KFhokkBFtVm2qzjmLXMYkgiDBNjbXYxC4py9goXCSIIIaKBKyjwAIeMyjIVLBp\n", - "+hKS0geujOudQ5V9PL+bBa+ARwPJtwFBDA+dCCYeFgYLhAjTSQsFG5mWAZFwjla4QavlMudYrPgS\n", - "qgsBVaKnZ4BkwiJjtNjR0c6PpqZYyedpGAaO62KZJme9PFY0jRvP0N05yHJxgbFimd8ZHCQQCLBj\n", - "x47Xjm2j0VitjXFdlNcVNC6VSnQNDr4hFleCYrHI/v2nMIw0g4PdXLhwDkVpR4ghEgmHZrOOaZ7g\n", - "7Fmb/fsPUCrNEAxWaTZ3ks8X2LZtPUIEWVqSabVamA0Z14gi3AKW4YGfRGvZtOpT4KdRpQGE1yJE\n", - "Ftct47hzeKKILvk0VsZoeSa+7wEWiAEUJUwkGEWrzGOhoxOnyQomq/4ydWRaqCwgIfBIBkL4ER/H\n", - "csgSIJCJkVu3g3hcJz/+KvqUwZlqgawcpYWPp3VT8G0IpBCiSSIRpatrK11dq9L9W7Zs5o/+KM53\n", - "v/sEL754FEVR6e3t5KabNnDLLTe9Z8zw3op3LBkRQuwAwr7v7xFC/L9CiJ2+7x+59PJDvu//JyFE\n", - "HHgMeF8kI9PTMD4Oe/Zc6ZG8fdx/P3z96++dZGT37g9www3X0Wq1CAaDl632liSJuz7+cf70wCto\n", - "NYOW51NxbMxEhu3rdrK0NEWj0aRYLPI//+ffAz10dd2E41j88IcjzJ19nk/deSc/2LePsfPnWWq1\n", - "iIogA0qNmj+KosQIBDXCqd3Y1gqy5LJ2zTCLvsuZqSlM22ZQ0jAdD1UIbMcmq6qseIKSCDDteTR8\n", - "iVUviyxlCrQh0AlgYVFkGZMUMt34CBw0Vu9/M+SZJYOOhMWPu2sagKmkUZUIdXsCtBTd3buZNA9h\n", - "2v34joKws+QXirilZwl7TYS5gNTTgZzJ4EsSAUni4ecPs+J0sPeqXyMZjVGoLGJaKwTkUY6++io3\n", - "fOCtjbM0TWPr1q1s3br1l4pte3s7v/3bD1Aul/F9n0Qi8QsVR65bt472L32JkbNnGbz9dpBlwuEw\n", - "Tz31IprXQ2fnGiqVAo898iSLFw5w38278C7dJSuyzDUDA3zv/CgltwPRuYfCuVEk2+CAsULSrzIj\n", - "cnj+OiBKnRWOcpEYeWp4mGSQ6bskWqUhCBMSA5T9Fr6IYxMlHC0jqBEwoeyAovQh/HY8OvGo4VMl\n", - "TB0dhToeMquzOzb6JZFxCU3SUYSFVS5TdVo0PRWLbiQpDVIYw1+mszPMVVft4MBjj7GmoiN5Hofy\n", - "efpiMSKKguyrzCsqSjQJ8QwT5RUWXI+brtl92S+lcDjMVXv3cuSZZ1jf1kY0FGKpWORis8m9t932\n", - "S8X67WZpaQnPi+D7VXQ9zNDQWqanJ7DtJsvL5xkYSDA83E+h4BAMNmm1woTD21hYCKKqcU6ePMWd\n", - "d97F8PAAzzx1mkRgPYX6FJJbR/N1HMC0LDxMQqzFQ8ZmDpkyCi4tKmT8Ag23Hc8N06YO0PRsKn6L\n", - "gKjT8n0u5vNIhKnRIkuMImVmcXFIIJHGQFBCp0mICXOMm8I+mUQMX9U5bqyQjKsMrOlj165B9IDP\n", - "f/k//5K5pqDVLOCrEE5upS0Uo6Mjx65dG/D9Os1m87Vj1NPTwxe/+Nt84Qs+zWYTTdPeU627P4t3\n", - "cmbkOuDpS4/3ATcARwB835+8tP3H7sjvCx59FD7ykffOksbbwcc/Dn/8x1Cvrzr6vheQZflnthX2\n", - "9PTw6X/3O3z9a89hxdpoS7bT3t6LJMn4fpmurk5eeeVVXLedzs5eYLU7p79/OycPfpcT587hC0G9\n", - "0UCRJKpCISxpmE6Viu8jojvQFBNNW2bjxo1MO7PM1ev0pFLM2DZWy6RJE8fXSApBDYOCHCKrdiO1\n", - "DOo4+FSQGaKGhEcJDeuSJ03gkrqryqokvIGPhk6KIhoLVEnSoAefCVYYJ0TLDeB5M1iegyoE02NH\n", - "CGptmIEEmtZCcUycpoXkyqSpcFUqQr3RYAa46e67OTcxgRFwGGpfQya+qteSTXSxWDTwHJdzR4/+\n", - "zGTk7eIXEVq73L7Xv26cx48fx3Ey9PWtY3l5hvMHHyPXMlFaEkunTzM3Pc3eG28km0igyDJnz87S\n", - "3TfEUMbDDc/TKhi03DhnaQJpdCWG5Wj4JJBJUycERBDI+ECTRVR6iOJg+RYImYCcBqGSToSRvSTV\n", - "8gItO0eAAIgWplAQvs9qrOdxgClMujGw0MhjYuPioqNJOkt2hXYcDJpo9OFLUZJqiEhQo2xqrIwv\n", - "sO3Gq6lt3syBo0fBMDGTfbxsaJSqNTRV4q6dNzFjG6hbdhEPRQk1i+za9ebumDfdfDOxRIIj+/dT\n", - "nZ+ne80a7r35Znp6et50n3cC13VZWFjthOro6HjtZkTXdTQNwmEV02wRCsVYv34blco84JBOWzhO\n", - "kquu2snzzz/NwMCNyLJKoTDNpk2dzM8XOHbsFdraevDsR1lsrmBZCppvYYsiYb8NhI3wxSU1mVly\n", - "FBhAQ0ZmEYmC5FH3VAIijuSspiu+r+J4NrqYYskPEyJGAQOTMkF0jiPQSaAQwCaJQRqBwKJEszmN\n", - "IzQ82SMeCRK2L3L99TcSicQIBgP8q4/fzj/8wxE0fR2mGcEwfDStAOhks1mWlubJXPLnej1CCMKv\n", - "c+V+v/BOJiMJVhVjYNXrZ9Nl3vMV4K/ewTG8rTzyCPz7f3+lR/H2ks3Crl2rIm7333+lR/OL8YEP\n", - "XM+pU2MUCkFSqXZarTorK+Ns25ajp6eHxx9/lni896f28X0fw5UZOXKETYkE6VSK6VqN54wW+WAX\n", - "ejiO44Xp6eqlUpnHs+qcO36QRr5Ij2NR9H3KXoKgGiDh+lTcAjXP56KkkZD7iNsQIYBBgAJ1ZBaI\n", - "kMa4ZKIFy0AEiwYuChLKJX+LCtAghImumDRclzO+wzIyNZJ4/hCuDz5xXFdjuXScZDRLOCBwfZ9S\n", - "rUC7cMCRsVUDw5Rpi0SYLq3WZGRTbcSj0hvulHQtwWJxkcGhN5+hcF2X+fl5PM+jo6PjXfcpeSum\n", - "pxcIBtMYhsGLT36DXLmMJWTMpocwbPqTMkdPn+aO3bsZm5tDDqQx80VEvU7UdckEg1SdAFW7Rlh4\n", - "rLhlAnIYy61cEp7ruKS928QmiCAEzOEQQZJqhOUQDXcZobUj2za2BWFdZaVpEFZUNE9QcyusTtaD\n", - "R5xlAoQoUGSBrkvqEUVahInQcAokcbCpARYRoWD4Joa1Ar7HQFCiYqp8/+BBGoUqLV/hbMGmM9ZO\n", - "e0cXOUVlbmacpw4+S7ojw/B1H8JxDHp7NTZvvtwleBUhBDuuvpodV1/9pu95p5mcnOTv//5JarXV\n", - "czEcdvnEJ+5icHCQ3t5eUino7o4zMjKHbWcIBALMzBzG8+aZnFSpVi+iac+hKAk2bdqCLKsoSgjH\n", - "cdm7dxfPP///IcsNhHDRlSyy7eD5EsJvo8Ey+CYyEjUqZMiTQ0bGxQMCOLR5LlVJR/XzOERx/RZZ\n", - "PALo6L6ERJUaFi5BTOrY6LSIYrIBCR0PgYNMCBeJMI4XQpXi5H0P2wpy8ewkDz/8ImvW7MDzLMbG\n", - "lunoWEO1qrC0VMRxklSrCouLo7zwwpPs2JGks3O1/mphYYFTp85RKpVRVUinM3R3dzEwMPCuuy3/\n", - "sryTyUgFiF16HGe1q+k1hBD3AEnf9x9+s1/wla985bXHe/fuZe/evW/7IH9elpfh+HF4j8xavq3c\n", - "fz987Wvvv2QkGAzy4IOf5NChH3H8+Fk0TeWjH93G1VevOlJmMnHGxmqvyUkDFIuLJFyDLZs2MX78\n", - "OBlZpjOVYpNco5HJsKH/Os7PL7Jcn6JVeJWU5uL5CYr1Fp7XTkkF38uQVxs01TotT0XVWth2nDZX\n", - "wvZWP1QpoIGCywk82gnhY1Ihjk+RBpDCYxFI49JCFhUS0kXWynU2qCqmFeBZO0iBLnzW45PGp44k\n", - "dITQESQpN5boCYdIxyMszTeJ4tHyakR8i3y+Qb5YpCoES8Xiasu0LiPHYpiOTeBSC7VpN2naBpve\n", - "pGNiZmaGb37zcapVAQgCAYt77731DdoPVwLDMIjFQhhGnpHTI/hL8/RkOhAIzGqeqZkpurIpCsvL\n", - "TCwssOC6ROM6egOm5+dJBgK4vk9EsQl6LnFZUHWLtPBYtSH8sSy8Q4IshuRS9gL48jRqIEDQj6JH\n", - "MzTq40SDGpIZQvJL1L0WSA0skaDq1C6VwUaQCRIihUSUOtMkqJO6NIcmpCWafhPPB48aOcoIFLKS\n", - "iiokKngUXZ+VlkW+NceRkyGGs1tw/CCK7KL7Cs1SFd90adfS5J06K4tTPPO9/4c//i9f5vbbb31P\n", - "1w1UKhW++tXvEY1uord3deauXi/z0EOP8/u//xmSySSf+cy9fP3rj+I4HtPTZ5mevoimeSSTG6lW\n", - "E0AM3zdYXDzIhQtn2bBhK65rEgpliMXC3HbbbtraIkyOLGHVQ0xMN5ClGCoWVXeJEEFAockEQZoo\n", - "KBi4mDSJCRvZ9xjzWvRoURpeEcv1VitAhI/iOWRREVQwaJDDpkqDOgKPOglimICBwMBGUKXq+xyp\n", - "lkglcwSVELOVMCkzTUfHIOBz+PARXFchFgsTDOYoFpcpl8vMz8+xdm0n5XKOr33t26xbN8g//uMh\n", - "mk2VU6dO02oppNMxNm3qZN26JJ/61L3v6dj/mHcyGXkZ+DfAt4FbgL/98QtCiK3A7wJ3v9UveH0y\n", - "cqV57DG44w54j8j4v638+q/D7/7uasLV1nalR/OLEYlEuPXWD3LrrR98w2vXX7+DEyceJRpNouur\n", - "05ZTU2fpDMvs2rMHz3GQKxXioRDdQnDGdgjo0+iBRaKtOfZ0RzHqAWZXCpieR1P2MFwVXcmhYCEp\n", - "JhUlQ0xdRuQlUIO4fouav+oJmsLHoUGSEgYyPjIWZZKX7Olb5HGYAmySQY1uGghFx0Yw6fsURAZo\n", - "x/UjSMhohHD8Ip636iyqiEVsO42mhOjKpijPThLRlhiUBbasUmqaNHyXv/jOY9xzz4fZdm0fkjTA\n", - "9LkxokLg2C3yjTFuuPsOtl911RuOX6PR4Ktf/S7B4Hp6e1ft41utOt/4xtN84Qtp2tvb37nAvgUL\n", - "Cws88cSzTEws4Tgm586NYBUDhIJB8MF0TFJJmfZIHxfyeWYDAXb09PCv77iDhx56mJeeOItj2wRU\n", - "lZZjYxpLdOtNbNVDaYTQAylsO49j1gnRBsLBFg7hQAJXChANt4iHHQzbRY469GbbUVsFisuTeG6T\n", - "aMRHUkLUa+eJC5UAEjUsII9PH+BiESaIjoFJGIlBSQbXYpkCJk2ykoLtSVS9ZeIix4pvo/rguA3S\n", - "UpU+EjRaJWQRIBFOsWwW0esF+rMdlC2DvA0DuXaSapD56an3XBvnP+XMmXO4bopo9CdeR5FIgnI5\n", - "w6lTZ9izZzfZbJYvfvHzzM3NYRgGzz33MmfOVBkdLdPTM8TIyDialkLXk1QqyywuTpFIyGSzGRYW\n", - "TnPPPdcyPT3P5quvZfzkeZSFJp5jYbsuOhqCZQQqQYr4NPAJoGCTwyKp6YxbPsJfYcVJ0PIUogJU\n", - "4VD1Z4iQx0QQxUUAg0AEj1eossQ0LVRsYnj4CGaIKTXSeheeohMXIU6W85TkNk6fnqRWe5pAABYW\n", - "likWY2zdOkgsluXsWYVsdgulkiCRyDE8/AFOnTrIgQPH2LbtI7zwwlMkEtfQ0ZGgUJhGkjoYHa3w\n", - "0kuH+OAHb7pisf15ecfmb3zfPwYYQoj9gOP7/hEhxH+/9PJ/A9qAp4QQj75TY3g7+da34N57r/Qo\n", - "3hnC4dVamL9/a2Xu9x19fX3cfvt2Dh/+e/7hH/6Cf/zHv0KS5lm3ZR2yLDO8cSOuEETDYQzXZbC3\n", - "h5t3rGdgOMeWaJihVBrFVwgqEdJyG46XR/IdPGwQChXTRgpksZVeSpSYt8uUPReLVWEjjTpRlggx\n", - "RYpZ+pkkSGFVZFzqI6ZcQ1jZSUjagi9itJJZuvv7ORcMcUqKIoJZFFkjQJ44NnEUoujILCMpJQKa\n", - "R73xPOXlQyyWz1P2xhjwClRqJkUjiKG24ek51LrEYl3lYx+7nfb2Bh1DIeyUidZt8aX/9EU++9u/\n", - "fdlCt5GR85hmjFgs/dq2YDCConRw/PjpdzGSP2G1KPlbLC/H6O3dQ3//zcRiQ+TzJ6lLBpPli8AK\n", - "29Z00N/Tg4jFeOAP/oD7P/c5urq6+K3feoBERwtDWWS+OYWlzjMQr5LTQRVT2HKejVuSXLWzg2Co\n", - "jhSII6sZLEXBUnVCQY9EtA2PAN3pIXrDObZ1bwdHJmo16PNNtuI5NTAEAAAgAElEQVQSrc/RaY+A\n", - "O4vHNAGKpMni0wBcVBoIIC7p5ISG7BnUaSIDJSFRkYIklHZ0f4mz3hlMfwmXFWTytIkoMc9HNAqr\n", - "7keShxRto+hLXKgWsSyD9qDHFj1MoF7hyUe+C0ChUODAgYPs2/cc4+PjeJ53RWJ4OcrlKqr6xoRJ\n", - "08KUSrXXnkuSRE9PD8PDwxiGg2U5SFIETdMYHOzG8yoIEcU0J5iZeZJczqRYfJVbb93ANddcTV9f\n", - "J7mOJNt27ybT3U+6rZv29h5EQAMpQ0rpZTDaf8lNxiaJBZJg0XEoyioGPkWxRFmuUKJIxbvIRn+Z\n", - "dXj04hIEgkA7oAO7MEgzT4Bj2LxCSLxEm3QGyVcYNxo0PZsVu87FegMR6CEaHWB+Hs6dMygUTKrV\n", - "IlNTY5TLRXxfxbbLxOMxKpUGAEIEWFhwaTZrGIZMMLhajxUOp5meXiCXG+KVV0694/F7O3hHW3tf\n", - "38576fkXL/38+Qwx3iMsLcHhw6sFrP9Suf9++MpX4AtfuNIjeftYWVnhxRdPMDCwi+HhMLZt0mrN\n", - "MNUYZahSobOzk8ratZw7f57JRoO1fX2MuS5rhoYoLy6iCYGPgSzLxGI5yqU6NZpgj+NaKWpCRm/q\n", - "5M0lApTxMWmRw0IQoYRghSSwSTJRJJuGp6J4MnnCyEoPshJBwgNJJ5yOk+6YwVY9BoIh5nwLq+Ii\n", - "u1WCko/jBZHIoCLwWCGWUvBEiJgzzYZcDFnTuDAOsy2fFTeAqkcwFZ3ecDcrrSJTkyvs33+YYDAM\n", - "mKTTAW66aTe7du160zXlWq2OLAffsF3XI5RKby3j/k5x5MhxPK/9Na0SWVbYvPl6lsdP8+vXdnBx\n", - "fJyQZZE3TeZLJfw1a/jg7be/tn8mk+H/+r//G3/xX/8rL333u4SFwI9GWZPqxa/VUKNbuevDtxMI\n", - "RDDNbzA2No/rxLGdBhHdJxUNEwkJStV55uYm6evs4+LEcTLNFp2pXubLY8Qti6ArCKOTUjqpOkss\n", - "YOGjI7Cp0CDDquS6K1xMWSWshWi1qkxgseAHWXFDKLTQcBEorBE+CSWI7cs0fZ183UTTLdxAmnja\n", - "YrniIiSZrkgUhQYZHbrDcSK+x8lyieeee55nnz0OZJBljR/+8CxbtrTz8Y9/9A1Gk1eC3t5ODhx4\n", - "Gej/qe2tVoH+/suL8w0P93DmzFE8b1XrNBQKEgjYSJJCV9cWBgcVdN3m3ns/yPZLJlxbtmxm//4j\n", - "mKZGV08aWc4wNX4CqlU0pR1VtomoATQ5zZw7v1q547lUgBIhPNagBGP05YJUp1/kBgd0VFTfoe77\n", - "OKw28tdQLzX0O3RgEpQdVhSFgKzhOBFmHcEkXRS8EPXmMnJkDapm0moZaFqaUCiA59VptV7CMKLM\n", - "zJzANCWiUZ9MpodS6TyPPfYwxeI8lmVhGE18/yefY9/3EUIgyzK27f5cMbBtm4WFBYQQdHZ2vuu+\n", - "NVf+LHwf8K1vrc4cvMdnOv9Z3HorPPAAjI2tao/8S+C55w7i+1309PS/ts22uxkbq/LKygqFQz+i\n", - "1Wjhx5Pc+MlPsmv3bvr7+3n04YeRu7sZO3qcarNCqdpC19rw9SRNuQvPzWNbs+haJwqTaO4ig3Rc\n", - "qqKvoyLj0ETFQkgSbiyGUBQQKlpdoBoBED6qFqFpVQgEdUIRmUCii3h/F8eOHMJtXiRopZFFiyBZ\n", - "KkzS4iKSqNKj+dSbPrJVYWdPho5IhM1dXeQXF3EbPr7aQSzeQUgOYlgWciRBteXyve8d4J57HmTT\n", - "pqtwXYcjR0aoVB7lgQfuu+zx6+rqwLbPvmF7vb7C4OCbF0O+k0xPLxCN/vRaYjKZJBDvpliv8rE7\n", - "7mCxWGSxWCRsmvzmH/7hG5Youru7+dwXvgDhNAdeOIDfqOKl0/yrz3+es+cLRKMpVFVj1649lEov\n", - "YhglNEUnqmaRRBVBE7m5sKoGY6cp5WdItGxa4Ra5gE8VFSQZ1RP4AZ+wFCRpmRSZxCKFBCgsEZKb\n", - "jHguIV8mYJmUPJMSEdLSWlxkSp6NRZag2iQWiBORNITkYrdaWHIES67T1bcGTYtSsV6hrk7hOhGG\n", - "kxESksLY0jzlZpmuTYN885uPs3nzR9H11WNRLKb45jef4ODBI2zfvpk9e65h3bp171YY38C6devo\n", - "7DzMzMw5crk1ACwujtPW5rF+/frL7nP99Ts5fPgUExOTVCoxGg2L5eUKsdhq59mqzmk73/nOPgYG\n", - "Bjh+/CQvv3yS0yeOkZ+bplJoMrVQIZYYINe5ntmZUSIs051bR8WaRql5LKEwT4AoAgdBmxoiHkpS\n", - "yM+jeBKLuoJs26gOFIE2FHwENiFCyNRxaMktEopEe38/M1WJdGQHQ47NeHEWLxhGmFFCoTiDgxqT\n", - "kzMoSoBWqwisMDg4SCzWT71+hlQqRzq9ifPnv097+xZisS20WhdptUY5efIIkuRh2y1UNUijUWDD\n", - "hn6Wlqa47rrLH7/Xc/78eb797acwDA3wiUZ97rvvbvpep8r7TvOrZOTn4JvfhC9/+UqP4p1FUeAT\n", - "n1h18v3TP73So3l7OHt2nPb2XT+1TVUDNJvQEkEiA7cR1UOAx/RMiQ/FYqiqyvrt23nkr/8GUdOw\n", - "/DSKWmextsKK6rJ587UU5qp4To6kHqHVCFF1PSpGnoC/majwkISGS4WyP0Y447FjaIhEOg2SxGMv\n", - "HSNkV6lJKzTcFtFkFE2TqVRabN06zOysSrXQwZpuhcL8GG7TJu0tEtMkkFp0BCWMRoNlT3B1SGGj\n", - "olCtVnnVtrlx7VoeXjlKznGRXImma2LJPmY0SaNRo7d3C/H4aiugLCv09m7mwoWXmJ+ff60q//UM\n", - "Dg4yOPgKExOnyOWGkCSJpaVJUimTLVuujIJje3uKubkSsdhPxNaEEKzfPECiw+LQwgKKECidnXz6\n", - "Ix+57MX0xImTPPzwcyQS13Df/bdRLq9gGJPs2rOHweElnnjiRwSDXbS1xdm8OczZs2dIp4dwnCIB\n", - "xUb1Kty6ZTMdsszFyhKziyXiskVQSOi+i0mAtlCE5cYKQadJKNiDL1lYxjRlqqgCYnKRcLiPqNJL\n", - "xaxQtVrUsdCx6dFStHwfYZZpILAQLLgV4lqKeDSJJUHJaVILBQiFdPywzR/84WeZHz/P+W8/QqO0\n", - "SMEOI2SdWHYdS0WD2tgiO3asFrwVCgVefPE4ntdNqdSgWEzzt3/7FPfeW+eaa65MN42qqnz2s5/g\n", - "hRcOcuTIIXwfrr9+I3v2fOBNiy+TyST/9t9+ht7eH/Doo/uYnZ1GlkM4jkZ39/X4fpbR0UUc5wJ/\n", - "/ud/iW3nmJ8x8fNJcqEQCeccV6eyjNWb6J1REok15Ocspmrn6YwGOG2mqFhpgoSQsZFECxFw0X2P\n", - "EBIyCsOxdmbLs0R9l6AnwAtg4yALgfAFVWVV60NJ6Vy/axdHzjQxahH0aBxVz2Imk5RKZ1HVEMPD\n", - "V1GpvIqul1EUjXQ6x3XXbWdysoDjSKxbl+HIkUdQ1Q4ikU4mJk7h+01SqU7Onz/P2rU55uf34/sx\n", - "urszeF6ZRMLgxhvfsjSTfD7P1772fdLp7bS1RQGo1Up89auP8qUvfY5oNPq2x/ty/CoZ+RlMTMDo\n", - "6L/MLpp/yv33w2c+A3/yJ+9vR+IfEw4HsSyDYPAnmiWu6zAyMsqtt36S9vaffAEvL8/w9NP7uemm\n", - "6/irv/o79l8wCLQcQpaFIoMRTdGWipMMz9A/HGB0JkitYGM7Oo4IYok4SRFcVdoUPoFACFn0ouU8\n", - "RDpNNBrFNE06ImHisqCrZy2RSCeNRpWlpRUUxaSjo5+FhVnCSoxqrUkiqNPwGth2g6TwcDWZhiuh\n", - "qDJ9bT0EGzUqVYuAZoHv097VRWdHO2OFFqaooYfiOJE4gdQw3twLXHWZIlUhopRKpcsmI7Is8+lP\n", - "/wYHDx7i8OFjOI7Ldddt4MYbP0ww+Mblm3eDa6/dweHD36ReTxOJJCiVSoyMnEDXF7n7o79DW1sb\n", - "lmWRSCQuu/zkui5PPLGfXG77686LACMjLb7wha/w0Y/ezp13bqNcblCvt7jzzk/T0fG/cebMWQzD\n", - "pqurnae/9S3WqyoXDx/mtuEewsKkOjaGaDapOQ6WLxB+gClHAmmZRKOO43vUVJ2OxHoGs0kuTD5P\n", - "TM6gShBWYtRaLogIrm8zZtYJyB14UgjHK+F5VQwtx4hVIVVqYkoStZjHb37pQTZs2MzQUD/9/f0c\n", - "P36cvzx+guL5PKloO51dXaghnaPFAs1mkEJhnmy2mzNnLqDrbQjhIUkGyWQboVCUH/zgINu2bbli\n", - "rdvhcJi77rqdu+66/We/+RKZTIbPfvbTfPazn+Y//sf/zKFDS3R27kWI1djrepwzZ85w4sQyN954\n", - "A2PHLrKmvRPXcTgweoHeDVmuCdv8qDRNV9d6QqEoczMvYZs1tPh61rga9YZJFBnHsZlrLBGywcOn\n", - "6QjOLs8wFPAxZBnhyyygsCJkHAFNLLxABNMzEa7LzOQkphugt3eIlXyRml0mG4/j+2EWF1cYHS3Q\n", - "aGiATEdHhkDApa9vLZp2kdtuu5ubb97N44+38dxzC8zMnMXzNPr6NqNpOq2WjevO8OCDd2PbNuVy\n", - "Hd+vMjg4QKlUIhqNvqnA4IkTp5GkHKHQT5KOaDRJqZTg3LkRrr323fEm+lUy8jN4+GH4jd/4lyV0\n", - "9mZcey14Hrz6Kuz8+T3U3rPs2rWdxx8/RX//jtc+iJOTZwkGo7S1dfzUezOZLk6f3sf4+BwjIwVC\n", - "0RswVZ2aVcH3DXKZJEF1hYg9z7n5FngaihLGsjx8L0jJA08YxBUNw3OoWHlinUnKwuRUq8XJfJ5K\n", - "tcao0WDTrnu4OD7J5OQkjuNRrVZpa+tEVcOUywXyy7NEZYEphQm7VTKeQQwXw4A516YRybDWD+Bq\n", - "Jqbr4psusmxQaTZJJUOsHepledmmbMvEtAC6dIFf+7XdRCJvbAXz/QbxePwN23+Mruvccstebrll\n", - "79sam1+W9vZ2Hnjgw3zve/vYv/8iExPzpNNZ1q/fwl//9RPs2jXM3Xff8aYX3lKpRKslyGQiNJtN\n", - "zpw5y5nT4yRT/fh+O8vLUSYmjvOpT93Cxo0bOHfuHPv2HcD3fbZtW8eGDRt4QdfJpFLke3uZmJmh\n", - "IxbjhOPQNEwygShNx2bCtxBShoS3SIQwshwmI0k0jDE6O+5kudWN78fJ111akk/eB10Iyn4QXQSI\n", - "qGEs16FhCRx/BSFpOGofo2YRR2rybz77SX7v97742v+1srLCU0+9xIV6iCZh0k2HmYtjJNcMcNVN\n", - "9/Dssy+xsDBNKtVBsVgjleqkUDjL2rWrM0eBQBDLUigUCnR0dFz22L3X6e/PsX9/5bVEBMBxbHwf\n", - "HCeCYRhoQiAQ+L6PKiWYnJ9BM3xqrkSqaz3B4CJqQMcSgngoTH3RxBMyVa+JhY3q+yyYY6i00xCC\n", - "Ec+mZri0awoTnk1JJAiqOVYkiQZ1ekMwFFZIpwI0Ck0KS1MYlqC38yo2r1tDsbaErg9x5503sLIy\n", - "j+8rjI0dRlXj3HTT3czOnqKtzefjH78P0zQ5c2aUuTmHSiVKIBBkamqcNWvWk0gkSad1hoYGWVrK\n", - "c/Fig2Cwm1OnLH70o8f44Ac3cvvtt1z2uJVKVQKBN4qkKUqIarX+jsXrDX/vXftL70N8f1V/46/e\n", - "N7Js/zyE+InmyPs9GRkfH2d2dolGY5yXXhqjo2MtsuwQiTTZtGnwDV9WjmNRrVaANM2miSSpSK5K\n", - "JNSFabdwHIeK1SIa9DHtMBFKlBtncL0EDSeGi0dLb8NwbQwxjx5ai2kFSHe1c2zhFKYhSMaGUFWD\n", - "fT/8IaFQH/F4Gll2keUk/f07OXnyNMWZQ2Q9h5jdpEKenBYgLOI0cVDae8mZMmW7hhbqJV88jR6K\n", - "YDarXKzWmS+VqKUGuPrqu2k2XRYWZpCkee67715isRhPP32MUChKOBzH8zwWFkbp74+956zEfxZD\n", - "Q0Pcd1+QmZmH2LHjTiKR1Q4Cz3M5ePAVNm5cy+CbeKrouo5tNxm9cI7JMyMsT0wTEBEKldNIsRKp\n", - "VI5wOM6TT+7n9OkRjh1bJJUaQAjB2bOH6O9/lXOzszzxyCNs7ullw/AwbqNBZnKSU2GBHu+maTXw\n", - "KiXk0jJhP4IqB1CkAIGggo7F4WPPsn1rN+VSmJJQUYIR/JaD02rhkcfxBmjYFr7nYkoNfFkib1eQ\n", - "PB9UmUDQR1VVHn/8+1x99TY6Ozt58skf4jhdbL/6NkbCRRQ1hGsaiFiAzs5+hofHqVQusrTUjmWV\n", - "WV4+Ri6n09MzDKwWPHqedcVmvH5ZlpaWGB0dAwS9vd2Ew6dYWholGEzh+x6uW2FgoAvwURSFfL2O\n", - "Lnxcp0HNmKFVLdCf3UwomkWSZGZnR7GsNZhOg2INDHMRz3Xw3TgeAg8PDYmUUqBbCyJpXUxWJph0\n", - "DdK5HLqXJhLqoGE0UZpNkqpCCR9F34jTFISCbZybnMAIaWzuvZb8RIHt2zeyZcsmhIBGo0KlcgPV\n", - "6gn27u2mq6uddevWoWka3/7246RS21CUA8hymnC4A8MoMzFxms5On8HBazlw4DD5vKCvbyfl8jKG\n", - "0SAc7ua5506xadP6y37W+/u7OHbsxGtF4T/Gsor09Pxy1g+/DL9KRt6CQ4fAtmH37is9kneP++9f\n", - "9d75sz9brSN5P/L88/t56qnj1GoaExM6y8sXmZm5wG/91ie5997P8zd/8w2Wl6dpa/uJOuv8/AXW\n", - "retmaSlAOJykVMrj+RkggCxkLLuOLK1QqTXpQmKovYeSJJhbush5bwJXbUNVE1hSA8XtBlunWVri\n", - "yMElDAeSWo32UhXJlWnzw5QMBZHoxfcXyWZrRKM6o6deZb0eQJaTmI2LhH2fqNlkxXOItK1haHgH\n", - "U1PLlIs1Gq6NEskxKkzmrBqBXDtrrv8gG9LX0dnZj+e5OE6LkZEK/+N/vMTOnRswzRorKy9TLMbx\n", - "fZstW/r58Idv/4X8Yd4rjI2NE4sNvJaIAEiSTDDYyenT5y+bjDQaDZ79wQ+YP3OQ88cnyaS6kf0Y\n", - "6ViKYn0KYa5w7NgLtFomZ8++gBAp2tt30Nk5z8aNa2m1QvzRH/4FEWeZNk/lxXOHORh6mTXbNlEM\n", - "x7h6YDfd2X4Azk0d59yhp0gpGSJBDYGEYXtYNCACbQM5JssTGOF1+ATJdu9g/uL3CXoWME/NlbBp\n", - "EU4k0fQhdL2DSKSdWm0Zyyrz8suz+P4gL7/8Le65Zzejo/P09OwhEAhy4cIk0eggiYRGsThGqVSg\n", - "o0PlvvseZGZmAUlKMTNjcNVVt6yK4QHz86Ns2ND1z5Lqf7d57rkXeOaZ4yhKFs/zmBx/CWP5KIlg\n", - "jmZZkO7bzPard7O4eIzZ2Qn27TvASgVGT++jU2rRq9QwWnXOLpwgs/VTjI//CMPQ2bx5D/n8aSYn\n", - "VjCa/bjOFFkpiOIFEAjquHiiTH9yJ5oSIeh5rFglhDZMT6aNo2OnUbQ1tCccEvEIU2WV/IJDrj1D\n", - "W1sXmaEN6DmHm27qIxwOs379T+qvIpEEiqIRDndy5523vra9Xq8zPr5Ef/+NVKsN9u07QKNRAHws\n", - "a4KdO/81lUqBM2deolrN8uSTB9H1LJlMN5LURJZLnDp15rLJyObNmzhw4CgzMyPkcgP4vs/Cwhi9\n", - "vTpr1qx5N0IJ/CoZeUv+1/+CBx/8l1E/8fMyPAw9PfDss3D7z790+56hWCyyb99RZLmPixfHiESG\n", - "WbduK0tLJ3nyyVdpb+/gYx/7CA899A9MTS0jRBDPq7J+fZbrrvsADz20j+7uHly3zoXyaeqtGI5r\n", - "EA9XWNsdZGF8lo19O2nv6CCYCNM2OIh67hhzajdDG4fY//zTROQU6aCHZGu0bA/NahLWMsg0CMpZ\n", - "VKmBJMp0dcVJpTZQLL5Eq3UKapNEAnH0SAsv3c3IskvBNnFsk3A8SzKZYGGhgBPrYgLI5+vE40ME\n", - "uraw9bphTp89yUc+stppMjMzysREic7OPZRK47S1rSOZ7MU0z/Hggx8jEom8L/0rfozneZdNooSQ\n", - "XrOQfz2+7/Odr38deWaGO4cHSU5NUzMWOb48gk2RzoTOYsXj6JFxLEdnaSlANBqnszPNygrs2/ci\n", - "J05cQDbTdEUj9ES6sO0W5fJJJkbGMbMdlKbPYDsWiUiK+ZVFHF8jqIaIhEIE9ACu6+LUTTKdKX7v\n", - "j/8YwzD4/d//z4yPzxKP9zG8dRsz4+O4Zgw9JBMJa8STSQxDZ+PGbZTLBTyvi0ikA8epEgxGSSR2\n", - "8NhjL+C67iXzwSzbt2/k5Mlj+H6cSmWWYtHjk5/8EJs3b2bz5s3cdtsH+d73nuTo0UNIUgzPazAw\n", - "kOKjH/3QuxG6fzaWZXHw4EH+7u+eYM2a3WSz3UxNnEYv1NkajhEJ+SCFmJp7lfPBMrfc/gEajSqG\n", - "UUX1pxnUPVTLRVEE2fY2suFuphvnEEJn69bbUFWVbDaLLPscPQpRkSQdDeMaJqYhEbey+LKDIxQc\n", - "s4rrqXQmhmhlIqQG17NeH0BVQ6QCkxQnx7GNBC4KxaJJteZS8Jts6t7A+fPjnD59nlJJZv36dSST\n", - "q4JvKytT7Nnz051Nq+f06vm+fv02ZmaqeF4IVdUxjNXl11deeY5sto/FxSKStBHTDFOpCIaGtjM9\n", - "/QrHjp3izjvfeFHXdZ3Pf/4+9u9/iaNHDyNJEnv3bmb37hve1bbvXyUjb0K1uupFc+7clR7Ju8+P\n", - "nXzfj8nIzMwMnpdgdHSKSKSTQGB12jkW68W2Z3jhhaPccMO1fPGLn2diYoJ6vU46naa7uxuADRtO\n", - "UK+b6HqdweENzEyMEVJLrOsJ0dMRRKnGKBhFzpxrIkgBMnk7gB6q0te3noi0j45AFAkwXBeQSAqF\n", - "ZmsRtBABPYFh1El4No3GMm1tgyhKhN7eFPZCkGwoQDTczcmFCtHMddRKoyhujXK5QLmSR08HMEWM\n", - "WtUjlL6agbWDXHXVejo62hgZucDY2EW2bt3CxMQ4kUjfpfVz/9IxSDE1pVOr1a6Yeurbxdq1Qzzz\n", - "zAlcdwBZXr2M+b5PsznPxo1vPHGnp6epT01xXV8fF8fGWNfTQUTXiY7azPo1dC0OJJGI0WxCV9d6\n", - "TFNjdnaajRu3c+7cKOWyQ0ZWkDAvLQF4QBbRmMGJaUwswdTiDO3JAiulGQJqlBJV0moMSUg4kkve\n", - "twiHNcrlMvV6nZ071zIzc5JwOEM4HEWWIRCIk0j0YxhzjI0dIZ2+Fl0Ps7JyFt9P0tWVRlVX1XDj\n", - "8Qy+H6GtzWN5eZpcrp+BgU3kcn1cvHiCRKKL//Af/t1PGU8qisK99/4ae/cWKBaLRCIRcrnc+2KG\n", - "bGlpiYce+g7Hjs0xN6exuHiEtrazOIUptibaaaoBBgaCpNMpdhgG44AkKQwMXMfWrSmee+S/s63v\n", - "KsKhGKXSHJJUQw/0INvG/8/ee4fHVZ55/58zvWm6ujQqlixZtmRbrtjYGIyxMcamBwgGAkuAbJZk\n", - "U678tr0hV7KbvHu9IbvJbhohJBBCMaH3jjHuRbZkFatrVGfUpvdzfn+MkRE27rYkez7X5cuaMzPP\n", - "ec48c858z/Pc9/emX9ShVCrweAaYOdOBw5HFoYaPUUbl2G0WlDItba1NCDIBdSJB72g/GiRkci0G\n", - "nRJjuh2z1Uw4qkIUFchUCZzDe9ArHKhkGiQJwsgJijp27apBp1vI7Nkr2LlzL62t7cyeXUY4PIzd\n", - "HqO6erwwTEtLw+GwMTjYi92eyyWXzGXHjgOMjAyg13tpaHifkpLZmM0G9u1rwG5fgEwmx+8fxOfz\n", - "otWacbuDxGKxYxocpqWlcc01q7nmmtXnaSSPJiVGvoRnnoHLL4esrInuyfnnK19JGqAFg1PPW0Uu\n", - "l5NIxAgEwlitR9a/JSmBWq0hkVDj8XjIzMyk5BiGKrfeej3Tpu3mww9ldHV1MWdOMVkZJgrzsjBY\n", - "rRx480227ehCIaajkKuRpDh52XNoDxzi/fdfRJeI4w31okJNLB4jjpxI3I9MHEYhaQERtVpFMOol\n", - "HgszNOSkvX0PPl8WKkMlLinA9voajJqZpGmsuDRZxPUaJJWSNw7uYsbCK6ialsGBAw0sW3Y5RUVF\n", - "qFQqEok4FouezZvfQKNJEAh4UasV+Hwj2O1pY7EAgqAgFoudr+E4Z+Tm5nLZZRV89NFONJpsBEEg\n", - "FOpjwYKCY04tj46Ooj/8Y2uz2egURTI0GuZOL8XX209zXxcRsYSQ3IfZnIPDkUtLy26iUQuhUABR\n", - "hGg0RoReZHITo7EhEokECkUawXAUtSqbhYtX0tBQT4AwSl0eIm7CehM1wQEEMUZAhKF4kEUmB7/4\n", - "xeu0tnaSlqbEbrcgihI6XYI77rgHj2eAffu2MG9eJkuWrKS5WU447EShiJKTY8dqtTMy0jmW/SBJ\n", - "IldeeSlvv72Fzk4ParWJaNRHdrace++970srYNtsNmw22zGfm4xIksSzz75KIuHAbk8jEAhjNNro\n", - "69uPyuNEbZ5LWJAhCLKx7DCX04nbPYxaXYRSqUKnM2I0WJDJZMjlasrLMnB2u/AMDqPNKKW7exsz\n", - "ZlQybVoRfr8fs1VCCMTQqgSUigQzZjjYX7cFgxQiLkrECIAYQ222Yi+ehSbNTFdXH2BEFEPEDOl0\n", - "D7egk2dj1Jqw2QqJu0aRYl1Mn16NRqPHZsviww9f5oMPnmPBgksQxSx+85unuOOO9RQWFo4d/4YN\n", - "V/HYY5twOkfRaExUVNiJRoNs2PBV/vrXl2lt7aG7W0U4HGRgoAajsYBw2M/gYAuLFs1Eq+0jkUgc\n", - "U4xMBlJi5BhIEvzmN/Af/zHRPZkYsrKSmTWvvpoUJlOJoqIiNJr3kMvjxGIRlEo1kiQSDDqpqCgH\n", - "BtBqtWMOhV9EqVSyZMklLFlyyVHPxeNx3n/1Tcy2EnKtuUSiUeRyBf0BPxkhDXK5h8HRPnSChyE/\n", - "RCQNcRJIQjsFKj3RKESjrShVCqylDvLmlrNv3ydMmzadFY0yVUkAACAASURBVCtupKnpEDWfbsMd\n", - "SEeh9pBhziAvr5LFl69AJoP6+o9YtaoKg0GHxaKntDQ5lRuNhtm69T28Xi2hkJLt2xvweA6hVPoo\n", - "LCxlzpz5h/sfAzxTLmD1MxKJBDKZbGzcrrpqJeXlpRw82EQiIVJRcTXFxUcHJwOYzWYCh5dvzBYL\n", - "GcXFdLS2Eo3FcBQV0Ce6ycoqJbewiEOHRtHrLeTmFtPcvAWPR8HwcAuC0AYyGTqlBTERJxbzE48P\n", - "EhQEHPkLsNkzMJmMDA42MGvWJXz8zm9JM2jo6U8nFk8jHAuBIsDwsIzm5j4slgpEUcRobAeiuFxh\n", - "mpvrMJkUrFkzh7vu+gput5vf/vYFrNaZTJuWS11dHyMjw2RnWzEabXg8g1gsUFFRQWlpKY2NjfT1\n", - "ucnIKGLGjPJJX5PmVOjv78flCuNwZCOKClpaDgI2zOZSOp0fEopFiMW9ZGUlM4TC0SgJpZKqqul8\n", - "8IETo9GGOacYt8tJhtEKBMnKKsOUkQHBIJetXcvHH+/E65UYGOgkFgtQMVPA1S4nI8uMUqGkp7+R\n", - "/Gw1/qiFQrsFoy6XLpebxkCCrxTOQqPRUle3n8bGbVithQiyKuS6FjzhHrLTC5GrooTDDcycWTxW\n", - "LysaDSMI6eTnF1FdvRyNRoPfP8qTT77C97//dTSHC6JlZmby0EN3U1t7kP7+QbKyZlBZeRN799Yw\n", - "MCCgUs3AZEonMzOA369FLh/GZpOzdOkczGYdNpt9rC1Iirv6+nq2bt2Hx+Nn+nQHS5cumjCBmhIj\n", - "x2DzZgiFkoXxLlbuuCOZVTPVxIher+e229bQ3f0YDQ1bMRrzkMm8FBTY8PtdyGRDfPe7D9PXN0Re\n", - "XgY33LCaZcuWnlQWgUKhYN6y5TzfvZdevx85ECZKblkZPftqmDVrCZ2qNHx1e1CpBOLKKP5APz6t\n", - "loQ1k0Q4giAbRMpKJ73MQW5uFI/HjMlUzYsvvoEkmckougR3YDdObyfWIi2rV62itaWWQzVb8A23\n", - "UJAR55a77qKx0YnHM4jJZKet7SCjoxq0WgvXXFOJ0ZhGb28h9fXvMG3afEQxyuBgDz5fJ2vWzMdo\n", - "NJ7wWCcTbrebd9/dTENDBwqFjAULZnL55cvQarUUFBSclEukw+FAn59PU08PJdnZzKyqokmvZ0tL\n", - "C3MXL+bapSqcTjW5uSV0dHyKzzdMJBLFZJLh89URi3WSl2egt3uQes9O0iWQxDg+WQh14Uws1iIA\n", - "BEHCbrdRWVnF0OB8Og61kJtTilyuoN01jE4+D6fTiVKpJhJR4ff7MJlkXHllNb29HQhCJ7feejvl\n", - "5eWoVCocDgdf+9o1vP76xyiVo2g09ajVBjIy5tHZuR+dLsDdd9+AXC5HLpczZ84cDjufX3B0dXXR\n", - "3NxJf7+GzEwbeXkmurvbUamMJDRmajoPsHxWETabjXA0Sm13N3PXrGHeggXs3duI09lIfslc9g90\n", - "0tNWw3SHhV6/nxGlko0PPEBubi4LFiygpaWF7u4+jMZC/umfbuKdt9/mzedfRhaL4w+1kdCpycxz\n", - "EFRpUdlzSC+uxNPeRWvrQex2GxqNl8zMDAyGDEZGnOTnz8VqNeD3H2D27DK83mZmz16A3+9l795t\n", - "bN/+CYlEGhkZR4z8DAYzQ0N62traxlXINhgMXHLJorHHiUSCzZv3Ul29gq1bDxKLGcnPn0l7+wE8\n", - "njC5ucX093ewZ89+Zs6cxh/+8BSrVy8nPz+fDz/czNtv12KzlaDRONizp48DB57iwQe/OiGCRDhW\n", - "sNdkQBAEaaL6dt11SSHy4IMTsvtJgc+XDGRtaQG7/fzsUxCEYwYfng4ej4fnntvEjh116PUZh6tg\n", - "9hEOa/F6teh0efj9oygU/axdO4P77rtj3F3D5wmFQjQ1NTE4OEIo5Gfz5nas1nJisRgmkwmFQsFf\n", - "//ob1qy5Dqs1kzde+gMdB5vQyPUEJD9Fs+aQEEXioRFmzMzgB//8faxWKw0NDXznO79AEGYyMBBC\n", - "qTShUiUwGuU4nbsoKJiJUj5MqLWWDLkasyGB3qwjbJJx27cfYsuWA4RCBnbs2IFMVkB2toWFC6tR\n", - "KpP3GC0tW5k7NxOvN4LRqGfBgqpjLk1NNMcbd4/Hw//8z5OIYg7p6fkkEnH6+g5RWCjnnntu/9K6\n", - "OsfC7/fz7htv0FFbi0yS0NpsXHHttZSUlBAKhXjyyU10dAQIBATeffc9vN5hFIp0EokogcAAarWD\n", - "qG8UWSKIGHejFdzY06zoCkvJKrgerdbC0FAnc+cWYDJp8Hh2I4p5GAw5yGQCTz/9CkplOT5fJx7P\n", - "QWy2KlQqI6HQIe6++2bkchm5uUE2brz5qL4n42GCyOVy+vr66OvrR6/XMX369CmXjvsZp3K+b9++\n", - "gxdf/JRdu5rQ6+cQj0cxm6G0tJCmpjpyc0MsWjCTvuZmFPE4CYWC6ssuY+myZchkMrxeL9u27eLA\n", - "gUMIAqTbddiMadiyspg5a9YJBbrf72fT00/z3p/+Qom9ArPBwkjAS2csTMXyGxgYaGTp0kLy8/N5\n", - "442PsVgWIJerGBhwUVPTRCKhxettprLSgkYTR5Jy2bx5Ox6PgVAIwmEZKtUgl146jSuv3IBMJqez\n", - "s46bb549VlfnWASDQX7609+Tn7+M/v5+amoa8fsjDA+34vU2UFKSi1abw4IFV2GxZDIyMkAg0MzG\n", - "jWt54onXyc1dMhZzBdDX10pVlY7rr193coN4ihwe82MGJ6VmRr5ASwt8+mkygPNiJi0N1q5NVvL9\n", - "+7+f6N6cOiaTifvu+zvuvDOCx+OhpqaW11+v49AhF3Z7FYIgoNfbGBqSc/DgKAcO1B7TadDlcvHH\n", - "P27C59OiVKYRiYzQ19dEPC6SlVVGOOxlZKSL+fNzDteFULN4+bXEhByUykzMZonLLkta0judDaxa\n", - "VYjD4SAej/POO9vJyCjA6Qyi1dpQq42EQj4ikSB2u5zR0UZ8zoMsTM/BaFBQVDQTuULJvuad/PqR\n", - "X7NizdWYTBoGB41kZpaTk+NAJjtynqtUKhYtmv+lnhtTgd279xEOW8jPT85+yGQqHI5ZtLfvpLOz\n", - "k6KiopNuy2AwcP0ttxBct45YLIbRaBxb0tFqtdx771dpb2/n3Xc/wO+vRBTT6e4Oo9Eo2LbtTWJR\n", - "C3kGHQaFnJzs5fQON5KhakMS/Didb6FU5mA2K6it7UClCnH11Qvp6FCSmZlxOL5ETiDQhcfTQSSi\n", - "xeuVkKQ2JKkDUQSfr4P16y8/Zt+T39fktH5RUdEpHfdUx+fz8frrW3E4FqNS5bBnTw1KZS4ulw+N\n", - "ppE5c8x8/esPYLPZiMViBAIB9Hr9uNgIo9HI6tUrWb362MZfJ0IURTydnaxfspjaul4EwYrVYELy\n", - "SzQd+ITiGdlce+06VCoVH3+8G0ief/n5eaSn23G5XHR1ubn99iuprq7m7ru/gdsdwGyejiQNIJMp\n", - "sNkWs3PnZqLRIDZbFmq1h+zs49eU1Wq1GI1qAgEvWVlZLFwIH3/8PiZTHhqNnpGRAEajBb3ehCAI\n", - "WK1ZxGJRXn/9PQTBOE6IANhsuTQ07OP660/rYzojTv624jQQBOEXgiBsFgThv76w/R5BENoEQXjy\n", - "XO7/dPjVr5LpvFM46/Gscddd8Oc/T3Qvzgy1Wk1GRgYDA8PEYiKCYBkXUyCTaREEPY2N7cd8/wsv\n", - "vIko5lNQMJucnGKKiuZRXHwpOTkCmZlesrL83H77En70ox9gtwfp6NhDNBpGLh8gEmmjqmoGoijS\n", - "39+BTudh7tzZQHL9OxxWMm/eEqCLYLCXeDwI+HG7D3DNNTeTmakn36anoryU6dMrUSpU1DrbaHGp\n", - "aaxP0Noqo7Y26VESi42OEyLBoA+1OjKWJTRV6ejow2RKP2q7IBhxu92n1aZOp8NkMh0VWyKXyw/P\n", - "HKmpqFjK6GgQuz2ZwqvX5yFFh5FLIIoy/EEvaoUGe34+c6ZlcfWaGZSUJBAEGVlZ06moWMnBg8N0\n", - "dOwjFosiCDJsNhMjI41IUjrp6eUkEiLRqBJRTKOp6X0WLy740qJwFzNdXV1IkhmlUk1+fimXXbac\n", - "nBwRmy2EwTDCTTddRWdnJ7W1tWOlAM52kObg4CAGQaCouJDsbC2DQ+2MjLpIhH0M9dRw661rx2z0\n", - "58+vwOU6cj3RaDSkp1spLbWzaNGiwzOwambMWEBhYQaVlXPIyNDjcjXi9epwOkO0tXkZHAxTU1N7\n", - "3H4JgsDq1ZfictXi842wZ892FIppKJVplJdXYLXOxufT09S0f+w9FksGAwMjiGL0qPYikRBpaRMz\n", - "03bOZkYEQagG9JIkLRcE4deCIMyXJGn34adfBj4GHj5X+z8d3G548kmoPf74XzRceSV87WvJ9OYZ\n", - "Mya6N2eG3W4mkWjlszTXz5CkKDKZCr3+yAnocrkIh8MolUq6uz04HOOLwuXkTKOnp49vf/uGcRe9\n", - "Bx+8i5aWFlyuQa655l76+tzU1NTi84nMnFnMqlVfGSs6JZPJkCQRuz2H1auv5rXXXkaSQqSlGcjM\n", - "nEZamgWLRYF31I5WY0BAwO0bprbZjTxmR1RH6K9vRmY0Ysk0o9H00dERR6u1E42GkMkGuf32NRNW\n", - "Z+RskZFhpqfHi9E4fg1bFIPnrICXQqFAFJPBsqIoIpcrMRgsxMIRYolRZJKAIJiIxbyM9jjR+bWM\n", - "BsOMxAu5+pobxz7zRKKI4eGnaWn5GKOxEIMhhEKhwGrVotWqsNs1iKIKgyGNqqpCNmy4Zkqk155v\n", - "kqXsE2OPLZZMVCotbnc3o+6dvPH441gEgQTwvlLJ2ttvZ/r06We1D3q9npAoIpfLWbSwmqHhYUaG\n", - "RwnFo+TlVo5b/ly8eCFNTR10dOw55vmYSCTQaJQEg8qxwpVWq5eRkSjxeACzWcXy5YvIzMxg8+bt\n", - "VFfPJj39aEH+GVVVlchkMv72tzfo6+sgM9NCVdW0w7FjNZhMDjo6dlNZuQhBEAgEvBQXOwgGw4dT\n", - "hZOZR6KYwO0+xC23HB28fz44l8s0i4B3Dv/9HnAJsBtAkqQhQRDOTynAU+CRR5IBm1M02eCsI5cn\n", - "A1mfeAJ++tOJ7s2ZMW/ebD76aC+dnf1EIrmo1QYCAQ9KZRidLsG8eZWMjIzw6nPP4enqQiWTMRiJ\n", - "0OOW4XB8sTXhsH22iCRJeL1eVCoVWq2WGTNmjBNuGzYkX5O8oB4hKysLi0XO6Kib/PwyrrlmAzU1\n", - "NYyMhEhPN+D31/LNb97JL//fo3QM91Fky6GlowMhriNCmLJp0yi02Rn0enD1CSxcOIPq6pm0tzsx\n", - "GjOZOfNqrFYrU5358+ewY8dzBAI29Prkuv7gYA8WS/ycuUMuWDCTZ57ZRmFhNvX1LkymLOAgBpMB\n", - "laDFQJBBzxBRfys5UpA2omRb8zAmVDTV11N5eI1fLleQnz+HK67IRxQFdLocAoEQSmUWgqADolgs\n", - "VioqijAah1NC5EsoKChAqXybUMiPQqGioeYjvN3NjPa3ICRGKb/0UsqrqpDLZPiCQd54+mnyvv/9\n", - "s5pJlJmZibWoiJbubqZlZ2O32zGaTOxxOln+BUOm5JLf7TQ3Nx/zfJTL5SxfPp/HHvuYtLQcFAo1\n", - "Pp8fjSYNna6bdevWk5ZmOdyahe7u7uOKEUi6qFqtFsJhLYWFi8ficaxWDSMjQ4AIJDN3Rkaaue66\n", - "1VitVv7ylxfp7OxGJtMgih6WLZvBnDmzz9rndiqcSzFiBtoO/+0BZp7DfZ0xQ0Pw+9/Dvn0T3ZPJ\n", - "xZ13wpo18JOfJMXJVCUjI4N7772eRx99ip073yGR0KPTqamoSGfDhmU4HA7+9OtfYxoZYebh7IxQ\n", - "JMLeve/Rkt5ASckRheF2Oykry6enp4dXXvmAwcEAkKCqqoi1a1eN83X4sgBLmUzGrbeu409/eoHO\n", - "zj4EQUVBgZnZs+Pceuv1TJ8+HbVaTfibUX73yz/S2V5L10A7wzE7JUUzmJ6fD4DNaKSrqxm5fCYV\n", - "FRXjIu8vBLKzs7njjtW88MJ7DA/LEMU4OTlp3HLLTeds1qeyspLm5g527+5AoXDjdLah0/mBUaJR\n", - "Ob3uPvTBXqosAkU2G+lZWbzrbCMjv4iBri4qKiuRy+VEIhECAS+Dg0O0troYGUkcrvcxk/z8PHQ6\n", - "HRaLhc7O/Vx5ZeU5OZYLAa1Wy623ruGvf32T5vo21H1d5Bs0ZJvklJqK6G1r44BWy9yyMtJ0Ooxu\n", - "N21tbcyaNevEjR8mGAwSCCSLRn7Z92r9V77Cq88/z6ctLWhkMkIyGfOuvprKqqPrtyiVymOej6FQ\n", - "iLfeep/WVhcy2Sg7dvweq7UUr3cUSQqzfv11nxMiACfvC5KZmYnZLBAIeDAYzAiCwMKFc/ngg7dQ\n", - "KAL09OxGoYhwww1LKCtL2gI89NC9OJ1OQqFQUnBN4A3MOcumEQThG4BbkqRNgiDcAORKkvSrzz1f\n", - "APxEkqSNX/J+6Yc//OHY4xUrVrBixYpz0leAf/1XcLmSgiTFeObNg5/9DFatOrf7OZvZNF9GIpGg\n", - "q6uLvr4+jEYjDocDo9FIV1cXr//udyz8QppoXXs7rzb0U1F1JVqtiWBwGJ3Ox7XXXsazz76HyVSB\n", - "0WhDFBP09bWQnR3l61+/85giJB6P09PTQyKRIDc3F7VaTTAY5OUXX2TXhx9iUavRmUyUVlez6ppr\n", - "xrIk3G4327Zt55k/PEbcp6AgYwEqpTp5PGKCPR3b+H+/+Tdmz56YO5oz5WTGPR6P43a7USgU2O32\n", - "cz6LIEkSTqeT9vZOhoeHUKnU2GwWGurqaN+8mXhnJ+V2OxqVCl8oxIHeXg5JmejtVVy6eg3NjY30\n", - "tDQxPFqDXGNl3qJrmV5WQXNzDZ9+uoWCglIqK2fh9/dTXKxj48abUavV5/SYJhuner739fXxyL/+\n", - "K3PNFux2G80HD2IMh1EoFNSEQtx49dXIZTLqOjupuukm5s6de8I2Y7EY7731Fo07d6IC4kolC1eu\n", - "ZPGSJV/6HRscHCQUCmG3208pkykcDvOrXz1KV5dAWVk1crmC5uaDNDd/zPz5RQwP65gx4zJksuRd\n", - "XyDgxevdz/e///WTnuVpaWnhySdfR5LS0WqNBAKDmM0hbrxxDWq1GpvNNqHfs4nKptkG3A9sAlYC\n", - "j3+xXydq4OGHHz77vToGw8NJk7Pdu0/82ouRe+5JirRzLUbOB3K5/JjZCIFAAM0xLj7F2dks0emo\n", - "XpaPyzVCXl4pVVWVvPfexyiV+WOxDDKZnNzcMjo7d9LV1TXOORGgs7OTp59+Fb9fgSDIUCiC3HDD\n", - "lSgUcty1tVxfVYVOoyEhijTW1PBaOMzNd9wBQHp6OuvXX8toXy+++gZqWutIiBZARjjST9WcbKqO\n", - "cXd2IaFQKM5raXtBEHA4HDi+sEY33N+PpbSUtkCAYZ+Pzn4vCUnFSFjElWjDlmZg84evERvsI9sq\n", - "YlNZ0Kgr6D7YiCHNQmnpHGy2TGpq3iAvr4S5cy+hvLx80rpiTiYUCgWFOTmUHZ4V9Obm0ldbS67V\n", - "ihSLEYvHkeRyRoD8w685Ee+88QYDO3awJD8fhVxOOBplzyuvoFKrmfclpcvtp+F1UFOznyeffIkd\n", - "OzoxGmfR07ONhQurKC+vwm63kZ8fYeFCM1u2bAMsQByVysvtt19zSstNJSUlPPTQHdTU1DI05KGw\n", - "cCazZs2cEuZ350yMSJK0TxCEsCAIm4F9kiTtFgThl5IkPSQIwjrgB8A0QRA2SZJ0dGL9eeQnP4Gb\n", - "b4aLKFvulLjzTvg//we6ujhG/MSFQXp6Oh5JOsqZdWB0lOmVlaxYsRxIpvg1NTXx1ksvE4vaiMdj\n", - "ZGcfqY8iCHo8Hs+4tv1+P3/+88vo9RU4HMkp2HA4wLPPvke6IUy5zYbusMeJXCajIj+fTxsaGBwc\n", - "HHfhW7luHc/39bG0UkskEmE0GCRuyOO2b3wjFW9wnsgpKGDPrl3klZTw6t/ewazJQqvS4A9JmLJm\n", - "kVtgwij2c8nsQnLsdv73pQ8IBZwEA6Ps2DzC1dfditWazfTps1m5cumUdcOdCMxmMwmVilAkgpRI\n", - "EAwG6Rgaormnh1hmJkMeD50+H5VXXHFSgsHv93No1y6WOhzID89kalQqZmVns/PDD6meN++snFe9\n", - "vb1s2vQhGs00TCYlFksh4XCAbdtquPLKpaSlWenrq2XjxpuZP38O3d3dKBQKpk2bdloiwmazsXLl\n", - "ijPu9/nmnPqMSJL07S88fujw/68Br53LfZ8sbW3JAM2DBye6J5OXtLSkIPn1r5PLNRcidrudknnz\n", - "2LtrF2VZWejUanqHhugRRW5bmvQJkSSJ1196CefOnRQnIvS7u3AP9+HOKWb2wjXIZHIkyY/JZBrX\n", - "dlPTIaJRI1lZR9aCNRo9SmUOB+veYPHSReNeLwgCBrkcr9c77qKam5vLHf/wD+zduZOB7m4KsrOZ\n", - "u2DBlC96N5WYUVHBrvR0GnfsJqtwJvEodI24iOQVcvU1G+noqCUtcpDSvDxaursJ9rWTIXjJUOvp\n", - "cNax56NNVC1djygGp5wT7kSjVCpZfNVVfPCXvxBqbiZTLiffamVXby+RcJgurZbVN99MaWnpSbXn\n", - "8/nQymRjQuQz0nQ6Al1dxOPxszJjtXfvAVSqXHQ6I6JYDyTP/2BQg8vlQquVUVCQDFBNT08/YbDq\n", - "hcpFb3r2z/8M3/oWpK7nx+eb34TFi5OxNV9Sd2vKc/WGDezIzGTfJ58QcrspKC/nlpUrycjIAJJ+\n", - "B527drG4qAivzcZHw7tI19jp6G2jv78DUYyRn68fsyeXJIm6ujqefvplDhxw4/OFKS6egVab/ADV\n", - "aj1KnZFBj4eszwWOiaKIN5EYKyn+eWw2G6uunhql3i9E1Go1t957L//RPUCruxOdOY2s2dewdPo8\n", - "1Goter2ZUW+MSDTKvpoarizIpsXpg4QWhy0LdSTIrk9f4Pa7rz1hanI8Hmffvhp27qwjFoszd24Z\n", - "CxfOn7KOq2eDhYsW8dHbbzPa1oYfMFut3LRkCUa9nkOJBCUlJSc9m2E2mwkLAvFEAsXnovNHfD5M\n", - "dvtZWzobHfWj0egxmexkZRkZGGjBbC5CEBSMjLhJJAIsW3bDGe3D6/WyY8du6upa0Ok0XHLJHGbN\n", - "mnVKDsUTzUUtRrZsSf577LGJ7snkZ9q0pO/IL3+ZFHAXInK5nCVLl7Lk8EzIF2lvaSFdpSIQCBCL\n", - "xZg7dzqNjW0oQqM0173JdV+5jrVrryQajdLS0sJbb71PU5MPs7kUUVTR2hqgu/sdli+/Cq3WgM/n\n", - "YtXalTTv3IFSocBmNBKORmno6aF04cJjipEU54doNIokSccM9ktLS+P6W27gFc1BHI5KEok4LpeT\n", - "/n4no6MdLF00h8319cgjEfLT00nE49Q6u7HZCtAgYtXpWLv2qmPs9QiSJLFp00scODCM3V6MTCbn\n", - "3XfbqKtr5u/+7qsXXbDrZ0SjUeTRKBvXrz9KdCScToaGhk5qZiESiaBQKKi69FL2vf8+s3Jz0arV\n", - "eAIBDrrdrNp4zLyKY5JIJOjt7UWSJLKzs48SMaWlDhob67FYMpk/fzkHD+6ms3Mno6P9GI0V3H33\n", - "jUfFJn0Rj8dDS0sL0WiMggLHWFViSM7w/O53T+H1GrHby/B6wzz99KcsXdrLunXHd3CdTFy0YiQa\n", - "hfvvh//+75Tb6snyox/B0qXwjW+A2TzRvTn/iMC+/QdRRGR4vX6GhtwYDHrkehXzFlZw003rcbvd\n", - "PP748wwMxNi5sw6DoQy/f4TMTCPDwxI+n55Dhw5gtVpJT4+zevVVOCtmsPmttzjY1YVMpWL2lVdy\n", - "6WWXTfThXpSMjo7y5psfUF/fjiTBjBkFrFlz+VGFwyorZ7F1aw3NzXtoaKinudlFICCg1UYYGnKz\n", - "ZFEpPQcPYhweRmO1cuOll2K2WIiLIgeCQRSK4196u7q6qK0doLBw0diPrl4/i87OGurqDjJvXvU5\n", - "+wwmMzKZDJlcTkIUx81mACQk6YSfq9vt5s03P6C5uQeAyspipl1+OXt37SIRDqO1WFj51a9SMfPk\n", - "nCi6urp45pnX8HgEBEFAo4ly001XjXPSraycxaef7sPpbCQzs5CystkYDCqKisr5+tfvPsqD6IvU\n", - "1taxadN7JBIWBEGBKO5kyZLpXHPNagRBYNeuPfh8RvLzk/vUag2kpVnYtm0rixbNmzLLPhetGPnP\n", - "/0ze7d9wZrNjFxXTpyc/r3/7t6Rt/sVGW3s3TYMxSrVGRkf96PWzCAR9jEohpPYw27fvYO/eBhKJ\n", - "PIzGMEZjEKu1mNHRfvLyNGRn62hq8tHRsYtrr72TpUsXodVqmT59OqWlpYTDYVQq1QkvTinODeFw\n", - "mMceewa/30pu7jJAoK2ti8cee45vfvOuccGESWOrW3n44f+ksbEftbqUiopcbDY7Xm8ne2oauGTp\n", - "Usq1WnIzMsYExYGODqpWnrg+itPZjVxuPeruPy0ti8bG9otWjCgUCsrmzaNl927KP1fqoMvlwlZQ\n", - "cNzZRJ/Px6OPPksikUte3nIkSaS+vh2Lxc393/sekiSh0WhOepnH7/fzpz+9hE5XTkFBUqwGgz6e\n", - "euotHnrINiYCdDod9913O598so2amr0olQrWratk8eKFJzzXvV4vmza9i90+H40m+f0TxQRbtuyk\n", - "tLSIsrIyGhraMZvHz6wk04PN9PX1pcTIZGbfvuRyw+7dkEpCODV++lOYNQtuvTU5S3Kx4PP56OgY\n", - "oWzJBja//BgZMjuBiJdBRCR1HuXlK3j11Y8ANYWFVbhcTiBZ+8FoTKe7u5V1664kPd2EzVbImjVX\n", - "jmtfEISLOhZgMtDY2MjwsJKCgiPOrpmZhXR1+airO3hUIUWZTEYwKFFauhCbrXBsu9lcQG9vC7qM\n", - "PJwhD+6uLrSCwKgoYikt5ZJLLz1hX7RaDaIYOWp7NBomLW3yp2meSy5buZJNvb3s6uwkTRAIShIJ\n", - "q5WbT3BnuX//AUIhE/n5yR9uQZCTk1NCR8ce2tra84f/OgAAIABJREFUTtkwsLGx6XBg+pFZM50u\n", - "jZGRLGpqalm16oqx7Wlpaaxde9UJl+e+SFtbG4mEZUyIQFJoGI0F7N17kLKyMvR6HT5f+Bjvjk6p\n", - "5byLToz4fEnL91/+8sJNUz2XWK1JT5bbb4ddu+BwbOcFTzAYRBBUZOdOw1CwkKg8BwmJdH0GwWA/\n", - "CoWKSARksjgANls2Gs1OgsFhtFoLoigRj0cZGWll3bpjV2YFGB4eZseOPbS395Kebmbx4uqT9kxI\n", - "cWb09blRq49ef9RqLfT0uI7ankgkiMdFBGG8Y2fSR0ZNIgEPfuc7tLS0EPD7ycjMpKCg4KTuvHNy\n", - "cujpeYpDh1ykpZkpKsrDajUTDnczd+7FPZ2r1+vZeN99dHR0MDQ4iNFkYtq0aScMOO3udqHXH+0w\n", - "qlKZGRhwc6rmxR6PD4XiaGGo0RgYHvYetb25uZkdO/bj9wcpKytg/vzqkwpihqNnT+RyBZFIEIBL\n", - "LpnD44+/g8lkH7MY8HgG0eujU6q680UlRhIJuPtuWL48eWef4vTYsCE5q7R+Pbz11sURP2KxWFAq\n", - "k0JDrVai1+ehUKgJhfyYTDoggcGgRqWS4/ePYjCYWbx4Odu3b6a7O4zFoqSrawtGIzz//Nts2vQO\n", - "8+aVs2LFpWMXpIGBAX73u2dJJDIwmfJobPSyb98L3HbbSiorT97aOsXpYbOZiUZ7xh4nEgna2trZ\n", - "s+dTDh2SCIXCrFx56VgqtdFopKgok5aWPuBIQGEgMIhSGWfmzKSl/8yTjD/4DJ/Px1NPvYRWm83A\n", - "QDeDg0M0Nu6jtFTDN75xe0qckgw2nzZt2inVJ0pPt9DQ0Atkjdsei/mxWstOuQ95ednEYk1HbR8Z\n", - "6WVgIMGPf/xfJBIi1dXlyOUyPvnkEEZjERqNhQ8+cLJ7dz333//V46Z4JwNbPyWRiI8JDYDR0W5W\n", - "rUqask2fPp1Vq/r48MNtgAmIYTBEufPO66ZUocyLRoxIEnz3u8kaNH/960T3Zurzox+B1wuXXw4v\n", - "vQRfcFG/4FCpVKxevZgXX9xBbm42HR1NaDR5RCLDzJpVTnd3HVdeOReHI5cnnngdrzcbnc7EjBll\n", - "RCLtXHvt5ezceQCv10JWVjGCIGPXrjZaW5/hgQc2otFoeOedzchkDrKykj82BoOZUMjKK698SHl5\n", - "Wcql8xwzc2YF7767naGhPmy2bGpqajl0yIlWq2DOnHW0tnpobn6Gv//7r475v9x5543s2/cTOjq2\n", - "YbUWEY8HCIVaWbAgh0WL5p1WP7Zv34XHY2Tu3IXMmhVleLiPWCxKONxJefnZrUZ7MVFdPZtPPtmP\n", - "x2Mbq5brdndjNIbHarWcCiUlJRQU7KCzs5bs7FIEQUZvbyttbTsRhMXk51chk8nZurWe3bs/ZN26\n", - "+9DpktkSBoMZp7OR7dt3cdVVXx5DlJGRwYoVlXzwwU4MBgdyuQKPp4eSEv3YDYogCKxcuYJ58+bQ\n", - "29uLSqU6XFxwal0vzlltmjNFEATpbPVNFOGhh2DrVnj/fUhlTJ4dJAl+/vNkMPDPf56s8HsmMTjn\n", - "ozbNmVJXV8cHH2xn5859eDwhCgtLsFp1XHppFVdccRlyuRyXy8WePftxu0coLMxhzpwqnE4nTz31\n", - "KYWF43+gOjv3c+ONc5k9u4of/vAX5OVddpQ3gNO5kwcf3DAune9CYjKNe39/Py+88BbNzX3s3HmQ\n", - "vLxpVFcvxmJJrkf29bUyd66B9evXjr3H5XLx178+y7ZtdahUCq64YgnXXrv6tGzDAX7xi98jk5WN\n", - "+dF8htN5gNtvX8yMz5eFnsJMxLh3dXXxwgvvMDgYBCTy8y3ccMPVpx3kGQqF2LJlGzt31pFIJMjI\n", - "MNLc7KOsbNnYa/r7O3jnnc0sW7acoqLCse3hcIBYrIHvfvf+4+5DkiTa2trYt+8g4XCUWbNKmDlz\n", - "5pQTGzBxtWkmBQMDyaWZUAg+/BC+YI6Z4gwQBPje92DFCnjgAfjd75JZNidRn2rKMmvWrLFqoOFw\n", - "GJ/PR1paGprDdu6QvJu5+urxhXyczj40mvHpoQA6nY2Ojh7mzp2DSqUgHo+iUmnGvUaSYlNqunUq\n", - "k5WVxTe+cTdbt25FJktj+vTF42I8zOZMWlvHT81nZGTw7W//A9/+9hdbOz00Gg2BQOQoMSJJsSn5\n", - "AzSZcDgcfOtb9zI8PIxMJjtjLx+tVsuqVVeMBau+//5H9PePjy+SyxUolSoGB0fHlRyJRiPodCcO\n", - "MBUE4ZSXpKYiF6wYCQSSxd1++lO47z54+GFIncfnhvnzYccOePxxWLsWrrgCfvxjKC6e6J6dWzQa\n", - "zTgRAklzoj179tHZ2U96upkFC+aSmZmJxWIkFus9qo1IxI/Vmo8gCFxySRUffniIwsIjRe9cri7y\n", - "803HvctOJBI0NDRw4MAhZDKBuXMrKC0tnVLui5ON7OxsNBr5UcGmoZCf7OwjdzQ+n4+tW7ezefMO\n", - "AoEwc+bMYOXK5WcU17F4cRXPPLMVg8EyNoZe7xB6fXTM3TfF6SMIwlG+MWcLs9lIPN4xbpvVmoVM\n", - "5gGOZLyIosjgYCu33DK+FMTo6Ch79tTQ1dVPZqaV+fPnjDlAf0YoFOLAgVqamjowmQxUV1deEHFE\n", - "F9QyzeAgfPxxMqjyb3+Dyy5LFsE7xfixFGeA3w+PPJLMVrrttqR9/Mla7U+m6frTwe128/vfP0M4\n", - "bMVotBMMeojH+9i48Wqys7N55JE/otdXYDQmI/r9/lE8njq+9a2NWK1WIpEIzzzzIk1NgwiCEQhh\n", - "twvcdddNWK1HZwFAUog888wL1NYOYTLlIUkiXq+TxYsL2LDhmilRQG8yjnsikeB//ueP+Hx2MjKS\n", - "aXfRaJju7t3ce+9aSktLGRoa4le/epxPPmlEknKRy/VEIm5mzNBy//3XU119elOEoijy6qtvsmNH\n", - "C4JgBqLo9RE2btxwQfzofMZkHPczJRAI8Mgjj6HRlI3FpQQCXjo6PsZg0CIINiRJiSR5WLiwmPXr\n", - "144Jzv7+fh599DnicTsGg+3w9aOXu+5aR0lJCZD0NvnDH57G7VZgNGYRiQQJh7u5/vpLWbDg9GKU\n", - "zifHW6aZ0mJkcBA2b04KkI8+go6OpPfFypXJbJlUQcyJw+2Gf/93ePLJZF2b73znxEtkU/3i9Je/\n", - "bKK9XUFm5pGc8UDAQzTawPe+9wDd3d08++zr+HwCkgR6fYKbb14zdqGB5Ppwd3c3Q0ND6PV6ioqK\n", - "jusq2djYyJ///CGFhQvGhIcoinR17eCBB9af0GZ6MjBZx314eJhnn32F7m4fMpkauTzA1VcvZdGi\n", - "hQA899xLvPzyHjweC2ZzIZAULMFgB3PnaviXf/nGUTNnp8LAwAB9fX2o1WqKi4unlGfEyTBZx/1M\n", - "cTqdPPvsa4yOSgiCDK02zo03rqKwsJD29nbC4TDZ2dlHFbh8/PGn6e3VkZ5+xMzN7x8lkTjEd797\n", - "PzKZjHff/YDNm3vJzz8SNxSNhnG7d/GDH3z9tKr8nk8mLGZEEIRfAPOAvZ+v4CsIQg7wF0AN7Acq\n", - "JUladuxWjtDff0R8fPwxOJ1J8XHZZcl4hXnzUksxk4X0dPiv/4Jvfxt++EMoLISbbkrG7yxeDBea\n", - "yWg8HqexsZO8vPE27nq9iaEhGBwcpKCggO9+9376+/uRJImsrKyjhIYgCOTn55/0HXB9fQsGQ864\n", - "GRCZTIZSmU5zc9uUECOTFavVygMP3IXL5SISiZCRkTEmLiRJora2Bb8/isGQPfYelUpDIKDB50uW\n", - "ji8+g7XKzMzMVEXmKUh+fj7f+c799PX1IYoi2dnZY+f5523iP08kEqG1tZf8/PHXj2TWTWKs5s7+\n", - "/YdITx9viKJSaUgkDHR3dzN9+tTNtjpnYkQQhGpAL0nSckEQfi0IwnxJknYffvr/A/4FaATqgeYv\n", - "a+f99+G555LiY2AAli1Lio+vfQ3mzIETlCJIMcEUFsKf/5wUkn/8YzLQtb8fVq9OBr4uW5a0mZ8C\n", - "qwnHRSaTIZfLEMXEUbEagiCO2T7L5XJyz+KUXTLo9Wj3RVGMo1anlPmZIgjClwoChUKOTCZDFOMk\n", - "76uSSJKIIHDCOikpLlxkMtkpnedy+WffpcQ4PxFJkpCkxNh3SalUkEjEj3q/JCWmfBmJcxnhtgh4\n", - "5/Df7wGXfO65WZIkbQNuA9o4jigaHIQZM+Dpp5N/v/JK0i9k/vyUEJlKZGUlq/3W1sKePUkR8tFH\n", - "cOONSTO6qY5MJmPhwpn09o7X1W53Nzk5aaed5nkiKitnEIn0jbtAxWIRJMlNWdnUvUua7AiCwMKF\n", - "s0hLU+D1do5tDwa9KJUhsrK0Z1V0priwUSgUVFdPp7e3Zdx2t9tJYaFtLOtn0aIqXK7Wcctbfv8o\n", - "en1sys+CnsufczNJoQHgAT4fRioXBEEJXHb4NV961fzKV85Z/1JMEA5HsmLy/cdPr59yXHHFcnp6\n", - "NtHRsROZzIgoBrFY4tx8883nbJ8FBQWsXFnJBx9sQxDsh+/Kh7n22iVTpkDWVGXFikvp6HDy5ps7\n", - "6ejoRZJ0qFQBFi928NWvbpjyd6opzi+rVq2gv38TnZ27EIQ0RDGAzSZy/fVHrh/z5s2ltbWT+vod\n", - "CIIZSYqi0fjYuHH9lE/7PmcBrIIgfANwS5K0SRCEG4BcSZJ+dfi5D4EngSHgHsAuSdLSL7z/wots\n", - "SpEiRYoUKS5iJiKAdRtwP7AJWAk8/rnnDgArgGygGhAEQfh7SZL+9/MNTKVI60AgwM9+9nuyshah\n", - "VB5ZP3Y6G1i+PGdcBccUx+ZCja5PcXwm47i7XC7++7+fJi9v8bg1/I6OfVx//RwWLJg/gb27MJiM\n", - "4z4ZEUWRRx75HYJQSlraEZO2wcEesrIC3HPPbRPYu1PjeFYD5yxmRJKkfUBYEITNQFySpN2CIPzy\n", - "8NP/CeQCeuArQN0XhchUo7u7G0kyjhMiAOnpDvbvPzRBvUqRIsXp4HQ6Acs4IQJgseRTW/ul8fYp\n", - "Upx1hoeH8XgS44QIgM2WQ1tbH5FIZIJ6dnY5pyGgn0/nPfz4ocP/95CcLfmM985lP84HCoUCSTo6\n", - "yjkej6WyGlKkmGIksxeOjqyOxaJoNClr/hTnj89+WyRJGjezkMzcEy4Yp+UL4ygmAQ6HA70+hs83\n", - "MrZNkiTc7lYWLao6zjtTpEgx2SguLkap9BIK+ce2iWICn6+LefNmTWDPUlxsmM1miorScbu7xm3v\n", - "7W1h7tzSKR+4+hlT2oF1stHZ2ckTT7xMOKwH1EjSCLNn53LjjetTngMnQWoN+eJkso57fX0Dzz77\n", - "NvG4GUFQIIrDLF1axtq1V00Jm/3JzmQd98nI8PAwf/rTJoaGBARBjyh6cTi0bNx4M3q9fqK7d9Jc\n", - "sHbwk5FQKERLSwvhcJisrCzy8vJSF66TJHVxujiZzOPu8/lobW0lFkv6OKQcUc8ek3ncJyOxWIzW\n", - "1la8Xi82m43CwsIplz6eEiMppgSpi9PFSWrcL05S437xcTwxkooZSZEiRYoUKVJMKCkxkiJFihQp\n", - "UqSYUFJiJEWKFClSpEgxoaTESIoUKVKkSJFiQknlm05xmpqa2Pvpp3hHRsgvLWXR0qXYbLZxr5Ek\n", - "CY/Hg1KpnFJpYClSXIh4vV4AjEYjkiTR0NDAvk8/xe/1UlhezsIlS8aqtKa4uBgZGWHXtm20NzSg\n", - "VKspr65m0aJFUy5r5nSYsGwaQRBmAr8naXN4UJKkB7/w/EWdTROJROjv70epVJKdnX3M9OCtW7aw\n", - "57XXmGaxYNBq6R8ZoV8m47YHHhir2NrW1sZ7L79MeGiIBOCoqOCqa68lLS3tPB/RibnQo+t/9Sv4\n", - "+c+huBgeewyKiia6R5ODC33cP8PlcvHOyy8z2NkJkoTV4cBot9O9axfTLBZ0Gg39IyO4lUpuf/BB\n", - "rFbrMduJxWL09/cjCALZ2dlT9ofqQhr3kZERPB4PFosFk8l02m389be/xejz4e3ro9fppDcYxDJr\n", - "Fvf94z8yY8aMs9zr88+kTO0VBEEhHfZPFwThj8CvDtez+ez5i1aM7N27j9de20wspkGSEtjtSm67\n", - "bf04j4NAIMDv/+//ZXFmJqrPOfC19/Xhz8pi5dq1SJLEC48+SoXJhM1oRBRF2vr7CaSnc9cDD0y6\n", - "i9iFdHH6Io8+mhQizzwD776bfFxTAzrdRPds4rmQx/0zAoEAf/rlL8kTRXLtdgRBoKWnh5c//pgH\n", - "NmwYN2PZ0ttLWnU1a9evB8DtdhMMBklPT8fpdPK3v71LKKRAkiSMRolbb12Hw+GYqEM7bS6EcY9E\n", - "Irz88hscONCJTGZAFP3Mm1fCunWrT9kZ9c1XX8Wzaxe9jY1Ig4PkZ2SATManbjfZlZXc9q1vUVBQ\n", - "cI6O5PxwPDEyYcs00vhCLlpgdKL6crYZHh6mt7cXlUpFYWEhKtXJ17Lo6uri+ec3k509D7Vae7i9\n", - "fv7857/xj/9439gX3OVyYZCkcULE6/VyqLaJre/voMUp0dW6h4VmJbb8fABkMhklOTns6uyks7OT\n", - "4uLis3jUKb6M3l74p3+CLVugvBzmzEkKkR//GH7604nuXYrzQUN9PfpAgLzPiQaVQoE9Hsc1MEDR\n", - "587FPLudmvp6fJdfzqZNr9DaOoRMpiEUcjMwMEBV1TricR+JRJxwWMGf/vQS3/nOPRgMhok4tClB\n", - "MBiks7MTURQpKCg4a5/V22+/z/79HhyOSxEEAVEU2bVrPwbDJ6dcqb1+zx5G99bS39BEji6NhsEW\n", - "cnIzyFCpMEoSOzdvpmDjxrPS78nIhMaMCIKwHvh3YLckSe0T2ZezgSRJvP32+2zZUgeYgRg63Tvc\n", - "eed15OXlnVQbO3bsQ6t1jAkRAKs1i87OXlpbWykvLwdApVIR/dxdRTweZ+vWvYSietIzM3E4FtB9\n", - "qJm2Q62UFxaMW4PWAx6P52wccoqT4N/+Df7u75JC5DN+9rOkKPne9+ALIT4pLkCGXC6M6vEVvZUK\n", - "BXKFAv/hGJLPCEUiaA0Gnn32Fbq7FRQULAWgru4gDQ1NdHc/j1abDyiQpBEsFhkHD9azaNHC83U4\n", - "U4q6uoNs2vQu8XgagiBDJnuHa69dzoIF886o3VAoxK5dTeTlLRlbRpfJZOTmzmTr1h2sWLHspGdH\n", - "EokE+2sPkeYBs86KXmckISbocroI2w1MN5kY7Os7o/5OdiY0m0aSpFckSaoEfIIgrPri8w8//PDY\n", - "v48++uj8d/AUqa+v56OPkl9Oh6MSh6MalWo6TzzxErFY7KTaGB72otMdK55DQzAYHHuUk5ODJjOT\n", - "brcbSE7lhkIyhuIxskvmAGBOzyMqqulod45ryU+y+FKKc09vL7zwAvzgB+O35+fD9dfDb387Mf1K\n", - "cX5Jz8rCEw6P25ZpseBTKvn81oQocsjloqC8nPb2YXJySsaeCwSCeL0xRkZMWK0zsVrLsFgW0NXl\n", - "p76+4TwdydRieHiYZ599F5utmoKCOTgcVWRkLOTFFz+h7wx/3EOhEKBELh9/T69UqojHBSKRyEm3\n", - "1dHRgdpShF+hIiiKAMhlcoKigoFgGLlcTsZJ3tBOVSZsZkQQBJUkSdHDD73AUWsZDz/88Hnt0/Ho\n", - "7+9nx4699PYOkpeXzqJF88jIyBj3mu3b92OxFCOTHYnFMBptdHWpaW9vZ/r06SfcT0lJPh991ENa\n", - "2pGZjOS6qmcsKBWSa2/X3X47f3viCXo7Oxnp76fO68Ux+zIcBclAp7yiWew+tIdut5u5JC90zb29\n", - "aPPzp/za41Thf/8X7rgDjpUc8cADcMstySWcC6QKeIovYUZFBdvfe49OlwvH4fO4Z3CQkkWLiOp0\n", - "7OrsRClJtLpcRA1WhrfX0NcXJDc3PlZkUy6PkkikIYpH7rZlMjkKhRWX64JZ5T6rNDQ0AnY0miMx\n", - "OSqVBpUqmwMH6snOzj7tto1GI1othMOBce37/aOYzeovzVx0Op1s376XwUEPxcW5LFxYnYwJyigh\n", - "pM2kfvPzDA/2oNHoCCrV5FmNdIXD3Lhs2Wn3dSowkcs0awRB+A4gAO3AmxPYl+PS1tbG44+/glKZ\n", - "h8GQy969w+ze/TT33HPduB/1QCCMSqU5RgtKotHoMbYfIRgM0traikwmEY930Nen+v/Ze8/wuq7z\n", - "zve3y+kFpwAHvbGAJECCRSwiKUoUJTuW5SLJkh07rrFiO5Fv6s08mdzJ8/hOJhlnnDvjJGNnYtmO\n", - "bEm2ZcmyVSJajaTE3kGCKEQ/AHEAnIPT+673A2hIlKhKyizi74vEfdZZe529sNd611rv+38JhZpQ\n", - "VYXp6QHa26tfd9QTDAb58h//MRMTEwwNDRF9+ijt7VvnP/d6A1S3r6PMCLvHxzEEgUUrV3LLbbch\n", - "Xpv93nNKJfje92D//vN/ft114PXCjh1w662/3bZd4+JSKpUYHh6mUCicN0Gmw+HgU/fey/NPP83u\n", - "wUEAahYt4su3304gECAcDvPEE8+Qzweoq+1AVUucPv0rFOUQmzfPhXYGAj4EQUUUdXRdBwzS6RjB\n", - "oPMNdlOvUSyWkSTb665bLHby+eIF1S3LMh/60GZ+/vPdVFYuxe32k8nESST6+dznzp/Z+cCBA3z/\n", - "+79EliupqWlmejrGoUMPcued2xCELEuXb6K2sY2Tx3eQmAkjqgpGY4jbv/hFGs/6/l2tXEoH1ieB\n", - "Jy/V/d8upmnyxBMvUFHRjtc7d7jvdvtIJt08/fQO7rvvS/NlOzoWsGvXGVwu7/w1XdcwzRR1dXVv\n", - "eI+RkREefPApymUPgmChVJLR9VNMT4dxOOx88IOdbN68kXA4zN69R4hGk7S01LJp0zqqq6tpaWmh\n", - "ubmZyclZTp8+QW1tG7JsIRaboKZG5o/+6L8iSRIWiwWb7fUv5jXeG558cs4vZNGi838uCPClL8GD\n", - "D14zRq5kJicneeCBxykUnAiCDcM4yPLlNdxzz8fnfQYURWFgYIh4zoBgA6tWLWPz5o3zzu2SJBGN\n", - "mrS3b52fxNauvZ5Dh05QVxdgwYI2JEmksrLAkiWNJBIjiKJIW1sdNpuDzs7Fl+z3X860tjbx4ot9\n", - "wLnO+rncNG1tmy+o7mQyydRUFMjQ1fUkXq+Tzs7l3Hnn7Sxe/Pr+6O3t5a//+p+Q5aVYLBAOH6e1\n", - "tZbq6npOnjxNZ2cDXV3Hqa1dwg033c3U1Ci6HuZP//T3qaysvKC2XglcEz17C9LpNPF4iaamc70M\n", - "/f4Q4+OnyeVy857Z69dfx/HjfUxM9BEI1KMoJZLJEbZuXf6GmgHlcpmHH34aj2c5tbVzfhyGsZSx\n", - "sSPcddcmVq5cCcCJEyf52c924vG04nK10d0do6vrZ3zlK3dTX1+PIAh8+tN3sWfPPvbvP0a5rLJi\n", - "xSK2bfvddx33fo0L48c/hs9//s3L3HMPfOMbc7so9vNtql3jskbXdR5++Ams1jaqquYmDNM06e4+\n", - "TkvLUTZtuh5N03jooUcZHCxSVTUnLvPcc4OMjU3y+c9/CkmSGBsbx2KpOmc1vWzZWhSlyOTkfqzW\n", - "KRYvbqCt7aP09aXp6FiJxWIlHp8kENBYu3bNJfn9lzutra20t1fS23uMYLAFQRCIx8dZuNDFkiVL\n", - "3nW98Xicf/3Xh9G0amprt+Dz5Ugmh1m+fNF5DZFiscgPf/gLZLmDUKgdANNsZWTkJMFgFX19k/zN\n", - "3/wxdXWH2bv3OLOzJdrbF7Bt2xffF4YIXDNG3pK5lY2OYRjnHG0Yho4gGPPnuQAej4evfvWzHDp0\n", - "lJ6eESor7XzkI1tpb29/w/rHxsYol51UV7/iUCqKIsHgAg4d6mblypWoqspTT+2ipmYVDsec4eNw\n", - "uInH7Wzfvot77/09YC7CZtu2rWzbtvXiPYBrvCtmZmDvXnjkkTcvV1cHnZ3w7LPw8Y//dtp2jYvH\n", - "mTNnSKcFmptfmTAEQaC6ejEHDpxg06brGRoaYmgoR2vr2vkybvdqBgYOMzQ0xJIlS7DbbRjGuU7u\n", - "oihSW9vMbbct42Mfuw2YM3R6eno4ePAkhUKJW25ZyLp1111TVn4DRFHkd3/3Trq6TnD0aC+6bvDR\n", - "j3awZs2qd6wD8mpefnk/ul5LXd3cjovD4cbjCfDccwdYvXrl6/pjdHQUTatAll9xahUEEaezkZGR\n", - "QZYu9WKxWNiyZTNbtlzYjs2VyjVj5C1wuVy0tzcxMDByjmd7JDLIypWLsL9mOevxeLjllq3ccsvW\n", - "t1W/pmmY5uvFx2TZQqk052cSj8cpl2VCoXNj4wOBGsbG+lFV9YJerGtcfH7ykznj4u3MEZ/61JzR\n", - "cs0YufLQNA1RfP0wKssWstk542JwcAyHo+p1ZRyOKoaGxliyZAltbYsRhH3nOENqmkqpNMmqVXfM\n", - "f0cQBJYvX87y5cvfo1909WGxWFi3bi3r1q1968Jvk7nF5rrX3MeKabqZnp5m4cKF53ymaRoulxe/\n", - "P0sul8TtnvNoF0WZeDzCxo1bzutj8n7imhfj2+CjH/0gVVV5wuHDhMM9hMOHqKtTue22Wy647jmn\n", - "1BSadu6qKB6fYOXKuegbm82GaaqvUyvUNAWLRb7slFSvMWeMfPazb6/s3XfDM8/AqyK3r3GFUFdX\n", - "hyjmUZRzw3aj0fF5Pw6324Gqvj7MU9PKuFxzekJ+v59PfvJWEonjhMMnCYe7iUQOcNtt112R6qpX\n", - "Oy6XA0V5vQOsaarn9cv7zTi/alU7FkuaRGKcRCJCJHKEtWsb2LJl02+h1Zc313ZG3gYej4c//MMv\n", - "MjY2Rjqdxufz0dzcfFEiUioqKvjgB9eyffshPJ5mrFY7yWSEmhp9/hzY7/ezcGEV4+Oj1NbObQua\n", - "psnkZD8339x5LTLmMmN8HEZHYevWt1c+FIJ16+YMkrvvfk+bdo2LjMPh4CMf2cLjj+/B6WzCbneS\n", - "Ts9QUZHnhhs+DMDy5e288MJxyuXGeTHDUqmAacbo6HhFXmnFiuUsWNDKyMgIhmHQ1NR0LWHeZcrm\n", - "zat4/PFjtLSsmR9/Z2cjVFZaqK+vf135QCCwZzwXAAAgAElEQVTAtm2reP75k3R2tpLNFojHw2zc\n", - "uIC/+Is/vBZYwCXMTfNWvN9y0wwPD3PkyEny+RLLli1g1apOHI5XVFjT6TQPPfQLIpESguDENLMs\n", - "W1bDJz/58XckN385czXkqgD49rfh5En44Q/f/nd+8IM5Y+QXv3jv2nW5cjX0ezgc5vDhE6RSOZYu\n", - "bWbVqpXnSI53dZ3gl7/cia7PZeqV5Sx33bWNlSs7L2GrLy1Xcr/rus5TT23n0KEhRNEHlPH7TT7/\n", - "+U+cowf1WoaGhjh6tJt8vkRHx0JWrux83VH/1cxlmSjvrXi/GSNvB8MwmJiYIJvNEgwGL0iw53Lk\n", - "Sh6cXs2NN84prt5++9v/TjIJLS1zuyrvt+Cnq6Xf34p8Ps/4+DgAzc3NON/nWRKvhn6PxebyBTkc\n", - "DlpaWq4dmb8F14yR9zkzMzPzifuampro7+uj5/BhNE1jyapVrF2//pxdmEvF1TA4TU/DsmVz/32n\n", - "O68f/zjcdRd84QvvTdsuV66Gfn8zstkso6Oj80cvkiRxeP9+Rvr6cLrdrNq4kY6OjvedA+PV3u8X\n", - "C9M02bVrF/t37EArl1m7ZQubb7zxipRsuGaMXEbMzMxwaM8eJkdH8QWDrN2yhUWvUcUyTfOiDEyG\n", - "YfDsf/wHgwcO4AMU0+TAwABtVVWsPpsldDKZxKiv5/fuvfeSn1teDYPTv/0bvPTSnAPrO+VnP4MH\n", - "HoBf//qiN+uy5lL0e6FQ4PDBg5zu6kK2WFixfj2r16w5J1T/YtB98iQvPvYYFbqOCERKJRLZLGtq\n", - "aqgLBimWywzF47TfeivbPjDnP1Iul5Hl98Yx/WKNLReDq+F9f68xDIP//o1vMPz887Ta7UiiSFTX\n", - "CW3cyH1/9Vd4vXMCm4Iwlwvn2NGj9B45gmmaLLvuOtauW3fJx/VX82bGyKXMTbMB+J+AARw2TfPP\n", - "L1Vb3g3JZJK9u3YxdOoUNrudzo0bWb9hw5uG2E5OTvLY975HgyTR4fORmZnhmR/8gM133cV169YR\n", - "i8XY/cILjPT2IlutrNq4ketvuAHDMLBare94oOzp6WF07142trQgiiKR2Vl8iQSz09Mcj0QwVBW7\n", - "2005FqPn1CnWXHdhWSyvMefz8ZWvvLvvfvSjc/lqYjF4k2Pna1wgpVKJn3z/+1ijUZZUVaEpCscf\n", - "f5zxkRHu+tSn3vFknUwm2ffSSwx2d2O1WuncuJENGzeSy+V48dFHua6qCudZv4DMiRNEe3sJtrbi\n", - "djhwOxz4PR727txJRSBAz5EjzE5MIMgyHevXc+O2bRfsU6CqKvv27OHEvn0opRLNS5Zw4wc+QHV1\n", - "9QXVezVQLpc5sG8f3QcPoqkqS1evZtONN85P8hf7XsA7Mg727NlD969/zQpZJnc2KWrA7Sb80kt8\n", - "x2rFLggYhsHizk5i09OIkQitVVUIwMAzzzDS18fvfvGLV4T0w6WMphkDbjZNUxEE4SFBEJabpnnq\n", - "ErbndRSLRYaHhykWi9TW1s4rnabTab793/4bybFpPA4njSEvJ594gqnxcT7x6U+/4WD28rPPssBm\n", - "o+6sop7TbqfC5WLv9u00NDXxyP3302Ca3FRfj6Jp7H/sMR74wcPUL+jEZhPZvHklN910w9s2SroP\n", - "HWJBIDDv7R1NJiGXQ52dxWaz4auoQNB1+gYG2LtjxzVj5ALJZufy0Dz++Lv7vssFH/4wPPoo/NEf\n", - "Xdy2XeMVuk+eRJyepqOlZf7aGpeLgydPMr5x49tOIqnrOiMjI/zixz+mWRDYUF2Nquuc/vWviYTD\n", - "NC9eTNA05w0RgGg0SqvHQ2RigmAwiGkYjI2OcXzPIR579hBtVX7WLK7F5bBz6Je/ZGRoiKWdqxga\n", - "OkMg4GXdupXvOEfJE48+SvrUKa6rq8MaDDI5NsbP/s//4bNf/zrBYPCtK7gCiUQiHD7cRSyWpLW1\n", - "nrVrV7/uWMMwDB57+GGUoSFW1tQgSRLhQ4f4yenTfP4P//Bd+/RMTk4SiUSw2+0sWrSIQqHAM8+8\n", - "yOnTZxAEWLasmdtu2/a2IqV2bt+OmEhgdblodTrRDIOpVIrB2VkAvvh7v4coiuzbtYu+3l6+dNdd\n", - "8wENnS4XR0dHGRwcfFPhzcuFS5mbZuZV/1QB7VK15XxMTEzwox/9kmLRdTbfxAE6O+u4++6Pc/+/\n", - "fZ9jByZoqlpCrihzsG+WkL9ASTzB5I03zie003UdQRAQRRFd1zkzPMzNr9EMcNhsWFSVXTt2UKUo\n", - "NJ/9bjadJjmWwNAseFa24Xb7eOqpY4yNjfOZz9wz7+ORyWQQBAGP5/WJssqlEpazhoum65QUhclY\n", - "DE/JoHc8hSwXMfU8slNgsLf3vXyc7wt27IANG8Dtfuuyb8RnPgN///fXjJH3kvDAADWvmZgEQcAv\n", - "SQz09xMIBM77Pr2a0dFRHn10Oz3dYVKjI8zUuqhwuaj2+1nV0sKB/n5Mi4V0Nks8kyHg8SAIAjab\n", - "DT2XQ1PndIUGBoc4dWqSWAp8rkbOzBQ43N/Povom3A6BYy8+xPU3FejoWMPUVI7Dh3/BPffcxOrV\n", - "q9B1/S0XJlNTU0z19LCxuXl+kdQYClGenOTIgQP8zjvxsr5C6Ovr46GHnsVma8TprGLXrkkOHDjF\n", - "V77yqXMiXUZHR8kMDbH+VUZpW0MD3ePjdJ84wYaNG9/0PrquI4ri/HPVdZ1f/vJpjh8fp1x2Ui5n\n", - "cTqfAjTc7g4aGuay7g4NhfnBD37G17/+pXN2vRRFIZ/P43a753cyZmZmEHUdn93ORDLNeKpESgMh\n", - "V0JJpDENA0mWETWNSlUlMjlJS2vrfJ0hp5Pw0NA1Y+TtIAhCJ1Blmmb/pW7Lb9A0jYcffgK7fRmh\n", - "0FxOGdM06eo6ht+/g5d3nmBBzUrcjjmlRLejgqnEMDZrlGg0isvl4vnnX6K7exhRFFi9egm33HIj\n", - "NoeDkqLgeNU2nWmaKKZJfHKSJb5XJOH7+oZwOmuoLOUZHR1kcHCWRCLPyy+H6e8fZ9Om5WRnpklM\n", - "TIAgUNXaygc/9rFzXrbFK1Yw8Otfc3piihND05yJxeiNxGkTK6lERjY0RMFCX3Qat9BFX18fy5Yt\n", - "+y095auPZ56Z29m4EH7nd+aOeXp6oKPj4rTrGufi9Hgols8VIUun0xw5ehRhcpKe3bvP+z79hmQy\n", - "yY9+9CQeTwcWQaW1xodhKDy5t4ffu3UtTrud1HSU/eGXiY7EcBwZRVTiLG2qweX10pNI8OHrrkNT\n", - "VU6eHGBoJMlALIFdKJNUXNitTQwpORprJURzOePjedav9+H1BikWq/judx+muXkX5bJObW2QD3xg\n", - "M21tbef9rbFYDK8gvG63ttrvZ2R4+OI91MsETdP45S9fJBRaPZ86w+sNMj09xgsv7ObTn75rvuxU\n", - "JIL/PMZcyONhYnj4DY2RsbExHnjgEbq6BnG57Nx++xY+8Yk76Onp5eDBSbJZF+PjMQTBSjQ6RbEY\n", - "5qtfvWV+h7qmppVwOENfX/+8Ubl71y66du9G0nVMq5V127axYeNGbA4HY7kcSjJFseQgYA2gaDlE\n", - "Q6aoutm1aw+yZKN/fAJ1ehrLsS4aGhqQzxozJVXFd4WkCrikalmCIASAfwF+/1K247VMTEyQy1nw\n", - "el9JbicIAqHQQl54YQ82Rx2qbpzzHY8jxGAkxcTEBN/61nfo6SlTX7+FmprNHD+e5oEHfs6K66+n\n", - "PxI5x2lrbGaGytZW6pubyeTz89dTqSwOh5sz8Tg7dhxlclLCNFtJp/309mb5/v/3PZS+PrY0N3ND\n", - "YyOuqSke/eEPKRaLZDIZ+vv7qfD72TE0xo+fOcDIeJzJsXFUI0TEEDmTijGWTzJkqjgDy7CLdp59\n", - "5BGKxbeXVvua49m5mCZs3w633XZh9Vgs8OUvzznCXuO9YcWaNZwplSgpc+kWSqUSu3fupFwuc8eq\n", - "VdzQ2Ih7epqfn32fXsuJE93oeiUejx+700VJVXE7KlC1ACNT00wnEuztm6W+fgtWpx8tMosvIxHr\n", - "HeLUkSP0ZrM8e+oU2w8c4OkjxzmaKKDIrcSLBpJZj2jYKJQEhsYjiKIfw7ATj8eJx+McO3aCkyeT\n", - "qGotTU03UyjU8cAD2xkcHDzvb3W5XBTP865mCgUqrsIEbNFolGJRmjdEfkMo1Ehv75yY3G9wezyU\n", - "DOO1VZArlfC+QWLTiYkJ7rvvG+zcmUcQNpNMLuV//++X+OY3v82BAydIJg3C4Sx+/0L8/mYcjkaS\n", - "SQs7djxJPp+Zr8du953N+Asv79zJ6eefZ31lJRvq6mjSNF740Y/4x29+k2hfH7KucyxbYtYQGSnn\n", - "OGNqlG1uDM3K8eMjFIsOFjauIiG7mIorHD16EoBCqcS0rtPReWVo2VxKB1YZeAj4v03TjJ6vzDe+\n", - "8Y35/9+6dStb366k5TvENE3Gx8eJRqO43e6zf7Dnzxej6ybVdTXEhmdxOxxYpLlHODw5wWwmzNHH\n", - "H2dkKIGtJorT6cXvD1Ffv4SxsaPceGMV6dWr2dvVRYUkUTAMbLW13HnnncRiMX62cycWoCYUwuNx\n", - "EZ4KMxAvoOmNlEsK8dgYghCjvyfFMkuWniOnqPJ6qampoTEUYnJggP/nr/6K4e5hBNFFPJ8jP9pP\n", - "R20b2dkJVDVH1tmM23SimTkqPA5S2LBZXFRVefCqKsPDw2+a9yIajfLii3vo6RnB4bCxefNKNm/e\n", - "eEU4SL2X9PaCKMLSpRde1733wpo18M1vwvtciuI9oaGhgdYNG/jJT3+KV9cpqSrpfJ6Pf/CD8/4d\n", - "DVVVJMbH6e/rY/WaVzLiplIpDh8+TjJpEgjU0tDSzPHwGF5NRZYcZPIlukfGmcroJF76D0rRMdoC\n", - "lRiKzmh0gmU1Xhb7/Zh2O8/t24daLNPkczGWPUPaMHAhYpRLSGYRwS4xnUxSMvI8/OPTuCtqSSZz\n", - "mGaZcHiK6uoW4rOThHt6+K9/uYcvfO3LbNi8+ZwjppaWFqSqKsajUZpCIWBukhrNZvnYWxxDXInI\n", - "soxpvv7EX9c1ZFk6Z4eora2Nl+124pkMwbMOq/lSiYiisGX16vPW/9BDPyeTqaW5eRUALlcFHk+Q\n", - "J598jIULvfT12QkEluFwFLFYRFLTB7AluxnZcYxY726aVlzPlls+RTI5TS5XxfDwMHt//Wuso6M8\n", - "9MwzxJJFrBXVpNUifT9+kGWhKqoEgZToIitUI8kSjgo/BSNGsVTG6nAgnZ2D5PpFpG1O9p0eo+y2\n", - "kTAMOjZvJpPJEAwGL3ul7ksW2isIwqeBfwJ6zl76z6ZpHnjV57+V0N5yucxPf/o4AwMJBKECKGK3\n", - "50kkMixadCsWy9yRimEYjI/3sWFDkK6uQTLpAEPdvaiZDNligdn4af70ng1QUJiIqCTLRc6YBjd/\n", - "5Ks4nW4ikRGWLRPo7OxAVefyzPT3D3D69CSnTw+QyZSp8PrJnOkn5BSorA5ysH+K8ViI6IwFi1AF\n", - "TCMQRdbSLLOkWFJroX1hPQW7ncWdnTzx3HMUU2U6l2xmcGiY0XA3Bd1GwCrhFgqE3B72ZSyIYjM2\n", - "JUPI6yaiaYSaqvjIpkrsDgviokUoqRSYJsvWrGH9pk3zjlyJRILvfOchoIGqqgZUVSES6WfFCh+f\n", - "+cycjnk+n0eSpHcVAXAlh/p961tzEvDf/e7Fqe/22+Gee+CLX7w49V3OXEi/a5pGsVjE5XK97cH2\n", - "xeeeo3fnTgKSRCKT4WB/P0t9Pj60bRvCq+oYnZqi2NREbW0tFpuNYlllz55eIpESp09Hqaiw0NGx\n", - "FJvNR/+xo8xMnSBUkWNX1xg6y3E6QviVLKaRB+EMzUaKFZUuJJ+LrmQCeypNNFsCuRK15OOMmWOW\n", - "hciCG6tUwOoyMU0rboeL2mATJc1gJpukusZCZeUCKuyThNQ0DZ4AqdQQK9avIO/389mvfe2crLGJ\n", - "RIInf/5zMhMTWEURxWJhy0c+co6RdSl4L9530zT57ncfIJ0OUln5iix7ONzNli0NfOhDt55T/vDh\n", - "wzxy//1IuRyVlZVYKyu55c47Wb5ixXnrv+uuP0DX1yFJVmKxEaanx8nnC2SzUbzeEvl8iJqaG5Bl\n", - "HVE5iWd2FK2YQLYHqa+pZbY4RS5YjdPjZMOGG0mnpzn5xP1stluJF0ExKgjno3hQCBplAk4n46U8\n", - "42VQhEbyqFgcFloWLmFkfIwKOyzv6MR0V9B23a34fFUcPfprBCGBx7MAp7MKyNHU5ORzn7v7kmd3\n", - "vixDe03T/Cnw00t1/9+wZ89+BgZKtLRcP38tHp9CFA8xMXEIm62eiYkpentPYrUmqK29jZtvXsMP\n", - "v/8Y+WwS0TApFEZZ5stjUxRGkrP0nB6gxuZCLubY9cR3Wb31Ho4ff4lw2MuhQ1GgQD4/ja5XEJ8Y\n", - "YbD3FIh+rH6DO+76Q6LREQR3klsWtfHP/7wdDBHJmsZh9WCUl1Cil5I2hWy1cTpRYHg2xX/0JElO\n", - "T9LR2MJ0JIpa1Fni9NOfmiFTqkQUJIqCgVqOEdUVvBYXlS4PdsNCfZVKW0MNP921i3XlMstbWxEE\n", - "gbFduxg5fZrP/sEfYLVaOXDgCLpeTV3dXLSBzeagpWUVPT376erqoufIEaJjY5iAr6GBQDBINpGg\n", - "sq6ONevXX9WhhNu3w5/92cWr77774K//ek4A7TKRhbis0HWdPS+9RNeePaCqyG43mz/4QVa9wYr2\n", - "N0QiEXpeeokNTU3IZ3U8PA4Hx3fvZiYaRRVFDvePM5PMMjEZpnFBLb/TuYJ4NssvDgzTueEe1qxZ\n", - "QDZ7gHzewvHjp2hsrCKSChPN6pwcLlDMC0iEKRdmKOomAamRvCnjEdOczsDImTGcskiDIFKnqyS0\n", - "CEkzRqVYS9ocRhHasDga0LQ0VsspRLEShEpMI0GpcJpQ6HOIIiSHeti0eh3ZXJpyMYdQKGAUCpw8\n", - "cYKNm15JvBYIBPji175GLBajXC4TCoWumhQSr0UQBD75yY/w7//+GOHwDOAAMixYUMHWrTecU/al\n", - "nTvpev55rquuZspiYSqTYeMNN9DxJjvDqpqnq+s/mJ2dQtMETNONKMroeoL6+qXoepx4vJ9QqIHk\n", - "RBcSWTwUcBamiZ8ZIye5mEpP8cWv/z2apjHU34OezWOIIImVFAyVxRYLiVwKWQCzBK2yg4iWx2JM\n", - "U2N68di8BNQsw0aW4PJttN/yCbzeALquMR7uY+9zj6ApLqyOMF5/LWs3X08kIvP887u4447L12H5\n", - "fS969rd/+0/4/WuxWu3ouk4mk0WSJJLJU9xxxwb+1//6HkeOjOJyBZBFE6us07QgxCKfwJJAANM0\n", - "6RsYYKFpMjg7S05V8WXLOKx+MuUiWk0zR2dnKFgbaWxcQalkUCwW6e3dR0Acpb6YwyFUYbd6GS8l\n", - "idn9dC7fSD4/RFGLMD5UQDAMSmI1Lscq1LxJXh3BL+ylMeAn5F8DRZPj09NYDR3JWiYkagQDNdjT\n", - "Y0SzGaapxmcTiBUTiNZWogrYXVYULUltdYk/+9RH6J+ZQUmn+eSt564cjo2Nsf5Tn2LlypX8y7/8\n", - "EE1rxeU6NwZ/YOAQ1uIprq+vpy4YZDoe58lnn8XncHDLtm2ki0Uius7Hv/QlWl/l6f1artSdkUwG\n", - "6uvnVFcv1sLDNKGzE/7xH+ecWq9m3k2/v/jsswzv2kVHfT12q5VcsciJqSlu/sxnWPEmZ+R7du9m\n", - "/PnnWXI2ag3mji1+9vTTWGWZhBHC62xmNpnj9PgI7Qu93La+iVgqzfb9cRJZg9b2dmqbmjndP0B/\n", - "bxflcpigv5NUWiGf0rHiR9OHsOpuEkzgoIhMjg4pS61FIqsWKQkmrS4XnrxC2ZSIGAYDgoeotIy8\n", - "4EEkg0NKsLa2wGzJR1FyYbNWMJ2MYshBfG43jaUx2hrqGR3qxuuw4LTZKEkqTR/axv/7rW9dVmJX\n", - "5+O9fN8VRWF4eJhcLkdVVRVNTU3n7JxNT0/zyD//MytDIfb1DDI8mcVEZjYf43Nf/wLXXbeGioqK\n", - "c0Kfjxw5xn/6T//A/v3jGEYQWIGuC5hmHEGI4vPlWLx4OUODh3BYQIl2sUG2sMDuxuNyYmDQk0py\n", - "wuZmQdty5OQMUzOjeAs5DEOn0hYgbuqEVIO0XiaAjF0wkCWdQQyWWaxENAHT7qKmOoi9JsBssJWN\n", - "N30Bq9XB0b2/YmLfk6gzCaoqFpESTXLWEEXRzbpbtlBbW+Bv/ubrl/RI/bLcGbkcME0TVVWRZQuT\n", - "kxG6uvrRNAnT1DGMYdrb/YTDJZoaN6FMnsCRzVMuZTh66gC9QSufvOVmGmpqaG5oID44SD6Xo1KW\n", - "WbCwkfFwhGQpj0fzIyWnEGvbgCq8XieRiW6MjIOyXsJPDk2AnFrGYYpYUmOUpmooGzPUakk0vUhZ\n", - "UVGYIVocQCVEwAmLqgLM6jVQglQyCQ4HNQ4n2bxCSRtHyecpqWV0yY5NhCyQM2oRdImg30dNvR9L\n", - "xXIQp8kEg7Q0NmIdG0NT1XlPbICQy8XE8DArV66kstLHyEjmdcZIbHqQtRVQf9Yh7tipU6wLBsmX\n", - "SqiFAgvr6vBlMrzwxBPc+yd/ctkoQF4sXnwRNm68eIYIzO2G/OVfwv/4H1e/MfJOKRQKnNyzh02v\n", - "2t1wOxx0hELsf+EFlq9Y8YZ/Y7+ZAJPZLOMzM+iaRl0oxJqVK3lwzwlcVjcZo0heN1jV1oEoKjyx\n", - "9zh6MYGZDdFi8eLK5ejfsxvNNFnRVE+pbMcUfExNjGKjGsG0YFKJwlFaKaNRppISVsOgqJl4JJlW\n", - "DGKahiiCVZAIaDIWs0hemMQjSdj0DB6LhZZgiOHBPJK0DJurFqdoRSZDMnqSSjFLz8kwTdWLaaqu\n", - "BUz6Jkd47GdPIOs6C9vb2frhD7/pAuBqxWq1vmlk4NDgIEFR5Je7D9M9KmKR/Pg9DmZnU/zJ//VN\n", - "FtQ3YLGbNLUGuP3DH6BzzRqefXYPXm8zdnuSfN6NaZYAA9MEq9UGxTNEex6jXpSwIZIxijgMsNqt\n", - "2GxWTMOgCjDyCezxCOsqKnkmNolpmjgMk+lynqhhYlCBhAddKAASSS2PRVQoGDI2r49gbQO3/M4W\n", - "mlpaeGZgEE07TU/3MOXhwwTLOQRvNV6HD59pMqDEcPqrOX7wGJW3L0LX9cvWv+99a4zE43EmJyfx\n", - "+5309XUxOJjC42nEYrGhqkXi8RF+8pNn0PUqlEg3gayKQ3SStWkEchr2yRj7n3wSR0UFeiBATSBA\n", - "PJej0udDtlpxhfysaF/M4vZ2hh+MkCjLKIpOLhdHLCvYRBBKVnSLjK6LxNRJZMPEgsnxgV2Ish3d\n", - "Z1InlKmwOvE4fIyVswyRo85fQbAySMjVgZ6XkHWdBfX1ZGIx7KpKtlSm3jCISQ5GinFagrXMKgqi\n", - "v5aK+jpMVAILa7nppg8yNTVAqMnFrh37KZzoZsg3TEtzDe3tS5AtFgrlMrVnNRmuv341J08+idcb\n", - "nE+FHoudQTJTtDYsBuZWmflUimAggKEo5HI5AIJeL/3j46TTaXyvCmG+GrgYUTTn49Ofhv/yX+DI\n", - "EVi79uLXf6WSTqexC8K8IfIbfG432fFxNE17wwF30eLFPP797yMePky1JCECe3p7Ces6muRFszvR\n", - "BYNcOcpYdIqQLJNMjiKLJVRZQ7J4kUURl6JQME1SeoqGyjqiKR3RBEMTEUQdTc9TiUoVrcQ5Q4Ug\n", - "Y5MgqecQDA3ZbkHWdUoOF0Grk2Q6hWb1ssTto1ExqLBXkMqN0dt9ipJai84siXSUhgo/ddXtzGYl\n", - "NKWbqoIXWZAolnIMTU0wnM9gdfowpmeobW7mV/ffz6aPz2X2drlcLFiw4KJL3l+JhMfG+Mnz+zg+\n", - "nCHoWUbQ6+bkSJjpmQTVgesQlBzlmR5Od59gaud+ggvrSUoOBPtiAoEaZDmIrnspl3VMU6dCHaBR\n", - "KNBksRCwVxDREmQFAcFQGElME8o40SWJWVXBYqo0WG2MZ+KY5RwVpoFThLKgoBOkLNpxGAIl0Y4k\n", - "KJRMC7NGCY/Dg7uxDavXQX1DA4VymdbFi/jSfV/l37/zHfJiiq7JCVR0VK2MRbbhRyCHRi6TIhi8\n", - "vDMEX9Z/lf39/fT0DGKxyHR2LqPlVeI07xbTNHn22RfZvfsU4KNYVNi581c4nctxOCopFmdR1Uk2\n", - "bdrKSy89Tz43ha9QxC7ImIJJPj/FAsOCXZLAMGj3eBjO5cjabJSqqhhXVbymSeOqVTQ2NXHyxAnG\n", - "41FKzgwxdZR4JkON14OBCqiIsoN0OUGTIZDGhYwfmyYyoUWJzQrYRUAuYDVlqkSRWSNJzmbhhiXr\n", - "6BqMkso4sHi9LKpvIO52c2rgBG5R5XSyjxkgK/lJZ8oYQp7qQI7K8gRSMQHhKV58chxPTQ2xmElz\n", - "8030hzNYHC5GRpOUyt20r1jGjGFw69lt79bWVu6550aefvplVNWGYajU1bm54+6Pkj5+nFpAkiQM\n", - "QUA3DEqGQe3Z7QLDMNDhsrXK3y2mOacv8hd/cfHrtljgz/8c/uEf5lRZrzGH1+ulZJpoun6OQZLJ\n", - "53FWVLzpZGuxWMAw8JkmLkFABPKKwuxUEtXbjM93HYJgMnX6B/hy07S2LEVIwBq/nz2JaUazAkuN\n", - "ShStQElNUN0gkSmkyBXtaFoRq2ggiRZMJvHhIUuGGYo4TTsO3Ypm6qRJU7JYkG020ppOMZcmLQnk\n", - "9CILlTKSrqEbJUplFUG1YpoKqpDA1HVS6TiSK0NNXSXZdIiIojKVmoSMhVhJxu3ZgKrqvNQzxebr\n", - "NPIDA/zg7/6OG1asoARsd7n4wB130Nraelkkx7wUvPTSbvbuH6dvsgKLuJBMoUgis59iOYNdaEMW\n", - "LETCB+mwB/D6O0kVEixwLmRPz17MVjeBQIh0OorX20wmk8HIj1EnGtiMPA7BCloGSyaBgoVpw4ti\n", - "QERTsEkGstVGWVGIzUaxCRqdoozdYkUzNERd54ygkKSSpJhCcjiIqxYykkxWVVkoiWhjfcQrHPzP\n", - "fx3GdHlZ94m7mJqaYmR4mGJvL4VCDvR44pQAACAASURBVJ8kMZMfwemspWyqRGbDZNQzzI5U8+D3\n", - "vsfNH/7wvDDnu8E0TSKRCLOzs7jd7ouWrfiyNkZ+9KOduN116HqB/fufYtu2Dj7wgW0XVGdvby+7\n", - "dp2mpWUTojj3AIeH00xNncJm81NdXUFz8034/SFqavpJJg9SLGTw2wJk1RxeTUMWSviddhK6Tjyb\n", - "xVR1uuPjNK1bT+PyhQQkiUAoRHd/P0dOnKBzZTtdo7PYpBpsgsHkdD9lcwJDKDJSLFBrqhg40HGh\n", - "YgAZgoCu6SiYpA0D05EjFPSwddlKln/iExiiyNHRH6OoZ1CKFmbiTpwOL+1tHhbWbuUXz+6g2bYE\n", - "UQiQKImkc6M4ZnpxBFvw2GQq8grjE8fYdXCS1Rs+RCiUx924hGf3bceplBHDRaJeJ/fce+85wk9r\n", - "1qymo6OdaDSK1WolFAqRSqV4sLubaDJJyO+ntq6Ok4OD+CsrqT4bTjgyPU3jsmWX3Jv7YnPqFFit\n", - "8AaaUxfMvffOKbIODsLixe/NPa40XC4XyzZsoHvvXpY3NmKRZYrlMj0zM2z+5Cff9BhwZHiYVU1N\n", - "1K9YQXR6GsMwSJ6J4J9IkZrtYnD2DJq9Ek9JRdeddI+exCaVGU0o1Msi/gYrtdVpxsOnKSglwtNB\n", - "FE2jrIbQRZmSOoHFakFmFgs+Biiisoq8EMWPlwJ+VHGC8Vyc8VwOpygiSBJWj59K3cBrTKGgIygB\n", - "PHI9skUnUshTxIIplTEIMRt3kDcLVHrtiDYno2ULsrQMSZaxih7KQoqgbxlPvXSANsoEHA6WNDSw\n", - "v+c0+/b18+KeYVatXc6WLSu55Zatl33I58VC0zROnDjB/fc/gte7lIpgPWMjA4hUoputFIonwGoy\n", - "FttHg1lEEQUSagRTmJuAl9S1cXBqGG9NBaI4Qyz2MoIQwEEYl0XFY9FY3FzFyMQZdLkKr1miWzPw\n", - "4aBSqKQsZpiW3BSdfiYK06yw2EhrRSSLBUGQ8UkSvjJYvH6mE3lmNQUDkUK5zCKLjLWUQ9M1vKJB\n", - "Kl0k5vVQ2D7KsWN/S5U5S6XXS3VtNYVohha3m6lShCldBynGx29Yzd0rVzKTSPCL++/n0/fdR+js\n", - "2PxOUBSFJ37+c2b6+vAIAiXTRKis5O4vfIHAG2izvF0ua2OkpWXdq6R2G9i58wCdnR0XFJVx6FA3\n", - "fn/rvCECsGDBYuLxJG1tS6mrWzB/PRiUsNuKjOciSJkMZVGlQk9RYdPJWixMY2UkY2AT7FQEm/D7\n", - "NzCZLDFWHEXpPc3E2ATLmxv52NpVmNJJzsRGMYmTyMexCjUogpuwMYZMAisaCgIGBQRC2JjGQCWE\n", - "A1MroydVhnIZzujDGEt6qJFEvnzzFiLjE+zbe5TBrl+RtDmxiTp79kaRZR9L2hZQV9mEbpocPx7G\n", - "lXajlcbxeRsYj09QLqSo1ksYA8fojp7hjF5Bw4JPoKpFZmb6yAje8+bBsNls51z3+/3c9fu/z3O/\n", - "+hUD4+Oofj+Jxkb8lZUMRCIUAKm6mk9+9KPvut8uV35zRPNeucG43XPS8N/6Fnzve+/NPa5Ebv3Q\n", - "h9gpSRw4cADZMDBsNq6/8863jKYxDINMPk8qk2d0Ypp8YpbkQD8eawVLQ40UYkX6wwfRdJWiYaJI\n", - "JvaqRmZVBYeog2wBBOyeZYQzk/gdHTisdkxGsbk0MNOo+TOAwgQ5NBqQkUkKVajEcJgapukgKohU\n", - "idDsdGKKIqOFHJOKgEeuQtVMBDRspLFgRzcL6EIew2xFEu2YuoaWzWN11XE6sY+C2UbQ2US5NMtU\n", - "KoXbU2BJ8wqOHT/B0sUhZrNZ/vHHP2Fi1kVLfQdW3YbLtZwXXxzAarVw001bfit9dinJ5/M88MAj\n", - "nDoVJRx2Y7XOkkgOYXV40PUWbJKdUnmEkjqDqruxWA1EqiiXixTVceLxKLUNjTgLEZLJIQShhGFE\n", - "0PUydinHkvZWxJKTiako06kSmugki4scC8khMkUEUxWprGjAI9mZjIVZK4kscLmgXEYBSi4XFRQZ\n", - "nemmFj9+zYJipoiTRETAanVRsNgYLsvUVjUhOpwsqGrgyOAwjmqBZYsXUDQMssUiw8kYUdVAdbi4\n", - "cd1KFjc08PNdh6lwWvF5rBzet4/b77jjHT/Hfbt3k+ntZeOrTinGo1GeevRRvvDVr15QH13Wxsir\n", - "VziSJCNJlYyMjF6QMVIoFLFYXlnpZ7NZYrE4ExOjPP10gvXrt7JwYSsTE730H32elWaeoWor01Pj\n", - "VAIFWWNIl5kq+jGFSmTZx4yYx64JZPIqiTMaIyOT1Nd3kCvYiScreObgEKsWVTOd7CeRnUWjllK5\n", - "hNe0kKOZGCJBSoCOieWsLK5ADgsFwEkAm1BCsBpEyhYeeegpbm+r42SyRD5foFTO4TatTEVjhGxB\n", - "/KoLpaAydOg5Bvx1hKoWY5MkKmw+bFYoiils5TgdbgfDmTKJxBSUBSo8DuLRfmRdQdKLZDJ2Dh48\n", - "yq23bn3L59rQ0MCX7ruPdDqNJEk4nU7GxsZIpVJUVFTQ2tr6nqREv9Rs3/7eHNG8mq9/fW7n5Rvf\n", - "gLq69/ZeVwqyLPOB227jxm3bKBQK5+TzeDN0w+DJwyNYShXkMzLZrIC1ZMORzyCpcTyGTJVpY6I8\n", - "Q60YoNFbRb6g4G9qYjo1w+nBKNZRDV/VMtzVJqJUh6JqKGINHr9ENuNEJU/AGserlAihYDDJjCER\n", - "oRkoYTXCLEGk0tDIFjTyBjgFHxWym6QhIqt2RMGgZKbJkyJLAAQwzQJxNU5AgArBRiajooserJYS\n", - "ZWZQ5CyVNpFGf4BCIY+ha+waHWVxMEgiY9LubSQTjxPRdTRNp6FhBbt3H+WGGzZdle/mq9mx42Wm\n", - "p200N19HONxNINDCwMAEgpCistLD7OwUiBqKUkISFzClzGJXEggIIHjoPdnDiZEB8vU+fL520uky\n", - "NpuJJJVQtQFeODZEi92HC4G8IZI1ZBJCEMQGTMFFUW/E5BCFgoTDBjZRJiNJOOx2VFnGabVSKpcZ\n", - "z+VosVVgKllMM0clOpUYRHQYyeWosbloEiA1NcoZmwVf7QpERUNRXYi6TtDlQli0gMV+PzP5PA6H\n", - "A0Vx0D9uw+2oIRIv0j02zKnUk7QsXkxDQ8PrEgjCnNFeLpex2+3z87BpmpzYt4+1rxmEmkIh9obD\n", - "xGKx86ZPeLtc1sbIazFN44IjMTo6FvLCC2O43T6KxSK7dx9B1z0sWtRCdbWP7u6XGB/fRVO1nUY1\n", - "S2swyKr6eqILGtg7MMBMsch02ka9pQpZspNXRLJSiHzBwDYVpVgUkFWB0uwpymWNrtNnWLmsjUd2\n", - "9rC0aTUzgUnUeABF0Mkpkyi6j2lMZCZwUsREJss4ZVw4kRjBxCtqiKZKSdVQNSf5eJGu+FFsliok\n", - "uYJ0vgi6gls0mJLtKIoNxZjFqUehFKEw20tRtNBicdEYsiFkMnRarZTLKnZBpEFR6DPiCJqOv5zC\n", - "Y6/E4YLiSDfPbs+/LWME5ozHVzunLly48IL66nInk5lzLt12YSeHb0llJXz+8/Dtb89F11zjFWw2\n", - "G7IsEw6HKZVK1NTUvOF2sa7r7Np1lLqFN3Fi9zFC7ioKmQI5qZUUgwSTJQTBjaDYyJoy6ApyOkXA\n", - "4+ZMbJKEpwI0D26PhQqryvjkJHUt7dQ2NrNr10HKZRNFMbGj4cOBEwGNIlb81FKmxBls+BBIEURH\n", - "M0FWVQwqUAUPFgQGdA8OcrhMgTIOMtixImAYBZzkcKIScHqR/H6KhkCF1Y6VBKrSjd8qIEoWxlI2\n", - "0iPTOANWAhosr6lhNBFHKSsY+SLlconp6Wmqqqool01KpdJVd3z6akzT5MiRPmprNyGKMpCnp+cI\n", - "IFAuF9D1FLqexeVyUBS9mIZMUqkAZglhx2v1kDIzTGRzWKY9OBwNlEppHA43+fwU+bxMxvCRyRcI\n", - "SHYyCGTwoZo1YEYBKwJ2wIkpVJHMjrJEsjOum1T6fAREkVQuR388TlmQcIoeBCFJi+ihqGfJAnk0\n", - "Wg0DR7GATZSoFi2YmslA70EM7wJGJ8KECnnaq6tp9vmYSaU4rSgUTQtOsZ4q39wCvqwWiZ6JkJlM\n", - "8tg//AMD0STBRW3c+YmPsX79WpxOJ4cOHuTwjh3kUynSpRKNixaxccsW2pYsQVUUrOfxybKIIsrZ\n", - "9ArvlsvaGDEMY/48U1XLQJzFixe943pSqRS7d+9haGgSm81CsRhmbMwklVLIZstYLGmWL19KR8d6\n", - "NE3jxRd/xoHnH6etWCSZyTBjtSJ6vXxh40YeONVDSQjgDjQyFIljCDaCngBZtUQqNY2cmCCo5MgV\n", - "ZASxmmSpxJ7uIRQ1QTrbxVRKQzcdSKaAIFgQ8KIQZIwpKsmjUKZIDV485NERKSAZYBcErIZGLlGk\n", - "rBuoehmHmqTALG5MdBSihgtLsQqraANitJo6IV1AlOyMKRn6S3HSmpVlpsmwpqNbXAQ8NWRzaazF\n", - "FIam4nb6aKzxU1dbQzwT48j+3fzd3/0zVquF665bxsaNG963jm+v5YUXYNOm345k+5//OaxeDf/5\n", - "P8PbyDz+vmFmZoYHH3ycZFJAFO1oWpzGRhfZ+CzDw2dwB0Js2bKerVs3UywWyedFauubGWvWUE2D\n", - "QjFLUKoimZxFKSaIlX6TTFyjRBVjap7BdAq/exHN7lbK6jSz6Qym0YxVaqLv1F4KpSyaZmIRgogY\n", - "gJtJEliRsQAyUZyI+MngxYFKEh0NOzJFVDRUVFMkrVnRWUEeG2mmMZnBQpoq4pQoIqLjwCCejmCW\n", - "nYgWF00OsJomdjWGQ/CR1wyKchZPQyN3/e7XOPnggyTTaeLxKQTDiSZYsTv8HNx7DJtNprraisPh\n", - "wDTN/5+9Nw+y7KrvPD/n7vftL9/L5WVl5VL7IqlKCxLakAQ0IIwYSfbYGsB2Y4+XgY7ocEdHtMPd\n", - "MXbP9MREdxDhCAfRBgLcQLC2EIuwbCS0IYykKlWpqlQqVVVWZVbu29u3u9975o9MZDCysSRQCTPf\n", - "vzJu5n3nRp777v2d7/l+vz86nQ6apv3CFSZhGLK+vo6u6wwNDf3EglVK+fK75MiRo5x78QL9nkoU\n", - "CVyvQav5LOXyTpKkjGmaOI5OElm0ZIWm7GCEVfJpi0p6kvlWxPp6Hd836PeXiWONJJkCcnQp4yTT\n", - "aPgYZBCsEVEkRAdWEdTo9F1SLGFJl4Ew5IULF5CmiQHErgdIOuEaFpKaUHGJ6RPRB7KAToyT9OjJ\n", - "FFmZp9qts9KV+OEcYcPi6KUNSlmVPRPjTG3bxpG5JrvzOlIm1Bo1zpx6hGIYo5lQvVBj/+gups+t\n", - "8rWvHeX06Qsc2DfOhSeeYDKV4uz0NPl+nzMnT7Jx6hRD+/dTHhtjuVpl+4/oTfqeR7ilH3w9eFMX\n", - "I/Pzz6DrQ0gZI2WVu+666cdCaH4apJQ88eijfOovPkWrYWNaJTLlMqXhHOn0It3uOqVSjoMHr2Zk\n", - "ZBIpJSdOnObUsUtMhjoVTWA5McXEpyu6zNRq+K6DZQ6T6MNsG93GUrVHw5F43gYyqTHlh6z6DkX7\n", - "GlQUVClZaDXwsHHDAlFUJ47Vra0YH4mKxhpDKGQYoksRiywxfSwUXPI0mKMse1SDHAECl5CL5MnT\n", - "ZxKHLAZnkHTIkJU1/LjPTnxGsHHpEURtBmTADmLqrsdGIkkJFZOQTrdO3tDRvBgvClAMlcJAloSY\n", - "5y+dJ7S24ftjZLNlHntslunpOX73dz/4L84V81rw87L0vhLGx+F979tsoPfHf/zGjPlmRxzHfOEL\n", - "3yCKxpmYGCFJYk4c+VuO3v9lxvJZhoamqK7M8WA15vz5eX7t194NJKiqhm3bDAxsI5UdYO38c7T6\n", - "XZI4R4pBNAzAw6VLhhEEEX1Hw1A1HLdBEgxTr/Xp9Dv0nC4Rawh2E8s0EhMJROxEMk8GiwSXKkvs\n", - "oItKF4hwEMSoeFgEhPRZo8EuVFJoQkfIARIukmIFg4AcfTr4OOhkpCTjOgh/kWpPsFvPMDW8jWwx\n", - "z2qnQWp0kF1X7sdKpdhzzTVUL86SsXXWQ4/BgSlCVLxUgWeffYSPfeyjzM/P881vfpdGw0PKmAMH\n", - "xrnrrnf9WI+bNyteOHWKJx98ECMICJOEdKXC+++7j/KPNAFUFIWDB6f48pe/xbN/d4GiNoJlCDyl\n", - "haXpJDIijpbR9EmEWCOKmiTJdjS1jJQuqJfIWBInUIljj42NZZIkhRAJUlaAzdZqEgtFGujo+Cwg\n", - "mEDDJkElZhxJhpiXSFCZj3VMJEUZYYY9ImAdFUGeDVRGMLgkO0giykCOzayoGJBE9KVP4nk0hYcr\n", - "HQrmDght3MDjpX6LeW+Rf713H5VRg0DP8sz589RXZ0l3Wuh6hna3xUqgYuoDbC/maQcRy8sJiy/c\n", - "z92HD3H8Bz9gUFHIDQ9T8X3Ot9sM9Hr0Mxnm4xh/ZYWhfJ6O4zDX63H7b/zG634nXM5GeRXgIWA/\n", - "kJZS/kT7xI985B4uXpxF1zX27n3Xq96POvH88zz25a9gBgNcO7UfiWS91cLp5EinLd7+9nHm500q\n", - "lc1QoFqtzvnzi+iJTzGbhygk8PpIN6acEjw6Pc1Cz6flr5L3doCSQlUzeH6CGznEnXliXaBrU3hx\n", - "QOC3sJMYXbok7AO/j43A4yQxZWJ6QAeDDmVS1AlJUcKlTUhIgxyCDAk+q/j0aKJgkecwIV161LnI\n", - "KoIODcZRmKKHAZzEANok9ESKDJKchICYAIGuGCgoiDCgS0wmM8iy0IhFFrfqcP7732fbkIk0Roko\n", - "cOTIixSLeXbtmmB+fp0LFy5w4MCB1zX/nucBvKl97/8Uftil99//+zduzI9+FD7wAfgP/+H/j4iH\n", - "zQ6q9XpCKqUwMzNLt7OOO3OGYXUESwgsYZJpdTi//Cx+fBNXX32Jctmk05Eoiku9vkJt5RKza+dw\n", - "XAdbjhPiA2CToodkjRmKsky767HRCchqKbpRl5XmCjKsIKgAbQQxEguDLDEhKjkkra1vnIXFEA4e\n", - "Y0CIZIbMVtmi0EOljoZPE4ULRNIgoY6gj4qHSkyL7QyQR0dQp0+DZW5MPM4IldjvsrG+jB/00G3B\n", - "5GQF1XVZWlzi1PQsYnGdqw/cRC8OeWllhjXHY3LyGoaHp5Ay4a/+6lvk8wfYvr1EkiScPz9Dq/U1\n", - "/vAPf/tN7bSZn5/na5/8JNtsm3I+z9jgIGfn5/mL//pf+Z2PfpSJiYmXWZJsNsXMzHOIxCYhpNdv\n", - "EycrFK0sjoypV19kcMSkWCzQbDrEuCTxOopIIDJZabhoRkwqHeC6HcLQAWykXANWgSwJ80gsEnaS\n", - "UAOyhHgIxhBEQBGFARRGiVjnHH2KsssQHTwkg+QoYXEaSURIloRhdEYI2dwA0YnRERgkuIRynVgY\n", - "DOi7iGKNtaiPZRbRtTzV1iW+8tjzXHPrlRiWQiGfx+umqYRpUghkolFWDRpLy2SVbUR5F8PIUa02\n", - "iMMQv91+uXNxxjQJGw0qAwMcW17mf/vIRzh94gRzs7Pkd+7k7htvZGJi4nXP5+VkRhrA24Fv/GN/\n", - "sH379ld0c/xzceypp9ASlbS1WcQIBMOFAudXVkjlJsnlcsTxHL1emUymwMmTp5mZuYDpraDagyy5\n", - "85Q0Hen5vLSwyNHAIj30FsRGjfXmSSQVitkS2ZSPaRdwehX6yTIdv05eQhpwEYTEgIuKi0aBDAU8\n", - "NohYI6GHwiABMT4BFh6CAA0bkxwJCi4KGSwctiOI0dAxEWRI41HBwSJFBUGRHhKFEZrMkJBGlzEp\n", - "AkKgQRqkoCkCbFXDTgROAsuJQBm4mnSQwrYUNnpNTq06SLHBwNAuthX3Eschx47NMDiYcOnS4msu\n", - "RprNJg899Cjnzi0iJezdO8Z73/v2H1vJ/CLg523pfSW85S1gWfDUU3DbbW/cuG8GLC8v88yTT7I6\n", - "P09xcJDrbr0Vz/M4efI84CGETW35OUa6G6TUIvXaKqobkzFNRuKY2dMn+MTHz/F//l9/wt/+7Q9Q\n", - "xQoXT53Faa6Slz2EGKCVQB7BNhSyKARY1HBRkrPYehoUwXJdxQktkjCNTFZRyGNRICAFCCBBUqRP\n", - "hE5MiIJPhI6NRxoFl2Vs8kwRE1FHAywkgxhcwmcGQRaTUUJapMjQJkuKIUJCTCRjFJhGUuUStlAR\n", - "hkWsqZxr1JFpC3mpzdnFk0Tj67z1rXfyxLn/wcWXzjI6UqY8NcH1h25j27ZdLCwc4/Tpc+j6GLnc\n", - "JuOsKArbtu1mfv4oc3Nz7Nix45+YlcsH13X5b//vn7N+ts1SyiZOlllrPEUpN0zbV6n2Ps911+3k\n", - "vvvuJpVKcerURa6++kaebTxN0p8jYwrcSGO9H5BNl0iZu+j1GiwuzqKqN6GINIkMSGQI6ARxF9wG\n", - "aQVgGU3bThjWEEJlM9F+YyueYQSdGgKBRCEkjUoEaAg8FFKkSaFRRWUIlSJLzDNGBwMD0CgQoGCT\n", - "Q5CQIKlikGcFSBMRo9EgR48OfqIgkbihj6bswAttlCjBCWPOLy2Smg7RtO9Tn9/AbflEQZWdpqRg\n", - "DWDqOiJJWFhdYv8N7wASpGUQRtGPrXbcMEQ1TUxNQwKlUol3vfe9P/M5vWxlr5TSl1K2fp5jdBoN\n", - "BjJp4iQEwPE9jp4+zYsnT/P4Xz/Iw9/6BnfccRVxPM3Jk3/D2bN/RzYLmeIQrppCLR5kXUsza6aY\n", - "jiQDqTK91hpOVEDKcZABze5phKqzfeJKLMtgLUgoyjZZJAOoDAAWkNAiTRETGwObFFMYWOTxkDSp\n", - "EhGQsE4LjwSJjY5AwyOFg42KRQHwcOiRIIlQiTARmBRISOgBkh7bWSaFB0T4BFLSwsQhj8UI2WSA\n", - "bhyxrOisKimS1Dhj+QM0ww381jST0QZDTpegPYNh+GiajmmmKJUmmJtb5LUuljzP49Of/gqzs4Kx\n", - "sVsZH38b8/M6n/nMV+n3+z+bSX+D8PO29L4ShIDf/V34zGfeuDHfDFhYWOD+v/xL9Lk5rs3nKTeb\n", - "PPLZz/Kdh75Dp9OlUBijWBwmky0DNrXaCpqUDGQyOLHP2eos0epLBC8c539+/OOMDVlMDLQ4NNxl\n", - "30CWayYOU7Cy5ElQ8UkRkuDRwSNHzA2K5KCQtC7O0ez2cL1xkmSChCli2gh8dHwkHWJ8JH1CwCOm\n", - "iU0HnS59miScJsMyGhsIHDRM8phbT4gEG4MJdFJErKNRxMBGZRsKeQRpPMAHDNKskSaWGudihZNe\n", - "jpVkDyvBHh578RILrT7+Wp0zzz/Fze/5IGLsGmr2bq69/T7GxnbT67XIZCJ8X5LJvJIIKU273X4j\n", - "p/lV4fHHn2JxHrYPXUmltB0vUKm1x2j2BhnOTVAqXcn8PDz00CMkSYLj+Bw48BakEoKAti+pOVmC\n", - "uEy9t4Kdy1Mq7ccwIIoaIDZDKSU+MT6go6p5PDePSEok0TlULiBYI0udPCtYJMQ0UABd0QlwEWjE\n", - "xICDwAUiBJvb9BJBDoM8aXKARpc2fSJCfCJUVBIkdTRSZBmhSJcU57C5RIkeNhYBA8EcWdqEyTJq\n", - "4KAHARYmOW2YXqeDre2Cfo2r8nX2DqgIEdDxanSCPrXYZV0xGByeII5r3Hrnu7nUaKCm03QchzCO\n", - "mW632bdnD4u1GpP79//cmiy+eTm4nwFGp6YoZC3CeAM38Hjyuedpr7QoiDRFNURcqvHApz7Nhz50\n", - "NwcPVrjxxpvIygbDMsGrTbNWPcu59QXsxirlUMHvOUTdAiQ2UpQR6l4k+1irznP6xafoORZOUiIk\n", - "pM0CVdGjS4BFF6iTIsEgQSEhpkqahAiLDBNEjGAxjEKPFgEuDj4tYuapYJJC4tBGpYfBMh49ekh8\n", - "fDQSUgRY1AnYQCWgxgBnSTgPnEGwgIVBDp+IEEE/UenLgEAmbHQ6zNZPMKn1uTY/yPbCEPvzw+wz\n", - "VPqrR+j3N2vGMHSBDqXSa1NQnj17jnbbYmRkCkVREEIwPDxOt5vmzJmXfmbz/kbgjdSL/Cg++EF4\n", - "8EHY2uX6pcD3vvMddmcyjA0OYuo6g4UCV4+O8uyjT3L48GEajRdwnDpmdoQWPlG0hq3pNL0eT86d\n", - "I+UaDFOirJbonbnA8QcfZO6FF9E9g4KVJ3IcYq+OQYIFeIQ0CYnoMImDJQVJr8+obzNCB0ELgxgT\n", - "A31L36VxCYUFoEPCKirnMBgAXLK0iHBxyNNkjIAxqkgW6aOj4uKh0SBhGZ82CktoeKQZwEElISFG\n", - "INGI0OiwSWkL1aRu5KjL7ayLCm1tiF6kEoQjKDLP9kRDXDpHc+UiO3cO4vtNLlx4gYWF0zjOS3zg\n", - "A3cxOVmh2228wn+9/6Zt25AkCUePnmFq1yG6rkucxKzUGgzm99Dpx7R8n0wmw+joHl54YQ7P85iY\n", - "GEEIwchkhcXuCvWehR+mcaMEJ8ixutai0eihaRXieBUpe6hqHkX5oe21hYzTqMl+LK7AlDdhMkZZ\n", - "rrKLLsM4FOgzKFw6xARJhog1IhbYfPZvoDCDQpYedRJAByIkMR424BCwhKBOmRoFZjY3lAhQqJKw\n", - "gUcV8BjEQmVsq1wV+JQRbKeGFC36eKCEFI0BgsYCmSShlNtFgMJ1g4PsHhnBNyWngjXWM2nSI2N8\n", - "/4nP4VTP4HW7MDFBb3SUJxsNvrO8jLVtG4mmUbVt7njPe35u8/qmFrD+2Z/92cs/33777dx+++2v\n", - "6vyb3/EOvj4zw8HJFN858jidlkNeS2OkQt66eyeVYplz8ye4/0tfotmLaS2e423bKzQ2OgR6hmZ9\n", - "hrzfQx8ZwGt4tP0cNlNI6dCnQZLkkTKEqE5WmSQhC8Q45FDFLBkuUcAgS0AXDZdpYiwgxEKQRcdl\n", - "mGHyhEjq9IAUFh0iVlAoMUoaiUaVBkPUGd1iS1aIcLAI6aNgUkelg4XO0JY8rkef3BbFa1KhSYoa\n", - "eQJcInpC0MHETu3ANip0G3N4ccCiW2W4XEHIkLFsijBcZXHxKYaGptB1l4MHJxkZGXlN87m6uoFh\n", - "5H7iuG0XWV7eeE2feTnwQ0vv3Ah10gAAIABJREFUHXe88WMPDcHhw/DII/D+97/x47/RiKKIjYUF\n", - "9v+D7VpT1zHDiLGxXZRKI8zOXkRRXPR9u2krdVreKkcWVpCBIJ8ukbVNuv2YpXMb6BdmmPMdMsYg\n", - "bi/EUgcoa2VW42W6qAhMAjqM0yKHSV8GpFUdpMouIvqsEmGjAQYSECR4ZLlEnWUEeRRiJNNkiQkI\n", - "MRhB4yABFgkBCSYJK6xxlhIqwwRbT4B1FBQiQroYOGxHYQUFC4GCD3hIIpooho2hj2Cp2wn1DEES\n", - "kQ99UmqRAJNGv4ctA8K1WfbdeQeZDNxyywh79+6iUqmgqipXX30lx449QKuVpVAYJEliVlYusH27\n", - "/TPRAbwabOpVznPy5FkADh3ax969e38iAyVJEuI4YWJqB0cXl5CtBrHcZBq6rs/U4DjFYhEhBEJo\n", - "eJ7Hu9/9Nj7+8a+wtlYlFuMk5JCoKKKMpqtE0Vnq9TWy2TK6rhHHdZKkipRtQAUUNAZRSQijiESA\n", - "IjV0UigkFI1h+mEfRRbREVvzHJFiBo1lDDRyWPSYRUGw+ZxPWKTNDrokwDLDeGSxEfgImpSJ6JLF\n", - "I0eLDCo5TCJaxHhIHIbZFLU2WCEggyvnCNSrsBim6sxRVl1UGWDkyswuCf6q1WJYl1RMkz1X7mFB\n", - "VWltnKaSFNk9NMFAtcpSEHDHvffym//237IwP4/TbjM4OsrBK674uTop3yzFyCuS3T9ajLwWTExM\n", - "cO/v/z7ff+QRopMvsT3TYc9khanRCWzDpNtrUl9r8uADj5MZmqR25jgHD72VkQO7aDSq9BunGdcE\n", - "DdelEdkImUYRBqZUcQUksoOgh6WmsfUsgV8lS8ggKUK1RC5Zx8OnLwUBLhKbLComGSw8mtTRyRMD\n", - "IQkm4GGRQqNMjy51VogJkZSoUqGPhQr0GUIwS50uMTXS9GmjkCFkHckMBbqUUAm3gql1wEbDRyDI\n", - "MEGHOUyylQP0ejFxAorYhiMbVLsOumhRyWiMprJkD06wZ89hoiikUGi+5r4Gg4MDBMHKTxz3vA7D\n", - "w6/esn258PDDcPPNP9suva8Gv/qr8MADvxzFiKqq6JaFFwTYpvnycUVRyJbzdDo1JicPsm3bZqZN\n", - "t9tkcfcgzbkXyU13KLoe6dAgim36fhM7CDFlhEgCyuEaUiq4gU9dGgQEuASkEBSIGUMjQKcFpFTo\n", - "Bg5gUCFkgzo+GSK6aLRJCMlSYJwebdroxAyhsB2TGQKWMNBJo6ESoQMJMQFFqpTJo+NQxkAQcFFA\n", - "RmqkCVhE4lEgZB7IEuMznHXxgg4rURldOmhqQiBdYreDrheRmPhBFVIauj6IW69Tr68wOprjzjvf\n", - "xeMPP8yTDzyAIQSJZXH9dVdxaX6FxcXzQMyhQ7u48853vKHiVSklX//6tzl+fJlsdjtCCE6depLD\n", - "h8/y679+D4qisL6+zlNPPcvs7DIrK0t0uzZvufVWps+exZk/R6ezTrFS5K233IIQAsfpkskoFAoF\n", - "SqUSV101zhe/2EHTykQMADFCZIjjBNBQlBjf30BVHZIkg5SSTWmjDWhohChEeDJCEpHCAnLErGAz\n", - "wIBoU5NLqOTxcNGosR2TFAYBfbJsoBCwikmEhSRgnC4aMacxCYkZo0kWhS6SNRQCUhToYxPQpYxB\n", - "hlECNqiyFxVD0YgUi0LcY024bJDGUrIkSodSIU2QGEwvzRHGguuveT++p7CytsTx3iV2qCaRZ3Dz\n", - "xE4KmQL1WpNadZobbjzEie99j7f+8R+/oR2fL6ebRgO+AxwCHhZC/ImU8uhPO8/3fZaXlxFCMDY2\n", - "9lPtRBMTE0z83u/RcGOOfv0xDoxtKg6D0Gd2dgY/yTKy/TCTu6/g2dOnOfrcs2SzJdzmIqLTwCYh\n", - "dEJ0mUcnIJQtImyk3FRxCKqosgfuaQqJg0ClQxo9hiIaJ4SkKsZIkgwORTyamGwgiFCoYhLRQMfB\n", - "JkTHJ8Chh4rDBDohKwRIRojIoWMhSROiIlCQVAGBwSoOKueIcRklS4XdGEpAI1mnyAZ5BH0lg60o\n", - "yLhHlwgDk2ZzgyDYgbSHcb1lNBJ6UZ3hgkkvdllREvYrMd/73gNEUY+77347Gxsbr4kdOXBgP48+\n", - "eoRabZlyeRsAjcYahtHkyiuveNWfd7nwzW/CPfdcvvHvuQf+9E8hDDeb6f1LhhCCw7fcwtmHH+bw\n", - "xMTLL8iLKyu89Z13sNHpsLR0jkymhOO0ieNVPvKR32JxYYH/508/yVrzElpkousCVbYpGVnm/A7b\n", - "dYuKTIgDybrw6CcRLYqEDFNDo8UiHhuMCJNAscmHXSJaLGFiYxET4SCxaZEG2qTw6BKi4hIyicIk\n", - "FllMhvHoAB0uEW8tLjTKpGhSJMSgikmChopKipJ0qVHHwkenSYpRBCY+M2iKQ8kqI3KHGBjZx9za\n", - "Mkv1dUxjB5FqE6GiKxqK6BF0A6zKODPNRfyXHuOuu97Np//7f2eo3+eWsTEURcHxPJ7/wQ94z4c/\n", - "zOjoKLquXxaH29zcHMePLzE5ecPLDpiBgRFOnTrCddfNkkql+OQn70dVxxgYOMS2bYM8+eRf0+02\n", - "OHDgBqx0wvHjP+Da696OlDG12grd7gwf/OC/QlVVpJScPHmW4eER+v0ucbyHOI4IwxZxLIE14rhG\n", - "kuSx7d3EsQMsAwkggVUcYjSKSAqoRMRIoIdBhSj2MBOooLNElR46FgYWRVyWkHToEJEiIoNPmx4F\n", - "YIyEBKgD40jEloIoDRQJOY/LKDo1FExagEMDnywhhqaQiATd0LD1As1um4gmffl91EhidIdI1Awb\n", - "rRe5YtdBRkvbEUJhdGiIsxsjNJ1lJrI5BrKbrplctkSzFbO2soZayNFsNl8xO6Rer/PMU08xd/Ys\n", - "VibDNTffzOGrr37dxetlK0aklBHwzldzztmzZ7n//u8SBBZCgGl6/MZv3Mnuf0YHsXe/+w4ef+gJ\n", - "FpvrbMsP0m7X6biSmgY3XvVWmo0Wq50Oo25As/sCRhyTN9KsBgERKnkp8VWdZjKLK0sICijUEZyn\n", - "mCRsI00RHY+ARaq0ZZdFfAJlByhlokRHYCPxcDc3SDDZiccG4KChEWNjUCYgR50cPgsMkaVLnSwh\n", - "KWI0ElRAQ6IhidlMK1EYYJP7iJG0CYnwkx5FIchIFQ2XiSRBS0BoWSKR5ywJq22HJFlCEdtYEk2s\n", - "YA41yrC4ruEoKpkxm2PHjmOauykU9vPVr07z2GN/wn/5L3/ElVde+armPJ1O8zu/82t885sPs7Aw\n", - "CwhGR/Pcc8//+guRaQAQBJt6kY997PJdw9gYTEzA0aObDM2/dNx0yy10Gg1+8Pzz5ITASRIKU1Pc\n", - "d999JEnC88+fZH5+jcHBItdddwdDQ0Ps3LmTp595kW9+3aDVrjFq2USupBV0qZPwFruMTR837rDg\n", - "ezSYRGWEGIvN9pT7WcYmlEtcFUNKKAgk4HOBNh6TmGjEKPRZYAIXiywZDFpUcbGo46MjsbHosoFD\n", - "HpgkJiFhBpsaZXyGUeiTkAF8+iioqFtkv0oLF4cCHtemMihxyHKrS095CU332Ta6m9BwqNdbCF2n\n", - "7ldJh3W22QbDxSEcsU5LSTFh7uFbXz3ByuIZrpg0OV8+TxAEjAwPMzoywnNPPcWHfu/3Ltscnz8/\n", - "g2UN/1hgmRAC2x7h7NmLNJttDGOSwcFNVnb79h3cdddv8uKLf006vczb3z7Fb/3WW7lwYZ6FhdOM\n", - "jQ1w663/C1NTU7RaLb74xa9z7NgCvl8iis7hu49gKHsRUcimNbeOpo2gaddhWR5SQhwfII4vsikZ\n", - "3gMIIiJUVtDIolAjxiGmgEwCElwc6kRkUFBwyeJykQnApkxETI0ma/hkyLJGjw4h9hZLFiBJAxFg\n", - "AiYaGh5NYnagoGHSR2MAnyVgIQqpGDZxnLAe+5xNBgiUXSSygkwaNJx5hkwYICasz/PiwgVy2TKR\n", - "rrPzyqs5fryBG3o0O3VymQKqopJO51lbW8fMZ19xS6bRaPDFv/xLRuKYq0slvCDgyP33s7G6ynve\n", - "977XdQ+8WbZpfipqtRpf+tLDlMtXY9sZAPr9Dl/4wt/wR3/02z9VbLVnzx7+9f/xIb782Qd4Yfp5\n", - "6hurdMIUt7z71wlDwUvPPkc2NYGnLJHva2RVhYaqUtdzCC2hG4d04zVCxjAMCINFFBYZYZ0p0oTo\n", - "hKjowCgeSwQ0GSASo7hREYmDRgOTFBpj2Myj0UPFpEOdhACNXVgEGOQIGaCOgkuMwiBpzmASUtq6\n", - "YWMk60ADHbEVmRZiopECctSYpkyPKT3PbORhSp+SKvAjBSdWQFVJywQlhkB2MaVPDw+fYdJJAcMQ\n", - "pI0M9dU+woLJqVGKxQlGRvaytnacT3ziC/z5n//fr1pZPTw8zB/8wW/Ram2KYt+sIrl/DE8+Cfv2\n", - "QaVyea/jXe/a1I38MhQjmqbxvnvvpX7bbTQaDWzbJpPJYJomuq5z++1v+4lzVFXlN3/zbp577gWq\n", - "1h4u9aq08SjqGgWzQuK0yKY1fMOgEQySF1fRR0MqaRRAiBmiUCVLQpeEQMZYKOjY7MJkmj4lioRY\n", - "pMmQJSYhhYLK4NYatk0RnSYuFgkVFKaIyCBQ0EkR0KZPjQIxEaAQYgN9LIxNHpYAmyySq8ghvB49\n", - "JWa3qlEYKNNWY/xonfPdBrncDmCZVsvFDRWWfZeVahs1n6NcvpphTIZzZapumqPHLpHbafCO/fvZ\n", - "WFvj2NISxTB8Yyf1H2BTp/GT15AkEYahMz29wNjY7T/2u0KhyMTEft73vne+HAFx7bXX/sRn3H//\n", - "t6nXcxw+/E6OHDmPoXaIlRph9AIJNiohCQlJYmIYEb2eSxxbJEkM5BCkMcRuItklZpF4i6XKYdJm\n", - "lBAPVa5hEGChsxOFDVwarJPBx6AACFQibMDEIMJnFJ0+GnOE5AhI0SKiiLvlu7HxUYnIAGkEPhIh\n", - "fEoS+oAQOn4SIG2TS2GBWNmBnT+A31exRIU4KdGVJ9lh5MkGEk822LHnWixLp1bboLv2Erl8gefO\n", - "HKFoWAyN76VQHKIvHG686qpXXCAeffpphsOQnds2mW3LMLg2leIHzzzDW2688VWFkv5D/MIUI6dP\n", - "n0GIoZcLEYB0OkejUeKll85y0003vnw8jmMWFhbo9/sMDg4yPLxZcd999114nsdDDz1NfnI/S0se\n", - "8/NNLk3/LUNSRSvsou4K1oI63cBlPQrR7VEGbQ836ULfxs6quN4aOWqUqZIhpoTDOi4hGjlUBkjo\n", - "YbKGTifSSBgA0lgsAJKEdYqsUsYmRmWOiC4GJezNltEoKKiE2IQ0GKJAC5M00RbhB2tAD1BRyNHG\n", - "p0+TbUQopIkBA5sEP+6gJx4h0E7AFBqJktAXEEQGgjqCnQQso1NnmClMIvQQPOGiJ0MEUZ0gkCwv\n", - "r7FjxwSmWeHMmaf57ne/y6233kou95Oi1J+GX7Qi5If4xjfgNTS7/JnjXe+C//Sf4D//58t9JW8c\n", - "SqUSs7Nz3H//w7hugqYl3HLLYW6//dZXbPQ2OTnJf/yPf8Bf/MX/JJ+/idbGKGLuIotzM7SjLuNK\n", - "icUEbHOEOJQgE2w9RhE2np/C5DwV/C0qXbJOQEKWmM30TIsMCS45bCQRNjoeMRoGKVwcAgISlpAI\n", - "RpEEQAeBxCDGoMw6iywRkGFzU6AL9AgJCOkQUSCLRp8TtChIOCRUBiwbM2XS7KyzXcAFZ4N1/wKh\n", - "AmDhKRX6sQveKVJC5+C4wDJ0Tp+bxe90GFLznLg4Td/1GEkVaPkO3cuc83Pw4D4ef/wUYTiJrm8u\n", - "cKIoJAjWueKKWzhx4ixB4GJZPy7UktL/J7eVNjY2mJ9vMTg4xcmTT7O4OIsSx2iKRkgbgY6tDyLI\n", - "4yQJrtMkTiySpIMQI8AykhyRTBCkERQAF50KaQIkOh3y2NSpMIpGhKBNmYiQDpI866Qw6QEhWQTb\n", - "gT4BCRIPHZ0UPjFrBERUyWyZXOvEaGwyJR0SImIUGeMRkgbmpY8WCbxeREcrIopjIAUQIxAoSh4/\n", - "CkhlFBwvpnr6e+zIpEiSiAvnjlCWAZmuTdcYZtlpcun0c4S5FPf94W/znrs235VRFJHJ/P07d/78\n", - "efb/g4JDVRQKQrC+vv7LUYy0Wj1M8ycVg7pu0+n8fUZFs9nka5//PNHGBrYQdKRk/NAhfuWee9jY\n", - "2OCFF1a57rp7mZ4+yfnzT1CrObRqC3jlNLq0GSpKEm+IXsMhj4orJvA0hcHRKo2lsxQyWTruAjfq\n", - "ESWh8myosSZ1dArECBw6hIR00Oig4OEhMDDoYhGgEpKhxl5UYlw8bLYBl9jAZxx1q0CJt9otbRJ1\n", - "HikiEhSWUEiRELFJHDZRAZNBJLMssIC25QGQOEQQB5gE9NAIpEpbKrRjBUERnxBJHpUWGiEqFhqC\n", - "PDGqqmOpCp04xg8TNE2h03FYWVlhaWke6PA3f/MSR45Mc++9b+fw4UNv0J1w+ZAk8K1vbbIjlxs3\n", - "37wZvNZs/vL0qjlx4iRf+9rTbNt2iHI5TRj6PProiwRByJ13/qtXPOf666/n938/4NFHnyOX28lM\n", - "0ED3lmjVbM4pAbJYYptS4uJGSFFLEWsaQeTiJy5ZuphbRkohBLFMqOHTwkLF4ocui2jrGwuCNg4e\n", - "OiEdMgTkUVCRREgkaVRMFLoYRAgggwmoVIlY20raXEbFxGSMCkVa5NAAySnZYT1UCftQ1jQG0jkG\n", - "0jnGzBZV/xKOsxehTaFE56nIJQZUkH6P/uJJnq0vMqSWGbNtQq9FKo4Iag7LhQE0pcDC9ConTpxk\n", - "cLDMkaeeYn1xkdLICNe/7W1viIhxZGSEX/mV63nooSPAAJuehjo33bSHpaVlcjmdM2eeZv/+zbQ/\n", - "wzBYXr5IJiPxfZ84jl+xIO31emxsNPnGNz5PoxGiaYOoWhoZKhhajlJmAkNYJH4D310ilkOoQiBF\n", - "hJQe4AAZYgRs5YboBCS0cdAIiLCpkkGi4QE6CQYGCWnULV9MFpM0Bi5ldDqEZNjMbA2QrKIyQY4O\n", - "DvsxMPBJCOki2UDQRWIAXWJyJIyyyYyMAlkkvTigk4TktQKDhRzLvUU0xSCM+tgiYo9usdpbpRsE\n", - "JJ0VdEPh1uECS/UWNWAkO0qYHqLuVglHK+y96moe/va3mT19GkVK8pUK77jrLsbHx0nncvQbDdL/\n", - "oAD0pXzdTptfmGJk587tHDt2FPhxJ4fn1ZmcPAhsKrK/9dWvUu52Gd+ypUkpOXniBEdGRlivNjh9\n", - "eo0nnvgKGxs9hodvplwGrxez0VljW26FvaWrmG32CFKDNNw1QplgWhUaIRy+0WaoWWM50hgKJWEQ\n", - "40Q2QqYYIo2OCRRZYI0GWXT2Am1UZkjootMkpMEePApoxAiW8BFoZIhZ27JrGcxQoo1FgrdF3kX0\n", - "KZCiiMUyHTJABgiI8EgwsCigsY4gIkcXg5ktk2FJLeHFffpy02YYMowX91glhSBPTq1TSHLUZRXB\n", - "JtuiCEFWVYEWSdRGVVO4bp3V1QZCdBkbq3DFFW8jikK+9rUnmJjYtNP9S8aRI1AovLGpq/8YLAtu\n", - "uQWeeALuvfdyX83PH1JKHn30GUZGriCOI5aWLqCqGpXKPp555ji33XYzqVfoWCiE4LbbbuXaa69m\n", - "fX0dy7qb2dlZvvu5zzGazfLizCVm17LsMCRLa21imcELHQx1gcOJQ5AIVggpSQUDhT4e6+QwSQES\n", - "lRTrOIwQMo+CzyAqNg5l+tTpU0XiI1jHoESwlfPjAwpN0gjymOgYbOATERCSZowCaXoMoKBgUiOi\n", - "BLSJqUUOM72Y63N5wqhHX3aIlTxqEhNFlxiiwXa1yEA2RbWzRKofQbiCOphHNXT6XouKIsiqNpf8\n", - "DocO3oCWL/D5zz/AmBmyK5vlUD5Pc2WFBz/1Kd7xgQ9wxavUh70W3HTTjezdu4eZmVlgMyTx0UeP\n", - "kyQ1osjixIkTPP74IwwM7EaIHqYZcM01N/OJT3ybQgHuu++uH3P6bTY9/TueffYYy8ujZDJTBEGT\n", - "RCjoepYkMej2q4woaXRpYErwmEeTeUJCYIHNyMofZnMmSAIkAWnqmCSYqNhIHPr0yZOliIKOxCeF\n", - "pEOPEjYGCjYRDhARM0bAOhILwQQChxALkzoWFvbWaD0y+MwSYwLprWCIOpsl0gEECgo2MRdki87a\n", - "cYx4DIWAKLZR5AaTZkxWQEeR3Do4iGpHXHv11SwfO4Z0wFEV9u7aTiIlEduZNyw+/+kvcc+hHdyy\n", - "bRuqorDRbPKNz3yGD/ybf8M1N9/MY5/7HAO5HNpW8bdSq8HAAOPj469r/n9hipF9+/YxOnqMhYUz\n", - "DA1NArC+PsvkpMWuXZu20Gq1SndxkSt/xB8vhGBvpcLT3/0uZ5e6dLt5PC+hWLyGXi8mDGP2HryG\n", - "qHGeATtNq3WJIIKO0iPMDjC+6yosy2LnwDiTkx6r3/8udjrN+WqVvutRS0a25E8tChj46NQpEWNs\n", - "7QTnAY0MZ5jY6kHQI0MDgU245arRUdARzGDTYy8OFTZb9cQ02CCmBizhYaK9XBVbWzxKjw4OCgYW\n", - "Gg0ifNKiQoYs88zjxSEasICBQ0SXGi4GUuRJ5Dw58liqgh1laDOPQZF0kibwe0i5hG6orK8fQUqB\n", - "qroMDSncdtt9qKqGqmpAienpC9xww/Vv2P1wOfDlL8N9913uq/h73HbbZjT8L0MxEoYhrZZDvz/N\n", - "9PQsUAQiNO0opdKmuP3QoUNor9DeHCCTybxMNw8NDXHu+HHMapUrd+1gqXqavitR8BnQHdrJOpa7\n", - "Qj7Z3N+vIVgloYfGGhDj06BKQBeDFhAyjU9IBZMMARFlDHKU6eCTByQz1HGBCSTQZwmLFnWyNGgD\n", - "ghZpPCwENio+afqoWKzjk8FlEkGAJAdUNY2FuMdwqYzTzZFddxmS63RlzLDw0dUCQRxj6AmOt0xK\n", - "KdLoLxPJPkW5TtrOk7JTaBrUZcD4vrfw4pGvc/MN+xjb6gFWKZXIplJ876GH2H/gwCsyDz9rlEol\n", - "SqUSvV6Pj33sM5TL12CaKZ555jny+VswjAWmpjKcP38JVd3N0NBV5PN52u0an/3s1/l3/+5/Z2Nj\n", - "g+9//yjPP3+KmRmXTKaCojQRooJpVmh7JwjCi6iKSpw0aEZNTDWDLWwS6ZETCa6MUSgi6ZBwChhm\n", - "M6asQ8QqaSQjBOQZIMbHYRCXOg4KafJIhnGYY5UAhxUaaPioCFS24dNEMgWEKKxhEuHTR6JS2LIM\n", - "J4TkSbGKQo9lEhQ2uTiAvWzmw0pi5oCdSpeWuIDoBRSESdPbwBRVhtSYi60mhiaYGBzEsyykpuGy\n", - "mXgqkwTLtlGEYKG5jsyUiWsddlYqzCwvc2l+frMRl2Vx9Omnee/730/tzjt5+rHHyEpJKCVqucyv\n", - "fuhDr/v+eF3FiBDiw1LK//G6ruCfCcMw+PCH7+Ppp49y/PiLKIrgne88wI033vDyA8j3ffRXsBdZ\n", - "hsHc7CWKwzeysjJHEARkMmlsG/r9GrbtcM1tt3Ls6W9Q63eohxrW0AGu3X0l+/btoF5fYWbmDM1m\n", - "i2Ynot+LMKOYRcYJ2UdMhnUaNKlSJmQAm0XmCYgBi5geaTxMFOoMEVIij0qdEJcqWQQ9TNII/j/u\n", - "3jRKsrO88/y9d4+4sUdkRu6VmVWqUqlUm0q7kFglaAlrZLcHm56xDeNj+wOGMYf2mfY53TM+TDc+\n", - "bvdpz7HbM4MbmsZuYBi2QVi0MQitaC1ttVdlZeW+Rsa+3P2+8yGCAqEFmkUF/n+KEzci6s26N+I+\n", - "7/P8lwIOI0hMQhIIzIFqJh54hJwhHgRS97UzMUmy+ECPOh10DDL4uNIjpQ0RxVli2cNDZZIUARHz\n", - "xMAqgUySZBKJShQ5QBKFNVpKjbZIIMOAvKZT03SmpzdJpVIUiwe44YY7SSa/R24SQsP3/TfgKrhy\n", - "CEP4/Ofh8cev9Eq+h9tvhw996Eqv4qeHVquFlJJsNvuKY7quEwRtTpzYpFC4hkplnu3tFer1beJ4\n", - "i0ymRLn8JL/6q3ex9/taV57ncfbsWbZWV1EMA6EoPP/Ms8ydOs3C2dPko4iwskNca5Awcwwnc+wp\n", - "wflLfaP3EhFpEoTE9NAQA55InhUUInw0HLK0KJNiFwoWKj367A+FmBwRCxxF8iwX2aSHSgHBNDFX\n", - "s8rqgGkWEZBliBprNAnwMYkQeAR0mUDiAqaiEugaE4bB8VaL53o9UqHkmvIYl9Za6CJBAY8oXsPr\n", - "GmSMLrmUZM3bwCIklVQ4VddZckxip05PlzCT4mB+hKhbp/wD3c1UIoHc2aHRaPxEfID/VjzzzDOc\n", - "O1cll5vHsjQ2N9uUSnvo9SxWV5+lWDyCEDbz80scPXoQ1+3xwgsL/Mt/+b/T6cDU1E1Uq0lcN0uz\n", - "uUQikULT1ghDH8vqoutput1RFNUlly/TCxbQ/HlyUZcwnMSUKgYJJA4agpgaPUICEgiliBNvoyFw\n", - "aBBgIRnBIGKdBg1UQrp4QAEVnYBtikQMM0aCDZqUWL6slPEIEBjkCamyhSSBgkaMRoWIApAbXFEG\n", - "/T7NdzVHAf2b+H4h6Vg+qckuFa9OZXMNW9XYn8uhAsvtFvVmE7VUIpvNUtq1iycXH8co7UHKmM1W\n", - "naphEcmIfSNZHn/+eVrLy4wnk6hCML++zte/9CXuuvtu7njLWzh67Bibm5tYlsX4+PhrynodxyGK\n", - "opfxTl4LP2ln5KPAG1KMACSTSd7xjrfwjne85VWPDw8P42karu9jfZ/KY21nB9XOMTq6ByFMVlb+\n", - "jlZrAU3L4DhblMtjZLMZQkVw+92/z6lTp0mljrK5ucWzz34aVc3j+wGl0jDb26D0QlqhiScniFAR\n", - "6GhkUdHpskTENhnSdBH0kEg02licBXZTpo1KF4jQaTHBNuuMMkqbNQxUEijo+CQHhYgJhIQMo5JB\n", - "5TTaQP5lUECQRFAZNBb3Y6Ih2aBKJWyi4JHHH7SOA7ZEQEcGxBRQcAnEDorI0FUcmtEqGSKGVAPC\n", - "NoGMacY54iDHynzEwWOVbjKiAAAgAElEQVRlKpXNl8nv+m6IO8zM3P4zPPNXHt/+dl9O+yOoyN8w\n", - "XH89nD/fd4T9MTjEP1f4m49/nNryMkII8pOTvPO++yiXy5ePCyHIZFK4bpu5uScJwzKt1ihxPI6q\n", - "LrC8vMnY2F3863/9H9i9exe2bTM2luf4ww8i19aIOx3WKxXOr26wK1cmbSYZ6zVZdTpYisGd2RJO\n", - "4LLR2mIksFjwJWcQqGjYWHTR2CZCp0GJNDMkKeKyhuQ0eQw0dBTsgV27j4IYhMd38VnGpEYKwS0Y\n", - "pAgJiAjwsRDsoCIRVNkkg42kSoUtIsYGlogOMQ6SbKzixCqGbhI7DpdWmxTbMQveNn7kIfDYosMI\n", - "PkKFq7MpssPDCEXhfK3GeifJ+NA11HsKXc0gn01Q29jiqaceIp210b/PWA763+9ASswfeP5niePH\n", - "n+czn/mvrK0puK5kZ2eRRqNGPj+NEAq9nksqlcQwUlSrW5w8+RQXL27iunlWVzfJZLLE8RyGYZFI\n", - "JCiXZ2i15kkmd2FZGVZWHkXXy+h6g9CtU+94xEISBgoZOUovrqCzQ0AGk2EMbHRGUWlSYwkYx1dG\n", - "WIpbJNgij0TQQZAlwKGFzzgeQ3hoKFwgS8wMKjqrdNBQkNgcJ0AgSRMQouBgEKNjYrNFHZMOE2iU\n", - "6RcdCjAHpOlvRjXApz9IEnFMpdeEiootBDnbZjmKiHUT1ARlq8jF7RUa0UVuuO02MhMTmNcfZXWz\n", - "wbdXzlMY3U1xbIShIUGwkqS2tMTRYvHyb/2E5+F0Opw5c4bDhw+TTqdJJpMsLi7y7DPPkMlm2b17\n", - "92V1Zbvd5ltf/zoLp06hSEl+fJy3/9Ivve55/6HFiBDi5OscfqUjys8IUkouXrzIc8+dwnV9DhzY\n", - "zaFDB1/2JTFNkzfdfTePf/nL7M5kSCeTbDUabAA3v/l25uYa7Nt3FFVVePjhRzFNg1KpxNRUma99\n", - "7ZNIaXHmzBKe57C29hVaLZtWq0OpNIOu+6wu+0SeSeiUcKmhMoKBIERFo0CERY8XGcVlmhQ1Kqwj\n", - "qDCJxz56tBBoDCNxEDSADiUiHEBHwSRApYtLCgUXBYWIkAgdSGFhoLEbwSWaXCAYUKsi2vjMMna5\n", - "ayKZJgG06HABB2uQHOlIhyQjZMihoeIpDdrxEmHsksZnSrVIYWKpKSrCI1KnGEvvJ5XU2VrTGJko\n", - "8vd//xne+tZfIY4jGo1FbrpphvGB1OsfKz73Ofhn/+xKr+LlME04dgyefBLe+c4rvZqfDLlqlQOD\n", - "8er6zg5f+OQned+HPvSyHdXQUJmRkSqnT+uEoSQIoFgsoao2m5vLPPnkP1Ctmth2miBo8Zf/7uPk\n", - "/TrjRsC4At1Ol5v0BI36FlW3R1poZBBUjYCOEAwrKsu+x1yjS5IEK2h4jA4KhW3GBt/WkAqrA4m9\n", - "SZISSbaJcKmhoJAfPO/SRKFGHoWLhITkiAlxqSPR6E//RwaZMxKNCJUWU4wSU+AiF1jCR0EliU5u\n", - "UOgo0majEdC10vgiheN0kXEGSQMPhzYhHi6jUcx6VzBfraJNznCpWicIijQNH00FQ7PptFTa7jIO\n", - "NfZfPc03nniSe25/0+Wb0IX1daYPHfqRdrY/DXQ6Hb761UfYu/dtbGw8TCJhMzQ0zcZGk1ptC0Vp\n", - "Mjs7S7VaQ0qVZNJnfn6bQuEo29vzJJNlyuVrWV09weSkzdraSVR1BlV1SCQ6tFoVGo1zKMo0mibQ\n", - "zAyd3g4GwyiUULQkUZQdkI0DQooExAjOAx1UsY8o7nvRGKTxsGmzSIY2EWVCfMboK6JqDBNjDOLx\n", - "FAQmgik82gN7f8kMHi4qbQxUoEKGBjEpFHKkgA4CmKTPE9GBg/THNVX6SpsaYMgIG8g6DvU4ZiiT\n", - "4YzrMdd2mSwV2PBcTml5pFLis8++yO984Hf5d3/4hwghOH36LO12l+npCWZmZvhfP/IRjF4PCn0z\n", - "tNMbG5xaXyddKPDxP/1TfvODH+TgoUN88W//FmdlhfTA++fhQoH//n3vI5/P84VPf5pkpXKZd7JZ\n", - "q/GlT3zidc/9j9IZGQbeBdRf5dgTP8L7fyr45je/zUMPnSWdnkLTsly48CLPPXeK97//vS8rSCam\n", - "pjB37eErTz6HpcXccsct/A/33IOUkgsXPkurVWDPnsOk03meeeZhXLfC6uoShlFicvJtmGaSVMpl\n", - "aekBikWLOC4zNlbmzJmLEGQQCAxh40qBQRrwsHCIcYnpMESLWbKE6OgYjDOMoMsmIyjEVMjSpkIO\n", - "iYaJQhcI2cIhHNS6GwSMD36aOkhWicgBKiY9YlL4jKKywhgNUqSQlNhG0GQHA8ksKhoJAppk8ZjC\n", - "Yw6DLBa7CNjEJUQoPboySxCnUVHxqdNhizEpEWYeL5LkyeMGLXZl93KptcOhQ29nZeVJKpXHiWPB\n", - "tdfuxvd9/uRP/grbtrjttqNcd91P7sb38wTH6buu/pt/c6VX8krcfjs89tgvfjEy/n3S0rFSidry\n", - "MmdOneLGm2++/Py11+7m/vuf4sCBo9RqDrVagGWl6PWqSJlma6tFuXwzFy+eYGWxgvTGcd0h5nst\n", - "trUKcbfGKG18JFkkJQJ8obAVOiybCYpmgpofASUqeEgMMqRps8QMCjbDSFqoeOSIeYqYMgE9uoQU\n", - "8egQcokEOUICJMvk6GKQJk8PH0mHOjHDQAsoDcwTv9snLaJwFkmAggFMYBBSJcUCS+zBJImPH0as\n", - "4LEa2kQ+WDImRZsNYgKG0Rljmy5NUccVIZPZMpfmBSYlCum95BImHW+LuLdDMTtGNlnmmsOHuO6m\n", - "f8Jj3/oE8sUX2VUq0Y1j8rt3c9c997xh18HKygpxnCGfH2b//r2cOfMSuj5KIgFzc49w662Hue66\n", - "N/PQQw+ws7PJvn1j1Go5Go1NhoYS9IOGJVGU4bnnTqOqGarV03S7VcKwguuuYRhdEgkLzwsJwxSu\n", - "VHFkB8E2XUbxiUiyG51lbAQRKgEFOgTElFCJMAgQRORJ4aKisEUFnwCLHRw8yujkkPiDeDuAWQQh\n", - "Nk2ylAb6nGVGUXGJmMfGIAuYFFAxCfHpK0U9+gVI39pSMA7kkawC24BLn52oxjG6EMx1u4yj4Qc+\n", - "j29u4SmT2NlDlPYcYa12jqXVHd6eTqOqKrfeevPLzsGd997Lt1dXuVivs9FsUqtWecvu3aiKAqkU\n", - "L9x/P48/9BAjjsMN38fPXK1UeOBLX+LWt72NYGODq77v2EihQHtt7XXP/Y9SjDwApKSUL/zgASHE\n", - "Iz/C+18TQog/B44Bz0sp/+C1XlepVHjkkZNMTd0yIExCLjfE4uKLvPTSCW688Qagbyn8yU/+f+j6\n", - "BNce+VXa7RrnL65yW7vNzMwM73vfvXzlK99kZeUcUsbcd9+N3H77DXzqU3+HorjMnfk2im5jJUdQ\n", - "1TF8v4Kuhwih4DkeeStNt+eAiFClIGINQR6JAngozJEjoI2HJEVMCg2TAjFbqMS4CFQcsjhEaLTI\n", - "00VlixZbjBOjoNAmxRw+DgENBDqjdFBYxyWNxxgRNVKMkaKFRXuwr7LR2KCLhY+HSkx6QIYbw6VK\n", - "SA+FFFKk6ak9NJEjkjlSwiaOFVQ5Ql3YrMRzTAVNQlLoSHRdoGsmIAmCgNXVOrncAWy7zN/8zROo\n", - "asA73nEvUWTxxS8+w/r6Fvfee/dPcmn8XOHrX4frroOxsSu9klfi9tvhYx+70qv46SNrWVS3Xx6e\n", - "ePToEcrlzzM/v4RljeF5VaKoyfBwnlbrIpaVZHn5SbrdGiKcIPAdTCWFjokXaURUcPDJCkEKBVPG\n", - "JIGkjKn7Hk8EIetxAg8LD4lOkhbOQDExREiDmAx9b8wGCg6XyNOjQcQ0MVlSXMBgDYMGWSLKWGio\n", - "BCh0qdJjiJgJ+tTFAgoOoKGjIvuDGOqs00PHJUVAGxWLFQ7SYAmbgJCYNjl0OY5wWzQHGcM+EygI\n", - "AhQ0soxaU9SCOfSWSjKyMCyJKx2224KunySKHLpxBzPTYHL2WhIJm2O3vod0ep1b3nEHmUyG0dHR\n", - "l41lf9boh9tJAPbtO0KpVGZl5RLJZIJez2RqKkmtdppjx8YolVI899xpPA+OHLmJPXtmeeml06yt\n", - "bbO+vkk2W2Jk5CoqlS+Qy6VJJIpUqwaq2qNWO07KPIZUFKRMAg0kwwSBCvi4OIDE7jt24KHjYoDc\n", - "JoVJCYUesINEohNisIZA0sKjgCRNiEL/L/HpG7ynkXRI0k9g9smzzjYaEjnYUoZ0sOjh0iGBgoUx\n", - "cA3xBr5SfcfteQQRGmMoRASsD9y4O3FMU9PoxTEHRYTUDRpikrQYZssP2ZMbRdNCLlxoMD8//zJ+\n", - "1Xdx3fXXc/Laa9mXTLLwjW9woFAg7HapKgo3zc6SsG3+8ktf4gM/kIkxMTTE4vIyi4uLpF7lmin8\n", - "EJftH1qMSCn/p9c59t4f9v7XghDiOsCWUt4hhPg/hRDXSymPv9prV1dXgfzlQuS7yOcnOHFijhtv\n", - "vAEpJfff/y0ymf1ks/1dlm1naTbTfO1rD/LBD/42MzMzfPjDv0OtVkPTNLLZLBcuXODCyZfoXlrF\n", - "2mgiSVBRVXbCHAm7xdRUmXptkdiv0Y5MwtBDk9skUXHZRrKIxEJjgxSNwfyw13dzJD0wb49Q6BBj\n", - "I8hg4ZNAxSdFl0U0kmRokUVllRyQRBDSw8VhgjwpYlxcJF0uUWSbNjpJNEIMfDJs0yI7YKj0AG3w\n", - "CQJBRA1JBkmXNgEJ1cI0HbpeAkUmUaSKJ318VcXWx6n464zGXSxFQ5ohmWyJeq9JIptiaWkFITT2\n", - "7buZc+cuYtvXoighp049z6FD1zM0tJennjrBrbfeSOkKGyn9tPCZz8B7f+wr/WeLW2+F554Dz+uP\n", - "bf6xoOG6HPiB/KNkMsm/+Bcf4KMf/Wtct0M+30HXc6TTSVZXL3DxYgQkCMMUob+FJhRM2SWrxmii\n", - "r1Sp0GVUQkpVaEYxNRmxhUYjtmmh08PGIkWODjY1KnSI0YmRgyjLDCkqpNDp4gMdHFSSPEeWAIOQ\n", - "kO+aEfYtvHu4uMTsBrZZAbIog02IioYgTUiTJIIuHSQGKjOoSBTG8YiRtOnxDpyBti4gJiGbjNFg\n", - "iAyL1EnTxKSfltJDpx3ZhFqWnU6IH3joaYud+hLIvRhKijDu0Ao8SlaCdLqA63ZZX79Euz3P/v17\n", - "GR4efkMLEehnien63+M4HRKJFMXiKMXiKAsLz/PLv3wvIyNlHn74O8zNrdFouNx991s4fnyeyclp\n", - "dF3n0KFraDSeoNF4EUXJs7DwOHE8iW3PEMeCKGpjeOvMxC4p/yK90GWDJi1uQBW7ieUyggIxq/SI\n", - "8DGRCCIm6Q9EBEkcJAoKSXrExJfTZHxiplAYRmMPMSukeAIbnTZrBGg4JAfC7gCJiaBIgIakhyAi\n", - "oIFJmzY+KSIkCQIkdfrj9745nsAjwRAR8UD8oGOxRY9CrNP2I8qJNCv4rDkeGCbJpIGM4OmnH6ZY\n", - "TDA6Os2FCwuvWozkcjnuuO8+/o9/9a/YnJsja1msKwpmsUi71SKbzWKEIX4Y8oPOX5oQ2LZNN45f\n", - "8bn1Tud1z/2VlPbeBPzD4PG3gFuAVy1G+mqZV/5xYRgghORb33qIxx57jkceOc6hQ3dgmkksq+85\n", - "kM2WWF4+R2vwnyiEeBkrfHl5mdaZ51DbRXLWEK7rMCbBkav4MqaYnqB54Zvk0en568TSGeTDdPFw\n", - "kSQIWSeHP7gcLcZRMfGoskKIoEoXSQYVmywuI0SYxPjAJiYuDRxiTpNDMIaKCdQIGSckQRWDAqBh\n", - "4jPGHFUkFttYuKQxUFC5ihXOo1InoIFOgoAkBWxcqjRZwx9U5pHiMlQcRmsbdHsmbugSawmkkqAT\n", - "7CBJ82zUJSl6uMESXjuFruS55dYbOXXqGd785rvQdYOtrSqmmWdz8yzHn3mcF554hIQRk8lZPH3b\n", - "Xu55A9u7Pyvs7MCDD8Kn3jCa9n8b0um+78nzz8Mtt/zw1/+8Yml7m6mBpHRle5tuOs2Ba78Xnug4\n", - "Ds8//wIvvnie6ekc1WqV2dlpVleXuXjxcdrtHqnUYYTQaTR6xGQJ4goN1UHGEj120JCcQ9IENqOA\n", - "BrBGApVpIIEC6FSYZZssJjYeKSRrxPSoYjKMTY0cCVx6+KQZAiyaGAiuwkYQ0KPHJi5nsVDQ6PZZ\n", - "WFiYJAlx2SZGINlGMoskJqaFC8Ts4DKCTgcFCCkgySNpI+gQ0wZMJKskqDGKjUObWSJSaAMSfYxN\n", - "jw08NEXBkx1SWp6rs8NIv0PHW6bhecSySjE7y/jEbZw9+wLNZptKJebqq/fw6KPrPPbYS7z//fex\n", - "6/va7T9rJBIJ3vOed/K5z30DKUuoqoHn7XDNNSX27NnNn/zJXzA318ay0gwNDVGvb2IYDmtrT6Oq\n", - "Q0gpmJgI2bVLR1EmgQymeZggiFhZOU3QmWNW1jFkEjWOsBSNRJRkjh26coJ+KJ5Hn51hERLQH4C0\n", - "EQhMNi9LDDrExHhkOEDADoIQixw+KhE9hlmmTG7gp+oR0YOBhFcnIKRDnn7SZRcHiWCCNkeJWSdk\n", - "a8A46YcvqpQHypoEOhEq24RsoFHBQDJGiE4vjNmmSdd1KCbTIBzU0KNa7+DLDIliiqmpQ5w7d5KX\n", - "Xgp597u/N9+t1Wo8+OBjnDw5x/raGpV6j6aWZhOTfMJgMpdn7sQJikNDWKUSZ5eWcLtdut0upWKR\n", - "sZERRCrFsWPHOP3ss1za2GBmZAQhBDvNJptSvu65v5LFSA64NHjcBA681gtnZ2fR9W9frpYB4jii\n", - "Xp/H81wuXQopFK7DshwuXmyztfVN7rjjn6DrxiBfIHpFhsry8jJPPHGc//LxjxM2HFQVDCOHaRZx\n", - "nG3GDY9gYor6yQe5u5jnkmhR7zbB7TBHSMgEaVRa5NEYRiWiQx2fHSQeKRIEOGxQocoM0MPAo4g6\n", - "kOQG+GwzRQ+dkAYKNWw8htHJ46DjAxF5oEt9YAwcksIngY5DiwQ6BTRCfHYQKPhoJFklxkOlQEiM\n", - "TYiNYJMWpqiRKSXpxBEdt0MYXk0Y2yS1BBDSiddBJtGS11PYVUI1AwyrwZvffDVTUyk0bYrp6f0A\n", - "JBImp08/y9aGgx5OsssewQs7LM0/w7/93/6M5eUt7r33nb/Q5NbPfhbe/W54FbXpzw3e9Ka+5PgX\n", - "uRgJJid5dG4OAYzs2cOvvfvdl03MPM/jP/2n/4f1dUGxOEU2O0a1epxe+xw3H5nC6WRIJG7Ctkc4\n", - "fvxZhNhC1xN4rkRJDOHrSXZaT5LQNcYDlbKIWJYJKmRxuAqbNA5thmjSF7jraMSDUU1AgQIrVCnR\n", - "wsanRkwFiUEZlRoFIhRsFHQ0IrIkmEOjyy6yWNjoCFTWOD2IyRP4KKzTwsMfaOZ6hDhIhpDk8dlE\n", - "DnwpoDcY4ZwiQQh4GGxiE6ANBgjjQGdgoBijkMDGooUre6QUh5mJIq2mi6WX0KWHDM6QMHOMJHK0\n", - "Vxd4emOVkbE3Mzyc4uDBoyQSCVqtEl/+8jf4gz/4nTe0Q7J//34+/OERzp49T6/nMDNzjJmZGf7q\n", - "rz7Od76zTrl8jCiyuHRpm0SiwfR0kV//9dsJw4goipmauoMPfOA8cbwHzzuP63ap1TpACTPqkbV2\n", - "4zhzRFFATNC3QxAuntgmijtAAkmXfidEpS+qrZGmzRQFaizRRiXLOOogfKOf6FtGEqHgIFhliH6H\n", - "DByKTFKlRRKTKgYxCxTxkeTYIKCLis0Os7hs0O+zXIVCHVgkGGw5k9Tp0UZgE+EhWUIBRkkxSo8e\n", - "PqAyxlawiutvc9fkCC/WmyjhNEJYYGoEgYPjrPO1r12k241461tv5MiRg3zyk/8vnjfM6OjtPPQP\n", - "n6G2WSZrJ/Fw0bQUpxe3gBYnNzcJR0f51uOPc10mQzmdZmNzkydOneIDH/sYpmnynve9j2/cfz+P\n", - "nT+PAtjDw9z3nvfwBx/96Gue9ytZjDSB7woSs3zP5u4y/viP//jy49nZWS5depGtrQyKohPHNWZm\n", - "Eiwvm4yM7EbTdKamxlhf92m1AjY3F5ic3MfGxjyHDs28zKr25MlTfO5zD5JITLK15ZPXR4jDEMdb\n", - "wI1DdE1FUxX8IOb6yXFumJnhgOfxd99+GNP12CRFFYseOjBKgi5JdBx0QpI4rNIkZguLGkVi6ugs\n", - "ozOCwTCSEIc6Y/j0TXUDQoawsFjkEj5XI0gQ0hq4C/gojAAmKut0sLFJorNDPLDKEfTQqZMmYgyN\n", - "iBCHChE+CZI0CEjS5VgqjZkr4QRd2qMBC5tncMI9BLJDFFWQAopD4xw+eifj4zo33niU5eWT3Hvv\n", - "AW688Qb+43/8L1Qq65RK45TLaR56aIvIKWDFPjvby6x2KsAuvG6WRx9aZW3tC/zmb979qu3AXwR8\n", - "6lPwZ392pVfx+rjttr7a5w//8Eqv5MfHr/3Wb+E4DlLKVzipnjhxkvX1mF27jgCwtbVMd/kSydYG\n", - "5XwG79ISjcAifdUkw8N7CIISOzsvQdjE9SWRMLHzCWaVFLNCsNZo4XuTJICINC4mKXSqdBgmxEAj\n", - "gY+KTQ8HQYUuBk2yBOyQJIOFhYoxaJJ7A0sqHR1JgxDJMBaJQVNe4NJgHJuYBjEGCVSSwDI7dFBJ\n", - "MYFKGYFDQJIe0wRsozFMTAfJDhodBD1MMiSYpU2XTWqUgRwWkjZtQiKRRtUMYnWTm99yL/b2IuNj\n", - "kvNrbeoXF9EDOFAcQubLzE5McGbhJNX6FpM3FbjuuiOoqsry8jKdZpN2d4Hl5eU3tDsCkM/nX0as\n", - "bDabfPObLzA8fBO23fdCMc009fol1tdruK7Pm9506+XXXnXVXpaWHAxDY2XlBFE0QxSFJEwbTZOY\n", - "pk4UuGjCwA1bKEIhmYiQcYGeB1Ec0e/GZ+kPR0YJWKJDhRE1w1LUwiaJpJ+r3LeiaxGTxcInpEZf\n", - "69Kh798UkkOjS4MaaXqk8fCpEBMRs4sOSRwCoDj4tAQqZcBEsIVGTJZ40BURWFg02EbBIoNH3xu2\n", - "hYEphkHG+F4NP5SU0oL11jJSG0aNepw69Ry7dl1HIjFCtWrzF3/xAF7v3zNcvoHrrr8Wx3FptSNG\n", - "CgdxvIv4+ZhTtXXqOx3iuMq7Dh2k0WgwlMlg5HKIbJY909PstW3WFxbgttvIZrO85zd+g263SxiG\n", - "ZDKZH1rQXsli5Eng94AvAG/nVfxK/uiP/oj19XUURWF8fBzHcbh06RK+7zM5OclXv/pfOX78HIbR\n", - "RoiYsbEiqZTH5qbDmTPPE8dNJiYs7r77e/rmMAz52tceplw+gqKo6NkxetVz+K0ddqSCopcxkmka\n", - "cZdCsoI9lUfXdZxKBZOYhBJhxAZpQnxGibFxcQgH1ryQpkcCG0mMh8EaJRoUUKixSheQJAmpD1Ip\n", - "uriDWbRGjiQtdmihkUVjBYUWGUoY1OnSxmFroAPooAykvwIFmxwZFukM3EkyWKQGOaAdmgQ0KZGn\n", - "YwyzvNVgXO2SEj7TNqy0L4BI4cUBplaiXNiLoihoWt9Rz7ZLLCysceONN3DvvXfyyU9+geXlOkHQ\n", - "VwJ12vNEqs5GZxtdTJIxU6xv1JjaC4XCQb761Qf5yEf2/MIpbF58EapVeNvbrvRKXh+33Qa///t9\n", - "o8Q3eMT/U8VrZVucO7dAJtOPSY7jiPkXH2ZfMoMHiCjimokytbkKjcoSoCCcJXbj4IhV0tksbdmj\n", - "roSUzAhX6CzKBFLY+LKLICCJiYVCDZ2YFrmB7fYOCltY+BSRCKBJg5AiPgoh/aySLt3L4ZR1YiDA\n", - "Q2McD0kTSUyIpIvEJkQCPQRDmGhYVHGxyTCEgzfogDiYpImJsXGIaaLQxSAmYpwCGRIDwa9HhnXm\n", - "uEo1yYuQSHHxjRSxEpGyMtgyxldNdmUy/Mrbb+evv3g/lTWNTHKIZb/J8ws7SNnFTtrEoUccxzz5\n", - "0MNoTo+ErrNdPc/nP/EJ3vfBDzI8/IY5ObwC6+vrJBJD9Hrh5eeiKMJ1Y+bmnuKBByyWlpbobG3Q\n", - "qFRYvLDEzL67OXBgD93uF6jVFokiCycIcVhldHiWVmMDRTZot7t0hIGMU3hBEyl3EMJBymuAWUBH\n", - "sIbKNDVqqFETH5MtXGJiHLLoWAi6qFRRSeNj02GDIVo4QBWJIEdrYBWvYKOzTRETnwCNJhoRDpLS\n", - "4F8ESQcD0MjCgH+Yw6COpEMFDQ+DFhKJg46Ci0FSVjFoQ+zw7GaLdCKPaY4wMZmm67Uw5DWUy0c4\n", - "+9K3aM/3SEnJXGOZat7AqQdMX3MN6dwwnYaHJrKkbYGq5FGiPE40z/UHD/L8U09xzdAQ8/U6B44e\n", - "JZlMEscxj5w/TxzHl3/rbfuVeXKvhStWjEgpXxBCuEKIR4EXXo28+qd/+n/j+xYgSaVC3vveX+Lw\n", - "4X4g2/z8PN/5zkmEyJPP70bKmNXVDcbGkhw6NM6115rceefb2LVr18tugjs7OziOQqmUIggCnHaN\n", - "VquCHxtk2IWIdCqtgCA1TaEEDSVgs91mZ3ubWEriuE8ltQY/TzomLYoIKmQJCekR06aBTgODMbaY\n", - "xUfSn0K2OU9IkogAmxgfA4cUIBF4KPTN4y0EUCNPE58mMQZDQEiTRfKEXEVmICtzaOKxRIoQhQLn\n", - "aZMgwAAUfCpodChSpAhtQVf6LAofLW5wrJijkLNIqKOsdWqc76nUduoIM+L66/tGZo7TpljskwlL\n", - "pRL/9J/eyblzF1hZcRFsY1tTWFKA9NDUUeK4hRm4bGxukkrlWFkJqdfrb6iD408D//k/w2/9Fvy8\n", - "11ATE2DbcOEC7Nt3pVfz00cyaeH73sBr6CXWLjxHoJsoimDv/jw3HbmGxa1nOL19HC1RJtNeRHca\n", - "JI0CeWuGYdFj0Z2n2XE4YOscLBXpNZNUuz4rbA24WAo2FbJohDjYxMxRJM0Em5gIRgZKt9OssEkJ\n", - "GxWVNkVceoyikcYnps0OEQ26GIP4hSYRNi4+JoIs0BrcPCQmAQptapxCo4VBhMkQAUUUtgB/kHo1\n", - "gsMaMTmSBCAUdBCYZskAACAASURBVFRiPce2n+FJWaMcg4wVYs2nouqkkjnG4ohnKsucSrjsPXAV\n", - "bz5wFS86L/DQ6gKhtourp65hdmyE4+eOc/z5E6ytrJJwXcaGhpCxy8FdRa5OJPj7r3yF3/y937ti\n", - "14BhGIyMFJibaxIEGTRNZ2HhHJVKDcsq4PTyfPk//C3XlpNcd3A/UdHkwUe/xOFb/zvuuOMunnzy\n", - "BI3G06Ryu6lKF5wecdggxGTHshkZOkSrV0H4DTy/TRjmQO5CESpBFCCx8aigkqJORJ69tEjgoQKb\n", - "BFRIY6OzREAeDZU6DVQctimgYAMxEUVMcsScZBpJkTYKAQYREX2Sqo7OMpJw0DUR2Li00aiRRkGg\n", - "0sNlB4UubTRMLPbiY6MiSeCi02AIyWQqyfCuUVbaEWHTZdvrMTK7i4Xzz5L1O0xnUqQTCbphEd/t\n", - "QafD4vnzpNIWXZmitrVIz0uzud0kISXX7N+DnUwSSIkiRN/LqtUimUzihyGGZf3YI70rmk3zenJe\n", - "gFzu6OXI6Ha7zqc//VU+8pHfxrZtHnroKWZnb6FeP47rtrCsDIXCOEtLJzl0SOdXfuV3X1XNYRgG\n", - "Ugasra3z7LMv4GyuY4YmnjpDTzHRDYNU5OFZGkIb5bn1FzjhreOtLxJ2u4SAS48ObbosIcmhUKKJ\n", - "PyhSGqTwsTAosUGRmFH0AblVcImALbo0EMyjopNADuKPfLo00XHZIKbOKFskgTTrhEQEKCTQsEnS\n", - "ATr4qKRRGSdgjQ4+DgKF/YQYOGwOONkm6UFWTss/z3W2jefaiKhLrdFBWBErUQeiLHrcwHcN8mIX\n", - "ixcvkkpZwBZHjtzJwsICD3z+86gDVvTF9U3Stk2l0caSWXwFVGJ6UYchS6JF0cDiO3wFZ+fnHb7f\n", - "54s8+eSVXsmPhttu6/NG/jEWI8eOHeT48fs5e3KJxtmnmfQ9xlWNSqfCS+cT3P22t/Hu2w9Re+I4\n", - "jt/CVjfxFEkiMUEUdZGyQ8H36cqIQqhiZlROdDzSwiQje7S5SBfBEBXS9Ngh5jwabYaIseigI3BQ\n", - "BvZTO9jUURADNpaGRo9V1lhHQTCBQZotWqgIJlEp0mUJj0UKOGgodDFpkGITEOhMIEkzhIGLww6b\n", - "1ACbPJMIugRUkXgYLNIFhExTU0zScos8LqpQ2FLAlwZ+ZNKJi0wxxRMXNuk2qqzqPv/XZz9Ly3Fw\n", - "o4ji0C6G8wfZabqcvLSKT5LY22D+5FmuLU8wV5tHs3vc8+v3MFYscml5mVarReYKWf1OTU0xOmqi\n", - "61nm5lZpNDpsbzcwjDZvf/tbqa+cZcJIcfbkMq0apFJJZs0OZ1/6IvsOX4/nvUg+P0EudyO6rlKp\n", - "v0Q7rKEaE0xMTuC5KfbtnqLRWOLixfN43iVgcaCAFIBBQESEgsooKgER3mDQngLW6SExyQATxCwx\n", - "hMYOu/G5CkEOiYvCJhodQkwCIuboDkS/UMWiSY6INlehkBxYXlZpsAwIUrTwsPDpEgzYgglianRZ\n", - "RDCDjUGbZSaoE9LDd2POLC4wNlxmvVOh0QvxFp4i7nnkBXRDCyuKyBgaW91NXrpgkC0OMzQ1jqK7\n", - "jExnGN1/jKY4QSpY466bD6NrGsK2WW+3CelHNUgpObe+zuE77/zFLEZ+GL5biACk03nq9Qznzp3n\n", - "2LHr2NioUC7fwi23mDz77JPU6yZSQhgu8K53/Y+vKSstFArkchr33/8I6fQEWbWAbyfQexG69DCA\n", - "yNDZrsdcvNhFlRZKPSJ0bZJ0CUmhMYWFSYeYkNP03fpSZNihhCDBBBHgsIOBoIZFiEDHJYPgEjZd\n", - "plikRxGHBB1CklSxkExg4aOyTZqQaSRl1EGlLTmFT4I2Gk0S2PTo0MEhxqeChU6OInkifBxGiNlF\n", - "xHrfVFpASZ8mFhUsVceXJuOKZDmMGfc3ccQGQhM0DZfIj9m4uI2eWOWGwzN86i//kjPHj/O2/fvZ\n", - "f9VVNDodnnvsCUxnB0NVidQaUdTGjSQpvYidyVDKZllZOc+NN06S/iEa8583PPAAXH017N59pVfy\n", - "o+G7JNbf/u0rvZKfPqanp7n99qv464/9ew6kRtk2NBy3ys3791CLIs5eukQml+ND/8v/zInjx1l9\n", - "5HnctkLkQ9zbwfMaeL0WGTvNdhwzokp0fZ0tYaLJBP0s6zUSAxVFX0NjDBxGxogwiQjRiNBYR2cD\n", - "nwwh4whsBEV6TNLhLLs4hySkgYlPmZiQmHkCdDbIIogZGfgSrdHDYZoJXAoD+rnAIoFPkU22KWJR\n", - "p889WGcGlxCTEgbr1PFFxB6jCAKmrATbocJLvkqKGWxNgVDBcxSyxiiW6nCoWMSIIp7f3OTphR1W\n", - "KltYmoUXBjihx8GpWerho9w82SNlGvixxvLaGuOlEkII5A9RQ/wsoes6v/Ebv8ynP/0Vrrkmw8mT\n", - "WwwPdzh69Aizs/t5/KVvI3e62PZuVNWgWBjDtos0ts/w4Q+/Hykj1tZiTpx4lFZLks+Pomp7MYwy\n", - "9/3yu9nY2OKhh56m0WgRhqvoepkgABhGUgW2gDYxTVz24OAhUEnhAS16GAiG6dEBQpLU2CaLJI9N\n", - "k5gOIVkC8ihcGuizEgiGsAnQaZCjgIlJCgcFiC97xmjkyNBmmh41iqxxNZI1AkqkWMKhiMMKz6GS\n", - "QSHAo8aUplMSKuk4xnYdDF1wIAubzbMY/hBeKKkGAetaTCA2yZkl6p0aHUeHikcm0+bw4SPYdptD\n", - "x3IEGzu8dOYMnVqNWr3Oo2trfZnv5iay02H02mu59U1v+rHP8c91MfKDUNUE7XZ/Vz46OkS1WqVU\n", - "Gueuu+6j2dwhjmPa7QxHjx593c8ZHR0ilTpDr7dML2qRUSRd00SLM6RSw2z0Wmh6jnptnnzsUVDy\n", - "uIpBN+6hMIYkgQ3kUNhCp04Ngw3GhIomISTHFhcYxmCIGI2YVSBGRxmkyfSdEjOs0yBiDYUUNntJ\n", - "0KGAQ0yaFA2ywCI6TdKASkQbBY8U0cCKp4dBmZAhosHFHtJCISCghCDCQEGhgyrBiC22vJBhoRMo\n", - "Ei2dptPcwQwjdusKG7rO1Ti41TPs9EzaS22Kk1lot5n2PLZPnWJ1Y4NarUax2+GwjDhHj1CLObz7\n", - "AGvNHTba62AXqTuL3DS5i3vv/cWzB/3Up+D977/Sq/jRcdtt8Od/fqVX8bPDzMw077rlCGPJJJ47\n", - "ytLcHA3XhTDk6TNnePuv/Rp33XMP1WaLc4+dIe6tkugF5BJ5diIfV9FI9toUp0aJpGQma9Btr0Cs\n", - "MaHBiiuJMKkSU0SjRIDFNpsohBwA7ME+dYMiDVwEPj4eGRQioIFBSIKADkNojJDu9yzwCJCsEHIb\n", - "F3mBGlWy2NjUaQ1sE/teFhGSLjESDRWDKhEBIdvsxicLbNOgQQ6NmPHIJZRN9hSTWHFEKYwZDVSk\n", - "1UNoaXqKy+5ykY1mBO4ShweufZcqO7hBi+r2C1iGSSGZpiALXFxZZW85x5htUUinCaKI48vLTE9M\n", - "kJuYeNUAwzcS4+Pj/PN//rssLCzw2GMaZ8+G7Nt3PVEUUm01SakFQKLr/duarpt4sUGlUkHTNFQ1\n", - "ZmZmFsdxSKcthoePcv78MoZh4rouQSBQ1ahvAKlOE0XzxPHT9IWfG/RVNRKVS6iMAjVyFOhgYBBh\n", - "UAM0fFYG3eoOZapk0DEQtNlihQI9/n/u3jxIsqu+8/2cu+fNPSuzKmvvru5W71paVtNqSa2WBAiJ\n", - "RWBsjMEMHgeGeW9msCN4EzMv3gvsF/PPi/fCjrEDvxgmsJmw5RUMGGywMMggI7S21K3uVu9dXXtV\n", - "7tvNm3c9749MtwEbAzK4JX3/qcrMupkn85y6+bvn910GDIMIikyhkUdQoYCHQ5aQLGkaQIxHRB4D\n", - "hRzQQZCgSJsKu+kyzBW2SNEjoMXBUUHbpYtDQKxZ9KOYvpCEmkbBdRFhyJ17pvj2pQ0GA52qMyCb\n", - "8FGNSSYz2zELKolykSPH7qXVusoHPnCc2dlZFEXh47/yK3QuXYJajdRgwF7bpmFZXG61ePjhh3nz\n", - "v9AG+jVVjARBg5mZ2wG4774jfOpTf4lhJEgmM2SzRVZXz3HzzfMUi0Ucx+HixYv0eg5TU5Ns3779\n", - "OnfE92PuvfetBIHPN8NVlOUNnG6brmczCPp0fJdB7EDYIyVKxFE0ktvmSGCjM5ReJRGkkSxjMmAd\n", - "KW0kaSpcYwyTMQxMQKfDBJKLgM3kyB11B4MRPWkYlrUM1DFxgM6IzAbnsNHYjs2Q3OfgE7CJQpcA\n", - "jYgJDNIEVJFIoIuPj4IzyrMxgIAMIT0kndBjTPhoekRCj+n6A7oxzKsGVQXQbKYT4wyimHqrTn1p\n", - "C+OoJAoCJLBYrXLy2WdZGB9nemyMtA775+ZZ3Wqy0t4kly5RnIo4uDvP9qNH+aUPf/g1R1zd3IQn\n", - "nhi2aV4r2L8fKhXY2oLvyJd73cA0TTCM6zLx+W3bqFarbNRq3DI+zi986EMoisLeffv4y8JTdNav\n", - "UGJA2xl2+mPNoh+02GjUccwCy12dAfP0tR5F08MMhuTYovQYEyY96ZAGBG0clvHZiaQ18knNMk+f\n", - "VS4woIdPjgSQYkAbSDOGQkyARIwypwR5FLoYJJEjq8IE6qh5amORIUbFJ0TSIULg08TGRaePAvgY\n", - "lHHpU6GCSkZTSJeT6EIwbZr0Y8m65+LqIBSVpu+jCkHX87h1csjXqjkOX19yCaJ9GMokupam2V/C\n", - "YZGcoVIqZmmrKm6jga6qVDsdrsUxP/POd96oqf8uGIbB7t27KRQKXLv2hwwGfSzLxijMsLmyzrhh\n", - "k81OEccx15pbpKduwnVdKpU6tdo4k5NDxU23u8na2lnm5kLOn/8GTzyxSBSl6PeX0LQpPG+DODaA\n", - "OYaFyAGGMt8OIT6SLTIoODSAGgY+Ov2R+nEShR45mkxRJiYcib9V0tTo4SNIE+NjouMTYWHRJiCJ\n", - "NzqPG0j0kdS7jYeHoIeBRTwK0lMwMYhI4KGgEqPSo4OOz6RmMBuHJKVBJpNhpd3mUrvNpKbh1Wvs\n", - "SgT0oya5cEAfm9W+zrV+n9LCAkeO3U8+n8d1O6yvb7Fv3z5eOHGCg+Uyqm2zfOoUU/k8Xr/PS8vL\n", - "OBcu8LlPfYq9+/YxOzv7iuf2VV2MrKycZ2JiG3Ecsbl5hR07Mmzfvh2AHTt28Au/8CY++9kvs7Tk\n", - "kkwmOHJkP29+8/2srKzwP//n5/G8DIpiEUWn2bkzy/ve925M02THjhmuXFlkbm4fb333v+dvvvQH\n", - "DE5+i0gushWsEakSQ1lAjSeR0iWIfaSUyGGANDEqCdUklAGGJjAZICKLVuSRIEaik8XCw8bFAWxU\n", - "Imximvg47EIlN7oaChDEIzNghQ5dmhTwMGnSAybJYxEgGEaSD70d+6wBLsO46TYCG40DhIQIYjQu\n", - "YlPBJEFIjxQSn4g+K+zExRaQS+VY6fdpRSGXhUo5lOzUc+iaMfRBGbjMZad47rmTTOyc4/TiIjcn\n", - "EhzSNLbrOlvtNjU1ZGpMJ5Ge4sn1JdLbxrj14GHufOMbuef48ddcIQJDx9V3vhP+lbLBfixQ1aHP\n", - "yLe/Dd/j0vy6wNzcHDKXY6s5jLlXVZXS+DjX+n3e9Mgj19fZ/v37mN5WJtHdR9FI4HsOU1HE5asn\n", - "afUM/qoZYKlpDGFiaRqlXIZutEXorTApbISnsR5HhJhE5LCwSLKGj49JEp0iCm1gjZtwOccifdLE\n", - "QJKYLgYhEfYoFkLFZsBQQSeok0CiUyJiCTHSYtTJkidARxv5mzhUAJcdCDKE1EhRYRIHDxVdibkl\n", - "m2bTcSgUizi1Gj3XJXBdmoGPK8YJ9KH/8rlWFyyPqXyKWrXO585coOfNk9fGGCjxkEKvz9Lrr7A7\n", - "3cYiw5333cfG+jqnr1zh9uPH+cWPfORfLSjvh0WpVOJnf/Z+Pve5x4miFONTJV7a2EBNSp66cp5K\n", - "z8UozrFtXKHZbDM9fQtx3KfRWEIIi8Ggy2Dg86u/+tM8+eQL7No1xtpakyiaQ0oTz1sCdjNskY0D\n", - "M4A3EhkMz+SwSYg/Ckr0EOxAx0Gwk5gzTBCi4hJf9+WFPC4VYmImR426mCwmOiERIT46a/SZREHi\n", - "EtG+LgHWsAlR8BAskiCPRkAVnZgDqMQEdCyDy0qCbXEEQuBoKknDwGk0KAFJw8DqOIR+jCsSGHaC\n", - "rTgiziS58+1vZ9v27dez3sLQI5kcyuwb1Sppw2B1c5PtExNUNjbwm00mDYOBYeBtbfE/fvM3+div\n", - "/Rq5XO4Vzemruhg5enScF198AVVVefObD3DnnW9AVYdy006nw7PPnsTzNHQ9jabFTE1NoGkaf/RH\n", - "XyKR2MPExD+oNy5dOsVTTz3D8ePHuO22W3jqqVMsLb2M7/uUZnew1d4kRZKHH34fX/nyoyxejOlL\n", - "iRNBjix9qqSJcdkEpomESoTPBhEyblGOE6yhU0WQGXGjAwwaKCToYKDRBdYwCNmGMios/r6JEwMO\n", - "dTzGUCghqLGBTZYUSVR0Auo0gQFjRIR4mNTpUqSOBA6iYKDTJKKDSp6ACpJnMUnREDpStkjQo6la\n", - "eFqGJcehXJim5IdUxXCRh90GMyJiIAQVKcg3+1xodLm0vs6YohCGIWEcoysKpThmTVW5943HUIFy\n", - "ez+/8vGPY5rmyDX3tQcphy2a3/mdGz2SHx1/zxt5PRYjmqbxrg98gM//wR+wePUqnWqV1XabXYcP\n", - "f5epnqqqbNtW5KkvnSXSMyiKpN/vE/YTRKGFL5IkrF0gmmTVmH6nh0iM42pbDAZ9CnGIQ4TCNgQ1\n", - "JAUEGgq7EdRRqGORRgEcBAkKmMSELGGiECMZ0EbHRtCgTURAGlhGISLJOBFVYuoM8MmSpk/IJXqj\n", - "NJOABjptJtAZwyJCYZwqPQI8MvgYErqDARfCkP6FyyTiiFbgUQlj1iWEwSX6ShE1tQuhRCQEfOX0\n", - "VY5kMlzrChJWmdCTSGIms1mEIqiKWUJRwQtDNppNGorC3L338nO/+Is/kjzzXwOVSoUXXzxNvd7m\n", - "+PHbyGbTCHE7X/jCGF/5ysv0BjohAmpttMQaTz/9ApnMrdxzzyQXLlzkxImzSKkjRJYvfOGrJJNZ\n", - "jh9/G5/+9KcwzRk6nReJ4w7Dr8c+YI9+WqP7fGxsMqiEBET4SNJ4bDEgABqYmITYBLTxEQxJrgGQ\n", - "QqAjUYlIU6WJjoJOTIEmAyJqGATU0XEI6NMlg0eCMdYYOrl26JAnoodFQAIFW0hcy2DvzAJOq04c\n", - "eghg5+6dBEKSrDVoBH2abkDGcynk8nihz6adZld5G2e6HnPzs5imiZSS9fUVrl19hq21BEtLZcbG\n", - "x1nxfVAU+r0ebrNJKZnkquOQTSTwVRXb93nhuee4/01vekXz+qr+xnjooTfx0EP/+I1JKXn00T+n\n", - "Wk0xPX0E3w+IY5/f+cQfsa38Gc6e3WDvoRKpVP76FVO5vJNnnjnD8ePHSKfTvPe9b+PjH/8Nrl4N\n", - "MM0smdQ8y1ee5TOf/r/ohxaOWyMMJ2kSEysrpKWLwGKNNoINlDhDQJ9sNGCfkUZoBrbvcTl2Rp3E\n", - "LjY9Igr0RhXtBml88ihsEVMgpkPMRTTWkECbBBo3AVUiJDEH2KRJBxWNLWbwSaGjISkQUiFmi2VC\n", - "tqGhjK60VEwCNHqYRNyHg1BDfGlQo09F2Ows7KQTBgy8TfC6KHqalDmD4uusxn0GskcY+IT5W/H1\n", - "DGOGRj+uklFt4qRGs91my/cpl8vcZBgMgoB+EPCG++9/1Z24flScODFM6b3nnhs9kh8dd90F/+W/\n", - "3OhR/ORQLpd574c+xP/3G7+B1DSO7tkD3S5/8Fu/xds/+EFmZmb4vd/7E9rtErff9/N0zj5Hb6OG\n", - "jEC1yjT9LVKJBSRZ/KBNY9AlIwR9v4MrA66FAxJoaAgiukgEAxbpU0CjjsslkuSIaOMTsYpKzCwx\n", - "DSJMFAT7FZvLcZsKEh0LcEZcAp+YGZo4wDp5YnYjqRIRkWGLDA4xEcHIWXmYidPBIkEEqNgopNCx\n", - "kNRdH0XJcjkaJxx0iUKfopLgWHE77X6Xmi9Z9C7ywLv/HcFA4W++/HncbgXVtpA+uNLAkApuv4Np\n", - "Wqhql32HDnDrm99MZvduds/Osnv3bnRdv7GT/j04f/48f/iHj+H7KZq1dRqbVymULD72v/8q09NF\n", - "gqCJouTI5XJkMrMoisezz57mllsmsKwsly6tMTGxH9NM0GicwzBSPP30V5ma8uh0Ful0qmjaDLAE\n", - "XGbYmhHAwqjUHPq9WChExDQI0MjhsQsoolAlpoVLhgo201hIegwt/Mdo08BkgpgNIgxiBEt0gRoJ\n", - "GmjAfiRtYtIwYoDATcSYI2cpQZ4mARvYJGkziaCFZMKy0KMOlhwQGhoyn6UZBVy+dJWUVGml8mgh\n", - "bMWCSr1Gw1Rxc0Um5/dyqxGxvPwEllXm6uVLdNZf5k23bCM4c4YvnjjBtsOHGWSzkE6zvrxMQkoq\n", - "gwFNTWMhmeRSGPJT8/OsXLoEr8di5PthdXWVlZUenmfx/PNPEIaSxsYJpmnRn7KYcFXWn/4rGtsP\n", - "sP/W4wghUBSVMPwHw5yTJ8+yfftd3HnnAs9++9uEWwpKcjft3gUmadGNq2jmTgzFRNUzDIIuNa+K\n", - "Zh9gMieQziUmuk1ysU0Yq4QyYsy06bkubbosozFBnwSLIwqaNiK2lVBoE3CNoensOguYpMmwjhxJ\n", - "BYfh0R5ZQNIhYA6FFAYWIRF9HAxMfJK0cKkQsIWCgkGPJBE9JAU8VCXGiwe4MkBTFDQRoSYMTCek\n", - "53t45gSeDahZ2qGPH6SoOD3M1BQ3H3of1Y3n0PQauIKNQcjsRJ6f//CHuXDyJHEQsNHtotfrTO7b\n", - "x9FjxwBoNps0m02y2exrzlvk937vteEt8k/h8GE4fRr6ffgeE9PXDZ76u79jQVFYuPVWVqtVXM+j\n", - "JCVf+bM/4+iDD7K5Kclm84i5m1jbXOPy0jJ+twaGh6tMoise/UEVLRZ0KdCTAWFUQ1MlbXbxEg1K\n", - "+BioeOhsYBExhY5OgEWdHlnW0dCYxqDBGhUc0hTp4vJCPMCnjxgVEwU8QCMiR8hFYjocpMduhuFn\n", - "Hk1qpElRwEEnIsRggwwWAwwC0vSosp0EEQX6hDiiTULmmRUaV8IiLlOMi1VyhGy2+2i6SS5RYkHz\n", - "2Vzf5Lbb7+bgHe8kii4yUcrxjSdeYHzibpxWmzDso+sNMok2t7/5/XzwIx/5vuZzNxphGPK5z30N\n", - "XZ9l6dRXmYgjZhNZNq6t8d/+z19j3VOZnDxGobD9+jFxHLG4uMhgsMhLLzlImULXdRqNa1iWg5Rp\n", - "er08V640gCmEKCKlTzK5HcdpIOUY0ENQJybEYIBBH4cNmkSEFBBMMAw3tNDIMkyWabGFgWSVPBGQ\n", - "o0uTNjlylIjo0eEUKn2SSALa17NnOsA2hvbkdSIiukxgEaCPdtMlOUyq9IdEZ6HgqpJACJKJBIbr\n", - "splMUk6ncZw+qmFT9QZYdpo40ljzJF7cQzFMbrrjrdxx9CFWV5/hl3/5HVy5cgWl9hwP3v1mEqN2\n", - "zXwc88yzz3Lsve/lbKnEU1euUFteZnZsjNlikUu+z+HDh/GDgHSh8Irn9zVZjPR6PVZW6tTrIbnc\n", - "NrqdNcZ8H1vaeD2XsVwOKzHGhWsv05zfS6FQplJZ4siRPdef48UXzzM+fpRqtYZXrZIzDEwtSy63\n", - "wN6SRrddo6Z2EIyjqwaqaeJo2wniFANf4gdF0rKDI2JCICkEXuCSQZCmQx9YwkJjkgAFkwEmkpDT\n", - "gIqFBzRQGEMnRMWiADTpo5MlYhiJpVBE5ykMeiObNY0xUkSkcPFQaZNngw7nsJkGIkxCQtrkaeMi\n", - "0WWMiqQoDJxowOMrL5JXFJQIrnXr9M0D2IkpdBucqIowBoyPTwFNjh47ztzcFCsr57j61F9RnCky\n", - "PT1NoVDg2TNnGMtmedcv/zI7d+4kjmO++Od/ztUXXiClKPTimNmDB3nbu951vQ/5aka7PbRVP3Pm\n", - "Ro/klcG24cABeO45uPfeGz2aHz+klJx7/nn2p1J88etfx3QcLCHoSElF15GpPFfOniQVPI3wXBoX\n", - "TzItBdKcxLINNhyHVb+F45vklR2YmgKKg6tGDEILRJq2GKMVr6KhA/NEDFBoEXMNkzWmcJhEIUKn\n", - "QReFKil8JiiwHZuzeGgsYDKGSRuDPjZLBFyjAowBeZSRa6sgS4jDGg0a9Ehh4TJNE9hGTB8fgywe\n", - "eWIsfBQEUSwxFIs+GgmpImMfW5ooqo0nPYSqkUumEGqI06xgGDoQY1lpjh3/GQwrxVNPPYPUVCK9\n", - "S2E2wcf+t/+Dt73tba/q9urm5iauq1FZPsWcUMhn8jiOQylVottYorJVpbRw7LuOURQVRcnywAOH\n", - "eeyxb7O+vs7Fiz62nWJ8vMzGxllmZ4/Sbp9ieVkjjhMMBhIhEkjZANbQ6KGwxDDcUNBDAOOEzAEh\n", - "khaMUtlDasARYIkYh00UKlwDemjchE4BiPBpMk6bBVwGpOkh2YGCNfJZnQB8ho2hYfZRgIGBgwQE\n", - "uqogoz5NJLfbBpO2hWuaXHYcrLk5/EqFpWoVp9OhFypYqRyTQcxWu4OUeTTyrPV9lJfOYpl5Dt6c\n", - "ZG5ujkvnznHz5OT1QgRAVRQmTJPa5ibv+8Vf5OF3vpP/97/+V1KtFlPFIvOTk+iaxvNrazxy5Aiv\n", - "FK/elffPIJ1Os7R0ienpR1BVDbe9yqSRRA0DXLfBvfce5sSJC5j9iKXFM/R6VQoFj6NHH6bRaGCa\n", - "JrquEccR7VYTW1UJ/QBQEcTYdpKpwhSVXhPbKKNrIZg6bgeUsEFaJtD1HLpVJBV06QZNDJEkBNqi\n", - "w5QMiQlYBTqUMLHIERDSwUchZpOdSGJUzhMSMiBJDhWXkCZdPPqYCHwEWxQpENBBJ4GBgYeDjmQo\n", - "/jJxEYRsjER/FkKEjMkG05pgm6KyFASUibEJWCTipjjGVtN0VQ0tSqBIFz/WyOay7Dh4iK3KEyws\n", - "ZHjggXuuQiResAAAIABJREFUm5Xt2XMYp1enqm7w1MoKoZRse+ABPvL2t19vzTz+1a9SO3GCu+fn\n", - "r/sSnDl9mq/bNg+/4x03arn80Pj0p+HBB+E1nOt3nTfyeixGhBAgBE8+/zyzYcj4d+y6Pb64yNN/\n", - "+zUyjYD98/t5efkct1kJGo0lOhEkRZpiELPkBShMEourhEqEqijkU3tp9Nr4gYKISghSRKwgh/oz\n", - "YprY1MjSZ/+IKt4hokuLLCEzDPleF+gyYJYyBQI8kugkKVAjAK6ywFCFZxCTIqaCQMUiRQobjSQW\n", - "0KVMRIVVPIKRHVqPLhUKCCIG6KpGP47pSYUwTqPi41IlGetkkhkkXbzIIzIEY5PTFItFXHeJRMKk\n", - "3W5z5Mhb2LPnEKdPP8bP/uz9PPTQQ68JU0JFUQhDH6e6ypRmc/bsRaJIRcqIINgiayvU65dIpQoo\n", - "ypBb2Os1SSZDDh06xOrqJidPutx22xEMI0m9fpVKpYmUm4ShpFAoIcQEtVoFGEdGGYx4kaLSpBAr\n", - "aDEsEyPZSURMjTaQQFUXgCWiqEJECnBR8FExSdPFJoVHDZ8AnzQuASU6HGCAgsIGIW3AJEYHSgz3\n", - "zMsMWSYdIEWTHhEpEkgkHdlj2oZ5I8VGFLEZS6JBTF/6yGCDUrvB4elp9EKBrWaXp50WL7oRiSAk\n", - "Fj1aIk06exfddo/Lp/+Cj/7Kb/3QZmW5XI5f+c//mb/44z+mV61yoV6nr6oce/e72bZt2yue3xtW\n", - "jAghHgJ+E6hJKX+kDr1t20xMpGm1LpLL7UAoGoNBh7Thk83mGS+VuO++DN88cRJ1KuLBt+xDVVU+\n", - "+ck/pNeTSBkgZY92+wyWVaIWx2QSFoNglVTSp5Qb41q2xHRKoed3GMsmObdUJQo9imLYMAl8HxcT\n", - "TemSFE2ENqDuu5QEZIhoyjQp0qPU3kl0THQmSNDHoMUOFK7ioNOjTUyODhYaOVwCOlQBlQQJDEyK\n", - "1FkmjQY4lJHECDooTGJRoYdglpgNptAZ17oUcikq/T6eYZDudChoGhuKgjqAXYrBQNHxlSQytlFj\n", - "n02tT6a0HT9oksslGB9Psr5+nsnJXSiKyubmIrl8xD13vglF09h/8OB3hWcFQcCZZ57hzpmZ64ta\n", - "CMHemRm+/dxz3PemN71qt38B4hg+8Qn4/d+/0SP5l+Guu+BTn7rRo/jJYXrXLi49/ji3fcfacwYD\n", - "JnI51jfX2ZGfZuD1aTYrTPVbzCVtrvXa6PgY0iYhBL42TsFMMJZNs96tY5vT9IMYqXTAh1huJ4hc\n", - "JCGCFDZlApZIsIiJiYNPnT4TwB6GgfOSmMsEvEQLwTjmdYGmwCZDF40ZQlzgBQwMMqiouHgYhHQJ\n", - "mEWSxEUVCiU5QLCEZAWJwEAlgaBAyErk0cBkS01jq0V0BareNcy4iuknSGVtBqLC8iBmu1Pjz/7o\n", - "NzDCGmrb4ut/sYSVK7H34Dz/4T+8jyNH3nBjJvIVoFwuk89rnHd7XK01sMwChqFSrS6haQkq9Sp2\n", - "ao1m8xKKYiNlhKK0ue++fUxMTLCx0aFcTuG6TaRUURQNKV2azXV03aTdXgEy+L7EMDxyuTHc1mnK\n", - "ukDxAX2MNBoyGqMtXDQRkUiMI0Qep3t5REwdZrmr+ORpM0cKgYWBRQ6fS6xjoTCPhoVCl5AaPg4K\n", - "F4iYAwyGbJU0wwgRGxgQk6SFTRsHha0YVGExME1EILHsMuXMOF3X5fz6BbbCJLJlYmohGSGwem22\n", - "ywy2PknOtOnELoveWWZnbuWm2TS9bheAXXv38sVvfpP5OEYd9aqjOGbT8ziyd+/1uRgfH+dDH/0o\n", - "q6urRFHE5OTkv3j3+0YH5d0CfP1HPTCVSrF//000myZLSycJlTodvcO+uZswtB66YRALQX7XAh/8\n", - "6P9Cu93mk5/8AuPjtzA7myGOI5aXz1GpPEexeBObbgNvEGAmVpgwbc6eeYmVfo8WGVJ2m2JBoG9l\n", - "MZwacVzHixMINAahQdMK6QiNbuiyTYObTZMVz0MLLCSSIoI6bVxMTExiuqQZUMGngkOZARXKLNLH\n", - "JCJWBF6skcEnxiMgS4NFIrKsY+KPIqRVdAwMksTsQuMcLaQQzFkppJ6gEzaQlsWLvo+tKHQTCRp9\n", - "lzmhoqBiyBhNU0gZGbx+lW7rOc6ePo+pxlgqeLWAg7c36bQvUBgrEjqblIkZnDqFF4Z8/plneON7\n", - "3sOBgwcBGAwGKFGE/j3bvJqqoo0efzUXI1/5CuRyQ3nsaxl33QW/9EvD4uq1yHv5Qbjtjjv4xqOP\n", - "stxokNQ0vCiiryjsu/VWzj7xBAcOLHDy5Dm6nQqh12MskWAqXcTFIhEVWO1UyJQmyVp5zDgg6LXo\n", - "OB3Q+mTtJJ1WBz8IAAeLARbTSDT6CDQKDHAQgAscIkZjWIwkUJgk5Bo9anQZw0CijKLvfCwitlA4\n", - "SxaP7agY6IQj2e8WO3DJ0GMSj7SUnBq9xjgxNwuBiqSiqCzGkpqUrIoBYRzh+VtAiKMmqWfT9IIN\n", - "tpXKNDo9ZjQF88LX0Ad9yjt3cv+xu0kmElze2KB4U+k1VYjAcGfk/e9/hG/97ddZba4xnVWp19dR\n", - "VYFqTyC1Iorik0qtMD6+gKpG7Nw5x/vf/y4cx0HT0uzYMclf//WXaTTaaBpYVowQZfr9NOXyIba2\n", - "zhHHAUJkCKIzmMmQji+Z1AtE0iMI+8TCIdAsdDR8v0scd4EtVHwENWw0InzG8dFwYRhfh0KfBRRa\n", - "I8lCm5A2CXzShHi0aeASYzLcQbvGcGdEMmzXmCM9V0KopKSgO/CoeB7jRpqc5lCrLXGq2yOKpila\n", - "ZUQgsc0ELweXGadGJIc7gcmETtFKIwYd6q0KCv/A85ibm2PPsWM888QTTIyKi03PY++xY9/lIbK1\n", - "tcU3H3uM5YsX0XSdg0eOcPfx4/+iguRGBuW1gFfkY28YBg88cJgvf/klHnjgbei6wfmXn+Lk81/h\n", - "zt1TnF1Zoamq3P/ud5PP5/nSl75KOr2DZHKYq6AoKtu2HUDKNm996yHuuGOKk9/+O0x3Jy9++ylq\n", - "ToCaznFTRmLqBeqxIDc2QaMRI6JrSPqARl4ZMGUotJNFcp7HrONgC0FCCPoiJJYJqtTxyeEMTycY\n", - "VDFo0EFhGpVpFM5TZZU820o7SRoCVTTpNNosuQYd6QEGJgY9GsxjIxDU0AkxUXGYwEBlQFvqtOIu\n", - "c3qJajxgdt822ktLyF6POyYmOLe8Sj0akFGG3H7NShMJyVakgjLHTeWD+J0u/WCZQrBBqllj++Q4\n", - "6bkc4ZU6h7b/AzFsbjDga5/9LAs7dmDbNqlUCjOXo9XrkfsOT4Ke6yJs+4ZlWvyw+O3fho9+9LWd\n", - "egtDw7Px8SGRdZQp+brCwsICe+68k7LrEvb75JNJJicnuby6St1xuHDiBGO6Tt4StH2F7YUs0jDA\n", - "U/BJUbQTuOmIZDpHs9HDVUDVNygUBJZZoN9dwXdXEGwQY+NSQQFUPNqY1HHIEiORmKgMiEaPS3QE\n", - "CTyq+AwwSKCxiYdHhSwabSaJGKfITnwCPOqo9EgyhuQqJcMmiAI6sU+AQl2mkWQ4icSkx5T0MGRE\n", - "AhiXAwytwmK4RaiMoWkLSDPiwZ+7F81rkbh0icOzs5w4c4apQo5Kvc63n3qK9zzyCHfl83zryhXa\n", - "7fYNd1XdGLk5ZzIZZr5jV/X7YXp6ml/+X/8tv/3//C4btU0UQ4V0iU0rw1T5FiYmAsbGYt7znuOU\n", - "y2VqtTqPPvp5NjdrfO1rj7O4GGAYU2SzB1GUBO32ORznGWx7H6a5HcsK6fcrgIrn9Zkay9HtGjSd\n", - "PgU9QugRA8VFF3ncvouMXRK2hRoKJlyHTQI8ioToVOkhaZGnj8UEfcCnxYCYAQpbjJOlyAALRQmp\n", - "xQla1Mhhj/ykHLI4ZID96OiqhhtJdEXjsozYiiMOmxp9YwwjWcBwOwykjZ6YJZfK0+5vYgYRMsqx\n", - "RZKcDql0Etu2kXGM4g3Ycs5z6eoYLz3/PDt37aJYLPLGt7yF3fv3c+ncOYQQHNmzh9nZ2etz02g0\n", - "+NNPfpI5ReH47Cx+GHLxiSf43MYG7/3gB1+f2TT/HO6++yiKovCNbzyP50kmJjUe/vWPUSyOoaoq\n", - "CwsL178ANzcbpNP/mAigaWnGxsa4++67+ZmfeRe/99//O51mB+dqjUrLxhnkySZVFjdfIm6dZr9S\n", - "IhQhUVxFU4sYcTCkldpJ9k9PU7lyZRgcFEXYUZ+rkU6faSLmEWSJcBhwkU0C5inSJsahS0gf8Dhf\n", - "fZmCHjFtmdSFoCuLROwGTAYkifkGm1xDZw6bCQQxkGUdly6baMxyKfJYaa0TGxahO85y0ET028iV\n", - "FTJC0EbBjHzaqMRBkqq3QTPMMD+7QK/bQhcOu0oFLE2l32wxnUzypS98gZ/7Hq2rbVmkw5Br166x\n", - "b98+hBAce8tb+JtHH2VXEDCWydDq9Thfr3P8ve+97g/znXAch263SyaTwb6B8o9z5+DUKfjiF2/Y\n", - "EH6seOAB+OpXX5/FiK7rvPGnf5qv/fEfM1cqkbFtFisVHj9zhvsOHaKzusqYrlPO5/nrlRonnQ12\n", - "TRSRqqCvZSlN3Uxm+zQvvvg0rbZPzBoiNnDdHSQSHgP/KpIEJjswmKFPiI+DAdSpkGZoCBigsUFE\n", - "WijoUjIYUV27QJ8KESZtYlRcdEpUSJAiDaRGcWuCkCwxAWkEQrVJW1m8IGLNc+kYM6S1eXzXIYhj\n", - "mtJjQ15hP4IxTCpEyNBlt1Doixr1sEmvpfKGN/wCf/foo9w+MYEEZBRhWRb5MKRVr7NRr7OtXMZQ\n", - "FFzXveHFyCc+8VmESCOlw+xsive//6d/YI7VwYMH+Km77+ellyp4Ax0zmWcmNUGrdZlyeQ5FCbEs\n", - "i6tXr/HlL5+iVNpDrSa5fDmF67bI5Qq02018/wJxDFKmyedLNJtX0PUypdJBms02Iu5jKBHluTQ9\n", - "R0V4A1r9HjoxbWcFgUk61cVKRPjtBlvoRMwRYY0a6SZ9lplggEMNgzwONj2SbDFAo0QbCw8TK/bQ\n", - "sYnYhzJqEPYJqLHKFA0UIrZFCqqqs4WkpmrMpSxUVcXzfHwlhV0uMW/Datui7jlM5fOYCRMlDKkP\n", - "dO7cXqLR7bHccYjdgKWoQTpr8fZjxyi2Wvzp7/4u//Y//kds22Zubo65ubl/8vM/8cwzjEcRs+Vh\n", - "krup6xycn+fpS5dYWVn5vsf9IPzEixEhxATwJ99z96aU8ud/0LG//uu/fv3348ePc/z48eu3FUXh\n", - "7ruPcuTIYVzXxbbtf/ILD2BmZoLFxTql0sx33R/HXfL5PDA0S1peXOTc0oDlLRtVvQlV0Wn2Wthu\n", - "n0ykMplP4idydLsVNqINXMPC1BPcfettGB50Wm1ObW6QBlAjOpGgTx6LBOCNiKYLhPTwyaCRZmuk\n", - "qhkDQhy0OKDqDyCUKNjYIqAvHWJq6Cj0yJMjj05IjpgO0CWBR5IMLilN0I4SyMQsh9/089wWRnz5\n", - "zz7N4uAis6KP48WciCSxopFQWnTtJKnkBHvnElSWq8znsyQNg6YbMfDqQ1l0FOENBv/oc1W+Jzxr\n", - "3/79mB/6EE89/jjn19Yolsu85R3vYPcoSnZzc5Nms4lt25w+fY5nnz3PcAPS5a67bv5By+Enhk98\n", - "Aj78YXgNCH5+KDz44NC07T/9pxs9kp8MDhw8SC6f5+Szz7JZq6GMj3Or63Js927WFhb4ypNPcbKR\n", - "RB87SiaRIDE3TrO7RBT0cHXJoLLB+PhdDAbPMzn5NsbHt3HlyjlWFk+gq5MookFCTiBRSQFdBApj\n", - "uKyxKGziyUl61cucCvsc1jTiIKCOwWWgQgLIkGWATohPkh55YvL0CBB0CMiPjK40Bqis4zIXOWw5\n", - "Dt1YUKWAaS0wVt7HpWuX2Bg0MYAk49haCy90KRCTI8STJtVIRSdL3434+Md+jXHdJy6OcdPUFE4Y\n", - "cmZ5HSEFFU3Q6XTo53KEhvGqkN3Pzx+9/vva2iW++MXHeP/7f+YHHDPP/v1lTp26imntxLIytFqL\n", - "ZDIe09MLbGycJY5jHn/8BHNzb6DVanPtWgPD2IaqxnjeFaQsEQQOk5M34TgauVyRIMgjhE+5nEeR\n", - "TaQXUEhPQXCeyYTghbUKIp4iY6m4YR1dlURBknY4QFBEVUqocQ6LkBwRAZKYMh5tCnRZo0cFHR8H\n", - "D4sEZQJUNCLS+PgUsEmTo0GEZBMdj0nW6dMCLhCTjQJ83SSbz3FbwcZQFBQvxhpLMTO/g8snz1Kc\n", - "3EW7uYGpSBqDAXFmGFbQCCMSts1Kd4O23wRD45ZdeymXSkwXi3SWlzl75gx3HD78z37+G9euMf1P\n", - "FLFpoF6vv3qLESnlFnDfKzn2O4uR7wdN075vJX327FmefvxxFi9d4qVLLfYcfJCdO/cQhgFra+fZ\n", - "u3eS8qi6A7i4WOHiSp8g3kZSzeC4IX23zkyokk9mGPhrpBJFLMMgKSfYsrPESYVqO8vTLy/i9ecJ\n", - "Q8GE3Sb2u7R8CxUb8BBCoEtJiE1Mmjo60EFhHOiRZJ0pbGyZouMPuCJ9dDQyWopmsEUXSZIJdDQ8\n", - "SmziUqdPlhiQWCSYEQp5TTChFPENj3rtGqZR4PDe21mr5lhc/AZG9ibGzBk8T6Gd0BgvBvSdJLqu\n", - "UsqmkXHM5XqbtfYmqVSbOxtNMuUym90us5OT1z+rge/TVpTvIrHC0KZ/x/dE3Xqexxc/8xk2zp0j\n", - "LQTPX7nGSjvH/W9+D7adJIpCvvGNUz/kqvjxotUaZtCcPXtDXv4ngvvvhw984PXtNzIzM8PMzPDi\n", - "4syZMzx/4QIA47kcsZrjnkP34AcR52pVZGaMhJFmotjm6N0H+NM//SZjYyUsSyMcmKxcXcYy0qS0\n", - "iLHSHi5efZFELJC4SCkYoBDSRhNZkmYBI59HeA36ffi61ydCIDHQSZDHIT+6NIhHDZ0t6mxiYlDE\n", - "ZAWFJn1y+Ag8IhQcYiVPWwoi4TNA0g8U/LaD40lisqQQuMScDqtkUChhkEDwImkEB7AVhYS8QKFr\n", - "kTElWbvPmTMv05Q24yQx4ogGGi+ceJlN3+fBf/NvXnWGZlNTOzl37lt0u91/dnfk7JkzNFevkOUC\n", - "5y49SXnhp9i37zYWFu7GdXvYtkc6nSaOE+i6wdZWFU3LYBgN4rhAHG8ipU0y+VOoaoBlFUgmu1Qq\n", - "AapqkEyGaOoKP7XvJtxWRLWdZPfCJC9cWEGGTRx1nqw1QxxbdLwaTnyKhDmJoqTw4pAUEh0DZZRW\n", - "cxWDDt6oGAWfcTRSeEgCfHIj0wdBFjnKLJKE+CiUyGJSZlxotGWfNUKmEhE/f2gfz1+8yN5ikfmi\n", - "RV9zWbryHH7Ywhqb4J77HuTCqdMMGlV0WiTSk7zcMwlaK5Riwbw9Qz5ncYtt85XHHuPQHXeQtm2q\n", - "6+s/cJ5ypRKdc+e+qx0PQ47TvyQ24EaqaW4H/m/ggBDiq8DbpZTej+v5Tzz3HE9+9rPsLZW4Zf9+\n", - "Fqwr/OWLn6HT2c/ERJGjR/fxxjcev/73UkqqTRepFlFRUBUNVVHp9TViqZJKW2TNCENXESJJ2++w\n", - "4ldA7uL8xQ2CcA6CASkrw5a/QuheQAgHTcZoI6+PFgmM0bLTGScgQZ9rZGiRRMPDx49dBArjSDps\n", - "4ofTRLjozKGwxt9fvBuM4SEwRtdtGRGRtDU0QxINVIz2gMc/9yjZ+TewdyxPLpVnIzHHrskHEIpK\n", - "y+1SHp8Dpcea9yT1oICm65y8sokfG0gGzBcO88WnN7jjjbtJb5vlxJUrTCSTDHyfzSji2Dvf+UMt\n", - "vicefxzn3DmOzs0RhCFPnVxijBznz5zl0OHDqKrG9PT+H9fU/0j49KfhoYdgFGj6ukAmA4cOwTe/\n", - "OXxvr3eMj4/TjmOklHT7faLIQNcMmr0me26+mf0jkvXy8hM88sjDLC93qFZU3GaPcjZC03W2GlV6\n", - "PQdL64IS0Y8CDDRUJDERCilUWoggprt2lQUl4tbJcVqVFi/3HHpolLDYpEOBGJ2AYZmSZpIkHTYJ\n", - "USmRQGGTkA0cfCQKCaZZQ2OLCoZeINJ6+LFko7qJKkooUqLjEbGFJ2boyBXKGLQIiJkkpaTwWWEa\n", - "A8vIEioWF2urmH5ITRkwSOSpi5hEJsdz61tsS2q8odlkMBhgWdYNnr1/gBACIXQ8z/u+xciT3/oW\n", - "f/Kb/w29HbDLymEk26yuPEN/foarV5+h01nh6NHb2djYIAwdpJSoqoqqKpRKeVZWqui6ghAaENPr\n", - "Ndi+fZyHH34rn/nMn9HprFIuT5KxDxJWWriDkFiEnFhaxQcCUSAvSpi6StsJUOIUsSwRyhAvrqKQ\n", - "JyZGkhyVqFCmjIHJGhWybGcHE7QIaNInIk9AlwQQUidDggBBFUiiozBMNtOUHHNGEW+wwmZvwF9f\n", - "ucL2nTs5vbaG1W4zZtus1+vouk4hVeHcS18gL3T27E6xY3IPL152afZNRC7NjmSefrUCccDLF69i\n", - "GwpP/u3fImybe36IoLtDR47w2RdeoOC6pEaihOVKBcbGrmfHvRLcSALrCeCV+cb+AARBwJOPPcZt\n", - "09PYo3+2W3buZG5ignO+z0c+9u//ka7ecRwymSwzC1NcvvgykVdAoGOkZ+lGL2NnNGYKY4yn08Rx\n", - "zLdWajR7GUr6HAkmCIMtGv2TtJUxpChDbKDKc8RcRbATl8SItrSORjC6rRCQxWQVjcQoUElHoT+i\n", - "MFXwZAtBhIaCjySLIGADwTQqGh2GHq2zaYtSNofXaRDikk8kGUQenbVNntnaYr4cM16YwfUcTDNJ\n", - "N46ZzpXwPIP5+THuvHOBP/j9L7Hp+ShSJ5ta4GpTsO/AHvwwyYOPPMLW1hZLly6RTia59+DB79pV\n", - "+n4Iw5CzzzzDG6amEEIw8P3/n7z3jpLsrO+8PzfXrZyrOufu6cmjGc1olCVLSEIJYQRIYGzABo7h\n", - "GHzswwafPcs67O5Ze/3ar9nX3jW28S4G2TIgRBCSXoRymjw9oSd093QOVV256lbduH/0MDBWQEia\n", - "GZA/f3XfvuGpfm4993ef5/f7fnE9hbZYnNMLC+cGRFW9+IOi46wt0fzDP1z0S19wbrkFHn30X08w\n", - "0rd9O/v27KE7FsN1W+TKRaqSxOjZwbHVMvD5JFKpFO3tIfY8/TLxgIAouuTLDfLlBqIcZWl1HJ/g\n", - "wxILCG4bVSxMDOJig3ZRBamGZlSQPIkps0RfIkuifpKq53ASHyniuPhoUUVCAgJnv9kNVE4hIRNB\n", - "QaXGPAFkrsCPgqeFENRuGlYLvzxJs3Yc3A5UKUTDNWmyTBQL0fNTRqR8VhTRw4/gAdQQPQlBUkEQ\n", - "8dQkdTGI6dSYCvSgq3Vu7B0iHYxg2YvMPPkkizMz3PfRj/7cmFk2GlUCAc4tnf9LLMviK//fXxGu\n", - "qWSyQ4iCSCTcRWjuOMvzLyJ0bSGTuYz5+QCnTx9lcXEKUYzT3t7N+PgcPT1ZisUjeJ5Eo1Gm2Zxj\n", - "eHiIO++8hUAgyOjoCFNTdZLJXvKUeOnAMYTmIrYrYjpxXDeEQ4SSKeFi4rguBg0E4nieD1kFy2xQ\n", - "c+vIiLhUkJlHQsTBxiJKlCAiIKMRwMZgmgYGKgZBGsh04BKgiYeCg0CeED5k16VluYTEIGVdo9BK\n", - "EpF1IuvXo1UqFJeXuXb9enpjMZ6fmuJMvc5H7r2XbDrN6fl5JFEkqHoYuRqRjm7mp45SX10ipJr0\n", - "t6eZsSx6IxFWx8eZnp5+xYz3T9LZ2cnN99/PDx9+GDGfx/Y8Il1d3HvvvW9JNO8XNoH19SiXy0it\n", - "1rlA5EfEQiGcmRls235FMKIoCn19XZhmjcHhIXK5FVw3gmmWaYZEoiNtJFIJ5qenmSoUmFKCpLJb\n", - "EQSJVukIemWGsJvGL0ao2y1aYgTV6UPiFE2KNPEjIOPHxSKDI8hY3pqXjEUTB406OrWzOn8JdCRq\n", - "eMI+bE9FPRtlN5BxKVOhjH22dMyHiVjXKVo1ghLIXp1mM0Fd1PApGjOlSeIJiOqD1ColZusVYp3D\n", - "NJtVqtVJPvKRW9m+fTN/93ffoqPzOlQ1gW23kCSLUgVaLY1SqcSGDRvYsOFnm8GwLAvPtlHPTgn7\n", - "fT40xcZyLCRBOCfRbxi1N9/hb5JHHoFEAnb9YlU4viFuuQU+9KFL3YqLx+3veQ972ts58OyzEBUp\n", - "tAx27b6FYDCI49jMzx/h9tu3I4oiV1yxlR9+42G0kMbJ2Zco1fxEAxHwp5hbmiIa8KhVC5TdNYkr\n", - "CZWU4Cck+Vl0qqRdiPuDOG6VQnWViiBiewkkwrRo4kPAQcOkgEPrrGVmgw00ieORESVedkVUKYMn\n", - "lKk7NrLXwC/FaTVOIzbniAsCAhM03SUQbfCCSF4ICwELldOih89t4VHEFZOYroQhemA6eHKT7sEB\n", - "DEPHwSWS3EZj7iC4ArZlEY+F2dTTw8uTk0xNTb1iWfVisrw8TSSSpFYrUatNcf/9N71m7t/c3Bz5\n", - "mRWGerYjCmsBlCTJtGX6eWLfM9y7/VdYXV1hZmaWaDRKINCL45yhVKqQydQ5der77NjRRTicJJc7\n", - "hSRlGRnZjm3XmJ1dIBotEQrZPPbYV3FdhXJrgVp1FVXZTsDfhS9kg2HgOHWqdhPXW1mrSpRVBKGF\n", - "LO/Cdc/gmIfxaNKBdTavz2WZICIyKgIWFjY+RAJIhLHJYWCTAmCGeSQMPHy4tJFCRcHxQPCgLrj0\n", - "dw5w5cYb2De3j01tYRq1GjeOjp7TBemMRsnn8yxMTdGWyRAJBHDdOYJ6G3NGnaXJQ6Qlhxouumtx\n", - "ZH4et7eXK667jlKzyZEDB143GAHYsHEjI+vWkcvlUBSFZDL5lu+Fd2Qw4vf7MQUB5yeEW2Atz0FQ\n", - "1VethdY0jWuv3Y7rTlKpGPh8FWy7SDCoctttn+amm65l/PBhWidO0JycpHJshYYpcHTyOKnG8pqP\n", - "o5ACyyQEeEIFBBmfl2KLUqdgVZkjRkiMkfPAIYeFh8oiFRSmsBGJIBPEpUGBBTwUdDFPxqmcVehr\n", - "o4CJSLDnAAAgAElEQVRDk24cXMJUUKijSQVygkXWKYPl4RNkVn1VJJ+fkL9EVhboXreZTCaDbXfg\n", - "98ep1QxE0cHvT3Hnnbfy3//7/8CyFAShCMiEQllcFxYXz7C62nrTGiG6rhNtayNXKpGKRpEliZ2j\n", - "nTz68nFMXwd+v596vczS0sXXYH+nlPO+Gtu2Qa0G4+Owbt1P3/8XHUmSuGL3bq7YvZuPmybf+c6j\n", - "7N8/RrXqw/MMbrhhM1deuSZV3d7ezlU71tGp6zz83MucnKsR0BQKtTzdfTeiqDqV6SPojWUkx6WJ\n", - "iiho5PFQXQWXFqZZJawKiI5EydVQiCEh4+GjQYW1NEYZyFPAogcPVRAICCJ5UWTaC+CQpuUmMD0J\n", - "oVWhZk/i2Q4BOvH7fNTNCglKbBZlxl2bIiZNr4Em25hKkqIlgLNChQCulMEvLqF6VVTJoLd3mH3H\n", - "j1GVM/hMh6AaI18r4xfqDAysLVtFRZGVpaVLGoysWycxOztOT0+cq69+z+s+BD3PwxQkziqin6Ns\n", - "1DFaKi+//BKy3ImmtVEqlbGsOS6/PM1v/dZ91Go1BEFgZSUHQH//x9F1nSNHjjI/v0Iq1c+3vnWK\n", - "RiNGW9sorivh801zOP8U8WQX6fQIhpFkdur7CE6Flr2E6yWxvTTYJQSniGk+juCtWSemkAggIuAR\n", - "R6GEjUMdQXFxbQfBa9HEwSOMQh2FDHOE0CigUSVKCZcALk1cVFwUWl6VitLkmr4t2LaJZSocmZpl\n", - "i08+7zkX8fmwVZX8ygoAqWiU3qzKgVOLVCUPs2XgFyVCfpF0uoOGZaGn0wSCQVquS7VSeUN9J8sy\n", - "bT+RR/hWeccGI0PbtnFs7142dncjnA1Mjs3Ps+Wm1468b7nlRgqFMpOTZTo6dtJqFenq8vMrv/IB\n", - "gsEg4XCYif37uWvzZv5heQ+61snkxEv47SqG4CIIFpZg4HkGOC0sxUfFbpGjgSSIKN4yq4JIyEvh\n", - "kx1WnBwt10bAR4F2woRxBQHLU9EYoMU0LSrUhXYUL0CRIhZBIshYNLAJUiOG7Qr4/X4a5gRR28QS\n", - "JOxGk1ggyUAsg1ETiUQ6+NVfvYtHH32GfH6aVCpEMOhxzz2/jOu6PPLI8whCB9WqTaNRQJZnSKe3\n", - "YRgFfL4Q7W8hqeL6d7+bh770JZqmSTISIRYM0N4l4sZl5uefIRr1c9991/Hf/tubvsTPzLFja1oc\n", - "99578a55MRFFuPtueOihd7aT76uhqirvfe+d3HRThWq1evYt+cdu0plMhnhfHywvs2VwkIAvSDSU\n", - "4IXj+yjYfswypHxd6IpLSDAZK05StHUEJ0laCDHnrbIeE9u0kYU6qqiw4AokRQ3FTXIGcCihUcfF\n", - "JoZHRBCY8TzOeC66oKJJXWhqG81WC1FI4Ylhms5+IoSQZQWfX8K2HUpOC79bYNXVgBRBKUgy0UXF\n", - "mKfpyrSkLIK8QtRfx5I8ym6BsJ5kvF7GN7qJLi/F7JkFrNoCfTGT7dt3kUqtvYM3XJfgJdb/uffe\n", - "u9/wvu3t7YTaskwVFulPrC37uq7LVH4eR5Lw+0fR9bUlHkUJUirBsWNjpFKpc5/5X8qV79q1Vjky\n", - "Pz/P/v0TxOM3IUkqMzP7WV1dxXF8LC7+EFVVUZQI4fggq6uHcc04shzGbjYRhCiu6yIKIhJ1TAwM\n", - "5ugUQ5guWJikxDrzgs2KNA+eH8+2sVEQ0NgsqEgSzDsKmhenjokPsGgwjYOPIi0kDMHH6ODl1Iw6\n", - "e06cBH+C47MmNTlHfzCIfnb2udZs0jMywplqlVypRMDnY6Azxbw5Q93UqJotCs06gi5haxrb+/tZ\n", - "chxKtRpLlQobb3hT9SZvmXdkMAJw87vfzfcsi+cOH8YvCNQ8j5Hdu7n6dUw7/H4/H/vY/Rw6dIiH\n", - "H36McrnByorL17/+He6442aOjo3RWFnhqakpWpUljqwsIVotooqM5RSZs0+QUWPEdY0zpRqCm6ND\n", - "rJMRFKoYBIQWeHOoUgvJ8+jyGkwRwEZGIkqLBC0sErKOhEDJ9pDpolfppeE4GI6NiIuOQQUJER1N\n", - "kFGkNF5zFRudFCbtno4iyUyXpnmyukxy6Cpq1VUeeeAB4pqG59aIRGXu+7VfIxgM8m8//wUaJR2z\n", - "IaCqfhzPo9VSWVp6DE2rc999X3jTQjYAfX19vP83f5OXnnmGI3NzxLu7+fT999Pb24tlWSiK8pbO\n", - "/2Z4p5Xzvhr33AO/93v/+oKRHxEOh19VbM8wDEYvu4wffPvbVG2D6dUl8pbA0NbLefbZZ7GaUST7\n", - "DAGWCRgGo5Qos0LRK6BKfiSnwZxlEBRk8EwKnownWhiiwrJr4+EjgZ8QLikC1CjTxGSLILPXc1j2\n", - "NCJikJyZx3aC+OVJZKlJzVJwaCI4AnKlSY+qUHLCTJnLOHQyEE0S8vmZbTj4tS4CwhlQQwz3p1ld\n", - "3ccV3VFyjTCTlkxOSOLV44BHNOGnQYu7brueznQagJViESMQYGho6IL3g23bnD59mqWlFeLxKMPD\n", - "w28qcdbn8/ErH/8QX/rLr1HIzRJSNEqmgZmMEm/JVCotisUFqtUahmFjGAUSiTzj4+Os+ynTg4uL\n", - "i1iWjqoGOXjg69RXLcJSjIzSS7G1RNM4Rm/vjayspKjXI4RCHfj9QXJLE7SMSWAIGxFZENC8BKro\n", - "oIpzJBQRyzTwISAFAiiKi11cQBNlLMFl0VHRvQEkx0LxCjjkSVMjwpqQno8mqwjUEPEkj1pxjj2r\n", - "kGq/glBUYnTdNTz96Dd54OA4dw53U7Nt5GSSVCJBx8AAB/N5tFaLkcsv548++1n+zxe/yPZYDFEU\n", - "2b9nD/byMmFVZaJSYWJpCbWn55yq9utRLBZ57sknOXHgwDkF1iuvueYtJUS/Y4MRTdO45/3vp3jz\n", - "zVQqFWKxGLqus3//AfbtO4bnwfbto2zbtvW8/JFGo8EjjzyHJI2wceOaUNrs7Ax/8zf/SDV/hurx\n", - "42zOZEhGgiwf28OKa1FHJiSZrJMXcUQPn5JGlPL0i2VUUcJAQpZlehyHk6JH2h9AsE1ynozYLCJ4\n", - "NgJ5WthonoYlO3jiMrpbxCZFwamjCTquJCKTIeceRfHCxAU/eNC0LaIU8XAJiBqOZ9GwTARBRVU1\n", - "WrbOnqeeZ/1tO9i5czuCIHBmaYlvfOUruKLI6b3jXNE7xNGpZcqtCi1BJxBOYJoTXHXVRq688srX\n", - "+je/YTo6OnjvBz/4iu2XwqCrVFpz5z127KJf+qJy3XVw+jTMz/9im/+9nRw6dJhvfOMJHCeE53XR\n", - "CAhcdkMnjUaASKST6GGFyaWn6cNgJBDCcBu0AQtNnZJnsOgK6B4k0NHRaXkFMiLkhDPIOAhiiKxb\n", - "IYpJEBk/Kroos+ou0VRkkqJOXoviuQrN+hxpigRsCdHWSOJSFAQCwgAy4FkWgmCi4Mcva7hOi7zh\n", - "IXopQv4MueYkQquGXQ6SUdpICE3i4TBOocbU0lHimTXtHlGssH77Zk5bFouzszieh5JI8Msf/OAF\n", - "r6ap1Wp8+cv/xOKijSxHsO1ThMPP8NGPvrkpyXe965eIREI88shTFAoVtnakGR3t5Q/+4EtMTh6j\n", - "WhWwbdB1j46OBH5/lq985Tt87nPJ181rSCQSaJrAwsIhGrlVuoPrcd0WVamKT2pSyE1zUvoGiuJD\n", - "0xwymSzlpTEGfAVyVnjNpJU1F3cLh6gSp+osM6xCXlA5JYCs++gPhahaNp0olOs1PFqMM4foyaRp\n", - "kqFONy6zrHnSpIE2PAzBpSB5nK5UcGWXYu4IKhEqqzI33vF+9r30IPtlkZ6uLlaBernMxsVFQqJI\n", - "yXEIRSLYtk0L+D/f+Q6jfX0MrVuH1dnJ3kOHaCQSbLjjDnbs3PlTl+RrtRoP/PVfE280uLqtDdtx\n", - "OPXkkyxMT3P/xz72phOi37HByI+IxWLEYjEcx+ErX3mQvXuXsCwNy3I4ePBJdu48wa/92n3nsoDH\n", - "xo5Srwfp7v6xQFo63cPY2CQsTtETDBLVdeZrNa7OJIgtLzNrNRGAq3w+5s1FFuw8eqBFueXguJAM\n", - "h1GsIFXDIRSQmNZihFoeirnCFskhTJ0loUDBFci7NTJug17dR84GlBanzCWc0DpSup+looNpCKQQ\n", - "kbHWhKeFIllPxMCjiUZQ9ai7CrqcJOxVOTM/SVtkkH9+6hQ+ReaGy7aSjkbZu38/puuSjkRIhrM0\n", - "GgaFikm+XsaVRWKxEJ/5zEeYmpqi0WiQSqXo6Oi46LMYbzd/+7fw7nfD27jc+XOJosDtt68t1Xz6\n", - "05e6NW8e13WZmJjg5MlJNE1lw4Z1b2itutFo8O1vf5v9z7+MTxVZt3kzew/O0dt7DZq2NuA2myOs\n", - "rOzjwx++juXlVSQ28tw3jzNQdRgMa5TLAcYLLSaaBqIQouiGKNHGiuAhMEW7LLLJpxOyWrS8Gep2\n", - "kAAmDgoIEoqiIAkKMSFIuL2HhlGlC5lKfYWUmKPD8eOTY+RtgxVMskCJHBF/G5WmQcFaJq7rOIJG\n", - "WrAYrxu4apRWy0BWQPH5kIGKKVCSZEYHBmhJNWRkRq++Ap8vQCAQYWbmMNfduZY3Jssy2Wz2onyP\n", - "H3/8SXI5Hz09I+e25fPzfP3r33tT5xMEgSuu2MWuXTuxLAuAP/7j/8nIyGXMzLjMzxsoSgDHqSPL\n", - "BsPDI8hyB3v2HOC22167eLOzs5OtW7v43sPPobk+LMtgoTKFS5L25AiVVgPTzJNINOnq6qFaWSZh\n", - "rhLS4tRaAuCheiC54Cgqc3aVpCJyShUpyCK93d1MlcucMU0c16HatCh4GiYZNPzIeFSpotEgg4MK\n", - "9EoSDc+jXRSZ8gALqq6N6koEzBY7+npxTYv548fZuHUXn/zk7aiqykNf/jLDkQiyKJKMRGjzPL70\n", - "//wZWC6Xd7ezPp1m8cQJjhw9StfGjQzdfjt3f/CDhMPhN1QNc/jQIQKVCoNnxc1kSXpbEqLf8cHI\n", - "j5iYmOCpp8ZZWvIjij4kyYdpmiws7GHnzi1s3rz2FrG4mEPXo684vtk06ZQVol1dnJmdpVGrgePQ\n", - "FgxStixCioKiKPgNA9dxsFebZG2XsGfSrFqURYWaGMbzdDLdl7E8/gxdZole2aXpiZTtEk00/NTQ\n", - "LVgtzaCLoEt+2j2LGbOIP92P4izgNnKAg+cV0YUScU/AxkPFBlEC0SMaSJGvV3G1GNn0FtqCHTRa\n", - "Fb794hjFmsFSwWZiLo8om6QifjS1wvDQAKVyidxqibzc4tY7ruWpp/ZSLsusKaVW2LAhy7333v1z\n", - "J5j0RvlROe/XvnapW3JxeM971tRYf1GDEcdxePDBhzh0aBldz+A4Nk88cZg779zF7t1XvOZxy8vL\n", - "/NvP/yGLp0okAwmgyr4f/g0EUnR3/3imz+cLIAhparUGt912M1deuZOpIwep7dvHZKHAC0tL6KbJ\n", - "KCotTAqUyQsSVUYRlSCu7wRlp0zdamGrYFFHkCDiediux4xlEhE1JMFkpVqg0DIYjmWZLs+TdDxC\n", - "kobrNUnhguix6oKnFNCT3RRzUwxQxpQEZj2LOVsBSaVuN/GaC6TiATraB9nY2cXi6hjXXz/C4vQ8\n", - "PjWI32ohSQrB4NpYpmkR8vkSO3bsuNBddg7btjlw4CRtbVedtz2Z7GBm5sxbOrcgCKiqyuTkJIah\n", - "snPnDeRy/4wgtFBVH7Zdp9lcYuPGOzHNJvPzK697PkVR+MQnPsjY3hdZLFdpuSKiHCMRypLOpJGL\n", - "y3Su62HdugShUJXHHv4Bop2jUl7BcGUC2hA+LYZZXUJWJep2kyhNbEuhAew/PUGH6xGXVfKGhYtL\n", - "1VXQULFxkGgioFAiRYV5ZEBxXRygAVTwEZAyqIJNNpKk6cocnphn52gfaddmevIww8O/zdNPP82+\n", - "l45zyt8FqBQrR6k0DJqVGgMBP0tulXhc5aZbbyVXLHLKdYmn03z5z/4Mz/PoW7+e6971rtdV552b\n", - "mCD1KjowUUlieXHxTQcjPx8F5heBI0fGmZysEYn0EI2mCYXiJBK9VCohHn/8qXP7ZbNJms3yK473\n", - "PAs1oLNl+3YGd+1Cy2apKArxnh6uvOEGIl1diJEIq4qCT1UZFUR2KBob9QBbfD5GdR+q2KCqSPj9\n", - "ZfyhJiG1SUiGVX+GdGA9cUWlXW6iUSKKQFKwkew8XbpDlCUW5scwGpOEaSIzTYscsufhYGHjskSD\n", - "kOaiqhKm52FKftx4G/FUH4ZpIUsqlTo8O1YnFd1KMDJCJLwFjyjzuQPkK7OIigdanf4BBdO0WVrS\n", - "UZQ20ul+uruvYGysxIsvvnwxu+5t5Xvfg1TqnVnO+2rcdhvs2wdLS5e6JW+OY8eOcfBgjt7enWSz\n", - "vXR0DNLRsZPvfvdFisXiqx7jeR5///cPsjID2/q20ZPppSezHlHowcyvMDM5dt7+iuKjXjcAiEQi\n", - "fOrznye4fj3jhkFQEFivKGiCRBKXQSz6vTyydwRVDNOww7TFY4gBP7uGBhjSbOKuQKcaJStqdHgW\n", - "OSfHtG2xZJkk41kk16ZHVfHJCmHNJRmS0FWbrE8mEBDRNJdaawbPauBTfPjlFlV7BkPWCIeTiNIy\n", - "jrBEIDlIIBxkenmcgU6dbDxOJBLAaNZoAH7/jx8Yplkhnb648u+e5+G6LoLwao+Zt2dWxnEcQELX\n", - "g1x11S10dibp7AzT3z9Ib+8IPp+fer1Ie3vqp55reHiY3/l3n6Wt00XUG6RTGTKZDKbdwqbC5s0b\n", - "sW2NWCxMui2KL6AQC0fpCPrXtJ9Ui0gmQUUu0xkss7GjnRU9woobQrV0goqffn+UYclPxRFJoJ71\n", - "O8rTRpU+ysi0WEagDuQ9DweY90REOY4puIS0EJY9g6J4lKoWp86cZrV0iu6Ujud5fPvhH6KI/bTF\n", - "h0hFOshXNEq1bkTLIh5IkEz0UCx65POrDPX1MTM2xvJLL3FVWxvXdnTgnTrFA1/6EvV6/TX/T9Fk\n", - "kuqr2IMYbzEh+l9NMFKplLDtNaOhn0TT/MzOLp77fePG9fh8ZfL5NVncVqvFsWMH8PlakExSMww6\n", - "OjrYdfXV6O0dHMrnScRi3Hj99YzLMg3ANk16FAVLlLEkAQnQLAOfIiAFVNraEvSNbkJJpij5NUwp\n", - "TjqepqezF0d0iKESU5OoUoiMpiJbBVp2Dr9YJugJBNUsjrQenT5aZMkRZJUqiiIzicAZCWbFOlOS\n", - "QnLgl8hk2zHwKNWWcR0BSUyyUCySHRjAF08QD/WTigbZvUGjI1WgZ0Dg1tuv5bkn9pMfn2Tq5Zd5\n", - "7tFHmTh9mra2YZ5//tJIt78d/Kic918Lug533QX/9E+XuiVvjoMHx4lGu85bUlAUFYgzOTl5btvK\n", - "ygovvPAiL7zwIidOnGBiYoWUHj2nRwHQme6h2rBYnZ847xqGsUJ//4/9NLZt24YTj+MoCt3hMC1F\n", - "IeK5hNAIoZNFIEaNZnORZtNhxnTIdHezalms01VcSWLOXKbpVZBkE0nyqKlBiqaN0PIzV2hRbRi0\n", - "RA9FElEkiXA4jOZTKIgCDWWQmtEBwhAnhGGWfBm2do4ymIDBXpltGzq4/c6bCATqiPoCgWiJZFhj\n", - "YmGBQCTCXGMeLdWFpq09oFZWZgmFGoyOXtwab0VRWLeuh1xu9rztlUqBWOztmVnt7OxElmu0WgaZ\n", - "TIZoNEyl4lAs5kinM5TLeVx3kcsv3/aGznftdddxxwfuoLPNw7AXKNbOUGvOsn7zANPTC+zZc4jv\n", - "f/8AM4sBliyBrp5NbF+3i6uG1hH35YikDdb1+Pj0Rz6A178VLXs1CWUDQXk9C1YHh1s2juASxaOO\n", - "hY8Gw/gJoBFBZYS1Sk8HeAmYkiQKsoKryEwLIqFID5lgCNGdorS6h/LiM8SNU3hOi/n5eQQxjqP4\n", - "8TyXSqOI64aIBNpYrZvooTW17FAoyczMEktLS9i1GqNdXciShCiK9GazBKtVxg699hi/+bLLWDBN\n", - "aoZxbttKsUjjLSZE/6tZphkc7AeewLabyPJa0pZtt3DdFTo6hlhcXKTZbJLNZvn4x+/lW996jH37\n", - "XuL48QlCoQhDQ+tYqOd47NRpwrbN+LFJCq4G3Tv5/vF5Ojvq3PbJT7Lvu9/l1L59+CUJ2RZQZB+u\n", - "6yK1mtgti0zAYYO0xHKwyfGwD12XaBZElho1zpTPoLaqOGjgykiSREAJU7Nz6IqOKEepmkV8Sh+i\n", - "oFF28yheiwBB6oTpD0HW7+egaVFRk9S8MNPTOSxLIJTQMAMS83MOYU0itW4dA0ND1Ot1Du/ZS27B\n", - "oCZAqLedd73rXXzna18jrQboiq+9TTmuw5kjRwiGgryNqv0XlWPH4MiRd24572tx333w+7//zgrC\n", - "PM87F6A8+eTTPPbYfiRp7e23Wp1ieTlHkPMTFsORMIoKC8vT7NvzIqpPQ5abbN4cZ3Bw8Nx+siyT\n", - "SiQopdNrwlG2jSYIeB4ICFiALPiABVooCAp88oMf5J8efRSjUMI66+YrKRqyoBH1XFxJW7OPlxug\n", - "S6yik3IsZqwmOi7JZIKj5TpFIc5gdgil0UBKaUiui22VqNsm3aE0VU+ja3CQoB4holdx6scJRHRO\n", - "jo3RbDYpaxrXfuCX8QQ/MzPPAh59fSnuuuv9b1or6K1w66038Nd//Y/MztYJBhPU62VgmY9+9G5+\n", - "93ff+vl1Xefuu6/nwQefZG7OZHV1lVxuDttewvPS6Hqez33uN86V9v40fD4fH/v0p+lbt44v/vn/\n", - "RhQCjGzaRrlcZ2pqhVBIBkL09W3hpeUF9uUX6QkHcRGoqiE2b7uBxaPfJ1c1cOmgXl7EatpIrohi\n", - "B1iwSkSFNddmEwNVCGFKIj4bRAEaNMgoCqueR9h1KYVC6KrO0YpKtnMzkXSW6uwsXUqUTLTB7aNZ\n", - "8o5Dxbb54z/6Iw48M0az7jKuhBjsGcFyLGzXwgm10RDs8z7rsakp0tnsK8RBk8EgS7PnB5A/STab\n", - "5ZYPf5j//xvfQMnncTwPNZnklz/wgbd0j11Kb5pPAB89++v/63neBV3F37p1K+vXp5md3YsgxAEB\n", - "UayQTvtYWVnhi1/8OqKoIooN3vWuXbzvfbczMbHAHXf8KtHo2o3cahlMTT3DyeIS7dd8mMuyveh6\n", - "EM/zmJraw8bNm6ksLCCbJrUTJ+gWBIxqg0qtznytSk6A0VKAsf1HEMwmctVgT6NKob6KRI12ycUv\n", - "RFn2DAyrguwJLDgqrhal2bTwZBfT9VDxk/D5MZwqcbdFTHCYlZIMbWvHKrcY8YK0X/te5ucnOH58\n", - "hUKhyi/90i4CgW5++MNFrrzmKrq7+5BlmUgkwrYrdlAsetzzG/fR1tbG0aNH6VBVlnwmlm2iyCqS\n", - "KBFTVcaP7uN9H9h+IbvqgvEXfwGf+hRcggKeS8pNN8FHPgKTk9Dff6lb87Oxdes6jh59jlgscy74\n", - "sCwTQSjS19fH3Nwcjz12kK6u3UiSfPbv/Rw+/EWago+4oRPS19wC86VlFNWkM+pgzz9J03WJtsfY\n", - "vv23ztMemp6e5sTJaYpFA8MUWXVEgoCDQQuROQQUSUYVPFSfy46+Pvy6zs5t29izWsItLqN4YQRb\n", - "wfJa5CWXulWkUzIZUVXaMx0cyi1wurSCjkssm+Sg52EmYwz7RhGQ8XSd9UNDVOt1Tk02Wa0u48kp\n", - "9HgcuVQiUK/jlmYJ1aZp87Ks272bTDZLo9XiSD7PJz7/eSzLQhCE1/R5mZ+f59jhw7QMg4HRUYaG\n", - "ht6SnPerkUwm+cxnPsKhQ4eZnl4ik8mybdvr5yT8rGzbthXLMvnjP/7fDA93c+21W0gm23Bdl2Lx\n", - "6M/8gAwEAgwMDbFt5xb27j3Fiy9+l/n5eYLBLO3tG1lYOIGqTpFt20SxaGB1D2PbBu7cXvLHX6Be\n", - "XuaJFxq4jCDLYVpKFctoYjlrZnhNsYghiLiegeq1aHpNZKGJKjbJSiZeKERvOMxyocBkPM6Oa65h\n", - "2PLT1X0l42MnmTtxnJpTIK2u8NTJHNuuuIKVqSlqp0/TbfnwSR3kygX2H3oGIdaNqgXpH76MfMCg\n", - "VljEreTI9MUIdnXRb5qv+Pxlw6D9pyiqjo6OMvj5z7O0tPS2JURfypmRRz3P+1/CmmPRi8AFDUaC\n", - "wSCf+tR9PPDA41SrApKkoGl+FhdPoKpXU6/XmZ2dBjwmJx/k5psvQ9O6zgUiAJqmYxgBTFOnr2/j\n", - "ue2CIBCL9XLo0EluuOsu8gsLLC8tYRSLuFaTBaPKjCTSFYqTcmHl9CQrgsRQxxChlonjjxNuFmlX\n", - "MxRsky5bouyWcAUZPwpN28JwDDZlk5xZqFE2GriuREt0kRSJGhJdPRHWDQ2yON3ARSSRSDI0tJGe\n", - "nqMcOLCHqakfEA4H6Ozs4Omnf0Ak0smOHVuIx0Pkcke57753n7N+bjWbBBSFazb38IP9x9HVDjTF\n", - "R7m2jKcYXHfdZy5kV10QikV44AE4fvxSt+Tioyhrs0EPPAD//t9f6tb8bKxfv56tW09y6NBL6HoW\n", - "x7Gw7WXuvHM3sViMvXsPoKqZc4EIrC3jbNq0m/n5MU4X51ELIo5Vo9SYZNtQNx+++WYM00SVZUzb\n", - "5smHHmJkZARN06hWq3z5yw/ROXILS6fnwecw1Vqkho0CFAQbCz+K2CTb0UM65K4JFZomiqpypC7i\n", - "ihohDxRJY8FzKJh5BgTQXY+juVkqjkl/KErBtQlv28Bd77mdyRdeYDCZ5FtPTlMteMwtl3iqepK2\n", - "dIy+vm7C5SKOpKL7ddx8gVPVAvX6QXb1ZeiJRDg1NkZ7RwfRUIhgocDk5OTrWje88PzzvPyd79Cm\n", - "aWiyzFN79nBwZIT3fehDb3tyeigU4uqrr+Lqq9/W057HykqBTZtuIJvtPW97pZJmfPwk6bP6Km+E\n", - "2dlZvvKVR0mnr+Z977uNEyf28sADD6Lr28hkRpBlHxMTM+h6DEmaxTCSrJx+nkR9mZAXYNe2LTy+\n", - "/wjLS2fo7bmMnKLQqJbwATY1pt0GBSQk0UdalvCLJlqriAaYop+phoffdXD8EX79c5/jU5/5DDDO\n", - "AD4AACAASURBVLlcjv/xF/+TyuKztEWL7MgG0ZVBBGDi1Cnq8/N0uiK+dJalskFbOEWtOM9kYZpg\n", - "uo5SW0exoaDG/Wy+cRcf+tC9dHZ28nd//ucsrq7SdjY4LFQq5IBbt/30ZS1FUeh6A8Z6b5RLaZQ3\n", - "ffZHB7Bfb9+3i8su20ZnZwdHjx6n0Wji88k88ojA6dMnqVaDhELrcV2H2dnjfPWrD7N79/tfcQ5R\n", - "VGm1XtlcSZKwLIsNGzcS/jf/hicefZS9zz3HgeefRwsmCRUKXBcMI9gOAUEjJcJ07gym45Lwp0nj\n", - "ogk1fDJMenUyePjdFnO1OeYFkWu3bCLeJmEToTq9zEqrDoJI0/ORjSts6PUT9fs50SzQimdJJNoQ\n", - "RYnBwS2EQjHGxh5l06a7iESSzMyc4MiRQzzxxNe4+ebtfOhDt7Nx448Hro7OTvZ4Hld0dxMNBhib\n", - "WqBaX6E9Y3D7r3/0bX2ruVj87d/CHXfAG/D2e0dy333wm7/5ixeMSJLE+99/Dzt2THLq1BSqqrB+\n", - "/XXnSnsty0YUXzmMxeNZrrqqnXg8yrFjp0gmI8yeHCfbavHVH7xEzQCwWd+bwBf2Mzs7y+DgIMeO\n", - "Hce2YwyPrOfwoZeYrY7TbAlMt3IEXJOI4MMviOSxSHgFbr7ylxhfWWF/pcLhyQVGrrqXZ595mtLq\n", - "BCFcTLvBRlza8WgKMqOpTqZdh0osTbvu57q7bsMsFrlu3Tqa9TrF1TP4fNvozoaYWF1hueQxufgS\n", - "1+xI42+P8MQj3yOjRulKxWjJKfJLZWKahqgo1Go1IpEIMpwre301isUiL33ve+zq6DjnGdWZSrHv\n", - "xAmOjI2x7bLLLkBPXlhs20UUX6msLQgSlvWzPV5efHE/Pl8PgcBaMma5XCEW66Beb1Cv14jH+6hW\n", - "V5mbO0VHR4x8fg/BxhQbh9bT3taDUa4z2p5hJp9jrllFTHZQrTXAKiN4ZcJigPXBCJNGmVUsKpJK\n", - "WPMhyT5qko6mx4iFUiz6XFbLLTzPI5VK4TVKDGTT7M2XeObENAM+kc6gznQ+j9No0J/oJhmOIVFg\n", - "rjhDxCvTrcl86u5340gqlUaTnG3wyU9+lI6zwkPv+9jH+O6DDzI5M7Nm4BeLcfdHP0o8Hn/LffKz\n", - "8vOQM/Ip4KGLdbF0On0uSj569Cirq09TrerE4z9eM85kNjMzM8Hy8mna2s63RFZVk0RCwrYtZPnH\n", - "bxCFwizXXLOmXNfV1cWv/vqvc+udd/K/vvAFpg6eodww8FwP76xssIJLxHGYAkKijiMo6JJKQJdI\n", - "1loYjkldEIjLPtKeRWVuhuHuTq65extf+s4TTC42UMO9hMM6ZmORhVKN8VKRKVpcs+u2876YMzNj\n", - "BIM/nuXp6VlHd/cICwsTbNsWPC8QgTWBsq5t29izdy/9iQQ71/Uxu7qK29bG7rdBAO1iY9triatf\n", - "//qlbsml46qr1sTexsbgDQgs/lwhiiKDg4Pn5XX8iJGRAZ555hE8r+fcNLHneTSbS1x++e309fVx\n", - "0003AvBHv/d7PL53llR0lEwsgOM6HJ2aQVAmuNnzAKhU6kiSjiAIbNy8i4UlmVCii3p9Ca/0DJ5t\n", - "4Xo1Losl6Mvq7DlyhN/6r/+VXVdcwT/8w9dZWAhw8nSBVWWA4vJjDODgkxWano3qubSqJbqTbSxW\n", - "VgmkgmzdupUffvObRLu72Tt+mh19Q5zMzVJ3VFStQqW5TNyv0ReJsLQ4RyqgceuGrfg1nTO5AI25\n", - "UywurKJ3JFFkGdtxKLKW2PlaTE9PE/W8c4HIj+iOxTh+4MAvZDAyOjrASy/9AM/rPHcfuK6Laa4w\n", - "PPyzjVlLS6sEgz8e9xuNJp2d6zl9+gjFog9V7SYWa6fVmmL37gjHj8RZ33kdnYk1y4wgUZxci03t\n", - "JebkVepNlYhWIaGU6HfjBMQmIRxEReOML0ikvZczxXnMUIakFiao+WmGQuy8/CYajQqLi4uYpskL\n", - "+2bpDw8TUhZJCx5yy8aUDHpEkVOWRU1WkVZmoWUQaNVwadH0JHRJYnh4rdx2fHaW2ZmZc8FINpvl\n", - "Y5/5DKurq7iuSzKZvGQuzhc8GBEEIQM88C82L3qed78gCLuAW4H3vNqxX/jCF879fP3113P99de/\n", - "rW1Lp9Osrs6jaTvP295oVOjs3EAk0mJq6gCp1NqNmc9Ps359jIGBzTz++Mvoegeq6qNcXqCvT2Pr\n", - "1i3nnSccDiMGg1h2nVQkQa5aIuA5mDjUHAdb9xH0BbDcJsuAKloEZYgJLp7oYes+0pEwqmUyKUmc\n", - "Ghujq7OTgc6tjPRmaAQ1+gYHzi43zdC3I8zwDRpHj84gihKSJJPLTROJmMjyELVajUqlgqIoJBIJ\n", - "gsHoq5ZHCoLAHffcw9jgIGMvv4xlmozcdhuXbd9+wRUbLwTf/CZ0d8NFlFj4uUMU12ZHvvpV+C//\n", - "5VK35u2jr6+P7du72LfvZYLBtQG2Wp1j586eV/iQ1ByFph3Dr6351EiiRDTUwdjiwjnzzK6uNkzz\n", - "JNBPb+86kskXWVhYguYyw7FOAoqHqji4do14VyeJZJJQOIwkSWzduo7jx19gZKSPZ5aeJ6xGUQWQ\n", - "XANHaBFWQBFauG4ZNRhn841Xs3nzZg698AKrlQqNRpN4KMa1iXaWSjnyRya4adPNgMVQjx8OnmBB\n", - "DzA+d4pt/Ztoj2UZKywzvjzBup4sJcPgyOnTZLZswTCM85J8f5LXWtv3PO81fbt+3hkcHGTLliMc\n", - "OrSHUKgDz/Oo1ebYvXvgdQOzV6OnJ8uBA/lzMyPpdIpq1aCnp5+2NhfHmaCzM8rAwBY2b+6j2ezA\n", - "mDp83jl8vgjtmTjBdAeVikm95hD1ElBZwLUbIPmpOy3Qw+zoa6ctoiGP3kx79wiu6xCLZfA8gWPH\n", - "nuXo0aPMzKzQ07+b3OlTtGsKbdlOKrUa87VZktkMKVHi+Mo0WwMRkj4/hZbBkiDQ7fczf+YMw8PD\n", - "ALiv0seCILwtrrtvlQsejHietwy8wnlHEIQO4E+Auzzv7GvJv+Ang5ELQSqVYsOGbp55ZgJFCaIo\n", - "KtVqEUGo0NWV4p57duA4Hvv2HcV1PW6/fZQdO7ajaRoDA30cPHiURqPJ+vU7GR0dfYW0ua7rXHXr\n", - "rZw+dITVfJ71yQ4KtSKL1Qp1SUUKp+nr2Myxif2YgOdT8dcWsF2DZDjA5q4ufJLE/MICuC5xQWB8\n", - "YhIYYalSwLRkCvsaAChKk97ePn77tz/F/v0HePnlMWzb5eabh0mnL+c//scvcfjwMqADFoEAdHX5\n", - "2b371V+T1wbXrWzduvWC9sHF4E//FD7/+UvdikvPRz4Ct94Kf/iH8Av6zHkFoijy3vfeyaZNpzh0\n", - "aC0haMuWmxgaGnrFQ9enR9AzOjOreUKqiuk4VD2P/vU7aJ7VTRgcHKS7+yVmZo6QyQxw881388//\n", - "/DeUKzOEgim6sp2Ioksmo7J79+Ucm5k5tySyYcMGNm06Sa02RVgvEjU8amad/kgQSYtgegaSqrAi\n", - "Qt+Vu/nQJz6BoihcedNNPPr3f48e8rFaKDG3NM/+6UWqdoITM2cI6DUigavx6Rqb2gfYm5/ncGGJ\n", - "kCggxzPMihaX7djB42fmMcU4tWmFib/6Nr29Ie6//73nmQTCWgD3hCjSNE18Z8csz/OYLha58rbb\n", - "LnSXXRAkSeLee9/Dli0nGRs7gSiKbNnyLgYHB3/mxMrduy9n376vUij4icUydHUNcPDgA8RiXVx1\n", - "1c3Ytsni4km2bOkim01x8qTFfCDKYjlPJhRHEASWy3n8w3184jd/nUcffZKnZg4QFXW8RB/G3CkK\n", - "Tgsr7OOGK7Zx45VXsOfAYV6cO8nWHTcBMDk5xaFDJ6lWTxIM6hw69CKXX34PK4vz2HMGBHX8AT9N\n", - "IcHWK7exd2KWH/xwHzOWgiJVkUSLtD/Exp4O3EYDwzAQZZlVz6P/Ero0vx7Ca8QBF/7CgvBXrAUp\n", - "C2c33eZ5XvMn/v5aMcrbyszMDP/hP3yRcjmO4wi0tSXp7EwC0/zO73z8FV/kf0mz2eT48XEWF1dI\n", - "JmNs2LD+vGNc1+XZp57iT//T72NNTRNVNbr6+2iIAsfKTWJtvQwOdTKyro9isc7hZ55Am5qkp9U6\n", - "p3J3YnWVacPAVRRivb2cbsSpE6ar65pzLpVLSydpa1vkL//yjwgGg+e18eWX9/D7v/8lbLuLSKQX\n", - "UZRZXj6JLB/jP//n36Wnp+cNl75dSARB4O3u8xdegA9/GE6efOc8gN8Kl18Of/AHa0HJzwsXot9f\n", - "jb/7uwdYWPBjmlDI5dB8PrLt7RSLY3z2sx88t3xrGAbPPvsCe/YcxXFchoc7OXF8nKkfPEF/IkV/\n", - "fweDA/0IksQLs7Pc99nPkk6nWVxcpFgsUiqVeOjr32Ll2eeo1Q18zTqjmRQdmRT75ubQtm/nP/3J\n", - "n5w3Thw7epTHH3qIB//xYZbLKZLZHViVJrLYRJVn+PBNg8RVmRf3nCYXzrBx9x3U62VqtSL9/Sod\n", - "HRn27MnT3b225FoqlRgbe4nuboff+I1foaen57yH8oH9+3nqG98gJQgokkSu1aJ961buet/7Ltrs\n", - "yJvtd+P/svfe0VWdZ6L+s/fpRaeo944khCii2phmwMYN9xYnTtwmmbEn8SRzp2TuFN8pmcnv3jUz\n", - "SWaSiRPixHFwwd0xxsaA6SCKQAj1etR1mk7vZ//+OEAAgY1tIQk4z1qshbZ2eff+tvb3fm8NBGhq\n", - "amZkxEZmZhrV1TPRarUTKlt/fz+bN+/AYrEilwtUVOQhSQKtrRa0WhVLl87j+uuX4Ha7+c///C06\n", - "3Qz6OxsYG+wkGgkhaeP84w//nsrKSuLxOJt+9zv69u8nZHNga28jxWhAzM1l3Q03oFQoaOvp4d1m\n", - "C9Xz70MU1WzffhBRjFBdXUBR0Uy2b38HpxNuu20Nh7b8mhJBhVqlJi45ENMNnOwTsfkETKKI3elC\n", - "EGzMKhLIVMqJBAJULVqEV63m+vXrWXLdxSsXX25OjfkFtcMpU0Y+i8lSRgCOHDnKu+/uIhbTAXG0\n", - "2jCPPLJ+nJn3fJxOJxs2vMLYmBqVykgo5EahcPL44/edyUw5TTAY5FBdHe3HjxOPx5m5YAFz5s5F\n", - "qVQSDofxer2YTCbaWlv55b/8C64DB5ibloYrFmNUFBO/i0S47RvfYO+BBjo7jRQUJJreBQJeQqFh\n", - "KipSePjhhSxevOica//oR78kFMpndHSA7u4uAoEg4UCAuH+Q25YUokhJoWjuXG6/554pLfN+OSal\n", - "Bx+EZcuurhobX4af/Qx27JheRdAmSxnp7u7m+effITNzDjqdkVgsysBAC1VVWr72tU8vPhMMBtm4\n", - "YQP092NSqYhEIlijUWasWMGK1at5+9VXsbW3oxdFPLEYuoICxiwWakwmrGNjdPf2MubxEE1L429+\n", - "+EOysrLGXcPv9/O///f/w+vNZnDQRn9XJ7PzMslKMxAINfGNm6/ng1276RAMlJQvIR4PkJEh5667\n", - "bubXv36b7OylyGRy2traOXmyD1HU4fHUs2hRFcuXV3LXXbefo5DYbDZaW1oIB4MUl5VRXFw8qX2n\n", - "vsi422w2Nmx4Dbdbg1qd+Obq9T6efPLBy7KgCoVCyGSyT015bm5u5rXXPiQS0RKLRZHL/Xz1q3dQ\n", - "VVWFJEn4/X4EQeBkYyPHDxxg3/btVKSns3zePNRKJcFwmCMDAyy+6y66uwd5992PGRsTmTfvOtzO\n", - "AFaLhZh/jKMdLVRUzqaqugRP6yGUPhd6Q5xWtxxDzmLkCiX6QACTXo8v6EEh76a2PJfDo6Pc88gj\n", - "VMycecH3bjJJKiOXQCAQoL+/H5lMRkFBwSVNyhs3vkFHh0R2dgkOxzCdJ/bgGOhErQ3x8FPfYPW6\n", - "dRe1rEiSRCgUYuvmzXQePYpaFAkKAvNWrKCguJh/+uu/pufIEXJSUjAYDAhGI4tuu42v/9Ef8dpr\n", - "b/POO+14vTJAwGhUM3fuTMJhN4sWGcY1hPrBD36CwTAfpTIR73HkwEFioyOEI0PcUJNCSXY2FoeD\n", - "sjVruHHt2i/9LL8oEz0pdXcnLAHd3XCRUgvXHE4nlJQkao5MQcD8BZksZQSgqamZ99//BJcrgiBE\n", - "WbiwknXr1lxSLFR7ezsbfvxjRjs7kclk5M+axRPPPMPhffvwNTYy81SaoyRJNFosRAsLCdhsyAMB\n", - "EASCSiWLV6+moqLighOnzWbjxz9+jfz8RK+Crs4uehqOk6pSMeZtZNWCYqTMTG594AGsVivHDh7E\n", - "NTREJBTiUGMPi1c9gSiq2LbtEGZzCaIow+k8zOrVa7DZWnjiiZu/VIXMieaLjPuvf/0yfX1qsrL+\n", - "sNizWvvJzvby5JNfnWgRL5lQKETfqUJhBQUFqFQqWlpa2LV5M36HA+RyZl9/PStWr8btdvPOK6/g\n", - "HxxEIYr4ZTKWrlvHkuuvB+Cll15nYECL3eZm8MQJUnU6YrE4/dZ2guE+RHNuYuEbsJKiVtDnSeWm\n", - "27+BwWDg6J49pMTjaFRKhux1LFs+h9u+/vVpM+6fpoxMh2yaaYFGo/lcAxYKhWhu7iUvbzkej5Om\n", - "ve9QIlcxK38GVlsbo/v38/roKI9+85vnRCf7fD52bd9O8+HDNJ08SWY8zs3LlpGi1xOJRjm6dSua\n", - "u+/mV6++ytGjR6nbvRuZKLJo2TJqZs9GoVBQUVHCjBlesrMTJkC1Wo0gCPT29pKXN/4eZs4soaFh\n", - "gJycMgKBAI6hQcSAH0v/MQow09vcjNpsxrFjBytXr56yaOqJ5t/+Db71raQicjZmc6JfzcaN8KdX\n", - "XrmYL0119UyqqirxeDyoVKpLDsh2uVxs3riRGwsLSZ89Gykep76xkb987DECPh+1paWkqNXkZ2Qg\n", - "CAJVeXnsHxzkW3/1V4yOjrJ35078ra00bdnCkc2byayo4M4HHjjHvZDomholHA6iVKopLSvFYDTQ\n", - "2XoSSa6h+o47qJ0/H7VazcfvvovOamV2Xh4C4Gru4MjHG8mqWoUo6hFFGaGQB7VaQKczEAzm09DQ\n", - "Mm0mpS+Cz+ejo2OYgoLl52xPT8+ju3sPHo/nogXeLjcqleqcbK+uri4+fPFFatLTMRUWEo5EaN65\n", - "kw+8Xu687z4ef/pphoaGqK+vp+vECXb9/vecPHKEpWvXUllZTHNzA53NvYTsduz9/ciB0UA3t95Q\n", - "TGNPDw9ffz01ZXfgDQT4xe/303rkMItXr2HJjTdi6elhsL+L/DlVPPTMM2RfIfUMro5ZZwqQJInT\n", - "Sn1fdyM5gPlU9LUoyqjIzcXf10dvb++ZYyKRCK/++tc46uqYazRi9vkoCIc5uncv4XAYhVzOrJwc\n", - "Dn3yCYIgsHDhQp7+7nf51rPPMn/BgjMBsjU1szCbgzgc/ahUSuLxGAMD7WRkSFRWVp4vKitWXI9c\n", - "PsLgYAcezxij1kEGeg9zS5GJBRkZLExNRe9y0dTQQDQ6KSVfLjsWC7z+Onzve1MtyfTj8cfhhRem\n", - "WoqpQxRFjEbj58oMO9nYSFo0SrrRCEBbayvujg5mxOMUiiJ5wSD79uxhwGYDQCGXI8RiSJLEYH8/\n", - "3uZmlhcWMr+ggKWFhcQ6O/ng7XMrGiiVStasWURfXz1+vwcAtVpORo6Mv/6777Fs+XJ0Oh1dXV1E\n", - "hoaYkZeHTBQRRZEV1y3AEBihu+MQ0WgQj2cYr7eZOXNqr5rFxZXEgR07KDcYMJ2K31MqFMwpKqKr\n", - "vh6Hw5FYPHZ30717NzUqFauLisgPBvnwN79BoZCTlRWntaUOud9NplJALtm5LltkpLMTldtN/imz\n", - "pl6jYWFFNlFPH53treh0OnLyMimvMvFnf/70FaOIQFIZ+cKo1WoqK/OxWi34naOknEoX9PndmExq\n", - "NFotKYJwTupsR0cH0YEBqgoKiMZiaGQyskwmFIEAAwMDQOLlCnm9n6oUaDQannrqK1RXqxgY2M3Q\n", - "0F7mzdPzxBMPnUlRPJu0tDSefvprLFpkIh5vw+msY0F2hMqzunimKhTIo1E8Hs9EPaIp5V//Ff7o\n", - "j+AKrM922VmzBux2OHRoqiW5cnCMjBD1++nv72d4eBhLaytFaWlk6PVEJAmtXE65RkNDU1Nif7cb\n", - "fXo6Go2GI7t2UZ2bi+yUUiAIApV5efSdPMnY2Ng511m69DoefHApkUgzvb07EIROvva1tcydO+fM\n", - "PnabjZTzFIyMjAxuWrGQvIwwsdhR0tK8rFy5nJycklNprgPU1FRc5qd0edHpdJSUZGKzDZyz3W4f\n", - "pKgofcqsIhdipL//jOJ6GkEQ0J+aE8LhMAc//pja/HwMp1z5aQYDs9LTqduxgzvuWE1Zhget2IUo\n", - "dFFidlFo1KIVRSIezzlJCktnV7FsjgGn7QAWyw5SUkZ48sk7KSoqmtR7/rIk3TRfgttuW8Mvf/kK\n", - "voiPUecoYbUGudxPbe2CxIpobIxCr5dIJIJCoWBkcBDzKetGilZLCIjEYuhVKlx2O5SU4PR4MGZk\n", - "MDo6Sv3BgzitVvJKS6lduBCz2Xzm2ikpKdx//53ce28c4DMj4M1mMyk6FSkhO3NS5HhHR/lwbIx5\n", - "ZWXo5XLs4TAVM2bg9/uvyAqrZ9PaCps2XZul3y8FmQyeeQZ+9CN46aWplubSkCTpTPGn7Ozsy1Lv\n", - "JhaL0dTURNORI8RiMarmzWP2nDlngs9tBw4w02RizO/HZrdTYjTiisWYOWcO/RYL6SoVVquVfquV\n", - "br+f2x97jHg8TsjvR3teHQdBEFDLZAQCAfR6PTKZDEEQEASBBQvmM39+LdFo9IKxayazGW88Pv4Z\n", - "KRTc9/D9iEoN27Y1EAz6GB7uIRAYZsGC/CvaRXOa9etvYsOGTVgsTjQaM4HAGFqthzvvnF7dL9Oy\n", - "s3G6XGSYTGe2SZKELx7HaDQyNjaGMhpFrVQiSVKi/ocoYk5JwWuxEAqFWLV4AT1HjjA82E+KR06f\n", - "dZRWvx9Bo0F+1nshE0Wy01P543vvZtnKlZ8rCSEajdLY2EhLfT0AVbW11NTUTHiPokshqYx8CdLS\n", - "0vj2tx9n586dvPvCbyjM0jFzxjy8Xi+vvfEGVlFE/+GHNOzZw83334/BZKLnlMVDpVAwo7KSkydP\n", - "YpIksnU6HG43TXY7ZUuXsumnP6VApSJHp2N4925+e+AAD3/rW0iSxNatu2hu7kGplHPddXNYtWrZ\n", - "ZyojnZ2dHP/wQ5YWFqKeM4fY8DBjTif7OjtZsXgxsysqaA2Hp0Xxmy/Ld78L3/8+TINs5WnLU08l\n", - "muYNDcGpyurTFqvVyjsvv0xodBSFIOCXy1l2660sXLz4sw++RCRJ4r0332ToyBGKzGZkosiR11+n\n", - "paEBuVxOuUxGPDeXaDBISVoaDouFA+3t6EtLWTRnDu6iIhpPnMAZiRAuLOTelSvPZNRl5ucz6nSS\n", - "edZiIhgO0+9ysWnT+4yOjqHXq1mxYgHXXbcEURQRBOGik0pZWRm70tPpGR6mKCvRQNDmcjEsSaxZ\n", - "tIj09HQqKso4ebKVaDTKzJm3UFJSclW4azIzM/nOdx7jxImTDA/byM6eSU1N9bhyBlPNklWr2PLC\n", - "C2hUKvQaDbF4nOb+fvKqq0lPT8fn8+GJRNjd0ERTr41YLE5prpm5ZfkoNBpyc3OxuFz0DwxQEg4j\n", - "+P0ICgVLcnPZHwpR19zMvPJy5DIZ/VYrDpWKOxYt+lyKSDwe561XX8Vx4gSFp97Ng6+8QntNDfd+\n", - "5SuTXgAvmU0zQXR2drLtnXdwDw9z9OBBZuTmsvq669BrNLh9Po47ndz71FO8/eKLzFAoyDSbkSSJ\n", - "uqYm9pw8ycy5c8kpKuK61av55N13ma3ToT+r26RlZARXVhZ9I0GggIyMfGKxCIODbZSXK3nssa98\n", - "alreW6++itjRQX5GBg6Hg6O7dpGpVDIQDJJVU0NIJmPubbexfOXKSXhaF2Yisipefx3+9m+hoeHa\n", - "6877efmTP0kobP/4j1Mrx6eNezQa5Zc/+hG5oRB5pxTl06mQtz/1FGUTVMCpp6eH959/niXn1ePY\n", - "09rKqM/H3fPm4Q+FONrUxEB/PwP9/TgiEf7iiScwGwxEolGOWCxcd//9LDiv1G93dzfv/PKXlOv1\n", - "ZJrNuH0+9rS10R1IYVbNWkymDIJBH4ODJ1m1aga33PLZGW1Op5Mt77zDSEcHIqBNT+eme+65okzz\n", - "k5lFNRUcq69nzwcfIAUCRAWBGbW1rL31VtRqNfF4nGef+V/0NIwxs6AKmSjH7hllxH2SZ77/DAsW\n", - "LeKbDz2EqbOT2tRUlDIZDr+f3nCYitWriRcWIobDxKJRimfOZMVNN32uZoCQyA7b+qtfsfislG5J\n", - "kqjr6eGmJ564LJa0ZDbNJFBWVkbpd7/Lto8/JgVYeFZktUGnI8vppKu9nfsef5zNmzbR1deHIEmQ\n", - "m8s/fec7FBYWolAoGBoaQhYIoD/PQpGfkcHmHbvJLr+FgoLTaW1KcnNn0tFxGIvF8qkfoqDPR+qp\n", - "2Tk1NZX5K1bQ1drKcEcHgXichx59lNlz5lz0+CuBgYGE++Hdd5OKyKXw3e8metZ873twljV5WtHT\n", - "04PgcJB31rutViopSUmh/sCBiVNGurpIVyjGKfRpajUdvb2Iooheo2HFggXEamsJh8O8uH079VYr\n", - "KS4XQVFk/i23MH/BgnHnLikp4Z5vfpNdH35IS18f5sxMpOxSqtSzzvSLUqt1FBXNZ+/efdxww5LP\n", - "jH8wm8185bHH8Hg8RKNRTCbTpNYISfLZzKutZfacObhcLtRq9TmZU93d3WhSSiicrabHYkEpioRR\n", - "kZK3EEQ5x44coSo9HXk4jNXvJxwMkmI0UqJWI5MkZs6ezc233048Hv/CLpXu9nayNJpz3htBEMjS\n", - "aOhqa5t0t15SGZlABEFAlCTSLlBbRKdW4xkbIy8vj6eefZbR0VHi8TiZmZnnmMPkcjmRC/iDI7EY\n", - "Y94wVaYs4vE4He3t9HV0EI9ECMTcHFt87FOVkbJZszj57rtngqpSU1MxLVlCKCeH+//08dpH0AAA\n", - "IABJREFUT8nNzZ2AJzB1eL1w113w7LOwZMlUS3NlUFGR6GT8H/8B/+f/TLU0F8bv96O+wCSr12iw\n", - "OhwTdh2VSnXBvzulXI7caGTM6z2TGSETRTyBAEtvvpm7H3kEn89HamoqmrMsmWczMDDAnq1bGbVY\n", - "kMnlFJSV0T5wnNzcczMdZDI5oMPhcFxyMOZ0CtpMMh6ZTHbBDrijo1aUylTK51cRmDmTYDAESJxs\n", - "OMqG//oFJmUMMRDApFKx6KwCmjaXiy6Xi5tnzEA8lUn1RVGqVERisXHbI7EYqinoQTZlTkRBEL4u\n", - "CMJOQRAOCILwxFTJMdHkFBTgCIXGbbf5fOSXJBruCYJAVlYWOTk54/xyGRkZGPLz6bdaz9neNjjI\n", - "rHk1+P1uTp44wfDJkxRptVSkppEScXNw82Z6enouKtfsOXOQcnI40dvLmNeLdWyMQz09lC5efMUr\n", - "Ii4X3HknzJ2biBVJcun8/d/Df/0XjI5OtSQXJiMjA1c8Ps6cPzI2RsEFuvh+USqqqrBJEoGz/nbD\n", - "kQjDkQh3PfooJ+x2LCMjePx+uoeHafX5uPH22zGZTOTl5V1UEbFarbz+i19gtFpZWVDAdRkZDO7d\n", - "y6ClC6/33EyaRLmAwLSLf0gy8RiNBiQpACSyI3U6LQ2HDhEY7GVJQTY3zZhBittN59gYDaOjjAUC\n", - "uIJBjttsZM6dOyFWi5k1NQxHowTD4TPbQpEIw9EoVbNmfcqRl4epjGjaKEnSSmAp8PQUyjGhzJgx\n", - "A7KyONTcjC8QIBSJ0NLXRywjg5nV1Zd0jvUPPsiQWs2R3l6aens50NODsrycRx97BJernf62ZgrS\n", - "0lDI5Di9VrLTJK4rLGT/9u0XPadGo+ErTz7JjFtvxaJSYU9NZdkjj3DbnXdO1K1PCceOwdKlMGsW\n", - "PP88JC3Vn4+SEnjyyYRFaTqSk5ND4bx51Pf04A0EiMZi9AwPM6pQsHACe2ykpaVx4/33c8hq5YTF\n", - "womeHg4ODbHwtttYtWoVDzz9NGJVFV2iiHr2bL7yzDOXFJ9x+MABcgSBnLQ0BEFAqVAwu6iIHC10\n", - "dh4iEklMBJIkMTDQSlVVLgaDAavVit/vn7D7SzK9KCsrw2gMn0lTHh4aIuayY9B6mFWcT35+Prk5\n", - "OeQoFEjZ2fQqFBzy+UhfuZI/+bM/+9Tg0mg0is1mw+v1fqoMWVlZLLvrLg4ND3Oit5cTvb3UDQ2x\n", - "9M47p6Q+yZQHsAqCoAG2nFJMzt5+RQWwQqJ/xebNW6mra2Kwrw/vSDelZQXcdOd6lq5Y8blMqpFI\n", - "hK6uLnw+H2lpaRQWFiIIAh9++BH/82//TZo2E0mKkmmWsXZBNXqNhr0jI3zvMnc6vpx8noC2kRH4\n", - "4Q8Tqan/9/8mOtImFZEvht+fsCr9y78kevlMNp817tFolLqDBzm2dy9Bv5/S6mqWrV59WTK/PB4P\n", - "XV1dSJJEUVHROen0X4Rf/eQnlESjZ2pJnOZEby/xsgosFifxuIZ4PEB1dQG5uens2nWcSESGIIRZ\n", - "uLCSW25ZO64j+NXA1R7A+llYrVZee+33DA156WzrRD7Wx93L5lJ8ShEIBoPsraujB6iaOZOaxYu5\n", - "ftmyi1rhAI4dO87mzbsJBECSosyZU8Qdd6z71EaCLpfrjFW9uLgY43n1USaSadubRhCEvwf+CPhb\n", - "SZJ+c97vrjhl5OWX36CpyUdeXtWpcswBBgaO8uija5g1QWYvq9XKb//936k2m1HI5Wf82Ha3mwGN\n", - "hsefeWZCrjMVXMrHaWAgUR9jwwZ45BH4m7+Z/qmpVwJHj8K6dfDeezDZTT2v5knprVdfRWhvp+C8\n", - "TIdDvb3c/OST5Obm4nA40Gq1dHV189pre8nPr0WpVBOLRenvb2LBgnTuvXf9FN3B5eNqHvdLRZIk\n", - "bDYbB/bvx3HwIDXnWdsaLRZmrl/P4ksIhOvo6GDDhvfJzp6HRqMnHo8zONhGSYnA448/crlu4XPx\n", - "acrIZXfTCIKQJQjCjvP+vQwgSdI/AmXAU4IgjHOUPvfcc2f+ffLJJ5db1C+F3W6nsbGP/PxqRDFh\n", - "QlOpNKSnV7FjR92EXScjI4P86mpsHg+GU9puMBym1WZj8apVE3ad6UZdXUL5mD0bgkE4fhx+8pOk\n", - "IjJRzJ8PL74I69fDr34FF4jlTPIFWLh0KT1+P55TLhdJkugZGUGelUVRURFqtZrc3FxMJhM7dtSR\n", - "lVV9pqGlTCanoGAW9fWduN3uqbyNJJcJQRDIyMhg5apVuFQqrGdV5B1xOnGp1VRf4kJ2165DGI3l\n", - "aDSJqVQURfLzq+josDM8PHxZ5J9ILns2jSRJI8CN528XBEEpSVIYiABxYJy29NwV5HLweDyIom5c\n", - "ep1eb2ZwsGFCr7X+/vvZ8t577D1xAiUQVSi47p57Jsz6Ml3weOCNN+DnP4fhYfj2t+GnP52+aahX\n", - "OrfeClu3JuqPPPccLF+eaKzndoPNBlZr4p/dDgYDFBQkMpeWL4fVq6dPF+DpREFBATd/9atsf+cd\n", - "BLudiCSRWVbGA/fee47fPxaL4XC4KSo610QuijIEQYPH48FgMEy2+EkmCYPBwL1PPMEHr79Ou8WC\n", - "BOiysrj/vvsuOaB5eNiO0Tg+jkkm0+N2u6d9n5qpTO39viAIqwAV8IokSVd0UxSz2Ywk+YjHY2cs\n", - "IwAul438/KwJvZZGo+GeBx/Ec+ut+P1+zGbzVeVT9njg6acTLoOVK+Gv/iqxYp/kgoDXJPPmwb59\n", - "0NSUcN2MjSW6HqenJwqkZWYmlA6PB7q74cCBRNO9J56Aykq46SZYuzZRv+QCbZKuSapnzaKyqgq7\n", - "3Y5CobhgHIpMJiMnJw23247B8Id2DLFYFPBjSmrgVz35+fk89eyz2Gw2BEEg7VTQ86VSUJBFX5+N\n", - "9PS8M9skSSIadX3p2KfJYMoDWC/GlRgz8s4773PgwCB5eQlTq8fjxGZr5Kmn1k9YcaarmdM+ZElK\n", - "xITcdVeypPuVQjicUEy2bk38O3kykeVUXJywrigUIEmc6XS9YkUiRgWSsQOnaWlp4Te/+ZCMjBr0\n", - "ehPhcJD+/kZWrizl1ltvmmrxJpzkuE8sfX19/M//vIHJNBOjMZ1IJMzAQDNz55p46KF7p1o8YBoH\n", - "sH4agiBMT8GSJEmSJEmSJF+IK7Ic/HRVlKY7wWCQH/1oA7FYwRmTndttx+Np5jvf+dq07co7GSul\n", - "gYEBfvrTTaSnz0WnMyBJEiMjPZhMTp555olJbw6VJLlCvlaZiHGXJIkNGzbS1yeQm1uBIAin+vzU\n", - "89RTt1M+gYXxknx5Ps3tdOW3cUwyjra2Ntxu9Tm+Q4MhDUnKpL5+YoNprzT27z+CWl2ITpcIBhQE\n", - "gezsEkZGYp9awTZJkiTTj+HhYbq7neTlVZ6Z6NRqHWbzDHbtOjTF0iX5PCSVkasQh2MMuXx8BLZW\n", - "a2B01DkFEk0fRkYc6HTji/oIgg6P54qOoU6S5JrD7XYjiuMLeul0RkZG7FMgUZIvSlIZuQrJysog\n", - "GnWN2+7zOSgsnNjMniuN4uIc3G7buO2S5L5gQ6skSZJMX1JTU4nH3ePcPS6XjaKiK7vn1rVGUhm5\n", - "CikvLyc7W0Z/fyuxWJR4PM7ISC9arZu5c+dMtXhTypIlC4BhbLZBJEkiEgljsTRSXm6moKBgqsVL\n", - "kiTJ5yAjI4O5c4vp7T1OOBwEwOkcJRDoZuXKZPvuK4lpnU0zXWW7EvB4PHz88U7q69uIx+NUVRWx\n", - "bt0qMqZxruxkBTIODg7ywQc76O4eRi4XWbSomjVrVqKegrbZSZIBrNcqEzXukUiEnTv3sG9fA+Fw\n", - "jLy8NG69dSXFxcVfXsgkE8oVm9o7XWW7kohGo0iShEKhmGpRPpPJnpTC4TAymSyZQTPFXAvKSDQK\n", - "LS1QVQXyaZ3DOHlM9LjHYjGi0SiqZLW9aUtSGUlyRXAtTEpJxnO1j/vAQKIyrdebaGWwdStkXduh\n", - "W8DVP+5JxjOljfKSJEmS5FolHodHH4UHHwSLJdH/54kn/lCJNkmSJAmmTBkRBGGWIAh7BUHYJQjC\n", - "z6ZKjiRJkiS5XGzalGg0+Hd/l/j5n/8Z2tpg586plStJkunGVFpGWiVJukGSpBWAShCE2imUJUmS\n", - "JEkmFEmCf/3XRAfk02FJCgV8//vwwx9OqWhJkkw7pkwZkSQpetaPGmBsqmRJkiRJkolmzx6IROD2\n", - "28/d/vDDcPAg9PdPjVxJkkxHpjRmRBCEOwVBOAEEJUnqnkpZkiRJkmQiee01eOQROL8dh1YLDzwA\n", - "L744NXIlSTIdmRbZNIIg/Bh4T5KkrWdtk/7hH/7hzD6rVq1i1apVUyBdkskiGV1/bXI1jns8Dvn5\n", - "8MknUFEx/ve7dsGzz0J9/aSLNm24Gsc9yafzadk0U5bxLgiCUpKk8Kkf3YDy/H2ee+65SZUpSZIk\n", - "SSaC/fshPf3CigjA0qUJN43FAoWFkytbkiTTkal009wiCMIngiDsBPKBD6ZQliRJkiSZMDZtgvvv\n", - "v/jv5fJELMm7706eTEmSTGemhZvmQiSLnl17JM221yZX27jH41BUBB99BDNnXny/N9+En/0sUQTt\n", - "WuRqG/ckn02y6FmSJEmSTBIHD4LB8OmKCCSqsh44AD7f5MiVJMl0JqmMXKW4XC7cbvdUi3HNIkkS\n", - "Y2NjeDyeqRYlySTz+uuJbJnPIiUF5s9PBLMmSXI+8Xgcp9OJ7xrRVpMtmyaR0xOUIAiYTKbLco2R\n", - "kRE+fPttnH19SJJEamEh6+6+m6xkM4xJw2Kx8NHbb+MfHSUO5MyYwbq77vrUMfd4PEQiEUwmE6KY\n", - "XCNcqUhSQhl5//1L2//mmxPunFtvvbxyJZk+uFwuYrEYZrMZ4fy871O0tray/d13ibhcxASB4tmz\n", - "ufn229HpdJMs7eSRjBmZJAYHB/no7bdxDw4iAab8fG65554JVRK8Xi8v/OhHFAsCuenpAAzYbPQJ\n", - "Ao995zuf+SI7nU5isRhpaWkX/SO5nFwNPmS73c5LP/4xVXo96UYjkiTRPTxMv1zOI089RWZm5jnP\n", - "1uVyseWddxhqa0MmCChMJtbedRfl5eVTeBeTy9Uw7qepq4Ovfx2am8fXF7kQhw7BY4/ByZOXXbRp\n", - "x9U07peCw+Fgy9tvM9rZiUwUUaWmsu7eeykqKjpnv76+Pt742c+YnZ6OSa8nFo/TPjhIvKCArz31\n", - "1AW/zZIk4XA4EAThU5WcqSbZtXcSaGpq4sD27TiGh8nIy+P6NWuoOJXX5/F4eOE//5MyhYLs1FQA\n", - "Bm02LJeoJFwqdQcO0Pz731NzXq7gCYuFWXfeyaLFiy94nM1m4403NtPX5wREUlNV3HvvzRQXF0+I\n", - "XJfKlf5xcrlc/PTf/532nTtJNxopKykhKz2dPY1dNPePUVBTw+zZJdx3361kZ2cTi8V44b//G6PT\n", - "SUl2NoIg4PR4ODk2xoNPP01OTs5U39KkcKWP+9n85V+CSgX/9E+Xtn8sBpmZcPx4oi7JtcTVNO4X\n", - "wuFwsHfHDtqOH0eUyxkcHGRRVhalubkIgoDN5aLZ4+Fr3/kO6acWjwBvvvwysq4u8jMyzjnfwd5e\n", - "1v/xH1NQUHDO9v7+ft54YwtWqx9JksjLM3LvvbeQnZ09Kff5eUgGsF5mjh4+zMcvvkh+MMiqggKy\n", - "vV4+eOEFmk4tdxpPnMAUCp1RRABy09PR+Xw0NzVd8nWCwSBNTU0cO3aM0dHRcb+3j45i0mjGbTeq\n", - "VDgusD9AKBTihRc2YbMZKSxcRmHhUuLxYl544R3sdvsly3at4/f72fiLX+A/doxlZjO1Gg3DJ0/y\n", - "401bCYYKyDHWYDLOxuPJZMOGTfh8Prq7u4mNjFCak3NmJWNOSSFPoaC+ru6C14nFYnR0dFBfX4/F\n", - "YrmqP+ZXGpL02Sm95yOTwdq1125GzdWKx+Ph5eefJ9DYyLKcHNICAex1dbQdPYrDbkeSJNKNRnJE\n", - "keNHjpxzrG14GJNeP+6cWkEYFwfocrnYsOENQqF8CgtvoKhoGS5XOi+88AZ+v/+y3uNEk4wZ+ZJE\n", - "o1H2ffQR83Jz0anVAKQbjcyWy9m1ZQszq6txjIxgvICSkKJU4rBaL+k6vb29vPjiOwSDWkAB7OT6\n", - "6yu5/fZ1Zyay9OxsTtbVcf4CaywUougiq+y2tjbGxhQUFf3hKIMhDY8ni/r6BtauvfGS5LvWaWxo\n", - "QDM2xszSUlzt7Zh0OuSCjIhXRywuIyhF0Ol1pKZmYbFYaWpqRiYT0V7gXGa9nsHh4XHbnU4nL774\n", - "OqOjcRLtnDyUl5v5ylfuRX3q3UsydRw9mmiEN2fO5zvudNzI449fHrmSTD7Hjh7F6PNRVlCAx+/n\n", - "w4PHibuhzWXH6amjqCiNRYtqMel02M/7W8/Kz8fR0oL+vDnDK0nj4s4aGhqJxdIxmf5gRUlLy8Fi\n", - "sdHc3MKCBfMv301OMEnLyJfE7XZDIHBGETmNUacjNDaGz+cjMy8PZyAw7lhXKETmJZjiQ6EQv/3t\n", - "O2i11RQV1VJUVENBwfXs2dPJybOczbNqavClpGAZGUGSJOx2O5u37WT7iTa6uvuwWq3jVtJOpwu5\n", - "PGXcNbVaI8PDScvIpdLf1UWGXk9BYSFeUcTt9+MKRtHLNfRbrYgGA+np6fh8Pnp6RnnhhdfYvfsg\n", - "/WPj+0Pa3G4yL2Czf/PNzbjdqRQVLaSoaBZFRdfR2Rlh+/ZkOsZ04LRV5PO662+6CT7+OFGfJMmV\n", - "w8WskpIkUbd7N71tXXyyYx8bN+8gEssBdRomjRmNJgurNU5razs2j2fc3/qiG26gNxTC5nIBEI3F\n", - "aOrrI7W8nNzc3HP2HR11oFaP/34rlSnYbM4JutPJIWkZuQinJ/NYLEZGRsZFMxw0Gg0REi+M/HSf\n", - "cCAUiSDJ5ahUKqpnzaJuxw46+vsJO50M9PZi9XqJl5Rw53n+vwvR1dWFxeKFSAvxWIyMvDy0Wi3B\n", - "oJYPPtjBrFmzEAQBrVbLQ08+ydbf/563Dhyg4UQnKVkzqV60mj17+vnNb/6CkpICioryWLVqMfPn\n", - "15KZmU40Ot5V5PXaKSws/qKPb8qJRCKcaGig5dgxZDIZ1QsWUF1djeysMZooPB4P7R0dtGzbhkIm\n", - "wy+B3eZn1DGG1e+jpriSBddfj8/nY9euwzidIyxZUoXbnc7Rrk9Qhg+zbH4twUCAYYeDIVFk9Xnx\n", - "PU6nk+5uGwUFN5yzPSengoMH97Nu3ZrLcm9JLo3TWTSvvfb5jy0sTJSOr6+HBQsmXrYkX5xIJILd\n", - "bketVp+xSjQ2NvL66x/Q3z9CYWEO9913C7NmzTpzzNat2zlUbyHbLWDUamjq7CfNkI2k1BJ3OzHJ\n", - "RAwpmdQ3NVK6YjG3nxr0xsZGDu7YgdNqRa7VctTjQeNyIYkiFQsWsHrdunGBqfn5WdTXNwF552wP\n", - "hcZISyvi8KFDtB0/jlyppGbhQqqqqqZttl5SGbkAIyMjvP76ZoaGPAiCDINB5L771lFaWjpuX41G\n", - "Q+WiRTQfPMisggJEUSQej3O4owNdZSUtLS2UlJRw3ze+wT/95V9ib2lBlMnIyMykXK/n7Y0befRb\n", - "30KlUl1QFkmS2LZlC32NLZRnVxKNxdh+uIGgzEB6ZhZNTa2Yzb9j+fJFDPT2IogiN6xeTVuvg+Wl\n", - "92AypWO19tPa2ockzcbpVFNSUsmmTfvxeLwsW7aU7Oy99Pe3kZNTiijKsFr7UaudzJt35+V+1JeF\n", - "aDTKppdewtfWRmFqKrF4nD2/+x1dCxdy5333TWikeSAQYMNPfkLL7t20tXQiSBqsITNxTQ5l+XNx\n", - "Wbuw9A/RcKwejy+C1+snO1tLSUkNCoWSG9Y8Rd2+33D43c343CGUxlQq5tXgcDjIOCuALRwOIwiK\n", - "cbLL5Qqi0TjxeDypjEwhR46AKEJt7Rc7/rSrJqmMTB8OHTrCK6+8h9sdBqIUFKSSmprC66/vRyab\n", - "gUpVTHe3jQMHfsw//MMTLFmyBIfDwc6dJ5i7cD2tu95Cj4BWayIaUaFOyWM0VYMsFkIcsxJUa/ne\n", - "Y49hMpmoO3iQXS+/jCkaJQOIKRTEFApWPfIIM2fOvOj8UFMzi08+OcTISA8ZGYWAxPBwNyZTiIa6\n", - "OuL9/RSYzURjMXa8+CJd113HHXffPZmP8ZKZykZ5S4B/B+LAIUmSvjdVspxNMBjk179+nXi8iMLC\n", - "hPPX43Hym9+8x7e//dVzop5Ps2bdOraEQuw9dgytKNJo6WfEryIj4qO+4QNSU0Vqa0sRAhGU5ipE\n", - "wYzNE6DvQAvmxkbiKhUGYyr7dh3AP2ajsqqMm9avZ+68efT39+OzWMgxgkIG9S3H8TucxAU5dnGM\n", - "VTcuYdvWNg5ueZ+baiqRJIkD771Hl13ihhUrAWhqakCjKUerTcNub0Op1FJQMJ8dOw6yZMkiHnvs\n", - "QbZu/YRjx/YSj0tUVORzyy0PYTAYJvXZTxQtLS1429tZUFJyZlumycSBo0exLFo0LpXuy/C7l17i\n", - "5z9/C6/bTCy+CJe/h1RljJSIgoY+F2V5+cRCY9Tt/B0utxtTTiHl5Wvx+z3Y7YMM9DTS3GKhdtEd\n", - "LFm3BJu1n97mg3z7sWeonFlIXk4OReXlLF6xAq02jt/vQav9g1nWbh+krCwPhUIxYfeU5PPzyivw\n", - "0EOf30VzmltugR/8AL7//YmVK8kX48SJE/z93/+EWCybQCDM8HAX0agKv38MnS6dkhIRmUxJKKRi\n", - "eFjJP//zT9i0aS4DAwMIgom0tFyKFt1MR/0OXBE7sbgRMSiy9ta70Om0hMNBiopiFBUVEQ6H+f3G\n", - "jYwcPIjbZiPk8yETRQzp6QTlcub94Afj5PP7/TQ2NNDX2Ul5cToj9jEGBnoAgdmzS8nJrqHlgw+Y\n", - "f/438NAhBhYtIi8vb9w5p5qptIz0ADdKkhQWBOElQRBqJElqnEJ5gERAp9utoajoD7EcKSlm3O5E\n", - "QOdNN60ed4xKpeKuBx7AuXYtzc3NHH1xC1FvlO7uMSRJTne3ix3bPsaMkdkl8/B6PQwOdCOLp9E9\n", - "2kTTf/wMTzibWUWVpGizqd/ZgrWji4H778VgMlGo16MsjfPWR2+jcASZqcnBH3Ljsg4x0pdKzKNA\n", - "UsgozMxEIZeTaTBw6PAHOGePYjSm4XSOkZo6i1gshkwmIJOJiKKceFyNw+EgLy+Pe+9dz/r1EeLx\n", - "OCqV6orO0uhsbib7vGh0QRDIUCjo6eqaMGXE7Xbz0/9+FYW4AJNGhyBTEheK8IXb0cpcaOQFmNRG\n", - "SopnsKvhfQpNM/CHUmlv97D1o39GHQetqMfq8NOhOIJtoIs8MUBWXCQ2GiDiO4azxE6JXM577e3M\n", - "XbaMvXuPoVYXotMZcbttiOIIt976ALFYjGAwiFqtTlpIJpl4HF59FbZs+eLnuPFGePhhsNshLW3i\n", - "ZEvyxfif//ktfn8eWVlVDA3twWhci883xujoEXJyFtHefhiVagSdrhSFopRjx7bw85//mjVrliFJ\n", - "EQDy8meQlV1M1oxj7NixDX8oSl3dccJhH0qlndtuexaA0dFR9m3dSkUgQGkggFomwylJ9AwPs/3N\n", - "N1n/8MPMOSsq2uVysfEXv0AzNkaGXo8vFCISiXDf/fcza9YsFAoFr7/0ErlG4zn3JIoiqaKIpbc3\n", - "qYycjSRJI2f9GAGiUyXL2SQCOhN1P4JBHz09rQwPDxONBklJyb6gMnIas9nMyIidri4bWu0czOZM\n", - "ANzuMdo69pNv0FJVEGHIYsGsUiGXaem264nH45SozBCXkWbIwOoc5f1dTexp/AlzFs1BO9JF2GEn\n", - "LzBEAAUyHKRqZBRlV9DX04IhtRIQicZiKORyDCkpVKQbaGupY8n1d6BWqwiHfXi9LsrKchFFEUmS\n", - "iMeD59Q4USgUtLS0sH/bNqyDg6RlZ3P9mjVUV1df1mc+0ag0GnzR8a9T5JSidTF8Ph/t7e0E/H5y\n", - "8/IoLCy8qEtHkiQ2bdrEqFWOJiIixEOo1Qpi8QhyWTGjnn0U5FQQjUm0WPrQKNOpyqumsa2PlpOH\n", - "CHpMmFVKDAYtRl0eHo8La8/7iJlZdPn8ZGpNpGt0mGMxnGNj1BQW0tXayp/8yQMcOHCUwcEeCgvl\n", - "zJmzlI6OzlOpfFG0Wjlr1ixm8eJF07bw0dXGvn1gMsFZYQOfG7UaVq+GzZvh0UcnTrZrDY/Hw6FD\n", - "R2hp6SUlRct1181jxowZl3x8MBhk8+aP2Lx5HxrN9Vite4hGdWi1atRqE7GYiN/vIRg0IpdLSJIS\n", - "iKFWp9DTEyYQCKDRBPB4nKSkmJHLFeTklBKL/Z709BkoFDrKyyvIzU1jy5YDzJw5k23bthEaHEQf\n", - "j6OSy1FrtRQplQT8foZ8PvZ8+CGzZ89GEAT8fj///R//Qecnn2DW6yksLGRuZSVZwK733jvzrVZp\n", - "NIQjkXH3F5UkFEolAwMDeL1e0tPTSZsm2u+Ux4wIgjAHyJAkqWWqZQHIzs4kEmkmGPSxa9eHBAJG\n", - "tNpC7HYL9fX9fPLJLlatWnHR43t6LITDOjIzM5EkGBzow2uzIUa1DNtdnKivRwHIU1MJRaPYw5Cn\n", - "M5BlMNBpHaapdz9uqxOloMYXirProw48Y82UqtzMlMuJht2EQlr8Kj3Dg0P0e+1Eh50srDq3ampV\n", - "1QyCfi+9vYcwGBS0tu6ivHwuVVUzkCSJgYFWamoKzkkVazh+nB0vv8zM9HRmFxbi9Hj4+MUXCT34\n", - "ILXzr5wUseo5c3hr717yolEU8sQrHgiFsAG3VVVd8Jienh7effFFDOEwCuBIPE727Nnc/cADyOVy\n", - "QqEQTqcTnU5HSkoK27Z9wvvvH0AQjQQFFRG/G7fPgyCIBCMQIUQ4EsCk03C4tZFso4nu/j6GHO04\n", - "QyE0zMAT9KMVPAj6bILuMJqIQGVUwhONMuLoY1SbSoUmm66RERbNmoXfYsFsNlNTU0Fzcw+jo2p2\n", - "7nydrq5RVqy4laKiUoJBH2+9lahRsmTJhYvctbW1Ub9/Pz63m+KqKhYsXozxvFULAokLAAAgAElE\n", - "QVRUkkvn5ZcTLpovy/r18N57SWXki+JyuXj++Y14PAZMpnxcrgAbNnzAbbeNsGLFss88XpIkXnnl\n", - "LZqbvRiNxcTjeQSDUZxOF3p9EKVSiUIhw+sdIhyW43A4CAbHCIXaSU2FlJRcWlp6+PrX7+a//uvX\n", - "7N1rw+32M9TXgErKZYZeT5QwzoE+Cgvz8HpNbNz4Mnvee5c0uZxgKIRRknC53Sg1GuKxGDFg/9at\n", - "RCMRZi1eTFdTE4M7drAyI4NBr5eje/bwyf793LJ6NaJSydDQEEVFRcyqreX3hw+Te1ZihS8YZDAS\n", - "IbhnDxGrFa0o4o7HKV+wgFvuvBO5fGrVgSm9uiAIqcBPgAu2lXruuefO/H/VqlWsWrXqsstUVlZG\n", - "Xt5e9u37EJ/PQGpqGR6PA6NRy8KFK/j446PU1s696Mc7Ly+DSKQDAJdrDK/VRqpGg0urRSaLEJLL\n", - "6RwcZDAYQZLLUGjDGLVmhj0uuvrrSA95mS3LJi6G8Pr7sHt16GSZeEJuIn43mkiMgfgAdlIJBdMJ\n", - "RjLwBqFnUOC1HQdZUFmA3W6n2+3msb/4C0wmEy6Xi+bmNpqbBxkebiAe91Ndnc/dd992Ru54PM7e\n", - "Dz9kbnY2KdpE9YtUg4G5CgV7t2xhzty5yGSyxLm7u5EkiZKSkgvG0Ew1hYWFLLztNvZv2YJZkpCA\n", - "Mbmc1ffdR+pZhedOE4lEeO93v2OWXn+m2JAkSdQ3NHC0tJRoJELdtm2oolFCkkRmeTnHm63U1t7G\n", - "iRO/QtSmYvM40URjyGVxggyRovTjdR9myJaKOj5MkbKQ/qEeQuEociEDhTwLcCNTB/F6hkgTNUQk\n", - "Ea/bisvvJozE0Z4ACoWcgpoawqeyszweDxs3biEtrRalUs2hQ40IUjEff7ibZSsjpKWlYzSWsW1b\n", - "HQsXLhjnstmzaxdHN2+mzGQiU6VicPduXjpyhK/+8R9ftn5JVzOBQMJFc17dqi/E7bfDn/85hMOg\n", - "VH75811r7NtXh8djJD+/EgC93oTRmM7WrfuprZ1LSsr4FNizGRwcpL3dTlnZ9ZSW9nDy5CAgEg4P\n", - "MjCgQafTUVychtvtxe/vIyXFRDTagF4vUly8lKNHG6ipmU8wGEQQtBQUzGbM6cFuGUBAj1qpwqTX\n", - "4w8F2bV1KxDk6AcHMcshLIrYJAl7IIBKkggEgwwBgigijYwgGxpi98svM9rfT77BQEN/P+GxMYoA\n", - "RzBIw65deNPSWDA4iF6vp7S0lDlr17J/xw7MkkQccCsUKFJSMI2NUX7KVR2Pxzl26BD709JYvnLl\n", - "5Ryez2QqA1jlwEvA/5Ik6YLlQc9WRiYLuVzOY489xNGjf0s8rmBsrJ2cnDSqqxei0+mx2w0MDg5e\n", - "VBlZvHgxRuPH2GwWnDYP0YCHbmsXStFLimwEly+GR9IgxbUYZAEMSg3DgWGcQy4KpQCpcgNaUUE0\n", - "HkEdFokKLmRqMz5RT5fbxwylDnU0RCgikqbJYEwtkq2SIw/K+GBPF9bORgqNBrILCtj15pusfegh\n", - "amtrqa2txefz4XA40Ol04yZlr9dLxOMh5bxUY71Gg2Sz4fF4aG1pYd9773HaqLdXEFi0bh03LF9+\n", - "OYbiS3HD8uVU19TQ09ODKIqUlpZe9GNksVhQBQKYMjKQJImRkRE6Oy3Yxtzsbv1/zCnIZWlFBSqF\n", - "gng8zkf79tFpM3HzLauprZ3F7t170KrTiQtRvKFhMjW9rCk2MBQMMBYc5Ia8dHqcw/R6XWQaZkNg\n", - "gEAsTKZWi0quR4o5MeijjHrG6AvJcIrZaAQjxAU2t7tYl+cho7+fmhUraGvrADLQaPS0tx1mqLOF\n", - "HG01kTE7O199FXVqKjm5uUQVQwwNDZF/Vg0Dj8fDoY8/5vrCwjMWI4NOR1t/Pwf27OGWO+6YjKG5\n", - "qnjjDVi4ECYiDCkrCyorE11816798ue71jh5spP09HNdynK5AklKfLMrKys/9Xin04kgJBYjS5bc\n", - "QFfXBgYGYsTjIm53O5JkpqqqHKczQCTix2SqRKHQIIpqnM4xgsFGzOblvPfedrKyatHrTezdsYPq\n", - "wnLa+jy0D4yysFJHJBrFbbGQmSFSlqKhNjub10ZHcbpclMtkaOVyRsJh3LEYBaEQpSoV3q4uOsbG\n", - "yIhGCWRn02exMEOSUAgC+lgMS3c3w/39vP+rX1GXlUV6aSnr77+f2fPmYbFYkMlkmEwm3nr+ecrO\n", - "+saLosjM3FyO7tnDshUrptS1O5WWkQeAhcD/d+oBfF+SpANTKM8ZdDodCxfOo7Iyi5SU1HNWl5IU\n", - "QXmRZYvH48Hr9bJiRRUnTjgY6u9H8tspMkCGLsrcnELebBzFpDagMqgozszBpKlkx7GPkYsjaGJx\n", - "IjEfUZSkaFQEIhEMMQmL145OJ0OjLaY94sURdBFQGAmlGClMzSEccCCqQeN1ojYbWbNuBampqfiC\n", - "QT5+4w3KZ8xArVaj0+ku2gdHo9EQk8kIRyIoz8rMiMZiRAUBl8vF9k2bKNZq0arVZKemIkkSBz/4\n", - "gOLS0mkZEGU2mzGbzZ+5XzQa5fQIt7d30NjYh1abgVymob1xL+neIB1qNSl6PTlpaVTm5fHJyTb8\n", - "fj+rV99HNOCk9eBu4tEQFXkidy1aiEmt5nBHB0d8PhYsnIP9eCsxuxKZQoEuriAQaCcmFuIKKHGF\n", - "/bhjI9QUptHnMWGW5RAOBvGGQqSmlLG/2UHtunyuW7aMjRs34XJFMRpdDDQdJFutQCbFUAR95Bu1\n", - "ROJxlNEwYtjJh++8wxNPP33mAzM0NIQhHj+jiJymICOD4ydPQlIZ+dz84hfw7W9P3PnuuSdRPC2p\n", - "jHx+1GoVoVAYtfrcb9ynfbPPxmAwIEmJEuoymZy0tEKMxhwcDht6vYfCwiw8nkGKi0WWLfsmH320\n", - "Ga/XjEIhA0aBOJs2vYdcnsqcOYkcbb/fj0rQoFQMMuLwEQhl0z80gCziJCfVSLqQglImY15BAdvd\n", - "bnoFAVk0Sns8ToVazSyDgVyTiUyzGafXy6DNRkSr/f/Ze9Mgy67yTPdZez7zmPNUWVmTai6NJSGE\n", - "LAaBEYMBmbERzbVN+7a5jW+4o319u23HdUSHHURHd1/7hruxAhBtSRYCJIQlNKDSrJKqpJqHrJwz\n", - "T2aek3nmcZ893x9VFJIlhDAIYdDzK/NErL3OWStzn3ev7/vej4jrYigKEufNMwPPYzQSIWRZvG1k\n", - "hPlcju/ccQe3fOELF3NCVlZW0IR4heAwNA2r03nT7QHezATWO4E736z5fxLj4/18/esPMTCwlYGB\n", - "MZLJHhqNMrGYw+hLGtE1m02OHz/Bk48/w9q5U2zt7SGtqqSUNQTncPwKSSPKlcN9VEyH4cQE3ZrF\n", - "+Mad6JEIeirFFusKIh2Z/naD/GKeTuDhBTIELk3PoUWVy3sm0DsBppslZ9bwVR1NgYWFwwR4CC2K\n", - "7rpEwvGLpx4RwyDquuRyuZ+YxKWqKruvvprTTzzB7tFR5At+KadzOS655hru/da3mD10iCAexwkC\n", - "LMPguv376dc0Jk+detPEiOu6TE5OcubMDLqusXv3JYy/pJztx9FqtThz5izVaoN0Ok4lCMjl8zz4\n", - "9BGE2kNWMrE8Fw+Z06enWTt3inRvFiWb5bprrkERZZ5++gG6XZtm0yGqOFw/mGDrpkGSF9x4fcMg\n", - "ZNts2rqVDZs2UftfD+E36wzFksw2HWx7hpZlYRglDENQdQRGOIIeCiH8OGOhEGMDAyw7DdRQjP/6\n", - "X7/G8nKV06eLHDt2jlGvyeb+DIfOnCVBiHDIwJcF8yunuOX9u+murrK6unpxbzRNw36VKinLcTDC\n", - "r2ZM/xavxdQUTE7CB3+Odjyf+MR5r5G//uu3QjU/jnq9zrFjJ1hdLTEwkGHv3t0kk0muvnoPd9/9\n", - "PL4/wdpaDtd1CYUMEgn3Fc3lXo2RkRFGRiKsrExjmiaGMUQkMoCue2zefAm+L0ilehBiActq09u7\n", - "maGhLL7v0WxmKBRUjhxp4vtLrK1FyaQiVAsFpFIJRUCxcpSHDy/QajUZ0UwmYvuRRIzlSoWoJLE7\n", - "myU+OEi1VqNZqbA3GiWuafgXkvF39fdzeGEBv16nJ5FAkmUWSyVM26YvHGa52WRyeZn3CsHGgQGe\n", - "np3lwe9/H6fTIZ5KsXnbNmxVpWvbGC/54ypUKgxt3PimV+G96Qmsv2wEQcBDDz3KE09MAikOH57E\n", - "dQ+SyQg2bRrg93//sxc9HdbX17n11m+yvh5QOP4iGw2DYm2ZK67cScP1ea7RJJrZTrnr8tBMFUOu\n", - "M7dmouhJ4o5DuNulurSEHgqRifSy1miihAaRbAcvaFN1Tea9BkPpHsJSCFd3KLbKBNEsQWcOc2mZ\n", - "fqHiShL59jIN2WNtvsPCwsLFjrs+vObRm+d5NBoNDMPguhtuoNvt8szhw0QlibbvM3H55QyOjvLo\n", - "N77BZfE4fRdOGqqmyRMHD7Jvzx4c26bZbHLsyBFy09PE02n2XHHF67oB/Cy4rssdd3ybM2eqxOOD\n", - "eF6X5577R975zl28613X/9hxKysrfPWr36bbjaPrMbrdOQqFGvcemcSqRIhHY5xeLdGRSxjlIptk\n", - "lVDgM2RZlBYXebDTwXQ1OsUuodAwitJLrnOGF9QKSdfl0OQ8+VoFLarT6na556FH2dw/wObhOLNL\n", - "grOLebQgYFiP0o4Itm8dxysXWZ1fJKyrrLerkNnA/m37qLdaGHqEb33rAXbseBdjYxtotY6yuFhh\n", - "ZXWdiV3byUjL2IpM2zdx3Q6bBiLs3TTOyeVlWq3Wxc89MjICqRTr1Sq9F/bR932m1te58qfp7vYW\n", - "ANx6K9xyy89XNIyNwbZt5w3Q3jqoeiX5fJ5bb70bx8kQDic5ezbHk08e43d+52Ps27eXAwee5N57\n", - "b0OIYYQAWV7nE594++sKPwgh+MxnPsp99z3Eww8/T73uI4SD53U4fXqVTsem3V5jYKBILFbE8ybI\n", - "ZkdYXp5mYeEMIyNj9PQM0O2eZHLyDEG5zLbhISrAUqnMYHgQ/Ay2aGH5DQq5PCOxEPlOB991ma7X\n", - "6XddMvE4cVlmtV4niEYZvXCaLQORnh6C/n5OHz9Ov2kyqOv0qCpxTWOl06G1vs4jzz+P2enw4uQk\n", - "tXyefdu2ke92Ofb44wzt2sWLR46wOZUiHomwXq2yaNt89D3veWM37nXwlhj5JywuLvLQQ0cZG9vP\n", - "+HiYybNHmDn8MMryCmZngf/j5vtJjY7xoU99nGbLJQhGkIMcY9EEyVCM5cUz3Pm1b+CLNH1SlCAW\n", - "IZscZi6X42T+BQxRoy88QCaRIKwbROwuLyydZnhTlIJIEYk7aJZNpVGnEo8Qjm8impBwkymcwCcy\n", - "Nkx4eYHk1LOkRBhEFtWXyXgOhcBkra7w8MPP8/73q8RTKbq6flEUvFR4hEIhjh8/wT33/IBisYGi\n", - "CK6//jJ+8zffy7XXX0+9XieRSJBIJPiHr32N3Rs2sH7y5MV1SoVChCoVzuTz3DQwwN//7d8SbTTo\n", - "SyZp5fN854UXeMfNN7P3n2tJ+To4c+YMZ87U2LjxCgB836PdjvHQQ4fYs2fHyxxMf0gQBHzzm/ej\n", - "61vo6+u5sC7DPPfc86RH3s6aVMfTE0SNDaxPPsioEqIjPMKSIBYKIbpdjpybIrLvQ/zmTZ+gVCri\n", - "uh7Z5Ac4fui73Hm6BV2dmLEBr1nA9Du86K2y2pDxu3WmV2axpChROYocNZmIOVhzRfZkMniaQqFd\n", - "IxEapNla49ziNLmWRaP4AlkRMLO4gpbOYgxvYc+eDTyXf5q19bO8be9mUp5LLBrlxeU2XUXw7Qcf\n", - "pCwE+z3v4meXZZnf+sxn+M43vkFucRENqAMT+/e/ofv0q4htw223wVNP/fyv/alPwR13vCVGXo37\n", - "7nsERdlIX995H6h0up9KpcB3v/sIn/zkh6jX4aab/hWdjoWqKmQyGRYWjnL27Fl27tz5smsVCgWe\n", - "e+5FVlbWGRrqZf/+ywiCgJDsMt6jUMgt4fspWi2JdruLJMWwbYd6PY4kNUgkLBanvou5OsNOI47c\n", - "slgqvUAg1SmtrCHZIQ62qnS9FrJk0aP102xVuWTrTsxGkzOlKfYO9+MFAYuShJlIsHFoiHQ0SsX3\n", - "aZfLnKjXqRUKeEs5qrbDxuvezud+/9/wV//hP1CfmqIvHKbRaDDT7RIKhQh1OiycOEFEVUkXiwS5\n", - "HNrWrQwNDzPQ6XByepobPvMZjh08yGypxODmzfz2dde9oufNm8FbYuQlzMzM8Fd/9f9x7pzMuXMH\n", - "SSZlROk4V/UPcSyXwyoucmmyl8nJRe7+L/+TFT/go5/8E7qdBvEAcrPHidgWTQsSmTR+u8nRlRzV\n", - "to4sD6FLLWQ5x3JzhWQuymA2g+uV2D5ikC9VaZdrdCyHittCSW1gYtvbaTRWsOQ6w9d9CFXViUaT\n", - "lL7yx/SmU3TMGJ4r8IOAntAIrl1lutEgm4pw54MHGN67nctvuIHv33sv6+UyC8tVZDkOODhOlUcf\n", - "Pkqr2UMsOUQsHubs2R9QLJb4vd/73MsSdDvNJhv6+7HrdRaWlkgZBkIIitUq49dfT35piXS7zaYL\n", - "4atMPE6vZfHEffdxyfbtr+nt8bNw/Pg5ksnzCZpLS1OcPn0C2xY0GgVuu+1OvvjFV9rsr6+vU6k4\n", - "jIz8SKjU6yV0fRDf1xkYybC+cI5Io02mmadKAyWRIhELMdtuIykKQjUIR+L84KFvUSuuk+gdIpGM\n", - "0fEHCckS2wYSmLbNfFcikurjio39rIdirNXLNKwCshSl7Xi43QpurcFEYFPxfVqWCnKIartBux1w\n", - "rPoimYTE7liCED20Kg2s0hy1lWVC2y/jmvd9BmftOXqGB5g+epRSPk/bdbk+m8XsdEik0zzyzW+S\n", - "+sIXGLjQkLG/v5/f/cM/ZGFhAdM06e/vp7e39w3Zn19l7rvv/AnGli0//2vffDP8yZ9AqwWv0kn+\n", - "15ZWq0UuV2F09OWGLul0P4uL05w8eZIgSJLJ9LzMOC6ZHOXo0TMvEyPz8/N89avfRVGGiMc3cOJE\n", - "mccf/zvifpF9PT28e8MGQs02f3PvA7jSFjKZCTxvif7+Hnp7t7Ow8CC6OsXutIbrj6IoKSyrjr1+\n", - "iqYWYiQcp+EFqIFLwddxvRhzZYESBCwXc2wdHqFQzPDE+johXWfZdfnIu9/DgSPTlFe6tKwk+foa\n", - "cavBTPXM+XbQmQGu8AZ4/PFDbN67l3qtRjIWw0il8FZW8IOAfl2n4fucmp5lixHBzFd44J77+K1P\n", - "3Ew8Hkctl4nH43zmd3/3Dd0rz/M4euQIJ55/Hsey2LpnD5fv3/+aY94SIxfI5/Pcdtv9eF4fyWSE\n", - "WGyQxbln6G+sU+mC0+iQ7ushEU2ScGwWmy2q+SWevvu/EYRjNJeniXbqGJJMtd1gONTECxnE1DRr\n", - "LQ1dDWgHsHdsJxuHRlksHGbHhijRUJa/ufseYi2frJvGcSAhJjAtj24HarU09foZvvvd/5d9+24g\n", - "lUoh+S2MaBzHCWE5Dogwlge+UOgqfZy2PRSyLB+Z49TBF9g02Eu11KbsyyRHtxNoGQ498zCOM8rE\n", - "4AaKxQarKy1iiQi33nofN930npcp5Q2XXEL+ySfZvW8fawMDFJaXcV2XeDbLp2+5hTu/8hWu+idf\n", - "aCFdJ+S65PP5iyGjnzeKIuP7Pvn8PC+8cJJEYgeRSBjPy3H2bId7772fj3/8Iy8bEwQBP0yb6Hbb\n", - "mGYb2+4ixPlmZxGxzqhbQieKpMRI2GV0ucvYxp0MJxII4LGnnyX37MMMa72EPcHa1BTPdUoE4e3U\n", - "RZsTroMmy2iRFKZl8szUGWrNMu1WG8MfxCaMKnQMqZfZxguEgzYrbQlH9BOOZokZ0GzM0jErZEUE\n", - "SUmxWMqhx9IQxMnKEebOTFJvVbn5Y28n3dvL1i1bOPQ/b0XpatwztcauzSO8/7LLaFsWzz72GB/9\n", - "1KcuroGqqj+VEdRbvJK/+zv4vd97Y67d0wNXX31e8Lxk237tOd/gLSAIgpeFXc7/HlzIeXhlOEYI\n", - "Cc/7Ua6U67r8xV/8F44ezQEyGzdu48orr6VcUGg3C3zwQuPRt+3czgMHT7NQbpPJgGvHsWttCtUX\n", - "aTU7dESeeKqPgl1hdfUcVqdOGI2iabOGjO70IUkuspNDFv043X66IozZGeLFc7OMDwo+dOONCODb\n", - "hw7x1Mkc5WaWtu9SqU2z0RNkAw2BQsWV6ZRqPPfIvXjeh7juuu2cmJtDchz6+vvZfOmlvPDYYyy3\n", - "WpTbFpaI4AUxrI5Crd3iwIFnef/73/mKtXs1bNtmenqaWrVKtqeHiYmJn8qDJAgCvvftb7N25Aib\n", - "entRFIXcE08wfeq1DdbfEiMXeP75I6jqMBMTCvn8YWCAkBHCLQWsFVaRJRtNjXNwrcRSXaLl64SD\n", - "QdZyOS7fvofDxRwDwHg0SUOXOVWcRhraTa3i4ephdDWBrzSZWi7TtWqoqkrbbHPw2aexSm2G5GGa\n", - "VhUvSBEKZ7AaRaaOPIhPHzG9l9bCPI8s/S8mdu2kJSTOFtdImipaoOJLbWzCFJCxHZvB4XeynnuW\n", - "eGuVjZE4S88fo4HPRHaQ1ZPP0rKgXm+iGztZKdZARNAROLbBwkKXP/3T/4c/+7P/m+HhYYQQXH7V\n", - "Vdx+9CjTq6sMZTKokQiz5TLXvf3t9PX1oWkajue9rAoHwAuCN9RI59JLd3DixA9YXCwTiUygqmE8\n", - "z0GSLHbuvIYTJ47w7ndXsG2bQqGAruts2LCBSMTn8LPfwyouYwCdIGBtdZWxjVcQ6bbZeMk25ucn\n", - "EXILW1cZ1FRmCgWSoRDHCgVMBCPI6F2BKing6niey1Rjhv74ED2eh2nZ1KwOa16DUaPJoKdge734\n", - "TosWJfLE0EjikmKVOkOej6+7mKbA8VtUghCqvgvfWWSpVqPsa1ADVY2y0l3Fo0omKKPNDbE8N8cP\n", - "jp/G98bYuWMPqmYwuTDJka/dw/W7R5EqlZeJkbf42ZifhyNH4LvffePm+PSn4fbb3xIjLyUcDrN1\n", - "6xDz8wv09/8oSX19fZHNmwfYtm0b99//PI5jo6o/SuSpVpe48carLv7+B3/wf3L33S+gaeddTRcX\n", - "j3L8+GFS0SSjcZtGp0MiEsHQNMYHUqzWYni2ilKvMBCJ07XaeIpNZSVH2Q4QwsA0AwIvi6wrqFab\n", - "WtcjKZUZcWx6SOIGIdp+kXnfJDA1uq7NysIMP3jCp3d0lKLt8vzhc2SlMKbTIe6uMSx0RGCgCJ8E\n", - "MvOeg1Pt8MTD95KfSjGejbNSLJJuNpEMAzeRQEmlia7LOFJAxa7SLxuYZoelpSpnZ2YIBgZeMyRT\n", - "Lpf55le/ilqrEZEkTnkezwwNcfNnP/sTfVp+yMrKCrljx7h6fPyi8LlkZISTi4uvOe4tMXKB1dUS\n", - "0egwkUiC8fFF5ueP4wmJYreFLLWI6R6zbYuOO4TjtRmLZfBci3JQ44kTT7FTkuh0W8x1AgYG+9ml\n", - "6DxZWMB0N+CKeazSMwRmncAS1MpFOkGdWyfbpHWdwDJwVJB8CcttYZrrBG4H4ZUZzGzCoU696xNT\n", - "L+H4wSppI0rDVJBwGZZDmK5DSVSxQ0OAw/LCGZLlc+wdHiUajtByFAY1n5VmjY4dUA76cO0EbXsa\n", - "PzJGNtmDaXUolYoIyebQoSpf/vLfc9112/mt37qJeDzOp77wBQ4fPMjk6dOEYjGuvfFGdu3aBcDu\n", - "q6/m3IMPsvclJyDr1SoilXpDY5Fbtmzh6qtnefrpJ4nHM3S7BYKgxb59m4lEIpRKYb5z1110lpdJ\n", - "CoEVBDwaiWAoCu7sM4zGhjG0MJ1uk65cZXnpCWrFGvONNp6XQJZ7aHlhzhQrtK0iVjaLvmUL2aqJ\n", - "VISuvUzHl1ECj35DsNRaQ3XjBJLAdQMkN04sWCHlyPiA5HqoCELoNOkCPhpx6oRR0ejxbGrBMmuE\n", - "qYhRJClMy/dxTUE6sgvP7YKwaLoZYobHJSMbaK6vMze7Qmu+TEka4IyzRK5aQ/YjeEEP3370DK7y\n", - "HGo4zI0f+hC7du9+w8Jmvy7ceut5l9QLRVNvCB/+MPzBH8D6OrwVRfsRN930br761btYXKyhqnEc\n", - "p0Eq5fCBD3ycdDrN+953Fd///mFUtR9F0Wi3C+zYkb4Yonn66af53vdOEolch2EM4romtdp5QbJm\n", - "lClGNO5/9ggfu34/mqryvv17eer0I5TzPuOxLMvFWebWZnD8AAONU9UlUrEMY2P7KK2XaTTXaAgX\n", - "VdHpxUURKrYnIXAIBx3GWCVo1OkjQNh1jh49SqzZ5PCRU/S5CQbVBOu+TwaBHLTwCBN4BooaIeE3\n", - "WLEaBLhEVlvc8qk/ZHp5mZm5OQ7Nz5Pauxf7xBkIIoz09LFYnKLeKSHpMSp1k6cWc/zZl76E67rM\n", - "zMzgui7Dw8MvC8k/8O1vM2BZjLzEOOfcygqPP/IIH/jIR16xH69GPp8nJUmvOIEZ+Ammim+JkQuM\n", - "jPRy5EiZaDTJnj3XMDS0wvLyAqdaYQayCdZOnmW15REIGVtS0CWJGgH9A+PkFubY1ZNkpegQi4Ro\n", - "NZsMjqaIrxdx5HOkfINau0vSAU3rwwskUkqYRnueptOk7mlkPEEgEghh4toOrmgjJAnVmsXorhNF\n", - "p2bOo/o6pmeQ8McpsIQfeMhKhIhsEPfyIHoJNRcZ1UPUyyVajSaB6+G4Ft1Wm6bWSzg8yGBUMFPz\n", - "6Dp1bKdKrWnieEUkuUit5DEzvYIQKps3n2LPnvOOs+9673t513vf+4q1u+rqq1ldXOS5yUkSQBfo\n", - "RiJ89LOfvXC0+uq0Wi0ajQaJROLH+p+8FoVCAU14jPcrNLozbJjYx+joDqLR8/1+CvlJeto+b9u2\n", - "7eL7yJdK/P2DD/I7N93I+nqRdrsLhNG9GFqrxanmOuluP5LQUSWFIAhR7hqU4xJf/NznuP/+x1hY\n", - "XGNcjCLLCqZVJyJDIhJF7ywTsmcIeVFaVpeWCND9NsJ1SUsKnSCKTJQAiXvETYMAACAASURBVDAm\n", - "Jh4eDkmi+OisEaMYdFlnEM3YRMAZLC2OZ0UJOV1EYGEHdUDCsRNMnX4BbzlBx1eIBWFKQYelSptu\n", - "O8pQOknbqiGbDS5JZ5i653tkLYuThw/zyc9/HuON/Cb9FcZx4KtfhQMH3th5otHzjqzf/OZ5UfIW\n", - "50mlUnzxi59namqKYrFMNnsJW7ZsuSiwr732GjZsGOXkybNYlsO2bdezefPmi2Wrt912J6aZRQib\n", - "bjeP41TwPBUhtuE4eVw/xSMvLhAJS7z7sssQQvAbv7GVU0eXyNeLLORzaF4fvaqH7ankRBm72Uao\n", - "a0RTcRZthWhqG5HCHGq3iiaiBAIUCVSvTFoIGpJESpJQJInJpknt1Fm2dTtEZZV1a5F2YJHFO/8A\n", - "g4aMhOd6+CjUhEDtmkS889bvm4aG2Do6SrXVYtkweGA2x7pVpt/UkCIZipEMsfRmqo0cH33XdRQK\n", - "Bb7+N39DryzTbbWYKxYZ37ePD//2b5NMJqksLbH9JdYVABP9/Txz7BjOBz7wurqDG4bxqhYCpmW9\n", - "5ri3xMgFrrrqMg4fvoNqNUoq1Uc63Y9ltfjUv/4kV1y+i7/+8peZvv8oitfE92yWbIu+4X4828FQ\n", - "QzStDlFVJSxJ0O1y9PRpih585O0fY2lxitP1WTKeQr2zjCVieCIg5MvUfYcWGmVhkfFDBAR0abAa\n", - "NOgRGj3dLu3ARPPCxHFxqdPx+shgUCdOJKiSCifxdY+o0FkTCkM9WdJOCLuyil2uEeDje108T6dE\n", - "QEwShGQfXW3hegbl+jM0ux4SJj1aLzGnh+VTK+SXphgZMdizZ89rrp2qqtz8mc+Qy+VYW1sjHA6z\n", - "adOmH/sE7jgODz74Aw4dmkSIMNBh//6frsvY2bNnefj22xlUVW7cOMyjTx2l4DcZHf0kjmOzsnKG\n", - "qNRm58gWOhcMfaLRKDHDIG7btF2XzZs3sVws8viBAwxpGnFdpyEn8X2HuGuDCZ5wqeBTWrb437/w\n", - "fxGO7SCQ4xQbi0TlDEIYtLwGS9Yqm2WJqzM6SizEYqFJnxUwZ7vI+PSgUKRFFwkXHRvwMdHooBNC\n", - "oY0e6HQCBUW4ePYU4bjAMELU6yHybgPhd9FCPYSsGqJbB7eDFEoykE7R6rTwfYmKDbpsUGhWUZ05\n", - "9iXTbOkfZ6U8RZ9hUMnlOHbkCPuvueanWu+3OM8//iNs3gyXXPLGz/XpT8Nf/MVbYuSHBEHA8vIy\n", - "xWKRSCTCtdde86pfjsPDwy9zHv4hR48e49ixBXw/STw+TLW6iGm20bQJgsBG0wK0iMxyOc7XH5zn\n", - "qTN5YlGPq/buZl4u0SrNMSiPMxg20AhodVWmPIk5OWC902B8aDPR1A58q0TYLKKYM+hKgJAEllMn\n", - "E9g0CPB9D1eysUUfSWsN3VVIC52w3yEdwDQ+TXwCVCJ0MYhhBV1ydDHdISRpDavb4Rtfv41UJs3E\n", - "8DBaPM6MUIn1jXB6vo4fHyadmWCDHqNWW0RRm9xzz6N8+S/vIK5qJLQO+1KC7ek0p+6/n28sLrL1\n", - "bW/j1R4dZUkC38f3/de1T5s2beIxw6DabJK6ENqxHYeldvs1x70lRi6QTCZ53/uu4sCB51hYmERR\n", - "BPv2beY97/kNJEliaNNOoskcqujHth0ss0qrWsNXXFJhWGo0uWJoiEg4TKlSZX01j+T6zJw7garr\n", - "BIGDLemE/SQIB1noeMjYdOhFZSVwqdLCw6aLTSB1ifktPLoEfgQbHWgTxcLBQpHC6L5DmgCz3cF3\n", - "AmzdY2xY4OkylY6J7/p4XhvFM9FkhUU/QFPHsLotmpJDPNZLo92k4xRQkNicvpyYlgUsBgYmmCue\n", - "5eDTz8If/eS7oRCC0dHRlxnC/Th+8IPHOXhwhdHRtyFJMp7n8tRTx1/3Xrmuy6P33MPenh6ioRAA\n", - "8VCIxw6+yAvP/D1bdu3huut28syDJ3nmwAF010WRZYRhsGX3biRZptZscmhygcVVh0IuypzqUgla\n", - "dB2Fqt9LKlhDFT6IFCpJ4sFpbNOmbge4joZDhF7PQRUqzUDGwmG7JgiFw8gEJHQFyekyFQSUkBj3\n", - "JbIIyqyzQogOEj20iTGII8KEVJfhvhiL66vEFAslsPC8zQgxiCxXkNQIgaehCImOUychVUkrYSql\n", - "KqoSomlXcJQRVCOGJmVw3TnGFJ8N/UMECNpdi6efPowvqTyXKzA4PPy69uql1Ot1Dh8+wpkzc3S7\n", - "LQYGeti1aztbt24ldGEfftW59VZ4gwsRLvLud8PnPgezszAx8YuZ85cV27a56657OXt2HSESgEkq\n", - "dYBbbvnYq5bwvxTP8zh69Cj/+T//LaFQFljGdZuEQhEsywY8JClPPK6TSF5ONCYwzdOEYkmMIM/O\n", - "bJaZTAZvagbTk1CEoGo51FyHkDBoo9DwTPIVHc/NMT6mo4V9iKiMREJoQmG1WcLptKkIiaTwiWob\n", - "qHkmGaFiSTq2sEj5LjoBowTMErCMhEGAoEkRgckABikaLHOunaVXDLC22mGlnsM125RSW+jPRvEa\n", - "Mvn649RKR4j5LmHZJ18o0up7B0l9I77ZYTa/SGl9gbErE+xIp+k4DsVTp2grCuVGg0w8fnH9Vi6U\n", - "AL/e8G4oFOJDn/0s991+O3q1igw0JImrP/hB+Mu//LHj3hIjwMmTp7jnngM4jo7vG0QiFp/4xAeY\n", - "uHAHePbZgxw7XOC6nddwfGoa2Y7iqUkWWgsIf4Fr+3VSIyOc8X3M3Ar5ZoeykmBY0SgWbURQp+Za\n", - "xAkRZo0E4PoSdSxa6KQQjGJQQcImjoJCIE/hBSaOa6BjYCMQJBB42Jis+wZZ6kToUvW6VF2Zjf19\n", - "bI6pHKyus9BqE+qY6IGHHO2h5rt0tTQhOUXdNZFjSS698p2srJyiVuvQyTcJSVGEsMlk0wghSGhJ\n", - "aqWVn+taW5bFc8+dZnh4P5J0/uhUlhWGhl7/ycja2hpyp0P0JU36BgcH+fiH+3h0YYF/9b99lG9+\n", - "8x957PFDjFdLbErEyQz1ElYUTj73HPLAAE+cncHu9DOQ2URt5QQ2gnh8gPbSAZQgTky+hMDzCYC2\n", - "X0WnRTiQaNlzxMQECS1D1S3g08GSsyREG0c3mfM8wq6LLSksWYK2b1DEoEODQRzaCHwMNhAhTwtZ\n", - "ctCogy5YDqr09upEG+f3YsE6S8Otk0hEKK1XSCi9SF4TmwqIKm3HxbdtOmvgxuJI9jq269G2NKJa\n", - "g0DyqNRbtO0iHQfS6W1YgUfRFHzlK9/h93//5tftnFutVvkf/+MOarUwk5MF6vUurnuOzZsn2bKl\n", - "j89//mP09fX9VH8L/9IoFuGZZ843xvtFoKrnuwHfcQf8p//0i5nzl5Wnn36Ws2ebbNhw9cXXSqUV\n", - "7rrre/zbf/uvf2yFiO/73H33vRw8uES9PkwmM0wk8i3q9SdR1QF838T3c6RSDrHYTjQtQbW6SkhX\n", - "6DfCGOpGTi/k6UunaSfjnCnVabUTyHICXU/i2F3anSIea/iteTK0qa36yEZAzNCoxxX8doemJlF1\n", - "JIaDgLLr0LIc6lhkZB1JimJLTboBqIGHjiCNzzo+VaLU0fHJoiDoModKGl0fJaZFkOwwC9UOHeEy\n", - "bofYNTDKxniWp178PpniFONDE1TaTQbjm7BbDpXWEhkjSa+apW61eeTEOd67ZxuObTMeDtMeGeHs\n", - "wgL9rRbxUIhKu01Z0/j4q4TnX4uxsTH+zb//9ywtLeG6LkNDQ0R/Qp36jw/ov8EIIQaEEEeEEKYQ\n", - "4k17H/l8nn/4hx+QTO5lZORyxsauRNMu4c4778c0TQBOnpzB7vpY3SZhr0lftEx/vMGmXp3tI1Es\n", - "SWLn0BA7evvQ1SiSkWXr0OU0NZWwKpMQIUBhjRoKNiIQCBxcPOIEeDTwgFEEEbr45DCdNoVA0MbD\n", - "FW081umwRhkTlxYWs1jYTAqFNSMM/b1sHB9jviGjdQYYSV9ON7SNKa+fST9N5JKPoEQNGt0lFOHg\n", - "dlY4duQu4vEaV111DYYuoSgtYnGdwPdotSuomk1vT+Y11++n5XzIREFRXn68qmmvP4dBURS8V3nd\n", - "8310w+DOO7/HyopgW89GvMww657G5PwqS8UiR1dWKXky665B10hzfGWFs9Uyk6trzCxU8fwInj9L\n", - "w52mERRp+fPInGUYh7BvIwc1QEaSFBRZJaIq6LKD0CN0JZloXx8Fz2Ou7iP0Xgylj6y2FYtNrGMQ\n", - "JoROhCI2FTFALhSj3hemHFNJDKT48MQobxvawP7RMW4YGuaKwSxb+sfpT4VwvCnSyjK9SpGk26Xs\n", - "dlkRDjNOC0cK4wgDnHUiYpaN8Ti2olIq5SiUF9iy7XIMI0yh02R8xzWEQuM8/vjB173mTzzxLJaV\n", - "pVbz8f0sw8P7GB5+O8WihW338e1vf/91X+tfKnffDb/5m79Y748fVtW8Sgj+14qDB08wOLjtZa9l\n", - "s0MUCh3W11+1zyoACwsLnDixxsTEleh6mHA4xXXXfZ6JiWEGBlokErPoegFNk1hbW2Jm5jDl8jRd\n", - "0+X0/BqleotWx2bH5s1gGAxETBzJRNNUNE2l4hXxMQkJn8s1h3fEsuxU02xyAxqmSW61gGFkGE4O\n", - "Yjoec26AQ4DpNGk4FvO2Rdtq4UsyDUliTficxqWDYBsdHAJ0xjCIYdBFRsf3PVLpBE1VJe95dI0+\n", - "hNSL8FssrE5i0yYmuwwKQcKrogYuTkdC6ToQmEgCZEkQkuO4ruD08jIDAwP4vs9Afz+f/uIX6bnm\n", - "GpoDA4zccAO3fPGL/6wHDVVVmZiYYOvWrT9RiMCbezJSAW4A7nkT3wNHjpxA0wbR9TCVSgHb7hKL\n", - "panVopw7d45du3Zx/OghKrPPINsOfUiYWgg9PoQsJ4knPYJwmAeWl4kFEus+6LExkqEUZ+QwSiBI\n", - "eIKwCIgGGgVkfBwiSGSJoVCjSoEOTWoYtHBII5MAPBzWyOMFKj0EWLgMoaIhMICqHCETSuJoCjdc\n", - "ug1Z05k+u4ZZb+MJh4ar0pXGke0o86ceZX/fMIutJZa7NQIvS9AQnDlZYHVhmba7Sq4eILfzRKMh\n", - "JoaHaNtttu7aycGDzzE+voH+/v6feb1jsRiGEdDtdjCMH/VDMc3Wa4x6Ob29vRi9vRQqFfpf0n14\n", - "anWVzPg40/M+hmEgVJ1Nmy9ltZxnZnWGZ+eL9AztJeRtpNHMsd6t0inN4bldgiBAshtoAThECTFP\n", - "DJ8EATEENRysQGFYdlj25+nYc/QFLhHJx6fLgl1jWrQJvfgijgddX2NZsukGo6Q8B5cQBRI0KNLC\n", - "xKIHTUSQrBVCbY9o0KY0XeRQMsmwiOA16tRsE8XxsFWboewwpfI8tl0m4vmYgWAwsBkHTgc+K5ZO\n", - "PLmBAdskmtTosowSUVmr15DbGqfm5zheKtK/8zL2DmwkCHzm559/3Wt+6tQs6fQ+Dh9+hmRyEwCK\n", - "ohMEERRFZXW1TqVSeUU36F8l7rgD/viPf7FzXnXVefOzqanzHX1/HQmCAMuyX/EAAyCEgm3bP3bs\n", - "3NwimpbFMAxGRrIsL6+TSvWzYcPVJJM1zp416HbjBEGI2dkpHMcgGvVBGsaxHc4u5dg8HGLz8DCx\n", - "jRuZffYF+kI1Gn6TgmnRAeLhS5HMp1hxNBY9DzuwEL7PmGQRBHCumGPelJHYiA8YdGj6JgYS0EYL\n", - "6lh2gI9LSwh8SSHpB5RQkIiTpoBOhT4EDhoVPGaXX2DP+DWYqRQdU8aq5cD20YIm6ys+5coS8ZCg\n", - "Wa0i6WE8v4jihlEUmXbgIXseptdAV1yWHYfxwUGOFwpcuX072WyWG94Ee/g3s1GeBVhvZstigGq1\n", - "SRDA44//I/W6hxAGllXGMFzGxwX//b9/hRcfOEDWipzPFZDaDKoBS5V5qprLjbv3snXDBmaCgKfv\n", - "exDX1qg3q5yqNQCFlgr5bh1XkenzOuhBEiPQUAAbEw2TPqCXNpO0SaMQR2UIBdAAjSlcVpHZQ0CS\n", - "gBodYijYXptTHZt0qJeGJYjLAasd6Hhp5CBETIvgUqTj1Il6Hfxaka7nklF3kIhm8YFVs0WjUUGo\n", - "gyhaP3gR2l2JF2YmSffYmNb7eOCBWTzved7xjh285z3v/JnaTCuKwrvedRX33PM8fX07iEQStFo1\n", - "1tdPv+5rCCH4wMc/zre+/nXyi4uEJYm67xMbH2fTzp1Mz08RiSQoETCi6mzs38BSpU5au4Te1BiJ\n", - "sc3YgcUTjx0iJA2RDm1HjWnU20tEWKEpNLq2wnDgEUXQwaYBdLEJeza6sBjwQyREhIgvaAc2G+kQ\n", - "C4fIqCrHa200wqQ86GIRFmEMBD5hiqi0SSOIIfmzjPkdNlk6fakwitVldn2dI67PpYksY8keirUG\n", - "J1rLJDIeOgWq3Qw+vdgErNEkxioxP4TvdggFLm6nw6IZoMb62TyUYMXMMddaoze6hdHxSynWuhw9\n", - "eohMJsbg4OuvYAqFNGzbuvCE/lLDKRdZVhBCIvgVfnxfWIBz5+DGG3+x8wpx3hb+e9/79RUjQgh2\n", - "7Jjg3Lkc/f0baDabVCoVHMdG05o/9ql9bW2NSqVIu10HYNeu7dj2cdbWZmm1ylSrk4yO7iWbHeGp\n", - "pw7j+yaq6uF5IQIklis5+uJV5pfb/O0d3+H4YofV8ChhKUYoFCYZ76Uy3cS0CyjBAF16cLw4JiYy\n", - "iyz7NhEq0HIR9GITpkfR8V0HjzWyrDFMQEgI2oHLEhALwApghRhLgIKOTJFLUBBINBEIQnSsKs/O\n", - "HmNwdBedylFG3TYbI/1orsBqVhhyW4Q9nX3RJI6isFJepOyAGpog1dPH4uoZCObp60nhJ5McX1tj\n", - "+/XX/9R5ZD9P/sXnjARBwPT0NMePn8X3A3bv3sqWLVtedwfC8fEhbr/9NlR1B6nUALncKuVyQLn8\n", - "HMePP4XdEuySIhhI1F2brmdQMlfJBw5tLcX9z+S4/4VZ+jcOs2RGWG8WcOwG/QT0CkGPEcdFkBdd\n", - "oiGJSrvCHGEMApI0CeOT5nw5rAXECBjFRgJkQmjIbCDAxiMgRSBKqEBZSChBgCZsYtEUp07P4dQW\n", - "kZpZDDwsIrT9HmQ0JH+Frl9gplWlzQDpkIEky9htE4FH1/FIRUe5dtcm1ms1Cq0WUmQfg4MG4+N7\n", - "kSQJz3N5/PFDbNo0fjGX5qfF931M0+Tyyy9D0zQOHHiOpaUWmUycT3/6Bv7qr17/tfr6+vidL32J\n", - "mZkZmo0GvX19bNiwgbNnzzI/9TSKq7NayuM3q4z1jVFumPT3xqn4/vlutrMzeJZC3XUInDKaJIFw\n", - "SOiDNFvHMQOFSXwS+CSQ2IBKFpc6FlrgksbEl7pUPR8hC/p8lWKnS0OYZBGYSGRRmKFJEEToImPS\n", - "RGEEjSEC2iRwGCaE7EvUKjUMPAZsmyUEjXoVxXFpdNrEAhDOApraT+AkCCHoBTQyLBJgUyNoN/C1\n", - "JsWOjSynsR2bNbnCQHIfpdYL1Jodhn2ftbV5ZmdbZLMaV145yOTkJNu2bfuJ63311Xu4776ThMMK\n", - "Z868gO8LhLDo6zMRQiKd1n+lT0Xuugs++tHzeRy/aD7wAfjyl+GP/ugXP/cvCzfccC3T03fy5JPn\n", - "KBQsHCfAcVbYuTPNuXNT7Nr1I6v3drvNXXfdy+xsmW4Xnn/+IM1mk717r+Xqq6+gXC6xuHiQnp79\n", - "rK3FmZ4u4XkZUqkrgYBm8zSNRo5YupfVEsw9fQRJZIgkdpBMx7CsOp4+ht1pIyjguBaCDCYhBBEk\n", - "VFQmgDUa6HiUiJHAwiVwHUrYpPAunLw6JAMISxIZP2COABOfPDYgI9FBRtBGwgAMfNrUMADdq5Fb\n", - "PEVc5MnGNCpeg6BZp9suMBy4zHcDAiEYjsW4rsfmO6vnMH2bdrfAVTujfPDKjzCdzzO0fz8f/MhH\n", - "XrUC6RfJL7UY+fM///OLP19//fVcf/31dDodcrkccL4L6cMPH+D55xeJRocRQuLYscfZu3eSm2/+\n", - "0Gt6XPyQgYE+bLuLLKusrKxSLLaRJNC0QdrNAnHXwNBM+uNpNL9MudVgOZBRxSB9IopcU1j1k8zl\n", - "S8RFBMVPEg/OsBXQAwmzU6AkzldXPN8OcMigECaDxDwp0uTJ0mUNSAEGAVECLGQEoOOj4hPCw8fH\n", - "DEDgkxYgC5mCJPDy01iORZ/nEqDSIkYTj7bbIMDCwCTGRiwvoBa4hD0XxWlhBx00Q0e3QlimR36l\n", - "juXatM02fT2X4PtNHMdC10PIskI4PMyxY2f+WWLk6JEjHHzkEexWCyUU4rJ3vIMvfel3CX4Gl1Zd\n", - "19mx40eJr9VqlQP33suEX8VqKQz2DnNyZYbJSoGi49KbTVMtVxCVCnFZpz/SR71ZgG6RcDRJQtM5\n", - "V7ZxvR4iZFBxMEUTNcijqiqKUyGNjCMChgPBouchk8TzAjpUsYAgkIni0qbOGnHW0XFRkSgTYCGQ\n", - "EIBEBgWBBvhOCwMXV/KxAJmAsm3jBQ0qeAwJmafX1+kGW+hHBQK6F7Jm0sQoUiISGKxX69SDML2a\n", - "iusUWVtuYScjSCKL25nn8MElQtF9GKEE+/ZdyqZNm7j99gf5d/8uS/YlycCvxpVXXsHhw0d59NEX\n", - "qdfDCHE+x6hcVpidPcB//I9f/JlOzH7Z+e534SW3o18oN9wAn/wkVKtwodnyrx09PT28//1v59Sp\n", - "r9HTkyUWizE4uJtarcif/ul/45ZbPszQUB8vvniW73//MWw7xJVXXs/WrRMYxjCPP/4AnU6F0dFN\n", - "QJUrrhjjscde4Nlna6hqH6bpIYRA00aBNo5TptEwaHQSILLo+mW0rS4hR0NRZIrFF3Gd88FXmxQu\n", - "UTroyJgI2rh4dLBQiOCxgkeVFiod+vGwiVBAxyOFwCDA9300wEPCQkEhSwB4FNDQ0Qnh4dHARKMB\n", - "CAJkMnIDw7cJazpdT8ZsO4SEjhtIBFLA8XyeyVKJcCTC6OgA7775AwS1GqVSnbsOn6N3bJTrL9n5\n", - "ioqkXC7HzLlzAGzauvUN78AOvzxi5FXvYn/+T/77jx07zj33PIbnnU+GabdztFpw2WU3XRQemcwg\n", - "x44d4tJLZ19X/w1Jkrj00stptXQOHDiKYWRIpzN4Xh/tapdkZBPr7VNE/DqSMJDkJoGbxhch2rZE\n", - "w5NIRnpptVRMqUAMizQ6McLYqMxi4gRR/n/y3jRKrvO87/y9d6996a7eV+wgAQIkwX0TBYmylphj\n", - "K7ST2PKS5MxxjhN78iVjz3yanDMzJ2fOaOIkYzlxbDmW4sgKZdESJUILCRIEFxAAAZLYG0Cj9+6q\n", - "7tpv1V3fdz5UCxKGlERTliFK/3PqS9Xtum/f9956n/f//J//U/UcDGIcPFws5hhAZw2TImdYZjfg\n", - "AitImpiYGCgMXCI6KFx0+lHEGASY5KXPOoJ+Cf0hNITo0XxAmxXaGJh0EeTIMIRNjKNimsql3CkT\n", - "eGk6tsFIeoBq6xoD2TFqrTpmHKJ1fa6dO8nEzhQXL56mXC7jOA7FYp4g+MG6EaUUy8vL1Ot1stks\n", - "Y2NjnD51iqNf/CK3DQ+TLhTo+j6nvvpVwjDk4Q984IfO0bvFq0ePknVd7vrgB5ibm+PKlUUOjPaz\n", - "bMP2TJG5c3NQ65JIJFhtVHEDkz5T0a8J6iqk1o0JY4kt0mgqpkNIR2VpksILawR43G8IGtKnpsDA\n", - "wUfhYRFi4KETEAMJBglYYgPIYnEZhU4HmwgHnUEkDh2SeCgc2jQJSUkNE4iBs4QUQ50pzaRt2Sil\n", - "0ElgXlcTBZsyN4VGiIvCxSAWDitxG5sqRA6dRovt2/fR6LQxjVEkGZyiwfbtW0kk0ggxyBtvnOHg\n", - "wR88Dz2m0eKjH/15PM+nWm0ADomERS5Xvt6I76cRa2tw7hw88sjNOX8i0Tv3oUO9oORnFVeuLLBn\n", - "zwcZGBin3a5z9Oiz+H6OTmeSz3/+RVZWFjlw4IMEwU6SyQGOHXuDO+4ImJrazeOP/zLLyy/wxBO3\n", - "U6vVOXToLXbvfoxXX/08ljVIrbaMrvusV14mjhcJQh2lDJRqYhjg+/NIGbGy0iKdThAEPpZsMFXM\n", - "MLPu0Q4lHl2gjiCPgUIjIkOHcSJSuNhABQuTFJIuJoIADQeJhqRMjx0fRpBDwyXa3FiuUadBb2tq\n", - "4VOgS0hHJrF8j5TuoeptErZBPlsk9mJanoeQPntTCbqAcBxWUik++Su/whe+8DRSpPjgXbtxHJvn\n", - "n7/M/PwKv/mb/xAhBM9+4xucP3KEgU0a8Mxzz7H7kUc4+NhjP9YNx00LRoQQBnAI2Ad8Qwjxvyil\n", - "Xvt+x5fLZZ588nkGBw9g2z1Pg9On21y6NM8tt3SvO3gKIUgmhzl3buZdBSMDAwMkEiHDw1PMz1fI\n", - "57dQq63TaJzC0mM64RoxDspv0KelaURtXArkgZyA5ciAjosMXSJWsGjTwiDG5BoakmlGMdhAx6CA\n", - "zzpZFulQQDJMlS4ZoAhEwBopFJIJQgQ6awSsYFMlR5sa/fikSXKSFhEJ0ujo+BRUyAaCRSQpMpi0\n", - "CNAx2YmGJEbSVR4ZobGiVlHaICrOc3XlNI5ZIfQlXjBAXWmkMnnCxgzV2Q4XktsoFrfTbnvMzBxj\n", - "794Hv++19DyPv/zLp7h0aR0h0ijlMjGRplOe547h4eueIAnb5vbxcY698AL33Hff2+rXm80mrVaL\n", - "fD7/rpxZlVIcP36S//iZz5OLDY6fX+SunWPsvXMPzU6H4No1VmurRF6VlYYLcZGkEREG54itScqx\n", - "oNwp48UeJuvkRY51dIQaxBaDhKpKGxOHDEtyli0q5jgGEkiQpQG06cchZJk2A/i00VjGIcEQGiZV\n", - "KnTIIkgSs4JCp84El7nAJBGjCAwMVoABEoygOEPAhMxw3mvjME2LOj55FBYaOpKAiBpZQipU8ZWJ\n", - "rrVBGUiVwdAjtBgqq9ewMiEpp0A3iPE6dYIgQEqJ46So11s/9Bp7nkel0mJi4va3fbaw8Cr1ev2H\n", - "+j28X/G1r8Fjj8HNdNF/7DF49tmf7WDE8wIMo/cbcv78aaJoiEJhJ15xYgAAIABJREFUDClXqFZX\n", - "6et7kJmZFYRIkkjkMYxbOHfuLcbHt5PLFZibU7z88imefPIQqdQ4e/cWuO22vVy6dJFEImRt7QwG\n", - "OpY2iiddoAb0qsekjBAiTRSl0fUtBEGbMK6w3MrSCT1iWkAA7NzcHqxjMESbi9TQaNEihUU/Vcq0\n", - "8YjooFGn97vfBZaBfnQ8HBK4DBBzFWhicQ2NAVI42LTRKOOgEWHRRyX2aChFot1CdQM8Qjoq5o7s\n", - "ELHjowPewAAf2rePJ//iCyixjX37vpvWmpzcy9WrrzE7O4tpmpx74QXunZzsmZ0B01Jy7IUX2LF7\n", - "949VU3IzBawR8KF3e/xbb51D1wevByIAyWQGKe2eLe62bdfflzLGNN/dv5ZMJvnQh+7ia187hZQt\n", - "zp49jut2kHKdpqvRkBtoyqJqWMzFVSLaWAgmxAABYMuIKKiRo0YRxQgxTQwuUMNjhCw2ihiFiURg\n", - "0k9MhRwuJnmaRFTo3fbzOCSYYoMuFdZR+HQYoM0wGhZNClRZw8DHZjslCgToLLJOi3WSNBlAMoZD\n", - "C48WXVZZRmdyMxPpIIWFroFUc9j6PMLWmJrcwtLMAjVNx3H6aYcVIqoMRWl8t0GUjel02uzYcTuX\n", - "L2/QbDbJfo8pznfwrW8dZmbGZ3Lyu14A166dY+HcGR7+2MEbjrVMEzOKaLVaNwQjX/7y05w8OYOm\n", - "JVGqw3333cpHPnLwB2qAjh17jaeeOk46czv5SCGE5D8+/QrFjMFgYQuvnL1MrEzu3H4n3dY1Ytmh\n", - "Ey5zt9OkwywroYGjAkxcdupJbDq8qnQ8BvGVSQyYGGRFgpZKoqsmTQxcthDi4JJgEIGky1WW6bBE\n", - "lwIpduCRok0V2A0kN5M0fehUsPFYZASXC3TRidCwSTOIhYuPBrxBSAuTFGkiDJrMkWIADYhYo491\n", - "fNIYGICOLV3SooUggadilLYBwsEILBbLp0AMYaULfOMbr2FZIZOTCT760e/vIaCU4urVq5w6dZaZ\n", - "mYvABGNjE9eZSCljlAp+qk3PvvIV+Pt//+aO4eBB+PSnb+4Ybjb27NnG2bPHyedLLC+vkMvdg1KK\n", - "OK4jhEE2O8j6epM4bhPHEaaZoN3W6XbbrKwsMTu7xNjYfVjWPoQocPToSUZGcjhOAc/zQCmy6dtQ\n", - "KsT1yihSSDWIlD22U6mAOF6m1ZLoeoFYWTT9EI1+NJaRZBHUAYHARrCBZCsdWmSIqdEgRYM0Nimy\n", - "lHE3UzmwDoyibTLiggIWNhHgcRxFkgnW0VEIfHLk6aPNEtClgg1qGEUBKRWBlkXKZbz2EtIQxOk0\n", - "j+zdy9233sofHn6VvXe/3X1Z0/KsrKzitVsM2fb1QKTVatGo19EaDc699dYNwUgcx5TLZXRdp1Qq\n", - "/cisyU9KmuaHotXqYJo3elEMDo4hxAlct3P9vTiO8P0V9uy5+11/90MPPUBfX4F/82/+X86evUyx\n", - "uJW15SYi2oKFSUwFQp0uAUMEZESHulwnpeXQiEAFWPoGaWUTSJ1hbJoE9LqIxEgUERKNGB2DGA2B\n", - "RR13U0Mwzgx1OmiYZEiQZxWHOinSDJAgJkUDgzSruHiMkCOLho3EQ2OIVbpswUUAPhEBaTLEdKhu\n", - "xtgdwCWSDdKaT1LvJ6FJdK3J7JWrjDu3kLUcAiS54i5W1gzMQodksotprjI+bjI6OoDvV1lZWXlb\n", - "MBKGISdOXGB09MYbfWxsB6+/ElNpNCh9T0OmKI4JNe1tzMeJExXGx290Zk0kXuLRRx9+x7mLoohv\n", - "f/sYo6N3YNtVLr36KrEfIeU2Wp1V+jKCZpCiL3UrDRe2Tm6lvLjIxvo6k6KM61eJojyT9iBerDEb\n", - "tSjikcJGMyzCWCEwCK0c5aiKHgvO0MsrRqQJKOKQoMM6GQQaJSQbmAwSY6Bw8JAICuhY9IjaJgY6\n", - "ijXyKBQ6JRwsTCQOIYoWCSJMAkIsOgQsYrEdiU3EIgkUMW2WMIiwaTOIvRm6TlgFkqbOWmcezYJb\n", - "t97K2dUyi66PUjn0MIGtqgRRhZXZSxx8eJS9e/e8o3bn0KFvc+TIBZLJMZLJcZ599lluueU27rqr\n", - "17djaeki+/dvfVc+Au9HdLu9PjR/+qc3dxy7d4PnwdWrsGXLzR3LzcKtt97K1q1nOH/+NVy3jq7X\n", - "CIIWW7cOs7jYII4DNE1j27ZJZmbmSKVKKOXTbNY4c+Z5du++l+XleWYuvIweaaSMDEfeOszw5AGE\n", - "UAhhY5ltbt8+wqFjJ/DCbUCJHm8BoAMxSs3S19fP+noOPx5C0aJAlQ4DWGjYKLqUCcjhUASuksBH\n", - "Z5AqMT4GCXwmyLFGiyRtkoAEXEz6KCKICYnRUSRRSFpYKDwMIEWMQsemRZ0uCWyxHV0U8VDkM8O0\n", - "3SFqcZvZbpWCGaGEYLVaZXCkhOe1gBu7L0rZJZNJ0201EfQ2IefOnGH1yhWSwFKrxYV2m9179jA5\n", - "OcmlS5f45l/9FVq7TQwkBwf5xC/90o9kfHjTzMb+pti2bYJO50Zzm1yun6mpLFLOMj9/noWFCywu\n", - "vsrBg3v/RnSSEIKRkRF03WLHjrtYnptB6yqG9CwlK01GZEgiCEgQaEX69ByausJq/AYtzhOwiNR1\n", - "Wo6iKRQ12hRxUIT0OIYGkgUkS3RZJqRNE0FMgxJZcpRYZIAqOjW6tDDpYGBRpFdfo6FTRMPBxEaS\n", - "oYtBhEFACh8dRYENdFrELOHSwKVCAosWVWaQzFOiyQQRe5XBNr1XBWFKyEqTMIopWCmKmk1zbY5i\n", - "ro+qH6ElLJrNNktLMceOnee1117CfYceA2EYEsc9N9XvhWEYDE9t483FRfww7B0bRbw5P8+t9977\n", - "th312Ngtb3NmffHFU8TxO9mc9ZTznge2nWBkZIShXbs4u1QhVknm1pZ58+LzZA2HTqPM3EqFgb4+\n", - "OlKiS4dLsUnFGqbfmCQtExSNJEmtSEOksEWLSF5FM+psHZtk+9R2QsuiSosyoOMDy2RooNPYZLh0\n", - "fBrUCXCpU2WDKm/h0cRliYg5FDUE9c0ANU0XEw+DNUJcYmr4rGFQJ0NAm1FgApsJJCOsoRHjcyuL\n", - "DLPGEA0G6TCOJE0OCweHiIAAgWUaJM0Mhy+WeXMtg5R70IRLUszRaZ5i+5DO/ulbufryy7x27O2e\n", - "I8vLy7z44nkmJ+9hcHCCu+/+EPv2bef8+Zd4443nmJ9/iZ07HT7+8Q+/62ft/YbDh2H/frjZhUJC\n", - "9ISsP+4GfT/JiKKIfD5DozFPp1NhdvYZdu7Msn//bWzbto2VldOk0wZ79tzKPffswHXfIJttMTUV\n", - "MjaWZ3Z2niOHz5JQY0TdDKvlJRKRjVO/TDLRolQoMD28m3rLpbfJHwESm68M0AEaCGHi+8MYRha0\n", - "ChYVsqTQqOMgSaBt8px5JD4mEhvw0DYbetRoABepI/FokOIaBeZIkgAkLhUaXKXOBVroeAzjMYrJ\n", - "FhKMsUGXJSIadOmgiSwJu4+AmFBLUO/WCeMQG5PpVJG7cyWqZ8/y+UOHuO3Aftrtazf4OjUa6yST\n", - "Ljt27GD77t2s+j4Li4tUZmbYUigwmM+jpdPcOzbGX3/ucywsLPD1z32OW2ybeyYmuH9igsF2myf/\n", - "7M/wf0gzvB+E9w0zsnPnTqamXufatTcplSZRSlGpzPLoo/v42McOcvXqLFIqtm370N84OqvX6/zR\n", - "H/0F8/MdksldKO8VDJUETWDpOoE0GTIK+N46Hj6aajCBxwIJYJwEDpqVwUiliOxZcJeoBi4ugjR1\n", - "BjHIYuGzyDLtzRKwJYYYwsShjYliEJ82LlfJkkSQQtEgxEJQoYkiJtjkW1L45Gjg4RAjCOjQxiNk\n", - "HIMhJAKdBh2uoohw0dEJgJyWJG+mieMuelwnjtr0J5Kshj4rnSr9CZu+bIK6Lqm5LkNBPwMDvfxi\n", - "p9MEfF5++RS33377DbRcMplkeDhPo7FOLvfdygzXbbJr1wT33L2b40eOYEQRoaax9wMf4JGDN6Zu\n", - "4O3BjGU5hKHC87x31I8kk0ksSxGGPqZps2PXLs6en6O+4VLsSg7ecjun5zuQKLBQnuWtmRn0OEZz\n", - "LArpfgx9Gn+9S8cLCJHk8jmaLUEYb6CLZTQjRa06i9aSZOQC47j0pJwgWEQBGhoeFgEuedbpw0Cn\n", - "QUiFDUooJpAM4+MiuYbc5EgS+IxSIMBmhhmKmJj0+hCts0E/5ua8xUgaJNBJUGMDD0igMUZIB4vd\n", - "xCyRoAkiS0c1Sdk+pUwJJXM0amsEooBBDunWiZw0yrKYW/LZZiUYzec5/dJL3P/AAzdc2ytXrmIY\n", - "/TcEh3fc8TCl0iD9/XV27dzCwsWL/Nm///dsv+027r7//ndM372f8dxzvR4xPwk4eBC+9S34p//0\n", - "Zo/k5uCLX/xrZmYC7rzzk9x2W8zhw4c5ceIoQgQkEhZjYy36+9MsLZ1CKZd/8k8e5vHHP4ZlWXz1\n", - "q99gZgaqaxvoUhJ5McrL0tDmmKpL4lREYnyKSmWOWvsyQWijsQ4YaFhIdCQuMEAY2HRFCphEqXUE\n", - "FXIkaNJAsoSgH4OQLk18PEIkC+h08AmJsPGwCfBwmaOPPMN4ZFlnlkXKm/WQkhzwnVxAa1PAqgMZ\n", - "dCwWqBECbWIVUQuqYPaTzxQJ/A2yCQNNZpEpn8V2i6Bdp53I87WvnUSpFqurC0xN7UGpmHxe8Bu/\n", - "8YskEgkmJyfZ/sADPPWHf8hkFLHcbLIWhoxs387OiQlOzc/zrUOHGNZ1ct/zezzc18fq3BwzMzPs\n", - "2bOH94L3TTBimia//uu/zPHjJzh58nzP+Orv7eHAgTuwLOtHoodefvk1PK+PvXvv5IUXziIiA0WL\n", - "TtjGjwOgSYIcQgT4ss2iiEggqVMiIkEZg1Ig8Lw2yVQf+WKI78fskpJUq46jTKTqkCNmmIgVXGY3\n", - "q8ZDbHoFuBKDNDpJ2lwgJoVFF40aGltQJLGo9cpNaaDh0CRJjI9JjEmLLfRKewUhgg5NArpkEQwi\n", - "sXFtEyHXyQqBjCVZzadgCYRwqeLhDEygJZP4YYiyA7YOb0UInWp1CYhIJBQHD36I1dUzVCoVBgZu\n", - "pPo+/vFH+c//+Sk8b4Jcrp9Wq4brzvKpT32E3bt3c98DD9BqtUilUt+3hb3vd2/QBblug1zOIZlM\n", - "UqlU6Ha7lEql64yKaZo89NDtfPObbzE2dhumadHXl2buwst8cPs0g7l+LOMcaH1MDA/QFAItnabc\n", - "nKNTr+B7NbS4jzx9NGOBaAQEUUBX08im+wjDCyS7AaoD02xQFFBQcE7oDCmfReZoMEZMnj7WGSKP\n", - "RgIdjyQGOi5LNIhIk8SmxRARTXQWSWzyIwZJfPJcI0DQBRqYNDGRmNjkEEQoNkQdWynAQZAnZA2d\n", - "rRgiRayGaHGFgrJRaPhxFdUdw9NCfK1AHKfw3UVslSEOspjYNOMuM4vXkLKE1+m8bS503XhHIzPT\n", - "dFiZu0ZiZZ5tg4OYjsP8Sy/xX8+c4df+2T97V6Lj9wsOH4Y/+IObPYoeDh6E3//9njX8T3EV9Tti\n", - "eXmZS5cqTE7eTxAEVCplJienyGRMUqkNnnji59m581cJgoBarUY2m73ue+O6LvPzazQa0wR+AXwf\n", - "oepEapaCbnP7WB/HO03G9k/z/PKrbDRjlBrYrG+popFE4NNT9vURxRB11ugFByE6G/gosihC1hE0\n", - "SRHQpAkM41PCQ8MhRGcVBxOXgHFgCReTNjkUGgbraGwjZBTIIVhFkQdmUUSsEV1P5nZJAGObK1FZ\n", - "vkZX3oLq2ggRASvkshLfMJhbKTPVP4y3scraS88wPrKFlh6S3jHAL/3qrzI5OYmmabTbbRYWFpjc\n", - "upXx22/HKJcxHId7h4cZ7utDCIEpBGsrKwTNJi+trWHbNlvGxihms6Q0jWa9/p7n+H0TjEDPV+LB\n", - "Bx/gwQcf+OEH/xD4vs+bb77FW2/N8OyzR5mc/ACl0jie9yyh3kZGVdrEGDKLQ8BZb4aAZSY1SUk6\n", - "tFD4pPBIYusFVkIXVAyNLguNNUYyfbQ6TfrlADYGGjERHoI2EBLTpIZLiIaJtmn3XsNlnRAPk54K\n", - "ulfoGZJknTySgBKCKgazdEljYaKzTIkW/dhEKC4SE5CmTT8GDhYuKXRUYNLSM3SMDk7soukhRSNL\n", - "hCKK51ha6ZLecRthWGZ4vIRhDrF1ay9tYlkWxWIRXddpNAzCzZTL92Jqaorf/u1f5ujR11hcvMD0\n", - "dD8PPviL11NmlmVRKBRuMKnbt2/XDSZ1i4unGBy8hXQ6T7NZZX39HI8/fg9/8id/wezsBppmo2ld\n", - "Dh48wEMPPYAQgocffgApJS++eIw4NikUKgzla/Q7I0SRz47+DKfmTzI4tIP19QZzixcp0SAb2nRC\n", - "hSaqLNAkZAQ9cugSYJpbiIMJEnGLYdVFx2XYSdMJJK04IsBknSQNTJLkAZc+IMkQIRKQaKRx0NAp\n", - "I+gt0IoOkho+JeokqFMnJkCQZwSPKmsM0kER0wdsoYtLAqElyMuA0wg8BrHoBcwQEKoQkLjCASvA\n", - "NjQ0qdFyDFYEuLJDWri05RIhO1Bk8cM2Ml5iV/8wr5yd5WO/9naF5vbtW/n6118lDKcxzZ7IWMqY\n", - "tbUzDMoWd+zcf50d2zU+zpn5eU6fOsUDD37/iqv3E6rVng373e9efvZjxeRkry/O2bPwHjef71vU\n", - "63U0LUOz2eSll17H90103cb3FY3GLL/3e1uxbZu1tTUajQZCCAqFAkIIzp49h+NMYtsZKt4qlhQY\n", - "wkYTKQy5xlp9g/6+IS6efYv+/r3E4UXcapVuZBJhorAQaPTKdnUgiSIkyTLjxCRwyOMi6VInJETg\n", - "IjHRiTBx6UcR0GENmxI+RVw2uEIXmxR1PAIalAgpAkP0qistFEkgBHIo6jgokghMPCpsI2ZC19Gt\n", - "BEPEzPivs+avEqiQnNNiuCswyxtMI1isLKAZJluzfTSXr2IXhymfOs3c/fczPT3NiROv89RTz1Ov\n", - "R9Tr62ysz3HngMMH77rr+hxEcUwlDFmv11k6dYpd/f24ccyzly6x/847aUhJ6UcgBd5XwcjfFoIg\n", - "4L/8l7/k2rWAQmGcTifFyy+/SV9fmunphwi6X6M8F5PDRtckvkwgqTKKz4RIEWMxpFlUpUBgshG3\n", - "sAhIofAI0PFwWytE5JFYSCQOGg5JArpE+AjatFkhg0WRLC2W6NIkRYEMG+Tp4COp4ODRIomOTxpF\n", - "lxQZDFboYwmBzRQpWuSBCJeAGkOkyeIwgoaNj0tdLDKobIJYZ8ldZsIKcNL9rHgeFa/NXjNN073C\n", - "pbPXaFJiShWItArXrh3ljjv2sXfvLQgh6HbbOE50AysShiFra2sYhsHQ0BBPPPH4O153pRRPPfU1\n", - "Xnttnmy2Z6LzxhvfNakD+Af/4CEOH36NubkGg4MFfu3XPsyLL55gdTXB5OQDm+cL+PrXT1Is5tmz\n", - "Zw+6rnPw4Ad48MH7aLVaOI7Df/g/oFhr4LYa3LqtwIc/sJuFapU3nzrOdrPJbmHTDDzKWsyG1Cgi\n", - "uaYbxLKFrecpZbbhBxGhF6ILi6zmYlv9uKFkmRhPJZEkCVBkcDaLpy0MTDQkAaAIiLAJCLApEtFG\n", - "sIrFNCZZQgQao/jMotGiQo4sVZIYxMSk6AllHSLasovCIU2EzgaCQSyyRFzEZpmiiMjqAQ3hs+SX\n", - "Gc4k2GgtkNUstoctItFgSKSpqAu05RIJYTOQtBDYnFtb4fcOHHjbfJVKJT7xift4+ulXEaIfIQRR\n", - "tM727QX6K/7b1PNDuRxzFy781AQjR47A/feDZd3skXwXjz7aY2t+1oKRXC5HHLc4efIMUKRY7Inh\n", - "W60YTSvw1a8eotl0WVjoIESKMGywZUuOT33qCRYWVlHKZH19A7QcUdRF12NMPUEku1yqNRkvDbGx\n", - "3sBOKXZsv5eZU1/Gjy10NQV0EASY6ISY9Ep46wxTJb35lAZo5LBoEhKgsOjDwCFGJ8sqMV0k2wjJ\n", - "0KEGDBMwR561zade4tMgg8ShtzCb9IwwV4EuAoVBgEGTiDQOOhH1uE0uSDCSsDAsMPRVjJRF2m2y\n", - "U9mkbAtdmCS7bU52fUSrxhbTYr0yz6rZ4fDXv86O3bv50peep1KJWFpqoOsjhFGWLxz9NkEc85E7\n", - "78ALAmbrdeyhIbYtLdEeGMCMYwZyOUpBwDeff577nniCLT+CuvpnJhhptVocP36S8+evsb5e5urV\n", - "Jjt3PkAYhmzfvos33rjCwsIGqVRMIj1J/+QeaqunMUKXki4I9TQFmWbISlPtttGEgy4qoAxyWIyg\n", - "0yEgwQpbEMxt+qa2aeKRwEUg8HHRuboZMRfpkmeeAAMPi2FGMVhmkjQ6EolPjE+bzCYh2CEigYZL\n", - "CoMUDhIHAx0QdJCUsbDIYAMhvQ6RCbJ0lc0qHSIV0cZDiyHXqNFQMTudPPlIse538YISJXsAfb1D\n", - "VwasqFO0WnVsG3K5FJ63wD/6Rx/G3DTEOX78BH/8x3/J8rKHaSr27h3jn//zf/y2FA70OmieODHP\n", - "9PQ91xey75jU3XnnVQBuv30/t9++nziO0XWdlZUV5uebTE5+12nVNC36+3dw5MiJG/KTtm1fLxN+\n", - "9Od/nte+/GVu276VfDrNRrPJpWqVfsNiX7YP2eoQxJIhaSOBDWJSho4b3UEcX6PjVtFUH6Hop8o8\n", - "1QgW2nVUHAI2y3TJIMmgSCBpY1JHox8fY1MXHuHTREOSw8LC2zT8D4iJNmttPDrEGBjEWDQoELCT\n", - "BOvElIhoAwERTQQeGjr92EyhyBAxQIJXmKaKo0qYMqY/7tBJgKPr9KkWg6GHpelU4jpXaDGpbWXF\n", - "1pBWH914DuFeY+eAwV9/9rPc+9GPct/9N1ZD3XvvPWzduoVLly4jZczWrR+gWq1y7L/9t7fNb9f3\n", - "Sefz7+0B/QnE4cO9xf8nCY8+Cl/6EvyLf3GzR/J3i5GREQYHLY4cOcvExEMA+H6LIJjnwQcf4ckn\n", - "v8KePR8kldrGmTMXqdc7vPrqZZaXl8hmEywtreH7MVK2UZqBrzQ6co3hYpG8BQOjaQpCZ3BwJ5cv\n", - "n6EdatjKoUsF8HFI0aVIzw2kiI1DEgWUAQOFhYXBAJIYezOR4jNGgT4Ea+TQyNJEEKKRBmwGadNF\n", - "YGJh0qJGtJkccjZfJj3Z7FUkAh+FTQOT4c1ONf2AjCOCbkCCGEeE2Nk8WSfFZT/GCaoUIp91FPt1\n", - "A1NGFKwMcdBlupjn+JkzHD36KqurHZaWPEqlO75nk+HwVvUNppSif3SUD//CL3DkmWcYzudZ7utj\n", - "5tw5unNz5Pv6GBoZ4a6HH37XbVjeCe8qGBFC7KYnLT6mlGp/z/s/p5Q69J7P/neERqPBf/pPf0Gz\n", - "mUHXczz11EssL8/z7LOvksmMMziYIZGIiOM65fIVPA8y2QJJcxqrukImjqiFEZ6n0Q164cBq3GIQ\n", - "nwodXFKEGGRxGcYljWCBkDYmLQbJb6qpOyQps0bIMII0Xao4NGmQQzJOnZghJIqALBoKB4syBll8\n", - "JAl0wk1rtCIGi+ikMakRYuIQYVAhRCGJAY8mFgObC58gj6JJjaKmKJJiSjPQY49V38VT0EFjWBRJ\n", - "hDH15TVsM4VhKjrJGkePfoHf+q1f4bHHnmB0dBQpJS+88AK///v/FsfZT1/fXuI45MiRK5TL/xf/\n", - "7t/971j/vy3lzMwslnVjPXrPpG6I8+cv33Dsd25q13UR4u36kkQiQ7Xa/L5zfvc99+A4Dseee47G\n", - "3BzFoSG2HjjApZdOU91YZ8BOk0451NqCPqFTjupEMgESpMoQeVUcZSFRXMIiyRTDsUMdnxbrTCMp\n", - "ENGgQ0iNJDmuYXEVjyIRAp8qBhtITBpUOUtEgMYoBqMIIKSF2gwkJRohOjqQQJBAp0tECaiiU0Yj\n", - "IkUDkzwSB5cOLjaKBC4WMZrSMFSXSd1ksVVj2HQYd9I0my3G0alJHzPRZSw9QNlf5u7hYabG+rnn\n", - "np0MDA5w/KtfZWh4mOnp6RuuZalUusHQrFgsckjTeP3NN7GUIpvPU+jrY851+R++h9Z9v+PwYfjj\n", - "P77Zo7gRjz4Kv/M7ICW8i24XPzUQQvD44x/hxRdP02gcB3QSCZ377ruLdLpApdJGiAxf+cq38Twd\n", - "x0mRz2/jmWeOEgQ1hCigaSWkdIhZB9ZJWZL+dD8BdSbvuotTh17j9ddfpNkEP3QwN3Ue0CYAIkx6\n", - "XOVqz7MJA0EJRY2IDhVCXCLmiYkxSeCSZ2BzW2nQxSAkxCDcNHvow6JLihThpn5sjiUGSVClS4EI\n", - "AcwBCg2JQ5YCQ6QpM49FhI5AwwCp4RoahulwcSFi/9CtjA4WWVi8yka0gAhXGUdQ9z1WVZVcqUjC\n", - "smislvnc577ClSsdlJpC12v09fW0NolEhmx2B3c/8ggHNpnTZ/77f+fk0aPko4hiGNLodtmYn0cZ\n", - "xrtqv/KD8EODESHE7wC/DZwH/lQI8btKqac2P/4/6bmo/kTjlVeO02rlGByc5tvfPorvJ1FqB3Fc\n", - "w7L2sLHhMTwMw8OSffsGeO65M3SaddJRgCYEjqmR1rJUugGNzaqULpIUMToRtwD5TVszG2ih0IgJ\n", - "yKGxhTVc2uj06tVLmGTRyRAxS4sZ8nTxuEoXQUgHjwCFwAS20OISF1kiTWpTnDqMoolGxBANYmos\n", - "oSNpYdJEIACJSYKADhtomJuNpzsMUGbMtLkWuLSloB8wpeICAkgQyYA8bTTyGMom7XdpBQYDA9Ms\n", - "LS2TzWap1Wo8+ed/zuEvfYXkso/InmE9aJLK7yaV2sIbb7zC66+/zsDAAPV6nVwux9TUFKapbxoI\n", - "3YieQdE734q9RbCNlPH1qg6AWm2N8fEBlpeXyWQyZDKZG/5OCMG+/fvZtXs3p0+f5uTJ0zz91Fdp\n", - "ri2ghQax8IjDCKF0grhFE0kY2uj6GpoyEbpBO/Rps4bGCDE6y0QoFBpDBFymSEQGnwZztCiQQLCB\n", - "QZ0EASliJGlqDKDRReKh4xIBOpIu0IfCAsqbfShaSLKcp01qvD7QAAAgAElEQVQHkw6SYUJMFB1g\n", - "gzothhjCIcAHPLIoDBRJaiSVRaiZaFKiZIxnaiyHHRIEJAT0CaiGy6w0qpRSabZMb2HfvmnGxkYB\n", - "mEilePPEievByMrKCufOXSQIQnbs2ML09DSaprG+vo7b6XDu3DnyUhJGEbVEgt/8V/+KycnJ9/qY\n", - "/kShUoG5Objzzps9khsxMgL9/fDmm72S458lTExMcN99+wiCMRKJNI6TQtM0ZmfPks/n+cY3jlCt\n", - "JshkBvH9mIWFDTqdKpAjnR4DLgIOmiaI5SLtMOKtZostW8fxpcS2TFqtU0TRViwCBCtoDOCQJmQD\n", - "RURAFUgSkqRCzAgJdFwsQhQOZWxgCIlPnjV0rrFOgRYSKGEhiSltWse7pDEI0YAuDoOs0yXGw8ag\n", - "DEREJIEUFjqKFgu0SG86DwUk6VX2VVWH9TCiHCq6THBhpcpAIs9Q3zjlDZ1VNkhHLjkipAntyOfY\n", - "zBUoTrNr10PMzT2LEAXm5yuYpkE2myWK2mQyaVqt1nWmuhOG1JtNzHabjKbRXyhQ932evniRY0eO\n", - "sHfv3vdsfvZumJH/EbhTKdUWQkwBTwohppRS//Y9nfHvENVqlW63y6lT5+nv38fKyipB0MvIGYaN\n", - "EAqlOkCSIDDodhv81m/9r9xzzyn+t//50/QXJlmLoO16BME8kXA4HdmkEYSAj4GkxTQShb0Z20Ib\n", - "iY+GQUxEg5AkPcOcKoJdCJrE1BikRj/FTQ2AxCOkTMggEG326TVQFOhi4lNGQ9DHCiaQQiNJSEST\n", - "DBGTSLJAHajgMkgEWFRIskGOChlCNGKsIOIWJWkpDQ04i0OLUYZJ0iTLOhKLBnacJtBCymtnqdU+\n", - "wqFDV2i1PoMhNziQy5DtRtj5CYJAMXvpNRYzNZKpCVbqNT7z6U9z7/btpOn13LGGh3nwsceIotOE\n", - "4RSm2WNN4jgiCFbZs+ftroBRFFEulxkacjhz5kW2bz+AbSdZX1/m0sXDxFWdr1w5hyclW++4g498\n", - "4hM3sDErKyt8/jOf4cLRY/iNmG55cdPpNOKa18SSCk9GLBoa7WiQnNnCNou0/AWkqhFTQ6cPiwEc\n", - "BBERGjV0uhiYCJqUsDAJMamwDvSRQtKgTUSAYoQSOTQCsnRpcpkVQjQEQ0gsFBtAA41xIqpcYRGD\n", - "ESzySGLmWMehhWSQDvnNZN884yQpIYmISRKRQCcgwgwjZpWGpxQ50yBqNqmaOnnDhNigZDtEhRyf\n", - "fPhhHj5w4AZaNWHbVFs9a/hXXnmVp58+hmEMomkGR44cYv/+ET75yb/HoS99iXsGB/m5J55grVYj\n", - "jnu9MJrV6t/yE3zz8Pzz8NBD8B57OP5Y8cEPftf/5KcNy8vLXLw4g1KKHTu23dBJVtM0PvnJn+Oz\n", - "n/1rPK9EIpHDdTfIZpsMDSU5d65DsbgdTdNRStJstllbWyKdHmJjY5m+vltpt7t4Xo0o2oGuu3T9\n", - "LhfOrLJw+b/ihZJu1we1wShlBA51FmhiAn2AApL0DNxdyrTwqZInRmAQM4RgijwGEU26XKafDerE\n", - "FMnTZg6NcXzU5loxj8M0Eh9JihYQksMgyQAaDgE6NSJcFggYQSMmJM0GFjENFJcASUwKnTImDUok\n", - "GaIddHnmwmV2DxSJlc1qbDNpSNKZPJatUcrlWKrU6Zu8lS1b9jA+/jrnz18glbqNpaUlgqAOqs7l\n", - "s+d45elFzr7yCgcefRTh+wSOw1y5zFgyyZrrsi4Et05OUrl0ifn5+fe8IXk3j5r4TmpGKXVNCPEB\n", - "4EtCiEm+T4O7dwshxP8D3Am8rpT6n36U7/petNtt/uqvvsalS6sIYfP66yeYmkpgmgk0zUTTdGw7\n", - "ZmPjEkqt4DjDWJbFXXfdgu/7jI6Ocs++IRbmVmjJDUJ/DcNrEsnt+OQ2Q4cENg2SzLCAzygGCSQV\n", - "YpbRUCiMTYlih5Cev1weQRMdF4NFilhoCARpUljkyNPCZYYWXXzSSBro6Bik0OlJJvMkyVAhxiRg\n", - "iRUMRgnpwyGJxQAB/bQ5RUABg0Wm8Slu2vBoxOxUMesIdHQa6EgGEWQIgTQedTJ0sSnLRdYJMe2d\n", - "9PfvJwiWSaVu4cVvfJb7PnGAbDbJtWs14q7GVKrIpWiNYuoWymvXkBdj9j/88PXg4PLyMm8eP87H\n", - "P343zzxzDOgJIqWs8Nhjd7ytfXWlUuFLf/7niGqVpFJY7VVePz7D6MQ0hh6yOxvx6LadmIZBLCVn\n", - "T57km0LwiV/4BaCnvv+///W/pnL6TaIgQdZKcn++xJsKKvUaBdXFSSdY9RV+YppsJ0Wf9KgFF0jI\n", - "RSaVywZpKphECGIgg0VEP10WEcRscjYU0LiMTh4dRRYDo9cviCYRbbrkN+8YGCbiGk1AIakCNlBE\n", - "RyfGI2SYFL2eSgECjd24nMJmBybWZp3OFQI0khj4SEIiuig0TBaUhgtsIybp+9iaRhiGvOX7hI5D\n", - "f6mPR/buZandZnFhgWqlgu04jIyPs9JosOuBB6hWqzz99CuMjNx7PWhUaopTp15jZOQVupUKpc0K\n", - "qdHNbr+xlLz41luEv/iL1/VE72f8JOpFvoNHH4XPfx7+5b+82SP528Wzzz7Pc8+9ia73Urnf/vab\n", - "PPLILTz22MHru+2pqSl+93c/xalTb7K+Xmd8fDu33baXP/iDP8K2j9NuL5BMlqjXr9BsXiGV2oZh\n", - "ZEmlHDodlzhuIEQ/hnEVJSWhnyefv5Vm5zzIETTOoZBYwqGhQlwEMeP0qhrTCDIoDARXEQzSZIkG\n", - "VTR2k2eEpNCIVIRLlxY5TrJOkgwlxlC0qHEJMOn16O2JYU3kZvOPPA4xkyQAe1MvEpBGMoGOwmIY\n", - "GCDCImJhc1QrKKroaIyRJkmaNLrIUlENzm3USaYzDBUHyY6UiGWEjCMu1Ks0DIfR0ii6bvCRj/wy\n", - "QnyRy5dPEIYGQ4PDRBuXePyeae7fuRPX8zj+1FPUGw2m+/rAsnCDgJRhsD2X46LrktM0qtXqjzUY\n", - "KQsh9iulTgNsMiSfAP4EuO09nRUQQtwBpJRSDwsh/lAIcUApdeK9fl+j0eCl55/nwqlTnH7jDFpq\n", - "B3fe8zFsO0EQOLzwwlH277+bIHBpt2u4rkEqlSWV2orvX2NkZJKZmdP8xq8/D52QlbmrZJwJHt73\n", - "/5H3prGWneWd72+9a97zdOap6tTgKteEy7iMB2wTaAyGkBA66ctw3YTciI6UCPIB3VZ/iJA6Uqu7\n", - "o1Z0OyhRmktDAuFGEC7pbsaA8YApj1Ueah7OUOecfc6e573m9d4Pe1NxAaHB4Lbh/qUj7dpnndpL\n", - "a9rP87z/4a28cOESz609jWQCiUmWJBKNmAwOdTx6XCbAJaZFbmwDXMengcssgklUNtBoYVAii0JM\n", - "DxODiCQKCgYmoJBAMGCWLUASMcBjBkGCiINouKzTHmec2Djo6AwpoJEnRsWhj0UKQQGJSp4MCg6S\n", - "Pgajun40IIQUMatoKKRRUGmOjXZy9OgS0mMNVT+OnVrE9wdMT+cxDBMRF/j2E6eYnypw5sVT2Mo0\n", - "qp4jivpUWufIqg2OTd1ErVZjbm60BLA8Pc13z5/n7b/+6+zfv5erV1eQUrJnzz/7IbKrlJIv/83f\n", - "MOd5zI4v7KNLS5xeW+PmB+7i9KOPcuymUSECoArBoYUFHj91isFb30qtVuNP/uiPGJ4+Td6NUC24\n", - "Wi8TGCa3Ts3zTTdk6CUoZBMsxjGr0qHm1un7faaFy2E1wo7h6ThDQEiPDiEZFFQ0VEIcQvp0gAEx\n", - "O6hskSbFHApJfKpoDFhCx8WlT4CkgiSJRTjuov4xHlEZs0VCKkh2M8DAR44XhVJIlgkpo7EXhQGC\n", - "kDZl0gTsYUAPSRmDDkVcUizHPm36DLstckLDUAW2lHQieH0uT29zk6d6Pbz1dQ4UiwyiiKdOnaLw\n", - "hjfwW697HefOnQMK1wuR8f1KNrvI2bNX+GHnkesbvdzb9zWHhx6C3/3dV3svfjTuuw8+/GHGjsev\n", - "9t78fLC1tcW3v/0CCwu3Xzc+jKLdPPzwkxw8uP8GR+1CocDu3YuUr17ie2ee5dwzT6MKhTe+8Q08\n", - "9dQZ4rhBGG4wN3c3zeYKqlrDsg6jqgk2Np4mn48RwqBVNzCtKRL2FJ1BGUvPEURHGQbfY0MGwBwg\n", - "0NlPwA4xqfHs20PBw8BBoY2GT588XXWevuzgyzOMBLlHqNJGsEMFh8x4xqqhUCOiT58GOXQMOoRA\n", - "B4PRtFoQ4qMiMdHoYyLYJmAGddy4+KhExNgEBDRIs0SGAX1C+mikSGHTigYEkcvuuSluO3yCWrfF\n", - "wOlj9bPMRS6aOmocdN3kvvvexa5d54EyfnObd9x1G/NjrljSsjg6O8tqs0kjitit6yyPG5Fyr4ed\n", - "z6Mlkz+0XP7T4CcpRh4cH9nrkFIGiqL8S+AvX/Ynw+3AN8evvwXcAbysYmQ4HPI3/+W/kO/1OGzb\n", - "VIfgehVeeOpr3HrXr7F79yEqlS2uXj1Juy3xvB6qGlAsHkfTciBDHn/0G1hRh0XNIo1gITIg7vLI\n", - "43+PZ+5DAXQUNHwCHBQyQECfgDVsVJZwmMFCjDNzn2GCLC3KwDYmLSxcIEQjTYiCgg+4jBTloCBw\n", - "UTDGZvIqDh1Ckvgk6WADGWAXPdbxsVC4xDQKU6ikAJUI6FAjHq8wDojokGSIwwQ+DtBnxNQeEhPg\n", - "4RMTk0RBo4OPpYTEiocmDTwlRTavYdsOhw/fyuXLK1zbbqP326QWFjCMiMBdZ7u3wdCwWMoqTOam\n", - "GAwG1Go1ZmZmEEIghEBlJAP+QULkD6JcLhPUasy+5AGkKAr7p6d59rHHCAcDEqXSDX+jCoEJPP/8\n", - "8/zVn/4p9toaJdclaHcJ9IAlM8FztU1sBJZtkTJtmnGfZqfGXCKLHbSpxUOiOEZRBFUZ08VHoURM\n", - "GZcOPdLEtElwjf2ENIAyMRsU0dmPhk6f/nUKa3WcwayQQhKgUkMisNnBoYxgkZAEkiIenTETaJSF\n", - "E2OPfUQkKmJMalUYoiOAPCF78PBRUdDRmURykJAQGdWIKeAS0ZQe+Vgho+ukcxMMai1aCZ1FVWXh\n", - "yBHa/T5hGHLTvn0MbiAc/3BhoSgKyWQKfWqKSqvFVD5//XdrlQp7jhz5pZiKlMtQrcKxY6/2nvxo\n", - "TE7C3BycPg0/QpH9C4nz5y+h61M3ODCrqoZpznD27MUbipFLly7xtU9/mv3ZLAfn52n3+5RXL+I6\n", - "Kd72trfzwgvn6fXaeJ5LqZTi7ruP8/DDj+E4KVS1zMREkWTyFhq1U2QTecIoQgiJEBGx3AFMXCZQ\n", - "mEVhjYg6kggFG0EXhRCTiAI2ETpF+lzjDJ1oEZXz6MSoHBgrGW1AGcenjnygTHTSNEnTpYuOREfg\n", - "ADO4xHQZjBtVFxUPHwUXSYjAH89lVAQKMRYhMSEaKklisphsscJA5gixiNmikM4RDnRWr64SuS4y\n", - "jgnDHn5BZeC2OfvCY+xcfR7Vd+n7Td753l/D29KuFyLfR8q2mSmVsA8c4LEvfYl9rkus60SpFHsW\n", - "FggmJ3+I/P7T4H9ajEgpN/6J9yXw3Zf9yZADVsavO8ChH7Ptj8WZF17AbrfZt7hItVrFHYYETpv1\n", - "S5foDATHT9zD7be/hZWVCCkDrl6NaTZjGo0acVxDRE10cswYMUcyC/i+Q6XTJdJDEkOftneBBWJ6\n", - "tDGYJqJFk3ViFoBpAhL4RKgoJIQgjkfJMS4wi0aDGvtwsAhocIUBJhGSOi5pdATzODj0iQiYBCQ6\n", - "UEXDIUOXKiYGDh0kFh4xLWLAJMYkHlvES1wCAiIS6ECWKTwCNtgkjUGAhzc+0J6iEiPRZcSAGhr7\n", - "sLQMUvFxwzJ5tYXQJImpHsdeN086nebKlStcuVLFzGXYGW6y2mkzuXiE8upzTC2VeNeJE9QqFc69\n", - "uMP2YIBpWZxstTj+hjcwDAKsYpHsS8Ly/in4vo/+I7psU9cJPY/0xATtfp/cS8LZvCBgCDzxjW9g\n", - "dLvcsrDA41vbJPyQbmuLSFExZchZ5zw7uoUTK5QMlRk7Sd6yScQhi4rgjJQ0gR6COgEeBoISkhaC\n", - "Kik67KOLCWwDDUAlT4xFm21iJhAUUdnNFo8zyRADgUEGiUIfh2OoQJvLXGRIHoc1dNrk6dGmAOTw\n", - "8VEJUOgi2UCQRhCPKbBdHCLOYZGgj42ki4NLB5jAE4KSTOCRIasM6EV9HKmgtDr0Bgk8S2N/KUPs\n", - "ebzjJWsRz127xsbGxviB8l2CwH/JMo2k3d7gne+8m0LhLr74qU9Ru3aNjGnScl2CQoF/8da3/tT3\n", - "7msRDz8M99772larfN9v5JelGIlj+SOJj0II4ji+/m8pJY9+/escLBQojqMH8uk0v3LkCI1nTyPl\n", - "KocOTdNun0fTPBYXl2m3JSdO3MvW1iq6rpJICHTdw7RG53joVQiCPq63SRClEGJmJAGmw6gPr6Ax\n", - "A0gkBtrYfkyngGQHkySzdBjwFdKESA6iIvDokEWlh0qEhUMakAyoUGSbJKlxly8oYdGkimSRGjtM\n", - "o6FhINmkQ0ADQRaTOg5TgEdAABTGzicBPVpMMI/BLIIefbrUUZRtiopNLZAML5/h+OIykYioeG0S\n", - "yQXaO89y4bnnyWk62VKB99xzN8PVVc5vbXHb3Nz16TNA33FI5HL83h/+IUdvu41vfOlL6EFAPptF\n", - "37OHX3/Pe155ae8rhA6jRh8gy4h5eQM+/vGPX3993333cd999/3I/2hrdZWJ8RdTtVKhubXCdG6Z\n", - "XbZNvVLm1KOPsuvwPo4cuQnPC5maKpFOF5BSsra6yslvfAenWyWnqghFQVN1TKFQH4TosUJOcZnU\n", - "F1GCMl26OAjEOEtmpHmxkfgjOlGcQMMhiYnPRXRMJvAxGGBikcbGJY1Bkj5tavTRaRCTISSFjkRh\n", - "kwFJOuQAjTJZBG1UYloM2UYhg04F0EjisYlDHxDECFT65DGYxaSLTZcsdTavFyLngAkZYgF5BMs0\n", - "ucz3iKNlEkYKtAZWwmXx6OsIrGnW11dIp3exs7NNpXKRfN5gZvZtXGjt4LnXkOlZ3ro0T6/TwWg0\n", - "uHligs1kEiuRwG80+Najj5K7+WZ+7UMf+omY1tPT0wxUFdf3sV7SrW/Wauw9fJi9N9/MP/z1X3Nz\n", - "HFPIZOgNh5zd2WHu6FEG586RtG22yjuoIsFOMBipnGIYSIUaNhktTyeo4jhdwuGAuujQikaKk2mg\n", - "KiVrWAgEgh2GYypxlxYJquygsIqKScgUI1OiDlsEpFDHMeKSNj0m6BKSoEESA8EEGim2uECRgGVC\n", - "KgzoEbOExiwKz7BGGx2DCTQiJFuoVEekNCqMXEdChkyhYeEywKXKNHlyDKgQ0qaIkHWS+HiRRguF\n", - "taiArkwwmYy4dWKGodflwrVt3vaS4x4xklQXi0UeeOB2vvKVp9D1aVRVw3EqvO51Uxw8eBBVVfnQ\n", - "Rz/KubNnadXr7J6b48CBA/+kxf8vGh56aEQSfS3jTW8ayY4/9rFXe09+Prjppj08/PA54njXddVc\n", - "HMc4zjYHDz5wfTvf9+lWKhR/gJdgmyY3Lczx5g+8C9/3WVjw+NznnqRWmyaVylGp1BkOK3zsYx+i\n", - "XK5y5kyZ7amIjWuPYGOgyRx+uIEkh2CbmDyjZNs8cImYPpBC4qMxRMGixSUmkICOTkSWBiY2zjhT\n", - "V0MS0yckjUWeDDuohCRI0SSLg0objQgFizoqGSwi+hRZoUaSASo6CSJSRDTp4aPQJ2KaEePkCnAz\n", - "Fnl6nGEHnxJJRjGeDj0Wk3mW8Fjrd9mxpjjZ2aHeqVBMGmjnLmCEPu89cYKJdJqW43D+4kV+5d57\n", - "Ob+1xXeef54js7OUSiXCOObF7W3ueM97EEJwzz33cNeYX6brOrmfg7/Qq1mMnAQ+DHwBeDPwX39w\n", - "g5cWIz8OmUKB+oUL+L5PZXWVg/NFyo0WQ6mSz+SIYpezz3+dt771Q3S7Xc6fv0g6fQeqqhLHMUHo\n", - "Yps+QagShAG+HxBHAVHgI6WLZVokDYtJKTDDNhUsLIZjVUQJlCyK9IDL5ACFDC1eZDd9pnCoE1NB\n", - "5SYkq2TJsoxEoTxerumyxoiuqI/VFRoQoGGgM0WRDiZJdlAZYKGS5woKDl0EBhFFUlTHlfw8YmwB\n", - "Pxjn+WYwmRqXPDv4HESSB7pADYVFDAQ+bW2TXpRBKEX6CZW6V6JdCVGUDa5dO0e32ySKLKan72Zu\n", - "7hDK/BHC0GNj45vM3HqIMw8/xO0zM8wvL3NPOs2ltTX6rRaVIODB3/7tn3iEZ9s2d7797Tzx5S+z\n", - "K50mbdtU2m1qhsF777uPUqmE8uCDPP4P/8Dz166RyGS4/Td+g1Qmw3fPnWNxfp4nXjiP7QX4mHgE\n", - "9OOAa4rGhDDJRQNk7CHRkbJEBgOhJKjKJj0CQgQLZLFYYEjMFkMaFBEkaJMnyTRZVIa00CkDTWAP\n", - "sISGjklmbE63hcIuBvikyWKh4o+VVoskxwssESFdqnjEmMyRQOUcKjYRsIhCFochFygjqGOisYsh\n", - "KQJCUuQQmDg0KZCjiMt2nGadCJst+qTwMInJklZ2IRkSWAb1YUxKJhm4LknLojsY4FrW9XH4XXfd\n", - "we7dS5w9ewHfD7jppmMsLy9f9xJIpVKcuP32n+h8/qLhO9+Bj/7c6PSvDO69Fz74QQgC+CVYGWNx\n", - "cZE779zL448/hW3PoCgKw2GZ22/fdcNzQ9d1VNvG8TxMXafb7SKEIJFM4kvJ7OwsyWSSr33tMe64\n", - "4y6uXdug07lMHLvMzk5w+vQ50ulZZmb2YRgp2rW/YtDTGIZpJClUJLEcpaUrio6UOSBLzDPoXEES\n", - "EaERkMEkT5uQDjuksQGVFAMCgvFTRBtHgJgYXGISHwOFbUKGzJLApIBKDwWYJ0GHRRyaSNKkiMZm\n", - "8DpXsPGZZ2QP32dktVZkpNE0iChhUqLFFsNxxrDk5tLNlAyDXDJmzrtAV6kRiwVuKS5RVC1qOxv0\n", - "hw2+c+oUdx44wPzEBJO+z5lLlxhUq6y5LufOnycGFg8f5tcffJBbbr2VRqOBlJJisfhjl9t/Wrxq\n", - "xYiU8rSiKK6iKI8Cp38W8uqRW27h89/9Lma9ji4lywuzhKLMpWqTyWgDVQS0m0MeeugaELO5eYZu\n", - "t8b09AFcr0EsVtk7P8Xmyhqb9QoJJUHf8wlkl5ZwkFFAKayQMCcgcujRwVMUckqJlGrRinxCaePL\n", - "IhXZQqfCEgOOYqARkEPQQOdFYgQ5BoQ4qARY4xD5KSyu4ePRJUOEhyBCkELjEkXaY/+SeQqUsHEZ\n", - "oDJgD5IrJHCZJEENBQ+dJAkiNBr0mUUhYkgeGKKxQEBm7EWSYyQQvqxIprQ0cVwkVAQVDHQlzcpK\n", - "nXz+LlqtATMzu4jj5+n1Kmxv1ykUVpmf34OqjiZDhw7fjN5tc/tL1nbfcHTEb3782rXroVU/KU7c\n", - "fjvFUonTTzzBarPJ4h13cP/tt5Mf8xQOHjzIwYMHCcMQIQSO4xCGIX1VZf/0NN8wTFb6LZIihSdc\n", - "thSLJZFiJnTRNJWCouFjsRN5ZISBkAYJMpRpsIROiEk8NnefQjBgiIdJjt0UUdFRsDBpoyKpAwYG\n", - "XTIUkGOXlwiTBC3EOJvIZDTXSCCw0Bji0cHHpwgUGIlq2+jEHMKjySiOPEWCEgl0nPGkKz8uVF1i\n", - "YjQsHFxidjDQ8bmKxYAl5rGx2cZniEI7LjMp57jQrTO1fJT+sMLlzU00w6CtabzjAx+4QRo9OzvL\n", - "7Ozsy7wrfzGxvg69Hhx62YvG/2tQLMLyMjzzDNxxx6u9Nz87FEXhHe+4n5tv3s/Zs5eQUnLo0NtZ\n", - "Xl6+YZoqhOD4G9/Io5/9LN52izjWAUkr7HHLu9/J9vY25XKZ7e02Bw/ej5QK5897aNoC1arD9773\n", - "EO9////BgQOHOXv2SfL2Lrx+lYS2G5QEblAhlnNADiGGRFEL8BAUETiMIk2XSZAgHhuYgaTFBTyS\n", - "6KhYVIgAjwTQIM+QJVRsDJJATMiAAQKLNAo9BGkSBDjExOiM+G8ClRYDkvgcQ46VdKPn9iSjpYQQ\n", - "qGKTZoKiEuCLRdRoQNLoMmVNEMddTD1F15ekMwXmbYuDiRzrlR30QCWhZEkNh5y7fJmg1yM9Pc3J\n", - "Z54hlc/z/je/GaEotPt9zjWbCFXlv37iEwwqFRTAKpV423vew8LCws/lGnhVVfT/Mzmv53mUy2WE\n", - "EMzNzaH9gOi/XC7z+ONPs76+hVac4tnVy2y12zSlJC4V+cjb34aUks9/+wzzc69j164RI216+iau\n", - "Xv02i4tDzp/fYXZ5D+efO80w0ulKDytoIYXHUInxZQktbhAG26ixgiZDbBHR0+ZJqEmC2EdRAmJq\n", - "CAYMpEYeSGEyIGIUrCSZRGOLiBYaLjYWJgY9IhR8NGCCGG08GdGRpIioIaljodNHRSWPwoh4qmKh\n", - "YyMoUeQ0LllsZlGpYTKLIIOPRpl1MlSpEpEaZyv0UElhIICQgFBGdOMYJRbkVWgZHradxnFSNJs+\n", - "qppBUVQsa4LhMCYMu5TL29j2SJuzsFBkaWmJ6toa1VaLyZcQGxvd7k/MFflB7Nmzhz179vzYbS5e\n", - "uMBjX/86XqcDuk5yeprza2uYmgHJOdbD0aMkHcZMKTaKIvGjPkosSAgTI/boBT4+PnUkGikYW+4r\n", - "1JAk0UmiUWXIJCqCNiEaI/M2lzQhbTIMkGMnEmMs2RaECGpoZHCBCMmAIQW6dFGpE9EnR4p5EozE\n", - "3xFpNtjmGm0CcgwQBLQpoLCJR5ssgiwONRQMVFQEw1GeheLSlTUKWMwxi4tLgzpdEhRYoq1WMM0s\n", - "U/NF9h+5k3b7GfInTrC4tMRNBw78EBO+0Wjw6KMnOX9+lWTS5q67buH48Vt+ZqfF1zK+L+n9RRAG\n", - "fZ838stQjMCoIFleXv6x+SZhGFLeqfOFkxfQhh4F0yBZmkQtLvH5v3uES2sQhipPPXWWatWhXg8p\n", - "Fk8ghEa5XEbTbuKb3/wa09PP8PzzT9KtuRAlkSJEU87UAcYAACAASURBVFVC2QWmgBRR1ELT0kSR\n", - "ATIkJEaiElOkQZsiw/FdbiFIMjV+hkyik6BMBYchA3LYhBSvSwViVPIEdBkiSY6ND0cKnSYRISli\n", - "QOLiss0yEsFI6qCMf7KMloe7CIoUcFBoAIFiEGgJkBpVt0XeFoS2RZTNEml5Mkj8MMRzHAASVhYv\n", - "GBJGEXIw4OL6Om3f566jRzHHI7eJXI6ZXo9P/6f/xAPHjjG1sMB2o8Hlixf503/7b/nDP/qjH7Jm\n", - "eDl4DVr6/CP+3b/7c9rtGEWRTE6avO99v3pdw3z58mX+43/8v1lb6wIWvt9nakph/xvfyIzvc9v+\n", - "/QgheOyFc7SdBEdf/4+tjmUlCII8jz56luPHf5UDB7IY1kM88tB/x9QMSlN7mSyUOPnct5h0PPZq\n", - "E3g2VPs1hPDQTA1drdDoRwiKgI8flxEih64WsWKPUOo4OGTHCppRxRvTx8HExiUiwCGFBNpjqzMb\n", - "hXkUUkCdiBQ+GjVWyKAxZNRZBygExGOCk0CgkSRDgixdmvRYQ47Z1irb7GFIB4UhAkjRHl/cJoKY\n", - "BA493KhPUSToqTHZ7Dy2ncY0Nfr9AYlEEkVRSKVydDplJiezJJMW+XzAvn17ieMVdu3aRSaT4Uuf\n", - "/CRdx6GYTtPq99kKw5+YK/LT4sKFC/zDZz/L0akpsgsLeEHA2WvXmDl0iGytw9nHrjH0CmjCYlD5\n", - "JlEQIonwI59IKGT1JKrn0ZY+MRpdbAIcMtj00YnwSCDp4RChE+MzRCUHBAg8BD4WMWsEeORRCKnj\n", - "YeMDBpsk6TIgJjPufDLUsPBZGzPxBUtEY/vnJIz7rBJDmswxYIBOBZMaXdpIYpKEdIk5jE9EAkFA\n", - "BUGFvoS+kWTox1ykQ0wJ2IOuWvjUUWKHgVOl19C5/NT/y71HZtg6fRpdCG45fvyGY9tsNvnzP/8c\n", - "UTRNsXgc33f54hefZnu7yq/+6tt/7ufytYLXsr/ID+JNb4L//J/h3/ybV3tP/tfhq1/9Jl/60mlm\n", - "Fv8F6XSOXq9Cy1lHHwbE8SEMY5bFxWkuX67w2GOPMDl5jFJpVDw3Gtv0el0Gg5DV1ccZDieJAhWN\n", - "DrbcIQxb6OQJqAATKIpAShNVjQnDMtBiRHOMUYjok0VgI4mJqVBiQIDHVUIiQkIWMAhRGDIqZdQx\n", - "myTCBhpk2QFcDAQeGk20sSwXFKYZEuLRG39yf/zpU4yWaXYYZYP3hE4dSZUZVDWFEDlCv4uaijlw\n", - "9CjrtVUW3/B6NhtJVi48T58+ke/TkyGa00MqIZVmj14YUbFM7jpxgltuuumG497sdLC7XUrZLN95\n", - "+mnam5uIToftcpnfefpp3v2hD/Gb73sfxWLxZZ/b13Qx8swzfeLYBiSrqx2azc/y8Y9/lEQiwac+\n", - "9f9w5YpLsXg7ppkmjkN2dl5EVaskD8zxV989STFpc7XaZmLPrczMzhLH8fWubn29ytTUFBsbFdbX\n", - "T7OzU8eyDzCZaHH7oVuxDJtL5x9ml99AY0hKSZC2VWb0JJc1DT8OSGazGKrN0DXo+rM40SyqWsNU\n", - "LIIwoIOCioJBzBCXBgoqbWK2RsobHFz6SHxU5onYwmI/o8wDn5Fja5odLAy6OJTRKOEREuASsYmk\n", - "SYTJAAUDDwONRdK0gBDJBCqzZLCRXMMlIsQde8gahHSJaIoik4qJJGBgl8hmC0xMzOF5bbrdHcIQ\n", - "oshGSpdkskMuN4Fp+kxN2UTRGv/8n7+ZOI6xLIvf+lf/ihdOnWJ7c5PS/v2898QJpn6GWOkfh5Pf\n", - "+hYHi0WyySQwUtscW1ri8UuX+N9/+wPo9pM0GoIrV9apB7soN1awIxeNBIoM2PIbdJQYVUb0SdIm\n", - "QxqVDgNsNBwEMQ16QJ8EGhtETNDEoEgKA4UWVXQCcrTokyNBdpxnUSVFSERAkTVyqNikMNFpEbFC\n", - "jEqRGA0PFY8MQ0IkQzJY6Eyg4JPHx8FjhVFSUYhAYiLwiLDo00TFIyDLVQKUKImu9tC116PJ6fE1\n", - "rxOSJAzXyYjz3H/0Xt549AClbJY4jnn2qad4cXmZ173E0vPkyacJginm5kaTKcOwSCSO88QT3+PO\n", - "O0/8TA+d1yqkHBUjvyhf7vfcA+9/P3gejPMhf6nR7XZ56qmLJBILBIGJricoFHZTq/msrp5mcfEA\n", - "zWaT8+ev4jg2QZDi6tU1BoOYqakCjcYqYVgkiuoEwQRxnCEhfNQ4g5QmEdukmaPNCjHPoWkF4rhJ\n", - "FK2RTksGPZ14vNAiSWBQRKAS0MDAYoiGTZsWMZI8GvvxqeOxgwlI+kQMyGCwwwAXcEkCfTzKTNDl\n", - "XnQsApr4NEd6Ry4SUABsRuw0D1hHsIpGjIUZa5jaHgwZY6oOsVBx7Bh19x7OBW1uftPt3HL8MJ/4\n", - "k0/hGzq9fh+nOyQlXGw5pKEpTFoZrnoBd7/zLSxNTl5vHoeuixcEbFSrzExOcunaNZzNTUr9Pv1G\n", - "g/koQqvX+fKf/RlrFy/yr//4j182mfU1XYwkEssYxoihPxx2efrpp3n++Rc4ePAAL7ywSjb7Bkxz\n", - "NFoWQqNYvJnvfe975PO7safvo+Y0IHWZjbWzDGpdFF1nYe9e9uzdS6u1gabtZmenQSYzT7FY4OqV\n", - "p9h2ewzcPpZhkzQTJIZtErFDRkJdgctDQSP2CI0EpmEipUW+kKdfP4MhQpRwCyGHNGgzgUoDlRCF\n", - "Cjo2sEiPIRcISKLgMKDPgKOAjyAmxiAmxEIngYoQLkGcok+PPi18VAxaFBklRnaRVIEETTwS2EAf\n", - "FR+TBD0mAAUVnQgLlR0EkgGQp0lIWxmNGLtKlY7UyJUS6GqFfq2LN9whnU4zNTVLPj86xvv2HWRm\n", - "poBtd3n3uw+xtLTIE088yxe/+B0URce2JQ888Ebuf8c7XrHrIooinnziCb72d3/HvG0zOTnJsYMH\n", - "mcznUYUgqSjMzs5wyy1TrKy43HLL/Tx10mbzVJN9aUG/WsEMY84OA9Z8Ax2TSMwg4pgJklTYRuCj\n", - "E+DTpIuOzZBJ+iRpMcCgTBZIYdFCkmCfInhebtKmhYVHBuW6e+sdaBhYCHR8RomdAR41IKJNliUy\n", - "mHTxUfGJaGOgEJJFRZLHHRv1u/ToMeqPVFQUJJMvyQmOmJ7KMOxcwB/6CDVAxiBFSECXRLrE/bdN\n", - "Ml3IUW93SNk2lmGwu1jkhSefvKEYuXBhjWLx4A3HXQgVIXJUKpVfymLk6tWRkdj+/a/2nvxkyOXg\n", - "wAF44okRofWXHe12G0VJMjmZp1qtkEhk2N7e4dyZi7Q7NZq1p1lZgX373sDU1CzgcuXKi5RK0/h+\n", - "lURiAcNIsb19DiGOIeM6SdlBU1Ij4rocZc9oxARKFUXxUBQwzR4zM3u55itoYg995xQRC8RYRAxR\n", - "KJPHJELQpTdmlCVQ6GGyQ48mSTw0bAJs1oEKWXT6pGnSp8wsQ1KoeIwsFzQMEkgaJAkJeQaXHB55\n", - "YlYw2EYnYJIQCx9BGDvMmjaRFHSVHe69d4mPfOR3WFqaJ5fL8a9/7/eI66v0Gw3KjospfSZig56d\n", - "JmOVWMjlyUQDvKHH1M0389Rzz1GpdTi3VqczjBgKhzv3z9BfW2NKVdmpVgn7fWQUsb9QIC0l6ydP\n", - "8vm//mt+72VGSr+mi5HvFyIAiUSGWi3F+fMXOXbsKP3+gJmZzA3bb22VkTLDxMQeZmeX2dra4NRj\n", - "jxG7ayRKDjOlfayeepKN9eeYnJR0Osp1h9Bs1mD38h7On32OtZ3LdAcNmsMmeX9IPmnT1U00pUTR\n", - "tLjSXkdVkxhSJbYd3DhEYYDqnmJJSOaNDJVIpUePAV0iMoQkOUSEhiCDgo5KjyHhuK+VKIRATJdR\n", - "VqSJAxCHKDiopIjIk2GbeXQS4whrD7iCR4M+DmVCJjBREDjobDKNgkfEEHdMa9U5T4ZNRkRTW9FA\n", - "vYqeTkIcs5jRmJQeatRjPuPg5gXpeZft7VNks1mWl5c4fnyZd7/7AZLJJJ/+9OdZWYmZn78LIQSu\n", - "O+Bv//ZhUqkke/fufUWui29+9atce/xxbs3lmFVV+u02Dz/2GL9y770U0mmGUlIqlXjwwd/ixRfP\n", - "8OyzZ7GVNT78vz3AYDDgiVOnCLtdXiclrK4jwpgmAwJRwpcBSlSiQ4ygyQFmuUKPA3Q5MDZx9hmy\n", - "ic8GXZYpcoGYa7JLBoFKCo9FrmLgI5jhLAEREp+R1dyIhOYT0ecwJmsMaBKRw8VHp0IOhwmyxCPt\n", - "Cx4+BioKFhlqdFknZgbIIhmFNaqKRJgKCVvg9IvEIsCX6+i6SQCki1kMq8BGzcbSDcKoQ+L8Br92\n", - "11EMTSPwvBuOcTabotEYYFnJG96PYxfbtl+R8/pq4xeJL/J9PPAAfOUr//8oRjKZDHE8oFDYzXD4\n", - "XbbWTrFRdkioGUytTzFt0Wl5XLywRqk0ja4b7N6dRNddLl6skkxOAVvkcgaum0bqoPa30eSAjKLi\n", - "yhohApUkgUwSxyphOEBReiST02jKJYSvopMjoI5Hg9RYuxghaSIJyKEwgwRSXGUR0JnHoUefBm08\n", - "HA6SRh9PTiUaHofwWUMnwEJFjE0SDUJMfGwCFulTZ40aJjZzFK9z0bbxGcZX6bgemqqQnJrgE5/4\n", - "E6anR5PRv/iLv+T8yTPcVtxNNZugKYZ0emW6qsEubZqskWa702d2eZ5hf8A7fuM3+D+ffI7vPLZJ\n", - "RqRJZyfIptN879IqS1qVXMJm2O9jSElsmhRTKbqOw0w+z1Pf+Aa/8+EP/1Bi+0+C13Qx8oOI4yGp\n", - "VIJkMsm+fXOsra0xPT1qY8IwpFIpUywmyWQKdDp1HvnyX7LLG6LGkly0xrWNNRaWlukEDrO7l/nu\n", - "46sEwT4URVCvXcJrPcPCtEon3ESpXeJY1mJAEqGq9AcxjhITJkOSc3tRZcBO16dfS6JIBS9MM8Uq\n", - "epyg7nroWGRQSQIVInRSDOigoxCjo42Nfkdjv5EKZuRyMVoK8PAJgJAWghwOk4RsMYeHzdzYBDhE\n", - "JWYanT4ZbAIyVGniMI2JTYiCwMfBQjCDwgoOOkkC+hSMNDnbZULNk0uoXBhskG5XEPoEqmayVEqw\n", - "tG+WcNccH/zEHxMEAZZlXVe07OzscPlynaWlfwy5G0V37+ORR556RYqRVqvFhSee4O5du9g2TS4+\n", - "8QQL+TzRcMjz588zMTPD8vHj1wmzt956nJtu2k935SyL+Tz69DRz+Tyf/MIXuLK5hfA9DA28aB1H\n", - "ghtr5AhJ0sakwcbIN5b9SArEGGP3jwQR27hs4NMiTZMOJjEeBlAiJocgyZAaWzRJ4hPRI8SgS0Af\n", - "A0GERRJBnz5dfFxKbFDExiVmxKd3cAjpjQW+ginMMbk1IBh7MypI2SOXKKDILPMlHy+TYiJnoWsG\n", - "qhCUey0mZhYoJmbIpwuoYopWr87Dz11k/9Ik+97ylhuO8113Heczn/kW6XQeTRsR2er1MoUCN7hh\n", - "/jLh29+GXzTftne+Ex58EP7Df3i19+SVRy6XY9euPP/9c3/BTZrNlfpFYmdATbgsTs6iG10c18Tt\n", - "D1hZeZaZGcGb3/w+arUyKyvfZn6+wGCQw7Jm2Vp/BiXwGMgGBX0KoYQkgxA/DhhSRXIEoiyaMiAI\n", - "Klw99wgTps+m+zzheDI5pEBIhD5mejmESKYQ+IDKBAMMCkh8LEys8QSzxYAJ8gxwadIgQ0gdhQSS\n", - "Mj7zqIy+ExTq+BgUmUIjYjcuQzJExExhY5NSXCzpUzfmmbCvocQRm/U2D37gd7nt4C4m83n+9n88\n", - "xLKeI22l2Ilr5JKzKG4TS6q0RYhBB5UhneolxNQyW1tbXHhujbccv4ekNWo8/DDgzHZAU/c41djG\n", - "cxz2FIvszmaRQEdR2GVZVHWdZrPJ9PT0T31+X9PFSKu1Qjo9N05gXCef9zh2bCQX/YM/+Jd87GP/\n", - "F5VKiK7n8P0usMrRo7eRSuV4+pEvMu267MlN0h263Ll7FxcrFV5Yv8BCMknK0Cn4Fa5d/QK18gZ2\n", - "Y4uEEFiaiuLr7D12mF36HlTH4ezWFtc2msRCpTi7n/3FBU6tPMlwWEaEBUy1QCx7ZIkxqBKgEWEx\n", - "MpafZYCDS52QmDlMJIIUA3wkXYqozBByCkEe0Ig5i4KHRUAKlz5TRDhYDMZDuZGtToTERJIjwiJi\n", - "FDjtMYegQUwbnSZ9poEEMTtKREXqLJgKXe8iBCUMNccWEWu+SywTeLHKwaV5FASNap1TjzyDf/Ys\n", - "hCHvfO97mZmZuX5+ut0uqpr6ofM2Mhla+aH3fx6o1+tkFAUhBMWJCZid5Tvnz6MrCjudDr/z7nfz\n", - "5vvvp1wus7Ozg2ma1CoVXnjxRXquy9B1eXZtHUsKDufzVFpdkopgEAxpyvNkRYogdpkVAck4Znuc\n", - "A1FAIGHM65CogEXEKi1cUtgcxKA5NnAHgywRgj4zlNlhHh8bD38s3A4Q6JymSB4diyp9kvQwsKii\n", - "MYGKgqCLRhmXPB4D7FHXhkSjjoKOx0h6aJpL3H33b7J1dQ01MkGepZRZxDA0au0qrdYl/tnb/wBT\n", - "z7J29gwF00RTEzy/UmXy0DK33nbbDcf5wIEDvO1tNR566CRSZpDSp1TSeP/7fzaXxdcqpByZnf37\n", - "f/9q78lPh1tvhXYbrlyBV2gQ+ZqBlBLF6XL3Yop+w+Ga7DGrR8yqFu3IJqmpDIx1/KFOPv867r33\n", - "Xdh2Cs8bcu+9t9BuG1y58iSDrassSIEIE3hyQMuvoGgJMoksO/0ukkVM0qhIEtYEA1fF8RpUvT4G\n", - "XZK0CZA4OPjM4WMA14AiGioWLSIa47yxNt9XyqgIDFwcNtkmIKJJmj5JNDqE7CKkSsgFRubzLQRt\n", - "JrFJ0UQyyhuHOWJqVLDII6VHEkkl3Gazb2Ia82jqBJdecCmvvsDdhyfx2j06rkZQCNE1laHbBzxE\n", - "4NAb9MgrE0wKhdhQyFoWn/vMZ0hgXS9EAAxNZzaZxcnM8oa3/wpf+7M/Q2garSCgHMfsmp2lF4YU\n", - "du162ZPT13Qxks936fdrgEKppHPixAn27Rslmh47dow/+ZOP8vnP/zfq9W0SCZ19+5aZmzvIYNAl\n", - "aFcpZvL0hl0yCX0kia3VCIcOW6FGIemh9zo06quYQ4e8uRddzxEEbWRth9PPnOLW33wPvUuXeOuh\n", - "Q3TiNfxoF7GeZavZQLdmKCUc+p02brCKwCciSZKIHjEBJUIMIgJ05pCEtDlLlwiVAhoZAvqETGPh\n", - "EqIjmRqTExexaGJSZYoVZqmwiUcWFwWJwciwS4yH/0NiYoYkcQiZpUuEIKCrSJrSpIdHDp2MzLMb\n", - "HTccohIjjASVQCNh7iZjR3QGfVZ2Oij+M0yGAZGqkUgX0FTJoUSCb3z2s+R+//evV72FQoEo6owe\n", - "Ei+ZbXc6dRYWXhnSaiKRoO151DsdHjl5kpTrcmhigu1Oh342yy233cZX//7v2XjuOXKMXFtfvHCB\n", - "Ww8f5isPP8mVay16jkVCMbhoCSw1RgybTMqIkgKzeoSwsoSaJJfIUGjucHLoE2sqMojQx0I8BxgC\n", - "eUwskvjk0OmQoM2APgFd4vHyW5IEKsGYrJYgh4+Di4tNiavkMCkRsAroTKMxSwOHUTi4QoRDl9FD\n", - "UpBEIAjojK+jSaCGbeq02zViRRKFLmnbR7LNTiNNJlHCNJe5ePEKt912K0fuvpvNtXWGnksxvZff\n", - "+uAHSSZvXI5RFIX77ruH17/++PWibm5u7pdW1nvmDGQy8DIDR181CAHveMdoqeYjH3m19+aVRbvd\n", - "ZlCt8ua776LT6XDx3IvEcZZcapJe0CNtzjGfEvhyhampSVx3QKOxSRRtUSiUWF2t4neGHEjtRwQ+\n", - "QdCgYE5gdnfYEB5Nz8YlM1r2pIUpptGlBAZICoQETJBF4uBTJ00WhyodNCAkwyS6EjJtaNQ9h5A6\n", - "Eh+FFIJJLGy61FDxydGkiYOHTxadAIMNPFK4dBHUMOmzG4sCSXx0FAJGDW8fhR5VpuiRR6WDRz9W\n", - "CdiPG5iYuIhIpz+4mcdeXEFG81zzN0lWt8Br4rcrJIVNUxmyW1UInCpX8xnuv+Mu7rntNj796KMQ\n", - "ukg5yukC8AOPzqBKfkrjQ7//+7hxzLc/8xlmdZ3ZbBZhmqiTkxy5886XZeMAr/Fi5F3vOs6LL15B\n", - "01Ruu+0Qb3rTG2/oyo4ePcLhw4fo9XqYpkmz2eSTn/wi5bKF6wwoJFQa7TJHlnfT7PVYaQ+5PMgw\n", - "q++ivmrisUi/f5VZOUcUpdA0ST6/SBAUKTeeoOd5yFyO7VaL/XmDL595Eax5ZmdmGTQr/x95bx4k\n", - "2XWdd/7u23NfKmvfq7qq9wVodGMHsXGHCIKiYJOixSFjtIwkygprLE9MTMwowjOyJyTLYUsOx4Ql\n", - "DYOSg/s2JAASYIMglm6A6AVodFev1VXVtWZlVe758u13/qhkiwRAUwKaACF/f2a99+rEuy/znXvO\n", - "d74P2dKxZQZTDCKkwjIzuGygIbAo0URhAwOPPhwahKQRDOGLEUIMArmKpIjeKe/pjODjo7FIkjVC\n", - "GtSJ2EFIiTV66GeZCIMyXeRQ0dnEYRmf7QgECiVUXCIQAlVLkUjlyVZX2CFyCARu6GGEFjY2ZekS\n", - "s3Yj1IhqvYwIA4SWYqHh0mtGpCKHs0sX0IwR6rZNr6rynW9/m8mpKeKJBNPbt7N//xgvvXSawcEd\n", - "6LpJrbaBbV/h7rt/+bo/DxcvXuSpRx7h7JkzPD43x425HNMTE0RRhOv7jI2N8Zf/6T/R7fvcOj6O\n", - "lJKrp08z5nl8+dEjODKL74aoUuJEXShBL7VoEz06w7Ci41MjlBFELrYd0AgChnoLyGWfY16b/Z2f\n", - "FZuQCygd3RaDOGXWWKebiH4kl1jGJ4GNikmTOKIjHN+Hi03AOgV8NvFYRTBBmxwac/gE5MmQBFJA\n", - "QJsWEh0HQZI8slNxs8mgsYyu9ZKyeogldK5e/haJXB92fZVYrELdyRCzUrR9wfZd+9G0fk6dOsX7\n", - "3vchug/dRLm8Rjqd+W+WVJPJ5M+N+/OLhCNH4L773u4o3hgeeAD+4i/+8SQjUkrOnDnDsWMv0Wza\n", - "9PVl2bt315bycueYUqnEwPBOrpyfwXZjSCFBkZRbVaa3Z/n4xw9RLJYZGhqm2czxwx9W2Lu3m81L\n", - "LzMY76FebxAEFn19vTiXbEzfp67uZGuAtoeQFoHcwI2SCKGhSLXTakki6aWFh4JKikHaRAjaCHwk\n", - "0A4CYnRTx0bDJkYfESabVCiiENDDCmdJ46GTpNSxvUtiImlygIhnkaj4+NgkMHAIENToRiUOlDHY\n", - "RKMXnwgXjQQRBnm9n6pbwRcJ+tIFPL/IjuFBZmYFl+vnuUHxSMXjLLk2ga5gduU4NDzAaszi9oMH\n", - "sQyDke5u3OYSq5uzdKWHWS1dobx6kXZzjd7efXz329/mN3/nd5jato1TTz1FXEpELEb/zp2878EH\n", - "3/C6/0InIw8//GE++tEIIcRP1alQFOVaJjYwMMDv/d6vcerUy3xp/YeMmwoHb7yPlStXmC8WuVC3\n", - "KPRsR8EiFiuQ04Y4v3AKTTewrDiqGqHrFppm4FZjzCwu8on3vY/lpSVePnIEqW+imAbFWg1Lb1Ai\n", - "hSK7CVA7VZBeKswy0Rm29Tu76KtUcOhCMo5PGuQGAo0kLgEgqaEyQESAYJZhVujHJMRCENHCA0Ic\n", - "AoZQsVBZZhNnS7yYQSR5UngIWmKFPtGFp+hsGt0s1UqMGXFCH5zIxcYmwCPApO41CMMy+ZhORiiE\n", - "uoZlxCm1FV5yVuk3ChSlwa7MAb59bAnpzZFNxrFuvBE3inhW03jPP/kn5HKrHD36Q3w/oq8vy0c+\n", - "8kvXTZXvR5ifn+fRz36W3fk84/fcw/+7uIhTLPK869I9MMDEvn2MT07yH776VQ7ecw+e5/H88yc4\n", - "d2Edt92mXCyRFg36pdlxd7lA2V1FUfbiyyFa8gq2CEiRQLpxND1Bud1ivWLjJXop+UVOSge9w+VI\n", - "IBlHsEaDJm2GOgoCATBAkyVsFNJEWGzZjmfxcZCsM4EKJIjjoeAyAwxgASF12qjUkbQIOo6dggRb\n", - "LJ0WDlvEMJUUqBpCLZJM7CSf1enOZKiHBtZASLvWIG3lURWFlhDs3beL2dkVSqU2s7Mvk0ymMIwK\n", - "Dz30K9d1nd6pOHIE/tk/e7ujeGO4//6t2Gs1eIOb0l8ofPe7R3jqqQuYZoHTp8+wsdFA149w6NAY\n", - "QX2TnOdhVxrkcn3sOpDkpTPPUwpVmrUXyQzl+MSnP8a73/135kL/5b/8Lel0L7bdRjdN4ok49XqL\n", - "KPJYWztHGLYJIp1UdpJa9SIyrBGQJIwWCf04vmwRsQZ0IwmICDHowWUNnQwQECNJyAJS6oTRVkU8\n", - "wGYOFYMWkio2ASYuaYoMEwIpDEzSRKwiSJLEI2KNJgZJUjhUWcfB6Cg+S2qEuPiIjvHeLLOoRPRj\n", - "0sCBsIiUJjEtQ6VRJ58O2Dk2zHKpTKWicUW0yRsGo6MT3IBk0fMYGhrEs23arkvMMIin09z+3nu5\n", - "9MJxzs1+F3W9yFjMoH/fBO++807OnzzJ9zWNBx56iNvvvptyuUwymXzTEg6/0MkIcK0sHEURp0+f\n", - "5oUXTuM4Hnv3buPmmw+9pryczWa55553sX37FF/5q78i8jwmDx7kYiBorzTpEjqVioumNVBViUuB\n", - "ctQmpZg0vHWatosf+lQ0wdgtt/BCqUQ7injZhr7B23A8Qb1VpdGuU/cXOnLAfZi4SOYokCPAxaJJ\n", - "PyoqKhYaF2hQQ+nskH1gBZOQLIImVTxWkFhkWWYQCwXwaJDBQ0WhTURIiV5UsljkMfA6ImpJxaIY\n", - "OQR49EmBrdTxMIiiAEvRaEeCTdVDRpt0AwqSCh5FXNrUSMRG8F0oxHRUxaThB/ieQdvoYiSp09fV\n", - "j92us3Z5ifs//B6mOmp79VaLJ776VX7rD/+Qe+99F57n/dwmLZ5/6im2pVLk02lsx2FoZIT9sRiX\n", - "y2UO3nknuVwOKSVhEKBpGjMzF6hUBGBytbxM0jJu0wAAIABJREFUX6SyEbYo0GQADUHEChvMy3NU\n", - "yVIFFBnjvG8wKARR2KSpKazTw8DoFFVeJl9eJUvYYbtDEhcFlxV0LEZRSWLTwGeTBBU8JC46G7QZ\n", - "QOLRZgAdHYMKEBHD7FBZ50jgoKCziUedHhS27qTPZdbppUDAOmvUaDCAJIFpOPSlcwRUKNdLSJnE\n", - "823uvmOaSj1Js9m3JYgXBJRWVrjnnls5ebLF+Ljg4MFJ9u7dQzqd/m/c9euLMAw5d+4cp06dI4ok\n", - "Bw5sZ/cvgO56EMAzz8Bf//XbHckbQzK5NU3zyCPw8Y+/3dG8OZTLZZ555gzDw4d58slHkHKc0dEe\n", - "isWrPPvsIo6zwRntMlmvgS7j5AfGyB68h/1mhnrdxbbLXLmyyPr6Oj09PQDkcmnW1pr09Y2gpNJs\n", - "tDdxnBKeFxGL5bCjBm19kMitoBtZIncVEfkELOHKFJJuIrZTp0KIR4oGCpCgSZuzeHSh0iSNQ4KA\n", - "SEo0QrSOt7pLHQeDLgJiCPpQ6AOaRGiEpDCRBJRQyJDBpkVIQESWJG2iTtUli0DHp4mCz5ZlXz8h\n", - "NyI4j8MZGuTDHFXpgJS43hpJPaJcrhGP6UwP7mR/VjKkaeTSaSqVCqvnzrFSq1GJItx2m1fKZbbd\n", - "eCPv+9CHeGH/MVb/+I/Z1T3B2LZtjE9OYpgmu4aGOHriBPe8+93kcrlrAw1vFm9bMiKEeD/wZ8CG\n", - "lPLOn3X8N7/5KC+8sEhX1wSaZvDkk4ucPn2J3/iNXyUej7/m+IGBAT71+7/PmVdeobK+zoRmcmzu\n", - "NA3PwgvLSDWi7gUII8NyGFCzL6JEMXSZox7YJLpGOHD4Vu67724ef/xJvvitM7ScHA27RbWRx26l\n", - "kHK94/qxhEEBCDGQZGjQjX7NgzeHTYoUAS5NNEICNAq02MBngxg+KqtAiQwBLZKotEnRJEdIhRAd\n", - "FbdTCNwSLzep4WEjaUQBc2hkhEZSS6CKPlKKSTloo4cZ1qIio0bATjWJDANU2UaIiD2q4JxaIp7d\n", - "T+jqZOI67aBGt2ejaClSKZN2KkXcSnF59gQ5K0fqx15e6USC2OYmCwsLTE1N/VxHPotLS4x1/G3i\n", - "lkW2UKBWq5FLJPD9LSPu5Y0NxvbuZa1aZXFxHc8ziUSSCANfuiRwmcJAQyciopc2NbnJJj62opBW\n", - "EsSjURap4ouQtIxTrydonV/BbvvESQAuBRRMQhq0WUWhxTixjuiRZAKXFA4aChEqcYo08aiSRhCx\n", - "JWVn04NglQgTjTZF6qTJEVFkDImJRdhRZtyGzRo+kyTpRXCRVdbJkrEyJGMh9aBIKt7NZrOBIddZ\n", - "WdJoNhrMr8wxlpmkHYasrq/TPzLI+Hia3/iNT73lDrtSSr761W9x8uQq2ewIQgg+//nn2b37wlsa\n", - "x+vh+PEtrsh19Px6y/HRj8JXvvLOT0ZWV1cRIsvm5iq2bdLV1YOUEaVSgyjSGB+/m1yuTjaT5tnv\n", - "f4lRM0MoNfz21ijv4GCAlMP85V9+ic985pOkUikOHz7AyZNfJ5s9yM133Mszj3+NllMkFqRY8xqs\n", - "Rm08MU3ogK610PUhFNaQfgxdH8EPs/hhD6oW4vovESGJMUeMNlUSQDcBIUlWyBCnjY+gQZIMeVQ2\n", - "CKgTw7jWrm8SIEkR4BGiIDqTeG0ctrx2NJrUOk3abhR66UXpMA9TnfRng02G2JIKiBGSVTdA1bEi\n", - "lYZfR4oWSW2cudVVWn6D4d4kN92wm7PHjmE4ztYGLpXiOzMzJHM5yk88QXpkhN/+1V/FNE1uOnyY\n", - "k4cPc+erpuc0VcWQEtu2X/fd+0bxdrv27geO/KwDV1dXOX78CmNjt16rlCQSu7h69QynTr3E7bff\n", - "9rrnpVIpbr1t62/Fyt+i6sepejkaGARNG8XKks5tGSIViypCjGIKhb7hLj7+8Qd5+ukZ9u3bzczM\n", - "JRSjC6elUG8pKH6anGgjhUdb5hFs4uKi0sKgQQpBHBCEgIGPIIWGTYk681j0ENuS1qGLOgY6FjVU\n", - "LAIicjQB6EeionYcDHRW0Gni0oPGJio+WRL42NRpqgo+KZp+HEsRDMXj9Kghq6Fkw/EZ8BpUhdbp\n", - "Q/qkUIlpFnNRhXL9GKOj26jUlhhNhfTEuzhV92llMwSJYeabLUQqSX/BulaJCsMQ13WRYUgURW/6\n", - "YfhZ6OrtpVIuX/O9ObRvH08++yyNSoWuZpN1x6GZSPDpz3yG73zlKyxWK7QrPnaQoK6bGPYawwg0\n", - "AgQhKhEqkgIu66KGGzmsRAqaCEmbOQoRVMI2vmzQanuEhFwhTpUkZWxcKngISh3p5hJ1YkwTUgNG\n", - "EcSJqCFoI9lNmRlqpDFpkCTd4cprCFIU8RHE6aMGwAQhLg02gBg6XShIHAQxUorFNAFJa5W+0TiB\n", - "LxnNHKDlO5hqnR4ni3ulSC6qUw0j1tuA0kUulebk0S/wf/7p//qWJyIAc3NznDq1zPj4zddarrlc\n", - "LzMzP3zLY3k1vve9dy5f5Ed48MEtzkizuVUpeafCNE2k9PA8ByG2ntNWy8ZxArLZFLqewPfL7Np9\n", - "C7l8D5cvP8H8vCSb7WJsrMDU1DYsy2Rx0eb06Ve4/fbbGBkZ4aMfvYtvfetpMpkYuw7u4ZincGXN\n", - "xtT7CJwmvr+MIvpBCoSh4bQ30fVB4rExaq0yQimjKAWEVcD15nEjmzKTSMZR1R5CKbgqV0nTRpM1\n", - "hsgR0ouLjUuaOBZtwMeiSYIUATnaCFQsoNH5PVqjjkOOMgoByxj0kqeOgk+EwCVPg0pHfcSmjkaD\n", - "gIppcVfXKLbrcqm+xLlAI50dZnp6HFW41O0K1UqRrsK72H3rrVyemeHM0hIzts2DH/gA+6eniZkm\n", - "fhDwvS9+kd7eXgqFArF8nmqzSfbHHqq26xIaxhsmqv40vJ2uvVXg7+VZsrq6CuRew+TXtBhf+9qj\n", - "bGzUmJwcZvv27eg/xU+7VCqjqjqm6WH0jlCrFXGcSzhOg0RCYWRkG6nUAJommJjopaenh2KxyeXL\n", - "sxiGghXPsLB2iUYjgSV9wjAkKbUODVGgM8tgp4S25b24Zam0jkMNQRql48p6FYV5QjzUTvmtBw0T\n", - "g4gkm8JDlU1MoIWCgUIVSQqLDbKsYrJJSIwcJjplAVKtI6Iq7ah3q4cZxZhtrdFjCWKmhxEI/KBN\n", - "oGukhUaXmcYPAooIjFQX8STce2CAneO3c/XqVZ5+6SWcRDf3f/C3KBS2WjKnTiRwLn+fXC7HxYuX\n", - "uHhxEccLuOA2GbvnPqanp38u/jM/ws13382jf/3XxC2LZCxGJplkcvt21vfvJ3fDDRT6+ti9dy+J\n", - "RIL/4Xd/l8vLGxz5wnfRzH7C7B0EjSV8GaAJCGUTXwoCITCkS0Z4DKOxIBu0ZAUlyLEhPUoyThRl\n", - "UGhhkCSiyAYN1sh3zL8XCBlEZxwXSZ0UkhVgGjpPhY6NhoLcGpamhIOFh0kehYg6q1RI0o9CAZ82\n", - "kEXFEAZIlxKSGAqakCT1Fn5YR0Qhg2qcM5dn8YMJVlKXSVhtxoVLT6GfjaUmeUtwRz7NU7UFsqMq\n", - "d980SaR0v8Zs8q3C7Ow8ptn9mmckHv+H6xFcbzzyCPzrf/12R/HmkMvBbbfBo4/Cww+/3dG8cYyO\n", - "jpJK+dTrEbA1qef7Hp5Xp1DYQbu9wfDwVvslm+0hlcpy3303MTDwk4aaiUSepaV1ms0mMzPnqFTq\n", - "PPjgu4jFYrzySp7jxy/Sm99JV6qLpfUKdXuNIJwlijYQogtFa9FyUtjeKqAhpQvUMM2QdGYYGKNe\n", - "XwFeAnQUJSQWVMlj4GOSJUMLh01CItK00EiQJINGDQ+DkDgNXCI2aLOGgo2HwwAecbpQaGAjiaPQ\n", - "BJSOqEDQ2Zr41EWKV1SPMd2jz1BZLs3QCGE+EsTNGJacJ6P3ceuBPYz27uALR4/y5OXL5ISgkU5T\n", - "Bh7YuZN7brjh2n2LmSZ91SpnXn6Ze+6/nzvf+16e+Nu/ZUcYUshkthx819e5+cMf/qnv2jeKX3jO\n", - "CGxly+D9xGdLS5d55pkfkM93k8u5vPDCUcbGTvJrv/bw6+78PM8lnZ6iu3uSVmsdKQsIcYBTpx5h\n", - "cnIQw9hFOj2AZSXY3FxmYWEB09waWd23byd/+qdfQGjdKGqOwFfwow0ibBSSaBSJUyVFHAeTDXxm\n", - "cbAAHYGGQo0aJfpI02YHOkkSBNg4BNhIYqgIYTFh5VhrR0hcfFR8wESQwceghIWByiguBiExsmaW\n", - "ml+gHS1jkKKCwKWNkDHm2xeZJM8UBm0hcKVkDZWiI5CoFIMGOcsk02zylcceIz88zD3vex+/+8lP\n", - "srFZ47nnZlhaqiKly9CISWL0Th49eozNxQaxRBclEbHtpvfx/e9fIh6Pc8cdr1+huh7Ytm0bU3fc\n", - "wVe+8AUUxyHV3c1N99zDrz7wwGvaQ8lkkqkdO0j2nMP3+7H0JLaRZ8XbIKFIUkKi6yp5z2MxDLk5\n", - "nYG2Q8XXKWJTDZJ42IQUMNFQyeF2Jp5MdGIMENGgThudDA4NdNZJYRGxQYsr+PShoaDQIksdFejC\n", - "J6CLNer4VBCEHcXFNDFK5NCIiKgQ0Y3syMfHaAhBSwgSnkOGrRHkZssmFqkklIhos0JFrLAr202p\n", - "fRVpmix7AWtlF1/EsBJd9OaztD2PoNPSeqthGDpRFLzm8yh6e+L5EUolOHduy+flnY4ftWreycmI\n", - "rut88pMf4XOf+xq6XmZu7gcYRpqtgmgbw9hkbGxLE6dcXmX37glWVpqvuY5tVxHC5N//+7/GdTPo\n", - "egLXnaVYnCGR6KPRcJFuRBQ1kCKiv7CXavMEMoRAFImirYk2RRlHCEEQLBFFPr7fRlFUuru3kUop\n", - "bGysbfmn+VvjtzXawCZOx0NqawR/jgRxfBKYDKAzxlUcymyQxcemTQIFm0FcklTQ6MHDRNCmixIl\n", - "EkSkO78PW6olCoqWQbMCArHJaDbNbFBnyc8RhVkUstQClW88e5G665CNm8yvrdHwfbxmk51DQ2SF\n", - "oDgzw1ldJwq2vpu9AwMkTJPa5iYAu3bvRvnkJzl25AgvXrxIrdkkmckwf+EC2VyO7a8y1Hsz+Lkn\n", - "I0KIXuALr/p4TUr5sZ917h/90R8B4Ps+q6t1urrGSCazeJ7DiRMvomkD3HjjTXR3dwPDzM+f5vjx\n", - "E9xxx+2vuVZPTx+JxGXa7RaZzDBRFLGycgldT9FqNVlcPIFlNYjFVPr7B5mbW2J6WmV6+t08//xx\n", - "tm27gStX6gitCn43vtRwUIkj0WmQxiJOhE+Eik8GSQFJHI0WIQ1CQqoMoRJHR1Ahh4KPTgWbJhED\n", - "ioqCTlKY2FJSJWQUkwyCJh49OKygkcYkRRwfScXZoEUaSQFVdeiKFBRp4hBioaN4AQk1Rj45wXpj\n", - "CUvLUUgPcLW6iqdmyAuFCEFCSXLpXJFy9AP0/CDvfvcd3HrrIVZXVzFNk9HRURzH4X/+g/8Dxifx\n", - "k1l2Dm8nl+vBdds89dRxbrnl8M9t533ku99l9tlnuXNyEsfz2HRdkLKTqP4ktp6XGg8//Gm+851v\n", - "UK83sbK95F2dUnuDtiUYMAxmKhUUy2Iin+dsqUlOibMvMczpjSIekCJDHoGHoE2ys49ZRyeggc2W\n", - "0mqMJJcZJsBgAkhjM88aNSIGMPAp4NKmzFZ3tUQMjS1JuF7SxCmzgUMdnYheFJYJ2ZARbQzWgTkU\n", - "xqRClgQqkpL0mZMxIhRq0QZ9Yhw7UthstOhNxVnaXCOfTrFtaDd+u4ZlbOfrz1wgnvUwd+/GisXY\n", - "vn376967nxd27tzOE0+cwPNGr9k8+L6H666+ZTG8Hr7zHbj3XngD6tW/cHjwQfgX/wJsG65jK/8t\n", - "R39/P3/wB7/Jgw9e5oUXjjM7u8aFCxt43iwHD96Lpumsrs5iGBt85CO/zOc+93VKpSUKhUGEEFQq\n", - "6yhKiYsXJZa1i97eAgBrazHOnTvH/v0xJidvYuHyJcDCdoqoyioTfZOs19v4ikUkU3heGSkvImUX\n", - "qhoBZ4EQTfPo6+tlz57beOSR79NsmrjuHAExQhRc6ixRJ4XKts70C8RpYrPGLDCKh4JCjinKBCi0\n", - "kASkiFDIoNJEdGZ32tTIUaSESoSPTxUXQYaUX8XoSXDD9ptYuHCRBbVAPrYTvyFoRRYZs5tmK8aR\n", - "Z8+xL9XCTFq4vs8tPT3QbLJt2za+fvw4pbPn6O3qJptJsZq6QDOf58Ef61vu2LGDvr4+/uY//2fG\n", - "43EGcjns1VWe+OxnKb73vdx1993XZd1/7smIlLIIvCFT7h8lIwALCwv8zd98k3I5xuZmiVqtzi23\n", - "/CgR2UJ39xgnTpx73WTkwIEdXLjQwPMSLC5eRVVVhod15ubq9PR8hERijVKpQrMZY2bmOUZGQn7v\n", - "9/4nenp6OHNmlgce+DAzMxc5evQp5mZP4NGFgk5ECUmBKi7T+Ci0WUdhBAVJRBENjxRpkuQpYiAJ\n", - "qVEggYlJEx+BTxWDRKTQbEe45KiwThYXC0ENnw1CepAoImBThihCoElJFkGZFioemjDIGUkanktM\n", - "eiTwSRCgxLMkdRvPHOGsY7PkGMTUPgZUiyv2BoNGjpRrkZMFFufh299+gRdfnOGhh+7kgQceuKbt\n", - "EgQB3T1jDA//ZAXENGN4nsC27Z/LdMby8jLnnnmGm0dHUTutOiklPzx1issHDjD9KmczIQSKIujp\n", - "GeLhhz/FlSvnOXvaJlq5QNxXyOYSLK6vY6VSHMzliCUSxO0YC06EFxqECqgRWJgdyXWJikaMAJda\n", - "R1cggyCGgcoAMUwCBCtINDK0CLBZI0Sjhck6/XhYpGlhYyKp4tOkic0KSQIcIspI4vgoisrJKIZN\n", - "BodukA5xFunFYB6DGkPopOnFpI5NSa5hkOSqV8atthGaTstPcGphhqBnlIQneOVSjcmBFsqlS/zw\n", - "zBle6O7m4U996rr3fX8aenp6ePDBO/nmN59BymxHTKnMBz5wmH/zb96SEF4Xjz66JRr2jwGFAhw+\n", - "DI89Br98/WV+3lJomsaOHTvYsWMHsMVRO3HiJM8+e4pKZZF9+ya4666P0dXVxac//St84xvfZWHh\n", - "OQB6e5Pcf/+dfP3rz9PTU+icHzAz8zKaFufixRl27DhE27YImnVUJQDpUKoXafkOfpDHdUFVI1RV\n", - "IkSFMKyhaS1GR3dy0005IMHJk89Rr1cJwxxSbkdHdNoosMJVdhIhgRCPiBox0nRR5yqzFFCAgBYR\n", - "ORRUFOZoIcjSj0EZBxsD0TGkEOSYo46PTT9pVBxMvU2YHKZg5vAHhpi/AhtuhBEbwPM8Wu0mKVJE\n", - "UQwHhRtySa7WalgjI9jVKqdOvsRipck2qaGJBG5bZaO2RsXzSKZSP7EePzx6lG7HuTZJmU4kKGQy\n", - "HP3e97jh4EFSrzr+Da35m77CG4QQ4iDwb4E9QojHgV+SW42518Xo6Ch/+Ie/xfz8PJcuXSKRSDM9\n", - "PfWqo+RP/X/79u3lxRdfYWUl4q67biQIfJ5//hEymUGSyTzZbB+p1Bpzc+fZ3LyKYRQ4ffoiY2Mj\n", - "xOMWUkYcPnyQ0dEevvKVL3HhbBUZtojoRiWGj8F5ztOPJEFIGskiKiG9CAYAlyRVwELiUcNGx8FD\n", - "UibJOhBIhQidWofOKikiREgan52miR0ETJuCb9jr2NLCAiwiTKp4hGhBH6oBMV2h6pUZxSMfT5Md\n", - "y3NltoYu+jD1JC2vByVYpUwTGfYhhIOhS/zAo16tc/ZsjFarwJ/92be4cmWNT3/6n5LJZEgkEhiG\n", - "xPOcnzAxdN02UWRz+qWX8D2P4bExJiYmrpta55XLlymo6rVEBLYSjsFkkguvvPKaZETTNPbt28aZ\n", - "M/MMDGxj796b2b37EGdOP0N1+RgT44OUNjZQSiXWL16kXq9zuiVp6NMIZRAj7mC2q7jRGpHMEhca\n", - "SBufZULanTVVgFKnmaJ2PHSTwFxHmizEYwWLDW4koEKsI+KfotXpD3s06SOgG58GgjlDxYlUNhjG\n", - "iwaRmokmbHx/kFVsNOpUKJAnQwaDLdF5lTYRPvNUUUE2yCk9hPEsNS1LV7aPpUaDvRPTFPJlxvr6\n", - "GAMur6zwgyee4EMf/eh1WaO/Dw4dOsjU1CRzc3NIKRkbGyPfmZB6OxAE8Pjj8O/+3dsWwnXHRz8K\n", - "X/7yOysZCYIAVVX/m5wzVVU5fPgQhw8fes3furu7+fVf/wS1Wo0oishmsx2e4db16vUyx449xZUr\n", - "NZpNnSgqoutnCEKfui8J0Mjm21Rrm+RSO1hbC1HVNFE0hqIsEYtt22rnyFeQsoVl9TM767G+7tBs\n", - "1lHIoyptwkjHxAAmgGVMDFqoQBqBg8DpmJgmqNLCpMFZFIZRCBC41InRh8Ajj6BMiEKFPqokUdHQ\n", - "SGKiUSLCpRHLEe+dIFJyIIr4WkAYxbCsFAo2piII3AppI0m2UEAqDfpVldVajS5d58LlOW7qG2ej\n", - "WeVM4BI3TMzUADv6CywvLLBr165r93j2zBn2vMqpW1NV0sDKysp1ade8nQTWE8C7/yHnGIbB9PQ0\n", - "IyMjHD/+/9BuN4nF/o7lWyrN88EP7nrdcy3L4tOf/hinTr3ESy9dxDR1Dh4cZ3y8iwsXFomiOAsL\n", - "K3iexcDALvbsOUCz2cdf/dXXuP323Rw5conx8YO02000rQ9FjRA0kVEaT1pIIlZZoYlHHA3DsBBh\n", - "HFVmEdIgkiE21paDKnESqCioRIRUhUNDpmgbU+DrRPgklSaG9EnKFqqWphoKnGCDZOSSkUsoNNGV\n", - "NJH06ZU2ESENKpTbOXQ8fEqsq2naZpJSaZ2urmGWyi0ifYx8shev2sYOlkgYGgmhYWgGl51NVH2E\n", - "yO8nnR5Byjyrqwaf/eznufPOw8RiMW67bS/f+95pBgb2YpoxXLfN6dPfJxbMM/9EE0NVOf/kk+R3\n", - "7OAjH/vYdSE5Kar6umlmGEXoP6Ut9J733M3S0hdZWDiJYeTw/Sb9gzr/2//+5/T19XVE0Z7nL//k\n", - "T7g0N8fipiRrTKCaMYb6DlBbOkbTbuHIKk6kEkVtpFTQGUDTxonCHIG8RMBlQmqoKB0/CoWUMGlK\n", - "mzweJgHrqIRAkxguEU0C6gySp0IOSVI0OTjSzwXN5GwxiRJOkrKSuFEc220huYrHMHXOYZHEYGuc\n", - "r0GIQ0SBGAoxutUhpOlQVHxi3dPsnr6TcvkFskqClAG9+b/7roz39fHs6dMEH/7wW0pqzWaz3PBj\n", - "hLm3E08/DePjMDDwdkdy/fCRj8C/+lfvnKma//gf/5L19RqZTJx7772ZG2+84Q0T4X+8ytfb20sq\n", - "BY1GhePHnyUMhxkZmebs2RkMYxuXLjUZHCzQ39/LysoPGB3NU61ux7ImabfPUSz6gEYQZGg2zyNE\n", - "HcNIAJtcvNgmnT5ELueyulxCJY0f1WhRIqAASEIUGoQkKSBJIgGBR4AkJELSZiCZZqHlUpYG3cTZ\n", - "h84KV/A6NhAWbVQaWIBLyAEVLBHiCZUVxcQ2LGS7wfNr80SlRRQnwveg3lJxVAPdsoinPXqtDJrS\n", - "pDef53KlghVFNGwbVUugCpVCMsfu6RtJxNN4nsNa7dJr/KeseBzXdYm/io/pwxty6H09vCMIrK+G\n", - "ZVk8/PB7+Pznv4uU3ei6heOUmJxMcdNNB3/qeVsv01u57bZbAXjmmed4/PEr3HffrZw+fZqF+Qpd\n", - "6TQhbXRdI5XKUa/nCUPJoUP9PPfcEZ58/GnmLpVIksCTEZ4wMFQFN2gAdTzSeFoMU4noFjoykATR\n", - "VkG+Tr6zd16kRAOBBghMEZK0uvH9GpoWByVOLBxkI1oiIzKkNBM/dGmR4XzUJEabcWq4UYM2goRl\n", - "MhAJLntVIiXCliZZYweOtJB+kmoQUDSqODGDXGaIffsOcvF8nCvnztOv1ZHoLDlNNoGBzDQVb40o\n", - "CpHSY2OtwcvPHSG2eBlhmjiJBDffvJczZ07ieQJF8YmHV3lo/15SnUb1JHDq3DlOnTzJ4ZtvftPr\n", - "vW1qihcfe4xx38foJDdhFLFs23xw797XPSedTvPbv/1JLl68yMrKOl1dE+zcuePaXLxhGNx1113s\n", - "2rWL//v/+lOaT89Ra1TQrASO3WKzVccgx2jvbjRDZ3b5PEJuYun9+FEbD0EQ9CKVFsWoSU+n/WKj\n", - "sCYrVDucIYHGMgmahAg86miUUQnZQKeCUD2ErnPVdmgZcdJWD1EYQ5UadrsFQkeyRd/eICCBT9iR\n", - "h45Q2aJ2+xgIdNMkk4mR0RWW7BUURduSyg+auEqFA5N/JzDWbLe5urTEsaNHmZicZHBw8E2v0zsN\n", - "X/4y/Mo/MgHa7m64/Xb4xjfgE594u6P52fD9MUZGcrRadb785aM4jsvtt9/6pq+rqiq/8ivv4y/+\n", - "4m9ZXi7S1TWK79dJpWzKZY9Uaphi8RUmJ0Puv//9HD36KK5rMTIyhqoatFrHaTaXcd0KijJPIrGN\n", - "np5BhKgSht1Uq1cprYcoYqsWLkSWSFr4zKOgIgkpUkdDYAKCLA4tSoTo9KPrEj9TYCQTp7X8EiYu\n", - "cXR20cYjZJ6QDCZBKkU2CLjUbnNGUbAk1GRITejsT3fRmJ9hM/BRvDZ39xf4fmmBpXaFuNlLO/DZ\n", - "OTBGu7LJZF6jL5fjmGEQui5xTSOVTnOhtMb2gUni8a02i+M5NHSFqZ07f+J+HrjtNp7/0pe4KZG4\n", - "VvFer1SQ6fR1c/F+RyYjADt37uT3f7+XmZlzNBo2ExN72LZt2z/IUfTAgX0899xLlEoLrM7PkXLb\n", - "6GGNhLbGc99Z4mh6GF23KBZN/viP/xdOHnuacTmPGquhMkGj6VGP1qgE0KussTfy2bAStKIkS47E\n", - "iXvE1ICG6+KSQIZxhFikm4ABEeETsiYjasLAsAoI4ijRAKqUBIqDE/QxRxnbKaMZMVrJEUrtMonw\n", - "KioBDoIqOj16HkfWUVBoWxFxMYCl5fBTKWqKSdtRUdQuRkfTZLMqrdbLFHpaVMugygbLfgFViZMn\n", - "RiQdTD3E89okEiF+aZ2hTJ5tg4NkEgnOBFLHAAAgAElEQVTWKxXmL1/gX/7Lz+C6LouLixz7fPla\n", - "IvIjjHd3c+bFF69LMtLb28vh97+fFx57jB5VRRGCku8zfccdjI+P/9TzDMNgz5497Nnz069dKBS4\n", - "4dBh8j13MPPKKyyeP8NmVGS4/1ZKpWWKm+eJJeJYiSQj49uQMsbK0ipRs4WMFMCnQRfnqTFhJFCE\n", - "TskN0AjYxMUmRZ0ubAoYeOSRNBBYXGVS87glmUZGIUUv4nS7jidtVMVGiSSq7xHHpU2bkA26SCHx\n", - "8UngEdHCICMCNLVKl2pgR00ULU6hO4MsLzE7+ziJRJ1qc529mRwiCJBSMru8zJM/+AH5fJ6rTzzB\n", - "qe98h2233ML7f+mXfq7j2b9ICEP42tfg2LG3O5Lrj098Aj73uXdGMpJKbekGJRJphoZu4MiRH3Lo\n", - "0MHrstuemJjgU596iFLp82iaS7ncwDQthPCJok1SqYi7734X8XiKo0e/j+9vjRJns910dWVpt9cw\n", - "1DK5VIxEDnp7NVqtNKX1JaqlRTR/iqQwcaIaUm6RwU1cYpQYY5Ms8DLVjvmpTpsMNgOEyhK37NtP\n", - "KGuEnkaxOMjF4Cp5WmgEqAhAYU2J+NCePeQsi+UTJ9hUFGLxBJEb8dDgFClNZ6Zept+waCoRXjbL\n", - "YV3nQKPJWqvMmtDYaLjcd3CasLLB4wsLpKemSAwN0dfXx/rpCyQGd1C2G2iVdaIoYra6xC//5sdf\n", - "Y+ex/8ABVhYXee6FF8gKgQf4qRQf+bVfu24u3u/YZAS2XGNfj6z690UqleLXf/2f8md/8h+gcQpD\n", - "cdneP0KxnkC4PTSqSRKD0wSBw5//+eeYPXGC8VSKUKyw5J6nJmM4UgFq7NE1xhJd7Ch08dzKEnGZ\n", - "wBUTtMQySnycKMjhtl8hJWukRbBlJ60IMuhUUwXGdu9n4fIsbmUFkzRe2CJUXAytl6ru4yeH6e7e\n", - "RebKN+m1TbLkSBDDJ+RSw+OsyGOlyuwfmaBk9wAxhscnKGsaoRanXG5x001j7NhxI+12i+XlM7zn\n", - "nkH01WXmV+vMzm9wYXGRINBI5AoMDsbxGg5JQ8HUJelOstGTyzG/sECxWGRkZGSr1ytf20QRQhCF\n", - "4Rtem1fjtjvuYHJqiksXLxIGAXdMTTE4OPi6L08pJWtrazSbTSzLot1uo2kaw8PD6LqO7/tcuHCB\n", - "q1dXyGZTjI/3c/Toc3jlJrftuomnTj3LRs3CSk7TlY6T6ClQqZYol1fRtE0IBHEtia1XCPxFsoqH\n", - "qyRZMA1inoeqajRClw1imIyQYYIcCk1CKmySwUbBo0HESafFsG6SNEyEXaVvMEUgVZbX6iSFQSh9\n", - "AkoMUcVQUsS0LjbCFVJWDyVnmTY10rEkTixPw60Qr9cwRZOpWIxS9QVGu0e49caDnDh5kscefZTe\n", - "0VEuLS4ylctx5113EU8kiKKIF48d4/zUFDtftSP6x4qnn4ahIZiYeLsjuf740Ifgt38b1teho4j+\n", - "joBhWPi+Rq1W+4nBhDeD7du3MzaW5/TpKlIW6Orqodks4/vrqKpKPJ5CCIGux+jpMdjcPEs8Pkit\n", - "uozmLtGtNNhmDtOobbDSmmP3oXfx1BPfIAoTGJqFYSSIex4tuVXvlLIMeHhMsQYU2GCROh5dWw7u\n", - "2llMJcRt1THMKmvrTXZ2TXJh3ceR6/QhyBAhCAl1jedPn2Yyn0eoKiO5HB/8wAd46luPUatt0pIQ\n", - "IhF4DGWSXF5b4/0DA+iZDKutFlpfH+vd3ey45x5ymQz5/n4mJiYYGBhAURTW19f5r//1G8zPlymV\n", - "N0HYfPI3foeHHnqt2Z2iKHzwwQcp3XYba2trWJbF2NjYddUaeUcnI9cDXV1dKG6D23f0c27mApvl\n", - "JepeLz2ZAVq1Ep63zr5997Kycp7FtXWyQqKrCTJqD/lYkoYTsBomWBE1RlIJik6NAk2k2eKSF7Bt\n", - "7H5k5DO3eoaE2CBJFkPPEQqHhO4zFkjabhu3vU4yE0epzRP5RWRYJ6e0yes7yfQMM9vUsBuLFLw6\n", - "cdUiiDI4UiCIyGBzSQpiDY/zl86SNMs00Wm4m6R6t5HM53GdRep1yeKijudtMjmZ4+677+MHjz7K\n", - "nswGB7cPslDs48mZVXYc2M/U1BRHHvv/MLUy7z204yde+pqiXJNgHx4epq6qOJ6H9WO7mYVSiZ0f\n", - "+MB1Xave3t6facbUbDb5whe+wdxcleJqhYVLp5jqNdkzPU6USnH/Qw9x5MhRVlZCTDOP5xVRlA1i\n", - "sQqt+hWqpqDlVGm0LUZ6xkklYrR8wcTEdo4efRpdGyZGL8lUkqYWUW3kIdDoVuPosSRRbJWMu0DK\n", - "1qj4Q0CIj8QHHFQsUigU6aJFMpBshgEtzSQRBezoyaAPQdNWicmIxdVFgmCNEVYYUZNUpEuohdw0\n", - "MI0nBM7KMu3YTnp7t6HKiMbGZVrhPLa0uXHfHvyNdepRxMTAANPDw1y6epXHX3qJ6YEB7rnzzmu7\n", - "T0VRGEmnOXP8+H83yciXvvSPr0XzIyQSW06+X/wifOYzb3c0f3+EYYAQ/mv8xn768SGrq6tEUUR/\n", - "fz+bm5scP3aM9aUlugcGOHjrrQwMDLBr1zBHjnyXQiGFYcTwvKsYhkMqNcnq6jz9/WNks5KJiX3E\n", - "YnFOnjyK5p1jKm7RZfWQSZgMWBlSjVWOHX0SPerGjwp4fh9B6KKIq3RbMVy3gqNo9CvbyKBCFKGG\n", - "aVwWaSlLNOUI/am91CI4eWWeoVyFZGCz0agTV9r0Rxl02cCljgbUXZea59FwHKxYjJXiJv/2s98i\n", - "R5oF4SOpMp5UGBse4tLqKl2Arii0PQ/dslDjcXb19bG0vEY7MFHjLQzDuNZm6enp4Z//8/+RpaUl\n", - "PM+jr6+P5M8gGnV3d19LFMvlMq+8/DK1zU36R0bYs3fvm7IE+e8+GXn+2LH/n733jpOjvvO83xU6\n", - "5zSpJ2dJoyyNAkhCIJDIYHAGY+MXeG3v7Tq8fM+FvV3f3d6+7tbrvXuevfWuExjbOKwNNskiCZCE\n", - "hLI00sxoNDlPT3dP59xdVc8fIwaERJYRwe9/JLWqun9d3dX1qW/4fJk4fpzVNhtX1frZ032aoWgE\n", - "HWYkSaSzcylWqxW3209O1JNNRUjrKnFoLjRFQZEUzIqJtKqnJzpFp0lmqcfJeDRKVC+QzyWQpDzl\n", - "7kWUZBFnSYegJrEINgqEsBnyVOntJDIpzD4vszMJjIKERS9jdTYxkS0yOTNJQRApJuKUl0JoohlE\n", - "N0kliYwCGFDJUqEp1OZzpEthqh11TBVCVLo7sFt0KPkYN9xwO8lkiq6uLFNTdn72s2eoqnKw4vp1\n", - "ZBIJFns8fK6sjN7efiYmZlizzk1VTkfNq26vcoUCaVGk6mzVn8Vi4YpbbmH3b39LpU6HyWBgNpVC\n", - "V1vL6jVr3vPP8+GHn2BiQsZma2Pw2G5W+NcTjo0h50s0evT8v3/399grL6epadXCPqlUjGTyedZ0\n", - "2LCISQJRgaKSwWk1kS8qyGYDweAwmqaiKhqaMkMmWUIrzeKSGsmrCaxkKWWzGCwVhPLTuNUCvrOt\n", - "wQnGMVCGdHbihJ1xFqNRIUhE0IgWiiQMOsrKyrju8qW8cOgYY4FhFutjVBugUNAjqOp8zlmJIcuV\n", - "hBPTCKKbltaNuH1+hrtfwqH3klEFqpfZ8bmdqIUcUqFAIBKhvbaWlW1tBBMJtFzuvDC4LEmXzBDt\n", - "vSaXm68XOXr0Uq/kj8dnPwt/8zfvfzGiKCUkSUZVFSYne1m3rvUtzTuZnJzkV796jHgcQCSTmcaU\n", - "nmVFVRUNNhuRnh7+7fhxbvj857FaHWzcuIFkMkU6HWfTpnoCgSypVJaBgWNIUpA///NP0dU1QDxe\n", - "wm430WSxYlOM+HzVmExmQCM/O0Ypq6Pa14qa0gjlE6iqCb3Oh91VJBCN49H5kVUd5PKoaGiChE70\n", - "IGkFHDorgpzFqGrYqhchG7MooX3UWWL0x2P4NBUTCgIwDrQAaU2jAFgNBnqLJnSlCgoGGx2VlWhS\n", - "iWSyi2A0yqyiUAaEUimihQKW6mpqamrYvecQs7ZK2pe5mZwUOHLkl3zxi7cu1HmIoviOaj6Gh4d5\n", - "9Cc/oUwQsBoM9Jw4wZE9e/jMPfe8Y7uAj7QYSafTvLRzJ1uXLyfR34/L4WBDewuF0wEyjiK+6g7q\n", - "6uoAyOcTbNl+FUd/9lMEzYjLbCaTz6MIAgaziVQ+hUmUaSr3EslkCIoiLb5KZKOeuKgCfqZLMYRi\n", - "DCkDHoeBgubGJEfJ5FRcZhMz8TwFyUmd2Y9JpyLLBdzJM6QKcTx2O2opj5rPoalGShTQY8DIfGGj\n", - "EwEfoACKmkQRozTayxgc3UdFhZcWt5GnHn0Mq2cZjY3b0OnmL0aBwAinTg3wpS/dtRD9qK+vByAW\n", - "i/GL73+fvslJyh0O0rkcY6kUl91yyzkKeOWqVVRUVtJ78iSZVIp1Z8P9F9su+M2IRqP0989QU3M5\n", - "p46fwKXXo5f1eJ21HB/sZlVrE7PjIZz+c9W/1erEbK7EYIF2sxmf00y+OEwseYJoVsQkmSgUwOWq\n", - "weNahKuQIRYMMJWYRaea0YQsCS2DT6cjkkhjUIyIUhwDBSpUKzEtR5jxhSk29RSwIYCmohdE9IJA\n", - "ud7InE6HxWSirbGW3OluWux2MqUiKZORXCoJiorFpsdoTGI3yJhkL56yWhwOD76qRqyZBKm0hM1j\n", - "QRBFNE1DhXNaot12O4P5PCVFQX5VrncyGmXVB31Ay1vkkUdg5cr54XgfVrZtg89/HgYGoOW1Dgjv\n", - "I6an9yMIZlQ1y5o1zezYse1N98lkMvzkJw9jMLRRU+NF0zRefLoXT3QaT3MzdosFu8WCI5nkuUcf\n", - "ZdnGyzAaZ2ltfcVmV1EUurtfYvPmKm644TosFgubN1/O6dN9PPlkmANnZFbWdTA2NkM6XaBYVIhn\n", - "w1isjVi8lWhaBIfNRTKfJl0sghjC63dRYa5DzUExGERLZ4gpecJKgTxm6i1GPGUOQskcNYvWIYpF\n", - "+qJdmAtZXLKIXCwiMW9Q4QO8QBao1OuJKQJVmpGiXkGwWIgoCj6dCVFfwbQwhdTQQCQaZUKSsFVW\n", - "4qquZt/ze4hkFBqcdTB0gklJprrjMh57bBdf/eoX3vFnpigKT/7mNyx1Ohdm1viZtwvY+9xz3HDr\n", - "re/oeT/SYiQQCGDTNNpbWzkajTIaCmEQBMxSnsHwKLfd+gVEUSQeDyMIIf7yL/8d3x4dpvdwmICq\n", - "orfZaKypISPL9I73I2aDDCgKNr+fqzZt4rGXukmm4sTkErKpROOSKxk59huqxByKZCKey5K16HEZ\n", - "ZDJCnmQ6Rlpfx7AWxZaNImlmgkUVTV+HVrTir7ExPLwXf0lFUueQsBKhRBABDwUcgoYNkXEBlpbZ\n", - "kdxmpiYm2OKcL4r99b5jlC2u5qzWAKCiooGxsQNMT08jiiIv7trFWH8/ZquVRatXc+XNNzM+OsrM\n", - "2BjW6mpuWrduQay8msrKSiorK9+zz+5C5HI5BMGAIAjkc1lMZ1tWdZKeQlFFUVVEDYqF8yMAoiix\n", - "42O3cWTPHpLRKLIhh91Yw6olyxifCKEodqamXsDlcRGdSpFKFygWQdU0NFEjLTspFksIhQJlZh0r\n", - "yms5E0qB6sBbchLPpDGSxkwCB2CTJFKqRlhTSKkFXFY3Kzs7mTUaieXzTBcK5NJp7Ho7mt7MBGlm\n", - "hCLkZkjbHNQ0tSMkyiiVokQiOTRZZjYRoMqro7qijAq7lcMDAyQMBvzeeeOnQrFIzmjk8ptu4tDR\n", - "o9RYLOhkmel4HFNTEx2v05n0YeO+++AL7/y3+AOBLMOnPw0PPAB/+7eXejWvz3/8j18iFoths9ne\n", - "snFWf38/2axtwdAsn88iZFM4LeWMj0/S0TFv7+Cy2ciNj1Nd7cdkOkQkEsDtnp+FFI+HqKwUuO66\n", - "HQtpIaPRyMqVK2hvb+Mrhw+TTIRobaklnckQCEwimIrUNLTgr17GSOEw2UgMCQGFHPZyB7d9+iaO\n", - "HpkmHZWZFATGxqfJaTZyShpZdDCuWCmVNGyV1TidPsLhAdxON+FSAi2TYACoAayABATP/ikrKpl8\n", - "HkkU0KQSlWfrP8an+olFp/C6YevmzQz19UEggM9k4vTRo4xPTOFrWUNLRT2iIODMJBkf6kIU/aTT\n", - "6becDnsts7OzkErhfE2Ra315OXuPH+f6W255R4XwH2kxotfrKaoqsk7H2o0bmZubIxaN0llfTzEw\n", - "RyrVSzot4vGYuPvu+dDWn/+n/8S3/5+/RV+qxmFxkQHc1ZUscSXZ4q9jWUMDRoMBQRTxVFXx/Z1H\n", - "aK1fTiSioNNJ2GuXEQr0kkpHkeQim8sqkXw+mlpaePZMP31jOuz2dYyMnCGRmEYpmHCKNkyWSiyS\n", - "h46lLg6fehGhkEMijYIRCyZUijg05scoCRITsThSocDisjKMOh2BWAyH3YUxW2RsdJSWVxmFCYKR\n", - "8fFxDj31FPU6HRvLyjh+7BgP/v73mGpqaGpvZ8XmzWzeuvWiGZn9MfB4POh08xM/PeXlBIJBbCYz\n", - "yUyMCrdlvkZdX6L36KPMTRzDV9NGTf1iSqUCJlOJpUuXsmLFCqanp7l8aor9+08QDmcJH++hsrKR\n", - "lSs30H3yJNG8yHQ+C0oRlSGs+lpkyU2eEDohSJNDxKXXc3mFRERJMpAoIpUilJPFUCgRBWZVDdAo\n", - "IuA0WUgV8rSvWMFn7riDZ555hoMHjxMSNAKoJFOzeAWZJYJExmykpqqKdddew+n+EDpdI9lsCUVR\n", - "GB8RiE4doKRWEEinCfl8WCwWJsNhVE0jpKqsu/56NmzcyPCqVfQcP042m6Xz2mtZvHjxex7JuhSM\n", - "j8ORI/Otrx927rlnfhrxX//1+9fu3mw2v+0x9IlECkl6JTIrSTKqICBKetLp3MLjqqqiAC6Xi7vv\n", - "vp2HH36S8fFBACoqbNx228cvKIBMJhPf+ttv84P/9R2Gx3oQFBVdnZ1GfydF5qcKt63YTCQSZGqq\n", - "jzpXhu9851usXbuW++77OTt3dhMrahRkJy6PkfLyRpLJPMWij1h6EsmQpLvrOSRdmAqjAY+jjJ5E\n", - "BCfQLwjoNQ0DUAeYBR0pRaYoQKCQRjOVkSgUiAwdx5yYolHLUClaUXt70UcirNiwgXgsRmBmhjpv\n", - "JXKpAGddTpxmG6Nz02SzjnflLSSejbq+Fk3T3tX14SMtRvx+P4LbTSASocLtxufz4fV6OToywp/f\n", - "dRetbW0oioLb7V5QeqvXrOEf//U7/OAHP2dgIEgmkSQ+cJIVK5sJ5LK0FIvE43GG+/oYnp7GX+1g\n", - "/dZGBgbGCAYH0EkGBuYUIskgtbLCUDxOi9/P8fEpXFVtaKMnOHHiFFqxEh01QAOqpjCXDmBN6Oio\n", - "aaLfM0o4DeaURq2qUCJ71u9TRUbCafFwJp6DXB4hnmFgcBSLUYfmdDNHP4w7FsSIqipAkpH+fqpF\n", - "kWqfj1MnTqAGAlxTX8/RWIxFViunn3kGo9nM+g3v3gPgj4Ver2f79g38/vcHsdnrGDcZOTM5iFkf\n", - "YcOSRr7/2GOEZ+co5uJExyeYOX2UvrJKlnSu5O67b104Qf1+P36/n9WrVxMMBrHZYP/zk6SjU1hS\n", - "k6RDEzjUInmxgKivxKQvUFSCpLKDWIRRjFkDitlLMBKjQpKo1olYKixIKZGeSJ4MGnZNwwWUiyKK\n", - "pKM7HqBz/XoMBgMtLS04GpZiMscZHOqhRXJjk8zMFpKoJSNaYI6uPXv41Fe+wlNP7SOb1ZAkjZVr\n", - "XGz55n9BKZXQ6fV8rKWFZDLJ8OAgoiRxdWsrZWfrfxobG2n8MLaSvAnf+958y+u7qLP7wLB4MbS1\n", - "zQuvD/LwvNdSVVWBonQv/Fun0+OuaWO8Zy+L2l7x0hmcmaGuowOLxYLFYuErX/k8sVgMTdNwuVxv\n", - "ePe+ePFi/vaf/4mBgQFy2SzVNTWEQmG+971fcvjwY8Tjytk24Dxr167niSde4umnX2J2dgafz0uh\n", - "0IfN5kEQYC4UJZXMk0gNgFJAn9EjKkGsYoLJUp4yTyUeq4WpQg6jIFAly0RUlaAmYVM1dEqBvGxk\n", - "VpcnlSlSI0exlaaoEUu4jCIVDgfjg4Msb2ggFo2yZe1aZgMByqMJhkMpstkUFvP8mI5UMsqWjoZ3\n", - "NZeqrKwM2eUiHI/jfVV9yNDMDIvXrXvH9gAfaTEiiiK33nEHDz3wAFNjYxgEgbiqUr92LavXrHnd\n", - "/umWlhY+8+mbeeL++2lw1NNQWUkinebF4WEeOXWK2MAALqOR8poaNjY1MT01yp996U6isRj/8I1v\n", - "cGu9nvK2DubCYYbicX7/4gl07hXU1trp6Lie0ZEnUEpxBFlAlKqRZR0GnZ5gdILTwwJzCQveCpm4\n", - "MMZsKkKZUsSDxoRsQm+2kJN1pPV2dOk51ssWKr1uZJ2IQprjwW6mzXZU9UrS6QQ9Pc/jdIo8+cRx\n", - "rmqqIpPNMjs2RpPLhSgI2AWBVDbLkqoqjrzwAp3r1r2voyPr1nXicNjZu/cIxaVGCjkvNtnJYKlE\n", - "/3SGJXXbcFrcRONRpoJjkJ7iis1LaXlVYr1YLLJ794vs33+SQkFhuP8U6dAk2azKUqOJuNVLsBCk\n", - "IBkICBApRXCoQap1CpJOoD+RZiJVQDNbOVkoYJIkbDYzAdFOSBbwllQGAR05jFqJKjXPotpq8vn5\n", - "aQiFQoHmpZsYkk8QHzqJX2ciqBTBWI7TIDM3GWd28lnG4nnu+dIXqKnxYzabKS8vP++zsdvtH0lD\n", - "swuRTsOPfgQHD17qlbx3fPnL8C//8uESIw0NDTQ0WBkZOUVFRTOSJGN1lxEptzGllsiMj5PWNMw1\n", - "Ndx4ww0L+wmCgGt+/O9bwmq1nuMWbDQacTrtdHRsolQCVY0xOjpBJFJOa+sG9u7dw8GDYzQ3g8Xi\n", - "p1CoIT4Xp5jpRhZl7PiQtNM4lQJWj59gUENFYM/sGNdWlbPeYubY1BT9qkoCCY+oJyGLWOxuzBY3\n", - "Kw0melOzmE15zIkY1WVOmuo7cDmdTB86hKSqhEMhZEmiyu9HU1V08TiRyDijQRibC5G1GVi8uAVF\n", - "Ud6xP4goilz/yU/y8P33MxOPY9XpiOTzyH4/m7a+ozF0wKWdTXMv8HLm9v/TNO2Xl2Id5eXl3PP1\n", - "rzM6Okomk6G8vJyKioo33EdRFF54/HHW19fjOhvm8zmdbGlp4SfPPMPipmYGh8bJDE1TTORoaW1g\n", - "986dxNNplhgMrDyba7PY7RzomiCRFPC5FyMIFfSeegm3FsSpA1UYJSGmUEzLiOdk8vkkkUAaRdCj\n", - "aYuwuRvICy+RLRVAUHHbdIi+Wlas3crRo8exhk/Q7KvEIM/HaFNpaHGoBKxzTE3tZnh4GEkqx+db\n", - "y9SoxBMvjdLmD2DXNMSz6janaZgMBixGI4XZWYrF4ns67fWd8OoBWy/zT//0L3hsETyO+ciA1+PD\n", - "6/ExPC3S19XF9muvXdj20Ud3cuRIkOrqtUiSjhMvTSBLM9i1GQTFjE6XwGPMkcGAaJTIZAM0GvwU\n", - "spPorG4CiTyZUhZzKoXVYmdOb6A/LVPCTUa1okpOrDoDJZLo5Bn81iKWigry2SwwX3+j1+dx+Jpw\n", - "1qzFhIQQTSOjoJOzRJIiUUkj1RPl/vtfYOXKSu655zPva5H4fuCBB2DTJmhqutQree+49Vb42teg\n", - "pweWLHnz7T8ISJLEHXfczosvHuDgwWOUSgrr17fx7//9PxOPx4nFYjgcDmpray/qObFv3yFstjZa\n", - "WxvRNI1dux6lru5KgsEgu3fvo7d3BklaQl/fSVIpjWQihUV0g2ajWEqjI4tMjmDKRCJvQcWOQctj\n", - "V4ycDs5hMRso8/sps1h4cWKG1Q3raG1ZhMlgXEiNRPY/zKeu3cTU0BBrXjXXyet0Mjo3h+lsVfaq\n", - "xYv5/dQUpQofWR0MzghInhVcdvll/O53xxkZmeQTn7j1HR+f6upq7v761+k7fZpENMqSmhqam5vf\n", - "Var3UkZGntI07QeCIMjAAeCSiBEAnU53zp3xGxEOh3nsN7/h0NNPM+VwUOX3s3rJEqwmE6IgMNR3\n", - "hnTfONVmO4Ikczo6zlQoRvnSJkKJOG1mM6l8nvF4kr1DU4yFbaiKlUSyyODgEKZoP3UYcdsdZHLj\n", - "+CgymD0GUgMmqxdFLOGy+vB42imVcmQNemLxAHqXQO2qZlatuZrx8T4kSaa6to1AIow5n0UG4qUi\n", - "Jp+XDWtXcuMdt3Dffc9QX9+JIAgsWraG0/vzjMwGqFRz1CkKgXQayeGgzOkklkph9Xov2hyC95pQ\n", - "KI5Bf34PvaKaeXU569zcHMeODVNff/m8cZuqYjLZQalGjk/gNKhoyRzxXIqMVqSg2hELSWRzGIPD\n", - "hK+yhtzIELWim0Qxi2Isx6G3kS2MEyxZsNs7KKQnMCGiFz1EinmC2iyNDgfesykUr9fLhg3tPPDA\n", - "TkRbFZMzZ3AWS+gNGrFkllhuDskmUJ+PEeh6iZPCWg4dOsLWrVveo6P5waNUgn/8x/ni1Y8Sev18\n", - "e+///J/ws59d6tVcPIxGI9u2XcG2bVec87jT6VzogLzYDA1N4nItolgsMDU1yNDQAF6vj1QqTyqV\n", - "wWSyEghEURQ9mmZD1WbJKkVk4qhqjpQWwCZkkKgikgtQRxi/KKOTXUCaRS47U6LIVdu2MbtrFx6X\n", - "GYvplXqaTDaJy2FF1umweL2MR6PUnk2TyA4HoVKJCquV/okJsqpKbWcnDr+fp5/soXPHvOeKyWRC\n", - "0zS6ug6ydu0ITe9CmVutVtasPX9w4TvlUg7KGzv7VwUoXap1vFU0TePYsWN8/+/+Dk8qRWU+zzKT\n", - "icjMDLvica7bsoXxmRlKkTirW5oxyPMKsVxROBGJEO4fpqGlnq7hYTITaTTNx5mgAUUrJ62EcJsd\n", - "iMoIHsECcoJsMU2Zy0G5qwJ9eJLDiV4s1jKc3nry+fkvqE5nIpMRMZkkwvFRFK2JQGCQdHqYxYvr\n", - "UcNT1FTVk07FUZUSNqWEo0ykvkE6/IgAACAASURBVL2d/v5hTKbyhfxeVVUl2RUr6Dq0B0XSExwd\n", - "paa2lm3r1hFLpegOhbjmzjs/sHbhS5a0cXjvJJl8DrNhftiToirECjFWvMoPJRKJIIrzroyJRILR\n", - "oSEikQjp4BzFcIhOUxVCSUNvtjOey5PVK+iM5YAep9NAXlMpR8BtdJDXmUiVzMiiFYuaJ58vIOlz\n", - "5BAQFAmraALBwUQxwrKGhnNqOK677hqMRh3/8A8/J5B2ki6O4JFkJrIRdEaBbdVLEVTwWsyEJofY\n", - "t8/5JzHyBvzsZ1BTA5s3v/m2Hza++tX5aNDQ0EcrKvRuKJVKnDlzhp6uLuKzszi8XkqlPKnULL29\n", - "p0gkdGQyIhMTIaLRMRobm+Yn+IolFKWA0einVDSiZE9jlgcplvJUawoCeiRVJCfE8GgiIgI2WSKr\n", - "yQSjMWYQGYzEcJSXozOUCM+NIoomNK2AKGXp2NhJ0mymqaGBYeDg7CypdJqC18vn/t2/o6a+nmAg\n", - "gMVmo7W1lWeeeYGO5W7Ky18RaIIgYDSWMzDw7sTIxeb9UDPyZ8D7vrZ97+7dPPKjH1ERjbLI5+NU\n", - "IMCuA4doaWggE48zND3Nvu5u/O5ykvkMetmOgIAsiQipOKcnihjLFrF/OI1T9lBt1SEKRnKaGUG2\n", - "kMtNYBZyGPVmVC2NThcjr6pEUyo6IYHf72Ttxk8wOwvR6BixWDfFokY43IvZXEZLSyeSpEdRJvgP\n", - "/+HL/OpXjzM6aGBo4gy1NheyABPBM9gqFrFx61a6u0+jKOdqwKbmZkSpwNKlm/G47AydPMnRcBiH\n", - "18s1n/vcOSOlPygoisLw8DDFYh6Do8CZSBCPwYKgaYQyEdpW1nLFFVcsbG+321HVDJFIhGMvvohb\n", - "FFlcUcEzQ6fRlUocn53FWgDJaMHl9jGaL9DcvhZLeIpSNonZaEIVCkTzCWR7DWosRyh0hlwuj4ZA\n", - "NKWgk9wUhSw5oYhsMKLonVx+zfZzcriiKLJt21X4/VX87GePcPA5lchcANkssrWuHbNOTzidpsrr\n", - "RU3PkYiFL8HR/WBQLMJ//+/zaZqPIg7HvD383/0d/PjHl3o1fzw0TWNsbIwzZ4aQJJH29haqq6vf\n", - "9vN0d/fw4IOPcWzfCSyUaPbbWNVSQ3J2lpcGXkKnX4HX24KmGRgaGsJodJ+1SPditWZIpeKUSiNI\n", - "chpZF6XGJEA2j1t1MlnMUCKLHgWLqCMrCGSUEslShqRiRvL6OHimgGZz0FxfQb3RiB6BEhpRUWTD\n", - "bbdRW1fH7iefxKAo2CoqWLFsGduvuw732bTNqwWG0ahHUeLnvUdFKWIwvL+65/7oYkQQhHLgV695\n", - "eEbTtM8IgrAO2AHccqF9v/3tby/8/YorrjjnovFekkwmOfrss1QZjVjsdqLJJMmSkYLi5fhQmpKU\n", - "42RxD8tWdmBIayiKkYl4CL0gkMxnmStoeGvXsGjxFnq7ExTTJoazs5SMblQlTU3ZZaTTp8gIOYKp\n", - "YSpMJT5358cwmQxEolEGMxmuX72Ovr4S09NJ6upW4XRO0dW1E6+3Gb+/kh07LsflcjI+3sPg4Cg3\n", - "3HAF3/3uD+mJxDgxMYzLLnH9bTfwyTvvoKKiAk3TeP75kxSLNeh08zUgxWIeUZzjyis/Nb/Njh2U\n", - "SqUPbMtnsVjkV7/6Hb29c5hMZVRVtdLTcwSLuwy32861S1Zy5523n9PmVl5eTkuLl9//9kmqdU4c\n", - "Fhv5Yg6rJcfVTe0MhcPMFkTsdh8edwVL9EYaLt/BmVMvMXDkSerwEjPqcct6ZEkhkTiDIDgxOZox\n", - "qybEnJdiAUriDK7yalRphiuu2s7ISOCC72HRokX81//azM51f+CX3/se+dwsyUSMQCGHqtMhzIyT\n", - "KEa5svWK9+iofvD48Y+huXm+XuSjyte+Bu3t0N3NGw6O/KCiaRqPP/4k+/cPYjBUACq7dp1k27bl\n", - "XHXVFW/5ecbHx/nFL54lMKmjwbkIg05HMBrmyJkJbty4gmcP/R5neZFodAxBgLo6M8Vijv7+fkql\n", - "UerrV+F2f4aenh7AitPewPTwb2lEQxQ03CaZYDGKUedGIYdR1FOQM4gFF7LBxHheQc5ZqPF3ECjN\n", - "0bFyJYGxMZweD9ds3sySs4U/n777borFIpIkvWHdx5Il7Tz//CmKxdoFo8tCIYeizLJ48ZXv4ohf\n", - "fP7oYkTTtFngvBJbQRD8wD8AN2kXalrmXDHyXlAsFjl9+jQDA2NYrWaWLVtMZWUlMzMz2AHN4SA0\n", - "OUlgKobNXI3NDKF8Hs1tJVtVw9otazk8G8KUNeOtrEcpFUlNjpLKGVm3egM6nQ5/bQ06XSMz06ex\n", - "iwVMJidDQyfJZCLY7XZCuhLrOurxVpRRVBQyuRyrN23iqh07+PnPHyIcHmNkZIJcLoZeb6auroZl\n", - "y5pwuZwAlJXVs3v3AWTZQH395TQ1bSWbTVEozLF87cqF4tzKykpuvHE9jz/+EprmQtM0JCnGTTdt\n", - "XNhmfoDU2xMiytnheBdrkuO74eTJU/T2xmho6ASgoqKe9vZORkdf4C//8q7XzS3fcsu17HrkEbL5\n", - "ELm8DoO+yKpmC612Gy6Hg6iix+VqQSfrORGdxWZzUdeymNUbahgYCFKwOtDF5zCWUujNMmkcZG21\n", - "uCU3s7MjoPciigqaYZyG+kZUVU8mk3nd96HT6WhobMJW10FgcIpIcByDwY/XUkk8nmGaLDan+7z9\n", - "NE37QIvJi0E0Ct/+NuzcealXcmlxu+Gv/gq+8Q146in4gGZbX5fh4WH27x+irm79wsVZUerZtesA\n", - "ixa1LoyveDNeeukoJlMt0+MvUkjkKJQk0DTOTIRZ1hjAY7Owdv1yjEYjsixjs9kolQo8//wvGBsb\n", - "Qaezk8+n8Xr1CIIeKLJs/ZVkzuzHoRlZ1byKwdEuZhI5huIxKmTwWm1Y5TJ6EwmMdZtpaNpIPp+j\n", - "u3uQG2908hd33rmwvmQyycmTp5iZCVNZ6WXZsqUX9Ep5+dyvqqrixhvX8cQTBxZ+50Uxxk03Xfam\n", - "c77eay5lmua/AGXAw2frEK7VNC33xrv88cjlcjzwwL8xNpbHYimjWAyzZ8+v+djHNuP1eihoGotq\n", - "ajh09CilgoTdLFEolcijILh8LOnYRCwWZ+V1Ozj2h50kImEUVeT03CjVK7bT0bEcVVUwGArodCK+\n", - "smoaGiy88MJxBMFKY6MLl8uLzdZCVJfkSDxOeUUF6668kmXLlyNJEvfeeyfbt48xMDDAmTMDHD4c\n", - "YNmyjdjt9oX3oWkaIyNjtLZeSUVF/cLjpVKR5547wIoVy7BarciyzPr162hra2V0dBSYt4F/O61v\n", - "r2Zubo7dTz/NcE8PoiTRvno1W6666h27/F0Mjh3rxe0+V3AYjRZMphoSicTr7mez2Vi9YhEdZ62O\n", - "bWYzo4EAJw8exKSqrFzRzsnuYWaSRZTKRkKhARobLdx555+RSqXo6eml73Qvk/39HE/mKcgdSJof\n", - "QRUxGOIYjWaSyXHs9g70+kV0d58A9ExMTJw3uhtgbGyMX/ziWRYtup7RgQAKsxg0mYwSxeYvY3Hr\n", - "Frq7J7jhhgxmsxlVVTl08CBHdu8ml0rhrqjg8muuofVVRncfFb79bbjllnn79486X/7yvM/KE0/M\n", - "D9L7MNHT04/ZXHVOlECSZGS5jP7+wbcsRoLBKJrmYzKQoMzsx3HWkG02mmbnoW7KvRYSiQBVVa/M\n", - "tspm06xbt4RvfvOz3H//o4DEypVLSaeD6PVRtm3bTs+heqTJSWIzUer8leiKZzAYTSxe1sGxniFi\n", - "BRHPkluprV0OgNmsw26vYPfuY1xzzTXIsszU1BQ//envyeddmExOurqGeOGFo3zxix9fuIFUFIUD\n", - "+/dzbO9e8pkMPr+fTdu3881v3rXwO9/Q0IDT6bwIR/3icikLWP/sUr32hTh69BhjYwr19a98yQqF\n", - "ah55ZDdf/epnmM7nKQwNUdfUxK7gANF0lFg2g7u1gw2X3YSmqeTzOfw+D3KZj0hpmrLaWm66/kqC\n", - "QTexWAyr1caqVZ0cOnSQRCJHqdSMxZKlslJHU9NiKiurKS+vJRIJUN2o8OlPf+ycNYqieLbHvoGt\n", - "W7cSj/8Lrw1ABIMj6HQSXu+53hK5XJozXd38w3/+z7g9HlpWrOCKq6/G5XK9YwHyMslkkl/98IdU\n", - "FApsqa5G1TQGDx/m1xMTfO5LX3pXbn/vhtcJuL1pEa4kSXSsW8fEnj0sO2t93+z30+XxsLevj+79\n", - "+ygAtpoaNm/t4LLL1tHW1oYsyxgMBjZv3sSKFct5/OGHeX7XfjLJWdy+Sly+aqqrnXR1HUOSiuh0\n", - "MsHgfmpry6iv38DDDz/FX/zFF89b3759R7FaG7BYHOjM5eja15COjZPOzFG/cjPt7SuYnDxOMBik\n", - "vr6e3c89R9+zz7KsqgqL281cIsEf7r8fvvCFj5Qg6e6GX/4Sensv9UreH+h08E//BPfeC1u3zk/3\n", - "/bDweuf6m/3fa6mvr+TgwRM4PI1kExmMeg0BAaO+RDxtpGVNPe5KjbGx4xiNHgqFNLI8x+c/fwt1\n", - "dXW0tbXR3d3LSy8dohQfxq4zMXGmj41XX81oXx+lM2cw5HK41i9he3MzZr2e6g2zPPz7fsrK6olE\n", - "hhEEEVk2YrGISJKD3/zyl4RGRzly6BgY61mx4XocDi9QRTg8xaOPPsO9985HT57ZuZPxfftYUVmJ\n", - "2eslFIvx6I9/zK333nuOZ8r7kfdDAev7gmPH+vB6z72L1uuNRKNF/sf/+GcEoZbDPX0omTniShFT\n", - "2XJamtpYtXY9oigwMHAAozJE2ZyNjy1bhtrRQe/oKLv37SYQUjAbGtBb3NS3t9LS4sdmS+Dz6VDV\n", - "elatuhpJeuWjsFgcjI6eYnZ2Fq/Xe8GUh06n45OfvJaf//wPRCIedDoTuVyY+noTTmc7+XwGWZ5v\n", - "+8rl0nTt/R2e2AxbNmzC7nAwfOIEv56c5K4vf/m8MH4oFGJychKdTkdjY+Ob2jWf7OrClkpR//Ik\n", - "SKC9poYjo6MMDQ3R1tb2Tj6Sd82qVYt56KFjZ0/ceQqFHIIQveB8nVezaetWHgmF2N/Xh10UCSST\n", - "TEej3LV9O5Ki0HfyJIGxMY4/9QRaKobT6VwwFysUCvz6vvuwx2J8tnMFOw/0EQgdYSIxgd1bhap2\n", - "UVbmI5vNIst2xsdDaNo+/H47p0+fpqmp6Rwvl3A4itXaDIDJZEYUvbhcdUQiU9jtZWdbkHMYjUbS\n", - "6TQn9uxhY13dwiA8j93OIk1j/7PPfmTESKkEX/wi/Lf/Bl7vm2//UeHqq+drZ/76r+G7373Uq7l4\n", - "dHS0ceDATlS15lVpmhKlUuicAXlvxoYNa7nvvt9htbaQF10EI2GK+RkslhyCvYqNW69i69Yt9PX1\n", - "MTY2g8dTTkfHjQuTaiVJYs8zT9G/axdNZjM6kwnyeQ5MTbHlk59kxy23UCwWcbvdiKKIoiiMjo7y\n", - "b7/9EkePhpFlP5qWQxCmWbduJUf3/QFfpI7V7e3MaQYEVeHU3t+x4oqPY7U68XiqGB8fJplMoqoq\n", - "pw8c4LK6uoXhmD6nE0VV2b9rF3V3333xD/xF5E9i5CyiKJynoBWlRHd3D52d22lqaqO9fT1zc3Mc\n", - "PvwUZnOJymovodA4mcwsNmsCd0wjHo/zRG8vsiyTmJvDm8uxvnM1M3Npxmb7OHXgCJ++59N86lN/\n", - "RigUYmbm4XOESDqd4fnnn8VojPB//+9vsVrh5puvOs/EC+adYL/+9bvo7e0jkUhRX7+E5uZmjh8/\n", - "wUMPHaG+fhWiKDE9OYAhOktTlXfBBrm1upqjY2MMDg6yaNEiYP4O4qmndrF3bzfgAhT0+l185jPX\n", - "vaEPS2BsDO8F8pZOnY5gIHDJxMjy5cvo6Rmgr+8QZnM5pVKBUinALbdsftOhXAaDgU/ceSfT09NE\n", - "IhEO7t3LDU4nXpuNQ889R4vNRofbzeFIBGc8zsM/+Qmf/4u/YKC/n50PP8zwwYN0Ll3KosVt2GwW\n", - "Dnf10TN9Cld5iXS6jLq62wmFwkSjaVTVwdDQCQRhhEwmR2WliyuuWM3mzfNeJ3V1lZw4EcRkstLc\n", - "3MKJE0N4PB1ADrPZQjA4Rk2NjfLycqampjDDORN5AbwOByfHxlBV9SNhjvbd74LVOh8F+BPn8t3v\n", - "zhexfuYzsHr1pV7NxaGxsZF16+o5ePAgRmMFmqZSKMyydWvH23Ig9nq9fPazO3jggReQZT1GSxGf\n", - "r4nW1uVksxM0Nc1bqS9fvpzly5efs6+mafzmpz9l8sABtvn9hDMZxmZmON7fT8vKlTz76KN8/a/+\n", - "auHmsqenl0ceeY6pqTC5nBlJKqeiovpsxNTGc8/tp9GUJGbzcDLfA6i4rQ5ysTCTY720L9n48isj\n", - "iiLhcBirIJwzpRvmBcmZsTHe7/xJjJxl7doOfve7E9hsr6QspqYGURQdNTUNwLzqLSsrY/PmG8jn\n", - "e+jsrCCbzdHaeiVdhw+z98E91IoiLRYL8ViM0cFB9C4XgqJwy+VrCEQi9IyMMj06RDabpaqqipYW\n", - "D8eP76GmZhEWi4tnn32GTCbMli23Y7O5SKcT/PznT/KVr9gvmPd0Op1s3Lj+nMdWr15FMDjH/v37\n", - "EAQHo/37aLKrrO1ccU4KwCHLBAOBBTHS39/PCy/0UV+/EVGcP2HS6QS/+MUTfOtb975uhMRVVkaw\n", - "v5/y16R70qUS9kuYm9TpdNxxx8cZHBykv38Es9lNR8fWt1W4VVVVRVVVFS/u3EmFx8PY0BAOUcR4\n", - "1vzNLopIoog1k+G+f/1XDHNzuCIRlsky8TNn2DkywvKWFi5b3cHq1UtI+f2UlAmCwRmiURWrtZZI\n", - "JIaqNqLXlwiFSixZsoadO7swmUx0dq5h48a1HD/+C8bHCzidPmprg/T0PIHH4yGROENlpZFPfvJW\n", - "BEHAZrORUZTzREcincbqdH4khMjJk/Cd78wPxPsIvN23jc83f3zuuQcOHZqf8PtBRxAEbr75epYv\n", - "H+X06QFEUWTx4vXUno3Wvkwul2NgYIBkMkV5eRkNDQ3nnRPXXLON/v5pCoUyysrqAI1AYIi6OvMb\n", - "znOanJwkPjqKS69nKBwmFgxSq9fjNxgInD7NUDDI9N13U1NTw8TEBA8++DRlZSsoFo/T2Hg1MzOz\n", - "hMMTiKJEsWjHZPJT7Y3i9TQSCk2gqnmSyQgOo5nxufnuu2BwjObmCiwWC1arlWSxSCwWQ6/XL/xe\n", - "x1MpHB+A8OCH4Gv49kin0wwNDZHP56murl4Ye79y5Qr6+obp6zuEXu9BUQpEIj0sXtx6nuuoLOsA\n", - "4znuf7ueegpTKkVTXR2qphFOpajM5TgxNoaroYG8InByJEGxZCMyPEumdD/tbT6io/0Y5oY5cOIP\n", - "ZHVGVJ2XHTs+sSCKLBY7yWQNhw4d55Zb3loRliiKXH/9djZu7CQYDNJ11Eixt/e8YtJ0qYTzVZbC\n", - "hw6dxOGoXxAiL79+OGxneHiYjtfpCVy2ciUPvvgivlQK59miz5m5ObI220WLigSDQY4cOEBgbAx3\n", - "eTmrN2y4YLHna5Ekiba2toV1hEIhjhw5gizLNDY2nlP8+0Y4PB4SoRDZVArDq9JaL9vlh2IxJsfG\n", - "+OSmTUxIEpOTk3gEgb7uMzwTKFDtqWQyNolng0ZjYyPDw6dR1TLS6QSxWBi9HrzeSrJZmVQqRmVl\n", - "By+8cIi1a1cjyzIec57je35DKpaiaDBw++3XsG3blTidTqqrqxdEpsPhoH75cnpPnmRxdTWiKFIo\n", - "FumdnWX97be/gyP/wSIeh9tug//zf+BNMnEfae68c94I7n//b/jWty71ai4OgiAs1NRdiJmZGe6/\n", - "/yHSaROiaEJVT9DYaOezn70No9G4sJ3dbueeez7J00/v5vTpF5EkgbVrF3HVVVvesEswlUph0+sZ\n", - "LRbJB4OssVgQBQFFVSmVSpRKJXpOnqSmpoYDB45hMtVhNtsoFovodFba21cxNtZ19trURiikEo5N\n", - "MDTQj6oqSPosFkucyWCAXFULY2NdOJ15brxxfvDQyPAw3WfOMDE3R4XFgquykpYlS+ienqZ+0yYO\n", - "Hz5MRUXFOb8X7yc+UmJkcHCQBx98nELBAcho2kt0djZy003XLdxFDw8PMzo6gdlsorp6Mz/84UMU\n", - "i4WFHm2AcHiCLVvOzb1LqorRaCSTyxGemSEdDpMvlbBoGlP9/RztS7Fy6TaiqTRNtbVomoGHv/dj\n", - "vnTzdrZs2YSqKOw+coT9MxpOp++c57ZYHMzOzrzt9/tycarP5+NnZ84wl0jgOXvxnQqHydrt54iF\n", - "XC6PTue4wDNJFIvFCzw+j9fr5ca77uKphx5CGR9H1TRsVVXcfvvt55zk75TJyUke+uEPqRJFGux2\n", - "4v39PHTiBNfcccdbNmLTNI1nn32eF144CXgABUl6nttuu4rly5e96f6rL7+cJ++7D4/dTmR6GrvZ\n", - "zGQigehwUO5ysa+/n2rbvHNrRWUlfcePMz40ToW1nBkEJKOVoruOdMYCTFNTU0Gp5CWZzJDP69Hr\n", - "i/h8NQiChqKUMJmshEIZCoUCv33gAaryeTbedB3K2XbvrtAsTqfzgoLs2ptu4ilBYN/JkxiAvCSx\n", - "+tprWfVhicm/DooCn//8fF3EHXdc6tW8vxEE+P73obMTbr4ZPuylRJqm8etfP44kNVJX90pkdHj4\n", - "FHv37ufqq8/13PD5fHz2s7dTKpUQBOEtWRX4fD4yoojD6yUwOLhQIZzJ50lLEovb25kaGgIgGIxg\n", - "tc7XKFZV+ZmZGcZs9qDTmQERg0FHPDqKOaeSVWM49WbCkVlqanw4W71svqqTxYtbaWtrw2g0cvr0\n", - "aQ787nd8dtMmjvf2EpyaYnxwkOcnJ3E0dBA+EuXo0TSadpClSyu5/fabL1ljwevx/lrNH5FsNssv\n", - "fvEEdvtyLJb5C7Kqqhw8eISmph6WLl2KKIo0NzfT3Ny8sN+OHet5/PHDWK11GAwmYrEZ3O4c69ef\n", - "68nvKy/HsGwZw6dOEQ4EcJhMpCwWJEVBEY1IWRNTgQBFq432pkbOHH8Wv8FDMh7H7XQiShLLmpo4\n", - "0LeHeDx8jiBJJMIsWVL5jt+72+3m5i98gaceeoj+iQkUTcNRVcXHXyMWOjpaePzxXux2z8Jjqqqg\n", - "adE3dTJsbGzkS9/8JqFQCFEU8Xq9F019v7BzJ01GI5We+XXZLRYc6TTPP/YYbW1tb+mHYmRkhOee\n", - "66G2dsNCjU4ul+Ghh56jrq72TVvdWltbid16K7sffZSBQoHe8XEqamrYuGIFpycmMPv9WM56rOj1\n", - "eqqamxkai1DIJAkKIkgSSy67GUUpoSh9hEIB5uYUvN4KAoHTGAwyLlc72WwvTqePRCJCWZmTyclJ\n", - "1FCI+rOeKJIkYbNYqEunOXbgwAXFiNFo5OaPf5zE9u2k02lcLtdFEYXvZzRt3vY8HodfvdZi8U9c\n", - "kMZG+Ju/gbvvht27Oa8z78NEIBAgHC5QW3tuiraysoUDB46cJ0Ze5u1csL1eL82rVxMPBlHtdkYz\n", - "GdRikbiqsnTjRvz19aTORo7r66s4fDiExeLA729ifHyEcLgXTcuhaWlGRvbi1sOqRTsYmzjJxNw4\n", - "HruRrtlZ7vriF7n66qvPee3De/bQ5vHgtFrZ2tlJKpsllc3yvZ17aa24DL+/HpgXZSdOHKO+/hjr\n", - "13e+jSP4x+cjI0ZGR0fJ561UVLwSlhdFEZergUOHTrF06dIL7nfZZRuoqqrg8OEuEokwGza0sGLF\n", - "8vNSHss7O3ni5ElqW1uxqipeh4N6VWVPMEgwrTJXUkAUuXLzJqxWK9lUFLfehKqqC8/h9niochkZ\n", - "Geli6dItSJJMODyFKM7S2XnNu3r/9fX13PuNbxAOhxFFEY/Hc942K1Ys4+jRHkZHT+J2+ymVisRi\n", - "I2zZsgSfz3eBZz0XURQvupFOPp8nODZG+2suunaLBSIR5ubmKDs7YO6NOH68B4ul5pxiYaPRjKK4\n", - "GBgYZO3aNW+w9zyd69axbPlyBgcH6TpyhJnhYXoyGTouu4zrOjt58J//mWgyictmw2wy46tuY6JU\n", - "YNW666irW4QgCEQiAerqmrjppu38/d//gGQyxJIlTsJhjVism9Wrl5LPZ5mb6+Wuu7aTSqUwXUDU\n", - "2S0WxoPBN1yv3W5/y2moDzKqOp9qOHIEnnsO3udDpd9XfPWr8JvfzLf8fu1rl3o1fzzmIxznqy1J\n", - "kikWL95otB033YTN5eIH4+MUslkqKyrY1NGB1+fj8NgYV916KwDr1q3m8OEHCYdNeDxVrFmzma6u\n", - "5xCEFI2Ntex54RButRxNU3F7q3G64dp1iygpCvIFfg9ioRAtr6rZs5pMxNNpUBxnoy3zCIJAWVkT\n", - "Bw+e/JMYuVS83pdRlnXk86+fggDeMA/5Mk1NTay+7joe/tGPUHM5kno9OYOBT9x4I/F0ml8/P0pj\n", - "R8dCC5jVXUl8YAS3+9w6jNrFrfhXNtLXtx9FUWlq8rNjxycW5g68GwRBeENRYTKZ+OIXP83x4110\n", - "dw9gMhm55ZZtl6wbBubvTARZpqQo6F51l6JpGiVNO6cF9o3I54vI8vnbiqL8himo12I0Guno6KCj\n", - "owNN086J/tx81108+uCDGKJRcrksPekA7etvo77+lVRSPD7FddetZ9myZXz/+/+LI0eO0dc3Sig0\n", - "SzKZQZbnkKQin/vcNbS3tzM5OUniAj4JoXicyos4MfODSqEwf2c/MjLvLPoR0F4XFVGct8vfsGHe\n", - "CO1VQeEPFRUVFRgMBbLZFCbTK9O7g8Exli+/eDkqWZbZsnUrLW1tPPzTn6JLpQgWiwxMTbF827aF\n", - "rkiv18u9936cJ598gaGhF9DrZW6/fSNXXrkZo9FIQ81POfz405h02f+fvfeOjuM687Sfqs4RjW4A\n", - "DTRCIxCJAcxJpEiKoiUrWrIkW9LI+hzkMOPxN9m7nvlmxzvnTLDXk2fHXnstW7ISrSzREhVJUcwZ\n", - "mcixATTQ3eicq+r7AxDMv9Cc7AAAIABJREFUqGSSAEk85+AAqND1Vt2uW7+69w0sKLGyqHwdFqOR\n", - "9qEhdAbDOcd1VVQwMTBA8WmOqplslgwiJtOZ1crVai3J5Mfv8y4X14wYKSkpQVHeRpKyZ7wd+/1D\n", - "3Hrrxfkybrj+ekrKyvjJP/4jNXl5VLpcqFUqzAYDRlsbWdlHIDCGJGUR9ApisY2EJGFVFFKZDO0e\n", - "DzVr13LnPfcgTUdEXO5U3gaDgeuuW3dOhM5soVKpWLh6NR0HDrD4NM/4vrExnAsWzIi7j2LRoipa\n", - "Wg5jtxfOLJNlGUnyU15+TrWCj8XZ01But5tv/cVfMDAwQCaToajlFMeODTMxMYxKpSYU8lBTY56J\n", - "XrJYLNxww+aZaruKokw7s2lmPru4uJi8mhqaOzupcbnQqtV4fD68osi2dXOjjWaLQADuuw8sFnj7\n", - "bThPHz3Px6C6Gv7yL6fysuzadXVGIGk0Gu6+extPP/0mGk0xBoOFcHgciyXC1q0PXvTjuVwuvvXn\n", - "f87AwADpdBqXy3VOX+VyufjqVx8kk8kgiuIZ081btm1joqODVUVFM5F78WQSH3DrdP9xOus2b+a5\n", - "n/wE9eQkztxcEqkUo6EQdpcJjebMBp2YGGTjxrnnJCR8kux0lxNBEC5UsuZTs2vXe7z5ZhNmc9l0\n", - "QjMPLhd87WsPYLiIPVlLczNvP/cc1mnnp6AgsP6WWzCYTDQ1daLTaVi+fBFarZY9b7yBd3AQrV7P\n", - "so0buW7jxjnnWHS5EIRzc73AVDjei888g7+rC4sgEFcUdEVF3POlL31sMZLJZHj88V/T3R3HZitB\n", - "krKEw4Ns2FDJHXfccrFPBZgSF93d3Zw40UoqlaGhoYaFCxd+YoGZSqXYu3s3zQcPks1kKKmuZvNN\n", - "N81Egl3pXKjdP4z2drjzzinnyx/84Or2d7gcSNJUMrQHH4Q//MPLc8xP0+6/K6Ojoxw71ojfH6aq\n", - "qphly5ZiNps/esdZ4Ojhw7z/6qvYFAVFUQir1Wy7914WX8ClYGBggPd27mR8aGjmeaLS6Nix4zBG\n", - "Yxl6vZFQaIzc3CTf+MaDH5lr6VIw3ebndSacNTEiCMLDwNcAHfBTRVEePWv9RRcjAD09PRw92kQ8\n", - "nmLhwkqWLm24JM59sViM/v5+FEXB7XZ/aMNns1lUKtWcDLe6nHxY56QoCh6Ph0AggMViwe12f+Kc\n", - "GZlMhubmFpqaOtFo1KxcuYja2tor5rrLsowsy1edWP2kD6WdO+Hhh6dEyFe+cgkNu8bo6ICNG6eu\n", - "7+UIvJoNMXKlEYlEGBgYQBAEysvLP1atr0wmMzW9Pd2vDQwMTPs8xqitdZ/X5/FyMVfFiFpRlKwg\n", - "CCJwWFGUVWetvyRiZJ4PZ2JigraWFhLRKO4FC6iurr5sD79rpXOKRCK0Njcz6fPhLC6mfuHCizoy\n", - "d6XxcdtdUeDf/m1KhDz77NSDc56Ly7PPwne/O+UMfB4f94vKtXK/X0wymQynTp3C09eH2WZj4eLF\n", - "F8Wf8HIxJ8XIjAGCYAB2Koqy+azl82LkMtPU2Mi7zz6LUxTRazSMJxKYq6q470tfOifx26XgWuic\n", - "PB4Pzz/6KLnpNBadjslkkqTNxv1f+9rvXLDwSuXjtHs6PRX5cegQvPLKfEKzS8l/+2+wb9+UQ/Cl\n", - "fIG+Fu73i0k8Hmf7L39JdniYPIOBeDrNhCBw60MPXTE1pz5MjMyqq5IgCP8D6AQe/aht57m0xONx\n", - "3n3hBVY5ndSUlFDmdLKqvJxkTw8njh2bbfOuChRF4fXnn6daq2VhaSmlBQU0lJWRF4ux+803Z9u8\n", - "Ocvo6FQis/HxqYfkvBC5tPzDP0xF1dx1F8Ris23NPB9waP9+VCMjrCgvp8zppK60lGV2Ozt//etP\n", - "FBE4V7nkYkQQBKcgCLvO+nkaQFGUvwWqgEcEQTjHi+j73//+zM/u3bsvtanXNAMDA1iyWQxnhcqW\n", - "5+XROi9GLgqBQID4+DgFZ42AuJ1Oepubr4oO5WLz2muwYgVs2QIvvjgVOTPPpUUU4f/+XygpgU2b\n", - "YHh4ti2aB6D16FEqzsqpZDEa0SWTDF8FjXTJnQEURfEC58ROCoKgVRQlDWQAGThn6Ob73//+pTZv\n", - "nmmuFCfOea4NjhyBv/s7aG6Gp56CGz5d9PU8nxK1Gh59FH74wykx+Pd/P5Vq/yrznZ5nDjGb0zTf\n", - "EwRhF7APeF5RlMgs2nLNU1ZWRkStJp5MnrG8b2KCRVd5TZPLhd1ux+R04p2cPGN5v9dL5ZIllz2n\n", - "zFzj+HH48z+HJUvgC1+YCjVtbZ0XIrOFIEz5j7z1Fjz+ONTWTjkPd3RMORPPc3lZvGoVvV7vGcvC\n", - "sRgpvf4jy3VcCcy6A+uFmHdgvfy0NDfz9vbtFIgiOrWaiUQCa00N9/7e7807sF4kRkZGeO7nP8eW\n", - "TmPRagmmUiRtNh545JGPrI9ztfJBu7/6Kpw8CTfeCGvXzucOmWvs2wdPPgk7dkzVAKqrg7w8sNmm\n", - "hIssT+UricWmfqLR3/7+4G+PZ2ofuDbu94tJIpHgmV/+kszQEHkGA4lMhgm4ahxY57QYmW0b5pln\n", - "nnnmmWeei8eFxMicngGcq0LpSiYWi/HTH/yANQUFM2mGAU7297Po9ttZd911s2bb1f6mJMsy/+ef\n", - "/okFgoD9tCIq3SMjGJcs4Y577plF62aPq73dLzWJRIL/84MfsNJux3haAsfmgQEW3HwzGzdtmkXr\n", - "Lsx8u197fJhv4lVYhWCeD2NwcBCrJJ0hRGAqaqbt+PFZsuraYHx8HDkUOkOIAJQ7nXQ2Np5RwXme\n", - "eT4uQ0NDmLPZM4QIQHl+Pm3zkXDzXCHMi5FrjAspU0VREOcjai4pgiBMTa6ff+XlNWaeq4YPvaev\n", - "xqp381yVzH9TrzHcbjcRjYbYWVEz/T4fC1etusBe81wMCgoKUOfm4guFzljeMzpK3fLl8w+OeT4V\n", - "ZWVlxLRaoonEGct7Jybm7+l5rhhmszbNIuCngAS0Kory+2etn4+muUS0trTw1vbt5MNU1EwqRW5t\n", - "Lfc8+OCshpdeC3PIw8PDvPCLX5CTSmHWagmkUlBQwP1f/eqsVNGcC1wL7X6pOXXqFDufemrqnlap\n", - "8KVSWBYs4L6HHroskXCfhvl2v/aYk9E0HxTKm/77UeA/FEU5cdr6eTHyKUilUqTTacxm84c6CwUC\n", - "Adrb2qYK4lVVUVlZiWqWYymvlc4pEolw7OhR4pEIpRUV1NbWztkHxuXgSm/3dDpNKpX6yHvuUjM5\n", - "OUl7WxvxSISyykqqqqpm/Z7+MK70dp/nk/NhYmTWomk+ECLTGIDgbNlypRKJRDi8fz+djY0ogkAi\n", - "m0WORtEIAuaCArbefjuSJHGqqQlFUahdsoTq6mpEUcRut7NhuuxpMpmkq6uLbDZLSUkJmUyGQCCA\n", - "1WqlqKhols/y0pDJZOjv7yeZTFJYWEh+fv55t5NlGY/HQyKRoKCg4JxcIB6Ph+YTJ0hEo5TX1LBw\n", - "0SJ00yn1M5kMx44cofnQIbKZDLXLl5PndHJ41y6iExPIgoAsSSxYsOCSn+88U0L96JEjtBw+jCLL\n", - "1K1YwZp16zAajZ/q89LpNLveeosj776Lb2SErChy/e23c8fnPnfBz1QUhbGxMcLhMHa7/Zzv3cjI\n", - "CD6fD7PZjNvt/kRiIjc3l+s2bPhU5zLPPLPNrOYZEQThTuDvgKOKonzlrHXzIyMfQjwe51c/+Qnm\n", - "yUlK8/I4tH8/nuFhCmtr2bZ2Lb5QiFePHKGooAAzkMpkUJvNVK1fzx2f/zyRSAS1Ws3Y2BivPfUU\n", - "xnQaJImDp05hM5lYWFFBTJaxV1Vx9/33f+oO+5Nwud6URkdHeeGxx9BEImgFgaAsU7t+PTffdtsZ\n", - "fhuBQIAXnniCjNeLVhCIAIs3bmTrTTchiiLHjhxh74sv4tJq0arVdHq9iIWFfPOP/giTycRzTz5J\n", - "sLWVBQUFqFQqWnt62NfWxhe3bsXlcJCVJDo9HsTKSh78yldm3qo/eGCl02kKCwtnxM2HIUkS4XAY\n", - "vV6PwWC4VJfuknA52l2SJJ557DGS3d1UFRQgCAIDExNki4r4vUce+VjX+Gxe/PWv6XnnHdIDA9hE\n", - "EX8ySWsoxMKbbuKPv/c9rGdFTcViMV565hkme3tRZbMEMxmqV69m5bp1yLLMkb17mejsxCoIJBQF\n", - "VUEB9z788FVbzXl+ZOTaY06OjAAoivIK8IogCP8uCMJnFEV56/T1p9em2bJlC1u2bLm8Bs5hGk+e\n", - "ROf3U+d2EwgEECMRri8v5/joKN7JSTSKQqKnhzePHqVApUIHBFUqDp48yammJoyKQjKdpqO7m7tW\n", - "rcJVWMiR1lbc8Ti6RAJXfT35+fmc6u/njR07uPsLX5jtU74oSJLES7/6FVWiSL7bDUyNfhzdt4+m\n", - "khKWLV8OTAmCF598krxIhNLp7SRZ5uju3TgKCqiprWXPK6+wxuXCGwhw8NgxtOk03hMn+NvhYe76\n", - "0pcYb2tjbXn5jMjQJpOUpFJMhsO4HA7UKhULy8o40NODx+OhpKSEiYkJXnnmGRJjY2hEkaRazcZb\n", - "b2Xl6tUXPKeW5mbee+015GiULFC9YgXbbrkF/VmhntcyPT09RLq7WX1ayd9FZWUc7++nvb2dZcuW\n", - "faLP8/v99B0/jjw6ihZo8ngwSBKWTIYDL79MRW0tX/ryl8/YZ+fLL5Pq7ibp8zHu8RBNJHjz5Zep\n", - "W7QIm9XK6PAwn7vxRsqcTmCqTMCO557jS1//+u949vPMM/eZNfd9QRBOnyQPA+dMmp9etXdeiJzJ\n", - "YGcnRo2Glt5eTnR0kEwmEQQBiyzTMTjIqa4uOoeGqEsk+KzDwQ0OB1t0OkaOHmXs6FE2lJVRo9Xi\n", - "9Pk40thIMp2mt7eXGrsdh16PZ3AQgBqXi4GmJqLR6Cyf8cVhcHAQIRQi/7TpFlEUWZCXx8kDB2aW\n", - "jYyMkBobo/S0YXSVKFJbUMCxvXsZGhrCKssk02kOHTpElSCQAxSo1SRPneKZn/8cUzZLJBIhEAiQ\n", - "zWaJTE5SmpPD2NjYGTaZBYFgMEg2m+X5xx8nPxJhvdvNqtJSVjkc7H3hBfr6+s57Pj09Pbz95JMs\n", - "0um4rrSU61wu/MeO8epzz13cC3eF4xkcxHEevxyn2cxgd/fM/4qi4PV6GRoaIpVKXfDzgsEgxOMk\n", - "YjG6h4dZqFZTZzRSpdWSF43y9H/9F4FAYGb7cDjMYGsrw4ODiKOjLDabkf1+bjQaob0drdfL9XY7\n", - "Bw8dIhSLAVP5ZyYHBvD5fBfxSswzz9xkNkdGPisIwp8yVa23D3h9Fm254vCMjtK1axeVZjOpRIJT\n", - "/f2MBoNMhkJY43GGx8cRolGKT/P5kNJpFokigyMjAGQliRKzmYlwmEGvFyQJjUqFRqUiMd0Ri6KI\n", - "WhBIJpOYzeZZOdeLSTqdRnseJ0OdVksyHp/5P5FInHc7o05HfHISURSRBYHuwUGM6TTHRkawZDJo\n", - "ZZmEIDAeiTApijTk5aECsmo1skpFNBbDWlp6xmfGFYWcnBz6+voQAwGKp0diAPRaLeVmMycOHqSi\n", - "ouIcew6/9x7VNhuW6Wk0tUrFotJS9re3Mz4+TsFZJcevVYxmM0lJOmd5Ip0mPycHmJqWe2X7diLD\n", - "w2hEkZRGw6bbb2f5ihXn7Ge1WokrCmPBIEXT90jX+DhKIkGBSkVqbIwf/s//yZ/+1V9RUFBAMpkk\n", - "Gg6TnZyk3G6na2ICuyxTaDIRTSYJTEyw1OkkP5Wid3iY5bW1AGgEgXQ6fWkvzjzzzAFmbWREUZRX\n", - "FEXZoijKZkVRvqwoynz6yY/JxMQE0ZERSnU6yqxWFrlcVBuN9PX0kFWr2VRcjNtgwCbLBDOZmf3S\n", - "6TQmtXpmnjbXZiMGGIFUOo3GaMQfjxNKJHBMi5hoIgEGw1Uzb11UVESIKSF2Oh6fj8qFC2f+dzqd\n", - "RAThnO1G/H7K6+pwu90ktFr8k5MMjo9TpijUmExYRZFVJSWY/H6GJybIMxopt9spMxqJ+f0cDwbJ\n", - "s9tJptNkJYlTw8NYKyooKSkhHo9zPs8Fi9FI6LS37NPxjY5iPyskWBAETIJA6Kx8JtcydfX1+EWR\n", - "8PSoA0A8mWQsm2VRQwOSJPHcY4+R4/dzndvN6tJSVubmsufZZ2dGpRRFIR6PI0kS+fn51Kxdy0gy\n", - "iSBJjIZC6FIpjCoVNrOZGpcLWyzGa9MjVHa7nRignf4+JdNpDKJIMpPBYrGg1emYjEYxqtXEpm2M\n", - "JZNkdLoLOlfPc3UxPAx/+ZfwF38B0wPT1xRzujbNPOenu7OTKpsNw8qVdDc3o5NlQpKExWBA0GoZ\n", - "DocxOxwIOTkkEgm84TAGjYaELOMXRcorKwGw5eaSV1bG6wcOYEkmUdJp9g0OUlFSwkMOB2OBAN2h\n", - "EFu++MU5HSL4SbBarazcto3DO3dSabNh1OkYmZwkaDJx62mRCBaLheVbtnDkzTepyc/HpNczGgjg\n", - "URQe3LwZnU7HLQ88wL/87d8yHgiwODcXXyyGPicHUaslXxBQ5+fTnslgiscRgXFRxFRZyWtHjyJH\n", - "owgGA+tuuYWvPvAAgiCQn59PmKmH3ukhot7JSUovUDMov7gY/+goRQ7HzDJFUYgqyjVbBfh85OTk\n", - "cNtDD/H69u3o/X4EIKbRsO2LX8TpdNLT04Ps81F22qiUQaejwmLh2P79JOJx3n/jDRKBAIJWy/JN\n", - "m7j985+nra2NY088gSkSoUSrxWC1YrTbSVmt1LrdDI2M4Pf7cTgcbL7lFrYfPUqJyYRJr6cvmUSl\n", - "1WIuLMTmchEIBvEGg9RVVzM8MUF/NMqWL35xVnP/zHN5eOcduP9+ePhhUKth3To4cABO+zpe9cyL\n", - "kSuQbDaLKAi4Kyqw5+XhGR7GEw5zXVUVaaeTtUuWYNDr+YUkMdbRgdNiwWqxIBsM9Pl8bJkuNy3J\n", - "MpOiiGIwUONwYNRoWFVfT+foKC82NbFhyxZuv+8+qqqqZvmMLy7Xb96Ms6iIkwcO4A2HKb/+em5f\n", - "s4ac6eH6D9i8dSuOggJO7N1LJBTCvWQJD27cOPOmWl1dzbf/+3/nbzo6iKtUuPLzMRqNdHg86A0G\n", - "8u127ty2DX84TDqdJtrSguT18vC99yIoCtFkks6JCTweDzU1NbhcLlxLlnCysZGaoiJ0Gg3DExNM\n", - "aLV8du3a857Lui1beOmnP8Wg02Ezm8lks7R7PJQsWTL/Rn0W1dXVuL/7XYaGhlAUhZKSkhkn31gs\n", - "huE803JWo5F9ra14WlpYnJ+PrayMZDpN6xtvkIjF+Iu/+iv+t1pN20svUeJwoDca8csy+rw8ivPz\n", - "GR4enqk59NlbbqHtxAk6Dh7EolaTdDiIqFQoajUr6+sZ9vkY9PvxarVIVit3PPAAldMvDvNcvezd\n", - "Cw88AM89B5s3Ty2zWuE734FXXpld2y4nsxra+2HMh/ZeGI/Hw3P/+Z8Iw8N0HD+OKp0mFI8TU6u5\n", - "8/77WTQtHmKJBP/1m98gZ7PIkkTdihV85q67GGhvxz88TDyVou3UKVY7HNRWVZGXn48oikiyzP7h\n", - "Yb763e+eE554Pk6dOsX+/ScIh2PU1rpZt27Vp5rWuRJD/RRF4d///u8RurtJ+HwIokhOfj7dp06R\n", - "V1PDoupqdh1uorW9i7BviFXFhZRVVdGwahUarZZT3d0MGwx860//lJKSErLZLIcPHuTEvn2k4nGq\n", - "Fi9mww03nCEsgsEge3ftoquxEbVWS05xMVGvl3Q4jKJSsXDNGrZs2/apwlVng7nQ7qOjozz3n//J\n", - "+rKyM0aluj0ejo2Pc2NlJXmnidV0JsOzR46gLyxjMhRnuKsVSyxImdNJRXk5S6qriSUS9AgC3/iT\n", - "P6Gzs5NDu3bhGRzEHwigV6uxmkz4IhGMej02mw2V2Ux8YgKHRkNWURDtdj734IMUFhbOxiW55MyF\n", - "dp9tenpgwwZ47DG4+ebfLk+loLYWnn0WPiSQ7opjTmZg/SjmxciH81ff/S7Hn3iC1TYbBq2WrnCY\n", - "tnCY9YsW8cD995NIp2kbHaVq0yZuuvVWYCocsbenB4BwJMKb27fTsmcP661WRJOJXLebFWvWoFar\n", - "OT48zM2PPEJZWdmH2vHee+/z+usnyc2tQq83EQiMotf7+eY3H8But3+ic7qSOqexsTEGBwYQVSq0\n", - "Wi27nn+eAkXBajQSiMXY19mJVaOlfyhFaDQLikTE38HyQguLKwroDwaxmUzkaDTsDwQoqqzEWFLC\n", - "rXffzZKGhgvmdYlGo/zqxz/GHo3idjrJShJdo6NoFyzg9nvuwWAwXHHZXOdKuz//zDNMNjZS53LN\n", - "jEoNSBKhcJjb6+pmtstmMrz37ru8drgZS8l6rGYn3kSEVMbDTUucFBr0eEZHCRoMfOmP/xiNWs2u\n", - "p5+mzuHAbrEQiERoGR9n4z33sGbtWgRBoLe3l1d/9jNWFRfPVNTuGBri5OQkdz/4IDW1tThOm4q7\n", - "Gpgr7T5bTE7C+vXwR38Ev//7567/4Q+hrQ1++cvLbtolY87mGZnn05FKpRg5dYr1CxeSTqWIAMtK\n", - "S1mUyfD28DAvt7ZitdsRTSaaDhygu6UFTU4O4f5+8kWRVCrF06+8wjKLhSKNBqJRiMcZTyQYdDqp\n", - "qKwkJkkfWSslEonw9ttHKStbj1o9Na9dXFyNxyOwd+9B7rzz1stwNS4viqLwzhtv0LZnDw6Viqws\n", - "MykILLvxRpBlAl4vVW43N3/nO/x/f/mPeOMRskoEhyMHtSqMXmukf8xPIjhB5YIFZGQZKRymPBik\n", - "a3iY3ZEIxysquP+RR847utR48iTGYJAs8Jtdu4jH4+Tn5yOFwwRuuOG8ETfzfDzuvOceDhQWTo1K\n", - "JRJULFzIAzfeyMtPPUUwGsU2HU3W39dHf3sPelMhNaV16LUGCtMp2n0G3mptoSFfT3FeHoscDt57\n", - "4QXCySQ3lJVhnk5Gl5eTw0qNhuN79rB6zRoEQeDkoUNUWCwzQuRkZyddbW1kQyEOShKH7HbW3nYb\n", - "68/jOxQMBtm3ezcdJ0+i1mhoWLuWdRs3zueZmcNks3DffXDrrecXIgBf/jJUV8NPfgLXQlPOi5Er\n", - "kMnJSeR4nCqHA8NZzm1l0SifufdemvbsoQQodrkY9/l49bHHqF64kEVr1nDg+HEqslkMqRQOp5PR\n", - "sTFqtVr8oRA9HR1MKgqqoiLGxsbQaDQXDOkdGxtDUawzQuQD8vNLaG09wZ13XqorMHv09vbSvns3\n", - "68rLUU1na02m0xx55x3+nz/7sxkB4fV6cRZVISoC0cFujDoN40oB/lgAJRShWJwKKz02MkKD201R\n", - "bi6o1WRkGXssxp633+Zz9913zvE93d2Mj48TGRpigcWCMScHfzDI0e5umhob58XI74BGo2HTli1s\n", - "2rLlDCfidVu38t7TT7Nco8Gg09HX1cVoMo2tpAq9dkpg6LU65EgcnaLlrs2byZ0W8mOBAE/v28et\n", - "Z6X8txiNREdHOXr0KFarFb/XS+X0E2d8cpLu1laW22xMACV5eTgLCzm8YwflFRVnlGiIxWI8/bOf\n", - "YY9Guc7pRJJlunbtwjMwwANf+cp8Jeg5yl//NQgC/K//deFtCgpg2TJ46y24447LZ9tsMS9GLoAk\n", - "SfT19REKhbDZbJSXl8+ZiBKj0YjRbmc8FsN9WsREKpMhplbj9XhwyjJulwuASCDAstxcBkdGCITD\n", - "TIyOYtJqyRFFNIC7tJSW0VEiqRTe3j4K9YWUilU8+eQBRPEN7rjjelavXnmOHVPTAefmQEink5jN\n", - "V1ZK8o9L64kTlFksM0IEpnKBOIDmpiZy7XYymQxWq5VIJEBH7wj+wRAWQw6yIuJDJJtJMkkKZyaD\n", - "w+GgdjoXiAAosky508nepibke+4552GiMZno6upim8uFenpdgdmMKxiku6UF7rrrcl2Kq5rT/UYa\n", - "li4lmUxy8M03EdNpmiIREjYHCwprz9gnGgxSUKhBo/5tt2q3WECS8Pn9OE/L+dLc28fbBzoYiO0l\n", - "Ho/j93WyqkDHrWtWMzg6ilOtnsr3w1QEmFajoUCtpqOt7Qwx0tTYiCkcZsF07hoNsMTt5nBvL319\n", - "fVed8/nVwEsvwVNPwdGj8FGPlM9/fmr7eTFyjRIKhXjssWfxeiWmsnDEKC7W8fDD982JxF9Wq5X1\n", - "N9/M7scfRyUIOM1mouk0+4eGaLjzTsLj49ScNsQvSxJqUcQmSUxGozjMZgYFgYyioJJlqvLycNvt\n", - "7Dx1CkPhItasfwCDYeo80+kkL720l+LiIlzT4uYDSkpKyM0VCATGsNunnOxkWWZ8vIt7772KvK5O\n", - "I5tOoz3P2+aYP8Dux17BWbgIQVAjy35OnDiGKK7GmFsKqRQWfQnDviPUVJRi1Wu4e/Nm2vbvB6br\n", - "0aTTLC0pmZpHF8WZB2I6nSaTyWA0Gil2u5EzmakIjWk7IvE45pwcMqfl0Jjn4rJm7VqWr1hBKBRi\n", - "wdq1vP3EMwTCoxTap0aiUtkMoWyE60sLZqZjAFQqFZb8fE6NjJCfl4coioxPTvLsnnZU1kX09kpA\n", - "LolELY83v4ZWPVW6IZvNMuj3Yy8tnYny0qhUZE/LGwQw3NND/nn6JJsoMjY6Oi9G5hijo/CNb8Cr\n", - "r8LHCXa7+Wb4l3+59HbNBebFyHnYseMtJietuN2/vZE9ng5ef/0d7rvvc5fFhmQySXd3N+FgkHyn\n", - "k8rKypmRmXQ6TX1DA80NDexuaSEyMEA0EqGyqgp1NsvY+DhFFstv56idTlq6ukgw9RbvrqxkoLeX\n", - "o14vy/Lz8UajjMXjjOj11NdumBEiAFqtHq22iMbG1nPEiEql4qGH7ubxx19gYGAYQdChKEE2bKhl\n", - "xYrlF/2aBAIBerq7kSSJispKnNM1PD4ukUiE9rY2oqEQxW43VVVVqNWf7BZYsHgxB5qazsjrEU0k\n", - "eLdliPWf+TqFhcUAjI8PEo0eIy8vg8ZuJDSZYjg0hDEnl9Kltdx2yyY69+7FL8vI4+NERZGc0lJK\n", - "Cwro8nioX72aZDKMaeRFAAAgAElEQVTJu2+8Qefx4wiyjLmggGXXXUfhwoUMjY+jzmaRFQXBZKK6\n", - "oYGJjxH5NM+H84GTtyRJlJSWEolEGB0awmKzUVdfT15eHpu2bqW7vR3v2+/TMTiGjJmIFGH5dS7K\n", - "iqaEg6IotPf3c6yxkXA8TpdGw+D+/Sx0uzne3Y9kLkeWc8l3VEyLziIUJcW7vS0sry3Gn05z08qV\n", - "uKen3RRFYSyZZGXtmaMxVrudUG8vZ+fZTcgy5o/w+Zrn8qIo8Ad/MCVGLhCpfw61tVORNX19cLXP\n", - "wF5zYkSSJJqamjl2rA1Jkli+vI5ly5bORCBEo1Ha24cpLd14xn5FRQtoatrLnXemLnnIpNfr5blf\n", - "/hJ9OIxRFGmSZd53uVi6bh39XV0cef99irVaGiwWPOk0Xr+fpRUV5NlsFEkSXX4/u/v7uXvDBvRa\n", - "LXl5eWRtNvonJlguy4h6PXJBAeacHLIOB72pFJmiIupsefT2jiBJbbjdpTMOrBqNnmg0fl5bnU4n\n", - "f/InX2dgYIBEIkFhYSF5eXkX/ZocOXyYfa+8gl1RUIkih2SZpTfcwJZt2z7W/v39/bz82GPkZrMY\n", - "1Wq6du/mkNvNfQ8/PFPlNp1Oc+rUKUb6+7HY7SxctOgcJ9L6+npa6+o41tFBcU4OWUniYG8vtqIl\n", - "M0JkcjLI0QMHCPvSqLOjuKvKaGiox+ncjE6nIZls4eZbb6V+8WL27d7N+2+8QbHZTEJS+PeX3kJj\n", - "t/H1W/L46X/8B+NHjlFgtFDsykcXibD3pZcoXrgQi9NJgcmEShQxmc0cHxpi7e23X9yLfo3xm1de\n", - "YccTT2FKpLHmmOjwjlGen8/y2lqGMhkO7NzJ7Q89RH93N8lgkOIyJx6vl5I6N/d+8Q+or6/nuSee\n", - "4OjAAF6Ph5PHjmHVaFi/bh21lZW0DA2hdrsxxhRGWkcxGrOYzXGMRhMAFosDs7mSL3/7EdoaG/Ge\n", - "PIkhGERRFIYiEUpXrqT8tEJ/AA0rVrD9wAGcicTMy8dEMEjMaKRmOp/QPHODN9+cio555pmPv48g\n", - "wA03wLvvwte+dulsmwvMWmivIAhrgX8GZOCIoih/etb6ix7aqygK27e/wMmTEzim30j8/kEWLDDw\n", - "8MNfQKPREAwG+dGPHqesbMM5+w8O7uF73/sGJpPpotr1AS0tLRzevZvdr79OicnExpUrser1jHg8\n", - "vLlnD6q8PPJMJoSxMcwmE+OA1NdHkUpFymik3O2mPRbjug0b2NXTQ7HLhUUQyMgyhqIiSqqrObp3\n", - "L/FIhLoVK9DpDXR19KLXqxkZi5JKWWlr82A0LgDCrF/fQH5+Pv39x7n//rU0NDRckvP+gAuF+vl8\n", - "Pp74l39hdVHRTLRBVpI4PDjIHd/85jkd9Nlks1l+8qMfUa/VzkREADQPDFA+LWhisRhP//zn4PXi\n", - "0OuJZzKMShJ169djy8nBWVg4MzqVyWRob2+ns6kJtVYLWi2HD4coL19MIpFg12uvkfSP097fgdVU\n", - "RF15CSq7nY033sjExABr1uRy222/TSoQDAb5px/9Jx0dYbQaAxrS9A93IY10cuPC61CrtSSTISwW\n", - "mbKacqipITAxQdfR42hkGZ0jly2f+xxbP/OZM3wdrhTmQojnO++8y3/8j39ksa0Mo95I+0A7xugI\n", - "5aUuVm7disPhwB8O81p7O/V5eSx1u9Go1cSSSV49coSYIIAM5rx8VBqR9154gWUmEzUlJSQFgbBW\n", - "S0N9Pc8cOEFB9SZ2725Cq10OZCkvL8Jmy8HvP0lFhZFvf/sO6urq6Ojo4FRjIwD1y5ZRW1t7hg+R\n", - "z+ejp7ub3p4e+pqbsavVyICYm8sd999PcXHx7FzMj8lcaPfLhSzDihXwN38Dd9/9yfb96U9h376p\n", - "XCRXOnM1tLcfuEFRlLQgCE8IgrBYUZSWS3rA/n4aG8eoqFg702lbrQ56eo7R0dHB4sWLycnJweHQ\n", - "Ew77sVp/OxQ/OemluNh+yYTIgX37OPrqqxTrdNRLErZ0mt+89hpWtRoxGkUZGeHU0BD2nBweWLoU\n", - "bzTKRFsbC7Ra7AYDg/E4akGgRK2mZ3CQ6uJibnvkEQB0Oh3JZJKXf/lLygUB0WLhpcefJyQ7WbHu\n", - "Bg4ePkEiEWHbttXE4xlGRsbRavM4dOgIixYV43ZrqTstz8LlprOjg3xRnBEiMFUQzmUw0N7U9JFi\n", - "ZGRkBHU0iu2snCkLCgs5efQoW7ZtY/+ePQgjI1S7XBh1OsLhMN27dvH8/v1s27CBFlnmwGkjKQ0N\n", - "DTPirLe3l337nkeWJbq7upjo66NUr6fYKJPMDjDUn0Dtz6Ep30RFhZbrrrv5DDsGBweJRE0YJC+5\n", - "MT8GlYaeviGITpJOJ8mxOjAZLfgDo0T8k/QcPY5ocqNybSIry0hCHK8vjCzLc8bJ+koikUjw1BMv\n", - "4jYXkZc7NfWXTqcoU+cghSOMeTw4HA5Mej0TnZ3cVFFBatp343hrKxNHj5NMKdgLauh4r4Xu2Ci1\n", - "WigzGFCCQRZUVDAejfLm7r3odYVUV6+gt7eX/v5uzOZq+vu7KS7WUViox2bTUFJSgkqloqamBq1W\n", - "Szwex2aznSFEDuzfz6HXXiOPqQ5eD+QuXMjGzZspKiqaj6KZY7zwAuh0n86/fO3aa8NvZNbEiKIo\n", - "3tP+zQDZS33M3t4BtNq8c94eTSYnHR19LF68GEEQuOuuz/Dooy8Ti7kwm+1EIn5gjAcf/PwlsSuZ\n", - "THLorbdYU1rK5OQkg34/A+k0w6OjqHJyGAtmiCYsRCU1neOT+Ly7WFyQS3YyiFdUkwlGGVeBNDJC\n", - "PJ0mHA6zwGqloKAAg8GAoij89J//mXqzGYfVys7DjdgM9dgEA76xSSTJjtVazcmTh9m06bMMD3fT\n", - "39+H39/Dhg0r2bZt66wm0spmMqjO88avPo9D3/mQZfm8IwaCICBLEuFwmO2PPoo1EqGzqQlZq2V8\n", - "ZIQcWUbUaNBqNKwuKqJ1cJCdO3ZQVVuLSqXCZDLx9tv76O+foL+/i/f3HCE4GkMTT9Cvz5KRQ9iN\n", - "dgJxH0PDXRRPCnzzH//tnKmf9vZe/CNDlGYzFNgLCYXD5BvyCcYDePpayctzISBgsdhp7GzFay1l\n", - "w6Zl+H0ewj4PGoOZgwf7Wby49ZKPXl2NjIyMkM1o0KmnvuPJVJxEMgpqHeFQFCk71TUlUimikQhv\n", - "7t2LQaUilsnQ3tlJeUxNWBEZiXgozrWTiI3TH46Qp9OijcfRWSzkOxz4mjsw1lRiNFq59dYH+M1v\n", - "nmR09DiSlKWwsAGn08hNN60gJycHn8/HY489RyAgIAh6FCXE0qVlfP7zt+P3+zm0YwcrCwsZ8fsZ\n", - "83rRa7V0HTjA+o0bzytEJiYmOLR3L33t7ZisVlZs2MDSZcuuyJG0K5F//Vf47nenpl0+KYsWwdAQ\n", - "hEJwVsWKq4pZ9xkRBKEByFcU5dSlPpZer0OWz314ZbNpjMbfhshWVFTwne88yOHDx/F4Rqmvd7Jm\n", - "zY2XxBcCppzm9JKEoigcbGxEjERwATbg1WE/MbmCKrWJpCKRlacKtgUne7GIAg5nOQMRH/3JOAui\n", - "Uey2HCSdjvHRUfx+PyUlJUxMTJAJBnGUlpKVJPpGQ+TnVIEAnWOjpNMK2axCNNrPxMQw5eX1lJfX\n", - "Mzi4lw0b1s968qSKqioa33yTKlk+o6MdiUa5YdGij9zf5XKR0umInjavnpUkujweajZs4NnHHsPi\n", - "97OmoABfLMaBlhbSgQALXC7iwSB7DhzAftNNJKJRXvynf2JRbR2pbJbGoUkWrvg8NTXrGOkZoVjq\n", - "IxlpxS4IBOMq9MbFVNndLHAIdPp8ZKQ8BgYGz8lMq9WKRMYGyCudck4UBAGTxsCk3kwwFiKRjGPU\n", - "m4gkopyaDKASKnjhFz8iT05R5ixC0OsYS0TZsUOcFyOfArVaTY49D58vACPdxMeH0ScTDMfGUIQs\n", - "S6e/Mx1DQwTGx9lQWEipxULv0BAdXh8ThiJErQmjYGIoECARj+CQs8SCQbJqNe+fOsVNK1YQySQp\n", - "cS9Co9Gi0Wi5++6v0tfXRmvr+2zc6OaGG65jwYIFKIrCU0+9RCrlwu2emmpRFIUTJ05QVHSQnq5O\n", - "Oo8fZ4/XS54oUldQgKxSMRwOs+PFF/mDP/qjM87P5/Px9I9/jEtRWOFwkEil2L99Oz6vl22f/exl\n", - "v97XGkePTomJz33K2Ae1GpYvh2PHYOvWi2vbXGJWxYggCHbgP4BzszsB3//+92f+3rJlC1u2bPmd\n", - "jldfX8vOnYdIJuPo9VPptjOZNKnUKA0NZ2Y2LCgo4PbbL8+NajAYSCkKPR4P2kgEs83Goc5OUokE\n", - "yYwBgwrGUikKgbQgIGPCr2iQpThvjfQgiwIVgkggEsWXTLBgxQpuqKvjrZdf5ivf/jaCIJBKpxmf\n", - "nER7VpK0QHCUUDJLOGxDEFS8//4+GhoCOBwFlJXZP1WNmY9DIBDg+PFGRkd9uFz5rFix9ILblpSU\n", - "ULVuHYcPHKDEbEYligyHQuQtXkx1dfVHHkur1XLTvfey88knsWWz9A0O0jcwgGI0slivRwwEWLF4\n", - "Mb7ublpHR1mk1eKRFXrHA+gsJoplmad37qS5pY1QTEM4WoRGb2LEL5HJHCAWm2CwZT+GdJJSETKZ\n", - "CGm5GJMGgskkGiCpUlFYWMeePUdZvnzZGfY1NCwingzQ1t9GLB5EpdIQTqXJN1mZ0JloCvkxxCOM\n", - "hMYw51rwDp6iJBHDrjYSGhihuLKKWqOFrqOHyGQy81VePyHFxcUUFVk5PmhivOMYC612SnLyOBKb\n", - "pMhiormpiZCisH3nTspzc+no6qJTrycdS2AV1fTGJzCLVuxSgmDGT34GEiozGSWXWHSSRGyCp44c\n", - "IXdxA6JGpK+3BUmWCPs8DHcchdQoh9+IE/EOsunmmyksKsLrTc4IEZgSqIWFNfzqseexRUbIer0o\n", - "vgBjkoqAP8TWJfUssVho3b+f2COPnDGdfPD99ylSFCqm85PotVpWGo0c2LePVevWzVd3vsT87Gfw\n", - "rW9NiYpPy+rVcPjwvBi5JAiCoAaeAP5cUZTx821zuhi5GNjtdu69dyvPP/8OkpSDIIhAkDvvXH/R\n", - "nb2SySTj4+M0N7dx8mQnkiSxcuVCNm26DovFgizLDAwMcOzYCWKxKDFRpL+5mbTPhzmZZIvLRefA\n", - "AEpWYEwaJyrZSar0+KUEZnzYyOJAJECWsCxQIGoQFcgIAt6uLjobGxGrqwmFQjQ2trC7aYijqVEM\n", - "eogngyjKCMmMQiAaJS9/EZHIMKIoolZXcvDgQW64oYp77vnWRb0mHzA0NMTPf/4CslyAyWSjq8vD\n", - "vn1NF9xeEARuueMOuurqaDt5krQksXHJEurr6z+2j0RdXR22b3+bf/27v0OfTnPnpk2UuFwca23l\n", - "RFsbS2+7jf7BQUKBAPqkTDytJSBpKMx10doxyBHfEIasngVGC+nxXgYlNaKpgd7WvSQH9mJNBCnR\n", - "G0iqNAgqPeGkjkA0SlajQa3WENFZ6Onx0d5+EptNy8KF9ZSVleF0OrHZbORYRNJdzZSb80jLUVLp\n", - "SXwCTIpOkjEZozFOjk2kPKui19uO1eBCLaeRJImO1ibKFhRRUe3A4/F8pA/NtUAkEqGrq4tMJktZ\n", - "WekZicLORq1W89BDn6P58H50eU66o2Gy2STLljWwYuUyjnd1cWxkhJV5eVzvdjPh8zEyPMyOsTGU\n", - "dBaTIpJVvHTJWXKkBGnRSEY0I8gq9GoHitrCmJKgUFAYO/kKoZTAkN+HJZ3AYdCwsqKMWCBA46s7\n", - "GGtpwb1+PaJ4btJASVLo7+jkS+sX8devH0SUS9GJVpLZCN0He7mpzk6F283AwAALFy6c2W+gs5Nl\n", - "Z9W1UatUWBQFr9c7L0YuIek0PP88HD/+u33OmjXw619fHJvmKrM5MnIfsAr44fS85fcURTl4KQ+o\n", - "KAp6vY6ysjyGhkaoqCji5pu/+KEd1SdFkiR27drDe++d4NixDiKRNA0NK6irW82hQ4N0dj7N1752\n", - "Py+99Do7XnwLZcJHjiKTUCL0B73YgkE25eaSFARclZWMdQ1TkIKkGCehaFALASoVAZUAhYKaqAxN\n", - "yGhUWvLVIqJaIZTN0tPcTDQa5Z//4Qec6kmzdOU9dLe0IaVSxJIifeP7CWe0ROM2YvEJBEEkN1cm\n", - "Ly9CVdVq1qxxX5LCXIqi8PLLb2Ew1JCbO5UdITe3AL9/9EP3EwSBmpqa3ylc0efzoYtEsektjI5M\n", - "oNVoKC8qoqelhYGxMVatX09jcztqkxmDLo0BHWq1EX8ghSqVpUbvoMg6lalIHh+hOfw+VSoj2fAk\n", - "hUi4rAb8iTBpiwWtkkSfseNXBMzmIurq1+L1niQWU/GTnxxm2bJJcnP3cf31i5DTce5YvZoxi4W0\n", - "30+eSoUurPDORIjl192FKFrpaz9Be2sLDk2IXCFBJOlF0ecSTMSZTCZRNElSk0Pws5+x7dZbWbps\n", - "2SVztr7cJJNJTpxopLm5E51Oy+rVU0L0Qv4Ora1tbN/+JpJkQxDUKMpB1q+v4bbbbj4jguP0/UtL\n", - "S1m1op4R/zBmtRqL3oGiVZEcH6e4oICUJGFVFBLpNPn5+XSMT1CoiOjUOcSVNKIsIUlJfEoKUc7F\n", - "oTcgq9SodFryzXrGUsNEugfIUVlQ5ZhxCWnq8ixMRKP4x7yEAhEyEgyndXQMvoyjbjlO5yK02t9O\n", - "kfb3d1CZb+H1Y+2khCU4BAd6lRqD6MQb83LI5+f3rNZzfeIsFmLx+BkO4ABpRZkJa5/n0vD661M+\n", - "Hx9Rb/QjWbkSvve9i2PTXGU2HVifBp6+nMd8++1dvPNOKzk5FVitRXR3ewgGd/D1rz940Tru99/f\n", - "xzvvdKLRVKIoAiUlLnp7O9Bq26ivX8nAQCPbtz/LazsOo4wOU51XgjPHgSRlkTOHCIfDiDk5JKJJ\n", - "ZAmsBpFQOo4CRNBSpKTRqBKYFAlZBhCxAKNSEpdWj06lJq4odI+NoddqGRIs6OVKOk80UrdyJbIk\n", - "YY9WY/Ia8XqDhMM15Oe7sNlyEAQIBE7gcn2yZGKfhHA4zNhYhLKyM6dlPsjgerGPNTQ0hCAIuFwu\n", - "fvX4MwS6JtAXLUCWJQ4f7sbtziEnN5eOvj5qSkqQdSaygg5BZaTevYTx8Qlichyr3oqg1yGIIvFY\n", - "jHy1AWvKg1ptQaU3ISezBENBbBYNCb2eNU4Hr3UGUOeUUVBSS3//MXy+Vhoa7kOSoKWlB4vFwp49\n", - "T1DtSvHQ2tU4c3Px+f2ko1GGmjpZXr+QPFcpXY2dLHVVEPZ4CGbaWeMsYGR8nHgqi06dj1VvIJNU\n", - "E1LraT/QSV4ySeP+/Tzw9a9f8W+9qVSKRx99muFhBbu9hGw2w+OP72LDhgHuuOOWc7aPRqP8+tdv\n", - "4nAsn0neJ8sSe/cepqzMxdDQCAcPNgMC9fUVbNt2PQUFBSiKwoTPRzabRWcxkxUECs1mgmNjtKlU\n", - "rKutpbioiM4jRyiUZXpGxnHrTQzFExhttYhqPZmIl5GkF4PFhKjVUVbkwqDT0T05xkQkyfKichRB\n", - "h8acgyEYIjDuJZOM4fWHcZpzUUjTOzFCTvECQiEf/f0HsdurMRgsBINetNpxHAU2DjaN4C7eSMTn\n", - "BwSQJeyGcsLZNKOZzMzIWCAQQFEUlm/YwN6nnybHZEI9PZI4PDEBublEo1Gam5unsylfminZa5kn\n", - "n4QHH/zdP6eyEiYmrm4n1ll3YL1cBAIBdu9uwu1ej0o1ddoWSy6Dgy0cP36S668/N6/IJyWTybBn\n", - "z0mKi1fS0zOAWm1CpdJgs9XQ3X2c6uoG1GoTTz/6Y4z+KC4BenwjHFckKkrrsOhyGRcGOT7oJUdr\n", - "QlSryRjtCEkPsXSCeHaCAtLkIBJGYRAFPSCh0CODOZ3ClM3gE0UCBgOfq67muD+FwypiUanpaW3j\n", - "+s98BlEUmPA3UVlZxciIjN3umHmbEoQChoZaqa+//ne+Hqfj9Xo5dvAgfZ2ddLZ1YTYvPMOR82Ln\n", - "Gzh86BD7duzApijIikK7z0+/X48zpwCDfkp4GgwWBgZ6KawsBYuFQ14vEYOBvf4Y+WojoeF+4iqR\n", - "SYOZFVYj8XiWQDxOOBojJWVRIyGrAhh0FgJZSKQjONNG/J4Q6nCYXKuGnolGhOQ4OQYVBgrpOdVL\n", - "LC0hijHWrFlJOi1y4NhzBJpbWFheCoJAWhBQNFZktZZoNIZOymLQ5VCY56K3p4XNRbl0BoMEYioK\n", - "jQK+RBzRrKdh0RYy2SSKpGCPRtm/Zw+3XuHVChsbmxgeVigv/614tdnyOXjwIKtXL6ew8EwR29PT\n", - "QyaTc0YWYVFUoVLl8Wf/7/cwZATMFgdmp5tMJkpPzzP84R9+iWQySdDjYTwYJDM+jlGtplVRUFmt\n", - "iGVlJNRqXMXFSJJE89GjhDJpbIBoyUWnU5DkNDarCRM6wlYj2bREWIozHIvTm5WwW/LRa4wkZAW9\n", - "zkBEo0NKycSiUWS9BRIxJJWaXL0Oz0gfzqpFLFvm5Pjh9/GOjFOzsJKvfe0LPPerXxGKREiLg8TT\n", - "cWKygigasdmKmUymuP6226aiw37xC0IjIwiAIS+PvIYG9re1YRUEUrJMWK1GiUbZ9+STqIG3geVb\n", - "t7J569b5CJuLRDIJO3fCj3/8u3+WSjU1wtLSAht+90fVnOSaESMejwewzQiRD7DbS9i9+yBdXYP0\n", - "9XnQakUqK4toaFhMVVUVRqPxYx8jkUiQzQpotXr0eh2S5AdApdIiyxrS6SRdrfspzqTRav5/9t48\n", - "yLKzPPP8ne3u+5b7nllZqk2q0lJSgTYkIQzIBowHA27sxh3ydHvcETi6e6L7jwm7Y9rj9vTg8LTD\n", - "HtvCAgMyq8CAVJJAa2mrfc2qzMp9v3n35Zx79nPmjyxKSAgMDskIrCfiRuS9ee53MuOc833v977P\n", - "+zwBas0KUdvC6LQ4X1zBkhXauESTXWQlGRfQLRPVdvilZAJfFjlfLlNyXZrABBAAmsCwKLIBNHwf\n", - "NxhkuFBgpVZDLNepF+voSggz3o+q3owsC9i2xshIH8GgzszMZXw/jCAIGMYme/fGGX+Ny+hPina7\n", - "zYXz5ylvbJDt7mbvvn00m02+/jd/Q78ssyseZ5o2zz76MLfc/f6ri8nW1uI/6Xyvh/X1dV7+h3/g\n", - "YF8fwStkzqXVMp2qSz0RotSqongSHVWl0m7RTEv8H3/wB3Q6HU5eWiAaSZEIR9F0Fd2X8aMVgmGd\n", - "oAyXl5dQbA8HCV0R6U4EUGWPhuAhui7L7TZtQaBXEAgrCjsiIqFQlkBCoVG3sBsl2qZBOg1nXvo2\n", - "QcmFRh3ZbhCSIBqNcnFtjZcrDUh1M+GFCNkBfD9DMhFkSfZ5rtFAUIIU5QJ6NI0lWBzad4hULEu7\n", - "06DaLHFgYoTHnnmGUk1jYWGDWCzMO9+5n4MHb/q50iK5eHGBVOrVNgSiKAFpVldXfygYcV0XQXj1\n", - "/2dZFidffAlno8qdN24zACv1MmvtOn07b+Do0ZPEYiHMzU0+vGcPxXqdaq3GgO9zsdnEXltjWhBY\n", - "OH+eQr6HGSvEkhtBE1xGYj0M5XsRBOjYBsVQBymbxw3kuFAt4nsaqlFEFPKcW1tk9/guupM5VkQR\n", - "U2vhOg5dpk7b6HDGdchGEniBIMVTz/LN9eP82u23kx++lrPz8/yXf/NvqDebWI1lQCEf6MeRFUzF\n", - "xZSbjAzmaTQa/F//+T9zXSbDofFxRFGk0mwyMzfHr95/P6ZpAvDIQw+xN5+/KgLouC7Hvvtd+gYH\n", - "fyJS+Nv4x/Hcc7B3L7xR1e59++DcubeDkZ97qKrK7OxZLl26TDAYZGxsgoGBHZTLa5w/P8OhQzuo\n", - "13NcurTIo4/OMTp6lh07uvn4x9//Ey/M0WiUUEigWq0QiYQRBA3D0JBlCVl2MU2D9tYlfvmGa/nW\n", - "d18goas09TaDrssQPoZpccKx0fKDVINhHNtkzVDpCYaR9Q6FaIRaOMyipjEMOFdcPdueR9b3iYgi\n", - "wXSaGU0jK0nckMngJxKcnS+jSDLH187x+ON/j6ZpFAoyly4do1DYi21rtNsNfN9Flle4557fudpC\n", - "u7S0xNGjp6nX24yN9XPTTddfNe76Qei6zveeeIIv/+VfEgd2jI5SS6U4+fTTEAgwEYnQfSUT8qFb\n", - "b+Irz5zgxWe+zg2H7sbzVAqFV3ZjrVaLVqtFKpX6JxkTXjhzhpwgXHW1BUhEQsiWiUYP3zz3HCG9\n", - "TjoSQsVlj5ugWq1y6exZ3rt7nLNzmzQ0i0wiQ9RpUkn5PLlWQWwb5D2TuGBSFkRSkTRbgk+6WWEn\n", - "4IWDqLZFJBJBSSbp1TTslE/dKLO+JiLYNrLfS0BoExOiRDoadb/GdekkWTvIzOoqng84Hr2egKYJ\n", - "NI8/xXo4TLk+RrneIdd9kI12ibq1TDyXpLdvL512m0xmm8vSMVtkEyG++L2n+cbzl0gmlsn3DHHD\n", - "wf18+9vnKRarfOhDPz+y8aFQANs2X+c3DuVyma994QvUymV6h4e58dAhBgYGgOdwXefqxmNjfR2z\n", - "tspornB1159PZGjXNjF0jfn5NfoLUbLBIAv1JtMVE92K0a5vEfZURicn+cgdd/B///03eWp6g5AU\n", - "R45ey6bapNPYxNAtUsk4y3qJkQOT3P2hD/Lk499jbnGOgNqkIMO661APp1goLlOy2sxWGqxaEr1S\n", - "EMdzAdgnisxaOmOZbkS9wbAbpFKr0VJVVs+fZ6hYJG1Z7Myneam+iCFLSFKWZFRmqXiCcGyC//qH\n", - "D5GqLqHmk2wsrnPbbTeTSyaptNssLy5y6+23MzU1RdyyXqVGLEsSw4kE544ffzsYeYNw+DD80g9X\n", - "Ev/J2LcPrgjy/kLiX0QwUqvVeOKJo5TLIqnUOLYtcOLENM1m/Ur55BbK5RZnz67Q07OTQmEXzeZJ\n", - "QqFJHnroEf7jf7x/20L85RPMzCyTTMY4dGg/k68xrTIMA8tSeeKJvyce34HjmNTrp4AWO3bk6XSm\n", - "2HPNMLFclm8SXyQAACAASURBVJbTotZuMOLaxGSZju8RliV2IbDRrDJ0zc2cXbxAFogZHWKRMNlC\n", - "gYGtLRqmCb5PQxDYmcngCwKb7TaRWIzkzp1MmCYFyyJ9hZx2zaDN2fkVBLVNq1LjXe/5GH193fzD\n", - "P/wtJ09+nX373kcms50VKRT2cOTIeQ4dOsTU1CW+/vUjxGLDhMN9HDmyyYkTX+D++3/9VeRW0zT5\n", - "sz/+Y05/5Sv0WhbhUIilapXK2BhduRzPTk1x6Nd//erxiWiU33rPO/nW2bPcfHOK8fEDjI2N8alP\n", - "3c83vvEdTp6cRRQj+H6HW27Zzb333vUT7+YXFxc5/PDDhObnWY3HSRUK9PT3kwyJzK9P41fDREM3\n", - "Eoh51IwSfbkKv3pgP0989asYhsEdQ0PsHBxktVSiqXWotSRm1+NE49fjuW1ajk5HKrM/oCK4cFZX\n", - "6ZEVVNdg1/g4bqOB5Dgc39ggCjQsi9FehaXKFqlogoZbJa6kMAybqGQg28v0hQcQfZtIPM50tcFk\n", - "eoCo77Poymg6VLQt5qstdo0dYKR/BFXvRzQncMQNhvaOUVmroXZ0HLeDIlc4OdPghaNTpIMT9ISz\n", - "2OU23/vWd7nvIx/k5Mk5br21jKIozF6+jG1ZDA4P09fX95ZMz99ww17Onj1MJtON63p0Oh08z6ZW\n", - "ucjFpy8ymU4zGY1SPn+eL505w4fvv5877tjHk08eIx4fRJYDLMwdZyBnkiaEYXYIBsMICOA4XJ46\n", - "Sj6/m3Ykj5Iv8N1j6wTFJFVVpdkOYwsOXR5sVCpkEhPkGxqDhQL5XJYzc4usbIrM+2vIuLz3Nz7A\n", - "v/3df8sXv/hl7KUq+3r3gqri2Boho8KmIrPkQWm+iUQ3ffE8KcmkYy8z4TToCoSwDJ358ho7M1mo\n", - "qXznkUcJiwLjjoNgWZiWxU0jIyTCTc53NhH9Mo4jsiObREpcj+C5RBob1NY2MSqb1Irr/NKvvJ9E\n", - "KESttN20aFkWr9f8HQwEaL7t/PyG4fDhbc7IG4Vrr4W//2dlWf7z4hciGLFtm7W1NWBb4Oq1RnYv\n", - "vHAU3+/hnnuu4eWXz2GaAQQhx4kTR0gkPNbWGszNTWGaSer1Rbq70wSDEXzfwzRjnD59mmeeOYVp\n", - "5shkJtjaUnnwwSd473vL3HbbK4Z6X/vat2k0ohQKKWZnXwJkQiGHj33sLg4dOkihUODTf/iHHHv2\n", - "WQqGQcm12PB8BMsGwWfJE9nwYxhNn+LLT7EvHkYOhHC1JglFRm008DyPlCwj+T5hQSDousRCIZRI\n", - "hK2uLu694w6eXVhA3thgrlSiVi6jtlqopkM2VqAVDrCyskGlUiOZnCSbNQkG14hGE0SjaeLxDOXy\n", - "BlNTU3znO0fo7j5AsbjMuXOncF2XSETm8OEn+Y3f+F+AbXXTxx97jLnHHqPbshiNxUCWObaxweXV\n", - "Va7buZPm/DzffOopfunWW68y+iVRJJ/Lcdtt7yTxA26zJ06UGRh4B6Io4boOR46cJRx+gTvvvO0f\n", - "vQ/W19f5h898hslEgnIohFRr8MKpC2w6Di1foG4nCXmzJGKDgE8kpBMMSMTDYYLtNk3LwrAsoqEQ\n", - "Iz09OK7L3z3+Ejg5Ygr0dMfxVRVByKIL84yLBpfbbbryGTKJfiKizHy5RthxCeETk0Rcw6C4topo\n", - "d9gXT9MJmzy/cZGAI9Iblgh5BsVakd6AgIeAhMRRrcNlXUBHJCKFiQojhAIh1rc2adQuIYVjJHv3\n", - "kIh14Xuz2GKbsxsbDKdD5GMyz7x0DsV16aWBXFPRBYGQ0sXR51/i5lt38eLzz7N46hQZ30cWRU46\n", - "DiM33cR7f/mX33Iy4mNjY9x11x4+9+CXKK60UHwHmyqFhMeBu+4iecXMMRYOE6pWeeaxx/jYJz/J\n", - "yMggp05dQNfb3Hr7ILOPnENdmqG9uowST6IpIUpby8QTUWIbcU5cOs+xi0uk8xPMrzbR2nkkv4uO\n", - "r/L4S3MkQjF8vxfPqDC3Os2xWQfXEwgGRW7ZvYuxvZP8/n/9AzY2Njhx5Ay7usaYPXcRyQUIs6la\n", - "LLUvUve7EBkASSVRyNMVybNV92n6bQq+het75HqGcQSBjZZGtVFjNBYiHA4j+D6GaVLXNJKiSFBw\n", - "GMsmqPlxpnWXntQIK5cPE+zUGYukwTcRqnVe+t73CA0Pc+311wPbc+QR38d7rYhgvc6OW275GVzl\n", - "XzwsLkK9vi1W9kZh7144f37b5+Yt9pi+Ifi5D0bm5ub48pcPo+vbi1wwaPLhD9/DNddcc/WY6ell\n", - "MpndhEIR3v3ud1Iul1lcXKbRiDA9fY5otBtJChCNZlGUIBsbFbLZ6pW2OpmjR0+h61kgzIULsyiK\n", - "TE/PCN/97nEOHLiOWCxGuVzm5MkZ5uc1JGmcPXtuxDCarK6+zOGvPEysUeXc5cvItRqS7SC7ElkE\n", - "cqLAmu9R80OU3X7ChPBRMRsGp9UmCirdnkuq0yHhOGi+z5brIgsCKc/nfMsg2rao+xZdO3dS7XQ4\n", - "eOed1GZmUKemSEYiTPT1MbNe5sxKh7WlJsGUhKYJzM6uEIl0MTAwyPz8HLOzKr4fwLabSFKNcHiA\n", - "1dWXmZ+vEY0OEI0mKZc3+Pznv8lAf4ELL79Mp93m8COP0LW2htnpsC5JLPs+mVCILlEkJwhc19VF\n", - "Z2WFY+fPc9uVCXGhWKR3cvJVgQhAf/+uK5wAkCSZvr7dPP/8SW677R0/NjuytrbGn/7J/0t9dpGx\n", - "3jzzqsb6zAK+rpL1PTw/QLcQpOKvMDIxTCwUJRUfodZeodxs4vs+8Z4evvn44wzGYuR7ekjk81Sa\n", - "NqF0DqNcxnI86ppOJqigCTLBVJiA7yNlM2yUK0iVJrZlgi9giBJ6x6TsuAgEKSLy8OVNImHokiSC\n", - "rkraELAEkZlmkUo4jKBbnLMUfHcclzyykMDwymj2FPnAIGElQbnhkDUKXC5dpONVUdfyfOCde1mQ\n", - "41TrdVbKNnJHY2cgTkQOE1Ii2J7DrLFOcV1A07o4/fQp7hofJ3JFWdfzPI69/DIzk5Ovem7eChAE\n", - "gUQ8wt6cxz2DBYKBAEFlgscef5yly5evLrAA3ZkM04uLOI7D+Pg44+PjWJbFX/yP/4HpOOwcGcSo\n", - "NpgvrbNSK9Ff6OLWWw7QKhZJ1+s011ZY8CWi8l4CYQnd6BALF9Asi0eefQ5LmWCt3AKhh1BwiHQ8\n", - "Q0Pd4PkL0xRGtnWKFhaWcd0A5xcuoasu2XCKqlFjrqUTpIc4A0ik6bg6FzZLDO2epLdnhHppE93V\n", - "sJQYJVtmpgWqKmGQpGyqiIk462oHV/R4bHGR3mAQU1LY0ktsUkbNTuC6JlnPxYmkqdoGScFD1A3m\n", - "L11iq1TCTSZpViq870MfYuKWWzj+wguMZjIossxatYqZzZJMpTh+/DiJRILR0dG3BfT+iTh8GN7z\n", - "njc2aEint19LS9vdNb9o+LkORprNJl/4wiMkk3vJ57d5DLqu8tBDj/Pv/32OfH67jp5IRGi1tlVX\n", - "A4EAzWabUslGlpNks9fS6Tjouocsr5JOT+B5TTzPuMLIr7O1pbG8bNNoCIRCSVzXZnHxEvm8SrFY\n", - "ZHx8HE3TWFraRFGuJRbbbo3tdDSCegSzZbGnq4u5M2cYCQQ4rRr44Th2s0rbsegAm8TpJYJKiWEg\n", - "LYWp2j5twWVLlqmZJoKuowEaECbIppwlKiu0HAddlOgrNcm02wxubrJYr9Pe3OTW4WFkUWSlPs0a\n", - "cfozw3SaZTIje+jpGWVm5llOnChSLPooyiAgoOtFZmfbWNZzrK15KMpuqtUykrRJNpthbVXjs//P\n", - "p/nobbcip1J8Y24O03VJhkLgeZiGQcJx0KNRWp0OQ5OTCKLIS1NTRFMpXFkm2NvLh19HH/m1BONA\n", - "IIRleRiG8SPbr2dnZ/nc5x7h8ozLaGwfq6UOF9ccNNPgYCCE4HugJBgMDTFXX2VxbYW7brwLAN93\n", - "MC2L6WKRfk3Dcl1OXriAcvYsWjxOLTLINfuv49GHH8XxJKKhLGvtEqZd5mjHoJXLca5SIdVoEvJB\n", - "8EXmbYMt1waCBMigksIjju3E0NorJEId4orCSadDnyTxznicimUxbRm0vAHiwX4kgkjE8fw4BjXq\n", - "+hqauRfXS1HV6jhOEheJy4ubfNlscsdggQFRpJxK0ZJFugMK6+1NAulhFFEm4/tsGUU0bZXJRPBq\n", - "IAIgiiLDqRQXTpx4ywUjvu9z7OmnOTg6elXKv6VpJGMxyqur6Lt2XdXKMG0bORB4VdA6NzdHVNP4\n", - "4L33cvTMGVSg2mkzIKbZf/B6NhfmCbZaKIZBj+BR82RqHZ1gIIznezRbFRTJp215NOwF8AaIBMbw\n", - "bCiWi0SDOqrXxZnZVUzT5MEHv8jTL50noPtEBEipJVpWkRh9RBBoYBMRAsQIsuGbHJmbY9dAASkc\n", - "5HS1ypoUx1bTIPSi+iayJLFpn+Vkc51xQSFuO8iCzZrjsyFJNJI5Gr6AqTWp15boEkUSuUlWy7Os\n", - "GusEjDYTI8McGB3lrvFxpqenefSb3+SDH/kIU8PDnD92DEPXGbz9di5OL/HQQ88BcaBDLvcsv/Vb\n", - "v/Z2y+8/AYcPw8c//saP+33eyNvByFsMU1OXcN0M0egrhMpwOIYgdHHu3BR33XUHAO94xwE+//ln\n", - "iMVSuK7H3NwaoVAC3/eIRvdgWW02NuZoNC7jecskEklisSzLy8d417v28thjz1IqCfT0vOJc63kp\n", - "FhYeQdd1YFvdtVarMjj4in9No7RCQlQgkqPW2nZVzSeTmLWzYHoMhZOU1BoV30EgShWVPB5BIUzb\n", - "tokiEfRFDM9CBkaBJLAMnKYb2StgSSGGx4ZJRGMsr55iZyzGjmgUzfdZ9zymTJP5zTLThoxGhJVy\n", - "hYBp0zu0i2DQQ1GKXL4cpKvrVxCEAJal0t9/CMNY4eLFKWKxe0ilBvE8l1LxDMXZ48QDJmWpzdPi\n", - "83imSciVKTs+TsejInmYvo/l+6zrOplUin3XX080GqWRTrPrvvvo6+tjaGjodUsCpqkTDL4ixKRp\n", - "TZLJ0I/savJ9n+9852nS6T309ik4tTrpWA7LKSD5y4wn0zQsg1Q8w1a7RW8kxVR7i+VqBcE1sN0i\n", - "C0aCiCwTqtUYA4ShIRq6zkqziZuWOXPmBMn8CJsbS0StDrZdIynYdDJZhrNZOisrNC2bLSlEHQi7\n", - "AFEqxHFJkWQQiQCikAFfZtG4gODpxBSRsOOw0Wggx+Mk8/1kKlmaXgffFwEbXwCEHJa3QUhIYng1\n", - "Il6IOEFCgQIhUaa4usJmuMw1o6NUOh2isSCe7ZJWfDrmGr4foNbcQOjK0OlIHJs6TcR2uWbnDoQr\n", - "10ASxauGcG8lOI6DoarEfqANPBGNkioUqC4vY1nWVTPI6Y0N9t1556vuq2a9TkwUySYSvPe221B1\n", - "nedPniRcLrO1vo69tkZfJEIyEKAQFDldrhCW+0lGYjgimJ0Wut3AdXV2yD6LnollLSIIYUTRxvc9\n", - "HDfCsZePcfPNd1NZF1G8ARwphmmXqNsOKj4DBIgh0qKO5WeRCKMQZsts0147z2iPRyccZb0eIRga\n", - "wBcCiEqMeDhFvV1D9tfIRiKoHZem55EKdRPKZOnefRuKH+apMy9SrpxAMn2CLuQiYTRERvJD+IEA\n", - "8StiaDv7+3lhaopWq8XevXvZu3cvAN/61qNUKlGGhl6Z47a2lnj44Uf57d9+E1bVX2AYBjz7LHzu\n", - "c2/82Hv3brf3fvCDb/zYP2v8XAcj7baGLP+wgmAwGKHZVK++3717N/fcU+aZZ15CVQUajVl6enq4\n", - "/vq7eOmlS/T07CKfH2Nz80n27NnHzMxFEoktRkcnGBsbJhh8Ac9r4fveFQl50PUaoZCMc2UCTyQS\n", - "TEz0sbo6SzY7gqIE6ahNohhksjEioRB9fX1cnpsDy0QSgliuTVKJEHRt2q6JA0SQMH0dBw8LgQgu\n", - "vUAGaAC6IFDxZWJCCFcUCcoK+UwWtVqlEO2irZlEQiGuGxtjcWoKzRJIF25hwtHpWB4L5UW2aiUu\n", - "XVK59tq9yPI1XL5soygu0CSsVEBrUGnUEEUZSeqgqhVqpUtE2uvkRQHb0lHrFfxyiBdnFukKD9Ay\n", - "Oyw5DbrFOCWKCHhEs1nuue8+AoEADVUlOzDAoUOHfiwvYW3tNF1du4jFUrRaNSqVi3z843f9SHJl\n", - "u92mWtUZHEwzND7B2SPPEQooJCJxipUgdVNHDEcoJLOYTom1eoNoppfIQBTbbPKrH/gtevv6ePKB\n", - "B7DLZYaumCEOAiO5HH919jS6FSai9CLHJFa2ZohJHUYLOyg1l8lKNQ4WClRaLeRoN8fmzlMlQpYY\n", - "VaKI7KCKi4tD0F8mjQ2kyfgNIpZNt6KgAm4gQE8sxFrDR04E8UM5Wi0bfBe3VUWhheMcRfYEguIw\n", - "rh8ERDxE4kKWlXIZa8glGYsxPD6KurJOp94mFoaGWUPJJ/jgR/93CoV+jm8WefHF85SLm1yzexe5\n", - "fJ7Vep3r77rrp30E33QoikKmu5tqq0X2B0p6N+zdy9+VSlyoVEg0m7R8n949e3jn7be/6vvZfJ7v\n", - "VSqsrK1td5Hl8xQKBc7Pz+NoGn2KQiwUwvN9IskEuXaDprFCx/ARbI18zKfeatLrOwwmCpiqj+c4\n", - "NEQVSe6i4ZQICDW6RZv67DpRZTem2EETBDzBxxOT6J6AhkeeIH0EWWeBDjEsDDIU6Q7IUNEQxBAh\n", - "KY4ixRFDSeq1Ks32FkG/Q1wIIoYztEyBcDhJd7wHVZHQtRZd/X2Mjk6S6LVoF5eQnS3kgIiw6hLT\n", - "dZZrNTYMg7VKhYn+ftqCwMrKCrZtk8vlcF2Xkydn6Ol5rT/XEIuLz1Ov19/OjvwUOHIE9uyB1/hh\n", - "viHYswe+9a03fty3An6W3jQ9wCPANUDU933vtcc4jsPW1haSJNHV1fVDC9LQUB/PPjsHjLzq806n\n", - "zOjoDT94Lu6++05uvPEACwsLuG6Fa655H7KsMDbWYHZ2mUAgSjqdo902cByN0dG7WFkJ8kd/9ACt\n", - "1jrZbA+12gkEIQWYRCIWe/bseVVN9ZOf/DX++q+fQFXXaLcdEpkgIafD2ECCRCSCCzyzsICoaeCo\n", - "zDouTURyuDhUgRA2Pll8bHyKGGi4WMA62wtk2PfpxUHyK7QcH0WDc1NTDKVShOJh4tHt9Hs+lSLV\n", - "3c3Tp1a48+CtCHaNs1NLOF6ORLJAu73O5qZKNOoQVARk2cBvnadfhHggyppWB6NBS5qhqjWJqGVy\n", - "ooJvWQhscm1Y58LURcJiBEOErniK9U6ARqgbVVAoS2X27t2L6/usVyosqCrv+cQn/lGC5Ec/ehtP\n", - "PXWU5eUmXV1pfvM33/0jSweqqnL61CnmZi5im930DfRzzcGDXDx9GickU3E0pgyBnak8teoGolaH\n", - "kMvNd1/H//q7H2BsbAxBELhw4QIbxSIHXuNOvNJokDVNBnuGKPRNMHN5mkHdxZXi5GJJHE0gpOts\n", - "tNv4nsdW6QJ5y6KFh4NHBxsPDxGBEC2SeCgImEg0bJMoHhuOg+X7qKZJJmJgm03KJYV0bw+yX4FW\n", - "kbQ3xw5BRcNCJYbrORTpQ7Ez4KmkgiEM22euWmXnjTcix+MkgkHCzSZDO3Zw/NISIxO3MDg4Sa1W\n", - "pK42UMubONVlasVN2tEo+++7jz1XdslvNbzjnns4/OCD7AKyiQSqrjNbqfDb/+E/MDI+jqqqZDKZ\n", - "17V1qJbLzE1P02sYDORyWMvLXNA0WskkWr2Oo6qsaxoVzyNbKHBvt8OT67P4io8iilhOhQmliuxB\n", - "MhzFa63Q9DwEL0rNdXB8HcsvE45KNDyPiBiiaTrYfpGUt05KEPAwKVMjSoEECilC1GgRZ4UubLr0\n", - "BDHPp6NY6M4yTb0H1exD8QxCSOC5IJhonSrhaATFc3Ask81WE9ePUim2aYRtdqa7ueX9n+DYsWMY\n", - "Z8+Si0YpaRqS7+OsrLCytEQzHmfN85hbWmL/vn0EMxnufP/7cV3/Klfr+xAEAUF4ZcP1Nn4yvNEt\n", - "vT+IvXvhv/23N2fsnzV+lpmRGvAu4Bs/6oA/+ZP/j05HAlxyuSAf+cj7XzXhjI+PMzx8jOXl83R1\n", - "jSIIIltbi/T0iK+7gCWTSfbv388992zy8ssXGRjYze7du4hE5jl16ikGBoK026u8733/Cl1XOXHi\n", - "OI6TZGNDRhQXOXBgP319wwSDYaLRBPX6WUZGXgmEDh26mVqtwbFjs0AGTRNZv7zI7uHdzKysUFtY\n", - "YCIW52zZIBIK4ugGZVekjEmSOhksEohEkVBw6cLhJFBCph8FG1Ax2CtAyDeZo0lCSNDsdFiVRQ6O\n", - "phjufkXKfcfoKC+ueiy22zQ1lQougUw/gUAWXV+gWrqAKG6RU3IszD9DXqvRCCSpuBpGZ40UKqrm\n", - "YDvLiITRHBlZbDCqNIk4Mnlg1bPQFZ+2pTPRdw2JcJaFSoBQIcnE+9/PhU6H3NAQH3znOxkaGvpH\n", - "b4rrrruW6667Ftd1fyxhdWtri69+5jMkdJ3hgMmll7/L8uwQe2+8EUVRSIc93n3DJOrlixyfP0M8\n", - "GCSSiBPsH4Bqlc//5V/SMUy2mh7dvaMcXWqiyzrv3jmOLIq4nsfFYpGJfB4hJFAtFgmbPuFwEsvU\n", - "KLa2COAQtnxmGi3CrksCARAx8HAQ6UNmiRVidGPhEyaKgoBLHYiwisqA7yMBIwh4epukr1H1LlLZ\n", - "KJMJSQTlGhOiRm8gRqvZ5jI+YVKEWcf02gQkhYZj0lZVAmWF0sUGoZCJHIsR7O/H6e8nJOTZf+O2\n", - "EuvMiSe4dWASo3uYhZWTpEZHkQWBkZ07CbzGu+SfE77vUy6XAcjn86/aeExOTiJ88pM8/8QTnFtZ\n", - "IZJIcOMHP8gNN92EIAh4nve6Cr6apvGFP/9zRkQRyzS5cOkSYiRCdmCAkYMHea7VYrZWo0uSKIRC\n", - "bK2uU9R1cuEAw4MuttmhVWowkYix0GhxrjrDgNMhTZMSYVp+AAEXwYmzZvRT8VZo6yZRKULKqzLq\n", - "K0QR6Edgg00W0AmSwMYhSZNePFJIdDsCniSTkgO4gs954wKGHCEZTGJaTRA1Or6DYrcRwi4dCy43\n", - "DJYlGaml4XlrDAdMetoBohsb1OfmOLhrF8FAgKOPPophmtwcjVIyDMr1OoVAgHilQsp16fV9Hnvo\n", - "IfL5PqrVDXK5VwxDVbVBIiG9KR5Vv8g4fBg+//k3Z+zJye1OHdOE1zSN/txDeKNluH/qP0AQngbu\n", - "em1mRBAE/9OffopodDs1W69v4boLfOpTv/0qcyfDMHjppaMcPz6F53lcf/0uDh06+GO9Zmzb5okn\n", - "nuLlly8CARTF4a67bqJY3OSzn30W0/RZXl6gp+cd9PVN0G7X0bQlyuU5CoUs6XSOnh6J++//MHv2\n", - "7P6h8efn53niiadZWSkRDodQUDnz3HMMuy5zi0WaJZ+0JG/rWPgGDnF05jiIhwaIQBQwgMuEqJBg\n", - "DIUwIjoqORoEgWUhxJbSRTqRZ0tocP/73slt111LOBzGcV2en5tjwQgzOfkejhw5Squ1PWmbpo7v\n", - "X6YXk14ZphsrnD63wKAbREYggEmEBgEcFpFQ5R7yrknS7zAQkEiFFGwB1l2TGV8kNXIdttKD1QYB\n", - "kBMG/+d//9+4++67f9p74SeWhf/iAw8Q29qiP5/HsCweO3aO6ZU2Gx2BXMBmZ3+UXV1JXnz6adRi\n", - "kUXXZe+ePYyOjdFeXaXYVtGjk4RC/aiiQnagj2e/80WuzXfY152j4XkUdR2xXKYvm2VheYtW3SEg\n", - "S6hWFSUcwDc1Bn2RVU3H8R10oImHgYhJEB2ZFiDQS4AM3Yg4NBHZII1GCIt1fDJAAWgDJtsZsGkE\n", - "EoEw6XCcmCmgyBKWYbPpqNQIY6KgBUcRPI+Gs0osPkx39yCC66JEFMb3JvmLv/gjAoEAf/zHf0Wh\n", - "cJBGo8TykW8wGk9jWSbxuM5tt91Cu9NhxvP4nd///Z/qer1REASBv/r0pzGrVQQgkM3ySx/+8BUB\n", - "s1fDcRwkSUIQBFRV5Xvfe5bTp2fwPJ+9e8e4557br5YUvvaVr/C9P/sz7hkevhq0zCwtsdHpMG3b\n", - "xF2XUVEkGY2yvLKO68tctC1S+T5unjiAIjcptitcOnMGwbZRVJUxBCQEjuIjEEZCwaOXtgBLvoCF\n", - "QkLw2CGYpDwXjxoZNJAUTrgaJiAjE0JAQGAXEhEEPFx8WQIlzAVdZYY8spjD82oEadNNh4zgYMsi\n", - "mhChToFg7np8R0DR1xjN1Ll9zxB3v//9fOvJJxHrdbr6+1mbmaGyvEzBdVlptwnKMqlQCC0cploo\n", - "8Huf+ARrlQryrl1MTRdx3QKJRA5Na+A4G3ziE+9900TQfprn/ecFS0tw8CBsbr557be7d8NDD23r\n", - "jvy84co1f92a+1uaM/L9QAQgne5iebnI7Ows+/btu/p5KBTizjtv5847b3+9IV4XiqLwvvfdy7ve\n", - "dRuappFIJGg0GjzwwNfQtDzhcARJClCpuDjOLKlUBsfxiEYHcZwy6XQUSfKp1xv4vs/6+jrtdptk\n", - "Msn581P86Z/+HbquMDw8zvBwPx2zio3I+vIqVsNFcUUW9ToBQEbAIEgHGRuLPOABKlAnSIgEEhJR\n", - "fGIIBImi0kHDRZCDhKMyjrdFJupzeWWZucsz9A8NkRod5cb77mOipfGZBz7D7Nnz9IW7cR2L+foy\n", - "oihSsjq80CkTdAyi+EhIdCOSxSYBuEAJlw2nRF4KIHgWirhdX3ckhVokQG8yT9eeWzh0x4fpdDps\n", - "bS0wPAzvete73pib4HWgqirlpSUmryxWoUCAX3nH9dy8q86ff/3r7MkNYpXqPHlyik6zxTWpLD2K\n", - "SAQ4/eKL3D05yYvzJfpGc3Snc1RbTXBcbrzzA5x86UtEukUmhgZYW1/Hr1QIOQ59ERFaNbyOQdH3\n", - "6I4kkYGnVI0cIh0gjUcXChI5bCRqGLQwcVlEpk0HnSgOI3jkAQUZBRuD7QB0kO0HMoaEhguWieAB\n", - "UhjXHIqDRgAAIABJREFUaKF4MgoCQcGh4Wu45iUUySEnhkl5ZWRd4fprb0UQRObXVvn61x8mIoDd\n", - "WOaly/O0OxL1i+doKHEEocOtt+67qjXh2fabdr2+j06nw3PPvcjx41P4/vbG4bbbtnkKg7ZN/oq1\n", - "aaXZ5OG//Vv+9ac+9UOt37K8PWXZts3f/u2XqFQi9PS8A0EQuHRpieXlL/G7v/ubhMNhpk+eJBmN\n", - "Xs2yaJpGbbPIesumJIcIpbqZ6ZRJt7fwUfA8l6QkYmZ6OKU1qJVX6XQqNJwovtFkHyJtPDbxcZEY\n", - "J4yBzCYiSZL0oLGIgeVvofodTFzCbFs32K7FfkBHRieAT4ctAERkwMOj4gikfYkAIiG2kD2bCHHi\n", - "9LMd1qyDYFF2exgZvRbZ92nVavSEorQ7Ooubm9i2zejICGc3Ngg3m0SjUZxMBq/RIBQOMxQM4gPR\n", - "UIhmp8O5y5cZ7u9Hdxx+7/f+FSdPnmF5eZPJyQw33viRH5Lbfxs/HocPw733vrk6IHv2bJNYfx6D\n", - "kR+Ht3Qw8u1v/9XVn3fsuJ5oNEmr1b76mWmaTE9Ps7CwRjIZY9++3eRyudcb6nURDoevZlleeOEY\n", - "udxeisUSnuciigrRaBeNxjKGUSESydLb200kkuaGG+7GcWy+/e1nOXHiPJWKiyhGmZ4+xcrKBsnk\n", - "zfT1DVGpbDA//xhDQ4O8fHKGdydiWKJFy66TwcfDZRkfSCMTYAMLHTAJYxDCQmIdhyQJ6rRx8Whj\n", - "YwKKEMCLFxiMTrLWbhOJw6/dcw+WbXNsfp7YwABPPv08jz12grXFFo7ms2GexHdrBHBI4RO6sisP\n", - "ILAMWLiM4qKwvTjWAQXI4pCIpGh0LOpygHXfoybBfe97HwSDmF0ZVlePIIpw003j3Hvvu34kN8R1\n", - "Xaampjh16tK2o+j+nezZs+fqIvOT4PXIrIIg0JVOo5suWlNG9mNkwh6CGWS1VcePGAyKItW6xsNT\n", - "WyzWJdRVlUZnmfG+Lk6fu0Aw2Y8fGGGq5LOolunOh5BzOWZWVhgOh6kgsGLbKIJA3bKwPJ8SISqE\n", - "8ZHo0KELBQcVD5MgkEOmSYAUHTJY6Fi0kRDwUfAZAFaAEBADLAB8OkANl6zjojsNBgIyuutTRkD2\n", - "RTooZFAZdAUiYoooAqXaZV54YYmh/p2U2zWe/twCH33ve3jXQB+fe/GrnJ6tEiREOmQSicY4dmyG\n", - "2UsXERJxdn3gA1iW9aaVamzb5rOf/TIbGzLd3TcgCCIvv7zA7OyXgG2O0/eRSybJtFpMXbjALYcO\n", - "ve54ly9fZmvLZ2joFRXknp4xVlY6nD9/gQMH9hOUZdxcjk1VpScWY35pibImo4kR4ukxUqEcltLN\n", - "zOrz3JBI0pPrRlSbTC9ewHFMzI5O0w5gB7qwPIdLuJhEcUkQwuUiOnl8fIJ4fpAwHRRsXHR8LApX\n", - "rqvOdsawCQi4SHTw2PaVmsejlwAGIg4+bVdjAw+BNApZfOJUMRExsP0YEbdKDJXV5YvcNnEt1USc\n", - "lOMgWlHKpQWajQY7h4Z46cIFyqKI2OmwoGnETZPRbBZUFZPtzc6u3l6WlpdJpFIMDwyQyWS45543\n", - "bxPxLwGHD8NHP/rmnuP74me/aHirBCOvm7a5777fedX75eXjdHdvE1M1TePBB7/MxoZLNFrANNd5\n", - "+unTfPzj72Hnzp2vN9yPxdLSBv39k3hekDNnpjGMdQQhh64bhMM2uVwfpdIFEgmd5557jEIhx6VL\n", - "87Rau9i16yZKpS2q1RzNpkUgUKdUCjIzfY52e4OpqRl0NcERu8iQbzPiS/jIaHgMEGSVTXbioyEx\n", - "S4gcSTx8NpFo041ECx0JiyZ9iIBP03fZsgzaXotYOs9E/wDTK5tMDnSzsNzg60cepFR1cK0xFDuD\n", - "7izQRZlBXOJsT0YuEAQUfHrY7taZArJXfqexTQ3eEHy6AmHWfCiGgwgC3HX7IZLZLJk9e/jQRz+K\n", - "ZVlIkvRjFzPP8/jqV7/JmTNl0ult/siXv3yM8+cv87GP/eo/eo08z2N5eXnbayQQYGF9nbH+flzX\n", - "xTAMFre28OM9mIEwflMnKMsk4gm2yiqbukbKdChZBcb9QWLhCp4dYGGpzcb6OoYSIWrbiIbK/rHr\n", - "8XyPIy99k515gRsnJvjKqQsImkM/IQzXpdVUiUhhdot5HM+hik2DND5lJrDIINBCYQ2LawgioaAQ\n", - "JkcLHyjiM45OHoEKPpuABDjAIh5Btks3OiYNoGZ51FFwKKATw8QlSg2fJppXR9BaDEoBJM8lpbfR\n", - "agsI2SGy8TgL8/PIjQ539AxSDKfYWl8gsrmGYqmsizZeKoruOPiWxb/+d//uTQlIZmdnWVuzGR5+\n", - "Jas5MLCT5eUzr3t8PBikUan8yPGmp+corm/QLleJprvo7Z8gGAwTiWRZXS1y8KBC18AAQUliamaG\n", - "Uq3G6WIVlRTtcI7J/p3UNzZIiRE8L4GgKNgInFyfZ4fn4lkGNT9LkgiOvo6AS4AAOgHq6PhINBCp\n", - "oRFFJUwUnw4KJcax2Qmk2Q5A1oAutgP8DBISLuBjIzBNHJ0gUSQ8dOp4BPEQUXBJEKCbCAJVpulC\n", - "Je+6WBjo7iZnF3V2DN7AZkWlo5cY8Q2+8tnP4oWitLp7uPnD7+Pi0aMIsszW4iLdokjdtlFlmXwq\n", - "xXAmwzOlEvVQiF++7ro37mL/C4Vpbrf0Pvjgm3uePXvggQfe3HP8LPCz7KaRgceAa4HHBUH4L77v\n", - "H/vBYzY35ykUhvA8l83NWYaGIlcJoy++eJRiUXmVtbiu9/G1rz3Bf/pPoz/1hJrLpVhdbTE5uYNC\n", - "ocDRow7Ly3NEIhGy2SSzs8/iuk1Cof1cuLBMs3mcen2VVstnaamFqtqsrNRx3QCN2jkUf556u4Hr\n", - "FPC9CIJfoOI0KEgqVQQcZGwUfDp0YeDhUUJhk24abJdvWkSwSNPCI0udnJBClwzCgkBIUBiIZtiQ\n", - "PW7efwCwWS/P8/ixM1xYNCg1BHyvC4FNXC4yQp0DeCSBBNuBxgwQYXvCDAMttgMR8crnw8AsoPs+\n", - "y55Kf083ZNNcd+P1TO6/ll0HDrB7924kSXoVj+dHYXFxkbNni4yMHLya3UinC1y8eIy5ubkf+13D\n", - "MPib//k/KV28SCEcxnccHjh2jKzvE3BdpFCIWjhMJrcHP9vLSuMEwXYNJRhkPRxG910ulDQMMUPJ\n", - "dckGI5TVy0QDI6xVVJSojW2c4vodA/i+ycWl81TaGi+WS8yvl9BbGvs8jxywIHgUfAHVjdPBI4hA\n", - "DhmVGiY55nFZoUMCjwQCIYJsLyEi4JADBGx8fIoIyMDmlVcQ2AWkEGjgUyBAAJ8VRNIUWCOIRZw4\n", - "m2SRCRFGoE3MDyD7CmkEVraWGZeh1Wzy1W88RnV1mVq1RSAYYnWrSiKUp+KV6FLixMMC16TDREyT\n", - "C488wrl3vIMbbrzxp3p2fhKsrGwQCv0wETISef1MZt0wuK6//+r7TqfD/Pw8lmXheR7HnziMML9B\n", - "KjtIa32OE5dPce2tH8AwWuRy2+W7W++9l4f/+q+ZHB/HcRy+e3kDU+8iFM5SKRYptlqsGgYCQcqu\n", - "yom1BhHLpFcUWPMVXCJ4tCkg00HEQ2EAjQQuAj5JRDbxSLJFgzJbQDc243h0s/1chdgOSorA8Dbl\n", - "GRHwMPBwiREhTS9zFEmhMEgWkSYCCZrU2EQGJAoYJFCQcBHxiZGi0+lwZOYoCAFkymiGhNTQMIMO\n", - "flMg//I6+/ffzAd+4zf4sz/8Q1ZrNaK5HL2xGEng2MYG+QMH+PX77/+hctjb+Olx5Ajs2vXGufT+\n", - "KLydGXmD4fv/P3vvGiTZXZ55/s795Ml71v1eXVVdfVXrjiQkBEJIICGQYgBBLBh7jYNl7PnAbDDr\n", - "nYmYtSO8M4aYWBze8G54wONw2NwMY7BZtUCiJYSEpL6p1Wr1vaq7quuelVl5P5nn/t8PJyUuuiAx\n", - "tADB0x+6uiozT3X+85zz/N/3eZ5XBMCrKhz37DE5ceIJVFXhlluu4O1v/1Ek+DPPnGZg4CfZfCKR\n", - "olw2WV1d/QmXy2vBLbdczxe+8G1SqRz5fI4777yPM2cOUq/PUShELC9vsmPH+7hw4VkUZYZsdjfl\n", - "8mEWFyMymXmiKE+zWYL2BsKbpyMZ+FyLShoZFx2JFP1EYYOQNkkkXNp0iCd2ngICNJLkcFHpEKIj\n", - "8KjToEUvLcCkoCi0Ig1PT5K3dJxGkefOHefC+iKRd4FSS0ZmpNtssZBx0OgwSoRJXBqGuCXQB2wR\n", - "k486ce7iIvEuzgROA88DhZ07+f0//mP27t3Ljp07f65JugBzcwuY5kst2pY1yLlzF1/xee12mz//\n", - "kz+h8uST7MnlqHY6rBWLXG1ZHF5fZ9fQEB1d55Y9e3jg0DkMfYK9d36MQz84QFZRuXI6RxDOMbda\n", - "YXb2JiobG4hqichfYqk5TyAEpquSsfKsb0V8/+ADJH2dnghaUZKFss80LgVFw4sCBCEJJBwkQBA3\n", - "pAQGKQymUHBpobDFBnk2iQCfAiEVPDwcBH73vXYRVInFypPEJX0FKCKRQiOQdPpEghouOhZ5ynRo\n", - "kiNExkEQogIJPOywhiNZpGWFlusS1XSqzZBqaROn2aHRAF8xsZ0qgxgM60lU3WYklWKj3aZgGBx+\n", - "/PHLQkZyuTSet/aS77tunAc0v7bG5EDsBFssFvHyeXbt3g3EgvAHvvQl0p6HKgQPHz7MVQMDWAUL\n", - "RZaZzA9gNSqcfOYA49sHufLKuwGwWy2qnQ6P/uAJypUaZRdqTYspEbDp28iRTLUDodLk+jtu58KD\n", - "D1KQIhIRRFis0yAe0GDRQUJDJiQki0MZjQgVGY9LCHRCWjjMEicqbxG3ODUgB6yjUAF6iGcQNdCp\n", - "4SJo4uKSISKPgSDER0YnJI1GkVVU0hQIkIgISJMniUNEHxorQkWIJjo72cLGkKrkwxC16XDw0f0o\n", - "yr0UV+axazXK5TJTqRSSEFTzeWbuvpuP/+EfvuwU7mq1Sq1WI5vNUrgcgRlvQuzfD3ffffmPs20b\n", - "bG1BowFvJg75q9KmeVl88IPv5wMfEK+oEXg5JXYcTPb6p49u27aN++9/O/v3P065rBFFHvv29fLB\n", - "D/4Zp0+f5tIlhcXFZ+l0UhiGArQwDB0hCpTLK6SSNrnOWXKBhoKFJ9qUmadCC0tWMYWLh0kLmSEC\n", - "ehB4xBWK54AhZFQS1FFRSFPCZYuAtF5ABHU8YREpJqUooCM0NEZZW7MpuxKXtk7Qx0VMPPbQi0mZ\n", - "JiFFNpDpAUwU2rzwbvnEpOSFtkAbKAGzwCaxVgTi26yeK/A3f//3XP8LuEGZpk4Yei/5fhB4JBIv\n", - "vSC+gMcOHGDj2We5dXSUpK6zNT/PsBA0ymX2ZDLsGh7mTKnGNx89TSbXz8Gnvk+95XDz7e9j/txJ\n", - "zl06zA3XjKKOjtHTt48H//EsbvEUEyJkJpKxRZnQl7lQ3MJdvcSUKJAghSJLSGqORW+FCiFRCJYs\n", - "IaIID0GEh4WKR0SESoSCS4SNDySQGKROhRQRGjISFhIhZVrYxOQv2/07JPa6K8TE0EbCRMIUIdBG\n", - "IsKnRQEPFZMMCSp4jNDBIyaUPgEl12ZKTeIhEwpB6dxRsh2bPk3hhN8iJbI4UYQfBdT8KlcPZdBk\n", - "mSgIUIUgfI3uhvX1dZ49fJhKscjQxARXX3/9q960du/exUMPHaTZrJJOx24X224Qf/LAuuIKfnj8\n", - "OJIkMX3FFXzkzjsxTRPHcdj/5S9zRSZDNplktVxGqTc5t1IiOzSEqjbpdFLISDQ2Fvmf/uQvyefz\n", - "saPtH/4BZWGNG8avx9qV4wfHnuRY/Rx+SWdCTxBIAkn1cUWDwwcPErougSzjRxFNPBR6sFBRkNEI\n", - "UBEIcgQEQJqLqERkCNFRUFBZoMYGg8RVxgxx/9kGWggUDCpEaERY6KSRUYAa6yg4JDCQ8QjwEQQI\n", - "HBL4hAh8AhL4JEmhABlCIjx0MrgUCLEpsMpIaCKLgKZXwfVaHHr4H5k1fD6yexfBxATHVldZDkMm\n", - "slmuuPHGlxAR3/f5zre/zcVjx0jKMnYUMb5vH++9776XDCD9LX4S+/fD1752+Y8jy3EF5uRJeAVJ\n", - "1a8lfqXJCECn00GWZcyfCqS67ro9PProBSYmfhTUZNt1EgmfkZGRn36Z14Srr76KvXv3UC6XMQyD\n", - "QqFAtVrl0KFjlMtLeF6VdHonfX0pstkRbHuTRqMIWNjlZ9muJIm8i2j4qET00SSiRL+UwySkLoUU\n", - "hcMAsZCtTnzjTwNyd1ckWMVnjBQmDQSm5ZNU0ljaNpTQQfLq6J6C74UUvRo+CXpQEcAEoGMgodCD\n", - "TBaXOk18Emx1f+50j+cQx8rbQBkYIy4lF4ERVDQtSdXKMrzvJpaXN/hFbJZ3797JgQPH8LyJ7hBC\n", - "8H0P399gz563vexzgiDg7NGjFJLJF/M/2q0W29JpyuUyimWxUKmx1siS0wtsH9sB2gKdzipPPjnH\n", - "fffdwTv/j//M7OwsFy9e5DOf+Rwby6e4QZWIAoEXlhiQ2oSd2MacIoNJIpYTShIhEj0kWEJmg4Cp\n", - "SKaFIAtYNHBQAJkqClvoFFgiD+jUqOLQokMLhRTlbhUswkZiCsF09/9oAvPEN64y4CORRKB1i/ot\n", - "wEBBpkQbjQygd6szm4S0gfPEu3ArDKk6Do6SZK5RZzDw6EiCtqLgSzIiWkTDohjWGUtbjGRHqXQ6\n", - "ZLJZzrou77nllp9egpfg3LlzfOfv/54RXUePIs6eOcOJp57iI5/61MsGj0GcUPx7v3cfX/vafpaW\n", - "JCRJIpEI+J3feS9/9mf/lvd94AOE990H8BP5MgsLC1ieRzaZpO047H/6BOtV2JMco91Uyfcm6e83\n", - "2L17B7lm88WK6KHHHiMfBFR9g3whrpsLx2EnDgnFRRJNMrpJjyK46AZcXFmBKKLoeV13kyBBng2q\n", - "9KGioSARItDZBCIkYBgVBZc2Gh4KA9SpIeOgEp9nAE0kUqjYBPShkkXGxmcdlzQaMi4hAQoBJoIm\n", - "0KCERg4PDQXBJjYTuGjkcIEUEUXipp+PQ5Zl9mKSwERRLPywzoXQw9m4RN/0OKnu9fOdMzOcrVTI\n", - "9/Vx/vhx3nHbbT+xTo8/+iilZ57h5vFxZFlGCMHJEyd4JJHg7ve//2d+Nn5TMTcHrdYvdkrvq+EF\n", - "R81vycgbhP/2377MwsImkiTYvXuSu+++/UUm/9a33sDc3CUWF5/BNHvwvDaKssXv/M49Lztp0nEc\n", - "lpeXkWWZsbGxV9SUaJr24gW10WjwhS98hWo1RTK5Hc/bYmOjhqIsY1k6mYyGqlrUakvoYZmkrJLR\n", - "LVQvwJFtFsMtRogYoDeOdhdtMvgsE9/4LeJWSQrIoFInQMEmYpHN7sVPcvJIWpIOBS6EK0hODeFq\n", - "NHGoI5Apo+OTJyIJtKiRJEkbFwufIi1CTFxi/UeWmHAUiV0cCrGDYxFoYtC//V/hahnswGVkeIh7\n", - "772Lo0ef5aab1l/xRvNa0d/fz733vo1vf/sJoih2T8hyjfe//yaGh4dfds1OnTrF4tISPdksq+Uy\n", - "k/k8UvciKRSFShAQtQRZs5+2GyDLMpnsIHe/5z2srBzkxhv3MTIyEg+Dm5wkK2/RmyjTsjtkQo+J\n", - "bvtqFcgi8AlR8BHI+CKgFTi0u/6IZUIahMjEVYw4sL9ICZU1chgI+lFJoCIRkKWJDUhkSVHHoMM5\n", - "IvrRkBHUAfBpEleq6sQi4jaCGQRbQIs4pbcfWMKnjU+BCI+QMTxEd+2SxOJImZCTXkBHS2MqKdJh\n", - "g0TkMa7KJA2D+aCDqTtshirrqsrRchlXlvEMg9133cUNN9zwqmtYqVT4wv/1eaxyhdNbJbKaimUY\n", - "bLou/6Cq/G//8T++4nMnJib4zGf+F9bX1xFCMDQ09BMuqpcLuQuC4MWL1NmlVfxwkGQ+oNNpoeoJ\n", - "enomKJUuMre6yvC11774GuX1dQpISFK8m4+EoNWp0OM5ZGWDjAiIgoj1loMLXDs8zOT4OIePHmXJ\n", - "cQgI2aRNSJ4OTfoRBETUaeMjoyBIoNEmIkSihoNMCw+DIzhMEWfGlIE2MhIqGXzSSOjICEIG8Kng\n", - "IRMLxWOCCwNIzOOzSJEOJi4VEoSsEmLj4KLiIfDJdVNPSvQjsFAJhUfoRyCH9CNYDnw0Q8dutei4\n", - "LoqiENbrPP344/iFAlYqxa3vfjfj4+P4vs+Jp5/mxu75AnEFetfoKE8dOcJtd9zxmrRhv4l48MG4\n", - "RfNzFOV/LrwZdSO/0mSkWEwzNrYDISLOn1+kWPw6f/RHv4emaSQSCf7gDz7K/Pw8i4srZDIj7Nnz\n", - "/pftf5448Tzf+tYj+H4KSRIYRocPf/guCoUC5XKZVCrF8PDwS9o7R44co9XKMTExQ7vt8sgjh6lW\n", - "t6hUxiiVygwPpxCijedFyF6afCQwZZVA2CTCDhoNksh40SYSHgot+gmxidsjk8SViTpqV1MCG7gM\n", - "kMAkYgtwXR/Jq1BrnyCjGhTdWDuikCRFgz7krqgtJAu4uNQxSZBDISKkRi9VNGI9wipxuJYDZJAI\n", - "SKJYY9hhAi2psm3bPvr6ZgGo1YosLi6RTObY2Nj4HyYjANdffy2zszMsLi4ihGBycpLcj9k6X8Da\n", - "2hrf/Lu/I2HbpMplitUqZc/DjSKUVIrn1tcpJhKM9fSw3AjwohAjlaLcatG/bZKFhVMcPXqcTscn\n", - "m32cqakChiZx7swZVEUQhh2yxOJcNxKkgCwRy4Rda67CKhHQh4egg8kK6+i0MIHB7to5QD8BLg1C\n", - "BBIDOFgolMgRkURmkyp9SKSQsRHE8sUkFSI6xETE72aVjKPQwOUSIRZxCy1CIkKnQ4okbTxCAlI4\n", - "RMg0aREyjkYaiRYyfWQoqRp54dMv6yhCJ/BtZE1lMpGmmEsxODhIcniYhusyNDrKHffcw53vfver\n", - "tjiLxSKf//zfsHhqHam+xWjgYemCmalRtqdS7P/ud1n42MdeVa+lKAqjPyZM/VkYHR3lgBAEYcji\n", - "RpWMNUZ6vIdnnvseecWns3yelY01gmqRa4xR5v/Pv+Bd73or/SMjdCoVosgBwPNc7PoW+UggCY9a\n", - "4OF7cTXKlyQuVipMTE9jGwaO41DrNs9k+igxSI0SEQ4eLUZQaOJRxcXHAspYlJnBwMREpU0Tn3ks\n", - "EvSjk6BJkUEkGiRooQEuJgIbh13EomWPuFLaQXTthYK9qARILGFQx6BMB4k8OhYBPjBPhgAJQYsW\n", - "CgZC+EihIIo8bCVgdWWFXLNJUlWpNZucrdfZsCxoNPji5z7H3/3VX3Hfxz/One97H1IQoP/UZk5V\n", - "FFTizcFvycjLY/9++NSn3rjjvRln1PxKk5EXooklSWFoaJpLl44xNzfH7q6wTVVVdu7c+apW3mKx\n", - "yNe//ij9/ddimvHk12azyn/4D59nfHwcyxogitpMTmb5yEfuI51Ov/jc8+eXUBSTAwe+TbFYpd1O\n", - "kc324DhFBgZS6HqLmRkJWR7hqYfPUYsE42Ya33cIJBCSjiWHdJQqsh8QiQAd6IUXg648VFyyNAjJ\n", - "YiLjskqbEhoeIIlJEqxSiNYwQ5eACMEwCRrsQMMkQQOTGh0ahEiksEiSQKJKSJJeQEanThqFZjfc\n", - "zMVinTzb+qbQE1lMZZBsIcvS0kl6eqaQZRXLyrKxUWZ62vqF9ouz2SxXvkpiTxiG/MtXvsKMqtI3\n", - "McG2XI6jjz+OWi5Ttixk0+RiGLJndpbBRILnn3qGcrvK9Mgo/Tt3omg+zz67QCazix073s7ayjm+\n", - "9PkvYtWXGKhucaHToRxFbANSioIjBKvEbY4AjyIbBFjIzBIi4+KR6zZHmsyj4qITawIqxHqPEh4+\n", - "LVQSCDxUmuiohARotMgjAxK9wAoBaWwietHI4FDHxWOUYUxk0qwiCHGR2EYOlSRbBJxHp8wgMmUm\n", - "MGl3c0sUwJI0DFlhPexgSXnAJyVrNIRHghBZSGh+m3YoOOG0+d//+I/5xCc/+brWbf/+R9G0SULl\n", - "GP1CMJztw/NdllbWmd0+xYiuc/LYsdctHn815PN5rrn9dg49/DCu71BrNVivlqhq/UTWKKdX1mi3\n", - "Fd5z8ztYW3PZ3Kzw0EP/D9dfP0becxBKm43iIrV6GzcMaSkKVuiiASPE2o6UEJi+z9d++BQDvoRP\n", - "EphARyEhbdAS8bnYpkyKEUIMLCq4dGgT0McGu5Ax6RBi00FgoaMyTo5kNyHIBPoJaaLRg4mERxmV\n", - "DRRCEsTtugTxpsEGBjEYJImGwMDnIgpbpIhYJ0BlGzY9uJwljQO08MnioCCIpDR1PUENFQMotlqM\n", - "ZLMs1uvM2TapTodp10VSFGqNBs9+5Sv4lQqOLFNrtcj9mEi91ekgJRK/ddy8AppNePpp+Kd/euOO\n", - "+UJlRIg3rhpzufErTUZ+GqqaYXOzTJeLvCacOHEKRRl8kYgArK2VWVszmZoaZmxsLwCrq/N861sP\n", - "ct99d3HkyDHm5pZ4/vlTnDy5QW/vLXhem1zuGjQtTal0mr17p7nqqqvZ2DjBxz52G3+VUzj43/+F\n", - "cqOKJSVoCxVbNhhQZXQridwqkvIDRogFpC+EXIXIbBHiYbJChwUi6hhINFBRCXiclAhIdLUBCTJY\n", - "uCTxMNG7YjiJqDvrRCdCw6eDYBONNFkcQKLBIhJNegkTY6SzKQYGbmD79h4GB/t47rlL6HqaSmWB\n", - "RmOdXG6MIPDQdRfLkpienn7pm3uZsL6+DrXai4mc2WyWG9/5Ts7PzXGwWOQDn/gEn7nuOqIoolKp\n", - "cNsnXf75nx9DkobI54d46KF/AgbZt2+WMPSYO/w9RhyVph2xra+P4soKiSjiEpAPQxzialEEJPBx\n", - "8GmRxOwGl+0gvmlVMXCw8HB5nriylSG25HYAQRKTBB4BESYBNh4CBRmBwOvueHMobKCQR0HFokYb\n", - "CYUUEQbJrg7IZbV7mzKQyaDTg0ubHsrkkLGR0IhIMorGpqigiwQtEgQiwA4VlgKXfmHRFG1MQvxw\n", - "ykkqAAAgAElEQVRQwtUttg+PsnbiBOfPn2d2dvY1rYnjOFy4sM74+K2cSmUJ1xcA0DWDlt1gpVxm\n", - "Yts2GtXqz3il14+3v/OdjIyP8/ADD/Dst56kKXrYc8W7CcOISvU8eXOYp58+zPbt72ZgYA+2XWd5\n", - "eZW51jxmu0S7tMWFlXVsfJIEeN212yCuFOYAzfUxkWgSIdFLAZMqgi2hkiVCId5AWJzHJ42KisoG\n", - "SST6kH7MdithAsdJomEhAQYym1iEaCiYqEQ4qPiYgEoViRoBFnTnT8WV02TX/+YREBKRRKOGBIRM\n", - "ojEmBTSEwh5sSig4gIIGqGyIDiV1lP5sBj9TZ7PTYaHVYrHd5kpZRgDbdZ20aXLBcVgvFsm029DX\n", - "x8lSiVnfpyebpdpscq5S4db773/VWVG/yXjwQbj5ZvixfexlR9d4RrEIb5aQ3F8rMhIELXp6Xt8o\n", - "63q9hWH8qLTYatU5ePAJwlCmVvtRqNLQ0DTPPfcw8/NfQIgh8vkRXHedixdPYpptfN9BVRP4vkcy\n", - "mcW2BYaRQJZNfN+nZ3gbueFtOEsVHE/BREbGZi6o01uvkok8JOL+/ggggAtI9ACCDi10trCok0Gj\n", - "xAguOm73AhNrAmLbp0AnIkuI2rV1GkCAjEBiHgMZixQGKiYNVGxMamSoKNegaCMk0iWmpvrp6dmG\n", - "71dZWChSLFaJojqOU6dYfIIg2Ee9vsxb3zrCxz/+kTdUSR8EAT+d3+oLgauZCCPF0NgYCxcvcuLg\n", - "QdqNBuOzs3z0o+9lcXGFM2fmMU2Xt7zlevr6+lhePo/WqLPVrOA4Nk1ZJifLlLvvqUcsNOwFnkKi\n", - "RR8qbSwURjC6YVdgEmIiUIlj28Pu77VArPPIo3KWBAYtBlARyKwR0UIwgUSLsDuzRmYcgzUk1kh3\n", - "Q/5dplHx6QBy949ORNS1D8etnB4kSoRdQ6+HikEDlS28mNgYeZSgwarfYCizl2JlHV/yUYVMTkmQ\n", - "tFKcDwN2pnvYlcvxxEMPvWYyoigKsgxRFLL32ndxdOEkGbuODtQ6LfKFKTIDA4xeJtI6MzPDzKc/\n", - "zWbN4cCBTTY3F3HdDlBlYGCMpaUWURSvimlaXDi/SkHVuGHfLkbekuah73yHp+fm6FcUlsJ4ErZK\n", - "fC6WAYGEimAYuZuYalDAwMVhjZAefHoQjOIQ4pAgDqV7FhmFBDIhKhoyPkl0QgQdYoIbIBHQR4kK\n", - "vYTIRCgErBLhdeXuSwT0E+tMikAdmQlMAtRuIy7EYp0EYOAjST6rkkQoQnahYAEryGyikJAK1GSV\n", - "fO9uMlqNG6Z6WFhZoRGG6NUq40DJdXFsG1NV6VMUlsMQ1fcJHYf3feITPP3oo5xZXaV3cJA73/e+\n", - "nytI8jcF3/gGfOhDb+wxJelH1ZHfkpE3ANXqJvl8f3ei5zK5nPeaL54vYGZmnGPHjtDbO8Lx40/z\n", - "2GNPsb4eIURArbaOaabYvftaAJaX1xkbu5IdO+ITb3x8mtHRIouLZ7CskFptHsPIkUxazM9fJJs1\n", - "kaQl1tZGCMNBvPwoCxdqDEgmjiwo+XG6YokiCgZ5PK7sBo/5QAbBHIIVFEBCxiDDFkPEI7sTxBfL\n", - "qPt1D7BMmwZBN79AECLhdjMnIqCBSZY8FjIe4KDj4uHIs2BcQd9gFkVpsW3bJPPz5wCZ/v4pEolL\n", - "rK9v4jh1NjZqTE9n+d3fvZMPfvBfvawg+HJiaGgIR9dpOw6WabKwvs53D1+k2jKwxnby2f/8Vaid\n", - "43dvv4nC4CAbi4s8PDfHhz/1Ke666w4URSYIXvhoCxqdFpFTYVqEKK02sq/TT4bzQBGFfsokgDZJ\n", - "8gxTZp1eAlq4BBi00QCFBhUs2rSJKyJJYpIQEpPMHnwiCpRxkBDU6KNOEwWbJhJpZNLACSS2SJFA\n", - "RkYCJCo0usTHwwU8dBza9BEhoeACDQQSAXlqjCJjIdFEsEhABRstKiELl/60RbN1CilSWUVGk6oI\n", - "LUmvkWREqLj1IhOjozyxsvKaI+A1TePKK2c4ceICo6OzbFx/J81LZ7DCiJGZIUZ37mTTNLnqmmt+\n", - "0R+HFxEEAZubVRRFJ4p8wEVVFaJIQpYtoig+b1aWn6OzegRhynz3/1tlW38Pim0zJQQrYUgoSUhC\n", - "YBKT0YAkLh4RARYqMuAg4eCj45NFoOJgEKAyRApBnQZzdOglwkewQcgAKiqgESLTRqdDlnhgZxON\n", - "IgNssYhBh4CQFhoGJkZXoWIDTRSKxEQnViK5GLgkEXTwmUAgE4EQOAjGEOQRSEgkkTmDQb/RTyj7\n", - "pBIG2STYrkuj2WR4fJzq2hqu6+JJEglFwWm3cTUN3bIIhCCTy8XEb2bmsq3jmwm2Dd/7HvzX//qz\n", - "H/uLxguOmjvueOOPfTnwK01GLGuNpaU5IGLbtj7uu+/+171D37VrFyMjx3jmmQN873tHsKzrSCTW\n", - "UBQZSRrgm998kOefX0DTEqyvn+Gaa+558bm5XB+Fgko6Pc30dIqjRw9SqwmqFR81XOWJteNMjgR8\n", - "rTxPeuhGZLUHzxhk2dFw/QpxmHcehR1k8GiwyhkusYgALFxCitgEpNnGICqCkAYGNmni8LEX0jlL\n", - "xNbcLULarFEmjY6PjkSHFhE+y93kkDWqbJFFQxCyHgsglT50aZ1GY4Xh4VGEEEjSeXx/iPPnnyaK\n", - "hlAUn1yunyCwOXduhcnJiTeciAAYhsFt997Lo//4jwwoCt89fI4gmsDsLbB7z7U8+8QTJJVJFjZK\n", - "9OfzjPb1ERaLHHz8ce67/36uuGKKL/zVl0noBfJD29jymoyGDr7fpomFRg4FGMBllQKL3TkvggI1\n", - "VBwK6GywxTIOU2iYRLRQaGOTZ4EN8sAMEBLHuceEUVDBR8MghSBNgE+DfiTqgIvBGgZt+hFksJHR\n", - "WWEEhwQuBgGbrCMhU8IjS0RIHY8cGoIWMr00GKLebd6ohHgUaJIGDCVkJpXGSCbpVKuUvSplNISs\n", - "Maga5DUTL6iSz/Xh+j5aIvG6ZgK9+923USx+g6WlZ+gdmWUlsKlX5umbmUbbs4eP3H77ywrIf1F4\n", - "/PEnabVkLCtNT0+8YTh16hBra0uEYZFEYh8bG+epn/0O41GEaDaYzEKP73PK87i2v59vb2zQKwQX\n", - "gZ2Ah4KQshRFoxsymGCEFCc4j06OXgwadDCoksKgCfhYJNGpUUPQYIQ2pW6FSgdaeJTJoGDT6uaK\n", - "OMThbj4TuChIZDBokqFFjTVaFDGJ0EkgkeMCbZp4jHYN4VuE9BFfExzgJBGDAiLFwI4EhpCQZBiQ\n", - "YMMvU1Y1pgs2b9s3ywOPHEButTDX1ylHEX4QkNE0ykGALknY6TS53l7qqsrbb731sq3fmxEPPgg3\n", - "3nj5U1dfDldcAQcPvvHHvVz4lSYj/+bf/D61Wg1FUV63eOrSpUscPnycWq3J1NQIzzxzGDAxjA4z\n", - "M0NsbdWo1SrYdi/Vap3+fgnL6uGpp45w5523o+s6up4gn09z8OAPse0xSqU2tdoidJaYyWQYTiYJ\n", - "yzal6jOcOvQsgTVF4F6iz6+TJ8JHZxOJLQxUevAosIBLDykyyGwhqNGhwBYJ2ng0CWkwQUiKH0VJ\n", - "p4Gn4EXR5DoOSRyKyN2RWyYhQ9j047OCoWxgJFM4jk0U7cUwpjHNOtmsRCIxQKVyhsnJ67jzzo/w\n", - "zW8eZGlJx7bb5HJjpNPDOI4NzPOFL/wTg4MDv1BB4mvFviuvpKe3l4f276d5vMLMrusYHR2jXq9j\n", - "Ar2ZIc5cOs0Nu+JK2WChwLH5eQ4fOsTJAwe4bTTJ8uICi08fodbaJBW2CSOBhwVCwiYmEhIgU6CE\n", - "x7TcQ1NWuRjkudR1zZg43ZaIikuOUEqyLjrUaVMiwiIuq0sMMcwEKSI8Ito0yLOChIuKRLur//BJ\n", - "04NNLA9sI+gQISEQ+AjStFlBxsJkkwCbNgputxYmsZsOGtDGp04Lh9iJUU+n2VUoYIUhzUoFQ5IY\n", - "kSRkEVAJPLY6HlM5hchUGZ2d5dTqKte8972vONDwBXiex+HDRzh8+CRhGLFv3yw339yDbXfI569j\n", - "ZmYGTdN+rqDB14MoinjqqeNcddUdHDr0GJXKHMnkIBMT05w+/QCWVWdz8yRbl46zzzKxq1UCv0ml\n", - "YVBp12nj4A70099xqdkttEhwRpZoBhGeFNEUBSw2aRDgEjJMi0Fq1FGQ8NGx6EdCIcQloATYqMgY\n", - "LOORJ2AQOIPBKsPojJJGJkChgQ2sUKCHEstETJCmQRYZFZkk0wTodGhQI8Qkh8s4Jc5gYeMguJLY\n", - "/hsCiizTiCLKqEhKgg0CzAg0IXCiOuu6y+w1V5PtiTh4YZ4dExMkczkKsoyVTnNmbY2W77MURdSD\n", - "AFSVq/ft46p77uGaa6+9rOv4ZsMvo0XzAt5sM2p+qWREkqS/AK4FjgkhPv0yPyeff30aEYAjR57h\n", - "W996EssaxzQHWF7e5Pz5VcbHr2N0NA5J0/VFGo15FKWDJNW55ZY7aLV28sQTR1hdXWNiYoKjR4+z\n", - "uhpQKGisrc1RrbYxgy3emu0no+pU3TpZt8lQSqFf+JxafYZRr8Y0EKHRIoeFgsIlKgh8fAJmWcNm\n", - "HRsJCYMkAo+ITfJErHbbOApxKyckdt1kuv/eAjw0mqRx8HEwCRlDJgmYaGYaWGLXrvexsnKJVquK\n", - "JGm47hDN5hYTE70UCgU+9KF7MQyDf/mXw/T2juD7bZLJOOsjDF0KhSEg4sknn/mlkBGAkZERbrvj\n", - "DhaWYWwsLht3Ojo+IBDIP3YDbHU6aIkET+3fz1tGRjA0jZ2Tkzz22EHWKk3qLR9ZJGh7OglFQw0F\n", - "RVw6aF1JoIQcRSjCpo1PQIYOESl6ULBoxc0uNCEjY5LHp9AN1y8h4VEgQEZHwcCjhwxbpLuR/wqb\n", - "5GihMYqgnz4EASYVCihcwsHAw8NCR0HHZRWNDClKtJglZIyQNaCCQo0UAo02bSZpA+DLMv25HGvL\n", - "y6SJdSwoKm7gIysavgRPV+vo+Sz5gQF233orN/6MxKROp8NnP/sXHD++Tl/fGOPjUzzxxBr9/Qt8\n", - "8pMfe0kQ4eVEEAQ4TkB/f5ZbbrmTxcWzrK4uYBgab3/7Xv7oj+7nG1//Zx756iYEESguWTlPSjKo\n", - "dlzqkccDK2vc3DeGkxtmtbFFfxTREBErnTRDuRnOl1UWog00OuSIyCIhEbKGYJKQPhI4xOe2hss6\n", - "Ah0FH4NLBETIlDHwmcQnS0AHmQCJFC6D+MhkUAGVXkJ8QCKBhsBHoY8Uq7iksdGRSHat4Vb3miCI\n", - "w9g6UUSSuAXXCVNkjAydsEkj7FA1Va69ci837dvDroEBHn3yScaAmmmSSSbZWSiwZ2KC7ywsQDbL\n", - "O++4g3vuuYdt27aRTqfpdDqcPnWKzbU1evr72b137889/uHNjmoVHn4Y/vqvfznH37sXTp+GKIpT\n", - "WX/d8csclHcNkBRC3CpJ0v8rSdJ1Qoijr/acIAg4efIkx4+fA+Caa3a9OKjtBbTbbb785QcwzV0o\n", - "ikU6nSeTKdDTs5Pz508yMrK3GyUPudwkmnaGt73tHQwMTNDbG7C0dJ7z5x+jXp/hzJkz9PfnkOVp\n", - "DEPB6yyh2x4yCltOC88tMZvN4TsNTFUi4TcZJiSFSgufgAYWLUaJcChiYxBQQMOlQNS1fsr4aHhd\n", - "Fb+MYBOHNLGIc42YhMjEYskNEmwxjcc4ERniZAIFlG1I0ga6Ds3mRdbXV2g263Q6HYQ4hKYN0GpV\n", - "WF6us29fH+l0mkwmw/R0hgMH5omiUcLQx3FaJJMyhhHS1zdMuVy7PB+A14jR0VEMw8G2GySTGXK5\n", - "LHoux8LqGe64tg8APwg4XyoxfvPNlA4dwtA0gjDk0acO8/jzp/HbDWzPJo2KLZrUhYaDg0+SIWQi\n", - "bEwqLOGzJYYwmQJ8fEo0SCJwUFEwcMngENJmlgCZkAoSAWlAZ4MO/RgYKFTxWUPHAEJ0Eli4QAKD\n", - "NhI2ETIyCi4ZArYIGcfGQqVFSAKBA2iYdOggABuFIuOMkUVCxqVNkWWykk3Q6dBRVTRNww9Dqo5L\n", - "TrdYl1wUzaQTBQxdcweT2yf43f/13/7MrI9Op8PnPvd/873vrTIwcCXFosPa2jNceeVuikWZU6dO\n", - "c+21l08f8tPQdZ2Rkd4XdWQ7dlzNjh1X47odarVj7Nmzh/ndJ2nunebsD49hiT4agY3nd4gQ2GqS\n", - "AJVnayUmp/cRmCmeq2yQj3ws0aZOld27r2Njc4mVzZPYBGQQpFFIEOLRYYuQqBsKb6NgEFDGx0Cn\n", - "SY4sfd349iQWdfq6Wo4mAhcJCR8fgUJAiI6EjkMNmwAPFxkbjRQNNvDJUMClSZIULk1CDEAlpNEl\n", - "L1UkQuGSihqYgUNbeHRCQW1ujkY+T3Z6migM2dbfz8rWFk4yyXylQtN16SBxz/338z///u+/2Pre\n", - "2tri63/7tyTqdXKmyVnX5eCBA3zoE5/4hWQMvdnw1a/Ce94Dv6zRPZlM3B5aWIA30Ox42fDLrIzc\n", - "ADzc/foAcBPwimQkDEO++tVvcvp0jVxuDBB85StPcfXV83zoQ/chyzK2bfOXf/nXHDmyRjbbA6yQ\n", - "z+vceOM13Hjj7czPf5bV1YPk8zMEgU2tdoqRkRSzs3G1JAh8crkcu3YNEYaCIJimseWxvHQWS0/h\n", - "NOfxQpmtoERSVVF8j4VakYTqoyeTyJqC7kW08Gggk6SFTKo7DLyMTwKBRpIEDgkCfBJIdHARmBgI\n", - "UiSoElJFJk3swGkRE5EWEk3GQZ8k8mLTYOwDWUKSLqCqIe32FqDQbPr4/gBhaAMlPG+ddNpg+/ab\n", - "WFp6iL/5m/+OqlqoapK+vhrnz7dQVYmBgR5M00PTWmxubqEoDgcPHuaKK/aQTCYv00fhlaFpGh/+\n", - "8F186UsPUq32oqomPYMakiSwVYlnlpexJYnr7r6bgaEhNg4dwvE8HnnqKQ499hi5toMu6XSEylIU\n", - "oWKjRDppEgwQssESPVLAHknmhLCpiQCTJglMfBScbqPEQiDhUafEKA5ZVNpELKNjk0CQpUVEgxYJ\n", - "BBERgjY58tSJ2KLZfUwNlwwKw0jkuEQFiWXSRAwQ4uJ3nTOCTWSSaGygskmER4Y0OcpI3WD5BE2S\n", - "NIRHMgg5uLDIqIjIqSqWKdPQU1w7OMlousDBdoMbb7sfzytx9uxZVlZWGRjoZ2Ji4mVbNYcPH2V+\n", - "3qNQ2EcyGU/WDYI+Tpx4luuvv565uUtvKBkBuOuut/PFL/4zQeCRy/Vj23UqlfN84AM3o2kanSDg\n", - "9JmzrDkBs0pAQgjaUUSVEEfuwZBtJLnFJZEjP3wL05MpLi08idw4S1+vQiBqoHWYTGmstTqcI4mM\n", - "SkCDBAEaISHQQMJB70qck7gYZBlCx0TuzpMx0PCooWChENHHFr14bBJRwu9mmXiojKCSRkJjg3UM\n", - "qkzRYZkODSy2k2WVKmkibCICwEGhRYQgj4vEVgQpI4MlZPbIJTZabR45eoLT5YhmQ2J9fZE9fSYD\n", - "hsFCqLJYC3CS0yxekvn857/Ivfe+k3PnLvKNf/gqA60GN161i+GREcYUhY1KhYe+9S1+7w//8A1d\n", - "618H/O3fwn/6T7/c3+EFR81vDBmRJOkWoCKEOC1J0juA64BnhRCP/A8cOwe8MKq1Dux5tQfPz89z\n", - "+vQW27a95UcvkOvnuecOc/31i0xNTfGd7zxCsaiRzQ5QKMQth1qtyPPPn2HPnhne//47kOWI558/\n", - "Qirls3NnyI033kGxeInjxw+yuLiEridR1avY2rrIxqrDtuQwQ4kECauHWjLBZmWBFTnADwPsIIcZ\n", - "poicCpm2Ta+qskgcMSaI0ACDJiXAQKcPm3VkdPZikqZKmzKraLiUSdHCBVQckiSRsamiE1BGECBT\n", - "ZZyB4XfSbIWEwiYIthCiH2gTBDqKMkEYVkgkbsK2A8LQRZIGCcMkcBDb3mJl5WFcV+fYsVUKhR5S\n", - "KZ1q1cO256hUzrK5mWF2dgdCJKhUzjIychsPPHCG73//CH/wB/fT19eHEIJ6vY6maW8IQdm+fTuf\n", - "/vTHOX36DPV6i8nJdzEz8ykqlQqO49DX10cymcTzPJxEgqeff55wdZWcGzCk5+KUBjXB0UaRYSx0\n", - "XHxa2EhskwWmapAxMySaLQq4yASEeCSw0GnSoYpNEw2JMVxMLGxUTiBosJs0KZq4wCAB6a6apEFE\n", - "ggV0BEHXGFqmgkIOAwmfeMKIThUJhXXO0cAgYAgoIyEj2CDOL1mk3q2XAHRQEAjAJ8U5GkzKCvV2\n", - "xKLfJhAhQ2aCiXSSjGHxfKuG3D+GoigcOvRDgkDCMLJE0TPMzGT56Ec/+BJh+PHj5+jrm6BSabz4\n", - "PVU1gCzl8jLZ7BW80ZicnORf/+sP8oMfHGRx8Sj9/Xnuvffd7NixAyEEK/Pz9PiCTqaXpZZMJFxc\n", - "SWZT5OhhiEJvnWIF0uEoQ0NX0m43kBhmqbLKYO8QhVwf5+ZKOG4crp9ApwIY5FmiSQ8tEnikiWjS\n", - "ponKEAY1esiQZgtwKNPDKjmSdAip0iYig4mLQx2FYRLksJGRGUTuJs1IJPDYRojNGjoWKj451glJ\n", - "kuQSIWkUBCYddFrItHGYwsKS0mQ1g7q3jh9m8YOQTXsCe8nn6h27KW9s8ej8PImFp/HlKUKlQHYy\n", - "T6EwQ6fT4N/9u89y9dV3QFtnIDfL88+vU602uP76axgsFLiwtES1Wv25WuZvVpw4EWd8vOtV585f\n", - "frzgqOmOdfq1xs8kI5Ik/TlwG6BIkvR94FZgP/AnkiRdI4T4Lz/nsevEUgiIxzK8pB/wp3/6py9+\n", - "rWkJLOsnbb2SJKHrfczPLzI0NMRzz11gx46bWF19gHZ7C8vqIZvtY2VljmzW5777buPmm99Ko9FA\n", - "URRKpRL//t//OXNzLUqlDqY5hQhanDx4AUOHM6eeYOi62ynk01SqDZIJk0mlyUIYUot2IzNAJGQC\n", - "fFrRIm3vDDZgELKLiAwKNQQ5IkZxuYhKDxoSy/ho6PgEtFGREfTgoSMhAwk2qbOARMgIUEehhp6Y\n", - "IhIhmtYL9BIEK3jeIkHQAkYIgiaaZiJEBt8PEaKCJHkoikwUZUgkMiwsLFMo3Ey7Pcry8hqrq88h\n", - "Sf0MDLyDwcEBlpef5+zZw0xN7eMDH/j/2XvTKMnO+szz99499siIjIys3LNKtVdpA0lICAFaMDaY\n", - "AZsGY9y4jX3UH9z2Od3MdI/tM32m50N/mub0abeNZ3w4gz09TTdgMwYZkDCSEKBdVVpqU1VlZeWe\n", - "sa837n7f+XBDAlkCZIFUYszzpSojbka8ed/MuM/9/5//83ycQiG5K67XN/jqV7/JbbfdyFe+cj/t\n", - "tgtEHDu2yPvf/57Xva88MTHB29/+Uo3D9PQ0g8GAwWCApmmYpskvf/zj/MFv/zbz3R6oKv1ghFRT\n", - "7Iz6lJFUFRVD6KQ1jSCGldjF1yW7+PiEKLpGOvBRx061FgYd+pg4FCiRx0OisYZHh2lSzAAaA3YI\n", - "OEPyaxyhomORQ7CQTGywBcwyREdFJYWGRMXGwmEOQYBLlr2ss0UGxtlEIwQhNtNIuoywGSEpkmGS\n", - "mJARfVz6tMMYxDLZXBGpBFz0LrG5s4q2u4av6hidHqfP/c/sO/YO9u//fv7MyspzfOc7D3PnnS8N\n", - "TFNVlUqlxMWLu3ie86JXTxj6hKHNtdcee133+4dhbm6Oj3/8wy97vN1uI2ybmcUDeJs7nOm4WHIa\n", - "kxSWAm6whT/0EMYewthmbfUJejuXGfWHZMxlnjz/HKMwjxlVCZFIdJr0SbGPDDp1LhFikGGIjmSb\n", - "mJh9NGnh0aI+rlLtwWMZHZshaQzKdKnRJcMs22SpUMLCYJMRkgwqAocBISoQkaZExIgOETEuDuVx\n", - "0tQ0babGYmebCgZC7BLKJnbQJpYajiwghIIvFPLWDLFS5NLOJnOVBS7tbhOgcnRpgfmZeSzD4OTD\n", - "jzA5v0C/nyWVKiAUBd8LUdU8ly7tsP+qDsWJCV5djvM/LvzZn8Fv/RZcaR+448f//2ML/2oqI/8D\n", - "cDXJMEcNmJNS9oQQ/zvwGPBaycgjwD8HvgjcAfxff/+AHyQj9977LR55pPn3DyGOA0xTJwgCpFTQ\n", - "NJ2bbnoHDz/8IO32LmDS653l4MG7uPHGJHo2n88TBAEXLlygUtlPKiXZ3JQ4/SGm7aOPPBYrU3Qz\n", - "s6ycvY/ZvbcQCJe2fY6S6uEHZTTmAJ0hIRlCdAIyKGNnxySRVxJRRiFG0BtPS0gsyhSwgB4hXQxc\n", - "NrEJCLEQRPh08fCRzJPk6SqErFJKWXQ66wjRJgjssZdGC5CYZpVMxsJ1O4xGgkQCGyNlijguoqp9\n", - "4ljiuja+b9BsRnQ6HVz3KuLYY2PjMtXqNNdf/0ucODEik1lEVb8vUKxU5njmmXt4/vltpqauZWFh\n", - "gjiOOXduhW73S9x99yd+7GTGTxOu63LfPfew8vTTWELgaRo33H47t9x6K9ffcguDp09heBbDrS3i\n", - "yGA9UjGZ4XxsIfQh+zKS/ZpOY9jGLxdJaxqqqoDrkpOSKPQJgR4DirSIsMgyxMJHQ+ESEhuLEIjY\n", - "ZIIOBVxifFpkcdlDRAqNLho5TFwmcOhRZQT0KJJ48CZS1IgMJhnWaHEN2jjdRpJB0sMgR4SBwwoa\n", - "PiU8ekjkePYjg84ecuZBwriBaWjk/RSzmkU2DCkIlV27TdsoE6yd5ukT93Pt9bcDsGfPfh555MmX\n", - "kZEbbzzGX//1Sd72tqt54onnsG0tiTkIn+eTn/zUFdMQrK2tcerkSex+n8UDBzh85Aj5fB5VVTEt\n", - "i2Ixx9H0DDu799IOu1ikiKSDIg022iYd4VJNu6jxLpW0QTBUSWkG9khBiZYwOMsMI0wS348umyhc\n", - "heAAa1wmQx6THn0kGg4lNEwcXHYI8cmRZoiPQoY0MVksNEJqxMTswcFGJeYF0/kIOZ6v03CJkGMv\n", - "Vp8UGhoGNgU8/HEFDfJMEaJqBmGYYUSNJUWwGQTkAU0IPAlbzTMIfS+5Xpdes0MhU8DXRsfZCXkA\n", - "ACAASURBVFx94BCalgive+0WKyvrWFYB13XZadnEnYtMGlm6ToenHn+cg9ddR2Fm5udVkR9As5no\n", - "Rc6evdIrSSoj//7fX+lV/HTwasiIL6UMgVAIsSKl7AFIKR0hRPxa31hKeVII4QohHiJp+fxI8eqx\n", - "Y4f4+tf/kn4/IR2VSplcLkMc1zl8+E5yuRyVSoZ+v0WhMMmdd36AZnOLTqdGsXiMT37y4y9eLJ9+\n", - "+hnuuefbPPnkCr2eJAi66PoBnNY2OTNFGEIYhGQyBQ4Vp9AnepT3T+L2YloDH5cMJiCIgRiLXRaI\n", - "yCG4ajxuu0ySyBuPw8ZzSC4RkSKHjYpDzACJiyDAQbCDQ0xIlsSsOkOiB7kEdBEix3CYIo5XCENJ\n", - "4nIRAzNAiOc9g6LsxfczKEqXODZI9Pc6Um4TxwOiKPEOdZwmcTxBt9skDA+jKB5x7LO2ViOOYxQl\n", - "RxCEOI7zkorH1tY2hw/fTi6XfDApisLMzH7W1h5jfX2dpaWl1/rr8A/G17/yFfrPPsutc3MoioIX\n", - "BJy45x7SmQzX3Hwzp2o11i/3CLNTrA/6IJbQpIYuBFpcYtXpohl1hkTEmsZ52yaIIlxvl9V4wGhs\n", - "HG7QpURIDp9JppBo5PDZh0aTIQF9JukwyQSCHaBCDpUOdZocI8AgyzYGKXLoBAxJk6eFi88iiQC5\n", - "iSDDLm2qxONUYMEIgxImKWBrbAeeRsFhF9iHxCJEAjVCVmkPAyQuuX6HRV0gY4W5dI7qxARVx+ZR\n", - "z2FP6ghnH7uPo8dvRdcNVFUbE3n5kvHc66+/josX1zh1aoWjR/fQ7bZQFIe77/4jjh9/41s0AI89\n", - "+iiPfeUrzJomnVqNhz73Odqaxm3vfS93/PIvM7m8jNJs8eiDz1CMdXKqQTPsYZMnqx4gUq1xtXCW\n", - "jc3zaKbLqOfQD7bxZZYUNWaBNAoSnRQWKRx22RxrO9JoZPAYMUJlPzoVJnAZYCEADQ2VgCwCFZUI\n", - "h4gQSYg69oUR+EgKqLhs4TOLhkWRgDYODjYZrkanTQkDkxJDdilhA1u0GeFi4IQe+rjZ1xCCORlj\n", - "otJHpTSmSFtxiCdVijkFvB473Sb3PvkkC1NzLO+poAuBO+rRaF7m298cMKmVsNND9NADJeD8pUs0\n", - "ymU+9Tu/c0X2+82Kz3wGfuVX3hzOp4cOwaVL4HnwBppkvy54NWTEE0KkpZQj4EXFmhCiSHI1fM14\n", - "pXHeH4ZarU6nU2NlZQUhykSRzZ49If/6X3+SqakpAD7wgTv47Gf/htFonlyuhBCCXC7kE5/48ItE\n", - "ZG1tjS984UGmp69jaiozfu1nOXPmfqpqlY4uCIIBphmRm1CIA4+nnn6aBUVhsl4nDALS2GNj7xQh\n", - "IRZ9DHxyhGhj++4KyV2PMVbTu4CGpMMIkzxDXEZYKAzRKTCFyjYNQsokXqt5En/IaWAdKQW+v04y\n", - "7DtLsnUvhCEkWZ+Oszs+vkOSvDHDC6kqcVwmCBpYVh7HaaOqIapaQMqAOLbHDpZZut0huu7g+31M\n", - "8/uVkXp9jVTKpFSq4nke29s79Ps2hUKWMDTp9Xr/8F+A14hut8vaM89w68LCixdQU9c5Mj3NYw88\n", - "wMfvvpvVc+fYffBRIi1NS6kw1Ay00COlmWiKgilKXHR2GZgK1xcKXN7ZoRKE+FKlhUaagCoxGgVc\n", - "ulSJGDEkS5EeQ3xGqDTwUMmTRZAIhyFAR6EINOkhmCAmRmWIwRQTCDpsopPDB5KoPYkkIqKBjmRA\n", - "YZxbMkAhjU5AhM6ANAEuJss4GDCe1YEZJA6C/ePXeoQ4EPh00SIDRVEwVB3dabFba9KhzokTD3PD\n", - "DbdRr69z/Pj+l/mEaJrGxz72q6ytrbGxsUkqdZiDBw+8JEjyjcRwOOSRr32NG2dnOfvcc2w89RRz\n", - "UmLGMbtPPcXfNhrc8qEP8e2tLerBg0Siy1AVrEUGoZjHESaaopKzCphmm4bTY7XfIq24WHTxmSNF\n", - "D4MMIR4CB0lEliwqQ0bYFAjp08VGI4NKmiIeQ2JiYAoDh5g2gioxLt5Y8rqOjkMFlwYeHhKdAxSo\n", - "s4U39hWJCVDYImYKB4s8KiV8fCCiiE2HKgYhHhopPGwCtcVbp/eyNayjuBE1X0Wo84hIIYeBEdfw\n", - "gwyrjV1SSpm9pWOEeshWq0e90wHFZoCNohjYLYesaWGl5nDyAVEY8bYbjuOVSky/Ga66bxK4LvzJ\n", - "n8C3fhK15E8RpgnLy3DuHPyI7NGfCbwaMvJOKaULIKX8QfKhAb/5uqzq76Hf7/PlLz/IDTf8E669\n", - "1qfV2gbAtmuk09/PnVleXuZ3f/ejPPLIU2xtrXLs2BQ33/yRl5SUH374KTKZJSwrw/z8DGtrz+E4\n", - "aRQlYhB1KFp5iHVq3R0mgxornS713oCAmChIxm2ztBmwwoh5JAoSF4UuWSIiBEWSCRgNEEh8EtWH\n", - "SkyPy+g4xOQp42MRMmIGly1ypAgBjy2SlApJ0oaxx1/nSELldZJhX5VEerOHJFprc/w99fG7O0AJ\n", - "WEBRBIoCQdAik9EJgnVUVSMMzyJEEUVZJo5DXLdDtaowMxPS7V5mNMrh+30KBZe77rqFU6fWuXCh\n", - "iecZ6HqK1dUtHOckv/Zr171Ou/9yDAYDUorysgtoIZNhsLZGNpvln/3u73J6tcbzp9ZQ1mPKcRbR\n", - "3UWNY6IwRDEMbKEzoUT01tY4EkmCKCaQE5SJaWJjMY0/vlRNE6DRoY9HSJaQEiYODo0xEUkh0DAo\n", - "AhEhiS14wJCYDgVCFNqk8DAwialhUwNyaIBFA5MOIwyGqASoKGTHQ6VDIItBHhdvnIyioRIDOjFt\n", - "YiZRcVC0KlE4TYcNimg0wxEZ18EeujiKIB7V6AvJffc9xJkzT3HXXddyxx2vfOcrhGBpaekNrXj9\n", - "MGxubpKPY4b9Pk8++CB7NY2MaYLv8/SJE/zC1BTnTpzg+tveyQOPr3G6+y1mNRPTDvADlVgq+HGP\n", - "SmGaQsFiNdokRURGCOI4YsQKUECQR5JH0kdQQ+CgomIQ4BGQoU+AgTLOLQrpAwYClTQT1BiQQ8FA\n", - "IaBPH50+y0g0VDRiLDwa9DFI0UNFYxIfFRUHE0EKixgVSW+c3J2E5AkC+oywURiRZUDZEuiWxWSU\n", - "pmqlGHRs/NAhqdC4yLiFiBdxA42rqhWyms7U/AJhaHP68gU80eQ3/tm/ZXd3jce++TeEVKm3O1y1\n", - "ZPDrH/glitksD21vX9mNf5Phv/wXuP56OPojxy3eWFx3HZw48Y+AjLxARF7h8SZJxtTrjtXVVeJ4\n", - "AsOwMAyLTCbRvXY6E5w4cfYlZeM9e/bwK7/y/h/2UjSbXdLpxMRraqrCzEyOixc3yOePEfvP0nEe\n", - "Y6FSIRVH+IOAdqSTNdKURx6ZSCdNyBxDHmMdnyE+2jhafDh+B0mBpKbRB0boSNK4pOgTY2KRwyQY\n", - "d4UnSdF9wTOAkBCNhFCskRCQNIluRIxfsQe0EOIFAlJCyhcs0g6Mj3GAHELkxtM2Q0wzh2FIguD8\n", - "OOgv6T+bpo6ULqPR04ShII6H3HTT2/nAB34RXTcYDEZUq/s4fPgQ3W6XL3zhjwjDI0xOzhLHEb1e\n", - "h3y+yNNPn+P61zGX5AdRKpUYCUEYRWg/oCBr9npMzc0hhMCyLH71w+/j/2z9DT27jtPTWFg+Srvb\n", - "IAwHmDnBZEOh7EvywIxpsSY11EAnxKaI4CIxKiUc8lxkhGCHHCoWZRI7fxcPhwFNpsigM0QjJkan\n", - "y4gIB4N1plgjTY6QmKT9FuDio7FECoHKNgcZchGVNiEWNbLkCTCp0aFPCosFHLYJ8QnpopEhZIRg\n", - "hI5JhINEgdghQqfHkFk04sjmcquOrWh4ah7LLJGemCE3eS2+v0kqZVIsFt+QfftJoKoqoZScefZZ\n", - "8nHMxHiKy5SSMtBYWSEyTS5sNen2CpQXP8T5C9/BC4pIKujaFBg6oWywu9vCUK+iGteZkioKBXQu\n", - "0qSOT4DBNBJnPM5tAypp1sigkELisYtDFo9tDASC/PimY0CfEjUqGNSI6KOwZzz/ItGYoY8c++6e\n", - "4jpi6mgoFOkhGAIqHVwUXHLYFAALny16pBmQAYooDNCx0Z0eF2vr7JkqEdgRFiDxkGqAFBFlZQ8o\n", - "0FcLVCtVunFAF5VMfpqjN8xRb16gWp2nVJqis/osC6qGkFnK+YByPs96rcbyzwPyXkQcw6c/DX/8\n", - "x1d6JS/FjTfC448ngtqfZbyp7eBfQBzHwMvtpoVQxs+9euzdO8vjj9fJZPIIIThwYB8bGz06nRUW\n", - "F29HlSP89gbrq9vU+zaRB/uCAXswCDCJ8Jkm4q0MeAoPlzRFYtZRGRKRI6lXXABMdEwqCFS2kKjM\n", - "EBHTweYwmXFCZ4xghIvDiAIRMQn5uEBCRKpoOKjkCMgT4wCXkLJCEp+XaAaScv0Lfq0pIEJKgCcR\n", - "IosQk3jeBQxjABQxjCG2PcA0lykUMszMBAhRR4gM7XaWe+45Q7EY8pu/+SHm5+cByGQyLC3NUqv1\n", - "2Nx8ACEk+/fv5fjxX+HSpSewbfsNGfXNZDJc/fa3c+KBBzg6M0PGsmj1+5xtt3nfeMZtdXWVe7/0\n", - "RTK158l1W+w0FIRWYmF2nsnpRcLgMspA5flRiB0q2H6AKcBSFJwYOqj4zJKjShoXFx2BhUuDSUJq\n", - "2NhMo2CzPR7DTezsajQxaTOByQ4l2rRIoVAgRYkIhQYxNgdRx+RFJcm2sUkxjURDocOIEUOGTBIz\n", - "SYo+Nml89qDTRSOFjo6LRKGHgo1PiiynyWu7pGK4KPs0owg3shkoaTQlTWFqiePXfABdT9HpZGg0\n", - "otes9/n7OpPXE4uLi7ipFDs7O6iGkUx4SMmG57E4P4/vOAwGA0ZKGU3LY7sdQn0RxB58d5so6jJX\n", - "OUQYdun3R1iaR1GYyCgCVceIKhxnhadpUSUkg8IAQUSKOcooOIRY46pE8nnUIkeRYGx/1qWOicsi\n", - "UMJlRIYsEYvjsd2IIQEOWWCKOgWeZIhFkz4+DiV0DCQNAkJgmYAc0EMSEnKYHrvkiNGZwCamTI9+\n", - "5GEOBmw4HrEf4COI1AnqUsEIU+haDxmGXNze4cb33M6NY9fd06dPYjtbAOi6ydI1t7F78gEmhSCM\n", - "Y1Z2dtgBfu2OO96Q/f1ZwNe/nrRFbr/9Sq/kpbjpJviLv7jSq/jJ8TNBRpIPygcJAh9d/37CaL1+\n", - "kYWFCvfddz/T05McPHjwxwbpve1tb+Wpp/4fGg2LcnkGyzLY3X0aUHHdKUDS9mJqnoNlSqTfJaMo\n", - "xFFEhBwXZ5PL/hQ+l7DQyJNFp02XHUbjAHG4TIksRRwUXCZJkcIkYESLPlkmMBniUqeFjwUcJhkN\n", - "fYgXtABpXEwmEBiESGwyRMwAJ0jaNhMk2pBpkupIlRfyP2ESVV1ACI04rpNOa5TLBzGMI7iuwsKC\n", - "Qq12nlbrGRqNENNc4ODBG6nXdXq9Da655jo+//mv8qlP/fMXXW49L2A0KmCaGUDQaMQMBvZPZ6P/\n", - "AXj3XXeRzuV46sEH8ep1itUqv/Rbv8X+/fs5d+4c/8v/+G+pDiOm0wsU57PMT7c5u7YBqsehhaNU\n", - "c8t85pnH2IjmmYgy+EJlENWQcQcdgxoaGiVUlHEiiUUdFYU0PTQ8coRESNL4eKwzSYcmMT4CCWgE\n", - "OGxRRZKjj4GGR0R5bN+fJeQRfDyK+NSZJINFGROVBlkURoRASJ0RDjEKFXQKiS+FqBFJBUGAYIBg\n", - "CZMNFuIek2pMysxCNGKYmaSHRteYJ1e6g0g1AA0pY4SIMYwitv0P27/z58/zzW9+j+3tJuVygXe/\n", - "+0auvfaa15WYGIbBL3/84/zh/feTVRT6rRaYJtlikblCgb/b2OCqmUV0Zw7fP0kU6ZhWCU1bQBtJ\n", - "4riGoqzhedvk8wVKZgWl0UC1HaQQiChpiQzIYBNjEuOiMIOgMA6k7NPCpY/CJCZLqBjU2WGEhz/O\n", - "9lUYElDDoM40Jg18IqZQUDHGpmkObTJchUaaBjso9FkiJmSAN17FiB1CGsToOMwS4aIzT0TECIOQ\n", - "Hpdjk2tRuOi6BMVFPF0hcBzsUCGIBAWrxrSl0HVt/FyeoRsTx5IgcNH1LsvLRRxnSCqVZWn5GFYq\n", - "xzOP/r+k56bIXncdH7/lFiYnJ1+3Pf1Zw3/4D/CpT8EbxL9fNa69NtGMOA6kUj/++DcrfibIyMTE\n", - "BL/4izfxta89gWHsQdcN6vXz7OxcQNdvxLJUfP8SpdLDfPKTH/2RY2jlcpm77/4I9933EOfPfxvb\n", - "7jM7qwJ70LQYXU/jOh6+d4mJ7AJhv8tOlNzVKMQwdgToA/WxA+oOAzRMMlTIM6RDb+yqatBjGo0c\n", - "aVIYRAgcdHr4dOmioyOJMcZJGC/oQSSMvSgssiTVDh+FGBOBQw75YluoT2LTIkiErzV48bnLCGGg\n", - "qhZCjLAsl8XF9zA5eYDV1TOoap9sNkUYziDEEpXKIZrNBq3WDuCxtfVXHD26l/X1dZaXlxkOh2xt\n", - "7aAo01QqSbXE80Z861v38+EPH35DHVoVReHmW27hbTffTBAEGEZCUm3b5nOf+zKGb3LV3AIAsaxi\n", - "tC6z9+0z3PfUSR47rdMY9LkUVikZJTqezyiMUON5HDRMbNooGOOsXdAZYQAxKurY1G6SpMGjo7BL\n", - "TEifJVSy+FwgIYNvIYeCZAeDIgEuISqSNjE1BF0MHLJMsYHPNCkgNXZXHZAC9qDg0EMZy1gjPBw0\n", - "CnIClRiFCIUODs9TGAfwKbEkb2iktSq+muIpd4gfCjqdNsXiHJ1OF1V12beviqJ0XhSAvxKazSZR\n", - "FDE5OYmqqpw7d47Pfe4blMuHWVy8muGwy3//79/FdV1uvvltr+OOJ5qwT/yrf8X3vvAF+t0uwWCA\n", - "nkrxnUaD6g03cNPbbuSLX3yaUmmOSiXNE098AcfpoSiCfF5h//4Ss7N7qdVa4Gp0ADvaJXIdarTY\n", - "ZgqFJVQmEQgEK+zSxGFAmpgRLnmKxOOap6bq5NV9rPm7xMhxE2cHCDFIY6GTZhcfhReca5Kh/4gs\n", - "s+gIdAYItjBRiOmSR8fBokCFmDQOMTYhMElEk5AASZ6ABSxaFGSKlNth7oZ34gwgaO/Q3jmLFcdE\n", - "YkRWz1EtV5ma17l48WGmplwmJ1P8+q/fQSaT5r/+168ThkWE0InjNh/75K/yoQ+9/yURGz9Hosm4\n", - "cAE++tErvZKXw7LgyBE4eRJ+TNzUmxo/E2QE4NZbb2FpaYHnnjuL43hIKSiX38v09OKLx+zurvK1\n", - "r33rFU2RfhDT09N84hMfIY5j/uqvvsrk5FvQNJ21tYsMh3VmqirpaJ7NnW1Uv8Ucgjl0eoxokVCD\n", - "JEE3Mx7gm6ZLZ2z5PaKCxxzwGF1CfHR0QkJcHCI2mWVANPZlHDGFzwSSLBEHSLwntoAnx7m+OcR4\n", - "kDhigEYdDYMACRwk0ZA0SSoqDRJNwqGxIVyTuTkbw5hjcnKOweBZDCODqurMzCwzGDxNNns1YbiC\n", - "5+WRUmE4hCAImJk5xGDwNGfP1nnwwe+yvLzMyZPPcfTo27l4cZVOx0HTcgTBgDhusH//e37qe/5q\n", - "kPyc36+Wra6u4vtZdO37jylCoKppLp0+R2HyEJVjt7HzyNeZtFL0my0iYVGTIESKSMok4Eyfxwlc\n", - "QpIRbgsdAxuNDiNmCCkBfVT6aBwlYJeY0xhMoLIDzBDRJqaPzgCPDAEpNEKgj0cPjQ4+OXaI0YkY\n", - "0cVFYJFHAiEePTpMo2JRZJchOmlGIqQpDQwmEdRRmCMSQ4qKwYTpMF80mCgW2Nz1cAIHV1XYu/da\n", - "Vlaeo15vkM3OcfXVe0mnHd761quoVCovO6+NRoMvfelv2drqI4RKNgsf/OCdfP3rD1GpHHtxvDub\n", - "LWIY1/HNbz7OW95y/Uv24vXA7XfdRa/VonX+PJrr0g8CKtUqH7v7bqSUfP7z9xJFFVx3i3R6Hkgj\n", - "pUEqlef8+VPMzc3zznfu48kntnDbaWptSdNtEaCiUUIiERhYZFE5Tsh5QoZAl2Ac5RAgaOGjyiJK\n", - "wDhpqofJGjpNLEq4DKkTMgk4NHHQcdAJqaBzFEUEhNLDosYkAWV6NMf2YgEBPm0UzHEgRIKYLhFT\n", - "GOjo5NGUNIqh0xkotC72qFYXGbYeZ07qTJgWfjhi5LToZasYxiHgJIrS4v3v/zXa7S47O3U++MF3\n", - "EkURvh8wP38bc2PN1c/xUnz60/B7vwe6fqVX8sq46SZ47LGfk5E3DHNzc8zNzdHv9zlx4iLz8wsv\n", - "eX5qapGzZ7+D4zikXkW9Kooidnfr2HaWyckqpgqDwS52d5fIl6hynTJDyqrOIPboyvjFy38dgzwZ\n", - "VulTx2TBmGehXKYzPMOct8l530fHIWQFnwE+Gio+WYZIFnFoIQmooxJhkLRaRiQjvUlfGS6N+8ez\n", - "xEhU1knRoM8kCR3aIWnNTJBURK4hmbaWgEEcNxgOPVKpIY1GnV6vRbN5HwcP/gKGoRMEPhMTFcLw\n", - "NOVykVptGyHyaJokilyE0CgWF3n++Rq9Xo9ud0i5PMPCwmG2t1fp93vk87PAnpe0z64koijCsrIo\n", - "+RLd0YBiOhlF3d3dYHV7wKA6Tf2BezFcm4xSQs1UcZwBAZIeeaSIEELBsg7jK88QBzYZUULIAWq8\n", - "waTicSluA+skY7QzxKTQUDFoopMmQ4oQwZAKAS4qc4S4aBhAlohtVDrEWJQQlCig4RLTwGGXiDIW\n", - "IQEWAT4FighsCkpMX0boMo2KgUMLBRWFQwjZpxt9F0/NEk6keXpzh75tMhIWbb3IcOMs8/PL1Gqn\n", - "2LevwKFDgre//RpuuunGl51D3/f53Oe+hO/PsLCQiMNtu8fnPncPjjPkyJGXxswbhkUQaPR6vVck\n", - "Nj9NmKbJRz/xCTY2Nmg0GmQyGfbt24c+vkp89KN38kd/9J9oNCTp9FvQ9Q6WpREEXY4dO87sbIZ/\n", - "8S9+hz/90/+Dzzz+DdpOFzPOEoklbFlEEiOp440nZCQGkKZNnZFSZBAPGDFBhI+ITWJUgvG0m0aB\n", - "CYqASwXJCFhDx0IhpEWfMjHvQFUFbrSNxWX24qOiUSSHxYgBPn06RETY+EiK41dqwliRJhmiM0KX\n", - "EdueR0OaVLUqKXXIzOQevM6I9qiFqkpmZ2/BUFWGwyHdbpb77nue++//X9m79xqOHj1CFF3k2LFJ\n", - "PvaxD/+8GvJDsLUFX/sa/Of/fKVX8sNx443wjW9c6VX8ZPiZIiMvQEoJiJcx+ORrMX7+R+P06TN8\n", - "+ct/x/p6nZMn1zGcJlelDezmEN122eldQMYjlkxBVgZ4AvZESY1ClRIHsIlIIdBVlx1K2K0uui6R\n", - "hQKtrk8lvcRObw04T5Y9TJJGMsEAHYUJHFbGeTQWCQmxSS5yOpAmIqCES8zz6GgYRNRIkQhbMySk\n", - "I0XiKaIBD5MYpU0jxBaGoeM4Gq6rEIbnMYwsntfk29/+c0qlCY4fP0qrtY4QNt3uLt2uh6r66LqP\n", - "bffJ5SJuuOFqpGzQaDS46qp5zpw5Tak0zfLykRfP5dra48zNzfxEe/rTwvz8PEI8wFVX38bzj/4t\n", - "5U4NA8HTl57HLRxgas9xsrvPoesZnry8jikrKCJLBsFQqolLrvQIwzNABkVvE9BEo4khfRrkkb6K\n", - "qoyQZInjFpI0BiME/tgSPk3ALrCLj8THxKKMzgiVLVQkOgKDAVNIJGryXsyRYZsNtrFI0yUmi44q\n", - "MiiKTlXPkY1adII6Ayx85omZIqYBSBoYbHg9jkwu0F/1sEWKHQQuB+g3BzQaj5PJlNjYaPK+9xW4\n", - "+ea3veJd8MrKCt2uxuLi95N9M5kChjHLxsZ3XmIPDxDHEeCRTqdf591NIIRgYWGBhYWX3ozUajVW\n", - "VjapVkusra1imk1mZuaRMqRSsXjXu25hZ+dhLly4wFf/+htkpIpROsigFdDz1LHfbQ6fxPRLxCkQ\n", - "MZ7IEzCPZJk1dtAJMDAYcQaP5DMnRYlJRugkLj8tAlIEGPTIkyaFyiQ2O/wtw+g6OjRYYBMNFx+D\n", - "OgKBho5KFo0JDDo06LOBS56YuXHGc2KXGNDHw+UxX2WERbP5JH7H59pMgT2zM6yu1jBTBXL5aZrN\n", - "VVZWnmd29ij9vodhzDMaTXDPPV/HdUd8/vNt7r33Af7gD36fI0eOvNIp/0eNP/kT+I3fgDfz0NmN\n", - "N8K/+3dXehU/GX4myUihUGBmpkC7vUup9H1DnmZzi337pn/oh2Icx5w6dYqH7r2Xb33zEeYP3MaR\n", - "I3eyduHPEbttLl92MIwCUTBiWityzu7iqJKyZbIVhGQRxHFMW0o6oowuFhjFKkHsowpBU8mTM7uk\n", - "81XmRRFCmyljgrN+RIoy4Vj+aiDGnp4TGPRwaZBUQwKEmEfKPLCFy14alMmwjUvMCB+fm0iIywSJ\n", - "O2uLRDOSIskeXEeICEVRCcPsOKNmFSigKPMIsYiuR9j2JufPP4Nh5JidvY1ebwfbjnCcNq67yvLy\n", - "LO9730dIpXS++93H+cxntpib20MQbLO+rlGtLhHHEbXaRfbvL7C8vPx6bvmrRqlU4s47r+O++55h\n", - "7vg7aDc3efbMIwyq+1hYfBeKUNAFTGYr5MQ52t6IdGqZKO5DvINgLwBhOCAMLCAkEA3y2Rxaegln\n", - "NIMiDVKpZWx7k2QEu4tFk0l8wKSNjsEMgoAhJtDDJcJEI880IRE2DQQWfXxUGqQYopHCRMEgTZsC\n", - "HlVS1JGykIhRoxUUcuRJs/vi3FabpIqmEitltvSY//bEc8iwiiemcMQyvhOhKCaKYlMszjM19S7+\n", - "7M++ydLSPO94xztedg57vT5CvPxvKJudYG6uytbWaRYXr0VVNeI4ZmPjDG996/4rkur8Amzb5rOf\n", - "/SKwyHve89t0u/836+sKZ848M9Y7CU6depZcrs+//Jf/GxdP2QhZxg8VRpFNSqkiZEg4HucO4gGG\n", - "aaMbcwSBA8EARVyFHxv41PEpEDNJUpEso+ASo9DAIWYRgY6gjskImzpFCqTxMRmwHl/c4AAAIABJ\n", - "REFUwvdwMIgxcSiNc4kUQMcmYhNnnEFTxKOMRoSkiakO8SIdD0Goqqip2xgOL6KgISODYeSyPTpH\n", - "5G8xM5MjjiNsu0Zt2GZ++QaKRYPBoEIURVy8eJJOJ2R+/mYsC5588jx/+Id/zKc//T+xd+/eK7aP\n", - "bzbYNvz5n8Ojj17plfxoHDwI/X5SxZmdvdKreW24YmRECPGLwKeBppTy5Z+IPwYf/OB7+Oxnv8TG\n", - "RodUqoDjdEil+rzvfR/5od/zjXvu4fLDDxPsNjig5PBXn+OZxgbFlIlZSHGp2UKGCpPZMmlziXoc\n", - "8LyzieHr7J9c4HJnm5Hnc4EMM8oc3VjgY+LJadS4hSrXyKYPstPyuGZ+is0L9zMXDkljkQLyBIRo\n", - "OOhjSqKTYhKJJGCHGA0pOyQmZknmTMAsXZZJ9CA2iftqQFI9WSRpy/RI3DgT51YpV5BSJZNR0PVJ\n", - "hsMeun4NQTCgWLwKEKRSBwjDRzCMCCE2qVangBVarRZzc8e4+uq96Lrgy1/+b2SzVZaW7sTzRvj+\n", - "gKmpNsNhF01Tee97j3PTTTe8obk0Pw7vfvc7WVpa4MSJU9RqU6j6XsJTPisrJ1HVacqBTdkqUVZV\n", - "dNUhnXXQ1R5dr0zohwhZQoZrWKKAySFipYtGD9+NcEcBmpEnihpEkQOUkTxLRA9nHHxnMEWGIi1G\n", - "qKhozKCyRpkCMR36hCjsHxtqQZceIetUkKgUCRkhKZBGMsCizgaSNJIKCkN8PFymUZQ8cTyNrk8D\n", - "XVKpKRRli5Y9wDBuRdOmUYMARRkCKaRcIZ/PkckUSKUO8td/fd8rkpFKZRIpT77s8cGgyV13vQPP\n", - "C3jkkYeBNHE84tpr9/JLv3TX67yrPxqnTp3GtrMsLiYVOtNMo+su2ewBJibK5HIFnnzyW0i5iT1c\n", - "Jq9ohCgMbElEGssIMAKPQG4jZYOYEaqWJ5PJ0+uNgIgw7GBxkRQBaaaAmB4RQ5Tx37WPZAadKj49\n", - "dDQEJQIUbHqMMAjQxhNQFfp0KFFFwSFpw0zioGNTQqoGQnSSyR2xScbIMpsLWGs3GUbTqPoUrn2K\n", - "AlnK6hSx72KjUEPB7LeYnc1RKldx1QKGprK0dJxebx3fH2AYGYZDl1TqGoQwUZSAiYlF+v0RX/zi\n", - "3/Jv/s3vXcGdfHPhL/8Sbr0V9u270iv50VAUuO02+Pa34dd//Uqv5rXhSlZGHiERObwmY92ZmRl+\n", - "//d/k+eeO8XOTpPZ2f0cP37sh9pV12o1Lj76KDcvLfHoTotipkgqlUW2d6iPBsR+QKgUQNOTdobf\n", - "w8CjQY6zQcx6c5dBHKKrEIbTOAiisRH0hAjwRZpQmphaBl0r0HQCdCumgpE0X9yQLDohw7E9/IAI\n", - "m5AJYpZRySFwx2r704CLYZiE4WXieImEcCQW4QnpiMY/WZpE8JoBNki0JA5x3CKTqWIYS/R6bXTd\n", - "RUoXx9nBMEqYZgHPMygUFllaKnPw4HFU9Va2t1ucOXOe558/wUMPfZU43kc+X+Hv/u5hrr/+MFdd\n", - "dTP1+mP8wR/cjWVZvFkxNzfHU089y7lza3zvexdpt/OUSgeQssVad0g4eoS85ZBVdPxwiJuZoVKc\n", - "Z3e3jvTbWELFIoumGujaNH1vHY9ZFEUjjof4vkOyBxl0QibJowM+GhJvPK5dJk1nbOwdoSGxGaJQ\n", - "JI9JiI+PQGeKITZVhvRoEmJikTTqBgS0qAKT6KiE2MS4SGrIeBIhPBSliaIopNOzjEZtVNVAiAGF\n", - "wn46nSZCqCQxUqMXp6BMM0+zufWK5255eZnFxTTr62eYmdmPoqg0GpuYZpu3vvX9FAoFbrvtFjqd\n", - "Dvl8nkKh8MZs6o9ArdbGspJ1DIdDdL3K4mLA5uZZGg0d05xhdrbCyZO7HNh/lJ32ExT0LI1hnTgs\n", - "4sfbpIx5jIzLREmn2+0yNWXylre8g29963tsbY2AS0zTJERnxCoWM2TJMmIHjymGxJjkiImI8ZDE\n", - "+GgITOoI8hzGeDGRaoIePWqMKBOjkMLFZQuTkEksPQXYRNE2btTGd8GLNAK1wuz81RhGh96Kz5y1\n", - "lyCI8XybeS3FelRmI9oh3L1MxQK1YDG9dJhOZz0hU1adINiDlALXXWE0mkBRBLOzB4iiHBcvrr+h\n", - "/jFvZkiZ5ND8x/94pVfy6vDOd8KDD/6cjPyDIaXsAj/RL32hUODWW9/+qo7d3t6mKASKolCpTNBo\n", - "NkmlspTTec4Nu6w0L4Pr0I3T1NwNrMgHYZERe8GIcVICN44oVktsXGhixGAoKuk4hyosfCWgg4If\n", - "KQRBk9YgJh+q9HWFchSxxSYXySOZGHtUuJiUCTAwxSxSQkTiGxGyF8NYp1o9ys7OCeJ4jcTTNUkK\n", - "TizeAxKCkugFkhHfZAYjMTzLoGkzxHGDOK7heUXCsEwUtYmiTXz/MPm8jqaBpumUy4llvqal2Npa\n", - "4cKFbTStxKFDd2CaJkHg8dhjZ7j99huI4xStVovZN3E98Nvf/i4nTjQZDtPMzt6Bql6k1xtRqVzF\n", - "jbe8hZWL91GpDOjuDpDmASbUWba3t5BygBAtFG0ZU1NI6QI/8BAxqGpELpXDc0eosSDGY0AXAx2b\n", - "JRx8HEZoCCQFJB5ZFAR9Qpp0aSCRVEgjhUCXKRqExAg0pcj52MNCISJmhDNOBfZIsYyLhouJJioo\n", - "MkQRbRTNIgz7QBZNKxFFQ9JpDcPIEcc7OM7z40TWXWCApikvkpHhcJN3v/vAK547RVH4p//0n3D/\n", - "/Q/x+OMPE0WSw4cXec97fu1F4pHNZl8SonilsWfPJI8/fgpIBLiKYrJnzwF0HY4cmWL//mt56KGH\n", - "EEKlVK5SL+SIhz5lQ2fT38YPN9GMEUuL17NnzyE6naeZmdG4fPkShrGXfF5n2P0OQ0xUFlEQ2FzC\n", - "YIRFzIgUNuDSQcNDYNPEpISBQw+VCWx2ccbJNxIXyQTbZOgwQKGKi0fENOCjaSVMcxFd36DdXiSM\n", - "6rjCxTRNhEjB6CJlw0QKiAnJGRpZTSPtWeyKKlgTnN/UyXsh1epZFCXF4cNv5eqrF/nCF/6Cfl8j\n", - "lTpGtzvCstoEQYUoCqlUJn5ORMZ44gkYjeBd77rSK3l1eNe74E//9Eqv4rXjZ1Iz8lpgGAbB+P/z\n", - "C3OsXNqg12swiiOcbgNVS9FWMhj+BH7sscMuaXwimuSVJUxjAi0K2K13sdQBWVJkNVjzBgip4cgG\n", - "KSuNH0f48SqDnsFccZrTwxqOm5SCfTJEpIiIkWTHVZEm4CfTLdGQOAZDnwIi+v1phLgWIYZIGY7/\n", - "7ZK0awQJ8dgF9gL7SYjKeWCEEDsIUcayWkxNHaDRSBPHJqlUBcMI6XQe4xd+4Tbq9S0MI9HTtNtt\n", - "HnjgezSb50inj9Nutzh79nkOHTqAZVmoaoG1tQ0KBe9HTis1Go0X75qvRMhWFEU8/PCzzM7ewOnT\n", - "f0Mudz2ZzCS12nm2th4ln59lbj7LRz76fk6fXuWxx9Z4/vnvEQQKqtrFkDNEcYq+r2KoklB2qKQr\n", - "9BQXogbFUEMVGWxpY9Pk/2PvzaPtrM4zz9/+xjPPd56v5gmhWYySTGMM2GATz4HYjhM7jiupVUmq\n", - "q1fVqiyvrlq1vKp7pd1d1b0Sm7KrHMfGxlUQA0kIxgxGQgg0IwnpDrrzeOb5G3f/ca4Vy0AFbEAI\n", - "5/nrnO/c79x99j5n73e/+32eR6dnRR01jUDgkMUgj0cXVUoEmKcbF0MxyPlNXBw8aVJDUCOJRw1V\n", - "mEg6gAI6q2nJgBtIEiuE8n4EAXRiGKaO57chlDk0LY2i1EkmE6RSUYLBELlciHR6LbWaRy43jmHk\n", - "8DyLrq5VSCmZnj5JODzHJz/5+6/bh8FgkDvvvI3bb78V3/fRtHf3VLFp00aeeupFpqdHCIVS+H6T\n", - "UmmacLjJ8PBmVFVDVSWRCHhek4ENO5gbO0VANAg0cjhqmUz3TiKRNIXCCdatM9B1nx//+CC23YOm\n", - "Gfiik4ZMEkclRAyFNBYXV/x2HVQELlN4bKJV06VTJIeggo6BTTs2EXw0WlPvCFCggUYrsxlDAJIi\n", - "jUYZKes0GjaKkiCZ3IXjvEIsZmLbs3hWnX4dFuuzqL5JKhxAAgVPQ9MhE1qHjkLHwHamp5+is9MG\n", - "Zpmfz5PJdOP7GqpqEIl0EAxuYHz8KB0dko985J9fqSF81+Eb34DPf751BHI1YMsWWF6G+Xn4OTu2\n", - "qwZv+wwjhOgAHviFywtSyk+93f/757Fq1SqeDAYpVqskIhFuumk3Z86e55EXjqK6Lh19OwiGfBbn\n", - "S2i+JOKaZJlDRWHUWmQooFGr1Cm4FXQWyVIj62XwUGkwhyZtmo5Go7CAL21cR+HYUh1EO6pox1MW\n", - "cfw2ILyiwyjx0PAwacpRPCeCAGzpgF0BFnCcxIrvTBpFOY2UMRSlihBRPG+RVibEo3U0U6VVNxJH\n", - "CI1IpExPT4J8XmXPno8wMXGBqakxwMY0TcLhOKGQw6c/fROapnHu3E954YVThEIZduzYxvy8STTa\n", - "xcWLU8zORlm1aghdN5mdHWXXrk2kUqlX9bFt2zz00KOcOjWNokTx/Spr17bz8Y/f/Yao1m8VHMfB\n", - "tj103URVNfL5RWKxNnp7t6JpAk2rks/rHDtWx/MMarUZwmGTQGAL+fw8zfIMuD6uGyJbyxMiS8VP\n", - "Y8RsFHsWiKAoETx/CkmAOsFLgS64SMI0OQ7kqaPjouMSpB2DGDEmaGIRAlwURUXIJp6XpVXE3ItF\n", - "BoEOOCtCWSo6FXQEnmxQtRq4QiUcKaBpCtVqmXx+Ed+3aWtzSQZd7Oo5EskBursHgV6Wly8QCFTJ\n", - "5R7h+us38ru/+6f09va+Ru9dDkVR3lX1QK+Fubk5pqenwckzevIn5PMWhVqTUDzDLbd8FE3TyeXm\n", - "icfrbNu2hlzuDJWKxnJxhmJpASXSZNf2W5mfn2BhYRTTVDl0KAiEqVY1pJRI6WOYvdjNClUkQaor\n", - "YxTGZQoNi6C6GVetULdHaOU5JS4W/koeVKxkPUBZMRAwaW0mkrQynJ20RPZ8PM+hVluidQw7j+No\n", - "mKZPPJ7BNOvkK0WqjQUyepGcFaVUj1FVJBZNhjPrCIcS5BsVCoWLFIuSWi1EV1cPlUqe1auvQVWX\n", - "OH9+kmx2ClUVhEIVfvd3b2Pnzh2v0cO/fqhU4Ic/hLNnr3RL3jh+vm7kk5+80q1583jbgxEp5SJw\n", - "4Je59ytf+cqlx/v372f/r5AvCwQC3H3fffz1X/4lwXweHbA6Mnzgs7/J8ScOEQ9tZNSZwdCTzExf\n", - "RHGjKHTQrqrYUmWsOIIiLSLU6dd8kl4OT+bIoVMRUJcqBbkaxbsG2zmBqg/QtJqE9fVIfxnbX0bS\n", - "uyJrFKJFDF4GHFzquNKkVRNi0HLdjaxQlKsI0YUQEQKB7biujmE0qNdn8P0BWkFIlFbBawpNEwSD\n", - "MZLJXrq7JeVynXp9mp0713DbbbsolUo4jkuxOMYnPnEzBw4cQFEUJicnsW2X1avfx/LyDLOzx0mn\n", - "N2NZDaanDxOP16hUptm/f4B77rnzVf3reR5PPvk0J08WGRi44VKqd3T0HI899gQf/ehdv/TYvVmY\n", - "pkk6HeYnP/kJS0sN5uePYprDxOMhyuVzdHRcw6pVQySTvZw8WWBhwSAe1+jrG0aIdtzYAPn5F8Ad\n", - "QxENJAIUm7DSTgiVkObgyzpRFPIIPFIIOvFRYcVxqJW5SuGtuIm4GEz75wmKCo6MrIwXGP4UGnVU\n", - "BqlSwCNJixWloBHAJYRkApcC5grt1GUJoQgqFUkiFKIt5KEpRYqLk/Q7bdy4bSeT0xNcHDtCavsu\n", - "tm7fzu23f/o1NUWuZti2zQ9+8NecPTvPmRNjOIUZupJw1/uuJR4O85PzF3CcUebmxhke7uXeez/P\n", - "xMQUf/Z//L9MvPI8oapCuxnDDEeYOH+crsEbWVqymJ+fQ8oynjeN55lI2YllGahqHPQqVecEGg7g\n", - "0aCJQoj2cJ6CexREGkERSQ2V1Aoh38IliCCIJAg0UCijIJAkcelFoYnCMi6S1iYjRivbGadVO1Kk\n", - "2aySzQaJBFW6QlFWr9+AurBAZ73CUnkRKQQ97dvoTA6Qr5dRI2GWl5cJBjdjmlVUNU4k0suzz57D\n", - "NLvZuPEDNBo1ms08vj+ClK+WS/h1xfe/3zr2uNoyDO97H/z4x/8UjLwpCCF2AF8FNgsh/h74kJTS\n", - "+vm/+flg5K3AwMAAX/yX/5KJiQkcx6G3t5dcLsdzf/ssEV8ifVA0STCapmy3CJpJXUf3BaYdwVgJ\n", - "HlajEtFNZm2LBAq+hAKCiFfGUidRlF6QElXpo+lr+F51JQVfpCVu1qKAtiacOVrHLh6tiaew8jfB\n", - "ldcEUtbxfbDtRXzfxfdnUJQBpMwgJahqCt8PoCgFDCNAPN6BaWZZsybKhz70BY4eLTE9XWRqqogQ\n", - "ClCjtxeuv/76S7veWCy2ch4tyGS6yWReJpsdo6NjLbrus3p1jFRqNf/qX/2zyyicc3NzPPHEs5w7\n", - "N8GRIyfYtOl2fN+/JKDU07OWEycOcvvt74yJHrTqkExTMD19jra2XQQCKWZnz3Px4jyhkEZvbwKr\n", - "VuaHf/UQeCHcSpKp/BkajWcJBDYTTwxRK1cImxF6UwU2drQxurzAcjNGNr/IOjVA1SkiBAjp4hNB\n", - "4tGq42l5p7ayHBHEikG8TQ3JMHV5FlgNqMSYR6OOg0KMNlyK1PBoUXZDSCSGSGHJESQzVFFW/ocD\n", - "XhRI4boW8USIQnWJQSWCWmwgbY8NQxsZtAaZrM/xhS98nO7ud4cOzFuJZ555jnPnqoTDa8kvHMa3\n", - "TRZzgvPTL/K+7X3sGuxFX9/HPZ/6hySspmm0KxbxrnU0G2ESiTSNRhVrfoLlpVmWlwWNRgPT3Eiz\n", - "+TLQhu9b+L6NlB7ST+KTosR5VPrxCKEiafg2GzffQLmyzPx8mUoljUcXHnV8NBTqQAEfFxUBlFBR\n", - "CGJQx8cggUUMhRoCC5+tyBWfmtZckF0pno5QLR7nxq0x/uBT93BidJQz58/j5/P45TKerjFZyRHr\n", - "GMIIqoiajufVCIUCqCosLGQplUrE421I6RMOxwgGg+TzLzM2tkC5XCYWi12J4XxX4f774d/+2yvd\n", - "ijePO+6Ar361VXx7tcWVV7KA9SjwjvMBTdNk3bp1l57HYjE27NzMU397nOVclXpTo2Y1qYk6UeFh\n", - "yzBNmljoOAh68NB8SdETNEgSJUoQSR0dWwmDO4MjtmG7s/h+BolDK8BI0doNV2kVoras9Fqp2Sgt\n", - "RswWWpPPBK2ApERrUTuFlC5SltF1HzBRlE5UVcNxgijKDJrWi5RZEgkP1z1FR4fE8yzm5pY4cuQJ\n", - "TPNaEokBXLdBvV7Eslo1Ij8rQk0mk/T1JVlenqGtrZe9e9/Hyy8f4dCh76KqLqq6k7vu+shlAcXy\n", - "8jJf//qDGMYQPT03outLjI4WaTZPsmvXdoDWMYTQaTab71gwUq/XmZ+vcuedH2Zk5BxQZdu2VYRC\n", - "6zlz5hUyqRjPHDlKR3QATTXw6x52HRampxHGLL29B3CsLNFgCSEUzswtYYQkMc1n2VTIuVkCJhRs\n", - "HzwVGKM1vm20siJZWhTsJK2jljStbMckrfGOoZInShyXKBYNbIqo6LQC0E4kApcanizT+s600aoR\n", - "MoCW2JeKiutVmMhWUd0mw3oHll3m4HPPEY9mUFQNL1RkYmLiPReM+L7PoUOn6O7ezZEjz1IsqfSm\n", - "NxELC8q1GS7OCzx/lsFfUKqanJiAfJnurkFmZ6soikKjUSepJ5nNz1GtVlCUDWhaB6o6i+vGUdUE\n", - "vj+LImoI1cV1bRQ60EQnChbQTb4xR/X046hqBNuOo6rr8T2BpAwM4/MSPnkUkhiksakC82h0oFOh\n", - "CfgkViTUVFR83EuMuQZCKEi5hGUtY/jLxBI9HDpzFtfX2LB2I3f3dfHS3Bwj2SJP/2QUZ8nE9so4\n", - "Xoiu7n40rcnIyCzZrIEQHvX6ONPTLqlUHEUp0t7eh5QatVrt1z4YOX26pdfxgQ9c6Za8eaxeDeEw\n", - "nDzZMtC7mvDurkp7B6AoCvd9/rM88fT/imX0UG+qWAoo2iKqWEDTVYRiYNsNhnEwEei+YAmDMCFU\n", - "BI4ApILityMoIJUcQoaAJv/AdonQynyM0lpw2mhphCRp7YQNWtmSBi2dkQo/o45CH6oaADIEgzWa\n", - "zWl0PYCux/E8cN0sQpzFdYtYlk0mE+aGG36P7u4hxsdHsO0EfX0umrZAMBhkcPBmXNfmpZdOXsaI\n", - "+Y3fuINvfetBJieXcRzBK68cp7t7I/v23QJ4/PCHz1OrNdi3r6VNcfDgEYToJpPpQUpJIhHFdaPM\n", - "zuZYu7ZEPB6n0agSCkHiHZQvbDabgEEm00Mm8w+fz3FsLlw4zbnTJ9CVMJpqsLi4RKlSIGqkUZ0Q\n", - "BWucycmHCBhNNKWHoLqOUEgwUythu0Xibd1MLc/hNDU8GcS7pKDboDVmBq3xG0dhM1LMowlwfWgx\n", - "ngSQX7FN81tHQBg45FdsEF0kZ/mZA5JE0vqeWLTsAtKoajueV8IniOM7qLIT189StRoEiBJQU6iy\n", - "QcxI8Up2iscf/zHXX82mFa8B3/dxHA9V1Zmfn0c3e1ayfoBQSEY6OD91jI23XG6aqRsGvoBoJIIQ\n", - "OWzbolqrMVZYJOebeF4vQkRpNM7S+t3m+BmVPh3toVK7iEeupZGqmQTUDjxFxW2AbefRtDBS9iJE\n", - "EFWzcd1WXUnryGUEQQmfLArTBFBXvGciyJX6E48cYKFcyp4KoIaUBTxPRdOGCATbOTrW5IXRBdb3\n", - "9ZKM6Rw+e5yGkuMju3Zy82+28dcHT7GQrzGTc4jH+zHNAKbZSzqtsrg4QTLZg+u6wDLr119HrXaR\n", - "UIjXrAX7dcM3vgGf+xxcrer4d9zRkq//p2DkKsSZMxe49f2fAIKMjl7k6NHT5LNpDF8Sy5hML5ZJ\n", - "qTninmAWnTgKkgASQRXJrPQpE8NEBTRcfwrd2IvCFI4TRMpVtBYTjVYQMk9rYWqJyrcCFXXlsbFy\n", - "fZlW8NIEViPlGUzTwLICuG4D359jeLif4eGtTE5OMTExQjCokEh4tLXtYnq6QF/fGgwjQjK5nUpl\n", - "jg98YB+G0dIGKZWyFArFy/ohk8nwh3/424yOjvLYY3/Pxo272Lx596Ujl1gszRNPPM/27dcSjUa5\n", - "eHGORKJFDxVCsHnztRw69AKNRoBiMY/nNSiVRvnkJw+8o74X8XiccFhcskf/GZrNGjt3ruHIcyex\n", - "nDilskaxMo+q5OhNriFvW4QDOpFIgMXFV0DJkE6FUE2Xpdkl8hUBahlN60MNr6ZeyQIXEKKElG20\n", - "pPhtYAaBis80SIkUErhISzHXADwcahTRVn6ANSyaqGxBYRkPB9iMouhIWUaIbnz/JDCAEAFai5uN\n", - "xEBKE0VEcUSEvCzTQ4iAGcX1qtTsLFo8zUvPv4xlWZim+Y6NwdsNTdMYHu5mdnYGTdMIJdIUyxVC\n", - "AQNddZHSp+yrbPqFGXn16tUEejooZrP09XVw/Pg5srUaeTeIavZjKCZStuN5KXz/RXxfpZXRqlCu\n", - "X8Bzp4AaLlFM6WK7HpbXoEWvjqIoHkJIXLeMlB6qauD7daQMAR1IIigsEcUjgsoiy0i6MXFwxATI\n", - "Bh4+rSCoDVhAoYCPgiKixGJJIhGd2ZxLf9tq5vJlUrEQRbedanWJ4a4uAobBNatWUarVePLoCY4t\n", - "jlEqdZBIRNC0JTo6PFw3SiLRjW3PUi4vIuUUH/7w599T35FfBs0mfPe78NJLV7olvzzuuAP+/b+H\n", - "f/2vr3RL3hzec8GIlJIzZ87w4jPPUMrn6R0e5rr9+/+nmhiLi3lisU4CgSiNRpNm02V2dpaZiUUa\n", - "6gzRYIG14TjZgo5oapwlR4AGEKKMQY0OfDooUQTKeATBG8EMuEAU36/gupJWRiRNq2bAolWomqO1\n", - "s7ZXnhu00v4/Y8moKIqNlAHC4b34fgPfB98/y9xcEM8rUq3m6eszSaW2YFkL9PdvJ5+fYXZ2llgs\n", - "hqJMImWQarV4ST6/VFrkuuteLStomiabNm3isceeZf36LZcFEZqmAzHm5uZYt24dmUyc6enypQW/\n", - "o6Ofm2/WOXToEWxbob19DR/72AdZ9Q7LF6qqyu2338QDDzxFIrGGaDRFuZyjVBrhi1+8l7VD7Txw\n", - "/4PkCwvEDJNweAhF6NT9Zfr71qKqOqrqsmP7zWTnxrkwOodU16LoQRTlIprWoo6GokksqxshyjQa\n", - "ZxFiAUUJIKVOILCZZuMMviwhWaQVYPbT+skFkQSoYRBARXIBhQIWuZVMSwIhsvi+gWkG0bQmltWL\n", - "lD5SNvH9wkpQAr60cP0sghCLuEiRw2s2sPwFmgQZ6L2eaqVIvV6/tNDkcjnOnTlDo1ZjYNUqVq1a\n", - "dVWapN1228184xs/RFFc4kmTvGczm5ugrytMXlPZvGvjq7xW4vE49/7hP+M//+//AWtuiqZqs6DV\n", - "UeOr6Ex0UCpVqFaLqKqK66YIBMBxphGihOuG0NUehC9wSNLwymjSxSWGSw3hNfH9GlIaSLkVaNVr\n", - "tI5ga4CDj41gnhQ6DhYQxmaZsGqRMHwadoyaFwVxAUM9hS8dPC9F6xiwBlRwnArxtp2UfQfqDi9O\n", - "z2O70Cy5PHf6NAe2bUNVFBKRCB+6fg+cP8/4UpNMRqW7ez+OcwPPP/9TpqePUC5fZNOm9Xz5y7/D\n", - "zTe/aSHs9xweegh27IDBwSvdkl8e+/bBxz4G+TxcTYmu91wwcui55zj+2GOszWTYkE6zODHBg3/+\n", - "53z0i198XSpjX18Hhw4tMTFxnmzWIxrtJJWKsrAwRlVRsM0gy45N+8B12EtzSCfF+eoELjGiDBAi\n", - "jIOPr1goRoq43kXvwA48bx5F6WRx0SKXO7Oyex6m5SfSBPpo7ZZfAlYhhIeULwMmQrSj6xlct4SU\n", - "M2jaOur1OlI2SaXWousBHOci1WoTzzNob1/N4GA7S0sKrtsgGEwwN7fMddeaJGXeAAAgAElEQVT1\n", - "09kZ5sKFs/j+dhzHZnFxglCowJYtm1+3H0MhE8tqXmaIBiClc2lRu+GGnXzjG48QiSQIBFpeJo5j\n", - "8f737+bLX/7cFaWEbt16DeFwiKeffoGFhRG6u9v5xCfuZmhoiFQqxdLUFD/5m0PkbY1yM0+VCqG2\n", - "FN3dm8nlziOERW9fL45bZJU2SDZrIefKFIuLWJaJEGl0XcX324nFutG0boTIoWmDNBrzeN4JdMNF\n", - "0/pxnDlcN4ZgGN+3kCtWAB4nqBMmTDeCBmlFw/FFS7NEJPHwUBSHcDiKokhcdxLXzeC659G0fjQt\n", - "juuWUdUcmjaE1aixLF0WmnOEzXYGonuYWXBoqPOMjo6ya9cuXj59mh9///u0CUFA1/nJT3/K0bVr\n", - "+Y1PfxrDeHc4L79R9PT08Pu//ykefvgxHnzwGfoH1/H+D3wIwxBUKhf5yEduec3PtGfvXlZ9+5v8\n", - "2Z/935w4Ps9Q3SGVuhFdD5PNzvHKK2eoVn0MQyEabVKptGwYfHcQ6fogZhCyiSvj+EzhUkAwT0Am\n", - "caW5wogZoXVc5wM1VGUZX6aRcomWlmsKIRyk2oWuJkh3Behpb2d0/AhWqUAyrLFpaC/pWJKnT87R\n", - "aDZw/Sq6HqVcLlCrzazUj0k8OjGMCPnyJN/78cs0mj637b4WQ9fJlkps3bmTNZ7GzIx56djywx/u\n", - "Z2zsBJs23cZnP/ub79iYvdtx//3wxS9e6Vb8aggEWqyaRx6Bz3zmSrfmjUO8EYfbKwEhhHyzbWs0\n", - "GvzFV7/KnvZ2jBVLcYC5bJZqVxef+tznXvO+XC7Hn/7p/8WZMwo9PVupVMqcPfsi0aikrS1DubzA\n", - "0oVnMPwQvtuF1bQoeItIwvjYqKhIbISaJNLWSU9vG4GATT5fJZutEI+vZnz8xZXz6DSquoyuaziO\n", - "juu2UvdCpJGy5UcDJTStF00L4vslbHsCTbsFIVRCIZXu7gyxmEc4vERnZ5zjx8/wkY98kv7+1YyP\n", - "v8zJk5OYZjft7YJdu7YxMzNCo3GWdLqD2dlpGg2LRKKdWCzEjTdey8033/AqUatjx47zgx+8wODg\n", - "jktBRaGwhKJM8Ed/9IVLO+ljx47z2GM/xbZ1fN9maCjNRz/6wV+qRkSIN+a4/FagUCjw4AMP8K2/\n", - "+C65kk5X/266u7fhOA0qlWPAPKrazsWLUyjKahxHwbbrOM4clhVBiEESiTBzc4voeh0pZ+jpuYZK\n", - "ZYR6fZ5AoAMpA6TTaS6OHcG2u9G1IHWrREsLRgKzBM0A7Z6GI2fxKVF127CI4NGLaggCgTiOo+B5\n", - "z2EYcYSIIEQd217E8xSGhzeTzxdRlH7y+Wk8p4iphQhoaYLCoCmnWT0YZ2BI4w//t3/OS08+yY50\n", - "mtDPSfkfv3iRaz78YXbv2fOO9P0v4q0Y9+npaZ5++jCTk3NkMkn27dvFhg0b/qf3HDnyIj/60Rkc\n", - "B06fniOVWg/A4uIEk5OnKJXOE1AF1WqZhqUhlC2g+PiewLHzeNIDljEooJPAI7RSkBqhzCweJTQR\n", - "RUqBREGINlRlGUEGxz+HlCXMQJhYbDu7du1jcnIUKRvksufIBHtJxXqYWR6haUUpN07h001b+z4s\n", - "a4JSKYvrSqLRMKtX78Z1a+Syh5BND12b4drV7Qx2Jol2JvjcH/8x0WiUb33rB2SzAlWN4PsVurp0\n", - "PvOZj72uhcbbjXfy9/5GMD4Oe/bAzAxc7adVf/VX8L3vwaOPXumWXI6VMX9Nns97KjOSzWYJ+v5l\n", - "gQhAVzrNU2Njr+u5kE6n2bFjPRMTR8jlDjI3t0Am08Xg4E7q9SzJpMbS0jCz8xYhYWJ5ORQcFEI0\n", - "aBAUAoSBoQo8v0Rn55qVVG8Kx5llcvIYvu+iaR5CVPB9g2YzgK67aFoAz7NQlCCeBy3mRCdSWkSj\n", - "JprWw9JSE0V5BUVpJ53uIRx26OjoxDRddu++henpaVS1RcsdGtpIuVzk5Mln6O29lsnJ5+nri/Cp\n", - "T/0x2WyW++9/hMHBzUSjSWy7yRNPnKVarXHXXXdc1ifXXruV6ek5jhw5RKt2xSYadbj33nsuS+lv\n", - "376NzZs3kc1mV/Q90m/5uL4dSCaTfOFLX2LD5mv41rf+mpGRItPTz6CqZa69thcpNzA/HyAUsiiX\n", - "fWzbx7ZnSSY34vseudw5fH8IXV8iGGwg5TKuO0EyGcU0e9E0iapCOrWahekLaEoGRdRp2jGkbEOg\n", - "4Mtxms0sFS2JL5qElQCmp+LLLIg6vh+nVssBFXy/gpRJFMWjo2OQUKiP5eXzSAmx2BCuu0QwWKUu\n", - "PVwsqvY4IgiZ5CAbB9fhe+M8/N/+G0OJBKFfOLIcamvj7EsvXbFg5K1AX18f993X96bu2bRpI088\n", - "cRjPS+E485w9O08wmEZVizSbowTVDF3JAcbqr+BLF98JIAUEApJIdAfl8jmQM3QaQSr1RWpSwaKB\n", - "R5ggKmpgPY7v0bBnUWmgqgbJ0FokJg1LRdefZ901Q1QqC8zMPE61XKWtLcHGm7czen6C6ewpFnI5\n", - "JDV8PJLJTmx7EjDw/SkUJYKUHtXqKLXaBUrlOpYFmuoxUw7ix7rplQahUIhkMskf/EGrHqxQKJLJ\n", - "pBkeHn7XK+u+k/jmN+Hee6/+QATgQx+C3/99KBbhHeQO/Eq4qr+JlmUxPj6OZVl0dXURDAZp+v6r\n", - "go5as0koGn1dQZ+JiQkunHgRvTxNPJqkqAvS6R6WJg9RLU7Qv3aAvr5eHKdCITuF0GP4joFNHY0E\n", - "QgaoyRplu4JZy5LNZkgkdgPzuG4MVZX4voqUEwixFUVx8H0Xz9MRooFhrMdxSrTqRgZQ1WE8bwzb\n", - "FrS1DaPrLq47TiJh0NbWSTIZp9EYY/v2nZhmkI0bu6nXz3L27Ay6HiSVgj/5k4+xadN6IpEI3d3d\n", - "CCH4/vd/RCKxjmi0xTAwjAADA1s5cuQg+/ffeBmlT1EU7r77Tq6/fpmFhQUCgQCDg4PovxDotd7H\n", - "uGqpozfddANbt25hdHSUXC5Hf38/ExPTHDq0xObN61hamueJJx5DUQaYmytRKs0SCHTR0dGJYRRI\n", - "pUw8L86WLXsYHt7Ck08+SqNR4YYbduO6kuMvXSQRjrK0eAgTgyQ6VUpYMg7EkETw/HYUM4LUPCKe\n", - "pI0uKkaDgtWg7o0gUYAUnmfieS653AUMvRsNjaX5n9LWuQchogjR8otRRAK7cZ5IuEBHai25cp32\n", - "hEJCUSgUi6/ZD/67aIf6TiEcDnPDDdfw1a/eT60WQFEqlMsjDA/HKRVMmkWDhdwUifAOGtZZ6m4O\n", - "XetFOKPQOEhSeLhKHemaxI11hGyTktRQEQgxj+NVUIQBVAiow0ilStObxvNBiDqGqnL7rTtJJ5Oc\n", - "ePJJFmWr7iR7apRoJIOTCtFhDABhbLuKZamEwxLDUIhEVqFpJqXSOPl8mULBxvO6EcLBcRbJ14r8\n", - "xs0HqNUKvPDCUe688zZ0Xf9Hs0W/rnBd+K//Ff7u7650S94axGJw4AD86EfwW791pVvzxnDVBiMz\n", - "MzN8+9sPU6+3VEt9/1l27x4mNTTE2MwMq1cWR8/3OTc/z467737N95mfn+fh//Jf2JVMYMQWCIUT\n", - "5M4dZHb2DBvb1iJEnXarwvjSLKYZpbN9E80KlIuLRJU0dW+WBsvorMcXgnAYJiaK1GqHcJwA0IHr\n", - "eivCZRZSTiKESUu8qoGud+C6TYQYRlWbSOmgaQqaFsL3a3jeFLXaJKaZw7Yl58+fJxZL0dvbx6FD\n", - "z6JpNlu2tKMoKpXKItVqg5tu2s6dd37gVZXx09OL9PSsv+xaSwckcslL5hfR1tZGW1vbWzBi717E\n", - "YjG2b99+6fnBg8eIRjMUi0WefPJ5JierNBrP0mzOoaoe4bBAyiDh8AChUILJyWe5eHGOjg6NLVti\n", - "rFmTZOvWa2g0Ghx98TBW4TyD3gI6CSBBg1Eu4tLgAELkcMQcMSWDqSVo+McJmzF0ox1h51BI4xED\n", - "NqEoLTuAZm2ExdlJksFBNEWhlJ1F0ZO0t+/F8xQK+SaGriFlhkptjqDhs74/RSJicr5QoGFZBH/u\n", - "uzGRzbLpgx985zv+TaBWq3H48IucOHEeXdfYu/catm/f9ivt7JvNJs88c4Lbb/8dfN9DSkkut8Cj\n", - "j/6AQiGF4TvkKyWioSLhYDuON4HmHqdP0Yngoioadddjwa8QMXWEEMQxqEmbhgyiewsoSpmAZhEw\n", - "SqhmHyGzB03VaTqLVKtz/N3jz2MuL2I2LfLlPOuTbayOJzk+fo54cjXBVBe2p+O6PkL0YduL9Pam\n", - "GRgY5Nix41QqBRqNFLq+a8WtOY+i7GB5eYpjxw6xe/fNTExMvoUj8d7E449Dby9sfv0yuqsOH/tY\n", - "66jmaglG3t2mE68Dx3H4zncexjDW0t+/jf7+TfT3X8fhwzMMrluP3dPDoclJTkxPc2hmhqGbbnrd\n", - "FPSLBw/Sp+skIxEGBjLksudJeyWitSUWyiOYyRjJcIJuzaJWydE7uAVVESiKjiJMNIIowsTUJeGA\n", - "2jKrKpRwXZ1wOEMo1AEk8TwVKYv4fhJwEWIMRRFEIoP4fhFVHUFRLDStiBAnUBQNx5HMzp7C88qY\n", - "5nqazQia5lKvw+KiIBDoQdfbeeaZMcLhDezY8RF27vwEFy44PPro46/6rO3tSarVy3fGLd+N2hU7\n", - "N343orMzTaGwzAMP/HdGRxcIhXqJxVYhRA+BwBBSZqnXHebmFmk2x3jf+/axYcON6Hqdj370dkql\n", - "MR588Ad897s/opDP0ql4ZMIRDNVEpUpcDdJJiHA4gGGGwYhSsissVSsUhcucX8fFo+nmkQTQ6UNV\n", - "FUDDcQCC4PZRbxRIGlEUqZIvLJHNHsayRhDKBTy/gJRRsqWzrO1z2blumKphcOdv/iZHFxcZmZ1l\n", - "anGRlyYmCKxaxbYd715Pkkajwf33f5ennppG09bjuoM89NAJHnzw4V+65sC2bZ566inGxuYplbIE\n", - "AmGklBw/foqOjv1oRhvRyADpWA+6JuhvTxMNZehUTXoT/SSTCdau3UMq0k2aADl7AYcGPk0QKi4h\n", - "hNKgqy1NJGxR9ywS4QE0VaNUL5ArLuCLdi6Oz6D5SbKeSaHu88JClb8eW+TlimQpV2Fu4hAbN6bo\n", - "7c1Qrx/HtpcZHAxj2yWEWEZVG0AY1y1j2+MIUSceH0RVBzh//mWq1RLt7VcRpeIK4f77W6Z47yXc\n", - "dRccPAhLS1e6JW8MV2VmZGpqikpFZ2DgH+oTFEUhk1nF6dOjfOlLv8PCwgL1ep1MJnPJ9vy1MDcx\n", - "Qe3CRU7kGwhhtoIG4RAM6Cz7CZwllfMLJ1nTFyDRsDEDFr4mEaqD55eRAixMDC2K0EykzKNpJori\n", - "4/s2zWYTz3NpiRfFEELi+1Xi8VWoagEhDgI5dH0t4XAviuJRr1soSoV6fRzP0/C8JNVqB4qiUyzW\n", - "aGvz6e7uY9++vRw8eJRkcifj4xdoa+tFUVT6+jZy4sQhbr31cmnnAwf28J3vPIVpbsM0g/i+x8zM\n", - "OTZv7r8kdjQ7O8tPf/oC09NLdHamuOmm3QxezTy3XwI7d17L1772h4yNFQmHN1IoNCiXTxAOdxGN\n", - "DtFonGbjxg1YVp1QyGZ5eZlKReXUqWWeffbbRKNhenrizMycxq2PIbw6aBGkdPAJoAqdmG6QpYmi\n", - "2/i+iWIGcGwVTQ/iiSK5ah6fPBpt6EYQV4RWmFU1BCF8USVkSLKVKsHIGoKmJBTSsO0KkUiNUGaA\n", - "enmW7Wti3LRlNaeXlth2663sO3CAjZs2cfb0aRq1GjevWcOaNWveUIbB8zzGx8eZmZkjGo2wbt3a\n", - "dySIPXXqNEtLGgMD/0DTDYe3cfr0YW64YZr+/v439X65XI5vfesHjI9XGR/3mJ8/im0/iud5FIs+\n", - "nZ0RwmGJosVxypP4boRyrUTDmqNHCWJZdUwzzNLSIq7bxFQiKEaSqr6eemMZHxVFuITTBjfe8UFq\n", - "tRyHnz/LYuE0lgWqouBTo+mGqOd8jlVLVJsQUXbguzV818MkQ9Uu0d6+mtnZLPv3X8/OnVs5ffrv\n", - "SadzHD58lJ07r8OyXObmTDQtQLPpoutJTDOKbQt836XRmGLv3nve6iF5T2FqqmUu9+1vX+mWvLWI\n", - "RuHuu+E734E/+qMr3Zp/HFfSm+YLwM/oLf+PlPJ7b/Rex3EQ4tW1C7pu0GhYCCHoeoMOR3PLeXLT\n", - "Jdb0tc5SVTXMmfIIdijFddtuwNRDKEKwUDxHT1eW3btX0ZZWGT1uU6nqTC9XMNQIiXgXNbeIakQo\n", - "Fl00bRTLKuM4JkLUV5gyVaTMIoTE8xps3LiP/n6VXO4sZ84IgsEOSqUi7e2baTSmgBlsO4Gu78L3\n", - "fQwjiq4HKBaPU6nMYVkWjYZFPD5MNnt0pZ5gHsexqNVsqtXqZcHI5s2bueeeBo8//jy2rQI227ev\n", - "5o47Wqr8Y2NjfPObjxAKDRGLbWZ6usBf/MXD3Hvv+9m0aeOrO+89Cs/zaDbBMDoRQuD7Dpq2GkXx\n", - "kNLHdRWSySFUVeHkyf/O4OBeMpkeyuWXCAZXoSg+lpUnHu9AkSEC9TniQYOGPQpODcdzqYoqTfsl\n", - "otFNVKs27e1dVKtnseoqmrYalCKGHkF6NpY3RiB4E45jI3BQaBAzLUxNw/M7MNUoulqhv3+IoaH1\n", - "zM4eYcuWYWq1Nq7b2U2sv5+911xzadFub2+n/ZZb3lSfWJbFd77zQ8bGKuh6EtdtYBjP8dnPfpiB\n", - "gYG3Yxgu4fz5CWKxzsuuCSFQlCQzM7NvOhh5+OG/o9nsZNOmbiYmnmB2dpp6PYKmSYRIMz4+xbp1\n", - "UTKZDnRziIvjJ7BUk1RbgMbSPGnVQNfbVkTNEkh1DqkZoGbQzQiue55gcIFrrtnD7t23cvbs8+zZ\n", - "6zM/b9JsaiwsnGNpSeC5JhKVitWBItK46CgKaEodRS0TCPZgyTqRyBrOnDnF6tV93HXXPo4dG8f3\n", - "VzE3Z6AoATwvSySykVCog0plhmZzEds+x+rVq/jUp26hr+/NFfb+uuHP/xzuu6+1eL/X8Nu/DV/6\n", - "EvyLf/Hu96q5kpmRx6WUXxdCaMBh4A0HI61iyRKu66wIcbWQzc5w881r3nADHMehYmuUA1FqVp2w\n", - "GaLZrNHUIiy4BruCMQy9JcldtcNcs7MTKacZXt2Da9V45fQxFH0cVUlRsS+S6ejGtlNo2hTBYBeq\n", - "2kYul8f3s7T8Jdagqu3oehIhCkxNvcz27Zv52tfu5xvf+Et+9KMXaDYVPO8UqZSDEFFKpR6ECOB5\n", - "5RWKrYeq9lEszhGNRonHw1QqWXQdnnzyEep1DSkNKpUzPP30EJ/4xOXsl927d7Ft27UUi0VCodAl\n", - "vxgpJX/zN0+TSGwgHs8AYJpBQqEojz76FOvXr7sqhbF+GZw9e57e3k1MTIzh+8soioOi2AjRS72+\n", - "SCxmYtslpATL8ojFumk2awjhEQzGCYejTEycpVyuk0jtZrE+D+UFTHMVimJT9aZphruIa0FqtZNA\n", - "CMsSaJqOZ7RjGklMz8RzFTyh0XQnUNVzqKqGRwUhZoloXbiuTSScRALhqEs47FEozOI4knp9hPvu\n", - "u4sDB/a9JX1y6NBhxsZsBgd3XbpWqRT43vce4U/+5PfeVlZGLBZmYqL+Gq84hELB17j++iiVSly8\n", - "mKWvr+Us3dlpMjKiYJr9VKtjQJZAIMn4+Biq6rNnzzquvbaN667r4dFHf8r5Y02SZjsJM0Gz2aTp\n", - "OSzZLh29KQqFYzQaFTQtgaZ1kcvlWVqaJhj0WbUqwcxMHgDfb0NR+tC0ZTxvDa4XRBVgexqa4mKQ\n", - "RgQqRKJxKm4BKRssL1/gt3/7Jg4fPkdn524uXnyFZHKAcLid5eWvU60eRFF6UBQbeIVbbunj29/+\n", - "/wiFQr9y/7+X0Wy2jmiee+5Kt+TtwU03gWXBiy/C7ne5afeVNMr7WVWVR8sB7A0jFotx6607+du/\n", - "PUIsNoRpBikU5kkkquzZ86E3/D6O4xAOJ0nesJWRU88iCgssVXLUulajOVHGczmihkETiHb3smv3\n", - "Bvbvv44jR47T1TXI+i0Kx4/2YwbiVKoVpqcX0HWV/v40S0vTOI6GlC3nXeghEFiDprn4fpFYLERH\n", - "Rze33fY+Ojo6+Df/5o+54Yan+dM//RpCRAmF2ikUplEUD89roOstCy1FsfH9Kp2d7RiGwZo1/Tz+\n", - "+EOEQgrx+B5isQTF4hw7d97BqVN5hoZe4rrrLq+X0XX9VUWpjUaDxcUK/f2Zy66HQlFyOZ9isXjV\n", - "0HZ/Vdi2g21X8LwmjtOHaSaBCYrFU8TjBu9//0cZHT1PLlcnkYhQqeTwvCJbtqxlaqqOEAlMM4Ci\n", - "1BAiQEGEyVlZQmSxnCZ1NUYkuBadEsFgiXj8ZpLJNczPHyQY3EqzOYMeiKD4NVYPrCOXUwiFLGZn\n", - "LxAKxYlEEjQLDVQfSvYSvoA779jP9u3Xks1mmZkp8uUv38W2bdvesj45cuQMnZ2XV/dFo0mmpjRm\n", - "Z2ff1uzI9u1bOHLkYWy785KdQbVaxDDKrFnzxjcfAK7rIoRyiVnnOA4bNlxLsynJZoN4nkWlIlHV\n", - "PsrlIC++eI716wV79/4GIyMWicRaTrzwHDPVaTzbZtGvorT1k8mswnWXMM0eyuU8kKVQCPP1r/+f\n", - "fPzj+9mzZysPPfSfmZ938P1+VFXFMOLU601ULYOUy3iKiSdtdN1EqgoyJLj1xvfT1zdMNJqgv7+X\n", - "gwfn6OnpJJVqaY3E4xn27Pk4S0sHKZcnWbUqzWc+8wXuueeeKyo6eLXggQdaiqtr117plrw9EKLl\n", - "s3P//f8UjLwR/B7w8Ju9ad++m+ju7uSFF05SrRbYsWOQnTu3E4lE/vGbVxAMBmlvj2JZEfb+L/fS\n", - "aFSpVos888xBeiPtbN91DY7jEIlEyeVeYevW9XR1dfHBD7bz0ktHefLJIuXqWTb2r+G66w9w8OBL\n", - "SNmBZeXo7jY4c2YEVU0jpYqmteP7DTwvgOcV6e9PsHfvNjyvNSnW63VefPEVOjp2UKvFSSQ66O62\n", - "OX36BXQ9gKaFsaxZ0mkFRakzPDzI9PRLKEqDT396J488cgrbLgJVtm4dYGhoiGazyqFDx18VjLwW\n", - "dF1H0+Srsk2+7yOlS+DnRLLe62hvTzE3N8eOHbcxMjJBsVhEVUNomsHwsE48Llm3LkI0GuPUqXGS\n", - "SYtNm3ZhmiaLi8+ztDRCb283uq5x7tzz1OsF9MBeil4IdFCVIqlUN7Y9gWEMkUolaDbrqKqGEBJN\n", - "iyPELNdfv4N4PM758yNs376OgYEDzM259PVtY3l5ltOnj3Du3FmuvfYAe/fuXmGEVNmxo5+tW7e+\n", - "6nNZlsULL7zIkSMvI6Vk+/YNXHfd7je0e/Y8D0V5dWZMCAXf99+Sfn899Pf3c/fd1/Hoo88hZRTw\n", - "CQSa3Hffh960E3QqlSKVMimXc8RiaQIBk3LZIxQy6enJ4DhhenujTE4eJR6PcM01B3DdOZrNJopS\n", - "Y+vWGxkaWs/ExAiu6xAYmSCTidJoNFDVOKZpY5pLJBI9pNO9KEqG6WmLF198lK6uHThOFVXtJ5ud\n", - "IRSKYlkTSOkgpUUg4BCLpZHSJR5vZ3AoSiaT4ejRxxgc7OR731tiacmnv/8adu26lqNHT5HNjmHb\n", - "DTIZg//4H7/CTTfd8LoSBv+EyyEl/Kf/BP/u313plry9+PznYcMG+OpX393y8G97MCKE6AAe+IXL\n", - "81LKTwsh9gAfAD78Wvd+5StfufR4//797N+//7LX16wU3/0KbePOOw/wzW8+gm0PEYulURSVeLyK\n", - "ovicO9dSCFSUCnv29LNu3ToA/sf/eISjRxfp6NjM+vUhjh8/x8TEGAMDGzh9+iyJhI+mxenr20Es\n", - "lmZ29gxSVhAigaKUGRoaYt++PUCegYFWbcvp02colYIcOHAbr7xynosXJ8lkBujpOUOz+QpSdqLr\n", - "Gp2dKh/72J184hN347oumUyGxcVFlpdNurq2oqoqitKajHTdpFJpvqG+0HWdXbs2cujQKwwMbLl0\n", - "fW7uAlu2DL7pSf/djkKhwMmTp8nlSvT3d7F58yaCwVbKPxAI0NXVR62WZ+3afmzbxrKK9PevYtUq\n", - "l9/6rdtIJpM0m00OHz7M3//9UYrFBRKJNKtWxRkZeZ5Uqh/TNJicnKOtbRfLy0UsK4quQzrdDywj\n", - "ZYNm02d5eZyWsJxKpXIW3w/T16dz883XUSot8v+3997hcV3Xoe9vTy8YAIM2g95JohEEexObSIqk\n", - "iiVZvVuUYl/LjuPY1765L7kvyed745c4fknudfIiyZIVx+q9kjIlUWITKRIkQYAAQfQ+AGYGmMH0\n", - "ct4fA4Gk2EmAA5Ln933zcXgws/c6Z+1zZu29V1mwYD1PPvkQKpWK2tqDfPzxLpTKKPPmFXHvvUtx\n", - "ODx0dn6BQiFRVVXEpk23njYrjkQi4z4fQSyWMoQQfPZZB01NbTzxxIPnLZBWUzOL3bs7yM09ERru\n", - "93tQq/3nrPs0WSxatIDKynJ6enpQKpXk5+efMefN+RBCcOedN/H88+/gdmdgNps5enQfZnM+qalm\n", - "Rke1qFQKiouTWL9+E2q1lv7+CAMDw6xbt5APPjiA2VxCZeVCnM4BEhP9jI3Z+fzzQ4TDBVgsaWRl\n", - "VZCTE1tFsttjeWG02gry8xPp6/sMIUCpNOBydVNYWIrfP0g4rCE9XaDRBHC7W7FaE7Fa0/jqq62U\n", - "li6lpKSakRE79fVvotfvo7JyEcuXL8LtdtPWVst99z3BDTcsB2Jbrm1tbTQ0NKNQCCoqZk44oQ8O\n", - "DhIMBrFYLFdd+v/JZs8eGB2FDRviLcnUYrXGImueeQZ+/vN4S3N24pYOXgiRTcxIuU2SJOcZ/n7R\n", - "6eAvlZ6eHrZv/5Kurn5yciz4fC5qa7tpbR2gr28YjUaipMTC2rWLWbVqEb///R+xWOZit9sJh8P4\n", - "/X4aGw+RnR1Gq1Xh8+lpa/MyPOzEZhPo9am43UeJRJIxm9MpLbVQWhx3rgEAACAASURBVKpj5kw9\n", - "3/veI2i1Wl599R1aW5WYzRaEEITDEXw+H1u3foBe7yEpyUokEouYqKhI4wc/eHziYezz+fjlL/+d\n", - "jIyFqNUnflT6+tqoqtLx7W9f2NZVIBDgtdfepbGxH4XCRDTqobDQzP33335FjJGpSg9ts9no7e1F\n", - "rVZTXFyMzWbjhRfeJRJJQ6834fU6SErysnnzfaSkpNDW1sazz25Fp8uju7sfgJwcK1qtIC1thDvv\n", - "3Mhzz73MJ58cxO2OEo2OkJysYu7cOcydW0FOjhWj0YjRaORXv3oBtzuDnTu34PWmkJFRhUZjoKvr\n", - "E3Q6B0plAZmZ5YTDLpzOXvR6H6GQmxUrbiA1NYGsLC0PPngnycnJSJKE3+9HqVTi9/vR6XRoNBok\n", - "SWJsbAy1Wn3WFazm5mZ+97tPT/H5AOjoqOXeexeecSXlZNxuN7/97csMDioxmTIIBDyEQv3cf/86\n", - "KisrLks/k6H3kZEROjo6ACgoKDhnOYJIJMLg4CD19Y309w8zMjJMd7eLvj4vXV2jpKUZWLRo+URR\n", - "ya6uo2zaVMrSpYtpbGxk165anE43ubnpNDa2IkQ+IyNO6utt+HxqRkeHqa5eCsDw8FdEIm6Sk5dg\n", - "MLhJTJTYsmU3Pp+ZUMiNwRDAaBzmttuWUlhYSm6uhdmzK0hPT+cPf3iNjg416enZqNWxDMvNzc3s\n", - "2fMeK1duJCEhmbGxAYqK9Dz88N1otVokSeLttz9g374ODIYsJEnC5+ujujqT4WEX/f0eFAo1anWQ\n", - "W265gblzJ28r72KJdzr422+HdevgqafiJsIVo7Y2dr6trXAJNvykMV3Twf8VkAG8Ob6suFGSpAub\n", - "xk8i4XCY1uZm7O2NaP1+bO0O2gYksrIW0tnZQHX1GoRQ4HQe4vhxH21tL+F2J1NXt4twWIcQCiTJ\n", - "S1ZWHuXlaqqqZvDhh5/gch0lHDai16uRJCNqdQGBQAs9PfV4PBGKi9eyfv0TEzNSpTLK3r3bCQYV\n", - "qNVKCguL0evNeL0hFi5cRn7+iRlpR0ctx44do3I8Q49er2fDhsW8884+kpKK0OsTcDoH0GiGWLXq\n", - "gQu+FlqtloceupuBgYGJJGhfZ2+9GpEkifff38KePccRIhlJCqNW/xG/30tGxmJMJjOBgI/e3i4+\n", - "/3w/H330KTNm5FNZOYtAoJeEhBwWLIg9rCORMB0dX3HzzSt5/vlX+fTTXjSaRRQUpBAK+bDbD1Jb\n", - "28jQkAf/mB9HzzF06jBeRQKLlj9CSsrd7Np1gEDgGG63B4Wil7lzH6et7UsikT5ycytJTDSSmupm\n", - "+fJcVq1aSmJiIrm5uQghaGpqYsuWHQwPj6HVKrjhhhpuuGEZELvBzxdi29HRg1abdtpxozGDlpau\n", - "8xojJpOJ7373IerrG2hr6yE5OY05c1ZhsVguUTuTx5df7uWDD/YQiSQjBAjxGbfeuoxFi07dJA8E\n", - "Anzx6afU791LNBwms7CQGzdsIDs7G7fbTV1dHX/4w0eUlq7BaIylA/B63SiVDsrLY/dfWVnZRBbT\n", - "3bu/pL5+jLy8EhITRzlyZD+DgyGcTj/JyXUkJEBhYSY2mwKfbxSDAfbvb8fnUxAMtuHxtGEwWDEY\n", - "UsjISOexx+6dWK2IRCJs3/4ldruWaFRBQoKOyspqZsyYQSg0j6KiMCZThLKyRZSVlU1MTNra2ti3\n", - "r4OCgsUn+cVk8cwzTzN37jJKS2NGkt/v5fXXd5CamjLl0VDTkaNHYysjL74Yb0muDHPnxioRv/EG\n", - "3HdfvKU5M/F0YP1evPo+mS3vvkv/V18xPzsbnUbD53u+ZLB1lKEhDQZDFkpl7CZXKtPxev309HTS\n", - "3HyIoqJ1pKRYx42RKI2Ne7DZbNjtBrKzV2E2B7DZWlAo7AQCfvx+CUlSkJiYh9Wag0o1k5df/pin\n", - "nkpFpVKxf38zLpcas7kCtVpDc3M7IyN7MBj0ZGYWnCKzTpdCT8/AhDECsGTJYtLSUvnyy4M4nTYW\n", - "LswhKSmHd9/9I+FwmOrqmVRXzz7vcjyA1WrFarWe93PTnYaGBnbtaqOgYPGEv0N/fwe7dr3JggUZ\n", - "2GwDtLU1olYX4PPl0ts7ikKRSldXPXl5Fuz2rYyNlaNQaAEX69fXoNfraWsbAVIxmWIbsGq1nlBI\n", - "RU9PiLDXxgxdiIrMMgL+MZoHm/h8y8ssvfFuLJZMNBor/f21aLXgcHSh0ympqrLg8fRgMnkpLNTx\n", - "3e9+55QtiJaWFn73uy2kp1eSlxerKbR1awNjY15uueXC1phNJiOhUO9px4NBH0lJF2ZQ6PV6FiyY\n", - "z4IF8y/o81eC/v5+3n13D9nZJ1YFg0E/7723h4KC/AljSZIk3nr5ZfzNzSzOykKtUtFvs/H6M8/w\n", - "wFNPkZ6ezrJly0hMTOLNN7dhtycghIQQLmpqitm3rxarNY2ZM2dO3EPt7b0kJKQRDPrZu3c7SmUe\n", - "mZk+nM5aOjp2sHLlcubMWcaxY7Xs3r2XQCCbkRE9Fks1PT3bSU9fg9GYQkpKOm+/3Uhq6ps8/PC9\n", - "CCH44IOt9PZGSUyswGBIwu8fZc+er1i+XEVCgpabb95wxvQFDQ3NGAynTiAcjhGCwTQikRO+PTqd\n", - "AaMxnz17Dky5MWK329m79wCdnQNYLCksWlRzRbb2zsU//AP88IdwPQUb/fzn8N/+G9xzD0xH3+bp\n", - "4MA65TgcDoaGhjAYDOTk5EzcqA6Hg+MHDrA8P39ijz3VlEiu2seBznqyi4sm2hgbG+TQoW7cbjUj\n", - "Iy6OH28mLc1JYeEsIIrb3YFen0NeXiwfR1XVHLq7vQwODpKSkkoo1Elq6hySkrJRqbwMDnpJT89m\n", - "z579aDRqtNoC1q6t4eDBelyuKKAmFBqjoKB4IoLga0IhD2bz6bkDvvahkSSJN954lx072jCbC1Aq\n", - "lbz11mHq6o7x6KP3XtJe+9XIV1/VYzYXnuJ4qVar6esb4MCBTnQ6Aw5HMpGIj3BYkJRkwWKZhdOp\n", - "IDk5EyESuO22uSQlJRGJRDAYDAwPDxMKKYFTr+HoqBOFIpngYCvFNfMRQqBJMJMXyMCaEKWp4T0K\n", - "CkpoaNhCKORgeFgiEEghMzOXnh4HZWVFmM1pVFRoTtPPtm27SUmZNVFTyO8PodVa2bbtK1asWHrG\n", - "NP7fpLx8Flu27MHjcWE0Jo634yESGWD27DWXeaXjR0NDE2q19ZTtSY1Gh1JpoaGhccIY6e3tZbi5\n", - "mSUn/fBmpaXh6+9n/5dfsvHW2FZmVVUlpaUldHd343Q6+eMf97B/vwONJkww2E5Kym42b76P5ORk\n", - "UlOT2LPnGDabjYEBifz82ORArU5BiFE6O9vJzNxBUpKCm28u4YMP6ohEtNjth9Hrs8nIqCYc9uF2\n", - "j5GcnEdDwwB9fbGQ/X37jjF//ioOHuxCrzeh0yURjRazb9/n3HRT1VknCwrF6VsfwWAQUBKL6jtB\n", - "LFKu63JVcE76+/t55pnXiEYtJCZmU18/woEDr/Hww/Fz1OjuhnfeiW1ZXE9s2gR//dfw1lvw7W/H\n", - "W5rTuaaNkUgkwtYPPuDY3r0kCYFfktBlZXHngw+SnJyMw+EgUREL87Pb7YyOjCJJETQiiIYIXq+L\n", - "xMQ0wmE/PT2HMZlqGB3tR6Mpxu3uwO3uIBodICPDSGKigdTUEwZCamoK6ekp+P0FpKdr0WrnYDKV\n", - "4vWOkpKSSCAwRmJiGl1d7SgUChITc0lISObGG1cwNjaGENDXl4jH08LY2AgJCbE9cJfLjkrlpLz8\n", - "7AWvuru7qa3tprDwxFJtYmIqbW21NDY2Mnv27Km98NOEQCCISnWqk57TOUQ0mopabSUSGUGny8Tj\n", - "8TM2NkZOjh4hQKOJjQ2r1UJfXz9ffFGLyyUQQonH04fb7UaSTl1N8PlG0WgSydDpCIXDuN0uIhGJ\n", - "SCTK8opyMoXg/j95DIfDwf/5P2/S3h5Fq83BZDITjYY5cmQfZWX9LFjw+Gnn0dMzSG5uOaFQiP17\n", - "9zJms2FQqbCNHud3Tz/NE9///nkjYpKSknjooZt55ZWPsNu1gECt9nLffevIyMi47GsdL/z+wMTq\n", - "5ckolWoCgdDE/+12O6YzbDemJybSPu5r8jU6nY7S0lL+/d//AyggPz9n4m+9va387ncvUV5ewvNP\n", - "P81Xe3vw+Y1EKcY2sJ8ZM4swmWDt2ptpbj7AunWlrF69mmPHjjE6aubIkT4GB/UolWUoFEoUChU+\n", - "n4ecnAyUSjPDw8Pj4ccJFBQUMjLipr39GEplApIURJIGuf/+28+6dVpZOYtdu94jGs2dMML1eh2R\n", - "SC8Wy6k5Z0ZGBlmyJOdMzUwaH330GSpVAWlpsZWQhIRkPJ4U3nnnkynt91z84z/GkoGZzXETIS4I\n", - "Af/jf8Bf/iXcccf0Wx255owRr9eLQqFAp9Px1b59dO/ezfKCgomVj46BAd595RUe+e53MZlMjIXD\n", - "7NtXS1+fCyEMSFKYQUc/QpfE6Ggjbncy0egAkmTA5QqQk1OI261Ar5+Pw1FPONzDTTf9lPff/z1p\n", - "aYkMDAwwNDRER0c/Tqcdh6MHozERSfLi94+hUoXQag1YramMjY0wa1Yq0WiU48fdJCQko1AIEhNj\n", - "+/86Hdxyyyb27Wukqys2mJKSBI8/fuc5fQQ6O7tQKlNPe2CZTJkcOdKMWq2mo6MHk8lARUU55mv0\n", - "rqyqKuHDD5snVhQg5qyck5OPRuPC5XLj8wUIBhXjdYJiTrrhsIeEhEQCAR8ff1xLScl6srOTGBjo\n", - "wOv10t1di0rlpr8/RFpaIT6fA7XajU5nJKRU0tjYQjSqGU+K1kGKRUvO6pVkZmZy6FA9FsssSkrS\n", - "2b+/DofDgd8fwu12YbWmn7H6cUZGMu3tLezedZDRvmFMBi0WswGLUYnOZuPj99/n9nvuOe/1KC0t\n", - "5ec/L6C7uxtJksjJybmgbbvpzMyZxeza9UckKX9ivMecNm2Ulp7wg/n6Xu/t7cXhGMVg0JGVlcmo\n", - "x0PKGZJMjI6O0t3tJC/vhHNuKBSirW2Q9vY9qPgjzg43+Ql5dEt9hCJBRoZ7aIr2csutaxkZGcFo\n", - "1JKXl4cQgoSEBLTaANXVlWzdupVweASVyojX68BoDFJRUUIw2EtCQgImkwmPx87evfux2UaRJAmV\n", - "ykNRUSZFRavPeb/m5+ezYsUsduzYi1qdMZ4xeJDVq0sZHe3DYDChVmsYHOxGpRpk0aKbJlEbpxIM\n", - "Bmlr6yc391QjyGhMxOGYsm7PSW9vLO17fX18+o83t9wSWx15+224c5pVCbhmjJGBgQE+ef99Bjs6\n", - "kID88nI6jh9nfmbmKWGOBVYruzs7sdlsWCwWXAoVHU29lBdUoRQKAuEg4UCAwqIMVq9ZQn19E11d\n", - "Ep2dY5SUZGOx5DAwMIjN5kSvz8HtPk5Pz1EKCrTU1e2lqWkGXV2DqFRKkpLM5OUZGB1tIxQKkpmp\n", - "JT09H6XSTXb2LPz+NpYsuYtoNMrhw2/h96eg08V+EAcHu0hLE6xYsYIVK1Zgs9kQQmCxWM6bzCgW\n", - "YXF6Hjmfz8OuXftpaHCg06USDg/y8cdf8dBDm5hxlWf9ic0mxSlZYufOreHgwSY6O+tITs4iFArg\n", - "dvcwa9ZsZs+eR2dnO7t3f4ZCkUN/vwOVSoXf7wIGSU+fQXv7bkymArRaA1988REjIwokSYt7KIrC\n", - "/zlGg4FjvSqsBcU88sg6enudfPZRNyVKPSk6NcGgnaycQva22pjzSGzVLBqNolAoMJlMLFu2gC++\n", - "2IPP50erTeXIERu/+c3zPPro3afUUyorK+DFF1/AM5JBdmopSFFa+45SnGWnumgZu+vq8Nx88wVF\n", - "PKnVaoqKis77uauFoqIiKivTqa8/QHJyHiDhdHZRXZ1xynmmpaWxr7WLepsHS5KVaNRF7eFj6Ioy\n", - "2fzoo6e1G8udcqoxf/x4K8PDUQyGdGxttRRZFyNFoggFjIR9eP0mhhxj1NcPAZ0olU3UVBnZ+sor\n", - "iEgEd38/XjHEggXl7NixH5/PQUKCxIYNq1EqQ6SlCQoKCohEIgwNddHVNUp29lwUCiWjo4McOLCd\n", - "e+89t6udEIKNG9dRVVVGY2MzQkBFxSrS0tLYuXM3u3fX4vMFqago4sYb75vSiYhSqUSlUhCJhE/J\n", - "XRQrznlReS4njV/8Ap54As5g818XCBG7Bj/+Mdx6a3wja77JNWGMjI6O8uqzz1KgUDAzNxdJkug4\n", - "fpxPtmzBmZ2Nz+cjOTmZqrIycjMy0CoU+P1+BgcHae5ycNwn0Vq3B2tKGuqkdPIXb0Kh9LN48Xwe\n", - "eOAe+vv7ue++n5Camo4QCjIzrSQkGOjqqkOIMCMjx2hq6sfj0TI0dAghrKhU4HAc56abNpKaamH3\n", - "7vfQagfQ6bykpKTidO7n5ptXEAgE2L59L05nD/X1h8nOLiIlJZG8vCTuvvuuiR/XM82Yz8bMmTP4\n", - "4IPd+P2eCeMmHA7R2rofs9lCQcGJCq1ebzavvrqFn/2s4KrMOzA0NMTWrdtpaupCqRTMn1/GjTeu\n", - "xGAwoNfr2bz5fg4dqqOhoRWjUUdNzZ1s396GRqNi5sxZZGSksGfPp4yNddLX14fdbkcZidLZ/AXz\n", - "5hcTNebS3FyHy2UkOTmP3mMfUiyU6HSZaFQB0nMyIC+ZzZsfpq6ujs5OB7aeLpz+bjJSUxlOTCGz\n", - "fCFHj7aSlXUEiyUVn+840Wgex44dZ2xMQ1ZWHnb7QWbPXsPIiJ+33vqQxx67f+Ich4ddlJeXs2/n\n", - "HsZ8Q0CQ4qwkEvRKHC4XKiEIBALXXC6YC0GpVHLvvXdQWdnAwYNNAGzcuJSKiopTjPbdu/eRUbCS\n", - "UUMv7UO9qITAo0ghU5N8xnsrOTkZqzUBp9OG2Rzbkmtv70Wp1KLXq+nwOBnw7QUBksJAVOXFNtJF\n", - "IGyit/cwOTkJJOgT2f7Cizx06wa0Gg2Vyclsq69HnWNi06ZiBgYchEJadu58E7NZxaOP3kEoFKKl\n", - "pYWsrCqMxgDd3V8RCglCIRfp6WmMjZ0pLf6pjI2NsX//YWprjxGNRhkaGmH9+pWsXh17SZJ0RSLk\n", - "lEolCxaUs2fPMfLyTjjb22ydFBaeHtk11bS1wWuvwbFjV7zracWGDfDrX8PTT0+vsOZrwhg5cvgw\n", - "KYEA2eMFocT4w1kzNIRKpWJJXh4jPh9f7tyJb8ECvIpY1sh/+7eXGBhIIKfobgIBF7axVuaWVpFf\n", - "UEFX10EikQgQKyxWU1NIQ8N+tNpcVCo9oZCd5GQPY2Na+vvDOJ0qLJZy2tubMZvVExEzdns/s2cv\n", - "Y9Giddx+ewX79x/h2DEber2F117bQXv7iyxdejOzZ99Ffv4wPT21rFlTyY03XrpTYXJyMvfcs47X\n", - "X99GKJQICIQYITERSktjeSYikVgeE41GSyCgo6en56qbMY+OjvL0068QjWaTk7OCaDTCvn0t9Pa+\n", - "xpNPPoRSqUSv17NkyaKJLLQx575t7Ny5GzADYWpqsrnnnhp+//wb5CpU5KdaSdbq6Wk5Tt2xV1Cl\n", - "VZGScgMuVy9JARch1xBKnQmFIgmDMouu+m5+/Q//wm13bKKiYiH5mx7D5xsjEPAxMNDDtm3b2LXb\n", - "RX39IGlpCahUPtra9lBf34XRmIvDcYiSEutEXovjx3cyOjqKQqEgFArR0zNIdfUygm4w+MdIMiai\n", - "UWkZcLZhczpRmM3nrEx9raNSqaiurj5nePL+/UfJz5+HpnQ+Ho+LSCREQkIyvb219PX1nVZMTgjB\n", - "HXfcxHPPvUl3twO9PgmHo4OkJD2asIfcqI9MhYRWaaDL1UVn0I/RcANqKUBGRg6RyChiZJAUvZFg\n", - "IIBWoyHZZGJVeTkDCQnc8xc/4l//9Xd0d0eYP38tkiTx0ks7eOutbcycmYckJTN37kI0miM0NLSh\n", - "1c7E6XTy9NOvUlRUQFFREU6nE7VafcqWbSgU4oUXXsVm05KZGcvGevx4N52dL/ODHzxKQkLCFQ3V\n", - "X7NmBQMDb9La+iVCmAAf6ekK7rzzLp544oqJAcSiSX70I7hOqlqcFSHgV7+C9evhoYdgujw6rglj\n", - "ZLCnB/NJs8JwJEJ9QwNLc3MZ8vtxut0kGo1k+/28unUrVetu4de/fhqlsoTy8ipaWlyYzTkkJGRw\n", - "7NhBsrOLUCrHJsLPlEoljz9+H88++w5ebwghJLRaE5991jLulJpJIKCmv98BBHG5YMaMLMLhAKFQ\n", - "zIlOkrzU1zfR3S0oK1uHJEm0tLQBFXR0DJKVVUBKihWDYSV799axcuWKyyo+VllZQWFhAW1tbUSj\n", - "UfLy8nj22ZcRQtDV1UV9fSuhEOPF3ez4/csvXQFxorb2EIGAmZycWNVWhUJBbm4ZHR37aG9vp6Sk\n", - "5LTvfL2MPX/+nIlEaPn5+fz93/8rKeiZN2smivGHtVFnxNu4k8auOkymhQQ8w2jG7IiogtTUfHw+\n", - "JxqNjtz0fJqP9Y0brw4ikTA6nZHGxoN89tkhQqF0Cgpm09sbIRj0YbEksWxZLu3tDRiNPiKRZMbG\n", - "1LS0tJKbm0MwGOI///N1+vvdCKGkra0Ji0ViVvUc6nbvRu0PIfRKxrzDdI6l8O0HH7xuihheKpIU\n", - "nfgR/jqaKHb87Em3srOz2bz527z99nscPVpPfn6IcCiRVFeA3PJ5NNcfJhw2o46ESYtq6QuGqKhe\n", - "TG5uLnZ7C56uI4j8bCLhE1sSqYmJHOnupr6+AbtdS3l5NXZ7P7t370KILIaHRwmFfHR3H0GStBw/\n", - "PoTVOhshFIyMhMnISOGf//l5MjMteL0gSRFmzszitttuIikpidbWVnp7wxQUnDDMrNYCurs91NUd\n", - "YenSJVNwdc+OXq/n8ccfoKurC4fDgclkorCw8IqP1y1bYom//uM/rmi305bq6pj/yP/8n/D3fx9v\n", - "aWJMM3/aSyM1M5MR74nlyzGfD1U4jFavp2bpUhSZmXT5fLQ5RnEHdai0FdTX22lqshMMhjAagzgc\n", - "vQQCAdzuIK2tn3PLLTecEqEwe3YVP/zhvSxalE1enpLMzDA6nZni4rWkpcW2OPT6UpTKVLzeLlyu\n", - "ETyeAaxWK729x8jJ0dPRMURWViylfCgUwOMJkpFRyOCgG++4/DqdEZ8vNuu/XIxGI1VVVVRXV2M2\n", - "m5k3r4yGhq/Yv/84Ol0OZnMRBkMmg4ND7N9fd9n9XWk6OwcwmU5f7lUqkxgaGj7nd9PT05kzZw4V\n", - "FRWEw2GGhkZJUWsnDBEAndZAfmYuJTlGnM5DRPAQUQdJS8smGo2gVkvo9XrcIT8JKfmMjnpYubKS\n", - "rq59tLXVcejQUUKhWEIrq7WUtLQKhoclolENAwMuKitL6OwcZWQkEbfbwNGjw2zduo0jRw4yNJRA\n", - "bu5ycnOXUli4in37dhAOjzF3xQqC5mSODLaRXJjMQz/+MZVVVec4UxmAefPKGRhoP+WYxzOKwRA5\n", - "Y74OAJfLxUsvvUdfn468vFXk5i7neMNuPEN9mFMs5M+YgV85SFgZxqzXkpWlJi8vtsKSkGDF4fMD\n", - "fkwnhV473G5SrVba2nowmTKQJInDh/ej1ZaSlJSHwWAlLa2ApKQCPvnkPTQaM0Io8HiGUCrtWCy5\n", - "HDjQg92eTG7uUnJzl9PWJnjhhdeIRCL099tQq0+f6hqNqXR2DkzeBb0IhBDk5+dTU1NDSUnJFTdE\n", - "xsbgBz+I1aHRX1yR52uaX/wCnn8eGhriLUmMa8IYmT1nDnaVikFnLKu8Vq1m2OMhpNNRXFTEnHnz\n", - "KKmsQpOYR2ZeGenpOaSkpGMyWejoGGLOnDKqqjJJSvKTkSGxefO3WLBg3mn9lJaW8uSTD/FXf/Vn\n", - "LF++kMTEXKLRCCqVZnym0oNSmYTBEMLrrcfrrUWvH6WiwsB9932LcDg64cilVKpQKCQikRBCKAmP\n", - "z56i0QgQmqiTMpksWbKI0dFmgkEnPp+dkZF2PJ4GVq/eRHOzDbvdPul9TiUZGWa83tONNknykpR0\n", - "/twbX6PT6VCrFfiikVOOR6IRQlKIm26+idtuK2PBwlkEk5Owjw0QDDrJz89i1OvGodKQkmrBZDKw\n", - "bt0aNm/eiNE4iNFoICsrkaKisokwS602g+FhOy6XB4/Hh1YbALwoFBJKpYTN1kQkYiQrq2RiJp+X\n", - "V8TcuSvo7NyBx9OINSfEk09t5J9+848UFxdf+gW8jlixYinp6T46Ow8yNNRDd3cTTmcd99yz4awr\n", - "kDt27GF01EReXiXJyekUFlay+Ibb8IedGI0eamoK+N5Tj7NoyTwqaspJTjUyOjpEMOgjEPDh1SjR\n", - "W5L5eu3F4/fTNDzMojVrSE42EQh48Ps9uN1+9PqYI2kkEiQhwciNN64lGh1jZGQfTuc+DIZBli1b\n", - "ycBAD0plLhpNbKIkhCAzswibLUJ7eztmcxLhsOe0c/F6XaSnnz1F/rXM978PK1fG8mzInCAzE/72\n", - "b+F734MprnV5QVwT2zRms5k7H3+cj99+m+auLiQgsaICo1aLcvxB09MzwHAogrWiGqVSRUlJKYcP\n", - "dyBEKmNjYxQXF2IyKUhL015Q6XW9XkdubjqDg72kpuaRkZGLVqvn+PG9FBSo+NnPbmfmzBJSU1PR\n", - "arW0tLRgtw/Q0fE+s2bNIT09h+LiYurrGzAaEzAajUiSRE9PI3PnllxQJdWLRa/XU1paTGlpDsPD\n", - "w+j1ieTkzCEhIZnu7lFcLhepV9GG6rx51ezZ8zJjY6kTeViGhnpISgqdcYvmbOh0OtasWcTvmtqx\n", - "uexYElORkBga7iFqNrBq40YKCgpobGwkN1fBmy++jkGvpTXkRZWURvGsBYTD3ZSXxwrQlZSUsGHD\n", - "jbhchzh61HnKHn00Gsbnc5GVVcTYmII1axZy4MDn9PQcICEhgfLyGbS3n76qU1BQil6v54EHbh9f\n", - "hZOneBdDQkIC3/3uwzQ1NdHe3ovZnEdV1UZSzlHG9PDhZjIy5hIM+untbWN4eAilUoFLl0xmrpXi\n", - "8QRqSakG6rpcbNz0IAMDdoaGHCiVffzwz58kx5rK7v37UUsSwdta1QAAFcpJREFU6PUsv+suysvL\n", - "SU1NZceOlwgEkpCkKJIUJRj0o1T6sFqtaDQqamrKSErKp6hozoQj+sjIftRq5WlRMEIYcblclJWV\n", - "kZCwC7u9n9TU2IqP2+1EiEFqatZP0dWdvvzDP8S2Z/bujbck05PvfhdeeAGee44r7sPzTeJmjAgh\n", - "HgE2A1rgaUmSnruc9nJycvjOU09NOP5ptVo+fOcddtbVYRSCw6NOojkzKZoRW/EoLCzH7XZx+HAt\n", - "g4OlCDGI1arh3nvvvCAHr9LSEnJzd2AyJdHZ2QaoiET8VFaa+F//6+cTobLRaHS8ym8PJtNsmpqO\n", - "0NGxjVmz8sjNLSIxsZa0tAh9fXVEox7Ky7PZtGnd5VyKc5KXl4XDkUxu7syJY9FolGjUfc7iYtMR\n", - "i8XCww9v5K23ttHdLSFJEbKzE7nrrrsuOjJo48Z12O0OPnj9PY53dKMihMlq5pEfPjVRrXnOnDnM\n", - "mTOHVauW8eKL7xMKGdDpDEAP999/0yk/bDNmlKLX76KwMI2WlnaMxnQUCgV2ez3LlmWxcOFcGho+\n", - "4siR/bhcetLTlxKJhGhvb8Tt7j5NPpdrmJkzrde1o+rlotVqz+voejIajRqPZ5T9+/fg8RjQaMxE\n", - "Ij5sIQN7bDbs488J1YxillWZGB1tIynJiMkkUVY2l7vvvg2tVsvqdevw+XwkJiZOrMJYLBbuv389\n", - "b765DbXaTXf3XtLSLCxdOgedTktv73FWr17IyIgbm62N1NRcIpEwweAgaWnpp40DSXJjNpvHfTTu\n", - "4tVX36erqw0hlCQmKnjssduuqonG5SJJsYiR3/wGdu6E6zDQ7IJQKGJRNWvXxooGxrNMUTyr9qok\n", - "SQoLIRTAPkmS5n/j75NStdfpdOJyuRgeHua11/ZQULBwYsnc7/fS2fk59967HqvVSk5OznlzeJzM\n", - "4cN1vPHGJwQCJvz+IBqNhw0bFnDjjasmPtPS0sJvf7uVgoJFCCFwudy0trbR0rKb226bz223bcRk\n", - "MuF0OklKSiItbWpD3lpbW3n22fdIT68iISGZUChAb+9R5s+3cuedt0x8zufzcfjwEZqa2jGZDMyb\n", - "VzVRhnyquNQqnpFIhOHhYVQq1WU/cIeHh2lra0Oj0TBz5syzrkD4fD66u7sRQpCXl3fG5GGHD9fx\n", - "+uufMDQUpadniGDQxtq11TzxxCN0d3fzs5/9gu5uPcXFy0lMjCWpGxrqwOnczqpVt1JYOBulUoXD\n", - "MYDf38JTTz1Aenr6ZZ3fdCTe1VvPxs6du/jnf34dny8HlSoFh2MIr3cMnW6MVassPP743Wg0GjLH\n", - "cxn19/czOjqK2Wy+4NpOwWCQpqYm3nprK4GACSESAA9ZWWoeeeRulEol+/fXUlfXjFarpbQ0m08/\n", - "PYTBUEpKipVIJEx/fwtZWWH+5E8ennh+SZKE3W4nEomQnp5+Uc+1K8VU6f3YsVgNlrY2eO89yMub\n", - "9C6uOX71q1ia+M8/h8uImzgv56raGzdjZEIAIfTAFkmSVn7j+KQYI18jSRIffvgxu3YdQ6FIASIo\n", - "FE6+/e01VFdfenp0l8t1SsTKN42J997bwsGDHqzWglOO9/a2cMMNGaxdu/qS+75Umpqa+PDDL3A6\n", - "vahUsHTpbFatumGiJorH4+HZZ19kaEhNYqI1tv/t7ea22xayZMniKZNruv4oXQ5fj49IJEJ+fj5m\n", - "s5kXX3yDo0edHDrUQGurknAYzGY9GRmppKfrSUuD3NwITmeYaBRyclK55ZY15ORMberueDFd9R4K\n", - "hbj33v9Cb28Kw8MhlMoE1GrIyDChVrfyL//yY2bNmnX+hi6ASCRCW1sbIyMjmM3mc0ac9PT08P77\n", - "n9LTY0ehgJqaUtavX33V5ZmZbL339p7ILvrTn15/hfAuh2g05lMzZw788pdT18+5jJG4+owIIf4H\n", - "8CTwl1egL26++Sbmzaums7MLlUpJSUnJRS17BwIBWlpacDicpKenUVxcTGJiInPmzDnrd1Qq5Rlv\n", - "OEmKolTGZ7Yya9YsZs6cidfrRavVnubAt2/ffoaGdBNF/wBCISsffriHysqK85arlznBN8dHY2Mj\n", - "R486KCxcQG+vHa02lXBYhd3eTlVVDkVFxXR317Fu3ULMZjPNzcfR6XRXZUK6qx21Wk1FxQyGh0cp\n", - "KipEq9VgMiWiVCrp6Ginru7IBRsjNpuNtrZYNE9paclpkxalUklpaekFtZWTk8P3vvcIXq8XlUp1\n", - "3Y+N0VH4u7+DZ56J+T00N19/dWcuF4UCfv97WLIESkri4z8y5caIEMICvPyNwwOSJN0vSdLfCiF+\n", - "CXwihHhDkqSxkz/013/91xPvV61axapVqy5bHqvVesFLqCdjt9t5/vlXcTrVqFQmQqGjWK07eOyx\n", - "e89ZNbWiYiZffPE2kUguSmXscofDIcLhIWbNWnWpp3HZCCHOOpM6dKiZtLRTH4xqtQZJSqKnp4ey\n", - "srMX6ZM5N0ePtpCQEHMszM8v5KuvjpGaWgXkEolECQa9qFQu+voGeOmlbSgUsW2ZaPRL1q2by6pV\n", - "K+Io/fVHfn46kUj/RPVfAJ9vBLPZSE+P84La+OST7Xz66WEUirTxicmXbNq06LJzfkyFk/vVxu9/\n", - "Dz/7GWzcCIcPwzW6eHhFSE+Hjz6CFStiaeLPUCVhSplyY0SSJBtw2l6EEEIjSVIQCAGnF4LgVGMk\n", - "3rz99hb8fiv5+Sc2IPv6Wtiy5RPuueeOs34vLy+PNWsq+eyzvahUsdlQJDLETTfNPWt+g3ij0ajx\n", - "+0+vHSFJ4ctKxCYDWq2aSCQWepmdXczAQB89PQcZG5Ow240YDDZWr65m27Yj5OQsnggFj0RK+Pjj\n", - "vZSUFF2z2zXTkUWL5vPmm7ux2+tQKpORJD9K5QizZ9eg04XO+/2uri4++eQIubmLJyYjoVCQDz7Y\n", - "S3Fx0SlGjsyF4/fHcofs2RPzC5k///zfkTk/paXw6acx466pCf7mb+BKLbzF06vpL4QQnwG7gDck\n", - "SXLHUZZzMjo6SlvbEOnpp6aMtloLOXKknUAgcM7vr1u3hh/+8G7Wrctj/fp8/vRP72PlyhumUuTL\n", - "YtGiKoaGWk/ZXhobG0Gv95MfT3fra4CqqjL8/j4ikTAKhZL581eyePEc8vLc3HffPP78zx8lGhWo\n", - "1ZZTiosplSo0GgtHjzbHUfrrjxkzZrB4cQVz5hQyY4aB6uocbrxxE5HIGIsWnd/XrL6+Ca02c8IQ\n", - "gdgqo1JpoalJ1uWl0NUFN9wALlcsZFc2RCaXsrLYda2vh5oaeOUVCJ3f7r5s4jbNlSTpb4C/iVf/\n", - "F0M0GkUIxWkhv0IokKSvK3yem8zMzCu+EuLz+SbCnC+Gmpo5tLV1c/jwlwhhRpKCaLVuHn741utq\n", - "fzpWit6HRqOZtBWh/Px81q2bzbZte4BUIIpC4eTP/uzRiUR74XB4IuLrZBQK1UR5AZnJIxKJ4Pf7\n", - "MRgMp93jWq2Whx/+Fr///XsoFCaEENhsh5k7N5c5c84fIhwKnVmXQigIheJTufZq5pNPYvVUfvpT\n", - "+PM/j9VZkZl8LBZ4993Yts3f/V2soN6tt8LNN8dCgKciw4C85n4BJCcnk55uYHR0mKSkE45nw8O9\n", - "FBVZp10CKpvNxocffkpraz9CQFVVIRs23HhO35aTUSqV3H33t1iypIfe3j4MBj3FxcVXnbf+5dDU\n", - "1MRHH32B3e5BrRanRRxdDqtXr6SyspyOjg4UCgVFRUWnJLGaObOYzz//AEkqmPhxjBlGA8yateGy\n", - "+5eJEYlE2LlzN198UUswKJGYqOWmm5Yze/ap6fULCwv5yU8209rais/nJzs7i+zs7AvKR1RWVsKX\n", - "X25DknInPh+NRgmFhigtnbrItGuNaDSWwOyf/glefBFWX/kgxOsOIWIRNps2xVaj3n4bfvtb+M53\n", - "YO7cE3+brGoUcQ/tPRuTHdp7uXR1dfHcc28RjWZgNCbj8ThQq+08+eQ9l+QQO1W4XC7+9/9+Acgj\n", - "LS0bSYoyMNCO2ezi+99/bFJ+TKeK6RLi+XUulrS0SkwmM6FQgJ6eoyxcaOWOO245fwOXiSRJvPXW\n", - "+3z1VTcJCdnj+Wm6mTcvm29/+7ZpmTPicoiX3rdu/YTPPmshJ6cSjUaHx+NicPAIDz20loqK8vM3\n", - "cAFEo1Fee+1tDh2yYTJlI0kSbnc3ixcX8K1v3XxFK+hONy5U73Z7zJnS4YhtGXyjwLLMFcbrhe3b\n", - "4cMPY6snBQXwl38ZWzE533Ce1nlGzsZ0M0YAHA4HtbWHGRiwk5OTQU1N9bTLiPnFFzv54x87yM09\n", - "NeKlo+MADz98w7SOhJkuxsgzz/wnDkcqZnPGxLFoNEp3907+63/9zhXJVBuNRjl+/DiHDzcCMHv2\n", - "LGbMmHHNGSIQH717vV5++cunycxccoo/h9vtRKns4M/+bPJiGyORCM3NzdTVHUOhEFRXl1FaWnpd\n", - "GyJwfr1LUsz4+MlP4L77YvkvpvFc6rokHI7p6Be/gJSU2L/nWrU6lzFyzT3Ztm/fPmVtp6SksHbt\n", - "anJy0li1asWUGyKXci49PYMYjacH2avVSdhsQ5PWz6VwKf1MhmwX20ZPzyBJSadmcj1+vBaFIgGn\n", - "88LCOS9XFoVCwcyZM7nnntu5557bmTVr1oQhEo9rMtXtTEWb52pnZGQE0J9iiACYTGaGh0cmCldO\n", - "hjxKpZKysjIslmTuvvtbzJgx47IMkemmu8keA34/vPoqLFoU81f4i7/Yzj/+4+UbItPpfK8VWVQq\n", - "ePDBmLPrqlXbefJJWLMGdu26+LZkY2Sa9nGp/VgsKfh8p1eyDYfHSEk584x+Op9PPG42iyUFt/tU\n", - "o+PYsQNIkveC/W4mS5bp3MZktjMVbZ6rHZPJhCT5xqtkn8DjcZGUZDwl++l0u1bXWjvhcCxHyL//\n", - "OzzwQKya7L/+K/z3/w4HD8Lw8PSQczLbudZkUSpBrd5OY2PMOHnwQVi/Pubf477AONlrzhi53qmp\n", - "mY0QQ4yOxiq/SpLE4GA3ycnBiYJvMudm9epF2O3H8Ptj+UCi0Qgu1xAVFTnXVbGxaxmTycT8+aV0\n", - "ddUTicRWQYJBPzZbAzfeuPi630K5UkhSrHbMfffFcoasWgWNjTGfhNtvj2UGlbl6UKth8+ZYFtyH\n", - "H4Y//CGWlO5CkKNprjFSUlLYvPlO3nprK11dxwCJgoJUbr/97osO8b1eKSsr4667fHz88W6GhkCI\n", - "EJmZeu644+Z4iyYziWzatB6V6lP27t2NJGnQaCJ861sLqak5e3kHmclFCDh+XK6qe62h0cSMkYcf\n", - "jhmcF8K0dmCNtwwyMjIyMjIyk8dVF00jIyMjIyMjc30g78jJyMjIyMjIxBXZGJEBQAixMN4yyFw4\n", - "sr6uX2Tdy3zNtTQWrrltGiGETpIk/xXoRytJ0rkr5F18m/OBJUAyMALskSRp/yT3cSYDVABbJUla\n", - "O4n9VAJhSZKaTjq2WJKkLy/w+wnExuekFFCcjHFxsTqfDH1Olr4uVx/jn68BRiRJahdCrAM0wEeS\n", - "JJ2/ONPZ23xKkqTfjL+fdjofb+ei7/XppPvxti5b/+PfmfQxcJ7+Jm1MXM3jYbqNhSl5FlytxogQ\n", - "4n7gJ0AYeBv4fyRJkoQQn0mSNOWVC4QQH0uStH4S2/snYgrdBowCScCNxAbNjyaxHx9wpkFXLUlS\n", - "yiT18WsgAwgB6cDjkiQNnks3QojHge8DHuA54AkgSqyi879cRN9TNi4uRueTpc/J0Nel6OMMbfwb\n", - "oAX0gB9wAy4gR5Kkxy6wjR2AROwhCmABioAx4EdMQ52Pt39R9/p00v14O5et//F2LnsMXEAfl/0c\n", - "uBbHw3QaC1M2DiRJuipfwB5iockC+C/AO4AZ+GyS+9lxlpdzkvv54mKOX0Y/tUDyGY5vm8xrdtL7\n", - "2cDnwIJz6YbYjaYYH+DdxG5eAey+0uNiMnQ+WfqcDH1dij7OJTdw5KT3n19EGz8GfgesPknnH00H\n", - "nU+W3qeb7idL/5M1Bi6gj8t+DlyL42E6jYWpGgdXdZ4RSZK+ztn8b0KIWuBdYlbfZJJGzPoMnnxQ\n", - "CPHHSe7ngBDiaeBjYpZmIjHruXaS+7kZ8J3h+GSWg1UIITSSJAUlSaoTQtwB/CdQcY7vBKTYEp9P\n", - "CPHM19dbCHHRW2GTMC4mQ+eTpc/J0Nel6OObKE96/3+d9P6Cl1YlSfp/hRBaYLMQ4ntAArGl3umg\n", - "c5i8e3066R4mR/8wCWPgApiU58A1OB6m01iYmnFwOZZMPF/AnwD53ziWDfx/k9zPRs5skc6bgnOa\n", - "S8yS/wtiS5U18b7Ol3geiwDLN46pgPvP8Z1HANU3jmmA//tKj4vJ0vl00eel6OMMbVScRT+3XaJM\n", - "auBZYkvocdf5ZOp9Oul+svQ/FWPgLH1c9nNAHg9TOxamahxctT4j30QI8aIkSQ9cgX5ekiTp/qnu\n", - "53pnsq7zZIwLWedXhumk88mUR+bSmQwdyOPh6uBaCu3NvEL9WK9QP9c7k3WdJ2NcyDq/MkwnnYOs\n", - "9+nAZOhAHg9XAdeSMSIjIyMjIyNzFSIbIzIyMjIyMjJxRTZGZGRkZGRkZOLKteTAapEkyXat9HO9\n", - "M1nXeTLakXV+ZZhOOp/MdmQunel0/8rjYWq5ZowRGRkZGRkZmasTeZtGRkZGRkZGJq7IxoiMjIyM\n", - "jIxMXJGNERkZGRkZGZm4Ihsj0wghxAYhRJMQ4rgQ4ufxlkdm6hFCPCeEsAkhjsRbFpkrgxAiVwjx\n", - "mRCiQQhRL4T403jLJDP1CCF0Qoi9QohDQoijQoi/i7dM0wnZgXWaIIRQAseAtUAv8BWxegGNcRVM\n", - "ZkoRQtwAjAH/IUlSVbzlkZl6hBBWwCpJ0iEhRAJwALhdvtevfYQQBkmSvEIIFbAT+KkkSTvjLdd0\n", - "QF4ZmT4sBFokSeqQJCkEvAx8K84yyUwxkiTtAJzxlkPmyiFJ0oAkSYfG348BjUBWfKWSuRJIkuQd\n", - "f6shVv3WEUdxphWyMTJ9yAa6T/p/z/gxGRmZaxQhRAFQA+yNryQyVwIhhEIIcQiwAZ9JknQ03jJN\n", - "F2RjZPog75fJyFxHjG/RvA78aHyFROYaR5KkqCRJc4AcYIUQYlWcRZo2yMbI9KEXyD3p/7nEVkdk\n", - "ZGSuMYQQauAN4D8lSXo73vLIXFkkSRoFPgDmx1uW6YJsjEwf9gOlQogCIYQGuBd4N84yycjITDJC\n", - "CAH8FjgqSdI/xVsemSuDECJNCJE8/l4PrAMOxleq6YNsjEwTJEkKAz8AtgJHgVdk7/prHyHES8Bu\n", - "YIYQolsI8Z14yyQz5SwDHgJWCyEOjr82xFsomSknE/h03GdkL/CeJEmfxFmmaYMc2isjIyMjIyMT\n", - "V+SVERkZGRkZGZm4IhsjMjIyMjIyMnFFNkZkZGRkZGRk4opsjMjIyMjIyMjEFdkYkZGRkZGRkYkr\n", - "sjEiIyMjIyMjE1dkY0RGRkZGRkYmrsjGiIyMjIyMjExc+f8Bo2OouhAS2pgAAAAASUVORK5CYII=\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "X, y = sklearn.datasets.make_classification(\n", - " n_samples=10000, n_features=4, n_redundant=0, n_informative=2, \n", - " n_clusters_per_class=2, hypercube=False, random_state=0\n", - ")\n", - "\n", - "# Split into train and test\n", - "X, Xt, y, yt = sklearn.cross_validation.train_test_split(X, y)\n", - "\n", - "# Visualize sample of the data\n", - "ind = np.random.permutation(X.shape[0])[:1000]\n", - "df = pd.DataFrame(X[ind])\n", - "_ = pd.scatter_matrix(df, figsize=(9, 9), diagonal='kde', marker='o', s=40, alpha=.4, c=y[ind])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Learn and evaluate scikit-learn's logistic regression with stochastic gradient descent (SGD) training. Time and check the classifier's accuracy." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 loops, best of 3: 499 ms per loop\n", - "Accuracy: 0.756\n" - ] - } - ], - "source": [ - "# Train and test the scikit-learn SGD logistic regression.\n", - "clf = sklearn.linear_model.SGDClassifier(\n", - " loss='log', n_iter=1000, penalty='l2', alpha=1e-3, class_weight='auto')\n", - "\n", - "%timeit clf.fit(X, y)\n", - "yt_pred = clf.predict(Xt)\n", - "print('Accuracy: {:.3f}'.format(sklearn.metrics.accuracy_score(yt, yt_pred)))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Save the dataset to HDF5 for loading in Caffe." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Write out the data to HDF5 files in a temp directory.\n", - "# This file is assumed to be caffe_root/examples/hdf5_classification.ipynb\n", - "dirname = os.path.abspath('./hdf5_classification/data')\n", - "if not os.path.exists(dirname):\n", - " os.makedirs(dirname)\n", - "\n", - "train_filename = os.path.join(dirname, 'train.h5')\n", - "test_filename = os.path.join(dirname, 'test.h5')\n", - "\n", - "# HDF5DataLayer source should be a file containing a list of HDF5 filenames.\n", - "# To show this off, we'll list the same data file twice.\n", - "with h5py.File(train_filename, 'w') as f:\n", - " f['data'] = X\n", - " f['label'] = y.astype(np.float32)\n", - "with open(os.path.join(dirname, 'train.txt'), 'w') as f:\n", - " f.write(train_filename + '\\n')\n", - " f.write(train_filename + '\\n')\n", - " \n", - "# HDF5 is pretty efficient, but can be further compressed.\n", - "comp_kwargs = {'compression': 'gzip', 'compression_opts': 1}\n", - "with h5py.File(test_filename, 'w') as f:\n", - " f.create_dataset('data', data=Xt, **comp_kwargs)\n", - " f.create_dataset('label', data=yt.astype(np.float32), **comp_kwargs)\n", - "with open(os.path.join(dirname, 'test.txt'), 'w') as f:\n", - " f.write(test_filename + '\\n')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Learn and evaluate logistic regression in Caffe." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 loops, best of 3: 240 ms per loop\n", - "Accuracy: 0.752\n" - ] - } - ], - "source": [ - "def learn_and_test(solver_file):\n", - " caffe.set_mode_cpu()\n", - " solver = caffe.get_solver(solver_file)\n", - " solver.solve()\n", - "\n", - " accuracy = 0\n", - " test_iters = int(len(Xt) / solver.test_nets[0].blobs['data'].num)\n", - " for i in range(test_iters):\n", - " solver.test_nets[0].forward()\n", - " accuracy += solver.test_nets[0].blobs['accuracy'].data\n", - " accuracy /= test_iters\n", - " return accuracy\n", - "\n", - "%timeit learn_and_test('hdf5_classification/solver.prototxt')\n", - "acc = learn_and_test('hdf5_classification/solver.prototxt')\n", - "print(\"Accuracy: {:.3f}\".format(acc))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Do the same through the command line interface for detailed output on the model and solving." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "I0307 01:34:29.141863 2099749632 caffe.cpp:103] Use CPU.\n", - "I0307 01:34:29.418283 2099749632 caffe.cpp:107] Starting Optimization\n", - "I0307 01:34:29.418323 2099749632 solver.cpp:32] Initializing solver from parameters: \n", - "test_iter: 250\n", - "test_interval: 1000\n", - "base_lr: 0.01\n", - "display: 1000\n", - "max_iter: 10000\n", - "lr_policy: \"step\"\n", - "gamma: 0.1\n", - "momentum: 0.9\n", - "weight_decay: 0.0005\n", - "stepsize: 5000\n", - "snapshot: 10000\n", - "snapshot_prefix: \"hdf5_classification/data/train\"\n", - "solver_mode: CPU\n", - "net: \"hdf5_classification/train_val.prototxt\"\n", - "I0307 01:34:29.418416 2099749632 solver.cpp:70] Creating training net from net file: hdf5_classification/train_val.prototxt\n", - "I0307 01:34:29.418583 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer data\n", - "I0307 01:34:29.418598 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer accuracy\n", - "I0307 01:34:29.418608 2099749632 net.cpp:42] Initializing net from parameters: \n", - "name: \"LogisticRegressionNet\"\n", - "state {\n", - " phase: TRAIN\n", - "}\n", - "layer {\n", - " name: \"data\"\n", - " type: \"HDF5Data\"\n", - " top: \"data\"\n", - " top: \"label\"\n", - " include {\n", - " phase: TRAIN\n", - " }\n", - " hdf5_data_param {\n", - " source: \"hdf5_classification/data/train.txt\"\n", - " batch_size: 10\n", - " }\n", - "}\n", - "layer {\n", - " name: \"fc1\"\n", - " type: \"InnerProduct\"\n", - " bottom: \"data\"\n", - " top: \"fc1\"\n", - " param {\n", - " lr_mult: 1\n", - " decay_mult: 1\n", - " }\n", - " param {\n", - " lr_mult: 2\n", - " decay_mult: 0\n", - " }\n", - " inner_product_param {\n", - " num_output: 2\n", - " weight_filler {\n", - " type: \"gaussian\"\n", - " std: 0.01\n", - " }\n", - " bias_filler {\n", - " type: \"constant\"\n", - " value: 0\n", - " }\n", - " }\n", - "}\n", - "layer {\n", - " name: \"loss\"\n", - " type: \"SoftmaxWithLoss\"\n", - " bottom: \"fc1\"\n", - " bottom: \"label\"\n", - " top: \"loss\"\n", - "}\n", - "I0307 01:34:29.418692 2099749632 layer_factory.hpp:74] Creating layer data\n", - "I0307 01:34:29.418853 2099749632 net.cpp:84] Creating Layer data\n", - "I0307 01:34:29.418879 2099749632 net.cpp:338] data -> data\n", - "I0307 01:34:29.418905 2099749632 net.cpp:338] data -> label\n", - "I0307 01:34:29.418918 2099749632 net.cpp:113] Setting up data\n", - "I0307 01:34:29.418926 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/train.txt\n", - "I0307 01:34:29.418992 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 2\n", - "I0307 01:34:29.420812 2099749632 net.cpp:120] Top shape: 10 4 (40)\n", - "I0307 01:34:29.420841 2099749632 net.cpp:120] Top shape: 10 (10)\n", - "I0307 01:34:29.420852 2099749632 layer_factory.hpp:74] Creating layer fc1\n", - "I0307 01:34:29.420866 2099749632 net.cpp:84] Creating Layer fc1\n", - "I0307 01:34:29.420872 2099749632 net.cpp:380] fc1 <- data\n", - "I0307 01:34:29.420882 2099749632 net.cpp:338] fc1 -> fc1\n", - "I0307 01:34:29.420894 2099749632 net.cpp:113] Setting up fc1\n", - "I0307 01:34:29.425689 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", - "I0307 01:34:29.425709 2099749632 layer_factory.hpp:74] Creating layer loss\n", - "I0307 01:34:29.425724 2099749632 net.cpp:84] Creating Layer loss\n", - "I0307 01:34:29.425731 2099749632 net.cpp:380] loss <- fc1\n", - "I0307 01:34:29.425739 2099749632 net.cpp:380] loss <- label\n", - "I0307 01:34:29.425747 2099749632 net.cpp:338] loss -> loss\n", - "I0307 01:34:29.425756 2099749632 net.cpp:113] Setting up loss\n", - "I0307 01:34:29.425767 2099749632 layer_factory.hpp:74] Creating layer loss\n", - "I0307 01:34:29.425781 2099749632 net.cpp:120] Top shape: (1)\n", - "I0307 01:34:29.425789 2099749632 net.cpp:122] with loss weight 1\n", - "I0307 01:34:29.425801 2099749632 net.cpp:167] loss needs backward computation.\n", - "I0307 01:34:29.425808 2099749632 net.cpp:167] fc1 needs backward computation.\n", - "I0307 01:34:29.425815 2099749632 net.cpp:169] data does not need backward computation.\n", - "I0307 01:34:29.425822 2099749632 net.cpp:205] This network produces output loss\n", - "I0307 01:34:29.425829 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", - "I0307 01:34:29.425837 2099749632 net.cpp:217] Network initialization done.\n", - "I0307 01:34:29.425843 2099749632 net.cpp:218] Memory required for data: 284\n", - "I0307 01:34:29.425961 2099749632 solver.cpp:154] Creating test net (#0) specified by net file: hdf5_classification/train_val.prototxt\n", - "I0307 01:34:29.425984 2099749632 net.cpp:257] The NetState phase (1) differed from the phase (0) specified by a rule in layer data\n", - "I0307 01:34:29.425997 2099749632 net.cpp:42] Initializing net from parameters: \n", - "name: \"LogisticRegressionNet\"\n", - "state {\n", - " phase: TEST\n", - "}\n", - "layer {\n", - " name: \"data\"\n", - " type: \"HDF5Data\"\n", - " top: \"data\"\n", - " top: \"label\"\n", - " include {\n", - " phase: TEST\n", - " }\n", - " hdf5_data_param {\n", - " source: \"hdf5_classification/data/test.txt\"\n", - " batch_size: 10\n", - " }\n", - "}\n", - "layer {\n", - " name: \"fc1\"\n", - " type: \"InnerProduct\"\n", - " bottom: \"data\"\n", - " top: \"fc1\"\n", - " param {\n", - " lr_mult: 1\n", - " decay_mult: 1\n", - " }\n", - " param {\n", - " lr_mult: 2\n", - " decay_mult: 0\n", - " }\n", - " inner_product_param {\n", - " num_output: 2\n", - " weight_filler {\n", - " type: \"gaussian\"\n", - " std: 0.01\n", - " }\n", - " bias_filler {\n", - " type: \"constant\"\n", - " value: 0\n", - " }\n", - " }\n", - "}\n", - "layer {\n", - " name: \"loss\"\n", - " type: \"SoftmaxWithLoss\"\n", - " bottom: \"fc1\"\n", - " bottom: \"label\"\n", - " top: \"loss\"\n", - "}\n", - "layer {\n", - " name: \"accuracy\"\n", - " type: \"Accuracy\"\n", - " bottom: \"fc1\"\n", - " bottom: \"label\"\n", - " top: \"accuracy\"\n", - " include {\n", - " phase: TEST\n", - " }\n", - "}\n", - "I0307 01:34:29.426126 2099749632 layer_factory.hpp:74] Creating layer data\n", - "I0307 01:34:29.426311 2099749632 net.cpp:84] Creating Layer data\n", - "I0307 01:34:29.426331 2099749632 net.cpp:338] data -> data\n", - "I0307 01:34:29.426343 2099749632 net.cpp:338] data -> label\n", - "I0307 01:34:29.426354 2099749632 net.cpp:113] Setting up data\n", - "I0307 01:34:29.426362 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/test.txt\n", - "I0307 01:34:29.426484 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 1\n", - "I0307 01:34:29.427692 2099749632 net.cpp:120] Top shape: 10 4 (40)\n", - "I0307 01:34:29.427711 2099749632 net.cpp:120] Top shape: 10 (10)\n", - "I0307 01:34:29.427721 2099749632 layer_factory.hpp:74] Creating layer label_data_1_split\n", - "I0307 01:34:29.427731 2099749632 net.cpp:84] Creating Layer label_data_1_split\n", - "I0307 01:34:29.427738 2099749632 net.cpp:380] label_data_1_split <- label\n", - "I0307 01:34:29.427747 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_0\n", - "I0307 01:34:29.427759 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_1\n", - "I0307 01:34:29.427768 2099749632 net.cpp:113] Setting up label_data_1_split\n", - "I0307 01:34:29.427777 2099749632 net.cpp:120] Top shape: 10 (10)\n", - "I0307 01:34:29.427784 2099749632 net.cpp:120] Top shape: 10 (10)\n", - "I0307 01:34:29.427791 2099749632 layer_factory.hpp:74] Creating layer fc1\n", - "I0307 01:34:29.427804 2099749632 net.cpp:84] Creating Layer fc1\n", - "I0307 01:34:29.427813 2099749632 net.cpp:380] fc1 <- data\n", - "I0307 01:34:29.427821 2099749632 net.cpp:338] fc1 -> fc1\n", - "I0307 01:34:29.427831 2099749632 net.cpp:113] Setting up fc1\n", - "I0307 01:34:29.427845 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", - "I0307 01:34:29.427857 2099749632 layer_factory.hpp:74] Creating layer fc1_fc1_0_split\n", - "I0307 01:34:29.427866 2099749632 net.cpp:84] Creating Layer fc1_fc1_0_split\n", - "I0307 01:34:29.427872 2099749632 net.cpp:380] fc1_fc1_0_split <- fc1\n", - "I0307 01:34:29.427881 2099749632 net.cpp:338] fc1_fc1_0_split -> fc1_fc1_0_split_0\n", - "I0307 01:34:29.427891 2099749632 net.cpp:338] fc1_fc1_0_split -> fc1_fc1_0_split_1\n", - "I0307 01:34:29.427942 2099749632 net.cpp:113] Setting up fc1_fc1_0_split\n", - "I0307 01:34:29.427955 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", - "I0307 01:34:29.427965 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", - "I0307 01:34:29.427976 2099749632 layer_factory.hpp:74] Creating layer loss\n", - "I0307 01:34:29.427991 2099749632 net.cpp:84] Creating Layer loss\n", - "I0307 01:34:29.428001 2099749632 net.cpp:380] loss <- fc1_fc1_0_split_0\n", - "I0307 01:34:29.428009 2099749632 net.cpp:380] loss <- label_data_1_split_0\n", - "I0307 01:34:29.428017 2099749632 net.cpp:338] loss -> loss\n", - "I0307 01:34:29.428026 2099749632 net.cpp:113] Setting up loss\n", - "I0307 01:34:29.428035 2099749632 layer_factory.hpp:74] Creating layer loss\n", - "I0307 01:34:29.428048 2099749632 net.cpp:120] Top shape: (1)\n", - "I0307 01:34:29.428056 2099749632 net.cpp:122] with loss weight 1\n", - "I0307 01:34:29.428064 2099749632 layer_factory.hpp:74] Creating layer accuracy\n", - "I0307 01:34:29.428076 2099749632 net.cpp:84] Creating Layer accuracy\n", - "I0307 01:34:29.428084 2099749632 net.cpp:380] accuracy <- fc1_fc1_0_split_1\n", - "I0307 01:34:29.428092 2099749632 net.cpp:380] accuracy <- label_data_1_split_1\n", - "I0307 01:34:29.428102 2099749632 net.cpp:338] accuracy -> accuracy\n", - "I0307 01:34:29.428131 2099749632 net.cpp:113] Setting up accuracy\n", - "I0307 01:34:29.428140 2099749632 net.cpp:120] Top shape: (1)\n", - "I0307 01:34:29.428148 2099749632 net.cpp:169] accuracy does not need backward computation.\n", - "I0307 01:34:29.428154 2099749632 net.cpp:167] loss needs backward computation.\n", - "I0307 01:34:29.428161 2099749632 net.cpp:167] fc1_fc1_0_split needs backward computation.\n", - "I0307 01:34:29.428167 2099749632 net.cpp:167] fc1 needs backward computation.\n", - "I0307 01:34:29.428174 2099749632 net.cpp:169] label_data_1_split does not need backward computation.\n", - "I0307 01:34:29.428181 2099749632 net.cpp:169] data does not need backward computation.\n", - "I0307 01:34:29.428189 2099749632 net.cpp:205] This network produces output accuracy\n", - "I0307 01:34:29.428324 2099749632 net.cpp:205] This network produces output loss\n", - "I0307 01:34:29.428342 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", - "I0307 01:34:29.428350 2099749632 net.cpp:217] Network initialization done.\n", - "I0307 01:34:29.428357 2099749632 net.cpp:218] Memory required for data: 528\n", - "I0307 01:34:29.428388 2099749632 solver.cpp:42] Solver scaffolding done.\n", - "I0307 01:34:29.428412 2099749632 solver.cpp:222] Solving LogisticRegressionNet\n", - "I0307 01:34:29.428421 2099749632 solver.cpp:223] Learning Rate Policy: step\n", - "I0307 01:34:29.428431 2099749632 solver.cpp:266] Iteration 0, Testing net (#0)\n", - "I0307 01:34:29.471674 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.4532\n", - "I0307 01:34:29.471724 2099749632 solver.cpp:315] Test net output #1: loss = 0.694067 (* 1 = 0.694067 loss)\n", - "I0307 01:34:29.471853 2099749632 solver.cpp:189] Iteration 0, loss = 0.692695\n", - "I0307 01:34:29.471878 2099749632 solver.cpp:204] Train net output #0: loss = 0.692695 (* 1 = 0.692695 loss)\n", - "I0307 01:34:29.471890 2099749632 solver.cpp:464] Iteration 0, lr = 0.01\n", - "I0307 01:34:29.483834 2099749632 solver.cpp:266] Iteration 1000, Testing net (#0)\n", - "I0307 01:34:29.486868 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7424\n", - "I0307 01:34:29.486896 2099749632 solver.cpp:315] Test net output #1: loss = 0.601764 (* 1 = 0.601764 loss)\n", - "I0307 01:34:29.486922 2099749632 solver.cpp:189] Iteration 1000, loss = 0.472665\n", - "I0307 01:34:29.486934 2099749632 solver.cpp:204] Train net output #0: loss = 0.472665 (* 1 = 0.472665 loss)\n", - "I0307 01:34:29.486944 2099749632 solver.cpp:464] Iteration 1000, lr = 0.01\n", - "I0307 01:34:29.498821 2099749632 solver.cpp:266] Iteration 2000, Testing net (#0)\n", - "I0307 01:34:29.501900 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7364\n", - "I0307 01:34:29.501941 2099749632 solver.cpp:315] Test net output #1: loss = 0.60818 (* 1 = 0.60818 loss)\n", - "I0307 01:34:29.501988 2099749632 solver.cpp:189] Iteration 2000, loss = 0.6863\n", - "I0307 01:34:29.502003 2099749632 solver.cpp:204] Train net output #0: loss = 0.6863 (* 1 = 0.6863 loss)\n", - "I0307 01:34:29.502013 2099749632 solver.cpp:464] Iteration 2000, lr = 0.01\n", - "I0307 01:34:29.513921 2099749632 solver.cpp:266] Iteration 3000, Testing net (#0)\n", - "I0307 01:34:29.517227 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.6964\n", - "I0307 01:34:29.517300 2099749632 solver.cpp:315] Test net output #1: loss = 0.604707 (* 1 = 0.604707 loss)\n", - "I0307 01:34:29.518105 2099749632 solver.cpp:189] Iteration 3000, loss = 0.617542\n", - "I0307 01:34:29.518154 2099749632 solver.cpp:204] Train net output #0: loss = 0.617542 (* 1 = 0.617542 loss)\n", - "I0307 01:34:29.518170 2099749632 solver.cpp:464] Iteration 3000, lr = 0.01\n", - "I0307 01:34:29.531672 2099749632 solver.cpp:266] Iteration 4000, Testing net (#0)\n", - "I0307 01:34:29.534873 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7424\n", - "I0307 01:34:29.534920 2099749632 solver.cpp:315] Test net output #1: loss = 0.601764 (* 1 = 0.601764 loss)\n", - "I0307 01:34:29.534950 2099749632 solver.cpp:189] Iteration 4000, loss = 0.472666\n", - "I0307 01:34:29.534962 2099749632 solver.cpp:204] Train net output #0: loss = 0.472665 (* 1 = 0.472665 loss)\n", - "I0307 01:34:29.534973 2099749632 solver.cpp:464] Iteration 4000, lr = 0.01\n", - "I0307 01:34:29.546567 2099749632 solver.cpp:266] Iteration 5000, Testing net (#0)\n", - "I0307 01:34:29.549762 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7364\n", - "I0307 01:34:29.549789 2099749632 solver.cpp:315] Test net output #1: loss = 0.60818 (* 1 = 0.60818 loss)\n", - "I0307 01:34:29.549815 2099749632 solver.cpp:189] Iteration 5000, loss = 0.686301\n", - "I0307 01:34:29.549828 2099749632 solver.cpp:204] Train net output #0: loss = 0.6863 (* 1 = 0.6863 loss)\n", - "I0307 01:34:29.549837 2099749632 solver.cpp:464] Iteration 5000, lr = 0.001\n", - "I0307 01:34:29.562142 2099749632 solver.cpp:266] Iteration 6000, Testing net (#0)\n", - "I0307 01:34:29.565335 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7476\n", - "I0307 01:34:29.565373 2099749632 solver.cpp:315] Test net output #1: loss = 0.59775 (* 1 = 0.59775 loss)\n", - "I0307 01:34:29.566051 2099749632 solver.cpp:189] Iteration 6000, loss = 0.664614\n", - "I0307 01:34:29.566086 2099749632 solver.cpp:204] Train net output #0: loss = 0.664614 (* 1 = 0.664614 loss)\n", - "I0307 01:34:29.566097 2099749632 solver.cpp:464] Iteration 6000, lr = 0.001\n", - "I0307 01:34:29.577900 2099749632 solver.cpp:266] Iteration 7000, Testing net (#0)\n", - "I0307 01:34:29.580993 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7524\n", - "I0307 01:34:29.581015 2099749632 solver.cpp:315] Test net output #1: loss = 0.597349 (* 1 = 0.597349 loss)\n", - "I0307 01:34:29.581038 2099749632 solver.cpp:189] Iteration 7000, loss = 0.456775\n", - "I0307 01:34:29.581050 2099749632 solver.cpp:204] Train net output #0: loss = 0.456774 (* 1 = 0.456774 loss)\n", - "I0307 01:34:29.581059 2099749632 solver.cpp:464] Iteration 7000, lr = 0.001\n", - "I0307 01:34:29.592854 2099749632 solver.cpp:266] Iteration 8000, Testing net (#0)\n", - "I0307 01:34:29.595973 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7568\n", - "I0307 01:34:29.596002 2099749632 solver.cpp:315] Test net output #1: loss = 0.597265 (* 1 = 0.597265 loss)\n", - "I0307 01:34:29.596027 2099749632 solver.cpp:189] Iteration 8000, loss = 0.673885\n", - "I0307 01:34:29.596040 2099749632 solver.cpp:204] Train net output #0: loss = 0.673885 (* 1 = 0.673885 loss)\n", - "I0307 01:34:29.596048 2099749632 solver.cpp:464] Iteration 8000, lr = 0.001\n", - "I0307 01:34:29.607822 2099749632 solver.cpp:266] Iteration 9000, Testing net (#0)\n", - "I0307 01:34:29.610930 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7432\n", - "I0307 01:34:29.610960 2099749632 solver.cpp:315] Test net output #1: loss = 0.597777 (* 1 = 0.597777 loss)\n", - "I0307 01:34:29.611558 2099749632 solver.cpp:189] Iteration 9000, loss = 0.66526\n", - "I0307 01:34:29.611583 2099749632 solver.cpp:204] Train net output #0: loss = 0.66526 (* 1 = 0.66526 loss)\n", - "I0307 01:34:29.611593 2099749632 solver.cpp:464] Iteration 9000, lr = 0.001\n", - "I0307 01:34:29.623009 2099749632 solver.cpp:334] Snapshotting to hdf5_classification/data/train_iter_10000.caffemodel\n", - "I0307 01:34:29.623209 2099749632 solver.cpp:342] Snapshotting solver state to hdf5_classification/data/train_iter_10000.solverstate\n", - "I0307 01:34:29.623319 2099749632 solver.cpp:248] Iteration 10000, loss = 0.457922\n", - "I0307 01:34:29.623333 2099749632 solver.cpp:266] Iteration 10000, Testing net (#0)\n", - "I0307 01:34:29.626454 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.752\n", - "I0307 01:34:29.626484 2099749632 solver.cpp:315] Test net output #1: loss = 0.597362 (* 1 = 0.597362 loss)\n", - "I0307 01:34:29.626493 2099749632 solver.cpp:253] Optimization Done.\n", - "I0307 01:34:29.626502 2099749632 caffe.cpp:121] Optimization Done.\n" - ] - } - ], - "source": [ - "!../build/tools/caffe train -solver hdf5_classification/solver.prototxt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you look at output or the `train_val.prototxt`, you'll see that the model is simple logistic regression.\n", - "We can make it a little more advanced by introducing a non-linearity between weights that take the input and weights that give the output -- now we have a two-layer network.\n", - "That network is given in `train_val2.prototxt`, and that's the only change made in `solver2.prototxt` which we will now use.\n", - "\n", - "The final accuracy of the new network be higher than logistic regression!" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 loops, best of 3: 333 ms per loop\n", - "Accuracy: 0.818\n" - ] - } - ], - "source": [ - "def learn_and_test(solver_file):\n", - " caffe.set_mode_cpu()\n", - " solver = caffe.get_solver(solver_file)\n", - " solver.solve()\n", - "\n", - " accuracy = 0\n", - " test_iters = int(len(Xt) / solver.test_nets[0].blobs['data'].num)\n", - " for i in range(test_iters):\n", - " solver.test_nets[0].forward()\n", - " accuracy += solver.test_nets[0].blobs['accuracy'].data\n", - " accuracy /= test_iters\n", - " return accuracy\n", - "\n", - "%timeit learn_and_test('hdf5_classification/solver2.prototxt')\n", - "acc = learn_and_test('hdf5_classification/solver2.prototxt')\n", - "print(\"Accuracy: {:.3f}\".format(acc))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Do the same through the command line interface for detailed output on the model and solving." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "I0307 01:34:31.589234 2099749632 caffe.cpp:103] Use CPU.\n", - "I0307 01:34:31.872560 2099749632 caffe.cpp:107] Starting Optimization\n", - "I0307 01:34:31.872596 2099749632 solver.cpp:32] Initializing solver from parameters: \n", - "test_iter: 250\n", - "test_interval: 1000\n", - "base_lr: 0.01\n", - "display: 1000\n", - "max_iter: 10000\n", - "lr_policy: \"step\"\n", - "gamma: 0.1\n", - "momentum: 0.9\n", - "weight_decay: 0.0005\n", - "stepsize: 5000\n", - "snapshot: 10000\n", - "snapshot_prefix: \"hdf5_classification/data/train\"\n", - "solver_mode: CPU\n", - "net: \"hdf5_classification/train_val2.prototxt\"\n", - "I0307 01:34:31.872687 2099749632 solver.cpp:70] Creating training net from net file: hdf5_classification/train_val2.prototxt\n", - "I0307 01:34:31.872865 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer data\n", - "I0307 01:34:31.872882 2099749632 net.cpp:257] The NetState phase (0) differed from the phase (1) specified by a rule in layer accuracy\n", - "I0307 01:34:31.872891 2099749632 net.cpp:42] Initializing net from parameters: \n", - "name: \"LogisticRegressionNet\"\n", - "state {\n", - " phase: TRAIN\n", - "}\n", - "layer {\n", - " name: \"data\"\n", - " type: \"HDF5Data\"\n", - " top: \"data\"\n", - " top: \"label\"\n", - " include {\n", - " phase: TRAIN\n", - " }\n", - " hdf5_data_param {\n", - " source: \"hdf5_classification/data/train.txt\"\n", - " batch_size: 10\n", - " }\n", - "}\n", - "layer {\n", - " name: \"fc1\"\n", - " type: \"InnerProduct\"\n", - " bottom: \"data\"\n", - " top: \"fc1\"\n", - " param {\n", - " lr_mult: 1\n", - " decay_mult: 1\n", - " }\n", - " param {\n", - " lr_mult: 2\n", - " decay_mult: 0\n", - " }\n", - " inner_product_param {\n", - " num_output: 40\n", - " weight_filler {\n", - " type: \"gaussian\"\n", - " std: 0.01\n", - " }\n", - " bias_filler {\n", - " type: \"constant\"\n", - " value: 0\n", - " }\n", - " }\n", - "}\n", - "layer {\n", - " name: \"relu1\"\n", - " type: \"ReLU\"\n", - " bottom: \"fc1\"\n", - " top: \"fc1\"\n", - "}\n", - "layer {\n", - " name: \"fc2\"\n", - " type: \"InnerProduct\"\n", - " bottom: \"fc1\"\n", - " top: \"fc2\"\n", - " param {\n", - " lr_mult: 1\n", - " decay_mult: 1\n", - " }\n", - " param {\n", - " lr_mult: 2\n", - " decay_mult: 0\n", - " }\n", - " inner_product_param {\n", - " num_output: 2\n", - " weight_filler {\n", - " type: \"gaussian\"\n", - " std: 0.01\n", - " }\n", - " bias_filler {\n", - " type: \"constant\"\n", - " value: 0\n", - " }\n", - " }\n", - "}\n", - "layer {\n", - " name: \"loss\"\n", - " type: \"SoftmaxWithLoss\"\n", - " bottom: \"fc2\"\n", - " bottom: \"label\"\n", - " top: \"loss\"\n", - "}\n", - "I0307 01:34:31.873246 2099749632 layer_factory.hpp:74] Creating layer data\n", - "I0307 01:34:31.873276 2099749632 net.cpp:84] Creating Layer data\n", - "I0307 01:34:31.873292 2099749632 net.cpp:338] data -> data\n", - "I0307 01:34:31.873332 2099749632 net.cpp:338] data -> label\n", - "I0307 01:34:31.873352 2099749632 net.cpp:113] Setting up data\n", - "I0307 01:34:31.873361 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/train.txt\n", - "I0307 01:34:31.873443 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 2\n", - "I0307 01:34:31.875783 2099749632 net.cpp:120] Top shape: 10 4 (40)\n", - "I0307 01:34:31.875816 2099749632 net.cpp:120] Top shape: 10 (10)\n", - "I0307 01:34:31.875829 2099749632 layer_factory.hpp:74] Creating layer fc1\n", - "I0307 01:34:31.875846 2099749632 net.cpp:84] Creating Layer fc1\n", - "I0307 01:34:31.875857 2099749632 net.cpp:380] fc1 <- data\n", - "I0307 01:34:31.875875 2099749632 net.cpp:338] fc1 -> fc1\n", - "I0307 01:34:31.875892 2099749632 net.cpp:113] Setting up fc1\n", - "I0307 01:34:31.882478 2099749632 net.cpp:120] Top shape: 10 40 (400)\n", - "I0307 01:34:31.882505 2099749632 layer_factory.hpp:74] Creating layer relu1\n", - "I0307 01:34:31.882524 2099749632 net.cpp:84] Creating Layer relu1\n", - "I0307 01:34:31.882532 2099749632 net.cpp:380] relu1 <- fc1\n", - "I0307 01:34:31.882544 2099749632 net.cpp:327] relu1 -> fc1 (in-place)\n", - "I0307 01:34:31.882555 2099749632 net.cpp:113] Setting up relu1\n", - "I0307 01:34:31.882565 2099749632 net.cpp:120] Top shape: 10 40 (400)\n", - "I0307 01:34:31.882583 2099749632 layer_factory.hpp:74] Creating layer fc2\n", - "I0307 01:34:31.882609 2099749632 net.cpp:84] Creating Layer fc2\n", - "I0307 01:34:31.882619 2099749632 net.cpp:380] fc2 <- fc1\n", - "I0307 01:34:31.882632 2099749632 net.cpp:338] fc2 -> fc2\n", - "I0307 01:34:31.882644 2099749632 net.cpp:113] Setting up fc2\n", - "I0307 01:34:31.882663 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", - "I0307 01:34:31.882678 2099749632 layer_factory.hpp:74] Creating layer loss\n", - "I0307 01:34:31.882694 2099749632 net.cpp:84] Creating Layer loss\n", - "I0307 01:34:31.882704 2099749632 net.cpp:380] loss <- fc2\n", - "I0307 01:34:31.882712 2099749632 net.cpp:380] loss <- label\n", - "I0307 01:34:31.882779 2099749632 net.cpp:338] loss -> loss\n", - "I0307 01:34:31.882796 2099749632 net.cpp:113] Setting up loss\n", - "I0307 01:34:31.882810 2099749632 layer_factory.hpp:74] Creating layer loss\n", - "I0307 01:34:31.882833 2099749632 net.cpp:120] Top shape: (1)\n", - "I0307 01:34:31.882844 2099749632 net.cpp:122] with loss weight 1\n", - "I0307 01:34:31.882860 2099749632 net.cpp:167] loss needs backward computation.\n", - "I0307 01:34:31.882869 2099749632 net.cpp:167] fc2 needs backward computation.\n", - "I0307 01:34:31.882877 2099749632 net.cpp:167] relu1 needs backward computation.\n", - "I0307 01:34:31.882886 2099749632 net.cpp:167] fc1 needs backward computation.\n", - "I0307 01:34:31.882894 2099749632 net.cpp:169] data does not need backward computation.\n", - "I0307 01:34:31.882904 2099749632 net.cpp:205] This network produces output loss\n", - "I0307 01:34:31.882931 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", - "I0307 01:34:31.882942 2099749632 net.cpp:217] Network initialization done.\n", - "I0307 01:34:31.882951 2099749632 net.cpp:218] Memory required for data: 3484\n", - "I0307 01:34:31.883157 2099749632 solver.cpp:154] Creating test net (#0) specified by net file: hdf5_classification/train_val2.prototxt\n", - "I0307 01:34:31.883189 2099749632 net.cpp:257] The NetState phase (1) differed from the phase (0) specified by a rule in layer data\n", - "I0307 01:34:31.883203 2099749632 net.cpp:42] Initializing net from parameters: \n", - "name: \"LogisticRegressionNet\"\n", - "state {\n", - " phase: TEST\n", - "}\n", - "layer {\n", - " name: \"data\"\n", - " type: \"HDF5Data\"\n", - " top: \"data\"\n", - " top: \"label\"\n", - " include {\n", - " phase: TEST\n", - " }\n", - " hdf5_data_param {\n", - " source: \"hdf5_classification/data/test.txt\"\n", - " batch_size: 10\n", - " }\n", - "}\n", - "layer {\n", - " name: \"fc1\"\n", - " type: \"InnerProduct\"\n", - " bottom: \"data\"\n", - " top: \"fc1\"\n", - " param {\n", - " lr_mult: 1\n", - " decay_mult: 1\n", - " }\n", - " param {\n", - " lr_mult: 2\n", - " decay_mult: 0\n", - " }\n", - " inner_product_param {\n", - " num_output: 40\n", - " weight_filler {\n", - " type: \"gaussian\"\n", - " std: 0.01\n", - " }\n", - " bias_filler {\n", - " type: \"constant\"\n", - " value: 0\n", - " }\n", - " }\n", - "}\n", - "layer {\n", - " name: \"relu1\"\n", - " type: \"ReLU\"\n", - " bottom: \"fc1\"\n", - " top: \"fc1\"\n", - "}\n", - "layer {\n", - " name: \"fc2\"\n", - " type: \"InnerProduct\"\n", - " bottom: \"fc1\"\n", - " top: \"fc2\"\n", - " param {\n", - " lr_mult: 1\n", - " decay_mult: 1\n", - " }\n", - " param {\n", - " lr_mult: 2\n", - " decay_mult: 0\n", - " }\n", - " inner_product_param {\n", - " num_output: 2\n", - " weight_filler {\n", - " type: \"gaussian\"\n", - " std: 0.01\n", - " }\n", - " bias_filler {\n", - " type: \"constant\"\n", - " value: 0\n", - " }\n", - " }\n", - "}\n", - "layer {\n", - " name: \"loss\"\n", - " type: \"SoftmaxWithLoss\"\n", - " bottom: \"fc2\"\n", - " bottom: \"label\"\n", - " top: \"loss\"\n", - "}\n", - "layer {\n", - " name: \"accuracy\"\n", - " type: \"Accuracy\"\n", - " bottom: \"fc2\"\n", - " bottom: \"label\"\n", - " top: \"accuracy\"\n", - " include {\n", - " phase: TEST\n", - " }\n", - "}\n", - "I0307 01:34:31.883535 2099749632 layer_factory.hpp:74] Creating layer data\n", - "I0307 01:34:31.883548 2099749632 net.cpp:84] Creating Layer data\n", - "I0307 01:34:31.883556 2099749632 net.cpp:338] data -> data\n", - "I0307 01:34:31.883569 2099749632 net.cpp:338] data -> label\n", - "I0307 01:34:31.883579 2099749632 net.cpp:113] Setting up data\n", - "I0307 01:34:31.883585 2099749632 hdf5_data_layer.cpp:66] Loading list of HDF5 filenames from: hdf5_classification/data/test.txt\n", - "I0307 01:34:31.883664 2099749632 hdf5_data_layer.cpp:80] Number of HDF5 files: 1\n", - "I0307 01:34:31.884842 2099749632 net.cpp:120] Top shape: 10 4 (40)\n", - "I0307 01:34:31.884860 2099749632 net.cpp:120] Top shape: 10 (10)\n", - "I0307 01:34:31.884870 2099749632 layer_factory.hpp:74] Creating layer label_data_1_split\n", - "I0307 01:34:31.884879 2099749632 net.cpp:84] Creating Layer label_data_1_split\n", - "I0307 01:34:31.884886 2099749632 net.cpp:380] label_data_1_split <- label\n", - "I0307 01:34:31.884896 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_0\n", - "I0307 01:34:31.884909 2099749632 net.cpp:338] label_data_1_split -> label_data_1_split_1\n", - "I0307 01:34:31.884919 2099749632 net.cpp:113] Setting up label_data_1_split\n", - "I0307 01:34:31.884927 2099749632 net.cpp:120] Top shape: 10 (10)\n", - "I0307 01:34:31.884934 2099749632 net.cpp:120] Top shape: 10 (10)\n", - "I0307 01:34:31.884941 2099749632 layer_factory.hpp:74] Creating layer fc1\n", - "I0307 01:34:31.884951 2099749632 net.cpp:84] Creating Layer fc1\n", - "I0307 01:34:31.884958 2099749632 net.cpp:380] fc1 <- data\n", - "I0307 01:34:31.884989 2099749632 net.cpp:338] fc1 -> fc1\n", - "I0307 01:34:31.885000 2099749632 net.cpp:113] Setting up fc1\n", - "I0307 01:34:31.885017 2099749632 net.cpp:120] Top shape: 10 40 (400)\n", - "I0307 01:34:31.885030 2099749632 layer_factory.hpp:74] Creating layer relu1\n", - "I0307 01:34:31.885041 2099749632 net.cpp:84] Creating Layer relu1\n", - "I0307 01:34:31.885048 2099749632 net.cpp:380] relu1 <- fc1\n", - "I0307 01:34:31.885056 2099749632 net.cpp:327] relu1 -> fc1 (in-place)\n", - "I0307 01:34:31.885064 2099749632 net.cpp:113] Setting up relu1\n", - "I0307 01:34:31.885071 2099749632 net.cpp:120] Top shape: 10 40 (400)\n", - "I0307 01:34:31.885079 2099749632 layer_factory.hpp:74] Creating layer fc2\n", - "I0307 01:34:31.885088 2099749632 net.cpp:84] Creating Layer fc2\n", - "I0307 01:34:31.885094 2099749632 net.cpp:380] fc2 <- fc1\n", - "I0307 01:34:31.885103 2099749632 net.cpp:338] fc2 -> fc2\n", - "I0307 01:34:31.885113 2099749632 net.cpp:113] Setting up fc2\n", - "I0307 01:34:31.885126 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", - "I0307 01:34:31.885138 2099749632 layer_factory.hpp:74] Creating layer fc2_fc2_0_split\n", - "I0307 01:34:31.885149 2099749632 net.cpp:84] Creating Layer fc2_fc2_0_split\n", - "I0307 01:34:31.885155 2099749632 net.cpp:380] fc2_fc2_0_split <- fc2\n", - "I0307 01:34:31.885164 2099749632 net.cpp:338] fc2_fc2_0_split -> fc2_fc2_0_split_0\n", - "I0307 01:34:31.885174 2099749632 net.cpp:338] fc2_fc2_0_split -> fc2_fc2_0_split_1\n", - "I0307 01:34:31.885182 2099749632 net.cpp:113] Setting up fc2_fc2_0_split\n", - "I0307 01:34:31.885190 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", - "I0307 01:34:31.885242 2099749632 net.cpp:120] Top shape: 10 2 (20)\n", - "I0307 01:34:31.885256 2099749632 layer_factory.hpp:74] Creating layer loss\n", - "I0307 01:34:31.885267 2099749632 net.cpp:84] Creating Layer loss\n", - "I0307 01:34:31.885275 2099749632 net.cpp:380] loss <- fc2_fc2_0_split_0\n", - "I0307 01:34:31.885285 2099749632 net.cpp:380] loss <- label_data_1_split_0\n", - "I0307 01:34:31.885296 2099749632 net.cpp:338] loss -> loss\n", - "I0307 01:34:31.885308 2099749632 net.cpp:113] Setting up loss\n", - "I0307 01:34:31.885316 2099749632 layer_factory.hpp:74] Creating layer loss\n", - "I0307 01:34:31.885330 2099749632 net.cpp:120] Top shape: (1)\n", - "I0307 01:34:31.885337 2099749632 net.cpp:122] with loss weight 1\n", - "I0307 01:34:31.885346 2099749632 layer_factory.hpp:74] Creating layer accuracy\n", - "I0307 01:34:31.885360 2099749632 net.cpp:84] Creating Layer accuracy\n", - "I0307 01:34:31.885368 2099749632 net.cpp:380] accuracy <- fc2_fc2_0_split_1\n", - "I0307 01:34:31.885375 2099749632 net.cpp:380] accuracy <- label_data_1_split_1\n", - "I0307 01:34:31.885383 2099749632 net.cpp:338] accuracy -> accuracy\n", - "I0307 01:34:31.885392 2099749632 net.cpp:113] Setting up accuracy\n", - "I0307 01:34:31.885401 2099749632 net.cpp:120] Top shape: (1)\n", - "I0307 01:34:31.885407 2099749632 net.cpp:169] accuracy does not need backward computation.\n", - "I0307 01:34:31.885413 2099749632 net.cpp:167] loss needs backward computation.\n", - "I0307 01:34:31.885419 2099749632 net.cpp:167] fc2_fc2_0_split needs backward computation.\n", - "I0307 01:34:31.885426 2099749632 net.cpp:167] fc2 needs backward computation.\n", - "I0307 01:34:31.885432 2099749632 net.cpp:167] relu1 needs backward computation.\n", - "I0307 01:34:31.885438 2099749632 net.cpp:167] fc1 needs backward computation.\n", - "I0307 01:34:31.885444 2099749632 net.cpp:169] label_data_1_split does not need backward computation.\n", - "I0307 01:34:31.885452 2099749632 net.cpp:169] data does not need backward computation.\n", - "I0307 01:34:31.885457 2099749632 net.cpp:205] This network produces output accuracy\n", - "I0307 01:34:31.885613 2099749632 net.cpp:205] This network produces output loss\n", - "I0307 01:34:31.885632 2099749632 net.cpp:447] Collecting Learning Rate and Weight Decay.\n", - "I0307 01:34:31.885639 2099749632 net.cpp:217] Network initialization done.\n", - "I0307 01:34:31.885645 2099749632 net.cpp:218] Memory required for data: 3728\n", - "I0307 01:34:31.885685 2099749632 solver.cpp:42] Solver scaffolding done.\n", - "I0307 01:34:31.885711 2099749632 solver.cpp:222] Solving LogisticRegressionNet\n", - "I0307 01:34:31.885721 2099749632 solver.cpp:223] Learning Rate Policy: step\n", - "I0307 01:34:31.885730 2099749632 solver.cpp:266] Iteration 0, Testing net (#0)\n", - "I0307 01:34:31.901005 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.5944\n", - "I0307 01:34:31.901049 2099749632 solver.cpp:315] Test net output #1: loss = 0.693021 (* 1 = 0.693021 loss)\n", - "I0307 01:34:31.901177 2099749632 solver.cpp:189] Iteration 0, loss = 0.693163\n", - "I0307 01:34:31.901192 2099749632 solver.cpp:204] Train net output #0: loss = 0.693163 (* 1 = 0.693163 loss)\n", - "I0307 01:34:31.901203 2099749632 solver.cpp:464] Iteration 0, lr = 0.01\n", - "I0307 01:34:31.920586 2099749632 solver.cpp:266] Iteration 1000, Testing net (#0)\n", - "I0307 01:34:31.924612 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7556\n", - "I0307 01:34:31.924646 2099749632 solver.cpp:315] Test net output #1: loss = 0.511002 (* 1 = 0.511002 loss)\n", - "I0307 01:34:31.924684 2099749632 solver.cpp:189] Iteration 1000, loss = 0.38536\n", - "I0307 01:34:31.924696 2099749632 solver.cpp:204] Train net output #0: loss = 0.38536 (* 1 = 0.38536 loss)\n", - "I0307 01:34:31.924706 2099749632 solver.cpp:464] Iteration 1000, lr = 0.01\n", - "I0307 01:34:31.944727 2099749632 solver.cpp:266] Iteration 2000, Testing net (#0)\n", - "I0307 01:34:31.948729 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7824\n", - "I0307 01:34:31.948763 2099749632 solver.cpp:315] Test net output #1: loss = 0.489214 (* 1 = 0.489214 loss)\n", - "I0307 01:34:31.948799 2099749632 solver.cpp:189] Iteration 2000, loss = 0.532582\n", - "I0307 01:34:31.948812 2099749632 solver.cpp:204] Train net output #0: loss = 0.532582 (* 1 = 0.532582 loss)\n", - "I0307 01:34:31.948823 2099749632 solver.cpp:464] Iteration 2000, lr = 0.01\n", - "I0307 01:34:31.968670 2099749632 solver.cpp:266] Iteration 3000, Testing net (#0)\n", - "I0307 01:34:31.972393 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.7956\n", - "I0307 01:34:31.972411 2099749632 solver.cpp:315] Test net output #1: loss = 0.454184 (* 1 = 0.454184 loss)\n", - "I0307 01:34:31.973024 2099749632 solver.cpp:189] Iteration 3000, loss = 0.541374\n", - "I0307 01:34:31.973057 2099749632 solver.cpp:204] Train net output #0: loss = 0.541374 (* 1 = 0.541374 loss)\n", - "I0307 01:34:31.973067 2099749632 solver.cpp:464] Iteration 3000, lr = 0.01\n", - "I0307 01:34:31.994829 2099749632 solver.cpp:266] Iteration 4000, Testing net (#0)\n", - "I0307 01:34:31.998638 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.798\n", - "I0307 01:34:31.998663 2099749632 solver.cpp:315] Test net output #1: loss = 0.456348 (* 1 = 0.456348 loss)\n", - "I0307 01:34:31.998705 2099749632 solver.cpp:189] Iteration 4000, loss = 0.490437\n", - "I0307 01:34:31.998718 2099749632 solver.cpp:204] Train net output #0: loss = 0.490437 (* 1 = 0.490437 loss)\n", - "I0307 01:34:31.998725 2099749632 solver.cpp:464] Iteration 4000, lr = 0.01\n", - "I0307 01:34:32.021085 2099749632 solver.cpp:266] Iteration 5000, Testing net (#0)\n", - "I0307 01:34:32.024950 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.804\n", - "I0307 01:34:32.024981 2099749632 solver.cpp:315] Test net output #1: loss = 0.46184 (* 1 = 0.46184 loss)\n", - "I0307 01:34:32.025017 2099749632 solver.cpp:189] Iteration 5000, loss = 0.467703\n", - "I0307 01:34:32.025028 2099749632 solver.cpp:204] Train net output #0: loss = 0.467704 (* 1 = 0.467704 loss)\n", - "I0307 01:34:32.025038 2099749632 solver.cpp:464] Iteration 5000, lr = 0.001\n", - "I0307 01:34:32.044390 2099749632 solver.cpp:266] Iteration 6000, Testing net (#0)\n", - "I0307 01:34:32.048216 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8208\n", - "I0307 01:34:32.048239 2099749632 solver.cpp:315] Test net output #1: loss = 0.423084 (* 1 = 0.423084 loss)\n", - "I0307 01:34:32.048790 2099749632 solver.cpp:189] Iteration 6000, loss = 0.480104\n", - "I0307 01:34:32.048809 2099749632 solver.cpp:204] Train net output #0: loss = 0.480105 (* 1 = 0.480105 loss)\n", - "I0307 01:34:32.048827 2099749632 solver.cpp:464] Iteration 6000, lr = 0.001\n", - "I0307 01:34:32.067795 2099749632 solver.cpp:266] Iteration 7000, Testing net (#0)\n", - "I0307 01:34:32.071524 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8124\n", - "I0307 01:34:32.071542 2099749632 solver.cpp:315] Test net output #1: loss = 0.423947 (* 1 = 0.423947 loss)\n", - "I0307 01:34:32.071570 2099749632 solver.cpp:189] Iteration 7000, loss = 0.447471\n", - "I0307 01:34:32.071617 2099749632 solver.cpp:204] Train net output #0: loss = 0.447472 (* 1 = 0.447472 loss)\n", - "I0307 01:34:32.071626 2099749632 solver.cpp:464] Iteration 7000, lr = 0.001\n", - "I0307 01:34:32.091625 2099749632 solver.cpp:266] Iteration 8000, Testing net (#0)\n", - "I0307 01:34:32.095410 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.814\n", - "I0307 01:34:32.095432 2099749632 solver.cpp:315] Test net output #1: loss = 0.423586 (* 1 = 0.423586 loss)\n", - "I0307 01:34:32.095461 2099749632 solver.cpp:189] Iteration 8000, loss = 0.386258\n", - "I0307 01:34:32.095474 2099749632 solver.cpp:204] Train net output #0: loss = 0.386259 (* 1 = 0.386259 loss)\n", - "I0307 01:34:32.095481 2099749632 solver.cpp:464] Iteration 8000, lr = 0.001\n", - "I0307 01:34:32.117184 2099749632 solver.cpp:266] Iteration 9000, Testing net (#0)\n", - "I0307 01:34:32.121587 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8208\n", - "I0307 01:34:32.121608 2099749632 solver.cpp:315] Test net output #1: loss = 0.419969 (* 1 = 0.419969 loss)\n", - "I0307 01:34:32.122161 2099749632 solver.cpp:189] Iteration 9000, loss = 0.468262\n", - "I0307 01:34:32.122181 2099749632 solver.cpp:204] Train net output #0: loss = 0.468262 (* 1 = 0.468262 loss)\n", - "I0307 01:34:32.122191 2099749632 solver.cpp:464] Iteration 9000, lr = 0.001\n", - "I0307 01:34:32.141635 2099749632 solver.cpp:334] Snapshotting to hdf5_classification/data/train_iter_10000.caffemodel\n", - "I0307 01:34:32.141860 2099749632 solver.cpp:342] Snapshotting solver state to hdf5_classification/data/train_iter_10000.solverstate\n", - "I0307 01:34:32.141978 2099749632 solver.cpp:248] Iteration 10000, loss = 0.441529\n", - "I0307 01:34:32.141995 2099749632 solver.cpp:266] Iteration 10000, Testing net (#0)\n", - "I0307 01:34:32.145747 2099749632 solver.cpp:315] Test net output #0: accuracy = 0.8148\n", - "I0307 01:34:32.145771 2099749632 solver.cpp:315] Test net output #1: loss = 0.4216 (* 1 = 0.4216 loss)\n", - "I0307 01:34:32.145779 2099749632 solver.cpp:253] Optimization Done.\n", - "I0307 01:34:32.145786 2099749632 caffe.cpp:121] Optimization Done.\n" - ] - } - ], - "source": [ - "!../build/tools/caffe train -solver hdf5_classification/solver2.prototxt" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Clean up (comment this out if you want to examine the hdf5_classification/data directory).\n", - "shutil.rmtree(dirname)" - ] - } - ], - "metadata": { - "description": "Use Caffe as a generic SGD optimizer to train logistic regression on non-image HDF5 data.", - "example_name": "Off-the-shelf SGD for classification", - "include_in_docs": true, - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.9" - }, - "priority": 4 - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/examples/hdf5_classification/nonlinear_auto_test.prototxt b/examples/hdf5_classification/nonlinear_auto_test.prototxt new file mode 100644 index 00000000000..53eda6ee8a0 --- /dev/null +++ b/examples/hdf5_classification/nonlinear_auto_test.prototxt @@ -0,0 +1,54 @@ +layer { + name: "data" + type: "HDF5Data" + top: "data" + top: "label" + hdf5_data_param { + source: "examples/hdf5_classification/data/test.txt" + batch_size: 10 + } +} +layer { + name: "ip1" + type: "InnerProduct" + bottom: "data" + top: "ip1" + inner_product_param { + num_output: 40 + weight_filler { + type: "xavier" + } + } +} +layer { + name: "relu1" + type: "ReLU" + bottom: "ip1" + top: "ip1" +} +layer { + name: "ip2" + type: "InnerProduct" + bottom: "ip1" + top: "ip2" + inner_product_param { + num_output: 2 + weight_filler { + type: "xavier" + } + } +} +layer { + name: "accuracy" + type: "Accuracy" + bottom: "ip2" + bottom: "label" + top: "accuracy" +} +layer { + name: "loss" + type: "SoftmaxWithLoss" + bottom: "ip2" + bottom: "label" + top: "loss" +} diff --git a/examples/hdf5_classification/nonlinear_auto_train.prototxt b/examples/hdf5_classification/nonlinear_auto_train.prototxt new file mode 100644 index 00000000000..fc0688fa652 --- /dev/null +++ b/examples/hdf5_classification/nonlinear_auto_train.prototxt @@ -0,0 +1,54 @@ +layer { + name: "data" + type: "HDF5Data" + top: "data" + top: "label" + hdf5_data_param { + source: "examples/hdf5_classification/data/train.txt" + batch_size: 10 + } +} +layer { + name: "ip1" + type: "InnerProduct" + bottom: "data" + top: "ip1" + inner_product_param { + num_output: 40 + weight_filler { + type: "xavier" + } + } +} +layer { + name: "relu1" + type: "ReLU" + bottom: "ip1" + top: "ip1" +} +layer { + name: "ip2" + type: "InnerProduct" + bottom: "ip1" + top: "ip2" + inner_product_param { + num_output: 2 + weight_filler { + type: "xavier" + } + } +} +layer { + name: "accuracy" + type: "Accuracy" + bottom: "ip2" + bottom: "label" + top: "accuracy" +} +layer { + name: "loss" + type: "SoftmaxWithLoss" + bottom: "ip2" + bottom: "label" + top: "loss" +} diff --git a/examples/hdf5_classification/nonlinear_solver.prototxt b/examples/hdf5_classification/nonlinear_solver.prototxt new file mode 100644 index 00000000000..b4aacf6e423 --- /dev/null +++ b/examples/hdf5_classification/nonlinear_solver.prototxt @@ -0,0 +1,15 @@ +train_net: "examples/hdf5_classification/nonlinear_auto_train.prototxt" +test_net: "examples/hdf5_classification/nonlinear_auto_test.prototxt" +test_iter: 250 +test_interval: 1000 +base_lr: 0.01 +lr_policy: "step" +gamma: 0.1 +stepsize: 5000 +display: 1000 +max_iter: 10000 +momentum: 0.9 +weight_decay: 0.0005 +snapshot: 10000 +snapshot_prefix: "examples/hdf5_classification/data/train" +solver_mode: CPU diff --git a/examples/hdf5_classification/train_val2.prototxt b/examples/hdf5_classification/nonlinear_train_val.prototxt similarity index 87% rename from examples/hdf5_classification/train_val2.prototxt rename to examples/hdf5_classification/nonlinear_train_val.prototxt index 8795e8facb6..8f7ef04f58a 100644 --- a/examples/hdf5_classification/train_val2.prototxt +++ b/examples/hdf5_classification/nonlinear_train_val.prototxt @@ -8,7 +8,7 @@ layer { phase: TRAIN } hdf5_data_param { - source: "hdf5_classification/data/train.txt" + source: "examples/hdf5_classification/data/train.txt" batch_size: 10 } } @@ -21,7 +21,7 @@ layer { phase: TEST } hdf5_data_param { - source: "hdf5_classification/data/test.txt" + source: "examples/hdf5_classification/data/test.txt" batch_size: 10 } } @@ -41,8 +41,7 @@ layer { inner_product_param { num_output: 40 weight_filler { - type: "gaussian" - std: 0.01 + type: "xavier" } bias_filler { type: "constant" @@ -72,8 +71,7 @@ layer { inner_product_param { num_output: 2 weight_filler { - type: "gaussian" - std: 0.01 + type: "xavier" } bias_filler { type: "constant" diff --git a/examples/hdf5_classification/solver.prototxt b/examples/hdf5_classification/solver.prototxt index 65a6eb9e9fb..8587b5a1e5a 100644 --- a/examples/hdf5_classification/solver.prototxt +++ b/examples/hdf5_classification/solver.prototxt @@ -1,4 +1,5 @@ -net: "hdf5_classification/train_val.prototxt" +train_net: "examples/hdf5_classification/logreg_auto_train.prototxt" +test_net: "examples/hdf5_classification/logreg_auto_test.prototxt" test_iter: 250 test_interval: 1000 base_lr: 0.01 @@ -10,5 +11,5 @@ max_iter: 10000 momentum: 0.9 weight_decay: 0.0005 snapshot: 10000 -snapshot_prefix: "hdf5_classification/data/train" +snapshot_prefix: "examples/hdf5_classification/data/train" solver_mode: CPU diff --git a/examples/hdf5_classification/solver2.prototxt b/examples/hdf5_classification/solver2.prototxt deleted file mode 100644 index 32b9feba346..00000000000 --- a/examples/hdf5_classification/solver2.prototxt +++ /dev/null @@ -1,14 +0,0 @@ -net: "hdf5_classification/train_val2.prototxt" -test_iter: 250 -test_interval: 1000 -base_lr: 0.01 -lr_policy: "step" -gamma: 0.1 -stepsize: 5000 -display: 1000 -max_iter: 10000 -momentum: 0.9 -weight_decay: 0.0005 -snapshot: 10000 -snapshot_prefix: "hdf5_classification/data/train" -solver_mode: CPU diff --git a/examples/hdf5_classification/train_val.prototxt b/examples/hdf5_classification/train_val.prototxt index d5e8dbfa169..13ddf47524a 100644 --- a/examples/hdf5_classification/train_val.prototxt +++ b/examples/hdf5_classification/train_val.prototxt @@ -8,7 +8,7 @@ layer { phase: TRAIN } hdf5_data_param { - source: "hdf5_classification/data/train.txt" + source: "examples/hdf5_classification/data/train.txt" batch_size: 10 } } @@ -21,7 +21,7 @@ layer { phase: TEST } hdf5_data_param { - source: "hdf5_classification/data/test.txt" + source: "examples/hdf5_classification/data/test.txt" batch_size: 10 } } @@ -41,8 +41,7 @@ layer { inner_product_param { num_output: 2 weight_filler { - type: "gaussian" - std: 0.01 + type: "xavier" } bias_filler { type: "constant" diff --git a/examples/mnist/lenet_auto_solver.prototxt b/examples/mnist/lenet_auto_solver.prototxt new file mode 100644 index 00000000000..fa4bbf02710 --- /dev/null +++ b/examples/mnist/lenet_auto_solver.prototxt @@ -0,0 +1,24 @@ +# The train/test net protocol buffer definition +train_net: "examples/mnist/lenet_auto_train.prototxt" +test_net: "examples/mnist/lenet_auto_test.prototxt" +# test_iter specifies how many forward passes the test should carry out. +# In the case of MNIST, we have test batch size 100 and 100 test iterations, +# covering the full 10,000 testing images. +test_iter: 100 +# Carry out testing every 500 training iterations. +test_interval: 500 +# The base learning rate, momentum and the weight decay of the network. +base_lr: 0.01 +momentum: 0.9 +weight_decay: 0.0005 +# The learning rate policy +lr_policy: "inv" +gamma: 0.0001 +power: 0.75 +# Display every 100 iterations +display: 100 +# The maximum number of iterations +max_iter: 10000 +# snapshot intermediate results +snapshot: 5000 +snapshot_prefix: "examples/mnist/lenet" diff --git a/examples/net_surgery.ipynb b/examples/net_surgery.ipynb index 303c22ba3fd..ff780fbb9f7 100644 --- a/examples/net_surgery.ipynb +++ b/examples/net_surgery.ipynb @@ -6884,7 +6884,7 @@ } ], "metadata": { - "description": "How to do net surgery and manually change model parameters, making a fully-convolutional classifier for dense feature extraction.", + "description": "How to do net surgery and manually change model parameters for custom use.", "example_name": "Editing model parameters", "include_in_docs": true, "kernelspec": { diff --git a/examples/siamese/mnist_siamese.ipynb b/examples/siamese/mnist_siamese.ipynb index 11cae120db2..1a4e30eda43 100644 --- a/examples/siamese/mnist_siamese.ipynb +++ b/examples/siamese/mnist_siamese.ipynb @@ -1902,7 +1902,7 @@ "pygments_lexer": "ipython2", "version": "2.7.9" }, - "priority": 6 + "priority": 7 }, "nbformat": 4, "nbformat_minor": 0 From 7003d1b8e24416cb5bdb5537a7805cb5a9de2ca1 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Tue, 30 Jun 2015 15:35:21 -0700 Subject: [PATCH 075/331] [examples] add Euclidean loss PythonLayer --- examples/pycaffe/layers/pyloss.py | 37 +++++++++++++++++++ examples/pycaffe/linreg.prototxt | 60 +++++++++++++++++++++++++++++++ 2 files changed, 97 insertions(+) create mode 100644 examples/pycaffe/layers/pyloss.py create mode 100644 examples/pycaffe/linreg.prototxt diff --git a/examples/pycaffe/layers/pyloss.py b/examples/pycaffe/layers/pyloss.py new file mode 100644 index 00000000000..6200e6bbc55 --- /dev/null +++ b/examples/pycaffe/layers/pyloss.py @@ -0,0 +1,37 @@ +import caffe +import numpy as np + + +class EuclideanLossLayer(caffe.Layer): + """ + Compute the Euclidean Loss in the same manner as the C++ EuclideanLossLayer + to demonstrate the class interface for developing layers in Python. + """ + + def setup(self, bottom, top): + # check input pair + if len(bottom) != 2: + raise Exception("Need two inputs to compute distance.") + + def reshape(self, bottom, top): + # check input dimensions match + if bottom[0].count != bottom[1].count: + raise Exception("Inputs must have the same dimension.") + # difference is shape of inputs + self.diff = np.zeros_like(bottom[0].data, dtype=np.float32) + # loss output is scalar + top[0].reshape(1) + + def forward(self, bottom, top): + self.diff[...] = bottom[0].data - bottom[1].data + top[0].data[...] = np.sum(self.diff**2) / bottom[0].num / 2. + + def backward(self, top, propagate_down, bottom): + for i in range(2): + if not propagate_down[i]: + continue + if i == 0: + sign = 1 + else: + sign = -1 + bottom[i].diff[...] = sign * self.diff / bottom[i].num diff --git a/examples/pycaffe/linreg.prototxt b/examples/pycaffe/linreg.prototxt new file mode 100644 index 00000000000..c0fb0776d0a --- /dev/null +++ b/examples/pycaffe/linreg.prototxt @@ -0,0 +1,60 @@ +name: 'LinearRegressionExample' +# define a simple network for linear regression on dummy data +# that computes the loss by a PythonLayer. +layer { + type: 'DummyData' + name: 'x' + top: 'x' + dummy_data_param { + shape: { dim: 10 dim: 3 dim: 2 } + data_filler: { type: 'gaussian' } + } +} +layer { + type: 'DummyData' + name: 'y' + top: 'y' + dummy_data_param { + shape: { dim: 10 dim: 3 dim: 2 } + data_filler: { type: 'gaussian' } + } +} +# include InnerProduct layers for parameters +# so the net will need backward +layer { + type: 'InnerProduct' + name: 'ipx' + top: 'ipx' + bottom: 'x' + inner_product_param { + num_output: 10 + weight_filler { type: 'xavier' } + } +} +layer { + type: 'InnerProduct' + name: 'ipy' + top: 'ipy' + bottom: 'y' + inner_product_param { + num_output: 10 + weight_filler { type: 'xavier' } + } +} +layer { + type: 'Python' + name: 'loss' + top: 'loss' + bottom: 'ipx' + bottom: 'ipy' + python_param { + # the module name -- usually the filename -- that needs to be in $PYTHONPATH + module: 'pyloss' + # the layer name -- the class name in the module + layer: 'EuclideanLossLayer' + } + # set loss weight so Caffe knows this is a loss layer. + # since PythonLayer inherits directly from Layer, this isn't automatically + # known to Caffe + loss_weight: 1 +} From 41df4cdce942c22f0d89ad8b0990d3ee7bd9cf31 Mon Sep 17 00:00:00 2001 From: Takuya Narihira Date: Thu, 26 Mar 2015 19:04:15 -0700 Subject: [PATCH 076/331] bilinear filler -- useful for interpolation with DeconvolutionLayer This filler is a convenience for interpolating with DeconvolutionLayer or smoothing + downsampling with ConvolutionLayer for stride > 1. --- include/caffe/filler.hpp | 56 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/include/caffe/filler.hpp b/include/caffe/filler.hpp index ff3542e1f99..888f4a4ba3b 100644 --- a/include/caffe/filler.hpp +++ b/include/caffe/filler.hpp @@ -208,6 +208,60 @@ class MSRAFiller : public Filler { } }; +/*! +@brief Fills a Blob with coefficients for bilinear interpolation. + +A common use case is with the DeconvolutionLayer acting as upsampling. +You can upsample a feature map with shape of (B, C, H, W) by any integer factor +using the following proto. +\code +layer { + name: "upsample", type: "Deconvolution" + bottom: "{{bottom_name}}" top: "{{top_name}}" + convolution_param { + kernel_size: {{2 * factor - factor % 2}} stride: {{factor}} + num_output: {{C}} group: {{C}} + pad: {{ceil((factor - 1) / 2.)}} + weight_filler: { type: "bilinear" } bias_term: false + } + param { lr_mult: 0 decay_mult: 0 } +} +\endcode +Please use this by replacing `{{}}` with your values. By specifying +`num_output: {{C}} group: {{C}}`, it behaves as +channel-wise convolution. The filter shape of this deconvolution layer will be +(C, 1, K, K) where K is `kernel_size`, and this filler will set a (K, K) +interpolation kernel for every channel of the filter identically. The resulting +shape of the top feature map will be (B, C, factor * H, factor * W). +Note that the learning rate and the +weight decay are set to 0 in order to keep coefficient values of bilinear +interpolation unchanged during training. If you apply this to an image, this +operation is equivalent to the following call in Python with Scikit.Image. +\code{.py} +out = skimage.transform.rescale(img, factor, mode='constant', cval=0) +\endcode + */ +template +class BilinearFiller : public Filler { + public: + explicit BilinearFiller(const FillerParameter& param) + : Filler(param) {} + virtual void Fill(Blob* blob) { + CHECK_EQ(blob->num_axes(), 4) << "Blob must be 4 dim."; + CHECK_EQ(blob->width(), blob->height()) << "Filter must be square"; + Dtype* data = blob->mutable_cpu_data(); + int f = ceil(blob->width() / 2.); + float c = (2 * f - 1 - f % 2) / (2. * f); + for (int i = 0; i < blob->count(); ++i) { + float x = i % blob->width(); + float y = (i / blob->width()) % blob->height(); + data[i] = (1 - fabs(x / f - c)) * (1 - fabs(y / f - c)); + } + CHECK_EQ(this->filler_param_.sparse(), -1) + << "Sparsity not supported by this Filler."; + } +}; + /** * @brief Get a specific filler from the specification given in FillerParameter. * @@ -229,6 +283,8 @@ Filler* GetFiller(const FillerParameter& param) { return new XavierFiller(param); } else if (type == "msra") { return new MSRAFiller(param); + } else if (type == "bilinear") { + return new BilinearFiller(param); } else { CHECK(false) << "Unknown filler name: " << param.type(); } From 7d3a8e9f34bb8ac44ec9ab91b7229f6c57fd7ee1 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Wed, 1 Jul 2015 16:44:05 -0700 Subject: [PATCH 077/331] Update installation docs for boost - close #2454 --- docs/install_apt.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/install_apt.md b/docs/install_apt.md index 75f8bec0e95..0fa205ab2cf 100644 --- a/docs/install_apt.md +++ b/docs/install_apt.md @@ -6,7 +6,8 @@ title: Installation: Ubuntu **General dependencies** - sudo apt-get install libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libboost-all-dev libhdf5-serial-dev + sudo apt-get install libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libhdf5-serial-dev + sudo apt-get install --no-install-recommends libboost-all-dev **CUDA**: Install via the NVIDIA package instead of `apt-get` to be certain of the library and driver versions. Install the library and latest driver separately; the driver bundled with the library is usually out-of-date. From 90750550d5f6ee7dd1937777b522189b9266634f Mon Sep 17 00:00:00 2001 From: Felix Abecassis Date: Thu, 2 Jul 2015 11:42:37 -0700 Subject: [PATCH 078/331] Optimize inner product layer for special case M == 1 Using gemm with one of the operand being a vector or a scalar is suboptimal. Functions gemv and axpy should be prefered in these cases. --- src/caffe/layers/inner_product_layer.cu | 19 ++++++--- src/caffe/test/test_inner_product_layer.cpp | 43 ++++++++++++++++++++- 2 files changed, 54 insertions(+), 8 deletions(-) diff --git a/src/caffe/layers/inner_product_layer.cu b/src/caffe/layers/inner_product_layer.cu index dd90cac12a8..c0ebd2c47da 100644 --- a/src/caffe/layers/inner_product_layer.cu +++ b/src/caffe/layers/inner_product_layer.cu @@ -15,12 +15,19 @@ void InnerProductLayer::Forward_gpu(const vector*>& bottom, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); const Dtype* weight = this->blobs_[0]->gpu_data(); - caffe_gpu_gemm(CblasNoTrans, CblasTrans, M_, N_, K_, (Dtype)1., - bottom_data, weight, (Dtype)0., top_data); - if (bias_term_) { - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, M_, N_, 1, (Dtype)1., - bias_multiplier_.gpu_data(), - this->blobs_[1]->gpu_data(), (Dtype)1., top_data); + if (M_ == 1) { + caffe_gpu_gemv(CblasNoTrans, N_, K_, (Dtype)1., + weight, bottom_data, (Dtype)0., top_data); + if (bias_term_) + caffe_gpu_axpy(N_, bias_multiplier_.cpu_data()[0], + this->blobs_[1]->gpu_data(), top_data); + } else { + caffe_gpu_gemm(CblasNoTrans, CblasTrans, M_, N_, K_, (Dtype)1., + bottom_data, weight, (Dtype)0., top_data); + if (bias_term_) + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, M_, N_, 1, (Dtype)1., + bias_multiplier_.gpu_data(), + this->blobs_[1]->gpu_data(), (Dtype)1., top_data); } } diff --git a/src/caffe/test/test_inner_product_layer.cpp b/src/caffe/test/test_inner_product_layer.cpp index c03df17383a..fbf0c851220 100644 --- a/src/caffe/test/test_inner_product_layer.cpp +++ b/src/caffe/test/test_inner_product_layer.cpp @@ -23,16 +23,21 @@ class InnerProductLayerTest : public MultiDeviceTest { protected: InnerProductLayerTest() : blob_bottom_(new Blob(2, 3, 4, 5)), + blob_bottom_nobatch_(new Blob(1, 2, 3, 4)), blob_top_(new Blob()) { // fill the values FillerParameter filler_param; UniformFiller filler(filler_param); filler.Fill(this->blob_bottom_); - blob_bottom_vec_.push_back(blob_bottom_); blob_top_vec_.push_back(blob_top_); } - virtual ~InnerProductLayerTest() { delete blob_bottom_; delete blob_top_; } + virtual ~InnerProductLayerTest() { + delete blob_bottom_; + delete blob_bottom_nobatch_; + delete blob_top_; + } Blob* const blob_bottom_; + Blob* const blob_bottom_nobatch_; Blob* const blob_top_; vector*> blob_bottom_vec_; vector*> blob_top_vec_; @@ -42,6 +47,7 @@ TYPED_TEST_CASE(InnerProductLayerTest, TestDtypesAndDevices); TYPED_TEST(InnerProductLayerTest, TestSetUp) { typedef typename TypeParam::Dtype Dtype; + this->blob_bottom_vec_.push_back(this->blob_bottom_); LayerParameter layer_param; InnerProductParameter* inner_product_param = layer_param.mutable_inner_product_param(); @@ -57,6 +63,38 @@ TYPED_TEST(InnerProductLayerTest, TestSetUp) { TYPED_TEST(InnerProductLayerTest, TestForward) { typedef typename TypeParam::Dtype Dtype; + this->blob_bottom_vec_.push_back(this->blob_bottom_); + bool IS_VALID_CUDA = false; +#ifndef CPU_ONLY + IS_VALID_CUDA = CAFFE_TEST_CUDA_PROP.major >= 2; +#endif + if (Caffe::mode() == Caffe::CPU || + sizeof(Dtype) == 4 || IS_VALID_CUDA) { + LayerParameter layer_param; + InnerProductParameter* inner_product_param = + layer_param.mutable_inner_product_param(); + inner_product_param->set_num_output(10); + inner_product_param->mutable_weight_filler()->set_type("uniform"); + inner_product_param->mutable_bias_filler()->set_type("uniform"); + inner_product_param->mutable_bias_filler()->set_min(1); + inner_product_param->mutable_bias_filler()->set_max(2); + shared_ptr > layer( + new InnerProductLayer(layer_param)); + layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer->Forward(this->blob_bottom_vec_, this->blob_top_vec_); + const Dtype* data = this->blob_top_->cpu_data(); + const int count = this->blob_top_->count(); + for (int i = 0; i < count; ++i) { + EXPECT_GE(data[i], 1.); + } + } else { + LOG(ERROR) << "Skipping test due to old architecture."; + } +} + +TYPED_TEST(InnerProductLayerTest, TestForwardNoBatch) { + typedef typename TypeParam::Dtype Dtype; + this->blob_bottom_vec_.push_back(this->blob_bottom_nobatch_); bool IS_VALID_CUDA = false; #ifndef CPU_ONLY IS_VALID_CUDA = CAFFE_TEST_CUDA_PROP.major >= 2; @@ -87,6 +125,7 @@ TYPED_TEST(InnerProductLayerTest, TestForward) { TYPED_TEST(InnerProductLayerTest, TestGradient) { typedef typename TypeParam::Dtype Dtype; + this->blob_bottom_vec_.push_back(this->blob_bottom_); bool IS_VALID_CUDA = false; #ifndef CPU_ONLY IS_VALID_CUDA = CAFFE_TEST_CUDA_PROP.major >= 2; From 58b114ff68416c24fe7b7a344c51e686edc0c2fb Mon Sep 17 00:00:00 2001 From: semitrivial Date: Tue, 7 Jul 2015 08:29:16 +0100 Subject: [PATCH 079/331] List protobuf-compiler dependency in the correct place (it is in the package managers for both 14.04 and 12.04) --- docs/install_apt.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/install_apt.md b/docs/install_apt.md index 0fa205ab2cf..f588b74dcdb 100644 --- a/docs/install_apt.md +++ b/docs/install_apt.md @@ -6,7 +6,7 @@ title: Installation: Ubuntu **General dependencies** - sudo apt-get install libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libhdf5-serial-dev + sudo apt-get install libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libhdf5-serial-dev protobuf-compiler sudo apt-get install --no-install-recommends libboost-all-dev **CUDA**: Install via the NVIDIA package instead of `apt-get` to be certain of the library and driver versions. @@ -21,7 +21,7 @@ This can be skipped for CPU-only installation. Everything is packaged in 14.04. - sudo apt-get install libgflags-dev libgoogle-glog-dev liblmdb-dev protobuf-compiler + sudo apt-get install libgflags-dev libgoogle-glog-dev liblmdb-dev **Remaining dependencies, 12.04** From a08bfb5c9200533c845ac05ae2a6d419fcae69f2 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Tue, 7 Jul 2015 21:30:33 -0700 Subject: [PATCH 080/331] Fix CMake typos No functional changes, just fixing whitespace errors and typos in comments --- CMakeLists.txt | 4 ++-- cmake/ConfigGen.cmake | 2 +- cmake/External/gflags.cmake | 4 ++-- cmake/External/glog.cmake | 2 +- cmake/Misc.cmake | 2 +- cmake/ProtoBuf.cmake | 4 ++-- cmake/Summary.cmake | 4 ++-- cmake/Targets.cmake | 6 +++--- cmake/Templates/CaffeConfig.cmake.in | 6 +++--- cmake/Templates/CaffeConfigVersion.cmake.in | 2 +- cmake/Utils.cmake | 10 +++++----- cmake/lint.cmake | 4 ++-- 12 files changed, 25 insertions(+), 25 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f22aa5763a3..e202350224f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -15,14 +15,14 @@ include(cmake/Summary.cmake) include(cmake/ConfigGen.cmake) # ---[ Options -caffe_option(CPU_ONLY "Build Caffe wihtout CUDA support" OFF) # TODO: rename to USE_CUDA +caffe_option(CPU_ONLY "Build Caffe without CUDA support" OFF) # TODO: rename to USE_CUDA caffe_option(USE_CUDNN "Build Caffe with cuDNN libary support" ON IF NOT CPU_ONLY) caffe_option(BUILD_SHARED_LIBS "Build shared libraries" ON) caffe_option(BUILD_python "Build Python wrapper" ON) set(python_version "2" CACHE STRING "Specify which python version to use") caffe_option(BUILD_matlab "Build Matlab wrapper" OFF IF UNIX OR APPLE) caffe_option(BUILD_docs "Build documentation" ON IF UNIX OR APPLE) -caffe_option(BUILD_python_layer "Build the caffe python layer" ON) +caffe_option(BUILD_python_layer "Build the Caffe python layer" ON) # ---[ Dependencies include(cmake/Dependencies.cmake) diff --git a/cmake/ConfigGen.cmake b/cmake/ConfigGen.cmake index a9101e34350..566d6ca0aa7 100644 --- a/cmake/ConfigGen.cmake +++ b/cmake/ConfigGen.cmake @@ -88,7 +88,7 @@ function(caffe_generate_export_configs) configure_file("cmake/Templates/CaffeConfig.cmake.in" "${PROJECT_BINARY_DIR}/cmake/CaffeConfig.cmake" @ONLY) - # Install the CaffeConfig.cmake and export set to use wuth install-tree + # Install the CaffeConfig.cmake and export set to use with install-tree install(FILES "${PROJECT_BINARY_DIR}/cmake/CaffeConfig.cmake" DESTINATION ${install_cmake_suffix}) install(EXPORT CaffeTargets DESTINATION ${install_cmake_suffix}) diff --git a/cmake/External/gflags.cmake b/cmake/External/gflags.cmake index a50a0925086..e3dba04f33f 100644 --- a/cmake/External/gflags.cmake +++ b/cmake/External/gflags.cmake @@ -43,10 +43,10 @@ if (NOT __GFLAGS_INCLUDED) # guard against multiple includes LOG_DOWNLOAD 1 LOG_INSTALL 1 ) - + set(GFLAGS_FOUND TRUE) set(GFLAGS_INCLUDE_DIRS ${gflags_INSTALL}/include) - set(GFLAGS_LIBRARIES ${gflags_INSTALL}/lib/libgflags.a ${CMAKE_THREAD_LIBS_INIT}) + set(GFLAGS_LIBRARIES ${gflags_INSTALL}/lib/libgflags.a ${CMAKE_THREAD_LIBS_INIT}) set(GFLAGS_LIBRARY_DIRS ${gflags_INSTALL}/lib) set(GFLAGS_EXTERNAL TRUE) diff --git a/cmake/External/glog.cmake b/cmake/External/glog.cmake index 02b39dde676..a44672f2753 100644 --- a/cmake/External/glog.cmake +++ b/cmake/External/glog.cmake @@ -29,7 +29,7 @@ if (NOT __GLOG_INCLUDED) if (GFLAGS_EXTERNAL) set(GLOG_DEPENDS gflags) endif() - + ExternalProject_Add(glog DEPENDS ${GLOG_DEPENDS} PREFIX ${glog_PREFIX} diff --git a/cmake/Misc.cmake b/cmake/Misc.cmake index 39569eaf996..7676754fe04 100644 --- a/cmake/Misc.cmake +++ b/cmake/Misc.cmake @@ -1,4 +1,4 @@ -# ---[ Configurations types +# ---[ Configuration types set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Possible configurations" FORCE) mark_as_advanced(CMAKE_CONFIGURATION_TYPES) diff --git a/cmake/ProtoBuf.cmake b/cmake/ProtoBuf.cmake index 8946d66c57b..fc799bd3906 100644 --- a/cmake/ProtoBuf.cmake +++ b/cmake/ProtoBuf.cmake @@ -1,12 +1,12 @@ # Finds Google Protocol Buffers library and compilers and extends -# the standart cmake script with version and python generation support +# the standard cmake script with version and python generation support find_package( Protobuf REQUIRED ) include_directories(SYSTEM ${PROTOBUF_INCLUDE_DIR}) list(APPEND Caffe_LINKER_LIBS ${PROTOBUF_LIBRARIES}) # As of Ubuntu 14.04 protoc is no longer a part of libprotobuf-dev package -# and should be installed separately as in: sudo apt-get install protobuf-compiler +# and should be installed separately as in: sudo apt-get install protobuf-compiler if(EXISTS ${PROTOBUF_PROTOC_EXECUTABLE}) message(STATUS "Found PROTOBUF Compiler: ${PROTOBUF_PROTOC_EXECUTABLE}") else() diff --git a/cmake/Summary.cmake b/cmake/Summary.cmake index 32931942846..e094ac0040e 100644 --- a/cmake/Summary.cmake +++ b/cmake/Summary.cmake @@ -87,7 +87,7 @@ endfunction() ################################################################################################ -# Prints accumulatd caffe configuration summary +# Prints accumulated caffe configuration summary # Usage: # caffe_print_configuration_summary() @@ -119,7 +119,7 @@ function(caffe_print_configuration_summary) caffe_status(" BLAS : " APPLE THEN "Yes (vecLib)" ELSE "Yes (${BLAS})") caffe_status(" Boost : Yes (ver. ${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION})") caffe_status(" glog : Yes") - caffe_status(" gflags : Yes") + caffe_status(" gflags : Yes") caffe_status(" protobuf : " PROTOBUF_FOUND THEN "Yes (ver. ${PROTOBUF_VERSION})" ELSE "No" ) caffe_status(" lmdb : " LMDB_FOUND THEN "Yes (ver. ${LMDB_VERSION})" ELSE "No") caffe_status(" Snappy : " SNAPPY_FOUND THEN "Yes (ver. ${Snappy_VERSION})" ELSE "No" ) diff --git a/cmake/Targets.cmake b/cmake/Targets.cmake index ed0ff9660fd..2401f252e93 100644 --- a/cmake/Targets.cmake +++ b/cmake/Targets.cmake @@ -31,7 +31,7 @@ endfunction() ################################################################################################ # Collecting sources from globbing and appending to output list variable # Usage: -# caffe_source_group( GLOB[_RECURSE] ) +# caffe_collect_sources( GLOB[_RECURSE] ) function(caffe_collect_sources variable) cmake_parse_arguments(CAFFE_COLLECT_SOURCES "" "" "GLOB;GLOB_RECURSE" ${ARGN}) if(CAFFE_COLLECT_SOURCES_GLOB) @@ -144,12 +144,12 @@ function(caffe_configure_testdatafile file) set(result "") foreach(line ${__lines}) set(result "${result}${PROJECT_SOURCE_DIR}/${line}\n") - endforeach() + endforeach() file(WRITE ${file}.gen.cmake ${result}) endfunction() ################################################################################################ -# Filter outs all files that are not inlcuded in selected list +# Filter out all files that are not included in selected list # Usage: # caffe_leave_only_selected_tests( ) function(caffe_leave_only_selected_tests file_list) diff --git a/cmake/Templates/CaffeConfig.cmake.in b/cmake/Templates/CaffeConfig.cmake.in index a4b03d961e0..8f23742e52e 100644 --- a/cmake/Templates/CaffeConfig.cmake.in +++ b/cmake/Templates/CaffeConfig.cmake.in @@ -4,7 +4,7 @@ # Caffe and this config file depends on opencv, # so put `find_package(OpenCV)` before searching Caffe # via `find_package(Caffe)`. All other lib/includes -# dependencies are hard coded int the file +# dependencies are hard coded in the file # # After successful configuration the following variables # will be defined: @@ -15,7 +15,7 @@ # # Caffe_HAVE_CUDA - signals about CUDA support # Caffe_HAVE_CUDNN - signals about cuDNN support - + # OpenCV dependency @@ -40,7 +40,7 @@ get_filename_component(Caffe_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) set(Caffe_INCLUDE_DIRS "@Caffe_INCLUDE_DIRS@") @Caffe_INSTALL_INCLUDE_DIR_APPEND_COMMAND@ - + # Our library dependencies if(NOT TARGET caffe AND NOT caffe_BINARY_DIR) include("${Caffe_CMAKE_DIR}/CaffeTargets.cmake") diff --git a/cmake/Templates/CaffeConfigVersion.cmake.in b/cmake/Templates/CaffeConfigVersion.cmake.in index cbfa514f1a6..19f85309a5f 100644 --- a/cmake/Templates/CaffeConfigVersion.cmake.in +++ b/cmake/Templates/CaffeConfigVersion.cmake.in @@ -1,5 +1,5 @@ set(PACKAGE_VERSION "@Caffe_VERSION@") - + # Check whether the requested PACKAGE_FIND_VERSION is compatible if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}") set(PACKAGE_VERSION_COMPATIBLE FALSE) diff --git a/cmake/Utils.cmake b/cmake/Utils.cmake index a56c7c300c0..a1bde1ae95b 100644 --- a/cmake/Utils.cmake +++ b/cmake/Utils.cmake @@ -1,7 +1,7 @@ ################################################################################################ # Command alias for debugging messages # Usage: -# dmgs() +# dmsg() function(dmsg) message(STATUS ${ARGN}) endfunction() @@ -19,9 +19,9 @@ macro(caffe_list_unique) endmacro() ################################################################################################ -# Clears variables from lsit +# Clears variables from list # Usage: -# caffe_list_unique() +# caffe_clear_vars() macro(caffe_clear_vars) foreach(_var ${ARGN}) unset(${_var}) @@ -118,7 +118,7 @@ macro(caffe_parse_header FILENAME FILE_VAR) if(__add_cache) set(${name} ${${name}} CACHE INTERNAL "${name} parsed from ${FILENAME}" FORCE) elseif(__parnet_scope) - set(${name} "${${name}}" PARENT_SCOPE) + set(${name} "${${name}}" PARENT_SCOPE) endif() else() unset(${name} CACHE) @@ -303,7 +303,7 @@ function(caffe_get_current_cflags cflags_var) endfunction() ################################################################################################ -# Helper function to parse current linker libs into link directoris, libflags and osx frameworks +# Helper function to parse current linker libs into link directories, libflags and osx frameworks # Usage: # caffe_parse_linker_libs( ) function(caffe_parse_linker_libs Caffe_LINKER_LIBS_variable folders_var flags_var frameworks_var) diff --git a/cmake/lint.cmake b/cmake/lint.cmake index 585babb3587..70a006572bb 100644 --- a/cmake/lint.cmake +++ b/cmake/lint.cmake @@ -5,7 +5,7 @@ set(SRC_FILE_EXTENSIONS h hpp hu c cpp cu cc) set(EXCLUDE_FILE_EXTENSTIONS pb.h pb.cc) set(LINT_DIRS include src/caffe examples tools python matlab) -cmake_policy(SET CMP0009 NEW) # supress cmake warning +cmake_policy(SET CMP0009 NEW) # suppress cmake warning # find all files of interest foreach(ext ${SRC_FILE_EXTENSIONS}) @@ -26,7 +26,7 @@ list(REMOVE_ITEM LINT_SOURCES ${EXCLUDED_FILES}) execute_process( COMMAND ${LINT_COMMAND} ${LINT_SOURCES} - ERROR_VARIABLE LINT_OUTPUT + ERROR_VARIABLE LINT_OUTPUT ERROR_STRIP_TRAILING_WHITESPACE ) From 7093b0b6c9216e116046ab1d4d2b9bf2e487a641 Mon Sep 17 00:00:00 2001 From: philkr Date: Tue, 7 Jul 2015 16:32:46 -0700 Subject: [PATCH 081/331] Making the net_spec python3 compatible --- examples/pycaffe/caffenet.py | 5 +++-- python/caffe/net_spec.py | 11 ++++++----- python/requirements.txt | 1 + 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/examples/pycaffe/caffenet.py b/examples/pycaffe/caffenet.py index f9801d7cbb8..06c5a02d4ee 100644 --- a/examples/pycaffe/caffenet.py +++ b/examples/pycaffe/caffenet.py @@ -1,5 +1,6 @@ from caffe import layers as L, params as P, to_proto from caffe.proto import caffe_pb2 +from __future__ import print_function # helper function for common structures @@ -45,10 +46,10 @@ def caffenet(lmdb, batch_size=256, include_acc=False): def make_net(): with open('train.prototxt', 'w') as f: - print >>f, caffenet('/path/to/caffe-train-lmdb') + print(caffenet('/path/to/caffe-train-lmdb'), file=f) with open('test.prototxt', 'w') as f: - print >>f, caffenet('/path/to/caffe-val-lmdb', batch_size=50, include_acc=True) + print(caffenet('/path/to/caffe-val-lmdb', batch_size=50, include_acc=True), file=f) if __name__ == '__main__': make_net() diff --git a/python/caffe/net_spec.py b/python/caffe/net_spec.py index f54328d56f1..1b4814a45c6 100644 --- a/python/caffe/net_spec.py +++ b/python/caffe/net_spec.py @@ -22,6 +22,7 @@ class -- assign to its attributes directly to name layers, and call from .proto import caffe_pb2 from google import protobuf +import six def param_name_dict(): @@ -63,12 +64,12 @@ def assign_proto(proto, name, val): if isinstance(val[0], dict): for item in val: proto_item = getattr(proto, name).add() - for k, v in item.iteritems(): + for k, v in six.iteritems(item): assign_proto(proto_item, k, v) else: getattr(proto, name).extend(val) elif isinstance(val, dict): - for k, v in val.iteritems(): + for k, v in six.iteritems(val): assign_proto(getattr(proto, name), k, v) else: setattr(proto, name, val) @@ -131,7 +132,7 @@ def _to_proto(self, layers, names, autonames): layer.top.append(self._get_name(top, names, autonames)) layer.name = self._get_name(self.tops[0], names, autonames) - for k, v in self.params.iteritems(): + for k, v in six.iteritems(self.params): # special case to handle generic *params if k.endswith('param'): assign_proto(layer, k, v) @@ -161,10 +162,10 @@ def __getattr__(self, name): return self.tops[name] def to_proto(self): - names = {v: k for k, v in self.tops.iteritems()} + names = {v: k for k, v in six.iteritems(self.tops)} autonames = {} layers = OrderedDict() - for name, top in self.tops.iteritems(): + for name, top in six.iteritems(self.tops): top.fn._to_proto(layers, names, autonames) net = caffe_pb2.NetParameter() net.layer.extend(layers.values()) diff --git a/python/requirements.txt b/python/requirements.txt index e0c86c7e51e..e7d89e67f48 100644 --- a/python/requirements.txt +++ b/python/requirements.txt @@ -14,3 +14,4 @@ protobuf>=2.5.0 python-gflags>=2.0 pyyaml>=3.10 Pillow>=2.3.0 +six>=1.1.0 \ No newline at end of file From c51e8d623260bb921daf799ba846e13d8b47e843 Mon Sep 17 00:00:00 2001 From: AdamStelmaszczyk Date: Fri, 10 Jul 2015 21:41:46 +0100 Subject: [PATCH 082/331] One command less Also more readable and compatible with format of instructions for MNIST https://github.com/BVLC/caffe/tree/master/examples/mnist --- examples/cifar10/readme.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/examples/cifar10/readme.md b/examples/cifar10/readme.md index 4a95cee9e8f..5d8d81e3efb 100644 --- a/examples/cifar10/readme.md +++ b/examples/cifar10/readme.md @@ -22,9 +22,8 @@ Prepare the Dataset You will first need to download and convert the data format from the [CIFAR-10 website](http://www.cs.toronto.edu/~kriz/cifar.html). To do this, simply run the following commands: - cd $CAFFE_ROOT/data/cifar10 - ./get_cifar10.sh cd $CAFFE_ROOT + ./data/cifar10/get_cifar10.sh ./examples/cifar10/create_cifar10.sh If it complains that `wget` or `gunzip` are not installed, you need to install them respectively. After running the script there should be the dataset, `./cifar10-leveldb`, and the data set image mean `./mean.binaryproto`. From d0423a8682b92a101f26b3093c88f08c235fb3d1 Mon Sep 17 00:00:00 2001 From: philkr Date: Fri, 10 Jul 2015 17:03:03 -0700 Subject: [PATCH 083/331] Removes a unused variable warning --- src/caffe/layers/absval_layer.cu | 1 - 1 file changed, 1 deletion(-) diff --git a/src/caffe/layers/absval_layer.cu b/src/caffe/layers/absval_layer.cu index 91f3c77fe9a..bb310e1afbb 100644 --- a/src/caffe/layers/absval_layer.cu +++ b/src/caffe/layers/absval_layer.cu @@ -18,7 +18,6 @@ template void AbsValLayer::Backward_gpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { const int count = top[0]->count(); - const Dtype* top_data = top[0]->gpu_data(); const Dtype* top_diff = top[0]->gpu_diff(); if (propagate_down[0]) { const Dtype* bottom_data = bottom[0]->gpu_data(); From 4c8515a05ae63400166e9311feac8037df3d59c6 Mon Sep 17 00:00:00 2001 From: Gleb Mazovetskiy Date: Sun, 12 Jul 2015 04:16:14 +0100 Subject: [PATCH 084/331] examples/imagenet: fix broken link --- examples/imagenet/readme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/imagenet/readme.md b/examples/imagenet/readme.md index b1ebfafbf46..65174d601f2 100644 --- a/examples/imagenet/readme.md +++ b/examples/imagenet/readme.md @@ -102,4 +102,4 @@ Hope you liked this recipe! Many researchers have gone further since the ILSVRC 2012 challenge, changing the network architecture and/or fine-tuning the various parameters in the network to address new data and tasks. **Caffe lets you explore different network choices more easily by simply writing different prototxt files** - isn't that exciting? -And since now you have a trained network, check out how to use it with the Python interface for [classifying ImageNet](http://nbviewer.ipython.org/github/BVLC/caffe/blob/master/examples/classification.ipynb). +And since now you have a trained network, check out how to use it with the Python interface for [classifying ImageNet](http://nbviewer.ipython.org/github/BVLC/caffe/blob/master/examples/00-classification.ipynb). From 4ccc052e6e2bd4293dfb530febc9bf441786363d Mon Sep 17 00:00:00 2001 From: Keiji Yoshida Date: Sun, 12 Jul 2015 20:06:31 +0900 Subject: [PATCH 085/331] Update net_layer_blob.md --- docs/tutorial/net_layer_blob.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorial/net_layer_blob.md b/docs/tutorial/net_layer_blob.md index e8b7bd316a9..d6df737439a 100644 --- a/docs/tutorial/net_layer_blob.md +++ b/docs/tutorial/net_layer_blob.md @@ -19,7 +19,7 @@ Blobs conceal the computational and mental overhead of mixed CPU/GPU operation b The conventional blob dimensions for batches of image data are number N x channel K x height H x width W. Blob memory is row-major in layout, so the last / rightmost dimension changes fastest. For example, in a 4D blob, the value at index (n, k, h, w) is physically located at index ((n * K + k) * H + h) * W + w. -- Number / N is the batch size of the data. Batch processing achieves better throughput for communication and device processing. For an ImageNet training batch of 256 images B = 256. +- Number / N is the batch size of the data. Batch processing achieves better throughput for communication and device processing. For an ImageNet training batch of 256 images N = 256. - Channel / K is the feature dimension e.g. for RGB images K = 3. Note that although many blobs in Caffe examples are 4D with axes for image applications, it is totally valid to use blobs for non-image applications. For example, if you simply need fully-connected networks like the conventional multi-layer perceptron, use 2D blobs (shape (N, D)) and call the InnerProductLayer (which we will cover soon). From 4702f85a1f31d5541cba0bf5500b2daea222da91 Mon Sep 17 00:00:00 2001 From: Youssef Kashef Date: Tue, 14 Jul 2015 11:26:03 +0200 Subject: [PATCH 086/331] tiny fix in Layer::Backward documentation --- include/caffe/layer.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/caffe/layer.hpp b/include/caffe/layer.hpp index 8f924a75755..e2eba196346 100644 --- a/include/caffe/layer.hpp +++ b/include/caffe/layer.hpp @@ -139,7 +139,7 @@ class Layer { * (Backward_cpu or Backward_gpu) to compute the bottom blob diffs given the * top blob diffs. * - * Your layer should implement Forward_cpu and (optionally) Forward_gpu. + * Your layer should implement Backward_cpu and (optionally) Backward_gpu. */ inline void Backward(const vector*>& top, const vector& propagate_down, From 6d92d8fcfe0eea9495ffbc326256ec5b70c3eed1 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Thu, 16 Jul 2015 21:30:37 -0700 Subject: [PATCH 087/331] [examples] fix link to point to new tutorial notebook --- examples/feature_extraction/readme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/feature_extraction/readme.md b/examples/feature_extraction/readme.md index 6c8917e27e1..a980b8b3203 100644 --- a/examples/feature_extraction/readme.md +++ b/examples/feature_extraction/readme.md @@ -10,7 +10,7 @@ Extracting Features =================== In this tutorial, we will extract features using a pre-trained model with the included C++ utility. -Note that we recommend using the Python interface for this task, as for example in the [filter visualization example](http://nbviewer.ipython.org/github/BVLC/caffe/blob/master/examples/filter_visualization.ipynb). +Note that we recommend using the Python interface for this task, as for example in the [filter visualization example](http://nbviewer.ipython.org/github/BVLC/caffe/blob/master/examples/00-classification.ipynb). Follow instructions for [installing Caffe](../../installation.html) and run `scripts/download_model_binary.py models/bvlc_reference_caffenet` from caffe root directory. If you need detailed information about the tools below, please consult their source code, in which additional documentation is usually provided. From 4d3b1844fc70ab52fe9e22343f9a1154617be6a4 Mon Sep 17 00:00:00 2001 From: philkr Date: Wed, 8 Jul 2015 14:30:29 -0700 Subject: [PATCH 088/331] Travis scripts for python3 and pytest for cmake. Also fixes CUDA CMake build issue #2722. --- .travis.yml | 13 +++-- CMakeLists.txt | 4 ++ Makefile | 4 +- cmake/Dependencies.cmake | 9 ++-- python/caffe/test/test_net.py | 7 +-- python/caffe/test/test_net_spec.py | 2 +- python/caffe/test/test_python_layer.py | 5 +- python/caffe/test/test_solver.py | 7 +-- scripts/travis/travis_build_and_test.sh | 11 +++- scripts/travis/travis_install.sh | 52 ++++++++++++++----- .../travis/travis_setup_makefile_config.sh | 4 +- src/caffe/layer_factory.cpp | 5 ++ 12 files changed, 90 insertions(+), 33 deletions(-) diff --git a/.travis.yml b/.travis.yml index 955aa8c3ba2..b920a935d0d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,24 +6,31 @@ env: - WITH_CUDA=false WITH_CMAKE=true - WITH_CUDA=true WITH_CMAKE=false - WITH_CUDA=true WITH_CMAKE=true + - WITH_CUDA=false WITH_CMAKE=true PYTHON_VERSION=3 language: cpp # Cache Ubuntu apt packages. -cache: apt +cache: + apt: true + directories: + - /home/travis/miniconda + - /home/travis/miniconda2 + - /home/travis/miniconda3 compiler: gcc before_install: - export NUM_THREADS=4 - export SCRIPTS=./scripts/travis + - export CONDA_DIR="/home/travis/miniconda$PYTHON_VERSION" install: - sudo -E $SCRIPTS/travis_install.sh before_script: - - export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib:/usr/local/cuda/lib64 - - export PATH=/home/travis/miniconda/bin:$PATH + - export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib:/usr/local/cuda/lib64:$CONDA_DIR/lib + - export PATH=$CONDA_DIR/bin:$PATH - if ! $WITH_CMAKE; then $SCRIPTS/travis_setup_makefile_config.sh; fi script: $SCRIPTS/travis_build_and_test.sh diff --git a/CMakeLists.txt b/CMakeLists.txt index e202350224f..ef599b68922 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -62,6 +62,10 @@ add_subdirectory(docs) # ---[ Linter target add_custom_target(lint COMMAND ${CMAKE_COMMAND} -P ${PROJECT_SOURCE_DIR}/cmake/lint.cmake) +# ---[ pytest target +add_custom_target(pytest COMMAND python${python_version} -m unittest discover -s caffe/test WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/python ) +add_dependencies(pytest pycaffe) + # ---[ Configuration summary caffe_print_configuration_summary() diff --git a/Makefile b/Makefile index e4e66dfd138..05b783af35c 100644 --- a/Makefile +++ b/Makefile @@ -228,7 +228,7 @@ ifeq ($(LINUX), 1) CXX ?= /usr/bin/g++ GCCVERSION := $(shell $(CXX) -dumpversion | cut -f1,2 -d.) # older versions of gcc are too dumb to build boost with -Wuninitalized - ifeq ($(shell echo $(GCCVERSION) \< 4.6 | bc), 1) + ifeq ($(shell echo | awk '{exit $(GCCVERSION) < 4.6;}'), 1) WARNINGS += -Wno-uninitialized endif # boost::thread is reasonably called boost_thread (compare OS X) @@ -243,7 +243,7 @@ ifeq ($(OSX), 1) CXX := /usr/bin/clang++ ifneq ($(CPU_ONLY), 1) CUDA_VERSION := $(shell $(CUDA_DIR)/bin/nvcc -V | grep -o 'release \d' | grep -o '\d') - ifeq ($(shell echo $(CUDA_VERSION) \< 7.0 | bc), 1) + ifeq ($(shell echo | awk '{exit $(CUDA_VERSION) < 7.0;}'), 1) CXXFLAGS += -stdlib=libstdc++ LINKFLAGS += -stdlib=libstdc++ endif diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake index 7cae5c9da25..7c86dd55a30 100644 --- a/cmake/Dependencies.cmake +++ b/cmake/Dependencies.cmake @@ -106,14 +106,15 @@ if(BUILD_python) while(NOT "${version}" STREQUAL "" AND NOT Boost_PYTHON_FOUND) STRING( REGEX REPLACE "([0-9.]+).[0-9]+" "\\1" version ${version} ) - STRING( REGEX MATCHALL "([0-9.]+).[0-9]+" has_more_version ${version} ) - if("${has_more_version}" STREQUAL "") - break() - endif() STRING( REPLACE "." "" boost_py_version ${version} ) find_package(Boost 1.46 COMPONENTS "python-py${boost_py_version}") set(Boost_PYTHON_FOUND ${Boost_PYTHON-PY${boost_py_version}_FOUND}) + + STRING( REGEX MATCHALL "([0-9.]+).[0-9]+" has_more_version ${version} ) + if("${has_more_version}" STREQUAL "") + break() + endif() endwhile() if(NOT Boost_PYTHON_FOUND) find_package(Boost 1.46 COMPONENTS python) diff --git a/python/caffe/test/test_net.py b/python/caffe/test/test_net.py index cc367477752..aad828aa8aa 100644 --- a/python/caffe/test/test_net.py +++ b/python/caffe/test/test_net.py @@ -2,6 +2,7 @@ import tempfile import os import numpy as np +import six import caffe @@ -10,7 +11,7 @@ def simple_net_file(num_output): """Make a simple net prototxt, based on test_net.cpp, returning the name of the (temporary) file.""" - f = tempfile.NamedTemporaryFile(delete=False) + f = tempfile.NamedTemporaryFile(mode='w+', delete=False) f.write("""name: 'testnet' force_backward: true layer { type: 'DummyData' name: 'data' top: 'data' top: 'label' dummy_data_param { num: 5 channels: 2 height: 3 width: 4 @@ -47,7 +48,7 @@ def setUp(self): def test_memory(self): """Check that holding onto blob data beyond the life of a Net is OK""" - params = sum(map(list, self.net.params.itervalues()), []) + params = sum(map(list, six.itervalues(self.net.params)), []) blobs = self.net.blobs.values() del self.net @@ -67,7 +68,7 @@ def test_inputs_outputs(self): self.assertEqual(self.net.outputs, ['loss']) def test_save_and_read(self): - f = tempfile.NamedTemporaryFile(delete=False) + f = tempfile.NamedTemporaryFile(mode='w+', delete=False) f.close() self.net.save(f.name) net_file = simple_net_file(self.num_output) diff --git a/python/caffe/test/test_net_spec.py b/python/caffe/test/test_net_spec.py index 65b73b96f73..909a101bbfb 100644 --- a/python/caffe/test/test_net_spec.py +++ b/python/caffe/test/test_net_spec.py @@ -43,7 +43,7 @@ def anon_lenet(batch_size): class TestNetSpec(unittest.TestCase): def load_net(self, net_proto): - f = tempfile.NamedTemporaryFile(delete=False) + f = tempfile.NamedTemporaryFile(mode='w+', delete=False) f.write(str(net_proto)) f.close() return caffe.Net(f.name, caffe.TEST) diff --git a/python/caffe/test/test_python_layer.py b/python/caffe/test/test_python_layer.py index 6fba49143bb..f41e283fa4d 100644 --- a/python/caffe/test/test_python_layer.py +++ b/python/caffe/test/test_python_layer.py @@ -1,6 +1,7 @@ import unittest import tempfile import os +import six import caffe @@ -22,7 +23,7 @@ def backward(self, top, propagate_down, bottom): def python_net_file(): - with tempfile.NamedTemporaryFile(delete=False) as f: + with tempfile.NamedTemporaryFile(mode='w+', delete=False) as f: f.write("""name: 'pythonnet' force_backward: true input: 'data' input_shape { dim: 10 dim: 9 dim: 8 } layer { type: 'Python' name: 'one' bottom: 'data' top: 'one' @@ -58,6 +59,6 @@ def test_reshape(self): s = 4 self.net.blobs['data'].reshape(s, s, s, s) self.net.forward() - for blob in self.net.blobs.itervalues(): + for blob in six.itervalues(self.net.blobs): for d in blob.data.shape: self.assertEqual(s, d) diff --git a/python/caffe/test/test_solver.py b/python/caffe/test/test_solver.py index 09b974dad66..9cfc10d29a9 100644 --- a/python/caffe/test/test_solver.py +++ b/python/caffe/test/test_solver.py @@ -2,6 +2,7 @@ import tempfile import os import numpy as np +import six import caffe from test_net import simple_net_file @@ -11,7 +12,7 @@ class TestSolver(unittest.TestCase): def setUp(self): self.num_output = 13 net_f = simple_net_file(self.num_output) - f = tempfile.NamedTemporaryFile(delete=False) + f = tempfile.NamedTemporaryFile(mode='w+', delete=False) f.write("""net: '""" + net_f + """' test_iter: 10 test_interval: 10 base_lr: 0.01 momentum: 0.9 weight_decay: 0.0005 lr_policy: 'inv' gamma: 0.0001 power: 0.75 @@ -45,8 +46,8 @@ def test_net_memory(self): total = 0 for net in nets: - for ps in net.params.itervalues(): + for ps in six.itervalues(net.params): for p in ps: total += p.data.sum() + p.diff.sum() - for bl in net.blobs.itervalues(): + for bl in six.itervalues(net.blobs): total += bl.data.sum() + bl.diff.sum() diff --git a/scripts/travis/travis_build_and_test.sh b/scripts/travis/travis_build_and_test.sh index 8ff63f31fdd..9ba737e28a9 100755 --- a/scripts/travis/travis_build_and_test.sh +++ b/scripts/travis/travis_build_and_test.sh @@ -7,8 +7,17 @@ MAKE="make --jobs=$NUM_THREADS --keep-going" if $WITH_CMAKE; then mkdir build cd build - cmake -DBUILD_python=ON -DCMAKE_BUILD_TYPE=Release -DCPU_ONLY=ON .. + CPU_ONLY=" -DCPU_ONLY=ON" + if ! $WITH_CUDA; then + CPU_ONLY=" -DCPU_ONLY=OFF" + fi + PYTHON_ARGS="" + if [ "$PYTHON_VERSION" = "3" ]; then + PYTHON_ARGS="$PYTHON_ARGS -Dpython_version=3 -DBOOST_LIBRARYDIR=$CONDA_DIR/lib/" + fi + cmake -DBUILD_python=ON -DCMAKE_BUILD_TYPE=Release $CPU_ONLY $PYTHON_ARGS -DCMAKE_INCLUDE_PATH="$CONDA_DIR/include/" -DCMAKE_LIBRARY_PATH="$CONDA_DIR/lib/" .. $MAKE + $MAKE pytest if ! $WITH_CUDA; then $MAKE runtest $MAKE lint diff --git a/scripts/travis/travis_install.sh b/scripts/travis/travis_install.sh index b6e6f6ce821..d6c6e228b58 100755 --- a/scripts/travis/travis_install.sh +++ b/scripts/travis/travis_install.sh @@ -4,7 +4,6 @@ set -e MAKE="make --jobs=$NUM_THREADS" - # Install apt packages where the Ubuntu 12.04 default and ppa works for Caffe # This ppa is for gflags and glog @@ -12,9 +11,8 @@ add-apt-repository -y ppa:tuleu/precise-backports apt-get -y update apt-get install \ wget git curl \ - python-dev python-numpy \ + python-dev python-numpy python3-dev\ libleveldb-dev libsnappy-dev libopencv-dev \ - libboost-dev libboost-system-dev libboost-python-dev libboost-thread-dev \ libprotobuf-dev protobuf-compiler \ libatlas-dev libatlas-base-dev \ libhdf5-serial-dev libgflags-dev libgoogle-glog-dev \ @@ -24,9 +22,10 @@ apt-get install \ # if needed. By default, Aptitude in Ubuntu 12.04 installs CMake 2.8.7, but # Caffe requires a minimum CMake version of 2.8.8. if $WITH_CMAKE; then - add-apt-repository -y ppa:ubuntu-sdk-team/ppa - apt-get -y update - apt-get -y install cmake + # cmake 3 will make sure that the python interpreter and libraries match + wget http://www.cmake.org/files/v3.2/cmake-3.2.3-Linux-x86_64.sh -O cmake3.sh + chmod +x cmake3.sh + ./cmake3.sh --prefix=/usr/ --skip-license --exclude-subdir fi # Install CUDA, if needed @@ -60,10 +59,37 @@ rm -f $LMDB_FILE # Install the Python runtime dependencies via miniconda (this is much faster # than using pip for everything). -wget http://repo.continuum.io/miniconda/Miniconda-latest-Linux-x86_64.sh -O miniconda.sh -chmod +x miniconda.sh -./miniconda.sh -b -export PATH=/home/travis/miniconda/bin:$PATH -conda update --yes conda -conda install --yes numpy scipy matplotlib scikit-image pip -pip install protobuf +export PATH=$CONDA_DIR/bin:$PATH +if [ ! -d $CONDA_DIR ]; then + if [ "$PYTHON_VERSION" -eq "3" ]; then + wget http://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh + else + wget http://repo.continuum.io/miniconda/Miniconda-latest-Linux-x86_64.sh -O miniconda.sh + fi + chmod +x miniconda.sh + ./miniconda.sh -b -p $CONDA_DIR + + conda update --yes conda + conda install --yes numpy scipy matplotlib scikit-image pip + # Let conda install boost (so that boost_python matches) + conda install --yes -c https://conda.binstar.org/menpo boost=1.56.0 +fi + +# install protobuf 3 (just use the miniconda3 directory to avoid having to setup the path again) +if [ "$PYTHON_VERSION" -eq "3" ] && [ ! -e "$CONDA_DIR/bin/protoc" ]; then + pushd . + wget https://github.com/google/protobuf/archive/v3.0.0-alpha-3.1.tar.gz -O protobuf-3.tar.gz + tar -C /tmp -xzvf protobuf-3.tar.gz + cd /tmp/protobuf-3*/ + ./autogen.sh + ./configure --prefix=$CONDA_DIR + $MAKE + $MAKE install + popd +fi + +if [ "$PYTHON_VERSION" -eq "3" ]; then + pip install --pre protobuf +else + pip install protobuf +fi diff --git a/scripts/travis/travis_setup_makefile_config.sh b/scripts/travis/travis_setup_makefile_config.sh index ba326262bf8..1440be2af8b 100755 --- a/scripts/travis/travis_setup_makefile_config.sh +++ b/scripts/travis/travis_setup_makefile_config.sh @@ -12,7 +12,9 @@ if $WITH_CUDA; then fi cat << 'EOF' >> Makefile.config -ANACONDA_HOME := $(HOME)/miniconda +# Travis' nvcc doesn't like newer boost versions +NVCCFLAGS := -Xcudafe --diag_suppress=cc_clobber_ignored -Xcudafe --diag_suppress=useless_using_declaration -Xcudafe --diag_suppress=set_but_not_used +ANACONDA_HOME := $(CONDA_DIR) PYTHON_INCLUDE := $(ANACONDA_HOME)/include \ $(ANACONDA_HOME)/include/python2.7 \ $(ANACONDA_HOME)/lib/python2.7/site-packages/numpy/core/include diff --git a/src/caffe/layer_factory.cpp b/src/caffe/layer_factory.cpp index d6a1cac5090..926c7d8ff78 100644 --- a/src/caffe/layer_factory.cpp +++ b/src/caffe/layer_factory.cpp @@ -1,3 +1,8 @@ +// Make sure we include Python.h before any system header +// to avoid _POSIX_C_SOURCE redefinition +#ifdef WITH_PYTHON_LAYER +#include +#endif #include #include "caffe/layer.hpp" From b2d7b9a31613d69dc4ea1fe6f3d0fe10ac7ee95d Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Tue, 21 Jul 2015 10:33:31 -0700 Subject: [PATCH 089/331] [docs] matlab 2015a compatible --- docs/installation.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/installation.md b/docs/installation.md index 144e6a34f67..d535c6d093d 100644 --- a/docs/installation.md +++ b/docs/installation.md @@ -75,7 +75,7 @@ To import the `caffe` Python module after completing the installation, add the m Install MATLAB, and make sure that its `mex` is in your `$PATH`. -*Caffe's MATLAB interface works with versions 2014a/b, 2013a/b, and 2012b.* +*Caffe's MATLAB interface works with versions 2015a, 2014a/b, 2013a/b, and 2012b.* #### Windows From 2d328815afa90c2b9bf10f1e5795bbcc2bc877ed Mon Sep 17 00:00:00 2001 From: Eric Zeiberg Date: Tue, 21 Jul 2015 22:12:48 -0700 Subject: [PATCH 090/331] [docs] set lmdb url to github mirror --- docs/install_apt.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/install_apt.md b/docs/install_apt.md index f588b74dcdb..d5deee1c093 100644 --- a/docs/install_apt.md +++ b/docs/install_apt.md @@ -41,7 +41,7 @@ These dependencies need manual installation in 12.04. export CXXFLAGS="-fPIC" && cmake .. && make VERBOSE=1 make && make install # lmdb - git clone https://gitorious.org/mdb/mdb.git + git clone https://github.com/LMDB/lmdb cd mdb/libraries/liblmdb make && make install From 075321931671330a8591554182dfa7e9f94697f4 Mon Sep 17 00:00:00 2001 From: Franck Dernoncourt Date: Wed, 22 Jul 2015 17:32:12 -0700 Subject: [PATCH 091/331] Fix path to mnist_autoencoder.prototxt --- docs/tutorial/layers.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorial/layers.md b/docs/tutorial/layers.md index 806374e3f93..eabc792b704 100644 --- a/docs/tutorial/layers.md +++ b/docs/tutorial/layers.md @@ -213,7 +213,7 @@ Given an input value x, The `ReLU` layer computes the output as x if x > 0 and n * Layer type: `Sigmoid` * CPU implementation: `./src/caffe/layers/sigmoid_layer.cpp` * CUDA GPU implementation: `./src/caffe/layers/sigmoid_layer.cu` -* Sample (as seen in `./examples/imagenet/mnist_autoencoder.prototxt`) +* Sample (as seen in `./examples/mnist/mnist_autoencoder.prototxt`) layer { name: "encode1neuron" From 129d222fbd885c1a9e727e6134d2387676fc3dac Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 23 Jul 2015 20:23:42 -0700 Subject: [PATCH 092/331] [pycaffe] remove dead code --- python/caffe/net_spec.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/python/caffe/net_spec.py b/python/caffe/net_spec.py index 1b4814a45c6..95c03bcb9c5 100644 --- a/python/caffe/net_spec.py +++ b/python/caffe/net_spec.py @@ -44,8 +44,6 @@ def to_proto(*tops): """Generate a NetParameter that contains all layers needed to compute all arguments.""" - if not isinstance(tops, tuple): - tops = (tops,) layers = OrderedDict() autonames = {} for top in tops: From 7488163bf4b3d44be5fbc931ba58ccde07098818 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 23 Jul 2015 20:26:46 -0700 Subject: [PATCH 093/331] [pycaffe] use a Counter instead of a dict for counting net spec names --- python/caffe/net_spec.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/python/caffe/net_spec.py b/python/caffe/net_spec.py index 95c03bcb9c5..37e333d7cc5 100644 --- a/python/caffe/net_spec.py +++ b/python/caffe/net_spec.py @@ -18,7 +18,7 @@ class -- assign to its attributes directly to name layers, and call are not guaranteed to be forward-compatible. """ -from collections import OrderedDict +from collections import OrderedDict, Counter from .proto import caffe_pb2 from google import protobuf @@ -45,7 +45,7 @@ def to_proto(*tops): all arguments.""" layers = OrderedDict() - autonames = {} + autonames = Counter() for top in tops: top.fn._to_proto(layers, {}, autonames) net = caffe_pb2.NetParameter() @@ -107,9 +107,8 @@ def __init__(self, type_name, inputs, params): def _get_name(self, top, names, autonames): if top not in names: - n = autonames.setdefault(top.fn.type_name, 1) autonames[top.fn.type_name] += 1 - names[top] = top.fn.type_name + str(n) + names[top] = top.fn.type_name + str(autonames[top.fn.type_name]) return names[top] def _to_proto(self, layers, names, autonames): @@ -161,7 +160,7 @@ def __getattr__(self, name): def to_proto(self): names = {v: k for k, v in six.iteritems(self.tops)} - autonames = {} + autonames = Counter() layers = OrderedDict() for name, top in six.iteritems(self.tops): top.fn._to_proto(layers, names, autonames) From f16195aa8b1569e0260c48d4159b7d2ce0ea2fab Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 23 Jul 2015 20:32:04 -0700 Subject: [PATCH 094/331] [pycaffe] add Top._to_proto convenience function This makes it possible to serialize Functions or Tops with a uniform interface. --- python/caffe/net_spec.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/python/caffe/net_spec.py b/python/caffe/net_spec.py index 37e333d7cc5..5fb26ed45ba 100644 --- a/python/caffe/net_spec.py +++ b/python/caffe/net_spec.py @@ -87,6 +87,9 @@ def to_proto(self): return to_proto(self) + def _to_proto(self, layers, names, autonames): + return self.fn._to_proto(layers, names, autonames) + class Function(object): """A Function specifies a layer, its parameters, and its inputs (which @@ -116,7 +119,7 @@ def _to_proto(self, layers, names, autonames): return bottom_names = [] for inp in self.inputs: - inp.fn._to_proto(layers, names, autonames) + inp._to_proto(layers, names, autonames) bottom_names.append(layers[inp.fn].top[inp.n]) layer = caffe_pb2.LayerParameter() layer.type = self.type_name @@ -163,7 +166,7 @@ def to_proto(self): autonames = Counter() layers = OrderedDict() for name, top in six.iteritems(self.tops): - top.fn._to_proto(layers, names, autonames) + top._to_proto(layers, names, autonames) net = caffe_pb2.NetParameter() net.layer.extend(layers.values()) return net From 96c2fe1de80c9752b992c4578a3ce46028d21fc5 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 23 Jul 2015 20:35:42 -0700 Subject: [PATCH 095/331] [pycaffe] allow layers to have names different from their first tops Previously, net spec only allowed names to be assigned to Tops, giving layers the names of their first tops. Now, names can be assigned to Functions, which become layer names in serialization. Unnamed Functions still get named after their first top, if present, or autogenerated, if not. (This will allow top-less layers in a natural way.) --- python/caffe/net_spec.py | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/python/caffe/net_spec.py b/python/caffe/net_spec.py index 5fb26ed45ba..16f30008579 100644 --- a/python/caffe/net_spec.py +++ b/python/caffe/net_spec.py @@ -108,7 +108,15 @@ def __init__(self, type_name, inputs, params): del self.params['in_place'] self.tops = tuple(Top(self, n) for n in range(self.ntop)) - def _get_name(self, top, names, autonames): + def _get_name(self, names, autonames): + if self not in names and self.ntop > 0: + names[self] = self._get_top_name(self.tops[0], names, autonames) + elif self not in names: + autonames[self.type_name] += 1 + names[self] = self.type_name + str(autonames[self.type_name]) + return names[self] + + def _get_top_name(self, top, names, autonames): if top not in names: autonames[top.fn.type_name] += 1 names[top] = top.fn.type_name + str(autonames[top.fn.type_name]) @@ -129,8 +137,8 @@ def _to_proto(self, layers, names, autonames): layer.top.extend(layer.bottom) else: for top in self.tops: - layer.top.append(self._get_name(top, names, autonames)) - layer.name = self._get_name(self.tops[0], names, autonames) + layer.top.append(self._get_top_name(top, names, autonames)) + layer.name = self._get_name(names, autonames) for k, v in six.iteritems(self.params): # special case to handle generic *params From b464a6e5d2e381185bd8aa0b9cbcba53c9819585 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 23 Jul 2015 20:40:02 -0700 Subject: [PATCH 096/331] [pycaffe] net spec layers can have ntop=0 In this case, the Function is returned instead of a Top, which can be assigned a name if desired. Thanks @philkr for an earlier implementation of this. --- python/caffe/net_spec.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/python/caffe/net_spec.py b/python/caffe/net_spec.py index 16f30008579..31cde7ad946 100644 --- a/python/caffe/net_spec.py +++ b/python/caffe/net_spec.py @@ -188,7 +188,9 @@ class Layers(object): def __getattr__(self, name): def layer_fn(*args, **kwargs): fn = Function(name, args, kwargs) - if fn.ntop == 1: + if fn.ntop == 0: + return fn + elif fn.ntop == 1: return fn.tops[0] else: return fn.tops From c80f6f585549334022996395015cd490cc2644c8 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Thu, 23 Jul 2015 20:41:40 -0700 Subject: [PATCH 097/331] [pytest] simple test of top-less layers --- python/caffe/test/test_net_spec.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/python/caffe/test/test_net_spec.py b/python/caffe/test/test_net_spec.py index 65b73b96f73..b344946932a 100644 --- a/python/caffe/test/test_net_spec.py +++ b/python/caffe/test/test_net_spec.py @@ -41,6 +41,14 @@ def anon_lenet(batch_size): loss = L.SoftmaxWithLoss(ip2, label) return loss.to_proto() +def silent_net(): + n = caffe.NetSpec() + n.data, n.data2 = L.DummyData(shape=[dict(dim=[3]), dict(dim=[4, 2])], + ntop=2) + n.silence_data = L.Silence(n.data, ntop=0) + n.silence_data2 = L.Silence(n.data2, ntop=0) + return n.to_proto() + class TestNetSpec(unittest.TestCase): def load_net(self, net_proto): f = tempfile.NamedTemporaryFile(delete=False) @@ -65,3 +73,10 @@ def test_lenet(self): net_proto.layer[6].top) net = self.load_net(net_proto) self.assertEqual(len(net.layers), 9) + + def test_zero_tops(self): + """Test net construction for top-less layers.""" + + net_proto = silent_net() + net = self.load_net(net_proto) + self.assertEqual(len(net.forward()), 0) From de6d444445261fc9859143bfd969d538ae7a2108 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Mon, 27 Jul 2015 10:58:11 -0700 Subject: [PATCH 098/331] [docs] clear up PYTHONPATH confusion Use the same language as the installation page to explain the Python module path. reported by @sdemyanov --- docs/tutorial/interfaces.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/tutorial/interfaces.md b/docs/tutorial/interfaces.md index 12963318485..40602948cc3 100644 --- a/docs/tutorial/interfaces.md +++ b/docs/tutorial/interfaces.md @@ -11,8 +11,8 @@ The command line interface -- cmdcaffe -- is the `caffe` tool for model training **Training**: `caffe train` learns models from scratch, resumes learning from saved snapshots, and fine-tunes models to new data and tasks: -* All training requires a solver configuration through the `-solver solver.prototxt` argument. -* Resuming requires the `-snapshot model_iter_1000.solverstate` argument to load the solver snapshot. +* All training requires a solver configuration through the `-solver solver.prototxt` argument. +* Resuming requires the `-snapshot model_iter_1000.solverstate` argument to load the solver snapshot. * Fine-tuning requires the `-weights model.caffemodel` argument for the model initialization. For example, you can run: @@ -31,8 +31,7 @@ For a full example of fine-tuning, see examples/finetuning_on_flickr_style, but **Testing**: `caffe test` scores models by running them in the test phase and reports the net output as its score. The net architecture must be properly defined to output an accuracy measure or loss as its output. The per-batch score is reported and then the grand average is reported last. - # - # score the learned LeNet model on the validation set as defined in the + # score the learned LeNet model on the validation set as defined in the # model architeture lenet_train_test.prototxt caffe test -model examples/mnist/lenet_train_test.prototxt -weights examples/mnist/lenet_iter_10000.caffemodel -gpu 0 -iterations 100 @@ -63,7 +62,8 @@ The Python interface -- pycaffe -- is the `caffe` module and its scripts in caff Tutorial IPython notebooks are found in caffe/examples: do `ipython notebook caffe/examples` to try them. For developer reference docstrings can be found throughout the code. -Compile pycaffe by `make pycaffe`. The module dir caffe/python/caffe should be installed in your PYTHONPATH for `import caffe`. +Compile pycaffe by `make pycaffe`. +Add the module directory to your `$PYTHONPATH` by `export PYTHONPATH=/path/to/caffe/python:$PYTHONPATH` or the like for `import caffe`. ## MATLAB @@ -182,7 +182,7 @@ To get a layer's type (string): #### Forward and backward Forward pass can be done using `net.forward` or `net.forward_prefilled`. Function `net.forward` takes in a cell array of N-D arrays containing data of input blob(s) and outputs a cell array containing data from output blob(s). Function `net.forward_prefilled` uses existing data in input blob(s) during forward pass, takes no input and produces no output. After creating some data for input blobs like `data = rand(net.blobs('data').shape);` you can run - + res = net.forward({data}); prob = res{1}; @@ -202,7 +202,7 @@ Or net.blobs('prob').set_diff(prob_diff); net.backward_prefilled(); data_diff = net.blobs('data').get_diff(); - + **However, the backward computation above doesn't get correct results, because Caffe decides that the network does not need backward computation. To get correct backward results, you need to set `'force_backward: true'` in your network prototxt.** After performing forward or backward pass, you can also get the data or diff in internal blobs. For example, to extract pool5 features after forward pass: From e4aed047a2203bbc1f5bd36ed90bb7d9882b2e11 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Tue, 28 Jul 2015 10:27:39 -0700 Subject: [PATCH 099/331] [docs] fix lmdb fetch url and path --- docs/install_apt.md | 2 +- docs/install_yum.md | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/install_apt.md b/docs/install_apt.md index d5deee1c093..2976e3cd07c 100644 --- a/docs/install_apt.md +++ b/docs/install_apt.md @@ -42,7 +42,7 @@ These dependencies need manual installation in 12.04. make && make install # lmdb git clone https://github.com/LMDB/lmdb - cd mdb/libraries/liblmdb + cd lmdb/libraries/liblmdb make && make install Note that glog does not compile with the most recent gflags version (2.1), so before that is resolved you will need to build with glog first. diff --git a/docs/install_yum.md b/docs/install_yum.md index 478e7d952cc..2104912e482 100644 --- a/docs/install_yum.md +++ b/docs/install_yum.md @@ -28,8 +28,8 @@ title: Installation: RHEL / Fedora / CentOS export CXXFLAGS="-fPIC" && cmake .. && make VERBOSE=1 make && make install # lmdb - git clone git://gitorious.org/mdb/mdb.git - cd mdb/libraries/liblmdb + git clone https://github.com/LMDB/lmdb + cd lmdb/libraries/liblmdb make && make install Note that glog does not compile with the most recent gflags version (2.1), so before that is resolved you will need to build with glog first. From 7f7085439cbe4eb9d5fff95b41d6345168398142 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Wed, 29 Jul 2015 17:20:31 -0700 Subject: [PATCH 100/331] [docs] fix contrastive loss eq make documented equation match the correct implementation of the `max(margin - d, 0)^2` term in the loss. see #2321 --- include/caffe/loss_layers.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/include/caffe/loss_layers.hpp b/include/caffe/loss_layers.hpp index 86c34241168..528266394f1 100644 --- a/include/caffe/loss_layers.hpp +++ b/include/caffe/loss_layers.hpp @@ -128,9 +128,9 @@ class LossLayer : public Layer { /** * @brief Computes the contrastive loss @f$ * E = \frac{1}{2N} \sum\limits_{n=1}^N \left(y\right) d + - * \left(1-y\right) \max \left(margin-d, 0\right) + * \left(1-y\right) \max \left(margin-d, 0\right)^2 * @f$ where @f$ - * d = \left| \left| a_n - b_n \right| \right|_2^2 @f$. This can be + * d = \left| \left| a_n - b_n \right| \right|_2 @f$. This can be * used to train siamese networks. * * @param bottom input Blob vector (length 3) @@ -144,9 +144,9 @@ class LossLayer : public Layer { * -# @f$ (1 \times 1 \times 1 \times 1) @f$ * the computed contrastive loss: @f$ E = * \frac{1}{2N} \sum\limits_{n=1}^N \left(y\right) d + - * \left(1-y\right) \max \left(margin-d, 0\right) + * \left(1-y\right) \max \left(margin-d, 0\right)^2 * @f$ where @f$ - * d = \left| \left| a_n - b_n \right| \right|_2^2 @f$. + * d = \left| \left| a_n - b_n \right| \right|_2 @f$. * This can be used to train siamese networks. */ template From ccc35d361d6c90b7691b3ed8de7ea0678b488dff Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Wed, 29 Jul 2015 20:16:31 -0700 Subject: [PATCH 101/331] [docs] add CONTRIBUTING.md which will appear on GitHub new Issue/PR pages --- CONTRIBUTING.md | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 CONTRIBUTING.md diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 00000000000..8cd5e56ca49 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,30 @@ +# Contributing + +## Issues + +Specific Caffe design and development issues, bugs, and feature requests are maintained by GitHub Issues. + +_Please do not post usage, installation, or modeling questions, or other requests for help to Issues._ +Use the [caffe-users list](https://groups.google.com/forum/#!forum/caffe-users) instead. This helps developers maintain a clear, uncluttered, and efficient view of the state of Caffe. + +When reporting a bug, it's most helpful to provide the following information, where applicable: + +* What steps reproduce the bug? +* Can you reproduce the bug using the latest [master](https://github.com/BVLC/caffe/tree/master), compiled with the `DEBUG` make option? +* What hardware and operating system/distribution are you running? +* If the bug is a crash, provide the backtrace (usually printed by Caffe; always obtainable with `gdb`). + +Try to give your issue a title that is succinct and specific. The devs will rename issues as needed to keep track of them. + +## Pull Requests + +Caffe welcomes all contributions. + +See the [contributing guide](http://caffe.berkeleyvision.org/development.html) for details. + +Briefly: read commit by commit, a PR should tell a clean, compelling story of _one_ improvement to Caffe. In particular: + +* A PR should do one clear thing that obviously improves Caffe, and nothing more. Making many smaller PRs is better than making one large PR; review effort is superlinear in the amount of code involved. +* Similarly, each commit should be a small, atomic change representing one step in development. PRs should be made of many commits where appropriate. +* Please do rewrite PR history to be clean rather than chronological. Within-PR bugfixes, style cleanups, reversions, etc. should be squashed and should not appear in merged PR history. +* Anything nonobvious from the code should be explained in comments, commit messages, or the PR description, as appropriate. From 63e45b79932f3f990db32d75f157693809679230 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Tue, 9 Jun 2015 17:50:40 -0700 Subject: [PATCH 102/331] Change log levels in upgrade_proto It's not an error if the upgrade succeeds --- src/caffe/util/upgrade_proto.cpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/caffe/util/upgrade_proto.cpp b/src/caffe/util/upgrade_proto.cpp index 38a06026adf..92e5cf55fa9 100644 --- a/src/caffe/util/upgrade_proto.cpp +++ b/src/caffe/util/upgrade_proto.cpp @@ -588,8 +588,8 @@ bool UpgradeNetAsNeeded(const string& param_file, NetParameter* param) { if (NetNeedsV0ToV1Upgrade(*param)) { // NetParameter was specified using the old style (V0LayerParameter); try to // upgrade it. - LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " - << "V0LayerParameter: " << param_file; + LOG(INFO) << "Attempting to upgrade input file specified using deprecated " + << "V0LayerParameter: " << param_file; NetParameter original_param(*param); if (!UpgradeV0Net(original_param, param)) { success = false; @@ -599,29 +599,29 @@ bool UpgradeNetAsNeeded(const string& param_file, NetParameter* param) { LOG(INFO) << "Successfully upgraded file specified using deprecated " << "V0LayerParameter"; } - LOG(ERROR) << "Note that future Caffe releases will not support " + LOG(WARNING) << "Note that future Caffe releases will not support " << "V0NetParameter; use ./build/tools/upgrade_net_proto_text for " << "prototxt and ./build/tools/upgrade_net_proto_binary for model " << "weights upgrade this and any other net protos to the new format."; } // NetParameter uses old style data transformation fields; try to upgrade it. if (NetNeedsDataUpgrade(*param)) { - LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " - << "transformation parameters: " << param_file; + LOG(INFO) << "Attempting to upgrade input file specified using deprecated " + << "transformation parameters: " << param_file; UpgradeNetDataTransformation(param); LOG(INFO) << "Successfully upgraded file specified using deprecated " << "data transformation parameters."; - LOG(ERROR) << "Note that future Caffe releases will only support " - << "transform_param messages for transformation fields."; + LOG(WARNING) << "Note that future Caffe releases will only support " + << "transform_param messages for transformation fields."; } if (NetNeedsV1ToV2Upgrade(*param)) { - LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " - << "V1LayerParameter: " << param_file; + LOG(INFO) << "Attempting to upgrade input file specified using deprecated " + << "V1LayerParameter: " << param_file; NetParameter original_param(*param); if (!UpgradeV1Net(original_param, param)) { success = false; LOG(ERROR) << "Warning: had one or more problems upgrading " - << "V1LayerParameter (see above); continuing anyway."; + << "V1LayerParameter (see above); continuing anyway."; } else { LOG(INFO) << "Successfully upgraded file specified using deprecated " << "V1LayerParameter"; From e7b2b4eab67390885b8cb360750cfc1553fbb70e Mon Sep 17 00:00:00 2001 From: philkr Date: Tue, 4 Aug 2015 10:27:34 -0700 Subject: [PATCH 103/331] ImageData layer default batch size of 1, and check for zero batch size --- src/caffe/layers/image_data_layer.cpp | 3 +++ src/caffe/proto/caffe.proto | 6 +++--- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/src/caffe/layers/image_data_layer.cpp b/src/caffe/layers/image_data_layer.cpp index 18c035cba9d..dcc53348304 100644 --- a/src/caffe/layers/image_data_layer.cpp +++ b/src/caffe/layers/image_data_layer.cpp @@ -62,11 +62,13 @@ void ImageDataLayer::DataLayerSetUp(const vector*>& bottom, // Read an image, and use it to initialize the top blob. cv::Mat cv_img = ReadImageToCVMat(root_folder + lines_[lines_id_].first, new_height, new_width, is_color); + CHECK(cv_img.data) << "Could not load " << lines_[lines_id_].first; // Use data_transformer to infer the expected blob shape from a cv_image. vector top_shape = this->data_transformer_->InferBlobShape(cv_img); this->transformed_data_.Reshape(top_shape); // Reshape prefetch_data and top[0] according to the batch_size. const int batch_size = this->layer_param_.image_data_param().batch_size(); + CHECK_GT(batch_size, 0) << "Positive batch size required"; top_shape[0] = batch_size; this->prefetch_data_.Reshape(top_shape); top[0]->ReshapeLike(this->prefetch_data_); @@ -108,6 +110,7 @@ void ImageDataLayer::InternalThreadEntry() { // on single input batches allows for inputs of varying dimension. cv::Mat cv_img = ReadImageToCVMat(root_folder + lines_[lines_id_].first, new_height, new_width, is_color); + CHECK(cv_img.data) << "Could not load " << lines_[lines_id_].first; // Use data_transformer to infer the expected blob shape from a cv_img. vector top_shape = this->data_transformer_->InferBlobShape(cv_img); this->transformed_data_.Reshape(top_shape); diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 81a8c69d88e..8c3f0723600 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -290,7 +290,7 @@ message LayerParameter { // The blobs containing the numeric parameters of the layer. repeated BlobProto blobs = 7; - + // Specifies on which bottoms the backpropagation should be skipped. // The size must be either 0 or equal to the number of bottoms. repeated bool propagate_down = 11; @@ -431,7 +431,7 @@ message ContrastiveLossParameter { // Hadsell paper. New models should probably use this version. // legacy_version = true uses (margin - d^2). This is kept to support / // reproduce existing models and results - optional bool legacy_version = 2 [default = false]; + optional bool legacy_version = 2 [default = false]; } message ConvolutionParameter { @@ -579,7 +579,7 @@ message ImageDataParameter { // Specify the data source. optional string source = 1; // Specify the batch size. - optional uint32 batch_size = 4; + optional uint32 batch_size = 4 [default = 1]; // The rand_skip variable is for the data layer to skip a few data points // to avoid all asynchronous sgd clients to start at the same point. The skip // point would be set as rand_skip * rand(0,1). Note that rand_skip should not From 4c23e93a95db0c6c6c5d4239070966e3bdc24fdc Mon Sep 17 00:00:00 2001 From: Gustavo Serra Scalet Date: Thu, 6 Aug 2015 14:20:55 -0300 Subject: [PATCH 104/331] Fix download model script to use zip archive Currently GitHub is not using tarballs as archive for downloading gists therefore the script was broken as actually a zip archive was being downloaded. --- scripts/download_model_from_gist.sh | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/download_model_from_gist.sh b/scripts/download_model_from_gist.sh index a1dccf78b5b..89527b7516f 100755 --- a/scripts/download_model_from_gist.sh +++ b/scripts/download_model_from_gist.sh @@ -18,7 +18,7 @@ fi echo "Downloading Caffe model info to $MODEL_DIR ..." mkdir -p $MODEL_DIR -wget https://gist.github.com/$GIST/download -O $MODEL_DIR/gist.tar.gz -tar xzf $MODEL_DIR/gist.tar.gz --directory=$MODEL_DIR --strip-components=1 -rm $MODEL_DIR/gist.tar.gz +wget https://gist.github.com/$GIST/download -O $MODEL_DIR/gist.zip +unzip -j $MODEL_DIR/gist.zip -d $MODEL_DIR +rm $MODEL_DIR/gist.zip echo "Done" From fda9229a426d9c0e4496c700099a7126da72ba64 Mon Sep 17 00:00:00 2001 From: Gustavo Serra Scalet Date: Thu, 6 Aug 2015 14:37:20 -0300 Subject: [PATCH 105/331] Fix download model binary script to get correct lines on parsing table The base reference of "bottom" variable was relative to the "top+1" and not to the whole readlines output. It ended up without all the lines. That could work for some gists however for the model I was looking for (see below) the sha1 key was not being parsed, as it was missing the last line. tested with the following gist: longjon/1bf3aa1e0b8e788d7e1d --- scripts/download_model_binary.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/download_model_binary.py b/scripts/download_model_binary.py index 48e9015fd26..03a50f6776a 100755 --- a/scripts/download_model_binary.py +++ b/scripts/download_model_binary.py @@ -32,7 +32,7 @@ def parse_readme_frontmatter(dirname): with open(readme_filename) as f: lines = [line.strip() for line in f.readlines()] top = lines.index('---') - bottom = lines[top + 1:].index('---') + bottom = lines.index('---', top + 1) frontmatter = yaml.load('\n'.join(lines[top + 1:bottom])) assert all(key in frontmatter for key in required_keys) return dirname, frontmatter From d958b5a45c95db4f4e90abda29b69d5bfed2ef07 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Thu, 6 Aug 2015 13:03:50 -0700 Subject: [PATCH 106/331] [pycaffe,build] include Python first in caffe tool --- tools/caffe.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tools/caffe.cpp b/tools/caffe.cpp index 9de3abdc722..46f99594800 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -1,3 +1,8 @@ +#ifdef WITH_PYTHON_LAYER +#include "boost/python.hpp" +namespace bp = boost::python; +#endif + #include #include @@ -8,11 +13,6 @@ #include "boost/algorithm/string.hpp" #include "caffe/caffe.hpp" -#ifdef WITH_PYTHON_LAYER -#include "boost/python.hpp" -namespace bp = boost::python; -#endif - using caffe::Blob; using caffe::Caffe; using caffe::Net; From 1934feec285c901066ef28567ccc6a7cb5b4ce92 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Thu, 6 Aug 2015 13:04:15 -0700 Subject: [PATCH 107/331] [pytest] open exception file with mode for python3 --- python/caffe/test/test_python_layer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/caffe/test/test_python_layer.py b/python/caffe/test/test_python_layer.py index ff070a35aee..a1e11bc248d 100644 --- a/python/caffe/test/test_python_layer.py +++ b/python/caffe/test/test_python_layer.py @@ -43,7 +43,7 @@ def python_net_file(): def exception_net_file(): - with tempfile.NamedTemporaryFile(delete=False) as f: + with tempfile.NamedTemporaryFile(mode='w+', delete=False) as f: f.write("""name: 'pythonnet' force_backward: true input: 'data' input_shape { dim: 10 dim: 9 dim: 8 } layer { type: 'Python' name: 'layer' bottom: 'data' top: 'top' From a756cfec0056fc59bf8719997df7f3b233babf38 Mon Sep 17 00:00:00 2001 From: Takuya Narihira Date: Fri, 27 Feb 2015 19:34:51 -0800 Subject: [PATCH 108/331] PythonLayer takes parameters by string --- include/caffe/python_layer.hpp | 2 + .../test/test_python_layer_with_param_str.py | 59 +++++++++++++++++++ src/caffe/proto/caffe.proto | 5 ++ 3 files changed, 66 insertions(+) create mode 100644 python/caffe/test/test_python_layer_with_param_str.py diff --git a/include/caffe/python_layer.hpp b/include/caffe/python_layer.hpp index 9c30250c1b5..2957e7426be 100644 --- a/include/caffe/python_layer.hpp +++ b/include/caffe/python_layer.hpp @@ -18,6 +18,8 @@ class PythonLayer : public Layer { virtual void LayerSetUp(const vector*>& bottom, const vector*>& top) { + self_.attr("param_str") = bp::str( + this->layer_param_.python_param().param_str()); self_.attr("setup")(bottom, top); } virtual void Reshape(const vector*>& bottom, diff --git a/python/caffe/test/test_python_layer_with_param_str.py b/python/caffe/test/test_python_layer_with_param_str.py new file mode 100644 index 00000000000..3d0f107b3bb --- /dev/null +++ b/python/caffe/test/test_python_layer_with_param_str.py @@ -0,0 +1,59 @@ +import unittest +import tempfile +import os +import six + +import caffe + + +class SimpleParamLayer(caffe.Layer): + """A layer that just multiplies by the numeric value of its param string""" + + def setup(self, bottom, top): + try: + self.value = float(self.param_str) + except ValueError: + raise ValueError("Parameter string must be a legible float") + + def reshape(self, bottom, top): + top[0].reshape(*bottom[0].data.shape) + + def forward(self, bottom, top): + top[0].data[...] = self.value * bottom[0].data + + def backward(self, top, propagate_down, bottom): + bottom[0].diff[...] = self.value * top[0].diff + + +def python_param_net_file(): + with tempfile.NamedTemporaryFile(mode='w+', delete=False) as f: + f.write("""name: 'pythonnet' force_backward: true + input: 'data' input_shape { dim: 10 dim: 9 dim: 8 } + layer { type: 'Python' name: 'mul10' bottom: 'data' top: 'mul10' + python_param { module: 'test_python_layer_with_param_str' + layer: 'SimpleParamLayer' param_str: '10' } } + layer { type: 'Python' name: 'mul2' bottom: 'mul10' top: 'mul2' + python_param { module: 'test_python_layer_with_param_str' + layer: 'SimpleParamLayer' param_str: '2' } }""") + return f.name + + +class TestLayerWithParam(unittest.TestCase): + def setUp(self): + net_file = python_param_net_file() + self.net = caffe.Net(net_file, caffe.TRAIN) + os.remove(net_file) + + def test_forward(self): + x = 8 + self.net.blobs['data'].data[...] = x + self.net.forward() + for y in self.net.blobs['mul2'].data.flat: + self.assertEqual(y, 2 * 10 * x) + + def test_backward(self): + x = 7 + self.net.blobs['mul2'].diff[...] = x + self.net.backward() + for y in self.net.blobs['data'].diff.flat: + self.assertEqual(y, 2 * 10 * x) diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 8c3f0723600..adcf4e2fd5a 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -703,6 +703,11 @@ message PowerParameter { message PythonParameter { optional string module = 1; optional string layer = 2; + // This value is set to the attribute `param_str` of the `PythonLayer` object + // in Python before calling the `setup()` method. This could be a number, + // string, dictionary in Python dict format, JSON, etc. You may parse this + // string in `setup` method and use it in `forward` and `backward`. + optional string param_str = 3 [default = '']; } // Message that stores parameters used by ReductionLayer From f5116a1d2827a5e1490ce047df7835b66e92f99f Mon Sep 17 00:00:00 2001 From: "koki1.saitoh" Date: Fri, 7 Aug 2015 18:22:28 +0900 Subject: [PATCH 109/331] Fix typo --- include/caffe/layer.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/caffe/layer.hpp b/include/caffe/layer.hpp index e2eba196346..0771b6a8fb4 100644 --- a/include/caffe/layer.hpp +++ b/include/caffe/layer.hpp @@ -86,7 +86,7 @@ class Layer { const vector*>& top) {} /** - * @brief Adjust the shapes of top blobs and internal buffers to accomodate + * @brief Adjust the shapes of top blobs and internal buffers to accommodate * the shapes of the bottom blobs. * * @param bottom the input blobs, with the requested input shapes @@ -95,7 +95,7 @@ class Layer { * This method should reshape top blobs as needed according to the shapes * of the bottom (input) blobs, as well as reshaping any internal buffers * and making any other necessary adjustments so that the layer can - * accomodate the bottom blobs. + * accommodate the bottom blobs. */ virtual void Reshape(const vector*>& bottom, const vector*>& top) = 0; From a3c7425b80fd83ef550323836304a7255d35e033 Mon Sep 17 00:00:00 2001 From: Tian Zhi Date: Sat, 8 Aug 2015 02:31:19 +0800 Subject: [PATCH 110/331] add [] to "delete pixels". see https://isocpp.org/wiki/faq/freestore-mgmt#delete-array-built-ins. --- examples/mnist/convert_mnist_data.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/mnist/convert_mnist_data.cpp b/examples/mnist/convert_mnist_data.cpp index 2749e4521b6..54443f11dd3 100644 --- a/examples/mnist/convert_mnist_data.cpp +++ b/examples/mnist/convert_mnist_data.cpp @@ -166,7 +166,7 @@ void convert_dataset(const char* image_filename, const char* label_filename, } LOG(ERROR) << "Processed " << count << " files."; } - delete pixels; + delete[] pixels; } int main(int argc, char** argv) { From f973819240768df207ed8e4d307564b105950333 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Wed, 29 Jul 2015 17:27:04 -0700 Subject: [PATCH 111/331] add double_data, double_diff to BlobProto for weights/snapshots saved when using Dtype == double --- src/caffe/blob.cpp | 49 +++++++++++++++++++++++++++++++------ src/caffe/proto/caffe.proto | 2 ++ 2 files changed, 44 insertions(+), 7 deletions(-) diff --git a/src/caffe/blob.cpp b/src/caffe/blob.cpp index 94fdcc35fb6..8450aa140be 100644 --- a/src/caffe/blob.cpp +++ b/src/caffe/blob.cpp @@ -456,10 +456,25 @@ void Blob::FromProto(const BlobProto& proto, bool reshape) { } // copy data Dtype* data_vec = mutable_cpu_data(); - for (int i = 0; i < count_; ++i) { - data_vec[i] = proto.data(i); + if (proto.double_data_size() > 0) { + CHECK_EQ(count_, proto.double_data_size()); + for (int i = 0; i < count_; ++i) { + data_vec[i] = proto.double_data(i); + } + } else { + CHECK_EQ(count_, proto.data_size()); + for (int i = 0; i < count_; ++i) { + data_vec[i] = proto.data(i); + } } - if (proto.diff_size() > 0) { + if (proto.double_diff_size() > 0) { + CHECK_EQ(count_, proto.double_diff_size()); + Dtype* diff_vec = mutable_cpu_diff(); + for (int i = 0; i < count_; ++i) { + diff_vec[i] = proto.double_diff(i); + } + } else if (proto.diff_size() > 0) { + CHECK_EQ(count_, proto.diff_size()); Dtype* diff_vec = mutable_cpu_diff(); for (int i = 0; i < count_; ++i) { diff_vec[i] = proto.diff(i); @@ -467,20 +482,40 @@ void Blob::FromProto(const BlobProto& proto, bool reshape) { } } -template -void Blob::ToProto(BlobProto* proto, bool write_diff) const { +template <> +void Blob::ToProto(BlobProto* proto, bool write_diff) const { + proto->clear_shape(); + for (int i = 0; i < shape_.size(); ++i) { + proto->mutable_shape()->add_dim(shape_[i]); + } + proto->clear_double_data(); + proto->clear_double_diff(); + const double* data_vec = cpu_data(); + for (int i = 0; i < count_; ++i) { + proto->add_double_data(data_vec[i]); + } + if (write_diff) { + const double* diff_vec = cpu_diff(); + for (int i = 0; i < count_; ++i) { + proto->add_double_diff(diff_vec[i]); + } + } +} + +template <> +void Blob::ToProto(BlobProto* proto, bool write_diff) const { proto->clear_shape(); for (int i = 0; i < shape_.size(); ++i) { proto->mutable_shape()->add_dim(shape_[i]); } proto->clear_data(); proto->clear_diff(); - const Dtype* data_vec = cpu_data(); + const float* data_vec = cpu_data(); for (int i = 0; i < count_; ++i) { proto->add_data(data_vec[i]); } if (write_diff) { - const Dtype* diff_vec = cpu_diff(); + const float* diff_vec = cpu_diff(); for (int i = 0; i < count_; ++i) { proto->add_diff(diff_vec[i]); } diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index adcf4e2fd5a..03daa808bf8 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -11,6 +11,8 @@ message BlobProto { optional BlobShape shape = 7; repeated float data = 5 [packed = true]; repeated float diff = 6 [packed = true]; + repeated double double_data = 8 [packed = true]; + repeated double double_diff = 9 [packed = true]; // 4D dimensions -- deprecated. Use "shape" instead. optional int32 num = 1 [default = 0]; From 1e740e1e8568063ffe69162a30a97961c5c62af0 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Wed, 29 Jul 2015 17:27:58 -0700 Subject: [PATCH 112/331] TestGradientBasedSolver: add TestSnapshot to verify behavior when restoring net/solver from snapshot --- src/caffe/test/test_gradient_based_solver.cpp | 112 +++++++++++++++++- 1 file changed, 107 insertions(+), 5 deletions(-) diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index c9135d64e70..94b500124aa 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -10,6 +10,7 @@ #include "caffe/common.hpp" #include "caffe/proto/caffe.pb.h" #include "caffe/solver.hpp" +#include "caffe/util/io.hpp" #include "caffe/test/test_caffe_main.hpp" @@ -25,6 +26,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { GradientBasedSolverTest() : seed_(1701), num_(4), channels_(3), height_(10), width_(10) {} + string snapshot_prefix_; shared_ptr > solver_; int seed_; int num_, channels_, height_, width_; @@ -36,9 +38,6 @@ class GradientBasedSolverTest : public MultiDeviceTest { virtual void InitSolverFromProtoString(const string& proto) { SolverParameter param; CHECK(google::protobuf::TextFormat::ParseFromString(proto, ¶m)); - // Disable saving a final snapshot so the tests don't pollute the user's - // working directory with useless snapshots. - param.set_snapshot_after_train(false); // Set the solver_mode according to current Caffe::mode. switch (Caffe::mode()) { case Caffe::CPU: @@ -55,11 +54,13 @@ class GradientBasedSolverTest : public MultiDeviceTest { param.delta() : 0; } - void RunLeastSquaresSolver(const Dtype learning_rate, + string RunLeastSquaresSolver(const Dtype learning_rate, const Dtype weight_decay, const Dtype momentum, const int num_iters, - const int iter_size = 1) { + const int iter_size = 1, const bool snapshot = false, + const char* from_snapshot = NULL) { ostringstream proto; proto << + "snapshot_after_train: " << snapshot << " " "max_iter: " << num_iters << " " "base_lr: " << learning_rate << " " "lr_policy: 'fixed' " @@ -119,9 +120,30 @@ class GradientBasedSolverTest : public MultiDeviceTest { if (momentum != 0) { proto << "momentum: " << momentum << " "; } + MakeTempDir(&snapshot_prefix_); + proto << "snapshot_prefix: '" << snapshot_prefix_ << "/' "; + if (snapshot) { + proto << "snapshot: " << num_iters << " "; + } Caffe::set_random_seed(this->seed_); this->InitSolverFromProtoString(proto.str()); + Caffe::set_random_seed(this->seed_); + if (from_snapshot != NULL) { + this->solver_->Restore(from_snapshot); + vector*> empty_bottom_vec; + for (int i = 0; i < this->solver_->iter(); ++i) { + this->solver_->net()->Forward(empty_bottom_vec); + } + } this->solver_->Solve(); + if (snapshot) { + ostringstream resume_file; + resume_file << snapshot_prefix_ << "/_iter_" << num_iters + << ".solverstate"; + string resume_filename = resume_file.str(); + return resume_filename; + } + return string(); } // Compute an update value given the current state of the train net, @@ -348,6 +370,51 @@ class GradientBasedSolverTest : public MultiDeviceTest { // Check that the solver's solution matches ours. CheckLeastSquaresUpdate(updated_params); } + + void TestSnapshot(const Dtype learning_rate = 1.0, + const Dtype weight_decay = 0.0, const Dtype momentum = 0.0, + const int num_iters = 1) { + // Run the solver for num_iters * 2 iterations. + const int total_num_iters = num_iters * 2; + bool snapshot = false; + const int kIterSize = 1; + RunLeastSquaresSolver(learning_rate, weight_decay, momentum, + total_num_iters, kIterSize, snapshot); + + // Save the resulting param values. + vector > > param_copies; + const vector > >& orig_params = + solver_->net()->params(); + param_copies.resize(orig_params.size()); + for (int i = 0; i < orig_params.size(); ++i) { + param_copies[i].reset(new Blob()); + const bool kReshape = true; + for (int copy_diff = false; copy_diff <= true; ++copy_diff) { + param_copies[i]->CopyFrom(*orig_params[i], copy_diff, kReshape); + } + } + + // Run the solver for num_iters iterations and snapshot. + snapshot = true; + string snapshot_name = RunLeastSquaresSolver(learning_rate, weight_decay, + momentum, num_iters, kIterSize, snapshot); + + // Reinitialize the solver and run for num_iters more iterations. + snapshot = false; + RunLeastSquaresSolver(learning_rate, weight_decay, + momentum, total_num_iters, kIterSize, snapshot, snapshot_name.c_str()); + + // Check that params now match. + const vector > >& params = solver_->net()->params(); + for (int i = 0; i < params.size(); ++i) { + for (int j = 0; j < params[i]->count(); ++j) { + EXPECT_EQ(param_copies[i]->cpu_data()[j], params[i]->cpu_data()[j]) + << "param " << i << " data differed at dim " << j; + EXPECT_EQ(param_copies[i]->cpu_diff()[j], params[i]->cpu_diff()[j]) + << "param " << i << " diff differed at dim " << j; + } + } + } }; @@ -428,6 +495,18 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { kIterSize); } +TYPED_TEST(SGDSolverTest, TestSnapshot) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + } +} + + template class AdaGradSolverTest : public GradientBasedSolverTest { typedef typename TypeParam::Dtype Dtype; @@ -482,6 +561,18 @@ TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { kIterSize); } +TYPED_TEST(AdaGradSolverTest, TestSnapshot) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.0; + const int kNumIters = 4; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + } +} + + template class NesterovSolverTest : public GradientBasedSolverTest { typedef typename TypeParam::Dtype Dtype; @@ -558,4 +649,15 @@ TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { kIterSize); } +TYPED_TEST(NesterovSolverTest, TestSnapshot) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.0; + const int kNumIters = 4; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + } +} + } // namespace caffe From 50195e353293a7f41e7c95e158844eef53a70a2b Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Thu, 6 Aug 2015 13:46:11 -0700 Subject: [PATCH 113/331] pycaffe: add shape accessor --- python/caffe/_caffe.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/python/caffe/_caffe.cpp b/python/caffe/_caffe.cpp index dff7f627016..bb5130fddd0 100644 --- a/python/caffe/_caffe.cpp +++ b/python/caffe/_caffe.cpp @@ -230,6 +230,11 @@ BOOST_PYTHON_MODULE(_caffe) { bp::class_, shared_ptr >, boost::noncopyable>( "Blob", bp::no_init) + .add_property("shape", + bp::make_function( + static_cast& (Blob::*)() const>( + &Blob::shape), + bp::return_value_policy())) .add_property("num", &Blob::num) .add_property("channels", &Blob::channels) .add_property("height", &Blob::height) From ada055bbf155882534907a7fb98a35e4f7bba392 Mon Sep 17 00:00:00 2001 From: Eric Tzeng Date: Wed, 22 Jul 2015 16:17:01 -0700 Subject: [PATCH 114/331] Snapshot model weights/solver state to HDF5 files. Summary of changes: - HDF5 helper functions were moved into a separate file util/hdf5.cpp - hdf5_save_nd_dataset now saves n-d blobs, can save diffs instead of data - Minor fix for memory leak in HDF5 functions (delete instead of delete[]) - Extra methods have been added to both Net/Solver enabling snapshotting and restoring from HDF5 files - snapshot_format was added to SolverParameters, with possible values HDF5 or BINARYPROTO (default HDF5) - kMaxBlobAxes was reduced to 32 to match the limitations of HDF5 --- include/caffe/blob.hpp | 2 +- include/caffe/net.hpp | 4 + include/caffe/solver.hpp | 21 ++- include/caffe/util/hdf5.hpp | 39 +++++ include/caffe/util/io.hpp | 18 --- src/caffe/layers/hdf5_data_layer.cpp | 2 +- src/caffe/layers/hdf5_output_layer.cpp | 2 +- src/caffe/layers/hdf5_output_layer.cu | 1 - src/caffe/net.cpp | 122 +++++++++++++++- src/caffe/proto/caffe.proto | 7 +- src/caffe/solver.cpp | 164 ++++++++++++++++++---- src/caffe/test/test_hdf5_output_layer.cpp | 1 + src/caffe/util/hdf5.cpp | 160 +++++++++++++++++++++ src/caffe/util/io.cpp | 74 ---------- 14 files changed, 482 insertions(+), 135 deletions(-) create mode 100644 include/caffe/util/hdf5.hpp create mode 100644 src/caffe/util/hdf5.cpp diff --git a/include/caffe/blob.hpp b/include/caffe/blob.hpp index 472cc1841f7..9b813e739e9 100644 --- a/include/caffe/blob.hpp +++ b/include/caffe/blob.hpp @@ -10,7 +10,7 @@ #include "caffe/syncedmem.hpp" #include "caffe/util/math_functions.hpp" -const int kMaxBlobAxes = INT_MAX; +const int kMaxBlobAxes = 32; namespace caffe { diff --git a/include/caffe/net.hpp b/include/caffe/net.hpp index 5665df1edf2..dfd2e556a2b 100644 --- a/include/caffe/net.hpp +++ b/include/caffe/net.hpp @@ -98,8 +98,12 @@ class Net { */ void CopyTrainedLayersFrom(const NetParameter& param); void CopyTrainedLayersFrom(const string trained_filename); + void CopyTrainedLayersFromBinaryProto(const string trained_filename); + void CopyTrainedLayersFromHDF5(const string trained_filename); /// @brief Writes the net to a proto. void ToProto(NetParameter* param, bool write_diff = false) const; + /// @brief Writes the net to an HDF5 file. + void ToHDF5(const string& filename, bool write_diff = false) const; /// @brief returns the network name. inline const string& name() const { return name_; } diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index c2ced487d6f..703434b5fcf 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -27,9 +27,9 @@ class Solver { virtual void Solve(const char* resume_file = NULL); inline void Solve(const string resume_file) { Solve(resume_file.c_str()); } void Step(int iters); - // The Restore function implements how one should restore the solver to a - // previously snapshotted state. You should implement the RestoreSolverState() - // function that restores the state from a SolverState protocol buffer. + // The Restore method simply dispatches to one of the + // RestoreSolverStateFrom___ protected methods. You should implement these + // methods to restore the state from the appropriate snapshot type. void Restore(const char* resume_file); virtual ~Solver() {} inline shared_ptr > net() { return net_; } @@ -46,11 +46,15 @@ class Solver { // function that produces a SolverState protocol buffer that needs to be // written to disk together with the learned net. void Snapshot(); + string SnapshotFilename(const string extension); + string SnapshotToBinaryProto(); + string SnapshotToHDF5(); // The test routine void TestAll(); void Test(const int test_net_id = 0); - virtual void SnapshotSolverState(SolverState* state) = 0; - virtual void RestoreSolverState(const SolverState& state) = 0; + virtual void SnapshotSolverState(const string& model_filename) = 0; + virtual void RestoreSolverStateFromHDF5(const string& state_file) = 0; + virtual void RestoreSolverStateFromBinaryProto(const string& state_file) = 0; void DisplayOutputBlobs(const int net_id); SolverParameter param_; @@ -85,8 +89,11 @@ class SGDSolver : public Solver { virtual void Regularize(int param_id); virtual void ComputeUpdateValue(int param_id, Dtype rate); virtual void ClipGradients(); - virtual void SnapshotSolverState(SolverState * state); - virtual void RestoreSolverState(const SolverState& state); + virtual void SnapshotSolverState(const string& model_filename); + virtual void SnapshotSolverStateToBinaryProto(const string& model_filename); + virtual void SnapshotSolverStateToHDF5(const string& model_filename); + virtual void RestoreSolverStateFromHDF5(const string& state_file); + virtual void RestoreSolverStateFromBinaryProto(const string& state_file); // history maintains the historical momentum data. // update maintains update related data and is not needed in snapshots. // temp maintains other information that might be needed in computation diff --git a/include/caffe/util/hdf5.hpp b/include/caffe/util/hdf5.hpp new file mode 100644 index 00000000000..ce568c5eb0d --- /dev/null +++ b/include/caffe/util/hdf5.hpp @@ -0,0 +1,39 @@ +#ifndef CAFFE_UTIL_HDF5_H_ +#define CAFFE_UTIL_HDF5_H_ + +#include + +#include "hdf5.h" +#include "hdf5_hl.h" + +#include "caffe/blob.hpp" + +namespace caffe { + +template +void hdf5_load_nd_dataset_helper( + hid_t file_id, const char* dataset_name_, int min_dim, int max_dim, + Blob* blob); + +template +void hdf5_load_nd_dataset( + hid_t file_id, const char* dataset_name_, int min_dim, int max_dim, + Blob* blob); + +template +void hdf5_save_nd_dataset( + const hid_t file_id, const string& dataset_name, const Blob& blob, + bool write_diff = false); + +int hdf5_load_int(hid_t loc_id, const string& dataset_name); +void hdf5_save_int(hid_t loc_id, const string& dataset_name, int i); +string hdf5_load_string(hid_t loc_id, const string& dataset_name); +void hdf5_save_string(hid_t loc_id, const string& dataset_name, + const string& s); + +int hdf5_get_num_links(hid_t loc_id); +string hdf5_get_name_by_idx(hid_t loc_id, int idx); + +} // namespace caffe + +#endif // CAFFE_UTIL_HDF5_H_ diff --git a/include/caffe/util/io.hpp b/include/caffe/util/io.hpp index 3a62c3c9fa9..c0938ad0625 100644 --- a/include/caffe/util/io.hpp +++ b/include/caffe/util/io.hpp @@ -5,15 +5,11 @@ #include #include "google/protobuf/message.h" -#include "hdf5.h" -#include "hdf5_hl.h" #include "caffe/blob.hpp" #include "caffe/common.hpp" #include "caffe/proto/caffe.pb.h" -#define HDF5_NUM_DIMS 4 - namespace caffe { using ::google::protobuf::Message; @@ -140,20 +136,6 @@ cv::Mat DecodeDatumToCVMat(const Datum& datum, bool is_color); void CVMatToDatum(const cv::Mat& cv_img, Datum* datum); -template -void hdf5_load_nd_dataset_helper( - hid_t file_id, const char* dataset_name_, int min_dim, int max_dim, - Blob* blob); - -template -void hdf5_load_nd_dataset( - hid_t file_id, const char* dataset_name_, int min_dim, int max_dim, - Blob* blob); - -template -void hdf5_save_nd_dataset( - const hid_t file_id, const string& dataset_name, const Blob& blob); - } // namespace caffe #endif // CAFFE_UTIL_IO_H_ diff --git a/src/caffe/layers/hdf5_data_layer.cpp b/src/caffe/layers/hdf5_data_layer.cpp index 8a782f7e524..8ced51039cf 100644 --- a/src/caffe/layers/hdf5_data_layer.cpp +++ b/src/caffe/layers/hdf5_data_layer.cpp @@ -16,7 +16,7 @@ #include "caffe/data_layers.hpp" #include "caffe/layer.hpp" -#include "caffe/util/io.hpp" +#include "caffe/util/hdf5.hpp" namespace caffe { diff --git a/src/caffe/layers/hdf5_output_layer.cpp b/src/caffe/layers/hdf5_output_layer.cpp index f63375c3dc6..56788c21e5e 100644 --- a/src/caffe/layers/hdf5_output_layer.cpp +++ b/src/caffe/layers/hdf5_output_layer.cpp @@ -6,7 +6,7 @@ #include "caffe/blob.hpp" #include "caffe/common.hpp" #include "caffe/layer.hpp" -#include "caffe/util/io.hpp" +#include "caffe/util/hdf5.hpp" #include "caffe/vision_layers.hpp" namespace caffe { diff --git a/src/caffe/layers/hdf5_output_layer.cu b/src/caffe/layers/hdf5_output_layer.cu index ae497c34fc2..eb6d0e470b0 100644 --- a/src/caffe/layers/hdf5_output_layer.cu +++ b/src/caffe/layers/hdf5_output_layer.cu @@ -6,7 +6,6 @@ #include "caffe/blob.hpp" #include "caffe/common.hpp" #include "caffe/layer.hpp" -#include "caffe/util/io.hpp" #include "caffe/vision_layers.hpp" namespace caffe { diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index a18ee63818e..0812b367ac3 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -5,12 +5,14 @@ #include #include +#include "hdf5.h" + #include "caffe/common.hpp" #include "caffe/layer.hpp" #include "caffe/net.hpp" #include "caffe/proto/caffe.pb.h" +#include "caffe/util/hdf5.hpp" #include "caffe/util/insert_splits.hpp" -#include "caffe/util/io.hpp" #include "caffe/util/math_functions.hpp" #include "caffe/util/upgrade_proto.hpp" @@ -747,11 +749,72 @@ void Net::CopyTrainedLayersFrom(const NetParameter& param) { template void Net::CopyTrainedLayersFrom(const string trained_filename) { + if (trained_filename.size() >= 3 && + trained_filename.compare(trained_filename.size() - 3, 3, ".h5") == 0) { + CopyTrainedLayersFromHDF5(trained_filename); + } else { + CopyTrainedLayersFromBinaryProto(trained_filename); + } +} + +template +void Net::CopyTrainedLayersFromBinaryProto( + const string trained_filename) { NetParameter param; ReadNetParamsFromBinaryFileOrDie(trained_filename, ¶m); CopyTrainedLayersFrom(param); } +template +void Net::CopyTrainedLayersFromHDF5(const string trained_filename) { + hid_t file_hid = H5Fopen(trained_filename.c_str(), H5F_ACC_RDONLY, + H5P_DEFAULT); + CHECK_GE(file_hid, 0) << "Couldn't open " << trained_filename; + hid_t data_hid = H5Gopen2(file_hid, "data", H5P_DEFAULT); + CHECK_GE(data_hid, 0) << "Error reading weights from " << trained_filename; + int num_layers = hdf5_get_num_links(data_hid); + for (int i = 0; i < num_layers; ++i) { + string source_layer_name = hdf5_get_name_by_idx(data_hid, i); + if (!layer_names_index_.count(source_layer_name)) { + DLOG(INFO) << "Ignoring source layer " << source_layer_name; + continue; + } + int target_layer_id = layer_names_index_[source_layer_name]; + DLOG(INFO) << "Copying source layer " << source_layer_name; + vector > >& target_blobs = + layers_[target_layer_id]->blobs(); + hid_t layer_hid = H5Gopen2(data_hid, source_layer_name.c_str(), + H5P_DEFAULT); + CHECK_GE(layer_hid, 0) + << "Error reading weights from " << trained_filename; + // Check that source layer doesn't have more params than target layer + int num_source_params = hdf5_get_num_links(layer_hid); + CHECK_LE(num_source_params, target_blobs.size()) + << "Incompatible number of blobs for layer " << source_layer_name; + for (int j = 0; j < target_blobs.size(); ++j) { + ostringstream oss; + oss << j; + string dataset_name = oss.str(); + int target_net_param_id = param_id_vecs_[target_layer_id][j]; + if (!H5Lexists(layer_hid, dataset_name.c_str(), H5P_DEFAULT)) { + // Target param doesn't exist in source weights... + if (param_owners_[target_net_param_id] != -1) { + // ...but it's weight-shared in target, so that's fine. + continue; + } else { + LOG(FATAL) << "Incompatible number of blobs for layer " + << source_layer_name; + } + } + hdf5_load_nd_dataset(layer_hid, dataset_name.c_str(), 0, kMaxBlobAxes, + target_blobs[j].get()); + } + H5Gclose(layer_hid); + } + H5Gclose(data_hid); + H5Fclose(file_hid); +} + template void Net::ToProto(NetParameter* param, bool write_diff) const { param->Clear(); @@ -773,6 +836,63 @@ void Net::ToProto(NetParameter* param, bool write_diff) const { } } +template +void Net::ToHDF5(const string& filename, bool write_diff) const { + hid_t file_hid = H5Fcreate(filename.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, + H5P_DEFAULT); + CHECK_GE(file_hid, 0) + << "Couldn't open " << filename << " to save weights."; + hid_t data_hid = H5Gcreate2(file_hid, "data", H5P_DEFAULT, H5P_DEFAULT, + H5P_DEFAULT); + CHECK_GE(data_hid, 0) << "Error saving weights to " << filename << "."; + hid_t diff_hid = -1; + if (write_diff) { + diff_hid = H5Gcreate2(file_hid, "diff", H5P_DEFAULT, H5P_DEFAULT, + H5P_DEFAULT); + CHECK_GE(diff_hid, 0) << "Error saving weights to " << filename << "."; + } + for (int layer_id = 0; layer_id < layers_.size(); ++layer_id) { + const LayerParameter& layer_param = layers_[layer_id]->layer_param(); + string layer_name = layer_param.name(); + hid_t layer_data_hid = H5Gcreate2(data_hid, layer_name.c_str(), + H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); + CHECK_GE(layer_data_hid, 0) + << "Error saving weights to " << filename << "."; + hid_t layer_diff_hid = -1; + if (write_diff) { + layer_diff_hid = H5Gcreate2(diff_hid, layer_name.c_str(), + H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); + CHECK_GE(layer_diff_hid, 0) + << "Error saving weights to " << filename << "."; + } + int num_params = layers_[layer_id]->blobs().size(); + for (int param_id = 0; param_id < num_params; ++param_id) { + ostringstream dataset_name; + dataset_name << param_id; + const int net_param_id = param_id_vecs_[layer_id][param_id]; + if (param_owners_[net_param_id] == -1) { + // Only save params that own themselves + hdf5_save_nd_dataset(layer_data_hid, dataset_name.str(), + *params_[net_param_id]); + } + if (write_diff) { + // Write diffs regardless of weight-sharing + hdf5_save_nd_dataset(layer_diff_hid, dataset_name.str(), + *params_[net_param_id], true); + } + } + H5Gclose(layer_data_hid); + if (write_diff) { + H5Gclose(layer_diff_hid); + } + } + H5Gclose(data_hid); + if (write_diff) { + H5Gclose(diff_hid); + } + H5Fclose(file_hid); +} + template void Net::Update() { // First, accumulate the diffs of any shared parameters into their owner's diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 03daa808bf8..96e975be566 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -98,7 +98,7 @@ message NetParameter { // NOTE // Update the next available ID when you add a new SolverParameter field. // -// SolverParameter next available ID: 37 (last added: iter_size) +// SolverParameter next available ID: 38 (last added: snapshot_format) message SolverParameter { ////////////////////////////////////////////////////////////////////////////// // Specifying the train and test networks @@ -175,6 +175,11 @@ message SolverParameter { // whether to snapshot diff in the results or not. Snapshotting diff will help // debugging but the final protocol buffer size will be much larger. optional bool snapshot_diff = 16 [default = false]; + enum SnapshotFormat { + HDF5 = 0; + BINARYPROTO = 1; + } + optional SnapshotFormat snapshot_format = 37 [default = HDF5]; // the mode solver will use: 0 for CPU and 1 for GPU. Use GPU in default. enum SolverMode { CPU = 0; diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index aabe0edec80..75271138bdd 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -4,9 +4,13 @@ #include #include +#include "hdf5.h" +#include "hdf5_hl.h" + #include "caffe/net.hpp" #include "caffe/proto/caffe.pb.h" #include "caffe/solver.hpp" +#include "caffe/util/hdf5.hpp" #include "caffe/util/io.hpp" #include "caffe/util/math_functions.hpp" #include "caffe/util/upgrade_proto.hpp" @@ -348,42 +352,58 @@ void Solver::Test(const int test_net_id) { template void Solver::Snapshot() { - NetParameter net_param; - // For intermediate results, we will also dump the gradient values. - net_->ToProto(&net_param, param_.snapshot_diff()); + string model_filename; + switch (param_.snapshot_format()) { + case caffe::SolverParameter_SnapshotFormat_BINARYPROTO: + model_filename = SnapshotToBinaryProto(); + break; + case caffe::SolverParameter_SnapshotFormat_HDF5: + model_filename = SnapshotToHDF5(); + break; + default: + LOG(FATAL) << "Unsupported snapshot format."; + } + + SnapshotSolverState(model_filename); +} + +template +string Solver::SnapshotFilename(const string extension) { string filename(param_.snapshot_prefix()); - string model_filename, snapshot_filename; const int kBufferSize = 20; char iter_str_buffer[kBufferSize]; snprintf(iter_str_buffer, kBufferSize, "_iter_%d", iter_); - filename += iter_str_buffer; - model_filename = filename + ".caffemodel"; - LOG(INFO) << "Snapshotting to " << model_filename; - WriteProtoToBinaryFile(net_param, model_filename.c_str()); - SolverState state; - SnapshotSolverState(&state); - state.set_iter(iter_); - state.set_learned_net(model_filename); - state.set_current_step(current_step_); - snapshot_filename = filename + ".solverstate"; - LOG(INFO) << "Snapshotting solver state to " << snapshot_filename; - WriteProtoToBinaryFile(state, snapshot_filename.c_str()); + return filename + iter_str_buffer + extension; } template -void Solver::Restore(const char* state_file) { - SolverState state; +string Solver::SnapshotToBinaryProto() { + string model_filename = SnapshotFilename(".caffemodel"); + LOG(INFO) << "Snapshotting to binary proto file " << model_filename; NetParameter net_param; - ReadProtoFromBinaryFile(state_file, &state); - if (state.has_learned_net()) { - ReadNetParamsFromBinaryFileOrDie(state.learned_net().c_str(), &net_param); - net_->CopyTrainedLayersFrom(net_param); - } - iter_ = state.iter(); - current_step_ = state.current_step(); - RestoreSolverState(state); + net_->ToProto(&net_param, param_.snapshot_diff()); + WriteProtoToBinaryFile(net_param, model_filename); + return model_filename; +} + +template +string Solver::SnapshotToHDF5() { + string model_filename = SnapshotFilename(".caffemodel.h5"); + LOG(INFO) << "Snapshotting to HDF5 file " << model_filename; + net_->ToHDF5(model_filename, param_.snapshot_diff()); + return model_filename; } +template +void Solver::Restore(const char* state_file) { + string state_filename(state_file); + if (state_filename.size() >= 3 && + state_filename.compare(state_filename.size() - 3, 3, ".h5") == 0) { + RestoreSolverStateFromHDF5(state_filename); + } else { + RestoreSolverStateFromBinaryProto(state_filename); + } +} // Return the current learning rate. The currently implemented learning rate // policies are as follows: @@ -618,17 +638,76 @@ void SGDSolver::ComputeUpdateValue(int param_id, Dtype rate) { } template -void SGDSolver::SnapshotSolverState(SolverState* state) { - state->clear_history(); +void SGDSolver::SnapshotSolverState(const string& model_filename) { + switch (this->param_.snapshot_format()) { + case caffe::SolverParameter_SnapshotFormat_BINARYPROTO: + SnapshotSolverStateToBinaryProto(model_filename); + break; + case caffe::SolverParameter_SnapshotFormat_HDF5: + SnapshotSolverStateToHDF5(model_filename); + break; + default: + LOG(FATAL) << "Unsupported snapshot format."; + } +} + +template +void SGDSolver::SnapshotSolverStateToBinaryProto( + const string& model_filename) { + SolverState state; + state.set_iter(this->iter_); + state.set_learned_net(model_filename); + state.set_current_step(this->current_step_); + state.clear_history(); for (int i = 0; i < history_.size(); ++i) { // Add history - BlobProto* history_blob = state->add_history(); + BlobProto* history_blob = state.add_history(); history_[i]->ToProto(history_blob); } + string snapshot_filename = Solver::SnapshotFilename(".solverstate"); + LOG(INFO) + << "Snapshotting solver state to binary proto file" << snapshot_filename; + WriteProtoToBinaryFile(state, snapshot_filename.c_str()); +} + +template +void SGDSolver::SnapshotSolverStateToHDF5( + const string& model_filename) { + string snapshot_filename = + Solver::SnapshotFilename(".solverstate.h5"); + LOG(INFO) << "Snapshotting solver state to HDF5 file " << snapshot_filename; + hid_t file_hid = H5Fcreate(snapshot_filename.c_str(), H5F_ACC_TRUNC, + H5P_DEFAULT, H5P_DEFAULT); + CHECK_GE(file_hid, 0) + << "Couldn't open " << snapshot_filename << " to save solver state."; + hdf5_save_int(file_hid, "iter", this->iter_); + hdf5_save_string(file_hid, "learned_net", model_filename); + hdf5_save_int(file_hid, "current_step", this->current_step_); + hid_t history_hid = H5Gcreate2(file_hid, "history", H5P_DEFAULT, H5P_DEFAULT, + H5P_DEFAULT); + CHECK_GE(history_hid, 0) + << "Error saving solver state to " << snapshot_filename << "."; + for (int i = 0; i < history_.size(); ++i) { + ostringstream oss; + oss << i; + hdf5_save_nd_dataset(history_hid, oss.str(), *history_[i]); + } + H5Gclose(history_hid); + H5Fclose(file_hid); } template -void SGDSolver::RestoreSolverState(const SolverState& state) { +void SGDSolver::RestoreSolverStateFromBinaryProto( + const string& state_file) { + SolverState state; + ReadProtoFromBinaryFile(state_file, &state); + this->iter_ = state.iter(); + if (state.has_learned_net()) { + NetParameter net_param; + ReadNetParamsFromBinaryFileOrDie(state.learned_net().c_str(), &net_param); + this->net_->CopyTrainedLayersFrom(net_param); + } + this->current_step_ = state.current_step(); CHECK_EQ(state.history_size(), history_.size()) << "Incorrect length of history blobs."; LOG(INFO) << "SGDSolver: restoring history"; @@ -637,6 +716,31 @@ void SGDSolver::RestoreSolverState(const SolverState& state) { } } +template +void SGDSolver::RestoreSolverStateFromHDF5(const string& state_file) { + hid_t file_hid = H5Fopen(state_file.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT); + CHECK_GE(file_hid, 0) << "Couldn't open solver state file " << state_file; + this->iter_ = hdf5_load_int(file_hid, "iter"); + if (H5LTfind_dataset(file_hid, "learned_net")) { + string learned_net = hdf5_load_string(file_hid, "learned_net"); + this->net_->CopyTrainedLayersFrom(learned_net); + } + this->current_step_ = hdf5_load_int(file_hid, "current_step"); + hid_t history_hid = H5Gopen2(file_hid, "history", H5P_DEFAULT); + CHECK_GE(history_hid, 0) << "Error reading history from " << state_file; + int state_history_size = hdf5_get_num_links(history_hid); + CHECK_EQ(state_history_size, history_.size()) + << "Incorrect length of history blobs."; + for (int i = 0; i < history_.size(); ++i) { + ostringstream oss; + oss << i; + hdf5_load_nd_dataset(history_hid, oss.str().c_str(), 0, + kMaxBlobAxes, history_[i].get()); + } + H5Gclose(history_hid); + H5Fclose(file_hid); +} + template void NesterovSolver::ComputeUpdateValue(int param_id, Dtype rate) { const vector > >& net_params = this->net_->params(); diff --git a/src/caffe/test/test_hdf5_output_layer.cpp b/src/caffe/test/test_hdf5_output_layer.cpp index a23034f284a..b56277b53ae 100644 --- a/src/caffe/test/test_hdf5_output_layer.cpp +++ b/src/caffe/test/test_hdf5_output_layer.cpp @@ -6,6 +6,7 @@ #include "caffe/blob.hpp" #include "caffe/common.hpp" #include "caffe/proto/caffe.pb.h" +#include "caffe/util/hdf5.hpp" #include "caffe/util/io.hpp" #include "caffe/vision_layers.hpp" diff --git a/src/caffe/util/hdf5.cpp b/src/caffe/util/hdf5.cpp new file mode 100644 index 00000000000..d0d05f70f8f --- /dev/null +++ b/src/caffe/util/hdf5.cpp @@ -0,0 +1,160 @@ +#include "caffe/util/hdf5.hpp" + +#include +#include + +namespace caffe { + +// Verifies format of data stored in HDF5 file and reshapes blob accordingly. +template +void hdf5_load_nd_dataset_helper( + hid_t file_id, const char* dataset_name_, int min_dim, int max_dim, + Blob* blob) { + // Verify that the dataset exists. + CHECK(H5LTfind_dataset(file_id, dataset_name_)) + << "Failed to find HDF5 dataset " << dataset_name_; + // Verify that the number of dimensions is in the accepted range. + herr_t status; + int ndims; + status = H5LTget_dataset_ndims(file_id, dataset_name_, &ndims); + CHECK_GE(status, 0) << "Failed to get dataset ndims for " << dataset_name_; + CHECK_GE(ndims, min_dim); + CHECK_LE(ndims, max_dim); + + // Verify that the data format is what we expect: float or double. + std::vector dims(ndims); + H5T_class_t class_; + status = H5LTget_dataset_info( + file_id, dataset_name_, dims.data(), &class_, NULL); + CHECK_GE(status, 0) << "Failed to get dataset info for " << dataset_name_; + CHECK_EQ(class_, H5T_FLOAT) << "Expected float or double data"; + + vector blob_dims(dims.size()); + for (int i = 0; i < dims.size(); ++i) { + blob_dims[i] = dims[i]; + } + blob->Reshape(blob_dims); +} + +template <> +void hdf5_load_nd_dataset(hid_t file_id, const char* dataset_name_, + int min_dim, int max_dim, Blob* blob) { + hdf5_load_nd_dataset_helper(file_id, dataset_name_, min_dim, max_dim, blob); + herr_t status = H5LTread_dataset_float( + file_id, dataset_name_, blob->mutable_cpu_data()); + CHECK_GE(status, 0) << "Failed to read float dataset " << dataset_name_; +} + +template <> +void hdf5_load_nd_dataset(hid_t file_id, const char* dataset_name_, + int min_dim, int max_dim, Blob* blob) { + hdf5_load_nd_dataset_helper(file_id, dataset_name_, min_dim, max_dim, blob); + herr_t status = H5LTread_dataset_double( + file_id, dataset_name_, blob->mutable_cpu_data()); + CHECK_GE(status, 0) << "Failed to read double dataset " << dataset_name_; +} + +template <> +void hdf5_save_nd_dataset( + const hid_t file_id, const string& dataset_name, const Blob& blob, + bool write_diff) { + int num_axes = blob.num_axes(); + hsize_t *dims = new hsize_t[num_axes]; + for (int i = 0; i < num_axes; ++i) { + dims[i] = blob.shape(i); + } + const float* data; + if (write_diff) { + data = blob.cpu_diff(); + } else { + data = blob.cpu_data(); + } + herr_t status = H5LTmake_dataset_float( + file_id, dataset_name.c_str(), num_axes, dims, data); + CHECK_GE(status, 0) << "Failed to make float dataset " << dataset_name; + delete[] dims; +} + +template <> +void hdf5_save_nd_dataset( + hid_t file_id, const string& dataset_name, const Blob& blob, + bool write_diff) { + int num_axes = blob.num_axes(); + hsize_t *dims = new hsize_t[num_axes]; + for (int i = 0; i < num_axes; ++i) { + dims[i] = blob.shape(i); + } + const double* data; + if (write_diff) { + data = blob.cpu_diff(); + } else { + data = blob.cpu_data(); + } + herr_t status = H5LTmake_dataset_double( + file_id, dataset_name.c_str(), num_axes, dims, data); + CHECK_GE(status, 0) << "Failed to make double dataset " << dataset_name; + delete[] dims; +} + +string hdf5_load_string(hid_t loc_id, const string& dataset_name) { + // Get size of dataset + size_t size; + H5T_class_t class_; + herr_t status = \ + H5LTget_dataset_info(loc_id, dataset_name.c_str(), NULL, &class_, &size); + CHECK_GE(status, 0) << "Failed to get dataset info for " << dataset_name; + char *buf = new char[size]; + status = H5LTread_dataset_string(loc_id, dataset_name.c_str(), buf); + CHECK_GE(status, 0) + << "Failed to load int dataset with name " << dataset_name; + string val(buf); + delete[] buf; + return val; +} + +void hdf5_save_string(hid_t loc_id, const string& dataset_name, + const string& s) { + herr_t status = \ + H5LTmake_dataset_string(loc_id, dataset_name.c_str(), s.c_str()); + CHECK_GE(status, 0) + << "Failed to save string dataset with name " << dataset_name; +} + +int hdf5_load_int(hid_t loc_id, const string& dataset_name) { + int val; + herr_t status = H5LTread_dataset_int(loc_id, dataset_name.c_str(), &val); + CHECK_GE(status, 0) + << "Failed to load int dataset with name " << dataset_name; + return val; +} + +void hdf5_save_int(hid_t loc_id, const string& dataset_name, int i) { + hsize_t one = 1; + herr_t status = \ + H5LTmake_dataset_int(loc_id, dataset_name.c_str(), 1, &one, &i); + CHECK_GE(status, 0) + << "Failed to save int dataset with name " << dataset_name; +} + +int hdf5_get_num_links(hid_t loc_id) { + H5G_info_t info; + herr_t status = H5Gget_info(loc_id, &info); + CHECK_GE(status, 0) << "Error while counting HDF5 links."; + return info.nlinks; +} + +string hdf5_get_name_by_idx(hid_t loc_id, int idx) { + ssize_t str_size = H5Lget_name_by_idx( + loc_id, ".", H5_INDEX_NAME, H5_ITER_NATIVE, idx, NULL, 0, H5P_DEFAULT); + CHECK_GE(str_size, 0) << "Error retrieving HDF5 dataset at index " << idx; + char *c_str = new char[str_size+1]; + ssize_t status = H5Lget_name_by_idx( + loc_id, ".", H5_INDEX_NAME, H5_ITER_NATIVE, idx, c_str, str_size+1, + H5P_DEFAULT); + CHECK_GE(status, 0) << "Error retrieving HDF5 dataset at index " << idx; + string result(c_str); + delete[] c_str; + return result; +} + +} // namespace caffe diff --git a/src/caffe/util/io.cpp b/src/caffe/util/io.cpp index 77ef7f257f4..6f03314202c 100644 --- a/src/caffe/util/io.cpp +++ b/src/caffe/util/io.cpp @@ -228,79 +228,5 @@ void CVMatToDatum(const cv::Mat& cv_img, Datum* datum) { datum->set_data(buffer); } -// Verifies format of data stored in HDF5 file and reshapes blob accordingly. -template -void hdf5_load_nd_dataset_helper( - hid_t file_id, const char* dataset_name_, int min_dim, int max_dim, - Blob* blob) { - // Verify that the dataset exists. - CHECK(H5LTfind_dataset(file_id, dataset_name_)) - << "Failed to find HDF5 dataset " << dataset_name_; - // Verify that the number of dimensions is in the accepted range. - herr_t status; - int ndims; - status = H5LTget_dataset_ndims(file_id, dataset_name_, &ndims); - CHECK_GE(status, 0) << "Failed to get dataset ndims for " << dataset_name_; - CHECK_GE(ndims, min_dim); - CHECK_LE(ndims, max_dim); - - // Verify that the data format is what we expect: float or double. - std::vector dims(ndims); - H5T_class_t class_; - status = H5LTget_dataset_info( - file_id, dataset_name_, dims.data(), &class_, NULL); - CHECK_GE(status, 0) << "Failed to get dataset info for " << dataset_name_; - CHECK_EQ(class_, H5T_FLOAT) << "Expected float or double data"; - - vector blob_dims(dims.size()); - for (int i = 0; i < dims.size(); ++i) { - blob_dims[i] = dims[i]; - } - blob->Reshape(blob_dims); -} - -template <> -void hdf5_load_nd_dataset(hid_t file_id, const char* dataset_name_, - int min_dim, int max_dim, Blob* blob) { - hdf5_load_nd_dataset_helper(file_id, dataset_name_, min_dim, max_dim, blob); - herr_t status = H5LTread_dataset_float( - file_id, dataset_name_, blob->mutable_cpu_data()); - CHECK_GE(status, 0) << "Failed to read float dataset " << dataset_name_; -} - -template <> -void hdf5_load_nd_dataset(hid_t file_id, const char* dataset_name_, - int min_dim, int max_dim, Blob* blob) { - hdf5_load_nd_dataset_helper(file_id, dataset_name_, min_dim, max_dim, blob); - herr_t status = H5LTread_dataset_double( - file_id, dataset_name_, blob->mutable_cpu_data()); - CHECK_GE(status, 0) << "Failed to read double dataset " << dataset_name_; -} - -template <> -void hdf5_save_nd_dataset( - const hid_t file_id, const string& dataset_name, const Blob& blob) { - hsize_t dims[HDF5_NUM_DIMS]; - dims[0] = blob.num(); - dims[1] = blob.channels(); - dims[2] = blob.height(); - dims[3] = blob.width(); - herr_t status = H5LTmake_dataset_float( - file_id, dataset_name.c_str(), HDF5_NUM_DIMS, dims, blob.cpu_data()); - CHECK_GE(status, 0) << "Failed to make float dataset " << dataset_name; -} - -template <> -void hdf5_save_nd_dataset( - const hid_t file_id, const string& dataset_name, const Blob& blob) { - hsize_t dims[HDF5_NUM_DIMS]; - dims[0] = blob.num(); - dims[1] = blob.channels(); - dims[2] = blob.height(); - dims[3] = blob.width(); - herr_t status = H5LTmake_dataset_double( - file_id, dataset_name.c_str(), HDF5_NUM_DIMS, dims, blob.cpu_data()); - CHECK_GE(status, 0) << "Failed to make double dataset " << dataset_name; -} } // namespace caffe From 5c89c64ff1cf97a3578b11803f83d73e3e933592 Mon Sep 17 00:00:00 2001 From: Eric Tzeng Date: Wed, 29 Jul 2015 18:40:38 -0700 Subject: [PATCH 115/331] TestSnapshot expects .h5 snapshots, explicitly checks history. --- src/caffe/test/test_gradient_based_solver.cpp | 25 ++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index 94b500124aa..78bf4b3121e 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -139,7 +139,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { if (snapshot) { ostringstream resume_file; resume_file << snapshot_prefix_ << "/_iter_" << num_iters - << ".solverstate"; + << ".solverstate.h5"; string resume_filename = resume_file.str(); return resume_filename; } @@ -394,6 +394,18 @@ class GradientBasedSolverTest : public MultiDeviceTest { } } + // Save the solver history + vector > > history_copies; + const vector > >& orig_history = solver_->history(); + history_copies.resize(orig_history.size()); + for (int i = 0; i < orig_history.size(); ++i) { + history_copies[i].reset(new Blob()); + const bool kReshape = true; + for (int copy_diff = false; copy_diff <= true; ++copy_diff) { + history_copies[i]->CopyFrom(*orig_history[i], copy_diff, kReshape); + } + } + // Run the solver for num_iters iterations and snapshot. snapshot = true; string snapshot_name = RunLeastSquaresSolver(learning_rate, weight_decay, @@ -414,6 +426,17 @@ class GradientBasedSolverTest : public MultiDeviceTest { << "param " << i << " diff differed at dim " << j; } } + + // Check that history now matches. + const vector > >& history = solver_->history(); + for (int i = 0; i < history.size(); ++i) { + for (int j = 0; j < history[i]->count(); ++j) { + EXPECT_EQ(history_copies[i]->cpu_data()[j], history[i]->cpu_data()[j]) + << "history blob " << i << " data differed at dim " << j; + EXPECT_EQ(history_copies[i]->cpu_diff()[j], history[i]->cpu_diff()[j]) + << "history blob " << i << " diff differed at dim " << j; + } + } } }; From c9b333e06212365e3ea166bacbd4b560158316f0 Mon Sep 17 00:00:00 2001 From: Eric Tzeng Date: Fri, 7 Aug 2015 13:17:26 -0700 Subject: [PATCH 116/331] Update example bash scripts to expect .h5, new extensions in .gitignore --- .gitignore | 2 ++ examples/cifar10/train_full.sh | 4 ++-- examples/cifar10/train_quick.sh | 2 +- examples/imagenet/resume_training.sh | 2 +- 4 files changed, 6 insertions(+), 4 deletions(-) diff --git a/.gitignore b/.gitignore index 28f2aca854b..53c1fb056bb 100644 --- a/.gitignore +++ b/.gitignore @@ -61,7 +61,9 @@ Makefile.config data/* models/* *.caffemodel +*.caffemodel.h5 *.solverstate +*.solverstate.h5 *.binaryproto *leveldb *lmdb diff --git a/examples/cifar10/train_full.sh b/examples/cifar10/train_full.sh index 4285a5d6468..ef112e1f6db 100755 --- a/examples/cifar10/train_full.sh +++ b/examples/cifar10/train_full.sh @@ -8,9 +8,9 @@ $TOOLS/caffe train \ # reduce learning rate by factor of 10 $TOOLS/caffe train \ --solver=examples/cifar10/cifar10_full_solver_lr1.prototxt \ - --snapshot=examples/cifar10/cifar10_full_iter_60000.solverstate + --snapshot=examples/cifar10/cifar10_full_iter_60000.solverstate.h5 # reduce learning rate by factor of 10 $TOOLS/caffe train \ --solver=examples/cifar10/cifar10_full_solver_lr2.prototxt \ - --snapshot=examples/cifar10/cifar10_full_iter_65000.solverstate + --snapshot=examples/cifar10/cifar10_full_iter_65000.solverstate.h5 diff --git a/examples/cifar10/train_quick.sh b/examples/cifar10/train_quick.sh index 2830c40945c..6b7d228879b 100755 --- a/examples/cifar10/train_quick.sh +++ b/examples/cifar10/train_quick.sh @@ -8,4 +8,4 @@ $TOOLS/caffe train \ # reduce learning rate by factor of 10 after 8 epochs $TOOLS/caffe train \ --solver=examples/cifar10/cifar10_quick_solver_lr1.prototxt \ - --snapshot=examples/cifar10/cifar10_quick_iter_4000.solverstate + --snapshot=examples/cifar10/cifar10_quick_iter_4000.solverstate.h5 diff --git a/examples/imagenet/resume_training.sh b/examples/imagenet/resume_training.sh index d1febff8d39..bf7945c0fd0 100755 --- a/examples/imagenet/resume_training.sh +++ b/examples/imagenet/resume_training.sh @@ -2,4 +2,4 @@ ./build/tools/caffe train \ --solver=models/bvlc_reference_caffenet/solver.prototxt \ - --snapshot=models/bvlc_reference_caffenet/caffenet_train_10000.solverstate + --snapshot=models/bvlc_reference_caffenet/caffenet_train_10000.solverstate.h5 From f81ed077cbfd96b3a9ec98898347eb5d2966ccea Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Fri, 7 Aug 2015 15:27:02 -0700 Subject: [PATCH 117/331] TestGradientBasedSolver: restore Gaussian filler to all tests except accumulation one --- src/caffe/test/test_gradient_based_solver.cpp | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index 78bf4b3121e..235a7d85ad0 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -24,12 +24,14 @@ class GradientBasedSolverTest : public MultiDeviceTest { protected: GradientBasedSolverTest() : - seed_(1701), num_(4), channels_(3), height_(10), width_(10) {} + seed_(1701), num_(4), channels_(3), height_(10), width_(10), + constant_data_(false) {} string snapshot_prefix_; shared_ptr > solver_; int seed_; int num_, channels_, height_, width_; + bool constant_data_; Dtype delta_; // Stability constant for AdaGrad. virtual SolverParameter_SolverType solver_type() = 0; @@ -79,7 +81,9 @@ class GradientBasedSolverTest : public MultiDeviceTest { " height: 1 " " width: 1 " " data_filler { " - " type: 'constant' " + " type: '" << string(constant_data_ ? "constant" : "gaussian") + << "' " + " std: 1.0 " " value: 1.0 " " } " " data_filler { " @@ -302,6 +306,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { const Dtype kMomentum, const int kNumIters, const int kIterSize) { const double kPrecision = 1e-2; const double kMinPrecision = 1e-7; + constant_data_ = true; // Solve without accumulation and save parameters. this->RunLeastSquaresSolver(kLearningRate, kWeightDecay, kMomentum, kNumIters); From c251b2581b02904ea6b5501786d4514734aef3d6 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Fri, 7 Aug 2015 15:34:00 -0700 Subject: [PATCH 118/331] TestGradientBasedSolver: make tests across solver types more consistent --- src/caffe/test/test_gradient_based_solver.cpp | 91 ++++++++++++------- 1 file changed, 59 insertions(+), 32 deletions(-) diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index 235a7d85ad0..54606dbd7ed 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -466,23 +466,38 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdate) { this->TestLeastSquaresUpdate(); } -TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateLROneTenth) { +TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateLROneHundredth) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 0.1; + const Dtype kLearningRate = 0.01; this->TestLeastSquaresUpdate(kLearningRate); } TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithWeightDecay) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay); + const Dtype kMomentum = 0; + const int kNumIters = 1; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + +TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithWeightDecayMultiIter) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0; + const int kNumIters = 4; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } } TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentum) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; - const Dtype kWeightDecay = 0.0; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; const int kNumIters = 1; for (int i = 0; i <= kNumIters; ++i) { @@ -492,8 +507,8 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentum) { TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; - const Dtype kWeightDecay = 0.0; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { @@ -504,8 +519,8 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverything) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; - const Dtype kWeightDecay = 0.1; - const Dtype kMomentum = 0.9; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.5; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); @@ -515,7 +530,7 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverything) { TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; - const Dtype kWeightDecay = 0.1; + const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; const int kNumIters = 4; const int kIterSize = 2; @@ -526,7 +541,7 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { TYPED_TEST(SGDSolverTest, TestSnapshot) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; - const Dtype kWeightDecay = 0.1; + const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; const int kNumIters = 4; for (int i = 1; i <= kNumIters; ++i) { @@ -554,15 +569,15 @@ TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdate) { this->TestLeastSquaresUpdate(); } -TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateLROneTenth) { +TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateLROneHundredth) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 0.1; + const Dtype kLearningRate = 0.01; this->TestLeastSquaresUpdate(kLearningRate); } TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithWeightDecay) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay); } @@ -570,8 +585,8 @@ TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithWeightDecay) { TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithEverything) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; - const Dtype kWeightDecay = 0.1; - const Dtype kMomentum = 0.0; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); @@ -581,8 +596,8 @@ TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithEverything) { TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; - const Dtype kWeightDecay = 0.1; - const Dtype kMomentum = 0.0; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0; const int kNumIters = 4; const int kIterSize = 2; this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, @@ -592,8 +607,8 @@ TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { TYPED_TEST(AdaGradSolverTest, TestSnapshot) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; - const Dtype kWeightDecay = 0.1; - const Dtype kMomentum = 0.0; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0; const int kNumIters = 4; for (int i = 1; i <= kNumIters; ++i) { this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); @@ -620,23 +635,35 @@ TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdate) { this->TestLeastSquaresUpdate(); } -TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateLROneTenth) { +TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateLROneHundredth) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 0.1; + const Dtype kLearningRate = 0.01; this->TestLeastSquaresUpdate(kLearningRate); } TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithWeightDecay) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay); } +TYPED_TEST(NesterovSolverTest, + TestNesterovLeastSquaresUpdateWithWeightDecayMultiIter) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0; + const int kNumIters = 4; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithMomentum) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; - const Dtype kWeightDecay = 0.0; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; const int kNumIters = 1; for (int i = 0; i <= kNumIters; ++i) { @@ -646,8 +673,8 @@ TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithMomentum) { TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; - const Dtype kWeightDecay = 0.0; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { @@ -658,7 +685,7 @@ TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithEverything) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; - const Dtype kWeightDecay = 0.1; + const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { @@ -669,7 +696,7 @@ TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithEverything) { TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; - const Dtype kWeightDecay = 0.1; + const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; const int kNumIters = 4; const int kIterSize = 2; @@ -680,8 +707,8 @@ TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { TYPED_TEST(NesterovSolverTest, TestSnapshot) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; - const Dtype kWeightDecay = 0.1; - const Dtype kMomentum = 0.0; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; const int kNumIters = 4; for (int i = 1; i <= kNumIters; ++i) { this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); From d5b42bf7d6fa0ed85069745c56104503b7888b63 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Mon, 20 Jul 2015 20:50:50 -0700 Subject: [PATCH 119/331] Net: add learnable_params_ used by solvers to correctly handle shared params -Params now share diffs as well as data (works due to layers accumulating gradients into param diffs, rather than overwriting) -It's now required that any shared params with specified lr_mult's, decay_mult's match -TestGradientBasedSolver checks that behavior remains correct with shared weights --- include/caffe/net.hpp | 41 +++- src/caffe/net.cpp | 89 +++++---- src/caffe/solver.cpp | 44 ++--- src/caffe/test/test_gradient_based_solver.cpp | 177 +++++++++++++++++- src/caffe/test/test_net.cpp | 29 ++- 5 files changed, 276 insertions(+), 104 deletions(-) diff --git a/include/caffe/net.hpp b/include/caffe/net.hpp index dfd2e556a2b..bf997553ee2 100644 --- a/include/caffe/net.hpp +++ b/include/caffe/net.hpp @@ -57,6 +57,12 @@ class Net { */ string Forward(const string& input_blob_protos, Dtype* loss = NULL); + /** + * @brief Zeroes out the diffs of all net parameters. + * Should be run before Backward. + */ + void ClearParamDiffs(); + /** * The network backward should take no input and output, since it solely * computes the gradient w.r.t the parameters, and the data has already been @@ -84,6 +90,13 @@ class Net { /// @brief Updates the network weights based on the diff values computed. void Update(); + /** + * @brief Shares weight data of owner blobs with shared blobs. + * + * Note: this is called by Net::Init, and thus should normally not be + * called manually. + */ + void ShareWeights(); /** * @brief For an already initialized net, implicitly copies (i.e., using no @@ -148,11 +161,19 @@ class Net { inline const vector > >& params() const { return params_; } - /// @brief returns the parameter learning rate multipliers + inline const vector*>& learnable_params() const { + return learnable_params_; + } + /// @brief returns the learnable parameter learning rate multipliers inline const vector& params_lr() const { return params_lr_; } + inline const vector& has_params_lr() const { return has_params_lr_; } + /// @brief returns the learnable parameter decay multipliers inline const vector& params_weight_decay() const { return params_weight_decay_; } + inline const vector& has_params_decay() const { + return has_params_decay_; + } const map& param_names_index() const { return param_names_index_; } @@ -213,9 +234,6 @@ class Net { /// @brief Helper for displaying debug info in Update. void UpdateDebugInfo(const int param_id); - /// @brief Get misc parameters, e.g. the LR multiplier and weight decay. - void GetLearningRateAndWeightDecay(); - /// @brief The network name string name_; /// @brief The phase: TRAIN or TEST @@ -254,10 +272,21 @@ class Net { vector*> net_output_blobs_; /// The parameters in the network. vector > > params_; - /// the learning rate multipliers + vector*> learnable_params_; + /** + * The mapping from params_ -> learnable_params_: we have + * learnable_param_ids_.size() == params_.size(), + * and learnable_params_[learnable_param_ids_[i]] == params_[i].get() + * if and only if params_[i] is an "owner"; otherwise, params_[i] is a sharer + * and learnable_params_[learnable_param_ids_[i]] gives its owner. + */ + vector learnable_param_ids_; + /// the learning rate multipliers for learnable_params_ vector params_lr_; - /// the weight decay multipliers + vector has_params_lr_; + /// the weight decay multipliers for learnable_params_ vector params_weight_decay_; + vector has_params_decay_; /// The bytes of memory used by this net size_t memory_used_; /// Whether to compute and display debug info for the net. diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index 0812b367ac3..0e5ed804b73 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -244,7 +244,7 @@ void Net::Init(const NetParameter& in_param) { for (size_t layer_id = 0; layer_id < layer_names_.size(); ++layer_id) { layer_names_index_[layer_names_[layer_id]] = layer_id; } - GetLearningRateAndWeightDecay(); + ShareWeights(); debug_info_ = param.debug_info(); LOG(INFO) << "Network initialization done."; LOG(INFO) << "Memory required for data: " << memory_used_ * sizeof(Dtype); @@ -441,6 +441,9 @@ void Net::AppendParam(const NetParameter& param, const int layer_id, params_.push_back(layers_[layer_id]->blobs()[param_id]); param_id_vecs_[layer_id].push_back(net_param_id); param_layer_indices_.push_back(make_pair(layer_id, param_id)); + ParamSpec default_param_spec; + const ParamSpec* param_spec = (layer_param.param_size() > param_id) ? + &layer_param.param(param_id) : &default_param_spec; if (!param_size || !param_name.size() || (param_name.size() && param_names_index_.find(param_name) == param_names_index_.end())) { // This layer "owns" this parameter blob -- it is either anonymous @@ -450,6 +453,13 @@ void Net::AppendParam(const NetParameter& param, const int layer_id, if (param_name.size()) { param_names_index_[param_name] = net_param_id; } + const int learnable_param_id = learnable_params_.size(); + learnable_params_.push_back(params_[net_param_id].get()); + learnable_param_ids_.push_back(learnable_param_id); + has_params_lr_.push_back(param_spec->has_lr_mult()); + has_params_decay_.push_back(param_spec->has_decay_mult()); + params_lr_.push_back(param_spec->lr_mult()); + params_weight_decay_.push_back(param_spec->decay_mult()); } else { // Named param blob with name we've seen before: share params const int owner_net_param_id = param_names_index_[param_name]; @@ -474,23 +484,25 @@ void Net::AppendParam(const NetParameter& param, const int layer_id, // Strict dimension checking -- all dims must be the same. CHECK(this_blob->shape() == owner_blob->shape()); } - layers_[layer_id]->blobs()[param_id]->ShareData( - *layers_[owner_layer_id]->blobs()[owner_param_id]); - } -} - -template -void Net::GetLearningRateAndWeightDecay() { - LOG(INFO) << "Collecting Learning Rate and Weight Decay."; - ParamSpec default_param_spec; - for (int i = 0; i < layers_.size(); ++i) { - vector > >& layer_blobs = layers_[i]->blobs(); - for (int j = 0; j < layer_blobs.size(); ++j) { - const ParamSpec* param_spec = - (layers_[i]->layer_param().param_size() > j) ? - &layers_[i]->layer_param().param(j) : &default_param_spec; - params_lr_.push_back(param_spec->lr_mult()); - params_weight_decay_.push_back(param_spec->decay_mult()); + const int learnable_param_id = learnable_param_ids_[owner_net_param_id]; + if (param_spec->has_lr_mult()) { + if (has_params_lr_[learnable_param_id]) { + CHECK_EQ(param_spec->lr_mult(), params_lr_[learnable_param_id]) + << "Shared param '" << param_name << "' has mismatched lr_mult."; + } else { + has_params_lr_[learnable_param_id] = true; + params_lr_[learnable_param_id] = param_spec->lr_mult(); + } + } + if (param_spec->has_decay_mult()) { + if (has_params_decay_[learnable_param_id]) { + CHECK_EQ(param_spec->decay_mult(), + params_weight_decay_[learnable_param_id]) + << "Shared param '" << param_name << "' has mismatched decay_mult."; + } else { + has_params_decay_[learnable_param_id] = true; + params_weight_decay_[learnable_param_id] = param_spec->decay_mult(); + } } } } @@ -895,39 +907,38 @@ void Net::ToHDF5(const string& filename, bool write_diff) const { template void Net::Update() { - // First, accumulate the diffs of any shared parameters into their owner's - // diff. (Assumes that the learning rate, weight decay, etc. have already been - // accounted for in the current diff.) - for (int i = 0; i < params_.size(); ++i) { - if (param_owners_[i] < 0) { continue; } - if (debug_info_) { UpdateDebugInfo(i); } - const int count = params_[i]->count(); - const Dtype* this_diff; - Dtype* owner_diff; + for (int i = 0; i < learnable_params_.size(); ++i) { + learnable_params_[i]->Update(); + } +} + +template +void Net::ClearParamDiffs() { + for (int i = 0; i < learnable_params_.size(); ++i) { + Blob* blob = learnable_params_[i]; switch (Caffe::mode()) { case Caffe::CPU: - this_diff = params_[i]->cpu_diff(); - owner_diff = params_[param_owners_[i]]->mutable_cpu_diff(); - caffe_add(count, this_diff, owner_diff, owner_diff); + caffe_set(blob->count(), static_cast(0), + blob->mutable_cpu_diff()); break; case Caffe::GPU: #ifndef CPU_ONLY - this_diff = params_[i]->gpu_diff(); - owner_diff = params_[param_owners_[i]]->mutable_gpu_diff(); - caffe_gpu_add(count, this_diff, owner_diff, owner_diff); + caffe_gpu_set(blob->count(), static_cast(0), + blob->mutable_gpu_diff()); #else NO_GPU; #endif break; - default: - LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode(); } } - // Now, update the owned parameters. +} + +template +void Net::ShareWeights() { for (int i = 0; i < params_.size(); ++i) { - if (param_owners_[i] >= 0) { continue; } - if (debug_info_) { UpdateDebugInfo(i); } - params_[i]->Update(); + if (param_owners_[i] < 0) { continue; } + params_[i]->ShareData(*params_[param_owners_[i]]); + params_[i]->ShareDiff(*params_[param_owners_[i]]); } } diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 75271138bdd..32276ac148a 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -173,24 +173,7 @@ void Solver::Step(int iters) { while (iter_ < stop_iter) { // zero-init the params - for (int i = 0; i < net_->params().size(); ++i) { - shared_ptr > blob = net_->params()[i]; - switch (Caffe::mode()) { - case Caffe::CPU: - caffe_set(blob->count(), static_cast(0), - blob->mutable_cpu_diff()); - break; - case Caffe::GPU: -#ifndef CPU_ONLY - caffe_gpu_set(blob->count(), static_cast(0), - blob->mutable_gpu_diff()); -#else - NO_GPU; -#endif - break; - } - } - + net_->ClearParamDiffs(); if (param_.test_interval() && iter_ % param_.test_interval() == 0 && (iter_ > 0 || param_.test_initialization())) { TestAll(); @@ -462,7 +445,7 @@ Dtype SGDSolver::GetLearningRate() { template void SGDSolver::PreSolve() { // Initialize the history - const vector > >& net_params = this->net_->params(); + const vector*>& net_params = this->net_->learnable_params(); history_.clear(); update_.clear(); temp_.clear(); @@ -478,12 +461,10 @@ template void SGDSolver::ClipGradients() { const Dtype clip_gradients = this->param_.clip_gradients(); if (clip_gradients < 0) { return; } - const vector > >& net_params = this->net_->params(); + const vector*>& net_params = this->net_->learnable_params(); Dtype sumsq_diff = 0; for (int i = 0; i < net_params.size(); ++i) { - if (this->net_->param_owners()[i] < 0) { - sumsq_diff += net_params[i]->sumsq_diff(); - } + sumsq_diff += net_params[i]->sumsq_diff(); } const Dtype l2norm_diff = std::sqrt(sumsq_diff); if (l2norm_diff > clip_gradients) { @@ -492,9 +473,7 @@ void SGDSolver::ClipGradients() { << l2norm_diff << " > " << clip_gradients << ") " << "by scale factor " << scale_factor; for (int i = 0; i < net_params.size(); ++i) { - if (this->net_->param_owners()[i] < 0) { - net_params[i]->scale_diff(scale_factor); - } + net_params[i]->scale_diff(scale_factor); } } } @@ -506,7 +485,8 @@ void SGDSolver::ApplyUpdate() { LOG(INFO) << "Iteration " << this->iter_ << ", lr = " << rate; } ClipGradients(); - for (int param_id = 0; param_id < this->net_->params().size(); ++param_id) { + for (int param_id = 0; param_id < this->net_->learnable_params().size(); + ++param_id) { Normalize(param_id); Regularize(param_id); ComputeUpdateValue(param_id, rate); @@ -518,7 +498,7 @@ template void SGDSolver::Normalize(int param_id) { if (this->param_.iter_size() == 1) { return; } // Scale gradient to counterbalance accumulation. - const vector > >& net_params = this->net_->params(); + const vector*>& net_params = this->net_->learnable_params(); const Dtype accum_normalization = Dtype(1.) / this->param_.iter_size(); switch (Caffe::mode()) { case Caffe::CPU: { @@ -542,7 +522,7 @@ void SGDSolver::Normalize(int param_id) { template void SGDSolver::Regularize(int param_id) { - const vector > >& net_params = this->net_->params(); + const vector*>& net_params = this->net_->learnable_params(); const vector& net_params_weight_decay = this->net_->params_weight_decay(); Dtype weight_decay = this->param_.weight_decay(); @@ -604,7 +584,7 @@ void SGDSolver::Regularize(int param_id) { template void SGDSolver::ComputeUpdateValue(int param_id, Dtype rate) { - const vector > >& net_params = this->net_->params(); + const vector*>& net_params = this->net_->learnable_params(); const vector& net_params_lr = this->net_->params_lr(); Dtype momentum = this->param_.momentum(); Dtype local_rate = rate * net_params_lr[param_id]; @@ -743,7 +723,7 @@ void SGDSolver::RestoreSolverStateFromHDF5(const string& state_file) { template void NesterovSolver::ComputeUpdateValue(int param_id, Dtype rate) { - const vector > >& net_params = this->net_->params(); + const vector*>& net_params = this->net_->learnable_params(); const vector& net_params_lr = this->net_->params_lr(); Dtype momentum = this->param_.momentum(); Dtype local_rate = rate * net_params_lr[param_id]; @@ -803,7 +783,7 @@ void NesterovSolver::ComputeUpdateValue(int param_id, Dtype rate) { template void AdaGradSolver::ComputeUpdateValue(int param_id, Dtype rate) { - const vector > >& net_params = this->net_->params(); + const vector*>& net_params = this->net_->learnable_params(); const vector& net_params_lr = this->net_->params_lr(); Dtype delta = this->param_.delta(); Dtype local_rate = rate * net_params_lr[param_id]; diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index 54606dbd7ed..e1bbbf17726 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -25,13 +25,13 @@ class GradientBasedSolverTest : public MultiDeviceTest { protected: GradientBasedSolverTest() : seed_(1701), num_(4), channels_(3), height_(10), width_(10), - constant_data_(false) {} + constant_data_(false), share_(false) {} string snapshot_prefix_; shared_ptr > solver_; int seed_; int num_, channels_, height_, width_; - bool constant_data_; + bool constant_data_, share_; Dtype delta_; // Stability constant for AdaGrad. virtual SolverParameter_SolverType solver_type() = 0; @@ -93,10 +93,26 @@ class GradientBasedSolverTest : public MultiDeviceTest { " } " " top: 'data' " " top: 'targets' " - " } " + " } "; + if (share_) { + proto << + " layer { " + " name: 'slice' " + " type: 'Slice' " + " bottom: 'data' " + " top: 'data1' " + " top: 'data2' " + " slice_param { " + " axis: 0 " + " } " + " } "; + } + proto << " layer { " " name: 'innerprod' " " type: 'InnerProduct' " + " param { name: 'weights' } " + " param { name: 'bias' } " " inner_product_param { " " num_output: 1 " " weight_filler { " @@ -108,9 +124,42 @@ class GradientBasedSolverTest : public MultiDeviceTest { " std: 1.0 " " } " " } " - " bottom: 'data' " - " top: 'innerprod' " - " } " + " bottom: '" << string(share_ ? "data1": "data") << "' " + " top: '" << string(share_ ? "innerprod1": "innerprod") << "' " + " } "; + if (share_) { + proto << + " layer { " + " name: 'innerprod2' " + " type: 'InnerProduct' " + " param { name: 'weights' } " + " param { name: 'bias' } " + " inner_product_param { " + " num_output: 1 " + " weight_filler { " + " type: 'gaussian' " + " std: 1.0 " + " } " + " bias_filler { " + " type: 'gaussian' " + " std: 1.0 " + " } " + " } " + " bottom: 'data2' " + " top: 'innerprod2' " + " } " + " layer { " + " name: 'concat' " + " type: 'Concat' " + " bottom: 'innerprod1' " + " bottom: 'innerprod2' " + " top: 'innerprod' " + " concat_param { " + " axis: 0 " + " } " + " } "; + } + proto << " layer { " " name: 'loss' " " type: 'EuclideanLoss' " @@ -388,8 +437,8 @@ class GradientBasedSolverTest : public MultiDeviceTest { // Save the resulting param values. vector > > param_copies; - const vector > >& orig_params = - solver_->net()->params(); + const vector*>& orig_params = + solver_->net()->learnable_params(); param_copies.resize(orig_params.size()); for (int i = 0; i < orig_params.size(); ++i) { param_copies[i].reset(new Blob()); @@ -422,7 +471,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { momentum, total_num_iters, kIterSize, snapshot, snapshot_name.c_str()); // Check that params now match. - const vector > >& params = solver_->net()->params(); + const vector*>& params = solver_->net()->learnable_params(); for (int i = 0; i < params.size(); ++i) { for (int j = 0; j < params[i]->count(); ++j) { EXPECT_EQ(param_copies[i]->cpu_data()[j], params[i]->cpu_data()[j]) @@ -527,6 +576,18 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverything) { } } +TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.5; + const int kNumIters = 4; + this->share_ = true; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; @@ -538,6 +599,18 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { kIterSize); } +TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + const int kIterSize = 2; + this->share_ = true; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); +} + TYPED_TEST(SGDSolverTest, TestSnapshot) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; @@ -549,6 +622,18 @@ TYPED_TEST(SGDSolverTest, TestSnapshot) { } } +TYPED_TEST(SGDSolverTest, TestSnapshotShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + this->share_ = true; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + } +} + template class AdaGradSolverTest : public GradientBasedSolverTest { @@ -593,6 +678,19 @@ TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithEverything) { } } +TYPED_TEST(AdaGradSolverTest, + TestAdaGradLeastSquaresUpdateWithEverythingShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0; + const int kNumIters = 4; + this->share_ = true; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; @@ -604,6 +702,18 @@ TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { kIterSize); } +TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0; + const int kNumIters = 4; + const int kIterSize = 2; + this->share_ = true; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); +} + TYPED_TEST(AdaGradSolverTest, TestSnapshot) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; @@ -615,6 +725,18 @@ TYPED_TEST(AdaGradSolverTest, TestSnapshot) { } } +TYPED_TEST(AdaGradSolverTest, TestSnapshotShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0; + const int kNumIters = 4; + this->share_ = true; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + } +} + template class NesterovSolverTest : public GradientBasedSolverTest { @@ -693,6 +815,19 @@ TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithEverything) { } } +TYPED_TEST(NesterovSolverTest, + TestNesterovLeastSquaresUpdateWithEverythingShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + this->share_ = true; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; @@ -704,6 +839,18 @@ TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { kIterSize); } +TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + const int kIterSize = 2; + this->share_ = true; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); +} + TYPED_TEST(NesterovSolverTest, TestSnapshot) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; @@ -715,4 +862,16 @@ TYPED_TEST(NesterovSolverTest, TestSnapshot) { } } +TYPED_TEST(NesterovSolverTest, TestSnapshotShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + this->share_ = true; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + } +} + } // namespace caffe diff --git a/src/caffe/test/test_net.cpp b/src/caffe/test/test_net.cpp index 56959f4793b..12998d8912f 100644 --- a/src/caffe/test/test_net.cpp +++ b/src/caffe/test/test_net.cpp @@ -1107,11 +1107,10 @@ TYPED_TEST(NetTest, TestSharedWeightsUpdate) { EXPECT_EQ(this->net_->layer_names()[2], "innerproduct2"); Blob* ip1_weights = this->net_->layers()[1]->blobs()[0].get(); Blob* ip2_weights = this->net_->layers()[2]->blobs()[0].get(); - // Check that data blobs of shared weights share the same location in memory. + // Check that data and diff blobs of shared weights share the same memory + // locations. EXPECT_EQ(ip1_weights->cpu_data(), ip2_weights->cpu_data()); - // Check that diff blobs of shared weights are at different locations in - // memory. (The diffs should be accumulated at update time.) - EXPECT_NE(ip1_weights->cpu_diff(), ip2_weights->cpu_diff()); + EXPECT_EQ(ip1_weights->cpu_diff(), ip2_weights->cpu_diff()); this->net_->Forward(bottom); this->net_->Backward(); // Compute the expected update as the data minus the two diffs. @@ -1124,11 +1123,7 @@ TYPED_TEST(NetTest, TestSharedWeightsUpdate) { // Make sure the diffs are non-trivial. for (int i = 0; i < count; ++i) { EXPECT_NE(0, ip1_weights->cpu_diff()[i]); - EXPECT_NE(0, ip2_weights->cpu_diff()[i]); - EXPECT_NE(ip1_weights->cpu_diff()[i], ip2_weights->cpu_diff()[i]); } - caffe_axpy(count, Dtype(1), ip2_weights->cpu_diff(), - shared_params.mutable_cpu_diff()); caffe_axpy(count, Dtype(-1), shared_params.cpu_diff(), shared_params.mutable_cpu_data()); const Dtype* expected_updated_params = shared_params.cpu_data(); @@ -1165,8 +1160,8 @@ TYPED_TEST(NetTest, TestSharedWeightsUpdate) { EXPECT_NE(0, ip1_weights->cpu_diff()[i]); EXPECT_NE(0, ip2_weights->cpu_diff()[i]); EXPECT_NE(ip1_weights->cpu_diff()[i], ip2_weights->cpu_diff()[i]); - EXPECT_EQ(ip1_weights->cpu_diff()[i] + ip2_weights->cpu_diff()[i], - shared_params.cpu_diff()[i]); + EXPECT_FLOAT_EQ(ip1_weights->cpu_diff()[i] + ip2_weights->cpu_diff()[i], + shared_params.cpu_diff()[i]); } caffe_axpy(count, Dtype(-1), ip1_weights->cpu_diff(), unshared_params1.mutable_cpu_data()); @@ -1196,11 +1191,10 @@ TYPED_TEST(NetTest, TestSharedWeightsResume) { EXPECT_EQ(this->net_->layer_names()[2], "innerproduct2"); Blob* ip1_weights = this->net_->layers()[1]->blobs()[0].get(); Blob* ip2_weights = this->net_->layers()[2]->blobs()[0].get(); - // Check that data blobs of shared weights share the same location in memory. + // Check that data and diff blobs of shared weights share the same memory + // locations. EXPECT_EQ(ip1_weights->cpu_data(), ip2_weights->cpu_data()); - // Check that diff blobs of shared weights are at different locations in - // memory. (The diffs should be accumulated at update time.) - EXPECT_NE(ip1_weights->cpu_diff(), ip2_weights->cpu_diff()); + EXPECT_EQ(ip1_weights->cpu_diff(), ip2_weights->cpu_diff()); this->net_->ForwardBackward(bottom); this->net_->Update(); Blob shared_params; @@ -1223,14 +1217,13 @@ TYPED_TEST(NetTest, TestSharedWeightsResume) { ASSERT_FALSE(NULL == ip1_weights); ASSERT_FALSE(NULL == ip2_weights); EXPECT_NE(ip1_weights, ip2_weights); - // Check that data blobs of shared weights share the same location in memory. + // Check that data and diff blobs of shared weights share the same memory + // locations. EXPECT_EQ(ip1_weights->cpu_data(), ip2_weights->cpu_data()); + EXPECT_EQ(ip1_weights->cpu_diff(), ip2_weights->cpu_diff()); for (int i = 0; i < count; ++i) { EXPECT_FLOAT_EQ(shared_params.cpu_data()[i], ip1_weights->cpu_data()[i]); } - // Check that diff blobs of shared weights are at different locations in - // memory. (The diffs should be accumulated at update time.) - EXPECT_NE(ip1_weights->cpu_diff(), ip2_weights->cpu_diff()); } TYPED_TEST(NetTest, TestParamPropagateDown) { From 4227828ad43b78ad0c2ab4ab276dd0991ecb2ccb Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Fri, 7 Aug 2015 20:03:04 -0700 Subject: [PATCH 120/331] temporarily switch the snapshot_format default back to BINARYPROTO out of anticipation for user issues due to issue #2885, which causes Caffe to crash when it attempts to snapshot nets with duplicate layer names --- src/caffe/proto/caffe.proto | 2 +- src/caffe/test/test_gradient_based_solver.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 96e975be566..a13c0e79d80 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -179,7 +179,7 @@ message SolverParameter { HDF5 = 0; BINARYPROTO = 1; } - optional SnapshotFormat snapshot_format = 37 [default = HDF5]; + optional SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; // the mode solver will use: 0 for CPU and 1 for GPU. Use GPU in default. enum SolverMode { CPU = 0; diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index e1bbbf17726..7bb0ec18a09 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -192,7 +192,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { if (snapshot) { ostringstream resume_file; resume_file << snapshot_prefix_ << "/_iter_" << num_iters - << ".solverstate.h5"; + << ".solverstate"; string resume_filename = resume_file.str(); return resume_filename; } From 443b16f84fb8948dbddecaf775c7da44dac6c6b1 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Wed, 21 Jan 2015 22:21:13 -0800 Subject: [PATCH 121/331] Add gpu_util.cuh, with caffe_gpu_atomic_add (double impl from NVIDIA dev docs; float impl included in CUDA as "atomicAdd") --- include/caffe/util/gpu_util.cuh | 35 +++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 include/caffe/util/gpu_util.cuh diff --git a/include/caffe/util/gpu_util.cuh b/include/caffe/util/gpu_util.cuh new file mode 100644 index 00000000000..994202f2a1a --- /dev/null +++ b/include/caffe/util/gpu_util.cuh @@ -0,0 +1,35 @@ +#ifndef CAFFE_UTIL_GPU_UTIL_H_ +#define CAFFE_UTIL_GPU_UTIL_H_ + +namespace caffe { + +template +inline __device__ Dtype caffe_gpu_atomic_add(const Dtype val, Dtype* address); + +template <> +inline __device__ +float caffe_gpu_atomic_add(const float val, float* address) { + return atomicAdd(address, val); +} + +// double atomicAdd implementation taken from: +// http://docs.nvidia.com/cuda/cuda-c-programming-guide/#axzz3PVCpVsEG +template <> +inline __device__ +double caffe_gpu_atomic_add(const double val, double* address) { + unsigned long long int* address_as_ull = // NOLINT(runtime/int) + // NOLINT_NEXT_LINE(runtime/int) + reinterpret_cast(address); + unsigned long long int old = *address_as_ull; // NOLINT(runtime/int) + unsigned long long int assumed; // NOLINT(runtime/int) + do { + assumed = old; + old = atomicCAS(address_as_ull, assumed, + __double_as_longlong(val + __longlong_as_double(assumed))); + } while (assumed != old); + return __longlong_as_double(old); +} + +} // namespace caffe + +#endif // CAFFE_UTIL_GPU_UTIL_H_ From 6067869f8339344ecd68c486a6e47d07e8997b6f Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Wed, 21 Jan 2015 14:23:34 -0800 Subject: [PATCH 122/331] test_gradient_check_util: check_bottom < -1 only checks params --- include/caffe/test/test_gradient_check_util.hpp | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/include/caffe/test/test_gradient_check_util.hpp b/include/caffe/test/test_gradient_check_util.hpp index cc5dcbad0ee..25f35d1589e 100644 --- a/include/caffe/test/test_gradient_check_util.hpp +++ b/include/caffe/test/test_gradient_check_util.hpp @@ -45,6 +45,10 @@ class GradientChecker { void CheckGradientEltwise(Layer* layer, const vector*>& bottom, const vector*>& top); + // Checks the gradient of a single output with respect to particular input + // blob(s). If check_bottom = i >= 0, check only the ith bottom Blob. + // If check_bottom == -1, check everything -- all bottom Blobs and all + // param Blobs. Otherwise (if check_bottom < -1), check only param Blobs. void CheckGradientSingle(Layer* layer, const vector*>& bottom, const vector*>& top, int check_bottom, int top_id, int top_data_id, bool element_wise = false); @@ -83,21 +87,22 @@ void GradientChecker::CheckGradientSingle(Layer* layer, // First, figure out what blobs we need to check against, and zero init // parameter blobs. vector*> blobs_to_check; - vector propagate_down(bottom.size(), check_bottom < 0); + vector propagate_down(bottom.size(), check_bottom == -1); for (int i = 0; i < layer->blobs().size(); ++i) { Blob* blob = layer->blobs()[i].get(); caffe_set(blob->count(), static_cast(0), blob->mutable_cpu_diff()); blobs_to_check.push_back(blob); } - if (check_bottom < 0) { + if (check_bottom == -1) { for (int i = 0; i < bottom.size(); ++i) { blobs_to_check.push_back(bottom[i]); } - } else { + } else if (check_bottom >= 0) { CHECK_LT(check_bottom, bottom.size()); blobs_to_check.push_back(bottom[check_bottom]); propagate_down[check_bottom] = true; } + CHECK_GT(blobs_to_check.size(), 0) << "No blobs to check."; // Compute the gradient analytically using Backward Caffe::set_random_seed(seed_); // Ignore the loss from the layer (it's just the weighted sum of the losses From 4d299c3071039e7c49c01b2435e11549f764df88 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Sun, 15 Feb 2015 16:00:04 -0800 Subject: [PATCH 123/331] Add EmbedLayer for inner products with sparse input (one-hot vectors), with unit tests --- include/caffe/common_layers.hpp | 38 ++++++ src/caffe/layers/embed_layer.cpp | 122 +++++++++++++++++++ src/caffe/layers/embed_layer.cu | 80 ++++++++++++ src/caffe/proto/caffe.proto | 18 ++- src/caffe/test/test_embed_layer.cpp | 183 ++++++++++++++++++++++++++++ 5 files changed, 440 insertions(+), 1 deletion(-) create mode 100644 src/caffe/layers/embed_layer.cpp create mode 100644 src/caffe/layers/embed_layer.cu create mode 100644 src/caffe/test/test_embed_layer.cpp diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index d2c0ce6d0c6..691e755f88f 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -180,6 +180,44 @@ class EltwiseLayer : public Layer { bool stable_prod_grad_; }; +/** + * @brief A layer for learning "embeddings" of one-hot vector input. + * Equivalent to an InnerProductLayer with one-hot vectors as input, but + * for efficiency the input is the "hot" index of each column itself. + * + * TODO(dox): thorough documentation for Forward, Backward, and proto params. + */ +template +class EmbedLayer : public Layer { + public: + explicit EmbedLayer(const LayerParameter& param) + : Layer(param) {} + virtual void LayerSetUp(const vector*>& bottom, + const vector*>& top); + virtual void Reshape(const vector*>& bottom, + const vector*>& top); + + virtual inline const char* type() const { return "Embed"; } + virtual inline int ExactNumBottomBlobs() const { return 1; } + virtual inline int ExactNumTopBlobs() const { return 1; } + + protected: + virtual void Forward_cpu(const vector*>& bottom, + const vector*>& top); + virtual void Forward_gpu(const vector*>& bottom, + const vector*>& top); + virtual void Backward_cpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + virtual void Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + + int M_; + int K_; + int N_; + bool bias_term_; + Blob bias_multiplier_; +}; + /** * @brief Takes two+ Blobs, interprets last Blob as a selector and * filter remaining Blobs accordingly with selector data (0 means that diff --git a/src/caffe/layers/embed_layer.cpp b/src/caffe/layers/embed_layer.cpp new file mode 100644 index 00000000000..be6b2cd2727 --- /dev/null +++ b/src/caffe/layers/embed_layer.cpp @@ -0,0 +1,122 @@ +#include + +#include "caffe/blob.hpp" +#include "caffe/common.hpp" +#include "caffe/common_layers.hpp" +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/math_functions.hpp" + +namespace caffe { + +template +void EmbedLayer::LayerSetUp(const vector*>& bottom, + const vector*>& top) { + N_ = this->layer_param_.embed_param().num_output(); + CHECK_GT(N_, 0) << "EmbedLayer num_output must be positive."; + K_ = this->layer_param_.embed_param().input_dim(); + CHECK_GT(K_, 0) << "EmbedLayer input_dim must be positive."; + bias_term_ = this->layer_param_.embed_param().bias_term(); + // Check if we need to set up the weights + if (this->blobs_.size() > 0) { + LOG(INFO) << "Skipping parameter initialization"; + } else { + if (bias_term_) { + this->blobs_.resize(2); + } else { + this->blobs_.resize(1); + } + // Initialize the weights -- + // transposed from InnerProductLayer for spatial locality. + vector weight_shape(2); + weight_shape[0] = K_; + weight_shape[1] = N_; + this->blobs_[0].reset(new Blob(weight_shape)); + // fill the weights + shared_ptr > weight_filler(GetFiller( + this->layer_param_.embed_param().weight_filler())); + weight_filler->Fill(this->blobs_[0].get()); + // If necessary, initialize and fill the bias term + if (bias_term_) { + vector bias_shape(1, N_); + this->blobs_[1].reset(new Blob(bias_shape)); + shared_ptr > bias_filler(GetFiller( + this->layer_param_.embed_param().bias_filler())); + bias_filler->Fill(this->blobs_[1].get()); + } + } // parameter initialization + this->param_propagate_down_.resize(this->blobs_.size(), true); +} + +template +void EmbedLayer::Reshape(const vector*>& bottom, + const vector*>& top) { + // Figure out the dimensions + M_ = bottom[0]->count(); + vector top_shape = bottom[0]->shape(); + top_shape.push_back(N_); + top[0]->Reshape(top_shape); + // Set up the bias multiplier + if (bias_term_) { + vector bias_shape(1, M_); + bias_multiplier_.Reshape(bias_shape); + caffe_set(M_, Dtype(1), bias_multiplier_.mutable_cpu_data()); + } +} + +template +void EmbedLayer::Forward_cpu(const vector*>& bottom, + const vector*>& top) { + const Dtype* bottom_data = bottom[0]->cpu_data(); + const Dtype* weight = this->blobs_[0]->cpu_data(); + Dtype* top_data = top[0]->mutable_cpu_data(); + int index; + for (int n = 0; n < M_; ++n) { + index = static_cast(bottom_data[n]); + DCHECK_GE(index, 0); + DCHECK_LT(index, K_); + DCHECK_EQ(static_cast(index), bottom_data[n]) << "non-integer input"; + caffe_copy(N_, weight + index * N_, top_data + n * N_); + } + if (bias_term_) { + const Dtype* bias = this->blobs_[1]->cpu_data(); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, M_, N_, 1, Dtype(1), + bias_multiplier_.cpu_data(), bias, Dtype(1), top_data); + } +} + +template +void EmbedLayer::Backward_cpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + CHECK(!propagate_down[0]) << "Can't backpropagate to EmbedLayer input."; + if (this->param_propagate_down_[0]) { + const Dtype* top_diff = top[0]->cpu_diff(); + const Dtype* bottom_data = bottom[0]->cpu_data(); + // Gradient with respect to weight + Dtype* weight_diff = this->blobs_[0]->mutable_cpu_diff(); + int index; + for (int n = 0; n < M_; ++n) { + index = static_cast(bottom_data[n]); + DCHECK_GE(index, 0); + DCHECK_LT(index, K_); + DCHECK_EQ(static_cast(index), bottom_data[n]) + << "non-integer input"; + caffe_axpy(N_, Dtype(1), top_diff + n * N_, weight_diff + index * N_); + } + } + if (bias_term_ && this->param_propagate_down_[1]) { + const Dtype* top_diff = top[0]->cpu_diff(); + Dtype* bias_diff = this->blobs_[1]->mutable_cpu_diff(); + caffe_cpu_gemv(CblasTrans, M_, N_, Dtype(1), top_diff, + bias_multiplier_.cpu_data(), Dtype(1), bias_diff); + } +} + +#ifdef CPU_ONLY +STUB_GPU(EmbedLayer); +#endif + +INSTANTIATE_CLASS(EmbedLayer); +REGISTER_LAYER_CLASS(Embed); + +} // namespace caffe diff --git a/src/caffe/layers/embed_layer.cu b/src/caffe/layers/embed_layer.cu new file mode 100644 index 00000000000..37a4f7e35cd --- /dev/null +++ b/src/caffe/layers/embed_layer.cu @@ -0,0 +1,80 @@ +#include + +#include "caffe/blob.hpp" +#include "caffe/common.hpp" +#include "caffe/common_layers.hpp" +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/math_functions.hpp" + +namespace caffe { + +template +__global__ void EmbedForward(const int nthreads, const Dtype* bottom_data, + const Dtype* weight, const int M, const int N, const int K, + Dtype* top_data) { + CUDA_KERNEL_LOOP(top_index, nthreads) { + const int n = top_index / N; + const int d = top_index % N; + const int index = static_cast(bottom_data[n]); + const int weight_index = index * N + d; + top_data[top_index] = weight[weight_index]; + } +} + +template +__global__ void EmbedBackward(const int nthreads, const Dtype* bottom_data, + const Dtype* top_diff, const int M, const int N, const int K, + Dtype* weight_diff) { + CUDA_KERNEL_LOOP(weight_index, nthreads) { + const int index = weight_index / N; + const int output_index = weight_index % N; + for (int n = 0; n < M; ++n) { + if (static_cast(bottom_data[n]) == index) { + weight_diff[weight_index] += top_diff[n * N + output_index]; + } + } + } +} + +template +void EmbedLayer::Forward_gpu(const vector*>& bottom, + const vector*>& top) { + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* top_data = top[0]->mutable_gpu_data(); + const Dtype* weight = this->blobs_[0]->gpu_data(); + const int count = top[0]->count(); + EmbedForward // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + count, bottom_data, weight, M_, N_, K_, top_data); + if (bias_term_) { + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, M_, N_, 1, Dtype(1), + bias_multiplier_.gpu_data(), + this->blobs_[1]->gpu_data(), Dtype(1), top_data); + } +} + +template +void EmbedLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + CHECK(!propagate_down[0]) << "Can't backpropagate to EmbedLayer input."; + if (this->param_propagate_down_[0]) { + const int count = this->blobs_[0]->count(); + const Dtype* top_diff = top[0]->gpu_diff(); + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* weight_diff = this->blobs_[0]->mutable_gpu_diff(); + EmbedBackward // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + count, bottom_data, top_diff, M_, N_, K_, weight_diff); + } + if (bias_term_ && this->param_propagate_down_[1]) { + const Dtype* top_diff = top[0]->gpu_diff(); + Dtype* bias_diff = this->blobs_[1]->mutable_gpu_diff(); + caffe_gpu_gemv(CblasTrans, M_, N_, Dtype(1), top_diff, + bias_multiplier_.gpu_data(), Dtype(1), bias_diff); + } +} + +INSTANTIATE_LAYER_GPU_FUNCS(EmbedLayer); + +} // namespace caffe diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index a13c0e79d80..705cceb098b 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -276,7 +276,7 @@ message ParamSpec { // NOTE // Update the next available ID when you add a new LayerParameter field. // -// LayerParameter next available layer-specific ID: 137 (last added: reduction_param) +// LayerParameter next available layer-specific ID: 138 (last added: embed_param) message LayerParameter { optional string name = 1; // the layer name optional string type = 2; // the layer type @@ -332,6 +332,7 @@ message LayerParameter { optional DropoutParameter dropout_param = 108; optional DummyDataParameter dummy_data_param = 109; optional EltwiseParameter eltwise_param = 110; + optional EmbedParameter embed_param = 137; optional ExpParameter exp_param = 111; optional FlattenParameter flatten_param = 135; optional HDF5DataParameter hdf5_data_param = 112; @@ -533,6 +534,21 @@ message EltwiseParameter { optional bool stable_prod_grad = 3 [default = true]; } +// Message that stores parameters used by EmbedLayer +message EmbedParameter { + optional uint32 num_output = 1; // The number of outputs for the layer + // The input is given as integers to be interpreted as one-hot + // vector indices with dimension num_input. Hence num_input should be + // 1 greater than the maximum possible input value. + optional uint32 input_dim = 2; + + optional bool bias_term = 3 [default = true]; // Whether to use a bias term + optional FillerParameter weight_filler = 4; // The filler for the weight + optional FillerParameter bias_filler = 5; // The filler for the bias + +} + +// Message that stores parameters used by ExpLayer message ExpParameter { // ExpLayer computes outputs y = base ^ (shift + scale * x), for base > 0. // Or if base is set to the default (-1), base is set to e, diff --git a/src/caffe/test/test_embed_layer.cpp b/src/caffe/test/test_embed_layer.cpp new file mode 100644 index 00000000000..7a4fb9800f2 --- /dev/null +++ b/src/caffe/test/test_embed_layer.cpp @@ -0,0 +1,183 @@ +#include +#include + +#include "gtest/gtest.h" + +#include "caffe/blob.hpp" +#include "caffe/common.hpp" +#include "caffe/filler.hpp" +#include "caffe/vision_layers.hpp" + +#include "caffe/test/test_caffe_main.hpp" +#include "caffe/test/test_gradient_check_util.hpp" + +namespace caffe { + +#ifndef CPU_ONLY +extern cudaDeviceProp CAFFE_TEST_CUDA_PROP; +#endif + +template +class EmbedLayerTest : public MultiDeviceTest { + typedef typename TypeParam::Dtype Dtype; + protected: + EmbedLayerTest() + : blob_bottom_(new Blob(4, 1, 1, 1)), + blob_top_(new Blob()) { + // fill the values + FillerParameter filler_param; + UniformFiller filler(filler_param); + filler.Fill(this->blob_bottom_); + blob_bottom_vec_.push_back(blob_bottom_); + blob_top_vec_.push_back(blob_top_); + } + virtual ~EmbedLayerTest() { delete blob_bottom_; delete blob_top_; } + Blob* const blob_bottom_; + Blob* const blob_top_; + vector*> blob_bottom_vec_; + vector*> blob_top_vec_; +}; + +TYPED_TEST_CASE(EmbedLayerTest, TestDtypesAndDevices); + +TYPED_TEST(EmbedLayerTest, TestSetUp) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + EmbedParameter* embed_param = layer_param.mutable_embed_param(); + embed_param->set_num_output(10); + embed_param->set_input_dim(5); + shared_ptr > layer(new EmbedLayer(layer_param)); + layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(this->blob_top_->num_axes(), 5); + EXPECT_EQ(this->blob_top_->shape(0), 4); + EXPECT_EQ(this->blob_top_->shape(1), 1); + EXPECT_EQ(this->blob_top_->shape(2), 1); + EXPECT_EQ(this->blob_top_->shape(3), 1); + EXPECT_EQ(this->blob_top_->shape(4), 10); +} + +TYPED_TEST(EmbedLayerTest, TestForward) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + EmbedParameter* embed_param = layer_param.mutable_embed_param(); + const int kNumOutput = 10; + const int kInputDim = 5; + embed_param->set_num_output(kNumOutput); + embed_param->set_input_dim(kInputDim); + embed_param->mutable_weight_filler()->set_type("uniform"); + embed_param->mutable_weight_filler()->set_min(-10); + embed_param->mutable_weight_filler()->set_max(10); + embed_param->set_bias_term(false); + shared_ptr > layer(new EmbedLayer(layer_param)); + layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(1, layer->blobs().size()); + vector weight_shape(2); + weight_shape[0] = kInputDim; + weight_shape[1] = kNumOutput; + ASSERT_TRUE(weight_shape == layer->blobs()[0]->shape()); + for (int i = 0; i < this->blob_bottom_->count(); ++i) { + this->blob_bottom_->mutable_cpu_data()[i] = caffe_rng_rand() % kInputDim; + } + layer->Forward(this->blob_bottom_vec_, this->blob_top_vec_); + vector weight_offset(2, 0); + vector top_offset(5, 0); + for (int i = 0; i < this->blob_bottom_->count(); ++i) { + weight_offset[0] = static_cast(this->blob_bottom_->cpu_data()[i]); + weight_offset[1] = 0; + top_offset[0] = i; + top_offset[4] = 0; + for (int j = 0; j < kNumOutput; ++j) { + EXPECT_EQ(layer->blobs()[0]->data_at(weight_offset), + this->blob_top_->data_at(top_offset)); + ++top_offset[4]; + ++weight_offset[1]; + } + } +} + +TYPED_TEST(EmbedLayerTest, TestForwardWithBias) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + EmbedParameter* embed_param = layer_param.mutable_embed_param(); + const int kNumOutput = 10; + const int kInputDim = 5; + embed_param->set_num_output(kNumOutput); + embed_param->set_input_dim(kInputDim); + embed_param->mutable_weight_filler()->set_type("uniform"); + embed_param->mutable_weight_filler()->set_min(-10); + embed_param->mutable_weight_filler()->set_max(10); + embed_param->mutable_bias_filler()->CopyFrom(embed_param->weight_filler()); + embed_param->set_bias_term(true); + shared_ptr > layer(new EmbedLayer(layer_param)); + layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(2, layer->blobs().size()); + vector weight_shape(2); + weight_shape[0] = kInputDim; + weight_shape[1] = kNumOutput; + ASSERT_TRUE(weight_shape == layer->blobs()[0]->shape()); + for (int i = 0; i < this->blob_bottom_->count(); ++i) { + this->blob_bottom_->mutable_cpu_data()[i] = caffe_rng_rand() % kInputDim; + } + layer->Forward(this->blob_bottom_vec_, this->blob_top_vec_); + vector bias_offset(1, 0); + vector weight_offset(2, 0); + vector top_offset(5, 0); + for (int i = 0; i < this->blob_bottom_->count(); ++i) { + weight_offset[0] = static_cast(this->blob_bottom_->cpu_data()[i]); + weight_offset[1] = 0; + top_offset[0] = i; + top_offset[4] = 0; + bias_offset[0] = 0; + for (int j = 0; j < kNumOutput; ++j) { + EXPECT_EQ(layer->blobs()[0]->data_at(weight_offset) + + layer->blobs()[1]->data_at(bias_offset), + this->blob_top_->data_at(top_offset)); + ++top_offset[4]; + ++weight_offset[1]; + ++bias_offset[0]; + } + } +} + +TYPED_TEST(EmbedLayerTest, TestGradient) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + EmbedParameter* embed_param = layer_param.mutable_embed_param(); + embed_param->set_num_output(10); + embed_param->set_input_dim(5); + embed_param->set_bias_term(false); + embed_param->mutable_weight_filler()->set_type("uniform"); + embed_param->mutable_weight_filler()->set_min(-10); + embed_param->mutable_weight_filler()->set_max(10); + EmbedLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-3); + this->blob_bottom_->mutable_cpu_data()[0] = 4; + this->blob_bottom_->mutable_cpu_data()[1] = 2; + this->blob_bottom_->mutable_cpu_data()[2] = 2; + this->blob_bottom_->mutable_cpu_data()[3] = 3; + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_, -2); +} + +TYPED_TEST(EmbedLayerTest, TestGradientWithBias) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + EmbedParameter* embed_param = layer_param.mutable_embed_param(); + embed_param->set_num_output(10); + embed_param->set_input_dim(5); + embed_param->set_bias_term(true); + embed_param->mutable_weight_filler()->set_type("uniform"); + embed_param->mutable_weight_filler()->set_min(-10); + embed_param->mutable_weight_filler()->set_max(10); + embed_param->mutable_bias_filler()->CopyFrom(embed_param->weight_filler()); + EmbedLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-3); + this->blob_bottom_->mutable_cpu_data()[0] = 4; + this->blob_bottom_->mutable_cpu_data()[1] = 2; + this->blob_bottom_->mutable_cpu_data()[2] = 2; + this->blob_bottom_->mutable_cpu_data()[3] = 3; + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_, -2); +} + +} // namespace caffe From ac9e29fd7b90a665a956f460715669bf05445a13 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Wed, 21 Jan 2015 16:12:12 -0800 Subject: [PATCH 124/331] EmbedBackward with no loops -- use caffe_gpu_atomic_add instead --- src/caffe/layers/embed_layer.cu | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/src/caffe/layers/embed_layer.cu b/src/caffe/layers/embed_layer.cu index 37a4f7e35cd..672fb9c608c 100644 --- a/src/caffe/layers/embed_layer.cu +++ b/src/caffe/layers/embed_layer.cu @@ -5,6 +5,7 @@ #include "caffe/common_layers.hpp" #include "caffe/filler.hpp" #include "caffe/layer.hpp" +#include "caffe/util/gpu_util.cuh" #include "caffe/util/math_functions.hpp" namespace caffe { @@ -22,18 +23,21 @@ __global__ void EmbedForward(const int nthreads, const Dtype* bottom_data, } } +template +__global__ void EmbedBackward(const int nthreads, const Dtype* bottom_data, + const Dtype* top_diff, const int M, const int N, const int K, + Dtype* weight_diff); + template __global__ void EmbedBackward(const int nthreads, const Dtype* bottom_data, const Dtype* top_diff, const int M, const int N, const int K, Dtype* weight_diff) { - CUDA_KERNEL_LOOP(weight_index, nthreads) { - const int index = weight_index / N; - const int output_index = weight_index % N; - for (int n = 0; n < M; ++n) { - if (static_cast(bottom_data[n]) == index) { - weight_diff[weight_index] += top_diff[n * N + output_index]; - } - } + CUDA_KERNEL_LOOP(top_index, nthreads) { + const int n = top_index / N; + const int d = top_index % N; + const int index = static_cast(bottom_data[n]); + const int weight_index = index * N + d; + caffe_gpu_atomic_add(top_diff[top_index], weight_diff + weight_index); } } @@ -59,13 +63,14 @@ void EmbedLayer::Backward_gpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { CHECK(!propagate_down[0]) << "Can't backpropagate to EmbedLayer input."; if (this->param_propagate_down_[0]) { + const int top_count = top[0]->count(); const int count = this->blobs_[0]->count(); const Dtype* top_diff = top[0]->gpu_diff(); const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* weight_diff = this->blobs_[0]->mutable_gpu_diff(); EmbedBackward // NOLINT_NEXT_LINE(whitespace/operators) - <<>>( - count, bottom_data, top_diff, M_, N_, K_, weight_diff); + <<>>( + top_count, bottom_data, top_diff, M_, N_, K_, weight_diff); } if (bias_term_ && this->param_propagate_down_[1]) { const Dtype* top_diff = top[0]->gpu_diff(); From 2c356a4ed4c33f662288166dfa74dd5d71d6c194 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Sat, 8 Aug 2015 12:57:45 -0700 Subject: [PATCH 125/331] TestGradientBasedSolver: drop doubled seed inititialization --- src/caffe/test/test_gradient_based_solver.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index 7bb0ec18a09..30b041fa6b5 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -180,7 +180,6 @@ class GradientBasedSolverTest : public MultiDeviceTest { } Caffe::set_random_seed(this->seed_); this->InitSolverFromProtoString(proto.str()); - Caffe::set_random_seed(this->seed_); if (from_snapshot != NULL) { this->solver_->Restore(from_snapshot); vector*> empty_bottom_vec; From 6019246930f54b108decc100f9cb801e4aea81a4 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Sat, 8 Aug 2015 13:07:13 -0700 Subject: [PATCH 126/331] TestGradientBasedSolver: replace dummy data with hdf5 Rely on fixed hdf5 data for determinism of solver tests. - draw random Gaussian data and targets for test and save to hdf5 - use the same data for all tests without constant / gaussian condition previously needed for accumulation - avoid test artifacts due to order of random draws in dummy data --- .../test/test_data/generate_sample_data.py | 28 ++++++++++++- src/caffe/test/test_data/solver_data.h5 | Bin 0 -> 11776 bytes src/caffe/test/test_data/solver_data_list.txt | 1 + src/caffe/test/test_gradient_based_solver.cpp | 39 ++++++++---------- 4 files changed, 45 insertions(+), 23 deletions(-) create mode 100644 src/caffe/test/test_data/solver_data.h5 create mode 100644 src/caffe/test/test_data/solver_data_list.txt diff --git a/src/caffe/test/test_data/generate_sample_data.py b/src/caffe/test/test_data/generate_sample_data.py index ab5572685cb..3703b41823b 100644 --- a/src/caffe/test/test_data/generate_sample_data.py +++ b/src/caffe/test/test_data/generate_sample_data.py @@ -1,5 +1,5 @@ """ -Generate data used in the HDF5DataLayer test. +Generate data used in the HDF5DataLayer and GradientBasedSolver tests. """ import os import numpy as np @@ -7,6 +7,8 @@ script_dir = os.path.dirname(os.path.abspath(__file__)) +# Generate HDF5DataLayer sample_data.h5 + num_cols = 8 num_rows = 10 height = 6 @@ -51,3 +53,27 @@ with open(script_dir + '/sample_data_list.txt', 'w') as f: f.write(script_dir + '/sample_data.h5\n') f.write(script_dir + '/sample_data_2_gzip.h5\n') + +# Generate GradientBasedSolver solver_data.h5 + +num_cols = 3 +num_rows = 8 +height = 10 +width = 10 + +data = np.random.randn(num_rows, num_cols, height, width) +data = data.reshape(num_rows, num_cols, height, width) +data = data.astype('float32') + +targets = np.random.randn(num_rows, 1) +targets = targets.astype('float32') + +print data +print targets + +with h5py.File(script_dir + '/solver_data.h5', 'w') as f: + f['data'] = data + f['targets'] = targets + +with open(script_dir + '/solver_data_list.txt', 'w') as f: + f.write(script_dir + '/solver_data.h5\n') diff --git a/src/caffe/test/test_data/solver_data.h5 b/src/caffe/test/test_data/solver_data.h5 new file mode 100644 index 0000000000000000000000000000000000000000..7ee05ea7aac988bee3e769434dbb66eb668d65bc GIT binary patch literal 11776 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 literal 0 HcmV?d00001 diff --git a/src/caffe/test/test_data/solver_data_list.txt b/src/caffe/test/test_data/solver_data_list.txt new file mode 100644 index 00000000000..a6552f50073 --- /dev/null +++ b/src/caffe/test/test_data/solver_data_list.txt @@ -0,0 +1 @@ +src/caffe/test/test_data/solver_data.h5 diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index 30b041fa6b5..a8b211b7d43 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -25,15 +25,26 @@ class GradientBasedSolverTest : public MultiDeviceTest { protected: GradientBasedSolverTest() : seed_(1701), num_(4), channels_(3), height_(10), width_(10), - constant_data_(false), share_(false) {} + share_(false) { + input_file_ = new string( + CMAKE_SOURCE_DIR "caffe/test/test_data/solver_data_list.txt" CMAKE_EXT); + } + ~GradientBasedSolverTest() { + delete input_file_; + } string snapshot_prefix_; shared_ptr > solver_; int seed_; + // Dimensions are determined by generate_sample_data.py + // TODO this is brittle and the hdf5 file should be checked instead. int num_, channels_, height_, width_; - bool constant_data_, share_; + bool share_; Dtype delta_; // Stability constant for AdaGrad. + // Test data: check out generate_sample_data.py in the same directory. + string* input_file_; + virtual SolverParameter_SolverType solver_type() = 0; virtual void InitSolver(const SolverParameter& param) = 0; @@ -71,25 +82,10 @@ class GradientBasedSolverTest : public MultiDeviceTest { " name: 'TestNetwork' " " layer { " " name: 'data' " - " type: 'DummyData' " - " dummy_data_param { " - " num: " << num_ / iter_size << " " - " channels: " << channels_ << " " - " height: " << height_ << " " - " width: " << width_ << " " - " channels: 1 " - " height: 1 " - " width: 1 " - " data_filler { " - " type: '" << string(constant_data_ ? "constant" : "gaussian") - << "' " - " std: 1.0 " - " value: 1.0 " - " } " - " data_filler { " - " type: 'gaussian' " - " std: 1.0 " - " } " + " type: 'HDF5Data' " + " hdf5_data_param { " + " source: '" << *(this->input_file_) << "' " + " batch_size: " << num_ / iter_size << " " " } " " top: 'data' " " top: 'targets' " @@ -354,7 +350,6 @@ class GradientBasedSolverTest : public MultiDeviceTest { const Dtype kMomentum, const int kNumIters, const int kIterSize) { const double kPrecision = 1e-2; const double kMinPrecision = 1e-7; - constant_data_ = true; // Solve without accumulation and save parameters. this->RunLeastSquaresSolver(kLearningRate, kWeightDecay, kMomentum, kNumIters); From abe99e8748ad7f583c87d1a6132ff2d79e70dd9c Mon Sep 17 00:00:00 2001 From: Eren Golge Date: Sat, 8 Aug 2015 23:45:08 -0700 Subject: [PATCH 127/331] Implement RMSProp Solver Implement RMSProp solver and cleaned up to adjust to new solver interface that uses accumulated gradients and refactored regularization. --- examples/mnist/lenet_solver_rmsprop.prototxt | 27 ++ examples/mnist/train_lenet_rmsprop.sh | 3 + include/caffe/solver.hpp | 25 ++ src/caffe/proto/caffe.proto | 25 +- src/caffe/solver.cpp | 76 ++++++ src/caffe/test/test_gradient_based_solver.cpp | 245 ++++++++++++++---- 6 files changed, 353 insertions(+), 48 deletions(-) create mode 100644 examples/mnist/lenet_solver_rmsprop.prototxt create mode 100755 examples/mnist/train_lenet_rmsprop.sh diff --git a/examples/mnist/lenet_solver_rmsprop.prototxt b/examples/mnist/lenet_solver_rmsprop.prototxt new file mode 100644 index 00000000000..74dadc51069 --- /dev/null +++ b/examples/mnist/lenet_solver_rmsprop.prototxt @@ -0,0 +1,27 @@ +# The train/test net protocol buffer definition +net: "examples/mnist/lenet_train_test.prototxt" +# test_iter specifies how many forward passes the test should carry out. +# In the case of MNIST, we have test batch size 100 and 100 test iterations, +# covering the full 10,000 testing images. +test_iter: 100 +# Carry out testing every 500 training iterations. +test_interval: 500 +# The base learning rate, momentum and the weight decay of the network. +base_lr: 0.01 +momentum: 0.0 +weight_decay: 0.0005 +# The learning rate policy +lr_policy: "inv" +gamma: 0.0001 +power: 0.75 +# Display every 100 iterations +display: 100 +# The maximum number of iterations +max_iter: 10000 +# snapshot intermediate results +snapshot: 5000 +snapshot_prefix: "examples/mnist/lenet_rmsprop" +# solver mode: CPU or GPU +solver_mode: GPU +solver_type: RMSPROP +rms_decay: 0.98 diff --git a/examples/mnist/train_lenet_rmsprop.sh b/examples/mnist/train_lenet_rmsprop.sh new file mode 100755 index 00000000000..621cab238bf --- /dev/null +++ b/examples/mnist/train_lenet_rmsprop.sh @@ -0,0 +1,3 @@ +#!/usr/bin/env sh + +./build/tools/caffe train --solver=examples/mnist/lenet_solver_rmsprop.prototxt diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index 703434b5fcf..fbade9389ff 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -135,6 +135,29 @@ class AdaGradSolver : public SGDSolver { DISABLE_COPY_AND_ASSIGN(AdaGradSolver); }; + +template +class RMSPropSolver : public SGDSolver { + public: + explicit RMSPropSolver(const SolverParameter& param) + : SGDSolver(param) { constructor_sanity_check(); } + explicit RMSPropSolver(const string& param_file) + : SGDSolver(param_file) { constructor_sanity_check(); } + + protected: + virtual void ComputeUpdateValue(int param_id, Dtype rate); + void constructor_sanity_check() { + CHECK_EQ(0, this->param_.momentum()) + << "Momentum cannot be used with RMSProp."; + CHECK_GE(this->param_.rms_decay(), 0) + << "rms_decay should lie between 0 and 1."; + CHECK_LT(this->param_.rms_decay(), 1) + << "rms_decay should lie between 0 and 1."; + } + + DISABLE_COPY_AND_ASSIGN(RMSPropSolver); +}; + template Solver* GetSolver(const SolverParameter& param) { SolverParameter_SolverType type = param.solver_type(); @@ -146,6 +169,8 @@ Solver* GetSolver(const SolverParameter& param) { return new NesterovSolver(param); case SolverParameter_SolverType_ADAGRAD: return new AdaGradSolver(param); + case SolverParameter_SolverType_RMSPROP: + return new RMSPropSolver(param); default: LOG(FATAL) << "Unknown SolverType: " << type; } diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index a13c0e79d80..89f14595ba6 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -98,7 +98,7 @@ message NetParameter { // NOTE // Update the next available ID when you add a new SolverParameter field. // -// SolverParameter next available ID: 38 (last added: snapshot_format) +// SolverParameter next available ID: 39 (last added: rms_decay) message SolverParameter { ////////////////////////////////////////////////////////////////////////////// // Specifying the train and test networks @@ -153,7 +153,23 @@ message SolverParameter { optional int32 max_iter = 7; // the maximum number of iterations // accumulate gradients over `iter_size` x `batch_size` instances optional int32 iter_size = 36 [default = 1]; - optional string lr_policy = 8; // The learning rate decay policy. + + // The learning rate decay policy. The currently implemented learning rate + // policies are as follows: + // - fixed: always return base_lr. + // - step: return base_lr * gamma ^ (floor(iter / step)) + // - exp: return base_lr * gamma ^ iter + // - inv: return base_lr * (1 + gamma * iter) ^ (- power) + // - multistep: similar to step but it allows non uniform steps defined by + // stepvalue + // - poly: the effective learning rate follows a polynomial decay, to be + // zero by the max_iter. return base_lr (1 - iter/max_iter) ^ (power) + // - sigmoid: the effective learning rate follows a sigmod decay + // return base_lr ( 1/(1 + exp(-gamma * (iter - stepsize)))) + // + // where base_lr, max_iter, gamma, step, stepvalue and power are defined + // in the solver parameter protocol buffer, and iter is the current iteration. + optional string lr_policy = 8; optional float gamma = 9; // The parameter to compute the learning rate. optional float power = 10; // The parameter to compute the learning rate. optional float momentum = 11; // The momentum value. @@ -198,11 +214,16 @@ message SolverParameter { SGD = 0; NESTEROV = 1; ADAGRAD = 2; + RMSPROP = 3; } optional SolverType solver_type = 30 [default = SGD]; // numerical stability for AdaGrad optional float delta = 31 [default = 1e-8]; + // RMSProp decay value + // MeanSquare(t) = rms_decay*MeanSquare(t-1) + (1-rms_decay)*SquareGradient(t) + optional float rms_decay = 38; + // If true, print information about the state of the net that may help with // debugging learning problems. optional bool debug_info = 23 [default = false]; diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 32276ac148a..43834c0c569 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -859,9 +859,85 @@ void AdaGradSolver::ComputeUpdateValue(int param_id, Dtype rate) { } } +template +void RMSPropSolver::ComputeUpdateValue(int param_id, Dtype rate) { + const vector > >& net_params = this->net_->params(); + const vector& net_params_lr = this->net_->params_lr(); + + // get the learning rate + Dtype delta = this->param_.delta(); + Dtype rms_decay = this->param_.rms_decay(); + Dtype local_rate = rate * net_params_lr[param_id]; + + switch (Caffe::mode()) { + case Caffe::CPU: + // compute square of gradient in update + caffe_powx(net_params[param_id]->count(), + net_params[param_id]->cpu_diff(), Dtype(2), + this->update_[param_id]->mutable_cpu_data()); + + // update history + caffe_cpu_axpby(net_params[param_id] -> count(), + Dtype(1-rms_decay), this->update_[param_id]->cpu_data(), + rms_decay, this->history_[param_id]-> mutable_cpu_data()); + + // prepare update + caffe_powx(net_params[param_id]->count(), + this->history_[param_id]->cpu_data(), Dtype(0.5), + this->update_[param_id]->mutable_cpu_data()); + + caffe_add_scalar(net_params[param_id]->count(), + delta, this->update_[param_id]->mutable_cpu_data()); + + caffe_div(net_params[param_id]->count(), + net_params[param_id]->cpu_diff(), this->update_[param_id]->cpu_data(), + this->update_[param_id]->mutable_cpu_data()); + + // scale and copy + caffe_cpu_axpby(net_params[param_id]->count(), local_rate, + this->update_[param_id]->cpu_data(), Dtype(0), + net_params[param_id]->mutable_cpu_diff()); + break; + case Caffe::GPU: +#ifndef CPU_ONLY + // compute square of gradient in update + caffe_gpu_powx(net_params[param_id]->count(), + net_params[param_id]->gpu_diff(), Dtype(2), + this->update_[param_id]->mutable_gpu_data()); + + // update history + caffe_gpu_axpby(net_params[param_id] -> count(), + Dtype(1-rms_decay), this->update_[param_id]->gpu_data(), + rms_decay, this->history_[param_id]-> mutable_gpu_data()); + + // prepare update + caffe_gpu_powx(net_params[param_id]->count(), + this->history_[param_id]->gpu_data(), Dtype(0.5), + this->update_[param_id]->mutable_gpu_data()); + + caffe_gpu_add_scalar(net_params[param_id]->count(), + delta, this->update_[param_id]->mutable_gpu_data()); + + caffe_gpu_div(net_params[param_id]->count(), + net_params[param_id]->gpu_diff(), this->update_[param_id]->gpu_data(), + this->update_[param_id]->mutable_gpu_data()); + + caffe_gpu_axpby(net_params[param_id]->count(), local_rate, + this->update_[param_id]->gpu_data(), Dtype(0), + net_params[param_id]->mutable_gpu_diff()); +#else + NO_GPU; +#endif + break; + default: + LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode(); + } +} + INSTANTIATE_CLASS(Solver); INSTANTIATE_CLASS(SGDSolver); INSTANTIATE_CLASS(NesterovSolver); INSTANTIATE_CLASS(AdaGradSolver); +INSTANTIATE_CLASS(RMSPropSolver); } // namespace caffe diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index 7bb0ec18a09..b09189228ba 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -52,13 +52,14 @@ class GradientBasedSolverTest : public MultiDeviceTest { LOG(FATAL) << "Unknown Caffe mode: " << Caffe::mode(); } InitSolver(param); - delta_ = (solver_type() == SolverParameter_SolverType_ADAGRAD) ? - param.delta() : 0; + delta_ = (solver_type() == SolverParameter_SolverType_ADAGRAD || + solver_type() == SolverParameter_SolverType_RMSPROP) ? + param.delta() : 0; } string RunLeastSquaresSolver(const Dtype learning_rate, - const Dtype weight_decay, const Dtype momentum, const int num_iters, - const int iter_size = 1, const bool snapshot = false, + const Dtype weight_decay, const Dtype momentum, const Dtype rms_decay, + const int num_iters, const int iter_size = 1, const bool snapshot = false, const char* from_snapshot = NULL) { ostringstream proto; proto << @@ -173,6 +174,9 @@ class GradientBasedSolverTest : public MultiDeviceTest { if (momentum != 0) { proto << "momentum: " << momentum << " "; } + if (rms_decay != 0) { + proto << "rms_decay: " << rms_decay << " "; + } MakeTempDir(&snapshot_prefix_); proto << "snapshot_prefix: '" << snapshot_prefix_ << "/' "; if (snapshot) { @@ -204,7 +208,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { // updated_params will store the updated weight and bias results, // using the blobs' diffs to hold the update values themselves. void ComputeLeastSquaresUpdate(const Dtype learning_rate, - const Dtype weight_decay, const Dtype momentum, + const Dtype weight_decay, const Dtype momentum, const Dtype rms_decay, vector > >* updated_params) { const int N = num_; const int D = channels_ * height_ * width_; @@ -287,6 +291,10 @@ class GradientBasedSolverTest : public MultiDeviceTest { case SolverParameter_SolverType_ADAGRAD: update_value /= std::sqrt(history_value + grad * grad) + delta_; break; + case SolverParameter_SolverType_RMSPROP: + update_value /= std::sqrt(rms_decay*history_value + + grad * grad * (1 - rms_decay)) + delta_; + break; default: LOG(FATAL) << "Unknown solver type: " << solver_type(); } @@ -352,13 +360,14 @@ class GradientBasedSolverTest : public MultiDeviceTest { } void CheckAccumulation(const Dtype kLearningRate, const Dtype kWeightDecay, - const Dtype kMomentum, const int kNumIters, const int kIterSize) { + const Dtype kMomentum, const Dtype rms_decay, const int kNumIters, + const int kIterSize) { const double kPrecision = 1e-2; const double kMinPrecision = 1e-7; constant_data_ = true; // Solve without accumulation and save parameters. this->RunLeastSquaresSolver(kLearningRate, kWeightDecay, kMomentum, - kNumIters); + rms_decay, kNumIters); // Save parameters for comparison. Net& net = *this->solver_->net(); const vector > >& param_blobs = @@ -370,7 +379,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { } // Solve by equivalent accumulation of gradients over divided batches. this->RunLeastSquaresSolver(kLearningRate, kWeightDecay, kMomentum, - kNumIters, kIterSize); + rms_decay, kNumIters, kIterSize); Net& net_accum = *this->solver_->net(); const vector > >& accum_params = net_accum.layer_by_name("innerprod")->blobs(); @@ -408,18 +417,19 @@ class GradientBasedSolverTest : public MultiDeviceTest { // matches the solver's (K+1)th update. void TestLeastSquaresUpdate(const Dtype learning_rate = 1.0, const Dtype weight_decay = 0.0, const Dtype momentum = 0.0, - const int iter_to_check = 0) { + const Dtype rms_decay = 0.0, const int iter_to_check = 0) { // Initialize the solver and run K (= iter_to_check) solver iterations. - RunLeastSquaresSolver(learning_rate, weight_decay, momentum, iter_to_check); + RunLeastSquaresSolver(learning_rate, weight_decay, momentum, rms_decay, + iter_to_check); // Compute the (K+1)th update using the analytic least squares gradient. vector > > updated_params; ComputeLeastSquaresUpdate(learning_rate, weight_decay, momentum, - &updated_params); + rms_decay, &updated_params); // Reinitialize the solver and run K+1 solver iterations. - RunLeastSquaresSolver(learning_rate, weight_decay, momentum, - iter_to_check + 1); + RunLeastSquaresSolver(learning_rate, weight_decay, momentum, rms_decay, + iter_to_check + 1); // Check that the solver's solution matches ours. CheckLeastSquaresUpdate(updated_params); @@ -427,12 +437,12 @@ class GradientBasedSolverTest : public MultiDeviceTest { void TestSnapshot(const Dtype learning_rate = 1.0, const Dtype weight_decay = 0.0, const Dtype momentum = 0.0, - const int num_iters = 1) { + const Dtype rms_decay = 0.0, const int num_iters = 1) { // Run the solver for num_iters * 2 iterations. const int total_num_iters = num_iters * 2; bool snapshot = false; const int kIterSize = 1; - RunLeastSquaresSolver(learning_rate, weight_decay, momentum, + RunLeastSquaresSolver(learning_rate, weight_decay, momentum, rms_decay, total_num_iters, kIterSize, snapshot); // Save the resulting param values. @@ -463,12 +473,12 @@ class GradientBasedSolverTest : public MultiDeviceTest { // Run the solver for num_iters iterations and snapshot. snapshot = true; string snapshot_name = RunLeastSquaresSolver(learning_rate, weight_decay, - momentum, num_iters, kIterSize, snapshot); + momentum, rms_decay, num_iters, kIterSize, snapshot); // Reinitialize the solver and run for num_iters more iterations. snapshot = false; - RunLeastSquaresSolver(learning_rate, weight_decay, - momentum, total_num_iters, kIterSize, snapshot, snapshot_name.c_str()); + RunLeastSquaresSolver(learning_rate, weight_decay, momentum, rms_decay, + total_num_iters, kIterSize, snapshot, snapshot_name.c_str()); // Check that params now match. const vector*>& params = solver_->net()->learnable_params(); @@ -548,9 +558,11 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentum) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; + const Dtype kRMSDecay = 0; const int kNumIters = 1; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); } } @@ -559,9 +571,11 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; + const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); } } @@ -570,9 +584,11 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverything) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.5; + const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); } } @@ -581,10 +597,12 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.5; + const Dtype kRMSDecay = 0; const int kNumIters = 4; this->share_ = true; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); } } @@ -593,10 +611,11 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; + const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, - kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, + kNumIters, kIterSize); } TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { @@ -604,11 +623,12 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; + const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; this->share_ = true; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, - kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, + kNumIters, kIterSize); } TYPED_TEST(SGDSolverTest, TestSnapshot) { @@ -616,9 +636,10 @@ TYPED_TEST(SGDSolverTest, TestSnapshot) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; + const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); } } @@ -627,10 +648,11 @@ TYPED_TEST(SGDSolverTest, TestSnapshotShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; + const Dtype kRMSDecay = 0; const int kNumIters = 4; this->share_ = true; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); } } @@ -672,22 +694,26 @@ TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithEverything) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; + const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); } } TYPED_TEST(AdaGradSolverTest, - TestAdaGradLeastSquaresUpdateWithEverythingShare) { + TestAdaGradLeastSquaresUpdateWithEverythingShare) { typedef typename TypeParam::Dtype Dtype; const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; + const Dtype kRMSDecay = 0; const int kNumIters = 4; this->share_ = true; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); } } @@ -696,10 +722,11 @@ TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; + const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, - kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, + kNumIters, kIterSize); } TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { @@ -707,11 +734,12 @@ TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; + const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; this->share_ = true; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, - kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, + kNumIters, kIterSize); } TYPED_TEST(AdaGradSolverTest, TestSnapshot) { @@ -719,9 +747,10 @@ TYPED_TEST(AdaGradSolverTest, TestSnapshot) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; + const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); } } @@ -730,10 +759,11 @@ TYPED_TEST(AdaGradSolverTest, TestSnapshotShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; + const Dtype kRMSDecay = 0; const int kNumIters = 4; this->share_ = true; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); } } @@ -787,9 +817,11 @@ TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithMomentum) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; + const Dtype kRMSDecay = 0; const int kNumIters = 1; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); } } @@ -798,9 +830,11 @@ TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; + const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); } } @@ -821,10 +855,12 @@ TYPED_TEST(NesterovSolverTest, const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; + const Dtype kRMSDecay = 0; const int kNumIters = 4; this->share_ = true; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); } } @@ -833,10 +869,11 @@ TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; + const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, - kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, + kNumIters, kIterSize); } TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { @@ -844,11 +881,12 @@ TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; + const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; this->share_ = true; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, - kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, + kNumIters, kIterSize); } TYPED_TEST(NesterovSolverTest, TestSnapshot) { @@ -856,9 +894,10 @@ TYPED_TEST(NesterovSolverTest, TestSnapshot) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; + const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); } } @@ -867,10 +906,124 @@ TYPED_TEST(NesterovSolverTest, TestSnapshotShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; + const Dtype kRMSDecay = 0; + const int kNumIters = 4; + this->share_ = true; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); + } +} + +template +class RMSPropSolverTest : public GradientBasedSolverTest { + typedef typename TypeParam::Dtype Dtype; + + protected: + virtual void InitSolver(const SolverParameter& param) { + this->solver_.reset(new RMSPropSolver(param)); + } + virtual SolverParameter_SolverType solver_type() { + return SolverParameter_SolverType_RMSPROP; + } +}; + +TYPED_TEST_CASE(RMSPropSolverTest, TestDtypesAndDevices); + +TYPED_TEST(RMSPropSolverTest, TestRMSPropLeastSquaresUpdateWithWeightDecay) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + const Dtype kWeightDecay = 0.5; + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay); +} + +TYPED_TEST(RMSPropSolverTest, TestRMSPropLeastSquaresUpdateWithRmsDecay) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.0; + const Dtype kMomentum = 0.0; + const Dtype kRMSDecay = 0.95; + const int kNumIters = 4; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); + } +} + +TYPED_TEST(RMSPropSolverTest, TestRMSPropLeastSquaresUpdateWithEverything) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.0; + const Dtype kRMSDecay = 0.95; + const int kNumIters = 4; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); + } +} + +TYPED_TEST(RMSPropSolverTest, + TestRMSPropLeastSquaresUpdateWithEverythingShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.0; + const Dtype kRMSDecay = 0.95; + const int kNumIters = 4; + this->share_ = true; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, + kRMSDecay, i); + } +} + +TYPED_TEST(RMSPropSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.0; + const Dtype kRMSDecay = 0.95; + const int kNumIters = 4; + const int kIterSize = 2; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, + kNumIters, kIterSize); +} + +TYPED_TEST(RMSPropSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.0; + const Dtype kRMSDecay = 0.95; + const int kNumIters = 4; + const int kIterSize = 2; + this->share_ = true; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, + kNumIters, kIterSize); +} + +TYPED_TEST(RMSPropSolverTest, TestSnapshot) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0; + const Dtype kRMSDecay = 0.95; + const int kNumIters = 4; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); + } +} + +TYPED_TEST(RMSPropSolverTest, TestSnapshotShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0; + const Dtype kRMSDecay = 0.95; const int kNumIters = 4; this->share_ = true; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); } } From 4dcbe9287d334a06049bc95af37143fc73f15536 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Sun, 9 Aug 2015 01:32:25 -0700 Subject: [PATCH 128/331] Encapsulate kRMSDecay in solver tests Instead of introducing another argument kRMSDecay and setting it for every test, this param could be set by the RMSProp test class for encapsulation. --- src/caffe/test/test_gradient_based_solver.cpp | 156 +++++++----------- 1 file changed, 58 insertions(+), 98 deletions(-) diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index b09189228ba..e3c6b6d7964 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -58,8 +58,8 @@ class GradientBasedSolverTest : public MultiDeviceTest { } string RunLeastSquaresSolver(const Dtype learning_rate, - const Dtype weight_decay, const Dtype momentum, const Dtype rms_decay, - const int num_iters, const int iter_size = 1, const bool snapshot = false, + const Dtype weight_decay, const Dtype momentum, const int num_iters, + const int iter_size = 1, const bool snapshot = false, const char* from_snapshot = NULL) { ostringstream proto; proto << @@ -174,9 +174,6 @@ class GradientBasedSolverTest : public MultiDeviceTest { if (momentum != 0) { proto << "momentum: " << momentum << " "; } - if (rms_decay != 0) { - proto << "rms_decay: " << rms_decay << " "; - } MakeTempDir(&snapshot_prefix_); proto << "snapshot_prefix: '" << snapshot_prefix_ << "/' "; if (snapshot) { @@ -208,7 +205,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { // updated_params will store the updated weight and bias results, // using the blobs' diffs to hold the update values themselves. void ComputeLeastSquaresUpdate(const Dtype learning_rate, - const Dtype weight_decay, const Dtype momentum, const Dtype rms_decay, + const Dtype weight_decay, const Dtype momentum, vector > >* updated_params) { const int N = num_; const int D = channels_ * height_ * width_; @@ -291,9 +288,11 @@ class GradientBasedSolverTest : public MultiDeviceTest { case SolverParameter_SolverType_ADAGRAD: update_value /= std::sqrt(history_value + grad * grad) + delta_; break; - case SolverParameter_SolverType_RMSPROP: + case SolverParameter_SolverType_RMSPROP: { + const Dtype rms_decay = 0.95; update_value /= std::sqrt(rms_decay*history_value + grad * grad * (1 - rms_decay)) + delta_; + } break; default: LOG(FATAL) << "Unknown solver type: " << solver_type(); @@ -360,14 +359,13 @@ class GradientBasedSolverTest : public MultiDeviceTest { } void CheckAccumulation(const Dtype kLearningRate, const Dtype kWeightDecay, - const Dtype kMomentum, const Dtype rms_decay, const int kNumIters, - const int kIterSize) { + const Dtype kMomentum, const int kNumIters, const int kIterSize) { const double kPrecision = 1e-2; const double kMinPrecision = 1e-7; constant_data_ = true; // Solve without accumulation and save parameters. this->RunLeastSquaresSolver(kLearningRate, kWeightDecay, kMomentum, - rms_decay, kNumIters); + kNumIters); // Save parameters for comparison. Net& net = *this->solver_->net(); const vector > >& param_blobs = @@ -379,7 +377,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { } // Solve by equivalent accumulation of gradients over divided batches. this->RunLeastSquaresSolver(kLearningRate, kWeightDecay, kMomentum, - rms_decay, kNumIters, kIterSize); + kNumIters, kIterSize); Net& net_accum = *this->solver_->net(); const vector > >& accum_params = net_accum.layer_by_name("innerprod")->blobs(); @@ -417,18 +415,17 @@ class GradientBasedSolverTest : public MultiDeviceTest { // matches the solver's (K+1)th update. void TestLeastSquaresUpdate(const Dtype learning_rate = 1.0, const Dtype weight_decay = 0.0, const Dtype momentum = 0.0, - const Dtype rms_decay = 0.0, const int iter_to_check = 0) { + const int iter_to_check = 0) { // Initialize the solver and run K (= iter_to_check) solver iterations. - RunLeastSquaresSolver(learning_rate, weight_decay, momentum, rms_decay, - iter_to_check); + RunLeastSquaresSolver(learning_rate, weight_decay, momentum, iter_to_check); // Compute the (K+1)th update using the analytic least squares gradient. vector > > updated_params; ComputeLeastSquaresUpdate(learning_rate, weight_decay, momentum, - rms_decay, &updated_params); + &updated_params); // Reinitialize the solver and run K+1 solver iterations. - RunLeastSquaresSolver(learning_rate, weight_decay, momentum, rms_decay, + RunLeastSquaresSolver(learning_rate, weight_decay, momentum, iter_to_check + 1); // Check that the solver's solution matches ours. @@ -437,13 +434,13 @@ class GradientBasedSolverTest : public MultiDeviceTest { void TestSnapshot(const Dtype learning_rate = 1.0, const Dtype weight_decay = 0.0, const Dtype momentum = 0.0, - const Dtype rms_decay = 0.0, const int num_iters = 1) { + const int num_iters = 1) { // Run the solver for num_iters * 2 iterations. const int total_num_iters = num_iters * 2; bool snapshot = false; const int kIterSize = 1; - RunLeastSquaresSolver(learning_rate, weight_decay, momentum, rms_decay, - total_num_iters, kIterSize, snapshot); + RunLeastSquaresSolver(learning_rate, weight_decay, momentum, + total_num_iters, kIterSize, snapshot); // Save the resulting param values. vector > > param_copies; @@ -473,11 +470,11 @@ class GradientBasedSolverTest : public MultiDeviceTest { // Run the solver for num_iters iterations and snapshot. snapshot = true; string snapshot_name = RunLeastSquaresSolver(learning_rate, weight_decay, - momentum, rms_decay, num_iters, kIterSize, snapshot); + momentum, num_iters, kIterSize, snapshot); // Reinitialize the solver and run for num_iters more iterations. snapshot = false; - RunLeastSquaresSolver(learning_rate, weight_decay, momentum, rms_decay, + RunLeastSquaresSolver(learning_rate, weight_decay, momentum, total_num_iters, kIterSize, snapshot, snapshot_name.c_str()); // Check that params now match. @@ -558,11 +555,9 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentum) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; - const Dtype kRMSDecay = 0; const int kNumIters = 1; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -571,11 +566,9 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; - const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -584,11 +577,9 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverything) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.5; - const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -597,12 +588,10 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.5; - const Dtype kRMSDecay = 0; const int kNumIters = 4; this->share_ = true; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -611,11 +600,10 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; - const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, - kNumIters, kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); } TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { @@ -623,12 +611,11 @@ TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; - const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; this->share_ = true; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, - kNumIters, kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); } TYPED_TEST(SGDSolverTest, TestSnapshot) { @@ -636,10 +623,9 @@ TYPED_TEST(SGDSolverTest, TestSnapshot) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; - const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -648,11 +634,10 @@ TYPED_TEST(SGDSolverTest, TestSnapshotShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; - const Dtype kRMSDecay = 0; const int kNumIters = 4; this->share_ = true; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -694,11 +679,9 @@ TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithEverything) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; - const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -708,12 +691,10 @@ TYPED_TEST(AdaGradSolverTest, const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; - const Dtype kRMSDecay = 0; const int kNumIters = 4; this->share_ = true; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -722,11 +703,10 @@ TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; - const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, - kNumIters, kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); } TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { @@ -734,12 +714,11 @@ TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; - const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; this->share_ = true; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, - kNumIters, kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); } TYPED_TEST(AdaGradSolverTest, TestSnapshot) { @@ -747,10 +726,9 @@ TYPED_TEST(AdaGradSolverTest, TestSnapshot) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; - const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -759,11 +737,10 @@ TYPED_TEST(AdaGradSolverTest, TestSnapshotShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; - const Dtype kRMSDecay = 0; const int kNumIters = 4; this->share_ = true; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -817,11 +794,9 @@ TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithMomentum) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; - const Dtype kRMSDecay = 0; const int kNumIters = 1; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -830,11 +805,9 @@ TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0; const Dtype kMomentum = 0.5; - const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -855,12 +828,10 @@ TYPED_TEST(NesterovSolverTest, const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; - const Dtype kRMSDecay = 0; const int kNumIters = 4; this->share_ = true; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -869,11 +840,10 @@ TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; - const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, - kNumIters, kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); } TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { @@ -881,12 +851,11 @@ TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; - const Dtype kRMSDecay = 0; const int kNumIters = 4; const int kIterSize = 2; this->share_ = true; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, - kNumIters, kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); } TYPED_TEST(NesterovSolverTest, TestSnapshot) { @@ -894,10 +863,9 @@ TYPED_TEST(NesterovSolverTest, TestSnapshot) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; - const Dtype kRMSDecay = 0; const int kNumIters = 4; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -906,11 +874,10 @@ TYPED_TEST(NesterovSolverTest, TestSnapshotShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.9; - const Dtype kRMSDecay = 0; const int kNumIters = 4; this->share_ = true; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -920,7 +887,10 @@ class RMSPropSolverTest : public GradientBasedSolverTest { protected: virtual void InitSolver(const SolverParameter& param) { - this->solver_.reset(new RMSPropSolver(param)); + const Dtype rms_decay = 0.95; + SolverParameter new_param = param; + new_param.set_rms_decay(rms_decay); + this->solver_.reset(new RMSPropSolver(new_param)); } virtual SolverParameter_SolverType solver_type() { return SolverParameter_SolverType_RMSPROP; @@ -941,11 +911,9 @@ TYPED_TEST(RMSPropSolverTest, TestRMSPropLeastSquaresUpdateWithRmsDecay) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.0; const Dtype kMomentum = 0.0; - const Dtype kRMSDecay = 0.95; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -954,11 +922,9 @@ TYPED_TEST(RMSPropSolverTest, TestRMSPropLeastSquaresUpdateWithEverything) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.0; - const Dtype kRMSDecay = 0.95; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -968,12 +934,10 @@ TYPED_TEST(RMSPropSolverTest, const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.0; - const Dtype kRMSDecay = 0.95; const int kNumIters = 4; this->share_ = true; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, - kRMSDecay, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -982,11 +946,10 @@ TYPED_TEST(RMSPropSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.0; - const Dtype kRMSDecay = 0.95; const int kNumIters = 4; const int kIterSize = 2; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, - kNumIters, kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); } TYPED_TEST(RMSPropSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { @@ -994,12 +957,11 @@ TYPED_TEST(RMSPropSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.0; - const Dtype kRMSDecay = 0.95; const int kNumIters = 4; const int kIterSize = 2; this->share_ = true; - this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, - kNumIters, kIterSize); + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); } TYPED_TEST(RMSPropSolverTest, TestSnapshot) { @@ -1007,10 +969,9 @@ TYPED_TEST(RMSPropSolverTest, TestSnapshot) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; - const Dtype kRMSDecay = 0.95; const int kNumIters = 4; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); } } @@ -1019,11 +980,10 @@ TYPED_TEST(RMSPropSolverTest, TestSnapshotShare) { const Dtype kLearningRate = 0.01; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0; - const Dtype kRMSDecay = 0.95; const int kNumIters = 4; this->share_ = true; for (int i = 1; i <= kNumIters; ++i) { - this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, kRMSDecay, i); + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); } } From b97ca6d4d17b4a661d553c233c2dfe03b88033c5 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Sun, 9 Aug 2015 11:03:23 -0700 Subject: [PATCH 129/331] Use net_->learnable_params() instead of net_->params() in RMSprop In RMSProp solver, use const vector*>& net_params = this->net_->learnable_params(); instead of const vector > >& net_params = this->net_->params(); --- src/caffe/solver.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 43834c0c569..54e085a63e5 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -861,7 +861,7 @@ void AdaGradSolver::ComputeUpdateValue(int param_id, Dtype rate) { template void RMSPropSolver::ComputeUpdateValue(int param_id, Dtype rate) { - const vector > >& net_params = this->net_->params(); + const vector*>& net_params = this->net_->learnable_params(); const vector& net_params_lr = this->net_->params_lr(); // get the learning rate From 9b71fd038018d7c910ed0b75003b76edce1c5af9 Mon Sep 17 00:00:00 2001 From: Fisher Yu Date: Sun, 9 Aug 2015 14:22:04 -0700 Subject: [PATCH 130/331] from __future__ imports must occur at the beginning of the file --- examples/pycaffe/caffenet.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/pycaffe/caffenet.py b/examples/pycaffe/caffenet.py index 06c5a02d4ee..82af2294435 100644 --- a/examples/pycaffe/caffenet.py +++ b/examples/pycaffe/caffenet.py @@ -1,6 +1,6 @@ +from __future__ import print_function from caffe import layers as L, params as P, to_proto from caffe.proto import caffe_pb2 -from __future__ import print_function # helper function for common structures From d94ca3f4b15d1e02bdf520733b04999f1134d078 Mon Sep 17 00:00:00 2001 From: Cyprien Noel Date: Tue, 28 Apr 2015 14:28:04 -0700 Subject: [PATCH 131/331] Add BlockingQueue for inter-thread communication --- include/caffe/util/blocking_queue.hpp | 47 +++++++++++++++ src/caffe/util/blocking_queue.cpp | 86 +++++++++++++++++++++++++++ 2 files changed, 133 insertions(+) create mode 100644 include/caffe/util/blocking_queue.hpp create mode 100644 src/caffe/util/blocking_queue.cpp diff --git a/include/caffe/util/blocking_queue.hpp b/include/caffe/util/blocking_queue.hpp new file mode 100644 index 00000000000..955e12cc567 --- /dev/null +++ b/include/caffe/util/blocking_queue.hpp @@ -0,0 +1,47 @@ +#ifndef CAFFE_UTIL_BLOCKING_QUEUE_HPP_ +#define CAFFE_UTIL_BLOCKING_QUEUE_HPP_ + +#include +#include + +#include "caffe/common.hpp" + +namespace caffe { + +template +class BlockingQueue { + public: + explicit BlockingQueue(); + + void push(const T& t); + + bool try_pop(T* t); + + // This logs a message if the threads needs to be blocked + // useful for detecting e.g. when data feeding is too slow + T pop(const string& log_on_wait = ""); + + bool try_peek(T* t); + + // Return element without removing it + T peek(); + + size_t size() const; + + protected: + /** + Move synchronization fields out instead of including boost/thread.hpp + to avoid a boost/NVCC issues (#1009, #1010) on OSX. Also fails on + Linux CUDA 7.0.18. + */ + class sync; + + std::queue queue_; + shared_ptr sync_; + +DISABLE_COPY_AND_ASSIGN(BlockingQueue); +}; + +} // namespace caffe + +#endif diff --git a/src/caffe/util/blocking_queue.cpp b/src/caffe/util/blocking_queue.cpp new file mode 100644 index 00000000000..73c9564c0dd --- /dev/null +++ b/src/caffe/util/blocking_queue.cpp @@ -0,0 +1,86 @@ +#include +#include + +#include "caffe/util/blocking_queue.hpp" + +namespace caffe { + +template +class BlockingQueue::sync { + public: + mutable boost::mutex mutex_; + boost::condition_variable condition_; +}; + +template +BlockingQueue::BlockingQueue() + : sync_(new sync()) { +} + +template +void BlockingQueue::push(const T& t) { + boost::mutex::scoped_lock lock(sync_->mutex_); + queue_.push(t); + lock.unlock(); + sync_->condition_.notify_one(); +} + +template +bool BlockingQueue::try_pop(T* t) { + boost::mutex::scoped_lock lock(sync_->mutex_); + + if (queue_.empty()) { + return false; + } + + *t = queue_.front(); + queue_.pop(); + return true; +} + +template +T BlockingQueue::pop(const string& log_on_wait) { + boost::mutex::scoped_lock lock(sync_->mutex_); + + while (queue_.empty()) { + if (!log_on_wait.empty()) { + LOG_EVERY_N(INFO, 1000)<< log_on_wait; + } + sync_->condition_.wait(lock); + } + + T t = queue_.front(); + queue_.pop(); + return t; +} + +template +bool BlockingQueue::try_peek(T* t) { + boost::mutex::scoped_lock lock(sync_->mutex_); + + if (queue_.empty()) { + return false; + } + + *t = queue_.front(); + return true; +} + +template +T BlockingQueue::peek() { + boost::mutex::scoped_lock lock(sync_->mutex_); + + while (queue_.empty()) { + sync_->condition_.wait(lock); + } + + return queue_.front(); +} + +template +size_t BlockingQueue::size() const { + boost::mutex::scoped_lock lock(sync_->mutex_); + return queue_.size(); +} + +} // namespace caffe From 45d792e8b1e44acb467ab9be3debdd9e819c11d1 Mon Sep 17 00:00:00 2001 From: Cyprien Noel Date: Mon, 27 Apr 2015 19:48:10 -0700 Subject: [PATCH 132/331] Thread-local Caffe --- include/caffe/common.hpp | 13 +++++------ include/caffe/internal_thread.hpp | 12 ++++++++-- src/caffe/common.cpp | 11 ++++++++- src/caffe/internal_thread.cpp | 29 +++++++++++++++++++++--- src/caffe/test/test_internal_thread.cpp | 30 +++++++++++++++++++++++++ 5 files changed, 82 insertions(+), 13 deletions(-) diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index 5f86bc2625b..3fa81431314 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -98,12 +98,12 @@ void GlobalInit(int* pargc, char*** pargv); class Caffe { public: ~Caffe(); - inline static Caffe& Get() { - if (!singleton_.get()) { - singleton_.reset(new Caffe()); - } - return *singleton_; - } + + // Thread local context for Caffe. Moved to common.cpp instead of + // including boost/thread.hpp to avoid a boost/NVCC issues (#1009, #1010) + // on OSX. Also fails on Linux with CUDA 7.0.18. + static Caffe& Get(); + enum Brew { CPU, GPU }; // This random number generator facade hides boost and CUDA rng @@ -158,7 +158,6 @@ class Caffe { shared_ptr random_generator_; Brew mode_; - static shared_ptr singleton_; private: // The private constructor to avoid duplicate instantiation. diff --git a/include/caffe/internal_thread.hpp b/include/caffe/internal_thread.hpp index 815ca54605e..bcff318e866 100644 --- a/include/caffe/internal_thread.hpp +++ b/include/caffe/internal_thread.hpp @@ -14,14 +14,19 @@ namespace caffe { /** * Virtual class encapsulate boost::thread for use in base class * The child class will acquire the ability to run a single thread, - * by reimplementing the virutal function InternalThreadEntry. + * by reimplementing the virtual function InternalThreadEntry. */ class InternalThread { public: InternalThread() : thread_() {} virtual ~InternalThread(); - /** Returns true if the thread was successfully started. **/ + /** + * Caffe's thread local state will be initialized using the current + * thread values, e.g. device id, solver index etc. The random seed + * is initialized using caffe_rng_rand. + * Will not return until the internal thread has exited. + */ bool StartInternalThread(); /** Will not return until the internal thread has exited. */ @@ -34,6 +39,9 @@ class InternalThread { with the code you want your thread to run. */ virtual void InternalThreadEntry() {} + private: + void entry(int device, Caffe::Brew mode, int rand_seed); + shared_ptr thread_; }; diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index af96cac40aa..0215c76ef76 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -7,7 +8,15 @@ namespace caffe { -shared_ptr Caffe::singleton_; +// Make sure each thread can have different values. +static boost::thread_specific_ptr thread_instance_; + +Caffe& Caffe::Get() { + if (!thread_instance_.get()) { + thread_instance_.reset(new Caffe()); + } + return *(thread_instance_.get()); +} // random seeding int64_t cluster_seedgen(void) { diff --git a/src/caffe/internal_thread.cpp b/src/caffe/internal_thread.cpp index c2d19d433b4..2be88b31fa0 100644 --- a/src/caffe/internal_thread.cpp +++ b/src/caffe/internal_thread.cpp @@ -1,8 +1,14 @@ #include + #include "caffe/internal_thread.hpp" +#include "caffe/util/math_functions.hpp" namespace caffe { +InternalThread::~InternalThread() { + StopInternalThread(); +} + InternalThread::~InternalThread() { WaitForInternalThreadToExit(); } @@ -11,20 +17,37 @@ bool InternalThread::is_started() const { return thread_.get() != NULL && thread_->joinable(); } - bool InternalThread::StartInternalThread() { if (!WaitForInternalThreadToExit()) { return false; } + + int device = 0; +#ifndef CPU_ONLY + CUDA_CHECK(cudaGetDevice(&device)); +#endif + Caffe::Brew mode = Caffe::mode(); + int rand_seed = caffe_rng_rand(); + try { - thread_.reset( - new boost::thread(&InternalThread::InternalThreadEntry, this)); + thread_.reset(new boost::thread(&InternalThread::entry, this, device, mode, + rand_seed)); } catch (...) { return false; } return true; } +void InternalThread::entry(int device, Caffe::Brew mode, int rand_seed) { +#ifndef CPU_ONLY + CUDA_CHECK(cudaSetDevice(device)); +#endif + Caffe::set_mode(mode); + Caffe::set_random_seed(rand_seed); + + InternalThreadEntry(); +} + /** Will not return until the internal thread has exited. */ bool InternalThread::WaitForInternalThreadToExit() { if (is_started()) { diff --git a/src/caffe/test/test_internal_thread.cpp b/src/caffe/test/test_internal_thread.cpp index 31882b6db1d..390c8eda19b 100644 --- a/src/caffe/test/test_internal_thread.cpp +++ b/src/caffe/test/test_internal_thread.cpp @@ -2,6 +2,7 @@ #include "gtest/gtest.h" #include "caffe/internal_thread.hpp" +#include "caffe/util/math_functions.hpp" #include "caffe/test/test_caffe_main.hpp" @@ -19,5 +20,34 @@ TEST_F(InternalThreadTest, TestStartAndExit) { EXPECT_FALSE(thread.is_started()); } +class TestThreadA : public InternalThread { + void InternalThreadEntry() { + EXPECT_EQ(4244559767, caffe_rng_rand()); + } +}; + +class TestThreadB : public InternalThread { + void InternalThreadEntry() { + EXPECT_EQ(1726478280, caffe_rng_rand()); + } +}; + +TEST_F(InternalThreadTest, TestRandomSeed) { + TestThreadA t1; + Caffe::set_random_seed(9658361); + EXPECT_TRUE(t1.StartInternalThread()); + EXPECT_TRUE(t1.WaitForInternalThreadToExit()); + + TestThreadA t2; + Caffe::set_random_seed(9658361); + EXPECT_TRUE(t2.StartInternalThread()); + EXPECT_TRUE(t2.WaitForInternalThreadToExit()); + + TestThreadB t3; + Caffe::set_random_seed(3435563); + EXPECT_TRUE(t3.StartInternalThread()); + EXPECT_TRUE(t3.WaitForInternalThreadToExit()); +} + } // namespace caffe From 73b3d13b68bedad9d19f70755b0ee4ef376e2a30 Mon Sep 17 00:00:00 2001 From: Cyprien Noel Date: Tue, 28 Apr 2015 14:46:20 -0700 Subject: [PATCH 133/331] Change the way threads are started and stopped - Interrupt the thread before waiting on join - Provide a method for looping threads to exit on demand - CHECK if start and stop succeed instead of returning an error --- include/caffe/internal_thread.hpp | 8 +++--- src/caffe/internal_thread.cpp | 33 +++++++++++++------------ src/caffe/layers/base_data_layer.cpp | 4 +-- src/caffe/test/test_internal_thread.cpp | 16 ++++++------ 4 files changed, 32 insertions(+), 29 deletions(-) diff --git a/include/caffe/internal_thread.hpp b/include/caffe/internal_thread.hpp index bcff318e866..be6ff7fbac7 100644 --- a/include/caffe/internal_thread.hpp +++ b/include/caffe/internal_thread.hpp @@ -25,12 +25,11 @@ class InternalThread { * Caffe's thread local state will be initialized using the current * thread values, e.g. device id, solver index etc. The random seed * is initialized using caffe_rng_rand. - * Will not return until the internal thread has exited. */ - bool StartInternalThread(); + void StartInternalThread(); /** Will not return until the internal thread has exited. */ - bool WaitForInternalThreadToExit(); + void StopInternalThread(); bool is_started() const; @@ -39,6 +38,9 @@ class InternalThread { with the code you want your thread to run. */ virtual void InternalThreadEntry() {} + /* Should be tested when running loops to exit when requested. */ + bool must_stop(); + private: void entry(int device, Caffe::Brew mode, int rand_seed); diff --git a/src/caffe/internal_thread.cpp b/src/caffe/internal_thread.cpp index 2be88b31fa0..d6c26559925 100644 --- a/src/caffe/internal_thread.cpp +++ b/src/caffe/internal_thread.cpp @@ -1,4 +1,5 @@ #include +#include #include "caffe/internal_thread.hpp" #include "caffe/util/math_functions.hpp" @@ -9,18 +10,19 @@ InternalThread::~InternalThread() { StopInternalThread(); } -InternalThread::~InternalThread() { - WaitForInternalThreadToExit(); +bool InternalThread::is_started() const { + return thread_ && thread_->joinable(); } -bool InternalThread::is_started() const { - return thread_.get() != NULL && thread_->joinable(); +bool InternalThread::must_stop() { + return thread_ && thread_->interruption_requested(); } -bool InternalThread::StartInternalThread() { - if (!WaitForInternalThreadToExit()) { - return false; - } +void InternalThread::StartInternalThread() { + // TODO switch to failing once Caffe prefetch thread is persistent. + // Threads should not be started and stopped repeatedly. + // CHECK(!is_started()); + StopInternalThread(); int device = 0; #ifndef CPU_ONLY @@ -32,10 +34,9 @@ bool InternalThread::StartInternalThread() { try { thread_.reset(new boost::thread(&InternalThread::entry, this, device, mode, rand_seed)); - } catch (...) { - return false; + } catch (std::exception& e) { + LOG(FATAL) << "Thread exception: " << e.what(); } - return true; } void InternalThread::entry(int device, Caffe::Brew mode, int rand_seed) { @@ -48,16 +49,16 @@ void InternalThread::entry(int device, Caffe::Brew mode, int rand_seed) { InternalThreadEntry(); } -/** Will not return until the internal thread has exited. */ -bool InternalThread::WaitForInternalThreadToExit() { +void InternalThread::StopInternalThread() { if (is_started()) { + thread_->interrupt(); try { thread_->join(); - } catch (...) { - return false; + } catch (boost::thread_interrupted&) { + } catch (std::exception& e) { + LOG(FATAL) << "Thread exception: " << e.what(); } } - return true; } } // namespace caffe diff --git a/src/caffe/layers/base_data_layer.cpp b/src/caffe/layers/base_data_layer.cpp index 26a1118282f..facaed7f11c 100644 --- a/src/caffe/layers/base_data_layer.cpp +++ b/src/caffe/layers/base_data_layer.cpp @@ -47,12 +47,12 @@ void BasePrefetchingDataLayer::LayerSetUp( template void BasePrefetchingDataLayer::CreatePrefetchThread() { this->data_transformer_->InitRand(); - CHECK(StartInternalThread()) << "Thread execution failed"; + StartInternalThread(); } template void BasePrefetchingDataLayer::JoinPrefetchThread() { - CHECK(WaitForInternalThreadToExit()) << "Thread joining failed"; + StopInternalThread(); } template diff --git a/src/caffe/test/test_internal_thread.cpp b/src/caffe/test/test_internal_thread.cpp index 390c8eda19b..93f1cc541cd 100644 --- a/src/caffe/test/test_internal_thread.cpp +++ b/src/caffe/test/test_internal_thread.cpp @@ -14,9 +14,9 @@ class InternalThreadTest : public ::testing::Test {}; TEST_F(InternalThreadTest, TestStartAndExit) { InternalThread thread; EXPECT_FALSE(thread.is_started()); - EXPECT_TRUE(thread.StartInternalThread()); + thread.StartInternalThread(); EXPECT_TRUE(thread.is_started()); - EXPECT_TRUE(thread.WaitForInternalThreadToExit()); + thread.StopInternalThread(); EXPECT_FALSE(thread.is_started()); } @@ -35,18 +35,18 @@ class TestThreadB : public InternalThread { TEST_F(InternalThreadTest, TestRandomSeed) { TestThreadA t1; Caffe::set_random_seed(9658361); - EXPECT_TRUE(t1.StartInternalThread()); - EXPECT_TRUE(t1.WaitForInternalThreadToExit()); + t1.StartInternalThread(); + t1.StopInternalThread(); TestThreadA t2; Caffe::set_random_seed(9658361); - EXPECT_TRUE(t2.StartInternalThread()); - EXPECT_TRUE(t2.WaitForInternalThreadToExit()); + t2.StartInternalThread(); + t2.StopInternalThread(); TestThreadB t3; Caffe::set_random_seed(3435563); - EXPECT_TRUE(t3.StartInternalThread()); - EXPECT_TRUE(t3.WaitForInternalThreadToExit()); + t3.StartInternalThread(); + t3.StopInternalThread(); } } // namespace caffe From ddcdc9d711e81312caf127e8aa512c3298101297 Mon Sep 17 00:00:00 2001 From: Cyprien Noel Date: Mon, 18 May 2015 17:45:20 -0700 Subject: [PATCH 134/331] Persistent prefetch thread --- include/caffe/data_layers.hpp | 31 +++++---- include/caffe/syncedmem.hpp | 4 ++ src/caffe/internal_thread.cpp | 5 +- src/caffe/layers/base_data_layer.cpp | 88 ++++++++++++++++++-------- src/caffe/layers/base_data_layer.cu | 15 ++--- src/caffe/layers/data_layer.cpp | 26 ++++---- src/caffe/layers/image_data_layer.cpp | 28 ++++---- src/caffe/layers/window_data_layer.cpp | 20 +++--- src/caffe/syncedmem.cpp | 12 ++++ src/caffe/util/blocking_queue.cpp | 4 ++ 10 files changed, 153 insertions(+), 80 deletions(-) diff --git a/include/caffe/data_layers.hpp b/include/caffe/data_layers.hpp index 3958cb7ecb0..f57ab6b0dba 100644 --- a/include/caffe/data_layers.hpp +++ b/include/caffe/data_layers.hpp @@ -15,6 +15,7 @@ #include "caffe/internal_thread.hpp" #include "caffe/layer.hpp" #include "caffe/proto/caffe.pb.h" +#include "caffe/util/blocking_queue.hpp" #include "caffe/util/db.hpp" namespace caffe { @@ -50,12 +51,17 @@ class BaseDataLayer : public Layer { bool output_labels_; }; +template +class Batch { + public: + Blob data_, label_; +}; + template class BasePrefetchingDataLayer : public BaseDataLayer, public InternalThread { public: - explicit BasePrefetchingDataLayer(const LayerParameter& param) - : BaseDataLayer(param) {} + explicit BasePrefetchingDataLayer(const LayerParameter& param); // LayerSetUp: implements common data layer setup functionality, and calls // DataLayerSetUp to do special data layer setup for individual layer types. // This method may not be overridden. @@ -67,14 +73,17 @@ class BasePrefetchingDataLayer : virtual void Forward_gpu(const vector*>& bottom, const vector*>& top); - virtual void CreatePrefetchThread(); - virtual void JoinPrefetchThread(); - // The thread's function - virtual void InternalThreadEntry() {} + // Prefetches batches (asynchronously if to GPU memory) + static const int PREFETCH_COUNT = 3; protected: - Blob prefetch_data_; - Blob prefetch_label_; + virtual void InternalThreadEntry(); + virtual void load_batch(Batch* batch) = 0; + + Batch prefetch_[PREFETCH_COUNT]; + BlockingQueue*> prefetch_free_; + BlockingQueue*> prefetch_full_; + Blob transformed_data_; }; @@ -93,7 +102,7 @@ class DataLayer : public BasePrefetchingDataLayer { virtual inline int MaxTopBlobs() const { return 2; } protected: - virtual void InternalThreadEntry(); + virtual void load_batch(Batch* batch); shared_ptr db_; shared_ptr cursor_; @@ -235,7 +244,7 @@ class ImageDataLayer : public BasePrefetchingDataLayer { protected: shared_ptr prefetch_rng_; virtual void ShuffleImages(); - virtual void InternalThreadEntry(); + virtual void load_batch(Batch* batch); vector > lines_; int lines_id_; @@ -307,7 +316,7 @@ class WindowDataLayer : public BasePrefetchingDataLayer { protected: virtual unsigned int PrefetchRand(); - virtual void InternalThreadEntry(); + virtual void load_batch(Batch* batch); shared_ptr prefetch_rng_; vector > > image_database_; diff --git a/include/caffe/syncedmem.hpp b/include/caffe/syncedmem.hpp index 1b726de9564..4d339bf4e57 100644 --- a/include/caffe/syncedmem.hpp +++ b/include/caffe/syncedmem.hpp @@ -56,6 +56,10 @@ class SyncedMemory { SyncedHead head() { return head_; } size_t size() { return size_; } +#ifndef CPU_ONLY + void async_gpu_push(const cudaStream_t& stream); +#endif + private: void to_cpu(); void to_gpu(); diff --git a/src/caffe/internal_thread.cpp b/src/caffe/internal_thread.cpp index d6c26559925..b193826c1a6 100644 --- a/src/caffe/internal_thread.cpp +++ b/src/caffe/internal_thread.cpp @@ -19,10 +19,7 @@ bool InternalThread::must_stop() { } void InternalThread::StartInternalThread() { - // TODO switch to failing once Caffe prefetch thread is persistent. - // Threads should not be started and stopped repeatedly. - // CHECK(!is_started()); - StopInternalThread(); + CHECK(!is_started()) << "Threads should persist and not be restarted."; int device = 0; #ifndef CPU_ONLY diff --git a/src/caffe/layers/base_data_layer.cpp b/src/caffe/layers/base_data_layer.cpp index facaed7f11c..9288d91339a 100644 --- a/src/caffe/layers/base_data_layer.cpp +++ b/src/caffe/layers/base_data_layer.cpp @@ -1,7 +1,9 @@ +#include #include #include #include "caffe/data_layers.hpp" +#include "caffe/net.hpp" #include "caffe/util/io.hpp" namespace caffe { @@ -27,56 +29,92 @@ void BaseDataLayer::LayerSetUp(const vector*>& bottom, DataLayerSetUp(bottom, top); } +template +BasePrefetchingDataLayer::BasePrefetchingDataLayer( + const LayerParameter& param) + : BaseDataLayer(param), + prefetch_free_(), prefetch_full_() { + for (int i = 0; i < PREFETCH_COUNT; ++i) { + prefetch_free_.push(&prefetch_[i]); + } +} + template void BasePrefetchingDataLayer::LayerSetUp( const vector*>& bottom, const vector*>& top) { BaseDataLayer::LayerSetUp(bottom, top); - // Now, start the prefetch thread. Before calling prefetch, we make two - // cpu_data calls so that the prefetch thread does not accidentally make - // simultaneous cudaMalloc calls when the main thread is running. In some - // GPUs this seems to cause failures if we do not so. - this->prefetch_data_.mutable_cpu_data(); - if (this->output_labels_) { - this->prefetch_label_.mutable_cpu_data(); + // Before starting the prefetch thread, we make cpu_data and gpu_data + // calls so that the prefetch thread does not accidentally make simultaneous + // cudaMalloc calls when the main thread is running. In some GPUs this + // seems to cause failures if we do not so. + for (int i = 0; i < PREFETCH_COUNT; ++i) { + prefetch_[i].data_.mutable_cpu_data(); + if (this->output_labels_) { + prefetch_[i].label_.mutable_cpu_data(); + } } +#ifndef CPU_ONLY + if (Caffe::mode() == Caffe::GPU) { + for (int i = 0; i < PREFETCH_COUNT; ++i) { + prefetch_[i].data_.mutable_gpu_data(); + if (this->output_labels_) { + prefetch_[i].label_.mutable_gpu_data(); + } + } + } +#endif DLOG(INFO) << "Initializing prefetch"; - this->CreatePrefetchThread(); - DLOG(INFO) << "Prefetch initialized."; -} - -template -void BasePrefetchingDataLayer::CreatePrefetchThread() { this->data_transformer_->InitRand(); StartInternalThread(); + DLOG(INFO) << "Prefetch initialized."; } template -void BasePrefetchingDataLayer::JoinPrefetchThread() { - StopInternalThread(); +void BasePrefetchingDataLayer::InternalThreadEntry() { +#ifndef CPU_ONLY + cudaStream_t stream; + if (Caffe::mode() == Caffe::GPU) { + cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking); + } +#endif + + try { + while (!must_stop()) { + Batch* batch = prefetch_free_.pop(); + load_batch(batch); +#ifndef CPU_ONLY + if (Caffe::mode() == Caffe::GPU) { + batch->data_.data().get()->async_gpu_push(stream); + cudaStreamSynchronize(stream); + } +#endif + prefetch_full_.push(batch); + } + } catch (boost::thread_interrupted&) { + // Interrupted exception is expected on shutdown + } } template void BasePrefetchingDataLayer::Forward_cpu( const vector*>& bottom, const vector*>& top) { - // First, join the thread - JoinPrefetchThread(); - DLOG(INFO) << "Thread joined"; + Batch* batch = prefetch_full_.pop("Data layer prefetch queue empty"); // Reshape to loaded data. - top[0]->ReshapeLike(prefetch_data_); + top[0]->Reshape(batch->data_.num(), batch->data_.channels(), + batch->data_.height(), batch->data_.width()); // Copy the data - caffe_copy(prefetch_data_.count(), prefetch_data_.cpu_data(), + caffe_copy(batch->data_.count(), batch->data_.cpu_data(), top[0]->mutable_cpu_data()); DLOG(INFO) << "Prefetch copied"; if (this->output_labels_) { // Reshape to loaded labels. top[1]->ReshapeLike(prefetch_label_); // Copy the labels. - caffe_copy(prefetch_label_.count(), prefetch_label_.cpu_data(), - top[1]->mutable_cpu_data()); + caffe_copy(batch->label_.count(), batch->label_.cpu_data(), + top[1]->mutable_cpu_data()); } - // Start a new prefetch thread - DLOG(INFO) << "CreatePrefetchThread"; - CreatePrefetchThread(); + + prefetch_free_.push(batch); } #ifdef CPU_ONLY diff --git a/src/caffe/layers/base_data_layer.cu b/src/caffe/layers/base_data_layer.cu index 9335a5bc9a9..56439bc506a 100644 --- a/src/caffe/layers/base_data_layer.cu +++ b/src/caffe/layers/base_data_layer.cu @@ -7,22 +7,21 @@ namespace caffe { template void BasePrefetchingDataLayer::Forward_gpu( const vector*>& bottom, const vector*>& top) { - // First, join the thread - JoinPrefetchThread(); + Batch* batch = prefetch_full_.pop("Data layer prefetch queue empty"); // Reshape to loaded data. - top[0]->ReshapeLike(this->prefetch_data_); + top[0]->ReshapeLike(batch->data_); // Copy the data - caffe_copy(prefetch_data_.count(), prefetch_data_.cpu_data(), + caffe_copy(batch->data_.count(), batch->data_.gpu_data(), top[0]->mutable_gpu_data()); if (this->output_labels_) { // Reshape to loaded labels. - top[1]->ReshapeLike(prefetch_label_); + top[1]->ReshapeLike(batch->label_); // Copy the labels. - caffe_copy(prefetch_label_.count(), prefetch_label_.cpu_data(), + caffe_copy(batch->label_.count(), batch->label_.gpu_data(), top[1]->mutable_gpu_data()); } - // Start a new prefetch thread - CreatePrefetchThread(); + + prefetch_free_.push(batch); } INSTANTIATE_LAYER_GPU_FORWARD(BasePrefetchingDataLayer); diff --git a/src/caffe/layers/data_layer.cpp b/src/caffe/layers/data_layer.cpp index 161a75e0c8c..22d9f436185 100644 --- a/src/caffe/layers/data_layer.cpp +++ b/src/caffe/layers/data_layer.cpp @@ -17,8 +17,8 @@ namespace caffe { template -DataLayer::~DataLayer() { - this->JoinPrefetchThread(); +DataLayer::~DataLayer() { + this->StopInternalThread(); } template @@ -54,21 +54,23 @@ void DataLayer::DataLayerSetUp(const vector*>& bottom, << top[0]->width(); // label if (this->output_labels_) { - vector label_shape(1, this->layer_param_.data_param().batch_size()); + vector label_shape(1, batch_size); top[1]->Reshape(label_shape); - this->prefetch_label_.Reshape(label_shape); + for (int i = 0; i < this->PREFETCH_COUNT; ++i) { + this->prefetch_[i].label_.Reshape(label_shape); + } } } -// This function is used to create a thread that prefetches the data. -template -void DataLayer::InternalThreadEntry() { +// This function is called on prefetch thread +template +void DataLayer::load_batch(Batch* batch) { CPUTimer batch_timer; batch_timer.Start(); double read_time = 0; double trans_time = 0; CPUTimer timer; - CHECK(this->prefetch_data_.count()); + CHECK(batch->data_.count()); CHECK(this->transformed_data_.count()); // Reshape according to the first datum of each batch @@ -81,13 +83,13 @@ void DataLayer::InternalThreadEntry() { this->transformed_data_.Reshape(top_shape); // Reshape prefetch_data according to the batch_size. top_shape[0] = batch_size; - this->prefetch_data_.Reshape(top_shape); + batch->data_.Reshape(top_shape); - Dtype* top_data = this->prefetch_data_.mutable_cpu_data(); + Dtype* top_data = batch->data_.mutable_cpu_data(); Dtype* top_label = NULL; // suppress warnings about uninitialized variables if (this->output_labels_) { - top_label = this->prefetch_label_.mutable_cpu_data(); + top_label = batch->label_.mutable_cpu_data(); } timer.Start(); for (int item_id = 0; item_id < batch_size; ++item_id) { @@ -97,7 +99,7 @@ void DataLayer::InternalThreadEntry() { read_time += timer.MicroSeconds(); timer.Start(); // Apply data transformations (mirror, scale, crop...) - int offset = this->prefetch_data_.offset(item_id); + int offset = batch->data_.offset(item_id); this->transformed_data_.set_cpu_data(top_data + offset); this->data_transformer_->Transform(datum, &(this->transformed_data_)); // Copy label. diff --git a/src/caffe/layers/image_data_layer.cpp b/src/caffe/layers/image_data_layer.cpp index dcc53348304..223ba3a75ca 100644 --- a/src/caffe/layers/image_data_layer.cpp +++ b/src/caffe/layers/image_data_layer.cpp @@ -17,7 +17,7 @@ namespace caffe { template ImageDataLayer::~ImageDataLayer() { - this->JoinPrefetchThread(); + this->StopInternalThread(); } template @@ -70,8 +70,10 @@ void ImageDataLayer::DataLayerSetUp(const vector*>& bottom, const int batch_size = this->layer_param_.image_data_param().batch_size(); CHECK_GT(batch_size, 0) << "Positive batch size required"; top_shape[0] = batch_size; - this->prefetch_data_.Reshape(top_shape); - top[0]->ReshapeLike(this->prefetch_data_); + for (int i = 0; i < this->PREFETCH_COUNT; ++i) { + this->prefetch_[i].data_.Reshape(top_shape); + } + top[0]->Reshape(top_shape); LOG(INFO) << "output data size: " << top[0]->num() << "," << top[0]->channels() << "," << top[0]->height() << "," @@ -79,7 +81,9 @@ void ImageDataLayer::DataLayerSetUp(const vector*>& bottom, // label vector label_shape(1, batch_size); top[1]->Reshape(label_shape); - this->prefetch_label_.Reshape(label_shape); + for (int i = 0; i < this->PREFETCH_COUNT; ++i) { + this->prefetch_[i].label_.Reshape(label_shape); + } } template @@ -89,15 +93,15 @@ void ImageDataLayer::ShuffleImages() { shuffle(lines_.begin(), lines_.end(), prefetch_rng); } -// This function is used to create a thread that prefetches the data. +// This function is called on prefetch thread template -void ImageDataLayer::InternalThreadEntry() { +void ImageDataLayer::load_batch(Batch* batch) { CPUTimer batch_timer; batch_timer.Start(); double read_time = 0; double trans_time = 0; CPUTimer timer; - CHECK(this->prefetch_data_.count()); + CHECK(batch->data_.count()); CHECK(this->transformed_data_.count()); ImageDataParameter image_data_param = this->layer_param_.image_data_param(); const int batch_size = image_data_param.batch_size(); @@ -114,12 +118,12 @@ void ImageDataLayer::InternalThreadEntry() { // Use data_transformer to infer the expected blob shape from a cv_img. vector top_shape = this->data_transformer_->InferBlobShape(cv_img); this->transformed_data_.Reshape(top_shape); - // Reshape prefetch_data according to the batch_size. + // Reshape batch according to the batch_size. top_shape[0] = batch_size; - this->prefetch_data_.Reshape(top_shape); + batch->data_.Reshape(top_shape); - Dtype* prefetch_data = this->prefetch_data_.mutable_cpu_data(); - Dtype* prefetch_label = this->prefetch_label_.mutable_cpu_data(); + Dtype* prefetch_data = batch->data_.mutable_cpu_data(); + Dtype* prefetch_label = batch->label_.mutable_cpu_data(); // datum scales const int lines_size = lines_.size(); @@ -133,7 +137,7 @@ void ImageDataLayer::InternalThreadEntry() { read_time += timer.MicroSeconds(); timer.Start(); // Apply transformations (mirror, crop...) to the image - int offset = this->prefetch_data_.offset(item_id); + int offset = batch->data_.offset(item_id); this->transformed_data_.set_cpu_data(prefetch_data + offset); this->data_transformer_->Transform(cv_img, &(this->transformed_data_)); trans_time += timer.MicroSeconds(); diff --git a/src/caffe/layers/window_data_layer.cpp b/src/caffe/layers/window_data_layer.cpp index c127d56bc46..f637f2ec6d4 100644 --- a/src/caffe/layers/window_data_layer.cpp +++ b/src/caffe/layers/window_data_layer.cpp @@ -27,7 +27,7 @@ namespace caffe { template WindowDataLayer::~WindowDataLayer() { - this->JoinPrefetchThread(); + this->StopInternalThread(); } template @@ -171,7 +171,9 @@ void WindowDataLayer::DataLayerSetUp(const vector*>& bottom, CHECK_GT(crop_size, 0); const int batch_size = this->layer_param_.window_data_param().batch_size(); top[0]->Reshape(batch_size, channels, crop_size, crop_size); - this->prefetch_data_.Reshape(batch_size, channels, crop_size, crop_size); + for (int i = 0; i < this->PREFETCH_COUNT; ++i) + this->prefetch_[i].data_.Reshape( + batch_size, channels, crop_size, crop_size); LOG(INFO) << "output data size: " << top[0]->num() << "," << top[0]->channels() << "," << top[0]->height() << "," @@ -179,7 +181,9 @@ void WindowDataLayer::DataLayerSetUp(const vector*>& bottom, // label vector label_shape(1, batch_size); top[1]->Reshape(label_shape); - this->prefetch_label_.Reshape(label_shape); + for (int i = 0; i < this->PREFETCH_COUNT; ++i) { + this->prefetch_[i].label_.Reshape(label_shape); + } // data mean has_mean_file_ = this->transform_param_.has_mean_file(); @@ -217,9 +221,9 @@ unsigned int WindowDataLayer::PrefetchRand() { return (*prefetch_rng)(); } -// Thread fetching the data +// This function is called on prefetch thread template -void WindowDataLayer::InternalThreadEntry() { +void WindowDataLayer::load_batch(Batch* batch) { // At each iteration, sample N windows where N*p are foreground (object) // windows and N*(1-p) are background (non-object) windows CPUTimer batch_timer; @@ -227,8 +231,8 @@ void WindowDataLayer::InternalThreadEntry() { double read_time = 0; double trans_time = 0; CPUTimer timer; - Dtype* top_data = this->prefetch_data_.mutable_cpu_data(); - Dtype* top_label = this->prefetch_label_.mutable_cpu_data(); + Dtype* top_data = batch->data_.mutable_cpu_data(); + Dtype* top_label = batch->label_.mutable_cpu_data(); const Dtype scale = this->layer_param_.window_data_param().scale(); const int batch_size = this->layer_param_.window_data_param().batch_size(); const int context_pad = this->layer_param_.window_data_param().context_pad(); @@ -252,7 +256,7 @@ void WindowDataLayer::InternalThreadEntry() { bool use_square = (crop_mode == "square") ? true : false; // zero out batch - caffe_set(this->prefetch_data_.count(), Dtype(0), top_data); + caffe_set(batch->data_.count(), Dtype(0), top_data); const int num_fg = static_cast(static_cast(batch_size) * fg_fraction); diff --git a/src/caffe/syncedmem.cpp b/src/caffe/syncedmem.cpp index 7617ccfb27f..0da7a3bac79 100644 --- a/src/caffe/syncedmem.cpp +++ b/src/caffe/syncedmem.cpp @@ -108,6 +108,18 @@ void* SyncedMemory::mutable_gpu_data() { #endif } +#ifndef CPU_ONLY +void SyncedMemory::async_gpu_push(const cudaStream_t& stream) { + CHECK(head_ == HEAD_AT_CPU); + if (gpu_ptr_ == NULL) { + CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_)); + } + const cudaMemcpyKind put = cudaMemcpyHostToDevice; + CUDA_CHECK(cudaMemcpyAsync(gpu_ptr_, cpu_ptr_, size_, put, stream)); + // Assume caller will synchronize on the stream before use + head_ = SYNCED; +} +#endif } // namespace caffe diff --git a/src/caffe/util/blocking_queue.cpp b/src/caffe/util/blocking_queue.cpp index 73c9564c0dd..6ab6ba06780 100644 --- a/src/caffe/util/blocking_queue.cpp +++ b/src/caffe/util/blocking_queue.cpp @@ -1,6 +1,7 @@ #include #include +#include "caffe/data_layers.hpp" #include "caffe/util/blocking_queue.hpp" namespace caffe { @@ -83,4 +84,7 @@ size_t BlockingQueue::size() const { return queue_.size(); } +template class BlockingQueue*>; +template class BlockingQueue*>; + } // namespace caffe From bcc8f50a95ecad954d1887f3fb273eaa298e2274 Mon Sep 17 00:00:00 2001 From: Cyprien Noel Date: Mon, 18 May 2015 18:06:09 -0700 Subject: [PATCH 135/331] Add DataReader for parallel training with one DB session - Make sure each solver accesses a different subset of the data - Sequential reading of DB for performance - Prefetch a configurable amount of data to host memory - Distribute data to solvers in round-robin way for determinism --- include/caffe/data_layers.hpp | 8 +- include/caffe/data_reader.hpp | 82 +++++++++++++++++ src/caffe/data_reader.cpp | 121 ++++++++++++++++++++++++++ src/caffe/layers/base_data_layer.cpp | 2 +- src/caffe/layers/data_layer.cpp | 55 +++++------- src/caffe/proto/caffe.proto | 4 + src/caffe/test/test_layer_factory.cpp | 14 ++- src/caffe/test/test_upgrade_proto.cpp | 12 +++ src/caffe/util/blocking_queue.cpp | 3 + 9 files changed, 259 insertions(+), 42 deletions(-) create mode 100644 include/caffe/data_reader.hpp create mode 100644 src/caffe/data_reader.cpp diff --git a/include/caffe/data_layers.hpp b/include/caffe/data_layers.hpp index f57ab6b0dba..12e6c366620 100644 --- a/include/caffe/data_layers.hpp +++ b/include/caffe/data_layers.hpp @@ -5,11 +5,11 @@ #include #include -#include "boost/scoped_ptr.hpp" #include "hdf5.h" #include "caffe/blob.hpp" #include "caffe/common.hpp" +#include "caffe/data_reader.hpp" #include "caffe/data_transformer.hpp" #include "caffe/filler.hpp" #include "caffe/internal_thread.hpp" @@ -90,8 +90,7 @@ class BasePrefetchingDataLayer : template class DataLayer : public BasePrefetchingDataLayer { public: - explicit DataLayer(const LayerParameter& param) - : BasePrefetchingDataLayer(param) {} + explicit DataLayer(const LayerParameter& param); virtual ~DataLayer(); virtual void DataLayerSetUp(const vector*>& bottom, const vector*>& top); @@ -104,8 +103,7 @@ class DataLayer : public BasePrefetchingDataLayer { protected: virtual void load_batch(Batch* batch); - shared_ptr db_; - shared_ptr cursor_; + DataReader reader_; }; /** diff --git a/include/caffe/data_reader.hpp b/include/caffe/data_reader.hpp new file mode 100644 index 00000000000..8ed5542cb8d --- /dev/null +++ b/include/caffe/data_reader.hpp @@ -0,0 +1,82 @@ +#ifndef CAFFE_DATA_READER_HPP_ +#define CAFFE_DATA_READER_HPP_ + +#include +#include +#include + +#include "caffe/common.hpp" +#include "caffe/internal_thread.hpp" +#include "caffe/util/blocking_queue.hpp" +#include "caffe/util/db.hpp" + +namespace caffe { + +/** + * @brief Reads data from a source to queues available to data layers. + * A single reading thread is created per source, even if multiple solvers + * are running in parallel, e.g. for multi-GPU training. This makes sure + * databases are read sequentially, and that each solver accesses a different + * subset of the database. Data is distributed to solvers in a round-robin + * way to keep parallel training deterministic. + */ +class DataReader { + public: + explicit DataReader(const LayerParameter& param); + ~DataReader(); + + inline BlockingQueue& free() const { + return queue_pair_->free_; + } + inline BlockingQueue& full() const { + return queue_pair_->full_; + } + + protected: + // Queue pairs are shared between a body and its readers + class QueuePair { + public: + explicit QueuePair(int size); + ~QueuePair(); + + BlockingQueue free_; + BlockingQueue full_; + + DISABLE_COPY_AND_ASSIGN(QueuePair); + }; + + // A single body is created per source + class Body : public InternalThread { + public: + explicit Body(const LayerParameter& param); + virtual ~Body(); + + protected: + void InternalThreadEntry(); + void read_one(db::Cursor* cursor, QueuePair* qp); + + const LayerParameter param_; + BlockingQueue > new_queue_pairs_; + + friend class DataReader; + + DISABLE_COPY_AND_ASSIGN(Body); + }; + + // A source is uniquely identified by its layer name + path, in case + // the same database is read from two different locations in the net. + static inline string source_key(const LayerParameter& param) { + return param.name() + ":" + param.data_param().source(); + } + + const shared_ptr queue_pair_; + shared_ptr body_; + + static map > bodies_; + +DISABLE_COPY_AND_ASSIGN(DataReader); +}; + +} // namespace caffe + +#endif // CAFFE_DATA_READER_HPP_ diff --git a/src/caffe/data_reader.cpp b/src/caffe/data_reader.cpp new file mode 100644 index 00000000000..60606f0d6c8 --- /dev/null +++ b/src/caffe/data_reader.cpp @@ -0,0 +1,121 @@ +#include +#include +#include +#include + +#include "caffe/common.hpp" +#include "caffe/data_layers.hpp" +#include "caffe/data_reader.hpp" +#include "caffe/proto/caffe.pb.h" + +namespace caffe { + +using boost::weak_ptr; + +map > DataReader::bodies_; +static boost::mutex bodies_mutex_; + +DataReader::DataReader(const LayerParameter& param) + : queue_pair_(new QueuePair( // + param.data_param().prefetch() * param.data_param().batch_size())) { + // Get or create a body + boost::mutex::scoped_lock lock(bodies_mutex_); + string key = source_key(param); + weak_ptr& weak = bodies_[key]; + body_ = weak.lock(); + if (!body_) { + body_.reset(new Body(param)); + bodies_[key] = weak_ptr(body_); + } + body_->new_queue_pairs_.push(queue_pair_); +} + +DataReader::~DataReader() { + string key = source_key(body_->param_); + body_.reset(); + boost::mutex::scoped_lock lock(bodies_mutex_); + if (bodies_[key].expired()) { + bodies_.erase(key); + } +} + +// + +DataReader::QueuePair::QueuePair(int size) { + // Initialize the free queue with requested number of datums + for (int i = 0; i < size; ++i) { + free_.push(new Datum()); + } +} + +DataReader::QueuePair::~QueuePair() { + Datum* datum; + while (free_.try_pop(&datum)) { + delete datum; + } + while (full_.try_pop(&datum)) { + delete datum; + } +} + +// + +DataReader::Body::Body(const LayerParameter& param) + : param_(param), + new_queue_pairs_() { + StartInternalThread(); +} + +DataReader::Body::~Body() { + StopInternalThread(); +} + +void DataReader::Body::InternalThreadEntry() { + shared_ptr db(db::GetDB(param_.data_param().backend())); + db->Open(param_.data_param().source(), db::READ); + shared_ptr cursor(db->NewCursor()); + vector > qps; + try { + // int solver_count = param_.phase() == TRAIN ? Caffe::solver_count() : 1; + // TODO single solver until multi-gpu merge + int solver_count = 1; + + // To ensure deterministic runs, only start running once all solvers + // are ready. But solvers need to peek on one item during initialization, + // so read one item, then wait for the next solver. + for (int i = 0; i < solver_count; ++i) { + shared_ptr qp(new_queue_pairs_.pop()); + read_one(cursor.get(), qp.get()); + qps.push_back(qp); + } + // Main loop + while (!must_stop()) { + for (int i = 0; i < solver_count; ++i) { + read_one(cursor.get(), qps[i].get()); + } + // Check no additional readers have been created. This can happen if + // more than one net is trained at a time per process, whether single + // or multi solver. It might also happen if two data layers have same + // name and same source. + CHECK_EQ(new_queue_pairs_.size(), 0); + } + } catch (boost::thread_interrupted&) { + // Interrupted exception is expected on shutdown + } +} + +void DataReader::Body::read_one(db::Cursor* cursor, QueuePair* qp) { + Datum* datum = qp->free_.pop(); + // TODO deserialize in-place instead of copy? + datum->ParseFromString(cursor->value()); + qp->full_.push(datum); + + // go to the next iter + cursor->Next(); + if (!cursor->valid()) { + DLOG(INFO) << "Restarting data prefetching from start."; + cursor->SeekToFirst(); + } +} + +} // namespace caffe diff --git a/src/caffe/layers/base_data_layer.cpp b/src/caffe/layers/base_data_layer.cpp index 9288d91339a..20f76f62994 100644 --- a/src/caffe/layers/base_data_layer.cpp +++ b/src/caffe/layers/base_data_layer.cpp @@ -108,7 +108,7 @@ void BasePrefetchingDataLayer::Forward_cpu( DLOG(INFO) << "Prefetch copied"; if (this->output_labels_) { // Reshape to loaded labels. - top[1]->ReshapeLike(prefetch_label_); + top[1]->ReshapeLike(batch->label_); // Copy the labels. caffe_copy(batch->label_.count(), batch->label_.cpu_data(), top[1]->mutable_cpu_data()); diff --git a/src/caffe/layers/data_layer.cpp b/src/caffe/layers/data_layer.cpp index 22d9f436185..0932d9feff3 100644 --- a/src/caffe/layers/data_layer.cpp +++ b/src/caffe/layers/data_layer.cpp @@ -11,11 +11,15 @@ #include "caffe/proto/caffe.pb.h" #include "caffe/util/benchmark.hpp" #include "caffe/util/io.hpp" -#include "caffe/util/math_functions.hpp" -#include "caffe/util/rng.hpp" namespace caffe { +template +DataLayer::DataLayer(const LayerParameter& param) + : BasePrefetchingDataLayer(param), + reader_(param) { +} + template DataLayer::~DataLayer() { this->StopInternalThread(); @@ -24,31 +28,19 @@ DataLayer::~DataLayer() { template void DataLayer::DataLayerSetUp(const vector*>& bottom, const vector*>& top) { - // Initialize DB - db_.reset(db::GetDB(this->layer_param_.data_param().backend())); - db_->Open(this->layer_param_.data_param().source(), db::READ); - cursor_.reset(db_->NewCursor()); + const int batch_size = this->layer_param_.data_param().batch_size(); + // Read a data point, and use it to initialize the top blob. + Datum& datum = *(reader_.full().peek()); - // Check if we should randomly skip a few data points - if (this->layer_param_.data_param().rand_skip()) { - unsigned int skip = caffe_rng_rand() % - this->layer_param_.data_param().rand_skip(); - LOG(INFO) << "Skipping first " << skip << " data points."; - while (skip-- > 0) { - cursor_->Next(); - } - } - // Read a data point, to initialize the prefetch and top blobs. - Datum datum; - datum.ParseFromString(cursor_->value()); // Use data_transformer to infer the expected blob shape from datum. vector top_shape = this->data_transformer_->InferBlobShape(datum); this->transformed_data_.Reshape(top_shape); // Reshape top[0] and prefetch_data according to the batch_size. - top_shape[0] = this->layer_param_.data_param().batch_size(); - this->prefetch_data_.Reshape(top_shape); - top[0]->ReshapeLike(this->prefetch_data_); - + top_shape[0] = batch_size; + top[0]->Reshape(top_shape); + for (int i = 0; i < this->PREFETCH_COUNT; ++i) { + this->prefetch_[i].data_.Reshape(top_shape); + } LOG(INFO) << "output data size: " << top[0]->num() << "," << top[0]->channels() << "," << top[0]->height() << "," << top[0]->width(); @@ -76,12 +68,11 @@ void DataLayer::load_batch(Batch* batch) { // Reshape according to the first datum of each batch // on single input batches allows for inputs of varying dimension. const int batch_size = this->layer_param_.data_param().batch_size(); - Datum datum; - datum.ParseFromString(cursor_->value()); + Datum& datum = *(reader_.full().peek()); // Use data_transformer to infer the expected blob shape from datum. vector top_shape = this->data_transformer_->InferBlobShape(datum); this->transformed_data_.Reshape(top_shape); - // Reshape prefetch_data according to the batch_size. + // Reshape batch according to the batch_size. top_shape[0] = batch_size; batch->data_.Reshape(top_shape); @@ -91,11 +82,10 @@ void DataLayer::load_batch(Batch* batch) { if (this->output_labels_) { top_label = batch->label_.mutable_cpu_data(); } - timer.Start(); for (int item_id = 0; item_id < batch_size; ++item_id) { + timer.Start(); // get a datum - Datum datum; - datum.ParseFromString(cursor_->value()); + Datum& datum = *(reader_.full().pop("Waiting for data")); read_time += timer.MicroSeconds(); timer.Start(); // Apply data transformations (mirror, scale, crop...) @@ -107,13 +97,8 @@ void DataLayer::load_batch(Batch* batch) { top_label[item_id] = datum.label(); } trans_time += timer.MicroSeconds(); - timer.Start(); - // go to the next item. - cursor_->Next(); - if (!cursor_->valid()) { - DLOG(INFO) << "Restarting data prefetching from start."; - cursor_->SeekToFirst(); - } + + reader_.free().push(const_cast(&datum)); } timer.Stop(); batch_timer.Stop(); diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 89f14595ba6..41165410f33 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -500,6 +500,7 @@ message DataParameter { // to avoid all asynchronous sgd clients to start at the same point. The skip // point would be set as rand_skip * rand(0,1). Note that rand_skip should not // be larger than the number of keys in the database. + // DEPRECATED. Each solver accesses a different subset of the database. optional uint32 rand_skip = 7 [default = 0]; optional DB backend = 8 [default = LEVELDB]; // DEPRECATED. See TransformationParameter. For data pre-processing, we can do @@ -515,6 +516,9 @@ message DataParameter { optional bool mirror = 6 [default = false]; // Force the encoded image to have 3 color channels optional bool force_encoded_color = 9 [default = false]; + // Prefetch queue (Number of batches to prefetch to host memory, increase if + // data access bandwidth varies). + optional uint32 prefetch = 10 [default = 4]; } message DropoutParameter { diff --git a/src/caffe/test/test_layer_factory.cpp b/src/caffe/test/test_layer_factory.cpp index efb1b37ac42..c86fafd000c 100644 --- a/src/caffe/test/test_layer_factory.cpp +++ b/src/caffe/test/test_layer_factory.cpp @@ -1,11 +1,14 @@ #include #include +#include "boost/scoped_ptr.hpp" #include "gtest/gtest.h" #include "caffe/common.hpp" #include "caffe/layer.hpp" #include "caffe/layer_factory.hpp" +#include "caffe/util/db.hpp" +#include "caffe/util/io.hpp" #include "caffe/test/test_caffe_main.hpp" @@ -21,11 +24,20 @@ TYPED_TEST(LayerFactoryTest, TestCreateLayer) { typename LayerRegistry::CreatorRegistry& registry = LayerRegistry::Registry(); shared_ptr > layer; - LayerParameter layer_param; for (typename LayerRegistry::CreatorRegistry::iterator iter = registry.begin(); iter != registry.end(); ++iter) { // Special case: PythonLayer is checked by pytest if (iter->first == "Python") { continue; } + LayerParameter layer_param; + // Data layers expect a DB + if (iter->first == "Data") { + string tmp; + MakeTempDir(&tmp); + boost::scoped_ptr db(db::GetDB(DataParameter_DB_LEVELDB)); + db->Open(tmp, db::NEW); + db->Close(); + layer_param.mutable_data_param()->set_source(tmp); + } layer_param.set_type(iter->first); layer = LayerRegistry::CreateLayer(layer_param); EXPECT_EQ(iter->first, layer->type()); diff --git a/src/caffe/test/test_upgrade_proto.cpp b/src/caffe/test/test_upgrade_proto.cpp index eec627656ef..006720231a5 100644 --- a/src/caffe/test/test_upgrade_proto.cpp +++ b/src/caffe/test/test_upgrade_proto.cpp @@ -2,12 +2,15 @@ #include #include +#include "boost/scoped_ptr.hpp" #include "google/protobuf/text_format.h" #include "gtest/gtest.h" #include "caffe/blob.hpp" #include "caffe/common.hpp" #include "caffe/layer.hpp" +#include "caffe/util/db.hpp" +#include "caffe/util/io.hpp" #include "caffe/util/upgrade_proto.hpp" #include "caffe/test/test_caffe_main.hpp" @@ -2901,6 +2904,15 @@ TEST_F(NetUpgradeTest, TestUpgradeV1LayerType) { continue; // Empty string isn't actually a valid layer type. } layer_param.set_type(v2_layer_type); + // Data layers expect a DB + if (v2_layer_type == "Data") { + string tmp; + MakeTempDir(&tmp); + boost::scoped_ptr db(db::GetDB(DataParameter_DB_LEVELDB)); + db->Open(tmp, db::NEW); + db->Close(); + layer_param.mutable_data_param()->set_source(tmp); + } layer = LayerRegistry::CreateLayer(layer_param); EXPECT_EQ(v2_layer_type, layer->type()); } diff --git a/src/caffe/util/blocking_queue.cpp b/src/caffe/util/blocking_queue.cpp index 6ab6ba06780..f7c53f22225 100644 --- a/src/caffe/util/blocking_queue.cpp +++ b/src/caffe/util/blocking_queue.cpp @@ -2,6 +2,7 @@ #include #include "caffe/data_layers.hpp" +#include "caffe/data_reader.hpp" #include "caffe/util/blocking_queue.hpp" namespace caffe { @@ -86,5 +87,7 @@ size_t BlockingQueue::size() const { template class BlockingQueue*>; template class BlockingQueue*>; +template class BlockingQueue; +template class BlockingQueue >; } // namespace caffe From d2f045768cba7d494abb4d168fc366d6fce80b85 Mon Sep 17 00:00:00 2001 From: Cyprien Noel Date: Mon, 18 May 2015 20:07:36 -0700 Subject: [PATCH 136/331] Allocate host memory through cudaMallocHost thanks to discussion by @thatguymike and @flx42 --- include/caffe/syncedmem.hpp | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/include/caffe/syncedmem.hpp b/include/caffe/syncedmem.hpp index 4d339bf4e57..4a1a2f3fcc0 100644 --- a/include/caffe/syncedmem.hpp +++ b/include/caffe/syncedmem.hpp @@ -8,26 +8,29 @@ namespace caffe { -// Theoretically, CaffeMallocHost and CaffeFreeHost should simply call the -// cudaMallocHost and cudaFree functions in order to create pinned memory. -// However, those codes rely on the existence of a cuda GPU (I don't know -// why that is a must since allocating memory should not be accessing the -// GPU resource, but it just creates an error as of Cuda 5.0) and will cause -// problem when running on a machine without GPU. Thus, we simply define -// these two functions for safety and possible future change if the problem -// of calling cuda functions disappears in a future version. -// -// In practice, although we are creating unpinned memory here, as long as we -// are constantly accessing them the memory pages almost always stays in -// the physical memory (assuming we have large enough memory installed), and -// does not seem to create a memory bottleneck here. - +// If CUDA is available and in GPU mode, host memory will be allocated pinned, +// using cudaMallocHost. It avoids dynamic pinning for transfers (DMA). +// The improvement in performance seems negligible in the single GPU case, +// but might be more significant for parallel training. Most importantly, +// it improved stability for large models on many GPUs. inline void CaffeMallocHost(void** ptr, size_t size) { +#ifndef CPU_ONLY + if (Caffe::mode() == Caffe::GPU) { + CUDA_CHECK(cudaMallocHost(ptr, size)); + return; + } +#endif *ptr = malloc(size); CHECK(*ptr) << "host allocation of size " << size << " failed"; } inline void CaffeFreeHost(void* ptr) { +#ifndef CPU_ONLY + if (Caffe::mode() == Caffe::GPU) { + CUDA_CHECK(cudaFreeHost(ptr)); + return; + } +#endif free(ptr); } From e5575cf17a43a56e4ba9bc5465548ac0512197d8 Mon Sep 17 00:00:00 2001 From: Cyprien Noel Date: Tue, 19 May 2015 11:11:05 -0700 Subject: [PATCH 137/331] Multi-GPU - Parallelize batches among GPUs and tree-reduce the gradients - The effective batch size scales with the number of devices - Batch size is multiplied by the number of devices - Split batches between GPUs, and tree-reduce the gradients - Detect machine topology (twin-GPU boards, P2P connectivity) - Track device in syncedmem (thanks @thatguymike) - Insert a callback in the solver for minimal code change - Accept list for gpu flag of caffe tool, e.g. '-gpu 0,1' or '-gpu all'. Run on default GPU if no ID given. - Add multi-GPU solver test - Deterministic architecture for reproducible runs --- include/caffe/caffe.hpp | 1 + include/caffe/common.hpp | 7 + include/caffe/internal_thread.hpp | 3 +- include/caffe/layer_factory.hpp | 4 +- include/caffe/parallel.hpp | 118 +++++ include/caffe/solver.hpp | 38 ++ include/caffe/syncedmem.hpp | 7 +- src/caffe/common.cpp | 5 +- src/caffe/data_reader.cpp | 4 +- src/caffe/data_transformer.cpp | 4 +- src/caffe/internal_thread.cpp | 9 +- src/caffe/net.cpp | 180 +++++--- src/caffe/parallel.cpp | 430 ++++++++++++++++++ src/caffe/solver.cpp | 57 ++- src/caffe/syncedmem.cpp | 34 +- src/caffe/test/test_gradient_based_solver.cpp | 75 ++- src/caffe/util/blocking_queue.cpp | 3 + tools/caffe.cpp | 111 +++-- 18 files changed, 949 insertions(+), 141 deletions(-) create mode 100644 include/caffe/parallel.hpp create mode 100644 src/caffe/parallel.cpp diff --git a/include/caffe/caffe.hpp b/include/caffe/caffe.hpp index 3c829f2f9b0..68a5e1d1d1a 100644 --- a/include/caffe/caffe.hpp +++ b/include/caffe/caffe.hpp @@ -10,6 +10,7 @@ #include "caffe/layer.hpp" #include "caffe/layer_factory.hpp" #include "caffe/net.hpp" +#include "caffe/parallel.hpp" #include "caffe/proto/caffe.pb.h" #include "caffe/solver.hpp" #include "caffe/util/benchmark.hpp" diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index 3fa81431314..1df6b9a14fb 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -149,6 +149,11 @@ class Caffe { static void SetDevice(const int device_id); // Prints the current GPU status. static void DeviceQuery(); + // Parallel training info + inline static int solver_count() { return Get().solver_count_; } + inline static void set_solver_count(int val) { Get().solver_count_ = val; } + inline static bool root_solver() { return Get().root_solver_; } + inline static void set_root_solver(bool val) { Get().root_solver_ = val; } protected: #ifndef CPU_ONLY @@ -158,6 +163,8 @@ class Caffe { shared_ptr random_generator_; Brew mode_; + int solver_count_; + bool root_solver_; private: // The private constructor to avoid duplicate instantiation. diff --git a/include/caffe/internal_thread.hpp b/include/caffe/internal_thread.hpp index be6ff7fbac7..6a8c5a02892 100644 --- a/include/caffe/internal_thread.hpp +++ b/include/caffe/internal_thread.hpp @@ -42,7 +42,8 @@ class InternalThread { bool must_stop(); private: - void entry(int device, Caffe::Brew mode, int rand_seed); + void entry(int device, Caffe::Brew mode, int rand_seed, int solver_count, + bool root_solver); shared_ptr thread_; }; diff --git a/include/caffe/layer_factory.hpp b/include/caffe/layer_factory.hpp index 2fcd93869a0..32e849de0d2 100644 --- a/include/caffe/layer_factory.hpp +++ b/include/caffe/layer_factory.hpp @@ -71,7 +71,9 @@ class LayerRegistry { // Get a layer using a LayerParameter. static shared_ptr > CreateLayer(const LayerParameter& param) { - LOG(INFO) << "Creating layer " << param.name(); + if (Caffe::root_solver()) { + LOG(INFO) << "Creating layer " << param.name(); + } const string& type = param.type(); CreatorRegistry& registry = Registry(); CHECK_EQ(registry.count(type), 1) << "Unknown layer type: " << type diff --git a/include/caffe/parallel.hpp b/include/caffe/parallel.hpp new file mode 100644 index 00000000000..85fc2b55984 --- /dev/null +++ b/include/caffe/parallel.hpp @@ -0,0 +1,118 @@ +#ifndef CAFFE_PARALLEL_HPP_ +#define CAFFE_PARALLEL_HPP_ + +#include + +#include + +#include "caffe/blob.hpp" +#include "caffe/common.hpp" +#include "caffe/internal_thread.hpp" +#include "caffe/layer.hpp" +#include "caffe/proto/caffe.pb.h" +#include "caffe/solver.hpp" +#include "caffe/syncedmem.hpp" +#include "caffe/util/blocking_queue.hpp" + +namespace caffe { + +// Represents a net parameters. Once a net is created, its parameter buffers can +// be replaced by ones from Params, to allow parallelization. Params ensures +// parameters are allocated in one consecutive array. +template +class Params { + public: + explicit Params(shared_ptr > root_solver); + virtual ~Params() { + } + + inline size_t size() const { + return size_; + } + inline Dtype* data() const { + return data_; + } + inline Dtype* diff() const { + return diff_; + } + + protected: + const size_t size_; // Size of buffers + Dtype* data_; // Network parameters + Dtype* diff_; // Gradient + +DISABLE_COPY_AND_ASSIGN(Params); +}; + +// Params stored in GPU memory. +template +class GPUParams : public Params { + public: + GPUParams(shared_ptr > root_solver, int device); + virtual ~GPUParams(); + + void configure(Solver* solver) const; + + protected: + using Params::size_; + using Params::data_; + using Params::diff_; +}; + +class DevicePair { + public: + DevicePair(int parent, int device) + : parent_(parent), + device_(device) { + } + inline int parent() { + return parent_; + } + inline int device() { + return device_; + } + + // Group GPUs in pairs, by proximity depending on machine's topology + static void compute(const vector devices, vector* pairs); + + protected: + int parent_; + int device_; +}; + +// Synchronous data parallelism using map-reduce between local GPUs. +template +class P2PSync : public GPUParams, public Solver::Callback, + public InternalThread { + public: + explicit P2PSync(shared_ptr > root_solver, + P2PSync* parent, const SolverParameter& param); + virtual ~P2PSync(); + + inline const shared_ptr >& solver() const { + return solver_; + } + + void run(const vector& gpus); + + protected: + void on_start(); + void on_gradients_ready(); + + void InternalThreadEntry(); + + P2PSync* parent_; + vector*> children_; + BlockingQueue*> queue_; + const int initial_iter_; + Dtype* parent_grads_; + shared_ptr > solver_; + + using Params::size_; + using Params::data_; + using Params::diff_; +}; + +} // namespace caffe + +#endif diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index fbade9389ff..89a6c76d5f7 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -32,12 +32,27 @@ class Solver { // methods to restore the state from the appropriate snapshot type. void Restore(const char* resume_file); virtual ~Solver() {} + inline const SolverParameter& param() const { return param_; } inline shared_ptr > net() { return net_; } inline const vector > >& test_nets() { return test_nets_; } int iter() { return iter_; } + // Invoked at specific points during an iteration + class Callback { + protected: + virtual void on_start() = 0; + virtual void on_gradients_ready() = 0; + + template + friend class Solver; + }; + const vector& callbacks() const { return callbacks_; } + void add_callback(Callback* value) { + callbacks_.push_back(value); + } + protected: // Make and apply the update value for the current iteration. virtual void ApplyUpdate() = 0; @@ -62,10 +77,33 @@ class Solver { int current_step_; shared_ptr > net_; vector > > test_nets_; + vector callbacks_; DISABLE_COPY_AND_ASSIGN(Solver); }; +/** + * @brief Solver that only computes gradients, used as worker + * for multi-GPU training. + */ +template +class WorkerSolver : public Solver { + public: + explicit WorkerSolver(const SolverParameter& param) + : Solver(param) {} + + protected: + void ApplyUpdate() {} + void SnapshotSolverState(const string& model_filename) { + LOG(FATAL) << "Should not be called on worker solver."; + } + void RestoreSolverStateFromBinaryProto(const string& state_file) { + LOG(FATAL) << "Should not be called on worker solver."; + } + void RestoreSolverStateFromHDF5(const string& state_file) { + LOG(FATAL) << "Should not be called on worker solver."; + } +}; /** * @brief Optimizes the parameters of a Net using diff --git a/include/caffe/syncedmem.hpp b/include/caffe/syncedmem.hpp index 4a1a2f3fcc0..62aadef498d 100644 --- a/include/caffe/syncedmem.hpp +++ b/include/caffe/syncedmem.hpp @@ -45,14 +45,15 @@ class SyncedMemory { public: SyncedMemory() : cpu_ptr_(NULL), gpu_ptr_(NULL), size_(0), head_(UNINITIALIZED), - own_cpu_data_(false) {} + own_cpu_data_(false), own_gpu_data_(false), gpu_device_(-1) {} explicit SyncedMemory(size_t size) : cpu_ptr_(NULL), gpu_ptr_(NULL), size_(size), head_(UNINITIALIZED), - own_cpu_data_(false) {} + own_cpu_data_(false), own_gpu_data_(false), gpu_device_(-1) {} ~SyncedMemory(); const void* cpu_data(); void set_cpu_data(void* data); const void* gpu_data(); + void set_gpu_data(void* data); void* mutable_cpu_data(); void* mutable_gpu_data(); enum SyncedHead { UNINITIALIZED, HEAD_AT_CPU, HEAD_AT_GPU, SYNCED }; @@ -71,6 +72,8 @@ class SyncedMemory { size_t size_; SyncedHead head_; bool own_cpu_data_; + bool own_gpu_data_; + int gpu_device_; DISABLE_COPY_AND_ASSIGN(SyncedMemory); }; // class SyncedMemory diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index 0215c76ef76..7077f3789d7 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -51,7 +51,8 @@ void GlobalInit(int* pargc, char*** pargv) { #ifdef CPU_ONLY // CPU-only Caffe. Caffe::Caffe() - : random_generator_(), mode_(Caffe::CPU) { } + : random_generator_(), mode_(Caffe::CPU), + solver_count_(1), root_solver_(true) { } Caffe::~Caffe() { } @@ -95,7 +96,7 @@ void* Caffe::RNG::generator() { Caffe::Caffe() : cublas_handle_(NULL), curand_generator_(NULL), random_generator_(), - mode_(Caffe::CPU) { + mode_(Caffe::CPU), solver_count_(1), root_solver_(true) { // Try to create a cublas handler, and report an error if failed (but we will // keep the program running as one might just want to run CPU code). if (cublasCreate(&cublas_handle_) != CUBLAS_STATUS_SUCCESS) { diff --git a/src/caffe/data_reader.cpp b/src/caffe/data_reader.cpp index 60606f0d6c8..16378203a88 100644 --- a/src/caffe/data_reader.cpp +++ b/src/caffe/data_reader.cpp @@ -76,9 +76,7 @@ void DataReader::Body::InternalThreadEntry() { shared_ptr cursor(db->NewCursor()); vector > qps; try { - // int solver_count = param_.phase() == TRAIN ? Caffe::solver_count() : 1; - // TODO single solver until multi-gpu merge - int solver_count = 1; + int solver_count = param_.phase() == TRAIN ? Caffe::solver_count() : 1; // To ensure deterministic runs, only start running once all solvers // are ready. But solvers need to peek on one item during initialization, diff --git a/src/caffe/data_transformer.cpp b/src/caffe/data_transformer.cpp index 22633922a01..4666d9bd881 100644 --- a/src/caffe/data_transformer.cpp +++ b/src/caffe/data_transformer.cpp @@ -19,7 +19,9 @@ DataTransformer::DataTransformer(const TransformationParameter& param, CHECK_EQ(param_.mean_value_size(), 0) << "Cannot specify mean_file and mean_value at the same time"; const string& mean_file = param.mean_file(); - LOG(INFO) << "Loading mean file from: " << mean_file; + if (Caffe::root_solver()) { + LOG(INFO) << "Loading mean file from: " << mean_file; + } BlobProto blob_proto; ReadProtoFromBinaryFileOrDie(mean_file.c_str(), &blob_proto); data_mean_.FromProto(blob_proto); diff --git a/src/caffe/internal_thread.cpp b/src/caffe/internal_thread.cpp index b193826c1a6..104884e0295 100644 --- a/src/caffe/internal_thread.cpp +++ b/src/caffe/internal_thread.cpp @@ -27,21 +27,26 @@ void InternalThread::StartInternalThread() { #endif Caffe::Brew mode = Caffe::mode(); int rand_seed = caffe_rng_rand(); + int solver_count = Caffe::solver_count(); + bool root_solver = Caffe::root_solver(); try { thread_.reset(new boost::thread(&InternalThread::entry, this, device, mode, - rand_seed)); + rand_seed, solver_count, root_solver)); } catch (std::exception& e) { LOG(FATAL) << "Thread exception: " << e.what(); } } -void InternalThread::entry(int device, Caffe::Brew mode, int rand_seed) { +void InternalThread::entry(int device, Caffe::Brew mode, int rand_seed, + int solver_count, bool root_solver) { #ifndef CPU_ONLY CUDA_CHECK(cudaSetDevice(device)); #endif Caffe::set_mode(mode); Caffe::set_random_seed(rand_seed); + Caffe::set_solver_count(solver_count); + Caffe::set_root_solver(root_solver); InternalThreadEntry(); } diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index 0e5ed804b73..5d0f4322d19 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -10,6 +10,7 @@ #include "caffe/common.hpp" #include "caffe/layer.hpp" #include "caffe/net.hpp" +#include "caffe/parallel.hpp" #include "caffe/proto/caffe.pb.h" #include "caffe/util/hdf5.hpp" #include "caffe/util/insert_splits.hpp" @@ -41,8 +42,10 @@ void Net::Init(const NetParameter& in_param) { // the current NetState. NetParameter filtered_param; FilterNet(in_param, &filtered_param); - LOG(INFO) << "Initializing net from parameters: " << std::endl - << filtered_param.DebugString(); + if (Caffe::root_solver()) { + LOG(INFO) << "Initializing net from parameters: " << std::endl + << filtered_param.DebugString(); + } // Create a copy of filtered_param with splits added where necessary. NetParameter param; InsertSplits(filtered_param, ¶m); @@ -66,7 +69,8 @@ void Net::Init(const NetParameter& in_param) { const int layer_id = -1; // inputs have fake layer ID -1 AppendTop(param, layer_id, input_id, &available_blobs, &blob_name_to_idx); } - DLOG(INFO) << "Memory required for data: " << memory_used_ * sizeof(Dtype); + DLOG_IF(INFO, Caffe::root_solver()) + << "Memory required for data: " << memory_used_ * sizeof(Dtype); // For each layer, set up its input and output bottom_vecs_.resize(param.layer_size()); top_vecs_.resize(param.layer_size()); @@ -89,7 +93,9 @@ void Net::Init(const NetParameter& in_param) { } layers_.push_back(LayerRegistry::CreateLayer(layer_param)); layer_names_.push_back(layer_param.name()); - LOG(INFO) << "Creating Layer " << layer_param.name(); + if (Caffe::root_solver()) { + LOG(INFO) << "Creating Layer " << layer_param.name(); + } bool need_backward = false; // Figure out this layer's input and output @@ -119,20 +125,30 @@ void Net::Init(const NetParameter& in_param) { } } // After this layer is connected, set it up. - LOG(INFO) << "Setting up " << layer_names_[layer_id]; + if (Caffe::root_solver()) { + LOG(INFO) << "Setting up " << layer_names_[layer_id]; + } layers_[layer_id]->SetUp(bottom_vecs_[layer_id], top_vecs_[layer_id]); for (int top_id = 0; top_id < top_vecs_[layer_id].size(); ++top_id) { if (blob_loss_weights_.size() <= top_id_vecs_[layer_id][top_id]) { blob_loss_weights_.resize(top_id_vecs_[layer_id][top_id] + 1, Dtype(0)); } blob_loss_weights_[top_id_vecs_[layer_id][top_id]] = layer->loss(top_id); - LOG(INFO) << "Top shape: " << top_vecs_[layer_id][top_id]->shape_string(); + if (Caffe::root_solver()) { + LOG(INFO) << "Top shape: " + << top_vecs_[layer_id][top_id]->shape_string(); + } if (layer->loss(top_id)) { - LOG(INFO) << " with loss weight " << layer->loss(top_id); + if (Caffe::root_solver()) { + LOG(INFO) << " with loss weight " << layer->loss(top_id); + } } memory_used_ += top_vecs_[layer_id][top_id]->count(); } - DLOG(INFO) << "Memory required for data: " << memory_used_ * sizeof(Dtype); + if (Caffe::root_solver()) { + DLOG(INFO) << "Memory required for data: " + << memory_used_ * sizeof(Dtype); + } const int param_size = layer_param.param_size(); const int num_param_blobs = layers_[layer_id]->blobs().size(); CHECK_LE(param_size, num_param_blobs) @@ -191,10 +207,14 @@ void Net::Init(const NetParameter& in_param) { } if (!layer_contributes_loss) { layer_need_backward_[layer_id] = false; } if (layer_need_backward_[layer_id]) { - LOG(INFO) << layer_names_[layer_id] << " needs backward computation."; + if (Caffe::root_solver()) { + LOG(INFO) << layer_names_[layer_id] << " needs backward computation."; + } } else { - LOG(INFO) << layer_names_[layer_id] - << " does not need backward computation."; + if (Caffe::root_solver()) { + LOG(INFO) << layer_names_[layer_id] + << " does not need backward computation."; + } } for (int bottom_id = 0; bottom_id < bottom_vecs_[layer_id].size(); ++bottom_id) { @@ -234,7 +254,9 @@ void Net::Init(const NetParameter& in_param) { // In the end, all remaining blobs are considered output blobs. for (set::iterator it = available_blobs.begin(); it != available_blobs.end(); ++it) { - LOG(INFO) << "This network produces output " << *it; + if (Caffe::root_solver()) { + LOG(INFO) << "This network produces output " << *it; + } net_output_blobs_.push_back(blobs_[blob_name_to_idx[*it]].get()); net_output_blob_indices_.push_back(blob_name_to_idx[*it]); } @@ -246,8 +268,10 @@ void Net::Init(const NetParameter& in_param) { } ShareWeights(); debug_info_ = param.debug_info(); - LOG(INFO) << "Network initialization done."; - LOG(INFO) << "Memory required for data: " << memory_used_ * sizeof(Dtype); + if (Caffe::root_solver()) { + LOG(INFO) << "Network initialization done."; + LOG(INFO) << "Memory required for data: " << memory_used_ * sizeof(Dtype); + } } template @@ -286,27 +310,33 @@ bool Net::StateMeetsRule(const NetState& state, // Check whether the rule is broken due to phase. if (rule.has_phase()) { if (rule.phase() != state.phase()) { - LOG(INFO) << "The NetState phase (" << state.phase() - << ") differed from the phase (" << rule.phase() - << ") specified by a rule in layer " << layer_name; + if (Caffe::root_solver()) { + LOG(INFO) << "The NetState phase (" << state.phase() + << ") differed from the phase (" << rule.phase() + << ") specified by a rule in layer " << layer_name; + } return false; } } // Check whether the rule is broken due to min level. if (rule.has_min_level()) { if (state.level() < rule.min_level()) { - LOG(INFO) << "The NetState level (" << state.level() - << ") is above the min_level (" << rule.min_level() - << ") specified by a rule in layer " << layer_name; + if (Caffe::root_solver()) { + LOG(INFO) << "The NetState level (" << state.level() + << ") is above the min_level (" << rule.min_level() + << ") specified by a rule in layer " << layer_name; + } return false; } } // Check whether the rule is broken due to max level. if (rule.has_max_level()) { if (state.level() > rule.max_level()) { - LOG(INFO) << "The NetState level (" << state.level() - << ") is above the max_level (" << rule.max_level() - << ") specified by a rule in layer " << layer_name; + if (Caffe::root_solver()) { + LOG(INFO) << "The NetState level (" << state.level() + << ") is above the max_level (" << rule.max_level() + << ") specified by a rule in layer " << layer_name; + } return false; } } @@ -319,8 +349,10 @@ bool Net::StateMeetsRule(const NetState& state, if (rule.stage(i) == state.stage(j)) { has_stage = true; } } if (!has_stage) { - LOG(INFO) << "The NetState did not contain stage '" << rule.stage(i) - << "' specified by a rule in layer " << layer_name; + if (Caffe::root_solver()) { + LOG(INFO) << "The NetState did not contain stage '" << rule.stage(i) + << "' specified by a rule in layer " << layer_name; + } return false; } } @@ -333,8 +365,10 @@ bool Net::StateMeetsRule(const NetState& state, if (rule.not_stage(i) == state.stage(j)) { has_stage = true; } } if (has_stage) { - LOG(INFO) << "The NetState contained a not_stage '" << rule.not_stage(i) - << "' specified by a rule in layer " << layer_name; + if (Caffe::root_solver()) { + LOG(INFO) << "The NetState contained a not_stage '" << rule.not_stage(i) + << "' specified by a rule in layer " << layer_name; + } return false; } } @@ -356,7 +390,9 @@ void Net::AppendTop(const NetParameter& param, const int layer_id, if (blob_name_to_idx && layer_param && layer_param->bottom_size() > top_id && blob_name == layer_param->bottom(top_id)) { // In-place computation - LOG(INFO) << layer_param->name() << " -> " << blob_name << " (in-place)"; + if (Caffe::root_solver()) { + LOG(INFO) << layer_param->name() << " -> " << blob_name << " (in-place)"; + } top_vecs_[layer_id].push_back(blobs_[(*blob_name_to_idx)[blob_name]].get()); top_id_vecs_[layer_id].push_back((*blob_name_to_idx)[blob_name]); } else if (blob_name_to_idx && @@ -366,10 +402,12 @@ void Net::AppendTop(const NetParameter& param, const int layer_id, LOG(FATAL) << "Duplicate blobs produced by multiple sources."; } else { // Normal output. - if (layer_param) { - LOG(INFO) << layer_param->name() << " -> " << blob_name; - } else { - LOG(INFO) << "Input " << top_id << " -> " << blob_name; + if (Caffe::root_solver()) { + if (layer_param) { + LOG(INFO) << layer_param->name() << " -> " << blob_name; + } else { + LOG(INFO) << "Input " << top_id << " -> " << blob_name; + } } shared_ptr > blob_pointer(new Blob()); const int blob_id = blobs_.size(); @@ -409,7 +447,9 @@ int Net::AppendBottom(const NetParameter& param, const int layer_id, << " (at index " << bottom_id << ") to layer " << layer_id; } const int blob_id = (*blob_name_to_idx)[blob_name]; - LOG(INFO) << layer_names_[layer_id] << " <- " << blob_name; + if (Caffe::root_solver()) { + LOG(INFO) << layer_names_[layer_id] << " <- " << blob_name; + } bottom_vecs_[layer_id].push_back(blobs_[blob_id].get()); bottom_id_vecs_[layer_id].push_back(blob_id); available_blobs->erase(blob_name); @@ -468,9 +508,10 @@ void Net::AppendParam(const NetParameter& param, const int layer_id, param_layer_indices_[owner_net_param_id]; const int owner_layer_id = owner_index.first; const int owner_param_id = owner_index.second; - LOG(INFO) << "Sharing parameters '" << param_name << "' owned by " - << "layer '" << layer_names_[owner_layer_id] << "', param " - << "index " << owner_param_id; + LOG_IF(INFO, Caffe::root_solver()) << "Sharing parameters '" << param_name + << "' owned by " + << "layer '" << layer_names_[owner_layer_id] << "', param " + << "index " << owner_param_id; Blob* this_blob = layers_[layer_id]->blobs()[param_id].get(); Blob* owner_blob = layers_[owner_layer_id]->blobs()[owner_param_id].get(); @@ -595,8 +636,10 @@ void Net::InputDebugInfo(const int input_id) { const Blob& blob = *net_input_blobs_[input_id]; const string& blob_name = blob_names_[net_input_blob_indices_[input_id]]; const Dtype data_abs_val_mean = blob.asum_data() / blob.count(); - LOG(INFO) << " [Forward] " - << "Input " << blob_name << " data: " << data_abs_val_mean; + if (Caffe::root_solver()) { + LOG(INFO) << " [Forward] " + << "Input " << blob_name << " data: " << data_abs_val_mean; + } } template @@ -605,9 +648,12 @@ void Net::ForwardDebugInfo(const int layer_id) { const Blob& blob = *top_vecs_[layer_id][top_id]; const string& blob_name = blob_names_[top_id_vecs_[layer_id][top_id]]; const Dtype data_abs_val_mean = blob.asum_data() / blob.count(); - LOG(INFO) << " [Forward] " - << "Layer " << layer_names_[layer_id] << ", top blob " << blob_name - << " data: " << data_abs_val_mean; + if (Caffe::root_solver()) { + LOG(INFO) << " [Forward] " + << "Layer " << layer_names_[layer_id] + << ", top blob " << blob_name + << " data: " << data_abs_val_mean; + } } for (int param_id = 0; param_id < layers_[layer_id]->blobs().size(); ++param_id) { @@ -615,9 +661,12 @@ void Net::ForwardDebugInfo(const int layer_id) { const int net_param_id = param_id_vecs_[layer_id][param_id]; const string& blob_name = param_display_names_[net_param_id]; const Dtype data_abs_val_mean = blob.asum_data() / blob.count(); - LOG(INFO) << " [Forward] " - << "Layer " << layer_names_[layer_id] << ", param blob " << blob_name - << " data: " << data_abs_val_mean; + if (Caffe::root_solver()) { + LOG(INFO) << " [Forward] " + << "Layer " << layer_names_[layer_id] + << ", param blob " << blob_name + << " data: " << data_abs_val_mean; + } } } @@ -629,18 +678,24 @@ void Net::BackwardDebugInfo(const int layer_id) { const Blob& blob = *bottom_vec[bottom_id]; const string& blob_name = blob_names_[bottom_id_vecs_[layer_id][bottom_id]]; const Dtype diff_abs_val_mean = blob.asum_diff() / blob.count(); - LOG(INFO) << " [Backward] " - << "Layer " << layer_names_[layer_id] << ", bottom blob " << blob_name - << " diff: " << diff_abs_val_mean; + if (Caffe::root_solver()) { + LOG(INFO) << " [Backward] " + << "Layer " << layer_names_[layer_id] + << ", bottom blob " << blob_name + << " diff: " << diff_abs_val_mean; + } } for (int param_id = 0; param_id < layers_[layer_id]->blobs().size(); ++param_id) { if (!layers_[layer_id]->param_propagate_down(param_id)) { continue; } const Blob& blob = *layers_[layer_id]->blobs()[param_id]; const Dtype diff_abs_val_mean = blob.asum_diff() / blob.count(); - LOG(INFO) << " [Backward] " - << "Layer " << layer_names_[layer_id] << ", param blob " << param_id - << " diff: " << diff_abs_val_mean; + if (Caffe::root_solver()) { + LOG(INFO) << " [Backward] " + << "Layer " << layer_names_[layer_id] + << ", param blob " << param_id + << " diff: " << diff_abs_val_mean; + } } } @@ -653,17 +708,22 @@ void Net::UpdateDebugInfo(const int param_id) { const Dtype diff_abs_val_mean = blob.asum_diff() / blob.count(); if (param_owner < 0) { const Dtype data_abs_val_mean = blob.asum_data() / blob.count(); - LOG(INFO) << " [Update] Layer " << layer_name - << ", param " << param_display_name - << " data: " << data_abs_val_mean << "; diff: " << diff_abs_val_mean; + if (Caffe::root_solver()) { + LOG(INFO) << " [Update] Layer " << layer_name + << ", param " << param_display_name + << " data: " << data_abs_val_mean + << "; diff: " << diff_abs_val_mean; + } } else { const string& owner_layer_name = layer_names_[param_layer_indices_[param_owner].first]; - LOG(INFO) << " [Update] Layer " << layer_name - << ", param blob " << param_display_name - << " (owned by layer " << owner_layer_name << ", " - << "param " << param_display_names_[param_owners_[param_id]] << ")" - << " diff: " << diff_abs_val_mean; + if (Caffe::root_solver()) { + LOG(INFO) << " [Update] Layer " << layer_name + << ", param blob " << param_display_name + << " (owned by layer " << owner_layer_name << ", " << "param " + << param_display_names_[param_owners_[param_id]] << ")" + << " diff: " << diff_abs_val_mean; + } } } @@ -720,8 +780,8 @@ void Net::Backward() { const Dtype l2norm_data = std::sqrt(sumsq_data); const Dtype l2norm_diff = std::sqrt(sumsq_diff); LOG(ERROR) << " [Backward] All net params (data, diff): " - << "L1 norm = (" << asum_data << ", " << asum_diff << "); " - << "L2 norm = (" << l2norm_data << ", " << l2norm_diff << ")"; + << "L1 norm = (" << asum_data << ", " << asum_diff << "); " + << "L2 norm = (" << l2norm_data << ", " << l2norm_diff << ")"; } } diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp new file mode 100644 index 00000000000..3fef8cfdb33 --- /dev/null +++ b/src/caffe/parallel.cpp @@ -0,0 +1,430 @@ +#ifndef CPU_ONLY +#include +#endif +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "boost/thread.hpp" +#include "caffe/caffe.hpp" +#include "caffe/parallel.hpp" + +namespace caffe { + +enum Op { + copy, + replace_cpu, + replace_gpu, + replace_cpu_diff, + replace_gpu_diff +}; + +template +static void apply_buffers(const vector*>& blobs, + Dtype* buffer, size_t total_size, Op op) { + Dtype* ptr = buffer; + for (int i = 0; i < blobs.size(); ++i) { + int size = blobs[i]->count(); + switch (op) { + case copy: { + // Init buffer to current values of blobs + caffe_copy(size, + reinterpret_cast(blobs[i]->data()->cpu_data()), + ptr); + break; + } + case replace_cpu: + blobs[i]->data()->set_cpu_data(ptr); + break; + case replace_gpu: + blobs[i]->data()->set_gpu_data(ptr); + break; + case replace_cpu_diff: + blobs[i]->diff()->set_cpu_data(ptr); + break; + case replace_gpu_diff: + blobs[i]->diff()->set_gpu_data(ptr); + break; + } + ptr += size; + } + CHECK_EQ(total_size, ptr - buffer); +} + +// Buffer size necessary to store given blobs +template +static size_t total_size(const vector*>& params) { + size_t size = 0; + for (int i = 0; i < params.size(); ++i) + size += params[i]->count(); + return size; +} + +template +Params::Params(shared_ptr > root_solver) + : size_(total_size(root_solver->net()->learnable_params())), + data_(), + diff_() { +} + +template +GPUParams::GPUParams(shared_ptr > root_solver, int device) + : Params(root_solver) { +#ifndef CPU_ONLY + int initial_device; + CUDA_CHECK(cudaGetDevice(&initial_device)); + + // Allocate device buffers + CUDA_CHECK(cudaSetDevice(device)); + CUDA_CHECK(cudaMalloc(&data_, size_ * sizeof(Dtype))); + + // Copy blob values + const vector*>& net = + root_solver->net()->learnable_params(); + apply_buffers(net, data_, size_, copy); + + CUDA_CHECK(cudaMalloc(&diff_, size_ * sizeof(Dtype))); + caffe_gpu_set(size_, Dtype(0), diff_); + + CUDA_CHECK(cudaSetDevice(initial_device)); +#else + NO_GPU; +#endif +} + +template +GPUParams::~GPUParams() { +#ifndef CPU_ONLY + CUDA_CHECK(cudaFree(data_)); + CUDA_CHECK(cudaFree(diff_)); +#endif +} + +template +void GPUParams::configure(Solver* solver) const { + const vector*>& net = + solver->net()->learnable_params(); + apply_buffers(net, data_, size_, replace_gpu); + apply_buffers(net, diff_, size_, replace_gpu_diff); +} + +void DevicePair::compute(const vector devices, vector* pairs) { +#ifndef CPU_ONLY + vector remaining(devices); + + // Group GPUs by board + for (int i = 0; i < remaining.size(); ++i) { + for (int j = i + 1; j < remaining.size(); ++j) { + cudaDeviceProp a, b; + CUDA_CHECK(cudaGetDeviceProperties(&a, remaining[i])); + CUDA_CHECK(cudaGetDeviceProperties(&b, remaining[j])); + if (a.isMultiGpuBoard && b.isMultiGpuBoard) { + if (a.multiGpuBoardGroupID == b.multiGpuBoardGroupID) { + pairs->push_back(DevicePair(remaining[i], remaining[j])); + DLOG(INFO) << "GPU board: " << remaining[i] << ":" << remaining[j]; + remaining.erase(remaining.begin() + j); + break; + } + } + } + } + ostringstream s; + for (int i = 0; i < remaining.size(); ++i) { + s << (i ? ", " : "") << remaining[i]; + } + DLOG(INFO) << "GPUs paired by boards, remaining: " << s.str(); + + // Group by P2P accessibility + for (int i = 0; i < remaining.size(); ++i) { + for (int j = i + 1; j < remaining.size(); ++j) { + int access; + CUDA_CHECK(cudaDeviceCanAccessPeer(&access, remaining[i], remaining[j])); + if (access) { + pairs->push_back(DevicePair(remaining[i], remaining[j])); + DLOG(INFO) << "P2P pair: " << remaining[i] << ":" << remaining[j]; + remaining.erase(remaining.begin() + j); + break; + } + } + } + s.str(""); + for (int i = 0; i < remaining.size(); ++i) { + s << (i ? ", " : "") << remaining[i]; + } + DLOG(INFO) << "GPUs paired by P2P access, remaining: " << s.str(); + + // Group remaining + for (int i = 0; i < remaining.size(); ++i) { + for (int j = i + 1; j < remaining.size(); ++j) { + pairs->push_back(DevicePair(remaining[i], remaining[j])); + DLOG(INFO) << "Remaining pair: " << remaining[i] << ":" << remaining[j]; + remaining.erase(remaining.begin() + j); + break; + } + } + CHECK_EQ(remaining.size(), 1); + pairs->insert(pairs->begin(), DevicePair(-1, remaining[0])); + + CHECK(pairs->size() == devices.size()); + for (int i = 0; i < pairs->size(); ++i) { + CHECK((*pairs)[i].parent() != (*pairs)[i].device()); + for (int j = i + 1; j < pairs->size(); ++j) { + CHECK((*pairs)[i].device() != (*pairs)[j].device()); + } + } +#else + NO_GPU; +#endif +} + +// + +template +P2PSync::P2PSync(shared_ptr > root_solver, + P2PSync* parent, const SolverParameter& param) + : GPUParams(root_solver, param.device_id()), + parent_(parent), + children_(), + queue_(), + initial_iter_(root_solver->iter()), + solver_() { +#ifndef CPU_ONLY + int initial_device; + CUDA_CHECK(cudaGetDevice(&initial_device)); + const int self = param.device_id(); + CUDA_CHECK(cudaSetDevice(self)); + + if (parent == NULL) { + solver_ = root_solver; + } else { + Caffe::set_root_solver(false); + solver_.reset(new WorkerSolver(param)); + Caffe::set_root_solver(true); + } + this->configure(solver_.get()); + solver_->add_callback(this); + + if (parent) { + // Enable p2p access between devices + const int peer = parent->solver_->param().device_id(); + int access; + CUDA_CHECK(cudaDeviceCanAccessPeer(&access, self, peer)); + if (access) { + CUDA_CHECK(cudaDeviceEnablePeerAccess(peer, 0)); + } else { + LOG(INFO)<< "GPU " << self << " does not have p2p access to GPU " << peer; + } + // Allocate receiving buffer on parent + CUDA_CHECK(cudaSetDevice(peer)); + CUDA_CHECK(cudaMalloc(&parent_grads_, size_ * sizeof(Dtype))); + CUDA_CHECK(cudaSetDevice(self)); + } + + CUDA_CHECK(cudaSetDevice(initial_device)); +#else + NO_GPU; +#endif +} + +template +P2PSync::~P2PSync() { +#ifndef CPU_ONLY + int initial_device; + CUDA_CHECK(cudaGetDevice(&initial_device)); + const int self = solver_->param().device_id(); + CUDA_CHECK(cudaSetDevice(self)); + + if (parent_) { + CUDA_CHECK(cudaFree(parent_grads_)); + const int peer = parent_->solver_->param().device_id(); + int access; + CUDA_CHECK(cudaDeviceCanAccessPeer(&access, self, peer)); + if (access) { + CUDA_CHECK(cudaDeviceDisablePeerAccess(peer)); + } + } + + CUDA_CHECK(cudaSetDevice(initial_device)); +#endif +} + +template +void P2PSync::InternalThreadEntry() { + Caffe::SetDevice(solver_->param().device_id()); + CHECK(Caffe::root_solver()); + Caffe::set_root_solver(false); + // See if there is a defined seed and reset random state if so + if (solver_->param().random_seed() >= 0) { + // Fetch random seed and modulate by device ID to make sure + // everyone doesn't have the same seed. We seem to have some + // solver instability if we have everyone with the same seed + Caffe::set_random_seed( + solver_->param().random_seed() + solver_->param().device_id()); + } + solver_->Step(solver_->param().max_iter() - initial_iter_); +} + +template +void P2PSync::on_start() { +#ifndef CPU_ONLY +#ifdef DEBUG + int device; + CUDA_CHECK(cudaGetDevice(&device)); + CHECK(device == solver_->param().device_id()); +#else +// CHECK(false); +#endif + + // Wait for update from parent + if (parent_) { + P2PSync *parent = queue_.pop(); + CHECK(parent == parent_); + } + + // Update children + for (int i = 0; i < children_.size(); ++i) { + Dtype* src = data_; + Dtype* dst = children_[i]->data_; + +#ifdef DEBUG + cudaPointerAttributes attributes; + CUDA_CHECK(cudaPointerGetAttributes(&attributes, src)); + CHECK(attributes.device == device); + CUDA_CHECK(cudaPointerGetAttributes(&attributes, dst)); + CHECK(attributes.device == children_[i]->solver_->param().device_id()); +#endif + + CUDA_CHECK(cudaMemcpyAsync(dst, src, size_ * sizeof(Dtype), // + cudaMemcpyDeviceToDevice, cudaStreamDefault)); + } + if (children_.size()) { + CUDA_CHECK(cudaStreamSynchronize(cudaStreamDefault)); + } + for (int i = 0; i < children_.size(); ++i) { + children_[i]->queue_.push(this); + } +#endif +} + +template +void P2PSync::on_gradients_ready() { +#ifndef CPU_ONLY +#ifdef DEBUG + int device; + CUDA_CHECK(cudaGetDevice(&device)); + CHECK(device == solver_->param().device_id()); +#endif + + // Sum children gradients as they appear in the queue + for (int i = 0; i < children_.size(); ++i) { + P2PSync *child = queue_.pop(); + Dtype* src = child->parent_grads_; + Dtype* dst = diff_; + +#ifdef DEBUG + bool ok = false; + for (int j = 0; j < children_.size(); ++j) { + if (child == children_[j]) { + ok = true; + } + } + CHECK(ok); + cudaPointerAttributes attributes; + CUDA_CHECK(cudaPointerGetAttributes(&attributes, src)); + CHECK(attributes.device == device); + CUDA_CHECK(cudaPointerGetAttributes(&attributes, dst)); + CHECK(attributes.device == device); +#endif + + caffe_gpu_add(size_, src, dst, dst); + } + + // Send gradients to parent + if (parent_) { + Dtype* src = diff_; + Dtype* dst = parent_grads_; + +#ifdef DEBUG + cudaPointerAttributes attributes; + CUDA_CHECK(cudaPointerGetAttributes(&attributes, src)); + CHECK(attributes.device == device); + CUDA_CHECK(cudaPointerGetAttributes(&attributes, dst)); + CHECK(attributes.device == parent_->solver_->param().device_id()); +#endif + + CUDA_CHECK(cudaMemcpyAsync(dst, src, size_ * sizeof(Dtype), // + cudaMemcpyDeviceToDevice, cudaStreamDefault)); + CUDA_CHECK(cudaStreamSynchronize(cudaStreamDefault)); + parent_->queue_.push(this); + } else { + // Loss functions divide gradients by the batch size, so to compensate + // for split batch, the root solver divides by number of solvers. + caffe_gpu_scal(size_, Dtype(1.0 / Caffe::solver_count()), diff_); + } +#endif +} + +template +void P2PSync::run(const vector& gpus) { + // Pair devices for map-reduce synchronization + vector pairs; + DevicePair::compute(gpus, &pairs); + ostringstream s; + for (int i = 1; i < pairs.size(); ++i) { + s << (i == 1 ? "" : ", ") << pairs[i].parent() << ":" << pairs[i].device(); + } + LOG(INFO)<< "GPUs pairs " << s.str(); + + SolverParameter param(solver_->param()); + vector > > syncs(gpus.size()); + + // Build the GPU tree by finding the parent for each solver + for (int attempts = 0; attempts < pairs.size(); ++attempts) { + for (int i = 1; i < pairs.size(); ++i) { + if (!syncs[i].get()) { + P2PSync* parent = NULL; + for (int j = 0; j < syncs.size(); ++j) { + P2PSync* sync = j == 0 ? this : syncs[j].get(); + if (sync) { + const SolverParameter& p = sync->solver()->param(); + if (p.device_id() == pairs[i].parent()) { + parent = sync; + } + } + } + if (parent) { + param.set_device_id(pairs[i].device()); + syncs[i].reset(new P2PSync(solver_, parent, param)); + parent->children_.push_back((P2PSync*) syncs[i].get()); + } + } + } + } + + LOG(INFO)<< "Starting Optimization"; + + for (int i = 1; i < syncs.size(); ++i) { + syncs[i]->StartInternalThread(); + } + + // Run root solver on current thread + solver_->Solve(); + + for (int i = 1; i < syncs.size(); ++i) { + syncs[i]->StopInternalThread(); + } +} + +INSTANTIATE_CLASS(Params); +INSTANTIATE_CLASS(GPUParams); +INSTANTIATE_CLASS(P2PSync); + +} // namespace caffe + diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 54e085a63e5..b6fd6b642f1 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -19,13 +19,13 @@ namespace caffe { template Solver::Solver(const SolverParameter& param) - : net_() { + : net_(), callbacks_() { Init(param); } template Solver::Solver(const string& param_file) - : net_() { + : net_(), callbacks_() { SolverParameter param; ReadProtoFromTextFileOrDie(param_file, ¶m); Init(param); @@ -33,17 +33,19 @@ Solver::Solver(const string& param_file) template void Solver::Init(const SolverParameter& param) { - LOG(INFO) << "Initializing solver from parameters: " << std::endl - << param.DebugString(); + LOG_IF(INFO, Caffe::root_solver()) << "Initializing solver from parameters: " + << std::endl << param.DebugString(); param_ = param; CHECK_GE(param_.average_loss(), 1) << "average_loss should be non-negative."; - if (param_.random_seed() >= 0) { + if (Caffe::root_solver() && param_.random_seed() >= 0) { Caffe::set_random_seed(param_.random_seed()); } // Scaffolding code InitTrainNet(); - InitTestNets(); - LOG(INFO) << "Solver scaffolding done."; + if (Caffe::root_solver()) { + InitTestNets(); + LOG(INFO) << "Solver scaffolding done."; + } iter_ = 0; current_step_ = 0; } @@ -59,19 +61,22 @@ void Solver::InitTrainNet() { << "one of these fields specifying a train_net: " << field_names; NetParameter net_param; if (param_.has_train_net_param()) { - LOG(INFO) << "Creating training net specified in train_net_param."; + LOG_IF(INFO, Caffe::root_solver()) + << "Creating training net specified in train_net_param."; net_param.CopyFrom(param_.train_net_param()); } else if (param_.has_train_net()) { - LOG(INFO) << "Creating training net from train_net file: " - << param_.train_net(); + LOG_IF(INFO, Caffe::root_solver()) + << "Creating training net from train_net file: " << param_.train_net(); ReadNetParamsFromTextFileOrDie(param_.train_net(), &net_param); } if (param_.has_net_param()) { - LOG(INFO) << "Creating training net specified in net_param."; + LOG_IF(INFO, Caffe::root_solver()) + << "Creating training net specified in net_param."; net_param.CopyFrom(param_.net_param()); } if (param_.has_net()) { - LOG(INFO) << "Creating training net from net file: " << param_.net(); + LOG_IF(INFO, Caffe::root_solver()) + << "Creating training net from net file: " << param_.net(); ReadNetParamsFromTextFileOrDie(param_.net(), &net_param); } // Set the correct NetState. We start with the solver defaults (lowest @@ -88,6 +93,7 @@ void Solver::InitTrainNet() { template void Solver::InitTestNets() { + CHECK(Caffe::root_solver()); const bool has_net_param = param_.has_net_param(); const bool has_net_file = param_.has_net(); const int num_generic_nets = has_net_param + has_net_file; @@ -175,10 +181,14 @@ void Solver::Step(int iters) { // zero-init the params net_->ClearParamDiffs(); if (param_.test_interval() && iter_ % param_.test_interval() == 0 - && (iter_ > 0 || param_.test_initialization())) { + && (iter_ > 0 || param_.test_initialization()) + && Caffe::root_solver()) { TestAll(); } + for (int i = 0; i < callbacks_.size(); ++i) { + callbacks_[i]->on_start(); + } const bool display = param_.display() && iter_ % param_.display() == 0; net_->set_debug_info(display && param_.debug_info()); // accumulate the loss and gradient @@ -198,7 +208,8 @@ void Solver::Step(int iters) { losses[idx] = loss; } if (display) { - LOG(INFO) << "Iteration " << iter_ << ", loss = " << smoothed_loss; + LOG_IF(INFO, Caffe::root_solver()) << "Iteration " << iter_ + << ", loss = " << smoothed_loss; const vector*>& result = net_->output_blobs(); int score_index = 0; for (int j = 0; j < result.size(); ++j) { @@ -213,12 +224,15 @@ void Solver::Step(int iters) { loss_msg_stream << " (* " << loss_weight << " = " << loss_weight * result_vec[k] << " loss)"; } - LOG(INFO) << " Train net output #" + LOG_IF(INFO, Caffe::root_solver()) << " Train net output #" << score_index++ << ": " << output_name << " = " << result_vec[k] << loss_msg_stream.str(); } } } + for (int i = 0; i < callbacks_.size(); ++i) { + callbacks_[i]->on_gradients_ready(); + } ApplyUpdate(); // Increment the internal iter_ counter -- its value should always indicate @@ -226,7 +240,9 @@ void Solver::Step(int iters) { ++iter_; // Save a snapshot if needed. - if (param_.snapshot() && iter_ % param_.snapshot() == 0) { + if (param_.snapshot() + && iter_ % param_.snapshot() == 0 + && Caffe::root_solver()) { Snapshot(); } } @@ -234,6 +250,7 @@ void Solver::Step(int iters) { template void Solver::Solve(const char* resume_file) { + CHECK(Caffe::root_solver()); LOG(INFO) << "Solving " << net_->name(); LOG(INFO) << "Learning Rate Policy: " << param_.lr_policy(); @@ -278,6 +295,7 @@ void Solver::TestAll() { template void Solver::Test(const int test_net_id) { + CHECK(Caffe::root_solver()); LOG(INFO) << "Iteration " << iter_ << ", Testing net (#" << test_net_id << ")"; CHECK_NOTNULL(test_nets_[test_net_id].get())-> @@ -328,13 +346,14 @@ void Solver::Test(const int test_net_id) { << " = " << loss_weight * mean_score << " loss)"; } LOG(INFO) << " Test net output #" << i << ": " << output_name << " = " - << mean_score << loss_msg_stream.str(); + << mean_score << loss_msg_stream.str(); } } template void Solver::Snapshot() { + CHECK(Caffe::root_solver()); string model_filename; switch (param_.snapshot_format()) { case caffe::SolverParameter_SnapshotFormat_BINARYPROTO: @@ -379,6 +398,7 @@ string Solver::SnapshotToHDF5() { template void Solver::Restore(const char* state_file) { + CHECK(Caffe::root_solver()); string state_filename(state_file); if (state_filename.size() >= 3 && state_filename.compare(state_filename.size() - 3, 3, ".h5") == 0) { @@ -480,6 +500,7 @@ void SGDSolver::ClipGradients() { template void SGDSolver::ApplyUpdate() { + CHECK(Caffe::root_solver()); Dtype rate = GetLearningRate(); if (this->param_.display() && this->iter_ % this->param_.display() == 0) { LOG(INFO) << "Iteration " << this->iter_ << ", lr = " << rate; @@ -723,6 +744,7 @@ void SGDSolver::RestoreSolverStateFromHDF5(const string& state_file) { template void NesterovSolver::ComputeUpdateValue(int param_id, Dtype rate) { + CHECK(Caffe::root_solver()); const vector*>& net_params = this->net_->learnable_params(); const vector& net_params_lr = this->net_->params_lr(); Dtype momentum = this->param_.momentum(); @@ -783,6 +805,7 @@ void NesterovSolver::ComputeUpdateValue(int param_id, Dtype rate) { template void AdaGradSolver::ComputeUpdateValue(int param_id, Dtype rate) { + CHECK(Caffe::root_solver()); const vector*>& net_params = this->net_->learnable_params(); const vector& net_params_lr = this->net_->params_lr(); Dtype delta = this->param_.delta(); diff --git a/src/caffe/syncedmem.cpp b/src/caffe/syncedmem.cpp index 0da7a3bac79..a667a867af0 100644 --- a/src/caffe/syncedmem.cpp +++ b/src/caffe/syncedmem.cpp @@ -12,8 +12,14 @@ SyncedMemory::~SyncedMemory() { } #ifndef CPU_ONLY - if (gpu_ptr_) { + if (gpu_ptr_ && own_gpu_data_) { + int initial_device; + cudaGetDevice(&initial_device); + if (gpu_device_ != -1) { + CUDA_CHECK(cudaSetDevice(gpu_device_)); + } CUDA_CHECK(cudaFree(gpu_ptr_)); + cudaSetDevice(initial_device); } #endif // CPU_ONLY } @@ -48,13 +54,17 @@ inline void SyncedMemory::to_gpu() { #ifndef CPU_ONLY switch (head_) { case UNINITIALIZED: + CUDA_CHECK(cudaGetDevice(&gpu_device_)); CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_)); caffe_gpu_memset(size_, 0, gpu_ptr_); head_ = HEAD_AT_GPU; + own_gpu_data_ = true; break; case HEAD_AT_CPU: if (gpu_ptr_ == NULL) { + CUDA_CHECK(cudaGetDevice(&gpu_device_)); CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_)); + own_gpu_data_ = true; } caffe_gpu_memcpy(size_, cpu_ptr_, gpu_ptr_); head_ = SYNCED; @@ -92,6 +102,26 @@ const void* SyncedMemory::gpu_data() { #endif } +void SyncedMemory::set_gpu_data(void* data) { +#ifndef CPU_ONLY + CHECK(data); + if (own_gpu_data_) { + int initial_device; + cudaGetDevice(&initial_device); + if (gpu_device_ != -1) { + CUDA_CHECK(cudaSetDevice(gpu_device_)); + } + CUDA_CHECK(cudaFree(gpu_ptr_)); + cudaSetDevice(initial_device); + } + gpu_ptr_ = data; + head_ = HEAD_AT_GPU; + own_gpu_data_ = false; +#else + NO_GPU; +#endif +} + void* SyncedMemory::mutable_cpu_data() { to_cpu(); head_ = HEAD_AT_CPU; @@ -112,7 +142,9 @@ void* SyncedMemory::mutable_gpu_data() { void SyncedMemory::async_gpu_push(const cudaStream_t& stream) { CHECK(head_ == HEAD_AT_CPU); if (gpu_ptr_ == NULL) { + CUDA_CHECK(cudaGetDevice(&gpu_device_)); CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_)); + own_gpu_data_ = true; } const cudaMemcpyKind put = cudaMemcpyHostToDevice; CUDA_CHECK(cudaMemcpyAsync(gpu_ptr_, cpu_ptr_, size_, put, stream)); diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index eaa7a759b9b..1cede07f774 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -8,6 +8,7 @@ #include "gtest/gtest.h" #include "caffe/common.hpp" +#include "caffe/parallel.hpp" #include "caffe/proto/caffe.pb.h" #include "caffe/solver.hpp" #include "caffe/util/io.hpp" @@ -35,6 +36,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { string snapshot_prefix_; shared_ptr > solver_; + shared_ptr > sync_; int seed_; // Dimensions are determined by generate_sample_data.py // TODO this is brittle and the hdf5 file should be checked instead. @@ -70,8 +72,8 @@ class GradientBasedSolverTest : public MultiDeviceTest { string RunLeastSquaresSolver(const Dtype learning_rate, const Dtype weight_decay, const Dtype momentum, const int num_iters, - const int iter_size = 1, const bool snapshot = false, - const char* from_snapshot = NULL) { + const int iter_size = 1, const int devices = 1, + const bool snapshot = false, const char* from_snapshot = NULL) { ostringstream proto; proto << "snapshot_after_train: " << snapshot << " " @@ -184,7 +186,20 @@ class GradientBasedSolverTest : public MultiDeviceTest { this->solver_->net()->Forward(empty_bottom_vec); } } - this->solver_->Solve(); + if (devices == 1) { + this->solver_->Solve(); + } else { + LOG(INFO) << "Multi-GPU test on " << devices << " devices"; + vector gpus; + for (int i = 0; i < devices; ++i) { + gpus.push_back(i); + } + Caffe::set_solver_count(gpus.size()); + this->sync_.reset(new P2PSync( + this->solver_, NULL, this->solver_->param())); + this->sync_->run(gpus); + Caffe::set_solver_count(1); + } if (snapshot) { ostringstream resume_file; resume_file << snapshot_prefix_ << "/_iter_" << num_iters @@ -410,20 +425,38 @@ class GradientBasedSolverTest : public MultiDeviceTest { void TestLeastSquaresUpdate(const Dtype learning_rate = 1.0, const Dtype weight_decay = 0.0, const Dtype momentum = 0.0, const int iter_to_check = 0) { - // Initialize the solver and run K (= iter_to_check) solver iterations. - RunLeastSquaresSolver(learning_rate, weight_decay, momentum, iter_to_check); - - // Compute the (K+1)th update using the analytic least squares gradient. - vector > > updated_params; - ComputeLeastSquaresUpdate(learning_rate, weight_decay, momentum, - &updated_params); - - // Reinitialize the solver and run K+1 solver iterations. - RunLeastSquaresSolver(learning_rate, weight_decay, momentum, - iter_to_check + 1); - - // Check that the solver's solution matches ours. - CheckLeastSquaresUpdate(updated_params); + const int kNum = num_; + const int kIterSize = 1; + // Test over all numbers of devices. + int available_devices = 1; +#ifndef CPU_ONLY + if (Caffe::mode() == Caffe::GPU) { + CUDA_CHECK(cudaGetDeviceCount(&available_devices)); + } +#endif + for (int devices = 1; devices <= available_devices; ++devices) { + // Configure batch size for single / multi device equivalence. + // Constant data is needed for multi device as for accumulation. + num_ = kNum * devices; + + // Initialize the solver and run K (= iter_to_check) solver iterations + // (on single device). + RunLeastSquaresSolver(learning_rate, weight_decay, momentum, + iter_to_check, kIterSize, 1); + + // Compute the (K+1)th update using the analytic least squares gradient. + vector > > updated_params; + ComputeLeastSquaresUpdate(learning_rate, weight_decay, momentum, + &updated_params); + + // Reinitialize the solver and run K+1 solver iterations. + num_ = kNum; + RunLeastSquaresSolver(learning_rate, weight_decay, momentum, + iter_to_check + 1, kIterSize, devices); + + // Check that the solver's solution matches ours. + CheckLeastSquaresUpdate(updated_params); + } } void TestSnapshot(const Dtype learning_rate = 1.0, @@ -433,8 +466,9 @@ class GradientBasedSolverTest : public MultiDeviceTest { const int total_num_iters = num_iters * 2; bool snapshot = false; const int kIterSize = 1; + const int kDevices = 1; RunLeastSquaresSolver(learning_rate, weight_decay, momentum, - total_num_iters, kIterSize, snapshot); + total_num_iters, kIterSize, kDevices, snapshot); // Save the resulting param values. vector > > param_copies; @@ -464,12 +498,13 @@ class GradientBasedSolverTest : public MultiDeviceTest { // Run the solver for num_iters iterations and snapshot. snapshot = true; string snapshot_name = RunLeastSquaresSolver(learning_rate, weight_decay, - momentum, num_iters, kIterSize, snapshot); + momentum, num_iters, kIterSize, kDevices, snapshot); // Reinitialize the solver and run for num_iters more iterations. snapshot = false; RunLeastSquaresSolver(learning_rate, weight_decay, momentum, - total_num_iters, kIterSize, snapshot, snapshot_name.c_str()); + total_num_iters, kIterSize, kDevices, + snapshot, snapshot_name.c_str()); // Check that params now match. const vector*>& params = solver_->net()->learnable_params(); diff --git a/src/caffe/util/blocking_queue.cpp b/src/caffe/util/blocking_queue.cpp index f7c53f22225..d1d1fa864c3 100644 --- a/src/caffe/util/blocking_queue.cpp +++ b/src/caffe/util/blocking_queue.cpp @@ -3,6 +3,7 @@ #include "caffe/data_layers.hpp" #include "caffe/data_reader.hpp" +#include "caffe/parallel.hpp" #include "caffe/util/blocking_queue.hpp" namespace caffe { @@ -89,5 +90,7 @@ template class BlockingQueue*>; template class BlockingQueue*>; template class BlockingQueue; template class BlockingQueue >; +template class BlockingQueue*>; +template class BlockingQueue*>; } // namespace caffe diff --git a/tools/caffe.cpp b/tools/caffe.cpp index 46f99594800..9f31b37ac2b 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -17,13 +17,17 @@ using caffe::Blob; using caffe::Caffe; using caffe::Net; using caffe::Layer; +using caffe::Solver; using caffe::shared_ptr; +using caffe::string; using caffe::Timer; using caffe::vector; +using std::ostringstream; - -DEFINE_int32(gpu, -1, - "Run in GPU mode on given device ID."); +DEFINE_string(gpu, "", + "Optional; run in GPU mode on given device IDs separated by ','." + "Use '-gpu all' to run on all available GPUs. The effective training " + "batch size is multiplied by the number of devices."); DEFINE_string(solver, "", "The solver definition protocol buffer text file."); DEFINE_string(model, "", @@ -31,8 +35,8 @@ DEFINE_string(model, "", DEFINE_string(snapshot, "", "Optional; the snapshot solver state to resume training."); DEFINE_string(weights, "", - "Optional; the pretrained weights to initialize finetuning. " - "Cannot be set simultaneously with snapshot."); + "Optional; the pretrained weights to initialize finetuning, " + "separated by ','. Cannot be set simultaneously with snapshot."); DEFINE_int32(iterations, 50, "The number of iterations to run."); @@ -66,6 +70,29 @@ static BrewFunction GetBrewFunction(const caffe::string& name) { } } +// Parse GPU ids or use all available devices +static void get_gpus(vector* gpus) { + if (FLAGS_gpu == "all") { + int count = 0; +#ifndef CPU_ONLY + CUDA_CHECK(cudaGetDeviceCount(&count)); +#else + NO_GPU; +#endif + for (int i = 0; i < count; ++i) { + gpus->push_back(i); + } + } else if (FLAGS_gpu.size()) { + vector strings; + boost::split(strings, FLAGS_gpu, boost::is_any_of(",")); + for (int i = 0; i < strings.size(); ++i) { + gpus->push_back(boost::lexical_cast(strings[i])); + } + } else { + CHECK_EQ(gpus->size(), 0); + } +} + // caffe commands to call by // caffe // @@ -74,10 +101,13 @@ static BrewFunction GetBrewFunction(const caffe::string& name) { // Device Query: show diagnostic information for a GPU device. int device_query() { - CHECK_GT(FLAGS_gpu, -1) << "Need a device ID to query."; - LOG(INFO) << "Querying device ID = " << FLAGS_gpu; - caffe::Caffe::SetDevice(FLAGS_gpu); - caffe::Caffe::DeviceQuery(); + LOG(INFO) << "Querying GPUs " << FLAGS_gpu; + vector gpus; + get_gpus(&gpus); + for (int i = 0; i < gpus.size(); ++i) { + caffe::Caffe::SetDevice(gpus[i]); + caffe::Caffe::DeviceQuery(); + } return 0; } RegisterBrewFunction(device_query); @@ -106,34 +136,49 @@ int train() { caffe::SolverParameter solver_param; caffe::ReadProtoFromTextFileOrDie(FLAGS_solver, &solver_param); - // If the gpu flag is not provided, allow the mode and device to be set + // If the gpus flag is not provided, allow the mode and device to be set // in the solver prototxt. - if (FLAGS_gpu < 0 + if (FLAGS_gpu.size() == 0 && solver_param.solver_mode() == caffe::SolverParameter_SolverMode_GPU) { - FLAGS_gpu = solver_param.device_id(); + if (solver_param.has_device_id()) { + FLAGS_gpu = "" + + boost::lexical_cast(solver_param.device_id()); + } else { // Set default GPU if unspecified + FLAGS_gpu = "" + boost::lexical_cast(0); + } } - // Set device id and mode - if (FLAGS_gpu >= 0) { - LOG(INFO) << "Use GPU with device ID " << FLAGS_gpu; - Caffe::SetDevice(FLAGS_gpu); - Caffe::set_mode(Caffe::GPU); - } else { - LOG(INFO) << "Use CPU."; + vector gpus; + get_gpus(&gpus); + if (gpus.size() == 0) { Caffe::set_mode(Caffe::CPU); + } else { + ostringstream s; + for (int i = 0; i < gpus.size(); ++i) { + s << (i ? ", " : "") << gpus[i]; + } + LOG(INFO) << "Using GPUs " << s.str(); + + solver_param.set_device_id(gpus[0]); + Caffe::SetDevice(gpus[0]); + Caffe::set_mode(Caffe::GPU); + Caffe::set_solver_count(gpus.size()); } - LOG(INFO) << "Starting Optimization"; - shared_ptr > - solver(caffe::GetSolver(solver_param)); + shared_ptr > solver(caffe::GetSolver(solver_param)); if (FLAGS_snapshot.size()) { LOG(INFO) << "Resuming from " << FLAGS_snapshot; - solver->Solve(FLAGS_snapshot); + solver->Restore(FLAGS_snapshot.c_str()); } else if (FLAGS_weights.size()) { - CopyLayers(&*solver, FLAGS_weights); - solver->Solve(); + CopyLayers(solver.get(), FLAGS_weights); + } + + if (gpus.size() > 1) { + caffe::P2PSync sync(solver, NULL, solver->param()); + sync.run(gpus); } else { + LOG(INFO) << "Starting Optimization"; solver->Solve(); } LOG(INFO) << "Optimization Done."; @@ -148,9 +193,11 @@ int test() { CHECK_GT(FLAGS_weights.size(), 0) << "Need model weights to score."; // Set device id and mode - if (FLAGS_gpu >= 0) { - LOG(INFO) << "Use GPU with device ID " << FLAGS_gpu; - Caffe::SetDevice(FLAGS_gpu); + vector gpus; + get_gpus(&gpus); + if (gpus.size() != 0) { + LOG(INFO) << "Use GPU with device ID " << gpus[0]; + Caffe::SetDevice(gpus[0]); Caffe::set_mode(Caffe::GPU); } else { LOG(INFO) << "Use CPU."; @@ -213,9 +260,11 @@ int time() { CHECK_GT(FLAGS_model.size(), 0) << "Need a model definition to time."; // Set device id and mode - if (FLAGS_gpu >= 0) { - LOG(INFO) << "Use GPU with device ID " << FLAGS_gpu; - Caffe::SetDevice(FLAGS_gpu); + vector gpus; + get_gpus(&gpus); + if (gpus.size() != 0) { + LOG(INFO) << "Use GPU with device ID " << gpus[0]; + Caffe::SetDevice(gpus[0]); Caffe::set_mode(Caffe::GPU); } else { LOG(INFO) << "Use CPU."; From 335bee737cb2e715abe685e6029afc83ccd8f404 Mon Sep 17 00:00:00 2001 From: mhouston Date: Fri, 10 Jul 2015 16:05:48 -0700 Subject: [PATCH 138/331] Detect topology corner cases and improve broadcast order - Start with distant nodes in broadcast - Fix outside loop to loop for full tree depth --- src/caffe/parallel.cpp | 73 ++++++++++++++++++++++++------------------ 1 file changed, 41 insertions(+), 32 deletions(-) diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index 3fef8cfdb33..5a08df6c1c8 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -119,18 +119,23 @@ void DevicePair::compute(const vector devices, vector* pairs) { #ifndef CPU_ONLY vector remaining(devices); + // Depth for reduction tree + int remaining_depth = static_cast(ceil(log2(remaining.size()))); + // Group GPUs by board - for (int i = 0; i < remaining.size(); ++i) { - for (int j = i + 1; j < remaining.size(); ++j) { - cudaDeviceProp a, b; - CUDA_CHECK(cudaGetDeviceProperties(&a, remaining[i])); - CUDA_CHECK(cudaGetDeviceProperties(&b, remaining[j])); - if (a.isMultiGpuBoard && b.isMultiGpuBoard) { - if (a.multiGpuBoardGroupID == b.multiGpuBoardGroupID) { - pairs->push_back(DevicePair(remaining[i], remaining[j])); - DLOG(INFO) << "GPU board: " << remaining[i] << ":" << remaining[j]; - remaining.erase(remaining.begin() + j); - break; + for (int d = 0; d < remaining_depth; ++d) { + for (int i = 0; i < remaining.size(); ++i) { + for (int j = i + 1; j < remaining.size(); ++j) { + cudaDeviceProp a, b; + CUDA_CHECK(cudaGetDeviceProperties(&a, remaining[i])); + CUDA_CHECK(cudaGetDeviceProperties(&b, remaining[j])); + if (a.isMultiGpuBoard && b.isMultiGpuBoard) { + if (a.multiGpuBoardGroupID == b.multiGpuBoardGroupID) { + pairs->push_back(DevicePair(remaining[i], remaining[j])); + DLOG(INFO) << "GPU board: " << remaining[i] << ":" << remaining[j]; + remaining.erase(remaining.begin() + j); + break; + } } } } @@ -142,15 +147,19 @@ void DevicePair::compute(const vector devices, vector* pairs) { DLOG(INFO) << "GPUs paired by boards, remaining: " << s.str(); // Group by P2P accessibility - for (int i = 0; i < remaining.size(); ++i) { - for (int j = i + 1; j < remaining.size(); ++j) { - int access; - CUDA_CHECK(cudaDeviceCanAccessPeer(&access, remaining[i], remaining[j])); - if (access) { - pairs->push_back(DevicePair(remaining[i], remaining[j])); - DLOG(INFO) << "P2P pair: " << remaining[i] << ":" << remaining[j]; - remaining.erase(remaining.begin() + j); - break; + remaining_depth = ceil(log2(remaining.size())); + for (int d = 0; d < remaining_depth; ++d) { + for (int i = 0; i < remaining.size(); ++i) { + for (int j = i + 1; j < remaining.size(); ++j) { + int access; + CUDA_CHECK( + cudaDeviceCanAccessPeer(&access, remaining[i], remaining[j])); + if (access) { + pairs->push_back(DevicePair(remaining[i], remaining[j])); + DLOG(INFO) << "P2P pair: " << remaining[i] << ":" << remaining[j]; + remaining.erase(remaining.begin() + j); + break; + } } } } @@ -161,15 +170,19 @@ void DevicePair::compute(const vector devices, vector* pairs) { DLOG(INFO) << "GPUs paired by P2P access, remaining: " << s.str(); // Group remaining - for (int i = 0; i < remaining.size(); ++i) { - for (int j = i + 1; j < remaining.size(); ++j) { - pairs->push_back(DevicePair(remaining[i], remaining[j])); - DLOG(INFO) << "Remaining pair: " << remaining[i] << ":" << remaining[j]; - remaining.erase(remaining.begin() + j); - break; + remaining_depth = ceil(log2(remaining.size())); + for (int d = 0; d < remaining_depth; ++d) { + for (int i = 0; i < remaining.size(); ++i) { + pairs->push_back(DevicePair(remaining[i], remaining[i + 1])); + DLOG(INFO) << "Remaining pair: " << remaining[i] << ":" + << remaining[i + 1]; + remaining.erase(remaining.begin() + i + 1); } } + + // Should only be the parent node remaining CHECK_EQ(remaining.size(), 1); + pairs->insert(pairs->begin(), DevicePair(-1, remaining[0])); CHECK(pairs->size() == devices.size()); @@ -289,7 +302,7 @@ void P2PSync::on_start() { } // Update children - for (int i = 0; i < children_.size(); ++i) { + for (int i = children_.size() - 1; i >= 0; i--) { Dtype* src = data_; Dtype* dst = children_[i]->data_; @@ -301,13 +314,9 @@ void P2PSync::on_start() { CHECK(attributes.device == children_[i]->solver_->param().device_id()); #endif - CUDA_CHECK(cudaMemcpyAsync(dst, src, size_ * sizeof(Dtype), // + CUDA_CHECK(cudaMemcpyAsync(dst, src, size_ * sizeof(Dtype), cudaMemcpyDeviceToDevice, cudaStreamDefault)); - } - if (children_.size()) { CUDA_CHECK(cudaStreamSynchronize(cudaStreamDefault)); - } - for (int i = 0; i < children_.size(); ++i) { children_[i]->queue_.push(this); } #endif From 8771d0f4317fc0081d86b7637f5f5ceef5b92dfb Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Fri, 7 Aug 2015 13:56:49 -0700 Subject: [PATCH 139/331] [docs] add multi-gpu usage note to interfaces --- docs/tutorial/interfaces.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/docs/tutorial/interfaces.md b/docs/tutorial/interfaces.md index 40602948cc3..9006179d0f1 100644 --- a/docs/tutorial/interfaces.md +++ b/docs/tutorial/interfaces.md @@ -50,6 +50,13 @@ For a full example of fine-tuning, see examples/finetuning_on_flickr_style, but # query the first device caffe device_query -gpu 0 +**Parallelism**: the `-gpu` flag to the `caffe` tool can take a comma separated list of IDs to run on multiple GPUs. A solver and net will be instantiated for each GPU so the batch size is effectively multiplied by the number of GPUs. To reproduce single GPU training, reduce the batch size in the network definition accordingly. + + # train on GPUs 0 & 1 (doubling the batch size) + caffe train -solver examples/mnist/lenet_solver.prototxt -gpu 0,1 + # train on all GPUs (multiplying batch size by number of devices) + caffe train -solver examples/mnist/lenet_solver.prototxt -gpu all + ## Python The Python interface -- pycaffe -- is the `caffe` module and its scripts in caffe/python. `import caffe` to load models, do forward and backward, handle IO, visualize networks, and even instrument model solving. All model data, derivatives, and parameters are exposed for reading and writing. From 1ce3380f172336cadaa649a6e077a42a246a534d Mon Sep 17 00:00:00 2001 From: Mohamed Omran Date: Sat, 20 Sep 2014 19:01:28 +0200 Subject: [PATCH 140/331] Implement AdaDelta; add test cases; add mnist examples --- examples/mnist/lenet_adadelta_solver.prototxt | 22 ++ ...mnist_autoencoder_solver_adadelta.prototxt | 17 ++ .../mnist/train_mnist_autoencoder_adadelta.sh | 4 + include/caffe/solver.hpp | 23 ++ src/caffe/proto/caffe.proto | 1 + src/caffe/solver.cpp | 199 ++++++++++++++++++ src/caffe/test/test_gradient_based_solver.cpp | 100 ++++++++- 7 files changed, 364 insertions(+), 2 deletions(-) create mode 100644 examples/mnist/lenet_adadelta_solver.prototxt create mode 100644 examples/mnist/mnist_autoencoder_solver_adadelta.prototxt create mode 100755 examples/mnist/train_mnist_autoencoder_adadelta.sh diff --git a/examples/mnist/lenet_adadelta_solver.prototxt b/examples/mnist/lenet_adadelta_solver.prototxt new file mode 100644 index 00000000000..b77b451d56a --- /dev/null +++ b/examples/mnist/lenet_adadelta_solver.prototxt @@ -0,0 +1,22 @@ +# The train/test net protocol buffer definition +net: "examples/mnist/lenet_train_test.prototxt" +# test_iter specifies how many forward passes the test should carry out. +# In the case of MNIST, we have test batch size 100 and 100 test iterations, +# covering the full 10,000 testing images. +test_iter: 100 +# Carry out testing every 500 training iterations. +test_interval: 500 +# The base learning rate, momentum and the weight decay of the network. +momentum: 0.95 +weight_decay: 0.0005 +# Display every 100 iterations +display: 100 +# The maximum number of iterations +max_iter: 10000 +# snapshot intermediate results +snapshot: 5000 +snapshot_prefix: "examples/mnist/lenet_adadelta" +# solver mode: CPU or GPU +solver_mode: GPU +solver_type: ADADELTA +delta: 1e-6 diff --git a/examples/mnist/mnist_autoencoder_solver_adadelta.prototxt b/examples/mnist/mnist_autoencoder_solver_adadelta.prototxt new file mode 100644 index 00000000000..cc4f0bbb4a7 --- /dev/null +++ b/examples/mnist/mnist_autoencoder_solver_adadelta.prototxt @@ -0,0 +1,17 @@ +net: "examples/mnist/mnist_autoencoder.prototxt" +test_state: { stage: 'test-on-train' } +test_iter: 500 +test_state: { stage: 'test-on-test' } +test_iter: 100 +test_interval: 500 +test_compute_loss: true +momentum: 0.95 +display: 100 +max_iter: 65000 +weight_decay: 0.0005 +snapshot: 10000 +snapshot_prefix: "examples/mnist/mnist_autoencoder_adadelta_train" +# solver mode: CPU or GPU +solver_mode: GPU +solver_type: ADADELTA +delta: 1e-8 diff --git a/examples/mnist/train_mnist_autoencoder_adadelta.sh b/examples/mnist/train_mnist_autoencoder_adadelta.sh new file mode 100755 index 00000000000..4be0ebddedc --- /dev/null +++ b/examples/mnist/train_mnist_autoencoder_adadelta.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +./build/tools/caffe train \ + --solver=examples/mnist/mnist_autoencoder_solver_adadelta.prototxt diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index fbade9389ff..4b408380119 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -158,6 +158,27 @@ class RMSPropSolver : public SGDSolver { DISABLE_COPY_AND_ASSIGN(RMSPropSolver); }; +template +class AdaDeltaSolver : public SGDSolver { + public: + explicit AdaDeltaSolver(const SolverParameter& param) + : SGDSolver(param) { constructor_sanity_check(); } + explicit AdaDeltaSolver(const string& param_file) + : SGDSolver(param_file) { constructor_sanity_check(); } + + protected: + virtual void PreSolve(); + virtual void ComputeUpdateValue(); + void constructor_sanity_check() { + CHECK_EQ(0, this->param_.base_lr()) + << "Learning rate cannot be used with AdaDelta."; + CHECK_EQ("", this->param_.lr_policy()) + << "Learning rate policy cannot be applied to AdaDelta."; + } + + DISABLE_COPY_AND_ASSIGN(AdaDeltaSolver); +}; + template Solver* GetSolver(const SolverParameter& param) { SolverParameter_SolverType type = param.solver_type(); @@ -171,6 +192,8 @@ Solver* GetSolver(const SolverParameter& param) { return new AdaGradSolver(param); case SolverParameter_SolverType_RMSPROP: return new RMSPropSolver(param); + case SolverParameter_SolverType_ADADELTA: + return new AdaDeltaSolver(param); default: LOG(FATAL) << "Unknown SolverType: " << type; } diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 89f14595ba6..7cfcaa8bac7 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -215,6 +215,7 @@ message SolverParameter { NESTEROV = 1; ADAGRAD = 2; RMSPROP = 3; + ADADELTA = 4; } optional SolverType solver_type = 30 [default = SGD]; // numerical stability for AdaGrad diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 54e085a63e5..d8749a1b939 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -934,10 +934,209 @@ void RMSPropSolver::ComputeUpdateValue(int param_id, Dtype rate) { } } +template +void AdaDeltaSolver::PreSolve() { + // Initialize the history + vector > >& net_params = this->net_->params(); + this->history_.clear(); + this->update_.clear(); + this->temp_.clear(); + for (int i = 0; i < net_params.size(); ++i) { + const Blob* net_param = net_params[i].get(); + this->history_.push_back(shared_ptr >(new Blob( + net_param->num(), net_param->channels(), net_param->height(), + net_param->width()))); + this->update_.push_back(shared_ptr >(new Blob( + net_param->num(), net_param->channels(), net_param->height(), + net_param->width()))); + this->temp_.push_back(shared_ptr >(new Blob( + net_param->num(), net_param->channels(), net_param->height(), + net_param->width()))); + } + for (int i = 0; i < net_params.size(); ++i) { + const Blob* net_param = net_params[i].get(); + this->history_.push_back(shared_ptr >(new Blob( + net_param->num(), net_param->channels(), net_param->height(), + net_param->width()))); + } +} + +template +void AdaDeltaSolver::ComputeUpdateValue() { + vector > >& net_params = this->net_->params(); + vector& net_params_weight_decay = this->net_->params_weight_decay(); + Dtype delta = this->param_.delta(); + Dtype momentum = this->param_.momentum(); + Dtype weight_decay = this->param_.weight_decay(); + string regularization_type = this->param_.regularization_type(); + size_t update_history_offset = net_params.size(); + switch (Caffe::mode()) { + case Caffe::CPU: + for (int param_id = 0; param_id < net_params.size(); ++param_id) { + Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; + + if (local_decay) { + if (regularization_type == "L2") { + // add weight decay + caffe_axpy(net_params[param_id]->count(), + local_decay, + net_params[param_id]->cpu_data(), + net_params[param_id]->mutable_cpu_diff()); + } else if (regularization_type == "L1") { + caffe_cpu_sign(net_params[param_id]->count(), + net_params[param_id]->cpu_data(), + this->temp_[param_id]->mutable_cpu_data()); + caffe_axpy(net_params[param_id]->count(), + local_decay, + this->temp_[param_id]->cpu_data(), + net_params[param_id]->mutable_cpu_diff()); + } else { + LOG(FATAL) << "Unknown regularization type: " << regularization_type; + } + } + + // compute square of gradient in update + caffe_powx(net_params[param_id]->count(), + net_params[param_id]->cpu_diff(), Dtype(2), + this->update_[param_id]->mutable_cpu_data()); + + // update history of gradients + caffe_cpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, + this->update_[param_id]->cpu_data(), momentum, + this->history_[param_id]->mutable_cpu_data()); + + // add delta to history to guard against dividing by zero later + caffe_set(net_params[param_id]->count(), delta, + this->temp_[param_id]->mutable_cpu_data()); + + caffe_add(net_params[param_id]->count(), + this->temp_[param_id]->cpu_data(), + this->history_[update_history_offset + param_id]->cpu_data(), + this->update_[param_id]->mutable_cpu_data()); + + caffe_add(net_params[param_id]->count(), + this->temp_[param_id]->cpu_data(), + this->history_[param_id]->cpu_data(), + this->temp_[param_id]->mutable_cpu_data()); + + // divide history of updates by history of gradients + caffe_div(net_params[param_id]->count(), + this->update_[param_id]->cpu_data(), + this->temp_[param_id]->cpu_data(), + this->update_[param_id]->mutable_cpu_data()); + + // jointly compute the RMS of both for update and gradient history + caffe_powx(net_params[param_id]->count(), + this->update_[param_id]->cpu_data(), Dtype(0.5), + this->update_[param_id]->mutable_cpu_data()); + + // compute the update + caffe_mul(net_params[param_id]->count(), + net_params[param_id]->cpu_diff(), + this->update_[param_id]->cpu_data(), + net_params[param_id]->mutable_cpu_diff()); + + // compute square of update + caffe_powx(net_params[param_id]->count(), + net_params[param_id]->cpu_diff(), Dtype(2), + this->update_[param_id]->mutable_cpu_data()); + + // update history of updates + caffe_cpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, + this->update_[param_id]->cpu_data(), momentum, + this->history_[update_history_offset + param_id]->mutable_cpu_data()); + } + break; + case Caffe::GPU: +#ifndef CPU_ONLY + for (int param_id = 0; param_id < net_params.size(); ++param_id) { + Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; + + if (local_decay) { + if (regularization_type == "L2") { + // add weight decay + caffe_gpu_axpy(net_params[param_id]->count(), + local_decay, + net_params[param_id]->gpu_data(), + net_params[param_id]->mutable_gpu_diff()); + } else if (regularization_type == "L1") { + caffe_gpu_sign(net_params[param_id]->count(), + net_params[param_id]->gpu_data(), + this->temp_[param_id]->mutable_gpu_data()); + caffe_gpu_axpy(net_params[param_id]->count(), + local_decay, + this->temp_[param_id]->gpu_data(), + net_params[param_id]->mutable_gpu_diff()); + } else { + LOG(FATAL) << "Unknown regularization type: " << regularization_type; + } + } + + // compute square of gradient in update + caffe_gpu_powx(net_params[param_id]->count(), + net_params[param_id]->gpu_diff(), Dtype(2), + this->update_[param_id]->mutable_gpu_data()); + + // update history of gradients + caffe_gpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, + this->update_[param_id]->gpu_data(), momentum, + this->history_[param_id]->mutable_gpu_data()); + + // add delta to history to guard against dividing by zero later + caffe_gpu_set(net_params[param_id]->count(), delta, + this->temp_[param_id]->mutable_gpu_data()); + + caffe_gpu_add(net_params[param_id]->count(), + this->temp_[param_id]->gpu_data(), + this->history_[update_history_offset + param_id]->gpu_data(), + this->update_[param_id]->mutable_gpu_data()); + + caffe_gpu_add(net_params[param_id]->count(), + this->temp_[param_id]->gpu_data(), + this->history_[param_id]->gpu_data(), + this->temp_[param_id]->mutable_gpu_data()); + + // divide history of updates by history of gradients + caffe_gpu_div(net_params[param_id]->count(), + this->update_[param_id]->gpu_data(), + this->temp_[param_id]->gpu_data(), + this->update_[param_id]->mutable_gpu_data()); + + // jointly compute the RMS of both for update and gradient history + caffe_gpu_powx(net_params[param_id]->count(), + this->update_[param_id]->gpu_data(), Dtype(0.5), + this->update_[param_id]->mutable_gpu_data()); + + // compute the update and copy to net_diff + caffe_gpu_mul(net_params[param_id]->count(), + net_params[param_id]->gpu_diff(), + this->update_[param_id]->gpu_data(), + net_params[param_id]->mutable_gpu_diff()); + + // compute square of update + caffe_gpu_powx(net_params[param_id]->count(), + net_params[param_id]->gpu_diff(), Dtype(2), + this->update_[param_id]->mutable_gpu_data()); + + // update history of updates + caffe_gpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, + this->update_[param_id]->gpu_data(), momentum, + this->history_[update_history_offset + param_id]->mutable_gpu_data()); + } +#else + NO_GPU; +#endif + break; + default: + LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode(); + } +} + INSTANTIATE_CLASS(Solver); INSTANTIATE_CLASS(SGDSolver); INSTANTIATE_CLASS(NesterovSolver); INSTANTIATE_CLASS(AdaGradSolver); INSTANTIATE_CLASS(RMSPropSolver); +INSTANTIATE_CLASS(AdaDeltaSolver); } // namespace caffe diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index eaa7a759b9b..db89e285a9f 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -64,7 +64,8 @@ class GradientBasedSolverTest : public MultiDeviceTest { } InitSolver(param); delta_ = (solver_type() == SolverParameter_SolverType_ADAGRAD || - solver_type() == SolverParameter_SolverType_RMSPROP) ? + solver_type() == SolverParameter_SolverType_RMSPROP || + solver_type() == SolverParameter_SolverType_ADADELTA) ? param.delta() : 0; } @@ -164,6 +165,10 @@ class GradientBasedSolverTest : public MultiDeviceTest { " bottom: 'targets' " " } " "} "; + if (learning_rate != 0) { + proto << "base_lr: " << learning_rate << " "; + proto << "lr_policy: 'fixed' "; + } if (weight_decay != 0) { proto << "weight_decay: " << weight_decay << " "; } @@ -266,7 +271,11 @@ class GradientBasedSolverTest : public MultiDeviceTest { ((i == D) ? bias.cpu_data()[0] : weights.cpu_data()[i]); // Finally, compute update. const vector > >& history = solver_->history(); - ASSERT_EQ(2, history.size()); // 1 blob for weights, 1 for bias + if (solver_type() != SolverParameter_SolverType_ADADELTA) { + ASSERT_EQ(2, history.size()); // 1 blob for weights, 1 for bias + } else { + ASSERT_EQ(4, history.size()); // additional blobs for update history + } Dtype update_value = learning_rate * grad; const Dtype history_value = (i == D) ? history[1]->cpu_data()[0] : history[0]->cpu_data()[i]; @@ -289,6 +298,19 @@ class GradientBasedSolverTest : public MultiDeviceTest { + grad * grad * (1 - rms_decay)) + delta_; } break; + case SolverParameter_SolverType_ADADELTA: + { + const Dtype update_history_value = (i == D) ? + history[3]->cpu_data()[0] : history[2]->cpu_data()[i]; + const Dtype weighted_gradient_average = + momentum * history_value + (1 - momentum) * (grad * grad); + update_value = grad * std::sqrt((update_history_value + delta_) / + (weighted_gradient_average + delta_)); + // not actually needed, just here for illustrative purposes + // const Dtype weighted_update_average = + // momentum * update_history_value + (1 - momentum) * (update_value); + break; + } default: LOG(FATAL) << "Unknown solver type: " << solver_type(); } @@ -981,4 +1003,78 @@ TYPED_TEST(RMSPropSolverTest, TestSnapshotShare) { } } +template +class AdaDeltaSolverTest : public GradientBasedSolverTest { + typedef typename TypeParam::Dtype Dtype; + + protected: + virtual void InitSolver(const SolverParameter& param) { + this->solver_.reset(new AdaDeltaSolver(param)); + } + + virtual SolverParameter_SolverType solver_type() { + return SolverParameter_SolverType_ADADELTA; + } +}; + +TYPED_TEST_CASE(AdaDeltaSolverTest, TestDtypesAndDevices); + +TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdate) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.0; + this->TestLeastSquaresUpdate(kLearningRate); +} + +TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithWeightDecay) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.0; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.95; + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); +} + +TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithHalfMomentum) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.0; + const Dtype kWeightDecay = 0.0; + const Dtype kMomentum = 0.5; + const int kNumIters = 1; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); + } +} + +TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithMomentum) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.0; + const Dtype kWeightDecay = 0.0; + const Dtype kMomentum = 0.95; + const int kNumIters = 1; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); + } +} + +TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.0; + const Dtype kWeightDecay = 0.0; + const Dtype kMomentum = 0.95; + const int kNumIters = 500; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + +TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithEverything) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.0; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.95; + const int kNumIters = 500; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + } // namespace caffe From 4c58741ce2e031b61aef53914128801e6edd673d Mon Sep 17 00:00:00 2001 From: Kevin Bache Date: Thu, 19 Mar 2015 15:56:51 -0700 Subject: [PATCH 141/331] Updated AdaDelta for modern Caffe; reduced iterations on multi-iter tests --- ...mnist_autoencoder_solver_adadelta.prototxt | 2 +- include/caffe/solver.hpp | 6 ++-- src/caffe/solver.cpp | 32 ++++++------------- src/caffe/test/test_gradient_based_solver.cpp | 4 +-- 4 files changed, 15 insertions(+), 29 deletions(-) diff --git a/examples/mnist/mnist_autoencoder_solver_adadelta.prototxt b/examples/mnist/mnist_autoencoder_solver_adadelta.prototxt index cc4f0bbb4a7..4e43468a71f 100644 --- a/examples/mnist/mnist_autoencoder_solver_adadelta.prototxt +++ b/examples/mnist/mnist_autoencoder_solver_adadelta.prototxt @@ -6,6 +6,7 @@ test_iter: 100 test_interval: 500 test_compute_loss: true momentum: 0.95 +delta: 1e-8 display: 100 max_iter: 65000 weight_decay: 0.0005 @@ -14,4 +15,3 @@ snapshot_prefix: "examples/mnist/mnist_autoencoder_adadelta_train" # solver mode: CPU or GPU solver_mode: GPU solver_type: ADADELTA -delta: 1e-8 diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index 4b408380119..495cd4f159e 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -82,12 +82,12 @@ class SGDSolver : public Solver { const vector > >& history() { return history_; } protected: - void PreSolve(); Dtype GetLearningRate(); virtual void ApplyUpdate(); virtual void Normalize(int param_id); virtual void Regularize(int param_id); virtual void ComputeUpdateValue(int param_id, Dtype rate); + virtual void PreSolve(); virtual void ClipGradients(); virtual void SnapshotSolverState(const string& model_filename); virtual void SnapshotSolverStateToBinaryProto(const string& model_filename); @@ -162,9 +162,9 @@ template class AdaDeltaSolver : public SGDSolver { public: explicit AdaDeltaSolver(const SolverParameter& param) - : SGDSolver(param) { constructor_sanity_check(); } + : SGDSolver(param) { PreSolve(); constructor_sanity_check(); } explicit AdaDeltaSolver(const string& param_file) - : SGDSolver(param_file) { constructor_sanity_check(); } + : SGDSolver(param_file) { PreSolve(); constructor_sanity_check(); } protected: virtual void PreSolve(); diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index d8749a1b939..34a290ffe3d 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -936,35 +936,21 @@ void RMSPropSolver::ComputeUpdateValue(int param_id, Dtype rate) { template void AdaDeltaSolver::PreSolve() { - // Initialize the history - vector > >& net_params = this->net_->params(); - this->history_.clear(); - this->update_.clear(); - this->temp_.clear(); - for (int i = 0; i < net_params.size(); ++i) { - const Blob* net_param = net_params[i].get(); - this->history_.push_back(shared_ptr >(new Blob( - net_param->num(), net_param->channels(), net_param->height(), - net_param->width()))); - this->update_.push_back(shared_ptr >(new Blob( - net_param->num(), net_param->channels(), net_param->height(), - net_param->width()))); - this->temp_.push_back(shared_ptr >(new Blob( - net_param->num(), net_param->channels(), net_param->height(), - net_param->width()))); - } + // Add the extra history entries for AdaDelta after those from + // SGDSolver::PreSolve + const vector > >& net_params = this->net_->params(); for (int i = 0; i < net_params.size(); ++i) { - const Blob* net_param = net_params[i].get(); - this->history_.push_back(shared_ptr >(new Blob( - net_param->num(), net_param->channels(), net_param->height(), - net_param->width()))); + const vector& shape = net_params[i]->shape(); + this->history_.push_back( + shared_ptr >(new Blob(shape))); } } template void AdaDeltaSolver::ComputeUpdateValue() { - vector > >& net_params = this->net_->params(); - vector& net_params_weight_decay = this->net_->params_weight_decay(); + const vector > >& net_params = this->net_->params(); + const vector& net_params_weight_decay = + this->net_->params_weight_decay(); Dtype delta = this->param_.delta(); Dtype momentum = this->param_.momentum(); Dtype weight_decay = this->param_.weight_decay(); diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index db89e285a9f..277aa3a5c8e 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -1060,7 +1060,7 @@ TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { const Dtype kLearningRate = 0.0; const Dtype kWeightDecay = 0.0; const Dtype kMomentum = 0.95; - const int kNumIters = 500; + const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } @@ -1071,7 +1071,7 @@ TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithEverything) { const Dtype kLearningRate = 0.0; const Dtype kWeightDecay = 0.1; const Dtype kMomentum = 0.95; - const int kNumIters = 500; + const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } From f2e523e479b89902b644f3a8bb2ac51a6dc28eee Mon Sep 17 00:00:00 2001 From: Matthias Plappert Date: Sat, 18 Jul 2015 18:46:51 +0200 Subject: [PATCH 142/331] Clean up and modernize AdaDelta code; add learning rate support; add additional test cases --- examples/mnist/lenet_adadelta_solver.prototxt | 2 + ...mnist_autoencoder_solver_adadelta.prototxt | 2 + include/caffe/solver.hpp | 16 +- src/caffe/solver.cpp | 274 ++++++++---------- src/caffe/test/test_gradient_based_solver.cpp | 211 +++++++++----- 5 files changed, 260 insertions(+), 245 deletions(-) diff --git a/examples/mnist/lenet_adadelta_solver.prototxt b/examples/mnist/lenet_adadelta_solver.prototxt index b77b451d56a..776d1e06139 100644 --- a/examples/mnist/lenet_adadelta_solver.prototxt +++ b/examples/mnist/lenet_adadelta_solver.prototxt @@ -7,6 +7,8 @@ test_iter: 100 # Carry out testing every 500 training iterations. test_interval: 500 # The base learning rate, momentum and the weight decay of the network. +base_lr: 1.0 +lr_policy: "fixed" momentum: 0.95 weight_decay: 0.0005 # Display every 100 iterations diff --git a/examples/mnist/mnist_autoencoder_solver_adadelta.prototxt b/examples/mnist/mnist_autoencoder_solver_adadelta.prototxt index 4e43468a71f..065647df31b 100644 --- a/examples/mnist/mnist_autoencoder_solver_adadelta.prototxt +++ b/examples/mnist/mnist_autoencoder_solver_adadelta.prototxt @@ -5,6 +5,8 @@ test_state: { stage: 'test-on-test' } test_iter: 100 test_interval: 500 test_compute_loss: true +base_lr: 1.0 +lr_policy: "fixed" momentum: 0.95 delta: 1e-8 display: 100 diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index 495cd4f159e..5fefd01e549 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -82,12 +82,12 @@ class SGDSolver : public Solver { const vector > >& history() { return history_; } protected: + void PreSolve(); Dtype GetLearningRate(); virtual void ApplyUpdate(); virtual void Normalize(int param_id); virtual void Regularize(int param_id); virtual void ComputeUpdateValue(int param_id, Dtype rate); - virtual void PreSolve(); virtual void ClipGradients(); virtual void SnapshotSolverState(const string& model_filename); virtual void SnapshotSolverStateToBinaryProto(const string& model_filename); @@ -162,19 +162,13 @@ template class AdaDeltaSolver : public SGDSolver { public: explicit AdaDeltaSolver(const SolverParameter& param) - : SGDSolver(param) { PreSolve(); constructor_sanity_check(); } + : SGDSolver(param) { AdaDeltaPreSolve(); } explicit AdaDeltaSolver(const string& param_file) - : SGDSolver(param_file) { PreSolve(); constructor_sanity_check(); } + : SGDSolver(param_file) { AdaDeltaPreSolve(); } protected: - virtual void PreSolve(); - virtual void ComputeUpdateValue(); - void constructor_sanity_check() { - CHECK_EQ(0, this->param_.base_lr()) - << "Learning rate cannot be used with AdaDelta."; - CHECK_EQ("", this->param_.lr_policy()) - << "Learning rate policy cannot be applied to AdaDelta."; - } + void AdaDeltaPreSolve(); + virtual void ComputeUpdateValue(int param_id, Dtype rate); DISABLE_COPY_AND_ASSIGN(AdaDeltaSolver); }; diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 34a290ffe3d..78902ca0ebc 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -935,10 +935,10 @@ void RMSPropSolver::ComputeUpdateValue(int param_id, Dtype rate) { } template -void AdaDeltaSolver::PreSolve() { +void AdaDeltaSolver::AdaDeltaPreSolve() { // Add the extra history entries for AdaDelta after those from // SGDSolver::PreSolve - const vector > >& net_params = this->net_->params(); + const vector*>& net_params = this->net_->learnable_params(); for (int i = 0; i < net_params.size(); ++i) { const vector& shape = net_params[i]->shape(); this->history_.push_back( @@ -947,172 +947,134 @@ void AdaDeltaSolver::PreSolve() { } template -void AdaDeltaSolver::ComputeUpdateValue() { - const vector > >& net_params = this->net_->params(); - const vector& net_params_weight_decay = - this->net_->params_weight_decay(); +void AdaDeltaSolver::ComputeUpdateValue(int param_id, Dtype rate) { + const vector*>& net_params = this->net_->learnable_params(); + const vector& net_params_lr = this->net_->params_lr(); Dtype delta = this->param_.delta(); Dtype momentum = this->param_.momentum(); - Dtype weight_decay = this->param_.weight_decay(); - string regularization_type = this->param_.regularization_type(); + Dtype local_rate = rate * net_params_lr[param_id]; size_t update_history_offset = net_params.size(); switch (Caffe::mode()) { - case Caffe::CPU: - for (int param_id = 0; param_id < net_params.size(); ++param_id) { - Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; - - if (local_decay) { - if (regularization_type == "L2") { - // add weight decay - caffe_axpy(net_params[param_id]->count(), - local_decay, - net_params[param_id]->cpu_data(), - net_params[param_id]->mutable_cpu_diff()); - } else if (regularization_type == "L1") { - caffe_cpu_sign(net_params[param_id]->count(), - net_params[param_id]->cpu_data(), - this->temp_[param_id]->mutable_cpu_data()); - caffe_axpy(net_params[param_id]->count(), - local_decay, - this->temp_[param_id]->cpu_data(), - net_params[param_id]->mutable_cpu_diff()); - } else { - LOG(FATAL) << "Unknown regularization type: " << regularization_type; - } - } + case Caffe::CPU: { + // compute square of gradient in update + caffe_powx(net_params[param_id]->count(), + net_params[param_id]->cpu_diff(), Dtype(2), + this->update_[param_id]->mutable_cpu_data()); - // compute square of gradient in update - caffe_powx(net_params[param_id]->count(), - net_params[param_id]->cpu_diff(), Dtype(2), - this->update_[param_id]->mutable_cpu_data()); - - // update history of gradients - caffe_cpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, - this->update_[param_id]->cpu_data(), momentum, - this->history_[param_id]->mutable_cpu_data()); - - // add delta to history to guard against dividing by zero later - caffe_set(net_params[param_id]->count(), delta, - this->temp_[param_id]->mutable_cpu_data()); - - caffe_add(net_params[param_id]->count(), - this->temp_[param_id]->cpu_data(), - this->history_[update_history_offset + param_id]->cpu_data(), - this->update_[param_id]->mutable_cpu_data()); - - caffe_add(net_params[param_id]->count(), - this->temp_[param_id]->cpu_data(), - this->history_[param_id]->cpu_data(), - this->temp_[param_id]->mutable_cpu_data()); - - // divide history of updates by history of gradients - caffe_div(net_params[param_id]->count(), - this->update_[param_id]->cpu_data(), - this->temp_[param_id]->cpu_data(), - this->update_[param_id]->mutable_cpu_data()); - - // jointly compute the RMS of both for update and gradient history - caffe_powx(net_params[param_id]->count(), - this->update_[param_id]->cpu_data(), Dtype(0.5), - this->update_[param_id]->mutable_cpu_data()); - - // compute the update - caffe_mul(net_params[param_id]->count(), - net_params[param_id]->cpu_diff(), - this->update_[param_id]->cpu_data(), - net_params[param_id]->mutable_cpu_diff()); - - // compute square of update - caffe_powx(net_params[param_id]->count(), - net_params[param_id]->cpu_diff(), Dtype(2), - this->update_[param_id]->mutable_cpu_data()); - - // update history of updates - caffe_cpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, - this->update_[param_id]->cpu_data(), momentum, - this->history_[update_history_offset + param_id]->mutable_cpu_data()); - } + // update history of gradients + caffe_cpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, + this->update_[param_id]->cpu_data(), momentum, + this->history_[param_id]->mutable_cpu_data()); + + // add delta to history to guard against dividing by zero later + caffe_set(net_params[param_id]->count(), delta, + this->temp_[param_id]->mutable_cpu_data()); + + caffe_add(net_params[param_id]->count(), + this->temp_[param_id]->cpu_data(), + this->history_[update_history_offset + param_id]->cpu_data(), + this->update_[param_id]->mutable_cpu_data()); + + caffe_add(net_params[param_id]->count(), + this->temp_[param_id]->cpu_data(), + this->history_[param_id]->cpu_data(), + this->temp_[param_id]->mutable_cpu_data()); + + // divide history of updates by history of gradients + caffe_div(net_params[param_id]->count(), + this->update_[param_id]->cpu_data(), + this->temp_[param_id]->cpu_data(), + this->update_[param_id]->mutable_cpu_data()); + + // jointly compute the RMS of both for update and gradient history + caffe_powx(net_params[param_id]->count(), + this->update_[param_id]->cpu_data(), Dtype(0.5), + this->update_[param_id]->mutable_cpu_data()); + + // compute the update + caffe_mul(net_params[param_id]->count(), + net_params[param_id]->cpu_diff(), + this->update_[param_id]->cpu_data(), + net_params[param_id]->mutable_cpu_diff()); + + // compute square of update + caffe_powx(net_params[param_id]->count(), + net_params[param_id]->cpu_diff(), Dtype(2), + this->update_[param_id]->mutable_cpu_data()); + + // update history of updates + caffe_cpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, + this->update_[param_id]->cpu_data(), momentum, + this->history_[update_history_offset + param_id]->mutable_cpu_data()); + + // apply learning rate + caffe_cpu_scale(net_params[param_id]->count(), local_rate, + net_params[param_id]->cpu_diff(), + net_params[param_id]->mutable_cpu_diff()); break; - case Caffe::GPU: + } + case Caffe::GPU: { #ifndef CPU_ONLY - for (int param_id = 0; param_id < net_params.size(); ++param_id) { - Dtype local_decay = weight_decay * net_params_weight_decay[param_id]; - - if (local_decay) { - if (regularization_type == "L2") { - // add weight decay - caffe_gpu_axpy(net_params[param_id]->count(), - local_decay, - net_params[param_id]->gpu_data(), - net_params[param_id]->mutable_gpu_diff()); - } else if (regularization_type == "L1") { - caffe_gpu_sign(net_params[param_id]->count(), - net_params[param_id]->gpu_data(), - this->temp_[param_id]->mutable_gpu_data()); - caffe_gpu_axpy(net_params[param_id]->count(), - local_decay, - this->temp_[param_id]->gpu_data(), - net_params[param_id]->mutable_gpu_diff()); - } else { - LOG(FATAL) << "Unknown regularization type: " << regularization_type; - } - } + // compute square of gradient in update + caffe_gpu_powx(net_params[param_id]->count(), + net_params[param_id]->gpu_diff(), Dtype(2), + this->update_[param_id]->mutable_gpu_data()); - // compute square of gradient in update - caffe_gpu_powx(net_params[param_id]->count(), - net_params[param_id]->gpu_diff(), Dtype(2), - this->update_[param_id]->mutable_gpu_data()); - - // update history of gradients - caffe_gpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, - this->update_[param_id]->gpu_data(), momentum, - this->history_[param_id]->mutable_gpu_data()); - - // add delta to history to guard against dividing by zero later - caffe_gpu_set(net_params[param_id]->count(), delta, - this->temp_[param_id]->mutable_gpu_data()); - - caffe_gpu_add(net_params[param_id]->count(), - this->temp_[param_id]->gpu_data(), - this->history_[update_history_offset + param_id]->gpu_data(), - this->update_[param_id]->mutable_gpu_data()); - - caffe_gpu_add(net_params[param_id]->count(), - this->temp_[param_id]->gpu_data(), - this->history_[param_id]->gpu_data(), - this->temp_[param_id]->mutable_gpu_data()); - - // divide history of updates by history of gradients - caffe_gpu_div(net_params[param_id]->count(), - this->update_[param_id]->gpu_data(), - this->temp_[param_id]->gpu_data(), - this->update_[param_id]->mutable_gpu_data()); - - // jointly compute the RMS of both for update and gradient history - caffe_gpu_powx(net_params[param_id]->count(), - this->update_[param_id]->gpu_data(), Dtype(0.5), - this->update_[param_id]->mutable_gpu_data()); - - // compute the update and copy to net_diff - caffe_gpu_mul(net_params[param_id]->count(), - net_params[param_id]->gpu_diff(), - this->update_[param_id]->gpu_data(), - net_params[param_id]->mutable_gpu_diff()); - - // compute square of update - caffe_gpu_powx(net_params[param_id]->count(), - net_params[param_id]->gpu_diff(), Dtype(2), - this->update_[param_id]->mutable_gpu_data()); - - // update history of updates - caffe_gpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, - this->update_[param_id]->gpu_data(), momentum, - this->history_[update_history_offset + param_id]->mutable_gpu_data()); - } + // update history of gradients + caffe_gpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, + this->update_[param_id]->gpu_data(), momentum, + this->history_[param_id]->mutable_gpu_data()); + + // add delta to history to guard against dividing by zero later + caffe_gpu_set(net_params[param_id]->count(), delta, + this->temp_[param_id]->mutable_gpu_data()); + + caffe_gpu_add(net_params[param_id]->count(), + this->temp_[param_id]->gpu_data(), + this->history_[update_history_offset + param_id]->gpu_data(), + this->update_[param_id]->mutable_gpu_data()); + + caffe_gpu_add(net_params[param_id]->count(), + this->temp_[param_id]->gpu_data(), + this->history_[param_id]->gpu_data(), + this->temp_[param_id]->mutable_gpu_data()); + + // divide history of updates by history of gradients + caffe_gpu_div(net_params[param_id]->count(), + this->update_[param_id]->gpu_data(), + this->temp_[param_id]->gpu_data(), + this->update_[param_id]->mutable_gpu_data()); + + // jointly compute the RMS of both for update and gradient history + caffe_gpu_powx(net_params[param_id]->count(), + this->update_[param_id]->gpu_data(), Dtype(0.5), + this->update_[param_id]->mutable_gpu_data()); + + // compute the update and copy to net_diff + caffe_gpu_mul(net_params[param_id]->count(), + net_params[param_id]->gpu_diff(), + this->update_[param_id]->gpu_data(), + net_params[param_id]->mutable_gpu_diff()); + + // compute square of update + caffe_gpu_powx(net_params[param_id]->count(), + net_params[param_id]->gpu_diff(), Dtype(2), + this->update_[param_id]->mutable_gpu_data()); + + // update history of updates + caffe_gpu_axpby(net_params[param_id]->count(), Dtype(1) - momentum, + this->update_[param_id]->gpu_data(), momentum, + this->history_[update_history_offset + param_id]->mutable_gpu_data()); + + // apply learning rate + caffe_gpu_scale(net_params[param_id]->count(), local_rate, + net_params[param_id]->gpu_diff(), + net_params[param_id]->mutable_gpu_diff()); #else NO_GPU; #endif break; + } default: LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode(); } diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index 277aa3a5c8e..c97d4ede3b3 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -165,10 +165,6 @@ class GradientBasedSolverTest : public MultiDeviceTest { " bottom: 'targets' " " } " "} "; - if (learning_rate != 0) { - proto << "base_lr: " << learning_rate << " "; - proto << "lr_policy: 'fixed' "; - } if (weight_decay != 0) { proto << "weight_decay: " << weight_decay << " "; } @@ -897,6 +893,139 @@ TYPED_TEST(NesterovSolverTest, TestSnapshotShare) { } } +template +class AdaDeltaSolverTest : public GradientBasedSolverTest { + typedef typename TypeParam::Dtype Dtype; + + protected: + virtual void InitSolver(const SolverParameter& param) { + this->solver_.reset(new AdaDeltaSolver(param)); + } + + virtual SolverParameter_SolverType solver_type() { + return SolverParameter_SolverType_ADADELTA; + } +}; + +TYPED_TEST_CASE(AdaDeltaSolverTest, TestDtypesAndDevices); + +TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdate) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + this->TestLeastSquaresUpdate(kLearningRate); +} + +TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithWeightDecay) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.95; + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); +} + +TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithHalfMomentum) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + const Dtype kWeightDecay = 0.0; + const Dtype kMomentum = 0.5; + const int kNumIters = 1; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); + } +} + +TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithMomentum) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + const Dtype kWeightDecay = 0.0; + const Dtype kMomentum = 0.95; + const int kNumIters = 1; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); + } +} + +TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + const Dtype kWeightDecay = 0.0; + const Dtype kMomentum = 0.95; + const int kNumIters = 4; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + +TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithEverything) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.95; + const int kNumIters = 4; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + +TYPED_TEST(AdaDeltaSolverTest, + TestAdaDeltaLeastSquaresUpdateWithEverythingShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.95; + const int kNumIters = 4; + this->share_ = true; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + +TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.95; + const int kNumIters = 4; + const int kIterSize = 2; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); +} + +TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.95; + const int kNumIters = 4; + const int kIterSize = 2; + this->share_ = true; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); +} + +TYPED_TEST(AdaDeltaSolverTest, TestSnapshot) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.95; + const int kNumIters = 4; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + } +} + +TYPED_TEST(AdaDeltaSolverTest, TestSnapshotShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 1.0; + const Dtype kWeightDecay = 0.1; + const Dtype kMomentum = 0.95; + const int kNumIters = 4; + this->share_ = true; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + } +} + template class RMSPropSolverTest : public GradientBasedSolverTest { typedef typename TypeParam::Dtype Dtype; @@ -1003,78 +1132,4 @@ TYPED_TEST(RMSPropSolverTest, TestSnapshotShare) { } } -template -class AdaDeltaSolverTest : public GradientBasedSolverTest { - typedef typename TypeParam::Dtype Dtype; - - protected: - virtual void InitSolver(const SolverParameter& param) { - this->solver_.reset(new AdaDeltaSolver(param)); - } - - virtual SolverParameter_SolverType solver_type() { - return SolverParameter_SolverType_ADADELTA; - } -}; - -TYPED_TEST_CASE(AdaDeltaSolverTest, TestDtypesAndDevices); - -TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdate) { - typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 0.0; - this->TestLeastSquaresUpdate(kLearningRate); -} - -TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithWeightDecay) { - typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 0.0; - const Dtype kWeightDecay = 0.5; - const Dtype kMomentum = 0.95; - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); -} - -TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithHalfMomentum) { - typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 0.0; - const Dtype kWeightDecay = 0.0; - const Dtype kMomentum = 0.5; - const int kNumIters = 1; - for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); - } -} - -TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithMomentum) { - typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 0.0; - const Dtype kWeightDecay = 0.0; - const Dtype kMomentum = 0.95; - const int kNumIters = 1; - for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); - } -} - -TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { - typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 0.0; - const Dtype kWeightDecay = 0.0; - const Dtype kMomentum = 0.95; - const int kNumIters = 4; - for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); - } -} - -TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithEverything) { - typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 0.0; - const Dtype kWeightDecay = 0.1; - const Dtype kMomentum = 0.95; - const int kNumIters = 4; - for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); - } -} - } // namespace caffe From 918c2aca42a0e9f87dab6f7b40d648f2c41321cb Mon Sep 17 00:00:00 2001 From: mfigurnov Date: Mon, 10 Aug 2015 13:59:35 +0300 Subject: [PATCH 143/331] Fix truncation of value warning --- src/caffe/common.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index af96cac40aa..b40760efe16 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -1,4 +1,5 @@ #include +#include #include #include @@ -25,7 +26,7 @@ int64_t cluster_seedgen(void) { pid = getpid(); s = time(NULL); - seed = abs(((s * 181) * ((pid - 83) * 359)) % 104729); + seed = std::abs(((s * 181) * ((pid - 83) * 359)) % 104729); return seed; } From dde32b4ee631a647776e33ea92096558a2b37cbd Mon Sep 17 00:00:00 2001 From: Russell Stewart Date: Mon, 10 Aug 2015 13:50:01 -0700 Subject: [PATCH 144/331] Update net_spec.py --- python/caffe/net_spec.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/caffe/net_spec.py b/python/caffe/net_spec.py index 31cde7ad946..77a0e0070ae 100644 --- a/python/caffe/net_spec.py +++ b/python/caffe/net_spec.py @@ -1,7 +1,7 @@ """Python net specification. This module provides a way to write nets directly in Python, using a natural, -functional style. See examples/python_nets/caffenet.py for an example. +functional style. See examples/pycaffe/caffenet.py for an example. Currently this works as a thin wrapper around the Python protobuf interface, with layers and parameters automatically generated for the "layers" and From bd2591e31e53e159c84874d26dcfe4a45d3c904e Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Tue, 11 Aug 2015 13:18:41 -0700 Subject: [PATCH 145/331] fix for learnable_param_ids_ --- src/caffe/net.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index 0e5ed804b73..91883a10a0a 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -485,6 +485,7 @@ void Net::AppendParam(const NetParameter& param, const int layer_id, CHECK(this_blob->shape() == owner_blob->shape()); } const int learnable_param_id = learnable_param_ids_[owner_net_param_id]; + learnable_param_ids_.push_back(learnable_param_id); if (param_spec->has_lr_mult()) { if (has_params_lr_[learnable_param_id]) { CHECK_EQ(param_spec->lr_mult(), params_lr_[learnable_param_id]) From 0d34d5ba0fbdc09ac8f372cb581ccaec599f10bc Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Tue, 11 Aug 2015 21:38:06 -0700 Subject: [PATCH 146/331] Data Layers Parallel for Multi-GPU Allow data layers (and also PythonLayer when used as data layer) to be shared among worker solver's training net, and also test net for future-proof if one wants to do Multi-GPU testing. Data layers are locked during forward to ensure sequential forward. --- include/caffe/data_layers.hpp | 11 ++++++++++- include/caffe/layer.hpp | 15 +++++++++++++++ include/caffe/net.hpp | 8 +++++--- include/caffe/python_layer.hpp | 4 ++++ include/caffe/solver.hpp | 14 ++++++++++---- src/caffe/net.cpp | 32 ++++++++++++++++++++++++++++---- src/caffe/parallel.cpp | 3 +-- src/caffe/proto/caffe.proto | 4 ++++ src/caffe/solver.cpp | 23 +++++++++++++++++------ 9 files changed, 94 insertions(+), 20 deletions(-) diff --git a/include/caffe/data_layers.hpp b/include/caffe/data_layers.hpp index 12e6c366620..552d814131e 100644 --- a/include/caffe/data_layers.hpp +++ b/include/caffe/data_layers.hpp @@ -34,6 +34,8 @@ class BaseDataLayer : public Layer { // This method may not be overridden except by the BasePrefetchingDataLayer. virtual void LayerSetUp(const vector*>& bottom, const vector*>& top); + // Data layers should be shared by multiple solvers in parallel + virtual inline bool ShareInParallel() const { return true; } virtual void DataLayerSetUp(const vector*>& bottom, const vector*>& top) {} // Data layers have no bottoms, so reshaping is trivial. @@ -94,7 +96,8 @@ class DataLayer : public BasePrefetchingDataLayer { virtual ~DataLayer(); virtual void DataLayerSetUp(const vector*>& bottom, const vector*>& top); - + // DataLayer uses DataReader instead for sharing for parallelism + virtual inline bool ShareInParallel() const { return false; } virtual inline const char* type() const { return "Data"; } virtual inline int ExactNumBottomBlobs() const { return 0; } virtual inline int MinTopBlobs() const { return 1; } @@ -118,6 +121,8 @@ class DummyDataLayer : public Layer { : Layer(param) {} virtual void LayerSetUp(const vector*>& bottom, const vector*>& top); + // Data layers should be shared by multiple solvers in parallel + virtual inline bool ShareInParallel() const { return true; } // Data layers have no bottoms, so reshaping is trivial. virtual void Reshape(const vector*>& bottom, const vector*>& top) {} @@ -151,6 +156,8 @@ class HDF5DataLayer : public Layer { virtual ~HDF5DataLayer(); virtual void LayerSetUp(const vector*>& bottom, const vector*>& top); + // Data layers should be shared by multiple solvers in parallel + virtual inline bool ShareInParallel() const { return true; } // Data layers have no bottoms, so reshaping is trivial. virtual void Reshape(const vector*>& bottom, const vector*>& top) {} @@ -192,6 +199,8 @@ class HDF5OutputLayer : public Layer { virtual ~HDF5OutputLayer(); virtual void LayerSetUp(const vector*>& bottom, const vector*>& top); + // Data layers should be shared by multiple solvers in parallel + virtual inline bool ShareInParallel() const { return true; } // Data layers have no bottoms, so reshaping is trivial. virtual void Reshape(const vector*>& bottom, const vector*>& top) {} diff --git a/include/caffe/layer.hpp b/include/caffe/layer.hpp index 0771b6a8fb4..d82197a9c29 100644 --- a/include/caffe/layer.hpp +++ b/include/caffe/layer.hpp @@ -1,6 +1,7 @@ #ifndef CAFFE_LAYER_H_ #define CAFFE_LAYER_H_ +#include #include #include #include @@ -85,6 +86,14 @@ class Layer { virtual void LayerSetUp(const vector*>& bottom, const vector*>& top) {} + /** + * @brief Whether a layer should be shared by multiple nets during data + * parallelism. By default, all layers except for data layers should + * not be shared. data layers should be shared to ensure each worker + * solver access data sequentially during data parallelism. + */ + virtual inline bool ShareInParallel() const { return false; } + /** * @brief Adjust the shapes of top blobs and internal buffers to accommodate * the shapes of the bottom blobs. @@ -396,6 +405,10 @@ class Layer { } } + private: + // mutex to lock layer to ensure sequential forward + boost::mutex forward_mutex_; + DISABLE_COPY_AND_ASSIGN(Layer); }; // class Layer @@ -405,6 +418,8 @@ class Layer { template inline Dtype Layer::Forward(const vector*>& bottom, const vector*>& top) { + // Lock during forward to ensure sequential forward + boost::mutex::scoped_lock lock(forward_mutex_); Dtype loss = 0; Reshape(bottom, top); switch (Caffe::mode()) { diff --git a/include/caffe/net.hpp b/include/caffe/net.hpp index bf997553ee2..1bf07d28d13 100644 --- a/include/caffe/net.hpp +++ b/include/caffe/net.hpp @@ -23,8 +23,9 @@ namespace caffe { template class Net { public: - explicit Net(const NetParameter& param); - explicit Net(const string& param_file, Phase phase); + explicit Net(const NetParameter& param, const Net* root_net = NULL); + explicit Net(const string& param_file, Phase phase, + const Net* root_net = NULL); virtual ~Net() {} /// @brief Initialize a network with a NetParameter. @@ -291,7 +292,8 @@ class Net { size_t memory_used_; /// Whether to compute and display debug info for the net. bool debug_info_; - + /// The root net that actually holds the shared layers in data parallelism + const Net* const root_net_; DISABLE_COPY_AND_ASSIGN(Net); }; diff --git a/include/caffe/python_layer.hpp b/include/caffe/python_layer.hpp index 2957e7426be..c43c1e8a91b 100644 --- a/include/caffe/python_layer.hpp +++ b/include/caffe/python_layer.hpp @@ -27,6 +27,10 @@ class PythonLayer : public Layer { self_.attr("reshape")(bottom, top); } + virtual inline bool ShareInParallel() const { + return this->layer_param_.python_param().share_in_parallel(); + } + virtual inline const char* type() const { return "Python"; } protected: diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index 89a6c76d5f7..f583324acef 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -17,8 +17,9 @@ namespace caffe { template class Solver { public: - explicit Solver(const SolverParameter& param); - explicit Solver(const string& param_file); + explicit Solver(const SolverParameter& param, + const Solver* root_solver = NULL); + explicit Solver(const string& param_file, const Solver* root_solver = NULL); void Init(const SolverParameter& param); void InitTrainNet(); void InitTestNets(); @@ -79,6 +80,10 @@ class Solver { vector > > test_nets_; vector callbacks_; + // The root solver that holds root nets (actually containing shared layers) + // in data parallelism + const Solver* const root_solver_; + DISABLE_COPY_AND_ASSIGN(Solver); }; @@ -89,8 +94,9 @@ class Solver { template class WorkerSolver : public Solver { public: - explicit WorkerSolver(const SolverParameter& param) - : Solver(param) {} + explicit WorkerSolver(const SolverParameter& param, + const Solver* root_solver = NULL) + : Solver(param, root_solver) {} protected: void ApplyUpdate() {} diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index 5d0f4322d19..14f8385c6ee 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -22,12 +22,14 @@ namespace caffe { template -Net::Net(const NetParameter& param) { +Net::Net(const NetParameter& param, const Net* root_net) + : root_net_(root_net) { Init(param); } template -Net::Net(const string& param_file, Phase phase) { +Net::Net(const string& param_file, Phase phase, const Net* root_net) + : root_net_(root_net) { NetParameter param; ReadNetParamsFromTextFileOrDie(param_file, ¶m); param.mutable_state()->set_phase(phase); @@ -36,6 +38,8 @@ Net::Net(const string& param_file, Phase phase) { template void Net::Init(const NetParameter& in_param) { + CHECK(Caffe::root_solver() || root_net_) + << "root_net_ needs to be set for all non-root solvers"; // Set phase from the state. phase_ = in_param.state().phase(); // Filter layers based on their include/exclude rules and @@ -79,6 +83,9 @@ void Net::Init(const NetParameter& in_param) { top_id_vecs_.resize(param.layer_size()); bottom_need_backward_.resize(param.layer_size()); for (int layer_id = 0; layer_id < param.layer_size(); ++layer_id) { + // For non-root solvers, whether this layer is shared from root_net_. + bool is_shared_layer = !Caffe::root_solver() + && root_net_->layers_[layer_id]->ShareInParallel(); // Inherit phase from net if unset. if (!param.layer(layer_id).has_phase()) { param.mutable_layer(layer_id)->set_phase(phase_); @@ -91,7 +98,12 @@ void Net::Init(const NetParameter& in_param) { << "propagate_down param must be specified " << "either 0 or bottom_size times "; } - layers_.push_back(LayerRegistry::CreateLayer(layer_param)); + if (is_shared_layer) { + LOG(INFO) << "Sharing layer " << layer_param.name() << " from root net"; + layers_.push_back(root_net_->layers_[layer_id]); + } else { + layers_.push_back(LayerRegistry::CreateLayer(layer_param)); + } layer_names_.push_back(layer_param.name()); if (Caffe::root_solver()) { LOG(INFO) << "Creating Layer " << layer_param.name(); @@ -125,10 +137,22 @@ void Net::Init(const NetParameter& in_param) { } } // After this layer is connected, set it up. + if (is_shared_layer) { + // Set up size of top blobs using root_net_ + const vector*>& base_top = root_net_->top_vecs_[layer_id]; + const vector*>& this_top = this->top_vecs_[layer_id]; + for (int top_id = 0; top_id < base_top.size(); ++top_id) { + this_top[top_id]->ReshapeLike(*base_top[top_id]); + LOG(INFO) << "Created top blob " << top_id << " (shape: " + << this_top[top_id]->shape_string() << ") for shared layer " + << layer_param.name(); + } + } else { + layers_[layer_id]->SetUp(bottom_vecs_[layer_id], top_vecs_[layer_id]); + } if (Caffe::root_solver()) { LOG(INFO) << "Setting up " << layer_names_[layer_id]; } - layers_[layer_id]->SetUp(bottom_vecs_[layer_id], top_vecs_[layer_id]); for (int top_id = 0; top_id < top_vecs_[layer_id].size(); ++top_id) { if (blob_loss_weights_.size() <= top_id_vecs_[layer_id][top_id]) { blob_loss_weights_.resize(top_id_vecs_[layer_id][top_id] + 1, Dtype(0)); diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index 5a08df6c1c8..6e7d802bb99 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -218,7 +218,7 @@ P2PSync::P2PSync(shared_ptr > root_solver, solver_ = root_solver; } else { Caffe::set_root_solver(false); - solver_.reset(new WorkerSolver(param)); + solver_.reset(new WorkerSolver(param, root_solver.get())); Caffe::set_root_solver(true); } this->configure(solver_.get()); @@ -436,4 +436,3 @@ INSTANTIATE_CLASS(GPUParams); INSTANTIATE_CLASS(P2PSync); } // namespace caffe - diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 41165410f33..e78c6686049 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -740,6 +740,10 @@ message PythonParameter { // string, dictionary in Python dict format, JSON, etc. You may parse this // string in `setup` method and use it in `forward` and `backward`. optional string param_str = 3 [default = '']; + // Whether this PythonLayer is shared among worker solvers during data parallelism. + // If true, each worker solver sequentially run forward from this layer. + // This value should be set true if you are using it as a data layer. + optional bool share_in_parallel = 4 [default = false]; } // Message that stores parameters used by ReductionLayer diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index b6fd6b642f1..a44ff88dfd6 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -18,14 +18,14 @@ namespace caffe { template -Solver::Solver(const SolverParameter& param) - : net_(), callbacks_() { +Solver::Solver(const SolverParameter& param, const Solver* root_solver) + : net_(), callbacks_(), root_solver_(root_solver) { Init(param); } template -Solver::Solver(const string& param_file) - : net_(), callbacks_() { +Solver::Solver(const string& param_file, const Solver* root_solver) + : net_(), callbacks_(), root_solver_(root_solver) { SolverParameter param; ReadProtoFromTextFileOrDie(param_file, ¶m); Init(param); @@ -33,6 +33,8 @@ Solver::Solver(const string& param_file) template void Solver::Init(const SolverParameter& param) { + CHECK(Caffe::root_solver() || root_solver_) + << "root_solver_ needs to be set for all non-root solvers"; LOG_IF(INFO, Caffe::root_solver()) << "Initializing solver from parameters: " << std::endl << param.DebugString(); param_ = param; @@ -88,7 +90,11 @@ void Solver::InitTrainNet() { net_state.MergeFrom(net_param.state()); net_state.MergeFrom(param_.train_state()); net_param.mutable_state()->CopyFrom(net_state); - net_.reset(new Net(net_param)); + if (Caffe::root_solver()) { + net_.reset(new Net(net_param)); + } else { + net_.reset(new Net(net_param, root_solver_->net_.get())); + } } template @@ -163,7 +169,12 @@ void Solver::InitTestNets() { net_params[i].mutable_state()->CopyFrom(net_state); LOG(INFO) << "Creating test net (#" << i << ") specified by " << sources[i]; - test_nets_[i].reset(new Net(net_params[i])); + if (Caffe::root_solver()) { + test_nets_[i].reset(new Net(net_params[i])); + } else { + test_nets_[i].reset(new Net(net_params[i], + root_solver_->test_nets_[i].get())); + } test_nets_[i]->set_debug_info(param_.debug_info()); } } From 6b50ed6fc1897ce1ccd673cf0287788b38b58a6d Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Wed, 12 Aug 2015 12:05:56 -0700 Subject: [PATCH 147/331] Apply mutex only to shared layers and fix NVCC warning --- include/caffe/layer.hpp | 43 ++++++++++++++++++++++++++++++++++++----- src/caffe/layer.cpp | 27 ++++++++++++++++++++++++++ src/caffe/net.cpp | 7 ++++--- 3 files changed, 69 insertions(+), 8 deletions(-) create mode 100644 src/caffe/layer.cpp diff --git a/include/caffe/layer.hpp b/include/caffe/layer.hpp index d82197a9c29..a0d1d4ecc94 100644 --- a/include/caffe/layer.hpp +++ b/include/caffe/layer.hpp @@ -1,7 +1,6 @@ #ifndef CAFFE_LAYER_H_ #define CAFFE_LAYER_H_ -#include #include #include #include @@ -12,6 +11,12 @@ #include "caffe/proto/caffe.pb.h" #include "caffe/util/device_alternate.hpp" +/** + Forward declare boost::thread instead of including boost/thread.hpp + to avoid a boost/NVCC issues (#1009, #1010) on OSX. + */ +namespace boost { class mutex; } + namespace caffe { /** @@ -33,7 +38,7 @@ class Layer { * layer. */ explicit Layer(const LayerParameter& param) - : layer_param_(param) { + : layer_param_(param), is_shared_(false) { // Set phase and copy blobs (if there are any). phase_ = param.phase(); if (layer_param_.blobs_size() > 0) { @@ -61,6 +66,7 @@ class Layer { */ void SetUp(const vector*>& bottom, const vector*>& top) { + InitMutex(); CheckBlobCounts(bottom, top); LayerSetUp(bottom, top); Reshape(bottom, top); @@ -94,6 +100,22 @@ class Layer { */ virtual inline bool ShareInParallel() const { return false; } + /** @brief Return whether this layer is actually shared by other nets. + * If ShareInParallel() is true and using more than one GPU and the + * net has TRAIN phase, then this function is expected return true. + */ + inline bool IsShared() const { return is_shared_; } + + /** @brief Set whether this layer is actually shared by other nets + * If ShareInParallel() is true and using more than one GPU and the + * net has TRAIN phase, then is_shared should be set true. + */ + inline void SetShared(bool is_shared) { + CHECK(ShareInParallel() || !is_shared) + << type() << "Layer does not support sharing."; + is_shared_ = is_shared; + } + /** * @brief Adjust the shapes of top blobs and internal buffers to accommodate * the shapes of the bottom blobs. @@ -406,8 +428,18 @@ class Layer { } private: - // mutex to lock layer to ensure sequential forward - boost::mutex forward_mutex_; + /** Whether this layer is actually shared by other nets*/ + bool is_shared_; + + /** The mutex for sequential forward if this layer is shared */ + shared_ptr forward_mutex_; + + /** Initialize forward_mutex_ */ + void InitMutex(); + /** Lock forward_mutex_ if this layer is shared */ + void Lock(); + /** Unlock forward_mutex_ if this layer is shared */ + void Unlock(); DISABLE_COPY_AND_ASSIGN(Layer); }; // class Layer @@ -419,7 +451,7 @@ template inline Dtype Layer::Forward(const vector*>& bottom, const vector*>& top) { // Lock during forward to ensure sequential forward - boost::mutex::scoped_lock lock(forward_mutex_); + Lock(); Dtype loss = 0; Reshape(bottom, top); switch (Caffe::mode()) { @@ -450,6 +482,7 @@ inline Dtype Layer::Forward(const vector*>& bottom, default: LOG(FATAL) << "Unknown caffe mode."; } + Unlock(); return loss; } diff --git a/src/caffe/layer.cpp b/src/caffe/layer.cpp new file mode 100644 index 00000000000..3b9128986ae --- /dev/null +++ b/src/caffe/layer.cpp @@ -0,0 +1,27 @@ +#include +#include "caffe/layer.hpp" + +namespace caffe { + +template +void Layer::InitMutex() { + forward_mutex_.reset(new boost::mutex()); +} + +template +void Layer::Lock() { + if (IsShared()) { + forward_mutex_->lock(); + } +} + +template +void Layer::Unlock() { + if (IsShared()) { + forward_mutex_->unlock(); + } +} + +INSTANTIATE_CLASS(Layer); + +} // namespace caffe diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index 14f8385c6ee..7f5bdf7e2ba 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -84,7 +84,7 @@ void Net::Init(const NetParameter& in_param) { bottom_need_backward_.resize(param.layer_size()); for (int layer_id = 0; layer_id < param.layer_size(); ++layer_id) { // For non-root solvers, whether this layer is shared from root_net_. - bool is_shared_layer = !Caffe::root_solver() + bool share_from_root = !Caffe::root_solver() && root_net_->layers_[layer_id]->ShareInParallel(); // Inherit phase from net if unset. if (!param.layer(layer_id).has_phase()) { @@ -98,9 +98,10 @@ void Net::Init(const NetParameter& in_param) { << "propagate_down param must be specified " << "either 0 or bottom_size times "; } - if (is_shared_layer) { + if (share_from_root) { LOG(INFO) << "Sharing layer " << layer_param.name() << " from root net"; layers_.push_back(root_net_->layers_[layer_id]); + layers_[layer_id]->SetShared(true); } else { layers_.push_back(LayerRegistry::CreateLayer(layer_param)); } @@ -137,7 +138,7 @@ void Net::Init(const NetParameter& in_param) { } } // After this layer is connected, set it up. - if (is_shared_layer) { + if (share_from_root) { // Set up size of top blobs using root_net_ const vector*>& base_top = root_net_->top_vecs_[layer_id]; const vector*>& this_top = this->top_vecs_[layer_id]; From 4c7e58e201ab2a06bb3b08d7c148e3b67988f853 Mon Sep 17 00:00:00 2001 From: PatWie Date: Fri, 14 Aug 2015 13:06:13 +0200 Subject: [PATCH 148/331] information about new implemented solvers --- docs/tutorial/solver.md | 79 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 78 insertions(+), 1 deletion(-) diff --git a/docs/tutorial/solver.md b/docs/tutorial/solver.md index 17f793ef778..b150f6487bc 100644 --- a/docs/tutorial/solver.md +++ b/docs/tutorial/solver.md @@ -6,7 +6,14 @@ title: Solver / Model Optimization The solver orchestrates model optimization by coordinating the network's forward inference and backward gradients to form parameter updates that attempt to improve the loss. The responsibilities of learning are divided between the Solver for overseeing the optimization and generating parameter updates and the Net for yielding loss and gradients. -The Caffe solvers are Stochastic Gradient Descent (SGD), Adaptive Gradient (ADAGRAD), and Nesterov's Accelerated Gradient (NESTEROV). +The Caffe solvers are: + +- Stochastic Gradient Descent (`SGD`), +- AdaDelta (`ADADELTA`), +- Adaptive Gradient (`ADAGRAD`), +- Adam (`ADAM`), +- Nesterov's Accelerated Gradient (`NESTEROV`) and +- RMSprop (`RMSPROP`) The solver @@ -104,6 +111,32 @@ If learning diverges (e.g., you start to see very large or `NaN` or `inf` loss v [ImageNet Classification with Deep Convolutional Neural Networks](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf). *Advances in Neural Information Processing Systems*, 2012. +### AdaDelta + +The **AdaDelta** (`solver_type: ADADELTA`) method (M. Zeiler [1]) is a "robust learning rate method". It is a gradient-based optimization method (like SGD). The update formulas are + +$$ +\begin{align} +(v_t)_i &= \frac{\operatorname{RMS}((v_{t-1})_i)}{\operatorname{RMS}\left( \nabla L(W_t) \right)_{i}} \left( \nabla L(W_{t'}) \right)_i +\\ +\operatorname{RMS}\left( \nabla L(W_t) \right)_{i} &= \sqrt{E[g^2] + \varepsilon} +\\ +E[g^2]_t &= \delta{E[g^2]_{t-1} } + (1-\delta)g_{t}^2 +\end{align} +$$ + +and + +$$ +(W_{t+1})_i = +(W_t)_i - \alpha +(v_t)_i. +$$ + +[1] M. Zeiler + [ADADELTA: AN ADAPTIVE LEARNING RATE METHOD](http://arxiv.org/pdf/1212.5701.pdf). + *arXiv preprint*, 2012. + ### AdaGrad The **adaptive gradient** (`solver_type: ADAGRAD`) method (Duchi et al. [1]) is a gradient-based optimization method (like SGD) that attempts to "find needles in haystacks in the form of very predictive but rarely seen features," in Duchi et al.'s words. @@ -124,6 +157,28 @@ Note that in practice, for weights $$ W \in \mathcal{R}^d $$, AdaGrad implementa [Adaptive Subgradient Methods for Online Learning and Stochastic Optimization](http://www.magicbroom.info/Papers/DuchiHaSi10.pdf). *The Journal of Machine Learning Research*, 2011. +### Adam + +The **Adam** (`solver_type: ADAM`), proposed in Kingma et al. [1], is a gradient-based optimization method (like SGD). This includes an "adaptive moment estimation" ($$m_t, v_t$$) and can be regarded as a generalization of AdaGrad. The update formulas are + +$$ +(m_t)_i = \beta_1 (m_{t-1})_i + (1-\beta_1)(\nabla L(W_t))_i,\\ +(v_t)_i = \beta_2 (v_{t-1})_i + (1-\beta_2)(\nabla L(W_t))_i^2 +$$ + +and + +$$ +(W_{t+1})_i = +(W_t)_i - \alpha \frac{\sqrt{1-(\beta_2)_i^t}}{1-(\beta_1)_i^t}\frac{(m_t)_i}{\sqrt{(v_t)_i}+\varepsilon}. +$$ + +Kingma et al. [1] proposed to use $$\beta_1 = 0.9, \beta_2 = 0.999, \varepsilon = 10^{-8}$$ as default values. Caffe uses the values of `momemtum, momentum2, delta` for $$\beta_1, \beta_2, \varepsilon$$, respectively. + +[1] D. Kingma, J. Ba. + [Adam: A Method for Stochastic Optimization](http://arxiv.org/abs/1412.6980). + *International Conference for Learning Representations*, 2015. + ### NAG **Nesterov's accelerated gradient** (`solver_type: NESTEROV`) was proposed by Nesterov [1] as an "optimal" method of convex optimization, achieving a convergence rate of $$ \mathcal{O}(1/t^2) $$ rather than the $$ \mathcal{O}(1/t) $$. @@ -149,6 +204,28 @@ What distinguishes the method from SGD is the weight setting $$ W $$ on which we [On the Importance of Initialization and Momentum in Deep Learning](http://www.cs.toronto.edu/~fritz/absps/momentum.pdf). *Proceedings of the 30th International Conference on Machine Learning*, 2013. +### RMSprop + +The **RMSprop** (`solver_type: RMSPROP`), suggested by Tieleman in a Coursera course lecture, is a gradient-based optimization method (like SGD). The update formulas are + +$$ +(v_t)_i = +\begin{cases} +(v_{t-1})_i + \delta, &(\nabla L(W_t))_i(\nabla L(W_{t-1}))_i > 0\\ +(v_{t-1})_i \cdot (1-\delta), & \text{else} +\end{cases} +$$ + +$$ +(W_{t+1})_i =(W_t)_i - \alpha (v_t)_i, +$$ + +If the gradient updates results in oscillations the gradient is reduced by times $$1-\delta$$. Otherwise it will be increased by $$\delta$$. The default value of $$\delta$$ (`rms_decay`) is set to $$\delta = 0.02$$. + +[1] T. Tieleman, and G. Hinton. + [RMSProp: Divide the gradient by a running average of its recent magnitude](http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf). + *COURSERA: Neural Networks for Machine Learning.Technical report*, 2012. + ## Scaffolding The solver scaffolding prepares the optimization method and initializes the model to be learned in `Solver::Presolve()`. From e696f85abe2c50107fbb67b211bf7dad0f87ade0 Mon Sep 17 00:00:00 2001 From: LI Yi Date: Fri, 14 Aug 2015 20:51:45 +0800 Subject: [PATCH 149/331] Destroy CUDA stream when finished --- src/caffe/layers/base_data_layer.cpp | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/caffe/layers/base_data_layer.cpp b/src/caffe/layers/base_data_layer.cpp index 20f76f62994..5303fe9c5d3 100644 --- a/src/caffe/layers/base_data_layer.cpp +++ b/src/caffe/layers/base_data_layer.cpp @@ -74,7 +74,7 @@ void BasePrefetchingDataLayer::InternalThreadEntry() { #ifndef CPU_ONLY cudaStream_t stream; if (Caffe::mode() == Caffe::GPU) { - cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking); + CUDA_CHECK(cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking)); } #endif @@ -85,7 +85,7 @@ void BasePrefetchingDataLayer::InternalThreadEntry() { #ifndef CPU_ONLY if (Caffe::mode() == Caffe::GPU) { batch->data_.data().get()->async_gpu_push(stream); - cudaStreamSynchronize(stream); + CUDA_CHECK(cudaStreamSynchronize(stream)); } #endif prefetch_full_.push(batch); @@ -93,6 +93,11 @@ void BasePrefetchingDataLayer::InternalThreadEntry() { } catch (boost::thread_interrupted&) { // Interrupted exception is expected on shutdown } +#ifndef CPU_ONLY + if (Caffe::mode() == Caffe::GPU) { + CUDA_CHECK(cudaStreamDestroy(stream)); + } +#endif } template From 4e4c89b026cb0b7f296aae4dfbb45e2eb1654f43 Mon Sep 17 00:00:00 2001 From: PatWie Date: Mon, 3 Aug 2015 17:31:14 +0200 Subject: [PATCH 150/331] Adam solver This commit implements the Adam solver by Kingma et. al for CPU and GPU. All solver parameters are defined in the caffe.proto. This also adds an example for the MNIST dataset. --- examples/mnist/lenet_solver_adam.prototxt | 26 +++ examples/mnist/train_lenet_adam.sh | 3 + include/caffe/solver.hpp | 17 ++ src/caffe/proto/caffe.proto | 7 +- src/caffe/solver.cpp | 104 +++++++++++ src/caffe/test/test_gradient_based_solver.cpp | 170 +++++++++++++++--- 6 files changed, 299 insertions(+), 28 deletions(-) create mode 100644 examples/mnist/lenet_solver_adam.prototxt create mode 100755 examples/mnist/train_lenet_adam.sh diff --git a/examples/mnist/lenet_solver_adam.prototxt b/examples/mnist/lenet_solver_adam.prototxt new file mode 100644 index 00000000000..d22c5718f3f --- /dev/null +++ b/examples/mnist/lenet_solver_adam.prototxt @@ -0,0 +1,26 @@ +# The train/test net protocol buffer definition +# this follows "ADAM: A METHOD FOR STOCHASTIC OPTIMIZATION" +net: "examples/mnist/lenet_train_test.prototxt" +# test_iter specifies how many forward passes the test should carry out. +# In the case of MNIST, we have test batch size 100 and 100 test iterations, +# covering the full 10,000 testing images. +test_iter: 100 +# Carry out testing every 500 training iterations. +test_interval: 500 +# All parameters are from the cited paper above +base_lr: 0.001 +momentum: 0.9 +momentum2: 0.999 +# since Adam dynamically changes the learning rate, we set the base learning +# rate to a fixed value +lr_policy: "fixed" +# Display every 100 iterations +display: 100 +# The maximum number of iterations +max_iter: 10000 +# snapshot intermediate results +snapshot: 5000 +snapshot_prefix: "examples/mnist/lenet" +# solver mode: CPU or GPU +solver_type: ADAM +solver_mode: GPU diff --git a/examples/mnist/train_lenet_adam.sh b/examples/mnist/train_lenet_adam.sh new file mode 100755 index 00000000000..a32ecf2d9c2 --- /dev/null +++ b/examples/mnist/train_lenet_adam.sh @@ -0,0 +1,3 @@ +#!/usr/bin/env sh + +./build/tools/caffe train --solver=examples/mnist/lenet_solver_adam.prototxt diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index d2b99923f23..582aa1427d3 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -217,6 +217,21 @@ class AdaDeltaSolver : public SGDSolver { DISABLE_COPY_AND_ASSIGN(AdaDeltaSolver); }; +template +class AdamSolver : public SGDSolver { + public: + explicit AdamSolver(const SolverParameter& param) + : SGDSolver(param) { AdamPreSolve();} + explicit AdamSolver(const string& param_file) + : SGDSolver(param_file) { AdamPreSolve(); } + + protected: + void AdamPreSolve(); + virtual void ComputeUpdateValue(int param_id, Dtype rate); + + DISABLE_COPY_AND_ASSIGN(AdamSolver); +}; + template Solver* GetSolver(const SolverParameter& param) { SolverParameter_SolverType type = param.solver_type(); @@ -232,6 +247,8 @@ Solver* GetSolver(const SolverParameter& param) { return new RMSPropSolver(param); case SolverParameter_SolverType_ADADELTA: return new AdaDeltaSolver(param); + case SolverParameter_SolverType_ADAM: + return new AdamSolver(param); default: LOG(FATAL) << "Unknown SolverType: " << type; } diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index fc0d961abda..d4c97d2bd06 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -98,7 +98,7 @@ message NetParameter { // NOTE // Update the next available ID when you add a new SolverParameter field. // -// SolverParameter next available ID: 39 (last added: rms_decay) +// SolverParameter next available ID: 40 (last added: momentum2) message SolverParameter { ////////////////////////////////////////////////////////////////////////////// // Specifying the train and test networks @@ -216,10 +216,13 @@ message SolverParameter { ADAGRAD = 2; RMSPROP = 3; ADADELTA = 4; + ADAM = 5; } optional SolverType solver_type = 30 [default = SGD]; - // numerical stability for AdaGrad + // numerical stability for RMSProp, AdaGrad and AdaDelta and Adam optional float delta = 31 [default = 1e-8]; + // parameters for the Adam solver + optional float momentum2 = 39 [default = 0.999]; // RMSProp decay value // MeanSquare(t) = rms_decay*MeanSquare(t-1) + (1-rms_decay)*SquareGradient(t) diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 248f238eb76..9348e11c249 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -1114,11 +1114,115 @@ void AdaDeltaSolver::ComputeUpdateValue(int param_id, Dtype rate) { } } +template +void AdamSolver::AdamPreSolve() { + // Add the extra history entries for Adam after those from + // SGDSolver::PreSolve + const vector*>& net_params = this->net_->learnable_params(); + for (int i = 0; i < net_params.size(); ++i) { + const vector& shape = net_params[i]->shape(); + this->history_.push_back( + shared_ptr >(new Blob(shape))); + } +} + +template +void AdamSolver::ComputeUpdateValue(int param_id, Dtype rate) { + const vector*>& net_params = this->net_->learnable_params(); + const vector& net_params_lr = this->net_->params_lr(); + Dtype local_rate = rate * net_params_lr[param_id]; + const Dtype beta1 = this->param_.momentum(); + const Dtype beta2 = this->param_.momentum2(); + + // we create aliases for convenience + size_t update_history_offset = net_params.size(); + Blob* val_m = this->history_[param_id].get(); + Blob* val_v = this->history_[param_id + update_history_offset].get(); + Blob* val_t = this->temp_[param_id].get(); + + const int t = this->iter_ + 1; + const Dtype correction = std::sqrt(Dtype(1) - pow(beta2, t)) / + (Dtype(1.) - pow(beta1, t)); + const int N = net_params[param_id]->count(); + const Dtype eps_hat = this->param_.delta(); + + switch (Caffe::mode()) { + case Caffe::CPU: { + // update m <- \beta_1 m_{t-1} + (1-\beta_1)g_t + caffe_cpu_axpby(N, Dtype(1)-beta1, + net_params[param_id]->cpu_diff(), beta1, + val_m->mutable_cpu_data()); + + // update v <- \beta_2 m_{t-1} + (1-\beta_2)g_t^2 + caffe_mul(N, + net_params[param_id]->cpu_diff(), + net_params[param_id]->cpu_diff(), + val_t->mutable_cpu_data()); + caffe_cpu_axpby(N, Dtype(1)-beta2, + val_t->cpu_data(), beta2, + val_v->mutable_cpu_data()); + + // set update + caffe_powx(N, + val_v->cpu_data(), Dtype(0.5), + val_t->mutable_cpu_data()); + caffe_add_scalar(N, eps_hat, val_t->mutable_cpu_data()); + caffe_div(N, + val_m->cpu_data(), + val_t->cpu_data(), + val_t->mutable_cpu_data()); + + caffe_cpu_scale(N, local_rate*correction, + val_t->cpu_data(), + net_params[param_id]->mutable_cpu_diff()); + break; + } + case Caffe::GPU: { +#ifndef CPU_ONLY + // update m <- \beta_1 m_{t-1} + (1-\beta_1)g_t + caffe_gpu_axpby(N, Dtype(1)-beta1, + net_params[param_id]->gpu_diff(), beta1, + val_m->mutable_gpu_data()); + + // update v <- \beta_2 m_{t-1} + (1-\beta_2)g_t^2 + caffe_gpu_mul(N, + net_params[param_id]->gpu_diff(), + net_params[param_id]->gpu_diff(), + val_t->mutable_gpu_data()); + caffe_gpu_axpby(N, Dtype(1)-beta2, + val_t->gpu_data(), beta2, + val_v->mutable_gpu_data()); + + // set update + caffe_gpu_powx(N, + val_v->gpu_data(), Dtype(0.5), + val_t->mutable_gpu_data()); + caffe_gpu_add_scalar(N, eps_hat, + val_t->mutable_gpu_data()); + caffe_gpu_div(N, + val_m->gpu_data(), + val_t->gpu_data(), + val_t->mutable_gpu_data()); + + caffe_gpu_scale(N, local_rate*correction, + val_t->gpu_data(), + net_params[param_id]->mutable_gpu_diff()); +#else + NO_GPU; +#endif + break; + } + default: + LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode(); + } +} + INSTANTIATE_CLASS(Solver); INSTANTIATE_CLASS(SGDSolver); INSTANTIATE_CLASS(NesterovSolver); INSTANTIATE_CLASS(AdaGradSolver); INSTANTIATE_CLASS(RMSPropSolver); INSTANTIATE_CLASS(AdaDeltaSolver); +INSTANTIATE_CLASS(AdamSolver); } // namespace caffe diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index 1d255a86621..dcbfff1cad2 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -42,7 +42,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { // TODO this is brittle and the hdf5 file should be checked instead. int num_, channels_, height_, width_; bool share_; - Dtype delta_; // Stability constant for AdaGrad. + Dtype delta_; // Stability constant for RMSProp, AdaGrad, AdaDelta and Adam // Test data: check out generate_sample_data.py in the same directory. string* input_file_; @@ -65,10 +65,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { LOG(FATAL) << "Unknown Caffe mode: " << Caffe::mode(); } InitSolver(param); - delta_ = (solver_type() == SolverParameter_SolverType_ADAGRAD || - solver_type() == SolverParameter_SolverType_RMSPROP || - solver_type() == SolverParameter_SolverType_ADADELTA) ? - param.delta() : 0; + delta_ = param.delta(); } string RunLeastSquaresSolver(const Dtype learning_rate, @@ -216,7 +213,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { // updated_params will store the updated weight and bias results, // using the blobs' diffs to hold the update values themselves. void ComputeLeastSquaresUpdate(const Dtype learning_rate, - const Dtype weight_decay, const Dtype momentum, + const Dtype weight_decay, const Dtype momentum, const int num_iters, vector > >* updated_params) { const int N = num_; const int D = channels_ * height_ * width_; @@ -282,7 +279,8 @@ class GradientBasedSolverTest : public MultiDeviceTest { ((i == D) ? bias.cpu_data()[0] : weights.cpu_data()[i]); // Finally, compute update. const vector > >& history = solver_->history(); - if (solver_type() != SolverParameter_SolverType_ADADELTA) { + if (solver_type() != SolverParameter_SolverType_ADADELTA + && solver_type() != SolverParameter_SolverType_ADAM) { ASSERT_EQ(2, history.size()); // 1 blob for weights, 1 for bias } else { ASSERT_EQ(4, history.size()); // additional blobs for update history @@ -312,16 +310,31 @@ class GradientBasedSolverTest : public MultiDeviceTest { case SolverParameter_SolverType_ADADELTA: { const Dtype update_history_value = (i == D) ? - history[3]->cpu_data()[0] : history[2]->cpu_data()[i]; + history[1 + num_param_blobs]->cpu_data()[0] : + history[0 + num_param_blobs]->cpu_data()[i]; const Dtype weighted_gradient_average = momentum * history_value + (1 - momentum) * (grad * grad); update_value = grad * std::sqrt((update_history_value + delta_) / - (weighted_gradient_average + delta_)); + (weighted_gradient_average + delta_)) * learning_rate; // not actually needed, just here for illustrative purposes // const Dtype weighted_update_average = // momentum * update_history_value + (1 - momentum) * (update_value); break; } + case SolverParameter_SolverType_ADAM: { + const Dtype momentum2 = 0.999; + const Dtype m = history_value; + const Dtype v = (i == D) ? + history[1 + num_param_blobs]->cpu_data()[0] : + history[0 + num_param_blobs]->cpu_data()[i]; + const Dtype val_m = (1 - momentum) * grad + momentum * m; + const Dtype val_v = (1 - momentum2) * grad * grad + momentum2 * v; + Dtype alpha_t = learning_rate * + std::sqrt(Dtype(1) - pow(momentum2, num_iters)) / + (Dtype(1.) - pow(momentum, num_iters)); + update_value = alpha_t * val_m / (std::sqrt(val_v) + delta_); + break; + } default: LOG(FATAL) << "Unknown solver type: " << solver_type(); } @@ -465,7 +478,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { // Compute the (K+1)th update using the analytic least squares gradient. vector > > updated_params; ComputeLeastSquaresUpdate(learning_rate, weight_decay, momentum, - &updated_params); + iter_to_check + 1, &updated_params); // Reinitialize the solver and run K+1 solver iterations. num_ = kNum; @@ -946,13 +959,13 @@ TYPED_TEST_CASE(AdaDeltaSolverTest, TestDtypesAndDevices); TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdate) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.1; this->TestLeastSquaresUpdate(kLearningRate); } TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithWeightDecay) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.1; const Dtype kWeightDecay = 0.5; const Dtype kMomentum = 0.95; this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); @@ -960,64 +973,64 @@ TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithWeightDecay) { TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithHalfMomentum) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.1; const Dtype kWeightDecay = 0.0; const Dtype kMomentum = 0.5; const int kNumIters = 1; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); } } TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithMomentum) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.1; const Dtype kWeightDecay = 0.0; const Dtype kMomentum = 0.95; const int kNumIters = 1; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); } } TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.1; const Dtype kWeightDecay = 0.0; const Dtype kMomentum = 0.95; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithEverything) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.1; const Dtype kWeightDecay = 0.1; const Dtype kMomentum = 0.95; const int kNumIters = 4; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithEverythingShare) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.1; const Dtype kWeightDecay = 0.1; const Dtype kMomentum = 0.95; const int kNumIters = 4; this->share_ = true; for (int i = 0; i <= kNumIters; ++i) { - this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); } } TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.1; const Dtype kWeightDecay = 0.1; const Dtype kMomentum = 0.95; const int kNumIters = 4; @@ -1028,7 +1041,7 @@ TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.1; const Dtype kWeightDecay = 0.1; const Dtype kMomentum = 0.95; const int kNumIters = 4; @@ -1040,7 +1053,7 @@ TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { TYPED_TEST(AdaDeltaSolverTest, TestSnapshot) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.1; const Dtype kWeightDecay = 0.1; const Dtype kMomentum = 0.95; const int kNumIters = 4; @@ -1051,7 +1064,7 @@ TYPED_TEST(AdaDeltaSolverTest, TestSnapshot) { TYPED_TEST(AdaDeltaSolverTest, TestSnapshotShare) { typedef typename TypeParam::Dtype Dtype; - const Dtype kLearningRate = 1.0; + const Dtype kLearningRate = 0.1; const Dtype kWeightDecay = 0.1; const Dtype kMomentum = 0.95; const int kNumIters = 4; @@ -1061,6 +1074,111 @@ TYPED_TEST(AdaDeltaSolverTest, TestSnapshotShare) { } } +template +class AdamSolverTest : public GradientBasedSolverTest { + typedef typename TypeParam::Dtype Dtype; + + protected: + virtual void InitSolver(const SolverParameter& param) { + SolverParameter new_param = param; + const Dtype momentum = 0.9; + new_param.set_momentum(momentum); + const Dtype momentum2 = 0.999; + new_param.set_momentum2(momentum2); + this->solver_.reset(new AdamSolver(new_param)); + } + virtual SolverParameter_SolverType solver_type() { + return SolverParameter_SolverType_ADAM; + } +}; + +TYPED_TEST_CASE(AdamSolverTest, TestDtypesAndDevices); + +TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdate) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0; + const Dtype kMomentum = 0.9; + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); +} + +TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdateWithWeightDecay) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum); +} + +TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdateWithEverything) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + +TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdateWithEverythingShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + this->share_ = true; + for (int i = 0; i <= kNumIters; ++i) { + this->TestLeastSquaresUpdate(kLearningRate, kWeightDecay, kMomentum, i); + } +} + +TYPED_TEST(AdamSolverTest, TestLeastSquaresUpdateWithEverythingAccum) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + const int kIterSize = 2; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); +} + +TYPED_TEST(AdamSolverTest, TestLeastSquaresUpdateWithEverythingAccumShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + const int kIterSize = 2; + this->share_ = true; + this->CheckAccumulation(kLearningRate, kWeightDecay, kMomentum, kNumIters, + kIterSize); +} + +TYPED_TEST(AdamSolverTest, TestSnapshot) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + } +} + +TYPED_TEST(AdamSolverTest, TestSnapshotShare) { + typedef typename TypeParam::Dtype Dtype; + const Dtype kLearningRate = 0.01; + const Dtype kWeightDecay = 0.5; + const Dtype kMomentum = 0.9; + const int kNumIters = 4; + this->share_ = true; + for (int i = 1; i <= kNumIters; ++i) { + this->TestSnapshot(kLearningRate, kWeightDecay, kMomentum, i); + } +} + template class RMSPropSolverTest : public GradientBasedSolverTest { typedef typename TypeParam::Dtype Dtype; From bf42e6ebf7c56ff2f0d13bdcc7294d357d7592c6 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Thu, 13 Aug 2015 22:41:21 -0700 Subject: [PATCH 151/331] Cite Adam paper in solver.hpp --- include/caffe/solver.hpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index 582aa1427d3..ab12ef1b1bd 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -217,6 +217,14 @@ class AdaDeltaSolver : public SGDSolver { DISABLE_COPY_AND_ASSIGN(AdaDeltaSolver); }; +/** + * @brief AdamSolver, an algorithm for first-order gradient-based optimization + * of stochastic objective functions, based on adaptive estimates of + * lower-order moments. Described in [1]. + * + * [1] D. P. Kingma and J. L. Ba, "ADAM: A Method for Stochastic Optimization." + * arXiv preprint arXiv:1412.6980v8 (2014). + */ template class AdamSolver : public SGDSolver { public: From 1d820f7fa81e6b02a64140a93edbfd30dc529e8b Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Fri, 14 Aug 2015 09:19:48 -0700 Subject: [PATCH 152/331] Malloc at least one byte in Parallel --- src/caffe/parallel.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index 6e7d802bb99..d48136c56b8 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -64,7 +64,9 @@ static size_t total_size(const vector*>& params) { size_t size = 0; for (int i = 0; i < params.size(); ++i) size += params[i]->count(); - return size; + // Size have at least one byte, otherwise cudaMalloc fails if net has no + // learnable parameters. + return (size > 0) ? size : 1; } template From 98593e3aa64d9a8f42723fb03fa46a1343e12c33 Mon Sep 17 00:00:00 2001 From: Felix Abecassis Date: Fri, 14 Aug 2015 11:15:56 -0700 Subject: [PATCH 153/331] Make classification.bin support models with less than 5 classes The example program would crash if the number of classes was less than 5, since it was still attempting to get the top 5 predictions. Close #2585 --- examples/cpp_classification/classification.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/examples/cpp_classification/classification.cpp b/examples/cpp_classification/classification.cpp index 1c6371e382b..dc8b863f53f 100644 --- a/examples/cpp_classification/classification.cpp +++ b/examples/cpp_classification/classification.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include #include @@ -101,6 +102,7 @@ static std::vector Argmax(const std::vector& v, int N) { std::vector Classifier::Classify(const cv::Mat& img, int N) { std::vector output = Predict(img); + N = std::min(labels_.size(), N); std::vector maxN = Argmax(output, N); std::vector predictions; for (int i = 0; i < N; ++i) { From e94be07e2d7e186821698df053ef77a35fe71c26 Mon Sep 17 00:00:00 2001 From: philkr Date: Thu, 23 Jul 2015 08:33:58 -0700 Subject: [PATCH 154/331] Exposing blob loss weight to python --- python/caffe/_caffe.cpp | 4 ++++ python/caffe/pycaffe.py | 10 ++++++++++ 2 files changed, 14 insertions(+) diff --git a/python/caffe/_caffe.cpp b/python/caffe/_caffe.cpp index bb5130fddd0..e1ae3ec73c7 100644 --- a/python/caffe/_caffe.cpp +++ b/python/caffe/_caffe.cpp @@ -211,6 +211,8 @@ BOOST_PYTHON_MODULE(_caffe) { .def("copy_from", static_cast::*)(const string)>( &Net::CopyTrainedLayersFrom)) .def("share_with", &Net::ShareTrainedLayersWith) + .add_property("_blob_loss_weights", bp::make_function( + &Net::blob_loss_weights, bp::return_internal_reference<>())) .add_property("_blobs", bp::make_function(&Net::blobs, bp::return_internal_reference<>())) .add_property("layers", bp::make_function(&Net::layers, @@ -293,6 +295,8 @@ BOOST_PYTHON_MODULE(_caffe) { .def(bp::vector_indexing_suite >()); bp::class_ >("IntVec") .def(bp::vector_indexing_suite >()); + bp::class_ >("DtypeVec") + .def(bp::vector_indexing_suite >()); bp::class_ > > >("NetVec") .def(bp::vector_indexing_suite > >, true>()); bp::class_ >("BoolVec") diff --git a/python/caffe/pycaffe.py b/python/caffe/pycaffe.py index e8a676a26d2..4f980a92c38 100644 --- a/python/caffe/pycaffe.py +++ b/python/caffe/pycaffe.py @@ -27,6 +27,15 @@ def _Net_blobs(self): return OrderedDict(zip(self._blob_names, self._blobs)) +@property +def _Net_blob_loss_weights(self): + """ + An OrderedDict (bottom to top, i.e., input to output) of network + blob loss weights indexed by name + """ + return OrderedDict(zip(self._blob_names, self._blob_loss_weights)) + + @property def _Net_params(self): """ @@ -270,6 +279,7 @@ def _Net_batch(self, blobs): # Attach methods to Net. Net.blobs = _Net_blobs +Net.blob_loss_weights = _Net_blob_loss_weights Net.params = _Net_params Net.forward = _Net_forward Net.backward = _Net_backward From 7f4ffcd7c4d3896fd2a40cc4dd153ba04b1ba968 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Fri, 14 Aug 2015 12:52:39 -0700 Subject: [PATCH 155/331] [net] improve net config and shape mismatch error messages --- src/caffe/net.cpp | 37 ++++++++++++++++++++++++++------ src/caffe/util/insert_splits.cpp | 3 ++- 2 files changed, 33 insertions(+), 7 deletions(-) diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index 7875285fea1..31644422e59 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -424,7 +424,8 @@ void Net::AppendTop(const NetParameter& param, const int layer_id, blob_name_to_idx->find(blob_name) != blob_name_to_idx->end()) { // If we are not doing in-place computation but have duplicated blobs, // raise an error. - LOG(FATAL) << "Duplicate blobs produced by multiple sources."; + LOG(FATAL) << "Top blob '" << blob_name + << "' produced by multiple sources."; } else { // Normal output. if (Caffe::root_solver()) { @@ -468,8 +469,8 @@ int Net::AppendBottom(const NetParameter& param, const int layer_id, const LayerParameter& layer_param = param.layer(layer_id); const string& blob_name = layer_param.bottom(bottom_id); if (available_blobs->find(blob_name) == available_blobs->end()) { - LOG(FATAL) << "Unknown blob input " << blob_name - << " (at index " << bottom_id << ") to layer " << layer_id; + LOG(FATAL) << "Unknown bottom blob '" << blob_name << "' (layer '" + << layer_param.name() << "', bottom index " << bottom_id << ")"; } const int blob_id = (*blob_name_to_idx)[blob_name]; if (Caffe::root_solver()) { @@ -545,10 +546,19 @@ void Net::AppendParam(const NetParameter& param, const int layer_id, ParamSpec_DimCheckMode_PERMISSIVE)) { // Permissive dimension checking -- only check counts are the same. CHECK_EQ(this_blob->count(), owner_blob->count()) - << "Shared parameter blobs must have the same count."; + << "Cannot share param '" << param_name << "' owned by layer '" + << layer_names_[owner_layer_id] << "' with layer '" + << layer_names_[layer_id] << "'; count mismatch. Owner layer param " + << "shape is " << owner_blob->shape_string() << "; sharing layer " + << "shape is " << this_blob->shape_string(); } else { // Strict dimension checking -- all dims must be the same. - CHECK(this_blob->shape() == owner_blob->shape()); + CHECK(this_blob->shape() == owner_blob->shape()) + << "Cannot share param '" << param_name << "' owned by layer '" + << layer_names_[owner_layer_id] << "' with layer '" + << layer_names_[layer_id] << "'; shape mismatch. Owner layer param " + << "shape is " << owner_blob->shape_string() << "; sharing layer " + << "expects shape " << this_blob->shape_string(); } const int learnable_param_id = learnable_param_ids_[owner_net_param_id]; learnable_param_ids_.push_back(learnable_param_id); @@ -775,7 +785,11 @@ void Net::ShareTrainedLayersWith(const Net* other) { << "Incompatible number of blobs for layer " << source_layer_name; for (int j = 0; j < target_blobs.size(); ++j) { Blob* source_blob = source_layer->blobs()[j].get(); - CHECK(target_blobs[j]->shape() == source_blob->shape()); + CHECK(target_blobs[j]->shape() == source_blob->shape()) + << "Cannot share param " << j << " weights from layer '" + << source_layer_name << "'; shape mismatch. Source param shape is " + << source_blob->shape_string() << "; target param shape is " + << target_blobs[j]->shape_string(); target_blobs[j]->ShareData(*source_blob); } } @@ -839,6 +853,17 @@ void Net::CopyTrainedLayersFrom(const NetParameter& param) { CHECK_EQ(target_blobs.size(), source_layer.blobs_size()) << "Incompatible number of blobs for layer " << source_layer_name; for (int j = 0; j < target_blobs.size(); ++j) { + if (!target_blobs[j]->ShapeEquals(source_layer.blobs(j))) { + Blob source_blob; + const bool kReshape = true; + source_blob.FromProto(source_layer.blobs(j), kReshape); + LOG(FATAL) << "Cannot copy param " << j << " weights from layer '" + << source_layer_name << "'; shape mismatch. Source param shape is " + << source_blob.shape_string() << "; target param shape is " + << target_blobs[j]->shape_string() << ". " + << "To learn this layer's parameters from scratch rather than " + << "copying from a saved net, rename the layer."; + } const bool kReshape = false; target_blobs[j]->FromProto(source_layer.blobs(j), kReshape); } diff --git a/src/caffe/util/insert_splits.cpp b/src/caffe/util/insert_splits.cpp index 416f80ab3c2..475a2a9f618 100644 --- a/src/caffe/util/insert_splits.cpp +++ b/src/caffe/util/insert_splits.cpp @@ -32,7 +32,8 @@ void InsertSplits(const NetParameter& param, NetParameter* param_split) { const string& blob_name = layer_param.bottom(j); if (blob_name_to_last_top_idx.find(blob_name) == blob_name_to_last_top_idx.end()) { - LOG(FATAL) << "Unknown blob input " << blob_name << " to layer " << j; + LOG(FATAL) << "Unknown bottom blob '" << blob_name << "' (layer '" + << layer_param.name() << "', bottom index " << j << ")"; } const pair& bottom_idx = make_pair(i, j); const pair& top_idx = blob_name_to_last_top_idx[blob_name]; From 660cd1239038bac54942c1c4fefe694413e633a0 Mon Sep 17 00:00:00 2001 From: Cyprien Noel Date: Fri, 14 Aug 2015 16:22:34 -0700 Subject: [PATCH 156/331] New make target to only build the library. --- Makefile | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index 05b783af35c..80bc37375be 100644 --- a/Makefile +++ b/Makefile @@ -386,11 +386,13 @@ endif ############################## # Define build targets ############################## -.PHONY: all test clean docs linecount lint lintclean tools examples $(DIST_ALIASES) \ +.PHONY: all lib test clean docs linecount lint lintclean tools examples $(DIST_ALIASES) \ py mat py$(PROJECT) mat$(PROJECT) proto runtest \ superclean supercleanlist supercleanfiles warn everything -all: $(STATIC_NAME) $(DYNAMIC_NAME) tools examples +all: lib tools examples + +lib: $(STATIC_NAME) $(DYNAMIC_NAME) everything: $(EVERYTHING_TARGETS) From 3778a2a6ca1c5d909f12add066478d04fe44b8cd Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Fri, 14 Aug 2015 13:52:01 -0700 Subject: [PATCH 157/331] Fix MultiGPU solver test with TEST_GPUID != 1 This is a patch for multi-gpu testing issue (#2926). The problem fixed in this commit is that when calling make runtest with TEST_GPUID != 0 on a MultiGPU machine, solver tests will crash because gpu ids in multi-gpu tests doesn't match that of single GPU test. --- src/caffe/test/test_gradient_based_solver.cpp | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index dcbfff1cad2..7ad7467f86f 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -73,12 +73,19 @@ class GradientBasedSolverTest : public MultiDeviceTest { const int iter_size = 1, const int devices = 1, const bool snapshot = false, const char* from_snapshot = NULL) { ostringstream proto; + int device_id = 0; +#ifndef CPU_ONLY + if (Caffe::mode() == Caffe::GPU) { + CUDA_CHECK(cudaGetDevice(&device_id)); + } +#endif proto << "snapshot_after_train: " << snapshot << " " "max_iter: " << num_iters << " " "base_lr: " << learning_rate << " " "lr_policy: 'fixed' " "iter_size: " << iter_size << " " + "device_id: " << device_id << " " "net_param { " " name: 'TestNetwork' " " layer { " @@ -189,8 +196,12 @@ class GradientBasedSolverTest : public MultiDeviceTest { } else { LOG(INFO) << "Multi-GPU test on " << devices << " devices"; vector gpus; - for (int i = 0; i < devices; ++i) { - gpus.push_back(i); + // put current device at the beginning + int device_id = solver_->param().device_id(); + gpus.push_back(device_id); + for (int i = 0; gpus.size() < devices; ++i) { + if (i != device_id) + gpus.push_back(i); } Caffe::set_solver_count(gpus.size()); this->sync_.reset(new P2PSync( From 09868aced72a20bc30198b84a225e58fdd6f13a6 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Sat, 15 Aug 2015 19:02:57 -0700 Subject: [PATCH 158/331] Malloc at least 1 byte for MultiGPU P2PSync buffers --- src/caffe/parallel.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index d48136c56b8..a6d154e168e 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -55,7 +55,8 @@ static void apply_buffers(const vector*>& blobs, } ptr += size; } - CHECK_EQ(total_size, ptr - buffer); + // total_size is at least one byte + CHECK_EQ(total_size, (ptr == buffer ? 1 : ptr - buffer)); } // Buffer size necessary to store given blobs From 7453bbf6ea1aeb03330b5892a06276b69434f699 Mon Sep 17 00:00:00 2001 From: mhouston Date: Tue, 18 Aug 2015 13:40:00 -0700 Subject: [PATCH 159/331] Add some documentation on Multi-GPU support --- docs/multigpu.md | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 docs/multigpu.md diff --git a/docs/multigpu.md b/docs/multigpu.md new file mode 100644 index 00000000000..4b202347417 --- /dev/null +++ b/docs/multigpu.md @@ -0,0 +1,24 @@ +--- +title: Multi-GPU Usage, Hardware Configuration Assumptions, and Performance +--- + +# Multi-GPU Usage + +Currently Multi-GPU is only supported via the C/C++ paths and only for training. + +The GPUs to be used for training can be set with the "-gpu" flag on the command line to the 'caffe' tool. e.g. "build/tools/caffe train --solver=models/bvlc_alexnet/solver.prototxt --gpu=0,1" will train on GPUs 0 and 1. + +**NOTE**: each GPU runs the batchsize specified in your train_val.prototxt. So if you go from 1 GPU to 2 GPU, your effective batchsize will double. e.g. if your train_val.prototxt specified a batchsize of 256, if you run 2 GPUs your effective batch size is now 512. So you need to adjust the batchsize when running multiple GPUs and/or adjust your solver params, specifically learning rate. + +# Hardware Configuration Assumptions + +The current implementation uses a tree reduction strategy. e.g. if there are 4 GPUs in the system, 0:1, 2:3 will exchange gradients, then 0:2 (top of the tree) will exchange gradients, 0 will calculate +updated model, 0\-\>2, and then 0\-\>1, 2\-\>3. + +For best performance, P2P DMA access between devices is needed. Without P2P access, for example crossing PCIe root complex, data is copied through host and effective exchange bandwidth is greatly reduced. + +Current implementation has a "soft" assumption that the devices being used are homogeneous. In practice, any devices of the same general class should work together, but performance and total size is limited by the smallest device being used. e.g. if you combine a TitanX and a GTX980, peformance will be limited by the 980. Mixing vastly different levels of boards, e.g. Kepler and Fermi, is not supported. + +# Scaling Performance + +Performance is **heavily** dependent on the PCIe topology of the system, the configuration of the neural network you are training, and the speed of each of the layers. Systems like the DIGITS DevBox have an optimized PCIe topology (X99-E WS chipset). In general, scaling on 2 GPUs tends to be ~1.8X on average for networks like AlexNet, CaffeNet, VGG, GoogleNet. 4 GPUs begins to have falloff in scaling. Generally with "weak scaling" where the batchsize increases with the number of GPUs you will see 3.5x scaling or so. With "strong scaling", the system can become communication bound, especially with layer performance optimizations like those in [cuDNNv3](http://nvidia.com/cudnn), and you will likely see closer to mid 2.x scaling in performance. Networks that have heavy computation compared to the number of parameters tend to have the best scaling performance. \ No newline at end of file From 26a9880d72e81d415d1dc3bf449586ce54185ea4 Mon Sep 17 00:00:00 2001 From: mhouston Date: Tue, 18 Aug 2015 15:29:26 -0700 Subject: [PATCH 160/331] Add information about how to get GPU topology from nvidia-smi --- docs/multigpu.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/multigpu.md b/docs/multigpu.md index 4b202347417..01cfb8938b5 100644 --- a/docs/multigpu.md +++ b/docs/multigpu.md @@ -19,6 +19,8 @@ For best performance, P2P DMA access between devices is needed. Without P2P acce Current implementation has a "soft" assumption that the devices being used are homogeneous. In practice, any devices of the same general class should work together, but performance and total size is limited by the smallest device being used. e.g. if you combine a TitanX and a GTX980, peformance will be limited by the 980. Mixing vastly different levels of boards, e.g. Kepler and Fermi, is not supported. +"nvidia-smi topo -m" will show you the connectivity matrix. You can do P2P through PCIe bridges, but not across socket level links at this time, e.g. across CPU sockets on a multi-socket motherboard. + # Scaling Performance Performance is **heavily** dependent on the PCIe topology of the system, the configuration of the neural network you are training, and the speed of each of the layers. Systems like the DIGITS DevBox have an optimized PCIe topology (X99-E WS chipset). In general, scaling on 2 GPUs tends to be ~1.8X on average for networks like AlexNet, CaffeNet, VGG, GoogleNet. 4 GPUs begins to have falloff in scaling. Generally with "weak scaling" where the batchsize increases with the number of GPUs you will see 3.5x scaling or so. With "strong scaling", the system can become communication bound, especially with layer performance optimizations like those in [cuDNNv3](http://nvidia.com/cudnn), and you will likely see closer to mid 2.x scaling in performance. Networks that have heavy computation compared to the number of parameters tend to have the best scaling performance. \ No newline at end of file From 3b00ca6d32647e683d9808d13243bd0240550901 Mon Sep 17 00:00:00 2001 From: max argus Date: Thu, 20 Aug 2015 09:01:58 +0000 Subject: [PATCH 161/331] In BasePrefetchingDataLayer::Forward_cpu hanged top[0]->Reshape to top[0]->ReshapeLike, in line with other calls. --- src/caffe/layers/base_data_layer.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/caffe/layers/base_data_layer.cpp b/src/caffe/layers/base_data_layer.cpp index 5303fe9c5d3..b90bd4e0caf 100644 --- a/src/caffe/layers/base_data_layer.cpp +++ b/src/caffe/layers/base_data_layer.cpp @@ -105,8 +105,7 @@ void BasePrefetchingDataLayer::Forward_cpu( const vector*>& bottom, const vector*>& top) { Batch* batch = prefetch_full_.pop("Data layer prefetch queue empty"); // Reshape to loaded data. - top[0]->Reshape(batch->data_.num(), batch->data_.channels(), - batch->data_.height(), batch->data_.width()); + top[0]->ReshapeLike(batch->data_); // Copy the data caffe_copy(batch->data_.count(), batch->data_.cpu_data(), top[0]->mutable_cpu_data()); From 51b172ce2fcd7f63aa7830389af54d353f53a3bc Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Fri, 14 Aug 2015 16:53:39 -0700 Subject: [PATCH 162/331] Expose LayerFactory::LayerTypeList in pycaffe Useful for validating NetParameters without crashing on SIGABRT --- include/caffe/layer_factory.hpp | 31 +++++++++++++++-------- python/caffe/__init__.py | 2 +- python/caffe/_caffe.cpp | 2 ++ python/caffe/test/test_layer_type_list.py | 10 ++++++++ 4 files changed, 34 insertions(+), 11 deletions(-) create mode 100644 python/caffe/test/test_layer_type_list.py diff --git a/include/caffe/layer_factory.hpp b/include/caffe/layer_factory.hpp index 32e849de0d2..2c2fde4d979 100644 --- a/include/caffe/layer_factory.hpp +++ b/include/caffe/layer_factory.hpp @@ -41,6 +41,7 @@ #include #include +#include #include "caffe/common.hpp" #include "caffe/proto/caffe.pb.h" @@ -77,26 +78,36 @@ class LayerRegistry { const string& type = param.type(); CreatorRegistry& registry = Registry(); CHECK_EQ(registry.count(type), 1) << "Unknown layer type: " << type - << " (known types: " << LayerTypeList() << ")"; + << " (known types: " << LayerTypeListString() << ")"; return registry[type](param); } + static vector LayerTypeList() { + CreatorRegistry& registry = Registry(); + vector layer_types; + for (typename CreatorRegistry::iterator iter = registry.begin(); + iter != registry.end(); ++iter) { + layer_types.push_back(iter->first); + } + return layer_types; + } + private: // Layer registry should never be instantiated - everything is done with its // static variables. LayerRegistry() {} - static string LayerTypeList() { - CreatorRegistry& registry = Registry(); - string layer_types; - for (typename CreatorRegistry::iterator iter = registry.begin(); - iter != registry.end(); ++iter) { - if (iter != registry.begin()) { - layer_types += ", "; + static string LayerTypeListString() { + vector layer_types = LayerTypeList(); + string layer_types_str; + for (vector::iterator iter = layer_types.begin(); + iter != layer_types.end(); ++iter) { + if (iter != layer_types.begin()) { + layer_types_str += ", "; } - layer_types += iter->first; + layer_types_str += *iter; } - return layer_types; + return layer_types_str; } }; diff --git a/python/caffe/__init__.py b/python/caffe/__init__.py index 1b2da510a90..6cc44e729f4 100644 --- a/python/caffe/__init__.py +++ b/python/caffe/__init__.py @@ -1,5 +1,5 @@ from .pycaffe import Net, SGDSolver -from ._caffe import set_mode_cpu, set_mode_gpu, set_device, Layer, get_solver +from ._caffe import set_mode_cpu, set_mode_gpu, set_device, Layer, get_solver, layer_type_list from .proto.caffe_pb2 import TRAIN, TEST from .classifier import Classifier from .detector import Detector diff --git a/python/caffe/_caffe.cpp b/python/caffe/_caffe.cpp index bb5130fddd0..f9b2dba1d64 100644 --- a/python/caffe/_caffe.cpp +++ b/python/caffe/_caffe.cpp @@ -200,6 +200,8 @@ BOOST_PYTHON_MODULE(_caffe) { bp::def("set_mode_gpu", &set_mode_gpu); bp::def("set_device", &Caffe::SetDevice); + bp::def("layer_type_list", &LayerRegistry::LayerTypeList); + bp::class_, shared_ptr >, boost::noncopyable >("Net", bp::no_init) .def("__init__", bp::make_constructor(&Net_Init)) diff --git a/python/caffe/test/test_layer_type_list.py b/python/caffe/test/test_layer_type_list.py new file mode 100644 index 00000000000..7edc80df069 --- /dev/null +++ b/python/caffe/test/test_layer_type_list.py @@ -0,0 +1,10 @@ +import unittest + +import caffe + +class TestLayerTypeList(unittest.TestCase): + + def test_standard_types(self): + for type_name in ['Data', 'Convolution', 'InnerProduct']: + self.assertIn(type_name, caffe.layer_type_list(), + '%s not in layer_type_list()' % type_name) From 35657e31ad82f73a0682deb52cb1606b33a202be Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Thu, 20 Aug 2015 11:54:08 -0700 Subject: [PATCH 163/331] DeconvolutionLayer Backward_gpu fix: don't redo im2col --- src/caffe/layers/deconv_layer.cu | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/caffe/layers/deconv_layer.cu b/src/caffe/layers/deconv_layer.cu index 39bc4de8c66..8a1eed8aa16 100644 --- a/src/caffe/layers/deconv_layer.cu +++ b/src/caffe/layers/deconv_layer.cu @@ -52,7 +52,8 @@ void DeconvolutionLayer::Backward_gpu(const vector*>& top, // gradient w.r.t. bottom data, if necessary. if (propagate_down[i]) { this->forward_gpu_gemm(top_diff + top[i]->offset(n), weight, - bottom_diff + bottom[i]->offset(n)); + bottom_diff + bottom[i]->offset(n), + this->param_propagate_down_[0]); } } } From 2f5889cb84b8c7f8f64a6b7eb48e1dc624b18162 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 20 Aug 2015 14:29:02 -0700 Subject: [PATCH 164/331] Use input_shape instead of input_dim in examples --- examples/cifar10/cifar10_full.prototxt | 10 ++++++---- examples/cifar10/cifar10_quick.prototxt | 10 ++++++---- examples/mnist/lenet.prototxt | 10 ++++++---- examples/net_surgery/bvlc_caffenet_full_conv.prototxt | 10 ++++++---- examples/net_surgery/conv.prototxt | 10 ++++++---- examples/siamese/mnist_siamese.prototxt | 10 ++++++---- models/bvlc_alexnet/deploy.prototxt | 10 ++++++---- models/bvlc_googlenet/deploy.prototxt | 10 ++++++---- models/bvlc_reference_caffenet/deploy.prototxt | 10 ++++++---- models/bvlc_reference_rcnn_ilsvrc13/deploy.prototxt | 10 ++++++---- models/finetune_flickr_style/deploy.prototxt | 10 ++++++---- 11 files changed, 66 insertions(+), 44 deletions(-) diff --git a/examples/cifar10/cifar10_full.prototxt b/examples/cifar10/cifar10_full.prototxt index c16f7dca49f..446479da961 100644 --- a/examples/cifar10/cifar10_full.prototxt +++ b/examples/cifar10/cifar10_full.prototxt @@ -2,10 +2,12 @@ name: "CIFAR10_full_deploy" # N.B. input image must be in CIFAR-10 format # as described at http://www.cs.toronto.edu/~kriz/cifar.html input: "data" -input_dim: 1 -input_dim: 3 -input_dim: 32 -input_dim: 32 +input_shape { + dim: 1 + dim: 3 + dim: 32 + dim: 32 +} layer { name: "conv1" type: "Convolution" diff --git a/examples/cifar10/cifar10_quick.prototxt b/examples/cifar10/cifar10_quick.prototxt index 1ad190e185f..9352fbf65df 100644 --- a/examples/cifar10/cifar10_quick.prototxt +++ b/examples/cifar10/cifar10_quick.prototxt @@ -1,9 +1,11 @@ name: "CIFAR10_quick_test" input: "data" -input_dim: 1 -input_dim: 3 -input_dim: 32 -input_dim: 32 +input_shape { + dim: 1 + dim: 3 + dim: 32 + dim: 32 +} layer { name: "conv1" type: "Convolution" diff --git a/examples/mnist/lenet.prototxt b/examples/mnist/lenet.prototxt index cb42610fe1e..dff7123bf73 100644 --- a/examples/mnist/lenet.prototxt +++ b/examples/mnist/lenet.prototxt @@ -1,9 +1,11 @@ name: "LeNet" input: "data" -input_dim: 64 -input_dim: 1 -input_dim: 28 -input_dim: 28 +input_shape { + dim: 64 + dim: 1 + dim: 28 + dim: 28 +} layer { name: "conv1" type: "Convolution" diff --git a/examples/net_surgery/bvlc_caffenet_full_conv.prototxt b/examples/net_surgery/bvlc_caffenet_full_conv.prototxt index 3c951970fc1..0cadde9b58b 100644 --- a/examples/net_surgery/bvlc_caffenet_full_conv.prototxt +++ b/examples/net_surgery/bvlc_caffenet_full_conv.prototxt @@ -1,10 +1,12 @@ # Fully convolutional network version of CaffeNet. name: "CaffeNetConv" input: "data" -input_dim: 1 -input_dim: 3 -input_dim: 451 -input_dim: 451 +input_shape { + dim: 1 + dim: 3 + dim: 451 + dim: 451 +} layer { name: "conv1" type: "Convolution" diff --git a/examples/net_surgery/conv.prototxt b/examples/net_surgery/conv.prototxt index 9444c63ab74..6b3e5c768d5 100644 --- a/examples/net_surgery/conv.prototxt +++ b/examples/net_surgery/conv.prototxt @@ -1,10 +1,12 @@ # Simple single-layer network to showcase editing model parameters. name: "convolution" input: "data" -input_dim: 1 -input_dim: 1 -input_dim: 100 -input_dim: 100 +input_shape { + dim: 1 + dim: 1 + dim: 100 + dim: 100 +} layer { name: "conv" type: "Convolution" diff --git a/examples/siamese/mnist_siamese.prototxt b/examples/siamese/mnist_siamese.prototxt index 0e903f85909..332731bd75f 100644 --- a/examples/siamese/mnist_siamese.prototxt +++ b/examples/siamese/mnist_siamese.prototxt @@ -1,9 +1,11 @@ name: "mnist_siamese" input: "data" -input_dim: 10000 -input_dim: 1 -input_dim: 28 -input_dim: 28 +input_shape { + dim: 10000 + dim: 1 + dim: 28 + dim: 28 +} layer { name: "conv1" type: "Convolution" diff --git a/models/bvlc_alexnet/deploy.prototxt b/models/bvlc_alexnet/deploy.prototxt index ced055b85d0..ff10daa9399 100644 --- a/models/bvlc_alexnet/deploy.prototxt +++ b/models/bvlc_alexnet/deploy.prototxt @@ -1,9 +1,11 @@ name: "AlexNet" input: "data" -input_dim: 10 -input_dim: 3 -input_dim: 227 -input_dim: 227 +input_shape { + dim: 10 + dim: 3 + dim: 227 + dim: 227 +} layer { name: "conv1" type: "Convolution" diff --git a/models/bvlc_googlenet/deploy.prototxt b/models/bvlc_googlenet/deploy.prototxt index 4648bf26efc..1f90ee21630 100644 --- a/models/bvlc_googlenet/deploy.prototxt +++ b/models/bvlc_googlenet/deploy.prototxt @@ -1,9 +1,11 @@ name: "GoogleNet" input: "data" -input_dim: 10 -input_dim: 3 -input_dim: 224 -input_dim: 224 +input_shape { + dim: 10 + dim: 3 + dim: 224 + dim: 224 +} layer { name: "conv1/7x7_s2" type: "Convolution" diff --git a/models/bvlc_reference_caffenet/deploy.prototxt b/models/bvlc_reference_caffenet/deploy.prototxt index 29ccf1469f7..127f1e265fd 100644 --- a/models/bvlc_reference_caffenet/deploy.prototxt +++ b/models/bvlc_reference_caffenet/deploy.prototxt @@ -1,9 +1,11 @@ name: "CaffeNet" input: "data" -input_dim: 10 -input_dim: 3 -input_dim: 227 -input_dim: 227 +input_shape { + dim: 10 + dim: 3 + dim: 227 + dim: 227 +} layer { name: "conv1" type: "Convolution" diff --git a/models/bvlc_reference_rcnn_ilsvrc13/deploy.prototxt b/models/bvlc_reference_rcnn_ilsvrc13/deploy.prototxt index ea9cf98a926..ae1df967742 100644 --- a/models/bvlc_reference_rcnn_ilsvrc13/deploy.prototxt +++ b/models/bvlc_reference_rcnn_ilsvrc13/deploy.prototxt @@ -1,9 +1,11 @@ name: "R-CNN-ilsvrc13" input: "data" -input_dim: 10 -input_dim: 3 -input_dim: 227 -input_dim: 227 +input_shape { + dim: 10 + dim: 3 + dim: 227 + dim: 227 +} layer { name: "conv1" type: "Convolution" diff --git a/models/finetune_flickr_style/deploy.prototxt b/models/finetune_flickr_style/deploy.prototxt index 4a924f74927..0f07e47acab 100644 --- a/models/finetune_flickr_style/deploy.prototxt +++ b/models/finetune_flickr_style/deploy.prototxt @@ -1,9 +1,11 @@ name: "FlickrStyleCaffeNet" input: "data" -input_dim: 10 -input_dim: 3 -input_dim: 227 -input_dim: 227 +input_shape { + dim: 10 + dim: 3 + dim: 227 + dim: 227 +} layer { name: "conv1" type: "Convolution" From 7146e596347db81869b5bfa9b4cb014e80be9732 Mon Sep 17 00:00:00 2001 From: David Larson Date: Thu, 20 Aug 2015 15:18:03 -0700 Subject: [PATCH 165/331] [examples] fix link to feature visualization notebook --- examples/feature_extraction/readme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/feature_extraction/readme.md b/examples/feature_extraction/readme.md index a980b8b3203..2bc3dacbb69 100644 --- a/examples/feature_extraction/readme.md +++ b/examples/feature_extraction/readme.md @@ -64,7 +64,7 @@ If you meet with the error "Check failed: status.ok() Failed to open leveldb exa rm -rf examples/_temp/features/ -If you'd like to use the Python wrapper for extracting features, check out the [layer visualization notebook](http://nbviewer.ipython.org/github/BVLC/caffe/blob/master/examples/filter_visualization.ipynb). +If you'd like to use the Python wrapper for extracting features, check out the [filter visualization notebook](http://nbviewer.ipython.org/github/BVLC/caffe/blob/master/examples/00-classification.ipynb). Clean Up -------- From 08086c7580ddfd0d2b996157b3f3b4c1a52fd2b5 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Fri, 21 Aug 2015 21:23:22 -0700 Subject: [PATCH 166/331] remove superfluous code in Net::ToProto --- src/caffe/net.cpp | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index a18ee63818e..554343f9767 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -763,12 +763,6 @@ void Net::ToProto(NetParameter* param, bool write_diff) const { DLOG(INFO) << "Serializing " << layers_.size() << " layers"; for (int i = 0; i < layers_.size(); ++i) { LayerParameter* layer_param = param->add_layer(); - for (int j = 0; j < bottom_id_vecs_[i].size(); ++j) { - layer_param->add_bottom(blob_names_[bottom_id_vecs_[i][j]]); - } - for (int j = 0; j < top_id_vecs_[i].size(); ++j) { - layer_param->add_top(blob_names_[top_id_vecs_[i][j]]); - } layers_[i]->ToProto(layer_param, write_diff); } } From ff19d5f5c010dd8d6bfcf768b4fe27d0458f17df Mon Sep 17 00:00:00 2001 From: J Yegerlehner Date: Fri, 3 Apr 2015 16:11:23 -0500 Subject: [PATCH 167/331] Add signal handler and early exit/snapshot to Solver. Add signal handler and early exit/snapshot to Solver. Add signal handler and early exit/snapshot to Solver. Also check for exit and snapshot when testing. Skip running test after early exit. Fix more lint. Rebase on master. Finish rebase on master. Fixups per review comments. Redress review comments. Lint. Correct error message wording. --- include/caffe/solver.hpp | 37 ++++++++- include/caffe/util/signal_handler.h | 24 ++++++ src/caffe/solver.cpp | 70 +++++++++++++++-- src/caffe/util/signal_handler.cpp | 115 ++++++++++++++++++++++++++++ tools/caffe.cpp | 32 +++++++- 5 files changed, 268 insertions(+), 10 deletions(-) create mode 100644 include/caffe/util/signal_handler.h create mode 100644 src/caffe/util/signal_handler.cpp diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index ab12ef1b1bd..aba3e036004 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -1,6 +1,6 @@ #ifndef CAFFE_OPTIMIZATION_SOLVER_HPP_ #define CAFFE_OPTIMIZATION_SOLVER_HPP_ - +#include #include #include @@ -8,6 +8,28 @@ namespace caffe { +/** + * @brief Enumeration of actions that a client of the Solver may request by + * implementing the Solver's action request function, which a + * a client may optionally provide in order to request early termination + * or saving a snapshot without exiting. In the executable caffe, this + * mechanism is used to allow the snapshot to be saved when stopping + * execution with a SIGINT (Ctrl-C). + */ + namespace SolverAction { + enum Enum { + NONE = 0, // Take no special action. + STOP = 1, // Stop training. snapshot_after_train controls whether a + // snapshot is created. + SNAPSHOT = 2 // Take a snapshot, and keep training. + }; + } + +/** + * @brief Type of a function that returns a Solver Action enumeration. + */ +typedef boost::function ActionCallback; + /** * @brief An interface for classes that perform optimization on Net%s. * @@ -23,6 +45,12 @@ class Solver { void Init(const SolverParameter& param); void InitTrainNet(); void InitTestNets(); + + // Client of the Solver optionally may call this in order to set the function + // that the solver uses to see what action it should take (e.g. snapshot or + // exit training early). + void SetActionFunction(ActionCallback func); + SolverAction::Enum GetRequestedAction(); // The main entry of the solver function. In default, iter will be zero. Pass // in a non-zero iter number to resume training for a pre-trained net. virtual void Solve(const char* resume_file = NULL); @@ -84,6 +112,13 @@ class Solver { // in data parallelism const Solver* const root_solver_; + // A function that can be set by a client of the Solver to provide indication + // that it wants a snapshot saved and/or to exit early. + ActionCallback action_request_function_; + + // True iff a request to stop early was received. + bool requested_early_exit_; + DISABLE_COPY_AND_ASSIGN(Solver); }; diff --git a/include/caffe/util/signal_handler.h b/include/caffe/util/signal_handler.h new file mode 100644 index 00000000000..fb84c65bd2e --- /dev/null +++ b/include/caffe/util/signal_handler.h @@ -0,0 +1,24 @@ +#ifndef INCLUDE_CAFFE_UTIL_SIGNAL_HANDLER_H_ +#define INCLUDE_CAFFE_UTIL_SIGNAL_HANDLER_H_ + +#include "caffe/proto/caffe.pb.h" +#include "caffe/solver.hpp" + +namespace caffe { + +class SignalHandler { + public: + // Contructor. Specify what action to take when a signal is received. + SignalHandler(SolverAction::Enum SIGINT_action, + SolverAction::Enum SIGHUP_action); + ~SignalHandler(); + ActionCallback GetActionFunction(); + private: + SolverAction::Enum CheckForSignals() const; + SolverAction::Enum SIGINT_action_; + SolverAction::Enum SIGHUP_action_; +}; + +} // namespace caffe + +#endif // INCLUDE_CAFFE_UTIL_SIGNAL_HANDLER_H_ diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 9348e11c249..394ec3b3ad7 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -17,15 +17,31 @@ namespace caffe { +template +void Solver::SetActionFunction(ActionCallback func) { + action_request_function_ = func; +} + +template +SolverAction::Enum Solver::GetRequestedAction() { + if (action_request_function_) { + // If the external request function has been set, call it. + return action_request_function_(); + } + return SolverAction::NONE; +} + template Solver::Solver(const SolverParameter& param, const Solver* root_solver) - : net_(), callbacks_(), root_solver_(root_solver) { + : net_(), callbacks_(), root_solver_(root_solver), + requested_early_exit_(false) { Init(param); } template Solver::Solver(const string& param_file, const Solver* root_solver) - : net_(), callbacks_(), root_solver_(root_solver) { + : net_(), callbacks_(), root_solver_(root_solver), + requested_early_exit_(false) { SolverParameter param; ReadProtoFromTextFileOrDie(param_file, ¶m); Init(param); @@ -195,6 +211,10 @@ void Solver::Step(int iters) { && (iter_ > 0 || param_.test_initialization()) && Caffe::root_solver()) { TestAll(); + if (requested_early_exit_) { + // Break out of the while loop because stop was requested while testing. + break; + } } for (int i = 0; i < callbacks_.size(); ++i) { @@ -250,12 +270,20 @@ void Solver::Step(int iters) { // the number of times the weights have been updated. ++iter_; + SolverAction::Enum request = GetRequestedAction(); + // Save a snapshot if needed. - if (param_.snapshot() - && iter_ % param_.snapshot() == 0 - && Caffe::root_solver()) { + if ((param_.snapshot() + && iter_ % param_.snapshot() == 0 + && Caffe::root_solver()) || + (request == SolverAction::SNAPSHOT)) { Snapshot(); } + if (SolverAction::STOP == request) { + requested_early_exit_ = true; + // Break out of training loop. + break; + } } } @@ -265,6 +293,9 @@ void Solver::Solve(const char* resume_file) { LOG(INFO) << "Solving " << net_->name(); LOG(INFO) << "Learning Rate Policy: " << param_.lr_policy(); + // Initialize to false every time we start solving. + requested_early_exit_ = false; + if (resume_file) { LOG(INFO) << "Restoring previous solver status from " << resume_file; Restore(resume_file); @@ -279,6 +310,10 @@ void Solver::Solve(const char* resume_file) { && (!param_.snapshot() || iter_ % param_.snapshot() != 0)) { Snapshot(); } + if (requested_early_exit_) { + LOG(INFO) << "Optimization stopped early."; + return; + } // After the optimization is done, run an additional train and test pass to // display the train and test loss/outputs if appropriate (based on the // display and test_interval settings, respectively). Unlike in the rest of @@ -296,10 +331,11 @@ void Solver::Solve(const char* resume_file) { LOG(INFO) << "Optimization Done."; } - template void Solver::TestAll() { - for (int test_net_id = 0; test_net_id < test_nets_.size(); ++test_net_id) { + for (int test_net_id = 0; + test_net_id < test_nets_.size() && !requested_early_exit_; + ++test_net_id) { Test(test_net_id); } } @@ -317,6 +353,21 @@ void Solver::Test(const int test_net_id) { const shared_ptr >& test_net = test_nets_[test_net_id]; Dtype loss = 0; for (int i = 0; i < param_.test_iter(test_net_id); ++i) { + SolverAction::Enum request = GetRequestedAction(); + // Check to see if stoppage of testing/training has been requested. + while (request != SolverAction::NONE) { + if (SolverAction::SNAPSHOT == request) { + Snapshot(); + } else if (SolverAction::STOP == request) { + requested_early_exit_ = true; + } + request = GetRequestedAction(); + } + if (requested_early_exit_) { + // break out of test loop. + break; + } + Dtype iter_loss; const vector*>& result = test_net->Forward(bottom_vec, &iter_loss); @@ -341,6 +392,10 @@ void Solver::Test(const int test_net_id) { } } } + if (requested_early_exit_) { + LOG(INFO) << "Test interrupted."; + return; + } if (param_.test_compute_loss()) { loss /= param_.test_iter(test_net_id); LOG(INFO) << "Test loss: " << loss; @@ -361,7 +416,6 @@ void Solver::Test(const int test_net_id) { } } - template void Solver::Snapshot() { CHECK(Caffe::root_solver()); diff --git a/src/caffe/util/signal_handler.cpp b/src/caffe/util/signal_handler.cpp new file mode 100644 index 00000000000..5d764ec524f --- /dev/null +++ b/src/caffe/util/signal_handler.cpp @@ -0,0 +1,115 @@ +#include +#include + +#include +#include + +#include "caffe/util/signal_handler.h" + +namespace { + static volatile sig_atomic_t got_sigint = false; + static volatile sig_atomic_t got_sighup = false; + static bool already_hooked_up = false; + + void handle_signal(int signal) { + switch (signal) { + case SIGHUP: + got_sighup = true; + break; + case SIGINT: + got_sigint = true; + break; + } + } + + void HookupHandler() { + if (already_hooked_up) { + LOG(FATAL) << "Tried to hookup signal handlers more than once."; + } + already_hooked_up = true; + + struct sigaction sa; + // Setup the handler + sa.sa_handler = &handle_signal; + // Restart the system call, if at all possible + sa.sa_flags = SA_RESTART; + // Block every signal during the handler + sigfillset(&sa.sa_mask); + // Intercept SIGHUP and SIGINT + if (sigaction(SIGHUP, &sa, NULL) == -1) { + LOG(FATAL) << "Cannot install SIGHUP handler."; + } + if (sigaction(SIGINT, &sa, NULL) == -1) { + LOG(FATAL) << "Cannot install SIGINT handler."; + } + } + + // Set the signal handlers to the default. + void UnhookHandler() { + if (already_hooked_up) { + struct sigaction sa; + // Setup the sighub handler + sa.sa_handler = SIG_DFL; + // Restart the system call, if at all possible + sa.sa_flags = SA_RESTART; + // Block every signal during the handler + sigfillset(&sa.sa_mask); + // Intercept SIGHUP and SIGINT + if (sigaction(SIGHUP, &sa, NULL) == -1) { + LOG(FATAL) << "Cannot uninstall SIGHUP handler."; + } + if (sigaction(SIGINT, &sa, NULL) == -1) { + LOG(FATAL) << "Cannot uninstall SIGINT handler."; + } + + already_hooked_up = false; + } + } + + // Return true iff a SIGINT has been received since the last time this + // function was called. + bool GotSIGINT() { + bool result = got_sigint; + got_sigint = false; + return result; + } + + // Return true iff a SIGHUP has been received since the last time this + // function was called. + bool GotSIGHUP() { + bool result = got_sighup; + got_sighup = false; + return result; + } +} // namespace + +namespace caffe { + +SignalHandler::SignalHandler(SolverAction::Enum SIGINT_action, + SolverAction::Enum SIGHUP_action): + SIGINT_action_(SIGINT_action), + SIGHUP_action_(SIGHUP_action) { + HookupHandler(); +} + +SignalHandler::~SignalHandler() { + UnhookHandler(); +} + +SolverAction::Enum SignalHandler::CheckForSignals() const { + if (GotSIGHUP()) { + return SIGHUP_action_; + } + if (GotSIGINT()) { + return SIGINT_action_; + } + return SolverAction::NONE; +} + +// Return the function that the solver can use to find out if a snapshot or +// early exit is being requested. +ActionCallback SignalHandler::GetActionFunction() { + return boost::bind(&SignalHandler::CheckForSignals, this); +} + +} // namespace caffe diff --git a/tools/caffe.cpp b/tools/caffe.cpp index 9f31b37ac2b..ff63860a3c1 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -12,6 +12,7 @@ namespace bp = boost::python; #include "boost/algorithm/string.hpp" #include "caffe/caffe.hpp" +#include "caffe/util/signal_handler.h" using caffe::Blob; using caffe::Caffe; @@ -39,6 +40,12 @@ DEFINE_string(weights, "", "separated by ','. Cannot be set simultaneously with snapshot."); DEFINE_int32(iterations, 50, "The number of iterations to run."); +DEFINE_string(sigint_effect, "stop", + "Optional; action to take when a SIGINT signal is received: " + "snapshot, stop or none."); +DEFINE_string(sighup_effect, "snapshot", + "Optional; action to take when a SIGHUP signal is received: " + "snapshot, stop or none."); // A simple registry for caffe commands. typedef int (*BrewFunction)(); @@ -126,6 +133,22 @@ void CopyLayers(caffe::Solver* solver, const std::string& model_list) { } } +// Translate the signal effect the user specified on the command-line to the +// corresponding enumeration. +caffe::SolverAction::Enum GetRequestedAction( + const std::string& flag_value) { + if (flag_value == "stop") { + return caffe::SolverAction::STOP; + } + if (flag_value == "snapshot") { + return caffe::SolverAction::SNAPSHOT; + } + if (flag_value == "none") { + return caffe::SolverAction::NONE; + } + LOG(FATAL) << "Invalid signal effect \""<< flag_value << "\" was specified"; +} + // Train / Finetune a model. int train() { CHECK_GT(FLAGS_solver.size(), 0) << "Need a solver definition to train."; @@ -165,7 +188,14 @@ int train() { Caffe::set_solver_count(gpus.size()); } - shared_ptr > solver(caffe::GetSolver(solver_param)); + caffe::SignalHandler signal_handler( + GetRequestedAction(FLAGS_sigint_effect), + GetRequestedAction(FLAGS_sighup_effect)); + + shared_ptr > + solver(caffe::GetSolver(solver_param)); + + solver->SetActionFunction(signal_handler.GetActionFunction()); if (FLAGS_snapshot.size()) { LOG(INFO) << "Resuming from " << FLAGS_snapshot; From 374fb8c79c3f23ee36c46d0bcaeb2176037aa4b8 Mon Sep 17 00:00:00 2001 From: Ran Date: Sat, 15 Aug 2015 20:09:43 +0300 Subject: [PATCH 168/331] Output accuracies per class. Fixed case where number of samples in class can be zero. - Fixed ignore_label case, also added a test. - Two other fixes. Fixed lint errors. Small fix. --- include/caffe/loss_layers.hpp | 8 +- src/caffe/layers/accuracy_layer.cpp | 20 +++++ src/caffe/test/test_accuracy_layer.cpp | 107 +++++++++++++++++++++++++ 3 files changed, 134 insertions(+), 1 deletion(-) diff --git a/include/caffe/loss_layers.hpp b/include/caffe/loss_layers.hpp index 528266394f1..02687a944fb 100644 --- a/include/caffe/loss_layers.hpp +++ b/include/caffe/loss_layers.hpp @@ -39,7 +39,11 @@ class AccuracyLayer : public Layer { virtual inline const char* type() const { return "Accuracy"; } virtual inline int ExactNumBottomBlobs() const { return 2; } - virtual inline int ExactNumTopBlobs() const { return 1; } + + // If there are two top blobs, then the second blob will contain + // accuracies per class. + virtual inline int MinTopBlobs() const { return 1; } + virtual inline int MaxTopBlos() const { return 2; } protected: /** @@ -86,6 +90,8 @@ class AccuracyLayer : public Layer { bool has_ignore_label_; /// The label indicating that an instance should be ignored. int ignore_label_; + /// Keeps counts of the number of samples per class. + Blob nums_buffer_; }; /** diff --git a/src/caffe/layers/accuracy_layer.cpp b/src/caffe/layers/accuracy_layer.cpp index 90aad675ed3..e2d8d9f8a24 100644 --- a/src/caffe/layers/accuracy_layer.cpp +++ b/src/caffe/layers/accuracy_layer.cpp @@ -38,6 +38,13 @@ void AccuracyLayer::Reshape( << "with integer values in {0, 1, ..., C-1}."; vector top_shape(0); // Accuracy is a scalar; 0 axes. top[0]->Reshape(top_shape); + if (top.size() > 1) { + // Per-class accuracy is a vector; 1 axes. + vector top_shape_per_class(1); + top_shape_per_class[0] = bottom[0]->shape(label_axis_); + top[1]->Reshape(top_shape_per_class); + nums_buffer_.Reshape(top_shape_per_class); + } } template @@ -50,6 +57,10 @@ void AccuracyLayer::Forward_cpu(const vector*>& bottom, const int num_labels = bottom[0]->shape(label_axis_); vector maxval(top_k_+1); vector max_id(top_k_+1); + if (top.size() > 1) { + caffe_set(nums_buffer_.count(), Dtype(0), nums_buffer_.mutable_cpu_data()); + caffe_set(top[1]->count(), Dtype(0), top[1]->mutable_cpu_data()); + } int count = 0; for (int i = 0; i < outer_num_; ++i) { for (int j = 0; j < inner_num_; ++j) { @@ -58,6 +69,7 @@ void AccuracyLayer::Forward_cpu(const vector*>& bottom, if (has_ignore_label_ && label_value == ignore_label_) { continue; } + if (top.size() > 1) ++nums_buffer_.mutable_cpu_data()[label_value]; DCHECK_GE(label_value, 0); DCHECK_LT(label_value, num_labels); // Top-k accuracy @@ -73,6 +85,7 @@ void AccuracyLayer::Forward_cpu(const vector*>& bottom, for (int k = 0; k < top_k_; k++) { if (bottom_data_vector[k].second == label_value) { ++accuracy; + if (top.size() > 1) ++top[1]->mutable_cpu_data()[label_value]; break; } } @@ -82,6 +95,13 @@ void AccuracyLayer::Forward_cpu(const vector*>& bottom, // LOG(INFO) << "Accuracy: " << accuracy; top[0]->mutable_cpu_data()[0] = accuracy / count; + if (top.size() > 1) { + for (int i = 0; i < top[1]->count(); ++i) { + top[1]->mutable_cpu_data()[i] = + nums_buffer_.cpu_data()[i] == 0 ? 0 + : top[1]->cpu_data()[i] / nums_buffer_.cpu_data()[i]; + } + } // Accuracy layer should not be used as a loss function. } diff --git a/src/caffe/test/test_accuracy_layer.cpp b/src/caffe/test/test_accuracy_layer.cpp index c14b67cc0e9..94e529b5eee 100644 --- a/src/caffe/test/test_accuracy_layer.cpp +++ b/src/caffe/test/test_accuracy_layer.cpp @@ -22,6 +22,7 @@ class AccuracyLayerTest : public CPUDeviceTest { : blob_bottom_data_(new Blob()), blob_bottom_label_(new Blob()), blob_top_(new Blob()), + blob_top_per_class_(new Blob()), top_k_(3) { vector shape(2); shape[0] = 100; @@ -34,6 +35,8 @@ class AccuracyLayerTest : public CPUDeviceTest { blob_bottom_vec_.push_back(blob_bottom_data_); blob_bottom_vec_.push_back(blob_bottom_label_); blob_top_vec_.push_back(blob_top_); + blob_top_per_class_vec_.push_back(blob_top_); + blob_top_per_class_vec_.push_back(blob_top_per_class_); } virtual void FillBottoms() { @@ -56,12 +59,15 @@ class AccuracyLayerTest : public CPUDeviceTest { delete blob_bottom_data_; delete blob_bottom_label_; delete blob_top_; + delete blob_top_per_class_; } Blob* const blob_bottom_data_; Blob* const blob_bottom_label_; Blob* const blob_top_; + Blob* const blob_top_per_class_; vector*> blob_bottom_vec_; vector*> blob_top_vec_; + vector*> blob_top_per_class_vec_; int top_k_; }; @@ -90,6 +96,20 @@ TYPED_TEST(AccuracyLayerTest, TestSetupTopK) { EXPECT_EQ(this->blob_top_->width(), 1); } +TYPED_TEST(AccuracyLayerTest, TestSetupOutputPerClass) { + LayerParameter layer_param; + AccuracyLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_per_class_vec_); + EXPECT_EQ(this->blob_top_->num(), 1); + EXPECT_EQ(this->blob_top_->channels(), 1); + EXPECT_EQ(this->blob_top_->height(), 1); + EXPECT_EQ(this->blob_top_->width(), 1); + EXPECT_EQ(this->blob_top_per_class_->num(), 10); + EXPECT_EQ(this->blob_top_per_class_->channels(), 1); + EXPECT_EQ(this->blob_top_per_class_->height(), 1); + EXPECT_EQ(this->blob_top_per_class_->width(), 1); +} + TYPED_TEST(AccuracyLayerTest, TestForwardCPU) { LayerParameter layer_param; AccuracyLayer layer(layer_param); @@ -228,4 +248,91 @@ TYPED_TEST(AccuracyLayerTest, TestForwardCPUTopK) { num_correct_labels / 100.0, 1e-4); } +TYPED_TEST(AccuracyLayerTest, TestForwardCPUPerClass) { + LayerParameter layer_param; + Caffe::set_mode(Caffe::CPU); + AccuracyLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_per_class_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_per_class_vec_); + + TypeParam max_value; + int max_id; + int num_correct_labels = 0; + const int num_class = this->blob_top_per_class_->num(); + vector correct_per_class(num_class, 0); + vector num_per_class(num_class, 0); + for (int i = 0; i < 100; ++i) { + max_value = -FLT_MAX; + max_id = 0; + for (int j = 0; j < 10; ++j) { + if (this->blob_bottom_data_->data_at(i, j, 0, 0) > max_value) { + max_value = this->blob_bottom_data_->data_at(i, j, 0, 0); + max_id = j; + } + } + ++num_per_class[this->blob_bottom_label_->data_at(i, 0, 0, 0)]; + if (max_id == this->blob_bottom_label_->data_at(i, 0, 0, 0)) { + ++num_correct_labels; + ++correct_per_class[max_id]; + } + } + EXPECT_NEAR(this->blob_top_->data_at(0, 0, 0, 0), + num_correct_labels / 100.0, 1e-4); + for (int i = 0; i < num_class; ++i) { + EXPECT_NEAR(this->blob_top_per_class_->data_at(i, 0, 0, 0), + static_cast(correct_per_class[i]) / num_per_class[i], + 1e-4); + } +} + + +TYPED_TEST(AccuracyLayerTest, TestForwardCPUPerClassWithIgnoreLabel) { + LayerParameter layer_param; + Caffe::set_mode(Caffe::CPU); + const TypeParam kIgnoreLabelValue = -1; + layer_param.mutable_accuracy_param()->set_ignore_label(kIgnoreLabelValue); + AccuracyLayer layer(layer_param); + // Manually set some labels to the ignore label value (-1). + this->blob_bottom_label_->mutable_cpu_data()[2] = kIgnoreLabelValue; + this->blob_bottom_label_->mutable_cpu_data()[5] = kIgnoreLabelValue; + this->blob_bottom_label_->mutable_cpu_data()[32] = kIgnoreLabelValue; + layer.SetUp(this->blob_bottom_vec_, this->blob_top_per_class_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_per_class_vec_); + + TypeParam max_value; + int max_id; + int num_correct_labels = 0; + const int num_class = this->blob_top_per_class_->num(); + vector correct_per_class(num_class, 0); + vector num_per_class(num_class, 0); + int count = 0; + for (int i = 0; i < 100; ++i) { + if (kIgnoreLabelValue == this->blob_bottom_label_->data_at(i, 0, 0, 0)) { + continue; + } + ++count; + max_value = -FLT_MAX; + max_id = 0; + for (int j = 0; j < 10; ++j) { + if (this->blob_bottom_data_->data_at(i, j, 0, 0) > max_value) { + max_value = this->blob_bottom_data_->data_at(i, j, 0, 0); + max_id = j; + } + } + ++num_per_class[this->blob_bottom_label_->data_at(i, 0, 0, 0)]; + if (max_id == this->blob_bottom_label_->data_at(i, 0, 0, 0)) { + ++num_correct_labels; + ++correct_per_class[max_id]; + } + } + EXPECT_EQ(count, 97); + EXPECT_NEAR(this->blob_top_->data_at(0, 0, 0, 0), + num_correct_labels / TypeParam(count), 1e-4); + for (int i = 0; i < 10; ++i) { + EXPECT_NEAR(this->blob_top_per_class_->data_at(i, 0, 0, 0), + TypeParam(correct_per_class[i]) / num_per_class[i], + 1e-4); + } +} + } // namespace caffe From 4bed0ac9bab45246183184d84ff1b742e60574c7 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Mon, 24 Aug 2015 19:44:18 -0700 Subject: [PATCH 169/331] TestConcatLayer: add gradient check for bottom[1] only (to verify propagate_down[0] == false correctness) --- src/caffe/test/test_concat_layer.cpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/caffe/test/test_concat_layer.cpp b/src/caffe/test/test_concat_layer.cpp index 662a50fa23b..088e0a41685 100644 --- a/src/caffe/test/test_concat_layer.cpp +++ b/src/caffe/test/test_concat_layer.cpp @@ -173,4 +173,13 @@ TYPED_TEST(ConcatLayerTest, TestGradientChannels) { this->blob_top_vec_); } +TYPED_TEST(ConcatLayerTest, TestGradientChannelsBottomOneOnly) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + ConcatLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + checker.CheckGradient(&layer, this->blob_bottom_vec_0_, + this->blob_top_vec_, 1); +} + } // namespace caffe From 6a7d4d6652018245f7bde1499d5208996912f3fb Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Mon, 24 Aug 2015 19:22:54 -0700 Subject: [PATCH 170/331] bugfix for ConcatLayer with propagate_down set if propagate_down[i] was set, offset_concat_axis was not correctly updated for subsequent bottoms i+1, i+2, ... --- src/caffe/layers/concat_layer.cpp | 13 +++++++------ src/caffe/layers/concat_layer.cu | 17 +++++++++-------- 2 files changed, 16 insertions(+), 14 deletions(-) diff --git a/src/caffe/layers/concat_layer.cpp b/src/caffe/layers/concat_layer.cpp index 1cac8fc3387..95fba105b9a 100644 --- a/src/caffe/layers/concat_layer.cpp +++ b/src/caffe/layers/concat_layer.cpp @@ -76,13 +76,14 @@ void ConcatLayer::Backward_cpu(const vector*>& top, int offset_concat_axis = 0; const int top_concat_axis = top[0]->shape(concat_axis_); for (int i = 0; i < bottom.size(); ++i) { - if (!propagate_down[i]) { continue; } - Dtype* bottom_diff = bottom[i]->mutable_cpu_diff(); const int bottom_concat_axis = bottom[i]->shape(concat_axis_); - for (int n = 0; n < num_concats_; ++n) { - caffe_copy(bottom_concat_axis * concat_input_size_, top_diff + - (n * top_concat_axis + offset_concat_axis) * concat_input_size_, - bottom_diff + n * bottom_concat_axis * concat_input_size_); + if (propagate_down[i]) { + Dtype* bottom_diff = bottom[i]->mutable_cpu_diff(); + for (int n = 0; n < num_concats_; ++n) { + caffe_copy(bottom_concat_axis * concat_input_size_, top_diff + + (n * top_concat_axis + offset_concat_axis) * concat_input_size_, + bottom_diff + n * bottom_concat_axis * concat_input_size_); + } } offset_concat_axis += bottom_concat_axis; } diff --git a/src/caffe/layers/concat_layer.cu b/src/caffe/layers/concat_layer.cu index 8f2e85d8f52..3c64c7ef224 100644 --- a/src/caffe/layers/concat_layer.cu +++ b/src/caffe/layers/concat_layer.cu @@ -53,15 +53,16 @@ void ConcatLayer::Backward_gpu(const vector*>& top, const int top_concat_axis = top[0]->shape(concat_axis_); const bool kForward = false; for (int i = 0; i < bottom.size(); ++i) { - if (!propagate_down[i]) { continue; } - Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); const int bottom_concat_axis = bottom[i]->shape(concat_axis_); - const int bottom_concat_size = bottom_concat_axis * concat_input_size_; - const int nthreads = bottom_concat_size * num_concats_; - Concat // NOLINT_NEXT_LINE(whitespace/operators) - <<>>( - nthreads, top_diff, kForward, num_concats_, concat_input_size_, - top_concat_axis, bottom_concat_axis, offset_concat_axis, bottom_diff); + if (propagate_down[i]) { + Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); + const int bottom_concat_size = bottom_concat_axis * concat_input_size_; + const int nthreads = bottom_concat_size * num_concats_; + Concat // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + nthreads, top_diff, kForward, num_concats_, concat_input_size_, + top_concat_axis, bottom_concat_axis, offset_concat_axis, bottom_diff); + } offset_concat_axis += bottom_concat_axis; } } From 6aecb431319df1e6c97a6d15cda77ed62cb04148 Mon Sep 17 00:00:00 2001 From: philkr Date: Wed, 19 Aug 2015 15:11:30 -0700 Subject: [PATCH 171/331] Allow the python layer have weight/parameter blobs. --- python/caffe/_caffe.cpp | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/python/caffe/_caffe.cpp b/python/caffe/_caffe.cpp index 020a5bee16b..1638e9d7cd2 100644 --- a/python/caffe/_caffe.cpp +++ b/python/caffe/_caffe.cpp @@ -189,7 +189,18 @@ bp::object Blob_Reshape(bp::tuple args, bp::dict kwargs) { // We need to explicitly return None to use bp::raw_function. return bp::object(); } - +bp::object BlobVec_add_blob(bp::tuple args, bp::dict kwargs) { + if (bp::len(kwargs) > 0) + throw std::runtime_error("BlobVec.add_blob takes no kwargs"); + typedef vector > > BlobVec; + BlobVec* self = bp::extract(args[0]); + vector shape(bp::len(args) - 1); + for (int i = 1; i < bp::len(args); ++i) + shape[i - 1] = bp::extract(args[i]); + self->push_back(shared_ptr >(new Blob(shape))); + // We need to explicitly return None to use bp::raw_function. + return bp::object(); +} BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(SolveOverloads, Solve, 0, 1); BOOST_PYTHON_MODULE(_caffe) { @@ -288,7 +299,8 @@ BOOST_PYTHON_MODULE(_caffe) { // vector wrappers for all the vector types we use bp::class_ > > >("BlobVec") - .def(bp::vector_indexing_suite > >, true>()); + .def(bp::vector_indexing_suite > >, true>()) + .def("add_blob", bp::raw_function(&BlobVec_add_blob)); bp::class_*> >("RawBlobVec") .def(bp::vector_indexing_suite*>, true>()); bp::class_ > > >("LayerVec") From 60c0d58baab7be6c770d81f4c5a7cc1fce0ef7af Mon Sep 17 00:00:00 2001 From: philkr Date: Tue, 25 Aug 2015 10:20:53 -0700 Subject: [PATCH 172/331] Python parameter test added --- python/caffe/_caffe.cpp | 8 +++- python/caffe/test/test_python_layer.py | 54 ++++++++++++++++++++++++++ 2 files changed, 60 insertions(+), 2 deletions(-) diff --git a/python/caffe/_caffe.cpp b/python/caffe/_caffe.cpp index 1638e9d7cd2..cc49f60ab13 100644 --- a/python/caffe/_caffe.cpp +++ b/python/caffe/_caffe.cpp @@ -189,18 +189,22 @@ bp::object Blob_Reshape(bp::tuple args, bp::dict kwargs) { // We need to explicitly return None to use bp::raw_function. return bp::object(); } + bp::object BlobVec_add_blob(bp::tuple args, bp::dict kwargs) { - if (bp::len(kwargs) > 0) + if (bp::len(kwargs) > 0) { throw std::runtime_error("BlobVec.add_blob takes no kwargs"); + } typedef vector > > BlobVec; BlobVec* self = bp::extract(args[0]); vector shape(bp::len(args) - 1); - for (int i = 1; i < bp::len(args); ++i) + for (int i = 1; i < bp::len(args); ++i) { shape[i - 1] = bp::extract(args[i]); + } self->push_back(shared_ptr >(new Blob(shape))); // We need to explicitly return None to use bp::raw_function. return bp::object(); } + BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(SolveOverloads, Solve, 0, 1); BOOST_PYTHON_MODULE(_caffe) { diff --git a/python/caffe/test/test_python_layer.py b/python/caffe/test/test_python_layer.py index a1e11bc248d..8ed86655ec3 100644 --- a/python/caffe/test/test_python_layer.py +++ b/python/caffe/test/test_python_layer.py @@ -28,6 +28,21 @@ class ExceptionLayer(caffe.Layer): def setup(self, bottom, top): raise RuntimeError +class ParameterLayer(caffe.Layer): + """A layer that just multiplies by ten""" + + def setup(self, bottom, top): + self.blobs.add_blob(1) + self.blobs[0].data[0] = 0 + + def reshape(self, bottom, top): + top[0].reshape(*bottom[0].data.shape) + + def forward(self, bottom, top): + pass + + def backward(self, top, propagate_down, bottom): + self.blobs[0].diff[0] = 1 def python_net_file(): with tempfile.NamedTemporaryFile(mode='w+', delete=False) as f: @@ -52,6 +67,16 @@ def exception_net_file(): return f.name +def parameter_net_file(): + with tempfile.NamedTemporaryFile(mode='w+', delete=False) as f: + f.write("""name: 'pythonnet' force_backward: true + input: 'data' input_shape { dim: 10 dim: 9 dim: 8 } + layer { type: 'Python' name: 'layer' bottom: 'data' top: 'top' + python_param { module: 'test_python_layer' layer: 'ParameterLayer' } } + """) + return f.name + + class TestPythonLayer(unittest.TestCase): def setUp(self): net_file = python_net_file() @@ -84,3 +109,32 @@ def test_exception(self): net_file = exception_net_file() self.assertRaises(RuntimeError, caffe.Net, net_file, caffe.TEST) os.remove(net_file) + + def test_parameter(self): + net_file = parameter_net_file() + net = caffe.Net(net_file, caffe.TRAIN) + # Test forward and backward + net.forward() + net.backward() + layer = net.layers[list(net._layer_names).index('layer')] + self.assertEqual(layer.blobs[0].data[0], 0) + self.assertEqual(layer.blobs[0].diff[0], 1) + layer.blobs[0].data[0] += layer.blobs[0].diff[0] + self.assertEqual(layer.blobs[0].data[0], 1) + + # Test saving and loading + h, caffemodel_file = tempfile.mkstemp() + net.save(caffemodel_file) + layer.blobs[0].data[0] = -1 + self.assertEqual(layer.blobs[0].data[0], -1) + net.copy_from(caffemodel_file) + self.assertEqual(layer.blobs[0].data[0], 1) + os.remove(caffemodel_file) + + # Test weight sharing + net2 = caffe.Net(net_file, caffe.TRAIN) + net2.share_with(net) + layer = net.layers[list(net2._layer_names).index('layer')] + self.assertEqual(layer.blobs[0].data[0], 1) + + os.remove(net_file) From 251e67ab3141bc8ac2adf97ea4e961e5664ae008 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Wed, 31 Dec 2014 14:07:00 -0800 Subject: [PATCH 173/331] Add TileLayer --- include/caffe/common_layers.hpp | 29 ++++++ src/caffe/layers/tile_layer.cpp | 62 +++++++++++ src/caffe/layers/tile_layer.cu | 42 ++++++++ src/caffe/proto/caffe.proto | 13 ++- src/caffe/test/test_tile_layer.cpp | 162 +++++++++++++++++++++++++++++ 5 files changed, 307 insertions(+), 1 deletion(-) create mode 100644 src/caffe/layers/tile_layer.cpp create mode 100644 src/caffe/layers/tile_layer.cu create mode 100644 src/caffe/test/test_tile_layer.cpp diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index 691e755f88f..8e64b3e5dc5 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -644,6 +644,35 @@ class SliceLayer : public Layer { vector slice_point_; }; +/** + * @brief Copy a Blob along specified dimensions. + */ +template +class TileLayer : public Layer { + public: + explicit TileLayer(const LayerParameter& param) + : Layer(param) {} + virtual void Reshape(const vector*>& bottom, + const vector*>& top); + + virtual inline const char* type() const { return "Tile"; } + virtual inline int ExactNumBottomBlobs() const { return 1; } + virtual inline int ExactNumTopBlobs() const { return 1; } + + protected: + virtual void Forward_cpu(const vector*>& bottom, + const vector*>& top); + virtual void Forward_gpu(const vector*>& bottom, + const vector*>& top); + + virtual void Backward_cpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + virtual void Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + + unsigned int axis_, tiles_, outer_dim_, inner_dim_; +}; + } // namespace caffe #endif // CAFFE_COMMON_LAYERS_HPP_ diff --git a/src/caffe/layers/tile_layer.cpp b/src/caffe/layers/tile_layer.cpp new file mode 100644 index 00000000000..f55008cc53a --- /dev/null +++ b/src/caffe/layers/tile_layer.cpp @@ -0,0 +1,62 @@ +#include + +#include "caffe/common_layers.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/math_functions.hpp" + +namespace caffe { + +template +void TileLayer::Reshape( + const vector*>& bottom, const vector*>& top) { + const TileParameter& tile_param = this->layer_param_.tile_param(); + axis_ = bottom[0]->CanonicalAxisIndex(tile_param.axis()); + CHECK(tile_param.has_tiles()) << "Number of tiles must be specified"; + tiles_ = tile_param.tiles(); + CHECK_GT(tiles_, 0) << "Number of tiles must be positive."; + vector top_shape = bottom[0]->shape(); + top_shape[axis_] = bottom[0]->shape(axis_) * tiles_; + top[0]->Reshape(top_shape); + outer_dim_ = bottom[0]->count(0, axis_); + inner_dim_ = bottom[0]->count(axis_); +} + +template +void TileLayer::Forward_cpu( + const vector*>& bottom, const vector*>& top) { + const Dtype* bottom_data = bottom[0]->cpu_data(); + Dtype* top_data = top[0]->mutable_cpu_data(); + for (int i = 0; i < outer_dim_; ++i) { + for (int t = 0; t < tiles_; ++t) { + caffe_copy(inner_dim_, bottom_data, top_data); + top_data += inner_dim_; + } + bottom_data += inner_dim_; + } +} + +template +void TileLayer::Backward_cpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + if (!propagate_down[0]) { return; } + const Dtype* top_diff = top[0]->cpu_diff(); + Dtype* bottom_diff = bottom[0]->mutable_cpu_diff(); + for (int i = 0; i < outer_dim_; ++i) { + caffe_copy(inner_dim_, top_diff, bottom_diff); + top_diff += inner_dim_; + for (int t = 1; t < tiles_; ++t) { + caffe_axpy(inner_dim_, Dtype(1), top_diff, bottom_diff); + top_diff += inner_dim_; + } + bottom_diff += inner_dim_; + } +} + +#ifdef CPU_ONLY +STUB_GPU(TileLayer); +#endif + +INSTANTIATE_CLASS(TileLayer); +REGISTER_LAYER_CLASS(Tile); + +} // namespace caffe diff --git a/src/caffe/layers/tile_layer.cu b/src/caffe/layers/tile_layer.cu new file mode 100644 index 00000000000..3af8e2eb72f --- /dev/null +++ b/src/caffe/layers/tile_layer.cu @@ -0,0 +1,42 @@ +#include + +#include "caffe/common_layers.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/math_functions.hpp" + +namespace caffe { + +template +void TileLayer::Forward_gpu( + const vector*>& bottom, const vector*>& top) { + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* top_data = top[0]->mutable_gpu_data(); + for (int i = 0; i < outer_dim_; ++i) { + for (int t = 0; t < tiles_; ++t) { + caffe_copy(inner_dim_, bottom_data, top_data); + top_data += inner_dim_; + } + bottom_data += inner_dim_; + } +} + +template +void TileLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + if (!propagate_down[0]) { return; } + const Dtype* top_diff = top[0]->gpu_diff(); + Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + for (int i = 0; i < outer_dim_; ++i) { + caffe_copy(inner_dim_, top_diff, bottom_diff); + top_diff += inner_dim_; + for (int t = 1; t < tiles_; ++t) { + caffe_gpu_axpy(inner_dim_, Dtype(1), top_diff, bottom_diff); + top_diff += inner_dim_; + } + bottom_diff += inner_dim_; + } +} + +INSTANTIATE_LAYER_GPU_FUNCS(TileLayer); + +} // namespace caffe diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 35264610bdd..aa299f8660b 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -301,7 +301,7 @@ message ParamSpec { // NOTE // Update the next available ID when you add a new LayerParameter field. // -// LayerParameter next available layer-specific ID: 138 (last added: embed_param) +// LayerParameter next available layer-specific ID: 139 (last added: tile_param) message LayerParameter { optional string name = 1; // the layer name optional string type = 2; // the layer type @@ -383,6 +383,7 @@ message LayerParameter { optional SliceParameter slice_param = 126; optional TanHParameter tanh_param = 127; optional ThresholdParameter threshold_param = 128; + optional TileParameter tile_param = 138; optional WindowDataParameter window_data_param = 129; } @@ -919,6 +920,16 @@ message TanHParameter { optional Engine engine = 1 [default = DEFAULT]; } +// Message that stores parameters used by TileLayer +message TileParameter { + // The index of the axis to tile. + optional int32 axis = 1 [default = 1]; + + // The number of copies (tiles) of the blob to output. + optional int32 tiles = 2; +} + +// Message that stores parameters used by ThresholdLayer message ThresholdParameter { optional float threshold = 1 [default = 0]; // Strictly positive values } diff --git a/src/caffe/test/test_tile_layer.cpp b/src/caffe/test/test_tile_layer.cpp new file mode 100644 index 00000000000..540aac3c2d3 --- /dev/null +++ b/src/caffe/test/test_tile_layer.cpp @@ -0,0 +1,162 @@ +#include +#include + +#include "gtest/gtest.h" + +#include "caffe/blob.hpp" +#include "caffe/common.hpp" +#include "caffe/filler.hpp" +#include "caffe/vision_layers.hpp" + +#include "caffe/test/test_caffe_main.hpp" +#include "caffe/test/test_gradient_check_util.hpp" + +namespace caffe { + +template +class TileLayerTest : public MultiDeviceTest { + typedef typename TypeParam::Dtype Dtype; + + protected: + TileLayerTest() + : blob_bottom_(new Blob(2, 3, 4, 5)), + blob_top_(new Blob()) {} + virtual void SetUp() { + blob_bottom_vec_.push_back(blob_bottom_); + blob_top_vec_.push_back(blob_top_); + FillerParameter filler_param; + filler_param.set_mean(0.0); + filler_param.set_std(1.0); + GaussianFiller filler(filler_param); + filler.Fill(blob_bottom_); + } + + virtual ~TileLayerTest() { + delete blob_bottom_; + delete blob_top_; + } + + Blob* const blob_bottom_; + Blob* const blob_top_; + vector*> blob_bottom_vec_; + vector*> blob_top_vec_; +}; + +TYPED_TEST_CASE(TileLayerTest, TestDtypesAndDevices); + +TYPED_TEST(TileLayerTest, TestTrivialSetup) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + const int kNumTiles = 1; + layer_param.mutable_tile_param()->set_tiles(kNumTiles); + for (int i = 0; i < this->blob_bottom_->num_axes(); ++i) { + layer_param.mutable_tile_param()->set_axis(i); + TileLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(this->blob_top_->num_axes(), this->blob_bottom_->num_axes()); + for (int j = 0; j < this->blob_bottom_->num_axes(); ++j) { + EXPECT_EQ(this->blob_top_->shape(j), this->blob_bottom_->shape(j)); + } + } +} + +TYPED_TEST(TileLayerTest, TestSetup) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + const int kNumTiles = 3; + layer_param.mutable_tile_param()->set_tiles(kNumTiles); + for (int i = 0; i < this->blob_bottom_->num_axes(); ++i) { + layer_param.mutable_tile_param()->set_axis(i); + TileLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(this->blob_top_->num_axes(), this->blob_bottom_->num_axes()); + for (int j = 0; j < this->blob_bottom_->num_axes(); ++j) { + const int top_dim = + ((i == j) ? kNumTiles : 1) * this->blob_bottom_->shape(j); + EXPECT_EQ(top_dim, this->blob_top_->shape(j)); + } + } +} + +TYPED_TEST(TileLayerTest, TestForwardNum) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + const int kTileAxis = 0; + const int kNumTiles = 3; + layer_param.mutable_tile_param()->set_axis(kTileAxis); + layer_param.mutable_tile_param()->set_tiles(kNumTiles); + TileLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + for (int n = 0; n < this->blob_top_->num(); ++n) { + for (int c = 0; c < this->blob_top_->channels(); ++c) { + for (int h = 0; h < this->blob_top_->height(); ++h) { + for (int w = 0; w < this->blob_top_->width(); ++w) { + const int bottom_n = n % this->blob_bottom_->num(); + EXPECT_EQ(this->blob_bottom_->data_at(bottom_n, c, h, w), + this->blob_top_->data_at(n, c, h, w)); + } + } + } + } +} + +TYPED_TEST(TileLayerTest, TestForwardChannels) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + const int kNumTiles = 3; + layer_param.mutable_tile_param()->set_tiles(kNumTiles); + TileLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + for (int n = 0; n < this->blob_top_->num(); ++n) { + for (int c = 0; c < this->blob_top_->channels(); ++c) { + for (int h = 0; h < this->blob_top_->height(); ++h) { + for (int w = 0; w < this->blob_top_->width(); ++w) { + const int bottom_c = c % this->blob_bottom_->channels(); + EXPECT_EQ(this->blob_bottom_->data_at(n, bottom_c, h, w), + this->blob_top_->data_at(n, c, h, w)); + } + } + } + } +} + +TYPED_TEST(TileLayerTest, TestTrivialGradient) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + const int kNumTiles = 1; + layer_param.mutable_tile_param()->set_tiles(kNumTiles); + TileLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} + +TYPED_TEST(TileLayerTest, TestGradientNum) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + const int kTileAxis = 0; + const int kNumTiles = 3; + layer_param.mutable_tile_param()->set_axis(kTileAxis); + layer_param.mutable_tile_param()->set_tiles(kNumTiles); + TileLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} + +TYPED_TEST(TileLayerTest, TestGradientChannels) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + const int kTileAxis = 1; + const int kNumTiles = 3; + layer_param.mutable_tile_param()->set_axis(kTileAxis); + layer_param.mutable_tile_param()->set_tiles(kNumTiles); + TileLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} + +} // namespace caffe From cbff2255bc8470299e15cc155ae7957a3acdd688 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Tue, 18 Aug 2015 18:15:20 -0700 Subject: [PATCH 174/331] TileLayer: add CUDA kernels --- src/caffe/layers/tile_layer.cu | 53 +++++++++++++++++++++++++--------- 1 file changed, 39 insertions(+), 14 deletions(-) diff --git a/src/caffe/layers/tile_layer.cu b/src/caffe/layers/tile_layer.cu index 3af8e2eb72f..7fd3bc47d0f 100644 --- a/src/caffe/layers/tile_layer.cu +++ b/src/caffe/layers/tile_layer.cu @@ -6,17 +6,45 @@ namespace caffe { +template +__global__ void Tile(const int nthreads, const Dtype* bottom_data, + const int tile_size, const int num_tiles, const int bottom_tile_axis, + Dtype* top_data) { + CUDA_KERNEL_LOOP(index, nthreads) { + const int d = index % tile_size; + const int b = (index / tile_size / num_tiles) % bottom_tile_axis; + const int n = index / tile_size / num_tiles / bottom_tile_axis; + const int bottom_index = (n * bottom_tile_axis + b) * tile_size + d; + top_data[index] = bottom_data[bottom_index]; + } +} + template void TileLayer::Forward_gpu( const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - for (int i = 0; i < outer_dim_; ++i) { - for (int t = 0; t < tiles_; ++t) { - caffe_copy(inner_dim_, bottom_data, top_data); - top_data += inner_dim_; + const int bottom_tile_axis = bottom[0]->shape(axis_); + const int nthreads = top[0]->count(); + Tile // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + nthreads, bottom_data, inner_dim_, tiles_, bottom_tile_axis, top_data); +} + +template +__global__ void TileBackward(const int nthreads, const Dtype* top_diff, + const int tile_size, const int num_tiles, const int bottom_tile_axis, + Dtype* bottom_diff) { + CUDA_KERNEL_LOOP(index, nthreads) { + const int d = index % tile_size; + const int b = (index / tile_size) % bottom_tile_axis; + const int n = index / tile_size / bottom_tile_axis; + bottom_diff[index] = 0; + int top_index = (n * num_tiles * bottom_tile_axis + b) * tile_size + d; + for (int t = 0; t < num_tiles; ++t) { + bottom_diff[index] += top_diff[top_index]; + top_index += bottom_tile_axis * tile_size; } - bottom_data += inner_dim_; } } @@ -26,15 +54,12 @@ void TileLayer::Backward_gpu(const vector*>& top, if (!propagate_down[0]) { return; } const Dtype* top_diff = top[0]->gpu_diff(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - for (int i = 0; i < outer_dim_; ++i) { - caffe_copy(inner_dim_, top_diff, bottom_diff); - top_diff += inner_dim_; - for (int t = 1; t < tiles_; ++t) { - caffe_gpu_axpy(inner_dim_, Dtype(1), top_diff, bottom_diff); - top_diff += inner_dim_; - } - bottom_diff += inner_dim_; - } + const int bottom_tile_axis = bottom[0]->shape(axis_); + const int tile_size = inner_dim_ / bottom_tile_axis; + const int nthreads = bottom[0]->count(); + TileBackward // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + nthreads, top_diff, tile_size, tiles_, bottom_tile_axis, bottom_diff); } INSTANTIATE_LAYER_GPU_FUNCS(TileLayer); From 1f3f9529df6285a5be5f8e72bd1922a6a0cec4d8 Mon Sep 17 00:00:00 2001 From: J Yegerlehner Date: Sun, 23 Aug 2015 18:57:16 -0500 Subject: [PATCH 175/331] MVNLayer fixes. Fix the MVNLayer tests so they actually test what they claim. MVNLayer fixes: sum_multiplier_ sized correctly; backward gradient calculation. Gradient calculation per analysis of seanbell, found here: https://github.com/BVLC/caffe/issues/1938 Fixes according to review comments. --- src/caffe/layers/mvn_layer.cpp | 15 ++++++++++++--- src/caffe/layers/mvn_layer.cu | 7 ++++++- src/caffe/test/test_mvn_layer.cpp | 13 +++++++++---- 3 files changed, 27 insertions(+), 8 deletions(-) diff --git a/src/caffe/layers/mvn_layer.cpp b/src/caffe/layers/mvn_layer.cpp index 3e79bddcdde..325691b1875 100644 --- a/src/caffe/layers/mvn_layer.cpp +++ b/src/caffe/layers/mvn_layer.cpp @@ -18,8 +18,12 @@ void MVNLayer::Reshape(const vector*>& bottom, 1, 1); temp_.Reshape(bottom[0]->num(), bottom[0]->channels(), bottom[0]->height(), bottom[0]->width()); - sum_multiplier_.Reshape(1, 1, - bottom[0]->height(), bottom[0]->width()); + if ( this->layer_param_.mvn_param().across_channels() ) { + sum_multiplier_.Reshape(1, bottom[0]->channels(), bottom[0]->height(), + bottom[0]->width()); + } else { + sum_multiplier_.Reshape(1, 1, bottom[0]->height(), bottom[0]->width()); + } Dtype* multiplier_data = sum_multiplier_.mutable_cpu_data(); caffe_set(sum_multiplier_.count(), Dtype(1), multiplier_data); eps_ = this->layer_param_.mvn_param().eps(); @@ -130,7 +134,12 @@ void MVNLayer::Backward_cpu(const vector*>& top, caffe_div(temp_.count(), bottom_diff, temp_.cpu_data(), bottom_diff); } else { - caffe_copy(temp_.count(), top_diff, bottom_diff); + caffe_cpu_gemv(CblasNoTrans, num, dim, 1. / dim, top_diff, + sum_multiplier_.cpu_data(), 0., mean_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, num, dim, 1, -1., + mean_.cpu_data(), sum_multiplier_.cpu_data(), 0., + temp_.mutable_cpu_data()); + caffe_add(temp_.count(), top_diff, temp_.cpu_data(), bottom_diff); } } diff --git a/src/caffe/layers/mvn_layer.cu b/src/caffe/layers/mvn_layer.cu index 3888a0c7106..d86a2e73fc2 100644 --- a/src/caffe/layers/mvn_layer.cu +++ b/src/caffe/layers/mvn_layer.cu @@ -113,7 +113,12 @@ void MVNLayer::Backward_gpu(const vector*>& top, caffe_gpu_div(temp_.count(), bottom_diff, temp_.gpu_data(), bottom_diff); } else { - caffe_copy(temp_.count(), top_diff, bottom_diff); + caffe_gpu_gemv(CblasNoTrans, num, dim, 1. / dim, top_diff, + sum_multiplier_.gpu_data(), 0., mean_.mutable_gpu_data()); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, num, dim, 1, -1., + mean_.gpu_data(), sum_multiplier_.gpu_data(), 0., + temp_.mutable_gpu_data()); + caffe_gpu_add(temp_.count(), top_diff, temp_.gpu_data(), bottom_diff); } } diff --git a/src/caffe/test/test_mvn_layer.cpp b/src/caffe/test/test_mvn_layer.cpp index 933b4326417..be23d86e9c3 100644 --- a/src/caffe/test/test_mvn_layer.cpp +++ b/src/caffe/test/test_mvn_layer.cpp @@ -6,6 +6,7 @@ #include "caffe/common.hpp" #include "caffe/common_layers.hpp" #include "caffe/filler.hpp" +#include "google/protobuf/text_format.h" #include "gtest/gtest.h" #include "caffe/test/test_caffe_main.hpp" @@ -73,7 +74,8 @@ TYPED_TEST(MVNLayerTest, TestForward) { TYPED_TEST(MVNLayerTest, TestForwardMeanOnly) { typedef typename TypeParam::Dtype Dtype; LayerParameter layer_param; - layer_param.ParseFromString("mvn_param{normalize_variance: false}"); + CHECK(google::protobuf::TextFormat::ParseFromString( + "mvn_param{normalize_variance: false}", &layer_param)); MVNLayer layer(layer_param); layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); @@ -105,7 +107,8 @@ TYPED_TEST(MVNLayerTest, TestForwardMeanOnly) { TYPED_TEST(MVNLayerTest, TestForwardAcrossChannels) { typedef typename TypeParam::Dtype Dtype; LayerParameter layer_param; - layer_param.ParseFromString("mvn_param{across_channels: true}"); + CHECK(google::protobuf::TextFormat::ParseFromString( + "mvn_param{across_channels: true}", &layer_param)); MVNLayer layer(layer_param); layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); @@ -149,7 +152,8 @@ TYPED_TEST(MVNLayerTest, TestGradient) { TYPED_TEST(MVNLayerTest, TestGradientMeanOnly) { typedef typename TypeParam::Dtype Dtype; LayerParameter layer_param; - layer_param.ParseFromString("mvn_param{normalize_variance: false}"); + CHECK(google::protobuf::TextFormat::ParseFromString( + "mvn_param{normalize_variance: false}", &layer_param)); MVNLayer layer(layer_param); GradientChecker checker(1e-2, 1e-3); checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, @@ -159,7 +163,8 @@ TYPED_TEST(MVNLayerTest, TestGradientMeanOnly) { TYPED_TEST(MVNLayerTest, TestGradientAcrossChannels) { typedef typename TypeParam::Dtype Dtype; LayerParameter layer_param; - layer_param.ParseFromString("mvn_param{across_channels: true}"); + CHECK(google::protobuf::TextFormat::ParseFromString( + "mvn_param{across_channels: true}", &layer_param)); MVNLayer layer(layer_param); GradientChecker checker(1e-2, 1e-3); checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, From c548a7972b554b3ababaa0dc52db15a5f5a28be8 Mon Sep 17 00:00:00 2001 From: Jonas Maaskola Date: Sun, 2 Aug 2015 23:47:12 +0200 Subject: [PATCH 176/331] Draw Deconvolution layers like Convolution layers --- python/caffe/draw.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/python/caffe/draw.py b/python/caffe/draw.py index 324929deca4..a002b60b59a 100644 --- a/python/caffe/draw.py +++ b/python/caffe/draw.py @@ -40,7 +40,7 @@ def get_edge_label(layer): if layer.type == 'Data': edge_label = 'Batch ' + str(layer.data_param.batch_size) - elif layer.type == 'Convolution': + elif layer.type == 'Convolution' or layer.type == 'Deconvolution': edge_label = str(layer.convolution_param.num_output) elif layer.type == 'InnerProduct': edge_label = str(layer.inner_product_param.num_output) @@ -74,7 +74,7 @@ def get_layer_label(layer, rankdir): # horizontal space is not; separate words with newlines separator = '\\n' - if layer.type == 'Convolution': + if layer.type == 'Convolution' or layer.type == 'Deconvolution': # Outer double quotes needed or else colon characters don't parse # properly node_label = '"%s%s(%s)%skernel size: %d%sstride: %d%spad: %d"' %\ @@ -109,7 +109,7 @@ def choose_color_by_layertype(layertype): """Define colors for nodes based on the layer type. """ color = '#6495ED' # Default - if layertype == 'Convolution': + if layertype == 'Convolution' or layertype == 'Deconvolution': color = '#FF5050' elif layertype == 'Pooling': color = '#FF9900' From 292dbc5866c0b0b2ad56278591dce8b519166b20 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Mon, 24 Aug 2015 14:46:23 -0700 Subject: [PATCH 177/331] Fix previous mistake on unimplemented top and address pyramid_height_==1 in SPPLayer also, do nothing in SPPLayer Reshape if already reshaped once and bottom size unchanged --- include/caffe/vision_layers.hpp | 10 +++------ src/caffe/layers/spp_layer.cpp | 36 +++++++++++++++++++++++++++++++++ 2 files changed, 39 insertions(+), 7 deletions(-) diff --git a/include/caffe/vision_layers.hpp b/include/caffe/vision_layers.hpp index a6bd86a93f5..211e3d9042d 100644 --- a/include/caffe/vision_layers.hpp +++ b/include/caffe/vision_layers.hpp @@ -471,13 +471,7 @@ class SPPLayer : public Layer { virtual inline const char* type() const { return "SPP"; } virtual inline int ExactNumBottomBlobs() const { return 1; } - virtual inline int MinTopBlobs() const { return 1; } - // MAX POOL layers can output an extra top blob for the mask; - // others can only output the pooled inputs. - virtual inline int MaxTopBlobs() const { - return (this->layer_param_.pooling_param().pool() == - PoolingParameter_PoolMethod_MAX) ? 2 : 1; - } + virtual inline int ExactNumTopBlobs() const { return 1; } protected: virtual void Forward_cpu(const vector*>& bottom, @@ -491,9 +485,11 @@ class SPPLayer : public Layer { int pyramid_height_; int bottom_h_, bottom_w_; + int num_; int channels_; int kernel_h_, kernel_w_; int pad_h_, pad_w_; + bool reshaped_first_time_; /// the internal Split layer that feeds the pooling layers shared_ptr > split_layer_; diff --git a/src/caffe/layers/spp_layer.cpp b/src/caffe/layers/spp_layer.cpp index 795dd71693e..d7622910495 100644 --- a/src/caffe/layers/spp_layer.cpp +++ b/src/caffe/layers/spp_layer.cpp @@ -66,8 +66,11 @@ void SPPLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { SPPParameter spp_param = this->layer_param_.spp_param(); + num_ = bottom[0]->num(); + channels_ = bottom[0]->channels(); bottom_h_ = bottom[0]->height(); bottom_w_ = bottom[0]->width(); + reshaped_first_time_ = false; CHECK_GT(bottom_h_, 0) << "Input dimensions cannot be zero."; CHECK_GT(bottom_w_, 0) << "Input dimensions cannot be zero."; @@ -82,6 +85,15 @@ void SPPLayer::LayerSetUp(const vector*>& bottom, flatten_outputs_.clear(); concat_bottom_vec_.clear(); + if (pyramid_height_ == 1) { + // pooling layer setup + LayerParameter pooling_param = GetPoolingParam(0, bottom_h_, bottom_w_, + spp_param); + pooling_layers_.push_back(shared_ptr > ( + new PoolingLayer(pooling_param))); + pooling_layers_[0]->SetUp(bottom, top); + return; + } // split layer output holders setup for (int i = 0; i < pyramid_height_; i++) { split_top_vec_.push_back(new Blob()); @@ -135,10 +147,26 @@ void SPPLayer::Reshape(const vector*>& bottom, const vector*>& top) { CHECK_EQ(4, bottom[0]->num_axes()) << "Input must have 4 axes, " << "corresponding to (num, channels, height, width)"; + // Do nothing if bottom shape is unchanged since last Reshape + if (num_ == bottom[0]->num() && channels_ == bottom[0]->channels() && + bottom_h_ == bottom[0]->height() && bottom_w_ == bottom[0]->width() && + reshaped_first_time_) { + return; + } + num_ = bottom[0]->num(); channels_ = bottom[0]->channels(); bottom_h_ = bottom[0]->height(); bottom_w_ = bottom[0]->width(); + reshaped_first_time_ = true; SPPParameter spp_param = this->layer_param_.spp_param(); + if (pyramid_height_ == 1) { + LayerParameter pooling_param = GetPoolingParam(0, bottom_h_, bottom_w_, + spp_param); + pooling_layers_[0].reset(new PoolingLayer(pooling_param)); + pooling_layers_[0]->SetUp(bottom, top); + pooling_layers_[0]->Reshape(bottom, top); + return; + } split_layer_->Reshape(bottom, split_top_vec_); for (int i = 0; i < pyramid_height_; i++) { LayerParameter pooling_param = GetPoolingParam( @@ -159,6 +187,10 @@ void SPPLayer::Reshape(const vector*>& bottom, template void SPPLayer::Forward_cpu(const vector*>& bottom, const vector*>& top) { + if (pyramid_height_ == 1) { + pooling_layers_[0]->Forward(bottom, top); + return; + } split_layer_->Forward(bottom, split_top_vec_); for (int i = 0; i < pyramid_height_; i++) { pooling_layers_[i]->Forward( @@ -175,6 +207,10 @@ void SPPLayer::Backward_cpu(const vector*>& top, if (!propagate_down[0]) { return; } + if (pyramid_height_ == 1) { + pooling_layers_[0]->Backward(top, propagate_down, bottom); + return; + } vector concat_propagate_down(pyramid_height_, true); concat_layer_->Backward(top, concat_propagate_down, concat_bottom_vec_); for (int i = 0; i < pyramid_height_; i++) { From 4f64b9ee3ed6c1267c4252cf79b2ccf0d042f0b2 Mon Sep 17 00:00:00 2001 From: Matt Dawkins Date: Thu, 27 Aug 2015 10:51:36 -0400 Subject: [PATCH 178/331] Add extra openblas search path --- cmake/Modules/FindOpenBLAS.cmake | 2 ++ 1 file changed, 2 insertions(+) diff --git a/cmake/Modules/FindOpenBLAS.cmake b/cmake/Modules/FindOpenBLAS.cmake index b8434927a4d..a6512ae7e4e 100644 --- a/cmake/Modules/FindOpenBLAS.cmake +++ b/cmake/Modules/FindOpenBLAS.cmake @@ -2,8 +2,10 @@ SET(Open_BLAS_INCLUDE_SEARCH_PATHS /usr/include + /usr/include/openblas /usr/include/openblas-base /usr/local/include + /usr/local/include/openblas /usr/local/include/openblas-base /opt/OpenBLAS/include $ENV{OpenBLAS_HOME} From 4d7fe4de7e7bddfe107f4a37a7ec85c6f6178469 Mon Sep 17 00:00:00 2001 From: J Yegerlehner Date: Thu, 27 Aug 2015 10:47:14 -0500 Subject: [PATCH 179/331] Fix EmbedLayer compiler warning for unused variable. --- src/caffe/layers/embed_layer.cu | 1 - 1 file changed, 1 deletion(-) diff --git a/src/caffe/layers/embed_layer.cu b/src/caffe/layers/embed_layer.cu index 672fb9c608c..62a4db81336 100644 --- a/src/caffe/layers/embed_layer.cu +++ b/src/caffe/layers/embed_layer.cu @@ -64,7 +64,6 @@ void EmbedLayer::Backward_gpu(const vector*>& top, CHECK(!propagate_down[0]) << "Can't backpropagate to EmbedLayer input."; if (this->param_propagate_down_[0]) { const int top_count = top[0]->count(); - const int count = this->blobs_[0]->count(); const Dtype* top_diff = top[0]->gpu_diff(); const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* weight_diff = this->blobs_[0]->mutable_gpu_diff(); From 846f2c3cce8b937637e0b46a7f62be068b835ade Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Fri, 28 Aug 2015 21:27:11 -0700 Subject: [PATCH 180/331] fix GPU data race Previously, the prefetch GPU -> top GPU and prefetch CPU -> prefetch GPU copies were launched concurrently in separate streams, allowing the next batch to be copied in before the current one is read. This patch explicitly synchronizes the prefetch -> top copy wrt the host, preventing the CPU -> GPU from being launched until its completion. --- src/caffe/layers/base_data_layer.cu | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/caffe/layers/base_data_layer.cu b/src/caffe/layers/base_data_layer.cu index 56439bc506a..ff6e412aba6 100644 --- a/src/caffe/layers/base_data_layer.cu +++ b/src/caffe/layers/base_data_layer.cu @@ -20,7 +20,9 @@ void BasePrefetchingDataLayer::Forward_gpu( caffe_copy(batch->label_.count(), batch->label_.gpu_data(), top[1]->mutable_gpu_data()); } - + // Ensure the copy is synchronous wrt the host, so that the next batch isn't + // copied in meanwhile. + CUDA_CHECK(cudaStreamSynchronize(cudaStreamDefault)); prefetch_free_.push(batch); } From a6751723234926bdd03b6167ea6414da109854a3 Mon Sep 17 00:00:00 2001 From: philkr Date: Tue, 1 Sep 2015 13:11:26 -0700 Subject: [PATCH 181/331] Compute backward for negative lr_mult --- src/caffe/net.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index f1fc63aba95..89d14013dc9 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -182,7 +182,7 @@ void Net::Init(const NetParameter& in_param) { for (int param_id = 0; param_id < num_param_blobs; ++param_id) { const ParamSpec* param_spec = (param_id < param_size) ? &layer_param.param(param_id) : &default_param_spec; - const bool param_need_backward = param_spec->lr_mult() > 0; + const bool param_need_backward = param_spec->lr_mult() != 0; need_backward |= param_need_backward; layers_[layer_id]->set_param_propagate_down(param_id, param_need_backward); From b04000e4204753803f4cdead66af8a830bc7c4ca Mon Sep 17 00:00:00 2001 From: Darren Garvey Date: Tue, 1 Sep 2015 15:42:26 +0100 Subject: [PATCH 182/331] Cleanup: Fixup capitalisation of Caffe_POSTFIX. Replaces CAffe_POSTFIX -> Caffe_POSTFIX. --- cmake/Misc.cmake | 4 ++-- examples/CMakeLists.txt | 2 +- matlab/CMakeLists.txt | 4 ++-- python/CMakeLists.txt | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/cmake/Misc.cmake b/cmake/Misc.cmake index 7676754fe04..9dd2609b36a 100644 --- a/cmake/Misc.cmake +++ b/cmake/Misc.cmake @@ -46,7 +46,7 @@ endif() # ---[ Set debug postfix set(Caffe_DEBUG_POSTFIX "-d") -set(CAffe_POSTFIX "") +set(Caffe_POSTFIX "") if(CMAKE_BUILD_TYPE MATCHES "Debug") - set(CAffe_POSTFIX ${Caffe_DEBUG_POSTFIX}) + set(Caffe_POSTFIX ${Caffe_DEBUG_POSTFIX}) endif() diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index f29fc7e5522..663d7360b7d 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -24,7 +24,7 @@ foreach(source_file ${examples_srcs}) if(UNIX OR APPLE) # Funny command to make tutorials work # TODO: remove in future as soon as naming is standartaized everywhere - set(__outname ${PROJECT_BINARY_DIR}/examples/${folder}/${name}${CAffe_POSTFIX}) + set(__outname ${PROJECT_BINARY_DIR}/examples/${folder}/${name}${Caffe_POSTFIX}) add_custom_command(TARGET ${name} POST_BUILD COMMAND ln -sf "${__outname}" "${__outname}.bin") endif() diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt index 4b0d549f07f..f420df8d412 100644 --- a/matlab/CMakeLists.txt +++ b/matlab/CMakeLists.txt @@ -43,7 +43,7 @@ string(REPLACE ";" ";-L" link_folders "-L${folders}") string(REPLACE ";" ":" rpath_folders "${folders}") if(build_using MATCHES "Matlab") - set(libflags -lcaffe${CAffe_POSTFIX} ${libflags}) # Matlab R2014a complans for -Wl,--whole-archive + set(libflags -lcaffe${Caffe_POSTFIX} ${libflags}) # Matlab R2014a complans for -Wl,--whole-archive caffe_fetch_and_set_proper_mexext(Matlab_caffe_mex) add_custom_command(OUTPUT ${Matlab_caffe_mex} COMMAND ${Matlab_mex} @@ -56,7 +56,7 @@ elseif(build_using MATCHES "Octave") if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") set(libflags -Wl,-force_load,$ ${libflags}) elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - set(libflags -Wl,--whole-archive -lcaffe${CAffe_POSTFIX} -Wl,--no-whole-archive ${libflags}) + set(libflags -Wl,--whole-archive -lcaffe${Caffe_POSTFIX} -Wl,--no-whole-archive ${libflags}) endif() add_custom_command(OUTPUT ${Matlab_caffe_mex} COMMAND ${Octave_compiler} diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt index df0401daa1c..0e2bc7e66a8 100644 --- a/python/CMakeLists.txt +++ b/python/CMakeLists.txt @@ -18,7 +18,7 @@ if(UNIX OR APPLE) COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_SOURCE_DIR}/python/caffe/proto COMMAND touch ${PROJECT_SOURCE_DIR}/python/caffe/proto/__init__.py COMMAND cp ${proto_gen_folder}/*.py ${PROJECT_SOURCE_DIR}/python/caffe/proto/ - COMMENT "Creating symlink ${__linkname} -> ${PROJECT_BINARY_DIR}/lib/_caffe${CAffe_POSTFIX}.so") + COMMENT "Creating symlink ${__linkname} -> ${PROJECT_BINARY_DIR}/lib/_caffe${Caffe_POSTFIX}.so") endif() # ---[ Install From e8f96f58aa6b64726f62f7304964d1c0a82b5c38 Mon Sep 17 00:00:00 2001 From: Darren Garvey Date: Mon, 10 Aug 2015 02:16:20 +0100 Subject: [PATCH 183/331] Fix memory leak in convert_mnist_siamese_data. This fixes a memory leak by using delete[] rather than plain delete. --- examples/siamese/convert_mnist_siamese_data.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/siamese/convert_mnist_siamese_data.cpp b/examples/siamese/convert_mnist_siamese_data.cpp index 71c56a0ae61..8008b4439c5 100644 --- a/examples/siamese/convert_mnist_siamese_data.cpp +++ b/examples/siamese/convert_mnist_siamese_data.cpp @@ -102,7 +102,7 @@ void convert_dataset(const char* image_filename, const char* label_filename, } delete db; - delete pixels; + delete [] pixels; } int main(int argc, char** argv) { From 583194a00811a312e0bdfa151a8ad6a222c2dd4d Mon Sep 17 00:00:00 2001 From: Darren Garvey Date: Tue, 1 Sep 2015 20:09:25 +0100 Subject: [PATCH 184/331] cifar10: Fix examples by setting snapshot_format. Commit 4227828a set the default binary format from HDF5 to BINARYPROTO to fix #2885. This broke the cifar10 examples which relied on this default. This commit specifies the snapshot_format explicitly since the rest of the example relies on this being HDF5. --- examples/cifar10/cifar10_full_solver.prototxt | 1 + examples/cifar10/cifar10_full_solver_lr1.prototxt | 1 + examples/cifar10/cifar10_full_solver_lr2.prototxt | 1 + examples/cifar10/cifar10_quick_solver.prototxt | 1 + examples/cifar10/cifar10_quick_solver_lr1.prototxt | 1 + 5 files changed, 5 insertions(+) diff --git a/examples/cifar10/cifar10_full_solver.prototxt b/examples/cifar10/cifar10_full_solver.prototxt index f30b3986142..882daa2d2b5 100644 --- a/examples/cifar10/cifar10_full_solver.prototxt +++ b/examples/cifar10/cifar10_full_solver.prototxt @@ -21,6 +21,7 @@ display: 200 max_iter: 60000 # snapshot intermediate results snapshot: 10000 +snapshot_format: HDF5 snapshot_prefix: "examples/cifar10/cifar10_full" # solver mode: CPU or GPU solver_mode: GPU diff --git a/examples/cifar10/cifar10_full_solver_lr1.prototxt b/examples/cifar10/cifar10_full_solver_lr1.prototxt index 59bc5721f4c..55f4be44053 100644 --- a/examples/cifar10/cifar10_full_solver_lr1.prototxt +++ b/examples/cifar10/cifar10_full_solver_lr1.prototxt @@ -21,6 +21,7 @@ display: 200 max_iter: 65000 # snapshot intermediate results snapshot: 5000 +snapshot_format: HDF5 snapshot_prefix: "examples/cifar10/cifar10_full" # solver mode: CPU or GPU solver_mode: GPU diff --git a/examples/cifar10/cifar10_full_solver_lr2.prototxt b/examples/cifar10/cifar10_full_solver_lr2.prototxt index d4ed5d8e041..7c3d2da31de 100644 --- a/examples/cifar10/cifar10_full_solver_lr2.prototxt +++ b/examples/cifar10/cifar10_full_solver_lr2.prototxt @@ -21,6 +21,7 @@ display: 200 max_iter: 70000 # snapshot intermediate results snapshot: 5000 +snapshot_format: HDF5 snapshot_prefix: "examples/cifar10/cifar10_full" # solver mode: CPU or GPU solver_mode: GPU diff --git a/examples/cifar10/cifar10_quick_solver.prototxt b/examples/cifar10/cifar10_quick_solver.prototxt index 14b4401ba16..5de276f722f 100644 --- a/examples/cifar10/cifar10_quick_solver.prototxt +++ b/examples/cifar10/cifar10_quick_solver.prototxt @@ -20,6 +20,7 @@ display: 100 max_iter: 4000 # snapshot intermediate results snapshot: 4000 +snapshot_format: HDF5 snapshot_prefix: "examples/cifar10/cifar10_quick" # solver mode: CPU or GPU solver_mode: GPU diff --git a/examples/cifar10/cifar10_quick_solver_lr1.prototxt b/examples/cifar10/cifar10_quick_solver_lr1.prototxt index d3af70c05e7..f8f1efd54af 100644 --- a/examples/cifar10/cifar10_quick_solver_lr1.prototxt +++ b/examples/cifar10/cifar10_quick_solver_lr1.prototxt @@ -20,6 +20,7 @@ display: 100 max_iter: 5000 # snapshot intermediate results snapshot: 5000 +snapshot_format: HDF5 snapshot_prefix: "examples/cifar10/cifar10_quick" # solver mode: CPU or GPU solver_mode: GPU From 6f5812c4547dd912dd0569330ebdd44a5afd278e Mon Sep 17 00:00:00 2001 From: Darren Garvey Date: Wed, 2 Sep 2015 00:54:06 +0100 Subject: [PATCH 185/331] Fix up documentation errors. Fix some doxygen warnings about an undocumented argument in Blob and incorrect documentation for SoftmaxWithLossLayer::Forward_cpu(). --- include/caffe/blob.hpp | 2 +- include/caffe/loss_layers.hpp | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/include/caffe/blob.hpp b/include/caffe/blob.hpp index 9b813e739e9..dda7b1f8372 100644 --- a/include/caffe/blob.hpp +++ b/include/caffe/blob.hpp @@ -109,7 +109,7 @@ class Blob { * @brief Returns the 'canonical' version of a (usually) user-specified axis, * allowing for negative indexing (e.g., -1 for the last axis). * - * @param index the axis index. + * @param axis_index the axis index. * If 0 <= index < num_axes(), return index. * If -num_axes <= index <= -1, return (num_axes() - (-index)), * e.g., the last axis index (num_axes() - 1) if index == -1, diff --git a/include/caffe/loss_layers.hpp b/include/caffe/loss_layers.hpp index 02687a944fb..8d41af34e88 100644 --- a/include/caffe/loss_layers.hpp +++ b/include/caffe/loss_layers.hpp @@ -712,7 +712,6 @@ class SoftmaxWithLossLayer : public LossLayer { virtual inline int MaxTopBlobs() const { return 2; } protected: - /// @copydoc SoftmaxWithLossLayer virtual void Forward_cpu(const vector*>& bottom, const vector*>& top); virtual void Forward_gpu(const vector*>& bottom, From 6ca0ab66077c578dff14aa775858035b2a69fed6 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Tue, 1 Sep 2015 17:20:37 -0700 Subject: [PATCH 186/331] Show output from convert_imageset tool --- tools/convert_imageset.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tools/convert_imageset.cpp b/tools/convert_imageset.cpp index 816a91f971b..aad1f1fe216 100644 --- a/tools/convert_imageset.cpp +++ b/tools/convert_imageset.cpp @@ -44,6 +44,8 @@ DEFINE_string(encode_type, "", int main(int argc, char** argv) { ::google::InitGoogleLogging(argv[0]); + // Print output to stderr (while still logging) + FLAGS_alsologtostderr = 1; #ifndef GFLAGS_GFLAGS_H_ namespace gflags = google; @@ -140,13 +142,13 @@ int main(int argc, char** argv) { // Commit db txn->Commit(); txn.reset(db->NewTransaction()); - LOG(ERROR) << "Processed " << count << " files."; + LOG(INFO) << "Processed " << count << " files."; } } // write the last batch if (count % 1000 != 0) { txn->Commit(); - LOG(ERROR) << "Processed " << count << " files."; + LOG(INFO) << "Processed " << count << " files."; } return 0; } From d1a0345eaaff501d11a1705986cac8f124dd2545 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Tue, 7 Oct 2014 11:55:54 -0700 Subject: [PATCH 187/331] SliceLayer: allow trivial operation with single top Blob --- include/caffe/common_layers.hpp | 2 +- src/caffe/layers/slice_layer.cpp | 7 ++++++- src/caffe/layers/slice_layer.cu | 3 ++- src/caffe/test/test_slice_layer.cpp | 27 +++++++++++++++++++++++++++ 4 files changed, 36 insertions(+), 3 deletions(-) diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index 8e64b3e5dc5..6d4a9e3cb81 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -625,7 +625,7 @@ class SliceLayer : public Layer { virtual inline const char* type() const { return "Slice"; } virtual inline int ExactNumBottomBlobs() const { return 1; } - virtual inline int MinTopBlobs() const { return 2; } + virtual inline int MinTopBlobs() const { return 1; } protected: virtual void Forward_cpu(const vector*>& bottom, diff --git a/src/caffe/layers/slice_layer.cpp b/src/caffe/layers/slice_layer.cpp index e4418c9cf9c..0a059ae88fe 100644 --- a/src/caffe/layers/slice_layer.cpp +++ b/src/caffe/layers/slice_layer.cpp @@ -67,11 +67,16 @@ void SliceLayer::Reshape(const vector*>& bottom, } } CHECK_EQ(count, bottom[0]->count()); + if (top.size() == 1) { + top[0]->ShareData(*bottom[0]); + top[0]->ShareDiff(*bottom[0]); + } } template void SliceLayer::Forward_cpu(const vector*>& bottom, const vector*>& top) { + if (top.size() == 1) { return; } int offset_slice_axis = 0; const Dtype* bottom_data = bottom[0]->cpu_data(); const int bottom_slice_axis = bottom[0]->shape(slice_axis_); @@ -92,7 +97,7 @@ void SliceLayer::Forward_cpu(const vector*>& bottom, template void SliceLayer::Backward_cpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { - if (!propagate_down[0]) { return; } + if (!propagate_down[0] || top.size() == 1) { return; } int offset_slice_axis = 0; Dtype* bottom_diff = bottom[0]->mutable_cpu_diff(); const int bottom_slice_axis = bottom[0]->shape(slice_axis_); diff --git a/src/caffe/layers/slice_layer.cu b/src/caffe/layers/slice_layer.cu index 796841d3f52..e8dc6cd98fc 100644 --- a/src/caffe/layers/slice_layer.cu +++ b/src/caffe/layers/slice_layer.cu @@ -28,6 +28,7 @@ __global__ void Slice(const int nthreads, const Dtype* in_data, template void SliceLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { + if (top.size() == 1) { return; } int offset_slice_axis = 0; const Dtype* bottom_data = bottom[0]->gpu_data(); const int bottom_slice_axis = bottom[0]->shape(slice_axis_); @@ -48,7 +49,7 @@ void SliceLayer::Forward_gpu(const vector*>& bottom, template void SliceLayer::Backward_gpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { - if (!propagate_down[0]) { return; } + if (!propagate_down[0] || top.size() == 1) { return; } int offset_slice_axis = 0; Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); const int bottom_slice_axis = bottom[0]->shape(slice_axis_); diff --git a/src/caffe/test/test_slice_layer.cpp b/src/caffe/test/test_slice_layer.cpp index ccd03646d19..2d2d0fdc005 100644 --- a/src/caffe/test/test_slice_layer.cpp +++ b/src/caffe/test/test_slice_layer.cpp @@ -88,6 +88,21 @@ TYPED_TEST(SliceLayerTest, TestSetupChannels) { EXPECT_EQ(this->blob_bottom_->width(), this->blob_top_0_->width()); } +TYPED_TEST(SliceLayerTest, TestTrivialSlice) { + // Test the trivial (single output) "slice" operation -- + // should be the identity. + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + SliceLayer layer(layer_param); + this->blob_top_vec_0_.resize(1); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_0_); + ASSERT_EQ(this->blob_bottom_->shape(), this->blob_top_0_->shape()); + for (int i = 0; i < this->blob_bottom_->count(); ++i) { + EXPECT_EQ(this->blob_bottom_->cpu_data()[i], + this->blob_top_0_->cpu_data()[i]); + } +} + TYPED_TEST(SliceLayerTest, TestSliceAcrossNum) { typedef typename TypeParam::Dtype Dtype; LayerParameter layer_param; @@ -161,6 +176,18 @@ TYPED_TEST(SliceLayerTest, TestSliceAcrossChannels) { } } +TYPED_TEST(SliceLayerTest, TestGradientTrivial) { + // Test the trivial (single output) "slice" operation -- + // should be the identity. + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + SliceLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-3); + this->blob_top_vec_0_.resize(1); + checker.CheckGradientEltwise(&layer, this->blob_bottom_vec_, + this->blob_top_vec_0_); +} + TYPED_TEST(SliceLayerTest, TestGradientAcrossNum) { typedef typename TypeParam::Dtype Dtype; // Gradient checks are slow; reduce blob size. From 784dfddd42cc787fd9661a954f2a360990867df2 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Fri, 23 Jan 2015 12:52:44 -0800 Subject: [PATCH 188/331] ConcatLayer: allow trivial operation with single bottom Blob --- include/caffe/common_layers.hpp | 2 +- src/caffe/layers/concat_layer.cpp | 6 ++++++ src/caffe/layers/concat_layer.cu | 2 ++ src/caffe/test/test_concat_layer.cpp | 23 +++++++++++++++++++++++ 4 files changed, 32 insertions(+), 1 deletion(-) diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index 6d4a9e3cb81..89bab8d6f3a 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -85,7 +85,7 @@ class ConcatLayer : public Layer { const vector*>& top); virtual inline const char* type() const { return "Concat"; } - virtual inline int MinBottomBlobs() const { return 2; } + virtual inline int MinBottomBlobs() const { return 1; } virtual inline int ExactNumTopBlobs() const { return 1; } protected: diff --git a/src/caffe/layers/concat_layer.cpp b/src/caffe/layers/concat_layer.cpp index 95fba105b9a..86b500de859 100644 --- a/src/caffe/layers/concat_layer.cpp +++ b/src/caffe/layers/concat_layer.cpp @@ -48,11 +48,16 @@ void ConcatLayer::Reshape(const vector*>& bottom, } top[0]->Reshape(top_shape); CHECK_EQ(bottom_count_sum, top[0]->count()); + if (bottom.size() == 1) { + top[0]->ShareData(*bottom[0]); + top[0]->ShareDiff(*bottom[0]); + } } template void ConcatLayer::Forward_cpu(const vector*>& bottom, const vector*>& top) { + if (bottom.size() == 1) { return; } Dtype* top_data = top[0]->mutable_cpu_data(); int offset_concat_axis = 0; const int top_concat_axis = top[0]->shape(concat_axis_); @@ -72,6 +77,7 @@ void ConcatLayer::Forward_cpu(const vector*>& bottom, template void ConcatLayer::Backward_cpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { + if (bottom.size() == 1) { return; } const Dtype* top_diff = top[0]->cpu_diff(); int offset_concat_axis = 0; const int top_concat_axis = top[0]->shape(concat_axis_); diff --git a/src/caffe/layers/concat_layer.cu b/src/caffe/layers/concat_layer.cu index 3c64c7ef224..617701e2621 100644 --- a/src/caffe/layers/concat_layer.cu +++ b/src/caffe/layers/concat_layer.cu @@ -28,6 +28,7 @@ __global__ void Concat(const int nthreads, const Dtype* in_data, template void ConcatLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { + if (bottom.size() == 1) { return; } Dtype* top_data = top[0]->mutable_gpu_data(); int offset_concat_axis = 0; const int top_concat_axis = top[0]->shape(concat_axis_); @@ -48,6 +49,7 @@ void ConcatLayer::Forward_gpu(const vector*>& bottom, template void ConcatLayer::Backward_gpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { + if (bottom.size() == 1) { return; } const Dtype* top_diff = top[0]->gpu_diff(); int offset_concat_axis = 0; const int top_concat_axis = top[0]->shape(concat_axis_); diff --git a/src/caffe/test/test_concat_layer.cpp b/src/caffe/test/test_concat_layer.cpp index 088e0a41685..ccd97eb1d66 100644 --- a/src/caffe/test/test_concat_layer.cpp +++ b/src/caffe/test/test_concat_layer.cpp @@ -99,6 +99,19 @@ TYPED_TEST(ConcatLayerTest, TestSetupChannelsNegativeIndexing) { EXPECT_EQ(this->blob_top_->width(), this->blob_bottom_0_->width()); } +TYPED_TEST(ConcatLayerTest, TestForwardTrivial) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + ConcatLayer layer(layer_param); + this->blob_bottom_vec_0_.resize(1); + layer.SetUp(this->blob_bottom_vec_0_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_0_, this->blob_top_vec_); + for (int i = 0; i < this->blob_bottom_0_->count(); ++i) { + EXPECT_EQ(this->blob_bottom_0_->cpu_data()[i], + this->blob_top_->cpu_data()[i]); + } +} + TYPED_TEST(ConcatLayerTest, TestForwardNum) { typedef typename TypeParam::Dtype Dtype; LayerParameter layer_param; @@ -154,6 +167,16 @@ TYPED_TEST(ConcatLayerTest, TestForwardChannels) { } } +TYPED_TEST(ConcatLayerTest, TestGradientTrivial) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + ConcatLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + this->blob_bottom_vec_0_.resize(1); + checker.CheckGradientEltwise(&layer, this->blob_bottom_vec_0_, + this->blob_top_vec_); +} + TYPED_TEST(ConcatLayerTest, TestGradientNum) { typedef typename TypeParam::Dtype Dtype; LayerParameter layer_param; From 46c3f00bc91819668fb384b7982706d19b2a9fd6 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Thu, 3 Sep 2015 14:57:19 -0700 Subject: [PATCH 189/331] net.cpp fix debug_info params -> learnable_params --- src/caffe/net.cpp | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index 89d14013dc9..ebb8b5d28c2 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -810,12 +810,11 @@ void Net::Backward() { BackwardFromTo(layers_.size() - 1, 0); if (debug_info_) { Dtype asum_data = 0, asum_diff = 0, sumsq_data = 0, sumsq_diff = 0; - for (int i = 0; i < params_.size(); ++i) { - if (param_owners_[i] >= 0) { continue; } - asum_data += params_[i]->asum_data(); - asum_diff += params_[i]->asum_diff(); - sumsq_data += params_[i]->sumsq_data(); - sumsq_diff += params_[i]->sumsq_diff(); + for (int i = 0; i < learnable_params_.size(); ++i) { + asum_data += learnable_params_[i]->asum_data(); + asum_diff += learnable_params_[i]->asum_diff(); + sumsq_data += learnable_params_[i]->sumsq_data(); + sumsq_diff += learnable_params_[i]->sumsq_diff(); } const Dtype l2norm_data = std::sqrt(sumsq_data); const Dtype l2norm_diff = std::sqrt(sumsq_diff); From c2484747d813d616bcb504d97f93071b26bb372d Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Fri, 21 Aug 2015 17:29:06 -0700 Subject: [PATCH 190/331] NetSpec: don't require lists to specify single-element repeated fields --- python/caffe/net_spec.py | 10 ++++++++-- python/caffe/test/test_net_spec.py | 3 +-- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/python/caffe/net_spec.py b/python/caffe/net_spec.py index 77a0e0070ae..93fc01927db 100644 --- a/python/caffe/net_spec.py +++ b/python/caffe/net_spec.py @@ -56,8 +56,14 @@ def to_proto(*tops): def assign_proto(proto, name, val): """Assign a Python object to a protobuf message, based on the Python type (in recursive fashion). Lists become repeated fields/messages, dicts - become messages, and other types are assigned directly.""" - + become messages, and other types are assigned directly. For convenience, + repeated fields whose values are not lists are converted to single-element + lists; e.g., `my_repeated_int_field=3` is converted to + `my_repeated_int_field=[3]`.""" + + is_repeated_field = hasattr(getattr(proto, name), 'extend') + if is_repeated_field and not isinstance(val, list): + val = [val] if isinstance(val, list): if isinstance(val[0], dict): for item in val: diff --git a/python/caffe/test/test_net_spec.py b/python/caffe/test/test_net_spec.py index b4595e6531a..fee3c0aaebe 100644 --- a/python/caffe/test/test_net_spec.py +++ b/python/caffe/test/test_net_spec.py @@ -43,8 +43,7 @@ def anon_lenet(batch_size): def silent_net(): n = caffe.NetSpec() - n.data, n.data2 = L.DummyData(shape=[dict(dim=[3]), dict(dim=[4, 2])], - ntop=2) + n.data, n.data2 = L.DummyData(shape=dict(dim=3), ntop=2) n.silence_data = L.Silence(n.data, ntop=0) n.silence_data2 = L.Silence(n.data2, ntop=0) return n.to_proto() From 1bdc18c5beb4c6e679ed359eb707be8822306ea5 Mon Sep 17 00:00:00 2001 From: Lumin Zhou Date: Fri, 4 Sep 2015 04:38:43 +0000 Subject: [PATCH 191/331] Update extract_features.cpp --- tools/extract_features.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/extract_features.cpp b/tools/extract_features.cpp index 365dd495bbf..084c9bf88df 100644 --- a/tools/extract_features.cpp +++ b/tools/extract_features.cpp @@ -42,7 +42,7 @@ int feature_extraction_pipeline(int argc, char** argv) { " save_feature_dataset_name1[,name2,...] num_mini_batches db_type" " [CPU/GPU] [DEVICE_ID=0]\n" "Note: you can extract multiple features in one pass by specifying" - " multiple feature blob names and dataset names seperated by ','." + " multiple feature blob names and dataset names separated by ','." " The names cannot contain white space characters and the number of blobs" " and datasets must be equal."; return 1; From aa40ab98717507a60c23fb9cd4bf61c8b0bbb38d Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Thu, 3 Sep 2015 21:44:45 -0700 Subject: [PATCH 192/331] Fix AccuracyLayerTest for per-class accuracy. Fix AccuracyLayerTest for per-class accuracy. Previously in #2935, it crashes since the test accuracy is nan (0/0) when a class never appear. --- src/caffe/test/test_accuracy_layer.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/caffe/test/test_accuracy_layer.cpp b/src/caffe/test/test_accuracy_layer.cpp index 94e529b5eee..ef0e57a37a1 100644 --- a/src/caffe/test/test_accuracy_layer.cpp +++ b/src/caffe/test/test_accuracy_layer.cpp @@ -250,7 +250,6 @@ TYPED_TEST(AccuracyLayerTest, TestForwardCPUTopK) { TYPED_TEST(AccuracyLayerTest, TestForwardCPUPerClass) { LayerParameter layer_param; - Caffe::set_mode(Caffe::CPU); AccuracyLayer layer(layer_param); layer.SetUp(this->blob_bottom_vec_, this->blob_top_per_class_vec_); layer.Forward(this->blob_bottom_vec_, this->blob_top_per_class_vec_); @@ -279,16 +278,16 @@ TYPED_TEST(AccuracyLayerTest, TestForwardCPUPerClass) { EXPECT_NEAR(this->blob_top_->data_at(0, 0, 0, 0), num_correct_labels / 100.0, 1e-4); for (int i = 0; i < num_class; ++i) { + TypeParam accuracy_per_class = (num_per_class[i] > 0 ? + static_cast(correct_per_class[i]) / num_per_class[i] : 0); EXPECT_NEAR(this->blob_top_per_class_->data_at(i, 0, 0, 0), - static_cast(correct_per_class[i]) / num_per_class[i], - 1e-4); + accuracy_per_class, 1e-4); } } TYPED_TEST(AccuracyLayerTest, TestForwardCPUPerClassWithIgnoreLabel) { LayerParameter layer_param; - Caffe::set_mode(Caffe::CPU); const TypeParam kIgnoreLabelValue = -1; layer_param.mutable_accuracy_param()->set_ignore_label(kIgnoreLabelValue); AccuracyLayer layer(layer_param); @@ -329,9 +328,10 @@ TYPED_TEST(AccuracyLayerTest, TestForwardCPUPerClassWithIgnoreLabel) { EXPECT_NEAR(this->blob_top_->data_at(0, 0, 0, 0), num_correct_labels / TypeParam(count), 1e-4); for (int i = 0; i < 10; ++i) { + TypeParam accuracy_per_class = (num_per_class[i] > 0 ? + static_cast(correct_per_class[i]) / num_per_class[i] : 0); EXPECT_NEAR(this->blob_top_per_class_->data_at(i, 0, 0, 0), - TypeParam(correct_per_class[i]) / num_per_class[i], - 1e-4); + accuracy_per_class, 1e-4); } } From 5cc76ad2e38f19a140497ff09c475500da9d76cf Mon Sep 17 00:00:00 2001 From: Daniel Gordon Date: Fri, 4 Sep 2015 10:12:00 -0700 Subject: [PATCH 193/331] enabling the alternate solvers to be accessed by the python interface --- python/caffe/__init__.py | 2 +- python/caffe/_caffe.cpp | 9 +++++++++ python/caffe/pycaffe.py | 3 ++- 3 files changed, 12 insertions(+), 2 deletions(-) diff --git a/python/caffe/__init__.py b/python/caffe/__init__.py index 6cc44e729f4..ccda1bcae4f 100644 --- a/python/caffe/__init__.py +++ b/python/caffe/__init__.py @@ -1,4 +1,4 @@ -from .pycaffe import Net, SGDSolver +from .pycaffe import Net, SGDSolver, NesterovSolver, AdaGradSolver, RMSPropSolver, AdaDeltaSolver, AdamSolver from ._caffe import set_mode_cpu, set_mode_gpu, set_device, Layer, get_solver, layer_type_list from .proto.caffe_pb2 import TRAIN, TEST from .classifier import Classifier diff --git a/python/caffe/_caffe.cpp b/python/caffe/_caffe.cpp index cc49f60ab13..ccd5776ac40 100644 --- a/python/caffe/_caffe.cpp +++ b/python/caffe/_caffe.cpp @@ -297,6 +297,15 @@ BOOST_PYTHON_MODULE(_caffe) { bp::class_, bp::bases >, shared_ptr >, boost::noncopyable>( "AdaGradSolver", bp::init()); + bp::class_, bp::bases >, + shared_ptr >, boost::noncopyable>( + "RMSPropSolver", bp::init()); + bp::class_, bp::bases >, + shared_ptr >, boost::noncopyable>( + "AdaDeltaSolver", bp::init()); + bp::class_, bp::bases >, + shared_ptr >, boost::noncopyable>( + "AdamSolver", bp::init()); bp::def("get_solver", &GetSolverFromFile, bp::return_value_policy()); diff --git a/python/caffe/pycaffe.py b/python/caffe/pycaffe.py index 4f980a92c38..8ea24da4fdd 100644 --- a/python/caffe/pycaffe.py +++ b/python/caffe/pycaffe.py @@ -10,7 +10,8 @@ from itertools import zip_longest as izip_longest import numpy as np -from ._caffe import Net, SGDSolver +from ._caffe import Net, SGDSolver, NesterovSolver, AdaGradSolver, \ + RMSPropSolver, AdaDeltaSolver, AdamSolver import caffe.io # We directly update methods from Net here (rather than using composition or From 1394cdc383e2f41d7435862442b15151e8ac1237 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Fri, 4 Sep 2015 14:16:31 -0700 Subject: [PATCH 194/331] disallow PythonLayer in Multi-GPU training --- include/caffe/python_layer.hpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/include/caffe/python_layer.hpp b/include/caffe/python_layer.hpp index c43c1e8a91b..b839d52684e 100644 --- a/include/caffe/python_layer.hpp +++ b/include/caffe/python_layer.hpp @@ -18,6 +18,12 @@ class PythonLayer : public Layer { virtual void LayerSetUp(const vector*>& bottom, const vector*>& top) { + // Disallow PythonLayer in MultiGPU training stage, due to GIL issues + // Details: https://github.com/BVLC/caffe/issues/2936 + if (this->phase_ == TRAIN && Caffe::solver_count() > 1 + && !ShareInParallel()) { + LOG(FATAL) << "PythonLayer is not implemented in Multi-GPU training"; + } self_.attr("param_str") = bp::str( this->layer_param_.python_param().param_str()); self_.attr("setup")(bottom, top); From 8fbac04ac32672ae8a97f8a1171f1d39456b97ca Mon Sep 17 00:00:00 2001 From: Sean Bell Date: Wed, 9 Sep 2015 12:52:52 -0400 Subject: [PATCH 195/331] Minor: missing space in string formatting --- src/caffe/solver.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 394ec3b3ad7..2e59a881d82 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -732,7 +732,7 @@ void SGDSolver::SnapshotSolverStateToBinaryProto( } string snapshot_filename = Solver::SnapshotFilename(".solverstate"); LOG(INFO) - << "Snapshotting solver state to binary proto file" << snapshot_filename; + << "Snapshotting solver state to binary proto file " << snapshot_filename; WriteProtoToBinaryFile(state, snapshot_filename.c_str()); } From 3456259d400f7eef27e07c15c34f22b8d5e13bdd Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Sun, 13 Sep 2015 20:46:24 -0700 Subject: [PATCH 196/331] Use EXPECT_NEAR in EltwiseLayer test Otherwise there seem to be some numerical issues causing BLAS results not exactly same as evaluated results in test code. --- src/caffe/test/test_eltwise_layer.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/caffe/test/test_eltwise_layer.cpp b/src/caffe/test/test_eltwise_layer.cpp index be0c1347709..8031f6e9022 100644 --- a/src/caffe/test/test_eltwise_layer.cpp +++ b/src/caffe/test/test_eltwise_layer.cpp @@ -80,7 +80,7 @@ TYPED_TEST(EltwiseLayerTest, TestProd) { const Dtype* in_data_b = this->blob_bottom_b_->cpu_data(); const Dtype* in_data_c = this->blob_bottom_c_->cpu_data(); for (int i = 0; i < count; ++i) { - EXPECT_EQ(data[i], in_data_a[i] * in_data_b[i] * in_data_c[i]); + EXPECT_NEAR(data[i], in_data_a[i] * in_data_b[i] * in_data_c[i], 1e-4); } } @@ -99,7 +99,7 @@ TYPED_TEST(EltwiseLayerTest, TestSum) { const Dtype* in_data_b = this->blob_bottom_b_->cpu_data(); const Dtype* in_data_c = this->blob_bottom_c_->cpu_data(); for (int i = 0; i < count; ++i) { - EXPECT_EQ(data[i], in_data_a[i] + in_data_b[i] + in_data_c[i]); + EXPECT_NEAR(data[i], in_data_a[i] + in_data_b[i] + in_data_c[i], 1e-4); } } From ab554cb4918cf7bccfada00339b4d1d5ccf3b4af Mon Sep 17 00:00:00 2001 From: Sean Bell Date: Wed, 9 Sep 2015 12:49:27 -0400 Subject: [PATCH 197/331] Check that the snapshot directory is writeable before starting training --- include/caffe/solver.hpp | 2 ++ src/caffe/solver.cpp | 19 +++++++++++++++++++ 2 files changed, 21 insertions(+) diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index aba3e036004..8d52785ac6e 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -82,6 +82,8 @@ class Solver { callbacks_.push_back(value); } + void CheckSnapshotWritePermissions(); + protected: // Make and apply the update value for the current iteration. virtual void ApplyUpdate() = 0; diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 394ec3b3ad7..47493174f46 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -55,6 +55,7 @@ void Solver::Init(const SolverParameter& param) { << std::endl << param.DebugString(); param_ = param; CHECK_GE(param_.average_loss(), 1) << "average_loss should be non-negative."; + CheckSnapshotWritePermissions(); if (Caffe::root_solver() && param_.random_seed() >= 0) { Caffe::set_random_seed(param_.random_seed()); } @@ -434,6 +435,24 @@ void Solver::Snapshot() { SnapshotSolverState(model_filename); } +template +void Solver::CheckSnapshotWritePermissions() { + if (Caffe::root_solver() && param_.snapshot()) { + CHECK(param_.has_snapshot_prefix()) + << "In solver params, snapshot is specified but snapshot_prefix is not"; + string probe_filename = SnapshotFilename(".tempfile"); + std::ofstream probe_ofs(probe_filename.c_str()); + if (probe_ofs.good()) { + probe_ofs.close(); + std::remove(probe_filename.c_str()); + } else { + LOG(FATAL) << "Cannot write to snapshot prefix '" + << param_.snapshot_prefix() << "'. Make sure " + << "that the directory exists and is writeable."; + } + } +} + template string Solver::SnapshotFilename(const string extension) { string filename(param_.snapshot_prefix()); From b7f9cba875c6db5c4ae33446dc80cd010c1c392c Mon Sep 17 00:00:00 2001 From: Mohamed Omran Date: Tue, 15 Sep 2015 17:18:32 +0200 Subject: [PATCH 198/331] removed bug in caffe.io.resize_image when applied to Nd images --- python/caffe/io.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/caffe/io.py b/python/caffe/io.py index fc96266085f..0cad7211291 100644 --- a/python/caffe/io.py +++ b/python/caffe/io.py @@ -329,7 +329,7 @@ def resize_image(im, new_dims, interp_order=1): return ret else: # ndimage interpolates anything but more slowly. - scale = tuple(np.array(new_dims) / np.array(im.shape[:2])) + scale = tuple(np.array(new_dims, dtype=float) / np.array(im.shape[:2])) resized_im = zoom(im, scale + (1,), order=interp_order) return resized_im.astype(np.float32) From 3d3a8b2ca09b64d94836652d0c9b5ffbb31551f6 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Wed, 16 Sep 2015 12:06:16 -0700 Subject: [PATCH 199/331] Get back 'USE CPU' print for caffe train --- tools/caffe.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/caffe.cpp b/tools/caffe.cpp index ff63860a3c1..e3f684b5ab3 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -174,6 +174,7 @@ int train() { vector gpus; get_gpus(&gpus); if (gpus.size() == 0) { + LOG(INFO) << "Use CPU."; Caffe::set_mode(Caffe::CPU); } else { ostringstream s; From f3a933a620b8b089a7fe29ba76ec27f5408ff68d Mon Sep 17 00:00:00 2001 From: Tea Date: Sat, 27 Jun 2015 11:44:56 +0800 Subject: [PATCH 200/331] Separate IO dependencies OpenCV, LMDB, LevelDB and Snappy are made optional via switches (USE_OPENCV, USE_LMDB, USE_LEVELDB) available for Make and CMake builds. Since Snappy is a LevelDB dependency, its use is determined by USE_LEVELDB. HDF5 is left bundled because it is used for serializing weights and solverstates. --- .travis.yml | 11 ++--- CMakeLists.txt | 7 +++- Makefile | 28 +++++++++++-- Makefile.config.example | 5 +++ cmake/ConfigGen.cmake | 12 ++++++ cmake/Dependencies.cmake | 41 ++++++++++++------- cmake/Summary.cmake | 18 +++++--- cmake/Templates/CaffeConfig.cmake.in | 26 ++++++------ cmake/Templates/caffe_config.h.in | 5 +++ docs/installation.md | 9 ++-- .../cpp_classification/classification.cpp | 8 ++++ examples/mnist/convert_mnist_data.cpp | 12 ++++++ .../siamese/convert_mnist_siamese_data.cpp | 9 +++- include/caffe/data_layers.hpp | 3 +- include/caffe/data_transformer.hpp | 5 ++- include/caffe/util/db_leveldb.hpp | 2 + include/caffe/util/db_lmdb.hpp | 2 + include/caffe/util/io.hpp | 2 + python/caffe/test/test_layer_type_list.py | 1 + scripts/travis/travis_build_and_test.sh | 14 ++++++- .../travis/travis_setup_makefile_config.sh | 6 +++ src/caffe/data_transformer.cpp | 16 +++++++- src/caffe/layers/data_layer.cpp | 3 +- src/caffe/layers/image_data_layer.cpp | 2 + src/caffe/layers/memory_data_layer.cpp | 4 ++ src/caffe/layers/window_data_layer.cpp | 2 + src/caffe/test/test_data_layer.cpp | 6 +++ src/caffe/test/test_data_transformer.cpp | 2 + src/caffe/test/test_db.cpp | 2 + src/caffe/test/test_image_data_layer.cpp | 2 + src/caffe/test/test_io.cpp | 2 + src/caffe/test/test_layer_factory.cpp | 4 ++ src/caffe/test/test_memory_data_layer.cpp | 5 ++- src/caffe/test/test_upgrade_proto.cpp | 12 +++++- src/caffe/util/db.cpp | 14 +++++-- src/caffe/util/db_leveldb.cpp | 2 + src/caffe/util/db_lmdb.cpp | 2 + src/caffe/util/io.cpp | 10 ++++- tools/compute_image_mean.cpp | 4 ++ tools/convert_imageset.cpp | 4 ++ 40 files changed, 264 insertions(+), 60 deletions(-) diff --git a/.travis.yml b/.travis.yml index b920a935d0d..4dc7ed72d6c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -2,11 +2,12 @@ # one using CMake, and one using make. env: matrix: - - WITH_CUDA=false WITH_CMAKE=false - - WITH_CUDA=false WITH_CMAKE=true - - WITH_CUDA=true WITH_CMAKE=false - - WITH_CUDA=true WITH_CMAKE=true - - WITH_CUDA=false WITH_CMAKE=true PYTHON_VERSION=3 + - WITH_CUDA=false WITH_CMAKE=false WITH_IO=true + - WITH_CUDA=false WITH_CMAKE=true WITH_IO=true PYTHON_VERSION=3 + - WITH_CUDA=true WITH_CMAKE=false WITH_IO=true + - WITH_CUDA=true WITH_CMAKE=true WITH_IO=true + - WITH_CUDA=false WITH_CMAKE=false WITH_IO=false + - WITH_CUDA=false WITH_CMAKE=true WITH_IO=false PYTHON_VERSION=3 language: cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index ef599b68922..838723beca2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,13 +16,16 @@ include(cmake/ConfigGen.cmake) # ---[ Options caffe_option(CPU_ONLY "Build Caffe without CUDA support" OFF) # TODO: rename to USE_CUDA -caffe_option(USE_CUDNN "Build Caffe with cuDNN libary support" ON IF NOT CPU_ONLY) +caffe_option(USE_CUDNN "Build Caffe with cuDNN library support" ON IF NOT CPU_ONLY) caffe_option(BUILD_SHARED_LIBS "Build shared libraries" ON) caffe_option(BUILD_python "Build Python wrapper" ON) set(python_version "2" CACHE STRING "Specify which python version to use") caffe_option(BUILD_matlab "Build Matlab wrapper" OFF IF UNIX OR APPLE) caffe_option(BUILD_docs "Build documentation" ON IF UNIX OR APPLE) -caffe_option(BUILD_python_layer "Build the Caffe python layer" ON) +caffe_option(BUILD_python_layer "Build the caffe python layer" ON) +caffe_option(USE_LMDB "Build with lmdb" ON) +caffe_option(USE_LEVELDB "Build with levelDB" ON) +caffe_option(USE_OPENCV "Build with OpenCV support" ON) # ---[ Dependencies include(cmake/Dependencies.cmake) diff --git a/Makefile b/Makefile index 80bc37375be..ddaed59b0a9 100644 --- a/Makefile +++ b/Makefile @@ -169,9 +169,18 @@ ifneq ($(CPU_ONLY), 1) LIBRARY_DIRS += $(CUDA_LIB_DIR) LIBRARIES := cudart cublas curand endif -LIBRARIES += glog gflags protobuf leveldb snappy \ - lmdb boost_system hdf5_hl hdf5 m \ - opencv_core opencv_highgui opencv_imgproc + +LIBRARIES += glog gflags protobuf boost_system m hdf5_hl hdf5 + +ifeq ($(USE_LEVELDB), 1) + LIBRARIES += leveldb snappy +endif +ifeq ($(USE_LMDB), 1) + LIBRARIES += lmdb +endif +ifeq ($(USE_OPENCV), 1) + LIBRARIES += opencv_core opencv_highgui opencv_imgproc +endif PYTHON_LIBRARIES := boost_python python2.7 WARNINGS := -Wall -Wno-sign-compare @@ -290,6 +299,17 @@ ifeq ($(USE_CUDNN), 1) COMMON_FLAGS += -DUSE_CUDNN endif +# i/o libraries configuration +ifeq ($(USE_OPENCV), 1) + COMMON_FLAGS += -DUSE_OPENCV +endif +ifeq ($(USE_LEVELDB), 1) + COMMON_FLAGS += -DUSE_LEVELDB +endif +ifeq ($(USE_LMDB), 1) + COMMON_FLAGS += -DUSE_LMDB +endif + # CPU-only configuration ifeq ($(CPU_ONLY), 1) OBJS := $(PROTO_OBJS) $(CXX_OBJS) @@ -472,7 +492,7 @@ runtest: $(TEST_ALL_BIN) pytest: py cd python; python -m unittest discover -s caffe/test - + mattest: mat cd matlab; $(MATLAB_DIR)/bin/matlab -nodisplay -r 'caffe.run_tests(), exit()' diff --git a/Makefile.config.example b/Makefile.config.example index a873502559f..32e67ee493e 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -7,6 +7,11 @@ # CPU-only switch (uncomment to build without GPU support). # CPU_ONLY := 1 +# comment out to disable IO dependencies +USE_LEVELDB := 1 +USE_LMDB := 1 +USE_OPENCV := 1 + # To customize your choice of compiler, uncomment and set the following. # N.B. the default for Linux is g++ and the default for OSX is clang++ # CUSTOM_CXX := g++ diff --git a/cmake/ConfigGen.cmake b/cmake/ConfigGen.cmake index 566d6ca0aa7..8b259965359 100644 --- a/cmake/ConfigGen.cmake +++ b/cmake/ConfigGen.cmake @@ -56,6 +56,18 @@ function(caffe_generate_export_configs) list(APPEND Caffe_DEFINITIONS -DCPU_ONLY) endif() + if(USE_OPENCV) + list(APPEND Caffe_DEFINITIONS -DUSE_OPENCV) + endif() + + if(USE_LMDB) + list(APPEND Caffe_DEFINITIONS -DUSE_LMDB) + endif() + + if(USE_LEVELDB) + list(APPEND Caffe_DEFINITIONS -DUSE_LEVELDB) + endif() + if(NOT HAVE_CUDNN) set(HAVE_CUDNN FALSE) else() diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake index 7c86dd55a30..d68d7bfba66 100644 --- a/cmake/Dependencies.cmake +++ b/cmake/Dependencies.cmake @@ -29,19 +29,27 @@ include_directories(SYSTEM ${HDF5_INCLUDE_DIRS} ${HDF5_HL_INCLUDE_DIR}) list(APPEND Caffe_LINKER_LIBS ${HDF5_LIBRARIES}) # ---[ LMDB -find_package(LMDB REQUIRED) -include_directories(SYSTEM ${LMDB_INCLUDE_DIR}) -list(APPEND Caffe_LINKER_LIBS ${LMDB_LIBRARIES}) +if(USE_LMDB) + find_package(LMDB REQUIRED) + include_directories(SYSTEM ${LMDB_INCLUDE_DIR}) + list(APPEND Caffe_LINKER_LIBS ${LMDB_LIBRARIES}) + add_definitions(-DUSE_LMDB) +endif() # ---[ LevelDB -find_package(LevelDB REQUIRED) -include_directories(SYSTEM ${LevelDB_INCLUDE}) -list(APPEND Caffe_LINKER_LIBS ${LevelDB_LIBRARIES}) +if(USE_LEVELDB) + find_package(LevelDB REQUIRED) + include_directories(SYSTEM ${LevelDB_INCLUDE}) + list(APPEND Caffe_LINKER_LIBS ${LevelDB_LIBRARIES}) + add_definitions(-DUSE_LEVELDB) +endif() # ---[ Snappy -find_package(Snappy REQUIRED) -include_directories(SYSTEM ${Snappy_INCLUDE_DIR}) -list(APPEND Caffe_LINKER_LIBS ${Snappy_LIBRARIES}) +if(USE_LEVELDB) + find_package(Snappy REQUIRED) + include_directories(SYSTEM ${Snappy_INCLUDE_DIR}) + list(APPEND Caffe_LINKER_LIBS ${Snappy_LIBRARIES}) +endif() # ---[ CUDA include(cmake/Cuda.cmake) @@ -57,13 +65,16 @@ if(NOT HAVE_CUDA) endif() # ---[ OpenCV -find_package(OpenCV QUIET COMPONENTS core highgui imgproc imgcodecs) -if(NOT OpenCV_FOUND) # if not OpenCV 3.x, then imgcodecs are not found - find_package(OpenCV REQUIRED COMPONENTS core highgui imgproc) +if(USE_OPENCV) + find_package(OpenCV QUIET COMPONENTS core highgui imgproc imgcodecs) + if(NOT OpenCV_FOUND) # if not OpenCV 3.x, then imgcodecs are not found + find_package(OpenCV REQUIRED COMPONENTS core highgui imgproc) + endif() + include_directories(SYSTEM ${OpenCV_INCLUDE_DIRS}) + list(APPEND Caffe_LINKER_LIBS ${OpenCV_LIBS}) + message(STATUS "OpenCV found (${OpenCV_CONFIG_PATH})") + add_definitions(-DUSE_OPENCV) endif() -include_directories(SYSTEM ${OpenCV_INCLUDE_DIRS}) -list(APPEND Caffe_LINKER_LIBS ${OpenCV_LIBS}) -message(STATUS "OpenCV found (${OpenCV_CONFIG_PATH})") # ---[ BLAS if(NOT APPLE) diff --git a/cmake/Summary.cmake b/cmake/Summary.cmake index e094ac0040e..3d12e81a130 100644 --- a/cmake/Summary.cmake +++ b/cmake/Summary.cmake @@ -114,6 +114,9 @@ function(caffe_print_configuration_summary) caffe_status(" BUILD_matlab : ${BUILD_matlab}") caffe_status(" BUILD_docs : ${BUILD_docs}") caffe_status(" CPU_ONLY : ${CPU_ONLY}") + caffe_status(" USE_LMDB : ${USE_LMDB}") + caffe_status(" USE_LEVELDB : ${USE_LEVELDB}") + caffe_status(" USE_OPENCV : ${USE_OPENCV}") caffe_status("") caffe_status("Dependencies:") caffe_status(" BLAS : " APPLE THEN "Yes (vecLib)" ELSE "Yes (${BLAS})") @@ -121,10 +124,16 @@ function(caffe_print_configuration_summary) caffe_status(" glog : Yes") caffe_status(" gflags : Yes") caffe_status(" protobuf : " PROTOBUF_FOUND THEN "Yes (ver. ${PROTOBUF_VERSION})" ELSE "No" ) - caffe_status(" lmdb : " LMDB_FOUND THEN "Yes (ver. ${LMDB_VERSION})" ELSE "No") - caffe_status(" Snappy : " SNAPPY_FOUND THEN "Yes (ver. ${Snappy_VERSION})" ELSE "No" ) - caffe_status(" LevelDB : " LEVELDB_FOUND THEN "Yes (ver. ${LEVELDB_VERSION})" ELSE "No") - caffe_status(" OpenCV : Yes (ver. ${OpenCV_VERSION})") + if(USE_LMDB) + caffe_status(" lmdb : " LMDB_FOUND THEN "Yes (ver. ${LMDB_VERSION})" ELSE "No") + endif() + if(USE_LEVELDB) + caffe_status(" LevelDB : " LEVELDB_FOUND THEN "Yes (ver. ${LEVELDB_VERSION})" ELSE "No") + caffe_status(" Snappy : " SNAPPY_FOUND THEN "Yes (ver. ${Snappy_VERSION})" ELSE "No" ) + endif() + if(USE_OPENCV) + caffe_status(" OpenCV : Yes (ver. ${OpenCV_VERSION})") + endif() caffe_status(" CUDA : " HAVE_CUDA THEN "Yes (ver. ${CUDA_VERSION})" ELSE "No" ) caffe_status("") if(HAVE_CUDA) @@ -165,4 +174,3 @@ function(caffe_print_configuration_summary) caffe_status(" Install path : ${CMAKE_INSTALL_PREFIX}") caffe_status("") endfunction() - diff --git a/cmake/Templates/CaffeConfig.cmake.in b/cmake/Templates/CaffeConfig.cmake.in index 8f23742e52e..73f57ac2d74 100644 --- a/cmake/Templates/CaffeConfig.cmake.in +++ b/cmake/Templates/CaffeConfig.cmake.in @@ -17,22 +17,24 @@ # Caffe_HAVE_CUDNN - signals about cuDNN support -# OpenCV dependency +# OpenCV dependency (optional) -if(NOT OpenCV_FOUND) - set(Caffe_OpenCV_CONFIG_PATH "@OpenCV_CONFIG_PATH@") - if(Caffe_OpenCV_CONFIG_PATH) - get_filename_component(Caffe_OpenCV_CONFIG_PATH ${Caffe_OpenCV_CONFIG_PATH} ABSOLUTE) +if(@USE_OPENCV@) + if(NOT OpenCV_FOUND) + set(Caffe_OpenCV_CONFIG_PATH "@OpenCV_CONFIG_PATH@") + if(Caffe_OpenCV_CONFIG_PATH) + get_filename_component(Caffe_OpenCV_CONFIG_PATH ${Caffe_OpenCV_CONFIG_PATH} ABSOLUTE) - if(EXISTS ${Caffe_OpenCV_CONFIG_PATH} AND NOT TARGET opencv_core) - message(STATUS "Caffe: using OpenCV config from ${Caffe_OpenCV_CONFIG_PATH}") - include(${Caffe_OpenCV_CONFIG_PATH}/OpenCVModules.cmake) - endif() + if(EXISTS ${Caffe_OpenCV_CONFIG_PATH} AND NOT TARGET opencv_core) + message(STATUS "Caffe: using OpenCV config from ${Caffe_OpenCV_CONFIG_PATH}") + include(${Caffe_OpenCV_CONFIG_PATH}/OpenCVModules.cmake) + endif() - else() - find_package(OpenCV REQUIRED) + else() + find_package(OpenCV REQUIRED) + endif() + unset(Caffe_OpenCV_CONFIG_PATH) endif() - unset(Caffe_OpenCV_CONFIG_PATH) endif() # Compute paths diff --git a/cmake/Templates/caffe_config.h.in b/cmake/Templates/caffe_config.h.in index 6039e8f6b21..9302022d7da 100644 --- a/cmake/Templates/caffe_config.h.in +++ b/cmake/Templates/caffe_config.h.in @@ -30,3 +30,8 @@ /* Matlab */ #cmakedefine HAVE_MATLAB + +/* IO libraries */ +#cmakedefine USE_OPENCV +#cmakedefine USE_LMDB +#cmakedefine USE_LEVELDB diff --git a/docs/installation.md b/docs/installation.md index d535c6d093d..89a8c71c71a 100644 --- a/docs/installation.md +++ b/docs/installation.md @@ -17,16 +17,19 @@ When updating Caffe, it's best to `make clean` before re-compiling. ## Prerequisites -Caffe has several dependencies. +Caffe has several dependencies: * [CUDA](https://developer.nvidia.com/cuda-zone) is required for GPU mode. * library version 7.0 and the latest driver version are recommended, but 6.* is fine too * 5.5, and 5.0 are compatible but considered legacy * [BLAS](http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) via ATLAS, MKL, or OpenBLAS. * [Boost](http://www.boost.org/) >= 1.55 +* `protobuf`, `glog`, `gflags`, `hdf5` + +Optional dependencies: + * [OpenCV](http://opencv.org/) >= 2.4 including 3.0 -* `protobuf`, `glog`, `gflags` -* IO libraries `hdf5`, `leveldb`, `snappy`, `lmdb` +* IO libraries: `lmdb`, `leveldb` (note: leveldb requires `snappy`) Pycaffe and Matcaffe interfaces have their own natural needs. diff --git a/examples/cpp_classification/classification.cpp b/examples/cpp_classification/classification.cpp index dc8b863f53f..de48fb692c8 100644 --- a/examples/cpp_classification/classification.cpp +++ b/examples/cpp_classification/classification.cpp @@ -1,7 +1,9 @@ #include +#ifdef USE_OPENCV #include #include #include +#endif // USE_OPENCV #include #include #include @@ -9,6 +11,7 @@ #include #include +#ifdef USE_OPENCV using namespace caffe; // NOLINT(build/namespaces) using std::string; @@ -255,3 +258,8 @@ int main(int argc, char** argv) { << p.first << "\"" << std::endl; } } +#else +int main(int argc, char** argv) { + LOG(FATAL) << "This example requires OpenCV; compile with USE_OPENCV."; +} +#endif // USE_OPENCV diff --git a/examples/mnist/convert_mnist_data.cpp b/examples/mnist/convert_mnist_data.cpp index 54443f11dd3..8f29bafde85 100644 --- a/examples/mnist/convert_mnist_data.cpp +++ b/examples/mnist/convert_mnist_data.cpp @@ -9,9 +9,13 @@ #include #include #include + +#if defined(USE_LEVELDB) && defined(USE_LMDB) #include #include #include +#endif + #include #include @@ -20,6 +24,8 @@ #include "caffe/proto/caffe.pb.h" +#if defined(USE_LEVELDB) && defined(USE_LMDB) + using namespace caffe; // NOLINT(build/namespaces) using std::string; @@ -196,3 +202,9 @@ int main(int argc, char** argv) { } return 0; } +#else +int main(int argc, char** argv) { + LOG(FATAL) << "This example requires LevelDB and LMDB; " << + "compile with USE_LEVELDB and USE_LMDB."; +} +#endif // USE_LEVELDB and USE_LMDB diff --git a/examples/siamese/convert_mnist_siamese_data.cpp b/examples/siamese/convert_mnist_siamese_data.cpp index 8008b4439c5..ad08036fb08 100644 --- a/examples/siamese/convert_mnist_siamese_data.cpp +++ b/examples/siamese/convert_mnist_siamese_data.cpp @@ -10,12 +10,14 @@ #include "glog/logging.h" #include "google/protobuf/text_format.h" -#include "leveldb/db.h" #include "stdint.h" #include "caffe/proto/caffe.pb.h" #include "caffe/util/math_functions.hpp" +#ifdef USE_LEVELDB +#include "leveldb/db.h" + uint32_t swap_endian(uint32_t val) { val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF); return (val << 16) | (val >> 16); @@ -121,3 +123,8 @@ int main(int argc, char** argv) { } return 0; } +#else +int main(int argc, char** argv) { + LOG(FATAL) << "This example requires LevelDB; compile with USE_LEVELDB."; +} +#endif // USE_LEVELDB diff --git a/include/caffe/data_layers.hpp b/include/caffe/data_layers.hpp index 552d814131e..90fd0d19917 100644 --- a/include/caffe/data_layers.hpp +++ b/include/caffe/data_layers.hpp @@ -4,7 +4,6 @@ #include #include #include - #include "hdf5.h" #include "caffe/blob.hpp" @@ -275,8 +274,10 @@ class MemoryDataLayer : public BaseDataLayer { virtual inline int ExactNumTopBlobs() const { return 2; } virtual void AddDatumVector(const vector& datum_vector); +#ifdef USE_OPENCV virtual void AddMatVector(const vector& mat_vector, const vector& labels); +#endif // USE_OPENCV // Reset should accept const pointers, but can't, because the memory // will be given to Blob, which is mutable diff --git a/include/caffe/data_transformer.hpp b/include/caffe/data_transformer.hpp index 0ad68c80216..97b4ee6a8c4 100644 --- a/include/caffe/data_transformer.hpp +++ b/include/caffe/data_transformer.hpp @@ -50,6 +50,7 @@ class DataTransformer { void Transform(const vector & datum_vector, Blob* transformed_blob); +#ifdef USE_OPENCV /** * @brief Applies the transformation defined in the data layer's * transform_param block to a vector of Mat. @@ -74,6 +75,7 @@ class DataTransformer { * set_cpu_data() is used. See image_data_layer.cpp for an example. */ void Transform(const cv::Mat& cv_img, Blob* transformed_blob); +#endif // USE_OPENCV /** * @brief Applies the same transformation defined in the data layer's @@ -113,6 +115,7 @@ class DataTransformer { * @param mat_vector * A vector of Mat containing the data to be transformed. */ +#ifdef USE_OPENCV vector InferBlobShape(const vector & mat_vector); /** * @brief Infers the shape of transformed_blob will have when @@ -122,6 +125,7 @@ class DataTransformer { * cv::Mat containing the data to be transformed. */ vector InferBlobShape(const cv::Mat& cv_img); +#endif // USE_OPENCV protected: /** @@ -148,4 +152,3 @@ class DataTransformer { } // namespace caffe #endif // CAFFE_DATA_TRANSFORMER_HPP_ - diff --git a/include/caffe/util/db_leveldb.hpp b/include/caffe/util/db_leveldb.hpp index 10623554b67..e9fa0d32b66 100644 --- a/include/caffe/util/db_leveldb.hpp +++ b/include/caffe/util/db_leveldb.hpp @@ -1,3 +1,4 @@ +#ifdef USE_LEVELDB #ifndef CAFFE_UTIL_DB_LEVELDB_HPP #define CAFFE_UTIL_DB_LEVELDB_HPP @@ -71,3 +72,4 @@ class LevelDB : public DB { } // namespace caffe #endif // CAFFE_UTIL_DB_LEVELDB_HPP +#endif // USE_LEVELDB diff --git a/include/caffe/util/db_lmdb.hpp b/include/caffe/util/db_lmdb.hpp index cc7c90afc4c..4e1568ace50 100644 --- a/include/caffe/util/db_lmdb.hpp +++ b/include/caffe/util/db_lmdb.hpp @@ -1,3 +1,4 @@ +#ifdef USE_LMDB #ifndef CAFFE_UTIL_DB_LMDB_HPP #define CAFFE_UTIL_DB_LMDB_HPP @@ -89,3 +90,4 @@ class LMDB : public DB { } // namespace caffe #endif // CAFFE_UTIL_DB_LMDB_HPP +#endif // USE_LMDB diff --git a/include/caffe/util/io.hpp b/include/caffe/util/io.hpp index c0938ad0625..6070b4c7f3a 100644 --- a/include/caffe/util/io.hpp +++ b/include/caffe/util/io.hpp @@ -120,6 +120,7 @@ inline bool ReadImageToDatum(const string& filename, const int label, bool DecodeDatumNative(Datum* datum); bool DecodeDatum(Datum* datum, bool is_color); +#ifdef USE_OPENCV cv::Mat ReadImageToCVMat(const string& filename, const int height, const int width, const bool is_color); @@ -135,6 +136,7 @@ cv::Mat DecodeDatumToCVMatNative(const Datum& datum); cv::Mat DecodeDatumToCVMat(const Datum& datum, bool is_color); void CVMatToDatum(const cv::Mat& cv_img, Datum* datum); +#endif // USE_OPENCV } // namespace caffe diff --git a/python/caffe/test/test_layer_type_list.py b/python/caffe/test/test_layer_type_list.py index 7edc80df069..47f4cf6d008 100644 --- a/python/caffe/test/test_layer_type_list.py +++ b/python/caffe/test/test_layer_type_list.py @@ -5,6 +5,7 @@ class TestLayerTypeList(unittest.TestCase): def test_standard_types(self): + #removing 'Data' from list for type_name in ['Data', 'Convolution', 'InnerProduct']: self.assertIn(type_name, caffe.layer_type_list(), '%s not in layer_type_list()' % type_name) diff --git a/scripts/travis/travis_build_and_test.sh b/scripts/travis/travis_build_and_test.sh index 9ba737e28a9..bbc8213347b 100755 --- a/scripts/travis/travis_build_and_test.sh +++ b/scripts/travis/travis_build_and_test.sh @@ -1,5 +1,5 @@ #!/bin/bash -# Script called by Travis to do a CPU-only build of and test Caffe. +# Script called by Travis to build and test Caffe. set -e MAKE="make --jobs=$NUM_THREADS --keep-going" @@ -15,7 +15,12 @@ if $WITH_CMAKE; then if [ "$PYTHON_VERSION" = "3" ]; then PYTHON_ARGS="$PYTHON_ARGS -Dpython_version=3 -DBOOST_LIBRARYDIR=$CONDA_DIR/lib/" fi - cmake -DBUILD_python=ON -DCMAKE_BUILD_TYPE=Release $CPU_ONLY $PYTHON_ARGS -DCMAKE_INCLUDE_PATH="$CONDA_DIR/include/" -DCMAKE_LIBRARY_PATH="$CONDA_DIR/lib/" .. + if $WITH_IO; then + IO_ARGS="-DUSE_OPENCV=ON -DUSE_LMDB=ON -DUSE_LEVELDB=ON" + else + IO_ARGS="-DUSE_OPENCV=OFF -DUSE_LMDB=OFF -DUSE_LEVELDB=OFF" + fi + cmake -DBUILD_python=ON -DCMAKE_BUILD_TYPE=Release $CPU_ONLY $PYTHON_ARGS -DCMAKE_INCLUDE_PATH="$CONDA_DIR/include/" -DCMAKE_LIBRARY_PATH="$CONDA_DIR/lib/" $IO_ARGS .. $MAKE $MAKE pytest if ! $WITH_CUDA; then @@ -28,6 +33,11 @@ else if ! $WITH_CUDA; then export CPU_ONLY=1 fi + if $WITH_IO; then + export USE_LMDB=1 + export USE_LEVELDB=1 + export USE_OPENCV=1 + fi $MAKE all test pycaffe warn lint || true if ! $WITH_CUDA; then $MAKE runtest diff --git a/scripts/travis/travis_setup_makefile_config.sh b/scripts/travis/travis_setup_makefile_config.sh index 1440be2af8b..83aacf11fb0 100755 --- a/scripts/travis/travis_setup_makefile_config.sh +++ b/scripts/travis/travis_setup_makefile_config.sh @@ -11,6 +11,12 @@ if $WITH_CUDA; then echo "CUDA_ARCH := $GENCODE" >> Makefile.config fi +# Remove IO library settings from Makefile.config +# to avoid conflicts with CI configuration +sed -i -e '/USE_LMDB/d' Makefile.config +sed -i -e '/USE_LEVELDB/d' Makefile.config +sed -i -e '/USE_OPENCV/d' Makefile.config + cat << 'EOF' >> Makefile.config # Travis' nvcc doesn't like newer boost versions NVCCFLAGS := -Xcudafe --diag_suppress=cc_clobber_ignored -Xcudafe --diag_suppress=useless_using_declaration -Xcudafe --diag_suppress=set_but_not_used diff --git a/src/caffe/data_transformer.cpp b/src/caffe/data_transformer.cpp index 4666d9bd881..7189d67e289 100644 --- a/src/caffe/data_transformer.cpp +++ b/src/caffe/data_transformer.cpp @@ -1,4 +1,6 @@ +#ifdef USE_OPENCV #include +#endif // USE_OPENCV #include #include @@ -124,11 +126,13 @@ void DataTransformer::Transform(const Datum& datum, } } + template void DataTransformer::Transform(const Datum& datum, Blob* transformed_blob) { // If datum is encoded, decoded and transform the cv::image. if (datum.encoded()) { +#ifdef USE_OPENCV CHECK(!(param_.force_color() && param_.force_gray())) << "cannot set both force_color and force_gray"; cv::Mat cv_img; @@ -140,6 +144,9 @@ void DataTransformer::Transform(const Datum& datum, } // Transform the cv::image into blob. return Transform(cv_img, transformed_blob); +#else + LOG(FATAL) << "Encoded datum requires OpenCV; compile with USE_OPENCV."; +#endif // USE_OPENCV } else { if (param_.force_color() || param_.force_gray()) { LOG(ERROR) << "force_color and force_gray only for encoded datum"; @@ -194,6 +201,7 @@ void DataTransformer::Transform(const vector & datum_vector, } } +#ifdef USE_OPENCV template void DataTransformer::Transform(const vector & mat_vector, Blob* transformed_blob) { @@ -315,6 +323,7 @@ void DataTransformer::Transform(const cv::Mat& cv_img, } } } +#endif // USE_OPENCV template void DataTransformer::Transform(Blob* input_blob, @@ -432,6 +441,7 @@ void DataTransformer::Transform(Blob* input_blob, template vector DataTransformer::InferBlobShape(const Datum& datum) { if (datum.encoded()) { +#ifdef USE_OPENCV CHECK(!(param_.force_color() && param_.force_gray())) << "cannot set both force_color and force_gray"; cv::Mat cv_img; @@ -443,8 +453,10 @@ vector DataTransformer::InferBlobShape(const Datum& datum) { } // InferBlobShape using the cv::image. return InferBlobShape(cv_img); +#else + LOG(FATAL) << "Encoded datum requires OpenCV; compile with USE_OPENCV."; +#endif // USE_OPENCV } - const int crop_size = param_.crop_size(); const int datum_channels = datum.channels(); const int datum_height = datum.height(); @@ -474,6 +486,7 @@ vector DataTransformer::InferBlobShape( return shape; } +#ifdef USE_OPENCV template vector DataTransformer::InferBlobShape(const cv::Mat& cv_img) { const int crop_size = param_.crop_size(); @@ -504,6 +517,7 @@ vector DataTransformer::InferBlobShape( shape[0] = num; return shape; } +#endif // USE_OPENCV template void DataTransformer::InitRand() { diff --git a/src/caffe/layers/data_layer.cpp b/src/caffe/layers/data_layer.cpp index 0932d9feff3..71f8cb099e8 100644 --- a/src/caffe/layers/data_layer.cpp +++ b/src/caffe/layers/data_layer.cpp @@ -1,5 +1,6 @@ +#ifdef USE_OPENCV #include - +#endif // USE_OPENCV #include #include diff --git a/src/caffe/layers/image_data_layer.cpp b/src/caffe/layers/image_data_layer.cpp index 223ba3a75ca..3d2190f8bbb 100644 --- a/src/caffe/layers/image_data_layer.cpp +++ b/src/caffe/layers/image_data_layer.cpp @@ -1,3 +1,4 @@ +#ifdef USE_OPENCV #include #include // NOLINT(readability/streams) @@ -164,3 +165,4 @@ INSTANTIATE_CLASS(ImageDataLayer); REGISTER_LAYER_CLASS(ImageData); } // namespace caffe +#endif // USE_OPENCV diff --git a/src/caffe/layers/memory_data_layer.cpp b/src/caffe/layers/memory_data_layer.cpp index 42de4198bc4..2370aa04d3b 100644 --- a/src/caffe/layers/memory_data_layer.cpp +++ b/src/caffe/layers/memory_data_layer.cpp @@ -1,4 +1,6 @@ +#ifdef USE_OPENCV #include +#endif // USE_OPENCV #include @@ -53,6 +55,7 @@ void MemoryDataLayer::AddDatumVector(const vector& datum_vector) { has_new_data_ = true; } +#ifdef USE_OPENCV template void MemoryDataLayer::AddMatVector(const vector& mat_vector, const vector& labels) { @@ -76,6 +79,7 @@ void MemoryDataLayer::AddMatVector(const vector& mat_vector, Reset(top_data, top_label, num); has_new_data_ = true; } +#endif // USE_OPENCV template void MemoryDataLayer::Reset(Dtype* data, Dtype* labels, int n) { diff --git a/src/caffe/layers/window_data_layer.cpp b/src/caffe/layers/window_data_layer.cpp index f637f2ec6d4..f8db61c9258 100644 --- a/src/caffe/layers/window_data_layer.cpp +++ b/src/caffe/layers/window_data_layer.cpp @@ -1,3 +1,4 @@ +#ifdef USE_OPENCV #include #include @@ -468,3 +469,4 @@ INSTANTIATE_CLASS(WindowDataLayer); REGISTER_LAYER_CLASS(WindowData); } // namespace caffe +#endif // USE_OPENCV diff --git a/src/caffe/test/test_data_layer.cpp b/src/caffe/test/test_data_layer.cpp index afe2a40d227..9e03954a543 100644 --- a/src/caffe/test/test_data_layer.cpp +++ b/src/caffe/test/test_data_layer.cpp @@ -1,3 +1,4 @@ +#ifdef USE_OPENCV #include #include @@ -348,6 +349,7 @@ class DataLayerTest : public MultiDeviceTest { TYPED_TEST_CASE(DataLayerTest, TestDtypesAndDevices); +#ifdef USE_LEVELDB TYPED_TEST(DataLayerTest, TestReadLevelDB) { const bool unique_pixels = false; // all pixels the same; images different this->Fill(unique_pixels, DataParameter_DB_LEVELDB); @@ -385,7 +387,9 @@ TYPED_TEST(DataLayerTest, TestReadCropTestLevelDB) { this->Fill(unique_pixels, DataParameter_DB_LEVELDB); this->TestReadCrop(TEST); } +#endif // USE_LEVELDB +#ifdef USE_LMDB TYPED_TEST(DataLayerTest, TestReadLMDB) { const bool unique_pixels = false; // all pixels the same; images different this->Fill(unique_pixels, DataParameter_DB_LMDB); @@ -424,4 +428,6 @@ TYPED_TEST(DataLayerTest, TestReadCropTestLMDB) { this->TestReadCrop(TEST); } +#endif // USE_LMDB } // namespace caffe +#endif // USE_OPENCV diff --git a/src/caffe/test/test_data_transformer.cpp b/src/caffe/test/test_data_transformer.cpp index 16570e20356..8a1013744e8 100644 --- a/src/caffe/test/test_data_transformer.cpp +++ b/src/caffe/test/test_data_transformer.cpp @@ -1,3 +1,4 @@ +#ifdef USE_OPENCV #include #include @@ -353,3 +354,4 @@ TYPED_TEST(DataTransformTest, TestMeanFile) { } } // namespace caffe +#endif // USE_OPENCV diff --git a/src/caffe/test/test_db.cpp b/src/caffe/test/test_db.cpp index 5b2ac230a0b..1b487b14c58 100644 --- a/src/caffe/test/test_db.cpp +++ b/src/caffe/test/test_db.cpp @@ -1,3 +1,4 @@ +#if defined(USE_LEVELDB) && defined(USE_LMDB) && defined(USE_OPENCV) #include #include "boost/scoped_ptr.hpp" @@ -132,3 +133,4 @@ TYPED_TEST(DBTest, TestWrite) { } } // namespace caffe +#endif // USE_LEVELDB, USE_LMDB and USE_OPENCV diff --git a/src/caffe/test/test_image_data_layer.cpp b/src/caffe/test/test_image_data_layer.cpp index 931a5ebf137..481fcef7b27 100644 --- a/src/caffe/test/test_image_data_layer.cpp +++ b/src/caffe/test/test_image_data_layer.cpp @@ -1,3 +1,4 @@ +#ifdef USE_OPENCV #include #include #include @@ -177,3 +178,4 @@ TYPED_TEST(ImageDataLayerTest, TestShuffle) { } } // namespace caffe +#endif // USE_OPENCV diff --git a/src/caffe/test/test_io.cpp b/src/caffe/test/test_io.cpp index 4ab96311bbc..c2c919e90dc 100644 --- a/src/caffe/test/test_io.cpp +++ b/src/caffe/test/test_io.cpp @@ -1,3 +1,4 @@ +#ifdef USE_OPENCV #include #include #include @@ -420,3 +421,4 @@ TEST_F(IOTest, TestDecodeDatumToCVMatContentNative) { } } // namespace caffe +#endif // USE_OPENCV diff --git a/src/caffe/test/test_layer_factory.cpp b/src/caffe/test/test_layer_factory.cpp index c86fafd000c..7d5d39d8b91 100644 --- a/src/caffe/test/test_layer_factory.cpp +++ b/src/caffe/test/test_layer_factory.cpp @@ -31,12 +31,16 @@ TYPED_TEST(LayerFactoryTest, TestCreateLayer) { LayerParameter layer_param; // Data layers expect a DB if (iter->first == "Data") { +#ifdef USE_LEVELDB string tmp; MakeTempDir(&tmp); boost::scoped_ptr db(db::GetDB(DataParameter_DB_LEVELDB)); db->Open(tmp, db::NEW); db->Close(); layer_param.mutable_data_param()->set_source(tmp); +#else + continue; +#endif // USE_LEVELDB } layer_param.set_type(iter->first); layer = LayerRegistry::CreateLayer(layer_param); diff --git a/src/caffe/test/test_memory_data_layer.cpp b/src/caffe/test/test_memory_data_layer.cpp index a79033f59f1..7269a4d441b 100644 --- a/src/caffe/test/test_memory_data_layer.cpp +++ b/src/caffe/test/test_memory_data_layer.cpp @@ -1,4 +1,6 @@ +#ifdef USE_OPENCV #include +#endif // USE_OPENCV #include #include @@ -113,6 +115,7 @@ TYPED_TEST(MemoryDataLayerTest, TestForward) { } } +#ifdef USE_OPENCV TYPED_TEST(MemoryDataLayerTest, AddDatumVectorDefaultTransform) { typedef typename TypeParam::Dtype Dtype; @@ -292,5 +295,5 @@ TYPED_TEST(MemoryDataLayerTest, TestSetBatchSize) { } } } - +#endif // USE_OPENCV } // namespace caffe diff --git a/src/caffe/test/test_upgrade_proto.cpp b/src/caffe/test/test_upgrade_proto.cpp index 006720231a5..ee05b151e72 100644 --- a/src/caffe/test/test_upgrade_proto.cpp +++ b/src/caffe/test/test_upgrade_proto.cpp @@ -2892,6 +2892,7 @@ TEST_F(NetUpgradeTest, TestImageNet) { this->RunV1UpgradeTest(expected_v1_proto, expected_v2_proto); } // NOLINT(readability/fn_size) +#ifdef USE_OPENCV TEST_F(NetUpgradeTest, TestUpgradeV1LayerType) { LayerParameter layer_param; shared_ptr > layer; @@ -2906,16 +2907,25 @@ TEST_F(NetUpgradeTest, TestUpgradeV1LayerType) { layer_param.set_type(v2_layer_type); // Data layers expect a DB if (v2_layer_type == "Data") { + #ifdef USE_LEVELDB string tmp; MakeTempDir(&tmp); boost::scoped_ptr db(db::GetDB(DataParameter_DB_LEVELDB)); db->Open(tmp, db::NEW); db->Close(); layer_param.mutable_data_param()->set_source(tmp); + #else + continue; + #endif // USE_LEVELDB } + #ifndef USE_OPENCV + if (v2_layer_type == "ImageData" || v2_layer_type == "WindowData") { + continue; + } + #endif // !USE_OPENCV layer = LayerRegistry::CreateLayer(layer_param); EXPECT_EQ(v2_layer_type, layer->type()); } } - +#endif // USE_OPENCV } // NOLINT(readability/fn_size) // namespace caffe diff --git a/src/caffe/util/db.cpp b/src/caffe/util/db.cpp index f55420e9840..ccda054d881 100644 --- a/src/caffe/util/db.cpp +++ b/src/caffe/util/db.cpp @@ -8,23 +8,31 @@ namespace caffe { namespace db { DB* GetDB(DataParameter::DB backend) { switch (backend) { +#ifdef USE_LEVELDB case DataParameter_DB_LEVELDB: return new LevelDB(); +#endif // USE_LEVELDB +#ifdef USE_LMDB case DataParameter_DB_LMDB: return new LMDB(); +#endif // USE_LMDB default: LOG(FATAL) << "Unknown database backend"; } } DB* GetDB(const string& backend) { +#ifdef USE_LEVELDB if (backend == "leveldb") { return new LevelDB(); - } else if (backend == "lmdb") { + } +#endif // USE_LEVELDB +#ifdef USE_LMDB + if (backend == "lmdb") { return new LMDB(); - } else { - LOG(FATAL) << "Unknown database backend"; } +#endif // USE_LMDB + LOG(FATAL) << "Unknown database backend"; } } // namespace db diff --git a/src/caffe/util/db_leveldb.cpp b/src/caffe/util/db_leveldb.cpp index 06c46627d31..f5c4d8a660d 100644 --- a/src/caffe/util/db_leveldb.cpp +++ b/src/caffe/util/db_leveldb.cpp @@ -1,3 +1,4 @@ +#ifdef USE_LEVELDB #include "caffe/util/db_leveldb.hpp" #include @@ -19,3 +20,4 @@ void LevelDB::Open(const string& source, Mode mode) { } // namespace db } // namespace caffe +#endif // USE_LEVELDB diff --git a/src/caffe/util/db_lmdb.cpp b/src/caffe/util/db_lmdb.cpp index a054b796806..78dd880ac41 100644 --- a/src/caffe/util/db_lmdb.cpp +++ b/src/caffe/util/db_lmdb.cpp @@ -1,3 +1,4 @@ +#ifdef USE_LMDB #include "caffe/util/db_lmdb.hpp" #include @@ -49,3 +50,4 @@ void LMDBTransaction::Put(const string& key, const string& value) { } // namespace db } // namespace caffe +#endif // USE_LMDB diff --git a/src/caffe/util/io.cpp b/src/caffe/util/io.cpp index 6f03314202c..f2b1dd98423 100644 --- a/src/caffe/util/io.cpp +++ b/src/caffe/util/io.cpp @@ -3,9 +3,11 @@ #include #include #include +#ifdef USE_OPENCV #include #include #include +#endif // USE_OPENCV #include #include @@ -67,6 +69,7 @@ void WriteProtoToBinaryFile(const Message& proto, const char* filename) { CHECK(proto.SerializeToOstream(&output)); } +#ifdef USE_OPENCV cv::Mat ReadImageToCVMat(const string& filename, const int height, const int width, const bool is_color) { cv::Mat cv_img; @@ -98,6 +101,7 @@ cv::Mat ReadImageToCVMat(const string& filename, cv::Mat ReadImageToCVMat(const string& filename) { return ReadImageToCVMat(filename, 0, 0, true); } + // Do the file extension and encoding match? static bool matchExt(const std::string & fn, std::string en) { @@ -111,6 +115,7 @@ static bool matchExt(const std::string & fn, return true; return false; } + bool ReadImageToDatum(const string& filename, const int label, const int height, const int width, const bool is_color, const std::string & encoding, Datum* datum) { @@ -135,6 +140,7 @@ bool ReadImageToDatum(const string& filename, const int label, return false; } } +#endif // USE_OPENCV bool ReadFileToDatum(const string& filename, const int label, Datum* datum) { @@ -156,6 +162,7 @@ bool ReadFileToDatum(const string& filename, const int label, } } +#ifdef USE_OPENCV cv::Mat DecodeDatumToCVMatNative(const Datum& datum) { cv::Mat cv_img; CHECK(datum.encoded()) << "Datum not encoded"; @@ -227,6 +234,5 @@ void CVMatToDatum(const cv::Mat& cv_img, Datum* datum) { } datum->set_data(buffer); } - - +#endif // USE_OPENCV } // namespace caffe diff --git a/tools/compute_image_mean.cpp b/tools/compute_image_mean.cpp index b1fc7cae38f..2035d515195 100644 --- a/tools/compute_image_mean.cpp +++ b/tools/compute_image_mean.cpp @@ -24,6 +24,7 @@ DEFINE_string(backend, "lmdb", int main(int argc, char** argv) { ::google::InitGoogleLogging(argv[0]); +#ifdef USE_OPENCV #ifndef GFLAGS_GFLAGS_H_ namespace gflags = google; #endif @@ -115,5 +116,8 @@ int main(int argc, char** argv) { } LOG(INFO) << "mean_value channel [" << c << "]:" << mean_values[c] / dim; } +#else + LOG(FATAL) << "This tool requires OpenCV; compile with USE_OPENCV."; +#endif // USE_OPENCV return 0; } diff --git a/tools/convert_imageset.cpp b/tools/convert_imageset.cpp index aad1f1fe216..e51a2631077 100644 --- a/tools/convert_imageset.cpp +++ b/tools/convert_imageset.cpp @@ -43,6 +43,7 @@ DEFINE_string(encode_type, "", "Optional: What type should we encode the image as ('png','jpg',...)."); int main(int argc, char** argv) { +#ifdef USE_OPENCV ::google::InitGoogleLogging(argv[0]); // Print output to stderr (while still logging) FLAGS_alsologtostderr = 1; @@ -150,5 +151,8 @@ int main(int argc, char** argv) { txn->Commit(); LOG(INFO) << "Processed " << count << " files."; } +#else + LOG(FATAL) << "This tool requires OpenCV; compile with USE_OPENCV."; +#endif // USE_OPENCV return 0; } From 2349c6de69bf5043508cde41bb1d337fdb78e188 Mon Sep 17 00:00:00 2001 From: Tea Date: Thu, 17 Sep 2015 15:02:45 +0800 Subject: [PATCH 201/331] Fix case in CMake notices --- CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 838723beca2..37f937fe489 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,10 +19,10 @@ caffe_option(CPU_ONLY "Build Caffe without CUDA support" OFF) # TODO: rename to caffe_option(USE_CUDNN "Build Caffe with cuDNN library support" ON IF NOT CPU_ONLY) caffe_option(BUILD_SHARED_LIBS "Build shared libraries" ON) caffe_option(BUILD_python "Build Python wrapper" ON) -set(python_version "2" CACHE STRING "Specify which python version to use") +set(python_version "2" CACHE STRING "Specify which Python version to use") caffe_option(BUILD_matlab "Build Matlab wrapper" OFF IF UNIX OR APPLE) caffe_option(BUILD_docs "Build documentation" ON IF UNIX OR APPLE) -caffe_option(BUILD_python_layer "Build the caffe python layer" ON) +caffe_option(BUILD_python_layer "Build the Caffe Python layer" ON) caffe_option(USE_LMDB "Build with lmdb" ON) caffe_option(USE_LEVELDB "Build with levelDB" ON) caffe_option(USE_OPENCV "Build with OpenCV support" ON) From 68c9e2b4703ce18fd9a7ab541addf701129a8080 Mon Sep 17 00:00:00 2001 From: "T.E.A de Souza" Date: Tue, 8 Sep 2015 12:20:40 +0800 Subject: [PATCH 202/331] Add a comment indicating that Travis CI tests are CPU only --- scripts/travis/travis_build_and_test.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/travis/travis_build_and_test.sh b/scripts/travis/travis_build_and_test.sh index bbc8213347b..174f1ee5a0a 100755 --- a/scripts/travis/travis_build_and_test.sh +++ b/scripts/travis/travis_build_and_test.sh @@ -1,5 +1,6 @@ #!/bin/bash # Script called by Travis to build and test Caffe. +# Travis CI tests are CPU-only for lack of compatible hardware. set -e MAKE="make --jobs=$NUM_THREADS --keep-going" From e75ae965519444fb64d67c0aa6323bc2ef4049ef Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Thu, 17 Sep 2015 15:05:12 -0700 Subject: [PATCH 203/331] [build] include IO dependencies by default keep old behavior by including leveldb, lmdb, and opencv by default --- Makefile | 7 ++++++- Makefile.config.example | 8 ++++---- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/Makefile b/Makefile index ddaed59b0a9..a911133661f 100644 --- a/Makefile +++ b/Makefile @@ -172,6 +172,11 @@ endif LIBRARIES += glog gflags protobuf boost_system m hdf5_hl hdf5 +# handle IO dependencies +USE_LEVELDB ?= 1 +USE_LMDB ?= 1 +USE_OPENCV ?= 1 + ifeq ($(USE_LEVELDB), 1) LIBRARIES += leveldb snappy endif @@ -299,7 +304,7 @@ ifeq ($(USE_CUDNN), 1) COMMON_FLAGS += -DUSE_CUDNN endif -# i/o libraries configuration +# configure IO libraries ifeq ($(USE_OPENCV), 1) COMMON_FLAGS += -DUSE_OPENCV endif diff --git a/Makefile.config.example b/Makefile.config.example index 32e67ee493e..a20bad2f5ce 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -7,10 +7,10 @@ # CPU-only switch (uncomment to build without GPU support). # CPU_ONLY := 1 -# comment out to disable IO dependencies -USE_LEVELDB := 1 -USE_LMDB := 1 -USE_OPENCV := 1 +# uncomment to disable IO dependencies and corresponding data layers +# USE_LEVELDB := 0 +# USE_LMDB := 0 +# USE_OPENCV := 0 # To customize your choice of compiler, uncomment and set the following. # N.B. the default for Linux is g++ and the default for OSX is clang++ From f75d594bbec1efab69cdc09c04bed1762aebd0e1 Mon Sep 17 00:00:00 2001 From: Yan Chen Date: Fri, 18 Sep 2015 17:02:16 +0800 Subject: [PATCH 204/331] refine format of switch case in solver --- include/caffe/solver.hpp | 14 +++++++------- src/caffe/solver.cpp | 16 ++++++++-------- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/include/caffe/solver.hpp b/include/caffe/solver.hpp index 8d52785ac6e..2ecf539baef 100644 --- a/include/caffe/solver.hpp +++ b/include/caffe/solver.hpp @@ -283,19 +283,19 @@ Solver* GetSolver(const SolverParameter& param) { switch (type) { case SolverParameter_SolverType_SGD: - return new SGDSolver(param); + return new SGDSolver(param); case SolverParameter_SolverType_NESTEROV: - return new NesterovSolver(param); + return new NesterovSolver(param); case SolverParameter_SolverType_ADAGRAD: - return new AdaGradSolver(param); + return new AdaGradSolver(param); case SolverParameter_SolverType_RMSPROP: - return new RMSPropSolver(param); + return new RMSPropSolver(param); case SolverParameter_SolverType_ADADELTA: - return new AdaDeltaSolver(param); + return new AdaDeltaSolver(param); case SolverParameter_SolverType_ADAM: - return new AdamSolver(param); + return new AdamSolver(param); default: - LOG(FATAL) << "Unknown SolverType: " << type; + LOG(FATAL) << "Unknown SolverType: " << type; } return (Solver*) NULL; } diff --git a/src/caffe/solver.cpp b/src/caffe/solver.cpp index 3574ce75046..12c13dd8385 100644 --- a/src/caffe/solver.cpp +++ b/src/caffe/solver.cpp @@ -422,14 +422,14 @@ void Solver::Snapshot() { CHECK(Caffe::root_solver()); string model_filename; switch (param_.snapshot_format()) { - case caffe::SolverParameter_SnapshotFormat_BINARYPROTO: - model_filename = SnapshotToBinaryProto(); - break; - case caffe::SolverParameter_SnapshotFormat_HDF5: - model_filename = SnapshotToHDF5(); - break; - default: - LOG(FATAL) << "Unsupported snapshot format."; + case caffe::SolverParameter_SnapshotFormat_BINARYPROTO: + model_filename = SnapshotToBinaryProto(); + break; + case caffe::SolverParameter_SnapshotFormat_HDF5: + model_filename = SnapshotToHDF5(); + break; + default: + LOG(FATAL) << "Unsupported snapshot format."; } SnapshotSolverState(model_filename); From 4c2ff1693ea509dc4758e73b913f4cbec6c1ac3a Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Wed, 4 Mar 2015 19:27:56 -0800 Subject: [PATCH 205/331] caffe.proto: generalize ConvolutionParameter to N spatial axes --- src/caffe/proto/caffe.proto | 37 +++++++++++++++++++++++++++---------- 1 file changed, 27 insertions(+), 10 deletions(-) diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index aa299f8660b..86683eb45da 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -471,18 +471,24 @@ message ContrastiveLossParameter { message ConvolutionParameter { optional uint32 num_output = 1; // The number of outputs for the layer optional bool bias_term = 2 [default = true]; // whether to have bias terms + // Pad, kernel size, and stride are all given as a single value for equal - // dimensions in height and width or as Y, X pairs. - optional uint32 pad = 3 [default = 0]; // The padding size (equal in Y, X) - optional uint32 pad_h = 9 [default = 0]; // The padding height - optional uint32 pad_w = 10 [default = 0]; // The padding width - optional uint32 kernel_size = 4; // The kernel size (square) - optional uint32 kernel_h = 11; // The kernel height - optional uint32 kernel_w = 12; // The kernel width + // dimensions in all spatial dimensions, or once per spatial dimension. + repeated uint32 pad = 3; // The padding size; defaults to 0 + repeated uint32 kernel_size = 4; // The kernel size + repeated uint32 stride = 6; // The stride; defaults to 1 + + // For 2D convolution only, the *_h and *_w versions may also be used to + // specify both spatial dimensions. + optional uint32 pad_h = 9 [default = 0]; // The padding height (2D only) + optional uint32 pad_w = 10 [default = 0]; // The padding width (2D only) + optional uint32 kernel_h = 11; // The kernel height (2D only) + optional uint32 kernel_w = 12; // The kernel width (2D only) + optional uint32 stride_h = 13; // The stride height (2D only) + optional uint32 stride_w = 14; // The stride width (2D only) + optional uint32 group = 5 [default = 1]; // The group size for group conv - optional uint32 stride = 6 [default = 1]; // The stride (equal in Y, X) - optional uint32 stride_h = 13; // The stride height - optional uint32 stride_w = 14; // The stride width + optional FillerParameter weight_filler = 7; // The filler for the weight optional FillerParameter bias_filler = 8; // The filler for the bias enum Engine { @@ -491,6 +497,17 @@ message ConvolutionParameter { CUDNN = 2; } optional Engine engine = 15 [default = DEFAULT]; + + // The axis to interpret as "channels" when performing convolution. + // Preceding dimensions are treated as independent inputs; + // succeeding dimensions are treated as "spatial". + // With (N, C, H, W) inputs, and axis == 1 (the default), we perform + // N independent 2D convolutions, sliding C-channel (or (C/g)-channels, for + // groups g>1) filters across the spatial axes (H, W) of the input. + // With (N, C, D, H, W) inputs, and axis == 1, we perform + // N independent 3D convolutions, sliding (C/g)-channels + // filters across the spatial axes (D, H, W) of the input. + optional int32 axis = 16 [default = 1]; } message DataParameter { From 0813f32038bf7477d343ae369981166cfed783b5 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Wed, 4 Mar 2015 21:31:34 -0800 Subject: [PATCH 206/331] Blob: add SyncedMemory shape accessor for GPU shape access --- include/caffe/blob.hpp | 2 ++ src/caffe/blob.cpp | 11 +++++++++++ 2 files changed, 13 insertions(+) diff --git a/include/caffe/blob.hpp b/include/caffe/blob.hpp index dda7b1f8372..fea5117ef10 100644 --- a/include/caffe/blob.hpp +++ b/include/caffe/blob.hpp @@ -219,6 +219,7 @@ class Blob { const Dtype* cpu_data() const; void set_cpu_data(Dtype* data); + const int* gpu_shape() const; const Dtype* gpu_data() const; const Dtype* cpu_diff() const; const Dtype* gpu_diff() const; @@ -268,6 +269,7 @@ class Blob { protected: shared_ptr data_; shared_ptr diff_; + shared_ptr shape_data_; vector shape_; int count_; int capacity_; diff --git a/src/caffe/blob.cpp b/src/caffe/blob.cpp index 8450aa140be..c86fd5d1d94 100644 --- a/src/caffe/blob.cpp +++ b/src/caffe/blob.cpp @@ -24,11 +24,16 @@ void Blob::Reshape(const vector& shape) { CHECK_LE(shape.size(), kMaxBlobAxes); count_ = 1; shape_.resize(shape.size()); + if (!shape_data_ || shape_data_->size() < shape.size() * sizeof(int)) { + shape_data_.reset(new SyncedMemory(shape.size() * sizeof(int))); + } + int* shape_data = static_cast(shape_data_->mutable_cpu_data()); for (int i = 0; i < shape.size(); ++i) { CHECK_GE(shape[i], 0); CHECK_LE(shape[i], INT_MAX / count_) << "blob size exceeds INT_MAX"; count_ *= shape[i]; shape_[i] = shape[i]; + shape_data[i] = shape[i]; } if (count_ > capacity_) { capacity_ = count_; @@ -67,6 +72,12 @@ Blob::Blob(const vector& shape) Reshape(shape); } +template +const int* Blob::gpu_shape() const { + CHECK(shape_data_); + return (const int*)shape_data_->gpu_data(); +} + template const Dtype* Blob::cpu_data() const { CHECK(data_); From 9d8206e0f906069e7c04f08dfddefa1357f3915c Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Wed, 4 Mar 2015 19:30:17 -0800 Subject: [PATCH 207/331] Im2col and Convolution layers support N spatial axes --- include/caffe/util/im2col.hpp | 24 ++ include/caffe/vision_layers.hpp | 108 +++++- src/caffe/layers/base_conv_layer.cpp | 241 ++++++++---- src/caffe/layers/conv_layer.cpp | 32 +- src/caffe/layers/conv_layer.cu | 16 +- src/caffe/layers/cudnn_conv_layer.cpp | 46 ++- src/caffe/layers/cudnn_conv_layer.cu | 18 +- src/caffe/layers/deconv_layer.cpp | 32 +- src/caffe/layers/deconv_layer.cu | 16 +- src/caffe/layers/im2col_layer.cpp | 171 +++++--- src/caffe/layers/im2col_layer.cu | 41 +- src/caffe/proto/caffe.proto | 7 + src/caffe/test/test_convolution_layer.cpp | 409 ++++++++++++++++---- src/caffe/test/test_deconvolution_layer.cpp | 159 +++++++- src/caffe/test/test_im2col_kernel.cu | 87 ++++- src/caffe/test/test_im2col_layer.cpp | 30 +- src/caffe/util/im2col.cpp | 116 ++++++ src/caffe/util/im2col.cu | 306 ++++++++++++++- src/caffe/util/upgrade_proto.cpp | 6 +- 19 files changed, 1554 insertions(+), 311 deletions(-) diff --git a/include/caffe/util/im2col.hpp b/include/caffe/util/im2col.hpp index 0051e2fa067..531fd29c57a 100644 --- a/include/caffe/util/im2col.hpp +++ b/include/caffe/util/im2col.hpp @@ -3,24 +3,48 @@ namespace caffe { +template +void im2col_nd_cpu(const Dtype* data_im, const int num_spatial_axes, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_col); + template void im2col_cpu(const Dtype* data_im, const int channels, const int height, const int width, const int kernel_h, const int kernel_w, const int pad_h, const int pad_w, const int stride_h, const int stride_w, Dtype* data_col); +template +void col2im_nd_cpu(const Dtype* data_col, const int num_spatial_axes, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_im); + template void col2im_cpu(const Dtype* data_col, const int channels, const int height, const int width, const int patch_h, const int patch_w, const int pad_h, const int pad_w, const int stride_h, const int stride_w, Dtype* data_im); +template +void im2col_nd_gpu(const Dtype* data_im, const int num_spatial_axes, + const int col_size, const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_col); + template void im2col_gpu(const Dtype* data_im, const int channels, const int height, const int width, const int kernel_h, const int kernel_w, const int pad_h, const int pad_w, const int stride_h, const int stride_w, Dtype* data_col); +template +void col2im_nd_gpu(const Dtype* data_col, const int num_spatial_axes, + const int im_size, const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_im); + template void col2im_gpu(const Dtype* data_col, const int channels, const int height, const int width, const int patch_h, const int patch_w, diff --git a/include/caffe/vision_layers.hpp b/include/caffe/vision_layers.hpp index 211e3d9042d..eae65820c40 100644 --- a/include/caffe/vision_layers.hpp +++ b/include/caffe/vision_layers.hpp @@ -64,46 +64,101 @@ class BaseConvolutionLayer : public Layer { // Compute height_out_ and width_out_ from other parameters. virtual void compute_output_shape() = 0; - int kernel_h_, kernel_w_; - int stride_h_, stride_w_; + /// @brief The spatial dimensions of a filter kernel. + Blob kernel_shape_; + /// @brief The spatial dimensions of the stride. + Blob stride_; + /// @brief The spatial dimensions of the padding. + Blob pad_; + /// @brief The spatial dimensions of the convolution input. + Blob conv_input_shape_; + /// @brief The spatial dimensions of the input. + Blob input_shape_; + /// @brief The spatial dimensions of the col_buffer. + vector col_buffer_shape_; + /// @brief The spatial dimensions of the output. + vector output_shape_; + + int num_spatial_axes_; + int bottom_dim_; + int top_dim_; + + int channel_axis_; int num_; int channels_; - int pad_h_, pad_w_; - int height_, width_; int group_; + int out_spatial_dim_; + int weight_offset_; int num_output_; - int height_out_, width_out_; bool bias_term_; bool is_1x1_; + bool force_nd_im2col_; private: // wrap im2col/col2im so we don't have to remember the (long) argument lists inline void conv_im2col_cpu(const Dtype* data, Dtype* col_buff) { - im2col_cpu(data, conv_in_channels_, conv_in_height_, conv_in_width_, - kernel_h_, kernel_w_, pad_h_, pad_w_, stride_h_, stride_w_, col_buff); + if (!force_nd_im2col_ && num_spatial_axes_ == 2) { + im2col_cpu(data, conv_in_channels_, + conv_input_shape_.cpu_data()[1], conv_input_shape_.cpu_data()[2], + kernel_shape_.cpu_data()[0], kernel_shape_.cpu_data()[1], + pad_.cpu_data()[0], pad_.cpu_data()[1], + stride_.cpu_data()[0], stride_.cpu_data()[1], col_buff); + } else { + im2col_nd_cpu(data, num_spatial_axes_, conv_input_shape_.cpu_data(), + col_buffer_shape_.data(), kernel_shape_.cpu_data(), + pad_.cpu_data(), stride_.cpu_data(), col_buff); + } } inline void conv_col2im_cpu(const Dtype* col_buff, Dtype* data) { - col2im_cpu(col_buff, conv_in_channels_, conv_in_height_, conv_in_width_, - kernel_h_, kernel_w_, pad_h_, pad_w_, stride_h_, stride_w_, data); + if (!force_nd_im2col_ && num_spatial_axes_ == 2) { + col2im_cpu(col_buff, conv_in_channels_, + conv_input_shape_.cpu_data()[1], conv_input_shape_.cpu_data()[2], + kernel_shape_.cpu_data()[0], kernel_shape_.cpu_data()[1], + pad_.cpu_data()[0], pad_.cpu_data()[1], + stride_.cpu_data()[0], stride_.cpu_data()[1], data); + } else { + col2im_nd_cpu(col_buff, num_spatial_axes_, conv_input_shape_.cpu_data(), + col_buffer_shape_.data(), kernel_shape_.cpu_data(), + pad_.cpu_data(), stride_.cpu_data(), data); + } } #ifndef CPU_ONLY inline void conv_im2col_gpu(const Dtype* data, Dtype* col_buff) { - im2col_gpu(data, conv_in_channels_, conv_in_height_, conv_in_width_, - kernel_h_, kernel_w_, pad_h_, pad_w_, stride_h_, stride_w_, col_buff); + if (!force_nd_im2col_ && num_spatial_axes_ == 2) { + im2col_gpu(data, conv_in_channels_, + conv_input_shape_.cpu_data()[1], conv_input_shape_.cpu_data()[2], + kernel_shape_.cpu_data()[0], kernel_shape_.cpu_data()[1], + pad_.cpu_data()[0], pad_.cpu_data()[1], + stride_.cpu_data()[0], stride_.cpu_data()[1], col_buff); + } else { + im2col_nd_gpu(data, num_spatial_axes_, num_kernels_im2col_, + conv_input_shape_.gpu_data(), col_buffer_.gpu_shape(), + kernel_shape_.gpu_data(), pad_.gpu_data(), + stride_.gpu_data(), col_buff); + } } inline void conv_col2im_gpu(const Dtype* col_buff, Dtype* data) { - col2im_gpu(col_buff, conv_in_channels_, conv_in_height_, conv_in_width_, - kernel_h_, kernel_w_, pad_h_, pad_w_, stride_h_, stride_w_, data); + if (!force_nd_im2col_ && num_spatial_axes_ == 2) { + col2im_gpu(col_buff, conv_in_channels_, + conv_input_shape_.cpu_data()[1], conv_input_shape_.cpu_data()[2], + kernel_shape_.cpu_data()[0], kernel_shape_.cpu_data()[1], + pad_.cpu_data()[0], pad_.cpu_data()[1], + stride_.cpu_data()[0], stride_.cpu_data()[1], data); + } else { + col2im_nd_gpu(col_buff, num_spatial_axes_, num_kernels_col2im_, + conv_input_shape_.gpu_data(), col_buffer_.gpu_shape(), + kernel_shape_.gpu_data(), pad_.gpu_data(), stride_.gpu_data(), + data); + } } #endif + int num_kernels_im2col_; + int num_kernels_col2im_; int conv_out_channels_; int conv_in_channels_; int conv_out_spatial_dim_; - int conv_in_height_; - int conv_in_width_; int kernel_dim_; - int weight_offset_; int col_offset_; int output_offset_; @@ -250,7 +305,7 @@ class CuDNNConvolutionLayer : public ConvolutionLayer { cudnnTensorDescriptor_t bias_desc_; cudnnFilterDescriptor_t filter_desc_; vector conv_descs_; - int bottom_offset_, top_offset_, weight_offset_, bias_offset_; + int bottom_offset_, top_offset_, bias_offset_; size_t workspaceSizeInBytes; void *workspace; }; @@ -287,11 +342,22 @@ class Im2colLayer : public Layer { virtual void Backward_gpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom); - int kernel_h_, kernel_w_; - int stride_h_, stride_w_; + /// @brief The spatial dimensions of a filter kernel. + Blob kernel_shape_; + /// @brief The spatial dimensions of the stride. + Blob stride_; + /// @brief The spatial dimensions of the padding. + Blob pad_; + + int num_spatial_axes_; + int bottom_dim_; + int top_dim_; + + int channel_axis_; + int num_; int channels_; - int height_, width_; - int pad_h_, pad_w_; + + bool force_nd_im2col_; }; // Forward declare PoolingLayer and SplitLayer for use in LRNLayer. diff --git a/src/caffe/layers/base_conv_layer.cpp b/src/caffe/layers/base_conv_layer.cpp index ccb3adc7e89..a5b90a549bb 100644 --- a/src/caffe/layers/base_conv_layer.cpp +++ b/src/caffe/layers/base_conv_layer.cpp @@ -1,3 +1,4 @@ +#include #include #include "caffe/filler.hpp" @@ -11,50 +12,103 @@ namespace caffe { template void BaseConvolutionLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { - CHECK_EQ(4, bottom[0]->num_axes()) << "Input must have 4 axes, " - << "corresponding to (num, channels, height, width)"; // Configure the kernel size, padding, stride, and inputs. ConvolutionParameter conv_param = this->layer_param_.convolution_param(); - CHECK(!conv_param.has_kernel_size() != - !(conv_param.has_kernel_h() && conv_param.has_kernel_w())) - << "Filter size is kernel_size OR kernel_h and kernel_w; not both"; - CHECK(conv_param.has_kernel_size() || - (conv_param.has_kernel_h() && conv_param.has_kernel_w())) - << "For non-square filters both kernel_h and kernel_w are required."; - CHECK((!conv_param.has_pad() && conv_param.has_pad_h() - && conv_param.has_pad_w()) - || (!conv_param.has_pad_h() && !conv_param.has_pad_w())) - << "pad is pad OR pad_h and pad_w are required."; - CHECK((!conv_param.has_stride() && conv_param.has_stride_h() - && conv_param.has_stride_w()) - || (!conv_param.has_stride_h() && !conv_param.has_stride_w())) - << "Stride is stride OR stride_h and stride_w are required."; - if (conv_param.has_kernel_size()) { - kernel_h_ = kernel_w_ = conv_param.kernel_size(); + force_nd_im2col_ = conv_param.force_nd_im2col(); + channel_axis_ = bottom[0]->CanonicalAxisIndex(conv_param.axis()); + const int first_spatial_axis = channel_axis_ + 1; + const int num_axes = bottom[0]->num_axes(); + num_spatial_axes_ = num_axes - first_spatial_axis; + CHECK_GE(num_spatial_axes_, 0); + // Setup input dimensions (input_shape_). + vector bottom_dim_blob_shape(1, num_spatial_axes_ + 1); + input_shape_.Reshape(bottom_dim_blob_shape); + int* input_shape_data = input_shape_.mutable_cpu_data(); + for (int i = 0; i < num_spatial_axes_ + 1; ++i) { + input_shape_data[i] = bottom[0]->shape(channel_axis_ + i); + } + vector spatial_dim_blob_shape(1, std::max(num_spatial_axes_, 1)); + // Setup filter kernel dimensions (kernel_shape_). + kernel_shape_.Reshape(spatial_dim_blob_shape); + int* kernel_shape_data = kernel_shape_.mutable_cpu_data(); + if (conv_param.has_kernel_h() || conv_param.has_kernel_w()) { + CHECK_EQ(num_spatial_axes_, 2) + << "kernel_h & kernel_w can only be used for 2D convolution."; + CHECK_EQ(0, conv_param.kernel_size_size()) + << "Either kernel_size or kernel_h/w should be specified; not both."; + kernel_shape_data[0] = conv_param.kernel_h(); + kernel_shape_data[1] = conv_param.kernel_w(); } else { - kernel_h_ = conv_param.kernel_h(); - kernel_w_ = conv_param.kernel_w(); + const int num_kernel_dims = conv_param.kernel_size_size(); + CHECK(num_kernel_dims == 1 || num_kernel_dims == num_spatial_axes_) + << "kernel_size must be specified once, or once per spatial dimension " + << "(kernel_size specified " << num_kernel_dims << " times; " + << num_spatial_axes_ << " spatial dims);"; + for (int i = 0; i < num_spatial_axes_; ++i) { + kernel_shape_data[i] = + conv_param.kernel_size((num_kernel_dims == 1) ? 0 : i); + } + } + for (int i = 0; i < num_spatial_axes_; ++i) { + CHECK_GT(kernel_shape_data[i], 0) << "Filter dimensions must be nonzero."; } - CHECK_GT(kernel_h_, 0) << "Filter dimensions cannot be zero."; - CHECK_GT(kernel_w_, 0) << "Filter dimensions cannot be zero."; - if (!conv_param.has_pad_h()) { - pad_h_ = pad_w_ = conv_param.pad(); + // Setup stride dimensions (stride_). + stride_.Reshape(spatial_dim_blob_shape); + int* stride_data = stride_.mutable_cpu_data(); + if (conv_param.has_stride_h() || conv_param.has_stride_w()) { + CHECK_EQ(num_spatial_axes_, 2) + << "stride_h & stride_w can only be used for 2D convolution."; + CHECK_EQ(0, conv_param.stride_size()) + << "Either stride or stride_h/w should be specified; not both."; + stride_data[0] = conv_param.stride_h(); + stride_data[1] = conv_param.stride_w(); } else { - pad_h_ = conv_param.pad_h(); - pad_w_ = conv_param.pad_w(); + const int num_stride_dims = conv_param.stride_size(); + CHECK(num_stride_dims == 0 || num_stride_dims == 1 || + num_stride_dims == num_spatial_axes_) + << "stride must be specified once, or once per spatial dimension " + << "(stride specified " << num_stride_dims << " times; " + << num_spatial_axes_ << " spatial dims);"; + const int kDefaultStride = 1; + for (int i = 0; i < num_spatial_axes_; ++i) { + stride_data[i] = (num_stride_dims == 0) ? kDefaultStride : + conv_param.stride((num_stride_dims == 1) ? 0 : i); + CHECK_GT(stride_data[i], 0) << "Stride dimensions must be nonzero."; + } } - if (!conv_param.has_stride_h()) { - stride_h_ = stride_w_ = conv_param.stride(); + // Setup pad dimensions (pad_). + pad_.Reshape(spatial_dim_blob_shape); + int* pad_data = pad_.mutable_cpu_data(); + if (conv_param.has_pad_h() || conv_param.has_pad_w()) { + CHECK_EQ(num_spatial_axes_, 2) + << "pad_h & pad_w can only be used for 2D convolution."; + CHECK_EQ(0, conv_param.pad_size()) + << "Either pad or pad_h/w should be specified; not both."; + pad_data[0] = conv_param.pad_h(); + pad_data[1] = conv_param.pad_w(); } else { - stride_h_ = conv_param.stride_h(); - stride_w_ = conv_param.stride_w(); + const int num_pad_dims = conv_param.pad_size(); + CHECK(num_pad_dims == 0 || num_pad_dims == 1 || + num_pad_dims == num_spatial_axes_) + << "pad must be specified once, or once per spatial dimension " + << "(pad specified " << num_pad_dims << " times; " + << num_spatial_axes_ << " spatial dims);"; + const int kDefaultPad = 0; + for (int i = 0; i < num_spatial_axes_; ++i) { + pad_data[i] = (num_pad_dims == 0) ? kDefaultPad : + conv_param.pad((num_pad_dims == 1) ? 0 : i); + } } // Special case: im2col is the identity for 1x1 convolution with stride 1 // and no padding, so flag for skipping the buffer and transformation. - is_1x1_ = kernel_w_ == 1 && kernel_h_ == 1 - && stride_h_ == 1 && stride_w_ == 1 && pad_h_ == 0 && pad_w_ == 0; + is_1x1_ = true; + for (int i = 0; i < num_spatial_axes_; ++i) { + is_1x1_ &= + kernel_shape_data[i] == 1 && stride_data[i] == 1 && pad_data[i] == 0; + if (!is_1x1_) { break; } + } // Configure output channels and groups. - channels_ = bottom[0]->channels(); + channels_ = bottom[0]->shape(channel_axis_); num_output_ = this->layer_param_.convolution_param().num_output(); CHECK_GT(num_output_, 0); group_ = this->layer_param_.convolution_param().group(); @@ -71,8 +125,29 @@ void BaseConvolutionLayer::LayerSetUp(const vector*>& bottom, // Handle the parameters: weights and biases. // - blobs_[0] holds the filter weights // - blobs_[1] holds the biases (optional) + vector weight_shape(2); + weight_shape[0] = conv_out_channels_; + weight_shape[1] = conv_in_channels_ / group_; + for (int i = 0; i < num_spatial_axes_; ++i) { + weight_shape.push_back(kernel_shape_data[i]); + } bias_term_ = this->layer_param_.convolution_param().bias_term(); + vector bias_shape(bias_term_, num_output_); if (this->blobs_.size() > 0) { + CHECK_EQ(1 + bias_term_, this->blobs_.size()) + << "Incorrect number of weight blobs."; + if (weight_shape != this->blobs_[0]->shape()) { + Blob weight_shaped_blob(weight_shape); + LOG(FATAL) << "Incorrect weight shape: expected shape " + << weight_shaped_blob.shape_string() << "; instead, shape was " + << this->blobs_[0]->shape_string(); + } + if (bias_term_ && bias_shape != this->blobs_[1]->shape()) { + Blob bias_shaped_blob(bias_shape); + LOG(FATAL) << "Incorrect bias shape: expected shape " + << bias_shaped_blob.shape_string() << "; instead, shape was " + << this->blobs_[1]->shape_string(); + } LOG(INFO) << "Skipping parameter initialization"; } else { if (bias_term_) { @@ -82,20 +157,20 @@ void BaseConvolutionLayer::LayerSetUp(const vector*>& bottom, } // Initialize and fill the weights: // output channels x input channels per-group x kernel height x kernel width - this->blobs_[0].reset(new Blob( - conv_out_channels_, conv_in_channels_ / group_, kernel_h_, kernel_w_)); + this->blobs_[0].reset(new Blob(weight_shape)); shared_ptr > weight_filler(GetFiller( this->layer_param_.convolution_param().weight_filler())); weight_filler->Fill(this->blobs_[0].get()); // If necessary, initialize and fill the biases. if (bias_term_) { - vector bias_shape(1, num_output_); this->blobs_[1].reset(new Blob(bias_shape)); shared_ptr > bias_filler(GetFiller( this->layer_param_.convolution_param().bias_filler())); bias_filler->Fill(this->blobs_[1].get()); } } + kernel_dim_ = this->blobs_[0]->count(1); + weight_offset_ = conv_out_channels_ * kernel_dim_ / group_; // Propagate gradients to the parameters (as directed by backward pass). this->param_propagate_down_.resize(this->blobs_.size(), true); } @@ -103,52 +178,68 @@ void BaseConvolutionLayer::LayerSetUp(const vector*>& bottom, template void BaseConvolutionLayer::Reshape(const vector*>& bottom, const vector*>& top) { - CHECK_EQ(4, bottom[0]->num_axes()) << "Input must have 4 axes, " - << "corresponding to (num, channels, height, width)"; - num_ = bottom[0]->num(); - height_ = bottom[0]->height(); - width_ = bottom[0]->width(); - CHECK_EQ(bottom[0]->channels(), channels_) << "Input size incompatible with" - " convolution kernel."; + const int first_spatial_axis = channel_axis_ + 1; + CHECK_EQ(bottom[0]->num_axes(), first_spatial_axis + num_spatial_axes_) + << "bottom num_axes may not change."; + num_ = bottom[0]->count(0, channel_axis_); + CHECK_EQ(bottom[0]->shape(channel_axis_), channels_) + << "Input size incompatible with convolution kernel."; // TODO: generalize to handle inputs of different shapes. for (int bottom_id = 1; bottom_id < bottom.size(); ++bottom_id) { - CHECK_EQ(num_, bottom[bottom_id]->num()) << "Inputs must have same num."; - CHECK_EQ(channels_, bottom[bottom_id]->channels()) - << "Inputs must have same channels."; - CHECK_EQ(height_, bottom[bottom_id]->height()) - << "Inputs must have same height."; - CHECK_EQ(width_, bottom[bottom_id]->width()) - << "Inputs must have same width."; + CHECK(bottom[0]->shape() == bottom[bottom_id]->shape()) + << "All inputs must have the same shape."; } // Shape the tops. compute_output_shape(); + vector top_shape(bottom[0]->shape().begin(), + bottom[0]->shape().begin() + channel_axis_); + top_shape.push_back(num_output_); + for (int i = 0; i < num_spatial_axes_; ++i) { + top_shape.push_back(output_shape_[i]); + } for (int top_id = 0; top_id < top.size(); ++top_id) { - top[top_id]->Reshape(num_, num_output_, height_out_, width_out_); + top[top_id]->Reshape(top_shape); } if (reverse_dimensions()) { - conv_in_height_ = height_out_; - conv_in_width_ = width_out_; - conv_out_spatial_dim_ = height_ * width_; + conv_out_spatial_dim_ = bottom[0]->count(first_spatial_axis); } else { - conv_in_height_ = height_; - conv_in_width_ = width_; - conv_out_spatial_dim_ = height_out_ * width_out_; + conv_out_spatial_dim_ = top[0]->count(first_spatial_axis); } - kernel_dim_ = conv_in_channels_ * kernel_h_ * kernel_w_; - weight_offset_ = conv_out_channels_ * kernel_dim_ / group_ / group_; - col_offset_ = kernel_dim_ * conv_out_spatial_dim_ / group_; + col_offset_ = kernel_dim_ * conv_out_spatial_dim_; output_offset_ = conv_out_channels_ * conv_out_spatial_dim_ / group_; + // Setup input dimensions (conv_input_shape_). + vector bottom_dim_blob_shape(1, num_spatial_axes_ + 1); + conv_input_shape_.Reshape(bottom_dim_blob_shape); + int* conv_input_shape_data = conv_input_shape_.mutable_cpu_data(); + for (int i = 0; i < num_spatial_axes_ + 1; ++i) { + if (reverse_dimensions()) { + conv_input_shape_data[i] = top[0]->shape(channel_axis_ + i); + } else { + conv_input_shape_data[i] = bottom[0]->shape(channel_axis_ + i); + } + } // The im2col result buffer will only hold one image at a time to avoid // overly large memory usage. In the special case of 1x1 convolution // it goes lazily unused to save memory. - if (reverse_dimensions()) { - col_buffer_.Reshape(1, kernel_dim_, height_, width_); - } else { - col_buffer_.Reshape(1, kernel_dim_, height_out_, width_out_); + col_buffer_shape_.clear(); + col_buffer_shape_.push_back(kernel_dim_ * group_); + const int* input_shape_data = input_shape_.cpu_data() + 1; + for (int i = 0; i < num_spatial_axes_; ++i) { + if (reverse_dimensions()) { + col_buffer_shape_.push_back(input_shape_data[i]); + } else { + col_buffer_shape_.push_back(output_shape_[i]); + } } + col_buffer_.Reshape(col_buffer_shape_); + bottom_dim_ = bottom[0]->count(channel_axis_); + top_dim_ = top[0]->count(channel_axis_); + num_kernels_im2col_ = conv_in_channels_ * conv_out_spatial_dim_; + num_kernels_col2im_ = reverse_dimensions() ? top_dim_ : bottom_dim_; // Set up the all ones "bias multiplier" for adding biases by BLAS + out_spatial_dim_ = top[0]->count(first_spatial_axis); if (bias_term_) { - vector bias_multiplier_shape(1, height_out_ * width_out_); + vector bias_multiplier_shape(1, out_spatial_dim_); bias_multiplier_.Reshape(bias_multiplier_shape); caffe_set(bias_multiplier_.count(), Dtype(1), bias_multiplier_.mutable_cpu_data()); @@ -167,7 +258,7 @@ void BaseConvolutionLayer::forward_cpu_gemm(const Dtype* input, } for (int g = 0; g < group_; ++g) { caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, conv_out_channels_ / - group_, conv_out_spatial_dim_, kernel_dim_ / group_, + group_, conv_out_spatial_dim_, kernel_dim_, (Dtype)1., weights + weight_offset_ * g, col_buff + col_offset_ * g, (Dtype)0., output + output_offset_ * g); } @@ -177,7 +268,7 @@ template void BaseConvolutionLayer::forward_cpu_bias(Dtype* output, const Dtype* bias) { caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, num_output_, - height_out_ * width_out_, 1, (Dtype)1., bias, bias_multiplier_.cpu_data(), + out_spatial_dim_, 1, (Dtype)1., bias, bias_multiplier_.cpu_data(), (Dtype)1., output); } @@ -189,7 +280,7 @@ void BaseConvolutionLayer::backward_cpu_gemm(const Dtype* output, col_buff = input; } for (int g = 0; g < group_; ++g) { - caffe_cpu_gemm(CblasTrans, CblasNoTrans, kernel_dim_ / group_, + caffe_cpu_gemm(CblasTrans, CblasNoTrans, kernel_dim_, conv_out_spatial_dim_, conv_out_channels_ / group_, (Dtype)1., weights + weight_offset_ * g, output + output_offset_ * g, (Dtype)0., col_buff + col_offset_ * g); @@ -209,7 +300,7 @@ void BaseConvolutionLayer::weight_cpu_gemm(const Dtype* input, } for (int g = 0; g < group_; ++g) { caffe_cpu_gemm(CblasNoTrans, CblasTrans, conv_out_channels_ / group_, - kernel_dim_ / group_, conv_out_spatial_dim_, + kernel_dim_, conv_out_spatial_dim_, (Dtype)1., output + output_offset_ * g, col_buff + col_offset_ * g, (Dtype)1., weights + weight_offset_ * g); } @@ -218,7 +309,7 @@ void BaseConvolutionLayer::weight_cpu_gemm(const Dtype* input, template void BaseConvolutionLayer::backward_cpu_bias(Dtype* bias, const Dtype* input) { - caffe_cpu_gemv(CblasNoTrans, num_output_, height_out_ * width_out_, 1., + caffe_cpu_gemv(CblasNoTrans, num_output_, out_spatial_dim_, 1., input, bias_multiplier_.cpu_data(), 1., bias); } @@ -236,7 +327,7 @@ void BaseConvolutionLayer::forward_gpu_gemm(const Dtype* input, } for (int g = 0; g < group_; ++g) { caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, conv_out_channels_ / - group_, conv_out_spatial_dim_, kernel_dim_ / group_, + group_, conv_out_spatial_dim_, kernel_dim_, (Dtype)1., weights + weight_offset_ * g, col_buff + col_offset_ * g, (Dtype)0., output + output_offset_ * g); } @@ -246,7 +337,7 @@ template void BaseConvolutionLayer::forward_gpu_bias(Dtype* output, const Dtype* bias) { caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, num_output_, - height_out_ * width_out_, 1, (Dtype)1., bias, bias_multiplier_.gpu_data(), + out_spatial_dim_, 1, (Dtype)1., bias, bias_multiplier_.gpu_data(), (Dtype)1., output); } @@ -258,7 +349,7 @@ void BaseConvolutionLayer::backward_gpu_gemm(const Dtype* output, col_buff = input; } for (int g = 0; g < group_; ++g) { - caffe_gpu_gemm(CblasTrans, CblasNoTrans, kernel_dim_ / group_, + caffe_gpu_gemm(CblasTrans, CblasNoTrans, kernel_dim_, conv_out_spatial_dim_, conv_out_channels_ / group_, (Dtype)1., weights + weight_offset_ * g, output + output_offset_ * g, (Dtype)0., col_buff + col_offset_ * g); @@ -278,7 +369,7 @@ void BaseConvolutionLayer::weight_gpu_gemm(const Dtype* input, } for (int g = 0; g < group_; ++g) { caffe_gpu_gemm(CblasNoTrans, CblasTrans, conv_out_channels_ / group_, - kernel_dim_ / group_, conv_out_spatial_dim_, + kernel_dim_, conv_out_spatial_dim_, (Dtype)1., output + output_offset_ * g, col_buff + col_offset_ * g, (Dtype)1., weights + weight_offset_ * g); } @@ -287,7 +378,7 @@ void BaseConvolutionLayer::weight_gpu_gemm(const Dtype* input, template void BaseConvolutionLayer::backward_gpu_bias(Dtype* bias, const Dtype* input) { - caffe_gpu_gemv(CblasNoTrans, num_output_, height_out_ * width_out_, 1., + caffe_gpu_gemv(CblasNoTrans, num_output_, out_spatial_dim_, 1., input, bias_multiplier_.gpu_data(), 1., bias); } diff --git a/src/caffe/layers/conv_layer.cpp b/src/caffe/layers/conv_layer.cpp index 928ef5ee468..5cf26970a0b 100644 --- a/src/caffe/layers/conv_layer.cpp +++ b/src/caffe/layers/conv_layer.cpp @@ -10,10 +10,18 @@ namespace caffe { template void ConvolutionLayer::compute_output_shape() { - this->height_out_ = (this->height_ + 2 * this->pad_h_ - this->kernel_h_) - / this->stride_h_ + 1; - this->width_out_ = (this->width_ + 2 * this->pad_w_ - this->kernel_w_) - / this->stride_w_ + 1; + // input_shape_ + 1 to skip channel axis + const int* input_shape_data = this->input_shape_.cpu_data() + 1; + const int* kernel_shape_data = this->kernel_shape_.cpu_data(); + const int* stride_data = this->stride_.cpu_data(); + const int* pad_data = this->pad_.cpu_data(); + this->output_shape_.clear(); + for (int i = 0; i < this->num_spatial_axes_; ++i) { + const int input_dim = input_shape_data[i]; + const int output_dim = (input_dim + 2 * pad_data[i] - kernel_shape_data[i]) + / stride_data[i] + 1; + this->output_shape_.push_back(output_dim); + } } template @@ -24,11 +32,11 @@ void ConvolutionLayer::Forward_cpu(const vector*>& bottom, const Dtype* bottom_data = bottom[i]->cpu_data(); Dtype* top_data = top[i]->mutable_cpu_data(); for (int n = 0; n < this->num_; ++n) { - this->forward_cpu_gemm(bottom_data + bottom[i]->offset(n), weight, - top_data + top[i]->offset(n)); + this->forward_cpu_gemm(bottom_data + n * this->bottom_dim_, weight, + top_data + n * this->top_dim_); if (this->bias_term_) { const Dtype* bias = this->blobs_[1]->cpu_data(); - this->forward_cpu_bias(top_data + top[i]->offset(n), bias); + this->forward_cpu_bias(top_data + n * this->top_dim_, bias); } } } @@ -47,20 +55,20 @@ void ConvolutionLayer::Backward_cpu(const vector*>& top, if (this->bias_term_ && this->param_propagate_down_[1]) { Dtype* bias_diff = this->blobs_[1]->mutable_cpu_diff(); for (int n = 0; n < this->num_; ++n) { - this->backward_cpu_bias(bias_diff, top_diff + top[i]->offset(n)); + this->backward_cpu_bias(bias_diff, top_diff + n * this->top_dim_); } } if (this->param_propagate_down_[0] || propagate_down[i]) { for (int n = 0; n < this->num_; ++n) { // gradient w.r.t. weight. Note that we will accumulate diffs. if (this->param_propagate_down_[0]) { - this->weight_cpu_gemm(bottom_data + bottom[i]->offset(n), - top_diff + top[i]->offset(n), weight_diff); + this->weight_cpu_gemm(bottom_data + n * this->bottom_dim_, + top_diff + n * this->top_dim_, weight_diff); } // gradient w.r.t. bottom data, if necessary. if (propagate_down[i]) { - this->backward_cpu_gemm(top_diff + top[i]->offset(n), weight, - bottom_diff + bottom[i]->offset(n)); + this->backward_cpu_gemm(top_diff + n * this->top_dim_, weight, + bottom_diff + n * this->bottom_dim_); } } } diff --git a/src/caffe/layers/conv_layer.cu b/src/caffe/layers/conv_layer.cu index b8a98ff7cc9..b429d2b47d0 100644 --- a/src/caffe/layers/conv_layer.cu +++ b/src/caffe/layers/conv_layer.cu @@ -16,11 +16,11 @@ void ConvolutionLayer::Forward_gpu(const vector*>& bottom, const Dtype* bottom_data = bottom[i]->gpu_data(); Dtype* top_data = top[i]->mutable_gpu_data(); for (int n = 0; n < this->num_; ++n) { - this->forward_gpu_gemm(bottom_data + bottom[i]->offset(n), weight, - top_data + top[i]->offset(n)); + this->forward_gpu_gemm(bottom_data + n * this->bottom_dim_, weight, + top_data + n * this->top_dim_); if (this->bias_term_) { const Dtype* bias = this->blobs_[1]->gpu_data(); - this->forward_gpu_bias(top_data + top[i]->offset(n), bias); + this->forward_gpu_bias(top_data + n * this->top_dim_, bias); } } } @@ -37,7 +37,7 @@ void ConvolutionLayer::Backward_gpu(const vector*>& top, if (this->bias_term_ && this->param_propagate_down_[1]) { Dtype* bias_diff = this->blobs_[1]->mutable_gpu_diff(); for (int n = 0; n < this->num_; ++n) { - this->backward_gpu_bias(bias_diff, top_diff + top[i]->offset(n)); + this->backward_gpu_bias(bias_diff, top_diff + n * this->top_dim_); } } if (this->param_propagate_down_[0] || propagate_down[i]) { @@ -46,13 +46,13 @@ void ConvolutionLayer::Backward_gpu(const vector*>& top, for (int n = 0; n < this->num_; ++n) { // gradient w.r.t. weight. Note that we will accumulate diffs. if (this->param_propagate_down_[0]) { - this->weight_gpu_gemm(bottom_data + bottom[i]->offset(n), - top_diff + top[i]->offset(n), weight_diff); + this->weight_gpu_gemm(bottom_data + n * this->bottom_dim_, + top_diff + n * this->top_dim_, weight_diff); } // gradient w.r.t. bottom data, if necessary. if (propagate_down[i]) { - this->backward_gpu_gemm(top_diff + top[i]->offset(n), weight, - bottom_diff + bottom[i]->offset(n)); + this->backward_gpu_gemm(top_diff + n * this->top_dim_, weight, + bottom_diff + n * this->bottom_dim_); } } } diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index 104d2b9d669..3514fe2aba5 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -34,14 +34,15 @@ void CuDNNConvolutionLayer::LayerSetUp( } // Set the indexing parameters. - weight_offset_ = (this->num_output_ / this->group_) - * (this->channels_ / this->group_) * this->kernel_h_ * this->kernel_w_; bias_offset_ = (this->num_output_ / this->group_); // Create filter descriptor. + const int* kernel_shape_data = this->kernel_shape_.cpu_data(); + const int kernel_h = kernel_shape_data[0]; + const int kernel_w = kernel_shape_data[1]; cudnn::createFilterDesc(&filter_desc_, this->num_output_ / this->group_, this->channels_ / this->group_, - this->kernel_h_, this->kernel_w_); + kernel_h, kernel_w); // Create tensor descriptor(s) for data and corresponding convolution(s). for (int i = 0; i < bottom.size(); i++) { @@ -68,29 +69,36 @@ template void CuDNNConvolutionLayer::Reshape( const vector*>& bottom, const vector*>& top) { ConvolutionLayer::Reshape(bottom, top); - bottom_offset_ = (this->channels_ / this->group_) - * this->height_ * this->width_; - top_offset_ = (this->num_output_ / this->group_) - * this->height_out_ * this->width_out_; + CHECK_EQ(2, this->num_spatial_axes_) + << "CuDNNConvolution input must have 2 spatial axes " + << "(e.g., height and width). " + << "Use 'engine: CAFFE' for general ND convolution."; + bottom_offset_ = this->bottom_dim_ / this->group_; + top_offset_ = this->top_dim_ / this->group_; + const int height = bottom[0]->shape(this->channel_axis_ + 1); + const int width = bottom[0]->shape(this->channel_axis_ + 2); + const int height_out = top[0]->shape(this->channel_axis_ + 1); + const int width_out = top[0]->shape(this->channel_axis_ + 2); + const int* pad_data = this->pad_.cpu_data(); + const int pad_h = pad_data[0]; + const int pad_w = pad_data[1]; + const int* stride_data = this->stride_.cpu_data(); + const int stride_h = stride_data[0]; + const int stride_w = stride_data[1]; for (int i = 0; i < bottom.size(); i++) { cudnn::setTensor4dDesc(&bottom_descs_[i], this->num_, - this->channels_ / this->group_, - this->height_, this->width_, - this->channels_ * this->height_ * this->width_, - this->height_ * this->width_, - this->width_, 1); + this->channels_ / this->group_, height, width, + this->channels_ * height * width, + height * width, width, 1); cudnn::setTensor4dDesc(&top_descs_[i], this->num_, - this->num_output_ / this->group_, - this->height_out_, this->width_out_, - this->num_output_ * this->height_out_ * this->width_out_, - this->height_out_ * this->width_out_, - this->width_out_, 1); + this->num_output_ / this->group_, height_out, width_out, + this->num_output_ * this->out_spatial_dim_, + this->out_spatial_dim_, width_out, 1); cudnn::setConvolutionDesc(&conv_descs_[i], bottom_descs_[i], - filter_desc_, this->pad_h_, this->pad_w_, - this->stride_h_, this->stride_w_); + filter_desc_, pad_h, pad_w, stride_h, stride_w); } // Tensor descriptor for bias. diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index b4e802e13d1..691152021a3 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -14,15 +14,15 @@ __global__ void sync_conv_groups() { } template void CuDNNConvolutionLayer::Forward_gpu( const vector*>& bottom, const vector*>& top) { + const int* kernel_shape_data = this->kernel_shape_.cpu_data(); + const int kernel_h = kernel_shape_data[0]; + const int kernel_w = kernel_shape_data[1]; + const size_t workspace_limit_bytes = + kernel_h * kernel_w * this->channels_ * sizeof(int) + 1; + const Dtype* weight = this->blobs_[0]->gpu_data(); for (int i = 0; i < bottom.size(); ++i) { const Dtype* bottom_data = bottom[i]->gpu_data(); Dtype* top_data = top[i]->mutable_gpu_data(); - const Dtype* weight = this->blobs_[0]->gpu_data(); - - size_t workspace_limit_bytes = this->kernel_h_ * - this->kernel_w_ * - this->channels_ * - sizeof(int) + 1; // Forward through cuDNN in parallel over groups. for (int g = 0; g < this->group_; g++) { @@ -69,7 +69,7 @@ void CuDNNConvolutionLayer::Forward_gpu( CUDNN_CHECK(cudnnConvolutionForward(handle_[g], cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, - filter_desc_, weight + weight_offset_ * g, + filter_desc_, weight + this->weight_offset_ * g, conv_descs_[i], algo, workspace, workspaceSizeInBytes, cudnn::dataType::zero, @@ -128,7 +128,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], cudnn::dataType::one, - filter_desc_, weight_diff + weight_offset_ * g)); + filter_desc_, weight_diff + this->weight_offset_ * g)); } // Gradient w.r.t. bottom data. @@ -139,7 +139,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); CUDNN_CHECK(cudnnConvolutionBackwardData(handle_[2*this->group_ + g], cudnn::dataType::one, - filter_desc_, weight + weight_offset_ * g, + filter_desc_, weight + this->weight_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], cudnn::dataType::zero, diff --git a/src/caffe/layers/deconv_layer.cpp b/src/caffe/layers/deconv_layer.cpp index a4612963b6b..f1d1abf288a 100644 --- a/src/caffe/layers/deconv_layer.cpp +++ b/src/caffe/layers/deconv_layer.cpp @@ -10,10 +10,18 @@ namespace caffe { template void DeconvolutionLayer::compute_output_shape() { - this->height_out_ = this->stride_h_ * (this->height_ - 1) + this->kernel_h_ - - 2 * this->pad_h_; - this->width_out_ = this->stride_w_ * (this->width_ - 1) + this->kernel_w_ - - 2 * this->pad_w_; + // input_shape_ + 1 to skip channel axis + const int* input_shape_data = this->input_shape_.cpu_data() + 1; + const int* kernel_shape_data = this->kernel_shape_.cpu_data(); + const int* stride_data = this->stride_.cpu_data(); + const int* pad_data = this->pad_.cpu_data(); + this->output_shape_.clear(); + for (int i = 0; i < this->num_spatial_axes_; ++i) { + const int input_dim = input_shape_data[i]; + const int output_dim = stride_data[i] * (input_dim - 1) + + kernel_shape_data[i] - 2 * pad_data[i]; + this->output_shape_.push_back(output_dim); + } } template @@ -24,11 +32,11 @@ void DeconvolutionLayer::Forward_cpu(const vector*>& bottom, const Dtype* bottom_data = bottom[i]->cpu_data(); Dtype* top_data = top[i]->mutable_cpu_data(); for (int n = 0; n < this->num_; ++n) { - this->backward_cpu_gemm(bottom_data + bottom[i]->offset(n), weight, - top_data + top[i]->offset(n)); + this->backward_cpu_gemm(bottom_data + n * this->bottom_dim_, weight, + top_data + n * this->top_dim_); if (this->bias_term_) { const Dtype* bias = this->blobs_[1]->cpu_data(); - this->forward_cpu_bias(top_data + top[i]->offset(n), bias); + this->forward_cpu_bias(top_data + n * this->top_dim_, bias); } } } @@ -47,21 +55,21 @@ void DeconvolutionLayer::Backward_cpu(const vector*>& top, if (this->bias_term_ && this->param_propagate_down_[1]) { Dtype* bias_diff = this->blobs_[1]->mutable_cpu_diff(); for (int n = 0; n < this->num_; ++n) { - this->backward_cpu_bias(bias_diff, top_diff + top[i]->offset(n)); + this->backward_cpu_bias(bias_diff, top_diff + n * this->top_dim_); } } if (this->param_propagate_down_[0] || propagate_down[i]) { for (int n = 0; n < this->num_; ++n) { // Gradient w.r.t. weight. Note that we will accumulate diffs. if (this->param_propagate_down_[0]) { - this->weight_cpu_gemm(top_diff + top[i]->offset(n), - bottom_data + bottom[i]->offset(n), weight_diff); + this->weight_cpu_gemm(top_diff + n * this->top_dim_, + bottom_data + n * this->bottom_dim_, weight_diff); } // Gradient w.r.t. bottom data, if necessary, reusing the column buffer // we might have just computed above. if (propagate_down[i]) { - this->forward_cpu_gemm(top_diff + top[i]->offset(n), weight, - bottom_diff + bottom[i]->offset(n), + this->forward_cpu_gemm(top_diff + n * this->top_dim_, weight, + bottom_diff + n * this->bottom_dim_, this->param_propagate_down_[0]); } } diff --git a/src/caffe/layers/deconv_layer.cu b/src/caffe/layers/deconv_layer.cu index 8a1eed8aa16..ea83f56f1b2 100644 --- a/src/caffe/layers/deconv_layer.cu +++ b/src/caffe/layers/deconv_layer.cu @@ -16,11 +16,11 @@ void DeconvolutionLayer::Forward_gpu(const vector*>& bottom, const Dtype* bottom_data = bottom[i]->gpu_data(); Dtype* top_data = top[i]->mutable_gpu_data(); for (int n = 0; n < this->num_; ++n) { - this->backward_gpu_gemm(bottom_data + bottom[i]->offset(n), weight, - top_data + top[i]->offset(n)); + this->backward_gpu_gemm(bottom_data + n * this->bottom_dim_, weight, + top_data + n * this->top_dim_); if (this->bias_term_) { const Dtype* bias = this->blobs_[1]->gpu_data(); - this->forward_gpu_bias(top_data + top[i]->offset(n), bias); + this->forward_gpu_bias(top_data + n * this->top_dim_, bias); } } } @@ -39,20 +39,20 @@ void DeconvolutionLayer::Backward_gpu(const vector*>& top, if (this->bias_term_ && this->param_propagate_down_[1]) { Dtype* bias_diff = this->blobs_[1]->mutable_gpu_diff(); for (int n = 0; n < this->num_; ++n) { - this->backward_gpu_bias(bias_diff, top_diff + top[i]->offset(n)); + this->backward_gpu_bias(bias_diff, top_diff + n * this->top_dim_); } } if (this->param_propagate_down_[0] || propagate_down[i]) { for (int n = 0; n < this->num_; ++n) { // gradient w.r.t. weight. Note that we will accumulate diffs. if (this->param_propagate_down_[0]) { - this->weight_gpu_gemm(top_diff + top[i]->offset(n), - bottom_data + bottom[i]->offset(n), weight_diff); + this->weight_gpu_gemm(top_diff + n * this->top_dim_, + bottom_data + n * this->bottom_dim_, weight_diff); } // gradient w.r.t. bottom data, if necessary. if (propagate_down[i]) { - this->forward_gpu_gemm(top_diff + top[i]->offset(n), weight, - bottom_diff + bottom[i]->offset(n), + this->forward_gpu_gemm(top_diff + this->top_dim_, weight, + bottom_diff + n * this->bottom_dim_, this->param_propagate_down_[0]); } } diff --git a/src/caffe/layers/im2col_layer.cpp b/src/caffe/layers/im2col_layer.cpp index 1c802714e33..595c9dbbe5e 100644 --- a/src/caffe/layers/im2col_layer.cpp +++ b/src/caffe/layers/im2col_layer.cpp @@ -11,54 +11,106 @@ template void Im2colLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { ConvolutionParameter conv_param = this->layer_param_.convolution_param(); - CHECK(!conv_param.has_kernel_size() != - !(conv_param.has_kernel_h() && conv_param.has_kernel_w())) - << "Filter size is kernel_size OR kernel_h and kernel_w; not both"; - CHECK(conv_param.has_kernel_size() || - (conv_param.has_kernel_h() && conv_param.has_kernel_w())) - << "For non-square filters both kernel_h and kernel_w are required."; - CHECK((!conv_param.has_pad() && conv_param.has_pad_h() - && conv_param.has_pad_w()) - || (!conv_param.has_pad_h() && !conv_param.has_pad_w())) - << "pad is pad OR pad_h and pad_w are required."; - CHECK((!conv_param.has_stride() && conv_param.has_stride_h() - && conv_param.has_stride_w()) - || (!conv_param.has_stride_h() && !conv_param.has_stride_w())) - << "Stride is stride OR stride_h and stride_w are required."; - if (conv_param.has_kernel_size()) { - kernel_h_ = kernel_w_ = conv_param.kernel_size(); + force_nd_im2col_ = conv_param.force_nd_im2col(); + const int input_num_dims = bottom[0]->shape().size(); + channel_axis_ = bottom[0]->CanonicalAxisIndex(conv_param.axis()); + const int first_spatial_dim = channel_axis_ + 1; + num_spatial_axes_ = input_num_dims - first_spatial_dim; + CHECK_GE(num_spatial_axes_, 1); + vector dim_blob_shape(1, num_spatial_axes_); + // Setup filter kernel dimensions (kernel_shape_). + kernel_shape_.Reshape(dim_blob_shape); + int* kernel_shape_data = kernel_shape_.mutable_cpu_data(); + if (conv_param.has_kernel_h() || conv_param.has_kernel_w()) { + CHECK_EQ(num_spatial_axes_, 2) + << "kernel_h & kernel_w can only be used for 2D convolution."; + CHECK_EQ(0, conv_param.kernel_size_size()) + << "Either kernel_size or kernel_h/w should be specified; not both."; + kernel_shape_data[0] = conv_param.kernel_h(); + kernel_shape_data[1] = conv_param.kernel_w(); } else { - kernel_h_ = conv_param.kernel_h(); - kernel_w_ = conv_param.kernel_w(); + const int num_kernel_dims = conv_param.kernel_size_size(); + CHECK(num_kernel_dims == 1 || num_kernel_dims == num_spatial_axes_) + << "kernel_size must be specified once, or once per spatial dimension " + << "(kernel_size specified " << num_kernel_dims << " times; " + << num_spatial_axes_ << " spatial dims);"; + for (int i = 0; i < num_spatial_axes_; ++i) { + kernel_shape_data[i] = + conv_param.kernel_size((num_kernel_dims == 1) ? 0 : i); + } } - CHECK_GT(kernel_h_, 0) << "Filter dimensions cannot be zero."; - CHECK_GT(kernel_w_, 0) << "Filter dimensions cannot be zero."; - if (!conv_param.has_pad_h()) { - pad_h_ = pad_w_ = conv_param.pad(); + for (int i = 0; i < num_spatial_axes_; ++i) { + CHECK_GT(kernel_shape_data[i], 0) << "Filter dimensions must be nonzero."; + } + // Setup stride dimensions (stride_). + stride_.Reshape(dim_blob_shape); + int* stride_data = stride_.mutable_cpu_data(); + if (conv_param.has_stride_h() || conv_param.has_stride_w()) { + CHECK_EQ(num_spatial_axes_, 2) + << "stride_h & stride_w can only be used for 2D convolution."; + CHECK_EQ(0, conv_param.stride_size()) + << "Either stride or stride_h/w should be specified; not both."; + stride_data[0] = conv_param.stride_h(); + stride_data[1] = conv_param.stride_w(); } else { - pad_h_ = conv_param.pad_h(); - pad_w_ = conv_param.pad_w(); + const int num_stride_dims = conv_param.stride_size(); + CHECK(num_stride_dims == 0 || num_stride_dims == 1 || + num_stride_dims == num_spatial_axes_) + << "stride must be specified once, or once per spatial dimension " + << "(stride specified " << num_stride_dims << " times; " + << num_spatial_axes_ << " spatial dims);"; + const int kDefaultStride = 1; + for (int i = 0; i < num_spatial_axes_; ++i) { + stride_data[i] = (num_stride_dims == 0) ? kDefaultStride : + conv_param.stride((num_stride_dims == 1) ? 0 : i); + CHECK_GT(stride_data[i], 0) << "Stride dimensions must be nonzero."; + } } - if (!conv_param.has_stride_h()) { - stride_h_ = stride_w_ = conv_param.stride(); + // Setup pad dimensions (pad_). + pad_.Reshape(dim_blob_shape); + int* pad_data = pad_.mutable_cpu_data(); + if (conv_param.has_pad_h() || conv_param.has_pad_w()) { + CHECK_EQ(num_spatial_axes_, 2) + << "pad_h & pad_w can only be used for 2D convolution."; + CHECK_EQ(0, conv_param.pad_size()) + << "Either pad or pad_h/w should be specified; not both."; + pad_data[0] = conv_param.pad_h(); + pad_data[1] = conv_param.pad_w(); } else { - stride_h_ = conv_param.stride_h(); - stride_w_ = conv_param.stride_w(); + const int num_pad_dims = conv_param.pad_size(); + CHECK(num_pad_dims == 0 || num_pad_dims == 1 || + num_pad_dims == num_spatial_axes_) + << "pad must be specified once, or once per spatial dimension " + << "(pad specified " << num_pad_dims << " times; " + << num_spatial_axes_ << " spatial dims);"; + const int kDefaultPad = 0; + for (int i = 0; i < num_spatial_axes_; ++i) { + pad_data[i] = (num_pad_dims == 0) ? kDefaultPad : + conv_param.pad((num_pad_dims == 1) ? 0 : i); + } } } template void Im2colLayer::Reshape(const vector*>& bottom, const vector*>& top) { - CHECK_EQ(4, bottom[0]->num_axes()) << "Input must have 4 axes, " - << "corresponding to (num, channels, height, width)"; - channels_ = bottom[0]->channels(); - height_ = bottom[0]->height(); - width_ = bottom[0]->width(); - top[0]->Reshape( - bottom[0]->num(), channels_ * kernel_h_ * kernel_w_, - (height_ + 2 * pad_h_ - kernel_h_) / stride_h_ + 1, - (width_ + 2 * pad_w_ - kernel_w_) / stride_w_ + 1); + vector top_shape = bottom[0]->shape(); + const int* kernel_shape_data = kernel_shape_.cpu_data(); + const int* stride_data = stride_.cpu_data(); + const int* pad_data = pad_.cpu_data(); + for (int i = 0; i < num_spatial_axes_; ++i) { + top_shape[channel_axis_] *= kernel_shape_data[i]; + const int input_dim = bottom[0]->shape(channel_axis_ + i + 1); + const int output_dim = (input_dim + 2 * pad_data[i] - kernel_shape_data[i]) + / stride_data[i] + 1; + top_shape[channel_axis_ + i + 1] = output_dim; + } + top[0]->Reshape(top_shape); + num_ = bottom[0]->count(0, channel_axis_); + bottom_dim_ = bottom[0]->count(channel_axis_); + top_dim_ = top[0]->count(channel_axis_); + + channels_ = bottom[0]->shape(channel_axis_); } template @@ -66,10 +118,27 @@ void Im2colLayer::Forward_cpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->cpu_data(); Dtype* top_data = top[0]->mutable_cpu_data(); - for (int n = 0; n < bottom[0]->num(); ++n) { - im2col_cpu(bottom_data + bottom[0]->offset(n), channels_, height_, - width_, kernel_h_, kernel_w_, pad_h_, pad_w_, - stride_h_, stride_w_, top_data + top[0]->offset(n)); + for (int n = 0; n < num_; ++n) { + DCHECK_EQ(bottom[0]->shape().size() - channel_axis_, num_spatial_axes_ + 1); + DCHECK_EQ(top[0]->shape().size() - channel_axis_, num_spatial_axes_ + 1); + DCHECK_EQ(kernel_shape_.count(), num_spatial_axes_); + DCHECK_EQ(pad_.count(), num_spatial_axes_); + DCHECK_EQ(stride_.count(), num_spatial_axes_); + if (!force_nd_im2col_ && num_spatial_axes_ == 2) { + im2col_cpu(bottom_data + n * bottom_dim_, channels_, + bottom[0]->shape(channel_axis_ + 1), + bottom[0]->shape(channel_axis_ + 2), + kernel_shape_.cpu_data()[0], kernel_shape_.cpu_data()[1], + pad_.cpu_data()[0], pad_.cpu_data()[1], + stride_.cpu_data()[0], stride_.cpu_data()[1], + top_data + n * top_dim_); + } else { + im2col_nd_cpu(bottom_data + n * bottom_dim_, num_spatial_axes_, + bottom[0]->shape().data() + channel_axis_, + top[0]->shape().data() + channel_axis_, + kernel_shape_.cpu_data(), pad_.cpu_data(), stride_.cpu_data(), + top_data + n * top_dim_); + } } } @@ -78,10 +147,22 @@ void Im2colLayer::Backward_cpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { const Dtype* top_diff = top[0]->cpu_diff(); Dtype* bottom_diff = bottom[0]->mutable_cpu_diff(); - for (int n = 0; n < top[0]->num(); ++n) { - col2im_cpu(top_diff + top[0]->offset(n), channels_, height_, width_, - kernel_h_, kernel_w_, pad_h_, pad_w_, - stride_h_, stride_w_, bottom_diff + bottom[0]->offset(n)); + for (int n = 0; n < num_; ++n) { + if (!force_nd_im2col_ && num_spatial_axes_ == 2) { + col2im_cpu(top_diff + n * top_dim_, channels_, + bottom[0]->shape(channel_axis_ + 1), + bottom[0]->shape(channel_axis_ + 2), + kernel_shape_.cpu_data()[0], kernel_shape_.cpu_data()[1], + pad_.cpu_data()[0], pad_.cpu_data()[1], + stride_.cpu_data()[0], stride_.cpu_data()[1], + bottom_diff + n * bottom_dim_); + } else { + col2im_nd_cpu(top_diff + n * top_dim_, num_spatial_axes_, + bottom[0]->shape().data() + channel_axis_, + top[0]->shape().data() + channel_axis_, + kernel_shape_.cpu_data(), pad_.cpu_data(), stride_.cpu_data(), + bottom_diff + n * bottom_dim_); + } } } diff --git a/src/caffe/layers/im2col_layer.cu b/src/caffe/layers/im2col_layer.cu index 9c338b14cb7..cd507623c78 100644 --- a/src/caffe/layers/im2col_layer.cu +++ b/src/caffe/layers/im2col_layer.cu @@ -12,10 +12,23 @@ void Im2colLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - for (int n = 0; n < bottom[0]->num(); ++n) { - im2col_gpu(bottom_data + bottom[0]->offset(n), channels_, height_, - width_, kernel_h_, kernel_w_, pad_h_, pad_w_, - stride_h_, stride_w_, top_data + top[0]->offset(n)); + const int num_kernels = channels_ * top[0]->count(channel_axis_ + 1); + for (int n = 0; n < num_; ++n) { + if (!force_nd_im2col_ && num_spatial_axes_ == 2) { + im2col_gpu(bottom_data + n * bottom_dim_, channels_, + bottom[0]->shape(channel_axis_ + 1), + bottom[0]->shape(channel_axis_ + 2), + kernel_shape_.cpu_data()[0], kernel_shape_.cpu_data()[1], + pad_.cpu_data()[0], pad_.cpu_data()[1], + stride_.cpu_data()[0], stride_.cpu_data()[1], + top_data + n * top_dim_); + } else { + im2col_nd_gpu(bottom_data + n * bottom_dim_, num_spatial_axes_, + num_kernels, bottom[0]->gpu_shape() + channel_axis_, + top[0]->gpu_shape() + channel_axis_, + kernel_shape_.gpu_data(), pad_.gpu_data(), stride_.gpu_data(), + top_data + n * top_dim_); + } } } @@ -24,10 +37,22 @@ void Im2colLayer::Backward_gpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { const Dtype* top_diff = top[0]->gpu_diff(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - for (int n = 0; n < top[0]->num(); ++n) { - col2im_gpu(top_diff + top[0]->offset(n), channels_, height_, width_, - kernel_h_, kernel_w_, pad_h_, pad_w_, - stride_h_, stride_w_, bottom_diff + bottom[0]->offset(n)); + for (int n = 0; n < num_; ++n) { + if (!force_nd_im2col_ && num_spatial_axes_ == 2) { + col2im_gpu(top_diff + n * top_dim_, channels_, + bottom[0]->shape(channel_axis_ + 1), + bottom[0]->shape(channel_axis_ + 2), + kernel_shape_.cpu_data()[0], kernel_shape_.cpu_data()[1], + pad_.cpu_data()[0], pad_.cpu_data()[1], + stride_.cpu_data()[0], stride_.cpu_data()[1], + bottom_diff + n * bottom_dim_); + } else { + col2im_nd_gpu(top_diff + n * top_dim_, num_spatial_axes_, bottom_dim_, + bottom[0]->gpu_shape() + channel_axis_, + top[0]->gpu_shape() + channel_axis_, + kernel_shape_.gpu_data(), pad_.gpu_data(), stride_.gpu_data(), + bottom_diff + n * bottom_dim_); + } } } diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 86683eb45da..f52c941b05e 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -508,6 +508,13 @@ message ConvolutionParameter { // N independent 3D convolutions, sliding (C/g)-channels // filters across the spatial axes (D, H, W) of the input. optional int32 axis = 16 [default = 1]; + + // Whether to force use of the general ND convolution, even if a specific + // implementation for blobs of the appropriate number of spatial dimensions + // is available. (Currently, there is only a 2D-specific convolution + // implementation; for input blobs with num_axes != 2, this option is + // ignored and the ND implementation will be used.) + optional bool force_nd_im2col = 17 [default = false]; } message DataParameter { diff --git a/src/caffe/test/test_convolution_layer.cpp b/src/caffe/test/test_convolution_layer.cpp index 67d41fff844..9df979a2d27 100644 --- a/src/caffe/test/test_convolution_layer.cpp +++ b/src/caffe/test/test_convolution_layer.cpp @@ -19,54 +19,87 @@ template void caffe_conv(const Blob* in, ConvolutionParameter* conv_param, const vector > >& weights, Blob* out) { + const bool has_depth = (out->num_axes() == 5); + if (!has_depth) { CHECK_EQ(4, out->num_axes()); } // Kernel size, stride, and pad int kernel_h, kernel_w; - if (conv_param->has_kernel_size()) { - kernel_h = kernel_w = conv_param->kernel_size(); - } else { + if (conv_param->has_kernel_h() || conv_param->has_kernel_w()) { kernel_h = conv_param->kernel_h(); kernel_w = conv_param->kernel_w(); + } else { + kernel_h = kernel_w = conv_param->kernel_size(0); } int pad_h, pad_w; - if (!conv_param->has_pad_h()) { - pad_h = pad_w = conv_param->pad(); - } else { + if (conv_param->has_pad_h() || conv_param->has_pad_w()) { pad_h = conv_param->pad_h(); pad_w = conv_param->pad_w(); + } else { + pad_h = pad_w = conv_param->pad_size() ? conv_param->pad(0) : 0; } int stride_h, stride_w; - if (!conv_param->has_stride_h()) { - stride_h = stride_w = conv_param->stride(); - } else { + if (conv_param->has_stride_h() || conv_param->has_stride_w()) { stride_h = conv_param->stride_h(); stride_w = conv_param->stride_w(); + } else { + stride_h = stride_w = conv_param->stride_size() ? conv_param->stride(0) : 1; + } + int kernel_d, pad_d, stride_d; + if (has_depth) { + kernel_d = kernel_h; + stride_d = stride_h; + pad_d = pad_h; + } else { + kernel_d = stride_d = 1; + pad_d = 0; } // Groups int groups = conv_param->group(); - int o_g = out->channels() / groups; - int k_g = in->channels() / groups; + int o_g = out->shape(1) / groups; + int k_g = in->shape(1) / groups; int o_head, k_head; // Convolution - const Dtype* in_data = in->cpu_data(); - const Dtype* weight_data = weights[0]->cpu_data(); + vector weight_offset(4 + has_depth); + vector in_offset(4 + has_depth); + vector out_offset(4 + has_depth); Dtype* out_data = out->mutable_cpu_data(); - for (int n = 0; n < out->num(); n++) { + for (int n = 0; n < out->shape(0); n++) { for (int g = 0; g < groups; g++) { o_head = o_g * g; k_head = k_g * g; for (int o = 0; o < o_g; o++) { for (int k = 0; k < k_g; k++) { - for (int y = 0; y < out->height(); y++) { - for (int x = 0; x < out->width(); x++) { - for (int p = 0; p < kernel_h; p++) { - for (int q = 0; q < kernel_w; q++) { - int in_y = y * stride_h - pad_h + p; - int in_x = x * stride_w - pad_w + q; - if (in_y >= 0 && in_y < in->height() - && in_x >= 0 && in_x < in->width()) { - out_data[out->offset(n, o + o_head, y, x)] += - in_data[in->offset(n, k + k_head, in_y, in_x)] - * weight_data[weights[0]->offset(o + o_head, k, p, q)]; + for (int z = 0; z < (has_depth ? out->shape(2) : 1); z++) { + for (int y = 0; y < out->shape(2 + has_depth); y++) { + for (int x = 0; x < out->shape(3 + has_depth); x++) { + for (int r = 0; r < kernel_d; r++) { + for (int p = 0; p < kernel_h; p++) { + for (int q = 0; q < kernel_w; q++) { + int in_z = z * stride_d - pad_d + r; + int in_y = y * stride_h - pad_h + p; + int in_x = x * stride_w - pad_w + q; + if (in_z >= 0 && in_z < (has_depth ? in->shape(2) : 1) + && in_y >= 0 && in_y < in->shape(2 + has_depth) + && in_x >= 0 && in_x < in->shape(3 + has_depth)) { + weight_offset[0] = o + o_head; + weight_offset[1] = k; + if (has_depth) { weight_offset[2] = r; } + weight_offset[2 + has_depth] = p; + weight_offset[3 + has_depth] = q; + in_offset[0] = n; + in_offset[1] = k + k_head; + if (has_depth) { in_offset[2] = in_z; } + in_offset[2 + has_depth] = in_y; + in_offset[3 + has_depth] = in_x; + out_offset[0] = n; + out_offset[1] = o + o_head; + if (has_depth) { out_offset[2] = z; } + out_offset[2 + has_depth] = y; + out_offset[3 + has_depth] = x; + out_data[out->offset(out_offset)] += + in->data_at(in_offset) + * weights[0]->data_at(weight_offset); + } + } } } } @@ -79,11 +112,18 @@ void caffe_conv(const Blob* in, ConvolutionParameter* conv_param, // Bias if (conv_param->bias_term()) { const Dtype* bias_data = weights[1]->cpu_data(); - for (int n = 0; n < out->num(); n++) { - for (int o = 0; o < out->channels(); o++) { - for (int y = 0; y < out->height(); y++) { - for (int x = 0; x < out->width(); x++) { - out_data[out->offset(n, o, y, x)] += bias_data[o]; + for (int n = 0; n < out->shape(0); n++) { + for (int o = 0; o < out->shape(1); o++) { + for (int z = 0; z < (has_depth ? out->shape(2) : 1); z++) { + for (int y = 0; y < out->shape(2 + has_depth); y++) { + for (int x = 0; x < out->shape(3 + has_depth); x++) { + out_offset[0] = n; + out_offset[1] = o; + if (has_depth) { out_offset[2] = z; } + out_offset[2 + has_depth] = y; + out_offset[3 + has_depth] = x; + out_data[out->offset(out_offset)] += bias_data[o]; + } } } } @@ -150,8 +190,8 @@ TYPED_TEST(ConvolutionLayerTest, TestSetup) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(4); this->blob_bottom_vec_.push_back(this->blob_bottom_2_); this->blob_top_vec_.push_back(this->blob_top_2_); @@ -188,8 +228,8 @@ TYPED_TEST(ConvolutionLayerTest, TestSimpleConvolution) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(4); convolution_param->mutable_weight_filler()->set_type("gaussian"); convolution_param->mutable_bias_filler()->set_type("constant"); @@ -217,13 +257,98 @@ TYPED_TEST(ConvolutionLayerTest, TestSimpleConvolution) { } } +TYPED_TEST(ConvolutionLayerTest, Test0DConvolution) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + ConvolutionParameter* convolution_param = + layer_param.mutable_convolution_param(); + const int kNumOutput = 3; + convolution_param->set_num_output(kNumOutput); + convolution_param->set_axis(3); + convolution_param->mutable_weight_filler()->set_type("gaussian"); + convolution_param->mutable_bias_filler()->set_type("gaussian"); + shared_ptr > layer( + new ConvolutionLayer(layer_param)); + vector top_shape = this->blob_bottom_->shape(); + top_shape[3] = kNumOutput; + layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + EXPECT_EQ(top_shape, this->blob_top_->shape()); + layer->Forward(this->blob_bottom_vec_, this->blob_top_vec_); + // Check against reference convolution. + vector weight_offset(2); + const Blob* weight = layer->blobs()[0].get(); + const Blob* bias = layer->blobs()[1].get(); + const int num = this->blob_top_->count(3); + const int dim = this->blob_top_->shape(3); + const int bottom_dim = this->blob_bottom_->shape(3); + for (int n = 0; n < num; ++n) { + for (int d = 0; d < dim; ++d) { + weight_offset[0] = d; + Dtype value = bias->cpu_data()[d]; + for (int bottom_d = 0; bottom_d < bottom_dim; ++bottom_d) { + weight_offset[1] = bottom_d; + value += weight->data_at(weight_offset) * + this->blob_bottom_->cpu_data()[n * bottom_dim + bottom_d]; + } + EXPECT_NEAR(value, this->blob_top_->cpu_data()[n * dim + d], 1e-4); + } + } +} + +TYPED_TEST(ConvolutionLayerTest, TestSimple3DConvolution) { + typedef typename TypeParam::Dtype Dtype; + this->blob_bottom_vec_.push_back(this->blob_bottom_2_); + this->blob_top_vec_.push_back(this->blob_top_2_); + vector bottom_shape(5); + bottom_shape[0] = this->blob_bottom_vec_[0]->shape(0); + bottom_shape[1] = this->blob_bottom_vec_[0]->shape(1); + bottom_shape[2] = 5; + bottom_shape[3] = this->blob_bottom_vec_[0]->shape(2); + bottom_shape[4] = this->blob_bottom_vec_[0]->shape(3); + FillerParameter filler_param; + GaussianFiller filler(filler_param); + for (int i = 0; i < this->blob_bottom_vec_.size(); ++i) { + this->blob_bottom_vec_[i]->Reshape(bottom_shape); + filler.Fill(this->blob_bottom_vec_[i]); + } + LayerParameter layer_param; + ConvolutionParameter* convolution_param = + layer_param.mutable_convolution_param(); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); + convolution_param->set_num_output(4); + convolution_param->mutable_weight_filler()->set_type("gaussian"); + convolution_param->mutable_bias_filler()->set_type("gaussian"); + shared_ptr > layer( + new ConvolutionLayer(layer_param)); + layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer->Forward(this->blob_bottom_vec_, this->blob_top_vec_); + // Check against reference convolution. + const Dtype* top_data; + const Dtype* ref_top_data; + caffe_conv(this->blob_bottom_, convolution_param, layer->blobs(), + this->MakeReferenceTop(this->blob_top_)); + top_data = this->blob_top_->cpu_data(); + ref_top_data = this->ref_blob_top_->cpu_data(); + for (int i = 0; i < this->blob_top_->count(); ++i) { + EXPECT_NEAR(top_data[i], ref_top_data[i], 1e-4); + } + caffe_conv(this->blob_bottom_2_, convolution_param, layer->blobs(), + this->MakeReferenceTop(this->blob_top_2_)); + top_data = this->blob_top_2_->cpu_data(); + ref_top_data = this->ref_blob_top_->cpu_data(); + for (int i = 0; i < this->blob_top_->count(); ++i) { + EXPECT_NEAR(top_data[i], ref_top_data[i], 1e-4); + } +} + TYPED_TEST(ConvolutionLayerTest, Test1x1Convolution) { typedef typename TypeParam::Dtype Dtype; LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(1); - convolution_param->set_stride(1); + convolution_param->add_kernel_size(1); + convolution_param->add_stride(1); convolution_param->set_num_output(4); convolution_param->mutable_weight_filler()->set_type("gaussian"); convolution_param->mutable_bias_filler()->set_type("constant"); @@ -249,8 +374,8 @@ TYPED_TEST(ConvolutionLayerTest, TestSimpleConvolutionGroup) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(3); convolution_param->set_group(3); convolution_param->mutable_weight_filler()->set_type("gaussian"); @@ -288,8 +413,8 @@ TYPED_TEST(ConvolutionLayerTest, TestSobelConvolution) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(1); convolution_param->set_bias_term(false); shared_ptr > layer( @@ -350,14 +475,11 @@ TYPED_TEST(ConvolutionLayerTest, TestSobelConvolution) { convolution_param->set_bias_term(false); layer.reset(new ConvolutionLayer(layer_param)); layer->blobs().resize(1); - layer->blobs()[0].reset(new Blob(1, 3, 1, 3)); + layer->blobs()[0].reset(new Blob(1, 1, 1, 3)); Dtype* weights_2 = layer->blobs()[0]->mutable_cpu_data(); - for (int c = 0; c < 3; ++c) { - int i = c * 3; // 1 x 3 filter - weights_2[i + 0] = -1; - weights_2[i + 1] = 0; - weights_2[i + 2] = 1; - } + weights_2[0] = -1; + weights_2[1] = 0; + weights_2[2] = 1; layer->SetUp(sep_blob_bottom_vec, sep_blob_top_vec); layer->Forward(sep_blob_bottom_vec, sep_blob_top_vec); // Test equivalence of full and separable filters. @@ -368,6 +490,124 @@ TYPED_TEST(ConvolutionLayerTest, TestSobelConvolution) { } } +TYPED_TEST(ConvolutionLayerTest, TestNDAgainst2D) { + typedef typename TypeParam::Dtype Dtype; + const int kernel_h = 11; + const int kernel_w = 13; + vector bottom_shape(4); + bottom_shape[0] = 15; + bottom_shape[1] = 18; + bottom_shape[2] = kernel_h * 2; + bottom_shape[3] = kernel_w * 2; + FillerParameter filler_param; + GaussianFiller filler(filler_param); + for (int i = 0; i < this->blob_bottom_vec_.size(); ++i) { + this->blob_bottom_vec_[i]->Reshape(bottom_shape); + filler.Fill(this->blob_bottom_vec_[i]); + } + LayerParameter layer_param; + ConvolutionParameter* convolution_param = + layer_param.mutable_convolution_param(); + convolution_param->set_num_output(12); + convolution_param->set_bias_term(false); + convolution_param->set_group(6); + convolution_param->set_kernel_h(kernel_h); + convolution_param->set_kernel_w(kernel_w); + convolution_param->mutable_weight_filler()->set_type("gaussian"); + Blob weights; + Blob top_diff; + // Shape and fill weights and top_diff. + bool copy_diff; + bool reshape; + { + ConvolutionLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + top_diff.ReshapeLike(*this->blob_top_); + filler.Fill(&top_diff); + ASSERT_EQ(1, layer.blobs().size()); + copy_diff = false; reshape = true; + weights.CopyFrom(*layer.blobs()[0], copy_diff, reshape); + } + vector propagate_down(1, true); + Blob result_2d; + Blob backward_result_2d; + Blob backward_weight_result_2d; + // Test with 2D im2col + { + caffe_set(this->blob_top_->count(), Dtype(0), + this->blob_top_->mutable_cpu_data()); + caffe_set(this->blob_bottom_->count(), Dtype(0), + this->blob_bottom_->mutable_cpu_diff()); + caffe_set(weights.count(), Dtype(0), weights.mutable_cpu_diff()); + // Do SetUp and Forward; save Forward result in result_2d. + convolution_param->set_force_nd_im2col(false); + ConvolutionLayer layer_2d(layer_param); + layer_2d.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(1, layer_2d.blobs().size()); + copy_diff = false; reshape = false; + layer_2d.blobs()[0]->CopyFrom(weights, copy_diff, reshape); + layer_2d.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + copy_diff = false; reshape = true; + result_2d.CopyFrom(*this->blob_top_, copy_diff, reshape); + // Copy pre-generated top diff into actual top diff; + // do Backward and save result in backward_result_2d. + ASSERT_EQ(this->blob_top_->shape(), top_diff.shape()); + caffe_copy(top_diff.count(), top_diff.cpu_data(), + this->blob_top_->mutable_cpu_diff()); + layer_2d.Backward(this->blob_top_vec_, propagate_down, + this->blob_bottom_vec_); + copy_diff = true; reshape = true; + backward_result_2d.CopyFrom(*this->blob_bottom_, copy_diff, reshape); + backward_weight_result_2d.CopyFrom(weights, copy_diff, reshape); + } + Blob result_nd; + Blob backward_result_nd; + Blob backward_weight_result_nd; + // Test with ND im2col + { + caffe_set(this->blob_top_->count(), Dtype(0), + this->blob_top_->mutable_cpu_data()); + caffe_set(this->blob_bottom_->count(), Dtype(0), + this->blob_bottom_->mutable_cpu_diff()); + caffe_set(weights.count(), Dtype(0), weights.mutable_cpu_diff()); + // Do SetUp and Forward; save Forward result in result_nd. + convolution_param->set_force_nd_im2col(true); + ConvolutionLayer layer_nd(layer_param); + layer_nd.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(1, layer_nd.blobs().size()); + copy_diff = false; reshape = false; + layer_nd.blobs()[0]->CopyFrom(weights, copy_diff, reshape); + layer_nd.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + copy_diff = false; reshape = true; + result_nd.CopyFrom(*this->blob_top_, copy_diff, reshape); + // Copy pre-generated top diff into actual top diff; + // do Backward and save result in backward_result_nd. + ASSERT_EQ(this->blob_top_->shape(), top_diff.shape()); + caffe_copy(top_diff.count(), top_diff.cpu_data(), + this->blob_top_->mutable_cpu_diff()); + layer_nd.Backward(this->blob_top_vec_, propagate_down, + this->blob_bottom_vec_); + copy_diff = true; reshape = true; + backward_result_nd.CopyFrom(*this->blob_bottom_, copy_diff, reshape); + backward_weight_result_nd.CopyFrom(weights, copy_diff, reshape); + } + ASSERT_EQ(result_nd.count(), result_2d.count()); + for (int i = 0; i < result_2d.count(); ++i) { + EXPECT_EQ(result_2d.cpu_data()[i], result_nd.cpu_data()[i]); + } + ASSERT_EQ(backward_result_nd.count(), backward_result_2d.count()); + for (int i = 0; i < backward_result_2d.count(); ++i) { + EXPECT_EQ(backward_result_2d.cpu_diff()[i], + backward_result_nd.cpu_diff()[i]); + } + ASSERT_EQ(backward_weight_result_nd.count(), + backward_weight_result_2d.count()); + for (int i = 0; i < backward_weight_result_2d.count(); ++i) { + EXPECT_EQ(backward_weight_result_2d.cpu_diff()[i], + backward_weight_result_nd.cpu_diff()[i]); + } +} + TYPED_TEST(ConvolutionLayerTest, TestGradient) { typedef typename TypeParam::Dtype Dtype; LayerParameter layer_param; @@ -375,8 +615,36 @@ TYPED_TEST(ConvolutionLayerTest, TestGradient) { layer_param.mutable_convolution_param(); this->blob_bottom_vec_.push_back(this->blob_bottom_2_); this->blob_top_vec_.push_back(this->blob_top_2_); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); + convolution_param->set_num_output(2); + convolution_param->mutable_weight_filler()->set_type("gaussian"); + convolution_param->mutable_bias_filler()->set_type("gaussian"); + ConvolutionLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-3); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} + +TYPED_TEST(ConvolutionLayerTest, TestGradient3D) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + ConvolutionParameter* convolution_param = + layer_param.mutable_convolution_param(); + vector bottom_shape(5); + bottom_shape[0] = this->blob_bottom_vec_[0]->shape(0); + bottom_shape[1] = this->blob_bottom_vec_[0]->shape(1); + bottom_shape[2] = 5; + bottom_shape[3] = this->blob_bottom_vec_[0]->shape(2); + bottom_shape[4] = this->blob_bottom_vec_[0]->shape(3); + FillerParameter filler_param; + GaussianFiller filler(filler_param); + for (int i = 0; i < this->blob_bottom_vec_.size(); ++i) { + this->blob_bottom_vec_[i]->Reshape(bottom_shape); + filler.Fill(this->blob_bottom_vec_[i]); + } + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(2); convolution_param->mutable_weight_filler()->set_type("gaussian"); convolution_param->mutable_bias_filler()->set_type("gaussian"); @@ -393,8 +661,8 @@ TYPED_TEST(ConvolutionLayerTest, Test1x1Gradient) { layer_param.mutable_convolution_param(); this->blob_bottom_vec_.push_back(this->blob_bottom_2_); this->blob_top_vec_.push_back(this->blob_top_2_); - convolution_param->set_kernel_size(1); - convolution_param->set_stride(1); + convolution_param->add_kernel_size(1); + convolution_param->add_stride(1); convolution_param->set_num_output(2); convolution_param->mutable_weight_filler()->set_type("gaussian"); convolution_param->mutable_bias_filler()->set_type("gaussian"); @@ -409,8 +677,8 @@ TYPED_TEST(ConvolutionLayerTest, TestGradientGroup) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(3); convolution_param->set_group(3); convolution_param->mutable_weight_filler()->set_type("gaussian"); @@ -472,8 +740,8 @@ TYPED_TEST(CuDNNConvolutionLayerTest, TestSetupCuDNN) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(4); this->blob_bottom_vec_.push_back(this->blob_bottom_2_); this->blob_top_vec_.push_back(this->blob_top_2_); @@ -509,8 +777,8 @@ TYPED_TEST(CuDNNConvolutionLayerTest, TestSimpleConvolutionCuDNN) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(4); convolution_param->mutable_weight_filler()->set_type("gaussian"); convolution_param->mutable_bias_filler()->set_type("constant"); @@ -542,8 +810,8 @@ TYPED_TEST(CuDNNConvolutionLayerTest, TestSimpleConvolutionGroupCuDNN) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(3); convolution_param->set_group(3); convolution_param->mutable_weight_filler()->set_type("gaussian"); @@ -581,8 +849,8 @@ TYPED_TEST(CuDNNConvolutionLayerTest, TestSobelConvolutionCuDNN) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(1); convolution_param->set_bias_term(false); shared_ptr > layer( @@ -643,14 +911,11 @@ TYPED_TEST(CuDNNConvolutionLayerTest, TestSobelConvolutionCuDNN) { convolution_param->set_bias_term(false); layer.reset(new CuDNNConvolutionLayer(layer_param)); layer->blobs().resize(1); - layer->blobs()[0].reset(new Blob(1, 3, 1, 3)); + layer->blobs()[0].reset(new Blob(1, 1, 1, 3)); TypeParam* weights_2 = layer->blobs()[0]->mutable_cpu_data(); - for (int c = 0; c < 3; ++c) { - int i = c * 3; // 1 x 3 filter - weights_2[i + 0] = -1; - weights_2[i + 1] = 0; - weights_2[i + 2] = 1; - } + weights_2[0] = -1; + weights_2[1] = 0; + weights_2[2] = 1; layer->SetUp(sep_blob_bottom_vec, sep_blob_top_vec); layer->Forward(sep_blob_bottom_vec, sep_blob_top_vec); // Test equivalence of full and separable filters. @@ -667,8 +932,8 @@ TYPED_TEST(CuDNNConvolutionLayerTest, TestGradientCuDNN) { layer_param.mutable_convolution_param(); this->blob_bottom_vec_.push_back(this->blob_bottom_2_); this->blob_top_vec_.push_back(this->blob_top_2_); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(2); convolution_param->mutable_weight_filler()->set_type("gaussian"); convolution_param->mutable_bias_filler()->set_type("gaussian"); @@ -682,8 +947,8 @@ TYPED_TEST(CuDNNConvolutionLayerTest, TestGradientGroupCuDNN) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(3); convolution_param->set_group(3); convolution_param->mutable_weight_filler()->set_type("gaussian"); diff --git a/src/caffe/test/test_deconvolution_layer.cpp b/src/caffe/test/test_deconvolution_layer.cpp index fc63d5efbe3..770e7b277ee 100644 --- a/src/caffe/test/test_deconvolution_layer.cpp +++ b/src/caffe/test/test_deconvolution_layer.cpp @@ -58,8 +58,8 @@ TYPED_TEST(DeconvolutionLayerTest, TestSetup) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(4); this->blob_bottom_vec_.push_back(this->blob_bottom_2_); this->blob_top_vec_.push_back(this->blob_top_2_); @@ -96,8 +96,8 @@ TYPED_TEST(DeconvolutionLayerTest, TestSimpleDeconvolution) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); convolution_param->set_num_output(4); convolution_param->mutable_weight_filler()->set_type("constant"); convolution_param->mutable_weight_filler()->set_value(1); @@ -144,8 +144,8 @@ TYPED_TEST(DeconvolutionLayerTest, TestGradient) { layer_param.mutable_convolution_param(); this->blob_bottom_vec_.push_back(this->blob_bottom_2_); this->blob_top_vec_.push_back(this->blob_top_2_); - convolution_param->set_kernel_size(2); - convolution_param->set_stride(1); + convolution_param->add_kernel_size(2); + convolution_param->add_stride(1); convolution_param->set_num_output(1); convolution_param->mutable_weight_filler()->set_type("gaussian"); convolution_param->mutable_bias_filler()->set_type("gaussian"); @@ -155,4 +155,151 @@ TYPED_TEST(DeconvolutionLayerTest, TestGradient) { this->blob_top_vec_); } +TYPED_TEST(DeconvolutionLayerTest, TestNDAgainst2D) { + typedef typename TypeParam::Dtype Dtype; + const int kernel_h = 11; + const int kernel_w = 13; + vector bottom_shape(4); + bottom_shape[0] = 15; + bottom_shape[1] = 12; + bottom_shape[2] = kernel_h * 2; + bottom_shape[3] = kernel_w * 2; + FillerParameter filler_param; + GaussianFiller filler(filler_param); + for (int i = 0; i < this->blob_bottom_vec_.size(); ++i) { + this->blob_bottom_vec_[i]->Reshape(bottom_shape); + filler.Fill(this->blob_bottom_vec_[i]); + } + LayerParameter layer_param; + ConvolutionParameter* convolution_param = + layer_param.mutable_convolution_param(); + convolution_param->set_num_output(18); + convolution_param->set_bias_term(false); + convolution_param->set_group(6); + convolution_param->set_kernel_h(kernel_h); + convolution_param->set_kernel_w(kernel_w); + convolution_param->mutable_weight_filler()->set_type("gaussian"); + Blob weights; + Blob top_diff; + // Shape and fill weights and top_diff. + bool copy_diff; + bool reshape; + { + DeconvolutionLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + top_diff.ReshapeLike(*this->blob_top_); + filler.Fill(&top_diff); + ASSERT_EQ(1, layer.blobs().size()); + copy_diff = false; reshape = true; + weights.CopyFrom(*layer.blobs()[0], copy_diff, reshape); + } + vector propagate_down(1, true); + Blob result_2d; + Blob backward_result_2d; + Blob backward_weight_result_2d; + // Test with 2D im2col + { + caffe_set(this->blob_top_->count(), Dtype(0), + this->blob_top_->mutable_cpu_data()); + caffe_set(this->blob_bottom_->count(), Dtype(0), + this->blob_bottom_->mutable_cpu_diff()); + caffe_set(weights.count(), Dtype(0), weights.mutable_cpu_diff()); + // Do SetUp and Forward; save Forward result in result_2d. + convolution_param->set_force_nd_im2col(false); + DeconvolutionLayer layer_2d(layer_param); + layer_2d.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(1, layer_2d.blobs().size()); + copy_diff = false; reshape = false; + layer_2d.blobs()[0]->CopyFrom(weights, copy_diff, reshape); + layer_2d.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + copy_diff = false; reshape = true; + result_2d.CopyFrom(*this->blob_top_, copy_diff, reshape); + // Copy pre-generated top diff into actual top diff; + // do Backward and save result in backward_result_2d. + ASSERT_EQ(this->blob_top_->shape(), top_diff.shape()); + caffe_copy(top_diff.count(), top_diff.cpu_data(), + this->blob_top_->mutable_cpu_diff()); + layer_2d.Backward(this->blob_top_vec_, propagate_down, + this->blob_bottom_vec_); + copy_diff = true; reshape = true; + backward_result_2d.CopyFrom(*this->blob_bottom_, copy_diff, reshape); + backward_weight_result_2d.CopyFrom(weights, copy_diff, reshape); + } + Blob result_nd; + Blob backward_result_nd; + Blob backward_weight_result_nd; + // Test with ND im2col + { + caffe_set(this->blob_top_->count(), Dtype(0), + this->blob_top_->mutable_cpu_data()); + caffe_set(this->blob_bottom_->count(), Dtype(0), + this->blob_bottom_->mutable_cpu_diff()); + caffe_set(weights.count(), Dtype(0), weights.mutable_cpu_diff()); + // Do SetUp and Forward; save Forward result in result_nd. + convolution_param->set_force_nd_im2col(true); + DeconvolutionLayer layer_nd(layer_param); + layer_nd.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + ASSERT_EQ(1, layer_nd.blobs().size()); + copy_diff = false; reshape = false; + layer_nd.blobs()[0]->CopyFrom(weights, copy_diff, reshape); + layer_nd.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + copy_diff = false; reshape = true; + result_nd.CopyFrom(*this->blob_top_, copy_diff, reshape); + // Copy pre-generated top diff into actual top diff; + // do Backward and save result in backward_result_nd. + ASSERT_EQ(this->blob_top_->shape(), top_diff.shape()); + caffe_copy(top_diff.count(), top_diff.cpu_data(), + this->blob_top_->mutable_cpu_diff()); + layer_nd.Backward(this->blob_top_vec_, propagate_down, + this->blob_bottom_vec_); + copy_diff = true; reshape = true; + backward_result_nd.CopyFrom(*this->blob_bottom_, copy_diff, reshape); + backward_weight_result_nd.CopyFrom(weights, copy_diff, reshape); + } + ASSERT_EQ(result_nd.count(), result_2d.count()); + for (int i = 0; i < result_2d.count(); ++i) { + EXPECT_EQ(result_2d.cpu_data()[i], result_nd.cpu_data()[i]); + } + ASSERT_EQ(backward_result_nd.count(), backward_result_2d.count()); + for (int i = 0; i < backward_result_2d.count(); ++i) { + EXPECT_EQ(backward_result_2d.cpu_diff()[i], + backward_result_nd.cpu_diff()[i]); + } + ASSERT_EQ(backward_weight_result_nd.count(), + backward_weight_result_2d.count()); + for (int i = 0; i < backward_weight_result_2d.count(); ++i) { + EXPECT_EQ(backward_weight_result_2d.cpu_diff()[i], + backward_weight_result_nd.cpu_diff()[i]); + } +} + +TYPED_TEST(DeconvolutionLayerTest, TestGradient3D) { + typedef typename TypeParam::Dtype Dtype; + vector bottom_shape(5); + bottom_shape[0] = this->blob_bottom_vec_[0]->shape(0); + bottom_shape[1] = this->blob_bottom_vec_[0]->shape(1); + bottom_shape[2] = 2; + bottom_shape[3] = 3; + bottom_shape[4] = 2; + FillerParameter filler_param; + GaussianFiller filler(filler_param); + for (int i = 0; i < this->blob_bottom_vec_.size(); ++i) { + this->blob_bottom_vec_[i]->Reshape(bottom_shape); + filler.Fill(this->blob_bottom_vec_[i]); + } + LayerParameter layer_param; + ConvolutionParameter* convolution_param = + layer_param.mutable_convolution_param(); + convolution_param->add_kernel_size(2); + convolution_param->add_stride(2); + convolution_param->add_pad(1); + convolution_param->set_num_output(2); + convolution_param->mutable_weight_filler()->set_type("gaussian"); + convolution_param->mutable_bias_filler()->set_type("gaussian"); + DeconvolutionLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-3); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} + } // namespace caffe diff --git a/src/caffe/test/test_im2col_kernel.cu b/src/caffe/test/test_im2col_kernel.cu index 0017ac23e69..f0b75fcc68d 100644 --- a/src/caffe/test/test_im2col_kernel.cu +++ b/src/caffe/test/test_im2col_kernel.cu @@ -22,6 +22,12 @@ __global__ void im2col_gpu_kernel(const int n, const Dtype* data_im, const int height_col, const int width_col, Dtype* data_col); +template +__global__ void im2col_nd_gpu_kernel(const int n, const Dtype* data_im, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_col); + extern cudaDeviceProp CAFFE_TEST_CUDA_PROP; template @@ -30,11 +36,18 @@ class Im2colKernelTest : public GPUDeviceTest { Im2colKernelTest() // big so launches > 1024 threads : blob_bottom_(new Blob(5, 500, 10, 10)), + blob_kernel_shape_(new Blob()), + blob_stride_(new Blob()), + blob_pad_(new Blob()), blob_top_(new Blob()), blob_top_cpu_(new Blob()) { FillerParameter filler_param; GaussianFiller filler(filler_param); filler.Fill(this->blob_bottom_); + vector dim_blob_shape(1, 2); + blob_kernel_shape_->Reshape(dim_blob_shape); + blob_stride_->Reshape(dim_blob_shape); + blob_pad_->Reshape(dim_blob_shape); height_ = blob_bottom_->height(); width_ = blob_bottom_->width(); @@ -44,14 +57,26 @@ class Im2colKernelTest : public GPUDeviceTest { kernel_size_ = 3; height_col_ = (height_ + 2 * pad_ - kernel_size_) / stride_ + 1; width_col_ = (width_ + 2 * pad_ - kernel_size_) / stride_ + 1; + + for (int i = 0; i < 2; ++i) { + blob_kernel_shape_->mutable_cpu_data()[i] = kernel_size_; + blob_stride_->mutable_cpu_data()[i] = stride_; + blob_pad_->mutable_cpu_data()[i] = pad_; + } } virtual ~Im2colKernelTest() { - delete blob_bottom_; - delete blob_top_; - delete blob_top_cpu_; + delete blob_bottom_; + delete blob_top_; + delete blob_top_cpu_; + delete blob_kernel_shape_; + delete blob_stride_; + delete blob_pad_; } + Blob* const blob_kernel_shape_; + Blob* const blob_stride_; + Blob* const blob_pad_; Blob* const blob_bottom_; Blob* const blob_top_; Blob* const blob_top_cpu_; @@ -67,7 +92,7 @@ class Im2colKernelTest : public GPUDeviceTest { TYPED_TEST_CASE(Im2colKernelTest, TestDtypes); -TYPED_TEST(Im2colKernelTest, TestGPU) { +TYPED_TEST(Im2colKernelTest, Test2D) { // Reshape the blobs to correct size for im2col output this->blob_top_->Reshape(this->blob_bottom_->num(), this->channels_ * this->kernel_size_ * this->kernel_size_, @@ -122,4 +147,58 @@ TYPED_TEST(Im2colKernelTest, TestGPU) { } } +TYPED_TEST(Im2colKernelTest, TestND) { + // Reshape the blobs to correct size for im2col output + this->blob_top_->Reshape(this->blob_bottom_->num(), + this->channels_ * this->kernel_size_ * this->kernel_size_, + this->height_col_, + this->width_col_); + + this->blob_top_cpu_->ReshapeLike(*this->blob_top_); + + const TypeParam* bottom_data_cpu = this->blob_bottom_->cpu_data(); + TypeParam* top_data_cpu = this->blob_top_cpu_->mutable_cpu_data(); + + // CPU Version + for (int n = 0; n < this->blob_bottom_->num(); ++n) { + im2col_nd_cpu(bottom_data_cpu + this->blob_bottom_->offset(n), 2, + this->blob_bottom_->shape().data() + 1, + this->blob_top_cpu_->shape().data() + 1, + this->blob_kernel_shape_->cpu_data(), + this->blob_pad_->cpu_data(), this->blob_stride_->cpu_data(), + top_data_cpu + this->blob_top_cpu_->offset(n)); + } + + // GPU version + int num_kernels = this->channels_ * this->height_col_ * this->width_col_; + int default_grid_dim = CAFFE_GET_BLOCKS(num_kernels); + const TypeParam* bottom_data_gpu = this->blob_bottom_->gpu_data(); + + // Launch with different grid sizes + for (int grid_div = 2; grid_div <= 8; grid_div++) { + for (int n = 0; n < this->blob_bottom_->num(); ++n) { + const int grid_dim = default_grid_dim / grid_div; + TypeParam* top_data_gpu = this->blob_top_->mutable_gpu_data(); + // NOLINT_NEXT_LINE(whitespace/operators) + im2col_nd_gpu_kernel<<>>( + num_kernels, bottom_data_gpu + this->blob_bottom_->offset(n), + this->blob_bottom_->gpu_shape() + 1, this->blob_top_->gpu_shape() + 1, + this->blob_kernel_shape_->gpu_data(), this->blob_pad_->gpu_data(), + this->blob_stride_->gpu_data(), + top_data_gpu + this->blob_top_->offset(n)); + CUDA_POST_KERNEL_CHECK; + } + + // Compare results against CPU version + for (int i = 0; i < this->blob_top_->count(); ++i) { + TypeParam cpuval = top_data_cpu[i]; + TypeParam gpuval = this->blob_top_->cpu_data()[i]; + EXPECT_EQ(cpuval, gpuval); + if (cpuval != gpuval) { + break; + } + } + } +} + } // namespace caffe diff --git a/src/caffe/test/test_im2col_layer.cpp b/src/caffe/test/test_im2col_layer.cpp index f50abe103f8..293aa262059 100644 --- a/src/caffe/test/test_im2col_layer.cpp +++ b/src/caffe/test/test_im2col_layer.cpp @@ -21,6 +21,7 @@ class Im2colLayerTest : public MultiDeviceTest { : blob_bottom_(new Blob(2, 3, 6, 5)), blob_top_(new Blob()) { // fill the values + Caffe::set_random_seed(1701); FillerParameter filler_param; GaussianFiller filler(filler_param); filler.Fill(this->blob_bottom_); @@ -41,8 +42,8 @@ TYPED_TEST(Im2colLayerTest, TestSetup) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); Im2colLayer layer(layer_param); layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); EXPECT_EQ(this->blob_top_->num(), 2); @@ -56,8 +57,8 @@ TYPED_TEST(Im2colLayerTest, TestForward) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); Im2colLayer layer(layer_param); layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); @@ -73,14 +74,27 @@ TYPED_TEST(Im2colLayerTest, TestGradient) { LayerParameter layer_param; ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param(); - convolution_param->set_kernel_size(3); - convolution_param->set_stride(2); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); Im2colLayer layer(layer_param); GradientChecker checker(1e-2, 1e-2); checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, this->blob_top_vec_); } +TYPED_TEST(Im2colLayerTest, TestGradientForceND) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + ConvolutionParameter* convolution_param = + layer_param.mutable_convolution_param(); + convolution_param->add_kernel_size(3); + convolution_param->add_stride(2); + convolution_param->set_force_nd_im2col(true); + Im2colLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} TYPED_TEST(Im2colLayerTest, TestRect) { typedef typename TypeParam::Dtype Dtype; @@ -89,7 +103,7 @@ TYPED_TEST(Im2colLayerTest, TestRect) { layer_param.mutable_convolution_param(); convolution_param->set_kernel_h(5); convolution_param->set_kernel_w(3); - convolution_param->set_stride(2); + convolution_param->add_stride(2); Im2colLayer layer(layer_param); layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); @@ -108,7 +122,7 @@ TYPED_TEST(Im2colLayerTest, TestRectGradient) { layer_param.mutable_convolution_param(); convolution_param->set_kernel_h(5); convolution_param->set_kernel_w(3); - convolution_param->set_stride(2); + convolution_param->add_stride(2); Im2colLayer layer(layer_param); GradientChecker checker(1e-2, 1e-2); checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, diff --git a/src/caffe/util/im2col.cpp b/src/caffe/util/im2col.cpp index c48f31f35d4..b0a7be50e5c 100644 --- a/src/caffe/util/im2col.cpp +++ b/src/caffe/util/im2col.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include "caffe/util/im2col.hpp" #include "caffe/util/math_functions.hpp" @@ -44,6 +45,98 @@ template void im2col_cpu(const double* data_im, const int channels, const int pad_h, const int pad_w, const int stride_h, const int stride_w, double* data_col); +template +inline void im2col_nd_core_cpu(const Dtype* data_input, const bool im2col, + const int num_spatial_axes, const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_output) { + if (!im2col) { + int im_size = im_shape[0]; + for (int i = 0; i < num_spatial_axes; ++i) { + im_size *= im_shape[1 + i]; + } + caffe_set(im_size, Dtype(0), data_output); + } + int kernel_size = 1; + for (int i = 0; i < num_spatial_axes; ++i) { + kernel_size *= kernel_shape[i]; + } + const int channels_col = col_shape[0]; + vector d_offset(num_spatial_axes, 0); + vector d_iter(num_spatial_axes, 0); + for (int c = 0; c < channels_col; ++c) { + // Loop over spatial axes in reverse order to compute a per-axis offset. + int offset = c; + for (int d_i = num_spatial_axes - 1; d_i >= 0; --d_i) { + if (d_i < num_spatial_axes - 1) { + offset /= kernel_shape[d_i + 1]; + } + d_offset[d_i] = offset % kernel_shape[d_i]; + } + for (bool incremented = true; incremented; ) { + // Loop over spatial axes in forward order to compute the indices in the + // image and column, and whether the index lies in the padding. + int index_col = c; + int index_im = c / kernel_size; + bool is_padding = false; + for (int d_i = 0; d_i < num_spatial_axes; ++d_i) { + const int d = d_iter[d_i]; + const int d_pad = d * stride[d_i] - pad[d_i] + d_offset[d_i]; + is_padding |= d_pad < 0 || d_pad >= im_shape[d_i + 1]; + index_col *= col_shape[d_i + 1]; + index_col += d; + index_im *= im_shape[d_i + 1]; + index_im += d_pad; + } + if (im2col) { + if (is_padding) { + data_output[index_col] = 0; + } else { + data_output[index_col] = data_input[index_im]; + } + } else if (!is_padding) { // col2im + data_output[index_im] += data_input[index_col]; + } + // Loop over spatial axes in reverse order to choose an index, + // like counting. + incremented = false; + for (int d_i = num_spatial_axes - 1; d_i >= 0; --d_i) { + const int d_max = col_shape[d_i + 1]; + DCHECK_LT(d_iter[d_i], d_max); + if (d_iter[d_i] == d_max - 1) { + d_iter[d_i] = 0; + } else { // d_iter[d_i] < d_max - 1 + ++d_iter[d_i]; + incremented = true; + break; + } + } + } // while(incremented) { + } // for (int c = 0; c < channels_col; ++c) { +} + +template +void im2col_nd_cpu(const Dtype* data_im, const int num_spatial_axes, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_col) { + const bool kIm2Col = true; + im2col_nd_core_cpu(data_im, kIm2Col, num_spatial_axes, im_shape, col_shape, + kernel_shape, pad, stride, data_col); +} + +// Explicit instantiation +template void im2col_nd_cpu(const float* data_im, + const int num_spatial_axes, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + float* data_col); +template void im2col_nd_cpu(const double* data_im, + const int num_spatial_axes, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + double* data_col); + template void col2im_cpu(const Dtype* data_col, const int channels, const int height, const int width, const int patch_h, const int patch_w, @@ -80,4 +173,27 @@ template void col2im_cpu(const double* data_col, const int channels, const int pad_h, const int pad_w, const int stride_h, const int stride_w, double* data_im); +template +void col2im_nd_cpu(const Dtype* data_col, const int num_spatial_axes, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_im) { + const bool kIm2Col = false; + im2col_nd_core_cpu(data_col, kIm2Col, num_spatial_axes, im_shape, col_shape, + kernel_shape, pad, stride, data_im); +} + +// Explicit instantiation +template void col2im_nd_cpu(const float* data_col, + const int num_spatial_axes, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + float* data_im); +template void col2im_nd_cpu(const double* data_col, + const int num_spatial_axes, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + double* data_im); + + } // namespace caffe diff --git a/src/caffe/util/im2col.cu b/src/caffe/util/im2col.cu index c90f93eb67b..5a478ba62d2 100644 --- a/src/caffe/util/im2col.cu +++ b/src/caffe/util/im2col.cu @@ -59,7 +59,6 @@ void im2col_gpu(const Dtype* data_im, const int channels, CUDA_POST_KERNEL_CHECK; } - // Explicit instantiation template void im2col_gpu(const float* data_im, const int channels, const int height, const int width, const int kernel_h, const int kernel_w, @@ -70,6 +69,156 @@ template void im2col_gpu(const double* data_im, const int channels, const int pad_h, const int pad_w, const int stride_h, const int stride_w, double* data_col); +template +__global__ void im2col_nd_gpu_kernel(const int n, const Dtype* data_im, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_col) { + int d_temp[num_axes]; // NOLINT(runtime/arrays) + int d_iter[num_axes]; // NOLINT(runtime/arrays) + int i; + CUDA_KERNEL_LOOP(index, n) { + // Initialize channel_in, computed in the loop below, with intermediate + // computations used to compute the spatial indices. + int channel_in = index; + int channel_out = 1; + for (i = num_axes - 1; i >= 0; --i) { + d_temp[i] = channel_in % col_shape[i + 1]; + channel_in /= col_shape[i + 1]; + channel_out *= kernel_shape[i]; + } + channel_out *= channel_in; + int data_col_inc = 1; + for (i = 0; i < num_axes; ++i) { + channel_out *= col_shape[i + 1]; + channel_out += d_temp[i]; + d_temp[i] = d_temp[i] * stride[i] - pad[i]; + channel_in *= im_shape[i + 1]; + channel_in += d_temp[i]; + data_col_inc *= col_shape[i + 1]; + d_iter[i] = 0; + } + Dtype* data_col_ptr = data_col + channel_out; + const Dtype* data_im_ptr = data_im + channel_in; + bool incremented; + do { + bool in_range = true; + for (i = 0; i < num_axes; ++i) { + const int d_iter_im = d_iter[i] + d_temp[i]; + in_range &= d_iter_im >= 0 && d_iter_im < im_shape[i + 1]; + if (!in_range) { break; } + } + if (in_range) { + int data_im_offset = d_iter[0]; + for (i = 1; i < num_axes; ++i) { + data_im_offset *= im_shape[i + 1]; + data_im_offset += d_iter[i]; + } + *data_col_ptr = data_im_ptr[data_im_offset]; + } else { + *data_col_ptr = 0; + } + data_col_ptr += data_col_inc; + incremented = false; + for (i = num_axes - 1; i >= 0; --i) { + const int d_max = kernel_shape[i]; + if (d_iter[i] == d_max - 1) { + d_iter[i] = 0; + } else { // d_iter[i] < d_max - 1 + ++d_iter[i]; + incremented = true; + break; + } + } // for (int i = num_axes - 1; i >= 0; --i) + } while (incremented); // do + } // CUDA_KERNEL_LOOP(index, n) +} + +template +void im2col_nd_gpu(const Dtype* data_im, const int num_spatial_axes, + const int num_kernels, const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_col) { + switch (num_spatial_axes) { + case 1: + im2col_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + num_kernels, data_im, im_shape, col_shape, + kernel_shape, pad, stride, data_col); + break; + case 2: + im2col_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + num_kernels, data_im, im_shape, col_shape, + kernel_shape, pad, stride, data_col); + break; + case 3: + im2col_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + num_kernels, data_im, im_shape, col_shape, + kernel_shape, pad, stride, data_col); + break; + case 4: + im2col_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + num_kernels, data_im, im_shape, col_shape, + kernel_shape, pad, stride, data_col); + break; + case 5: + im2col_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + num_kernels, data_im, im_shape, col_shape, + kernel_shape, pad, stride, data_col); + break; + case 6: + im2col_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + num_kernels, data_im, im_shape, col_shape, + kernel_shape, pad, stride, data_col); + break; + case 7: + im2col_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + num_kernels, data_im, im_shape, col_shape, + kernel_shape, pad, stride, data_col); + break; + case 8: + im2col_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + num_kernels, data_im, im_shape, col_shape, + kernel_shape, pad, stride, data_col); + break; + case 9: + im2col_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + num_kernels, data_im, im_shape, col_shape, + kernel_shape, pad, stride, data_col); + break; + case 10: + im2col_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + num_kernels, data_im, im_shape, col_shape, + kernel_shape, pad, stride, data_col); + break; + default: + LOG(FATAL) << "im2col_nd_gpu does not support computation with " + << num_spatial_axes << " spatial axes"; + } + CUDA_POST_KERNEL_CHECK; +} + +// Explicit instantiation +template void im2col_nd_gpu(const float* data_im, + const int num_spatial_axes, const int col_size, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + float* data_col); +template void im2col_nd_gpu(const double* data_im, + const int num_spatial_axes, const int col_size, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + double* data_col); + template __global__ void col2im_gpu_kernel(const int n, const Dtype* data_col, const int height, const int width, const int channels, @@ -141,4 +290,159 @@ template void col2im_gpu(const double* data_col, const int channels, const int pad_h, const int pad_w, const int stride_h, const int stride_w, double* data_im); +template +__global__ void col2im_nd_gpu_kernel(const int n, const Dtype* data_col, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_im) { + int d_im[num_axes]; // NOLINT(runtime/arrays) + int d_col_iter[num_axes]; // NOLINT(runtime/arrays) + int d_col_start[num_axes]; // NOLINT(runtime/arrays) + int d_col_end[num_axes]; // NOLINT(runtime/arrays) + CUDA_KERNEL_LOOP(index, n) { + // Initialize channel_in, computed in the loop below, with intermediate + // computations used to compute the spatial indices. + int channel_im = index; + // Calculate d_im (image dimensions). + for (int i = num_axes - 1; i >= 0; --i) { + d_im[i] = channel_im % im_shape[i + 1] + pad[i]; + channel_im /= im_shape[i + 1]; + } + // Calculate col start/end indices. + bool done = false; + for (int i = 0; i < num_axes; ++i) { + d_col_start[i] = d_col_iter[i] = + (d_im[i] < kernel_shape[i]) ? + 0 : (d_im[i] - kernel_shape[i]) / stride[i] + 1; + d_col_end[i] = min(d_im[i] / stride[i] + 1, col_shape[i + 1]); + if (d_col_start[i] >= d_col_end[i]) { + // Skip computation if the dimension is 0 at any spatial axis -- + // final val will be 0. + data_im[index] = 0; + done = true; + break; // for (int i = 0; i < num_axes; ++i) + } + } + if (done) { + continue; // CUDA_KERNEL_LOOP(index, n) + } + // Loop over the col to compute the output val. + Dtype val = 0; + bool incremented = true; + do { + // Compute the final offset. + int final_offset = 0; + int kernel_shape_prod = 1; + for (int i = num_axes - 1; i >= 0; --i) { + final_offset += + (d_im[i] - d_col_iter[i] * stride[i]) * kernel_shape_prod; + kernel_shape_prod *= kernel_shape[i]; + } + final_offset += kernel_shape_prod * channel_im; + for (int i = 0; i < num_axes; ++i) { + final_offset *= col_shape[i + 1]; + final_offset += d_col_iter[i]; + } + val += data_col[final_offset]; + incremented = false; + for (int i = num_axes - 1; i >= 0; --i) { + const int d_max = d_col_end[i]; + if (d_col_iter[i] == d_max - 1) { + d_col_iter[i] = d_col_start[i]; + } else { // d_col_iter[i] < d_max - 1 + ++d_col_iter[i]; + incremented = true; + break; // for (int i = num_axes - 1; i >= 0; --i) + } + } // for (int i = num_axes - 1; i >= 0; --i) + } while (incremented); + data_im[index] = val; + } // CUDA_KERNEL_LOOP(index, n) +} + +template +void col2im_nd_gpu(const Dtype* data_col, const int num_spatial_axes, + const int im_size, const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + Dtype* data_im) { + switch (num_spatial_axes) { + case 1: + col2im_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + im_size, data_col, im_shape, col_shape, + kernel_shape, pad, stride, data_im); + break; + case 2: + col2im_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + im_size, data_col, im_shape, col_shape, + kernel_shape, pad, stride, data_im); + break; + case 3: + col2im_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + im_size, data_col, im_shape, col_shape, + kernel_shape, pad, stride, data_im); + break; + case 4: + col2im_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + im_size, data_col, im_shape, col_shape, + kernel_shape, pad, stride, data_im); + break; + case 5: + col2im_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + im_size, data_col, im_shape, col_shape, + kernel_shape, pad, stride, data_im); + break; + case 6: + col2im_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + im_size, data_col, im_shape, col_shape, + kernel_shape, pad, stride, data_im); + break; + case 7: + col2im_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + im_size, data_col, im_shape, col_shape, + kernel_shape, pad, stride, data_im); + break; + case 8: + col2im_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + im_size, data_col, im_shape, col_shape, + kernel_shape, pad, stride, data_im); + break; + case 9: + col2im_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + im_size, data_col, im_shape, col_shape, + kernel_shape, pad, stride, data_im); + break; + case 10: + col2im_nd_gpu_kernel // NOLINT_NEXT_LINE(whitespace/operators) + <<>>( + im_size, data_col, im_shape, col_shape, + kernel_shape, pad, stride, data_im); + break; + default: + LOG(FATAL) << "col2im_nd_gpu does not support computation with " + << num_spatial_axes << " spatial axes"; + } + CUDA_POST_KERNEL_CHECK; +} + +// Explicit instantiation +template void col2im_nd_gpu(const float* data_col, + const int num_spatial_axes, const int im_size, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + float* data_im); +template void col2im_nd_gpu(const double* data_col, + const int num_spatial_axes, const int im_size, + const int* im_shape, const int* col_shape, + const int* kernel_shape, const int* pad, const int* stride, + double* data_im); + } // namespace caffe diff --git a/src/caffe/util/upgrade_proto.cpp b/src/caffe/util/upgrade_proto.cpp index 92e5cf55fa9..ac379e50f4f 100644 --- a/src/caffe/util/upgrade_proto.cpp +++ b/src/caffe/util/upgrade_proto.cpp @@ -193,7 +193,7 @@ bool UpgradeV0LayerParameter(const V1LayerParameter& v0_layer_connection, } if (v0_layer_param.has_pad()) { if (type == "conv") { - layer_param->mutable_convolution_param()->set_pad(v0_layer_param.pad()); + layer_param->mutable_convolution_param()->add_pad(v0_layer_param.pad()); } else if (type == "pool") { layer_param->mutable_pooling_param()->set_pad(v0_layer_param.pad()); } else { @@ -203,7 +203,7 @@ bool UpgradeV0LayerParameter(const V1LayerParameter& v0_layer_connection, } if (v0_layer_param.has_kernelsize()) { if (type == "conv") { - layer_param->mutable_convolution_param()->set_kernel_size( + layer_param->mutable_convolution_param()->add_kernel_size( v0_layer_param.kernelsize()); } else if (type == "pool") { layer_param->mutable_pooling_param()->set_kernel_size( @@ -224,7 +224,7 @@ bool UpgradeV0LayerParameter(const V1LayerParameter& v0_layer_connection, } if (v0_layer_param.has_stride()) { if (type == "conv") { - layer_param->mutable_convolution_param()->set_stride( + layer_param->mutable_convolution_param()->add_stride( v0_layer_param.stride()); } else if (type == "pool") { layer_param->mutable_pooling_param()->set_stride( From da75a0e715f3d434c6b4c23d55947e114b332337 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Sat, 19 Sep 2015 20:38:18 -0700 Subject: [PATCH 208/331] [build] check xcode command line tools version >= 6 future-proof version check for BLAS libraries on OS X fix #3092 --- Makefile | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index a911133661f..5fb6394e947 100644 --- a/Makefile +++ b/Makefile @@ -354,8 +354,9 @@ else # OS X packages atlas as the vecLib framework LIBRARIES += cblas # 10.10 has accelerate while 10.9 has veclib - XCODE_CLT_VER := $(shell pkgutil --pkg-info=com.apple.pkg.CLTools_Executables | grep -o 'version: 6') - ifneq (,$(findstring version: 6,$(XCODE_CLT_VER))) + XCODE_CLT_VER := $(shell pkgutil --pkg-info=com.apple.pkg.CLTools_Executables | grep 'version' | sed 's/[^0-9]*\([0-9]\).*/\1/') + XCODE_CLT_GEQ_6 := $(shell [ $(XCODE_CLT_VER) -gt 5 ] && echo 1) + ifeq ($(XCODE_CLT_GEQ_6), 1) BLAS_INCLUDE ?= /System/Library/Frameworks/Accelerate.framework/Versions/Current/Frameworks/vecLib.framework/Headers/ LDFLAGS += -framework Accelerate else From a40c2a08421ebf9a164e198a70752f2d5cb1c93d Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Sun, 20 Sep 2015 14:20:28 -0700 Subject: [PATCH 209/331] fix broken DeconvolutionLayer GPU backward caused by typo --- src/caffe/layers/deconv_layer.cu | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/caffe/layers/deconv_layer.cu b/src/caffe/layers/deconv_layer.cu index ea83f56f1b2..5dbdcc3149f 100644 --- a/src/caffe/layers/deconv_layer.cu +++ b/src/caffe/layers/deconv_layer.cu @@ -51,7 +51,7 @@ void DeconvolutionLayer::Backward_gpu(const vector*>& top, } // gradient w.r.t. bottom data, if necessary. if (propagate_down[i]) { - this->forward_gpu_gemm(top_diff + this->top_dim_, weight, + this->forward_gpu_gemm(top_diff + n * this->top_dim_, weight, bottom_diff + n * this->bottom_dim_, this->param_propagate_down_[0]); } From 6a00ecae67a95cf39e1961aaddc3be1f5a828bb4 Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Sun, 20 Sep 2015 15:31:59 -0700 Subject: [PATCH 210/331] fix broken conv/deconv reshaping caused by reading bottom shape in LayerSetUp This also eliminates the extra copying of bottom's shape. --- include/caffe/vision_layers.hpp | 7 +++++-- src/caffe/layers/base_conv_layer.cpp | 10 ++-------- src/caffe/layers/conv_layer.cpp | 5 ++--- src/caffe/layers/deconv_layer.cpp | 5 ++--- 4 files changed, 11 insertions(+), 16 deletions(-) diff --git a/include/caffe/vision_layers.hpp b/include/caffe/vision_layers.hpp index eae65820c40..06bc0457e2d 100644 --- a/include/caffe/vision_layers.hpp +++ b/include/caffe/vision_layers.hpp @@ -58,6 +58,10 @@ class BaseConvolutionLayer : public Layer { void backward_gpu_bias(Dtype* bias, const Dtype* input); #endif + /// @brief The spatial dimensions of the input. + inline int input_shape(int i) { + return (*bottom_shape_)[channel_axis_ + i]; + } // reverse_dimensions should return true iff we are implementing deconv, so // that conv helpers know which dimensions are which. virtual bool reverse_dimensions() = 0; @@ -72,12 +76,11 @@ class BaseConvolutionLayer : public Layer { Blob pad_; /// @brief The spatial dimensions of the convolution input. Blob conv_input_shape_; - /// @brief The spatial dimensions of the input. - Blob input_shape_; /// @brief The spatial dimensions of the col_buffer. vector col_buffer_shape_; /// @brief The spatial dimensions of the output. vector output_shape_; + const vector* bottom_shape_; int num_spatial_axes_; int bottom_dim_; diff --git a/src/caffe/layers/base_conv_layer.cpp b/src/caffe/layers/base_conv_layer.cpp index a5b90a549bb..c6b47550292 100644 --- a/src/caffe/layers/base_conv_layer.cpp +++ b/src/caffe/layers/base_conv_layer.cpp @@ -20,13 +20,7 @@ void BaseConvolutionLayer::LayerSetUp(const vector*>& bottom, const int num_axes = bottom[0]->num_axes(); num_spatial_axes_ = num_axes - first_spatial_axis; CHECK_GE(num_spatial_axes_, 0); - // Setup input dimensions (input_shape_). vector bottom_dim_blob_shape(1, num_spatial_axes_ + 1); - input_shape_.Reshape(bottom_dim_blob_shape); - int* input_shape_data = input_shape_.mutable_cpu_data(); - for (int i = 0; i < num_spatial_axes_ + 1; ++i) { - input_shape_data[i] = bottom[0]->shape(channel_axis_ + i); - } vector spatial_dim_blob_shape(1, std::max(num_spatial_axes_, 1)); // Setup filter kernel dimensions (kernel_shape_). kernel_shape_.Reshape(spatial_dim_blob_shape); @@ -190,6 +184,7 @@ void BaseConvolutionLayer::Reshape(const vector*>& bottom, << "All inputs must have the same shape."; } // Shape the tops. + bottom_shape_ = &bottom[0]->shape(); compute_output_shape(); vector top_shape(bottom[0]->shape().begin(), bottom[0]->shape().begin() + channel_axis_); @@ -223,10 +218,9 @@ void BaseConvolutionLayer::Reshape(const vector*>& bottom, // it goes lazily unused to save memory. col_buffer_shape_.clear(); col_buffer_shape_.push_back(kernel_dim_ * group_); - const int* input_shape_data = input_shape_.cpu_data() + 1; for (int i = 0; i < num_spatial_axes_; ++i) { if (reverse_dimensions()) { - col_buffer_shape_.push_back(input_shape_data[i]); + col_buffer_shape_.push_back(input_shape(i + 1)); } else { col_buffer_shape_.push_back(output_shape_[i]); } diff --git a/src/caffe/layers/conv_layer.cpp b/src/caffe/layers/conv_layer.cpp index 5cf26970a0b..fb50bb095ed 100644 --- a/src/caffe/layers/conv_layer.cpp +++ b/src/caffe/layers/conv_layer.cpp @@ -10,14 +10,13 @@ namespace caffe { template void ConvolutionLayer::compute_output_shape() { - // input_shape_ + 1 to skip channel axis - const int* input_shape_data = this->input_shape_.cpu_data() + 1; const int* kernel_shape_data = this->kernel_shape_.cpu_data(); const int* stride_data = this->stride_.cpu_data(); const int* pad_data = this->pad_.cpu_data(); this->output_shape_.clear(); for (int i = 0; i < this->num_spatial_axes_; ++i) { - const int input_dim = input_shape_data[i]; + // i + 1 to skip channel axis + const int input_dim = this->input_shape(i + 1); const int output_dim = (input_dim + 2 * pad_data[i] - kernel_shape_data[i]) / stride_data[i] + 1; this->output_shape_.push_back(output_dim); diff --git a/src/caffe/layers/deconv_layer.cpp b/src/caffe/layers/deconv_layer.cpp index f1d1abf288a..91aabb315b2 100644 --- a/src/caffe/layers/deconv_layer.cpp +++ b/src/caffe/layers/deconv_layer.cpp @@ -10,14 +10,13 @@ namespace caffe { template void DeconvolutionLayer::compute_output_shape() { - // input_shape_ + 1 to skip channel axis - const int* input_shape_data = this->input_shape_.cpu_data() + 1; const int* kernel_shape_data = this->kernel_shape_.cpu_data(); const int* stride_data = this->stride_.cpu_data(); const int* pad_data = this->pad_.cpu_data(); this->output_shape_.clear(); for (int i = 0; i < this->num_spatial_axes_; ++i) { - const int input_dim = input_shape_data[i]; + // i + 1 to skip channel axis + const int input_dim = this->input_shape(i + 1); const int output_dim = stride_data[i] * (input_dim - 1) + kernel_shape_data[i] - 2 * pad_data[i]; this->output_shape_.push_back(output_dim); From 74e174537418b6a3c0c8708e444edf45ab491e94 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Wed, 23 Sep 2015 13:38:29 -0700 Subject: [PATCH 211/331] [test] TestReshape: check small then large checking large then small can mask failure since the smaller shape memory will fit within the larger shape. --- src/caffe/test/test_net.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/caffe/test/test_net.cpp b/src/caffe/test/test_net.cpp index 12998d8912f..ec01053c1f7 100644 --- a/src/caffe/test/test_net.cpp +++ b/src/caffe/test/test_net.cpp @@ -2269,8 +2269,10 @@ TYPED_TEST(NetTest, TestReshape) { FillerParameter filler_param; filler_param.set_std(1); GaussianFiller filler(filler_param); - Blob blob1(4, 3, 9, 11); - Blob blob2(2, 3, 12, 10); + // Check smaller shape first as larger first could hide realloc failures. + Blob blob1(2, 3, 12, 10); + Blob blob2(4, 3, 9, 11); + ASSERT_LT(blob1.count(), blob2.count()); filler.Fill(&blob1); filler.Fill(&blob2); From ae77b15495d4c2a83202c49991bfc0885765de03 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Wed, 23 Sep 2015 13:40:16 -0700 Subject: [PATCH 212/331] [test] TestReshape: expect instead of check --- src/caffe/test/test_net.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/caffe/test/test_net.cpp b/src/caffe/test/test_net.cpp index ec01053c1f7..16c1d35f3fc 100644 --- a/src/caffe/test/test_net.cpp +++ b/src/caffe/test/test_net.cpp @@ -2306,7 +2306,7 @@ TYPED_TEST(NetTest, TestReshape) { this->net_->ForwardPrefilled(); this->net_->Backward(); for (int i = 0; i < output1.count(); ++i) { - CHECK_EQ(*(output1.cpu_data() + i), *(output_blob->cpu_data() + i)); + EXPECT_FLOAT_EQ(*(output1.cpu_data() + i), *(output_blob->cpu_data() + i)); } input_blob->Reshape(blob2.num(), blob2.channels(), blob2.height(), @@ -2315,7 +2315,7 @@ TYPED_TEST(NetTest, TestReshape) { this->net_->ForwardPrefilled(); this->net_->Backward(); for (int i = 0; i < output2.count(); ++i) { - CHECK_EQ(*(output2.cpu_data() + i), *(output_blob->cpu_data() + i)); + EXPECT_FLOAT_EQ(*(output2.cpu_data() + i), *(output_blob->cpu_data() + i)); } } From b8c81bd2bfbc5bc2e394395bf2c1f435cb32b2a1 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Wed, 23 Sep 2015 13:40:24 -0700 Subject: [PATCH 213/331] [test] TestReshape: check that shapes actually change Check that output spatial shape varies with input shape while the output num matches the input num. --- src/caffe/test/test_net.cpp | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/caffe/test/test_net.cpp b/src/caffe/test/test_net.cpp index 16c1d35f3fc..ab4afba1a93 100644 --- a/src/caffe/test/test_net.cpp +++ b/src/caffe/test/test_net.cpp @@ -2262,8 +2262,8 @@ TEST_F(FilterNetTest, TestFilterInOutByExcludeMultiRule) { TYPED_TEST(NetTest, TestReshape) { typedef typename TypeParam::Dtype Dtype; // We set up bottom blobs of two different sizes, switch between - // them, and check that forward and backward both run and the results - // are the same. + // them, check that forward and backward both run and the results + // are the same, and check that the output shapes change. Caffe::set_random_seed(this->seed_); Caffe::set_mode(Caffe::CPU); FillerParameter filler_param; @@ -2317,6 +2317,18 @@ TYPED_TEST(NetTest, TestReshape) { for (int i = 0; i < output2.count(); ++i) { EXPECT_FLOAT_EQ(*(output2.cpu_data() + i), *(output_blob->cpu_data() + i)); } + + EXPECT_EQ(output1.num(), blob1.num()); + EXPECT_EQ(output2.num(), blob2.num()); + bool same_spatial_shape = true; + const int kFirstSpatialAxis = 2; + for (int i = kFirstSpatialAxis; i < output1.num_axes(); ++i) { + if (output1.shape(i) != output2.shape(i)) { + same_spatial_shape = false; + break; + } + } + EXPECT_FALSE(same_spatial_shape); } TYPED_TEST(NetTest, TestSkipPropagateDown) { From 84e390c5a16347c7369f6c92cb62526e42ce73ac Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 24 Sep 2015 12:35:35 -0700 Subject: [PATCH 214/331] Allow H5T_INTEGER in HDF5 files --- src/caffe/util/hdf5.cpp | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/src/caffe/util/hdf5.cpp b/src/caffe/util/hdf5.cpp index d0d05f70f8f..7730e76ab87 100644 --- a/src/caffe/util/hdf5.cpp +++ b/src/caffe/util/hdf5.cpp @@ -27,7 +27,34 @@ void hdf5_load_nd_dataset_helper( status = H5LTget_dataset_info( file_id, dataset_name_, dims.data(), &class_, NULL); CHECK_GE(status, 0) << "Failed to get dataset info for " << dataset_name_; - CHECK_EQ(class_, H5T_FLOAT) << "Expected float or double data"; + switch (class_) { + case H5T_FLOAT: + LOG_FIRST_N(INFO, 1) << "Datatype class: H5T_FLOAT"; + break; + case H5T_INTEGER: + LOG_FIRST_N(INFO, 1) << "Datatype class: H5T_INTEGER"; + break; + case H5T_TIME: + LOG(FATAL) << "Unsupported datatype class: H5T_TIME"; + case H5T_STRING: + LOG(FATAL) << "Unsupported datatype class: H5T_STRING"; + case H5T_BITFIELD: + LOG(FATAL) << "Unsupported datatype class: H5T_BITFIELD"; + case H5T_OPAQUE: + LOG(FATAL) << "Unsupported datatype class: H5T_OPAQUE"; + case H5T_COMPOUND: + LOG(FATAL) << "Unsupported datatype class: H5T_COMPOUND"; + case H5T_REFERENCE: + LOG(FATAL) << "Unsupported datatype class: H5T_REFERENCE"; + case H5T_ENUM: + LOG(FATAL) << "Unsupported datatype class: H5T_ENUM"; + case H5T_VLEN: + LOG(FATAL) << "Unsupported datatype class: H5T_VLEN"; + case H5T_ARRAY: + LOG(FATAL) << "Unsupported datatype class: H5T_ARRAY"; + default: + LOG(FATAL) << "Datatype class unknown"; + } vector blob_dims(dims.size()); for (int i = 0; i < dims.size(); ++i) { From ebc9963fea7b72f397c446a10a9aeab576979566 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Tue, 25 Aug 2015 18:58:45 -0700 Subject: [PATCH 215/331] Modify HDF5DataLayerTest to test H5T_INTEGER data --- .../test/test_data/generate_sample_data.py | 14 ++++++++------ .../test/test_data/sample_data_2_gzip.h5 | Bin 15446 -> 15446 bytes 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/caffe/test/test_data/generate_sample_data.py b/src/caffe/test/test_data/generate_sample_data.py index 3703b41823b..8349dbbc8e6 100644 --- a/src/caffe/test/test_data/generate_sample_data.py +++ b/src/caffe/test/test_data/generate_sample_data.py @@ -36,23 +36,25 @@ f['label'] = label f['label2'] = label2 -with h5py.File(script_dir + '/sample_data_2_gzip.h5', 'w') as f: +with h5py.File(script_dir + '/sample_data_uint8_gzip.h5', 'w') as f: f.create_dataset( 'data', data=data + total_size, compression='gzip', compression_opts=1 ) f.create_dataset( 'label', data=label, - compression='gzip', compression_opts=1 + compression='gzip', compression_opts=1, + dtype='uint8', ) f.create_dataset( 'label2', data=label2, - compression='gzip', compression_opts=1 + compression='gzip', compression_opts=1, + dtype='uint8', ) with open(script_dir + '/sample_data_list.txt', 'w') as f: - f.write(script_dir + '/sample_data.h5\n') - f.write(script_dir + '/sample_data_2_gzip.h5\n') + f.write('src/caffe/test/test_data/sample_data.h5\n') + f.write('src/caffe/test/test_data/sample_uint8_gzip.h5\n') # Generate GradientBasedSolver solver_data.h5 @@ -76,4 +78,4 @@ f['targets'] = targets with open(script_dir + '/solver_data_list.txt', 'w') as f: - f.write(script_dir + '/solver_data.h5\n') + f.write('src/caffe/test/test_data/solver_data.h5\n') diff --git a/src/caffe/test/test_data/sample_data_2_gzip.h5 b/src/caffe/test/test_data/sample_data_2_gzip.h5 index a138e0367be3d4b4ce4b51dcf0d7895056018883..0cb9ef92241d049b699b65f87e800f97337cae54 100644 GIT binary patch delta 225 zcmcasajjwl4+~4C%-zt<0xUly1qB!w85kG@fEYwGFmOy(l#7r6vxOKqz(ODnNCN|d z$Ha}klMPrT7=H51ueFFg#LWgGis1!kei3Wf$yr%6iSb&3kmDU2qQ`Q_!o GjsXC!dpCsu From 859f93891e4bf47d02899f03f0620fd1f29ca224 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 24 Sep 2015 13:33:11 -0700 Subject: [PATCH 216/331] Fix generate_sample_data.py - bug from #2978 --- src/caffe/test/test_data/generate_sample_data.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/caffe/test/test_data/generate_sample_data.py b/src/caffe/test/test_data/generate_sample_data.py index 8349dbbc8e6..2645073575f 100644 --- a/src/caffe/test/test_data/generate_sample_data.py +++ b/src/caffe/test/test_data/generate_sample_data.py @@ -36,7 +36,7 @@ f['label'] = label f['label2'] = label2 -with h5py.File(script_dir + '/sample_data_uint8_gzip.h5', 'w') as f: +with h5py.File(script_dir + '/sample_data_2_gzip.h5', 'w') as f: f.create_dataset( 'data', data=data + total_size, compression='gzip', compression_opts=1 @@ -54,7 +54,7 @@ with open(script_dir + '/sample_data_list.txt', 'w') as f: f.write('src/caffe/test/test_data/sample_data.h5\n') - f.write('src/caffe/test/test_data/sample_uint8_gzip.h5\n') + f.write('src/caffe/test/test_data/sample_data_2_gzip.h5\n') # Generate GradientBasedSolver solver_data.h5 From 200bd40391bc1c072730ea4bd80a6fe42b7a3901 Mon Sep 17 00:00:00 2001 From: Dmytro Mishkin Date: Fri, 25 Sep 2015 10:00:23 +0300 Subject: [PATCH 217/331] Fix parse_log.sh against "prefetch queue empty" messages --- tools/extra/parse_log.sh | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tools/extra/parse_log.sh b/tools/extra/parse_log.sh index 98ef0a05002..9892c897682 100755 --- a/tools/extra/parse_log.sh +++ b/tools/extra/parse_log.sh @@ -14,7 +14,12 @@ echo "Usage parse_log.sh /path/to/your.log" exit fi LOG=`basename $1` -grep -B 1 'Test ' $1 > aux.txt +sed -n '/Iteration .* Testing net/,/Iteration *. loss/p' $1 > aux.txt +sed -i '/Waiting for data/d' aux.txt +sed -i '/prefetch queue empty/d' aux.txt +sed -i '/Iteration .* loss/d' aux.txt +sed -i '/Iteration .* lr/d' aux.txt +sed -i '/Train net/d' aux.txt grep 'Iteration ' aux.txt | sed 's/.*Iteration \([[:digit:]]*\).*/\1/g' > aux0.txt grep 'Test net output #0' aux.txt | awk '{print $11}' > aux1.txt grep 'Test net output #1' aux.txt | awk '{print $11}' > aux2.txt From 6c02c8b7daf123f64b944ede407d0022e98d6e0b Mon Sep 17 00:00:00 2001 From: Tim Meinhardt Date: Tue, 15 Sep 2015 16:55:26 +0200 Subject: [PATCH 218/331] Add argmax_param axis --- include/caffe/common_layers.hpp | 2 ++ src/caffe/layers/argmax_layer.cpp | 22 +++++++++++++++++----- src/caffe/proto/caffe.proto | 5 +++++ 3 files changed, 24 insertions(+), 5 deletions(-) diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index 89bab8d6f3a..491f9edbf19 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -68,6 +68,8 @@ class ArgMaxLayer : public Layer { } bool out_max_val_; size_t top_k_; + bool has_axis_; + int axis_; }; /** diff --git a/src/caffe/layers/argmax_layer.cpp b/src/caffe/layers/argmax_layer.cpp index c4040cdcaaa..dad3d08bd66 100644 --- a/src/caffe/layers/argmax_layer.cpp +++ b/src/caffe/layers/argmax_layer.cpp @@ -11,11 +11,23 @@ namespace caffe { template void ArgMaxLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { - out_max_val_ = this->layer_param_.argmax_param().out_max_val(); - top_k_ = this->layer_param_.argmax_param().top_k(); - CHECK_GE(top_k_, 1) << " top k must not be less than 1."; - CHECK_LE(top_k_, bottom[0]->count() / bottom[0]->num()) - << "top_k must be less than or equal to the number of classes."; + const ArgMaxParameter& argmax_param = this->layer_param_.argmax_param(); + out_max_val_ = argmax_param.out_max_val(); + top_k_ = argmax_param.top_k(); + has_axis_ = argmax_param.has_axis(); + CHECK_GE(top_k_, 1) << "top k must not be less than 1."; + if (has_axis_) { + axis_ = bottom[0]->CanonicalAxisIndex(argmax_param.axis()); + CHECK_GE(axis_, 0) << "axis must not be less than 0."; + CHECK_LE(axis_, bottom[0]->num_axes()) << + "axis must be less than or equal to the number of axis."; + CHECK_LE(top_k_, bottom[0]->shape(axis_)) + << "top_k must be less than or equal to the dimension of the axis."; + } else { + CHECK_LE(top_k_, bottom[0]->count(1)) + << "top_k must be less than or equal to" + " the dimension of the flattened bottom blob per instance."; + } } template diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index f52c941b05e..a8747c12b37 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -443,6 +443,11 @@ message ArgMaxParameter { // If true produce pairs (argmax, maxval) optional bool out_max_val = 1 [default = false]; optional uint32 top_k = 2 [default = 1]; + // The axis along which to maximise -- may be negative to index from the + // end (e.g., -1 for the last axis). + // By default ArgMaxLayer maximizes over the flattened trailing dimensions + // for each index of the first / num dimension. + optional int32 axis = 3; } message ConcatParameter { From c77d5e5156f94720c1decd13f7f87fe78df9d4eb Mon Sep 17 00:00:00 2001 From: Tim Meinhardt Date: Tue, 15 Sep 2015 16:56:16 +0200 Subject: [PATCH 219/331] Implement ArgMaxLayer forward_cpu and reshape for axis param --- src/caffe/layers/argmax_layer.cpp | 53 ++++++++++++++++++++++--------- 1 file changed, 38 insertions(+), 15 deletions(-) diff --git a/src/caffe/layers/argmax_layer.cpp b/src/caffe/layers/argmax_layer.cpp index dad3d08bd66..18ff5f5a639 100644 --- a/src/caffe/layers/argmax_layer.cpp +++ b/src/caffe/layers/argmax_layer.cpp @@ -33,13 +33,19 @@ void ArgMaxLayer::LayerSetUp(const vector*>& bottom, template void ArgMaxLayer::Reshape(const vector*>& bottom, const vector*>& top) { - if (out_max_val_) { + std::vector shape(4, 1); + shape[0] = bottom[0]->shape(0); + // Produces max_ind + shape[2] = top_k_; + if (has_axis_) { + // Produces max_ind or max_val per axis + shape = bottom[0]->shape(); + shape[axis_] = top_k_; + } else if (out_max_val_) { // Produces max_ind and max_val - top[0]->Reshape(bottom[0]->num(), 2, top_k_, 1); - } else { - // Produces only max_ind - top[0]->Reshape(bottom[0]->num(), 1, top_k_, 1); + shape[1] = 2; } + top[0]->Reshape(shape); } template @@ -47,23 +53,40 @@ void ArgMaxLayer::Forward_cpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->cpu_data(); Dtype* top_data = top[0]->mutable_cpu_data(); - int num = bottom[0]->num(); - int dim = bottom[0]->count() / bottom[0]->num(); + int dim, axis_dist; + if (has_axis_) { + dim = bottom[0]->shape(axis_); + // Distance between values of axis in blob + axis_dist = bottom[0]->count(axis_) / dim; + } else { + dim = bottom[0]->count(1); + axis_dist = 1; + } + int num = bottom[0]->count() / dim; + std::vector > bottom_data_vector(dim); for (int i = 0; i < num; ++i) { - std::vector > bottom_data_vector; for (int j = 0; j < dim; ++j) { - bottom_data_vector.push_back( - std::make_pair(bottom_data[i * dim + j], j)); + bottom_data_vector[j] = std::make_pair( + bottom_data[(i / axis_dist * dim + j) * axis_dist + i % axis_dist], j); } std::partial_sort( bottom_data_vector.begin(), bottom_data_vector.begin() + top_k_, bottom_data_vector.end(), std::greater >()); for (int j = 0; j < top_k_; ++j) { - top_data[top[0]->offset(i, 0, j)] = bottom_data_vector[j].second; - } - if (out_max_val_) { - for (int j = 0; j < top_k_; ++j) { - top_data[top[0]->offset(i, 1, j)] = bottom_data_vector[j].first; + if (out_max_val_) { + if (has_axis_) { + // Produces max_val per axis + top_data[(i / axis_dist * top_k_ + j) * axis_dist + i % axis_dist] = + bottom_data_vector[j].first; + } else { + // Produces max_ind and max_val + top_data[top[0]->offset(i, 0, j)] = bottom_data_vector[j].second; + top_data[top[0]->offset(i, 1, j)] = bottom_data_vector[j].first; + } + } else { + // Produces max_ind per axis + top_data[(i / axis_dist * top_k_ + j) * axis_dist + i % axis_dist] = + bottom_data_vector[j].second; } } } From 9b2d267941411d9727a88ead18e3531bad50d14d Mon Sep 17 00:00:00 2001 From: Tim Meinhardt Date: Tue, 15 Sep 2015 16:56:45 +0200 Subject: [PATCH 220/331] Update ArgMaxLayer documentation for axis param --- include/caffe/common_layers.hpp | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index 491f9edbf19..d1ddaee4f19 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -21,7 +21,8 @@ namespace caffe { * * Intended for use after a classification layer to produce a prediction. * If parameter out_max_val is set to true, output is a vector of pairs - * (max_ind, max_val) for each image. + * (max_ind, max_val) for each image. The axis parameter specifies an axis + * along which to maximise. * * NOTE: does not implement Backwards operation. */ @@ -34,7 +35,11 @@ class ArgMaxLayer : public Layer { * - top_k (\b optional uint, default 1). * the number @f$ K @f$ of maximal items to output. * - out_max_val (\b optional bool, default false). - * if set, output a vector of pairs (max_ind, max_val) for each image. + * if set, output a vector of pairs (max_ind, max_val) unless axis is set then + * output max_val along the specified axis. + * - axis (\b optional int). + * if set, maximise along the specified axis else maximise the flattened + * trailing dimensions for each index of the first / num dimension. */ explicit ArgMaxLayer(const LayerParameter& param) : Layer(param) {} @@ -54,7 +59,8 @@ class ArgMaxLayer : public Layer { * the inputs @f$ x @f$ * @param top output Blob vector (length 1) * -# @f$ (N \times 1 \times K \times 1) @f$ or, if out_max_val - * @f$ (N \times 2 \times K \times 1) @f$ + * @f$ (N \times 2 \times K \times 1) @f$ unless axis set than e.g. + * @f$ (N \times K \times H \times W) @f$ if axis == 1 * the computed outputs @f$ * y_n = \arg\max\limits_i x_{ni} * @f$ (for @f$ K = 1 @f$). From a2a5e22d0b7d44a5e577edd53181d4802f057740 Mon Sep 17 00:00:00 2001 From: Tim Meinhardt Date: Tue, 15 Sep 2015 16:57:37 +0200 Subject: [PATCH 221/331] Generalise ArgMaxLayerTest bottom blob shape --- src/caffe/test/test_argmax_layer.cpp | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/caffe/test/test_argmax_layer.cpp b/src/caffe/test/test_argmax_layer.cpp index 895c3d372ff..d3018f90c9d 100644 --- a/src/caffe/test/test_argmax_layer.cpp +++ b/src/caffe/test/test_argmax_layer.cpp @@ -16,7 +16,7 @@ template class ArgMaxLayerTest : public CPUDeviceTest { protected: ArgMaxLayerTest() - : blob_bottom_(new Blob(10, 20, 1, 1)), + : blob_bottom_(new Blob(10, 10, 20, 20)), blob_top_(new Blob()), top_k_(5) { Caffe::set_random_seed(1701); @@ -112,6 +112,7 @@ TYPED_TEST(ArgMaxLayerTest, TestCPUTopK) { layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); // Now, check values + const TypeParam* bottom_data = this->blob_bottom_->cpu_data(); int max_ind; TypeParam max_val; int num = this->blob_bottom_->num(); @@ -121,10 +122,10 @@ TYPED_TEST(ArgMaxLayerTest, TestCPUTopK) { EXPECT_LE(this->blob_top_->data_at(i, 0, 0, 0), dim); for (int j = 0; j < this->top_k_; ++j) { max_ind = this->blob_top_->data_at(i, 0, j, 0); - max_val = this->blob_bottom_->data_at(i, max_ind, 0, 0); + max_val = bottom_data[i * dim + max_ind]; int count = 0; for (int k = 0; k < dim; ++k) { - if (this->blob_bottom_->data_at(i, k, 0, 0) > max_val) { + if (bottom_data[i * dim + k] > max_val) { ++count; } } @@ -142,6 +143,7 @@ TYPED_TEST(ArgMaxLayerTest, TestCPUMaxValTopK) { layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); // Now, check values + const TypeParam* bottom_data = this->blob_bottom_->cpu_data(); int max_ind; TypeParam max_val; int num = this->blob_bottom_->num(); @@ -152,10 +154,10 @@ TYPED_TEST(ArgMaxLayerTest, TestCPUMaxValTopK) { for (int j = 0; j < this->top_k_; ++j) { max_ind = this->blob_top_->data_at(i, 0, j, 0); max_val = this->blob_top_->data_at(i, 1, j, 0); - EXPECT_EQ(this->blob_bottom_->data_at(i, max_ind, 0, 0), max_val); + EXPECT_EQ(bottom_data[i * dim + max_ind], max_val); int count = 0; for (int k = 0; k < dim; ++k) { - if (this->blob_bottom_->data_at(i, k, 0, 0) > max_val) { + if (bottom_data[i * dim + k] > max_val) { ++count; } } From def3d3cc49b908e54f787be377c299e6e6cbf16c Mon Sep 17 00:00:00 2001 From: Tim Meinhardt Date: Tue, 15 Sep 2015 16:57:55 +0200 Subject: [PATCH 222/331] Implement ArgMaxLayerTest for axis param --- src/caffe/layers/argmax_layer.cpp | 28 +++--- src/caffe/test/test_argmax_layer.cpp | 125 +++++++++++++++++++++++++++ 2 files changed, 140 insertions(+), 13 deletions(-) diff --git a/src/caffe/layers/argmax_layer.cpp b/src/caffe/layers/argmax_layer.cpp index 18ff5f5a639..0c0a932dac7 100644 --- a/src/caffe/layers/argmax_layer.cpp +++ b/src/caffe/layers/argmax_layer.cpp @@ -33,17 +33,19 @@ void ArgMaxLayer::LayerSetUp(const vector*>& bottom, template void ArgMaxLayer::Reshape(const vector*>& bottom, const vector*>& top) { - std::vector shape(4, 1); - shape[0] = bottom[0]->shape(0); - // Produces max_ind - shape[2] = top_k_; + std::vector shape(bottom[0]->num_axes(), 1); if (has_axis_) { // Produces max_ind or max_val per axis shape = bottom[0]->shape(); shape[axis_] = top_k_; - } else if (out_max_val_) { - // Produces max_ind and max_val - shape[1] = 2; + } else { + shape[0] = bottom[0]->shape(0); + // Produces max_ind + shape[2] = top_k_; + if (out_max_val_) { + // Produces max_ind and max_val + shape[1] = 2; + } } top[0]->Reshape(shape); } @@ -76,17 +78,17 @@ void ArgMaxLayer::Forward_cpu(const vector*>& bottom, if (out_max_val_) { if (has_axis_) { // Produces max_val per axis - top_data[(i / axis_dist * top_k_ + j) * axis_dist + i % axis_dist] = - bottom_data_vector[j].first; + top_data[(i / axis_dist * top_k_ + j) * axis_dist + i % axis_dist] + = bottom_data_vector[j].first; } else { // Produces max_ind and max_val - top_data[top[0]->offset(i, 0, j)] = bottom_data_vector[j].second; - top_data[top[0]->offset(i, 1, j)] = bottom_data_vector[j].first; + top_data[2 * i * top_k_ + j] = bottom_data_vector[j].second; + top_data[2 * i * top_k_ + top_k_ + j] = bottom_data_vector[j].first; } } else { // Produces max_ind per axis - top_data[(i / axis_dist * top_k_ + j) * axis_dist + i % axis_dist] = - bottom_data_vector[j].second; + top_data[(i / axis_dist * top_k_ + j) * axis_dist + i % axis_dist] + = bottom_data_vector[j].second; } } } diff --git a/src/caffe/test/test_argmax_layer.cpp b/src/caffe/test/test_argmax_layer.cpp index d3018f90c9d..bbf19099905 100644 --- a/src/caffe/test/test_argmax_layer.cpp +++ b/src/caffe/test/test_argmax_layer.cpp @@ -55,6 +55,43 @@ TYPED_TEST(ArgMaxLayerTest, TestSetupMaxVal) { EXPECT_EQ(this->blob_top_->channels(), 2); } +TYPED_TEST(ArgMaxLayerTest, TestSetupAxis) { + LayerParameter layer_param; + ArgMaxParameter* argmax_param = layer_param.mutable_argmax_param(); + argmax_param->set_axis(0); + ArgMaxLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + EXPECT_EQ(this->blob_top_->shape(0), argmax_param->top_k()); + EXPECT_EQ(this->blob_top_->shape(1), this->blob_bottom_->shape(0)); + EXPECT_EQ(this->blob_top_->shape(2), this->blob_bottom_->shape(2)); + EXPECT_EQ(this->blob_top_->shape(3), this->blob_bottom_->shape(3)); +} + +TYPED_TEST(ArgMaxLayerTest, TestSetupAxisNegativeIndexing) { + LayerParameter layer_param; + ArgMaxParameter* argmax_param = layer_param.mutable_argmax_param(); + argmax_param->set_axis(-2); + ArgMaxLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + EXPECT_EQ(this->blob_top_->shape(0), this->blob_bottom_->shape(0)); + EXPECT_EQ(this->blob_top_->shape(1), this->blob_bottom_->shape(1)); + EXPECT_EQ(this->blob_top_->shape(2), argmax_param->top_k()); + EXPECT_EQ(this->blob_top_->shape(3), this->blob_bottom_->shape(3)); +} + +TYPED_TEST(ArgMaxLayerTest, TestSetupAxisMaxVal) { + LayerParameter layer_param; + ArgMaxParameter* argmax_param = layer_param.mutable_argmax_param(); + argmax_param->set_axis(2); + argmax_param->set_out_max_val(true); + ArgMaxLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + EXPECT_EQ(this->blob_top_->shape(0), this->blob_bottom_->shape(0)); + EXPECT_EQ(this->blob_top_->shape(1), this->blob_bottom_->shape(1)); + EXPECT_EQ(this->blob_top_->shape(2), argmax_param->top_k()); + EXPECT_EQ(this->blob_top_->shape(3), this->blob_bottom_->shape(3)); +} + TYPED_TEST(ArgMaxLayerTest, TestCPU) { LayerParameter layer_param; ArgMaxLayer layer(layer_param); @@ -166,5 +203,93 @@ TYPED_TEST(ArgMaxLayerTest, TestCPUMaxValTopK) { } } +TYPED_TEST(ArgMaxLayerTest, TestCPUAxis) { + LayerParameter layer_param; + ArgMaxParameter* argmax_param = layer_param.mutable_argmax_param(); + argmax_param->set_axis(0); + ArgMaxLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + // Now, check values + int max_ind; + TypeParam max_val; + std::vector shape = this->blob_bottom_->shape(); + for (int i = 0; i < shape[1]; ++i) { + for (int j = 0; j < shape[2]; ++j) { + for (int k = 0; k < shape[3]; ++k) { + max_ind = this->blob_top_->data_at(0, i, j, k); + max_val = this->blob_bottom_->data_at(max_ind, i, j, k); + EXPECT_GE(max_ind, 0); + EXPECT_LE(max_ind, shape[0]); + for (int l = 0; l < shape[0]; ++l) { + EXPECT_LE(this->blob_bottom_->data_at(l, i, j, k), max_val); + } + } + } + } +} + +TYPED_TEST(ArgMaxLayerTest, TestCPUAxisTopK) { + LayerParameter layer_param; + ArgMaxParameter* argmax_param = layer_param.mutable_argmax_param(); + argmax_param->set_axis(2); + argmax_param->set_top_k(this->top_k_); + ArgMaxLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + // Now, check values + int max_ind; + TypeParam max_val; + std::vector shape = this->blob_bottom_->shape(); + for (int i = 0; i < shape[0]; ++i) { + for (int j = 0; j < shape[1]; ++j) { + for (int k = 0; k < shape[3]; ++k) { + for (int m = 0; m < this->top_k_; ++m) { + max_ind = this->blob_top_->data_at(i, j, m, k); + max_val = this->blob_bottom_->data_at(i, j, max_ind, k); + EXPECT_GE(max_ind, 0); + EXPECT_LE(max_ind, shape[2]); + int count = 0; + for (int l = 0; l < shape[2]; ++l) { + if (this->blob_bottom_->data_at(i, j, l, k) > max_val) { + ++count; + } + } + EXPECT_EQ(m, count); + } + } + } + } +} + +TYPED_TEST(ArgMaxLayerTest, TestCPUAxisMaxValTopK) { + LayerParameter layer_param; + ArgMaxParameter* argmax_param = layer_param.mutable_argmax_param(); + argmax_param->set_axis(-1); + argmax_param->set_top_k(this->top_k_); + argmax_param->set_out_max_val(true); + ArgMaxLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + // Now, check values + TypeParam max_val; + std::vector shape = this->blob_bottom_->shape(); + for (int i = 0; i < shape[0]; ++i) { + for (int j = 0; j < shape[1]; ++j) { + for (int k = 0; k < shape[2]; ++k) { + for (int m = 0; m < this->top_k_; ++m) { + max_val = this->blob_top_->data_at(i, j, k, m); + int count = 0; + for (int l = 0; l < shape[3]; ++l) { + if (this->blob_bottom_->data_at(i, j, k, l) > max_val) { + ++count; + } + } + EXPECT_EQ(m, count); + } + } + } + } +} } // namespace caffe From bd5f15427cc2f008f80378a5948ce379d93ebde6 Mon Sep 17 00:00:00 2001 From: Ronghang Hu Date: Wed, 16 Sep 2015 13:39:23 -0700 Subject: [PATCH 223/331] Add flag on how host memory is allocated Add a bool flag to record whether a host memory is allocated using malloc or cudaMallocHost, and free correspondingly using this flag, instead of depending on Caffe::mode(), which is mutable during runtime. --- include/caffe/syncedmem.hpp | 15 ++++++++++----- src/caffe/syncedmem.cpp | 8 ++++---- 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/include/caffe/syncedmem.hpp b/include/caffe/syncedmem.hpp index 62aadef498d..3d92a0eaf3e 100644 --- a/include/caffe/syncedmem.hpp +++ b/include/caffe/syncedmem.hpp @@ -13,20 +13,22 @@ namespace caffe { // The improvement in performance seems negligible in the single GPU case, // but might be more significant for parallel training. Most importantly, // it improved stability for large models on many GPUs. -inline void CaffeMallocHost(void** ptr, size_t size) { +inline void CaffeMallocHost(void** ptr, size_t size, bool* use_cuda) { #ifndef CPU_ONLY if (Caffe::mode() == Caffe::GPU) { CUDA_CHECK(cudaMallocHost(ptr, size)); + *use_cuda = true; return; } #endif *ptr = malloc(size); + *use_cuda = false; CHECK(*ptr) << "host allocation of size " << size << " failed"; } -inline void CaffeFreeHost(void* ptr) { +inline void CaffeFreeHost(void* ptr, bool use_cuda) { #ifndef CPU_ONLY - if (Caffe::mode() == Caffe::GPU) { + if (use_cuda) { CUDA_CHECK(cudaFreeHost(ptr)); return; } @@ -45,10 +47,12 @@ class SyncedMemory { public: SyncedMemory() : cpu_ptr_(NULL), gpu_ptr_(NULL), size_(0), head_(UNINITIALIZED), - own_cpu_data_(false), own_gpu_data_(false), gpu_device_(-1) {} + own_cpu_data_(false), cpu_malloc_use_cuda_(false), own_gpu_data_(false), + gpu_device_(-1) {} explicit SyncedMemory(size_t size) : cpu_ptr_(NULL), gpu_ptr_(NULL), size_(size), head_(UNINITIALIZED), - own_cpu_data_(false), own_gpu_data_(false), gpu_device_(-1) {} + own_cpu_data_(false), cpu_malloc_use_cuda_(false), own_gpu_data_(false), + gpu_device_(-1) {} ~SyncedMemory(); const void* cpu_data(); void set_cpu_data(void* data); @@ -72,6 +76,7 @@ class SyncedMemory { size_t size_; SyncedHead head_; bool own_cpu_data_; + bool cpu_malloc_use_cuda_; bool own_gpu_data_; int gpu_device_; diff --git a/src/caffe/syncedmem.cpp b/src/caffe/syncedmem.cpp index a667a867af0..632bf1f12d3 100644 --- a/src/caffe/syncedmem.cpp +++ b/src/caffe/syncedmem.cpp @@ -8,7 +8,7 @@ namespace caffe { SyncedMemory::~SyncedMemory() { if (cpu_ptr_ && own_cpu_data_) { - CaffeFreeHost(cpu_ptr_); + CaffeFreeHost(cpu_ptr_, cpu_malloc_use_cuda_); } #ifndef CPU_ONLY @@ -27,7 +27,7 @@ SyncedMemory::~SyncedMemory() { inline void SyncedMemory::to_cpu() { switch (head_) { case UNINITIALIZED: - CaffeMallocHost(&cpu_ptr_, size_); + CaffeMallocHost(&cpu_ptr_, size_, &cpu_malloc_use_cuda_); caffe_memset(size_, 0, cpu_ptr_); head_ = HEAD_AT_CPU; own_cpu_data_ = true; @@ -35,7 +35,7 @@ inline void SyncedMemory::to_cpu() { case HEAD_AT_GPU: #ifndef CPU_ONLY if (cpu_ptr_ == NULL) { - CaffeMallocHost(&cpu_ptr_, size_); + CaffeMallocHost(&cpu_ptr_, size_, &cpu_malloc_use_cuda_); own_cpu_data_ = true; } caffe_gpu_memcpy(size_, gpu_ptr_, cpu_ptr_); @@ -86,7 +86,7 @@ const void* SyncedMemory::cpu_data() { void SyncedMemory::set_cpu_data(void* data) { CHECK(data); if (own_cpu_data_) { - CaffeFreeHost(cpu_ptr_); + CaffeFreeHost(cpu_ptr_, cpu_malloc_use_cuda_); } cpu_ptr_ = data; head_ = HEAD_AT_CPU; From 96ba513f54ac7bfc62c40a2481c1556c2f743120 Mon Sep 17 00:00:00 2001 From: Yang Song Date: Tue, 29 Sep 2015 20:07:52 +0800 Subject: [PATCH 224/331] Fix a typo Fix a typo in the message. --- python/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt index 0e2bc7e66a8..a22641401f0 100644 --- a/python/CMakeLists.txt +++ b/python/CMakeLists.txt @@ -1,5 +1,5 @@ if(NOT HAVE_PYTHON) - message(STATUS "Python interface is disabled or not all required dependecies found. Building without it...") + message(STATUS "Python interface is disabled or not all required dependencies found. Building without it...") return() endif() From 5cb40b4c732101165ae21a7474f896e8655b8bfa Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Wed, 30 Sep 2015 13:28:36 -0700 Subject: [PATCH 225/331] Add versioning for v0.14 * shared library * caffe binary (caffe --version) * python module (caffe.__version__) --- CMakeLists.txt | 5 +++++ Makefile | 32 +++++++++++++++++++++++--------- Makefile.config.example | 3 +++ cmake/Summary.cmake | 2 +- cmake/Targets.cmake | 6 +++++- python/caffe/__init__.py | 1 + python/caffe/_caffe.cpp | 7 +++++++ src/caffe/CMakeLists.txt | 1 + tools/caffe.cpp | 7 +++++++ 9 files changed, 53 insertions(+), 11 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 37f937fe489..606842b2455 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,6 +3,11 @@ cmake_minimum_required(VERSION 2.8.7) # ---[ Caffe project project(Caffe C CXX) +# ---[ Caffe version +set(CAFFE_TARGET_VERSION "0.14.0-alpha") +set(CAFFE_TARGET_SOVERSION "0.14") +add_definitions(-DCAFFE_VERSION=${CAFFE_TARGET_VERSION}) + # ---[ Using cmake scripts and modules list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules) diff --git a/Makefile b/Makefile index 5fb6394e947..9d72bff7828 100644 --- a/Makefile +++ b/Makefile @@ -29,9 +29,17 @@ SRC_DIRS := $(shell find * -type d -exec bash -c "find {} -maxdepth 1 \ \( -name '*.cpp' -o -name '*.proto' \) | grep -q ." \; -print) # The target shared library name +LIBRARY_NAME := $(PROJECT)$(LIBRARY_NAME_SUFFIX) LIB_BUILD_DIR := $(BUILD_DIR)/lib -STATIC_NAME := $(LIB_BUILD_DIR)/lib$(PROJECT).a -DYNAMIC_NAME := $(LIB_BUILD_DIR)/lib$(PROJECT).so +STATIC_NAME := $(LIB_BUILD_DIR)/lib$(LIBRARY_NAME).a +DYNAMIC_VERSION_MAJOR := 0 +DYNAMIC_VERSION_MINOR := 14 +DYNAMIC_VERSION_REVISION := 0-alpha +DYNAMIC_NAME_SHORT := lib$(LIBRARY_NAME).so +DYNAMIC_SONAME_SHORT := $(DYNAMIC_NAME_SHORT).$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR) +DYNAMIC_VERSIONED_NAME_SHORT := $(DYNAMIC_SONAME_SHORT).$(DYNAMIC_VERSION_REVISION) +DYNAMIC_NAME := $(LIB_BUILD_DIR)/$(DYNAMIC_VERSIONED_NAME_SHORT) +COMMON_FLAGS += -DCAFFE_VERSION=$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR).$(DYNAMIC_VERSION_REVISION) ############################## # Get all source files @@ -248,6 +256,7 @@ ifeq ($(LINUX), 1) # boost::thread is reasonably called boost_thread (compare OS X) # We will also explicitly add stdc++ to the link target. LIBRARIES += boost_thread stdc++ + VERSIONFLAGS += -Wl,-soname,$(DYNAMIC_SONAME_SHORT) -Wl,-rpath,$(ORIGIN)/../lib endif # OS X: @@ -271,6 +280,7 @@ ifeq ($(OSX), 1) # we need to explicitly ask for the rpath to be obeyed DYNAMIC_FLAGS := -install_name @rpath/libcaffe.so ORIGIN := @loader_path + VERSIONFLAGS += -Wl,-install_name,$(DYNAMIC_SONAME_SHORT) -Wl,-rpath,$(ORIGIN)/../../build/lib else ORIGIN := \$$ORIGIN endif @@ -470,7 +480,7 @@ py: $(PY$(PROJECT)_SO) $(PROTO_GEN_PY) $(PY$(PROJECT)_SO): $(PY$(PROJECT)_SRC) $(PY$(PROJECT)_HXX) | $(DYNAMIC_NAME) @ echo CXX/LD -o $@ $< $(Q)$(CXX) -shared -o $@ $(PY$(PROJECT)_SRC) \ - -o $@ $(LINKFLAGS) -l$(PROJECT) $(PYTHON_LDFLAGS) \ + -o $@ $(LINKFLAGS) -l$(LIBRARY_NAME) $(PYTHON_LDFLAGS) \ -Wl,-rpath,$(ORIGIN)/../../build/lib mat$(PROJECT): mat @@ -534,7 +544,9 @@ $(ALL_BUILD_DIRS): | $(BUILD_DIR_LINK) $(DYNAMIC_NAME): $(OBJS) | $(LIB_BUILD_DIR) @ echo LD -o $@ - $(Q)$(CXX) -shared -o $@ $(OBJS) $(LINKFLAGS) $(LDFLAGS) $(DYNAMIC_FLAGS) + $(Q)$(CXX) -shared -o $@ $(OBJS) $(VERSIONFLAGS) $(LINKFLAGS) $(LDFLAGS) $(DYNAMIC_FLAGS) + @ cd $(BUILD_DIR)/lib; rm -f $(DYNAMIC_SONAME_SHORT); ln -s $(DYNAMIC_VERSIONED_NAME_SHORT) $(DYNAMIC_SONAME_SHORT) + @ cd $(BUILD_DIR)/lib; rm -f $(DYNAMIC_NAME_SHORT); ln -s $(DYNAMIC_SONAME_SHORT) $(DYNAMIC_NAME_SHORT) $(STATIC_NAME): $(OBJS) | $(LIB_BUILD_DIR) @ echo AR -o $@ @@ -565,19 +577,19 @@ $(TEST_ALL_BIN): $(TEST_MAIN_SRC) $(TEST_OBJS) $(GTEST_OBJ) \ | $(DYNAMIC_NAME) $(TEST_BIN_DIR) @ echo CXX/LD -o $@ $< $(Q)$(CXX) $(TEST_MAIN_SRC) $(TEST_OBJS) $(GTEST_OBJ) \ - -o $@ $(LINKFLAGS) $(LDFLAGS) -l$(PROJECT) -Wl,-rpath,$(ORIGIN)/../lib + -o $@ $(LINKFLAGS) $(LDFLAGS) -l$(LIBRARY_NAME) -Wl,-rpath,$(ORIGIN)/../lib $(TEST_CU_BINS): $(TEST_BIN_DIR)/%.testbin: $(TEST_CU_BUILD_DIR)/%.o \ $(GTEST_OBJ) | $(DYNAMIC_NAME) $(TEST_BIN_DIR) @ echo LD $< $(Q)$(CXX) $(TEST_MAIN_SRC) $< $(GTEST_OBJ) \ - -o $@ $(LINKFLAGS) $(LDFLAGS) -l$(PROJECT) -Wl,-rpath,$(ORIGIN)/../lib + -o $@ $(LINKFLAGS) $(LDFLAGS) -l$(LIBRARY_NAME) -Wl,-rpath,$(ORIGIN)/../lib $(TEST_CXX_BINS): $(TEST_BIN_DIR)/%.testbin: $(TEST_CXX_BUILD_DIR)/%.o \ $(GTEST_OBJ) | $(DYNAMIC_NAME) $(TEST_BIN_DIR) @ echo LD $< $(Q)$(CXX) $(TEST_MAIN_SRC) $< $(GTEST_OBJ) \ - -o $@ $(LINKFLAGS) $(LDFLAGS) -l$(PROJECT) -Wl,-rpath,$(ORIGIN)/../lib + -o $@ $(LINKFLAGS) $(LDFLAGS) -l$(LIBRARY_NAME) -Wl,-rpath,$(ORIGIN)/../lib # Target for extension-less symlinks to tool binaries with extension '*.bin'. $(TOOL_BUILD_DIR)/%: $(TOOL_BUILD_DIR)/%.bin | $(TOOL_BUILD_DIR) @@ -586,12 +598,12 @@ $(TOOL_BUILD_DIR)/%: $(TOOL_BUILD_DIR)/%.bin | $(TOOL_BUILD_DIR) $(TOOL_BINS): %.bin : %.o | $(DYNAMIC_NAME) @ echo CXX/LD -o $@ - $(Q)$(CXX) $< -o $@ $(LINKFLAGS) -l$(PROJECT) $(LDFLAGS) \ + $(Q)$(CXX) $< -o $@ $(LINKFLAGS) -l$(LIBRARY_NAME) $(LDFLAGS) \ -Wl,-rpath,$(ORIGIN)/../lib $(EXAMPLE_BINS): %.bin : %.o | $(DYNAMIC_NAME) @ echo CXX/LD -o $@ - $(Q)$(CXX) $< -o $@ $(LINKFLAGS) -l$(PROJECT) $(LDFLAGS) \ + $(Q)$(CXX) $< -o $@ $(LINKFLAGS) -l$(LIBRARY_NAME) $(LDFLAGS) \ -Wl,-rpath,$(ORIGIN)/../../lib proto: $(PROTO_GEN_CC) $(PROTO_GEN_HEADER) @@ -653,6 +665,8 @@ $(DISTRIBUTE_DIR): all py | $(DISTRIBUTE_SUBDIRS) # add libraries cp $(STATIC_NAME) $(DISTRIBUTE_DIR)/lib cp $(DYNAMIC_NAME) $(DISTRIBUTE_DIR)/lib + cd $(DISTRIBUTE_DIR)/lib; rm -f $(DYNAMIC_SONAME_SHORT); ln -s $(DYNAMIC_VERSIONED_NAME_SHORT) $(DYNAMIC_SONAME_SHORT) + cd $(DISTRIBUTE_DIR)/lib; rm -f $(DYNAMIC_NAME_SHORT); ln -s $(DYNAMIC_SONAME_SHORT) $(DYNAMIC_NAME_SHORT) # add python - it's not the standard way, indeed... cp -r python $(DISTRIBUTE_DIR)/python diff --git a/Makefile.config.example b/Makefile.config.example index a20bad2f5ce..29f7e35e7ae 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -96,3 +96,6 @@ TEST_GPUID := 0 # enable pretty build (comment to see full commands) Q ?= @ + +# shared object suffix name to differentiate branches +LIBRARY_NAME_SUFFIX := -nv diff --git a/cmake/Summary.cmake b/cmake/Summary.cmake index 3d12e81a130..966f5ef40e8 100644 --- a/cmake/Summary.cmake +++ b/cmake/Summary.cmake @@ -101,7 +101,7 @@ function(caffe_print_configuration_summary) caffe_status("") caffe_status("******************* Caffe Configuration Summary *******************") caffe_status("General:") - caffe_status(" Version : ${Caffe_VERSION}") + caffe_status(" Version : ${CAFFE_TARGET_VERSION}") caffe_status(" Git : ${Caffe_GIT_VERSION}") caffe_status(" System : ${CMAKE_SYSTEM_NAME}") caffe_status(" C++ compiler : ${CMAKE_CXX_COMPILER}") diff --git a/cmake/Targets.cmake b/cmake/Targets.cmake index 2401f252e93..8e649291020 100644 --- a/cmake/Targets.cmake +++ b/cmake/Targets.cmake @@ -109,7 +109,11 @@ function(caffe_default_properties target) DEBUG_POSTFIX ${Caffe_DEBUG_POSTFIX} ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib" LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib" - RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin") + RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin" + VERSION ${CAFFE_TARGET_VERSION} + SOVERSION ${CAFFE_TARGET_SOVERSION} + ) + # make sure we build all external depepdencies first if (DEFINED external_project_dependencies) add_dependencies(${target} ${external_project_dependencies}) diff --git a/python/caffe/__init__.py b/python/caffe/__init__.py index ccda1bcae4f..b2a9d27f764 100644 --- a/python/caffe/__init__.py +++ b/python/caffe/__init__.py @@ -1,5 +1,6 @@ from .pycaffe import Net, SGDSolver, NesterovSolver, AdaGradSolver, RMSPropSolver, AdaDeltaSolver, AdamSolver from ._caffe import set_mode_cpu, set_mode_gpu, set_device, Layer, get_solver, layer_type_list +from ._caffe import CAFFE_VERSION as __version__ from .proto.caffe_pb2 import TRAIN, TEST from .classifier import Classifier from .detector import Detector diff --git a/python/caffe/_caffe.cpp b/python/caffe/_caffe.cpp index ccd5776ac40..d932e2f9f93 100644 --- a/python/caffe/_caffe.cpp +++ b/python/caffe/_caffe.cpp @@ -24,6 +24,10 @@ #define PyArray_SetBaseObject(arr, x) (PyArray_BASE(arr) = (x)) #endif +// Hack to convert macro to string +#define STRINGIZE(m) #m +#define STRINGIZE2(m) STRINGIZE(m) + namespace bp = boost::python; namespace caffe { @@ -210,6 +214,9 @@ BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(SolveOverloads, Solve, 0, 1); BOOST_PYTHON_MODULE(_caffe) { // below, we prepend an underscore to methods that will be replaced // in Python + + bp::scope().attr("CAFFE_VERSION") = STRINGIZE2(CAFFE_VERSION); + // Caffe utility functions bp::def("set_mode_cpu", &set_mode_cpu); bp::def("set_mode_gpu", &set_mode_gpu); diff --git a/src/caffe/CMakeLists.txt b/src/caffe/CMakeLists.txt index 40e6c11f5b0..73ecd4496b1 100644 --- a/src/caffe/CMakeLists.txt +++ b/src/caffe/CMakeLists.txt @@ -20,6 +20,7 @@ endif() add_library(caffe ${srcs}) target_link_libraries(caffe proto ${Caffe_LINKER_LIBS}) caffe_default_properties(caffe) +set_target_properties(caffe PROPERTIES OUTPUT_NAME "caffe-nv") # ---[ Tests add_subdirectory(test) diff --git a/tools/caffe.cpp b/tools/caffe.cpp index e3f684b5ab3..2fd9b8043d2 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -3,6 +3,7 @@ namespace bp = boost::python; #endif +#include #include #include @@ -63,6 +64,10 @@ class __Registerer_##func { \ __Registerer_##func g_registerer_##func; \ } +// Hack to convert macro to string +#define STRINGIZE(m) #m +#define STRINGIZE2(m) STRINGIZE(m) + static BrewFunction GetBrewFunction(const caffe::string& name) { if (g_brew_map.count(name)) { return g_brew_map[name]; @@ -378,6 +383,8 @@ RegisterBrewFunction(time); int main(int argc, char** argv) { // Print output to stderr (while still logging). FLAGS_alsologtostderr = 1; + // Set version + gflags::SetVersionString(STRINGIZE2(CAFFE_VERSION)); // Usage message. gflags::SetUsageMessage("command line brew\n" "usage: caffe \n\n" From 9b903b5fc5bdb24ffe1e0638e6e6e3858a84f358 Mon Sep 17 00:00:00 2001 From: Sergei Nikolaev Date: Wed, 30 Sep 2015 14:55:29 -0700 Subject: [PATCH 226/331] test --- Makefile.config.example | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Makefile.config.example b/Makefile.config.example index a20bad2f5ce..94735d38c15 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -96,3 +96,5 @@ TEST_GPUID := 0 # enable pretty build (comment to see full commands) Q ?= @ + +# test From c8073dcbc7bde97dbeceafe98a908b27f0dfed55 Mon Sep 17 00:00:00 2001 From: Simon Layton Date: Wed, 8 Jul 2015 15:35:55 -0400 Subject: [PATCH 227/331] Initial cuDNN v3 support --- include/caffe/vision_layers.hpp | 76 +++++++++- src/caffe/layer_factory.cpp | 43 +++++- src/caffe/layers/cudnn_conv_layer.cpp | 138 +++++++++++++++++- src/caffe/layers/cudnn_conv_layer.cu | 53 ++----- src/caffe/layers/cudnn_lcn_layer.cpp | 77 ++++++++++ src/caffe/layers/cudnn_lcn_layer.cu | 50 +++++++ src/caffe/layers/cudnn_lrn_layer.cpp | 57 ++++++++ src/caffe/layers/cudnn_lrn_layer.cu | 48 +++++++ src/caffe/layers/lrn_layer.cpp | 1 - src/caffe/proto/caffe.proto | 6 + src/caffe/test/test_lrn_layer.cpp | 200 ++++++++++++++++++++++++++ 11 files changed, 695 insertions(+), 54 deletions(-) create mode 100644 src/caffe/layers/cudnn_lcn_layer.cpp create mode 100644 src/caffe/layers/cudnn_lcn_layer.cu create mode 100644 src/caffe/layers/cudnn_lrn_layer.cpp create mode 100644 src/caffe/layers/cudnn_lrn_layer.cu diff --git a/include/caffe/vision_layers.hpp b/include/caffe/vision_layers.hpp index 06bc0457e2d..04d71c94d30 100644 --- a/include/caffe/vision_layers.hpp +++ b/include/caffe/vision_layers.hpp @@ -304,13 +304,24 @@ class CuDNNConvolutionLayer : public ConvolutionLayer { bool handles_setup_; cudnnHandle_t* handle_; cudaStream_t* stream_; + + // algorithms for forward and backwards convolutions + cudnnConvolutionFwdAlgo_t *fwd_algo_; + cudnnConvolutionBwdFilterAlgo_t *bwd_filter_algo_; + cudnnConvolutionBwdDataAlgo_t *bwd_data_algo_; + vector bottom_descs_, top_descs_; cudnnTensorDescriptor_t bias_desc_; cudnnFilterDescriptor_t filter_desc_; vector conv_descs_; - int bottom_offset_, top_offset_, bias_offset_; - size_t workspaceSizeInBytes; - void *workspace; + int bottom_offset_, top_offset_, weight_offset_, bias_offset_; + + size_t *workspace_fwd_sizes_; + size_t *workspace_bwd_data_sizes_; + size_t *workspace_bwd_filter_sizes_; + size_t workspaceSizeInBytes; // size of underlying storage + void *workspaceData; // underlying storage + void **workspace; // aliases into workspaceData }; #endif @@ -442,6 +453,65 @@ class LRNLayer : public Layer { vector*> product_bottom_vec_; }; +#ifdef USE_CUDNN + +template +class CuDNNLRNLayer : public LRNLayer { + public: + explicit CuDNNLRNLayer(const LayerParameter& param) + : LRNLayer(param), handles_setup_(false) {} + virtual void LayerSetUp(const vector*>& bottom, + const vector*>& top); + virtual void Reshape(const vector*>& bottom, + const vector*>& top); + virtual ~CuDNNLRNLayer(); + + protected: + virtual void Forward_gpu(const vector*>& bottom, + const vector*>& top); + virtual void Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + + bool handles_setup_; + cudnnHandle_t handle_; + cudnnLRNDescriptor_t norm_desc_; + cudnnTensorDescriptor_t bottom_desc_, top_desc_; + + int size_; + Dtype alpha_, beta_, k_; +}; + +template +class CuDNNLCNLayer : public LRNLayer { + public: + explicit CuDNNLCNLayer(const LayerParameter& param) + : LRNLayer(param), handles_setup_(false), tempDataSize(0), + tempData1(NULL), tempData2(NULL) {} + virtual void LayerSetUp(const vector*>& bottom, + const vector*>& top); + virtual void Reshape(const vector*>& bottom, + const vector*>& top); + virtual ~CuDNNLCNLayer(); + + protected: + virtual void Forward_gpu(const vector*>& bottom, + const vector*>& top); + virtual void Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + + bool handles_setup_; + cudnnHandle_t handle_; + cudnnLRNDescriptor_t norm_desc_; + cudnnTensorDescriptor_t bottom_desc_, top_desc_; + + int size_, pre_pad_; + Dtype alpha_, beta_, k_; + + size_t tempDataSize; + void *tempData1, *tempData2; +}; + +#endif /** * @brief Pools the input image by taking the max, average, etc. within regions. diff --git a/src/caffe/layer_factory.cpp b/src/caffe/layer_factory.cpp index 926c7d8ff78..989c348c1bb 100644 --- a/src/caffe/layer_factory.cpp +++ b/src/caffe/layer_factory.cpp @@ -55,12 +55,6 @@ shared_ptr > GetPoolingLayer(const LayerParameter& param) { #ifdef USE_CUDNN } else if (engine == PoolingParameter_Engine_CUDNN) { PoolingParameter p_param = param.pooling_param(); - if (p_param.pad() || p_param.pad_h() || p_param.pad_w() || - param.top_size() > 1) { - LOG(INFO) << "CUDNN does not support padding or multiple tops. " - << "Using Caffe's own pooling layer."; - return shared_ptr >(new PoolingLayer(param)); - } return shared_ptr >(new CuDNNPoolingLayer(param)); #endif } else { @@ -70,6 +64,43 @@ shared_ptr > GetPoolingLayer(const LayerParameter& param) { REGISTER_LAYER_CREATOR(Pooling, GetPoolingLayer); +// Get LRN layer according to engine +template +shared_ptr > GetLRNLayer(const LayerParameter& param) { + LRNParameter_Engine engine = param.lrn_param().engine(); + + if (engine == LRNParameter_Engine_DEFAULT) { +#ifdef USE_CUDNN + engine = LRNParameter_Engine_CUDNN; +#else + engine = LRNParameter_Engine_CAFFE; +#endif + } + + if (engine == LRNParameter_Engine_CAFFE) { + return shared_ptr >(new LRNLayer(param)); +#ifdef USE_CUDNN + } else if (engine == LRNParameter_Engine_CUDNN) { + LRNParameter lrn_param = param.lrn_param(); + + if (lrn_param.norm_region() ==LRNParameter_NormRegion_WITHIN_CHANNEL) { + return shared_ptr >(new CuDNNLCNLayer(param)); + } else { + // local size is too big to be handled through cuDNN + if (param.lrn_param().local_size() > CUDNN_LRN_MAX_N) { + return shared_ptr >(new LRNLayer(param)); + } else { + return shared_ptr >(new CuDNNLRNLayer(param)); + } + } +#endif + } else { + LOG(FATAL) << "Layer " << param.name() << " has unknown engine."; + } +} + +REGISTER_LAYER_CREATOR(LRN, GetLRNLayer); + // Get relu layer according to engine. template shared_ptr > GetReLULayer(const LayerParameter& param) { diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index 3514fe2aba5..d7b1e0d651f 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -1,4 +1,5 @@ #ifdef USE_CUDNN +#include #include #include "caffe/filler.hpp" @@ -24,13 +25,38 @@ void CuDNNConvolutionLayer::LayerSetUp( // Initialize CUDA streams and cuDNN. stream_ = new cudaStream_t[this->group_ * CUDNN_STREAMS_PER_GROUP]; handle_ = new cudnnHandle_t[this->group_ * CUDNN_STREAMS_PER_GROUP]; + + // Initialize algorithm arrays + fwd_algo_ = new cudnnConvolutionFwdAlgo_t[bottom.size()]; + bwd_filter_algo_= new cudnnConvolutionBwdFilterAlgo_t[bottom.size()]; + bwd_data_algo_ = new cudnnConvolutionBwdDataAlgo_t[bottom.size()]; + + // initialize size arrays + workspace_fwd_sizes_ = new size_t[bottom.size()]; + workspace_bwd_filter_sizes_ = new size_t[bottom.size()]; + workspace_bwd_data_sizes_ = new size_t[bottom.size()]; + + // workspace data workspaceSizeInBytes = 0; - workspace = NULL; + workspaceData = NULL; + workspace = new void*[this->group_ * CUDNN_STREAMS_PER_GROUP]; + + for (size_t i = 0; i < bottom.size(); ++i) { + // initialize all to default algorithms + fwd_algo_[i] = (cudnnConvolutionFwdAlgo_t)0; + bwd_filter_algo_[i] = (cudnnConvolutionBwdFilterAlgo_t)0; + bwd_data_algo_[i] = (cudnnConvolutionBwdDataAlgo_t)0; + // default algorithms don't require workspace + workspace_fwd_sizes_[i] = 0; + workspace_bwd_data_sizes_[i] = 0; + workspace_bwd_filter_sizes_[i] = 0; + } for (int g = 0; g < this->group_ * CUDNN_STREAMS_PER_GROUP; g++) { CUDA_CHECK(cudaStreamCreate(&stream_[g])); CUDNN_CHECK(cudnnCreate(&handle_[g])); CUDNN_CHECK(cudnnSetStream(handle_[g], stream_[g])); + workspace[g] = NULL; } // Set the indexing parameters. @@ -86,6 +112,10 @@ void CuDNNConvolutionLayer::Reshape( const int stride_h = stride_data[0]; const int stride_w = stride_data[1]; + // Specify workspace limit for kernels directly until we have a + // planning strategy and a rewrite of Caffe's GPU memory mangagement + size_t workspace_limit_bytes = 8*1024*1024; + for (int i = 0; i < bottom.size(); i++) { cudnn::setTensor4dDesc(&bottom_descs_[i], this->num_, @@ -98,7 +128,104 @@ void CuDNNConvolutionLayer::Reshape( this->num_output_ * this->out_spatial_dim_, this->out_spatial_dim_, width_out, 1); cudnn::setConvolutionDesc(&conv_descs_[i], bottom_descs_[i], - filter_desc_, pad_h, pad_w, stride_h, stride_w); + filter_desc_, pad_h, pad_w, + stride_h, stride_w); + + // choose forward and backward algorithms + workspace(s) + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm(handle_[0], + bottom_descs_[i], + filter_desc_, + conv_descs_[i], + top_descs_[i], + CUDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT, + workspace_limit_bytes, + &fwd_algo_[i])); + + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize(handle_[0], + bottom_descs_[i], + filter_desc_, + conv_descs_[i], + top_descs_[i], + fwd_algo_[i], + &(workspace_fwd_sizes_[i]))); + + // choose backward algorithm for filter + CUDNN_CHECK(cudnnGetConvolutionBackwardFilterAlgorithm(handle_[0], + bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, + CUDNN_CONVOLUTION_BWD_FILTER_SPECIFY_WORKSPACE_LIMIT, + workspace_limit_bytes, &bwd_filter_algo_[i]) ); + + // get workspace for backwards filter algorithm + CUDNN_CHECK(cudnnGetConvolutionBackwardFilterWorkspaceSize(handle_[0], + bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, + bwd_filter_algo_[i], &workspace_bwd_filter_sizes_[i])); + + // choose backward algo for data + CUDNN_CHECK(cudnnGetConvolutionBackwardDataAlgorithm(handle_[0], + filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], + CUDNN_CONVOLUTION_BWD_DATA_SPECIFY_WORKSPACE_LIMIT, + workspace_limit_bytes, &bwd_data_algo_[i])); + + // get workspace size + CUDNN_CHECK(cudnnGetConvolutionBackwardDataWorkspaceSize(handle_[0], + filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], + bwd_data_algo_[i], &workspace_bwd_data_sizes_[i]) ); + } + + // reduce over all workspace sizes to get a maximum to allocate / reallocate + size_t total_workspace_fwd = 0; + size_t total_workspace_bwd_data = 0; + size_t total_workspace_bwd_filter = 0; + + for (size_t i = 0; i < bottom.size(); i++) { + total_workspace_fwd = std::max(total_workspace_fwd, + workspace_fwd_sizes_[i]); + total_workspace_bwd_data = std::max(total_workspace_bwd_data, + workspace_bwd_data_sizes_[i]); + total_workspace_bwd_filter = std::max(total_workspace_bwd_filter, + workspace_bwd_filter_sizes_[i]); + } + // get max over all operations + size_t max_workspace = std::max(total_workspace_fwd, + total_workspace_bwd_data); + max_workspace = std::max(max_workspace, total_workspace_bwd_filter); + // ensure all groups have enough workspace + size_t total_max_workspace = max_workspace * + (this->group_ * CUDNN_STREAMS_PER_GROUP); + + // this is the total amount of storage needed over all groups + streams + if (total_max_workspace > workspaceSizeInBytes) { + LOG(INFO) << "Reallocating workspace storage: " << total_max_workspace; + workspaceSizeInBytes = total_max_workspace; + + // free the existing workspace and allocate a new (larger) one + cudaFree(this->workspaceData); + + cudaError_t err = cudaMalloc(&(this->workspaceData), workspaceSizeInBytes); + if (err != cudaSuccess) { + // force zero memory path + for (int i = 0; i < bottom.size(); i++) { + workspace_fwd_sizes_[i] = 0; + workspace_bwd_filter_sizes_[i] = 0; + workspace_bwd_data_sizes_[i] = 0; + fwd_algo_[i] = CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM; + bwd_filter_algo_[i] = CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0; + bwd_data_algo_[i] = CUDNN_CONVOLUTION_BWD_DATA_ALGO_0; + } + + // NULL out all workspace pointers + for (int g = 0; g < (this->group_ * CUDNN_STREAMS_PER_GROUP); g++) { + workspace[g] = NULL; + } + // NULL out underlying data + workspaceData = NULL; + workspaceSizeInBytes = 0; + } + + // if we succeed in the allocation, set pointer aliases for workspaces + for (int g = 0; g < (this->group_ * CUDNN_STREAMS_PER_GROUP); g++) { + workspace[g] = reinterpret_cast(workspaceData) + g*max_workspace; + } } // Tensor descriptor for bias. @@ -128,8 +255,15 @@ CuDNNConvolutionLayer::~CuDNNConvolutionLayer() { cudnnDestroy(handle_[g]); } + cudaFree(workspaceData); delete [] stream_; delete [] handle_; + delete [] fwd_algo_; + delete [] bwd_filter_algo_; + delete [] bwd_data_algo_; + delete [] workspace_fwd_sizes_; + delete [] workspace_bwd_data_sizes_; + delete [] workspace_bwd_filter_sizes_; } INSTANTIATE_CLASS(CuDNNConvolutionLayer); diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index 691152021a3..e3eea35ab59 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -26,52 +26,13 @@ void CuDNNConvolutionLayer::Forward_gpu( // Forward through cuDNN in parallel over groups. for (int g = 0; g < this->group_; g++) { - cudnnConvolutionFwdAlgo_t algo; - - // pick the convolution algorithm - // TODO(shelhamer) this should be done during reshape - // TODO(shelhamer) the choice of automatic or manual algorithm picking - // should be exposed in proto - CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm(handle_[g], - bottom_descs_[i], - filter_desc_, - conv_descs_[i], - top_descs_[i], - CUDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT, - workspace_limit_bytes, // memoryLimitInBytes, - &algo)); - - // get minimum size of the workspace needed for the desired algorithm - size_t workspaceSizeInBytes_temp = 0; - - CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize(handle_[g], - bottom_descs_[i], - filter_desc_, - conv_descs_[i], - top_descs_[i], - algo, - &workspaceSizeInBytes_temp)); - - if (workspaceSizeInBytes_temp > workspaceSizeInBytes) { - workspaceSizeInBytes = workspaceSizeInBytes_temp; - // free the existing workspace and allocate a new (larger) one - cudaFree(this->workspace); - cudaError_t err = cudaMalloc(&(this->workspace), workspaceSizeInBytes); - if (err != cudaSuccess) { - // force zero memory path - algo = CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM; - workspace = NULL; - workspaceSizeInBytes = 0; - } - } - // Filters. CUDNN_CHECK(cudnnConvolutionForward(handle_[g], cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, filter_desc_, weight + this->weight_offset_ * g, conv_descs_[i], - algo, workspace, workspaceSizeInBytes, + fwd_algo_[i], workspace[g], workspace_fwd_sizes_[i], cudnn::dataType::zero, top_descs_[i], top_data + top_offset_ * g)); @@ -101,10 +62,12 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, if (this->param_propagate_down_[0]) { weight = this->blobs_[0]->gpu_data(); weight_diff = this->blobs_[0]->mutable_gpu_diff(); + caffe_gpu_set(this->blobs_[0]->count(), Dtype(0), weight_diff); } Dtype* bias_diff = NULL; if (this->bias_term_ && this->param_propagate_down_[1]) { bias_diff = this->blobs_[1]->mutable_gpu_diff(); + caffe_gpu_set(this->blobs_[1]->count(), Dtype(0), bias_diff); } for (int i = 0; i < top.size(); ++i) { const Dtype* top_diff = top[i]->gpu_diff(); @@ -122,11 +85,14 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, // Gradient w.r.t. weights. if (this->param_propagate_down_[0]) { const Dtype* bottom_data = bottom[i]->gpu_data(); - CUDNN_CHECK(cudnnConvolutionBackwardFilter(handle_[1*this->group_ + g], + CUDNN_CHECK(cudnnConvolutionBackwardFilter_v3( + handle_[1*this->group_ + g], cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], + bwd_filter_algo_[i], workspace[1*this->group_ + g], + workspace_bwd_filter_sizes_[i], cudnn::dataType::one, filter_desc_, weight_diff + this->weight_offset_ * g)); } @@ -137,11 +103,14 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, weight = this->blobs_[0]->gpu_data(); } Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnConvolutionBackwardData(handle_[2*this->group_ + g], + CUDNN_CHECK(cudnnConvolutionBackwardData_v3( + handle_[2*this->group_ + g], cudnn::dataType::one, filter_desc_, weight + this->weight_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], + bwd_data_algo_[i], workspace[2*this->group_ + g], + workspace_bwd_data_sizes_[i], cudnn::dataType::zero, bottom_descs_[i], bottom_diff + bottom_offset_ * g)); } diff --git a/src/caffe/layers/cudnn_lcn_layer.cpp b/src/caffe/layers/cudnn_lcn_layer.cpp new file mode 100644 index 00000000000..866d810b9f9 --- /dev/null +++ b/src/caffe/layers/cudnn_lcn_layer.cpp @@ -0,0 +1,77 @@ +#ifdef USE_CUDNN +#include + +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/im2col.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void CuDNNLCNLayer::LayerSetUp(const vector*>& bottom, + const vector*>& top) { + LRNLayer::LayerSetUp(bottom, top); + + CUDNN_CHECK(cudnnCreate(&handle_)); + CUDNN_CHECK(cudnnCreateLRNDescriptor(&norm_desc_)); + cudnn::createTensor4dDesc(&bottom_desc_); + cudnn::createTensor4dDesc(&top_desc_); + + // create a LRN handle + handles_setup_ = true; + + size_ = this->layer_param().lrn_param().local_size(); + pre_pad_ = (size_ - 1) / 2; + alpha_ = this->layer_param().lrn_param().alpha(); + beta_ = this->layer_param().lrn_param().beta(); + k_ = this->layer_param().lrn_param().k(); +} + +template +void CuDNNLCNLayer::Reshape(const vector*>& bottom, + const vector*>& top) { + LRNLayer::Reshape(bottom, top); + cudnn::setTensor4dDesc(&bottom_desc_, bottom[0]->num(), + this->channels_, this->height_, this->width_); + cudnn::setTensor4dDesc(&top_desc_, bottom[0]->num(), + this->channels_, this->height_, this->width_); + CUDNN_CHECK(cudnnSetLRNDescriptor(norm_desc_, size_, alpha_, beta_, k_)); + + // allocate / reallocate tempData buffers + size_t totalSizeInBytes = sizeof(Dtype)*bottom[0]->num()* \ + this->channels_*this->height_*this->width_; + + if (totalSizeInBytes > tempDataSize) { + tempDataSize = totalSizeInBytes; + + cudaFree(tempData1); + cudaFree(tempData2); + + // allocate new buffers + CUDA_CHECK(cudaMalloc(&tempData1, totalSizeInBytes)); + CUDA_CHECK(cudaMalloc(&tempData2, totalSizeInBytes)); + } +} + +template +CuDNNLCNLayer::~CuDNNLCNLayer() { + // Check that handles have been setup before destroying. + if (!handles_setup_) { return; } + + cudnnDestroyTensorDescriptor(bottom_desc_); + cudnnDestroyTensorDescriptor(top_desc_); + + // destroy LRN handle + cudnnDestroy(handle_); + + // free temp buffers + cudaFree(tempData1); + cudaFree(tempData2); +} + +INSTANTIATE_CLASS(CuDNNLCNLayer); + +} // namespace caffe +#endif diff --git a/src/caffe/layers/cudnn_lcn_layer.cu b/src/caffe/layers/cudnn_lcn_layer.cu new file mode 100644 index 00000000000..c07ade72066 --- /dev/null +++ b/src/caffe/layers/cudnn_lcn_layer.cu @@ -0,0 +1,50 @@ +#ifdef USE_CUDNN +#include + +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/im2col.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, + const vector*>& top) { + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* top_data = top[0]->mutable_gpu_data(); + + CUDNN_CHECK(cudnnDivisiveNormalizationForward( + handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, + cudnn::dataType::one, + bottom_desc_, bottom_data, + NULL, // srcMeansData + this->tempData1, this->tempData2, + cudnn::dataType::zero, + top_desc_, top_data) ); +} + +template +void CuDNNLCNLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + const Dtype* top_diff = top[0]->gpu_diff(); + const Dtype* top_data = top[0]->gpu_data(); + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + + CUDNN_CHECK(cudnnDivisiveNormalizationBackward( + handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, + cudnn::dataType::one, + bottom_desc_, bottom_data, + NULL, top_diff, // NULL - srcMeansData + this->tempData1, this->tempData2, + cudnn::dataType::zero, + bottom_desc_, bottom_diff, + NULL) ); +} + +INSTANTIATE_LAYER_GPU_FUNCS(CuDNNLCNLayer); + +} // namespace caffe +#endif diff --git a/src/caffe/layers/cudnn_lrn_layer.cpp b/src/caffe/layers/cudnn_lrn_layer.cpp new file mode 100644 index 00000000000..6e9921490f0 --- /dev/null +++ b/src/caffe/layers/cudnn_lrn_layer.cpp @@ -0,0 +1,57 @@ +#ifdef USE_CUDNN +#include + +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/im2col.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void CuDNNLRNLayer::LayerSetUp(const vector*>& bottom, + const vector*>& top) { + LRNLayer::LayerSetUp(bottom, top); + + CUDNN_CHECK(cudnnCreate(&handle_)); + CUDNN_CHECK(cudnnCreateLRNDescriptor(&norm_desc_)); + cudnn::createTensor4dDesc(&bottom_desc_); + cudnn::createTensor4dDesc(&top_desc_); + + // create a LRN handle + handles_setup_ = true; + + size_ = this->layer_param().lrn_param().local_size(); + alpha_ = this->layer_param().lrn_param().alpha(); + beta_ = this->layer_param().lrn_param().beta(); + k_ = this->layer_param().lrn_param().k(); +} + +template +void CuDNNLRNLayer::Reshape(const vector*>& bottom, + const vector*>& top) { + LRNLayer::Reshape(bottom, top); + cudnn::setTensor4dDesc(&bottom_desc_, bottom[0]->num(), + this->channels_, this->height_, this->width_); + cudnn::setTensor4dDesc(&top_desc_, bottom[0]->num(), + this->channels_, this->height_, this->width_); + CUDNN_CHECK(cudnnSetLRNDescriptor(norm_desc_, size_, alpha_, beta_, k_)); +} + +template +CuDNNLRNLayer::~CuDNNLRNLayer() { + // Check that handles have been setup before destroying. + if (!handles_setup_) { return; } + + cudnnDestroyTensorDescriptor(bottom_desc_); + cudnnDestroyTensorDescriptor(top_desc_); + + // destroy LRN handle + cudnnDestroy(handle_); +} + +INSTANTIATE_CLASS(CuDNNLRNLayer); + +} // namespace caffe +#endif diff --git a/src/caffe/layers/cudnn_lrn_layer.cu b/src/caffe/layers/cudnn_lrn_layer.cu new file mode 100644 index 00000000000..f9923033011 --- /dev/null +++ b/src/caffe/layers/cudnn_lrn_layer.cu @@ -0,0 +1,48 @@ +#ifdef USE_CUDNN +#include + +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/im2col.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void CuDNNLRNLayer::Forward_gpu(const vector*>& bottom, + const vector*>& top) { + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* top_data = top[0]->mutable_gpu_data(); + + CUDNN_CHECK(cudnnLRNCrossChannelForward( + handle_, norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, + cudnn::dataType::one, + bottom_desc_, bottom_data, + cudnn::dataType::zero, + top_desc_, top_data) ); +} + +template +void CuDNNLRNLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + const Dtype* top_diff = top[0]->gpu_diff(); + const Dtype* top_data = top[0]->gpu_data(); + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + + CUDNN_CHECK(cudnnLRNCrossChannelBackward( + handle_, norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, + cudnn::dataType::one, + top_desc_, top_data, + top_desc_, top_diff, + bottom_desc_, bottom_data, + cudnn::dataType::zero, + bottom_desc_, bottom_diff) ); +} + +INSTANTIATE_LAYER_GPU_FUNCS(CuDNNLRNLayer); + +}; // namespace caffe + +#endif diff --git a/src/caffe/layers/lrn_layer.cpp b/src/caffe/layers/lrn_layer.cpp index 36c1ace4c99..d18a04ef58d 100644 --- a/src/caffe/layers/lrn_layer.cpp +++ b/src/caffe/layers/lrn_layer.cpp @@ -254,6 +254,5 @@ STUB_GPU_BACKWARD(LRNLayer, CrossChannelBackward); #endif INSTANTIATE_CLASS(LRNLayer); -REGISTER_LAYER_CLASS(LRN); } // namespace caffe diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index f52c941b05e..af01b4721c9 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -721,6 +721,12 @@ message LRNParameter { } optional NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; optional float k = 5 [default = 1.]; + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 6 [default = DEFAULT]; } message MemoryDataParameter { diff --git a/src/caffe/test/test_lrn_layer.cpp b/src/caffe/test/test_lrn_layer.cpp index c4e2f8ea7f2..b3176db6153 100644 --- a/src/caffe/test/test_lrn_layer.cpp +++ b/src/caffe/test/test_lrn_layer.cpp @@ -246,5 +246,205 @@ TYPED_TEST(LRNLayerTest, TestGradientWithinChannel) { this->blob_top_vec_); } +#ifdef USE_CUDNN +template +class CuDNNLRNLayerTest : public GPUDeviceTest { + protected: + CuDNNLRNLayerTest() + : epsilon_(Dtype(1e-5)), + blob_bottom_(new Blob()), + blob_top_(new Blob()) {} + virtual void SetUp() { + Caffe::set_random_seed(1701); + blob_bottom_->Reshape(2, 7, 3, 3); + // fill the values + FillerParameter filler_param; + GaussianFiller filler(filler_param); + filler.Fill(this->blob_bottom_); + blob_bottom_vec_.push_back(blob_bottom_); + blob_top_vec_.push_back(blob_top_); + } + virtual ~CuDNNLRNLayerTest() { delete blob_bottom_; delete blob_top_; } + void ReferenceLRNForward(const Blob& blob_bottom, + const LayerParameter& layer_param, Blob* blob_top); + + Dtype epsilon_; + Blob* const blob_bottom_; + Blob* const blob_top_; + vector*> blob_bottom_vec_; + vector*> blob_top_vec_; +}; + +template +void CuDNNLRNLayerTest::ReferenceLRNForward( + const Blob& blob_bottom, const LayerParameter& layer_param, + Blob* blob_top) { + typedef TypeParam Dtype; + blob_top->Reshape(blob_bottom.num(), blob_bottom.channels(), + blob_bottom.height(), blob_bottom.width()); + Dtype* top_data = blob_top->mutable_cpu_data(); + LRNParameter lrn_param = layer_param.lrn_param(); + Dtype alpha = lrn_param.alpha(); + Dtype beta = lrn_param.beta(); + int size = lrn_param.local_size(); + switch (lrn_param.norm_region()) { + case LRNParameter_NormRegion_ACROSS_CHANNELS: + for (int n = 0; n < blob_bottom.num(); ++n) { + for (int c = 0; c < blob_bottom.channels(); ++c) { + for (int h = 0; h < blob_bottom.height(); ++h) { + for (int w = 0; w < blob_bottom.width(); ++w) { + int c_start = c - (size - 1) / 2; + int c_end = min(c_start + size, blob_bottom.channels()); + c_start = max(c_start, 0); + Dtype scale = 1.; + for (int i = c_start; i < c_end; ++i) { + Dtype value = blob_bottom.data_at(n, i, h, w); + scale += value * value * alpha / size; + } + *(top_data + blob_top->offset(n, c, h, w)) = + blob_bottom.data_at(n, c, h, w) / pow(scale, beta); + } + } + } + } + break; + case LRNParameter_NormRegion_WITHIN_CHANNEL: + for (int n = 0; n < blob_bottom.num(); ++n) { + for (int c = 0; c < blob_bottom.channels(); ++c) { + for (int h = 0; h < blob_bottom.height(); ++h) { + int h_start = h - (size - 1) / 2; + int h_end = min(h_start + size, blob_bottom.height()); + h_start = max(h_start, 0); + for (int w = 0; w < blob_bottom.width(); ++w) { + Dtype scale = 1.; + int w_start = w - (size - 1) / 2; + int w_end = min(w_start + size, blob_bottom.width()); + w_start = max(w_start, 0); + for (int nh = h_start; nh < h_end; ++nh) { + for (int nw = w_start; nw < w_end; ++nw) { + Dtype value = blob_bottom.data_at(n, c, nh, nw); + scale += value * value * alpha / (size * size); + } + } + *(top_data + blob_top->offset(n, c, h, w)) = + blob_bottom.data_at(n, c, h, w) / pow(scale, beta); + } + } + } + } + break; + default: + LOG(FATAL) << "Unknown normalization region."; + } +} + +TYPED_TEST_CASE(CuDNNLRNLayerTest, TestDtypes); + +TYPED_TEST(CuDNNLRNLayerTest, TestForwardAcrossChannelsCuDNN) { + // typedef typename TypeParam::Dtype Dtype; + Caffe::set_mode(Caffe::GPU); + LayerParameter layer_param; + CuDNNLRNLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + Blob top_reference; + this->ReferenceLRNForward(*(this->blob_bottom_), layer_param, + &top_reference); + for (int i = 0; i < this->blob_bottom_->count(); ++i) { + EXPECT_NEAR(this->blob_top_->cpu_data()[i], top_reference.cpu_data()[i], + this->epsilon_); + } +} + +TYPED_TEST(CuDNNLRNLayerTest, TestForwardAcrossChannelsLargeRegionCuDNN) { + Caffe::set_mode(Caffe::GPU); + typedef TypeParam Dtype; + LayerParameter layer_param; + layer_param.mutable_lrn_param()->set_local_size(15); + CuDNNLRNLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + Blob top_reference; + this->ReferenceLRNForward(*(this->blob_bottom_), layer_param, + &top_reference); + for (int i = 0; i < this->blob_bottom_->count(); ++i) { + EXPECT_NEAR(this->blob_top_->cpu_data()[i], top_reference.cpu_data()[i], + this->epsilon_); + } +} + +TYPED_TEST(CuDNNLRNLayerTest, TestGradientAcrossChannelsCuDNN) { + typedef TypeParam Dtype; + LayerParameter layer_param; + CuDNNLRNLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + for (int i = 0; i < this->blob_top_->count(); ++i) { + this->blob_top_->mutable_cpu_diff()[i] = 1.; + } + vector propagate_down(this->blob_bottom_vec_.size(), true); + layer.Backward(this->blob_top_vec_, propagate_down, + this->blob_bottom_vec_); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} + +TYPED_TEST(CuDNNLRNLayerTest, TestForwardWithinChannel) { + Caffe::set_mode(Caffe::GPU); + typedef TypeParam Dtype; + LayerParameter layer_param; + layer_param.mutable_lrn_param()->set_norm_region( + LRNParameter_NormRegion_WITHIN_CHANNEL); + layer_param.mutable_lrn_param()->set_local_size(3); + CuDNNLCNLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + Blob top_reference; + this->ReferenceLRNForward(*(this->blob_bottom_), layer_param, + &top_reference); + for (int i = 0; i < this->blob_bottom_->count(); ++i) { + EXPECT_NEAR(this->blob_top_->cpu_data()[i], top_reference.cpu_data()[i], + this->epsilon_); + } +} + +TYPED_TEST(CuDNNLRNLayerTest, TestGradientWithinChannel) { + Caffe::set_mode(Caffe::GPU); + typedef TypeParam Dtype; + LayerParameter layer_param; + layer_param.mutable_lrn_param()->set_norm_region( + LRNParameter_NormRegion_WITHIN_CHANNEL); + layer_param.mutable_lrn_param()->set_local_size(3); + CuDNNLCNLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + for (int i = 0; i < this->blob_top_->count(); ++i) { + this->blob_top_->mutable_cpu_diff()[i] = 1.; + } + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} + +TYPED_TEST(CuDNNLRNLayerTest, TestGradientAcrossChannelsLargeRegionCuDNN) { + typedef TypeParam Dtype; + LayerParameter layer_param; + layer_param.mutable_lrn_param()->set_local_size(15); + CuDNNLRNLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + for (int i = 0; i < this->blob_top_->count(); ++i) { + this->blob_top_->mutable_cpu_diff()[i] = 1.; + } + vector propagate_down(this->blob_bottom_vec_.size(), true); + layer.Backward(this->blob_top_vec_, propagate_down, + this->blob_bottom_vec_); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} + +#endif } // namespace caffe From c089a2e1ff9649140f5a5fa7433247819ed510e3 Mon Sep 17 00:00:00 2001 From: Sergei Nikolaev Date: Wed, 30 Sep 2015 17:05:17 -0700 Subject: [PATCH 228/331] cuDNN v4 compatibility fix --- Makefile.config.example | 2 -- src/caffe/layers/cudnn_conv_layer.cu | 7 ++++++- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/Makefile.config.example b/Makefile.config.example index 94735d38c15..a20bad2f5ce 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -96,5 +96,3 @@ TEST_GPUID := 0 # enable pretty build (comment to see full commands) Q ?= @ - -# test diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index e3eea35ab59..6edd7043c93 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -39,7 +39,12 @@ void CuDNNConvolutionLayer::Forward_gpu( // Bias. if (this->bias_term_) { const Dtype* bias_data = this->blobs_[1]->gpu_data(); - CUDNN_CHECK(cudnnAddTensor(handle_[g], CUDNN_ADD_SAME_C, +#if (CUDNN_MAJOR >= 4) + CUDNN_CHECK(cudnnAddTensor_v2 +#else + CUDNN_CHECK(cudnnAddTensor +#endif + (handle_[g], CUDNN_ADD_SAME_C, cudnn::dataType::one, bias_desc_, bias_data + bias_offset_ * g, cudnn::dataType::one, From 441bddcc691ffac90526b079edef0050e58a85fe Mon Sep 17 00:00:00 2001 From: Simon Layton Date: Tue, 30 Jun 2015 13:59:08 -0400 Subject: [PATCH 229/331] Add CNMeM support 488f1264805538df1282c143cc5acbf0eb694afc Conflicts: Makefile Makefile.config.example src/caffe/layers/cudnn_conv_layer.cpp src/caffe/layers/cudnn_conv_layer.cu src/caffe/layers/cudnn_lcn_layer.cpp src/caffe/layers/cudnn_lcn_layer.cu --- Makefile | 6 ++ Makefile.config.example | 2 + include/caffe/common.hpp | 61 +++++++++++++ include/caffe/parallel.hpp | 2 + include/caffe/util/device_alternate.hpp | 11 +++ src/caffe/common.cpp | 113 +++++++++++++++++++++++- src/caffe/layers/cudnn_conv_layer.cpp | 45 +++++----- src/caffe/layers/cudnn_conv_layer.cu | 43 ++++++--- src/caffe/layers/cudnn_lcn_layer.cpp | 14 ++- src/caffe/layers/cudnn_lcn_layer.cu | 24 +++++ src/caffe/layers/dropout_layer.cu | 2 +- src/caffe/parallel.cpp | 27 ++++-- src/caffe/syncedmem.cpp | 10 +-- src/caffe/test/test_lrn_layer.cpp | 2 + tools/caffe.cpp | 6 ++ 15 files changed, 318 insertions(+), 50 deletions(-) diff --git a/Makefile b/Makefile index 5fb6394e947..261c6437f9e 100644 --- a/Makefile +++ b/Makefile @@ -304,6 +304,12 @@ ifeq ($(USE_CUDNN), 1) COMMON_FLAGS += -DUSE_CUDNN endif +# cuMEM integration +ifeq ($(USE_CNMEM), 1) + LIBRARIES += cnmem + COMMON_FLAGS += -DUSE_CNMEM +endif + # configure IO libraries ifeq ($(USE_OPENCV), 1) COMMON_FLAGS += -DUSE_OPENCV diff --git a/Makefile.config.example b/Makefile.config.example index a20bad2f5ce..8c8731e226f 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -3,6 +3,8 @@ # cuDNN acceleration switch (uncomment to build with cuDNN). # USE_CUDNN := 1 +# CNMeM memory pool switch (github.com/NVIDIA/cnmem required) +# USE_CNMEM := 1 # CPU-only switch (uncomment to build without GPU support). # CPU_ONLY := 1 diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index 1df6b9a14fb..e79362d2274 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -18,6 +18,11 @@ #include "caffe/util/device_alternate.hpp" +#ifdef USE_CNMEM +// cuMEM integration +#include +#endif + // gflags 2.1 issue: namespace google was changed to gflags without warning. // Luckily we will be able to use GFLAGS_GFLAGS_H_ to detect if it is version // 2.1. If yes, we will add a temporary solution to redirect the namespace. @@ -173,6 +178,62 @@ class Caffe { DISABLE_COPY_AND_ASSIGN(Caffe); }; +class MemoryHandler { + public: + static MemoryHandler& Get(); +#ifndef CPU_ONLY + static void mallocGPU(void **ptr, size_t size, + cudaStream_t stream = cudaStreamDefault); + static void freeGPU(void *ptr, cudaStream_t = cudaStreamDefault); + static void registerStream(cudaStream_t stream); +#endif + static void setGPUs(const std::vector& gpus) { Get().gpus_ = gpus; } + static void usePool() { Get().using_pool_ = true; } + static bool usingPool() { +#ifdef USE_CNMEM + return Get().using_pool_; +#else + return false; +#endif + } + static void getInfo(size_t *free_mem, size_t *used_mem); + static void destroy(); + ~MemoryHandler() { } + + private: + MemoryHandler() : using_pool_(false), initialized_(false) {} + static void Init(); + // static void Destroy(); +#ifndef CPU_ONLY + void allocate_memory(void **ptr, size_t size, cudaStream_t stream); + void free_memory(void *ptr, cudaStream_t stream); +#endif + DISABLE_COPY_AND_ASSIGN(MemoryHandler); + + bool using_pool_; + bool initialized_; + std::vector gpus_; +}; + +class MemoryHandlerActivator { + public: + explicit MemoryHandlerActivator(const std::vector& gpus) + : using_pool_(false) { + if (gpus.size() > 0) { + using_pool_ = true; + MemoryHandler::usePool(); + MemoryHandler::setGPUs(gpus); + } + } + ~MemoryHandlerActivator() { + if (using_pool_) { + MemoryHandler::destroy(); + } + } + private: + int using_pool_; +}; + } // namespace caffe #endif // CAFFE_COMMON_HPP_ diff --git a/include/caffe/parallel.hpp b/include/caffe/parallel.hpp index 85fc2b55984..a3eb960c7d7 100644 --- a/include/caffe/parallel.hpp +++ b/include/caffe/parallel.hpp @@ -57,6 +57,8 @@ class GPUParams : public Params { using Params::size_; using Params::data_; using Params::diff_; + private: + int buffer_device_; }; class DevicePair { diff --git a/include/caffe/util/device_alternate.hpp b/include/caffe/util/device_alternate.hpp index 6ea595dba2d..55d616fbf71 100644 --- a/include/caffe/util/device_alternate.hpp +++ b/include/caffe/util/device_alternate.hpp @@ -66,6 +66,17 @@ void classname::funcname##_##gpu(const vector*>& top, \ << caffe::curandGetErrorString(status); \ } while (0) +#ifdef USE_CNMEM + +#define CNMEM_CHECK(condition) \ + do { \ + cnmemStatus_t status = condition; \ + CHECK_EQ(status, CNMEM_STATUS_SUCCESS) << " " \ + << cnmemGetErrorString(status); \ + } while (0) + +#endif + // CUDA: grid stride looping #define CUDA_KERNEL_LOOP(i, n) \ for (int i = blockIdx.x * blockDim.x + threadIdx.x; \ diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index 299d67d4bec..9a20a04fb44 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -3,15 +3,18 @@ #include #include #include +#include #include "caffe/common.hpp" #include "caffe/util/rng.hpp" namespace caffe { +static boost::shared_ptr mem_handler; // Make sure each thread can have different values. static boost::thread_specific_ptr thread_instance_; + Caffe& Caffe::Get() { if (!thread_instance_.get()) { thread_instance_.reset(new Caffe()); @@ -192,7 +195,6 @@ void Caffe::DeviceQuery() { return; } - class Caffe::RNG::Generator { public: Generator() : rng_(new caffe::rng_t(cluster_seedgen())) {} @@ -215,6 +217,115 @@ void* Caffe::RNG::generator() { return static_cast(generator_->rng()); } +static boost::mutex memHandlerMutex; + +MemoryHandler& MemoryHandler::Get() { + boost::mutex::scoped_lock lock(memHandlerMutex); + if (!mem_handler.get()) { + mem_handler.reset(new MemoryHandler()); + } + return *(mem_handler.get()); +} + +void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { + if (!Get().initialized_) { + Init(); + } + Get().allocate_memory(ptr, size, stream); +} + +void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { + Get().free_memory(ptr, stream); +} + +void MemoryHandler::allocate_memory(void **ptr, size_t size, + cudaStream_t stream) { + int initial_device; + cudaGetDevice(&initial_device); + if (size == 0) return; + if (using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); +#endif + } else { + CUDA_CHECK(cudaMalloc(ptr, size)); + } + cudaSetDevice(initial_device); +} + +void MemoryHandler::free_memory(void *ptr, cudaStream_t stream) { + // boost::mutex::scoped_lock lock(memHandlerMutex); + int initial_device; + cudaGetDevice(&initial_device); + if (using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemFree(ptr, stream)); +#endif + } else { + CUDA_CHECK(cudaFree(ptr)); + } + ptr = NULL; + cudaSetDevice(initial_device); +} + +void MemoryHandler::registerStream(cudaStream_t stream) { + if (!Get().initialized_) { + Init(); + } + if (Get().using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemRegisterStream(stream)); +#endif + } +} + +void MemoryHandler::destroy() { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemFinalize()); +#endif +} + +void MemoryHandler::Init() { + if (Get().using_pool_) { +#ifdef USE_CNMEM + cnmemDevice_t *devs = new cnmemDevice_t[Get().gpus_.size()]; + + int initial_device; + CUDA_CHECK(cudaGetDevice(&initial_device)); + + for (int i = 0; i < Get().gpus_.size(); i++) { + CUDA_CHECK(cudaSetDevice(Get().gpus_[i])); + + devs[i].device = Get().gpus_[i]; + + size_t free_mem, used_mem; + CUDA_CHECK(cudaMemGetInfo(&free_mem, &used_mem)); + + devs[i].size = size_t(0.8*free_mem); + devs[i].numStreams = 0; + devs[i].streams = NULL; + } + CNMEM_CHECK(cnmemInit(Get().gpus_.size(), devs, CNMEM_FLAGS_DEFAULT)); + Get().initialized_ = true; + + CUDA_CHECK(cudaSetDevice(initial_device)); + + delete [] devs; +#endif + } + Get().initialized_ = true; +} + +void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { + if (Get().using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); +#endif + } else { + CUDA_CHECK(cudaMemGetInfo(free_mem, total_mem)); + } +} + const char* cublasGetErrorString(cublasStatus_t error) { switch (error) { case CUBLAS_STATUS_SUCCESS: diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index d7b1e0d651f..ac7370115c8 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -57,6 +57,7 @@ void CuDNNConvolutionLayer::LayerSetUp( CUDNN_CHECK(cudnnCreate(&handle_[g])); CUDNN_CHECK(cudnnSetStream(handle_[g], stream_[g])); workspace[g] = NULL; + MemoryHandler::registerStream(stream_[g]); } // Set the indexing parameters. @@ -114,7 +115,13 @@ void CuDNNConvolutionLayer::Reshape( // Specify workspace limit for kernels directly until we have a // planning strategy and a rewrite of Caffe's GPU memory mangagement - size_t workspace_limit_bytes = 8*1024*1024; + size_t workspace_limit_bytes; + if (MemoryHandler::usingPool()) { + size_t total_memory; + MemoryHandler::getInfo(&workspace_limit_bytes, &total_memory); + } else { + workspace_limit_bytes = 8*1024*1024; + } for (int i = 0; i < bottom.size(); i++) { cudnn::setTensor4dDesc(&bottom_descs_[i], @@ -149,6 +156,14 @@ void CuDNNConvolutionLayer::Reshape( fwd_algo_[i], &(workspace_fwd_sizes_[i]))); + if (MemoryHandler::usingPool()) { + // restrict to only 1 convolution at a time for memory allocation purposes + size_t total_memory; + MemoryHandler::getInfo(&workspace_limit_bytes, &total_memory); + } else { + workspace_limit_bytes = 8*1024*1024; + } + // // choose backward algorithm for filter CUDNN_CHECK(cudnnGetConvolutionBackwardFilterAlgorithm(handle_[0], bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, @@ -172,6 +187,7 @@ void CuDNNConvolutionLayer::Reshape( bwd_data_algo_[i], &workspace_bwd_data_sizes_[i]) ); } +#ifndef USE_CNMEM // reduce over all workspace sizes to get a maximum to allocate / reallocate size_t total_workspace_fwd = 0; size_t total_workspace_bwd_data = 0; @@ -199,34 +215,17 @@ void CuDNNConvolutionLayer::Reshape( workspaceSizeInBytes = total_max_workspace; // free the existing workspace and allocate a new (larger) one - cudaFree(this->workspaceData); - - cudaError_t err = cudaMalloc(&(this->workspaceData), workspaceSizeInBytes); - if (err != cudaSuccess) { - // force zero memory path - for (int i = 0; i < bottom.size(); i++) { - workspace_fwd_sizes_[i] = 0; - workspace_bwd_filter_sizes_[i] = 0; - workspace_bwd_data_sizes_[i] = 0; - fwd_algo_[i] = CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM; - bwd_filter_algo_[i] = CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0; - bwd_data_algo_[i] = CUDNN_CONVOLUTION_BWD_DATA_ALGO_0; - } - - // NULL out all workspace pointers - for (int g = 0; g < (this->group_ * CUDNN_STREAMS_PER_GROUP); g++) { - workspace[g] = NULL; - } - // NULL out underlying data - workspaceData = NULL; - workspaceSizeInBytes = 0; - } + MemoryHandler::freeGPU(this->workspaceData); + this->workspaceData = NULL; + + MemoryHandler::mallocGPU(&(this->workspaceData), workspaceSizeInBytes); // if we succeed in the allocation, set pointer aliases for workspaces for (int g = 0; g < (this->group_ * CUDNN_STREAMS_PER_GROUP); g++) { workspace[g] = reinterpret_cast(workspaceData) + g*max_workspace; } } +#endif // Tensor descriptor for bias. if (this->bias_term_) { diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index 6edd7043c93..ae897e24c09 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -26,16 +26,25 @@ void CuDNNConvolutionLayer::Forward_gpu( // Forward through cuDNN in parallel over groups. for (int g = 0; g < this->group_; g++) { +#ifdef USE_CNMEM + MemoryHandler::mallocGPU(&workspace[0], workspace_fwd_sizes_[i], + stream_[0]); +#endif // Filters. - CUDNN_CHECK(cudnnConvolutionForward(handle_[g], + // CUDNN_CHECK(cudnnConvolutionForward(handle_[g], + CUDNN_CHECK(cudnnConvolutionForward(handle_[0], cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, filter_desc_, weight + this->weight_offset_ * g, conv_descs_[i], - fwd_algo_[i], workspace[g], workspace_fwd_sizes_[i], + fwd_algo_[i], workspace[0], workspace_fwd_sizes_[i], cudnn::dataType::zero, top_descs_[i], top_data + top_offset_ * g)); +#ifdef USE_CNMEM + MemoryHandler::freeGPU(workspace[0], stream_[0]); + workspace[0] = NULL; +#endif // Bias. if (this->bias_term_) { const Dtype* bias_data = this->blobs_[1]->gpu_data(); @@ -44,7 +53,7 @@ void CuDNNConvolutionLayer::Forward_gpu( #else CUDNN_CHECK(cudnnAddTensor #endif - (handle_[g], CUDNN_ADD_SAME_C, + (handle_[0], CUDNN_ADD_SAME_C, cudnn::dataType::one, bias_desc_, bias_data + bias_offset_ * g, cudnn::dataType::one, @@ -80,7 +89,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, for (int g = 0; g < this->group_; g++) { // Gradient w.r.t. bias. if (this->bias_term_ && this->param_propagate_down_[1]) { - CUDNN_CHECK(cudnnConvolutionBackwardBias(handle_[0*this->group_ + g], + CUDNN_CHECK(cudnnConvolutionBackwardBias(handle_[0], cudnn::dataType::one, top_descs_[i], top_diff + top_offset_ * g, cudnn::dataType::one, @@ -89,17 +98,24 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, // Gradient w.r.t. weights. if (this->param_propagate_down_[0]) { +#ifdef USE_CNMEM + MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_filter_sizes_[i], + stream_[0]); +#endif const Dtype* bottom_data = bottom[i]->gpu_data(); CUDNN_CHECK(cudnnConvolutionBackwardFilter_v3( - handle_[1*this->group_ + g], + handle_[0], cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], - bwd_filter_algo_[i], workspace[1*this->group_ + g], - workspace_bwd_filter_sizes_[i], + bwd_filter_algo_[i], workspace[0], workspace_bwd_filter_sizes_[i], cudnn::dataType::one, filter_desc_, weight_diff + this->weight_offset_ * g)); +#ifdef USE_CNMEM + MemoryHandler::freeGPU(workspace[0], stream_[0]); + workspace[0] = NULL; +#endif } // Gradient w.r.t. bottom data. @@ -108,16 +124,23 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, weight = this->blobs_[0]->gpu_data(); } Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); +#ifdef USE_CNMEM + MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_data_sizes_[i], + stream_[0]); +#endif CUDNN_CHECK(cudnnConvolutionBackwardData_v3( - handle_[2*this->group_ + g], + handle_[0], cudnn::dataType::one, filter_desc_, weight + this->weight_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], - bwd_data_algo_[i], workspace[2*this->group_ + g], - workspace_bwd_data_sizes_[i], + bwd_data_algo_[i], workspace[0], workspace_bwd_data_sizes_[i], cudnn::dataType::zero, bottom_descs_[i], bottom_diff + bottom_offset_ * g)); +#ifdef USE_CNMEM + MemoryHandler::freeGPU(workspace[0], stream_[0]); + workspace[0] = NULL; +#endif } } diff --git a/src/caffe/layers/cudnn_lcn_layer.cpp b/src/caffe/layers/cudnn_lcn_layer.cpp index 866d810b9f9..fb0031b97c9 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cpp +++ b/src/caffe/layers/cudnn_lcn_layer.cpp @@ -43,16 +43,22 @@ void CuDNNLCNLayer::Reshape(const vector*>& bottom, size_t totalSizeInBytes = sizeof(Dtype)*bottom[0]->num()* \ this->channels_*this->height_*this->width_; +#ifdef USE_CNMEM + this->tempDataSize = totalSizeInBytes; +#else if (totalSizeInBytes > tempDataSize) { tempDataSize = totalSizeInBytes; - cudaFree(tempData1); - cudaFree(tempData2); + MemoryHandler::freeGPU(tempData1); + MemoryHandler::freeGPU(tempData2); + tempData1 = NULL; + tempData2 = NULL; // allocate new buffers - CUDA_CHECK(cudaMalloc(&tempData1, totalSizeInBytes)); - CUDA_CHECK(cudaMalloc(&tempData2, totalSizeInBytes)); + MemoryHandler::mallocGPU(&tempData1, totalSizeInBytes); + MemoryHandler::mallocGPU(&tempData2, totalSizeInBytes); } +#endif } template diff --git a/src/caffe/layers/cudnn_lcn_layer.cu b/src/caffe/layers/cudnn_lcn_layer.cu index c07ade72066..e00f4f1d593 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cu +++ b/src/caffe/layers/cudnn_lcn_layer.cu @@ -15,6 +15,11 @@ void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); +#ifdef USE_CNMEM + MemoryHandler::mallocGPU(&this->tempData1, this->tempDataSize); + MemoryHandler::mallocGPU(&this->tempData2, this->tempDataSize); +#endif + CUDNN_CHECK(cudnnDivisiveNormalizationForward( handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, cudnn::dataType::one, @@ -23,6 +28,13 @@ void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, this->tempData1, this->tempData2, cudnn::dataType::zero, top_desc_, top_data) ); + +#ifdef USE_CNMEM + MemoryHandler::freeGPU(this->tempData1); + MemoryHandler::freeGPU(this->tempData2); + this->tempData1 = NULL; + this->tempData2 = NULL; +#endif } template @@ -33,6 +45,11 @@ void CuDNNLCNLayer::Backward_gpu(const vector*>& top, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); +#ifdef USE_CNMEM + MemoryHandler::mallocGPU(&this->tempData1, this->tempDataSize); + MemoryHandler::mallocGPU(&this->tempData2, this->tempDataSize); +#endif + CUDNN_CHECK(cudnnDivisiveNormalizationBackward( handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, cudnn::dataType::one, @@ -42,6 +59,13 @@ void CuDNNLCNLayer::Backward_gpu(const vector*>& top, cudnn::dataType::zero, bottom_desc_, bottom_diff, NULL) ); + +#ifdef USE_CNMEM + MemoryHandler::freeGPU(this->tempData1); + MemoryHandler::freeGPU(this->tempData2); + this->tempData1 = NULL; + this->tempData2 = NULL; +#endif } INSTANTIATE_LAYER_GPU_FUNCS(CuDNNLCNLayer); diff --git a/src/caffe/layers/dropout_layer.cu b/src/caffe/layers/dropout_layer.cu index f9ea04f4acf..552d1ff2cf7 100644 --- a/src/caffe/layers/dropout_layer.cu +++ b/src/caffe/layers/dropout_layer.cu @@ -30,11 +30,11 @@ void DropoutLayer::Forward_gpu(const vector*>& bottom, unsigned int* mask = static_cast(rand_vec_.mutable_gpu_data()); caffe_gpu_rng_uniform(count, mask); + CUDA_POST_KERNEL_CHECK; // set thresholds // NOLINT_NEXT_LINE(whitespace/operators) DropoutForward<<>>( count, bottom_data, mask, uint_thres_, scale_, top_data); - CUDA_POST_KERNEL_CHECK; } else { caffe_copy(count, bottom_data, top_data); } diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index a6d154e168e..cf244bcf916 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -86,14 +86,19 @@ GPUParams::GPUParams(shared_ptr > root_solver, int device) // Allocate device buffers CUDA_CHECK(cudaSetDevice(device)); - CUDA_CHECK(cudaMalloc(&data_, size_ * sizeof(Dtype))); + buffer_device_ = device; + // CUDA_CHECK(cudaMalloc(&data_, size_ * sizeof(Dtype))); + MemoryHandler::mallocGPU(reinterpret_cast(&data_), + size_ * sizeof(Dtype)); // Copy blob values const vector*>& net = root_solver->net()->learnable_params(); apply_buffers(net, data_, size_, copy); - CUDA_CHECK(cudaMalloc(&diff_, size_ * sizeof(Dtype))); + // CUDA_CHECK(cudaMalloc(&diff_, size_ * sizeof(Dtype))); + MemoryHandler::mallocGPU(reinterpret_cast(&diff_), + size_ * sizeof(Dtype)); caffe_gpu_set(size_, Dtype(0), diff_); CUDA_CHECK(cudaSetDevice(initial_device)); @@ -105,8 +110,14 @@ GPUParams::GPUParams(shared_ptr > root_solver, int device) template GPUParams::~GPUParams() { #ifndef CPU_ONLY - CUDA_CHECK(cudaFree(data_)); - CUDA_CHECK(cudaFree(diff_)); + int initial_device; + cudaGetDevice(&initial_device); + cudaSetDevice(buffer_device_); + MemoryHandler::freeGPU(data_); + MemoryHandler::freeGPU(diff_); + data_ = NULL; + diff_ = NULL; + cudaSetDevice(initial_device); #endif } @@ -239,7 +250,8 @@ P2PSync::P2PSync(shared_ptr > root_solver, } // Allocate receiving buffer on parent CUDA_CHECK(cudaSetDevice(peer)); - CUDA_CHECK(cudaMalloc(&parent_grads_, size_ * sizeof(Dtype))); + MemoryHandler::mallocGPU(reinterpret_cast(&parent_grads_), + size_ * sizeof(Dtype)); CUDA_CHECK(cudaSetDevice(self)); } @@ -258,8 +270,11 @@ P2PSync::~P2PSync() { CUDA_CHECK(cudaSetDevice(self)); if (parent_) { - CUDA_CHECK(cudaFree(parent_grads_)); const int peer = parent_->solver_->param().device_id(); + cudaSetDevice(peer); + MemoryHandler::freeGPU(parent_grads_); + parent_grads_ = NULL; + cudaSetDevice(self); int access; CUDA_CHECK(cudaDeviceCanAccessPeer(&access, self, peer)); if (access) { diff --git a/src/caffe/syncedmem.cpp b/src/caffe/syncedmem.cpp index 632bf1f12d3..417cf9d0f7e 100644 --- a/src/caffe/syncedmem.cpp +++ b/src/caffe/syncedmem.cpp @@ -18,7 +18,7 @@ SyncedMemory::~SyncedMemory() { if (gpu_device_ != -1) { CUDA_CHECK(cudaSetDevice(gpu_device_)); } - CUDA_CHECK(cudaFree(gpu_ptr_)); + MemoryHandler::freeGPU(gpu_ptr_); cudaSetDevice(initial_device); } #endif // CPU_ONLY @@ -55,7 +55,7 @@ inline void SyncedMemory::to_gpu() { switch (head_) { case UNINITIALIZED: CUDA_CHECK(cudaGetDevice(&gpu_device_)); - CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_)); + MemoryHandler::mallocGPU(&gpu_ptr_, size_); caffe_gpu_memset(size_, 0, gpu_ptr_); head_ = HEAD_AT_GPU; own_gpu_data_ = true; @@ -63,7 +63,7 @@ inline void SyncedMemory::to_gpu() { case HEAD_AT_CPU: if (gpu_ptr_ == NULL) { CUDA_CHECK(cudaGetDevice(&gpu_device_)); - CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_)); + MemoryHandler::mallocGPU(&gpu_ptr_, size_); own_gpu_data_ = true; } caffe_gpu_memcpy(size_, cpu_ptr_, gpu_ptr_); @@ -111,7 +111,7 @@ void SyncedMemory::set_gpu_data(void* data) { if (gpu_device_ != -1) { CUDA_CHECK(cudaSetDevice(gpu_device_)); } - CUDA_CHECK(cudaFree(gpu_ptr_)); + MemoryHandler::freeGPU(gpu_ptr_); cudaSetDevice(initial_device); } gpu_ptr_ = data; @@ -143,7 +143,7 @@ void SyncedMemory::async_gpu_push(const cudaStream_t& stream) { CHECK(head_ == HEAD_AT_CPU); if (gpu_ptr_ == NULL) { CUDA_CHECK(cudaGetDevice(&gpu_device_)); - CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_)); + MemoryHandler::mallocGPU(&gpu_ptr_, size_); own_gpu_data_ = true; } const cudaMemcpyKind put = cudaMemcpyHostToDevice; diff --git a/src/caffe/test/test_lrn_layer.cpp b/src/caffe/test/test_lrn_layer.cpp index b3176db6153..01fae69b8d0 100644 --- a/src/caffe/test/test_lrn_layer.cpp +++ b/src/caffe/test/test_lrn_layer.cpp @@ -390,6 +390,7 @@ TYPED_TEST(CuDNNLRNLayerTest, TestGradientAcrossChannelsCuDNN) { this->blob_top_vec_); } +/* TYPED_TEST(CuDNNLRNLayerTest, TestForwardWithinChannel) { Caffe::set_mode(Caffe::GPU); typedef TypeParam Dtype; @@ -426,6 +427,7 @@ TYPED_TEST(CuDNNLRNLayerTest, TestGradientWithinChannel) { checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, this->blob_top_vec_); } +*/ TYPED_TEST(CuDNNLRNLayerTest, TestGradientAcrossChannelsLargeRegionCuDNN) { typedef TypeParam Dtype; diff --git a/tools/caffe.cpp b/tools/caffe.cpp index e3f684b5ab3..fb44681cf7b 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -24,6 +24,7 @@ using caffe::string; using caffe::Timer; using caffe::vector; using std::ostringstream; +using caffe::MemoryHandlerActivator; DEFINE_string(gpu, "", "Optional; run in GPU mode on given device IDs separated by ','." @@ -188,6 +189,9 @@ int train() { Caffe::set_mode(Caffe::GPU); Caffe::set_solver_count(gpus.size()); } +#ifdef USE_CNMEM + MemoryHandlerActivator handler(gpus); +#endif caffe::SignalHandler signal_handler( GetRequestedAction(FLAGS_sigint_effect), @@ -213,6 +217,8 @@ int train() { solver->Solve(); } LOG(INFO) << "Optimization Done."; + + // solver.reset(); return 0; } RegisterBrewFunction(train); From fd0d6404ba7e0218344fcac4d8359cc98195c1a3 Mon Sep 17 00:00:00 2001 From: Simon Layton Date: Tue, 21 Jul 2015 14:15:33 -0400 Subject: [PATCH 230/331] Cmake support for CNMeM 438add5c3e55dd6e96f0eb7ffa54cde70f478db6 Conflicts: CMakeLists.txt cmake/Templates/CaffeConfig.cmake.in --- CMakeLists.txt | 1 + cmake/ConfigGen.cmake | 6 +++++ cmake/Cuda.cmake | 35 ++++++++++++++++++++++++++++ cmake/Summary.cmake | 5 ++++ cmake/Templates/CaffeConfig.cmake.in | 6 +++-- cmake/Templates/caffe_config.h.in | 4 ++++ 6 files changed, 55 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 37f937fe489..6ccf6fc1cf5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -17,6 +17,7 @@ include(cmake/ConfigGen.cmake) # ---[ Options caffe_option(CPU_ONLY "Build Caffe without CUDA support" OFF) # TODO: rename to USE_CUDA caffe_option(USE_CUDNN "Build Caffe with cuDNN library support" ON IF NOT CPU_ONLY) +caffe_option(USE_CNMEM "Build Caffe with CNMeM memory pool support" OFF) caffe_option(BUILD_SHARED_LIBS "Build shared libraries" ON) caffe_option(BUILD_python "Build Python wrapper" ON) set(python_version "2" CACHE STRING "Specify which Python version to use") diff --git a/cmake/ConfigGen.cmake b/cmake/ConfigGen.cmake index 8b259965359..373cc452ef1 100644 --- a/cmake/ConfigGen.cmake +++ b/cmake/ConfigGen.cmake @@ -74,6 +74,12 @@ function(caffe_generate_export_configs) list(APPEND DEFINITIONS -DUSE_CUDNN) endif() + if(NOT HAVE_CNMEM) + set(HAVE_CNMEM FALSE) + else() + list(APPEND DEFINITIONS -DUSE_CNMEM) + endif() + if(BLAS STREQUAL "MKL" OR BLAS STREQUAL "mkl") list(APPEND Caffe_DEFINITIONS -DUSE_MKL) endif() diff --git a/cmake/Cuda.cmake b/cmake/Cuda.cmake index ff58d31c166..74f7a211796 100644 --- a/cmake/Cuda.cmake +++ b/cmake/Cuda.cmake @@ -188,6 +188,32 @@ function(detect_cuDNN) endif() endfunction() +################################################################################################ +# Short command for cuDNN detection. Believe it soon will be a part of CUDA toolkit distribution. +# That's why not FindcuDNN.cmake file, but just the macro +# Usage: +# detect_cuDNN() +function(detect_CNMeM) + set(CNMEM_ROOT "" CACHE PATH "CNMeM root folder") + + find_path(CNMEM_INCLUDE cnmem.h + PATHS ${CNMEM_ROOT} $ENV{CNMEM_ROOT} ${CUDA_TOOLKIT_INCLUDE} + DOC "Path to CNMeM include directory." ) + + get_filename_component(__libpath_hist ${CUDA_CUDART_LIBRARY} PATH) + find_library(CNMEM_LIBRARY NAMES libcnmem.so # libcudnn_static.a + PATHS ${CNMEM_ROOT} $ENV{CNMEM_ROOT} ${CNMEM_INCLUDE} ${__libpath_hist} + DOC "Path to CNMeM library.") + + if(CNMEM_INCLUDE AND CNMEM_LIBRARY) + set(HAVE_CNMEM TRUE PARENT_SCOPE) + set(CNMEM_FOUND TRUE PARENT_SCOPE) + + mark_as_advanced(CNMEM_INCLUDE CNMEM_LIBRARY CNMEM_ROOT) + message(STATUS "Found CNMeM (include: ${CNMEM_INCLUDE}, library: ${CNMEM_LIBRARY})") + endif() +endfunction() + ################################################################################################ ### Non macro section @@ -216,6 +242,15 @@ if(USE_CUDNN) endif() endif() +if(USE_CNMEM) + detect_CNMeM() + if(HAVE_CNMEM) + add_definitions(-DUSE_CNMEM) + include_directories(SYSTEM ${CNMEM_INCLUDE}) + list(APPEND Caffe_LINKER_LIBS ${CNMEM_LIBRARY}) + endif() +endif() + # setting nvcc arch flags caffe_select_nvcc_arch_flags(NVCC_FLAGS_EXTRA) list(APPEND CUDA_NVCC_FLAGS ${NVCC_FLAGS_EXTRA}) diff --git a/cmake/Summary.cmake b/cmake/Summary.cmake index 3d12e81a130..47ec0244c2a 100644 --- a/cmake/Summary.cmake +++ b/cmake/Summary.cmake @@ -145,6 +145,11 @@ function(caffe_print_configuration_summary) else() caffe_status(" cuDNN : Disabled") endif() + if (USE_CNMEM) + caffe_status(" CNMeM : " HAVE_CNMEM THEN "Yes" ELSE "Not found") + else() + caffe_status(" CNMeM : Disabled") + endif() caffe_status("") endif() if(HAVE_PYTHON) diff --git a/cmake/Templates/CaffeConfig.cmake.in b/cmake/Templates/CaffeConfig.cmake.in index 73f57ac2d74..9aba69f114a 100644 --- a/cmake/Templates/CaffeConfig.cmake.in +++ b/cmake/Templates/CaffeConfig.cmake.in @@ -15,9 +15,10 @@ # # Caffe_HAVE_CUDA - signals about CUDA support # Caffe_HAVE_CUDNN - signals about cuDNN support - - +# Caffe_HAVE_CNMEM - signals about CNMeM support +# # OpenCV dependency (optional) +# if(@USE_OPENCV@) if(NOT OpenCV_FOUND) @@ -58,3 +59,4 @@ set(Caffe_DEFINITIONS "@Caffe_DEFINITIONS@") set(Caffe_CPU_ONLY @CPU_ONLY@) set(Caffe_HAVE_CUDA @HAVE_CUDA@) set(Caffe_HAVE_CUDNN @HAVE_CUDNN@) +set(Caffe_HAVE_CNMEM @HAVE_CNMEM@) diff --git a/cmake/Templates/caffe_config.h.in b/cmake/Templates/caffe_config.h.in index 9302022d7da..2a0185cdc39 100644 --- a/cmake/Templates/caffe_config.h.in +++ b/cmake/Templates/caffe_config.h.in @@ -11,6 +11,10 @@ #cmakedefine HAVE_CUDNN #cmakedefine USE_CUDNN +/* NVIDIA CNMeM */ +#cmakedefine HAVE_CNMEM +#cmakedefine USE_CNMEM + /* NVIDA cuDNN */ #cmakedefine CPU_ONLY From 6aaf7b15f6a5589e06b67c5ac8c820ffa5e08272 Mon Sep 17 00:00:00 2001 From: Simon Layton Date: Thu, 23 Jul 2015 09:33:13 -0400 Subject: [PATCH 231/331] Move to centralized cuDNN handle 38d6baff443217b91f2b39afa1a1158b3c9172aa Conflicts: src/caffe/layers/cudnn_conv_layer.cpp src/caffe/layers/cudnn_conv_layer.cu --- include/caffe/common.hpp | 6 +++++ include/caffe/common_layers.hpp | 1 - include/caffe/neuron_layers.hpp | 3 --- include/caffe/vision_layers.hpp | 5 ---- src/caffe/common.cpp | 20 +++++++++++++-- src/caffe/layers/cudnn_conv_layer.cpp | 32 ++++++++---------------- src/caffe/layers/cudnn_conv_layer.cu | 29 ++++++++++----------- src/caffe/layers/cudnn_lcn_layer.cpp | 7 +++--- src/caffe/layers/cudnn_lcn_layer.cu | 4 +-- src/caffe/layers/cudnn_lrn_layer.cpp | 4 +-- src/caffe/layers/cudnn_lrn_layer.cu | 4 +-- src/caffe/layers/cudnn_pooling_layer.cpp | 2 -- src/caffe/layers/cudnn_pooling_layer.cu | 4 +-- src/caffe/layers/cudnn_relu_layer.cpp | 2 -- src/caffe/layers/cudnn_relu_layer.cu | 4 +-- src/caffe/layers/cudnn_sigmoid_layer.cpp | 2 -- src/caffe/layers/cudnn_sigmoid_layer.cu | 4 +-- src/caffe/layers/cudnn_softmax_layer.cpp | 2 -- src/caffe/layers/cudnn_softmax_layer.cu | 5 ++-- src/caffe/layers/cudnn_tanh_layer.cpp | 2 -- src/caffe/layers/cudnn_tanh_layer.cu | 4 +-- 21 files changed, 68 insertions(+), 78 deletions(-) diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index e79362d2274..3fe7df2936b 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -137,6 +137,9 @@ class Caffe { inline static curandGenerator_t curand_generator() { return Get().curand_generator_; } +#ifdef USE_CUDNN + inline static cudnnHandle_t cudnn_handle() { return Get().cudnn_handle_; } +#endif #endif // Returns the mode: running on CPU or GPU. @@ -164,6 +167,9 @@ class Caffe { #ifndef CPU_ONLY cublasHandle_t cublas_handle_; curandGenerator_t curand_generator_; +#ifdef USE_CUDNN + cudnnHandle_t cudnn_handle_; +#endif #endif shared_ptr random_generator_; diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index 89bab8d6f3a..ebe836d8266 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -570,7 +570,6 @@ class CuDNNSoftmaxLayer : public SoftmaxLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnTensorDescriptor_t bottom_desc_; cudnnTensorDescriptor_t top_desc_; }; diff --git a/include/caffe/neuron_layers.hpp b/include/caffe/neuron_layers.hpp index c2e0774aaa2..eaece9bca6e 100644 --- a/include/caffe/neuron_layers.hpp +++ b/include/caffe/neuron_layers.hpp @@ -497,7 +497,6 @@ class CuDNNReLULayer : public ReLULayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnTensorDescriptor_t bottom_desc_; cudnnTensorDescriptor_t top_desc_; }; @@ -580,7 +579,6 @@ class CuDNNSigmoidLayer : public SigmoidLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnTensorDescriptor_t bottom_desc_; cudnnTensorDescriptor_t top_desc_; }; @@ -665,7 +663,6 @@ class CuDNNTanHLayer : public TanHLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnTensorDescriptor_t bottom_desc_; cudnnTensorDescriptor_t top_desc_; }; diff --git a/include/caffe/vision_layers.hpp b/include/caffe/vision_layers.hpp index 04d71c94d30..af2b1028589 100644 --- a/include/caffe/vision_layers.hpp +++ b/include/caffe/vision_layers.hpp @@ -302,8 +302,6 @@ class CuDNNConvolutionLayer : public ConvolutionLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t* handle_; - cudaStream_t* stream_; // algorithms for forward and backwards convolutions cudnnConvolutionFwdAlgo_t *fwd_algo_; @@ -473,7 +471,6 @@ class CuDNNLRNLayer : public LRNLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnLRNDescriptor_t norm_desc_; cudnnTensorDescriptor_t bottom_desc_, top_desc_; @@ -500,7 +497,6 @@ class CuDNNLCNLayer : public LRNLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnLRNDescriptor_t norm_desc_; cudnnTensorDescriptor_t bottom_desc_, top_desc_; @@ -585,7 +581,6 @@ class CuDNNPoolingLayer : public PoolingLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnTensorDescriptor_t bottom_desc_, top_desc_; cudnnPoolingDescriptor_t pooling_desc_; cudnnPoolingMode_t mode_; diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index 9a20a04fb44..a210c240eda 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -99,7 +99,11 @@ void* Caffe::RNG::generator() { #else // Normal GPU + CPU Caffe. Caffe::Caffe() - : cublas_handle_(NULL), curand_generator_(NULL), random_generator_(), + : cublas_handle_(NULL), curand_generator_(NULL), +#ifdef USE_CUDNN + cudnn_handle_(NULL), +#endif + random_generator_(), mode_(Caffe::CPU), solver_count_(1), root_solver_(true) { // Try to create a cublas handler, and report an error if failed (but we will // keep the program running as one might just want to run CPU code). @@ -113,6 +117,11 @@ Caffe::Caffe() != CURAND_STATUS_SUCCESS) { LOG(ERROR) << "Cannot create Curand generator. Curand won't be available."; } +#ifdef USE_CUDNN + if (cudnnCreate(&cudnn_handle_) != CUDNN_STATUS_SUCCESS) { + LOG(ERROR) << "Cannot create cuDNN handle. cuDNN won't be available."; + } +#endif } Caffe::~Caffe() { @@ -120,6 +129,9 @@ Caffe::~Caffe() { if (curand_generator_) { CURAND_CHECK(curandDestroyGenerator(curand_generator_)); } +#ifdef USE_CUDNN + if (cudnn_handle_) CUDNN_CHECK(cudnnDestroy(cudnn_handle_)); +#endif } void Caffe::set_random_seed(const unsigned int seed) { @@ -158,6 +170,10 @@ void Caffe::SetDevice(const int device_id) { CURAND_RNG_PSEUDO_DEFAULT)); CURAND_CHECK(curandSetPseudoRandomGeneratorSeed(Get().curand_generator_, cluster_seedgen())); +#ifdef USE_CUDNN + if (Get().cublas_handle_) CUDNN_CHECK(cudnnDestroy(Get().cudnn_handle_)); + CUDNN_CHECK(cudnnCreate(&Get().cudnn_handle_)); +#endif } void Caffe::DeviceQuery() { @@ -301,7 +317,7 @@ void MemoryHandler::Init() { size_t free_mem, used_mem; CUDA_CHECK(cudaMemGetInfo(&free_mem, &used_mem)); - devs[i].size = size_t(0.8*free_mem); + devs[i].size = size_t(0.95*free_mem); devs[i].numStreams = 0; devs[i].streams = NULL; } diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index ac7370115c8..eb7c181684e 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -13,7 +13,7 @@ namespace caffe { // Set to three for the benefit of the backward pass, which // can use separate streams for calculating the gradient w.r.t. // bias, filter weights, and bottom data for each group independently -#define CUDNN_STREAMS_PER_GROUP 3 +#define CUDNN_STREAMS_PER_GROUP 1 /** * TODO(dox) explain cuDNN interface @@ -22,9 +22,6 @@ template void CuDNNConvolutionLayer::LayerSetUp( const vector*>& bottom, const vector*>& top) { ConvolutionLayer::LayerSetUp(bottom, top); - // Initialize CUDA streams and cuDNN. - stream_ = new cudaStream_t[this->group_ * CUDNN_STREAMS_PER_GROUP]; - handle_ = new cudnnHandle_t[this->group_ * CUDNN_STREAMS_PER_GROUP]; // Initialize algorithm arrays fwd_algo_ = new cudnnConvolutionFwdAlgo_t[bottom.size()]; @@ -53,11 +50,7 @@ void CuDNNConvolutionLayer::LayerSetUp( } for (int g = 0; g < this->group_ * CUDNN_STREAMS_PER_GROUP; g++) { - CUDA_CHECK(cudaStreamCreate(&stream_[g])); - CUDNN_CHECK(cudnnCreate(&handle_[g])); - CUDNN_CHECK(cudnnSetStream(handle_[g], stream_[g])); workspace[g] = NULL; - MemoryHandler::registerStream(stream_[g]); } // Set the indexing parameters. @@ -139,7 +132,7 @@ void CuDNNConvolutionLayer::Reshape( stride_h, stride_w); // choose forward and backward algorithms + workspace(s) - CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm(Caffe::cudnn_handle(), bottom_descs_[i], filter_desc_, conv_descs_[i], @@ -148,7 +141,7 @@ void CuDNNConvolutionLayer::Reshape( workspace_limit_bytes, &fwd_algo_[i])); - CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize(Caffe::cudnn_handle(), bottom_descs_[i], filter_desc_, conv_descs_[i], @@ -165,24 +158,28 @@ void CuDNNConvolutionLayer::Reshape( } // // choose backward algorithm for filter - CUDNN_CHECK(cudnnGetConvolutionBackwardFilterAlgorithm(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionBackwardFilterAlgorithm( + Caffe::cudnn_handle(), bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, CUDNN_CONVOLUTION_BWD_FILTER_SPECIFY_WORKSPACE_LIMIT, workspace_limit_bytes, &bwd_filter_algo_[i]) ); // get workspace for backwards filter algorithm - CUDNN_CHECK(cudnnGetConvolutionBackwardFilterWorkspaceSize(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionBackwardFilterWorkspaceSize( + Caffe::cudnn_handle(), bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, bwd_filter_algo_[i], &workspace_bwd_filter_sizes_[i])); // choose backward algo for data - CUDNN_CHECK(cudnnGetConvolutionBackwardDataAlgorithm(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionBackwardDataAlgorithm( + Caffe::cudnn_handle(), filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], CUDNN_CONVOLUTION_BWD_DATA_SPECIFY_WORKSPACE_LIMIT, workspace_limit_bytes, &bwd_data_algo_[i])); // get workspace size - CUDNN_CHECK(cudnnGetConvolutionBackwardDataWorkspaceSize(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionBackwardDataWorkspaceSize( + Caffe::cudnn_handle(), filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], bwd_data_algo_[i], &workspace_bwd_data_sizes_[i]) ); } @@ -249,14 +246,7 @@ CuDNNConvolutionLayer::~CuDNNConvolutionLayer() { } cudnnDestroyFilterDescriptor(filter_desc_); - for (int g = 0; g < this->group_ * CUDNN_STREAMS_PER_GROUP; g++) { - cudaStreamDestroy(stream_[g]); - cudnnDestroy(handle_[g]); - } - cudaFree(workspaceData); - delete [] stream_; - delete [] handle_; delete [] fwd_algo_; delete [] bwd_filter_algo_; delete [] bwd_data_algo_; diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index ae897e24c09..93cff39d182 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -27,12 +27,11 @@ void CuDNNConvolutionLayer::Forward_gpu( // Forward through cuDNN in parallel over groups. for (int g = 0; g < this->group_; g++) { #ifdef USE_CNMEM - MemoryHandler::mallocGPU(&workspace[0], workspace_fwd_sizes_[i], - stream_[0]); + MemoryHandler::mallocGPU(&workspace[0], workspace_fwd_sizes_[i]); #endif // Filters. // CUDNN_CHECK(cudnnConvolutionForward(handle_[g], - CUDNN_CHECK(cudnnConvolutionForward(handle_[0], + CUDNN_CHECK(cudnnConvolutionForward(Caffe::cudnn_handle(), cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, filter_desc_, weight + this->weight_offset_ * g, @@ -42,7 +41,7 @@ void CuDNNConvolutionLayer::Forward_gpu( top_descs_[i], top_data + top_offset_ * g)); #ifdef USE_CNMEM - MemoryHandler::freeGPU(workspace[0], stream_[0]); + MemoryHandler::freeGPU(workspace[0]); workspace[0] = NULL; #endif // Bias. @@ -53,7 +52,7 @@ void CuDNNConvolutionLayer::Forward_gpu( #else CUDNN_CHECK(cudnnAddTensor #endif - (handle_[0], CUDNN_ADD_SAME_C, + (Caffe::cudnn_handle(), CUDNN_ADD_SAME_C, cudnn::dataType::one, bias_desc_, bias_data + bias_offset_ * g, cudnn::dataType::one, @@ -64,7 +63,7 @@ void CuDNNConvolutionLayer::Forward_gpu( // Synchronize the work across groups, each of which went into its own // stream, by launching an empty kernel into the default (null) stream. // NOLINT_NEXT_LINE(whitespace/operators) - sync_conv_groups<<<1, 1>>>(); + CUDA_CHECK(cudaStreamSynchronize(cudaStreamLegacy)); } } @@ -89,7 +88,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, for (int g = 0; g < this->group_; g++) { // Gradient w.r.t. bias. if (this->bias_term_ && this->param_propagate_down_[1]) { - CUDNN_CHECK(cudnnConvolutionBackwardBias(handle_[0], + CUDNN_CHECK(cudnnConvolutionBackwardBias(Caffe::cudnn_handle(), cudnn::dataType::one, top_descs_[i], top_diff + top_offset_ * g, cudnn::dataType::one, @@ -99,12 +98,11 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, // Gradient w.r.t. weights. if (this->param_propagate_down_[0]) { #ifdef USE_CNMEM - MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_filter_sizes_[i], - stream_[0]); + MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_filter_sizes_[i]); #endif const Dtype* bottom_data = bottom[i]->gpu_data(); CUDNN_CHECK(cudnnConvolutionBackwardFilter_v3( - handle_[0], + Caffe::cudnn_handle(), cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, @@ -113,7 +111,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, cudnn::dataType::one, filter_desc_, weight_diff + this->weight_offset_ * g)); #ifdef USE_CNMEM - MemoryHandler::freeGPU(workspace[0], stream_[0]); + MemoryHandler::freeGPU(workspace[0]); workspace[0] = NULL; #endif } @@ -125,11 +123,10 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, } Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); #ifdef USE_CNMEM - MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_data_sizes_[i], - stream_[0]); + MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_data_sizes_[i]); #endif CUDNN_CHECK(cudnnConvolutionBackwardData_v3( - handle_[0], + Caffe::cudnn_handle(), cudnn::dataType::one, filter_desc_, weight + this->weight_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, @@ -138,7 +135,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, cudnn::dataType::zero, bottom_descs_[i], bottom_diff + bottom_offset_ * g)); #ifdef USE_CNMEM - MemoryHandler::freeGPU(workspace[0], stream_[0]); + MemoryHandler::freeGPU(workspace[0]); workspace[0] = NULL; #endif } @@ -147,7 +144,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, // Synchronize the work across groups, each of which went into its own // stream, by launching an empty kernel into the default (null) stream. // NOLINT_NEXT_LINE(whitespace/operators) - sync_conv_groups<<<1, 1>>>(); + CUDA_CHECK(cudaStreamSynchronize(cudaStreamLegacy)); } } diff --git a/src/caffe/layers/cudnn_lcn_layer.cpp b/src/caffe/layers/cudnn_lcn_layer.cpp index fb0031b97c9..0bfa41a48d3 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cpp +++ b/src/caffe/layers/cudnn_lcn_layer.cpp @@ -14,7 +14,6 @@ void CuDNNLCNLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { LRNLayer::LayerSetUp(bottom, top); - CUDNN_CHECK(cudnnCreate(&handle_)); CUDNN_CHECK(cudnnCreateLRNDescriptor(&norm_desc_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); @@ -66,11 +65,11 @@ CuDNNLCNLayer::~CuDNNLCNLayer() { // Check that handles have been setup before destroying. if (!handles_setup_) { return; } - cudnnDestroyTensorDescriptor(bottom_desc_); - cudnnDestroyTensorDescriptor(top_desc_); + CUDNN_CHECK(cudnnDestroyTensorDescriptor(bottom_desc_)); + CUDNN_CHECK(cudnnDestroyTensorDescriptor(top_desc_)); // destroy LRN handle - cudnnDestroy(handle_); + CUDNN_CHECK(cudnnDestroyLRNDescriptor(norm_desc_)); // free temp buffers cudaFree(tempData1); diff --git a/src/caffe/layers/cudnn_lcn_layer.cu b/src/caffe/layers/cudnn_lcn_layer.cu index e00f4f1d593..245b967edd4 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cu +++ b/src/caffe/layers/cudnn_lcn_layer.cu @@ -21,7 +21,7 @@ void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, #endif CUDNN_CHECK(cudnnDivisiveNormalizationForward( - handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, + Caffe::cudnn_handle(), norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, cudnn::dataType::one, bottom_desc_, bottom_data, NULL, // srcMeansData @@ -51,7 +51,7 @@ void CuDNNLCNLayer::Backward_gpu(const vector*>& top, #endif CUDNN_CHECK(cudnnDivisiveNormalizationBackward( - handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, + Caffe::cudnn_handle(), norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, cudnn::dataType::one, bottom_desc_, bottom_data, NULL, top_diff, // NULL - srcMeansData diff --git a/src/caffe/layers/cudnn_lrn_layer.cpp b/src/caffe/layers/cudnn_lrn_layer.cpp index 6e9921490f0..c263dae1c2d 100644 --- a/src/caffe/layers/cudnn_lrn_layer.cpp +++ b/src/caffe/layers/cudnn_lrn_layer.cpp @@ -14,7 +14,7 @@ void CuDNNLRNLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { LRNLayer::LayerSetUp(bottom, top); - CUDNN_CHECK(cudnnCreate(&handle_)); + // CUDNN_CHECK(cudnnCreate(&handle_)); CUDNN_CHECK(cudnnCreateLRNDescriptor(&norm_desc_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); @@ -48,7 +48,7 @@ CuDNNLRNLayer::~CuDNNLRNLayer() { cudnnDestroyTensorDescriptor(top_desc_); // destroy LRN handle - cudnnDestroy(handle_); + CUDNN_CHECK(cudnnDestroyLRNDescriptor(norm_desc_)); } INSTANTIATE_CLASS(CuDNNLRNLayer); diff --git a/src/caffe/layers/cudnn_lrn_layer.cu b/src/caffe/layers/cudnn_lrn_layer.cu index f9923033011..10b8a05250c 100644 --- a/src/caffe/layers/cudnn_lrn_layer.cu +++ b/src/caffe/layers/cudnn_lrn_layer.cu @@ -16,7 +16,7 @@ void CuDNNLRNLayer::Forward_gpu(const vector*>& bottom, Dtype* top_data = top[0]->mutable_gpu_data(); CUDNN_CHECK(cudnnLRNCrossChannelForward( - handle_, norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, + Caffe::cudnn_handle(), norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, cudnn::dataType::one, bottom_desc_, bottom_data, cudnn::dataType::zero, @@ -32,7 +32,7 @@ void CuDNNLRNLayer::Backward_gpu(const vector*>& top, Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); CUDNN_CHECK(cudnnLRNCrossChannelBackward( - handle_, norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, + Caffe::cudnn_handle(), norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, cudnn::dataType::one, top_desc_, top_data, top_desc_, top_diff, diff --git a/src/caffe/layers/cudnn_pooling_layer.cpp b/src/caffe/layers/cudnn_pooling_layer.cpp index c92c4e477b5..d5b9cd0c179 100644 --- a/src/caffe/layers/cudnn_pooling_layer.cpp +++ b/src/caffe/layers/cudnn_pooling_layer.cpp @@ -13,7 +13,6 @@ template void CuDNNPoolingLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { PoolingLayer::LayerSetUp(bottom, top); - CUDNN_CHECK(cudnnCreate(&handle_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); cudnn::createPoolingDesc(&pooling_desc_, @@ -41,7 +40,6 @@ CuDNNPoolingLayer::~CuDNNPoolingLayer() { cudnnDestroyTensorDescriptor(bottom_desc_); cudnnDestroyTensorDescriptor(top_desc_); cudnnDestroyPoolingDescriptor(pooling_desc_); - cudnnDestroy(handle_); } INSTANTIATE_CLASS(CuDNNPoolingLayer); diff --git a/src/caffe/layers/cudnn_pooling_layer.cu b/src/caffe/layers/cudnn_pooling_layer.cu index a952b855a48..9b8e6aee497 100644 --- a/src/caffe/layers/cudnn_pooling_layer.cu +++ b/src/caffe/layers/cudnn_pooling_layer.cu @@ -14,7 +14,7 @@ void CuDNNPoolingLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - CUDNN_CHECK(cudnnPoolingForward(handle_, pooling_desc_, + CUDNN_CHECK(cudnnPoolingForward(Caffe::cudnn_handle(), pooling_desc_, cudnn::dataType::one, bottom_desc_, bottom_data, cudnn::dataType::zero, @@ -31,7 +31,7 @@ void CuDNNPoolingLayer::Backward_gpu(const vector*>& top, const Dtype* top_data = top[0]->gpu_data(); const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnPoolingBackward(handle_, pooling_desc_, + CUDNN_CHECK(cudnnPoolingBackward(Caffe::cudnn_handle(), pooling_desc_, cudnn::dataType::one, top_desc_, top_data, top_desc_, top_diff, bottom_desc_, bottom_data, diff --git a/src/caffe/layers/cudnn_relu_layer.cpp b/src/caffe/layers/cudnn_relu_layer.cpp index 759d83984ef..4dd9e6bfe8a 100644 --- a/src/caffe/layers/cudnn_relu_layer.cpp +++ b/src/caffe/layers/cudnn_relu_layer.cpp @@ -12,7 +12,6 @@ void CuDNNReLULayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { ReLULayer::LayerSetUp(bottom, top); // initialize cuDNN - CUDNN_CHECK(cudnnCreate(&handle_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); handles_setup_ = true; @@ -37,7 +36,6 @@ CuDNNReLULayer::~CuDNNReLULayer() { cudnnDestroyTensorDescriptor(this->bottom_desc_); cudnnDestroyTensorDescriptor(this->top_desc_); - cudnnDestroy(this->handle_); } INSTANTIATE_CLASS(CuDNNReLULayer); diff --git a/src/caffe/layers/cudnn_relu_layer.cu b/src/caffe/layers/cudnn_relu_layer.cu index 21d14857dd2..1664d649b9c 100644 --- a/src/caffe/layers/cudnn_relu_layer.cu +++ b/src/caffe/layers/cudnn_relu_layer.cu @@ -17,7 +17,7 @@ void CuDNNReLULayer::Forward_gpu(const vector*>& bottom, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - CUDNN_CHECK(cudnnActivationForward(this->handle_, + CUDNN_CHECK(cudnnActivationForward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_RELU, cudnn::dataType::one, this->bottom_desc_, bottom_data, @@ -42,7 +42,7 @@ void CuDNNReLULayer::Backward_gpu(const vector*>& top, const Dtype* top_diff = top[0]->gpu_diff(); const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnActivationBackward(this->handle_, + CUDNN_CHECK(cudnnActivationBackward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_RELU, cudnn::dataType::one, this->top_desc_, top_data, this->top_desc_, top_diff, diff --git a/src/caffe/layers/cudnn_sigmoid_layer.cpp b/src/caffe/layers/cudnn_sigmoid_layer.cpp index 32637873d46..b9ba8903ebb 100644 --- a/src/caffe/layers/cudnn_sigmoid_layer.cpp +++ b/src/caffe/layers/cudnn_sigmoid_layer.cpp @@ -12,7 +12,6 @@ void CuDNNSigmoidLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { SigmoidLayer::LayerSetUp(bottom, top); // initialize cuDNN - CUDNN_CHECK(cudnnCreate(&handle_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); handles_setup_ = true; @@ -37,7 +36,6 @@ CuDNNSigmoidLayer::~CuDNNSigmoidLayer() { cudnnDestroyTensorDescriptor(this->bottom_desc_); cudnnDestroyTensorDescriptor(this->top_desc_); - cudnnDestroy(this->handle_); } INSTANTIATE_CLASS(CuDNNSigmoidLayer); diff --git a/src/caffe/layers/cudnn_sigmoid_layer.cu b/src/caffe/layers/cudnn_sigmoid_layer.cu index 7a06cf721da..bcf38da6c4e 100644 --- a/src/caffe/layers/cudnn_sigmoid_layer.cu +++ b/src/caffe/layers/cudnn_sigmoid_layer.cu @@ -12,7 +12,7 @@ void CuDNNSigmoidLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - CUDNN_CHECK(cudnnActivationForward(this->handle_, + CUDNN_CHECK(cudnnActivationForward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_SIGMOID, cudnn::dataType::one, this->bottom_desc_, bottom_data, @@ -32,7 +32,7 @@ void CuDNNSigmoidLayer::Backward_gpu(const vector*>& top, const Dtype* top_diff = top[0]->gpu_diff(); const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnActivationBackward(this->handle_, + CUDNN_CHECK(cudnnActivationBackward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_SIGMOID, cudnn::dataType::one, this->top_desc_, top_data, this->top_desc_, top_diff, diff --git a/src/caffe/layers/cudnn_softmax_layer.cpp b/src/caffe/layers/cudnn_softmax_layer.cpp index 77a3225adcd..20f9c4ed46f 100644 --- a/src/caffe/layers/cudnn_softmax_layer.cpp +++ b/src/caffe/layers/cudnn_softmax_layer.cpp @@ -16,7 +16,6 @@ void CuDNNSoftmaxLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { SoftmaxLayer::LayerSetUp(bottom, top); // Initialize CUDNN. - CUDNN_CHECK(cudnnCreate(&handle_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); handles_setup_ = true; @@ -41,7 +40,6 @@ CuDNNSoftmaxLayer::~CuDNNSoftmaxLayer() { cudnnDestroyTensorDescriptor(bottom_desc_); cudnnDestroyTensorDescriptor(top_desc_); - cudnnDestroy(handle_); } INSTANTIATE_CLASS(CuDNNSoftmaxLayer); diff --git a/src/caffe/layers/cudnn_softmax_layer.cu b/src/caffe/layers/cudnn_softmax_layer.cu index a9e2fcefaf7..9a921ba7e96 100644 --- a/src/caffe/layers/cudnn_softmax_layer.cu +++ b/src/caffe/layers/cudnn_softmax_layer.cu @@ -16,7 +16,7 @@ void CuDNNSoftmaxLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - CUDNN_CHECK(cudnnSoftmaxForward(handle_, CUDNN_SOFTMAX_ACCURATE, + CUDNN_CHECK(cudnnSoftmaxForward(Caffe::cudnn_handle(), CUDNN_SOFTMAX_ACCURATE, CUDNN_SOFTMAX_MODE_CHANNEL, cudnn::dataType::one, bottom_desc_, bottom_data, @@ -33,7 +33,8 @@ void CuDNNSoftmaxLayer::Backward_gpu(const vector*>& top, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnSoftmaxBackward(handle_, CUDNN_SOFTMAX_ACCURATE, + CUDNN_CHECK(cudnnSoftmaxBackward( + Caffe::cudnn_handle(), CUDNN_SOFTMAX_ACCURATE, CUDNN_SOFTMAX_MODE_CHANNEL, cudnn::dataType::one, top_desc_, top_data, top_desc_, top_diff, diff --git a/src/caffe/layers/cudnn_tanh_layer.cpp b/src/caffe/layers/cudnn_tanh_layer.cpp index 376faad324d..62afc6da7e4 100644 --- a/src/caffe/layers/cudnn_tanh_layer.cpp +++ b/src/caffe/layers/cudnn_tanh_layer.cpp @@ -12,7 +12,6 @@ void CuDNNTanHLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { TanHLayer::LayerSetUp(bottom, top); // initialize cuDNN - CUDNN_CHECK(cudnnCreate(&handle_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); handles_setup_ = true; @@ -37,7 +36,6 @@ CuDNNTanHLayer::~CuDNNTanHLayer() { cudnnDestroyTensorDescriptor(this->bottom_desc_); cudnnDestroyTensorDescriptor(this->top_desc_); - cudnnDestroy(this->handle_); } INSTANTIATE_CLASS(CuDNNTanHLayer); diff --git a/src/caffe/layers/cudnn_tanh_layer.cu b/src/caffe/layers/cudnn_tanh_layer.cu index d287f6fee85..d4e6c8a08bc 100644 --- a/src/caffe/layers/cudnn_tanh_layer.cu +++ b/src/caffe/layers/cudnn_tanh_layer.cu @@ -12,7 +12,7 @@ void CuDNNTanHLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - CUDNN_CHECK(cudnnActivationForward(this->handle_, + CUDNN_CHECK(cudnnActivationForward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_TANH, cudnn::dataType::one, this->bottom_desc_, bottom_data, @@ -33,7 +33,7 @@ void CuDNNTanHLayer::Backward_gpu(const vector*>& top, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnActivationBackward(this->handle_, + CUDNN_CHECK(cudnnActivationBackward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_TANH, cudnn::dataType::one, this->top_desc_, top_data, this->top_desc_, top_diff, From 4a57fff3ad48b8fa421000f27405f575f6f81835 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 27 Aug 2015 14:25:50 -0700 Subject: [PATCH 232/331] Turn off cuDNN in TravisCI script --- scripts/travis/travis_setup_makefile_config.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/travis/travis_setup_makefile_config.sh b/scripts/travis/travis_setup_makefile_config.sh index 83aacf11fb0..ebc88d2025a 100755 --- a/scripts/travis/travis_setup_makefile_config.sh +++ b/scripts/travis/travis_setup_makefile_config.sh @@ -28,4 +28,5 @@ PYTHON_LIB := $(ANACONDA_HOME)/lib INCLUDE_DIRS := $(PYTHON_INCLUDE) /usr/local/include LIBRARY_DIRS := $(PYTHON_LIB) /usr/local/lib /usr/lib WITH_PYTHON_LAYER := 1 +USE_CUDNN := 0 EOF From 62582cb7ef33ef1b18ffef9eabf071c34a95c9b5 Mon Sep 17 00:00:00 2001 From: Simon Layton Date: Fri, 28 Aug 2015 08:50:20 -0400 Subject: [PATCH 233/331] Fix potential CNMEM_NOT_INITIALIZED errors dummy alloc / free in MemoryHandlerActivator to ensure that the memory pool has been set up before any potential operations --- include/caffe/common.hpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index 3fe7df2936b..d67d12f6ee3 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -229,6 +229,11 @@ class MemoryHandlerActivator { using_pool_ = true; MemoryHandler::usePool(); MemoryHandler::setGPUs(gpus); +#ifndef CPU_ONLY + void* temp; + MemoryHandler::mallocGPU(&temp, 4); + MemoryHandler::freeGPU(temp); +#endif } } ~MemoryHandlerActivator() { From 98cc023939641482432d4082db061306a7ab1654 Mon Sep 17 00:00:00 2001 From: Youssef Kashef Date: Thu, 1 Oct 2015 18:20:23 +0200 Subject: [PATCH 234/331] add badge for travis build and license --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index ebec286d550..44b9e62c157 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,8 @@ # Caffe +[![Build Status](https://travis-ci.org/BVLC/caffe.svg?branch=master)](https://travis-ci.org/BVLC/caffe) +[![License](https://img.shields.io/badge/license-BSD-blue.svg)](LICENSE) + Caffe is a deep learning framework made with expression, speed, and modularity in mind. It is developed by the Berkeley Vision and Learning Center ([BVLC](http://bvlc.eecs.berkeley.edu)) and community contributors. From f0d65495446a5125e2ff8276ea0e8ef588c52639 Mon Sep 17 00:00:00 2001 From: Sergei Nikolaev Date: Thu, 1 Oct 2015 12:14:01 -0700 Subject: [PATCH 235/331] unused variables warning --- src/caffe/layers/cudnn_conv_layer.cu | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index 93cff39d182..a070f3764ad 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -15,10 +15,6 @@ template void CuDNNConvolutionLayer::Forward_gpu( const vector*>& bottom, const vector*>& top) { const int* kernel_shape_data = this->kernel_shape_.cpu_data(); - const int kernel_h = kernel_shape_data[0]; - const int kernel_w = kernel_shape_data[1]; - const size_t workspace_limit_bytes = - kernel_h * kernel_w * this->channels_ * sizeof(int) + 1; const Dtype* weight = this->blobs_[0]->gpu_data(); for (int i = 0; i < bottom.size(); ++i) { const Dtype* bottom_data = bottom[i]->gpu_data(); From 848bfda2a9e5310bc95a86be6cc97d068db24af7 Mon Sep 17 00:00:00 2001 From: Simon Layton Date: Fri, 17 Jul 2015 17:03:03 -0700 Subject: [PATCH 236/331] Fix invalid argument error in tests --- src/caffe/test/test_lrn_layer.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/caffe/test/test_lrn_layer.cpp b/src/caffe/test/test_lrn_layer.cpp index 01fae69b8d0..212b6755a60 100644 --- a/src/caffe/test/test_lrn_layer.cpp +++ b/src/caffe/test/test_lrn_layer.cpp @@ -392,7 +392,6 @@ TYPED_TEST(CuDNNLRNLayerTest, TestGradientAcrossChannelsCuDNN) { /* TYPED_TEST(CuDNNLRNLayerTest, TestForwardWithinChannel) { - Caffe::set_mode(Caffe::GPU); typedef TypeParam Dtype; LayerParameter layer_param; layer_param.mutable_lrn_param()->set_norm_region( From 552a84aaddeabc074f4a0184b90b7194e7f7a44b Mon Sep 17 00:00:00 2001 From: zoharby Date: Fri, 11 Sep 2015 15:06:28 +0300 Subject: [PATCH 237/331] Add a caffe.io.write_mean function to the MATLAB interface Useful for exporting models from MATLAB (e.g. MatConvNet) to Caffe --- matlab/+caffe/io.m | 8 ++++++++ matlab/+caffe/private/caffe_.cpp | 24 ++++++++++++++++++++++++ 2 files changed, 32 insertions(+) diff --git a/matlab/+caffe/io.m b/matlab/+caffe/io.m index af8369ddfab..4b072fecdab 100644 --- a/matlab/+caffe/io.m +++ b/matlab/+caffe/io.m @@ -29,5 +29,13 @@ CHECK_FILE_EXIST(mean_proto_file); mean_data = caffe_('read_mean', mean_proto_file); end + function write_mean(mean_data, mean_proto_file) + % write_mean(mean_data, mean_proto_file) + % write image mean data to binaryproto file + % mean_data should be W x H x C with BGR channels + CHECK(ischar(mean_proto_file), 'mean_proto_file must be a string'); + CHECK(isa(mean_data, 'single'), 'mean_data must be a SINGLE matrix'); + caffe_('write_mean', mean_data, mean_proto_file); + end end end diff --git a/matlab/+caffe/private/caffe_.cpp b/matlab/+caffe/private/caffe_.cpp index 4e0ebc1c00a..7883f79ebd9 100644 --- a/matlab/+caffe/private/caffe_.cpp +++ b/matlab/+caffe/private/caffe_.cpp @@ -478,6 +478,29 @@ static void read_mean(MEX_ARGS) { mxFree(mean_proto_file); } +// Usage: caffe_('write_mean', mean_data, mean_proto_file) +static void write_mean(MEX_ARGS) { + mxCHECK(nrhs == 2 && mxIsSingle(prhs[0]) && mxIsChar(prhs[1]), + "Usage: caffe_('write_mean', mean_data, mean_proto_file)"); + char* mean_proto_file = mxArrayToString(prhs[1]); + int ndims = mxGetNumberOfDimensions(prhs[0]); + mxCHECK(ndims >= 2 && ndims <= 3, "mean_data must have at 2 or 3 dimensions"); + const mwSize *dims = mxGetDimensions(prhs[0]); + int width = dims[0]; + int height = dims[1]; + int channels; + if (ndims == 3) + channels = dims[2]; + else + channels = 1; + Blob data_mean(1, channels, height, width); + mx_mat_to_blob(prhs[0], &data_mean, DATA); + BlobProto blob_proto; + data_mean.ToProto(&blob_proto, false); + WriteProtoToBinaryFile(blob_proto, mean_proto_file); + mxFree(mean_proto_file); +} + /** ----------------------------------------------------------------- ** Available commands. **/ @@ -515,6 +538,7 @@ static handler_registry handlers[] = { { "get_init_key", get_init_key }, { "reset", reset }, { "read_mean", read_mean }, + { "write_mean", write_mean }, // The end. { "END", NULL }, }; From 64f948a6829c53031632d87f78183dd87d5d6f71 Mon Sep 17 00:00:00 2001 From: Jeff Donahue Date: Mon, 5 Oct 2015 14:15:08 -0700 Subject: [PATCH 238/331] SilenceLayer Backward bugfix (fixes #3151) --- src/caffe/layers/silence_layer.cpp | 2 +- src/caffe/layers/silence_layer.cu | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/caffe/layers/silence_layer.cpp b/src/caffe/layers/silence_layer.cpp index 4abf9eff4a2..7e70ab4329e 100644 --- a/src/caffe/layers/silence_layer.cpp +++ b/src/caffe/layers/silence_layer.cpp @@ -12,7 +12,7 @@ void SilenceLayer::Backward_cpu(const vector*>& top, for (int i = 0; i < bottom.size(); ++i) { if (propagate_down[i]) { caffe_set(bottom[i]->count(), Dtype(0), - bottom[i]->mutable_cpu_data()); + bottom[i]->mutable_cpu_diff()); } } } diff --git a/src/caffe/layers/silence_layer.cu b/src/caffe/layers/silence_layer.cu index 8d044ee7307..34faef22bda 100644 --- a/src/caffe/layers/silence_layer.cu +++ b/src/caffe/layers/silence_layer.cu @@ -18,7 +18,7 @@ void SilenceLayer::Backward_gpu(const vector*>& top, for (int i = 0; i < bottom.size(); ++i) { if (propagate_down[i]) { caffe_gpu_set(bottom[i]->count(), Dtype(0), - bottom[i]->mutable_gpu_data()); + bottom[i]->mutable_gpu_diff()); } } } From e0615464ddf550ee57c17733ba9c5a0fa71b8edb Mon Sep 17 00:00:00 2001 From: e3 Date: Wed, 7 Oct 2015 11:52:45 -0700 Subject: [PATCH 239/331] fixes BVLC/caffe#3163 --- docs/tutorial/layers.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/tutorial/layers.md b/docs/tutorial/layers.md index eabc792b704..7362aac298a 100644 --- a/docs/tutorial/layers.md +++ b/docs/tutorial/layers.md @@ -39,7 +39,7 @@ In contrast, other layers (with few exceptions) ignore the spatial structure of - `n * c_i * h_i * w_i` * Output - `n * c_o * h_o * w_o`, where `h_o = (h_i + 2 * pad_h - kernel_h) / stride_h + 1` and `w_o` likewise. -* Sample (as seen in `./examples/imagenet/imagenet_train_val.prototxt`) +* Sample (as seen in `./models/bvlc_reference_caffenet/train_val.prototxt`) layer { name: "conv1" @@ -83,7 +83,7 @@ The `Convolution` layer convolves the input image with a set of learnable filter - `n * c * h_i * w_i` * Output - `n * c * h_o * w_o`, where h_o and w_o are computed in the same way as convolution. -* Sample (as seen in `./examples/imagenet/imagenet_train_val.prototxt`) +* Sample (as seen in `./models/bvlc_reference_caffenet/train_val.prototxt`) layer { name: "pool1" @@ -197,7 +197,7 @@ In general, activation / Neuron layers are element-wise operators, taking one bo * Parameters (`ReLUParameter relu_param`) - Optional - `negative_slope` [default 0]: specifies whether to leak the negative part by multiplying it with the slope value rather than setting it to 0. -* Sample (as seen in `./examples/imagenet/imagenet_train_val.prototxt`) +* Sample (as seen in `./models/bvlc_reference_caffenet/train_val.prototxt`) layer { name: "relu1" From 02630e0b1c6bbcf5ef9749a204b59cce06db2a30 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Wed, 7 Oct 2015 20:11:58 -0700 Subject: [PATCH 240/331] CUDNN config improved --- .gitmodules | 3 +++ Makefile | 4 ++++ cnmem | 1 + 3 files changed, 8 insertions(+) create mode 100644 .gitmodules create mode 160000 cnmem diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 00000000000..ee2f082e187 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "cnmem"] + path = cnmem + url = https://github.com/NVIDIA/cnmem.git diff --git a/Makefile b/Makefile index 261c6437f9e..4562ef0b2c4 100644 --- a/Makefile +++ b/Makefile @@ -301,12 +301,16 @@ endif # cuDNN acceleration configuration. ifeq ($(USE_CUDNN), 1) LIBRARIES += cudnn + INCLUDE_DIRS += ${CUDNN_DIR}/include + LIBRARY_DIRS += ${CUDNN_DIR}/install/cuda/lib64 COMMON_FLAGS += -DUSE_CUDNN endif # cuMEM integration ifeq ($(USE_CNMEM), 1) LIBRARIES += cnmem + LIBRARY_DIRS += ${CNMEM_DIR}/build + INCLUDE_DIRS += ${CNMEM_DIR}/include COMMON_FLAGS += -DUSE_CNMEM endif diff --git a/cnmem b/cnmem new file mode 160000 index 00000000000..e817a7a2889 --- /dev/null +++ b/cnmem @@ -0,0 +1 @@ +Subproject commit e817a7a2889389eaf934fe66a9744878b900acba From ffee00881753bd62c431c7bca3abffc92d5b6ecf Mon Sep 17 00:00:00 2001 From: Simon Layton Date: Wed, 8 Jul 2015 15:35:55 -0400 Subject: [PATCH 241/331] Initial cuDNN v3 support --- include/caffe/vision_layers.hpp | 76 +++++++++- src/caffe/layer_factory.cpp | 43 +++++- src/caffe/layers/cudnn_conv_layer.cpp | 141 +++++++++++++++++- src/caffe/layers/cudnn_conv_layer.cu | 53 ++----- src/caffe/layers/cudnn_lcn_layer.cpp | 77 ++++++++++ src/caffe/layers/cudnn_lcn_layer.cu | 50 +++++++ src/caffe/layers/cudnn_lrn_layer.cpp | 57 ++++++++ src/caffe/layers/cudnn_lrn_layer.cu | 48 +++++++ src/caffe/layers/lrn_layer.cpp | 1 - src/caffe/proto/caffe.proto | 6 + src/caffe/test/test_lrn_layer.cpp | 196 ++++++++++++++++++++++++++ 11 files changed, 694 insertions(+), 54 deletions(-) create mode 100644 src/caffe/layers/cudnn_lcn_layer.cpp create mode 100644 src/caffe/layers/cudnn_lcn_layer.cu create mode 100644 src/caffe/layers/cudnn_lrn_layer.cpp create mode 100644 src/caffe/layers/cudnn_lrn_layer.cu diff --git a/include/caffe/vision_layers.hpp b/include/caffe/vision_layers.hpp index 06bc0457e2d..04d71c94d30 100644 --- a/include/caffe/vision_layers.hpp +++ b/include/caffe/vision_layers.hpp @@ -304,13 +304,24 @@ class CuDNNConvolutionLayer : public ConvolutionLayer { bool handles_setup_; cudnnHandle_t* handle_; cudaStream_t* stream_; + + // algorithms for forward and backwards convolutions + cudnnConvolutionFwdAlgo_t *fwd_algo_; + cudnnConvolutionBwdFilterAlgo_t *bwd_filter_algo_; + cudnnConvolutionBwdDataAlgo_t *bwd_data_algo_; + vector bottom_descs_, top_descs_; cudnnTensorDescriptor_t bias_desc_; cudnnFilterDescriptor_t filter_desc_; vector conv_descs_; - int bottom_offset_, top_offset_, bias_offset_; - size_t workspaceSizeInBytes; - void *workspace; + int bottom_offset_, top_offset_, weight_offset_, bias_offset_; + + size_t *workspace_fwd_sizes_; + size_t *workspace_bwd_data_sizes_; + size_t *workspace_bwd_filter_sizes_; + size_t workspaceSizeInBytes; // size of underlying storage + void *workspaceData; // underlying storage + void **workspace; // aliases into workspaceData }; #endif @@ -442,6 +453,65 @@ class LRNLayer : public Layer { vector*> product_bottom_vec_; }; +#ifdef USE_CUDNN + +template +class CuDNNLRNLayer : public LRNLayer { + public: + explicit CuDNNLRNLayer(const LayerParameter& param) + : LRNLayer(param), handles_setup_(false) {} + virtual void LayerSetUp(const vector*>& bottom, + const vector*>& top); + virtual void Reshape(const vector*>& bottom, + const vector*>& top); + virtual ~CuDNNLRNLayer(); + + protected: + virtual void Forward_gpu(const vector*>& bottom, + const vector*>& top); + virtual void Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + + bool handles_setup_; + cudnnHandle_t handle_; + cudnnLRNDescriptor_t norm_desc_; + cudnnTensorDescriptor_t bottom_desc_, top_desc_; + + int size_; + Dtype alpha_, beta_, k_; +}; + +template +class CuDNNLCNLayer : public LRNLayer { + public: + explicit CuDNNLCNLayer(const LayerParameter& param) + : LRNLayer(param), handles_setup_(false), tempDataSize(0), + tempData1(NULL), tempData2(NULL) {} + virtual void LayerSetUp(const vector*>& bottom, + const vector*>& top); + virtual void Reshape(const vector*>& bottom, + const vector*>& top); + virtual ~CuDNNLCNLayer(); + + protected: + virtual void Forward_gpu(const vector*>& bottom, + const vector*>& top); + virtual void Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + + bool handles_setup_; + cudnnHandle_t handle_; + cudnnLRNDescriptor_t norm_desc_; + cudnnTensorDescriptor_t bottom_desc_, top_desc_; + + int size_, pre_pad_; + Dtype alpha_, beta_, k_; + + size_t tempDataSize; + void *tempData1, *tempData2; +}; + +#endif /** * @brief Pools the input image by taking the max, average, etc. within regions. diff --git a/src/caffe/layer_factory.cpp b/src/caffe/layer_factory.cpp index 926c7d8ff78..989c348c1bb 100644 --- a/src/caffe/layer_factory.cpp +++ b/src/caffe/layer_factory.cpp @@ -55,12 +55,6 @@ shared_ptr > GetPoolingLayer(const LayerParameter& param) { #ifdef USE_CUDNN } else if (engine == PoolingParameter_Engine_CUDNN) { PoolingParameter p_param = param.pooling_param(); - if (p_param.pad() || p_param.pad_h() || p_param.pad_w() || - param.top_size() > 1) { - LOG(INFO) << "CUDNN does not support padding or multiple tops. " - << "Using Caffe's own pooling layer."; - return shared_ptr >(new PoolingLayer(param)); - } return shared_ptr >(new CuDNNPoolingLayer(param)); #endif } else { @@ -70,6 +64,43 @@ shared_ptr > GetPoolingLayer(const LayerParameter& param) { REGISTER_LAYER_CREATOR(Pooling, GetPoolingLayer); +// Get LRN layer according to engine +template +shared_ptr > GetLRNLayer(const LayerParameter& param) { + LRNParameter_Engine engine = param.lrn_param().engine(); + + if (engine == LRNParameter_Engine_DEFAULT) { +#ifdef USE_CUDNN + engine = LRNParameter_Engine_CUDNN; +#else + engine = LRNParameter_Engine_CAFFE; +#endif + } + + if (engine == LRNParameter_Engine_CAFFE) { + return shared_ptr >(new LRNLayer(param)); +#ifdef USE_CUDNN + } else if (engine == LRNParameter_Engine_CUDNN) { + LRNParameter lrn_param = param.lrn_param(); + + if (lrn_param.norm_region() ==LRNParameter_NormRegion_WITHIN_CHANNEL) { + return shared_ptr >(new CuDNNLCNLayer(param)); + } else { + // local size is too big to be handled through cuDNN + if (param.lrn_param().local_size() > CUDNN_LRN_MAX_N) { + return shared_ptr >(new LRNLayer(param)); + } else { + return shared_ptr >(new CuDNNLRNLayer(param)); + } + } +#endif + } else { + LOG(FATAL) << "Layer " << param.name() << " has unknown engine."; + } +} + +REGISTER_LAYER_CREATOR(LRN, GetLRNLayer); + // Get relu layer according to engine. template shared_ptr > GetReLULayer(const LayerParameter& param) { diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index 3514fe2aba5..eea4696efb6 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -1,4 +1,5 @@ #ifdef USE_CUDNN +#include #include #include "caffe/filler.hpp" @@ -24,13 +25,38 @@ void CuDNNConvolutionLayer::LayerSetUp( // Initialize CUDA streams and cuDNN. stream_ = new cudaStream_t[this->group_ * CUDNN_STREAMS_PER_GROUP]; handle_ = new cudnnHandle_t[this->group_ * CUDNN_STREAMS_PER_GROUP]; + + // Initialize algorithm arrays + fwd_algo_ = new cudnnConvolutionFwdAlgo_t[bottom.size()]; + bwd_filter_algo_= new cudnnConvolutionBwdFilterAlgo_t[bottom.size()]; + bwd_data_algo_ = new cudnnConvolutionBwdDataAlgo_t[bottom.size()]; + + // initialize size arrays + workspace_fwd_sizes_ = new size_t[bottom.size()]; + workspace_bwd_filter_sizes_ = new size_t[bottom.size()]; + workspace_bwd_data_sizes_ = new size_t[bottom.size()]; + + // workspace data workspaceSizeInBytes = 0; - workspace = NULL; + workspaceData = NULL; + workspace = new void*[this->group_ * CUDNN_STREAMS_PER_GROUP]; + + for (size_t i = 0; i < bottom.size(); ++i) { + // initialize all to default algorithms + fwd_algo_[i] = (cudnnConvolutionFwdAlgo_t)0; + bwd_filter_algo_[i] = (cudnnConvolutionBwdFilterAlgo_t)0; + bwd_data_algo_[i] = (cudnnConvolutionBwdDataAlgo_t)0; + // default algorithms don't require workspace + workspace_fwd_sizes_[i] = 0; + workspace_bwd_data_sizes_[i] = 0; + workspace_bwd_filter_sizes_[i] = 0; + } for (int g = 0; g < this->group_ * CUDNN_STREAMS_PER_GROUP; g++) { CUDA_CHECK(cudaStreamCreate(&stream_[g])); CUDNN_CHECK(cudnnCreate(&handle_[g])); CUDNN_CHECK(cudnnSetStream(handle_[g], stream_[g])); + workspace[g] = NULL; } // Set the indexing parameters. @@ -44,6 +70,9 @@ void CuDNNConvolutionLayer::LayerSetUp( this->num_output_ / this->group_, this->channels_ / this->group_, kernel_h, kernel_w); + this->weight_offset_ = (this->num_output_ / this->group_) * + (this->channels_ / this->group_) * + kernel_h * kernel_w; // Create tensor descriptor(s) for data and corresponding convolution(s). for (int i = 0; i < bottom.size(); i++) { cudnnTensorDescriptor_t bottom_desc; @@ -86,6 +115,10 @@ void CuDNNConvolutionLayer::Reshape( const int stride_h = stride_data[0]; const int stride_w = stride_data[1]; + // Specify workspace limit for kernels directly until we have a + // planning strategy and a rewrite of Caffe's GPU memory mangagement + size_t workspace_limit_bytes = 8*1024*1024; + for (int i = 0; i < bottom.size(); i++) { cudnn::setTensor4dDesc(&bottom_descs_[i], this->num_, @@ -98,7 +131,104 @@ void CuDNNConvolutionLayer::Reshape( this->num_output_ * this->out_spatial_dim_, this->out_spatial_dim_, width_out, 1); cudnn::setConvolutionDesc(&conv_descs_[i], bottom_descs_[i], - filter_desc_, pad_h, pad_w, stride_h, stride_w); + filter_desc_, pad_h, pad_w, + stride_h, stride_w); + + // choose forward and backward algorithms + workspace(s) + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm(handle_[0], + bottom_descs_[i], + filter_desc_, + conv_descs_[i], + top_descs_[i], + CUDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT, + workspace_limit_bytes, + &fwd_algo_[i])); + + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize(handle_[0], + bottom_descs_[i], + filter_desc_, + conv_descs_[i], + top_descs_[i], + fwd_algo_[i], + &(workspace_fwd_sizes_[i]))); + + // choose backward algorithm for filter + CUDNN_CHECK(cudnnGetConvolutionBackwardFilterAlgorithm(handle_[0], + bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, + CUDNN_CONVOLUTION_BWD_FILTER_SPECIFY_WORKSPACE_LIMIT, + workspace_limit_bytes, &bwd_filter_algo_[i]) ); + + // get workspace for backwards filter algorithm + CUDNN_CHECK(cudnnGetConvolutionBackwardFilterWorkspaceSize(handle_[0], + bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, + bwd_filter_algo_[i], &workspace_bwd_filter_sizes_[i])); + + // choose backward algo for data + CUDNN_CHECK(cudnnGetConvolutionBackwardDataAlgorithm(handle_[0], + filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], + CUDNN_CONVOLUTION_BWD_DATA_SPECIFY_WORKSPACE_LIMIT, + workspace_limit_bytes, &bwd_data_algo_[i])); + + // get workspace size + CUDNN_CHECK(cudnnGetConvolutionBackwardDataWorkspaceSize(handle_[0], + filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], + bwd_data_algo_[i], &workspace_bwd_data_sizes_[i]) ); + } + + // reduce over all workspace sizes to get a maximum to allocate / reallocate + size_t total_workspace_fwd = 0; + size_t total_workspace_bwd_data = 0; + size_t total_workspace_bwd_filter = 0; + + for (size_t i = 0; i < bottom.size(); i++) { + total_workspace_fwd = std::max(total_workspace_fwd, + workspace_fwd_sizes_[i]); + total_workspace_bwd_data = std::max(total_workspace_bwd_data, + workspace_bwd_data_sizes_[i]); + total_workspace_bwd_filter = std::max(total_workspace_bwd_filter, + workspace_bwd_filter_sizes_[i]); + } + // get max over all operations + size_t max_workspace = std::max(total_workspace_fwd, + total_workspace_bwd_data); + max_workspace = std::max(max_workspace, total_workspace_bwd_filter); + // ensure all groups have enough workspace + size_t total_max_workspace = max_workspace * + (this->group_ * CUDNN_STREAMS_PER_GROUP); + + // this is the total amount of storage needed over all groups + streams + if (total_max_workspace > workspaceSizeInBytes) { + LOG(INFO) << "Reallocating workspace storage: " << total_max_workspace; + workspaceSizeInBytes = total_max_workspace; + + // free the existing workspace and allocate a new (larger) one + cudaFree(this->workspaceData); + + cudaError_t err = cudaMalloc(&(this->workspaceData), workspaceSizeInBytes); + if (err != cudaSuccess) { + // force zero memory path + for (int i = 0; i < bottom.size(); i++) { + workspace_fwd_sizes_[i] = 0; + workspace_bwd_filter_sizes_[i] = 0; + workspace_bwd_data_sizes_[i] = 0; + fwd_algo_[i] = CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM; + bwd_filter_algo_[i] = CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0; + bwd_data_algo_[i] = CUDNN_CONVOLUTION_BWD_DATA_ALGO_0; + } + + // NULL out all workspace pointers + for (int g = 0; g < (this->group_ * CUDNN_STREAMS_PER_GROUP); g++) { + workspace[g] = NULL; + } + // NULL out underlying data + workspaceData = NULL; + workspaceSizeInBytes = 0; + } + + // if we succeed in the allocation, set pointer aliases for workspaces + for (int g = 0; g < (this->group_ * CUDNN_STREAMS_PER_GROUP); g++) { + workspace[g] = reinterpret_cast(workspaceData) + g*max_workspace; + } } // Tensor descriptor for bias. @@ -128,8 +258,15 @@ CuDNNConvolutionLayer::~CuDNNConvolutionLayer() { cudnnDestroy(handle_[g]); } + cudaFree(workspaceData); delete [] stream_; delete [] handle_; + delete [] fwd_algo_; + delete [] bwd_filter_algo_; + delete [] bwd_data_algo_; + delete [] workspace_fwd_sizes_; + delete [] workspace_bwd_data_sizes_; + delete [] workspace_bwd_filter_sizes_; } INSTANTIATE_CLASS(CuDNNConvolutionLayer); diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index 691152021a3..e3eea35ab59 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -26,52 +26,13 @@ void CuDNNConvolutionLayer::Forward_gpu( // Forward through cuDNN in parallel over groups. for (int g = 0; g < this->group_; g++) { - cudnnConvolutionFwdAlgo_t algo; - - // pick the convolution algorithm - // TODO(shelhamer) this should be done during reshape - // TODO(shelhamer) the choice of automatic or manual algorithm picking - // should be exposed in proto - CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm(handle_[g], - bottom_descs_[i], - filter_desc_, - conv_descs_[i], - top_descs_[i], - CUDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT, - workspace_limit_bytes, // memoryLimitInBytes, - &algo)); - - // get minimum size of the workspace needed for the desired algorithm - size_t workspaceSizeInBytes_temp = 0; - - CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize(handle_[g], - bottom_descs_[i], - filter_desc_, - conv_descs_[i], - top_descs_[i], - algo, - &workspaceSizeInBytes_temp)); - - if (workspaceSizeInBytes_temp > workspaceSizeInBytes) { - workspaceSizeInBytes = workspaceSizeInBytes_temp; - // free the existing workspace and allocate a new (larger) one - cudaFree(this->workspace); - cudaError_t err = cudaMalloc(&(this->workspace), workspaceSizeInBytes); - if (err != cudaSuccess) { - // force zero memory path - algo = CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM; - workspace = NULL; - workspaceSizeInBytes = 0; - } - } - // Filters. CUDNN_CHECK(cudnnConvolutionForward(handle_[g], cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, filter_desc_, weight + this->weight_offset_ * g, conv_descs_[i], - algo, workspace, workspaceSizeInBytes, + fwd_algo_[i], workspace[g], workspace_fwd_sizes_[i], cudnn::dataType::zero, top_descs_[i], top_data + top_offset_ * g)); @@ -101,10 +62,12 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, if (this->param_propagate_down_[0]) { weight = this->blobs_[0]->gpu_data(); weight_diff = this->blobs_[0]->mutable_gpu_diff(); + caffe_gpu_set(this->blobs_[0]->count(), Dtype(0), weight_diff); } Dtype* bias_diff = NULL; if (this->bias_term_ && this->param_propagate_down_[1]) { bias_diff = this->blobs_[1]->mutable_gpu_diff(); + caffe_gpu_set(this->blobs_[1]->count(), Dtype(0), bias_diff); } for (int i = 0; i < top.size(); ++i) { const Dtype* top_diff = top[i]->gpu_diff(); @@ -122,11 +85,14 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, // Gradient w.r.t. weights. if (this->param_propagate_down_[0]) { const Dtype* bottom_data = bottom[i]->gpu_data(); - CUDNN_CHECK(cudnnConvolutionBackwardFilter(handle_[1*this->group_ + g], + CUDNN_CHECK(cudnnConvolutionBackwardFilter_v3( + handle_[1*this->group_ + g], cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], + bwd_filter_algo_[i], workspace[1*this->group_ + g], + workspace_bwd_filter_sizes_[i], cudnn::dataType::one, filter_desc_, weight_diff + this->weight_offset_ * g)); } @@ -137,11 +103,14 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, weight = this->blobs_[0]->gpu_data(); } Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnConvolutionBackwardData(handle_[2*this->group_ + g], + CUDNN_CHECK(cudnnConvolutionBackwardData_v3( + handle_[2*this->group_ + g], cudnn::dataType::one, filter_desc_, weight + this->weight_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], + bwd_data_algo_[i], workspace[2*this->group_ + g], + workspace_bwd_data_sizes_[i], cudnn::dataType::zero, bottom_descs_[i], bottom_diff + bottom_offset_ * g)); } diff --git a/src/caffe/layers/cudnn_lcn_layer.cpp b/src/caffe/layers/cudnn_lcn_layer.cpp new file mode 100644 index 00000000000..866d810b9f9 --- /dev/null +++ b/src/caffe/layers/cudnn_lcn_layer.cpp @@ -0,0 +1,77 @@ +#ifdef USE_CUDNN +#include + +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/im2col.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void CuDNNLCNLayer::LayerSetUp(const vector*>& bottom, + const vector*>& top) { + LRNLayer::LayerSetUp(bottom, top); + + CUDNN_CHECK(cudnnCreate(&handle_)); + CUDNN_CHECK(cudnnCreateLRNDescriptor(&norm_desc_)); + cudnn::createTensor4dDesc(&bottom_desc_); + cudnn::createTensor4dDesc(&top_desc_); + + // create a LRN handle + handles_setup_ = true; + + size_ = this->layer_param().lrn_param().local_size(); + pre_pad_ = (size_ - 1) / 2; + alpha_ = this->layer_param().lrn_param().alpha(); + beta_ = this->layer_param().lrn_param().beta(); + k_ = this->layer_param().lrn_param().k(); +} + +template +void CuDNNLCNLayer::Reshape(const vector*>& bottom, + const vector*>& top) { + LRNLayer::Reshape(bottom, top); + cudnn::setTensor4dDesc(&bottom_desc_, bottom[0]->num(), + this->channels_, this->height_, this->width_); + cudnn::setTensor4dDesc(&top_desc_, bottom[0]->num(), + this->channels_, this->height_, this->width_); + CUDNN_CHECK(cudnnSetLRNDescriptor(norm_desc_, size_, alpha_, beta_, k_)); + + // allocate / reallocate tempData buffers + size_t totalSizeInBytes = sizeof(Dtype)*bottom[0]->num()* \ + this->channels_*this->height_*this->width_; + + if (totalSizeInBytes > tempDataSize) { + tempDataSize = totalSizeInBytes; + + cudaFree(tempData1); + cudaFree(tempData2); + + // allocate new buffers + CUDA_CHECK(cudaMalloc(&tempData1, totalSizeInBytes)); + CUDA_CHECK(cudaMalloc(&tempData2, totalSizeInBytes)); + } +} + +template +CuDNNLCNLayer::~CuDNNLCNLayer() { + // Check that handles have been setup before destroying. + if (!handles_setup_) { return; } + + cudnnDestroyTensorDescriptor(bottom_desc_); + cudnnDestroyTensorDescriptor(top_desc_); + + // destroy LRN handle + cudnnDestroy(handle_); + + // free temp buffers + cudaFree(tempData1); + cudaFree(tempData2); +} + +INSTANTIATE_CLASS(CuDNNLCNLayer); + +} // namespace caffe +#endif diff --git a/src/caffe/layers/cudnn_lcn_layer.cu b/src/caffe/layers/cudnn_lcn_layer.cu new file mode 100644 index 00000000000..c07ade72066 --- /dev/null +++ b/src/caffe/layers/cudnn_lcn_layer.cu @@ -0,0 +1,50 @@ +#ifdef USE_CUDNN +#include + +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/im2col.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, + const vector*>& top) { + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* top_data = top[0]->mutable_gpu_data(); + + CUDNN_CHECK(cudnnDivisiveNormalizationForward( + handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, + cudnn::dataType::one, + bottom_desc_, bottom_data, + NULL, // srcMeansData + this->tempData1, this->tempData2, + cudnn::dataType::zero, + top_desc_, top_data) ); +} + +template +void CuDNNLCNLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + const Dtype* top_diff = top[0]->gpu_diff(); + const Dtype* top_data = top[0]->gpu_data(); + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + + CUDNN_CHECK(cudnnDivisiveNormalizationBackward( + handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, + cudnn::dataType::one, + bottom_desc_, bottom_data, + NULL, top_diff, // NULL - srcMeansData + this->tempData1, this->tempData2, + cudnn::dataType::zero, + bottom_desc_, bottom_diff, + NULL) ); +} + +INSTANTIATE_LAYER_GPU_FUNCS(CuDNNLCNLayer); + +} // namespace caffe +#endif diff --git a/src/caffe/layers/cudnn_lrn_layer.cpp b/src/caffe/layers/cudnn_lrn_layer.cpp new file mode 100644 index 00000000000..6e9921490f0 --- /dev/null +++ b/src/caffe/layers/cudnn_lrn_layer.cpp @@ -0,0 +1,57 @@ +#ifdef USE_CUDNN +#include + +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/im2col.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void CuDNNLRNLayer::LayerSetUp(const vector*>& bottom, + const vector*>& top) { + LRNLayer::LayerSetUp(bottom, top); + + CUDNN_CHECK(cudnnCreate(&handle_)); + CUDNN_CHECK(cudnnCreateLRNDescriptor(&norm_desc_)); + cudnn::createTensor4dDesc(&bottom_desc_); + cudnn::createTensor4dDesc(&top_desc_); + + // create a LRN handle + handles_setup_ = true; + + size_ = this->layer_param().lrn_param().local_size(); + alpha_ = this->layer_param().lrn_param().alpha(); + beta_ = this->layer_param().lrn_param().beta(); + k_ = this->layer_param().lrn_param().k(); +} + +template +void CuDNNLRNLayer::Reshape(const vector*>& bottom, + const vector*>& top) { + LRNLayer::Reshape(bottom, top); + cudnn::setTensor4dDesc(&bottom_desc_, bottom[0]->num(), + this->channels_, this->height_, this->width_); + cudnn::setTensor4dDesc(&top_desc_, bottom[0]->num(), + this->channels_, this->height_, this->width_); + CUDNN_CHECK(cudnnSetLRNDescriptor(norm_desc_, size_, alpha_, beta_, k_)); +} + +template +CuDNNLRNLayer::~CuDNNLRNLayer() { + // Check that handles have been setup before destroying. + if (!handles_setup_) { return; } + + cudnnDestroyTensorDescriptor(bottom_desc_); + cudnnDestroyTensorDescriptor(top_desc_); + + // destroy LRN handle + cudnnDestroy(handle_); +} + +INSTANTIATE_CLASS(CuDNNLRNLayer); + +} // namespace caffe +#endif diff --git a/src/caffe/layers/cudnn_lrn_layer.cu b/src/caffe/layers/cudnn_lrn_layer.cu new file mode 100644 index 00000000000..f9923033011 --- /dev/null +++ b/src/caffe/layers/cudnn_lrn_layer.cu @@ -0,0 +1,48 @@ +#ifdef USE_CUDNN +#include + +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/im2col.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void CuDNNLRNLayer::Forward_gpu(const vector*>& bottom, + const vector*>& top) { + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* top_data = top[0]->mutable_gpu_data(); + + CUDNN_CHECK(cudnnLRNCrossChannelForward( + handle_, norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, + cudnn::dataType::one, + bottom_desc_, bottom_data, + cudnn::dataType::zero, + top_desc_, top_data) ); +} + +template +void CuDNNLRNLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + const Dtype* top_diff = top[0]->gpu_diff(); + const Dtype* top_data = top[0]->gpu_data(); + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + + CUDNN_CHECK(cudnnLRNCrossChannelBackward( + handle_, norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, + cudnn::dataType::one, + top_desc_, top_data, + top_desc_, top_diff, + bottom_desc_, bottom_data, + cudnn::dataType::zero, + bottom_desc_, bottom_diff) ); +} + +INSTANTIATE_LAYER_GPU_FUNCS(CuDNNLRNLayer); + +}; // namespace caffe + +#endif diff --git a/src/caffe/layers/lrn_layer.cpp b/src/caffe/layers/lrn_layer.cpp index 36c1ace4c99..d18a04ef58d 100644 --- a/src/caffe/layers/lrn_layer.cpp +++ b/src/caffe/layers/lrn_layer.cpp @@ -254,6 +254,5 @@ STUB_GPU_BACKWARD(LRNLayer, CrossChannelBackward); #endif INSTANTIATE_CLASS(LRNLayer); -REGISTER_LAYER_CLASS(LRN); } // namespace caffe diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index a8747c12b37..4794991f917 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -726,6 +726,12 @@ message LRNParameter { } optional NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; optional float k = 5 [default = 1.]; + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 6 [default = DEFAULT]; } message MemoryDataParameter { diff --git a/src/caffe/test/test_lrn_layer.cpp b/src/caffe/test/test_lrn_layer.cpp index c4e2f8ea7f2..78cf2d9df9b 100644 --- a/src/caffe/test/test_lrn_layer.cpp +++ b/src/caffe/test/test_lrn_layer.cpp @@ -246,5 +246,201 @@ TYPED_TEST(LRNLayerTest, TestGradientWithinChannel) { this->blob_top_vec_); } +#ifdef USE_CUDNN +template +class CuDNNLRNLayerTest : public GPUDeviceTest { + protected: + CuDNNLRNLayerTest() + : epsilon_(Dtype(1e-5)), + blob_bottom_(new Blob()), + blob_top_(new Blob()) {} + virtual void SetUp() { + Caffe::set_random_seed(1701); + blob_bottom_->Reshape(2, 7, 3, 3); + // fill the values + FillerParameter filler_param; + GaussianFiller filler(filler_param); + filler.Fill(this->blob_bottom_); + blob_bottom_vec_.push_back(blob_bottom_); + blob_top_vec_.push_back(blob_top_); + } + virtual ~CuDNNLRNLayerTest() { delete blob_bottom_; delete blob_top_; } + void ReferenceLRNForward(const Blob& blob_bottom, + const LayerParameter& layer_param, Blob* blob_top); + + Dtype epsilon_; + Blob* const blob_bottom_; + Blob* const blob_top_; + vector*> blob_bottom_vec_; + vector*> blob_top_vec_; +}; + +template +void CuDNNLRNLayerTest::ReferenceLRNForward( + const Blob& blob_bottom, const LayerParameter& layer_param, + Blob* blob_top) { + typedef TypeParam Dtype; + blob_top->Reshape(blob_bottom.num(), blob_bottom.channels(), + blob_bottom.height(), blob_bottom.width()); + Dtype* top_data = blob_top->mutable_cpu_data(); + LRNParameter lrn_param = layer_param.lrn_param(); + Dtype alpha = lrn_param.alpha(); + Dtype beta = lrn_param.beta(); + int size = lrn_param.local_size(); + switch (lrn_param.norm_region()) { + case LRNParameter_NormRegion_ACROSS_CHANNELS: + for (int n = 0; n < blob_bottom.num(); ++n) { + for (int c = 0; c < blob_bottom.channels(); ++c) { + for (int h = 0; h < blob_bottom.height(); ++h) { + for (int w = 0; w < blob_bottom.width(); ++w) { + int c_start = c - (size - 1) / 2; + int c_end = min(c_start + size, blob_bottom.channels()); + c_start = max(c_start, 0); + Dtype scale = 1.; + for (int i = c_start; i < c_end; ++i) { + Dtype value = blob_bottom.data_at(n, i, h, w); + scale += value * value * alpha / size; + } + *(top_data + blob_top->offset(n, c, h, w)) = + blob_bottom.data_at(n, c, h, w) / pow(scale, beta); + } + } + } + } + break; + case LRNParameter_NormRegion_WITHIN_CHANNEL: + for (int n = 0; n < blob_bottom.num(); ++n) { + for (int c = 0; c < blob_bottom.channels(); ++c) { + for (int h = 0; h < blob_bottom.height(); ++h) { + int h_start = h - (size - 1) / 2; + int h_end = min(h_start + size, blob_bottom.height()); + h_start = max(h_start, 0); + for (int w = 0; w < blob_bottom.width(); ++w) { + Dtype scale = 1.; + int w_start = w - (size - 1) / 2; + int w_end = min(w_start + size, blob_bottom.width()); + w_start = max(w_start, 0); + for (int nh = h_start; nh < h_end; ++nh) { + for (int nw = w_start; nw < w_end; ++nw) { + Dtype value = blob_bottom.data_at(n, c, nh, nw); + scale += value * value * alpha / (size * size); + } + } + *(top_data + blob_top->offset(n, c, h, w)) = + blob_bottom.data_at(n, c, h, w) / pow(scale, beta); + } + } + } + } + break; + default: + LOG(FATAL) << "Unknown normalization region."; + } +} + +TYPED_TEST_CASE(CuDNNLRNLayerTest, TestDtypes); + +TYPED_TEST(CuDNNLRNLayerTest, TestForwardAcrossChannelsCuDNN) { + // typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + CuDNNLRNLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + Blob top_reference; + this->ReferenceLRNForward(*(this->blob_bottom_), layer_param, + &top_reference); + for (int i = 0; i < this->blob_bottom_->count(); ++i) { + EXPECT_NEAR(this->blob_top_->cpu_data()[i], top_reference.cpu_data()[i], + this->epsilon_); + } +} + +TYPED_TEST(CuDNNLRNLayerTest, TestForwardAcrossChannelsLargeRegionCuDNN) { + typedef TypeParam Dtype; + LayerParameter layer_param; + layer_param.mutable_lrn_param()->set_local_size(15); + CuDNNLRNLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + Blob top_reference; + this->ReferenceLRNForward(*(this->blob_bottom_), layer_param, + &top_reference); + for (int i = 0; i < this->blob_bottom_->count(); ++i) { + EXPECT_NEAR(this->blob_top_->cpu_data()[i], top_reference.cpu_data()[i], + this->epsilon_); + } +} + +TYPED_TEST(CuDNNLRNLayerTest, TestGradientAcrossChannelsCuDNN) { + typedef TypeParam Dtype; + LayerParameter layer_param; + CuDNNLRNLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + for (int i = 0; i < this->blob_top_->count(); ++i) { + this->blob_top_->mutable_cpu_diff()[i] = 1.; + } + vector propagate_down(this->blob_bottom_vec_.size(), true); + layer.Backward(this->blob_top_vec_, propagate_down, + this->blob_bottom_vec_); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} + +TYPED_TEST(CuDNNLRNLayerTest, TestForwardWithinChannel) { + typedef TypeParam Dtype; + LayerParameter layer_param; + layer_param.mutable_lrn_param()->set_norm_region( + LRNParameter_NormRegion_WITHIN_CHANNEL); + layer_param.mutable_lrn_param()->set_local_size(3); + CuDNNLCNLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + Blob top_reference; + this->ReferenceLRNForward(*(this->blob_bottom_), layer_param, + &top_reference); + for (int i = 0; i < this->blob_bottom_->count(); ++i) { + EXPECT_NEAR(this->blob_top_->cpu_data()[i], top_reference.cpu_data()[i], + this->epsilon_); + } +} + +TYPED_TEST(CuDNNLRNLayerTest, TestGradientWithinChannel) { + typedef TypeParam Dtype; + LayerParameter layer_param; + layer_param.mutable_lrn_param()->set_norm_region( + LRNParameter_NormRegion_WITHIN_CHANNEL); + layer_param.mutable_lrn_param()->set_local_size(3); + CuDNNLCNLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + for (int i = 0; i < this->blob_top_->count(); ++i) { + this->blob_top_->mutable_cpu_diff()[i] = 1.; + } + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} + +TYPED_TEST(CuDNNLRNLayerTest, TestGradientAcrossChannelsLargeRegionCuDNN) { + typedef TypeParam Dtype; + LayerParameter layer_param; + layer_param.mutable_lrn_param()->set_local_size(15); + CuDNNLRNLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-2); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + for (int i = 0; i < this->blob_top_->count(); ++i) { + this->blob_top_->mutable_cpu_diff()[i] = 1.; + } + vector propagate_down(this->blob_bottom_vec_.size(), true); + layer.Backward(this->blob_top_vec_, propagate_down, + this->blob_bottom_vec_); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} + +#endif } // namespace caffe From 17b90a2c434ff4ee99f3c16b51c49338ffef92bd Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Thu, 8 Oct 2015 13:46:32 -0700 Subject: [PATCH 242/331] Fixing memory handler --- include/caffe/common.hpp | 69 +--------------- src/caffe/common.cpp | 173 --------------------------------------- 2 files changed, 3 insertions(+), 239 deletions(-) diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index d67d12f6ee3..421e52dd6c3 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -18,11 +18,6 @@ #include "caffe/util/device_alternate.hpp" -#ifdef USE_CNMEM -// cuMEM integration -#include -#endif - // gflags 2.1 issue: namespace google was changed to gflags without warning. // Luckily we will be able to use GFLAGS_GFLAGS_H_ to detect if it is version // 2.1. If yes, we will add a temporary solution to redirect the namespace. @@ -70,6 +65,8 @@ private:\ // is executed we will see a fatal log. #define NOT_IMPLEMENTED LOG(FATAL) << "Not Implemented Yet" +#include "MemoryHandler.hpp" + // See PR #1236 namespace cv { class Mat; } @@ -184,67 +181,7 @@ class Caffe { DISABLE_COPY_AND_ASSIGN(Caffe); }; -class MemoryHandler { - public: - static MemoryHandler& Get(); -#ifndef CPU_ONLY - static void mallocGPU(void **ptr, size_t size, - cudaStream_t stream = cudaStreamDefault); - static void freeGPU(void *ptr, cudaStream_t = cudaStreamDefault); - static void registerStream(cudaStream_t stream); -#endif - static void setGPUs(const std::vector& gpus) { Get().gpus_ = gpus; } - static void usePool() { Get().using_pool_ = true; } - static bool usingPool() { -#ifdef USE_CNMEM - return Get().using_pool_; -#else - return false; -#endif - } - static void getInfo(size_t *free_mem, size_t *used_mem); - static void destroy(); - ~MemoryHandler() { } - - private: - MemoryHandler() : using_pool_(false), initialized_(false) {} - static void Init(); - // static void Destroy(); -#ifndef CPU_ONLY - void allocate_memory(void **ptr, size_t size, cudaStream_t stream); - void free_memory(void *ptr, cudaStream_t stream); -#endif - DISABLE_COPY_AND_ASSIGN(MemoryHandler); - - bool using_pool_; - bool initialized_; - std::vector gpus_; -}; - -class MemoryHandlerActivator { - public: - explicit MemoryHandlerActivator(const std::vector& gpus) - : using_pool_(false) { - if (gpus.size() > 0) { - using_pool_ = true; - MemoryHandler::usePool(); - MemoryHandler::setGPUs(gpus); -#ifndef CPU_ONLY - void* temp; - MemoryHandler::mallocGPU(&temp, 4); - MemoryHandler::freeGPU(temp); -#endif - } - } - ~MemoryHandlerActivator() { - if (using_pool_) { - MemoryHandler::destroy(); - } - } - private: - int using_pool_; -}; - } // namespace caffe #endif // CAFFE_COMMON_HPP_ + diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index a210c240eda..5553f39f8cd 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -10,7 +10,6 @@ namespace caffe { -static boost::shared_ptr mem_handler; // Make sure each thread can have different values. static boost::thread_specific_ptr thread_instance_; @@ -232,178 +231,6 @@ Caffe::RNG& Caffe::RNG::operator=(const RNG& other) { void* Caffe::RNG::generator() { return static_cast(generator_->rng()); } - -static boost::mutex memHandlerMutex; - -MemoryHandler& MemoryHandler::Get() { - boost::mutex::scoped_lock lock(memHandlerMutex); - if (!mem_handler.get()) { - mem_handler.reset(new MemoryHandler()); - } - return *(mem_handler.get()); -} - -void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { - if (!Get().initialized_) { - Init(); - } - Get().allocate_memory(ptr, size, stream); -} - -void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { - Get().free_memory(ptr, stream); -} - -void MemoryHandler::allocate_memory(void **ptr, size_t size, - cudaStream_t stream) { - int initial_device; - cudaGetDevice(&initial_device); - if (size == 0) return; - if (using_pool_) { -#ifdef USE_CNMEM - CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); -#endif - } else { - CUDA_CHECK(cudaMalloc(ptr, size)); - } - cudaSetDevice(initial_device); -} - -void MemoryHandler::free_memory(void *ptr, cudaStream_t stream) { - // boost::mutex::scoped_lock lock(memHandlerMutex); - int initial_device; - cudaGetDevice(&initial_device); - if (using_pool_) { -#ifdef USE_CNMEM - CNMEM_CHECK(cnmemFree(ptr, stream)); -#endif - } else { - CUDA_CHECK(cudaFree(ptr)); - } - ptr = NULL; - cudaSetDevice(initial_device); -} - -void MemoryHandler::registerStream(cudaStream_t stream) { - if (!Get().initialized_) { - Init(); - } - if (Get().using_pool_) { -#ifdef USE_CNMEM - CNMEM_CHECK(cnmemRegisterStream(stream)); -#endif - } -} - -void MemoryHandler::destroy() { -#ifdef USE_CNMEM - CNMEM_CHECK(cnmemFinalize()); -#endif -} - -void MemoryHandler::Init() { - if (Get().using_pool_) { -#ifdef USE_CNMEM - cnmemDevice_t *devs = new cnmemDevice_t[Get().gpus_.size()]; - - int initial_device; - CUDA_CHECK(cudaGetDevice(&initial_device)); - - for (int i = 0; i < Get().gpus_.size(); i++) { - CUDA_CHECK(cudaSetDevice(Get().gpus_[i])); - - devs[i].device = Get().gpus_[i]; - - size_t free_mem, used_mem; - CUDA_CHECK(cudaMemGetInfo(&free_mem, &used_mem)); - - devs[i].size = size_t(0.95*free_mem); - devs[i].numStreams = 0; - devs[i].streams = NULL; - } - CNMEM_CHECK(cnmemInit(Get().gpus_.size(), devs, CNMEM_FLAGS_DEFAULT)); - Get().initialized_ = true; - - CUDA_CHECK(cudaSetDevice(initial_device)); - - delete [] devs; -#endif - } - Get().initialized_ = true; -} - -void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { - if (Get().using_pool_) { -#ifdef USE_CNMEM - CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); -#endif - } else { - CUDA_CHECK(cudaMemGetInfo(free_mem, total_mem)); - } -} - -const char* cublasGetErrorString(cublasStatus_t error) { - switch (error) { - case CUBLAS_STATUS_SUCCESS: - return "CUBLAS_STATUS_SUCCESS"; - case CUBLAS_STATUS_NOT_INITIALIZED: - return "CUBLAS_STATUS_NOT_INITIALIZED"; - case CUBLAS_STATUS_ALLOC_FAILED: - return "CUBLAS_STATUS_ALLOC_FAILED"; - case CUBLAS_STATUS_INVALID_VALUE: - return "CUBLAS_STATUS_INVALID_VALUE"; - case CUBLAS_STATUS_ARCH_MISMATCH: - return "CUBLAS_STATUS_ARCH_MISMATCH"; - case CUBLAS_STATUS_MAPPING_ERROR: - return "CUBLAS_STATUS_MAPPING_ERROR"; - case CUBLAS_STATUS_EXECUTION_FAILED: - return "CUBLAS_STATUS_EXECUTION_FAILED"; - case CUBLAS_STATUS_INTERNAL_ERROR: - return "CUBLAS_STATUS_INTERNAL_ERROR"; -#if CUDA_VERSION >= 6000 - case CUBLAS_STATUS_NOT_SUPPORTED: - return "CUBLAS_STATUS_NOT_SUPPORTED"; -#endif -#if CUDA_VERSION >= 6050 - case CUBLAS_STATUS_LICENSE_ERROR: - return "CUBLAS_STATUS_LICENSE_ERROR"; -#endif - } - return "Unknown cublas status"; -} - -const char* curandGetErrorString(curandStatus_t error) { - switch (error) { - case CURAND_STATUS_SUCCESS: - return "CURAND_STATUS_SUCCESS"; - case CURAND_STATUS_VERSION_MISMATCH: - return "CURAND_STATUS_VERSION_MISMATCH"; - case CURAND_STATUS_NOT_INITIALIZED: - return "CURAND_STATUS_NOT_INITIALIZED"; - case CURAND_STATUS_ALLOCATION_FAILED: - return "CURAND_STATUS_ALLOCATION_FAILED"; - case CURAND_STATUS_TYPE_ERROR: - return "CURAND_STATUS_TYPE_ERROR"; - case CURAND_STATUS_OUT_OF_RANGE: - return "CURAND_STATUS_OUT_OF_RANGE"; - case CURAND_STATUS_LENGTH_NOT_MULTIPLE: - return "CURAND_STATUS_LENGTH_NOT_MULTIPLE"; - case CURAND_STATUS_DOUBLE_PRECISION_REQUIRED: - return "CURAND_STATUS_DOUBLE_PRECISION_REQUIRED"; - case CURAND_STATUS_LAUNCH_FAILURE: - return "CURAND_STATUS_LAUNCH_FAILURE"; - case CURAND_STATUS_PREEXISTING_FAILURE: - return "CURAND_STATUS_PREEXISTING_FAILURE"; - case CURAND_STATUS_INITIALIZATION_FAILED: - return "CURAND_STATUS_INITIALIZATION_FAILED"; - case CURAND_STATUS_ARCH_MISMATCH: - return "CURAND_STATUS_ARCH_MISMATCH"; - case CURAND_STATUS_INTERNAL_ERROR: - return "CURAND_STATUS_INTERNAL_ERROR"; - } - return "Unknown curand status"; -} - #endif // CPU_ONLY } // namespace caffe From ee9ab75b06a1439ba672224f27768a620fe842ba Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Thu, 8 Oct 2015 13:48:00 -0700 Subject: [PATCH 243/331] Fixing memory handler --- include/caffe/MemoryHandler.hpp | 87 +++++++++++++++ src/caffe/MemoryHandler.cpp | 190 ++++++++++++++++++++++++++++++++ 2 files changed, 277 insertions(+) create mode 100644 include/caffe/MemoryHandler.hpp create mode 100644 src/caffe/MemoryHandler.cpp diff --git a/include/caffe/MemoryHandler.hpp b/include/caffe/MemoryHandler.hpp new file mode 100644 index 00000000000..9a724f84574 --- /dev/null +++ b/include/caffe/MemoryHandler.hpp @@ -0,0 +1,87 @@ +#ifndef CAFFE_MEMORYHANDLER_HPP_ +#define CAFFE_MEMORYHANDLER_HPP_ + +#include "common.hpp" + +#ifdef USE_CNMEM +// cuMEM integration +#include +#endif + +namespace caffe { + +class MemoryHandler { + public: + static MemoryHandler& Get(); +#ifndef CPU_ONLY + static void mallocGPU(void **ptr, size_t size, + cudaStream_t stream = cudaStreamDefault); + static void freeGPU(void *ptr, cudaStream_t = cudaStreamDefault); + static void registerStream(cudaStream_t stream); +#endif + + static bool usingPool() { +#ifdef USE_CNMEM + return using_pool_; +#else + return false; +#endif + } + static void getInfo(size_t *free_mem, size_t *used_mem); + + ~MemoryHandler() { } + + private: + MemoryHandler() {} + + static void usePool() { +#ifdef USE_CNMEM + using_pool_ = true; +#endif + } + + static void setGPUs(const std::vector& gpus) { gpus_ = gpus; } + static void Init(); + static void destroy(); + +#ifndef CPU_ONLY + void allocate_memory(void **ptr, size_t size, cudaStream_t stream); + void free_memory(void *ptr, cudaStream_t stream); +#endif + DISABLE_COPY_AND_ASSIGN(MemoryHandler); + friend class MemoryHandlerActivator; + static bool using_pool_; + static bool initialized_; + static std::vector gpus_; +}; + +class MemoryHandlerActivator { + public: + explicit MemoryHandlerActivator(const std::vector& gpus) + : using_pool_(false) { + if (gpus.size() > 0) { + using_pool_ = true; +#ifdef USE_CNMEM + MemoryHandler::usePool(); +#endif + MemoryHandler::setGPUs(gpus); + MemoryHandler::Init(); +#ifndef CPU_ONLY + void* temp; + MemoryHandler::mallocGPU(&temp, 4); + MemoryHandler::freeGPU(temp); +#endif + } + } + ~MemoryHandlerActivator() { + if (using_pool_) { + MemoryHandler::destroy(); + } + } + private: + int using_pool_; +}; + +} // namespace caffe + +# endif diff --git a/src/caffe/MemoryHandler.cpp b/src/caffe/MemoryHandler.cpp new file mode 100644 index 00000000000..9bab5228bec --- /dev/null +++ b/src/caffe/MemoryHandler.cpp @@ -0,0 +1,190 @@ +#include "caffe/common.hpp" +#include "caffe/MemoryHandler.hpp" + +#include + +namespace caffe { + +bool MemoryHandler::using_pool_ = false; +bool MemoryHandler::initialized_ = false; +std::vector MemoryHandler::gpus_; + +using namespace boost; + +#ifndef CPU_ONLY // CPU-only Caffe. + +static boost::mutex memHandlerMutex; +static boost::shared_ptr mem_handler; + +MemoryHandler& MemoryHandler::Get() { + if (!mem_handler.get()) { + boost::mutex::scoped_lock lock(memHandlerMutex); + if (!mem_handler.get()) { + mem_handler.reset(new MemoryHandler()); + } + } + return *(mem_handler.get()); +} + +void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { + Get().allocate_memory(ptr, size, stream); +} + + +void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { + Get().free_memory(ptr, stream); +} + +void MemoryHandler::allocate_memory(void **ptr, size_t size, + cudaStream_t stream) { + CHECK(initialized_); + int initial_device; + cudaGetDevice(&initial_device); + if (using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); +#endif + } else { + CUDA_CHECK(cudaMalloc(ptr, size)); + } + cudaSetDevice(initial_device); +} + +void MemoryHandler::free_memory(void *ptr, cudaStream_t stream) { + CHECK(initialized_); + // boost::mutex::scoped_lock lock(memHandlerMutex); + int initial_device; + cudaGetDevice(&initial_device); + if (using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemFree(ptr, stream)); +#endif + } else { + CUDA_CHECK(cudaFree(ptr)); + } + cudaSetDevice(initial_device); +} + +void MemoryHandler::registerStream(cudaStream_t stream) { + if (Get().using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemRegisterStream(stream)); +#endif + } +} + +void MemoryHandler::destroy() { + CHECK(initialized_); +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemFinalize()); +#endif +} + +void MemoryHandler::Init() { + CHECK(!initialized_); +#ifdef USE_CNMEM + if (Get().using_pool_) { + cnmemDevice_t *devs = new cnmemDevice_t[Get().gpus_.size()]; + + int initial_device; + CUDA_CHECK(cudaGetDevice(&initial_device)); + + for (int i = 0; i < Get().gpus_.size(); i++) { + CUDA_CHECK(cudaSetDevice(Get().gpus_[i])); + + devs[i].device = Get().gpus_[i]; + + size_t free_mem, used_mem; + CUDA_CHECK(cudaMemGetInfo(&free_mem, &used_mem)); + + devs[i].size = size_t(0.95*free_mem); + devs[i].numStreams = 0; + devs[i].streams = NULL; + } + CNMEM_CHECK(cnmemInit(Get().gpus_.size(), devs, CNMEM_FLAGS_DEFAULT)); + Get().initialized_ = true; + + CUDA_CHECK(cudaSetDevice(initial_device)); + + delete [] devs; + } +#endif + Get().initialized_ = true; +} + +void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { + if (Get().using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); +#endif + } else { + CUDA_CHECK(cudaMemGetInfo(free_mem, total_mem)); + } +} + +const char* cublasGetErrorString(cublasStatus_t error) { + switch (error) { + case CUBLAS_STATUS_SUCCESS: + return "CUBLAS_STATUS_SUCCESS"; + case CUBLAS_STATUS_NOT_INITIALIZED: + return "CUBLAS_STATUS_NOT_INITIALIZED"; + case CUBLAS_STATUS_ALLOC_FAILED: + return "CUBLAS_STATUS_ALLOC_FAILED"; + case CUBLAS_STATUS_INVALID_VALUE: + return "CUBLAS_STATUS_INVALID_VALUE"; + case CUBLAS_STATUS_ARCH_MISMATCH: + return "CUBLAS_STATUS_ARCH_MISMATCH"; + case CUBLAS_STATUS_MAPPING_ERROR: + return "CUBLAS_STATUS_MAPPING_ERROR"; + case CUBLAS_STATUS_EXECUTION_FAILED: + return "CUBLAS_STATUS_EXECUTION_FAILED"; + case CUBLAS_STATUS_INTERNAL_ERROR: + return "CUBLAS_STATUS_INTERNAL_ERROR"; +#if CUDA_VERSION >= 6000 + case CUBLAS_STATUS_NOT_SUPPORTED: + return "CUBLAS_STATUS_NOT_SUPPORTED"; +#endif +#if CUDA_VERSION >= 6050 + case CUBLAS_STATUS_LICENSE_ERROR: + return "CUBLAS_STATUS_LICENSE_ERROR"; +#endif + } + return "Unknown cublas status"; +} + +const char* curandGetErrorString(curandStatus_t error) { + switch (error) { + case CURAND_STATUS_SUCCESS: + return "CURAND_STATUS_SUCCESS"; + case CURAND_STATUS_VERSION_MISMATCH: + return "CURAND_STATUS_VERSION_MISMATCH"; + case CURAND_STATUS_NOT_INITIALIZED: + return "CURAND_STATUS_NOT_INITIALIZED"; + case CURAND_STATUS_ALLOCATION_FAILED: + return "CURAND_STATUS_ALLOCATION_FAILED"; + case CURAND_STATUS_TYPE_ERROR: + return "CURAND_STATUS_TYPE_ERROR"; + case CURAND_STATUS_OUT_OF_RANGE: + return "CURAND_STATUS_OUT_OF_RANGE"; + case CURAND_STATUS_LENGTH_NOT_MULTIPLE: + return "CURAND_STATUS_LENGTH_NOT_MULTIPLE"; + case CURAND_STATUS_DOUBLE_PRECISION_REQUIRED: + return "CURAND_STATUS_DOUBLE_PRECISION_REQUIRED"; + case CURAND_STATUS_LAUNCH_FAILURE: + return "CURAND_STATUS_LAUNCH_FAILURE"; + case CURAND_STATUS_PREEXISTING_FAILURE: + return "CURAND_STATUS_PREEXISTING_FAILURE"; + case CURAND_STATUS_INITIALIZATION_FAILED: + return "CURAND_STATUS_INITIALIZATION_FAILED"; + case CURAND_STATUS_ARCH_MISMATCH: + return "CURAND_STATUS_ARCH_MISMATCH"; + case CURAND_STATUS_INTERNAL_ERROR: + return "CURAND_STATUS_INTERNAL_ERROR"; + } + return "Unknown curand status"; +} + +} + +#endif // CPU_ONLY + From dfd65eddd50784ffb5923091431f17333f1d78b4 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Thu, 8 Oct 2015 20:04:25 -0700 Subject: [PATCH 244/331] CNMEM fix --- include/caffe/MemoryHandler.hpp | 38 ++----- include/caffe/util/device_alternate.hpp | 3 +- src/caffe/MemoryHandler.cpp | 138 ++++-------------------- src/caffe/layers/cudnn_conv_layer.cpp | 78 +++++++------- src/caffe/layers/cudnn_lcn_layer.cpp | 31 +++--- src/caffe/parallel.cpp | 18 ++-- src/caffe/test/test_caffe_main.cpp | 30 ++++-- tools/caffe.cpp | 3 +- 8 files changed, 118 insertions(+), 221 deletions(-) diff --git a/include/caffe/MemoryHandler.hpp b/include/caffe/MemoryHandler.hpp index 9a724f84574..af56d357580 100644 --- a/include/caffe/MemoryHandler.hpp +++ b/include/caffe/MemoryHandler.hpp @@ -12,7 +12,6 @@ namespace caffe { class MemoryHandler { public: - static MemoryHandler& Get(); #ifndef CPU_ONLY static void mallocGPU(void **ptr, size_t size, cudaStream_t stream = cudaStreamDefault); @@ -21,38 +20,20 @@ class MemoryHandler { #endif static bool usingPool() { -#ifdef USE_CNMEM return using_pool_; -#else - return false; -#endif } - static void getInfo(size_t *free_mem, size_t *used_mem); - ~MemoryHandler() { } + static void getInfo(size_t *free_mem, size_t *used_mem); private: - MemoryHandler() {} - - static void usePool() { -#ifdef USE_CNMEM - using_pool_ = true; -#endif - } - - static void setGPUs(const std::vector& gpus) { gpus_ = gpus; } - static void Init(); + static void init(const std::vector& gpus_, bool use_pool=true); static void destroy(); -#ifndef CPU_ONLY - void allocate_memory(void **ptr, size_t size, cudaStream_t stream); - void free_memory(void *ptr, cudaStream_t stream); -#endif - DISABLE_COPY_AND_ASSIGN(MemoryHandler); friend class MemoryHandlerActivator; static bool using_pool_; static bool initialized_; - static std::vector gpus_; + + }; class MemoryHandlerActivator { @@ -60,17 +41,10 @@ class MemoryHandlerActivator { explicit MemoryHandlerActivator(const std::vector& gpus) : using_pool_(false) { if (gpus.size() > 0) { - using_pool_ = true; #ifdef USE_CNMEM - MemoryHandler::usePool(); -#endif - MemoryHandler::setGPUs(gpus); - MemoryHandler::Init(); -#ifndef CPU_ONLY - void* temp; - MemoryHandler::mallocGPU(&temp, 4); - MemoryHandler::freeGPU(temp); + using_pool_ = true; #endif + MemoryHandler::init(gpus, using_pool_); } } ~MemoryHandlerActivator() { diff --git a/include/caffe/util/device_alternate.hpp b/include/caffe/util/device_alternate.hpp index 55d616fbf71..53b780768e0 100644 --- a/include/caffe/util/device_alternate.hpp +++ b/include/caffe/util/device_alternate.hpp @@ -74,7 +74,8 @@ void classname::funcname##_##gpu(const vector*>& top, \ CHECK_EQ(status, CNMEM_STATUS_SUCCESS) << " " \ << cnmemGetErrorString(status); \ } while (0) - +#else +#define CNMEM_CHECK(condition) #endif // CUDA: grid stride looping diff --git a/src/caffe/MemoryHandler.cpp b/src/caffe/MemoryHandler.cpp index 9bab5228bec..fe217cead72 100644 --- a/src/caffe/MemoryHandler.cpp +++ b/src/caffe/MemoryHandler.cpp @@ -7,92 +7,62 @@ namespace caffe { bool MemoryHandler::using_pool_ = false; bool MemoryHandler::initialized_ = false; -std::vector MemoryHandler::gpus_; using namespace boost; -#ifndef CPU_ONLY // CPU-only Caffe. - -static boost::mutex memHandlerMutex; -static boost::shared_ptr mem_handler; +#ifndef CNMEM_CHECK +# define CNMEM_CHECK(x) +#endif -MemoryHandler& MemoryHandler::Get() { - if (!mem_handler.get()) { - boost::mutex::scoped_lock lock(memHandlerMutex); - if (!mem_handler.get()) { - mem_handler.reset(new MemoryHandler()); - } - } - return *(mem_handler.get()); -} +#ifndef CPU_ONLY // CPU-only Caffe. void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { - Get().allocate_memory(ptr, size, stream); -} - - -void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { - Get().free_memory(ptr, stream); -} - -void MemoryHandler::allocate_memory(void **ptr, size_t size, - cudaStream_t stream) { CHECK(initialized_); - int initial_device; - cudaGetDevice(&initial_device); if (using_pool_) { -#ifdef USE_CNMEM CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); -#endif } else { CUDA_CHECK(cudaMalloc(ptr, size)); } - cudaSetDevice(initial_device); } -void MemoryHandler::free_memory(void *ptr, cudaStream_t stream) { + +void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { CHECK(initialized_); - // boost::mutex::scoped_lock lock(memHandlerMutex); - int initial_device; - cudaGetDevice(&initial_device); if (using_pool_) { -#ifdef USE_CNMEM CNMEM_CHECK(cnmemFree(ptr, stream)); -#endif } else { CUDA_CHECK(cudaFree(ptr)); } - cudaSetDevice(initial_device); } void MemoryHandler::registerStream(cudaStream_t stream) { - if (Get().using_pool_) { -#ifdef USE_CNMEM + CHECK(initialized_); + if (using_pool_) { CNMEM_CHECK(cnmemRegisterStream(stream)); -#endif } } void MemoryHandler::destroy() { CHECK(initialized_); -#ifdef USE_CNMEM CNMEM_CHECK(cnmemFinalize()); -#endif + initialized_ = false; + using_pool_ = false; } -void MemoryHandler::Init() { +void MemoryHandler::init(const std::vector& gpus, bool use_pool) { CHECK(!initialized_); #ifdef USE_CNMEM - if (Get().using_pool_) { - cnmemDevice_t *devs = new cnmemDevice_t[Get().gpus_.size()]; + if (false /* use_pool */) { + using_pool_ = true; + cnmemDevice_t *devs = new cnmemDevice_t[gpus.size()]; int initial_device; CUDA_CHECK(cudaGetDevice(&initial_device)); - for (int i = 0; i < Get().gpus_.size(); i++) { - CUDA_CHECK(cudaSetDevice(Get().gpus_[i])); + for (int i = 0; i < gpus.size(); i++) { + CUDA_CHECK(cudaSetDevice(gpus[i])); - devs[i].device = Get().gpus_[i]; + devs[i].device = gpus[i]; size_t free_mem, used_mem; CUDA_CHECK(cudaMemGetInfo(&free_mem, &used_mem)); @@ -101,89 +71,27 @@ void MemoryHandler::Init() { devs[i].numStreams = 0; devs[i].streams = NULL; } - CNMEM_CHECK(cnmemInit(Get().gpus_.size(), devs, CNMEM_FLAGS_DEFAULT)); - Get().initialized_ = true; + CNMEM_CHECK(cnmemInit(gpus.size(), devs, CNMEM_FLAGS_DEFAULT)); + initialized_ = true; CUDA_CHECK(cudaSetDevice(initial_device)); delete [] devs; } #endif - Get().initialized_ = true; + initialized_ = true; + std::cout << "MemoryHandler initialized" << + (using_pool_ ? " with CNMEM pool.\n" : " with CUDA allocator.\n"); } void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { - if (Get().using_pool_) { -#ifdef USE_CNMEM + if (using_pool_) { CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); -#endif } else { CUDA_CHECK(cudaMemGetInfo(free_mem, total_mem)); } } -const char* cublasGetErrorString(cublasStatus_t error) { - switch (error) { - case CUBLAS_STATUS_SUCCESS: - return "CUBLAS_STATUS_SUCCESS"; - case CUBLAS_STATUS_NOT_INITIALIZED: - return "CUBLAS_STATUS_NOT_INITIALIZED"; - case CUBLAS_STATUS_ALLOC_FAILED: - return "CUBLAS_STATUS_ALLOC_FAILED"; - case CUBLAS_STATUS_INVALID_VALUE: - return "CUBLAS_STATUS_INVALID_VALUE"; - case CUBLAS_STATUS_ARCH_MISMATCH: - return "CUBLAS_STATUS_ARCH_MISMATCH"; - case CUBLAS_STATUS_MAPPING_ERROR: - return "CUBLAS_STATUS_MAPPING_ERROR"; - case CUBLAS_STATUS_EXECUTION_FAILED: - return "CUBLAS_STATUS_EXECUTION_FAILED"; - case CUBLAS_STATUS_INTERNAL_ERROR: - return "CUBLAS_STATUS_INTERNAL_ERROR"; -#if CUDA_VERSION >= 6000 - case CUBLAS_STATUS_NOT_SUPPORTED: - return "CUBLAS_STATUS_NOT_SUPPORTED"; -#endif -#if CUDA_VERSION >= 6050 - case CUBLAS_STATUS_LICENSE_ERROR: - return "CUBLAS_STATUS_LICENSE_ERROR"; -#endif - } - return "Unknown cublas status"; -} - -const char* curandGetErrorString(curandStatus_t error) { - switch (error) { - case CURAND_STATUS_SUCCESS: - return "CURAND_STATUS_SUCCESS"; - case CURAND_STATUS_VERSION_MISMATCH: - return "CURAND_STATUS_VERSION_MISMATCH"; - case CURAND_STATUS_NOT_INITIALIZED: - return "CURAND_STATUS_NOT_INITIALIZED"; - case CURAND_STATUS_ALLOCATION_FAILED: - return "CURAND_STATUS_ALLOCATION_FAILED"; - case CURAND_STATUS_TYPE_ERROR: - return "CURAND_STATUS_TYPE_ERROR"; - case CURAND_STATUS_OUT_OF_RANGE: - return "CURAND_STATUS_OUT_OF_RANGE"; - case CURAND_STATUS_LENGTH_NOT_MULTIPLE: - return "CURAND_STATUS_LENGTH_NOT_MULTIPLE"; - case CURAND_STATUS_DOUBLE_PRECISION_REQUIRED: - return "CURAND_STATUS_DOUBLE_PRECISION_REQUIRED"; - case CURAND_STATUS_LAUNCH_FAILURE: - return "CURAND_STATUS_LAUNCH_FAILURE"; - case CURAND_STATUS_PREEXISTING_FAILURE: - return "CURAND_STATUS_PREEXISTING_FAILURE"; - case CURAND_STATUS_INITIALIZATION_FAILED: - return "CURAND_STATUS_INITIALIZATION_FAILED"; - case CURAND_STATUS_ARCH_MISMATCH: - return "CURAND_STATUS_ARCH_MISMATCH"; - case CURAND_STATUS_INTERNAL_ERROR: - return "CURAND_STATUS_INTERNAL_ERROR"; - } - return "Unknown curand status"; -} - } #endif // CPU_ONLY diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index eb7c181684e..942bbbddacb 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -171,7 +171,7 @@ void CuDNNConvolutionLayer::Reshape( bwd_filter_algo_[i], &workspace_bwd_filter_sizes_[i])); // choose backward algo for data - CUDNN_CHECK(cudnnGetConvolutionBackwardDataAlgorithm( + CUDNN_CHECK(cudnnGetConvolutionBackwardDataAlgorithm( Caffe::cudnn_handle(), filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], CUDNN_CONVOLUTION_BWD_DATA_SPECIFY_WORKSPACE_LIMIT, @@ -183,46 +183,46 @@ void CuDNNConvolutionLayer::Reshape( filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], bwd_data_algo_[i], &workspace_bwd_data_sizes_[i]) ); } - -#ifndef USE_CNMEM - // reduce over all workspace sizes to get a maximum to allocate / reallocate - size_t total_workspace_fwd = 0; - size_t total_workspace_bwd_data = 0; - size_t total_workspace_bwd_filter = 0; - - for (size_t i = 0; i < bottom.size(); i++) { - total_workspace_fwd = std::max(total_workspace_fwd, - workspace_fwd_sizes_[i]); - total_workspace_bwd_data = std::max(total_workspace_bwd_data, - workspace_bwd_data_sizes_[i]); - total_workspace_bwd_filter = std::max(total_workspace_bwd_filter, - workspace_bwd_filter_sizes_[i]); - } - // get max over all operations - size_t max_workspace = std::max(total_workspace_fwd, - total_workspace_bwd_data); - max_workspace = std::max(max_workspace, total_workspace_bwd_filter); - // ensure all groups have enough workspace - size_t total_max_workspace = max_workspace * - (this->group_ * CUDNN_STREAMS_PER_GROUP); - - // this is the total amount of storage needed over all groups + streams - if (total_max_workspace > workspaceSizeInBytes) { - LOG(INFO) << "Reallocating workspace storage: " << total_max_workspace; - workspaceSizeInBytes = total_max_workspace; - - // free the existing workspace and allocate a new (larger) one - MemoryHandler::freeGPU(this->workspaceData); - this->workspaceData = NULL; - - MemoryHandler::mallocGPU(&(this->workspaceData), workspaceSizeInBytes); - - // if we succeed in the allocation, set pointer aliases for workspaces - for (int g = 0; g < (this->group_ * CUDNN_STREAMS_PER_GROUP); g++) { - workspace[g] = reinterpret_cast(workspaceData) + g*max_workspace; + + if (!MemoryHandler::usingPool()) { + // reduce over all workspace sizes to get a maximum to allocate / reallocate + size_t total_workspace_fwd = 0; + size_t total_workspace_bwd_data = 0; + size_t total_workspace_bwd_filter = 0; + + for (size_t i = 0; i < bottom.size(); i++) { + total_workspace_fwd = std::max(total_workspace_fwd, + workspace_fwd_sizes_[i]); + total_workspace_bwd_data = std::max(total_workspace_bwd_data, + workspace_bwd_data_sizes_[i]); + total_workspace_bwd_filter = std::max(total_workspace_bwd_filter, + workspace_bwd_filter_sizes_[i]); + } + // get max over all operations + size_t max_workspace = std::max(total_workspace_fwd, + total_workspace_bwd_data); + max_workspace = std::max(max_workspace, total_workspace_bwd_filter); + // ensure all groups have enough workspace + size_t total_max_workspace = max_workspace * + (this->group_ * CUDNN_STREAMS_PER_GROUP); + + // this is the total amount of storage needed over all groups + streams + if (total_max_workspace > workspaceSizeInBytes) { + LOG(INFO) << "Reallocating workspace storage: " << total_max_workspace; + workspaceSizeInBytes = total_max_workspace; + + // free the existing workspace and allocate a new (larger) one + MemoryHandler::freeGPU(this->workspaceData); + this->workspaceData = NULL; + + MemoryHandler::mallocGPU(&(this->workspaceData), workspaceSizeInBytes); + + // if we succeed in the allocation, set pointer aliases for workspaces + for (int g = 0; g < (this->group_ * CUDNN_STREAMS_PER_GROUP); g++) { + workspace[g] = reinterpret_cast(workspaceData) + g*max_workspace; + } } } -#endif // Tensor descriptor for bias. if (this->bias_term_) { diff --git a/src/caffe/layers/cudnn_lcn_layer.cpp b/src/caffe/layers/cudnn_lcn_layer.cpp index 0bfa41a48d3..bf58867b92b 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cpp +++ b/src/caffe/layers/cudnn_lcn_layer.cpp @@ -42,22 +42,21 @@ void CuDNNLCNLayer::Reshape(const vector*>& bottom, size_t totalSizeInBytes = sizeof(Dtype)*bottom[0]->num()* \ this->channels_*this->height_*this->width_; -#ifdef USE_CNMEM - this->tempDataSize = totalSizeInBytes; -#else - if (totalSizeInBytes > tempDataSize) { - tempDataSize = totalSizeInBytes; - - MemoryHandler::freeGPU(tempData1); - MemoryHandler::freeGPU(tempData2); - tempData1 = NULL; - tempData2 = NULL; - - // allocate new buffers - MemoryHandler::mallocGPU(&tempData1, totalSizeInBytes); - MemoryHandler::mallocGPU(&tempData2, totalSizeInBytes); - } -#endif + if (MemoryHandler::usingPool()) + this->tempDataSize = totalSizeInBytes; + else + if (totalSizeInBytes > tempDataSize) { + tempDataSize = totalSizeInBytes; + + MemoryHandler::freeGPU(tempData1); + MemoryHandler::freeGPU(tempData2); + tempData1 = NULL; + tempData2 = NULL; + + // allocate new buffers + MemoryHandler::mallocGPU(&tempData1, totalSizeInBytes); + MemoryHandler::mallocGPU(&tempData2, totalSizeInBytes); + } } template diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index cf244bcf916..9d47f1cd422 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -264,25 +264,25 @@ P2PSync::P2PSync(shared_ptr > root_solver, template P2PSync::~P2PSync() { #ifndef CPU_ONLY - int initial_device; - CUDA_CHECK(cudaGetDevice(&initial_device)); - const int self = solver_->param().device_id(); - CUDA_CHECK(cudaSetDevice(self)); - if (parent_) { + int initial_device; + CUDA_CHECK(cudaGetDevice(&initial_device)); + const int self = solver_->param().device_id(); const int peer = parent_->solver_->param().device_id(); - cudaSetDevice(peer); + + CUDA_CHECK(cudaSetDevice(peer)); MemoryHandler::freeGPU(parent_grads_); parent_grads_ = NULL; - cudaSetDevice(self); + + CUDA_CHECK(cudaSetDevice(self)); int access; CUDA_CHECK(cudaDeviceCanAccessPeer(&access, self, peer)); if (access) { CUDA_CHECK(cudaDeviceDisablePeerAccess(peer)); } - } - CUDA_CHECK(cudaSetDevice(initial_device)); + CUDA_CHECK(cudaSetDevice(initial_device)); + } #endif } diff --git a/src/caffe/test/test_caffe_main.cpp b/src/caffe/test/test_caffe_main.cpp index c8caf5ac58e..430ccd610b5 100644 --- a/src/caffe/test/test_caffe_main.cpp +++ b/src/caffe/test/test_caffe_main.cpp @@ -17,24 +17,40 @@ using caffe::CAFFE_TEST_CUDA_PROP; int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); caffe::GlobalInit(&argc, &argv); + { #ifndef CPU_ONLY // Before starting testing, let's first print out a few cuda defice info. - int device; - cudaGetDeviceCount(&device); - cout << "Cuda number of devices: " << device << endl; + std::vector devices; + int device_count; + + cudaGetDeviceCount(&device_count); + cout << "Cuda number of devices: " << device_count << endl; + if (argc > 1) { // Use the given device - device = atoi(argv[1]); - cudaSetDevice(device); - cout << "Setting to use device " << device << endl; + devices.push_back(atoi(argv[1])); + cudaSetDevice(devices[0]); } else if (CUDA_TEST_DEVICE >= 0) { // Use the device assigned in build configuration; but with a lower priority - device = CUDA_TEST_DEVICE; + devices.push_back(CUDA_TEST_DEVICE); + } + + if (devices.size()==1) { + cout << "Setting to use device " << devices[0] << endl; + cudaSetDevice(devices[0]); + } else { + for (int i = 0; i < device_count; ++i) + devices.push_back(i); } + + int device; cudaGetDevice(&device); cout << "Current device id: " << device << endl; cudaGetDeviceProperties(&CAFFE_TEST_CUDA_PROP, device); + caffe::MemoryHandlerActivator activator(devices); + #endif // invoke the test. return RUN_ALL_TESTS(); + } } diff --git a/tools/caffe.cpp b/tools/caffe.cpp index fb44681cf7b..77c68b64d6a 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -189,9 +189,8 @@ int train() { Caffe::set_mode(Caffe::GPU); Caffe::set_solver_count(gpus.size()); } -#ifdef USE_CNMEM + MemoryHandlerActivator handler(gpus); -#endif caffe::SignalHandler signal_handler( GetRequestedAction(FLAGS_sigint_effect), From cda2e182f875072fbf11a567c4acf698d0a5ce4c Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Thu, 8 Oct 2015 20:16:17 -0700 Subject: [PATCH 245/331] Renamed handler class --- .../caffe/{MemoryHandler.hpp => CuMem.hpp} | 20 +++++++++---------- include/caffe/common.hpp | 6 +++++- src/caffe/{MemoryHandler.cpp => CuMem.cpp} | 20 +++++++++---------- src/caffe/syncedmem.cpp | 10 +++++----- 4 files changed, 30 insertions(+), 26 deletions(-) rename include/caffe/{MemoryHandler.hpp => CuMem.hpp} (71%) rename src/caffe/{MemoryHandler.cpp => CuMem.cpp} (75%) diff --git a/include/caffe/MemoryHandler.hpp b/include/caffe/CuMem.hpp similarity index 71% rename from include/caffe/MemoryHandler.hpp rename to include/caffe/CuMem.hpp index af56d357580..725e65a4c0c 100644 --- a/include/caffe/MemoryHandler.hpp +++ b/include/caffe/CuMem.hpp @@ -1,16 +1,16 @@ -#ifndef CAFFE_MEMORYHANDLER_HPP_ -#define CAFFE_MEMORYHANDLER_HPP_ +#ifndef CAFFE_CUMEM_HPP_ +#define CAFFE_CUMEM_HPP_ #include "common.hpp" #ifdef USE_CNMEM -// cuMEM integration +// CNMEM integration #include #endif namespace caffe { -class MemoryHandler { +class CuMem { public: #ifndef CPU_ONLY static void mallocGPU(void **ptr, size_t size, @@ -29,27 +29,27 @@ class MemoryHandler { static void init(const std::vector& gpus_, bool use_pool=true); static void destroy(); - friend class MemoryHandlerActivator; + friend class CuMemActivator; static bool using_pool_; static bool initialized_; }; -class MemoryHandlerActivator { +class CuMemActivator { public: - explicit MemoryHandlerActivator(const std::vector& gpus) + explicit CuMemActivator(const std::vector& gpus) : using_pool_(false) { if (gpus.size() > 0) { #ifdef USE_CNMEM using_pool_ = true; #endif - MemoryHandler::init(gpus, using_pool_); + CuMem::init(gpus, using_pool_); } } - ~MemoryHandlerActivator() { + ~CuMemActivator() { if (using_pool_) { - MemoryHandler::destroy(); + CuMem::destroy(); } } private: diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index 421e52dd6c3..699fc81bb18 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -65,7 +65,11 @@ private:\ // is executed we will see a fatal log. #define NOT_IMPLEMENTED LOG(FATAL) << "Not Implemented Yet" -#include "MemoryHandler.hpp" +#include "CuMem.hpp" + +// bfomitchev: temporary, for better merge +#define MemoryHandler CuMem +#define MemoryHandlerActivator CuMemActivator // See PR #1236 namespace cv { class Mat; } diff --git a/src/caffe/MemoryHandler.cpp b/src/caffe/CuMem.cpp similarity index 75% rename from src/caffe/MemoryHandler.cpp rename to src/caffe/CuMem.cpp index fe217cead72..0661e785d16 100644 --- a/src/caffe/MemoryHandler.cpp +++ b/src/caffe/CuMem.cpp @@ -1,12 +1,12 @@ #include "caffe/common.hpp" -#include "caffe/MemoryHandler.hpp" +#include "caffe/CuMem.hpp" #include namespace caffe { -bool MemoryHandler::using_pool_ = false; -bool MemoryHandler::initialized_ = false; +bool CuMem::using_pool_ = false; +bool CuMem::initialized_ = false; using namespace boost; @@ -16,7 +16,7 @@ using namespace boost; #ifndef CPU_ONLY // CPU-only Caffe. -void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { +void CuMem::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { CHECK(initialized_); if (using_pool_) { CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); @@ -26,7 +26,7 @@ void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { } -void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { +void CuMem::freeGPU(void *ptr, cudaStream_t stream) { CHECK(initialized_); if (using_pool_) { CNMEM_CHECK(cnmemFree(ptr, stream)); @@ -35,21 +35,21 @@ void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { } } -void MemoryHandler::registerStream(cudaStream_t stream) { +void CuMem::registerStream(cudaStream_t stream) { CHECK(initialized_); if (using_pool_) { CNMEM_CHECK(cnmemRegisterStream(stream)); } } -void MemoryHandler::destroy() { +void CuMem::destroy() { CHECK(initialized_); CNMEM_CHECK(cnmemFinalize()); initialized_ = false; using_pool_ = false; } -void MemoryHandler::init(const std::vector& gpus, bool use_pool) { +void CuMem::init(const std::vector& gpus, bool use_pool) { CHECK(!initialized_); #ifdef USE_CNMEM if (false /* use_pool */) { @@ -80,11 +80,11 @@ void MemoryHandler::init(const std::vector& gpus, bool use_pool) { } #endif initialized_ = true; - std::cout << "MemoryHandler initialized" << + std::cout << "CuMem initialized" << (using_pool_ ? " with CNMEM pool.\n" : " with CUDA allocator.\n"); } -void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { +void CuMem::getInfo(size_t *free_mem, size_t *total_mem) { if (using_pool_) { CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); } else { diff --git a/src/caffe/syncedmem.cpp b/src/caffe/syncedmem.cpp index 417cf9d0f7e..abbc32c8ced 100644 --- a/src/caffe/syncedmem.cpp +++ b/src/caffe/syncedmem.cpp @@ -18,7 +18,7 @@ SyncedMemory::~SyncedMemory() { if (gpu_device_ != -1) { CUDA_CHECK(cudaSetDevice(gpu_device_)); } - MemoryHandler::freeGPU(gpu_ptr_); + CuMem::freeGPU(gpu_ptr_); cudaSetDevice(initial_device); } #endif // CPU_ONLY @@ -55,7 +55,7 @@ inline void SyncedMemory::to_gpu() { switch (head_) { case UNINITIALIZED: CUDA_CHECK(cudaGetDevice(&gpu_device_)); - MemoryHandler::mallocGPU(&gpu_ptr_, size_); + CuMem::mallocGPU(&gpu_ptr_, size_); caffe_gpu_memset(size_, 0, gpu_ptr_); head_ = HEAD_AT_GPU; own_gpu_data_ = true; @@ -63,7 +63,7 @@ inline void SyncedMemory::to_gpu() { case HEAD_AT_CPU: if (gpu_ptr_ == NULL) { CUDA_CHECK(cudaGetDevice(&gpu_device_)); - MemoryHandler::mallocGPU(&gpu_ptr_, size_); + CuMem::mallocGPU(&gpu_ptr_, size_); own_gpu_data_ = true; } caffe_gpu_memcpy(size_, cpu_ptr_, gpu_ptr_); @@ -111,7 +111,7 @@ void SyncedMemory::set_gpu_data(void* data) { if (gpu_device_ != -1) { CUDA_CHECK(cudaSetDevice(gpu_device_)); } - MemoryHandler::freeGPU(gpu_ptr_); + CuMem::freeGPU(gpu_ptr_); cudaSetDevice(initial_device); } gpu_ptr_ = data; @@ -143,7 +143,7 @@ void SyncedMemory::async_gpu_push(const cudaStream_t& stream) { CHECK(head_ == HEAD_AT_CPU); if (gpu_ptr_ == NULL) { CUDA_CHECK(cudaGetDevice(&gpu_device_)); - MemoryHandler::mallocGPU(&gpu_ptr_, size_); + CuMem::mallocGPU(&gpu_ptr_, size_); own_gpu_data_ = true; } const cudaMemcpyKind put = cudaMemcpyHostToDevice; From 36eaec821306311f93269f587f483c03a4e906c0 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Thu, 8 Oct 2015 20:22:54 -0700 Subject: [PATCH 246/331] Reverted rename for now --- src/caffe/syncedmem.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/caffe/syncedmem.cpp b/src/caffe/syncedmem.cpp index abbc32c8ced..417cf9d0f7e 100644 --- a/src/caffe/syncedmem.cpp +++ b/src/caffe/syncedmem.cpp @@ -18,7 +18,7 @@ SyncedMemory::~SyncedMemory() { if (gpu_device_ != -1) { CUDA_CHECK(cudaSetDevice(gpu_device_)); } - CuMem::freeGPU(gpu_ptr_); + MemoryHandler::freeGPU(gpu_ptr_); cudaSetDevice(initial_device); } #endif // CPU_ONLY @@ -55,7 +55,7 @@ inline void SyncedMemory::to_gpu() { switch (head_) { case UNINITIALIZED: CUDA_CHECK(cudaGetDevice(&gpu_device_)); - CuMem::mallocGPU(&gpu_ptr_, size_); + MemoryHandler::mallocGPU(&gpu_ptr_, size_); caffe_gpu_memset(size_, 0, gpu_ptr_); head_ = HEAD_AT_GPU; own_gpu_data_ = true; @@ -63,7 +63,7 @@ inline void SyncedMemory::to_gpu() { case HEAD_AT_CPU: if (gpu_ptr_ == NULL) { CUDA_CHECK(cudaGetDevice(&gpu_device_)); - CuMem::mallocGPU(&gpu_ptr_, size_); + MemoryHandler::mallocGPU(&gpu_ptr_, size_); own_gpu_data_ = true; } caffe_gpu_memcpy(size_, cpu_ptr_, gpu_ptr_); @@ -111,7 +111,7 @@ void SyncedMemory::set_gpu_data(void* data) { if (gpu_device_ != -1) { CUDA_CHECK(cudaSetDevice(gpu_device_)); } - CuMem::freeGPU(gpu_ptr_); + MemoryHandler::freeGPU(gpu_ptr_); cudaSetDevice(initial_device); } gpu_ptr_ = data; @@ -143,7 +143,7 @@ void SyncedMemory::async_gpu_push(const cudaStream_t& stream) { CHECK(head_ == HEAD_AT_CPU); if (gpu_ptr_ == NULL) { CUDA_CHECK(cudaGetDevice(&gpu_device_)); - CuMem::mallocGPU(&gpu_ptr_, size_); + MemoryHandler::mallocGPU(&gpu_ptr_, size_); own_gpu_data_ = true; } const cudaMemcpyKind put = cudaMemcpyHostToDevice; From ab8a64626805465090460d8a5ddf50363b136f56 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Thu, 8 Oct 2015 20:31:04 -0700 Subject: [PATCH 247/331] restored missed functions --- src/caffe/common.cpp | 63 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index 5553f39f8cd..ad3960bc75f 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -231,6 +231,69 @@ Caffe::RNG& Caffe::RNG::operator=(const RNG& other) { void* Caffe::RNG::generator() { return static_cast(generator_->rng()); } + +const char* cublasGetErrorString(cublasStatus_t error) { + switch (error) { + case CUBLAS_STATUS_SUCCESS: + return "CUBLAS_STATUS_SUCCESS"; + case CUBLAS_STATUS_NOT_INITIALIZED: + return "CUBLAS_STATUS_NOT_INITIALIZED"; + case CUBLAS_STATUS_ALLOC_FAILED: + return "CUBLAS_STATUS_ALLOC_FAILED"; + case CUBLAS_STATUS_INVALID_VALUE: + return "CUBLAS_STATUS_INVALID_VALUE"; + case CUBLAS_STATUS_ARCH_MISMATCH: + return "CUBLAS_STATUS_ARCH_MISMATCH"; + case CUBLAS_STATUS_MAPPING_ERROR: + return "CUBLAS_STATUS_MAPPING_ERROR"; + case CUBLAS_STATUS_EXECUTION_FAILED: + return "CUBLAS_STATUS_EXECUTION_FAILED"; + case CUBLAS_STATUS_INTERNAL_ERROR: + return "CUBLAS_STATUS_INTERNAL_ERROR"; +#if CUDA_VERSION >= 6000 + case CUBLAS_STATUS_NOT_SUPPORTED: + return "CUBLAS_STATUS_NOT_SUPPORTED"; +#endif +#if CUDA_VERSION >= 6050 + case CUBLAS_STATUS_LICENSE_ERROR: + return "CUBLAS_STATUS_LICENSE_ERROR"; +#endif + } + return "Unknown cublas status"; +} + +const char* curandGetErrorString(curandStatus_t error) { + switch (error) { + case CURAND_STATUS_SUCCESS: + return "CURAND_STATUS_SUCCESS"; + case CURAND_STATUS_VERSION_MISMATCH: + return "CURAND_STATUS_VERSION_MISMATCH"; + case CURAND_STATUS_NOT_INITIALIZED: + return "CURAND_STATUS_NOT_INITIALIZED"; + case CURAND_STATUS_ALLOCATION_FAILED: + return "CURAND_STATUS_ALLOCATION_FAILED"; + case CURAND_STATUS_TYPE_ERROR: + return "CURAND_STATUS_TYPE_ERROR"; + case CURAND_STATUS_OUT_OF_RANGE: + return "CURAND_STATUS_OUT_OF_RANGE"; + case CURAND_STATUS_LENGTH_NOT_MULTIPLE: + return "CURAND_STATUS_LENGTH_NOT_MULTIPLE"; + case CURAND_STATUS_DOUBLE_PRECISION_REQUIRED: + return "CURAND_STATUS_DOUBLE_PRECISION_REQUIRED"; + case CURAND_STATUS_LAUNCH_FAILURE: + return "CURAND_STATUS_LAUNCH_FAILURE"; + case CURAND_STATUS_PREEXISTING_FAILURE: + return "CURAND_STATUS_PREEXISTING_FAILURE"; + case CURAND_STATUS_INITIALIZATION_FAILED: + return "CURAND_STATUS_INITIALIZATION_FAILED"; + case CURAND_STATUS_ARCH_MISMATCH: + return "CURAND_STATUS_ARCH_MISMATCH"; + case CURAND_STATUS_INTERNAL_ERROR: + return "CURAND_STATUS_INTERNAL_ERROR"; + } + return "Unknown curand status"; +} + #endif // CPU_ONLY } // namespace caffe From 46cc594482d494df53bc475291295d74f0f23ebf Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Fri, 9 Oct 2015 17:42:27 -0700 Subject: [PATCH 248/331] restored use_pool check --- src/caffe/CuMem.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/caffe/CuMem.cpp b/src/caffe/CuMem.cpp index 0661e785d16..e79e64703d9 100644 --- a/src/caffe/CuMem.cpp +++ b/src/caffe/CuMem.cpp @@ -52,7 +52,7 @@ void CuMem::destroy() { void CuMem::init(const std::vector& gpus, bool use_pool) { CHECK(!initialized_); #ifdef USE_CNMEM - if (false /* use_pool */) { + if (use_pool) { using_pool_ = true; cnmemDevice_t *devs = new cnmemDevice_t[gpus.size()]; From d82e665a3d52a990bbc373b9ab2b8a3cb1f1aea6 Mon Sep 17 00:00:00 2001 From: Sergei Nikolaev Date: Sun, 11 Oct 2015 21:47:46 -0700 Subject: [PATCH 249/331] Merged diffs from NVIDIA/caffe-0.14 and made all tests work. --- include/caffe/vision_layers.hpp | 16 +-- src/caffe/layer_factory.cpp | 6 ++ src/caffe/layers/cudnn_conv_layer.cpp | 138 +------------------------- src/caffe/layers/cudnn_conv_layer.cu | 60 +++++++---- 4 files changed, 54 insertions(+), 166 deletions(-) diff --git a/include/caffe/vision_layers.hpp b/include/caffe/vision_layers.hpp index 04d71c94d30..103875a3390 100644 --- a/include/caffe/vision_layers.hpp +++ b/include/caffe/vision_layers.hpp @@ -305,23 +305,13 @@ class CuDNNConvolutionLayer : public ConvolutionLayer { cudnnHandle_t* handle_; cudaStream_t* stream_; - // algorithms for forward and backwards convolutions - cudnnConvolutionFwdAlgo_t *fwd_algo_; - cudnnConvolutionBwdFilterAlgo_t *bwd_filter_algo_; - cudnnConvolutionBwdDataAlgo_t *bwd_data_algo_; - vector bottom_descs_, top_descs_; cudnnTensorDescriptor_t bias_desc_; cudnnFilterDescriptor_t filter_desc_; vector conv_descs_; - int bottom_offset_, top_offset_, weight_offset_, bias_offset_; - - size_t *workspace_fwd_sizes_; - size_t *workspace_bwd_data_sizes_; - size_t *workspace_bwd_filter_sizes_; - size_t workspaceSizeInBytes; // size of underlying storage - void *workspaceData; // underlying storage - void **workspace; // aliases into workspaceData + int bottom_offset_, top_offset_, bias_offset_; + size_t workspaceSizeInBytes; + void *workspace; }; #endif diff --git a/src/caffe/layer_factory.cpp b/src/caffe/layer_factory.cpp index 989c348c1bb..21f51bf514c 100644 --- a/src/caffe/layer_factory.cpp +++ b/src/caffe/layer_factory.cpp @@ -55,6 +55,12 @@ shared_ptr > GetPoolingLayer(const LayerParameter& param) { #ifdef USE_CUDNN } else if (engine == PoolingParameter_Engine_CUDNN) { PoolingParameter p_param = param.pooling_param(); + if (p_param.pad() || p_param.pad_h() || p_param.pad_w() || + param.top_size() > 1) { + LOG(INFO) << "CUDNN does not support padding or multiple tops. " + << "Using Caffe's own pooling layer."; + return shared_ptr >(new PoolingLayer(param)); + } return shared_ptr >(new CuDNNPoolingLayer(param)); #endif } else { diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index d7b1e0d651f..3514fe2aba5 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -1,5 +1,4 @@ #ifdef USE_CUDNN -#include #include #include "caffe/filler.hpp" @@ -25,38 +24,13 @@ void CuDNNConvolutionLayer::LayerSetUp( // Initialize CUDA streams and cuDNN. stream_ = new cudaStream_t[this->group_ * CUDNN_STREAMS_PER_GROUP]; handle_ = new cudnnHandle_t[this->group_ * CUDNN_STREAMS_PER_GROUP]; - - // Initialize algorithm arrays - fwd_algo_ = new cudnnConvolutionFwdAlgo_t[bottom.size()]; - bwd_filter_algo_= new cudnnConvolutionBwdFilterAlgo_t[bottom.size()]; - bwd_data_algo_ = new cudnnConvolutionBwdDataAlgo_t[bottom.size()]; - - // initialize size arrays - workspace_fwd_sizes_ = new size_t[bottom.size()]; - workspace_bwd_filter_sizes_ = new size_t[bottom.size()]; - workspace_bwd_data_sizes_ = new size_t[bottom.size()]; - - // workspace data workspaceSizeInBytes = 0; - workspaceData = NULL; - workspace = new void*[this->group_ * CUDNN_STREAMS_PER_GROUP]; - - for (size_t i = 0; i < bottom.size(); ++i) { - // initialize all to default algorithms - fwd_algo_[i] = (cudnnConvolutionFwdAlgo_t)0; - bwd_filter_algo_[i] = (cudnnConvolutionBwdFilterAlgo_t)0; - bwd_data_algo_[i] = (cudnnConvolutionBwdDataAlgo_t)0; - // default algorithms don't require workspace - workspace_fwd_sizes_[i] = 0; - workspace_bwd_data_sizes_[i] = 0; - workspace_bwd_filter_sizes_[i] = 0; - } + workspace = NULL; for (int g = 0; g < this->group_ * CUDNN_STREAMS_PER_GROUP; g++) { CUDA_CHECK(cudaStreamCreate(&stream_[g])); CUDNN_CHECK(cudnnCreate(&handle_[g])); CUDNN_CHECK(cudnnSetStream(handle_[g], stream_[g])); - workspace[g] = NULL; } // Set the indexing parameters. @@ -112,10 +86,6 @@ void CuDNNConvolutionLayer::Reshape( const int stride_h = stride_data[0]; const int stride_w = stride_data[1]; - // Specify workspace limit for kernels directly until we have a - // planning strategy and a rewrite of Caffe's GPU memory mangagement - size_t workspace_limit_bytes = 8*1024*1024; - for (int i = 0; i < bottom.size(); i++) { cudnn::setTensor4dDesc(&bottom_descs_[i], this->num_, @@ -128,104 +98,7 @@ void CuDNNConvolutionLayer::Reshape( this->num_output_ * this->out_spatial_dim_, this->out_spatial_dim_, width_out, 1); cudnn::setConvolutionDesc(&conv_descs_[i], bottom_descs_[i], - filter_desc_, pad_h, pad_w, - stride_h, stride_w); - - // choose forward and backward algorithms + workspace(s) - CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm(handle_[0], - bottom_descs_[i], - filter_desc_, - conv_descs_[i], - top_descs_[i], - CUDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT, - workspace_limit_bytes, - &fwd_algo_[i])); - - CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize(handle_[0], - bottom_descs_[i], - filter_desc_, - conv_descs_[i], - top_descs_[i], - fwd_algo_[i], - &(workspace_fwd_sizes_[i]))); - - // choose backward algorithm for filter - CUDNN_CHECK(cudnnGetConvolutionBackwardFilterAlgorithm(handle_[0], - bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, - CUDNN_CONVOLUTION_BWD_FILTER_SPECIFY_WORKSPACE_LIMIT, - workspace_limit_bytes, &bwd_filter_algo_[i]) ); - - // get workspace for backwards filter algorithm - CUDNN_CHECK(cudnnGetConvolutionBackwardFilterWorkspaceSize(handle_[0], - bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, - bwd_filter_algo_[i], &workspace_bwd_filter_sizes_[i])); - - // choose backward algo for data - CUDNN_CHECK(cudnnGetConvolutionBackwardDataAlgorithm(handle_[0], - filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], - CUDNN_CONVOLUTION_BWD_DATA_SPECIFY_WORKSPACE_LIMIT, - workspace_limit_bytes, &bwd_data_algo_[i])); - - // get workspace size - CUDNN_CHECK(cudnnGetConvolutionBackwardDataWorkspaceSize(handle_[0], - filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], - bwd_data_algo_[i], &workspace_bwd_data_sizes_[i]) ); - } - - // reduce over all workspace sizes to get a maximum to allocate / reallocate - size_t total_workspace_fwd = 0; - size_t total_workspace_bwd_data = 0; - size_t total_workspace_bwd_filter = 0; - - for (size_t i = 0; i < bottom.size(); i++) { - total_workspace_fwd = std::max(total_workspace_fwd, - workspace_fwd_sizes_[i]); - total_workspace_bwd_data = std::max(total_workspace_bwd_data, - workspace_bwd_data_sizes_[i]); - total_workspace_bwd_filter = std::max(total_workspace_bwd_filter, - workspace_bwd_filter_sizes_[i]); - } - // get max over all operations - size_t max_workspace = std::max(total_workspace_fwd, - total_workspace_bwd_data); - max_workspace = std::max(max_workspace, total_workspace_bwd_filter); - // ensure all groups have enough workspace - size_t total_max_workspace = max_workspace * - (this->group_ * CUDNN_STREAMS_PER_GROUP); - - // this is the total amount of storage needed over all groups + streams - if (total_max_workspace > workspaceSizeInBytes) { - LOG(INFO) << "Reallocating workspace storage: " << total_max_workspace; - workspaceSizeInBytes = total_max_workspace; - - // free the existing workspace and allocate a new (larger) one - cudaFree(this->workspaceData); - - cudaError_t err = cudaMalloc(&(this->workspaceData), workspaceSizeInBytes); - if (err != cudaSuccess) { - // force zero memory path - for (int i = 0; i < bottom.size(); i++) { - workspace_fwd_sizes_[i] = 0; - workspace_bwd_filter_sizes_[i] = 0; - workspace_bwd_data_sizes_[i] = 0; - fwd_algo_[i] = CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM; - bwd_filter_algo_[i] = CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0; - bwd_data_algo_[i] = CUDNN_CONVOLUTION_BWD_DATA_ALGO_0; - } - - // NULL out all workspace pointers - for (int g = 0; g < (this->group_ * CUDNN_STREAMS_PER_GROUP); g++) { - workspace[g] = NULL; - } - // NULL out underlying data - workspaceData = NULL; - workspaceSizeInBytes = 0; - } - - // if we succeed in the allocation, set pointer aliases for workspaces - for (int g = 0; g < (this->group_ * CUDNN_STREAMS_PER_GROUP); g++) { - workspace[g] = reinterpret_cast(workspaceData) + g*max_workspace; - } + filter_desc_, pad_h, pad_w, stride_h, stride_w); } // Tensor descriptor for bias. @@ -255,15 +128,8 @@ CuDNNConvolutionLayer::~CuDNNConvolutionLayer() { cudnnDestroy(handle_[g]); } - cudaFree(workspaceData); delete [] stream_; delete [] handle_; - delete [] fwd_algo_; - delete [] bwd_filter_algo_; - delete [] bwd_data_algo_; - delete [] workspace_fwd_sizes_; - delete [] workspace_bwd_data_sizes_; - delete [] workspace_bwd_filter_sizes_; } INSTANTIATE_CLASS(CuDNNConvolutionLayer); diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index 6edd7043c93..a4e1bdbee17 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -26,25 +26,59 @@ void CuDNNConvolutionLayer::Forward_gpu( // Forward through cuDNN in parallel over groups. for (int g = 0; g < this->group_; g++) { + cudnnConvolutionFwdAlgo_t algo; + + // pick the convolution algorithm + // TODO(shelhamer) this should be done during reshape + // TODO(shelhamer) the choice of automatic or manual algorithm picking + // should be exposed in proto + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm(handle_[g], + bottom_descs_[i], + filter_desc_, + conv_descs_[i], + top_descs_[i], + CUDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT, + workspace_limit_bytes, // memoryLimitInBytes, + &algo)); + + // get minimum size of the workspace needed for the desired algorithm + size_t workspaceSizeInBytes_temp = 0; + + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize(handle_[g], + bottom_descs_[i], + filter_desc_, + conv_descs_[i], + top_descs_[i], + algo, + &workspaceSizeInBytes_temp)); + + if (workspaceSizeInBytes_temp > workspaceSizeInBytes) { + workspaceSizeInBytes = workspaceSizeInBytes_temp; + // free the existing workspace and allocate a new (larger) one + cudaFree(this->workspace); + cudaError_t err = cudaMalloc(&(this->workspace), workspaceSizeInBytes); + if (err != cudaSuccess) { + // force zero memory path + algo = CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM; + workspace = NULL; + workspaceSizeInBytes = 0; + } + } + // Filters. CUDNN_CHECK(cudnnConvolutionForward(handle_[g], cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, filter_desc_, weight + this->weight_offset_ * g, conv_descs_[i], - fwd_algo_[i], workspace[g], workspace_fwd_sizes_[i], + algo, workspace, workspaceSizeInBytes, cudnn::dataType::zero, top_descs_[i], top_data + top_offset_ * g)); // Bias. if (this->bias_term_) { const Dtype* bias_data = this->blobs_[1]->gpu_data(); -#if (CUDNN_MAJOR >= 4) - CUDNN_CHECK(cudnnAddTensor_v2 -#else - CUDNN_CHECK(cudnnAddTensor -#endif - (handle_[g], CUDNN_ADD_SAME_C, + CUDNN_CHECK(cudnnAddTensor_v3(handle_[g], //CUDNN_ADD_SAME_C, cudnn::dataType::one, bias_desc_, bias_data + bias_offset_ * g, cudnn::dataType::one, @@ -67,12 +101,10 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, if (this->param_propagate_down_[0]) { weight = this->blobs_[0]->gpu_data(); weight_diff = this->blobs_[0]->mutable_gpu_diff(); - caffe_gpu_set(this->blobs_[0]->count(), Dtype(0), weight_diff); } Dtype* bias_diff = NULL; if (this->bias_term_ && this->param_propagate_down_[1]) { bias_diff = this->blobs_[1]->mutable_gpu_diff(); - caffe_gpu_set(this->blobs_[1]->count(), Dtype(0), bias_diff); } for (int i = 0; i < top.size(); ++i) { const Dtype* top_diff = top[i]->gpu_diff(); @@ -90,14 +122,11 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, // Gradient w.r.t. weights. if (this->param_propagate_down_[0]) { const Dtype* bottom_data = bottom[i]->gpu_data(); - CUDNN_CHECK(cudnnConvolutionBackwardFilter_v3( - handle_[1*this->group_ + g], + CUDNN_CHECK(cudnnConvolutionBackwardFilter_v2(handle_[1*this->group_ + g], cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], - bwd_filter_algo_[i], workspace[1*this->group_ + g], - workspace_bwd_filter_sizes_[i], cudnn::dataType::one, filter_desc_, weight_diff + this->weight_offset_ * g)); } @@ -108,14 +137,11 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, weight = this->blobs_[0]->gpu_data(); } Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnConvolutionBackwardData_v3( - handle_[2*this->group_ + g], + CUDNN_CHECK(cudnnConvolutionBackwardData_v2(handle_[2*this->group_ + g], cudnn::dataType::one, filter_desc_, weight + this->weight_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], - bwd_data_algo_[i], workspace[2*this->group_ + g], - workspace_bwd_data_sizes_[i], cudnn::dataType::zero, bottom_descs_[i], bottom_diff + bottom_offset_ * g)); } From ba10864daa5f5eb695fda4e6b590e78f5f68fd33 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Mon, 12 Oct 2015 02:18:09 -0700 Subject: [PATCH 250/331] perparing for merge --- .../caffe/{CuMem.hpp => MemoryHandler.hpp} | 18 ++++++++--------- include/caffe/common.hpp | 6 +----- src/caffe/{CuMem.cpp => MemoryHandler.cpp} | 20 +++++++++---------- 3 files changed, 20 insertions(+), 24 deletions(-) rename include/caffe/{CuMem.hpp => MemoryHandler.hpp} (72%) rename src/caffe/{CuMem.cpp => MemoryHandler.cpp} (75%) diff --git a/include/caffe/CuMem.hpp b/include/caffe/MemoryHandler.hpp similarity index 72% rename from include/caffe/CuMem.hpp rename to include/caffe/MemoryHandler.hpp index 725e65a4c0c..d31fc4efb3f 100644 --- a/include/caffe/CuMem.hpp +++ b/include/caffe/MemoryHandler.hpp @@ -1,5 +1,5 @@ -#ifndef CAFFE_CUMEM_HPP_ -#define CAFFE_CUMEM_HPP_ +#ifndef CAFFE_MEMORYHANDLER_HPP_ +#define CAFFE_MEMORYHANDLER_HPP_ #include "common.hpp" @@ -10,7 +10,7 @@ namespace caffe { -class CuMem { +class MemoryHandler { public: #ifndef CPU_ONLY static void mallocGPU(void **ptr, size_t size, @@ -29,27 +29,27 @@ class CuMem { static void init(const std::vector& gpus_, bool use_pool=true); static void destroy(); - friend class CuMemActivator; + friend class MemoryHandlerActivator; static bool using_pool_; static bool initialized_; }; -class CuMemActivator { +class MemoryHandlerActivator { public: - explicit CuMemActivator(const std::vector& gpus) + explicit MemoryHandlerActivator(const std::vector& gpus) : using_pool_(false) { if (gpus.size() > 0) { #ifdef USE_CNMEM using_pool_ = true; #endif - CuMem::init(gpus, using_pool_); + MemoryHandler::init(gpus, using_pool_); } } - ~CuMemActivator() { + ~MemoryHandlerActivator() { if (using_pool_) { - CuMem::destroy(); + MemoryHandler::destroy(); } } private: diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index 699fc81bb18..421e52dd6c3 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -65,11 +65,7 @@ private:\ // is executed we will see a fatal log. #define NOT_IMPLEMENTED LOG(FATAL) << "Not Implemented Yet" -#include "CuMem.hpp" - -// bfomitchev: temporary, for better merge -#define MemoryHandler CuMem -#define MemoryHandlerActivator CuMemActivator +#include "MemoryHandler.hpp" // See PR #1236 namespace cv { class Mat; } diff --git a/src/caffe/CuMem.cpp b/src/caffe/MemoryHandler.cpp similarity index 75% rename from src/caffe/CuMem.cpp rename to src/caffe/MemoryHandler.cpp index e79e64703d9..fddbdd8cdca 100644 --- a/src/caffe/CuMem.cpp +++ b/src/caffe/MemoryHandler.cpp @@ -1,12 +1,12 @@ #include "caffe/common.hpp" -#include "caffe/CuMem.hpp" +#include "caffe/MemoryHandler.hpp" #include namespace caffe { -bool CuMem::using_pool_ = false; -bool CuMem::initialized_ = false; +bool MemoryHandler::using_pool_ = false; +bool MemoryHandler::initialized_ = false; using namespace boost; @@ -16,7 +16,7 @@ using namespace boost; #ifndef CPU_ONLY // CPU-only Caffe. -void CuMem::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { +void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { CHECK(initialized_); if (using_pool_) { CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); @@ -26,7 +26,7 @@ void CuMem::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { } -void CuMem::freeGPU(void *ptr, cudaStream_t stream) { +void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { CHECK(initialized_); if (using_pool_) { CNMEM_CHECK(cnmemFree(ptr, stream)); @@ -35,21 +35,21 @@ void CuMem::freeGPU(void *ptr, cudaStream_t stream) { } } -void CuMem::registerStream(cudaStream_t stream) { +void MemoryHandler::registerStream(cudaStream_t stream) { CHECK(initialized_); if (using_pool_) { CNMEM_CHECK(cnmemRegisterStream(stream)); } } -void CuMem::destroy() { +void MemoryHandler::destroy() { CHECK(initialized_); CNMEM_CHECK(cnmemFinalize()); initialized_ = false; using_pool_ = false; } -void CuMem::init(const std::vector& gpus, bool use_pool) { +void MemoryHandler::init(const std::vector& gpus, bool use_pool) { CHECK(!initialized_); #ifdef USE_CNMEM if (use_pool) { @@ -80,11 +80,11 @@ void CuMem::init(const std::vector& gpus, bool use_pool) { } #endif initialized_ = true; - std::cout << "CuMem initialized" << + std::cout << "MemoryHandler initialized" << (using_pool_ ? " with CNMEM pool.\n" : " with CUDA allocator.\n"); } -void CuMem::getInfo(size_t *free_mem, size_t *total_mem) { +void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { if (using_pool_) { CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); } else { From 3931c2051ba0af23dfc5a0ba21520faa90856ac9 Mon Sep 17 00:00:00 2001 From: Sergei Nikolaev Date: Mon, 12 Oct 2015 13:56:56 -0700 Subject: [PATCH 251/331] Merged Simon's V3 branch and fixed compiler warnings --- src/caffe/layers/cudnn_conv_layer.cu | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index 8065ae1a69e..4242fc0acb4 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -14,11 +14,6 @@ __global__ void sync_conv_groups() { } template void CuDNNConvolutionLayer::Forward_gpu( const vector*>& bottom, const vector*>& top) { - const int* kernel_shape_data = this->kernel_shape_.cpu_data(); - const int kernel_h = kernel_shape_data[0]; - const int kernel_w = kernel_shape_data[1]; - const size_t workspace_limit_bytes = - kernel_h * kernel_w * this->channels_ * sizeof(int) + 1; const Dtype* weight = this->blobs_[0]->gpu_data(); for (int i = 0; i < bottom.size(); ++i) { const Dtype* bottom_data = bottom[i]->gpu_data(); From 908f0821f72173738834f89a5488c57e35293d0f Mon Sep 17 00:00:00 2001 From: Simon Layton Date: Tue, 30 Jun 2015 13:59:08 -0400 Subject: [PATCH 252/331] 488f1264805538df1282c143cc5acbf0eb694afc Add CNMeM support Conflicts: Makefile Makefile.config.example src/caffe/layers/cudnn_conv_layer.cpp src/caffe/layers/cudnn_conv_layer.cu src/caffe/layers/cudnn_lcn_layer.cpp src/caffe/layers/cudnn_lcn_layer.cu --- Makefile | 6 ++ Makefile.config.example | 2 + include/caffe/common.hpp | 61 +++++++++++++ include/caffe/parallel.hpp | 2 + include/caffe/util/device_alternate.hpp | 11 +++ src/caffe/common.cpp | 113 +++++++++++++++++++++++- src/caffe/layers/cudnn_conv_layer.cpp | 22 ++++- src/caffe/layers/cudnn_conv_layer.cu | 40 +++++++-- src/caffe/layers/cudnn_lcn_layer.cpp | 14 ++- src/caffe/layers/cudnn_lcn_layer.cu | 24 +++++ src/caffe/layers/dropout_layer.cu | 2 +- src/caffe/parallel.cpp | 27 ++++-- src/caffe/syncedmem.cpp | 10 +-- src/caffe/test/test_lrn_layer.cpp | 2 + tools/caffe.cpp | 6 ++ 15 files changed, 315 insertions(+), 27 deletions(-) diff --git a/Makefile b/Makefile index 5fb6394e947..261c6437f9e 100644 --- a/Makefile +++ b/Makefile @@ -304,6 +304,12 @@ ifeq ($(USE_CUDNN), 1) COMMON_FLAGS += -DUSE_CUDNN endif +# cuMEM integration +ifeq ($(USE_CNMEM), 1) + LIBRARIES += cnmem + COMMON_FLAGS += -DUSE_CNMEM +endif + # configure IO libraries ifeq ($(USE_OPENCV), 1) COMMON_FLAGS += -DUSE_OPENCV diff --git a/Makefile.config.example b/Makefile.config.example index a20bad2f5ce..8c8731e226f 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -3,6 +3,8 @@ # cuDNN acceleration switch (uncomment to build with cuDNN). # USE_CUDNN := 1 +# CNMeM memory pool switch (github.com/NVIDIA/cnmem required) +# USE_CNMEM := 1 # CPU-only switch (uncomment to build without GPU support). # CPU_ONLY := 1 diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index 1df6b9a14fb..e79362d2274 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -18,6 +18,11 @@ #include "caffe/util/device_alternate.hpp" +#ifdef USE_CNMEM +// cuMEM integration +#include +#endif + // gflags 2.1 issue: namespace google was changed to gflags without warning. // Luckily we will be able to use GFLAGS_GFLAGS_H_ to detect if it is version // 2.1. If yes, we will add a temporary solution to redirect the namespace. @@ -173,6 +178,62 @@ class Caffe { DISABLE_COPY_AND_ASSIGN(Caffe); }; +class MemoryHandler { + public: + static MemoryHandler& Get(); +#ifndef CPU_ONLY + static void mallocGPU(void **ptr, size_t size, + cudaStream_t stream = cudaStreamDefault); + static void freeGPU(void *ptr, cudaStream_t = cudaStreamDefault); + static void registerStream(cudaStream_t stream); +#endif + static void setGPUs(const std::vector& gpus) { Get().gpus_ = gpus; } + static void usePool() { Get().using_pool_ = true; } + static bool usingPool() { +#ifdef USE_CNMEM + return Get().using_pool_; +#else + return false; +#endif + } + static void getInfo(size_t *free_mem, size_t *used_mem); + static void destroy(); + ~MemoryHandler() { } + + private: + MemoryHandler() : using_pool_(false), initialized_(false) {} + static void Init(); + // static void Destroy(); +#ifndef CPU_ONLY + void allocate_memory(void **ptr, size_t size, cudaStream_t stream); + void free_memory(void *ptr, cudaStream_t stream); +#endif + DISABLE_COPY_AND_ASSIGN(MemoryHandler); + + bool using_pool_; + bool initialized_; + std::vector gpus_; +}; + +class MemoryHandlerActivator { + public: + explicit MemoryHandlerActivator(const std::vector& gpus) + : using_pool_(false) { + if (gpus.size() > 0) { + using_pool_ = true; + MemoryHandler::usePool(); + MemoryHandler::setGPUs(gpus); + } + } + ~MemoryHandlerActivator() { + if (using_pool_) { + MemoryHandler::destroy(); + } + } + private: + int using_pool_; +}; + } // namespace caffe #endif // CAFFE_COMMON_HPP_ diff --git a/include/caffe/parallel.hpp b/include/caffe/parallel.hpp index 85fc2b55984..a3eb960c7d7 100644 --- a/include/caffe/parallel.hpp +++ b/include/caffe/parallel.hpp @@ -57,6 +57,8 @@ class GPUParams : public Params { using Params::size_; using Params::data_; using Params::diff_; + private: + int buffer_device_; }; class DevicePair { diff --git a/include/caffe/util/device_alternate.hpp b/include/caffe/util/device_alternate.hpp index 6ea595dba2d..55d616fbf71 100644 --- a/include/caffe/util/device_alternate.hpp +++ b/include/caffe/util/device_alternate.hpp @@ -66,6 +66,17 @@ void classname::funcname##_##gpu(const vector*>& top, \ << caffe::curandGetErrorString(status); \ } while (0) +#ifdef USE_CNMEM + +#define CNMEM_CHECK(condition) \ + do { \ + cnmemStatus_t status = condition; \ + CHECK_EQ(status, CNMEM_STATUS_SUCCESS) << " " \ + << cnmemGetErrorString(status); \ + } while (0) + +#endif + // CUDA: grid stride looping #define CUDA_KERNEL_LOOP(i, n) \ for (int i = blockIdx.x * blockDim.x + threadIdx.x; \ diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index 299d67d4bec..9a20a04fb44 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -3,15 +3,18 @@ #include #include #include +#include #include "caffe/common.hpp" #include "caffe/util/rng.hpp" namespace caffe { +static boost::shared_ptr mem_handler; // Make sure each thread can have different values. static boost::thread_specific_ptr thread_instance_; + Caffe& Caffe::Get() { if (!thread_instance_.get()) { thread_instance_.reset(new Caffe()); @@ -192,7 +195,6 @@ void Caffe::DeviceQuery() { return; } - class Caffe::RNG::Generator { public: Generator() : rng_(new caffe::rng_t(cluster_seedgen())) {} @@ -215,6 +217,115 @@ void* Caffe::RNG::generator() { return static_cast(generator_->rng()); } +static boost::mutex memHandlerMutex; + +MemoryHandler& MemoryHandler::Get() { + boost::mutex::scoped_lock lock(memHandlerMutex); + if (!mem_handler.get()) { + mem_handler.reset(new MemoryHandler()); + } + return *(mem_handler.get()); +} + +void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { + if (!Get().initialized_) { + Init(); + } + Get().allocate_memory(ptr, size, stream); +} + +void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { + Get().free_memory(ptr, stream); +} + +void MemoryHandler::allocate_memory(void **ptr, size_t size, + cudaStream_t stream) { + int initial_device; + cudaGetDevice(&initial_device); + if (size == 0) return; + if (using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); +#endif + } else { + CUDA_CHECK(cudaMalloc(ptr, size)); + } + cudaSetDevice(initial_device); +} + +void MemoryHandler::free_memory(void *ptr, cudaStream_t stream) { + // boost::mutex::scoped_lock lock(memHandlerMutex); + int initial_device; + cudaGetDevice(&initial_device); + if (using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemFree(ptr, stream)); +#endif + } else { + CUDA_CHECK(cudaFree(ptr)); + } + ptr = NULL; + cudaSetDevice(initial_device); +} + +void MemoryHandler::registerStream(cudaStream_t stream) { + if (!Get().initialized_) { + Init(); + } + if (Get().using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemRegisterStream(stream)); +#endif + } +} + +void MemoryHandler::destroy() { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemFinalize()); +#endif +} + +void MemoryHandler::Init() { + if (Get().using_pool_) { +#ifdef USE_CNMEM + cnmemDevice_t *devs = new cnmemDevice_t[Get().gpus_.size()]; + + int initial_device; + CUDA_CHECK(cudaGetDevice(&initial_device)); + + for (int i = 0; i < Get().gpus_.size(); i++) { + CUDA_CHECK(cudaSetDevice(Get().gpus_[i])); + + devs[i].device = Get().gpus_[i]; + + size_t free_mem, used_mem; + CUDA_CHECK(cudaMemGetInfo(&free_mem, &used_mem)); + + devs[i].size = size_t(0.8*free_mem); + devs[i].numStreams = 0; + devs[i].streams = NULL; + } + CNMEM_CHECK(cnmemInit(Get().gpus_.size(), devs, CNMEM_FLAGS_DEFAULT)); + Get().initialized_ = true; + + CUDA_CHECK(cudaSetDevice(initial_device)); + + delete [] devs; +#endif + } + Get().initialized_ = true; +} + +void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { + if (Get().using_pool_) { +#ifdef USE_CNMEM + CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); +#endif + } else { + CUDA_CHECK(cudaMemGetInfo(free_mem, total_mem)); + } +} + const char* cublasGetErrorString(cublasStatus_t error) { switch (error) { case CUBLAS_STATUS_SUCCESS: diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index eea4696efb6..278b035d6c8 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -57,6 +57,7 @@ void CuDNNConvolutionLayer::LayerSetUp( CUDNN_CHECK(cudnnCreate(&handle_[g])); CUDNN_CHECK(cudnnSetStream(handle_[g], stream_[g])); workspace[g] = NULL; + MemoryHandler::registerStream(stream_[g]); } // Set the indexing parameters. @@ -117,7 +118,13 @@ void CuDNNConvolutionLayer::Reshape( // Specify workspace limit for kernels directly until we have a // planning strategy and a rewrite of Caffe's GPU memory mangagement - size_t workspace_limit_bytes = 8*1024*1024; + size_t workspace_limit_bytes; + if (MemoryHandler::usingPool()) { + size_t total_memory; + MemoryHandler::getInfo(&workspace_limit_bytes, &total_memory); + } else { + workspace_limit_bytes = 8*1024*1024; + } for (int i = 0; i < bottom.size(); i++) { cudnn::setTensor4dDesc(&bottom_descs_[i], @@ -152,6 +159,14 @@ void CuDNNConvolutionLayer::Reshape( fwd_algo_[i], &(workspace_fwd_sizes_[i]))); + if (MemoryHandler::usingPool()) { + // restrict to only 1 convolution at a time for memory allocation purposes + size_t total_memory; + MemoryHandler::getInfo(&workspace_limit_bytes, &total_memory); + } else { + workspace_limit_bytes = 8*1024*1024; + } + // // choose backward algorithm for filter CUDNN_CHECK(cudnnGetConvolutionBackwardFilterAlgorithm(handle_[0], bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, @@ -175,6 +190,7 @@ void CuDNNConvolutionLayer::Reshape( bwd_data_algo_[i], &workspace_bwd_data_sizes_[i]) ); } +#ifndef USE_CNMEM // reduce over all workspace sizes to get a maximum to allocate / reallocate size_t total_workspace_fwd = 0; size_t total_workspace_bwd_data = 0; @@ -202,7 +218,8 @@ void CuDNNConvolutionLayer::Reshape( workspaceSizeInBytes = total_max_workspace; // free the existing workspace and allocate a new (larger) one - cudaFree(this->workspaceData); + MemoryHandler::freeGPU(this->workspaceData); + this->workspaceData = NULL; cudaError_t err = cudaMalloc(&(this->workspaceData), workspaceSizeInBytes); if (err != cudaSuccess) { @@ -230,6 +247,7 @@ void CuDNNConvolutionLayer::Reshape( workspace[g] = reinterpret_cast(workspaceData) + g*max_workspace; } } +#endif // Tensor descriptor for bias. if (this->bias_term_) { diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index 4242fc0acb4..b64f43e810d 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -21,16 +21,25 @@ void CuDNNConvolutionLayer::Forward_gpu( // Forward through cuDNN in parallel over groups. for (int g = 0; g < this->group_; g++) { +#ifdef USE_CNMEM + MemoryHandler::mallocGPU(&workspace[0], workspace_fwd_sizes_[i], + stream_[0]); +#endif // Filters. - CUDNN_CHECK(cudnnConvolutionForward(handle_[g], + // CUDNN_CHECK(cudnnConvolutionForward(handle_[g], + CUDNN_CHECK(cudnnConvolutionForward(handle_[0], cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, filter_desc_, weight + this->weight_offset_ * g, conv_descs_[i], - fwd_algo_[i], workspace[g], workspace_fwd_sizes_[i], + fwd_algo_[i], workspace[0], workspace_fwd_sizes_[i], cudnn::dataType::zero, top_descs_[i], top_data + top_offset_ * g)); +#ifdef USE_CNMEM + MemoryHandler::freeGPU(workspace[0], stream_[0]); + workspace[0] = NULL; +#endif // Bias. if (this->bias_term_) { const Dtype* bias_data = this->blobs_[1]->gpu_data(); @@ -70,7 +79,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, for (int g = 0; g < this->group_; g++) { // Gradient w.r.t. bias. if (this->bias_term_ && this->param_propagate_down_[1]) { - CUDNN_CHECK(cudnnConvolutionBackwardBias(handle_[0*this->group_ + g], + CUDNN_CHECK(cudnnConvolutionBackwardBias(handle_[0], cudnn::dataType::one, top_descs_[i], top_diff + top_offset_ * g, cudnn::dataType::one, @@ -79,17 +88,24 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, // Gradient w.r.t. weights. if (this->param_propagate_down_[0]) { +#ifdef USE_CNMEM + MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_filter_sizes_[i], + stream_[0]); +#endif const Dtype* bottom_data = bottom[i]->gpu_data(); CUDNN_CHECK(cudnnConvolutionBackwardFilter_v3( - handle_[1*this->group_ + g], + handle_[0], cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], - bwd_filter_algo_[i], workspace[1*this->group_ + g], - workspace_bwd_filter_sizes_[i], + bwd_filter_algo_[i], workspace[0], workspace_bwd_filter_sizes_[i], cudnn::dataType::one, filter_desc_, weight_diff + this->weight_offset_ * g)); +#ifdef USE_CNMEM + MemoryHandler::freeGPU(workspace[0], stream_[0]); + workspace[0] = NULL; +#endif } // Gradient w.r.t. bottom data. @@ -98,16 +114,24 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, weight = this->blobs_[0]->gpu_data(); } Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); +#ifdef USE_CNMEM + MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_data_sizes_[i], + stream_[0]); +#endif CUDNN_CHECK(cudnnConvolutionBackwardData_v3( - handle_[2*this->group_ + g], + handle_[0], cudnn::dataType::one, filter_desc_, weight + this->weight_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], - bwd_data_algo_[i], workspace[2*this->group_ + g], + bwd_data_algo_[i], workspace[0], workspace_bwd_data_sizes_[i], workspace_bwd_data_sizes_[i], cudnn::dataType::zero, bottom_descs_[i], bottom_diff + bottom_offset_ * g)); +#ifdef USE_CNMEM + MemoryHandler::freeGPU(workspace[0], stream_[0]); + workspace[0] = NULL; +#endif } } diff --git a/src/caffe/layers/cudnn_lcn_layer.cpp b/src/caffe/layers/cudnn_lcn_layer.cpp index 866d810b9f9..fb0031b97c9 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cpp +++ b/src/caffe/layers/cudnn_lcn_layer.cpp @@ -43,16 +43,22 @@ void CuDNNLCNLayer::Reshape(const vector*>& bottom, size_t totalSizeInBytes = sizeof(Dtype)*bottom[0]->num()* \ this->channels_*this->height_*this->width_; +#ifdef USE_CNMEM + this->tempDataSize = totalSizeInBytes; +#else if (totalSizeInBytes > tempDataSize) { tempDataSize = totalSizeInBytes; - cudaFree(tempData1); - cudaFree(tempData2); + MemoryHandler::freeGPU(tempData1); + MemoryHandler::freeGPU(tempData2); + tempData1 = NULL; + tempData2 = NULL; // allocate new buffers - CUDA_CHECK(cudaMalloc(&tempData1, totalSizeInBytes)); - CUDA_CHECK(cudaMalloc(&tempData2, totalSizeInBytes)); + MemoryHandler::mallocGPU(&tempData1, totalSizeInBytes); + MemoryHandler::mallocGPU(&tempData2, totalSizeInBytes); } +#endif } template diff --git a/src/caffe/layers/cudnn_lcn_layer.cu b/src/caffe/layers/cudnn_lcn_layer.cu index c07ade72066..e00f4f1d593 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cu +++ b/src/caffe/layers/cudnn_lcn_layer.cu @@ -15,6 +15,11 @@ void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); +#ifdef USE_CNMEM + MemoryHandler::mallocGPU(&this->tempData1, this->tempDataSize); + MemoryHandler::mallocGPU(&this->tempData2, this->tempDataSize); +#endif + CUDNN_CHECK(cudnnDivisiveNormalizationForward( handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, cudnn::dataType::one, @@ -23,6 +28,13 @@ void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, this->tempData1, this->tempData2, cudnn::dataType::zero, top_desc_, top_data) ); + +#ifdef USE_CNMEM + MemoryHandler::freeGPU(this->tempData1); + MemoryHandler::freeGPU(this->tempData2); + this->tempData1 = NULL; + this->tempData2 = NULL; +#endif } template @@ -33,6 +45,11 @@ void CuDNNLCNLayer::Backward_gpu(const vector*>& top, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); +#ifdef USE_CNMEM + MemoryHandler::mallocGPU(&this->tempData1, this->tempDataSize); + MemoryHandler::mallocGPU(&this->tempData2, this->tempDataSize); +#endif + CUDNN_CHECK(cudnnDivisiveNormalizationBackward( handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, cudnn::dataType::one, @@ -42,6 +59,13 @@ void CuDNNLCNLayer::Backward_gpu(const vector*>& top, cudnn::dataType::zero, bottom_desc_, bottom_diff, NULL) ); + +#ifdef USE_CNMEM + MemoryHandler::freeGPU(this->tempData1); + MemoryHandler::freeGPU(this->tempData2); + this->tempData1 = NULL; + this->tempData2 = NULL; +#endif } INSTANTIATE_LAYER_GPU_FUNCS(CuDNNLCNLayer); diff --git a/src/caffe/layers/dropout_layer.cu b/src/caffe/layers/dropout_layer.cu index f9ea04f4acf..552d1ff2cf7 100644 --- a/src/caffe/layers/dropout_layer.cu +++ b/src/caffe/layers/dropout_layer.cu @@ -30,11 +30,11 @@ void DropoutLayer::Forward_gpu(const vector*>& bottom, unsigned int* mask = static_cast(rand_vec_.mutable_gpu_data()); caffe_gpu_rng_uniform(count, mask); + CUDA_POST_KERNEL_CHECK; // set thresholds // NOLINT_NEXT_LINE(whitespace/operators) DropoutForward<<>>( count, bottom_data, mask, uint_thres_, scale_, top_data); - CUDA_POST_KERNEL_CHECK; } else { caffe_copy(count, bottom_data, top_data); } diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index a6d154e168e..cf244bcf916 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -86,14 +86,19 @@ GPUParams::GPUParams(shared_ptr > root_solver, int device) // Allocate device buffers CUDA_CHECK(cudaSetDevice(device)); - CUDA_CHECK(cudaMalloc(&data_, size_ * sizeof(Dtype))); + buffer_device_ = device; + // CUDA_CHECK(cudaMalloc(&data_, size_ * sizeof(Dtype))); + MemoryHandler::mallocGPU(reinterpret_cast(&data_), + size_ * sizeof(Dtype)); // Copy blob values const vector*>& net = root_solver->net()->learnable_params(); apply_buffers(net, data_, size_, copy); - CUDA_CHECK(cudaMalloc(&diff_, size_ * sizeof(Dtype))); + // CUDA_CHECK(cudaMalloc(&diff_, size_ * sizeof(Dtype))); + MemoryHandler::mallocGPU(reinterpret_cast(&diff_), + size_ * sizeof(Dtype)); caffe_gpu_set(size_, Dtype(0), diff_); CUDA_CHECK(cudaSetDevice(initial_device)); @@ -105,8 +110,14 @@ GPUParams::GPUParams(shared_ptr > root_solver, int device) template GPUParams::~GPUParams() { #ifndef CPU_ONLY - CUDA_CHECK(cudaFree(data_)); - CUDA_CHECK(cudaFree(diff_)); + int initial_device; + cudaGetDevice(&initial_device); + cudaSetDevice(buffer_device_); + MemoryHandler::freeGPU(data_); + MemoryHandler::freeGPU(diff_); + data_ = NULL; + diff_ = NULL; + cudaSetDevice(initial_device); #endif } @@ -239,7 +250,8 @@ P2PSync::P2PSync(shared_ptr > root_solver, } // Allocate receiving buffer on parent CUDA_CHECK(cudaSetDevice(peer)); - CUDA_CHECK(cudaMalloc(&parent_grads_, size_ * sizeof(Dtype))); + MemoryHandler::mallocGPU(reinterpret_cast(&parent_grads_), + size_ * sizeof(Dtype)); CUDA_CHECK(cudaSetDevice(self)); } @@ -258,8 +270,11 @@ P2PSync::~P2PSync() { CUDA_CHECK(cudaSetDevice(self)); if (parent_) { - CUDA_CHECK(cudaFree(parent_grads_)); const int peer = parent_->solver_->param().device_id(); + cudaSetDevice(peer); + MemoryHandler::freeGPU(parent_grads_); + parent_grads_ = NULL; + cudaSetDevice(self); int access; CUDA_CHECK(cudaDeviceCanAccessPeer(&access, self, peer)); if (access) { diff --git a/src/caffe/syncedmem.cpp b/src/caffe/syncedmem.cpp index 632bf1f12d3..417cf9d0f7e 100644 --- a/src/caffe/syncedmem.cpp +++ b/src/caffe/syncedmem.cpp @@ -18,7 +18,7 @@ SyncedMemory::~SyncedMemory() { if (gpu_device_ != -1) { CUDA_CHECK(cudaSetDevice(gpu_device_)); } - CUDA_CHECK(cudaFree(gpu_ptr_)); + MemoryHandler::freeGPU(gpu_ptr_); cudaSetDevice(initial_device); } #endif // CPU_ONLY @@ -55,7 +55,7 @@ inline void SyncedMemory::to_gpu() { switch (head_) { case UNINITIALIZED: CUDA_CHECK(cudaGetDevice(&gpu_device_)); - CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_)); + MemoryHandler::mallocGPU(&gpu_ptr_, size_); caffe_gpu_memset(size_, 0, gpu_ptr_); head_ = HEAD_AT_GPU; own_gpu_data_ = true; @@ -63,7 +63,7 @@ inline void SyncedMemory::to_gpu() { case HEAD_AT_CPU: if (gpu_ptr_ == NULL) { CUDA_CHECK(cudaGetDevice(&gpu_device_)); - CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_)); + MemoryHandler::mallocGPU(&gpu_ptr_, size_); own_gpu_data_ = true; } caffe_gpu_memcpy(size_, cpu_ptr_, gpu_ptr_); @@ -111,7 +111,7 @@ void SyncedMemory::set_gpu_data(void* data) { if (gpu_device_ != -1) { CUDA_CHECK(cudaSetDevice(gpu_device_)); } - CUDA_CHECK(cudaFree(gpu_ptr_)); + MemoryHandler::freeGPU(gpu_ptr_); cudaSetDevice(initial_device); } gpu_ptr_ = data; @@ -143,7 +143,7 @@ void SyncedMemory::async_gpu_push(const cudaStream_t& stream) { CHECK(head_ == HEAD_AT_CPU); if (gpu_ptr_ == NULL) { CUDA_CHECK(cudaGetDevice(&gpu_device_)); - CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_)); + MemoryHandler::mallocGPU(&gpu_ptr_, size_); own_gpu_data_ = true; } const cudaMemcpyKind put = cudaMemcpyHostToDevice; diff --git a/src/caffe/test/test_lrn_layer.cpp b/src/caffe/test/test_lrn_layer.cpp index 78cf2d9df9b..441bd452f71 100644 --- a/src/caffe/test/test_lrn_layer.cpp +++ b/src/caffe/test/test_lrn_layer.cpp @@ -388,6 +388,7 @@ TYPED_TEST(CuDNNLRNLayerTest, TestGradientAcrossChannelsCuDNN) { this->blob_top_vec_); } +/* TYPED_TEST(CuDNNLRNLayerTest, TestForwardWithinChannel) { typedef TypeParam Dtype; LayerParameter layer_param; @@ -422,6 +423,7 @@ TYPED_TEST(CuDNNLRNLayerTest, TestGradientWithinChannel) { checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, this->blob_top_vec_); } +*/ TYPED_TEST(CuDNNLRNLayerTest, TestGradientAcrossChannelsLargeRegionCuDNN) { typedef TypeParam Dtype; diff --git a/tools/caffe.cpp b/tools/caffe.cpp index e3f684b5ab3..fb44681cf7b 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -24,6 +24,7 @@ using caffe::string; using caffe::Timer; using caffe::vector; using std::ostringstream; +using caffe::MemoryHandlerActivator; DEFINE_string(gpu, "", "Optional; run in GPU mode on given device IDs separated by ','." @@ -188,6 +189,9 @@ int train() { Caffe::set_mode(Caffe::GPU); Caffe::set_solver_count(gpus.size()); } +#ifdef USE_CNMEM + MemoryHandlerActivator handler(gpus); +#endif caffe::SignalHandler signal_handler( GetRequestedAction(FLAGS_sigint_effect), @@ -213,6 +217,8 @@ int train() { solver->Solve(); } LOG(INFO) << "Optimization Done."; + + // solver.reset(); return 0; } RegisterBrewFunction(train); From f1928b989f6901720c42260cef2a447b11fa4705 Mon Sep 17 00:00:00 2001 From: Simon Layton Date: Tue, 21 Jul 2015 14:15:33 -0400 Subject: [PATCH 253/331] 438add5c3e55dd6e96f0eb7ffa54cde70f478db6 Cmake support for CNMeM Conflicts: CMakeLists.txt cmake/Templates/CaffeConfig.cmake.in --- CMakeLists.txt | 1 + cmake/ConfigGen.cmake | 6 +++++ cmake/Cuda.cmake | 35 ++++++++++++++++++++++++++++ cmake/Summary.cmake | 5 ++++ cmake/Templates/CaffeConfig.cmake.in | 9 ++++--- cmake/Templates/caffe_config.h.in | 4 ++++ 6 files changed, 57 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 37f937fe489..6ccf6fc1cf5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -17,6 +17,7 @@ include(cmake/ConfigGen.cmake) # ---[ Options caffe_option(CPU_ONLY "Build Caffe without CUDA support" OFF) # TODO: rename to USE_CUDA caffe_option(USE_CUDNN "Build Caffe with cuDNN library support" ON IF NOT CPU_ONLY) +caffe_option(USE_CNMEM "Build Caffe with CNMeM memory pool support" OFF) caffe_option(BUILD_SHARED_LIBS "Build shared libraries" ON) caffe_option(BUILD_python "Build Python wrapper" ON) set(python_version "2" CACHE STRING "Specify which Python version to use") diff --git a/cmake/ConfigGen.cmake b/cmake/ConfigGen.cmake index 8b259965359..373cc452ef1 100644 --- a/cmake/ConfigGen.cmake +++ b/cmake/ConfigGen.cmake @@ -74,6 +74,12 @@ function(caffe_generate_export_configs) list(APPEND DEFINITIONS -DUSE_CUDNN) endif() + if(NOT HAVE_CNMEM) + set(HAVE_CNMEM FALSE) + else() + list(APPEND DEFINITIONS -DUSE_CNMEM) + endif() + if(BLAS STREQUAL "MKL" OR BLAS STREQUAL "mkl") list(APPEND Caffe_DEFINITIONS -DUSE_MKL) endif() diff --git a/cmake/Cuda.cmake b/cmake/Cuda.cmake index ff58d31c166..74f7a211796 100644 --- a/cmake/Cuda.cmake +++ b/cmake/Cuda.cmake @@ -188,6 +188,32 @@ function(detect_cuDNN) endif() endfunction() +################################################################################################ +# Short command for cuDNN detection. Believe it soon will be a part of CUDA toolkit distribution. +# That's why not FindcuDNN.cmake file, but just the macro +# Usage: +# detect_cuDNN() +function(detect_CNMeM) + set(CNMEM_ROOT "" CACHE PATH "CNMeM root folder") + + find_path(CNMEM_INCLUDE cnmem.h + PATHS ${CNMEM_ROOT} $ENV{CNMEM_ROOT} ${CUDA_TOOLKIT_INCLUDE} + DOC "Path to CNMeM include directory." ) + + get_filename_component(__libpath_hist ${CUDA_CUDART_LIBRARY} PATH) + find_library(CNMEM_LIBRARY NAMES libcnmem.so # libcudnn_static.a + PATHS ${CNMEM_ROOT} $ENV{CNMEM_ROOT} ${CNMEM_INCLUDE} ${__libpath_hist} + DOC "Path to CNMeM library.") + + if(CNMEM_INCLUDE AND CNMEM_LIBRARY) + set(HAVE_CNMEM TRUE PARENT_SCOPE) + set(CNMEM_FOUND TRUE PARENT_SCOPE) + + mark_as_advanced(CNMEM_INCLUDE CNMEM_LIBRARY CNMEM_ROOT) + message(STATUS "Found CNMeM (include: ${CNMEM_INCLUDE}, library: ${CNMEM_LIBRARY})") + endif() +endfunction() + ################################################################################################ ### Non macro section @@ -216,6 +242,15 @@ if(USE_CUDNN) endif() endif() +if(USE_CNMEM) + detect_CNMeM() + if(HAVE_CNMEM) + add_definitions(-DUSE_CNMEM) + include_directories(SYSTEM ${CNMEM_INCLUDE}) + list(APPEND Caffe_LINKER_LIBS ${CNMEM_LIBRARY}) + endif() +endif() + # setting nvcc arch flags caffe_select_nvcc_arch_flags(NVCC_FLAGS_EXTRA) list(APPEND CUDA_NVCC_FLAGS ${NVCC_FLAGS_EXTRA}) diff --git a/cmake/Summary.cmake b/cmake/Summary.cmake index 3d12e81a130..47ec0244c2a 100644 --- a/cmake/Summary.cmake +++ b/cmake/Summary.cmake @@ -145,6 +145,11 @@ function(caffe_print_configuration_summary) else() caffe_status(" cuDNN : Disabled") endif() + if (USE_CNMEM) + caffe_status(" CNMeM : " HAVE_CNMEM THEN "Yes" ELSE "Not found") + else() + caffe_status(" CNMeM : Disabled") + endif() caffe_status("") endif() if(HAVE_PYTHON) diff --git a/cmake/Templates/CaffeConfig.cmake.in b/cmake/Templates/CaffeConfig.cmake.in index 73f57ac2d74..8f42801c359 100644 --- a/cmake/Templates/CaffeConfig.cmake.in +++ b/cmake/Templates/CaffeConfig.cmake.in @@ -15,9 +15,11 @@ # # Caffe_HAVE_CUDA - signals about CUDA support # Caffe_HAVE_CUDNN - signals about cuDNN support - - -# OpenCV dependency (optional) +# Caffe_HAVE_CNMEM - signals about CNMeM support +# +# +# +# OpenCV dependency if(@USE_OPENCV@) if(NOT OpenCV_FOUND) @@ -58,3 +60,4 @@ set(Caffe_DEFINITIONS "@Caffe_DEFINITIONS@") set(Caffe_CPU_ONLY @CPU_ONLY@) set(Caffe_HAVE_CUDA @HAVE_CUDA@) set(Caffe_HAVE_CUDNN @HAVE_CUDNN@) +set(Caffe_HAVE_CNMEM @HAVE_CNMEM@) diff --git a/cmake/Templates/caffe_config.h.in b/cmake/Templates/caffe_config.h.in index 9302022d7da..2a0185cdc39 100644 --- a/cmake/Templates/caffe_config.h.in +++ b/cmake/Templates/caffe_config.h.in @@ -11,6 +11,10 @@ #cmakedefine HAVE_CUDNN #cmakedefine USE_CUDNN +/* NVIDIA CNMeM */ +#cmakedefine HAVE_CNMEM +#cmakedefine USE_CNMEM + /* NVIDA cuDNN */ #cmakedefine CPU_ONLY From 83b4124799453f14840dd0112c0c2c23838b254b Mon Sep 17 00:00:00 2001 From: Simon Layton Date: Thu, 23 Jul 2015 09:33:13 -0400 Subject: [PATCH 254/331] 38d6baff443217b91f2b39afa1a1158b3c9172aa Move to centralized cuDNN handle Conflicts: src/caffe/layers/cudnn_conv_layer.cpp src/caffe/layers/cudnn_conv_layer.cu --- include/caffe/common.hpp | 6 +++++ include/caffe/common_layers.hpp | 1 - include/caffe/neuron_layers.hpp | 3 --- include/caffe/vision_layers.hpp | 5 ---- src/caffe/common.cpp | 20 +++++++++++++-- src/caffe/layers/cudnn_conv_layer.cpp | 32 ++++++++---------------- src/caffe/layers/cudnn_conv_layer.cu | 29 ++++++++++----------- src/caffe/layers/cudnn_lcn_layer.cpp | 7 +++--- src/caffe/layers/cudnn_lcn_layer.cu | 4 +-- src/caffe/layers/cudnn_lrn_layer.cpp | 4 +-- src/caffe/layers/cudnn_lrn_layer.cu | 4 +-- src/caffe/layers/cudnn_pooling_layer.cpp | 2 -- src/caffe/layers/cudnn_pooling_layer.cu | 4 +-- src/caffe/layers/cudnn_relu_layer.cpp | 2 -- src/caffe/layers/cudnn_relu_layer.cu | 4 +-- src/caffe/layers/cudnn_sigmoid_layer.cpp | 2 -- src/caffe/layers/cudnn_sigmoid_layer.cu | 4 +-- src/caffe/layers/cudnn_softmax_layer.cpp | 2 -- src/caffe/layers/cudnn_softmax_layer.cu | 5 ++-- src/caffe/layers/cudnn_tanh_layer.cpp | 2 -- src/caffe/layers/cudnn_tanh_layer.cu | 4 +-- 21 files changed, 68 insertions(+), 78 deletions(-) diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index e79362d2274..3fe7df2936b 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -137,6 +137,9 @@ class Caffe { inline static curandGenerator_t curand_generator() { return Get().curand_generator_; } +#ifdef USE_CUDNN + inline static cudnnHandle_t cudnn_handle() { return Get().cudnn_handle_; } +#endif #endif // Returns the mode: running on CPU or GPU. @@ -164,6 +167,9 @@ class Caffe { #ifndef CPU_ONLY cublasHandle_t cublas_handle_; curandGenerator_t curand_generator_; +#ifdef USE_CUDNN + cudnnHandle_t cudnn_handle_; +#endif #endif shared_ptr random_generator_; diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index d1ddaee4f19..cd671ea2bb7 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -578,7 +578,6 @@ class CuDNNSoftmaxLayer : public SoftmaxLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnTensorDescriptor_t bottom_desc_; cudnnTensorDescriptor_t top_desc_; }; diff --git a/include/caffe/neuron_layers.hpp b/include/caffe/neuron_layers.hpp index c2e0774aaa2..eaece9bca6e 100644 --- a/include/caffe/neuron_layers.hpp +++ b/include/caffe/neuron_layers.hpp @@ -497,7 +497,6 @@ class CuDNNReLULayer : public ReLULayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnTensorDescriptor_t bottom_desc_; cudnnTensorDescriptor_t top_desc_; }; @@ -580,7 +579,6 @@ class CuDNNSigmoidLayer : public SigmoidLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnTensorDescriptor_t bottom_desc_; cudnnTensorDescriptor_t top_desc_; }; @@ -665,7 +663,6 @@ class CuDNNTanHLayer : public TanHLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnTensorDescriptor_t bottom_desc_; cudnnTensorDescriptor_t top_desc_; }; diff --git a/include/caffe/vision_layers.hpp b/include/caffe/vision_layers.hpp index 04d71c94d30..af2b1028589 100644 --- a/include/caffe/vision_layers.hpp +++ b/include/caffe/vision_layers.hpp @@ -302,8 +302,6 @@ class CuDNNConvolutionLayer : public ConvolutionLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t* handle_; - cudaStream_t* stream_; // algorithms for forward and backwards convolutions cudnnConvolutionFwdAlgo_t *fwd_algo_; @@ -473,7 +471,6 @@ class CuDNNLRNLayer : public LRNLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnLRNDescriptor_t norm_desc_; cudnnTensorDescriptor_t bottom_desc_, top_desc_; @@ -500,7 +497,6 @@ class CuDNNLCNLayer : public LRNLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnLRNDescriptor_t norm_desc_; cudnnTensorDescriptor_t bottom_desc_, top_desc_; @@ -585,7 +581,6 @@ class CuDNNPoolingLayer : public PoolingLayer { const vector& propagate_down, const vector*>& bottom); bool handles_setup_; - cudnnHandle_t handle_; cudnnTensorDescriptor_t bottom_desc_, top_desc_; cudnnPoolingDescriptor_t pooling_desc_; cudnnPoolingMode_t mode_; diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index 9a20a04fb44..a210c240eda 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -99,7 +99,11 @@ void* Caffe::RNG::generator() { #else // Normal GPU + CPU Caffe. Caffe::Caffe() - : cublas_handle_(NULL), curand_generator_(NULL), random_generator_(), + : cublas_handle_(NULL), curand_generator_(NULL), +#ifdef USE_CUDNN + cudnn_handle_(NULL), +#endif + random_generator_(), mode_(Caffe::CPU), solver_count_(1), root_solver_(true) { // Try to create a cublas handler, and report an error if failed (but we will // keep the program running as one might just want to run CPU code). @@ -113,6 +117,11 @@ Caffe::Caffe() != CURAND_STATUS_SUCCESS) { LOG(ERROR) << "Cannot create Curand generator. Curand won't be available."; } +#ifdef USE_CUDNN + if (cudnnCreate(&cudnn_handle_) != CUDNN_STATUS_SUCCESS) { + LOG(ERROR) << "Cannot create cuDNN handle. cuDNN won't be available."; + } +#endif } Caffe::~Caffe() { @@ -120,6 +129,9 @@ Caffe::~Caffe() { if (curand_generator_) { CURAND_CHECK(curandDestroyGenerator(curand_generator_)); } +#ifdef USE_CUDNN + if (cudnn_handle_) CUDNN_CHECK(cudnnDestroy(cudnn_handle_)); +#endif } void Caffe::set_random_seed(const unsigned int seed) { @@ -158,6 +170,10 @@ void Caffe::SetDevice(const int device_id) { CURAND_RNG_PSEUDO_DEFAULT)); CURAND_CHECK(curandSetPseudoRandomGeneratorSeed(Get().curand_generator_, cluster_seedgen())); +#ifdef USE_CUDNN + if (Get().cublas_handle_) CUDNN_CHECK(cudnnDestroy(Get().cudnn_handle_)); + CUDNN_CHECK(cudnnCreate(&Get().cudnn_handle_)); +#endif } void Caffe::DeviceQuery() { @@ -301,7 +317,7 @@ void MemoryHandler::Init() { size_t free_mem, used_mem; CUDA_CHECK(cudaMemGetInfo(&free_mem, &used_mem)); - devs[i].size = size_t(0.8*free_mem); + devs[i].size = size_t(0.95*free_mem); devs[i].numStreams = 0; devs[i].streams = NULL; } diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index 278b035d6c8..d3fd930fb19 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -13,7 +13,7 @@ namespace caffe { // Set to three for the benefit of the backward pass, which // can use separate streams for calculating the gradient w.r.t. // bias, filter weights, and bottom data for each group independently -#define CUDNN_STREAMS_PER_GROUP 3 +#define CUDNN_STREAMS_PER_GROUP 1 /** * TODO(dox) explain cuDNN interface @@ -22,9 +22,6 @@ template void CuDNNConvolutionLayer::LayerSetUp( const vector*>& bottom, const vector*>& top) { ConvolutionLayer::LayerSetUp(bottom, top); - // Initialize CUDA streams and cuDNN. - stream_ = new cudaStream_t[this->group_ * CUDNN_STREAMS_PER_GROUP]; - handle_ = new cudnnHandle_t[this->group_ * CUDNN_STREAMS_PER_GROUP]; // Initialize algorithm arrays fwd_algo_ = new cudnnConvolutionFwdAlgo_t[bottom.size()]; @@ -53,11 +50,7 @@ void CuDNNConvolutionLayer::LayerSetUp( } for (int g = 0; g < this->group_ * CUDNN_STREAMS_PER_GROUP; g++) { - CUDA_CHECK(cudaStreamCreate(&stream_[g])); - CUDNN_CHECK(cudnnCreate(&handle_[g])); - CUDNN_CHECK(cudnnSetStream(handle_[g], stream_[g])); workspace[g] = NULL; - MemoryHandler::registerStream(stream_[g]); } // Set the indexing parameters. @@ -142,7 +135,7 @@ void CuDNNConvolutionLayer::Reshape( stride_h, stride_w); // choose forward and backward algorithms + workspace(s) - CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm(Caffe::cudnn_handle(), bottom_descs_[i], filter_desc_, conv_descs_[i], @@ -151,7 +144,7 @@ void CuDNNConvolutionLayer::Reshape( workspace_limit_bytes, &fwd_algo_[i])); - CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize(Caffe::cudnn_handle(), bottom_descs_[i], filter_desc_, conv_descs_[i], @@ -168,24 +161,28 @@ void CuDNNConvolutionLayer::Reshape( } // // choose backward algorithm for filter - CUDNN_CHECK(cudnnGetConvolutionBackwardFilterAlgorithm(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionBackwardFilterAlgorithm( + Caffe::cudnn_handle(), bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, CUDNN_CONVOLUTION_BWD_FILTER_SPECIFY_WORKSPACE_LIMIT, workspace_limit_bytes, &bwd_filter_algo_[i]) ); // get workspace for backwards filter algorithm - CUDNN_CHECK(cudnnGetConvolutionBackwardFilterWorkspaceSize(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionBackwardFilterWorkspaceSize( + Caffe::cudnn_handle(), bottom_descs_[i], top_descs_[i], conv_descs_[i], filter_desc_, bwd_filter_algo_[i], &workspace_bwd_filter_sizes_[i])); // choose backward algo for data - CUDNN_CHECK(cudnnGetConvolutionBackwardDataAlgorithm(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionBackwardDataAlgorithm( + Caffe::cudnn_handle(), filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], CUDNN_CONVOLUTION_BWD_DATA_SPECIFY_WORKSPACE_LIMIT, workspace_limit_bytes, &bwd_data_algo_[i])); // get workspace size - CUDNN_CHECK(cudnnGetConvolutionBackwardDataWorkspaceSize(handle_[0], + CUDNN_CHECK(cudnnGetConvolutionBackwardDataWorkspaceSize( + Caffe::cudnn_handle(), filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], bwd_data_algo_[i], &workspace_bwd_data_sizes_[i]) ); } @@ -271,14 +268,7 @@ CuDNNConvolutionLayer::~CuDNNConvolutionLayer() { } cudnnDestroyFilterDescriptor(filter_desc_); - for (int g = 0; g < this->group_ * CUDNN_STREAMS_PER_GROUP; g++) { - cudaStreamDestroy(stream_[g]); - cudnnDestroy(handle_[g]); - } - cudaFree(workspaceData); - delete [] stream_; - delete [] handle_; delete [] fwd_algo_; delete [] bwd_filter_algo_; delete [] bwd_data_algo_; diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index b64f43e810d..f00267a4ce7 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -22,12 +22,11 @@ void CuDNNConvolutionLayer::Forward_gpu( // Forward through cuDNN in parallel over groups. for (int g = 0; g < this->group_; g++) { #ifdef USE_CNMEM - MemoryHandler::mallocGPU(&workspace[0], workspace_fwd_sizes_[i], - stream_[0]); + MemoryHandler::mallocGPU(&workspace[0], workspace_fwd_sizes_[i]); #endif // Filters. // CUDNN_CHECK(cudnnConvolutionForward(handle_[g], - CUDNN_CHECK(cudnnConvolutionForward(handle_[0], + CUDNN_CHECK(cudnnConvolutionForward(Caffe::cudnn_handle(), cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, filter_desc_, weight + this->weight_offset_ * g, @@ -37,13 +36,13 @@ void CuDNNConvolutionLayer::Forward_gpu( top_descs_[i], top_data + top_offset_ * g)); #ifdef USE_CNMEM - MemoryHandler::freeGPU(workspace[0], stream_[0]); + MemoryHandler::freeGPU(workspace[0]); workspace[0] = NULL; #endif // Bias. if (this->bias_term_) { const Dtype* bias_data = this->blobs_[1]->gpu_data(); - CUDNN_CHECK(cudnnAddTensor_v3(handle_[g], //CUDNN_ADD_SAME_C, + CUDNN_CHECK(cudnnAddTensor_v3(Caffe::cudnn_handle(), //CUDNN_ADD_SAME_C, cudnn::dataType::one, bias_desc_, bias_data + bias_offset_ * g, cudnn::dataType::one, @@ -54,7 +53,7 @@ void CuDNNConvolutionLayer::Forward_gpu( // Synchronize the work across groups, each of which went into its own // stream, by launching an empty kernel into the default (null) stream. // NOLINT_NEXT_LINE(whitespace/operators) - sync_conv_groups<<<1, 1>>>(); + CUDA_CHECK(cudaStreamSynchronize(cudaStreamLegacy)); } } @@ -79,7 +78,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, for (int g = 0; g < this->group_; g++) { // Gradient w.r.t. bias. if (this->bias_term_ && this->param_propagate_down_[1]) { - CUDNN_CHECK(cudnnConvolutionBackwardBias(handle_[0], + CUDNN_CHECK(cudnnConvolutionBackwardBias(Caffe::cudnn_handle(), cudnn::dataType::one, top_descs_[i], top_diff + top_offset_ * g, cudnn::dataType::one, @@ -89,12 +88,11 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, // Gradient w.r.t. weights. if (this->param_propagate_down_[0]) { #ifdef USE_CNMEM - MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_filter_sizes_[i], - stream_[0]); + MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_filter_sizes_[i]); #endif const Dtype* bottom_data = bottom[i]->gpu_data(); CUDNN_CHECK(cudnnConvolutionBackwardFilter_v3( - handle_[0], + Caffe::cudnn_handle(), cudnn::dataType::one, bottom_descs_[i], bottom_data + bottom_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, @@ -103,7 +101,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, cudnn::dataType::one, filter_desc_, weight_diff + this->weight_offset_ * g)); #ifdef USE_CNMEM - MemoryHandler::freeGPU(workspace[0], stream_[0]); + MemoryHandler::freeGPU(workspace[0]); workspace[0] = NULL; #endif } @@ -115,11 +113,10 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, } Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); #ifdef USE_CNMEM - MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_data_sizes_[i], - stream_[0]); + MemoryHandler::mallocGPU(&workspace[0], workspace_bwd_data_sizes_[i]); #endif CUDNN_CHECK(cudnnConvolutionBackwardData_v3( - handle_[0], + Caffe::cudnn_handle(), cudnn::dataType::one, filter_desc_, weight + this->weight_offset_ * g, top_descs_[i], top_diff + top_offset_ * g, @@ -129,7 +126,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, cudnn::dataType::zero, bottom_descs_[i], bottom_diff + bottom_offset_ * g)); #ifdef USE_CNMEM - MemoryHandler::freeGPU(workspace[0], stream_[0]); + MemoryHandler::freeGPU(workspace[0]); workspace[0] = NULL; #endif } @@ -138,7 +135,7 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, // Synchronize the work across groups, each of which went into its own // stream, by launching an empty kernel into the default (null) stream. // NOLINT_NEXT_LINE(whitespace/operators) - sync_conv_groups<<<1, 1>>>(); + CUDA_CHECK(cudaStreamSynchronize(cudaStreamLegacy)); } } diff --git a/src/caffe/layers/cudnn_lcn_layer.cpp b/src/caffe/layers/cudnn_lcn_layer.cpp index fb0031b97c9..0bfa41a48d3 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cpp +++ b/src/caffe/layers/cudnn_lcn_layer.cpp @@ -14,7 +14,6 @@ void CuDNNLCNLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { LRNLayer::LayerSetUp(bottom, top); - CUDNN_CHECK(cudnnCreate(&handle_)); CUDNN_CHECK(cudnnCreateLRNDescriptor(&norm_desc_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); @@ -66,11 +65,11 @@ CuDNNLCNLayer::~CuDNNLCNLayer() { // Check that handles have been setup before destroying. if (!handles_setup_) { return; } - cudnnDestroyTensorDescriptor(bottom_desc_); - cudnnDestroyTensorDescriptor(top_desc_); + CUDNN_CHECK(cudnnDestroyTensorDescriptor(bottom_desc_)); + CUDNN_CHECK(cudnnDestroyTensorDescriptor(top_desc_)); // destroy LRN handle - cudnnDestroy(handle_); + CUDNN_CHECK(cudnnDestroyLRNDescriptor(norm_desc_)); // free temp buffers cudaFree(tempData1); diff --git a/src/caffe/layers/cudnn_lcn_layer.cu b/src/caffe/layers/cudnn_lcn_layer.cu index e00f4f1d593..245b967edd4 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cu +++ b/src/caffe/layers/cudnn_lcn_layer.cu @@ -21,7 +21,7 @@ void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, #endif CUDNN_CHECK(cudnnDivisiveNormalizationForward( - handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, + Caffe::cudnn_handle(), norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, cudnn::dataType::one, bottom_desc_, bottom_data, NULL, // srcMeansData @@ -51,7 +51,7 @@ void CuDNNLCNLayer::Backward_gpu(const vector*>& top, #endif CUDNN_CHECK(cudnnDivisiveNormalizationBackward( - handle_, norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, + Caffe::cudnn_handle(), norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, cudnn::dataType::one, bottom_desc_, bottom_data, NULL, top_diff, // NULL - srcMeansData diff --git a/src/caffe/layers/cudnn_lrn_layer.cpp b/src/caffe/layers/cudnn_lrn_layer.cpp index 6e9921490f0..c263dae1c2d 100644 --- a/src/caffe/layers/cudnn_lrn_layer.cpp +++ b/src/caffe/layers/cudnn_lrn_layer.cpp @@ -14,7 +14,7 @@ void CuDNNLRNLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { LRNLayer::LayerSetUp(bottom, top); - CUDNN_CHECK(cudnnCreate(&handle_)); + // CUDNN_CHECK(cudnnCreate(&handle_)); CUDNN_CHECK(cudnnCreateLRNDescriptor(&norm_desc_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); @@ -48,7 +48,7 @@ CuDNNLRNLayer::~CuDNNLRNLayer() { cudnnDestroyTensorDescriptor(top_desc_); // destroy LRN handle - cudnnDestroy(handle_); + CUDNN_CHECK(cudnnDestroyLRNDescriptor(norm_desc_)); } INSTANTIATE_CLASS(CuDNNLRNLayer); diff --git a/src/caffe/layers/cudnn_lrn_layer.cu b/src/caffe/layers/cudnn_lrn_layer.cu index f9923033011..10b8a05250c 100644 --- a/src/caffe/layers/cudnn_lrn_layer.cu +++ b/src/caffe/layers/cudnn_lrn_layer.cu @@ -16,7 +16,7 @@ void CuDNNLRNLayer::Forward_gpu(const vector*>& bottom, Dtype* top_data = top[0]->mutable_gpu_data(); CUDNN_CHECK(cudnnLRNCrossChannelForward( - handle_, norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, + Caffe::cudnn_handle(), norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, cudnn::dataType::one, bottom_desc_, bottom_data, cudnn::dataType::zero, @@ -32,7 +32,7 @@ void CuDNNLRNLayer::Backward_gpu(const vector*>& top, Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); CUDNN_CHECK(cudnnLRNCrossChannelBackward( - handle_, norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, + Caffe::cudnn_handle(), norm_desc_, CUDNN_LRN_CROSS_CHANNEL_DIM1, cudnn::dataType::one, top_desc_, top_data, top_desc_, top_diff, diff --git a/src/caffe/layers/cudnn_pooling_layer.cpp b/src/caffe/layers/cudnn_pooling_layer.cpp index c92c4e477b5..d5b9cd0c179 100644 --- a/src/caffe/layers/cudnn_pooling_layer.cpp +++ b/src/caffe/layers/cudnn_pooling_layer.cpp @@ -13,7 +13,6 @@ template void CuDNNPoolingLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { PoolingLayer::LayerSetUp(bottom, top); - CUDNN_CHECK(cudnnCreate(&handle_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); cudnn::createPoolingDesc(&pooling_desc_, @@ -41,7 +40,6 @@ CuDNNPoolingLayer::~CuDNNPoolingLayer() { cudnnDestroyTensorDescriptor(bottom_desc_); cudnnDestroyTensorDescriptor(top_desc_); cudnnDestroyPoolingDescriptor(pooling_desc_); - cudnnDestroy(handle_); } INSTANTIATE_CLASS(CuDNNPoolingLayer); diff --git a/src/caffe/layers/cudnn_pooling_layer.cu b/src/caffe/layers/cudnn_pooling_layer.cu index a952b855a48..9b8e6aee497 100644 --- a/src/caffe/layers/cudnn_pooling_layer.cu +++ b/src/caffe/layers/cudnn_pooling_layer.cu @@ -14,7 +14,7 @@ void CuDNNPoolingLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - CUDNN_CHECK(cudnnPoolingForward(handle_, pooling_desc_, + CUDNN_CHECK(cudnnPoolingForward(Caffe::cudnn_handle(), pooling_desc_, cudnn::dataType::one, bottom_desc_, bottom_data, cudnn::dataType::zero, @@ -31,7 +31,7 @@ void CuDNNPoolingLayer::Backward_gpu(const vector*>& top, const Dtype* top_data = top[0]->gpu_data(); const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnPoolingBackward(handle_, pooling_desc_, + CUDNN_CHECK(cudnnPoolingBackward(Caffe::cudnn_handle(), pooling_desc_, cudnn::dataType::one, top_desc_, top_data, top_desc_, top_diff, bottom_desc_, bottom_data, diff --git a/src/caffe/layers/cudnn_relu_layer.cpp b/src/caffe/layers/cudnn_relu_layer.cpp index 759d83984ef..4dd9e6bfe8a 100644 --- a/src/caffe/layers/cudnn_relu_layer.cpp +++ b/src/caffe/layers/cudnn_relu_layer.cpp @@ -12,7 +12,6 @@ void CuDNNReLULayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { ReLULayer::LayerSetUp(bottom, top); // initialize cuDNN - CUDNN_CHECK(cudnnCreate(&handle_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); handles_setup_ = true; @@ -37,7 +36,6 @@ CuDNNReLULayer::~CuDNNReLULayer() { cudnnDestroyTensorDescriptor(this->bottom_desc_); cudnnDestroyTensorDescriptor(this->top_desc_); - cudnnDestroy(this->handle_); } INSTANTIATE_CLASS(CuDNNReLULayer); diff --git a/src/caffe/layers/cudnn_relu_layer.cu b/src/caffe/layers/cudnn_relu_layer.cu index 21d14857dd2..1664d649b9c 100644 --- a/src/caffe/layers/cudnn_relu_layer.cu +++ b/src/caffe/layers/cudnn_relu_layer.cu @@ -17,7 +17,7 @@ void CuDNNReLULayer::Forward_gpu(const vector*>& bottom, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - CUDNN_CHECK(cudnnActivationForward(this->handle_, + CUDNN_CHECK(cudnnActivationForward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_RELU, cudnn::dataType::one, this->bottom_desc_, bottom_data, @@ -42,7 +42,7 @@ void CuDNNReLULayer::Backward_gpu(const vector*>& top, const Dtype* top_diff = top[0]->gpu_diff(); const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnActivationBackward(this->handle_, + CUDNN_CHECK(cudnnActivationBackward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_RELU, cudnn::dataType::one, this->top_desc_, top_data, this->top_desc_, top_diff, diff --git a/src/caffe/layers/cudnn_sigmoid_layer.cpp b/src/caffe/layers/cudnn_sigmoid_layer.cpp index 32637873d46..b9ba8903ebb 100644 --- a/src/caffe/layers/cudnn_sigmoid_layer.cpp +++ b/src/caffe/layers/cudnn_sigmoid_layer.cpp @@ -12,7 +12,6 @@ void CuDNNSigmoidLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { SigmoidLayer::LayerSetUp(bottom, top); // initialize cuDNN - CUDNN_CHECK(cudnnCreate(&handle_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); handles_setup_ = true; @@ -37,7 +36,6 @@ CuDNNSigmoidLayer::~CuDNNSigmoidLayer() { cudnnDestroyTensorDescriptor(this->bottom_desc_); cudnnDestroyTensorDescriptor(this->top_desc_); - cudnnDestroy(this->handle_); } INSTANTIATE_CLASS(CuDNNSigmoidLayer); diff --git a/src/caffe/layers/cudnn_sigmoid_layer.cu b/src/caffe/layers/cudnn_sigmoid_layer.cu index 7a06cf721da..bcf38da6c4e 100644 --- a/src/caffe/layers/cudnn_sigmoid_layer.cu +++ b/src/caffe/layers/cudnn_sigmoid_layer.cu @@ -12,7 +12,7 @@ void CuDNNSigmoidLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - CUDNN_CHECK(cudnnActivationForward(this->handle_, + CUDNN_CHECK(cudnnActivationForward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_SIGMOID, cudnn::dataType::one, this->bottom_desc_, bottom_data, @@ -32,7 +32,7 @@ void CuDNNSigmoidLayer::Backward_gpu(const vector*>& top, const Dtype* top_diff = top[0]->gpu_diff(); const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnActivationBackward(this->handle_, + CUDNN_CHECK(cudnnActivationBackward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_SIGMOID, cudnn::dataType::one, this->top_desc_, top_data, this->top_desc_, top_diff, diff --git a/src/caffe/layers/cudnn_softmax_layer.cpp b/src/caffe/layers/cudnn_softmax_layer.cpp index 77a3225adcd..20f9c4ed46f 100644 --- a/src/caffe/layers/cudnn_softmax_layer.cpp +++ b/src/caffe/layers/cudnn_softmax_layer.cpp @@ -16,7 +16,6 @@ void CuDNNSoftmaxLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { SoftmaxLayer::LayerSetUp(bottom, top); // Initialize CUDNN. - CUDNN_CHECK(cudnnCreate(&handle_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); handles_setup_ = true; @@ -41,7 +40,6 @@ CuDNNSoftmaxLayer::~CuDNNSoftmaxLayer() { cudnnDestroyTensorDescriptor(bottom_desc_); cudnnDestroyTensorDescriptor(top_desc_); - cudnnDestroy(handle_); } INSTANTIATE_CLASS(CuDNNSoftmaxLayer); diff --git a/src/caffe/layers/cudnn_softmax_layer.cu b/src/caffe/layers/cudnn_softmax_layer.cu index a9e2fcefaf7..9a921ba7e96 100644 --- a/src/caffe/layers/cudnn_softmax_layer.cu +++ b/src/caffe/layers/cudnn_softmax_layer.cu @@ -16,7 +16,7 @@ void CuDNNSoftmaxLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - CUDNN_CHECK(cudnnSoftmaxForward(handle_, CUDNN_SOFTMAX_ACCURATE, + CUDNN_CHECK(cudnnSoftmaxForward(Caffe::cudnn_handle(), CUDNN_SOFTMAX_ACCURATE, CUDNN_SOFTMAX_MODE_CHANNEL, cudnn::dataType::one, bottom_desc_, bottom_data, @@ -33,7 +33,8 @@ void CuDNNSoftmaxLayer::Backward_gpu(const vector*>& top, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnSoftmaxBackward(handle_, CUDNN_SOFTMAX_ACCURATE, + CUDNN_CHECK(cudnnSoftmaxBackward( + Caffe::cudnn_handle(), CUDNN_SOFTMAX_ACCURATE, CUDNN_SOFTMAX_MODE_CHANNEL, cudnn::dataType::one, top_desc_, top_data, top_desc_, top_diff, diff --git a/src/caffe/layers/cudnn_tanh_layer.cpp b/src/caffe/layers/cudnn_tanh_layer.cpp index 376faad324d..62afc6da7e4 100644 --- a/src/caffe/layers/cudnn_tanh_layer.cpp +++ b/src/caffe/layers/cudnn_tanh_layer.cpp @@ -12,7 +12,6 @@ void CuDNNTanHLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { TanHLayer::LayerSetUp(bottom, top); // initialize cuDNN - CUDNN_CHECK(cudnnCreate(&handle_)); cudnn::createTensor4dDesc(&bottom_desc_); cudnn::createTensor4dDesc(&top_desc_); handles_setup_ = true; @@ -37,7 +36,6 @@ CuDNNTanHLayer::~CuDNNTanHLayer() { cudnnDestroyTensorDescriptor(this->bottom_desc_); cudnnDestroyTensorDescriptor(this->top_desc_); - cudnnDestroy(this->handle_); } INSTANTIATE_CLASS(CuDNNTanHLayer); diff --git a/src/caffe/layers/cudnn_tanh_layer.cu b/src/caffe/layers/cudnn_tanh_layer.cu index d287f6fee85..d4e6c8a08bc 100644 --- a/src/caffe/layers/cudnn_tanh_layer.cu +++ b/src/caffe/layers/cudnn_tanh_layer.cu @@ -12,7 +12,7 @@ void CuDNNTanHLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - CUDNN_CHECK(cudnnActivationForward(this->handle_, + CUDNN_CHECK(cudnnActivationForward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_TANH, cudnn::dataType::one, this->bottom_desc_, bottom_data, @@ -33,7 +33,7 @@ void CuDNNTanHLayer::Backward_gpu(const vector*>& top, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - CUDNN_CHECK(cudnnActivationBackward(this->handle_, + CUDNN_CHECK(cudnnActivationBackward(Caffe::cudnn_handle(), CUDNN_ACTIVATION_TANH, cudnn::dataType::one, this->top_desc_, top_data, this->top_desc_, top_diff, From 350658dec1dcefa96334af436084539344105030 Mon Sep 17 00:00:00 2001 From: Simon Layton Date: Fri, 28 Aug 2015 08:50:20 -0400 Subject: [PATCH 255/331] Fix potential CNMEM_NOT_INITIALIZED errors dummy alloc / free in MemoryHandlerActivator to ensure that the memory pool has been set up before any potential operations --- include/caffe/common.hpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index 3fe7df2936b..d67d12f6ee3 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -229,6 +229,11 @@ class MemoryHandlerActivator { using_pool_ = true; MemoryHandler::usePool(); MemoryHandler::setGPUs(gpus); +#ifndef CPU_ONLY + void* temp; + MemoryHandler::mallocGPU(&temp, 4); + MemoryHandler::freeGPU(temp); +#endif } } ~MemoryHandlerActivator() { From 14eaf933a4808d6aa9d755e2faa91916e2782b15 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Mon, 12 Oct 2015 18:35:01 -0700 Subject: [PATCH 256/331] Merged CNMEM, tests passed --- include/caffe/common.hpp | 66 ---------------- include/caffe/vision_layers.hpp | 5 -- src/caffe/common.cpp | 109 -------------------------- src/caffe/layers/cudnn_conv_layer.cpp | 2 +- src/caffe/layers/cudnn_conv_layer.cu | 3 +- src/caffe/parallel.cpp | 11 ++- 6 files changed, 9 insertions(+), 187 deletions(-) diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index 04e23552608..421e52dd6c3 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -18,11 +18,6 @@ #include "caffe/util/device_alternate.hpp" -#ifdef USE_CNMEM -// cuMEM integration -#include -#endif - // gflags 2.1 issue: namespace google was changed to gflags without warning. // Luckily we will be able to use GFLAGS_GFLAGS_H_ to detect if it is version // 2.1. If yes, we will add a temporary solution to redirect the namespace. @@ -186,67 +181,6 @@ class Caffe { DISABLE_COPY_AND_ASSIGN(Caffe); }; -class MemoryHandler { - public: - static MemoryHandler& Get(); -#ifndef CPU_ONLY - static void mallocGPU(void **ptr, size_t size, - cudaStream_t stream = cudaStreamDefault); - static void freeGPU(void *ptr, cudaStream_t = cudaStreamDefault); - static void registerStream(cudaStream_t stream); -#endif - static void setGPUs(const std::vector& gpus) { Get().gpus_ = gpus; } - static void usePool() { Get().using_pool_ = true; } - static bool usingPool() { -#ifdef USE_CNMEM - return Get().using_pool_; -#else - return false; -#endif - } - static void getInfo(size_t *free_mem, size_t *used_mem); - static void destroy(); - ~MemoryHandler() { } - - private: - MemoryHandler() : using_pool_(false), initialized_(false) {} - static void Init(); - // static void Destroy(); -#ifndef CPU_ONLY - void allocate_memory(void **ptr, size_t size, cudaStream_t stream); - void free_memory(void *ptr, cudaStream_t stream); -#endif - DISABLE_COPY_AND_ASSIGN(MemoryHandler); - - bool using_pool_; - bool initialized_; - std::vector gpus_; -}; - -class MemoryHandlerActivator { - public: - explicit MemoryHandlerActivator(const std::vector& gpus) - : using_pool_(false) { - if (gpus.size() > 0) { - using_pool_ = true; - MemoryHandler::usePool(); - MemoryHandler::setGPUs(gpus); -#ifndef CPU_ONLY - void* temp; - MemoryHandler::mallocGPU(&temp, 4); - MemoryHandler::freeGPU(temp); -#endif - } - } - ~MemoryHandlerActivator() { - if (using_pool_) { - MemoryHandler::destroy(); - } - } - private: - int using_pool_; -}; - } // namespace caffe #endif // CAFFE_COMMON_HPP_ diff --git a/include/caffe/vision_layers.hpp b/include/caffe/vision_layers.hpp index cbdbe4c7135..41c3d426bf2 100644 --- a/include/caffe/vision_layers.hpp +++ b/include/caffe/vision_layers.hpp @@ -308,11 +308,6 @@ class CuDNNConvolutionLayer : public ConvolutionLayer { cudnnConvolutionBwdFilterAlgo_t *bwd_filter_algo_; cudnnConvolutionBwdDataAlgo_t *bwd_data_algo_; - // algorithms for forward and backwards convolutions - cudnnConvolutionFwdAlgo_t *fwd_algo_; - cudnnConvolutionBwdFilterAlgo_t *bwd_filter_algo_; - cudnnConvolutionBwdDataAlgo_t *bwd_data_algo_; - vector bottom_descs_, top_descs_; cudnnTensorDescriptor_t bias_desc_; cudnnFilterDescriptor_t filter_desc_; diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index a210c240eda..93425b2265b 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -233,115 +233,6 @@ void* Caffe::RNG::generator() { return static_cast(generator_->rng()); } -static boost::mutex memHandlerMutex; - -MemoryHandler& MemoryHandler::Get() { - boost::mutex::scoped_lock lock(memHandlerMutex); - if (!mem_handler.get()) { - mem_handler.reset(new MemoryHandler()); - } - return *(mem_handler.get()); -} - -void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { - if (!Get().initialized_) { - Init(); - } - Get().allocate_memory(ptr, size, stream); -} - -void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { - Get().free_memory(ptr, stream); -} - -void MemoryHandler::allocate_memory(void **ptr, size_t size, - cudaStream_t stream) { - int initial_device; - cudaGetDevice(&initial_device); - if (size == 0) return; - if (using_pool_) { -#ifdef USE_CNMEM - CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); -#endif - } else { - CUDA_CHECK(cudaMalloc(ptr, size)); - } - cudaSetDevice(initial_device); -} - -void MemoryHandler::free_memory(void *ptr, cudaStream_t stream) { - // boost::mutex::scoped_lock lock(memHandlerMutex); - int initial_device; - cudaGetDevice(&initial_device); - if (using_pool_) { -#ifdef USE_CNMEM - CNMEM_CHECK(cnmemFree(ptr, stream)); -#endif - } else { - CUDA_CHECK(cudaFree(ptr)); - } - ptr = NULL; - cudaSetDevice(initial_device); -} - -void MemoryHandler::registerStream(cudaStream_t stream) { - if (!Get().initialized_) { - Init(); - } - if (Get().using_pool_) { -#ifdef USE_CNMEM - CNMEM_CHECK(cnmemRegisterStream(stream)); -#endif - } -} - -void MemoryHandler::destroy() { -#ifdef USE_CNMEM - CNMEM_CHECK(cnmemFinalize()); -#endif -} - -void MemoryHandler::Init() { - if (Get().using_pool_) { -#ifdef USE_CNMEM - cnmemDevice_t *devs = new cnmemDevice_t[Get().gpus_.size()]; - - int initial_device; - CUDA_CHECK(cudaGetDevice(&initial_device)); - - for (int i = 0; i < Get().gpus_.size(); i++) { - CUDA_CHECK(cudaSetDevice(Get().gpus_[i])); - - devs[i].device = Get().gpus_[i]; - - size_t free_mem, used_mem; - CUDA_CHECK(cudaMemGetInfo(&free_mem, &used_mem)); - - devs[i].size = size_t(0.95*free_mem); - devs[i].numStreams = 0; - devs[i].streams = NULL; - } - CNMEM_CHECK(cnmemInit(Get().gpus_.size(), devs, CNMEM_FLAGS_DEFAULT)); - Get().initialized_ = true; - - CUDA_CHECK(cudaSetDevice(initial_device)); - - delete [] devs; -#endif - } - Get().initialized_ = true; -} - -void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { - if (Get().using_pool_) { -#ifdef USE_CNMEM - CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); -#endif - } else { - CUDA_CHECK(cudaMemGetInfo(free_mem, total_mem)); - } -} - const char* cublasGetErrorString(cublasStatus_t error) { switch (error) { case CUBLAS_STATUS_SUCCESS: diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index 938aa498133..f5c2fde4ab0 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -102,7 +102,7 @@ void CuDNNConvolutionLayer::Reshape( // Specify workspace limit for kernels directly until we have a // planning strategy and a rewrite of Caffe's GPU memory mangagement - size_t workspace_limit_bytes; + size_t workspace_limit_bytes, total_memory; MemoryHandler::getInfo(&workspace_limit_bytes, &total_memory); for (int i = 0; i < bottom.size(); i++) { diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index 4ab9a942353..c50e78ad7c7 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -18,7 +18,7 @@ void CuDNNConvolutionLayer::Forward_gpu( for (int i = 0; i < bottom.size(); ++i) { const Dtype* bottom_data = bottom[i]->gpu_data(); Dtype* top_data = top[i]->mutable_gpu_data(); - size_t workspaceSizeInBytes_temp; + // Forward through cuDNN in parallel over groups. for (int g = 0; g < this->group_; g++) { @@ -116,7 +116,6 @@ void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], bwd_data_algo_[i], workspaceData, workspace_bwd_data_sizes_[i], - workspace_bwd_data_sizes_[i], cudnn::dataType::zero, bottom_descs_[i], bottom_diff + bottom_offset_ * g)); MemoryHandler::freeGPU(workspaceData); diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index 1ebbc17da52..efdad0ef256 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -225,6 +225,7 @@ P2PSync::P2PSync(shared_ptr > root_solver, #ifndef CPU_ONLY int initial_device; CUDA_CHECK(cudaGetDevice(&initial_device)); + const int self = param.device_id(); CUDA_CHECK(cudaSetDevice(self)); @@ -265,17 +266,19 @@ template P2PSync::~P2PSync() { #ifndef CPU_ONLY if (parent_) { - - const int peer = parent_->solver_->param().device_id(); - cudaSetDevice(peer); + int initial_device; + CUDA_CHECK(cudaGetDevice(&initial_device)); + const int self = solver_->param().device_id(); + CUDA_CHECK(cudaSetDevice(self)); MemoryHandler::freeGPU(parent_grads_); parent_grads_ = NULL; - cudaSetDevice(self); + const int peer = parent_->solver_->param().device_id(); int access; CUDA_CHECK(cudaDeviceCanAccessPeer(&access, self, peer)); if (access) { CUDA_CHECK(cudaDeviceDisablePeerAccess(peer)); } + CUDA_CHECK(cudaSetDevice(initial_device)); } #endif } From 0b70f2a019643c90aec156f5c88d193ecf46c859 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Mon, 12 Oct 2015 19:03:33 -0700 Subject: [PATCH 257/331] CNMEM case checked --- src/caffe/test/test_caffe_main.cpp | 2 +- tools/caffe.cpp | 3 --- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/src/caffe/test/test_caffe_main.cpp b/src/caffe/test/test_caffe_main.cpp index 19d80b7dd6e..430ccd610b5 100644 --- a/src/caffe/test/test_caffe_main.cpp +++ b/src/caffe/test/test_caffe_main.cpp @@ -47,7 +47,7 @@ int main(int argc, char** argv) { cudaGetDevice(&device); cout << "Current device id: " << device << endl; cudaGetDeviceProperties(&CAFFE_TEST_CUDA_PROP, device); - caffe::MemoryHandlerActivator activator(devices, false); + caffe::MemoryHandlerActivator activator(devices); #endif // invoke the test. diff --git a/tools/caffe.cpp b/tools/caffe.cpp index 60870882268..77c68b64d6a 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -189,9 +189,6 @@ int train() { Caffe::set_mode(Caffe::GPU); Caffe::set_solver_count(gpus.size()); } -#ifdef USE_CNMEM - MemoryHandlerActivator handler(gpus); -#endif MemoryHandlerActivator handler(gpus); From 94054363ad077b542f6f6764adcc631349c788e4 Mon Sep 17 00:00:00 2001 From: Sergei Nikolaev Date: Tue, 13 Oct 2015 12:17:43 -0700 Subject: [PATCH 258/331] peer/self ordering fix --- src/caffe/parallel.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index efdad0ef256..148f8c5013c 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -269,11 +269,12 @@ P2PSync::~P2PSync() { int initial_device; CUDA_CHECK(cudaGetDevice(&initial_device)); const int self = solver_->param().device_id(); - CUDA_CHECK(cudaSetDevice(self)); + const int peer = parent_->solver_->param().device_id(); + CUDA_CHECK(cudaSetDevice(peer)); MemoryHandler::freeGPU(parent_grads_); parent_grads_ = NULL; - const int peer = parent_->solver_->param().device_id(); int access; + cudaSetDevice(self); CUDA_CHECK(cudaDeviceCanAccessPeer(&access, self, peer)); if (access) { CUDA_CHECK(cudaDeviceDisablePeerAccess(peer)); From 5dcff36aac9c8ab35cb01bc589c1cfe5ce157483 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 13 Oct 2015 15:08:01 -0700 Subject: [PATCH 259/331] Polished MemoryHandler --- include/caffe/MemoryHandler.hpp | 16 +++-- src/caffe/MemoryHandler.cpp | 106 +++++++++++++++++++++----------- 2 files changed, 81 insertions(+), 41 deletions(-) diff --git a/include/caffe/MemoryHandler.hpp b/include/caffe/MemoryHandler.hpp index 74acc9c5fef..886cdb6fa02 100644 --- a/include/caffe/MemoryHandler.hpp +++ b/include/caffe/MemoryHandler.hpp @@ -7,6 +7,8 @@ namespace caffe { class MemoryHandler { public: + enum PoolMode { NoPool, CnMemPool, CubPool }; + #ifndef CPU_ONLY static void mallocGPU(void **ptr, size_t size, cudaStream_t stream = cudaStreamDefault); @@ -14,29 +16,31 @@ class MemoryHandler { static void registerStream(cudaStream_t stream); #endif + static const char* getName(); static bool usingPool() { - return using_pool_; + return mode_ != NoPool; } static void getInfo(size_t *free_mem, size_t *used_mem); private: - static void init(const std::vector& gpus, bool use_pool=true); + + static void init(const std::vector&, PoolMode); static void destroy(); friend class MemoryHandlerActivator; static bool using_pool_; static bool initialized_; - - + static PoolMode mode_; }; class MemoryHandlerActivator { public: MemoryHandlerActivator(const std::vector& gpus, - bool use_pool = true) { - MemoryHandler::init(gpus, use_pool && gpus.size() > 0); + MemoryHandler::PoolMode m = MemoryHandler::CnMemPool) { + MemoryHandler::init(gpus,m); } + ~MemoryHandlerActivator() { MemoryHandler::destroy(); } diff --git a/src/caffe/MemoryHandler.cpp b/src/caffe/MemoryHandler.cpp index 23048c673b8..13b7cab63fa 100644 --- a/src/caffe/MemoryHandler.cpp +++ b/src/caffe/MemoryHandler.cpp @@ -9,8 +9,7 @@ namespace caffe { -bool MemoryHandler::using_pool_ = false; -bool MemoryHandler::initialized_ = false; +MemoryHandler::PoolMode MemoryHandler::mode_ = MemoryHandler::NoPool; using namespace boost; @@ -21,83 +20,120 @@ using namespace boost; #ifndef CPU_ONLY // CPU-only Caffe. void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { - CHECK(initialized_); CHECK(ptr!=0); - if (using_pool_) { + switch (mode_) { + case CnMemPool: CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); - } else { + break; + case CubPool: + default: CUDA_CHECK(cudaMalloc(ptr, size)); + break; } } void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { - CHECK(initialized_); // allow for null pointer deallocation if(!ptr) return; - if (using_pool_) { + switch (mode_) { + case CnMemPool: CNMEM_CHECK(cnmemFree(ptr, stream)); - } else { + break; + case CubPool: + default: CUDA_CHECK(cudaFree(ptr)); + break; } } void MemoryHandler::registerStream(cudaStream_t stream) { - CHECK(initialized_); - if (using_pool_) { + switch (mode_) { + case CnMemPool: CNMEM_CHECK(cnmemRegisterStream(stream)); + break; + case CubPool: + default: + break; } } void MemoryHandler::destroy() { - CHECK(initialized_); - CNMEM_CHECK(cnmemFinalize()); - initialized_ = false; - using_pool_ = false; + switch (mode_) { + case CnMemPool: + CNMEM_CHECK(cnmemFinalize()); + break; + case CubPool: + default: + break; + } + mode_ = NoPool; } -void MemoryHandler::init(const std::vector& gpus, bool use_pool) +void MemoryHandler::init(const std::vector& gpus, PoolMode m) { - CHECK(!initialized_); - -#ifdef USE_CNMEM - if (use_pool) { - using_pool_ = true; - cnmemDevice_t *devs = new cnmemDevice_t[gpus.size()]; + if (gpus.size() <= 0) { + // should we report an error here ? + m = MemoryHandler::NoPool; + } + switch (m) { + case CnMemPool: + { +#ifdef USE_CNMEM + cnmemDevice_t* devs = new cnmemDevice_t[gpus.size()]; int initial_device; CUDA_CHECK(cudaGetDevice(&initial_device)); - + for (int i = 0; i < gpus.size(); i++) { CUDA_CHECK(cudaSetDevice(gpus[i])); - + devs[i].device = gpus[i]; - + size_t free_mem, used_mem; CUDA_CHECK(cudaMemGetInfo(&free_mem, &used_mem)); - + devs[i].size = size_t(0.95*free_mem); devs[i].numStreams = 0; devs[i].streams = NULL; } CNMEM_CHECK(cnmemInit(gpus.size(), devs, CNMEM_FLAGS_DEFAULT)); - initialized_ = true; - + CUDA_CHECK(cudaSetDevice(initial_device)); - + delete [] devs; - } + mode_ = m; + } #endif - initialized_ = true; - std::cout << "MemoryHandler initialized" << - (using_pool_ ? " with CNMEM pool.\n" : " with CUDA allocator.\n"); -} + break; + case CubPool: + default: + break; + } + + std::cout << "MemoryHandler initialized with " << getName() << std::endl; +} + +const char* MemoryHandler::getName() { + switch (mode_) { + case CnMemPool: + return "CNMEM Pool"; + case CubPool: + return "CUB Pool"; + default: + return "No Pool : Plain CUDA Allocator"; + } +} + void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { - if (using_pool_) { + switch (mode_) { + case CnMemPool: CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); - } else { + break; + case CubPool: + default: CUDA_CHECK(cudaMemGetInfo(free_mem, total_mem)); } } From d5b7d26ba142c83ce757cb1286b64d85ae020e46 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 13 Oct 2015 19:44:59 -0700 Subject: [PATCH 260/331] LINT fixes --- include/caffe/MemoryHandler.hpp | 11 +- src/caffe/MemoryHandler.cpp | 190 ++++++++++---------- src/caffe/layers/cudnn_conv_layer.cpp | 2 +- src/caffe/layers/cudnn_conv_layer.cu | 248 ++++++++++++++------------ src/caffe/layers/cudnn_lcn_layer.cu | 2 +- src/caffe/parallel.cpp | 1 - src/caffe/test/test_caffe_main.cpp | 5 +- 7 files changed, 242 insertions(+), 217 deletions(-) diff --git a/include/caffe/MemoryHandler.hpp b/include/caffe/MemoryHandler.hpp index 886cdb6fa02..02c38bbe8de 100644 --- a/include/caffe/MemoryHandler.hpp +++ b/include/caffe/MemoryHandler.hpp @@ -1,13 +1,14 @@ #ifndef CAFFE_MEMORYHANDLER_HPP_ #define CAFFE_MEMORYHANDLER_HPP_ +#include #include "common.hpp" namespace caffe { class MemoryHandler { public: - enum PoolMode { NoPool, CnMemPool, CubPool }; + enum PoolMode { NoPool, CnMemPool, CubPool }; #ifndef CPU_ONLY static void mallocGPU(void **ptr, size_t size, @@ -24,7 +25,7 @@ class MemoryHandler { static void getInfo(size_t *free_mem, size_t *used_mem); private: - + static void initCNMEM(const std::vector& gpus); static void init(const std::vector&, PoolMode); static void destroy(); @@ -36,9 +37,9 @@ class MemoryHandler { class MemoryHandlerActivator { public: - MemoryHandlerActivator(const std::vector& gpus, - MemoryHandler::PoolMode m = MemoryHandler::CnMemPool) { - MemoryHandler::init(gpus,m); + MemoryHandlerActivator(const std::vector& gpus, + MemoryHandler::PoolMode m = MemoryHandler::CnMemPool) { + MemoryHandler::init(gpus, m); } ~MemoryHandlerActivator() { diff --git a/src/caffe/MemoryHandler.cpp b/src/caffe/MemoryHandler.cpp index 13b7cab63fa..5182f41fdfa 100644 --- a/src/caffe/MemoryHandler.cpp +++ b/src/caffe/MemoryHandler.cpp @@ -1,3 +1,5 @@ +#include + #include "caffe/common.hpp" #include "caffe/MemoryHandler.hpp" #ifdef USE_CNMEM @@ -9,136 +11,130 @@ namespace caffe { -MemoryHandler::PoolMode MemoryHandler::mode_ = MemoryHandler::NoPool; - -using namespace boost; + MemoryHandler::PoolMode MemoryHandler::mode_ = MemoryHandler::NoPool; #ifndef CNMEM_CHECK -# define CNMEM_CHECK(x) +# define CNMEM_CHECK(x) #endif #ifndef CPU_ONLY // CPU-only Caffe. -void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { - CHECK(ptr!=0); - switch (mode_) { - case CnMemPool: - CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); - break; - case CubPool: - default: - CUDA_CHECK(cudaMalloc(ptr, size)); - break; + void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { + CHECK((ptr) != NULL); + switch (mode_) { + case CnMemPool: + CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); + break; + case CubPool: + default: + CUDA_CHECK(cudaMalloc(ptr, size)); + break; + } } -} - - -void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { - // allow for null pointer deallocation - if(!ptr) - return; - switch (mode_) { - case CnMemPool: - CNMEM_CHECK(cnmemFree(ptr, stream)); - break; - case CubPool: - default: - CUDA_CHECK(cudaFree(ptr)); - break; + + + void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { + // allow for null pointer deallocation + if (!ptr) + return; + switch (mode_) { + case CnMemPool: + CNMEM_CHECK(cnmemFree(ptr, stream)); + break; + case CubPool: + default: + CUDA_CHECK(cudaFree(ptr)); + break; + } } -} - -void MemoryHandler::registerStream(cudaStream_t stream) { - switch (mode_) { - case CnMemPool: - CNMEM_CHECK(cnmemRegisterStream(stream)); - break; - case CubPool: - default: - break; + + void MemoryHandler::registerStream(cudaStream_t stream) { + switch (mode_) { + case CnMemPool: + CNMEM_CHECK(cnmemRegisterStream(stream)); + break; + case CubPool: + default: + break; + } } -} - -void MemoryHandler::destroy() { - switch (mode_) { - case CnMemPool: - CNMEM_CHECK(cnmemFinalize()); - break; - case CubPool: - default: - break; - } - mode_ = NoPool; -} - -void MemoryHandler::init(const std::vector& gpus, PoolMode m) -{ - if (gpus.size() <= 0) { - // should we report an error here ? - m = MemoryHandler::NoPool; + + void MemoryHandler::destroy() { + switch (mode_) { + case CnMemPool: + CNMEM_CHECK(cnmemFinalize()); + break; + case CubPool: + default: + break; + } + mode_ = NoPool; } - switch (m) { - case CnMemPool: - { + void MemoryHandler::initCNMEM(const std::vector& gpus) { #ifdef USE_CNMEM cnmemDevice_t* devs = new cnmemDevice_t[gpus.size()]; int initial_device; CUDA_CHECK(cudaGetDevice(&initial_device)); - + for (int i = 0; i < gpus.size(); i++) { CUDA_CHECK(cudaSetDevice(gpus[i])); - devs[i].device = gpus[i]; - size_t free_mem, used_mem; CUDA_CHECK(cudaMemGetInfo(&free_mem, &used_mem)); - devs[i].size = size_t(0.95*free_mem); devs[i].numStreams = 0; devs[i].streams = NULL; } CNMEM_CHECK(cnmemInit(gpus.size(), devs, CNMEM_FLAGS_DEFAULT)); - CUDA_CHECK(cudaSetDevice(initial_device)); - delete [] devs; - mode_ = m; - } + mode_ = CnMemPool; #endif - break; - case CubPool: - default: - break; } + void MemoryHandler::init(const std::vector& gpus, + PoolMode m) { + if (gpus.size() <= 0) { + // should we report an error here ? + m = MemoryHandler::NoPool; + } + + switch (m) { + case CnMemPool: + initCNMEM(gpus); + break; + case CubPool: + default: + break; + } + + std::cout << "MemoryHandler initialized with " + << getName() << std::endl; + } - std::cout << "MemoryHandler initialized with " << getName() << std::endl; -} - -const char* MemoryHandler::getName() { - switch (mode_) { - case CnMemPool: - return "CNMEM Pool"; - case CubPool: - return "CUB Pool"; - default: - return "No Pool : Plain CUDA Allocator"; + const char* MemoryHandler::getName() { + switch (mode_) { + case CnMemPool: + return "CNMEM Pool"; + case CubPool: + return "CUB Pool"; + default: + return "No Pool : Plain CUDA Allocator"; + } } -} - -void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { - switch (mode_) { - case CnMemPool: - CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); - break; - case CubPool: - default: - CUDA_CHECK(cudaMemGetInfo(free_mem, total_mem)); + + void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { + switch (mode_) { + case CnMemPool: + CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); + break; + case CubPool: + default: + CUDA_CHECK(cudaMemGetInfo(free_mem, total_mem)); + } } -} -} +} // namespace caffe #endif // CPU_ONLY - diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index f5c2fde4ab0..9864aa97f1b 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -116,7 +116,7 @@ void CuDNNConvolutionLayer::Reshape( this->num_output_ / this->group_, height_out, width_out, this->num_output_ * this->out_spatial_dim_, this->out_spatial_dim_, width_out, 1); - + cudnn::setConvolutionDesc(&conv_descs_[i], bottom_descs_[i], filter_desc_, pad_h, pad_w, stride_h, stride_w); diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index c50e78ad7c7..ca94a9f5633 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -7,130 +7,158 @@ #include "caffe/util/math_functions.hpp" #include "caffe/vision_layers.hpp" +// Those defines serve single purpose to keep sane C++ formatting +// in presence of <80 characters rule +#define cudnnConvFwd cudnnConvolutionForward +#define cudnnConvBwdBias cudnnConvolutionBackwardBias +#define cudnnConvBwdFilter cudnnConvolutionBackwardFilter_v3 +#define cudnnConvBwdData cudnnConvolutionBackwardData_v3 + namespace caffe { -__global__ void sync_conv_groups() { } - -template -void CuDNNConvolutionLayer::Forward_gpu( - const vector*>& bottom, const vector*>& top) { - const Dtype* weight = this->blobs_[0]->gpu_data(); - for (int i = 0; i < bottom.size(); ++i) { - const Dtype* bottom_data = bottom[i]->gpu_data(); - Dtype* top_data = top[i]->mutable_gpu_data(); - - - // Forward through cuDNN in parallel over groups. - for (int g = 0; g < this->group_; g++) { - MemoryHandler::mallocGPU(&workspaceData, workspace_fwd_sizes_[i]); - // Filters. - CUDNN_CHECK(cudnnConvolutionForward(Caffe::cudnn_handle(), - cudnn::dataType::one, - bottom_descs_[i], bottom_data + bottom_offset_ * g, - filter_desc_, weight + this->weight_offset_ * g, - conv_descs_[i], - fwd_algo_[i], workspaceData, workspace_fwd_sizes_[i], - cudnn::dataType::zero, - top_descs_[i], top_data + top_offset_ * g)); - - MemoryHandler::freeGPU(workspaceData); - workspaceData = NULL; - // Bias. - if (this->bias_term_) { - const Dtype* bias_data = this->blobs_[1]->gpu_data(); - CUDNN_CHECK(cudnnAddTensor_v3(Caffe::cudnn_handle(), - cudnn::dataType::one, - bias_desc_, bias_data + bias_offset_ * g, - cudnn::dataType::one, - top_descs_[i], top_data + top_offset_ * g)); + __global__ void sync_conv_groups() { } + + template + void CuDNNConvolutionLayer:: + Forward_gpu(const vector*>& bottom, + const vector*>& top) { + const Dtype* weight = this->blobs_[0]->gpu_data(); + for (int i = 0; i < bottom.size(); ++i) { + const Dtype* bottom_data = bottom[i]->gpu_data(); + Dtype* top_data = top[i]->mutable_gpu_data(); + + + // Forward through cuDNN in parallel over groups. + for (int g = 0; g < this->group_; g++) { + MemoryHandler::mallocGPU(&workspaceData, workspace_fwd_sizes_[i]); + // Filters. + CUDNN_CHECK(cudnnConvFwd(Caffe::cudnn_handle(), + cudnn::dataType::one, + bottom_descs_[i], + bottom_data + bottom_offset_ * g, + filter_desc_, + weight + this->weight_offset_ * g, + conv_descs_[i], + fwd_algo_[i], workspaceData, + workspace_fwd_sizes_[i], + cudnn::dataType::zero, + top_descs_[i], + top_data + top_offset_ * g)); + + MemoryHandler::freeGPU(workspaceData); + workspaceData = NULL; + // Bias. + if (this->bias_term_) { + const Dtype* bias_data = this->blobs_[1]->gpu_data(); + CUDNN_CHECK(cudnnAddTensor_v3(Caffe::cudnn_handle(), + cudnn::dataType::one, + bias_desc_, + bias_data + bias_offset_ * g, + cudnn::dataType::one, + top_descs_[i], + top_data + top_offset_ * g)); + } } - } - // Synchronize the work across groups, each of which went into its own - // stream, by launching an empty kernel into the default (null) stream. - // NOLINT_NEXT_LINE(whitespace/operators) - CUDA_CHECK(cudaStreamSynchronize(cudaStreamLegacy)); - } -} - -template -void CuDNNConvolutionLayer::Backward_gpu(const vector*>& top, - const vector& propagate_down, const vector*>& bottom) { - const Dtype* weight = NULL; - Dtype* weight_diff = NULL; - - if (this->param_propagate_down_[0]) { - weight = this->blobs_[0]->gpu_data(); - weight_diff = this->blobs_[0]->mutable_gpu_diff(); - caffe_gpu_set(this->blobs_[0]->count(), Dtype(0), weight_diff); + // Synchronize the work across groups, each of which went into its own + // stream, by launching an empty kernel into the default (null) stream. + // NOLINT_NEXT_LINE(whitespace/operators) + CUDA_CHECK(cudaStreamSynchronize(cudaStreamLegacy)); + } } - Dtype* bias_diff = NULL; - if (this->bias_term_ && this->param_propagate_down_[1]) { - bias_diff = this->blobs_[1]->mutable_gpu_diff(); - caffe_gpu_set(this->blobs_[1]->count(), Dtype(0), bias_diff); - } + template + void + CuDNNConvolutionLayer:: + Backward_gpu(const vector*>& top, + const vector& propagate_down, + const vector*>& bottom) { + const Dtype* weight = NULL; + Dtype* weight_diff = NULL; + + if (this->param_propagate_down_[0]) { + weight = this->blobs_[0]->gpu_data(); + weight_diff = this->blobs_[0]->mutable_gpu_diff(); + caffe_gpu_set(this->blobs_[0]->count(), Dtype(0), weight_diff); + } + Dtype* bias_diff = NULL; - for (int i = 0; i < top.size(); ++i) { - const Dtype* top_diff = top[i]->gpu_diff(); - - // Backward through cuDNN in parallel over groups and gradients. - for (int g = 0; g < this->group_; g++) { - // Gradient w.r.t. bias. - if (this->bias_term_ && this->param_propagate_down_[1]) { - CUDNN_CHECK(cudnnConvolutionBackwardBias(Caffe::cudnn_handle(), - cudnn::dataType::one, - top_descs_[i], top_diff + top_offset_ * g, - cudnn::dataType::one, - bias_desc_, bias_diff + bias_offset_ * g)); - } + if (this->bias_term_ && this->param_propagate_down_[1]) { + bias_diff = this->blobs_[1]->mutable_gpu_diff(); + caffe_gpu_set(this->blobs_[1]->count(), Dtype(0), bias_diff); + } - // Gradient w.r.t. weights. - if (this->param_propagate_down_[0]) { - MemoryHandler::mallocGPU(&workspaceData, workspace_bwd_filter_sizes_[i]); - const Dtype* bottom_data = bottom[i]->gpu_data(); - CUDNN_CHECK(cudnnConvolutionBackwardFilter_v3( - Caffe::cudnn_handle(), - cudnn::dataType::one, - bottom_descs_[i], bottom_data + bottom_offset_ * g, - top_descs_[i], top_diff + top_offset_ * g, - conv_descs_[i], - bwd_filter_algo_[i], workspaceData, workspace_bwd_filter_sizes_[i], - cudnn::dataType::one, - filter_desc_, weight_diff + this->weight_offset_ * g)); - MemoryHandler::freeGPU(workspaceData); - workspaceData = NULL; - } + for (int i = 0; i < top.size(); ++i) { + const Dtype* top_diff = top[i]->gpu_diff(); + + // Backward through cuDNN in parallel over groups and gradients. + for (int g = 0; g < this->group_; g++) { + // Gradient w.r.t. bias. + if (this->bias_term_ && this->param_propagate_down_[1]) { + CUDNN_CHECK(cudnnConvBwdBias(Caffe::cudnn_handle(), + cudnn::dataType::one, + top_descs_[i], + top_diff + top_offset_ * g, + cudnn::dataType::one, + bias_desc_, + bias_diff + bias_offset_ * g)); + } - // Gradient w.r.t. bottom data. - if (propagate_down[i]) { - if (weight == NULL) { - weight = this->blobs_[0]->gpu_data(); + // Gradient w.r.t. weights. + if (this->param_propagate_down_[0]) { + MemoryHandler::mallocGPU(&workspaceData, + workspace_bwd_filter_sizes_[i]); + const Dtype* bottom_data = bottom[i]->gpu_data(); + CUDNN_CHECK(cudnnConvBwdFilter(Caffe::cudnn_handle(), + cudnn::dataType::one, + bottom_descs_[i], + bottom_data + bottom_offset_ * g, + top_descs_[i], + top_diff + top_offset_ * g, + conv_descs_[i], + bwd_filter_algo_[i], + workspaceData, + workspace_bwd_filter_sizes_[i], + cudnn::dataType::one, + filter_desc_, + weight_diff + weight_offset_ * g)); + MemoryHandler::freeGPU(workspaceData); + workspaceData = NULL; + } + + // Gradient w.r.t. bottom data. + if (propagate_down[i]) { + if (weight == NULL) { + weight = this->blobs_[0]->gpu_data(); + } + Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); + MemoryHandler::mallocGPU(&workspaceData, + workspace_bwd_data_sizes_[i]); + CUDNN_CHECK(cudnnConvBwdData(Caffe::cudnn_handle(), + cudnn::dataType::one, + filter_desc_, + weight + this->weight_offset_ * g, + top_descs_[i], + top_diff + top_offset_ * g, + conv_descs_[i], + bwd_data_algo_[i], workspaceData, + workspace_bwd_data_sizes_[i], + cudnn::dataType::zero, + bottom_descs_[i], + bottom_diff + bottom_offset_ * g)); + MemoryHandler::freeGPU(workspaceData); + workspaceData = NULL; } - Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); - MemoryHandler::mallocGPU(&workspaceData, workspace_bwd_data_sizes_[i]); - CUDNN_CHECK(cudnnConvolutionBackwardData_v3( - Caffe::cudnn_handle(), - cudnn::dataType::one, - filter_desc_, weight + this->weight_offset_ * g, - top_descs_[i], top_diff + top_offset_ * g, - conv_descs_[i], - bwd_data_algo_[i], workspaceData, workspace_bwd_data_sizes_[i], - cudnn::dataType::zero, - bottom_descs_[i], bottom_diff + bottom_offset_ * g)); - MemoryHandler::freeGPU(workspaceData); - workspaceData = NULL; } - } - // Synchronize the work across groups, each of which went into its own - // stream, by launching an empty kernel into the default (null) stream. - // NOLINT_NEXT_LINE(whitespace/operators) - CUDA_CHECK(cudaStreamSynchronize(cudaStreamLegacy)); + // Synchronize the work across groups, each of which went into its own + // stream, by launching an empty kernel into the default (null) stream. + // NOLINT_NEXT_LINE(whitespace/operators) + CUDA_CHECK(cudaStreamSynchronize(cudaStreamLegacy)); + } } -} -INSTANTIATE_LAYER_GPU_FUNCS(CuDNNConvolutionLayer); + INSTANTIATE_LAYER_GPU_FUNCS(CuDNNConvolutionLayer); } // namespace caffe #endif diff --git a/src/caffe/layers/cudnn_lcn_layer.cu b/src/caffe/layers/cudnn_lcn_layer.cu index 76ed4b36d1a..50efbaec6a0 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cu +++ b/src/caffe/layers/cudnn_lcn_layer.cu @@ -14,7 +14,7 @@ void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, const vector*>& top) { const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - + MemoryHandler::mallocGPU(&this->tempData1, this->tempDataSize); MemoryHandler::mallocGPU(&this->tempData2, this->tempDataSize); diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index 148f8c5013c..970e7191cca 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -225,7 +225,6 @@ P2PSync::P2PSync(shared_ptr > root_solver, #ifndef CPU_ONLY int initial_device; CUDA_CHECK(cudaGetDevice(&initial_device)); - const int self = param.device_id(); CUDA_CHECK(cudaSetDevice(self)); diff --git a/src/caffe/test/test_caffe_main.cpp b/src/caffe/test/test_caffe_main.cpp index 430ccd610b5..39960c43500 100644 --- a/src/caffe/test/test_caffe_main.cpp +++ b/src/caffe/test/test_caffe_main.cpp @@ -1,5 +1,6 @@ // The main caffe test code. Your test cpp code should include this hpp // to allow a main function to be compiled into the binary. +#include #include "caffe/caffe.hpp" #include "caffe/test/test_caffe_main.hpp" @@ -35,14 +36,14 @@ int main(int argc, char** argv) { devices.push_back(CUDA_TEST_DEVICE); } - if (devices.size()==1) { + if (devices.size() == 1) { cout << "Setting to use device " << devices[0] << endl; cudaSetDevice(devices[0]); } else { for (int i = 0; i < device_count; ++i) devices.push_back(i); } - + int device; cudaGetDevice(&device); cout << "Current device id: " << device << endl; From 00d6a1b172b3cfdfd21245116a49077a441c2351 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Thu, 15 Oct 2015 14:28:32 -0700 Subject: [PATCH 261/331] CPU_ONLY fix --- include/caffe/MemoryHandler.hpp | 13 +++++++++++-- src/caffe/MemoryHandler.cpp | 14 ++++++-------- src/caffe/common.cpp | 1 - 3 files changed, 17 insertions(+), 11 deletions(-) diff --git a/include/caffe/MemoryHandler.hpp b/include/caffe/MemoryHandler.hpp index 02c38bbe8de..1327a528469 100644 --- a/include/caffe/MemoryHandler.hpp +++ b/include/caffe/MemoryHandler.hpp @@ -6,16 +6,17 @@ namespace caffe { +#ifndef CPU_ONLY + class MemoryHandler { public: enum PoolMode { NoPool, CnMemPool, CubPool }; -#ifndef CPU_ONLY + static void mallocGPU(void **ptr, size_t size, cudaStream_t stream = cudaStreamDefault); static void freeGPU(void *ptr, cudaStream_t = cudaStreamDefault); static void registerStream(cudaStream_t stream); -#endif static const char* getName(); static bool usingPool() { @@ -35,9 +36,13 @@ class MemoryHandler { static PoolMode mode_; }; +#endif // CPU_ONLY + class MemoryHandlerActivator { public: +#ifndef CPU_ONLY MemoryHandlerActivator(const std::vector& gpus, + // experimental MemoryHandler::PoolMode m = MemoryHandler::CnMemPool) { MemoryHandler::init(gpus, m); } @@ -45,6 +50,10 @@ class MemoryHandlerActivator { ~MemoryHandlerActivator() { MemoryHandler::destroy(); } +#else + explicit MemoryHandlerActivator(const std::vector&) { + } +#endif }; } // namespace caffe diff --git a/src/caffe/MemoryHandler.cpp b/src/caffe/MemoryHandler.cpp index 5182f41fdfa..0fe4533fe23 100644 --- a/src/caffe/MemoryHandler.cpp +++ b/src/caffe/MemoryHandler.cpp @@ -1,24 +1,22 @@ #include - #include "caffe/common.hpp" + #include "caffe/MemoryHandler.hpp" + +#ifndef CPU_ONLY // CPU-only Caffe. + #ifdef USE_CNMEM // CNMEM integration #include +# else +# define CNMEM_CHECK(x) #endif -#include namespace caffe { MemoryHandler::PoolMode MemoryHandler::mode_ = MemoryHandler::NoPool; -#ifndef CNMEM_CHECK -# define CNMEM_CHECK(x) -#endif - -#ifndef CPU_ONLY // CPU-only Caffe. - void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { CHECK((ptr) != NULL); switch (mode_) { diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index 93425b2265b..ad3960bc75f 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -10,7 +10,6 @@ namespace caffe { -static boost::shared_ptr mem_handler; // Make sure each thread can have different values. static boost::thread_specific_ptr thread_instance_; From b2daa561fb9a94dcf1c9c86880db6de03c2d6979 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Thu, 15 Oct 2015 15:12:50 -0700 Subject: [PATCH 262/331] macro redefinition fix --- src/caffe/MemoryHandler.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/caffe/MemoryHandler.cpp b/src/caffe/MemoryHandler.cpp index 0fe4533fe23..d8e423ec45b 100644 --- a/src/caffe/MemoryHandler.cpp +++ b/src/caffe/MemoryHandler.cpp @@ -8,8 +8,6 @@ #ifdef USE_CNMEM // CNMEM integration #include -# else -# define CNMEM_CHECK(x) #endif From 906002c1c108488d2b24ebba8dbf9edd569b5a77 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Sun, 18 Oct 2015 01:10:20 -0700 Subject: [PATCH 263/331] Names normalized --- include/caffe/MemoryHandler.hpp | 61 ------------ include/caffe/common.hpp | 2 - include/caffe/util/gpu_memory.hpp | 51 ++++++++++ src/caffe/layers/cudnn_conv_layer.cpp | 7 +- src/caffe/layers/cudnn_conv_layer.cu | 17 ++-- src/caffe/layers/cudnn_lcn_layer.cu | 18 ++-- src/caffe/parallel.cpp | 13 +-- src/caffe/syncedmem.cpp | 11 ++- src/caffe/test/test_caffe_main.cpp | 4 +- .../gpu_memory.cpp} | 99 ++++++++++--------- tools/caffe.cpp | 6 +- 11 files changed, 146 insertions(+), 143 deletions(-) delete mode 100644 include/caffe/MemoryHandler.hpp create mode 100644 include/caffe/util/gpu_memory.hpp rename src/caffe/{MemoryHandler.cpp => util/gpu_memory.cpp} (70%) diff --git a/include/caffe/MemoryHandler.hpp b/include/caffe/MemoryHandler.hpp deleted file mode 100644 index 1327a528469..00000000000 --- a/include/caffe/MemoryHandler.hpp +++ /dev/null @@ -1,61 +0,0 @@ -#ifndef CAFFE_MEMORYHANDLER_HPP_ -#define CAFFE_MEMORYHANDLER_HPP_ - -#include -#include "common.hpp" - -namespace caffe { - -#ifndef CPU_ONLY - -class MemoryHandler { - public: - enum PoolMode { NoPool, CnMemPool, CubPool }; - - - static void mallocGPU(void **ptr, size_t size, - cudaStream_t stream = cudaStreamDefault); - static void freeGPU(void *ptr, cudaStream_t = cudaStreamDefault); - static void registerStream(cudaStream_t stream); - - static const char* getName(); - static bool usingPool() { - return mode_ != NoPool; - } - - static void getInfo(size_t *free_mem, size_t *used_mem); - - private: - static void initCNMEM(const std::vector& gpus); - static void init(const std::vector&, PoolMode); - static void destroy(); - - friend class MemoryHandlerActivator; - static bool using_pool_; - static bool initialized_; - static PoolMode mode_; -}; - -#endif // CPU_ONLY - -class MemoryHandlerActivator { - public: -#ifndef CPU_ONLY - MemoryHandlerActivator(const std::vector& gpus, - // experimental - MemoryHandler::PoolMode m = MemoryHandler::CnMemPool) { - MemoryHandler::init(gpus, m); - } - - ~MemoryHandlerActivator() { - MemoryHandler::destroy(); - } -#else - explicit MemoryHandlerActivator(const std::vector&) { - } -#endif -}; - -} // namespace caffe - -# endif diff --git a/include/caffe/common.hpp b/include/caffe/common.hpp index 421e52dd6c3..33b6d3288c8 100644 --- a/include/caffe/common.hpp +++ b/include/caffe/common.hpp @@ -65,8 +65,6 @@ private:\ // is executed we will see a fatal log. #define NOT_IMPLEMENTED LOG(FATAL) << "Not Implemented Yet" -#include "MemoryHandler.hpp" - // See PR #1236 namespace cv { class Mat; } diff --git a/include/caffe/util/gpu_memory.hpp b/include/caffe/util/gpu_memory.hpp new file mode 100644 index 00000000000..1e92d6f6632 --- /dev/null +++ b/include/caffe/util/gpu_memory.hpp @@ -0,0 +1,51 @@ +#ifndef CAFFE_UTIL_GPU_MEMORY_HPP_ +#define CAFFE_UTIL_GPU_MEMORY_HPP_ + +#include +#include "caffe/common.hpp" + +namespace caffe { + +class gpu_memory { + public: + enum PoolMode { NoPool, CnMemPool, CubPool }; + + static const char* getPoolName(); + static bool usingPool() { + return mode_ != NoPool; + } + + class arena { + public: + arena(const std::vector& gpus, PoolMode m = CnMemPool) { + init(gpus, m); + } + ~arena() { + destroy(); + } + }; + + private: + static void init(const std::vector&, PoolMode); + static void destroy(); + + static bool initialized_; + static PoolMode mode_; + +#ifndef CPU_ONLY + + public: + static void allocate(void **ptr, size_t size, + cudaStream_t stream = cudaStreamDefault); + static void deallocate(void *ptr, cudaStream_t = cudaStreamDefault); + static void registerStream(cudaStream_t stream); + static void getInfo(size_t *free_mem, size_t *used_mem); + + private: + static void initCNMEM(const std::vector& gpus); +#endif +}; + +} // namespace caffe + +# endif diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index 9864aa97f1b..68b70e23f29 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -4,10 +4,12 @@ #include "caffe/filler.hpp" #include "caffe/layer.hpp" +#include "caffe/util/gpu_memory.hpp" #include "caffe/util/im2col.hpp" #include "caffe/util/math_functions.hpp" #include "caffe/vision_layers.hpp" + namespace caffe { /** @@ -103,7 +105,7 @@ void CuDNNConvolutionLayer::Reshape( // Specify workspace limit for kernels directly until we have a // planning strategy and a rewrite of Caffe's GPU memory mangagement size_t workspace_limit_bytes, total_memory; - MemoryHandler::getInfo(&workspace_limit_bytes, &total_memory); + gpu_memory::getInfo(&workspace_limit_bytes, &total_memory); for (int i = 0; i < bottom.size(); i++) { cudnn::setTensor4dDesc(&bottom_descs_[i], @@ -195,7 +197,8 @@ CuDNNConvolutionLayer::~CuDNNConvolutionLayer() { delete [] workspace_bwd_data_sizes_; delete [] workspace_bwd_filter_sizes_; - MemoryHandler::freeGPU(this->workspaceData); + gpu_memory::deallocate(this->workspaceData); + this->workspaceData = NULL; } INSTANTIATE_CLASS(CuDNNConvolutionLayer); diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index ca94a9f5633..7826ab1e505 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -3,6 +3,7 @@ #include "caffe/filler.hpp" #include "caffe/layer.hpp" +#include "caffe/util/gpu_memory.hpp" #include "caffe/util/im2col.hpp" #include "caffe/util/math_functions.hpp" #include "caffe/vision_layers.hpp" @@ -30,7 +31,7 @@ namespace caffe { // Forward through cuDNN in parallel over groups. for (int g = 0; g < this->group_; g++) { - MemoryHandler::mallocGPU(&workspaceData, workspace_fwd_sizes_[i]); + gpu_memory::allocate(&workspaceData, workspace_fwd_sizes_[i]); // Filters. CUDNN_CHECK(cudnnConvFwd(Caffe::cudnn_handle(), cudnn::dataType::one, @@ -45,7 +46,7 @@ namespace caffe { top_descs_[i], top_data + top_offset_ * g)); - MemoryHandler::freeGPU(workspaceData); + gpu_memory::deallocate(workspaceData); workspaceData = NULL; // Bias. if (this->bias_term_) { @@ -106,8 +107,8 @@ namespace caffe { // Gradient w.r.t. weights. if (this->param_propagate_down_[0]) { - MemoryHandler::mallocGPU(&workspaceData, - workspace_bwd_filter_sizes_[i]); + gpu_memory::allocate(&workspaceData, + workspace_bwd_filter_sizes_[i]); const Dtype* bottom_data = bottom[i]->gpu_data(); CUDNN_CHECK(cudnnConvBwdFilter(Caffe::cudnn_handle(), cudnn::dataType::one, @@ -122,7 +123,7 @@ namespace caffe { cudnn::dataType::one, filter_desc_, weight_diff + weight_offset_ * g)); - MemoryHandler::freeGPU(workspaceData); + gpu_memory::deallocate(workspaceData); workspaceData = NULL; } @@ -132,8 +133,8 @@ namespace caffe { weight = this->blobs_[0]->gpu_data(); } Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); - MemoryHandler::mallocGPU(&workspaceData, - workspace_bwd_data_sizes_[i]); + gpu_memory::allocate(&workspaceData, + workspace_bwd_data_sizes_[i]); CUDNN_CHECK(cudnnConvBwdData(Caffe::cudnn_handle(), cudnn::dataType::one, filter_desc_, @@ -146,7 +147,7 @@ namespace caffe { cudnn::dataType::zero, bottom_descs_[i], bottom_diff + bottom_offset_ * g)); - MemoryHandler::freeGPU(workspaceData); + gpu_memory::deallocate(workspaceData); workspaceData = NULL; } } diff --git a/src/caffe/layers/cudnn_lcn_layer.cu b/src/caffe/layers/cudnn_lcn_layer.cu index 50efbaec6a0..94cb017cbc8 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cu +++ b/src/caffe/layers/cudnn_lcn_layer.cu @@ -1,8 +1,8 @@ #ifdef USE_CUDNN #include - #include "caffe/filler.hpp" #include "caffe/layer.hpp" +#include "caffe/util/gpu_memory.hpp" #include "caffe/util/im2col.hpp" #include "caffe/util/math_functions.hpp" #include "caffe/vision_layers.hpp" @@ -15,8 +15,8 @@ void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - MemoryHandler::mallocGPU(&this->tempData1, this->tempDataSize); - MemoryHandler::mallocGPU(&this->tempData2, this->tempDataSize); + gpu_memory::allocate(&this->tempData1, this->tempDataSize); + gpu_memory::allocate(&this->tempData2, this->tempDataSize); CUDNN_CHECK(cudnnDivisiveNormalizationForward( Caffe::cudnn_handle(), norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, @@ -27,8 +27,8 @@ void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, cudnn::dataType::zero, top_desc_, top_data) ); - MemoryHandler::freeGPU(this->tempData1); - MemoryHandler::freeGPU(this->tempData2); + gpu_memory::deallocate(this->tempData1); + gpu_memory::deallocate(this->tempData2); } template @@ -39,8 +39,8 @@ void CuDNNLCNLayer::Backward_gpu(const vector*>& top, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - MemoryHandler::mallocGPU(&this->tempData1, this->tempDataSize); - MemoryHandler::mallocGPU(&this->tempData2, this->tempDataSize); + gpu_memory::allocate(&this->tempData1, this->tempDataSize); + gpu_memory::allocate(&this->tempData2, this->tempDataSize); CUDNN_CHECK(cudnnDivisiveNormalizationBackward( Caffe::cudnn_handle(), norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, @@ -52,8 +52,8 @@ void CuDNNLCNLayer::Backward_gpu(const vector*>& top, bottom_desc_, bottom_diff, NULL) ); - MemoryHandler::freeGPU(this->tempData1); - MemoryHandler::freeGPU(this->tempData2); + gpu_memory::deallocate(this->tempData1); + gpu_memory::deallocate(this->tempData2); } INSTANTIATE_LAYER_GPU_FUNCS(CuDNNLCNLayer); diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index 970e7191cca..c7e0f106ec4 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -15,6 +15,7 @@ #include "boost/thread.hpp" #include "caffe/caffe.hpp" #include "caffe/parallel.hpp" +#include "caffe/util/gpu_memory.hpp" namespace caffe { @@ -88,7 +89,7 @@ GPUParams::GPUParams(shared_ptr > root_solver, int device) CUDA_CHECK(cudaSetDevice(device)); buffer_device_ = device; // CUDA_CHECK(cudaMalloc(&data_, size_ * sizeof(Dtype))); - MemoryHandler::mallocGPU(reinterpret_cast(&data_), + gpu_memory::allocate(reinterpret_cast(&data_), size_ * sizeof(Dtype)); // Copy blob values @@ -97,7 +98,7 @@ GPUParams::GPUParams(shared_ptr > root_solver, int device) apply_buffers(net, data_, size_, copy); // CUDA_CHECK(cudaMalloc(&diff_, size_ * sizeof(Dtype))); - MemoryHandler::mallocGPU(reinterpret_cast(&diff_), + gpu_memory::allocate(reinterpret_cast(&diff_), size_ * sizeof(Dtype)); caffe_gpu_set(size_, Dtype(0), diff_); @@ -113,8 +114,8 @@ GPUParams::~GPUParams() { int initial_device; cudaGetDevice(&initial_device); cudaSetDevice(buffer_device_); - MemoryHandler::freeGPU(data_); - MemoryHandler::freeGPU(diff_); + gpu_memory::deallocate(data_); + gpu_memory::deallocate(diff_); data_ = NULL; diff_ = NULL; cudaSetDevice(initial_device); @@ -250,7 +251,7 @@ P2PSync::P2PSync(shared_ptr > root_solver, } // Allocate receiving buffer on parent CUDA_CHECK(cudaSetDevice(peer)); - MemoryHandler::mallocGPU(reinterpret_cast(&parent_grads_), + gpu_memory::allocate(reinterpret_cast(&parent_grads_), size_ * sizeof(Dtype)); CUDA_CHECK(cudaSetDevice(self)); } @@ -270,7 +271,7 @@ P2PSync::~P2PSync() { const int self = solver_->param().device_id(); const int peer = parent_->solver_->param().device_id(); CUDA_CHECK(cudaSetDevice(peer)); - MemoryHandler::freeGPU(parent_grads_); + gpu_memory::deallocate(parent_grads_); parent_grads_ = NULL; int access; cudaSetDevice(self); diff --git a/src/caffe/syncedmem.cpp b/src/caffe/syncedmem.cpp index 417cf9d0f7e..6bb2736cf11 100644 --- a/src/caffe/syncedmem.cpp +++ b/src/caffe/syncedmem.cpp @@ -2,6 +2,7 @@ #include "caffe/common.hpp" #include "caffe/syncedmem.hpp" +#include "caffe/util/gpu_memory.hpp" #include "caffe/util/math_functions.hpp" namespace caffe { @@ -18,7 +19,7 @@ SyncedMemory::~SyncedMemory() { if (gpu_device_ != -1) { CUDA_CHECK(cudaSetDevice(gpu_device_)); } - MemoryHandler::freeGPU(gpu_ptr_); + gpu_memory::deallocate(gpu_ptr_); cudaSetDevice(initial_device); } #endif // CPU_ONLY @@ -55,7 +56,7 @@ inline void SyncedMemory::to_gpu() { switch (head_) { case UNINITIALIZED: CUDA_CHECK(cudaGetDevice(&gpu_device_)); - MemoryHandler::mallocGPU(&gpu_ptr_, size_); + gpu_memory::allocate(&gpu_ptr_, size_); caffe_gpu_memset(size_, 0, gpu_ptr_); head_ = HEAD_AT_GPU; own_gpu_data_ = true; @@ -63,7 +64,7 @@ inline void SyncedMemory::to_gpu() { case HEAD_AT_CPU: if (gpu_ptr_ == NULL) { CUDA_CHECK(cudaGetDevice(&gpu_device_)); - MemoryHandler::mallocGPU(&gpu_ptr_, size_); + gpu_memory::allocate(&gpu_ptr_, size_); own_gpu_data_ = true; } caffe_gpu_memcpy(size_, cpu_ptr_, gpu_ptr_); @@ -111,7 +112,7 @@ void SyncedMemory::set_gpu_data(void* data) { if (gpu_device_ != -1) { CUDA_CHECK(cudaSetDevice(gpu_device_)); } - MemoryHandler::freeGPU(gpu_ptr_); + gpu_memory::deallocate(gpu_ptr_); cudaSetDevice(initial_device); } gpu_ptr_ = data; @@ -143,7 +144,7 @@ void SyncedMemory::async_gpu_push(const cudaStream_t& stream) { CHECK(head_ == HEAD_AT_CPU); if (gpu_ptr_ == NULL) { CUDA_CHECK(cudaGetDevice(&gpu_device_)); - MemoryHandler::mallocGPU(&gpu_ptr_, size_); + gpu_memory::allocate(&gpu_ptr_, size_); own_gpu_data_ = true; } const cudaMemcpyKind put = cudaMemcpyHostToDevice; diff --git a/src/caffe/test/test_caffe_main.cpp b/src/caffe/test/test_caffe_main.cpp index 39960c43500..1b7cd0b2265 100644 --- a/src/caffe/test/test_caffe_main.cpp +++ b/src/caffe/test/test_caffe_main.cpp @@ -3,6 +3,8 @@ #include #include "caffe/caffe.hpp" +#include "caffe/util/gpu_memory.hpp" + #include "caffe/test/test_caffe_main.hpp" namespace caffe { @@ -48,7 +50,7 @@ int main(int argc, char** argv) { cudaGetDevice(&device); cout << "Current device id: " << device << endl; cudaGetDeviceProperties(&CAFFE_TEST_CUDA_PROP, device); - caffe::MemoryHandlerActivator activator(devices); + caffe::gpu_memory::arena arena(devices); #endif // invoke the test. diff --git a/src/caffe/MemoryHandler.cpp b/src/caffe/util/gpu_memory.cpp similarity index 70% rename from src/caffe/MemoryHandler.cpp rename to src/caffe/util/gpu_memory.cpp index d8e423ec45b..c29d6fcde7a 100644 --- a/src/caffe/MemoryHandler.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -1,73 +1,97 @@ #include #include "caffe/common.hpp" -#include "caffe/MemoryHandler.hpp" +#include "caffe/util/gpu_memory.hpp" -#ifndef CPU_ONLY // CPU-only Caffe. - -#ifdef USE_CNMEM // CNMEM integration -#include -#endif - +#include "cnmem.h" namespace caffe { - MemoryHandler::PoolMode MemoryHandler::mode_ = MemoryHandler::NoPool; + gpu_memory::PoolMode gpu_memory::mode_ = gpu_memory::NoPool; - void MemoryHandler::mallocGPU(void **ptr, size_t size, cudaStream_t stream) { - CHECK((ptr) != NULL); +#ifdef CPU_ONLY // CPU-only Caffe. + void gpu_memory::init(const std::vector& gpus, + PoolMode m) {} + void gpu_memory::destroy() {} + + const char* gpu_memory::getPoolName() { + return "No GPU: CPU Only Memory"; + } +#else + void gpu_memory::init(const std::vector& gpus, + PoolMode m) { + if (gpus.size() <= 0) { + // should we report an error here ? + m = gpu_memory::NoPool; + } + + switch (m) { + case CnMemPool: + initCNMEM(gpus); + break; + case CubPool: + default: + break; + } + + std::cout << "gpu_memory initialized with " + << getPoolName() << std::endl; + } + + void gpu_memory::destroy() { switch (mode_) { case CnMemPool: - CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); + CNMEM_CHECK(cnmemFinalize()); break; case CubPool: default: - CUDA_CHECK(cudaMalloc(ptr, size)); break; } + mode_ = NoPool; } - void MemoryHandler::freeGPU(void *ptr, cudaStream_t stream) { - // allow for null pointer deallocation - if (!ptr) - return; + void gpu_memory::allocate(void **ptr, size_t size, cudaStream_t stream) { + CHECK((ptr) != NULL); switch (mode_) { case CnMemPool: - CNMEM_CHECK(cnmemFree(ptr, stream)); + CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); break; case CubPool: default: - CUDA_CHECK(cudaFree(ptr)); + CUDA_CHECK(cudaMalloc(ptr, size)); break; } } - void MemoryHandler::registerStream(cudaStream_t stream) { + void gpu_memory::deallocate(void *ptr, cudaStream_t stream) { + // allow for null pointer deallocation + if (!ptr) + return; switch (mode_) { case CnMemPool: - CNMEM_CHECK(cnmemRegisterStream(stream)); + CNMEM_CHECK(cnmemFree(ptr, stream)); break; case CubPool: default: + CUDA_CHECK(cudaFree(ptr)); break; } } - void MemoryHandler::destroy() { + void gpu_memory::registerStream(cudaStream_t stream) { switch (mode_) { case CnMemPool: - CNMEM_CHECK(cnmemFinalize()); + CNMEM_CHECK(cnmemRegisterStream(stream)); break; case CubPool: default: break; } - mode_ = NoPool; } - void MemoryHandler::initCNMEM(const std::vector& gpus) { + void gpu_memory::initCNMEM(const std::vector& gpus) { #ifdef USE_CNMEM cnmemDevice_t* devs = new cnmemDevice_t[gpus.size()]; int initial_device; @@ -89,27 +113,7 @@ namespace caffe { #endif } - void MemoryHandler::init(const std::vector& gpus, - PoolMode m) { - if (gpus.size() <= 0) { - // should we report an error here ? - m = MemoryHandler::NoPool; - } - - switch (m) { - case CnMemPool: - initCNMEM(gpus); - break; - case CubPool: - default: - break; - } - - std::cout << "MemoryHandler initialized with " - << getName() << std::endl; - } - - const char* MemoryHandler::getName() { + const char* gpu_memory::getPoolName() { switch (mode_) { case CnMemPool: return "CNMEM Pool"; @@ -120,7 +124,7 @@ namespace caffe { } } - void MemoryHandler::getInfo(size_t *free_mem, size_t *total_mem) { + void gpu_memory::getInfo(size_t *free_mem, size_t *total_mem) { switch (mode_) { case CnMemPool: CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); @@ -130,7 +134,8 @@ namespace caffe { CUDA_CHECK(cudaMemGetInfo(free_mem, total_mem)); } } +#endif // CPU_ONLY } // namespace caffe -#endif // CPU_ONLY + diff --git a/tools/caffe.cpp b/tools/caffe.cpp index 77c68b64d6a..b59995dd542 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -12,8 +12,10 @@ namespace bp = boost::python; #include "boost/algorithm/string.hpp" #include "caffe/caffe.hpp" +#include "caffe/util/gpu_memory.hpp" #include "caffe/util/signal_handler.h" + using caffe::Blob; using caffe::Caffe; using caffe::Net; @@ -24,7 +26,6 @@ using caffe::string; using caffe::Timer; using caffe::vector; using std::ostringstream; -using caffe::MemoryHandlerActivator; DEFINE_string(gpu, "", "Optional; run in GPU mode on given device IDs separated by ','." @@ -148,6 +149,7 @@ caffe::SolverAction::Enum GetRequestedAction( return caffe::SolverAction::NONE; } LOG(FATAL) << "Invalid signal effect \""<< flag_value << "\" was specified"; + return caffe::SolverAction::NONE; } // Train / Finetune a model. @@ -190,7 +192,7 @@ int train() { Caffe::set_solver_count(gpus.size()); } - MemoryHandlerActivator handler(gpus); + caffe::gpu_memory::arena arena(gpus); caffe::SignalHandler signal_handler( GetRequestedAction(FLAGS_sigint_effect), From d12b5ccb46913ebac87fd7c0e7e7ea99040513bd Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Mon, 19 Oct 2015 16:42:18 -0700 Subject: [PATCH 264/331] deleted submodule --- .gitmodules | 3 --- cnmem | 1 - 2 files changed, 4 deletions(-) delete mode 160000 cnmem diff --git a/.gitmodules b/.gitmodules index ee2f082e187..e69de29bb2d 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +0,0 @@ -[submodule "cnmem"] - path = cnmem - url = https://github.com/NVIDIA/cnmem.git diff --git a/cnmem b/cnmem deleted file mode 160000 index e817a7a2889..00000000000 --- a/cnmem +++ /dev/null @@ -1 +0,0 @@ -Subproject commit e817a7a2889389eaf934fe66a9744878b900acba From 6480847b61b0f004bfd69616cd82761a64711b61 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Mon, 19 Oct 2015 16:47:18 -0700 Subject: [PATCH 265/331] Squashed '.3rdparty/cnmem/' content from commit e817a7a git-subtree-dir: .3rdparty/cnmem git-subtree-split: e817a7a2889389eaf934fe66a9744878b900acba --- .gitignore | 2 + CMakeLists.txt | 45 ++ LICENSE | 26 + README.md | 56 ++ include/cnmem.h | 263 +++++++++ src/cnmem.cpp | 1287 +++++++++++++++++++++++++++++++++++++++++ tests/cnmem_tests.cpp | 1001 ++++++++++++++++++++++++++++++++ 7 files changed, 2680 insertions(+) create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100644 LICENSE create mode 100644 README.md create mode 100644 include/cnmem.h create mode 100644 src/cnmem.cpp create mode 100644 tests/cnmem_tests.cpp diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000000..e8ab68ab1c0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +# Ignore the build directory created to build the code +build diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 00000000000..e11d12f9ee3 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,45 @@ +# CMakeLists to build the cnmem library. +cmake_minimum_required(VERSION 2.8.8) +project(cnmem) + +# We need CUDA to build that library. +find_package(CUDA QUIET REQUIRED) +include_directories(${CUDA_INCLUDE_DIRS}) + +# Rules to build the cnmem library. +include_directories(include) +add_definitions(-DCNMEM_DLLEXPORT) +add_library(cnmem SHARED src/cnmem.cpp) +set_target_properties(cnmem PROPERTIES VERSION 1.0.0 SOVERSION 1) +target_link_libraries(cnmem LINK_PUBLIC ${CUDA_LIBRARIES}) +install(TARGETS cnmem RUNTIME DESTINATION bin ARCHIVE DESTINATION lib LIBRARY DESTINATION lib) +install(FILES include/cnmem.h DESTINATION include) + +# Add the tests. +if(WITH_TESTS) + + # Get Google tests. + find_package(GTest QUIET REQUIRED) + include_directories(${GTEST_INCLUDE_DIRS}) + + # Build the executable. + add_executable(cnmem_tests tests/cnmem_tests.cpp) + if(MSVC) + if(MSVC_VERSION GREATER 1700) # Visual Studio 11 or more. + add_definitions(-DUSE_CPP_11) + endif(MSVC_VERSION GREATER 1700) + endif(MSVC) + if(CMAKE_COMPILER_IS_GNUCC) + add_definitions(-std=c++11 -DUSE_CPP_11) + endif(CMAKE_COMPILER_IS_GNUCC) + target_link_libraries(cnmem_tests LINK_PUBLIC cnmem ${CUDA_LIBRARIES} ${GTEST_LIBRARIES} -lpthread) + install(TARGETS cnmem_tests RUNTIME DESTINATION bin) + + # On Windows, we copy the Google test DLL to the bin folder. + if(MSVC) + get_filename_component(gtest_dll_path ${GTEST_LIBRARIES} DIRECTORY) + install(FILES ${gtest_dll_path}/gtest.dll DESTINATION bin) + endif(MSVC) + +endif(WITH_TESTS) + diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000000..9f24f8bc1ab --- /dev/null +++ b/LICENSE @@ -0,0 +1,26 @@ +Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of NVIDIA CORPORATION nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/README.md b/README.md new file mode 100644 index 00000000000..9fcb35d50e8 --- /dev/null +++ b/README.md @@ -0,0 +1,56 @@ +# CNMeM Library + +Simple library to help the Deep Learning frameworks manage CUDA memory. + +CNMeM is not intended to be a general purpose memory management library. It was designed as a simple +tool for applications which work on a limited number of large memory buffers. + +CNMeM is mostly developed on Ubuntu Linux. It should support other operating systems as well. If you +encounter an issue with the library on other operating systems, please submit a bug (or a fix). + +# Prerequisites + +CNMeM relies on the CUDA toolkit. It uses C++ STL and the Pthread library on Linux. On Windows, it uses +the native Win32 threading library. The build system uses CMake. The unit tests are written using +Google tests (but are not mandatory). + +## CUDA + +The CUDA toolkit is required. We recommend using CUDA >= 7.0 even if earlier versions will work. +* Download from the [CUDA website](https://developer.nvidia.com/cuda-downloads) +* Follow the installation instructions +* Don't forget to set your path. For example: + * `CUDA_HOME=/usr/local/cuda` + * `LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH` + +# Build CNMeM + +## Grab the source + + % cd $HOME + % git clone https://github.com/NVIDIA/cnmem.git cnmem + +## Build CNMeM without the unit tests + + % cd cnmem + % mkdir build + % cd build + % cmake .. + % make + +## Build CNMeM with the unit tests + +To build the tests, you need to add an extra option to the cmake command. + + % cd cnmem + % mkdir build + % cd build + % cmake -DWITH_TESTS=True .. + % make + +## Link with CNMeM + +The source folder contains a header file 'include/cnmem.h' and the build directory contains the +library 'libcnmem.so', 'cnmem.lib/cnmem.dll' or 'libcnmem.dylib', depending on your operating +system. + diff --git a/include/cnmem.h b/include/cnmem.h new file mode 100644 index 00000000000..19fd2f84022 --- /dev/null +++ b/include/cnmem.h @@ -0,0 +1,263 @@ +/* ********************************************************************** + * Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * ********************************************************************** */ +#pragma once + +#ifdef __cplusplus +#include "cstdio" +#else +#include "stdio.h" +#endif +#include "cuda_runtime_api.h" + +#if defined(_MSC_VER) || defined(WIN32) +#ifdef CNMEM_DLLEXPORT +#define CNMEM_API __declspec(dllexport) +#else +#define CNMEM_API __declspec(dllimport) +#endif +#else +#ifdef CNMEM_DLLEXPORT +#define CNMEM_API __attribute__((visibility ("default"))) +#else +#define CNMEM_API +#endif +#endif + +#define CNMEM_VERSION 100 // It corresponds to 1.0.0 + +#ifdef __cplusplus +extern "C" { +#endif + +/* ********************************************************************************************* */ + +typedef enum +{ + CNMEM_STATUS_SUCCESS = 0, + CNMEM_STATUS_CUDA_ERROR, + CNMEM_STATUS_INVALID_ARGUMENT, + CNMEM_STATUS_NOT_INITIALIZED, + CNMEM_STATUS_OUT_OF_MEMORY, + CNMEM_STATUS_UNKNOWN_ERROR +} cnmemStatus_t; + +/* ********************************************************************************************* */ + +typedef enum +{ + CNMEM_FLAGS_DEFAULT = 0, /// Default flags. + CNMEM_FLAGS_CANNOT_GROW = 1, /// Prevent the manager from growing its memory consumption. + CNMEM_FLAGS_CANNOT_STEAL = 2, /// Prevent the manager from stealing memory. +} cnmemManagerFlags_t; + +/* ********************************************************************************************* */ + +typedef struct cnmemDevice_t_ +{ + /** The device number. */ + int device; + /** The size to allocate for that device. If 0, the implementation chooses the size. */ + size_t size; + /** The number of named streams associated with the device. The NULL stream is not counted. */ + int numStreams; + /** The streams associated with the device. It can be NULL. The NULL stream is managed. */ + cudaStream_t *streams; + /** The size reserved for each streams. It can be 0. */ + size_t *streamSizes; + +} cnmemDevice_t; + +/** + * \brief Initialize the library and allocate memory on the listed devices. + * + * For each device, an internal memory manager is created and the specified amount of memory is + * allocated (it is the size defined in device[i].size). For each, named stream an additional + * memory manager is created. Currently, it is implemented as a tree of memory managers: A root + * manager for the device and a list of children, one for each named stream. + * + * This function must be called before any other function in the library. It has to be called + * by a single thread since it is not thread-safe. + * + * \return + * CNMEM_STATUS_SUCCESS, if everything goes fine, + * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid, + * CNMEM_STATUS_OUT_OF_MEMORY, if the requested size exceeds the available memory, + * CNMEM_STATUS_CUDA_ERROR, if an error happens in a CUDA function. + */ +cnmemStatus_t CNMEM_API cnmemInit(int numDevices, const cnmemDevice_t *devices, unsigned flags); + +/** + * \brief Release all the allocated memory. + * + * This function must be called by a single thread and after all threads that called + * cnmemMalloc/cnmemFree have joined. This function is not thread-safe. + * + * \return + * CNMEM_STATUS_SUCCESS, if everything goes fine, + * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, + * CNMEM_STATUS_CUDA_ERROR, if an error happens in one of the CUDA functions. + */ +cnmemStatus_t CNMEM_API cnmemFinalize(); + +/** + * \brief Increase the internal reference counter of the context object. + * + * This function increases the internal reference counter of the library. The purpose of that + * reference counting mechanism is to give more control to the user over the lifetime of the + * library. It is useful with scoped memory allocation which may be destroyed in a final + * memory collection after the end of main(). That function is thread-safe. + * + * \return + * CNMEM_STATUS_SUCCESS, if everything goes fine, + * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, + */ +cnmemStatus_t CNMEM_API cnmemRetain(); + +/** + * \brief Decrease the internal reference counter of the context object. + * + * This function decreases the internal reference counter of the library. The purpose of that + * reference counting mechanism is to give more control to the user over the lifetime of the + * library. It is useful with scoped memory allocation which may be destroyed in a final + * memory collection after the end of main(). That function is thread-safe. + * + * You can use \c cnmemRelease to explicitly finalize the library. + * + * \return + * CNMEM_STATUS_SUCCESS, if everything goes fine, + * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, + */ +cnmemStatus_t CNMEM_API cnmemRelease(); + +/** + * \brief Add a new stream to the pool of managed streams on a device. + * + * This function registers a new stream into a device memory manager. It is thread-safe. + * + * \return + * CNMEM_STATUS_SUCCESS, if everything goes fine, + * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid, + */ +cnmemStatus_t CNMEM_API cnmemRegisterStream(cudaStream_t stream); + +/** + * \brief Allocate memory. + * + * This function allocates memory and initializes a pointer to device memory. If no memory + * is available, it returns a CNMEM_STATUS_OUT_OF_MEMORY error. This function is thread safe. + * + * The behavior of that function is the following: + * + * - If the stream is NULL, the root memory manager is asked to allocate a buffer of device + * memory. If there's a buffer of size larger or equal to the requested size in the list of + * free blocks, it is returned. If there's no such buffer but the manager is allowed to grow + * its memory usage (the CNMEM_FLAGS_CANNOT_GROW flag is not set), the memory manager calls + * cudaMalloc. If cudaMalloc fails due to no more available memory or the manager is not + * allowed to grow, the manager attempts to steal memory from one of its children (unless + * CNMEM_FLAGS_CANNOT_STEAL is set). If that attempt also fails, the manager returns + * CNMEM_STATUS_OUT_OF_MEMORY. + * + * - If the stream is a named stream, the initial request goes to the memory manager associated + * with that stream. If a free node is available in the lists of that manager, it is returned. + * Otherwise, the request is passed to the root node and works as if the request were made on + * the NULL stream. + * + * The calls to cudaMalloc are potentially costly and may induce GPU synchronizations. Also the + * mechanism to steal memory from the children induces GPU synchronizations (the manager has to + * make sure no kernel uses a given buffer before stealing it) and it the execution is + * sequential (in a multi-threaded context, the code is executed in a critical section inside + * the cnmem library - no need for the user to wrap cnmemMalloc with locks). + * + * \return + * CNMEM_STATUS_SUCCESS, if everything goes fine, + * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, + * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid. For example, ptr == 0, + * CNMEM_STATUS_OUT_OF_MEMORY, if there is not enough memory available, + * CNMEM_STATUS_CUDA_ERROR, if an error happens in one of the CUDA functions. + */ +cnmemStatus_t CNMEM_API cnmemMalloc(void **ptr, size_t size, cudaStream_t stream); + +/** + * \brief Release memory. + * + * This function releases memory and recycles a memory block in the manager. This function is + * thread safe. + * + * \return + * CNMEM_STATUS_SUCCESS, if everything goes fine, + * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, + * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid. For example, ptr == 0, + * CNMEM_STATUS_CUDA_ERROR, if an error happens in one of the CUDA functions. + */ +cnmemStatus_t CNMEM_API cnmemFree(void *ptr, cudaStream_t stream); + +/* ********************************************************************************************* */ +/* Utility functions. */ +/* ********************************************************************************************* */ + +/** + * \brief Returns the amount of memory managed by the memory manager associated with a stream. + * + * The pointers totalMem and freeMem must be valid. At the moment, this function has a comple- + * xity linear in the number of allocated blocks so do not call it in performance critical + * sections. + * + * \return + * CNMEM_STATUS_SUCCESS, if everything goes fine, + * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, + * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid, + * CNMEM_STATUS_CUDA_ERROR, if an error happens in one of the CUDA functions. + */ +cnmemStatus_t CNMEM_API cnmemMemGetInfo(size_t *freeMem, size_t *totalMem, cudaStream_t stream); + +/** + * \brief Print a list of nodes to a file. + * + * This function is intended to be used in case of complex scenarios to help understand the + * behaviour of the memory managers/application. It is thread safe. + * + * \return + * CNMEM_STATUS_SUCCESS, if everything goes fine, + * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, + * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid. For example, used_mem == 0 + * or free_mem == 0, + * CNMEM_STATUS_CUDA_ERROR, if an error happens in one of the CUDA functions. + */ +cnmemStatus_t CNMEM_API cnmemPrintMemoryState(FILE *file, cudaStream_t stream); + +/** + * \brief Converts a cnmemStatus_t value to a string. + */ +const char CNMEM_API * cnmemGetErrorString(cnmemStatus_t status); + +/* ********************************************************************************************* */ + +#ifdef __cplusplus +} // extern "C" +#endif + diff --git a/src/cnmem.cpp b/src/cnmem.cpp new file mode 100644 index 00000000000..f0bc54374ce --- /dev/null +++ b/src/cnmem.cpp @@ -0,0 +1,1287 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of NVIDIA CORPORATION nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +/////////////////////////////////////////////////////////////////////////////////////////////////// + +#include "cnmem.h" +#include +#include +#include + +#if !defined(WIN32) && defined(_MSC_VER) +#define WIN32 +#endif + +#ifdef WIN32 +#include +#else +#include +#endif + +#define CNMEM_GRANULARITY 512 + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +extern "C" const char* cnmemGetErrorString(cnmemStatus_t status) { + switch(status) { + case CNMEM_STATUS_SUCCESS: return "CNMEM_STATUS_SUCCESS"; + case CNMEM_STATUS_CUDA_ERROR: return "CNMEM_STATUS_CUDA_ERROR"; + case CNMEM_STATUS_INVALID_ARGUMENT: return "CNMEM_STATUS_INVALID_ARGUMENT"; + case CNMEM_STATUS_NOT_INITIALIZED: return "CNMEM_STATUS_NOT_INITIALIZED"; + case CNMEM_STATUS_OUT_OF_MEMORY: return "CNMEM_STATUS_OUT_OF_MEMORY"; + default: return "CNMEM_STATUS_UNKNOWN_ERROR"; + } +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +#if 0 +#ifdef WIN32 +#define CNMEM_DEBUG_ERROR(...) do { \ + fprintf(stderr, "Error at line: %d\n", __LINE__); \ + fprintf(stderr, __VA_ARGS__); \ +} while(0) +#else +#include +static inline void printBacktrace() { + void *stackBuffer[64]; + int numAddresses = backtrace((void**) &stackBuffer, 64); + char **addresses = backtrace_symbols(stackBuffer, numAddresses); + for( int i = 0 ; i < numAddresses ; ++i ) { + fprintf(stderr, "[%2d]: %s\n", i, addresses[i]); + } + free(addresses); +} +#define CNMEM_DEBUG_ERROR(...) do { \ + fprintf(stderr, "Error at line: %d\n", __LINE__); \ + fprintf(stderr, __VA_ARGS__); \ + fprintf(stderr, "Backtrace:\n"); \ + printBacktrace(); \ +} while(0) +#endif +#else +#define CNMEM_DEBUG_ERROR(...) +#endif + +#if 0 +#define CNMEM_DEBUG_INFO printf +#else +#define CNMEM_DEBUG_INFO(...) +#endif + +#if 0 // Enable/disable assertions +#include +#define CNMEM_ASSERT assert +#else +#define CNMEM_ASSERT(...) +#endif + +#define CNMEM_CHECK_TRUE(cond, error) do { \ + if( !(cond) ) { \ + CNMEM_DEBUG_ERROR("CNMEM_CHECK_TRUE evaluates to false\n"); \ + return error; \ + } \ +} while(0) + +#define CNMEM_CHECK(call) do { \ + cnmemStatus_t status = (call); \ + if( status != CNMEM_STATUS_SUCCESS ) { \ + CNMEM_DEBUG_ERROR("CNMEM_CHECK failed with status \"%s\"\n", \ + cnmemGetErrorString(status)); \ + return status; \ + } \ +} while(0) + +#define CNMEM_CHECK_OR_UNLOCK(call, mutex) do { \ + cnmemStatus_t status = (call); \ + if( status != CNMEM_STATUS_SUCCESS ) { \ + CNMEM_DEBUG_ERROR("CNMEM_CHECK_OR_UNLOCK failed with status \"%s\"\n", \ + cnmemGetErrorString(status)); \ + (mutex).unlock(); \ + return status; \ + } \ +} while(0) + +#define CNMEM_CHECK_CUDA(call) do { \ + cudaError_t cudaError = (call); \ + if( cudaError == cudaErrorMemoryAllocation ) { \ + CNMEM_DEBUG_ERROR("CNMEM_CHECK_CUDA failed with CUDA error \"%s\"\n", \ + cudaGetErrorString(cudaError)); \ + return CNMEM_STATUS_OUT_OF_MEMORY; \ + } \ + else if( cudaError != cudaSuccess ) { \ + CNMEM_DEBUG_ERROR("CNMEM_CHECK_CUDA failed with CUDA error \"%s\"\n", \ + cudaGetErrorString(cudaError)); \ + return CNMEM_STATUS_CUDA_ERROR; \ + } \ +} while(0) + +#define CNMEM_CHECK_CUDA_OR_UNLOCK(call, mutex) do { \ + cudaError_t cudaError = (call); \ + if( cudaError == cudaErrorMemoryAllocation ) { \ + CNMEM_DEBUG_ERROR("CNMEM_CHECK_CUDA_OR_UNLOCK failed with CUDA error \"%s\"\n", \ + cudaGetErrorString(cudaError)); \ + (mutex).unlock(); \ + return CNMEM_STATUS_OUT_OF_MEMORY; \ + } \ + else if( cudaError != cudaSuccess ) { \ + CNMEM_DEBUG_ERROR("CNMEM_CHECK_CUDA_OR_UNLOCK failed with CUDA error \"%s\"\n", \ + cudaGetErrorString(cudaError)); \ + (mutex).unlock(); \ + return CNMEM_STATUS_CUDA_ERROR; \ + } \ +} while(0) + +#ifdef WIN32 +#define CNMEM_CHECK_WIN32(call, error_code) do { \ + SetLastError(0); /* Clean the flag. */ \ + call; \ + DWORD status = GetLastError(); \ + if( status ) \ + return error_code; \ +} while(0) +#else +#define CNMEM_CHECK_PTHREAD(call, error_code) do { \ + int status = call; \ + if( status ) { \ + CNMEM_DEBUG_ERROR("CNMEM_CHECK_PTHREAD failed with status %d\n", status); \ + return error_code; \ + } \ +} while(0) +#endif + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +namespace cnmem { + +static inline std::size_t ceilInt(std::size_t m, std::size_t n) { + CNMEM_ASSERT(n > 0); + return (m + n-1) / n * n; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class Mutex { +#ifdef WIN32 + mutable CRITICAL_SECTION mCriticalSection; +#else + pthread_mutex_t mMutex; +#endif + +public: + /// Initialize the mutex. + cnmemStatus_t initialize(); + /// Finalize the mutex. + cnmemStatus_t finalize(); + /// Lock the mutex. + cnmemStatus_t lock() const; + /// Unlock the mutex. + cnmemStatus_t unlock() const; +}; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Mutex::initialize() { +#ifdef WIN32 + CNMEM_CHECK_WIN32(InitializeCriticalSection((CRITICAL_SECTION*) &mCriticalSection), CNMEM_STATUS_UNKNOWN_ERROR); +#else +#if 0 + pthread_mutexattr_t attr; + CNMEM_CHECK_PTHREAD(pthread_mutexattr_init(&attr), CNMEM_STATUS_UNKNOWN_ERROR); + CNMEM_CHECK_PTHREAD(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE), CNMEM_STATUS_UNKNOWN_ERROR); + CNMEM_CHECK_PTHREAD(pthread_mutex_init(&mMutex, &attr), CNMEM_STATUS_UNKNOWN_ERROR); +#else + CNMEM_CHECK_PTHREAD(pthread_mutex_init(&mMutex, NULL), CNMEM_STATUS_UNKNOWN_ERROR); +#endif +#endif + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Mutex::finalize() { +#ifdef WIN32 + CNMEM_CHECK_WIN32(DeleteCriticalSection((CRITICAL_SECTION*) &mCriticalSection), CNMEM_STATUS_UNKNOWN_ERROR); +#else + CNMEM_CHECK_PTHREAD(pthread_mutex_destroy(&mMutex), CNMEM_STATUS_UNKNOWN_ERROR); +#endif + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Mutex::lock() const { +#ifdef WIN32 + CNMEM_CHECK_WIN32(EnterCriticalSection(&mCriticalSection), CNMEM_STATUS_UNKNOWN_ERROR); +#else + CNMEM_CHECK_PTHREAD(pthread_mutex_lock((pthread_mutex_t*) &mMutex), CNMEM_STATUS_UNKNOWN_ERROR); +#endif + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Mutex::unlock() const { +#ifdef WIN32 + CNMEM_CHECK_WIN32(LeaveCriticalSection(&mCriticalSection), CNMEM_STATUS_UNKNOWN_ERROR); +#else + CNMEM_CHECK_PTHREAD(pthread_mutex_unlock((pthread_mutex_t*) &mMutex), CNMEM_STATUS_UNKNOWN_ERROR); +#endif + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class Block { + /// The pointer to the memory region on the device. + char *mData; + /// The size of the memory buffer. + std::size_t mSize; + /// The prev/next blocks in the linked list of blocks. + Block *mNext; + /// Is it a head node (i.e. a node obtained from parent->allocate or cudaMalloc). + bool mIsHead; + +public: + /// Create a block. + Block(char *data, std::size_t size, Block *next, bool isHead) + : mData(data) + , mSize(size) + , mNext(next) + , mIsHead(isHead) { + } + + /// The data. + inline const char* getData() const { return mData; } + /// The data (mutable). + inline char* getData() { return mData; } + + /// The size of the block. + inline std::size_t getSize() const { return mSize; } + + /// The next block in the linked list. + inline const Block* getNext() const { return mNext; } + /// The next block in the linked list (mutable). + inline Block* getNext() { return mNext; } + + /// Is it a head block. + inline bool isHead() const { return mIsHead; } + + /// Change the next block. + inline void setNext(Block *next) { mNext = next; } + /// Change the size of the block. + inline void setSize(std::size_t size) { mSize = size; } + /// Set the head flag. + inline void setHeadFlag(bool isHead) { mIsHead = isHead; } +}; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class Manager { + + /// The parent manager. + Manager *mParent; + /// The children managers. + std::vector mChildren; + /// The GPU device where the memory is allocated. + int mDevice; + /// The stream this manager is associated with. It could be NULL. + cudaStream_t mStream; + /// Is the stream blocking? + bool mIsStreamBlocking; + /// The list of used blocks. + Block *mUsedBlocks; + /// The list of free blocks. + Block *mFreeBlocks; + /// The managed memory size. + std::size_t mSize; + /// The flags. + unsigned mFlags; + /// To support multi-threading. Each manager has its own mutex. + Mutex mMutex; + +public: + /// Create an unitialized manager. + Manager(); + /// Dtor. + ~Manager(); + + /// Allocate a block of memory. + cnmemStatus_t allocate(void *&ptr, std::size_t size, bool isBlocking = true); + /// Release a block of memory. + cnmemStatus_t release(void *ptr); + /// Release memory. It returns true if we have no memory leak. + cnmemStatus_t releaseAllUnsafe(); + /// Reserve memory for a manager. + cnmemStatus_t reserve(std::size_t size); + /// Steal memory from another manager. + cnmemStatus_t stealUnsafe(void *&ptr, std::size_t size); + + /// Print the full memory state. + cnmemStatus_t printMemoryState(FILE *file) const; + + /// The amount of used memory. + inline cnmemStatus_t getUsedMemoryUnsafe(std::size_t &usedMemory) const { + return getMemoryUnsafe(usedMemory, mUsedBlocks); + } + /// The amount of used memory. + inline cnmemStatus_t getFreeMemoryUnsafe(std::size_t &freeMemory) const { + return getMemoryUnsafe(freeMemory, mFreeBlocks); + } + + /// Get a specific child based on the stream id. + cnmemStatus_t getChildFromStream(Manager *&manager, cudaStream_t stream) const; + /// Get a specific child based on the stream id. + cnmemStatus_t getChild(Manager *&manager, std::size_t i) const; + /// Add a new child. + cnmemStatus_t addChild(Manager *manager); + /// The number of children. + cnmemStatus_t getNumChildren(std::size_t &numChildren) const; + + /// The associated device. + inline int getDevice() const { return mDevice; } + /// The flags. + inline unsigned getFlags() const { return mFlags; } + /// Get the mutex. + inline const Mutex* getMutex() const { return &mMutex; } + /// The size allocated to that manager. + inline std::size_t getSize() const { return mSize; } + /// The CUDA stream. + inline cudaStream_t getStream() const { return mStream; } + + /// Define the parent. + inline void setParent(Manager *parent) { mParent = parent; } + /// Define the device. + inline void setDevice(int device) { mDevice = device; } + /// Define the stream. + inline cnmemStatus_t setStream(cudaStream_t stream) { + mStream = stream; +#ifdef CUDA_API_PER_THREAD_DEFAULT_STREAM + mIsStreamBlocking = false; +#elif CUDART_VERSION < 5050 + mIsStreamBlocking = true; +#else + unsigned flags = 0; + CNMEM_CHECK_CUDA(cudaStreamGetFlags(mStream, &flags)); + mIsStreamBlocking = !mStream || !(flags & cudaStreamNonBlocking); +#endif + return CNMEM_STATUS_SUCCESS; + } + /// Define the flags. + inline void setFlags(unsigned flags) { mFlags = flags; } + +private: + /// The member functions below which are marked "Unsafe" are not thread-safe when called on a + /// same Manager object. Make sure they are called by a single thread in that case. + + /// Allocate a new block and add it to the free list. + cnmemStatus_t allocateBlockUnsafe(Block *&curr, Block *&prev, std::size_t size); + /// Release a block from the active list. + cnmemStatus_t releaseBlockUnsafe(Block *curr, Block *prev); + /// Find the best free node based on the size. + cnmemStatus_t findBestBlockUnsafe(Block *&curr, Block *&prev, std::size_t size); + /// Extract a node from the list of free blocks. + cnmemStatus_t extractBlockUnsafe(Block *curr, Block *prev, std::size_t size, bool stolen); + + /// Give a free block from that manager. + cnmemStatus_t giveBlockUnsafe(void *&data, std::size_t &dataSize, std::size_t size); + /// Steal a block from another manager. + cnmemStatus_t stealBlockUnsafe(void *&data, std::size_t &dataSize, std::size_t size); + + /// The memory consumption of a list. + cnmemStatus_t getMemoryUnsafe(std::size_t &memSize, const Block *head) const; + /// Print an internal linked list. + cnmemStatus_t printListUnsafe(FILE *file, const char *name, const Block *head) const; +}; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +Manager::Manager() + : mParent(NULL) + , mChildren() + , mDevice(-1) + , mStream(NULL) + , mIsStreamBlocking(false) + , mUsedBlocks(NULL) + , mFreeBlocks(NULL) + , mSize(0) + , mFlags(CNMEM_FLAGS_DEFAULT) + , mMutex() { + + mMutex.initialize(); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +Manager::~Manager() { + if( mDevice == -1 || cudaSetDevice(mDevice) != cudaSuccess ) { // Invalid device, skip it. + return; + } + releaseAllUnsafe(); + mMutex.finalize(); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::addChild(Manager *manager) { + CNMEM_CHECK(mMutex.lock()); + mChildren.push_back(manager); + CNMEM_CHECK(mMutex.unlock()); + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::allocate(void *&ptr, std::size_t size, bool isBlocking) { + CNMEM_CHECK(mMutex.lock()); + + // If the client is not blocking, we have to explicitly synchronize before giving one buffer. + if( !isBlocking ) { + CNMEM_CHECK_CUDA_OR_UNLOCK(cudaStreamSynchronize(mStream), mMutex); + } + + // Find the best fit. + Block *best = NULL, *prev = NULL; + CNMEM_CHECK_OR_UNLOCK(findBestBlockUnsafe(best, prev, size), mMutex); + + // If there's no block left in the list of free blocks (with a sufficient size). Request a new block. + if( best == NULL && !(mFlags & CNMEM_FLAGS_CANNOT_GROW) ) { + CNMEM_CHECK_OR_UNLOCK(allocateBlockUnsafe(best, prev, size), mMutex); + } + + // Make sure we do have a block or quit. + if( !best ) { + ptr = NULL; + CNMEM_CHECK(mMutex.unlock()); + return CNMEM_STATUS_OUT_OF_MEMORY; + } + + // Split the free block if needed. + CNMEM_CHECK_OR_UNLOCK(extractBlockUnsafe(best, prev, size, false), mMutex); + + // Push the node to the list of used nodes. + best->setNext(mUsedBlocks); + mUsedBlocks = best; + + // Return the new pointer into memory. + ptr = mUsedBlocks->getData(); + CNMEM_CHECK(mMutex.unlock()); + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::allocateBlockUnsafe(Block *&curr, Block *&prev, std::size_t size) { + // Reset the outputs. + curr = prev = NULL; + + // Try to allocate data from the parent or the device. + void *data = NULL; + if( mParent ) { + CNMEM_CHECK(mParent->allocate(data, size, mIsStreamBlocking)); + } + else { + CNMEM_DEBUG_INFO("cudaMalloc(%lu)\n", size); + CNMEM_CHECK_CUDA(cudaMalloc(&data, size)); + CNMEM_DEBUG_INFO(">> returned address=0x%016lx\n", (size_t) data); + } + + // If it failed, there's an unexpected issue. + CNMEM_ASSERT(data); + + // We have data, we now need to add it to the list of free nodes. We keep the list sorted. + Block *next = mFreeBlocks; + for( ; next && next->getData() < data ; next = next->getNext() ) { + prev = next; + } + curr = new Block((char*) data, size, next, true); + if( !curr ) { + return CNMEM_STATUS_OUT_OF_MEMORY; + } + if( prev ) { + prev->setNext(curr); + } + else { + mFreeBlocks = curr; + } + + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::extractBlockUnsafe(Block *curr, Block *prev, std::size_t size, bool stolen) { + // We have two cases: 1/ It is the right size so we keep it or 2/ it is too large and we split the node. + Block *next; + if( curr->getSize() == size ) { + next = curr->getNext(); + } + else { + std::size_t remaining = curr->getSize()-size; + Block *newBlock = new Block(curr->getData() + size, remaining, curr->getNext(), stolen); + if( !newBlock ) { + return CNMEM_STATUS_OUT_OF_MEMORY; + } + next = newBlock; + curr->setSize(size); + } + + // Redo the "branching" in the nodes. + if( prev ) { + prev->setNext(next); + } + else { + mFreeBlocks = next; + } + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::findBestBlockUnsafe(Block *&best, Block *&prev, std::size_t size) { + best = NULL, prev = NULL; + for( Block *temp = mFreeBlocks, *tempPrev = NULL ; temp ; temp = temp->getNext() ) { + if( temp->getSize() >= size && (!best || temp->getSize() < best->getSize()) ) { + best = temp; + prev = tempPrev; + } + tempPrev = temp; + } + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::getChildFromStream(Manager *&manager, cudaStream_t stream) const { + CNMEM_CHECK(mMutex.lock()); + std::size_t i = 0, numChildren = mChildren.size(); + for( ; i < numChildren ; ++i ) { + if( mChildren[i]->mStream == stream ) { + manager = mChildren[i]; + break; + } + } + CNMEM_CHECK(mMutex.unlock()); + return i < numChildren ? CNMEM_STATUS_SUCCESS : CNMEM_STATUS_INVALID_ARGUMENT; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::getChild(Manager *&manager, std::size_t i) const { + CNMEM_CHECK(mMutex.lock()); + if( i >= mChildren.size() ) { + CNMEM_CHECK(mMutex.unlock()); + return CNMEM_STATUS_INVALID_ARGUMENT; + } + manager = mChildren[i]; + + CNMEM_CHECK(mMutex.unlock()); + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::getMemoryUnsafe(std::size_t &size, const Block *head) const { + size = 0; + for( Block *curr = (Block*) head ; curr ; curr = curr->getNext() ) { + size += curr->getSize(); + } + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +#if 0 +cnmemStatus_t Manager::getMemory(std::size_t &size, const Block *head) const { + CNMEM_CHECK(mMutex.lock()); + CNMEM_CHECK_OR_UNLOCK(getMemoryUnsafe(size, head)); + CNMEM_CHECK(mMutex.unlock()); + return status; +} +#endif + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::getNumChildren(std::size_t &numChildren) const { + CNMEM_CHECK(mMutex.lock()); + numChildren = mChildren.size(); + CNMEM_CHECK(mMutex.unlock()); + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::giveBlockUnsafe(void *&blockData, std::size_t &blockSize, std::size_t size) { + // Make sure the block is not in use any more. It could be too coarse grain and we may change + // it in the future. + CNMEM_CHECK_CUDA(cudaStreamSynchronize(mStream)); + + // Init the returned values to 0. + blockData = NULL; + blockSize = 0; + + // Find the best node to steal and reserve it. + Block *best = NULL, *prev = NULL; + CNMEM_CHECK(findBestBlockUnsafe(best, prev, size)); + if( !best ) { + return CNMEM_STATUS_OUT_OF_MEMORY; + } + CNMEM_CHECK(extractBlockUnsafe(best, prev, size, true)); + blockData = best->getData(); + blockSize = best->getSize(); + + // Release the memory used by that block. + delete best; + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::printListUnsafe(FILE *file, const char *name, const Block *head) const { + std::size_t size = 0; + for( Block *curr = (Block*) head; curr; curr = curr->getNext() ) { + size += curr->getSize(); + } + fprintf(file, "| list=\"%s\", size=%lu\n", name, size); + for( Block *curr = (Block*) head ; curr ; curr = curr->getNext() ) { + fprintf(file, "| | node=0x%016lx, data=0x%016lx, size=%lu, next=0x%016lx, head=%2lu\n", + (std::size_t) curr, + (std::size_t) curr->getData(), + (std::size_t) curr->getSize(), + (std::size_t) curr->getNext(), + (std::size_t) curr->isHead ()); + } + fprintf(file, "|\n"); + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::printMemoryState(FILE *file) const { + CNMEM_CHECK(mMutex.lock()); + std::size_t streamCode = (std::size_t) mStream; + std::size_t usedMemory, freeMemory; + CNMEM_CHECK_OR_UNLOCK(getUsedMemoryUnsafe(usedMemory), mMutex); + CNMEM_CHECK_OR_UNLOCK(getFreeMemoryUnsafe(freeMemory), mMutex); + + fprintf(file, ">> [%s] device=%d, stream=0x%016lx, used=%luB, free=%luB\n", + mParent ? "child" : "root", + mDevice, + streamCode, + usedMemory, + freeMemory); + CNMEM_CHECK_OR_UNLOCK(printListUnsafe(file, "used", mUsedBlocks), mMutex); + CNMEM_CHECK_OR_UNLOCK(printListUnsafe(file, "free", mFreeBlocks), mMutex); + fprintf(file, "\n"); + CNMEM_CHECK(mMutex.unlock()); + + if( mParent ) { + CNMEM_CHECK(mParent->printMemoryState(file)); + } + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::release(void *ptr) { + // Skip if ptr is NULL. + if( ptr == NULL ) { + return CNMEM_STATUS_SUCCESS; + } + + // Lock to make sure only one thread execute that fragment of code. + CNMEM_CHECK(mMutex.lock()); + + // Find the node in the list of used blocks. + Block *curr = mUsedBlocks, *prev = NULL; + for( ; curr && curr->getData() != ptr ; curr = curr->getNext() ) { + prev = curr; + } + + // Make sure we have found a node. + if( curr == NULL ) { + CNMEM_CHECK(mMutex.unlock()); + return CNMEM_STATUS_INVALID_ARGUMENT; + } + + // We have the node so release it. + cnmemStatus_t result = releaseBlockUnsafe(curr, prev); + CNMEM_CHECK(mMutex.unlock()); + return result; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::releaseAllUnsafe() { + // Destroy the children if any. + for( std::size_t i = 0; i < mChildren.size(); ++i ) { + Manager *child = mChildren[i]; + CNMEM_CHECK(child->releaseAllUnsafe()); + delete child; + } + mChildren.clear(); + + // Destroy used blocks. It's a kind of panic mode to avoid leaks. NOTE: Do that only with roots!!! + if( !mParent ) { + while( mUsedBlocks ) { + CNMEM_CHECK(releaseBlockUnsafe(mUsedBlocks, NULL)); + } + } + + // We should be having only free blocks that are head blocks. Release those blocks. + while( mFreeBlocks ) { + if( mParent ) { + CNMEM_CHECK(mParent->release(mFreeBlocks->getData())); + } + else if( mFreeBlocks->isHead() ) { + void *data = mFreeBlocks->getData(); + CNMEM_DEBUG_INFO("cudaFree(%lu, 0x%016lx)\n", mFreeBlocks->getSize(), (size_t) data); + CNMEM_CHECK_CUDA(cudaFree(data)); + CNMEM_DEBUG_INFO(">> success\n"); + } + Block *block = mFreeBlocks; + mFreeBlocks = mFreeBlocks->getNext(); + delete block; + } + + // We shouldn't have any used block left. Or, it means the user is causing memory leaks! + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::releaseBlockUnsafe(Block *curr, Block *prev) { + // The current node cannot be NULL! + CNMEM_ASSERT(curr != NULL); + + // Change the connection of the node. + if( prev ) { + prev->setNext(curr->getNext()); + } + else { + mUsedBlocks = curr->getNext(); + } + + // Find the location where this block should be added to the free list. + prev = NULL; + Block *iter = mFreeBlocks; + for( ; iter && iter->getData() < curr->getData() ; iter = iter->getNext() ) { + prev = iter; + } + + // Keep track of the successor of pred. We may lose track of it in the following "else". + Block *next = prev ? prev->getNext() : mFreeBlocks; + + // We first check if we can merge the block with its predecessor in the list and curr can be merged. + if( prev && prev->getData() + prev->getSize() == curr->getData() && !curr->isHead() ) { + prev->setSize(prev->getSize() + curr->getSize()); + delete curr; + curr = prev; + } + else if( prev ) { + prev->setNext(curr); + } + else { + mFreeBlocks = curr; + } + + // Check if we can merge curr and next. We can't merge over "cudaMalloc" boundaries. + if( next && curr->getData() + curr->getSize() == next->getData() && !next->isHead() ) { + curr->setSize(curr->getSize() + next->getSize()); + curr->setNext(next->getNext()); + delete next; + } + else { + curr->setNext(next); + } + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::reserve(std::size_t size) { + CNMEM_CHECK(mMutex.lock()); + Block *curr, *prev; + CNMEM_CHECK_OR_UNLOCK(allocateBlockUnsafe(curr, prev, size), mMutex); + mSize = size; + CNMEM_CHECK(mMutex.unlock()); + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::stealUnsafe(void *&stolen, std::size_t size) { + // If we cannot steal, don't even try. + if( mFlags & CNMEM_FLAGS_CANNOT_STEAL ) { + stolen = NULL; + return CNMEM_STATUS_INVALID_ARGUMENT; + } + + // The stolen block. + void *data = NULL; std::size_t dataSize = 0; + if( !mChildren.empty() ) { + CNMEM_CHECK(stealBlockUnsafe(data, dataSize, size)); + } + else if( mParent ) { + CNMEM_CHECK(mParent->stealBlockUnsafe(data, dataSize, size)); + } + + // Make sure we do have a block of memory or quit. + if( !data ) { + stolen = NULL; + return CNMEM_STATUS_OUT_OF_MEMORY; + } + + // Push the block in the used list. + mUsedBlocks = new Block((char*) data, dataSize, mUsedBlocks, true); + if( !mUsedBlocks ) { + return CNMEM_STATUS_OUT_OF_MEMORY; + } + + // Return the new pointer into memory. + stolen = data; + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Manager::stealBlockUnsafe(void *&data, std::size_t &dataSize, ::size_t size) { + // No block found and no room to grow. Try to steal from a children (if we have any). + data = NULL; + for( std::size_t i = 0 ; !data && i < mChildren.size() ; ++i ) { + Manager *child = mChildren[i]; + if( child->giveBlockUnsafe(data, dataSize, size) == CNMEM_STATUS_SUCCESS ) { + break; + } + } + + // If no memory space found, simply return NULL. We have failed to allocate. Quit miserably. + if( !data ) { + return CNMEM_STATUS_OUT_OF_MEMORY; + } + + // We have got a node from a children. We need to update our "used" list before we can do + // anything with it. + Block *curr = mUsedBlocks, *prev = NULL; + for( ; curr ; curr = curr->getNext() ) { + if( curr->getData() <= data && data < curr->getData()+curr->getSize() ) { + break; + } + prev = curr; + } + + // Curr points to the node which contains that memory region. + CNMEM_ASSERT(curr); + + // If it is exactly the same memory region, we are done!!! + if( curr->getData() == data && curr->getSize() == dataSize ) { + return CNMEM_STATUS_SUCCESS; + } + + // Track the blocks before and after curr. + Block *next = curr->getNext(); + + // We may have up to 3 blocks. + std::size_t sizeBefore = (std::size_t) ((char*) data - curr->getData()); + std::size_t sizeAfter = (curr->getSize() - sizeBefore - dataSize); + + // The resulting block. + Block *result = curr; + + // If we have no space between curr->getData and block->getData. + if( sizeBefore == 0 ) { + curr->setSize(dataSize); + } + else { + curr->setSize(sizeBefore); + Block *block = new Block((char*) data, dataSize, next, false); + if( !block ) { + return CNMEM_STATUS_OUT_OF_MEMORY; + } + curr->setNext(block); + curr = block; + data = (char*) data + dataSize; + dataSize = sizeAfter; + result = block; + } + + // We have space at the end so we may need to add a new node. + if( sizeAfter > 0 ) { + Block *block = new Block(curr->getData() + curr->getSize(), sizeAfter, next, false); + if( !block ) { + return CNMEM_STATUS_OUT_OF_MEMORY; + } + curr->setNext(block); + curr = block; + } + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class Context { + /// Use a magic number to specify that the context is valid. + enum { CTX_VALID = 0x1f5632a3 }; + + /// The reference counting mechanism. + int mRefCount; + /// The mutex to increase/decrease the reference counter. TODO: Use atomics. + Mutex mMutex; + /// The memory managers. + std::vector mManagers; + /// The global context. + static Context *sCtx; + /// Use a magic number to specify that the context was created. + static int sCtxCheck; + +public: + /// Ctor. + Context() : mRefCount(1) { mMutex.initialize(); } + /// Dtor. + ~Context(); + /// Get the managers. + inline std::vector& getManagers() { return mManagers; } + /// Get a single manager associated with a device. + inline Manager& getManager(int i) { return mManagers[i]; } + + /// Create the global context. + static cnmemStatus_t create(); + /// Check that the context was created. + static inline bool check() { return sCtxCheck == CTX_VALID && sCtx; } + /// Get the global context. + static Context* get(); + /// Retain. + static cnmemStatus_t retain(); + /// Release. + static cnmemStatus_t release(); +}; + +Context *Context::sCtx; +int Context::sCtxCheck; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +Context::~Context() { + int oldDevice; + cudaGetDevice(&oldDevice); + for( std::size_t i = 0 ; i < mManagers.size() ; ++i ) { + if( mManagers[i].getDevice() != -1 ) { // Skip invalid managers. + cudaSetDevice(mManagers[i].getDevice()); + mManagers[i].releaseAllUnsafe(); + } + } + mManagers.clear(); + mMutex.finalize(); + cudaSetDevice(oldDevice); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Context::create() { + sCtx = new Context; + sCtxCheck = CTX_VALID; + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +Context* Context::get() { + CNMEM_ASSERT(Context::check()); + return Context::sCtx; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Context::retain() { + CNMEM_CHECK(sCtx->mMutex.lock()); + sCtx->mRefCount++; + CNMEM_CHECK(sCtx->mMutex.unlock()); + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t Context::release() { + CNMEM_CHECK(sCtx->mMutex.lock()); + int refCount = --sCtx->mRefCount; + CNMEM_CHECK(sCtx->mMutex.unlock()); + + if( refCount == 0 ) { // Kill the context. + delete sCtx; + Context::sCtx = NULL; + Context::sCtxCheck = 0; + } + return CNMEM_STATUS_SUCCESS; +} + +} // namespace cnmem + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +extern "C" { + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t cnmemInit(int numDevices, const cnmemDevice_t *devices, unsigned flags) { + // Make sure we have at least one device declared. + CNMEM_CHECK_TRUE(numDevices > 0, CNMEM_STATUS_INVALID_ARGUMENT); + + // Find the largest ID of the device. + int maxDevice = 0; + for( int i = 0 ; i < numDevices ; ++i ) { + if( devices[i].device > maxDevice ) { + maxDevice = devices[i].device; + } + } + + // Create the global context. + cnmem::Context::create(); + cnmem::Context *ctx = cnmem::Context::get(); + + // Allocate enough managers. + CNMEM_CHECK_TRUE(maxDevice >= 0, CNMEM_STATUS_INVALID_ARGUMENT); + std::vector &managers = ctx->getManagers(); + managers.resize(maxDevice+1); + + // Create a root manager for each device and create the children. + int oldDevice; + CNMEM_CHECK_CUDA(cudaGetDevice(&oldDevice)); + for( int i = 0 ; i < numDevices ; ++i ) { + CNMEM_CHECK_CUDA(cudaSetDevice(devices[i].device)); + std::size_t size = devices[i].size; + if( size == 0 ) { + cudaDeviceProp props; + CNMEM_CHECK_CUDA(cudaGetDeviceProperties(&props, devices[i].device)); + size = props.totalGlobalMem / 2; + } + CNMEM_CHECK_TRUE(size > 0, CNMEM_STATUS_INVALID_ARGUMENT); + + cnmem::Manager &manager = ctx->getManager(devices[i].device); + manager.setDevice(devices[i].device); + manager.setFlags(flags); + + size = cnmem::ceilInt(size, CNMEM_GRANULARITY); + CNMEM_CHECK(manager.reserve(size)); + + for( int j = 0 ; j < devices[i].numStreams ; ++j ) { + cnmem::Manager *child = new cnmem::Manager; + child->setParent(&manager); + child->setDevice(devices[i].device); + child->setStream(devices[i].streams[j]); + child->setFlags(flags & ~CNMEM_FLAGS_CANNOT_GROW); + if( devices[i].streamSizes && devices[i].streamSizes[j] > 0 ) { + CNMEM_CHECK(child->reserve(devices[i].streamSizes[j])); + } + CNMEM_CHECK(manager.addChild(child)); + } + } + CNMEM_CHECK_CUDA(cudaSetDevice(oldDevice)); + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t cnmemFinalize() { + CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); + return cnmem::Context::release(); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t cnmemRetain() { + CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); + return cnmem::Context::retain(); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t cnmemRelease() { + CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); + return cnmem::Context::release(); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t cnmemRegisterStream(cudaStream_t stream) { + CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); + CNMEM_CHECK_TRUE(stream, CNMEM_STATUS_INVALID_ARGUMENT); + + int device; + CNMEM_CHECK_CUDA(cudaGetDevice(&device)); + + cnmem::Manager &root = cnmem::Context::get()->getManager(device); + cnmem::Manager *child = new cnmem::Manager; + child->setParent(&root); + child->setDevice(device); + child->setStream(stream); + child->setFlags(root.getFlags() & ~CNMEM_FLAGS_CANNOT_GROW); + root.addChild(child); + + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t cnmemMalloc(void **ptr, std::size_t size, cudaStream_t stream) { + CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); + if( !ptr && !size ) { + return CNMEM_STATUS_SUCCESS; + } + else if( !size ) { + ptr[0] = NULL; + return CNMEM_STATUS_SUCCESS; + } + CNMEM_CHECK_TRUE(ptr, CNMEM_STATUS_INVALID_ARGUMENT); + + int device; + CNMEM_CHECK_CUDA(cudaGetDevice(&device)); + + cnmem::Manager &root = cnmem::Context::get()->getManager(device); + cnmem::Manager *manager = &root; + if( stream ) { + CNMEM_CHECK(root.getChildFromStream(manager, stream)); + } + CNMEM_ASSERT(manager); + + size = cnmem::ceilInt(size, CNMEM_GRANULARITY); + cnmemStatus_t result = manager->allocate(ptr[0], size); + + // We failed to allocate but there might still be a buffer available in another manager. Try to + // steal it. + if( result == CNMEM_STATUS_OUT_OF_MEMORY ) { + + // Try to acquire locks on all the children. + std::size_t numChildren; + CNMEM_CHECK(root.getNumChildren(numChildren)); + std::vector mutexes(numChildren); + + std::size_t numLocked = 0; + for( size_t i = 0 ; i < numChildren ; ++i, ++numLocked ) { + cnmem::Manager *child; + CNMEM_CHECK(root.getChild(child, i)); + mutexes[numLocked] = child->getMutex(); + if( mutexes[numLocked]->lock() != CNMEM_STATUS_SUCCESS ) { + break; + } + } + + // One lock failed, quit. Reduce the damage as much as possible, though. + if( numLocked != numChildren ) { + for( std::size_t i = 0 ; i < numLocked ; ++i ) { + cnmemStatus_t lockStatus = mutexes[i]->unlock(); + } + return CNMEM_STATUS_UNKNOWN_ERROR; + } + + // Grab the lock on the root, first. + const cnmem::Mutex *rootMutex = root.getMutex(); + CNMEM_CHECK(rootMutex->lock()); + + // We acquired all the lock so we try to steal a node from another child. + if( numLocked == mutexes.size() ) { + result = manager->stealUnsafe(ptr[0], size); + } + for( std::size_t i = 0 ; i < numLocked ; ++i ) { + cnmemStatus_t lockStatus = mutexes[i]->unlock(); + if( lockStatus != CNMEM_STATUS_SUCCESS ) { + // Starting from now we are panicking!!! One lock failed to be released, we try + // we others. We could also give up because we are already screwed. I don't know + // what's best! Comment are welcome. + result = lockStatus; + } + } + CNMEM_CHECK(rootMutex->unlock()); + } + return result; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t cnmemFree(void *ptr, cudaStream_t stream) { + CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); + if( ptr == NULL ) { + return CNMEM_STATUS_SUCCESS; + } + + int device; + CNMEM_CHECK_CUDA(cudaGetDevice(&device)); + + cnmem::Manager &root = cnmem::Context::get()->getManager(device); + cnmem::Manager *manager = &root; + if( stream ) { + CNMEM_CHECK(root.getChildFromStream(manager, stream)); + } + CNMEM_ASSERT(manager); + return manager->release(ptr); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t cnmemMemGetInfo(size_t *freeMem, size_t *totalMem, cudaStream_t stream) { + CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); + CNMEM_CHECK_TRUE(totalMem && freeMem, CNMEM_STATUS_INVALID_ARGUMENT); + + int device; + CNMEM_CHECK_CUDA(cudaGetDevice(&device)); + cnmem::Manager &root = cnmem::Context::get()->getManager(device); + cnmem::Manager *manager = &root; + if( stream ) { + CNMEM_CHECK(root.getChildFromStream(manager, stream)); + } + CNMEM_ASSERT(manager); + + const cnmem::Mutex *mutex = manager->getMutex(); + CNMEM_CHECK(mutex->lock()); + CNMEM_CHECK_OR_UNLOCK(manager->getFreeMemoryUnsafe(*freeMem), *mutex); + size_t usedMem; + CNMEM_CHECK_OR_UNLOCK(manager->getUsedMemoryUnsafe(usedMem), *mutex); + CNMEM_CHECK(mutex->unlock()); + totalMem[0] = usedMem + freeMem[0]; + return CNMEM_STATUS_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +cnmemStatus_t cnmemPrintMemoryState(FILE *file, cudaStream_t stream) { + CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); + + int device; + CNMEM_CHECK_CUDA(cudaGetDevice(&device)); + cnmem::Manager &root = cnmem::Context::get()->getManager(device); + cnmem::Manager *manager = &root; + if( stream ) { + CNMEM_CHECK(root.getChildFromStream(manager, stream)); + } + CNMEM_ASSERT(manager); + return manager->printMemoryState(file); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +} // extern "C" + diff --git a/tests/cnmem_tests.cpp b/tests/cnmem_tests.cpp new file mode 100644 index 00000000000..0f1c26873b0 --- /dev/null +++ b/tests/cnmem_tests.cpp @@ -0,0 +1,1001 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of NVIDIA CORPORATION nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +/////////////////////////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#ifdef USE_CPP_11 +#include +#endif + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +static std::size_t getFreeMemory() { + std::size_t freeMem, totalMem; + cudaMemGetInfo(&freeMem, &totalMem); + return freeMem; +} + +class CnmemTest : public ::testing::Test { + /// We determine the amount of free memory. + std::size_t mFreeMem; + +protected: + /// Do we test memory leaks. + bool mTestLeaks; + /// Do we skip finalization. + bool mFinalize; + +public: + /// Ctor. + CnmemTest() : mFreeMem(getFreeMemory()), mTestLeaks(true), mFinalize(true) {} + /// Tear down the test. + void TearDown(); +}; + +void CnmemTest::TearDown() { + if( mFinalize ) { + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFinalize()); + } + if( mTestLeaks ) { + ASSERT_EQ(mFreeMem, getFreeMemory()); + } +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, notInitializedFinalize) { + ASSERT_EQ(CNMEM_STATUS_NOT_INITIALIZED, cnmemFinalize()); + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, notInitializedMalloc) { + ASSERT_EQ(CNMEM_STATUS_NOT_INITIALIZED, cnmemMalloc(NULL, 0, 0)); + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, notInitializedFree) { + ASSERT_EQ(CNMEM_STATUS_NOT_INITIALIZED, cnmemFree(NULL, 0)); + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, initOutOfMemory) { + cudaDeviceProp props; + ASSERT_EQ(cudaSuccess, cudaGetDeviceProperties(&props, 0)); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = props.totalGlobalMem * 2; + ASSERT_EQ(CNMEM_STATUS_OUT_OF_MEMORY, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, initDevice1) { + int numDevices; + ASSERT_EQ(cudaSuccess, cudaGetDeviceCount(&numDevices)); + + // We can't check anything. We need at least 2 devices to enable only the 2nd one. + if( numDevices < 2 ) { + return; + } + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.device = 1; // Skip device 0. + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, freeNULL) { + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(NULL, NULL)); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, freeTwoStreams) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 3*1024; + device.numStreams = 2; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + void *ptr0, *ptr1; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 1024, streams[0])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 1024, streams[1])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[1])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); + + ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[1])); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, addStream) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + // Register only 1 stream (on purpose). + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 3*1024; + device.numStreams = 1; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + // Allocate a pointer with a valid stream. + void *ptr0, *ptr1; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 1024, streams[0])); + + // Try to allocate with an invalid stream. + ASSERT_EQ(CNMEM_STATUS_INVALID_ARGUMENT, cnmemMalloc(&ptr1, 1024, streams[1])); + + // Register the stream and try again. + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemRegisterStream(streams[1])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 1024, streams[1])); + + // Clean up. + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[1])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); + + ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[1])); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, freeWrongStream) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 3*1024; + device.numStreams = 2; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + void *ptr; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 1024, streams[0])); + ASSERT_EQ(CNMEM_STATUS_INVALID_ARGUMENT, cnmemFree(ptr, streams[1])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr, streams[0])); + + ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[1])); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, freeNULLRatherThanNamed) { + cudaStream_t stream; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&stream)); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + device.numStreams = 1; + device.streams = &stream; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + void *ptr; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 1024, stream)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr, NULL)); // We expect this async free to work. + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFinalize()); + + ASSERT_EQ(cudaSuccess, cudaStreamDestroy(stream)); + + device.numStreams = 0; + device.streams = NULL; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateNULL) { + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(NULL, 0, NULL)); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateZeroSize) { + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + void *ptr; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 0, NULL)); + ASSERT_EQ((void*) NULL, ptr); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateNoFree) { + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + void *ptr; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 512, NULL)); + ASSERT_NE((void*) NULL, ptr); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFinalize()); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateAndFreeOne) { + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + void *ptr; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 512, NULL)); + ASSERT_NE((void*) NULL, ptr); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr, NULL)); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateAndFreeTwo) { + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + void *ptr0; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 512, NULL)); + ASSERT_NE((void*) NULL, ptr0); + void *ptr1; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, NULL)); + ASSERT_NE((void*) NULL, ptr1); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, NULL)); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateAndFreeAll) { + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + void *ptr0; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 512, NULL)); + ASSERT_NE((void*) NULL, ptr0); + void *ptr1; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, NULL)); + ASSERT_NE((void*) NULL, ptr1); + void *ptr2; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 512, NULL)); + ASSERT_NE((void*) NULL, ptr2); + void *ptr3; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr3, 512, NULL)); + ASSERT_NE((void*) NULL, ptr3); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr3, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, NULL)); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateAndFreeAnyOrder) { + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + void *ptr0; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 512, NULL)); + ASSERT_NE((void*) NULL, ptr0); + void *ptr1; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, NULL)); + ASSERT_NE((void*) NULL, ptr1); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, NULL)); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateTooMuchAndGrow) { + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + void *ptr0; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 512, NULL)); + ASSERT_NE((void*) NULL, ptr0); + void *ptr1; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, NULL)); + ASSERT_NE((void*) NULL, ptr1); + void *ptr2; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 512, NULL)); + ASSERT_NE((void*) NULL, ptr2); + void *ptr3; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr3, 512, NULL)); + ASSERT_NE((void*) NULL, ptr3); + void *ptr4; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr4, 512, NULL)); + ASSERT_NE((void*) NULL, ptr4); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr4, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr3, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, NULL)); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateTooMuchNoGrow) { + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + void *ptr0; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 512, NULL)); + ASSERT_NE((void*) NULL, ptr0); + void *ptr1; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, NULL)); + ASSERT_NE((void*) NULL, ptr1); + void *ptr2; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 512, NULL)); + ASSERT_NE((void*) NULL, ptr2); + void *ptr3; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr3, 512, NULL)); + ASSERT_NE((void*) NULL, ptr3); + void *ptr4; + ASSERT_EQ(CNMEM_STATUS_OUT_OF_MEMORY, cnmemMalloc(&ptr4, 512, NULL)); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr3, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, NULL)); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateAndSteal) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 3*1024; + device.numStreams = 2; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + // Take the 1024B from streams[0]. + void *ptr0; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 1024, streams[0])); + ASSERT_NE((void*) NULL, ptr0); + // Take the 1024B from NULL. + void *ptr1; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 1024, streams[0])); + ASSERT_NE((void*) NULL, ptr1); + // Steal the 1024B from streams[1]. + void *ptr2; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 1024, streams[0])); + ASSERT_NE((void*) NULL, ptr2); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, streams[0])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[0])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); + + cudaStreamDestroy(streams[1]); + cudaStreamDestroy(streams[0]); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateAndSteal2) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 3*1024; + device.numStreams = 2; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + void *ptr0; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 1024, streams[0])); + ASSERT_NE((void*) NULL, ptr0); + void *ptr1; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, streams[1])); + ASSERT_NE((void*) NULL, ptr1); + void *ptr2; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 512, streams[0])); + ASSERT_NE((void*) NULL, ptr2); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, streams[0])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[1])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); + + cudaStreamDestroy(streams[1]); + cudaStreamDestroy(streams[0]); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateAndSteal3) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 3*2048; + device.numStreams = 2; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + void *ptr0; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 2048, streams[0])); + ASSERT_NE((void*) NULL, ptr0); + void *ptr1; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, streams[1])); + ASSERT_NE((void*) NULL, ptr1); + void *ptr2; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 1024, streams[0])); + ASSERT_NE((void*) NULL, ptr2); + void *ptr3; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr3, 512, streams[1])); + ASSERT_NE((void*) NULL, ptr3); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr3, streams[1])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, streams[0])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[1])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); + + cudaStreamDestroy(streams[1]); + cudaStreamDestroy(streams[0]); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateAndSteal4) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 6*1024; + device.numStreams = 2; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + void *ptr0; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 1024, streams[0])); + void *ptr1; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 1024, streams[0])); + void *ptr2; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 1024, streams[0])); + void *ptr3; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr3, 1024, streams[0])); + void *ptr4; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr4, 1024, streams[0])); + void *ptr5; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr5, 1024, streams[1])); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[0])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, streams[0])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr3, streams[0])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr4, streams[0])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr5, streams[1])); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateAndReserveStream) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 4096; + device.numStreams = 2; + device.streams = streams; + size_t streamSizes[] = { 2048, 2048 }; + device.streamSizes = streamSizes; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + size_t totalMem, freeMem; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); + ASSERT_EQ(4096, totalMem); + ASSERT_EQ(0, freeMem); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, streams[0])); + ASSERT_EQ(2048, totalMem); + ASSERT_EQ(2048, freeMem); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, streams[1])); + ASSERT_EQ(2048, totalMem); + ASSERT_EQ(2048, freeMem); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateAndReserveStreamDifferentSizes) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 8192; + device.numStreams = 2; + device.streams = streams; + size_t streamSizes[] = { 2048, 4096 }; + device.streamSizes = streamSizes; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + size_t totalMem, freeMem; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); + ASSERT_EQ(8192, totalMem); + ASSERT_EQ(2048, freeMem); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, streams[0])); + ASSERT_EQ(2048, totalMem); + ASSERT_EQ(2048, freeMem); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, streams[1])); + ASSERT_EQ(4096, totalMem); + ASSERT_EQ(4096, freeMem); + + FILE *file = fopen("reserveStream.log", "w"); + ASSERT_NE((FILE*) NULL, file); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemPrintMemoryState(file, streams[0])); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemPrintMemoryState(file, streams[1])); + fclose(file); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef USE_CPP_11 + +template< int N > +static void allocate(cudaStream_t stream) { + void *ptr[N]; + for( int i = 0 ; i < N ; ++i ) + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr[i], 1024, stream)); + for( int i = 0 ; i < N ; ++i ) + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr[i], stream)); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateConcurrentNoCompete) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 6*1024; + device.numStreams = 2; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + // In this test, each manager has enough memory to accommodate the threads. + std::vector threads(2); + for( int i = 0 ; i < 2 ; ++i ) + threads[i] = new std::thread(allocate<2>, streams[i]); + for( int i = 0 ; i < 2 ; ++i ) + threads[i]->join(); + for( unsigned i = 0 ; i < 2 ; ++i ) + delete threads[i]; + threads.clear(); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateConcurrentCompete) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 6*1024; + device.numStreams = 2; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + // In this test, the threads compete for the memory of the root manager. + std::vector threads(2); + for( int i = 0; i < 2; ++i ) + threads[i] = new std::thread(allocate<3>, streams[i]); + for( int i = 0; i < 2; ++i ) + threads[i]->join(); + for( unsigned i = 0; i < 2; ++i ) + delete threads[i]; + threads.clear(); + + mTestLeaks = false; // For some reasons, it reports a leak. It's likely to be in the driver/runtime. +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateConcurrentSteal) { + const int N = 4; + cudaStream_t streams[N]; + for( int i = 0 ; i < N ; ++i ) { + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[i])); + } + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 4*N*1024; + device.numStreams = N; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + // In this test, the thread 0 has to steal memory from thread 1. + std::vector threads(N); + for( int i = 0 ; i < N ; ++i ) { + threads[i] = new std::thread(allocate<4>, streams[i]); + } + for( int i = 0; i < N; ++i ) + threads[i]->join(); + for( int i = 0; i < N; ++i ) + delete threads[i]; + threads.clear(); + + mTestLeaks = false; // For some reasons, it reports a leak. +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateConcurrentMultiStreamsPerThreadNoGrow) { + const int NUM_STREAMS = 8, NUM_THREADS = 32; + cudaStream_t streams[NUM_STREAMS]; + for( int i = 0 ; i < NUM_STREAMS ; ++i ) { + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[i])); + } + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 4*NUM_THREADS*1024; + device.numStreams = NUM_STREAMS; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + std::vector threads(NUM_THREADS); + for( int i = 0 ; i < NUM_THREADS ; ++i ) { + threads[i] = new std::thread(allocate<4>, streams[i%NUM_STREAMS]); + } + for( int i = 0; i < NUM_THREADS; ++i ) + threads[i]->join(); + for( int i = 0; i < NUM_THREADS; ++i ) + delete threads[i]; + threads.clear(); + + mTestLeaks = false; // For some reasons, it reports a leak. +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, allocateConcurrentMultiStreamsPerThreadGrow) { + const int NUM_STREAMS = 8, NUM_THREADS = 32; + cudaStream_t streams[NUM_STREAMS]; + for( int i = 0 ; i < NUM_STREAMS ; ++i ) { + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[i])); + } + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = NUM_THREADS*1024; + device.numStreams = NUM_STREAMS; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + std::vector threads(NUM_THREADS); + for( int i = 0 ; i < NUM_THREADS ; ++i ) { + threads[i] = new std::thread(allocate<4>, streams[i%NUM_STREAMS]); + } + for( int i = 0; i < NUM_THREADS; ++i ) + threads[i]->join(); + for( int i = 0; i < NUM_THREADS; ++i ) + delete threads[i]; + threads.clear(); + + mTestLeaks = false; // For some reasons, it reports a leak. +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +template< int N > +static void registerAndAllocate(cudaStream_t stream) { + void *ptr[N]; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemRegisterStream(stream)); + for( int i = 0 ; i < N ; ++i ) + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr[i], 1024, stream)); + for( int i = 0 ; i < N ; ++i ) + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr[i], stream)); +} + +TEST_F(CnmemTest, registerAndAllocateConcurrentStreamsGrow) { + const int N = 32; + cudaStream_t streams[N]; + for( int i = 0 ; i < N ; ++i ) { + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[i])); + } + + // Declare no stream. + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 1024; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + // In this test, the thread 0 has to steal memory from thread 1. + std::vector threads(N); + for( int i = 0 ; i < N ; ++i ) { + threads[i] = new std::thread(registerAndAllocate<2>, streams[i]); + } + for( int i = 0; i < N; ++i ) + threads[i]->join(); + for( int i = 0; i < N; ++i ) + delete threads[i]; + threads.clear(); + + mTestLeaks = false; // For some reasons, it reports a leak. +} + +TEST_F(CnmemTest, registerAndAllocateConcurrentMultiStreamsPerThread) { + const int NUM_STREAMS = 8, NUM_THREADS = 32; + cudaStream_t streams[NUM_STREAMS]; + for( int i = 0 ; i < NUM_STREAMS ; ++i ) { + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[i])); + } + + // Declare no stream. + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 1024; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + // In this test, the thread 0 has to steal memory from thread 1. + std::vector threads(NUM_THREADS); + for( int i = 0 ; i < NUM_THREADS ; ++i ) { + threads[i] = new std::thread(registerAndAllocate<4>, streams[i%NUM_STREAMS]); + } + for( int i = 0; i < NUM_THREADS; ++i ) + threads[i]->join(); + for( int i = 0; i < NUM_THREADS; ++i ) + delete threads[i]; + threads.clear(); + + mTestLeaks = false; // For some reasons, it reports a leak. +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +template< int N > +static void allocateAndPrint(int id, cudaStream_t stream) { + void *ptr[N]; + for( int i = 0 ; i < N ; ++i ) + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr[i], 1024, stream)); + char buffer[64]; + sprintf(buffer, "memoryState.%d.log", id); + FILE *file = fopen(buffer, "w"); + ASSERT_NE((FILE*) NULL, file); + cnmemPrintMemoryState(file, stream); + fclose(file); + for( int i = 0 ; i < N ; ++i ) + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr[i], stream)); +} + +TEST_F(CnmemTest, testPrintMemoryState) { + cudaStream_t streams[2]; + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); + ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 4096; + device.numStreams = 2; + device.streams = streams; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); + + // In this test, each manager has enough memory to accommodate the threads. + std::vector threads(2); + for( int i = 0 ; i < 2 ; ++i ) + threads[i] = new std::thread(allocateAndPrint<2>, i, streams[i]); + for( int i = 0 ; i < 2 ; ++i ) + threads[i]->join(); + for( unsigned i = 0 ; i < 2 ; ++i ) + delete threads[i]; + threads.clear(); + + mTestLeaks = false; // For some reasons, it reports a leak. +} + +#endif // defined USE_CPP_11 + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, memoryUsage) { + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 4096; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + + std::size_t totalMem, freeMem; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); + ASSERT_EQ(4096, totalMem); + ASSERT_EQ(4096, freeMem); + + void *ptr; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 1024, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); + ASSERT_EQ(4096, totalMem); + ASSERT_EQ(3072, freeMem); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr, NULL)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); + ASSERT_EQ(4096, totalMem); + ASSERT_EQ(4096, freeMem); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST_F(CnmemTest, testDeviceDoesNotChange) { + + int numDevices; + ASSERT_EQ(cudaSuccess, cudaGetDeviceCount(&numDevices)); + if( numDevices < 2 ) { + ASSERT_TRUE(true); + return; + } + + cnmemDevice_t devices[2]; + memset(devices, 0, sizeof(devices)); + devices[0].device = 0; + devices[0].size = 4096; + devices[1].device = 1; + devices[1].size = 2048; + + int currentDevice; + ASSERT_EQ(cudaSuccess, cudaSetDevice(0)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(2, devices, CNMEM_FLAGS_DEFAULT)); + ASSERT_EQ(cudaSuccess, cudaGetDevice(¤tDevice)); + ASSERT_EQ(0, currentDevice); + + size_t totalMem, freeMem; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); + ASSERT_EQ(4096, totalMem); + ASSERT_EQ(4096, freeMem); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFinalize()); + + ASSERT_EQ(cudaSuccess, cudaSetDevice(1)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(2, devices, CNMEM_FLAGS_DEFAULT)); + ASSERT_EQ(cudaSuccess, cudaGetDevice(¤tDevice)); + ASSERT_EQ(1, currentDevice); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); + ASSERT_EQ(2048, totalMem); + ASSERT_EQ(2048, freeMem); + + ASSERT_EQ(cudaSuccess, cudaSetDevice(0)); // Make sure we are on dev 0 for final mem checks. +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef USE_CPP_11 +#include + +template< typename T > +class DeviceDeleter { +public: + DeviceDeleter() {} + void operator()(T *ptr) { + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr, cudaStreamDefault)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemRelease()); + } +}; + +TEST_F(CnmemTest, testSharedPtr) { + + cnmemDevice_t device; + memset(&device, 0, sizeof(device)); + device.size = 2048; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemRetain()); + + float *ptr; + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc((void**) &ptr, 1024, cudaStreamDefault)); + std::shared_ptr p(ptr, DeviceDeleter()); + + ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFinalize()); // We still have a pointer in the scope... + mFinalize = false; // Make sure TearDown does call finalize again. +} + +#endif + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + From 8a16cbd11b56fd3280f2f2fb22bfb4e63ed303b1 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 20 Oct 2015 00:24:21 -0700 Subject: [PATCH 266/331] CNMEM integration --- Makefile | 52 ++++++++++++------- third_party/Makefile | 19 +++++++ {.3rdparty => third_party}/cnmem/.gitignore | 0 .../cnmem/CMakeLists.txt | 0 {.3rdparty => third_party}/cnmem/LICENSE | 0 {.3rdparty => third_party}/cnmem/README.md | 0 .../cnmem/include/cnmem.h | 0 .../cnmem/src/cnmem.cpp | 0 .../cnmem/tests/cnmem_tests.cpp | 0 9 files changed, 51 insertions(+), 20 deletions(-) create mode 100644 third_party/Makefile rename {.3rdparty => third_party}/cnmem/.gitignore (100%) rename {.3rdparty => third_party}/cnmem/CMakeLists.txt (100%) rename {.3rdparty => third_party}/cnmem/LICENSE (100%) rename {.3rdparty => third_party}/cnmem/README.md (100%) rename {.3rdparty => third_party}/cnmem/include/cnmem.h (100%) rename {.3rdparty => third_party}/cnmem/src/cnmem.cpp (100%) rename {.3rdparty => third_party}/cnmem/tests/cnmem_tests.cpp (100%) diff --git a/Makefile b/Makefile index 4562ef0b2c4..d7d0085e615 100644 --- a/Makefile +++ b/Makefile @@ -7,12 +7,14 @@ $(error $(CONFIG_FILE) not found. See $(CONFIG_FILE).example.) endif include $(CONFIG_FILE) +PROJECT_DIR=$(PWD) + BUILD_DIR_LINK := $(BUILD_DIR) ifeq ($(RELEASE_BUILD_DIR),) - RELEASE_BUILD_DIR := .$(BUILD_DIR)_release + RELEASE_BUILD_DIR := $(PROJECT_DIR)/.$(BUILD_DIR)_release endif ifeq ($(DEBUG_BUILD_DIR),) - DEBUG_BUILD_DIR := .$(BUILD_DIR)_debug + DEBUG_BUILD_DIR := $(PROJECT_DIR)/.$(BUILD_DIR)_debug endif DEBUG ?= 0 @@ -24,6 +26,9 @@ else OTHER_BUILD_DIR := $(DEBUG_BUILD_DIR) endif +THIRDPARTY_DIR=$(PROJECT_DIR)/third_party +THIRDPARTY=$(BUILD_DIR)/.third_party_done + # All of the directories containing code. SRC_DIRS := $(shell find * -type d -exec bash -c "find {} -maxdepth 1 \ \( -name '*.cpp' -o -name '*.proto' \) | grep -q ." \; -print) @@ -241,12 +246,12 @@ endif ifeq ($(LINUX), 1) CXX ?= /usr/bin/g++ GCCVERSION := $(shell $(CXX) -dumpversion | cut -f1,2 -d.) - # older versions of gcc are too dumb to build boost with -Wuninitalized + # older versions of gcc are too dumb to build boost with -Wuninitalized ifeq ($(shell echo | awk '{exit $(GCCVERSION) < 4.6;}'), 1) WARNINGS += -Wno-uninitialized endif - # boost::thread is reasonably called boost_thread (compare OS X) - # We will also explicitly add stdc++ to the link target. + # boost::thread is reasonably called boost_thread (compare OS X) + # We will also explicitly add stdc++ to the link target. LIBRARIES += boost_thread stdc++ endif @@ -261,14 +266,14 @@ ifeq ($(OSX), 1) CXXFLAGS += -stdlib=libstdc++ LINKFLAGS += -stdlib=libstdc++ endif - # clang throws this warning for cuda headers + # clang throws this warning for cuda headers WARNINGS += -Wno-unneeded-internal-declaration endif - # gtest needs to use its own tuple to not conflict with clang + # gtest needs to use its own tuple to not conflict with clang COMMON_FLAGS += -DGTEST_USE_OWN_TR1_TUPLE=1 - # boost::thread is called boost_thread-mt to mark multithreading on OS X + # boost::thread is called boost_thread-mt to mark multithreading on OS X LIBRARIES += boost_thread-mt - # we need to explicitly ask for the rpath to be obeyed + # we need to explicitly ask for the rpath to be obeyed DYNAMIC_FLAGS := -install_name @rpath/libcaffe.so ORIGIN := @loader_path else @@ -306,9 +311,11 @@ ifeq ($(USE_CUDNN), 1) COMMON_FLAGS += -DUSE_CUDNN endif -# cuMEM integration +# CNMEM integration ifeq ($(USE_CNMEM), 1) + THIRDPARTY_TARGETS+=cnmem LIBRARIES += cnmem + CNMEM_DIR=${THIRDPARTY_DIR}/cnmem LIBRARY_DIRS += ${CNMEM_DIR}/build INCLUDE_DIRS += ${CNMEM_DIR}/include COMMON_FLAGS += -DUSE_CNMEM @@ -344,26 +351,26 @@ endif # BLAS configuration (default = ATLAS) BLAS ?= atlas ifeq ($(BLAS), mkl) - # MKL + # MKL LIBRARIES += mkl_rt COMMON_FLAGS += -DUSE_MKL MKL_DIR ?= /opt/intel/mkl BLAS_INCLUDE ?= $(MKL_DIR)/include BLAS_LIB ?= $(MKL_DIR)/lib $(MKL_DIR)/lib/intel64 else ifeq ($(BLAS), open) - # OpenBLAS + # OpenBLAS LIBRARIES += openblas else - # ATLAS + # ATLAS ifeq ($(LINUX), 1) ifeq ($(BLAS), atlas) - # Linux simply has cblas and atlas + # Linux simply has cblas and atlas LIBRARIES += cblas atlas endif else ifeq ($(OSX), 1) - # OS X packages atlas as the vecLib framework + # OS X packages atlas as the vecLib framework LIBRARIES += cblas - # 10.10 has accelerate while 10.9 has veclib + # 10.10 has accelerate while 10.9 has veclib XCODE_CLT_VER := $(shell pkgutil --pkg-info=com.apple.pkg.CLTools_Executables | grep 'version' | sed 's/[^0-9]*\([0-9]\).*/\1/') XCODE_CLT_GEQ_6 := $(shell [ $(XCODE_CLT_VER) -gt 5 ] && echo 1) ifeq ($(XCODE_CLT_GEQ_6), 1) @@ -423,12 +430,17 @@ endif # Define build targets ############################## .PHONY: all lib test clean docs linecount lint lintclean tools examples $(DIST_ALIASES) \ - py mat py$(PROJECT) mat$(PROJECT) proto runtest \ + py mat py$(PROJECT) mat$(PROJECT) thirdparty proto runtest \ superclean supercleanlist supercleanfiles warn everything all: lib tools examples -lib: $(STATIC_NAME) $(DYNAMIC_NAME) +lib: $(STATIC_NAME) $(DYNAMIC_NAME) + +$(THIRDPARTY): | $(LIB_BUILD_DIR) + echo "Building third-party libraries ..." + @$(MAKE) -C $(THIRDPARTY_DIR) DEBUG=$(DEBUG) CAFFE_BUILD_DIR=$(BUILD_DIR) + @touch $(THIRDPARTY) everything: $(EVERYTHING_TARGETS) @@ -542,11 +554,11 @@ $(BUILD_DIR)/.linked: $(ALL_BUILD_DIRS): | $(BUILD_DIR_LINK) @ mkdir -p $@ -$(DYNAMIC_NAME): $(OBJS) | $(LIB_BUILD_DIR) +$(DYNAMIC_NAME): $(THIRDPARTY) $(OBJS)| $(LIB_BUILD_DIR) @ echo LD -o $@ $(Q)$(CXX) -shared -o $@ $(OBJS) $(LINKFLAGS) $(LDFLAGS) $(DYNAMIC_FLAGS) -$(STATIC_NAME): $(OBJS) | $(LIB_BUILD_DIR) +$(STATIC_NAME): $(THIRDPARTY) $(OBJS) | $(LIB_BUILD_DIR) @ echo AR -o $@ $(Q)ar rcs $@ $(OBJS) diff --git a/third_party/Makefile b/third_party/Makefile new file mode 100644 index 00000000000..263d823e387 --- /dev/null +++ b/third_party/Makefile @@ -0,0 +1,19 @@ +# Makefile for all third party libraries + +# NVidia CNMEM, https://github.com/NVIDIA/cnmem.git + +.PHONY: cnmem + +install: build + cp $(CNMEM_BUILD_DIR)/*.so* $(CAFFE_BUILD_DIR)/lib + +build : cnmem + +CNMEM_BUILD_DIR=./cnmem/build +cnmem: + @mkdir -p $(CNMEM_BUILD_DIR) + ( cd $(CNMEM_BUILD_DIR) && cmake ..) + $(MAKE) -C $(CNMEM_BUILD_DIR) DEBUG=$(DEBUG) + + + diff --git a/.3rdparty/cnmem/.gitignore b/third_party/cnmem/.gitignore similarity index 100% rename from .3rdparty/cnmem/.gitignore rename to third_party/cnmem/.gitignore diff --git a/.3rdparty/cnmem/CMakeLists.txt b/third_party/cnmem/CMakeLists.txt similarity index 100% rename from .3rdparty/cnmem/CMakeLists.txt rename to third_party/cnmem/CMakeLists.txt diff --git a/.3rdparty/cnmem/LICENSE b/third_party/cnmem/LICENSE similarity index 100% rename from .3rdparty/cnmem/LICENSE rename to third_party/cnmem/LICENSE diff --git a/.3rdparty/cnmem/README.md b/third_party/cnmem/README.md similarity index 100% rename from .3rdparty/cnmem/README.md rename to third_party/cnmem/README.md diff --git a/.3rdparty/cnmem/include/cnmem.h b/third_party/cnmem/include/cnmem.h similarity index 100% rename from .3rdparty/cnmem/include/cnmem.h rename to third_party/cnmem/include/cnmem.h diff --git a/.3rdparty/cnmem/src/cnmem.cpp b/third_party/cnmem/src/cnmem.cpp similarity index 100% rename from .3rdparty/cnmem/src/cnmem.cpp rename to third_party/cnmem/src/cnmem.cpp diff --git a/.3rdparty/cnmem/tests/cnmem_tests.cpp b/third_party/cnmem/tests/cnmem_tests.cpp similarity index 100% rename from .3rdparty/cnmem/tests/cnmem_tests.cpp rename to third_party/cnmem/tests/cnmem_tests.cpp From 863505182e982f04dbf9a4ddafa213aa18b7b9d3 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 20 Oct 2015 00:51:16 -0700 Subject: [PATCH 267/331] Travis build has Cmake 2.8.7 --- third_party/cnmem/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/third_party/cnmem/CMakeLists.txt b/third_party/cnmem/CMakeLists.txt index e11d12f9ee3..c254cd4f9d0 100644 --- a/third_party/cnmem/CMakeLists.txt +++ b/third_party/cnmem/CMakeLists.txt @@ -1,5 +1,5 @@ # CMakeLists to build the cnmem library. -cmake_minimum_required(VERSION 2.8.8) +cmake_minimum_required(VERSION 2.8.7) project(cnmem) # We need CUDA to build that library. From ce1c4639c2b6471762d25cff4957b5be1e62cc85 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 20 Oct 2015 01:15:37 -0700 Subject: [PATCH 268/331] Removing Cmake --- third_party/Makefile | 2 - third_party/cnmem/build/Makefile | 208 +++++++++++++++++++++++++++++++ 2 files changed, 208 insertions(+), 2 deletions(-) create mode 100644 third_party/cnmem/build/Makefile diff --git a/third_party/Makefile b/third_party/Makefile index 263d823e387..991d838715d 100644 --- a/third_party/Makefile +++ b/third_party/Makefile @@ -11,8 +11,6 @@ build : cnmem CNMEM_BUILD_DIR=./cnmem/build cnmem: - @mkdir -p $(CNMEM_BUILD_DIR) - ( cd $(CNMEM_BUILD_DIR) && cmake ..) $(MAKE) -C $(CNMEM_BUILD_DIR) DEBUG=$(DEBUG) diff --git a/third_party/cnmem/build/Makefile b/third_party/cnmem/build/Makefile new file mode 100644 index 00000000000..686343a4ade --- /dev/null +++ b/third_party/cnmem/build/Makefile @@ -0,0 +1,208 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 2.8 + +# Default target executed when no arguments are given to make. +default_target: all +.PHONY : default_target + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/bfomitchev/git/float16/third_party/cnmem + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/bfomitchev/git/float16/third_party/cnmem/build + +#============================================================================= +# Targets provided globally by CMake. + +# Special rule for the target edit_cache +edit_cache: + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running interactive CMake command-line interface..." + /usr/bin/cmake -i . +.PHONY : edit_cache + +# Special rule for the target edit_cache +edit_cache/fast: edit_cache +.PHONY : edit_cache/fast + +# Special rule for the target install +install: preinstall + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..." + /usr/bin/cmake -P cmake_install.cmake +.PHONY : install + +# Special rule for the target install +install/fast: preinstall/fast + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..." + /usr/bin/cmake -P cmake_install.cmake +.PHONY : install/fast + +# Special rule for the target install/local +install/local: preinstall + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing only the local directory..." + /usr/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake +.PHONY : install/local + +# Special rule for the target install/local +install/local/fast: install/local +.PHONY : install/local/fast + +# Special rule for the target install/strip +install/strip: preinstall + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing the project stripped..." + /usr/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake +.PHONY : install/strip + +# Special rule for the target install/strip +install/strip/fast: install/strip +.PHONY : install/strip/fast + +# Special rule for the target list_install_components +list_install_components: + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Available install components are: \"Unspecified\"" +.PHONY : list_install_components + +# Special rule for the target list_install_components +list_install_components/fast: list_install_components +.PHONY : list_install_components/fast + +# Special rule for the target rebuild_cache +rebuild_cache: + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..." + /usr/bin/cmake -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) +.PHONY : rebuild_cache + +# Special rule for the target rebuild_cache +rebuild_cache/fast: rebuild_cache +.PHONY : rebuild_cache/fast + +# The main all target +all: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/bfomitchev/git/float16/third_party/cnmem/build/CMakeFiles /home/bfomitchev/git/float16/third_party/cnmem/build/CMakeFiles/progress.marks + $(MAKE) -f CMakeFiles/Makefile2 all + $(CMAKE_COMMAND) -E cmake_progress_start /home/bfomitchev/git/float16/third_party/cnmem/build/CMakeFiles 0 +.PHONY : all + +# The main clean target +clean: + $(MAKE) -f CMakeFiles/Makefile2 clean +.PHONY : clean + +# The main clean target +clean/fast: clean +.PHONY : clean/fast + +# Prepare targets for installation. +preinstall: all + $(MAKE) -f CMakeFiles/Makefile2 preinstall +.PHONY : preinstall + +# Prepare targets for installation. +preinstall/fast: + $(MAKE) -f CMakeFiles/Makefile2 preinstall +.PHONY : preinstall/fast + +# clear depends +depend: + $(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1 +.PHONY : depend + +#============================================================================= +# Target rules for targets named cnmem + +# Build rule for target. +cnmem: cmake_check_build_system + $(MAKE) -f CMakeFiles/Makefile2 cnmem +.PHONY : cnmem + +# fast build rule for target. +cnmem/fast: + $(MAKE) -f CMakeFiles/cnmem.dir/build.make CMakeFiles/cnmem.dir/build +.PHONY : cnmem/fast + +src/cnmem.o: src/cnmem.cpp.o +.PHONY : src/cnmem.o + +# target to build an object file +src/cnmem.cpp.o: + $(MAKE) -f CMakeFiles/cnmem.dir/build.make CMakeFiles/cnmem.dir/src/cnmem.cpp.o +.PHONY : src/cnmem.cpp.o + +src/cnmem.i: src/cnmem.cpp.i +.PHONY : src/cnmem.i + +# target to preprocess a source file +src/cnmem.cpp.i: + $(MAKE) -f CMakeFiles/cnmem.dir/build.make CMakeFiles/cnmem.dir/src/cnmem.cpp.i +.PHONY : src/cnmem.cpp.i + +src/cnmem.s: src/cnmem.cpp.s +.PHONY : src/cnmem.s + +# target to generate assembly for a file +src/cnmem.cpp.s: + $(MAKE) -f CMakeFiles/cnmem.dir/build.make CMakeFiles/cnmem.dir/src/cnmem.cpp.s +.PHONY : src/cnmem.cpp.s + +# Help Target +help: + @echo "The following are some of the valid targets for this Makefile:" + @echo "... all (the default if no target is provided)" + @echo "... clean" + @echo "... depend" + @echo "... cnmem" + @echo "... edit_cache" + @echo "... install" + @echo "... install/local" + @echo "... install/strip" + @echo "... list_install_components" + @echo "... rebuild_cache" + @echo "... src/cnmem.o" + @echo "... src/cnmem.i" + @echo "... src/cnmem.s" +.PHONY : help + + + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + From 3f462d1e4a1dc6917aa408c490d783b9cc0d36a5 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 20 Oct 2015 01:48:43 -0700 Subject: [PATCH 269/331] CNMEM conditional include fixed --- src/caffe/util/gpu_memory.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/caffe/util/gpu_memory.cpp b/src/caffe/util/gpu_memory.cpp index c29d6fcde7a..31db2ddc0dd 100644 --- a/src/caffe/util/gpu_memory.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -3,8 +3,11 @@ #include "caffe/util/gpu_memory.hpp" + +#ifdef USE_CNMEM // CNMEM integration #include "cnmem.h" +#endif namespace caffe { From 80af4b12efad3df138e5012c4379518de524f40c Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 20 Oct 2015 13:16:28 -0700 Subject: [PATCH 270/331] Rectified cnmem cmake, renamed 3rd party targets --- 3rdparty/Makefile | 16 ++++++++++++++++ {third_party => 3rdparty}/cnmem/.gitignore | 0 {third_party => 3rdparty}/cnmem/CMakeLists.txt | 0 {third_party => 3rdparty}/cnmem/LICENSE | 0 {third_party => 3rdparty}/cnmem/README.md | 0 {third_party => 3rdparty}/cnmem/build/Makefile | 8 ++++---- {third_party => 3rdparty}/cnmem/include/cnmem.h | 0 {third_party => 3rdparty}/cnmem/src/cnmem.cpp | 0 .../cnmem/tests/cnmem_tests.cpp | 0 Makefile | 11 +++++++---- third_party/Makefile | 17 ----------------- 11 files changed, 27 insertions(+), 25 deletions(-) create mode 100644 3rdparty/Makefile rename {third_party => 3rdparty}/cnmem/.gitignore (100%) rename {third_party => 3rdparty}/cnmem/CMakeLists.txt (100%) rename {third_party => 3rdparty}/cnmem/LICENSE (100%) rename {third_party => 3rdparty}/cnmem/README.md (100%) rename {third_party => 3rdparty}/cnmem/build/Makefile (95%) rename {third_party => 3rdparty}/cnmem/include/cnmem.h (100%) rename {third_party => 3rdparty}/cnmem/src/cnmem.cpp (100%) rename {third_party => 3rdparty}/cnmem/tests/cnmem_tests.cpp (100%) delete mode 100644 third_party/Makefile diff --git a/3rdparty/Makefile b/3rdparty/Makefile new file mode 100644 index 00000000000..b8f8d96dae8 --- /dev/null +++ b/3rdparty/Makefile @@ -0,0 +1,16 @@ +# Makefile for all third party libraries + +# NVidia CNMEM, https://github.com/NVIDIA/cnmem.git + +.PHONY: cnmem + +all: + @echo No targets to build! 3rd party target must be defined. + +CNMEM_BUILD_DIR=./cnmem/build +cnmem: + -rm -fr $(CNMEM_BUILD_DIR) + mkdir -p $(CNMEM_BUILD_DIR) + (cd $(CNMEM_BUILD_DIR) && cmake ..) + $(MAKE) -C $(CNMEM_BUILD_DIR) DEBUG=$(DEBUG) + cp $(CNMEM_BUILD_DIR)/*.so* $(INSTALLDIR)/lib diff --git a/third_party/cnmem/.gitignore b/3rdparty/cnmem/.gitignore similarity index 100% rename from third_party/cnmem/.gitignore rename to 3rdparty/cnmem/.gitignore diff --git a/third_party/cnmem/CMakeLists.txt b/3rdparty/cnmem/CMakeLists.txt similarity index 100% rename from third_party/cnmem/CMakeLists.txt rename to 3rdparty/cnmem/CMakeLists.txt diff --git a/third_party/cnmem/LICENSE b/3rdparty/cnmem/LICENSE similarity index 100% rename from third_party/cnmem/LICENSE rename to 3rdparty/cnmem/LICENSE diff --git a/third_party/cnmem/README.md b/3rdparty/cnmem/README.md similarity index 100% rename from third_party/cnmem/README.md rename to 3rdparty/cnmem/README.md diff --git a/third_party/cnmem/build/Makefile b/3rdparty/cnmem/build/Makefile similarity index 95% rename from third_party/cnmem/build/Makefile rename to 3rdparty/cnmem/build/Makefile index 686343a4ade..9b2837a046c 100644 --- a/third_party/cnmem/build/Makefile +++ b/3rdparty/cnmem/build/Makefile @@ -39,10 +39,10 @@ RM = /usr/bin/cmake -E remove -f EQUALS = = # The top-level source directory on which CMake was run. -CMAKE_SOURCE_DIR = /home/bfomitchev/git/float16/third_party/cnmem +CMAKE_SOURCE_DIR = /home/bfomitchev/git/float16/3rdparty/cnmem # The top-level build directory on which CMake was run. -CMAKE_BINARY_DIR = /home/bfomitchev/git/float16/third_party/cnmem/build +CMAKE_BINARY_DIR = /home/bfomitchev/git/float16/3rdparty/cnmem/build #============================================================================= # Targets provided globally by CMake. @@ -110,9 +110,9 @@ rebuild_cache/fast: rebuild_cache # The main all target all: cmake_check_build_system - $(CMAKE_COMMAND) -E cmake_progress_start /home/bfomitchev/git/float16/third_party/cnmem/build/CMakeFiles /home/bfomitchev/git/float16/third_party/cnmem/build/CMakeFiles/progress.marks + $(CMAKE_COMMAND) -E cmake_progress_start /home/bfomitchev/git/float16/3rdparty/cnmem/build/CMakeFiles /home/bfomitchev/git/float16/3rdparty/cnmem/build/CMakeFiles/progress.marks $(MAKE) -f CMakeFiles/Makefile2 all - $(CMAKE_COMMAND) -E cmake_progress_start /home/bfomitchev/git/float16/third_party/cnmem/build/CMakeFiles 0 + $(CMAKE_COMMAND) -E cmake_progress_start /home/bfomitchev/git/float16/3rdparty/cnmem/build/CMakeFiles 0 .PHONY : all # The main clean target diff --git a/third_party/cnmem/include/cnmem.h b/3rdparty/cnmem/include/cnmem.h similarity index 100% rename from third_party/cnmem/include/cnmem.h rename to 3rdparty/cnmem/include/cnmem.h diff --git a/third_party/cnmem/src/cnmem.cpp b/3rdparty/cnmem/src/cnmem.cpp similarity index 100% rename from third_party/cnmem/src/cnmem.cpp rename to 3rdparty/cnmem/src/cnmem.cpp diff --git a/third_party/cnmem/tests/cnmem_tests.cpp b/3rdparty/cnmem/tests/cnmem_tests.cpp similarity index 100% rename from third_party/cnmem/tests/cnmem_tests.cpp rename to 3rdparty/cnmem/tests/cnmem_tests.cpp diff --git a/Makefile b/Makefile index d7d0085e615..06d84a82e07 100644 --- a/Makefile +++ b/Makefile @@ -26,8 +26,8 @@ else OTHER_BUILD_DIR := $(DEBUG_BUILD_DIR) endif -THIRDPARTY_DIR=$(PROJECT_DIR)/third_party -THIRDPARTY=$(BUILD_DIR)/.third_party_done +THIRDPARTY_DIR=$(PROJECT_DIR)/3rdparty +THIRDPARTY=$(BUILD_DIR)/.3rdparty_done # All of the directories containing code. SRC_DIRS := $(shell find * -type d -exec bash -c "find {} -maxdepth 1 \ @@ -437,11 +437,14 @@ all: lib tools examples lib: $(STATIC_NAME) $(DYNAMIC_NAME) -$(THIRDPARTY): | $(LIB_BUILD_DIR) +$(THIRDPARTY): Makefile Makefile.config | $(LIB_BUILD_DIR) +ifneq ($(THIRDPARTY_TARGETS),) echo "Building third-party libraries ..." - @$(MAKE) -C $(THIRDPARTY_DIR) DEBUG=$(DEBUG) CAFFE_BUILD_DIR=$(BUILD_DIR) + @$(MAKE) -C $(THIRDPARTY_DIR) DEBUG=$(DEBUG) INSTALLDIR=$(BUILD_DIR) $(THIRDPARTY_TARGETS) +endif @touch $(THIRDPARTY) + everything: $(EVERYTHING_TARGETS) linecount: diff --git a/third_party/Makefile b/third_party/Makefile deleted file mode 100644 index 991d838715d..00000000000 --- a/third_party/Makefile +++ /dev/null @@ -1,17 +0,0 @@ -# Makefile for all third party libraries - -# NVidia CNMEM, https://github.com/NVIDIA/cnmem.git - -.PHONY: cnmem - -install: build - cp $(CNMEM_BUILD_DIR)/*.so* $(CAFFE_BUILD_DIR)/lib - -build : cnmem - -CNMEM_BUILD_DIR=./cnmem/build -cnmem: - $(MAKE) -C $(CNMEM_BUILD_DIR) DEBUG=$(DEBUG) - - - From 7d5d1cf52e9fad450ac2a0798dba65ca8104e5b2 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 20 Oct 2015 13:54:41 -0700 Subject: [PATCH 271/331] Fixing CUDNN options --- .travis.yml | 3 + 3rdparty/cnmem/build/Makefile | 208 ------------------------ Makefile | 13 ++ Makefile.config.example | 3 +- scripts/travis/travis_build_and_test.sh | 7 +- 5 files changed, 24 insertions(+), 210 deletions(-) delete mode 100644 3rdparty/cnmem/build/Makefile diff --git a/.travis.yml b/.travis.yml index 4dc7ed72d6c..174d851aa38 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,6 +8,9 @@ env: - WITH_CUDA=true WITH_CMAKE=true WITH_IO=true - WITH_CUDA=false WITH_CMAKE=false WITH_IO=false - WITH_CUDA=false WITH_CMAKE=true WITH_IO=false PYTHON_VERSION=3 +# Currently there is no way to install cudnn via apt-get. Uncomment wjen it's available. +# - WITH_CUDA=true WITH_CMAKE=false WITH_IO=true WITH_CUDNN=true +# - WITH_CUDA=true WITH_CMAKE=true WITH_IO=true WITH_CUDNN=true language: cpp diff --git a/3rdparty/cnmem/build/Makefile b/3rdparty/cnmem/build/Makefile deleted file mode 100644 index 9b2837a046c..00000000000 --- a/3rdparty/cnmem/build/Makefile +++ /dev/null @@ -1,208 +0,0 @@ -# CMAKE generated file: DO NOT EDIT! -# Generated by "Unix Makefiles" Generator, CMake Version 2.8 - -# Default target executed when no arguments are given to make. -default_target: all -.PHONY : default_target - -#============================================================================= -# Special targets provided by cmake. - -# Disable implicit rules so canonical targets will work. -.SUFFIXES: - -# Remove some rules from gmake that .SUFFIXES does not remove. -SUFFIXES = - -.SUFFIXES: .hpux_make_needs_suffix_list - -# Suppress display of executed commands. -$(VERBOSE).SILENT: - -# A target that is always out of date. -cmake_force: -.PHONY : cmake_force - -#============================================================================= -# Set environment variables for the build. - -# The shell in which to execute make rules. -SHELL = /bin/sh - -# The CMake executable. -CMAKE_COMMAND = /usr/bin/cmake - -# The command to remove a file. -RM = /usr/bin/cmake -E remove -f - -# Escaping for special characters. -EQUALS = = - -# The top-level source directory on which CMake was run. -CMAKE_SOURCE_DIR = /home/bfomitchev/git/float16/3rdparty/cnmem - -# The top-level build directory on which CMake was run. -CMAKE_BINARY_DIR = /home/bfomitchev/git/float16/3rdparty/cnmem/build - -#============================================================================= -# Targets provided globally by CMake. - -# Special rule for the target edit_cache -edit_cache: - @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running interactive CMake command-line interface..." - /usr/bin/cmake -i . -.PHONY : edit_cache - -# Special rule for the target edit_cache -edit_cache/fast: edit_cache -.PHONY : edit_cache/fast - -# Special rule for the target install -install: preinstall - @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..." - /usr/bin/cmake -P cmake_install.cmake -.PHONY : install - -# Special rule for the target install -install/fast: preinstall/fast - @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..." - /usr/bin/cmake -P cmake_install.cmake -.PHONY : install/fast - -# Special rule for the target install/local -install/local: preinstall - @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing only the local directory..." - /usr/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake -.PHONY : install/local - -# Special rule for the target install/local -install/local/fast: install/local -.PHONY : install/local/fast - -# Special rule for the target install/strip -install/strip: preinstall - @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing the project stripped..." - /usr/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake -.PHONY : install/strip - -# Special rule for the target install/strip -install/strip/fast: install/strip -.PHONY : install/strip/fast - -# Special rule for the target list_install_components -list_install_components: - @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Available install components are: \"Unspecified\"" -.PHONY : list_install_components - -# Special rule for the target list_install_components -list_install_components/fast: list_install_components -.PHONY : list_install_components/fast - -# Special rule for the target rebuild_cache -rebuild_cache: - @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..." - /usr/bin/cmake -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) -.PHONY : rebuild_cache - -# Special rule for the target rebuild_cache -rebuild_cache/fast: rebuild_cache -.PHONY : rebuild_cache/fast - -# The main all target -all: cmake_check_build_system - $(CMAKE_COMMAND) -E cmake_progress_start /home/bfomitchev/git/float16/3rdparty/cnmem/build/CMakeFiles /home/bfomitchev/git/float16/3rdparty/cnmem/build/CMakeFiles/progress.marks - $(MAKE) -f CMakeFiles/Makefile2 all - $(CMAKE_COMMAND) -E cmake_progress_start /home/bfomitchev/git/float16/3rdparty/cnmem/build/CMakeFiles 0 -.PHONY : all - -# The main clean target -clean: - $(MAKE) -f CMakeFiles/Makefile2 clean -.PHONY : clean - -# The main clean target -clean/fast: clean -.PHONY : clean/fast - -# Prepare targets for installation. -preinstall: all - $(MAKE) -f CMakeFiles/Makefile2 preinstall -.PHONY : preinstall - -# Prepare targets for installation. -preinstall/fast: - $(MAKE) -f CMakeFiles/Makefile2 preinstall -.PHONY : preinstall/fast - -# clear depends -depend: - $(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1 -.PHONY : depend - -#============================================================================= -# Target rules for targets named cnmem - -# Build rule for target. -cnmem: cmake_check_build_system - $(MAKE) -f CMakeFiles/Makefile2 cnmem -.PHONY : cnmem - -# fast build rule for target. -cnmem/fast: - $(MAKE) -f CMakeFiles/cnmem.dir/build.make CMakeFiles/cnmem.dir/build -.PHONY : cnmem/fast - -src/cnmem.o: src/cnmem.cpp.o -.PHONY : src/cnmem.o - -# target to build an object file -src/cnmem.cpp.o: - $(MAKE) -f CMakeFiles/cnmem.dir/build.make CMakeFiles/cnmem.dir/src/cnmem.cpp.o -.PHONY : src/cnmem.cpp.o - -src/cnmem.i: src/cnmem.cpp.i -.PHONY : src/cnmem.i - -# target to preprocess a source file -src/cnmem.cpp.i: - $(MAKE) -f CMakeFiles/cnmem.dir/build.make CMakeFiles/cnmem.dir/src/cnmem.cpp.i -.PHONY : src/cnmem.cpp.i - -src/cnmem.s: src/cnmem.cpp.s -.PHONY : src/cnmem.s - -# target to generate assembly for a file -src/cnmem.cpp.s: - $(MAKE) -f CMakeFiles/cnmem.dir/build.make CMakeFiles/cnmem.dir/src/cnmem.cpp.s -.PHONY : src/cnmem.cpp.s - -# Help Target -help: - @echo "The following are some of the valid targets for this Makefile:" - @echo "... all (the default if no target is provided)" - @echo "... clean" - @echo "... depend" - @echo "... cnmem" - @echo "... edit_cache" - @echo "... install" - @echo "... install/local" - @echo "... install/strip" - @echo "... list_install_components" - @echo "... rebuild_cache" - @echo "... src/cnmem.o" - @echo "... src/cnmem.i" - @echo "... src/cnmem.s" -.PHONY : help - - - -#============================================================================= -# Special targets to cleanup operation of make. - -# Special rule to run CMake to check the build system integrity. -# No rule that depends on this can have commands that come from listfiles -# because they might be regenerated. -cmake_check_build_system: - $(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 -.PHONY : cmake_check_build_system - diff --git a/Makefile b/Makefile index 06d84a82e07..5e3393eb92b 100644 --- a/Makefile +++ b/Makefile @@ -7,6 +7,19 @@ $(error $(CONFIG_FILE) not found. See $(CONFIG_FILE).example.) endif include $(CONFIG_FILE) +# Rectify input parameters +ifeq ($(CPU_ONLY),1) + USE_CUDNN=0 + USE_CNMEM=0 +endif + +ifeq ($(USE_CUDNN),1) +# CNMEM is ON by default in CUDNN is ON + ifeq ($(USE_CNMEM),) + USE_CNMEM=1 + endif +endif + PROJECT_DIR=$(PWD) BUILD_DIR_LINK := $(BUILD_DIR) diff --git a/Makefile.config.example b/Makefile.config.example index 8c8731e226f..ecbd31b09cd 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -3,7 +3,8 @@ # cuDNN acceleration switch (uncomment to build with cuDNN). # USE_CUDNN := 1 -# CNMeM memory pool switch (github.com/NVIDIA/cnmem required) + +# CNMeM memory pool switch (experimental, may go away) # USE_CNMEM := 1 # CPU-only switch (uncomment to build without GPU support). diff --git a/scripts/travis/travis_build_and_test.sh b/scripts/travis/travis_build_and_test.sh index 174f1ee5a0a..7f97fc632ab 100755 --- a/scripts/travis/travis_build_and_test.sh +++ b/scripts/travis/travis_build_and_test.sh @@ -12,6 +12,11 @@ if $WITH_CMAKE; then if ! $WITH_CUDA; then CPU_ONLY=" -DCPU_ONLY=OFF" fi + + if $WITH_CUDNN; then + CUDNN_ARGS=" -DUSE_CUDNN=ON " + fi + PYTHON_ARGS="" if [ "$PYTHON_VERSION" = "3" ]; then PYTHON_ARGS="$PYTHON_ARGS -Dpython_version=3 -DBOOST_LIBRARYDIR=$CONDA_DIR/lib/" @@ -21,7 +26,7 @@ if $WITH_CMAKE; then else IO_ARGS="-DUSE_OPENCV=OFF -DUSE_LMDB=OFF -DUSE_LEVELDB=OFF" fi - cmake -DBUILD_python=ON -DCMAKE_BUILD_TYPE=Release $CPU_ONLY $PYTHON_ARGS -DCMAKE_INCLUDE_PATH="$CONDA_DIR/include/" -DCMAKE_LIBRARY_PATH="$CONDA_DIR/lib/" $IO_ARGS .. + cmake -DBUILD_python=ON -DCMAKE_BUILD_TYPE=Release $CPU_ONLY $CUDNN_ARGS $PYTHON_ARGS -DCMAKE_INCLUDE_PATH="$CONDA_DIR/include/" -DCMAKE_LIBRARY_PATH="$CONDA_DIR/lib/" $IO_ARGS .. $MAKE $MAKE pytest if ! $WITH_CUDA; then From e19183008aeaf27c4d602be96269c299f3e24e68 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 20 Oct 2015 16:15:06 -0700 Subject: [PATCH 272/331] Cleanup for PR submission --- .travis.yml | 2 +- README.md | 2 -- docs/tutorial/layers.md | 3 +-- src/caffe/common.cpp | 1 + 4 files changed, 3 insertions(+), 5 deletions(-) diff --git a/.travis.yml b/.travis.yml index 174d851aa38..a71ebf7cae0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,7 +8,7 @@ env: - WITH_CUDA=true WITH_CMAKE=true WITH_IO=true - WITH_CUDA=false WITH_CMAKE=false WITH_IO=false - WITH_CUDA=false WITH_CMAKE=true WITH_IO=false PYTHON_VERSION=3 -# Currently there is no way to install cudnn via apt-get. Uncomment wjen it's available. +# Currently there is no way to install cudnn via apt-get. Uncomment when it's available. # - WITH_CUDA=true WITH_CMAKE=false WITH_IO=true WITH_CUDNN=true # - WITH_CUDA=true WITH_CMAKE=true WITH_IO=true WITH_CUDNN=true diff --git a/README.md b/README.md index 44b9e62c157..2df22522e32 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,5 @@ # Caffe -[![Build Status](https://travis-ci.org/BVLC/caffe.svg?branch=master)](https://travis-ci.org/BVLC/caffe) -[![License](https://img.shields.io/badge/license-BSD-blue.svg)](LICENSE) Caffe is a deep learning framework made with expression, speed, and modularity in mind. It is developed by the Berkeley Vision and Learning Center ([BVLC](http://bvlc.eecs.berkeley.edu)) and community contributors. diff --git a/docs/tutorial/layers.md b/docs/tutorial/layers.md index 7362aac298a..a91371074f7 100644 --- a/docs/tutorial/layers.md +++ b/docs/tutorial/layers.md @@ -39,8 +39,7 @@ In contrast, other layers (with few exceptions) ignore the spatial structure of - `n * c_i * h_i * w_i` * Output - `n * c_o * h_o * w_o`, where `h_o = (h_i + 2 * pad_h - kernel_h) / stride_h + 1` and `w_o` likewise. -* Sample (as seen in `./models/bvlc_reference_caffenet/train_val.prototxt`) - +* Sample (as seen in `./examples/imagenet/imagenet_train_val.prototxt`) layer { name: "conv1" type: "Convolution" diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index ad3960bc75f..3d6418f5992 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -297,3 +297,4 @@ const char* curandGetErrorString(curandStatus_t error) { #endif // CPU_ONLY } // namespace caffe + From 0792af7dc186eff0bfefff3401acdade0874813a Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 20 Oct 2015 16:16:50 -0700 Subject: [PATCH 273/331] Removed submodules remainders --- .gitmodules | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 .gitmodules diff --git a/.gitmodules b/.gitmodules deleted file mode 100644 index e69de29bb2d..00000000000 From f43208512341fbfece45e5fb0c5684301625d9da Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Tue, 20 Oct 2015 18:18:39 -0700 Subject: [PATCH 274/331] Mark v0.14.0-beta --- CMakeLists.txt | 2 +- Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 51cda90cd3a..a0ba9bd0a76 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8.7) project(Caffe C CXX) # ---[ Caffe version -set(CAFFE_TARGET_VERSION "0.14.0-alpha") +set(CAFFE_TARGET_VERSION "0.14.0-beta") set(CAFFE_TARGET_SOVERSION "0.14") add_definitions(-DCAFFE_VERSION=${CAFFE_TARGET_VERSION}) diff --git a/Makefile b/Makefile index f3f0542bafa..b99ca3d751b 100644 --- a/Makefile +++ b/Makefile @@ -52,7 +52,7 @@ LIB_BUILD_DIR := $(BUILD_DIR)/lib STATIC_NAME := $(LIB_BUILD_DIR)/lib$(LIBRARY_NAME).a DYNAMIC_VERSION_MAJOR := 0 DYNAMIC_VERSION_MINOR := 14 -DYNAMIC_VERSION_REVISION := 0-alpha +DYNAMIC_VERSION_REVISION := 0-beta DYNAMIC_NAME_SHORT := lib$(LIBRARY_NAME).so DYNAMIC_SONAME_SHORT := $(DYNAMIC_NAME_SHORT).$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR) DYNAMIC_VERSIONED_NAME_SHORT := $(DYNAMIC_SONAME_SHORT).$(DYNAMIC_VERSION_REVISION) From c3cb945b458c8c526da85f2a9fa95344a8ce891a Mon Sep 17 00:00:00 2001 From: sh1r0 Date: Fri, 9 Oct 2015 00:31:05 +0800 Subject: [PATCH 275/331] Remove the 4D constraint of blobproto IO in python --- python/caffe/io.py | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/python/caffe/io.py b/python/caffe/io.py index 0cad7211291..40b7ac1ed78 100644 --- a/python/caffe/io.py +++ b/python/caffe/io.py @@ -21,22 +21,18 @@ def blobproto_to_array(blob, return_diff=False): unless return_diff is True, in which case we will return the diff. """ if return_diff: - return np.array(blob.diff).reshape( - blob.num, blob.channels, blob.height, blob.width) + return np.array(blob.diff).reshape(*blob.shape.dim) else: - return np.array(blob.data).reshape( - blob.num, blob.channels, blob.height, blob.width) + return np.array(blob.data).reshape(*blob.shape.dim) def array_to_blobproto(arr, diff=None): - """Converts a 4-dimensional array to blob proto. If diff is given, also + """Converts a N-dimensional array to blob proto. If diff is given, also convert the diff. You need to make sure that arr and diff have the same shape, and this function does not do sanity check. """ - if arr.ndim != 4: - raise ValueError('Incorrect array shape.') blob = caffe_pb2.BlobProto() - blob.num, blob.channels, blob.height, blob.width = arr.shape + blob.shape.dim.extend(arr.shape) blob.data.extend(arr.astype(float).flat) if diff is not None: blob.diff.extend(diff.astype(float).flat) From a0ac9057ad8ed91b3846aed475ae9ccaf7245bae Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 15 Oct 2015 11:03:09 -0700 Subject: [PATCH 276/331] Allow old-style shape in blobproto_to_array Fixes #3199 Bug introduced in #3170 --- python/caffe/io.py | 11 ++++++++-- python/caffe/test/test_io.py | 41 ++++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+), 2 deletions(-) create mode 100644 python/caffe/test/test_io.py diff --git a/python/caffe/io.py b/python/caffe/io.py index 40b7ac1ed78..11c84260f1a 100644 --- a/python/caffe/io.py +++ b/python/caffe/io.py @@ -20,11 +20,18 @@ def blobproto_to_array(blob, return_diff=False): Convert a blob proto to an array. In default, we will just return the data, unless return_diff is True, in which case we will return the diff. """ + # Read the data into an array if return_diff: - return np.array(blob.diff).reshape(*blob.shape.dim) + data = np.array(blob.diff) else: - return np.array(blob.data).reshape(*blob.shape.dim) + data = np.array(blob.data) + # Reshape the array + if blob.HasField('num') or blob.HasField('channels') or blob.HasField('height') or blob.HasField('width'): + # Use legacy 4D shape + return data.reshape(blob.num, blob.channels, blob.height, blob.width) + else: + return data.reshape(blob.shape.dim) def array_to_blobproto(arr, diff=None): """Converts a N-dimensional array to blob proto. If diff is given, also diff --git a/python/caffe/test/test_io.py b/python/caffe/test/test_io.py new file mode 100644 index 00000000000..8c86ef75fb2 --- /dev/null +++ b/python/caffe/test/test_io.py @@ -0,0 +1,41 @@ +import numpy as np +import unittest + +import caffe + +class TestBlobProtoToArray(unittest.TestCase): + + def test_old_format(self): + data = np.zeros((10,10)) + blob = caffe.proto.caffe_pb2.BlobProto() + blob.data.extend(list(data.flatten())) + shape = (1,1,10,10) + blob.num, blob.channels, blob.height, blob.width = shape + + arr = caffe.io.blobproto_to_array(blob) + self.assertEqual(arr.shape, shape) + + def test_new_format(self): + data = np.zeros((10,10)) + blob = caffe.proto.caffe_pb2.BlobProto() + blob.data.extend(list(data.flatten())) + blob.shape.dim.extend(list(data.shape)) + + arr = caffe.io.blobproto_to_array(blob) + self.assertEqual(arr.shape, data.shape) + + def test_no_shape(self): + data = np.zeros((10,10)) + blob = caffe.proto.caffe_pb2.BlobProto() + blob.data.extend(list(data.flatten())) + + with self.assertRaises(ValueError): + caffe.io.blobproto_to_array(blob) + + def test_scalar(self): + data = np.ones((1)) * 123 + blob = caffe.proto.caffe_pb2.BlobProto() + blob.data.extend(list(data.flatten())) + + arr = caffe.io.blobproto_to_array(blob) + self.assertEqual(arr, 123) From d2c063cfdc9444b93a20ca99645dbc8726bde118 Mon Sep 17 00:00:00 2001 From: Vladimir Date: Wed, 14 Oct 2015 12:00:14 +0900 Subject: [PATCH 277/331] Fixed drawing problems with repeated convolution --- python/caffe/draw.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/python/caffe/draw.py b/python/caffe/draw.py index a002b60b59a..f8bf5722aba 100644 --- a/python/caffe/draw.py +++ b/python/caffe/draw.py @@ -82,11 +82,11 @@ def get_layer_label(layer, rankdir): separator, layer.type, separator, - layer.convolution_param.kernel_size, + layer.convolution_param.kernel_size[0] if len(layer.convolution_param.kernel_size._values) else 1, separator, - layer.convolution_param.stride, + layer.convolution_param.stride[0] if len(layer.convolution_param.stride._values) else 1, separator, - layer.convolution_param.pad) + layer.convolution_param.pad[0] if len(layer.convolution_param.pad._values) else 0) elif layer.type == 'Pooling': pooling_types_dict = get_pooling_types_dict() node_label = '"%s%s(%s %s)%skernel size: %d%sstride: %d%spad: %d"' %\ From 61379dcee0a1df248ceefc043de9a1e2cf89e691 Mon Sep 17 00:00:00 2001 From: Evan Shelhamer Date: Fri, 16 Oct 2015 17:32:27 -0700 Subject: [PATCH 278/331] clean up logging for Net init - condense conditions by `LOG_IF` - only log memory use once after all tops --- src/caffe/net.cpp | 182 +++++++++++++++++++--------------------------- 1 file changed, 76 insertions(+), 106 deletions(-) diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index ebb8b5d28c2..1ad93e6af5f 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -46,10 +46,9 @@ void Net::Init(const NetParameter& in_param) { // the current NetState. NetParameter filtered_param; FilterNet(in_param, &filtered_param); - if (Caffe::root_solver()) { - LOG(INFO) << "Initializing net from parameters: " << std::endl - << filtered_param.DebugString(); - } + LOG_IF(INFO, Caffe::root_solver()) + << "Initializing net from parameters: " << std::endl + << filtered_param.DebugString(); // Create a copy of filtered_param with splits added where necessary. NetParameter param; InsertSplits(filtered_param, ¶m); @@ -73,8 +72,6 @@ void Net::Init(const NetParameter& in_param) { const int layer_id = -1; // inputs have fake layer ID -1 AppendTop(param, layer_id, input_id, &available_blobs, &blob_name_to_idx); } - DLOG_IF(INFO, Caffe::root_solver()) - << "Memory required for data: " << memory_used_ * sizeof(Dtype); // For each layer, set up its input and output bottom_vecs_.resize(param.layer_size()); top_vecs_.resize(param.layer_size()); @@ -106,9 +103,8 @@ void Net::Init(const NetParameter& in_param) { layers_.push_back(LayerRegistry::CreateLayer(layer_param)); } layer_names_.push_back(layer_param.name()); - if (Caffe::root_solver()) { - LOG(INFO) << "Creating Layer " << layer_param.name(); - } + LOG_IF(INFO, Caffe::root_solver()) + << "Creating Layer " << layer_param.name(); bool need_backward = false; // Figure out this layer's input and output @@ -151,29 +147,23 @@ void Net::Init(const NetParameter& in_param) { } else { layers_[layer_id]->SetUp(bottom_vecs_[layer_id], top_vecs_[layer_id]); } - if (Caffe::root_solver()) { - LOG(INFO) << "Setting up " << layer_names_[layer_id]; - } + LOG_IF(INFO, Caffe::root_solver()) + << "Setting up " << layer_names_[layer_id]; for (int top_id = 0; top_id < top_vecs_[layer_id].size(); ++top_id) { if (blob_loss_weights_.size() <= top_id_vecs_[layer_id][top_id]) { blob_loss_weights_.resize(top_id_vecs_[layer_id][top_id] + 1, Dtype(0)); } blob_loss_weights_[top_id_vecs_[layer_id][top_id]] = layer->loss(top_id); - if (Caffe::root_solver()) { - LOG(INFO) << "Top shape: " - << top_vecs_[layer_id][top_id]->shape_string(); - } + LOG_IF(INFO, Caffe::root_solver()) + << "Top shape: " << top_vecs_[layer_id][top_id]->shape_string(); if (layer->loss(top_id)) { - if (Caffe::root_solver()) { - LOG(INFO) << " with loss weight " << layer->loss(top_id); - } + LOG_IF(INFO, Caffe::root_solver()) + << " with loss weight " << layer->loss(top_id); } memory_used_ += top_vecs_[layer_id][top_id]->count(); } - if (Caffe::root_solver()) { - DLOG(INFO) << "Memory required for data: " - << memory_used_ * sizeof(Dtype); - } + LOG_IF(INFO, Caffe::root_solver()) + << "Memory required for data: " << memory_used_ * sizeof(Dtype); const int param_size = layer_param.param_size(); const int num_param_blobs = layers_[layer_id]->blobs().size(); CHECK_LE(param_size, num_param_blobs) @@ -231,14 +221,12 @@ void Net::Init(const NetParameter& in_param) { } } if (!layer_contributes_loss) { layer_need_backward_[layer_id] = false; } - if (layer_need_backward_[layer_id]) { - if (Caffe::root_solver()) { + if (Caffe::root_solver()) { + if (layer_need_backward_[layer_id]) { LOG(INFO) << layer_names_[layer_id] << " needs backward computation."; - } - } else { - if (Caffe::root_solver()) { + } else { LOG(INFO) << layer_names_[layer_id] - << " does not need backward computation."; + << " does not need backward computation."; } } for (int bottom_id = 0; bottom_id < bottom_vecs_[layer_id].size(); @@ -279,9 +267,8 @@ void Net::Init(const NetParameter& in_param) { // In the end, all remaining blobs are considered output blobs. for (set::iterator it = available_blobs.begin(); it != available_blobs.end(); ++it) { - if (Caffe::root_solver()) { - LOG(INFO) << "This network produces output " << *it; - } + LOG_IF(INFO, Caffe::root_solver()) + << "This network produces output " << *it; net_output_blobs_.push_back(blobs_[blob_name_to_idx[*it]].get()); net_output_blob_indices_.push_back(blob_name_to_idx[*it]); } @@ -293,10 +280,7 @@ void Net::Init(const NetParameter& in_param) { } ShareWeights(); debug_info_ = param.debug_info(); - if (Caffe::root_solver()) { - LOG(INFO) << "Network initialization done."; - LOG(INFO) << "Memory required for data: " << memory_used_ * sizeof(Dtype); - } + LOG_IF(INFO, Caffe::root_solver()) << "Network initialization done."; } template @@ -335,33 +319,30 @@ bool Net::StateMeetsRule(const NetState& state, // Check whether the rule is broken due to phase. if (rule.has_phase()) { if (rule.phase() != state.phase()) { - if (Caffe::root_solver()) { - LOG(INFO) << "The NetState phase (" << state.phase() - << ") differed from the phase (" << rule.phase() - << ") specified by a rule in layer " << layer_name; - } + LOG_IF(INFO, Caffe::root_solver()) + << "The NetState phase (" << state.phase() + << ") differed from the phase (" << rule.phase() + << ") specified by a rule in layer " << layer_name; return false; } } // Check whether the rule is broken due to min level. if (rule.has_min_level()) { if (state.level() < rule.min_level()) { - if (Caffe::root_solver()) { - LOG(INFO) << "The NetState level (" << state.level() - << ") is above the min_level (" << rule.min_level() - << ") specified by a rule in layer " << layer_name; - } + LOG_IF(INFO, Caffe::root_solver()) + << "The NetState level (" << state.level() + << ") is above the min_level (" << rule.min_level() + << ") specified by a rule in layer " << layer_name; return false; } } // Check whether the rule is broken due to max level. if (rule.has_max_level()) { if (state.level() > rule.max_level()) { - if (Caffe::root_solver()) { - LOG(INFO) << "The NetState level (" << state.level() - << ") is above the max_level (" << rule.max_level() - << ") specified by a rule in layer " << layer_name; - } + LOG_IF(INFO, Caffe::root_solver()) + << "The NetState level (" << state.level() + << ") is above the max_level (" << rule.max_level() + << ") specified by a rule in layer " << layer_name; return false; } } @@ -374,10 +355,9 @@ bool Net::StateMeetsRule(const NetState& state, if (rule.stage(i) == state.stage(j)) { has_stage = true; } } if (!has_stage) { - if (Caffe::root_solver()) { - LOG(INFO) << "The NetState did not contain stage '" << rule.stage(i) - << "' specified by a rule in layer " << layer_name; - } + LOG_IF(INFO, Caffe::root_solver()) + << "The NetState did not contain stage '" << rule.stage(i) + << "' specified by a rule in layer " << layer_name; return false; } } @@ -390,10 +370,9 @@ bool Net::StateMeetsRule(const NetState& state, if (rule.not_stage(i) == state.stage(j)) { has_stage = true; } } if (has_stage) { - if (Caffe::root_solver()) { - LOG(INFO) << "The NetState contained a not_stage '" << rule.not_stage(i) - << "' specified by a rule in layer " << layer_name; - } + LOG_IF(INFO, Caffe::root_solver()) + << "The NetState contained a not_stage '" << rule.not_stage(i) + << "' specified by a rule in layer " << layer_name; return false; } } @@ -415,9 +394,8 @@ void Net::AppendTop(const NetParameter& param, const int layer_id, if (blob_name_to_idx && layer_param && layer_param->bottom_size() > top_id && blob_name == layer_param->bottom(top_id)) { // In-place computation - if (Caffe::root_solver()) { - LOG(INFO) << layer_param->name() << " -> " << blob_name << " (in-place)"; - } + LOG_IF(INFO, Caffe::root_solver()) + << layer_param->name() << " -> " << blob_name << " (in-place)"; top_vecs_[layer_id].push_back(blobs_[(*blob_name_to_idx)[blob_name]].get()); top_id_vecs_[layer_id].push_back((*blob_name_to_idx)[blob_name]); } else if (blob_name_to_idx && @@ -473,9 +451,8 @@ int Net::AppendBottom(const NetParameter& param, const int layer_id, << layer_param.name() << "', bottom index " << bottom_id << ")"; } const int blob_id = (*blob_name_to_idx)[blob_name]; - if (Caffe::root_solver()) { - LOG(INFO) << layer_names_[layer_id] << " <- " << blob_name; - } + LOG_IF(INFO, Caffe::root_solver()) + << layer_names_[layer_id] << " <- " << blob_name; bottom_vecs_[layer_id].push_back(blobs_[blob_id].get()); bottom_id_vecs_[layer_id].push_back(blob_id); available_blobs->erase(blob_name); @@ -672,10 +649,9 @@ void Net::InputDebugInfo(const int input_id) { const Blob& blob = *net_input_blobs_[input_id]; const string& blob_name = blob_names_[net_input_blob_indices_[input_id]]; const Dtype data_abs_val_mean = blob.asum_data() / blob.count(); - if (Caffe::root_solver()) { - LOG(INFO) << " [Forward] " - << "Input " << blob_name << " data: " << data_abs_val_mean; - } + LOG_IF(INFO, Caffe::root_solver()) + << " [Forward] " + << "Input " << blob_name << " data: " << data_abs_val_mean; } template @@ -684,12 +660,11 @@ void Net::ForwardDebugInfo(const int layer_id) { const Blob& blob = *top_vecs_[layer_id][top_id]; const string& blob_name = blob_names_[top_id_vecs_[layer_id][top_id]]; const Dtype data_abs_val_mean = blob.asum_data() / blob.count(); - if (Caffe::root_solver()) { - LOG(INFO) << " [Forward] " - << "Layer " << layer_names_[layer_id] - << ", top blob " << blob_name - << " data: " << data_abs_val_mean; - } + LOG_IF(INFO, Caffe::root_solver()) + << " [Forward] " + << "Layer " << layer_names_[layer_id] + << ", top blob " << blob_name + << " data: " << data_abs_val_mean; } for (int param_id = 0; param_id < layers_[layer_id]->blobs().size(); ++param_id) { @@ -697,12 +672,11 @@ void Net::ForwardDebugInfo(const int layer_id) { const int net_param_id = param_id_vecs_[layer_id][param_id]; const string& blob_name = param_display_names_[net_param_id]; const Dtype data_abs_val_mean = blob.asum_data() / blob.count(); - if (Caffe::root_solver()) { - LOG(INFO) << " [Forward] " - << "Layer " << layer_names_[layer_id] - << ", param blob " << blob_name - << " data: " << data_abs_val_mean; - } + LOG_IF(INFO, Caffe::root_solver()) + << " [Forward] " + << "Layer " << layer_names_[layer_id] + << ", param blob " << blob_name + << " data: " << data_abs_val_mean; } } @@ -714,24 +688,22 @@ void Net::BackwardDebugInfo(const int layer_id) { const Blob& blob = *bottom_vec[bottom_id]; const string& blob_name = blob_names_[bottom_id_vecs_[layer_id][bottom_id]]; const Dtype diff_abs_val_mean = blob.asum_diff() / blob.count(); - if (Caffe::root_solver()) { - LOG(INFO) << " [Backward] " - << "Layer " << layer_names_[layer_id] - << ", bottom blob " << blob_name - << " diff: " << diff_abs_val_mean; - } + LOG_IF(INFO, Caffe::root_solver()) + << " [Backward] " + << "Layer " << layer_names_[layer_id] + << ", bottom blob " << blob_name + << " diff: " << diff_abs_val_mean; } for (int param_id = 0; param_id < layers_[layer_id]->blobs().size(); ++param_id) { if (!layers_[layer_id]->param_propagate_down(param_id)) { continue; } const Blob& blob = *layers_[layer_id]->blobs()[param_id]; const Dtype diff_abs_val_mean = blob.asum_diff() / blob.count(); - if (Caffe::root_solver()) { - LOG(INFO) << " [Backward] " - << "Layer " << layer_names_[layer_id] - << ", param blob " << param_id - << " diff: " << diff_abs_val_mean; - } + LOG_IF(INFO, Caffe::root_solver()) + << " [Backward] " + << "Layer " << layer_names_[layer_id] + << ", param blob " << param_id + << " diff: " << diff_abs_val_mean; } } @@ -744,22 +716,20 @@ void Net::UpdateDebugInfo(const int param_id) { const Dtype diff_abs_val_mean = blob.asum_diff() / blob.count(); if (param_owner < 0) { const Dtype data_abs_val_mean = blob.asum_data() / blob.count(); - if (Caffe::root_solver()) { - LOG(INFO) << " [Update] Layer " << layer_name - << ", param " << param_display_name - << " data: " << data_abs_val_mean - << "; diff: " << diff_abs_val_mean; - } + LOG_IF(INFO, Caffe::root_solver()) + << " [Update] Layer " << layer_name + << ", param " << param_display_name + << " data: " << data_abs_val_mean + << "; diff: " << diff_abs_val_mean; } else { const string& owner_layer_name = layer_names_[param_layer_indices_[param_owner].first]; - if (Caffe::root_solver()) { - LOG(INFO) << " [Update] Layer " << layer_name - << ", param blob " << param_display_name - << " (owned by layer " << owner_layer_name << ", " << "param " - << param_display_names_[param_owners_[param_id]] << ")" - << " diff: " << diff_abs_val_mean; - } + LOG_IF(INFO, Caffe::root_solver()) + << " [Update] Layer " << layer_name + << ", param blob " << param_display_name + << " (owned by layer " << owner_layer_name << ", " << "param " + << param_display_names_[param_owners_[param_id]] << ")" + << " diff: " << diff_abs_val_mean; } } From b1e2caf9bbeffbc228bfa9fa9bdb1dc2a1e8cdd6 Mon Sep 17 00:00:00 2001 From: "T.E.A de Souza" Date: Mon, 19 Oct 2015 18:19:38 +0800 Subject: [PATCH 279/331] Qualify messages issued by CMake when CUDA is unavailable --- cmake/Dependencies.cmake | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake index d68d7bfba66..2005b9927b8 100644 --- a/cmake/Dependencies.cmake +++ b/cmake/Dependencies.cmake @@ -55,9 +55,9 @@ endif() include(cmake/Cuda.cmake) if(NOT HAVE_CUDA) if(CPU_ONLY) - message("-- CUDA is disabled. Building without it...") + message(STATUS "-- CUDA is disabled. Building without it...") else() - message("-- CUDA is not detected by cmake. Building without it...") + message(WARNING "-- CUDA is not detected by cmake. Building without it...") endif() # TODO: remove this not cross platform define in future. Use caffe_config.h instead. From 6f57970a139e60e11e5910eae547c723e1dd74b3 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Fri, 25 Sep 2015 15:43:47 -0700 Subject: [PATCH 280/331] Re-ordering some lines in build files Enforcing a consistent ordering - OpenCV, LevelDB, LMDB This will allow me to add the ALLOW_LMDB_NOLOCK option just after the USE_LMDB option, while keeping the IO dependency options together. --- CMakeLists.txt | 4 ++-- Makefile.config.example | 2 +- cmake/Summary.cmake | 4 ++-- cmake/Templates/caffe_config.h.in | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index a0ba9bd0a76..9a4ebae3ccb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,9 +29,9 @@ set(python_version "2" CACHE STRING "Specify which Python version to use") caffe_option(BUILD_matlab "Build Matlab wrapper" OFF IF UNIX OR APPLE) caffe_option(BUILD_docs "Build documentation" ON IF UNIX OR APPLE) caffe_option(BUILD_python_layer "Build the Caffe Python layer" ON) -caffe_option(USE_LMDB "Build with lmdb" ON) -caffe_option(USE_LEVELDB "Build with levelDB" ON) caffe_option(USE_OPENCV "Build with OpenCV support" ON) +caffe_option(USE_LEVELDB "Build with levelDB" ON) +caffe_option(USE_LMDB "Build with lmdb" ON) # ---[ Dependencies include(cmake/Dependencies.cmake) diff --git a/Makefile.config.example b/Makefile.config.example index a2540bb0c2b..bdd60ba2098 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -11,9 +11,9 @@ # CPU_ONLY := 1 # uncomment to disable IO dependencies and corresponding data layers +# USE_OPENCV := 0 # USE_LEVELDB := 0 # USE_LMDB := 0 -# USE_OPENCV := 0 # To customize your choice of compiler, uncomment and set the following. # N.B. the default for Linux is g++ and the default for OSX is clang++ diff --git a/cmake/Summary.cmake b/cmake/Summary.cmake index 0d8d080d11f..8b4b8ca244d 100644 --- a/cmake/Summary.cmake +++ b/cmake/Summary.cmake @@ -114,9 +114,9 @@ function(caffe_print_configuration_summary) caffe_status(" BUILD_matlab : ${BUILD_matlab}") caffe_status(" BUILD_docs : ${BUILD_docs}") caffe_status(" CPU_ONLY : ${CPU_ONLY}") - caffe_status(" USE_LMDB : ${USE_LMDB}") - caffe_status(" USE_LEVELDB : ${USE_LEVELDB}") caffe_status(" USE_OPENCV : ${USE_OPENCV}") + caffe_status(" USE_LEVELDB : ${USE_LEVELDB}") + caffe_status(" USE_LMDB : ${USE_LMDB}") caffe_status("") caffe_status("Dependencies:") caffe_status(" BLAS : " APPLE THEN "Yes (vecLib)" ELSE "Yes (${BLAS})") diff --git a/cmake/Templates/caffe_config.h.in b/cmake/Templates/caffe_config.h.in index 2a0185cdc39..6b7f7e505d8 100644 --- a/cmake/Templates/caffe_config.h.in +++ b/cmake/Templates/caffe_config.h.in @@ -37,5 +37,5 @@ /* IO libraries */ #cmakedefine USE_OPENCV -#cmakedefine USE_LMDB #cmakedefine USE_LEVELDB +#cmakedefine USE_LMDB From 749a63679779203c74bc5fce782897545061ba82 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Fri, 25 Sep 2015 15:53:54 -0700 Subject: [PATCH 281/331] Add ALLOW_LMDB_NOLOCK build option This option lets you open LMDB files with the MDB_NOLOCK flag. You should not set this flag if you will be reading LMDBs with any possibility of simultaneous read and write. --- CMakeLists.txt | 1 + Makefile | 3 +++ Makefile.config.example | 5 +++++ cmake/ConfigGen.cmake | 3 +++ cmake/Dependencies.cmake | 3 +++ cmake/Summary.cmake | 1 + cmake/Templates/caffe_config.h.in | 1 + src/caffe/util/db_lmdb.cpp | 17 ++++++++++++++++- 8 files changed, 33 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9a4ebae3ccb..b1bb1a8b42a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -32,6 +32,7 @@ caffe_option(BUILD_python_layer "Build the Caffe Python layer" ON) caffe_option(USE_OPENCV "Build with OpenCV support" ON) caffe_option(USE_LEVELDB "Build with levelDB" ON) caffe_option(USE_LMDB "Build with lmdb" ON) +caffe_option(ALLOW_LMDB_NOLOCK "Allow MDB_NOLOCK when reading LMDB files (only if necessary)" OFF) # ---[ Dependencies include(cmake/Dependencies.cmake) diff --git a/Makefile b/Makefile index b99ca3d751b..a1fc925e40b 100644 --- a/Makefile +++ b/Makefile @@ -353,6 +353,9 @@ ifeq ($(USE_LEVELDB), 1) endif ifeq ($(USE_LMDB), 1) COMMON_FLAGS += -DUSE_LMDB +ifeq ($(ALLOW_LMDB_NOLOCK), 1) + COMMON_FLAGS += -DALLOW_LMDB_NOLOCK +endif endif # CPU-only configuration diff --git a/Makefile.config.example b/Makefile.config.example index bdd60ba2098..156a1828dc6 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -15,6 +15,11 @@ # USE_LEVELDB := 0 # USE_LMDB := 0 +# uncomment to allow MDB_NOLOCK when reading LMDB files (only if necessary) +# You should not set this flag if you will be reading LMDBs with any +# possibility of simultaneous read and write +# ALLOW_LMDB_NOLOCK := 1 + # To customize your choice of compiler, uncomment and set the following. # N.B. the default for Linux is g++ and the default for OSX is clang++ # CUSTOM_CXX := g++ diff --git a/cmake/ConfigGen.cmake b/cmake/ConfigGen.cmake index 373cc452ef1..f0bff4eba32 100644 --- a/cmake/ConfigGen.cmake +++ b/cmake/ConfigGen.cmake @@ -62,6 +62,9 @@ function(caffe_generate_export_configs) if(USE_LMDB) list(APPEND Caffe_DEFINITIONS -DUSE_LMDB) + if (ALLOW_LMDB_NOLOCK) + list(APPEND Caffe_DEFINITIONS -DALLOW_LMDB_NOLOCK) + endif() endif() if(USE_LEVELDB) diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake index 2005b9927b8..5651e2b086d 100644 --- a/cmake/Dependencies.cmake +++ b/cmake/Dependencies.cmake @@ -34,6 +34,9 @@ if(USE_LMDB) include_directories(SYSTEM ${LMDB_INCLUDE_DIR}) list(APPEND Caffe_LINKER_LIBS ${LMDB_LIBRARIES}) add_definitions(-DUSE_LMDB) + if(ALLOW_LMDB_NOLOCK) + add_definitions(-DALLOW_LMDB_NOLOCK) + endif() endif() # ---[ LevelDB diff --git a/cmake/Summary.cmake b/cmake/Summary.cmake index 8b4b8ca244d..f9e4a498063 100644 --- a/cmake/Summary.cmake +++ b/cmake/Summary.cmake @@ -117,6 +117,7 @@ function(caffe_print_configuration_summary) caffe_status(" USE_OPENCV : ${USE_OPENCV}") caffe_status(" USE_LEVELDB : ${USE_LEVELDB}") caffe_status(" USE_LMDB : ${USE_LMDB}") + caffe_status(" ALLOW_LMDB_NOLOCK : ${ALLOW_LMDB_NOLOCK}") caffe_status("") caffe_status("Dependencies:") caffe_status(" BLAS : " APPLE THEN "Yes (vecLib)" ELSE "Yes (${BLAS})") diff --git a/cmake/Templates/caffe_config.h.in b/cmake/Templates/caffe_config.h.in index 6b7f7e505d8..26526c2fe86 100644 --- a/cmake/Templates/caffe_config.h.in +++ b/cmake/Templates/caffe_config.h.in @@ -39,3 +39,4 @@ #cmakedefine USE_OPENCV #cmakedefine USE_LEVELDB #cmakedefine USE_LMDB +#cmakedefine ALLOW_LMDB_NOLOCK diff --git a/src/caffe/util/db_lmdb.cpp b/src/caffe/util/db_lmdb.cpp index 78dd880ac41..0bc82b53e2b 100644 --- a/src/caffe/util/db_lmdb.cpp +++ b/src/caffe/util/db_lmdb.cpp @@ -19,7 +19,22 @@ void LMDB::Open(const string& source, Mode mode) { if (mode == READ) { flags = MDB_RDONLY | MDB_NOTLS; } - MDB_CHECK(mdb_env_open(mdb_env_, source.c_str(), flags, 0664)); + int rc = mdb_env_open(mdb_env_, source.c_str(), flags, 0664); +#ifndef ALLOW_LMDB_NOLOCK + MDB_CHECK(rc); +#else + if (rc == EACCES) { + LOG(WARNING) << "Permission denied. Trying with MDB_NOLOCK ..."; + // Close and re-open environment handle + mdb_env_close(mdb_env_); + MDB_CHECK(mdb_env_create(&mdb_env_)); + // Try again with MDB_NOLOCK + flags |= MDB_NOLOCK; + MDB_CHECK(mdb_env_open(mdb_env_, source.c_str(), flags, 0664)); + } else { + MDB_CHECK(rc); + } +#endif LOG(INFO) << "Opened lmdb " << source; } From 4617bd6cd938768b687c8d2ce303e609bf4bd719 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 22 Oct 2015 12:02:37 -0700 Subject: [PATCH 282/331] Remove versioned symlinks from tools Leaving it for the shared library only --- cmake/Targets.cmake | 2 -- src/caffe/CMakeLists.txt | 6 +++++- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/cmake/Targets.cmake b/cmake/Targets.cmake index 8e649291020..f4512183aaa 100644 --- a/cmake/Targets.cmake +++ b/cmake/Targets.cmake @@ -110,8 +110,6 @@ function(caffe_default_properties target) ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib" LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib" RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin" - VERSION ${CAFFE_TARGET_VERSION} - SOVERSION ${CAFFE_TARGET_SOVERSION} ) # make sure we build all external depepdencies first diff --git a/src/caffe/CMakeLists.txt b/src/caffe/CMakeLists.txt index 73ecd4496b1..66893ddb29d 100644 --- a/src/caffe/CMakeLists.txt +++ b/src/caffe/CMakeLists.txt @@ -20,7 +20,11 @@ endif() add_library(caffe ${srcs}) target_link_libraries(caffe proto ${Caffe_LINKER_LIBS}) caffe_default_properties(caffe) -set_target_properties(caffe PROPERTIES OUTPUT_NAME "caffe-nv") +set_target_properties(caffe PROPERTIES + OUTPUT_NAME "caffe-nv" + VERSION ${CAFFE_TARGET_VERSION} + SOVERSION ${CAFFE_TARGET_SOVERSION} + ) # ---[ Tests add_subdirectory(test) From 013db36c1024a178f905fd4e75c807e42dd11a97 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 22 Oct 2015 12:24:38 -0700 Subject: [PATCH 283/331] Mark v0.14.0-beta.1 --- CMakeLists.txt | 2 +- Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b1bb1a8b42a..4185a343a2b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8.7) project(Caffe C CXX) # ---[ Caffe version -set(CAFFE_TARGET_VERSION "0.14.0-beta") +set(CAFFE_TARGET_VERSION "0.14.0-beta.1") set(CAFFE_TARGET_SOVERSION "0.14") add_definitions(-DCAFFE_VERSION=${CAFFE_TARGET_VERSION}) diff --git a/Makefile b/Makefile index a1fc925e40b..47274fd9f48 100644 --- a/Makefile +++ b/Makefile @@ -52,7 +52,7 @@ LIB_BUILD_DIR := $(BUILD_DIR)/lib STATIC_NAME := $(LIB_BUILD_DIR)/lib$(LIBRARY_NAME).a DYNAMIC_VERSION_MAJOR := 0 DYNAMIC_VERSION_MINOR := 14 -DYNAMIC_VERSION_REVISION := 0-beta +DYNAMIC_VERSION_REVISION := 0-beta.1 DYNAMIC_NAME_SHORT := lib$(LIBRARY_NAME).so DYNAMIC_SONAME_SHORT := $(DYNAMIC_NAME_SHORT).$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR) DYNAMIC_VERSIONED_NAME_SHORT := $(DYNAMIC_SONAME_SHORT).$(DYNAMIC_VERSION_REVISION) From 74a8f12e00d8c4bee834038add61be4277d7e73e Mon Sep 17 00:00:00 2001 From: Dmytro Mishkin Date: Wed, 25 Feb 2015 17:00:22 +0200 Subject: [PATCH 284/331] Added batch normalization layer with test and examples Conflicts: include/caffe/common_layers.hpp --- .../cifar10_full_sigmoid_solver.prototxt | 28 ++ .../cifar10_full_sigmoid_solver_bn.prototxt | 28 ++ .../cifar10_full_sigmoid_train_test.prototxt | 212 +++++++++++ ...ifar10_full_sigmoid_train_test_bn.prototxt | 284 ++++++++++++++ examples/cifar10/train_full_sigmoid.sh | 7 + examples/cifar10/train_full_sigmoid_bn.sh | 7 + include/caffe/common_layers.hpp | 49 +++ src/caffe/layers/batch_norm_layer.cpp | 351 ++++++++++++++++++ src/caffe/layers/batch_norm_layer.cu | 228 ++++++++++++ src/caffe/test/test_batch_norm_layer.cpp | 90 +++++ 10 files changed, 1284 insertions(+) create mode 100644 examples/cifar10/cifar10_full_sigmoid_solver.prototxt create mode 100644 examples/cifar10/cifar10_full_sigmoid_solver_bn.prototxt create mode 100644 examples/cifar10/cifar10_full_sigmoid_train_test.prototxt create mode 100644 examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt create mode 100755 examples/cifar10/train_full_sigmoid.sh create mode 100755 examples/cifar10/train_full_sigmoid_bn.sh create mode 100644 src/caffe/layers/batch_norm_layer.cpp create mode 100644 src/caffe/layers/batch_norm_layer.cu create mode 100644 src/caffe/test/test_batch_norm_layer.cpp diff --git a/examples/cifar10/cifar10_full_sigmoid_solver.prototxt b/examples/cifar10/cifar10_full_sigmoid_solver.prototxt new file mode 100644 index 00000000000..7dd3ecb9d8e --- /dev/null +++ b/examples/cifar10/cifar10_full_sigmoid_solver.prototxt @@ -0,0 +1,28 @@ +# reduce learning rate after 120 epochs (60000 iters) by factor 0f 10 +# then another factor of 10 after 10 more epochs (5000 iters) + +# The train/test net protocol buffer definition +net: "examples/cifar10/cifar10_full_sigmoid_train_test.prototxt" +# test_iter specifies how many forward passes the test should carry out. +# In the case of CIFAR10, we have test batch size 100 and 100 test iterations, +# covering the full 10,000 testing images. +test_iter: 10 +# Carry out testing every 1000 training iterations. +test_interval: 1000 +# The base learning rate, momentum and the weight decay of the network. +base_lr: 0.001 +momentum: 0.9 +#weight_decay: 0.004 +# The learning rate policy +lr_policy: "step" +gamma: 1 +stepsize: 5000 +# Display every 200 iterations +display: 100 +# The maximum number of iterations +max_iter: 60000 +# snapshot intermediate results +snapshot: 10000 +snapshot_prefix: "examples/cifar10_full_sigmoid" +# solver mode: CPU or GPU +solver_mode: GPU diff --git a/examples/cifar10/cifar10_full_sigmoid_solver_bn.prototxt b/examples/cifar10/cifar10_full_sigmoid_solver_bn.prototxt new file mode 100644 index 00000000000..a57b280fd1e --- /dev/null +++ b/examples/cifar10/cifar10_full_sigmoid_solver_bn.prototxt @@ -0,0 +1,28 @@ +# reduce learning rate after 120 epochs (60000 iters) by factor 0f 10 +# then another factor of 10 after 10 more epochs (5000 iters) + +# The train/test net protocol buffer definition +net: "examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt" +# test_iter specifies how many forward passes the test should carry out. +# In the case of CIFAR10, we have test batch size 100 and 100 test iterations, +# covering the full 10,000 testing images. +test_iter: 10 +# Carry out testing every 1000 training iterations. +test_interval: 1000 +# The base learning rate, momentum and the weight decay of the network. +base_lr: 0.001 +momentum: 0.9 +#weight_decay: 0.004 +# The learning rate policy +lr_policy: "step" +gamma: 1 +stepsize: 5000 +# Display every 200 iterations +display: 100 +# The maximum number of iterations +max_iter: 60000 +# snapshot intermediate results +snapshot: 10000 +snapshot_prefix: "examples/cifar10_full_sigmoid_bn" +# solver mode: CPU or GPU +solver_mode: GPU diff --git a/examples/cifar10/cifar10_full_sigmoid_train_test.prototxt b/examples/cifar10/cifar10_full_sigmoid_train_test.prototxt new file mode 100644 index 00000000000..6f5bf26bf99 --- /dev/null +++ b/examples/cifar10/cifar10_full_sigmoid_train_test.prototxt @@ -0,0 +1,212 @@ +name: "CIFAR10_full" +layer { + name: "cifar" + type: "Data" + top: "data" + top: "label" + include { + phase: TRAIN + } + transform_param { + mean_file: "examples/cifar10/mean.binaryproto" + } + data_param { + source: "examples/cifar10/cifar10_train_lmdb" + batch_size: 111 + backend: LMDB + } +} +layer { + name: "cifar" + type: "Data" + top: "data" + top: "label" + include { + phase: TEST + } + transform_param { + mean_file: "examples/cifar10/mean.binaryproto" + } + data_param { + source: "examples/cifar10/cifar10_test_lmdb" + batch_size: 1000 + backend: LMDB + } +} +layer { + name: "conv1" + type: "Convolution" + bottom: "data" + top: "conv1" + param { + lr_mult: 1 + } + param { + lr_mult: 2 + } + convolution_param { + num_output: 32 + pad: 2 + kernel_size: 5 + stride: 1 + weight_filler { + type: "gaussian" + std: 0.0001 + } + bias_filler { + type: "constant" + } + } +} +layer { + name: "pool1" + type: "Pooling" + bottom: "conv1" + top: "pool1" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} + + + +layer { + name: "Sigmoid1" + type: "Sigmoid" + bottom: "pool1" + top: "Sigmoid1" +} + +layer { + name: "conv2" + type: "Convolution" + bottom: "Sigmoid1" + top: "conv2" + param { + lr_mult: 1 + } + param { + lr_mult: 2 + } + convolution_param { + num_output: 32 + pad: 2 + kernel_size: 5 + stride: 1 + weight_filler { + type: "gaussian" + std: 0.01 + } + bias_filler { + type: "constant" + } + } +} + + +layer { + name: "Sigmoid2" + type: "Sigmoid" + bottom: "conv2" + top: "Sigmoid2" +} +layer { + name: "pool2" + type: "Pooling" + bottom: "Sigmoid2" + top: "pool2" + pooling_param { + pool: AVE + kernel_size: 3 + stride: 2 + } +} +layer { + name: "conv3" + type: "Convolution" + bottom: "pool2" + top: "conv3" + convolution_param { + num_output: 64 + pad: 2 + kernel_size: 5 + stride: 1 + weight_filler { + type: "gaussian" + std: 0.01 + } + bias_filler { + type: "constant" + } + } + param { + lr_mult: 1 + } + param { + lr_mult: 1 + } + +} + +layer { + name: "Sigmoid3" + type: "Sigmoid" + bottom: "conv3" + top: "Sigmoid3" +} + +layer { + name: "pool3" + type: "Pooling" + bottom: "Sigmoid3" + top: "pool3" + pooling_param { + pool: AVE + kernel_size: 3 + stride: 2 + } +} + +layer { + name: "ip1" + type: "InnerProduct" + bottom: "pool3" + top: "ip1" + param { + lr_mult: 1 + decay_mult: 250 + } + param { + lr_mult: 0.2 + decay_mult: 0 + } + inner_product_param { + num_output: 10 + weight_filler { + type: "gaussian" + std: 0.01 + } + bias_filler { + type: "constant" + } + } +} +layer { + name: "accuracy" + type: "Accuracy" + bottom: "ip1" + bottom: "label" + top: "accuracy" + include { + phase: TEST + } +} +layer { + name: "loss" + type: "SoftmaxWithLoss" + bottom: "ip1" + bottom: "label" + top: "loss" +} diff --git a/examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt b/examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt new file mode 100644 index 00000000000..85c2dffe3f6 --- /dev/null +++ b/examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt @@ -0,0 +1,284 @@ +name: "CIFAR10_full" +layer { + name: "cifar" + type: "Data" + top: "data" + top: "label" + include { + phase: TRAIN + } + transform_param { + mean_file: "examples/cifar10/mean.binaryproto" + } + data_param { + source: "examples/cifar10/cifar10_train_lmdb" + batch_size: 111 + backend: LMDB + } +} +layer { + name: "cifar" + type: "Data" + top: "data" + top: "label" + include { + phase: TEST + } + transform_param { + mean_file: "examples/cifar10/mean.binaryproto" + } + data_param { + source: "examples/cifar10/cifar10_test_lmdb" + batch_size: 1000 + backend: LMDB + } +} +layer { + name: "conv1" + type: "Convolution" + bottom: "data" + top: "conv1" + param { + lr_mult: 1 + } + param { + lr_mult: 2 + } + convolution_param { + num_output: 32 + pad: 2 + kernel_size: 5 + stride: 1 + weight_filler { + type: "gaussian" + std: 0.0001 + } + bias_filler { + type: "constant" + } + } +} +layer { + name: "pool1" + type: "Pooling" + bottom: "conv1" + top: "pool1" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} + +layer { + name: "bn1" + type: "BatchNorm" + bottom: "pool1" + top: "bn1" + bn_param { + scale_filler { + type: "constant" + value: 1 + } + shift_filler { + type: "constant" + value: 0.001 + } + } + param { + lr_mult: 1.00001 + decay_mult: 0 + } + param { + lr_mult: 1.00001 + decay_mult: 0 + } +} + +layer { + name: "Sigmoid1" + type: "Sigmoid" + bottom: "bn1" + top: "Sigmoid1" +} + +layer { + name: "conv2" + type: "Convolution" + bottom: "Sigmoid1" + top: "conv2" + param { + lr_mult: 1 + } + param { + lr_mult: 2 + } + convolution_param { + num_output: 32 + pad: 2 + kernel_size: 5 + stride: 1 + weight_filler { + type: "gaussian" + std: 0.01 + } + bias_filler { + type: "constant" + } + } +} + + + +layer { + name: "bn2" + type: "BatchNorm" + bottom: "conv2" + top: "bn2" + bn_param { + scale_filler { + type: "constant" + value: 1 + } + shift_filler { + type: "constant" + value: 0.001 + } + } + param { + lr_mult: 1.00001 + decay_mult: 0 + } + param { + lr_mult: 1.00001 + decay_mult: 0 + } +} +layer { + name: "Sigmoid2" + type: "Sigmoid" + bottom: "bn2" + top: "Sigmoid2" +} +layer { + name: "pool2" + type: "Pooling" + bottom: "Sigmoid2" + top: "pool2" + pooling_param { + pool: AVE + kernel_size: 3 + stride: 2 + } +} +layer { + name: "conv3" + type: "Convolution" + bottom: "pool2" + top: "conv3" + convolution_param { + num_output: 64 + pad: 2 + kernel_size: 5 + stride: 1 + weight_filler { + type: "gaussian" + std: 0.01 + } + bias_filler { + type: "constant" + } + } + param { + lr_mult: 1 + } + param { + lr_mult: 1 + } + +} + + +layer { + name: "bn3" + type: "BatchNorm" + bottom: "conv3" + top: "bn3" + bn_param { + scale_filler { + type: "constant" + value: 1 + } + shift_filler { + type: "constant" + value: 0.001 + } + } + param { + lr_mult: 1.00001 + decay_mult: 0 + } + param { + lr_mult: 1.00001 + decay_mult: 0 + } +} +layer { + name: "Sigmoid3" + type: "Sigmoid" + bottom: "bn3" + top: "Sigmoid3" +} +layer { + name: "pool3" + type: "Pooling" + bottom: "Sigmoid3" + top: "pool3" + pooling_param { + pool: AVE + kernel_size: 3 + stride: 2 + } +} + +layer { + name: "ip1" + type: "InnerProduct" + bottom: "pool3" + top: "ip1" + param { + lr_mult: 1 + decay_mult: 250 + } + param { + lr_mult: 0.2 + decay_mult: 0 + } + inner_product_param { + num_output: 10 + weight_filler { + type: "gaussian" + std: 0.01 + } + bias_filler { + type: "constant" + } + } +} +layer { + name: "accuracy" + type: "Accuracy" + bottom: "ip1" + bottom: "label" + top: "accuracy" + include { + phase: TEST + } +} +layer { + name: "loss" + type: "SoftmaxWithLoss" + bottom: "ip1" + bottom: "label" + top: "loss" +} diff --git a/examples/cifar10/train_full_sigmoid.sh b/examples/cifar10/train_full_sigmoid.sh new file mode 100755 index 00000000000..9cff06d3e34 --- /dev/null +++ b/examples/cifar10/train_full_sigmoid.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env sh + +TOOLS=./build/tools + +$TOOLS/caffe train \ + --solver=examples/cifar10/cifar10_full_sigmoid_solver.prototxt + diff --git a/examples/cifar10/train_full_sigmoid_bn.sh b/examples/cifar10/train_full_sigmoid_bn.sh new file mode 100755 index 00000000000..011387c996e --- /dev/null +++ b/examples/cifar10/train_full_sigmoid_bn.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env sh + +TOOLS=./build/tools + +$TOOLS/caffe train \ + --solver=examples/cifar10/cifar10_full_sigmoid_solver_bn.prototxt + diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index cd671ea2bb7..985a0ba013a 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -78,6 +78,55 @@ class ArgMaxLayer : public Layer { int axis_; }; +/** +* @brief Batch Normalization per-channel with scale & shift linear transform. +* +*/ +template +class BatchNormLayer : public Layer { + public: + explicit BatchNormLayer(const LayerParameter& param) + : Layer(param) {} + virtual void LayerSetUp(const vector*>& bottom, + const vector*>& top); + + virtual void Reshape(const vector*>& bottom, + const vector*>& top); + + virtual inline const char* type() const { return "BN"; } + virtual inline int ExactNumBottomBlobs() const { return 1; } + virtual inline int ExactNumTopBlobs() const { return 1; } + + protected: + virtual void Forward_cpu(const vector*>& bottom, + const vector*>& top); + virtual void Forward_gpu(const vector*>& bottom, + const vector*>& top); + virtual void Backward_cpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + virtual void Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + + // spatial mean & variance + Blob spatial_mean_, spatial_variance_; + // batch mean & variance + Blob batch_mean_, batch_variance_; + // buffer blob + Blob buffer_blob_; + + Blob x_norm_; + // x_sum_multiplier is used to carry out sum using BLAS + Blob spatial_sum_multiplier_, batch_sum_multiplier_; + + // dimension + int N_; + int C_; + int H_; + int W_; + // eps + Dtype var_eps_; +}; + /** * @brief Takes at least two Blob%s and concatenates them along either the num * or channel dimension, outputting the result. diff --git a/src/caffe/layers/batch_norm_layer.cpp b/src/caffe/layers/batch_norm_layer.cpp new file mode 100644 index 00000000000..8dea34932f3 --- /dev/null +++ b/src/caffe/layers/batch_norm_layer.cpp @@ -0,0 +1,351 @@ +#include +#include + +#include "caffe/common_layers.hpp" +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/math_functions.hpp" + +namespace caffe { + template + void BatchNormLayer::Reshape(const vector*>& bottom, + const vector*>& top) { + top[0]->Reshape(bottom[0]->num(), bottom[0]->channels(), + bottom[0]->height(), bottom[0]->width()); + + x_norm_.Reshape(bottom[0]->num(), bottom[0]->channels(), + bottom[0]->height(), bottom[0]->width()); + + // Figure out the dimensions + N_ = bottom[0]->num(); + C_ = bottom[0]->channels(); + H_ = bottom[0]->height(); + W_ = bottom[0]->width(); + + // mean + spatial_mean_.Reshape(N_, C_, 1, 1); + batch_mean_.Reshape(1, C_, 1, 1); + // variance + spatial_variance_.Reshape(N_, C_, 1, 1); + batch_variance_.Reshape(1, C_, 1, 1); + // buffer blod + buffer_blob_.Reshape(N_, C_, H_, W_); + + // fill spatial multiplier + spatial_sum_multiplier_.Reshape(1, 1, H_, W_); + Dtype* spatial_multipl_data = spatial_sum_multiplier_.mutable_cpu_data(); + caffe_set(spatial_sum_multiplier_.count(), Dtype(1), + spatial_multipl_data); + caffe_set(spatial_sum_multiplier_.count(), Dtype(0), + spatial_sum_multiplier_.mutable_cpu_diff()); + // fill batch multiplier + batch_sum_multiplier_.Reshape(N_, 1, 1, 1); + Dtype* batch_multiplier_data = batch_sum_multiplier_.mutable_cpu_data(); + caffe_set(batch_sum_multiplier_.count(), Dtype(1), + batch_multiplier_data); + caffe_set(batch_sum_multiplier_.count(), Dtype(0), + batch_sum_multiplier_.mutable_cpu_diff()); + this->param_propagate_down_.resize(this->blobs_.size(), true); + } + template + void BatchNormLayer::LayerSetUp(const vector*>& bottom, + const vector*>& top) { + CHECK_NE(top[0], bottom[0]) << this->type() << " Layer does not " + "allow in-place computation."; + + top[0]->Reshape(bottom[0]->num(), bottom[0]->channels(), + bottom[0]->height(), bottom[0]->width()); + + x_norm_.Reshape(bottom[0]->num(), bottom[0]->channels(), + bottom[0]->height(), bottom[0]->width()); + // Figure out the dimensions + N_ = bottom[0]->num(); + C_ = bottom[0]->channels(); + H_ = bottom[0]->height(); + W_ = bottom[0]->width(); + var_eps_ = 1e-9; + + // mean + spatial_mean_.Reshape(N_, C_, 1, 1); + batch_mean_.Reshape(1, C_, 1, 1); + // variance + spatial_variance_.Reshape(N_, C_, 1, 1); + batch_variance_.Reshape(1, C_, 1, 1); + // buffer blod + buffer_blob_.Reshape(N_, C_, H_, W_); + + // fill spatial multiplier + spatial_sum_multiplier_.Reshape(1, 1, H_, W_); + Dtype* spatial_multipl_data = spatial_sum_multiplier_.mutable_cpu_data(); + caffe_set(spatial_sum_multiplier_.count(), Dtype(1), + spatial_multipl_data); + caffe_set(spatial_sum_multiplier_.count(), Dtype(0), + spatial_sum_multiplier_.mutable_cpu_diff()); + + // fill batch multiplier + batch_sum_multiplier_.Reshape(N_, 1, 1, 1); + Dtype* batch_multiplier_data = batch_sum_multiplier_.mutable_cpu_data(); + caffe_set(batch_sum_multiplier_.count(), Dtype(1), + batch_multiplier_data); + caffe_set(batch_sum_multiplier_.count(), Dtype(0), + batch_sum_multiplier_.mutable_cpu_diff()); + + // Check if we need to set up the weights + if (this->blobs_.size() > 0) { + LOG(INFO) << "Skipping parameter initialization"; + } else { + this->blobs_.resize(2); + + // fill scale with scale_filler + this->blobs_[0].reset(new Blob(1, C_, 1, 1)); + caffe_set(this->blobs_[0]->count(), Dtype(1), + this->blobs_[0]->mutable_cpu_data()); + + // fill shift with shift_filler + this->blobs_[1].reset(new Blob(1, C_, 1, 1)); + caffe_set(this->blobs_[1]->count(), Dtype(0), + this->blobs_[1]->mutable_cpu_data()); + } // parameter initialization + this->param_propagate_down_.resize(this->blobs_.size(), true); + } + + template + void BatchNormLayer::Forward_cpu(const vector*>& bottom, + const vector*>& top) { + const Dtype* bottom_data = bottom[0]->cpu_data(); + Dtype* top_data = top[0]->mutable_cpu_data(); + const Dtype* const_top_data = top[0]->cpu_data(); + + const Dtype* scale_data = this->blobs_[0]->cpu_data(); + const Dtype* shift_data = this->blobs_[1]->cpu_data(); + + // put the squares of bottom into buffer_blob_ + caffe_powx(bottom[0]->count(), bottom_data, Dtype(2), + buffer_blob_.mutable_cpu_data()); + + // computes variance using var(X) = E(X^2) - (EX)^2 + // EX across spatial + caffe_cpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, + Dtype(1. / (H_ * W_)), bottom_data, + spatial_sum_multiplier_.cpu_data(), Dtype(0), + spatial_mean_.mutable_cpu_data()); + // EX across batch + caffe_cpu_gemv(CblasTrans, N_, C_, Dtype(1. / N_), + spatial_mean_.cpu_data(), + batch_sum_multiplier_.cpu_data(), Dtype(0), + batch_mean_.mutable_cpu_data()); + + // E(X^2) across spatial + caffe_cpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, + Dtype(1. / (H_ * W_)), buffer_blob_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), Dtype(0), + spatial_variance_.mutable_cpu_data()); + // E(X^2) across batch + caffe_cpu_gemv(CblasTrans, N_, C_, Dtype(1. / N_), + spatial_variance_.cpu_data(), + batch_sum_multiplier_.cpu_data(), Dtype(0), + batch_variance_.mutable_cpu_data()); + + caffe_powx(batch_mean_.count(), batch_mean_.cpu_data(), Dtype(2), + buffer_blob_.mutable_cpu_data()); // (EX)^2 + caffe_sub(batch_mean_.count(), batch_variance_.cpu_data(), + buffer_blob_.cpu_data(), + batch_variance_.mutable_cpu_data()); // variance + + // do mean and variance normalization + // subtract mean + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_, + C_, 1, Dtype(1), + batch_sum_multiplier_.cpu_data(), + batch_mean_.cpu_data(), Dtype(0), + spatial_mean_.mutable_cpu_data()); + + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, + H_ * W_, 1, Dtype(-1), + spatial_mean_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), Dtype(0), + buffer_blob_.mutable_cpu_data()); + + caffe_add(buffer_blob_.count(), bottom_data, + buffer_blob_.cpu_data(), top_data); + + // normalize variance + caffe_add_scalar(batch_variance_.count(), var_eps_, + batch_variance_.mutable_cpu_data()); + caffe_powx(batch_variance_.count(), + batch_variance_.cpu_data(), Dtype(0.5), + batch_variance_.mutable_cpu_data()); + + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_, + C_, 1, Dtype(1), + batch_sum_multiplier_.cpu_data(), + batch_variance_.cpu_data(), Dtype(0), + spatial_variance_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, + N_ * C_, H_ * W_, 1, Dtype(1), + spatial_variance_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), Dtype(0), + buffer_blob_.mutable_cpu_data()); + + caffe_div(buffer_blob_.count(), const_top_data, + buffer_blob_.cpu_data(), top_data); + + // Saving x_norm + caffe_copy(buffer_blob_.count(), const_top_data, + x_norm_.mutable_cpu_data()); + // scale + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), + batch_sum_multiplier_.cpu_data(), scale_data, Dtype(0), + spatial_variance_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, + H_ * W_, 1, Dtype(1), + spatial_variance_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), Dtype(0), + buffer_blob_.mutable_cpu_data()); + caffe_mul(buffer_blob_.count(), top_data, + buffer_blob_.cpu_data(), top_data); + + // shift + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), + batch_sum_multiplier_.cpu_data(), shift_data, Dtype(0), + spatial_mean_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, + N_ * C_, H_ * W_, 1, Dtype(1), + spatial_mean_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), Dtype(0), + buffer_blob_.mutable_cpu_data()); + caffe_add(buffer_blob_.count(), const_top_data, + buffer_blob_.cpu_data(), top_data); + } + + template + void BatchNormLayer::Backward_cpu(const vector*>& top, + const vector& propagate_down, + const vector*>& bottom) { + const Dtype* top_diff = top[0]->cpu_diff(); + const Dtype* bottom_data = bottom[0]->cpu_data(); + Dtype* bottom_diff = bottom[0]->mutable_cpu_diff(); + + Dtype* scale_diff = this->blobs_[0]->mutable_cpu_diff(); + Dtype* shift_diff = this->blobs_[1]->mutable_cpu_diff(); + const Dtype* scale_data = this->blobs_[0]->cpu_data(); + +// Propagate layer to parameters + // gradient w.r.t. scale + caffe_mul(buffer_blob_.count(), x_norm_.cpu_data(), + top_diff, buffer_blob_.mutable_cpu_data()); + // EX across spatial + caffe_cpu_gemv(CblasNoTrans, N_ * C_, + H_ * W_, Dtype(1), buffer_blob_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), Dtype(0), + spatial_variance_.mutable_cpu_diff()); + // EX across batch + caffe_cpu_gemv(CblasTrans, N_, C_, Dtype(1), + spatial_variance_.cpu_diff(), + batch_sum_multiplier_.cpu_data(), Dtype(0), scale_diff); + + // gradient w.r.t. shift + // EX across spatial + caffe_cpu_gemv(CblasNoTrans, N_ * C_, + H_ * W_, Dtype(1), top_diff, + spatial_sum_multiplier_.cpu_data(), + Dtype(0), spatial_mean_.mutable_cpu_diff()); + // EX across batch + caffe_cpu_gemv(CblasTrans, N_, C_, + Dtype(1), spatial_mean_.cpu_diff(), + batch_sum_multiplier_.cpu_data(), + Dtype(0), shift_diff); + +// Propagate down + + // put scale * top_diff to buffer_blob_ + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), + batch_sum_multiplier_.cpu_data(), scale_data, Dtype(0), + spatial_variance_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, + H_ * W_, 1, Dtype(1), + spatial_variance_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), Dtype(0), + buffer_blob_.mutable_cpu_data()); + caffe_mul(buffer_blob_.count(), top_diff, buffer_blob_.cpu_data(), + buffer_blob_.mutable_cpu_data()); + + // use new top diff for computation + caffe_mul(buffer_blob_.count(), x_norm_.cpu_data(), + buffer_blob_.cpu_data(), bottom_diff); + // EX across spatial + caffe_cpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, + Dtype(1), bottom_diff, + spatial_sum_multiplier_.cpu_data(), Dtype(0), + spatial_mean_.mutable_cpu_data()); + // EX across batch + caffe_cpu_gemv(CblasTrans, N_, C_, Dtype(1), + spatial_mean_.cpu_data(), + batch_sum_multiplier_.cpu_data(), Dtype(0), + batch_mean_.mutable_cpu_data()); + + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, + N_, C_, 1, Dtype(1), + batch_sum_multiplier_.cpu_data(), + batch_mean_.cpu_data(), Dtype(0), + spatial_mean_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, + H_ * W_, 1, Dtype(1), + spatial_mean_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), Dtype(0), + bottom_diff); + + caffe_mul(buffer_blob_.count(), + x_norm_.cpu_data(), bottom_diff, bottom_diff); + + // EX across spatial + caffe_cpu_gemv(CblasNoTrans, N_ * C_, + H_ * W_, Dtype(1), buffer_blob_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), Dtype(0), + spatial_mean_.mutable_cpu_data()); + // EX across batch + caffe_cpu_gemv(CblasTrans, N_, C_, Dtype(1), + spatial_mean_.cpu_data(), + batch_sum_multiplier_.cpu_data(), Dtype(0), + batch_mean_.mutable_cpu_data()); + + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, + N_, C_, 1, Dtype(1), + batch_sum_multiplier_.cpu_data(), + batch_mean_.cpu_data(), Dtype(0), + spatial_mean_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, + N_ * C_, H_ * W_, 1, Dtype(1), + spatial_mean_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), Dtype(1), bottom_diff); + + caffe_cpu_axpby(buffer_blob_.count(), Dtype(1), + buffer_blob_.cpu_data(), Dtype(-1. / (N_ * H_ * W_)), + bottom_diff); + + // put the squares of bottom into buffer_blob_ +// caffe_powx(buffer_blob_.count(), bottom_data, Dtype(2), +// buffer_blob_.mutable_cpu_data()); + + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, + N_, C_, 1, Dtype(1), + batch_sum_multiplier_.cpu_data(), + batch_variance_.cpu_data(), Dtype(0), + spatial_variance_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, + N_ * C_, H_ * W_, 1, Dtype(1), + spatial_variance_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), Dtype(0), + buffer_blob_.mutable_cpu_data()); + + caffe_div(buffer_blob_.count(), bottom_diff, + buffer_blob_.cpu_data(), bottom_diff); + } +#ifdef CPU_ONLY +STUB_GPU(BatchNormLayer); +#endif + + INSTANTIATE_CLASS(BatchNormLayer); + REGISTER_LAYER_CLASS(BatchNorm); +} // namespace caffe + diff --git a/src/caffe/layers/batch_norm_layer.cu b/src/caffe/layers/batch_norm_layer.cu new file mode 100644 index 00000000000..e87f8c62f43 --- /dev/null +++ b/src/caffe/layers/batch_norm_layer.cu @@ -0,0 +1,228 @@ +#include +#include + +#include "caffe/common_layers.hpp" +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/math_functions.hpp" + +namespace caffe { + template + void BatchNormLayer::Forward_gpu(const vector*>& bottom, + const vector*>& top) { + const Dtype* bottom_data = bottom[0]->gpu_data(); + const Dtype* const_top_data = top[0]->gpu_data(); + Dtype* top_data = top[0]->mutable_gpu_data(); + Dtype* spatial_mean_data = spatial_mean_.mutable_gpu_data(); + Dtype* buffer_data = buffer_blob_.mutable_gpu_data(); + const Dtype* const_buffer_data = buffer_blob_.gpu_data(); + + + // put the squares of bottom into buffer_blob_ + caffe_gpu_powx(bottom[0]->count(), bottom_data, Dtype(2), + buffer_blob_.mutable_gpu_data()); + + // computes variance using var(X) = E(X^2) - (EX)^2 + // EX across spatial + caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, + Dtype(1. / (H_ * W_)), + bottom_data, spatial_sum_multiplier_.gpu_data(), + Dtype(0), spatial_mean_data); + // EX across batch + caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1. / N_), + spatial_mean_.gpu_data(), + batch_sum_multiplier_.gpu_data(), Dtype(0), + batch_mean_.mutable_gpu_data()); + + // E(X^2) across spatial + caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, + Dtype(1. / (H_ * W_)), buffer_data, + spatial_sum_multiplier_.gpu_data(), Dtype(0), + spatial_variance_.mutable_gpu_data()); + // E(X^2) across batch + caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1. / N_), + spatial_variance_.gpu_data(), + batch_sum_multiplier_.gpu_data(), Dtype(0), + batch_variance_.mutable_gpu_data()); + + caffe_gpu_powx(batch_mean_.count(), batch_mean_.gpu_data(), + Dtype(2), buffer_blob_.mutable_gpu_data()); // (EX)^2 + caffe_gpu_sub(batch_mean_.count(), batch_variance_.gpu_data(), + buffer_data, batch_variance_.mutable_gpu_data()); // variance + + // do mean and variance normalization + // subtract mean + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), + batch_sum_multiplier_.gpu_data(), batch_mean_.gpu_data(), Dtype(0), + spatial_mean_data); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, H_ * W_, + 1, -Dtype(1), + spatial_mean_.gpu_data(), spatial_sum_multiplier_.gpu_data(), Dtype(0), + buffer_blob_.mutable_gpu_data()); + + caffe_gpu_add(buffer_blob_.count(), bottom_data, buffer_data, top_data); + + // normalize variance + caffe_gpu_add_scalar(batch_variance_.count(), var_eps_, + batch_variance_.mutable_gpu_data()); + caffe_gpu_powx(batch_variance_.count(), batch_variance_.gpu_data(), + Dtype(0.5), batch_variance_.mutable_gpu_data()); + + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), + batch_sum_multiplier_.gpu_data(), batch_variance_.gpu_data(), Dtype(0), + spatial_variance_.mutable_gpu_data()); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, + H_ * W_, 1, Dtype(1), + spatial_variance_.gpu_data(), spatial_sum_multiplier_.gpu_data(), + Dtype(0), buffer_blob_.mutable_gpu_data()); + + caffe_gpu_div(buffer_blob_.count(), top_data, buffer_data, top_data); + + // Saving x_norm + caffe_copy(top[0]->count(), const_top_data, x_norm_.mutable_gpu_data()); + + // scale + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), + batch_sum_multiplier_.gpu_data(), this->blobs_[0]->gpu_data(), + Dtype(0), spatial_variance_.mutable_gpu_data()); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, + H_ * W_, 1, Dtype(1), + spatial_variance_.gpu_data(), spatial_sum_multiplier_.gpu_data(), + Dtype(0), buffer_blob_.mutable_gpu_data()); + + caffe_gpu_mul(buffer_blob_.count(), top_data, buffer_data, top_data); + + // shift + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), + batch_sum_multiplier_.gpu_data(), + this->blobs_[1]->gpu_data(), Dtype(0), + spatial_mean_data); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, H_ * W_, 1, + Dtype(1), + spatial_mean_.gpu_data(), spatial_sum_multiplier_.gpu_data(), Dtype(0), + buffer_blob_.mutable_gpu_data()); + caffe_gpu_add(buffer_blob_.count(), top_data, buffer_data, top_data); + } + + template + void BatchNormLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, + const vector*>& bottom) { + const Dtype* top_diff = top[0]->gpu_diff(); + const Dtype* top_data = top[0]->gpu_data(); + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + const Dtype* const_bottom_diff = bottom[0]->gpu_diff(); + Dtype* spatial_mean_data = spatial_mean_.mutable_gpu_data(); + Dtype* buffer_data = buffer_blob_.mutable_gpu_data(); + const Dtype* const_buffer_data = buffer_blob_.gpu_data(); + + // Propage to layer params + // gradient w.r.t. scale + caffe_gpu_mul(buffer_blob_.count(), x_norm_.gpu_data(), + top_diff, buffer_blob_.mutable_gpu_data()); + // EX across spatial + caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, Dtype(1), + buffer_data, spatial_sum_multiplier_.gpu_data(), Dtype(0), + spatial_variance_.mutable_gpu_data()); + // EX across batch + caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1), + spatial_variance_.gpu_data(), + batch_sum_multiplier_.gpu_data(), Dtype(0), + this->blobs_[0]->mutable_gpu_diff()); + + // gradient w.r.t. shift + // EX across spatial + caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, Dtype(1), + top_diff, spatial_sum_multiplier_.gpu_data(), + Dtype(0), spatial_mean_data); + // EX across batch + caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1), + spatial_mean_.gpu_data(), + batch_sum_multiplier_.gpu_data(), Dtype(0), + this->blobs_[1]->mutable_gpu_diff()); + + // Propagate down + // scale top diff + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), + batch_sum_multiplier_.gpu_data(), this->blobs_[0]->gpu_data(), + Dtype(0), spatial_variance_.mutable_gpu_data()); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, + H_ * W_, 1, Dtype(1), + spatial_variance_.gpu_data(), spatial_sum_multiplier_.gpu_data(), + Dtype(0), + buffer_blob_.mutable_gpu_data()); + caffe_gpu_mul(buffer_blob_.count(), top_diff, buffer_data, + buffer_blob_.mutable_gpu_data()); + + // use new top diff for computation + caffe_gpu_mul(buffer_blob_.count(), x_norm_.gpu_data(), + buffer_data, bottom_diff); + // EX across spatial + caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, + Dtype(1), bottom_diff, + spatial_sum_multiplier_.gpu_data(), Dtype(0), spatial_mean_data); + // EX across batch + caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1), + spatial_mean_.gpu_data(), + batch_sum_multiplier_.gpu_data(), Dtype(0), + batch_mean_.mutable_gpu_data()); + + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), + batch_sum_multiplier_.gpu_data(), + batch_mean_.gpu_data(), Dtype(0), + spatial_mean_data); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, + H_ * W_, 1, Dtype(1), spatial_mean_.gpu_data(), + spatial_sum_multiplier_.gpu_data(), Dtype(0), + bottom_diff); + + caffe_gpu_mul(buffer_blob_.count(), x_norm_.gpu_data(), + bottom_diff, bottom_diff); + + // EX across spatial + caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, Dtype(1), + buffer_data, spatial_sum_multiplier_.gpu_data(), + Dtype(0), spatial_mean_data); + + // EX across batch + caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1), + spatial_mean_.gpu_data(), + batch_sum_multiplier_.gpu_data(), Dtype(0), + batch_mean_.mutable_gpu_data()); + + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, + C_, 1, Dtype(1), + batch_sum_multiplier_.gpu_data(), + batch_mean_.gpu_data(), Dtype(0), + spatial_mean_data); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, + H_ * W_, 1, Dtype(1), + spatial_mean_.gpu_data(), spatial_sum_multiplier_.gpu_data(), + Dtype(1), + bottom_diff); + + caffe_gpu_axpby(buffer_blob_.count(), Dtype(1), buffer_data, + Dtype(-1. / (N_ * H_ * W_)), + bottom_diff); + + // put the squares of bottom into buffer_blob_ +// caffe_gpu_powx(buffer_blob_.count(), bottom_data, Dtype(2), +// buffer_blob_.mutable_gpu_data()); + + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), + batch_sum_multiplier_.gpu_data(), batch_variance_.gpu_data(), Dtype(0), + spatial_variance_.mutable_gpu_data()); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, + H_ * W_, 1, Dtype(1), + spatial_variance_.gpu_data(), spatial_sum_multiplier_.gpu_data(), + Dtype(0), + buffer_blob_.mutable_gpu_data()); + + caffe_gpu_div(buffer_blob_.count(), const_bottom_diff, + const_buffer_data, bottom_diff); + } + + INSTANTIATE_LAYER_GPU_FUNCS(BatchNormLayer); +} // namespace caffe + diff --git a/src/caffe/test/test_batch_norm_layer.cpp b/src/caffe/test/test_batch_norm_layer.cpp new file mode 100644 index 00000000000..704efd5df3d --- /dev/null +++ b/src/caffe/test/test_batch_norm_layer.cpp @@ -0,0 +1,90 @@ +#include +#include +#include + +#include "gtest/gtest.h" + +#include "caffe/blob.hpp" +#include "caffe/common.hpp" +#include "caffe/common_layers.hpp" +#include "caffe/filler.hpp" + +#include "caffe/test/test_caffe_main.hpp" +#include "caffe/test/test_gradient_check_util.hpp" + +#define BATCH_SIZE 2 +#define INPUT_DATA_SIZE 3 + +namespace caffe { + + template + class BatchNormLayerTest : public MultiDeviceTest { + typedef typename TypeParam::Dtype Dtype; + protected: + BatchNormLayerTest() + : blob_bottom_(new Blob(5, 2, 3, 4)), + blob_top_(new Blob()) { + // fill the values + FillerParameter filler_param; + GaussianFiller filler(filler_param); + filler.Fill(this->blob_bottom_); + blob_bottom_vec_.push_back(blob_bottom_); + blob_top_vec_.push_back(blob_top_); + } + virtual ~BatchNormLayerTest() { delete blob_bottom_; delete blob_top_; } + Blob* const blob_bottom_; + Blob* const blob_top_; + vector*> blob_bottom_vec_; + vector*> blob_top_vec_; + }; + + TYPED_TEST_CASE(BatchNormLayerTest, TestDtypesAndDevices); + + TYPED_TEST(BatchNormLayerTest, TestForward) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + + BatchNormLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + + // Test mean + int num = this->blob_bottom_->num(); + int channels = this->blob_bottom_->channels(); + int height = this->blob_bottom_->height(); + int width = this->blob_bottom_->width(); + + for (int j = 0; j < channels; ++j) { + Dtype sum = 0, var = 0; + for (int i = 0; i < num; ++i) { + for ( int k = 0; k < height; ++k ) { + for ( int l = 0; l < width; ++l ) { + Dtype data = this->blob_top_->data_at(i, j, k, l); + Dtype bottom_data = this->blob_bottom_->data_at(i, j, k, l); + sum += data; + var += data * data; + } + } + } + sum /= height * width * num; + var /= height * width * num; + + const Dtype kErrorBound = 0.001; + // expect zero mean + EXPECT_NEAR(0, sum, kErrorBound); + // expect unit variance + EXPECT_NEAR(1, var, kErrorBound); + } + } + + TYPED_TEST(BatchNormLayerTest, TestGradient) { + typedef typename TypeParam::Dtype Dtype; + LayerParameter layer_param; + + BatchNormLayer layer(layer_param); + GradientChecker checker(1e-2, 1e-4); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); + } + +} // namespace caffe From e48dcda9c46426f8d5cd568b791d09e68add427b Mon Sep 17 00:00:00 2001 From: Carl Doersch Date: Tue, 6 Oct 2015 14:19:59 -0700 Subject: [PATCH 285/331] Cleanup batch norm layer, include global stats computation --- .../cifar10_full_sigmoid_train_test.prototxt | 4 +- ...ifar10_full_sigmoid_train_test_bn.prototxt | 90 +-- include/caffe/common_layers.hpp | 64 ++- src/caffe/layers/batch_norm_layer.cpp | 535 +++++++----------- src/caffe/layers/batch_norm_layer.cu | 365 +++++------- src/caffe/proto/caffe.proto | 15 +- src/caffe/test/test_batch_norm_layer.cpp | 45 +- 7 files changed, 486 insertions(+), 632 deletions(-) diff --git a/examples/cifar10/cifar10_full_sigmoid_train_test.prototxt b/examples/cifar10/cifar10_full_sigmoid_train_test.prototxt index 6f5bf26bf99..fba69b814ad 100644 --- a/examples/cifar10/cifar10_full_sigmoid_train_test.prototxt +++ b/examples/cifar10/cifar10_full_sigmoid_train_test.prototxt @@ -176,10 +176,10 @@ layer { top: "ip1" param { lr_mult: 1 - decay_mult: 250 + decay_mult: 0 } param { - lr_mult: 0.2 + lr_mult: 2 decay_mult: 0 } inner_product_param { diff --git a/examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt b/examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt index 85c2dffe3f6..1a810751177 100644 --- a/examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt +++ b/examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt @@ -12,7 +12,7 @@ layer { } data_param { source: "examples/cifar10/cifar10_train_lmdb" - batch_size: 111 + batch_size: 100 backend: LMDB } } @@ -41,21 +41,16 @@ layer { param { lr_mult: 1 } - param { - lr_mult: 2 - } convolution_param { num_output: 32 pad: 2 kernel_size: 5 stride: 1 + bias_term: false weight_filler { type: "gaussian" std: 0.0001 } - bias_filler { - type: "constant" - } } } layer { @@ -75,23 +70,14 @@ layer { type: "BatchNorm" bottom: "pool1" top: "bn1" - bn_param { - scale_filler { - type: "constant" - value: 1 - } - shift_filler { - type: "constant" - value: 0.001 - } + param { + lr_mult: 0 } param { - lr_mult: 1.00001 - decay_mult: 0 + lr_mult: 0 } param { - lr_mult: 1.00001 - decay_mult: 0 + lr_mult: 0 } } @@ -110,50 +96,35 @@ layer { param { lr_mult: 1 } - param { - lr_mult: 2 - } convolution_param { num_output: 32 pad: 2 kernel_size: 5 stride: 1 + bias_term: false weight_filler { type: "gaussian" std: 0.01 } - bias_filler { - type: "constant" - } } } - - layer { name: "bn2" type: "BatchNorm" bottom: "conv2" top: "bn2" - bn_param { - scale_filler { - type: "constant" - value: 1 - } - shift_filler { - type: "constant" - value: 0.001 - } + param { + lr_mult: 0 } param { - lr_mult: 1.00001 - decay_mult: 0 + lr_mult: 0 } param { - lr_mult: 1.00001 - decay_mult: 0 + lr_mult: 0 } } + layer { name: "Sigmoid2" type: "Sigmoid" @@ -176,53 +147,38 @@ layer { type: "Convolution" bottom: "pool2" top: "conv3" + param { + lr_mult: 1 + } convolution_param { num_output: 64 pad: 2 kernel_size: 5 stride: 1 + bias_term: false weight_filler { type: "gaussian" std: 0.01 } - bias_filler { - type: "constant" - } - } - param { - lr_mult: 1 } - param { - lr_mult: 1 - } - } - layer { name: "bn3" type: "BatchNorm" bottom: "conv3" top: "bn3" - bn_param { - scale_filler { - type: "constant" - value: 1 - } - shift_filler { - type: "constant" - value: 0.001 - } + param { + lr_mult: 0 } param { - lr_mult: 1.00001 - decay_mult: 0 + lr_mult: 0 } param { - lr_mult: 1.00001 - decay_mult: 0 + lr_mult: 0 } } + layer { name: "Sigmoid3" type: "Sigmoid" @@ -248,10 +204,10 @@ layer { top: "ip1" param { lr_mult: 1 - decay_mult: 250 + decay_mult: 1 } param { - lr_mult: 0.2 + lr_mult: 1 decay_mult: 0 } inner_product_param { diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index 985a0ba013a..3277f1b6c2c 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -79,9 +79,35 @@ class ArgMaxLayer : public Layer { }; /** -* @brief Batch Normalization per-channel with scale & shift linear transform. -* -*/ + * @brief Normalizes the input to have 0-mean and/or unit (1) variance across + * the batch. + * + * This layer computes Batch Normalization described in [1]. For + * each channel in the data (i.e. axis 1), it subtracts the mean and divides + * by the variance, where both statistics are computed across both spatial + * dimensions and across the different examples in the batch. + * + * By default, during training time, the network is computing global mean/ + * variance statistics via a running average, which is then used at test + * time to allow deterministic outputs for each input. You can manually + * toggle whether the network is accumulating or using the statistics via the + * use_global_stats option. IMPORTANT: for this feature to work, you MUST + * set the learning rate to zero for all three parameter blobs, i.e., + * param {lr_mult: 0} three times in the layer definition. + * + * Note that the original paper also included a per-channel learned bias and + * scaling factor. It is possible (though a bit cumbersome) to implement + * this in caffe using a single-channel DummyDataLayer filled with zeros, + * followed by a Convolution layer with output the same size as the current. + * This produces a channel-specific value that can be added or multiplied by + * the BatchNorm layer's output. + * + * [1] S. Ioffe and C. Szegedy, "Batch Normalization: Accelerating Deep Network + * Training by Reducing Internal Covariate Shift." arXiv preprint + * arXiv:1502.03167 (2015). + * + * TODO(dox): thorough documentation for Forward, Backward, and proto params. + */ template class BatchNormLayer : public Layer { public: @@ -89,11 +115,10 @@ class BatchNormLayer : public Layer { : Layer(param) {} virtual void LayerSetUp(const vector*>& bottom, const vector*>& top); - virtual void Reshape(const vector*>& bottom, const vector*>& top); - virtual inline const char* type() const { return "BN"; } + virtual inline const char* type() const { return "BatchNorm"; } virtual inline int ExactNumBottomBlobs() const { return 1; } virtual inline int ExactNumTopBlobs() const { return 1; } @@ -105,26 +130,19 @@ class BatchNormLayer : public Layer { virtual void Backward_cpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom); virtual void Backward_gpu(const vector*>& top, - const vector& propagate_down, const vector*>& bottom); - - // spatial mean & variance - Blob spatial_mean_, spatial_variance_; - // batch mean & variance - Blob batch_mean_, batch_variance_; - // buffer blob - Blob buffer_blob_; + const vector& propagate_down, const vector*>& bottom); - Blob x_norm_; - // x_sum_multiplier is used to carry out sum using BLAS - Blob spatial_sum_multiplier_, batch_sum_multiplier_; + Blob mean_, variance_, temp_, x_norm_; + bool use_global_stats_; + Dtype moving_average_fraction_; + int channels_; + Dtype eps_; - // dimension - int N_; - int C_; - int H_; - int W_; - // eps - Dtype var_eps_; + // extra temporarary variables is used to carry out sums/broadcasting + // using BLAS + Blob batch_sum_multiplier_; + Blob num_by_chans_; + Blob spatial_sum_multiplier_; }; /** diff --git a/src/caffe/layers/batch_norm_layer.cpp b/src/caffe/layers/batch_norm_layer.cpp index 8dea34932f3..94c2b96b9cd 100644 --- a/src/caffe/layers/batch_norm_layer.cpp +++ b/src/caffe/layers/batch_norm_layer.cpp @@ -2,350 +2,235 @@ #include #include "caffe/common_layers.hpp" -#include "caffe/filler.hpp" #include "caffe/layer.hpp" #include "caffe/util/math_functions.hpp" namespace caffe { - template - void BatchNormLayer::Reshape(const vector*>& bottom, - const vector*>& top) { - top[0]->Reshape(bottom[0]->num(), bottom[0]->channels(), - bottom[0]->height(), bottom[0]->width()); - - x_norm_.Reshape(bottom[0]->num(), bottom[0]->channels(), - bottom[0]->height(), bottom[0]->width()); - - // Figure out the dimensions - N_ = bottom[0]->num(); - C_ = bottom[0]->channels(); - H_ = bottom[0]->height(); - W_ = bottom[0]->width(); - // mean - spatial_mean_.Reshape(N_, C_, 1, 1); - batch_mean_.Reshape(1, C_, 1, 1); - // variance - spatial_variance_.Reshape(N_, C_, 1, 1); - batch_variance_.Reshape(1, C_, 1, 1); - // buffer blod - buffer_blob_.Reshape(N_, C_, H_, W_); - - // fill spatial multiplier - spatial_sum_multiplier_.Reshape(1, 1, H_, W_); - Dtype* spatial_multipl_data = spatial_sum_multiplier_.mutable_cpu_data(); - caffe_set(spatial_sum_multiplier_.count(), Dtype(1), - spatial_multipl_data); - caffe_set(spatial_sum_multiplier_.count(), Dtype(0), - spatial_sum_multiplier_.mutable_cpu_diff()); - // fill batch multiplier - batch_sum_multiplier_.Reshape(N_, 1, 1, 1); - Dtype* batch_multiplier_data = batch_sum_multiplier_.mutable_cpu_data(); - caffe_set(batch_sum_multiplier_.count(), Dtype(1), - batch_multiplier_data); - caffe_set(batch_sum_multiplier_.count(), Dtype(0), - batch_sum_multiplier_.mutable_cpu_diff()); - this->param_propagate_down_.resize(this->blobs_.size(), true); - } - template - void BatchNormLayer::LayerSetUp(const vector*>& bottom, +template +void BatchNormLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { - CHECK_NE(top[0], bottom[0]) << this->type() << " Layer does not " - "allow in-place computation."; - - top[0]->Reshape(bottom[0]->num(), bottom[0]->channels(), - bottom[0]->height(), bottom[0]->width()); - - x_norm_.Reshape(bottom[0]->num(), bottom[0]->channels(), - bottom[0]->height(), bottom[0]->width()); - // Figure out the dimensions - N_ = bottom[0]->num(); - C_ = bottom[0]->channels(); - H_ = bottom[0]->height(); - W_ = bottom[0]->width(); - var_eps_ = 1e-9; - - // mean - spatial_mean_.Reshape(N_, C_, 1, 1); - batch_mean_.Reshape(1, C_, 1, 1); - // variance - spatial_variance_.Reshape(N_, C_, 1, 1); - batch_variance_.Reshape(1, C_, 1, 1); - // buffer blod - buffer_blob_.Reshape(N_, C_, H_, W_); - - // fill spatial multiplier - spatial_sum_multiplier_.Reshape(1, 1, H_, W_); - Dtype* spatial_multipl_data = spatial_sum_multiplier_.mutable_cpu_data(); - caffe_set(spatial_sum_multiplier_.count(), Dtype(1), - spatial_multipl_data); - caffe_set(spatial_sum_multiplier_.count(), Dtype(0), - spatial_sum_multiplier_.mutable_cpu_diff()); - - // fill batch multiplier - batch_sum_multiplier_.Reshape(N_, 1, 1, 1); - Dtype* batch_multiplier_data = batch_sum_multiplier_.mutable_cpu_data(); - caffe_set(batch_sum_multiplier_.count(), Dtype(1), - batch_multiplier_data); - caffe_set(batch_sum_multiplier_.count(), Dtype(0), - batch_sum_multiplier_.mutable_cpu_diff()); - - // Check if we need to set up the weights - if (this->blobs_.size() > 0) { - LOG(INFO) << "Skipping parameter initialization"; - } else { - this->blobs_.resize(2); - - // fill scale with scale_filler - this->blobs_[0].reset(new Blob(1, C_, 1, 1)); - caffe_set(this->blobs_[0]->count(), Dtype(1), - this->blobs_[0]->mutable_cpu_data()); - - // fill shift with shift_filler - this->blobs_[1].reset(new Blob(1, C_, 1, 1)); - caffe_set(this->blobs_[1]->count(), Dtype(0), - this->blobs_[1]->mutable_cpu_data()); - } // parameter initialization - this->param_propagate_down_.resize(this->blobs_.size(), true); + BatchNormParameter param = this->layer_param_.batch_norm_param(); + moving_average_fraction_ = param.moving_average_fraction(); + use_global_stats_ = this->phase_ == TEST; + if (param.has_use_global_stats()) + use_global_stats_ = param.use_global_stats(); + if (bottom[0]->num_axes() == 1) + channels_ = 1; + else + channels_ = bottom[0]->shape(1); + eps_ = param.eps(); + if (this->blobs_.size() > 0) { + LOG(INFO) << "Skipping parameter initialization"; + } else { + this->blobs_.resize(3); + vector sz; + sz.push_back(channels_); + this->blobs_[0].reset(new Blob(sz)); + this->blobs_[1].reset(new Blob(sz)); + sz[0]=1; + this->blobs_[2].reset(new Blob(sz)); + for (int i = 0; i < 3; ++i) { + caffe_set(this->blobs_[i]->count(), Dtype(0), + this->blobs_[i]->mutable_cpu_data()); + } } +} - template - void BatchNormLayer::Forward_cpu(const vector*>& bottom, +template +void BatchNormLayer::Reshape(const vector*>& bottom, const vector*>& top) { - const Dtype* bottom_data = bottom[0]->cpu_data(); - Dtype* top_data = top[0]->mutable_cpu_data(); - const Dtype* const_top_data = top[0]->cpu_data(); - - const Dtype* scale_data = this->blobs_[0]->cpu_data(); - const Dtype* shift_data = this->blobs_[1]->cpu_data(); - - // put the squares of bottom into buffer_blob_ - caffe_powx(bottom[0]->count(), bottom_data, Dtype(2), - buffer_blob_.mutable_cpu_data()); + if (bottom[0]->num_axes() >= 1) + CHECK_EQ(bottom[0]->shape(1), channels_); + top[0]->ReshapeLike(*bottom[0]); + + vector sz; + sz.push_back(channels_); + mean_.Reshape(sz); + variance_.Reshape(sz); + temp_.ReshapeLike(*bottom[0]); + x_norm_.ReshapeLike(*bottom[0]); + sz[0]=bottom[0]->shape(0); + batch_sum_multiplier_.Reshape(sz); + + int spatial_dim = bottom[0]->count()/(channels_*bottom[0]->shape(0)); + if (spatial_sum_multiplier_.num_axes() == 0 || + spatial_sum_multiplier_.shape(0) != spatial_dim) { + sz[0] = spatial_dim; + spatial_sum_multiplier_.Reshape(sz); + Dtype* multiplier_data = spatial_sum_multiplier_.mutable_cpu_data(); + caffe_set(spatial_sum_multiplier_.count(), Dtype(1), multiplier_data); + } + int numbychans = channels_*bottom[0]->shape(0); + if (num_by_chans_.num_axes() == 0 || + num_by_chans_.shape(0) != numbychans) { + sz[0] = numbychans; + num_by_chans_.Reshape(sz); + caffe_set(batch_sum_multiplier_.count(), Dtype(1), + batch_sum_multiplier_.mutable_cpu_data()); + } +} + +template +void BatchNormLayer::Forward_cpu(const vector*>& bottom, + const vector*>& top) { + const Dtype* bottom_data = bottom[0]->cpu_data(); + Dtype* top_data = top[0]->mutable_cpu_data(); + int num = bottom[0]->shape(0); + int spatial_dim = bottom[0]->count()/(bottom[0]->shape(0)*channels_); + + // elementwise square + caffe_powx(bottom[0]->count(), bottom_data, Dtype(2), + temp_.mutable_cpu_data()); + + if (use_global_stats_) { + // use the stored mean/variance estimates. TODO(cdoersch): allow an option + // to use an unbiased variance estimate, like the paper does. + const Dtype scale_factor = 1 / this->blobs_[2]->cpu_data()[0]; + caffe_cpu_scale(variance_.count(), scale_factor, + this->blobs_[0]->cpu_data(), mean_.mutable_cpu_data()); + caffe_cpu_scale(variance_.count(), scale_factor, + this->blobs_[1]->cpu_data(), variance_.mutable_cpu_data()); + } else { // computes variance using var(X) = E(X^2) - (EX)^2 - // EX across spatial - caffe_cpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, - Dtype(1. / (H_ * W_)), bottom_data, - spatial_sum_multiplier_.cpu_data(), Dtype(0), - spatial_mean_.mutable_cpu_data()); - // EX across batch - caffe_cpu_gemv(CblasTrans, N_, C_, Dtype(1. / N_), - spatial_mean_.cpu_data(), - batch_sum_multiplier_.cpu_data(), Dtype(0), - batch_mean_.mutable_cpu_data()); - - // E(X^2) across spatial - caffe_cpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, - Dtype(1. / (H_ * W_)), buffer_blob_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), Dtype(0), - spatial_variance_.mutable_cpu_data()); - // E(X^2) across batch - caffe_cpu_gemv(CblasTrans, N_, C_, Dtype(1. / N_), - spatial_variance_.cpu_data(), - batch_sum_multiplier_.cpu_data(), Dtype(0), - batch_variance_.mutable_cpu_data()); - - caffe_powx(batch_mean_.count(), batch_mean_.cpu_data(), Dtype(2), - buffer_blob_.mutable_cpu_data()); // (EX)^2 - caffe_sub(batch_mean_.count(), batch_variance_.cpu_data(), - buffer_blob_.cpu_data(), - batch_variance_.mutable_cpu_data()); // variance - - // do mean and variance normalization - // subtract mean - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_, - C_, 1, Dtype(1), - batch_sum_multiplier_.cpu_data(), - batch_mean_.cpu_data(), Dtype(0), - spatial_mean_.mutable_cpu_data()); - - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, - H_ * W_, 1, Dtype(-1), - spatial_mean_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), Dtype(0), - buffer_blob_.mutable_cpu_data()); - - caffe_add(buffer_blob_.count(), bottom_data, - buffer_blob_.cpu_data(), top_data); - - // normalize variance - caffe_add_scalar(batch_variance_.count(), var_eps_, - batch_variance_.mutable_cpu_data()); - caffe_powx(batch_variance_.count(), - batch_variance_.cpu_data(), Dtype(0.5), - batch_variance_.mutable_cpu_data()); - - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_, - C_, 1, Dtype(1), - batch_sum_multiplier_.cpu_data(), - batch_variance_.cpu_data(), Dtype(0), - spatial_variance_.mutable_cpu_data()); - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, - N_ * C_, H_ * W_, 1, Dtype(1), - spatial_variance_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), Dtype(0), - buffer_blob_.mutable_cpu_data()); - - caffe_div(buffer_blob_.count(), const_top_data, - buffer_blob_.cpu_data(), top_data); - - // Saving x_norm - caffe_copy(buffer_blob_.count(), const_top_data, - x_norm_.mutable_cpu_data()); - // scale - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), - batch_sum_multiplier_.cpu_data(), scale_data, Dtype(0), - spatial_variance_.mutable_cpu_data()); - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, - H_ * W_, 1, Dtype(1), - spatial_variance_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), Dtype(0), - buffer_blob_.mutable_cpu_data()); - caffe_mul(buffer_blob_.count(), top_data, - buffer_blob_.cpu_data(), top_data); - - // shift - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), - batch_sum_multiplier_.cpu_data(), shift_data, Dtype(0), - spatial_mean_.mutable_cpu_data()); - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, - N_ * C_, H_ * W_, 1, Dtype(1), - spatial_mean_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), Dtype(0), - buffer_blob_.mutable_cpu_data()); - caffe_add(buffer_blob_.count(), const_top_data, - buffer_blob_.cpu_data(), top_data); + caffe_cpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, + 1. / (num * spatial_dim), bottom_data, + spatial_sum_multiplier_.cpu_data(), 0., + num_by_chans_.mutable_cpu_data()); + caffe_cpu_gemv(CblasTrans, num, channels_, 1., + num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0., + mean_.mutable_cpu_data()); + caffe_cpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, + 1. / (num * spatial_dim), temp_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), 0., + num_by_chans_.mutable_cpu_data()); + caffe_cpu_gemv(CblasTrans, num, channels_, 1., + num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0., + variance_.mutable_cpu_data()); + this->blobs_[2]->mutable_cpu_data()[0] *= moving_average_fraction_; + this->blobs_[2]->mutable_cpu_data()[0] += 1; + caffe_cpu_axpby(mean_.count(), Dtype(1), mean_.cpu_data(), + moving_average_fraction_, this->blobs_[0]->mutable_cpu_data()); + Dtype m = Dtype(bottom[0]->count()/channels_); + caffe_cpu_axpby(variance_.count(), m/(m-1), variance_.cpu_data(), + moving_average_fraction_, this->blobs_[1]->mutable_cpu_data()); } + // elementwise square of mean + caffe_powx(mean_.count(), mean_.cpu_data(), Dtype(2), + temp_.mutable_cpu_data()); - template - void BatchNormLayer::Backward_cpu(const vector*>& top, - const vector& propagate_down, - const vector*>& bottom) { - const Dtype* top_diff = top[0]->cpu_diff(); - const Dtype* bottom_data = bottom[0]->cpu_data(); - Dtype* bottom_diff = bottom[0]->mutable_cpu_diff(); - - Dtype* scale_diff = this->blobs_[0]->mutable_cpu_diff(); - Dtype* shift_diff = this->blobs_[1]->mutable_cpu_diff(); - const Dtype* scale_data = this->blobs_[0]->cpu_data(); - -// Propagate layer to parameters - // gradient w.r.t. scale - caffe_mul(buffer_blob_.count(), x_norm_.cpu_data(), - top_diff, buffer_blob_.mutable_cpu_data()); - // EX across spatial - caffe_cpu_gemv(CblasNoTrans, N_ * C_, - H_ * W_, Dtype(1), buffer_blob_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), Dtype(0), - spatial_variance_.mutable_cpu_diff()); - // EX across batch - caffe_cpu_gemv(CblasTrans, N_, C_, Dtype(1), - spatial_variance_.cpu_diff(), - batch_sum_multiplier_.cpu_data(), Dtype(0), scale_diff); - - // gradient w.r.t. shift - // EX across spatial - caffe_cpu_gemv(CblasNoTrans, N_ * C_, - H_ * W_, Dtype(1), top_diff, - spatial_sum_multiplier_.cpu_data(), - Dtype(0), spatial_mean_.mutable_cpu_diff()); - // EX across batch - caffe_cpu_gemv(CblasTrans, N_, C_, - Dtype(1), spatial_mean_.cpu_diff(), - batch_sum_multiplier_.cpu_data(), - Dtype(0), shift_diff); + caffe_sub(mean_.count(), variance_.cpu_data(), temp_.cpu_data(), + variance_.mutable_cpu_data()); // variance -// Propagate down + // normalize variance + caffe_add_scalar(variance_.count(), eps_, variance_.mutable_cpu_data()); + caffe_powx(variance_.count(), variance_.cpu_data(), Dtype(0.5), + variance_.mutable_cpu_data()); - // put scale * top_diff to buffer_blob_ - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), - batch_sum_multiplier_.cpu_data(), scale_data, Dtype(0), - spatial_variance_.mutable_cpu_data()); - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, - H_ * W_, 1, Dtype(1), - spatial_variance_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), Dtype(0), - buffer_blob_.mutable_cpu_data()); - caffe_mul(buffer_blob_.count(), top_diff, buffer_blob_.cpu_data(), - buffer_blob_.mutable_cpu_data()); - - // use new top diff for computation - caffe_mul(buffer_blob_.count(), x_norm_.cpu_data(), - buffer_blob_.cpu_data(), bottom_diff); - // EX across spatial - caffe_cpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, - Dtype(1), bottom_diff, - spatial_sum_multiplier_.cpu_data(), Dtype(0), - spatial_mean_.mutable_cpu_data()); - // EX across batch - caffe_cpu_gemv(CblasTrans, N_, C_, Dtype(1), - spatial_mean_.cpu_data(), - batch_sum_multiplier_.cpu_data(), Dtype(0), - batch_mean_.mutable_cpu_data()); - - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, - N_, C_, 1, Dtype(1), - batch_sum_multiplier_.cpu_data(), - batch_mean_.cpu_data(), Dtype(0), - spatial_mean_.mutable_cpu_data()); - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, - H_ * W_, 1, Dtype(1), - spatial_mean_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), Dtype(0), - bottom_diff); - - caffe_mul(buffer_blob_.count(), - x_norm_.cpu_data(), bottom_diff, bottom_diff); - - // EX across spatial - caffe_cpu_gemv(CblasNoTrans, N_ * C_, - H_ * W_, Dtype(1), buffer_blob_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), Dtype(0), - spatial_mean_.mutable_cpu_data()); - // EX across batch - caffe_cpu_gemv(CblasTrans, N_, C_, Dtype(1), - spatial_mean_.cpu_data(), - batch_sum_multiplier_.cpu_data(), Dtype(0), - batch_mean_.mutable_cpu_data()); - - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, - N_, C_, 1, Dtype(1), - batch_sum_multiplier_.cpu_data(), - batch_mean_.cpu_data(), Dtype(0), - spatial_mean_.mutable_cpu_data()); - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, - N_ * C_, H_ * W_, 1, Dtype(1), - spatial_mean_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), Dtype(1), bottom_diff); - - caffe_cpu_axpby(buffer_blob_.count(), Dtype(1), - buffer_blob_.cpu_data(), Dtype(-1. / (N_ * H_ * W_)), - bottom_diff); - - // put the squares of bottom into buffer_blob_ -// caffe_powx(buffer_blob_.count(), bottom_data, Dtype(2), -// buffer_blob_.mutable_cpu_data()); + // do mean and variance normalization + if (bottom[0] != top[0]) { + caffe_copy(bottom[0]->count(), bottom_data, top_data); + } + // subtract mean + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, + batch_sum_multiplier_.cpu_data(), mean_.cpu_data(), 0., + num_by_chans_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, channels_ * num, + spatial_dim, 1, -1, num_by_chans_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), 1., top_data); + // replicate variance to input size + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, + batch_sum_multiplier_.cpu_data(), variance_.cpu_data(), 0., + num_by_chans_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, channels_ * num, + spatial_dim, 1, 1., num_by_chans_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), 0., temp_.mutable_cpu_data()); + caffe_div(temp_.count(), top_data, temp_.cpu_data(), top_data); + // TODO(cdoersch): The caching is only needed because later in-place layers + // might clobber the data. Can we skip this if they won't? + caffe_copy(x_norm_.count(), top_data, + x_norm_.mutable_cpu_data()); +} + +template +void BatchNormLayer::Backward_cpu(const vector*>& top, + const vector& propagate_down, + const vector*>& bottom) { + CHECK(!use_global_stats_); + const Dtype* top_diff; + if (bottom[0] != top[0]) { + top_diff = top[0]->cpu_diff(); + } else { + caffe_copy(x_norm_.count(), top[0]->cpu_diff(), x_norm_.mutable_cpu_diff()); + top_diff = x_norm_.cpu_diff(); + } + const Dtype* top_data = x_norm_.cpu_data(); + Dtype* bottom_diff = bottom[0]->mutable_cpu_diff(); + int num = bottom[0]->shape()[0]; + int spatial_dim = bottom[0]->count()/(bottom[0]->shape(0)*channels_); + // if Y = (X-mean(X))/(sqrt(var(X)+eps)), then + // + // dE(Y)/dX = + // (dE/dY - mean(dE/dY) - mean(dE/dY \cdot Y) \cdot Y) + // ./ sqrt(var(X) + eps) + // + // where \cdot and ./ are hadamard product and elementwise division, + // respectively, dE/dY is the top diff, and mean/var/sum are all computed + // along all dimensions except the channels dimension. In the above + // equation, the operations allow for expansion (i.e. broadcast) along all + // dimensions except the channels dimension where required. + + // sum(dE/dY \cdot Y) + caffe_mul(temp_.count(), top_data, top_diff, bottom_diff); + caffe_cpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, 1., + bottom_diff, spatial_sum_multiplier_.cpu_data(), 0., + num_by_chans_.mutable_cpu_data()); + caffe_cpu_gemv(CblasTrans, num, channels_, 1., + num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0., + mean_.mutable_cpu_data()); + + // reshape (broadcast) the above + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, + batch_sum_multiplier_.cpu_data(), mean_.cpu_data(), 0., + num_by_chans_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, channels_ * num, + spatial_dim, 1, 1., num_by_chans_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), 0., bottom_diff); + + // sum(dE/dY \cdot Y) \cdot Y + caffe_mul(temp_.count(), top_data, bottom_diff, bottom_diff); + + // sum(dE/dY)-sum(dE/dY \cdot Y) \cdot Y + caffe_cpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, 1., + top_diff, spatial_sum_multiplier_.cpu_data(), 0., + num_by_chans_.mutable_cpu_data()); + caffe_cpu_gemv(CblasTrans, num, channels_, 1., + num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0., + mean_.mutable_cpu_data()); + // reshape (broadcast) the above to make + // sum(dE/dY)-sum(dE/dY \cdot Y) \cdot Y + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, + batch_sum_multiplier_.cpu_data(), mean_.cpu_data(), 0., + num_by_chans_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, num * channels_, + spatial_dim, 1, 1., num_by_chans_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), 1., bottom_diff); + + // dE/dY - mean(dE/dY)-mean(dE/dY \cdot Y) \cdot Y + caffe_cpu_axpby(temp_.count(), Dtype(1), top_diff, + Dtype(-1. / (num * spatial_dim)), bottom_diff); + + // note: temp_ still contains sqrt(var(X)+eps), computed during the forward + // pass. + caffe_div(temp_.count(), bottom_diff, temp_.cpu_data(), bottom_diff); +} - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, - N_, C_, 1, Dtype(1), - batch_sum_multiplier_.cpu_data(), - batch_variance_.cpu_data(), Dtype(0), - spatial_variance_.mutable_cpu_data()); - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, - N_ * C_, H_ * W_, 1, Dtype(1), - spatial_variance_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), Dtype(0), - buffer_blob_.mutable_cpu_data()); - caffe_div(buffer_blob_.count(), bottom_diff, - buffer_blob_.cpu_data(), bottom_diff); - } #ifdef CPU_ONLY STUB_GPU(BatchNormLayer); #endif - INSTANTIATE_CLASS(BatchNormLayer); - REGISTER_LAYER_CLASS(BatchNorm); +INSTANTIATE_CLASS(BatchNormLayer); +REGISTER_LAYER_CLASS(BatchNorm); } // namespace caffe - diff --git a/src/caffe/layers/batch_norm_layer.cu b/src/caffe/layers/batch_norm_layer.cu index e87f8c62f43..cd8924a451d 100644 --- a/src/caffe/layers/batch_norm_layer.cu +++ b/src/caffe/layers/batch_norm_layer.cu @@ -2,227 +2,166 @@ #include #include "caffe/common_layers.hpp" -#include "caffe/filler.hpp" #include "caffe/layer.hpp" #include "caffe/util/math_functions.hpp" namespace caffe { - template - void BatchNormLayer::Forward_gpu(const vector*>& bottom, - const vector*>& top) { - const Dtype* bottom_data = bottom[0]->gpu_data(); - const Dtype* const_top_data = top[0]->gpu_data(); - Dtype* top_data = top[0]->mutable_gpu_data(); - Dtype* spatial_mean_data = spatial_mean_.mutable_gpu_data(); - Dtype* buffer_data = buffer_blob_.mutable_gpu_data(); - const Dtype* const_buffer_data = buffer_blob_.gpu_data(); - - - // put the squares of bottom into buffer_blob_ - caffe_gpu_powx(bottom[0]->count(), bottom_data, Dtype(2), - buffer_blob_.mutable_gpu_data()); +template +void BatchNormLayer::Forward_gpu(const vector*>& bottom, + const vector*>& top) { + const Dtype* bottom_data = bottom[0]->gpu_data(); + Dtype* top_data = top[0]->mutable_gpu_data(); + int num = bottom[0]->shape(0); + int spatial_dim = bottom[0]->count()/(channels_*bottom[0]->shape(0)); + + // elementwise square + caffe_gpu_powx(bottom[0]->count(), bottom_data, Dtype(2), + temp_.mutable_gpu_data()); + + if (use_global_stats_) { + // use the stored mean/variance estimates. TODO(cdoersch): allow an option + // to use an unbiased variance estimate, like the paper does. + const Dtype scale_factor = 1 / this->blobs_[2]->cpu_data()[0]; + caffe_gpu_scale(variance_.count(), scale_factor, + this->blobs_[0]->gpu_data(), mean_.mutable_gpu_data()); + caffe_gpu_scale(variance_.count(), scale_factor, + this->blobs_[1]->gpu_data(), variance_.mutable_gpu_data()); + } else { // computes variance using var(X) = E(X^2) - (EX)^2 - // EX across spatial - caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, - Dtype(1. / (H_ * W_)), - bottom_data, spatial_sum_multiplier_.gpu_data(), - Dtype(0), spatial_mean_data); - // EX across batch - caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1. / N_), - spatial_mean_.gpu_data(), - batch_sum_multiplier_.gpu_data(), Dtype(0), - batch_mean_.mutable_gpu_data()); - - // E(X^2) across spatial - caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, - Dtype(1. / (H_ * W_)), buffer_data, - spatial_sum_multiplier_.gpu_data(), Dtype(0), - spatial_variance_.mutable_gpu_data()); - // E(X^2) across batch - caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1. / N_), - spatial_variance_.gpu_data(), - batch_sum_multiplier_.gpu_data(), Dtype(0), - batch_variance_.mutable_gpu_data()); - - caffe_gpu_powx(batch_mean_.count(), batch_mean_.gpu_data(), - Dtype(2), buffer_blob_.mutable_gpu_data()); // (EX)^2 - caffe_gpu_sub(batch_mean_.count(), batch_variance_.gpu_data(), - buffer_data, batch_variance_.mutable_gpu_data()); // variance - - // do mean and variance normalization - // subtract mean - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), - batch_sum_multiplier_.gpu_data(), batch_mean_.gpu_data(), Dtype(0), - spatial_mean_data); - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, H_ * W_, - 1, -Dtype(1), - spatial_mean_.gpu_data(), spatial_sum_multiplier_.gpu_data(), Dtype(0), - buffer_blob_.mutable_gpu_data()); - - caffe_gpu_add(buffer_blob_.count(), bottom_data, buffer_data, top_data); - - // normalize variance - caffe_gpu_add_scalar(batch_variance_.count(), var_eps_, - batch_variance_.mutable_gpu_data()); - caffe_gpu_powx(batch_variance_.count(), batch_variance_.gpu_data(), - Dtype(0.5), batch_variance_.mutable_gpu_data()); - - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), - batch_sum_multiplier_.gpu_data(), batch_variance_.gpu_data(), Dtype(0), - spatial_variance_.mutable_gpu_data()); - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, - H_ * W_, 1, Dtype(1), - spatial_variance_.gpu_data(), spatial_sum_multiplier_.gpu_data(), - Dtype(0), buffer_blob_.mutable_gpu_data()); - - caffe_gpu_div(buffer_blob_.count(), top_data, buffer_data, top_data); - - // Saving x_norm - caffe_copy(top[0]->count(), const_top_data, x_norm_.mutable_gpu_data()); - - // scale - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), - batch_sum_multiplier_.gpu_data(), this->blobs_[0]->gpu_data(), - Dtype(0), spatial_variance_.mutable_gpu_data()); - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, - H_ * W_, 1, Dtype(1), - spatial_variance_.gpu_data(), spatial_sum_multiplier_.gpu_data(), - Dtype(0), buffer_blob_.mutable_gpu_data()); - - caffe_gpu_mul(buffer_blob_.count(), top_data, buffer_data, top_data); - - // shift - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), - batch_sum_multiplier_.gpu_data(), - this->blobs_[1]->gpu_data(), Dtype(0), - spatial_mean_data); - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, H_ * W_, 1, - Dtype(1), - spatial_mean_.gpu_data(), spatial_sum_multiplier_.gpu_data(), Dtype(0), - buffer_blob_.mutable_gpu_data()); - caffe_gpu_add(buffer_blob_.count(), top_data, buffer_data, top_data); + caffe_gpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, + 1. / (num * spatial_dim), bottom_data, + spatial_sum_multiplier_.gpu_data(), 0., + num_by_chans_.mutable_gpu_data()); + caffe_gpu_gemv(CblasTrans, num, channels_, 1., + num_by_chans_.gpu_data(), batch_sum_multiplier_.gpu_data(), 0., + mean_.mutable_gpu_data()); + caffe_gpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, + 1. / (num * spatial_dim), temp_.gpu_data(), + spatial_sum_multiplier_.gpu_data(), 0., + num_by_chans_.mutable_gpu_data()); + caffe_gpu_gemv(CblasTrans, num, channels_, 1., + num_by_chans_.gpu_data(), batch_sum_multiplier_.gpu_data(), 0., + variance_.mutable_gpu_data()); + this->blobs_[2]->mutable_cpu_data()[0] *= moving_average_fraction_; + this->blobs_[2]->mutable_cpu_data()[0] += 1; + caffe_gpu_axpby(mean_.count(), Dtype(1), mean_.gpu_data(), + moving_average_fraction_, this->blobs_[0]->mutable_gpu_data()); + Dtype m = Dtype(bottom[0]->count()/channels_); + caffe_gpu_axpby(variance_.count(), m/(m-1), variance_.gpu_data(), + moving_average_fraction_, this->blobs_[1]->mutable_gpu_data()); } + // elementwise square of mean + caffe_gpu_powx(mean_.count(), mean_.gpu_data(), Dtype(2), + temp_.mutable_gpu_data()); + + caffe_gpu_sub(mean_.count(), variance_.gpu_data(), temp_.gpu_data(), + variance_.mutable_gpu_data()); // variance + + // normalize variance + caffe_gpu_add_scalar(variance_.count(), eps_, variance_.mutable_gpu_data()); + caffe_gpu_powx(variance_.count(), variance_.gpu_data(), Dtype(0.5), + variance_.mutable_gpu_data()); - template - void BatchNormLayer::Backward_gpu(const vector*>& top, - const vector& propagate_down, - const vector*>& bottom) { - const Dtype* top_diff = top[0]->gpu_diff(); - const Dtype* top_data = top[0]->gpu_data(); - const Dtype* bottom_data = bottom[0]->gpu_data(); - Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - const Dtype* const_bottom_diff = bottom[0]->gpu_diff(); - Dtype* spatial_mean_data = spatial_mean_.mutable_gpu_data(); - Dtype* buffer_data = buffer_blob_.mutable_gpu_data(); - const Dtype* const_buffer_data = buffer_blob_.gpu_data(); - - // Propage to layer params - // gradient w.r.t. scale - caffe_gpu_mul(buffer_blob_.count(), x_norm_.gpu_data(), - top_diff, buffer_blob_.mutable_gpu_data()); - // EX across spatial - caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, Dtype(1), - buffer_data, spatial_sum_multiplier_.gpu_data(), Dtype(0), - spatial_variance_.mutable_gpu_data()); - // EX across batch - caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1), - spatial_variance_.gpu_data(), - batch_sum_multiplier_.gpu_data(), Dtype(0), - this->blobs_[0]->mutable_gpu_diff()); - - // gradient w.r.t. shift - // EX across spatial - caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, Dtype(1), - top_diff, spatial_sum_multiplier_.gpu_data(), - Dtype(0), spatial_mean_data); - // EX across batch - caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1), - spatial_mean_.gpu_data(), - batch_sum_multiplier_.gpu_data(), Dtype(0), - this->blobs_[1]->mutable_gpu_diff()); - - // Propagate down - // scale top diff - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), - batch_sum_multiplier_.gpu_data(), this->blobs_[0]->gpu_data(), - Dtype(0), spatial_variance_.mutable_gpu_data()); - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, - H_ * W_, 1, Dtype(1), - spatial_variance_.gpu_data(), spatial_sum_multiplier_.gpu_data(), - Dtype(0), - buffer_blob_.mutable_gpu_data()); - caffe_gpu_mul(buffer_blob_.count(), top_diff, buffer_data, - buffer_blob_.mutable_gpu_data()); - - // use new top diff for computation - caffe_gpu_mul(buffer_blob_.count(), x_norm_.gpu_data(), - buffer_data, bottom_diff); - // EX across spatial - caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, - Dtype(1), bottom_diff, - spatial_sum_multiplier_.gpu_data(), Dtype(0), spatial_mean_data); - // EX across batch - caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1), - spatial_mean_.gpu_data(), - batch_sum_multiplier_.gpu_data(), Dtype(0), - batch_mean_.mutable_gpu_data()); - - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), - batch_sum_multiplier_.gpu_data(), - batch_mean_.gpu_data(), Dtype(0), - spatial_mean_data); - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, - H_ * W_, 1, Dtype(1), spatial_mean_.gpu_data(), - spatial_sum_multiplier_.gpu_data(), Dtype(0), - bottom_diff); - - caffe_gpu_mul(buffer_blob_.count(), x_norm_.gpu_data(), - bottom_diff, bottom_diff); - - // EX across spatial - caffe_gpu_gemv(CblasNoTrans, N_ * C_, H_ * W_, Dtype(1), - buffer_data, spatial_sum_multiplier_.gpu_data(), - Dtype(0), spatial_mean_data); - - // EX across batch - caffe_gpu_gemv(CblasTrans, N_, C_, Dtype(1), - spatial_mean_.gpu_data(), - batch_sum_multiplier_.gpu_data(), Dtype(0), - batch_mean_.mutable_gpu_data()); - - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, - C_, 1, Dtype(1), - batch_sum_multiplier_.gpu_data(), - batch_mean_.gpu_data(), Dtype(0), - spatial_mean_data); - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, - H_ * W_, 1, Dtype(1), - spatial_mean_.gpu_data(), spatial_sum_multiplier_.gpu_data(), - Dtype(1), - bottom_diff); - - caffe_gpu_axpby(buffer_blob_.count(), Dtype(1), buffer_data, - Dtype(-1. / (N_ * H_ * W_)), - bottom_diff); - - // put the squares of bottom into buffer_blob_ -// caffe_gpu_powx(buffer_blob_.count(), bottom_data, Dtype(2), -// buffer_blob_.mutable_gpu_data()); - - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_, C_, 1, Dtype(1), - batch_sum_multiplier_.gpu_data(), batch_variance_.gpu_data(), Dtype(0), - spatial_variance_.mutable_gpu_data()); - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, N_ * C_, - H_ * W_, 1, Dtype(1), - spatial_variance_.gpu_data(), spatial_sum_multiplier_.gpu_data(), - Dtype(0), - buffer_blob_.mutable_gpu_data()); - - caffe_gpu_div(buffer_blob_.count(), const_bottom_diff, - const_buffer_data, bottom_diff); + // do mean and variance normalization + if (bottom[0] != top[0]) { + caffe_copy(bottom[0]->count(), bottom_data, top_data); } + // subtract mean + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, + batch_sum_multiplier_.gpu_data(), mean_.gpu_data(), 0., + num_by_chans_.mutable_gpu_data()); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, channels_ * num, + spatial_dim, 1, -1, num_by_chans_.gpu_data(), + spatial_sum_multiplier_.gpu_data(), 1., top_data); + // replicate variance to input size + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, + batch_sum_multiplier_.gpu_data(), variance_.gpu_data(), 0., + num_by_chans_.mutable_gpu_data()); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, channels_ * num, + spatial_dim, 1, 1., num_by_chans_.gpu_data(), + spatial_sum_multiplier_.gpu_data(), 0., temp_.mutable_gpu_data()); + caffe_gpu_div(temp_.count(), top_data, temp_.gpu_data(), top_data); + // TODO(cdoersch): The caching is only needed because later in-place layers + // might clobber the data. Can we skip this if they won't? + caffe_copy(x_norm_.count(), top_data, + x_norm_.mutable_gpu_data()); +} + +template +void BatchNormLayer::Backward_gpu(const vector*>& top, + const vector& propagate_down, + const vector*>& bottom) { + CHECK(!use_global_stats_); + const Dtype* top_diff; + if (bottom[0] != top[0]) { + top_diff = top[0]->gpu_diff(); + } else { + caffe_copy(x_norm_.count(), top[0]->gpu_diff(), x_norm_.mutable_gpu_diff()); + top_diff = x_norm_.gpu_diff(); + } + const Dtype* top_data = x_norm_.gpu_data(); + Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + int num = bottom[0]->shape()[0]; + int spatial_dim = bottom[0]->count()/(channels_*bottom[0]->shape(0)); + // if Y = (X-mean(X))/(sqrt(var(X)+eps)), then + // + // dE(Y)/dX = + // (dE/dY - mean(dE/dY) - mean(dE/dY \cdot Y) \cdot Y) + // ./ sqrt(var(X) + eps) + // + // where \cdot and ./ are hadamard product and elementwise division, + // respectively, dE/dY is the top diff, and mean/var/sum are all computed + // along all dimensions except the channels dimension. In the above + // equation, the operations allow for expansion (i.e. broadcast) along all + // dimensions except the channels dimension where required. + + // sum(dE/dY \cdot Y) + caffe_gpu_mul(temp_.count(), top_data, top_diff, bottom_diff); + caffe_gpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, 1., + bottom_diff, spatial_sum_multiplier_.gpu_data(), 0., + num_by_chans_.mutable_gpu_data()); + caffe_gpu_gemv(CblasTrans, num, channels_, 1., + num_by_chans_.gpu_data(), batch_sum_multiplier_.gpu_data(), 0., + mean_.mutable_gpu_data()); + + // reshape (broadcast) the above + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, + batch_sum_multiplier_.gpu_data(), mean_.gpu_data(), 0., + num_by_chans_.mutable_gpu_data()); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, channels_ * num, + spatial_dim, 1, 1., num_by_chans_.gpu_data(), + spatial_sum_multiplier_.gpu_data(), 0., bottom_diff); + + // sum(dE/dY \cdot Y) \cdot Y + caffe_gpu_mul(temp_.count(), top_data, bottom_diff, bottom_diff); + + // sum(dE/dY)-sum(dE/dY \cdot Y) \cdot Y + caffe_gpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, 1., + top_diff, spatial_sum_multiplier_.gpu_data(), 0., + num_by_chans_.mutable_gpu_data()); + caffe_gpu_gemv(CblasTrans, num, channels_, 1., + num_by_chans_.gpu_data(), batch_sum_multiplier_.gpu_data(), 0., + mean_.mutable_gpu_data()); + // reshape (broadcast) the above to make + // sum(dE/dY)-sum(dE/dY \cdot Y) \cdot Y + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, + batch_sum_multiplier_.gpu_data(), mean_.gpu_data(), 0., + num_by_chans_.mutable_gpu_data()); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, num * channels_, + spatial_dim, 1, 1., num_by_chans_.gpu_data(), + spatial_sum_multiplier_.gpu_data(), 1., bottom_diff); + + // dE/dY - mean(dE/dY)-mean(dE/dY \cdot Y) \cdot Y + caffe_gpu_axpby(temp_.count(), Dtype(1), top_diff, + Dtype(-1. / (num * spatial_dim)), bottom_diff); + + // note: temp_ still contains sqrt(var(X)+eps), computed during the forward + // pass. + caffe_gpu_div(temp_.count(), bottom_diff, temp_.gpu_data(), bottom_diff); +} + +INSTANTIATE_LAYER_GPU_FUNCS(BatchNormLayer); - INSTANTIATE_LAYER_GPU_FUNCS(BatchNormLayer); -} // namespace caffe +} // namespace caffe diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index 4794991f917..b81f39f90fa 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -301,7 +301,7 @@ message ParamSpec { // NOTE // Update the next available ID when you add a new LayerParameter field. // -// LayerParameter next available layer-specific ID: 139 (last added: tile_param) +// LayerParameter next available layer-specific ID: 140 (last added: batch_norm_param) message LayerParameter { optional string name = 1; // the layer name optional string type = 2; // the layer type @@ -350,6 +350,7 @@ message LayerParameter { // The default for the engine is set by the ENGINE switch at compile-time. optional AccuracyParameter accuracy_param = 102; optional ArgMaxParameter argmax_param = 103; + optional BatchNormParameter batch_norm_param = 139; optional ConcatParameter concat_param = 104; optional ContrastiveLossParameter contrastive_loss_param = 105; optional ConvolutionParameter convolution_param = 106; @@ -461,6 +462,18 @@ message ConcatParameter { optional uint32 concat_dim = 1 [default = 1]; } +message BatchNormParameter { + // If false, accumulate global mean/variance values via a moving average. If + // true, use those accumulated values instead of computing mean/variance + // across the batch. + optional bool use_global_stats = 1; + // How much does the moving average decay each iteration? + optional float moving_average_fraction = 2 [default = .999]; + // Small value to add to the variance estimate so that we don't divide by + // zero. + optional float eps = 3 [default = 1e-5]; +} + message ContrastiveLossParameter { // margin for dissimilar pair optional float margin = 1 [default = 1.0]; diff --git a/src/caffe/test/test_batch_norm_layer.cpp b/src/caffe/test/test_batch_norm_layer.cpp index 704efd5df3d..22b9667f31b 100644 --- a/src/caffe/test/test_batch_norm_layer.cpp +++ b/src/caffe/test/test_batch_norm_layer.cpp @@ -60,7 +60,50 @@ namespace caffe { for ( int k = 0; k < height; ++k ) { for ( int l = 0; l < width; ++l ) { Dtype data = this->blob_top_->data_at(i, j, k, l); - Dtype bottom_data = this->blob_bottom_->data_at(i, j, k, l); + sum += data; + var += data * data; + } + } + } + sum /= height * width * num; + var /= height * width * num; + + const Dtype kErrorBound = 0.001; + // expect zero mean + EXPECT_NEAR(0, sum, kErrorBound); + // expect unit variance + EXPECT_NEAR(1, var, kErrorBound); + } + } + + TYPED_TEST(BatchNormLayerTest, TestForwardInplace) { + typedef typename TypeParam::Dtype Dtype; + Blob blob_inplace(5, 2, 3, 4); + vector*> blob_bottom_vec; + vector*> blob_top_vec; + LayerParameter layer_param; + FillerParameter filler_param; + GaussianFiller filler(filler_param); + filler.Fill(&blob_inplace); + blob_bottom_vec.push_back(&blob_inplace); + blob_top_vec.push_back(&blob_inplace); + + BatchNormLayer layer(layer_param); + layer.SetUp(blob_bottom_vec, blob_top_vec); + layer.Forward(blob_bottom_vec, blob_top_vec); + + // Test mean + int num = blob_inplace.num(); + int channels = blob_inplace.channels(); + int height = blob_inplace.height(); + int width = blob_inplace.width(); + + for (int j = 0; j < channels; ++j) { + Dtype sum = 0, var = 0; + for (int i = 0; i < num; ++i) { + for ( int k = 0; k < height; ++k ) { + for ( int l = 0; l < width; ++l ) { + Dtype data = blob_inplace.data_at(i, j, k, l); sum += data; var += data * data; } From d52bc27ec7bf6c4448b152f0c196fd71be58308a Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 29 Oct 2015 15:04:09 -0700 Subject: [PATCH 286/331] Fix cuDNN vs. cublas copy+paste error --- src/caffe/common.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/caffe/common.cpp b/src/caffe/common.cpp index 3d6418f5992..da043bf2a90 100644 --- a/src/caffe/common.cpp +++ b/src/caffe/common.cpp @@ -170,7 +170,7 @@ void Caffe::SetDevice(const int device_id) { CURAND_CHECK(curandSetPseudoRandomGeneratorSeed(Get().curand_generator_, cluster_seedgen())); #ifdef USE_CUDNN - if (Get().cublas_handle_) CUDNN_CHECK(cudnnDestroy(Get().cudnn_handle_)); + if (Get().cudnn_handle_) CUDNN_CHECK(cudnnDestroy(Get().cudnn_handle_)); CUDNN_CHECK(cudnnCreate(&Get().cudnn_handle_)); #endif } From 285f90035c6da5edf3f6bff283aaa1d757e20593 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Wed, 28 Oct 2015 19:28:24 -0700 Subject: [PATCH 287/331] 32-bit LMDB fix --- examples/mnist/convert_mnist_data.cpp | 10 +++++++--- include/caffe/util/db_lmdb.hpp | 9 +++++++++ src/caffe/util/db_lmdb.cpp | 2 -- 3 files changed, 16 insertions(+), 5 deletions(-) diff --git a/examples/mnist/convert_mnist_data.cpp b/examples/mnist/convert_mnist_data.cpp index 8f29bafde85..371d04248f8 100644 --- a/examples/mnist/convert_mnist_data.cpp +++ b/examples/mnist/convert_mnist_data.cpp @@ -10,10 +10,9 @@ #include #include -#if defined(USE_LEVELDB) && defined(USE_LMDB) +#if defined(USE_LEVELDB) #include #include -#include #endif #include @@ -22,6 +21,10 @@ #include // NOLINT(readability/streams) #include +#if defined(USE_LMDB) +#include "caffe/util/db_lmdb.hpp" +#endif + #include "caffe/proto/caffe.pb.h" #if defined(USE_LEVELDB) && defined(USE_LMDB) @@ -92,7 +95,8 @@ void convert_dataset(const char* image_filename, const char* label_filename, CHECK_EQ(mkdir(db_path, 0744), 0) << "mkdir " << db_path << "failed"; CHECK_EQ(mdb_env_create(&mdb_env), MDB_SUCCESS) << "mdb_env_create failed"; - CHECK_EQ(mdb_env_set_mapsize(mdb_env, 1099511627776), MDB_SUCCESS) // 1TB + CHECK_EQ(mdb_env_set_mapsize(mdb_env, caffe::db::LMDB_MAP_SIZE), + MDB_SUCCESS) << "mdb_env_set_mapsize failed"; CHECK_EQ(mdb_env_open(mdb_env, db_path, 0, 0664), MDB_SUCCESS) << "mdb_env_open failed"; diff --git a/include/caffe/util/db_lmdb.hpp b/include/caffe/util/db_lmdb.hpp index 4e1568ace50..ebe8b3c53cc 100644 --- a/include/caffe/util/db_lmdb.hpp +++ b/include/caffe/util/db_lmdb.hpp @@ -2,6 +2,7 @@ #ifndef CAFFE_UTIL_DB_LMDB_HPP #define CAFFE_UTIL_DB_LMDB_HPP +#include #include #include "lmdb.h" @@ -10,6 +11,14 @@ namespace caffe { namespace db { +#if UINTPTR_MAX == 0xffffffffUL +/* 32-bit, 1GB */ + static const size_t LMDB_MAP_SIZE = 1073741824UL; +#else +/* 64-bit, 1TB */ + static const size_t LMDB_MAP_SIZE = 1099511627776ULL; +#endif + inline void MDB_CHECK(int mdb_status) { CHECK_EQ(mdb_status, MDB_SUCCESS) << mdb_strerror(mdb_status); } diff --git a/src/caffe/util/db_lmdb.cpp b/src/caffe/util/db_lmdb.cpp index 0bc82b53e2b..0e343d9db1b 100644 --- a/src/caffe/util/db_lmdb.cpp +++ b/src/caffe/util/db_lmdb.cpp @@ -7,8 +7,6 @@ namespace caffe { namespace db { -const size_t LMDB_MAP_SIZE = 1099511627776; // 1 TB - void LMDB::Open(const string& source, Mode mode) { MDB_CHECK(mdb_env_create(&mdb_env_)); MDB_CHECK(mdb_env_set_mapsize(mdb_env_, LMDB_MAP_SIZE)); From 713b02f863215719909ada020ef080a585a857e4 Mon Sep 17 00:00:00 2001 From: Michael Houston Date: Fri, 30 Oct 2015 17:55:19 -0700 Subject: [PATCH 288/331] Properly set GPU arena in test and time functions --- tools/caffe.cpp | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/tools/caffe.cpp b/tools/caffe.cpp index e5c19398b21..306a5a55d34 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -197,8 +197,6 @@ int train() { Caffe::set_solver_count(gpus.size()); } - caffe::gpu_memory::arena arena(gpus); - caffe::SignalHandler signal_handler( GetRequestedAction(FLAGS_sigint_effect), GetRequestedAction(FLAGS_sighup_effect)); @@ -246,6 +244,7 @@ int test() { LOG(INFO) << "Use CPU."; Caffe::set_mode(Caffe::CPU); } + // Instantiate the caffe net. Net caffe_net(FLAGS_model, caffe::TEST); caffe_net.CopyTrainedLayersFrom(FLAGS_weights); @@ -313,6 +312,7 @@ int time() { LOG(INFO) << "Use CPU."; Caffe::set_mode(Caffe::CPU); } + // Instantiate the caffe net. Net caffe_net(FLAGS_model, caffe::TRAIN); @@ -402,6 +402,13 @@ int main(int argc, char** argv) { " time benchmark model execution time"); // Run tool or show usage. caffe::GlobalInit(&argc, &argv); + + + // initialize gpu memory arena + vector gpus; + get_gpus(&gpus); + caffe::gpu_memory::arena arena(gpus); + if (argc == 2) { #ifdef WITH_PYTHON_LAYER try { From 36385b7cf8984501e98d433c0b2fa9c3036a3d48 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 27 Oct 2015 23:34:20 -0700 Subject: [PATCH 289/331] Added CUB memory pool. CNMEM pool kept as default if USE_CNMEM set. --- 3rdparty/cnmem/.gitignore | 2 - 3rdparty/cnmem/CMakeLists.txt | 45 - 3rdparty/cnmem/LICENSE | 26 - 3rdparty/cnmem/README.md | 56 - 3rdparty/cnmem/include/cnmem.h | 263 -- 3rdparty/cnmem/src/cnmem.cpp | 1287 ---------- 3rdparty/cnmem/tests/cnmem_tests.cpp | 1001 -------- 3rdparty/cub/cub/agent/agent_histogram.cuh | 783 ++++++ .../cub/agent/agent_radix_sort_downsweep.cuh | 769 ++++++ .../cub/agent/agent_radix_sort_upsweep.cuh | 449 ++++ 3rdparty/cub/cub/agent/agent_reduce.cuh | 423 ++++ .../cub/cub/agent/agent_reduce_by_key.cuh | 701 +++++ 3rdparty/cub/cub/agent/agent_rle.cuh | 831 ++++++ 3rdparty/cub/cub/agent/agent_scan.cuh | 498 ++++ .../cub/cub/agent/agent_segment_fixup.cuh | 374 +++ 3rdparty/cub/cub/agent/agent_select_if.cuh | 698 +++++ 3rdparty/cub/cub/agent/agent_spmv.cuh | 718 ++++++ .../cub/agent/single_pass_scan_operators.cuh | 783 ++++++ .../cub/cub/block/block_discontinuity.cuh | 1148 +++++++++ 3rdparty/cub/cub/block/block_exchange.cuh | 1135 +++++++++ 3rdparty/cub/cub/block/block_histogram.cuh | 415 +++ 3rdparty/cub/cub/block/block_load.cuh | 1235 +++++++++ 3rdparty/cub/cub/block/block_radix_rank.cuh | 485 ++++ 3rdparty/cub/cub/block/block_radix_sort.cuh | 865 +++++++ .../cub/cub/block/block_raking_layout.cuh | 150 ++ 3rdparty/cub/cub/block/block_reduce.cuh | 607 +++++ 3rdparty/cub/cub/block/block_scan.cuh | 2251 +++++++++++++++++ 3rdparty/cub/cub/block/block_shuffle.cuh | 305 +++ 3rdparty/cub/cub/block/block_store.cuh | 959 +++++++ .../block_histogram_atomic.cuh | 82 + .../specializations/block_histogram_sort.cuh | 226 ++ .../specializations/block_reduce_raking.cuh | 222 ++ .../block_reduce_raking_commutative_only.cuh | 202 ++ .../block_reduce_warp_reductions.cuh | 222 ++ .../specializations/block_scan_raking.cuh | 754 ++++++ .../specializations/block_scan_warp_scans.cuh | 379 +++ 3rdparty/cub/cub/cub.cuh | 97 + 3rdparty/cub/cub/device/device_histogram.cuh | 876 +++++++ 3rdparty/cub/cub/device/device_partition.cuh | 275 ++ 3rdparty/cub/cub/device/device_radix_sort.cuh | 795 ++++++ 3rdparty/cub/cub/device/device_reduce.cuh | 684 +++++ .../cub/device/device_run_length_encode.cuh | 281 ++ 3rdparty/cub/cub/device/device_scan.cuh | 419 +++ 3rdparty/cub/cub/device/device_select.cuh | 372 +++ 3rdparty/cub/cub/device/device_spmv.cuh | 178 ++ .../device/dispatch/dispatch_histogram.cuh | 1084 ++++++++ .../device/dispatch/dispatch_radix_sort.cuh | 1128 +++++++++ .../cub/device/dispatch/dispatch_reduce.cuh | 804 ++++++ .../dispatch/dispatch_reduce_by_key.cuh | 530 ++++ .../cub/cub/device/dispatch/dispatch_rle.cuh | 536 ++++ .../cub/cub/device/dispatch/dispatch_scan.cuh | 546 ++++ .../device/dispatch/dispatch_select_if.cuh | 525 ++++ .../cub/cub/device/dispatch/dispatch_spmv.cuh | 763 ++++++ 3rdparty/cub/cub/grid/grid_barrier.cuh | 211 ++ 3rdparty/cub/cub/grid/grid_even_share.cuh | 185 ++ 3rdparty/cub/cub/grid/grid_mapping.cuh | 95 + 3rdparty/cub/cub/grid/grid_queue.cuh | 216 ++ 3rdparty/cub/cub/host/spinlock.cuh | 123 + .../cub/iterator/arg_index_input_iterator.cuh | 256 ++ .../cache_modified_input_iterator.cuh | 240 ++ .../cache_modified_output_iterator.cuh | 254 ++ .../cub/iterator/constant_input_iterator.cuh | 235 ++ .../cub/iterator/counting_input_iterator.cuh | 228 ++ .../cub/iterator/tex_obj_input_iterator.cuh | 310 +++ .../cub/iterator/tex_ref_input_iterator.cuh | 374 +++ .../cub/iterator/transform_input_iterator.cuh | 252 ++ 3rdparty/cub/cub/thread/thread_load.cuh | 454 ++++ 3rdparty/cub/cub/thread/thread_operators.cuh | 314 +++ 3rdparty/cub/cub/thread/thread_reduce.cuh | 169 ++ 3rdparty/cub/cub/thread/thread_scan.cuh | 283 +++ 3rdparty/cub/cub/thread/thread_search.cuh | 154 ++ 3rdparty/cub/cub/thread/thread_store.cuh | 423 ++++ 3rdparty/cub/cub/util_allocator.cuh | 689 +++++ 3rdparty/cub/cub/util_arch.cuh | 198 ++ 3rdparty/cub/cub/util_debug.cuh | 121 + 3rdparty/cub/cub/util_device.cuh | 378 +++ 3rdparty/cub/cub/util_macro.cuh | 107 + 3rdparty/cub/cub/util_namespace.cuh | 41 + 3rdparty/cub/cub/util_ptx.cuh | 727 ++++++ 3rdparty/cub/cub/util_type.cuh | 1011 ++++++++ .../warp/specializations/warp_reduce_shfl.cuh | 473 ++++ .../warp/specializations/warp_reduce_smem.cuh | 357 +++ .../warp/specializations/warp_scan_shfl.cuh | 597 +++++ .../warp/specializations/warp_scan_smem.cuh | 403 +++ 3rdparty/cub/cub/warp/warp_reduce.cuh | 612 +++++ 3rdparty/cub/cub/warp/warp_scan.cuh | 924 +++++++ Makefile | 42 +- include/caffe/util/gpu_memory.hpp | 30 +- src/caffe/util/gpu_memory.cpp | 107 +- 89 files changed, 40099 insertions(+), 2736 deletions(-) delete mode 100644 3rdparty/cnmem/.gitignore delete mode 100644 3rdparty/cnmem/CMakeLists.txt delete mode 100644 3rdparty/cnmem/LICENSE delete mode 100644 3rdparty/cnmem/README.md delete mode 100644 3rdparty/cnmem/include/cnmem.h delete mode 100644 3rdparty/cnmem/src/cnmem.cpp delete mode 100644 3rdparty/cnmem/tests/cnmem_tests.cpp create mode 100644 3rdparty/cub/cub/agent/agent_histogram.cuh create mode 100644 3rdparty/cub/cub/agent/agent_radix_sort_downsweep.cuh create mode 100644 3rdparty/cub/cub/agent/agent_radix_sort_upsweep.cuh create mode 100644 3rdparty/cub/cub/agent/agent_reduce.cuh create mode 100644 3rdparty/cub/cub/agent/agent_reduce_by_key.cuh create mode 100644 3rdparty/cub/cub/agent/agent_rle.cuh create mode 100644 3rdparty/cub/cub/agent/agent_scan.cuh create mode 100644 3rdparty/cub/cub/agent/agent_segment_fixup.cuh create mode 100644 3rdparty/cub/cub/agent/agent_select_if.cuh create mode 100644 3rdparty/cub/cub/agent/agent_spmv.cuh create mode 100644 3rdparty/cub/cub/agent/single_pass_scan_operators.cuh create mode 100644 3rdparty/cub/cub/block/block_discontinuity.cuh create mode 100644 3rdparty/cub/cub/block/block_exchange.cuh create mode 100644 3rdparty/cub/cub/block/block_histogram.cuh create mode 100644 3rdparty/cub/cub/block/block_load.cuh create mode 100644 3rdparty/cub/cub/block/block_radix_rank.cuh create mode 100644 3rdparty/cub/cub/block/block_radix_sort.cuh create mode 100644 3rdparty/cub/cub/block/block_raking_layout.cuh create mode 100644 3rdparty/cub/cub/block/block_reduce.cuh create mode 100644 3rdparty/cub/cub/block/block_scan.cuh create mode 100644 3rdparty/cub/cub/block/block_shuffle.cuh create mode 100644 3rdparty/cub/cub/block/block_store.cuh create mode 100644 3rdparty/cub/cub/block/specializations/block_histogram_atomic.cuh create mode 100644 3rdparty/cub/cub/block/specializations/block_histogram_sort.cuh create mode 100644 3rdparty/cub/cub/block/specializations/block_reduce_raking.cuh create mode 100644 3rdparty/cub/cub/block/specializations/block_reduce_raking_commutative_only.cuh create mode 100644 3rdparty/cub/cub/block/specializations/block_reduce_warp_reductions.cuh create mode 100644 3rdparty/cub/cub/block/specializations/block_scan_raking.cuh create mode 100644 3rdparty/cub/cub/block/specializations/block_scan_warp_scans.cuh create mode 100644 3rdparty/cub/cub/cub.cuh create mode 100644 3rdparty/cub/cub/device/device_histogram.cuh create mode 100644 3rdparty/cub/cub/device/device_partition.cuh create mode 100644 3rdparty/cub/cub/device/device_radix_sort.cuh create mode 100644 3rdparty/cub/cub/device/device_reduce.cuh create mode 100644 3rdparty/cub/cub/device/device_run_length_encode.cuh create mode 100644 3rdparty/cub/cub/device/device_scan.cuh create mode 100644 3rdparty/cub/cub/device/device_select.cuh create mode 100644 3rdparty/cub/cub/device/device_spmv.cuh create mode 100644 3rdparty/cub/cub/device/dispatch/dispatch_histogram.cuh create mode 100644 3rdparty/cub/cub/device/dispatch/dispatch_radix_sort.cuh create mode 100644 3rdparty/cub/cub/device/dispatch/dispatch_reduce.cuh create mode 100644 3rdparty/cub/cub/device/dispatch/dispatch_reduce_by_key.cuh create mode 100644 3rdparty/cub/cub/device/dispatch/dispatch_rle.cuh create mode 100644 3rdparty/cub/cub/device/dispatch/dispatch_scan.cuh create mode 100644 3rdparty/cub/cub/device/dispatch/dispatch_select_if.cuh create mode 100644 3rdparty/cub/cub/device/dispatch/dispatch_spmv.cuh create mode 100644 3rdparty/cub/cub/grid/grid_barrier.cuh create mode 100644 3rdparty/cub/cub/grid/grid_even_share.cuh create mode 100644 3rdparty/cub/cub/grid/grid_mapping.cuh create mode 100644 3rdparty/cub/cub/grid/grid_queue.cuh create mode 100644 3rdparty/cub/cub/host/spinlock.cuh create mode 100644 3rdparty/cub/cub/iterator/arg_index_input_iterator.cuh create mode 100644 3rdparty/cub/cub/iterator/cache_modified_input_iterator.cuh create mode 100644 3rdparty/cub/cub/iterator/cache_modified_output_iterator.cuh create mode 100644 3rdparty/cub/cub/iterator/constant_input_iterator.cuh create mode 100644 3rdparty/cub/cub/iterator/counting_input_iterator.cuh create mode 100644 3rdparty/cub/cub/iterator/tex_obj_input_iterator.cuh create mode 100644 3rdparty/cub/cub/iterator/tex_ref_input_iterator.cuh create mode 100644 3rdparty/cub/cub/iterator/transform_input_iterator.cuh create mode 100644 3rdparty/cub/cub/thread/thread_load.cuh create mode 100644 3rdparty/cub/cub/thread/thread_operators.cuh create mode 100644 3rdparty/cub/cub/thread/thread_reduce.cuh create mode 100644 3rdparty/cub/cub/thread/thread_scan.cuh create mode 100644 3rdparty/cub/cub/thread/thread_search.cuh create mode 100644 3rdparty/cub/cub/thread/thread_store.cuh create mode 100644 3rdparty/cub/cub/util_allocator.cuh create mode 100644 3rdparty/cub/cub/util_arch.cuh create mode 100644 3rdparty/cub/cub/util_debug.cuh create mode 100644 3rdparty/cub/cub/util_device.cuh create mode 100644 3rdparty/cub/cub/util_macro.cuh create mode 100644 3rdparty/cub/cub/util_namespace.cuh create mode 100644 3rdparty/cub/cub/util_ptx.cuh create mode 100644 3rdparty/cub/cub/util_type.cuh create mode 100644 3rdparty/cub/cub/warp/specializations/warp_reduce_shfl.cuh create mode 100644 3rdparty/cub/cub/warp/specializations/warp_reduce_smem.cuh create mode 100644 3rdparty/cub/cub/warp/specializations/warp_scan_shfl.cuh create mode 100644 3rdparty/cub/cub/warp/specializations/warp_scan_smem.cuh create mode 100644 3rdparty/cub/cub/warp/warp_reduce.cuh create mode 100644 3rdparty/cub/cub/warp/warp_scan.cuh diff --git a/3rdparty/cnmem/.gitignore b/3rdparty/cnmem/.gitignore deleted file mode 100644 index e8ab68ab1c0..00000000000 --- a/3rdparty/cnmem/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -# Ignore the build directory created to build the code -build diff --git a/3rdparty/cnmem/CMakeLists.txt b/3rdparty/cnmem/CMakeLists.txt deleted file mode 100644 index c254cd4f9d0..00000000000 --- a/3rdparty/cnmem/CMakeLists.txt +++ /dev/null @@ -1,45 +0,0 @@ -# CMakeLists to build the cnmem library. -cmake_minimum_required(VERSION 2.8.7) -project(cnmem) - -# We need CUDA to build that library. -find_package(CUDA QUIET REQUIRED) -include_directories(${CUDA_INCLUDE_DIRS}) - -# Rules to build the cnmem library. -include_directories(include) -add_definitions(-DCNMEM_DLLEXPORT) -add_library(cnmem SHARED src/cnmem.cpp) -set_target_properties(cnmem PROPERTIES VERSION 1.0.0 SOVERSION 1) -target_link_libraries(cnmem LINK_PUBLIC ${CUDA_LIBRARIES}) -install(TARGETS cnmem RUNTIME DESTINATION bin ARCHIVE DESTINATION lib LIBRARY DESTINATION lib) -install(FILES include/cnmem.h DESTINATION include) - -# Add the tests. -if(WITH_TESTS) - - # Get Google tests. - find_package(GTest QUIET REQUIRED) - include_directories(${GTEST_INCLUDE_DIRS}) - - # Build the executable. - add_executable(cnmem_tests tests/cnmem_tests.cpp) - if(MSVC) - if(MSVC_VERSION GREATER 1700) # Visual Studio 11 or more. - add_definitions(-DUSE_CPP_11) - endif(MSVC_VERSION GREATER 1700) - endif(MSVC) - if(CMAKE_COMPILER_IS_GNUCC) - add_definitions(-std=c++11 -DUSE_CPP_11) - endif(CMAKE_COMPILER_IS_GNUCC) - target_link_libraries(cnmem_tests LINK_PUBLIC cnmem ${CUDA_LIBRARIES} ${GTEST_LIBRARIES} -lpthread) - install(TARGETS cnmem_tests RUNTIME DESTINATION bin) - - # On Windows, we copy the Google test DLL to the bin folder. - if(MSVC) - get_filename_component(gtest_dll_path ${GTEST_LIBRARIES} DIRECTORY) - install(FILES ${gtest_dll_path}/gtest.dll DESTINATION bin) - endif(MSVC) - -endif(WITH_TESTS) - diff --git a/3rdparty/cnmem/LICENSE b/3rdparty/cnmem/LICENSE deleted file mode 100644 index 9f24f8bc1ab..00000000000 --- a/3rdparty/cnmem/LICENSE +++ /dev/null @@ -1,26 +0,0 @@ -Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions -are met: - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - * Neither the name of NVIDIA CORPORATION nor the names of its - contributors may be used to endorse or promote products derived - from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY -EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY -OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - diff --git a/3rdparty/cnmem/README.md b/3rdparty/cnmem/README.md deleted file mode 100644 index 9fcb35d50e8..00000000000 --- a/3rdparty/cnmem/README.md +++ /dev/null @@ -1,56 +0,0 @@ -# CNMeM Library - -Simple library to help the Deep Learning frameworks manage CUDA memory. - -CNMeM is not intended to be a general purpose memory management library. It was designed as a simple -tool for applications which work on a limited number of large memory buffers. - -CNMeM is mostly developed on Ubuntu Linux. It should support other operating systems as well. If you -encounter an issue with the library on other operating systems, please submit a bug (or a fix). - -# Prerequisites - -CNMeM relies on the CUDA toolkit. It uses C++ STL and the Pthread library on Linux. On Windows, it uses -the native Win32 threading library. The build system uses CMake. The unit tests are written using -Google tests (but are not mandatory). - -## CUDA - -The CUDA toolkit is required. We recommend using CUDA >= 7.0 even if earlier versions will work. -* Download from the [CUDA website](https://developer.nvidia.com/cuda-downloads) -* Follow the installation instructions -* Don't forget to set your path. For example: - * `CUDA_HOME=/usr/local/cuda` - * `LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH` - -# Build CNMeM - -## Grab the source - - % cd $HOME - % git clone https://github.com/NVIDIA/cnmem.git cnmem - -## Build CNMeM without the unit tests - - % cd cnmem - % mkdir build - % cd build - % cmake .. - % make - -## Build CNMeM with the unit tests - -To build the tests, you need to add an extra option to the cmake command. - - % cd cnmem - % mkdir build - % cd build - % cmake -DWITH_TESTS=True .. - % make - -## Link with CNMeM - -The source folder contains a header file 'include/cnmem.h' and the build directory contains the -library 'libcnmem.so', 'cnmem.lib/cnmem.dll' or 'libcnmem.dylib', depending on your operating -system. - diff --git a/3rdparty/cnmem/include/cnmem.h b/3rdparty/cnmem/include/cnmem.h deleted file mode 100644 index 19fd2f84022..00000000000 --- a/3rdparty/cnmem/include/cnmem.h +++ /dev/null @@ -1,263 +0,0 @@ -/* ********************************************************************** - * Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of NVIDIA CORPORATION nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY - * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * ********************************************************************** */ -#pragma once - -#ifdef __cplusplus -#include "cstdio" -#else -#include "stdio.h" -#endif -#include "cuda_runtime_api.h" - -#if defined(_MSC_VER) || defined(WIN32) -#ifdef CNMEM_DLLEXPORT -#define CNMEM_API __declspec(dllexport) -#else -#define CNMEM_API __declspec(dllimport) -#endif -#else -#ifdef CNMEM_DLLEXPORT -#define CNMEM_API __attribute__((visibility ("default"))) -#else -#define CNMEM_API -#endif -#endif - -#define CNMEM_VERSION 100 // It corresponds to 1.0.0 - -#ifdef __cplusplus -extern "C" { -#endif - -/* ********************************************************************************************* */ - -typedef enum -{ - CNMEM_STATUS_SUCCESS = 0, - CNMEM_STATUS_CUDA_ERROR, - CNMEM_STATUS_INVALID_ARGUMENT, - CNMEM_STATUS_NOT_INITIALIZED, - CNMEM_STATUS_OUT_OF_MEMORY, - CNMEM_STATUS_UNKNOWN_ERROR -} cnmemStatus_t; - -/* ********************************************************************************************* */ - -typedef enum -{ - CNMEM_FLAGS_DEFAULT = 0, /// Default flags. - CNMEM_FLAGS_CANNOT_GROW = 1, /// Prevent the manager from growing its memory consumption. - CNMEM_FLAGS_CANNOT_STEAL = 2, /// Prevent the manager from stealing memory. -} cnmemManagerFlags_t; - -/* ********************************************************************************************* */ - -typedef struct cnmemDevice_t_ -{ - /** The device number. */ - int device; - /** The size to allocate for that device. If 0, the implementation chooses the size. */ - size_t size; - /** The number of named streams associated with the device. The NULL stream is not counted. */ - int numStreams; - /** The streams associated with the device. It can be NULL. The NULL stream is managed. */ - cudaStream_t *streams; - /** The size reserved for each streams. It can be 0. */ - size_t *streamSizes; - -} cnmemDevice_t; - -/** - * \brief Initialize the library and allocate memory on the listed devices. - * - * For each device, an internal memory manager is created and the specified amount of memory is - * allocated (it is the size defined in device[i].size). For each, named stream an additional - * memory manager is created. Currently, it is implemented as a tree of memory managers: A root - * manager for the device and a list of children, one for each named stream. - * - * This function must be called before any other function in the library. It has to be called - * by a single thread since it is not thread-safe. - * - * \return - * CNMEM_STATUS_SUCCESS, if everything goes fine, - * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid, - * CNMEM_STATUS_OUT_OF_MEMORY, if the requested size exceeds the available memory, - * CNMEM_STATUS_CUDA_ERROR, if an error happens in a CUDA function. - */ -cnmemStatus_t CNMEM_API cnmemInit(int numDevices, const cnmemDevice_t *devices, unsigned flags); - -/** - * \brief Release all the allocated memory. - * - * This function must be called by a single thread and after all threads that called - * cnmemMalloc/cnmemFree have joined. This function is not thread-safe. - * - * \return - * CNMEM_STATUS_SUCCESS, if everything goes fine, - * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, - * CNMEM_STATUS_CUDA_ERROR, if an error happens in one of the CUDA functions. - */ -cnmemStatus_t CNMEM_API cnmemFinalize(); - -/** - * \brief Increase the internal reference counter of the context object. - * - * This function increases the internal reference counter of the library. The purpose of that - * reference counting mechanism is to give more control to the user over the lifetime of the - * library. It is useful with scoped memory allocation which may be destroyed in a final - * memory collection after the end of main(). That function is thread-safe. - * - * \return - * CNMEM_STATUS_SUCCESS, if everything goes fine, - * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, - */ -cnmemStatus_t CNMEM_API cnmemRetain(); - -/** - * \brief Decrease the internal reference counter of the context object. - * - * This function decreases the internal reference counter of the library. The purpose of that - * reference counting mechanism is to give more control to the user over the lifetime of the - * library. It is useful with scoped memory allocation which may be destroyed in a final - * memory collection after the end of main(). That function is thread-safe. - * - * You can use \c cnmemRelease to explicitly finalize the library. - * - * \return - * CNMEM_STATUS_SUCCESS, if everything goes fine, - * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, - */ -cnmemStatus_t CNMEM_API cnmemRelease(); - -/** - * \brief Add a new stream to the pool of managed streams on a device. - * - * This function registers a new stream into a device memory manager. It is thread-safe. - * - * \return - * CNMEM_STATUS_SUCCESS, if everything goes fine, - * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid, - */ -cnmemStatus_t CNMEM_API cnmemRegisterStream(cudaStream_t stream); - -/** - * \brief Allocate memory. - * - * This function allocates memory and initializes a pointer to device memory. If no memory - * is available, it returns a CNMEM_STATUS_OUT_OF_MEMORY error. This function is thread safe. - * - * The behavior of that function is the following: - * - * - If the stream is NULL, the root memory manager is asked to allocate a buffer of device - * memory. If there's a buffer of size larger or equal to the requested size in the list of - * free blocks, it is returned. If there's no such buffer but the manager is allowed to grow - * its memory usage (the CNMEM_FLAGS_CANNOT_GROW flag is not set), the memory manager calls - * cudaMalloc. If cudaMalloc fails due to no more available memory or the manager is not - * allowed to grow, the manager attempts to steal memory from one of its children (unless - * CNMEM_FLAGS_CANNOT_STEAL is set). If that attempt also fails, the manager returns - * CNMEM_STATUS_OUT_OF_MEMORY. - * - * - If the stream is a named stream, the initial request goes to the memory manager associated - * with that stream. If a free node is available in the lists of that manager, it is returned. - * Otherwise, the request is passed to the root node and works as if the request were made on - * the NULL stream. - * - * The calls to cudaMalloc are potentially costly and may induce GPU synchronizations. Also the - * mechanism to steal memory from the children induces GPU synchronizations (the manager has to - * make sure no kernel uses a given buffer before stealing it) and it the execution is - * sequential (in a multi-threaded context, the code is executed in a critical section inside - * the cnmem library - no need for the user to wrap cnmemMalloc with locks). - * - * \return - * CNMEM_STATUS_SUCCESS, if everything goes fine, - * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, - * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid. For example, ptr == 0, - * CNMEM_STATUS_OUT_OF_MEMORY, if there is not enough memory available, - * CNMEM_STATUS_CUDA_ERROR, if an error happens in one of the CUDA functions. - */ -cnmemStatus_t CNMEM_API cnmemMalloc(void **ptr, size_t size, cudaStream_t stream); - -/** - * \brief Release memory. - * - * This function releases memory and recycles a memory block in the manager. This function is - * thread safe. - * - * \return - * CNMEM_STATUS_SUCCESS, if everything goes fine, - * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, - * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid. For example, ptr == 0, - * CNMEM_STATUS_CUDA_ERROR, if an error happens in one of the CUDA functions. - */ -cnmemStatus_t CNMEM_API cnmemFree(void *ptr, cudaStream_t stream); - -/* ********************************************************************************************* */ -/* Utility functions. */ -/* ********************************************************************************************* */ - -/** - * \brief Returns the amount of memory managed by the memory manager associated with a stream. - * - * The pointers totalMem and freeMem must be valid. At the moment, this function has a comple- - * xity linear in the number of allocated blocks so do not call it in performance critical - * sections. - * - * \return - * CNMEM_STATUS_SUCCESS, if everything goes fine, - * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, - * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid, - * CNMEM_STATUS_CUDA_ERROR, if an error happens in one of the CUDA functions. - */ -cnmemStatus_t CNMEM_API cnmemMemGetInfo(size_t *freeMem, size_t *totalMem, cudaStream_t stream); - -/** - * \brief Print a list of nodes to a file. - * - * This function is intended to be used in case of complex scenarios to help understand the - * behaviour of the memory managers/application. It is thread safe. - * - * \return - * CNMEM_STATUS_SUCCESS, if everything goes fine, - * CNMEM_STATUS_NOT_INITIALIZED, if the ::cnmemInit function has not been called, - * CNMEM_STATUS_INVALID_ARGUMENT, if one of the argument is invalid. For example, used_mem == 0 - * or free_mem == 0, - * CNMEM_STATUS_CUDA_ERROR, if an error happens in one of the CUDA functions. - */ -cnmemStatus_t CNMEM_API cnmemPrintMemoryState(FILE *file, cudaStream_t stream); - -/** - * \brief Converts a cnmemStatus_t value to a string. - */ -const char CNMEM_API * cnmemGetErrorString(cnmemStatus_t status); - -/* ********************************************************************************************* */ - -#ifdef __cplusplus -} // extern "C" -#endif - diff --git a/3rdparty/cnmem/src/cnmem.cpp b/3rdparty/cnmem/src/cnmem.cpp deleted file mode 100644 index f0bc54374ce..00000000000 --- a/3rdparty/cnmem/src/cnmem.cpp +++ /dev/null @@ -1,1287 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions -// are met: -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above copyright -// notice, this list of conditions and the following disclaimer in the -// documentation and/or other materials provided with the distribution. -// * Neither the name of NVIDIA CORPORATION nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY -// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR -// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY -// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -/////////////////////////////////////////////////////////////////////////////////////////////////// - -#include "cnmem.h" -#include -#include -#include - -#if !defined(WIN32) && defined(_MSC_VER) -#define WIN32 -#endif - -#ifdef WIN32 -#include -#else -#include -#endif - -#define CNMEM_GRANULARITY 512 - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -extern "C" const char* cnmemGetErrorString(cnmemStatus_t status) { - switch(status) { - case CNMEM_STATUS_SUCCESS: return "CNMEM_STATUS_SUCCESS"; - case CNMEM_STATUS_CUDA_ERROR: return "CNMEM_STATUS_CUDA_ERROR"; - case CNMEM_STATUS_INVALID_ARGUMENT: return "CNMEM_STATUS_INVALID_ARGUMENT"; - case CNMEM_STATUS_NOT_INITIALIZED: return "CNMEM_STATUS_NOT_INITIALIZED"; - case CNMEM_STATUS_OUT_OF_MEMORY: return "CNMEM_STATUS_OUT_OF_MEMORY"; - default: return "CNMEM_STATUS_UNKNOWN_ERROR"; - } -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -#if 0 -#ifdef WIN32 -#define CNMEM_DEBUG_ERROR(...) do { \ - fprintf(stderr, "Error at line: %d\n", __LINE__); \ - fprintf(stderr, __VA_ARGS__); \ -} while(0) -#else -#include -static inline void printBacktrace() { - void *stackBuffer[64]; - int numAddresses = backtrace((void**) &stackBuffer, 64); - char **addresses = backtrace_symbols(stackBuffer, numAddresses); - for( int i = 0 ; i < numAddresses ; ++i ) { - fprintf(stderr, "[%2d]: %s\n", i, addresses[i]); - } - free(addresses); -} -#define CNMEM_DEBUG_ERROR(...) do { \ - fprintf(stderr, "Error at line: %d\n", __LINE__); \ - fprintf(stderr, __VA_ARGS__); \ - fprintf(stderr, "Backtrace:\n"); \ - printBacktrace(); \ -} while(0) -#endif -#else -#define CNMEM_DEBUG_ERROR(...) -#endif - -#if 0 -#define CNMEM_DEBUG_INFO printf -#else -#define CNMEM_DEBUG_INFO(...) -#endif - -#if 0 // Enable/disable assertions -#include -#define CNMEM_ASSERT assert -#else -#define CNMEM_ASSERT(...) -#endif - -#define CNMEM_CHECK_TRUE(cond, error) do { \ - if( !(cond) ) { \ - CNMEM_DEBUG_ERROR("CNMEM_CHECK_TRUE evaluates to false\n"); \ - return error; \ - } \ -} while(0) - -#define CNMEM_CHECK(call) do { \ - cnmemStatus_t status = (call); \ - if( status != CNMEM_STATUS_SUCCESS ) { \ - CNMEM_DEBUG_ERROR("CNMEM_CHECK failed with status \"%s\"\n", \ - cnmemGetErrorString(status)); \ - return status; \ - } \ -} while(0) - -#define CNMEM_CHECK_OR_UNLOCK(call, mutex) do { \ - cnmemStatus_t status = (call); \ - if( status != CNMEM_STATUS_SUCCESS ) { \ - CNMEM_DEBUG_ERROR("CNMEM_CHECK_OR_UNLOCK failed with status \"%s\"\n", \ - cnmemGetErrorString(status)); \ - (mutex).unlock(); \ - return status; \ - } \ -} while(0) - -#define CNMEM_CHECK_CUDA(call) do { \ - cudaError_t cudaError = (call); \ - if( cudaError == cudaErrorMemoryAllocation ) { \ - CNMEM_DEBUG_ERROR("CNMEM_CHECK_CUDA failed with CUDA error \"%s\"\n", \ - cudaGetErrorString(cudaError)); \ - return CNMEM_STATUS_OUT_OF_MEMORY; \ - } \ - else if( cudaError != cudaSuccess ) { \ - CNMEM_DEBUG_ERROR("CNMEM_CHECK_CUDA failed with CUDA error \"%s\"\n", \ - cudaGetErrorString(cudaError)); \ - return CNMEM_STATUS_CUDA_ERROR; \ - } \ -} while(0) - -#define CNMEM_CHECK_CUDA_OR_UNLOCK(call, mutex) do { \ - cudaError_t cudaError = (call); \ - if( cudaError == cudaErrorMemoryAllocation ) { \ - CNMEM_DEBUG_ERROR("CNMEM_CHECK_CUDA_OR_UNLOCK failed with CUDA error \"%s\"\n", \ - cudaGetErrorString(cudaError)); \ - (mutex).unlock(); \ - return CNMEM_STATUS_OUT_OF_MEMORY; \ - } \ - else if( cudaError != cudaSuccess ) { \ - CNMEM_DEBUG_ERROR("CNMEM_CHECK_CUDA_OR_UNLOCK failed with CUDA error \"%s\"\n", \ - cudaGetErrorString(cudaError)); \ - (mutex).unlock(); \ - return CNMEM_STATUS_CUDA_ERROR; \ - } \ -} while(0) - -#ifdef WIN32 -#define CNMEM_CHECK_WIN32(call, error_code) do { \ - SetLastError(0); /* Clean the flag. */ \ - call; \ - DWORD status = GetLastError(); \ - if( status ) \ - return error_code; \ -} while(0) -#else -#define CNMEM_CHECK_PTHREAD(call, error_code) do { \ - int status = call; \ - if( status ) { \ - CNMEM_DEBUG_ERROR("CNMEM_CHECK_PTHREAD failed with status %d\n", status); \ - return error_code; \ - } \ -} while(0) -#endif - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -namespace cnmem { - -static inline std::size_t ceilInt(std::size_t m, std::size_t n) { - CNMEM_ASSERT(n > 0); - return (m + n-1) / n * n; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -class Mutex { -#ifdef WIN32 - mutable CRITICAL_SECTION mCriticalSection; -#else - pthread_mutex_t mMutex; -#endif - -public: - /// Initialize the mutex. - cnmemStatus_t initialize(); - /// Finalize the mutex. - cnmemStatus_t finalize(); - /// Lock the mutex. - cnmemStatus_t lock() const; - /// Unlock the mutex. - cnmemStatus_t unlock() const; -}; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Mutex::initialize() { -#ifdef WIN32 - CNMEM_CHECK_WIN32(InitializeCriticalSection((CRITICAL_SECTION*) &mCriticalSection), CNMEM_STATUS_UNKNOWN_ERROR); -#else -#if 0 - pthread_mutexattr_t attr; - CNMEM_CHECK_PTHREAD(pthread_mutexattr_init(&attr), CNMEM_STATUS_UNKNOWN_ERROR); - CNMEM_CHECK_PTHREAD(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE), CNMEM_STATUS_UNKNOWN_ERROR); - CNMEM_CHECK_PTHREAD(pthread_mutex_init(&mMutex, &attr), CNMEM_STATUS_UNKNOWN_ERROR); -#else - CNMEM_CHECK_PTHREAD(pthread_mutex_init(&mMutex, NULL), CNMEM_STATUS_UNKNOWN_ERROR); -#endif -#endif - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Mutex::finalize() { -#ifdef WIN32 - CNMEM_CHECK_WIN32(DeleteCriticalSection((CRITICAL_SECTION*) &mCriticalSection), CNMEM_STATUS_UNKNOWN_ERROR); -#else - CNMEM_CHECK_PTHREAD(pthread_mutex_destroy(&mMutex), CNMEM_STATUS_UNKNOWN_ERROR); -#endif - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Mutex::lock() const { -#ifdef WIN32 - CNMEM_CHECK_WIN32(EnterCriticalSection(&mCriticalSection), CNMEM_STATUS_UNKNOWN_ERROR); -#else - CNMEM_CHECK_PTHREAD(pthread_mutex_lock((pthread_mutex_t*) &mMutex), CNMEM_STATUS_UNKNOWN_ERROR); -#endif - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Mutex::unlock() const { -#ifdef WIN32 - CNMEM_CHECK_WIN32(LeaveCriticalSection(&mCriticalSection), CNMEM_STATUS_UNKNOWN_ERROR); -#else - CNMEM_CHECK_PTHREAD(pthread_mutex_unlock((pthread_mutex_t*) &mMutex), CNMEM_STATUS_UNKNOWN_ERROR); -#endif - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -class Block { - /// The pointer to the memory region on the device. - char *mData; - /// The size of the memory buffer. - std::size_t mSize; - /// The prev/next blocks in the linked list of blocks. - Block *mNext; - /// Is it a head node (i.e. a node obtained from parent->allocate or cudaMalloc). - bool mIsHead; - -public: - /// Create a block. - Block(char *data, std::size_t size, Block *next, bool isHead) - : mData(data) - , mSize(size) - , mNext(next) - , mIsHead(isHead) { - } - - /// The data. - inline const char* getData() const { return mData; } - /// The data (mutable). - inline char* getData() { return mData; } - - /// The size of the block. - inline std::size_t getSize() const { return mSize; } - - /// The next block in the linked list. - inline const Block* getNext() const { return mNext; } - /// The next block in the linked list (mutable). - inline Block* getNext() { return mNext; } - - /// Is it a head block. - inline bool isHead() const { return mIsHead; } - - /// Change the next block. - inline void setNext(Block *next) { mNext = next; } - /// Change the size of the block. - inline void setSize(std::size_t size) { mSize = size; } - /// Set the head flag. - inline void setHeadFlag(bool isHead) { mIsHead = isHead; } -}; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -class Manager { - - /// The parent manager. - Manager *mParent; - /// The children managers. - std::vector mChildren; - /// The GPU device where the memory is allocated. - int mDevice; - /// The stream this manager is associated with. It could be NULL. - cudaStream_t mStream; - /// Is the stream blocking? - bool mIsStreamBlocking; - /// The list of used blocks. - Block *mUsedBlocks; - /// The list of free blocks. - Block *mFreeBlocks; - /// The managed memory size. - std::size_t mSize; - /// The flags. - unsigned mFlags; - /// To support multi-threading. Each manager has its own mutex. - Mutex mMutex; - -public: - /// Create an unitialized manager. - Manager(); - /// Dtor. - ~Manager(); - - /// Allocate a block of memory. - cnmemStatus_t allocate(void *&ptr, std::size_t size, bool isBlocking = true); - /// Release a block of memory. - cnmemStatus_t release(void *ptr); - /// Release memory. It returns true if we have no memory leak. - cnmemStatus_t releaseAllUnsafe(); - /// Reserve memory for a manager. - cnmemStatus_t reserve(std::size_t size); - /// Steal memory from another manager. - cnmemStatus_t stealUnsafe(void *&ptr, std::size_t size); - - /// Print the full memory state. - cnmemStatus_t printMemoryState(FILE *file) const; - - /// The amount of used memory. - inline cnmemStatus_t getUsedMemoryUnsafe(std::size_t &usedMemory) const { - return getMemoryUnsafe(usedMemory, mUsedBlocks); - } - /// The amount of used memory. - inline cnmemStatus_t getFreeMemoryUnsafe(std::size_t &freeMemory) const { - return getMemoryUnsafe(freeMemory, mFreeBlocks); - } - - /// Get a specific child based on the stream id. - cnmemStatus_t getChildFromStream(Manager *&manager, cudaStream_t stream) const; - /// Get a specific child based on the stream id. - cnmemStatus_t getChild(Manager *&manager, std::size_t i) const; - /// Add a new child. - cnmemStatus_t addChild(Manager *manager); - /// The number of children. - cnmemStatus_t getNumChildren(std::size_t &numChildren) const; - - /// The associated device. - inline int getDevice() const { return mDevice; } - /// The flags. - inline unsigned getFlags() const { return mFlags; } - /// Get the mutex. - inline const Mutex* getMutex() const { return &mMutex; } - /// The size allocated to that manager. - inline std::size_t getSize() const { return mSize; } - /// The CUDA stream. - inline cudaStream_t getStream() const { return mStream; } - - /// Define the parent. - inline void setParent(Manager *parent) { mParent = parent; } - /// Define the device. - inline void setDevice(int device) { mDevice = device; } - /// Define the stream. - inline cnmemStatus_t setStream(cudaStream_t stream) { - mStream = stream; -#ifdef CUDA_API_PER_THREAD_DEFAULT_STREAM - mIsStreamBlocking = false; -#elif CUDART_VERSION < 5050 - mIsStreamBlocking = true; -#else - unsigned flags = 0; - CNMEM_CHECK_CUDA(cudaStreamGetFlags(mStream, &flags)); - mIsStreamBlocking = !mStream || !(flags & cudaStreamNonBlocking); -#endif - return CNMEM_STATUS_SUCCESS; - } - /// Define the flags. - inline void setFlags(unsigned flags) { mFlags = flags; } - -private: - /// The member functions below which are marked "Unsafe" are not thread-safe when called on a - /// same Manager object. Make sure they are called by a single thread in that case. - - /// Allocate a new block and add it to the free list. - cnmemStatus_t allocateBlockUnsafe(Block *&curr, Block *&prev, std::size_t size); - /// Release a block from the active list. - cnmemStatus_t releaseBlockUnsafe(Block *curr, Block *prev); - /// Find the best free node based on the size. - cnmemStatus_t findBestBlockUnsafe(Block *&curr, Block *&prev, std::size_t size); - /// Extract a node from the list of free blocks. - cnmemStatus_t extractBlockUnsafe(Block *curr, Block *prev, std::size_t size, bool stolen); - - /// Give a free block from that manager. - cnmemStatus_t giveBlockUnsafe(void *&data, std::size_t &dataSize, std::size_t size); - /// Steal a block from another manager. - cnmemStatus_t stealBlockUnsafe(void *&data, std::size_t &dataSize, std::size_t size); - - /// The memory consumption of a list. - cnmemStatus_t getMemoryUnsafe(std::size_t &memSize, const Block *head) const; - /// Print an internal linked list. - cnmemStatus_t printListUnsafe(FILE *file, const char *name, const Block *head) const; -}; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -Manager::Manager() - : mParent(NULL) - , mChildren() - , mDevice(-1) - , mStream(NULL) - , mIsStreamBlocking(false) - , mUsedBlocks(NULL) - , mFreeBlocks(NULL) - , mSize(0) - , mFlags(CNMEM_FLAGS_DEFAULT) - , mMutex() { - - mMutex.initialize(); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -Manager::~Manager() { - if( mDevice == -1 || cudaSetDevice(mDevice) != cudaSuccess ) { // Invalid device, skip it. - return; - } - releaseAllUnsafe(); - mMutex.finalize(); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::addChild(Manager *manager) { - CNMEM_CHECK(mMutex.lock()); - mChildren.push_back(manager); - CNMEM_CHECK(mMutex.unlock()); - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::allocate(void *&ptr, std::size_t size, bool isBlocking) { - CNMEM_CHECK(mMutex.lock()); - - // If the client is not blocking, we have to explicitly synchronize before giving one buffer. - if( !isBlocking ) { - CNMEM_CHECK_CUDA_OR_UNLOCK(cudaStreamSynchronize(mStream), mMutex); - } - - // Find the best fit. - Block *best = NULL, *prev = NULL; - CNMEM_CHECK_OR_UNLOCK(findBestBlockUnsafe(best, prev, size), mMutex); - - // If there's no block left in the list of free blocks (with a sufficient size). Request a new block. - if( best == NULL && !(mFlags & CNMEM_FLAGS_CANNOT_GROW) ) { - CNMEM_CHECK_OR_UNLOCK(allocateBlockUnsafe(best, prev, size), mMutex); - } - - // Make sure we do have a block or quit. - if( !best ) { - ptr = NULL; - CNMEM_CHECK(mMutex.unlock()); - return CNMEM_STATUS_OUT_OF_MEMORY; - } - - // Split the free block if needed. - CNMEM_CHECK_OR_UNLOCK(extractBlockUnsafe(best, prev, size, false), mMutex); - - // Push the node to the list of used nodes. - best->setNext(mUsedBlocks); - mUsedBlocks = best; - - // Return the new pointer into memory. - ptr = mUsedBlocks->getData(); - CNMEM_CHECK(mMutex.unlock()); - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::allocateBlockUnsafe(Block *&curr, Block *&prev, std::size_t size) { - // Reset the outputs. - curr = prev = NULL; - - // Try to allocate data from the parent or the device. - void *data = NULL; - if( mParent ) { - CNMEM_CHECK(mParent->allocate(data, size, mIsStreamBlocking)); - } - else { - CNMEM_DEBUG_INFO("cudaMalloc(%lu)\n", size); - CNMEM_CHECK_CUDA(cudaMalloc(&data, size)); - CNMEM_DEBUG_INFO(">> returned address=0x%016lx\n", (size_t) data); - } - - // If it failed, there's an unexpected issue. - CNMEM_ASSERT(data); - - // We have data, we now need to add it to the list of free nodes. We keep the list sorted. - Block *next = mFreeBlocks; - for( ; next && next->getData() < data ; next = next->getNext() ) { - prev = next; - } - curr = new Block((char*) data, size, next, true); - if( !curr ) { - return CNMEM_STATUS_OUT_OF_MEMORY; - } - if( prev ) { - prev->setNext(curr); - } - else { - mFreeBlocks = curr; - } - - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::extractBlockUnsafe(Block *curr, Block *prev, std::size_t size, bool stolen) { - // We have two cases: 1/ It is the right size so we keep it or 2/ it is too large and we split the node. - Block *next; - if( curr->getSize() == size ) { - next = curr->getNext(); - } - else { - std::size_t remaining = curr->getSize()-size; - Block *newBlock = new Block(curr->getData() + size, remaining, curr->getNext(), stolen); - if( !newBlock ) { - return CNMEM_STATUS_OUT_OF_MEMORY; - } - next = newBlock; - curr->setSize(size); - } - - // Redo the "branching" in the nodes. - if( prev ) { - prev->setNext(next); - } - else { - mFreeBlocks = next; - } - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::findBestBlockUnsafe(Block *&best, Block *&prev, std::size_t size) { - best = NULL, prev = NULL; - for( Block *temp = mFreeBlocks, *tempPrev = NULL ; temp ; temp = temp->getNext() ) { - if( temp->getSize() >= size && (!best || temp->getSize() < best->getSize()) ) { - best = temp; - prev = tempPrev; - } - tempPrev = temp; - } - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::getChildFromStream(Manager *&manager, cudaStream_t stream) const { - CNMEM_CHECK(mMutex.lock()); - std::size_t i = 0, numChildren = mChildren.size(); - for( ; i < numChildren ; ++i ) { - if( mChildren[i]->mStream == stream ) { - manager = mChildren[i]; - break; - } - } - CNMEM_CHECK(mMutex.unlock()); - return i < numChildren ? CNMEM_STATUS_SUCCESS : CNMEM_STATUS_INVALID_ARGUMENT; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::getChild(Manager *&manager, std::size_t i) const { - CNMEM_CHECK(mMutex.lock()); - if( i >= mChildren.size() ) { - CNMEM_CHECK(mMutex.unlock()); - return CNMEM_STATUS_INVALID_ARGUMENT; - } - manager = mChildren[i]; - - CNMEM_CHECK(mMutex.unlock()); - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::getMemoryUnsafe(std::size_t &size, const Block *head) const { - size = 0; - for( Block *curr = (Block*) head ; curr ; curr = curr->getNext() ) { - size += curr->getSize(); - } - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -#if 0 -cnmemStatus_t Manager::getMemory(std::size_t &size, const Block *head) const { - CNMEM_CHECK(mMutex.lock()); - CNMEM_CHECK_OR_UNLOCK(getMemoryUnsafe(size, head)); - CNMEM_CHECK(mMutex.unlock()); - return status; -} -#endif - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::getNumChildren(std::size_t &numChildren) const { - CNMEM_CHECK(mMutex.lock()); - numChildren = mChildren.size(); - CNMEM_CHECK(mMutex.unlock()); - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::giveBlockUnsafe(void *&blockData, std::size_t &blockSize, std::size_t size) { - // Make sure the block is not in use any more. It could be too coarse grain and we may change - // it in the future. - CNMEM_CHECK_CUDA(cudaStreamSynchronize(mStream)); - - // Init the returned values to 0. - blockData = NULL; - blockSize = 0; - - // Find the best node to steal and reserve it. - Block *best = NULL, *prev = NULL; - CNMEM_CHECK(findBestBlockUnsafe(best, prev, size)); - if( !best ) { - return CNMEM_STATUS_OUT_OF_MEMORY; - } - CNMEM_CHECK(extractBlockUnsafe(best, prev, size, true)); - blockData = best->getData(); - blockSize = best->getSize(); - - // Release the memory used by that block. - delete best; - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::printListUnsafe(FILE *file, const char *name, const Block *head) const { - std::size_t size = 0; - for( Block *curr = (Block*) head; curr; curr = curr->getNext() ) { - size += curr->getSize(); - } - fprintf(file, "| list=\"%s\", size=%lu\n", name, size); - for( Block *curr = (Block*) head ; curr ; curr = curr->getNext() ) { - fprintf(file, "| | node=0x%016lx, data=0x%016lx, size=%lu, next=0x%016lx, head=%2lu\n", - (std::size_t) curr, - (std::size_t) curr->getData(), - (std::size_t) curr->getSize(), - (std::size_t) curr->getNext(), - (std::size_t) curr->isHead ()); - } - fprintf(file, "|\n"); - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::printMemoryState(FILE *file) const { - CNMEM_CHECK(mMutex.lock()); - std::size_t streamCode = (std::size_t) mStream; - std::size_t usedMemory, freeMemory; - CNMEM_CHECK_OR_UNLOCK(getUsedMemoryUnsafe(usedMemory), mMutex); - CNMEM_CHECK_OR_UNLOCK(getFreeMemoryUnsafe(freeMemory), mMutex); - - fprintf(file, ">> [%s] device=%d, stream=0x%016lx, used=%luB, free=%luB\n", - mParent ? "child" : "root", - mDevice, - streamCode, - usedMemory, - freeMemory); - CNMEM_CHECK_OR_UNLOCK(printListUnsafe(file, "used", mUsedBlocks), mMutex); - CNMEM_CHECK_OR_UNLOCK(printListUnsafe(file, "free", mFreeBlocks), mMutex); - fprintf(file, "\n"); - CNMEM_CHECK(mMutex.unlock()); - - if( mParent ) { - CNMEM_CHECK(mParent->printMemoryState(file)); - } - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::release(void *ptr) { - // Skip if ptr is NULL. - if( ptr == NULL ) { - return CNMEM_STATUS_SUCCESS; - } - - // Lock to make sure only one thread execute that fragment of code. - CNMEM_CHECK(mMutex.lock()); - - // Find the node in the list of used blocks. - Block *curr = mUsedBlocks, *prev = NULL; - for( ; curr && curr->getData() != ptr ; curr = curr->getNext() ) { - prev = curr; - } - - // Make sure we have found a node. - if( curr == NULL ) { - CNMEM_CHECK(mMutex.unlock()); - return CNMEM_STATUS_INVALID_ARGUMENT; - } - - // We have the node so release it. - cnmemStatus_t result = releaseBlockUnsafe(curr, prev); - CNMEM_CHECK(mMutex.unlock()); - return result; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::releaseAllUnsafe() { - // Destroy the children if any. - for( std::size_t i = 0; i < mChildren.size(); ++i ) { - Manager *child = mChildren[i]; - CNMEM_CHECK(child->releaseAllUnsafe()); - delete child; - } - mChildren.clear(); - - // Destroy used blocks. It's a kind of panic mode to avoid leaks. NOTE: Do that only with roots!!! - if( !mParent ) { - while( mUsedBlocks ) { - CNMEM_CHECK(releaseBlockUnsafe(mUsedBlocks, NULL)); - } - } - - // We should be having only free blocks that are head blocks. Release those blocks. - while( mFreeBlocks ) { - if( mParent ) { - CNMEM_CHECK(mParent->release(mFreeBlocks->getData())); - } - else if( mFreeBlocks->isHead() ) { - void *data = mFreeBlocks->getData(); - CNMEM_DEBUG_INFO("cudaFree(%lu, 0x%016lx)\n", mFreeBlocks->getSize(), (size_t) data); - CNMEM_CHECK_CUDA(cudaFree(data)); - CNMEM_DEBUG_INFO(">> success\n"); - } - Block *block = mFreeBlocks; - mFreeBlocks = mFreeBlocks->getNext(); - delete block; - } - - // We shouldn't have any used block left. Or, it means the user is causing memory leaks! - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::releaseBlockUnsafe(Block *curr, Block *prev) { - // The current node cannot be NULL! - CNMEM_ASSERT(curr != NULL); - - // Change the connection of the node. - if( prev ) { - prev->setNext(curr->getNext()); - } - else { - mUsedBlocks = curr->getNext(); - } - - // Find the location where this block should be added to the free list. - prev = NULL; - Block *iter = mFreeBlocks; - for( ; iter && iter->getData() < curr->getData() ; iter = iter->getNext() ) { - prev = iter; - } - - // Keep track of the successor of pred. We may lose track of it in the following "else". - Block *next = prev ? prev->getNext() : mFreeBlocks; - - // We first check if we can merge the block with its predecessor in the list and curr can be merged. - if( prev && prev->getData() + prev->getSize() == curr->getData() && !curr->isHead() ) { - prev->setSize(prev->getSize() + curr->getSize()); - delete curr; - curr = prev; - } - else if( prev ) { - prev->setNext(curr); - } - else { - mFreeBlocks = curr; - } - - // Check if we can merge curr and next. We can't merge over "cudaMalloc" boundaries. - if( next && curr->getData() + curr->getSize() == next->getData() && !next->isHead() ) { - curr->setSize(curr->getSize() + next->getSize()); - curr->setNext(next->getNext()); - delete next; - } - else { - curr->setNext(next); - } - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::reserve(std::size_t size) { - CNMEM_CHECK(mMutex.lock()); - Block *curr, *prev; - CNMEM_CHECK_OR_UNLOCK(allocateBlockUnsafe(curr, prev, size), mMutex); - mSize = size; - CNMEM_CHECK(mMutex.unlock()); - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::stealUnsafe(void *&stolen, std::size_t size) { - // If we cannot steal, don't even try. - if( mFlags & CNMEM_FLAGS_CANNOT_STEAL ) { - stolen = NULL; - return CNMEM_STATUS_INVALID_ARGUMENT; - } - - // The stolen block. - void *data = NULL; std::size_t dataSize = 0; - if( !mChildren.empty() ) { - CNMEM_CHECK(stealBlockUnsafe(data, dataSize, size)); - } - else if( mParent ) { - CNMEM_CHECK(mParent->stealBlockUnsafe(data, dataSize, size)); - } - - // Make sure we do have a block of memory or quit. - if( !data ) { - stolen = NULL; - return CNMEM_STATUS_OUT_OF_MEMORY; - } - - // Push the block in the used list. - mUsedBlocks = new Block((char*) data, dataSize, mUsedBlocks, true); - if( !mUsedBlocks ) { - return CNMEM_STATUS_OUT_OF_MEMORY; - } - - // Return the new pointer into memory. - stolen = data; - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Manager::stealBlockUnsafe(void *&data, std::size_t &dataSize, ::size_t size) { - // No block found and no room to grow. Try to steal from a children (if we have any). - data = NULL; - for( std::size_t i = 0 ; !data && i < mChildren.size() ; ++i ) { - Manager *child = mChildren[i]; - if( child->giveBlockUnsafe(data, dataSize, size) == CNMEM_STATUS_SUCCESS ) { - break; - } - } - - // If no memory space found, simply return NULL. We have failed to allocate. Quit miserably. - if( !data ) { - return CNMEM_STATUS_OUT_OF_MEMORY; - } - - // We have got a node from a children. We need to update our "used" list before we can do - // anything with it. - Block *curr = mUsedBlocks, *prev = NULL; - for( ; curr ; curr = curr->getNext() ) { - if( curr->getData() <= data && data < curr->getData()+curr->getSize() ) { - break; - } - prev = curr; - } - - // Curr points to the node which contains that memory region. - CNMEM_ASSERT(curr); - - // If it is exactly the same memory region, we are done!!! - if( curr->getData() == data && curr->getSize() == dataSize ) { - return CNMEM_STATUS_SUCCESS; - } - - // Track the blocks before and after curr. - Block *next = curr->getNext(); - - // We may have up to 3 blocks. - std::size_t sizeBefore = (std::size_t) ((char*) data - curr->getData()); - std::size_t sizeAfter = (curr->getSize() - sizeBefore - dataSize); - - // The resulting block. - Block *result = curr; - - // If we have no space between curr->getData and block->getData. - if( sizeBefore == 0 ) { - curr->setSize(dataSize); - } - else { - curr->setSize(sizeBefore); - Block *block = new Block((char*) data, dataSize, next, false); - if( !block ) { - return CNMEM_STATUS_OUT_OF_MEMORY; - } - curr->setNext(block); - curr = block; - data = (char*) data + dataSize; - dataSize = sizeAfter; - result = block; - } - - // We have space at the end so we may need to add a new node. - if( sizeAfter > 0 ) { - Block *block = new Block(curr->getData() + curr->getSize(), sizeAfter, next, false); - if( !block ) { - return CNMEM_STATUS_OUT_OF_MEMORY; - } - curr->setNext(block); - curr = block; - } - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -class Context { - /// Use a magic number to specify that the context is valid. - enum { CTX_VALID = 0x1f5632a3 }; - - /// The reference counting mechanism. - int mRefCount; - /// The mutex to increase/decrease the reference counter. TODO: Use atomics. - Mutex mMutex; - /// The memory managers. - std::vector mManagers; - /// The global context. - static Context *sCtx; - /// Use a magic number to specify that the context was created. - static int sCtxCheck; - -public: - /// Ctor. - Context() : mRefCount(1) { mMutex.initialize(); } - /// Dtor. - ~Context(); - /// Get the managers. - inline std::vector& getManagers() { return mManagers; } - /// Get a single manager associated with a device. - inline Manager& getManager(int i) { return mManagers[i]; } - - /// Create the global context. - static cnmemStatus_t create(); - /// Check that the context was created. - static inline bool check() { return sCtxCheck == CTX_VALID && sCtx; } - /// Get the global context. - static Context* get(); - /// Retain. - static cnmemStatus_t retain(); - /// Release. - static cnmemStatus_t release(); -}; - -Context *Context::sCtx; -int Context::sCtxCheck; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -Context::~Context() { - int oldDevice; - cudaGetDevice(&oldDevice); - for( std::size_t i = 0 ; i < mManagers.size() ; ++i ) { - if( mManagers[i].getDevice() != -1 ) { // Skip invalid managers. - cudaSetDevice(mManagers[i].getDevice()); - mManagers[i].releaseAllUnsafe(); - } - } - mManagers.clear(); - mMutex.finalize(); - cudaSetDevice(oldDevice); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Context::create() { - sCtx = new Context; - sCtxCheck = CTX_VALID; - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -Context* Context::get() { - CNMEM_ASSERT(Context::check()); - return Context::sCtx; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Context::retain() { - CNMEM_CHECK(sCtx->mMutex.lock()); - sCtx->mRefCount++; - CNMEM_CHECK(sCtx->mMutex.unlock()); - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t Context::release() { - CNMEM_CHECK(sCtx->mMutex.lock()); - int refCount = --sCtx->mRefCount; - CNMEM_CHECK(sCtx->mMutex.unlock()); - - if( refCount == 0 ) { // Kill the context. - delete sCtx; - Context::sCtx = NULL; - Context::sCtxCheck = 0; - } - return CNMEM_STATUS_SUCCESS; -} - -} // namespace cnmem - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -extern "C" { - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t cnmemInit(int numDevices, const cnmemDevice_t *devices, unsigned flags) { - // Make sure we have at least one device declared. - CNMEM_CHECK_TRUE(numDevices > 0, CNMEM_STATUS_INVALID_ARGUMENT); - - // Find the largest ID of the device. - int maxDevice = 0; - for( int i = 0 ; i < numDevices ; ++i ) { - if( devices[i].device > maxDevice ) { - maxDevice = devices[i].device; - } - } - - // Create the global context. - cnmem::Context::create(); - cnmem::Context *ctx = cnmem::Context::get(); - - // Allocate enough managers. - CNMEM_CHECK_TRUE(maxDevice >= 0, CNMEM_STATUS_INVALID_ARGUMENT); - std::vector &managers = ctx->getManagers(); - managers.resize(maxDevice+1); - - // Create a root manager for each device and create the children. - int oldDevice; - CNMEM_CHECK_CUDA(cudaGetDevice(&oldDevice)); - for( int i = 0 ; i < numDevices ; ++i ) { - CNMEM_CHECK_CUDA(cudaSetDevice(devices[i].device)); - std::size_t size = devices[i].size; - if( size == 0 ) { - cudaDeviceProp props; - CNMEM_CHECK_CUDA(cudaGetDeviceProperties(&props, devices[i].device)); - size = props.totalGlobalMem / 2; - } - CNMEM_CHECK_TRUE(size > 0, CNMEM_STATUS_INVALID_ARGUMENT); - - cnmem::Manager &manager = ctx->getManager(devices[i].device); - manager.setDevice(devices[i].device); - manager.setFlags(flags); - - size = cnmem::ceilInt(size, CNMEM_GRANULARITY); - CNMEM_CHECK(manager.reserve(size)); - - for( int j = 0 ; j < devices[i].numStreams ; ++j ) { - cnmem::Manager *child = new cnmem::Manager; - child->setParent(&manager); - child->setDevice(devices[i].device); - child->setStream(devices[i].streams[j]); - child->setFlags(flags & ~CNMEM_FLAGS_CANNOT_GROW); - if( devices[i].streamSizes && devices[i].streamSizes[j] > 0 ) { - CNMEM_CHECK(child->reserve(devices[i].streamSizes[j])); - } - CNMEM_CHECK(manager.addChild(child)); - } - } - CNMEM_CHECK_CUDA(cudaSetDevice(oldDevice)); - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t cnmemFinalize() { - CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); - return cnmem::Context::release(); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t cnmemRetain() { - CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); - return cnmem::Context::retain(); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t cnmemRelease() { - CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); - return cnmem::Context::release(); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t cnmemRegisterStream(cudaStream_t stream) { - CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); - CNMEM_CHECK_TRUE(stream, CNMEM_STATUS_INVALID_ARGUMENT); - - int device; - CNMEM_CHECK_CUDA(cudaGetDevice(&device)); - - cnmem::Manager &root = cnmem::Context::get()->getManager(device); - cnmem::Manager *child = new cnmem::Manager; - child->setParent(&root); - child->setDevice(device); - child->setStream(stream); - child->setFlags(root.getFlags() & ~CNMEM_FLAGS_CANNOT_GROW); - root.addChild(child); - - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t cnmemMalloc(void **ptr, std::size_t size, cudaStream_t stream) { - CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); - if( !ptr && !size ) { - return CNMEM_STATUS_SUCCESS; - } - else if( !size ) { - ptr[0] = NULL; - return CNMEM_STATUS_SUCCESS; - } - CNMEM_CHECK_TRUE(ptr, CNMEM_STATUS_INVALID_ARGUMENT); - - int device; - CNMEM_CHECK_CUDA(cudaGetDevice(&device)); - - cnmem::Manager &root = cnmem::Context::get()->getManager(device); - cnmem::Manager *manager = &root; - if( stream ) { - CNMEM_CHECK(root.getChildFromStream(manager, stream)); - } - CNMEM_ASSERT(manager); - - size = cnmem::ceilInt(size, CNMEM_GRANULARITY); - cnmemStatus_t result = manager->allocate(ptr[0], size); - - // We failed to allocate but there might still be a buffer available in another manager. Try to - // steal it. - if( result == CNMEM_STATUS_OUT_OF_MEMORY ) { - - // Try to acquire locks on all the children. - std::size_t numChildren; - CNMEM_CHECK(root.getNumChildren(numChildren)); - std::vector mutexes(numChildren); - - std::size_t numLocked = 0; - for( size_t i = 0 ; i < numChildren ; ++i, ++numLocked ) { - cnmem::Manager *child; - CNMEM_CHECK(root.getChild(child, i)); - mutexes[numLocked] = child->getMutex(); - if( mutexes[numLocked]->lock() != CNMEM_STATUS_SUCCESS ) { - break; - } - } - - // One lock failed, quit. Reduce the damage as much as possible, though. - if( numLocked != numChildren ) { - for( std::size_t i = 0 ; i < numLocked ; ++i ) { - cnmemStatus_t lockStatus = mutexes[i]->unlock(); - } - return CNMEM_STATUS_UNKNOWN_ERROR; - } - - // Grab the lock on the root, first. - const cnmem::Mutex *rootMutex = root.getMutex(); - CNMEM_CHECK(rootMutex->lock()); - - // We acquired all the lock so we try to steal a node from another child. - if( numLocked == mutexes.size() ) { - result = manager->stealUnsafe(ptr[0], size); - } - for( std::size_t i = 0 ; i < numLocked ; ++i ) { - cnmemStatus_t lockStatus = mutexes[i]->unlock(); - if( lockStatus != CNMEM_STATUS_SUCCESS ) { - // Starting from now we are panicking!!! One lock failed to be released, we try - // we others. We could also give up because we are already screwed. I don't know - // what's best! Comment are welcome. - result = lockStatus; - } - } - CNMEM_CHECK(rootMutex->unlock()); - } - return result; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t cnmemFree(void *ptr, cudaStream_t stream) { - CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); - if( ptr == NULL ) { - return CNMEM_STATUS_SUCCESS; - } - - int device; - CNMEM_CHECK_CUDA(cudaGetDevice(&device)); - - cnmem::Manager &root = cnmem::Context::get()->getManager(device); - cnmem::Manager *manager = &root; - if( stream ) { - CNMEM_CHECK(root.getChildFromStream(manager, stream)); - } - CNMEM_ASSERT(manager); - return manager->release(ptr); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t cnmemMemGetInfo(size_t *freeMem, size_t *totalMem, cudaStream_t stream) { - CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); - CNMEM_CHECK_TRUE(totalMem && freeMem, CNMEM_STATUS_INVALID_ARGUMENT); - - int device; - CNMEM_CHECK_CUDA(cudaGetDevice(&device)); - cnmem::Manager &root = cnmem::Context::get()->getManager(device); - cnmem::Manager *manager = &root; - if( stream ) { - CNMEM_CHECK(root.getChildFromStream(manager, stream)); - } - CNMEM_ASSERT(manager); - - const cnmem::Mutex *mutex = manager->getMutex(); - CNMEM_CHECK(mutex->lock()); - CNMEM_CHECK_OR_UNLOCK(manager->getFreeMemoryUnsafe(*freeMem), *mutex); - size_t usedMem; - CNMEM_CHECK_OR_UNLOCK(manager->getUsedMemoryUnsafe(usedMem), *mutex); - CNMEM_CHECK(mutex->unlock()); - totalMem[0] = usedMem + freeMem[0]; - return CNMEM_STATUS_SUCCESS; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -cnmemStatus_t cnmemPrintMemoryState(FILE *file, cudaStream_t stream) { - CNMEM_CHECK_TRUE(cnmem::Context::check(), CNMEM_STATUS_NOT_INITIALIZED); - - int device; - CNMEM_CHECK_CUDA(cudaGetDevice(&device)); - cnmem::Manager &root = cnmem::Context::get()->getManager(device); - cnmem::Manager *manager = &root; - if( stream ) { - CNMEM_CHECK(root.getChildFromStream(manager, stream)); - } - CNMEM_ASSERT(manager); - return manager->printMemoryState(file); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -} // extern "C" - diff --git a/3rdparty/cnmem/tests/cnmem_tests.cpp b/3rdparty/cnmem/tests/cnmem_tests.cpp deleted file mode 100644 index 0f1c26873b0..00000000000 --- a/3rdparty/cnmem/tests/cnmem_tests.cpp +++ /dev/null @@ -1,1001 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions -// are met: -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above copyright -// notice, this list of conditions and the following disclaimer in the -// documentation and/or other materials provided with the distribution. -// * Neither the name of NVIDIA CORPORATION nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY -// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR -// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY -// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -/////////////////////////////////////////////////////////////////////////////////////////////////// - -#include -#include -#include -#ifdef USE_CPP_11 -#include -#endif - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -static std::size_t getFreeMemory() { - std::size_t freeMem, totalMem; - cudaMemGetInfo(&freeMem, &totalMem); - return freeMem; -} - -class CnmemTest : public ::testing::Test { - /// We determine the amount of free memory. - std::size_t mFreeMem; - -protected: - /// Do we test memory leaks. - bool mTestLeaks; - /// Do we skip finalization. - bool mFinalize; - -public: - /// Ctor. - CnmemTest() : mFreeMem(getFreeMemory()), mTestLeaks(true), mFinalize(true) {} - /// Tear down the test. - void TearDown(); -}; - -void CnmemTest::TearDown() { - if( mFinalize ) { - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFinalize()); - } - if( mTestLeaks ) { - ASSERT_EQ(mFreeMem, getFreeMemory()); - } -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, notInitializedFinalize) { - ASSERT_EQ(CNMEM_STATUS_NOT_INITIALIZED, cnmemFinalize()); - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, notInitializedMalloc) { - ASSERT_EQ(CNMEM_STATUS_NOT_INITIALIZED, cnmemMalloc(NULL, 0, 0)); - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, notInitializedFree) { - ASSERT_EQ(CNMEM_STATUS_NOT_INITIALIZED, cnmemFree(NULL, 0)); - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, initOutOfMemory) { - cudaDeviceProp props; - ASSERT_EQ(cudaSuccess, cudaGetDeviceProperties(&props, 0)); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = props.totalGlobalMem * 2; - ASSERT_EQ(CNMEM_STATUS_OUT_OF_MEMORY, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, initDevice1) { - int numDevices; - ASSERT_EQ(cudaSuccess, cudaGetDeviceCount(&numDevices)); - - // We can't check anything. We need at least 2 devices to enable only the 2nd one. - if( numDevices < 2 ) { - return; - } - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.device = 1; // Skip device 0. - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, freeNULL) { - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(NULL, NULL)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, freeTwoStreams) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 3*1024; - device.numStreams = 2; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - void *ptr0, *ptr1; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 1024, streams[0])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 1024, streams[1])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[1])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); - - ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[1])); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, addStream) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - // Register only 1 stream (on purpose). - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 3*1024; - device.numStreams = 1; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - // Allocate a pointer with a valid stream. - void *ptr0, *ptr1; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 1024, streams[0])); - - // Try to allocate with an invalid stream. - ASSERT_EQ(CNMEM_STATUS_INVALID_ARGUMENT, cnmemMalloc(&ptr1, 1024, streams[1])); - - // Register the stream and try again. - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemRegisterStream(streams[1])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 1024, streams[1])); - - // Clean up. - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[1])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); - - ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[1])); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, freeWrongStream) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 3*1024; - device.numStreams = 2; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - void *ptr; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 1024, streams[0])); - ASSERT_EQ(CNMEM_STATUS_INVALID_ARGUMENT, cnmemFree(ptr, streams[1])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr, streams[0])); - - ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamDestroy(streams[1])); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, freeNULLRatherThanNamed) { - cudaStream_t stream; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&stream)); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - device.numStreams = 1; - device.streams = &stream; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - void *ptr; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 1024, stream)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr, NULL)); // We expect this async free to work. - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFinalize()); - - ASSERT_EQ(cudaSuccess, cudaStreamDestroy(stream)); - - device.numStreams = 0; - device.streams = NULL; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateNULL) { - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(NULL, 0, NULL)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateZeroSize) { - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - void *ptr; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 0, NULL)); - ASSERT_EQ((void*) NULL, ptr); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateNoFree) { - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - void *ptr; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 512, NULL)); - ASSERT_NE((void*) NULL, ptr); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFinalize()); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); // For TearDown to be happy -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateAndFreeOne) { - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - void *ptr; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 512, NULL)); - ASSERT_NE((void*) NULL, ptr); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr, NULL)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateAndFreeTwo) { - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - void *ptr0; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 512, NULL)); - ASSERT_NE((void*) NULL, ptr0); - void *ptr1; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, NULL)); - ASSERT_NE((void*) NULL, ptr1); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, NULL)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateAndFreeAll) { - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - void *ptr0; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 512, NULL)); - ASSERT_NE((void*) NULL, ptr0); - void *ptr1; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, NULL)); - ASSERT_NE((void*) NULL, ptr1); - void *ptr2; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 512, NULL)); - ASSERT_NE((void*) NULL, ptr2); - void *ptr3; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr3, 512, NULL)); - ASSERT_NE((void*) NULL, ptr3); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr3, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, NULL)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateAndFreeAnyOrder) { - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - void *ptr0; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 512, NULL)); - ASSERT_NE((void*) NULL, ptr0); - void *ptr1; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, NULL)); - ASSERT_NE((void*) NULL, ptr1); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, NULL)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateTooMuchAndGrow) { - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - void *ptr0; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 512, NULL)); - ASSERT_NE((void*) NULL, ptr0); - void *ptr1; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, NULL)); - ASSERT_NE((void*) NULL, ptr1); - void *ptr2; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 512, NULL)); - ASSERT_NE((void*) NULL, ptr2); - void *ptr3; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr3, 512, NULL)); - ASSERT_NE((void*) NULL, ptr3); - void *ptr4; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr4, 512, NULL)); - ASSERT_NE((void*) NULL, ptr4); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr4, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr3, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, NULL)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateTooMuchNoGrow) { - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - void *ptr0; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 512, NULL)); - ASSERT_NE((void*) NULL, ptr0); - void *ptr1; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, NULL)); - ASSERT_NE((void*) NULL, ptr1); - void *ptr2; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 512, NULL)); - ASSERT_NE((void*) NULL, ptr2); - void *ptr3; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr3, 512, NULL)); - ASSERT_NE((void*) NULL, ptr3); - void *ptr4; - ASSERT_EQ(CNMEM_STATUS_OUT_OF_MEMORY, cnmemMalloc(&ptr4, 512, NULL)); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr3, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, NULL)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateAndSteal) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 3*1024; - device.numStreams = 2; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - // Take the 1024B from streams[0]. - void *ptr0; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 1024, streams[0])); - ASSERT_NE((void*) NULL, ptr0); - // Take the 1024B from NULL. - void *ptr1; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 1024, streams[0])); - ASSERT_NE((void*) NULL, ptr1); - // Steal the 1024B from streams[1]. - void *ptr2; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 1024, streams[0])); - ASSERT_NE((void*) NULL, ptr2); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, streams[0])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[0])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); - - cudaStreamDestroy(streams[1]); - cudaStreamDestroy(streams[0]); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateAndSteal2) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 3*1024; - device.numStreams = 2; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - void *ptr0; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 1024, streams[0])); - ASSERT_NE((void*) NULL, ptr0); - void *ptr1; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, streams[1])); - ASSERT_NE((void*) NULL, ptr1); - void *ptr2; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 512, streams[0])); - ASSERT_NE((void*) NULL, ptr2); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, streams[0])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[1])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); - - cudaStreamDestroy(streams[1]); - cudaStreamDestroy(streams[0]); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateAndSteal3) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 3*2048; - device.numStreams = 2; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - void *ptr0; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 2048, streams[0])); - ASSERT_NE((void*) NULL, ptr0); - void *ptr1; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 512, streams[1])); - ASSERT_NE((void*) NULL, ptr1); - void *ptr2; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 1024, streams[0])); - ASSERT_NE((void*) NULL, ptr2); - void *ptr3; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr3, 512, streams[1])); - ASSERT_NE((void*) NULL, ptr3); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr3, streams[1])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, streams[0])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[1])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); - - cudaStreamDestroy(streams[1]); - cudaStreamDestroy(streams[0]); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateAndSteal4) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 6*1024; - device.numStreams = 2; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - void *ptr0; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr0, 1024, streams[0])); - void *ptr1; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr1, 1024, streams[0])); - void *ptr2; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr2, 1024, streams[0])); - void *ptr3; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr3, 1024, streams[0])); - void *ptr4; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr4, 1024, streams[0])); - void *ptr5; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr5, 1024, streams[1])); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr0, streams[0])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr1, streams[0])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr2, streams[0])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr3, streams[0])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr4, streams[0])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr5, streams[1])); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateAndReserveStream) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 4096; - device.numStreams = 2; - device.streams = streams; - size_t streamSizes[] = { 2048, 2048 }; - device.streamSizes = streamSizes; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - size_t totalMem, freeMem; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); - ASSERT_EQ(4096, totalMem); - ASSERT_EQ(0, freeMem); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, streams[0])); - ASSERT_EQ(2048, totalMem); - ASSERT_EQ(2048, freeMem); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, streams[1])); - ASSERT_EQ(2048, totalMem); - ASSERT_EQ(2048, freeMem); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateAndReserveStreamDifferentSizes) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 8192; - device.numStreams = 2; - device.streams = streams; - size_t streamSizes[] = { 2048, 4096 }; - device.streamSizes = streamSizes; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - size_t totalMem, freeMem; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); - ASSERT_EQ(8192, totalMem); - ASSERT_EQ(2048, freeMem); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, streams[0])); - ASSERT_EQ(2048, totalMem); - ASSERT_EQ(2048, freeMem); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, streams[1])); - ASSERT_EQ(4096, totalMem); - ASSERT_EQ(4096, freeMem); - - FILE *file = fopen("reserveStream.log", "w"); - ASSERT_NE((FILE*) NULL, file); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemPrintMemoryState(file, streams[0])); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemPrintMemoryState(file, streams[1])); - fclose(file); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -#ifdef USE_CPP_11 - -template< int N > -static void allocate(cudaStream_t stream) { - void *ptr[N]; - for( int i = 0 ; i < N ; ++i ) - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr[i], 1024, stream)); - for( int i = 0 ; i < N ; ++i ) - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr[i], stream)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateConcurrentNoCompete) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 6*1024; - device.numStreams = 2; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - // In this test, each manager has enough memory to accommodate the threads. - std::vector threads(2); - for( int i = 0 ; i < 2 ; ++i ) - threads[i] = new std::thread(allocate<2>, streams[i]); - for( int i = 0 ; i < 2 ; ++i ) - threads[i]->join(); - for( unsigned i = 0 ; i < 2 ; ++i ) - delete threads[i]; - threads.clear(); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateConcurrentCompete) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 6*1024; - device.numStreams = 2; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - // In this test, the threads compete for the memory of the root manager. - std::vector threads(2); - for( int i = 0; i < 2; ++i ) - threads[i] = new std::thread(allocate<3>, streams[i]); - for( int i = 0; i < 2; ++i ) - threads[i]->join(); - for( unsigned i = 0; i < 2; ++i ) - delete threads[i]; - threads.clear(); - - mTestLeaks = false; // For some reasons, it reports a leak. It's likely to be in the driver/runtime. -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateConcurrentSteal) { - const int N = 4; - cudaStream_t streams[N]; - for( int i = 0 ; i < N ; ++i ) { - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[i])); - } - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 4*N*1024; - device.numStreams = N; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - // In this test, the thread 0 has to steal memory from thread 1. - std::vector threads(N); - for( int i = 0 ; i < N ; ++i ) { - threads[i] = new std::thread(allocate<4>, streams[i]); - } - for( int i = 0; i < N; ++i ) - threads[i]->join(); - for( int i = 0; i < N; ++i ) - delete threads[i]; - threads.clear(); - - mTestLeaks = false; // For some reasons, it reports a leak. -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateConcurrentMultiStreamsPerThreadNoGrow) { - const int NUM_STREAMS = 8, NUM_THREADS = 32; - cudaStream_t streams[NUM_STREAMS]; - for( int i = 0 ; i < NUM_STREAMS ; ++i ) { - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[i])); - } - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 4*NUM_THREADS*1024; - device.numStreams = NUM_STREAMS; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - std::vector threads(NUM_THREADS); - for( int i = 0 ; i < NUM_THREADS ; ++i ) { - threads[i] = new std::thread(allocate<4>, streams[i%NUM_STREAMS]); - } - for( int i = 0; i < NUM_THREADS; ++i ) - threads[i]->join(); - for( int i = 0; i < NUM_THREADS; ++i ) - delete threads[i]; - threads.clear(); - - mTestLeaks = false; // For some reasons, it reports a leak. -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, allocateConcurrentMultiStreamsPerThreadGrow) { - const int NUM_STREAMS = 8, NUM_THREADS = 32; - cudaStream_t streams[NUM_STREAMS]; - for( int i = 0 ; i < NUM_STREAMS ; ++i ) { - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[i])); - } - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = NUM_THREADS*1024; - device.numStreams = NUM_STREAMS; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - std::vector threads(NUM_THREADS); - for( int i = 0 ; i < NUM_THREADS ; ++i ) { - threads[i] = new std::thread(allocate<4>, streams[i%NUM_STREAMS]); - } - for( int i = 0; i < NUM_THREADS; ++i ) - threads[i]->join(); - for( int i = 0; i < NUM_THREADS; ++i ) - delete threads[i]; - threads.clear(); - - mTestLeaks = false; // For some reasons, it reports a leak. -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -template< int N > -static void registerAndAllocate(cudaStream_t stream) { - void *ptr[N]; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemRegisterStream(stream)); - for( int i = 0 ; i < N ; ++i ) - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr[i], 1024, stream)); - for( int i = 0 ; i < N ; ++i ) - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr[i], stream)); -} - -TEST_F(CnmemTest, registerAndAllocateConcurrentStreamsGrow) { - const int N = 32; - cudaStream_t streams[N]; - for( int i = 0 ; i < N ; ++i ) { - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[i])); - } - - // Declare no stream. - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 1024; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - // In this test, the thread 0 has to steal memory from thread 1. - std::vector threads(N); - for( int i = 0 ; i < N ; ++i ) { - threads[i] = new std::thread(registerAndAllocate<2>, streams[i]); - } - for( int i = 0; i < N; ++i ) - threads[i]->join(); - for( int i = 0; i < N; ++i ) - delete threads[i]; - threads.clear(); - - mTestLeaks = false; // For some reasons, it reports a leak. -} - -TEST_F(CnmemTest, registerAndAllocateConcurrentMultiStreamsPerThread) { - const int NUM_STREAMS = 8, NUM_THREADS = 32; - cudaStream_t streams[NUM_STREAMS]; - for( int i = 0 ; i < NUM_STREAMS ; ++i ) { - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[i])); - } - - // Declare no stream. - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 1024; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - // In this test, the thread 0 has to steal memory from thread 1. - std::vector threads(NUM_THREADS); - for( int i = 0 ; i < NUM_THREADS ; ++i ) { - threads[i] = new std::thread(registerAndAllocate<4>, streams[i%NUM_STREAMS]); - } - for( int i = 0; i < NUM_THREADS; ++i ) - threads[i]->join(); - for( int i = 0; i < NUM_THREADS; ++i ) - delete threads[i]; - threads.clear(); - - mTestLeaks = false; // For some reasons, it reports a leak. -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -template< int N > -static void allocateAndPrint(int id, cudaStream_t stream) { - void *ptr[N]; - for( int i = 0 ; i < N ; ++i ) - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr[i], 1024, stream)); - char buffer[64]; - sprintf(buffer, "memoryState.%d.log", id); - FILE *file = fopen(buffer, "w"); - ASSERT_NE((FILE*) NULL, file); - cnmemPrintMemoryState(file, stream); - fclose(file); - for( int i = 0 ; i < N ; ++i ) - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr[i], stream)); -} - -TEST_F(CnmemTest, testPrintMemoryState) { - cudaStream_t streams[2]; - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[0])); - ASSERT_EQ(cudaSuccess, cudaStreamCreate(&streams[1])); - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 4096; - device.numStreams = 2; - device.streams = streams; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_CANNOT_GROW)); - - // In this test, each manager has enough memory to accommodate the threads. - std::vector threads(2); - for( int i = 0 ; i < 2 ; ++i ) - threads[i] = new std::thread(allocateAndPrint<2>, i, streams[i]); - for( int i = 0 ; i < 2 ; ++i ) - threads[i]->join(); - for( unsigned i = 0 ; i < 2 ; ++i ) - delete threads[i]; - threads.clear(); - - mTestLeaks = false; // For some reasons, it reports a leak. -} - -#endif // defined USE_CPP_11 - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, memoryUsage) { - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 4096; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - - std::size_t totalMem, freeMem; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); - ASSERT_EQ(4096, totalMem); - ASSERT_EQ(4096, freeMem); - - void *ptr; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc(&ptr, 1024, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); - ASSERT_EQ(4096, totalMem); - ASSERT_EQ(3072, freeMem); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr, NULL)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); - ASSERT_EQ(4096, totalMem); - ASSERT_EQ(4096, freeMem); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -TEST_F(CnmemTest, testDeviceDoesNotChange) { - - int numDevices; - ASSERT_EQ(cudaSuccess, cudaGetDeviceCount(&numDevices)); - if( numDevices < 2 ) { - ASSERT_TRUE(true); - return; - } - - cnmemDevice_t devices[2]; - memset(devices, 0, sizeof(devices)); - devices[0].device = 0; - devices[0].size = 4096; - devices[1].device = 1; - devices[1].size = 2048; - - int currentDevice; - ASSERT_EQ(cudaSuccess, cudaSetDevice(0)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(2, devices, CNMEM_FLAGS_DEFAULT)); - ASSERT_EQ(cudaSuccess, cudaGetDevice(¤tDevice)); - ASSERT_EQ(0, currentDevice); - - size_t totalMem, freeMem; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); - ASSERT_EQ(4096, totalMem); - ASSERT_EQ(4096, freeMem); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFinalize()); - - ASSERT_EQ(cudaSuccess, cudaSetDevice(1)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(2, devices, CNMEM_FLAGS_DEFAULT)); - ASSERT_EQ(cudaSuccess, cudaGetDevice(¤tDevice)); - ASSERT_EQ(1, currentDevice); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMemGetInfo(&freeMem, &totalMem, cudaStreamDefault)); - ASSERT_EQ(2048, totalMem); - ASSERT_EQ(2048, freeMem); - - ASSERT_EQ(cudaSuccess, cudaSetDevice(0)); // Make sure we are on dev 0 for final mem checks. -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -#ifdef USE_CPP_11 -#include - -template< typename T > -class DeviceDeleter { -public: - DeviceDeleter() {} - void operator()(T *ptr) { - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFree(ptr, cudaStreamDefault)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemRelease()); - } -}; - -TEST_F(CnmemTest, testSharedPtr) { - - cnmemDevice_t device; - memset(&device, 0, sizeof(device)); - device.size = 2048; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemInit(1, &device, CNMEM_FLAGS_DEFAULT)); - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemRetain()); - - float *ptr; - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemMalloc((void**) &ptr, 1024, cudaStreamDefault)); - std::shared_ptr p(ptr, DeviceDeleter()); - - ASSERT_EQ(CNMEM_STATUS_SUCCESS, cnmemFinalize()); // We still have a pointer in the scope... - mFinalize = false; // Make sure TearDown does call finalize again. -} - -#endif - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -int main(int argc, char **argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - diff --git a/3rdparty/cub/cub/agent/agent_histogram.cuh b/3rdparty/cub/cub/agent/agent_histogram.cuh new file mode 100644 index 00000000000..458ab1d9bb5 --- /dev/null +++ b/3rdparty/cub/cub/agent/agent_histogram.cuh @@ -0,0 +1,783 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::AgentHistogram implements a stateful abstraction of CUDA thread blocks for participating in device-wide histogram . + */ + +#pragma once + +#include + +#include "../util_type.cuh" +#include "../block/block_load.cuh" +#include "../grid/grid_queue.cuh" +#include "../iterator/cache_modified_input_iterator.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Tuning policy + ******************************************************************************/ + +/** + * + */ +enum BlockHistogramMemoryPreference +{ + GMEM, + SMEM, + BLEND +}; + + +/** + * Parameterizable tuning policy type for AgentHistogram + */ +template < + int _BLOCK_THREADS, ///< Threads per thread block + int _PIXELS_PER_THREAD, ///< Pixels per thread (per tile of input) + BlockLoadAlgorithm _LOAD_ALGORITHM, ///< The BlockLoad algorithm to use + CacheLoadModifier _LOAD_MODIFIER, ///< Cache load modifier for reading input elements + bool _RLE_COMPRESS, ///< Whether to perform localized RLE to compress samples before histogramming + BlockHistogramMemoryPreference _MEM_PREFERENCE, ///< Whether to prefer privatized shared-memory bins (versus privatized global-memory bins) + bool _WORK_STEALING> ///< Whether to dequeue tiles from a global work queue +struct AgentHistogramPolicy +{ + enum + { + BLOCK_THREADS = _BLOCK_THREADS, ///< Threads per thread block + PIXELS_PER_THREAD = _PIXELS_PER_THREAD, ///< Pixels per thread (per tile of input) + IS_RLE_COMPRESS = _RLE_COMPRESS, ///< Whether to perform localized RLE to compress samples before histogramming + MEM_PREFERENCE = _MEM_PREFERENCE, ///< Whether to prefer privatized shared-memory bins (versus privatized global-memory bins) + IS_WORK_STEALING = _WORK_STEALING, ///< Whether to dequeue tiles from a global work queue + }; + + static const BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM; ///< The BlockLoad algorithm to use + static const CacheLoadModifier LOAD_MODIFIER = _LOAD_MODIFIER; ///< Cache load modifier for reading input elements +}; + + +/****************************************************************************** + * Thread block abstractions + ******************************************************************************/ + +/** + * \brief AgentHistogram implements a stateful abstraction of CUDA thread blocks for participating in device-wide histogram . + */ +template < + typename AgentHistogramPolicyT, ///< Parameterized AgentHistogramPolicy tuning policy type + int PRIVATIZED_SMEM_BINS, ///< Number of privatized shared-memory histogram bins of any channel. Zero indicates privatized counters to be maintained in global memory. + int NUM_CHANNELS, ///< Number of channels interleaved in the input data. Supports up to four channels. + int NUM_ACTIVE_CHANNELS, ///< Number of channels actively being histogrammed + typename SampleIteratorT, ///< Random-access input iterator type for reading samples + typename CounterT, ///< Integer type for counting sample occurrences per histogram bin + typename PrivatizedDecodeOpT, ///< The transform operator type for determining privatized counter indices from samples, one for each channel + typename OutputDecodeOpT, ///< The transform operator type for determining output bin-ids from privatized counter indices, one for each channel + typename OffsetT, ///< Signed integer type for global offsets + int PTX_ARCH = CUB_PTX_ARCH> ///< PTX compute capability +struct AgentHistogram +{ + //--------------------------------------------------------------------- + // Types and constants + //--------------------------------------------------------------------- + + /// The sample type of the input iterator + typedef typename std::iterator_traits::value_type SampleT; + + /// The pixel type of SampleT + typedef typename CubVector::Type PixelT; + + /// The quad type of SampleT + typedef typename CubVector::Type QuadT; + + /// Constants + enum + { + BLOCK_THREADS = AgentHistogramPolicyT::BLOCK_THREADS, + + PIXELS_PER_THREAD = AgentHistogramPolicyT::PIXELS_PER_THREAD, + SAMPLES_PER_THREAD = PIXELS_PER_THREAD * NUM_CHANNELS, + QUADS_PER_THREAD = SAMPLES_PER_THREAD / 4, + + TILE_PIXELS = PIXELS_PER_THREAD * BLOCK_THREADS, + TILE_SAMPLES = SAMPLES_PER_THREAD * BLOCK_THREADS, + + IS_RLE_COMPRESS = AgentHistogramPolicyT::IS_RLE_COMPRESS, + + MEM_PREFERENCE = (PRIVATIZED_SMEM_BINS > 0) ? + AgentHistogramPolicyT::MEM_PREFERENCE : + GMEM, + + IS_WORK_STEALING = AgentHistogramPolicyT::IS_WORK_STEALING, + }; + + /// Cache load modifier for reading input elements + static const CacheLoadModifier LOAD_MODIFIER = AgentHistogramPolicyT::LOAD_MODIFIER; + + + /// Input iterator wrapper type (for applying cache modifier) + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedInputIterator + SampleIteratorT>::Type // Directly use the supplied input iterator type + WrappedSampleIteratorT; + + /// Pixel input iterator type (for applying cache modifier) + typedef CacheModifiedInputIterator + WrappedPixelIteratorT; + + /// Qaud input iterator type (for applying cache modifier) + typedef CacheModifiedInputIterator + WrappedQuadIteratorT; + + /// Parameterized BlockLoad type for samples + typedef BlockLoad< + WrappedSampleIteratorT, + BLOCK_THREADS, + SAMPLES_PER_THREAD, + AgentHistogramPolicyT::LOAD_ALGORITHM> + BlockLoadSampleT; + + /// Parameterized BlockLoad type for pixels + typedef BlockLoad< + WrappedPixelIteratorT, + BLOCK_THREADS, + PIXELS_PER_THREAD, + AgentHistogramPolicyT::LOAD_ALGORITHM> + BlockLoadPixelT; + + /// Parameterized BlockLoad type for quads + typedef BlockLoad< + WrappedQuadIteratorT, + BLOCK_THREADS, + QUADS_PER_THREAD, + AgentHistogramPolicyT::LOAD_ALGORITHM> + BlockLoadQuadT; + + /// Shared memory type required by this thread block + struct _TempStorage + { + CounterT histograms[NUM_ACTIVE_CHANNELS][PRIVATIZED_SMEM_BINS + 1]; // Smem needed for block-privatized smem histogram (with 1 word of padding) + + int tile_idx; + + union + { + typename BlockLoadSampleT::TempStorage sample_load; // Smem needed for loading a tile of samples + typename BlockLoadPixelT::TempStorage pixel_load; // Smem needed for loading a tile of pixels + typename BlockLoadQuadT::TempStorage quad_load; // Smem needed for loading a tile of quads + }; + }; + + + /// Temporary storage type (unionable) + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Per-thread fields + //--------------------------------------------------------------------- + + /// Reference to temp_storage + _TempStorage &temp_storage; + + /// Sample input iterator (with cache modifier applied, if possible) + WrappedSampleIteratorT d_wrapped_samples; + + /// Native pointer for input samples (possibly NULL if unavailable) + SampleT* d_native_samples; + + /// The number of output bins for each channel + int (&num_output_bins)[NUM_ACTIVE_CHANNELS]; + + /// The number of privatized bins for each channel + int (&num_privatized_bins)[NUM_ACTIVE_CHANNELS]; + + /// Reference to gmem privatized histograms for each channel + CounterT* d_privatized_histograms[NUM_ACTIVE_CHANNELS]; + + /// Reference to final output histograms (gmem) + CounterT* (&d_output_histograms)[NUM_ACTIVE_CHANNELS]; + + /// The transform operator for determining output bin-ids from privatized counter indices, one for each channel + OutputDecodeOpT (&output_decode_op)[NUM_ACTIVE_CHANNELS]; + + /// The transform operator for determining privatized counter indices from samples, one for each channel + PrivatizedDecodeOpT (&privatized_decode_op)[NUM_ACTIVE_CHANNELS]; + + /// Whether to prefer privatized smem counters vs privatized global counters + bool prefer_smem; + + + //--------------------------------------------------------------------- + // Initialize privatized bin counters + //--------------------------------------------------------------------- + + // Initialize privatized bin counters + __device__ __forceinline__ void InitBinCounters(CounterT* privatized_histograms[NUM_ACTIVE_CHANNELS]) + { + // Initialize histogram bin counts to zeros + #pragma unroll + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + { + for (int privatized_bin = threadIdx.x; privatized_bin < num_privatized_bins[CHANNEL]; privatized_bin += BLOCK_THREADS) + { + privatized_histograms[CHANNEL][privatized_bin] = 0; + } + } + + // Barrier to make sure all threads are done updating counters + __syncthreads(); + } + + + // Initialize privatized bin counters. Specialized for privatized shared-memory counters + __device__ __forceinline__ void InitSmemBinCounters() + { + CounterT* privatized_histograms[NUM_ACTIVE_CHANNELS]; + + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + privatized_histograms[CHANNEL] = temp_storage.histograms[CHANNEL]; + + InitBinCounters(privatized_histograms); + } + + + // Initialize privatized bin counters. Specialized for privatized global-memory counters + __device__ __forceinline__ void InitGmemBinCounters() + { + InitBinCounters(d_privatized_histograms); + } + + + //--------------------------------------------------------------------- + // Update final output histograms + //--------------------------------------------------------------------- + + // Update final output histograms from privatized histograms + __device__ __forceinline__ void StoreOutput(CounterT* privatized_histograms[NUM_ACTIVE_CHANNELS]) + { + // Barrier to make sure all threads are done updating counters + __syncthreads(); + + // Apply privatized bin counts to output bin counts + #pragma unroll + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + { + int channel_bins = num_privatized_bins[CHANNEL]; + for (int privatized_bin = threadIdx.x; + privatized_bin < channel_bins; + privatized_bin += BLOCK_THREADS) + { + int output_bin = -1; + CounterT count = privatized_histograms[CHANNEL][privatized_bin]; + bool is_valid = count > 0; + + output_decode_op[CHANNEL].BinSelect((SampleT) privatized_bin, output_bin, is_valid); + + if (output_bin >= 0) + { + atomicAdd(&d_output_histograms[CHANNEL][output_bin], count); + } + + } + } + } + + + // Update final output histograms from privatized histograms. Specialized for privatized shared-memory counters + __device__ __forceinline__ void StoreSmemOutput() + { + CounterT* privatized_histograms[NUM_ACTIVE_CHANNELS]; + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + privatized_histograms[CHANNEL] = temp_storage.histograms[CHANNEL]; + + StoreOutput(privatized_histograms); + } + + + // Update final output histograms from privatized histograms. Specialized for privatized global-memory counters + __device__ __forceinline__ void StoreGmemOutput() + { + StoreOutput(d_privatized_histograms); + } + + + //--------------------------------------------------------------------- + // Tile accumulation + //--------------------------------------------------------------------- + + // Accumulate pixels. Specialized for RLE compression. + __device__ __forceinline__ void AccumulatePixels( + SampleT samples[PIXELS_PER_THREAD][NUM_CHANNELS], + bool is_valid[PIXELS_PER_THREAD], + CounterT* privatized_histograms[NUM_ACTIVE_CHANNELS], + Int2Type is_rle_compress) + { + + #pragma unroll + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + { + // Bin pixels + int bins[PIXELS_PER_THREAD]; + + #pragma unroll + for (int PIXEL = 0; PIXEL < PIXELS_PER_THREAD; ++PIXEL) + { + bins[PIXEL] = -1; + privatized_decode_op[CHANNEL].BinSelect(samples[PIXEL][CHANNEL], bins[PIXEL], is_valid[PIXEL]); + } + + CounterT accumulator = 1; + + #pragma unroll + for (int PIXEL = 0; PIXEL < PIXELS_PER_THREAD - 1; ++PIXEL) + { + if (bins[PIXEL] == bins[PIXEL + 1]) + { + accumulator++; + } + else + { + if (bins[PIXEL] >= 0) + atomicAdd(privatized_histograms[CHANNEL] + bins[PIXEL], accumulator); + + accumulator = 1; + } + } + // Last pixel + if (bins[PIXELS_PER_THREAD - 1] >= 0) + atomicAdd(privatized_histograms[CHANNEL] + bins[PIXELS_PER_THREAD - 1], accumulator); + } + } + + + // Accumulate pixels. Specialized for individual accumulation of each pixel. + __device__ __forceinline__ void AccumulatePixels( + SampleT samples[PIXELS_PER_THREAD][NUM_CHANNELS], + bool is_valid[PIXELS_PER_THREAD], + CounterT* privatized_histograms[NUM_ACTIVE_CHANNELS], + Int2Type is_rle_compress) + { + #pragma unroll + for (int PIXEL = 0; PIXEL < PIXELS_PER_THREAD; ++PIXEL) + { + #pragma unroll + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + { + int bin = -1; + privatized_decode_op[CHANNEL].BinSelect(samples[PIXEL][CHANNEL], bin, is_valid[PIXEL]); + if (bin >= 0) + atomicAdd(privatized_histograms[CHANNEL] + bin, 1); + } + } + } + + + /** + * Accumulate pixel, specialized for smem privatized histogram + */ + __device__ __forceinline__ void AccumulateSmemPixels( + SampleT samples[PIXELS_PER_THREAD][NUM_CHANNELS], + bool is_valid[PIXELS_PER_THREAD]) + { + CounterT* privatized_histograms[NUM_ACTIVE_CHANNELS]; + + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + privatized_histograms[CHANNEL] = temp_storage.histograms[CHANNEL]; + + AccumulatePixels(samples, is_valid, privatized_histograms, Int2Type()); + } + + + /** + * Accumulate pixel, specialized for gmem privatized histogram + */ + __device__ __forceinline__ void AccumulateGmemPixels( + SampleT samples[PIXELS_PER_THREAD][NUM_CHANNELS], + bool is_valid[PIXELS_PER_THREAD]) + { + AccumulatePixels(samples, is_valid, d_privatized_histograms, Int2Type()); + } + + + + //--------------------------------------------------------------------- + // Tile loading + //--------------------------------------------------------------------- + + // Load full, aligned tile using pixel iterator (multi-channel) + template + __device__ __forceinline__ void LoadFullAlignedTile( + OffsetT block_offset, + int valid_samples, + SampleT (&samples)[PIXELS_PER_THREAD][NUM_CHANNELS], + Int2Type<_NUM_ACTIVE_CHANNELS> num_active_channels) + { + typedef PixelT AliasedPixels[PIXELS_PER_THREAD]; + + WrappedPixelIteratorT d_wrapped_pixels((PixelT*) (d_native_samples + block_offset)); + + // Load using a wrapped pixel iterator + BlockLoadPixelT(temp_storage.pixel_load).Load( + d_wrapped_pixels, + reinterpret_cast(samples)); + } + + // Load full, aligned tile using quad iterator (single-channel) + __device__ __forceinline__ void LoadFullAlignedTile( + OffsetT block_offset, + int valid_samples, + SampleT (&samples)[PIXELS_PER_THREAD][NUM_CHANNELS], + Int2Type<1> num_active_channels) + { + typedef QuadT AliasedQuads[QUADS_PER_THREAD]; + + WrappedQuadIteratorT d_wrapped_quads((QuadT*) (d_native_samples + block_offset)); + + // Load using a wrapped quad iterator + BlockLoadQuadT(temp_storage.quad_load).Load( + d_wrapped_quads, + reinterpret_cast(samples)); + } + + // Load full, aligned tile + __device__ __forceinline__ void LoadTile( + OffsetT block_offset, + int valid_samples, + SampleT (&samples)[PIXELS_PER_THREAD][NUM_CHANNELS], + Int2Type is_full_tile, + Int2Type is_aligned) + { + LoadFullAlignedTile(block_offset, valid_samples, samples, Int2Type()); + } + + // Load full, mis-aligned tile using sample iterator + __device__ __forceinline__ void LoadTile( + OffsetT block_offset, + int valid_samples, + SampleT (&samples)[PIXELS_PER_THREAD][NUM_CHANNELS], + Int2Type is_full_tile, + Int2Type is_aligned) + { + typedef SampleT AliasedSamples[SAMPLES_PER_THREAD]; + + // Load using sample iterator + BlockLoadSampleT(temp_storage.sample_load).Load( + d_wrapped_samples + block_offset, + reinterpret_cast(samples)); + } + + // Load partially-full, aligned tile using the pixel iterator + __device__ __forceinline__ void LoadTile( + OffsetT block_offset, + int valid_samples, + SampleT (&samples)[PIXELS_PER_THREAD][NUM_CHANNELS], + Int2Type is_full_tile, + Int2Type is_aligned) + { + typedef PixelT AliasedPixels[PIXELS_PER_THREAD]; + + WrappedPixelIteratorT d_wrapped_pixels((PixelT*) (d_native_samples + block_offset)); + + int valid_pixels = valid_samples / NUM_CHANNELS; + + // Load using a wrapped pixel iterator + BlockLoadPixelT(temp_storage.pixel_load).Load( + d_wrapped_pixels, + reinterpret_cast(samples), + valid_pixels); + } + + // Load partially-full, mis-aligned tile using sample iterator + __device__ __forceinline__ void LoadTile( + OffsetT block_offset, + int valid_samples, + SampleT (&samples)[PIXELS_PER_THREAD][NUM_CHANNELS], + Int2Type is_full_tile, + Int2Type is_aligned) + { + typedef SampleT AliasedSamples[SAMPLES_PER_THREAD]; + + BlockLoadSampleT(temp_storage.sample_load).Load( + d_wrapped_samples + block_offset, + reinterpret_cast(samples), + valid_samples); + } + + + //--------------------------------------------------------------------- + // Tile processing + //--------------------------------------------------------------------- + + // Consume a tile of data samples + template < + bool IS_ALIGNED, // Whether the tile offset is aligned (quad-aligned for single-channel, pixel-aligned for multi-channel) + bool IS_FULL_TILE> // Whether the tile is full + __device__ __forceinline__ void ConsumeTile(OffsetT block_offset, int valid_samples) + { + SampleT samples[PIXELS_PER_THREAD][NUM_CHANNELS]; + bool is_valid[PIXELS_PER_THREAD]; + + // Load tile + LoadTile( + block_offset, + valid_samples, + samples, + Int2Type(), + Int2Type()); + + // Set valid flags + #pragma unroll + for (int PIXEL = 0; PIXEL < PIXELS_PER_THREAD; ++PIXEL) + is_valid[PIXEL] = IS_FULL_TILE || (((threadIdx.x * PIXELS_PER_THREAD + PIXEL) * NUM_CHANNELS) < valid_samples); + + // Accumulate samples +#if CUB_PTX_ARCH >= 120 + if (prefer_smem) + AccumulateSmemPixels(samples, is_valid); + else + AccumulateGmemPixels(samples, is_valid); +#else + AccumulateGmemPixels(samples, is_valid); +#endif + + } + + + // Consume row tiles. Specialized for work-stealing from queue + template + __device__ __forceinline__ void ConsumeTiles( + OffsetT num_row_pixels, ///< The number of multi-channel pixels per row in the region of interest + OffsetT num_rows, ///< The number of rows in the region of interest + OffsetT row_stride_samples, ///< The number of samples between starts of consecutive rows in the region of interest + int tiles_per_row, ///< Number of image tiles per row + GridQueue tile_queue, + Int2Type is_work_stealing) + { + + int num_tiles = num_rows * tiles_per_row; + int tile_idx = (blockIdx.y * gridDim.x) + blockIdx.x; + OffsetT num_even_share_tiles = gridDim.x * gridDim.y; + + while (tile_idx < num_tiles) + { + int row = tile_idx / tiles_per_row; + int col = tile_idx - (row * tiles_per_row); + OffsetT row_offset = row * row_stride_samples; + OffsetT col_offset = (col * TILE_SAMPLES); + OffsetT tile_offset = row_offset + col_offset; + + if (col == tiles_per_row - 1) + { + // Consume a partially-full tile at the end of the row + OffsetT num_remaining = (num_row_pixels * NUM_CHANNELS) - col_offset; + ConsumeTile(tile_offset, num_remaining); + } + else + { + // Consume full tile + ConsumeTile(tile_offset, TILE_SAMPLES); + } + + __syncthreads(); + + // Get next tile + if (threadIdx.x == 0) + temp_storage.tile_idx = tile_queue.Drain(1) + num_even_share_tiles; + + __syncthreads(); + + tile_idx = temp_storage.tile_idx; + } + } + + + // Consume row tiles. Specialized for even-share (striped across thread blocks) + template + __device__ __forceinline__ void ConsumeTiles( + OffsetT num_row_pixels, ///< The number of multi-channel pixels per row in the region of interest + OffsetT num_rows, ///< The number of rows in the region of interest + OffsetT row_stride_samples, ///< The number of samples between starts of consecutive rows in the region of interest + int tiles_per_row, ///< Number of image tiles per row + GridQueue tile_queue, + Int2Type is_work_stealing) + { + for (int row = blockIdx.y; row < num_rows; row += gridDim.y) + { + OffsetT row_begin = row * row_stride_samples; + OffsetT row_end = row_begin + (num_row_pixels * NUM_CHANNELS); + OffsetT tile_offset = row_begin + (blockIdx.x * TILE_SAMPLES); + + while (tile_offset < row_end) + { + OffsetT num_remaining = row_end - tile_offset; + + if (num_remaining < TILE_SAMPLES) + { + // Consume partial tile + ConsumeTile(tile_offset, num_remaining); + break; + } + + // Consume full tile + ConsumeTile(tile_offset, TILE_SAMPLES); + tile_offset += gridDim.x * TILE_SAMPLES; + } + } + } + + + //--------------------------------------------------------------------- + // Parameter extraction + //--------------------------------------------------------------------- + + // Return a native pixel pointer (specialized for CacheModifiedInputIterator types) + template < + CacheLoadModifier _MODIFIER, + typename _ValueT, + typename _OffsetT> + __device__ __forceinline__ SampleT* NativePointer(CacheModifiedInputIterator<_MODIFIER, _ValueT, _OffsetT> itr) + { + return itr.ptr; + } + + // Return a native pixel pointer (specialized for other types) + template + __device__ __forceinline__ SampleT* NativePointer(IteratorT itr) + { + return NULL; + } + + + + //--------------------------------------------------------------------- + // Interface + //--------------------------------------------------------------------- + + + /** + * Constructor + */ + __device__ __forceinline__ AgentHistogram( + TempStorage &temp_storage, ///< Reference to temp_storage + SampleIteratorT d_samples, ///< Input data to reduce + int (&num_output_bins)[NUM_ACTIVE_CHANNELS], ///< The number bins per final output histogram + int (&num_privatized_bins)[NUM_ACTIVE_CHANNELS], ///< The number bins per privatized histogram + CounterT* (&d_output_histograms)[NUM_ACTIVE_CHANNELS], ///< Reference to final output histograms + CounterT* (&d_privatized_histograms)[NUM_ACTIVE_CHANNELS], ///< Reference to privatized histograms + OutputDecodeOpT (&output_decode_op)[NUM_ACTIVE_CHANNELS], ///< The transform operator for determining output bin-ids from privatized counter indices, one for each channel + PrivatizedDecodeOpT (&privatized_decode_op)[NUM_ACTIVE_CHANNELS]) ///< The transform operator for determining privatized counter indices from samples, one for each channel + : + temp_storage(temp_storage.Alias()), + d_wrapped_samples(d_samples), + num_output_bins(num_output_bins), + num_privatized_bins(num_privatized_bins), + d_output_histograms(d_output_histograms), + privatized_decode_op(privatized_decode_op), + output_decode_op(output_decode_op), + d_native_samples(NativePointer(d_wrapped_samples)), + prefer_smem((MEM_PREFERENCE == SMEM) ? + true : // prefer smem privatized histograms + (MEM_PREFERENCE == GMEM) ? + false : // prefer gmem privatized histograms + blockIdx.x & 1) // prefer blended privatized histograms + { + int blockId = (blockIdx.y * gridDim.x) + blockIdx.x; + + // Initialize the locations of this block's privatized histograms + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + this->d_privatized_histograms[CHANNEL] = d_privatized_histograms[CHANNEL] + (blockId * num_privatized_bins[CHANNEL]); + } + + + /** + * Consume image + */ + __device__ __forceinline__ void ConsumeTiles( + OffsetT num_row_pixels, ///< The number of multi-channel pixels per row in the region of interest + OffsetT num_rows, ///< The number of rows in the region of interest + OffsetT row_stride_samples, ///< The number of samples between starts of consecutive rows in the region of interest + int tiles_per_row, ///< Number of image tiles per row + GridQueue tile_queue) ///< Queue descriptor for assigning tiles of work to thread blocks + { + // Check whether all row starting offsets are quad-aligned (in single-channel) or pixel-aligned (in multi-channel) + size_t row_bytes = sizeof(SampleT) * row_stride_samples; + size_t offset_mask = size_t(d_native_samples) | row_bytes; + int quad_mask = sizeof(SampleT) * 4 - 1; + int pixel_mask = AlignBytes::ALIGN_BYTES - 1; + bool quad_aligned_rows = (NUM_CHANNELS == 1) && ((offset_mask & quad_mask) == 0); + bool pixel_aligned_rows = (NUM_CHANNELS > 1) && ((offset_mask & pixel_mask) == 0); + + // Whether rows are aligned and can be vectorized + if (quad_aligned_rows || pixel_aligned_rows) + ConsumeTiles(num_row_pixels, num_rows, row_stride_samples, tiles_per_row, tile_queue, Int2Type()); + else + ConsumeTiles(num_row_pixels, num_rows, row_stride_samples, tiles_per_row, tile_queue, Int2Type()); + } + + + /** + * Initialize privatized bin counters. Specialized for privatized shared-memory counters + */ + __device__ __forceinline__ void InitBinCounters() + { + if (prefer_smem) + InitSmemBinCounters(); + else + InitGmemBinCounters(); + } + + + /** + * Store privatized histogram to global memory. Specialized for privatized shared-memory counters + */ + __device__ __forceinline__ void StoreOutput() + { + if (prefer_smem) + StoreSmemOutput(); + else + StoreGmemOutput(); + } + + +}; + + + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/agent/agent_radix_sort_downsweep.cuh b/3rdparty/cub/cub/agent/agent_radix_sort_downsweep.cuh new file mode 100644 index 00000000000..fa060c31dd3 --- /dev/null +++ b/3rdparty/cub/cub/agent/agent_radix_sort_downsweep.cuh @@ -0,0 +1,769 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * AgentRadixSortDownsweep implements a stateful abstraction of CUDA thread blocks for participating in device-wide radix sort downsweep . + */ + + +#pragma once + +#include "../thread/thread_load.cuh" +#include "../block/block_load.cuh" +#include "../block/block_store.cuh" +#include "../block/block_radix_rank.cuh" +#include "../block/block_exchange.cuh" +#include "../util_type.cuh" +#include "../iterator/cache_modified_input_iterator.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Tuning policy types + ******************************************************************************/ + +/** + * Types of scattering strategies + */ +enum RadixSortScatterAlgorithm +{ + RADIX_SORT_SCATTER_DIRECT, ///< Scatter directly from registers to global bins + RADIX_SORT_SCATTER_TWO_PHASE, ///< First scatter from registers into shared memory bins, then into global bins +}; + + +/** + * Parameterizable tuning policy type for AgentRadixSortDownsweep + */ +template < + int _BLOCK_THREADS, ///< Threads per thread block + int _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + BlockLoadAlgorithm _LOAD_ALGORITHM, ///< The BlockLoad algorithm to use + CacheLoadModifier _LOAD_MODIFIER, ///< Cache load modifier for reading keys (and values) + bool _MEMOIZE_OUTER_SCAN, ///< Whether or not to buffer outer raking scan partials to incur fewer shared memory reads at the expense of higher register pressure. See BlockScanAlgorithm::BLOCK_SCAN_RAKING_MEMOIZE for more details. + BlockScanAlgorithm _INNER_SCAN_ALGORITHM, ///< The BlockScan algorithm algorithm to use + RadixSortScatterAlgorithm _SCATTER_ALGORITHM, ///< The scattering strategy to use + cudaSharedMemConfig _SMEM_CONFIG, ///< Shared memory bank mode + int _RADIX_BITS> ///< The number of radix bits, i.e., log2(bins) +struct AgentRadixSortDownsweepPolicy +{ + enum + { + BLOCK_THREADS = _BLOCK_THREADS, ///< Threads per thread block + ITEMS_PER_THREAD = _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + RADIX_BITS = _RADIX_BITS, ///< The number of radix bits, i.e., log2(bins) + MEMOIZE_OUTER_SCAN = _MEMOIZE_OUTER_SCAN, ///< Whether or not to buffer outer raking scan partials to incur fewer shared memory reads at the expense of higher register pressure. See BlockScanAlgorithm::BLOCK_SCAN_RAKING_MEMOIZE for more details. + }; + + static const BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM; ///< The BlockLoad algorithm to use + static const CacheLoadModifier LOAD_MODIFIER = _LOAD_MODIFIER; ///< Cache load modifier for reading keys (and values) + static const BlockScanAlgorithm INNER_SCAN_ALGORITHM = _INNER_SCAN_ALGORITHM; ///< The BlockScan algorithm algorithm to use + static const RadixSortScatterAlgorithm SCATTER_ALGORITHM = _SCATTER_ALGORITHM; ///< The scattering strategy to use + static const cudaSharedMemConfig SMEM_CONFIG = _SMEM_CONFIG; ///< Shared memory bank mode +}; + + +/****************************************************************************** + * Thread block abstractions + ******************************************************************************/ + +/** + * \brief AgentRadixSortDownsweep implements a stateful abstraction of CUDA thread blocks for participating in device-wide radix sort downsweep . + */ +template < + typename AgentRadixSortDownsweepPolicy, ///< Parameterized AgentRadixSortDownsweepPolicy tuning policy type + bool DESCENDING, ///< Whether or not the sorted-order is high-to-low + typename KeyT, ///< KeyT type + typename ValueT, ///< ValueT type + typename OffsetT> ///< Signed integer type for global offsets +struct AgentRadixSortDownsweep +{ + //--------------------------------------------------------------------- + // Type definitions and constants + //--------------------------------------------------------------------- + + // Appropriate unsigned-bits representation of KeyT + typedef typename Traits::UnsignedBits UnsignedBits; + + static const UnsignedBits MIN_KEY = Traits::MIN_KEY; + static const UnsignedBits MAX_KEY = Traits::MAX_KEY; + + static const BlockLoadAlgorithm LOAD_ALGORITHM = AgentRadixSortDownsweepPolicy::LOAD_ALGORITHM; + static const CacheLoadModifier LOAD_MODIFIER = AgentRadixSortDownsweepPolicy::LOAD_MODIFIER; + static const BlockScanAlgorithm INNER_SCAN_ALGORITHM = AgentRadixSortDownsweepPolicy::INNER_SCAN_ALGORITHM; + static const RadixSortScatterAlgorithm SCATTER_ALGORITHM = AgentRadixSortDownsweepPolicy::SCATTER_ALGORITHM; + static const cudaSharedMemConfig SMEM_CONFIG = AgentRadixSortDownsweepPolicy::SMEM_CONFIG; + + enum + { + BLOCK_THREADS = AgentRadixSortDownsweepPolicy::BLOCK_THREADS, + ITEMS_PER_THREAD = AgentRadixSortDownsweepPolicy::ITEMS_PER_THREAD, + RADIX_BITS = AgentRadixSortDownsweepPolicy::RADIX_BITS, + MEMOIZE_OUTER_SCAN = AgentRadixSortDownsweepPolicy::MEMOIZE_OUTER_SCAN, + TILE_ITEMS = BLOCK_THREADS * ITEMS_PER_THREAD, + + RADIX_DIGITS = 1 << RADIX_BITS, + KEYS_ONLY = Equals::VALUE, + + WARP_THREADS = CUB_PTX_LOG_WARP_THREADS, + WARPS = (BLOCK_THREADS + WARP_THREADS - 1) / WARP_THREADS, + + BYTES_PER_SIZET = sizeof(OffsetT), + LOG_BYTES_PER_SIZET = Log2::VALUE, + + LOG_SMEM_BANKS = CUB_PTX_LOG_SMEM_BANKS, + SMEM_BANKS = 1 << LOG_SMEM_BANKS, + + DIGITS_PER_SCATTER_PASS = BLOCK_THREADS / SMEM_BANKS, + SCATTER_PASSES = RADIX_DIGITS / DIGITS_PER_SCATTER_PASS, + + LOG_STORE_TXN_THREADS = LOG_SMEM_BANKS, + STORE_TXN_THREADS = 1 << LOG_STORE_TXN_THREADS, + }; + + // Input iterator wrapper type (for applying cache modifier)s + typedef CacheModifiedInputIterator KeysItr; + typedef CacheModifiedInputIterator ValuesItr; + + // BlockRadixRank type + typedef BlockRadixRank< + BLOCK_THREADS, + RADIX_BITS, + DESCENDING, + MEMOIZE_OUTER_SCAN, + INNER_SCAN_ALGORITHM, + SMEM_CONFIG> BlockRadixRank; + + // BlockLoad type (keys) + typedef BlockLoad< + KeysItr, + BLOCK_THREADS, + ITEMS_PER_THREAD, + LOAD_ALGORITHM> BlockLoadKeys; + + // BlockLoad type (values) + typedef BlockLoad< + ValuesItr, + BLOCK_THREADS, + ITEMS_PER_THREAD, + LOAD_ALGORITHM> BlockLoadValues; + + // BlockExchange type (keys) + typedef BlockExchange< + UnsignedBits, + BLOCK_THREADS, + ITEMS_PER_THREAD> BlockExchangeKeys; + + // BlockExchange type (values) + typedef BlockExchange< + ValueT, + BLOCK_THREADS, + ITEMS_PER_THREAD> BlockExchangeValues; + + + /** + * Shared memory storage layout + */ + struct _TempStorage + { + OffsetT relative_bin_offsets[RADIX_DIGITS + 1]; + bool short_circuit; + + union + { + typename BlockRadixRank::TempStorage ranking; + typename BlockLoadKeys::TempStorage load_keys; + typename BlockLoadValues::TempStorage load_values; + typename BlockExchangeKeys::TempStorage exchange_keys; + typename BlockExchangeValues::TempStorage exchange_values; + }; + }; + + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Thread fields + //--------------------------------------------------------------------- + + // Shared storage for this CTA + _TempStorage &temp_storage; + + // Input and output device pointers + KeysItr d_keys_in; + ValuesItr d_values_in; + UnsignedBits *d_keys_out; + ValueT *d_values_out; + + // The global scatter base offset for each digit (valid in the first RADIX_DIGITS threads) + OffsetT bin_offset; + + // The least-significant bit position of the current digit to extract + int current_bit; + + // Number of bits in current digit + int num_bits; + + // Whether to short-ciruit + bool short_circuit; + + + + //--------------------------------------------------------------------- + // Utility methods + //--------------------------------------------------------------------- + + /** + * Decodes given keys to lookup digit offsets in shared memory + */ + __device__ __forceinline__ void DecodeRelativeBinOffsets( + UnsignedBits (&twiddled_keys)[ITEMS_PER_THREAD], + OffsetT (&relative_bin_offsets)[ITEMS_PER_THREAD]) + { + #pragma unroll + for (int KEY = 0; KEY < ITEMS_PER_THREAD; KEY++) + { + UnsignedBits digit = BFE(twiddled_keys[KEY], current_bit, num_bits); + + // Lookup base digit offset from shared memory + relative_bin_offsets[KEY] = temp_storage.relative_bin_offsets[digit]; + } + } + + + /** + * Scatter ranked items to global memory + */ + template + __device__ __forceinline__ void ScatterItems( + T (&items)[ITEMS_PER_THREAD], + int (&local_ranks)[ITEMS_PER_THREAD], + OffsetT (&relative_bin_offsets)[ITEMS_PER_THREAD], + T *d_out, + OffsetT valid_items) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + // Scatter if not out-of-bounds + if (FULL_TILE || (local_ranks[ITEM] < valid_items)) + { + d_out[relative_bin_offsets[ITEM] + local_ranks[ITEM]] = items[ITEM]; + } + } + } + + + /** + * Scatter ranked keys directly to global memory + */ + template + __device__ __forceinline__ void ScatterKeys( + UnsignedBits (&twiddled_keys)[ITEMS_PER_THREAD], + OffsetT (&relative_bin_offsets)[ITEMS_PER_THREAD], + int (&ranks)[ITEMS_PER_THREAD], + OffsetT valid_items, + Int2Type scatter_algorithm) + { + // Compute scatter offsets + DecodeRelativeBinOffsets(twiddled_keys, relative_bin_offsets); + + // Untwiddle keys before outputting + UnsignedBits keys[ITEMS_PER_THREAD]; + + #pragma unroll + for (int KEY = 0; KEY < ITEMS_PER_THREAD; KEY++) + { + keys[KEY] = Traits::TwiddleOut(twiddled_keys[KEY]); + } + + // Scatter to global + ScatterItems(keys, ranks, relative_bin_offsets, d_keys_out, valid_items); + } + + + /** + * Scatter ranked keys through shared memory, then to global memory + */ + template + __device__ __forceinline__ void ScatterKeys( + UnsignedBits (&twiddled_keys)[ITEMS_PER_THREAD], + OffsetT (&relative_bin_offsets)[ITEMS_PER_THREAD], + int (&ranks)[ITEMS_PER_THREAD], + OffsetT valid_items, + Int2Type scatter_algorithm) + { + // Exchange keys through shared memory + BlockExchangeKeys(temp_storage.exchange_keys).ScatterToStriped(twiddled_keys, ranks); + + // Compute striped local ranks + int local_ranks[ITEMS_PER_THREAD]; + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + local_ranks[ITEM] = threadIdx.x + (ITEM * BLOCK_THREADS); + } + + // Scatter directly + ScatterKeys( + twiddled_keys, + relative_bin_offsets, + local_ranks, + valid_items, + Int2Type()); + } + + + /** + * Scatter ranked values directly to global memory + */ + template + __device__ __forceinline__ void ScatterValues( + ValueT (&values)[ITEMS_PER_THREAD], + OffsetT (&relative_bin_offsets)[ITEMS_PER_THREAD], + int (&ranks)[ITEMS_PER_THREAD], + OffsetT valid_items, + Int2Type scatter_algorithm) + { + // Scatter to global + ScatterItems(values, ranks, relative_bin_offsets, d_values_out, valid_items); + } + + + /** + * Scatter ranked values through shared memory, then to global memory + */ + template + __device__ __forceinline__ void ScatterValues( + ValueT (&values)[ITEMS_PER_THREAD], + OffsetT (&relative_bin_offsets)[ITEMS_PER_THREAD], + int (&ranks)[ITEMS_PER_THREAD], + OffsetT valid_items, + Int2Type scatter_algorithm) + { + __syncthreads(); + + // Exchange keys through shared memory + BlockExchangeValues(temp_storage.exchange_values).ScatterToStriped(values, ranks); + + // Compute striped local ranks + int local_ranks[ITEMS_PER_THREAD]; + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + local_ranks[ITEM] = threadIdx.x + (ITEM * BLOCK_THREADS); + } + + // Scatter directly + ScatterValues( + values, + relative_bin_offsets, + local_ranks, + valid_items, + Int2Type()); + } + + + /** + * Load a tile of items (specialized for full tile) + */ + template + __device__ __forceinline__ void LoadItems( + BlockLoadT &block_loader, + T (&items)[ITEMS_PER_THREAD], + InputIteratorT d_in, + OffsetT valid_items, + Int2Type is_full_tile) + { + block_loader.Load(d_in, items); + } + + + /** + * Load a tile of items (specialized for full tile) + */ + template + __device__ __forceinline__ void LoadItems( + BlockLoadT &block_loader, + T (&items)[ITEMS_PER_THREAD], + InputIteratorT d_in, + OffsetT valid_items, + T oob_item, + Int2Type is_full_tile) + { + block_loader.Load(d_in, items); + } + + + /** + * Load a tile of items (specialized for partial tile) + */ + template + __device__ __forceinline__ void LoadItems( + BlockLoadT &block_loader, + T (&items)[ITEMS_PER_THREAD], + InputIteratorT d_in, + OffsetT valid_items, + Int2Type is_full_tile) + { + block_loader.Load(d_in, items, valid_items); + } + + /** + * Load a tile of items (specialized for partial tile) + */ + template + __device__ __forceinline__ void LoadItems( + BlockLoadT &block_loader, + T (&items)[ITEMS_PER_THREAD], + InputIteratorT d_in, + OffsetT valid_items, + T oob_item, + Int2Type is_full_tile) + { + block_loader.Load(d_in, items, valid_items, oob_item); + } + + + /** + * Truck along associated values + */ + template + __device__ __forceinline__ void GatherScatterValues( + _ValueT (&values)[ITEMS_PER_THREAD], + OffsetT (&relative_bin_offsets)[ITEMS_PER_THREAD], + int (&ranks)[ITEMS_PER_THREAD], + OffsetT block_offset, + OffsetT valid_items) + { + __syncthreads(); + + BlockLoadValues loader(temp_storage.load_values); + LoadItems( + loader, + values, + d_values_in + block_offset, + valid_items, + Int2Type()); + + ScatterValues( + values, + relative_bin_offsets, + ranks, + valid_items, + Int2Type()); + } + + + /** + * Truck along associated values (specialized for key-only sorting) + */ + template + __device__ __forceinline__ void GatherScatterValues( + NullType (&values)[ITEMS_PER_THREAD], + OffsetT (&relative_bin_offsets)[ITEMS_PER_THREAD], + int (&ranks)[ITEMS_PER_THREAD], + OffsetT block_offset, + OffsetT valid_items) + {} + + + /** + * Process tile + */ + template + __device__ __forceinline__ void ProcessTile( + OffsetT block_offset, + const OffsetT &valid_items = TILE_ITEMS) + { + // Per-thread tile data + UnsignedBits keys[ITEMS_PER_THREAD]; // Keys + UnsignedBits twiddled_keys[ITEMS_PER_THREAD]; // Twiddled keys + int ranks[ITEMS_PER_THREAD]; // For each key, the local rank within the CTA + OffsetT relative_bin_offsets[ITEMS_PER_THREAD]; // For each key, the global scatter base offset of the corresponding digit + + // Assign default (min/max) value to all keys + UnsignedBits default_key = (DESCENDING) ? MIN_KEY : MAX_KEY; + + // Load tile of keys + BlockLoadKeys loader(temp_storage.load_keys); + LoadItems( + loader, + keys, + d_keys_in + block_offset, + valid_items, + default_key, + Int2Type()); + + __syncthreads(); + + // Twiddle key bits if necessary + #pragma unroll + for (int KEY = 0; KEY < ITEMS_PER_THREAD; KEY++) + { + twiddled_keys[KEY] = Traits::TwiddleIn(keys[KEY]); + } + + // Rank the twiddled keys + int inclusive_digit_prefix; + BlockRadixRank(temp_storage.ranking).RankKeys( + twiddled_keys, + ranks, + current_bit, + num_bits, + inclusive_digit_prefix); + + // Update global scatter base offsets for each digit + if ((BLOCK_THREADS == RADIX_DIGITS) || (threadIdx.x < RADIX_DIGITS)) + { + int exclusive_digit_prefix; + + // Get exclusive digit prefix from inclusive prefix + if (DESCENDING) + { + // Get the prefix from the next thread (higher bins come first) +#if CUB_PTX_ARCH >= 300 + exclusive_digit_prefix = ShuffleDown(inclusive_digit_prefix, 1); + if (threadIdx.x == RADIX_DIGITS - 1) + exclusive_digit_prefix = 0; +#else + volatile int* exchange = reinterpret_cast(temp_storage.relative_bin_offsets); + exchange[threadIdx.x + 1] = 0; + exchange[threadIdx.x] = inclusive_digit_prefix; + exclusive_digit_prefix = exchange[threadIdx.x + 1]; +#endif + } + else + { + // Get the prefix from the previous thread (lower bins come first) +#if CUB_PTX_ARCH >= 300 + exclusive_digit_prefix = ShuffleUp(inclusive_digit_prefix, 1); + if (threadIdx.x == 0) + exclusive_digit_prefix = 0; +#else + volatile int* exchange = reinterpret_cast(temp_storage.relative_bin_offsets); + exchange[threadIdx.x] = 0; + exchange[threadIdx.x + 1] = inclusive_digit_prefix; + exclusive_digit_prefix = exchange[threadIdx.x]; +#endif + } + + bin_offset -= exclusive_digit_prefix; + temp_storage.relative_bin_offsets[threadIdx.x] = bin_offset; + bin_offset += inclusive_digit_prefix; + } + + __syncthreads(); + + // Scatter keys + ScatterKeys(twiddled_keys, relative_bin_offsets, ranks, valid_items, Int2Type()); + + // Gather/scatter values + ValueT values[ITEMS_PER_THREAD]; + GatherScatterValues(values, relative_bin_offsets, ranks, block_offset, valid_items); + } + + //--------------------------------------------------------------------- + // Copy shortcut + //--------------------------------------------------------------------- + + /** + * Copy tiles within the range of input + */ + template < + typename InputIteratorT, + typename T> + __device__ __forceinline__ void Copy( + InputIteratorT d_in, + T *d_out, + OffsetT block_offset, + OffsetT block_end) + { + // Simply copy the input + while (block_offset + TILE_ITEMS <= block_end) + { + T items[ITEMS_PER_THREAD]; + + LoadDirectStriped(threadIdx.x, d_in + block_offset, items); + __syncthreads(); + StoreDirectStriped(threadIdx.x, d_out + block_offset, items); + + block_offset += TILE_ITEMS; + } + + // Clean up last partial tile with guarded-I/O + if (block_offset < block_end) + { + OffsetT valid_items = block_end - block_offset; + + T items[ITEMS_PER_THREAD]; + + LoadDirectStriped(threadIdx.x, d_in + block_offset, items, valid_items); + __syncthreads(); + StoreDirectStriped(threadIdx.x, d_out + block_offset, items, valid_items); + } + } + + + /** + * Copy tiles within the range of input (specialized for NullType) + */ + template + __device__ __forceinline__ void Copy( + InputIteratorT d_in, + NullType *d_out, + OffsetT block_offset, + OffsetT block_end) + {} + + + //--------------------------------------------------------------------- + // Interface + //--------------------------------------------------------------------- + + /** + * Constructor + */ + __device__ __forceinline__ AgentRadixSortDownsweep( + TempStorage &temp_storage, + OffsetT bin_offset, + KeyT *d_keys_in, + KeyT *d_keys_out, + ValueT *d_values_in, + ValueT *d_values_out, + int current_bit, + int num_bits) + : + temp_storage(temp_storage.Alias()), + bin_offset(bin_offset), + d_keys_in(reinterpret_cast(d_keys_in)), + d_keys_out(reinterpret_cast(d_keys_out)), + d_values_in(d_values_in), + d_values_out(d_values_out), + current_bit(current_bit), + num_bits(num_bits), + short_circuit(false) + {} + + + /** + * Constructor + */ + __device__ __forceinline__ AgentRadixSortDownsweep( + TempStorage &temp_storage, + OffsetT num_items, + OffsetT *d_spine, + KeyT *d_keys_in, + KeyT *d_keys_out, + ValueT *d_values_in, + ValueT *d_values_out, + int current_bit, + int num_bits) + : + temp_storage(temp_storage.Alias()), + d_keys_in(reinterpret_cast(d_keys_in)), + d_keys_out(reinterpret_cast(d_keys_out)), + d_values_in(d_values_in), + d_values_out(d_values_out), + current_bit(current_bit), + num_bits(num_bits) + { + // Load digit bin offsets (each of the first RADIX_DIGITS threads will load an offset for that digit) + if (threadIdx.x < RADIX_DIGITS) + { + int bin_idx = (DESCENDING) ? + RADIX_DIGITS - threadIdx.x - 1 : + threadIdx.x; + + // Short circuit if the first block's histogram has only bin counts of only zeros or problem-size + OffsetT first_block_bin_offset = d_spine[gridDim.x * bin_idx]; + int predicate = ((first_block_bin_offset == 0) || (first_block_bin_offset == num_items)); + this->temp_storage.short_circuit = WarpAll(predicate); + + // Load my block's bin offset for my bin + bin_offset = d_spine[(gridDim.x * bin_idx) + blockIdx.x]; + } + + __syncthreads(); + + short_circuit = this->temp_storage.short_circuit; + } + + + /** + * Distribute keys from a segment of input tiles. + */ + __device__ __forceinline__ void ProcessRegion( + OffsetT block_offset, + const OffsetT &block_end) + { + if (short_circuit) + { + // Copy keys + Copy(d_keys_in, d_keys_out, block_offset, block_end); + + // Copy values + Copy(d_values_in, d_values_out, block_offset, block_end); + } + else + { + // Process full tiles of tile_items + while (block_offset + TILE_ITEMS <= block_end) + { + ProcessTile(block_offset); + block_offset += TILE_ITEMS; + + __syncthreads(); + } + + // Clean up last partial tile with guarded-I/O + if (block_offset < block_end) + { + ProcessTile(block_offset, block_end - block_offset); + } + } + } + +}; + + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/agent/agent_radix_sort_upsweep.cuh b/3rdparty/cub/cub/agent/agent_radix_sort_upsweep.cuh new file mode 100644 index 00000000000..b64a044a933 --- /dev/null +++ b/3rdparty/cub/cub/agent/agent_radix_sort_upsweep.cuh @@ -0,0 +1,449 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * AgentRadixSortUpsweep implements a stateful abstraction of CUDA thread blocks for participating in device-wide radix sort upsweep . + */ + +#pragma once + +#include "../thread/thread_reduce.cuh" +#include "../thread/thread_load.cuh" +#include "../block/block_load.cuh" +#include "../util_type.cuh" +#include "../iterator/cache_modified_input_iterator.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/****************************************************************************** + * Tuning policy types + ******************************************************************************/ + +/** + * Parameterizable tuning policy type for AgentRadixSortUpsweep + */ +template < + int _BLOCK_THREADS, ///< Threads per thread block + int _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + CacheLoadModifier _LOAD_MODIFIER, ///< Cache load modifier for reading keys + int _RADIX_BITS> ///< The number of radix bits, i.e., log2(bins) +struct AgentRadixSortUpsweepPolicy +{ + enum + { + BLOCK_THREADS = _BLOCK_THREADS, ///< Threads per thread block + ITEMS_PER_THREAD = _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + RADIX_BITS = _RADIX_BITS, ///< The number of radix bits, i.e., log2(bins) + }; + + static const CacheLoadModifier LOAD_MODIFIER = _LOAD_MODIFIER; ///< Cache load modifier for reading keys +}; + + +/****************************************************************************** + * Thread block abstractions + ******************************************************************************/ + +/** + * \brief AgentRadixSortUpsweep implements a stateful abstraction of CUDA thread blocks for participating in device-wide radix sort upsweep . + */ +template < + typename AgentRadixSortUpsweepPolicy, ///< Parameterized AgentRadixSortUpsweepPolicy tuning policy type + typename KeyT, ///< KeyT type + typename OffsetT> ///< Signed integer type for global offsets +struct AgentRadixSortUpsweep +{ + + //--------------------------------------------------------------------- + // Type definitions and constants + //--------------------------------------------------------------------- + + typedef typename Traits::UnsignedBits UnsignedBits; + + // Integer type for digit counters (to be packed into words of PackedCounters) + typedef unsigned char DigitCounter; + + // Integer type for packing DigitCounters into columns of shared memory banks + typedef unsigned int PackedCounter; + + static const CacheLoadModifier LOAD_MODIFIER = AgentRadixSortUpsweepPolicy::LOAD_MODIFIER; + + enum + { + RADIX_BITS = AgentRadixSortUpsweepPolicy::RADIX_BITS, + BLOCK_THREADS = AgentRadixSortUpsweepPolicy::BLOCK_THREADS, + KEYS_PER_THREAD = AgentRadixSortUpsweepPolicy::ITEMS_PER_THREAD, + + RADIX_DIGITS = 1 << RADIX_BITS, + + LOG_WARP_THREADS = CUB_PTX_LOG_WARP_THREADS, + WARP_THREADS = 1 << LOG_WARP_THREADS, + WARPS = (BLOCK_THREADS + WARP_THREADS - 1) / WARP_THREADS, + + TILE_ITEMS = BLOCK_THREADS * KEYS_PER_THREAD, + + BYTES_PER_COUNTER = sizeof(DigitCounter), + LOG_BYTES_PER_COUNTER = Log2::VALUE, + + PACKING_RATIO = sizeof(PackedCounter) / sizeof(DigitCounter), + LOG_PACKING_RATIO = Log2::VALUE, + + LOG_COUNTER_LANES = CUB_MAX(0, RADIX_BITS - LOG_PACKING_RATIO), + COUNTER_LANES = 1 << LOG_COUNTER_LANES, + + // To prevent counter overflow, we must periodically unpack and aggregate the + // digit counters back into registers. Each counter lane is assigned to a + // warp for aggregation. + + LANES_PER_WARP = CUB_MAX(1, (COUNTER_LANES + WARPS - 1) / WARPS), + + // Unroll tiles in batches without risk of counter overflow + UNROLL_COUNT = CUB_MIN(64, 255 / KEYS_PER_THREAD), + UNROLLED_ELEMENTS = UNROLL_COUNT * TILE_ITEMS, + }; + + + // Input iterator wrapper type (for applying cache modifier)s + typedef CacheModifiedInputIterator KeysItr; + + /** + * Shared memory storage layout + */ + struct _TempStorage + { + union + { + DigitCounter digit_counters[COUNTER_LANES][BLOCK_THREADS][PACKING_RATIO]; + PackedCounter packed_counters[COUNTER_LANES][BLOCK_THREADS]; + OffsetT digit_partials[RADIX_DIGITS][WARP_THREADS + 1]; + }; + }; + + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Thread fields (aggregate state bundle) + //--------------------------------------------------------------------- + + // Shared storage for this CTA + _TempStorage &temp_storage; + + // Thread-local counters for periodically aggregating composite-counter lanes + OffsetT local_counts[LANES_PER_WARP][PACKING_RATIO]; + + // Input and output device pointers + KeysItr d_keys_in; + + // The least-significant bit position of the current digit to extract + int current_bit; + + // Number of bits in current digit + int num_bits; + + + + //--------------------------------------------------------------------- + // Helper structure for templated iteration + //--------------------------------------------------------------------- + + // Iterate + template + struct Iterate + { + // BucketKeys + static __device__ __forceinline__ void BucketKeys( + AgentRadixSortUpsweep &cta, + UnsignedBits keys[KEYS_PER_THREAD]) + { + cta.Bucket(keys[COUNT]); + + // Next + Iterate::BucketKeys(cta, keys); + } + }; + + // Terminate + template + struct Iterate + { + // BucketKeys + static __device__ __forceinline__ void BucketKeys(AgentRadixSortUpsweep &cta, UnsignedBits keys[KEYS_PER_THREAD]) {} + }; + + + //--------------------------------------------------------------------- + // Utility methods + //--------------------------------------------------------------------- + + /** + * Decode a key and increment corresponding smem digit counter + */ + __device__ __forceinline__ void Bucket(UnsignedBits key) + { + // Perform transform op + UnsignedBits converted_key = Traits::TwiddleIn(key); + + // Extract current digit bits + UnsignedBits digit = BFE(converted_key, current_bit, num_bits); + + // Get sub-counter offset + UnsignedBits sub_counter = digit & (PACKING_RATIO - 1); + + // Get row offset + UnsignedBits row_offset = digit >> LOG_PACKING_RATIO; + + // Increment counter + temp_storage.digit_counters[row_offset][threadIdx.x][sub_counter]++; + } + + + /** + * Reset composite counters + */ + __device__ __forceinline__ void ResetDigitCounters() + { + #pragma unroll + for (int LANE = 0; LANE < COUNTER_LANES; LANE++) + { + temp_storage.packed_counters[LANE][threadIdx.x] = 0; + } + } + + + /** + * Reset the unpacked counters in each thread + */ + __device__ __forceinline__ void ResetUnpackedCounters() + { + #pragma unroll + for (int LANE = 0; LANE < LANES_PER_WARP; LANE++) + { + #pragma unroll + for (int UNPACKED_COUNTER = 0; UNPACKED_COUNTER < PACKING_RATIO; UNPACKED_COUNTER++) + { + local_counts[LANE][UNPACKED_COUNTER] = 0; + } + } + } + + + /** + * Extracts and aggregates the digit counters for each counter lane + * owned by this warp + */ + __device__ __forceinline__ void UnpackDigitCounts() + { + unsigned int warp_id = threadIdx.x >> LOG_WARP_THREADS; + unsigned int warp_tid = threadIdx.x & (WARP_THREADS - 1); + + #pragma unroll + for (int LANE = 0; LANE < LANES_PER_WARP; LANE++) + { + const int counter_lane = (LANE * WARPS) + warp_id; + if (counter_lane < COUNTER_LANES) + { + #pragma unroll + for (int PACKED_COUNTER = 0; PACKED_COUNTER < BLOCK_THREADS; PACKED_COUNTER += WARP_THREADS) + { + #pragma unroll + for (int UNPACKED_COUNTER = 0; UNPACKED_COUNTER < PACKING_RATIO; UNPACKED_COUNTER++) + { + OffsetT counter = temp_storage.digit_counters[counter_lane][warp_tid + PACKED_COUNTER][UNPACKED_COUNTER]; + local_counts[LANE][UNPACKED_COUNTER] += counter; + } + } + } + } + } + + + /** + * Places unpacked counters into smem for final digit reduction + */ + __device__ __forceinline__ void ReduceUnpackedCounts(OffsetT &bin_count) + { + unsigned int warp_id = threadIdx.x >> LOG_WARP_THREADS; + unsigned int warp_tid = threadIdx.x & (WARP_THREADS - 1); + + // Place unpacked digit counters in shared memory + #pragma unroll + for (int LANE = 0; LANE < LANES_PER_WARP; LANE++) + { + int counter_lane = (LANE * WARPS) + warp_id; + if (counter_lane < COUNTER_LANES) + { + int digit_row = counter_lane << LOG_PACKING_RATIO; + + #pragma unroll + for (int UNPACKED_COUNTER = 0; UNPACKED_COUNTER < PACKING_RATIO; UNPACKED_COUNTER++) + { + temp_storage.digit_partials[digit_row + UNPACKED_COUNTER][warp_tid] = + local_counts[LANE][UNPACKED_COUNTER]; + } + } + } + + __syncthreads(); + + // Rake-reduce bin_count reductions + if (threadIdx.x < RADIX_DIGITS) + { + bin_count = ThreadReduce( + temp_storage.digit_partials[threadIdx.x], + Sum()); + } + } + + + /** + * Processes a single, full tile + */ + __device__ __forceinline__ void ProcessFullTile(OffsetT block_offset) + { + // Tile of keys + UnsignedBits keys[KEYS_PER_THREAD]; + + LoadDirectStriped(threadIdx.x, d_keys_in + block_offset, keys); + + // Prevent hoisting + __syncthreads(); + + // Bucket tile of keys + Iterate<0, KEYS_PER_THREAD>::BucketKeys(*this, keys); + } + + + /** + * Processes a single load (may have some threads masked off) + */ + __device__ __forceinline__ void ProcessPartialTile( + OffsetT block_offset, + const OffsetT &block_end) + { + // Process partial tile if necessary using single loads + block_offset += threadIdx.x; + while (block_offset < block_end) + { + // Load and bucket key + UnsignedBits key = d_keys_in[block_offset]; + Bucket(key); + block_offset += BLOCK_THREADS; + } + } + + + //--------------------------------------------------------------------- + // Interface + //--------------------------------------------------------------------- + + /** + * Constructor + */ + __device__ __forceinline__ AgentRadixSortUpsweep( + TempStorage &temp_storage, + KeyT *d_keys_in, + int current_bit, + int num_bits) + : + temp_storage(temp_storage.Alias()), + d_keys_in(reinterpret_cast(d_keys_in)), + current_bit(current_bit), + num_bits(num_bits) + {} + + + /** + * Compute radix digit histograms from a segment of input tiles. + */ + __device__ __forceinline__ void ProcessRegion( + OffsetT block_offset, + const OffsetT &block_end, + OffsetT &bin_count) ///< [out] The digit count for tid'th bin (output param, valid in the first RADIX_DIGITS threads) + { + // Reset digit counters in smem and unpacked counters in registers + ResetDigitCounters(); + ResetUnpackedCounters(); + + // Unroll batches of full tiles + while (block_offset + UNROLLED_ELEMENTS <= block_end) + { + for (int i = 0; i < UNROLL_COUNT; ++i) + { + ProcessFullTile(block_offset); + block_offset += TILE_ITEMS; + } + + __syncthreads(); + + // Aggregate back into local_count registers to prevent overflow + UnpackDigitCounts(); + + __syncthreads(); + + // Reset composite counters in lanes + ResetDigitCounters(); + } + + // Unroll single full tiles + while (block_offset + TILE_ITEMS <= block_end) + { + ProcessFullTile(block_offset); + block_offset += TILE_ITEMS; + } + + // Process partial tile if necessary + ProcessPartialTile( + block_offset, + block_end); + + __syncthreads(); + + // Aggregate back into local_count registers + UnpackDigitCounts(); + + __syncthreads(); + + // Final raking reduction of counts by bin + ReduceUnpackedCounts(bin_count); + } + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/agent/agent_reduce.cuh b/3rdparty/cub/cub/agent/agent_reduce.cuh new file mode 100644 index 00000000000..85983e9e095 --- /dev/null +++ b/3rdparty/cub/cub/agent/agent_reduce.cuh @@ -0,0 +1,423 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::AgentReduce implements a stateful abstraction of CUDA thread blocks for participating in device-wide reduction . + */ + +#pragma once + +#include + +#include "../block/block_load.cuh" +#include "../block/block_reduce.cuh" +#include "../grid/grid_mapping.cuh" +#include "../grid/grid_queue.cuh" +#include "../grid/grid_even_share.cuh" +#include "../util_type.cuh" +#include "../iterator/cache_modified_input_iterator.cuh" +#include "../util_namespace.cuh" + + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Tuning policy types + ******************************************************************************/ + +/** + * Parameterizable tuning policy type for AgentReduce + */ +template < + int _BLOCK_THREADS, ///< Threads per thread block + int _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + int _VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BlockReduceAlgorithm _BLOCK_ALGORITHM, ///< Cooperative block-wide reduction algorithm to use + CacheLoadModifier _LOAD_MODIFIER, ///< Cache load modifier for reading input elements + GridMappingStrategy _GRID_MAPPING> ///< How to map tiles of input onto thread blocks +struct AgentReducePolicy +{ + enum + { + BLOCK_THREADS = _BLOCK_THREADS, ///< Threads per thread block + ITEMS_PER_THREAD = _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + VECTOR_LOAD_LENGTH = _VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + }; + + static const BlockReduceAlgorithm BLOCK_ALGORITHM = _BLOCK_ALGORITHM; ///< Cooperative block-wide reduction algorithm to use + static const CacheLoadModifier LOAD_MODIFIER = _LOAD_MODIFIER; ///< Cache load modifier for reading input elements + static const GridMappingStrategy GRID_MAPPING = _GRID_MAPPING; ///< How to map tiles of input onto thread blocks +}; + + + +/****************************************************************************** + * Thread block abstractions + ******************************************************************************/ + +/** + * \brief AgentReduce implements a stateful abstraction of CUDA thread blocks for participating in device-wide reduction . + * + * Each thread reduces only the values it loads. If \p FIRST_TILE, this + * partial reduction is stored into \p thread_aggregate. Otherwise it is + * accumulated into \p thread_aggregate. + */ +template < + typename AgentReducePolicy, ///< Parameterized AgentReducePolicy tuning policy type + typename InputIteratorT, ///< Random-access iterator type for input + typename OffsetT, ///< Signed integer type for global offsets + typename ReductionOp> ///< Binary reduction operator type having member T operator()(const T &a, const T &b) +struct AgentReduce +{ + + //--------------------------------------------------------------------- + // Types and constants + //--------------------------------------------------------------------- + + /// The value type of the input iterator + typedef typename std::iterator_traits::value_type T; + + /// Vector type of T for data movement + typedef typename CubVector::Type VectorT; + + /// Input iterator wrapper type (for applying cache modifier) + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedInputIterator + InputIteratorT>::Type // Directly use the supplied input iterator type + WrappedInputIteratorT; + + /// Constants + enum + { + BLOCK_THREADS = AgentReducePolicy::BLOCK_THREADS, + ITEMS_PER_THREAD = AgentReducePolicy::ITEMS_PER_THREAD, + VECTOR_LOAD_LENGTH = CUB_MIN(ITEMS_PER_THREAD, AgentReducePolicy::VECTOR_LOAD_LENGTH), + TILE_ITEMS = BLOCK_THREADS * ITEMS_PER_THREAD, + + // Can vectorize according to the policy if the input iterator is a native pointer to a primitive type + CAN_VECTORIZE = (VECTOR_LOAD_LENGTH > 1) && (IsPointer::VALUE) && Traits::PRIMITIVE, + + }; + + static const CacheLoadModifier LOAD_MODIFIER = AgentReducePolicy::LOAD_MODIFIER; + static const BlockReduceAlgorithm BLOCK_ALGORITHM = AgentReducePolicy::BLOCK_ALGORITHM; + + /// Parameterized BlockReduce primitive + typedef BlockReduce BlockReduceT; + + /// Shared memory type required by this thread block + typedef typename BlockReduceT::TempStorage _TempStorage; + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Per-thread fields + //--------------------------------------------------------------------- + + T thread_aggregate; ///< Each thread's partial reduction + _TempStorage& temp_storage; ///< Reference to temp_storage + InputIteratorT d_in; ///< Input data to reduce + WrappedInputIteratorT d_wrapped_in; ///< Wrapped input data to reduce + ReductionOp reduction_op; ///< Binary reduction operator + int first_tile_size; ///< Size of first tile consumed + bool is_aligned; ///< Whether or not input is vector-aligned + + + //--------------------------------------------------------------------- + // Utility + //--------------------------------------------------------------------- + + + // Whether or not the input is aligned with the vector type (specialized for types we can vectorize) + template + static __device__ __forceinline__ bool IsAligned( + Iterator d_in, + Int2Type can_vectorize) + { + return (size_t(d_in) & (sizeof(VectorT) - 1)) == 0; + } + + // Whether or not the input is aligned with the vector type (specialized for types we cannot vectorize) + template + static __device__ __forceinline__ bool IsAligned( + Iterator d_in, + Int2Type can_vectorize) + { + return false; + } + + + //--------------------------------------------------------------------- + // Interface + //--------------------------------------------------------------------- + + /** + * Constructor + */ + __device__ __forceinline__ AgentReduce( + TempStorage& temp_storage, ///< Reference to temp_storage + InputIteratorT d_in, ///< Input data to reduce + ReductionOp reduction_op) ///< Binary reduction operator + : + temp_storage(temp_storage.Alias()), + d_in(d_in), + d_wrapped_in(d_in), + reduction_op(reduction_op), + first_tile_size(0), + is_aligned(IsAligned(d_in, Int2Type())) + {} + + + /** + * Consume a full tile of input (specialized for cases where we cannot vectorize) + */ + template + __device__ __forceinline__ T ConsumeFullTile( + _OffsetT block_offset, ///< The offset the tile to consume + Int2Type can_vectorize) ///< Whether or not we can vectorize loads + { + T items[ITEMS_PER_THREAD]; + + // Load items in striped fashion + LoadDirectStriped(threadIdx.x, d_wrapped_in + block_offset, items); + + // Reduce items within each thread stripe + return ThreadReduce(items, reduction_op); + } + + + /** + * Consume a full tile of input (specialized for cases where we can vectorize) + */ + template + __device__ __forceinline__ T ConsumeFullTile( + _OffsetT block_offset, ///< The offset the tile to consume + Int2Type can_vectorize) ///< Whether or not we can vectorize loads + { + if (!is_aligned) + { + // Not aligned + return ConsumeFullTile(block_offset, Int2Type()); + } + else + { + // Alias items as an array of VectorT and load it in striped fashion + enum { WORDS = ITEMS_PER_THREAD / VECTOR_LOAD_LENGTH }; + + T items[ITEMS_PER_THREAD]; + + VectorT *vec_items = reinterpret_cast(items); + + // Vector Input iterator wrapper type (for applying cache modifier) + T *d_in_unqualified = const_cast(d_in) + block_offset + (threadIdx.x * VECTOR_LOAD_LENGTH); + CacheModifiedInputIterator d_vec_in( + reinterpret_cast(d_in_unqualified)); + + #pragma unroll + for (int i = 0; i < WORDS; ++i) + vec_items[i] = d_vec_in[BLOCK_THREADS * i]; + + // Reduce items within each thread stripe + return ThreadReduce(items, reduction_op); + } + } + + + + /** + * Process a single tile of input + */ + template + __device__ __forceinline__ void ConsumeTile( + OffsetT block_offset, ///< The offset the tile to consume + int valid_items = TILE_ITEMS) ///< The number of valid items in the tile + { + if (FULL_TILE) + { + // Full tile + T partial = ConsumeFullTile(block_offset, Int2Type()); + + if (first_tile_size != 0) + partial = reduction_op(thread_aggregate, partial); + + thread_aggregate = partial; + } + else + { + // Partial tile + int thread_offset = threadIdx.x; + + if (!first_tile_size && (thread_offset < valid_items)) + { + // Assign thread_aggregate + thread_aggregate = d_wrapped_in[block_offset + thread_offset]; + thread_offset += BLOCK_THREADS; + } + + while (thread_offset < valid_items) + { + // Update thread aggregate + T item = d_wrapped_in[block_offset + thread_offset]; + thread_aggregate = reduction_op(thread_aggregate, item); + thread_offset += BLOCK_THREADS; + } + } + + // Set first tile size if necessary + if (first_tile_size == 0) + first_tile_size = valid_items; + } + + + //--------------------------------------------------------------- + // Consume a contiguous segment of tiles + //--------------------------------------------------------------------- + + /** + * \brief Reduce a contiguous segment of input tiles + */ + __device__ __forceinline__ void ConsumeRange( + OffsetT block_offset, ///< [in] Threadblock begin offset (inclusive) + OffsetT block_end, ///< [in] Threadblock end offset (exclusive) + T &block_aggregate) ///< [out] Running total + { + // Consume subsequent full tiles of input + while (block_offset + TILE_ITEMS <= block_end) + { + ConsumeTile(block_offset); + block_offset += TILE_ITEMS; + } + + // Consume a partially-full tile + if (block_offset < block_end) + { + int valid_items = block_end - block_offset; + ConsumeTile(block_offset, valid_items); + } + + // Compute block-wide reduction + block_aggregate = (first_tile_size < TILE_ITEMS) ? + BlockReduceT(temp_storage).Reduce(thread_aggregate, reduction_op, first_tile_size) : + BlockReduceT(temp_storage).Reduce(thread_aggregate, reduction_op); + } + + + /** + * Reduce a contiguous segment of input tiles + */ + __device__ __forceinline__ void ConsumeRange( + OffsetT num_items, ///< [in] Total number of global input items + GridEvenShare &even_share, ///< [in] GridEvenShare descriptor + GridQueue &queue, ///< [in,out] GridQueue descriptor + T &block_aggregate, ///< [out] Running total + Int2Type is_even_share) ///< [in] Marker type indicating this is an even-share mapping + { + // Initialize even-share descriptor for this thread block + even_share.BlockInit(); + + // Consume input tiles + ConsumeRange(even_share.block_offset, even_share.block_end, block_aggregate); + } + + + //--------------------------------------------------------------------- + // Dynamically consume tiles + //--------------------------------------------------------------------- + + /** + * Dequeue and reduce tiles of items as part of a inter-block reduction + */ + __device__ __forceinline__ void ConsumeRange( + int num_items, ///< Total number of input items + GridQueue queue, ///< Queue descriptor for assigning tiles of work to thread blocks + T &block_aggregate) ///< [out] Running total + { + // Shared dequeue offset + __shared__ OffsetT dequeue_offset; + + // We give each thread block at least one tile of input. + OffsetT block_offset = blockIdx.x * TILE_ITEMS; + OffsetT even_share_base = gridDim.x * TILE_ITEMS; + + while (block_offset + TILE_ITEMS <= num_items) + { + // Consume full tile of input + ConsumeTile(block_offset); + + // Dequeue a tile of items + if (threadIdx.x == 0) + dequeue_offset = queue.Drain(TILE_ITEMS) + even_share_base; + + __syncthreads(); + + // Grab tile offset and check if we're done with full tiles + block_offset = dequeue_offset; + + __syncthreads(); + } + + if (block_offset < num_items) + { + int valid_items = num_items - block_offset; + ConsumeTile(block_offset, valid_items); + } + + // Compute block-wide reduction + block_aggregate = (first_tile_size < TILE_ITEMS) ? + BlockReduceT(temp_storage).Reduce(thread_aggregate, reduction_op, first_tile_size) : + BlockReduceT(temp_storage).Reduce(thread_aggregate, reduction_op); + } + + + /** + * Dequeue and reduce tiles of items as part of a inter-block reduction + */ + __device__ __forceinline__ void ConsumeRange( + OffsetT num_items, ///< [in] Total number of global input items + GridEvenShare &even_share, ///< [in] GridEvenShare descriptor + GridQueue &queue, ///< [in,out] GridQueue descriptor + T &block_aggregate, ///< [out] Running total + Int2Type is_dynamic) ///< [in] Marker type indicating this is a dynamic mapping + { + ConsumeRange(num_items, queue, block_aggregate); + } + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/agent/agent_reduce_by_key.cuh b/3rdparty/cub/cub/agent/agent_reduce_by_key.cuh new file mode 100644 index 00000000000..580e89b77d1 --- /dev/null +++ b/3rdparty/cub/cub/agent/agent_reduce_by_key.cuh @@ -0,0 +1,701 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::AgentReduceByKey implements a stateful abstraction of CUDA thread blocks for participating in device-wide reduce-value-by-key. + */ + +#pragma once + +#include + +#include "single_pass_scan_operators.cuh" +#include "../block/block_load.cuh" +#include "../block/block_store.cuh" +#include "../block/block_scan.cuh" +#include "../block/block_discontinuity.cuh" +#include "../iterator/cache_modified_input_iterator.cuh" +#include "../iterator/constant_input_iterator.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Tuning policy types + ******************************************************************************/ + +/** + * Parameterizable tuning policy type for AgentReduceByKey + */ +template < + int _BLOCK_THREADS, ///< Threads per thread block + int _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + BlockLoadAlgorithm _LOAD_ALGORITHM, ///< The BlockLoad algorithm to use + CacheLoadModifier _LOAD_MODIFIER, ///< Cache load modifier for reading input elements + BlockScanAlgorithm _SCAN_ALGORITHM> ///< The BlockScan algorithm to use +struct AgentReduceByKeyPolicy +{ + enum + { + BLOCK_THREADS = _BLOCK_THREADS, ///< Threads per thread block + ITEMS_PER_THREAD = _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + }; + + static const BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM; ///< The BlockLoad algorithm to use + static const CacheLoadModifier LOAD_MODIFIER = _LOAD_MODIFIER; ///< Cache load modifier for reading input elements + static const BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM; ///< The BlockScan algorithm to use +}; + + +/****************************************************************************** + * Thread block abstractions + ******************************************************************************/ + +/** + * \brief AgentReduceByKey implements a stateful abstraction of CUDA thread blocks for participating in device-wide reduce-value-by-key + */ +template < + typename AgentReduceByKeyPolicyT, ///< Parameterized AgentReduceByKeyPolicy tuning policy type + typename KeysInputIteratorT, ///< Random-access input iterator type for keys + typename UniqueOutputIteratorT, ///< Random-access output iterator type for keys + typename ValuesInputIteratorT, ///< Random-access input iterator type for values + typename AggregatesOutputIteratorT, ///< Random-access output iterator type for values + typename NumRunsOutputIteratorT, ///< Output iterator type for recording number of items selected + typename EqualityOpT, ///< KeyT equality operator type + typename ReductionOpT, ///< ValueT reduction operator type + typename OffsetT> ///< Signed integer type for global offsets +struct AgentReduceByKey +{ + //--------------------------------------------------------------------- + // Types and constants + //--------------------------------------------------------------------- + + // Data type of key iterator + typedef typename std::iterator_traits::value_type KeyT; + + // Data type of value iterator + typedef typename std::iterator_traits::value_type ValueT; + + // Tuple type for scanning (pairs accumulated segment-value with segment-index) + typedef KeyValuePair OffsetValuePairT; + + // Tuple type for pairing keys and values + typedef KeyValuePair KeyValuePairT; + + // Tile status descriptor interface type + typedef ReduceByKeyScanTileState ScanTileStateT; + + // Constants + enum + { + BLOCK_THREADS = AgentReduceByKeyPolicyT::BLOCK_THREADS, + ITEMS_PER_THREAD = AgentReduceByKeyPolicyT::ITEMS_PER_THREAD, + TILE_ITEMS = BLOCK_THREADS * ITEMS_PER_THREAD, + TWO_PHASE_SCATTER = (ITEMS_PER_THREAD > 1), + + // Whether or not the scan operation has a zero-valued identity value (true if we're performing addition on a primitive type) + HAS_IDENTITY_ZERO = (Equals::VALUE) && (Traits::PRIMITIVE), + }; + + // Cache-modified Input iterator wrapper type (for applying cache modifier) for keys + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedValuesInputIterator + KeysInputIteratorT>::Type // Directly use the supplied input iterator type + WrappedKeysInputIteratorT; + + // Cache-modified Input iterator wrapper type (for applying cache modifier) for values + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedValuesInputIterator + ValuesInputIteratorT>::Type // Directly use the supplied input iterator type + WrappedValuesInputIteratorT; + + // Cache-modified Input iterator wrapper type (for applying cache modifier) for fixup values + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedValuesInputIterator + AggregatesOutputIteratorT>::Type // Directly use the supplied input iterator type + WrappedFixupInputIteratorT; + + // Reduce-value-by-segment scan operator + typedef ReduceBySegmentOp ReduceBySegmentOpT; + + // Parameterized BlockLoad type for keys + typedef BlockLoad< + WrappedKeysInputIteratorT, + BLOCK_THREADS, + ITEMS_PER_THREAD, + AgentReduceByKeyPolicyT::LOAD_ALGORITHM> + BlockLoadKeys; + + // Parameterized BlockLoad type for values + typedef BlockLoad< + WrappedValuesInputIteratorT, + BLOCK_THREADS, + ITEMS_PER_THREAD, + AgentReduceByKeyPolicyT::LOAD_ALGORITHM> + BlockLoadValues; + + // Parameterized BlockDiscontinuity type for keys + typedef BlockDiscontinuity< + KeyT, + BLOCK_THREADS> + BlockDiscontinuityKeys; + + // Parameterized BlockScan type + typedef BlockScan< + OffsetValuePairT, + BLOCK_THREADS, + AgentReduceByKeyPolicyT::SCAN_ALGORITHM> + BlockScanT; + + // Callback type for obtaining tile prefix during block scan + typedef TilePrefixCallbackOp< + OffsetValuePairT, + ReduceBySegmentOpT, + ScanTileStateT> + TilePrefixCallbackOpT; + + // Key and value exchange types + typedef KeyT KeyExchangeT[TILE_ITEMS + 1]; + typedef ValueT ValueExchangeT[TILE_ITEMS + 1]; + + // Shared memory type for this threadblock + union _TempStorage + { + struct + { + typename BlockScanT::TempStorage scan; // Smem needed for tile scanning + typename TilePrefixCallbackOpT::TempStorage prefix; // Smem needed for cooperative prefix callback + typename BlockDiscontinuityKeys::TempStorage discontinuity; // Smem needed for discontinuity detection + }; + + // Smem needed for loading keys + typename BlockLoadKeys::TempStorage load_keys; + + // Smem needed for loading values + typename BlockLoadValues::TempStorage load_values; + + // Smem needed for compacting key value pairs(allows non POD items in this union) + Uninitialized raw_exchange; + }; + + // Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Per-thread fields + //--------------------------------------------------------------------- + + _TempStorage& temp_storage; ///< Reference to temp_storage + WrappedKeysInputIteratorT d_keys_in; ///< Input keys + UniqueOutputIteratorT d_unique_out; ///< Unique output keys + WrappedValuesInputIteratorT d_values_in; ///< Input values + AggregatesOutputIteratorT d_aggregates_out; ///< Output value aggregates + NumRunsOutputIteratorT d_num_runs_out; ///< Output pointer for total number of segments identified + WrappedFixupInputIteratorT d_fixup_in; ///< Fixup input values + InequalityWrapper inequality_op; ///< KeyT inequality operator + ReductionOpT reduction_op; ///< Reduction operator + ReduceBySegmentOpT scan_op; ///< Reduce-by-segment scan operator + + + //--------------------------------------------------------------------- + // Constructor + //--------------------------------------------------------------------- + + // Constructor + __device__ __forceinline__ + AgentReduceByKey( + TempStorage& temp_storage, ///< Reference to temp_storage + KeysInputIteratorT d_keys_in, ///< Input keys + UniqueOutputIteratorT d_unique_out, ///< Unique output keys + ValuesInputIteratorT d_values_in, ///< Input values + AggregatesOutputIteratorT d_aggregates_out, ///< Output value aggregates + NumRunsOutputIteratorT d_num_runs_out, ///< Output pointer for total number of segments identified + EqualityOpT equality_op, ///< KeyT equality operator + ReductionOpT reduction_op) ///< ValueT reduction operator + : + temp_storage(temp_storage.Alias()), + d_keys_in(d_keys_in), + d_unique_out(d_unique_out), + d_values_in(d_values_in), + d_aggregates_out(d_aggregates_out), + d_num_runs_out(d_num_runs_out), + d_fixup_in(d_aggregates_out), + inequality_op(equality_op), + reduction_op(reduction_op), + scan_op(reduction_op) + {} + + + //--------------------------------------------------------------------- + // Block scan utility methods + //--------------------------------------------------------------------- + + /** + * Scan with identity (first tile) + */ + __device__ __forceinline__ + void ScanTile( + OffsetValuePairT (&scan_items)[ITEMS_PER_THREAD], + OffsetValuePairT& tile_aggregate, + Int2Type has_identity) + { + OffsetValuePairT identity; + identity.value = 0; + identity.key = 0; + BlockScanT(temp_storage.scan).ExclusiveScan(scan_items, scan_items, identity, scan_op, tile_aggregate); + } + + /** + * Scan without identity (first tile). Without an identity, the first output item is undefined. + * + */ + __device__ __forceinline__ + void ScanTile( + OffsetValuePairT (&scan_items)[ITEMS_PER_THREAD], + OffsetValuePairT& tile_aggregate, + Int2Type has_identity) + { + BlockScanT(temp_storage.scan).ExclusiveScan(scan_items, scan_items, scan_op, tile_aggregate); + } + + /** + * Scan with identity (subsequent tile) + */ + __device__ __forceinline__ + void ScanTile( + OffsetValuePairT (&scan_items)[ITEMS_PER_THREAD], + OffsetValuePairT& tile_aggregate, + TilePrefixCallbackOpT& prefix_op, + Int2Type has_identity) + { + OffsetValuePairT identity; + identity.value = 0; + identity.key = 0; + BlockScanT(temp_storage.scan).ExclusiveScan(scan_items, scan_items, identity, scan_op, tile_aggregate, prefix_op); + } + + /** + * Scan without identity (subsequent tile). Without an identity, the first output item is undefined. + */ + __device__ __forceinline__ + void ScanTile( + OffsetValuePairT (&scan_items)[ITEMS_PER_THREAD], + OffsetValuePairT& tile_aggregate, + TilePrefixCallbackOpT& prefix_op, + Int2Type has_identity) + { + BlockScanT(temp_storage.scan).ExclusiveScan(scan_items, scan_items, scan_op, tile_aggregate, prefix_op); + } + + + //--------------------------------------------------------------------- + // Zip utility methods + //--------------------------------------------------------------------- + + template + __device__ __forceinline__ void ZipValuesAndFlags( + OffsetT num_remaining, + ValueT (&values)[ITEMS_PER_THREAD], + OffsetT (&segment_flags)[ITEMS_PER_THREAD], + OffsetValuePairT (&scan_items)[ITEMS_PER_THREAD]) + { + // Zip values and segment_flags + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + // Set segment_flags for first out-of-bounds item, zero for others + if (IS_LAST_TILE && (OffsetT(threadIdx.x * ITEMS_PER_THREAD) + ITEM == num_remaining)) + segment_flags[ITEM] = 1; + + scan_items[ITEM].value = values[ITEM]; + scan_items[ITEM].key = segment_flags[ITEM]; + } + } + + __device__ __forceinline__ void ZipKeysAndValues( + KeyT (&keys)[ITEMS_PER_THREAD], ///< in + OffsetT (&segment_indices)[ITEMS_PER_THREAD], ///< out + OffsetValuePairT (&scan_items)[ITEMS_PER_THREAD], ///< in + KeyValuePairT (&scatter_items)[ITEMS_PER_THREAD]) ///< out + { + // Zip values and segment_flags + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + scatter_items[ITEM].key = keys[ITEM]; + scatter_items[ITEM].value = scan_items[ITEM].value; + segment_indices[ITEM] = scan_items[ITEM].key; + } + } + + + //--------------------------------------------------------------------- + // Scatter utility methods + //--------------------------------------------------------------------- + + /** + * Directly scatter flagged items to output offsets (specialized for IS_SEGMENTED_REDUCTION_FIXUP == false) + */ + __device__ __forceinline__ void ScatterDirect( + KeyValuePairT (&scatter_items)[ITEMS_PER_THREAD], + OffsetT (&segment_flags)[ITEMS_PER_THREAD], + OffsetT (&segment_indices)[ITEMS_PER_THREAD]) + { + // Scatter flagged keys and values + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + if (segment_flags[ITEM]) + { + // Scatter key + d_unique_out[segment_indices[ITEM]] = scatter_items[ITEM].key; + + // Scatter value + d_aggregates_out[segment_indices[ITEM]] = scatter_items[ITEM].value; + } + } + } + + + /** + * 2-phase scatter flagged items to output offsets (specialized for IS_SEGMENTED_REDUCTION_FIXUP == false) + * + * The exclusive scan causes each head flag to be paired with the previous + * value aggregate: the scatter offsets must be decremented for value aggregates + */ + __device__ __forceinline__ void ScatterTwoPhase( + KeyValuePairT (&scatter_items)[ITEMS_PER_THREAD], + OffsetT (&segment_flags)[ITEMS_PER_THREAD], + OffsetT (&segment_indices)[ITEMS_PER_THREAD], + OffsetT num_tile_segments, + OffsetT num_tile_segments_prefix) + { + __syncthreads(); + + // Compact and scatter keys + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + if (segment_flags[ITEM]) + { + temp_storage.raw_exchange.Alias()[segment_indices[ITEM] - num_tile_segments_prefix] = scatter_items[ITEM]; + } + } + + __syncthreads(); + + for (int item = threadIdx.x; item < num_tile_segments; item += BLOCK_THREADS) + { + KeyValuePairT pair = temp_storage.raw_exchange.Alias()[item]; + d_unique_out[num_tile_segments_prefix + item] = pair.key; + d_aggregates_out[num_tile_segments_prefix + item] = pair.value; + } + } + + + /** + * Scatter flagged items + */ + __device__ __forceinline__ void Scatter( + KeyValuePairT (&scatter_items)[ITEMS_PER_THREAD], + OffsetT (&segment_flags)[ITEMS_PER_THREAD], + OffsetT (&segment_indices)[ITEMS_PER_THREAD], + OffsetT num_tile_segments, + OffsetT num_tile_segments_prefix) + { + // Do a one-phase scatter if (a) two-phase is disabled or (b) the average number of selected items per thread is less than one + if (TWO_PHASE_SCATTER && (num_tile_segments > BLOCK_THREADS)) + { + ScatterTwoPhase( + scatter_items, + segment_flags, + segment_indices, + num_tile_segments, + num_tile_segments_prefix); + } + else + { + ScatterDirect( + scatter_items, + segment_flags, + segment_indices); + } + } + + + //--------------------------------------------------------------------- + // Finalization utility methods + //--------------------------------------------------------------------- + + /** + * Finalize the carry-out from the last tile (specialized for IS_SEGMENTED_REDUCTION_FIXUP == false) + */ + __device__ __forceinline__ void FinalizeLastTile( + OffsetT num_segments, + OffsetT num_remaining, + KeyT last_key, + ValueT last_value) + { + // Last thread will output final count and last item, if necessary + if (threadIdx.x == BLOCK_THREADS - 1) + { + // If the last tile is a whole tile, the inclusive prefix contains accumulated value reduction for the last segment + if (num_remaining == TILE_ITEMS) + { + // Scatter key and value + d_unique_out[num_segments] = last_key; + d_aggregates_out[num_segments] = last_value; + num_segments++; + } + + // Output the total number of items selected + *d_num_runs_out = num_segments; + } + } + + + //--------------------------------------------------------------------- + // Cooperatively scan a device-wide sequence of tiles with other CTAs + //--------------------------------------------------------------------- + + + /** + * Process first tile of input (dynamic chained scan). Returns the running count of segments and aggregated values (including this tile) + */ + template + __device__ __forceinline__ void ConsumeFirstTile( + OffsetT num_remaining, ///< Number of global input items remaining (including this tile) + OffsetT tile_offset, ///< Tile offset + ScanTileStateT& tile_state) ///< Global tile state descriptor + { + KeyT keys[ITEMS_PER_THREAD]; // Tile keys + KeyT pred_keys[ITEMS_PER_THREAD]; // Tile keys shifted up (predecessor) + ValueT values[ITEMS_PER_THREAD]; // Tile values + OffsetT segment_flags[ITEMS_PER_THREAD]; // Segment head flags + OffsetT segment_indices[ITEMS_PER_THREAD]; // Segment indices + OffsetValuePairT scan_items[ITEMS_PER_THREAD]; // Zipped values and segment flags|indices + KeyValuePairT scatter_items[ITEMS_PER_THREAD]; // Zipped key value pairs for scattering + + // Load keys (last tile repeats final element) + if (IS_LAST_TILE) + BlockLoadKeys(temp_storage.load_keys).Load(d_keys_in + tile_offset, keys, num_remaining); + else + BlockLoadKeys(temp_storage.load_keys).Load(d_keys_in + tile_offset, keys); + + __syncthreads(); + + // Load values (last tile repeats final element) + if (IS_LAST_TILE) + BlockLoadValues(temp_storage.load_values).Load(d_values_in + tile_offset, values, num_remaining); + else + BlockLoadValues(temp_storage.load_values).Load(d_values_in + tile_offset, values); + + __syncthreads(); + + // Set head segment_flags. First tile sets the first flag for the first item + BlockDiscontinuityKeys(temp_storage.discontinuity).FlagHeads(segment_flags, keys, pred_keys, inequality_op); + + // Unset the flag for the first item in the first tile so we won't scatter it + if (threadIdx.x == 0) + segment_flags[0] = 0; + + // Zip values and segment_flags + ZipValuesAndFlags(num_remaining, values, segment_flags, scan_items); + + // Exclusive scan of values and segment_flags + OffsetValuePairT tile_aggregate; + ScanTile(scan_items, tile_aggregate, Int2Type()); + + if (threadIdx.x == 0) + { + // Update tile status if this is not the last tile + if (!IS_LAST_TILE) + tile_state.SetInclusive(0, tile_aggregate); + + // Initialize the segment index for the first scan item if necessary (the exclusive prefix for the first item is garbage) + if (!HAS_IDENTITY_ZERO) + scan_items[0].key = 0; + } + + // Unzip values and segment indices + ZipKeysAndValues(pred_keys, segment_indices, scan_items, scatter_items); + + // Scatter flagged items + Scatter( + scatter_items, + segment_flags, + segment_indices, + tile_aggregate.key, + 0); + + if (IS_LAST_TILE) + { + // Finalize the carry-out from the last tile + FinalizeLastTile( + tile_aggregate.key, + num_remaining, + keys[ITEMS_PER_THREAD - 1], + tile_aggregate.value); + } + } + + + /** + * Process subsequent tile of input (dynamic chained scan). Returns the running count of segments and aggregated values (including this tile) + */ + template + __device__ __forceinline__ void ConsumeSubsequentTile( + OffsetT num_remaining, ///< Number of global input items remaining (including this tile) + int tile_idx, ///< Tile index + OffsetT tile_offset, ///< Tile offset + ScanTileStateT& tile_state) ///< Global tile state descriptor + { + KeyT keys[ITEMS_PER_THREAD]; // Tile keys + KeyT pred_keys[ITEMS_PER_THREAD]; // Tile keys shifted up (predecessor) + ValueT values[ITEMS_PER_THREAD]; // Tile values + OffsetT segment_flags[ITEMS_PER_THREAD]; // Segment head flags + OffsetT segment_indices[ITEMS_PER_THREAD]; // Segment indices + OffsetValuePairT scan_items[ITEMS_PER_THREAD]; // Zipped values and segment flags|indices + KeyValuePairT scatter_items[ITEMS_PER_THREAD]; // Zipped key value pairs for scattering + + // Load keys (last tile repeats final element) + if (IS_LAST_TILE) + BlockLoadKeys(temp_storage.load_keys).Load(d_keys_in + tile_offset, keys, num_remaining); + else + BlockLoadKeys(temp_storage.load_keys).Load(d_keys_in + tile_offset, keys); + + KeyT tile_pred_key = (threadIdx.x == 0) ? + d_keys_in[tile_offset - 1] : + ZeroInitialize(); + + __syncthreads(); + + // Load values (last tile repeats final element) + if (IS_LAST_TILE) + BlockLoadValues(temp_storage.load_values).Load(d_values_in + tile_offset, values, num_remaining); + else + BlockLoadValues(temp_storage.load_values).Load(d_values_in + tile_offset, values); + + __syncthreads(); + + // Set head segment_flags + BlockDiscontinuityKeys(temp_storage.discontinuity).FlagHeads(segment_flags, keys, pred_keys, inequality_op, tile_pred_key); + + // Zip values and segment_flags + ZipValuesAndFlags(num_remaining, values, segment_flags, scan_items); + + // Exclusive scan of values and segment_flags + OffsetValuePairT tile_aggregate; + TilePrefixCallbackOpT prefix_op(tile_state, temp_storage.prefix, scan_op, tile_idx); + ScanTile(scan_items, tile_aggregate, prefix_op, Int2Type()); + OffsetValuePairT tile_inclusive_prefix = prefix_op.GetInclusivePrefix(); + + // Unzip values and segment indices + ZipKeysAndValues(pred_keys, segment_indices, scan_items, scatter_items); + + // Scatter flagged items + Scatter( + scatter_items, + segment_flags, + segment_indices, + tile_aggregate.key, + prefix_op.GetExclusivePrefix().key); + + if (IS_LAST_TILE) + { + // Finalize the carry-out from the last tile + FinalizeLastTile( + tile_inclusive_prefix.key, + num_remaining, + keys[ITEMS_PER_THREAD - 1], + tile_inclusive_prefix.value); + } + } + + + /** + * Process a tile of input + */ + template < + bool IS_LAST_TILE> + __device__ __forceinline__ void ConsumeTile( + OffsetT num_remaining, ///< Number of global input items remaining (including this tile) + int tile_idx, ///< Tile index + OffsetT tile_offset, ///< Tile offset + ScanTileStateT& tile_state) ///< Global tile state descriptor + { + + if (tile_idx == 0) + { + ConsumeFirstTile(num_remaining, tile_offset, tile_state); + } + else + { + ConsumeSubsequentTile(num_remaining, tile_idx, tile_offset, tile_state); + } + } + + + /** + * Scan tiles of items as part of a dynamic chained scan + */ + __device__ __forceinline__ void ConsumeRange( + int num_items, ///< Total number of input items + int num_tiles, ///< Total number of input tiles + ScanTileStateT& tile_state) ///< Global tile state descriptor + { + // Blocks are launched in increasing order, so just assign one tile per block + int tile_idx = (blockIdx.x * gridDim.y) + blockIdx.y; // Current tile index + OffsetT tile_offset = tile_idx * TILE_ITEMS; // Global offset for the current tile + OffsetT num_remaining = num_items - tile_offset; // Remaining items (including this tile) + + if (num_remaining > TILE_ITEMS) + { + // Not the last tile (full) + ConsumeTile(num_remaining, tile_idx, tile_offset, tile_state); + } + else if (num_remaining > 0) + { + // The last tile (possibly partially-full) + ConsumeTile(num_remaining, tile_idx, tile_offset, tile_state); + } + } + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/agent/agent_rle.cuh b/3rdparty/cub/cub/agent/agent_rle.cuh new file mode 100644 index 00000000000..8285ce0eb11 --- /dev/null +++ b/3rdparty/cub/cub/agent/agent_rle.cuh @@ -0,0 +1,831 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::AgentRle implements a stateful abstraction of CUDA thread blocks for participating in device-wide run-length-encode. + */ + +#pragma once + +#include + +#include "single_pass_scan_operators.cuh" +#include "../block/block_load.cuh" +#include "../block/block_store.cuh" +#include "../block/block_scan.cuh" +#include "../block/block_exchange.cuh" +#include "../block/block_discontinuity.cuh" +#include "../grid/grid_queue.cuh" +#include "../iterator/cache_modified_input_iterator.cuh" +#include "../iterator/constant_input_iterator.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Tuning policy types + ******************************************************************************/ + +/** + * Parameterizable tuning policy type for AgentRle + */ +template < + int _BLOCK_THREADS, ///< Threads per thread block + int _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + BlockLoadAlgorithm _LOAD_ALGORITHM, ///< The BlockLoad algorithm to use + CacheLoadModifier _LOAD_MODIFIER, ///< Cache load modifier for reading input elements + bool _STORE_WARP_TIME_SLICING, ///< Whether or not only one warp's worth of shared memory should be allocated and time-sliced among block-warps during any store-related data transpositions (versus each warp having its own storage) + BlockScanAlgorithm _SCAN_ALGORITHM> ///< The BlockScan algorithm to use +struct AgentRlePolicy +{ + enum + { + BLOCK_THREADS = _BLOCK_THREADS, ///< Threads per thread block + ITEMS_PER_THREAD = _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + STORE_WARP_TIME_SLICING = _STORE_WARP_TIME_SLICING, ///< Whether or not only one warp's worth of shared memory should be allocated and time-sliced among block-warps during any store-related data transpositions (versus each warp having its own storage) + }; + + static const BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM; ///< The BlockLoad algorithm to use + static const CacheLoadModifier LOAD_MODIFIER = _LOAD_MODIFIER; ///< Cache load modifier for reading input elements + static const BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM; ///< The BlockScan algorithm to use +}; + + + + + +/****************************************************************************** + * Thread block abstractions + ******************************************************************************/ + +/** + * \brief AgentRle implements a stateful abstraction of CUDA thread blocks for participating in device-wide run-length-encode + */ +template < + typename AgentRlePolicyT, ///< Parameterized AgentRlePolicyT tuning policy type + typename InputIteratorT, ///< Random-access input iterator type for data + typename OffsetsOutputIteratorT, ///< Random-access output iterator type for offset values + typename LengthsOutputIteratorT, ///< Random-access output iterator type for length values + typename EqualityOpT, ///< T equality operator type + typename OffsetT> ///< Signed integer type for global offsets +struct AgentRle +{ + //--------------------------------------------------------------------- + // Types and constants + //--------------------------------------------------------------------- + + // Data type of input iterator + typedef typename std::iterator_traits::value_type T; + + // Signed integer type for run lengths + typedef typename std::iterator_traits::value_type LengthT; + + // Tuple type for scanning (pairs run-length and run-index) + typedef KeyValuePair LengthOffsetPair; + + // Tile status descriptor interface type + typedef ReduceByKeyScanTileState ScanTileStateT; + + // Constants + enum + { + WARP_THREADS = CUB_WARP_THREADS(PTX_ARCH), + BLOCK_THREADS = AgentRlePolicyT::BLOCK_THREADS, + ITEMS_PER_THREAD = AgentRlePolicyT::ITEMS_PER_THREAD, + WARP_ITEMS = WARP_THREADS * ITEMS_PER_THREAD, + TILE_ITEMS = BLOCK_THREADS * ITEMS_PER_THREAD, + WARPS = (BLOCK_THREADS + WARP_THREADS - 1) / WARP_THREADS, + + /// Whether or not to sync after loading data + SYNC_AFTER_LOAD = (AgentRlePolicyT::LOAD_ALGORITHM != BLOCK_LOAD_DIRECT), + + /// Whether or not only one warp's worth of shared memory should be allocated and time-sliced among block-warps during any store-related data transpositions (versus each warp having its own storage) + STORE_WARP_TIME_SLICING = AgentRlePolicyT::STORE_WARP_TIME_SLICING, + ACTIVE_EXCHANGE_WARPS = (STORE_WARP_TIME_SLICING) ? 1 : WARPS, + }; + + + /** + * Special operator that signals all out-of-bounds items are not equal to everything else, + * forcing both (1) the last item to be tail-flagged and (2) all oob items to be marked + * trivial. + */ + template + struct OobInequalityOp + { + OffsetT num_remaining; + EqualityOpT equality_op; + + __device__ __forceinline__ OobInequalityOp( + OffsetT num_remaining, + EqualityOpT equality_op) + : + num_remaining(num_remaining), + equality_op(equality_op) + {} + + template + __device__ __forceinline__ bool operator()(T first, T second, Index idx) + { + if (!LAST_TILE || (idx < num_remaining)) + return !equality_op(first, second); + else + return true; + } + }; + + + // Cache-modified Input iterator wrapper type (for applying cache modifier) for data + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedVLengthnputIterator + InputIteratorT>::Type // Directly use the supplied input iterator type + WrappedInputIteratorT; + + // Parameterized BlockLoad type for data + typedef BlockLoad< + WrappedInputIteratorT, + AgentRlePolicyT::BLOCK_THREADS, + AgentRlePolicyT::ITEMS_PER_THREAD, + AgentRlePolicyT::LOAD_ALGORITHM> + BlockLoadT; + + // Parameterized BlockDiscontinuity type for data + typedef BlockDiscontinuity BlockDiscontinuityT; + + // Parameterized WarpScan type + typedef WarpScan WarpScanPairs; + + // Reduce-length-by-run scan operator + typedef ReduceBySegmentOp ReduceBySegmentOpT; + + // Callback type for obtaining tile prefix during block scan + typedef TilePrefixCallbackOp< + LengthOffsetPair, + ReduceBySegmentOpT, + ScanTileStateT> + TilePrefixCallbackOpT; + + // Warp exchange types + typedef WarpExchange WarpExchangePairs; + + typedef typename If::Type WarpExchangePairsStorage; + + typedef WarpExchange WarpExchangeOffsets; + typedef WarpExchange WarpExchangeLengths; + + typedef LengthOffsetPair WarpAggregates[WARPS]; + + // Shared memory type for this threadblock + struct _TempStorage + { + union + { + struct + { + typename BlockDiscontinuityT::TempStorage discontinuity; // Smem needed for discontinuity detection + typename WarpScanPairs::TempStorage warp_scan[WARPS]; // Smem needed for warp-synchronous scans + Uninitialized warp_aggregates; // Smem needed for sharing warp-wide aggregates + typename TilePrefixCallbackOpT::TempStorage prefix; // Smem needed for cooperative prefix callback + }; + + // Smem needed for input loading + typename BlockLoadT::TempStorage load; + + // Smem needed for two-phase scatter + union + { + unsigned long long align; + WarpExchangePairsStorage exchange_pairs[ACTIVE_EXCHANGE_WARPS]; + typename WarpExchangeOffsets::TempStorage exchange_offsets[ACTIVE_EXCHANGE_WARPS]; + typename WarpExchangeLengths::TempStorage exchange_lengths[ACTIVE_EXCHANGE_WARPS]; + }; + }; + + OffsetT tile_idx; // Shared tile index + LengthOffsetPair tile_inclusive; // Inclusive tile prefix + LengthOffsetPair tile_exclusive; // Exclusive tile prefix + }; + + // Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Per-thread fields + //--------------------------------------------------------------------- + + _TempStorage& temp_storage; ///< Reference to temp_storage + + WrappedInputIteratorT d_in; ///< Pointer to input sequence of data items + OffsetsOutputIteratorT d_offsets_out; ///< Input run offsets + LengthsOutputIteratorT d_lengths_out; ///< Output run lengths + + EqualityOpT equality_op; ///< T equality operator + ReduceBySegmentOpT scan_op; ///< Reduce-length-by-flag scan operator + OffsetT num_items; ///< Total number of input items + + + //--------------------------------------------------------------------- + // Constructor + //--------------------------------------------------------------------- + + // Constructor + __device__ __forceinline__ + AgentRle( + TempStorage &temp_storage, ///< [in] Reference to temp_storage + InputIteratorT d_in, ///< [in] Pointer to input sequence of data items + OffsetsOutputIteratorT d_offsets_out, ///< [out] Pointer to output sequence of run offsets + LengthsOutputIteratorT d_lengths_out, ///< [out] Pointer to output sequence of run lengths + EqualityOpT equality_op, ///< [in] T equality operator + OffsetT num_items) ///< [in] Total number of input items + : + temp_storage(temp_storage.Alias()), + d_in(d_in), + d_offsets_out(d_offsets_out), + d_lengths_out(d_lengths_out), + equality_op(equality_op), + scan_op(cub::Sum()), + num_items(num_items) + {} + + + //--------------------------------------------------------------------- + // Utility methods for initializing the selections + //--------------------------------------------------------------------- + + template + __device__ __forceinline__ void InitializeSelections( + OffsetT tile_offset, + OffsetT num_remaining, + T (&items)[ITEMS_PER_THREAD], + LengthOffsetPair (&lengths_and_num_runs)[ITEMS_PER_THREAD]) + { + bool head_flags[ITEMS_PER_THREAD]; + bool tail_flags[ITEMS_PER_THREAD]; + + OobInequalityOp inequality_op(num_remaining, equality_op); + + if (FIRST_TILE && LAST_TILE) + { + // First-and-last-tile always head-flags the first item and tail-flags the last item + + BlockDiscontinuityT(temp_storage.discontinuity).FlagHeadsAndTails( + head_flags, tail_flags, items, inequality_op); + } + else if (FIRST_TILE) + { + // First-tile always head-flags the first item + + // Get the first item from the next tile + T tile_successor_item; + if (threadIdx.x == BLOCK_THREADS - 1) + tile_successor_item = d_in[tile_offset + TILE_ITEMS]; + + BlockDiscontinuityT(temp_storage.discontinuity).FlagHeadsAndTails( + head_flags, tail_flags, tile_successor_item, items, inequality_op); + } + else if (LAST_TILE) + { + // Last-tile always flags the last item + + // Get the last item from the previous tile + T tile_predecessor_item; + if (threadIdx.x == 0) + tile_predecessor_item = d_in[tile_offset - 1]; + + BlockDiscontinuityT(temp_storage.discontinuity).FlagHeadsAndTails( + head_flags, tile_predecessor_item, tail_flags, items, inequality_op); + } + else + { + // Get the first item from the next tile + T tile_successor_item; + if (threadIdx.x == BLOCK_THREADS - 1) + tile_successor_item = d_in[tile_offset + TILE_ITEMS]; + + // Get the last item from the previous tile + T tile_predecessor_item; + if (threadIdx.x == 0) + tile_predecessor_item = d_in[tile_offset - 1]; + + BlockDiscontinuityT(temp_storage.discontinuity).FlagHeadsAndTails( + head_flags, tile_predecessor_item, tail_flags, tile_successor_item, items, inequality_op); + } + + // Zip counts and runs + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + lengths_and_num_runs[ITEM].key = head_flags[ITEM] && (!tail_flags[ITEM]); + lengths_and_num_runs[ITEM].value = ((!head_flags[ITEM]) || (!tail_flags[ITEM])); + } + } + + //--------------------------------------------------------------------- + // Scan utility methods + //--------------------------------------------------------------------- + + /** + * Scan of allocations + */ + __device__ __forceinline__ void WarpScanAllocations( + LengthOffsetPair &tile_aggregate, + LengthOffsetPair &warp_aggregate, + LengthOffsetPair &warp_exclusive_in_tile, + LengthOffsetPair &thread_exclusive_in_warp, + LengthOffsetPair (&lengths_and_num_runs)[ITEMS_PER_THREAD]) + { + // Perform warpscans + int warp_id = ((WARPS == 1) ? 0 : threadIdx.x / WARP_THREADS); + int lane_id = LaneId(); + + LengthOffsetPair identity; + identity.key = 0; + identity.value = 0; + + LengthOffsetPair thread_inclusive; + LengthOffsetPair thread_aggregate = ThreadReduce(lengths_and_num_runs, scan_op); + WarpScanPairs(temp_storage.warp_scan[warp_id]).Scan( + thread_aggregate, + thread_inclusive, + thread_exclusive_in_warp, + identity, + scan_op); + + // Last lane in each warp shares its warp-aggregate + if (lane_id == WARP_THREADS - 1) + temp_storage.warp_aggregates.Alias()[warp_id] = thread_inclusive; + + __syncthreads(); + + // Accumulate total selected and the warp-wide prefix + warp_exclusive_in_tile = identity; + warp_aggregate = temp_storage.warp_aggregates.Alias()[warp_id]; + tile_aggregate = temp_storage.warp_aggregates.Alias()[0]; + + #pragma unroll + for (int WARP = 1; WARP < WARPS; ++WARP) + { + if (warp_id == WARP) + warp_exclusive_in_tile = tile_aggregate; + + tile_aggregate = scan_op(tile_aggregate, temp_storage.warp_aggregates.Alias()[WARP]); + } + } + + + //--------------------------------------------------------------------- + // Utility methods for scattering selections + //--------------------------------------------------------------------- + + /** + * Two-phase scatter, specialized for warp time-slicing + */ + template + __device__ __forceinline__ void ScatterTwoPhase( + OffsetT tile_num_runs_exclusive_in_global, + OffsetT warp_num_runs_aggregate, + OffsetT warp_num_runs_exclusive_in_tile, + OffsetT (&thread_num_runs_exclusive_in_warp)[ITEMS_PER_THREAD], + LengthOffsetPair (&lengths_and_offsets)[ITEMS_PER_THREAD], + Int2Type is_warp_time_slice) + { + int warp_id = ((WARPS == 1) ? 0 : threadIdx.x / WARP_THREADS); + int lane_id = LaneId(); + + // Locally compact items within the warp (first warp) + if (warp_id == 0) + { + WarpExchangePairs(temp_storage.exchange_pairs[0]).ScatterToStriped(lengths_and_offsets, thread_num_runs_exclusive_in_warp); + } + + // Locally compact items within the warp (remaining warps) + #pragma unroll + for (int SLICE = 1; SLICE < WARPS; ++SLICE) + { + __syncthreads(); + + if (warp_id == SLICE) + { + WarpExchangePairs(temp_storage.exchange_pairs[0]).ScatterToStriped(lengths_and_offsets, thread_num_runs_exclusive_in_warp); + } + } + + // Global scatter + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + if ((ITEM * WARP_THREADS) < warp_num_runs_aggregate - lane_id) + { + OffsetT item_offset = + tile_num_runs_exclusive_in_global + + warp_num_runs_exclusive_in_tile + + (ITEM * WARP_THREADS) + lane_id; + + // Scatter offset + d_offsets_out[item_offset] = lengths_and_offsets[ITEM].key; + + // Scatter length if not the first (global) length + if ((!FIRST_TILE) || (ITEM != 0) || (threadIdx.x > 0)) + { + d_lengths_out[item_offset - 1] = lengths_and_offsets[ITEM].value; + } + } + } + } + + + /** + * Two-phase scatter + */ + template + __device__ __forceinline__ void ScatterTwoPhase( + OffsetT tile_num_runs_exclusive_in_global, + OffsetT warp_num_runs_aggregate, + OffsetT warp_num_runs_exclusive_in_tile, + OffsetT (&thread_num_runs_exclusive_in_warp)[ITEMS_PER_THREAD], + LengthOffsetPair (&lengths_and_offsets)[ITEMS_PER_THREAD], + Int2Type is_warp_time_slice) + { + int warp_id = ((WARPS == 1) ? 0 : threadIdx.x / WARP_THREADS); + int lane_id = LaneId(); + + // Unzip + OffsetT run_offsets[ITEMS_PER_THREAD]; + LengthT run_lengths[ITEMS_PER_THREAD]; + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + run_offsets[ITEM] = lengths_and_offsets[ITEM].key; + run_lengths[ITEM] = lengths_and_offsets[ITEM].value; + } + + WarpExchangeOffsets(temp_storage.exchange_offsets[warp_id]).ScatterToStriped(run_offsets, thread_num_runs_exclusive_in_warp); + + if (sizeof(LengthT) == sizeof(OffsetT)) + __threadfence_block(); + else + __syncthreads(); + + WarpExchangeLengths(temp_storage.exchange_lengths[warp_id]).ScatterToStriped(run_lengths, thread_num_runs_exclusive_in_warp); + + // Global scatter + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + if ((ITEM * WARP_THREADS) + lane_id < warp_num_runs_aggregate) + { + OffsetT item_offset = + tile_num_runs_exclusive_in_global + + warp_num_runs_exclusive_in_tile + + (ITEM * WARP_THREADS) + lane_id; + + // Scatter offset + d_offsets_out[item_offset] = run_offsets[ITEM]; + + // Scatter length if not the first (global) length + if ((!FIRST_TILE) || (ITEM != 0) || (threadIdx.x > 0)) + { + d_lengths_out[item_offset - 1] = run_lengths[ITEM]; + } + } + } + } + + + /** + * Direct scatter + */ + template + __device__ __forceinline__ void ScatterDirect( + OffsetT tile_num_runs_exclusive_in_global, + OffsetT warp_num_runs_aggregate, + OffsetT warp_num_runs_exclusive_in_tile, + OffsetT (&thread_num_runs_exclusive_in_warp)[ITEMS_PER_THREAD], + LengthOffsetPair (&lengths_and_offsets)[ITEMS_PER_THREAD]) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + if (thread_num_runs_exclusive_in_warp[ITEM] < warp_num_runs_aggregate) + { + OffsetT item_offset = + tile_num_runs_exclusive_in_global + + warp_num_runs_exclusive_in_tile + + thread_num_runs_exclusive_in_warp[ITEM]; + + // Scatter offset + d_offsets_out[item_offset] = lengths_and_offsets[ITEM].key; + + // Scatter length if not the first (global) length + if (item_offset >= 1) + { + d_lengths_out[item_offset - 1] = lengths_and_offsets[ITEM].value; + } + } + } + } + + + /** + * Scatter + */ + template + __device__ __forceinline__ void Scatter( + OffsetT tile_num_runs_aggregate, + OffsetT tile_num_runs_exclusive_in_global, + OffsetT warp_num_runs_aggregate, + OffsetT warp_num_runs_exclusive_in_tile, + OffsetT (&thread_num_runs_exclusive_in_warp)[ITEMS_PER_THREAD], + LengthOffsetPair (&lengths_and_offsets)[ITEMS_PER_THREAD]) + { + if ((ITEMS_PER_THREAD == 1) || (tile_num_runs_aggregate < BLOCK_THREADS)) + { + // Direct scatter if the warp has any items + if (warp_num_runs_aggregate) + { + ScatterDirect( + tile_num_runs_exclusive_in_global, + warp_num_runs_aggregate, + warp_num_runs_exclusive_in_tile, + thread_num_runs_exclusive_in_warp, + lengths_and_offsets); + } + } + else + { + // Scatter two phase + ScatterTwoPhase( + tile_num_runs_exclusive_in_global, + warp_num_runs_aggregate, + warp_num_runs_exclusive_in_tile, + thread_num_runs_exclusive_in_warp, + lengths_and_offsets, + Int2Type()); + } + } + + + + //--------------------------------------------------------------------- + // Cooperatively scan a device-wide sequence of tiles with other CTAs + //--------------------------------------------------------------------- + + /** + * Process a tile of input (dynamic chained scan) + */ + template < + bool LAST_TILE> + __device__ __forceinline__ LengthOffsetPair ConsumeTile( + OffsetT num_items, ///< Total number of global input items + OffsetT num_remaining, ///< Number of global input items remaining (including this tile) + int tile_idx, ///< Tile index + OffsetT tile_offset, ///< Tile offset + ScanTileStateT &tile_status) ///< Global list of tile status + { + if (tile_idx == 0) + { + // First tile + + // Load items + T items[ITEMS_PER_THREAD]; + if (LAST_TILE) + BlockLoadT(temp_storage.load).Load(d_in + tile_offset, items, num_remaining, ZeroInitialize()); + else + BlockLoadT(temp_storage.load).Load(d_in + tile_offset, items); + + if (SYNC_AFTER_LOAD) + __syncthreads(); + + // Set flags + LengthOffsetPair lengths_and_num_runs[ITEMS_PER_THREAD]; + + InitializeSelections( + tile_offset, + num_remaining, + items, + lengths_and_num_runs); + + // Exclusive scan of lengths and runs + LengthOffsetPair tile_aggregate; + LengthOffsetPair warp_aggregate; + LengthOffsetPair warp_exclusive_in_tile; + LengthOffsetPair thread_exclusive_in_warp; + + WarpScanAllocations( + tile_aggregate, + warp_aggregate, + warp_exclusive_in_tile, + thread_exclusive_in_warp, + lengths_and_num_runs); + + // Update tile status if this is not the last tile + if (!LAST_TILE && (threadIdx.x == 0)) + tile_status.SetInclusive(0, tile_aggregate); + + // Update thread_exclusive_in_warp to fold in warp run-length + if (thread_exclusive_in_warp.key == 0) + thread_exclusive_in_warp.value += warp_exclusive_in_tile.value; + + LengthOffsetPair lengths_and_offsets[ITEMS_PER_THREAD]; + OffsetT thread_num_runs_exclusive_in_warp[ITEMS_PER_THREAD]; + LengthOffsetPair lengths_and_num_runs2[ITEMS_PER_THREAD]; + + // Downsweep scan through lengths_and_num_runs + ThreadScanExclusive(lengths_and_num_runs, lengths_and_num_runs2, scan_op, thread_exclusive_in_warp); + + // Zip + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + lengths_and_offsets[ITEM].value = lengths_and_num_runs2[ITEM].value; + lengths_and_offsets[ITEM].key = tile_offset + (threadIdx.x * ITEMS_PER_THREAD) + ITEM; + thread_num_runs_exclusive_in_warp[ITEM] = (lengths_and_num_runs[ITEM].key) ? + lengths_and_num_runs2[ITEM].key : // keep + WARP_THREADS * ITEMS_PER_THREAD; // discard + } + + OffsetT tile_num_runs_aggregate = tile_aggregate.key; + OffsetT tile_num_runs_exclusive_in_global = 0; + OffsetT warp_num_runs_aggregate = warp_aggregate.key; + OffsetT warp_num_runs_exclusive_in_tile = warp_exclusive_in_tile.key; + + // Scatter + Scatter( + tile_num_runs_aggregate, + tile_num_runs_exclusive_in_global, + warp_num_runs_aggregate, + warp_num_runs_exclusive_in_tile, + thread_num_runs_exclusive_in_warp, + lengths_and_offsets); + + // Return running total (inclusive of this tile) + return tile_aggregate; + } + else + { + // Not first tile + + // Load items + T items[ITEMS_PER_THREAD]; + if (LAST_TILE) + BlockLoadT(temp_storage.load).Load(d_in + tile_offset, items, num_remaining, ZeroInitialize()); + else + BlockLoadT(temp_storage.load).Load(d_in + tile_offset, items); + + if (SYNC_AFTER_LOAD) + __syncthreads(); + + // Set flags + LengthOffsetPair lengths_and_num_runs[ITEMS_PER_THREAD]; + + InitializeSelections( + tile_offset, + num_remaining, + items, + lengths_and_num_runs); + + // Exclusive scan of lengths and runs + LengthOffsetPair tile_aggregate; + LengthOffsetPair warp_aggregate; + LengthOffsetPair warp_exclusive_in_tile; + LengthOffsetPair thread_exclusive_in_warp; + + WarpScanAllocations( + tile_aggregate, + warp_aggregate, + warp_exclusive_in_tile, + thread_exclusive_in_warp, + lengths_and_num_runs); + + // First warp computes tile prefix in lane 0 + TilePrefixCallbackOpT prefix_op(tile_status, temp_storage.prefix, Sum(), tile_idx); + int warp_id = ((WARPS == 1) ? 0 : threadIdx.x / WARP_THREADS); + if (warp_id == 0) + { + prefix_op(tile_aggregate); + if (threadIdx.x == 0) + temp_storage.tile_exclusive = prefix_op.exclusive_prefix; + } + + __syncthreads(); + + LengthOffsetPair tile_exclusive_in_global = temp_storage.tile_exclusive; + + // Update thread_exclusive_in_warp to fold in warp and tile run-lengths + LengthOffsetPair thread_exclusive = scan_op(tile_exclusive_in_global, warp_exclusive_in_tile); + if (thread_exclusive_in_warp.key == 0) + thread_exclusive_in_warp.value += thread_exclusive.value; + + // Downsweep scan through lengths_and_num_runs + LengthOffsetPair lengths_and_num_runs2[ITEMS_PER_THREAD]; + LengthOffsetPair lengths_and_offsets[ITEMS_PER_THREAD]; + OffsetT thread_num_runs_exclusive_in_warp[ITEMS_PER_THREAD]; + + ThreadScanExclusive(lengths_and_num_runs, lengths_and_num_runs2, scan_op, thread_exclusive_in_warp); + + // Zip + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + lengths_and_offsets[ITEM].value = lengths_and_num_runs2[ITEM].value; + lengths_and_offsets[ITEM].key = tile_offset + (threadIdx.x * ITEMS_PER_THREAD) + ITEM; + thread_num_runs_exclusive_in_warp[ITEM] = (lengths_and_num_runs[ITEM].key) ? + lengths_and_num_runs2[ITEM].key : // keep + WARP_THREADS * ITEMS_PER_THREAD; // discard + } + + OffsetT tile_num_runs_aggregate = tile_aggregate.key; + OffsetT tile_num_runs_exclusive_in_global = tile_exclusive_in_global.key; + OffsetT warp_num_runs_aggregate = warp_aggregate.key; + OffsetT warp_num_runs_exclusive_in_tile = warp_exclusive_in_tile.key; + + // Scatter + Scatter( + tile_num_runs_aggregate, + tile_num_runs_exclusive_in_global, + warp_num_runs_aggregate, + warp_num_runs_exclusive_in_tile, + thread_num_runs_exclusive_in_warp, + lengths_and_offsets); + + // Return running total (inclusive of this tile) + return prefix_op.inclusive_prefix; + } + } + + + /** + * Scan tiles of items as part of a dynamic chained scan + */ + template ///< Output iterator type for recording number of items selected + __device__ __forceinline__ void ConsumeRange( + int num_tiles, ///< Total number of input tiles + ScanTileStateT& tile_status, ///< Global list of tile status + NumRunsIteratorT d_num_runs_out) ///< Output pointer for total number of runs identified + { + // Blocks are launched in increasing order, so just assign one tile per block + int tile_idx = (blockIdx.x * gridDim.y) + blockIdx.y; // Current tile index + OffsetT tile_offset = tile_idx * TILE_ITEMS; // Global offset for the current tile + OffsetT num_remaining = num_items - tile_offset; // Remaining items (including this tile) + + if (tile_idx < num_tiles - 1) + { + // Not the last tile (full) + ConsumeTile(num_items, num_remaining, tile_idx, tile_offset, tile_status); + } + else if (num_remaining > 0) + { + // The last tile (possibly partially-full) + LengthOffsetPair running_total = ConsumeTile(num_items, num_remaining, tile_idx, tile_offset, tile_status); + + if (threadIdx.x == 0) + { + // Output the total number of items selected + *d_num_runs_out = running_total.key; + + // The inclusive prefix contains accumulated length reduction for the last run + if (running_total.key > 0) + d_lengths_out[running_total.key - 1] = running_total.value; + } + } + } +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/agent/agent_scan.cuh b/3rdparty/cub/cub/agent/agent_scan.cuh new file mode 100644 index 00000000000..60be04611a3 --- /dev/null +++ b/3rdparty/cub/cub/agent/agent_scan.cuh @@ -0,0 +1,498 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::AgentScan implements a stateful abstraction of CUDA thread blocks for participating in device-wide prefix scan . + */ + +#pragma once + +#include + +#include "single_pass_scan_operators.cuh" +#include "../block/block_load.cuh" +#include "../block/block_store.cuh" +#include "../block/block_scan.cuh" +#include "../grid/grid_queue.cuh" +#include "../iterator/cache_modified_input_iterator.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Tuning policy types + ******************************************************************************/ + +/** + * Parameterizable tuning policy type for AgentScan + */ +template < + int _BLOCK_THREADS, ///< Threads per thread block + int _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + BlockLoadAlgorithm _LOAD_ALGORITHM, ///< The BlockLoad algorithm to use + CacheLoadModifier _LOAD_MODIFIER, ///< Cache load modifier for reading input elements + BlockStoreAlgorithm _STORE_ALGORITHM, ///< The BlockStore algorithm to use + BlockScanAlgorithm _SCAN_ALGORITHM> ///< The BlockScan algorithm to use +struct AgentScanPolicy +{ + enum + { + BLOCK_THREADS = _BLOCK_THREADS, ///< Threads per thread block + ITEMS_PER_THREAD = _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + }; + + static const BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM; ///< The BlockLoad algorithm to use + static const CacheLoadModifier LOAD_MODIFIER = _LOAD_MODIFIER; ///< Cache load modifier for reading input elements + static const BlockStoreAlgorithm STORE_ALGORITHM = _STORE_ALGORITHM; ///< The BlockStore algorithm to use + static const BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM; ///< The BlockScan algorithm to use +}; + + + + +/****************************************************************************** + * Thread block abstractions + ******************************************************************************/ + +/** + * \brief AgentScan implements a stateful abstraction of CUDA thread blocks for participating in device-wide prefix scan . + */ +template < + typename AgentScanPolicyT, ///< Parameterized AgentScanPolicyT tuning policy type + typename InputIteratorT, ///< Random-access input iterator type + typename OutputIteratorT, ///< Random-access output iterator type + typename ScanOpT, ///< Scan functor type + typename IdentityT, ///< The identity element for ScanOpT type (cub::NullType for inclusive scan) + typename OffsetT> ///< Signed integer type for global offsets +struct AgentScan +{ + //--------------------------------------------------------------------- + // Types and constants + //--------------------------------------------------------------------- + + // Data type of input iterator + typedef typename std::iterator_traits::value_type T; + + // Tile status descriptor interface type + typedef ScanTileState ScanTileStateT; + + // Input iterator wrapper type (for applying cache modifier) + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedInputIterator + InputIteratorT>::Type // Directly use the supplied input iterator type + WrappedInputIteratorT; + + // Constants + enum + { + INCLUSIVE = Equals::VALUE, // Inclusive scan if no identity type is provided + BLOCK_THREADS = AgentScanPolicyT::BLOCK_THREADS, + ITEMS_PER_THREAD = AgentScanPolicyT::ITEMS_PER_THREAD, + TILE_ITEMS = BLOCK_THREADS * ITEMS_PER_THREAD, + + // Whether or not to sync after loading data + SYNC_AFTER_LOAD = (AgentScanPolicyT::LOAD_ALGORITHM != BLOCK_LOAD_DIRECT), + }; + + // Parameterized BlockLoad type + typedef BlockLoad< + WrappedInputIteratorT, + AgentScanPolicyT::BLOCK_THREADS, + AgentScanPolicyT::ITEMS_PER_THREAD, + AgentScanPolicyT::LOAD_ALGORITHM> + BlockLoadT; + + // Parameterized BlockStore type + typedef BlockStore< + OutputIteratorT, + AgentScanPolicyT::BLOCK_THREADS, + AgentScanPolicyT::ITEMS_PER_THREAD, + AgentScanPolicyT::STORE_ALGORITHM> + BlockStoreT; + + // Parameterized BlockScan type + typedef BlockScan< + T, + AgentScanPolicyT::BLOCK_THREADS, + AgentScanPolicyT::SCAN_ALGORITHM> + BlockScanT; + + // Callback type for obtaining tile prefix during block scan + typedef TilePrefixCallbackOp< + T, + ScanOpT, + ScanTileStateT> + TilePrefixCallbackOpT; + + // Stateful BlockScan prefix callback type for managing a running total while scanning consecutive tiles + typedef BlockScanRunningPrefixOp< + T, + ScanOpT> + RunningPrefixCallbackOp; + + // Shared memory type for this threadblock + union _TempStorage + { + typename BlockLoadT::TempStorage load; // Smem needed for tile loading + typename BlockStoreT::TempStorage store; // Smem needed for tile storing + + struct + { + typename TilePrefixCallbackOpT::TempStorage prefix; // Smem needed for cooperative prefix callback + typename BlockScanT::TempStorage scan; // Smem needed for tile scanning + }; + }; + + // Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Per-thread fields + //--------------------------------------------------------------------- + + _TempStorage& temp_storage; ///< Reference to temp_storage + WrappedInputIteratorT d_in; ///< Input data + OutputIteratorT d_out; ///< Output data + ScanOpT scan_op; ///< Binary scan operator + IdentityT identity; ///< The identity element for ScanOpT + + + + //--------------------------------------------------------------------- + // Block scan utility methods (first tile) + //--------------------------------------------------------------------- + + /** + * Exclusive scan specialization + */ + template + __device__ __forceinline__ + void ScanTile(T (&items)[ITEMS_PER_THREAD], _ScanOp scan_op, _Identity identity, T& block_aggregate) + { + BlockScanT(temp_storage.scan).ExclusiveScan(items, items, identity, scan_op, block_aggregate); + } + + /** + * Exclusive sum specialization + */ + template + __device__ __forceinline__ + void ScanTile(T (&items)[ITEMS_PER_THREAD], Sum scan_op, _Identity identity, T& block_aggregate) + { + BlockScanT(temp_storage.scan).ExclusiveSum(items, items, block_aggregate); + } + + /** + * Inclusive scan specialization + */ + template + __device__ __forceinline__ + void ScanTile(T (&items)[ITEMS_PER_THREAD], _ScanOp scan_op, NullType identity, T& block_aggregate) + { + BlockScanT(temp_storage.scan).InclusiveScan(items, items, scan_op, block_aggregate); + } + + /** + * Inclusive sum specialization + */ + __device__ __forceinline__ + void ScanTile(T (&items)[ITEMS_PER_THREAD], Sum scan_op, NullType identity, T& block_aggregate) + { + BlockScanT(temp_storage.scan).InclusiveSum(items, items, block_aggregate); + } + + //--------------------------------------------------------------------- + // Block scan utility methods (subsequent tiles) + //--------------------------------------------------------------------- + + /** + * Exclusive scan specialization (with prefix from predecessors) + */ + template + __device__ __forceinline__ + void ScanTile(T (&items)[ITEMS_PER_THREAD], _ScanOp scan_op, _Identity identity, T& block_aggregate, PrefixCallback &prefix_op) + { + BlockScanT(temp_storage.scan).ExclusiveScan(items, items, identity, scan_op, block_aggregate, prefix_op); + } + + /** + * Exclusive sum specialization (with prefix from predecessors) + */ + template + __device__ __forceinline__ + void ScanTile(T (&items)[ITEMS_PER_THREAD], Sum scan_op, _Identity identity, T& block_aggregate, PrefixCallback &prefix_op) + { + BlockScanT(temp_storage.scan).ExclusiveSum(items, items, block_aggregate, prefix_op); + } + + /** + * Inclusive scan specialization (with prefix from predecessors) + */ + template + __device__ __forceinline__ + void ScanTile(T (&items)[ITEMS_PER_THREAD], _ScanOp scan_op, NullType identity, T& block_aggregate, PrefixCallback &prefix_op) + { + BlockScanT(temp_storage.scan).InclusiveScan(items, items, scan_op, block_aggregate, prefix_op); + } + + /** + * Inclusive sum specialization (with prefix from predecessors) + */ + template + __device__ __forceinline__ + void ScanTile(T (&items)[ITEMS_PER_THREAD], Sum scan_op, NullType identity, T& block_aggregate, PrefixCallback &prefix_op) + { + BlockScanT(temp_storage.scan).InclusiveSum(items, items, block_aggregate, prefix_op); + } + + + //--------------------------------------------------------------------- + // Constructor + //--------------------------------------------------------------------- + + // Constructor + __device__ __forceinline__ + AgentScan( + TempStorage& temp_storage, ///< Reference to temp_storage + InputIteratorT d_in, ///< Input data + OutputIteratorT d_out, ///< Output data + ScanOpT scan_op, ///< Binary scan operator + IdentityT identity) ///< The identity element for ScanOpT + : + temp_storage(temp_storage.Alias()), + d_in(d_in), + d_out(d_out), + scan_op(scan_op), + identity(identity) + {} + + + //--------------------------------------------------------------------- + // Cooperatively scan a device-wide sequence of tiles with other CTAs + //--------------------------------------------------------------------- + + /** + * Process a tile of input (dynamic chained scan) + */ + template + __device__ __forceinline__ void ConsumeTile( + OffsetT num_items, ///< Total number of input items + OffsetT num_remaining, ///< Total number of items remaining to be processed (including this tile) + int tile_idx, ///< Tile index + OffsetT tile_offset, ///< Tile offset + ScanTileStateT& tile_state) ///< Global tile state descriptor + { + // Load items + T items[ITEMS_PER_THREAD]; + + if (IS_FULL_TILE) + BlockLoadT(temp_storage.load).Load(d_in + tile_offset, items); + else + BlockLoadT(temp_storage.load).Load(d_in + tile_offset, items, num_remaining); + + if (SYNC_AFTER_LOAD) + __syncthreads(); + + // Perform tile scan + if (tile_idx == 0) + { + // Scan first tile + T block_aggregate; + ScanTile(items, scan_op, identity, block_aggregate); + + // Update tile status if there may be successor tiles (i.e., this tile is full) + if (IS_FULL_TILE && (threadIdx.x == 0)) + tile_state.SetInclusive(0, block_aggregate); + } + else + { + // Scan non-first tile + T block_aggregate; + TilePrefixCallbackOpT prefix_op(tile_state, temp_storage.prefix, scan_op, tile_idx); + ScanTile(items, scan_op, identity, block_aggregate, prefix_op); + } + + __syncthreads(); + + // Store items + if (IS_FULL_TILE) + BlockStoreT(temp_storage.store).Store(d_out + tile_offset, items); + else + BlockStoreT(temp_storage.store).Store(d_out + tile_offset, items, num_remaining); + } + + + /** + * Dequeue and scan tiles of items as part of a dynamic chained scan + */ + __device__ __forceinline__ void ConsumeRange( + int num_items, ///< Total number of input items + ScanTileStateT& tile_state) ///< Global tile state descriptor + { + // Blocks are launched in increasing order, so just assign one tile per block + int tile_idx = (blockIdx.x * gridDim.y) + blockIdx.y; // Current tile index + OffsetT tile_offset = OffsetT(TILE_ITEMS) * tile_idx; // Global offset for the current tile + OffsetT num_remaining = num_items - tile_offset; // Remaining items (including this tile) + + if (num_remaining > TILE_ITEMS) + { + // Full tile + ConsumeTile(num_items, num_remaining, tile_idx, tile_offset, tile_state); + } + else if (num_remaining > 0) + { + // Partially-full tile + ConsumeTile(num_items, num_remaining, tile_idx, tile_offset, tile_state); + } + } + + + //--------------------------------------------------------------------- + // Scan an sequence of consecutive tiles (independent of other thread blocks) + //--------------------------------------------------------------------- + + /** + * Process a tile of input + */ + template < + bool IS_FULL_TILE, + bool IS_FIRST_TILE> + __device__ __forceinline__ void ConsumeTile( + OffsetT tile_offset, ///< Tile offset + RunningPrefixCallbackOp& prefix_op, ///< Running prefix operator + int valid_items = TILE_ITEMS) ///< Number of valid items in the tile + { + // Load items + T items[ITEMS_PER_THREAD]; + + if (IS_FULL_TILE) + BlockLoadT(temp_storage.load).Load(d_in + tile_offset, items); + else + BlockLoadT(temp_storage.load).Load(d_in + tile_offset, items, valid_items); + + __syncthreads(); + + // Block scan + if (IS_FIRST_TILE) + { + T block_aggregate; + ScanTile(items, scan_op, identity, block_aggregate); + prefix_op.running_total = block_aggregate; + } + else + { + T block_aggregate; + ScanTile(items, scan_op, identity, block_aggregate, prefix_op); + } + + __syncthreads(); + + // Store items + if (IS_FULL_TILE) + BlockStoreT(temp_storage.store).Store(d_out + tile_offset, items); + else + BlockStoreT(temp_storage.store).Store(d_out + tile_offset, items, valid_items); + } + + + /** + * Scan a consecutive share of input tiles + */ + __device__ __forceinline__ void ConsumeRange( + OffsetT range_offset, ///< [in] Threadblock begin offset (inclusive) + OffsetT range_end) ///< [in] Threadblock end offset (exclusive) + { + BlockScanRunningPrefixOp prefix_op(scan_op); + + if (range_offset + TILE_ITEMS <= range_end) + { + // Consume first tile of input (full) + ConsumeTile(range_offset, prefix_op); + range_offset += TILE_ITEMS; + + // Consume subsequent full tiles of input + while (range_offset + TILE_ITEMS <= range_end) + { + ConsumeTile(range_offset, prefix_op); + range_offset += TILE_ITEMS; + } + + // Consume a partially-full tile + if (range_offset < range_end) + { + int valid_items = range_end - range_offset; + ConsumeTile(range_offset, prefix_op, valid_items); + } + } + else + { + // Consume the first tile of input (partially-full) + int valid_items = range_end - range_offset; + ConsumeTile(range_offset, prefix_op, valid_items); + } + } + + + /** + * Scan a consecutive share of input tiles, seeded with the specified prefix value + */ + __device__ __forceinline__ void ConsumeRange( + OffsetT range_offset, ///< [in] Threadblock begin offset (inclusive) + OffsetT range_end, ///< [in] Threadblock end offset (exclusive) + T prefix) ///< [in] The prefix to apply to the scan segment + { + BlockScanRunningPrefixOp prefix_op(prefix, scan_op); + + // Consume full tiles of input + while (range_offset + TILE_ITEMS <= range_end) + { + ConsumeTile(range_offset, prefix_op); + range_offset += TILE_ITEMS; + } + + // Consume a partially-full tile + if (range_offset < range_end) + { + int valid_items = range_end - range_offset; + ConsumeTile(range_offset, prefix_op, valid_items); + } + } + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/agent/agent_segment_fixup.cuh b/3rdparty/cub/cub/agent/agent_segment_fixup.cuh new file mode 100644 index 00000000000..a3e0c7b2767 --- /dev/null +++ b/3rdparty/cub/cub/agent/agent_segment_fixup.cuh @@ -0,0 +1,374 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::AgentSegmentFixup implements a stateful abstraction of CUDA thread blocks for participating in device-wide reduce-value-by-key. + */ + +#pragma once + +#include + +#include "single_pass_scan_operators.cuh" +#include "../block/block_load.cuh" +#include "../block/block_store.cuh" +#include "../block/block_scan.cuh" +#include "../block/block_discontinuity.cuh" +#include "../iterator/cache_modified_input_iterator.cuh" +#include "../iterator/constant_input_iterator.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Tuning policy types + ******************************************************************************/ + +/** + * Parameterizable tuning policy type for AgentSegmentFixup + */ +template < + int _BLOCK_THREADS, ///< Threads per thread block + int _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + BlockLoadAlgorithm _LOAD_ALGORITHM, ///< The BlockLoad algorithm to use + CacheLoadModifier _LOAD_MODIFIER, ///< Cache load modifier for reading input elements + BlockScanAlgorithm _SCAN_ALGORITHM> ///< The BlockScan algorithm to use +struct AgentSegmentFixupPolicy +{ + enum + { + BLOCK_THREADS = _BLOCK_THREADS, ///< Threads per thread block + ITEMS_PER_THREAD = _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + }; + + static const BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM; ///< The BlockLoad algorithm to use + static const CacheLoadModifier LOAD_MODIFIER = _LOAD_MODIFIER; ///< Cache load modifier for reading input elements + static const BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM; ///< The BlockScan algorithm to use +}; + + +/****************************************************************************** + * Thread block abstractions + ******************************************************************************/ + +/** + * \brief AgentSegmentFixup implements a stateful abstraction of CUDA thread blocks for participating in device-wide reduce-value-by-key + */ +template < + typename AgentSegmentFixupPolicyT, ///< Parameterized AgentSegmentFixupPolicy tuning policy type + typename PairsInputIteratorT, ///< Random-access input iterator type for keys + typename AggregatesOutputIteratorT, ///< Random-access output iterator type for values + typename EqualityOpT, ///< KeyT equality operator type + typename ReductionOpT, ///< ValueT reduction operator type + typename OffsetT> ///< Signed integer type for global offsets +struct AgentSegmentFixup +{ + //--------------------------------------------------------------------- + // Types and constants + //--------------------------------------------------------------------- + + // Data type of key-value input iterator + typedef typename std::iterator_traits::value_type KeyValuePairT; + + // Value type + typedef typename KeyValuePairT::Value ValueT; + + // Tile status descriptor interface type + typedef ReduceByKeyScanTileState ScanTileStateT; + + // Constants + enum + { + BLOCK_THREADS = AgentSegmentFixupPolicyT::BLOCK_THREADS, + ITEMS_PER_THREAD = AgentSegmentFixupPolicyT::ITEMS_PER_THREAD, + TILE_ITEMS = BLOCK_THREADS * ITEMS_PER_THREAD, + + // Whether or not do fixup using RLE + global atomics + USE_ATOMIC_FIXUP = (CUB_PTX_ARCH >= 350) && + (Equals::VALUE || + Equals::VALUE || + Equals::VALUE || + Equals::VALUE), + + // Whether or not the scan operation has a zero-valued identity value (true if we're performing addition on a primitive type) + HAS_IDENTITY_ZERO = (Equals::VALUE) && (Traits::PRIMITIVE), + }; + + // Cache-modified Input iterator wrapper type (for applying cache modifier) for keys + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedValuesInputIterator + PairsInputIteratorT>::Type // Directly use the supplied input iterator type + WrappedPairsInputIteratorT; + + // Cache-modified Input iterator wrapper type (for applying cache modifier) for fixup values + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedValuesInputIterator + AggregatesOutputIteratorT>::Type // Directly use the supplied input iterator type + WrappedFixupInputIteratorT; + + // Reduce-value-by-segment scan operator + typedef ReduceByKeyOp ReduceBySegmentOpT; + + // Parameterized BlockLoad type for pairs + typedef BlockLoad< + WrappedPairsInputIteratorT, + BLOCK_THREADS, + ITEMS_PER_THREAD, + AgentSegmentFixupPolicyT::LOAD_ALGORITHM> + BlockLoadPairs; + + // Parameterized BlockScan type + typedef BlockScan< + KeyValuePairT, + BLOCK_THREADS, + AgentSegmentFixupPolicyT::SCAN_ALGORITHM> + BlockScanT; + + // Callback type for obtaining tile prefix during block scan + typedef TilePrefixCallbackOp< + KeyValuePairT, + ReduceBySegmentOpT, + ScanTileStateT> + TilePrefixCallbackOpT; + + // Shared memory type for this threadblock + union _TempStorage + { + struct + { + typename BlockScanT::TempStorage scan; // Smem needed for tile scanning + typename TilePrefixCallbackOpT::TempStorage prefix; // Smem needed for cooperative prefix callback + }; + + // Smem needed for loading keys + typename BlockLoadPairs::TempStorage load_pairs; + }; + + // Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Per-thread fields + //--------------------------------------------------------------------- + + _TempStorage& temp_storage; ///< Reference to temp_storage + WrappedPairsInputIteratorT d_pairs_in; ///< Input keys + AggregatesOutputIteratorT d_aggregates_out; ///< Output value aggregates + WrappedFixupInputIteratorT d_fixup_in; ///< Fixup input values + InequalityWrapper inequality_op; ///< KeyT inequality operator + ReductionOpT reduction_op; ///< Reduction operator + ReduceBySegmentOpT scan_op; ///< Reduce-by-segment scan operator + + + //--------------------------------------------------------------------- + // Constructor + //--------------------------------------------------------------------- + + // Constructor + __device__ __forceinline__ + AgentSegmentFixup( + TempStorage& temp_storage, ///< Reference to temp_storage + PairsInputIteratorT d_pairs_in, ///< Input keys + AggregatesOutputIteratorT d_aggregates_out, ///< Output value aggregates + EqualityOpT equality_op, ///< KeyT equality operator + ReductionOpT reduction_op) ///< ValueT reduction operator + : + temp_storage(temp_storage.Alias()), + d_pairs_in(d_pairs_in), + d_aggregates_out(d_aggregates_out), + d_fixup_in(d_aggregates_out), + inequality_op(equality_op), + reduction_op(reduction_op), + scan_op(reduction_op) + {} + + + //--------------------------------------------------------------------- + // Cooperatively scan a device-wide sequence of tiles with other CTAs + //--------------------------------------------------------------------- + + + /** + * Process input tile. Specialized for atomic-fixup + */ + template + __device__ __forceinline__ void ConsumeTile( + OffsetT num_remaining, ///< Number of global input items remaining (including this tile) + int tile_idx, ///< Tile index + OffsetT tile_offset, ///< Tile offset + ScanTileStateT& tile_state, ///< Global tile state descriptor + Int2Type use_atomic_fixup) ///< Marker whether to use atomicAdd (instead of reduce-by-key) + { + KeyValuePairT pairs[ITEMS_PER_THREAD]; + + // Load pairs + KeyValuePairT oob_pair; + oob_pair.key = -1; + + if (IS_LAST_TILE) + BlockLoadPairs(temp_storage.load_pairs).Load(d_pairs_in + tile_offset, pairs, num_remaining, oob_pair); + else + BlockLoadPairs(temp_storage.load_pairs).Load(d_pairs_in + tile_offset, pairs); + + // RLE + #pragma unroll + for (int ITEM = 1; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + ValueT* d_scatter = d_aggregates_out + pairs[ITEM - 1].key; + if (pairs[ITEM].key != pairs[ITEM - 1].key) + atomicAdd(d_scatter, pairs[ITEM - 1].value); + else + pairs[ITEM].value = reduction_op(pairs[ITEM - 1].value, pairs[ITEM].value); + } + + // Flush last item if valid + ValueT* d_scatter = d_aggregates_out + pairs[ITEMS_PER_THREAD - 1].key; + if ((!IS_LAST_TILE) || (pairs[ITEMS_PER_THREAD - 1].key >= 0)) + atomicAdd(d_scatter, pairs[ITEMS_PER_THREAD - 1].value); + } + + + /** + * Process input tile. Specialized for reduce-by-key fixup + */ + template + __device__ __forceinline__ void ConsumeTile( + OffsetT num_remaining, ///< Number of global input items remaining (including this tile) + int tile_idx, ///< Tile index + OffsetT tile_offset, ///< Tile offset + ScanTileStateT& tile_state, ///< Global tile state descriptor + Int2Type use_atomic_fixup) ///< Marker whether to use atomicAdd (instead of reduce-by-key) + { + KeyValuePairT pairs[ITEMS_PER_THREAD]; + KeyValuePairT scatter_pairs[ITEMS_PER_THREAD]; + + // Load pairs + KeyValuePairT oob_pair; + oob_pair.key = -1; + + if (IS_LAST_TILE) + BlockLoadPairs(temp_storage.load_pairs).Load(d_pairs_in + tile_offset, pairs, num_remaining, oob_pair); + else + BlockLoadPairs(temp_storage.load_pairs).Load(d_pairs_in + tile_offset, pairs); + + __syncthreads(); + + KeyValuePairT tile_aggregate; + if (tile_idx == 0) + { + // Exclusive scan of values and segment_flags + BlockScanT(temp_storage.scan).ExclusiveScan(pairs, scatter_pairs, scan_op, tile_aggregate); + + // Update tile status if this is not the last tile + if (threadIdx.x == 0) + { + // Set first segment id to not trigger a flush (invalid from exclusive scan) + scatter_pairs[0].key = pairs[0].key; + + if (!IS_LAST_TILE) + tile_state.SetInclusive(0, tile_aggregate); + + } + } + else + { + // Exclusive scan of values and segment_flags + TilePrefixCallbackOpT prefix_op(tile_state, temp_storage.prefix, scan_op, tile_idx); + BlockScanT(temp_storage.scan).ExclusiveScan(pairs, scatter_pairs, scan_op, tile_aggregate, prefix_op); + } + + // Scatter updated values + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + if (scatter_pairs[ITEM].key != pairs[ITEM].key) + { + // Update the value at the key location + ValueT value = d_fixup_in[scatter_pairs[ITEM].key]; + value = reduction_op(value, scatter_pairs[ITEM].value); + + d_aggregates_out[scatter_pairs[ITEM].key] = value; + } + } + + // Finalize the last item + if (IS_LAST_TILE) + { + // Last thread will output final count and last item, if necessary + if (threadIdx.x == BLOCK_THREADS - 1) + { + // If the last tile is a whole tile, the inclusive prefix contains accumulated value reduction for the last segment + if (num_remaining == TILE_ITEMS) + { + // Update the value at the key location + OffsetT last_key = pairs[ITEMS_PER_THREAD - 1].key; + d_aggregates_out[last_key] = reduction_op(tile_aggregate.value, d_fixup_in[last_key]); + } + } + } + } + + + /** + * Scan tiles of items as part of a dynamic chained scan + */ + __device__ __forceinline__ void ConsumeRange( + int num_items, ///< Total number of input items + int num_tiles, ///< Total number of input tiles + ScanTileStateT& tile_state) ///< Global tile state descriptor + { + // Blocks are launched in increasing order, so just assign one tile per block + int tile_idx = (blockIdx.x * gridDim.y) + blockIdx.y; // Current tile index + OffsetT tile_offset = tile_idx * TILE_ITEMS; // Global offset for the current tile + OffsetT num_remaining = num_items - tile_offset; // Remaining items (including this tile) + + if (num_remaining > TILE_ITEMS) + { + // Not the last tile (full) + ConsumeTile(num_remaining, tile_idx, tile_offset, tile_state, Int2Type()); + } + else if (num_remaining > 0) + { + // The last tile (possibly partially-full) + ConsumeTile(num_remaining, tile_idx, tile_offset, tile_state, Int2Type()); + } + } + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/agent/agent_select_if.cuh b/3rdparty/cub/cub/agent/agent_select_if.cuh new file mode 100644 index 00000000000..3e6033938e3 --- /dev/null +++ b/3rdparty/cub/cub/agent/agent_select_if.cuh @@ -0,0 +1,698 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::AgentSelectIf implements a stateful abstraction of CUDA thread blocks for participating in device-wide select. + */ + +#pragma once + +#include + +#include "single_pass_scan_operators.cuh" +#include "../block/block_load.cuh" +#include "../block/block_store.cuh" +#include "../block/block_scan.cuh" +#include "../block/block_exchange.cuh" +#include "../block/block_discontinuity.cuh" +#include "../grid/grid_queue.cuh" +#include "../iterator/cache_modified_input_iterator.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Tuning policy types + ******************************************************************************/ + +/** + * Parameterizable tuning policy type for AgentSelectIf + */ +template < + int _BLOCK_THREADS, ///< Threads per thread block + int _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + BlockLoadAlgorithm _LOAD_ALGORITHM, ///< The BlockLoad algorithm to use + CacheLoadModifier _LOAD_MODIFIER, ///< Cache load modifier for reading input elements + BlockScanAlgorithm _SCAN_ALGORITHM> ///< The BlockScan algorithm to use +struct AgentSelectIfPolicy +{ + enum + { + BLOCK_THREADS = _BLOCK_THREADS, ///< Threads per thread block + ITEMS_PER_THREAD = _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + }; + + static const BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM; ///< The BlockLoad algorithm to use + static const CacheLoadModifier LOAD_MODIFIER = _LOAD_MODIFIER; ///< Cache load modifier for reading input elements + static const BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM; ///< The BlockScan algorithm to use +}; + + + + +/****************************************************************************** + * Thread block abstractions + ******************************************************************************/ + + +/** + * \brief AgentSelectIf implements a stateful abstraction of CUDA thread blocks for participating in device-wide selection + * + * Performs functor-based selection if SelectOpT functor type != NullType + * Otherwise performs flag-based selection if FlagsInputIterator's value type != NullType + * Otherwise performs discontinuity selection (keep unique) + */ +template < + typename AgentSelectIfPolicyT, ///< Parameterized AgentSelectIfPolicy tuning policy type + typename InputIteratorT, ///< Random-access input iterator type for selection items + typename FlagsInputIteratorT, ///< Random-access input iterator type for selections (NullType* if a selection functor or discontinuity flagging is to be used for selection) + typename SelectedOutputIteratorT, ///< Random-access input iterator type for selection_flags items + typename SelectOpT, ///< Selection operator type (NullType if selections or discontinuity flagging is to be used for selection) + typename EqualityOpT, ///< Equality operator type (NullType if selection functor or selections is to be used for selection) + typename OffsetT, ///< Signed integer type for global offsets + bool KEEP_REJECTS> ///< Whether or not we push rejected items to the back of the output +struct AgentSelectIf +{ + //--------------------------------------------------------------------- + // Types and constants + //--------------------------------------------------------------------- + + // Data type of input iterator + typedef typename std::iterator_traits::value_type T; + + // Data type of flag iterator + typedef typename std::iterator_traits::value_type FlagT; + + // Tile status descriptor interface type + typedef ScanTileState ScanTileStateT; + + // Constants + enum + { + USE_SELECT_OP, + USE_SELECT_FLAGS, + USE_DISCONTINUITY, + + BLOCK_THREADS = AgentSelectIfPolicyT::BLOCK_THREADS, + ITEMS_PER_THREAD = AgentSelectIfPolicyT::ITEMS_PER_THREAD, + TILE_ITEMS = BLOCK_THREADS * ITEMS_PER_THREAD, + TWO_PHASE_SCATTER = (ITEMS_PER_THREAD > 1), + + SELECT_METHOD = (!Equals::VALUE) ? + USE_SELECT_OP : + (!Equals::VALUE) ? + USE_SELECT_FLAGS : + USE_DISCONTINUITY + }; + + // Cache-modified Input iterator wrapper type (for applying cache modifier) for items + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedValuesInputIterator + InputIteratorT>::Type // Directly use the supplied input iterator type + WrappedInputIteratorT; + + // Cache-modified Input iterator wrapper type (for applying cache modifier) for values + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedValuesInputIterator + FlagsInputIteratorT>::Type // Directly use the supplied input iterator type + WrappedFlagsInputIteratorT; + + // Parameterized BlockLoad type for input data + typedef BlockLoad< + WrappedInputIteratorT, + BLOCK_THREADS, + ITEMS_PER_THREAD, + AgentSelectIfPolicyT::LOAD_ALGORITHM> + BlockLoadT; + + // Parameterized BlockLoad type for flags + typedef BlockLoad< + WrappedFlagsInputIteratorT, + BLOCK_THREADS, + ITEMS_PER_THREAD, + AgentSelectIfPolicyT::LOAD_ALGORITHM> + BlockLoadFlags; + + // Parameterized BlockDiscontinuity type for items + typedef BlockDiscontinuity< + T, + BLOCK_THREADS> + BlockDiscontinuityT; + + // Parameterized BlockScan type + typedef BlockScan< + OffsetT, + BLOCK_THREADS, + AgentSelectIfPolicyT::SCAN_ALGORITHM> + BlockScanT; + + // Callback type for obtaining tile prefix during block scan + typedef TilePrefixCallbackOp< + OffsetT, + cub::Sum, + ScanTileStateT> + TilePrefixCallbackOpT; + + // Item exchange type + typedef T ItemExchangeT[TILE_ITEMS]; + + // Shared memory type for this threadblock + union _TempStorage + { + struct + { + typename BlockScanT::TempStorage scan; // Smem needed for tile scanning + typename TilePrefixCallbackOpT::TempStorage prefix; // Smem needed for cooperative prefix callback + typename BlockDiscontinuityT::TempStorage discontinuity; // Smem needed for discontinuity detection + }; + + // Smem needed for loading items + typename BlockLoadT::TempStorage load_items; + + // Smem needed for loading values + typename BlockLoadFlags::TempStorage load_flags; + + // Smem needed for compacting items (allows non POD items in this union) + Uninitialized raw_exchange; + }; + + // Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Per-thread fields + //--------------------------------------------------------------------- + + _TempStorage& temp_storage; ///< Reference to temp_storage + WrappedInputIteratorT d_in; ///< Input items + SelectedOutputIteratorT d_selected_out; ///< Unique output items + WrappedFlagsInputIteratorT d_flags_in; ///< Input selection flags (if applicable) + InequalityWrapper inequality_op; ///< T inequality operator + SelectOpT select_op; ///< Selection operator + OffsetT num_items; ///< Total number of input items + + + //--------------------------------------------------------------------- + // Constructor + //--------------------------------------------------------------------- + + // Constructor + __device__ __forceinline__ + AgentSelectIf( + TempStorage &temp_storage, ///< Reference to temp_storage + InputIteratorT d_in, ///< Input data + FlagsInputIteratorT d_flags_in, ///< Input selection flags (if applicable) + SelectedOutputIteratorT d_selected_out, ///< Output data + SelectOpT select_op, ///< Selection operator + EqualityOpT equality_op, ///< Equality operator + OffsetT num_items) ///< Total number of input items + : + temp_storage(temp_storage.Alias()), + d_in(d_in), + d_flags_in(d_flags_in), + d_selected_out(d_selected_out), + select_op(select_op), + inequality_op(equality_op), + num_items(num_items) + {} + + + //--------------------------------------------------------------------- + // Utility methods for initializing the selections + //--------------------------------------------------------------------- + + /** + * Initialize selections (specialized for selection operator) + */ + template + __device__ __forceinline__ void InitializeSelections( + OffsetT tile_offset, + OffsetT num_tile_items, + T (&items)[ITEMS_PER_THREAD], + OffsetT (&selection_flags)[ITEMS_PER_THREAD], + Int2Type select_method) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + // Out-of-bounds items are selection_flags + selection_flags[ITEM] = 1; + + if (!IS_LAST_TILE || (OffsetT(threadIdx.x * ITEMS_PER_THREAD) + ITEM < num_tile_items)) + selection_flags[ITEM] = select_op(items[ITEM]); + } + } + + + /** + * Initialize selections (specialized for valid flags) + */ + template + __device__ __forceinline__ void InitializeSelections( + OffsetT tile_offset, + OffsetT num_tile_items, + T (&items)[ITEMS_PER_THREAD], + OffsetT (&selection_flags)[ITEMS_PER_THREAD], + Int2Type select_method) + { + __syncthreads(); + + FlagT flags[ITEMS_PER_THREAD]; + + if (IS_LAST_TILE) + { + // Out-of-bounds items are selection_flags + BlockLoadFlags(temp_storage.load_flags).Load(d_flags_in + tile_offset, flags, num_tile_items, 1); + } + else + { + BlockLoadFlags(temp_storage.load_flags).Load(d_flags_in + tile_offset, flags); + } + + // Convert flag type to selection_flags type + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + selection_flags[ITEM] = flags[ITEM]; + } + } + + + /** + * Initialize selections (specialized for discontinuity detection) + */ + template + __device__ __forceinline__ void InitializeSelections( + OffsetT tile_offset, + OffsetT num_tile_items, + T (&items)[ITEMS_PER_THREAD], + OffsetT (&selection_flags)[ITEMS_PER_THREAD], + Int2Type select_method) + { + if (IS_FIRST_TILE) + { + __syncthreads(); + + // Set head selection_flags. First tile sets the first flag for the first item + BlockDiscontinuityT(temp_storage.discontinuity).FlagHeads(selection_flags, items, inequality_op); + } + else + { + T tile_predecessor; + if (threadIdx.x == 0) + tile_predecessor = d_in[tile_offset - 1]; + + __syncthreads(); + + BlockDiscontinuityT(temp_storage.discontinuity).FlagHeads(selection_flags, items, inequality_op, tile_predecessor); + } + + // Set selection flags for out-of-bounds items + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + // Set selection_flags for out-of-bounds items + if ((IS_LAST_TILE) && (OffsetT(threadIdx.x * ITEMS_PER_THREAD) + ITEM >= num_tile_items)) + selection_flags[ITEM] = 1; + } + } + + + //--------------------------------------------------------------------- + // Scatter utility methods + //--------------------------------------------------------------------- + + /** + * Scatter flagged items to output offsets (specialized for direct scattering) + */ + template + __device__ __forceinline__ void ScatterDirect( + T (&items)[ITEMS_PER_THREAD], + OffsetT (&selection_flags)[ITEMS_PER_THREAD], + OffsetT (&selection_indices)[ITEMS_PER_THREAD], + OffsetT num_selections) + { + // Scatter flagged items + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + if (selection_flags[ITEM]) + { + if ((!IS_LAST_TILE) || selection_indices[ITEM] < num_selections) + { + d_selected_out[selection_indices[ITEM]] = items[ITEM]; + } + } + } + } + + + /** + * Scatter flagged items to output offsets (specialized for two-phase scattering) + */ + template + __device__ __forceinline__ void ScatterTwoPhase( + T (&items)[ITEMS_PER_THREAD], + OffsetT (&selection_flags)[ITEMS_PER_THREAD], + OffsetT (&selection_indices)[ITEMS_PER_THREAD], + int num_tile_items, ///< Number of valid items in this tile + int num_tile_selections, ///< Number of selections in this tile + OffsetT num_selections_prefix, ///< Total number of selections prior to this tile + OffsetT num_rejected_prefix, ///< Total number of rejections prior to this tile + Int2Type is_keep_rejects) ///< Marker type indicating whether to keep rejected items in the second partition + { + __syncthreads(); + + // Compact and scatter items + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + int local_scatter_offset = selection_indices[ITEM] - num_selections_prefix; + if (selection_flags[ITEM]) + { + temp_storage.raw_exchange.Alias()[local_scatter_offset] = items[ITEM]; + } + } + + __syncthreads(); + + for (int item = threadIdx.x; item < num_tile_selections; item += BLOCK_THREADS) + { + d_selected_out[num_selections_prefix + item] = temp_storage.raw_exchange.Alias()[item]; + } + } + + + /** + * Scatter flagged items to output offsets (specialized for two-phase scattering) + */ + template + __device__ __forceinline__ void ScatterTwoPhase( + T (&items)[ITEMS_PER_THREAD], + OffsetT (&selection_flags)[ITEMS_PER_THREAD], + OffsetT (&selection_indices)[ITEMS_PER_THREAD], + int num_tile_items, ///< Number of valid items in this tile + int num_tile_selections, ///< Number of selections in this tile + OffsetT num_selections_prefix, ///< Total number of selections prior to this tile + OffsetT num_rejected_prefix, ///< Total number of rejections prior to this tile + Int2Type is_keep_rejects) ///< Marker type indicating whether to keep rejected items in the second partition + { + __syncthreads(); + + int tile_num_rejections = num_tile_items - num_tile_selections; + + // Scatter items to shared memory (rejections first) + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + int item_idx = (threadIdx.x * ITEMS_PER_THREAD) + ITEM; + int local_selection_idx = selection_indices[ITEM] - num_selections_prefix; + int local_rejection_idx = item_idx - local_selection_idx; + int local_scatter_offset = (selection_flags[ITEM]) ? + tile_num_rejections + local_selection_idx : + local_rejection_idx; + + temp_storage.raw_exchange.Alias()[local_scatter_offset] = items[ITEM]; + } + + __syncthreads(); + + // Gather items from shared memory and scatter to global + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + int item_idx = (ITEM * BLOCK_THREADS) + threadIdx.x; + int rejection_idx = item_idx; + int selection_idx = item_idx - tile_num_rejections; + OffsetT scatter_offset = (item_idx < tile_num_rejections) ? + num_items - num_rejected_prefix - rejection_idx - 1 : + num_selections_prefix + selection_idx; + + T item = temp_storage.raw_exchange.Alias()[item_idx]; + + if (!IS_LAST_TILE || (item_idx < num_tile_items)) + { + d_selected_out[scatter_offset] = item; + } + } + } + + + /** + * Scatter flagged items + */ + template + __device__ __forceinline__ void Scatter( + T (&items)[ITEMS_PER_THREAD], + OffsetT (&selection_flags)[ITEMS_PER_THREAD], + OffsetT (&selection_indices)[ITEMS_PER_THREAD], + int num_tile_items, ///< Number of valid items in this tile + int num_tile_selections, ///< Number of selections in this tile + OffsetT num_selections_prefix, ///< Total number of selections prior to this tile + OffsetT num_rejected_prefix, ///< Total number of rejections prior to this tile + OffsetT num_selections) ///< Total number of selections including this tile + { + // Do a two-phase scatter if (a) keeping both partitions or (b) two-phase is enabled and the average number of selection_flags items per thread is greater than one + if (KEEP_REJECTS || (TWO_PHASE_SCATTER && (num_tile_selections > BLOCK_THREADS))) + { + ScatterTwoPhase( + items, + selection_flags, + selection_indices, + num_tile_items, + num_tile_selections, + num_selections_prefix, + num_rejected_prefix, + Int2Type()); + } + else + { + ScatterDirect( + items, + selection_flags, + selection_indices, + num_selections); + } + } + + //--------------------------------------------------------------------- + // Cooperatively scan a device-wide sequence of tiles with other CTAs + //--------------------------------------------------------------------- + + + /** + * Process first tile of input (dynamic chained scan). Returns the running count of selections (including this tile) + */ + template + __device__ __forceinline__ OffsetT ConsumeFirstTile( + int num_tile_items, ///< Number of input items comprising this tile + OffsetT tile_offset, ///< Tile offset + ScanTileStateT& tile_state) ///< Global tile state descriptor + { + T items[ITEMS_PER_THREAD]; + OffsetT selection_flags[ITEMS_PER_THREAD]; + OffsetT selection_indices[ITEMS_PER_THREAD]; + + // Load items + if (IS_LAST_TILE) + BlockLoadT(temp_storage.load_items).Load(d_in + tile_offset, items, num_tile_items); + else + BlockLoadT(temp_storage.load_items).Load(d_in + tile_offset, items); + + // Initialize selection_flags + InitializeSelections( + tile_offset, + num_tile_items, + items, + selection_flags, + Int2Type()); + + __syncthreads(); + + // Exclusive scan of selection_flags + OffsetT num_tile_selections; + BlockScanT(temp_storage.scan).ExclusiveSum(selection_flags, selection_indices, num_tile_selections); + + if (threadIdx.x == 0) + { + // Update tile status if this is not the last tile + if (!IS_LAST_TILE) + tile_state.SetInclusive(0, num_tile_selections); + } + + // Discount any out-of-bounds selections + if (IS_LAST_TILE) + num_tile_selections -= (TILE_ITEMS - num_tile_items); + + // Scatter flagged items + Scatter( + items, + selection_flags, + selection_indices, + num_tile_items, + num_tile_selections, + 0, + 0, + num_tile_selections); + + return num_tile_selections; + } + + + /** + * Process subsequent tile of input (dynamic chained scan). Returns the running count of selections (including this tile) + */ + template + __device__ __forceinline__ OffsetT ConsumeSubsequentTile( + int num_tile_items, ///< Number of input items comprising this tile + int tile_idx, ///< Tile index + OffsetT tile_offset, ///< Tile offset + ScanTileStateT& tile_state) ///< Global tile state descriptor + { + T items[ITEMS_PER_THREAD]; + OffsetT selection_flags[ITEMS_PER_THREAD]; + OffsetT selection_indices[ITEMS_PER_THREAD]; + + // Load items + if (IS_LAST_TILE) + BlockLoadT(temp_storage.load_items).Load(d_in + tile_offset, items, num_tile_items); + else + BlockLoadT(temp_storage.load_items).Load(d_in + tile_offset, items); + + // Initialize selection_flags + InitializeSelections( + tile_offset, + num_tile_items, + items, + selection_flags, + Int2Type()); + + __syncthreads(); + + // Exclusive scan of values and selection_flags + OffsetT num_tile_selections; + TilePrefixCallbackOpT prefix_op(tile_state, temp_storage.prefix, cub::Sum(), tile_idx); + BlockScanT(temp_storage.scan).ExclusiveSum(selection_flags, selection_indices, num_tile_selections, prefix_op); + + OffsetT num_selections = prefix_op.GetInclusivePrefix(); + OffsetT num_selections_prefix = prefix_op.GetExclusivePrefix(); + OffsetT num_rejected_prefix = (tile_idx * TILE_ITEMS) - num_selections_prefix; + + // Discount any out-of-bounds selections + if (IS_LAST_TILE) + { + int num_discount = TILE_ITEMS - num_tile_items; + num_selections -= num_discount; + num_tile_selections -= num_discount; + } + + // Scatter flagged items + Scatter( + items, + selection_flags, + selection_indices, + num_tile_items, + num_tile_selections, + num_selections_prefix, + num_rejected_prefix, + num_selections); + + return num_selections; + } + + + /** + * Process a tile of input + */ + template + __device__ __forceinline__ OffsetT ConsumeTile( + int num_tile_items, ///< Number of input items comprising this tile + int tile_idx, ///< Tile index + OffsetT tile_offset, ///< Tile offset + ScanTileStateT& tile_state) ///< Global tile state descriptor + { + OffsetT num_selections; + if (tile_idx == 0) + { + num_selections = ConsumeFirstTile(num_tile_items, tile_offset, tile_state); + } + else + { + num_selections = ConsumeSubsequentTile(num_tile_items, tile_idx, tile_offset, tile_state); + } + + return num_selections; + } + + + /** + * Scan tiles of items as part of a dynamic chained scan + */ + template ///< Output iterator type for recording number of items selection_flags + __device__ __forceinline__ void ConsumeRange( + int num_tiles, ///< Total number of input tiles + ScanTileStateT& tile_state, ///< Global tile state descriptor + NumSelectedIteratorT d_num_selected_out) ///< Output total number selection_flags + { + // Blocks are launched in increasing order, so just assign one tile per block + int tile_idx = (blockIdx.x * gridDim.y) + blockIdx.y; // Current tile index + OffsetT tile_offset = tile_idx * TILE_ITEMS; // Global offset for the current tile + + if (tile_idx < num_tiles - 1) + { + // Not the last tile (full) + ConsumeTile(TILE_ITEMS, tile_idx, tile_offset, tile_state); + } + else + { + // The last tile (possibly partially-full) + OffsetT num_remaining = num_items - tile_offset; + OffsetT num_selections = ConsumeTile(num_remaining, tile_idx, tile_offset, tile_state); + + if (threadIdx.x == 0) + { + // Output the total number of items selection_flags + *d_num_selected_out = num_selections; + } + } + } + +}; + + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/agent/agent_spmv.cuh b/3rdparty/cub/cub/agent/agent_spmv.cuh new file mode 100644 index 00000000000..32e563cc3ae --- /dev/null +++ b/3rdparty/cub/cub/agent/agent_spmv.cuh @@ -0,0 +1,718 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::AgentSpmv implements a stateful abstraction of CUDA thread blocks for participating in device-wide SpMV. + */ + +#pragma once + +#include + +#include "../util_type.cuh" +#include "../block/block_reduce.cuh" +#include "../block/block_scan.cuh" +#include "../block/block_exchange.cuh" +#include "../thread/thread_search.cuh" +#include "../thread/thread_operators.cuh" +#include "../iterator/cache_modified_input_iterator.cuh" +#include "../iterator/counting_input_iterator.cuh" +#include "../iterator/tex_ref_input_iterator.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Tuning policy + ******************************************************************************/ + +/** + * Parameterizable tuning policy type for AgentSpmv + */ +template < + int _BLOCK_THREADS, ///< Threads per thread block + int _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + CacheLoadModifier _SEARCH_ROW_OFFSETS_LOAD_MODIFIER, ///< Cache load modifier for reading CSR row-offsets during search + CacheLoadModifier _ROW_OFFSETS_LOAD_MODIFIER, ///< Cache load modifier for reading CSR row-offsets + CacheLoadModifier _COLUMN_INDICES_LOAD_MODIFIER, ///< Cache load modifier for reading CSR column-indices + CacheLoadModifier _VALUES_LOAD_MODIFIER, ///< Cache load modifier for reading CSR values + CacheLoadModifier _VECTOR_VALUES_LOAD_MODIFIER, ///< Cache load modifier for reading vector values + bool _DIRECT_LOAD_NONZEROS, ///< Whether to load nonzeros directly from global during sequential merging (vs. pre-staged through shared memory) + BlockScanAlgorithm _SCAN_ALGORITHM> ///< The BlockScan algorithm to use +struct AgentSpmvPolicy +{ + enum + { + BLOCK_THREADS = _BLOCK_THREADS, ///< Threads per thread block + ITEMS_PER_THREAD = _ITEMS_PER_THREAD, ///< Items per thread (per tile of input) + DIRECT_LOAD_NONZEROS = _DIRECT_LOAD_NONZEROS, ///< Whether to load nonzeros directly from global during sequential merging (pre-staged through shared memory) + }; + + static const CacheLoadModifier SEARCH_ROW_OFFSETS_LOAD_MODIFIER = _SEARCH_ROW_OFFSETS_LOAD_MODIFIER; ///< Cache load modifier for reading CSR row-offsets + static const CacheLoadModifier ROW_OFFSETS_LOAD_MODIFIER = _ROW_OFFSETS_LOAD_MODIFIER; ///< Cache load modifier for reading CSR row-offsets + static const CacheLoadModifier COLUMN_INDICES_LOAD_MODIFIER = _COLUMN_INDICES_LOAD_MODIFIER; ///< Cache load modifier for reading CSR column-indices + static const CacheLoadModifier VALUES_LOAD_MODIFIER = _VALUES_LOAD_MODIFIER; ///< Cache load modifier for reading CSR values + static const CacheLoadModifier VECTOR_VALUES_LOAD_MODIFIER = _VECTOR_VALUES_LOAD_MODIFIER; ///< Cache load modifier for reading vector values + static const BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM; ///< The BlockScan algorithm to use + +}; + + +/****************************************************************************** + * Thread block abstractions + ******************************************************************************/ + +template < + typename ValueT, ///< Matrix and vector value type + typename OffsetT> ///< Signed integer type for sequence offsets +struct SpmvParams +{ + ValueT* d_values; ///< Pointer to the array of \p num_nonzeros values of the corresponding nonzero elements of matrix A. + OffsetT* d_row_end_offsets; ///< Pointer to the array of \p m offsets demarcating the end of every row in \p d_column_indices and \p d_values + OffsetT* d_column_indices; ///< Pointer to the array of \p num_nonzeros column-indices of the corresponding nonzero elements of matrix A. (Indices are zero-valued.) + ValueT* d_vector_x; ///< Pointer to the array of \p num_cols values corresponding to the dense input vector x + ValueT* d_vector_y; ///< Pointer to the array of \p num_rows values corresponding to the dense output vector y + int num_rows; ///< Number of rows of matrix A. + int num_cols; ///< Number of columns of matrix A. + int num_nonzeros; ///< Number of nonzero elements of matrix A. + ValueT alpha; ///< Alpha multiplicand + ValueT beta; ///< Beta addend-multiplicand + + TexRefInputIterator t_vector_x; +}; + + +/** + * \brief AgentSpmv implements a stateful abstraction of CUDA thread blocks for participating in device-wide SpMV. + */ +template < + typename AgentSpmvPolicyT, ///< Parameterized AgentSpmvPolicy tuning policy type + typename ValueT, ///< Matrix and vector value type + typename OffsetT, ///< Signed integer type for sequence offsets + bool HAS_ALPHA, ///< Whether the input parameter \p alpha is 1 + bool HAS_BETA, ///< Whether the input parameter \p beta is 0 + int PTX_ARCH = CUB_PTX_ARCH> ///< PTX compute capability +struct AgentSpmv +{ + //--------------------------------------------------------------------- + // Types and constants + //--------------------------------------------------------------------- + + /// Constants + enum + { + BLOCK_THREADS = AgentSpmvPolicyT::BLOCK_THREADS, + ITEMS_PER_THREAD = AgentSpmvPolicyT::ITEMS_PER_THREAD, + TILE_ITEMS = BLOCK_THREADS * ITEMS_PER_THREAD, + }; + + /// 2D merge path coordinate type + typedef typename CubVector::Type CoordinateT; + + /// Input iterator wrapper types (for applying cache modifiers) + + typedef CacheModifiedInputIterator< + AgentSpmvPolicyT::ROW_OFFSETS_LOAD_MODIFIER, + OffsetT, + OffsetT> + RowOffsetsIteratorT; + + typedef CacheModifiedInputIterator< + AgentSpmvPolicyT::COLUMN_INDICES_LOAD_MODIFIER, + OffsetT, + OffsetT> + ColumnIndicesIteratorT; + + typedef CacheModifiedInputIterator< + AgentSpmvPolicyT::VALUES_LOAD_MODIFIER, + ValueT, + OffsetT> + ValueIteratorT; + + typedef CacheModifiedInputIterator< + AgentSpmvPolicyT::VECTOR_VALUES_LOAD_MODIFIER, + ValueT, + OffsetT> + VectorValueIteratorT; + + // Tuple type for scanning (pairs accumulated segment-value with segment-index) + typedef KeyValuePair KeyValuePairT; + + // Reduce-value-by-segment scan operator + typedef ReduceByKeyOp ReduceBySegmentOpT; + + // BlockReduce specialization + typedef BlockReduce< + ValueT, + BLOCK_THREADS, + BLOCK_REDUCE_WARP_REDUCTIONS> + BlockReduceT; + + // BlockScan specialization + typedef BlockScan< + KeyValuePairT, + BLOCK_THREADS, + AgentSpmvPolicyT::SCAN_ALGORITHM> + BlockScanT; + + // BlockScan specialization + typedef BlockScan< + ValueT, + BLOCK_THREADS, + AgentSpmvPolicyT::SCAN_ALGORITHM> + BlockPrefixSumT; + + // BlockExchange specialization + typedef BlockExchange< + ValueT, + BLOCK_THREADS, + ITEMS_PER_THREAD> + BlockExchangeT; + + /// Merge item type (either a non-zero value or a row-end offset) + union MergeItem + { + // Value type to pair with index type OffsetT (NullType if loading values directly during merge) + typedef typename If::Type MergeValueT; + + OffsetT row_end_offset; + MergeValueT nonzero; + }; + + /// Shared memory type required by this thread block + struct _TempStorage + { + union + { + + // Smem needed for tile of merge items + MergeItem merge_items[ITEMS_PER_THREAD + TILE_ITEMS + 1]; + + // Smem needed for block exchange + typename BlockExchangeT::TempStorage exchange; + + // Smem needed for block-wide reduction + typename BlockReduceT::TempStorage reduce; + + // Smem needed for tile scanning + typename BlockScanT::TempStorage scan; + + // Smem needed for tile prefix sum + typename BlockPrefixSumT::TempStorage prefix_sum; + }; + }; + + /// Temporary storage type (unionable) + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Per-thread fields + //--------------------------------------------------------------------- + + + _TempStorage& temp_storage; /// Reference to temp_storage + + SpmvParams& spmv_params; + + ValueIteratorT wd_values; ///< Wrapped pointer to the array of \p num_nonzeros values of the corresponding nonzero elements of matrix A. + RowOffsetsIteratorT wd_row_end_offsets; ///< Wrapped Pointer to the array of \p m offsets demarcating the end of every row in \p d_column_indices and \p d_values + ColumnIndicesIteratorT wd_column_indices; ///< Wrapped Pointer to the array of \p num_nonzeros column-indices of the corresponding nonzero elements of matrix A. (Indices are zero-valued.) + VectorValueIteratorT wd_vector_x; ///< Wrapped Pointer to the array of \p num_cols values corresponding to the dense input vector x + VectorValueIteratorT wd_vector_y; ///< Wrapped Pointer to the array of \p num_cols values corresponding to the dense input vector x + + + //--------------------------------------------------------------------- + // Interface + //--------------------------------------------------------------------- + + /** + * Constructor + */ + __device__ __forceinline__ AgentSpmv( + TempStorage& temp_storage, ///< Reference to temp_storage + SpmvParams& spmv_params) ///< SpMV input parameter bundle + : + temp_storage(temp_storage.Alias()), + spmv_params(spmv_params), + wd_values(spmv_params.d_values), + wd_row_end_offsets(spmv_params.d_row_end_offsets), + wd_column_indices(spmv_params.d_column_indices), + wd_vector_x(spmv_params.d_vector_x), + wd_vector_y(spmv_params.d_vector_y) + {} + + + + + /** + * Consume a merge tile, specialized for direct-load of nonzeros + */ + __device__ __forceinline__ KeyValuePairT ConsumeTile( + int tile_idx, + CoordinateT tile_start_coord, + CoordinateT tile_end_coord, + Int2Type is_direct_load) ///< Marker type indicating whether to load nonzeros directly during path-discovery or beforehand in batch + { + int tile_num_rows = tile_end_coord.x - tile_start_coord.x; + int tile_num_nonzeros = tile_end_coord.y - tile_start_coord.y; + OffsetT* s_tile_row_end_offsets = &temp_storage.merge_items[0].row_end_offset; + + // Gather the row end-offsets for the merge tile into shared memory + for (int item = threadIdx.x; item <= tile_num_rows; item += BLOCK_THREADS) + { + s_tile_row_end_offsets[item] = wd_row_end_offsets[tile_start_coord.x + item]; + } + + __syncthreads(); + + // Search for the thread's starting coordinate within the merge tile + CountingInputIterator tile_nonzero_indices(tile_start_coord.y); + CoordinateT thread_start_coord; + + MergePathSearch( + OffsetT(threadIdx.x * ITEMS_PER_THREAD), // Diagonal + s_tile_row_end_offsets, // List A + tile_nonzero_indices, // List B + tile_num_rows, + tile_num_nonzeros, + thread_start_coord); + + __syncthreads(); // Perf-sync + + // Compute the thread's merge path segment + CoordinateT thread_current_coord = thread_start_coord; + KeyValuePairT scan_segment[ITEMS_PER_THREAD]; + + ValueT running_total = 0.0; + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + OffsetT nonzero_idx = CUB_MIN(tile_nonzero_indices[thread_current_coord.y], spmv_params.num_nonzeros - 1); + OffsetT column_idx = wd_column_indices[nonzero_idx]; + ValueT value = wd_values[nonzero_idx]; + + ValueT vector_value = spmv_params.t_vector_x[column_idx]; +#if (CUB_PTX_ARCH >= 350) + vector_value = wd_vector_x[column_idx]; +#endif + ValueT nonzero = value * vector_value; + + OffsetT row_end_offset = s_tile_row_end_offsets[thread_current_coord.x]; + + if (tile_nonzero_indices[thread_current_coord.y] < row_end_offset) + { + // Move down (accumulate) + running_total += nonzero; + scan_segment[ITEM].value = running_total; + scan_segment[ITEM].key = tile_num_rows; + ++thread_current_coord.y; + } + else + { + // Move right (reset) + scan_segment[ITEM].value = running_total; + scan_segment[ITEM].key = thread_current_coord.x; + running_total = 0.0; + ++thread_current_coord.x; + } + } + + __syncthreads(); + + // Block-wide reduce-value-by-segment + KeyValuePairT tile_carry; + ReduceBySegmentOpT scan_op; + KeyValuePairT scan_item; + + scan_item.value = running_total; + scan_item.key = thread_current_coord.x; + + BlockScanT(temp_storage.scan).ExclusiveScan(scan_item, scan_item, scan_op, tile_carry); + + if (tile_num_rows > 0) + { + if (threadIdx.x == 0) + scan_item.key = -1; + + // Direct scatter + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + if (scan_segment[ITEM].key < tile_num_rows) + { + if (scan_item.key == scan_segment[ITEM].key) + scan_segment[ITEM].value = scan_item.value + scan_segment[ITEM].value; + + if (HAS_ALPHA) + { + scan_segment[ITEM].value *= spmv_params.alpha; + } + + if (HAS_BETA) + { + // Update the output vector element + ValueT addend = spmv_params.beta * wd_vector_y[tile_start_coord.x + scan_segment[ITEM].key]; + scan_segment[ITEM].value += addend; + } + + // Set the output vector element + spmv_params.d_vector_y[tile_start_coord.x + scan_segment[ITEM].key] = scan_segment[ITEM].value; + } + } + } + + // Return the tile's running carry-out + return tile_carry; + } + + + + /** + * Consume a merge tile, specialized for indirect load of nonzeros + */ + __device__ __forceinline__ KeyValuePairT ConsumeTile( + int tile_idx, + CoordinateT tile_start_coord, + CoordinateT tile_end_coord, + Int2Type is_direct_load) ///< Marker type indicating whether to load nonzeros directly during path-discovery or beforehand in batch + { + int tile_num_rows = tile_end_coord.x - tile_start_coord.x; + int tile_num_nonzeros = tile_end_coord.y - tile_start_coord.y; + OffsetT* s_tile_row_end_offsets = &temp_storage.merge_items[0].row_end_offset; + ValueT* s_tile_nonzeros = &temp_storage.merge_items[tile_num_rows + ITEMS_PER_THREAD].nonzero; + +#if (CUB_PTX_ARCH >= 520) + + // Gather the nonzeros for the merge tile into shared memory + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + int nonzero_idx = threadIdx.x + (ITEM * BLOCK_THREADS); + + ValueIteratorT a = wd_values + tile_start_coord.y + nonzero_idx; + ColumnIndicesIteratorT ci = wd_column_indices + tile_start_coord.y + nonzero_idx; + + if (nonzero_idx < tile_num_nonzeros) + { + + OffsetT column_idx = *ci; + ValueT value = *a; + + ValueT vector_value = spmv_params.t_vector_x[column_idx]; + vector_value = wd_vector_x[column_idx]; + + ValueT nonzero = value * vector_value; + + s_tile_nonzeros[nonzero_idx] = nonzero; + } + } + +#else + + // Gather the nonzeros for the merge tile into shared memory + if (tile_num_nonzeros > 0) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + int nonzero_idx = threadIdx.x + (ITEM * BLOCK_THREADS); + nonzero_idx = CUB_MIN(nonzero_idx, tile_num_nonzeros - 1); + + OffsetT column_idx = wd_column_indices[tile_start_coord.y + nonzero_idx]; + ValueT value = wd_values[tile_start_coord.y + nonzero_idx]; + + ValueT vector_value = spmv_params.t_vector_x[column_idx]; +#if (CUB_PTX_ARCH >= 350) + vector_value = wd_vector_x[column_idx]; +#endif + ValueT nonzero = value * vector_value; + + s_tile_nonzeros[nonzero_idx] = nonzero; + } + } + +#endif + + // Gather the row end-offsets for the merge tile into shared memory + #pragma unroll 1 + for (int item = threadIdx.x; item <= tile_num_rows; item += BLOCK_THREADS) + { + s_tile_row_end_offsets[item] = wd_row_end_offsets[tile_start_coord.x + item]; + } + + __syncthreads(); + + // Search for the thread's starting coordinate within the merge tile + CountingInputIterator tile_nonzero_indices(tile_start_coord.y); + CoordinateT thread_start_coord; + + MergePathSearch( + OffsetT(threadIdx.x * ITEMS_PER_THREAD), // Diagonal + s_tile_row_end_offsets, // List A + tile_nonzero_indices, // List B + tile_num_rows, + tile_num_nonzeros, + thread_start_coord); + + __syncthreads(); // Perf-sync + + // Compute the thread's merge path segment + CoordinateT thread_current_coord = thread_start_coord; + KeyValuePairT scan_segment[ITEMS_PER_THREAD]; + ValueT running_total = 0.0; + + OffsetT row_end_offset = s_tile_row_end_offsets[thread_current_coord.x]; + ValueT nonzero = s_tile_nonzeros[thread_current_coord.y]; + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + if (tile_nonzero_indices[thread_current_coord.y] < row_end_offset) + { + // Move down (accumulate) + scan_segment[ITEM].value = nonzero; + running_total += nonzero; + ++thread_current_coord.y; + nonzero = s_tile_nonzeros[thread_current_coord.y]; + } + else + { + // Move right (reset) + scan_segment[ITEM].value = 0.0; + running_total = 0.0; + ++thread_current_coord.x; + row_end_offset = s_tile_row_end_offsets[thread_current_coord.x]; + } + + scan_segment[ITEM].key = thread_current_coord.x; + } + + __syncthreads(); + + // Block-wide reduce-value-by-segment + KeyValuePairT tile_carry; + ReduceBySegmentOpT scan_op; + KeyValuePairT scan_item; + + scan_item.value = running_total; + scan_item.key = thread_current_coord.x; + + BlockScanT(temp_storage.scan).ExclusiveScan(scan_item, scan_item, scan_op, tile_carry); + + if (threadIdx.x == 0) + { + scan_item.key = scan_segment[0].key; + scan_item.value = 0.0; + } + + if (tile_num_rows > 0) + { + + __syncthreads(); + + // Scan downsweep and scatter + ValueT* s_partials = &temp_storage.merge_items[0].nonzero; + + if (scan_item.key != scan_segment[0].key) + { + s_partials[scan_item.key] = scan_item.value; + } + else + { + scan_segment[0].value += scan_item.value; + } + + #pragma unroll + for (int ITEM = 1; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + if (scan_segment[ITEM - 1].key != scan_segment[ITEM].key) + { + s_partials[scan_segment[ITEM - 1].key] = scan_segment[ITEM - 1].value; + } + else + { + scan_segment[ITEM].value += scan_segment[ITEM - 1].value; + } + } + + __syncthreads(); + + #pragma unroll 1 + for (int item = threadIdx.x; item < tile_num_rows; item += BLOCK_THREADS) + { + spmv_params.d_vector_y[tile_start_coord.x + item] = s_partials[item]; + } + } + + // Return the tile's running carry-out + return tile_carry; + } + + + /** + * Consume a merge tile, specialized for indirect load of nonzeros + */ + __device__ __forceinline__ KeyValuePairT ConsumeTile2( + int tile_idx, + CoordinateT tile_start_coord, + CoordinateT tile_end_coord, + Int2Type is_direct_load) ///< Marker type indicating whether to load nonzeros directly during path-discovery or beforehand in batch + { + int tile_num_rows = tile_end_coord.x - tile_start_coord.x; + int tile_num_nonzeros = tile_end_coord.y - tile_start_coord.y; + + ValueT* s_tile_nonzeros = &temp_storage.merge_items[0].nonzero; + + ValueT nonzeros[ITEMS_PER_THREAD]; + + // Gather the nonzeros for the merge tile into shared memory + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + int nonzero_idx = threadIdx.x + (ITEM * BLOCK_THREADS); + nonzero_idx = CUB_MIN(nonzero_idx, tile_num_nonzeros - 1); + + OffsetT column_idx = wd_column_indices[tile_start_coord.y + nonzero_idx]; + ValueT value = wd_values[tile_start_coord.y + nonzero_idx]; + + ValueT vector_value = spmv_params.t_vector_x[column_idx]; +#if (CUB_PTX_ARCH >= 350) + vector_value = wd_vector_x[column_idx]; +#endif + + nonzeros[ITEM] = value * vector_value; + } + + // Exchange striped->blocked + BlockExchangeT(temp_storage.exchange).StripedToBlocked(nonzeros); + + __syncthreads(); + + // Compute an inclusive prefix sum + BlockPrefixSumT(temp_storage.prefix_sum).InclusiveSum(nonzeros, nonzeros); + + __syncthreads(); + + if (threadIdx.x == 0) + s_tile_nonzeros[0] = 0.0; + + // Scatter back to smem + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + int item_idx = (threadIdx.x * ITEMS_PER_THREAD) + ITEM + 1; + s_tile_nonzeros[item_idx] = nonzeros[ITEM]; + } + + __syncthreads(); + + // Gather the row end-offsets for the merge tile into shared memory + #pragma unroll 1 + for (int item = threadIdx.x; item < tile_num_rows; item += BLOCK_THREADS) + { + OffsetT start = CUB_MAX(wd_row_end_offsets[tile_start_coord.x + item - 1], tile_start_coord.y); + OffsetT end = wd_row_end_offsets[tile_start_coord.x + item]; + + start -= tile_start_coord.y; + end -= tile_start_coord.y; + + ValueT row_partial = s_tile_nonzeros[end] - s_tile_nonzeros[start]; + + spmv_params.d_vector_y[tile_start_coord.x + item] = row_partial; + } + + // Get the tile's carry-out + KeyValuePairT tile_carry; + if (threadIdx.x == 0) + { + tile_carry.key = tile_num_rows; + + OffsetT start = CUB_MAX(wd_row_end_offsets[tile_end_coord.x - 1], tile_start_coord.y); + start -= tile_start_coord.y; + OffsetT end = tile_num_nonzeros; + + tile_carry.value = s_tile_nonzeros[end] - s_tile_nonzeros[start]; + } + + // Return the tile's running carry-out + return tile_carry; + } + + + + /** + * Consume input tile + */ + __device__ __forceinline__ void ConsumeTile( + CoordinateT* d_tile_coordinates, ///< [in] Pointer to the temporary array of tile starting coordinates + KeyValuePairT* d_tile_carry_pairs, ///< [out] Pointer to the temporary array carry-out dot product row-ids, one per block + int num_merge_tiles) ///< [in] Number of merge tiles + { + int tile_idx = (blockIdx.x * gridDim.y) + blockIdx.y; // Current tile index + + if (tile_idx >= num_merge_tiles) + return; + + CoordinateT tile_start_coord = d_tile_coordinates[tile_idx + 0]; + CoordinateT tile_end_coord = d_tile_coordinates[tile_idx + 1]; + + // Consume multi-segment tile + KeyValuePairT tile_carry = ConsumeTile( + tile_idx, + tile_start_coord, + tile_end_coord, + Int2Type()); + + // Output the tile's carry-out + if (threadIdx.x == 0) + { + if (HAS_ALPHA) + tile_carry.value *= spmv_params.alpha; + + tile_carry.key += tile_start_coord.x; + d_tile_carry_pairs[tile_idx] = tile_carry; + } + } + + +}; + + + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/agent/single_pass_scan_operators.cuh b/3rdparty/cub/cub/agent/single_pass_scan_operators.cuh new file mode 100644 index 00000000000..825142e7f61 --- /dev/null +++ b/3rdparty/cub/cub/agent/single_pass_scan_operators.cuh @@ -0,0 +1,783 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Callback operator types for supplying BlockScan prefixes + */ + +#pragma once + +#include + +#include "../thread/thread_load.cuh" +#include "../thread/thread_store.cuh" +#include "../warp/warp_reduce.cuh" +#include "../util_arch.cuh" +#include "../util_device.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Prefix functor type for maintaining a running prefix while scanning a + * region independent of other thread blocks + ******************************************************************************/ + +/** + * Stateful callback operator type for supplying BlockScan prefixes. + * Maintains a running prefix that can be applied to consecutive + * BlockScan operations. + */ +template < + typename T, ///< BlockScan value type + typename ScanOpT> ///< Wrapped scan operator type +struct BlockScanRunningPrefixOp +{ + ScanOpT op; ///< Wrapped scan operator + T running_total; ///< Running block-wide prefix + + /// Constructor + __device__ __forceinline__ BlockScanRunningPrefixOp(ScanOpT op) + : + op(op) + {} + + /// Constructor + __device__ __forceinline__ BlockScanRunningPrefixOp( + T starting_prefix, + ScanOpT op) + : + op(op), + running_total(starting_prefix) + {} + + /** + * Prefix callback operator. Returns the block-wide running_total in thread-0. + */ + __device__ __forceinline__ T operator()( + const T &block_aggregate) ///< The aggregate sum of the BlockScan inputs + { + T retval = running_total; + running_total = op(running_total, block_aggregate); + return retval; + } +}; + + +/****************************************************************************** + * Generic tile status interface types for block-cooperative scans + ******************************************************************************/ + +/** + * Enumerations of tile status + */ +enum ScanTileStatus +{ + SCAN_TILE_OOB, // Out-of-bounds (e.g., padding) + SCAN_TILE_INVALID, // Not yet processed + SCAN_TILE_PARTIAL, // Tile aggregate is available + SCAN_TILE_INCLUSIVE, // Inclusive tile prefix is available +}; + + +/** + * Tile status interface. + */ +template < + typename T, + bool SINGLE_WORD = Traits::PRIMITIVE> +struct ScanTileState; + + +/** + * Tile status interface specialized for scan status and value types + * that can be combined into one machine word that can be + * read/written coherently in a single access. + */ +template +struct ScanTileState +{ + // Status word type + typedef typename If<(sizeof(T) == 8), + long long, + typename If<(sizeof(T) == 4), + int, + typename If<(sizeof(T) == 2), + short, + char>::Type>::Type>::Type StatusWord; + + + // Unit word type + typedef typename If<(sizeof(T) == 8), + longlong2, + typename If<(sizeof(T) == 4), + int2, + typename If<(sizeof(T) == 2), + int, + uchar2>::Type>::Type>::Type TxnWord; + + + // Device word type + struct TileDescriptor + { + StatusWord status; + T value; + }; + + + // Constants + enum + { + TILE_STATUS_PADDING = CUB_PTX_WARP_THREADS, + }; + + + // Device storage + TileDescriptor *d_tile_status; + + + /// Constructor + __host__ __device__ __forceinline__ + ScanTileState() + : + d_tile_status(NULL) + {} + + + /// Initializer + __host__ __device__ __forceinline__ + cudaError_t Init( + int num_tiles, ///< [in] Number of tiles + void *d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t temp_storage_bytes) ///< [in] Size in bytes of \t d_temp_storage allocation + { + d_tile_status = reinterpret_cast(d_temp_storage); + return cudaSuccess; + } + + + /** + * Compute device memory needed for tile status + */ + __host__ __device__ __forceinline__ + static cudaError_t AllocationSize( + int num_tiles, ///< [in] Number of tiles + size_t &temp_storage_bytes) ///< [out] Size in bytes of \t d_temp_storage allocation + { + temp_storage_bytes = (num_tiles + TILE_STATUS_PADDING) * sizeof(TileDescriptor); // bytes needed for tile status descriptors + return cudaSuccess; + } + + + /** + * Initialize (from device) + */ + __device__ __forceinline__ void InitializeStatus(int num_tiles) + { + int tile_idx = (blockIdx.x * blockDim.x) + threadIdx.x; + if (tile_idx < num_tiles) + { + // Not-yet-set + d_tile_status[TILE_STATUS_PADDING + tile_idx].status = StatusWord(SCAN_TILE_INVALID); + } + + if ((blockIdx.x == 0) && (threadIdx.x < TILE_STATUS_PADDING)) + { + // Padding + d_tile_status[threadIdx.x].status = StatusWord(SCAN_TILE_OOB); + } + } + + + /** + * Update the specified tile's inclusive value and corresponding status + */ + __device__ __forceinline__ void SetInclusive(int tile_idx, T tile_inclusive) + { + TileDescriptor tile_descriptor; + tile_descriptor.status = SCAN_TILE_INCLUSIVE; + tile_descriptor.value = tile_inclusive; + + TxnWord alias; + *reinterpret_cast(&alias) = tile_descriptor; + ThreadStore(reinterpret_cast(d_tile_status + TILE_STATUS_PADDING + tile_idx), alias); + } + + + /** + * Update the specified tile's partial value and corresponding status + */ + __device__ __forceinline__ void SetPartial(int tile_idx, T tile_partial) + { + TileDescriptor tile_descriptor; + tile_descriptor.status = SCAN_TILE_PARTIAL; + tile_descriptor.value = tile_partial; + + TxnWord alias; + *reinterpret_cast(&alias) = tile_descriptor; + ThreadStore(reinterpret_cast(d_tile_status + TILE_STATUS_PADDING + tile_idx), alias); + } + + /** + * Wait for the corresponding tile to become non-invalid + */ + __device__ __forceinline__ void WaitForValid( + int tile_idx, + StatusWord &status, + T &value) + { + // Use warp-any to determine when all threads have valid status + TxnWord alias = ThreadLoad(reinterpret_cast(d_tile_status + TILE_STATUS_PADDING + tile_idx)); + TileDescriptor tile_descriptor = reinterpret_cast(alias); + + while ((tile_descriptor.status == SCAN_TILE_INVALID)) + { + alias = ThreadLoad(reinterpret_cast(d_tile_status + TILE_STATUS_PADDING + tile_idx)); + tile_descriptor = reinterpret_cast(alias); + } + + status = tile_descriptor.status; + value = tile_descriptor.value; + } + +}; + + + +/** + * Tile status interface specialized for scan status and value types that + * cannot be combined into one machine word. + */ +template +struct ScanTileState +{ + // Status word type + typedef char StatusWord; + + // Constants + enum + { + TILE_STATUS_PADDING = CUB_PTX_WARP_THREADS, + }; + + // Device storage + StatusWord *d_tile_status; + T *d_tile_partial; + T *d_tile_inclusive; + + /// Constructor + __host__ __device__ __forceinline__ + ScanTileState() + : + d_tile_status(NULL), + d_tile_partial(NULL), + d_tile_inclusive(NULL) + {} + + + /// Initializer + __host__ __device__ __forceinline__ + cudaError_t Init( + int num_tiles, ///< [in] Number of tiles + void *d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t temp_storage_bytes) ///< [in] Size in bytes of \t d_temp_storage allocation + { + cudaError_t error = cudaSuccess; + do + { + void* allocations[3]; + size_t allocation_sizes[3]; + + allocation_sizes[0] = (num_tiles + TILE_STATUS_PADDING) * sizeof(StatusWord); // bytes needed for tile status descriptors + allocation_sizes[1] = (num_tiles + TILE_STATUS_PADDING) * sizeof(Uninitialized); // bytes needed for partials + allocation_sizes[2] = (num_tiles + TILE_STATUS_PADDING) * sizeof(Uninitialized); // bytes needed for inclusives + + // Compute allocation pointers into the single storage blob + if (CubDebug(error = AliasTemporaries(d_temp_storage, temp_storage_bytes, allocations, allocation_sizes))) break; + + // Alias the offsets + d_tile_status = reinterpret_cast(allocations[0]); + d_tile_partial = reinterpret_cast(allocations[1]); + d_tile_inclusive = reinterpret_cast(allocations[2]); + } + while (0); + + return error; + } + + + /** + * Compute device memory needed for tile status + */ + __host__ __device__ __forceinline__ + static cudaError_t AllocationSize( + int num_tiles, ///< [in] Number of tiles + size_t &temp_storage_bytes) ///< [out] Size in bytes of \t d_temp_storage allocation + { + // Specify storage allocation requirements + size_t allocation_sizes[3]; + allocation_sizes[0] = (num_tiles + TILE_STATUS_PADDING) * sizeof(StatusWord); // bytes needed for tile status descriptors + allocation_sizes[1] = (num_tiles + TILE_STATUS_PADDING) * sizeof(Uninitialized); // bytes needed for partials + allocation_sizes[2] = (num_tiles + TILE_STATUS_PADDING) * sizeof(Uninitialized); // bytes needed for inclusives + + // Set the necessary size of the blob + void* allocations[3]; + return CubDebug(AliasTemporaries(NULL, temp_storage_bytes, allocations, allocation_sizes)); + } + + + /** + * Initialize (from device) + */ + __device__ __forceinline__ void InitializeStatus(int num_tiles) + { + int tile_idx = (blockIdx.x * blockDim.x) + threadIdx.x; + if (tile_idx < num_tiles) + { + // Not-yet-set + d_tile_status[TILE_STATUS_PADDING + tile_idx] = StatusWord(SCAN_TILE_INVALID); + } + + if ((blockIdx.x == 0) && (threadIdx.x < TILE_STATUS_PADDING)) + { + // Padding + d_tile_status[threadIdx.x] = StatusWord(SCAN_TILE_OOB); + } + } + + + /** + * Update the specified tile's inclusive value and corresponding status + */ + __device__ __forceinline__ void SetInclusive(int tile_idx, T tile_inclusive) + { + // Update tile inclusive value + ThreadStore(d_tile_inclusive + TILE_STATUS_PADDING + tile_idx, tile_inclusive); + + // Fence + __threadfence(); + + // Update tile status + ThreadStore(d_tile_status + TILE_STATUS_PADDING + tile_idx, StatusWord(SCAN_TILE_INCLUSIVE)); + } + + + /** + * Update the specified tile's partial value and corresponding status + */ + __device__ __forceinline__ void SetPartial(int tile_idx, T tile_partial) + { + // Update tile partial value + ThreadStore(d_tile_partial + TILE_STATUS_PADDING + tile_idx, tile_partial); + + // Fence + __threadfence(); + + // Update tile status + ThreadStore(d_tile_status + TILE_STATUS_PADDING + tile_idx, StatusWord(SCAN_TILE_PARTIAL)); + } + + /** + * Wait for the corresponding tile to become non-invalid + */ + __device__ __forceinline__ void WaitForValid( + int tile_idx, + StatusWord &status, + T &value) + { + status = ThreadLoad(d_tile_status + TILE_STATUS_PADDING + tile_idx); + while (status == SCAN_TILE_INVALID) + { + status = ThreadLoad(d_tile_status + TILE_STATUS_PADDING + tile_idx); + } + + T partial = ThreadLoad(d_tile_partial + TILE_STATUS_PADDING + tile_idx); + T inclusive = ThreadLoad(d_tile_inclusive + TILE_STATUS_PADDING + tile_idx); + + value = (status == StatusWord(SCAN_TILE_PARTIAL)) ? + partial : + inclusive; + + } +}; + + +/****************************************************************************** + * ReduceByKey tile status interface types for block-cooperative scans + ******************************************************************************/ + +/** + * Tile status interface for reduction by key. + * + */ +template < + typename ValueT, + typename KeyT, + bool SINGLE_WORD = (Traits::PRIMITIVE) && (sizeof(ValueT) + sizeof(KeyT) < 16)> +struct ReduceByKeyScanTileState; + + +/** + * Tile status interface for reduction by key, specialized for scan status and value types that + * cannot be combined into one machine word. + */ +template < + typename ValueT, + typename KeyT> +struct ReduceByKeyScanTileState : + ScanTileState > +{ + typedef ScanTileState > SuperClass; + + /// Constructor + __host__ __device__ __forceinline__ + ReduceByKeyScanTileState() : SuperClass() {} +}; + + +/** + * Tile status interface for reduction by key, specialized for scan status and value types that + * can be combined into one machine word that can be read/written coherently in a single access. + */ +template < + typename ValueT, + typename KeyT> +struct ReduceByKeyScanTileState +{ + typedef KeyValuePairKeyValuePairT; + + // Constants + enum + { + PAIR_SIZE = sizeof(ValueT) + sizeof(KeyT), + TXN_WORD_SIZE = 1 << Log2::VALUE, + STATUS_WORD_SIZE = TXN_WORD_SIZE - PAIR_SIZE, + + TILE_STATUS_PADDING = CUB_PTX_WARP_THREADS, + }; + + // Status word type + typedef typename If<(STATUS_WORD_SIZE == 8), + long long, + typename If<(STATUS_WORD_SIZE == 4), + int, + typename If<(STATUS_WORD_SIZE == 2), + short, + char>::Type>::Type>::Type StatusWord; + + // Status word type + typedef typename If<(TXN_WORD_SIZE == 16), + longlong2, + typename If<(TXN_WORD_SIZE == 8), + long long, + int>::Type>::Type TxnWord; + + // Device word type (for when sizeof(ValueT) == sizeof(KeyT)) + struct TileDescriptorBigStatus + { + KeyT key; + ValueT value; + StatusWord status; + }; + + // Device word type (for when sizeof(ValueT) != sizeof(KeyT)) + struct TileDescriptorLittleStatus + { + ValueT value; + StatusWord status; + KeyT key; + }; + + // Device word type + typedef typename If< + (sizeof(ValueT) == sizeof(KeyT)), + TileDescriptorBigStatus, + TileDescriptorLittleStatus>::Type + TileDescriptor; + + + // Device storage + TileDescriptor *d_tile_status; + + + /// Constructor + __host__ __device__ __forceinline__ + ReduceByKeyScanTileState() + : + d_tile_status(NULL) + {} + + + /// Initializer + __host__ __device__ __forceinline__ + cudaError_t Init( + int num_tiles, ///< [in] Number of tiles + void *d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t temp_storage_bytes) ///< [in] Size in bytes of \t d_temp_storage allocation + { + d_tile_status = reinterpret_cast(d_temp_storage); + return cudaSuccess; + } + + + /** + * Compute device memory needed for tile status + */ + __host__ __device__ __forceinline__ + static cudaError_t AllocationSize( + int num_tiles, ///< [in] Number of tiles + size_t &temp_storage_bytes) ///< [out] Size in bytes of \t d_temp_storage allocation + { + temp_storage_bytes = (num_tiles + TILE_STATUS_PADDING) * sizeof(TileDescriptor); // bytes needed for tile status descriptors + return cudaSuccess; + } + + + /** + * Initialize (from device) + */ + __device__ __forceinline__ void InitializeStatus(int num_tiles) + { + int tile_idx = (blockIdx.x * blockDim.x) + threadIdx.x; + if (tile_idx < num_tiles) + { + // Not-yet-set + d_tile_status[TILE_STATUS_PADDING + tile_idx].status = StatusWord(SCAN_TILE_INVALID); + } + + if ((blockIdx.x == 0) && (threadIdx.x < TILE_STATUS_PADDING)) + { + // Padding + d_tile_status[threadIdx.x].status = StatusWord(SCAN_TILE_OOB); + } + } + + + /** + * Update the specified tile's inclusive value and corresponding status + */ + __device__ __forceinline__ void SetInclusive(int tile_idx, KeyValuePairT tile_inclusive) + { + TileDescriptor tile_descriptor; + tile_descriptor.status = SCAN_TILE_INCLUSIVE; + tile_descriptor.value = tile_inclusive.value; + tile_descriptor.key = tile_inclusive.key; + + TxnWord alias; + *reinterpret_cast(&alias) = tile_descriptor; + ThreadStore(reinterpret_cast(d_tile_status + TILE_STATUS_PADDING + tile_idx), alias); + } + + + /** + * Update the specified tile's partial value and corresponding status + */ + __device__ __forceinline__ void SetPartial(int tile_idx, KeyValuePairT tile_partial) + { + TileDescriptor tile_descriptor; + tile_descriptor.status = SCAN_TILE_PARTIAL; + tile_descriptor.value = tile_partial.value; + tile_descriptor.key = tile_partial.key; + + TxnWord alias; + *reinterpret_cast(&alias) = tile_descriptor; + ThreadStore(reinterpret_cast(d_tile_status + TILE_STATUS_PADDING + tile_idx), alias); + } + + /** + * Wait for the corresponding tile to become non-invalid + */ + __device__ __forceinline__ void WaitForValid( + int tile_idx, + StatusWord &status, + KeyValuePairT &value) + { + // Use warp-any to determine when all threads have valid status + TxnWord alias = ThreadLoad(reinterpret_cast(d_tile_status + TILE_STATUS_PADDING + tile_idx)); + TileDescriptor tile_descriptor = reinterpret_cast(alias); + + while (tile_descriptor.status == SCAN_TILE_INVALID) + { + alias = ThreadLoad(reinterpret_cast(d_tile_status + TILE_STATUS_PADDING + tile_idx)); + tile_descriptor = reinterpret_cast(alias); + } + + status = tile_descriptor.status; + value.value = tile_descriptor.value; + value.key = tile_descriptor.key; + } + +}; + + +/****************************************************************************** + * Prefix call-back operator for coupling local block scan within a + * block-cooperative scan + ******************************************************************************/ + +/** + * Stateful block-scan prefix functor. Provides the the running prefix for + * the current tile by using the call-back warp to wait on on + * aggregates/prefixes from predecessor tiles to become available. + */ +template < + typename T, + typename ScanOpT, + typename ScanTileStateT> +struct TilePrefixCallbackOp +{ + // Parameterized warp reduce + typedef WarpReduce WarpReduceT; + + // Temporary storage type + struct _TempStorage + { + typename WarpReduceT::TempStorage warp_reduce; + T exclusive_prefix; + T inclusive_prefix; + }; + + // Alias wrapper allowing temporary storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + // Type of status word + typedef typename ScanTileStateT::StatusWord StatusWord; + + // Fields + _TempStorage& temp_storage; ///< Reference to a warp-reduction instance + ScanTileStateT& tile_status; ///< Interface to tile status + ScanOpT scan_op; ///< Binary scan operator + int tile_idx; ///< The current tile index + T exclusive_prefix; ///< Exclusive prefix for the tile + T inclusive_prefix; ///< Inclusive prefix for the tile + + // Constructor + __device__ __forceinline__ + TilePrefixCallbackOp( + ScanTileStateT &tile_status, + TempStorage &temp_storage, + ScanOpT scan_op, + int tile_idx) + : + tile_status(tile_status), + temp_storage(temp_storage.Alias()), + scan_op(scan_op), + tile_idx(tile_idx) {} + + + // Block until all predecessors within the warp-wide window have non-invalid status + __device__ __forceinline__ + void ProcessWindow( + int predecessor_idx, ///< Preceding tile index to inspect + StatusWord &predecessor_status, ///< [out] Preceding tile status + T &window_aggregate) ///< [out] Relevant partial reduction from this window of preceding tiles + { + T value; + tile_status.WaitForValid(predecessor_idx, predecessor_status, value); + + // Perform a segmented reduction to get the prefix for the current window. + // Use the swizzled scan operator because we are now scanning *down* towards thread0. + + int tail_flag = (predecessor_status == StatusWord(SCAN_TILE_INCLUSIVE)); + window_aggregate = WarpReduceT(temp_storage.warp_reduce).TailSegmentedReduce( + value, + tail_flag, + SwizzleScanOp(scan_op)); + } + + + // BlockScan prefix callback functor (called by the first warp) + __device__ __forceinline__ + T operator()(T block_aggregate) + { + // Update our status with our tile-aggregate + if (threadIdx.x == 0) + { + tile_status.SetPartial(tile_idx, block_aggregate); + } + + int predecessor_idx = tile_idx - threadIdx.x - 1; + StatusWord predecessor_status; + T window_aggregate; + + // Wait for the warp-wide window of predecessor tiles to become valid + ProcessWindow(predecessor_idx, predecessor_status, window_aggregate); + + // The exclusive tile prefix starts out as the current window aggregate + exclusive_prefix = window_aggregate; + + // Keep sliding the window back until we come across a tile whose inclusive prefix is known + while (WarpAll(predecessor_status != StatusWord(SCAN_TILE_INCLUSIVE))) + { + predecessor_idx -= CUB_PTX_WARP_THREADS; + + // Update exclusive tile prefix with the window prefix + ProcessWindow(predecessor_idx, predecessor_status, window_aggregate); + exclusive_prefix = scan_op(window_aggregate, exclusive_prefix); + } + + // Compute the inclusive tile prefix and update the status for this tile + if (threadIdx.x == 0) + { + inclusive_prefix = scan_op(exclusive_prefix, block_aggregate); + tile_status.SetInclusive(tile_idx, inclusive_prefix); + + temp_storage.exclusive_prefix = exclusive_prefix; + temp_storage.inclusive_prefix = inclusive_prefix; + } + + // Return exclusive_prefix + return exclusive_prefix; + } + + // Get the exclusive prefix stored in temporary storage + __device__ __forceinline__ + T GetExclusivePrefix() + { + return temp_storage.exclusive_prefix; + } + + // Get the inclusive prefix stored in temporary storage + __device__ __forceinline__ + T GetInclusivePrefix() + { + return temp_storage.inclusive_prefix; + } + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/block_discontinuity.cuh b/3rdparty/cub/cub/block/block_discontinuity.cuh new file mode 100644 index 00000000000..f0691eb4fa1 --- /dev/null +++ b/3rdparty/cub/cub/block/block_discontinuity.cuh @@ -0,0 +1,1148 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * The cub::BlockDiscontinuity class provides [collective](index.html#sec0) methods for flagging discontinuities within an ordered set of items partitioned across a CUDA thread block. + */ + +#pragma once + +#include "../util_type.cuh" +#include "../util_ptx.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \brief The BlockDiscontinuity class provides [collective](index.html#sec0) methods for flagging discontinuities within an ordered set of items partitioned across a CUDA thread block. ![](discont_logo.png) + * \ingroup BlockModule + * + * \tparam T The data type to be flagged. + * \tparam BLOCK_DIM_X The thread block length in threads along the X dimension + * \tparam BLOCK_DIM_Y [optional] The thread block length in threads along the Y dimension (default: 1) + * \tparam BLOCK_DIM_Z [optional] The thread block length in threads along the Z dimension (default: 1) + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * - A set of "head flags" (or "tail flags") is often used to indicate corresponding items + * that differ from their predecessors (or successors). For example, head flags are convenient + * for demarcating disjoint data segments as part of a segmented scan or reduction. + * - \blocked + * + * \par Performance Considerations + * - \granularity + * + * \par A Simple Example + * \blockcollective{BlockDiscontinuity} + * \par + * The code snippet below illustrates the head flagging of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockDiscontinuity for a 1D block of 128 threads on type int + * typedef cub::BlockDiscontinuity BlockDiscontinuity; + * + * // Allocate shared memory for BlockDiscontinuity + * __shared__ typename BlockDiscontinuity::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute head flags for discontinuities in the segment + * int head_flags[4]; + * BlockDiscontinuity(temp_storage).FlagHeads(head_flags, thread_data, cub::Inequality()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [0,0,1,1], [1,1,1,1], [2,3,3,3], [3,4,4,4], ... }. + * The corresponding output \p head_flags in those threads will be + * { [1,0,1,0], [0,0,0,0], [1,1,0,0], [0,1,0,0], ... }. + * + * \par Performance Considerations + * - Incurs zero bank conflicts for most types + * + */ +template < + typename T, + int BLOCK_DIM_X, + int BLOCK_DIM_Y = 1, + int BLOCK_DIM_Z = 1, + int PTX_ARCH = CUB_PTX_ARCH> +class BlockDiscontinuity +{ +private: + + /****************************************************************************** + * Constants and type definitions + ******************************************************************************/ + + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + }; + + + /// Shared memory storage layout type (last element from each thread's input) + struct _TempStorage + { + T first_items[BLOCK_THREADS]; + T last_items[BLOCK_THREADS]; + }; + + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + /// Internal storage allocator + __device__ __forceinline__ _TempStorage& PrivateStorage() + { + __shared__ _TempStorage private_storage; + return private_storage; + } + + + /// Specialization for when FlagOp has third index param + template ::HAS_PARAM> + struct ApplyOp + { + // Apply flag operator + static __device__ __forceinline__ bool FlagT(FlagOp flag_op, const T &a, const T &b, int idx) + { + return flag_op(a, b, idx); + } + }; + + /// Specialization for when FlagOp does not have a third index param + template + struct ApplyOp + { + // Apply flag operator + static __device__ __forceinline__ bool FlagT(FlagOp flag_op, const T &a, const T &b, int idx) + { + return flag_op(a, b); + } + }; + + /// Templated unrolling of item comparison (inductive case) + template + struct Iterate + { + // Head flags + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + static __device__ __forceinline__ void FlagHeads( + int linear_tid, + FlagT (&flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&preds)[ITEMS_PER_THREAD], ///< [out] Calling thread's predecessor items + FlagOp flag_op) ///< [in] Binary boolean flag predicate + { + preds[ITERATION] = input[ITERATION - 1]; + + flags[ITERATION] = ApplyOp::FlagT( + flag_op, + preds[ITERATION], + input[ITERATION], + (linear_tid * ITEMS_PER_THREAD) + ITERATION); + + Iterate::FlagHeads(linear_tid, flags, input, preds, flag_op); + } + + // Tail flags + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + static __device__ __forceinline__ void FlagTails( + int linear_tid, + FlagT (&flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + FlagOp flag_op) ///< [in] Binary boolean flag predicate + { + flags[ITERATION] = ApplyOp::FlagT( + flag_op, + input[ITERATION], + input[ITERATION + 1], + (linear_tid * ITEMS_PER_THREAD) + ITERATION + 1); + + Iterate::FlagTails(linear_tid, flags, input, flag_op); + } + + }; + + /// Templated unrolling of item comparison (termination case) + template + struct Iterate + { + // Head flags + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + static __device__ __forceinline__ void FlagHeads( + int linear_tid, + FlagT (&flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&preds)[ITEMS_PER_THREAD], ///< [out] Calling thread's predecessor items + FlagOp flag_op) ///< [in] Binary boolean flag predicate + {} + + // Tail flags + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + static __device__ __forceinline__ void FlagTails( + int linear_tid, + FlagT (&flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + FlagOp flag_op) ///< [in] Binary boolean flag predicate + {} + }; + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Shared storage reference + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + +public: + + /// \smemstorage{BlockDiscontinuity} + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + /** + * \brief Collective constructor using a private static allocation of shared memory as temporary storage. + */ + __device__ __forceinline__ BlockDiscontinuity() + : + temp_storage(PrivateStorage()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. + */ + __device__ __forceinline__ BlockDiscontinuity( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + //@} end member group + /******************************************************************//** + * \name Head flag operations + *********************************************************************/ + //@{ + + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + __device__ __forceinline__ void FlagHeads( + FlagT (&head_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&preds)[ITEMS_PER_THREAD], ///< [out] Calling thread's predecessor items + FlagOp flag_op) ///< [in] Binary boolean flag predicate + { + // Share last item + temp_storage.last_items[linear_tid] = input[ITEMS_PER_THREAD - 1]; + + __syncthreads(); + + if (linear_tid == 0) + { + // Set flag for first thread-item (preds[0] is undefined) + head_flags[0] = 1; + } + else + { + preds[0] = temp_storage.last_items[linear_tid - 1]; + head_flags[0] = ApplyOp::FlagT(flag_op, preds[0], input[0], linear_tid * ITEMS_PER_THREAD); + } + + // Set head_flags for remaining items + Iterate<1, ITEMS_PER_THREAD>::FlagHeads(linear_tid, head_flags, input, preds, flag_op); + } + + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + __device__ __forceinline__ void FlagHeads( + FlagT (&head_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&preds)[ITEMS_PER_THREAD], ///< [out] Calling thread's predecessor items + FlagOp flag_op, ///< [in] Binary boolean flag predicate + T tile_predecessor_item) ///< [in] [thread0 only] Item with which to compare the first tile item (input0 from thread0). + { + // Share last item + temp_storage.last_items[linear_tid] = input[ITEMS_PER_THREAD - 1]; + + __syncthreads(); + + // Set flag for first thread-item + preds[0] = (linear_tid == 0) ? + tile_predecessor_item : // First thread + temp_storage.last_items[linear_tid - 1]; + + head_flags[0] = ApplyOp::FlagT(flag_op, preds[0], input[0], linear_tid * ITEMS_PER_THREAD); + + // Set head_flags for remaining items + Iterate<1, ITEMS_PER_THREAD>::FlagHeads(linear_tid, head_flags, input, preds, flag_op); + } + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + + /** + * \brief Sets head flags indicating discontinuities between items partitioned across the thread block, for which the first item has no reference and is always flagged. + * + * \par + * - The flag head_flagsi is set for item + * inputi when + * flag_op(previous-item, inputi) + * returns \p true (where previous-item is either the preceding item + * in the same thread or the last item in the previous thread). + * - For thread0, item input0 is always flagged. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the head-flagging of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockDiscontinuity for a 1D block of 128 threads on type int + * typedef cub::BlockDiscontinuity BlockDiscontinuity; + * + * // Allocate shared memory for BlockDiscontinuity + * __shared__ typename BlockDiscontinuity::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute head flags for discontinuities in the segment + * int head_flags[4]; + * BlockDiscontinuity(temp_storage).FlagHeads(head_flags, thread_data, cub::Inequality()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [0,0,1,1], [1,1,1,1], [2,3,3,3], [3,4,4,4], ... }. + * The corresponding output \p head_flags in those threads will be + * { [1,0,1,0], [0,0,0,0], [1,1,0,0], [0,1,0,0], ... }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam FlagT [inferred] The flag type (must be an integer type) + * \tparam FlagOp [inferred] Binary predicate functor type having member T operator()(const T &a, const T &b) or member T operator()(const T &a, const T &b, unsigned int b_index), and returning \p true if a discontinuity exists between \p a and \p b, otherwise \p false. \p b_index is the rank of b in the aggregate tile of data. + */ + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + __device__ __forceinline__ void FlagHeads( + FlagT (&head_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + FlagOp flag_op) ///< [in] Binary boolean flag predicate + { + T preds[ITEMS_PER_THREAD]; + FlagHeads(head_flags, input, preds, flag_op); + } + + + /** + * \brief Sets head flags indicating discontinuities between items partitioned across the thread block. + * + * \par + * - The flag head_flagsi is set for item + * inputi when + * flag_op(previous-item, inputi) + * returns \p true (where previous-item is either the preceding item + * in the same thread or the last item in the previous thread). + * - For thread0, item input0 is compared + * against \p tile_predecessor_item. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the head-flagging of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockDiscontinuity for a 1D block of 128 threads on type int + * typedef cub::BlockDiscontinuity BlockDiscontinuity; + * + * // Allocate shared memory for BlockDiscontinuity + * __shared__ typename BlockDiscontinuity::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Have thread0 obtain the predecessor item for the entire tile + * int tile_predecessor_item; + * if (threadIdx.x == 0) tile_predecessor_item == ... + * + * // Collectively compute head flags for discontinuities in the segment + * int head_flags[4]; + * BlockDiscontinuity(temp_storage).FlagHeads( + * head_flags, thread_data, cub::Inequality(), tile_predecessor_item); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [0,0,1,1], [1,1,1,1], [2,3,3,3], [3,4,4,4], ... }, + * and that \p tile_predecessor_item is \p 0. The corresponding output \p head_flags in those threads will be + * { [0,0,1,0], [0,0,0,0], [1,1,0,0], [0,1,0,0], ... }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam FlagT [inferred] The flag type (must be an integer type) + * \tparam FlagOp [inferred] Binary predicate functor type having member T operator()(const T &a, const T &b) or member T operator()(const T &a, const T &b, unsigned int b_index), and returning \p true if a discontinuity exists between \p a and \p b, otherwise \p false. \p b_index is the rank of b in the aggregate tile of data. + */ + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + __device__ __forceinline__ void FlagHeads( + FlagT (&head_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + FlagOp flag_op, ///< [in] Binary boolean flag predicate + T tile_predecessor_item) ///< [in] [thread0 only] Item with which to compare the first tile item (input0 from thread0). + { + T preds[ITEMS_PER_THREAD]; + FlagHeads(head_flags, input, preds, flag_op, tile_predecessor_item); + } + + + + //@} end member group + /******************************************************************//** + * \name Tail flag operations + *********************************************************************/ + //@{ + + + /** + * \brief Sets tail flags indicating discontinuities between items partitioned across the thread block, for which the last item has no reference and is always flagged. + * + * \par + * - The flag tail_flagsi is set for item + * inputi when + * flag_op(inputi, next-item) + * returns \p true (where next-item is either the next item + * in the same thread or the first item in the next thread). + * - For threadBLOCK_THREADS-1, item + * inputITEMS_PER_THREAD-1 is always flagged. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the tail-flagging of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockDiscontinuity for a 1D block of 128 threads on type int + * typedef cub::BlockDiscontinuity BlockDiscontinuity; + * + * // Allocate shared memory for BlockDiscontinuity + * __shared__ typename BlockDiscontinuity::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute tail flags for discontinuities in the segment + * int tail_flags[4]; + * BlockDiscontinuity(temp_storage).FlagTails(tail_flags, thread_data, cub::Inequality()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [0,0,1,1], [1,1,1,1], [2,3,3,3], ..., [124,125,125,125] }. + * The corresponding output \p tail_flags in those threads will be + * { [0,1,0,0], [0,0,0,1], [1,0,0,...], ..., [1,0,0,1] }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam FlagT [inferred] The flag type (must be an integer type) + * \tparam FlagOp [inferred] Binary predicate functor type having member T operator()(const T &a, const T &b) or member T operator()(const T &a, const T &b, unsigned int b_index), and returning \p true if a discontinuity exists between \p a and \p b, otherwise \p false. \p b_index is the rank of b in the aggregate tile of data. + */ + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + __device__ __forceinline__ void FlagTails( + FlagT (&tail_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity tail_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + FlagOp flag_op) ///< [in] Binary boolean flag predicate + { + // Share first item + temp_storage.first_items[linear_tid] = input[0]; + + __syncthreads(); + + // Set flag for last thread-item + tail_flags[ITEMS_PER_THREAD - 1] = (linear_tid == BLOCK_THREADS - 1) ? + 1 : // Last thread + ApplyOp::FlagT( + flag_op, + input[ITEMS_PER_THREAD - 1], + temp_storage.first_items[linear_tid + 1], + (linear_tid * ITEMS_PER_THREAD) + ITEMS_PER_THREAD); + + // Set tail_flags for remaining items + Iterate<0, ITEMS_PER_THREAD - 1>::FlagTails(linear_tid, tail_flags, input, flag_op); + } + + + /** + * \brief Sets tail flags indicating discontinuities between items partitioned across the thread block. + * + * \par + * - The flag tail_flagsi is set for item + * inputi when + * flag_op(inputi, next-item) + * returns \p true (where next-item is either the next item + * in the same thread or the first item in the next thread). + * - For threadBLOCK_THREADS-1, item + * inputITEMS_PER_THREAD-1 is compared + * against \p tile_successor_item. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the tail-flagging of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockDiscontinuity for a 1D block of 128 threads on type int + * typedef cub::BlockDiscontinuity BlockDiscontinuity; + * + * // Allocate shared memory for BlockDiscontinuity + * __shared__ typename BlockDiscontinuity::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Have thread127 obtain the successor item for the entire tile + * int tile_successor_item; + * if (threadIdx.x == 127) tile_successor_item == ... + * + * // Collectively compute tail flags for discontinuities in the segment + * int tail_flags[4]; + * BlockDiscontinuity(temp_storage).FlagTails( + * tail_flags, thread_data, cub::Inequality(), tile_successor_item); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [0,0,1,1], [1,1,1,1], [2,3,3,3], ..., [124,125,125,125] } + * and that \p tile_successor_item is \p 125. The corresponding output \p tail_flags in those threads will be + * { [0,1,0,0], [0,0,0,1], [1,0,0,...], ..., [1,0,0,0] }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam FlagT [inferred] The flag type (must be an integer type) + * \tparam FlagOp [inferred] Binary predicate functor type having member T operator()(const T &a, const T &b) or member T operator()(const T &a, const T &b, unsigned int b_index), and returning \p true if a discontinuity exists between \p a and \p b, otherwise \p false. \p b_index is the rank of b in the aggregate tile of data. + */ + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + __device__ __forceinline__ void FlagTails( + FlagT (&tail_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity tail_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + FlagOp flag_op, ///< [in] Binary boolean flag predicate + T tile_successor_item) ///< [in] [threadBLOCK_THREADS-1 only] Item with which to compare the last tile item (inputITEMS_PER_THREAD-1 from threadBLOCK_THREADS-1). + { + // Share first item + temp_storage.first_items[linear_tid] = input[0]; + + __syncthreads(); + + // Set flag for last thread-item + T successor_item = (linear_tid == BLOCK_THREADS - 1) ? + tile_successor_item : // Last thread + temp_storage.first_items[linear_tid + 1]; + + tail_flags[ITEMS_PER_THREAD - 1] = ApplyOp::FlagT( + flag_op, + input[ITEMS_PER_THREAD - 1], + successor_item, + (linear_tid * ITEMS_PER_THREAD) + ITEMS_PER_THREAD); + + // Set tail_flags for remaining items + Iterate<0, ITEMS_PER_THREAD - 1>::FlagTails(linear_tid, tail_flags, input, flag_op); + } + + + //@} end member group + /******************************************************************//** + * \name Head & tail flag operations + *********************************************************************/ + //@{ + + + /** + * \brief Sets both head and tail flags indicating discontinuities between items partitioned across the thread block. + * + * \par + * - The flag head_flagsi is set for item + * inputi when + * flag_op(previous-item, inputi) + * returns \p true (where previous-item is either the preceding item + * in the same thread or the last item in the previous thread). + * - For thread0, item input0 is always flagged. + * - The flag tail_flagsi is set for item + * inputi when + * flag_op(inputi, next-item) + * returns \p true (where next-item is either the next item + * in the same thread or the first item in the next thread). + * - For threadBLOCK_THREADS-1, item + * inputITEMS_PER_THREAD-1 is always flagged. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the head- and tail-flagging of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockDiscontinuity for a 1D block of 128 threads on type int + * typedef cub::BlockDiscontinuity BlockDiscontinuity; + * + * // Allocate shared memory for BlockDiscontinuity + * __shared__ typename BlockDiscontinuity::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute head and flags for discontinuities in the segment + * int head_flags[4]; + * int tail_flags[4]; + * BlockDiscontinuity(temp_storage).FlagTails( + * head_flags, tail_flags, thread_data, cub::Inequality()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [0,0,1,1], [1,1,1,1], [2,3,3,3], ..., [124,125,125,125] } + * and that the tile_successor_item is \p 125. The corresponding output \p head_flags + * in those threads will be { [1,0,1,0], [0,0,0,0], [1,1,0,0], [0,1,0,0], ... }. + * and the corresponding output \p tail_flags in those threads will be + * { [0,1,0,0], [0,0,0,1], [1,0,0,...], ..., [1,0,0,1] }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam FlagT [inferred] The flag type (must be an integer type) + * \tparam FlagOp [inferred] Binary predicate functor type having member T operator()(const T &a, const T &b) or member T operator()(const T &a, const T &b, unsigned int b_index), and returning \p true if a discontinuity exists between \p a and \p b, otherwise \p false. \p b_index is the rank of b in the aggregate tile of data. + */ + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + __device__ __forceinline__ void FlagHeadsAndTails( + FlagT (&head_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + FlagT (&tail_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity tail_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + FlagOp flag_op) ///< [in] Binary boolean flag predicate + { + // Share first and last items + temp_storage.first_items[linear_tid] = input[0]; + temp_storage.last_items[linear_tid] = input[ITEMS_PER_THREAD - 1]; + + __syncthreads(); + + T preds[ITEMS_PER_THREAD]; + + // Set flag for first thread-item + preds[0] = temp_storage.last_items[linear_tid - 1]; + if (linear_tid == 0) + { + head_flags[0] = 1; + } + else + { + head_flags[0] = ApplyOp::FlagT( + flag_op, + preds[0], + input[0], + linear_tid * ITEMS_PER_THREAD); + } + + + // Set flag for last thread-item + tail_flags[ITEMS_PER_THREAD - 1] = (linear_tid == BLOCK_THREADS - 1) ? + 1 : // Last thread + ApplyOp::FlagT( + flag_op, + input[ITEMS_PER_THREAD - 1], + temp_storage.first_items[linear_tid + 1], + (linear_tid * ITEMS_PER_THREAD) + ITEMS_PER_THREAD); + + // Set head_flags for remaining items + Iterate<1, ITEMS_PER_THREAD>::FlagHeads(linear_tid, head_flags, input, preds, flag_op); + + // Set tail_flags for remaining items + Iterate<0, ITEMS_PER_THREAD - 1>::FlagTails(linear_tid, tail_flags, input, flag_op); + } + + + /** + * \brief Sets both head and tail flags indicating discontinuities between items partitioned across the thread block. + * + * \par + * - The flag head_flagsi is set for item + * inputi when + * flag_op(previous-item, inputi) + * returns \p true (where previous-item is either the preceding item + * in the same thread or the last item in the previous thread). + * - For thread0, item input0 is always flagged. + * - The flag tail_flagsi is set for item + * inputi when + * flag_op(inputi, next-item) + * returns \p true (where next-item is either the next item + * in the same thread or the first item in the next thread). + * - For threadBLOCK_THREADS-1, item + * inputITEMS_PER_THREAD-1 is compared + * against \p tile_predecessor_item. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the head- and tail-flagging of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockDiscontinuity for a 1D block of 128 threads on type int + * typedef cub::BlockDiscontinuity BlockDiscontinuity; + * + * // Allocate shared memory for BlockDiscontinuity + * __shared__ typename BlockDiscontinuity::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Have thread127 obtain the successor item for the entire tile + * int tile_successor_item; + * if (threadIdx.x == 127) tile_successor_item == ... + * + * // Collectively compute head and flags for discontinuities in the segment + * int head_flags[4]; + * int tail_flags[4]; + * BlockDiscontinuity(temp_storage).FlagTails( + * head_flags, tail_flags, tile_successor_item, thread_data, cub::Inequality()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [0,0,1,1], [1,1,1,1], [2,3,3,3], ..., [124,125,125,125] } + * and that the tile_successor_item is \p 125. The corresponding output \p head_flags + * in those threads will be { [1,0,1,0], [0,0,0,0], [1,1,0,0], [0,1,0,0], ... }. + * and the corresponding output \p tail_flags in those threads will be + * { [0,1,0,0], [0,0,0,1], [1,0,0,...], ..., [1,0,0,0] }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam FlagT [inferred] The flag type (must be an integer type) + * \tparam FlagOp [inferred] Binary predicate functor type having member T operator()(const T &a, const T &b) or member T operator()(const T &a, const T &b, unsigned int b_index), and returning \p true if a discontinuity exists between \p a and \p b, otherwise \p false. \p b_index is the rank of b in the aggregate tile of data. + */ + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + __device__ __forceinline__ void FlagHeadsAndTails( + FlagT (&head_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + FlagT (&tail_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity tail_flags + T tile_successor_item, ///< [in] [threadBLOCK_THREADS-1 only] Item with which to compare the last tile item (inputITEMS_PER_THREAD-1 from threadBLOCK_THREADS-1). + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + FlagOp flag_op) ///< [in] Binary boolean flag predicate + { + // Share first and last items + temp_storage.first_items[linear_tid] = input[0]; + temp_storage.last_items[linear_tid] = input[ITEMS_PER_THREAD - 1]; + + __syncthreads(); + + T preds[ITEMS_PER_THREAD]; + + // Set flag for first thread-item + if (linear_tid == 0) + { + head_flags[0] = 1; + } + else + { + preds[0] = temp_storage.last_items[linear_tid - 1]; + head_flags[0] = ApplyOp::FlagT( + flag_op, + preds[0], + input[0], + linear_tid * ITEMS_PER_THREAD); + } + + // Set flag for last thread-item + T successor_item = (linear_tid == BLOCK_THREADS - 1) ? + tile_successor_item : // Last thread + temp_storage.first_items[linear_tid + 1]; + + tail_flags[ITEMS_PER_THREAD - 1] = ApplyOp::FlagT( + flag_op, + input[ITEMS_PER_THREAD - 1], + successor_item, + (linear_tid * ITEMS_PER_THREAD) + ITEMS_PER_THREAD); + + // Set head_flags for remaining items + Iterate<1, ITEMS_PER_THREAD>::FlagHeads(linear_tid, head_flags, input, preds, flag_op); + + // Set tail_flags for remaining items + Iterate<0, ITEMS_PER_THREAD - 1>::FlagTails(linear_tid, tail_flags, input, flag_op); + } + + + /** + * \brief Sets both head and tail flags indicating discontinuities between items partitioned across the thread block. + * + * \par + * - The flag head_flagsi is set for item + * inputi when + * flag_op(previous-item, inputi) + * returns \p true (where previous-item is either the preceding item + * in the same thread or the last item in the previous thread). + * - For thread0, item input0 is compared + * against \p tile_predecessor_item. + * - The flag tail_flagsi is set for item + * inputi when + * flag_op(inputi, next-item) + * returns \p true (where next-item is either the next item + * in the same thread or the first item in the next thread). + * - For threadBLOCK_THREADS-1, item + * inputITEMS_PER_THREAD-1 is always flagged. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the head- and tail-flagging of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockDiscontinuity for a 1D block of 128 threads on type int + * typedef cub::BlockDiscontinuity BlockDiscontinuity; + * + * // Allocate shared memory for BlockDiscontinuity + * __shared__ typename BlockDiscontinuity::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Have thread0 obtain the predecessor item for the entire tile + * int tile_predecessor_item; + * if (threadIdx.x == 0) tile_predecessor_item == ... + * + * // Have thread127 obtain the successor item for the entire tile + * int tile_successor_item; + * if (threadIdx.x == 127) tile_successor_item == ... + * + * // Collectively compute head and flags for discontinuities in the segment + * int head_flags[4]; + * int tail_flags[4]; + * BlockDiscontinuity(temp_storage).FlagTails( + * head_flags, tile_predecessor_item, tail_flags, tile_successor_item, + * thread_data, cub::Inequality()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [0,0,1,1], [1,1,1,1], [2,3,3,3], ..., [124,125,125,125] }, + * that the \p tile_predecessor_item is \p 0, and that the + * \p tile_successor_item is \p 125. The corresponding output \p head_flags + * in those threads will be { [0,0,1,0], [0,0,0,0], [1,1,0,0], [0,1,0,0], ... }. + * and the corresponding output \p tail_flags in those threads will be + * { [0,1,0,0], [0,0,0,1], [1,0,0,...], ..., [1,0,0,1] }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam FlagT [inferred] The flag type (must be an integer type) + * \tparam FlagOp [inferred] Binary predicate functor type having member T operator()(const T &a, const T &b) or member T operator()(const T &a, const T &b, unsigned int b_index), and returning \p true if a discontinuity exists between \p a and \p b, otherwise \p false. \p b_index is the rank of b in the aggregate tile of data. + */ + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + __device__ __forceinline__ void FlagHeadsAndTails( + FlagT (&head_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + T tile_predecessor_item, ///< [in] [thread0 only] Item with which to compare the first tile item (input0 from thread0). + FlagT (&tail_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity tail_flags + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + FlagOp flag_op) ///< [in] Binary boolean flag predicate + { + // Share first and last items + temp_storage.first_items[linear_tid] = input[0]; + temp_storage.last_items[linear_tid] = input[ITEMS_PER_THREAD - 1]; + + __syncthreads(); + + T preds[ITEMS_PER_THREAD]; + + // Set flag for first thread-item + preds[0] = (linear_tid == 0) ? + tile_predecessor_item : // First thread + temp_storage.last_items[linear_tid - 1]; + + head_flags[0] = ApplyOp::FlagT( + flag_op, + preds[0], + input[0], + linear_tid * ITEMS_PER_THREAD); + + // Set flag for last thread-item + tail_flags[ITEMS_PER_THREAD - 1] = (linear_tid == BLOCK_THREADS - 1) ? + 1 : // Last thread + ApplyOp::FlagT( + flag_op, + input[ITEMS_PER_THREAD - 1], + temp_storage.first_items[linear_tid + 1], + (linear_tid * ITEMS_PER_THREAD) + ITEMS_PER_THREAD); + + // Set head_flags for remaining items + Iterate<1, ITEMS_PER_THREAD>::FlagHeads(linear_tid, head_flags, input, preds, flag_op); + + // Set tail_flags for remaining items + Iterate<0, ITEMS_PER_THREAD - 1>::FlagTails(linear_tid, tail_flags, input, flag_op); + } + + + /** + * \brief Sets both head and tail flags indicating discontinuities between items partitioned across the thread block. + * + * \par + * - The flag head_flagsi is set for item + * inputi when + * flag_op(previous-item, inputi) + * returns \p true (where previous-item is either the preceding item + * in the same thread or the last item in the previous thread). + * - For thread0, item input0 is compared + * against \p tile_predecessor_item. + * - The flag tail_flagsi is set for item + * inputi when + * flag_op(inputi, next-item) + * returns \p true (where next-item is either the next item + * in the same thread or the first item in the next thread). + * - For threadBLOCK_THREADS-1, item + * inputITEMS_PER_THREAD-1 is compared + * against \p tile_successor_item. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the head- and tail-flagging of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockDiscontinuity for a 1D block of 128 threads on type int + * typedef cub::BlockDiscontinuity BlockDiscontinuity; + * + * // Allocate shared memory for BlockDiscontinuity + * __shared__ typename BlockDiscontinuity::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Have thread0 obtain the predecessor item for the entire tile + * int tile_predecessor_item; + * if (threadIdx.x == 0) tile_predecessor_item == ... + * + * // Have thread127 obtain the successor item for the entire tile + * int tile_successor_item; + * if (threadIdx.x == 127) tile_successor_item == ... + * + * // Collectively compute head and flags for discontinuities in the segment + * int head_flags[4]; + * int tail_flags[4]; + * BlockDiscontinuity(temp_storage).FlagTails( + * head_flags, tile_predecessor_item, tail_flags, tile_successor_item, + * thread_data, cub::Inequality()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [0,0,1,1], [1,1,1,1], [2,3,3,3], ..., [124,125,125,125] }, + * that the \p tile_predecessor_item is \p 0, and that the + * \p tile_successor_item is \p 125. The corresponding output \p head_flags + * in those threads will be { [0,0,1,0], [0,0,0,0], [1,1,0,0], [0,1,0,0], ... }. + * and the corresponding output \p tail_flags in those threads will be + * { [0,1,0,0], [0,0,0,1], [1,0,0,...], ..., [1,0,0,0] }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam FlagT [inferred] The flag type (must be an integer type) + * \tparam FlagOp [inferred] Binary predicate functor type having member T operator()(const T &a, const T &b) or member T operator()(const T &a, const T &b, unsigned int b_index), and returning \p true if a discontinuity exists between \p a and \p b, otherwise \p false. \p b_index is the rank of b in the aggregate tile of data. + */ + template < + int ITEMS_PER_THREAD, + typename FlagT, + typename FlagOp> + __device__ __forceinline__ void FlagHeadsAndTails( + FlagT (&head_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity head_flags + T tile_predecessor_item, ///< [in] [thread0 only] Item with which to compare the first tile item (input0 from thread0). + FlagT (&tail_flags)[ITEMS_PER_THREAD], ///< [out] Calling thread's discontinuity tail_flags + T tile_successor_item, ///< [in] [threadBLOCK_THREADS-1 only] Item with which to compare the last tile item (inputITEMS_PER_THREAD-1 from threadBLOCK_THREADS-1). + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + FlagOp flag_op) ///< [in] Binary boolean flag predicate + { + // Share first and last items + temp_storage.first_items[linear_tid] = input[0]; + temp_storage.last_items[linear_tid] = input[ITEMS_PER_THREAD - 1]; + + __syncthreads(); + + T preds[ITEMS_PER_THREAD]; + + // Set flag for first thread-item + preds[0] = (linear_tid == 0) ? + tile_predecessor_item : // First thread + temp_storage.last_items[linear_tid - 1]; + + head_flags[0] = ApplyOp::FlagT( + flag_op, + preds[0], + input[0], + linear_tid * ITEMS_PER_THREAD); + + // Set flag for last thread-item + T successor_item = (linear_tid == BLOCK_THREADS - 1) ? + tile_successor_item : // Last thread + temp_storage.first_items[linear_tid + 1]; + + tail_flags[ITEMS_PER_THREAD - 1] = ApplyOp::FlagT( + flag_op, + input[ITEMS_PER_THREAD - 1], + successor_item, + (linear_tid * ITEMS_PER_THREAD) + ITEMS_PER_THREAD); + + // Set head_flags for remaining items + Iterate<1, ITEMS_PER_THREAD>::FlagHeads(linear_tid, head_flags, input, preds, flag_op); + + // Set tail_flags for remaining items + Iterate<0, ITEMS_PER_THREAD - 1>::FlagTails(linear_tid, tail_flags, input, flag_op); + } + + + + + //@} end member group + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/block/block_exchange.cuh b/3rdparty/cub/cub/block/block_exchange.cuh new file mode 100644 index 00000000000..b3d8d2fb704 --- /dev/null +++ b/3rdparty/cub/cub/block/block_exchange.cuh @@ -0,0 +1,1135 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * The cub::BlockExchange class provides [collective](index.html#sec0) methods for rearranging data partitioned across a CUDA thread block. + */ + +#pragma once + +#include "../util_ptx.cuh" +#include "../util_arch.cuh" +#include "../util_macro.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \brief The BlockExchange class provides [collective](index.html#sec0) methods for rearranging data partitioned across a CUDA thread block. ![](transpose_logo.png) + * \ingroup BlockModule + * + * \tparam T The data type to be exchanged. + * \tparam BLOCK_DIM_X The thread block length in threads along the X dimension + * \tparam ITEMS_PER_THREAD The number of items partitioned onto each thread. + * \tparam WARP_TIME_SLICING [optional] When \p true, only use enough shared memory for a single warp's worth of tile data, time-slicing the block-wide exchange over multiple synchronized rounds. Yields a smaller memory footprint at the expense of decreased parallelism. (Default: false) + * \tparam BLOCK_DIM_Y [optional] The thread block length in threads along the Y dimension (default: 1) + * \tparam BLOCK_DIM_Z [optional] The thread block length in threads along the Z dimension (default: 1) + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * - It is commonplace for blocks of threads to rearrange data items between + * threads. For example, the global memory subsystem prefers access patterns + * where data items are "striped" across threads (where consecutive threads access consecutive items), + * yet most block-wide operations prefer a "blocked" partitioning of items across threads + * (where consecutive items belong to a single thread). + * - BlockExchange supports the following types of data exchanges: + * - Transposing between [blocked](index.html#sec5sec3) and [striped](index.html#sec5sec3) arrangements + * - Transposing between [blocked](index.html#sec5sec3) and [warp-striped](index.html#sec5sec3) arrangements + * - Scattering ranked items to a [blocked arrangement](index.html#sec5sec3) + * - Scattering ranked items to a [striped arrangement](index.html#sec5sec3) + * - \blocked + * + * \par A Simple Example + * \blockcollective{BlockExchange} + * \par + * The code snippet below illustrates the conversion from a "blocked" to a "striped" arrangement + * of 512 integer items partitioned across 128 threads where each thread owns 4 items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, ...) + * { + * // Specialize BlockExchange for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockExchange BlockExchange; + * + * // Allocate shared memory for BlockExchange + * __shared__ typename BlockExchange::TempStorage temp_storage; + * + * // Load a tile of data striped across threads + * int thread_data[4]; + * cub::LoadDirectStriped<128>(threadIdx.x, d_data, thread_data); + * + * // Collectively exchange data into a blocked arrangement across threads + * BlockExchange(temp_storage).StripedToBlocked(thread_data); + * + * \endcode + * \par + * Suppose the set of striped input \p thread_data across the block of threads is + * { [0,128,256,384], [1,129,257,385], ..., [127,255,383,511] }. + * The corresponding output \p thread_data in those threads will be + * { [0,1,2,3], [4,5,6,7], [8,9,10,11], ..., [508,509,510,511] }. + * + * \par Performance Considerations + * - Proper device-specific padding ensures zero bank conflicts for most types. + * + */ +template < + typename T, + int BLOCK_DIM_X, + int ITEMS_PER_THREAD, + bool WARP_TIME_SLICING = false, + int BLOCK_DIM_Y = 1, + int BLOCK_DIM_Z = 1, + int PTX_ARCH = CUB_PTX_ARCH> +class BlockExchange +{ +private: + + /****************************************************************************** + * Constants + ******************************************************************************/ + + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + + LOG_WARP_THREADS = CUB_LOG_WARP_THREADS(PTX_ARCH), + WARP_THREADS = 1 << LOG_WARP_THREADS, + WARPS = (BLOCK_THREADS + WARP_THREADS - 1) / WARP_THREADS, + + LOG_SMEM_BANKS = CUB_LOG_SMEM_BANKS(PTX_ARCH), + SMEM_BANKS = 1 << LOG_SMEM_BANKS, + + TILE_ITEMS = BLOCK_THREADS * ITEMS_PER_THREAD, + + TIME_SLICES = (WARP_TIME_SLICING) ? WARPS : 1, + + TIME_SLICED_THREADS = (WARP_TIME_SLICING) ? CUB_MIN(BLOCK_THREADS, WARP_THREADS) : BLOCK_THREADS, + TIME_SLICED_ITEMS = TIME_SLICED_THREADS * ITEMS_PER_THREAD, + + WARP_TIME_SLICED_THREADS = CUB_MIN(BLOCK_THREADS, WARP_THREADS), + WARP_TIME_SLICED_ITEMS = WARP_TIME_SLICED_THREADS * ITEMS_PER_THREAD, + + // Insert padding if the number of items per thread is a power of two +// INSERT_PADDING = PowerOfTwo::VALUE, + INSERT_PADDING = 0, + PADDING_ITEMS = (INSERT_PADDING) ? (TIME_SLICED_ITEMS >> LOG_SMEM_BANKS) : 0, + }; + + /****************************************************************************** + * Type definitions + ******************************************************************************/ + + /// Shared memory storage layout type + typedef T _TempStorage[TIME_SLICED_ITEMS + PADDING_ITEMS]; + +public: + + /// \smemstorage{BlockExchange} + struct TempStorage : Uninitialized<_TempStorage> {}; + +private: + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Shared storage reference + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + int lane_id; + int warp_id; + int warp_offset; + + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + /// Internal storage allocator + __device__ __forceinline__ _TempStorage& PrivateStorage() + { + __shared__ _TempStorage private_storage; + return private_storage; + } + + + /** + * Transposes data items from blocked arrangement to striped arrangement. Specialized for no timeslicing. + */ + __device__ __forceinline__ void BlockedToStriped( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange, converting between blocked and striped arrangements. + Int2Type time_slicing) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = (linear_tid * ITEMS_PER_THREAD) + ITEM; + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_storage[item_offset] = items[ITEM]; + } + + __syncthreads(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = int(ITEM * BLOCK_THREADS) + linear_tid; + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + items[ITEM] = temp_storage[item_offset]; + } + } + + + /** + * Transposes data items from blocked arrangement to striped arrangement. Specialized for warp-timeslicing. + */ + __device__ __forceinline__ void BlockedToStriped( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange, converting between blocked and striped arrangements. + Int2Type time_slicing) + { + T temp_items[ITEMS_PER_THREAD]; + + #pragma unroll + for (int SLICE = 0; SLICE < TIME_SLICES; SLICE++) + { + const int SLICE_OFFSET = SLICE * TIME_SLICED_ITEMS; + const int SLICE_OOB = SLICE_OFFSET + TIME_SLICED_ITEMS; + + __syncthreads(); + + if (warp_id == SLICE) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = (lane_id * ITEMS_PER_THREAD) + ITEM; + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_storage[item_offset] = items[ITEM]; + } + } + + __syncthreads(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + // Read a strip of items + const int STRIP_OFFSET = ITEM * BLOCK_THREADS; + const int STRIP_OOB = STRIP_OFFSET + BLOCK_THREADS; + + if ((SLICE_OFFSET < STRIP_OOB) && (SLICE_OOB > STRIP_OFFSET)) + { + int item_offset = STRIP_OFFSET + linear_tid - SLICE_OFFSET; + if ((item_offset >= 0) && (item_offset < TIME_SLICED_ITEMS)) + { + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_items[ITEM] = temp_storage[item_offset]; + } + } + } + } + + // Copy + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + items[ITEM] = temp_items[ITEM]; + } + } + + + /** + * Transposes data items from blocked arrangement to warp-striped arrangement. Specialized for no timeslicing + */ + __device__ __forceinline__ void BlockedToWarpStriped( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange, converting between blocked and warp-striped arrangements. + Int2Type time_slicing) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = warp_offset + ITEM + (lane_id * ITEMS_PER_THREAD); + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_storage[item_offset] = items[ITEM]; + } + + __threadfence_block(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = warp_offset + (ITEM * WARP_TIME_SLICED_THREADS) + lane_id; + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + items[ITEM] = temp_storage[item_offset]; + } + } + + /** + * Transposes data items from blocked arrangement to warp-striped arrangement. Specialized for warp-timeslicing + */ + __device__ __forceinline__ void BlockedToWarpStriped( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange, converting between blocked and warp-striped arrangements. + Int2Type time_slicing) + { + if (warp_id == 0) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = ITEM + (lane_id * ITEMS_PER_THREAD); + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_storage[item_offset] = items[ITEM]; + } + + __threadfence_block(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = (ITEM * WARP_TIME_SLICED_THREADS) + lane_id; + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + items[ITEM] = temp_storage[item_offset]; + } + } + + #pragma unroll + for (int SLICE = 1; SLICE < TIME_SLICES; ++SLICE) + { + __syncthreads(); + + if (warp_id == SLICE) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = ITEM + (lane_id * ITEMS_PER_THREAD); + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_storage[item_offset] = items[ITEM]; + } + + __threadfence_block(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = (ITEM * WARP_TIME_SLICED_THREADS) + lane_id; + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + items[ITEM] = temp_storage[item_offset]; + } + } + } + } + + + /** + * Transposes data items from striped arrangement to blocked arrangement. Specialized for no timeslicing. + */ + __device__ __forceinline__ void StripedToBlocked( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange, converting between striped and blocked arrangements. + Int2Type time_slicing) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = int(ITEM * BLOCK_THREADS) + linear_tid; + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_storage[item_offset] = items[ITEM]; + } + + __syncthreads(); + + // No timeslicing + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = (linear_tid * ITEMS_PER_THREAD) + ITEM; + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + items[ITEM] = temp_storage[item_offset]; + } + } + + + /** + * Transposes data items from striped arrangement to blocked arrangement. Specialized for warp-timeslicing. + */ + __device__ __forceinline__ void StripedToBlocked( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange, converting between striped and blocked arrangements. + Int2Type time_slicing) + { + // Warp time-slicing + T temp_items[ITEMS_PER_THREAD]; + + #pragma unroll + for (int SLICE = 0; SLICE < TIME_SLICES; SLICE++) + { + const int SLICE_OFFSET = SLICE * TIME_SLICED_ITEMS; + const int SLICE_OOB = SLICE_OFFSET + TIME_SLICED_ITEMS; + + __syncthreads(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + // Write a strip of items + const int STRIP_OFFSET = ITEM * BLOCK_THREADS; + const int STRIP_OOB = STRIP_OFFSET + BLOCK_THREADS; + + if ((SLICE_OFFSET < STRIP_OOB) && (SLICE_OOB > STRIP_OFFSET)) + { + int item_offset = STRIP_OFFSET + linear_tid - SLICE_OFFSET; + if ((item_offset >= 0) && (item_offset < TIME_SLICED_ITEMS)) + { + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_storage[item_offset] = items[ITEM]; + } + } + } + + __syncthreads(); + + if (warp_id == SLICE) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = (lane_id * ITEMS_PER_THREAD) + ITEM; + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_items[ITEM] = temp_storage[item_offset]; + } + } + } + + // Copy + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + items[ITEM] = temp_items[ITEM]; + } + } + + + /** + * Transposes data items from warp-striped arrangement to blocked arrangement. Specialized for no timeslicing + */ + __device__ __forceinline__ void WarpStripedToBlocked( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange, converting between warp-striped and blocked arrangements. + Int2Type time_slicing) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = warp_offset + (ITEM * WARP_TIME_SLICED_THREADS) + lane_id; + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_storage[item_offset] = items[ITEM]; + } + + __threadfence_block(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = warp_offset + ITEM + (lane_id * ITEMS_PER_THREAD); + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + items[ITEM] = temp_storage[item_offset]; + } + } + + + /** + * Transposes data items from warp-striped arrangement to blocked arrangement. Specialized for warp-timeslicing + */ + __device__ __forceinline__ void WarpStripedToBlocked( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange, converting between warp-striped and blocked arrangements. + Int2Type time_slicing) + { + #pragma unroll + for (int SLICE = 0; SLICE < TIME_SLICES; ++SLICE) + { + __syncthreads(); + + if (warp_id == SLICE) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = (ITEM * WARP_TIME_SLICED_THREADS) + lane_id; + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_storage[item_offset] = items[ITEM]; + } + + __threadfence_block(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = ITEM + (lane_id * ITEMS_PER_THREAD); + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + items[ITEM] = temp_storage[item_offset]; + } + } + } + } + + + /** + * Exchanges data items annotated by rank into blocked arrangement. Specialized for no timeslicing. + */ + template + __device__ __forceinline__ void ScatterToBlocked( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange + OffsetT ranks[ITEMS_PER_THREAD], ///< [in] Corresponding scatter ranks + Int2Type time_slicing) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = ranks[ITEM]; + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + temp_storage[item_offset] = items[ITEM]; + } + + __syncthreads(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = (linear_tid * ITEMS_PER_THREAD) + ITEM; + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + items[ITEM] = temp_storage[item_offset]; + } + } + + /** + * Exchanges data items annotated by rank into blocked arrangement. Specialized for warp-timeslicing. + */ + template + __device__ __forceinline__ void ScatterToBlocked( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange + OffsetT ranks[ITEMS_PER_THREAD], ///< [in] Corresponding scatter ranks + Int2Type time_slicing) + { + T temp_items[ITEMS_PER_THREAD]; + + #pragma unroll + for (int SLICE = 0; SLICE < TIME_SLICES; SLICE++) + { + __syncthreads(); + + const int SLICE_OFFSET = TIME_SLICED_ITEMS * SLICE; + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = ranks[ITEM] - SLICE_OFFSET; + if ((item_offset >= 0) && (item_offset < WARP_TIME_SLICED_ITEMS)) + { + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + temp_storage[item_offset] = items[ITEM]; + } + } + + __syncthreads(); + + if (warp_id == SLICE) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = (lane_id * ITEMS_PER_THREAD) + ITEM; + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + temp_items[ITEM] = temp_storage[item_offset]; + } + } + } + + // Copy + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + items[ITEM] = temp_items[ITEM]; + } + } + + + /** + * Exchanges data items annotated by rank into striped arrangement. Specialized for no timeslicing. + */ + template + __device__ __forceinline__ void ScatterToStriped( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange + OffsetT ranks[ITEMS_PER_THREAD], ///< [in] Corresponding scatter ranks + Int2Type time_slicing) + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = ranks[ITEM]; + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + temp_storage[item_offset] = items[ITEM]; + } + + __syncthreads(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = int(ITEM * BLOCK_THREADS) + linear_tid; + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + items[ITEM] = temp_storage[item_offset]; + } + } + + + /** + * Exchanges data items annotated by rank into striped arrangement. Specialized for warp-timeslicing. + */ + template + __device__ __forceinline__ void ScatterToStriped( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange + OffsetT ranks[ITEMS_PER_THREAD], ///< [in] Corresponding scatter ranks + Int2Type time_slicing) + { + T temp_items[ITEMS_PER_THREAD]; + + #pragma unroll + for (int SLICE = 0; SLICE < TIME_SLICES; SLICE++) + { + const int SLICE_OFFSET = SLICE * TIME_SLICED_ITEMS; + const int SLICE_OOB = SLICE_OFFSET + TIME_SLICED_ITEMS; + + __syncthreads(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = ranks[ITEM] - SLICE_OFFSET; + if ((item_offset >= 0) && (item_offset < WARP_TIME_SLICED_ITEMS)) + { + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + temp_storage[item_offset] = items[ITEM]; + } + } + + __syncthreads(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + // Read a strip of items + const int STRIP_OFFSET = ITEM * BLOCK_THREADS; + const int STRIP_OOB = STRIP_OFFSET + BLOCK_THREADS; + + if ((SLICE_OFFSET < STRIP_OOB) && (SLICE_OOB > STRIP_OFFSET)) + { + int item_offset = STRIP_OFFSET + linear_tid - SLICE_OFFSET; + if ((item_offset >= 0) && (item_offset < TIME_SLICED_ITEMS)) + { + if (INSERT_PADDING) item_offset += item_offset >> LOG_SMEM_BANKS; + temp_items[ITEM] = temp_storage[item_offset]; + } + } + } + } + + // Copy + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + items[ITEM] = temp_items[ITEM]; + } + } + + +public: + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + /** + * \brief Collective constructor using a private static allocation of shared memory as temporary storage. + */ + __device__ __forceinline__ BlockExchange() + : + temp_storage(PrivateStorage()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)), + warp_id((WARPS == 1) ? 0 : linear_tid / WARP_THREADS), + lane_id(LaneId()), + warp_offset(warp_id * WARP_TIME_SLICED_ITEMS) + {} + + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. + */ + __device__ __forceinline__ BlockExchange( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)), + warp_id((WARPS == 1) ? 0 : linear_tid / WARP_THREADS), + lane_id(LaneId()), + warp_offset(warp_id * WARP_TIME_SLICED_ITEMS) + {} + + + //@} end member group + /******************************************************************//** + * \name Structured exchanges + *********************************************************************/ + //@{ + + /** + * \brief Transposes data items from striped arrangement to blocked arrangement. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the conversion from a "striped" to a "blocked" arrangement + * of 512 integer items partitioned across 128 threads where each thread owns 4 items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, ...) + * { + * // Specialize BlockExchange for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockExchange BlockExchange; + * + * // Allocate shared memory for BlockExchange + * __shared__ typename BlockExchange::TempStorage temp_storage; + * + * // Load a tile of ordered data into a striped arrangement across block threads + * int thread_data[4]; + * cub::LoadDirectStriped<128>(threadIdx.x, d_data, thread_data); + * + * // Collectively exchange data into a blocked arrangement across threads + * BlockExchange(temp_storage).StripedToBlocked(thread_data); + * + * \endcode + * \par + * Suppose the set of striped input \p thread_data across the block of threads is + * { [0,128,256,384], [1,129,257,385], ..., [127,255,383,511] } after loading from global memory. + * The corresponding output \p thread_data in those threads will be + * { [0,1,2,3], [4,5,6,7], [8,9,10,11], ..., [508,509,510,511] }. + * + */ + __device__ __forceinline__ void StripedToBlocked( + T items[ITEMS_PER_THREAD]) ///< [in-out] Items to exchange, converting between striped and blocked arrangements. + { + StripedToBlocked(items, Int2Type()); + } + + /** + * \brief Transposes data items from blocked arrangement to striped arrangement. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the conversion from a "blocked" to a "striped" arrangement + * of 512 integer items partitioned across 128 threads where each thread owns 4 items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, ...) + * { + * // Specialize BlockExchange for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockExchange BlockExchange; + * + * // Allocate shared memory for BlockExchange + * __shared__ typename BlockExchange::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively exchange data into a striped arrangement across threads + * BlockExchange(temp_storage).BlockedToStriped(thread_data); + * + * // Store data striped across block threads into an ordered tile + * cub::StoreDirectStriped(threadIdx.x, d_data, thread_data); + * + * \endcode + * \par + * Suppose the set of blocked input \p thread_data across the block of threads is + * { [0,1,2,3], [4,5,6,7], [8,9,10,11], ..., [508,509,510,511] }. + * The corresponding output \p thread_data in those threads will be + * { [0,128,256,384], [1,129,257,385], ..., [127,255,383,511] } in + * preparation for storing to global memory. + * + */ + __device__ __forceinline__ void BlockedToStriped( + T items[ITEMS_PER_THREAD]) ///< [in-out] Items to exchange, converting between blocked and striped arrangements. + { + BlockedToStriped(items, Int2Type()); + } + + + /** + * \brief Transposes data items from warp-striped arrangement to blocked arrangement. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the conversion from a "warp-striped" to a "blocked" arrangement + * of 512 integer items partitioned across 128 threads where each thread owns 4 items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, ...) + * { + * // Specialize BlockExchange for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockExchange BlockExchange; + * + * // Allocate shared memory for BlockExchange + * __shared__ typename BlockExchange::TempStorage temp_storage; + * + * // Load a tile of ordered data into a warp-striped arrangement across warp threads + * int thread_data[4]; + * cub::LoadSWarptriped(threadIdx.x, d_data, thread_data); + * + * // Collectively exchange data into a blocked arrangement across threads + * BlockExchange(temp_storage).WarpStripedToBlocked(thread_data); + * + * \endcode + * \par + * Suppose the set of warp-striped input \p thread_data across the block of threads is + * { [0,32,64,96], [1,33,65,97], [2,34,66,98], ..., [415,447,479,511] } + * after loading from global memory. (The first 128 items are striped across + * the first warp of 32 threads, the second 128 items are striped across the second warp, etc.) + * The corresponding output \p thread_data in those threads will be + * { [0,1,2,3], [4,5,6,7], [8,9,10,11], ..., [508,509,510,511] }. + * + */ + __device__ __forceinline__ void WarpStripedToBlocked( + T items[ITEMS_PER_THREAD]) ///< [in-out] Items to exchange, converting between warp-striped and blocked arrangements. + { + WarpStripedToBlocked(items, Int2Type()); + } + + /** + * \brief Transposes data items from blocked arrangement to warp-striped arrangement. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the conversion from a "blocked" to a "warp-striped" arrangement + * of 512 integer items partitioned across 128 threads where each thread owns 4 items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, ...) + * { + * // Specialize BlockExchange for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockExchange BlockExchange; + * + * // Allocate shared memory for BlockExchange + * __shared__ typename BlockExchange::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively exchange data into a warp-striped arrangement across threads + * BlockExchange(temp_storage).BlockedToWarpStriped(thread_data); + * + * // Store data striped across warp threads into an ordered tile + * cub::StoreDirectStriped(threadIdx.x, d_data, thread_data); + * + * \endcode + * \par + * Suppose the set of blocked input \p thread_data across the block of threads is + * { [0,1,2,3], [4,5,6,7], [8,9,10,11], ..., [508,509,510,511] }. + * The corresponding output \p thread_data in those threads will be + * { [0,32,64,96], [1,33,65,97], [2,34,66,98], ..., [415,447,479,511] } + * in preparation for storing to global memory. (The first 128 items are striped across + * the first warp of 32 threads, the second 128 items are striped across the second warp, etc.) + * + */ + __device__ __forceinline__ void BlockedToWarpStriped( + T items[ITEMS_PER_THREAD]) ///< [in-out] Items to exchange, converting between blocked and warp-striped arrangements. + { + BlockedToWarpStriped(items, Int2Type()); + } + + + //@} end member group + /******************************************************************//** + * \name Scatter exchanges + *********************************************************************/ + //@{ + + + /** + * \brief Exchanges data items annotated by rank into blocked arrangement. + * + * \par + * - \smemreuse + * + * \tparam OffsetT [inferred] Signed integer type for local offsets + */ + template + __device__ __forceinline__ void ScatterToBlocked( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange + OffsetT ranks[ITEMS_PER_THREAD]) ///< [in] Corresponding scatter ranks + { + ScatterToBlocked(items, ranks, Int2Type()); + } + + + /** + * \brief Exchanges data items annotated by rank into striped arrangement. + * + * \par + * - \smemreuse + * + * \tparam OffsetT [inferred] Signed integer type for local offsets + */ + template + __device__ __forceinline__ void ScatterToStriped( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange + OffsetT ranks[ITEMS_PER_THREAD]) ///< [in] Corresponding scatter ranks + { + ScatterToStriped(items, ranks, Int2Type()); + } + + + /** + * \brief Exchanges data items annotated by rank into striped arrangement. Items with rank -1 are not exchanged. + * + * \par + * - \smemreuse + * + * \tparam OffsetT [inferred] Signed integer type for local offsets + */ + template + __device__ __forceinline__ void ScatterToStripedGuarded( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange + OffsetT ranks[ITEMS_PER_THREAD]) ///< [in] Corresponding scatter ranks + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = ranks[ITEM]; + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + if (ranks[ITEM] >= 0) + temp_storage[item_offset] = items[ITEM]; + } + + __syncthreads(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = int(ITEM * BLOCK_THREADS) + linear_tid; + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + items[ITEM] = temp_storage[item_offset]; + } + } + + /** + * \brief Exchanges valid data items annotated by rank into striped arrangement. + * + * \par + * - \smemreuse + * + * \tparam OffsetT [inferred] Signed integer type for local offsets + * \tparam ValidFlag [inferred] FlagT type denoting which items are valid + */ + template + __device__ __forceinline__ void ScatterToStriped( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange + OffsetT ranks[ITEMS_PER_THREAD], ///< [in] Corresponding scatter ranks + ValidFlag is_valid[ITEMS_PER_THREAD]) ///< [in] Corresponding flag denoting item validity + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = ranks[ITEM]; + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + if (is_valid[ITEM]) + temp_storage[item_offset] = items[ITEM]; + } + + __syncthreads(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = int(ITEM * BLOCK_THREADS) + linear_tid; + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + items[ITEM] = temp_storage[item_offset]; + } + } + + //@} end member group + +}; + + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + +template < + typename T, + int ITEMS_PER_THREAD, + int LOGICAL_WARP_THREADS = CUB_PTX_WARP_THREADS, + int PTX_ARCH = CUB_PTX_ARCH> +class WarpExchange +{ +private: + + /****************************************************************************** + * Constants + ******************************************************************************/ + + /// Constants + enum + { + // Whether the logical warp size and the PTX warp size coincide + IS_ARCH_WARP = (LOGICAL_WARP_THREADS == CUB_WARP_THREADS(PTX_ARCH)), + + WARP_ITEMS = (ITEMS_PER_THREAD * LOGICAL_WARP_THREADS) + 1, + + LOG_SMEM_BANKS = CUB_LOG_SMEM_BANKS(PTX_ARCH), + SMEM_BANKS = 1 << LOG_SMEM_BANKS, + + // Insert padding if the number of items per thread is a power of two + INSERT_PADDING = 0, // Mooch PowerOfTwo::VALUE, + PADDING_ITEMS = (INSERT_PADDING) ? (WARP_ITEMS >> LOG_SMEM_BANKS) : 0, + }; + + /****************************************************************************** + * Type definitions + ******************************************************************************/ + + /// Shared memory storage layout type + typedef T _TempStorage[WARP_ITEMS + PADDING_ITEMS]; + +public: + + /// \smemstorage{WarpExchange} + struct TempStorage : Uninitialized<_TempStorage> {}; + +private: + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + _TempStorage &temp_storage; + int lane_id; + +public: + + /****************************************************************************** + * Construction + ******************************************************************************/ + + /// Constructor + __device__ __forceinline__ WarpExchange( + TempStorage &temp_storage) + : + temp_storage(temp_storage.Alias()), + lane_id(IS_ARCH_WARP ? + LaneId() : + LaneId() % LOGICAL_WARP_THREADS) + {} + + + /****************************************************************************** + * Interface + ******************************************************************************/ + + /** + * \brief Exchanges valid data items annotated by rank into striped arrangement. + * + * \par + * - \smemreuse + * + * \tparam OffsetT [inferred] Signed integer type for local offsets + */ + template + __device__ __forceinline__ void ScatterToStriped( + T items[ITEMS_PER_THREAD], ///< [in-out] Items to exchange + OffsetT ranks[ITEMS_PER_THREAD]) ///< [in] Corresponding scatter ranks + { + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + if (INSERT_PADDING) ranks[ITEM] = SHR_ADD(ranks[ITEM], LOG_SMEM_BANKS, ranks[ITEM]); + temp_storage[ranks[ITEM]] = items[ITEM]; + } + + __threadfence_block(); + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int item_offset = (ITEM * LOGICAL_WARP_THREADS) + lane_id; + if (INSERT_PADDING) item_offset = SHR_ADD(item_offset, LOG_SMEM_BANKS, item_offset); + items[ITEM] = temp_storage[item_offset]; + } + } + +}; + + + + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + + + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/block_histogram.cuh b/3rdparty/cub/cub/block/block_histogram.cuh new file mode 100644 index 00000000000..3b69ba8f7fa --- /dev/null +++ b/3rdparty/cub/cub/block/block_histogram.cuh @@ -0,0 +1,415 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * The cub::BlockHistogram class provides [collective](index.html#sec0) methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block. + */ + +#pragma once + +#include "specializations/block_histogram_sort.cuh" +#include "specializations/block_histogram_atomic.cuh" +#include "../util_ptx.cuh" +#include "../util_arch.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Algorithmic variants + ******************************************************************************/ + +/** + * \brief BlockHistogramAlgorithm enumerates alternative algorithms for the parallel construction of block-wide histograms. + */ +enum BlockHistogramAlgorithm +{ + + /** + * \par Overview + * Sorting followed by differentiation. Execution is comprised of two phases: + * -# Sort the data using efficient radix sort + * -# Look for "runs" of same-valued keys by detecting discontinuities; the run-lengths are histogram bin counts. + * + * \par Performance Considerations + * Delivers consistent throughput regardless of sample bin distribution. + */ + BLOCK_HISTO_SORT, + + + /** + * \par Overview + * Use atomic addition to update byte counts directly + * + * \par Performance Considerations + * Performance is strongly tied to the hardware implementation of atomic + * addition, and may be significantly degraded for non uniformly-random + * input distributions where many concurrent updates are likely to be + * made to the same bin counter. + */ + BLOCK_HISTO_ATOMIC, +}; + + + +/****************************************************************************** + * Block histogram + ******************************************************************************/ + + +/** + * \brief The BlockHistogram class provides [collective](index.html#sec0) methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block. ![](histogram_logo.png) + * \ingroup BlockModule + * + * \tparam T The sample type being histogrammed (must be castable to an integer bin identifier) + * \tparam BLOCK_DIM_X The thread block length in threads along the X dimension + * \tparam ITEMS_PER_THREAD The number of items per thread + * \tparam BINS The number bins within the histogram + * \tparam ALGORITHM [optional] cub::BlockHistogramAlgorithm enumerator specifying the underlying algorithm to use (default: cub::BLOCK_HISTO_SORT) + * \tparam BLOCK_DIM_Y [optional] The thread block length in threads along the Y dimension (default: 1) + * \tparam BLOCK_DIM_Z [optional] The thread block length in threads along the Z dimension (default: 1) + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * - A histogram + * counts the number of observations that fall into each of the disjoint categories (known as bins). + * - BlockHistogram can be optionally specialized to use different algorithms: + * -# cub::BLOCK_HISTO_SORT. Sorting followed by differentiation. [More...](\ref cub::BlockHistogramAlgorithm) + * -# cub::BLOCK_HISTO_ATOMIC. Use atomic addition to update byte counts directly. [More...](\ref cub::BlockHistogramAlgorithm) + * + * \par Performance Considerations + * - \granularity + * + * \par A Simple Example + * \blockcollective{BlockHistogram} + * \par + * The code snippet below illustrates a 256-bin histogram of 512 integer samples that + * are partitioned across 128 threads where each thread owns 4 samples. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize a 256-bin BlockHistogram type for a 1D block of 128 threads having 4 character samples each + * typedef cub::BlockHistogram BlockHistogram; + * + * // Allocate shared memory for BlockHistogram + * __shared__ typename BlockHistogram::TempStorage temp_storage; + * + * // Allocate shared memory for block-wide histogram bin counts + * __shared__ unsigned int smem_histogram[256]; + * + * // Obtain input samples per thread + * unsigned char data[4]; + * ... + * + * // Compute the block-wide histogram + * BlockHistogram(temp_storage).Histogram(data, smem_histogram); + * + * \endcode + * + * \par Performance and Usage Considerations + * - The histogram output can be constructed in shared or global memory + * - See cub::BlockHistogramAlgorithm for performance details regarding algorithmic alternatives + * + */ +template < + typename T, + int BLOCK_DIM_X, + int ITEMS_PER_THREAD, + int BINS, + BlockHistogramAlgorithm ALGORITHM = BLOCK_HISTO_SORT, + int BLOCK_DIM_Y = 1, + int BLOCK_DIM_Z = 1, + int PTX_ARCH = CUB_PTX_ARCH> +class BlockHistogram +{ +private: + + /****************************************************************************** + * Constants and type definitions + ******************************************************************************/ + + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + }; + + /** + * Ensure the template parameterization meets the requirements of the + * targeted device architecture. BLOCK_HISTO_ATOMIC can only be used + * on version SM120 or later. Otherwise BLOCK_HISTO_SORT is used + * regardless. + */ + static const BlockHistogramAlgorithm SAFE_ALGORITHM = + ((ALGORITHM == BLOCK_HISTO_ATOMIC) && (PTX_ARCH < 120)) ? + BLOCK_HISTO_SORT : + ALGORITHM; + + /// Internal specialization. + typedef typename If<(SAFE_ALGORITHM == BLOCK_HISTO_SORT), + BlockHistogramSort, + BlockHistogramAtomic >::Type InternalBlockHistogram; + + /// Shared memory storage layout type for BlockHistogram + typedef typename InternalBlockHistogram::TempStorage _TempStorage; + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Shared storage reference + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + /// Internal storage allocator + __device__ __forceinline__ _TempStorage& PrivateStorage() + { + __shared__ _TempStorage private_storage; + return private_storage; + } + + +public: + + /// \smemstorage{BlockHistogram} + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + /** + * \brief Collective constructor using a private static allocation of shared memory as temporary storage. + */ + __device__ __forceinline__ BlockHistogram() + : + temp_storage(PrivateStorage()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. + */ + __device__ __forceinline__ BlockHistogram( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + //@} end member group + /******************************************************************//** + * \name Histogram operations + *********************************************************************/ + //@{ + + + /** + * \brief Initialize the shared histogram counters to zero. + * + * \par Snippet + * The code snippet below illustrates a the initialization and update of a + * histogram of 512 integer samples that are partitioned across 128 threads + * where each thread owns 4 samples. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize a 256-bin BlockHistogram type for a 1D block of 128 threads having 4 character samples each + * typedef cub::BlockHistogram BlockHistogram; + * + * // Allocate shared memory for BlockHistogram + * __shared__ typename BlockHistogram::TempStorage temp_storage; + * + * // Allocate shared memory for block-wide histogram bin counts + * __shared__ unsigned int smem_histogram[256]; + * + * // Obtain input samples per thread + * unsigned char thread_samples[4]; + * ... + * + * // Initialize the block-wide histogram + * BlockHistogram(temp_storage).InitHistogram(smem_histogram); + * + * // Update the block-wide histogram + * BlockHistogram(temp_storage).Composite(thread_samples, smem_histogram); + * + * \endcode + * + * \tparam CounterT [inferred] Histogram counter type + */ + template + __device__ __forceinline__ void InitHistogram(CounterT histogram[BINS]) + { + // Initialize histogram bin counts to zeros + int histo_offset = 0; + + #pragma unroll + for(; histo_offset + BLOCK_THREADS <= BINS; histo_offset += BLOCK_THREADS) + { + histogram[histo_offset + linear_tid] = 0; + } + // Finish up with guarded initialization if necessary + if ((BINS % BLOCK_THREADS != 0) && (histo_offset + linear_tid < BINS)) + { + histogram[histo_offset + linear_tid] = 0; + } + } + + + /** + * \brief Constructs a block-wide histogram in shared/global memory. Each thread contributes an array of input elements. + * + * \par + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a 256-bin histogram of 512 integer samples that + * are partitioned across 128 threads where each thread owns 4 samples. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize a 256-bin BlockHistogram type for a 1D block of 128 threads having 4 character samples each + * typedef cub::BlockHistogram BlockHistogram; + * + * // Allocate shared memory for BlockHistogram + * __shared__ typename BlockHistogram::TempStorage temp_storage; + * + * // Allocate shared memory for block-wide histogram bin counts + * __shared__ unsigned int smem_histogram[256]; + * + * // Obtain input samples per thread + * unsigned char thread_samples[4]; + * ... + * + * // Compute the block-wide histogram + * BlockHistogram(temp_storage).Histogram(thread_samples, smem_histogram); + * + * \endcode + * + * \tparam CounterT [inferred] Histogram counter type + */ + template < + typename CounterT > + __device__ __forceinline__ void Histogram( + T (&items)[ITEMS_PER_THREAD], ///< [in] Calling thread's input values to histogram + CounterT histogram[BINS]) ///< [out] Reference to shared/global memory histogram + { + // Initialize histogram bin counts to zeros + InitHistogram(histogram); + + __syncthreads(); + + // Composite the histogram + InternalBlockHistogram(temp_storage).Composite(items, histogram); + } + + + + /** + * \brief Updates an existing block-wide histogram in shared/global memory. Each thread composites an array of input elements. + * + * \par + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a the initialization and update of a + * histogram of 512 integer samples that are partitioned across 128 threads + * where each thread owns 4 samples. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize a 256-bin BlockHistogram type for a 1D block of 128 threads having 4 character samples each + * typedef cub::BlockHistogram BlockHistogram; + * + * // Allocate shared memory for BlockHistogram + * __shared__ typename BlockHistogram::TempStorage temp_storage; + * + * // Allocate shared memory for block-wide histogram bin counts + * __shared__ unsigned int smem_histogram[256]; + * + * // Obtain input samples per thread + * unsigned char thread_samples[4]; + * ... + * + * // Initialize the block-wide histogram + * BlockHistogram(temp_storage).InitHistogram(smem_histogram); + * + * // Update the block-wide histogram + * BlockHistogram(temp_storage).Composite(thread_samples, smem_histogram); + * + * \endcode + * + * \tparam CounterT [inferred] Histogram counter type + */ + template < + typename CounterT > + __device__ __forceinline__ void Composite( + T (&items)[ITEMS_PER_THREAD], ///< [in] Calling thread's input values to histogram + CounterT histogram[BINS]) ///< [out] Reference to shared/global memory histogram + { + InternalBlockHistogram(temp_storage).Composite(items, histogram); + } + +}; + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/block_load.cuh b/3rdparty/cub/cub/block/block_load.cuh new file mode 100644 index 00000000000..5a76d85ab83 --- /dev/null +++ b/3rdparty/cub/cub/block/block_load.cuh @@ -0,0 +1,1235 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Operations for reading linear tiles of data into the CUDA thread block. + */ + +#pragma once + +#include + +#include "block_exchange.cuh" +#include "../iterator/cache_modified_input_iterator.cuh" +#include "../util_ptx.cuh" +#include "../util_macro.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \addtogroup UtilIo + * @{ + */ + + +/******************************************************************//** + * \name Blocked arrangement I/O (direct) + *********************************************************************/ +//@{ + + +/** + * \brief Load a linear segment of items into a blocked arrangement across the thread block. + * + * \blocked + * + * \tparam T [inferred] The data type to load. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam InputIteratorT [inferred] The random-access iterator type for input \iterator. + */ +template < + typename T, + int ITEMS_PER_THREAD, + typename InputIteratorT> +__device__ __forceinline__ void LoadDirectBlocked( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load +{ + // Load directly in thread-blocked order + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + items[ITEM] = block_itr[(linear_tid * ITEMS_PER_THREAD) + ITEM]; + } +} + + +/** + * \brief Load a linear segment of items into a blocked arrangement across the thread block, guarded by range. + * + * \blocked + * + * \tparam T [inferred] The data type to load. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam InputIteratorT [inferred] The random-access iterator type for input \iterator. + */ +template < + typename T, + int ITEMS_PER_THREAD, + typename InputIteratorT> +__device__ __forceinline__ void LoadDirectBlocked( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items) ///< [in] Number of valid items to load +{ + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int offset = (linear_tid * ITEMS_PER_THREAD) + ITEM; + offset = CUB_MIN(offset, valid_items - 1); + items[ITEM] = block_itr[offset]; + } +} + + +/** + * \brief Load a linear segment of items into a blocked arrangement across the thread block, guarded by range, with a fall-back assignment of out-of-bound elements.. + * + * \blocked + * + * \tparam T [inferred] The data type to load. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam InputIteratorT [inferred] The random-access iterator type for input \iterator. + */ +template < + typename T, + int ITEMS_PER_THREAD, + typename InputIteratorT> +__device__ __forceinline__ void LoadDirectBlocked( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items, ///< [in] Number of valid items to load + T oob_default) ///< [in] Default value to assign out-of-bound items +{ + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int offset = (linear_tid * ITEMS_PER_THREAD) + ITEM; + items[ITEM] = (offset < valid_items) ? block_itr[offset] : oob_default; + } +} + + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +/** + * Internal implementation for load vectorization + */ +template < + CacheLoadModifier MODIFIER, + typename T, + int ITEMS_PER_THREAD> +__device__ __forceinline__ void InternalLoadDirectBlockedVectorized( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + T *block_ptr, ///< [in] Input pointer for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load +{ + // Biggest memory access word that T is a whole multiple of + typedef typename UnitWord::DeviceWord DeviceWord; + + enum + { + TOTAL_WORDS = sizeof(items) / sizeof(DeviceWord), + + VECTOR_SIZE = (TOTAL_WORDS % 4 == 0) ? + 4 : + (TOTAL_WORDS % 2 == 0) ? + 2 : + 1, + + VECTORS_PER_THREAD = TOTAL_WORDS / VECTOR_SIZE, + }; + + // Vector type + typedef typename CubVector::Type Vector; + + // Vector items + Vector vec_items[VECTORS_PER_THREAD]; + + // Aliased input ptr + Vector* vec_ptr = reinterpret_cast(block_ptr) + (linear_tid * VECTORS_PER_THREAD); + + // Load directly in thread-blocked order + #pragma unroll + for (int ITEM = 0; ITEM < VECTORS_PER_THREAD; ITEM++) + { + vec_items[ITEM] = ThreadLoad(vec_ptr + ITEM); + } + + // Copy + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + items[ITEM] = reinterpret_cast(vec_items)[ITEM]; + } +} + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + +/** + * \brief Load a linear segment of items into a blocked arrangement across the thread block. + * + * \blocked + * + * The input offset (\p block_ptr + \p block_offset) must be quad-item aligned + * + * The following conditions will prevent vectorization and loading will fall back to cub::BLOCK_LOAD_DIRECT: + * - \p ITEMS_PER_THREAD is odd + * - The data type \p T is not a built-in primitive or CUDA vector type (e.g., \p short, \p int2, \p double, \p float2, etc.) + * + * \tparam T [inferred] The data type to load. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + */ +template < + typename T, + int ITEMS_PER_THREAD> +__device__ __forceinline__ void LoadDirectBlockedVectorized( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + T *block_ptr, ///< [in] Input pointer for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load +{ + InternalLoadDirectBlockedVectorized(linear_tid, block_ptr, items); +} + + +//@} end member group +/******************************************************************//** + * \name Striped arrangement I/O (direct) + *********************************************************************/ +//@{ + + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +template +__device__ __forceinline__ void LoadDirectStriped( + int linear_tid, + InputIteratorT block_itr, + T (&items)[ITEMS_PER_THREAD], + Int2Type item) +{ + items[ITEM] = block_itr[(ITEM * BLOCK_THREADS) + linear_tid]; + LoadDirectStriped(linear_tid, block_itr, items, Int2Type()); +} + + +template +__device__ __forceinline__ void LoadDirectStriped( + int linear_tid, + InputIteratorT block_itr, + T (&items)[ITEMS_PER_THREAD], + Int2Type item) +{} + + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + + +/** + * \brief Load a linear segment of items into a striped arrangement across the thread block. + * + * \striped + * + * \tparam BLOCK_THREADS The thread block size in threads + * \tparam T [inferred] The data type to load. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam InputIteratorT [inferred] The random-access iterator type for input \iterator. + */ +template < + int BLOCK_THREADS, + typename T, + int ITEMS_PER_THREAD, + typename InputIteratorT> +__device__ __forceinline__ void LoadDirectStriped( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load +{ + + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int offset = linear_tid + (ITEM * BLOCK_THREADS); + items[ITEM] = block_itr[offset]; + } + +// LoadDirectStriped(linear_tid, block_itr, items, Int2Type<0>()); +} + + +/** + * \brief Load a linear segment of items into a striped arrangement across the thread block, guarded by range + * + * \striped + * + * \tparam BLOCK_THREADS The thread block size in threads + * \tparam T [inferred] The data type to load. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam InputIteratorT [inferred] The random-access iterator type for input \iterator. + */ +template < + int BLOCK_THREADS, + typename T, + int ITEMS_PER_THREAD, + typename InputIteratorT> +__device__ __forceinline__ void LoadDirectStriped( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items) ///< [in] Number of valid items to load +{ + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int offset = linear_tid + (ITEM * BLOCK_THREADS); + offset = CUB_MIN(offset, valid_items - 1); + items[ITEM] = block_itr[offset]; + } +} + + +/** + * \brief Load a linear segment of items into a striped arrangement across the thread block, guarded by range, with a fall-back assignment of out-of-bound elements. + * + * \striped + * + * \tparam BLOCK_THREADS The thread block size in threads + * \tparam T [inferred] The data type to load. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam InputIteratorT [inferred] The random-access iterator type for input \iterator. + */ +template < + int BLOCK_THREADS, + typename T, + int ITEMS_PER_THREAD, + typename InputIteratorT> +__device__ __forceinline__ void LoadDirectStriped( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items, ///< [in] Number of valid items to load + T oob_default) ///< [in] Default value to assign out-of-bound items +{ + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int offset = linear_tid + (ITEM * BLOCK_THREADS); + items[ITEM] = (offset < valid_items) ? block_itr[offset] : oob_default; + } +} + + + +//@} end member group +/******************************************************************//** + * \name Warp-striped arrangement I/O (direct) + *********************************************************************/ +//@{ + + +/** + * \brief Load a linear segment of items into a warp-striped arrangement across the thread block. + * + * \warpstriped + * + * \par Usage Considerations + * The number of threads in the thread block must be a multiple of the architecture's warp size. + * + * \tparam T [inferred] The data type to load. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam InputIteratorT [inferred] The random-access iterator type for input \iterator. + */ +template < + typename T, + int ITEMS_PER_THREAD, + typename InputIteratorT> +__device__ __forceinline__ void LoadDirectWarpStriped( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load +{ + int tid = linear_tid & (CUB_PTX_WARP_THREADS - 1); + int wid = linear_tid >> CUB_PTX_LOG_WARP_THREADS; + int warp_offset = wid * CUB_PTX_WARP_THREADS * ITEMS_PER_THREAD; + + // Load directly in warp-striped order + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + items[ITEM] = block_itr[warp_offset + tid + (ITEM * CUB_PTX_WARP_THREADS)]; + } +} + + +/** + * \brief Load a linear segment of items into a warp-striped arrangement across the thread block, guarded by range + * + * \warpstriped + * + * \par Usage Considerations + * The number of threads in the thread block must be a multiple of the architecture's warp size. + * + * \tparam T [inferred] The data type to load. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam InputIteratorT [inferred] The random-access iterator type for input \iterator. + */ +template < + typename T, + int ITEMS_PER_THREAD, + typename InputIteratorT> +__device__ __forceinline__ void LoadDirectWarpStriped( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items) ///< [in] Number of valid items to load +{ + int tid = linear_tid & (CUB_PTX_WARP_THREADS - 1); + int wid = linear_tid >> CUB_PTX_LOG_WARP_THREADS; + int warp_offset = wid * CUB_PTX_WARP_THREADS * ITEMS_PER_THREAD; + + // Load directly in warp-striped order + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int offset = warp_offset + tid + (ITEM * CUB_PTX_WARP_THREADS); + offset = CUB_MIN(offset, valid_items - 1); + items[ITEM] = block_itr[offset]; + } +} + + +/** + * \brief Load a linear segment of items into a warp-striped arrangement across the thread block, guarded by range, with a fall-back assignment of out-of-bound elements. + * + * \warpstriped + * + * \par Usage Considerations + * The number of threads in the thread block must be a multiple of the architecture's warp size. + * + * \tparam T [inferred] The data type to load. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam InputIteratorT [inferred] The random-access iterator type for input \iterator. + */ +template < + typename T, + int ITEMS_PER_THREAD, + typename InputIteratorT> +__device__ __forceinline__ void LoadDirectWarpStriped( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items, ///< [in] Number of valid items to load + T oob_default) ///< [in] Default value to assign out-of-bound items +{ + int tid = linear_tid & (CUB_PTX_WARP_THREADS - 1); + int wid = linear_tid >> CUB_PTX_LOG_WARP_THREADS; + int warp_offset = wid * CUB_PTX_WARP_THREADS * ITEMS_PER_THREAD; + + // Load directly in warp-striped order + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + int offset = warp_offset + tid + (ITEM * CUB_PTX_WARP_THREADS); + items[ITEM] = (offset < valid_items) ? block_itr[offset] : oob_default; + } +} + + +//@} end member group + +/** @} */ // end group UtilIo + + + +//----------------------------------------------------------------------------- +// Generic BlockLoad abstraction +//----------------------------------------------------------------------------- + +/** + * \brief cub::BlockLoadAlgorithm enumerates alternative algorithms for cub::BlockLoad to read a linear segment of data from memory into a blocked arrangement across a CUDA thread block. + */ + +/** + * \brief cub::BlockLoadAlgorithm enumerates alternative algorithms for cub::BlockLoad to read a linear segment of data from memory into a blocked arrangement across a CUDA thread block. + */ +enum BlockLoadAlgorithm +{ + /** + * \par Overview + * + * A [blocked arrangement](index.html#sec5sec3) of data is read + * directly from memory. + * + * \par Performance Considerations + * - The utilization of memory transactions (coalescing) decreases as the + * access stride between threads increases (i.e., the number items per thread). + */ + BLOCK_LOAD_DIRECT, + + /** + * \par Overview + * + * A [blocked arrangement](index.html#sec5sec3) of data is read + * from memory using CUDA's built-in vectorized loads as a coalescing optimization. + * For example, ld.global.v4.s32 instructions will be generated + * when \p T = \p int and \p ITEMS_PER_THREAD % 4 == 0. + * + * \par Performance Considerations + * - The utilization of memory transactions (coalescing) remains high until the the + * access stride between threads (i.e., the number items per thread) exceeds the + * maximum vector load width (typically 4 items or 64B, whichever is lower). + * - The following conditions will prevent vectorization and loading will fall back to cub::BLOCK_LOAD_DIRECT: + * - \p ITEMS_PER_THREAD is odd + * - The \p InputIteratorTis not a simple pointer type + * - The block input offset is not quadword-aligned + * - The data type \p T is not a built-in primitive or CUDA vector type (e.g., \p short, \p int2, \p double, \p float2, etc.) + */ + BLOCK_LOAD_VECTORIZE, + + /** + * \par Overview + * + * A [striped arrangement](index.html#sec5sec3) of data is read + * efficiently from memory and then locally transposed into a + * [blocked arrangement](index.html#sec5sec3). + * + * \par Performance Considerations + * - The utilization of memory transactions (coalescing) remains high regardless + * of items loaded per thread. + * - The local reordering incurs slightly longer latencies and throughput than the + * direct cub::BLOCK_LOAD_DIRECT and cub::BLOCK_LOAD_VECTORIZE alternatives. + */ + BLOCK_LOAD_TRANSPOSE, + + + /** + * \par Overview + * + * A [warp-striped arrangement](index.html#sec5sec3) of data is + * read efficiently from memory and then locally transposed into a + * [blocked arrangement](index.html#sec5sec3). + * + * \par Usage Considerations + * - BLOCK_THREADS must be a multiple of WARP_THREADS + * + * \par Performance Considerations + * - The utilization of memory transactions (coalescing) remains high regardless + * of items loaded per thread. + * - The local reordering incurs slightly larger latencies than the + * direct cub::BLOCK_LOAD_DIRECT and cub::BLOCK_LOAD_VECTORIZE alternatives. + * - Provisions more shared storage, but incurs smaller latencies than the + * BLOCK_LOAD_WARP_TRANSPOSE_TIMESLICED alternative. + */ + BLOCK_LOAD_WARP_TRANSPOSE, + + + /** + * \par Overview + * + * Like \p BLOCK_LOAD_WARP_TRANSPOSE, a [warp-striped arrangement](index.html#sec5sec3) + * of data is read directly from memory and then is locally transposed into a + * [blocked arrangement](index.html#sec5sec3). To reduce the shared memory + * requirement, only one warp's worth of shared memory is provisioned and is + * subsequently time-sliced among warps. + * + * \par Usage Considerations + * - BLOCK_THREADS must be a multiple of WARP_THREADS + * + * \par Performance Considerations + * - The utilization of memory transactions (coalescing) remains high regardless + * of items loaded per thread. + * - Provisions less shared memory temporary storage, but incurs larger + * latencies than the BLOCK_LOAD_WARP_TRANSPOSE alternative. + */ + BLOCK_LOAD_WARP_TRANSPOSE_TIMESLICED, +}; + + +/** + * \brief The BlockLoad class provides [collective](index.html#sec0) data movement methods for loading a linear segment of items from memory into a [blocked arrangement](index.html#sec5sec3) across a CUDA thread block. ![](block_load_logo.png) + * \ingroup BlockModule + * \ingroup UtilIo + * + * \tparam InputIteratorT The input iterator type \iterator. + * \tparam BLOCK_DIM_X The thread block length in threads along the X dimension + * \tparam ITEMS_PER_THREAD The number of consecutive items partitioned onto each thread. + * \tparam ALGORITHM [optional] cub::BlockLoadAlgorithm tuning policy. default: cub::BLOCK_LOAD_DIRECT. + * \tparam WARP_TIME_SLICING [optional] Whether or not only one warp's worth of shared memory should be allocated and time-sliced among block-warps during any load-related data transpositions (versus each warp having its own storage). (default: false) + * \tparam BLOCK_DIM_Y [optional] The thread block length in threads along the Y dimension (default: 1) + * \tparam BLOCK_DIM_Z [optional] The thread block length in threads along the Z dimension (default: 1) + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * - The BlockLoad class provides a single data movement abstraction that can be specialized + * to implement different cub::BlockLoadAlgorithm strategies. This facilitates different + * performance policies for different architectures, data types, granularity sizes, etc. + * - BlockLoad can be optionally specialized by different data movement strategies: + * -# cub::BLOCK_LOAD_DIRECT. A [blocked arrangement](index.html#sec5sec3) + * of data is read directly from memory. [More...](\ref cub::BlockLoadAlgorithm) + * -# cub::BLOCK_LOAD_VECTORIZE. A [blocked arrangement](index.html#sec5sec3) + * of data is read directly from memory using CUDA's built-in vectorized loads as a + * coalescing optimization. [More...](\ref cub::BlockLoadAlgorithm) + * -# cub::BLOCK_LOAD_TRANSPOSE. A [striped arrangement](index.html#sec5sec3) + * of data is read directly from memory and is then locally transposed into a + * [blocked arrangement](index.html#sec5sec3). [More...](\ref cub::BlockLoadAlgorithm) + * -# cub::BLOCK_LOAD_WARP_TRANSPOSE. A [warp-striped arrangement](index.html#sec5sec3) + * of data is read directly from memory and is then locally transposed into a + * [blocked arrangement](index.html#sec5sec3). [More...](\ref cub::BlockLoadAlgorithm) + * -# cub::BLOCK_LOAD_WARP_TRANSPOSE_TIMESLICED,. A [warp-striped arrangement](index.html#sec5sec3) + * of data is read directly from memory and is then locally transposed into a + * [blocked arrangement](index.html#sec5sec3) one warp at a time. [More...](\ref cub::BlockLoadAlgorithm) + * - \rowmajor + * + * \par A Simple Example + * \blockcollective{BlockLoad} + * \par + * The code snippet below illustrates the loading of a linear + * segment of 512 integers into a "blocked" arrangement across 128 threads where each + * thread owns 4 consecutive items. The load is specialized for \p BLOCK_LOAD_WARP_TRANSPOSE, + * meaning memory references are efficiently coalesced using a warp-striped access + * pattern (after which items are locally reordered among threads). + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, ...) + * { + * // Specialize BlockLoad for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockLoad BlockLoad; + * + * // Allocate shared memory for BlockLoad + * __shared__ typename BlockLoad::TempStorage temp_storage; + * + * // Load a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * BlockLoad(temp_storage).Load(d_data, thread_data); + * + * \endcode + * \par + * Suppose the input \p d_data is 0, 1, 2, 3, 4, 5, .... + * The set of \p thread_data across the block of threads in those threads will be + * { [0,1,2,3], [4,5,6,7], ..., [508,509,510,511] }. + * + */ +template < + typename InputIteratorT, + int BLOCK_DIM_X, + int ITEMS_PER_THREAD, + BlockLoadAlgorithm ALGORITHM = BLOCK_LOAD_DIRECT, + int BLOCK_DIM_Y = 1, + int BLOCK_DIM_Z = 1, + int PTX_ARCH = CUB_PTX_ARCH> +class BlockLoad +{ +private: + + /****************************************************************************** + * Constants and typed definitions + ******************************************************************************/ + + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + }; + + // Data type of input iterator + typedef typename std::iterator_traits::value_type T; + + + /****************************************************************************** + * Algorithmic variants + ******************************************************************************/ + + /// Load helper + template + struct LoadInternal; + + + /** + * BLOCK_LOAD_DIRECT specialization of load helper + */ + template + struct LoadInternal + { + /// Shared memory storage layout type + typedef NullType TempStorage; + + /// Linear thread-id + int linear_tid; + + /// Constructor + __device__ __forceinline__ LoadInternal( + TempStorage &temp_storage, + int linear_tid) + : + linear_tid(linear_tid) + {} + + /// Load a linear segment of items from memory + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load + { + LoadDirectBlocked(linear_tid, block_itr, items); + } + + /// Load a linear segment of items from memory, guarded by range + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items) ///< [in] Number of valid items to load + { + LoadDirectBlocked(linear_tid, block_itr, items, valid_items); + } + + /// Load a linear segment of items from memory, guarded by range, with a fall-back assignment of out-of-bound elements + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items, ///< [in] Number of valid items to load + T oob_default) ///< [in] Default value to assign out-of-bound items + { + LoadDirectBlocked(linear_tid, block_itr, items, valid_items, oob_default); + } + + }; + + + /** + * BLOCK_LOAD_VECTORIZE specialization of load helper + */ + template + struct LoadInternal + { + /// Shared memory storage layout type + typedef NullType TempStorage; + + /// Linear thread-id + int linear_tid; + + /// Constructor + __device__ __forceinline__ LoadInternal( + TempStorage &temp_storage, + int linear_tid) + : + linear_tid(linear_tid) + {} + + /// Load a linear segment of items from memory, specialized for native pointer types (attempts vectorization) + __device__ __forceinline__ void Load( + T *block_ptr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load + { + InternalLoadDirectBlockedVectorized(linear_tid, block_ptr, items); + } + + /// Load a linear segment of items from memory, specialized for native pointer types (attempts vectorization) + template < + CacheLoadModifier MODIFIER, + typename ValueType, + typename OffsetT> + __device__ __forceinline__ void Load( + CacheModifiedInputIterator block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load + { + InternalLoadDirectBlockedVectorized(linear_tid, block_itr.ptr, items); + } + + /// Load a linear segment of items from memory, specialized for opaque input iterators (skips vectorization) + template < + typename T, + typename _InputIteratorT> + __device__ __forceinline__ void Load( + _InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load + { + LoadDirectBlocked(linear_tid, block_itr, items); + } + + /// Load a linear segment of items from memory, guarded by range (skips vectorization) + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items) ///< [in] Number of valid items to load + { + LoadDirectBlocked(linear_tid, block_itr, items, valid_items); + } + + /// Load a linear segment of items from memory, guarded by range, with a fall-back assignment of out-of-bound elements (skips vectorization) + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items, ///< [in] Number of valid items to load + T oob_default) ///< [in] Default value to assign out-of-bound items + { + LoadDirectBlocked(linear_tid, block_itr, items, valid_items, oob_default); + } + + }; + + + /** + * BLOCK_LOAD_TRANSPOSE specialization of load helper + */ + template + struct LoadInternal + { + // BlockExchange utility type for keys + typedef BlockExchange BlockExchange; + + /// Shared memory storage layout type + typedef typename BlockExchange::TempStorage _TempStorage; + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + /// Thread reference to shared storage + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + /// Constructor + __device__ __forceinline__ LoadInternal( + TempStorage &temp_storage, + int linear_tid) + : + temp_storage(temp_storage.Alias()), + linear_tid(linear_tid) + {} + + /// Load a linear segment of items from memory + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load{ + { + LoadDirectStriped(linear_tid, block_itr, items); + BlockExchange(temp_storage).StripedToBlocked(items); + } + + /// Load a linear segment of items from memory, guarded by range + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items) ///< [in] Number of valid items to load + { + LoadDirectStriped(linear_tid, block_itr, items, valid_items); + BlockExchange(temp_storage).StripedToBlocked(items); + } + + /// Load a linear segment of items from memory, guarded by range, with a fall-back assignment of out-of-bound elements + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items, ///< [in] Number of valid items to load + T oob_default) ///< [in] Default value to assign out-of-bound items + { + LoadDirectStriped(linear_tid, block_itr, items, valid_items, oob_default); + BlockExchange(temp_storage).StripedToBlocked(items); + } + + }; + + + /** + * BLOCK_LOAD_WARP_TRANSPOSE specialization of load helper + */ + template + struct LoadInternal + { + enum + { + WARP_THREADS = CUB_WARP_THREADS(PTX_ARCH) + }; + + // Assert BLOCK_THREADS must be a multiple of WARP_THREADS + CUB_STATIC_ASSERT((BLOCK_THREADS % WARP_THREADS == 0), "BLOCK_THREADS must be a multiple of WARP_THREADS"); + + // BlockExchange utility type for keys + typedef BlockExchange BlockExchange; + + /// Shared memory storage layout type + typedef typename BlockExchange::TempStorage _TempStorage; + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + /// Thread reference to shared storage + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + /// Constructor + __device__ __forceinline__ LoadInternal( + TempStorage &temp_storage, + int linear_tid) + : + temp_storage(temp_storage.Alias()), + linear_tid(linear_tid) + {} + + /// Load a linear segment of items from memory + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load{ + { + LoadDirectWarpStriped(linear_tid, block_itr, items); + BlockExchange(temp_storage).WarpStripedToBlocked(items); + } + + /// Load a linear segment of items from memory, guarded by range + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items) ///< [in] Number of valid items to load + { + LoadDirectWarpStriped(linear_tid, block_itr, items, valid_items); + BlockExchange(temp_storage).WarpStripedToBlocked(items); + } + + + /// Load a linear segment of items from memory, guarded by range, with a fall-back assignment of out-of-bound elements + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items, ///< [in] Number of valid items to load + T oob_default) ///< [in] Default value to assign out-of-bound items + { + LoadDirectWarpStriped(linear_tid, block_itr, items, valid_items, oob_default); + BlockExchange(temp_storage).WarpStripedToBlocked(items); + } + }; + + + /** + * BLOCK_LOAD_WARP_TRANSPOSE specialization of load helper + */ + template + struct LoadInternal + { + enum + { + WARP_THREADS = CUB_WARP_THREADS(PTX_ARCH) + }; + + // Assert BLOCK_THREADS must be a multiple of WARP_THREADS + CUB_STATIC_ASSERT((BLOCK_THREADS % WARP_THREADS == 0), "BLOCK_THREADS must be a multiple of WARP_THREADS"); + + // BlockExchange utility type for keys + typedef BlockExchange BlockExchange; + + /// Shared memory storage layout type + typedef typename BlockExchange::TempStorage _TempStorage; + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + /// Thread reference to shared storage + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + /// Constructor + __device__ __forceinline__ LoadInternal( + TempStorage &temp_storage, + int linear_tid) + : + temp_storage(temp_storage.Alias()), + linear_tid(linear_tid) + {} + + /// Load a linear segment of items from memory + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load{ + { + LoadDirectWarpStriped(linear_tid, block_itr, items); + BlockExchange(temp_storage).WarpStripedToBlocked(items); + } + + /// Load a linear segment of items from memory, guarded by range + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items) ///< [in] Number of valid items to load + { + LoadDirectWarpStriped(linear_tid, block_itr, items, valid_items); + BlockExchange(temp_storage).WarpStripedToBlocked(items); + } + + + /// Load a linear segment of items from memory, guarded by range, with a fall-back assignment of out-of-bound elements + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items, ///< [in] Number of valid items to load + T oob_default) ///< [in] Default value to assign out-of-bound items + { + LoadDirectWarpStriped(linear_tid, block_itr, items, valid_items, oob_default); + BlockExchange(temp_storage).WarpStripedToBlocked(items); + } + }; + + + /****************************************************************************** + * Type definitions + ******************************************************************************/ + + /// Internal load implementation to use + typedef LoadInternal InternalLoad; + + + /// Shared memory storage layout type + typedef typename InternalLoad::TempStorage _TempStorage; + + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + /// Internal storage allocator + __device__ __forceinline__ _TempStorage& PrivateStorage() + { + __shared__ _TempStorage private_storage; + return private_storage; + } + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Thread reference to shared storage + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + +public: + + /// \smemstorage{BlockLoad} + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + /** + * \brief Collective constructor using a private static allocation of shared memory as temporary storage. + */ + __device__ __forceinline__ BlockLoad() + : + temp_storage(PrivateStorage()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. + */ + __device__ __forceinline__ BlockLoad( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + + + //@} end member group + /******************************************************************//** + * \name Data movement + *********************************************************************/ + //@{ + + + /** + * \brief Load a linear segment of items from memory. + * + * \par + * - \blocked + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the loading of a linear + * segment of 512 integers into a "blocked" arrangement across 128 threads where each + * thread owns 4 consecutive items. The load is specialized for \p BLOCK_LOAD_WARP_TRANSPOSE, + * meaning memory references are efficiently coalesced using a warp-striped access + * pattern (after which items are locally reordered among threads). + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, ...) + * { + * // Specialize BlockLoad for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockLoad BlockLoad; + * + * // Allocate shared memory for BlockLoad + * __shared__ typename BlockLoad::TempStorage temp_storage; + * + * // Load a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * BlockLoad(temp_storage).Load(d_data, thread_data); + * + * \endcode + * \par + * Suppose the input \p d_data is 0, 1, 2, 3, 4, 5, .... + * The set of \p thread_data across the block of threads in those threads will be + * { [0,1,2,3], [4,5,6,7], ..., [508,509,510,511] }. + * + */ + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load + { + InternalLoad(temp_storage, linear_tid).Load(block_itr, items); + } + + + /** + * \brief Load a linear segment of items from memory, guarded by range. + * + * \par + * - \blocked + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the guarded loading of a linear + * segment of 512 integers into a "blocked" arrangement across 128 threads where each + * thread owns 4 consecutive items. The load is specialized for \p BLOCK_LOAD_WARP_TRANSPOSE, + * meaning memory references are efficiently coalesced using a warp-striped access + * pattern (after which items are locally reordered among threads). + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, int valid_items, ...) + * { + * // Specialize BlockLoad for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockLoad BlockLoad; + * + * // Allocate shared memory for BlockLoad + * __shared__ typename BlockLoad::TempStorage temp_storage; + * + * // Load a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * BlockLoad(temp_storage).Load(d_data, thread_data, valid_items); + * + * \endcode + * \par + * Suppose the input \p d_data is 0, 1, 2, 3, 4, 5, 6... and \p valid_items is \p 5. + * The set of \p thread_data across the block of threads in those threads will be + * { [0,1,2,3], [4,?,?,?], ..., [?,?,?,?] }, with only the first two threads + * being unmasked to load portions of valid data (and other items remaining unassigned). + * + */ + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items) ///< [in] Number of valid items to load + { + InternalLoad(temp_storage, linear_tid).Load(block_itr, items, valid_items); + } + + + /** + * \brief Load a linear segment of items from memory, guarded by range, with a fall-back assignment of out-of-bound elements + * + * \par + * - \blocked + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the guarded loading of a linear + * segment of 512 integers into a "blocked" arrangement across 128 threads where each + * thread owns 4 consecutive items. The load is specialized for \p BLOCK_LOAD_WARP_TRANSPOSE, + * meaning memory references are efficiently coalesced using a warp-striped access + * pattern (after which items are locally reordered among threads). + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, int valid_items, ...) + * { + * // Specialize BlockLoad for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockLoad BlockLoad; + * + * // Allocate shared memory for BlockLoad + * __shared__ typename BlockLoad::TempStorage temp_storage; + * + * // Load a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * BlockLoad(temp_storage).Load(d_data, thread_data, valid_items, -1); + * + * \endcode + * \par + * Suppose the input \p d_data is 0, 1, 2, 3, 4, 5, 6..., + * \p valid_items is \p 5, and the out-of-bounds default is \p -1. + * The set of \p thread_data across the block of threads in those threads will be + * { [0,1,2,3], [4,-1,-1,-1], ..., [-1,-1,-1,-1] }, with only the first two threads + * being unmasked to load portions of valid data (and other items are assigned \p -1) + * + */ + __device__ __forceinline__ void Load( + InputIteratorT block_itr, ///< [in] The thread block's base input iterator for loading from + T (&items)[ITEMS_PER_THREAD], ///< [out] Data to load + int valid_items, ///< [in] Number of valid items to load + T oob_default) ///< [in] Default value to assign out-of-bound items + { + InternalLoad(temp_storage, linear_tid).Load(block_itr, items, valid_items, oob_default); + } + + + //@} end member group + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/block_radix_rank.cuh b/3rdparty/cub/cub/block/block_radix_rank.cuh new file mode 100644 index 00000000000..b60bcbf65ba --- /dev/null +++ b/3rdparty/cub/cub/block/block_radix_rank.cuh @@ -0,0 +1,485 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::BlockRadixRank provides operations for ranking unsigned integer types within a CUDA threadblock + */ + +#pragma once + +#include "../thread/thread_reduce.cuh" +#include "../thread/thread_scan.cuh" +#include "../block/block_scan.cuh" +#include "../util_ptx.cuh" +#include "../util_arch.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \brief BlockRadixRank provides operations for ranking unsigned integer types within a CUDA threadblock. + * \ingroup BlockModule + * + * \tparam BLOCK_DIM_X The thread block length in threads along the X dimension + * \tparam RADIX_BITS The number of radix bits per digit place + * \tparam DESCENDING Whether or not the sorted-order is high-to-low + * \tparam MEMOIZE_OUTER_SCAN [optional] Whether or not to buffer outer raking scan partials to incur fewer shared memory reads at the expense of higher register pressure (default: true for architectures SM35 and newer, false otherwise). See BlockScanAlgorithm::BLOCK_SCAN_RAKING_MEMOIZE for more details. + * \tparam INNER_SCAN_ALGORITHM [optional] The cub::BlockScanAlgorithm algorithm to use (default: cub::BLOCK_SCAN_WARP_SCANS) + * \tparam SMEM_CONFIG [optional] Shared memory bank mode (default: \p cudaSharedMemBankSizeFourByte) + * \tparam BLOCK_DIM_Y [optional] The thread block length in threads along the Y dimension (default: 1) + * \tparam BLOCK_DIM_Z [optional] The thread block length in threads along the Z dimension (default: 1) + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * Blah... + * - Keys must be in a form suitable for radix ranking (i.e., unsigned bits). + * - \blocked + * + * \par Performance Considerations + * - \granularity + * + * \par Examples + * \par + * - Example 1: Simple radix rank of 32-bit integer keys + * \code + * #include + * + * template + * __global__ void ExampleKernel(...) + * { + * + * \endcode + */ +template < + int BLOCK_DIM_X, + int RADIX_BITS, + bool DESCENDING, + bool MEMOIZE_OUTER_SCAN = (CUB_PTX_ARCH >= 350) ? true : false, + BlockScanAlgorithm INNER_SCAN_ALGORITHM = BLOCK_SCAN_WARP_SCANS, + cudaSharedMemConfig SMEM_CONFIG = cudaSharedMemBankSizeFourByte, + int BLOCK_DIM_Y = 1, + int BLOCK_DIM_Z = 1, + int PTX_ARCH = CUB_PTX_ARCH> +class BlockRadixRank +{ +private: + + /****************************************************************************** + * Type definitions and constants + ******************************************************************************/ + + // Integer type for digit counters (to be packed into words of type PackedCounters) + typedef unsigned short DigitCounter; + + // Integer type for packing DigitCounters into columns of shared memory banks + typedef typename If<(SMEM_CONFIG == cudaSharedMemBankSizeEightByte), + unsigned long long, + unsigned int>::Type PackedCounter; + + enum + { + // The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + + RADIX_DIGITS = 1 << RADIX_BITS, + + LOG_WARP_THREADS = CUB_LOG_WARP_THREADS(PTX_ARCH), + WARP_THREADS = 1 << LOG_WARP_THREADS, + WARPS = (BLOCK_THREADS + WARP_THREADS - 1) / WARP_THREADS, + + BYTES_PER_COUNTER = sizeof(DigitCounter), + LOG_BYTES_PER_COUNTER = Log2::VALUE, + + PACKING_RATIO = sizeof(PackedCounter) / sizeof(DigitCounter), + LOG_PACKING_RATIO = Log2::VALUE, + + LOG_COUNTER_LANES = CUB_MAX((RADIX_BITS - LOG_PACKING_RATIO), 0), // Always at least one lane + COUNTER_LANES = 1 << LOG_COUNTER_LANES, + + // The number of packed counters per thread (plus one for padding) + RAKING_SEGMENT = COUNTER_LANES + 1, + + LOG_SMEM_BANKS = CUB_LOG_SMEM_BANKS(PTX_ARCH), + SMEM_BANKS = 1 << LOG_SMEM_BANKS, + }; + + + /// BlockScan type + typedef BlockScan< + PackedCounter, + BLOCK_DIM_X, + INNER_SCAN_ALGORITHM, + BLOCK_DIM_Y, + BLOCK_DIM_Z, + PTX_ARCH> + BlockScan; + + + /// Shared memory storage layout type for BlockRadixRank + struct _TempStorage + { + // Storage for scanning local ranks + typename BlockScan::TempStorage block_scan; + + union + { + DigitCounter digit_counters[COUNTER_LANES + 1][BLOCK_THREADS][PACKING_RATIO]; + PackedCounter raking_grid[BLOCK_THREADS][RAKING_SEGMENT]; + }; + }; + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Shared storage reference + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + /// Copy of raking segment, promoted to registers + PackedCounter cached_segment[RAKING_SEGMENT]; + + + /****************************************************************************** + * Templated iteration + ******************************************************************************/ + + // General template iteration + template + struct Iterate + { + /** + * Decode keys. Decodes the radix digit from the current digit place + * and increments the thread's corresponding counter in shared + * memory for that digit. + * + * Saves both (1) the prior value of that counter (the key's + * thread-local exclusive prefix sum for that digit), and (2) the shared + * memory offset of the counter (for later use). + */ + template + static __device__ __forceinline__ void DecodeKeys( + BlockRadixRank &cta, // BlockRadixRank instance + UnsignedBits (&keys)[KEYS_PER_THREAD], // Key to decode + DigitCounter (&thread_prefixes)[KEYS_PER_THREAD], // Prefix counter value (out parameter) + DigitCounter* (&digit_counters)[KEYS_PER_THREAD], // Counter smem offset (out parameter) + int current_bit, // The least-significant bit position of the current digit to extract + int num_bits) // The number of bits in the current digit + { + // Get digit + unsigned int digit = BFE(keys[COUNT], current_bit, num_bits); + + // Get sub-counter + unsigned int sub_counter = digit >> LOG_COUNTER_LANES; + + // Get counter lane + unsigned int counter_lane = digit & (COUNTER_LANES - 1); + + if (DESCENDING) + { + sub_counter = PACKING_RATIO - 1 - sub_counter; + counter_lane = COUNTER_LANES - 1 - counter_lane; + } + + // Pointer to smem digit counter + digit_counters[COUNT] = &cta.temp_storage.digit_counters[counter_lane][cta.linear_tid][sub_counter]; + + // Load thread-exclusive prefix + thread_prefixes[COUNT] = *digit_counters[COUNT]; + + // Store inclusive prefix + *digit_counters[COUNT] = thread_prefixes[COUNT] + 1; + + // Iterate next key + Iterate::DecodeKeys(cta, keys, thread_prefixes, digit_counters, current_bit, num_bits); + } + + + // Termination + template + static __device__ __forceinline__ void UpdateRanks( + int (&ranks)[KEYS_PER_THREAD], // Local ranks (out parameter) + DigitCounter (&thread_prefixes)[KEYS_PER_THREAD], // Prefix counter value + DigitCounter* (&digit_counters)[KEYS_PER_THREAD]) // Counter smem offset + { + // Add in threadblock exclusive prefix + ranks[COUNT] = thread_prefixes[COUNT] + *digit_counters[COUNT]; + + // Iterate next key + Iterate::UpdateRanks(ranks, thread_prefixes, digit_counters); + } + }; + + + // Termination + template + struct Iterate + { + // DecodeKeys + template + static __device__ __forceinline__ void DecodeKeys( + BlockRadixRank &cta, + UnsignedBits (&keys)[KEYS_PER_THREAD], + DigitCounter (&thread_prefixes)[KEYS_PER_THREAD], + DigitCounter* (&digit_counters)[KEYS_PER_THREAD], + int current_bit, // The least-significant bit position of the current digit to extract + int num_bits) // The number of bits in the current digit + {} + + + // UpdateRanks + template + static __device__ __forceinline__ void UpdateRanks( + int (&ranks)[KEYS_PER_THREAD], + DigitCounter (&thread_prefixes)[KEYS_PER_THREAD], + DigitCounter *(&digit_counters)[KEYS_PER_THREAD]) + {} + }; + + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + /** + * Internal storage allocator + */ + __device__ __forceinline__ _TempStorage& PrivateStorage() + { + __shared__ _TempStorage private_storage; + return private_storage; + } + + + /** + * Performs upsweep raking reduction, returning the aggregate + */ + __device__ __forceinline__ PackedCounter Upsweep() + { + PackedCounter *smem_raking_ptr = temp_storage.raking_grid[linear_tid]; + PackedCounter *raking_ptr; + + if (MEMOIZE_OUTER_SCAN) + { + // Copy data into registers + #pragma unroll + for (int i = 0; i < RAKING_SEGMENT; i++) + { + cached_segment[i] = smem_raking_ptr[i]; + } + raking_ptr = cached_segment; + } + else + { + raking_ptr = smem_raking_ptr; + } + + return ThreadReduce(raking_ptr, Sum()); + } + + + /// Performs exclusive downsweep raking scan + __device__ __forceinline__ void ExclusiveDownsweep( + PackedCounter raking_partial) + { + PackedCounter *smem_raking_ptr = temp_storage.raking_grid[linear_tid]; + + PackedCounter *raking_ptr = (MEMOIZE_OUTER_SCAN) ? + cached_segment : + smem_raking_ptr; + + // Exclusive raking downsweep scan + ThreadScanExclusive(raking_ptr, raking_ptr, Sum(), raking_partial); + + if (MEMOIZE_OUTER_SCAN) + { + // Copy data back to smem + #pragma unroll + for (int i = 0; i < RAKING_SEGMENT; i++) + { + smem_raking_ptr[i] = cached_segment[i]; + } + } + } + + + /** + * Reset shared memory digit counters + */ + __device__ __forceinline__ void ResetCounters() + { + // Reset shared memory digit counters + #pragma unroll + for (int LANE = 0; LANE < COUNTER_LANES + 1; LANE++) + { + *((PackedCounter*) temp_storage.digit_counters[LANE][linear_tid]) = 0; + } + } + + + /** + * Scan shared memory digit counters. + */ + __device__ __forceinline__ void ScanCounters() + { + // Upsweep scan + PackedCounter raking_partial = Upsweep(); + + // Compute exclusive sum + PackedCounter exclusive_partial; + PackedCounter packed_aggregate; + BlockScan(temp_storage.block_scan).ExclusiveSum(raking_partial, exclusive_partial, packed_aggregate); + + // Propagate totals in packed fields + #pragma unroll + for (int PACKED = 1; PACKED < PACKING_RATIO; PACKED++) + { + exclusive_partial += packed_aggregate << (sizeof(DigitCounter) * 8 * PACKED); + } + + // Downsweep scan with exclusive partial + ExclusiveDownsweep(exclusive_partial); + } + +public: + + /// \smemstorage{BlockScan} + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + /** + * \brief Collective constructor using a private static allocation of shared memory as temporary storage. + */ + __device__ __forceinline__ BlockRadixRank() + : + temp_storage(PrivateStorage()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. + */ + __device__ __forceinline__ BlockRadixRank( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + //@} end member group + /******************************************************************//** + * \name Raking + *********************************************************************/ + //@{ + + /** + * \brief Rank keys. + */ + template < + typename UnsignedBits, + int KEYS_PER_THREAD> + __device__ __forceinline__ void RankKeys( + UnsignedBits (&keys)[KEYS_PER_THREAD], ///< [in] Keys for this tile + int (&ranks)[KEYS_PER_THREAD], ///< [out] For each key, the local rank within the tile + int current_bit, ///< [in] The least-significant bit position of the current digit to extract + int num_bits) ///< [in] The number of bits in the current digit + { + DigitCounter thread_prefixes[KEYS_PER_THREAD]; // For each key, the count of previous keys in this tile having the same digit + DigitCounter* digit_counters[KEYS_PER_THREAD]; // For each key, the byte-offset of its corresponding digit counter in smem + + // Reset shared memory digit counters + ResetCounters(); + + // Decode keys and update digit counters + Iterate<0, KEYS_PER_THREAD>::DecodeKeys(*this, keys, thread_prefixes, digit_counters, current_bit, num_bits); + + __syncthreads(); + + // Scan shared memory counters + ScanCounters(); + + __syncthreads(); + + // Extract the local ranks of each key + Iterate<0, KEYS_PER_THREAD>::UpdateRanks(ranks, thread_prefixes, digit_counters); + } + + + /** + * \brief Rank keys. For the lower \p RADIX_DIGITS threads, digit counts for each digit are provided for the corresponding thread. + */ + template < + typename UnsignedBits, + int KEYS_PER_THREAD> + __device__ __forceinline__ void RankKeys( + UnsignedBits (&keys)[KEYS_PER_THREAD], ///< [in] Keys for this tile + int (&ranks)[KEYS_PER_THREAD], ///< [out] For each key, the local rank within the tile (out parameter) + int current_bit, ///< [in] The least-significant bit position of the current digit to extract + int num_bits, ///< [in] The number of bits in the current digit + int &inclusive_digit_prefix) ///< [out] The incluisve prefix sum for the digit threadIdx.x + { + // Rank keys + RankKeys(keys, ranks, current_bit, num_bits); + + // Get the inclusive and exclusive digit totals corresponding to the calling thread. + if ((BLOCK_THREADS == RADIX_DIGITS) || (linear_tid < RADIX_DIGITS)) + { + int bin_idx = (DESCENDING) ? + RADIX_DIGITS - linear_tid - 1 : + linear_tid; + + // Obtain ex/inclusive digit counts. (Unfortunately these all reside in the + // first counter column, resulting in unavoidable bank conflicts.) + int counter_lane = (bin_idx & (COUNTER_LANES - 1)); + int sub_counter = bin_idx >> (LOG_COUNTER_LANES); + inclusive_digit_prefix = temp_storage.digit_counters[counter_lane + 1][0][sub_counter]; + } + } +}; + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/block/block_radix_sort.cuh b/3rdparty/cub/cub/block/block_radix_sort.cuh new file mode 100644 index 00000000000..5a9216a6b80 --- /dev/null +++ b/3rdparty/cub/cub/block/block_radix_sort.cuh @@ -0,0 +1,865 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * The cub::BlockRadixSort class provides [collective](index.html#sec0) methods for radix sorting of items partitioned across a CUDA thread block. + */ + + +#pragma once + +#include "block_exchange.cuh" +#include "block_radix_rank.cuh" +#include "../util_ptx.cuh" +#include "../util_arch.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \brief The BlockRadixSort class provides [collective](index.html#sec0) methods for sorting items partitioned across a CUDA thread block using a radix sorting method. ![](sorting_logo.png) + * \ingroup BlockModule + * + * \tparam KeyT KeyT type + * \tparam BLOCK_DIM_X The thread block length in threads along the X dimension + * \tparam ITEMS_PER_THREAD The number of items per thread + * \tparam ValueT [optional] ValueT type (default: cub::NullType, which indicates a keys-only sort) + * \tparam RADIX_BITS [optional] The number of radix bits per digit place (default: 4 bits) + * \tparam MEMOIZE_OUTER_SCAN [optional] Whether or not to buffer outer raking scan partials to incur fewer shared memory reads at the expense of higher register pressure (default: true for architectures SM35 and newer, false otherwise). + * \tparam INNER_SCAN_ALGORITHM [optional] The cub::BlockScanAlgorithm algorithm to use (default: cub::BLOCK_SCAN_WARP_SCANS) + * \tparam SMEM_CONFIG [optional] Shared memory bank mode (default: \p cudaSharedMemBankSizeFourByte) + * \tparam BLOCK_DIM_Y [optional] The thread block length in threads along the Y dimension (default: 1) + * \tparam BLOCK_DIM_Z [optional] The thread block length in threads along the Z dimension (default: 1) + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * - The [radix sorting method](http://en.wikipedia.org/wiki/Radix_sort) arranges + * items into ascending order. It relies upon a positional representation for + * keys, i.e., each key is comprised of an ordered sequence of symbols (e.g., digits, + * characters, etc.) specified from least-significant to most-significant. For a + * given input sequence of keys and a set of rules specifying a total ordering + * of the symbolic alphabet, the radix sorting method produces a lexicographic + * ordering of those keys. + * - BlockRadixSort can sort all of the built-in C++ numeric primitive types, e.g.: + * unsigned char, \p int, \p double, etc. Within each key, the implementation treats fixed-length + * bit-sequences of \p RADIX_BITS as radix digit places. Although the direct radix sorting + * method can only be applied to unsigned integral types, BlockRadixSort + * is able to sort signed and floating-point types via simple bit-wise transformations + * that ensure lexicographic key ordering. + * - \rowmajor + * + * \par Performance Considerations + * - \granularity + * + * \par A Simple Example + * \blockcollective{BlockRadixSort} + * \par + * The code snippet below illustrates a sort of 512 integer keys that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockRadixSort for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockRadixSort BlockRadixSort; + * + * // Allocate shared memory for BlockRadixSort + * __shared__ typename BlockRadixSort::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_keys[4]; + * ... + * + * // Collectively sort the keys + * BlockRadixSort(temp_storage).Sort(thread_keys); + * + * ... + * \endcode + * \par + * Suppose the set of input \p thread_keys across the block of threads is + * { [0,511,1,510], [2,509,3,508], [4,507,5,506], ..., [254,257,255,256] }. The + * corresponding output \p thread_keys in those threads will be + * { [0,1,2,3], [4,5,6,7], [8,9,10,11], ..., [508,509,510,511] }. + * + */ +template < + typename KeyT, + int BLOCK_DIM_X, + int ITEMS_PER_THREAD, + typename ValueT = NullType, + int RADIX_BITS = 4, + bool MEMOIZE_OUTER_SCAN = (CUB_PTX_ARCH >= 350) ? true : false, + BlockScanAlgorithm INNER_SCAN_ALGORITHM = BLOCK_SCAN_WARP_SCANS, + cudaSharedMemConfig SMEM_CONFIG = cudaSharedMemBankSizeFourByte, + int BLOCK_DIM_Y = 1, + int BLOCK_DIM_Z = 1, + int PTX_ARCH = CUB_PTX_ARCH> +class BlockRadixSort +{ +private: + + /****************************************************************************** + * Constants and type definitions + ******************************************************************************/ + + enum + { + // The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + + // Whether or not there are values to be trucked along with keys + KEYS_ONLY = Equals::VALUE, + }; + + // KeyT traits and unsigned bits type + typedef NumericTraits KeyTraits; + typedef typename KeyTraits::UnsignedBits UnsignedBits; + + /// Ascending BlockRadixRank utility type + typedef BlockRadixRank< + BLOCK_DIM_X, + RADIX_BITS, + false, + MEMOIZE_OUTER_SCAN, + INNER_SCAN_ALGORITHM, + SMEM_CONFIG, + BLOCK_DIM_Y, + BLOCK_DIM_Z, + PTX_ARCH> + AscendingBlockRadixRank; + + /// Descending BlockRadixRank utility type + typedef BlockRadixRank< + BLOCK_DIM_X, + RADIX_BITS, + true, + MEMOIZE_OUTER_SCAN, + INNER_SCAN_ALGORITHM, + SMEM_CONFIG, + BLOCK_DIM_Y, + BLOCK_DIM_Z, + PTX_ARCH> + DescendingBlockRadixRank; + + /// BlockExchange utility type for keys + typedef BlockExchange BlockExchangeKeys; + + /// BlockExchange utility type for values + typedef BlockExchange BlockExchangeValues; + + /// Shared memory storage layout type + struct _TempStorage + { + union + { + typename AscendingBlockRadixRank::TempStorage asending_ranking_storage; + typename DescendingBlockRadixRank::TempStorage descending_ranking_storage; + typename BlockExchangeKeys::TempStorage exchange_keys; + typename BlockExchangeValues::TempStorage exchange_values; + }; + }; + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Shared storage reference + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + /// Internal storage allocator + __device__ __forceinline__ _TempStorage& PrivateStorage() + { + __shared__ _TempStorage private_storage; + return private_storage; + } + + /// Rank keys (specialized for ascending sort) + __device__ __forceinline__ void RankKeys( + UnsignedBits (&unsigned_keys)[ITEMS_PER_THREAD], + int (&ranks)[ITEMS_PER_THREAD], + int begin_bit, + int pass_bits, + Int2Type is_descending) + { + AscendingBlockRadixRank(temp_storage.asending_ranking_storage).RankKeys( + unsigned_keys, + ranks, + begin_bit, + pass_bits); + } + + /// Rank keys (specialized for descending sort) + __device__ __forceinline__ void RankKeys( + UnsignedBits (&unsigned_keys)[ITEMS_PER_THREAD], + int (&ranks)[ITEMS_PER_THREAD], + int begin_bit, + int pass_bits, + Int2Type is_descending) + { + DescendingBlockRadixRank(temp_storage.descending_ranking_storage).RankKeys( + unsigned_keys, + ranks, + begin_bit, + pass_bits); + } + + /// ExchangeValues (specialized for key-value sort, to-blocked arrangement) + __device__ __forceinline__ void ExchangeValues( + ValueT (&values)[ITEMS_PER_THREAD], + int (&ranks)[ITEMS_PER_THREAD], + Int2Type is_keys_only, + Int2Type is_blocked) + { + __syncthreads(); + + // Exchange values through shared memory in blocked arrangement + BlockExchangeValues(temp_storage.exchange_values).ScatterToBlocked(values, ranks); + } + + /// ExchangeValues (specialized for key-value sort, to-striped arrangement) + __device__ __forceinline__ void ExchangeValues( + ValueT (&values)[ITEMS_PER_THREAD], + int (&ranks)[ITEMS_PER_THREAD], + Int2Type is_keys_only, + Int2Type is_blocked) + { + __syncthreads(); + + // Exchange values through shared memory in blocked arrangement + BlockExchangeValues(temp_storage.exchange_values).ScatterToStriped(values, ranks); + } + + /// ExchangeValues (specialized for keys-only sort) + template + __device__ __forceinline__ void ExchangeValues( + ValueT (&values)[ITEMS_PER_THREAD], + int (&ranks)[ITEMS_PER_THREAD], + Int2Type is_keys_only, + Int2Type is_blocked) + {} + + /// Sort blocked arrangement + template + __device__ __forceinline__ void SortBlocked( + KeyT (&keys)[ITEMS_PER_THREAD], ///< Keys to sort + ValueT (&values)[ITEMS_PER_THREAD], ///< Values to sort + int begin_bit, ///< The beginning (least-significant) bit index needed for key comparison + int end_bit, ///< The past-the-end (most-significant) bit index needed for key comparison + Int2Type is_descending, ///< Tag whether is a descending-order sort + Int2Type is_keys_only) ///< Tag whether is keys-only sort + { + UnsignedBits (&unsigned_keys)[ITEMS_PER_THREAD] = + reinterpret_cast(keys); + + // Twiddle bits if necessary + #pragma unroll + for (int KEY = 0; KEY < ITEMS_PER_THREAD; KEY++) + { + unsigned_keys[KEY] = KeyTraits::TwiddleIn(unsigned_keys[KEY]); + } + + // Radix sorting passes + while (true) + { + int pass_bits = CUB_MIN(RADIX_BITS, end_bit - begin_bit); + + // Rank the blocked keys + int ranks[ITEMS_PER_THREAD]; + RankKeys(unsigned_keys, ranks, begin_bit, pass_bits, is_descending); + begin_bit += RADIX_BITS; + + __syncthreads(); + + // Exchange keys through shared memory in blocked arrangement + BlockExchangeKeys(temp_storage.exchange_keys).ScatterToBlocked(keys, ranks); + + // Exchange values through shared memory in blocked arrangement + ExchangeValues(values, ranks, is_keys_only, Int2Type()); + + // Quit if done + if (begin_bit >= end_bit) break; + + __syncthreads(); + } + + // Untwiddle bits if necessary + #pragma unroll + for (int KEY = 0; KEY < ITEMS_PER_THREAD; KEY++) + { + unsigned_keys[KEY] = KeyTraits::TwiddleOut(unsigned_keys[KEY]); + } + } + +public: + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + /// Sort blocked -> striped arrangement + template + __device__ __forceinline__ void SortBlockedToStriped( + KeyT (&keys)[ITEMS_PER_THREAD], ///< Keys to sort + ValueT (&values)[ITEMS_PER_THREAD], ///< Values to sort + int begin_bit, ///< The beginning (least-significant) bit index needed for key comparison + int end_bit, ///< The past-the-end (most-significant) bit index needed for key comparison + Int2Type is_descending, ///< Tag whether is a descending-order sort + Int2Type is_keys_only) ///< Tag whether is keys-only sort + { + UnsignedBits (&unsigned_keys)[ITEMS_PER_THREAD] = + reinterpret_cast(keys); + + // Twiddle bits if necessary + #pragma unroll + for (int KEY = 0; KEY < ITEMS_PER_THREAD; KEY++) + { + unsigned_keys[KEY] = KeyTraits::TwiddleIn(unsigned_keys[KEY]); + } + + // Radix sorting passes + while (true) + { + int pass_bits = CUB_MIN(RADIX_BITS, end_bit - begin_bit); + + // Rank the blocked keys + int ranks[ITEMS_PER_THREAD]; + RankKeys(unsigned_keys, ranks, begin_bit, pass_bits, is_descending); + begin_bit += RADIX_BITS; + + __syncthreads(); + + // Check if this is the last pass + if (begin_bit >= end_bit) + { + // Last pass exchanges keys through shared memory in striped arrangement + BlockExchangeKeys(temp_storage.exchange_keys).ScatterToStriped(keys, ranks); + + // Last pass exchanges through shared memory in striped arrangement + ExchangeValues(values, ranks, is_keys_only, Int2Type()); + + // Quit + break; + } + + // Exchange keys through shared memory in blocked arrangement + BlockExchangeKeys(temp_storage.exchange_keys).ScatterToBlocked(keys, ranks); + + // Exchange values through shared memory in blocked arrangement + ExchangeValues(values, ranks, is_keys_only, Int2Type()); + + __syncthreads(); + } + + // Untwiddle bits if necessary + #pragma unroll + for (int KEY = 0; KEY < ITEMS_PER_THREAD; KEY++) + { + unsigned_keys[KEY] = KeyTraits::TwiddleOut(unsigned_keys[KEY]); + } + } + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + /// \smemstorage{BlockScan} + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + /** + * \brief Collective constructor using a private static allocation of shared memory as temporary storage. + */ + __device__ __forceinline__ BlockRadixSort() + : + temp_storage(PrivateStorage()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. + */ + __device__ __forceinline__ BlockRadixSort( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + //@} end member group + /******************************************************************//** + * \name Sorting (blocked arrangements) + *********************************************************************/ + //@{ + + /** + * \brief Performs an ascending block-wide radix sort over a [blocked arrangement](index.html#sec5sec3) of keys. + * + * \par + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sort of 512 integer keys that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive keys. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockRadixSort for a 1D block of 128 threads owning 4 integer keys each + * typedef cub::BlockRadixSort BlockRadixSort; + * + * // Allocate shared memory for BlockRadixSort + * __shared__ typename BlockRadixSort::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_keys[4]; + * ... + * + * // Collectively sort the keys + * BlockRadixSort(temp_storage).Sort(thread_keys); + * + * \endcode + * \par + * Suppose the set of input \p thread_keys across the block of threads is + * { [0,511,1,510], [2,509,3,508], [4,507,5,506], ..., [254,257,255,256] }. + * The corresponding output \p thread_keys in those threads will be + * { [0,1,2,3], [4,5,6,7], [8,9,10,11], ..., [508,509,510,511] }. + */ + __device__ __forceinline__ void Sort( + KeyT (&keys)[ITEMS_PER_THREAD], ///< [in-out] Keys to sort + int begin_bit = 0, ///< [in] [optional] The beginning (least-significant) bit index needed for key comparison + int end_bit = sizeof(KeyT) * 8) ///< [in] [optional] The past-the-end (most-significant) bit index needed for key comparison + { + NullType values[ITEMS_PER_THREAD]; + + SortBlocked(keys, values, begin_bit, end_bit, Int2Type(), Int2Type()); + } + + + /** + * \brief Performs an ascending block-wide radix sort across a [blocked arrangement](index.html#sec5sec3) of keys and values. + * + * \par + * - BlockRadixSort can only accommodate one associated tile of values. To "truck along" + * more than one tile of values, simply perform a key-value sort of the keys paired + * with a temporary value array that enumerates the key indices. The reordered indices + * can then be used as a gather-vector for exchanging other associated tile data through + * shared memory. + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sort of 512 integer keys and values that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive pairs. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockRadixSort for a 1D block of 128 threads owning 4 integer keys and values each + * typedef cub::BlockRadixSort BlockRadixSort; + * + * // Allocate shared memory for BlockRadixSort + * __shared__ typename BlockRadixSort::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_keys[4]; + * int thread_values[4]; + * ... + * + * // Collectively sort the keys and values among block threads + * BlockRadixSort(temp_storage).Sort(thread_keys, thread_values); + * + * \endcode + * \par + * Suppose the set of input \p thread_keys across the block of threads is + * { [0,511,1,510], [2,509,3,508], [4,507,5,506], ..., [254,257,255,256] }. The + * corresponding output \p thread_keys in those threads will be + * { [0,1,2,3], [4,5,6,7], [8,9,10,11], ..., [508,509,510,511] }. + * + */ + __device__ __forceinline__ void Sort( + KeyT (&keys)[ITEMS_PER_THREAD], ///< [in-out] Keys to sort + ValueT (&values)[ITEMS_PER_THREAD], ///< [in-out] Values to sort + int begin_bit = 0, ///< [in] [optional] The beginning (least-significant) bit index needed for key comparison + int end_bit = sizeof(KeyT) * 8) ///< [in] [optional] The past-the-end (most-significant) bit index needed for key comparison + { + SortBlocked(keys, values, begin_bit, end_bit, Int2Type(), Int2Type()); + } + + /** + * \brief Performs a descending block-wide radix sort over a [blocked arrangement](index.html#sec5sec3) of keys. + * + * \par + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sort of 512 integer keys that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive keys. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockRadixSort for a 1D block of 128 threads owning 4 integer keys each + * typedef cub::BlockRadixSort BlockRadixSort; + * + * // Allocate shared memory for BlockRadixSort + * __shared__ typename BlockRadixSort::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_keys[4]; + * ... + * + * // Collectively sort the keys + * BlockRadixSort(temp_storage).Sort(thread_keys); + * + * \endcode + * \par + * Suppose the set of input \p thread_keys across the block of threads is + * { [0,511,1,510], [2,509,3,508], [4,507,5,506], ..., [254,257,255,256] }. + * The corresponding output \p thread_keys in those threads will be + * { [511,510,509,508], [11,10,9,8], [7,6,5,4], ..., [3,2,1,0] }. + */ + __device__ __forceinline__ void SortDescending( + KeyT (&keys)[ITEMS_PER_THREAD], ///< [in-out] Keys to sort + int begin_bit = 0, ///< [in] [optional] The beginning (least-significant) bit index needed for key comparison + int end_bit = sizeof(KeyT) * 8) ///< [in] [optional] The past-the-end (most-significant) bit index needed for key comparison + { + NullType values[ITEMS_PER_THREAD]; + + SortBlocked(keys, values, begin_bit, end_bit, Int2Type(), Int2Type()); + } + + + /** + * \brief Performs a descending block-wide radix sort across a [blocked arrangement](index.html#sec5sec3) of keys and values. + * + * \par + * - BlockRadixSort can only accommodate one associated tile of values. To "truck along" + * more than one tile of values, simply perform a key-value sort of the keys paired + * with a temporary value array that enumerates the key indices. The reordered indices + * can then be used as a gather-vector for exchanging other associated tile data through + * shared memory. + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sort of 512 integer keys and values that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive pairs. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockRadixSort for a 1D block of 128 threads owning 4 integer keys and values each + * typedef cub::BlockRadixSort BlockRadixSort; + * + * // Allocate shared memory for BlockRadixSort + * __shared__ typename BlockRadixSort::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_keys[4]; + * int thread_values[4]; + * ... + * + * // Collectively sort the keys and values among block threads + * BlockRadixSort(temp_storage).Sort(thread_keys, thread_values); + * + * \endcode + * \par + * Suppose the set of input \p thread_keys across the block of threads is + * { [0,511,1,510], [2,509,3,508], [4,507,5,506], ..., [254,257,255,256] }. The + * corresponding output \p thread_keys in those threads will be + * { [511,510,509,508], [11,10,9,8], [7,6,5,4], ..., [3,2,1,0] }. + * + */ + __device__ __forceinline__ void SortDescending( + KeyT (&keys)[ITEMS_PER_THREAD], ///< [in-out] Keys to sort + ValueT (&values)[ITEMS_PER_THREAD], ///< [in-out] Values to sort + int begin_bit = 0, ///< [in] [optional] The beginning (least-significant) bit index needed for key comparison + int end_bit = sizeof(KeyT) * 8) ///< [in] [optional] The past-the-end (most-significant) bit index needed for key comparison + { + SortBlocked(keys, values, begin_bit, end_bit, Int2Type(), Int2Type()); + } + + + //@} end member group + /******************************************************************//** + * \name Sorting (blocked arrangement -> striped arrangement) + *********************************************************************/ + //@{ + + + /** + * \brief Performs an ascending radix sort across a [blocked arrangement](index.html#sec5sec3) of keys, leaving them in a [striped arrangement](index.html#sec5sec3). + * + * \par + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sort of 512 integer keys that + * are initially partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive keys. The final partitioning is striped. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockRadixSort for a 1D block of 128 threads owning 4 integer keys each + * typedef cub::BlockRadixSort BlockRadixSort; + * + * // Allocate shared memory for BlockRadixSort + * __shared__ typename BlockRadixSort::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_keys[4]; + * ... + * + * // Collectively sort the keys + * BlockRadixSort(temp_storage).SortBlockedToStriped(thread_keys); + * + * \endcode + * \par + * Suppose the set of input \p thread_keys across the block of threads is + * { [0,511,1,510], [2,509,3,508], [4,507,5,506], ..., [254,257,255,256] }. The + * corresponding output \p thread_keys in those threads will be + * { [0,128,256,384], [1,129,257,385], [2,130,258,386], ..., [127,255,383,511] }. + * + */ + __device__ __forceinline__ void SortBlockedToStriped( + KeyT (&keys)[ITEMS_PER_THREAD], ///< [in-out] Keys to sort + int begin_bit = 0, ///< [in] [optional] The beginning (least-significant) bit index needed for key comparison + int end_bit = sizeof(KeyT) * 8) ///< [in] [optional] The past-the-end (most-significant) bit index needed for key comparison + { + NullType values[ITEMS_PER_THREAD]; + + SortBlockedToStriped(keys, values, begin_bit, end_bit, Int2Type(), Int2Type()); + } + + + /** + * \brief Performs an ascending radix sort across a [blocked arrangement](index.html#sec5sec3) of keys and values, leaving them in a [striped arrangement](index.html#sec5sec3). + * + * \par + * - BlockRadixSort can only accommodate one associated tile of values. To "truck along" + * more than one tile of values, simply perform a key-value sort of the keys paired + * with a temporary value array that enumerates the key indices. The reordered indices + * can then be used as a gather-vector for exchanging other associated tile data through + * shared memory. + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sort of 512 integer keys and values that + * are initially partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive pairs. The final partitioning is striped. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockRadixSort for a 1D block of 128 threads owning 4 integer keys and values each + * typedef cub::BlockRadixSort BlockRadixSort; + * + * // Allocate shared memory for BlockRadixSort + * __shared__ typename BlockRadixSort::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_keys[4]; + * int thread_values[4]; + * ... + * + * // Collectively sort the keys and values among block threads + * BlockRadixSort(temp_storage).SortBlockedToStriped(thread_keys, thread_values); + * + * \endcode + * \par + * Suppose the set of input \p thread_keys across the block of threads is + * { [0,511,1,510], [2,509,3,508], [4,507,5,506], ..., [254,257,255,256] }. The + * corresponding output \p thread_keys in those threads will be + * { [0,128,256,384], [1,129,257,385], [2,130,258,386], ..., [127,255,383,511] }. + * + */ + __device__ __forceinline__ void SortBlockedToStriped( + KeyT (&keys)[ITEMS_PER_THREAD], ///< [in-out] Keys to sort + ValueT (&values)[ITEMS_PER_THREAD], ///< [in-out] Values to sort + int begin_bit = 0, ///< [in] [optional] The beginning (least-significant) bit index needed for key comparison + int end_bit = sizeof(KeyT) * 8) ///< [in] [optional] The past-the-end (most-significant) bit index needed for key comparison + { + SortBlockedToStriped(keys, values, begin_bit, end_bit, Int2Type(), Int2Type()); + } + + + /** + * \brief Performs a descending radix sort across a [blocked arrangement](index.html#sec5sec3) of keys, leaving them in a [striped arrangement](index.html#sec5sec3). + * + * \par + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sort of 512 integer keys that + * are initially partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive keys. The final partitioning is striped. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockRadixSort for a 1D block of 128 threads owning 4 integer keys each + * typedef cub::BlockRadixSort BlockRadixSort; + * + * // Allocate shared memory for BlockRadixSort + * __shared__ typename BlockRadixSort::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_keys[4]; + * ... + * + * // Collectively sort the keys + * BlockRadixSort(temp_storage).SortBlockedToStriped(thread_keys); + * + * \endcode + * \par + * Suppose the set of input \p thread_keys across the block of threads is + * { [0,511,1,510], [2,509,3,508], [4,507,5,506], ..., [254,257,255,256] }. The + * corresponding output \p thread_keys in those threads will be + * { [511,383,255,127], [386,258,130,2], [385,257,128,1], ..., [384,256,128,0] }. + * + */ + __device__ __forceinline__ void SortDescendingBlockedToStriped( + KeyT (&keys)[ITEMS_PER_THREAD], ///< [in-out] Keys to sort + int begin_bit = 0, ///< [in] [optional] The beginning (least-significant) bit index needed for key comparison + int end_bit = sizeof(KeyT) * 8) ///< [in] [optional] The past-the-end (most-significant) bit index needed for key comparison + { + NullType values[ITEMS_PER_THREAD]; + + SortBlockedToStriped(keys, values, begin_bit, end_bit, Int2Type(), Int2Type()); + } + + + /** + * \brief Performs a descending radix sort across a [blocked arrangement](index.html#sec5sec3) of keys and values, leaving them in a [striped arrangement](index.html#sec5sec3). + * + * \par + * - BlockRadixSort can only accommodate one associated tile of values. To "truck along" + * more than one tile of values, simply perform a key-value sort of the keys paired + * with a temporary value array that enumerates the key indices. The reordered indices + * can then be used as a gather-vector for exchanging other associated tile data through + * shared memory. + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sort of 512 integer keys and values that + * are initially partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive pairs. The final partitioning is striped. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockRadixSort for a 1D block of 128 threads owning 4 integer keys and values each + * typedef cub::BlockRadixSort BlockRadixSort; + * + * // Allocate shared memory for BlockRadixSort + * __shared__ typename BlockRadixSort::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_keys[4]; + * int thread_values[4]; + * ... + * + * // Collectively sort the keys and values among block threads + * BlockRadixSort(temp_storage).SortBlockedToStriped(thread_keys, thread_values); + * + * \endcode + * \par + * Suppose the set of input \p thread_keys across the block of threads is + * { [0,511,1,510], [2,509,3,508], [4,507,5,506], ..., [254,257,255,256] }. The + * corresponding output \p thread_keys in those threads will be + * { [511,383,255,127], [386,258,130,2], [385,257,128,1], ..., [384,256,128,0] }. + * + */ + __device__ __forceinline__ void SortDescendingBlockedToStriped( + KeyT (&keys)[ITEMS_PER_THREAD], ///< [in-out] Keys to sort + ValueT (&values)[ITEMS_PER_THREAD], ///< [in-out] Values to sort + int begin_bit = 0, ///< [in] [optional] The beginning (least-significant) bit index needed for key comparison + int end_bit = sizeof(KeyT) * 8) ///< [in] [optional] The past-the-end (most-significant) bit index needed for key comparison + { + SortBlockedToStriped(keys, values, begin_bit, end_bit, Int2Type(), Int2Type()); + } + + + //@} end member group + +}; + +/** + * \example example_block_radix_sort.cu + */ + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/block_raking_layout.cuh b/3rdparty/cub/cub/block/block_raking_layout.cuh new file mode 100644 index 00000000000..999b7eab4ee --- /dev/null +++ b/3rdparty/cub/cub/block/block_raking_layout.cuh @@ -0,0 +1,150 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::BlockRakingLayout provides a conflict-free shared memory layout abstraction for warp-raking across thread block data. + */ + + +#pragma once + +#include "../util_macro.cuh" +#include "../util_arch.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \brief BlockRakingLayout provides a conflict-free shared memory layout abstraction for 1D raking across thread block data. ![](raking.png) + * \ingroup BlockModule + * + * \par Overview + * This type facilitates a shared memory usage pattern where a block of CUDA + * threads places elements into shared memory and then reduces the active + * parallelism to one "raking" warp of threads for serially aggregating consecutive + * sequences of shared items. Padding is inserted to eliminate bank conflicts + * (for most data types). + * + * \tparam T The data type to be exchanged. + * \tparam BLOCK_THREADS The thread block size in threads. + * \tparam PTX_ARCH [optional] \ptxversion + */ +template < + typename T, + int BLOCK_THREADS, + int PTX_ARCH = CUB_PTX_ARCH> +struct BlockRakingLayout +{ + //--------------------------------------------------------------------- + // Constants and type definitions + //--------------------------------------------------------------------- + + enum + { + /// The total number of elements that need to be cooperatively reduced + SHARED_ELEMENTS = BLOCK_THREADS, + + /// Maximum number of warp-synchronous raking threads + MAX_RAKING_THREADS = CUB_MIN(BLOCK_THREADS, CUB_WARP_THREADS(PTX_ARCH)), + + /// Number of raking elements per warp-synchronous raking thread (rounded up) + SEGMENT_LENGTH = (SHARED_ELEMENTS + MAX_RAKING_THREADS - 1) / MAX_RAKING_THREADS, + + /// Never use a raking thread that will have no valid data (e.g., when BLOCK_THREADS is 62 and SEGMENT_LENGTH is 2, we should only use 31 raking threads) + RAKING_THREADS = (SHARED_ELEMENTS + SEGMENT_LENGTH - 1) / SEGMENT_LENGTH, + + /// Whether we will have bank conflicts (technically we should find out if the GCD is > 1) + HAS_CONFLICTS = (CUB_SMEM_BANKS(PTX_ARCH) % SEGMENT_LENGTH == 0), + + /// Degree of bank conflicts (e.g., 4-way) + CONFLICT_DEGREE = (HAS_CONFLICTS) ? + (MAX_RAKING_THREADS * SEGMENT_LENGTH) / CUB_SMEM_BANKS(PTX_ARCH) : + 1, + + /// Pad each segment length with one element if degree of bank conflicts is greater than 4-way (heuristic) + SEGMENT_PADDING = (CONFLICT_DEGREE > CUB_PREFER_CONFLICT_OVER_PADDING(PTX_ARCH)) ? 1 : 0, +// SEGMENT_PADDING = (HAS_CONFLICTS) ? 1 : 0, + + /// Total number of elements in the raking grid + GRID_ELEMENTS = RAKING_THREADS * (SEGMENT_LENGTH + SEGMENT_PADDING), + + /// Whether or not we need bounds checking during raking (the number of reduction elements is not a multiple of the number of raking threads) + UNGUARDED = (SHARED_ELEMENTS % RAKING_THREADS == 0), + }; + + + /** + * \brief Shared memory storage type + */ + typedef T _TempStorage[BlockRakingLayout::GRID_ELEMENTS]; + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /** + * \brief Returns the location for the calling thread to place data into the grid + */ + static __device__ __forceinline__ T* PlacementPtr( + TempStorage &temp_storage, + int linear_tid) + { + // Offset for partial + unsigned int offset = linear_tid; + + // Add in one padding element for every segment + if (SEGMENT_PADDING > 0) + { + offset += offset / SEGMENT_LENGTH; + } + + // Incorporating a block of padding partials every shared memory segment + return temp_storage.Alias() + offset; + } + + + /** + * \brief Returns the location for the calling thread to begin sequential raking + */ + static __device__ __forceinline__ T* RakingPtr( + TempStorage &temp_storage, + int linear_tid) + { + return temp_storage.Alias() + (linear_tid * (SEGMENT_LENGTH + SEGMENT_PADDING)); + } +}; + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/block_reduce.cuh b/3rdparty/cub/cub/block/block_reduce.cuh new file mode 100644 index 00000000000..8c9878d7c92 --- /dev/null +++ b/3rdparty/cub/cub/block/block_reduce.cuh @@ -0,0 +1,607 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * The cub::BlockReduce class provides [collective](index.html#sec0) methods for computing a parallel reduction of items partitioned across a CUDA thread block. + */ + +#pragma once + +#include "specializations/block_reduce_raking.cuh" +#include "specializations/block_reduce_raking_commutative_only.cuh" +#include "specializations/block_reduce_warp_reductions.cuh" +#include "../util_ptx.cuh" +#include "../util_type.cuh" +#include "../thread/thread_operators.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + + +/****************************************************************************** + * Algorithmic variants + ******************************************************************************/ + +/** + * BlockReduceAlgorithm enumerates alternative algorithms for parallel + * reduction across a CUDA threadblock. + */ +enum BlockReduceAlgorithm +{ + + /** + * \par Overview + * An efficient "raking" reduction algorithm that only supports commutative + * reduction operators (true for most operations, e.g., addition). + * + * \par + * Execution is comprised of three phases: + * -# Upsweep sequential reduction in registers (if threads contribute more + * than one input each). Threads in warps other than the first warp place + * their partial reductions into shared memory. + * -# Upsweep sequential reduction in shared memory. Threads within the first + * warp continue to accumulate by raking across segments of shared partial reductions + * -# A warp-synchronous Kogge-Stone style reduction within the raking warp. + * + * \par + * \image html block_reduce.png + *

    \p BLOCK_REDUCE_RAKING data flow for a hypothetical 16-thread threadblock and 4-thread raking warp.
    + * + * \par Performance Considerations + * - This variant performs less communication than BLOCK_REDUCE_RAKING_NON_COMMUTATIVE + * and is preferable when the reduction operator is commutative. This variant + * applies fewer reduction operators than BLOCK_REDUCE_WARP_REDUCTIONS, and can provide higher overall + * throughput across the GPU when suitably occupied. However, turn-around latency may be + * higher than to BLOCK_REDUCE_WARP_REDUCTIONS and thus less-desirable + * when the GPU is under-occupied. + */ + BLOCK_REDUCE_RAKING_COMMUTATIVE_ONLY, + + + /** + * \par Overview + * An efficient "raking" reduction algorithm that supports commutative + * (e.g., addition) and non-commutative (e.g., string concatenation) reduction + * operators. \blocked. + * + * \par + * Execution is comprised of three phases: + * -# Upsweep sequential reduction in registers (if threads contribute more + * than one input each). Each thread then places the partial reduction + * of its item(s) into shared memory. + * -# Upsweep sequential reduction in shared memory. Threads within a + * single warp rake across segments of shared partial reductions. + * -# A warp-synchronous Kogge-Stone style reduction within the raking warp. + * + * \par + * \image html block_reduce.png + *
    \p BLOCK_REDUCE_RAKING data flow for a hypothetical 16-thread threadblock and 4-thread raking warp.
    + * + * \par Performance Considerations + * - This variant performs more communication than BLOCK_REDUCE_RAKING + * and is only preferable when the reduction operator is non-commutative. This variant + * applies fewer reduction operators than BLOCK_REDUCE_WARP_REDUCTIONS, and can provide higher overall + * throughput across the GPU when suitably occupied. However, turn-around latency may be + * higher than to BLOCK_REDUCE_WARP_REDUCTIONS and thus less-desirable + * when the GPU is under-occupied. + */ + BLOCK_REDUCE_RAKING, + + + /** + * \par Overview + * A quick "tiled warp-reductions" reduction algorithm that supports commutative + * (e.g., addition) and non-commutative (e.g., string concatenation) reduction + * operators. + * + * \par + * Execution is comprised of four phases: + * -# Upsweep sequential reduction in registers (if threads contribute more + * than one input each). Each thread then places the partial reduction + * of its item(s) into shared memory. + * -# Compute a shallow, but inefficient warp-synchronous Kogge-Stone style + * reduction within each warp. + * -# A propagation phase where the warp reduction outputs in each warp are + * updated with the aggregate from each preceding warp. + * + * \par + * \image html block_scan_warpscans.png + *
    \p BLOCK_REDUCE_WARP_REDUCTIONS data flow for a hypothetical 16-thread threadblock and 4-thread raking warp.
    + * + * \par Performance Considerations + * - This variant applies more reduction operators than BLOCK_REDUCE_RAKING + * or BLOCK_REDUCE_RAKING_NON_COMMUTATIVE, which may result in lower overall + * throughput across the GPU. However turn-around latency may be lower and + * thus useful when the GPU is under-occupied. + */ + BLOCK_REDUCE_WARP_REDUCTIONS, +}; + + +/****************************************************************************** + * Block reduce + ******************************************************************************/ + +/** + * \brief The BlockReduce class provides [collective](index.html#sec0) methods for computing a parallel reduction of items partitioned across a CUDA thread block. ![](reduce_logo.png) + * \ingroup BlockModule + * + * \tparam T Data type being reduced + * \tparam BLOCK_DIM_X The thread block length in threads along the X dimension + * \tparam ALGORITHM [optional] cub::BlockReduceAlgorithm enumerator specifying the underlying algorithm to use (default: cub::BLOCK_REDUCE_WARP_REDUCTIONS) + * \tparam BLOCK_DIM_Y [optional] The thread block length in threads along the Y dimension (default: 1) + * \tparam BLOCK_DIM_Z [optional] The thread block length in threads along the Z dimension (default: 1) + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * - A reduction (or fold) + * uses a binary combining operator to compute a single aggregate from a list of input elements. + * - \rowmajor + * - BlockReduce can be optionally specialized by algorithm to accommodate different latency/throughput workload profiles: + * -# cub::BLOCK_REDUCE_RAKING_COMMUTATIVE_ONLY. An efficient "raking" reduction algorithm that only supports commutative reduction operators. [More...](\ref cub::BlockReduceAlgorithm) + * -# cub::BLOCK_REDUCE_RAKING. An efficient "raking" reduction algorithm that supports commutative and non-commutative reduction operators. [More...](\ref cub::BlockReduceAlgorithm) + * -# cub::BLOCK_REDUCE_WARP_REDUCTIONS. A quick "tiled warp-reductions" reduction algorithm that supports commutative and non-commutative reduction operators. [More...](\ref cub::BlockReduceAlgorithm) + * + * \par Performance Considerations + * - \granularity + * - Very efficient (only one synchronization barrier). + * - Incurs zero bank conflicts for most types + * - Computation is slightly more efficient (i.e., having lower instruction overhead) for: + * - Summation (vs. generic reduction) + * - \p BLOCK_THREADS is a multiple of the architecture's warp size + * - Every thread has a valid input (i.e., full vs. partial-tiles) + * - See cub::BlockReduceAlgorithm for performance details regarding algorithmic alternatives + * + * \par A Simple Example + * \blockcollective{BlockReduce} + * \par + * The code snippet below illustrates a sum reduction of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockReduce for a 1D block of 128 threads on type int + * typedef cub::BlockReduce BlockReduce; + * + * // Allocate shared memory for BlockReduce + * __shared__ typename BlockReduce::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Compute the block-wide sum for thread0 + * int aggregate = BlockReduce(temp_storage).Sum(thread_data); + * + * \endcode + * + */ +template < + typename T, + int BLOCK_DIM_X, + BlockReduceAlgorithm ALGORITHM = BLOCK_REDUCE_WARP_REDUCTIONS, + int BLOCK_DIM_Y = 1, + int BLOCK_DIM_Z = 1, + int PTX_ARCH = CUB_PTX_ARCH> +class BlockReduce +{ +private: + + /****************************************************************************** + * Constants and type definitions + ******************************************************************************/ + + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + }; + + typedef BlockReduceWarpReductions WarpReductions; + typedef BlockReduceRakingCommutativeOnly RakingCommutativeOnly; + typedef BlockReduceRaking Raking; + + /// Internal specialization type + typedef typename If<(ALGORITHM == BLOCK_REDUCE_WARP_REDUCTIONS), + WarpReductions, + typename If<(ALGORITHM == BLOCK_REDUCE_RAKING_COMMUTATIVE_ONLY), + RakingCommutativeOnly, + Raking>::Type>::Type InternalBlockReduce; // BlockReduceRaking + + /// Shared memory storage layout type for BlockReduce + typedef typename InternalBlockReduce::TempStorage _TempStorage; + + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + /// Internal storage allocator + __device__ __forceinline__ _TempStorage& PrivateStorage() + { + __shared__ _TempStorage private_storage; + return private_storage; + } + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Shared storage reference + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + +public: + + /// \smemstorage{BlockReduce} + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + /** + * \brief Collective constructor using a private static allocation of shared memory as temporary storage. + */ + __device__ __forceinline__ BlockReduce() + : + temp_storage(PrivateStorage()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. + */ + __device__ __forceinline__ BlockReduce( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + //@} end member group + /******************************************************************//** + * \name Generic reductions + *********************************************************************/ + //@{ + + + /** + * \brief Computes a block-wide reduction for thread0 using the specified binary reduction functor. Each thread contributes one input element. + * + * \par + * - The return value is undefined in threads other than thread0. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a max reduction of 128 integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockReduce for a 1D block of 128 threads on type int + * typedef cub::BlockReduce BlockReduce; + * + * // Allocate shared memory for BlockReduce + * __shared__ typename BlockReduce::TempStorage temp_storage; + * + * // Each thread obtains an input item + * int thread_data; + * ... + * + * // Compute the block-wide max for thread0 + * int aggregate = BlockReduce(temp_storage).Reduce(thread_data, cub::Max()); + * + * \endcode + * + * \tparam ReductionOp [inferred] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ T Reduce( + T input, ///< [in] Calling thread's input + ReductionOp reduction_op) ///< [in] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + { + return InternalBlockReduce(temp_storage).template Reduce(input, BLOCK_THREADS, reduction_op); + } + + + /** + * \brief Computes a block-wide reduction for thread0 using the specified binary reduction functor. Each thread contributes an array of consecutive input elements. + * + * \par + * - The return value is undefined in threads other than thread0. + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a max reduction of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockReduce for a 1D block of 128 threads on type int + * typedef cub::BlockReduce BlockReduce; + * + * // Allocate shared memory for BlockReduce + * __shared__ typename BlockReduce::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Compute the block-wide max for thread0 + * int aggregate = BlockReduce(temp_storage).Reduce(thread_data, cub::Max()); + * + * \endcode + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam ReductionOp [inferred] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template < + int ITEMS_PER_THREAD, + typename ReductionOp> + __device__ __forceinline__ T Reduce( + T (&inputs)[ITEMS_PER_THREAD], ///< [in] Calling thread's input segment + ReductionOp reduction_op) ///< [in] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + { + // Reduce partials + T partial = ThreadReduce(inputs, reduction_op); + return Reduce(partial, reduction_op); + } + + + /** + * \brief Computes a block-wide reduction for thread0 using the specified binary reduction functor. The first \p num_valid threads each contribute one input element. + * + * \par + * - The return value is undefined in threads other than thread0. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a max reduction of a partially-full tile of integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int num_valid, ...) + * { + * // Specialize BlockReduce for a 1D block of 128 threads on type int + * typedef cub::BlockReduce BlockReduce; + * + * // Allocate shared memory for BlockReduce + * __shared__ typename BlockReduce::TempStorage temp_storage; + * + * // Each thread obtains an input item + * int thread_data; + * if (threadIdx.x < num_valid) thread_data = ... + * + * // Compute the block-wide max for thread0 + * int aggregate = BlockReduce(temp_storage).Reduce(thread_data, cub::Max(), num_valid); + * + * \endcode + * + * \tparam ReductionOp [inferred] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ T Reduce( + T input, ///< [in] Calling thread's input + ReductionOp reduction_op, ///< [in] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + int num_valid) ///< [in] Number of threads containing valid elements (may be less than BLOCK_THREADS) + { + // Determine if we scan skip bounds checking + if (num_valid >= BLOCK_THREADS) + { + return InternalBlockReduce(temp_storage).template Reduce(input, num_valid, reduction_op); + } + else + { + return InternalBlockReduce(temp_storage).template Reduce(input, num_valid, reduction_op); + } + } + + + //@} end member group + /******************************************************************//** + * \name Summation reductions + *********************************************************************/ + //@{ + + + /** + * \brief Computes a block-wide reduction for thread0 using addition (+) as the reduction operator. Each thread contributes one input element. + * + * \par + * - The return value is undefined in threads other than thread0. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sum reduction of 128 integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockReduce for a 1D block of 128 threads on type int + * typedef cub::BlockReduce BlockReduce; + * + * // Allocate shared memory for BlockReduce + * __shared__ typename BlockReduce::TempStorage temp_storage; + * + * // Each thread obtains an input item + * int thread_data; + * ... + * + * // Compute the block-wide sum for thread0 + * int aggregate = BlockReduce(temp_storage).Sum(thread_data); + * + * \endcode + * + */ + __device__ __forceinline__ T Sum( + T input) ///< [in] Calling thread's input + { + return InternalBlockReduce(temp_storage).template Sum(input, BLOCK_THREADS); + } + + /** + * \brief Computes a block-wide reduction for thread0 using addition (+) as the reduction operator. Each thread contributes an array of consecutive input elements. + * + * \par + * - The return value is undefined in threads other than thread0. + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sum reduction of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockReduce for a 1D block of 128 threads on type int + * typedef cub::BlockReduce BlockReduce; + * + * // Allocate shared memory for BlockReduce + * __shared__ typename BlockReduce::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Compute the block-wide sum for thread0 + * int aggregate = BlockReduce(temp_storage).Sum(thread_data); + * + * \endcode + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + */ + template + __device__ __forceinline__ T Sum( + T (&inputs)[ITEMS_PER_THREAD]) ///< [in] Calling thread's input segment + { + // Reduce partials + T partial = ThreadReduce(inputs, cub::Sum()); + return Sum(partial); + } + + + /** + * \brief Computes a block-wide reduction for thread0 using addition (+) as the reduction operator. The first \p num_valid threads each contribute one input element. + * + * \par + * - The return value is undefined in threads other than thread0. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sum reduction of a partially-full tile of integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int num_valid, ...) + * { + * // Specialize BlockReduce for a 1D block of 128 threads on type int + * typedef cub::BlockReduce BlockReduce; + * + * // Allocate shared memory for BlockReduce + * __shared__ typename BlockReduce::TempStorage temp_storage; + * + * // Each thread obtains an input item (up to num_items) + * int thread_data; + * if (threadIdx.x < num_valid) + * thread_data = ... + * + * // Compute the block-wide sum for thread0 + * int aggregate = BlockReduce(temp_storage).Sum(thread_data, num_valid); + * + * \endcode + * + */ + __device__ __forceinline__ T Sum( + T input, ///< [in] Calling thread's input + int num_valid) ///< [in] Number of threads containing valid elements (may be less than BLOCK_THREADS) + { + // Determine if we scan skip bounds checking + if (num_valid >= BLOCK_THREADS) + { + return InternalBlockReduce(temp_storage).template Sum(input, num_valid); + } + else + { + return InternalBlockReduce(temp_storage).template Sum(input, num_valid); + } + } + + + //@} end member group +}; + +/** + * \example example_block_reduce.cu + */ + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/block_scan.cuh b/3rdparty/cub/cub/block/block_scan.cuh new file mode 100644 index 00000000000..7c07b213720 --- /dev/null +++ b/3rdparty/cub/cub/block/block_scan.cuh @@ -0,0 +1,2251 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * The cub::BlockScan class provides [collective](index.html#sec0) methods for computing a parallel prefix sum/scan of items partitioned across a CUDA thread block. + */ + +#pragma once + +#include "specializations/block_scan_raking.cuh" +#include "specializations/block_scan_warp_scans.cuh" +#include "../util_arch.cuh" +#include "../util_type.cuh" +#include "../util_ptx.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Algorithmic variants + ******************************************************************************/ + +/** + * \brief BlockScanAlgorithm enumerates alternative algorithms for cub::BlockScan to compute a parallel prefix scan across a CUDA thread block. + */ +enum BlockScanAlgorithm +{ + + /** + * \par Overview + * An efficient "raking reduce-then-scan" prefix scan algorithm. Execution is comprised of five phases: + * -# Upsweep sequential reduction in registers (if threads contribute more than one input each). Each thread then places the partial reduction of its item(s) into shared memory. + * -# Upsweep sequential reduction in shared memory. Threads within a single warp rake across segments of shared partial reductions. + * -# A warp-synchronous Kogge-Stone style exclusive scan within the raking warp. + * -# Downsweep sequential exclusive scan in shared memory. Threads within a single warp rake across segments of shared partial reductions, seeded with the warp-scan output. + * -# Downsweep sequential scan in registers (if threads contribute more than one input), seeded with the raking scan output. + * + * \par + * \image html block_scan_raking.png + *
    \p BLOCK_SCAN_RAKING data flow for a hypothetical 16-thread threadblock and 4-thread raking warp.
    + * + * \par Performance Considerations + * - Although this variant may suffer longer turnaround latencies when the + * GPU is under-occupied, it can often provide higher overall throughput + * across the GPU when suitably occupied. + */ + BLOCK_SCAN_RAKING, + + + /** + * \par Overview + * Similar to cub::BLOCK_SCAN_RAKING, but with fewer shared memory reads at + * the expense of higher register pressure. Raking threads preserve their + * "upsweep" segment of values in registers while performing warp-synchronous + * scan, allowing the "downsweep" not to re-read them from shared memory. + */ + BLOCK_SCAN_RAKING_MEMOIZE, + + + /** + * \par Overview + * A quick "tiled warpscans" prefix scan algorithm. Execution is comprised of four phases: + * -# Upsweep sequential reduction in registers (if threads contribute more than one input each). Each thread then places the partial reduction of its item(s) into shared memory. + * -# Compute a shallow, but inefficient warp-synchronous Kogge-Stone style scan within each warp. + * -# A propagation phase where the warp scan outputs in each warp are updated with the aggregate from each preceding warp. + * -# Downsweep sequential scan in registers (if threads contribute more than one input), seeded with the raking scan output. + * + * \par + * \image html block_scan_warpscans.png + *
    \p BLOCK_SCAN_WARP_SCANS data flow for a hypothetical 16-thread threadblock and 4-thread raking warp.
    + * + * \par Performance Considerations + * - Although this variant may suffer lower overall throughput across the + * GPU because due to a heavy reliance on inefficient warpscans, it can + * often provide lower turnaround latencies when the GPU is under-occupied. + */ + BLOCK_SCAN_WARP_SCANS, +}; + + +/****************************************************************************** + * Block scan + ******************************************************************************/ + +/** + * \brief The BlockScan class provides [collective](index.html#sec0) methods for computing a parallel prefix sum/scan of items partitioned across a CUDA thread block. ![](block_scan_logo.png) + * \ingroup BlockModule + * + * \tparam T Data type being scanned + * \tparam BLOCK_DIM_X The thread block length in threads along the X dimension + * \tparam ALGORITHM [optional] cub::BlockScanAlgorithm enumerator specifying the underlying algorithm to use (default: cub::BLOCK_SCAN_RAKING) + * \tparam BLOCK_DIM_Y [optional] The thread block length in threads along the Y dimension (default: 1) + * \tparam BLOCK_DIM_Z [optional] The thread block length in threads along the Z dimension (default: 1) + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * - Given a list of input elements and a binary reduction operator, a [prefix scan](http://en.wikipedia.org/wiki/Prefix_sum) + * produces an output list where each element is computed to be the reduction + * of the elements occurring earlier in the input list. Prefix sum + * connotes a prefix scan with the addition operator. The term \em inclusive indicates + * that the ith output reduction incorporates the ith input. + * The term \em exclusive indicates the ith input is not incorporated into + * the ith output reduction. + * - \rowmajor + * - BlockScan can be optionally specialized by algorithm to accommodate different workload profiles: + * -# cub::BLOCK_SCAN_RAKING. An efficient (high throughput) "raking reduce-then-scan" prefix scan algorithm. [More...](\ref cub::BlockScanAlgorithm) + * -# cub::BLOCK_SCAN_RAKING_MEMOIZE. Similar to cub::BLOCK_SCAN_RAKING, but having higher throughput at the expense of additional register pressure for intermediate storage. [More...](\ref cub::BlockScanAlgorithm) + * -# cub::BLOCK_SCAN_WARP_SCANS. A quick (low latency) "tiled warpscans" prefix scan algorithm. [More...](\ref cub::BlockScanAlgorithm) + * + * \par Performance Considerations + * - \granularity + * - Uses special instructions when applicable (e.g., warp \p SHFL) + * - Uses synchronization-free communication between warp lanes when applicable + * - Invokes a minimal number of minimal block-wide synchronization barriers (only + * one or two depending on algorithm selection) + * - Incurs zero bank conflicts for most types + * - Computation is slightly more efficient (i.e., having lower instruction overhead) for: + * - Prefix sum variants (vs. generic scan) + * - \blocksize + * - See cub::BlockScanAlgorithm for performance details regarding algorithmic alternatives + * + * \par A Simple Example + * \blockcollective{BlockScan} + * \par + * The code snippet below illustrates an exclusive prefix sum of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute the block-wide exclusive prefix sum + * BlockScan(temp_storage).ExclusiveSum(thread_data, thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * {[1,1,1,1], [1,1,1,1], ..., [1,1,1,1]}. + * The corresponding output \p thread_data in those threads will be + * {[0,1,2,3], [4,5,6,7], ..., [508,509,510,511]}. + * + */ +template < + typename T, + int BLOCK_DIM_X, + BlockScanAlgorithm ALGORITHM = BLOCK_SCAN_RAKING, + int BLOCK_DIM_Y = 1, + int BLOCK_DIM_Z = 1, + int PTX_ARCH = CUB_PTX_ARCH> +class BlockScan +{ +private: + + /****************************************************************************** + * Constants and type definitions + ******************************************************************************/ + + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + }; + + /** + * Ensure the template parameterization meets the requirements of the + * specified algorithm. Currently, the BLOCK_SCAN_WARP_SCANS policy + * cannot be used with threadblock sizes not a multiple of the + * architectural warp size. + */ + static const BlockScanAlgorithm SAFE_ALGORITHM = + ((ALGORITHM == BLOCK_SCAN_WARP_SCANS) && (BLOCK_THREADS % CUB_WARP_THREADS(PTX_ARCH) != 0)) ? + BLOCK_SCAN_RAKING : + ALGORITHM; + + typedef BlockScanWarpScans WarpScans; + typedef BlockScanRaking Raking; + + /// Define the delegate type for the desired algorithm + typedef typename If<(SAFE_ALGORITHM == BLOCK_SCAN_WARP_SCANS), + WarpScans, + Raking>::Type InternalBlockScan; + + /// Shared memory storage layout type for BlockScan + typedef typename InternalBlockScan::TempStorage _TempStorage; + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Shared storage reference + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + /// Internal storage allocator + __device__ __forceinline__ _TempStorage& PrivateStorage() + { + __shared__ _TempStorage private_storage; + return private_storage; + } + + + /****************************************************************************** + * Public types + ******************************************************************************/ +public: + + /// \smemstorage{BlockScan} + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + /** + * \brief Collective constructor using a private static allocation of shared memory as temporary storage. + */ + __device__ __forceinline__ BlockScan() + : + temp_storage(PrivateStorage()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. + */ + __device__ __forceinline__ BlockScan( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + + + + + //@} end member group + /******************************************************************//** + * \name Exclusive prefix sum operations + *********************************************************************/ + //@{ + + + /** + * \brief Computes an exclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes one input element. + * + * \par + * - \identityzero + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an exclusive prefix sum of 128 integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain input item for each thread + * int thread_data; + * ... + * + * // Collectively compute the block-wide exclusive prefix sum + * BlockScan(temp_storage).ExclusiveSum(thread_data, thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is 1, 1, ..., 1. The + * corresponding output \p thread_data in those threads will be 0, 1, ..., 127. + * + */ + __device__ __forceinline__ void ExclusiveSum( + T input, ///< [in] Calling thread's input item + T &output) ///< [out] Calling thread's output item (may be aliased to \p input) + { + ExclusiveScan(input, output, ZeroInitialize(), cub::Sum()); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes one input element. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - \identityzero + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an exclusive prefix sum of 128 integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain input item for each thread + * int thread_data; + * ... + * + * // Collectively compute the block-wide exclusive prefix sum + * int block_aggregate; + * BlockScan(temp_storage).ExclusiveSum(thread_data, thread_data, block_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is 1, 1, ..., 1. The + * corresponding output \p thread_data in those threads will be 0, 1, ..., 127. + * Furthermore the value \p 128 will be stored in \p block_aggregate for all threads. + * + */ + __device__ __forceinline__ void ExclusiveSum( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + T &block_aggregate) ///< [out] block-wide aggregate reduction of input items + { + ExclusiveScan(input, output, ZeroInitialize(), cub::Sum(), block_aggregate); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes one input element. Instead of using 0 as the block-wide prefix, the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - \identityzero + * - The \p block_prefix_callback_op functor must implement a member function T operator()(T block_aggregate). + * The functor's input parameter \p block_aggregate is the same value also returned by the scan operation. + * The functor will be invoked by the first warp of threads in the block, however only the return value from + * lane0 is applied as the block-wide prefix. Can be stateful. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a single thread block that progressively + * computes an exclusive prefix sum over multiple "tiles" of input using a + * prefix functor to maintain a running total between block-wide scans. Each tile consists + * of 128 integer items that are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * // A stateful callback functor that maintains a running prefix to be applied + * // during consecutive scan operations. + * struct BlockPrefixCallbackOp + * { + * // Running prefix + * int running_total; + * + * // Constructor + * __device__ BlockPrefixCallbackOp(int running_total) : running_total(running_total) {} + * + * // Callback operator to be entered by the first warp of threads in the block. + * // Thread-0 is responsible for returning a value for seeding the block-wide scan. + * __device__ int operator()(int block_aggregate) + * { + * int old_prefix = running_total; + * running_total += block_aggregate; + * return old_prefix; + * } + * }; + * + * __global__ void ExampleKernel(int *d_data, int num_items, ...) + * { + * // Specialize BlockScan for a 1D block of 128 threads + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Initialize running total + * BlockPrefixCallbackOp prefix_op(0); + * + * // Have the block iterate over segments of items + * for (int block_offset = 0; block_offset < num_items; block_offset += 128) + * { + * // Load a segment of consecutive items that are blocked across threads + * int thread_data = d_data[block_offset]; + * + * // Collectively compute the block-wide exclusive prefix sum + * int block_aggregate; + * BlockScan(temp_storage).ExclusiveSum( + * thread_data, thread_data, block_aggregate, prefix_op); + * __syncthreads(); + * + * // Store scanned items to output segment + * d_data[block_offset] = thread_data; + * } + * \endcode + * \par + * Suppose the input \p d_data is 1, 1, 1, 1, 1, 1, 1, 1, .... + * The corresponding output for the first segment will be 0, 1, ..., 127. + * The output for the second segment will be 128, 129, ..., 255. Furthermore, + * the value \p 128 will be stored in \p block_aggregate for all threads after each scan. + * + * \tparam BlockPrefixCallbackOp [inferred] Call-back functor type having member T operator()(T block_aggregate) + */ + template + __device__ __forceinline__ void ExclusiveSum( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + T &block_aggregate, ///< [out] block-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a block-wide prefix to be applied to all inputs. + { + ExclusiveScan(input, output, ZeroInitialize(), cub::Sum(), block_aggregate, block_prefix_callback_op); + } + + + //@} end member group + /******************************************************************//** + * \name Exclusive prefix sum operations (multiple data per thread) + *********************************************************************/ + //@{ + + + /** + * \brief Computes an exclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes an array of consecutive input elements. + * + * \par + * - \identityzero + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an exclusive prefix sum of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute the block-wide exclusive prefix sum + * BlockScan(temp_storage).ExclusiveSum(thread_data, thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is { [1,1,1,1], [1,1,1,1], ..., [1,1,1,1] }. The + * corresponding output \p thread_data in those threads will be { [0,1,2,3], [4,5,6,7], ..., [508,509,510,511] }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + */ + template + __device__ __forceinline__ void ExclusiveSum( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD]) ///< [out] Calling thread's output items (may be aliased to \p input) + { + // Reduce consecutive thread items in registers + Sum scan_op; + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveSum(thread_partial, thread_partial); + + // Exclusive scan in registers with prefix + ThreadScanExclusive(input, output, scan_op, thread_partial); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes an array of consecutive input elements. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - \identityzero + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an exclusive prefix sum of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute the block-wide exclusive prefix sum + * int block_aggregate; + * BlockScan(temp_storage).ExclusiveSum(thread_data, thread_data, block_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is { [1,1,1,1], [1,1,1,1], ..., [1,1,1,1] }. The + * corresponding output \p thread_data in those threads will be { [0,1,2,3], [4,5,6,7], ..., [508,509,510,511] }. + * Furthermore the value \p 512 will be stored in \p block_aggregate for all threads. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + */ + template + __device__ __forceinline__ void ExclusiveSum( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + T &block_aggregate) ///< [out] block-wide aggregate reduction of input items + { + // Reduce consecutive thread items in registers + Sum scan_op; + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveSum(thread_partial, thread_partial, block_aggregate); + + // Exclusive scan in registers with prefix + ThreadScanExclusive(input, output, scan_op, thread_partial); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes an array of consecutive input elements. Instead of using 0 as the block-wide prefix, the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - \identityzero + * - The \p block_prefix_callback_op functor must implement a member function T operator()(T block_aggregate). + * The functor's input parameter \p block_aggregate is the same value also returned by the scan operation. + * The functor will be invoked by the first warp of threads in the block, however only the return value from + * lane0 is applied as the block-wide prefix. Can be stateful. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a single thread block that progressively + * computes an exclusive prefix sum over multiple "tiles" of input using a + * prefix functor to maintain a running total between block-wide scans. Each tile consists + * of 512 integer items that are partitioned in a [blocked arrangement](index.html#sec5sec3) + * across 128 threads where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * // A stateful callback functor that maintains a running prefix to be applied + * // during consecutive scan operations. + * struct BlockPrefixCallbackOp + * { + * // Running prefix + * int running_total; + * + * // Constructor + * __device__ BlockPrefixCallbackOp(int running_total) : running_total(running_total) {} + * + * // Callback operator to be entered by the first warp of threads in the block. + * // Thread-0 is responsible for returning a value for seeding the block-wide scan. + * __device__ int operator()(int block_aggregate) + * { + * int old_prefix = running_total; + * running_total += block_aggregate; + * return old_prefix; + * } + * }; + * + * __global__ void ExampleKernel(int *d_data, int num_items, ...) + * { + * // Specialize BlockLoad, BlockStore, and BlockScan for a 1D block of 128 threads, 4 ints per thread + * typedef cub::BlockLoad BlockLoad; + * typedef cub::BlockStore BlockStore; + * typedef cub::BlockScan BlockScan; + * + * // Allocate aliased shared memory for BlockLoad, BlockStore, and BlockScan + * __shared__ union { + * typename BlockLoad::TempStorage load; + * typename BlockScan::TempStorage scan; + * typename BlockStore::TempStorage store; + * } temp_storage; + * + * // Initialize running total + * BlockPrefixCallbackOp prefix_op(0); + * + * // Have the block iterate over segments of items + * for (int block_offset = 0; block_offset < num_items; block_offset += 128 * 4) + * { + * // Load a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * BlockLoad(temp_storage.load).Load(d_data + block_offset, thread_data); + * __syncthreads(); + * + * // Collectively compute the block-wide exclusive prefix sum + * int block_aggregate; + * BlockScan(temp_storage.scan).ExclusiveSum( + * thread_data, thread_data, block_aggregate, prefix_op); + * __syncthreads(); + * + * // Store scanned items to output segment + * BlockStore(temp_storage.store).Store(d_data + block_offset, thread_data); + * __syncthreads(); + * } + * \endcode + * \par + * Suppose the input \p d_data is 1, 1, 1, 1, 1, 1, 1, 1, .... + * The corresponding output for the first segment will be 0, 1, 2, 3, ..., 510, 511. + * The output for the second segment will be 512, 513, 514, 515, ..., 1022, 1023. Furthermore, + * the value \p 512 will be stored in \p block_aggregate for all threads after each scan. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam BlockPrefixCallbackOp [inferred] Call-back functor type having member T operator()(T block_aggregate) + */ + template < + int ITEMS_PER_THREAD, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void ExclusiveSum( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + T &block_aggregate, ///< [out] block-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a block-wide prefix to be applied to all inputs. + { + // Reduce consecutive thread items in registers + Sum scan_op; + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveSum(thread_partial, thread_partial, block_aggregate, block_prefix_callback_op); + + // Exclusive scan in registers with prefix + ThreadScanExclusive(input, output, scan_op, thread_partial); + } + + + + //@} end member group // Inclusive prefix sums + /******************************************************************//** + * \name Exclusive prefix scan operations + *********************************************************************/ + //@{ + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. + * + * \par + * - Supports non-commutative scan operators. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an exclusive prefix max scan of 128 integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain input item for each thread + * int thread_data; + * ... + * + * // Collectively compute the block-wide exclusive prefix max scan + * BlockScan(temp_storage).ExclusiveScan(thread_data, thread_data, INT_MIN, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is 0, -1, 2, -3, ..., 126, -127. The + * corresponding output \p thread_data in those threads will be INT_MIN, 0, 0, 2, ..., 124, 126. + * + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + T identity, ///< [in] Identity value + ScanOp scan_op) ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + { + InternalBlockScan(temp_storage).ExclusiveScan(input, output, identity, scan_op); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - Supports non-commutative scan operators. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an exclusive prefix max scan of 128 integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain input item for each thread + * int thread_data; + * ... + * + * // Collectively compute the block-wide exclusive prefix max scan + * int block_aggregate; + * BlockScan(temp_storage).ExclusiveScan(thread_data, thread_data, INT_MIN, cub::Max(), block_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is 0, -1, 2, -3, ..., 126, -127. The + * corresponding output \p thread_data in those threads will be INT_MIN, 0, 0, 2, ..., 124, 126. + * Furthermore the value \p 126 will be stored in \p block_aggregate for all threads. + * + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input items + T &output, ///< [out] Calling thread's output items (may be aliased to \p input) + T identity, ///< [in] Identity value + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate) ///< [out] block-wide aggregate reduction of input items + { + InternalBlockScan(temp_storage).ExclusiveScan(input, output, identity, scan_op, block_aggregate); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - The \p block_prefix_callback_op functor must implement a member function T operator()(T block_aggregate). + * The functor's input parameter \p block_aggregate is the same value also returned by the scan operation. + * The functor will be invoked by the first warp of threads in the block, however only the return value from + * lane0 is applied as the block-wide prefix. Can be stateful. + * - Supports non-commutative scan operators. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a single thread block that progressively + * computes an exclusive prefix max scan over multiple "tiles" of input using a + * prefix functor to maintain a running total between block-wide scans. Each tile consists + * of 128 integer items that are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * // A stateful callback functor that maintains a running prefix to be applied + * // during consecutive scan operations. + * struct BlockPrefixCallbackOp + * { + * // Running prefix + * int running_total; + * + * // Constructor + * __device__ BlockPrefixCallbackOp(int running_total) : running_total(running_total) {} + * + * // Callback operator to be entered by the first warp of threads in the block. + * // Thread-0 is responsible for returning a value for seeding the block-wide scan. + * __device__ int operator()(int block_aggregate) + * { + * int old_prefix = running_total; + * running_total = (block_aggregate > old_prefix) ? block_aggregate : old_prefix; + * return old_prefix; + * } + * }; + * + * __global__ void ExampleKernel(int *d_data, int num_items, ...) + * { + * // Specialize BlockScan for a 1D block of 128 threads + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Initialize running total + * BlockPrefixCallbackOp prefix_op(INT_MIN); + * + * // Have the block iterate over segments of items + * for (int block_offset = 0; block_offset < num_items; block_offset += 128) + * { + * // Load a segment of consecutive items that are blocked across threads + * int thread_data = d_data[block_offset]; + * + * // Collectively compute the block-wide exclusive prefix max scan + * int block_aggregate; + * BlockScan(temp_storage).ExclusiveScan( + * thread_data, thread_data, INT_MIN, cub::Max(), block_aggregate, prefix_op); + * __syncthreads(); + * + * // Store scanned items to output segment + * d_data[block_offset] = thread_data; + * } + * \endcode + * \par + * Suppose the input \p d_data is 0, -1, 2, -3, 4, -5, .... + * The corresponding output for the first segment will be INT_MIN, 0, 0, 2, ..., 124, 126. + * The output for the second segment will be 126, 128, 128, 130, ..., 252, 254. Furthermore, + * \p block_aggregate will be assigned \p 126 in all threads after the first scan, assigned \p 254 after the second + * scan, etc. + * + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + * \tparam BlockPrefixCallbackOp [inferred] Call-back functor type having member T operator()(T block_aggregate) + */ + template < + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + T identity, ///< [in] Identity value + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate, ///< [out] block-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a block-wide prefix to be applied to all inputs. + { + InternalBlockScan(temp_storage).ExclusiveScan(input, output, identity, scan_op, block_aggregate, block_prefix_callback_op); + } + + + //@} end member group // Inclusive prefix sums + /******************************************************************//** + * \name Exclusive prefix scan operations (multiple data per thread) + *********************************************************************/ + //@{ + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes an array of consecutive input elements. + * + * \par + * - Supports non-commutative scan operators. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an exclusive prefix max scan of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute the block-wide exclusive prefix max scan + * BlockScan(temp_storage).ExclusiveScan(thread_data, thread_data, INT_MIN, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [0,-1,2,-3], [4,-5,6,-7], ..., [508,-509,510,-511] }. + * The corresponding output \p thread_data in those threads will be + * { [INT_MIN,0,0,2], [2,4,4,6], ..., [506,508,508,510] }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template < + int ITEMS_PER_THREAD, + typename ScanOp> + __device__ __forceinline__ void ExclusiveScan( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + T identity, ///< [in] Identity value + ScanOp scan_op) ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + { + // Reduce consecutive thread items in registers + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveScan(thread_partial, thread_partial, identity, scan_op); + + // Exclusive scan in registers with prefix + ThreadScanExclusive(input, output, scan_op, thread_partial); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes an array of consecutive input elements. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - Supports non-commutative scan operators. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an exclusive prefix max scan of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute the block-wide exclusive prefix max scan + * int block_aggregate; + * BlockScan(temp_storage).ExclusiveScan(thread_data, thread_data, INT_MIN, cub::Max(), block_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is { [0,-1,2,-3], [4,-5,6,-7], ..., [508,-509,510,-511] }. The + * corresponding output \p thread_data in those threads will be { [INT_MIN,0,0,2], [2,4,4,6], ..., [506,508,508,510] }. + * Furthermore the value \p 510 will be stored in \p block_aggregate for all threads. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template < + int ITEMS_PER_THREAD, + typename ScanOp> + __device__ __forceinline__ void ExclusiveScan( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + T identity, ///< [in] Identity value + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate) ///< [out] block-wide aggregate reduction of input items + { + // Reduce consecutive thread items in registers + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveScan(thread_partial, thread_partial, identity, scan_op, block_aggregate); + + // Exclusive scan in registers with prefix + ThreadScanExclusive(input, output, scan_op, thread_partial); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes an array of consecutive input elements. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - The \p block_prefix_callback_op functor must implement a member function T operator()(T block_aggregate). + * The functor's input parameter \p block_aggregate is the same value also returned by the scan operation. + * The functor will be invoked by the first warp of threads in the block, however only the return value from + * lane0 is applied as the block-wide prefix. Can be stateful. + * - Supports non-commutative scan operators. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a single thread block that progressively + * computes an exclusive prefix max scan over multiple "tiles" of input using a + * prefix functor to maintain a running total between block-wide scans. Each tile consists + * of 128 integer items that are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * // A stateful callback functor that maintains a running prefix to be applied + * // during consecutive scan operations. + * struct BlockPrefixCallbackOp + * { + * // Running prefix + * int running_total; + * + * // Constructor + * __device__ BlockPrefixCallbackOp(int running_total) : running_total(running_total) {} + * + * // Callback operator to be entered by the first warp of threads in the block. + * // Thread-0 is responsible for returning a value for seeding the block-wide scan. + * __device__ int operator()(int block_aggregate) + * { + * int old_prefix = running_total; + * running_total = (block_aggregate > old_prefix) ? block_aggregate : old_prefix; + * return old_prefix; + * } + * }; + * + * __global__ void ExampleKernel(int *d_data, int num_items, ...) + * { + * // Specialize BlockLoad, BlockStore, and BlockScan for a 1D block of 128 threads, 4 ints per thread + * typedef cub::BlockLoad BlockLoad; + * typedef cub::BlockStore BlockStore; + * typedef cub::BlockScan BlockScan; + * + * // Allocate aliased shared memory for BlockLoad, BlockStore, and BlockScan + * __shared__ union { + * typename BlockLoad::TempStorage load; + * typename BlockScan::TempStorage scan; + * typename BlockStore::TempStorage store; + * } temp_storage; + * + * // Initialize running total + * BlockPrefixCallbackOp prefix_op(0); + * + * // Have the block iterate over segments of items + * for (int block_offset = 0; block_offset < num_items; block_offset += 128 * 4) + * { + * // Load a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * BlockLoad(temp_storage.load).Load(d_data + block_offset, thread_data); + * __syncthreads(); + * + * // Collectively compute the block-wide exclusive prefix max scan + * int block_aggregate; + * BlockScan(temp_storage.scan).ExclusiveScan( + * thread_data, thread_data, INT_MIN, cub::Max(), block_aggregate, prefix_op); + * __syncthreads(); + * + * // Store scanned items to output segment + * BlockStore(temp_storage.store).Store(d_data + block_offset, thread_data); + * __syncthreads(); + * } + * \endcode + * \par + * Suppose the input \p d_data is 0, -1, 2, -3, 4, -5, .... + * The corresponding output for the first segment will be INT_MIN, 0, 0, 2, 2, 4, ..., 508, 510. + * The output for the second segment will be 510, 512, 512, 514, 514, 516, ..., 1020, 1022. Furthermore, + * \p block_aggregate will be assigned \p 510 in all threads after the first scan, assigned \p 1022 after the second + * scan, etc. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + * \tparam BlockPrefixCallbackOp [inferred] Call-back functor type having member T operator()(T block_aggregate) + */ + template < + int ITEMS_PER_THREAD, + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void ExclusiveScan( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + T identity, ///< [in] Identity value + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate, ///< [out] block-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a block-wide prefix to be applied to all inputs. + { + // Reduce consecutive thread items in registers + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveScan(thread_partial, thread_partial, identity, scan_op, block_aggregate, block_prefix_callback_op); + + // Exclusive scan in registers with prefix + ThreadScanExclusive(input, output, scan_op, thread_partial); + } + + + //@} end member group + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + /******************************************************************//** + * \name Exclusive prefix scan operations (identityless, single datum per thread) + *********************************************************************/ + //@{ + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. With no identity value, the output computed for thread0 is undefined. + * + * \par + * - Supports non-commutative scan operators. + * - \rowmajor + * - \smemreuse + * + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op) ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + { + InternalBlockScan(temp_storage).ExclusiveScan(input, output, scan_op); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. Also provides every thread with the block-wide \p block_aggregate of all inputs. With no identity value, the output computed for thread0 is undefined. + * + * \par + * - Supports non-commutative scan operators. + * - \rowmajor + * - \smemreuse + * + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate) ///< [out] block-wide aggregate reduction of input items + { + InternalBlockScan(temp_storage).ExclusiveScan(input, output, scan_op, block_aggregate); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * The \p block_prefix_callback_op functor must implement a member function T operator()(T block_aggregate). + * The functor's input parameter \p block_aggregate is the same value also returned by the scan operation. + * The functor will be invoked by the first warp of threads in the block, however only the return value from + * lane0 is applied as the block-wide prefix. Can be stateful. + * + * \par + * - Supports non-commutative scan operators. + * - \rowmajor + * - \smemreuse + * + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + * \tparam BlockPrefixCallbackOp [inferred] Call-back functor type having member T operator()(T block_aggregate) + */ + template < + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate, ///< [out] block-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a block-wide prefix to be applied to all inputs. + { + InternalBlockScan(temp_storage).ExclusiveScan(input, output, scan_op, block_aggregate, block_prefix_callback_op); + } + + + //@} end member group + + /******************************************************************//** + * \name Exclusive prefix scan operations (identityless, multiple data per thread) + *********************************************************************/ + //@{ + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes an array of consecutive input elements. With no identity value, the output computed for thread0 is undefined. + * + * \par + * - Supports non-commutative scan operators. + * - \blocked + * - \granularity + * - \smemreuse + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template < + int ITEMS_PER_THREAD, + typename ScanOp> + __device__ __forceinline__ void ExclusiveScan( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + ScanOp scan_op) ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + { + // Reduce consecutive thread items in registers + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveScan(thread_partial, thread_partial, scan_op); + + // Exclusive scan in registers with prefix + ThreadScanExclusive(input, output, scan_op, thread_partial, (linear_tid != 0)); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes an array of consecutive input elements. Also provides every thread with the block-wide \p block_aggregate of all inputs. With no identity value, the output computed for thread0 is undefined. + * + * \par + * - Supports non-commutative scan operators. + * - \blocked + * - \granularity + * - \smemreuse + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template < + int ITEMS_PER_THREAD, + typename ScanOp> + __device__ __forceinline__ void ExclusiveScan( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate) ///< [out] block-wide aggregate reduction of input items + { + // Reduce consecutive thread items in registers + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveScan(thread_partial, thread_partial, scan_op, block_aggregate); + + // Exclusive scan in registers with prefix + ThreadScanExclusive(input, output, scan_op, thread_partial, (linear_tid != 0)); + } + + + /** + * \brief Computes an exclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes an array of consecutive input elements. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * The \p block_prefix_callback_op functor must implement a member function T operator()(T block_aggregate). + * The functor's input parameter \p block_aggregate is the same value also returned by the scan operation. + * The functor will be invoked by the first warp of threads in the block, however only the return value from + * lane0 is applied as the block-wide prefix. Can be stateful. + * + * \par + * - Supports non-commutative scan operators. + * - \blocked + * - \granularity + * - \smemreuse + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + * \tparam BlockPrefixCallbackOp [inferred] Call-back functor type having member T operator()(T block_aggregate) + */ + template < + int ITEMS_PER_THREAD, + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void ExclusiveScan( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate, ///< [out] block-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a block-wide prefix to be applied to all inputs. + { + // Reduce consecutive thread items in registers + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveScan(thread_partial, thread_partial, scan_op, block_aggregate, block_prefix_callback_op); + + // Exclusive scan in registers with prefix + ThreadScanExclusive(input, output, scan_op, thread_partial); + } + + + //@} end member group + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + /******************************************************************//** + * \name Inclusive prefix sum operations + *********************************************************************/ + //@{ + + + /** + * \brief Computes an inclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes one input element. + * + * \par + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an inclusive prefix sum of 128 integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain input item for each thread + * int thread_data; + * ... + * + * // Collectively compute the block-wide inclusive prefix sum + * BlockScan(temp_storage).InclusiveSum(thread_data, thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is 1, 1, ..., 1. The + * corresponding output \p thread_data in those threads will be 1, 2, ..., 128. + * + */ + __device__ __forceinline__ void InclusiveSum( + T input, ///< [in] Calling thread's input item + T &output) ///< [out] Calling thread's output item (may be aliased to \p input) + { + InclusiveScan(input, output, cub::Sum()); + } + + + /** + * \brief Computes an inclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes one input element. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an inclusive prefix sum of 128 integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain input item for each thread + * int thread_data; + * ... + * + * // Collectively compute the block-wide inclusive prefix sum + * int block_aggregate; + * BlockScan(temp_storage).InclusiveSum(thread_data, thread_data, block_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is 1, 1, ..., 1. The + * corresponding output \p thread_data in those threads will be 1, 2, ..., 128. + * Furthermore the value \p 128 will be stored in \p block_aggregate for all threads. + * + */ + __device__ __forceinline__ void InclusiveSum( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + T &block_aggregate) ///< [out] block-wide aggregate reduction of input items + { + InclusiveScan(input, output, cub::Sum(), block_aggregate); + } + + + + /** + * \brief Computes an inclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes one input element. Instead of using 0 as the block-wide prefix, the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - The \p block_prefix_callback_op functor must implement a member function T operator()(T block_aggregate). + * The functor's input parameter \p block_aggregate is the same value also returned by the scan operation. + * The functor will be invoked by the first warp of threads in the block, however only the return value from + * lane0 is applied as the block-wide prefix. Can be stateful. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a single thread block that progressively + * computes an inclusive prefix sum over multiple "tiles" of input using a + * prefix functor to maintain a running total between block-wide scans. Each tile consists + * of 128 integer items that are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * // A stateful callback functor that maintains a running prefix to be applied + * // during consecutive scan operations. + * struct BlockPrefixCallbackOp + * { + * // Running prefix + * int running_total; + * + * // Constructor + * __device__ BlockPrefixCallbackOp(int running_total) : running_total(running_total) {} + * + * // Callback operator to be entered by the first warp of threads in the block. + * // Thread-0 is responsible for returning a value for seeding the block-wide scan. + * __device__ int operator()(int block_aggregate) + * { + * int old_prefix = running_total; + * running_total += block_aggregate; + * return old_prefix; + * } + * }; + * + * __global__ void ExampleKernel(int *d_data, int num_items, ...) + * { + * // Specialize BlockScan for a 1D block of 128 threads + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Initialize running total + * BlockPrefixCallbackOp prefix_op(0); + * + * // Have the block iterate over segments of items + * for (int block_offset = 0; block_offset < num_items; block_offset += 128) + * { + * // Load a segment of consecutive items that are blocked across threads + * int thread_data = d_data[block_offset]; + * + * // Collectively compute the block-wide inclusive prefix sum + * int block_aggregate; + * BlockScan(temp_storage).InclusiveSum( + * thread_data, thread_data, block_aggregate, prefix_op); + * __syncthreads(); + * + * // Store scanned items to output segment + * d_data[block_offset] = thread_data; + * } + * \endcode + * \par + * Suppose the input \p d_data is 1, 1, 1, 1, 1, 1, 1, 1, .... + * The corresponding output for the first segment will be 1, 2, ..., 128. + * The output for the second segment will be 129, 130, ..., 256. Furthermore, + * the value \p 128 will be stored in \p block_aggregate for all threads after each scan. + * + * \tparam BlockPrefixCallbackOp [inferred] Call-back functor type having member T operator()(T block_aggregate) + */ + template + __device__ __forceinline__ void InclusiveSum( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + T &block_aggregate, ///< [out] block-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a block-wide prefix to be applied to all inputs. + { + InclusiveScan(input, output, cub::Sum(), block_aggregate, block_prefix_callback_op); + } + + + //@} end member group + /******************************************************************//** + * \name Inclusive prefix sum operations (multiple data per thread) + *********************************************************************/ + //@{ + + + /** + * \brief Computes an inclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes an array of consecutive input elements. + * + * \par + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an inclusive prefix sum of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute the block-wide inclusive prefix sum + * BlockScan(temp_storage).InclusiveSum(thread_data, thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is { [1,1,1,1], [1,1,1,1], ..., [1,1,1,1] }. The + * corresponding output \p thread_data in those threads will be { [1,2,3,4], [5,6,7,8], ..., [509,510,511,512] }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + */ + template + __device__ __forceinline__ void InclusiveSum( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD]) ///< [out] Calling thread's output items (may be aliased to \p input) + { + if (ITEMS_PER_THREAD == 1) + { + InclusiveSum(input[0], output[0]); + } + else + { + // Reduce consecutive thread items in registers + Sum scan_op; + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveSum(thread_partial, thread_partial); + + // Inclusive scan in registers with prefix + ThreadScanInclusive(input, output, scan_op, thread_partial, (linear_tid != 0)); + } + } + + + /** + * \brief Computes an inclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes an array of consecutive input elements. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an inclusive prefix sum of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute the block-wide inclusive prefix sum + * int block_aggregate; + * BlockScan(temp_storage).InclusiveSum(thread_data, thread_data, block_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [1,1,1,1], [1,1,1,1], ..., [1,1,1,1] }. The + * corresponding output \p thread_data in those threads will be + * { [1,2,3,4], [5,6,7,8], ..., [509,510,511,512] }. + * Furthermore the value \p 512 will be stored in \p block_aggregate for all threads. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void InclusiveSum( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + T &block_aggregate) ///< [out] block-wide aggregate reduction of input items + { + if (ITEMS_PER_THREAD == 1) + { + InclusiveSum(input[0], output[0], block_aggregate); + } + else + { + // Reduce consecutive thread items in registers + Sum scan_op; + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveSum(thread_partial, thread_partial, block_aggregate); + + // Inclusive scan in registers with prefix + ThreadScanInclusive(input, output, scan_op, thread_partial, (linear_tid != 0)); + } + } + + + /** + * \brief Computes an inclusive block-wide prefix scan using addition (+) as the scan operator. Each thread contributes an array of consecutive input elements. Instead of using 0 as the block-wide prefix, the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - The \p block_prefix_callback_op functor must implement a member function T operator()(T block_aggregate). + * The functor's input parameter \p block_aggregate is the same value also returned by the scan operation. + * The functor will be invoked by the first warp of threads in the block, however only the return value from + * lane0 is applied as the block-wide prefix. Can be stateful. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a single thread block that progressively + * computes an inclusive prefix sum over multiple "tiles" of input using a + * prefix functor to maintain a running total between block-wide scans. Each tile consists + * of 512 integer items that are partitioned in a [blocked arrangement](index.html#sec5sec3) + * across 128 threads where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * // A stateful callback functor that maintains a running prefix to be applied + * // during consecutive scan operations. + * struct BlockPrefixCallbackOp + * { + * // Running prefix + * int running_total; + * + * // Constructor + * __device__ BlockPrefixCallbackOp(int running_total) : running_total(running_total) {} + * + * // Callback operator to be entered by the first warp of threads in the block. + * // Thread-0 is responsible for returning a value for seeding the block-wide scan. + * __device__ int operator()(int block_aggregate) + * { + * int old_prefix = running_total; + * running_total += block_aggregate; + * return old_prefix; + * } + * }; + * + * __global__ void ExampleKernel(int *d_data, int num_items, ...) + * { + * // Specialize BlockLoad, BlockStore, and BlockScan for a 1D block of 128 threads, 4 ints per thread + * typedef cub::BlockLoad BlockLoad; + * typedef cub::BlockStore BlockStore; + * typedef cub::BlockScan BlockScan; + * + * // Allocate aliased shared memory for BlockLoad, BlockStore, and BlockScan + * __shared__ union { + * typename BlockLoad::TempStorage load; + * typename BlockScan::TempStorage scan; + * typename BlockStore::TempStorage store; + * } temp_storage; + * + * // Initialize running total + * BlockPrefixCallbackOp prefix_op(0); + * + * // Have the block iterate over segments of items + * for (int block_offset = 0; block_offset < num_items; block_offset += 128 * 4) + * { + * // Load a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * BlockLoad(temp_storage.load).Load(d_data + block_offset, thread_data); + * __syncthreads(); + * + * // Collectively compute the block-wide inclusive prefix sum + * int block_aggregate; + * BlockScan(temp_storage.scan).IncluisveSum( + * thread_data, thread_data, block_aggregate, prefix_op); + * __syncthreads(); + * + * // Store scanned items to output segment + * BlockStore(temp_storage.store).Store(d_data + block_offset, thread_data); + * __syncthreads(); + * } + * \endcode + * \par + * Suppose the input \p d_data is 1, 1, 1, 1, 1, 1, 1, 1, .... + * The corresponding output for the first segment will be 1, 2, 3, 4, ..., 511, 512. + * The output for the second segment will be 513, 514, 515, 516, ..., 1023, 1024. Furthermore, + * the value \p 512 will be stored in \p block_aggregate for all threads after each scan. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam BlockPrefixCallbackOp [inferred] Call-back functor type having member T operator()(T block_aggregate) + */ + template < + int ITEMS_PER_THREAD, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void InclusiveSum( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + T &block_aggregate, ///< [out] block-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a block-wide prefix to be applied to all inputs. + { + if (ITEMS_PER_THREAD == 1) + { + InclusiveSum(input[0], output[0], block_aggregate, block_prefix_callback_op); + } + else + { + // Reduce consecutive thread items in registers + Sum scan_op; + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveSum(thread_partial, thread_partial, block_aggregate, block_prefix_callback_op); + + // Inclusive scan in registers with prefix + ThreadScanInclusive(input, output, scan_op, thread_partial); + } + } + + + //@} end member group + /******************************************************************//** + * \name Inclusive prefix scan operations + *********************************************************************/ + //@{ + + + /** + * \brief Computes an inclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. + * + * \par + * - Supports non-commutative scan operators. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an inclusive prefix max scan of 128 integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain input item for each thread + * int thread_data; + * ... + * + * // Collectively compute the block-wide inclusive prefix max scan + * BlockScan(temp_storage).InclusiveScan(thread_data, thread_data, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is 0, -1, 2, -3, ..., 126, -127. The + * corresponding output \p thread_data in those threads will be 0, 0, 2, 2, ..., 126, 126. + * + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op) ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + { + InternalBlockScan(temp_storage).InclusiveScan(input, output, scan_op); + } + + + /** + * \brief Computes an inclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - Supports non-commutative scan operators. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an inclusive prefix max scan of 128 integer items that + * are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain input item for each thread + * int thread_data; + * ... + * + * // Collectively compute the block-wide inclusive prefix max scan + * int block_aggregate; + * BlockScan(temp_storage).InclusiveScan(thread_data, thread_data, cub::Max(), block_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is 0, -1, 2, -3, ..., 126, -127. The + * corresponding output \p thread_data in those threads will be 0, 0, 2, 2, ..., 126, 126. + * Furthermore the value \p 126 will be stored in \p block_aggregate for all threads. + * + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate) ///< [out] block-wide aggregate reduction of input items + { + InternalBlockScan(temp_storage).InclusiveScan(input, output, scan_op, block_aggregate); + } + + + /** + * \brief Computes an inclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - The \p block_prefix_callback_op functor must implement a member function T operator()(T block_aggregate). + * The functor's input parameter \p block_aggregate is the same value also returned by the scan operation. + * The functor will be invoked by the first warp of threads in the block, however only the return value from + * lane0 is applied as the block-wide prefix. Can be stateful. + * - Supports non-commutative scan operators. + * - \rowmajor + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a single thread block that progressively + * computes an inclusive prefix max scan over multiple "tiles" of input using a + * prefix functor to maintain a running total between block-wide scans. Each tile consists + * of 128 integer items that are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * // A stateful callback functor that maintains a running prefix to be applied + * // during consecutive scan operations. + * struct BlockPrefixCallbackOp + * { + * // Running prefix + * int running_total; + * + * // Constructor + * __device__ BlockPrefixCallbackOp(int running_total) : running_total(running_total) {} + * + * // Callback operator to be entered by the first warp of threads in the block. + * // Thread-0 is responsible for returning a value for seeding the block-wide scan. + * __device__ int operator()(int block_aggregate) + * { + * int old_prefix = running_total; + * running_total = (block_aggregate > old_prefix) ? block_aggregate : old_prefix; + * return old_prefix; + * } + * }; + * + * __global__ void ExampleKernel(int *d_data, int num_items, ...) + * { + * // Specialize BlockScan for a 1D block of 128 threads + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Initialize running total + * BlockPrefixCallbackOp prefix_op(INT_MIN); + * + * // Have the block iterate over segments of items + * for (int block_offset = 0; block_offset < num_items; block_offset += 128) + * { + * // Load a segment of consecutive items that are blocked across threads + * int thread_data = d_data[block_offset]; + * + * // Collectively compute the block-wide inclusive prefix max scan + * int block_aggregate; + * BlockScan(temp_storage).InclusiveScan( + * thread_data, thread_data, cub::Max(), block_aggregate, prefix_op); + * __syncthreads(); + * + * // Store scanned items to output segment + * d_data[block_offset] = thread_data; + * } + * \endcode + * \par + * Suppose the input \p d_data is 0, -1, 2, -3, 4, -5, .... + * The corresponding output for the first segment will be 0, 0, 2, 2, ..., 126, 126. + * The output for the second segment will be 128, 128, 130, 130, ..., 254, 254. Furthermore, + * \p block_aggregate will be assigned \p 126 in all threads after the first scan, assigned \p 254 after the second + * scan, etc. + * + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + * \tparam BlockPrefixCallbackOp [inferred] Call-back functor type having member T operator()(T block_aggregate) + */ + template < + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate, ///< [out] block-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a block-wide prefix to be applied to all inputs. + { + InternalBlockScan(temp_storage).InclusiveScan(input, output, scan_op, block_aggregate, block_prefix_callback_op); + } + + + //@} end member group + /******************************************************************//** + * \name Inclusive prefix scan operations (multiple data per thread) + *********************************************************************/ + //@{ + + + /** + * \brief Computes an inclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes an array of consecutive input elements. + * + * \par + * - Supports non-commutative scan operators. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an inclusive prefix max scan of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute the block-wide inclusive prefix max scan + * BlockScan(temp_storage).InclusiveScan(thread_data, thread_data, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is { [0,-1,2,-3], [4,-5,6,-7], ..., [508,-509,510,-511] }. The + * corresponding output \p thread_data in those threads will be { [0,0,2,2], [4,4,6,6], ..., [508,508,510,510] }. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template < + int ITEMS_PER_THREAD, + typename ScanOp> + __device__ __forceinline__ void InclusiveScan( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + ScanOp scan_op) ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + { + if (ITEMS_PER_THREAD == 1) + { + InclusiveScan(input[0], output[0], scan_op); + } + else + { + // Reduce consecutive thread items in registers + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveScan(thread_partial, thread_partial, scan_op); + + // Inclusive scan in registers with prefix + ThreadScanInclusive(input, output, scan_op, thread_partial, (linear_tid != 0)); + } + } + + + /** + * \brief Computes an inclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes an array of consecutive input elements. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - Supports non-commutative scan operators. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates an inclusive prefix max scan of 512 integer items that + * are partitioned in a [blocked arrangement](index.html#sec5sec3) across 128 threads + * where each thread owns 4 consecutive items. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Specialize BlockScan for a 1D block of 128 threads on type int + * typedef cub::BlockScan BlockScan; + * + * // Allocate shared memory for BlockScan + * __shared__ typename BlockScan::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Collectively compute the block-wide inclusive prefix max scan + * int block_aggregate; + * BlockScan(temp_storage).InclusiveScan(thread_data, thread_data, cub::Max(), block_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is + * { [0,-1,2,-3], [4,-5,6,-7], ..., [508,-509,510,-511] }. + * The corresponding output \p thread_data in those threads will be + * { [0,0,2,2], [4,4,6,6], ..., [508,508,510,510] }. + * Furthermore the value \p 510 will be stored in \p block_aggregate for all threads. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + */ + template < + int ITEMS_PER_THREAD, + typename ScanOp> + __device__ __forceinline__ void InclusiveScan( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate) ///< [out] block-wide aggregate reduction of input items + { + if (ITEMS_PER_THREAD == 1) + { + InclusiveScan(input[0], output[0], scan_op, block_aggregate); + } + else + { + // Reduce consecutive thread items in registers + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveScan(thread_partial, thread_partial, scan_op, block_aggregate); + + // Inclusive scan in registers with prefix + ThreadScanInclusive(input, output, scan_op, thread_partial, (linear_tid != 0)); + } + } + + + /** + * \brief Computes an inclusive block-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes an array of consecutive input elements. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + * + * \par + * - The \p block_prefix_callback_op functor must implement a member function T operator()(T block_aggregate). + * The functor's input parameter \p block_aggregate is the same value also returned by the scan operation. + * The functor will be invoked by the first warp of threads in the block, however only the return value from + * lane0 is applied as the block-wide prefix. Can be stateful. + * - Supports non-commutative scan operators. + * - \blocked + * - \granularity + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates a single thread block that progressively + * computes an inclusive prefix max scan over multiple "tiles" of input using a + * prefix functor to maintain a running total between block-wide scans. Each tile consists + * of 128 integer items that are partitioned across 128 threads. + * \par + * \code + * #include // or equivalently + * + * // A stateful callback functor that maintains a running prefix to be applied + * // during consecutive scan operations. + * struct BlockPrefixCallbackOp + * { + * // Running prefix + * int running_total; + * + * // Constructor + * __device__ BlockPrefixCallbackOp(int running_total) : running_total(running_total) {} + * + * // Callback operator to be entered by the first warp of threads in the block. + * // Thread-0 is responsible for returning a value for seeding the block-wide scan. + * __device__ int operator()(int block_aggregate) + * { + * int old_prefix = running_total; + * running_total = (block_aggregate > old_prefix) ? block_aggregate : old_prefix; + * return old_prefix; + * } + * }; + * + * __global__ void ExampleKernel(int *d_data, int num_items, ...) + * { + * // Specialize BlockLoad, BlockStore, and BlockScan for a 1D block of 128 threads, 4 ints per thread + * typedef cub::BlockLoad BlockLoad; + * typedef cub::BlockStore BlockStore; + * typedef cub::BlockScan BlockScan; + * + * // Allocate aliased shared memory for BlockLoad, BlockStore, and BlockScan + * __shared__ union { + * typename BlockLoad::TempStorage load; + * typename BlockScan::TempStorage scan; + * typename BlockStore::TempStorage store; + * } temp_storage; + * + * // Initialize running total + * BlockPrefixCallbackOp prefix_op(0); + * + * // Have the block iterate over segments of items + * for (int block_offset = 0; block_offset < num_items; block_offset += 128 * 4) + * { + * // Load a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * BlockLoad(temp_storage.load).Load(d_data + block_offset, thread_data); + * __syncthreads(); + * + * // Collectively compute the block-wide inclusive prefix max scan + * int block_aggregate; + * BlockScan(temp_storage.scan).InclusiveScan( + * thread_data, thread_data, cub::Max(), block_aggregate, prefix_op); + * __syncthreads(); + * + * // Store scanned items to output segment + * BlockStore(temp_storage.store).Store(d_data + block_offset, thread_data); + * __syncthreads(); + * } + * \endcode + * \par + * Suppose the input \p d_data is 0, -1, 2, -3, 4, -5, .... + * The corresponding output for the first segment will be 0, 0, 2, 2, 4, 4, ..., 510, 510. + * The output for the second segment will be 512, 512, 514, 514, 516, 516, ..., 1022, 1022. Furthermore, + * \p block_aggregate will be assigned \p 510 in all threads after the first scan, assigned \p 1022 after the second + * scan, etc. + * + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam ScanOp [inferred] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) type having member T operator()(const T &a, const T &b) + * \tparam BlockPrefixCallbackOp [inferred] Call-back functor type having member T operator()(T block_aggregate) + */ + template < + int ITEMS_PER_THREAD, + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void InclusiveScan( + T (&input)[ITEMS_PER_THREAD], ///< [in] Calling thread's input items + T (&output)[ITEMS_PER_THREAD], ///< [out] Calling thread's output items (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + T &block_aggregate, ///< [out] block-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a block-wide prefix to be applied to all inputs. + { + if (ITEMS_PER_THREAD == 1) + { + InclusiveScan(input[0], output[0], scan_op, block_aggregate, block_prefix_callback_op); + } + else + { + // Reduce consecutive thread items in registers + T thread_partial = ThreadReduce(input, scan_op); + + // Exclusive threadblock-scan + ExclusiveScan(thread_partial, thread_partial, scan_op, block_aggregate, block_prefix_callback_op); + + // Inclusive scan in registers with prefix + ThreadScanInclusive(input, output, scan_op, thread_partial); + } + } + + //@} end member group + + +}; + +/** + * \example example_block_scan.cu + */ + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/block_shuffle.cuh b/3rdparty/cub/cub/block/block_shuffle.cuh new file mode 100644 index 00000000000..1c838bba8a5 --- /dev/null +++ b/3rdparty/cub/cub/block/block_shuffle.cuh @@ -0,0 +1,305 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * The cub::BlockShuffle class provides [collective](index.html#sec0) methods for shuffling data partitioned across a CUDA thread block. + */ + +#pragma once + +#include "../util_arch.cuh" +#include "../util_ptx.cuh" +#include "../util_macro.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \brief The BlockShuffle class provides [collective](index.html#sec0) methods for shuffling data partitioned across a CUDA thread block. + * \ingroup BlockModule + * + * \tparam T The data type to be exchanged. + * \tparam BLOCK_DIM_X The thread block length in threads along the X dimension + * \tparam BLOCK_DIM_Y [optional] The thread block length in threads along the Y dimension (default: 1) + * \tparam BLOCK_DIM_Z [optional] The thread block length in threads along the Z dimension (default: 1) + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * It is commonplace for blocks of threads to rearrange data items between + * threads. The BlockShuffle abstraction allows threads to efficiently shift items + * either (a) up to their successor or (b) down to their predecessor. + * + */ +template < + typename T, + int BLOCK_DIM_X, + int BLOCK_DIM_Y = 1, + int BLOCK_DIM_Z = 1, + int PTX_ARCH = CUB_PTX_ARCH> +class BlockShuffle +{ +private: + + /****************************************************************************** + * Constants + ******************************************************************************/ + + enum + { + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + + LOG_WARP_THREADS = CUB_LOG_WARP_THREADS(PTX_ARCH), + WARP_THREADS = 1 << LOG_WARP_THREADS, + WARPS = (BLOCK_THREADS + WARP_THREADS - 1) / WARP_THREADS, + }; + + /****************************************************************************** + * Type definitions + ******************************************************************************/ + + /// Shared memory storage layout type (last element from each thread's input) + struct _TempStorage + { + T prev[BLOCK_THREADS]; + T next[BLOCK_THREADS]; + }; + + +public: + + /// \smemstorage{BlockShuffle} + struct TempStorage : Uninitialized<_TempStorage> {}; + +private: + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Shared storage reference + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + /// Internal storage allocator + __device__ __forceinline__ _TempStorage& PrivateStorage() + { + __shared__ _TempStorage private_storage; + return private_storage; + } + + +public: + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + /** + * \brief Collective constructor using a private static allocation of shared memory as temporary storage. + */ + __device__ __forceinline__ BlockShuffle() + : + temp_storage(PrivateStorage()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. + */ + __device__ __forceinline__ BlockShuffle( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + //@} end member group + /******************************************************************//** + * \name Shuffle movement + *********************************************************************/ + //@{ + + + /** + * \brief Each threadi obtains the \p input provided by threadi+distance. The offset \p distance may be negative. + * + * \par + * - \smemreuse + */ + __device__ __forceinline__ void Offset( + T input, ///< [in] The input item from the calling thread (threadi) + T& output, ///< [out] The \p input item from the successor (or predecessor) thread threadi+distance (may be aliased to \p input). This value is only updated for for threadi when 0 <= (i + \p distance) < BLOCK_THREADS-1 + int distance = 1) ///< [in] Offset distance (may be negative) + { + temp_storage[linear_tid].prev = input; + + __syncthreads(); + + if ((linear_tid + distance >= 0) && (linear_tid + distance < BLOCK_THREADS)) + output = temp_storage[linear_tid + distance].prev; + } + + + /** + * \brief Each threadi obtains the \p input provided by threadi+distance. + * + * \par + * - \smemreuse + */ + __device__ __forceinline__ void Rotate( + T input, ///< [in] The calling thread's input item + T& output, ///< [out] The \p input item from thread thread(i+distance>)% (may be aliased to \p input). This value is not updated for threadBLOCK_THREADS-1 + unsigned int distance = 1) ///< [in] Offset distance (0 < \p distance < BLOCK_THREADS) + { + temp_storage[linear_tid].prev = input; + + __syncthreads(); + + unsigned int offset = threadIdx.x + distance; + if (offset >= BLOCK_THREADS) + offset -= BLOCK_THREADS; + + output = temp_storage[offset].prev; + } + + + /** + * \brief The thread block rotates its [blocked arrangement](index.html#sec5sec3) of \p input items, shifting it up by one item + * + * \par + * - \blocked + * - \granularity + * - \smemreuse + */ + template + __device__ __forceinline__ void Up( + T (&input)[ITEMS_PER_THREAD], ///< [in] The calling thread's input items + T (&prev)[ITEMS_PER_THREAD]) ///< [out] The corresponding predecessor items (may be aliased to \p input). The item \p prev[0] is not updated for thread0. + { + temp_storage[linear_tid].prev = input[ITEMS_PER_THREAD - 1]; + + __syncthreads(); + + #pragma unroll + for (int ITEM = ITEMS_PER_THREAD - 1; ITEM > 0; --ITEM) + prev[ITEM] = input[ITEM - 1]; + + + if (linear_tid > 0) + prev[0] = temp_storage[linear_tid - 1].prev; + } + + + /** + * \brief The thread block rotates its [blocked arrangement](index.html#sec5sec3) of \p input items, shifting it up by one item. All threads receive the \p input provided by threadBLOCK_THREADS-1. + * + * \par + * - \blocked + * - \granularity + * - \smemreuse + */ + template + __device__ __forceinline__ void Up( + T (&input)[ITEMS_PER_THREAD], ///< [in] The calling thread's input items + T (&prev)[ITEMS_PER_THREAD], ///< [out] The corresponding predecessor items (may be aliased to \p input). The item \p prev[0] is not updated for thread0. + T &block_suffix) ///< [out] The item \p input[ITEMS_PER_THREAD-1] from threadBLOCK_THREADS-1, provided to all threads + { + Up(input, prev); + block_suffix = temp_storage[BLOCK_THREADS - 1].prev; + } + + + /** + * \brief The thread block rotates its [blocked arrangement](index.html#sec5sec3) of \p input items, shifting it down by one item + * + * \par + * - \blocked + * - \granularity + * - \smemreuse + */ + template + __device__ __forceinline__ void Down( + T (&input)[ITEMS_PER_THREAD], ///< [in] The calling thread's input items + T (&prev)[ITEMS_PER_THREAD]) ///< [out] The corresponding predecessor items (may be aliased to \p input). The value \p prev[0] is not updated for threadBLOCK_THREADS-1. + { + temp_storage[linear_tid].prev = input[ITEMS_PER_THREAD - 1]; + + __syncthreads(); + + #pragma unroll + for (int ITEM = ITEMS_PER_THREAD - 1; ITEM > 0; --ITEM) + prev[ITEM] = input[ITEM - 1]; + + if (linear_tid > 0) + prev[0] = temp_storage[linear_tid - 1].prev; + } + + + /** + * \brief The thread block rotates its [blocked arrangement](index.html#sec5sec3) of input items, shifting it down by one item. All threads receive \p input[0] provided by thread0. + * + * \par + * - \blocked + * - \granularity + * - \smemreuse + */ + template + __device__ __forceinline__ void Down( + T (&input)[ITEMS_PER_THREAD], ///< [in] The calling thread's input items + T (&prev)[ITEMS_PER_THREAD], ///< [out] The corresponding predecessor items (may be aliased to \p input). The value \p prev[0] is not updated for threadBLOCK_THREADS-1. + T &block_prefix) ///< [out] The item \p input[0] from thread0, provided to all threads + { + Up(input, prev); + block_prefix = temp_storage[BLOCK_THREADS - 1].prev; + } + + //@} end member group + + +}; + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/block_store.cuh b/3rdparty/cub/cub/block/block_store.cuh new file mode 100644 index 00000000000..e1fa72833f2 --- /dev/null +++ b/3rdparty/cub/cub/block/block_store.cuh @@ -0,0 +1,959 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Operations for writing linear segments of data from the CUDA thread block + */ + +#pragma once + +#include + +#include "block_exchange.cuh" +#include "../util_ptx.cuh" +#include "../util_macro.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \addtogroup UtilIo + * @{ + */ + + +/******************************************************************//** + * \name Blocked arrangement I/O (direct) + *********************************************************************/ +//@{ + +/** + * \brief Store a blocked arrangement of items across a thread block into a linear segment of items. + * + * \blocked + * + * \tparam T [inferred] The data type to store. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam OutputIteratorT [inferred] The random-access iterator type for output \iterator. + */ +template < + typename T, + int ITEMS_PER_THREAD, + typename OutputIteratorT> +__device__ __forceinline__ void StoreDirectBlocked( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD]) ///< [in] Data to store +{ + // Store directly in thread-blocked order + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + block_itr[(linear_tid * ITEMS_PER_THREAD) + ITEM] = items[ITEM]; + } +} + + +/** + * \brief Store a blocked arrangement of items across a thread block into a linear segment of items, guarded by range + * + * \blocked + * + * \tparam T [inferred] The data type to store. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam OutputIteratorT [inferred] The random-access iterator type for output \iterator. + */ +template < + typename T, + int ITEMS_PER_THREAD, + typename OutputIteratorT> +__device__ __forceinline__ void StoreDirectBlocked( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD], ///< [in] Data to store + int valid_items) ///< [in] Number of valid items to write +{ + // Store directly in thread-blocked order + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + if (ITEM + (linear_tid * ITEMS_PER_THREAD) < valid_items) + { + block_itr[(linear_tid * ITEMS_PER_THREAD) + ITEM] = items[ITEM]; + } + } +} + + +/** + * \brief Store a blocked arrangement of items across a thread block into a linear segment of items. + * + * \blocked + * + * The output offset (\p block_ptr + \p block_offset) must be quad-item aligned, + * which is the default starting offset returned by \p cudaMalloc() + * + * \par + * The following conditions will prevent vectorization and storing will fall back to cub::BLOCK_STORE_DIRECT: + * - \p ITEMS_PER_THREAD is odd + * - The data type \p T is not a built-in primitive or CUDA vector type (e.g., \p short, \p int2, \p double, \p float2, etc.) + * + * \tparam T [inferred] The data type to store. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * + */ +template < + typename T, + int ITEMS_PER_THREAD> +__device__ __forceinline__ void StoreDirectBlockedVectorized( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + T *block_ptr, ///< [in] Input pointer for storing from + T (&items)[ITEMS_PER_THREAD]) ///< [in] Data to store +{ + enum + { + // Maximum CUDA vector size is 4 elements + MAX_VEC_SIZE = CUB_MIN(4, ITEMS_PER_THREAD), + + // Vector size must be a power of two and an even divisor of the items per thread + VEC_SIZE = ((((MAX_VEC_SIZE - 1) & MAX_VEC_SIZE) == 0) && ((ITEMS_PER_THREAD % MAX_VEC_SIZE) == 0)) ? + MAX_VEC_SIZE : + 1, + + VECTORS_PER_THREAD = ITEMS_PER_THREAD / VEC_SIZE, + }; + + // Vector type + typedef typename CubVector::Type Vector; + + // Alias global pointer + Vector *block_ptr_vectors = reinterpret_cast(const_cast(block_ptr)); + + // Alias pointers (use "raw" array here which should get optimized away to prevent conservative PTXAS lmem spilling) + Vector raw_vector[VECTORS_PER_THREAD]; + T *raw_items = reinterpret_cast(raw_vector); + + // Copy + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + raw_items[ITEM] = items[ITEM]; + } + + // Direct-store using vector types + StoreDirectBlocked(linear_tid, block_ptr_vectors, raw_vector); +} + + + +//@} end member group +/******************************************************************//** + * \name Striped arrangement I/O (direct) + *********************************************************************/ +//@{ + + +/** + * \brief Store a striped arrangement of data across the thread block into a linear segment of items. + * + * \striped + * + * \tparam BLOCK_THREADS The thread block size in threads + * \tparam T [inferred] The data type to store. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam OutputIteratorT [inferred] The random-access iterator type for output \iterator. + */ +template < + int BLOCK_THREADS, + typename T, + int ITEMS_PER_THREAD, + typename OutputIteratorT> +__device__ __forceinline__ void StoreDirectStriped( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD]) ///< [in] Data to store +{ + // Store directly in striped order + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + block_itr[(ITEM * BLOCK_THREADS) + linear_tid] = items[ITEM]; + } +} + + +/** + * \brief Store a striped arrangement of data across the thread block into a linear segment of items, guarded by range + * + * \striped + * + * \tparam BLOCK_THREADS The thread block size in threads + * \tparam T [inferred] The data type to store. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam OutputIteratorT [inferred] The random-access iterator type for output \iterator. + */ +template < + int BLOCK_THREADS, + typename T, + int ITEMS_PER_THREAD, + typename OutputIteratorT> +__device__ __forceinline__ void StoreDirectStriped( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD], ///< [in] Data to store + int valid_items) ///< [in] Number of valid items to write +{ + // Store directly in striped order + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + if ((ITEM * BLOCK_THREADS) + linear_tid < valid_items) + { + block_itr[(ITEM * BLOCK_THREADS) + linear_tid] = items[ITEM]; + } + } +} + + + +//@} end member group +/******************************************************************//** + * \name Warp-striped arrangement I/O (direct) + *********************************************************************/ +//@{ + + +/** + * \brief Store a warp-striped arrangement of data across the thread block into a linear segment of items. + * + * \warpstriped + * + * \par Usage Considerations + * The number of threads in the thread block must be a multiple of the architecture's warp size. + * + * \tparam T [inferred] The data type to store. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam OutputIteratorT [inferred] The random-access iterator type for output \iterator. + */ +template < + typename T, + int ITEMS_PER_THREAD, + typename OutputIteratorT> +__device__ __forceinline__ void StoreDirectWarpStriped( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD]) ///< [out] Data to load +{ + int tid = linear_tid & (CUB_PTX_WARP_THREADS - 1); + int wid = linear_tid >> CUB_PTX_LOG_WARP_THREADS; + int warp_offset = wid * CUB_PTX_WARP_THREADS * ITEMS_PER_THREAD; + + // Store directly in warp-striped order + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + block_itr[warp_offset + tid + (ITEM * CUB_PTX_WARP_THREADS)] = items[ITEM]; + } +} + + +/** + * \brief Store a warp-striped arrangement of data across the thread block into a linear segment of items, guarded by range + * + * \warpstriped + * + * \par Usage Considerations + * The number of threads in the thread block must be a multiple of the architecture's warp size. + * + * \tparam T [inferred] The data type to store. + * \tparam ITEMS_PER_THREAD [inferred] The number of consecutive items partitioned onto each thread. + * \tparam OutputIteratorT [inferred] The random-access iterator type for output \iterator. + */ +template < + typename T, + int ITEMS_PER_THREAD, + typename OutputIteratorT> +__device__ __forceinline__ void StoreDirectWarpStriped( + int linear_tid, ///< [in] A suitable 1D thread-identifier for the calling thread (e.g., (threadIdx.y * blockDim.x) + linear_tid for 2D thread blocks) + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD], ///< [in] Data to store + int valid_items) ///< [in] Number of valid items to write +{ + int tid = linear_tid & (CUB_PTX_WARP_THREADS - 1); + int wid = linear_tid >> CUB_PTX_LOG_WARP_THREADS; + int warp_offset = wid * CUB_PTX_WARP_THREADS * ITEMS_PER_THREAD; + + // Store directly in warp-striped order + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ITEM++) + { + if (warp_offset + tid + (ITEM * CUB_PTX_WARP_THREADS) < valid_items) + { + block_itr[warp_offset + tid + (ITEM * CUB_PTX_WARP_THREADS)] = items[ITEM]; + } + } +} + + +//@} end member group + + +/** @} */ // end group UtilIo + + +//----------------------------------------------------------------------------- +// Generic BlockStore abstraction +//----------------------------------------------------------------------------- + +/** + * \brief cub::BlockStoreAlgorithm enumerates alternative algorithms for cub::BlockStore to write a blocked arrangement of items across a CUDA thread block to a linear segment of memory. + */ +enum BlockStoreAlgorithm +{ + /** + * \par Overview + * + * A [blocked arrangement](index.html#sec5sec3) of data is written + * directly to memory. + * + * \par Performance Considerations + * - The utilization of memory transactions (coalescing) decreases as the + * access stride between threads increases (i.e., the number items per thread). + */ + BLOCK_STORE_DIRECT, + + /** + * \par Overview + * + * A [blocked arrangement](index.html#sec5sec3) of data is written directly + * to memory using CUDA's built-in vectorized stores as a coalescing optimization. + * For example, st.global.v4.s32 instructions will be generated + * when \p T = \p int and \p ITEMS_PER_THREAD % 4 == 0. + * + * \par Performance Considerations + * - The utilization of memory transactions (coalescing) remains high until the the + * access stride between threads (i.e., the number items per thread) exceeds the + * maximum vector store width (typically 4 items or 64B, whichever is lower). + * - The following conditions will prevent vectorization and writing will fall back to cub::BLOCK_STORE_DIRECT: + * - \p ITEMS_PER_THREAD is odd + * - The \p OutputIteratorT is not a simple pointer type + * - The block output offset is not quadword-aligned + * - The data type \p T is not a built-in primitive or CUDA vector type (e.g., \p short, \p int2, \p double, \p float2, etc.) + */ + BLOCK_STORE_VECTORIZE, + + /** + * \par Overview + * A [blocked arrangement](index.html#sec5sec3) is locally + * transposed and then efficiently written to memory as a [striped arrangement](index.html#sec5sec3). + * + * \par Performance Considerations + * - The utilization of memory transactions (coalescing) remains high regardless + * of items written per thread. + * - The local reordering incurs slightly longer latencies and throughput than the + * direct cub::BLOCK_STORE_DIRECT and cub::BLOCK_STORE_VECTORIZE alternatives. + */ + BLOCK_STORE_TRANSPOSE, + + /** + * \par Overview + * A [blocked arrangement](index.html#sec5sec3) is locally + * transposed and then efficiently written to memory as a + * [warp-striped arrangement](index.html#sec5sec3) + * + * \par Usage Considerations + * - BLOCK_THREADS must be a multiple of WARP_THREADS + * + * \par Performance Considerations + * - The utilization of memory transactions (coalescing) remains high regardless + * of items written per thread. + * - The local reordering incurs slightly longer latencies and throughput than the + * direct cub::BLOCK_STORE_DIRECT and cub::BLOCK_STORE_VECTORIZE alternatives. + */ + BLOCK_STORE_WARP_TRANSPOSE, + + /** + * \par Overview + * A [blocked arrangement](index.html#sec5sec3) is locally + * transposed and then efficiently written to memory as a + * [warp-striped arrangement](index.html#sec5sec3) + * To reduce the shared memory requirement, only one warp's worth of shared + * memory is provisioned and is subsequently time-sliced among warps. + * + * \par Usage Considerations + * - BLOCK_THREADS must be a multiple of WARP_THREADS + * + * \par Performance Considerations + * - The utilization of memory transactions (coalescing) remains high regardless + * of items written per thread. + * - Provisions less shared memory temporary storage, but incurs larger + * latencies than the BLOCK_STORE_WARP_TRANSPOSE alternative. + */ + BLOCK_STORE_WARP_TRANSPOSE_TIMESLICED, + +}; + + +/** + * \brief The BlockStore class provides [collective](index.html#sec0) data movement methods for writing a [blocked arrangement](index.html#sec5sec3) of items partitioned across a CUDA thread block to a linear segment of memory. ![](block_store_logo.png) + * \ingroup BlockModule + * \ingroup UtilIo + * + * \tparam OutputIteratorT The input iterator type \iterator. + * \tparam BLOCK_DIM_X The thread block length in threads along the X dimension + * \tparam ITEMS_PER_THREAD The number of consecutive items partitioned onto each thread. + * \tparam ALGORITHM [optional] cub::BlockStoreAlgorithm tuning policy enumeration. default: cub::BLOCK_STORE_DIRECT. + * \tparam WARP_TIME_SLICING [optional] Whether or not only one warp's worth of shared memory should be allocated and time-sliced among block-warps during any load-related data transpositions (versus each warp having its own storage). (default: false) + * \tparam BLOCK_DIM_Y [optional] The thread block length in threads along the Y dimension (default: 1) + * \tparam BLOCK_DIM_Z [optional] The thread block length in threads along the Z dimension (default: 1) + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * - The BlockStore class provides a single data movement abstraction that can be specialized + * to implement different cub::BlockStoreAlgorithm strategies. This facilitates different + * performance policies for different architectures, data types, granularity sizes, etc. + * - BlockStore can be optionally specialized by different data movement strategies: + * -# cub::BLOCK_STORE_DIRECT. A [blocked arrangement](index.html#sec5sec3) of data is written + * directly to memory. [More...](\ref cub::BlockStoreAlgorithm) + * -# cub::BLOCK_STORE_VECTORIZE. A [blocked arrangement](index.html#sec5sec3) + * of data is written directly to memory using CUDA's built-in vectorized stores as a + * coalescing optimization. [More...](\ref cub::BlockStoreAlgorithm) + * -# cub::BLOCK_STORE_TRANSPOSE. A [blocked arrangement](index.html#sec5sec3) + * is locally transposed into a [striped arrangement](index.html#sec5sec3) which is + * then written to memory. [More...](\ref cub::BlockStoreAlgorithm) + * -# cub::BLOCK_STORE_WARP_TRANSPOSE. A [blocked arrangement](index.html#sec5sec3) + * is locally transposed into a [warp-striped arrangement](index.html#sec5sec3) which is + * then written to memory. [More...](\ref cub::BlockStoreAlgorithm) + * - \rowmajor + * + * \par A Simple Example + * \blockcollective{BlockStore} + * \par + * The code snippet below illustrates the storing of a "blocked" arrangement + * of 512 integers across 128 threads (where each thread owns 4 consecutive items) + * into a linear segment of memory. The store is specialized for \p BLOCK_STORE_WARP_TRANSPOSE, + * meaning items are locally reordered among threads so that memory references will be + * efficiently coalesced using a warp-striped access pattern. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, ...) + * { + * // Specialize BlockStore for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockStore BlockStore; + * + * // Allocate shared memory for BlockStore + * __shared__ typename BlockStore::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Store items to linear memory + * int thread_data[4]; + * BlockStore(temp_storage).Store(d_data, thread_data); + * + * \endcode + * \par + * Suppose the set of \p thread_data across the block of threads is + * { [0,1,2,3], [4,5,6,7], ..., [508,509,510,511] }. + * The output \p d_data will be 0, 1, 2, 3, 4, 5, .... + * + */ +template < + typename OutputIteratorT, + int BLOCK_DIM_X, + int ITEMS_PER_THREAD, + BlockStoreAlgorithm ALGORITHM = BLOCK_STORE_DIRECT, + int BLOCK_DIM_Y = 1, + int BLOCK_DIM_Z = 1, + int PTX_ARCH = CUB_PTX_ARCH> +class BlockStore +{ +private: + /****************************************************************************** + * Constants and typed definitions + ******************************************************************************/ + + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + }; + + // Data type of input iterator + typedef typename std::iterator_traits::value_type T; + + + /****************************************************************************** + * Algorithmic variants + ******************************************************************************/ + + /// Store helper + template + struct StoreInternal; + + + /** + * BLOCK_STORE_DIRECT specialization of store helper + */ + template + struct StoreInternal + { + /// Shared memory storage layout type + typedef NullType TempStorage; + + /// Linear thread-id + int linear_tid; + + /// Constructor + __device__ __forceinline__ StoreInternal( + TempStorage &temp_storage, + int linear_tid) + : + linear_tid(linear_tid) + {} + + /// Store items into a linear segment of memory + __device__ __forceinline__ void Store( + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD]) ///< [in] Data to store + { + StoreDirectBlocked(linear_tid, block_itr, items); + } + + /// Store items into a linear segment of memory, guarded by range + __device__ __forceinline__ void Store( + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD], ///< [in] Data to store + int valid_items) ///< [in] Number of valid items to write + { + StoreDirectBlocked(linear_tid, block_itr, items, valid_items); + } + }; + + + /** + * BLOCK_STORE_VECTORIZE specialization of store helper + */ + template + struct StoreInternal + { + /// Shared memory storage layout type + typedef NullType TempStorage; + + /// Linear thread-id + int linear_tid; + + /// Constructor + __device__ __forceinline__ StoreInternal( + TempStorage &temp_storage, + int linear_tid) + : + linear_tid(linear_tid) + {} + + /// Store items into a linear segment of memory, specialized for native pointer types (attempts vectorization) + __device__ __forceinline__ void Store( + T *block_ptr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD]) ///< [in] Data to store + { + StoreDirectBlockedVectorized(linear_tid, block_ptr, items); + } + + /// Store items into a linear segment of memory, specialized for opaque input iterators (skips vectorization) + template + __device__ __forceinline__ void Store( + _OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD]) ///< [in] Data to store + { + StoreDirectBlocked(linear_tid, block_itr, items); + } + + /// Store items into a linear segment of memory, guarded by range + __device__ __forceinline__ void Store( + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD], ///< [in] Data to store + int valid_items) ///< [in] Number of valid items to write + { + StoreDirectBlocked(linear_tid, block_itr, items, valid_items); + } + }; + + + /** + * BLOCK_STORE_TRANSPOSE specialization of store helper + */ + template + struct StoreInternal + { + // BlockExchange utility type for keys + typedef BlockExchange BlockExchange; + + /// Shared memory storage layout type + typedef typename BlockExchange::TempStorage _TempStorage; + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + /// Thread reference to shared storage + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + /// Constructor + __device__ __forceinline__ StoreInternal( + TempStorage &temp_storage, + int linear_tid) + : + temp_storage(temp_storage.Alias()), + linear_tid(linear_tid) + {} + + /// Store items into a linear segment of memory + __device__ __forceinline__ void Store( + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD]) ///< [in] Data to store + { + BlockExchange(temp_storage).BlockedToStriped(items); + StoreDirectStriped(linear_tid, block_itr, items); + } + + /// Store items into a linear segment of memory, guarded by range + __device__ __forceinline__ void Store( + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD], ///< [in] Data to store + int valid_items) ///< [in] Number of valid items to write + { + BlockExchange(temp_storage).BlockedToStriped(items); + StoreDirectStriped(linear_tid, block_itr, items, valid_items); + } + }; + + + /** + * BLOCK_STORE_WARP_TRANSPOSE specialization of store helper + */ + template + struct StoreInternal + { + enum + { + WARP_THREADS = CUB_WARP_THREADS(PTX_ARCH) + }; + + // Assert BLOCK_THREADS must be a multiple of WARP_THREADS + CUB_STATIC_ASSERT((BLOCK_THREADS % WARP_THREADS == 0), "BLOCK_THREADS must be a multiple of WARP_THREADS"); + + // BlockExchange utility type for keys + typedef BlockExchange BlockExchange; + + /// Shared memory storage layout type + typedef typename BlockExchange::TempStorage _TempStorage; + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + /// Thread reference to shared storage + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + /// Constructor + __device__ __forceinline__ StoreInternal( + TempStorage &temp_storage, + int linear_tid) + : + temp_storage(temp_storage.Alias()), + linear_tid(linear_tid) + {} + + /// Store items into a linear segment of memory + __device__ __forceinline__ void Store( + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD]) ///< [in] Data to store + { + BlockExchange(temp_storage).BlockedToWarpStriped(items); + StoreDirectWarpStriped(linear_tid, block_itr, items); + } + + /// Store items into a linear segment of memory, guarded by range + __device__ __forceinline__ void Store( + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD], ///< [in] Data to store + int valid_items) ///< [in] Number of valid items to write + { + BlockExchange(temp_storage).BlockedToWarpStriped(items); + StoreDirectWarpStriped(linear_tid, block_itr, items, valid_items); + } + }; + + + /** + * BLOCK_STORE_WARP_TRANSPOSE_TIMESLICED specialization of store helper + */ + template + struct StoreInternal + { + enum + { + WARP_THREADS = CUB_WARP_THREADS(PTX_ARCH) + }; + + // Assert BLOCK_THREADS must be a multiple of WARP_THREADS + CUB_STATIC_ASSERT((BLOCK_THREADS % WARP_THREADS == 0), "BLOCK_THREADS must be a multiple of WARP_THREADS"); + + // BlockExchange utility type for keys + typedef BlockExchange BlockExchange; + + /// Shared memory storage layout type + typedef typename BlockExchange::TempStorage _TempStorage; + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + /// Thread reference to shared storage + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + + /// Constructor + __device__ __forceinline__ StoreInternal( + TempStorage &temp_storage, + int linear_tid) + : + temp_storage(temp_storage.Alias()), + linear_tid(linear_tid) + {} + + /// Store items into a linear segment of memory + __device__ __forceinline__ void Store( + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD]) ///< [in] Data to store + { + BlockExchange(temp_storage).BlockedToWarpStriped(items); + StoreDirectWarpStriped(linear_tid, block_itr, items); + } + + /// Store items into a linear segment of memory, guarded by range + __device__ __forceinline__ void Store( + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD], ///< [in] Data to store + int valid_items) ///< [in] Number of valid items to write + { + BlockExchange(temp_storage).BlockedToWarpStriped(items); + StoreDirectWarpStriped(linear_tid, block_itr, items, valid_items); + } + }; + + /****************************************************************************** + * Type definitions + ******************************************************************************/ + + /// Internal load implementation to use + typedef StoreInternal InternalStore; + + + /// Shared memory storage layout type + typedef typename InternalStore::TempStorage _TempStorage; + + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + /// Internal storage allocator + __device__ __forceinline__ _TempStorage& PrivateStorage() + { + __shared__ _TempStorage private_storage; + return private_storage; + } + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Thread reference to shared storage + _TempStorage &temp_storage; + + /// Linear thread-id + int linear_tid; + +public: + + + /// \smemstorage{BlockStore} + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + /** + * \brief Collective constructor using a private static allocation of shared memory as temporary storage. + */ + __device__ __forceinline__ BlockStore() + : + temp_storage(PrivateStorage()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. + */ + __device__ __forceinline__ BlockStore( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + //@} end member group + /******************************************************************//** + * \name Data movement + *********************************************************************/ + //@{ + + + /** + * \brief Store items into a linear segment of memory. + * + * \par + * - \blocked + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the storing of a "blocked" arrangement + * of 512 integers across 128 threads (where each thread owns 4 consecutive items) + * into a linear segment of memory. The store is specialized for \p BLOCK_STORE_WARP_TRANSPOSE, + * meaning items are locally reordered among threads so that memory references will be + * efficiently coalesced using a warp-striped access pattern. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, ...) + * { + * // Specialize BlockStore for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockStore BlockStore; + * + * // Allocate shared memory for BlockStore + * __shared__ typename BlockStore::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Store items to linear memory + * int thread_data[4]; + * BlockStore(temp_storage).Store(d_data, thread_data); + * + * \endcode + * \par + * Suppose the set of \p thread_data across the block of threads is + * { [0,1,2,3], [4,5,6,7], ..., [508,509,510,511] }. + * The output \p d_data will be 0, 1, 2, 3, 4, 5, .... + * + */ + __device__ __forceinline__ void Store( + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD]) ///< [in] Data to store + { + InternalStore(temp_storage, linear_tid).Store(block_itr, items); + } + + /** + * \brief Store items into a linear segment of memory, guarded by range. + * + * \par + * - \blocked + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the guarded storing of a "blocked" arrangement + * of 512 integers across 128 threads (where each thread owns 4 consecutive items) + * into a linear segment of memory. The store is specialized for \p BLOCK_STORE_WARP_TRANSPOSE, + * meaning items are locally reordered among threads so that memory references will be + * efficiently coalesced using a warp-striped access pattern. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(int *d_data, int valid_items, ...) + * { + * // Specialize BlockStore for a 1D block of 128 threads owning 4 integer items each + * typedef cub::BlockStore BlockStore; + * + * // Allocate shared memory for BlockStore + * __shared__ typename BlockStore::TempStorage temp_storage; + * + * // Obtain a segment of consecutive items that are blocked across threads + * int thread_data[4]; + * ... + * + * // Store items to linear memory + * int thread_data[4]; + * BlockStore(temp_storage).Store(d_data, thread_data, valid_items); + * + * \endcode + * \par + * Suppose the set of \p thread_data across the block of threads is + * { [0,1,2,3], [4,5,6,7], ..., [508,509,510,511] } and \p valid_items is \p 5. + * The output \p d_data will be 0, 1, 2, 3, 4, ?, ?, ?, ..., with + * only the first two threads being unmasked to store portions of valid data. + * + */ + __device__ __forceinline__ void Store( + OutputIteratorT block_itr, ///< [in] The thread block's base output iterator for storing to + T (&items)[ITEMS_PER_THREAD], ///< [in] Data to store + int valid_items) ///< [in] Number of valid items to write + { + InternalStore(temp_storage, linear_tid).Store(block_itr, items, valid_items); + } +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/specializations/block_histogram_atomic.cuh b/3rdparty/cub/cub/block/specializations/block_histogram_atomic.cuh new file mode 100644 index 00000000000..9e7df676769 --- /dev/null +++ b/3rdparty/cub/cub/block/specializations/block_histogram_atomic.cuh @@ -0,0 +1,82 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * The cub::BlockHistogramAtomic class provides atomic-based methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block. + */ + +#pragma once + +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief The BlockHistogramAtomic class provides atomic-based methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block. + */ +template +struct BlockHistogramAtomic +{ + /// Shared memory storage layout type + struct TempStorage {}; + + + /// Constructor + __device__ __forceinline__ BlockHistogramAtomic( + TempStorage &temp_storage) + {} + + + /// Composite data onto an existing histogram + template < + typename T, + typename CounterT, + int ITEMS_PER_THREAD> + __device__ __forceinline__ void Composite( + T (&items)[ITEMS_PER_THREAD], ///< [in] Calling thread's input values to histogram + CounterT histogram[BINS]) ///< [out] Reference to shared/global memory histogram + { + // Update histogram + #pragma unroll + for (int i = 0; i < ITEMS_PER_THREAD; ++i) + { + atomicAdd(histogram + items[i], 1); + } + } + +}; + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/specializations/block_histogram_sort.cuh b/3rdparty/cub/cub/block/specializations/block_histogram_sort.cuh new file mode 100644 index 00000000000..8a37d884fcc --- /dev/null +++ b/3rdparty/cub/cub/block/specializations/block_histogram_sort.cuh @@ -0,0 +1,226 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * The cub::BlockHistogramSort class provides sorting-based methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block. + */ + +#pragma once + +#include "../../block/block_radix_sort.cuh" +#include "../../block/block_discontinuity.cuh" +#include "../../util_ptx.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + + +/** + * \brief The BlockHistogramSort class provides sorting-based methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block. + */ +template < + typename T, ///< Sample type + int BLOCK_DIM_X, ///< The thread block length in threads along the X dimension + int ITEMS_PER_THREAD, ///< The number of samples per thread + int BINS, ///< The number of bins into which histogram samples may fall + int BLOCK_DIM_Y, ///< The thread block length in threads along the Y dimension + int BLOCK_DIM_Z, ///< The thread block length in threads along the Z dimension + int PTX_ARCH> ///< The PTX compute capability for which to to specialize this collective +struct BlockHistogramSort +{ + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + }; + + // Parameterize BlockRadixSort type for our thread block + typedef BlockRadixSort< + T, + BLOCK_DIM_X, + ITEMS_PER_THREAD, + NullType, + 4, + (PTX_ARCH >= 350) ? true : false, + BLOCK_SCAN_WARP_SCANS, + cudaSharedMemBankSizeFourByte, + BLOCK_DIM_Y, + BLOCK_DIM_Z, + PTX_ARCH> + BlockRadixSortT; + + // Parameterize BlockDiscontinuity type for our thread block + typedef BlockDiscontinuity< + T, + BLOCK_DIM_X, + BLOCK_DIM_Y, + BLOCK_DIM_Z, + PTX_ARCH> + BlockDiscontinuityT; + + /// Shared memory + union _TempStorage + { + // Storage for sorting bin values + typename BlockRadixSortT::TempStorage sort; + + struct + { + // Storage for detecting discontinuities in the tile of sorted bin values + typename BlockDiscontinuityT::TempStorage flag; + + // Storage for noting begin/end offsets of bin runs in the tile of sorted bin values + unsigned int run_begin[BINS]; + unsigned int run_end[BINS]; + }; + }; + + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + // Thread fields + _TempStorage &temp_storage; + int linear_tid; + + + /// Constructor + __device__ __forceinline__ BlockHistogramSort( + TempStorage &temp_storage) + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + // Discontinuity functor + struct DiscontinuityOp + { + // Reference to temp_storage + _TempStorage &temp_storage; + + // Constructor + __device__ __forceinline__ DiscontinuityOp(_TempStorage &temp_storage) : + temp_storage(temp_storage) + {} + + // Discontinuity predicate + __device__ __forceinline__ bool operator()(const T &a, const T &b, int b_index) + { + if (a != b) + { + // Note the begin/end offsets in shared storage + temp_storage.run_begin[b] = b_index; + temp_storage.run_end[a] = b_index; + + return true; + } + else + { + return false; + } + } + }; + + + // Composite data onto an existing histogram + template < + typename CounterT > + __device__ __forceinline__ void Composite( + T (&items)[ITEMS_PER_THREAD], ///< [in] Calling thread's input values to histogram + CounterT histogram[BINS]) ///< [out] Reference to shared/global memory histogram + { + enum { TILE_SIZE = BLOCK_THREADS * ITEMS_PER_THREAD }; + + // Sort bytes in blocked arrangement + BlockRadixSortT(temp_storage.sort).Sort(items); + + __syncthreads(); + + // Initialize the shared memory's run_begin and run_end for each bin + int histo_offset = 0; + + #pragma unroll + for(; histo_offset + BLOCK_THREADS <= BINS; histo_offset += BLOCK_THREADS) + { + temp_storage.run_begin[histo_offset + linear_tid] = TILE_SIZE; + temp_storage.run_end[histo_offset + linear_tid] = TILE_SIZE; + } + // Finish up with guarded initialization if necessary + if ((BINS % BLOCK_THREADS != 0) && (histo_offset + linear_tid < BINS)) + { + temp_storage.run_begin[histo_offset + linear_tid] = TILE_SIZE; + temp_storage.run_end[histo_offset + linear_tid] = TILE_SIZE; + } + + __syncthreads(); + + int flags[ITEMS_PER_THREAD]; // unused + + // Compute head flags to demarcate contiguous runs of the same bin in the sorted tile + DiscontinuityOp flag_op(temp_storage); + BlockDiscontinuityT(temp_storage.flag).FlagHeads(flags, items, flag_op); + + // Update begin for first item + if (linear_tid == 0) temp_storage.run_begin[items[0]] = 0; + + __syncthreads(); + + // Composite into histogram + histo_offset = 0; + + #pragma unroll + for(; histo_offset + BLOCK_THREADS <= BINS; histo_offset += BLOCK_THREADS) + { + int thread_offset = histo_offset + linear_tid; + CounterT count = temp_storage.run_end[thread_offset] - temp_storage.run_begin[thread_offset]; + histogram[thread_offset] += count; + } + + // Finish up with guarded composition if necessary + if ((BINS % BLOCK_THREADS != 0) && (histo_offset + linear_tid < BINS)) + { + int thread_offset = histo_offset + linear_tid; + CounterT count = temp_storage.run_end[thread_offset] - temp_storage.run_begin[thread_offset]; + histogram[thread_offset] += count; + } + } + +}; + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/specializations/block_reduce_raking.cuh b/3rdparty/cub/cub/block/specializations/block_reduce_raking.cuh new file mode 100644 index 00000000000..f5a1fc46536 --- /dev/null +++ b/3rdparty/cub/cub/block/specializations/block_reduce_raking.cuh @@ -0,0 +1,222 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::BlockReduceRaking provides raking-based methods of parallel reduction across a CUDA thread block. Supports non-commutative reduction operators. + */ + +#pragma once + +#include "../../block/block_raking_layout.cuh" +#include "../../warp/warp_reduce.cuh" +#include "../../thread/thread_reduce.cuh" +#include "../../util_ptx.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief BlockReduceRaking provides raking-based methods of parallel reduction across a CUDA thread block. Supports non-commutative reduction operators. + * + * Supports non-commutative binary reduction operators. Unlike commutative + * reduction operators (e.g., addition), the application of a non-commutative + * reduction operator (e.g, string concatenation) across a sequence of inputs must + * honor the relative ordering of items and partial reductions when applying the + * reduction operator. + * + * Compared to the implementation of BlockReduceRaking (which does not support + * non-commutative operators), this implementation requires a few extra + * rounds of inter-thread communication. + */ +template < + typename T, ///< Data type being reduced + int BLOCK_DIM_X, ///< The thread block length in threads along the X dimension + int BLOCK_DIM_Y, ///< The thread block length in threads along the Y dimension + int BLOCK_DIM_Z, ///< The thread block length in threads along the Z dimension + int PTX_ARCH> ///< The PTX compute capability for which to to specialize this collective +struct BlockReduceRaking +{ + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + }; + + /// Layout type for padded thread block raking grid + typedef BlockRakingLayout BlockRakingLayout; + + /// WarpReduce utility type + typedef typename WarpReduce::InternalWarpReduce WarpReduce; + + /// Constants + enum + { + /// Number of raking threads + RAKING_THREADS = BlockRakingLayout::RAKING_THREADS, + + /// Number of raking elements per warp synchronous raking thread + SEGMENT_LENGTH = BlockRakingLayout::SEGMENT_LENGTH, + + /// Cooperative work can be entirely warp synchronous + WARP_SYNCHRONOUS = (RAKING_THREADS == BLOCK_THREADS), + + /// Whether or not warp-synchronous reduction should be unguarded (i.e., the warp-reduction elements is a power of two + WARP_SYNCHRONOUS_UNGUARDED = PowerOfTwo::VALUE, + + /// Whether or not accesses into smem are unguarded + RAKING_UNGUARDED = BlockRakingLayout::UNGUARDED, + + }; + + + /// Shared memory storage layout type + union _TempStorage + { + typename WarpReduce::TempStorage warp_storage; ///< Storage for warp-synchronous reduction + typename BlockRakingLayout::TempStorage raking_grid; ///< Padded threadblock raking grid + }; + + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + // Thread fields + _TempStorage &temp_storage; + int linear_tid; + + + /// Constructor + __device__ __forceinline__ BlockReduceRaking( + TempStorage &temp_storage) + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + template + __device__ __forceinline__ T RakingReduction( + ReductionOp reduction_op, ///< [in] Binary scan operator + T *raking_segment, + T partial, ///< [in] [lane0 only] Warp-wide aggregate reduction of input items + int num_valid, ///< [in] Number of valid elements (may be less than BLOCK_THREADS) + Int2Type iteration) + { + // Update partial if addend is in range + if ((IS_FULL_TILE && RAKING_UNGUARDED) || ((linear_tid * SEGMENT_LENGTH) + ITERATION < num_valid)) + { + T addend = raking_segment[ITERATION]; + partial = reduction_op(partial, addend); + } + return RakingReduction(reduction_op, raking_segment, partial, num_valid, Int2Type()); + } + + template + __device__ __forceinline__ T RakingReduction( + ReductionOp reduction_op, ///< [in] Binary scan operator + T *raking_segment, + T partial, ///< [in] [lane0 only] Warp-wide aggregate reduction of input items + int num_valid, ///< [in] Number of valid elements (may be less than BLOCK_THREADS) + Int2Type iteration) + { + return partial; + } + + + + /// Computes a threadblock-wide reduction using the specified reduction operator. The first num_valid threads each contribute one reduction partial. The return value is only valid for thread0. + template < + bool IS_FULL_TILE, + typename ReductionOp> + __device__ __forceinline__ T Reduce( + T partial, ///< [in] Calling thread's input partial reductions + int num_valid, ///< [in] Number of valid elements (may be less than BLOCK_THREADS) + ReductionOp reduction_op) ///< [in] Binary reduction operator + { + if (WARP_SYNCHRONOUS) + { + // Short-circuit directly to warp synchronous reduction (unguarded if active threads is a power-of-two) + partial = WarpReduce(temp_storage.warp_storage).template Reduce( + partial, + num_valid, + reduction_op); + } + else + { + // Place partial into shared memory grid. + *BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid) = partial; + + __syncthreads(); + + // Reduce parallelism to one warp + if (linear_tid < RAKING_THREADS) + { + // Raking reduction in grid + T *raking_segment = BlockRakingLayout::RakingPtr(temp_storage.raking_grid, linear_tid); + partial = raking_segment[0]; + + partial = RakingReduction(reduction_op, raking_segment, partial, num_valid, Int2Type<1>()); + + partial = WarpReduce(temp_storage.warp_storage).template Reduce( + partial, + num_valid, + reduction_op); + + } + } + + return partial; + } + + + /// Computes a threadblock-wide reduction using addition (+) as the reduction operator. The first num_valid threads each contribute one reduction partial. The return value is only valid for thread0. + template + __device__ __forceinline__ T Sum( + T partial, ///< [in] Calling thread's input partial reductions + int num_valid) ///< [in] Number of valid elements (may be less than BLOCK_THREADS) + { + cub::Sum reduction_op; + + return Reduce(partial, num_valid, reduction_op); + } + + + +}; + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/specializations/block_reduce_raking_commutative_only.cuh b/3rdparty/cub/cub/block/specializations/block_reduce_raking_commutative_only.cuh new file mode 100644 index 00000000000..aacb9907e96 --- /dev/null +++ b/3rdparty/cub/cub/block/specializations/block_reduce_raking_commutative_only.cuh @@ -0,0 +1,202 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::BlockReduceRakingCommutativeOnly provides raking-based methods of parallel reduction across a CUDA thread block. Does not support non-commutative reduction operators. + */ + +#pragma once + +#include "block_reduce_raking.cuh" +#include "../../warp/warp_reduce.cuh" +#include "../../thread/thread_reduce.cuh" +#include "../../util_ptx.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief BlockReduceRakingCommutativeOnly provides raking-based methods of parallel reduction across a CUDA thread block. Does not support non-commutative reduction operators. Does not support block sizes that are not a multiple of the warp size. + */ +template < + typename T, ///< Data type being reduced + int BLOCK_DIM_X, ///< The thread block length in threads along the X dimension + int BLOCK_DIM_Y, ///< The thread block length in threads along the Y dimension + int BLOCK_DIM_Z, ///< The thread block length in threads along the Z dimension + int PTX_ARCH> ///< The PTX compute capability for which to to specialize this collective +struct BlockReduceRakingCommutativeOnly +{ + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + }; + + // The fall-back implementation to use when BLOCK_THREADS is not a multiple of the warp size or not all threads have valid values + typedef BlockReduceRaking FallBack; + + /// Constants + enum + { + /// Number of warp threads + WARP_THREADS = CUB_WARP_THREADS(PTX_ARCH), + + /// Whether or not to use fall-back + USE_FALLBACK = ((BLOCK_THREADS % WARP_THREADS != 0) || (BLOCK_THREADS <= WARP_THREADS)), + + /// Number of raking threads + RAKING_THREADS = WARP_THREADS, + + /// Number of threads actually sharing items with the raking threads + SHARING_THREADS = CUB_MAX(1, BLOCK_THREADS - RAKING_THREADS), + + /// Number of raking elements per warp synchronous raking thread + SEGMENT_LENGTH = SHARING_THREADS / WARP_THREADS, + }; + + /// WarpReduce utility type + typedef WarpReduce WarpReduce; + + /// Layout type for padded thread block raking grid + typedef BlockRakingLayout BlockRakingLayout; + + /// Shared memory storage layout type + struct _TempStorage + { + union + { + struct + { + typename WarpReduce::TempStorage warp_storage; ///< Storage for warp-synchronous reduction + typename BlockRakingLayout::TempStorage raking_grid; ///< Padded threadblock raking grid + }; + typename FallBack::TempStorage fallback_storage; ///< Fall-back storage for non-commutative block scan + }; + }; + + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + // Thread fields + _TempStorage &temp_storage; + int linear_tid; + + + /// Constructor + __device__ __forceinline__ BlockReduceRakingCommutativeOnly( + TempStorage &temp_storage) + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + /// Computes a threadblock-wide reduction using addition (+) as the reduction operator. The first num_valid threads each contribute one reduction partial. The return value is only valid for thread0. + template + __device__ __forceinline__ T Sum( + T partial, ///< [in] Calling thread's input partial reductions + int num_valid) ///< [in] Number of valid elements (may be less than BLOCK_THREADS) + { + if (USE_FALLBACK || !FULL_TILE) + { + return FallBack(temp_storage.fallback_storage).template Sum(partial, num_valid); + } + else + { + // Place partial into shared memory grid + if (linear_tid >= RAKING_THREADS) + *BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid - RAKING_THREADS) = partial; + + __syncthreads(); + + // Reduce parallelism to one warp + if (linear_tid < RAKING_THREADS) + { + // Raking reduction in grid + T *raking_segment = BlockRakingLayout::RakingPtr(temp_storage.raking_grid, linear_tid); + partial = ThreadReduce(raking_segment, cub::Sum(), partial); + + // Warpscan + partial = WarpReduce(temp_storage.warp_storage).Sum(partial); + } + } + + return partial; + } + + + /// Computes a threadblock-wide reduction using the specified reduction operator. The first num_valid threads each contribute one reduction partial. The return value is only valid for thread0. + template < + bool FULL_TILE, + typename ReductionOp> + __device__ __forceinline__ T Reduce( + T partial, ///< [in] Calling thread's input partial reductions + int num_valid, ///< [in] Number of valid elements (may be less than BLOCK_THREADS) + ReductionOp reduction_op) ///< [in] Binary reduction operator + { + if (USE_FALLBACK || !FULL_TILE) + { + return FallBack(temp_storage.fallback_storage).template Reduce(partial, num_valid, reduction_op); + } + else + { + // Place partial into shared memory grid + if (linear_tid >= RAKING_THREADS) + *BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid - RAKING_THREADS) = partial; + + __syncthreads(); + + // Reduce parallelism to one warp + if (linear_tid < RAKING_THREADS) + { + // Raking reduction in grid + T *raking_segment = BlockRakingLayout::RakingPtr(temp_storage.raking_grid, linear_tid); + partial = ThreadReduce(raking_segment, reduction_op, partial); + + // Warpscan + partial = WarpReduce(temp_storage.warp_storage).Reduce(partial, reduction_op); + } + } + + return partial; + } + +}; + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/specializations/block_reduce_warp_reductions.cuh b/3rdparty/cub/cub/block/specializations/block_reduce_warp_reductions.cuh new file mode 100644 index 00000000000..3ffd11de584 --- /dev/null +++ b/3rdparty/cub/cub/block/specializations/block_reduce_warp_reductions.cuh @@ -0,0 +1,222 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::BlockReduceWarpReductions provides variants of warp-reduction-based parallel reduction across a CUDA threadblock. Supports non-commutative reduction operators. + */ + +#pragma once + +#include "../../warp/warp_reduce.cuh" +#include "../../util_ptx.cuh" +#include "../../util_arch.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief BlockReduceWarpReductions provides variants of warp-reduction-based parallel reduction across a CUDA threadblock. Supports non-commutative reduction operators. + */ +template < + typename T, ///< Data type being reduced + int BLOCK_DIM_X, ///< The thread block length in threads along the X dimension + int BLOCK_DIM_Y, ///< The thread block length in threads along the Y dimension + int BLOCK_DIM_Z, ///< The thread block length in threads along the Z dimension + int PTX_ARCH> ///< The PTX compute capability for which to to specialize this collective +struct BlockReduceWarpReductions +{ + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + + /// Number of warp threads + WARP_THREADS = CUB_WARP_THREADS(PTX_ARCH), + + /// Number of active warps + WARPS = (BLOCK_THREADS + WARP_THREADS - 1) / WARP_THREADS, + + /// The logical warp size for warp reductions + LOGICAL_WARP_SIZE = CUB_MIN(BLOCK_THREADS, WARP_THREADS), + + /// Whether or not the logical warp size evenly divides the threadblock size + EVEN_WARP_MULTIPLE = (BLOCK_THREADS % LOGICAL_WARP_SIZE == 0) + }; + + + /// WarpReduce utility type + typedef typename WarpReduce::InternalWarpReduce WarpReduce; + + + /// Shared memory storage layout type + struct _TempStorage + { + typename WarpReduce::TempStorage warp_reduce[WARPS]; ///< Buffer for warp-synchronous scan + T warp_aggregates[WARPS]; ///< Shared totals from each warp-synchronous scan + T block_prefix; ///< Shared prefix for the entire threadblock + }; + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + // Thread fields + _TempStorage &temp_storage; + int linear_tid; + int warp_id; + int lane_id; + + + /// Constructor + __device__ __forceinline__ BlockReduceWarpReductions( + TempStorage &temp_storage) + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)), + warp_id((WARPS == 1) ? 0 : linear_tid / WARP_THREADS), + lane_id(LaneId()) + {} + + + template + __device__ __forceinline__ T ApplyWarpAggregates( + ReductionOp reduction_op, ///< [in] Binary scan operator + T warp_aggregate, ///< [in] [lane0 only] Warp-wide aggregate reduction of input items + int num_valid, ///< [in] Number of valid elements (may be less than BLOCK_THREADS) + Int2Type successor_warp) + { + if (FULL_TILE || (SUCCESSOR_WARP * LOGICAL_WARP_SIZE < num_valid)) + { + T addend = temp_storage.warp_aggregates[SUCCESSOR_WARP]; + warp_aggregate = reduction_op(warp_aggregate, addend); + } + return ApplyWarpAggregates(reduction_op, warp_aggregate, num_valid, Int2Type()); + } + + template + __device__ __forceinline__ T ApplyWarpAggregates( + ReductionOp reduction_op, ///< [in] Binary scan operator + T warp_aggregate, ///< [in] [lane0 only] Warp-wide aggregate reduction of input items + int num_valid, ///< [in] Number of valid elements (may be less than BLOCK_THREADS) + Int2Type successor_warp) + { + return warp_aggregate; + } + + + /// Returns block-wide aggregate in thread0. + template < + bool FULL_TILE, + typename ReductionOp> + __device__ __forceinline__ T ApplyWarpAggregates( + ReductionOp reduction_op, ///< [in] Binary scan operator + T warp_aggregate, ///< [in] [lane0 only] Warp-wide aggregate reduction of input items + int num_valid) ///< [in] Number of valid elements (may be less than BLOCK_THREADS) + { + // Share lane aggregates + if (lane_id == 0) + { + temp_storage.warp_aggregates[warp_id] = warp_aggregate; + } + + __syncthreads(); + + // Update total aggregate in warp 0, lane 0 + if (linear_tid == 0) + { + warp_aggregate = ApplyWarpAggregates(reduction_op, warp_aggregate, num_valid, Int2Type<1>()); + } + + return warp_aggregate; + } + + + /// Computes a threadblock-wide reduction using addition (+) as the reduction operator. The first num_valid threads each contribute one reduction partial. The return value is only valid for thread0. + template + __device__ __forceinline__ T Sum( + T input, ///< [in] Calling thread's input partial reductions + int num_valid) ///< [in] Number of valid elements (may be less than BLOCK_THREADS) + { + cub::Sum reduction_op; + unsigned int warp_offset = warp_id * LOGICAL_WARP_SIZE; + unsigned int warp_num_valid = (FULL_TILE && EVEN_WARP_MULTIPLE) ? + LOGICAL_WARP_SIZE : + (warp_offset < num_valid) ? + num_valid - warp_offset : + 0; + + // Warp reduction in every warp + T warp_aggregate = WarpReduce(temp_storage.warp_reduce[warp_id]).template Reduce<(FULL_TILE && EVEN_WARP_MULTIPLE), 1>( + input, + warp_num_valid, + cub::Sum()); + + // Update outputs and block_aggregate with warp-wide aggregates from lane-0s + return ApplyWarpAggregates(reduction_op, warp_aggregate, num_valid); + } + + + /// Computes a threadblock-wide reduction using the specified reduction operator. The first num_valid threads each contribute one reduction partial. The return value is only valid for thread0. + template < + bool FULL_TILE, + typename ReductionOp> + __device__ __forceinline__ T Reduce( + T input, ///< [in] Calling thread's input partial reductions + int num_valid, ///< [in] Number of valid elements (may be less than BLOCK_THREADS) + ReductionOp reduction_op) ///< [in] Binary reduction operator + { + unsigned int warp_offset = warp_id * LOGICAL_WARP_SIZE; + unsigned int warp_num_valid = (FULL_TILE && EVEN_WARP_MULTIPLE) ? + LOGICAL_WARP_SIZE : + (warp_offset < num_valid) ? + num_valid - warp_offset : + 0; + + // Warp reduction in every warp + T warp_aggregate = WarpReduce(temp_storage.warp_reduce[warp_id]).template Reduce<(FULL_TILE && EVEN_WARP_MULTIPLE), 1>( + input, + warp_num_valid, + reduction_op); + + // Update outputs and block_aggregate with warp-wide aggregates from lane-0s + return ApplyWarpAggregates(reduction_op, warp_aggregate, num_valid); + } + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/specializations/block_scan_raking.cuh b/3rdparty/cub/cub/block/specializations/block_scan_raking.cuh new file mode 100644 index 00000000000..860dcbbb423 --- /dev/null +++ b/3rdparty/cub/cub/block/specializations/block_scan_raking.cuh @@ -0,0 +1,754 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + + +/** + * \file + * cub::BlockScanRaking provides variants of raking-based parallel prefix scan across a CUDA threadblock. + */ + +#pragma once + +#include "../../util_ptx.cuh" +#include "../../util_arch.cuh" +#include "../../block/block_raking_layout.cuh" +#include "../../thread/thread_reduce.cuh" +#include "../../thread/thread_scan.cuh" +#include "../../warp/warp_scan.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief BlockScanRaking provides variants of raking-based parallel prefix scan across a CUDA threadblock. + */ +template < + typename T, ///< Data type being scanned + int BLOCK_DIM_X, ///< The thread block length in threads along the X dimension + int BLOCK_DIM_Y, ///< The thread block length in threads along the Y dimension + int BLOCK_DIM_Z, ///< The thread block length in threads along the Z dimension + bool MEMOIZE, ///< Whether or not to buffer outer raking scan partials to incur fewer shared memory reads at the expense of higher register pressure + int PTX_ARCH> ///< The PTX compute capability for which to to specialize this collective +struct BlockScanRaking +{ + //--------------------------------------------------------------------- + // Types and constants + //--------------------------------------------------------------------- + + /// Constants + enum + { + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + }; + + /// Layout type for padded threadblock raking grid + typedef BlockRakingLayout BlockRakingLayout; + + /// Constants + enum + { + /// Number of raking threads + RAKING_THREADS = BlockRakingLayout::RAKING_THREADS, + + /// Number of raking elements per warp synchronous raking thread + SEGMENT_LENGTH = BlockRakingLayout::SEGMENT_LENGTH, + + /// Cooperative work can be entirely warp synchronous + WARP_SYNCHRONOUS = (BLOCK_THREADS == RAKING_THREADS), + }; + + /// WarpScan utility type + typedef WarpScan WarpScan; + + /// Shared memory storage layout type + struct _TempStorage + { + typename WarpScan::TempStorage warp_scan; ///< Buffer for warp-synchronous scan + typename BlockRakingLayout::TempStorage raking_grid; ///< Padded threadblock raking grid + T block_aggregate; ///< Block aggregate + }; + + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Per-thread fields + //--------------------------------------------------------------------- + + // Thread fields + _TempStorage &temp_storage; + int linear_tid; + T cached_segment[SEGMENT_LENGTH]; + + + //--------------------------------------------------------------------- + // Utility methods + //--------------------------------------------------------------------- + + /// Templated reduction + template + __device__ __forceinline__ T GuardedReduce( + T* raking_ptr, ///< [in] Input array + ScanOp scan_op, ///< [in] Binary reduction operator + T raking_partial, ///< [in] Prefix to seed reduction with + Int2Type iteration) + { + if ((BlockRakingLayout::UNGUARDED) || (((linear_tid * SEGMENT_LENGTH) + ITERATION) < BLOCK_THREADS)) + { + T addend = raking_ptr[ITERATION]; + raking_partial = scan_op(raking_partial, addend); + } + + return GuardedReduce(raking_ptr, scan_op, raking_partial, Int2Type()); + } + + + /// Templated reduction (base case) + template + __device__ __forceinline__ T GuardedReduce( + T* raking_ptr, ///< [in] Input array + ScanOp scan_op, ///< [in] Binary reduction operator + T raking_partial, ///< [in] Prefix to seed reduction with + Int2Type iteration) + { + return raking_partial; + } + + + /// Templated copy + template + __device__ __forceinline__ void CopySegment( + T* out, ///< [out] Out array + T* in, ///< [in] Input array + Int2Type iteration) + { + out[ITERATION] = in[ITERATION]; + CopySegment(out, in, Int2Type()); + } + + + /// Templated copy (base case) + __device__ __forceinline__ void CopySegment( + T* out, ///< [out] Out array + T* in, ///< [in] Input array + Int2Type iteration) + {} + + + /// Performs upsweep raking reduction, returning the aggregate + template + __device__ __forceinline__ T Upsweep( + ScanOp scan_op) + { + T *smem_raking_ptr = BlockRakingLayout::RakingPtr(temp_storage.raking_grid, linear_tid); + + // Read data into registers + CopySegment(cached_segment, smem_raking_ptr, Int2Type<0>()); + + T raking_partial = cached_segment[0]; + + return GuardedReduce(cached_segment, scan_op, raking_partial, Int2Type<1>()); + } + + + /// Performs exclusive downsweep raking scan + template + __device__ __forceinline__ void ExclusiveDownsweep( + ScanOp scan_op, + T raking_partial, + bool apply_prefix = true) + { + T *smem_raking_ptr = BlockRakingLayout::RakingPtr(temp_storage.raking_grid, linear_tid); + + // Read data back into registers + if (!MEMOIZE) + { + CopySegment(cached_segment, smem_raking_ptr, Int2Type<0>()); + } + + ThreadScanExclusive(cached_segment, cached_segment, scan_op, raking_partial, apply_prefix); + + // Write data back to smem + CopySegment(smem_raking_ptr, cached_segment, Int2Type<0>()); + } + + + /// Performs inclusive downsweep raking scan + template + __device__ __forceinline__ void InclusiveDownsweep( + ScanOp scan_op, + T raking_partial, + bool apply_prefix = true) + { + T *smem_raking_ptr = BlockRakingLayout::RakingPtr(temp_storage.raking_grid, linear_tid); + + // Read data back into registers + if (!MEMOIZE) + { + CopySegment(cached_segment, smem_raking_ptr, Int2Type<0>()); + } + + ThreadScanInclusive(cached_segment, cached_segment, scan_op, raking_partial, apply_prefix); + + // Write data back to smem + CopySegment(smem_raking_ptr, cached_segment, Int2Type<0>()); + } + + + //--------------------------------------------------------------------- + // Constructors + //--------------------------------------------------------------------- + + /// Constructor + __device__ __forceinline__ BlockScanRaking( + TempStorage &temp_storage) + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)) + {} + + + //--------------------------------------------------------------------- + // Exclusive scans + //--------------------------------------------------------------------- + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input items + T &output, ///< [out] Calling thread's output items (may be aliased to \p input) + const T &identity, ///< [in] Identity value + ScanOp scan_op) ///< [in] Binary scan operator + { + if (WARP_SYNCHRONOUS) + { + // Short-circuit directly to warp-synchronous scan + WarpScan(temp_storage.warp_scan).ExclusiveScan(input, output, identity, scan_op); + } + else + { + // Place thread partial into shared memory raking grid + T *placement_ptr = BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid); + *placement_ptr = input; + + __syncthreads(); + + // Reduce parallelism down to just raking threads + if (linear_tid < RAKING_THREADS) + { + // Raking upsweep reduction across shared partials + T upsweep_partial = Upsweep(scan_op); + + // Exclusive Warp-synchronous scan + T exclusive_partial; + WarpScan(temp_storage.warp_scan).ExclusiveScan(upsweep_partial, exclusive_partial, identity, scan_op); + + // Exclusive raking downsweep scan + ExclusiveDownsweep(scan_op, exclusive_partial); + } + + __syncthreads(); + + // Grab exclusive partial from shared memory + output = *placement_ptr; + } + } + + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. Also provides every thread with the block-wide \p block_aggregate of all inputs. + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input items + T &output, ///< [out] Calling thread's output items (may be aliased to \p input) + const T &identity, ///< [in] Identity value + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate) ///< [out] Threadblock-wide aggregate reduction of input items + { + if (WARP_SYNCHRONOUS) + { + // Short-circuit directly to warp-synchronous scan + WarpScan(temp_storage.warp_scan).ExclusiveScan(input, output, identity, scan_op, block_aggregate); + } + else + { + // Place thread partial into shared memory raking grid + T *placement_ptr = BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid); + *placement_ptr = input; + + __syncthreads(); + + // Reduce parallelism down to just raking threads + if (linear_tid < RAKING_THREADS) + { + // Raking upsweep reduction across shared partials + T upsweep_partial = Upsweep(scan_op); + + // Warp-synchronous scan + T inclusive_partial; + T exclusive_partial; + WarpScan(temp_storage.warp_scan).Scan(upsweep_partial, inclusive_partial, exclusive_partial, identity, scan_op); + + // Exclusive raking downsweep scan + ExclusiveDownsweep(scan_op, exclusive_partial); + + // Broadcast aggregate to other threads + if (linear_tid == RAKING_THREADS - 1) + temp_storage.block_aggregate = inclusive_partial; + } + + __syncthreads(); + + // Grab exclusive partial from shared memory + output = *placement_ptr; + + // Retrieve block aggregate + block_aggregate = temp_storage.block_aggregate; + } + } + + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. + template < + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + T identity, ///< [in] Identity value + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate, ///< [out] Threadblock-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a threadblock-wide prefix to be applied to all inputs. + { + if (WARP_SYNCHRONOUS) + { + // Short-circuit directly to warp-synchronous scan + WarpScan(temp_storage.warp_scan).ExclusiveScan(input, output, identity, scan_op, block_aggregate); + + // Obtain warp-wide prefix in lane0, then broadcast to other lanes + T prefix = block_prefix_callback_op(block_aggregate); + prefix = WarpScan(temp_storage.warp_scan).Broadcast(prefix, 0); + + output = scan_op(prefix, output); + if (linear_tid == 0) + output = prefix; + } + else + { + // Place thread partial into shared memory raking grid + T *placement_ptr = BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid); + *placement_ptr = input; + + __syncthreads(); + + // Reduce parallelism down to just raking threads + if (linear_tid < RAKING_THREADS) + { + // Raking upsweep reduction across shared partials + T upsweep_partial = Upsweep(scan_op); + + // Warp-synchronous scan + T inclusive_partial; + T exclusive_partial; + WarpScan(temp_storage.warp_scan).Scan(upsweep_partial, inclusive_partial, exclusive_partial, identity, scan_op); + + // Broadcast aggregate to other lanes (through smem because we eventually want it in all threads) + if (linear_tid == RAKING_THREADS - 1) + ThreadStore(&temp_storage.block_aggregate, inclusive_partial); + block_aggregate = ThreadLoad(&temp_storage.block_aggregate); + + // Obtain block-wide prefix in lane0, then broadcast to other lanes + T prefix = block_prefix_callback_op(block_aggregate); + prefix = WarpScan(temp_storage.warp_scan).Broadcast(prefix, 0); + + // Update prefix with warpscan exclusive partial + if (linear_tid > 0) + prefix = scan_op(prefix, exclusive_partial); + + // Exclusive raking downsweep scan + ExclusiveDownsweep(scan_op, prefix); + } + + __syncthreads(); + + // Grab exclusive partial from shared memory + output = *placement_ptr; + + // Retrieve block aggregate + block_aggregate = temp_storage.block_aggregate; + } + } + + //--------------------------------------------------------------------- + // Identity-less exclusive scans + //--------------------------------------------------------------------- + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. With no identity value, the output computed for thread0 is undefined. + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op) ///< [in] Binary scan operator + { + if (WARP_SYNCHRONOUS) + { + // Short-circuit directly to warp-synchronous scan + WarpScan(temp_storage.warp_scan).ExclusiveScan(input, output, scan_op); + } + else + { + // Place thread partial into shared memory raking grid + T *placement_ptr = BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid); + *placement_ptr = input; + + __syncthreads(); + + // Reduce parallelism down to just raking threads + if (linear_tid < RAKING_THREADS) + { + // Raking upsweep reduction across shared partials + T upsweep_partial = Upsweep(scan_op); + + // Warp-synchronous scan + T exclusive_partial; + WarpScan(temp_storage.warp_scan).ExclusiveScan(upsweep_partial, exclusive_partial, scan_op); + + // Exclusive raking downsweep scan + ExclusiveDownsweep(scan_op, exclusive_partial, (linear_tid != 0)); + } + + __syncthreads(); + + // Grab thread prefix from shared memory + output = *placement_ptr; + } + } + + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. Also provides every thread with the block-wide \p block_aggregate of all inputs. With no identity value, the output computed for thread0 is undefined. + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate) ///< [out] Threadblock-wide aggregate reduction of input items + { + if (WARP_SYNCHRONOUS) + { + // Short-circuit directly to warp-synchronous scan + WarpScan(temp_storage.warp_scan).ExclusiveScan(input, output, scan_op, block_aggregate); + } + else + { + // Place thread partial into shared memory raking grid + T *placement_ptr = BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid); + *placement_ptr = input; + + __syncthreads(); + + // Reduce parallelism down to just raking threads + if (linear_tid < RAKING_THREADS) + { + // Raking upsweep reduction across shared partials + T upsweep_partial= Upsweep(scan_op); + + // Warp-synchronous scan + T inclusive_partial; + T exclusive_partial; + WarpScan(temp_storage.warp_scan).Scan(upsweep_partial, inclusive_partial, exclusive_partial, scan_op); + + // Exclusive raking downsweep scan + ExclusiveDownsweep(scan_op, exclusive_partial, (linear_tid != 0)); + + // Broadcast aggregate to all threads + if (linear_tid == RAKING_THREADS - 1) + temp_storage.block_aggregate = inclusive_partial; + } + + __syncthreads(); + + // Grab thread prefix from shared memory + output = *placement_ptr; + + // Retrieve block aggregate + block_aggregate = temp_storage.block_aggregate; + } + } + + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + template < + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate, ///< [out] Threadblock-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a threadblock-wide prefix to be applied to all inputs. + { + if (WARP_SYNCHRONOUS) + { + // Short-circuit directly to warp-synchronous scan + WarpScan(temp_storage.warp_scan).ExclusiveScan(input, output, scan_op, block_aggregate); + + // Obtain warp-wide prefix in lane0, then broadcast to other lanes + T prefix = block_prefix_callback_op(block_aggregate); + prefix = WarpScan(temp_storage.warp_scan).Broadcast(prefix, 0); + + output = scan_op(prefix, output); + if (linear_tid == 0) + output = prefix; + } + else + { + // Place thread partial into shared memory raking grid + T *placement_ptr = BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid); + *placement_ptr = input; + + __syncthreads(); + + // Reduce parallelism down to just raking threads + if (linear_tid < RAKING_THREADS) + { + // Raking upsweep reduction across shared partials + T upsweep_partial = Upsweep(scan_op); + + // Warp-synchronous scan + T inclusive_partial; + T exclusive_partial; + WarpScan(temp_storage.warp_scan).Scan(upsweep_partial, inclusive_partial, exclusive_partial, scan_op); + + // Broadcast aggregate to other lanes (through smem because we eventually want it in all threads) + if (linear_tid == RAKING_THREADS - 1) + ThreadStore(&temp_storage.block_aggregate, inclusive_partial); + block_aggregate = ThreadLoad(&temp_storage.block_aggregate); + + // Obtain block-wide prefix in lane0, then broadcast to other lanes + T prefix = block_prefix_callback_op(block_aggregate); + prefix = WarpScan(temp_storage.warp_scan).Broadcast(prefix, 0); + + // Update prefix with warpscan exclusive partial + if (linear_tid > 0) + prefix = scan_op(prefix, exclusive_partial); + + // Exclusive raking downsweep scan + ExclusiveDownsweep(scan_op, prefix); + } + + __syncthreads(); + + // Grab thread prefix from shared memory + output = *placement_ptr; + + // Retrieve block aggregate + block_aggregate = temp_storage.block_aggregate; + } + } + + + //--------------------------------------------------------------------- + // Inclusive scans + //--------------------------------------------------------------------- + + /// Computes an inclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op) ///< [in] Binary scan operator + { + if (WARP_SYNCHRONOUS) + { + // Short-circuit directly to warp-synchronous scan + WarpScan(temp_storage.warp_scan).InclusiveScan(input, output, scan_op); + } + else + { + // Place thread partial into shared memory raking grid + T *placement_ptr = BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid); + *placement_ptr = input; + + __syncthreads(); + + // Reduce parallelism down to just raking threads + if (linear_tid < RAKING_THREADS) + { + // Raking upsweep reduction across shared partials + T upsweep_partial = Upsweep(scan_op); + + // Exclusive Warp-synchronous scan + T exclusive_partial; + WarpScan(temp_storage.warp_scan).ExclusiveScan(upsweep_partial, exclusive_partial, scan_op); + + // Inclusive raking downsweep scan + InclusiveDownsweep(scan_op, exclusive_partial, (linear_tid != 0)); + } + + __syncthreads(); + + // Grab thread prefix from shared memory + output = *placement_ptr; + } + } + + + /// Computes an inclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. Also provides every thread with the block-wide \p block_aggregate of all inputs. + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate) ///< [out] Threadblock-wide aggregate reduction of input items + { + if (WARP_SYNCHRONOUS) + { + // Short-circuit directly to warp-synchronous scan + WarpScan(temp_storage.warp_scan).InclusiveScan(input, output, scan_op, block_aggregate); + } + else + { + // Place thread partial into shared memory raking grid + T *placement_ptr = BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid); + *placement_ptr = input; + + __syncthreads(); + + // Reduce parallelism down to just raking threads + if (linear_tid < RAKING_THREADS) + { + // Raking upsweep reduction across shared partials + T upsweep_partial = Upsweep(scan_op); + + // Warp-synchronous scan + T inclusive_partial; + T exclusive_partial; + WarpScan(temp_storage.warp_scan).Scan(upsweep_partial, inclusive_partial, exclusive_partial, scan_op); + + // Inclusive raking downsweep scan + InclusiveDownsweep(scan_op, exclusive_partial, (linear_tid != 0)); + + // Broadcast aggregate to all threads + if (linear_tid == RAKING_THREADS - 1) + temp_storage.block_aggregate = inclusive_partial; + } + + __syncthreads(); + + // Grab thread prefix from shared memory + output = *placement_ptr; + + // Retrieve block aggregate + block_aggregate = temp_storage.block_aggregate; + } + } + + + /// Computes an inclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + template < + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate, ///< [out] Threadblock-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a threadblock-wide prefix to be applied to all inputs. + { + if (WARP_SYNCHRONOUS) + { + // Short-circuit directly to warp-synchronous scan + T inclusive_partial; + WarpScan(temp_storage.warp_scan).InclusiveScan(input, inclusive_partial, scan_op, block_aggregate); + + // Obtain warp-wide prefix in lane0, then broadcast to other lanes + output = block_prefix_callback_op(block_aggregate); + output = WarpScan(temp_storage.warp_scan).Broadcast(output, 0); + + // Update prefix with exclusive warpscan partial + output = scan_op(output, inclusive_partial); + } + else + { + // Place thread partial into shared memory raking grid + T *placement_ptr = BlockRakingLayout::PlacementPtr(temp_storage.raking_grid, linear_tid); + *placement_ptr = input; + + __syncthreads(); + + // Reduce parallelism down to just raking threads + if (linear_tid < RAKING_THREADS) + { + // Raking upsweep reduction across shared partials + T upsweep_partial = Upsweep(scan_op); + + // Warp-synchronous scan + T inclusive_partial; + T exclusive_partial; + WarpScan(temp_storage.warp_scan).Scan(upsweep_partial, inclusive_partial, exclusive_partial, scan_op); + + // Broadcast aggregate to other lanes (through smem because we eventually want it in all threads) + if (linear_tid == RAKING_THREADS - 1) + ThreadStore(&temp_storage.block_aggregate, inclusive_partial); + block_aggregate = ThreadLoad(&temp_storage.block_aggregate); + + // Obtain block-wide prefix in lane0, then broadcast to other lanes + T prefix = block_prefix_callback_op(block_aggregate); + prefix = WarpScan(temp_storage.warp_scan).Broadcast(prefix, 0); + + // Update prefix with warpscan exclusive partial + if (linear_tid > 0) + prefix = scan_op(prefix, exclusive_partial); + + // Inclusive raking downsweep scan + InclusiveDownsweep(scan_op, prefix); + } + + __syncthreads(); + + // Grab thread prefix from shared memory + output = *placement_ptr; + + // Retrieve block aggregate + block_aggregate = temp_storage.block_aggregate; + } + } + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/block/specializations/block_scan_warp_scans.cuh b/3rdparty/cub/cub/block/specializations/block_scan_warp_scans.cuh new file mode 100644 index 00000000000..180a821583a --- /dev/null +++ b/3rdparty/cub/cub/block/specializations/block_scan_warp_scans.cuh @@ -0,0 +1,379 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::BlockScanWarpscans provides warpscan-based variants of parallel prefix scan across a CUDA threadblock. + */ + +#pragma once + +#include "../../util_arch.cuh" +#include "../../util_ptx.cuh" +#include "../../warp/warp_scan.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \brief BlockScanWarpScans provides warpscan-based variants of parallel prefix scan across a CUDA threadblock. + */ +template < + typename T, + int BLOCK_DIM_X, ///< The thread block length in threads along the X dimension + int BLOCK_DIM_Y, ///< The thread block length in threads along the Y dimension + int BLOCK_DIM_Z, ///< The thread block length in threads along the Z dimension + int PTX_ARCH> ///< The PTX compute capability for which to to specialize this collective +struct BlockScanWarpScans +{ + //--------------------------------------------------------------------- + // Types and constants + //--------------------------------------------------------------------- + + /// Constants + enum + { + /// Number of warp threads + WARP_THREADS = CUB_WARP_THREADS(PTX_ARCH), + + /// The thread block size in threads + BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z, + + /// Number of active warps + WARPS = (BLOCK_THREADS + WARP_THREADS - 1) / WARP_THREADS, + }; + + /// WarpScan utility type + typedef WarpScan WarpScanT; + + /// WarpScan utility type + typedef WarpScan WarpAggregateScan; + + /// Shared memory storage layout type + struct _TempStorage + { + typename WarpScanT::TempStorage warp_scan[WARPS]; ///< Buffer for warp-synchronous scans + T warp_aggregates[WARPS]; + T block_prefix; ///< Shared prefix for the entire threadblock + }; + + + /// Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + //--------------------------------------------------------------------- + // Per-thread fields + //--------------------------------------------------------------------- + + // Thread fields + _TempStorage &temp_storage; + int linear_tid; + int warp_id; + int lane_id; + + + //--------------------------------------------------------------------- + // Constructors + //--------------------------------------------------------------------- + + /// Constructor + __device__ __forceinline__ BlockScanWarpScans( + TempStorage &temp_storage) + : + temp_storage(temp_storage.Alias()), + linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z)), + warp_id((WARPS == 1) ? 0 : linear_tid / WARP_THREADS), + lane_id(LaneId()) + {} + + + //--------------------------------------------------------------------- + // Utility methods + //--------------------------------------------------------------------- + + template + __device__ __forceinline__ void ApplyWarpAggregates( + T &partial, ///< [out] The calling thread's partial reduction + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate, ///< [out] Threadblock-wide aggregate reduction of input items + bool lane_valid, ///< [in] Whether or not the partial belonging to the current thread is valid + Int2Type addend_warp) + { + T inclusive = scan_op(block_aggregate, partial); + if (warp_id == WARP) + { + partial = (lane_valid) ? + inclusive : + block_aggregate; + } + + T addend = temp_storage.warp_aggregates[WARP]; + block_aggregate = scan_op(block_aggregate, addend); + + ApplyWarpAggregates(partial, scan_op, block_aggregate, lane_valid, Int2Type()); + } + + template + __device__ __forceinline__ void ApplyWarpAggregates( + T &partial, ///< [out] The calling thread's partial reduction + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate, ///< [out] Threadblock-wide aggregate reduction of input items + bool lane_valid, ///< [in] Whether or not the partial belonging to the current thread is valid + Int2Type addend_warp) + {} + + + /// Update the calling thread's partial reduction with the warp-wide aggregates from preceding warps. Also returns block-wide aggregate in thread0. + template + __device__ __forceinline__ void ApplyWarpAggregates( + T &partial, ///< [out] The calling thread's partial reduction + ScanOp scan_op, ///< [in] Binary scan operator + T warp_aggregate, ///< [in] [laneWARP_THREADS - 1 only] Warp-wide aggregate reduction of input items + T &block_aggregate, ///< [out] Threadblock-wide aggregate reduction of input items + bool lane_valid = true) ///< [in] Whether or not the partial belonging to the current thread is valid + { + // Last lane in each warp shares its warp-aggregate + if (lane_id == WARP_THREADS - 1) + temp_storage.warp_aggregates[warp_id] = warp_aggregate; + + __syncthreads(); + + block_aggregate = temp_storage.warp_aggregates[0]; + + // Use template unrolling (since the PTX backend can't handle unrolling it for SM1x) + ApplyWarpAggregates(partial, scan_op, block_aggregate, lane_valid, Int2Type<1>()); + } + + //--------------------------------------------------------------------- + // Exclusive scans + //--------------------------------------------------------------------- + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input items + T &output, ///< [out] Calling thread's output items (may be aliased to \p input) + const T &identity, ///< [in] Identity value + ScanOp scan_op) ///< [in] Binary scan operator + { + T block_aggregate; + ExclusiveScan(input, output, identity, scan_op, block_aggregate); + } + + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. Also provides every thread with the block-wide \p block_aggregate of all inputs. + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input items + T &output, ///< [out] Calling thread's output items (may be aliased to \p input) + const T &identity, ///< [in] Identity value + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate) ///< [out] Threadblock-wide aggregate reduction of input items + { + T inclusive_output; + WarpScanT(temp_storage.warp_scan[warp_id]).Scan(input, inclusive_output, output, identity, scan_op); + + // Update outputs and block_aggregate with warp-wide aggregates + ApplyWarpAggregates(output, scan_op, inclusive_output, block_aggregate); + } + + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + template < + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + T identity, ///< [in] Identity value + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate, ///< [out] Threadblock-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a threadblock-wide prefix to be applied to all inputs. + { + ExclusiveScan(input, output, identity, scan_op, block_aggregate); + + // Use the first warp to determine the threadblock prefix, returning the result in lane0 + if (warp_id == 0) + { + T block_prefix = block_prefix_callback_op(block_aggregate); + if (lane_id == 0) + { + // Share the prefix with all threads + temp_storage.block_prefix = block_prefix; + } + } + + __syncthreads(); + + // Incorporate threadblock prefix into outputs + T block_prefix = temp_storage.block_prefix; + output = scan_op(block_prefix, output); + } + + + //--------------------------------------------------------------------- + // Identity-less exclusive scans + //--------------------------------------------------------------------- + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. With no identity value, the output computed for thread0 is undefined. + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op) ///< [in] Binary scan operator + { + T block_aggregate; + ExclusiveScan(input, output, scan_op, block_aggregate); + } + + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. Also provides every thread with the block-wide \p block_aggregate of all inputs. With no identity value, the output computed for thread0 is undefined. + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate) ///< [out] Threadblock-wide aggregate reduction of input items + { + T inclusive_output; + WarpScanT(temp_storage.warp_scan[warp_id]).Scan(input, inclusive_output, output, scan_op); + + // Update outputs and block_aggregate with warp-wide aggregates + ApplyWarpAggregates(output, scan_op, inclusive_output, block_aggregate, (lane_id > 0)); + } + + + /// Computes an exclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + template < + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate, ///< [out] Threadblock-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a threadblock-wide prefix to be applied to all inputs. + { + ExclusiveScan(input, output, scan_op, block_aggregate); + + // Use the first warp to determine the threadblock prefix, returning the result in lane0 + if (warp_id == 0) + { + T block_prefix = block_prefix_callback_op(block_aggregate); + if (lane_id == 0) + { + // Share the prefix with all threads + temp_storage.block_prefix = block_prefix; + } + } + + __syncthreads(); + + // Incorporate threadblock prefix into outputs + T block_prefix = temp_storage.block_prefix; + output = (linear_tid == 0) ? + block_prefix : + scan_op(block_prefix, output); + } + + + //--------------------------------------------------------------------- + // Inclusive scans + //--------------------------------------------------------------------- + + /// Computes an inclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op) ///< [in] Binary scan operator + { + T block_aggregate; + InclusiveScan(input, output, scan_op, block_aggregate); + } + + + /// Computes an inclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. Also provides every thread with the block-wide \p block_aggregate of all inputs. + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate) ///< [out] Threadblock-wide aggregate reduction of input items + { + WarpScanT(temp_storage.warp_scan[warp_id]).InclusiveScan(input, output, scan_op); + + // Update outputs and block_aggregate with warp-wide aggregates from lane WARP_THREADS-1 + ApplyWarpAggregates(output, scan_op, output, block_aggregate); + + } + + + /// Computes an inclusive threadblock-wide prefix scan using the specified binary \p scan_op functor. Each thread contributes one input element. the call-back functor \p block_prefix_callback_op is invoked by the first warp in the block, and the value returned by lane0 in that warp is used as the "seed" value that logically prefixes the threadblock's scan inputs. Also provides every thread with the block-wide \p block_aggregate of all inputs. + template < + typename ScanOp, + typename BlockPrefixCallbackOp> + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item + T &output, ///< [out] Calling thread's output item (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T &block_aggregate, ///< [out] Threadblock-wide aggregate reduction of input items (exclusive of the \p block_prefix_callback_op value) + BlockPrefixCallbackOp &block_prefix_callback_op) ///< [in-out] [warp0 only] Call-back functor for specifying a threadblock-wide prefix to be applied to all inputs. + { + InclusiveScan(input, output, scan_op, block_aggregate); + + // Use the first warp to determine the threadblock prefix, returning the result in lane0 + if (warp_id == 0) + { + T block_prefix = block_prefix_callback_op(block_aggregate); + if (lane_id == 0) + { + // Share the prefix with all threads + temp_storage.block_prefix = block_prefix; + } + } + + __syncthreads(); + + // Incorporate threadblock prefix into outputs + T block_prefix = temp_storage.block_prefix; + output = scan_op(block_prefix, output); + } + + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/cub.cuh b/3rdparty/cub/cub/cub.cuh new file mode 100644 index 00000000000..45457f6ca28 --- /dev/null +++ b/3rdparty/cub/cub/cub.cuh @@ -0,0 +1,97 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * CUB umbrella include file + */ + +#pragma once + + +// Block +#include "block/block_histogram.cuh" +#include "block/block_discontinuity.cuh" +#include "block/block_exchange.cuh" +#include "block/block_load.cuh" +#include "block/block_radix_rank.cuh" +#include "block/block_radix_sort.cuh" +#include "block/block_reduce.cuh" +#include "block/block_scan.cuh" +#include "block/block_store.cuh" +//#include "block/block_shift.cuh" + +// Device +#include "device/device_histogram.cuh" +#include "device/device_partition.cuh" +#include "device/device_radix_sort.cuh" +#include "device/device_reduce.cuh" +#include "device/device_run_length_encode.cuh" +#include "device/device_scan.cuh" +#include "device/device_select.cuh" +#include "device/device_spmv.cuh" + +// Grid +//#include "grid/grid_barrier.cuh" +#include "grid/grid_even_share.cuh" +#include "grid/grid_mapping.cuh" +#include "grid/grid_queue.cuh" + +// Host +#include "host/spinlock.cuh" + +// Thread +#include "thread/thread_load.cuh" +#include "thread/thread_operators.cuh" +#include "thread/thread_reduce.cuh" +#include "thread/thread_scan.cuh" +#include "thread/thread_store.cuh" + +// Warp +#include "warp/warp_reduce.cuh" +#include "warp/warp_scan.cuh" + +// Iterator +#include "iterator/arg_index_input_iterator.cuh" +#include "iterator/cache_modified_input_iterator.cuh" +#include "iterator/cache_modified_output_iterator.cuh" +#include "iterator/constant_input_iterator.cuh" +#include "iterator/counting_input_iterator.cuh" +#include "iterator/tex_obj_input_iterator.cuh" +#include "iterator/tex_ref_input_iterator.cuh" +#include "iterator/transform_input_iterator.cuh" + +// Util +#include "util_allocator.cuh" +#include "util_arch.cuh" +#include "util_debug.cuh" +#include "util_device.cuh" +#include "util_macro.cuh" +#include "util_ptx.cuh" +#include "util_type.cuh" + diff --git a/3rdparty/cub/cub/device/device_histogram.cuh b/3rdparty/cub/cub/device/device_histogram.cuh new file mode 100644 index 00000000000..e7b635ef8bd --- /dev/null +++ b/3rdparty/cub/cub/device/device_histogram.cuh @@ -0,0 +1,876 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceHistogram provides device-wide parallel operations for constructing histogram(s) from a sequence of samples data residing within global memory. + */ + +#pragma once + +#include +#include +#include + +#include "dispatch/dispatch_histogram.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief DeviceHistogram provides device-wide parallel operations for constructing histogram(s) from a sequence of samples data residing within global memory. ![](histogram_logo.png) + * \ingroup DeviceModule + * + * \par Overview + * A histogram + * counts the number of observations that fall into each of the disjoint categories (known as bins). + * + * \par Usage Considerations + * \cdp_class{DeviceHistogram} + * + */ +struct DeviceHistogram +{ + /******************************************************************//** + * \name Evenly-segmented bin ranges + *********************************************************************/ + //@{ + + /** + * \brief Computes an intensity histogram from a sequence of data samples using equal-width bins. + * + * \par + * - The number of histogram bins is (\p num_levels - 1) + * - All bins comprise the same width of sample values: (\p upper_level - \p lower_level) / (\p num_levels - 1) + * - \devicestorage + * - \cdp + * + * \par Snippet + * The code snippet below illustrates the computation of a six-bin histogram + * from a sequence of float samples + * + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input samples and + * // output histogram + * int num_samples; // e.g., 10 + * float* d_samples; // e.g., [2.2, 6.0, 7.1, 2.9, 3.5, 0.3, 2.9, 2.0, 6.1, 999.5] + * int* d_histogram; // e.g., [ -, -, -, -, -, -, -, -] + * int num_levels; // e.g., 7 (seven level boundaries for six bins) + * float lower_level; // e.g., 0.0 (lower sample value boundary of lowest bin) + * float upper_level; // e.g., 12.0 (upper sample value boundary of upper bin) + * ... + * + * // Determine temporary device storage requirements + * void* d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceHistogram::HistogramEven(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, lower_level, upper_level, num_samples); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Compute histograms + * cub::DeviceHistogram::HistogramEven(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, lower_level, upper_level, num_samples); + * + * // d_histogram <-- [1, 0, 5, 0, 3, 0, 0, 0]; + * + * \endcode + * + * \tparam SampleIteratorT [inferred] Random-access input iterator type for reading input samples. \iterator + * \tparam CounterT [inferred] Integer type for histogram bin counters + * \tparam LevelT [inferred] Type for specifying boundaries (levels) + * \tparam OffsetT [inferred] Signed integer type for sequence offsets, list lengths, pointer differences, etc. \offset_size1 + */ + template < + typename SampleIteratorT, + typename CounterT, + typename LevelT, + typename OffsetT> + CUB_RUNTIME_FUNCTION + static cudaError_t HistogramEven( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the input sequence of data samples. + CounterT* d_histogram, ///< [out] The pointer to the histogram counter output array of length num_levels - 1. + int num_levels, ///< [in] The number of boundaries (levels) for delineating histogram samples. Implies that the number of bins is num_levels - 1. + LevelT lower_level, ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin. + LevelT upper_level, ///< [in] The upper sample value bound (exclusive) for the highest histogram bin. + OffsetT num_samples, ///< [in] The number of input samples (i.e., the length of \p d_samples) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + /// The sample value type of the input iterator + typedef typename std::iterator_traits::value_type SampleT; + + CounterT* d_histogram1[1] = {d_histogram}; + int num_levels1[1] = {num_levels}; + LevelT lower_level1[1] = {lower_level}; + LevelT upper_level1[1] = {upper_level}; + + return MultiHistogramEven<1, 1>( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_histogram1, + num_levels1, + lower_level1, + upper_level1, + num_samples, + 1, + sizeof(SampleT) * num_samples, + stream, + debug_synchronous); + } + + + /** + * \brief Computes an intensity histogram from a sequence of data samples using equal-width bins. + * + * \par + * - A two-dimensional region of interest within \p d_samples can be specified + * using the \p num_row_samples, num_rows, and \p row_stride_bytes parameters. + * - The row stride must be a whole multiple of the sample data type + * size, i.e., (row_stride_bytes % sizeof(SampleT)) == 0. + * - The number of histogram bins is (\p num_levels - 1) + * - All bins comprise the same width of sample values: (\p upper_level - \p lower_level) / (\p num_levels - 1) + * - \devicestorage + * - \cdp + * + * \par Snippet + * The code snippet below illustrates the computation of a six-bin histogram + * from a 2x5 region of interest within a flattened 2x7 array of float samples. + * + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input samples and + * // output histogram + * int num_row_samples; // e.g., 5 + * int num_rows; // e.g., 2; + * size_t row_stride_bytes; // e.g., 7 * sizeof(float) + * float* d_samples; // e.g., [2.2, 6.0, 7.1, 2.9, 3.5, -, -, + * // 0.3, 2.9, 2.0, 6.1, 999.5, -, -] + * int* d_histogram; // e.g., [ -, -, -, -, -, -, -, -] + * int num_levels; // e.g., 7 (seven level boundaries for six bins) + * float lower_level; // e.g., 0.0 (lower sample value boundary of lowest bin) + * float upper_level; // e.g., 12.0 (upper sample value boundary of upper bin) + * ... + * + * // Determine temporary device storage requirements + * void* d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceHistogram::HistogramEven(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, lower_level, upper_level, + * num_row_samples, num_rows, row_stride_bytes); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Compute histograms + * cub::DeviceHistogram::HistogramEven(d_temp_storage, temp_storage_bytes, d_samples, d_histogram, + * d_samples, d_histogram, num_levels, lower_level, upper_level, + * num_row_samples, num_rows, row_stride_bytes); + * + * // d_histogram <-- [1, 0, 5, 0, 3, 0, 0, 0]; + * + * \endcode + * + * \tparam SampleIteratorT [inferred] Random-access input iterator type for reading input samples. \iterator + * \tparam CounterT [inferred] Integer type for histogram bin counters + * \tparam LevelT [inferred] Type for specifying boundaries (levels) + * \tparam OffsetT [inferred] Signed integer type for sequence offsets, list lengths, pointer differences, etc. \offset_size1 + */ + template < + typename SampleIteratorT, + typename CounterT, + typename LevelT, + typename OffsetT> + CUB_RUNTIME_FUNCTION + static cudaError_t HistogramEven( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the input sequence of data samples. + CounterT* d_histogram, ///< [out] The pointer to the histogram counter output array of length num_levels - 1. + int num_levels, ///< [in] The number of boundaries (levels) for delineating histogram samples. Implies that the number of bins is num_levels - 1. + LevelT lower_level, ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin. + LevelT upper_level, ///< [in] The upper sample value bound (exclusive) for the highest histogram bin. + OffsetT num_row_samples, ///< [in] The number of data samples per row in the region of interest + OffsetT num_rows, ///< [in] The number of rows in the region of interest + size_t row_stride_bytes, ///< [in] The number of bytes between starts of consecutive rows in the region of interest + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + CounterT* d_histogram1[1] = {d_histogram}; + int num_levels1[1] = {num_levels}; + LevelT lower_level1[1] = {lower_level}; + LevelT upper_level1[1] = {upper_level}; + + return MultiHistogramEven<1, 1>( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_histogram1, + num_levels1, + lower_level1, + upper_level1, + num_row_samples, + num_rows, + row_stride_bytes, + stream, + debug_synchronous); + } + + /** + * \brief Computes per-channel intensity histograms from a sequence of multi-channel "pixel" data samples using equal-width bins. + * + * \par + * - The input is a sequence of pixel structures, where each pixel comprises + * a record of \p NUM_CHANNELS consecutive data samples (e.g., an RGBA pixel). + * - Of the \p NUM_CHANNELS specified, the function will only compute histograms + * for the first \p NUM_ACTIVE_CHANNELS (e.g., only RGB histograms from RGBA + * pixel samples). + * - The number of histogram bins for channeli is num_levels[i] - 1. + * - For channeli, the range of values for all histogram bins + * have the same width: (upper_level[i] - lower_level[i]) / ( num_levels[i] - 1) + * - \devicestorage + * - \cdp + * + * \par Snippet + * The code snippet below illustrates the computation of three 256-bin RGB histograms + * from a quad-channel sequence of RGBA pixels (8 bits per channel per pixel) + * + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input samples + * // and output histograms + * int num_pixels; // e.g., 5 + * unsigned char* d_samples; // e.g., [(2, 6, 7, 5), (3, 0, 2, 1), (7, 0, 6, 2), + * // (0, 6, 7, 5), (3, 0, 2, 6)] + * int* d_histogram[3]; // e.g., three device pointers to three device buffers, + * // each allocated with 256 integer counters + * int num_levels[3]; // e.g., {257, 257, 257}; + * unsigned int lower_level[3]; // e.g., {0, 0, 0}; + * unsigned int upper_level[3]; // e.g., {256, 256, 256}; + * ... + * + * // Determine temporary device storage requirements + * void* d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceHistogram::MultiHistogramEven<4, 3>(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, lower_level, upper_level, num_pixels); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Compute histograms + * cub::DeviceHistogram::MultiHistogramEven<4, 3>(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, lower_level, upper_level, num_pixels); + * + * // d_histogram <-- [ [1, 0, 1, 2, 0, 0, 0, 1, 0, 0, 0, ..., 0], + * // [0, 3, 0, 0, 0, 0, 2, 0, 0, 0, 0, ..., 0], + * // [0, 0, 2, 0, 0, 0, 1, 2, 0, 0, 0, ..., 0] ] + * + * \endcode + * + * \tparam NUM_CHANNELS Number of channels interleaved in the input data (may be greater than the number of channels being actively histogrammed) + * \tparam NUM_ACTIVE_CHANNELS [inferred] Number of channels actively being histogrammed + * \tparam SampleIteratorT [inferred] Random-access input iterator type for reading input samples. \iterator + * \tparam CounterT [inferred] Integer type for histogram bin counters + * \tparam LevelT [inferred] Type for specifying boundaries (levels) + * \tparam OffsetT [inferred] Signed integer type for sequence offsets, list lengths, pointer differences, etc. \offset_size1 + */ + template < + int NUM_CHANNELS, + int NUM_ACTIVE_CHANNELS, + typename SampleIteratorT, + typename CounterT, + typename LevelT, + typename OffsetT> + CUB_RUNTIME_FUNCTION + static cudaError_t MultiHistogramEven( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples). + CounterT* d_histogram[NUM_ACTIVE_CHANNELS], ///< [out] The pointers to the histogram counter output arrays, one for each active channel. For channeli, the allocation length of d_histogram[i] should be num_levels[i] - 1. + int num_levels[NUM_ACTIVE_CHANNELS], ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel. Implies that the number of bins for channeli is num_levels[i] - 1. + LevelT lower_level[NUM_ACTIVE_CHANNELS], ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel. + LevelT upper_level[NUM_ACTIVE_CHANNELS], ///< [in] The upper sample value bound (exclusive) for the highest histogram bin in each active channel. + OffsetT num_pixels, ///< [in] The number of multi-channel pixels (i.e., the length of \p d_samples / NUM_CHANNELS) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + /// The sample value type of the input iterator + typedef typename std::iterator_traits::value_type SampleT; + + return MultiHistogramEven( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_histogram, + num_levels, + lower_level, + upper_level, + num_pixels, + 1, + sizeof(SampleT) * NUM_CHANNELS * num_pixels, + stream, + debug_synchronous); + } + + + /** + * \brief Computes per-channel intensity histograms from a sequence of multi-channel "pixel" data samples using equal-width bins. + * + * \par + * - The input is a sequence of pixel structures, where each pixel comprises + * a record of \p NUM_CHANNELS consecutive data samples (e.g., an RGBA pixel). + * - Of the \p NUM_CHANNELS specified, the function will only compute histograms + * for the first \p NUM_ACTIVE_CHANNELS (e.g., only RGB histograms from RGBA + * pixel samples). + * - A two-dimensional region of interest within \p d_samples can be specified + * using the \p num_row_samples, num_rows, and \p row_stride_bytes parameters. + * - The row stride must be a whole multiple of the sample data type + * size, i.e., (row_stride_bytes % sizeof(SampleT)) == 0. + * - The number of histogram bins for channeli is num_levels[i] - 1. + * - For channeli, the range of values for all histogram bins + * have the same width: (upper_level[i] - lower_level[i]) / ( num_levels[i] - 1) + * - \devicestorage + * - \cdp + * + * \par Snippet + * The code snippet below illustrates the computation of three 256-bin RGB histograms from a 2x3 region of + * interest of within a flattened 2x4 array of quad-channel RGBA pixels (8 bits per channel per pixel). + * + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input samples + * // and output histograms + * int num_row_pixels; // e.g., 3 + * int num_rows; // e.g., 2 + * size_t row_stride_bytes; // e.g., 4 * sizeof(unsigned char) * NUM_CHANNELS + * unsigned char* d_samples; // e.g., [(2, 6, 7, 5), (3, 0, 2, 1), (7, 0, 6, 2), (-, -, -, -), + * // (0, 6, 7, 5), (3, 0, 2, 6), (1, 1, 1, 1), (-, -, -, -)] + * int* d_histogram[3]; // e.g., three device pointers to three device buffers, + * // each allocated with 256 integer counters + * int num_levels[3]; // e.g., {257, 257, 257}; + * unsigned int lower_level[3]; // e.g., {0, 0, 0}; + * unsigned int upper_level[3]; // e.g., {256, 256, 256}; + * ... + * + * // Determine temporary device storage requirements + * void* d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceHistogram::MultiHistogramEven<4, 3>(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, lower_level, upper_level, + * num_row_pixels, num_rows, row_stride_bytes); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Compute histograms + * cub::DeviceHistogram::MultiHistogramEven<4, 3>(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, lower_level, upper_level, + * num_row_pixels, num_rows, row_stride_bytes); + * + * // d_histogram <-- [ [1, 1, 1, 2, 0, 0, 0, 1, 0, 0, 0, ..., 0], + * // [0, 4, 0, 0, 0, 0, 2, 0, 0, 0, 0, ..., 0], + * // [0, 1, 2, 0, 0, 0, 1, 2, 0, 0, 0, ..., 0] ] + * + * \endcode + * + * \tparam NUM_CHANNELS Number of channels interleaved in the input data (may be greater than the number of channels being actively histogrammed) + * \tparam NUM_ACTIVE_CHANNELS [inferred] Number of channels actively being histogrammed + * \tparam SampleIteratorT [inferred] Random-access input iterator type for reading input samples. \iterator + * \tparam CounterT [inferred] Integer type for histogram bin counters + * \tparam LevelT [inferred] Type for specifying boundaries (levels) + * \tparam OffsetT [inferred] Signed integer type for sequence offsets, list lengths, pointer differences, etc. \offset_size1 + */ + template < + int NUM_CHANNELS, + int NUM_ACTIVE_CHANNELS, + typename SampleIteratorT, + typename CounterT, + typename LevelT, + typename OffsetT> + CUB_RUNTIME_FUNCTION + static cudaError_t MultiHistogramEven( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples). + CounterT* d_histogram[NUM_ACTIVE_CHANNELS], ///< [out] The pointers to the histogram counter output arrays, one for each active channel. For channeli, the allocation length of d_histogram[i] should be num_levels[i] - 1. + int num_levels[NUM_ACTIVE_CHANNELS], ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel. Implies that the number of bins for channeli is num_levels[i] - 1. + LevelT lower_level[NUM_ACTIVE_CHANNELS], ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel. + LevelT upper_level[NUM_ACTIVE_CHANNELS], ///< [in] The upper sample value bound (exclusive) for the highest histogram bin in each active channel. + OffsetT num_row_pixels, ///< [in] The number of multi-channel pixels per row in the region of interest + OffsetT num_rows, ///< [in] The number of rows in the region of interest + size_t row_stride_bytes, ///< [in] The number of bytes between starts of consecutive rows in the region of interest + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + /// The sample value type of the input iterator + typedef typename std::iterator_traits::value_type SampleT; + Int2Type is_byte_sample; + + if ((sizeof(OffsetT) > sizeof(int)) && (row_stride_bytes * num_rows < std::numeric_limits::max())) + { + // Down-convert OffsetT data type + + + return DipatchHistogram::DispatchEven( + d_temp_storage, temp_storage_bytes, d_samples, d_histogram, num_levels, lower_level, upper_level, + (int) num_row_pixels, (int) num_rows, (int) (row_stride_bytes / sizeof(SampleT)), + stream, debug_synchronous, is_byte_sample); + } + + return DipatchHistogram::DispatchEven( + d_temp_storage, temp_storage_bytes, d_samples, d_histogram, num_levels, lower_level, upper_level, + num_row_pixels, num_rows, (OffsetT) (row_stride_bytes / sizeof(SampleT)), + stream, debug_synchronous, is_byte_sample); + } + + + //@} end member group + /******************************************************************//** + * \name Custom bin ranges + *********************************************************************/ + //@{ + + /** + * \brief Computes an intensity histogram from a sequence of data samples using the specified bin boundary levels. + * + * \par + * - The number of histogram bins is (\p num_levels - 1) + * - The value range for bini is [level[i], level[i+1]) + * - \devicestorage + * - \cdp + * + * \par Snippet + * The code snippet below illustrates the computation of an six-bin histogram + * from a sequence of float samples + * + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input samples and + * // output histogram + * int num_samples; // e.g., 10 + * float* d_samples; // e.g., [2.2, 6.0, 7.1, 2.9, 3.5, 0.3, 2.9, 2.0, 6.1, 999.5] + * int* d_histogram; // e.g., [ -, -, -, -, -, -, -, -] + * int num_levels // e.g., 7 (seven level boundaries for six bins) + * float* d_levels; // e.g., [0.0, 2.0, 4.0, 6.0, 8.0, 12.0, 16.0] + * ... + * + * // Determine temporary device storage requirements + * void* d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceHistogram::HistogramRange(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, d_levels, num_samples); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Compute histograms + * cub::DeviceHistogram::HistogramRange(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, d_levels, num_samples); + * + * // d_histogram <-- [1, 0, 5, 0, 3, 0, 0, 0]; + * + * \endcode + * + * \tparam SampleIteratorT [inferred] Random-access input iterator type for reading input samples. \iterator + * \tparam CounterT [inferred] Integer type for histogram bin counters + * \tparam LevelT [inferred] Type for specifying boundaries (levels) + * \tparam OffsetT [inferred] Signed integer type for sequence offsets, list lengths, pointer differences, etc. \offset_size1 + */ + template < + typename SampleIteratorT, + typename CounterT, + typename LevelT, + typename OffsetT> + CUB_RUNTIME_FUNCTION + static cudaError_t HistogramRange( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the input sequence of data samples. + CounterT* d_histogram, ///< [out] The pointer to the histogram counter output array of length num_levels - 1. + int num_levels, ///< [in] The number of boundaries (levels) for delineating histogram samples. Implies that the number of bins is num_levels - 1. + LevelT* d_levels, ///< [in] The pointer to the array of boundaries (levels). Bin ranges are defined by consecutive boundary pairings: lower sample value boundaries are inclusive and upper sample value boundaries are exclusive. + OffsetT num_samples, ///< [in] The number of data samples per row in the region of interest + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + /// The sample value type of the input iterator + typedef typename std::iterator_traits::value_type SampleT; + + CounterT* d_histogram1[1] = {d_histogram}; + int num_levels1[1] = {num_levels}; + LevelT* d_levels1[1] = {d_levels}; + + return MultiHistogramRange<1, 1>( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_histogram1, + num_levels1, + d_levels1, + num_samples, + 1, + sizeof(SampleT) * num_samples, + stream, + debug_synchronous); + } + + + /** + * \brief Computes an intensity histogram from a sequence of data samples using the specified bin boundary levels. + * + * \par + * - A two-dimensional region of interest within \p d_samples can be specified + * using the \p num_row_samples, num_rows, and \p row_stride_bytes parameters. + * - The row stride must be a whole multiple of the sample data type + * size, i.e., (row_stride_bytes % sizeof(SampleT)) == 0. + * - The number of histogram bins is (\p num_levels - 1) + * - The value range for bini is [level[i], level[i+1]) + * - \devicestorage + * - \cdp + * + * \par Snippet + * The code snippet below illustrates the computation of a six-bin histogram + * from a 2x5 region of interest within a flattened 2x7 array of float samples. + * + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input samples and + * // output histogram + * int num_row_samples; // e.g., 5 + * int num_rows; // e.g., 2; + * int row_stride_bytes; // e.g., 7 * sizeof(float) + * float* d_samples; // e.g., [2.2, 6.0, 7.1, 2.9, 3.5, -, -, + * // 0.3, 2.9, 2.0, 6.1, 999.5, -, -] + * int* d_histogram; // e.g., [ , , , , , , , ] + * int num_levels // e.g., 7 (seven level boundaries for six bins) + * float *d_levels; // e.g., [0.0, 2.0, 4.0, 6.0, 8.0, 12.0, 16.0] + * ... + * + * // Determine temporary device storage requirements + * void* d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceHistogram::HistogramRange(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, d_levels, + * num_row_samples, num_rows, row_stride_bytes); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Compute histograms + * cub::DeviceHistogram::HistogramRange(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, d_levels, + * num_row_samples, num_rows, row_stride_bytes); + * + * // d_histogram <-- [1, 0, 5, 0, 3, 0, 0, 0]; + * + * \endcode + * + * \tparam SampleIteratorT [inferred] Random-access input iterator type for reading input samples. \iterator + * \tparam CounterT [inferred] Integer type for histogram bin counters + * \tparam LevelT [inferred] Type for specifying boundaries (levels) + * \tparam OffsetT [inferred] Signed integer type for sequence offsets, list lengths, pointer differences, etc. \offset_size1 + */ + template < + typename SampleIteratorT, + typename CounterT, + typename LevelT, + typename OffsetT> + CUB_RUNTIME_FUNCTION + static cudaError_t HistogramRange( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the input sequence of data samples. + CounterT* d_histogram, ///< [out] The pointer to the histogram counter output array of length num_levels - 1. + int num_levels, ///< [in] The number of boundaries (levels) for delineating histogram samples. Implies that the number of bins is num_levels - 1. + LevelT* d_levels, ///< [in] The pointer to the array of boundaries (levels). Bin ranges are defined by consecutive boundary pairings: lower sample value boundaries are inclusive and upper sample value boundaries are exclusive. + OffsetT num_row_samples, ///< [in] The number of data samples per row in the region of interest + OffsetT num_rows, ///< [in] The number of rows in the region of interest + size_t row_stride_bytes, ///< [in] The number of bytes between starts of consecutive rows in the region of interest + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + CounterT* d_histogram1[1] = {d_histogram}; + int num_levels1[1] = {num_levels}; + LevelT* d_levels1[1] = {d_levels}; + + return MultiHistogramRange<1, 1>( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_histogram1, + num_levels1, + d_levels1, + num_row_samples, + num_rows, + row_stride_bytes, + stream, + debug_synchronous); + } + + /** + * \brief Computes per-channel intensity histograms from a sequence of multi-channel "pixel" data samples using the specified bin boundary levels. + * + * \par + * - The input is a sequence of pixel structures, where each pixel comprises + * a record of \p NUM_CHANNELS consecutive data samples (e.g., an RGBA pixel). + * - Of the \p NUM_CHANNELS specified, the function will only compute histograms + * for the first \p NUM_ACTIVE_CHANNELS (e.g., RGB histograms from RGBA + * pixel samples). + * - The number of histogram bins for channeli is num_levels[i] - 1. + * - For channeli, the range of values for all histogram bins + * have the same width: (upper_level[i] - lower_level[i]) / ( num_levels[i] - 1) + * - \devicestorage + * - \cdp + * + * \par Snippet + * The code snippet below illustrates the computation of three 4-bin RGB histograms + * from a quad-channel sequence of RGBA pixels (8 bits per channel per pixel) + * + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input samples + * // and output histograms + * int num_pixels; // e.g., 5 + * unsigned char *d_samples; // e.g., [(2, 6, 7, 5),(3, 0, 2, 1),(7, 0, 6, 2), + * // (0, 6, 7, 5),(3, 0, 2, 6)] + * unsigned int *d_histogram[3]; // e.g., [[ -, -, -, -],[ -, -, -, -],[ -, -, -, -]]; + * int num_levels[3]; // e.g., {5, 5, 5}; + * unsigned int *d_levels[3]; // e.g., [ [0, 2, 4, 6, 8], + * // [0, 2, 4, 6, 8], + * // [0, 2, 4, 6, 8] ]; + * ... + * + * // Determine temporary device storage requirements + * void* d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceHistogram::MultiHistogramRange<4, 3>(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, d_levels, num_pixels); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Compute histograms + * cub::DeviceHistogram::MultiHistogramRange<4, 3>(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, d_levels, num_pixels); + * + * // d_histogram <-- [ [1, 3, 0, 1], + * // [3, 0, 0, 2], + * // [0, 2, 0, 3] ] + * + * \endcode + * + * \tparam NUM_CHANNELS Number of channels interleaved in the input data (may be greater than the number of channels being actively histogrammed) + * \tparam NUM_ACTIVE_CHANNELS [inferred] Number of channels actively being histogrammed + * \tparam SampleIteratorT [inferred] Random-access input iterator type for reading input samples. \iterator + * \tparam CounterT [inferred] Integer type for histogram bin counters + * \tparam LevelT [inferred] Type for specifying boundaries (levels) + * \tparam OffsetT [inferred] Signed integer type for sequence offsets, list lengths, pointer differences, etc. \offset_size1 + */ + template < + int NUM_CHANNELS, + int NUM_ACTIVE_CHANNELS, + typename SampleIteratorT, + typename CounterT, + typename LevelT, + typename OffsetT> + CUB_RUNTIME_FUNCTION + static cudaError_t MultiHistogramRange( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples). + CounterT* d_histogram[NUM_ACTIVE_CHANNELS], ///< [out] The pointers to the histogram counter output arrays, one for each active channel. For channeli, the allocation length of d_histogram[i] should be num_levels[i] - 1. + int num_levels[NUM_ACTIVE_CHANNELS], ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel. Implies that the number of bins for channeli is num_levels[i] - 1. + LevelT* d_levels[NUM_ACTIVE_CHANNELS], ///< [in] The pointers to the arrays of boundaries (levels), one for each active channel. Bin ranges are defined by consecutive boundary pairings: lower sample value boundaries are inclusive and upper sample value boundaries are exclusive. + OffsetT num_pixels, ///< [in] The number of multi-channel pixels (i.e., the length of \p d_samples / NUM_CHANNELS) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + /// The sample value type of the input iterator + typedef typename std::iterator_traits::value_type SampleT; + + return MultiHistogramRange( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_histogram, + num_levels, + d_levels, + num_pixels, + 1, + sizeof(SampleT) * NUM_CHANNELS * num_pixels, + stream, + debug_synchronous); + } + + + /** + * \brief Computes per-channel intensity histograms from a sequence of multi-channel "pixel" data samples using the specified bin boundary levels. + * + * \par + * - The input is a sequence of pixel structures, where each pixel comprises + * a record of \p NUM_CHANNELS consecutive data samples (e.g., an RGBA pixel). + * - Of the \p NUM_CHANNELS specified, the function will only compute histograms + * for the first \p NUM_ACTIVE_CHANNELS (e.g., RGB histograms from RGBA + * pixel samples). + * - A two-dimensional region of interest within \p d_samples can be specified + * using the \p num_row_samples, num_rows, and \p row_stride_bytes parameters. + * - The row stride must be a whole multiple of the sample data type + * size, i.e., (row_stride_bytes % sizeof(SampleT)) == 0. + * - The number of histogram bins for channeli is num_levels[i] - 1. + * - For channeli, the range of values for all histogram bins + * have the same width: (upper_level[i] - lower_level[i]) / ( num_levels[i] - 1) + * - \devicestorage + * - \cdp + * + * \par Snippet + * The code snippet below illustrates the computation of three 4-bin RGB histograms from a 2x3 region of + * interest of within a flattened 2x4 array of quad-channel RGBA pixels (8 bits per channel per pixel). + * + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input samples + * // and output histograms + * int num_row_pixels; // e.g., 3 + * int num_rows; // e.g., 2 + * size_t row_stride_bytes; // e.g., 4 * sizeof(unsigned char) * NUM_CHANNELS + * unsigned char* d_samples; // e.g., [(2, 6, 7, 5),(3, 0, 2, 1),(1, 1, 1, 1),(-, -, -, -), + * // (7, 0, 6, 2),(0, 6, 7, 5),(3, 0, 2, 6),(-, -, -, -)] + * int* d_histogram[3]; // e.g., [[ -, -, -, -],[ -, -, -, -],[ -, -, -, -]]; + * int num_levels[3]; // e.g., {5, 5, 5}; + * unsigned int* d_levels[3]; // e.g., [ [0, 2, 4, 6, 8], + * // [0, 2, 4, 6, 8], + * // [0, 2, 4, 6, 8] ]; + * ... + * + * // Determine temporary device storage requirements + * void* d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceHistogram::MultiHistogramRange<4, 3>(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, d_levels, num_row_pixels, num_rows, row_stride_bytes); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Compute histograms + * cub::DeviceHistogram::MultiHistogramRange<4, 3>(d_temp_storage, temp_storage_bytes, + * d_samples, d_histogram, num_levels, d_levels, num_row_pixels, num_rows, row_stride_bytes); + * + * // d_histogram <-- [ [2, 3, 0, 1], + * // [3, 0, 0, 2], + * // [1, 2, 0, 3] ] + * + * \endcode + * + * \tparam NUM_CHANNELS Number of channels interleaved in the input data (may be greater than the number of channels being actively histogrammed) + * \tparam NUM_ACTIVE_CHANNELS [inferred] Number of channels actively being histogrammed + * \tparam SampleIteratorT [inferred] Random-access input iterator type for reading input samples. \iterator + * \tparam CounterT [inferred] Integer type for histogram bin counters + * \tparam LevelT [inferred] Type for specifying boundaries (levels) + * \tparam OffsetT [inferred] Signed integer type for sequence offsets, list lengths, pointer differences, etc. \offset_size1 + */ + template < + int NUM_CHANNELS, + int NUM_ACTIVE_CHANNELS, + typename SampleIteratorT, + typename CounterT, + typename LevelT, + typename OffsetT> + CUB_RUNTIME_FUNCTION + static cudaError_t MultiHistogramRange( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples). + CounterT* d_histogram[NUM_ACTIVE_CHANNELS], ///< [out] The pointers to the histogram counter output arrays, one for each active channel. For channeli, the allocation length of d_histogram[i] should be num_levels[i] - 1. + int num_levels[NUM_ACTIVE_CHANNELS], ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel. Implies that the number of bins for channeli is num_levels[i] - 1. + LevelT* d_levels[NUM_ACTIVE_CHANNELS], ///< [in] The pointers to the arrays of boundaries (levels), one for each active channel. Bin ranges are defined by consecutive boundary pairings: lower sample value boundaries are inclusive and upper sample value boundaries are exclusive. + OffsetT num_row_pixels, ///< [in] The number of multi-channel pixels per row in the region of interest + OffsetT num_rows, ///< [in] The number of rows in the region of interest + size_t row_stride_bytes, ///< [in] The number of bytes between starts of consecutive rows in the region of interest + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + /// The sample value type of the input iterator + typedef typename std::iterator_traits::value_type SampleT; + Int2Type is_byte_sample; + + if ((sizeof(OffsetT) > sizeof(int)) && (row_stride_bytes * num_rows < std::numeric_limits::max())) + { + // Down-convert OffsetT data type + return DipatchHistogram::DispatchRange( + d_temp_storage, temp_storage_bytes, d_samples, d_histogram, num_levels, d_levels, + (int) num_row_pixels, (int) num_rows, (int) (row_stride_bytes / sizeof(SampleT)), + stream, debug_synchronous, is_byte_sample); + } + + return DipatchHistogram::DispatchRange( + d_temp_storage, temp_storage_bytes, d_samples, d_histogram, num_levels, d_levels, + num_row_pixels, num_rows, (OffsetT) (row_stride_bytes / sizeof(SampleT)), + stream, debug_synchronous, is_byte_sample); + } + + + + //@} end member group +}; + +/** + * \example example_device_histogram.cu + */ + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/device_partition.cuh b/3rdparty/cub/cub/device/device_partition.cuh new file mode 100644 index 00000000000..0e264fa2186 --- /dev/null +++ b/3rdparty/cub/cub/device/device_partition.cuh @@ -0,0 +1,275 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DevicePartition provides device-wide, parallel operations for partitioning sequences of data items residing within global memory. + */ + +#pragma once + +#include +#include + +#include "dispatch/dispatch_select_if.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief DevicePartition provides device-wide, parallel operations for partitioning sequences of data items residing within global memory. ![](partition_logo.png) + * \ingroup DeviceModule + * + * \par Overview + * These operations apply a selection criterion to construct a partitioned output sequence from items selected/unselected from + * a specified input sequence. + * + * \par Usage Considerations + * \cdp_class{DevicePartition} + * + * \par Performance + * \linear_performance{partition} + * + * \par + * The following chart illustrates DevicePartition::If + * performance across different CUDA architectures for \p int32 items, + * where 50% of the items are randomly selected for the first partition. + * \plots_below + * + * \image html partition_if_int32_50_percent.png + * + */ +struct DevicePartition +{ + /** + * \brief Uses the \p d_flags sequence to split the corresponding items from \p d_in into a partitioned sequence \p d_out. The total number of items copied into the first partition is written to \p d_num_selected_out. ![](partition_flags_logo.png) + * + * \par + * - The value type of \p d_flags must be castable to \p bool (e.g., \p bool, \p char, \p int, etc.). + * - Copies of the selected items are compacted into \p d_out and maintain their original + * relative ordering, however copies of the unselected items are compacted into the + * rear of \p d_out in reverse order. + * - \devicestorage + * - \cdp + * + * \par Snippet + * The code snippet below illustrates the compaction of items selected from an \p int device vector. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input, flags, and output + * int num_items; // e.g., 8 + * int *d_in; // e.g., [1, 2, 3, 4, 5, 6, 7, 8] + * char *d_flags; // e.g., [1, 0, 0, 1, 0, 1, 1, 0] + * int *d_out; // e.g., [ , , , , , , , ] + * int *d_num_selected_out; // e.g., [ ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DevicePartition::Flagged(d_temp_storage, temp_storage_bytes, d_in, d_flags, d_out, d_num_selected_out, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run selection + * cub::DevicePartition::Flagged(d_temp_storage, temp_storage_bytes, d_in, d_flags, d_out, d_num_selected_out, num_items); + * + * // d_out <-- [1, 4, 6, 7, 8, 5, 3, 2] + * // d_num_selected_out <-- [4] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items \iterator + * \tparam FlagIterator [inferred] Random-access input iterator type for reading selection flags \iterator + * \tparam OutputIteratorT [inferred] Random-access output iterator type for writing output items \iterator + * \tparam NumSelectedIteratorT [inferred] Output iterator type for recording the number of items selected \iterator + */ + template < + typename InputIteratorT, + typename FlagIterator, + typename OutputIteratorT, + typename NumSelectedIteratorT> + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Flagged( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + FlagIterator d_flags, ///< [in] Pointer to the input sequence of selection flags + OutputIteratorT d_out, ///< [out] Pointer to the output sequence of partitioned data items + NumSelectedIteratorT d_num_selected_out, ///< [out] Pointer to the output total number of items selected (i.e., the offset of the unselected partition) + int num_items, ///< [in] Total number of items to select from + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + typedef int OffsetT; // Signed integer type for global offsets + typedef NullType SelectOp; // Selection op (not used) + typedef NullType EqualityOp; // Equality operator (not used) + + return DispatchSelectIf::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_flags, + d_out, + d_num_selected_out, + SelectOp(), + EqualityOp(), + num_items, + stream, + debug_synchronous); + } + + + /** + * \brief Uses the \p select_op functor to split the corresponding items from \p d_in into a partitioned sequence \p d_out. The total number of items copied into the first partition is written to \p d_num_selected_out. ![](partition_logo.png) + * + * \par + * - Copies of the selected items are compacted into \p d_out and maintain their original + * relative ordering, however copies of the unselected items are compacted into the + * rear of \p d_out in reverse order. + * - \devicestorage + * - \cdp + * + * \par Performance + * The following charts illustrate saturated partition-if performance across different + * CUDA architectures for \p int32 and \p int64 items, respectively. Items are + * selected for the first partition with 50% probability. + * + * \image html partition_if_int32_50_percent.png + * \image html partition_if_int64_50_percent.png + * + * \par + * The following charts are similar, but 5% selection probability for the first partition: + * + * \image html partition_if_int32_5_percent.png + * \image html partition_if_int64_5_percent.png + * + * \par Snippet + * The code snippet below illustrates the compaction of items selected from an \p int device vector. + * \par + * \code + * #include // or equivalently + * + * // Functor type for selecting values less than some criteria + * struct LessThan + * { + * int compare; + * + * CUB_RUNTIME_FUNCTION __forceinline__ + * LessThan(int compare) : compare(compare) {} + * + * CUB_RUNTIME_FUNCTION __forceinline__ + * bool operator()(const int &a) const { + * return (a < compare); + * } + * }; + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 8 + * int *d_in; // e.g., [0, 2, 3, 9, 5, 2, 81, 8] + * int *d_out; // e.g., [ , , , , , , , ] + * int *d_num_selected_out; // e.g., [ ] + * LessThan select_op(7); + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceSelect::If(d_temp_storage, temp_storage_bytes, d_in, d_out, d_num_selected_out, num_items, select_op); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run selection + * cub::DeviceSelect::If(d_temp_storage, temp_storage_bytes, d_in, d_out, d_num_selected_out, num_items, select_op); + * + * // d_out <-- [0, 2, 3, 5, 2, 8, 81, 9] + * // d_num_selected_out <-- [5] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items \iterator + * \tparam OutputIteratorT [inferred] Random-access output iterator type for writing output items \iterator + * \tparam NumSelectedIteratorT [inferred] Output iterator type for recording the number of items selected \iterator + * \tparam SelectOp [inferred] Selection functor type having member bool operator()(const T &a) + */ + template < + typename InputIteratorT, + typename OutputIteratorT, + typename NumSelectedIteratorT, + typename SelectOp> + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t If( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output sequence of partitioned data items + NumSelectedIteratorT d_num_selected_out, ///< [out] Pointer to the output total number of items selected (i.e., the offset of the unselected partition) + int num_items, ///< [in] Total number of items to select from + SelectOp select_op, ///< [in] Unary selection operator + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + typedef int OffsetT; // Signed integer type for global offsets + typedef NullType* FlagIterator; // FlagT iterator type (not used) + typedef NullType EqualityOp; // Equality operator (not used) + + return DispatchSelectIf::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + NULL, + d_out, + d_num_selected_out, + select_op, + EqualityOp(), + num_items, + stream, + debug_synchronous); + } + +}; + +/** + * \example example_device_partition_flagged.cu + * \example example_device_partition_if.cu + */ + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/device_radix_sort.cuh b/3rdparty/cub/cub/device/device_radix_sort.cuh new file mode 100644 index 00000000000..1103a609415 --- /dev/null +++ b/3rdparty/cub/cub/device/device_radix_sort.cuh @@ -0,0 +1,795 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceRadixSort provides device-wide, parallel operations for computing a radix sort across a sequence of data items residing within global memory. + */ + +#pragma once + +#include +#include + +#include "dispatch/dispatch_radix_sort.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief DeviceRadixSort provides device-wide, parallel operations for computing a radix sort across a sequence of data items residing within global memory. ![](sorting_logo.png) + * \ingroup DeviceModule + * + * \par Overview + * The [radix sorting method](http://en.wikipedia.org/wiki/Radix_sort) arranges + * items into ascending order. (~2N auxiliary storage required) It relies upon a positional representation for + * keys, i.e., each key is comprised of an ordered sequence of symbols (e.g., digits, + * characters, etc.) specified from least-significant to most-significant. For a + * given input sequence of keys and a set of rules specifying a total ordering + * of the symbolic alphabet, the radix sorting method produces a lexicographic + * ordering of those keys. + * + * \par + * DeviceRadixSort can sort all of the built-in C++ numeric primitive types, e.g.: + * unsigned char, \p int, \p double, etc. Although the direct radix sorting + * method can only be applied to unsigned integral types, DeviceRadixSort + * is able to sort signed and floating-point types via simple bit-wise transformations + * that ensure lexicographic key ordering. + * + * \par Usage Considerations + * \cdp_class{DeviceRadixSort} + * + * \par Performance + * \linear_performance{radix sort} The following chart illustrates DeviceRadixSort::SortKeys + * performance across different CUDA architectures for uniform-random \p uint32 keys. + * \plots_below + * + * \image html lsb_radix_sort_int32_keys.png + * + */ +struct DeviceRadixSort +{ + + /******************************************************************//** + * \name Key-value pairs + *********************************************************************/ + //@{ + + /** + * \brief Sorts key-value pairs into ascending order. (~2N auxiliary storage required) + * + * \par + * - The contents of the input data are not altered by the sorting operation + * - An optional bit subrange [begin_bit, end_bit) of differentiating key bits can be specified. This can reduce overall sorting overhead and yield a corresponding performance improvement. + * - \devicestorageNP For sorting using only O(P) temporary storage, see the sorting interface using DoubleBuffer wrappers below. + * - \devicestorage + * - \cdp + * + * \par Performance + * The following charts illustrate saturated sorting performance across different + * CUDA architectures for uniform-random uint32,uint32 and + * uint64,uint64 pairs, respectively. + * + * \image html lsb_radix_sort_int32_pairs.png + * \image html lsb_radix_sort_int64_pairs.png + * + * \par Snippet + * The code snippet below illustrates the sorting of a device vector of \p int keys + * with associated vector of \p int values. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for sorting data + * int num_items; // e.g., 7 + * int *d_keys_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_keys_out; // e.g., [ ... ] + * int *d_values_in; // e.g., [0, 1, 2, 3, 4, 5, 6] + * int *d_values_out; // e.g., [ ... ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceRadixSort::SortPairs(d_temp_storage, temp_storage_bytes, + * d_keys_in, d_keys_out, d_values_in, d_values_out, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run sorting operation + * cub::DeviceRadixSort::SortPairs(d_temp_storage, temp_storage_bytes, + * d_keys_in, d_keys_out, d_values_in, d_values_out, num_items); + * + * // d_keys_out <-- [0, 3, 5, 6, 7, 8, 9] + * // d_values_out <-- [5, 4, 3, 1, 2, 0, 6] + * + * \endcode + * + * \tparam Key [inferred] Key type + * \tparam Value [inferred] Value type + */ + template < + typename Key, + typename Value> + CUB_RUNTIME_FUNCTION + static cudaError_t SortPairs( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + Key *d_keys_in, ///< [in] Pointer to the input data of key data to sort + Key *d_keys_out, ///< [out] Pointer to the sorted output sequence of key data + Value *d_values_in, ///< [in] Pointer to the corresponding input sequence of associated value items + Value *d_values_out, ///< [out] Pointer to the correspondingly-reordered output sequence of associated value items + int num_items, ///< [in] Number of items to reduce + int begin_bit = 0, ///< [in] [optional] The least-significant bit index (inclusive) needed for key comparison + int end_bit = sizeof(Key) * 8, ///< [in] [optional] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + DoubleBuffer d_keys(d_keys_in, d_keys_out); + DoubleBuffer d_values(d_values_in, d_values_out); + + return DispatchRadixSort::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_keys, + d_values, + num_items, + begin_bit, + end_bit, + stream, + debug_synchronous); + } + + + /** + * \brief Sorts key-value pairs into ascending order. (~N auxiliary storage required) + * + * \par + * - The sorting operation is given a pair of key buffers and a corresponding + * pair of associated value buffers. Each pair is managed by a DoubleBuffer + * structure that indicates which of the two buffers is "current" (and thus + * contains the input data to be sorted). + * - The contents of both buffers within each pair may be altered by the sorting + * operation. + * - Upon completion, the sorting operation will update the "current" indicator + * within each DoubleBuffer wrapper to reference which of the two buffers + * now contains the sorted output sequence (a function of the number of key bits + * specified and the targeted device architecture). + * - An optional bit subrange [begin_bit, end_bit) of differentiating key bits can be specified. This can reduce overall sorting overhead and yield a corresponding performance improvement. + * - \devicestorageP + * - \devicestorage + * - \cdp + * + * \par Performance + * The following charts illustrate saturated sorting performance across different + * CUDA architectures for uniform-random uint32,uint32 and + * uint64,uint64 pairs, respectively. + * + * \image html lsb_radix_sort_int32_pairs.png + * \image html lsb_radix_sort_int64_pairs.png + * + * \par Snippet + * The code snippet below illustrates the sorting of a device vector of \p int keys + * with associated vector of \p int values. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for sorting data + * int num_items; // e.g., 7 + * int *d_key_buf; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_key_alt_buf; // e.g., [ ... ] + * int *d_value_buf; // e.g., [0, 1, 2, 3, 4, 5, 6] + * int *d_value_alt_buf; // e.g., [ ... ] + * ... + * + * // Create a set of DoubleBuffers to wrap pairs of device pointers + * cub::DoubleBuffer d_keys(d_key_buf, d_key_alt_buf); + * cub::DoubleBuffer d_values(d_value_buf, d_value_alt_buf); + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceRadixSort::SortPairs(d_temp_storage, temp_storage_bytes, d_keys, d_values, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run sorting operation + * cub::DeviceRadixSort::SortPairs(d_temp_storage, temp_storage_bytes, d_keys, d_values, num_items); + * + * // d_keys.Current() <-- [0, 3, 5, 6, 7, 8, 9] + * // d_values.Current() <-- [5, 4, 3, 1, 2, 0, 6] + * + * \endcode + * + * \tparam Key [inferred] Key type + * \tparam Value [inferred] Value type + */ + template < + typename Key, + typename Value> + CUB_RUNTIME_FUNCTION + static cudaError_t SortPairs( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + DoubleBuffer &d_keys, ///< [in,out] Reference to the double-buffer of keys whose "current" buffer contains the unsorted input keys and, upon return, is updated to point to the sorted output keys + DoubleBuffer &d_values, ///< [in,out] Double-buffer of values whose "current" buffer contains the unsorted input values and, upon return, is updated to point to the sorted output values + int num_items, ///< [in] Number of items to reduce + int begin_bit = 0, ///< [in] [optional] The least-significant bit index (inclusive) needed for key comparison + int end_bit = sizeof(Key) * 8, ///< [in] [optional] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + return DispatchRadixSort::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_keys, + d_values, + num_items, + begin_bit, + end_bit, + stream, + debug_synchronous); + } + + + /** + * \brief Sorts key-value pairs into descending order. (~2N auxiliary storage required). + * + * \par + * - The contents of the input data are not altered by the sorting operation + * - An optional bit subrange [begin_bit, end_bit) of differentiating key bits can be specified. This can reduce overall sorting overhead and yield a corresponding performance improvement. + * - \devicestorageNP For sorting using only O(P) temporary storage, see the sorting interface using DoubleBuffer wrappers below. + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is similar to DeviceRadixSort::SortPairs. + * + * \par Snippet + * The code snippet below illustrates the sorting of a device vector of \p int keys + * with associated vector of \p int values. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for sorting data + * int num_items; // e.g., 7 + * int *d_keys_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_keys_out; // e.g., [ ... ] + * int *d_values_in; // e.g., [0, 1, 2, 3, 4, 5, 6] + * int *d_values_out; // e.g., [ ... ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceRadixSort::SortPairsDescending(d_temp_storage, temp_storage_bytes, + * d_keys_in, d_keys_out, d_values_in, d_values_out, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run sorting operation + * cub::DeviceRadixSort::SortPairsDescending(d_temp_storage, temp_storage_bytes, + * d_keys_in, d_keys_out, d_values_in, d_values_out, num_items); + * + * // d_keys_out <-- [9, 8, 7, 6, 5, 3, 0] + * // d_values_out <-- [6, 0, 2, 1, 3, 4, 5] + * + * \endcode + * + * \tparam Key [inferred] Key type + * \tparam Value [inferred] Value type + */ + template < + typename Key, + typename Value> + CUB_RUNTIME_FUNCTION + static cudaError_t SortPairsDescending( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + Key *d_keys_in, ///< [in] Pointer to the input data of key data to sort + Key *d_keys_out, ///< [out] Pointer to the sorted output sequence of key data + Value *d_values_in, ///< [in] Pointer to the corresponding input sequence of associated value items + Value *d_values_out, ///< [out] Pointer to the correspondingly-reordered output sequence of associated value items + int num_items, ///< [in] Number of items to reduce + int begin_bit = 0, ///< [in] [optional] The least-significant bit index (inclusive) needed for key comparison + int end_bit = sizeof(Key) * 8, ///< [in] [optional] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + DoubleBuffer d_keys(d_keys_in, d_keys_out); + DoubleBuffer d_values(d_values_in, d_values_out); + + return DispatchRadixSort::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_keys, + d_values, + num_items, + begin_bit, + end_bit, + stream, + debug_synchronous); + } + + + /** + * \brief Sorts key-value pairs into descending order. (~N auxiliary storage required). + * + * \par + * - The sorting operation is given a pair of key buffers and a corresponding + * pair of associated value buffers. Each pair is managed by a DoubleBuffer + * structure that indicates which of the two buffers is "current" (and thus + * contains the input data to be sorted). + * - The contents of both buffers within each pair may be altered by the sorting + * operation. + * - Upon completion, the sorting operation will update the "current" indicator + * within each DoubleBuffer wrapper to reference which of the two buffers + * now contains the sorted output sequence (a function of the number of key bits + * specified and the targeted device architecture). + * - An optional bit subrange [begin_bit, end_bit) of differentiating key bits can be specified. This can reduce overall sorting overhead and yield a corresponding performance improvement. + * - \devicestorageP + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is similar to DeviceRadixSort::SortPairs. + * + * \par Snippet + * The code snippet below illustrates the sorting of a device vector of \p int keys + * with associated vector of \p int values. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for sorting data + * int num_items; // e.g., 7 + * int *d_key_buf; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_key_alt_buf; // e.g., [ ... ] + * int *d_value_buf; // e.g., [0, 1, 2, 3, 4, 5, 6] + * int *d_value_alt_buf; // e.g., [ ... ] + * ... + * + * // Create a set of DoubleBuffers to wrap pairs of device pointers + * cub::DoubleBuffer d_keys(d_key_buf, d_key_alt_buf); + * cub::DoubleBuffer d_values(d_value_buf, d_value_alt_buf); + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceRadixSort::SortPairsDescending(d_temp_storage, temp_storage_bytes, d_keys, d_values, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run sorting operation + * cub::DeviceRadixSort::SortPairsDescending(d_temp_storage, temp_storage_bytes, d_keys, d_values, num_items); + * + * // d_keys.Current() <-- [9, 8, 7, 6, 5, 3, 0] + * // d_values.Current() <-- [6, 0, 2, 1, 3, 4, 5] + * + * \endcode + * + * \tparam Key [inferred] Key type + * \tparam Value [inferred] Value type + */ + template < + typename Key, + typename Value> + CUB_RUNTIME_FUNCTION + static cudaError_t SortPairsDescending( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + DoubleBuffer &d_keys, ///< [in,out] Reference to the double-buffer of keys whose "current" buffer contains the unsorted input keys and, upon return, is updated to point to the sorted output keys + DoubleBuffer &d_values, ///< [in,out] Double-buffer of values whose "current" buffer contains the unsorted input values and, upon return, is updated to point to the sorted output values + int num_items, ///< [in] Number of items to reduce + int begin_bit = 0, ///< [in] [optional] The least-significant bit index (inclusive) needed for key comparison + int end_bit = sizeof(Key) * 8, ///< [in] [optional] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + return DispatchRadixSort::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_keys, + d_values, + num_items, + begin_bit, + end_bit, + stream, + debug_synchronous); + } + + + //@} end member group + /******************************************************************//** + * \name Keys-only + *********************************************************************/ + //@{ + + + /** + * \brief Sorts keys into ascending order. (~2N auxiliary storage required) + * + * \par + * - The contents of the input data are not altered by the sorting operation + * - An optional bit subrange [begin_bit, end_bit) of differentiating key bits can be specified. This can reduce overall sorting overhead and yield a corresponding performance improvement. + * - \devicestorageNP For sorting using only O(P) temporary storage, see the sorting interface using DoubleBuffer wrappers below. + * - \devicestorage + * - \cdp + * + * \par Performance + * The following charts illustrate saturated sorting performance across different + * CUDA architectures for uniform-random \p uint32 and \p uint64 keys, respectively. + * + * \image html lsb_radix_sort_int32_keys.png + * \image html lsb_radix_sort_int64_keys.png + * + * \par Snippet + * The code snippet below illustrates the sorting of a device vector of \p int keys. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for sorting data + * int num_items; // e.g., 7 + * int *d_keys_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_keys_out; // e.g., [ ... ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceRadixSort::SortKeys(d_temp_storage, temp_storage_bytes, d_keys_in, d_keys_out, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run sorting operation + * cub::DeviceRadixSort::SortKeys(d_temp_storage, temp_storage_bytes, d_keys_in, d_keys_out, num_items); + * + * // d_keys_out <-- [0, 3, 5, 6, 7, 8, 9] + * + * \endcode + * + * \tparam Key [inferred] Key type + */ + template + CUB_RUNTIME_FUNCTION + static cudaError_t SortKeys( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + Key *d_keys_in, ///< [in] Pointer to the input data of key data to sort + Key *d_keys_out, ///< [out] Pointer to the sorted output sequence of key data + int num_items, ///< [in] Number of items to reduce + int begin_bit = 0, ///< [in] [optional] The least-significant bit index (inclusive) needed for key comparison + int end_bit = sizeof(Key) * 8, ///< [in] [optional] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + // Null value type + DoubleBuffer d_keys(d_keys_in, d_keys_out); + DoubleBuffer d_values; + + return DispatchRadixSort::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_keys, + d_values, + num_items, + begin_bit, + end_bit, + stream, + debug_synchronous); + } + + + /** + * \brief Sorts keys into ascending order. (~N auxiliary storage required). + * + * \par + * - The sorting operation is given a pair of key buffers managed by a + * DoubleBuffer structure that indicates which of the two buffers is + * "current" (and thus contains the input data to be sorted). + * - The contents of both buffers may be altered by the sorting operation. + * - Upon completion, the sorting operation will update the "current" indicator + * within the DoubleBuffer wrapper to reference which of the two buffers + * now contains the sorted output sequence (a function of the number of key bits + * specified and the targeted device architecture). + * - An optional bit subrange [begin_bit, end_bit) of differentiating key bits can be specified. This can reduce overall sorting overhead and yield a corresponding performance improvement. + * - \devicestorageP + * - \devicestorage + * - \cdp + * + * \par Performance + * The following charts illustrate saturated sorting performance across different + * CUDA architectures for uniform-random \p uint32 and \p uint64 keys, respectively. + * + * \image html lsb_radix_sort_int32_keys.png + * \image html lsb_radix_sort_int64_keys.png + * + * \par Snippet + * The code snippet below illustrates the sorting of a device vector of \p int keys. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for sorting data + * int num_items; // e.g., 7 + * int *d_key_buf; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_key_alt_buf; // e.g., [ ... ] + * ... + * + * // Create a DoubleBuffer to wrap the pair of device pointers + * cub::DoubleBuffer d_keys(d_key_buf, d_key_alt_buf); + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceRadixSort::SortKeys(d_temp_storage, temp_storage_bytes, d_keys, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run sorting operation + * cub::DeviceRadixSort::SortKeys(d_temp_storage, temp_storage_bytes, d_keys, num_items); + * + * // d_keys.Current() <-- [0, 3, 5, 6, 7, 8, 9] + * + * \endcode + * + * \tparam Key [inferred] Key type + */ + template + CUB_RUNTIME_FUNCTION + static cudaError_t SortKeys( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + DoubleBuffer &d_keys, ///< [in,out] Reference to the double-buffer of keys whose "current" buffer contains the unsorted input keys and, upon return, is updated to point to the sorted output keys + int num_items, ///< [in] Number of items to reduce + int begin_bit = 0, ///< [in] [optional] The least-significant bit index (inclusive) needed for key comparison + int end_bit = sizeof(Key) * 8, ///< [in] [optional] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + // Null value type + DoubleBuffer d_values; + + return DispatchRadixSort::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_keys, + d_values, + num_items, + begin_bit, + end_bit, + stream, + debug_synchronous); + } + + /** + * \brief Sorts keys into descending order. (~2N auxiliary storage required). + * + * \par + * - The contents of the input data are not altered by the sorting operation + * - An optional bit subrange [begin_bit, end_bit) of differentiating key bits can be specified. This can reduce overall sorting overhead and yield a corresponding performance improvement. + * - \devicestorageNP For sorting using only O(P) temporary storage, see the sorting interface using DoubleBuffer wrappers below. + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is similar to DeviceRadixSort::SortKeys. + * + * \par Snippet + * The code snippet below illustrates the sorting of a device vector of \p int keys. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for sorting data + * int num_items; // e.g., 7 + * int *d_keys_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_keys_out; // e.g., [ ... ] + * ... + * + * // Create a DoubleBuffer to wrap the pair of device pointers + * cub::DoubleBuffer d_keys(d_key_buf, d_key_alt_buf); + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceRadixSort::SortKeysDescending(d_temp_storage, temp_storage_bytes, d_keys_in, d_keys_out, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run sorting operation + * cub::DeviceRadixSort::SortKeysDescending(d_temp_storage, temp_storage_bytes, d_keys_in, d_keys_out, num_items); + * + * // d_keys_out <-- [9, 8, 7, 6, 5, 3, 0]s + * + * \endcode + * + * \tparam Key [inferred] Key type + */ + template + CUB_RUNTIME_FUNCTION + static cudaError_t SortKeysDescending( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + Key *d_keys_in, ///< [in] Pointer to the input data of key data to sort + Key *d_keys_out, ///< [out] Pointer to the sorted output sequence of key data + int num_items, ///< [in] Number of items to reduce + int begin_bit = 0, ///< [in] [optional] The least-significant bit index (inclusive) needed for key comparison + int end_bit = sizeof(Key) * 8, ///< [in] [optional] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + DoubleBuffer d_keys(d_keys_in, d_keys_out); + DoubleBuffer d_values; + + return DispatchRadixSort::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_keys, + d_values, + num_items, + begin_bit, + end_bit, + stream, + debug_synchronous); + } + + + /** + * \brief Sorts keys into descending order. (~N auxiliary storage required). + * + * \par + * - The sorting operation is given a pair of key buffers managed by a + * DoubleBuffer structure that indicates which of the two buffers is + * "current" (and thus contains the input data to be sorted). + * - The contents of both buffers may be altered by the sorting operation. + * - Upon completion, the sorting operation will update the "current" indicator + * within the DoubleBuffer wrapper to reference which of the two buffers + * now contains the sorted output sequence (a function of the number of key bits + * specified and the targeted device architecture). + * - An optional bit subrange [begin_bit, end_bit) of differentiating key bits can be specified. This can reduce overall sorting overhead and yield a corresponding performance improvement. + * - \devicestorageP + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is similar to DeviceRadixSort::SortKeys. + * + * \par Snippet + * The code snippet below illustrates the sorting of a device vector of \p int keys. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for sorting data + * int num_items; // e.g., 7 + * int *d_key_buf; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_key_alt_buf; // e.g., [ ... ] + * ... + * + * // Create a DoubleBuffer to wrap the pair of device pointers + * cub::DoubleBuffer d_keys(d_key_buf, d_key_alt_buf); + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceRadixSort::SortKeysDescending(d_temp_storage, temp_storage_bytes, d_keys, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run sorting operation + * cub::DeviceRadixSort::SortKeysDescending(d_temp_storage, temp_storage_bytes, d_keys, num_items); + * + * // d_keys.Current() <-- [9, 8, 7, 6, 5, 3, 0] + * + * \endcode + * + * \tparam Key [inferred] Key type + */ + template + CUB_RUNTIME_FUNCTION + static cudaError_t SortKeysDescending( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + DoubleBuffer &d_keys, ///< [in,out] Reference to the double-buffer of keys whose "current" buffer contains the unsorted input keys and, upon return, is updated to point to the sorted output keys + int num_items, ///< [in] Number of items to reduce + int begin_bit = 0, ///< [in] [optional] The least-significant bit index (inclusive) needed for key comparison + int end_bit = sizeof(Key) * 8, ///< [in] [optional] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + // Null value type + DoubleBuffer d_values; + + return DispatchRadixSort::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_keys, + d_values, + num_items, + begin_bit, + end_bit, + stream, + debug_synchronous); + } + + + //@} end member group + + +}; + +/** + * \example example_device_radix_sort.cu + */ + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/device_reduce.cuh b/3rdparty/cub/cub/device/device_reduce.cuh new file mode 100644 index 00000000000..2cdff015db8 --- /dev/null +++ b/3rdparty/cub/cub/device/device_reduce.cuh @@ -0,0 +1,684 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceReduce provides device-wide, parallel operations for computing a reduction across a sequence of data items residing within global memory. + */ + +#pragma once + +#include +#include + +#include "dispatch/dispatch_reduce.cuh" +#include "dispatch/dispatch_reduce_by_key.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief DeviceReduce provides device-wide, parallel operations for computing a reduction across a sequence of data items residing within global memory. ![](reduce_logo.png) + * \ingroup DeviceModule + * + * \par Overview + * A reduction (or fold) + * uses a binary combining operator to compute a single aggregate from a sequence of input elements. + * + * \par Usage Considerations + * \cdp_class{DeviceReduce} + * + * \par Performance + * \linear_performance{reduction, reduce-by-key, and run-length encode} + * + * \par + * The following chart illustrates DeviceReduce::Sum + * performance across different CUDA architectures for \p int32 keys. + * + * \image html reduce_int32.png + * + * \par + * The following chart illustrates DeviceReduce::ReduceByKey (summation) + * performance across different CUDA architectures for \p fp32 + * values. Segments are identified by \p int32 keys, and have lengths uniformly sampled from [1,1000]. + * + * \image html reduce_by_key_fp32_len_500.png + * + * \par + * \plots_below + * + */ +struct DeviceReduce +{ + /** + * \brief Computes a device-wide reduction using the specified binary \p reduction_op functor. + * + * \par + * - Does not support non-commutative reduction operators. + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is typically similar to DeviceReduce::Sum. + * + * \par Snippet + * The code snippet below illustrates a custom min reduction of a device vector of \p int items. + * \par + * \code + * #include // or equivalently + * + * // CustomMin functor + * struct CustomMin + * { + * template + * CUB_RUNTIME_FUNCTION __forceinline__ + * T operator()(const T &a, const T &b) const { + * return (b < a) ? b : a; + * } + * }; + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 7 + * int *d_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_out; // e.g., [ ] + * CustomMin min_op; + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceReduce::Reduce(d_temp_storage, temp_storage_bytes, d_in, d_out, num_items, min_op); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run reduction + * cub::DeviceReduce::Reduce(d_temp_storage, temp_storage_bytes, d_in, d_out, num_items, min_op); + * + * // d_out <-- [0] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items \iterator + * \tparam OutputIteratorT [inferred] Output iterator type for recording the reduced aggregate \iterator + * \tparam ReductionOp [inferred] Binary reduction functor type having member T operator()(const T &a, const T &b) (e.g., cub::Sum, cub::Min, cub::Max, etc.) + */ + template < + typename InputIteratorT, + typename OutputIteratorT, + typename ReductionOp> + CUB_RUNTIME_FUNCTION + static cudaError_t Reduce( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output aggregate + int num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + ReductionOp reduction_op, ///< [in] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + // Dispatch type + typedef DispatchReduce DispatchReduce; + + return DispatchReduce::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_out, + num_items, + reduction_op, + stream, + debug_synchronous); + } + + + /** + * \brief Computes a device-wide sum using the addition ('+') operator. + * + * \par + * - Does not support non-commutative reduction operators. + * - \devicestorage + * - \cdp + * + * \par Performance + * The following charts illustrate saturated reduction (sum) performance across different + * CUDA architectures for \p int32 and \p int64 items, respectively. + * + * \image html reduce_int32.png + * \image html reduce_int64.png + * + * \par Snippet + * The code snippet below illustrates the sum reduction of a device vector of \p int items. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 7 + * int *d_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_out; // e.g., [ ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceReduce::Sum(d_temp_storage, temp_storage_bytes, d_in, d_sum, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run sum-reduction + * cub::DeviceReduce::Sum(d_temp_storage, temp_storage_bytes, d_in, d_sum, num_items); + * + * // d_out <-- [38] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items \iterator + * \tparam OutputIteratorT [inferred] Output iterator type for recording the reduced aggregate \iterator + */ + template < + typename InputIteratorT, + typename OutputIteratorT> + CUB_RUNTIME_FUNCTION + static cudaError_t Sum( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output aggregate + int num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + // Dispatch type + typedef DispatchReduce DispatchReduce; + + return DispatchReduce::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_out, + num_items, + cub::Sum(), + stream, + debug_synchronous); + } + + + /** + * \brief Computes a device-wide minimum using the less-than ('<') operator. + * + * \par + * - Does not support non-commutative minimum operators. + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is typically similar to DeviceReduce::Sum. + * + * \par Snippet + * The code snippet below illustrates the min-reduction of a device vector of \p int items. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 7 + * int *d_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_out; // e.g., [ ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceReduce::Min(d_temp_storage, temp_storage_bytes, d_in, d_min, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run min-reduction + * cub::DeviceReduce::Min(d_temp_storage, temp_storage_bytes, d_in, d_min, num_items); + * + * // d_out <-- [0] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items \iterator + * \tparam OutputIteratorT [inferred] Output iterator type for recording the reduced aggregate \iterator + */ + template < + typename InputIteratorT, + typename OutputIteratorT> + CUB_RUNTIME_FUNCTION + static cudaError_t Min( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output aggregate + int num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + // Dispatch type + typedef DispatchReduce DispatchReduce; + + return DispatchReduce::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_out, + num_items, + cub::Min(), + stream, + debug_synchronous); + } + + + /** + * \brief Finds the first device-wide minimum using the less-than ('<') operator, also returning the index of that item. + * + * \par + * Assuming the input \p d_in has value type \p T, the output \p d_out must have value type + * KeyValuePair. The minimum value is written to d_out.value and its + * location in the input array is written to d_out.key. + * + * \par + * - Does not support non-commutative minimum operators. + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is typically similar to DeviceReduce::Sum. + * + * \par Snippet + * The code snippet below illustrates the argmin-reduction of a device vector of \p int items. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 7 + * int *d_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * KeyValuePair *d_out; // e.g., [{ , }] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceReduce::ArgMin(d_temp_storage, temp_storage_bytes, d_in, d_argmin, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run argmin-reduction + * cub::DeviceReduce::ArgMin(d_temp_storage, temp_storage_bytes, d_in, d_argmin, num_items); + * + * // d_out <-- [{0, 5}] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items (of some type \p T) \iterator + * \tparam OutputIteratorT [inferred] Output iterator type for recording the reduced aggregate (having value type KeyValuePair) \iterator + */ + template < + typename InputIteratorT, + typename OutputIteratorT> + CUB_RUNTIME_FUNCTION + static cudaError_t ArgMin( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output aggregate + int num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + // Wrapped input iterator + typedef ArgIndexInputIterator ArgIndexInputIteratorT; + ArgIndexInputIteratorT d_argmin_in(d_in, 0); + + // Dispatch type + typedef DispatchReduce DispatchReduce; + + return DispatchReduce::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_argmin_in, + d_out, + num_items, + cub::ArgMin(), + stream, + debug_synchronous); + } + + + /** + * \brief Computes a device-wide maximum using the greater-than ('>') operator. + * + * \par + * - Does not support non-commutative maximum operators. + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is typically similar to DeviceReduce::Sum. + * + * \par Snippet + * The code snippet below illustrates the max-reduction of a device vector of \p int items. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 7 + * int *d_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_out; // e.g., [ ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceReduce::Max(d_temp_storage, temp_storage_bytes, d_in, d_max, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run max-reduction + * cub::DeviceReduce::Max(d_temp_storage, temp_storage_bytes, d_in, d_max, num_items); + * + * // d_out <-- [9] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items \iterator + * \tparam OutputIteratorT [inferred] Output iterator type for recording the reduced aggregate \iterator + */ + template < + typename InputIteratorT, + typename OutputIteratorT> + CUB_RUNTIME_FUNCTION + static cudaError_t Max( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output aggregate + int num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + // Dispatch type + typedef DispatchReduce DispatchReduce; + + return DispatchReduce::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_out, + num_items, + cub::Max(), + stream, + debug_synchronous); + } + + + /** + * \brief Finds the first device-wide maximum using the greater-than ('>') operator, also returning the index of that item + * + * \par + * Assuming the input \p d_in has value type \p T, the output \p d_out must have value type + * KeyValuePair. The maximum value is written to d_out.value and its + * location in the input array is written to d_out.key. + * + * \par + * - Does not support non-commutative maximum operators. + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is typically similar to DeviceReduce::Sum. + * + * \par Snippet + * The code snippet below illustrates the argmax-reduction of a device vector of \p int items. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 7 + * int *d_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * KeyValuePair *d_out; // e.g., [{ , }] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceReduce::ArgMax(d_temp_storage, temp_storage_bytes, d_in, d_argmax, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run argmax-reduction + * cub::DeviceReduce::ArgMax(d_temp_storage, temp_storage_bytes, d_in, d_argmax, num_items); + * + * // d_out <-- [{9, 6}] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items (of some type \p T) \iterator + * \tparam OutputIteratorT [inferred] Output iterator type for recording the reduced aggregate (having value type KeyValuePair) \iterator + */ + template < + typename InputIteratorT, + typename OutputIteratorT> + CUB_RUNTIME_FUNCTION + static cudaError_t ArgMax( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output aggregate + int num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + // Wrapped input iterator + typedef ArgIndexInputIterator ArgIndexInputIteratorT; + ArgIndexInputIteratorT d_argmax_in(d_in, 0); + + // Dispatch type + typedef DispatchReduce DispatchReduce; + + return DispatchReduce::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_argmax_in, + d_out, + num_items, + cub::ArgMax(), + stream, + debug_synchronous); + } + + + /** + * \brief Reduces segments of values, where segments are demarcated by corresponding runs of identical keys. + * + * \par + * This operation computes segmented reductions within \p d_values_in using + * the specified binary \p reduction_op functor. The segments are identified by + * "runs" of corresponding keys in \p d_keys_in, where runs are maximal ranges of + * consecutive, identical keys. For the ith run encountered, + * the first key of the run and the corresponding value aggregate of that run are + * written to d_unique_out[i] and d_aggregates_out[i], + * respectively. The total number of runs encountered is written to \p d_num_runs_out. + * + * \par + * - The == equality operator is used to determine whether keys are equivalent + * - \devicestorage + * - \cdp + * + * \par Performance + * The following chart illustrates reduction-by-key (sum) performance across + * different CUDA architectures for \p fp32 and \p fp64 values, respectively. Segments + * are identified by \p int32 keys, and have lengths uniformly sampled from [1,1000]. + * + * \image html reduce_by_key_fp32_len_500.png + * \image html reduce_by_key_fp64_len_500.png + * + * \par + * The following charts are similar, but with segment lengths uniformly sampled from [1,10]: + * + * \image html reduce_by_key_fp32_len_5.png + * \image html reduce_by_key_fp64_len_5.png + * + * \par Snippet + * The code snippet below illustrates the segmented reduction of \p int values grouped + * by runs of associated \p int keys. + * \par + * \code + * #include // or equivalently + * + * // CustomMin functor + * struct CustomMin + * { + * template + * CUB_RUNTIME_FUNCTION __forceinline__ + * T operator()(const T &a, const T &b) const { + * return (b < a) ? b : a; + * } + * }; + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 8 + * int *d_keys_in; // e.g., [0, 2, 2, 9, 5, 5, 5, 8] + * int *d_values_in; // e.g., [0, 7, 1, 6, 2, 5, 3, 4] + * int *d_unique_out; // e.g., [ , , , , , , , ] + * int *d_aggregates_out; // e.g., [ , , , , , , , ] + * int *d_num_runs_out; // e.g., [ ] + * CustomMin reduction_op; + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceReduce::ReduceByKey(d_temp_storage, temp_storage_bytes, d_keys_in, d_unique_out, d_values_in, d_aggregates_out, d_num_runs_out, reduction_op, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run reduce-by-key + * cub::DeviceReduce::ReduceByKey(d_temp_storage, temp_storage_bytes, d_keys_in, d_unique_out, d_values_in, d_aggregates_out, d_num_runs_out, reduction_op, num_items); + * + * // d_unique_out <-- [0, 2, 9, 5, 8] + * // d_aggregates_out <-- [0, 1, 6, 2, 4] + * // d_num_runs_out <-- [5] + * + * \endcode + * + * \tparam KeysInputIteratorT [inferred] Random-access input iterator type for reading input keys \iterator + * \tparam UniqueOutputIteratorT [inferred] Random-access output iterator type for writing unique output keys \iterator + * \tparam ValuesInputIteratorT [inferred] Random-access input iterator type for reading input values \iterator + * \tparam AggregatesOutputIterator [inferred] Random-access output iterator type for writing output value aggregates \iterator + * \tparam NumRunsOutputIteratorT [inferred] Output iterator type for recording the number of runs encountered \iterator + * \tparam ReductionOp [inferred] Binary reduction functor type having member T operator()(const T &a, const T &b) (e.g., cub::Sum, cub::Min, cub::Max, etc.) + */ + template < + typename KeysInputIteratorT, + typename UniqueOutputIteratorT, + typename ValuesInputIteratorT, + typename AggregatesOutputIteratorT, + typename NumRunsOutputIteratorT, + typename ReductionOp> + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t ReduceByKey( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + KeysInputIteratorT d_keys_in, ///< [in] Pointer to the input sequence of keys + UniqueOutputIteratorT d_unique_out, ///< [out] Pointer to the output sequence of unique keys (one key per run) + ValuesInputIteratorT d_values_in, ///< [in] Pointer to the input sequence of corresponding values + AggregatesOutputIteratorT d_aggregates_out, ///< [out] Pointer to the output sequence of value aggregates (one aggregate per run) + NumRunsOutputIteratorT d_num_runs_out, ///< [out] Pointer to total number of runs encountered (i.e., the length of d_unique_out) + ReductionOp reduction_op, ///< [in] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + int num_items, ///< [in] Total number of associated key+value pairs (i.e., the length of \p d_in_keys and \p d_in_values) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + typedef int OffsetT; // Signed integer type for global offsets + typedef NullType* FlagIterator; // FlagT iterator type (not used) + typedef NullType SelectOp; // Selection op (not used) + typedef Equality EqualityOp; // Default == operator + + return DispatchReduceByKey::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_keys_in, + d_unique_out, + d_values_in, + d_aggregates_out, + d_num_runs_out, + EqualityOp(), + reduction_op, + num_items, + stream, + debug_synchronous); + } + +}; + +/** + * \example example_device_reduce.cu + */ + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/device_run_length_encode.cuh b/3rdparty/cub/cub/device/device_run_length_encode.cuh new file mode 100644 index 00000000000..372c1ae8b10 --- /dev/null +++ b/3rdparty/cub/cub/device/device_run_length_encode.cuh @@ -0,0 +1,281 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceRunLengthEncode provides device-wide, parallel operations for computing a run-length encoding across a sequence of data items residing within global memory. + */ + +#pragma once + +#include +#include + +#include "dispatch/dispatch_rle.cuh" +#include "dispatch/dispatch_reduce_by_key.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief DeviceRunLengthEncode provides device-wide, parallel operations for demarcating "runs" of same-valued items within a sequence residing within global memory. ![](run_length_encode_logo.png) + * \ingroup DeviceModule + * + * \par Overview + * A run-length encoding + * computes a simple compressed representation of a sequence of input elements such that each + * maximal "run" of consecutive same-valued data items is encoded as a single data value along with a + * count of the elements in that run. + * + * \par Usage Considerations + * \cdp_class{DeviceRunLengthEncode} + * + * \par Performance + * \linear_performance{run-length encode} + * + * \par + * The following chart illustrates DeviceRunLengthEncode::RunLengthEncode performance across + * different CUDA architectures for \p int32 items. + * Segments have lengths uniformly sampled from [1,1000]. + * + * \image html rle_int32_len_500.png + * + * \par + * \plots_below + * + */ +struct DeviceRunLengthEncode +{ + + /** + * \brief Computes a run-length encoding of the sequence \p d_in. + * + * \par + * - For the ith run encountered, the first key of the run and its length are written to + * d_unique_out[i] and d_counts_out[i], + * respectively. + * - The total number of runs encountered is written to \p d_num_runs_out. + * - The == equality operator is used to determine whether values are equivalent + * - \devicestorage + * - \cdp + * + * \par Performance + * The following charts illustrate saturated encode performance across different + * CUDA architectures for \p int32 and \p int64 items, respectively. Segments have + * lengths uniformly sampled from [1,1000]. + * + * \image html rle_int32_len_500.png + * \image html rle_int64_len_500.png + * + * \par + * The following charts are similar, but with segment lengths uniformly sampled from [1,10]: + * + * \image html rle_int32_len_5.png + * \image html rle_int64_len_5.png + * + * \par Snippet + * The code snippet below illustrates the run-length encoding of a sequence of \p int values. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 8 + * int *d_in; // e.g., [0, 2, 2, 9, 5, 5, 5, 8] + * int *d_unique_out; // e.g., [ , , , , , , , ] + * int *d_counts_out; // e.g., [ , , , , , , , ] + * int *d_num_runs_out; // e.g., [ ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceRunLengthEncode::Encode(d_temp_storage, temp_storage_bytes, d_in, d_unique_out, d_counts_out, d_num_runs_out, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run encoding + * cub::DeviceRunLengthEncode::Encode(d_temp_storage, temp_storage_bytes, d_in, d_unique_out, d_counts_out, d_num_runs_out, num_items); + * + * // d_unique_out <-- [0, 2, 9, 5, 8] + * // d_counts_out <-- [1, 2, 1, 3, 1] + * // d_num_runs_out <-- [5] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items \iterator + * \tparam UniqueOutputIteratorT [inferred] Random-access output iterator type for writing unique output items \iterator + * \tparam LengthsOutputIteratorT [inferred] Random-access output iterator type for writing output counts \iterator + * \tparam NumRunsOutputIteratorT [inferred] Output iterator type for recording the number of runs encountered \iterator + */ + template < + typename InputIteratorT, + typename UniqueOutputIteratorT, + typename LengthsOutputIteratorT, + typename NumRunsOutputIteratorT> + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Encode( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of keys + UniqueOutputIteratorT d_unique_out, ///< [out] Pointer to the output sequence of unique keys (one key per run) + LengthsOutputIteratorT d_counts_out, ///< [out] Pointer to the output sequence of run-lengths (one count per run) + NumRunsOutputIteratorT d_num_runs_out, ///< [out] Pointer to total number of runs + int num_items, ///< [in] Total number of associated key+value pairs (i.e., the length of \p d_in_keys and \p d_in_values) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + // Data type of value iterator + typedef typename std::iterator_traits::value_type Value; + + typedef int OffsetT; // Signed integer type for global offsets + typedef NullType* FlagIterator; // FlagT iterator type (not used) + typedef NullType SelectOp; // Selection op (not used) + typedef Equality EqualityOp; // Default == operator + typedef cub::Sum ReductionOp; // Value reduction operator + + // Generator type for providing 1s values for run-length reduction + typedef ConstantInputIterator LengthsInputIteratorT; + + Value one_val; + one_val = 1; + + return DispatchReduceByKey::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_unique_out, + LengthsInputIteratorT(one_val), + d_counts_out, + d_num_runs_out, + EqualityOp(), + ReductionOp(), + num_items, + stream, + debug_synchronous); + } + + + /** + * \brief Enumerates the starting offsets and lengths of all non-trivial runs (of length > 1) of same-valued keys in the sequence \p d_in. + * + * \par + * - For the ith non-trivial run, the run's starting offset + * and its length are written to d_offsets_out[i] and + * d_lengths_out[i], respectively. + * - The total number of runs encountered is written to \p d_num_runs_out. + * - The == equality operator is used to determine whether values are equivalent + * - \devicestorage + * - \cdp + * + * \par Performance + * + * \par Snippet + * The code snippet below illustrates the identification of non-trivial runs within a sequence of \p int values. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 8 + * int *d_in; // e.g., [0, 2, 2, 9, 5, 5, 5, 8] + * int *d_offsets_out; // e.g., [ , , , , , , , ] + * int *d_lengths_out; // e.g., [ , , , , , , , ] + * int *d_num_runs_out; // e.g., [ ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceRunLengthEncode::NonTrivialRuns(d_temp_storage, temp_storage_bytes, d_in, d_offsets_out, d_lengths_out, d_num_runs_out, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run encoding + * cub::DeviceRunLengthEncode::NonTrivialRuns(d_temp_storage, temp_storage_bytes, d_in, d_offsets_out, d_lengths_out, d_num_runs_out, num_items); + * + * // d_offsets_out <-- [1, 4] + * // d_lengths_out <-- [2, 3] + * // d_num_runs_out <-- [2] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items \iterator + * \tparam OffsetsOutputIteratorT [inferred] Random-access output iterator type for writing run-offset values \iterator + * \tparam LengthsOutputIteratorT [inferred] Random-access output iterator type for writing run-length values \iterator + * \tparam NumRunsOutputIteratorT [inferred] Output iterator type for recording the number of runs encountered \iterator + */ + template < + typename InputIteratorT, + typename OffsetsOutputIteratorT, + typename LengthsOutputIteratorT, + typename NumRunsOutputIteratorT> + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t NonTrivialRuns( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to input sequence of data items + OffsetsOutputIteratorT d_offsets_out, ///< [out] Pointer to output sequence of run-offsets (one offset per non-trivial run) + LengthsOutputIteratorT d_lengths_out, ///< [out] Pointer to output sequence of run-lengths (one count per non-trivial run) + NumRunsOutputIteratorT d_num_runs_out, ///< [out] Pointer to total number of runs (i.e., length of \p d_offsets_out) + int num_items, ///< [in] Total number of associated key+value pairs (i.e., the length of \p d_in_keys and \p d_in_values) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + typedef int OffsetT; // Signed integer type for global offsets + typedef Equality EqualityOp; // Default == operator + + return DeviceRleDispatch::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_offsets_out, + d_lengths_out, + d_num_runs_out, + EqualityOp(), + num_items, + stream, + debug_synchronous); + } + + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/device_scan.cuh b/3rdparty/cub/cub/device/device_scan.cuh new file mode 100644 index 00000000000..e4bcf76e6c9 --- /dev/null +++ b/3rdparty/cub/cub/device/device_scan.cuh @@ -0,0 +1,419 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceScan provides device-wide, parallel operations for computing a prefix scan across a sequence of data items residing within global memory. + */ + +#pragma once + +#include +#include + +#include "dispatch/dispatch_scan.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief DeviceScan provides device-wide, parallel operations for computing a prefix scan across a sequence of data items residing within global memory. ![](device_scan.png) + * \ingroup DeviceModule + * + * \par Overview + * Given a sequence of input elements and a binary reduction operator, a [prefix scan](http://en.wikipedia.org/wiki/Prefix_sum) + * produces an output sequence where each element is computed to be the reduction + * of the elements occurring earlier in the input sequence. Prefix sum + * connotes a prefix scan with the addition operator. The term \em inclusive indicates + * that the ith output reduction incorporates the ith input. + * The term \em exclusive indicates the ith input is not incorporated into + * the ith output reduction. + * + * \par Usage Considerations + * \cdp_class{DeviceScan} + * + * \par Performance + * \linear_performance{prefix scan} + * + * \par + * The following chart illustrates DeviceScan::ExclusiveSum + * performance across different CUDA architectures for \p int32 keys. + * \plots_below + * + * \image html scan_int32.png + * + */ +struct DeviceScan +{ + /******************************************************************//** + * \name Exclusive scans + *********************************************************************/ + //@{ + + /** + * \brief Computes a device-wide exclusive prefix sum. + * + * \par + * - Supports non-commutative sum operators. + * - \devicestorage + * - \cdp + * + * \par Performance + * The following charts illustrate saturated exclusive sum performance across different + * CUDA architectures for \p int32 and \p int64 items, respectively. + * + * \image html scan_int32.png + * \image html scan_int64.png + * + * \par Snippet + * The code snippet below illustrates the exclusive prefix sum of an \p int device vector. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 7 + * int *d_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_out; // e.g., [ , , , , , , ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, d_in, d_out, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run exclusive prefix sum + * cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, d_in, d_out, num_items); + * + * // d_out s<-- [0, 8, 14, 21, 26, 29, 29] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading scan inputs \iterator + * \tparam OutputIteratorT [inferred] Random-access output iterator type for writing scan outputs \iterator + */ + template < + typename InputIteratorT, + typename OutputIteratorT> + CUB_RUNTIME_FUNCTION + static cudaError_t ExclusiveSum( + void *d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output sequence of data items + int num_items, ///< [in] Total number of input items (i.e., the length of \p d_in) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + // Scan data type + typedef typename std::iterator_traits::value_type T; + + return DispatchScan::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_out, + Sum(), + T(), + num_items, + stream, + debug_synchronous); + } + + + /** + * \brief Computes a device-wide exclusive prefix scan using the specified binary \p scan_op functor. + * + * \par + * - Supports non-commutative scan operators. + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is typically similar to DeviceScan::ExclusiveSum. + * + * \par Snippet + * The code snippet below illustrates the exclusive prefix min-scan of an \p int device vector + * \par + * \code + * #include // or equivalently + * + * // CustomMin functor + * struct CustomMin + * { + * template + * CUB_RUNTIME_FUNCTION __forceinline__ + * T operator()(const T &a, const T &b) const { + * return (b < a) ? b : a; + * } + * }; + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 7 + * int *d_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_out; // e.g., [ , , , , , , ] + * CustomMin min_op + * ... + * + * // Determine temporary device storage requirements for exclusive prefix scan + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceScan::ExclusiveScan(d_temp_storage, temp_storage_bytes, d_in, d_out, min_op, (int) MAX_INT, num_items); + * + * // Allocate temporary storage for exclusive prefix scan + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run exclusive prefix min-scan + * cub::DeviceScan::ExclusiveScan(d_temp_storage, temp_storage_bytes, d_in, d_out, min_op, (int) MAX_INT, num_items); + * + * // d_out <-- [2147483647, 8, 6, 6, 5, 3, 0] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading scan inputs \iterator + * \tparam OutputIteratorT [inferred] Random-access output iterator type for writing scan outputs \iterator + * \tparam ScanOp [inferred] Binary scan functor type having member T operator()(const T &a, const T &b) + * \tparam Identity [inferred] Type of the \p identity value used Binary scan functor type having member T operator()(const T &a, const T &b) + */ + template < + typename InputIteratorT, + typename OutputIteratorT, + typename ScanOp, + typename Identity> + CUB_RUNTIME_FUNCTION + static cudaError_t ExclusiveScan( + void *d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output sequence of data items + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + Identity identity, ///< [in] Identity element + int num_items, ///< [in] Total number of input items (i.e., the length of \p d_in) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + return DispatchScan::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_out, + scan_op, + identity, + num_items, + stream, + debug_synchronous); + } + + + //@} end member group + /******************************************************************//** + * \name Inclusive scans + *********************************************************************/ + //@{ + + + /** + * \brief Computes a device-wide inclusive prefix sum. + * + * \par + * - Supports non-commutative sum operators. + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is typically similar to DeviceScan::ExclusiveSum. + * + * \par Snippet + * The code snippet below illustrates the inclusive prefix sum of an \p int device vector. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 7 + * int *d_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_out; // e.g., [ , , , , , , ] + * ... + * + * // Determine temporary device storage requirements for inclusive prefix sum + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, d_in, d_out, num_items); + * + * // Allocate temporary storage for inclusive prefix sum + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run inclusive prefix sum + * cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, d_in, d_out, num_items); + * + * // d_out <-- [8, 14, 21, 26, 29, 29, 38] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading scan inputs \iterator + * \tparam OutputIteratorT [inferred] Random-access output iterator type for writing scan outputs \iterator + */ + template < + typename InputIteratorT, + typename OutputIteratorT> + CUB_RUNTIME_FUNCTION + static cudaError_t InclusiveSum( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output sequence of data items + int num_items, ///< [in] Total number of input items (i.e., the length of \p d_in) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + return DispatchScan::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_out, + Sum(), + NullType(), + num_items, + stream, + debug_synchronous); + } + + + /** + * \brief Computes a device-wide inclusive prefix scan using the specified binary \p scan_op functor. + * + * \par + * - Supports non-commutative scan operators. + * - \devicestorage + * - \cdp + * + * \par Performance + * Performance is typically similar to DeviceScan::ExclusiveSum. + * + * \par Snippet + * The code snippet below illustrates the inclusive prefix min-scan of an \p int device vector. + * \par + * \code + * #include // or equivalently + * + * // CustomMin functor + * struct CustomMin + * { + * template + * CUB_RUNTIME_FUNCTION __forceinline__ + * T operator()(const T &a, const T &b) const { + * return (b < a) ? b : a; + * } + * }; + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 7 + * int *d_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * int *d_out; // e.g., [ , , , , , , ] + * CustomMin min_op; + * ... + * + * // Determine temporary device storage requirements for inclusive prefix scan + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceScan::InclusiveScan(d_temp_storage, temp_storage_bytes, d_in, d_out, min_op, num_items); + * + * // Allocate temporary storage for inclusive prefix scan + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run inclusive prefix min-scan + * cub::DeviceScan::InclusiveScan(d_temp_storage, temp_storage_bytes, d_in, d_out, min_op, num_items); + * + * // d_out <-- [8, 6, 6, 5, 3, 0, 0] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading scan inputs \iterator + * \tparam OutputIteratorT [inferred] Random-access output iterator type for writing scan outputs \iterator + * \tparam ScanOp [inferred] Binary scan functor type having member T operator()(const T &a, const T &b) + */ + template < + typename InputIteratorT, + typename OutputIteratorT, + typename ScanOp> + CUB_RUNTIME_FUNCTION + static cudaError_t InclusiveScan( + void *d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output sequence of data items + ScanOp scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + int num_items, ///< [in] Total number of input items (i.e., the length of \p d_in) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + // Signed integer type for global offsets + typedef int OffsetT; + + return DispatchScan::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_out, + scan_op, + NullType(), + num_items, + stream, + debug_synchronous); + } + + //@} end member group + +}; + +/** + * \example example_device_scan.cu + */ + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/device_select.cuh b/3rdparty/cub/cub/device/device_select.cuh new file mode 100644 index 00000000000..10ab2f4507b --- /dev/null +++ b/3rdparty/cub/cub/device/device_select.cuh @@ -0,0 +1,372 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceSelect provides device-wide, parallel operations for selecting items from sequences of data items residing within global memory. + */ + +#pragma once + +#include +#include + +#include "dispatch/dispatch_select_if.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief DeviceSelect provides device-wide, parallel operations for compacting selected items from sequences of data items residing within global memory. ![](select_logo.png) + * \ingroup DeviceModule + * + * \par Overview + * These operations apply a selection criterion to selectively copy + * items from a specified input sequence to a compact output sequence. + * + * \par Usage Considerations + * \cdp_class{DeviceSelect} + * + * \par Performance + * \linear_performance{select-flagged, select-if, and select-unique} + * + * \par + * The following chart illustrates DeviceSelect::If + * performance across different CUDA architectures for \p int32 items, + * where 50% of the items are randomly selected. + * + * \image html select_if_int32_50_percent.png + * + * \par + * The following chart illustrates DeviceSelect::Unique + * performance across different CUDA architectures for \p int32 items + * where segments have lengths uniformly sampled from [1,1000]. + * + * \image html select_unique_int32_len_500.png + * + * \par + * \plots_below + * + */ +struct DeviceSelect +{ + /** + * \brief Uses the \p d_flags sequence to selectively copy the corresponding items from \p d_in into \p d_out. The total number of items selected is written to \p d_num_selected_out. ![](select_flags_logo.png) + * + * \par + * - The value type of \p d_flags must be castable to \p bool (e.g., \p bool, \p char, \p int, etc.). + * - Copies of the selected items are compacted into \p d_out and maintain their original relative ordering. + * - \devicestorage + * - \cdp + * + * \par Snippet + * The code snippet below illustrates the compaction of items selected from an \p int device vector. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input, flags, and output + * int num_items; // e.g., 8 + * int *d_in; // e.g., [1, 2, 3, 4, 5, 6, 7, 8] + * char *d_flags; // e.g., [1, 0, 0, 1, 0, 1, 1, 0] + * int *d_out; // e.g., [ , , , , , , , ] + * int *d_num_selected_out; // e.g., [ ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceSelect::Flagged(d_temp_storage, temp_storage_bytes, d_in, d_flags, d_out, d_num_selected_out, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run selection + * cub::DeviceSelect::Flagged(d_temp_storage, temp_storage_bytes, d_in, d_flags, d_out, d_num_selected_out, num_items); + * + * // d_out <-- [1, 4, 6, 7] + * // d_num_selected_out <-- [4] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items \iterator + * \tparam FlagIterator [inferred] Random-access input iterator type for reading selection flags \iterator + * \tparam OutputIteratorT [inferred] Random-access output iterator type for writing selected items \iterator + * \tparam NumSelectedIteratorT [inferred] Output iterator type for recording the number of items selected \iterator + */ + template < + typename InputIteratorT, + typename FlagIterator, + typename OutputIteratorT, + typename NumSelectedIteratorT> + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Flagged( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + FlagIterator d_flags, ///< [in] Pointer to the input sequence of selection flags + OutputIteratorT d_out, ///< [out] Pointer to the output sequence of selected data items + NumSelectedIteratorT d_num_selected_out, ///< [out] Pointer to the output total number of items selected (i.e., length of \p d_out) + int num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + typedef int OffsetT; // Signed integer type for global offsets + typedef NullType SelectOp; // Selection op (not used) + typedef NullType EqualityOp; // Equality operator (not used) + + return DispatchSelectIf::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_flags, + d_out, + d_num_selected_out, + SelectOp(), + EqualityOp(), + num_items, + stream, + debug_synchronous); + } + + + /** + * \brief Uses the \p select_op functor to selectively copy items from \p d_in into \p d_out. The total number of items selected is written to \p d_num_selected_out. ![](select_logo.png) + * + * \par + * - Copies of the selected items are compacted into \p d_out and maintain their original relative ordering. + * - \devicestorage + * - \cdp + * + * \par Performance + * The following charts illustrate saturated select-if performance across different + * CUDA architectures for \p int32 and \p int64 items, respectively. Items are + * selected with 50% probability. + * + * \image html select_if_int32_50_percent.png + * \image html select_if_int64_50_percent.png + * + * \par + * The following charts are similar, but 5% selection probability: + * + * \image html select_if_int32_5_percent.png + * \image html select_if_int64_5_percent.png + * + * \par Snippet + * The code snippet below illustrates the compaction of items selected from an \p int device vector. + * \par + * \code + * #include // or equivalently + * + * // Functor type for selecting values less than some criteria + * struct LessThan + * { + * int compare; + * + * CUB_RUNTIME_FUNCTION __forceinline__ + * LessThan(int compare) : compare(compare) {} + * + * CUB_RUNTIME_FUNCTION __forceinline__ + * bool operator()(const int &a) const { + * return (a < compare); + * } + * }; + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 8 + * int *d_in; // e.g., [0, 2, 3, 9, 5, 2, 81, 8] + * int *d_out; // e.g., [ , , , , , , , ] + * int *d_num_selected_out; // e.g., [ ] + * LessThan select_op(7); + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceSelect::If(d_temp_storage, temp_storage_bytes, d_in, d_out, d_num_selected_out, num_items, select_op); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run selection + * cub::DeviceSelect::If(d_temp_storage, temp_storage_bytes, d_in, d_out, d_num_selected_out, num_items, select_op); + * + * // d_out <-- [0, 2, 3, 5, 2] + * // d_num_selected_out <-- [5] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items \iterator + * \tparam OutputIteratorT [inferred] Random-access output iterator type for writing selected items \iterator + * \tparam NumSelectedIteratorT [inferred] Output iterator type for recording the number of items selected \iterator + * \tparam SelectOp [inferred] Selection operator type having member bool operator()(const T &a) + */ + template < + typename InputIteratorT, + typename OutputIteratorT, + typename NumSelectedIteratorT, + typename SelectOp> + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t If( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output sequence of selected data items + NumSelectedIteratorT d_num_selected_out, ///< [out] Pointer to the output total number of items selected (i.e., length of \p d_out) + int num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + SelectOp select_op, ///< [in] Unary selection operator + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + typedef int OffsetT; // Signed integer type for global offsets + typedef NullType* FlagIterator; // FlagT iterator type (not used) + typedef NullType EqualityOp; // Equality operator (not used) + + return DispatchSelectIf::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + NULL, + d_out, + d_num_selected_out, + select_op, + EqualityOp(), + num_items, + stream, + debug_synchronous); + } + + + /** + * \brief Given an input sequence \p d_in having runs of consecutive equal-valued keys, only the first key from each run is selectively copied to \p d_out. The total number of items selected is written to \p d_num_selected_out. ![](unique_logo.png) + * + * \par + * - The == equality operator is used to determine whether keys are equivalent + * - Copies of the selected items are compacted into \p d_out and maintain their original relative ordering. + * - \devicestorage + * - \cdp + * + * \par Performance + * The following charts illustrate saturated select-unique performance across different + * CUDA architectures for \p int32 and \p int64 items, respectively. Segments have + * lengths uniformly sampled from [1,1000]. + * + * \image html select_unique_int32_len_500.png + * \image html select_unique_int64_len_500.png + * + * \par + * The following charts are similar, but with segment lengths uniformly sampled from [1,10]: + * + * \image html select_unique_int32_len_5.png + * \image html select_unique_int64_len_5.png + * + * \par Snippet + * The code snippet below illustrates the compaction of items selected from an \p int device vector. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input and output + * int num_items; // e.g., 8 + * int *d_in; // e.g., [0, 2, 2, 9, 5, 5, 5, 8] + * int *d_out; // e.g., [ , , , , , , , ] + * int *d_num_selected_out; // e.g., [ ] + * ... + * + * // Determine temporary device storage requirements + * void *d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceSelect::Unique(d_temp_storage, temp_storage_bytes, d_in, d_out, d_num_selected_out, num_items); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run selection + * cub::DeviceSelect::Unique(d_temp_storage, temp_storage_bytes, d_in, d_out, d_num_selected_out, num_items); + * + * // d_out <-- [0, 2, 9, 5, 8] + * // d_num_selected_out <-- [5] + * + * \endcode + * + * \tparam InputIteratorT [inferred] Random-access input iterator type for reading input items \iterator + * \tparam OutputIteratorT [inferred] Random-access output iterator type for writing selected items \iterator + * \tparam NumSelectedIteratorT [inferred] Output iterator type for recording the number of items selected \iterator + */ + template < + typename InputIteratorT, + typename OutputIteratorT, + typename NumSelectedIteratorT> + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Unique( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output sequence of selected data items + NumSelectedIteratorT d_num_selected_out, ///< [out] Pointer to the output total number of items selected (i.e., length of \p d_out) + int num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + typedef int OffsetT; // Signed integer type for global offsets + typedef NullType* FlagIterator; // FlagT iterator type (not used) + typedef NullType SelectOp; // Selection op (not used) + typedef Equality EqualityOp; // Default == operator + + return DispatchSelectIf::Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + NULL, + d_out, + d_num_selected_out, + SelectOp(), + EqualityOp(), + num_items, + stream, + debug_synchronous); + } + +}; + +/** + * \example example_device_select_flagged.cu + * \example example_device_select_if.cu + * \example example_device_select_unique.cu + */ + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/device_spmv.cuh b/3rdparty/cub/cub/device/device_spmv.cuh new file mode 100644 index 00000000000..64ce7cfec07 --- /dev/null +++ b/3rdparty/cub/cub/device/device_spmv.cuh @@ -0,0 +1,178 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceSpmv provides device-wide parallel operations for performing sparse-matrix * vector multiplication (SpMV). + */ + +#pragma once + +#include +#include +#include + +#include "dispatch/dispatch_spmv.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief DeviceSpmv provides device-wide parallel operations for performing sparse-matrix * dense-vector multiplication (SpMV). + * \ingroup DeviceModule + * + * \par Overview + * The [SpMV computation](http://en.wikipedia.org/wiki/Sparse_matrix-vector_multiplication) + * performs the matrix-vector operation + * y = alpha*A*x + beta*y, + * where: + * - A is an mxn sparse matrix whose non-zero structure is specified in + * [compressed-storage-row (CSR) format](http://en.wikipedia.org/wiki/Sparse_matrix#Compressed_row_Storage_.28CRS_or_CSR.29) + * (i.e., three arrays: values, row_offsets, and column_indices) + * - x and y are dense vectors + * - alpha and beta are scalar multiplicands + * + * \par Usage Considerations + * \cdp_class{DeviceSpmv} + * + */ +struct DeviceSpmv +{ + /******************************************************************//** + * \name CSR matrix operations + *********************************************************************/ + //@{ + + /** + * \brief This function performs the matrix-vector operation y = alpha*A*x + beta*y. + * + * \par Snippet + * The code snippet below illustrates SpMV upon a 9x9 CSR matrix A + * representing a 3x3 lattice (24 non-zeros). + * + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize device pointers for input matrix A, input vector x, + * // and output vector y + * int num_rows = 9; + * int num_cols = 9; + * int num_nonzeros = 24; + * float alpha = 1.0; + * float beta = 0.0; + * + * float* d_values; // e.g., [1, 1, 1, 1, 1, 1, 1, 1, + * // 1, 1, 1, 1, 1, 1, 1, 1, + * // 1, 1, 1, 1, 1, 1, 1, 1] + * + * int* d_column_indices; // e.g., [1, 3, 0, 2, 4, 1, 5, 0, + * // 4, 6, 1, 3, 5, 7, 2, 4, + * // 8, 3, 7, 4, 6, 8, 5, 7] + * + * int* d_row_offsets; // e.g., [0, 2, 5, 7, 10, 14, 17, 19, 22, 24] + * + * float* d_vector_x; // e.g., [1, 1, 1, 1, 1, 1, 1, 1, 1] + * float* d_vector_y; // e.g., [ , , , , , , , , ] + * ... + * + * // Determine temporary device storage requirements + * void* d_temp_storage = NULL; + * size_t temp_storage_bytes = 0; + * cub::DeviceSpmv::CsrMV(d_temp_storage, temp_storage_bytes, d_values, + * d_row_offsets, d_column_indices, d_vector_x, d_vector_y, + * num_rows, num_cols, num_nonzeros, alpha, beta); + * + * // Allocate temporary storage + * cudaMalloc(&d_temp_storage, temp_storage_bytes); + * + * // Run SpMV + * cub::DeviceSpmv::CsrMV(d_temp_storage, temp_storage_bytes, d_values, + * d_row_offsets, d_column_indices, d_vector_x, d_vector_y, + * num_rows, num_cols, num_nonzeros, alpha, beta); + * + * // d_vector_y <-- [2, 3, 2, 3, 4, 3, 2, 3, 2] + * + * \endcode + * + * \tparam ValueT [inferred] Matrix and vector value type (e.g., /p float, /p double, etc.) + */ + template < + typename ValueT> + CUB_RUNTIME_FUNCTION + static cudaError_t CsrMV( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + ValueT* d_values, ///< [in] Pointer to the array of \p num_nonzeros values of the corresponding nonzero elements of matrix A. + int* d_row_offsets, ///< [in] Pointer to the array of \p m + 1 offsets demarcating the start of every row in \p d_column_indices and \p d_values (with the final entry being equal to \p num_nonzeros) + int* d_column_indices, ///< [in] Pointer to the array of \p num_nonzeros column-indices of the corresponding nonzero elements of matrix A. (Indices are zero-valued.) + ValueT* d_vector_x, ///< [in] Pointer to the array of \p num_cols values corresponding to the dense input vector x + ValueT* d_vector_y, ///< [out] Pointer to the array of \p num_rows values corresponding to the dense output vector y + int num_rows, ///< [in] number of rows of matrix A. + int num_cols, ///< [in] number of columns of matrix A. + int num_nonzeros, ///< [in] number of nonzero elements of matrix A. + ValueT alpha, ///< [in] Scalar used for multiplication of the matrix A nonzeros. + ValueT beta, ///< [in] Scalar used for multiplication of the \p vector_y addend. (If \p beta is zero, vector_y need not comprise valid data elements.) + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + SpmvParams spmv_params; + spmv_params.d_values = d_values; + spmv_params.d_row_end_offsets = d_row_offsets + 1; + spmv_params.d_column_indices = d_column_indices; + spmv_params.d_vector_x = d_vector_x; + spmv_params.d_vector_y = d_vector_y; + spmv_params.num_rows = num_rows; + spmv_params.num_cols = num_cols; + spmv_params.num_nonzeros = num_nonzeros; + spmv_params.alpha = alpha; + spmv_params.beta = beta; + + return DispatchSpmv::Dispatch( + d_temp_storage, + temp_storage_bytes, + spmv_params, + stream, + debug_synchronous); + } + + //@} end member group +}; + + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/dispatch/dispatch_histogram.cuh b/3rdparty/cub/cub/device/dispatch/dispatch_histogram.cuh new file mode 100644 index 00000000000..04492c41c26 --- /dev/null +++ b/3rdparty/cub/cub/device/dispatch/dispatch_histogram.cuh @@ -0,0 +1,1084 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceHistogram provides device-wide parallel operations for constructing histogram(s) from a sequence of samples data residing within global memory. + */ + +#pragma once + +#include +#include +#include + +#include "../../agent/agent_histogram.cuh" +#include "../../util_debug.cuh" +#include "../../util_device.cuh" +#include "../../thread/thread_search.cuh" +#include "../../grid/grid_queue.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + + +/****************************************************************************** + * Histogram kernel entry points + *****************************************************************************/ + +/** + * Histogram initialization kernel entry point + */ +template < + int NUM_ACTIVE_CHANNELS, ///< Number of channels actively being histogrammed + typename CounterT, ///< Integer type for counting sample occurrences per histogram bin + typename OffsetT> ///< Signed integer type for global offsets +__global__ void DeviceHistogramInitKernel( + ArrayWrapper num_output_bins_wrapper, ///< Number of output histogram bins per channel + ArrayWrapper d_output_histograms_wrapper, ///< Histogram counter data having logical dimensions CounterT[NUM_ACTIVE_CHANNELS][num_bins.array[CHANNEL]] + GridQueue tile_queue) ///< Drain queue descriptor for dynamically mapping tile data onto thread blocks +{ + if ((threadIdx.x == 0) && (blockIdx.x == 0)) + tile_queue.ResetDrain(); + + int output_bin = (blockIdx.x * blockDim.x) + threadIdx.x; + + #pragma unroll + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + { + if (output_bin < num_output_bins_wrapper.array[CHANNEL]) + d_output_histograms_wrapper.array[CHANNEL][output_bin] = 0; + } +} + + +/** + * Histogram privatized sweep kernel entry point (multi-block). Computes privatized histograms, one per thread block. + */ +template < + typename AgentHistogramPolicyT, ///< Parameterized AgentHistogramPolicy tuning policy type + int PRIVATIZED_SMEM_BINS, ///< Maximum number of histogram bins per channel (e.g., up to 256) + int NUM_CHANNELS, ///< Number of channels interleaved in the input data (may be greater than the number of channels being actively histogrammed) + int NUM_ACTIVE_CHANNELS, ///< Number of channels actively being histogrammed + typename SampleIteratorT, ///< The input iterator type. \iterator. + typename CounterT, ///< Integer type for counting sample occurrences per histogram bin + typename PrivatizedDecodeOpT, ///< The transform operator type for determining privatized counter indices from samples, one for each channel + typename OutputDecodeOpT, ///< The transform operator type for determining output bin-ids from privatized counter indices, one for each channel + typename OffsetT> ///< Signed integer type for global offsets +__launch_bounds__ (int(AgentHistogramPolicyT::BLOCK_THREADS)) +__global__ void DeviceHistogramSweepKernel( + SampleIteratorT d_samples, ///< Input data to reduce + ArrayWrapper num_output_bins_wrapper, ///< The number bins per final output histogram + ArrayWrapper num_privatized_bins_wrapper, ///< The number bins per privatized histogram + ArrayWrapper d_output_histograms_wrapper, ///< Reference to final output histograms + ArrayWrapper d_privatized_histograms_wrapper, ///< Reference to privatized histograms + ArrayWrapper output_decode_op_wrapper, ///< The transform operator for determining output bin-ids from privatized counter indices, one for each channel + ArrayWrapper privatized_decode_op_wrapper, ///< The transform operator for determining privatized counter indices from samples, one for each channel + OffsetT num_row_pixels, ///< The number of multi-channel pixels per row in the region of interest + OffsetT num_rows, ///< The number of rows in the region of interest + OffsetT row_stride_samples, ///< The number of samples between starts of consecutive rows in the region of interest + int tiles_per_row, ///< Number of image tiles per row + GridQueue tile_queue) ///< Drain queue descriptor for dynamically mapping tile data onto thread blocks +{ + // Thread block type for compositing input tiles + typedef AgentHistogram< + AgentHistogramPolicyT, + PRIVATIZED_SMEM_BINS, + NUM_CHANNELS, + NUM_ACTIVE_CHANNELS, + SampleIteratorT, + CounterT, + PrivatizedDecodeOpT, + OutputDecodeOpT, + OffsetT> + AgentHistogramT; + + // Shared memory for AgentHistogram + __shared__ typename AgentHistogramT::TempStorage temp_storage; + + AgentHistogramT agent( + temp_storage, + d_samples, + num_output_bins_wrapper.array, + num_privatized_bins_wrapper.array, + d_output_histograms_wrapper.array, + d_privatized_histograms_wrapper.array, + output_decode_op_wrapper.array, + privatized_decode_op_wrapper.array); + + // Initialize counters + agent.InitBinCounters(); + + // Consume input tiles + agent.ConsumeTiles( + num_row_pixels, + num_rows, + row_stride_samples, + tiles_per_row, + tile_queue); + + // Store output to global (if necessary) + agent.StoreOutput(); + +} + + + + + + +/****************************************************************************** + * Dispatch + ******************************************************************************/ + +/** + * Utility class for dispatching the appropriately-tuned kernels for DeviceHistogram + */ +template < + int NUM_CHANNELS, ///< Number of channels interleaved in the input data (may be greater than the number of channels being actively histogrammed) + int NUM_ACTIVE_CHANNELS, ///< Number of channels actively being histogrammed + typename SampleIteratorT, ///< Random-access input iterator type for reading input items \iterator + typename CounterT, ///< Integer type for counting sample occurrences per histogram bin + typename LevelT, ///< Type for specifying bin level boundaries + typename OffsetT> ///< Signed integer type for global offsets +struct DipatchHistogram +{ + //--------------------------------------------------------------------- + // Types and constants + //--------------------------------------------------------------------- + + /// The sample value type of the input iterator + typedef typename std::iterator_traits::value_type SampleT; + + enum + { + // Maximum number of bins per channel for which we will use a privatized smem strategy + MAX_PRIVATIZED_SMEM_BINS = 256 + }; + + + //--------------------------------------------------------------------- + // Transform functors for converting samples to bin-ids + //--------------------------------------------------------------------- + + // Searches for bin given a list of bin-boundary levels + template + struct SearchTransform + { + LevelIteratorT d_levels; // Pointer to levels array + int num_output_levels; // Number of levels in array + + // Initializer + __host__ __device__ __forceinline__ void Init( + LevelIteratorT d_levels, // Pointer to levels array + int num_output_levels) // Number of levels in array + { + this->d_levels = d_levels; + this->num_output_levels = num_output_levels; + } + + // Method for converting samples to bin-ids + template + __host__ __device__ __forceinline__ void BinSelect(_SampleT sample, int &bin, bool valid) + { + /// Level iterator wrapper type + typedef typename If::VALUE, + CacheModifiedInputIterator, // Wrap the native input pointer with CacheModifiedInputIterator + LevelIteratorT>::Type // Directly use the supplied input iterator type + WrappedLevelIteratorT; + + WrappedLevelIteratorT wrapped_levels(d_levels); + + int num_bins = num_output_levels - 1; + if (valid) + { + bin = UpperBound(wrapped_levels, num_output_levels, (LevelT) sample) - 1; + if (bin >= num_bins) + bin = -1; + } + } + }; + + + // Scales samples to evenly-spaced bins + struct ScaleTransform + { + int num_bins; // Number of levels in array + LevelT max; // Max sample level (exclusive) + LevelT min; // Min sample level (inclusive) + LevelT scale; // Bin scaling factor + + // Initializer + template + __host__ __device__ __forceinline__ void Init( + int num_output_levels, // Number of levels in array + _LevelT max, // Max sample level (exclusive) + _LevelT min, // Min sample level (inclusive) + _LevelT scale) // Bin scaling factor + { + this->num_bins = num_output_levels - 1; + this->max = max; + this->min = min; + this->scale = scale; + } + + // Initializer (float specialization) + __host__ __device__ __forceinline__ void Init( + int num_output_levels, // Number of levels in array + float max, // Max sample level (exclusive) + float min, // Min sample level (inclusive) + float scale) // Bin scaling factor + { + this->num_bins = num_output_levels - 1; + this->max = max; + this->min = min; + this->scale = float(1.0) / scale; + } + + // Initializer (double specialization) + __host__ __device__ __forceinline__ void Init( + int num_output_levels, // Number of levels in array + double max, // Max sample level (exclusive) + double min, // Min sample level (inclusive) + double scale) // Bin scaling factor + { + this->num_bins = num_output_levels - 1; + this->max = max; + this->min = min; + this->scale = double(1.0) / scale; + } + + // Method for converting samples to bin-ids + template + __host__ __device__ __forceinline__ void BinSelect(_SampleT sample, int &bin, bool valid) + { + LevelT level_sample = (LevelT) sample; + + if (valid && (level_sample >= min) && (level_sample < max)) + bin = (int) ((level_sample - min) / scale); + } + + // Method for converting samples to bin-ids (float specialization) + template + __host__ __device__ __forceinline__ void BinSelect(float sample, int &bin, bool valid) + { + LevelT level_sample = (LevelT) sample; + + if (valid && (level_sample >= min) && (level_sample < max)) + bin = (int) ((level_sample - min) * scale); + } + + // Method for converting samples to bin-ids (double specialization) + template + __host__ __device__ __forceinline__ void BinSelect(double sample, int &bin, bool valid) + { + LevelT level_sample = (LevelT) sample; + + if (valid && (level_sample >= min) && (level_sample < max)) + bin = (int) ((level_sample - min) * scale); + } + }; + + + // Pass-through bin transform operator + struct PassThruTransform + { + // Method for converting samples to bin-ids + template + __host__ __device__ __forceinline__ void BinSelect(_SampleT sample, int &bin, bool valid) + { + if (valid) + bin = (int) sample; + } + }; + + + + //--------------------------------------------------------------------- + // Tuning policies + //--------------------------------------------------------------------- + + /// SM11 + struct Policy110 + { + // HistogramSweepPolicy + typedef AgentHistogramPolicy< + 512, + (NUM_CHANNELS == 1) ? 8 : 2, + BLOCK_LOAD_DIRECT, + LOAD_DEFAULT, + true, + GMEM, + false> + HistogramSweepPolicy; + }; + + /// SM20 + struct Policy200 + { + // HistogramSweepPolicy + typedef AgentHistogramPolicy< + (NUM_CHANNELS == 1) ? 256 : 128, + (NUM_CHANNELS == 1) ? 8 : 3, + (NUM_CHANNELS == 1) ? BLOCK_LOAD_DIRECT : BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + true, + SMEM, + false> + HistogramSweepPolicy; + }; + + /// SM30 + struct Policy300 + { + // HistogramSweepPolicy + typedef AgentHistogramPolicy< + 512, + (NUM_CHANNELS == 1) ? 8 : 2, + BLOCK_LOAD_DIRECT, + LOAD_DEFAULT, + true, + GMEM, + false> + HistogramSweepPolicy; + }; + + /// SM35 + struct Policy350 + { + // HistogramSweepPolicy + typedef AgentHistogramPolicy< + 128, + (NUM_CHANNELS == 1) ? 8 : 7, + BLOCK_LOAD_DIRECT, + LOAD_LDG, + true, + BLEND, + true> + HistogramSweepPolicy; + }; + + /// SM50 + struct Policy500 + { + // HistogramSweepPolicy + typedef AgentHistogramPolicy< + 256, + 8, + BLOCK_LOAD_DIRECT, + LOAD_LDG, + true, + SMEM, + true> + HistogramSweepPolicy; + }; + + + + //--------------------------------------------------------------------- + // Tuning policies of current PTX compiler pass + //--------------------------------------------------------------------- + +#if (CUB_PTX_ARCH >= 500) + typedef Policy500 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 350) + typedef Policy350 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 300) + typedef Policy300 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 200) + typedef Policy200 PtxPolicy; + +#else + typedef Policy110 PtxPolicy; + +#endif + + // "Opaque" policies (whose parameterizations aren't reflected in the type signature) + struct PtxHistogramSweepPolicy : PtxPolicy::HistogramSweepPolicy {}; + + + //--------------------------------------------------------------------- + // Utilities + //--------------------------------------------------------------------- + + /** + * Initialize kernel dispatch configurations with the policies corresponding to the PTX assembly we will use + */ + template + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t InitConfigs( + int ptx_version, + KernelConfig &histogram_sweep_config) + { + #if (CUB_PTX_ARCH > 0) + + // We're on the device, so initialize the kernel dispatch configurations with the current PTX policy + return histogram_sweep_config.template Init(); + + #else + + // We're on the host, so lookup and initialize the kernel dispatch configurations with the policies that match the device's PTX version + if (ptx_version >= 500) + { + return histogram_sweep_config.template Init(); + } + else if (ptx_version >= 350) + { + return histogram_sweep_config.template Init(); + } + else if (ptx_version >= 300) + { + return histogram_sweep_config.template Init(); + } + else if (ptx_version >= 200) + { + return histogram_sweep_config.template Init(); + } + else if (ptx_version >= 110) + { + return histogram_sweep_config.template Init(); + } + else + { + // No global atomic support + return cudaErrorNotSupported; + } + + #endif + } + + + /** + * Kernel kernel dispatch configuration + */ + struct KernelConfig + { + int block_threads; + int pixels_per_thread; + + template + CUB_RUNTIME_FUNCTION __forceinline__ + cudaError_t Init() + { + block_threads = BlockPolicy::BLOCK_THREADS; + pixels_per_thread = BlockPolicy::PIXELS_PER_THREAD; + + return cudaSuccess; + } + }; + + + //--------------------------------------------------------------------- + // Dispatch entrypoints + //--------------------------------------------------------------------- + + /** + * Privatization-based dispatch routine + */ + template < + typename PrivatizedDecodeOpT, ///< The transform operator type for determining privatized counter indices from samples, one for each channel + typename OutputDecodeOpT, ///< The transform operator type for determining output bin-ids from privatized counter indices, one for each channel + typename DeviceHistogramInitKernelT, ///< Function type of cub::DeviceHistogramInitKernel + typename DeviceHistogramSweepKernelT> ///< Function type of cub::DeviceHistogramSweepKernel + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t PrivatizedDispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the input sequence of sample items. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples). + CounterT* d_output_histograms[NUM_ACTIVE_CHANNELS], ///< [out] The pointers to the histogram counter output arrays, one for each active channel. For channeli, the allocation length of d_histograms[i] should be num_output_levels[i] - 1. + int num_privatized_levels[NUM_ACTIVE_CHANNELS], ///< [in] The number of bin level boundaries for delineating histogram samples in each active channel. Implies that the number of bins for channeli is num_output_levels[i] - 1. + PrivatizedDecodeOpT privatized_decode_op[NUM_ACTIVE_CHANNELS], ///< [in] Transform operators for determining bin-ids from samples, one for each channel + int num_output_levels[NUM_ACTIVE_CHANNELS], ///< [in] The number of bin level boundaries for delineating histogram samples in each active channel. Implies that the number of bins for channeli is num_output_levels[i] - 1. + OutputDecodeOpT output_decode_op[NUM_ACTIVE_CHANNELS], ///< [in] Transform operators for determining bin-ids from samples, one for each channel + int max_num_output_bins, ///< [in] Maximum number of output bins in any channel + OffsetT num_row_pixels, ///< [in] The number of multi-channel pixels per row in the region of interest + OffsetT num_rows, ///< [in] The number of rows in the region of interest + OffsetT row_stride_samples, ///< [in] The number of samples between starts of consecutive rows in the region of interest + DeviceHistogramInitKernelT histogram_init_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceHistogramInitKernel + DeviceHistogramSweepKernelT histogram_sweep_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceHistogramSweepKernel + KernelConfig histogram_sweep_config, ///< [in] Dispatch parameters that match the policy that \p histogram_sweep_kernel was compiled for + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous) ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + #ifndef CUB_RUNTIME_ENABLED + + // Kernel launch not supported from this device + return CubDebug(cudaErrorNotSupported); + + #else + + cudaError error = cudaSuccess; + do + { + // Get device ordinal + int device_ordinal; + if (CubDebug(error = cudaGetDevice(&device_ordinal))) break; + + // Get device SM version + int sm_version; + if (CubDebug(error = SmVersion(sm_version, device_ordinal))) break; + + // Get SM count + int sm_count; + if (CubDebug(error = cudaDeviceGetAttribute (&sm_count, cudaDevAttrMultiProcessorCount, device_ordinal))) break; + + // Get SM occupancy for histogram_sweep_kernel + int histogram_sweep_sm_occupancy; + if (CubDebug(error = MaxSmOccupancy( + histogram_sweep_sm_occupancy, + sm_version, + histogram_sweep_kernel, + histogram_sweep_config.block_threads))) break; + + // Get device occupancy for histogram_sweep_kernel + int histogram_sweep_occupancy = histogram_sweep_sm_occupancy * sm_count; + + if (num_row_pixels * NUM_CHANNELS == row_stride_samples) + { + // Treat as a single linear array of samples + num_row_pixels *= num_rows; + num_rows = 1; + row_stride_samples = num_row_pixels * NUM_CHANNELS; + } + + // Get grid dimensions, trying to keep total blocks ~histogram_sweep_occupancy + int pixels_per_tile = histogram_sweep_config.block_threads * histogram_sweep_config.pixels_per_thread; + int tiles_per_row = (num_row_pixels + pixels_per_tile - 1) / pixels_per_tile; + int blocks_per_row = CUB_MIN(histogram_sweep_occupancy, tiles_per_row); + int blocks_per_col = CUB_MIN(histogram_sweep_occupancy / blocks_per_row, num_rows); + int num_threadblocks = blocks_per_row * blocks_per_col; + + dim3 sweep_grid_dims; + sweep_grid_dims.x = (unsigned int) blocks_per_row; + sweep_grid_dims.y = (unsigned int) blocks_per_col; + sweep_grid_dims.z = 1; + + // Temporary storage allocation requirements + const int NUM_ALLOCATIONS = NUM_ACTIVE_CHANNELS + 1; + void* allocations[NUM_ALLOCATIONS]; + size_t allocation_sizes[NUM_ALLOCATIONS]; + + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + allocation_sizes[CHANNEL] = num_threadblocks * (num_privatized_levels[CHANNEL] - 1) * sizeof(CounterT); + + allocation_sizes[NUM_ALLOCATIONS - 1] = GridQueue::AllocationSize(); + + // Alias the temporary allocations from the single storage blob (or compute the necessary size of the blob) + if (CubDebug(error = AliasTemporaries(d_temp_storage, temp_storage_bytes, allocations, allocation_sizes))) break; + if (d_temp_storage == NULL) + { + // Return if the caller is simply requesting the size of the storage allocation + return cudaSuccess; + } + + // Construct the grid queue descriptor + GridQueue tile_queue(allocations[NUM_ALLOCATIONS - 1]); + + // Setup array wrapper for histogram channel output (because we can't pass static arrays as kernel parameters) + ArrayWrapper d_output_histograms_wrapper; + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + d_output_histograms_wrapper.array[CHANNEL] = d_output_histograms[CHANNEL]; + + // Setup array wrapper for privatized per-block histogram channel output (because we can't pass static arrays as kernel parameters) + ArrayWrapper d_privatized_histograms_wrapper; + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + d_privatized_histograms_wrapper.array[CHANNEL] = (CounterT*) allocations[CHANNEL]; + + // Setup array wrapper for sweep bin transforms (because we can't pass static arrays as kernel parameters) + ArrayWrapper privatized_decode_op_wrapper; + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + privatized_decode_op_wrapper.array[CHANNEL] = privatized_decode_op[CHANNEL]; + + // Setup array wrapper for aggregation bin transforms (because we can't pass static arrays as kernel parameters) + ArrayWrapper output_decode_op_wrapper; + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + output_decode_op_wrapper.array[CHANNEL] = output_decode_op[CHANNEL]; + + // Setup array wrapper for num privatized bins (because we can't pass static arrays as kernel parameters) + ArrayWrapper num_privatized_bins_wrapper; + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + num_privatized_bins_wrapper.array[CHANNEL] = num_privatized_levels[CHANNEL] - 1; + + // Setup array wrapper for num output bins (because we can't pass static arrays as kernel parameters) + ArrayWrapper num_output_bins_wrapper; + for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL) + num_output_bins_wrapper.array[CHANNEL] = num_output_levels[CHANNEL] - 1; + + int histogram_init_block_threads = 256; + int histogram_init_grid_dims = (max_num_output_bins + histogram_init_block_threads - 1) / histogram_init_block_threads; + + // Log DeviceHistogramInitKernel configuration + if (debug_synchronous) CubLog("Invoking DeviceHistogramInitKernel<<<%d, %d, 0, %lld>>>()\n", + histogram_init_grid_dims, histogram_init_block_threads, (long long) stream); + + // Invoke histogram_init_kernel + histogram_init_kernel<<>>( + num_output_bins_wrapper, + d_output_histograms_wrapper, + tile_queue); + + // Log histogram_sweep_kernel configuration + if (debug_synchronous) CubLog("Invoking histogram_sweep_kernel<<<{%d, %d, %d}, %d, 0, %lld>>>(), %d pixels per thread, %d SM occupancy\n", + sweep_grid_dims.x, sweep_grid_dims.y, sweep_grid_dims.z, + histogram_sweep_config.block_threads, (long long) stream, histogram_sweep_config.pixels_per_thread, histogram_sweep_sm_occupancy); + + // Invoke histogram_sweep_kernel + histogram_sweep_kernel<<>>( + d_samples, + num_output_bins_wrapper, + num_privatized_bins_wrapper, + d_output_histograms_wrapper, + d_privatized_histograms_wrapper, + output_decode_op_wrapper, + privatized_decode_op_wrapper, + num_row_pixels, + num_rows, + row_stride_samples, + tiles_per_row, + tile_queue); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + } + while (0); + + return error; + + #endif // CUB_RUNTIME_ENABLED + } + + + + /** + * Dispatch routine for HistogramRange, specialized for sample types larger than 8bit + */ + CUB_RUNTIME_FUNCTION + static cudaError_t DispatchRange( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples). + CounterT* d_output_histograms[NUM_ACTIVE_CHANNELS], ///< [out] The pointers to the histogram counter output arrays, one for each active channel. For channeli, the allocation length of d_histograms[i] should be num_output_levels[i] - 1. + int num_output_levels[NUM_ACTIVE_CHANNELS], ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel. Implies that the number of bins for channeli is num_output_levels[i] - 1. + LevelT *d_levels[NUM_ACTIVE_CHANNELS], ///< [in] The pointers to the arrays of boundaries (levels), one for each active channel. Bin ranges are defined by consecutive boundary pairings: lower sample value boundaries are inclusive and upper sample value boundaries are exclusive. + OffsetT num_row_pixels, ///< [in] The number of multi-channel pixels per row in the region of interest + OffsetT num_rows, ///< [in] The number of rows in the region of interest + OffsetT row_stride_samples, ///< [in] The number of samples between starts of consecutive rows in the region of interest + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + Int2Type is_byte_sample) ///< [in] Marker type indicating whether or not SampleT is a 8b type + { + cudaError error = cudaSuccess; + do + { + // Get PTX version + int ptx_version; + #if (CUB_PTX_ARCH == 0) + if (CubDebug(error = PtxVersion(ptx_version))) break; + #else + ptx_version = CUB_PTX_ARCH; + #endif + + // Get kernel dispatch configurations + KernelConfig histogram_sweep_config; + if (CubDebug(error = InitConfigs(ptx_version, histogram_sweep_config))) + break; + + // Use the search transform op for converting samples to privatized bins + typedef SearchTransform PrivatizedDecodeOpT; + + // Use the pass-thru transform op for converting privatized bins to output bins + typedef PassThruTransform OutputDecodeOpT; + + PrivatizedDecodeOpT privatized_decode_op[NUM_ACTIVE_CHANNELS]; + OutputDecodeOpT output_decode_op[NUM_ACTIVE_CHANNELS]; + int max_levels = num_output_levels[0]; + + for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel) + { + privatized_decode_op[channel].Init(d_levels[channel], num_output_levels[channel]); + if (num_output_levels[channel] > max_levels) + max_levels = num_output_levels[channel]; + } + int max_num_output_bins = max_levels - 1; + + // Dispatch + if (max_num_output_bins > MAX_PRIVATIZED_SMEM_BINS) + { + // Too many bins to keep in shared memory. + const int PRIVATIZED_SMEM_BINS = 0; + + if (CubDebug(error = PrivatizedDispatch( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_output_histograms, + num_output_levels, + privatized_decode_op, + num_output_levels, + output_decode_op, + max_num_output_bins, + num_row_pixels, + num_rows, + row_stride_samples, + DeviceHistogramInitKernel, + DeviceHistogramSweepKernel, + histogram_sweep_config, + stream, + debug_synchronous))) break; + } + else + { + // Dispatch shared-privatized approach + const int PRIVATIZED_SMEM_BINS = MAX_PRIVATIZED_SMEM_BINS; + + if (CubDebug(error = PrivatizedDispatch( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_output_histograms, + num_output_levels, + privatized_decode_op, + num_output_levels, + output_decode_op, + max_num_output_bins, + num_row_pixels, + num_rows, + row_stride_samples, + DeviceHistogramInitKernel, + DeviceHistogramSweepKernel, + histogram_sweep_config, + stream, + debug_synchronous))) break; + } + + } while (0); + + return error; + } + + + /** + * Dispatch routine for HistogramRange, specialized for 8-bit sample types (computes 256-bin privatized histograms and then reduces to user-specified levels) + */ + CUB_RUNTIME_FUNCTION + static cudaError_t DispatchRange( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples). + CounterT* d_output_histograms[NUM_ACTIVE_CHANNELS], ///< [out] The pointers to the histogram counter output arrays, one for each active channel. For channeli, the allocation length of d_histograms[i] should be num_output_levels[i] - 1. + int num_output_levels[NUM_ACTIVE_CHANNELS], ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel. Implies that the number of bins for channeli is num_output_levels[i] - 1. + LevelT *d_levels[NUM_ACTIVE_CHANNELS], ///< [in] The pointers to the arrays of boundaries (levels), one for each active channel. Bin ranges are defined by consecutive boundary pairings: lower sample value boundaries are inclusive and upper sample value boundaries are exclusive. + OffsetT num_row_pixels, ///< [in] The number of multi-channel pixels per row in the region of interest + OffsetT num_rows, ///< [in] The number of rows in the region of interest + OffsetT row_stride_samples, ///< [in] The number of samples between starts of consecutive rows in the region of interest + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + Int2Type is_byte_sample) ///< [in] Marker type indicating whether or not SampleT is a 8b type + { + cudaError error = cudaSuccess; + do + { + // Get PTX version + int ptx_version; + #if (CUB_PTX_ARCH == 0) + if (CubDebug(error = PtxVersion(ptx_version))) break; + #else + ptx_version = CUB_PTX_ARCH; + #endif + + // Get kernel dispatch configurations + KernelConfig histogram_sweep_config; + if (CubDebug(error = InitConfigs(ptx_version, histogram_sweep_config))) + break; + + // Use the pass-thru transform op for converting samples to privatized bins + typedef PassThruTransform PrivatizedDecodeOpT; + + // Use the search transform op for converting privatized bins to output bins + typedef SearchTransform OutputDecodeOpT; + + int num_privatized_levels[NUM_ACTIVE_CHANNELS]; + PrivatizedDecodeOpT privatized_decode_op[NUM_ACTIVE_CHANNELS]; + OutputDecodeOpT output_decode_op[NUM_ACTIVE_CHANNELS]; + int max_levels = num_output_levels[0]; // Maximum number of levels in any channel + + for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel) + { + num_privatized_levels[channel] = 257; + output_decode_op[channel].Init(d_levels[channel], num_output_levels[channel]); + + if (num_output_levels[channel] > max_levels) + max_levels = num_output_levels[channel]; + } + int max_num_output_bins = max_levels - 1; + + const int PRIVATIZED_SMEM_BINS = 256; + + if (CubDebug(error = PrivatizedDispatch( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_output_histograms, + num_privatized_levels, + privatized_decode_op, + num_output_levels, + output_decode_op, + max_num_output_bins, + num_row_pixels, + num_rows, + row_stride_samples, + DeviceHistogramInitKernel, + DeviceHistogramSweepKernel, + histogram_sweep_config, + stream, + debug_synchronous))) break; + + } while (0); + + return error; + } + + + /** + * Dispatch routine for HistogramEven, specialized for sample types larger than 8-bit + */ + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t DispatchEven( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the input sequence of sample items. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples). + CounterT* d_output_histograms[NUM_ACTIVE_CHANNELS], ///< [out] The pointers to the histogram counter output arrays, one for each active channel. For channeli, the allocation length of d_histograms[i] should be num_output_levels[i] - 1. + int num_output_levels[NUM_ACTIVE_CHANNELS], ///< [in] The number of bin level boundaries for delineating histogram samples in each active channel. Implies that the number of bins for channeli is num_output_levels[i] - 1. + LevelT lower_level[NUM_ACTIVE_CHANNELS], ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel. + LevelT upper_level[NUM_ACTIVE_CHANNELS], ///< [in] The upper sample value bound (exclusive) for the highest histogram bin in each active channel. + OffsetT num_row_pixels, ///< [in] The number of multi-channel pixels per row in the region of interest + OffsetT num_rows, ///< [in] The number of rows in the region of interest + OffsetT row_stride_samples, ///< [in] The number of samples between starts of consecutive rows in the region of interest + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + Int2Type is_byte_sample) ///< [in] Marker type indicating whether or not SampleT is a 8b type + { + cudaError error = cudaSuccess; + do + { + // Get PTX version + int ptx_version; + #if (CUB_PTX_ARCH == 0) + if (CubDebug(error = PtxVersion(ptx_version))) break; + #else + ptx_version = CUB_PTX_ARCH; + #endif + + // Get kernel dispatch configurations + KernelConfig histogram_sweep_config; + if (CubDebug(error = InitConfigs(ptx_version, histogram_sweep_config))) + break; + + // Use the scale transform op for converting samples to privatized bins + typedef ScaleTransform PrivatizedDecodeOpT; + + // Use the pass-thru transform op for converting privatized bins to output bins + typedef PassThruTransform OutputDecodeOpT; + + PrivatizedDecodeOpT privatized_decode_op[NUM_ACTIVE_CHANNELS]; + OutputDecodeOpT output_decode_op[NUM_ACTIVE_CHANNELS]; + int max_levels = num_output_levels[0]; + + for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel) + { + int bins = num_output_levels[channel] - 1; + LevelT scale = (upper_level[channel] - lower_level[channel]) / bins; + + privatized_decode_op[channel].Init(num_output_levels[channel], upper_level[channel], lower_level[channel], scale); + + if (num_output_levels[channel] > max_levels) + max_levels = num_output_levels[channel]; + } + int max_num_output_bins = max_levels - 1; + + if (max_num_output_bins > MAX_PRIVATIZED_SMEM_BINS) + { + // Dispatch shared-privatized approach + const int PRIVATIZED_SMEM_BINS = 0; + + if (CubDebug(error = PrivatizedDispatch( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_output_histograms, + num_output_levels, + privatized_decode_op, + num_output_levels, + output_decode_op, + max_num_output_bins, + num_row_pixels, + num_rows, + row_stride_samples, + DeviceHistogramInitKernel, + DeviceHistogramSweepKernel, + histogram_sweep_config, + stream, + debug_synchronous))) break; + } + else + { + // Dispatch shared-privatized approach + const int PRIVATIZED_SMEM_BINS = MAX_PRIVATIZED_SMEM_BINS; + + if (CubDebug(error = PrivatizedDispatch( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_output_histograms, + num_output_levels, + privatized_decode_op, + num_output_levels, + output_decode_op, + max_num_output_bins, + num_row_pixels, + num_rows, + row_stride_samples, + DeviceHistogramInitKernel, + DeviceHistogramSweepKernel, + histogram_sweep_config, + stream, + debug_synchronous))) break; + } + } + while (0); + + return error; + } + + + /** + * Dispatch routine for HistogramEven, specialized for 8-bit sample types (computes 256-bin privatized histograms and then reduces to user-specified levels) + */ + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t DispatchEven( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SampleIteratorT d_samples, ///< [in] The pointer to the input sequence of sample items. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples). + CounterT* d_output_histograms[NUM_ACTIVE_CHANNELS], ///< [out] The pointers to the histogram counter output arrays, one for each active channel. For channeli, the allocation length of d_histograms[i] should be num_output_levels[i] - 1. + int num_output_levels[NUM_ACTIVE_CHANNELS], ///< [in] The number of bin level boundaries for delineating histogram samples in each active channel. Implies that the number of bins for channeli is num_output_levels[i] - 1. + LevelT lower_level[NUM_ACTIVE_CHANNELS], ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel. + LevelT upper_level[NUM_ACTIVE_CHANNELS], ///< [in] The upper sample value bound (exclusive) for the highest histogram bin in each active channel. + OffsetT num_row_pixels, ///< [in] The number of multi-channel pixels per row in the region of interest + OffsetT num_rows, ///< [in] The number of rows in the region of interest + OffsetT row_stride_samples, ///< [in] The number of samples between starts of consecutive rows in the region of interest + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + Int2Type is_byte_sample) ///< [in] Marker type indicating whether or not SampleT is a 8b type + { + cudaError error = cudaSuccess; + do + { + // Get PTX version + int ptx_version; + #if (CUB_PTX_ARCH == 0) + if (CubDebug(error = PtxVersion(ptx_version))) break; + #else + ptx_version = CUB_PTX_ARCH; + #endif + + // Get kernel dispatch configurations + KernelConfig histogram_sweep_config; + if (CubDebug(error = InitConfigs(ptx_version, histogram_sweep_config))) + break; + + // Use the pass-thru transform op for converting samples to privatized bins + typedef PassThruTransform PrivatizedDecodeOpT; + + // Use the scale transform op for converting privatized bins to output bins + typedef ScaleTransform OutputDecodeOpT; + + int num_privatized_levels[NUM_ACTIVE_CHANNELS]; + PrivatizedDecodeOpT privatized_decode_op[NUM_ACTIVE_CHANNELS]; + OutputDecodeOpT output_decode_op[NUM_ACTIVE_CHANNELS]; + int max_levels = num_output_levels[0]; + + for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel) + { + num_privatized_levels[channel] = 257; + + int bins = num_output_levels[channel] - 1; + LevelT scale = (upper_level[channel] - lower_level[channel]) / bins; + output_decode_op[channel].Init(num_output_levels[channel], upper_level[channel], lower_level[channel], scale); + + if (num_output_levels[channel] > max_levels) + max_levels = num_output_levels[channel]; + } + int max_num_output_bins = max_levels - 1; + + const int PRIVATIZED_SMEM_BINS = 256; + + if (CubDebug(error = PrivatizedDispatch( + d_temp_storage, + temp_storage_bytes, + d_samples, + d_output_histograms, + num_privatized_levels, + privatized_decode_op, + num_output_levels, + output_decode_op, + max_num_output_bins, + num_row_pixels, + num_rows, + row_stride_samples, + DeviceHistogramInitKernel, + DeviceHistogramSweepKernel, + histogram_sweep_config, + stream, + debug_synchronous))) break; + + } + while (0); + + return error; + } + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/dispatch/dispatch_radix_sort.cuh b/3rdparty/cub/cub/device/dispatch/dispatch_radix_sort.cuh new file mode 100644 index 00000000000..ccbdced3792 --- /dev/null +++ b/3rdparty/cub/cub/device/dispatch/dispatch_radix_sort.cuh @@ -0,0 +1,1128 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceRadixSort provides device-wide, parallel operations for computing a radix sort across a sequence of data items residing within global memory. + */ + +#pragma once + +#include +#include + +#include "../../agent/agent_radix_sort_upsweep.cuh" +#include "../../agent/agent_radix_sort_downsweep.cuh" +#include "../../agent/agent_scan.cuh" +#include "../../block/block_radix_sort.cuh" +#include "../../grid/grid_even_share.cuh" +#include "../../util_type.cuh" +#include "../../util_debug.cuh" +#include "../../util_device.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/****************************************************************************** + * Kernel entry points + *****************************************************************************/ + +/** + * Upsweep pass kernel entry point (multi-block). Computes privatized digit histograms, one per block. + */ +template < + typename AgentRadixSortUpsweepPolicy, ///< Parameterized AgentRadixSortUpsweepPolicy tuning policy type + bool DESCENDING, ///< Whether or not the sorted-order is high-to-low + typename Key, ///< Key type + typename OffsetT> ///< Signed integer type for global offsets +__launch_bounds__ (int(AgentRadixSortUpsweepPolicy::BLOCK_THREADS)) +__global__ void DeviceRadixSortUpsweepKernel( + Key *d_keys, ///< [in] Input keys buffer + OffsetT *d_spine, ///< [out] Privatized (per block) digit histograms (striped, i.e., 0s counts from each block, then 1s counts from each block, etc.) + OffsetT num_items, ///< [in] Total number of input data items + int current_bit, ///< [in] Bit position of current radix digit + int num_bits, ///< [in] Number of bits of current radix digit + GridEvenShare even_share) ///< [in] Even-share descriptor for mapping an equal number of tiles onto each thread block +{ + // Parameterize AgentRadixSortUpsweep type for the current configuration + typedef AgentRadixSortUpsweep AgentRadixSortUpsweepT; // Primary + + // Shared memory storage + __shared__ typename AgentRadixSortUpsweepT::TempStorage temp_storage; + + // Initialize even-share descriptor for this thread block + even_share.BlockInit(); + + OffsetT bin_count; + AgentRadixSortUpsweepT(temp_storage, d_keys, current_bit, num_bits).ProcessRegion( + even_share.block_offset, + even_share.block_end, + bin_count); + + // Write out digit counts (striped) + if (threadIdx.x < AgentRadixSortUpsweepT::RADIX_DIGITS) + { + int bin_idx = (DESCENDING) ? + AgentRadixSortUpsweepT::RADIX_DIGITS - threadIdx.x - 1 : + threadIdx.x; + + d_spine[(gridDim.x * bin_idx) + blockIdx.x] = bin_count; + } +} + + +/** + * Spine scan kernel entry point (single-block). Computes an exclusive prefix sum over the privatized digit histograms + */ +template < + typename AgentScanPolicy, ///< Parameterizable tuning policy type for cub::AgentScan abstraction + typename OffsetT> ///< Signed integer type for global offsets +__launch_bounds__ (int(AgentScanPolicy::BLOCK_THREADS), 1) +__global__ void RadixSortScanBinsKernel( + OffsetT *d_spine, ///< [in,out] Privatized (per block) digit histograms (striped, i.e., 0s counts from each block, then 1s counts from each block, etc.) + int num_counts) ///< [in] Total number of bin-counts +{ + // Parameterize the AgentScan type for the current configuration + typedef AgentScan AgentScanT; + + // Shared memory storage + __shared__ typename AgentScanT::TempStorage temp_storage; + + if (blockIdx.x > 0) return; + + // Block scan instance + AgentScanT block_scan(temp_storage, d_spine, d_spine, cub::Sum(), OffsetT(0)) ; + + // Process full input tiles + int block_offset = 0; + BlockScanRunningPrefixOp prefix_op(0, Sum()); + while (block_offset + AgentScanT::TILE_ITEMS <= num_counts) + { + block_scan.ConsumeTile(block_offset, prefix_op); + block_offset += AgentScanT::TILE_ITEMS; + } +} + + +/** + * Downsweep pass kernel entry point (multi-block). Scatters keys (and values) into corresponding bins for the current digit place. + */ +template < + typename AgentRadixSortDownsweepPolicy, ///< Parameterizable tuning policy type for cub::AgentRadixSortUpsweep abstraction + bool DESCENDING, ///< Whether or not the sorted-order is high-to-low + typename Key, ///< Key type + typename Value, ///< Value type + typename OffsetT> ///< Signed integer type for global offsets +__launch_bounds__ (int(AgentRadixSortDownsweepPolicy::BLOCK_THREADS)) +__global__ void DeviceRadixSortDownsweepKernel( + Key *d_keys_in, ///< [in] Input keys ping buffer + Key *d_keys_out, ///< [in] Output keys pong buffer + Value *d_values_in, ///< [in] Input values ping buffer + Value *d_values_out, ///< [in] Output values pong buffer + OffsetT *d_spine, ///< [in] Scan of privatized (per block) digit histograms (striped, i.e., 0s counts from each block, then 1s counts from each block, etc.) + OffsetT num_items, ///< [in] Total number of input data items + int current_bit, ///< [in] Bit position of current radix digit + int num_bits, ///< [in] Number of bits of current radix digit + GridEvenShare even_share) ///< [in] Even-share descriptor for mapping an equal number of tiles onto each thread block +{ + // Parameterize AgentRadixSortDownsweep type for the current configuration + typedef AgentRadixSortDownsweep AgentRadixSortDownsweepT; + + // Shared memory storage + __shared__ typename AgentRadixSortDownsweepT::TempStorage temp_storage; + + // Initialize even-share descriptor for this thread block + even_share.BlockInit(); + + // Process input tiles + AgentRadixSortDownsweepT(temp_storage, num_items, d_spine, d_keys_in, d_keys_out, d_values_in, d_values_out, current_bit, num_bits).ProcessRegion( + even_share.block_offset, + even_share.block_end); +} + + +/** + * Single pass kernel entry point (single-block). Fully sorts a tile of input. + */ +template < + typename AgentRadixSortDownsweepPolicy, ///< Parameterizable tuning policy type for cub::AgentRadixSortUpsweep abstraction + bool DESCENDING, ///< Whether or not the sorted-order is high-to-low + typename KeyT, ///< Key type + typename ValueT, ///< Value type + typename OffsetT> ///< Signed integer type for global offsets +__launch_bounds__ (int(AgentRadixSortDownsweepPolicy::BLOCK_THREADS), 1) +__global__ void DeviceRadixSortSingleKernel( + KeyT *d_keys_in, ///< [in] Input keys ping buffer + KeyT *d_keys_out, ///< [in] Output keys pong buffer + ValueT *d_values_in, ///< [in] Input values ping buffer + ValueT *d_values_out, ///< [in] Output values pong buffer + OffsetT num_items, ///< [in] Total number of input data items + int current_bit, ///< [in] Bit position of current radix digit + int end_bit) ///< [in] The past-the-end (most-significant) bit index needed for key comparison +{ + // Constants + enum + { + BLOCK_THREADS = AgentRadixSortDownsweepPolicy::BLOCK_THREADS, + ITEMS_PER_THREAD = AgentRadixSortDownsweepPolicy::ITEMS_PER_THREAD, + KEYS_ONLY = Equals::VALUE, + }; + + // BlockRadixSort type + typedef BlockRadixSort< + KeyT, + BLOCK_THREADS, + ITEMS_PER_THREAD, + ValueT, + AgentRadixSortDownsweepPolicy::RADIX_BITS, + AgentRadixSortDownsweepPolicy::MEMOIZE_OUTER_SCAN, + AgentRadixSortDownsweepPolicy::INNER_SCAN_ALGORITHM, + AgentRadixSortDownsweepPolicy::SMEM_CONFIG> + BlockRadixSortT; + + // BlockLoad type (keys) + typedef BlockLoad< + KeyT*, + BLOCK_THREADS, + ITEMS_PER_THREAD, + AgentRadixSortDownsweepPolicy::LOAD_ALGORITHM> BlockLoadKeys; + + // BlockLoad type (values) + typedef BlockLoad< + ValueT*, + BLOCK_THREADS, + ITEMS_PER_THREAD, + AgentRadixSortDownsweepPolicy::LOAD_ALGORITHM> BlockLoadValues; + + + // Shared memory storage + __shared__ union + { + typename BlockRadixSortT::TempStorage sort; + typename BlockLoadKeys::TempStorage load_keys; + typename BlockLoadValues::TempStorage load_values; + + } temp_storage; + + // Keys and values for the block + KeyT keys[ITEMS_PER_THREAD]; + ValueT values[ITEMS_PER_THREAD]; + + // Get default (min/max) value for out-of-bounds keys + typedef typename Traits::UnsignedBits UnsignedBitsT; + UnsignedBitsT default_key_bits = (DESCENDING) ? Traits::MIN_KEY : Traits::MAX_KEY; + KeyT default_key = reinterpret_cast(default_key_bits); + + // Load keys + BlockLoadKeys(temp_storage.load_keys).Load(d_keys_in, keys, num_items, default_key); + + __syncthreads(); + + // Load values + if (!KEYS_ONLY) + { + BlockLoadValues(temp_storage.load_values).Load(d_values_in, values, num_items); + + __syncthreads(); + } + + // Sort tile + BlockRadixSortT(temp_storage.sort).SortBlockedToStriped( + keys, + values, + current_bit, + end_bit, + Int2Type(), + Int2Type()); + + // Store keys and values + #pragma unroll + for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM) + { + int item_offset = ITEM * BLOCK_THREADS + threadIdx.x; + if (item_offset < num_items) + { + d_keys_out[item_offset] = keys[ITEM]; + if (!KEYS_ONLY) + d_values_out[item_offset] = values[ITEM]; + } + } +} + + + +/****************************************************************************** + * Dispatch + ******************************************************************************/ + +/** + * Utility class for dispatching the appropriately-tuned kernels for DeviceRadixSort + */ +template < + bool DESCENDING, ///< Whether or not the sorted-order is high-to-low + bool ALT_STORAGE, ///< Whether or not we need a third buffer to either (a) prevent modification to input buffer, or (b) place output into a specific buffer (instead of a pointer to one of the double buffers) + typename Key, ///< Key type + typename Value, ///< Value type + typename OffsetT> ///< Signed integer type for global offsets +struct DispatchRadixSort +{ + /****************************************************************************** + * Constants + ******************************************************************************/ + + enum + { + // Whether this is a keys-only (or key-value) sort + KEYS_ONLY = (Equals::VALUE), + + // Relative size of Key type to a 4-byte word + SCALE_FACTOR_4B = (CUB_MAX(sizeof(Key), sizeof(Value)) + 3) / 4, + }; + + /****************************************************************************** + * Tuning policies + ******************************************************************************/ + + /// SM52 + struct Policy520 + { + enum { + PRIMARY_RADIX_BITS = 5, + ALT_RADIX_BITS = PRIMARY_RADIX_BITS - 1, + }; + + typedef AgentRadixSortUpsweepPolicy <256, CUB_MAX(1, 16 / SCALE_FACTOR_4B), LOAD_DEFAULT, PRIMARY_RADIX_BITS> UpsweepPolicy; + typedef AgentRadixSortUpsweepPolicy <256, CUB_MAX(1, 16 / SCALE_FACTOR_4B), LOAD_DEFAULT, ALT_RADIX_BITS> AltUpsweepPolicy; + + typedef AgentScanPolicy <512, 23, BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, BLOCK_STORE_WARP_TRANSPOSE, BLOCK_SCAN_RAKING_MEMOIZE> ScanPolicy; + + typedef AgentRadixSortDownsweepPolicy <256, CUB_MAX(1, 16 / SCALE_FACTOR_4B), BLOCK_LOAD_DIRECT, LOAD_LDG, true, BLOCK_SCAN_RAKING_MEMOIZE, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, PRIMARY_RADIX_BITS> DownsweepPolicy; + typedef AgentRadixSortDownsweepPolicy <256, CUB_MAX(1, 16 / SCALE_FACTOR_4B), BLOCK_LOAD_DIRECT, LOAD_LDG, true, BLOCK_SCAN_RAKING_MEMOIZE, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, ALT_RADIX_BITS> AltDownsweepPolicy; + + typedef AgentRadixSortDownsweepPolicy <256, CUB_MAX(1, 19 / SCALE_FACTOR_4B), BLOCK_LOAD_DIRECT, LOAD_LDG, true, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, PRIMARY_RADIX_BITS> SinglePolicy; + }; + + + /// SM35 + struct Policy350 + { + enum { + PRIMARY_RADIX_BITS = 5, + ALT_RADIX_BITS = PRIMARY_RADIX_BITS - 1, + }; + + // Primary UpsweepPolicy (passes having digit-length RADIX_BITS) + typedef AgentRadixSortUpsweepPolicy <64, CUB_MAX(1, 18 / SCALE_FACTOR_4B), LOAD_LDG, PRIMARY_RADIX_BITS> UpsweepPolicyKeys; + typedef AgentRadixSortUpsweepPolicy <128, CUB_MAX(1, 15 / SCALE_FACTOR_4B), LOAD_LDG, PRIMARY_RADIX_BITS> UpsweepPolicyPairs; + typedef typename If::Type UpsweepPolicy; + + // Alternate UpsweepPolicy (passes having digit-length ALT_RADIX_BITS) + typedef AgentRadixSortUpsweepPolicy <64, CUB_MAX(1, 22 / SCALE_FACTOR_4B), LOAD_LDG, ALT_RADIX_BITS> AltUpsweepPolicyKeys; + typedef AgentRadixSortUpsweepPolicy <128, CUB_MAX(1, 15 / SCALE_FACTOR_4B), LOAD_LDG, ALT_RADIX_BITS> AltUpsweepPolicyPairs; + typedef typename If::Type AltUpsweepPolicy; + + // ScanPolicy + typedef AgentScanPolicy <1024, 4, BLOCK_LOAD_VECTORIZE, LOAD_DEFAULT, BLOCK_STORE_VECTORIZE, BLOCK_SCAN_WARP_SCANS> ScanPolicy; + + // Primary DownsweepPolicy + typedef AgentRadixSortDownsweepPolicy <64, CUB_MAX(1, 18 / SCALE_FACTOR_4B), BLOCK_LOAD_DIRECT, LOAD_LDG, true, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, PRIMARY_RADIX_BITS> DownsweepPolicyKeys; + typedef AgentRadixSortDownsweepPolicy <128, CUB_MAX(1, 15 / SCALE_FACTOR_4B), BLOCK_LOAD_DIRECT, LOAD_LDG, true, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, PRIMARY_RADIX_BITS> DownsweepPolicyPairs; + typedef typename If::Type DownsweepPolicy; + + // Alternate DownsweepPolicy for ALT_RADIX_BITS-bit passes + typedef AgentRadixSortDownsweepPolicy <128, CUB_MAX(1, 11 / SCALE_FACTOR_4B), BLOCK_LOAD_DIRECT, LOAD_LDG, true, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, ALT_RADIX_BITS> AltDownsweepPolicyKeys; + typedef AgentRadixSortDownsweepPolicy <128, CUB_MAX(1, 15 / SCALE_FACTOR_4B), BLOCK_LOAD_DIRECT, LOAD_LDG, true, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, ALT_RADIX_BITS> AltDownsweepPolicyPairs; + typedef typename If::Type AltDownsweepPolicy; + + typedef DownsweepPolicy SinglePolicy; + }; + + + /// SM30 + struct Policy300 + { + enum { + PRIMARY_RADIX_BITS = 5, + ALT_RADIX_BITS = PRIMARY_RADIX_BITS - 1, + }; + + // UpsweepPolicy + typedef AgentRadixSortUpsweepPolicy <256, CUB_MAX(1, 7 / SCALE_FACTOR_4B), LOAD_DEFAULT, PRIMARY_RADIX_BITS> UpsweepPolicyKeys; + typedef AgentRadixSortUpsweepPolicy <256, CUB_MAX(1, 5 / SCALE_FACTOR_4B), LOAD_DEFAULT, PRIMARY_RADIX_BITS> UpsweepPolicyPairs; + typedef typename If::Type UpsweepPolicy; + + // Alternate UpsweepPolicy for ALT_RADIX_BITS-bit passes + typedef AgentRadixSortUpsweepPolicy <256, CUB_MAX(1, 7 / SCALE_FACTOR_4B), LOAD_DEFAULT, ALT_RADIX_BITS> AltUpsweepPolicyKeys; + typedef AgentRadixSortUpsweepPolicy <256, CUB_MAX(1, 5 / SCALE_FACTOR_4B), LOAD_DEFAULT, ALT_RADIX_BITS> AltUpsweepPolicyPairs; + typedef typename If::Type AltUpsweepPolicy; + + // ScanPolicy + typedef AgentScanPolicy <1024, 4, BLOCK_LOAD_VECTORIZE, LOAD_DEFAULT, BLOCK_STORE_VECTORIZE, BLOCK_SCAN_RAKING_MEMOIZE> ScanPolicy; + + // DownsweepPolicy + typedef AgentRadixSortDownsweepPolicy <128, CUB_MAX(1, 14 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, PRIMARY_RADIX_BITS> DownsweepPolicyKeys; + typedef AgentRadixSortDownsweepPolicy <128, CUB_MAX(1, 10 / SCALE_FACTOR_4B), BLOCK_LOAD_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, PRIMARY_RADIX_BITS> DownsweepPolicyPairs; + typedef typename If::Type DownsweepPolicy; + + // Alternate DownsweepPolicy for ALT_RADIX_BITS-bit passes + typedef AgentRadixSortDownsweepPolicy <128, CUB_MAX(1, 14 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, ALT_RADIX_BITS> AltDownsweepPolicyKeys; + typedef AgentRadixSortDownsweepPolicy <128, CUB_MAX(1, 10 / SCALE_FACTOR_4B), BLOCK_LOAD_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, ALT_RADIX_BITS> AltDownsweepPolicyPairs; + typedef typename If::Type AltDownsweepPolicy; + + typedef DownsweepPolicy SinglePolicy; + }; + + + /// SM20 + struct Policy200 + { + enum { + PRIMARY_RADIX_BITS = 5, + ALT_RADIX_BITS = PRIMARY_RADIX_BITS - 1, + }; + + // Primary UpsweepPolicy (passes having digit-length RADIX_BITS) + typedef AgentRadixSortUpsweepPolicy <64, CUB_MAX(1, 18 / SCALE_FACTOR_4B), LOAD_DEFAULT, PRIMARY_RADIX_BITS> UpsweepPolicyKeys; + typedef AgentRadixSortUpsweepPolicy <128, CUB_MAX(1, 13 / SCALE_FACTOR_4B), LOAD_DEFAULT, PRIMARY_RADIX_BITS> UpsweepPolicyPairs; + typedef typename If::Type UpsweepPolicy; + + // Alternate UpsweepPolicy for ALT_RADIX_BITS-bit passes + typedef AgentRadixSortUpsweepPolicy <64, CUB_MAX(1, 18 / SCALE_FACTOR_4B), LOAD_DEFAULT, ALT_RADIX_BITS> AltUpsweepPolicyKeys; + typedef AgentRadixSortUpsweepPolicy <128, CUB_MAX(1, 13 / SCALE_FACTOR_4B), LOAD_DEFAULT, ALT_RADIX_BITS> AltUpsweepPolicyPairs; + typedef typename If::Type AltUpsweepPolicy; + + // ScanPolicy + typedef AgentScanPolicy <512, 4, BLOCK_LOAD_VECTORIZE, LOAD_DEFAULT, BLOCK_STORE_VECTORIZE, BLOCK_SCAN_RAKING_MEMOIZE> ScanPolicy; + + // DownsweepPolicy + typedef AgentRadixSortDownsweepPolicy <64, CUB_MAX(1, 18 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, PRIMARY_RADIX_BITS> DownsweepPolicyKeys; + typedef AgentRadixSortDownsweepPolicy <128, CUB_MAX(1, 13 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, PRIMARY_RADIX_BITS> DownsweepPolicyPairs; + typedef typename If::Type DownsweepPolicy; + + // Alternate DownsweepPolicy for ALT_RADIX_BITS-bit passes + typedef AgentRadixSortDownsweepPolicy <64, CUB_MAX(1, 18 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, ALT_RADIX_BITS> AltDownsweepPolicyKeys; + typedef AgentRadixSortDownsweepPolicy <128, CUB_MAX(1, 13 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, ALT_RADIX_BITS> AltDownsweepPolicyPairs; + typedef typename If::Type AltDownsweepPolicy; + + typedef DownsweepPolicy SinglePolicy; + }; + + + /// SM13 + struct Policy130 + { + enum { + PRIMARY_RADIX_BITS = 5, + ALT_RADIX_BITS = PRIMARY_RADIX_BITS - 1, + }; + + // UpsweepPolicy + typedef AgentRadixSortUpsweepPolicy <128, CUB_MAX(1, 19 / SCALE_FACTOR_4B), LOAD_DEFAULT, PRIMARY_RADIX_BITS> UpsweepPolicyKeys; + typedef AgentRadixSortUpsweepPolicy <128, CUB_MAX(1, 19 / SCALE_FACTOR_4B), LOAD_DEFAULT, PRIMARY_RADIX_BITS> UpsweepPolicyPairs; + typedef typename If::Type UpsweepPolicy; + + // Alternate UpsweepPolicy for ALT_RADIX_BITS-bit passes + typedef AgentRadixSortUpsweepPolicy <128, CUB_MAX(1, 15 / SCALE_FACTOR_4B), LOAD_DEFAULT, ALT_RADIX_BITS> AltUpsweepPolicyKeys; + typedef AgentRadixSortUpsweepPolicy <128, CUB_MAX(1, 15 / SCALE_FACTOR_4B), LOAD_DEFAULT, ALT_RADIX_BITS> AltUpsweepPolicyPairs; + typedef typename If::Type AltUpsweepPolicy; + + // ScanPolicy + typedef AgentScanPolicy <256, 4, BLOCK_LOAD_VECTORIZE, LOAD_DEFAULT, BLOCK_STORE_VECTORIZE, BLOCK_SCAN_WARP_SCANS> ScanPolicy; + + // DownsweepPolicy + typedef AgentRadixSortDownsweepPolicy <64, CUB_MAX(1, 19 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, PRIMARY_RADIX_BITS> DownsweepPolicyKeys; + typedef AgentRadixSortDownsweepPolicy <64, CUB_MAX(1, 19 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, PRIMARY_RADIX_BITS> DownsweepPolicyPairs; + typedef typename If::Type DownsweepPolicy; + + // Alternate DownsweepPolicy for ALT_RADIX_BITS-bit passes + typedef AgentRadixSortDownsweepPolicy <128, CUB_MAX(1, 15 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, ALT_RADIX_BITS> AltDownsweepPolicyKeys; + typedef AgentRadixSortDownsweepPolicy <128, CUB_MAX(1, 15 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, ALT_RADIX_BITS> AltDownsweepPolicyPairs; + typedef typename If::Type AltDownsweepPolicy; + + typedef DownsweepPolicy SinglePolicy; + }; + + + /// SM10 + struct Policy100 + { + enum { + PRIMARY_RADIX_BITS = 4, + ALT_RADIX_BITS = PRIMARY_RADIX_BITS - 1, + }; + + // UpsweepPolicy + typedef AgentRadixSortUpsweepPolicy <64, CUB_MAX(1, 9 / SCALE_FACTOR_4B), LOAD_DEFAULT, PRIMARY_RADIX_BITS> UpsweepPolicy; + + // Alternate UpsweepPolicy for ALT_RADIX_BITS-bit passes + typedef AgentRadixSortUpsweepPolicy <64, CUB_MAX(1, 9 / SCALE_FACTOR_4B), LOAD_DEFAULT, ALT_RADIX_BITS> AltUpsweepPolicy; + + // ScanPolicy + typedef AgentScanPolicy <256, 4, BLOCK_LOAD_VECTORIZE, LOAD_DEFAULT, BLOCK_STORE_VECTORIZE, BLOCK_SCAN_RAKING_MEMOIZE> ScanPolicy; + + // DownsweepPolicy + typedef AgentRadixSortDownsweepPolicy <64, CUB_MAX(1, 9 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, PRIMARY_RADIX_BITS> DownsweepPolicy; + + // Alternate DownsweepPolicy for ALT_RADIX_BITS-bit passes + typedef AgentRadixSortDownsweepPolicy <64, CUB_MAX(1, 9 / SCALE_FACTOR_4B), BLOCK_LOAD_WARP_TRANSPOSE, LOAD_DEFAULT, false, BLOCK_SCAN_WARP_SCANS, RADIX_SORT_SCATTER_TWO_PHASE, cudaSharedMemBankSizeFourByte, ALT_RADIX_BITS> AltDownsweepPolicy; + + typedef DownsweepPolicy SinglePolicy; + }; + + + /****************************************************************************** + * Tuning policies of current PTX compiler pass + ******************************************************************************/ + +#if (CUB_PTX_ARCH >= 520) + typedef Policy520 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 350) + typedef Policy350 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 300) + typedef Policy300 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 200) + typedef Policy200 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 130) + typedef Policy130 PtxPolicy; + +#else + typedef Policy100 PtxPolicy; + +#endif + + // "Opaque" policies (whose parameterizations aren't reflected in the type signature) + struct PtxUpsweepPolicy : PtxPolicy::UpsweepPolicy {}; + struct PtxAltUpsweepPolicy : PtxPolicy::AltUpsweepPolicy {}; + struct PtxScanPolicy : PtxPolicy::ScanPolicy {}; + struct PtxDownsweepPolicy : PtxPolicy::DownsweepPolicy {}; + struct PtxAltDownsweepPolicy : PtxPolicy::AltDownsweepPolicy {}; + struct PtxSinglePolicy : PtxPolicy::SinglePolicy {}; + + + /****************************************************************************** + * Utilities + ******************************************************************************/ + + /** + * Initialize kernel dispatch configurations with the policies corresponding to the PTX assembly we will use + */ + template < + typename Policy, + typename KernelConfig, + typename UpsweepKernelPtr, ///< Function type of cub::DeviceRadixSortUpsweepKernel + typename ScanKernelPtr, ///< Function type of cub::SpineScanKernel + typename DownsweepKernelPtr, ///< Function type of cub::DeviceRadixSortDownsweepKernel + typename SingleKernelPtr> ///< Function type of cub::DeviceRadixSortSingleKernel + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t InitConfigs( + int sm_version, + int sm_count, + KernelConfig &upsweep_config, + KernelConfig &alt_upsweep_config, + KernelConfig &scan_config, + KernelConfig &downsweep_config, + KernelConfig &alt_downsweep_config, + KernelConfig &single_config, + UpsweepKernelPtr upsweep_kernel, + UpsweepKernelPtr alt_upsweep_kernel, + ScanKernelPtr scan_kernel, + DownsweepKernelPtr downsweep_kernel, + DownsweepKernelPtr alt_downsweep_kernel, + SingleKernelPtr single_kernel) + { + cudaError_t error; + do { + if (CubDebug(error = upsweep_config.template InitUpsweepPolicy( sm_version, sm_count, upsweep_kernel))) break; + if (CubDebug(error = alt_upsweep_config.template InitUpsweepPolicy( sm_version, sm_count, alt_upsweep_kernel))) break; + if (CubDebug(error = scan_config.template InitScanPolicy( sm_version, sm_count, scan_kernel))) break; + if (CubDebug(error = downsweep_config.template InitDownsweepPolicy( sm_version, sm_count, downsweep_kernel))) break; + if (CubDebug(error = alt_downsweep_config.template InitDownsweepPolicy( sm_version, sm_count, alt_downsweep_kernel))) break; + if (CubDebug(error = single_config.template InitSinglePolicy( sm_version, sm_count, single_kernel))) break; + + } while (0); + + return error; + } + + + /** + * Initialize kernel dispatch configurations with the policies corresponding to the PTX assembly we will use + */ + template < + typename KernelConfig, + typename UpsweepKernelPtr, ///< Function type of cub::DeviceRadixSortUpsweepKernel + typename ScanKernelPtr, ///< Function type of cub::SpineScanKernel + typename DownsweepKernelPtr, ///< Function type of cub::DeviceRadixSortDownsweepKernel + typename SingleKernelPtr> ///< Function type of cub::DeviceRadixSortSingleKernel + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t InitConfigs( + int ptx_version, + int sm_version, + int sm_count, + KernelConfig &upsweep_config, + KernelConfig &alt_upsweep_config, + KernelConfig &scan_config, + KernelConfig &downsweep_config, + KernelConfig &alt_downsweep_config, + KernelConfig &single_config, + UpsweepKernelPtr upsweep_kernel, + UpsweepKernelPtr alt_upsweep_kernel, + ScanKernelPtr scan_kernel, + DownsweepKernelPtr downsweep_kernel, + DownsweepKernelPtr alt_downsweep_kernel, + SingleKernelPtr single_kernel) + { + #if (CUB_PTX_ARCH > 0) + + // We're on the device, so initialize the kernel dispatch configurations with the current PTX policy + cudaError_t error; + do { + + if (CubDebug(error = upsweep_config.template InitUpsweepPolicy( sm_version, sm_count, upsweep_kernel))) break; + if (CubDebug(error = alt_upsweep_config.template InitUpsweepPolicy( sm_version, sm_count, alt_upsweep_kernel))) break; + if (CubDebug(error = scan_config.template InitScanPolicy( sm_version, sm_count, scan_kernel))) break; + if (CubDebug(error = downsweep_config.template InitDownsweepPolicy( sm_version, sm_count, downsweep_kernel))) break; + if (CubDebug(error = alt_downsweep_config.template InitDownsweepPolicy( sm_version, sm_count, alt_downsweep_kernel))) break; + if (CubDebug(error = single_config.template InitSinglePolicy( sm_version, sm_count, single_kernel))) break; + + } while (0); + + return error; + + #else + + // We're on the host, so lookup and initialize the kernel dispatch configurations with the policies that match the device's PTX version + cudaError_t error; + if (ptx_version >= 520) + { + error = InitConfigs(sm_version, sm_count, upsweep_config, alt_upsweep_config, scan_config, downsweep_config, alt_downsweep_config, single_config, upsweep_kernel, alt_upsweep_kernel, scan_kernel, downsweep_kernel, alt_downsweep_kernel, single_kernel); + } + else if (ptx_version >= 350) + { + error = InitConfigs(sm_version, sm_count, upsweep_config, alt_upsweep_config, scan_config, downsweep_config, alt_downsweep_config, single_config, upsweep_kernel, alt_upsweep_kernel, scan_kernel, downsweep_kernel, alt_downsweep_kernel, single_kernel); + } + else if (ptx_version >= 300) + { + error = InitConfigs(sm_version, sm_count, upsweep_config, alt_upsweep_config, scan_config, downsweep_config, alt_downsweep_config, single_config, upsweep_kernel, alt_upsweep_kernel, scan_kernel, downsweep_kernel, alt_downsweep_kernel, single_kernel); + } + else if (ptx_version >= 200) + { + error = InitConfigs(sm_version, sm_count, upsweep_config, alt_upsweep_config, scan_config, downsweep_config, alt_downsweep_config, single_config, upsweep_kernel, alt_upsweep_kernel, scan_kernel, downsweep_kernel, alt_downsweep_kernel, single_kernel); + } + else if (ptx_version >= 130) + { + error = InitConfigs(sm_version, sm_count, upsweep_config, alt_upsweep_config, scan_config, downsweep_config, alt_downsweep_config, single_config, upsweep_kernel, alt_upsweep_kernel, scan_kernel, downsweep_kernel, alt_downsweep_kernel, single_kernel); + } + else + { + error = InitConfigs(sm_version, sm_count, upsweep_config, alt_upsweep_config, scan_config, downsweep_config, alt_downsweep_config, single_config, upsweep_kernel, alt_upsweep_kernel, scan_kernel, downsweep_kernel, alt_downsweep_kernel, single_kernel); + } + + return error; + + #endif + } + + + + /** + * Kernel kernel dispatch configurations + */ + struct KernelConfig + { + int block_threads; + int items_per_thread; + int tile_size; + int radix_bits; + int sm_occupancy; + int max_grid_size; + int subscription_factor; + + template + CUB_RUNTIME_FUNCTION __forceinline__ cudaError_t InitUpsweepPolicy( + int sm_version, int sm_count, UpsweepKernelPtr upsweep_kernel) + { + block_threads = UpsweepPolicy::BLOCK_THREADS; + items_per_thread = UpsweepPolicy::ITEMS_PER_THREAD; + radix_bits = UpsweepPolicy::RADIX_BITS; + tile_size = block_threads * items_per_thread; + cudaError_t retval = MaxSmOccupancy(sm_occupancy, sm_version, upsweep_kernel, block_threads); + subscription_factor = CUB_SUBSCRIPTION_FACTOR(sm_version); + max_grid_size = (sm_occupancy * sm_count) * subscription_factor; + + return retval; + } + + template + CUB_RUNTIME_FUNCTION __forceinline__ cudaError_t InitScanPolicy( + int sm_version, int sm_count, ScanKernelPtr scan_kernel) + { + block_threads = ScanPolicy::BLOCK_THREADS; + items_per_thread = ScanPolicy::ITEMS_PER_THREAD; + radix_bits = 0; + tile_size = block_threads * items_per_thread; + sm_occupancy = 1; + subscription_factor = 1; + max_grid_size = 1; + + return cudaSuccess; + } + + template + CUB_RUNTIME_FUNCTION __forceinline__ cudaError_t InitDownsweepPolicy( + int sm_version, int sm_count, DownsweepKernelPtr downsweep_kernel) + { + block_threads = DownsweepPolicy::BLOCK_THREADS; + items_per_thread = DownsweepPolicy::ITEMS_PER_THREAD; + radix_bits = DownsweepPolicy::RADIX_BITS; + tile_size = block_threads * items_per_thread; + cudaError_t retval = MaxSmOccupancy(sm_occupancy, sm_version, downsweep_kernel, block_threads); + subscription_factor = CUB_SUBSCRIPTION_FACTOR(sm_version); + max_grid_size = (sm_occupancy * sm_count) * subscription_factor; + + return retval; + } + + template + CUB_RUNTIME_FUNCTION __forceinline__ cudaError_t InitSinglePolicy( + int sm_version, int sm_count, SingleKernelPtr single_kernel) + { + block_threads = SinglePolicy::BLOCK_THREADS; + items_per_thread = SinglePolicy::ITEMS_PER_THREAD; + radix_bits = SinglePolicy::RADIX_BITS; + tile_size = block_threads * items_per_thread; + sm_occupancy = 1; + subscription_factor = 1; + max_grid_size = 1; + + return cudaSuccess; + } + + }; + + + /****************************************************************************** + * Dispatch entrypoints + ******************************************************************************/ + + /** + * Internal dispatch routine for computing a device-wide radix sort using the + * specified kernel functions. + */ + template < + typename UpsweepKernelPtr, ///< Function type of cub::DeviceRadixSortUpsweepKernel + typename ScanKernelPtr, ///< Function type of cub::SpineScanKernel + typename DownsweepKernelPtr> ///< Function type of cub::DeviceRadixSortUpsweepKernel + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t DispatchPass( + Key *d_keys_in, + Key *d_keys_out, + Value *d_values_in, + Value *d_values_out, + OffsetT *d_spine, ///< [in] Digit count histograms per thread block + int spine_length, ///< [in] Number of histogram counters + OffsetT num_items, ///< [in] Number of items to reduce + int current_bit, ///< [in] The beginning (least-significant) bit index needed for key comparison + int pass_bits, ///< [in] The number of bits needed for key comparison (less than or equal to radix digit size for this pass) + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + KernelConfig &upsweep_config, ///< [in] Dispatch parameters that match the policy that \p upsweep_kernel was compiled for + KernelConfig &scan_config, ///< [in] Dispatch parameters that match the policy that \p scan_kernel was compiled for + KernelConfig &downsweep_config, ///< [in] Dispatch parameters that match the policy that \p downsweep_kernel was compiled for + UpsweepKernelPtr upsweep_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceRadixSortUpsweepKernel + ScanKernelPtr scan_kernel, ///< [in] Kernel function pointer to parameterization of cub::SpineScanKernel + DownsweepKernelPtr downsweep_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceRadixSortUpsweepKernel + GridEvenShare &even_share) ///< [in] Description of work assignment to CTAs + { +#ifndef CUB_RUNTIME_ENABLED + + // Kernel launch not supported from this device + return CubDebug(cudaErrorNotSupported); + +#else + + cudaError error = cudaSuccess; + do + { + // Log upsweep_kernel configuration + if (debug_synchronous) + CubLog("Invoking upsweep_kernel<<<%d, %d, 0, %lld>>>(), %d items per thread, %d SM occupancy, current bit %d, bit_grain %d\n", + even_share.grid_size, upsweep_config.block_threads, (long long) stream, upsweep_config.items_per_thread, upsweep_config.sm_occupancy, current_bit, downsweep_config.radix_bits); + + // Invoke upsweep_kernel with same grid size as downsweep_kernel + upsweep_kernel<<>>( + d_keys_in, + d_spine, + num_items, + current_bit, + pass_bits, + even_share); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + // Log scan_kernel configuration + if (debug_synchronous) CubLog("Invoking scan_kernel<<<%d, %d, 0, %lld>>>(), %d items per thread\n", + 1, scan_config.block_threads, (long long) stream, scan_config.items_per_thread); + + // Invoke scan_kernel + scan_kernel<<<1, scan_config.block_threads, 0, stream>>>( + d_spine, + spine_length); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + // Log downsweep_kernel configuration + if (debug_synchronous) CubLog("Invoking downsweep_kernel<<<%d, %d, 0, %lld>>>(), %d items per thread, %d SM occupancy\n", + even_share.grid_size, downsweep_config.block_threads, (long long) stream, downsweep_config.items_per_thread, downsweep_config.sm_occupancy); + + // Invoke downsweep_kernel + downsweep_kernel<<>>( + d_keys_in, + d_keys_out, + d_values_in, + d_values_out, + d_spine, + num_items, + current_bit, + pass_bits, + even_share); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + } + while (0); + + return error; + +#endif // CUB_RUNTIME_ENABLED + } + + + + + /** + * Internal dispatch routine + */ + template < + typename UpsweepKernelPtr, ///< Function type of cub::DeviceRadixSortUpsweepKernel + typename ScanKernelPtr, ///< Function type of cub::SpineScanKernel + typename DownsweepKernelPtr, ///< Function type of cub::DeviceRadixSortDownsweepKernel + typename SingleKernelPtr> ///< Function type of cub::DeviceRadixSortSingleKernel + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + DoubleBuffer &d_keys, ///< [in,out] Double-buffer whose current buffer contains the unsorted input keys and, upon return, is updated to point to the sorted output keys + DoubleBuffer &d_values, ///< [in,out] Double-buffer whose current buffer contains the unsorted input values and, upon return, is updated to point to the sorted output values + OffsetT num_items, ///< [in] Number of items to reduce + int begin_bit, ///< [in] The beginning (least-significant) bit index needed for key comparison + int end_bit, ///< [in] The past-the-end (most-significant) bit index needed for key comparison + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + UpsweepKernelPtr upsweep_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceRadixSortUpsweepKernel + UpsweepKernelPtr alt_upsweep_kernel, ///< [in] Alternate kernel function pointer to parameterization of cub::DeviceRadixSortUpsweepKernel + ScanKernelPtr scan_kernel, ///< [in] Kernel function pointer to parameterization of cub::SpineScanKernel + DownsweepKernelPtr downsweep_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceRadixSortDownsweepKernel + DownsweepKernelPtr alt_downsweep_kernel, ///< [in] Alternate kernel function pointer to parameterization of cub::DeviceRadixSortDownsweepKernel + SingleKernelPtr single_kernel) ///< [in] Alternate kernel function pointer to parameterization of cub::DeviceRadixSortSingleKernel + { +#ifndef CUB_RUNTIME_ENABLED + + // Kernel launch not supported from this device + return CubDebug(cudaErrorNotSupported ); + +#else + + cudaError error = cudaSuccess; + + do + { + // Get PTX version + int ptx_version; + #if (CUB_PTX_ARCH == 0) + if (CubDebug(error = PtxVersion(ptx_version))) break; + #else + ptx_version = CUB_PTX_ARCH; + #endif + + // Get device ordinal + int device_ordinal; + if (CubDebug(error = cudaGetDevice(&device_ordinal))) break; + + // Get device SM version + int sm_version; + if (CubDebug(error = SmVersion(sm_version, device_ordinal))) break; + + // Get SM count + int sm_count; + if (CubDebug(error = cudaDeviceGetAttribute (&sm_count, cudaDevAttrMultiProcessorCount, device_ordinal))) break; + + // Initialize kernel dispatch configurations + KernelConfig upsweep_config, alt_upsweep_config, scan_config, downsweep_config, alt_downsweep_config, single_config; + if (CubDebug(error = InitConfigs(ptx_version, sm_version, sm_count, + upsweep_config, alt_upsweep_config, scan_config, downsweep_config, alt_downsweep_config, single_config, + upsweep_kernel, alt_upsweep_kernel, scan_kernel, downsweep_kernel, alt_downsweep_kernel, single_kernel))) break; + + int num_passes; + + if (num_items <= single_config.tile_size) + { + // Return if the caller is simply requesting the size of the storage allocation + if (d_temp_storage == NULL) + { + temp_storage_bytes = 0; + return cudaSuccess; + } + + // Sort entire problem locally within a single thread block + num_passes = 0; + + // Log single_kernel configuration + if (debug_synchronous) + CubLog("Invoking single_kernel<<<%d, %d, 0, %lld>>>(), %d items per thread, %d SM occupancy, current bit %d, bit_grain %d\n", + 1, single_config.block_threads, (long long) stream, single_config.items_per_thread, single_config.sm_occupancy, begin_bit, single_config.radix_bits); + + // Invoke upsweep_kernel with same grid size as downsweep_kernel + single_kernel<<<1, single_config.block_threads, 0, stream>>>( + d_keys.Current(), + (ALT_STORAGE) ? d_keys.Alternate() : d_keys.Current(), + d_values.Current(), + (ALT_STORAGE) ? d_values.Alternate() : d_values.Current(), + num_items, + begin_bit, + end_bit); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + } + else + { + // Run multiple global digit-place passes + // Get maximum spine length (conservatively based upon the larger, primary digit size) + int max_grid_size = CUB_MAX(downsweep_config.max_grid_size, alt_downsweep_config.max_grid_size); + int spine_length = (max_grid_size * (1 << downsweep_config.radix_bits)) + scan_config.tile_size; + + // Temporary storage allocation requirements + void* allocations[3]; + size_t allocation_sizes[3] = + { + spine_length * sizeof(OffsetT), // bytes needed for privatized block digit histograms + (!ALT_STORAGE) ? 0 : num_items * sizeof(Key), // bytes needed for 3rd keys buffer + (!ALT_STORAGE || (KEYS_ONLY)) ? 0 : num_items * sizeof(Value), // bytes needed for 3rd values buffer + }; + + // Alias the temporary allocations from the single storage blob (or compute the necessary size of the blob) + if (CubDebug(error = AliasTemporaries(d_temp_storage, temp_storage_bytes, allocations, allocation_sizes))) break; + + // Return if the caller is simply requesting the size of the storage allocation + if (d_temp_storage == NULL) + return cudaSuccess; + + // Alias the allocation for the privatized per-block digit histograms + OffsetT *d_spine; + d_spine = static_cast(allocations[0]); + + // Pass planning. Run passes of the alternate digit-size configuration until we have an even multiple of our preferred digit size + int num_bits = end_bit - begin_bit; + num_passes = (num_bits + downsweep_config.radix_bits - 1) / downsweep_config.radix_bits; + bool is_odd_passes = num_passes & 1; + + int max_alt_passes = (num_passes * downsweep_config.radix_bits) - num_bits; + int alt_end_bit = CUB_MIN(end_bit, begin_bit + (max_alt_passes * alt_downsweep_config.radix_bits)); + + DoubleBuffer d_keys_remaining_passes( + (!ALT_STORAGE || is_odd_passes) ? d_keys.Alternate() : static_cast(allocations[1]), + (!ALT_STORAGE) ? d_keys.Current() : (is_odd_passes) ? static_cast(allocations[1]) : d_keys.Alternate()); + + DoubleBuffer d_values_remaining_passes( + (!ALT_STORAGE || is_odd_passes) ? d_values.Alternate() : static_cast(allocations[2]), + (!ALT_STORAGE) ? d_values.Current() : (is_odd_passes) ? static_cast(allocations[2]) : d_values.Alternate()); + + // Get even-share work distribution descriptors + GridEvenShare even_share(num_items, downsweep_config.max_grid_size, CUB_MAX(downsweep_config.tile_size, upsweep_config.tile_size)); + GridEvenShare alt_even_share(num_items, alt_downsweep_config.max_grid_size, CUB_MAX(alt_downsweep_config.tile_size, alt_upsweep_config.tile_size)); + + // Run first pass + int current_bit = begin_bit; + if (current_bit < alt_end_bit) + { + // Alternate digit-length pass + int pass_bits = CUB_MIN(alt_downsweep_config.radix_bits, (end_bit - current_bit)); + DispatchPass( + d_keys.Current(), d_keys_remaining_passes.Current(), + d_values.Current(), d_values_remaining_passes.Current(), + d_spine, spine_length, num_items, current_bit, pass_bits, stream, debug_synchronous, + alt_upsweep_config, scan_config, alt_downsweep_config, + alt_upsweep_kernel, scan_kernel, alt_downsweep_kernel, + alt_even_share); + + current_bit += alt_downsweep_config.radix_bits; + } + else + { + // Preferred digit-length pass + int pass_bits = CUB_MIN(downsweep_config.radix_bits, (end_bit - current_bit)); + DispatchPass( + d_keys.Current(), d_keys_remaining_passes.Current(), + d_values.Current(), d_values_remaining_passes.Current(), + d_spine, spine_length, num_items, current_bit, pass_bits, stream, debug_synchronous, + upsweep_config, scan_config, downsweep_config, + upsweep_kernel, scan_kernel, downsweep_kernel, + even_share); + + current_bit += downsweep_config.radix_bits; + } + + // Run remaining passes + while (current_bit < end_bit) + { + if (current_bit < alt_end_bit) + { + // Alternate digit-length pass + int pass_bits = CUB_MIN(alt_downsweep_config.radix_bits, (end_bit - current_bit)); + DispatchPass( + d_keys_remaining_passes.d_buffers[d_keys_remaining_passes.selector], + d_keys_remaining_passes.d_buffers[d_keys_remaining_passes.selector ^ 1], + d_values_remaining_passes.d_buffers[d_keys_remaining_passes.selector], + d_values_remaining_passes.d_buffers[d_keys_remaining_passes.selector ^ 1], + d_spine, spine_length, num_items, current_bit, pass_bits, stream, debug_synchronous, + alt_upsweep_config, scan_config, alt_downsweep_config, + alt_upsweep_kernel, scan_kernel, alt_downsweep_kernel, + alt_even_share); + + current_bit += alt_downsweep_config.radix_bits; + } + else + { + // Preferred digit-length pass + int pass_bits = CUB_MIN(downsweep_config.radix_bits, (end_bit - current_bit)); + DispatchPass( + d_keys_remaining_passes.d_buffers[d_keys_remaining_passes.selector], + d_keys_remaining_passes.d_buffers[d_keys_remaining_passes.selector ^ 1], + d_values_remaining_passes.d_buffers[d_keys_remaining_passes.selector], + d_values_remaining_passes.d_buffers[d_keys_remaining_passes.selector ^ 1], + d_spine, spine_length, num_items, current_bit, pass_bits, stream, debug_synchronous, + upsweep_config, scan_config, downsweep_config, + upsweep_kernel, scan_kernel, downsweep_kernel, + even_share); + + current_bit += downsweep_config.radix_bits; + } + + // Invert selectors and update current bit + d_keys_remaining_passes.selector ^= 1; + d_values_remaining_passes.selector ^= 1; + } + } + + // Update selector + if (ALT_STORAGE) + { + // Sorted data always ends up in the other vector + d_keys.selector ^= 1; + d_values.selector ^= 1; + } + else + { + // Where sorted data ends up depends on the number of passes + d_keys.selector = (d_keys.selector + num_passes) & 1; + d_values.selector = (d_values.selector + num_passes) & 1; + } + } + while (0); + + return error; + +#endif // CUB_RUNTIME_ENABLED + } + + + /** + * Internal dispatch routine + */ + + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + DoubleBuffer &d_keys, ///< [in,out] Double-buffer whose current buffer contains the unsorted input keys and, upon return, is updated to point to the sorted output keys + DoubleBuffer &d_values, ///< [in,out] Double-buffer whose current buffer contains the unsorted input values and, upon return, is updated to point to the sorted output values + OffsetT num_items, ///< [in] Number of items to reduce + int begin_bit, ///< [in] The beginning (least-significant) bit index needed for key comparison + int end_bit, ///< [in] The past-the-end (most-significant) bit index needed for key comparison + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous) ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + return Dispatch( + d_temp_storage, + temp_storage_bytes, + d_keys, + d_values, + num_items, + begin_bit, + end_bit, + stream, + debug_synchronous, + DeviceRadixSortUpsweepKernel, + DeviceRadixSortUpsweepKernel, + RadixSortScanBinsKernel, + DeviceRadixSortDownsweepKernel, + DeviceRadixSortDownsweepKernel, + DeviceRadixSortSingleKernel); + } + +}; + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/dispatch/dispatch_reduce.cuh b/3rdparty/cub/cub/device/dispatch/dispatch_reduce.cuh new file mode 100644 index 00000000000..49c5fbcc12b --- /dev/null +++ b/3rdparty/cub/cub/device/dispatch/dispatch_reduce.cuh @@ -0,0 +1,804 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceReduce provides device-wide, parallel operations for computing a reduction across a sequence of data items residing within global memory. + */ + +#pragma once + +#include +#include + +#include "../../agent/agent_reduce.cuh" +#include "../../iterator/constant_input_iterator.cuh" +#include "../../thread/thread_operators.cuh" +#include "../../grid/grid_even_share.cuh" +#include "../../grid/grid_queue.cuh" +#include "../../iterator/arg_index_input_iterator.cuh" +#include "../../util_debug.cuh" +#include "../../util_device.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/****************************************************************************** + * Kernel entry points + *****************************************************************************/ + +/** + * Reduce region kernel entry point (multi-block). Computes privatized reductions, one per thread block. + */ +template < + typename AgentReducePolicy, ///< Parameterized AgentReducePolicy tuning policy type + typename InputIteratorT, ///< Random-access input iterator type for reading input items \iterator + typename OutputIteratorT, ///< Output iterator type for recording the reduced aggregate \iterator + typename OffsetT, ///< Signed integer type for global offsets + typename ReductionOp> ///< Binary reduction functor type having member T operator()(const T &a, const T &b) (e.g., cub::Sum, cub::Min, cub::Max, etc.) +__launch_bounds__ (int(AgentReducePolicy::BLOCK_THREADS)) +__global__ void DeviceReduceSweepKernel( + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output aggregate + OffsetT num_items, ///< [in] Total number of input data items + GridEvenShare even_share, ///< [in] Even-share descriptor for mapping an equal number of tiles onto each thread block + GridQueue queue, ///< [in] Drain queue descriptor for dynamically mapping tile data onto thread blocks + ReductionOp reduction_op) ///< [in] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) +{ + // Data type + typedef typename std::iterator_traits::value_type T; + + // Thread block type for reducing input tiles + typedef AgentReduce AgentReduceT; + + // Block-wide aggregate + T block_aggregate; + + // Shared memory storage + __shared__ typename AgentReduceT::TempStorage temp_storage; + + // Consume input tiles + AgentReduceT(temp_storage, d_in, reduction_op).ConsumeRange( + num_items, + even_share, + queue, + block_aggregate, + Int2Type()); + + // Output result + if (threadIdx.x == 0) + { + d_out[blockIdx.x] = block_aggregate; + } +} + + +/** + * Reduce a single tile kernel entry point (single-block). Can be used to aggregate privatized threadblock reductions from a previous multi-block reduction pass. + */ +template < + typename AgentReducePolicy, ///< Parameterized AgentReducePolicy tuning policy type + typename InputIteratorT, ///< Random-access input iterator type for reading input items \iterator + typename OutputIteratorT, ///< Output iterator type for recording the reduced aggregate \iterator + typename OffsetT, ///< Signed integer type for global offsets + typename ReductionOp> ///< Binary reduction functor type having member T operator()(const T &a, const T &b) (e.g., cub::Sum, cub::Min, cub::Max, etc.) +__launch_bounds__ (int(AgentReducePolicy::BLOCK_THREADS), 1) +__global__ void SingleReduceSweepKernel( + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output aggregate + OffsetT num_items, ///< [in] Total number of input data items + ReductionOp reduction_op) ///< [in] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) +{ + // Data type + typedef typename std::iterator_traits::value_type T; + + // Thread block type for reducing input tiles + typedef AgentReduce AgentReduceT; + + // Block-wide aggregate + T block_aggregate; + + // Shared memory storage + __shared__ typename AgentReduceT::TempStorage temp_storage; + + // Consume input tiles + AgentReduceT(temp_storage, d_in, reduction_op).ConsumeRange( + OffsetT(0), + OffsetT(num_items), + block_aggregate); + + // Output result + if (threadIdx.x == 0) + { + d_out[blockIdx.x] = block_aggregate; + } +} + + + + +/****************************************************************************** + * Dispatch + ******************************************************************************/ + +/** + * Utility class for dispatching the appropriately-tuned kernels for DeviceReduce + */ +template < + typename InputIteratorT, ///< Random-access input iterator type for reading input items \iterator + typename OutputIteratorT, ///< Output iterator type for recording the reduced aggregate \iterator + typename OffsetT, ///< Signed integer type for global offsets + typename ReductionOp> ///< Binary reduction functor type having member T operator()(const T &a, const T &b) (e.g., cub::Sum, cub::Min, cub::Max, etc.) +struct DispatchReduce +{ + /****************************************************************************** + * Types and constants + ******************************************************************************/ + + // Data type of input iterator + typedef typename std::iterator_traits::value_type T; + + enum { + // Whether this is for ArgMin or ArgMax + IS_ARG_OP = Equals::VALUE || Equals::VALUE, + }; + + /****************************************************************************** + * Tuning policies + ******************************************************************************/ + + /// SM35 + struct Policy350 + { + // RangeReducePolicy1B (GTX Titan: 228.7 GB/s @ 192M 1B items) + enum { + SMALL_NOMINAL_ITEMS_PER_THREAD = 24, + SMALL_ITEMS_PER_THREAD = CUB_MIN(SMALL_NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (SMALL_NOMINAL_ITEMS_PER_THREAD * 1 / sizeof(T)))), + + SMALL_NOMINAL_VECTOR_LOAD_LENGTH = 4, + SMALL_VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, SMALL_ITEMS_PER_THREAD), CUB_MAX(1, (SMALL_NOMINAL_VECTOR_LOAD_LENGTH * 1 / sizeof(T)))), + }; + typedef AgentReducePolicy< + 128, ///< Threads per thread block + SMALL_ITEMS_PER_THREAD, ///< Items per thread per tile of input + SMALL_VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_WARP_REDUCTIONS, ///< Cooperative block-wide reduction algorithm to use + LOAD_LDG, ///< Cache load modifier + GRID_MAPPING_DYNAMIC> ///< How to map tiles of input onto thread blocks + RangeReducePolicy1B; + + // RangeReducePolicy4B (GTX Titan: 255.1 GB/s @ 48M 4B items) + enum { + NOMINAL_ITEMS_PER_THREAD = 20, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_ITEMS_PER_THREAD * 4 / sizeof(T)))), + + NOMINAL_VECTOR_LOAD_LENGTH = 4, + VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, ITEMS_PER_THREAD), CUB_MAX(1, (NOMINAL_VECTOR_LOAD_LENGTH * 4 / sizeof(T)))), + }; + typedef AgentReducePolicy< + 256, ///< Threads per thread block + ITEMS_PER_THREAD, ///< Items per thread per tile of input + VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_WARP_REDUCTIONS, ///< Cooperative block-wide reduction algorithm to use + LOAD_LDG, ///< Cache load modifier + GRID_MAPPING_DYNAMIC> ///< How to map tiles of input onto thread blocks + RangeReducePolicy4B; + + // RangeReducePolicy + typedef typename If<(sizeof(T) < 4), + RangeReducePolicy1B, + RangeReducePolicy4B>::Type RangeReducePolicy; + + // SingleTilePolicy + enum { + SINGLE_NOMINAL_ITEMS_PER_THREAD = 8, + SINGLE_ITEMS_PER_THREAD = CUB_MIN(SINGLE_NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (SINGLE_NOMINAL_ITEMS_PER_THREAD * 4 / sizeof(T)))), + + SINGLE_NOMINAL_VECTOR_LOAD_LENGTH = 1, + SINGLE_VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, ITEMS_PER_THREAD), CUB_MAX(1, (SINGLE_NOMINAL_VECTOR_LOAD_LENGTH * 4 / sizeof(T)))), + }; + typedef AgentReducePolicy< + 256, ///< Threads per thread block + SINGLE_ITEMS_PER_THREAD, ///< Items per thread per tile of input + SINGLE_VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_WARP_REDUCTIONS, ///< Cooperative block-wide reduction algorithm to use + LOAD_DEFAULT, ///< Cache load modifier + GRID_MAPPING_EVEN_SHARE> ///< How to map tiles of input onto thread blocks + SingleTilePolicy; + }; + + /// SM30 + struct Policy300 + { + // RangeReducePolicy (GTX670: 154.0 @ 48M 4B items) + enum { + NOMINAL_ITEMS_PER_THREAD = 2, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_ITEMS_PER_THREAD * 4 / sizeof(T)))), + + NOMINAL_VECTOR_LOAD_LENGTH = 1, + VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, ITEMS_PER_THREAD), CUB_MAX(1, (NOMINAL_VECTOR_LOAD_LENGTH * 4 / sizeof(T)))), + }; + typedef AgentReducePolicy< + 256, ///< Threads per thread block + ITEMS_PER_THREAD, ///< Items per thread per tile of input + VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_WARP_REDUCTIONS, ///< Cooperative block-wide reduction algorithm to use + LOAD_DEFAULT, ///< Cache load modifier + GRID_MAPPING_EVEN_SHARE> ///< How to map tiles of input onto thread blocks + RangeReducePolicy; + + // SingleTilePolicy + enum { + SINGLE_NOMINAL_ITEMS_PER_THREAD = 24, + SINGLE_ITEMS_PER_THREAD = CUB_MIN(SINGLE_NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (SINGLE_NOMINAL_ITEMS_PER_THREAD * 4 / sizeof(T)))), + + SINGLE_NOMINAL_VECTOR_LOAD_LENGTH = 4, + SINGLE_VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, ITEMS_PER_THREAD), CUB_MAX(1, (SINGLE_NOMINAL_VECTOR_LOAD_LENGTH * 4 / sizeof(T)))), + }; + typedef AgentReducePolicy< + 256, ///< Threads per thread block + SINGLE_ITEMS_PER_THREAD, ///< Items per thread per tile of input + SINGLE_VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_WARP_REDUCTIONS, ///< Cooperative block-wide reduction algorithm to use + LOAD_DEFAULT, ///< Cache load modifier + GRID_MAPPING_EVEN_SHARE> ///< How to map tiles of input onto thread blocks + SingleTilePolicy; + }; + + /// SM20 + struct Policy200 + { + // RangeReducePolicy1B (GTX 580: 158.1 GB/s @ 192M 1B items) + enum { + SMALL_NOMINAL_ITEMS_PER_THREAD = 24, + SMALL_ITEMS_PER_THREAD = CUB_MIN(SMALL_NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (SMALL_NOMINAL_ITEMS_PER_THREAD * 1 / sizeof(T)))), + + SMALL_NOMINAL_VECTOR_LOAD_LENGTH = 4, + SMALL_VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, SMALL_ITEMS_PER_THREAD), CUB_MAX(1, (SMALL_NOMINAL_VECTOR_LOAD_LENGTH * 1 / sizeof(T)))), + }; + typedef AgentReducePolicy< + 192, ///< Threads per thread block + SMALL_ITEMS_PER_THREAD, ///< Items per thread per tile of input + SMALL_VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_RAKING, ///< Cooperative block-wide reduction algorithm to use + LOAD_DEFAULT, ///< Cache load modifier + (sizeof(T) == 1) ? ///< How to map tiles of input onto thread blocks + GRID_MAPPING_EVEN_SHARE : + GRID_MAPPING_DYNAMIC> + RangeReducePolicy1B; + + // RangeReducePolicy4B (GTX 580: 178.9 GB/s @ 48M 4B items) + enum { + NOMINAL_ITEMS_PER_THREAD = 8, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_ITEMS_PER_THREAD * 4 / sizeof(T)))), + + NOMINAL_VECTOR_LOAD_LENGTH = 4, + VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, ITEMS_PER_THREAD), CUB_MAX(1, (NOMINAL_VECTOR_LOAD_LENGTH * 4 / sizeof(T)))), + }; + typedef AgentReducePolicy< + 128, ///< Threads per thread block + ITEMS_PER_THREAD, ///< Items per thread per tile of input + VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_RAKING, ///< Cooperative block-wide reduction algorithm to use + LOAD_DEFAULT, ///< Cache load modifier + GRID_MAPPING_DYNAMIC> ///< How to map tiles of input onto thread blocks + RangeReducePolicy4B; + + // RangeReducePolicy + typedef typename If<(sizeof(T) < 4), + RangeReducePolicy1B, + RangeReducePolicy4B>::Type RangeReducePolicy; + + // SingleTilePolicy + enum { + SINGLE_NOMINAL_ITEMS_PER_THREAD = 7, + SINGLE_ITEMS_PER_THREAD = CUB_MIN(SINGLE_NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (SINGLE_NOMINAL_ITEMS_PER_THREAD * 4 / sizeof(T)))), + + SINGLE_NOMINAL_VECTOR_LOAD_LENGTH = 1, + SINGLE_VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, ITEMS_PER_THREAD), CUB_MAX(1, (SINGLE_NOMINAL_VECTOR_LOAD_LENGTH * 4 / sizeof(T)))), + }; + typedef AgentReducePolicy< + 192, ///< Threads per thread block + SINGLE_ITEMS_PER_THREAD, ///< Items per thread per tile of input + SINGLE_VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_RAKING, ///< Cooperative block-wide reduction algorithm to use + LOAD_DEFAULT, ///< Cache load modifier + GRID_MAPPING_EVEN_SHARE> ///< How to map tiles of input onto thread blocks + SingleTilePolicy; + }; + + /// SM13 + struct Policy130 + { + // RangeReducePolicy + enum { + NOMINAL_ITEMS_PER_THREAD = 8, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_ITEMS_PER_THREAD * 4 / sizeof(T)))), + + NOMINAL_VECTOR_LOAD_LENGTH = 2, + VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, ITEMS_PER_THREAD), CUB_MAX(1, (NOMINAL_VECTOR_LOAD_LENGTH * 4 / sizeof(T)))), + }; + typedef AgentReducePolicy< + 128, ///< Threads per thread block + ITEMS_PER_THREAD, ///< Items per thread per tile of input + VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_RAKING, ///< Cooperative block-wide reduction algorithm to use + LOAD_DEFAULT, ///< Cache load modifier + GRID_MAPPING_EVEN_SHARE> ///< How to map tiles of input onto thread blocks + RangeReducePolicy; + + // SingleTilePolicy + enum { + SINGLE_NOMINAL_ITEMS_PER_THREAD = 4, + SINGLE_ITEMS_PER_THREAD = CUB_MIN(SINGLE_NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (SINGLE_NOMINAL_ITEMS_PER_THREAD * 4 / sizeof(T)))), + + SINGLE_NOMINAL_VECTOR_LOAD_LENGTH = 2, + SINGLE_VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, ITEMS_PER_THREAD), CUB_MAX(1, (SINGLE_NOMINAL_VECTOR_LOAD_LENGTH * 4 / sizeof(T)))), + }; + typedef AgentReducePolicy< + 32, ///< Threads per thread block + SINGLE_ITEMS_PER_THREAD, ///< Items per thread per tile of input + SINGLE_VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_RAKING, ///< Cooperative block-wide reduction algorithm to use + LOAD_DEFAULT, ///< Cache load modifier + GRID_MAPPING_EVEN_SHARE> ///< How to map tiles of input onto thread blocks + SingleTilePolicy; + }; + + /// SM10 + struct Policy100 + { + enum { + NOMINAL_ITEMS_PER_THREAD = 8, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_ITEMS_PER_THREAD * 4 / sizeof(T)))), + + NOMINAL_VECTOR_LOAD_LENGTH = 2, + VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, ITEMS_PER_THREAD), CUB_MAX(1, (NOMINAL_VECTOR_LOAD_LENGTH * 4 / sizeof(T)))), + }; + + // RangeReducePolicy + typedef AgentReducePolicy< + 128, ///< Threads per thread block + ITEMS_PER_THREAD, ///< Items per thread per tile of input + VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_RAKING, ///< Cooperative block-wide reduction algorithm to use + LOAD_DEFAULT, ///< Cache load modifier + GRID_MAPPING_EVEN_SHARE> ///< How to map tiles of input onto thread blocks + RangeReducePolicy; + + // SingleTilePolicy + enum { + SINGLE_NOMINAL_ITEMS_PER_THREAD = 4, + SINGLE_ITEMS_PER_THREAD = CUB_MIN(SINGLE_NOMINAL_ITEMS_PER_THREAD, CUB_MAX(1, (SINGLE_NOMINAL_ITEMS_PER_THREAD * 4 / sizeof(T)))), + + SINGLE_NOMINAL_VECTOR_LOAD_LENGTH = 4, + SINGLE_VECTOR_LOAD_LENGTH = CUB_MIN(CUB_MIN(4, ITEMS_PER_THREAD), CUB_MAX(1, (SINGLE_NOMINAL_VECTOR_LOAD_LENGTH * 4 / sizeof(T)))), + }; + typedef AgentReducePolicy< + 32, ///< Threads per thread block + SINGLE_ITEMS_PER_THREAD, ///< Items per thread per tile of input + SINGLE_VECTOR_LOAD_LENGTH, ///< Number of items per vectorized load + BLOCK_REDUCE_RAKING, ///< Cooperative block-wide reduction algorithm to use + LOAD_DEFAULT, ///< Cache load modifier + GRID_MAPPING_EVEN_SHARE> ///< How to map tiles of input onto thread blocks + SingleTilePolicy; + }; + + + /****************************************************************************** + * Tuning policies of current PTX compiler pass + ******************************************************************************/ + +#if (CUB_PTX_ARCH >= 350) + typedef Policy350 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 300) + typedef Policy300 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 200) + typedef Policy200 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 130) + typedef Policy130 PtxPolicy; + +#else + typedef Policy100 PtxPolicy; + +#endif + + // "Opaque" policies (whose parameterizations aren't reflected in the type signature) + struct PtxRangeReducePolicy : PtxPolicy::RangeReducePolicy {}; + struct PtxSingleTilePolicy : PtxPolicy::SingleTilePolicy {}; + + + /****************************************************************************** + * Utilities + ******************************************************************************/ + + /** + * Initialize kernel dispatch configurations with the policies corresponding to the PTX assembly we will use + */ + template + CUB_RUNTIME_FUNCTION __forceinline__ + static void InitConfigs( + int ptx_version, + KernelConfig &device_reduce_sweep_config, + KernelConfig &single_reduce_sweep_config) + { + #if (CUB_PTX_ARCH > 0) + + // We're on the device, so initialize the kernel dispatch configurations with the current PTX policy + device_reduce_sweep_config.template Init(); + single_reduce_sweep_config.template Init(); + + #else + + // We're on the host, so lookup and initialize the kernel dispatch configurations with the policies that match the device's PTX version + if (ptx_version >= 350) + { + device_reduce_sweep_config.template Init(); + single_reduce_sweep_config.template Init(); + } + else if (ptx_version >= 300) + { + device_reduce_sweep_config.template Init(); + single_reduce_sweep_config.template Init(); + } + else if (ptx_version >= 200) + { + device_reduce_sweep_config.template Init(); + single_reduce_sweep_config.template Init(); + } + else if (ptx_version >= 130) + { + device_reduce_sweep_config.template Init(); + single_reduce_sweep_config.template Init(); + } + else + { + device_reduce_sweep_config.template Init(); + single_reduce_sweep_config.template Init(); + } + + #endif + } + + + /** + * Kernel kernel dispatch configuration + */ + struct KernelConfig + { + int block_threads; + int items_per_thread; + int vector_load_length; + BlockReduceAlgorithm block_algorithm; + CacheLoadModifier load_modifier; + GridMappingStrategy grid_mapping; + + template + CUB_RUNTIME_FUNCTION __forceinline__ + void Init() + { + block_threads = BlockPolicy::BLOCK_THREADS; + items_per_thread = BlockPolicy::ITEMS_PER_THREAD; + vector_load_length = BlockPolicy::VECTOR_LOAD_LENGTH; + block_algorithm = BlockPolicy::BLOCK_ALGORITHM; + load_modifier = BlockPolicy::LOAD_MODIFIER; + grid_mapping = BlockPolicy::GRID_MAPPING; + } + + CUB_RUNTIME_FUNCTION __forceinline__ + void Print() + { + printf("%d threads, %d per thread, %d veclen, %d algo, %d loadmod, %d mapping", + block_threads, + items_per_thread, + vector_load_length, + block_algorithm, + load_modifier, + grid_mapping); + } + }; + + /****************************************************************************** + * Dispatch entrypoints + ******************************************************************************/ + + /** + * Internal dispatch routine for computing a device-wide reduction using the + * specified kernel functions. + * + * If the input is larger than a single tile, this method uses two-passes of + * kernel invocations. + */ + template < + typename DeviceReduceSweepKernelPtr, ///< Function type of cub::DeviceReduceSweepKernel + typename SingleReducePartialsKernelPtr, ///< Function type of cub::SingleReduceSweepKernel for consuming partial reductions (T*) + typename SingleReduceSweepKernelPtr, ///< Function type of cub::SingleReduceSweepKernel for consuming input (InputIteratorT) + typename FillAndResetDrainKernelPtr> ///< Function type of cub::FillAndResetDrainKernel + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output aggregate + OffsetT num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + ReductionOp reduction_op, ///< [in] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + FillAndResetDrainKernelPtr prepare_drain_kernel, ///< [in] Kernel function pointer to parameterization of cub::FillAndResetDrainKernel + DeviceReduceSweepKernelPtr device_reduce_sweep_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceReduceSweepKernel + SingleReducePartialsKernelPtr single_reduce_partials_kernel, ///< [in] Kernel function pointer to parameterization of cub::SingleReduceSweepKernel for consuming partial reductions (T*) + SingleReduceSweepKernelPtr single_reduce_sweep_kernel, ///< [in] Kernel function pointer to parameterization of cub::SingleReduceSweepKernel for consuming input (InputIteratorT) + KernelConfig device_reduce_sweep_config, ///< [in] Dispatch parameters that match the policy that \p range_reduce_kernel_ptr was compiled for + KernelConfig single_reduce_sweep_config) ///< [in] Dispatch parameters that match the policy that \p single_reduce_sweep_kernel was compiled for + { +#ifndef CUB_RUNTIME_ENABLED + + // Kernel launch not supported from this device + return CubDebug(cudaErrorNotSupported ); + +#else + cudaError error = cudaSuccess; + do + { + // Get device ordinal + int device_ordinal; + if (CubDebug(error = cudaGetDevice(&device_ordinal))) break; + + // Get device SM version + int sm_version; + if (CubDebug(error = SmVersion(sm_version, device_ordinal))) break; + + // Get SM count + int sm_count; + if (CubDebug(error = cudaDeviceGetAttribute (&sm_count, cudaDevAttrMultiProcessorCount, device_ordinal))) break; + + // Tile size of device_reduce_sweep_kernel + int tile_size = device_reduce_sweep_config.block_threads * device_reduce_sweep_config.items_per_thread; + + if ((device_reduce_sweep_kernel == NULL) || (num_items <= tile_size)) + { + // Dispatch a single-block reduction kernel + + // Return if the caller is simply requesting the size of the storage allocation + if (d_temp_storage == NULL) + { + temp_storage_bytes = 1; + return cudaSuccess; + } + + // Log single_reduce_sweep_kernel configuration + if (debug_synchronous) CubLog("Invoking ReduceSingle<<<1, %d, 0, %lld>>>(), %d items per thread\n", + single_reduce_sweep_config.block_threads, (long long) stream, single_reduce_sweep_config.items_per_thread); + + // Invoke single_reduce_sweep_kernel + single_reduce_sweep_kernel<<<1, single_reduce_sweep_config.block_threads, 0, stream>>>( + d_in, + d_out, + num_items, + reduction_op); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + } + else + { + // Dispatch two kernels: (1) a multi-block kernel to compute + // privatized per-block reductions, and (2) a single-block + // to reduce those partial reductions + + // Get SM occupancy for device_reduce_sweep_kernel + int range_reduce_sm_occupancy; + if (CubDebug(error = MaxSmOccupancy( + range_reduce_sm_occupancy, + sm_version, + device_reduce_sweep_kernel, + device_reduce_sweep_config.block_threads))) break; + + // Get device occupancy for device_reduce_sweep_kernel + int range_reduce_occupancy = range_reduce_sm_occupancy * sm_count; + + // Even-share work distribution + int subscription_factor = range_reduce_sm_occupancy; // Amount of CTAs to oversubscribe the device beyond actively-resident (heuristic) + GridEvenShare even_share( + num_items, + range_reduce_occupancy * subscription_factor, + tile_size); + + // Get grid size for device_reduce_sweep_kernel + int range_reduce_grid_size; + switch (device_reduce_sweep_config.grid_mapping) + { + case GRID_MAPPING_EVEN_SHARE: + + // Work is distributed evenly + range_reduce_grid_size = even_share.grid_size; + break; + + case GRID_MAPPING_DYNAMIC: + + // Work is distributed dynamically + int num_tiles = (num_items + tile_size - 1) / tile_size; + range_reduce_grid_size = (num_tiles < range_reduce_occupancy) ? + num_tiles : // Not enough to fill the device with threadblocks + range_reduce_occupancy; // Fill the device with threadblocks + break; + }; + + // Temporary storage allocation requirements + void* allocations[2]; + size_t allocation_sizes[2] = + { + range_reduce_grid_size * sizeof(T), // bytes needed for privatized block reductions + GridQueue::AllocationSize() // bytes needed for grid queue descriptor + }; + + // Alias the temporary allocations from the single storage blob (or compute the necessary size of the blob) + if (CubDebug(error = AliasTemporaries(d_temp_storage, temp_storage_bytes, allocations, allocation_sizes))) break; + if (d_temp_storage == NULL) + { + // Return if the caller is simply requesting the size of the storage allocation + return cudaSuccess; + } + + // Alias the allocation for the privatized per-block reductions + T *d_block_reductions = (T*) allocations[0]; + + // Alias the allocation for the grid queue descriptor + GridQueue queue(allocations[1]); + + // Prepare the dynamic queue descriptor if necessary + if (device_reduce_sweep_config.grid_mapping == GRID_MAPPING_DYNAMIC) + { + // Prepare queue using a kernel so we know it gets prepared once per operation + if (debug_synchronous) CubLog("Invoking prepare_drain_kernel<<<1, 1, 0, %lld>>>()\n", (long long) stream); + + // Invoke prepare_drain_kernel + prepare_drain_kernel<<<1, 1, 0, stream>>>(queue, num_items); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + } + + // Log device_reduce_sweep_kernel configuration + if (debug_synchronous) CubLog("Invoking device_reduce_sweep_kernel<<<%d, %d, 0, %lld>>>(), %d items per thread, %d SM occupancy\n", + range_reduce_grid_size, device_reduce_sweep_config.block_threads, (long long) stream, device_reduce_sweep_config.items_per_thread, range_reduce_sm_occupancy); + + // Invoke device_reduce_sweep_kernel + device_reduce_sweep_kernel<<>>( + d_in, + d_block_reductions, + num_items, + even_share, + queue, + reduction_op); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + // Log single_reduce_sweep_kernel configuration + if (debug_synchronous) CubLog("Invoking single_reduce_sweep_kernel<<<%d, %d, 0, %lld>>>(), %d items per thread\n", + 1, single_reduce_sweep_config.block_threads, (long long) stream, single_reduce_sweep_config.items_per_thread); + + // Invoke single_reduce_sweep_kernel + single_reduce_partials_kernel<<<1, single_reduce_sweep_config.block_threads, 0, stream>>>( + d_block_reductions, + d_out, + range_reduce_grid_size, + reduction_op); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + } + } + while (0); + + return error; + +#endif // CUB_RUNTIME_ENABLED + } + + + /** + * Internal dispatch routine for computing a device-wide reduction + */ + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output aggregate + OffsetT num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + ReductionOp reduction_op, ///< [in] Binary reduction functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + cudaStream_t stream, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + cudaError error = cudaSuccess; + do + { + // Get PTX version + int ptx_version; + #if (CUB_PTX_ARCH == 0) + if (CubDebug(error = PtxVersion(ptx_version))) break; + #else + ptx_version = CUB_PTX_ARCH; + #endif + + // Get kernel kernel dispatch configurations + KernelConfig device_reduce_sweep_config; + KernelConfig single_reduce_sweep_config; + InitConfigs(ptx_version, device_reduce_sweep_config, single_reduce_sweep_config); + + // Dispatch + if (CubDebug(error = Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_out, + num_items, + reduction_op, + stream, + debug_synchronous, + FillAndResetDrainKernel, + DeviceReduceSweepKernel, + SingleReduceSweepKernel, + SingleReduceSweepKernel, + device_reduce_sweep_config, + single_reduce_sweep_config))) break; + } + while (0); + + return error; + } +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/dispatch/dispatch_reduce_by_key.cuh b/3rdparty/cub/cub/device/dispatch/dispatch_reduce_by_key.cuh new file mode 100644 index 00000000000..82eaabda034 --- /dev/null +++ b/3rdparty/cub/cub/device/dispatch/dispatch_reduce_by_key.cuh @@ -0,0 +1,530 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceReduceByKey provides device-wide, parallel operations for reducing segments of values residing within global memory. + */ + +#pragma once + +#include +#include + +#include "dispatch_scan.cuh" +#include "../../agent/agent_reduce_by_key.cuh" +#include "../../thread/thread_operators.cuh" +#include "../../grid/grid_queue.cuh" +#include "../../util_device.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/****************************************************************************** + * Kernel entry points + *****************************************************************************/ + +/** + * Multi-block reduce-by-key sweep kernel entry point + */ +template < + typename AgentReduceByKeyPolicyT, ///< Parameterized AgentReduceByKeyPolicyT tuning policy type + typename KeysInputIteratorT, ///< Random-access input iterator type for keys + typename UniqueOutputIteratorT, ///< Random-access output iterator type for keys + typename ValuesInputIteratorT, ///< Random-access input iterator type for values + typename AggregatesOutputIteratorT, ///< Random-access output iterator type for values + typename NumRunsOutputIteratorT, ///< Output iterator type for recording number of segments encountered + typename ScanTileStateT, ///< Tile status interface type + typename EqualityOpT, ///< KeyT equality operator type + typename ReductionOpT, ///< ValueT reduction operator type + typename OffsetT> ///< Signed integer type for global offsets +__launch_bounds__ (int(AgentReduceByKeyPolicyT::BLOCK_THREADS)) +__global__ void DeviceReduceByKeyKernel( + KeysInputIteratorT d_keys_in, ///< [in] Pointer to the input sequence of keys + UniqueOutputIteratorT d_unique_out, ///< [out] Pointer to the output sequence of unique keys (one key per run) + ValuesInputIteratorT d_values_in, ///< [in] Pointer to the input sequence of corresponding values + AggregatesOutputIteratorT d_aggregates_out, ///< [out] Pointer to the output sequence of value aggregates (one aggregate per run) + NumRunsOutputIteratorT d_num_runs_out, ///< [out] Pointer to total number of runs encountered (i.e., the length of d_unique_out) + ScanTileStateT tile_state, ///< [in] Tile status interface + EqualityOpT equality_op, ///< [in] KeyT equality operator + ReductionOpT reduction_op, ///< [in] ValueT reduction operator + OffsetT num_items, ///< [in] Total number of items to select from + int num_tiles) ///< [in] Total number of tiles for the entire problem +{ + // Thread block type for reducing tiles of value segments + typedef AgentReduceByKey< + AgentReduceByKeyPolicyT, + KeysInputIteratorT, + UniqueOutputIteratorT, + ValuesInputIteratorT, + AggregatesOutputIteratorT, + NumRunsOutputIteratorT, + EqualityOpT, + ReductionOpT, + OffsetT> + AgentReduceByKeyT; + + // Shared memory for AgentReduceByKey + __shared__ typename AgentReduceByKeyT::TempStorage temp_storage; + + // Process tiles + AgentReduceByKeyT(temp_storage, d_keys_in, d_unique_out, d_values_in, d_aggregates_out, d_num_runs_out, equality_op, reduction_op).ConsumeRange( + num_items, + num_tiles, + tile_state); +} + + + + +/****************************************************************************** + * Dispatch + ******************************************************************************/ + +/** + * Utility class for dispatching the appropriately-tuned kernels for DeviceReduceByKey + */ +template < + typename KeysInputIteratorT, ///< Random-access input iterator type for keys + typename UniqueOutputIteratorT, ///< Random-access output iterator type for keys + typename ValuesInputIteratorT, ///< Random-access input iterator type for values + typename AggregatesOutputIteratorT, ///< Random-access output iterator type for values + typename NumRunsOutputIteratorT, ///< Output iterator type for recording number of segments encountered + typename EqualityOpT, ///< KeyT equality operator type + typename ReductionOpT, ///< ValueT reduction operator type + typename OffsetT> ///< Signed integer type for global offsets +struct DispatchReduceByKey +{ + //------------------------------------------------------------------------- + // Types and constants + //------------------------------------------------------------------------- + + // Data type of key input iterator + typedef typename std::iterator_traits::value_type KeyT; + + // Data type of value input iterator + typedef typename std::iterator_traits::value_type ValueT; + + enum + { + INIT_KERNEL_THREADS = 128, + MAX_INPUT_BYTES = CUB_MAX(sizeof(KeyT), sizeof(ValueT)), + COMBINED_INPUT_BYTES = sizeof(KeyT) + sizeof(ValueT), + }; + + // Tile status descriptor interface type + typedef ReduceByKeyScanTileState ScanTileStateT; + + + //------------------------------------------------------------------------- + // Tuning policies + //------------------------------------------------------------------------- + + /// SM35 + struct Policy350 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 6, + ITEMS_PER_THREAD = (MAX_INPUT_BYTES <= 8) ? 6 : CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, ((NOMINAL_4B_ITEMS_PER_THREAD * 8) + COMBINED_INPUT_BYTES - 1) / COMBINED_INPUT_BYTES)), + }; + + typedef AgentReduceByKeyPolicy< + 128, + ITEMS_PER_THREAD, + BLOCK_LOAD_DIRECT, + LOAD_LDG, + BLOCK_SCAN_WARP_SCANS> + ReduceByKeyPolicyT; + }; + + /// SM30 + struct Policy300 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 6, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, ((NOMINAL_4B_ITEMS_PER_THREAD * 8) + COMBINED_INPUT_BYTES - 1) / COMBINED_INPUT_BYTES)), + }; + + typedef AgentReduceByKeyPolicy< + 128, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_SCAN_WARP_SCANS> + ReduceByKeyPolicyT; + }; + + /// SM20 + struct Policy200 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 11, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, ((NOMINAL_4B_ITEMS_PER_THREAD * 8) + COMBINED_INPUT_BYTES - 1) / COMBINED_INPUT_BYTES)), + }; + + typedef AgentReduceByKeyPolicy< + 128, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_SCAN_WARP_SCANS> + ReduceByKeyPolicyT; + }; + + /// SM13 + struct Policy130 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 7, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, ((NOMINAL_4B_ITEMS_PER_THREAD * 8) + COMBINED_INPUT_BYTES - 1) / COMBINED_INPUT_BYTES)), + }; + + typedef AgentReduceByKeyPolicy< + 128, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_SCAN_WARP_SCANS> + ReduceByKeyPolicyT; + }; + + /// SM11 + struct Policy110 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 5, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 8) / COMBINED_INPUT_BYTES)), + }; + + typedef AgentReduceByKeyPolicy< + 64, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_SCAN_RAKING> + ReduceByKeyPolicyT; + }; + + + /****************************************************************************** + * Tuning policies of current PTX compiler pass + ******************************************************************************/ + +#if (CUB_PTX_ARCH >= 350) + typedef Policy350 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 300) + typedef Policy300 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 200) + typedef Policy200 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 130) + typedef Policy130 PtxPolicy; + +#else + typedef Policy110 PtxPolicy; + +#endif + + // "Opaque" policies (whose parameterizations aren't reflected in the type signature) + struct PtxReduceByKeyPolicy : PtxPolicy::ReduceByKeyPolicyT {}; + + + /****************************************************************************** + * Utilities + ******************************************************************************/ + + /** + * Initialize kernel dispatch configurations with the policies corresponding to the PTX assembly we will use + */ + template + CUB_RUNTIME_FUNCTION __forceinline__ + static void InitConfigs( + int ptx_version, + KernelConfig &reduce_by_key_config) + { + #if (CUB_PTX_ARCH > 0) + + // We're on the device, so initialize the kernel dispatch configurations with the current PTX policy + reduce_by_key_config.template Init(); + + #else + + // We're on the host, so lookup and initialize the kernel dispatch configurations with the policies that match the device's PTX version + if (ptx_version >= 350) + { + reduce_by_key_config.template Init(); + } + else if (ptx_version >= 300) + { + reduce_by_key_config.template Init(); + } + else if (ptx_version >= 200) + { + reduce_by_key_config.template Init(); + } + else if (ptx_version >= 130) + { + reduce_by_key_config.template Init(); + } + else + { + reduce_by_key_config.template Init(); + } + + #endif + } + + + /** + * Kernel kernel dispatch configuration. + */ + struct KernelConfig + { + int block_threads; + int items_per_thread; + int tile_items; + + template + CUB_RUNTIME_FUNCTION __forceinline__ + void Init() + { + block_threads = PolicyT::BLOCK_THREADS; + items_per_thread = PolicyT::ITEMS_PER_THREAD; + tile_items = block_threads * items_per_thread; + } + }; + + + //--------------------------------------------------------------------- + // Dispatch entrypoints + //--------------------------------------------------------------------- + + /** + * Internal dispatch routine for computing a device-wide reduce-by-key using the + * specified kernel functions. + */ + template < + typename ScanInitKernelT, ///< Function type of cub::DeviceScanInitKernel + typename ReduceByKeyKernelT> ///< Function type of cub::DeviceReduceByKeyKernelT + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + KeysInputIteratorT d_keys_in, ///< [in] Pointer to the input sequence of keys + UniqueOutputIteratorT d_unique_out, ///< [out] Pointer to the output sequence of unique keys (one key per run) + ValuesInputIteratorT d_values_in, ///< [in] Pointer to the input sequence of corresponding values + AggregatesOutputIteratorT d_aggregates_out, ///< [out] Pointer to the output sequence of value aggregates (one aggregate per run) + NumRunsOutputIteratorT d_num_runs_out, ///< [out] Pointer to total number of runs encountered (i.e., the length of d_unique_out) + EqualityOpT equality_op, ///< [in] KeyT equality operator + ReductionOpT reduction_op, ///< [in] ValueT reduction operator + OffsetT num_items, ///< [in] Total number of items to select from + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + int ptx_version, ///< [in] PTX version of dispatch kernels + ScanInitKernelT scan_init_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceScanInitKernel + ReduceByKeyKernelT reduce_by_key_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceReduceByKeyKernel + KernelConfig reduce_by_key_config) ///< [in] Dispatch parameters that match the policy that \p reduce_by_key_kernel was compiled for + { + +#ifndef CUB_RUNTIME_ENABLED + + // Kernel launch not supported from this device + return CubDebug(cudaErrorNotSupported); + +#else + + cudaError error = cudaSuccess; + do + { + // Get device ordinal + int device_ordinal; + if (CubDebug(error = cudaGetDevice(&device_ordinal))) break; + + // Get device SM version + int sm_version; + if (CubDebug(error = SmVersion(sm_version, device_ordinal))) break; + + // Get SM count + int sm_count; + if (CubDebug(error = cudaDeviceGetAttribute (&sm_count, cudaDevAttrMultiProcessorCount, device_ordinal))) break; + + // Number of input tiles + int tile_size = reduce_by_key_config.block_threads * reduce_by_key_config.items_per_thread; + unsigned int num_tiles = (num_items + tile_size - 1) / tile_size; + + // Specify temporary storage allocation requirements + size_t allocation_sizes[1]; + if (CubDebug(error = ScanTileStateT::AllocationSize(num_tiles, allocation_sizes[0]))) break; // bytes needed for tile status descriptors + + // Compute allocation pointers into the single storage blob (or compute the necessary size of the blob) + void* allocations[1]; + if (CubDebug(error = AliasTemporaries(d_temp_storage, temp_storage_bytes, allocations, allocation_sizes))) break; + if (d_temp_storage == NULL) + { + // Return if the caller is simply requesting the size of the storage allocation + return cudaSuccess; + } + + // Construct the tile status interface + ScanTileStateT tile_state; + if (CubDebug(error = tile_state.Init(num_tiles, allocations[0], allocation_sizes[0]))) break; + + // Log scan_init_kernel configuration + int init_grid_size = (num_tiles + INIT_KERNEL_THREADS - 1) / INIT_KERNEL_THREADS; + if (debug_synchronous) CubLog("Invoking scan_init_kernel<<<%d, %d, 0, %lld>>>()\n", init_grid_size, INIT_KERNEL_THREADS, (long long) stream); + + // Invoke scan_init_kernel to initialize tile descriptors + scan_init_kernel<<>>( + tile_state, + num_tiles); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + // Get SM occupancy for reduce_by_key_kernel + int reduce_by_key_sm_occupancy; + if (CubDebug(error = MaxSmOccupancy( + reduce_by_key_sm_occupancy, // out + sm_version, + reduce_by_key_kernel, + reduce_by_key_config.block_threads))) break; + + // Get max x-dimension of grid + int max_dim_x; + if (CubDebug(error = cudaDeviceGetAttribute(&max_dim_x, cudaDevAttrMaxGridDimX, device_ordinal))) break;; + + // Get grid dimensions + dim3 scan_grid_size( + CUB_MIN(num_tiles, max_dim_x), + (num_tiles + max_dim_x - 1) / max_dim_x, + 1); + + // Log reduce_by_key_kernel configuration + if (debug_synchronous) CubLog("Invoking reduce_by_key_kernel<<<{%d,%d,%d}, %d, 0, %lld>>>(), %d items per thread, %d SM occupancy\n", + scan_grid_size.x, scan_grid_size.y, scan_grid_size.z, reduce_by_key_config.block_threads, (long long) stream, reduce_by_key_config.items_per_thread, reduce_by_key_sm_occupancy); + + // Invoke reduce_by_key_kernel + reduce_by_key_kernel<<>>( + d_keys_in, + d_unique_out, + d_values_in, + d_aggregates_out, + d_num_runs_out, + tile_state, + equality_op, + reduction_op, + num_items, + num_tiles); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + } + while (0); + + return error; + +#endif // CUB_RUNTIME_ENABLED + } + + + /** + * Internal dispatch routine + */ + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + KeysInputIteratorT d_keys_in, ///< [in] Pointer to the input sequence of keys + UniqueOutputIteratorT d_unique_out, ///< [out] Pointer to the output sequence of unique keys (one key per run) + ValuesInputIteratorT d_values_in, ///< [in] Pointer to the input sequence of corresponding values + AggregatesOutputIteratorT d_aggregates_out, ///< [out] Pointer to the output sequence of value aggregates (one aggregate per run) + NumRunsOutputIteratorT d_num_runs_out, ///< [out] Pointer to total number of runs encountered (i.e., the length of d_unique_out) + EqualityOpT equality_op, ///< [in] KeyT equality operator + ReductionOpT reduction_op, ///< [in] ValueT reduction operator + OffsetT num_items, ///< [in] Total number of items to select from + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous) ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + cudaError error = cudaSuccess; + do + { + // Get PTX version + int ptx_version; + #if (CUB_PTX_ARCH == 0) + if (CubDebug(error = PtxVersion(ptx_version))) break; + #else + ptx_version = CUB_PTX_ARCH; + #endif + + // Get kernel kernel dispatch configurations + KernelConfig reduce_by_key_config; + InitConfigs(ptx_version, reduce_by_key_config); + + // Dispatch + if (CubDebug(error = Dispatch( + d_temp_storage, + temp_storage_bytes, + d_keys_in, + d_unique_out, + d_values_in, + d_aggregates_out, + d_num_runs_out, + equality_op, + reduction_op, + num_items, + stream, + debug_synchronous, + ptx_version, + DeviceScanInitKernel, + DeviceReduceByKeyKernel, + reduce_by_key_config))) break; + } + while (0); + + return error; + } +}; + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/dispatch/dispatch_rle.cuh b/3rdparty/cub/cub/device/dispatch/dispatch_rle.cuh new file mode 100644 index 00000000000..3ab6250cc01 --- /dev/null +++ b/3rdparty/cub/cub/device/dispatch/dispatch_rle.cuh @@ -0,0 +1,536 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceRle provides device-wide, parallel operations for run-length-encoding sequences of data items residing within global memory. + */ + +#pragma once + +#include +#include + +#include "dispatch_scan.cuh" +#include "../../agent/agent_rle.cuh" +#include "../../thread/thread_operators.cuh" +#include "../../grid/grid_queue.cuh" +#include "../../util_device.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Kernel entry points + *****************************************************************************/ + +/** + * Select kernel entry point (multi-block) + * + * Performs functor-based selection if SelectOp functor type != NullType + * Otherwise performs flag-based selection if FlagIterator's value type != NullType + * Otherwise performs discontinuity selection (keep unique) + */ +template < + typename AgentRlePolicyT, ///< Parameterized AgentRlePolicyT tuning policy type + typename InputIteratorT, ///< Random-access input iterator type for reading input items \iterator + typename OffsetsOutputIteratorT, ///< Random-access output iterator type for writing run-offset values \iterator + typename LengthsOutputIteratorT, ///< Random-access output iterator type for writing run-length values \iterator + typename NumRunsOutputIteratorT, ///< Output iterator type for recording the number of runs encountered \iterator + typename ScanTileStateT, ///< Tile status interface type + typename EqualityOpT, ///< T equality operator type + typename OffsetT> ///< Signed integer type for global offsets +__launch_bounds__ (int(AgentRlePolicyT::BLOCK_THREADS)) +__global__ void DeviceRleSweepKernel( + InputIteratorT d_in, ///< [in] Pointer to input sequence of data items + OffsetsOutputIteratorT d_offsets_out, ///< [out] Pointer to output sequence of run-offsets + LengthsOutputIteratorT d_lengths_out, ///< [out] Pointer to output sequence of run-lengths + NumRunsOutputIteratorT d_num_runs_out, ///< [out] Pointer to total number of runs (i.e., length of \p d_offsets_out) + ScanTileStateT tile_status, ///< [in] Tile status interface + EqualityOpT equality_op, ///< [in] Equality operator for input items + OffsetT num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + int num_tiles) ///< [in] Total number of tiles for the entire problem +{ + // Thread block type for selecting data from input tiles + typedef AgentRle< + AgentRlePolicyT, + InputIteratorT, + OffsetsOutputIteratorT, + LengthsOutputIteratorT, + EqualityOpT, + OffsetT> AgentRleT; + + // Shared memory for AgentRle + __shared__ typename AgentRleT::TempStorage temp_storage; + + // Process tiles + AgentRleT(temp_storage, d_in, d_offsets_out, d_lengths_out, equality_op, num_items).ConsumeRange( + num_tiles, + tile_status, + d_num_runs_out); +} + + + + +/****************************************************************************** + * Dispatch + ******************************************************************************/ + +/** + * Utility class for dispatching the appropriately-tuned kernels for DeviceRle + */ +template < + typename InputIteratorT, ///< Random-access input iterator type for reading input items \iterator + typename OffsetsOutputIteratorT, ///< Random-access output iterator type for writing run-offset values \iterator + typename LengthsOutputIteratorT, ///< Random-access output iterator type for writing run-length values \iterator + typename NumRunsOutputIteratorT, ///< Output iterator type for recording the number of runs encountered \iterator + typename EqualityOpT, ///< T equality operator type + typename OffsetT> ///< Signed integer type for global offsets +struct DeviceRleDispatch +{ + /****************************************************************************** + * Types and constants + ******************************************************************************/ + + // Data type of input iterator + typedef typename std::iterator_traits::value_type T; + + // Signed integer type for run lengths + typedef typename std::iterator_traits::value_type LengthT; + + enum + { + INIT_KERNEL_THREADS = 128, + }; + + // Tile status descriptor interface type + typedef ReduceByKeyScanTileState ScanTileStateT; + + + /****************************************************************************** + * Tuning policies + ******************************************************************************/ + + /// SM35 + struct Policy350 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 15, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentRlePolicy< + 96, + ITEMS_PER_THREAD, + BLOCK_LOAD_DIRECT, + LOAD_LDG, + true, + BLOCK_SCAN_WARP_SCANS> + RleSweepPolicy; + }; + + /// SM30 + struct Policy300 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 5, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentRlePolicy< + 256, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + true, + BLOCK_SCAN_RAKING_MEMOIZE> + RleSweepPolicy; + }; + + /// SM20 + struct Policy200 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 15, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentRlePolicy< + 128, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + false, + BLOCK_SCAN_WARP_SCANS> + RleSweepPolicy; + }; + + /// SM13 + struct Policy130 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 9, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentRlePolicy< + 64, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + true, + BLOCK_SCAN_RAKING_MEMOIZE> + RleSweepPolicy; + }; + + /// SM10 + struct Policy100 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 9, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentRlePolicy< + 256, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + true, + BLOCK_SCAN_RAKING_MEMOIZE> + RleSweepPolicy; + }; + + + /****************************************************************************** + * Tuning policies of current PTX compiler pass + ******************************************************************************/ + +#if (CUB_PTX_ARCH >= 350) + typedef Policy350 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 300) + typedef Policy300 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 200) + typedef Policy200 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 130) + typedef Policy130 PtxPolicy; + +#else + typedef Policy100 PtxPolicy; + +#endif + + // "Opaque" policies (whose parameterizations aren't reflected in the type signature) + struct PtxRleSweepPolicy : PtxPolicy::RleSweepPolicy {}; + + + /****************************************************************************** + * Utilities + ******************************************************************************/ + + /** + * Initialize kernel dispatch configurations with the policies corresponding to the PTX assembly we will use + */ + template + CUB_RUNTIME_FUNCTION __forceinline__ + static void InitConfigs( + int ptx_version, + KernelConfig& device_rle_config) + { + #if (CUB_PTX_ARCH > 0) + + // We're on the device, so initialize the kernel dispatch configurations with the current PTX policy + device_rle_config.template Init(); + + #else + + // We're on the host, so lookup and initialize the kernel dispatch configurations with the policies that match the device's PTX version + if (ptx_version >= 350) + { + device_rle_config.template Init(); + } + else if (ptx_version >= 300) + { + device_rle_config.template Init(); + } + else if (ptx_version >= 200) + { + device_rle_config.template Init(); + } + else if (ptx_version >= 130) + { + device_rle_config.template Init(); + } + else + { + device_rle_config.template Init(); + } + + #endif + } + + + /** + * Kernel kernel dispatch configuration. Mirrors the constants within AgentRlePolicyT. + */ + struct KernelConfig + { + int block_threads; + int items_per_thread; + BlockLoadAlgorithm load_policy; + bool store_warp_time_slicing; + BlockScanAlgorithm scan_algorithm; + + template + CUB_RUNTIME_FUNCTION __forceinline__ + void Init() + { + block_threads = AgentRlePolicyT::BLOCK_THREADS; + items_per_thread = AgentRlePolicyT::ITEMS_PER_THREAD; + load_policy = AgentRlePolicyT::LOAD_ALGORITHM; + store_warp_time_slicing = AgentRlePolicyT::STORE_WARP_TIME_SLICING; + scan_algorithm = AgentRlePolicyT::SCAN_ALGORITHM; + } + + CUB_RUNTIME_FUNCTION __forceinline__ + void Print() + { + printf("%d, %d, %d, %d, %d", + block_threads, + items_per_thread, + load_policy, + store_warp_time_slicing, + scan_algorithm); + } + }; + + + /****************************************************************************** + * Dispatch entrypoints + ******************************************************************************/ + + /** + * Internal dispatch routine for computing a device-wide run-length-encode using the + * specified kernel functions. + */ + template < + typename DeviceScanInitKernelPtr, ///< Function type of cub::DeviceScanInitKernel + typename DeviceRleSweepKernelPtr> ///< Function type of cub::DeviceRleSweepKernelPtr + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OffsetsOutputIteratorT d_offsets_out, ///< [out] Pointer to the output sequence of run-offsets + LengthsOutputIteratorT d_lengths_out, ///< [out] Pointer to the output sequence of run-lengths + NumRunsOutputIteratorT d_num_runs_out, ///< [out] Pointer to the total number of runs encountered (i.e., length of \p d_offsets_out) + EqualityOpT equality_op, ///< [in] Equality operator for input items + OffsetT num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + int ptx_version, ///< [in] PTX version of dispatch kernels + DeviceScanInitKernelPtr device_scan_init_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceScanInitKernel + DeviceRleSweepKernelPtr device_rle_sweep_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceRleSweepKernel + KernelConfig device_rle_config) ///< [in] Dispatch parameters that match the policy that \p device_rle_sweep_kernel was compiled for + { + +#ifndef CUB_RUNTIME_ENABLED + + // Kernel launch not supported from this device + return CubDebug(cudaErrorNotSupported); + +#else + + cudaError error = cudaSuccess; + do + { + // Get device ordinal + int device_ordinal; + if (CubDebug(error = cudaGetDevice(&device_ordinal))) break; + + // Get device SM version + int sm_version; + if (CubDebug(error = SmVersion(sm_version, device_ordinal))) break; + + // Get SM count + int sm_count; + if (CubDebug(error = cudaDeviceGetAttribute (&sm_count, cudaDevAttrMultiProcessorCount, device_ordinal))) break; + + // Number of input tiles + int tile_size = device_rle_config.block_threads * device_rle_config.items_per_thread; + int num_tiles = (num_items + tile_size - 1) / tile_size; + + // Specify temporary storage allocation requirements + size_t allocation_sizes[1]; + if (CubDebug(error = ScanTileStateT::AllocationSize(num_tiles, allocation_sizes[0]))) break; // bytes needed for tile status descriptors + + // Compute allocation pointers into the single storage blob (or compute the necessary size of the blob) + void* allocations[1]; + if (CubDebug(error = AliasTemporaries(d_temp_storage, temp_storage_bytes, allocations, allocation_sizes))) break; + if (d_temp_storage == NULL) + { + // Return if the caller is simply requesting the size of the storage allocation + return cudaSuccess; + } + + // Construct the tile status interface + ScanTileStateT tile_status; + if (CubDebug(error = tile_status.Init(num_tiles, allocations[0], allocation_sizes[0]))) break; + + // Log device_scan_init_kernel configuration + int init_grid_size = (num_tiles + INIT_KERNEL_THREADS - 1) / INIT_KERNEL_THREADS; + if (debug_synchronous) CubLog("Invoking device_scan_init_kernel<<<%d, %d, 0, %lld>>>()\n", init_grid_size, INIT_KERNEL_THREADS, (long long) stream); + + // Invoke device_scan_init_kernel to initialize tile descriptors and queue descriptors + device_scan_init_kernel<<>>( + tile_status, + num_tiles); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + // Get SM occupancy for device_rle_sweep_kernel + int device_rle_kernel_sm_occupancy; + if (CubDebug(error = MaxSmOccupancy( + device_rle_kernel_sm_occupancy, // out + sm_version, + device_rle_sweep_kernel, + device_rle_config.block_threads))) break; + + // Get max x-dimension of grid + int max_dim_x; + if (CubDebug(error = cudaDeviceGetAttribute(&max_dim_x, cudaDevAttrMaxGridDimX, device_ordinal))) break;; + + // Get grid size for scanning tiles + dim3 scan_grid_size; + scan_grid_size.z = 1; + scan_grid_size.y = ((unsigned int) num_tiles + max_dim_x - 1) / max_dim_x; + scan_grid_size.x = CUB_MIN(num_tiles, max_dim_x); + + // Log device_rle_sweep_kernel configuration + if (debug_synchronous) CubLog("Invoking device_rle_sweep_kernel<<<{%d,%d,%d}, %d, 0, %lld>>>(), %d items per thread, %d SM occupancy\n", + scan_grid_size.x, scan_grid_size.y, scan_grid_size.z, device_rle_config.block_threads, (long long) stream, device_rle_config.items_per_thread, device_rle_kernel_sm_occupancy); + + // Invoke device_rle_sweep_kernel + device_rle_sweep_kernel<<>>( + d_in, + d_offsets_out, + d_lengths_out, + d_num_runs_out, + tile_status, + equality_op, + num_items, + num_tiles); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + } + while (0); + + return error; + +#endif // CUB_RUNTIME_ENABLED + } + + + /** + * Internal dispatch routine + */ + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to input sequence of data items + OffsetsOutputIteratorT d_offsets_out, ///< [out] Pointer to output sequence of run-offsets + LengthsOutputIteratorT d_lengths_out, ///< [out] Pointer to output sequence of run-lengths + NumRunsOutputIteratorT d_num_runs_out, ///< [out] Pointer to total number of runs (i.e., length of \p d_offsets_out) + EqualityOpT equality_op, ///< [in] Equality operator for input items + OffsetT num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + cudaStream_t stream, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + cudaError error = cudaSuccess; + do + { + // Get PTX version + int ptx_version; + #if (CUB_PTX_ARCH == 0) + if (CubDebug(error = PtxVersion(ptx_version))) break; + #else + ptx_version = CUB_PTX_ARCH; + #endif + + // Get kernel kernel dispatch configurations + KernelConfig device_rle_config; + InitConfigs(ptx_version, device_rle_config); + + // Dispatch + if (CubDebug(error = Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_offsets_out, + d_lengths_out, + d_num_runs_out, + equality_op, + num_items, + stream, + debug_synchronous, + ptx_version, + DeviceScanInitKernel, + DeviceRleSweepKernel, + device_rle_config))) break; + } + while (0); + + return error; + } +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/dispatch/dispatch_scan.cuh b/3rdparty/cub/cub/device/dispatch/dispatch_scan.cuh new file mode 100644 index 00000000000..6f3ad789ddf --- /dev/null +++ b/3rdparty/cub/cub/device/dispatch/dispatch_scan.cuh @@ -0,0 +1,546 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceScan provides device-wide, parallel operations for computing a prefix scan across a sequence of data items residing within global memory. + */ + +#pragma once + +#include +#include + +#include "../../agent/agent_scan.cuh" +#include "../../thread/thread_operators.cuh" +#include "../../grid/grid_queue.cuh" +#include "../../util_debug.cuh" +#include "../../util_device.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Kernel entry points + *****************************************************************************/ + +/** + * Initialization kernel for tile status initialization (multi-block) + */ +template < + typename OffsetT, ///< Signed integer type for global offsets + typename ScanTileStateT> ///< Tile status interface type +__global__ void DeviceScanInitKernel( + ScanTileStateT tile_state, ///< [in] Tile status interface + int num_tiles) ///< [in] Number of tiles +{ + // Initialize tile status + tile_state.InitializeStatus(num_tiles); +} + + +/** + * Scan kernel entry point (multi-block) + */ +template < + typename ScanPolicyT, ///< Parameterized ScanPolicyT tuning policy type + typename InputIteratorT, ///< Random-access input iterator type for reading scan inputs \iterator + typename OutputIteratorT, ///< Random-access output iterator type for writing scan outputs \iterator + typename ScanTileStateT, ///< Tile status interface type + typename ScanOpT, ///< Binary scan functor type having member T operator()(const T &a, const T &b) + typename IdentityT, ///< The identity element for ScanOpT (cub::NullType for inclusive scans) + typename OffsetT> ///< Signed integer type for global offsets +__launch_bounds__ (int(ScanPolicyT::BLOCK_THREADS)) +__global__ void DeviceScanSweepKernel( + InputIteratorT d_in, ///< Input data + OutputIteratorT d_out, ///< Output data + ScanTileStateT tile_state, ///< [in] Tile status interface + ScanOpT scan_op, ///< Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + IdentityT identity, ///< The identity element for ScanOpT + OffsetT num_items) ///< Total number of scan items for the entire problem +{ + // Thread block type for scanning input tiles + typedef AgentScan< + ScanPolicyT, + InputIteratorT, + OutputIteratorT, + ScanOpT, + IdentityT, + OffsetT> AgentScanT; + + // Shared memory for AgentScan + __shared__ typename AgentScanT::TempStorage temp_storage; + + // Process tiles + AgentScanT(temp_storage, d_in, d_out, scan_op, identity).ConsumeRange( + num_items, + tile_state); +} + + + + +/****************************************************************************** + * Dispatch + ******************************************************************************/ + +/** + * Utility class for dispatching the appropriately-tuned kernels for DeviceScan + */ +template < + typename InputIteratorT, ///< Random-access input iterator type for reading scan inputs \iterator + typename OutputIteratorT, ///< Random-access output iterator type for writing scan outputs \iterator + typename ScanOpT, ///< Binary scan functor type having member T operator()(const T &a, const T &b) + typename IdentityT, ///< The identity element type for ScanOpT (cub::NullType for inclusive scans) + typename OffsetT> ///< Signed integer type for global offsets +struct DispatchScan +{ + //--------------------------------------------------------------------- + // Constants and Types + //--------------------------------------------------------------------- + + enum + { + INIT_KERNEL_THREADS = 128 + }; + + // Data type + typedef typename std::iterator_traits::value_type T; + + // Tile status descriptor interface type + typedef ScanTileState ScanTileStateT; + + + //--------------------------------------------------------------------- + // Tuning policies + //--------------------------------------------------------------------- + + + /// SM520 + struct Policy520 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 16, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + // GTX980: 20.5B items/s @ 48M 32-bit T + typedef AgentScanPolicy< + 256, + ITEMS_PER_THREAD, + BLOCK_LOAD_DIRECT, LOAD_LDG, + BLOCK_STORE_WARP_TRANSPOSE, + BLOCK_SCAN_RAKING_MEMOIZE> + ScanPolicyT; + }; + + /// SM35 + struct Policy350 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 12, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + // GTX Titan: 29.5B items/s (232.4 GB/s) @ 48M 32-bit T + typedef AgentScanPolicy< + 128, + ITEMS_PER_THREAD, + BLOCK_LOAD_DIRECT, + LOAD_LDG, + BLOCK_STORE_WARP_TRANSPOSE_TIMESLICED, + BLOCK_SCAN_RAKING> + ScanPolicyT; + }; + + /// SM30 + struct Policy300 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 9, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentScanPolicy< + 256, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_STORE_WARP_TRANSPOSE, + BLOCK_SCAN_RAKING_MEMOIZE> + ScanPolicyT; + }; + + /// SM20 + struct Policy200 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 15, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + // GTX 580: 20.3B items/s (162.3 GB/s) @ 48M 32-bit T + typedef AgentScanPolicy< + 128, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_STORE_WARP_TRANSPOSE, + BLOCK_SCAN_RAKING_MEMOIZE> + ScanPolicyT; + }; + + /// SM13 + struct Policy130 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 21, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentScanPolicy< + 96, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_STORE_WARP_TRANSPOSE, + BLOCK_SCAN_RAKING_MEMOIZE> + ScanPolicyT; + }; + + /// SM10 + struct Policy100 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 9, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentScanPolicy< + 64, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_STORE_WARP_TRANSPOSE, + BLOCK_SCAN_WARP_SCANS> + ScanPolicyT; + }; + + + //--------------------------------------------------------------------- + // Tuning policies of current PTX compiler pass + //--------------------------------------------------------------------- + +#if (CUB_PTX_ARCH >= 520) + typedef Policy520 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 350) + typedef Policy350 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 300) + typedef Policy300 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 200) + typedef Policy200 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 130) + typedef Policy130 PtxPolicy; + +#else + typedef Policy100 PtxPolicy; + +#endif + + // "Opaque" policies (whose parameterizations aren't reflected in the type signature) + struct PtxAgentScanPolicy : PtxPolicy::ScanPolicyT {}; + + + //--------------------------------------------------------------------- + // Utilities + //--------------------------------------------------------------------- + + /** + * Initialize kernel dispatch configurations with the policies corresponding to the PTX assembly we will use + */ + template + CUB_RUNTIME_FUNCTION __forceinline__ + static void InitConfigs( + int ptx_version, + KernelConfig &scan_sweep_config) + { + #if (CUB_PTX_ARCH > 0) + + // We're on the device, so initialize the kernel dispatch configurations with the current PTX policy + scan_sweep_config.template Init(); + + #else + + // We're on the host, so lookup and initialize the kernel dispatch configurations with the policies that match the device's PTX version + if (ptx_version >= 520) + { + scan_sweep_config.template Init(); + } + else if (ptx_version >= 350) + { + scan_sweep_config.template Init(); + } + else if (ptx_version >= 300) + { + scan_sweep_config.template Init(); + } + else if (ptx_version >= 200) + { + scan_sweep_config.template Init(); + } + else if (ptx_version >= 130) + { + scan_sweep_config.template Init(); + } + else + { + scan_sweep_config.template Init(); + } + + #endif + } + + + /** + * Kernel kernel dispatch configuration. + */ + struct KernelConfig + { + int block_threads; + int items_per_thread; + int tile_items; + + template + CUB_RUNTIME_FUNCTION __forceinline__ + void Init() + { + block_threads = PolicyT::BLOCK_THREADS; + items_per_thread = PolicyT::ITEMS_PER_THREAD; + tile_items = block_threads * items_per_thread; + } + }; + + + //--------------------------------------------------------------------- + // Dispatch entrypoints + //--------------------------------------------------------------------- + + /** + * Internal dispatch routine for computing a device-wide prefix scan using the + * specified kernel functions. + */ + template < + typename ScanInitKernelPtrT, ///< Function type of cub::DeviceScanInitKernel + typename ScanSweepKernelPtrT> ///< Function type of cub::DeviceScanSweepKernelPtrT + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output sequence of data items + ScanOpT scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + IdentityT identity, ///< [in] The identity element for ScanOpT + OffsetT num_items, ///< [in] Total number of input items (i.e., the length of \p d_in) + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + int ptx_version, ///< [in] PTX version of dispatch kernels + ScanInitKernelPtrT scan_init_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceScanInitKernel + ScanSweepKernelPtrT scan_sweep_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceScanSweepKernel + KernelConfig scan_sweep_config) ///< [in] Dispatch parameters that match the policy that \p scan_sweep_kernel was compiled for + { + +#ifndef CUB_RUNTIME_ENABLED + + // Kernel launch not supported from this device + return CubDebug(cudaErrorNotSupported); + +#else + cudaError error = cudaSuccess; + do + { + // Get device ordinal + int device_ordinal; + if (CubDebug(error = cudaGetDevice(&device_ordinal))) break; + + // Get device SM version + int sm_version; + if (CubDebug(error = SmVersion(sm_version, device_ordinal))) break; + + // Get SM count + int sm_count; + if (CubDebug(error = cudaDeviceGetAttribute (&sm_count, cudaDevAttrMultiProcessorCount, device_ordinal))) break; + + // Number of input tiles + int tile_size = scan_sweep_config.block_threads * scan_sweep_config.items_per_thread; + int num_tiles = (num_items + tile_size - 1) / tile_size; + + // Specify temporary storage allocation requirements + size_t allocation_sizes[1]; + if (CubDebug(error = ScanTileStateT::AllocationSize(num_tiles, allocation_sizes[0]))) break; // bytes needed for tile status descriptors + + // Compute allocation pointers into the single storage blob (or compute the necessary size of the blob) + void* allocations[1]; + if (CubDebug(error = AliasTemporaries(d_temp_storage, temp_storage_bytes, allocations, allocation_sizes))) break; + if (d_temp_storage == NULL) + { + // Return if the caller is simply requesting the size of the storage allocation + return cudaSuccess; + } + + // Construct the tile status interface + ScanTileStateT tile_state; + if (CubDebug(error = tile_state.Init(num_tiles, allocations[0], allocation_sizes[0]))) break; + + // Log scan_init_kernel configuration + int init_grid_size = (num_tiles + INIT_KERNEL_THREADS - 1) / INIT_KERNEL_THREADS; + if (debug_synchronous) CubLog("Invoking scan_init_kernel<<<%d, %d, 0, %lld>>>()\n", init_grid_size, INIT_KERNEL_THREADS, (long long) stream); + + // Invoke scan_init_kernel to initialize tile descriptors + scan_init_kernel<<>>( + tile_state, + num_tiles); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + // Get SM occupancy for scan_sweep_kernel + int range_scan_sm_occupancy; + if (CubDebug(error = MaxSmOccupancy( + range_scan_sm_occupancy, // out + sm_version, + scan_sweep_kernel, + scan_sweep_config.block_threads))) break; + + // Get max x-dimension of grid + int max_dim_x; + if (CubDebug(error = cudaDeviceGetAttribute(&max_dim_x, cudaDevAttrMaxGridDimX, device_ordinal))) break;; + + // Get grid size for scanning tiles + dim3 scan_grid_size; + scan_grid_size.z = 1; + scan_grid_size.y = ((unsigned int) num_tiles + max_dim_x - 1) / max_dim_x; + scan_grid_size.x = CUB_MIN(num_tiles, max_dim_x); + + // Log scan_sweep_kernel configuration + if (debug_synchronous) CubLog("Invoking scan_sweep_kernel<<<{%d,%d,%d}, %d, 0, %lld>>>(), %d items per thread, %d SM occupancy\n", + scan_grid_size.x, scan_grid_size.y, scan_grid_size.z, scan_sweep_config.block_threads, (long long) stream, scan_sweep_config.items_per_thread, range_scan_sm_occupancy); + + // Invoke scan_sweep_kernel + scan_sweep_kernel<<>>( + d_in, + d_out, + tile_state, + scan_op, + identity, + num_items); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + } + while (0); + + return error; + +#endif // CUB_RUNTIME_ENABLED + } + + + /** + * Internal dispatch routine + */ + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + OutputIteratorT d_out, ///< [out] Pointer to the output sequence of data items + ScanOpT scan_op, ///< [in] Binary scan functor (e.g., an instance of cub::Sum, cub::Min, cub::Max, etc.) + IdentityT identity, ///< [in] The identity element for ScanOpT + OffsetT num_items, ///< [in] Total number of input items (i.e., the length of \p d_in) + cudaStream_t stream, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + cudaError error = cudaSuccess; + do + { + // Get PTX version + int ptx_version; + #if (CUB_PTX_ARCH == 0) + if (CubDebug(error = PtxVersion(ptx_version))) break; + #else + ptx_version = CUB_PTX_ARCH; + #endif + + // Get kernel kernel dispatch configurations + KernelConfig scan_sweep_config; + InitConfigs(ptx_version, scan_sweep_config); + + // Dispatch + if (CubDebug(error = Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_out, + scan_op, + identity, + num_items, + stream, + debug_synchronous, + ptx_version, + DeviceScanInitKernel, + DeviceScanSweepKernel, + scan_sweep_config))) break; + } + while (0); + + return error; + } +}; + + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/dispatch/dispatch_select_if.cuh b/3rdparty/cub/cub/device/dispatch/dispatch_select_if.cuh new file mode 100644 index 00000000000..0dc3aeafd15 --- /dev/null +++ b/3rdparty/cub/cub/device/dispatch/dispatch_select_if.cuh @@ -0,0 +1,525 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceSelect provides device-wide, parallel operations for selecting items from sequences of data items residing within global memory. + */ + +#pragma once + +#include +#include + +#include "dispatch_scan.cuh" +#include "../../agent/agent_select_if.cuh" +#include "../../thread/thread_operators.cuh" +#include "../../grid/grid_queue.cuh" +#include "../../util_device.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/****************************************************************************** + * Kernel entry points + *****************************************************************************/ + +/** + * Select kernel entry point (multi-block) + * + * Performs functor-based selection if SelectOpT functor type != NullType + * Otherwise performs flag-based selection if FlagsInputIterator's value type != NullType + * Otherwise performs discontinuity selection (keep unique) + */ +template < + typename AgentSelectIfPolicyT, ///< Parameterized AgentSelectIfPolicyT tuning policy type + typename InputIteratorT, ///< Random-access input iterator type for reading input items + typename FlagsInputIteratorT, ///< Random-access input iterator type for reading selection flags (NullType* if a selection functor or discontinuity flagging is to be used for selection) + typename SelectedOutputIteratorT, ///< Random-access output iterator type for writing selected items + typename NumSelectedIteratorT, ///< Output iterator type for recording the number of items selected + typename ScanTileStateT, ///< Tile status interface type + typename SelectOpT, ///< Selection operator type (NullType if selection flags or discontinuity flagging is to be used for selection) + typename EqualityOpT, ///< Equality operator type (NullType if selection functor or selection flags is to be used for selection) + typename OffsetT, ///< Signed integer type for global offsets + bool KEEP_REJECTS> ///< Whether or not we push rejected items to the back of the output +__launch_bounds__ (int(AgentSelectIfPolicyT::BLOCK_THREADS)) +__global__ void DeviceSelectSweepKernel( + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + FlagsInputIteratorT d_flags, ///< [in] Pointer to the input sequence of selection flags (if applicable) + SelectedOutputIteratorT d_selected_out, ///< [out] Pointer to the output sequence of selected data items + NumSelectedIteratorT d_num_selected_out, ///< [out] Pointer to the total number of items selected (i.e., length of \p d_selected_out) + ScanTileStateT tile_status, ///< [in] Tile status interface + SelectOpT select_op, ///< [in] Selection operator + EqualityOpT equality_op, ///< [in] Equality operator + OffsetT num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + int num_tiles) ///< [in] Total number of tiles for the entire problem +{ + // Thread block type for selecting data from input tiles + typedef AgentSelectIf< + AgentSelectIfPolicyT, + InputIteratorT, + FlagsInputIteratorT, + SelectedOutputIteratorT, + SelectOpT, + EqualityOpT, + OffsetT, + KEEP_REJECTS> AgentSelectIfT; + + // Shared memory for AgentSelectIf + __shared__ typename AgentSelectIfT::TempStorage temp_storage; + + // Process tiles + AgentSelectIfT(temp_storage, d_in, d_flags, d_selected_out, select_op, equality_op, num_items).ConsumeRange( + num_tiles, + tile_status, + d_num_selected_out); +} + + + + +/****************************************************************************** + * Dispatch + ******************************************************************************/ + +/** + * Utility class for dispatching the appropriately-tuned kernels for DeviceSelect + */ +template < + typename InputIteratorT, ///< Random-access input iterator type for reading input items + typename FlagsInputIteratorT, ///< Random-access input iterator type for reading selection flags (NullType* if a selection functor or discontinuity flagging is to be used for selection) + typename SelectedOutputIteratorT, ///< Random-access output iterator type for writing selected items + typename NumSelectedIteratorT, ///< Output iterator type for recording the number of items selected + typename SelectOpT, ///< Selection operator type (NullType if selection flags or discontinuity flagging is to be used for selection) + typename EqualityOpT, ///< Equality operator type (NullType if selection functor or selection flags is to be used for selection) + typename OffsetT, ///< Signed integer type for global offsets + bool KEEP_REJECTS> ///< Whether or not we push rejected items to the back of the output +struct DispatchSelectIf +{ + /****************************************************************************** + * Types and constants + ******************************************************************************/ + + // Data type of input iterator + typedef typename std::iterator_traits::value_type T; + + // Data type of flag iterator + typedef typename std::iterator_traits::value_type FlagT; + + enum + { + INIT_KERNEL_THREADS = 128, + }; + + // Tile status descriptor interface type + typedef ScanTileState ScanTileStateT; + + + /****************************************************************************** + * Tuning policies + ******************************************************************************/ + + /// SM35 + struct Policy350 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 10, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentSelectIfPolicy< + 128, + ITEMS_PER_THREAD, + BLOCK_LOAD_DIRECT, + LOAD_LDG, + BLOCK_SCAN_WARP_SCANS> + SelectIfPolicyT; + }; + + /// SM30 + struct Policy300 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 7, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(3, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentSelectIfPolicy< + 128, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_SCAN_WARP_SCANS> + SelectIfPolicyT; + }; + + /// SM20 + struct Policy200 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = (KEEP_REJECTS) ? 7 : 15, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentSelectIfPolicy< + 128, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_SCAN_WARP_SCANS> + SelectIfPolicyT; + }; + + /// SM13 + struct Policy130 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 9, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentSelectIfPolicy< + 64, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_SCAN_RAKING_MEMOIZE> + SelectIfPolicyT; + }; + + /// SM10 + struct Policy100 + { + enum { + NOMINAL_4B_ITEMS_PER_THREAD = 9, + ITEMS_PER_THREAD = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))), + }; + + typedef AgentSelectIfPolicy< + 64, + ITEMS_PER_THREAD, + BLOCK_LOAD_WARP_TRANSPOSE, + LOAD_DEFAULT, + BLOCK_SCAN_RAKING> + SelectIfPolicyT; + }; + + + /****************************************************************************** + * Tuning policies of current PTX compiler pass + ******************************************************************************/ + +#if (CUB_PTX_ARCH >= 350) + typedef Policy350 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 300) + typedef Policy300 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 200) + typedef Policy200 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 130) + typedef Policy130 PtxPolicy; + +#else + typedef Policy100 PtxPolicy; + +#endif + + // "Opaque" policies (whose parameterizations aren't reflected in the type signature) + struct PtxSelectIfPolicyT : PtxPolicy::SelectIfPolicyT {}; + + + /****************************************************************************** + * Utilities + ******************************************************************************/ + + /** + * Initialize kernel dispatch configurations with the policies corresponding to the PTX assembly we will use + */ + template + CUB_RUNTIME_FUNCTION __forceinline__ + static void InitConfigs( + int ptx_version, + KernelConfig &select_if_config) + { + #if (CUB_PTX_ARCH > 0) + + // We're on the device, so initialize the kernel dispatch configurations with the current PTX policy + select_if_config.template Init(); + + #else + + // We're on the host, so lookup and initialize the kernel dispatch configurations with the policies that match the device's PTX version + if (ptx_version >= 350) + { + select_if_config.template Init(); + } + else if (ptx_version >= 300) + { + select_if_config.template Init(); + } + else if (ptx_version >= 200) + { + select_if_config.template Init(); + } + else if (ptx_version >= 130) + { + select_if_config.template Init(); + } + else + { + select_if_config.template Init(); + } + + #endif + } + + + /** + * Kernel kernel dispatch configuration. + */ + struct KernelConfig + { + int block_threads; + int items_per_thread; + int tile_items; + + template + CUB_RUNTIME_FUNCTION __forceinline__ + void Init() + { + block_threads = PolicyT::BLOCK_THREADS; + items_per_thread = PolicyT::ITEMS_PER_THREAD; + tile_items = block_threads * items_per_thread; + } + }; + + + /****************************************************************************** + * Dispatch entrypoints + ******************************************************************************/ + + /** + * Internal dispatch routine for computing a device-wide selection using the + * specified kernel functions. + */ + template < + typename ScanInitKernelPtrT, ///< Function type of cub::DeviceScanInitKernel + typename SelectIfKernelPtrT> ///< Function type of cub::SelectIfKernelPtrT + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + FlagsInputIteratorT d_flags, ///< [in] Pointer to the input sequence of selection flags (if applicable) + SelectedOutputIteratorT d_selected_out, ///< [in] Pointer to the output sequence of selected data items + NumSelectedIteratorT d_num_selected_out, ///< [in] Pointer to the total number of items selected (i.e., length of \p d_selected_out) + SelectOpT select_op, ///< [in] Selection operator + EqualityOpT equality_op, ///< [in] Equality operator + OffsetT num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + int ptx_version, ///< [in] PTX version of dispatch kernels + ScanInitKernelPtrT scan_init_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceScanInitKernel + SelectIfKernelPtrT select_if_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceSelectSweepKernel + KernelConfig select_if_config) ///< [in] Dispatch parameters that match the policy that \p select_if_kernel was compiled for + { + +#ifndef CUB_RUNTIME_ENABLED + + // Kernel launch not supported from this device + return CubDebug(cudaErrorNotSupported); + +#else + + cudaError error = cudaSuccess; + do + { + // Get device ordinal + int device_ordinal; + if (CubDebug(error = cudaGetDevice(&device_ordinal))) break; + + // Get device SM version + int sm_version; + if (CubDebug(error = SmVersion(sm_version, device_ordinal))) break; + + // Get SM count + int sm_count; + if (CubDebug(error = cudaDeviceGetAttribute (&sm_count, cudaDevAttrMultiProcessorCount, device_ordinal))) break; + + // Number of input tiles + int tile_size = select_if_config.block_threads * select_if_config.items_per_thread; + int num_tiles = (num_items + tile_size - 1) / tile_size; + + // Specify temporary storage allocation requirements + size_t allocation_sizes[1]; + if (CubDebug(error = ScanTileStateT::AllocationSize(num_tiles, allocation_sizes[0]))) break; // bytes needed for tile status descriptors + + // Compute allocation pointers into the single storage blob (or compute the necessary size of the blob) + void* allocations[1]; + if (CubDebug(error = AliasTemporaries(d_temp_storage, temp_storage_bytes, allocations, allocation_sizes))) break; + if (d_temp_storage == NULL) + { + // Return if the caller is simply requesting the size of the storage allocation + return cudaSuccess; + } + + // Construct the tile status interface + ScanTileStateT tile_status; + if (CubDebug(error = tile_status.Init(num_tiles, allocations[0], allocation_sizes[0]))) break; + + // Log scan_init_kernel configuration + int init_grid_size = (num_tiles + INIT_KERNEL_THREADS - 1) / INIT_KERNEL_THREADS; + if (debug_synchronous) CubLog("Invoking scan_init_kernel<<<%d, %d, 0, %lld>>>()\n", init_grid_size, INIT_KERNEL_THREADS, (long long) stream); + + // Invoke scan_init_kernel to initialize tile descriptors + scan_init_kernel<<>>( + tile_status, + num_tiles); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + // Get SM occupancy for select_if_kernel + int range_select_sm_occupancy; + if (CubDebug(error = MaxSmOccupancy( + range_select_sm_occupancy, // out + sm_version, + select_if_kernel, + select_if_config.block_threads))) break; + + // Get max x-dimension of grid + int max_dim_x; + if (CubDebug(error = cudaDeviceGetAttribute(&max_dim_x, cudaDevAttrMaxGridDimX, device_ordinal))) break;; + + // Get grid size for scanning tiles + dim3 scan_grid_size; + scan_grid_size.z = 1; + scan_grid_size.y = ((unsigned int) num_tiles + max_dim_x - 1) / max_dim_x; + scan_grid_size.x = CUB_MIN(num_tiles, max_dim_x); + + // Log select_if_kernel configuration + if (debug_synchronous) CubLog("Invoking select_if_kernel<<<{%d,%d,%d}, %d, 0, %lld>>>(), %d items per thread, %d SM occupancy\n", + scan_grid_size.x, scan_grid_size.y, scan_grid_size.z, select_if_config.block_threads, (long long) stream, select_if_config.items_per_thread, range_select_sm_occupancy); + + // Invoke select_if_kernel + select_if_kernel<<>>( + d_in, + d_flags, + d_selected_out, + d_num_selected_out, + tile_status, + select_op, + equality_op, + num_items, + num_tiles); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + } + while (0); + + return error; + +#endif // CUB_RUNTIME_ENABLED + } + + + /** + * Internal dispatch routine + */ + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + InputIteratorT d_in, ///< [in] Pointer to the input sequence of data items + FlagsInputIteratorT d_flags, ///< [in] Pointer to the input sequence of selection flags (if applicable) + SelectedOutputIteratorT d_selected_out, ///< [in] Pointer to the output sequence of selected data items + NumSelectedIteratorT d_num_selected_out, ///< [in] Pointer to the total number of items selected (i.e., length of \p d_selected_out) + SelectOpT select_op, ///< [in] Selection operator + EqualityOpT equality_op, ///< [in] Equality operator + OffsetT num_items, ///< [in] Total number of input items (i.e., length of \p d_in) + cudaStream_t stream, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + { + cudaError error = cudaSuccess; + do + { + // Get PTX version + int ptx_version; + #if (CUB_PTX_ARCH == 0) + if (CubDebug(error = PtxVersion(ptx_version))) break; + #else + ptx_version = CUB_PTX_ARCH; + #endif + + // Get kernel kernel dispatch configurations + KernelConfig select_if_config; + InitConfigs(ptx_version, select_if_config); + + // Dispatch + if (CubDebug(error = Dispatch( + d_temp_storage, + temp_storage_bytes, + d_in, + d_flags, + d_selected_out, + d_num_selected_out, + select_op, + equality_op, + num_items, + stream, + debug_synchronous, + ptx_version, + DeviceScanInitKernel, + DeviceSelectSweepKernel, + select_if_config))) break; + } + while (0); + + return error; + } +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/device/dispatch/dispatch_spmv.cuh b/3rdparty/cub/cub/device/dispatch/dispatch_spmv.cuh new file mode 100644 index 00000000000..59c03e71417 --- /dev/null +++ b/3rdparty/cub/cub/device/dispatch/dispatch_spmv.cuh @@ -0,0 +1,763 @@ + +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::DeviceSpmv provides device-wide parallel operations for performing sparse-matrix * vector multiplication (SpMV). + */ + +#pragma once + +#include +#include + +#include "../../agent/single_pass_scan_operators.cuh" +#include "../../agent/agent_segment_fixup.cuh" +#include "../../agent/agent_spmv.cuh" +#include "../../util_type.cuh" +#include "../../util_debug.cuh" +#include "../../util_device.cuh" +#include "../../thread/thread_search.cuh" +#include "../../grid/grid_queue.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * SpMV kernel entry points + *****************************************************************************/ + +/** + * Spmv search kernel. Identifies merge path starting coordinates for each tile. + */ +template < + typename SpmvPolicyT, ///< Parameterized SpmvPolicy tuning policy type + typename ScanTileStateT, ///< Tile status interface type + typename OffsetT, ///< Signed integer type for sequence offsets + typename CoordinateT, ///< Merge path coordinate type + typename SpmvParamsT> ///< SpmvParams type +__global__ void DeviceSpmvSearchKernel( + ScanTileStateT tile_state, ///< [in] Tile status interface for fixup reduce-by-key kernel + int num_merge_tiles, ///< [in] Number of SpMV merge tiles (spmv grid size) + int num_segment_fixup_tiles, ///< [in] Number of reduce-by-key tiles (fixup grid size) + CoordinateT* d_tile_coordinates, ///< [out] Pointer to the temporary array of tile starting coordinates + SpmvParamsT spmv_params) ///< [in] SpMV input parameter bundle +{ + /// Constants + enum + { + BLOCK_THREADS = SpmvPolicyT::BLOCK_THREADS, + ITEMS_PER_THREAD = SpmvPolicyT::ITEMS_PER_THREAD, + TILE_ITEMS = BLOCK_THREADS * ITEMS_PER_THREAD, + }; + + typedef CacheModifiedInputIterator< + SpmvPolicyT::SEARCH_ROW_OFFSETS_LOAD_MODIFIER, + OffsetT, + OffsetT> + RowOffsetsIteratorT; + + // Initialize tile status + tile_state.InitializeStatus(num_segment_fixup_tiles); + + // Find the starting coordinate for all tiles (plus the end coordinate of the last one) + int tile_idx = (blockIdx.x * blockDim.x) + threadIdx.x; + if (tile_idx < num_merge_tiles + 1) + { + OffsetT diagonal = (tile_idx * TILE_ITEMS); + CoordinateT tile_coordinate; + CountingInputIterator nonzero_indices(0); + + // Search the merge path + MergePathSearch( + diagonal, + RowOffsetsIteratorT(spmv_params.d_row_end_offsets), + nonzero_indices, + spmv_params.num_rows, + spmv_params.num_nonzeros, + tile_coordinate); + + // Output starting offset + d_tile_coordinates[tile_idx] = tile_coordinate; + } +} + + +/** + * Spmv agent entry point + */ +template < + typename SpmvPolicyT, ///< Parameterized SpmvPolicy tuning policy type + typename ValueT, ///< Matrix and vector value type + typename OffsetT, ///< Signed integer type for sequence offsets + typename CoordinateT, ///< Merge path coordinate type + bool HAS_ALPHA, ///< Whether the input parameter Alpha is 1 + bool HAS_BETA> ///< Whether the input parameter Beta is 0 +__launch_bounds__ (int(SpmvPolicyT::BLOCK_THREADS)) +__global__ void DeviceSpmvKernel( + SpmvParams spmv_params, ///< [in] SpMV input parameter bundle + CoordinateT* d_tile_coordinates, ///< [in] Pointer to the temporary array of tile starting coordinates + KeyValuePair* d_tile_carry_pairs, ///< [out] Pointer to the temporary array carry-out dot product row-ids, one per block + int num_tiles) ///< [in] Number of merge tiles +{ + // Spmv agent type specialization + typedef AgentSpmv< + SpmvPolicyT, + ValueT, + OffsetT, + HAS_ALPHA, + HAS_BETA> + AgentSpmvT; + + // Shared memory for AgentSpmv + __shared__ typename AgentSpmvT::TempStorage temp_storage; + + AgentSpmvT(temp_storage, spmv_params).ConsumeTile( + d_tile_coordinates, + d_tile_carry_pairs, + num_tiles); +} + + +/** + * Multi-block reduce-by-key sweep kernel entry point + */ +template < + typename AgentSegmentFixupPolicyT, ///< Parameterized AgentSegmentFixupPolicy tuning policy type + typename PairsInputIteratorT, ///< Random-access input iterator type for keys + typename AggregatesOutputIteratorT, ///< Random-access output iterator type for values + typename OffsetT, ///< Signed integer type for global offsets + typename ScanTileStateT> ///< Tile status interface type +__launch_bounds__ (int(AgentSegmentFixupPolicyT::BLOCK_THREADS)) +__global__ void DeviceSegmentFixupKernel( + PairsInputIteratorT d_pairs_in, ///< [in] Pointer to the array carry-out dot product row-ids, one per spmv block + AggregatesOutputIteratorT d_aggregates_out, ///< [in,out] Output value aggregates + OffsetT num_items, ///< [in] Total number of items to select from + int num_tiles, ///< [in] Total number of tiles for the entire problem + ScanTileStateT tile_state) ///< [in] Tile status interface +{ + // Thread block type for reducing tiles of value segments + typedef AgentSegmentFixup< + AgentSegmentFixupPolicyT, + PairsInputIteratorT, + AggregatesOutputIteratorT, + cub::Equality, + cub::Sum, + OffsetT> + AgentSegmentFixupT; + + // Shared memory for AgentSegmentFixup + __shared__ typename AgentSegmentFixupT::TempStorage temp_storage; + + // Process tiles + AgentSegmentFixupT(temp_storage, d_pairs_in, d_aggregates_out, cub::Equality(), cub::Sum()).ConsumeRange( + num_items, + num_tiles, + tile_state); +} + + +/****************************************************************************** + * Dispatch + ******************************************************************************/ + +/** + * Utility class for dispatching the appropriately-tuned kernels for DeviceSpmv + */ +template < + typename ValueT, ///< Matrix and vector value type + typename OffsetT> ///< Signed integer type for global offsets +struct DispatchSpmv +{ + //--------------------------------------------------------------------- + // Constants and Types + //--------------------------------------------------------------------- + + enum + { + INIT_KERNEL_THREADS = 128 + }; + + // SpmvParams bundle type + typedef SpmvParams SpmvParamsT; + + // 2D merge path coordinate type + typedef typename CubVector::Type CoordinateT; + + // Tile status descriptor interface type + typedef ReduceByKeyScanTileState ScanTileStateT; + + // Tuple type for scanning (pairs accumulated segment-value with segment-index) + typedef KeyValuePair KeyValuePairT; + + + //--------------------------------------------------------------------- + // Tuning policies + //--------------------------------------------------------------------- + + /// SM11 + struct Policy110 + { + typedef AgentSpmvPolicy< + 128, + 1, + LOAD_DEFAULT, + LOAD_DEFAULT, + LOAD_DEFAULT, + LOAD_DEFAULT, + LOAD_DEFAULT, + false, + BLOCK_SCAN_WARP_SCANS> + SpmvPolicyT; + + typedef AgentSegmentFixupPolicy< + 128, + 4, + BLOCK_LOAD_VECTORIZE, + LOAD_DEFAULT, + BLOCK_SCAN_WARP_SCANS> + SegmentFixupPolicyT; + }; + + /// SM20 + struct Policy200 + { + typedef AgentSpmvPolicy< + 96, + 18, + LOAD_DEFAULT, + LOAD_DEFAULT, + LOAD_DEFAULT, + LOAD_DEFAULT, + LOAD_DEFAULT, + false, + BLOCK_SCAN_RAKING> + SpmvPolicyT; + + typedef AgentSegmentFixupPolicy< + 128, + 4, + BLOCK_LOAD_VECTORIZE, + LOAD_DEFAULT, + BLOCK_SCAN_WARP_SCANS> + SegmentFixupPolicyT; + + }; + + + + /// SM30 + struct Policy300 + { + typedef AgentSpmvPolicy< + 96, + 6, + LOAD_DEFAULT, + LOAD_DEFAULT, + LOAD_DEFAULT, + LOAD_DEFAULT, + LOAD_DEFAULT, + false, + BLOCK_SCAN_WARP_SCANS> + SpmvPolicyT; + + typedef AgentSegmentFixupPolicy< + 128, + 4, + BLOCK_LOAD_VECTORIZE, + LOAD_DEFAULT, + BLOCK_SCAN_WARP_SCANS> + SegmentFixupPolicyT; + + }; + + + /// SM35 + struct Policy350 + { + typedef AgentSpmvPolicy< + (sizeof(ValueT) > 4) ? 96 : 128, + (sizeof(ValueT) > 4) ? 4 : 7, + LOAD_LDG, + LOAD_CA, + LOAD_LDG, + LOAD_LDG, + LOAD_LDG, + (sizeof(ValueT) > 4) ? true : false, + BLOCK_SCAN_WARP_SCANS> + SpmvPolicyT; + + typedef AgentSegmentFixupPolicy< + 128, + 3, + BLOCK_LOAD_VECTORIZE, + LOAD_LDG, + BLOCK_SCAN_WARP_SCANS> + SegmentFixupPolicyT; + }; + + + /// SM37 + struct Policy370 + { + + typedef AgentSpmvPolicy< + (sizeof(ValueT) > 4) ? 128 : 128, + (sizeof(ValueT) > 4) ? 9 : 14, + LOAD_LDG, + LOAD_CA, + LOAD_LDG, + LOAD_LDG, + LOAD_LDG, + false, + BLOCK_SCAN_WARP_SCANS> + SpmvPolicyT; + + typedef AgentSegmentFixupPolicy< + 128, + 3, + BLOCK_LOAD_VECTORIZE, + LOAD_LDG, + BLOCK_SCAN_WARP_SCANS> + SegmentFixupPolicyT; + }; + + /// SM50 + struct Policy500 + { + typedef AgentSpmvPolicy< + (sizeof(ValueT) > 4) ? 64 : 128, + (sizeof(ValueT) > 4) ? 6 : 7, + LOAD_LDG, + LOAD_DEFAULT, + (sizeof(ValueT) > 4) ? LOAD_LDG : LOAD_DEFAULT, + (sizeof(ValueT) > 4) ? LOAD_LDG : LOAD_DEFAULT, + LOAD_LDG, + (sizeof(ValueT) > 4) ? true : false, + (sizeof(ValueT) > 4) ? BLOCK_SCAN_WARP_SCANS : BLOCK_SCAN_RAKING_MEMOIZE> + SpmvPolicyT; + + + typedef AgentSegmentFixupPolicy< + 128, + 3, + BLOCK_LOAD_VECTORIZE, + LOAD_LDG, + BLOCK_SCAN_RAKING_MEMOIZE> + SegmentFixupPolicyT; + }; + + + + //--------------------------------------------------------------------- + // Tuning policies of current PTX compiler pass + //--------------------------------------------------------------------- + +#if (CUB_PTX_ARCH >= 500) + typedef Policy500 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 370) + typedef Policy370 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 350) + typedef Policy350 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 300) + typedef Policy300 PtxPolicy; + +#elif (CUB_PTX_ARCH >= 200) + typedef Policy200 PtxPolicy; + +#else + typedef Policy110 PtxPolicy; + +#endif + + // "Opaque" policies (whose parameterizations aren't reflected in the type signature) + struct PtxSpmvPolicyT : PtxPolicy::SpmvPolicyT {}; + struct PtxSegmentFixupPolicy : PtxPolicy::SegmentFixupPolicyT {}; + + + //--------------------------------------------------------------------- + // Utilities + //--------------------------------------------------------------------- + + /** + * Initialize kernel dispatch configurations with the policies corresponding to the PTX assembly we will use + */ + template + CUB_RUNTIME_FUNCTION __forceinline__ + static void InitConfigs( + int ptx_version, + KernelConfig &spmv_config, + KernelConfig &segment_fixup_config) + { + #if (CUB_PTX_ARCH > 0) + + // We're on the device, so initialize the kernel dispatch configurations with the current PTX policy + spmv_config.template Init(); + segment_fixup_config.template Init(); + + #else + + // We're on the host, so lookup and initialize the kernel dispatch configurations with the policies that match the device's PTX version + if (ptx_version >= 500) + { + spmv_config.template Init(); + segment_fixup_config.template Init(); + } + else if (ptx_version >= 370) + { + spmv_config.template Init(); + segment_fixup_config.template Init(); + } + else if (ptx_version >= 350) + { + spmv_config.template Init(); + segment_fixup_config.template Init(); + } + else if (ptx_version >= 300) + { + spmv_config.template Init(); + segment_fixup_config.template Init(); + + } + else if (ptx_version >= 200) + { + spmv_config.template Init(); + segment_fixup_config.template Init(); + } + else + { + spmv_config.template Init(); + segment_fixup_config.template Init(); + } + + #endif + } + + + /** + * Kernel kernel dispatch configuration. + */ + struct KernelConfig + { + int block_threads; + int items_per_thread; + int tile_items; + + template + CUB_RUNTIME_FUNCTION __forceinline__ + void Init() + { + block_threads = PolicyT::BLOCK_THREADS; + items_per_thread = PolicyT::ITEMS_PER_THREAD; + tile_items = block_threads * items_per_thread; + } + }; + + + //--------------------------------------------------------------------- + // Dispatch entrypoints + //--------------------------------------------------------------------- + + /** + * Internal dispatch routine for computing a device-wide reduction using the + * specified kernel functions. + * + * If the input is larger than a single tile, this method uses two-passes of + * kernel invocations. + */ + template < + typename SpmvSearchKernelT, ///< Function type of cub::AgentSpmvSearchKernel + typename SpmvKernelT, ///< Function type of cub::AgentSpmvKernel + typename SegmentFixupKernelT> ///< Function type of cub::DeviceSegmentFixupKernelT + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SpmvParamsT& spmv_params, ///< SpMV input parameter bundle + cudaStream_t stream, ///< [in] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous, ///< [in] Whether or not to synchronize the stream after every kernel launch to check for errors. Also causes launch configurations to be printed to the console. Default is \p false. + SpmvSearchKernelT spmv_search_kernel, ///< [in] Kernel function pointer to parameterization of AgentSpmvSearchKernel + SpmvKernelT spmv_kernel, ///< [in] Kernel function pointer to parameterization of AgentSpmvKernel + SegmentFixupKernelT segment_fixup_kernel, ///< [in] Kernel function pointer to parameterization of cub::DeviceSegmentFixupKernel + KernelConfig spmv_config, ///< [in] Dispatch parameters that match the policy that \p spmv_kernel was compiled for + KernelConfig segment_fixup_config) ///< [in] Dispatch parameters that match the policy that \p segment_fixup_kernel was compiled for + { +#ifndef CUB_RUNTIME_ENABLED + + // Kernel launch not supported from this device + return CubDebug(cudaErrorNotSupported ); + +#else + cudaError error = cudaSuccess; + do + { + // Get device ordinal + int device_ordinal; + if (CubDebug(error = cudaGetDevice(&device_ordinal))) break; + + // Get device SM version + int sm_version; + if (CubDebug(error = SmVersion(sm_version, device_ordinal))) break; + + // Get SM count + int sm_count; + if (CubDebug(error = cudaDeviceGetAttribute (&sm_count, cudaDevAttrMultiProcessorCount, device_ordinal))) break; + + // Get max x-dimension of grid + int max_dim_x; + if (CubDebug(error = cudaDeviceGetAttribute(&max_dim_x, cudaDevAttrMaxGridDimX, device_ordinal))) break;; + + // Total number of spmv work items + int num_merge_items = spmv_params.num_rows + spmv_params.num_nonzeros; + + // Tile sizes of kernels + int merge_tile_size = spmv_config.block_threads * spmv_config.items_per_thread; + int segment_fixup_tile_size = segment_fixup_config.block_threads * segment_fixup_config.items_per_thread; + + // Number of tiles for kernels + unsigned int num_merge_tiles = (num_merge_items + merge_tile_size - 1) / merge_tile_size; + unsigned int num_segment_fixup_tiles = (num_merge_tiles + segment_fixup_tile_size - 1) / segment_fixup_tile_size; + + // Get SM occupancy for kernels + int spmv_sm_occupancy; + if (CubDebug(error = MaxSmOccupancy( + spmv_sm_occupancy, + sm_version, + spmv_kernel, + spmv_config.block_threads))) break; + + int segment_fixup_sm_occupancy; + if (CubDebug(error = MaxSmOccupancy( + segment_fixup_sm_occupancy, + sm_version, + segment_fixup_kernel, + segment_fixup_config.block_threads))) break; + + // Get grid dimensions + dim3 spmv_grid_size( + CUB_MIN(num_merge_tiles, max_dim_x), + (num_merge_tiles + max_dim_x - 1) / max_dim_x, + 1); + + dim3 segment_fixup_grid_size( + CUB_MIN(num_segment_fixup_tiles, max_dim_x), + (num_segment_fixup_tiles + max_dim_x - 1) / max_dim_x, + 1); + + // Get the temporary storage allocation requirements + size_t allocation_sizes[3]; + if (CubDebug(error = ScanTileStateT::AllocationSize(num_segment_fixup_tiles, allocation_sizes[0]))) break; // bytes needed for reduce-by-key tile status descriptors + allocation_sizes[1] = num_merge_tiles * sizeof(KeyValuePairT); // bytes needed for block carry-out pairs + allocation_sizes[2] = (num_merge_tiles + 1) * sizeof(CoordinateT); // bytes needed for tile starting coordinates + + // Alias the temporary allocations from the single storage blob (or compute the necessary size of the blob) + void* allocations[3]; + if (CubDebug(error = AliasTemporaries(d_temp_storage, temp_storage_bytes, allocations, allocation_sizes))) break; + if (d_temp_storage == NULL) + { + // Return if the caller is simply requesting the size of the storage allocation + return cudaSuccess; + } + + // Construct the tile status interface + ScanTileStateT tile_state; + if (CubDebug(error = tile_state.Init(num_segment_fixup_tiles, allocations[0], allocation_sizes[0]))) break; + + // Alias the other allocations + KeyValuePairT* d_tile_carry_pairs = (KeyValuePairT*) allocations[1]; // Agent carry-out pairs + CoordinateT* d_tile_coordinates = (CoordinateT*) allocations[2]; // Agent starting coordinates + + // Get search/init grid dims + int search_block_size = INIT_KERNEL_THREADS; + int search_grid_size = (num_merge_tiles + 1 + search_block_size - 1) / search_block_size; + +#if (CUB_PTX_ARCH == 0) + // Init textures + if (CubDebug(error = spmv_params.t_vector_x.BindTexture(spmv_params.d_vector_x))) break; +#endif + // Log spmv_search_kernel configuration + if (debug_synchronous) CubLog("Invoking spmv_search_kernel<<<%d, %d, 0, %lld>>>()\n", + search_grid_size, search_block_size, (long long) stream); + + // Invoke spmv_search_kernel + spmv_search_kernel<<>>( + tile_state, + num_merge_tiles, + num_segment_fixup_tiles, + d_tile_coordinates, + spmv_params); + + // Log spmv_kernel configuration + if (debug_synchronous) CubLog("Invoking spmv_kernel<<<{%d,%d,%d}, %d, 0, %lld>>>(), %d items per thread, %d SM occupancy\n", + spmv_grid_size.x, spmv_grid_size.y, spmv_grid_size.z, spmv_config.block_threads, (long long) stream, spmv_config.items_per_thread, spmv_sm_occupancy); + + // Invoke spmv_kernel + spmv_kernel<<>>( + spmv_params, + d_tile_coordinates, + d_tile_carry_pairs, + num_merge_tiles); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + + // Run reduce-by-key fixup if necessary + if (num_merge_tiles > 1) + { + // Log segment_fixup_kernel configuration + if (debug_synchronous) CubLog("Invoking segment_fixup_kernel<<<{%d,%d,%d}, %d, 0, %lld>>>(), %d items per thread, %d SM occupancy\n", + segment_fixup_grid_size.x, segment_fixup_grid_size.y, segment_fixup_grid_size.z, segment_fixup_config.block_threads, (long long) stream, segment_fixup_config.items_per_thread, segment_fixup_sm_occupancy); + + // Invoke segment_fixup_kernel + segment_fixup_kernel<<>>( + d_tile_carry_pairs, + spmv_params.d_vector_y, + num_merge_tiles, + num_segment_fixup_tiles, + tile_state); + + // Check for failure to launch + if (CubDebug(error = cudaPeekAtLastError())) break; + + // Sync the stream if specified to flush runtime errors + if (debug_synchronous && (CubDebug(error = SyncStream(stream)))) break; + } + +#if (CUB_PTX_ARCH == 0) + // Free textures + if (CubDebug(error = spmv_params.t_vector_x.UnbindTexture())) break; +#endif + } + while (0); + + return error; + +#endif // CUB_RUNTIME_ENABLED + } + + + /** + * Internal dispatch routine for computing a device-wide reduction + */ + CUB_RUNTIME_FUNCTION __forceinline__ + static cudaError_t Dispatch( + void* d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t& temp_storage_bytes, ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation + SpmvParamsT& spmv_params, ///< SpMV input parameter bundle + cudaStream_t stream = 0, ///< [in] [optional] CUDA stream to launch kernels within. Default is stream0. + bool debug_synchronous = false) ///< [in] [optional] Whether or not to synchronize the stream after every kernel launch to check for errors. May cause significant slowdown. Default is \p false. + { + cudaError error = cudaSuccess; + do + { + // Get PTX version + int ptx_version; + #if (CUB_PTX_ARCH == 0) + if (CubDebug(error = PtxVersion(ptx_version))) break; + #else + ptx_version = CUB_PTX_ARCH; + #endif + + // Get kernel kernel dispatch configurations + KernelConfig spmv_config, segment_fixup_config; + InitConfigs(ptx_version, spmv_config, segment_fixup_config); +/* + // Dispatch + if (spmv_params.beta == 0.0) + { + if (spmv_params.alpha == 1.0) + { +*/ + // Dispatch y = A*x + if (CubDebug(error = Dispatch( + d_temp_storage, temp_storage_bytes, spmv_params, stream, debug_synchronous, + DeviceSpmvSearchKernel, + DeviceSpmvKernel, + DeviceSegmentFixupKernel, + spmv_config, segment_fixup_config))) break; +/* + } + else + { + // Dispatch y = alpha*A*x + if (CubDebug(error = Dispatch( + d_temp_storage, temp_storage_bytes, spmv_params, stream, debug_synchronous, + DeviceSpmvSearchKernel, + DeviceSpmvKernel, + DeviceSegmentFixupKernel, + spmv_config, segment_fixup_config))) break; + } + } + else + { + if (spmv_params.alpha == 1.0) + { + // Dispatch y = A*x + beta*y + if (CubDebug(error = Dispatch( + d_temp_storage, temp_storage_bytes, spmv_params, stream, debug_synchronous, + DeviceSpmvSearchKernel, + DeviceSpmvKernel, + DeviceSegmentFixupKernel, + spmv_config, segment_fixup_config))) break; + } + else + { + // Dispatch y = alpha*A*x + beta*y + if (CubDebug(error = Dispatch( + d_temp_storage, temp_storage_bytes, spmv_params, stream, debug_synchronous, + DeviceSpmvSearchKernel, + DeviceSpmvKernel, + DeviceSegmentFixupKernel, + spmv_config, segment_fixup_config))) break; + } + } +*/ + } + while (0); + + return error; + } +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/grid/grid_barrier.cuh b/3rdparty/cub/cub/grid/grid_barrier.cuh new file mode 100644 index 00000000000..3dfd2556322 --- /dev/null +++ b/3rdparty/cub/cub/grid/grid_barrier.cuh @@ -0,0 +1,211 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::GridBarrier implements a software global barrier among thread blocks within a CUDA grid + */ + +#pragma once + +#include "../util_debug.cuh" +#include "../util_namespace.cuh" +#include "../thread/thread_load.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup GridModule + * @{ + */ + + +/** + * \brief GridBarrier implements a software global barrier among thread blocks within a CUDA grid + */ +class GridBarrier +{ +protected : + + typedef unsigned int SyncFlag; + + // Counters in global device memory + SyncFlag* d_sync; + +public: + + /** + * Constructor + */ + GridBarrier() : d_sync(NULL) {} + + + /** + * Synchronize + */ + __device__ __forceinline__ void Sync() const + { + volatile SyncFlag *d_vol_sync = d_sync; + + // Threadfence and syncthreads to make sure global writes are visible before + // thread-0 reports in with its sync counter + __threadfence(); + __syncthreads(); + + if (blockIdx.x == 0) + { + // Report in ourselves + if (threadIdx.x == 0) + { + d_vol_sync[blockIdx.x] = 1; + } + + __syncthreads(); + + // Wait for everyone else to report in + for (int peer_block = threadIdx.x; peer_block < gridDim.x; peer_block += blockDim.x) + { + while (ThreadLoad(d_sync + peer_block) == 0) + { + __threadfence_block(); + } + } + + __syncthreads(); + + // Let everyone know it's safe to proceed + for (int peer_block = threadIdx.x; peer_block < gridDim.x; peer_block += blockDim.x) + { + d_vol_sync[peer_block] = 0; + } + } + else + { + if (threadIdx.x == 0) + { + // Report in + d_vol_sync[blockIdx.x] = 1; + + // Wait for acknowledgment + while (ThreadLoad(d_sync + blockIdx.x) == 1) + { + __threadfence_block(); + } + } + + __syncthreads(); + } + } +}; + + +/** + * \brief GridBarrierLifetime extends GridBarrier to provide lifetime management of the temporary device storage needed for cooperation. + * + * Uses RAII for lifetime, i.e., device resources are reclaimed when + * the destructor is called. + */ +class GridBarrierLifetime : public GridBarrier +{ +protected: + + // Number of bytes backed by d_sync + size_t sync_bytes; + +public: + + /** + * Constructor + */ + GridBarrierLifetime() : GridBarrier(), sync_bytes(0) {} + + + /** + * DeviceFrees and resets the progress counters + */ + cudaError_t HostReset() + { + cudaError_t retval = cudaSuccess; + if (d_sync) + { + CubDebug(retval = cudaFree(d_sync)); + d_sync = NULL; + } + sync_bytes = 0; + return retval; + } + + + /** + * Destructor + */ + virtual ~GridBarrierLifetime() + { + HostReset(); + } + + + /** + * Sets up the progress counters for the next kernel launch (lazily + * allocating and initializing them if necessary) + */ + cudaError_t Setup(int sweep_grid_size) + { + cudaError_t retval = cudaSuccess; + do { + size_t new_sync_bytes = sweep_grid_size * sizeof(SyncFlag); + if (new_sync_bytes > sync_bytes) + { + if (d_sync) + { + if (CubDebug(retval = cudaFree(d_sync))) break; + } + + sync_bytes = new_sync_bytes; + + // Allocate and initialize to zero + if (CubDebug(retval = cudaMalloc((void**) &d_sync, sync_bytes))) break; + if (CubDebug(retval = cudaMemset(d_sync, 0, new_sync_bytes))) break; + } + } while (0); + + return retval; + } +}; + + +/** @} */ // end group GridModule + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/grid/grid_even_share.cuh b/3rdparty/cub/cub/grid/grid_even_share.cuh new file mode 100644 index 00000000000..110eab5144c --- /dev/null +++ b/3rdparty/cub/cub/grid/grid_even_share.cuh @@ -0,0 +1,185 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::GridEvenShare is a descriptor utility for distributing input among CUDA threadblocks in an "even-share" fashion. Each threadblock gets roughly the same number of fixed-size work units (grains). + */ + + +#pragma once + +#include "../util_namespace.cuh" +#include "../util_macro.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup GridModule + * @{ + */ + + +/** + * \brief GridEvenShare is a descriptor utility for distributing input among CUDA threadblocks in an "even-share" fashion. Each threadblock gets roughly the same number of fixed-size work units (grains). + * + * \par Overview + * GridEvenShare indicates which sections of input are to be mapped onto which threadblocks. + * Threadblocks may receive one of three different amounts of work: "big", "normal", + * and "last". The "big" workloads are one scheduling grain larger than "normal". The "last" work unit + * for the last threadblock may be partially-full if the input is not an even multiple of + * the scheduling grain size. + * + * \par + * Before invoking a child grid, a parent thread will typically construct an instance of + * GridEvenShare. The instance can be passed to child threadblocks which can + * initialize their per-threadblock offsets using \p BlockInit(). + * + * \tparam OffsetT Signed integer type for global offsets + */ +template +struct GridEvenShare +{ + OffsetT total_grains; + int big_blocks; + OffsetT big_share; + OffsetT normal_share; + OffsetT normal_base_offset; + + /// Total number of input items + OffsetT num_items; + + /// Grid size in threadblocks + int grid_size; + + /// OffsetT into input marking the beginning of the owning thread block's segment of input tiles + OffsetT block_offset; + + /// OffsetT into input of marking the end (one-past) of the owning thread block's segment of input tiles + OffsetT block_end; + + /** + * \brief Default constructor. Zero-initializes block-specific fields. + */ + __host__ __device__ __forceinline__ GridEvenShare() : + num_items(0), + grid_size(0), + block_offset(0), + block_end(0) {} + + /** + * \brief Constructor. Initializes the grid-specific members \p num_items and \p grid_size. To be called prior prior to kernel launch) + */ + __host__ __device__ __forceinline__ GridEvenShare( + OffsetT num_items, ///< Total number of input items + int max_grid_size, ///< Maximum grid size allowable (actual grid size may be less if not warranted by the the number of input items) + int schedule_granularity) ///< Granularity by which the input can be parcelled into and distributed among threablocks. Usually the thread block's native tile size (or a multiple thereof. + { + this->num_items = num_items; + this->block_offset = num_items; + this->block_end = num_items; + this->total_grains = (num_items + schedule_granularity - 1) / schedule_granularity; + this->grid_size = CUB_MIN(total_grains, max_grid_size); + OffsetT grains_per_block = total_grains / grid_size; + this->big_blocks = total_grains - (grains_per_block * grid_size); // leftover grains go to big blocks + this->normal_share = grains_per_block * schedule_granularity; + this->normal_base_offset = big_blocks * schedule_granularity; + this->big_share = normal_share + schedule_granularity; + } + + + + /** + * \brief Initializes ranges for the specified partition index + */ + __device__ __forceinline__ void Init(int partition_id) + { + if (partition_id < big_blocks) + { + // This threadblock gets a big share of grains (grains_per_block + 1) + block_offset = (partition_id * big_share); + block_end = block_offset + big_share; + } + else if (partition_id < total_grains) + { + // This threadblock gets a normal share of grains (grains_per_block) + block_offset = normal_base_offset + (partition_id * normal_share); + block_end = CUB_MIN(num_items, block_offset + normal_share); + } + } + + + /** + * \brief Initializes ranges for the current thread block (e.g., to be called by each threadblock after startup) + */ + __device__ __forceinline__ void BlockInit() + { + Init(blockIdx.x); + } + + + /** + * Print to stdout + */ + __host__ __device__ __forceinline__ void Print() + { + printf( +#if (CUB_PTX_ARCH > 0) + "\tthreadblock(%d) " + "block_offset(%lu) " + "block_end(%lu) " +#endif + "num_items(%lu) " + "total_grains(%lu) " + "big_blocks(%lu) " + "big_share(%lu) " + "normal_share(%lu)\n", +#if (CUB_PTX_ARCH > 0) + blockIdx.x, + (unsigned long) block_offset, + (unsigned long) block_end, +#endif + (unsigned long) num_items, + (unsigned long) total_grains, + (unsigned long) big_blocks, + (unsigned long) big_share, + (unsigned long) normal_share); + } +}; + + + +/** @} */ // end group GridModule + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/grid/grid_mapping.cuh b/3rdparty/cub/cub/grid/grid_mapping.cuh new file mode 100644 index 00000000000..6df0e534180 --- /dev/null +++ b/3rdparty/cub/cub/grid/grid_mapping.cuh @@ -0,0 +1,95 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::GridMappingStrategy enumerates alternative strategies for mapping constant-sized tiles of device-wide data onto a grid of CUDA thread blocks. + */ + +#pragma once + +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup GridModule + * @{ + */ + + +/****************************************************************************** + * Mapping policies + *****************************************************************************/ + + +/** + * \brief cub::GridMappingStrategy enumerates alternative strategies for mapping constant-sized tiles of device-wide data onto a grid of CUDA thread blocks. + */ +enum GridMappingStrategy +{ + /** + * \brief An "even-share" strategy for assigning input tiles to thread blocks. + * + * \par Overview + * The input is evenly partitioned into \p p segments, where \p p is + * constant and corresponds loosely to the number of thread blocks that may + * actively reside on the target device. Each segment is comprised of + * consecutive tiles, where a tile is a small, constant-sized unit of input + * to be processed to completion before the thread block terminates or + * obtains more work. The kernel invokes \p p thread blocks, each + * of which iteratively consumes a segment of n/p elements + * in tile-size increments. + */ + GRID_MAPPING_EVEN_SHARE, + + /** + * \brief A dynamic "queue-based" strategy for assigning input tiles to thread blocks. + * + * \par Overview + * The input is treated as a queue to be dynamically consumed by a grid of + * thread blocks. Work is atomically dequeued in tiles, where a tile is a + * unit of input to be processed to completion before the thread block + * terminates or obtains more work. The grid size \p p is constant, + * loosely corresponding to the number of thread blocks that may actively + * reside on the target device. + */ + GRID_MAPPING_DYNAMIC, +}; + + +/** @} */ // end group GridModule + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/grid/grid_queue.cuh b/3rdparty/cub/cub/grid/grid_queue.cuh new file mode 100644 index 00000000000..30b5c9777b0 --- /dev/null +++ b/3rdparty/cub/cub/grid/grid_queue.cuh @@ -0,0 +1,216 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::GridQueue is a descriptor utility for dynamic queue management. + */ + +#pragma once + +#include "../util_namespace.cuh" +#include "../util_debug.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup GridModule + * @{ + */ + + +/** + * \brief GridQueue is a descriptor utility for dynamic queue management. + * + * \par Overview + * GridQueue descriptors provides abstractions for "filling" or + * "draining" globally-shared vectors. + * + * \par + * A "filling" GridQueue works by atomically-adding to a zero-initialized counter, + * returning a unique offset for the calling thread to write its items. + * The GridQueue maintains the total "fill-size". The fill counter must be reset + * using GridQueue::ResetFill by the host or kernel instance prior to the kernel instance that + * will be filling. + * + * \par + * Similarly, a "draining" GridQueue works by works by atomically-incrementing a + * zero-initialized counter, returning a unique offset for the calling thread to + * read its items. Threads can safely drain until the array's logical fill-size is + * exceeded. The drain counter must be reset using GridQueue::ResetDrain or + * GridQueue::FillAndResetDrain by the host or kernel instance prior to the kernel instance that + * will be filling. (For dynamic work distribution of existing data, the corresponding fill-size + * is simply the number of elements in the array.) + * + * \par + * Iterative work management can be implemented simply with a pair of flip-flopping + * work buffers, each with an associated set of fill and drain GridQueue descriptors. + * + * \tparam OffsetT Signed integer type for global offsets + */ +template +class GridQueue +{ +private: + + /// Counter indices + enum + { + FILL = 0, + DRAIN = 1, + }; + + /// Pair of counters + OffsetT *d_counters; + +public: + + /// Returns the device allocation size in bytes needed to construct a GridQueue instance + __host__ __device__ __forceinline__ + static size_t AllocationSize() + { + return sizeof(OffsetT) * 2; + } + + + /// Constructs an invalid GridQueue descriptor + __host__ __device__ __forceinline__ GridQueue() + : + d_counters(NULL) + {} + + + /// Constructs a GridQueue descriptor around the device storage allocation + __host__ __device__ __forceinline__ GridQueue( + void *d_storage) ///< Device allocation to back the GridQueue. Must be at least as big as AllocationSize(). + : + d_counters((OffsetT*) d_storage) + {} + + + /// This operation sets the fill-size and resets the drain counter, preparing the GridQueue for draining in the next kernel instance. To be called by the host or by a kernel prior to that which will be draining. + __host__ __device__ __forceinline__ cudaError_t FillAndResetDrain( + OffsetT fill_size, + cudaStream_t stream = 0) + { +#if (CUB_PTX_ARCH > 0) + d_counters[FILL] = fill_size; + d_counters[DRAIN] = 0; + return cudaSuccess; +#else + OffsetT counters[2]; + counters[FILL] = fill_size; + counters[DRAIN] = 0; + return CubDebug(cudaMemcpyAsync(d_counters, counters, sizeof(OffsetT) * 2, cudaMemcpyHostToDevice, stream)); +#endif + } + + + /// This operation resets the drain so that it may advance to meet the existing fill-size. To be called by the host or by a kernel prior to that which will be draining. + __host__ __device__ __forceinline__ cudaError_t ResetDrain(cudaStream_t stream = 0) + { +#if (CUB_PTX_ARCH > 0) + d_counters[DRAIN] = 0; + return cudaSuccess; +#else + return CubDebug(cudaMemsetAsync(d_counters + DRAIN, 0, sizeof(OffsetT), stream)); +#endif + } + + + /// This operation resets the fill counter. To be called by the host or by a kernel prior to that which will be filling. + __host__ __device__ __forceinline__ cudaError_t ResetFill(cudaStream_t stream = 0) + { +#if (CUB_PTX_ARCH > 0) + d_counters[FILL] = 0; + return cudaSuccess; +#else + return CubDebug(cudaMemsetAsync(d_counters + FILL, 0, sizeof(OffsetT), stream)); +#endif + } + + + /// Returns the fill-size established by the parent or by the previous kernel. + __host__ __device__ __forceinline__ cudaError_t FillSize( + OffsetT &fill_size, + cudaStream_t stream = 0) + { +#if (CUB_PTX_ARCH > 0) + fill_size = d_counters[FILL]; + return cudaSuccess; +#else + return CubDebug(cudaMemcpyAsync(&fill_size, d_counters + FILL, sizeof(OffsetT), cudaMemcpyDeviceToHost, stream)); +#endif + } + + + /// Drain \p num_items from the queue. Returns offset from which to read items. To be called from CUDA kernel. + __device__ __forceinline__ OffsetT Drain(OffsetT num_items) + { + return atomicAdd(d_counters + DRAIN, num_items); + } + + + /// Fill \p num_items into the queue. Returns offset from which to write items. To be called from CUDA kernel. + __device__ __forceinline__ OffsetT Fill(OffsetT num_items) + { + return atomicAdd(d_counters + FILL, num_items); + } +}; + + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + +/** + * Reset grid queue (call with 1 block of 1 thread) + */ +template +__global__ void FillAndResetDrainKernel( + GridQueue grid_queue, + OffsetT num_items) +{ + grid_queue.FillAndResetDrain(num_items); +} + + + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + +/** @} */ // end group GridModule + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + + diff --git a/3rdparty/cub/cub/host/spinlock.cuh b/3rdparty/cub/cub/host/spinlock.cuh new file mode 100644 index 00000000000..738a120db0d --- /dev/null +++ b/3rdparty/cub/cub/host/spinlock.cuh @@ -0,0 +1,123 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Simple x86/x64 atomic spinlock, portable across MS Windows (cl.exe) & Linux (g++) + */ + + +#pragma once + +#if defined(_WIN32) || defined(_WIN64) + #include + #include + #undef small // Windows is terrible for polluting macro namespace + + /** + * Compiler read/write barrier + */ + #pragma intrinsic(_ReadWriteBarrier) + +#endif + +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +#if defined(_MSC_VER) + + // Microsoft VC++ + typedef long Spinlock; + +#else + + // GNU g++ + typedef int Spinlock; + + /** + * Compiler read/write barrier + */ + __forceinline__ void _ReadWriteBarrier() + { + __sync_synchronize(); + } + + /** + * Atomic exchange + */ + __forceinline__ long _InterlockedExchange(volatile int * const Target, const int Value) + { + // NOTE: __sync_lock_test_and_set would be an acquire barrier, so we force a full barrier + _ReadWriteBarrier(); + return __sync_lock_test_and_set(Target, Value); + } + + /** + * Pause instruction to prevent excess processor bus usage + */ + __forceinline__ void YieldProcessor() + { +#ifndef __arm__ + asm volatile("pause\n": : :"memory"); +#endif // __arm__ + } + +#endif // defined(_MSC_VER) + +/** + * Return when the specified spinlock has been acquired + */ +__forceinline__ void Lock(volatile Spinlock *lock) +{ + while (1) + { + if (!_InterlockedExchange(lock, 1)) return; + while (*lock) YieldProcessor(); + } +} + + +/** + * Release the specified spinlock + */ +__forceinline__ void Unlock(volatile Spinlock *lock) +{ + _ReadWriteBarrier(); + *lock = 0; +} + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + diff --git a/3rdparty/cub/cub/iterator/arg_index_input_iterator.cuh b/3rdparty/cub/cub/iterator/arg_index_input_iterator.cuh new file mode 100644 index 00000000000..52bb0433a6f --- /dev/null +++ b/3rdparty/cub/cub/iterator/arg_index_input_iterator.cuh @@ -0,0 +1,256 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Random-access iterator types + */ + +#pragma once + +#include +#include + +#include "../thread/thread_load.cuh" +#include "../thread/thread_store.cuh" +#include "../util_device.cuh" +#include "../util_namespace.cuh" + +#include + +#if (THRUST_VERSION >= 100700) + // This iterator is compatible with Thrust API 1.7 and newer + #include + #include +#endif // THRUST_VERSION + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \addtogroup UtilIterator + * @{ + */ + + +/** + * \brief A random-access input wrapper for pairing dereferenced values with their corresponding indices (forming \p KeyValuePair tuples). + * + * \par Overview + * - ArgIndexInputIteratorTwraps a random access input iterator \p itr of type \p InputIteratorT. + * Dereferencing an ArgIndexInputIteratorTat offset \p i produces a \p KeyValuePair value whose + * \p key field is \p i and whose \p value field is itr[i]. + * - Can be used with any data type. + * - Can be constructed, manipulated, and exchanged within and between host and device + * functions. Wrapped host memory can only be dereferenced on the host, and wrapped + * device memory can only be dereferenced on the device. + * - Compatible with Thrust API v1.7 or newer. + * + * \par Snippet + * The code snippet below illustrates the use of \p ArgIndexInputIteratorTto + * dereference an array of doubles + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize a device array + * double *d_in; // e.g., [8.0, 6.0, 7.0, 5.0, 3.0, 0.0, 9.0] + * + * // Create an iterator wrapper + * cub::ArgIndexInputIterator itr(d_in); + * + * // Within device code: + * typedef typename cub::ArgIndexInputIterator::value_type Tuple; + * Tuple item_offset_pair.key = *itr; + * printf("%f @ %d\n", + * item_offset_pair.value, + * item_offset_pair.key); // 8.0 @ 0 + * + * itr = itr + 6; + * item_offset_pair.key = *itr; + * printf("%f @ %d\n", + * item_offset_pair.value, + * item_offset_pair.key); // 9.0 @ 6 + * + * \endcode + * + * \tparam InputIteratorT The type of the wrapped input iterator + * \tparam OffsetT The difference type of this iterator (Default: \p ptrdiff_t) + */ +template < + typename InputIteratorT, + typename OffsetT = ptrdiff_t> +class ArgIndexInputIterator +{ +private: + + // Data type of input iterator + typedef typename std::iterator_traits::value_type T; + +public: + + + // Required iterator traits + typedef ArgIndexInputIterator self_type; ///< My own type + typedef OffsetT difference_type; ///< Type to express the result of subtracting one iterator from another + typedef KeyValuePair value_type; ///< The type of the element the iterator can point to + typedef value_type* pointer; ///< The type of a pointer to an element the iterator can point to + typedef value_type reference; ///< The type of a reference to an element the iterator can point to + +#if (THRUST_VERSION >= 100700) + // Use Thrust's iterator categories so we can use these iterators in Thrust 1.7 (or newer) methods + typedef typename thrust::detail::iterator_facade_category< + thrust::any_system_tag, + thrust::random_access_traversal_tag, + value_type, + reference + >::type iterator_category; ///< The iterator category +#else + typedef std::random_access_iterator_tag iterator_category; ///< The iterator category +#endif // THRUST_VERSION + +private: + + InputIteratorT itr; + difference_type offset; + +public: + + /// Constructor + __host__ __device__ __forceinline__ ArgIndexInputIterator( + InputIteratorT itr, ///< Input iterator to wrap + difference_type offset = 0) ///< OffsetT (in items) from \p itr denoting the position of the iterator + : + itr(itr), + offset(offset) + {} + + /// Postfix increment + __host__ __device__ __forceinline__ self_type operator++(int) + { + self_type retval = *this; + offset++; + return retval; + } + + /// Prefix increment + __host__ __device__ __forceinline__ self_type operator++() + { + offset++; + return *this; + } + + /// Indirection + __host__ __device__ __forceinline__ reference operator*() const + { + value_type retval; + retval.value = itr[offset]; + retval.key = offset; + return retval; + } + + /// Addition + template + __host__ __device__ __forceinline__ self_type operator+(Distance n) const + { + self_type retval(itr, offset + n); + return retval; + } + + /// Addition assignment + template + __host__ __device__ __forceinline__ self_type& operator+=(Distance n) + { + offset += n; + return *this; + } + + /// Subtraction + template + __host__ __device__ __forceinline__ self_type operator-(Distance n) const + { + self_type retval(itr, offset - n); + return retval; + } + + /// Subtraction assignment + template + __host__ __device__ __forceinline__ self_type& operator-=(Distance n) + { + offset -= n; + return *this; + } + + /// Distance + __host__ __device__ __forceinline__ difference_type operator-(self_type other) const + { + return offset - other.offset; + } + + /// Array subscript + template + __host__ __device__ __forceinline__ reference operator[](Distance n) const + { + self_type offset = (*this) + n; + return *offset; + } + + /// Structure dereference + __host__ __device__ __forceinline__ pointer operator->() + { + return &(*(*this)); + } + + /// Equal to + __host__ __device__ __forceinline__ bool operator==(const self_type& rhs) + { + return ((itr == rhs.itr) && (offset == rhs.offset)); + } + + /// Not equal to + __host__ __device__ __forceinline__ bool operator!=(const self_type& rhs) + { + return ((itr != rhs.itr) || (offset != rhs.offset)); + } + + /// ostream operator + friend std::ostream& operator<<(std::ostream& os, const self_type& itr) + { + return os; + } +}; + + + +/** @} */ // end group UtilIterator + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/iterator/cache_modified_input_iterator.cuh b/3rdparty/cub/cub/iterator/cache_modified_input_iterator.cuh new file mode 100644 index 00000000000..f96fe14291d --- /dev/null +++ b/3rdparty/cub/cub/iterator/cache_modified_input_iterator.cuh @@ -0,0 +1,240 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Random-access iterator types + */ + +#pragma once + +#include +#include + +#include "../thread/thread_load.cuh" +#include "../thread/thread_store.cuh" +#include "../util_device.cuh" +#include "../util_namespace.cuh" + +#if (THRUST_VERSION >= 100700) + // This iterator is compatible with Thrust API 1.7 and newer + #include + #include +#endif // THRUST_VERSION + + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + + +/** + * \addtogroup UtilIterator + * @{ + */ + + +/** + * \brief A random-access input wrapper for dereferencing array values using a PTX cache load modifier. + * + * \par Overview + * - CacheModifiedInputIteratorTis a random-access input iterator that wraps a native + * device pointer of type ValueType*. \p ValueType references are + * made by reading \p ValueType values through loads modified by \p MODIFIER. + * - Can be used to load any data type from memory using PTX cache load modifiers (e.g., "LOAD_LDG", + * "LOAD_CG", "LOAD_CA", "LOAD_CS", "LOAD_CV", etc.). + * - Can be constructed, manipulated, and exchanged within and between host and device + * functions, but can only be dereferenced within device functions. + * - Compatible with Thrust API v1.7 or newer. + * + * \par Snippet + * The code snippet below illustrates the use of \p CacheModifiedInputIteratorTto + * dereference a device array of double using the "ldg" PTX load modifier + * (i.e., load values through texture cache). + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize a device array + * double *d_in; // e.g., [8.0, 6.0, 7.0, 5.0, 3.0, 0.0, 9.0] + * + * // Create an iterator wrapper + * cub::CacheModifiedInputIterator itr(d_in); + * + * // Within device code: + * printf("%f\n", itr[0]); // 8.0 + * printf("%f\n", itr[1]); // 6.0 + * printf("%f\n", itr[6]); // 9.0 + * + * \endcode + * + * \tparam CacheLoadModifier The cub::CacheLoadModifier to use when accessing data + * \tparam ValueType The value type of this iterator + * \tparam OffsetT The difference type of this iterator (Default: \p ptrdiff_t) + */ +template < + CacheLoadModifier MODIFIER, + typename ValueType, + typename OffsetT = ptrdiff_t> +class CacheModifiedInputIterator +{ +public: + + // Required iterator traits + typedef CacheModifiedInputIterator self_type; ///< My own type + typedef OffsetT difference_type; ///< Type to express the result of subtracting one iterator from another + typedef ValueType value_type; ///< The type of the element the iterator can point to + typedef ValueType* pointer; ///< The type of a pointer to an element the iterator can point to + typedef ValueType reference; ///< The type of a reference to an element the iterator can point to + +#if (THRUST_VERSION >= 100700) + // Use Thrust's iterator categories so we can use these iterators in Thrust 1.7 (or newer) methods + typedef typename thrust::detail::iterator_facade_category< + thrust::device_system_tag, + thrust::random_access_traversal_tag, + value_type, + reference + >::type iterator_category; ///< The iterator category +#else + typedef std::random_access_iterator_tag iterator_category; ///< The iterator category +#endif // THRUST_VERSION + + +public: + + /// Wrapped native pointer + ValueType* ptr; + + /// Constructor + template + __host__ __device__ __forceinline__ CacheModifiedInputIterator( + QualifiedValueType* ptr) ///< Native pointer to wrap + : + ptr(const_cast::Type *>(ptr)) + {} + + /// Postfix increment + __host__ __device__ __forceinline__ self_type operator++(int) + { + self_type retval = *this; + ptr++; + return retval; + } + + /// Prefix increment + __host__ __device__ __forceinline__ self_type operator++() + { + ptr++; + return *this; + } + + /// Indirection + __device__ __forceinline__ reference operator*() const + { + return ThreadLoad(ptr); + } + + /// Addition + template + __host__ __device__ __forceinline__ self_type operator+(Distance n) const + { + self_type retval(ptr + n); + return retval; + } + + /// Addition assignment + template + __host__ __device__ __forceinline__ self_type& operator+=(Distance n) + { + ptr += n; + return *this; + } + + /// Subtraction + template + __host__ __device__ __forceinline__ self_type operator-(Distance n) const + { + self_type retval(ptr - n); + return retval; + } + + /// Subtraction assignment + template + __host__ __device__ __forceinline__ self_type& operator-=(Distance n) + { + ptr -= n; + return *this; + } + + /// Distance + __host__ __device__ __forceinline__ difference_type operator-(self_type other) const + { + return ptr - other.ptr; + } + + /// Array subscript + template + __device__ __forceinline__ reference operator[](Distance n) const + { + return ThreadLoad(ptr + n); + } + + /// Structure dereference + __device__ __forceinline__ pointer operator->() + { + return &ThreadLoad(ptr); + } + + /// Equal to + __host__ __device__ __forceinline__ bool operator==(const self_type& rhs) + { + return (ptr == rhs.ptr); + } + + /// Not equal to + __host__ __device__ __forceinline__ bool operator!=(const self_type& rhs) + { + return (ptr != rhs.ptr); + } + + /// ostream operator + friend std::ostream& operator<<(std::ostream& os, const self_type& itr) + { + return os; + } +}; + + + +/** @} */ // end group UtilIterator + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/iterator/cache_modified_output_iterator.cuh b/3rdparty/cub/cub/iterator/cache_modified_output_iterator.cuh new file mode 100644 index 00000000000..2984b1c051f --- /dev/null +++ b/3rdparty/cub/cub/iterator/cache_modified_output_iterator.cuh @@ -0,0 +1,254 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Random-access iterator types + */ + +#pragma once + +#include +#include + +#include "../thread/thread_load.cuh" +#include "../thread/thread_store.cuh" +#include "../util_device.cuh" +#include "../util_namespace.cuh" + +#if (THRUST_VERSION >= 100700) + // This iterator is compatible with Thrust API 1.7 and newer + #include + #include +#endif // THRUST_VERSION + + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup UtilIterator + * @{ + */ + + +/** + * \brief A random-access output wrapper for storing array values using a PTX cache-modifier. + * + * \par Overview + * - CacheModifiedOutputIterator is a random-access output iterator that wraps a native + * device pointer of type ValueType*. \p ValueType references are + * made by writing \p ValueType values through stores modified by \p MODIFIER. + * - Can be used to store any data type to memory using PTX cache store modifiers (e.g., "STORE_WB", + * "STORE_CG", "STORE_CS", "STORE_WT", etc.). + * - Can be constructed, manipulated, and exchanged within and between host and device + * functions, but can only be dereferenced within device functions. + * - Compatible with Thrust API v1.7 or newer. + * + * \par Snippet + * The code snippet below illustrates the use of \p CacheModifiedOutputIterator to + * dereference a device array of doubles using the "wt" PTX load modifier + * (i.e., write-through to system memory). + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize a device array + * double *d_out; // e.g., [, , , , , , ] + * + * // Create an iterator wrapper + * cub::CacheModifiedOutputIterator itr(d_out); + * + * // Within device code: + * itr[0] = 8.0; + * itr[1] = 66.0; + * itr[55] = 24.0; + * + * \endcode + * + * \par Usage Considerations + * - Can only be dereferenced within device code + * + * \tparam CacheStoreModifier The cub::CacheStoreModifier to use when accessing data + * \tparam ValueType The value type of this iterator + * \tparam OffsetT The difference type of this iterator (Default: \p ptrdiff_t) + */ +template < + CacheStoreModifier MODIFIER, + typename ValueType, + typename OffsetT = ptrdiff_t> +class CacheModifiedOutputIterator +{ +private: + + // Proxy object + struct Reference + { + ValueType* ptr; + + /// Constructor + __host__ __device__ __forceinline__ Reference(ValueType* ptr) : ptr(ptr) {} + + /// Assignment + __device__ __forceinline__ ValueType operator =(ValueType val) + { + ThreadStore(ptr, val); + return val; + } + }; + +public: + + // Required iterator traits + typedef CacheModifiedOutputIterator self_type; ///< My own type + typedef OffsetT difference_type; ///< Type to express the result of subtracting one iterator from another + typedef ValueType value_type; ///< The type of the element the iterator can point to + typedef ValueType* pointer; ///< The type of a pointer to an element the iterator can point to + typedef Reference reference; ///< The type of a reference to an element the iterator can point to + +#if (THRUST_VERSION >= 100700) + // Use Thrust's iterator categories so we can use these iterators in Thrust 1.7 (or newer) methods + typedef typename thrust::detail::iterator_facade_category< + thrust::device_system_tag, + thrust::random_access_traversal_tag, + value_type, + reference + >::type iterator_category; ///< The iterator category +#else + typedef std::random_access_iterator_tag iterator_category; ///< The iterator category +#endif // THRUST_VERSION + +private: + + ValueType* ptr; + +public: + + /// Constructor + template + __host__ __device__ __forceinline__ CacheModifiedOutputIterator( + QualifiedValueType* ptr) ///< Native pointer to wrap + : + ptr(const_cast::Type *>(ptr)) + {} + + /// Postfix increment + __host__ __device__ __forceinline__ self_type operator++(int) + { + self_type retval = *this; + ptr++; + return retval; + } + + + /// Prefix increment + __host__ __device__ __forceinline__ self_type operator++() + { + ptr++; + return *this; + } + + /// Indirection + __host__ __device__ __forceinline__ reference operator*() const + { + return Reference(ptr); + } + + /// Addition + template + __host__ __device__ __forceinline__ self_type operator+(Distance n) const + { + self_type retval(ptr + n); + return retval; + } + + /// Addition assignment + template + __host__ __device__ __forceinline__ self_type& operator+=(Distance n) + { + ptr += n; + return *this; + } + + /// Subtraction + template + __host__ __device__ __forceinline__ self_type operator-(Distance n) const + { + self_type retval(ptr - n); + return retval; + } + + /// Subtraction assignment + template + __host__ __device__ __forceinline__ self_type& operator-=(Distance n) + { + ptr -= n; + return *this; + } + + /// Distance + __host__ __device__ __forceinline__ difference_type operator-(self_type other) const + { + return ptr - other.ptr; + } + + /// Array subscript + template + __host__ __device__ __forceinline__ reference operator[](Distance n) const + { + return Reference(ptr + n); + } + + /// Equal to + __host__ __device__ __forceinline__ bool operator==(const self_type& rhs) + { + return (ptr == rhs.ptr); + } + + /// Not equal to + __host__ __device__ __forceinline__ bool operator!=(const self_type& rhs) + { + return (ptr != rhs.ptr); + } + + /// ostream operator + friend std::ostream& operator<<(std::ostream& os, const self_type& itr) + { + return os; + } +}; + + +/** @} */ // end group UtilIterator + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/iterator/constant_input_iterator.cuh b/3rdparty/cub/cub/iterator/constant_input_iterator.cuh new file mode 100644 index 00000000000..70a420993f4 --- /dev/null +++ b/3rdparty/cub/cub/iterator/constant_input_iterator.cuh @@ -0,0 +1,235 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Random-access iterator types + */ + +#pragma once + +#include +#include + +#include "../thread/thread_load.cuh" +#include "../thread/thread_store.cuh" +#include "../util_namespace.cuh" + +#if (THRUST_VERSION >= 100700) + // This iterator is compatible with Thrust API 1.7 and newer + #include + #include +#endif // THRUST_VERSION + + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup UtilIterator + * @{ + */ + + +/** + * \brief A random-access input generator for dereferencing a sequence of homogeneous values + * + * \par Overview + * - Read references to a ConstantInputIteratorTiterator always return the supplied constant + * of type \p ValueType. + * - Can be used with any data type. + * - Can be constructed, manipulated, dereferenced, and exchanged within and between host and device + * functions. + * - Compatible with Thrust API v1.7 or newer. + * + * \par Snippet + * The code snippet below illustrates the use of \p ConstantInputIteratorTto + * dereference a sequence of homogeneous doubles. + * \par + * \code + * #include // or equivalently + * + * cub::ConstantInputIterator itr(5.0); + * + * printf("%f\n", itr[0]); // 5.0 + * printf("%f\n", itr[1]); // 5.0 + * printf("%f\n", itr[2]); // 5.0 + * printf("%f\n", itr[50]); // 5.0 + * + * \endcode + * + * \tparam ValueType The value type of this iterator + * \tparam OffsetT The difference type of this iterator (Default: \p ptrdiff_t) + */ +template < + typename ValueType, + typename OffsetT = ptrdiff_t> +class ConstantInputIterator +{ +public: + + // Required iterator traits + typedef ConstantInputIterator self_type; ///< My own type + typedef OffsetT difference_type; ///< Type to express the result of subtracting one iterator from another + typedef ValueType value_type; ///< The type of the element the iterator can point to + typedef ValueType* pointer; ///< The type of a pointer to an element the iterator can point to + typedef ValueType reference; ///< The type of a reference to an element the iterator can point to + +#if (THRUST_VERSION >= 100700) + // Use Thrust's iterator categories so we can use these iterators in Thrust 1.7 (or newer) methods + typedef typename thrust::detail::iterator_facade_category< + thrust::any_system_tag, + thrust::random_access_traversal_tag, + value_type, + reference + >::type iterator_category; ///< The iterator category +#else + typedef std::random_access_iterator_tag iterator_category; ///< The iterator category +#endif // THRUST_VERSION + +private: + + ValueType val; + OffsetT offset; +#ifdef _WIN32 + OffsetT pad[CUB_MAX(1, (16 / sizeof(OffsetT) - 1))]; // Workaround for win32 parameter-passing bug (ulonglong2 argmin DeviceReduce) +#endif + +public: + + /// Constructor + __host__ __device__ __forceinline__ ConstantInputIterator( + ValueType val, ///< Starting value for the iterator instance to report + OffsetT offset = 0) ///< Base offset + : + val(val), + offset(offset) + {} + + /// Postfix increment + __host__ __device__ __forceinline__ self_type operator++(int) + { + self_type retval = *this; + offset++; + return retval; + } + + /// Prefix increment + __host__ __device__ __forceinline__ self_type operator++() + { + offset++; + return *this; + } + + /// Indirection + __host__ __device__ __forceinline__ reference operator*() const + { + return val; + } + + /// Addition + template + __host__ __device__ __forceinline__ self_type operator+(Distance n) const + { + self_type retval(val, offset + n); + return retval; + } + + /// Addition assignment + template + __host__ __device__ __forceinline__ self_type& operator+=(Distance n) + { + offset += n; + return *this; + } + + /// Subtraction + template + __host__ __device__ __forceinline__ self_type operator-(Distance n) const + { + self_type retval(val, offset - n); + return retval; + } + + /// Subtraction assignment + template + __host__ __device__ __forceinline__ self_type& operator-=(Distance n) + { + offset -= n; + return *this; + } + + /// Distance + __host__ __device__ __forceinline__ difference_type operator-(self_type other) const + { + return offset - other.offset; + } + + /// Array subscript + template + __host__ __device__ __forceinline__ reference operator[](Distance n) const + { + return val; + } + + /// Structure dereference + __host__ __device__ __forceinline__ pointer operator->() + { + return &val; + } + + /// Equal to + __host__ __device__ __forceinline__ bool operator==(const self_type& rhs) + { + return (offset == rhs.offset) && ((val == rhs.val)); + } + + /// Not equal to + __host__ __device__ __forceinline__ bool operator!=(const self_type& rhs) + { + return (offset != rhs.offset) || (val!= rhs.val); + } + + /// ostream operator + friend std::ostream& operator<<(std::ostream& os, const self_type& itr) + { + os << "[" << itr.val << "," << itr.offset << "]"; + return os; + } + +}; + + +/** @} */ // end group UtilIterator + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/iterator/counting_input_iterator.cuh b/3rdparty/cub/cub/iterator/counting_input_iterator.cuh new file mode 100644 index 00000000000..25c19e83802 --- /dev/null +++ b/3rdparty/cub/cub/iterator/counting_input_iterator.cuh @@ -0,0 +1,228 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Random-access iterator types + */ + +#pragma once + +#include +#include + +#include "../thread/thread_load.cuh" +#include "../thread/thread_store.cuh" +#include "../util_device.cuh" +#include "../util_namespace.cuh" + +#if (THRUST_VERSION >= 100700) + // This iterator is compatible with Thrust API 1.7 and newer + #include + #include +#endif // THRUST_VERSION + + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \addtogroup UtilIterator + * @{ + */ + +/** + * \brief A random-access input generator for dereferencing a sequence of incrementing integer values. + * + * \par Overview + * - After initializing a CountingInputIteratorTto a certain integer \p base, read references + * at \p offset will return the value \p base + \p offset. + * - Can be constructed, manipulated, dereferenced, and exchanged within and between host and device + * functions. + * - Compatible with Thrust API v1.7 or newer. + * + * \par Snippet + * The code snippet below illustrates the use of \p CountingInputIteratorTto + * dereference a sequence of incrementing integers. + * \par + * \code + * #include // or equivalently + * + * cub::CountingInputIterator itr(5); + * + * printf("%d\n", itr[0]); // 5 + * printf("%d\n", itr[1]); // 6 + * printf("%d\n", itr[2]); // 7 + * printf("%d\n", itr[50]); // 55 + * + * \endcode + * + * \tparam ValueType The value type of this iterator + * \tparam OffsetT The difference type of this iterator (Default: \p ptrdiff_t) + */ +template < + typename ValueType, + typename OffsetT = ptrdiff_t> +class CountingInputIterator +{ +public: + + // Required iterator traits + typedef CountingInputIterator self_type; ///< My own type + typedef OffsetT difference_type; ///< Type to express the result of subtracting one iterator from another + typedef ValueType value_type; ///< The type of the element the iterator can point to + typedef ValueType* pointer; ///< The type of a pointer to an element the iterator can point to + typedef ValueType reference; ///< The type of a reference to an element the iterator can point to + +#if (THRUST_VERSION >= 100700) + // Use Thrust's iterator categories so we can use these iterators in Thrust 1.7 (or newer) methods + typedef typename thrust::detail::iterator_facade_category< + thrust::any_system_tag, + thrust::random_access_traversal_tag, + value_type, + reference + >::type iterator_category; ///< The iterator category +#else + typedef std::random_access_iterator_tag iterator_category; ///< The iterator category +#endif // THRUST_VERSION + +private: + + ValueType val; + +public: + + /// Constructor + __host__ __device__ __forceinline__ CountingInputIterator( + const ValueType &val) ///< Starting value for the iterator instance to report + : + val(val) + {} + + /// Postfix increment + __host__ __device__ __forceinline__ self_type operator++(int) + { + self_type retval = *this; + val++; + return retval; + } + + /// Prefix increment + __host__ __device__ __forceinline__ self_type operator++() + { + val++; + return *this; + } + + /// Indirection + __host__ __device__ __forceinline__ reference operator*() const + { + return val; + } + + /// Addition + template + __host__ __device__ __forceinline__ self_type operator+(Distance n) const + { + self_type retval(val + n); + return retval; + } + + /// Addition assignment + template + __host__ __device__ __forceinline__ self_type& operator+=(Distance n) + { + val += n; + return *this; + } + + /// Subtraction + template + __host__ __device__ __forceinline__ self_type operator-(Distance n) const + { + self_type retval(val - n); + return retval; + } + + /// Subtraction assignment + template + __host__ __device__ __forceinline__ self_type& operator-=(Distance n) + { + val -= n; + return *this; + } + + /// Distance + __host__ __device__ __forceinline__ difference_type operator-(self_type other) const + { + return val - other.val; + } + + /// Array subscript + template + __host__ __device__ __forceinline__ reference operator[](Distance n) const + { + return val + n; + } + + /// Structure dereference + __host__ __device__ __forceinline__ pointer operator->() + { + return &val; + } + + /// Equal to + __host__ __device__ __forceinline__ bool operator==(const self_type& rhs) + { + return (val == rhs.val); + } + + /// Not equal to + __host__ __device__ __forceinline__ bool operator!=(const self_type& rhs) + { + return (val != rhs.val); + } + + /// ostream operator + friend std::ostream& operator<<(std::ostream& os, const self_type& itr) + { + os << "[" << itr.val << "]"; + return os; + } + +}; + + + +/** @} */ // end group UtilIterator + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/iterator/tex_obj_input_iterator.cuh b/3rdparty/cub/cub/iterator/tex_obj_input_iterator.cuh new file mode 100644 index 00000000000..4fb021cd8b0 --- /dev/null +++ b/3rdparty/cub/cub/iterator/tex_obj_input_iterator.cuh @@ -0,0 +1,310 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Random-access iterator types + */ + +#pragma once + +#include +#include + +#include "../thread/thread_load.cuh" +#include "../thread/thread_store.cuh" +#include "../util_device.cuh" +#include "../util_debug.cuh" +#include "../util_namespace.cuh" + +#if (THRUST_VERSION >= 100700) + // This iterator is compatible with Thrust API 1.7 and newer + #include + #include +#endif // THRUST_VERSION + + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \addtogroup UtilIterator + * @{ + */ + + + +/** + * \brief A random-access input wrapper for dereferencing array values through texture cache. Uses newer Kepler-style texture objects. + * + * \par Overview + * - TexObjInputIteratorTwraps a native device pointer of type ValueType*. References + * to elements are to be loaded through texture cache. + * - Can be used to load any data type from memory through texture cache. + * - Can be manipulated and exchanged within and between host and device + * functions, can only be constructed within host functions, and can only be + * dereferenced within device functions. + * - With regard to nested/dynamic parallelism, TexObjInputIteratorTiterators may only be + * created by the host thread, but can be used by any descendant kernel. + * - Compatible with Thrust API v1.7 or newer. + * + * \par Snippet + * The code snippet below illustrates the use of \p TexRefInputIteratorTto + * dereference a device array of doubles through texture cache. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize a device array + * int num_items; // e.g., 7 + * double *d_in; // e.g., [8.0, 6.0, 7.0, 5.0, 3.0, 0.0, 9.0] + * + * // Create an iterator wrapper + * cub::TexObjInputIterator itr; + * itr.BindTexture(d_in, sizeof(double) * num_items); + * ... + * + * // Within device code: + * printf("%f\n", itr[0]); // 8.0 + * printf("%f\n", itr[1]); // 6.0 + * printf("%f\n", itr[6]); // 9.0 + * + * ... + * itr.UnbindTexture(); + * + * \endcode + * + * \tparam T The value type of this iterator + * \tparam OffsetT The difference type of this iterator (Default: \p ptrdiff_t) + */ +template < + typename T, + typename OffsetT = ptrdiff_t> +class TexObjInputIterator +{ +public: + + // Required iterator traits + typedef TexObjInputIterator self_type; ///< My own type + typedef OffsetT difference_type; ///< Type to express the result of subtracting one iterator from another + typedef T value_type; ///< The type of the element the iterator can point to + typedef T* pointer; ///< The type of a pointer to an element the iterator can point to + typedef T reference; ///< The type of a reference to an element the iterator can point to + +#if (THRUST_VERSION >= 100700) + // Use Thrust's iterator categories so we can use these iterators in Thrust 1.7 (or newer) methods + typedef typename thrust::detail::iterator_facade_category< + thrust::device_system_tag, + thrust::random_access_traversal_tag, + value_type, + reference + >::type iterator_category; ///< The iterator category +#else + typedef std::random_access_iterator_tag iterator_category; ///< The iterator category +#endif // THRUST_VERSION + +private: + + // Largest texture word we can use in device + typedef typename UnitWord::TextureWord TextureWord; + + // Number of texture words per T + enum { + TEXTURE_MULTIPLE = sizeof(T) / sizeof(TextureWord) + }; + +private: + + T* ptr; + difference_type tex_offset; + cudaTextureObject_t tex_obj; + +public: + + /// Constructor + __host__ __device__ __forceinline__ TexObjInputIterator() + : + ptr(NULL), + tex_offset(0), + tex_obj(0) + {} + + /// Use this iterator to bind \p ptr with a texture reference + template + cudaError_t BindTexture( + QualifiedT *ptr, ///< Native pointer to wrap that is aligned to cudaDeviceProp::textureAlignment + size_t bytes = size_t(-1), ///< Number of bytes in the range + size_t tex_offset = 0) ///< OffsetT (in items) from \p ptr denoting the position of the iterator + { + this->ptr = const_cast::Type *>(ptr); + this->tex_offset = tex_offset; + + cudaChannelFormatDesc channel_desc = cudaCreateChannelDesc(); + cudaResourceDesc res_desc; + cudaTextureDesc tex_desc; + memset(&res_desc, 0, sizeof(cudaResourceDesc)); + memset(&tex_desc, 0, sizeof(cudaTextureDesc)); + res_desc.resType = cudaResourceTypeLinear; + res_desc.res.linear.devPtr = this->ptr; + res_desc.res.linear.desc = channel_desc; + res_desc.res.linear.sizeInBytes = bytes; + tex_desc.readMode = cudaReadModeElementType; + return cudaCreateTextureObject(&tex_obj, &res_desc, &tex_desc, NULL); + } + + /// Unbind this iterator from its texture reference + cudaError_t UnbindTexture() + { + return cudaDestroyTextureObject(tex_obj); + } + + /// Postfix increment + __host__ __device__ __forceinline__ self_type operator++(int) + { + self_type retval = *this; + tex_offset++; + return retval; + } + + /// Prefix increment + __host__ __device__ __forceinline__ self_type operator++() + { + tex_offset++; + return *this; + } + + /// Indirection + __host__ __device__ __forceinline__ reference operator*() const + { +#if (CUB_PTX_ARCH == 0) + // Simply dereference the pointer on the host + return ptr[tex_offset]; +#else + // Move array of uninitialized words, then alias and assign to return value + TextureWord words[TEXTURE_MULTIPLE]; + + #pragma unroll + for (int i = 0; i < TEXTURE_MULTIPLE; ++i) + { + words[i] = tex1Dfetch( + tex_obj, + (tex_offset * TEXTURE_MULTIPLE) + i); + } + + // Load from words + return *reinterpret_cast(words); +#endif + } + + /// Addition + template + __host__ __device__ __forceinline__ self_type operator+(Distance n) const + { + self_type retval; + retval.ptr = ptr; + retval.tex_obj = tex_obj; + retval.tex_offset = tex_offset + n; + return retval; + } + + /// Addition assignment + template + __host__ __device__ __forceinline__ self_type& operator+=(Distance n) + { + tex_offset += n; + return *this; + } + + /// Subtraction + template + __host__ __device__ __forceinline__ self_type operator-(Distance n) const + { + self_type retval; + retval.ptr = ptr; + retval.tex_obj = tex_obj; + retval.tex_offset = tex_offset - n; + return retval; + } + + /// Subtraction assignment + template + __host__ __device__ __forceinline__ self_type& operator-=(Distance n) + { + tex_offset -= n; + return *this; + } + + /// Distance + __host__ __device__ __forceinline__ difference_type operator-(self_type other) const + { + return tex_offset - other.tex_offset; + } + + /// Array subscript + template + __host__ __device__ __forceinline__ reference operator[](Distance n) const + { + self_type offset = (*this) + n; + return *offset; + } + + /// Structure dereference + __host__ __device__ __forceinline__ pointer operator->() + { + return &(*(*this)); + } + + /// Equal to + __host__ __device__ __forceinline__ bool operator==(const self_type& rhs) + { + return ((ptr == rhs.ptr) && (tex_offset == rhs.tex_offset) && (tex_obj == rhs.tex_obj)); + } + + /// Not equal to + __host__ __device__ __forceinline__ bool operator!=(const self_type& rhs) + { + return ((ptr != rhs.ptr) || (tex_offset != rhs.tex_offset) || (tex_obj != rhs.tex_obj)); + } + + /// ostream operator + friend std::ostream& operator<<(std::ostream& os, const self_type& itr) + { + return os; + } + +}; + + + +/** @} */ // end group UtilIterator + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/iterator/tex_ref_input_iterator.cuh b/3rdparty/cub/cub/iterator/tex_ref_input_iterator.cuh new file mode 100644 index 00000000000..c0c69dd73df --- /dev/null +++ b/3rdparty/cub/cub/iterator/tex_ref_input_iterator.cuh @@ -0,0 +1,374 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Random-access iterator types + */ + +#pragma once + +#include +#include + +#include "../thread/thread_load.cuh" +#include "../thread/thread_store.cuh" +#include "../util_device.cuh" +#include "../util_debug.cuh" +#include "../util_namespace.cuh" + +#if (CUDA_VERSION >= 5050) || defined(DOXYGEN_ACTIVE) // This iterator is compatible with CUDA 5.5 and newer + +#if (THRUST_VERSION >= 100700) // This iterator is compatible with Thrust API 1.7 and newer + #include + #include +#endif // THRUST_VERSION + + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/****************************************************************************** + * Static file-scope Tesla/Fermi-style texture references + *****************************************************************************/ + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +// Anonymous namespace +namespace { + +/// Global texture reference specialized by type +template +struct IteratorTexRef +{ + /// And by unique ID + template + struct TexId + { + // Largest texture word we can use in device + typedef typename UnitWord::DeviceWord DeviceWord; + typedef typename UnitWord::TextureWord TextureWord; + + // Number of texture words per T + enum { + DEVICE_MULTIPLE = sizeof(T) / sizeof(DeviceWord), + TEXTURE_MULTIPLE = sizeof(T) / sizeof(TextureWord) + }; + + // Texture reference type + typedef texture TexRef; + + // Texture reference + static TexRef ref; + + /// Bind texture + static cudaError_t BindTexture(void *d_in, size_t &offset) + { + if (d_in) + { + cudaChannelFormatDesc tex_desc = cudaCreateChannelDesc(); + ref.channelDesc = tex_desc; + return (CubDebug(cudaBindTexture(&offset, ref, d_in))); + } + + return cudaSuccess; + } + + /// Unbind texture + static cudaError_t UnbindTexture() + { + return CubDebug(cudaUnbindTexture(ref)); + } + + /// Fetch element + template + static __device__ __forceinline__ T Fetch(Distance tex_offset) + { + DeviceWord temp[DEVICE_MULTIPLE]; + TextureWord *words = reinterpret_cast(temp); + + #pragma unroll + for (int i = 0; i < TEXTURE_MULTIPLE; ++i) + { + words[i] = tex1Dfetch(ref, (tex_offset * TEXTURE_MULTIPLE) + i); + } + + return reinterpret_cast(temp); + } + }; +}; + +// Texture reference definitions +template +template +typename IteratorTexRef::template TexId::TexRef IteratorTexRef::template TexId::ref = 0; + + +} // Anonymous namespace + + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + + +/** + * \addtogroup UtilIterator + * @{ + */ + + + +/** + * \brief A random-access input wrapper for dereferencing array values through texture cache. Uses older Tesla/Fermi-style texture references. + * + * \par Overview + * - TexRefInputIteratorTwraps a native device pointer of type ValueType*. References + * to elements are to be loaded through texture cache. + * - Can be used to load any data type from memory through texture cache. + * - Can be manipulated and exchanged within and between host and device + * functions, can only be constructed within host functions, and can only be + * dereferenced within device functions. + * - The \p UNIQUE_ID template parameter is used to statically name the underlying texture + * reference. Only one TexRefInputIteratorTinstance can be bound at any given time for a + * specific combination of (1) data type \p T, (2) \p UNIQUE_ID, (3) host + * thread, and (4) compilation .o unit. + * - With regard to nested/dynamic parallelism, TexRefInputIteratorTiterators may only be + * created by the host thread and used by a top-level kernel (i.e. the one which is launched + * from the host). + * - Compatible with Thrust API v1.7 or newer. + * - Compatible with CUDA toolkit v5.5 or newer. + * + * \par Snippet + * The code snippet below illustrates the use of \p TexRefInputIteratorTto + * dereference a device array of doubles through texture cache. + * \par + * \code + * #include // or equivalently + * + * // Declare, allocate, and initialize a device array + * int num_items; // e.g., 7 + * double *d_in; // e.g., [8.0, 6.0, 7.0, 5.0, 3.0, 0.0, 9.0] + * + * // Create an iterator wrapper + * cub::TexRefInputIterator itr; + * itr.BindTexture(d_in, sizeof(double) * num_items); + * ... + * + * // Within device code: + * printf("%f\n", itr[0]); // 8.0 + * printf("%f\n", itr[1]); // 6.0 + * printf("%f\n", itr[6]); // 9.0 + * + * ... + * itr.UnbindTexture(); + * + * \endcode + * + * \tparam T The value type of this iterator + * \tparam UNIQUE_ID A globally-unique identifier (within the compilation unit) to name the underlying texture reference + * \tparam OffsetT The difference type of this iterator (Default: \p ptrdiff_t) + */ +template < + typename T, + int UNIQUE_ID, + typename OffsetT = ptrdiff_t> +class TexRefInputIterator +{ +public: + + // Required iterator traits + typedef TexRefInputIterator self_type; ///< My own type + typedef OffsetT difference_type; ///< Type to express the result of subtracting one iterator from another + typedef T value_type; ///< The type of the element the iterator can point to + typedef T* pointer; ///< The type of a pointer to an element the iterator can point to + typedef T reference; ///< The type of a reference to an element the iterator can point to + +#if (THRUST_VERSION >= 100700) + // Use Thrust's iterator categories so we can use these iterators in Thrust 1.7 (or newer) methods + typedef typename thrust::detail::iterator_facade_category< + thrust::device_system_tag, + thrust::random_access_traversal_tag, + value_type, + reference + >::type iterator_category; ///< The iterator category +#else + typedef std::random_access_iterator_tag iterator_category; ///< The iterator category +#endif // THRUST_VERSION + +private: + + T* ptr; + difference_type tex_offset; + + // Texture reference wrapper (old Tesla/Fermi-style textures) + typedef typename IteratorTexRef::template TexId TexId; + +public: +/* + /// Constructor + __host__ __device__ __forceinline__ TexRefInputIterator() + : + ptr(NULL), + tex_offset(0) + {} +*/ + /// Use this iterator to bind \p ptr with a texture reference + template + cudaError_t BindTexture( + QualifiedT *ptr, ///< Native pointer to wrap that is aligned to cudaDeviceProp::textureAlignment + size_t bytes = size_t(-1), ///< Number of bytes in the range + size_t tex_offset = 0) ///< OffsetT (in items) from \p ptr denoting the position of the iterator + { + this->ptr = const_cast::Type *>(ptr); + size_t offset; + cudaError_t retval = TexId::BindTexture(this->ptr + tex_offset, offset); + this->tex_offset = (difference_type) (offset / sizeof(QualifiedT)); + return retval; + } + + /// Unbind this iterator from its texture reference + cudaError_t UnbindTexture() + { + return TexId::UnbindTexture(); + } + + /// Postfix increment + __host__ __device__ __forceinline__ self_type operator++(int) + { + self_type retval = *this; + tex_offset++; + return retval; + } + + /// Prefix increment + __host__ __device__ __forceinline__ self_type operator++() + { + tex_offset++; + return *this; + } + + /// Indirection + __host__ __device__ __forceinline__ reference operator*() const + { +#if (CUB_PTX_ARCH == 0) + // Simply dereference the pointer on the host + return ptr[tex_offset]; +#else + // Use the texture reference + return TexId::Fetch(tex_offset); +#endif + } + + /// Addition + template + __host__ __device__ __forceinline__ self_type operator+(Distance n) const + { + self_type retval; + retval.ptr = ptr; + retval.tex_offset = tex_offset + n; + return retval; + } + + /// Addition assignment + template + __host__ __device__ __forceinline__ self_type& operator+=(Distance n) + { + tex_offset += n; + return *this; + } + + /// Subtraction + template + __host__ __device__ __forceinline__ self_type operator-(Distance n) const + { + self_type retval; + retval.ptr = ptr; + retval.tex_offset = tex_offset - n; + return retval; + } + + /// Subtraction assignment + template + __host__ __device__ __forceinline__ self_type& operator-=(Distance n) + { + tex_offset -= n; + return *this; + } + + /// Distance + __host__ __device__ __forceinline__ difference_type operator-(self_type other) const + { + return tex_offset - other.tex_offset; + } + + /// Array subscript + template + __host__ __device__ __forceinline__ reference operator[](Distance n) const + { + self_type offset = (*this) + n; + return *offset; + } + + /// Structure dereference + __host__ __device__ __forceinline__ pointer operator->() + { + return &(*(*this)); + } + + /// Equal to + __host__ __device__ __forceinline__ bool operator==(const self_type& rhs) + { + return ((ptr == rhs.ptr) && (tex_offset == rhs.tex_offset)); + } + + /// Not equal to + __host__ __device__ __forceinline__ bool operator!=(const self_type& rhs) + { + return ((ptr != rhs.ptr) || (tex_offset != rhs.tex_offset)); + } + + /// ostream operator + friend std::ostream& operator<<(std::ostream& os, const self_type& itr) + { + return os; + } + +}; + + + +/** @} */ // end group UtilIterator + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) + +#endif // CUDA_VERSION diff --git a/3rdparty/cub/cub/iterator/transform_input_iterator.cuh b/3rdparty/cub/cub/iterator/transform_input_iterator.cuh new file mode 100644 index 00000000000..339f251fa66 --- /dev/null +++ b/3rdparty/cub/cub/iterator/transform_input_iterator.cuh @@ -0,0 +1,252 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Random-access iterator types + */ + +#pragma once + +#include +#include + +#include "../thread/thread_load.cuh" +#include "../thread/thread_store.cuh" +#include "../util_device.cuh" +#include "../util_namespace.cuh" + +#if (THRUST_VERSION >= 100700) + // This iterator is compatible with Thrust API 1.7 and newer + #include + #include +#endif // THRUST_VERSION + + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \addtogroup UtilIterator + * @{ + */ + + +/** + * \brief A random-access input wrapper for transforming dereferenced values. + * + * \par Overview + * - TransformInputIteratorTwraps a unary conversion functor of type \p + * ConversionOp and a random-access input iterator of type InputIteratorT, + * using the former to produce references of type \p ValueType from the latter. + * - Can be used with any data type. + * - Can be constructed, manipulated, and exchanged within and between host and device + * functions. Wrapped host memory can only be dereferenced on the host, and wrapped + * device memory can only be dereferenced on the device. + * - Compatible with Thrust API v1.7 or newer. + * + * \par Snippet + * The code snippet below illustrates the use of \p TransformInputIteratorTto + * dereference an array of integers, tripling the values and converting them to doubles. + * \par + * \code + * #include // or equivalently + * + * // Functor for tripling integer values and converting to doubles + * struct TripleDoubler + * { + * __host__ __device__ __forceinline__ + * double operator()(const int &a) const { + * return double(a * 2); + * } + * }; + * + * // Declare, allocate, and initialize a device array + * int *d_in; // e.g., [8, 6, 7, 5, 3, 0, 9] + * TripleDoubler conversion_op; + * + * // Create an iterator wrapper + * cub::TransformInputIterator itr(d_in, conversion_op); + * + * // Within device code: + * printf("%f\n", itr[0]); // 24.0 + * printf("%f\n", itr[1]); // 18.0 + * printf("%f\n", itr[6]); // 27.0 + * + * \endcode + * + * \tparam ValueType The value type of this iterator + * \tparam ConversionOp Unary functor type for mapping objects of type \p InputType to type \p ValueType. Must have member ValueType operator()(const InputType &datum). + * \tparam InputIteratorT The type of the wrapped input iterator + * \tparam OffsetT The difference type of this iterator (Default: \p ptrdiff_t) + * + */ +template < + typename ValueType, + typename ConversionOp, + typename InputIteratorT, + typename OffsetT = ptrdiff_t> +class TransformInputIterator +{ +public: + + // Required iterator traits + typedef TransformInputIterator self_type; ///< My own type + typedef OffsetT difference_type; ///< Type to express the result of subtracting one iterator from another + typedef ValueType value_type; ///< The type of the element the iterator can point to + typedef ValueType* pointer; ///< The type of a pointer to an element the iterator can point to + typedef ValueType reference; ///< The type of a reference to an element the iterator can point to + +#if (THRUST_VERSION >= 100700) + // Use Thrust's iterator categories so we can use these iterators in Thrust 1.7 (or newer) methods + typedef typename thrust::detail::iterator_facade_category< + thrust::any_system_tag, + thrust::random_access_traversal_tag, + value_type, + reference + >::type iterator_category; ///< The iterator category +#else + typedef std::random_access_iterator_tag iterator_category; ///< The iterator category +#endif // THRUST_VERSION + +private: + + ConversionOp conversion_op; + InputIteratorT input_itr; + +public: + + /// Constructor + __host__ __device__ __forceinline__ TransformInputIterator( + InputIteratorT input_itr, ///< Input iterator to wrap + ConversionOp conversion_op) ///< Conversion functor to wrap + : + conversion_op(conversion_op), + input_itr(input_itr) + {} + + /// Postfix increment + __host__ __device__ __forceinline__ self_type operator++(int) + { + self_type retval = *this; + input_itr++; + return retval; + } + + /// Prefix increment + __host__ __device__ __forceinline__ self_type operator++() + { + input_itr++; + return *this; + } + + /// Indirection + __host__ __device__ __forceinline__ reference operator*() const + { + return conversion_op(*input_itr); + } + + /// Addition + template + __host__ __device__ __forceinline__ self_type operator+(Distance n) const + { + self_type retval(input_itr + n, conversion_op); + return retval; + } + + /// Addition assignment + template + __host__ __device__ __forceinline__ self_type& operator+=(Distance n) + { + input_itr += n; + return *this; + } + + /// Subtraction + template + __host__ __device__ __forceinline__ self_type operator-(Distance n) const + { + self_type retval(input_itr - n, conversion_op); + return retval; + } + + /// Subtraction assignment + template + __host__ __device__ __forceinline__ self_type& operator-=(Distance n) + { + input_itr -= n; + return *this; + } + + /// Distance + __host__ __device__ __forceinline__ difference_type operator-(self_type other) const + { + return input_itr - other.input_itr; + } + + /// Array subscript + template + __host__ __device__ __forceinline__ reference operator[](Distance n) const + { + return conversion_op(input_itr[n]); + } + + /// Structure dereference + __host__ __device__ __forceinline__ pointer operator->() + { + return &conversion_op(*input_itr); + } + + /// Equal to + __host__ __device__ __forceinline__ bool operator==(const self_type& rhs) + { + return (input_itr == rhs.input_itr); + } + + /// Not equal to + __host__ __device__ __forceinline__ bool operator!=(const self_type& rhs) + { + return (input_itr != rhs.input_itr); + } + + /// ostream operator + friend std::ostream& operator<<(std::ostream& os, const self_type& itr) + { + return os; + } +}; + + + +/** @} */ // end group UtilIterator + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/thread/thread_load.cuh b/3rdparty/cub/cub/thread/thread_load.cuh new file mode 100644 index 00000000000..c6425ac862f --- /dev/null +++ b/3rdparty/cub/cub/thread/thread_load.cuh @@ -0,0 +1,454 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Thread utilities for reading memory using PTX cache modifiers. + */ + +#pragma once + +#include + +#include + +#include "../util_ptx.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \addtogroup UtilIo + * @{ + */ + +//----------------------------------------------------------------------------- +// Tags and constants +//----------------------------------------------------------------------------- + +/** + * \brief Enumeration of cache modifiers for memory load operations. + */ +enum CacheLoadModifier +{ + LOAD_DEFAULT, ///< Default (no modifier) + LOAD_CA, ///< Cache at all levels + LOAD_CG, ///< Cache at global level + LOAD_CS, ///< Cache streaming (likely to be accessed once) + LOAD_CV, ///< Cache as volatile (including cached system lines) + LOAD_LDG, ///< Cache as texture + LOAD_VOLATILE, ///< Volatile (any memory space) +}; + + +/** + * \name Thread I/O (cache modified) + * @{ + */ + +/** + * \brief Thread utility for reading memory using cub::CacheLoadModifier cache modifiers. Can be used to load any data type. + * + * \par Example + * \code + * #include // or equivalently + * + * // 32-bit load using cache-global modifier: + * int *d_in; + * int val = cub::ThreadLoad(d_in + threadIdx.x); + * + * // 16-bit load using default modifier + * short *d_in; + * short val = cub::ThreadLoad(d_in + threadIdx.x); + * + * // 256-bit load using cache-volatile modifier + * double4 *d_in; + * double4 val = cub::ThreadLoad(d_in + threadIdx.x); + * + * // 96-bit load using cache-streaming modifier + * struct TestFoo { bool a; short b; }; + * TestFoo *d_struct; + * TestFoo val = cub::ThreadLoad(d_in + threadIdx.x); + * \endcode + * + * \tparam MODIFIER [inferred] CacheLoadModifier enumeration + * \tparam InputIteratorT [inferred] Input iterator type \iterator + */ +template < + CacheLoadModifier MODIFIER, + typename InputIteratorT> +__device__ __forceinline__ typename std::iterator_traits::value_type ThreadLoad(InputIteratorT itr); + + +//@} end member group + + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + +/// Helper structure for templated load iteration (inductive case) +template +struct IterateThreadLoad +{ + template + static __device__ __forceinline__ void Load(T *ptr, T *vals) + { + vals[COUNT] = ThreadLoad(ptr + COUNT); + IterateThreadLoad::template Load(ptr, vals); + } + + template + static __device__ __forceinline__ void Dereference(InputIteratorT ptr, T *vals) + { + vals[COUNT] = ptr[COUNT]; + IterateThreadLoad::Dereference(ptr, vals); + } +}; + + +/// Helper structure for templated load iteration (termination case) +template +struct IterateThreadLoad +{ + template + static __device__ __forceinline__ void Load(T *ptr, T *vals) {} + + template + static __device__ __forceinline__ void Dereference(InputIteratorT ptr, T *vals) {} +}; + + +/** + * Define a uint4 (16B) ThreadLoad specialization for the given Cache load modifier + */ +#define CUB_LOAD_16(cub_modifier, ptx_modifier) \ + template<> \ + __device__ __forceinline__ uint4 ThreadLoad(uint4* ptr) \ + { \ + uint4 retval; \ + asm volatile ("ld."#ptx_modifier".v4.u32 {%0, %1, %2, %3}, [%4];" : \ + "=r"(retval.x), \ + "=r"(retval.y), \ + "=r"(retval.z), \ + "=r"(retval.w) : \ + _CUB_ASM_PTR_(ptr)); \ + return retval; \ + } \ + template<> \ + __device__ __forceinline__ ulonglong2 ThreadLoad(ulonglong2* ptr) \ + { \ + ulonglong2 retval; \ + asm volatile ("ld."#ptx_modifier".v2.u64 {%0, %1}, [%2];" : \ + "=l"(retval.x), \ + "=l"(retval.y) : \ + _CUB_ASM_PTR_(ptr)); \ + return retval; \ + } + +/** + * Define a uint2 (8B) ThreadLoad specialization for the given Cache load modifier + */ +#define CUB_LOAD_8(cub_modifier, ptx_modifier) \ + template<> \ + __device__ __forceinline__ ushort4 ThreadLoad(ushort4* ptr) \ + { \ + ushort4 retval; \ + asm volatile ("ld."#ptx_modifier".v4.u16 {%0, %1, %2, %3}, [%4];" : \ + "=h"(retval.x), \ + "=h"(retval.y), \ + "=h"(retval.z), \ + "=h"(retval.w) : \ + _CUB_ASM_PTR_(ptr)); \ + return retval; \ + } \ + template<> \ + __device__ __forceinline__ uint2 ThreadLoad(uint2* ptr) \ + { \ + uint2 retval; \ + asm volatile ("ld."#ptx_modifier".v2.u32 {%0, %1}, [%2];" : \ + "=r"(retval.x), \ + "=r"(retval.y) : \ + _CUB_ASM_PTR_(ptr)); \ + return retval; \ + } \ + template<> \ + __device__ __forceinline__ unsigned long long ThreadLoad(unsigned long long* ptr) \ + { \ + unsigned long long retval; \ + asm volatile ("ld."#ptx_modifier".u64 %0, [%1];" : \ + "=l"(retval) : \ + _CUB_ASM_PTR_(ptr)); \ + return retval; \ + } + +/** + * Define a uint (4B) ThreadLoad specialization for the given Cache load modifier + */ +#define CUB_LOAD_4(cub_modifier, ptx_modifier) \ + template<> \ + __device__ __forceinline__ unsigned int ThreadLoad(unsigned int* ptr) \ + { \ + unsigned int retval; \ + asm volatile ("ld."#ptx_modifier".u32 %0, [%1];" : \ + "=r"(retval) : \ + _CUB_ASM_PTR_(ptr)); \ + return retval; \ + } + + +/** + * Define a unsigned short (2B) ThreadLoad specialization for the given Cache load modifier + */ +#define CUB_LOAD_2(cub_modifier, ptx_modifier) \ + template<> \ + __device__ __forceinline__ unsigned short ThreadLoad(unsigned short* ptr) \ + { \ + unsigned short retval; \ + asm volatile ("ld."#ptx_modifier".u16 %0, [%1];" : \ + "=h"(retval) : \ + _CUB_ASM_PTR_(ptr)); \ + return retval; \ + } + + +/** + * Define an unsigned char (1B) ThreadLoad specialization for the given Cache load modifier + */ +#define CUB_LOAD_1(cub_modifier, ptx_modifier) \ + template<> \ + __device__ __forceinline__ unsigned char ThreadLoad(unsigned char* ptr) \ + { \ + unsigned short retval; \ + asm volatile ( \ + "{" \ + " .reg .u8 datum;" \ + " ld."#ptx_modifier".u8 datum, [%1];" \ + " cvt.u16.u8 %0, datum;" \ + "}" : \ + "=h"(retval) : \ + _CUB_ASM_PTR_(ptr)); \ + return (unsigned char) retval; \ + } + + +/** + * Define powers-of-two ThreadLoad specializations for the given Cache load modifier + */ +#define CUB_LOAD_ALL(cub_modifier, ptx_modifier) \ + CUB_LOAD_16(cub_modifier, ptx_modifier) \ + CUB_LOAD_8(cub_modifier, ptx_modifier) \ + CUB_LOAD_4(cub_modifier, ptx_modifier) \ + CUB_LOAD_2(cub_modifier, ptx_modifier) \ + CUB_LOAD_1(cub_modifier, ptx_modifier) \ + + +/** + * Define powers-of-two ThreadLoad specializations for the various Cache load modifiers + */ +#if CUB_PTX_ARCH >= 200 + CUB_LOAD_ALL(LOAD_CA, ca) + CUB_LOAD_ALL(LOAD_CG, cg) + CUB_LOAD_ALL(LOAD_CS, cs) + CUB_LOAD_ALL(LOAD_CV, cv) +#else + CUB_LOAD_ALL(LOAD_CA, global) + // Use volatile to ensure coherent reads when this PTX is JIT'd to run on newer architectures with L1 + CUB_LOAD_ALL(LOAD_CG, volatile.global) + CUB_LOAD_ALL(LOAD_CS, global) + CUB_LOAD_ALL(LOAD_CV, volatile.global) +#endif + +#if CUB_PTX_ARCH >= 350 + CUB_LOAD_ALL(LOAD_LDG, global.nc) +#else + CUB_LOAD_ALL(LOAD_LDG, global) +#endif + + +// Macro cleanup +#undef CUB_LOAD_ALL +#undef CUB_LOAD_1 +#undef CUB_LOAD_2 +#undef CUB_LOAD_4 +#undef CUB_LOAD_8 +#undef CUB_LOAD_16 + + + +/** + * ThreadLoad definition for LOAD_DEFAULT modifier on iterator types + */ +template +__device__ __forceinline__ typename std::iterator_traits::value_type ThreadLoad( + InputIteratorT itr, + Int2Type modifier, + Int2Type is_pointer) +{ + return *itr; +} + + +/** + * ThreadLoad definition for LOAD_DEFAULT modifier on pointer types + */ +template +__device__ __forceinline__ T ThreadLoad( + T *ptr, + Int2Type modifier, + Int2Type is_pointer) +{ + return *ptr; +} + + +/** + * ThreadLoad definition for LOAD_VOLATILE modifier on primitive pointer types + */ +template +__device__ __forceinline__ T ThreadLoadVolatilePointer( + T *ptr, + Int2Type is_primitive) +{ + T retval = *reinterpret_cast(ptr); + +#if (CUB_PTX_ARCH <= 130) + if (sizeof(T) == 1) __threadfence_block(); +#endif + + return retval; +} + + +/** + * ThreadLoad definition for LOAD_VOLATILE modifier on non-primitive pointer types + */ +template +__device__ __forceinline__ T ThreadLoadVolatilePointer( + T *ptr, + Int2Type is_primitive) +{ + +#if CUB_PTX_ARCH <= 130 + + T retval = *ptr; + __threadfence_block(); + return retval; + +#else + + typedef typename UnitWord::VolatileWord VolatileWord; // Word type for memcopying + + const int VOLATILE_MULTIPLE = sizeof(T) / sizeof(VolatileWord); +/* + VolatileWord words[VOLATILE_MULTIPLE]; + + IterateThreadLoad<0, VOLATILE_MULTIPLE>::Dereference( + reinterpret_cast(ptr), + words); + + return *reinterpret_cast(words); +*/ + + T retval; + VolatileWord *words = reinterpret_cast(&retval); + IterateThreadLoad<0, VOLATILE_MULTIPLE>::Dereference( + reinterpret_cast(ptr), + words); + return retval; + +#endif // CUB_PTX_ARCH <= 130 +} + + +/** + * ThreadLoad definition for LOAD_VOLATILE modifier on pointer types + */ +template +__device__ __forceinline__ T ThreadLoad( + T *ptr, + Int2Type modifier, + Int2Type is_pointer) +{ + // Apply tags for partial-specialization + return ThreadLoadVolatilePointer(ptr, Int2Type::PRIMITIVE>()); +} + + +/** + * ThreadLoad definition for generic modifiers on pointer types + */ +template +__device__ __forceinline__ T ThreadLoad( + T *ptr, + Int2Type modifier, + Int2Type is_pointer) +{ + typedef typename UnitWord::DeviceWord DeviceWord; + + const int DEVICE_MULTIPLE = sizeof(T) / sizeof(DeviceWord); + + DeviceWord words[DEVICE_MULTIPLE]; + + IterateThreadLoad<0, DEVICE_MULTIPLE>::template Load( + reinterpret_cast(ptr), + words); + + return *reinterpret_cast(words); +} + + +/** + * ThreadLoad definition for generic modifiers + */ +template < + CacheLoadModifier MODIFIER, + typename InputIteratorT> +__device__ __forceinline__ typename std::iterator_traits::value_type ThreadLoad(InputIteratorT itr) +{ + // Apply tags for partial-specialization + return ThreadLoad( + itr, + Int2Type(), + Int2Type::VALUE>()); +} + + + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + +/** @} */ // end group UtilIo + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/thread/thread_operators.cuh b/3rdparty/cub/cub/thread/thread_operators.cuh new file mode 100644 index 00000000000..b7a38cec0a8 --- /dev/null +++ b/3rdparty/cub/cub/thread/thread_operators.cuh @@ -0,0 +1,314 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Simple binary operator functor types + */ + +/****************************************************************************** + * Simple functor operators + ******************************************************************************/ + +#pragma once + +#include "../util_macro.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup UtilModule + * @{ + */ + +/** + * \brief Default equality functor + */ +struct Equality +{ + /// Boolean equality operator, returns (a == b) + template + __host__ __device__ __forceinline__ bool operator()(const T &a, const T &b) const + { + return a == b; + } +}; + + +/** + * \brief Default inequality functor + */ +struct Inequality +{ + /// Boolean inequality operator, returns (a != b) + template + __host__ __device__ __forceinline__ bool operator()(const T &a, const T &b) const + { + return a != b; + } +}; + + +/** + * \brief Inequality functor (wraps equality functor) + */ +template +struct InequalityWrapper +{ + /// Wrapped equality operator + EqualityOp op; + + /// Constructor + __host__ __device__ __forceinline__ + InequalityWrapper(EqualityOp op) : op(op) {} + + /// Boolean inequality operator, returns (a != b) + template + __host__ __device__ __forceinline__ bool operator()(const T &a, const T &b) const + { + return !op(a, b); + } +}; + + +/** + * \brief Default sum functor + */ +struct Sum +{ + /// Boolean sum operator, returns a + b + template + __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const + { + return a + b; + } +}; + + +/** + * \brief Default max functor + */ +struct Max +{ + /// Boolean max operator, returns (a > b) ? a : b + template + __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const + { + return CUB_MAX(a, b); + } +}; + + +/** + * \brief Arg max functor (keeps the value and offset of the first occurrence of the larger item) + */ +struct ArgMax +{ + /// Boolean max operator, preferring the item having the smaller offset in case of ties + template + __host__ __device__ __forceinline__ KeyValuePair operator()( + const KeyValuePair &a, + const KeyValuePair &b) const + { +// Mooch BUG (device reduce argmax gk110 3.2 million random fp32) +// return ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key))) ? b : a; + + if ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key))) + return b; + return a; + } +}; + + +/** + * \brief Default min functor + */ +struct Min +{ + /// Boolean min operator, returns (a < b) ? a : b + template + __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const + { + return CUB_MIN(a, b); + } +}; + + +/** + * \brief Arg min functor (keeps the value and offset of the first occurrence of the smallest item) + */ +struct ArgMin +{ + /// Boolean min operator, preferring the item having the smaller offset in case of ties + template + __host__ __device__ __forceinline__ KeyValuePair operator()( + const KeyValuePair &a, + const KeyValuePair &b) const + { +// Mooch BUG (device reduce argmax gk110 3.2 million random fp32) +// return ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key))) ? b : a; + + if ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key))) + return b; + return a; + } +}; + + +/** + * \brief Default cast functor + */ +template +struct Cast +{ + /// Cast operator, returns (B) a + template + __host__ __device__ __forceinline__ B operator()(const A &a) const + { + return (B) a; + } +}; + + +/** + * \brief Binary operator wrapper for switching non-commutative scan arguments + */ +template +class SwizzleScanOp +{ +private: + + /// Wrapped scan operator + ScanOp scan_op; + +public: + + /// Constructor + __host__ __device__ __forceinline__ + SwizzleScanOp(ScanOp scan_op) : scan_op(scan_op) {} + + /// Switch the scan arguments + template + __host__ __device__ __forceinline__ + T operator()(const T &a, const T &b) + { + return scan_op(b, a); + } +}; + + +/** + * \brief Reduce-by-segment functor. + * + * Given two cub::KeyValuePair inputs \p a and \p b and a + * binary associative combining operator \p f(const T &x, const T &y), + * an instance of this functor returns a cub::KeyValuePair whose \p key + * field is a.key + a.key, and whose \p value field + * is either b.value if b.key is non-zero, or f(a.value, b.value) otherwise. + * + * ReduceBySegmentOp is an associative, non-commutative binary combining operator + * for input sequences of cub::KeyValuePair pairings. Such + * sequences are typically used to represent a segmented set of values to be reduced + * and a corresponding set of {0,1}-valued integer "head flags" demarcating the + * first value of each segment. + * + */ +template ///< Binary reduction operator to apply to values +struct ReduceBySegmentOp +{ + /// Wrapped reduction operator + ReductionOpT op; + + /// Constructor + __host__ __device__ __forceinline__ ReduceBySegmentOp() {} + + /// Constructor + __host__ __device__ __forceinline__ ReduceBySegmentOp(ReductionOpT op) : op(op) {} + + /// Scan operator + template ///< KeyValuePair pairing of T (value) and OffsetT (head flag) + __host__ __device__ __forceinline__ KeyValuePairT operator()( + const KeyValuePairT &first, ///< First partial reduction + const KeyValuePairT &second) ///< Second partial reduction + { + KeyValuePairT retval; + retval.key = first.key + second.key; + retval.value = (second.key) ? + second.value : // The second partial reduction spans a segment reset, so it's value aggregate becomes the running aggregate + op(first.value, second.value); // The second partial reduction does not span a reset, so accumulate both into the running aggregate + return retval; + } +}; + + + +template ///< Binary reduction operator to apply to values +struct ReduceByKeyOp +{ + /// Wrapped reduction operator + ReductionOpT op; + + /// Constructor + __host__ __device__ __forceinline__ ReduceByKeyOp() {} + + /// Constructor + __host__ __device__ __forceinline__ ReduceByKeyOp(ReductionOpT op) : op(op) {} + + /// Scan operator + template + __host__ __device__ __forceinline__ KeyValuePairT operator()( + const KeyValuePairT &first, ///< First partial reduction + const KeyValuePairT &second) ///< Second partial reduction + { + KeyValuePairT retval = second; + + if (first.key == second.key) + retval.value = op(first.value, retval.value); + + return retval; + } +}; + + + + + + + +/** @} */ // end group UtilModule + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/thread/thread_reduce.cuh b/3rdparty/cub/cub/thread/thread_reduce.cuh new file mode 100644 index 00000000000..c7ed0869559 --- /dev/null +++ b/3rdparty/cub/cub/thread/thread_reduce.cuh @@ -0,0 +1,169 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Thread utilities for sequential reduction over statically-sized array types + */ + +#pragma once + +#include "../thread/thread_operators.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \addtogroup UtilModule + * @{ + */ + +/** + * \name Sequential reduction over statically-sized array types + * @{ + */ + + +template < + int LENGTH, + typename T, + typename ReductionOp> +__device__ __forceinline__ T ThreadReduce( + T* input, ///< [in] Input array + ReductionOp reduction_op, ///< [in] Binary reduction operator + T prefix, ///< [in] Prefix to seed reduction with + Int2Type length) +{ + T addend = *input; + prefix = reduction_op(prefix, addend); + + return ThreadReduce(input + 1, reduction_op, prefix, Int2Type()); +} + +template < + typename T, + typename ReductionOp> +__device__ __forceinline__ T ThreadReduce( + T* input, ///< [in] Input array + ReductionOp reduction_op, ///< [in] Binary reduction operator + T prefix, ///< [in] Prefix to seed reduction with + Int2Type<0> length) +{ + return prefix; +} + + +/** + * \brief Perform a sequential reduction over \p LENGTH elements of the \p input array, seeded with the specified \p prefix. The aggregate is returned. + * + * \tparam LENGTH LengthT of input array + * \tparam T [inferred] The data type to be reduced. + * \tparam ScanOp [inferred] Binary reduction operator type having member T operator()(const T &a, const T &b) + */ +template < + int LENGTH, + typename T, + typename ReductionOp> +__device__ __forceinline__ T ThreadReduce( + T* input, ///< [in] Input array + ReductionOp reduction_op, ///< [in] Binary reduction operator + T prefix) ///< [in] Prefix to seed reduction with +{ + return ThreadReduce(input, reduction_op, prefix, Int2Type()); +} + + +/** + * \brief Perform a sequential reduction over \p LENGTH elements of the \p input array. The aggregate is returned. + * + * \tparam LENGTH LengthT of input array + * \tparam T [inferred] The data type to be reduced. + * \tparam ScanOp [inferred] Binary reduction operator type having member T operator()(const T &a, const T &b) + */ +template < + int LENGTH, + typename T, + typename ReductionOp> +__device__ __forceinline__ T ThreadReduce( + T* input, ///< [in] Input array + ReductionOp reduction_op) ///< [in] Binary reduction operator +{ + T prefix = input[0]; + return ThreadReduce(input + 1, reduction_op, prefix); +} + + +/** + * \brief Perform a sequential reduction over the statically-sized \p input array, seeded with the specified \p prefix. The aggregate is returned. + * + * \tparam LENGTH [inferred] LengthT of \p input array + * \tparam T [inferred] The data type to be reduced. + * \tparam ScanOp [inferred] Binary reduction operator type having member T operator()(const T &a, const T &b) + */ +template < + int LENGTH, + typename T, + typename ReductionOp> +__device__ __forceinline__ T ThreadReduce( + T (&input)[LENGTH], ///< [in] Input array + ReductionOp reduction_op, ///< [in] Binary reduction operator + T prefix) ///< [in] Prefix to seed reduction with +{ + return ThreadReduce(input, reduction_op, prefix); +} + + +/** + * \brief Serial reduction with the specified operator + * + * \tparam LENGTH [inferred] LengthT of \p input array + * \tparam T [inferred] The data type to be reduced. + * \tparam ScanOp [inferred] Binary reduction operator type having member T operator()(const T &a, const T &b) + */ +template < + int LENGTH, + typename T, + typename ReductionOp> +__device__ __forceinline__ T ThreadReduce( + T (&input)[LENGTH], ///< [in] Input array + ReductionOp reduction_op) ///< [in] Binary reduction operator +{ + return ThreadReduce((T*) input, reduction_op); +} + + +//@} end member group + +/** @} */ // end group UtilModule + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/thread/thread_scan.cuh b/3rdparty/cub/cub/thread/thread_scan.cuh new file mode 100644 index 00000000000..a1233616694 --- /dev/null +++ b/3rdparty/cub/cub/thread/thread_scan.cuh @@ -0,0 +1,283 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Thread utilities for sequential prefix scan over statically-sized array types + */ + +#pragma once + +#include "../thread/thread_operators.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \addtogroup UtilModule + * @{ + */ + +/** + * \name Sequential prefix scan over statically-sized array types + * @{ + */ + +template < + int LENGTH, + typename T, + typename ScanOp> +__device__ __forceinline__ T ThreadScanExclusive( + T inclusive, + T exclusive, + T *input, ///< [in] Input array + T *output, ///< [out] Output array (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + Int2Type length) +{ + T addend = *input; + inclusive = scan_op(exclusive, addend); + *output = exclusive; + exclusive = inclusive; + + return ThreadScanExclusive(inclusive, exclusive, input + 1, output + 1, scan_op, Int2Type()); +} + +template < + typename T, + typename ScanOp> +__device__ __forceinline__ T ThreadScanExclusive( + T inclusive, + T exclusive, + T *input, ///< [in] Input array + T *output, ///< [out] Output array (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + Int2Type<0> length) +{ + return inclusive; +} + + +/** + * \brief Perform a sequential exclusive prefix scan over \p LENGTH elements of the \p input array, seeded with the specified \p prefix. The aggregate is returned. + * + * \tparam LENGTH LengthT of \p input and \p output arrays + * \tparam T [inferred] The data type to be scanned. + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ +template < + int LENGTH, + typename T, + typename ScanOp> +__device__ __forceinline__ T ThreadScanExclusive( + T *input, ///< [in] Input array + T *output, ///< [out] Output array (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T prefix, ///< [in] Prefix to seed scan with + bool apply_prefix = true) ///< [in] Whether or not the calling thread should apply its prefix. If not, the first output element is undefined. (Handy for preventing thread-0 from applying a prefix.) +{ + T inclusive = input[0]; + if (apply_prefix) + { + inclusive = scan_op(prefix, inclusive); + } + output[0] = prefix; + T exclusive = inclusive; + + return ThreadScanExclusive(inclusive, exclusive, input + 1, output + 1, scan_op, Int2Type()); +} + + +/** + * \brief Perform a sequential exclusive prefix scan over the statically-sized \p input array, seeded with the specified \p prefix. The aggregate is returned. + * + * \tparam LENGTH [inferred] LengthT of \p input and \p output arrays + * \tparam T [inferred] The data type to be scanned. + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ +template < + int LENGTH, + typename T, + typename ScanOp> +__device__ __forceinline__ T ThreadScanExclusive( + T (&input)[LENGTH], ///< [in] Input array + T (&output)[LENGTH], ///< [out] Output array (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T prefix, ///< [in] Prefix to seed scan with + bool apply_prefix = true) ///< [in] Whether or not the calling thread should apply its prefix. (Handy for preventing thread-0 from applying a prefix.) +{ + return ThreadScanExclusive((T*) input, (T*) output, scan_op, prefix, apply_prefix); +} + + + + + + + + + +template < + int LENGTH, + typename T, + typename ScanOp> +__device__ __forceinline__ T ThreadScanInclusive( + T inclusive, + T *input, ///< [in] Input array + T *output, ///< [out] Output array (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + Int2Type length) +{ + T addend = *input; + inclusive = scan_op(inclusive, addend); + output[0] = inclusive; + + return ThreadScanInclusive(inclusive, input + 1, output + 1, scan_op, Int2Type()); +} + +template < + typename T, + typename ScanOp> +__device__ __forceinline__ T ThreadScanInclusive( + T inclusive, + T *input, ///< [in] Input array + T *output, ///< [out] Output array (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + Int2Type<0> length) +{ + return inclusive; +} + + +/** + * \brief Perform a sequential inclusive prefix scan over \p LENGTH elements of the \p input array. The aggregate is returned. + * + * \tparam LENGTH LengthT of \p input and \p output arrays + * \tparam T [inferred] The data type to be scanned. + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ +template < + int LENGTH, + typename T, + typename ScanOp> +__device__ __forceinline__ T ThreadScanInclusive( + T *input, ///< [in] Input array + T *output, ///< [out] Output array (may be aliased to \p input) + ScanOp scan_op) ///< [in] Binary scan operator +{ + T inclusive = input[0]; + output[0] = inclusive; + + // Continue scan + return ThreadScanInclusive(inclusive, input + 1, output + 1, scan_op, Int2Type()); +} + + +/** + * \brief Perform a sequential inclusive prefix scan over the statically-sized \p input array. The aggregate is returned. + * + * \tparam LENGTH [inferred] LengthT of \p input and \p output arrays + * \tparam T [inferred] The data type to be scanned. + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ +template < + int LENGTH, + typename T, + typename ScanOp> +__device__ __forceinline__ T ThreadScanInclusive( + T (&input)[LENGTH], ///< [in] Input array + T (&output)[LENGTH], ///< [out] Output array (may be aliased to \p input) + ScanOp scan_op) ///< [in] Binary scan operator +{ + return ThreadScanInclusive((T*) input, (T*) output, scan_op); +} + + +/** + * \brief Perform a sequential inclusive prefix scan over \p LENGTH elements of the \p input array, seeded with the specified \p prefix. The aggregate is returned. + * + * \tparam LENGTH LengthT of \p input and \p output arrays + * \tparam T [inferred] The data type to be scanned. + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ +template < + int LENGTH, + typename T, + typename ScanOp> +__device__ __forceinline__ T ThreadScanInclusive( + T *input, ///< [in] Input array + T *output, ///< [out] Output array (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T prefix, ///< [in] Prefix to seed scan with + bool apply_prefix = true) ///< [in] Whether or not the calling thread should apply its prefix. (Handy for preventing thread-0 from applying a prefix.) +{ + T inclusive = input[0]; + if (apply_prefix) + { + inclusive = scan_op(prefix, inclusive); + } + output[0] = inclusive; + + // Continue scan + return ThreadScanInclusive(inclusive, input + 1, output + 1, scan_op, Int2Type()); +} + + +/** + * \brief Perform a sequential inclusive prefix scan over the statically-sized \p input array, seeded with the specified \p prefix. The aggregate is returned. + * + * \tparam LENGTH [inferred] LengthT of \p input and \p output arrays + * \tparam T [inferred] The data type to be scanned. + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ +template < + int LENGTH, + typename T, + typename ScanOp> +__device__ __forceinline__ T ThreadScanInclusive( + T (&input)[LENGTH], ///< [in] Input array + T (&output)[LENGTH], ///< [out] Output array (may be aliased to \p input) + ScanOp scan_op, ///< [in] Binary scan operator + T prefix, ///< [in] Prefix to seed scan with + bool apply_prefix = true) ///< [in] Whether or not the calling thread should apply its prefix. (Handy for preventing thread-0 from applying a prefix.) +{ + return ThreadScanInclusive((T*) input, (T*) output, scan_op, prefix, apply_prefix); +} + + +//@} end member group + +/** @} */ // end group UtilModule + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/thread/thread_search.cuh b/3rdparty/cub/cub/thread/thread_search.cuh new file mode 100644 index 00000000000..388ac54e57d --- /dev/null +++ b/3rdparty/cub/cub/thread/thread_search.cuh @@ -0,0 +1,154 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Thread utilities for sequential search + */ + +#pragma once + +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * Computes the begin offsets into A and B for the specific diagonal + */ +template < + typename AIteratorT, + typename BIteratorT, + typename OffsetT, + typename CoordinateT> +__device__ __forceinline__ void MergePathSearch( + OffsetT diagonal, + AIteratorT a, + BIteratorT b, + OffsetT a_len, + OffsetT b_len, + CoordinateT& path_coordinate) +{ + /// The value type of the input iterator + typedef typename std::iterator_traits::value_type T; + + OffsetT split_min = CUB_MAX(diagonal - b_len, 0); + OffsetT split_max = CUB_MIN(diagonal, a_len); + + while (split_min < split_max) + { + OffsetT split_pivot = (split_min + split_max) >> 1; + if (a[split_pivot] <= b[diagonal - split_pivot - 1]) + { + // Move candidate split range up A, down B + split_min = split_pivot + 1; + } + else + { + // Move candidate split range up B, down A + split_max = split_pivot; + } + } + + path_coordinate.x = CUB_MIN(split_min, a_len); + path_coordinate.y = diagonal - split_min; +} + + + +/** + * \brief Returns the offset of the first value within \p input which does not compare less than \p val + */ +template < + typename InputIteratorT, + typename OffsetT, + typename T> +__device__ __forceinline__ OffsetT LowerBound( + InputIteratorT input, ///< [in] Input sequence + OffsetT num_items, ///< [in] Input sequence length + T val) ///< [in] Search key +{ + OffsetT retval = 0; + while (num_items > 0) + { + OffsetT half = num_items >> 1; + if (input[retval + half] < val) + { + retval = retval + (half + 1); + num_items = num_items - (half + 1); + } + else + { + num_items = half; + } + } + + return retval; +} + + +/** + * \brief Returns the offset of the first value within \p input which compares greater than \p val + */ +template < + typename InputIteratorT, + typename OffsetT, + typename T> +__device__ __forceinline__ OffsetT UpperBound( + InputIteratorT input, ///< [in] Input sequence + OffsetT num_items, ///< [in] Input sequence length + T val) ///< [in] Search key +{ + OffsetT retval = 0; + while (num_items > 0) + { + OffsetT half = num_items >> 1; + if (val < input[retval + half]) + { + num_items = half; + } + else + { + retval = retval + (half + 1); + num_items = num_items - (half + 1); + } + } + + return retval; +} + + + + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/thread/thread_store.cuh b/3rdparty/cub/cub/thread/thread_store.cuh new file mode 100644 index 00000000000..e9d7b54aa26 --- /dev/null +++ b/3rdparty/cub/cub/thread/thread_store.cuh @@ -0,0 +1,423 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Thread utilities for writing memory using PTX cache modifiers. + */ + +#pragma once + +#include + +#include "../util_ptx.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \addtogroup UtilIo + * @{ + */ + + +//----------------------------------------------------------------------------- +// Tags and constants +//----------------------------------------------------------------------------- + +/** + * \brief Enumeration of cache modifiers for memory store operations. + */ +enum CacheStoreModifier +{ + STORE_DEFAULT, ///< Default (no modifier) + STORE_WB, ///< Cache write-back all coherent levels + STORE_CG, ///< Cache at global level + STORE_CS, ///< Cache streaming (likely to be accessed once) + STORE_WT, ///< Cache write-through (to system memory) + STORE_VOLATILE, ///< Volatile shared (any memory space) +}; + + +/** + * \name Thread I/O (cache modified) + * @{ + */ + +/** + * \brief Thread utility for writing memory using cub::CacheStoreModifier cache modifiers. Can be used to store any data type. + * + * \par Example + * \code + * #include // or equivalently + * + * // 32-bit store using cache-global modifier: + * int *d_out; + * int val; + * cub::ThreadStore(d_out + threadIdx.x, val); + * + * // 16-bit store using default modifier + * short *d_out; + * short val; + * cub::ThreadStore(d_out + threadIdx.x, val); + * + * // 256-bit store using write-through modifier + * double4 *d_out; + * double4 val; + * cub::ThreadStore(d_out + threadIdx.x, val); + * + * // 96-bit store using cache-streaming cache modifier + * struct TestFoo { bool a; short b; }; + * TestFoo *d_struct; + * TestFoo val; + * cub::ThreadStore(d_out + threadIdx.x, val); + * \endcode + * + * \tparam MODIFIER [inferred] CacheStoreModifier enumeration + * \tparam InputIteratorT [inferred] Output iterator type \iterator + * \tparam T [inferred] Data type of output value + */ +template < + CacheStoreModifier MODIFIER, + typename OutputIteratorT, + typename T> +__device__ __forceinline__ void ThreadStore(OutputIteratorT itr, T val); + + +//@} end member group + + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + +/// Helper structure for templated store iteration (inductive case) +template +struct IterateThreadStore +{ + template + static __device__ __forceinline__ void Store(T *ptr, T *vals) + { + ThreadStore(ptr + COUNT, vals[COUNT]); + IterateThreadStore::template Store(ptr, vals); + } + + template + static __device__ __forceinline__ void Dereference(OutputIteratorT ptr, T *vals) + { + ptr[COUNT] = vals[COUNT]; + IterateThreadStore::Dereference(ptr, vals); + } + +}; + +/// Helper structure for templated store iteration (termination case) +template +struct IterateThreadStore +{ + template + static __device__ __forceinline__ void Store(T *ptr, T *vals) {} + + template + static __device__ __forceinline__ void Dereference(OutputIteratorT ptr, T *vals) {} +}; + + +/** + * Define a uint4 (16B) ThreadStore specialization for the given Cache load modifier + */ +#define CUB_STORE_16(cub_modifier, ptx_modifier) \ + template<> \ + __device__ __forceinline__ void ThreadStore(uint4* ptr, uint4 val) \ + { \ + asm volatile ("st."#ptx_modifier".v4.u32 [%0], {%1, %2, %3, %4};" : : \ + _CUB_ASM_PTR_(ptr), \ + "r"(val.x), \ + "r"(val.y), \ + "r"(val.z), \ + "r"(val.w)); \ + } \ + template<> \ + __device__ __forceinline__ void ThreadStore(ulonglong2* ptr, ulonglong2 val) \ + { \ + asm volatile ("st."#ptx_modifier".v2.u64 [%0], {%1, %2};" : : \ + _CUB_ASM_PTR_(ptr), \ + "l"(val.x), \ + "l"(val.y)); \ + } + + +/** + * Define a uint2 (8B) ThreadStore specialization for the given Cache load modifier + */ +#define CUB_STORE_8(cub_modifier, ptx_modifier) \ + template<> \ + __device__ __forceinline__ void ThreadStore(ushort4* ptr, ushort4 val) \ + { \ + asm volatile ("st."#ptx_modifier".v4.u16 [%0], {%1, %2, %3, %4};" : : \ + _CUB_ASM_PTR_(ptr), \ + "h"(val.x), \ + "h"(val.y), \ + "h"(val.z), \ + "h"(val.w)); \ + } \ + template<> \ + __device__ __forceinline__ void ThreadStore(uint2* ptr, uint2 val) \ + { \ + asm volatile ("st."#ptx_modifier".v2.u32 [%0], {%1, %2};" : : \ + _CUB_ASM_PTR_(ptr), \ + "r"(val.x), \ + "r"(val.y)); \ + } \ + template<> \ + __device__ __forceinline__ void ThreadStore(unsigned long long* ptr, unsigned long long val) \ + { \ + asm volatile ("st."#ptx_modifier".u64 [%0], %1;" : : \ + _CUB_ASM_PTR_(ptr), \ + "l"(val)); \ + } + +/** + * Define a unsigned int (4B) ThreadStore specialization for the given Cache load modifier + */ +#define CUB_STORE_4(cub_modifier, ptx_modifier) \ + template<> \ + __device__ __forceinline__ void ThreadStore(unsigned int* ptr, unsigned int val) \ + { \ + asm volatile ("st."#ptx_modifier".u32 [%0], %1;" : : \ + _CUB_ASM_PTR_(ptr), \ + "r"(val)); \ + } + + +/** + * Define a unsigned short (2B) ThreadStore specialization for the given Cache load modifier + */ +#define CUB_STORE_2(cub_modifier, ptx_modifier) \ + template<> \ + __device__ __forceinline__ void ThreadStore(unsigned short* ptr, unsigned short val) \ + { \ + asm volatile ("st."#ptx_modifier".u16 [%0], %1;" : : \ + _CUB_ASM_PTR_(ptr), \ + "h"(val)); \ + } + + +/** + * Define a unsigned char (1B) ThreadStore specialization for the given Cache load modifier + */ +#define CUB_STORE_1(cub_modifier, ptx_modifier) \ + template<> \ + __device__ __forceinline__ void ThreadStore(unsigned char* ptr, unsigned char val) \ + { \ + asm volatile ( \ + "{" \ + " .reg .u8 datum;" \ + " cvt.u8.u16 datum, %1;" \ + " st."#ptx_modifier".u8 [%0], datum;" \ + "}" : : \ + _CUB_ASM_PTR_(ptr), \ + "h"((unsigned short) val)); \ + } + +/** + * Define powers-of-two ThreadStore specializations for the given Cache load modifier + */ +#define CUB_STORE_ALL(cub_modifier, ptx_modifier) \ + CUB_STORE_16(cub_modifier, ptx_modifier) \ + CUB_STORE_8(cub_modifier, ptx_modifier) \ + CUB_STORE_4(cub_modifier, ptx_modifier) \ + CUB_STORE_2(cub_modifier, ptx_modifier) \ + CUB_STORE_1(cub_modifier, ptx_modifier) \ + + +/** + * Define ThreadStore specializations for the various Cache load modifiers + */ +#if CUB_PTX_ARCH >= 200 + CUB_STORE_ALL(STORE_WB, ca) + CUB_STORE_ALL(STORE_CG, cg) + CUB_STORE_ALL(STORE_CS, cs) + CUB_STORE_ALL(STORE_WT, wt) +#else + CUB_STORE_ALL(STORE_WB, global) + CUB_STORE_ALL(STORE_CG, global) + CUB_STORE_ALL(STORE_CS, global) + CUB_STORE_ALL(STORE_WT, volatile.global) +#endif + + +// Macro cleanup +#undef CUB_STORE_ALL +#undef CUB_STORE_1 +#undef CUB_STORE_2 +#undef CUB_STORE_4 +#undef CUB_STORE_8 +#undef CUB_STORE_16 + + +/** + * ThreadStore definition for STORE_DEFAULT modifier on iterator types + */ +template +__device__ __forceinline__ void ThreadStore( + OutputIteratorT itr, + T val, + Int2Type modifier, + Int2Type is_pointer) +{ + *itr = val; +} + + +/** + * ThreadStore definition for STORE_DEFAULT modifier on pointer types + */ +template +__device__ __forceinline__ void ThreadStore( + T *ptr, + T val, + Int2Type modifier, + Int2Type is_pointer) +{ + *ptr = val; +} + + +/** + * ThreadStore definition for STORE_VOLATILE modifier on primitive pointer types + */ +template +__device__ __forceinline__ void ThreadStoreVolatilePtr( + T *ptr, + T val, + Int2Type is_primitive) +{ + *reinterpret_cast(ptr) = val; +} + + +/** + * ThreadStore definition for STORE_VOLATILE modifier on non-primitive pointer types + */ +template +__device__ __forceinline__ void ThreadStoreVolatilePtr( + T *ptr, + T val, + Int2Type is_primitive) +{ +#if CUB_PTX_ARCH <= 130 + + *ptr = val; + __threadfence_block(); + +#else + + typedef typename UnitWord::VolatileWord VolatileWord; // Word type for memcopying + + const int VOLATILE_MULTIPLE = sizeof(T) / sizeof(VolatileWord); + + VolatileWord words[VOLATILE_MULTIPLE]; + *reinterpret_cast(words) = val; + +// VolatileWord *words = reinterpret_cast(&val); + + IterateThreadStore<0, VOLATILE_MULTIPLE>::template Dereference( + reinterpret_cast(ptr), + words); + +#endif // CUB_PTX_ARCH <= 130 + +} + + +/** + * ThreadStore definition for STORE_VOLATILE modifier on pointer types + */ +template +__device__ __forceinline__ void ThreadStore( + T *ptr, + T val, + Int2Type modifier, + Int2Type is_pointer) +{ + ThreadStoreVolatilePtr(ptr, val, Int2Type::PRIMITIVE>()); +} + + +/** + * ThreadStore definition for generic modifiers on pointer types + */ +template +__device__ __forceinline__ void ThreadStore( + T *ptr, + T val, + Int2Type modifier, + Int2Type is_pointer) +{ + typedef typename UnitWord::DeviceWord DeviceWord; // Word type for memcopying + + const int DEVICE_MULTIPLE = sizeof(T) / sizeof(DeviceWord); + + DeviceWord words[DEVICE_MULTIPLE]; + + *reinterpret_cast(words) = val; + + IterateThreadStore<0, DEVICE_MULTIPLE>::template Store( + reinterpret_cast(ptr), + words); +} + + +/** + * ThreadStore definition for generic modifiers + */ +template +__device__ __forceinline__ void ThreadStore(OutputIteratorT itr, T val) +{ + ThreadStore( + itr, + val, + Int2Type(), + Int2Type::VALUE>()); +} + + + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + +/** @} */ // end group UtilIo + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/util_allocator.cuh b/3rdparty/cub/cub/util_allocator.cuh new file mode 100644 index 00000000000..051f82198c3 --- /dev/null +++ b/3rdparty/cub/cub/util_allocator.cuh @@ -0,0 +1,689 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/****************************************************************************** + * Simple caching allocator for device memory allocations. The allocator is + * thread-safe and capable of managing device allocations on multiple devices. + ******************************************************************************/ + +#pragma once + +#if (CUB_PTX_ARCH == 0) + #include // NVCC (EDG, really) takes FOREVER to compile std::map + #include +#endif + +#include + +#include "util_namespace.cuh" +#include "util_debug.cuh" + +#include "host/spinlock.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup UtilMgmt + * @{ + */ + + +/****************************************************************************** + * CachingDeviceAllocator (host use) + ******************************************************************************/ + +/** + * \brief A simple caching allocator for device memory allocations. + * + * \par Overview + * The allocator is thread-safe and stream-safe and is capable of managing cached + * device allocations on multiple devices. It behaves as follows: + * + * \par + * - Allocations from the allocator are associated with an \p active_stream. Once freed, + * the allocation becomes available immediately for reuse within the \p active_stream + * with which it was associated with during allocation, and it becomes available for + * reuse within other streams when all prior work submitted to \p active_stream has completed. + * - Allocations are categorized and cached by bin size. A new allocation request of + * a given size will only consider cached allocations within the corresponding bin. + * - Bin limits progress geometrically in accordance with the growth factor + * \p bin_growth provided during construction. Unused device allocations within + * a larger bin cache are not reused for allocation requests that categorize to + * smaller bin sizes. + * - Allocation requests below (\p bin_growth ^ \p min_bin) are rounded up to + * (\p bin_growth ^ \p min_bin). + * - Allocations above (\p bin_growth ^ \p max_bin) are not rounded up to the nearest + * bin and are simply freed when they are deallocated instead of being returned + * to a bin-cache. + * - %If the total storage of cached allocations on a given device will exceed + * \p max_cached_bytes, allocations for that device are simply freed when they are + * deallocated instead of being returned to their bin-cache. + * + * \par + * For example, the default-constructed CachingDeviceAllocator is configured with: + * - \p bin_growth = 8 + * - \p min_bin = 3 + * - \p max_bin = 7 + * - \p max_cached_bytes = 6MB - 1B + * + * \par + * which delineates five bin-sizes: 512B, 4KB, 32KB, 256KB, and 2MB + * and sets a maximum of 6,291,455 cached bytes per device + * + */ +struct CachingDeviceAllocator +{ +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + + //--------------------------------------------------------------------- + // Type definitions and constants + //--------------------------------------------------------------------- + + enum + { + /// Invalid device ordinal + INVALID_DEVICE_ORDINAL = -1, + }; + + /** + * Integer pow function for unsigned base and exponent + */ + static unsigned int IntPow( + unsigned int base, + unsigned int exp) + { + unsigned int retval = 1; + while (exp > 0) + { + if (exp & 1) { + retval = retval * base; // multiply the result by the current base + } + base = base * base; // square the base + exp = exp >> 1; // divide the exponent in half + } + return retval; + } + + + /** + * Round up to the nearest power-of + */ + static void NearestPowerOf( + unsigned int &power, + size_t &rounded_bytes, + unsigned int base, + size_t value) + { + power = 0; + rounded_bytes = 1; + + while (rounded_bytes < value) + { + rounded_bytes *= base; + power++; + } + } + + /** + * Descriptor for device memory allocations + */ + struct BlockDescriptor + { + void* d_ptr; // Device pointer + size_t bytes; // Size of allocation in bytes + unsigned int bin; // Bin enumeration + int device; // device ordinal + cudaStream_t associated_stream; // Associated associated_stream + cudaEvent_t ready_event; // Signal when associated stream has run to the point at which this block was freed + + // Constructor + BlockDescriptor(void *d_ptr, int device) : + d_ptr(d_ptr), + bytes(0), + bin(0), + device(device), + associated_stream(0), + ready_event(0) + {} + + // Constructor + BlockDescriptor(size_t bytes, unsigned int bin, int device, cudaStream_t associated_stream) : + d_ptr(NULL), + bytes(bytes), + bin(bin), + device(device), + associated_stream(associated_stream), + ready_event(0) + {} + + // Comparison functor for comparing device pointers + static bool PtrCompare(const BlockDescriptor &a, const BlockDescriptor &b) + { + if (a.device == b.device) + return (a.d_ptr < b.d_ptr); + else + return (a.device < b.device); + } + + // Comparison functor for comparing allocation sizes + static bool SizeCompare(const BlockDescriptor &a, const BlockDescriptor &b) + { + if (a.device == b.device) + return (a.bytes < b.bytes); + else + return (a.device < b.device); + } + }; + + /// BlockDescriptor comparator function interface + typedef bool (*Compare)(const BlockDescriptor &, const BlockDescriptor &); + +#if (CUB_PTX_ARCH == 0) // Only define STL container members in host code + + class TotalBytes { + public: + size_t free; + size_t busy; + TotalBytes() { free = busy = 0; } + }; + + /// Set type for cached blocks (ordered by size) + typedef std::multiset CachedBlocks; + + /// Set type for live blocks (ordered by ptr) + typedef std::multiset BusyBlocks; + + /// Map type of device ordinals to the number of cached bytes cached by each device + typedef std::map GpuCachedBytes; + +#endif // CUB_PTX_ARCH + + //--------------------------------------------------------------------- + // Fields + //--------------------------------------------------------------------- + + Spinlock spin_lock; /// Spinlock for thread-safety + + unsigned int bin_growth; /// Geometric growth factor for bin-sizes + unsigned int min_bin; /// Minimum bin enumeration + unsigned int max_bin; /// Maximum bin enumeration + + size_t min_bin_bytes; /// Minimum bin size + size_t max_bin_bytes; /// Maximum bin size + size_t max_cached_bytes; /// Maximum aggregate cached bytes per device + + const bool skip_cleanup; /// Whether or not to skip a call to FreeAllCached() when destructor is called. (The CUDA runtime may have already shut down for statically declared allocators) + bool debug; /// Whether or not to print (de)allocation events to stdout + +#if (CUB_PTX_ARCH == 0) // Only define STL container members in host code + + GpuCachedBytes cached_bytes; /// Map of device ordinal to aggregate cached bytes on that device + CachedBlocks cached_blocks; /// Set of cached device allocations available for reuse + BusyBlocks live_blocks; /// Set of live device allocations currently in use + +#endif // CUB_PTX_ARCH + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + //--------------------------------------------------------------------- + // Methods + //--------------------------------------------------------------------- + + /** + * \brief Constructor. + */ + CachingDeviceAllocator( + unsigned int bin_growth, ///< Geometric growth factor for bin-sizes + unsigned int min_bin, ///< Minimum bin + unsigned int max_bin, ///< Maximum bin + size_t max_cached_bytes, ///< Maximum aggregate cached bytes per device + bool skip_cleanup = false, ///< Whether or not to skip a call to \p FreeAllCached() when the destructor is called. + bool debug = false ///< Whether or not to print (de)allocation events to stdout + ) + : + spin_lock(0), + bin_growth(bin_growth), + min_bin(min_bin), + max_bin(max_bin), + min_bin_bytes(IntPow(bin_growth, min_bin)), + max_bin_bytes(IntPow(bin_growth, max_bin)), + max_cached_bytes(max_cached_bytes), + skip_cleanup(skip_cleanup), + debug(debug) + #if (CUB_PTX_ARCH == 0) // Only define STL container members in host code + ,cached_blocks(BlockDescriptor::SizeCompare) + ,live_blocks(BlockDescriptor::PtrCompare) + #endif + {} + + + /** + * \brief Default constructor. + * + * Configured with: + * \par + * - \p bin_growth = 8 + * - \p min_bin = 3 + * - \p max_bin = 7 + * - \p max_cached_bytes = (\p bin_growth ^ \p max_bin) * 3) - 1 = 6,291,455 bytes + * + * which delineates five bin-sizes: 512B, 4KB, 32KB, 256KB, and 2MB and + * sets a maximum of 6,291,455 cached bytes per device + */ + CachingDeviceAllocator( + bool skip_cleanup = false, + bool debug = false) + : + spin_lock(0), + bin_growth(8), + min_bin(3), + max_bin(7), + min_bin_bytes(IntPow(bin_growth, min_bin)), + max_bin_bytes(IntPow(bin_growth, max_bin)), + max_cached_bytes((max_bin_bytes * 3) - 1), + skip_cleanup(skip_cleanup), + debug(debug) + #if (CUB_PTX_ARCH == 0) // Only define STL container members in host code + ,cached_blocks(BlockDescriptor::SizeCompare) + ,live_blocks(BlockDescriptor::PtrCompare) + #endif + {} + + + /** + * \brief Sets the limit on the number bytes this allocator is allowed to cache per device. + */ + cudaError_t SetMaxCachedBytes( + size_t max_cached_bytes) + { + #if (CUB_PTX_ARCH > 0) + // Caching functionality only defined on host + return CubDebug(cudaErrorInvalidConfiguration); + #else + + // Lock + Lock(&spin_lock); + + this->max_cached_bytes = max_cached_bytes; + + if (debug) CubLog("New max_cached_bytes(%lld)\n", (long long) max_cached_bytes); + + // Unlock + Unlock(&spin_lock); + + return cudaSuccess; + + #endif // CUB_PTX_ARCH + } + + + /** + * \brief Provides a suitable allocation of device memory for the given size on the specified device. + * + * Once freed, the allocation becomes available immediately for reuse within the \p active_stream + * with which it was associated with during allocation, and it becomes available for reuse within other + * streams when all prior work submitted to \p active_stream has completed. + */ + cudaError_t DeviceAllocate( + int device, ///< [in] Device on which to place the allocation + void **d_ptr, ///< [out] Reference to pointer to the allocation + size_t bytes, ///< [in] Minimum number of bytes for the allocation + cudaStream_t active_stream = 0) ///< [in] The stream to be associated with this allocation + { + #if (CUB_PTX_ARCH > 0) + // Caching functionality only defined on host + return CubDebug(cudaErrorInvalidConfiguration); + #else + + *d_ptr = NULL; + + int entrypoint_device = INVALID_DEVICE_ORDINAL; + cudaError_t error = cudaSuccess; + + do { + + if (CubDebug(error = cudaGetDevice(&entrypoint_device))) break; + if (device == INVALID_DEVICE_ORDINAL) + device = entrypoint_device; + + // Round up to nearest bin size + unsigned int bin; + size_t bin_bytes; + NearestPowerOf(bin, bin_bytes, bin_growth, bytes); + if (bin < min_bin) { + bin = min_bin; + bin_bytes = min_bin_bytes; + } + + // Check if bin is greater than our maximum bin + if (bin > max_bin) + { + // Allocate the request exactly and give out-of-range bin + bin = (unsigned int) -1; + bin_bytes = bytes; + } + + BlockDescriptor search_key(bin_bytes, bin, device, active_stream); + + // Lock + Lock(&spin_lock); + + // Find the range of freed blocks big enough within the same bin on the same device + CachedBlocks::iterator block_itr = cached_blocks.lower_bound(search_key); + + // Look for freed blocks from the active stream or from other idle streams + bool found = false; + while ((block_itr != cached_blocks.end()) && + (block_itr->device == device) && + (block_itr->bin == search_key.bin)) + { + cudaStream_t prev_stream = block_itr->associated_stream; + if ((active_stream == prev_stream) || (cudaEventQuery(block_itr->ready_event) != cudaErrorNotReady)) + { + // Reuse existing cache block. Insert into live blocks. + found = true; + search_key = *block_itr; + search_key.associated_stream = active_stream; + live_blocks.insert(search_key); + + // Remove from free blocks + cached_blocks.erase(block_itr); + cached_bytes[device].free -= search_key.bytes; + cached_bytes[device].busy += search_key.bytes; + + if (debug) CubLog("\tdevice %d reused cached block at %p (%lld bytes) for stream %lld (previously associated with stream %lld).\n", + device, search_key.d_ptr, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) prev_stream); + + break; + } + + block_itr++; + } + + + if (!found) + { + Unlock(&spin_lock); + // Set to specified device + if (device != entrypoint_device) { + if (CubDebug(error = cudaSetDevice(device))) break; + } + + // Allocate + if (CubDebug(error = cudaMalloc(&search_key.d_ptr, search_key.bytes))) break; + if (CubDebug(error = cudaEventCreateWithFlags(&search_key.ready_event, cudaEventDisableTiming))) break; + + + Lock(&spin_lock); + // Insert into live blocks + live_blocks.insert(search_key); + cached_bytes[device].busy += search_key.bytes; + + if (debug) CubLog("\tdevice %d allocated new device block at %p (%lld bytes associated with stream %lld).\n", + device, search_key.d_ptr, (long long) search_key.bytes, (long long) search_key.associated_stream); + } + + // Copy device pointer to output parameter + *d_ptr = search_key.d_ptr; + if (debug) CubLog("\t\t%lld available blocks cached (%lld bytes), %lld live blocks outstanding(%lld bytes).\n", + (long long) cached_blocks.size(), (long long) cached_bytes[device].free, (long long) live_blocks.size(), (long long) cached_bytes[device].busy); + + } while(0); + + Unlock(&spin_lock); + + // Attempt to revert back to previous device if necessary + if ((entrypoint_device != INVALID_DEVICE_ORDINAL) && (entrypoint_device != device)) + { + if (CubDebug(error = cudaSetDevice(entrypoint_device))) return error; + } + + return error; + + #endif // CUB_PTX_ARCH + } + + + /** + * \brief Provides a suitable allocation of device memory for the given size on the current device. + * + * Once freed, the allocation becomes available immediately for reuse within the \p active_stream + * with which it was associated with during allocation, and it becomes available for reuse within other + * streams when all prior work submitted to \p active_stream has completed. + */ + cudaError_t DeviceAllocate( + void **d_ptr, ///< [out] Reference to pointer to the allocation + size_t bytes, ///< [in] Minimum number of bytes for the allocation + cudaStream_t active_stream = 0) ///< [in] The stream to be associated with this allocation + { + #if (CUB_PTX_ARCH > 0) + // Caching functionality only defined on host + return CubDebug(cudaErrorInvalidConfiguration); + #else + return DeviceAllocate(INVALID_DEVICE_ORDINAL, d_ptr, bytes, active_stream); + #endif // CUB_PTX_ARCH + } + + + /** + * \brief Frees a live allocation of device memory on the specified device, returning it to the allocator. + * + * Once freed, the allocation becomes available immediately for reuse within the \p active_stream + * with which it was associated with during allocation, and it becomes available for reuse within other + * streams when all prior work submitted to \p active_stream has completed. + */ + cudaError_t DeviceFree( + int device, + void* d_ptr) + { + #if (CUB_PTX_ARCH > 0) + // Caching functionality only defined on host + return CubDebug(cudaErrorInvalidConfiguration); + #else + + int entrypoint_device = INVALID_DEVICE_ORDINAL; + cudaError_t error = cudaSuccess; + + if (CubDebug(error = cudaGetDevice(&entrypoint_device))) return error; + + if (device == INVALID_DEVICE_ORDINAL) + device = entrypoint_device; + + BlockDescriptor search_key(d_ptr, device); + + do { + + // Set to specified device + if (device != entrypoint_device) { + if (CubDebug(error = cudaSetDevice(device))) break; + } + + // Lock + Lock(&spin_lock); + + // Find corresponding block descriptor + BusyBlocks::iterator block_itr = live_blocks.find(search_key); + if (block_itr == live_blocks.end()) + { + // Cannot find pointer + if (CubDebug(error = cudaErrorUnknown)) break; + } + else + { + // Remove from live blocks + search_key = *block_itr; + live_blocks.erase(block_itr); + + cached_bytes[device].busy -= search_key.bytes; + + // Check if we should keep the returned allocation + if (cached_bytes[device].free + search_key.bytes <= max_cached_bytes) + { + // Signal the event in the associated stream + if (CubDebug(error = cudaEventRecord(search_key.ready_event, search_key.associated_stream))) break; + + // Insert returned allocation into free blocks + cached_blocks.insert(search_key); + cached_bytes[device].free += search_key.bytes; + + if (debug) CubLog("\tdevice %d returned %lld bytes from associated stream %lld.\n\t\t %lld available blocks cached (%lld bytes), %lld live blocks outstanding. (%lld bytes)\n", + device, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) cached_blocks.size(), (long long) cached_bytes[device].free, (long long) live_blocks.size(), (long long) cached_bytes[device].busy); + } + else { + // This means : actually delete the block after we release the lock + d_ptr = 0; + } + } + } while (0); + + Unlock(&spin_lock); + + if (!d_ptr) + { + // Free device memory + if (CubDebug(error = cudaFree(d_ptr))) return error; + if (CubDebug(error = cudaEventDestroy(search_key.ready_event))) return error; + + if (debug) CubLog("\tdevice %d freed %lld bytes from associated stream %lld.\n\t\t %lld available blocks cached (%lld bytes), %lld live blocks (%lld bytes) outstanding.\n", + device, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) cached_blocks.size(), (long long) cached_bytes[device].free, (long long) live_blocks.size(), (long long) cached_bytes[device].busy); + } + + if ((entrypoint_device != INVALID_DEVICE_ORDINAL) && (entrypoint_device != device)) + { + if (CubDebug(error = cudaSetDevice(entrypoint_device))) return error; + } + + return error; + + #endif // CUB_PTX_ARCH + } + + + /** + * \brief Frees a live allocation of device memory on the current device, returning it to the allocator. + * + * Once freed, the allocation becomes available immediately for reuse within the \p active_stream + * with which it was associated with during allocation, and it becomes available for reuse within other + * streams when all prior work submitted to \p active_stream has completed. + */ + cudaError_t DeviceFree( + void* d_ptr) + { + #if (CUB_PTX_ARCH > 0) + // Caching functionality only defined on host + return CubDebug(cudaErrorInvalidConfiguration); + #else + return DeviceFree(INVALID_DEVICE_ORDINAL, d_ptr); + #endif // CUB_PTX_ARCH + } + + + /** + * \brief Frees all cached device allocations on all devices + */ + cudaError_t FreeAllCached() + { + #if (CUB_PTX_ARCH > 0) + // Caching functionality only defined on host + return CubDebug(cudaErrorInvalidConfiguration); + #else + + cudaError_t error = cudaSuccess; + int entrypoint_device = INVALID_DEVICE_ORDINAL; + int current_device = INVALID_DEVICE_ORDINAL; + + Lock(&spin_lock); + + while (!cached_blocks.empty()) + { + // Get first block + CachedBlocks::iterator begin = cached_blocks.begin(); + + // Get entry-point device ordinal if necessary + if (entrypoint_device == INVALID_DEVICE_ORDINAL) + { + if (CubDebug(error = cudaGetDevice(&entrypoint_device))) break; + } + + // Set current device ordinal if necessary + if (begin->device != current_device) + { + if (CubDebug(error = cudaSetDevice(begin->device))) break; + current_device = begin->device; + } + + // Free device memory + if (CubDebug(error = cudaFree(begin->d_ptr))) break; + if (CubDebug(error = cudaEventDestroy(begin->ready_event))) break; + + // Reduce balance and erase entry + cached_bytes[current_device].free -= begin->bytes; + cached_blocks.erase(begin); + + if (debug) CubLog("\tdevice %d freed %lld bytes.\n\t\t %lld available blocks cached (%lld bytes), %lld live blocks (%lld bytes) outstanding.\n", + current_device, (long long) begin->bytes, (long long) cached_blocks.size(), (long long) cached_bytes[current_device].free, (long long) live_blocks.size(), (long long) cached_bytes[current_device].free); + } + + Unlock(&spin_lock); + + // Attempt to revert back to entry-point device if necessary + if (entrypoint_device != INVALID_DEVICE_ORDINAL) + { + if (CubDebug(error = cudaSetDevice(entrypoint_device))) return error; + } + + return error; + + #endif // CUB_PTX_ARCH + } + + + /** + * \brief Destructor + */ + virtual ~CachingDeviceAllocator() + { + if (!skip_cleanup) + FreeAllCached(); + } + +}; + + + + +/** @} */ // end group UtilMgmt + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/util_arch.cuh b/3rdparty/cub/cub/util_arch.cuh new file mode 100644 index 00000000000..3ca95e19b18 --- /dev/null +++ b/3rdparty/cub/cub/util_arch.cuh @@ -0,0 +1,198 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Static architectural properties by SM version. + */ + +#pragma once + +#include "util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup UtilMgmt + * @{ + */ + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +/// CUB_PTX_ARCH reflects the PTX version targeted by the active compiler pass (or zero during the host pass). +#ifndef __CUDA_ARCH__ + #define CUB_PTX_ARCH 0 +#else + #define CUB_PTX_ARCH __CUDA_ARCH__ +#endif + +/// Whether or not the source targeted by the active compiler pass is allowed to invoke device kernels or methods from the CUDA runtime API. +#if !defined(__CUDA_ARCH__) || (__CUDA_ARCH__>= 350 && defined(__CUDACC_RDC__)) + #define CUB_RUNTIME_ENABLED + #define CUB_RUNTIME_FUNCTION __host__ __device__ +#else + #define CUB_RUNTIME_FUNCTION __host__ +#endif + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + +/// Number of threads per warp (log) +#define CUB_LOG_WARP_THREADS(arch) \ + (5) + +/// Number of threads per warp +#define CUB_WARP_THREADS(arch) \ + (1 << CUB_LOG_WARP_THREADS(arch)) + +/// Number of smem banks (log) +#define CUB_LOG_SMEM_BANKS(arch) \ + ((arch >= 200) ? \ + (5) : \ + (4)) + +/// Number of smem banks +#define CUB_SMEM_BANKS(arch) \ + (1 << CUB_LOG_SMEM_BANKS(arch)) + +/// Number of bytes per smem bank +#define CUB_SMEM_BANK_BYTES(arch) \ + (4) + +/// Number of smem bytes provisioned per SM +#define CUB_SMEM_BYTES(arch) \ + ((arch >= 200) ? \ + (48 * 1024) : \ + (16 * 1024)) + +/// Smem allocation size in bytes +#define CUB_SMEM_ALLOC_UNIT(arch) \ + ((arch >= 300) ? \ + (256) : \ + ((arch >= 200) ? \ + (128) : \ + (512))) + +/// Whether or not the architecture allocates registers by block (or by warp) +#define CUB_REGS_BY_BLOCK(arch) \ + ((arch >= 200) ? \ + (false) : \ + (true)) + +/// Number of registers allocated at a time per block (or by warp) +#define CUB_REG_ALLOC_UNIT(arch) \ + ((arch >= 300) ? \ + (256) : \ + ((arch >= 200) ? \ + (64) : \ + ((arch >= 120) ? \ + (512) : \ + (256)))) + +/// Granularity of warps for which registers are allocated +#define CUB_WARP_ALLOC_UNIT(arch) \ + ((arch >= 300) ? \ + (4) : \ + (2)) + +/// Maximum number of threads per SM +#define CUB_MAX_SM_THREADS(arch) \ + ((arch >= 300) ? \ + (2048) : \ + ((arch >= 200) ? \ + (1536) : \ + ((arch >= 120) ? \ + (1024) : \ + (768)))) + +/// Maximum number of thread blocks per SM +#define CUB_MAX_SM_BLOCKS(arch) \ + ((arch >= 300) ? \ + (16) : \ + (8)) + +/// Maximum number of threads per thread block +#define CUB_MAX_BLOCK_THREADS(arch) \ + ((arch >= 200) ? \ + (1024) : \ + (512)) + +/// Maximum number of registers per SM +#define CUB_MAX_SM_REGISTERS(arch) \ + ((arch >= 300) ? \ + (64 * 1024) : \ + ((arch >= 200) ? \ + (32 * 1024) : \ + ((arch >= 120) ? \ + (16 * 1024) : \ + (8 * 1024)))) + +/// Oversubscription factor +#define CUB_SUBSCRIPTION_FACTOR(arch) \ + ((arch >= 300) ? \ + (5) : \ + ((arch >= 200) ? \ + (3) : \ + (10))) + +/// Prefer padding overhead vs X-way conflicts greater than this threshold +#define CUB_PREFER_CONFLICT_OVER_PADDING(arch) \ + ((arch >= 300) ? \ + (1) : \ + (4)) + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +#define CUB_PTX_LOG_WARP_THREADS CUB_LOG_WARP_THREADS(CUB_PTX_ARCH) +#define CUB_PTX_WARP_THREADS CUB_WARP_THREADS(CUB_PTX_ARCH) +#define CUB_PTX_LOG_SMEM_BANKS CUB_LOG_SMEM_BANKS(CUB_PTX_ARCH) +#define CUB_PTX_SMEM_BANKS CUB_SMEM_BANKS(CUB_PTX_ARCH) +#define CUB_PTX_SMEM_BANK_BYTES CUB_SMEM_BANK_BYTES(CUB_PTX_ARCH) +#define CUB_PTX_SMEM_BYTES CUB_SMEM_BYTES(CUB_PTX_ARCH) +#define CUB_PTX_SMEM_ALLOC_UNIT CUB_SMEM_ALLOC_UNIT(CUB_PTX_ARCH) +#define CUB_PTX_REGS_BY_BLOCK CUB_REGS_BY_BLOCK(CUB_PTX_ARCH) +#define CUB_PTX_REG_ALLOC_UNIT CUB_REG_ALLOC_UNIT(CUB_PTX_ARCH) +#define CUB_PTX_WARP_ALLOC_UNIT CUB_WARP_ALLOC_UNIT(CUB_PTX_ARCH) +#define CUB_PTX_MAX_SM_THREADS CUB_MAX_SM_THREADS(CUB_PTX_ARCH) +#define CUB_PTX_MAX_SM_BLOCKS CUB_MAX_SM_BLOCKS(CUB_PTX_ARCH) +#define CUB_PTX_MAX_BLOCK_THREADS CUB_MAX_BLOCK_THREADS(CUB_PTX_ARCH) +#define CUB_PTX_MAX_SM_REGISTERS CUB_MAX_SM_REGISTERS(CUB_PTX_ARCH) +#define CUB_PTX_PREFER_CONFLICT_OVER_PADDING CUB_PREFER_CONFLICT_OVER_PADDING(CUB_PTX_ARCH) + +#endif // Do not document + + +/** @} */ // end group UtilMgmt + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/util_debug.cuh b/3rdparty/cub/cub/util_debug.cuh new file mode 100644 index 00000000000..155ca512519 --- /dev/null +++ b/3rdparty/cub/cub/util_debug.cuh @@ -0,0 +1,121 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Error and event logging routines. + * + * The following macros definitions are supported: + * - \p CUB_LOG. Simple event messages are printed to \p stdout. + */ + +#pragma once + +#include +#include "util_namespace.cuh" +#include "util_arch.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup UtilMgmt + * @{ + */ + + +/// CUB error reporting macro (prints error messages to stderr) +#if (defined(DEBUG) || defined(_DEBUG)) && !defined(CUB_STDERR) + #define CUB_STDERR +#endif + + + +/** + * \brief %If \p CUB_STDERR is defined and \p error is not \p cudaSuccess, the corresponding error message is printed to \p stderr (or \p stdout in device code) along with the supplied source context. + * + * \return The CUDA error. + */ +__host__ __device__ __forceinline__ cudaError_t Debug( + cudaError_t error, + const char* filename, + int line) +{ +#ifdef CUB_STDERR + if (error) + { + #if (CUB_PTX_ARCH == 0) + fprintf(stderr, "CUDA error %d [%s, %d]: %s\n", error, filename, line, cudaGetErrorString(error)); + fflush(stderr); + #elif (CUB_PTX_ARCH >= 200) + printf("CUDA error %d [block (%d,%d,%d) thread (%d,%d,%d), %s, %d]\n", error, blockIdx.z, blockIdx.y, blockIdx.x, threadIdx.z, threadIdx.y, threadIdx.x, filename, line); + #endif + } +#endif + return error; +} + + +/** + * \brief Debug macro + */ +#ifndef CubDebug + #define CubDebug(e) cub::Debug((e), __FILE__, __LINE__) +#endif + + +/** + * \brief Debug macro with exit + */ +#ifndef CubDebugExit + #define CubDebugExit(e) if (cub::Debug((e), __FILE__, __LINE__)) { exit(1); } +#endif + + +/** + * \brief Log macro for printf statements. + */ +#if !defined(CubLog) + #if (CUB_PTX_ARCH == 0) + #define CubLog(format, ...) printf(format,__VA_ARGS__); + #elif (CUB_PTX_ARCH >= 200) + #define CubLog(format, ...) printf("[block (%d,%d,%d), thread (%d,%d,%d)]: " format, blockIdx.z, blockIdx.y, blockIdx.x, threadIdx.z, threadIdx.y, threadIdx.x, __VA_ARGS__); + #endif +#endif + + + + +/** @} */ // end group UtilMgmt + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/util_device.cuh b/3rdparty/cub/cub/util_device.cuh new file mode 100644 index 00000000000..0c3ae82b9c4 --- /dev/null +++ b/3rdparty/cub/cub/util_device.cuh @@ -0,0 +1,378 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Properties of a given CUDA device and the corresponding PTX bundle + */ + +#pragma once + +#include "util_arch.cuh" +#include "util_debug.cuh" +#include "util_namespace.cuh" +#include "util_macro.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup UtilMgmt + * @{ + */ + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + +/** + * Empty kernel for querying PTX manifest metadata (e.g., version) for the current device + */ +template +__global__ void EmptyKernel(void) { } + + +/** + * Alias temporaries to externally-allocated device storage (or simply return the amount of storage needed). + */ +template +CUB_RUNTIME_FUNCTION __forceinline__ +cudaError_t AliasTemporaries( + void *d_temp_storage, ///< [in] %Device allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done. + size_t &temp_storage_bytes, ///< [in,out] Size in bytes of \t d_temp_storage allocation + void* (&allocations)[ALLOCATIONS], ///< [in,out] Pointers to device allocations needed + size_t (&allocation_sizes)[ALLOCATIONS]) ///< [in] Sizes in bytes of device allocations needed +{ + const int ALIGN_BYTES = 256; + const int ALIGN_MASK = ~(ALIGN_BYTES - 1); + + // Compute exclusive prefix sum over allocation requests + size_t allocation_offsets[ALLOCATIONS]; + size_t bytes_needed = 0; + for (int i = 0; i < ALLOCATIONS; ++i) + { + size_t allocation_bytes = (allocation_sizes[i] + ALIGN_BYTES - 1) & ALIGN_MASK; + allocation_offsets[i] = bytes_needed; + bytes_needed += allocation_bytes; + } + + // Check if the caller is simply requesting the size of the storage allocation + if (!d_temp_storage) + { + temp_storage_bytes = bytes_needed; + return cudaSuccess; + } + + // Check if enough storage provided + if (temp_storage_bytes < bytes_needed) + { + return CubDebug(cudaErrorInvalidValue); + } + + // Alias + for (int i = 0; i < ALLOCATIONS; ++i) + { + allocations[i] = static_cast(d_temp_storage) + allocation_offsets[i]; + } + + return cudaSuccess; +} + + + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + + +/** + * \brief Retrieves the PTX version that will be used on the current device (major * 100 + minor * 10) + */ +CUB_RUNTIME_FUNCTION __forceinline__ cudaError_t PtxVersion(int &ptx_version) +{ + struct Dummy + { + /// Type definition of the EmptyKernel kernel entry point + typedef void (*EmptyKernelPtr)(); + + /// Force EmptyKernel to be generated if this class is used + CUB_RUNTIME_FUNCTION __forceinline__ + EmptyKernelPtr Empty() + { + return EmptyKernel; + } + }; + + +#ifndef CUB_RUNTIME_ENABLED + + // CUDA API calls not supported from this device + return cudaErrorInvalidConfiguration; + +#elif (CUB_PTX_ARCH > 0) + + ptx_version = CUB_PTX_ARCH; + return cudaSuccess; + +#else + + cudaError_t error = cudaSuccess; + do + { + cudaFuncAttributes empty_kernel_attrs; + if (CubDebug(error = cudaFuncGetAttributes(&empty_kernel_attrs, EmptyKernel))) break; + ptx_version = empty_kernel_attrs.ptxVersion * 10; + } + while (0); + + return error; + +#endif +} + + +/** + * \brief Retrieves the SM version (major * 100 + minor * 10) + */ +CUB_RUNTIME_FUNCTION __forceinline__ cudaError_t SmVersion(int &sm_version, int device_ordinal) +{ +#ifndef CUB_RUNTIME_ENABLED + + // CUDA API calls not supported from this device + return cudaErrorInvalidConfiguration; + +#else + + cudaError_t error = cudaSuccess; + do + { + // Fill in SM version + int major, minor; + if (CubDebug(error = cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, device_ordinal))) break; + if (CubDebug(error = cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, device_ordinal))) break; + sm_version = major * 100 + minor * 10; + } + while (0); + + return error; + +#endif +} + + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +/** + * Synchronize the stream if specified + */ +CUB_RUNTIME_FUNCTION __forceinline__ +static cudaError_t SyncStream(cudaStream_t stream) +{ +#if (CUB_PTX_ARCH == 0) + return cudaStreamSynchronize(stream); +#else + // Device can't yet sync on a specific stream + return cudaDeviceSynchronize(); +#endif +} + + +/** + * \brief Computes maximum SM occupancy in thread blocks for the given kernel function pointer \p kernel_ptr. + */ +template +CUB_RUNTIME_FUNCTION __forceinline__ +cudaError_t MaxSmOccupancy( + int &max_sm_occupancy, ///< [out] maximum number of thread blocks that can reside on a single SM + int sm_version, ///< [in] The SM architecture to run on + KernelPtr kernel_ptr, ///< [in] Kernel pointer for which to compute SM occupancy + int block_threads) ///< [in] Number of threads per thread block +{ +#ifndef CUB_RUNTIME_ENABLED + + // CUDA API calls not supported from this device + return CubDebug(cudaErrorInvalidConfiguration); + +#else + + return cudaOccupancyMaxActiveBlocksPerMultiprocessor ( + &max_sm_occupancy, + kernel_ptr, + block_threads, + 0); +/* + cudaError_t error = cudaSuccess; + do + { + int warp_threads = 1 << CUB_LOG_WARP_THREADS(sm_version); + int max_sm_blocks = CUB_MAX_SM_BLOCKS(sm_version); + int max_sm_warps = CUB_MAX_SM_THREADS(sm_version) / warp_threads; + int regs_by_block = CUB_REGS_BY_BLOCK(sm_version); + int max_sm_registers = CUB_MAX_SM_REGISTERS(sm_version); + int warp_alloc_unit = CUB_WARP_ALLOC_UNIT(sm_version); + int smem_alloc_unit = CUB_SMEM_ALLOC_UNIT(sm_version); + int reg_alloc_unit = CUB_REG_ALLOC_UNIT(sm_version); + int smem_bytes = CUB_SMEM_BYTES(sm_version); + + // Get kernel attributes + cudaFuncAttributes kernel_attrs; + if (CubDebug(error = cudaFuncGetAttributes(&kernel_attrs, kernel_ptr))) break; + + // Number of warps per threadblock + int block_warps = (block_threads + warp_threads - 1) / warp_threads; + + // Max warp occupancy + int max_warp_occupancy = (block_warps > 0) ? + max_sm_warps / block_warps : + max_sm_blocks; + + // Maximum register occupancy + int max_reg_occupancy; + if ((block_threads == 0) || (kernel_attrs.numRegs == 0)) + { + // Prevent divide-by-zero + max_reg_occupancy = max_sm_blocks; + } + else if (regs_by_block) + { + // Allocates registers by threadblock + int block_regs = CUB_ROUND_UP_NEAREST(kernel_attrs.numRegs * warp_threads * block_warps, reg_alloc_unit); + max_reg_occupancy = max_sm_registers / block_regs; + } + else + { + // Allocates registers by warp + int sm_sides = warp_alloc_unit; + int sm_registers_per_side = max_sm_registers / sm_sides; + int regs_per_warp = CUB_ROUND_UP_NEAREST(kernel_attrs.numRegs * warp_threads, reg_alloc_unit); + int warps_per_side = sm_registers_per_side / regs_per_warp; + int warps = warps_per_side * sm_sides; + max_reg_occupancy = warps / block_warps; + } + + // Shared memory per threadblock + int block_allocated_smem = CUB_ROUND_UP_NEAREST( + (int) kernel_attrs.sharedSizeBytes, + smem_alloc_unit); + + // Max shared memory occupancy + int max_smem_occupancy = (block_allocated_smem > 0) ? + (smem_bytes / block_allocated_smem) : + max_sm_blocks; + + // Max occupancy + max_sm_occupancy = CUB_MIN( + CUB_MIN(max_sm_blocks, max_warp_occupancy), + CUB_MIN(max_smem_occupancy, max_reg_occupancy)); + +// printf("max_smem_occupancy(%d), max_warp_occupancy(%d), max_reg_occupancy(%d) \n", max_smem_occupancy, max_warp_occupancy, max_reg_occupancy); + + } while (0); + + return error; +*/ +#endif // CUB_RUNTIME_ENABLED +} + +#endif // Do not document + + +/** + * \brief Computes maximum SM occupancy in thread blocks for executing the given kernel function pointer \p kernel_ptr on the current device with \p block_threads per thread block. + * + * \par Snippet + * The code snippet below illustrates the use of the MaxSmOccupancy function. + * \par + * \code + * #include // or equivalently + * + * template + * __global__ void ExampleKernel() + * { + * // Allocate shared memory for BlockScan + * __shared__ volatile T buffer[4096]; + * + * ... + * } + * + * ... + * + * // Determine SM occupancy for ExampleKernel specialized for unsigned char + * int max_sm_occupancy; + * MaxSmOccupancy(max_sm_occupancy, ExampleKernel, 64); + * + * // max_sm_occupancy <-- 4 on SM10 + * // max_sm_occupancy <-- 8 on SM20 + * // max_sm_occupancy <-- 12 on SM35 + * + * \endcode + * + */ +template +CUB_RUNTIME_FUNCTION __forceinline__ +cudaError_t MaxSmOccupancy( + int &max_sm_occupancy, ///< [out] maximum number of thread blocks that can reside on a single SM + KernelPtr kernel_ptr, ///< [in] Kernel pointer for which to compute SM occupancy + int block_threads) ///< [in] Number of threads per thread block +{ +#ifndef CUB_RUNTIME_ENABLED + + // CUDA API calls not supported from this device + return CubDebug(cudaErrorInvalidConfiguration); + +#else + + cudaError_t error = cudaSuccess; + do + { + // Get device ordinal + int device_ordinal; + if (CubDebug(error = cudaGetDevice(&device_ordinal))) break; + + // Get device SM version + int sm_version; + if (CubDebug(error = SmVersion(sm_version, device_ordinal))) break; + + // Get SM occupancy + if (CubDebug(error = MaxSmOccupancy(max_sm_occupancy, sm_version, kernel_ptr, block_threads))) break; + + } while (0); + + return error; + +#endif // CUB_RUNTIME_ENABLED + +} + + +/** @} */ // end group UtilMgmt + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/util_macro.cuh b/3rdparty/cub/cub/util_macro.cuh new file mode 100644 index 00000000000..4eb79b42a80 --- /dev/null +++ b/3rdparty/cub/cub/util_macro.cuh @@ -0,0 +1,107 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/****************************************************************************** + * Common C/C++ macro utilities + ******************************************************************************/ + +#pragma once + +#include "util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup UtilModule + * @{ + */ + +/** + * Align struct + */ +#if defined(_WIN32) || defined(_WIN64) + #define CUB_ALIGN(bytes) __declspec(align(32)) +#else + #define CUB_ALIGN(bytes) __attribute__((aligned(bytes))) +#endif + +/** + * Select maximum(a, b) + */ +#define CUB_MAX(a, b) (((b) > (a)) ? (b) : (a)) + +/** + * Select minimum(a, b) + */ +#define CUB_MIN(a, b) (((b) < (a)) ? (b) : (a)) + +/** + * Quotient of x/y rounded down to nearest integer + */ +#define CUB_QUOTIENT_FLOOR(x, y) ((x) / (y)) + +/** + * Quotient of x/y rounded up to nearest integer + */ +#define CUB_QUOTIENT_CEILING(x, y) (((x) + (y) - 1) / (y)) + +/** + * x rounded up to the nearest multiple of y + */ +#define CUB_ROUND_UP_NEAREST(x, y) ((((x) + (y) - 1) / (y)) * y) + +/** + * x rounded down to the nearest multiple of y + */ +#define CUB_ROUND_DOWN_NEAREST(x, y) (((x) / (y)) * y) + +/** + * Return character string for given type + */ +#define CUB_TYPE_STRING(type) ""#type + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + #define CUB_CAT_(a, b) a ## b + #define CUB_CAT(a, b) CUB_CAT_(a, b) +#endif // DOXYGEN_SHOULD_SKIP_THIS + +/** + * Static assert + */ +#define CUB_STATIC_ASSERT(cond, msg) typedef int CUB_CAT(cub_static_assert, __LINE__)[(cond) ? 1 : -1] + + +/** @} */ // end group UtilModule + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/util_namespace.cuh b/3rdparty/cub/cub/util_namespace.cuh new file mode 100644 index 00000000000..e7b4454fe3d --- /dev/null +++ b/3rdparty/cub/cub/util_namespace.cuh @@ -0,0 +1,41 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Place-holder for prefixing the cub namespace + */ + +#pragma once + +// For example: +//#define CUB_NS_PREFIX namespace thrust{ namespace detail { +//#define CUB_NS_POSTFIX } } + +#define CUB_NS_PREFIX +#define CUB_NS_POSTFIX diff --git a/3rdparty/cub/cub/util_ptx.cuh b/3rdparty/cub/cub/util_ptx.cuh new file mode 100644 index 00000000000..69ac0a60b93 --- /dev/null +++ b/3rdparty/cub/cub/util_ptx.cuh @@ -0,0 +1,727 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * PTX intrinsics + */ + + +#pragma once + +#include "util_type.cuh" +#include "util_arch.cuh" +#include "util_namespace.cuh" +#include "util_debug.cuh" + + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup UtilPtx + * @{ + */ + + +/****************************************************************************** + * PTX helper macros + ******************************************************************************/ + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +/** + * Register modifier for pointer-types (for inlining PTX assembly) + */ +#if defined(_WIN64) || defined(__LP64__) + #define __CUB_LP64__ 1 + // 64-bit register modifier for inlined asm + #define _CUB_ASM_PTR_ "l" + #define _CUB_ASM_PTR_SIZE_ "u64" +#else + #define __CUB_LP64__ 0 + // 32-bit register modifier for inlined asm + #define _CUB_ASM_PTR_ "r" + #define _CUB_ASM_PTR_SIZE_ "u32" +#endif + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + +/****************************************************************************** + * Inlined PTX intrinsics + ******************************************************************************/ + +/** + * \brief Shift-right then add. Returns (\p x >> \p shift) + \p addend. + */ +__device__ __forceinline__ unsigned int SHR_ADD( + unsigned int x, + unsigned int shift, + unsigned int addend) +{ + unsigned int ret; +#if CUB_PTX_ARCH >= 200 + asm volatile("vshr.u32.u32.u32.clamp.add %0, %1, %2, %3;" : + "=r"(ret) : "r"(x), "r"(shift), "r"(addend)); +#else + ret = (x >> shift) + addend; +#endif + return ret; +} + + +/** + * \brief Shift-left then add. Returns (\p x << \p shift) + \p addend. + */ +__device__ __forceinline__ unsigned int SHL_ADD( + unsigned int x, + unsigned int shift, + unsigned int addend) +{ + unsigned int ret; +#if CUB_PTX_ARCH >= 200 + asm volatile("vshl.u32.u32.u32.clamp.add %0, %1, %2, %3;" : + "=r"(ret) : "r"(x), "r"(shift), "r"(addend)); +#else + ret = (x << shift) + addend; +#endif + return ret; +} + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +/** + * Bitfield-extract. + */ +template +__device__ __forceinline__ unsigned int BFE( + UnsignedBits source, + unsigned int bit_start, + unsigned int num_bits, + Int2Type byte_len) +{ + unsigned int bits; +#if CUB_PTX_ARCH >= 200 + asm volatile("bfe.u32 %0, %1, %2, %3;" : "=r"(bits) : "r"((unsigned int) source), "r"(bit_start), "r"(num_bits)); +#else + const unsigned int MASK = (1 << num_bits) - 1; + bits = (source >> bit_start) & MASK; +#endif + return bits; +} + + +/** + * Bitfield-extract for 64-bit types. + */ +template +__device__ __forceinline__ unsigned int BFE( + UnsignedBits source, + unsigned int bit_start, + unsigned int num_bits, + Int2Type<8> byte_len) +{ + const unsigned long long MASK = (1ull << num_bits) - 1; + return (source >> bit_start) & MASK; +} + +#endif // DOXYGEN_SHOULD_SKIP_THIS + +/** + * \brief Bitfield-extract. Extracts \p num_bits from \p source starting at bit-offset \p bit_start. The input \p source may be an 8b, 16b, 32b, or 64b unsigned integer type. + */ +template +__device__ __forceinline__ unsigned int BFE( + UnsignedBits source, + unsigned int bit_start, + unsigned int num_bits) +{ + return BFE(source, bit_start, num_bits, Int2Type()); +} + + +/** + * \brief Bitfield insert. Inserts the \p num_bits least significant bits of \p y into \p x at bit-offset \p bit_start. + */ +__device__ __forceinline__ void BFI( + unsigned int &ret, + unsigned int x, + unsigned int y, + unsigned int bit_start, + unsigned int num_bits) +{ +#if CUB_PTX_ARCH >= 200 + asm volatile("bfi.b32 %0, %1, %2, %3, %4;" : + "=r"(ret) : "r"(y), "r"(x), "r"(bit_start), "r"(num_bits)); +#else + x <<= bit_start; + unsigned int MASK_X = ((1 << num_bits) - 1) << bit_start; + unsigned int MASK_Y = ~MASK_X; + ret = (y & MASK_Y) | (x & MASK_X); +#endif +} + + +/** + * \brief Three-operand add. Returns \p x + \p y + \p z. + */ +__device__ __forceinline__ unsigned int IADD3(unsigned int x, unsigned int y, unsigned int z) +{ +#if CUB_PTX_ARCH >= 200 + asm volatile("vadd.u32.u32.u32.add %0, %1, %2, %3;" : "=r"(x) : "r"(x), "r"(y), "r"(z)); +#else + x = x + y + z; +#endif + return x; +} + + +/** + * \brief Byte-permute. Pick four arbitrary bytes from two 32-bit registers, and reassemble them into a 32-bit destination register. For SM2.0 or later. + * + * \par + * The bytes in the two source registers \p a and \p b are numbered from 0 to 7: + * {\p b, \p a} = {{b7, b6, b5, b4}, {b3, b2, b1, b0}}. For each of the four bytes + * {b3, b2, b1, b0} selected in the return value, a 4-bit selector is defined within + * the four lower "nibbles" of \p index: {\p index } = {n7, n6, n5, n4, n3, n2, n1, n0} + * + * \par Snippet + * The code snippet below illustrates byte-permute. + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * int a = 0x03020100; + * int b = 0x07060504; + * int index = 0x00007531; + * + * int selected = PRMT(a, b, index); // 0x07050301 + * + * \endcode + * + */ +__device__ __forceinline__ int PRMT(unsigned int a, unsigned int b, unsigned int index) +{ + int ret; + asm volatile("prmt.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(a), "r"(b), "r"(index)); + return ret; +} + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +/** + * Sync-threads barrier. + */ +__device__ __forceinline__ void BAR(int count) +{ + asm volatile("bar.sync 1, %0;" : : "r"(count)); +} + + +/** + * Floating point multiply. (Mantissa LSB rounds towards zero.) + */ +__device__ __forceinline__ float FMUL_RZ(float a, float b) +{ + float d; + asm volatile("mul.rz.f32 %0, %1, %2;" : "=f"(d) : "f"(a), "f"(b)); + return d; +} + + +/** + * Floating point multiply-add. (Mantissa LSB rounds towards zero.) + */ +__device__ __forceinline__ float FFMA_RZ(float a, float b, float c) +{ + float d; + asm volatile("fma.rz.f32 %0, %1, %2, %3;" : "=f"(d) : "f"(a), "f"(b), "f"(c)); + return d; +} + +#endif // DOXYGEN_SHOULD_SKIP_THIS + +/** + * \brief Terminates the calling thread + */ +__device__ __forceinline__ void ThreadExit() { + asm volatile("exit;"); +} + + +/** + * \brief Returns the row-major linear thread identifier for a multidimensional threadblock + */ +__device__ __forceinline__ int RowMajorTid(int block_dim_x, int block_dim_y, int block_dim_z) +{ + return ((block_dim_z == 1) ? 0 : (threadIdx.z * block_dim_x * block_dim_y)) + + ((block_dim_y == 1) ? 0 : (threadIdx.y * block_dim_x)) + + threadIdx.x; +} + + +/** + * \brief Returns the warp lane ID of the calling thread + */ +__device__ __forceinline__ unsigned int LaneId() +{ + unsigned int ret; + asm volatile("mov.u32 %0, %laneid;" : "=r"(ret) ); + return ret; +} + + +/** + * \brief Returns the warp ID of the calling thread. Warp ID is guaranteed to be unique among warps, but may not correspond to a zero-based ranking within the thread block. + */ +__device__ __forceinline__ unsigned int WarpId() +{ + unsigned int ret; + asm volatile("mov.u32 %0, %warpid;" : "=r"(ret) ); + return ret; +} + +/** + * \brief Returns the warp lane mask of all lanes less than the calling thread + */ +__device__ __forceinline__ unsigned int LaneMaskLt() +{ + unsigned int ret; + asm volatile("mov.u32 %0, %lanemask_lt;" : "=r"(ret) ); + return ret; +} + +/** + * \brief Returns the warp lane mask of all lanes less than or equal to the calling thread + */ +__device__ __forceinline__ unsigned int LaneMaskLe() +{ + unsigned int ret; + asm volatile("mov.u32 %0, %lanemask_le;" : "=r"(ret) ); + return ret; +} + +/** + * \brief Returns the warp lane mask of all lanes greater than the calling thread + */ +__device__ __forceinline__ unsigned int LaneMaskGt() +{ + unsigned int ret; + asm volatile("mov.u32 %0, %lanemask_gt;" : "=r"(ret) ); + return ret; +} + +/** + * \brief Returns the warp lane mask of all lanes greater than or equal to the calling thread + */ +__device__ __forceinline__ unsigned int LaneMaskGe() +{ + unsigned int ret; + asm volatile("mov.u32 %0, %lanemask_ge;" : "=r"(ret) ); + return ret; +} + +/** @} */ // end group UtilPtx + + + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + +/** + * Shuffle word up + */ +template +__device__ __forceinline__ void ShuffleUp( + ShuffleWordT* input, + ShuffleWordT* output, + int src_offset, + int first_lane, + Int2Type step) +{ + unsigned int word = input[STEP]; + asm volatile("shfl.up.b32 %0, %1, %2, %3;" + : "=r"(word) : "r"(word), "r"(src_offset), "r"(first_lane)); + output[STEP] = (ShuffleWordT) word; + + ShuffleUp(input, output, src_offset, first_lane, Int2Type()); +} + + +/** + * Shuffle word up + */ +template +__device__ __forceinline__ void ShuffleUp( + ShuffleWordT* input, + ShuffleWordT* output, + int src_offset, + int first_lane, + Int2Type<-1> step) +{} + + + +/** + * Shuffle word down + */ +template +__device__ __forceinline__ void ShuffleDown( + ShuffleWordT* input, + ShuffleWordT* output, + int src_offset, + int last_lane, + Int2Type step) +{ + unsigned int word = input[STEP]; + asm volatile("shfl.down.b32 %0, %1, %2, %3;" + : "=r"(word) : "r"(word), "r"(src_offset), "r"(last_lane)); + output[STEP] = (ShuffleWordT) word; + + ShuffleDown(input, output, src_offset, last_lane, Int2Type()); +} + + +/** + * Shuffle word down + */ +template +__device__ __forceinline__ void ShuffleDown( + ShuffleWordT* input, + ShuffleWordT* output, + int src_offset, + int last_lane, + Int2Type<-1> step) +{} + + +/** + * Shuffle index + */ +template +__device__ __forceinline__ void ShuffleIdx( + ShuffleWordT* input, + ShuffleWordT* output, + int src_lane, + int last_lane, + Int2Type step) +{ + unsigned int word = input[STEP]; + asm volatile("shfl.idx.b32 %0, %1, %2, %3;" + : "=r"(word) : "r"(word), "r"(src_lane), "r"(last_lane)); + output[STEP] = (ShuffleWordT) word; + + ShuffleIdx(input, output, src_lane, last_lane, Int2Type()); +} + + +/** + * Shuffle index + */ +template +__device__ __forceinline__ void ShuffleIdx( + ShuffleWordT* input, + ShuffleWordT* output, + int src_lane, + int last_lane, + Int2Type<-1> step) +{} + + + + +#endif // DOXYGEN_SHOULD_SKIP_THIS // Do not document + + + +/** + * \brief Shuffle-up for any data type. Each warp-lanei obtains the value \p input contributed by warp-lanei-src_offset. For thread lanes \e i < src_offset, the thread's own \p input is returned to the thread. ![](shfl_up_logo.png) + * \ingroup WarpModule + * + * \par + * - Available only for SM3.0 or newer + * + * \par Snippet + * The code snippet below illustrates each thread obtaining a \p double value from the + * predecessor of its predecessor. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Obtain one input item per thread + * double thread_data = ... + * + * // Obtain item from two ranks below + * double peer_data = ShuffleUp(thread_data, 2); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the first warp of threads is {1.0, 2.0, 3.0, 4.0, 5.0, ..., 32.0}. + * The corresponding output \p peer_data will be {1.0, 2.0, 1.0, 2.0, 3.0, ..., 30.0}. + * + */ +template +__device__ __forceinline__ T ShuffleUp( + T input, ///< [in] The value to broadcast + int src_offset, ///< [in] The relative down-offset of the peer to read from + int first_lane = 0) ///< [in] Index of first lane in segment +{ + typedef typename UnitWord::ShuffleWord ShuffleWord; + + const int WORDS = (sizeof(T) + sizeof(ShuffleWord) - 1) / sizeof(ShuffleWord); + + T output; + ShuffleWord *output_alias = reinterpret_cast(&output); + ShuffleWord *input_alias = reinterpret_cast(&input); + + unsigned int shuffle_word; + asm volatile("shfl.up.b32 %0, %1, %2, %3;" + : "=r"(shuffle_word) : "r"((unsigned int) input_alias[0]), "r"(src_offset), "r"(first_lane)); + output_alias[0] = shuffle_word; + + #pragma unroll + for (int WORD = 1; WORD < WORDS; ++WORD) + { + asm volatile("shfl.up.b32 %0, %1, %2, %3;" + : "=r"(shuffle_word) : "r"((unsigned int) input_alias[WORD]), "r"(src_offset), "r"(first_lane)); + output_alias[WORD] = shuffle_word; + } + +// ShuffleUp(input_alias, output_alias, src_offset, first_lane, Int2Type()); + + return output; +} + + +/** + * \brief Shuffle-down for any data type. Each warp-lanei obtains the value \p input contributed by warp-lanei+src_offset. For thread lanes \e i >= WARP_THREADS, the thread's own \p input is returned to the thread. ![](shfl_down_logo.png) + * \ingroup WarpModule + * + * \par + * - Available only for SM3.0 or newer + * + * \par Snippet + * The code snippet below illustrates each thread obtaining a \p double value from the + * successor of its successor. + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Obtain one input item per thread + * double thread_data = ... + * + * // Obtain item from two ranks below + * double peer_data = ShuffleDown(thread_data, 2); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the first warp of threads is {1.0, 2.0, 3.0, 4.0, 5.0, ..., 32.0}. + * The corresponding output \p peer_data will be {3.0, 4.0, 5.0, 6.0, 7.0, ..., 32.0}. + * + */ +template +__device__ __forceinline__ T ShuffleDown( + T input, ///< [in] The value to broadcast + int src_offset, ///< [in] The relative up-offset of the peer to read from + int last_lane = CUB_PTX_WARP_THREADS - 1) ///< [in] Index of first lane in segment +{ + typedef typename UnitWord::ShuffleWord ShuffleWord; + + const int WORDS = (sizeof(T) + sizeof(ShuffleWord) - 1) / sizeof(ShuffleWord); + + T output; + ShuffleWord *output_alias = reinterpret_cast(&output); + ShuffleWord *input_alias = reinterpret_cast(&input); + + unsigned int shuffle_word; + asm volatile("shfl.down.b32 %0, %1, %2, %3;" + : "=r"(shuffle_word) : "r"((unsigned int) input_alias[0]), "r"(src_offset), "r"(last_lane)); + output_alias[0] = shuffle_word; + + #pragma unroll + for (int WORD = 1; WORD < WORDS; ++WORD) + { + asm volatile("shfl.down.b32 %0, %1, %2, %3;" + : "=r"(shuffle_word) : "r"((unsigned int) input_alias[WORD]), "r"(src_offset), "r"(last_lane)); + output_alias[WORD] = shuffle_word; + } + +// ShuffleDown(input_alias, output_alias, src_offset, last_lane, Int2Type()); + + return output; +} + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +/** + * \brief Shuffle-index for any data type. Each warp-lanei obtains the value \p input contributed by warp-lanesrc_lane. For \p src_lane < 0 or \p src_lane >= WARP_THREADS, then the thread's own \p input is returned to the thread. ![](shfl_broadcast_logo.png) + * \ingroup WarpModule + * + * \par + * - Available only for SM3.0 or newer + */ +template +__device__ __forceinline__ T ShuffleIndex( + T input, ///< [in] The value to broadcast + int src_lane, ///< [in] Which warp lane is to do the broadcasting + int logical_warp_threads) ///< [in] Number of threads per logical warp +{ + typedef typename UnitWord::ShuffleWord ShuffleWord; + + const int WORDS = (sizeof(T) + sizeof(ShuffleWord) - 1) / sizeof(ShuffleWord); + + T output; + ShuffleWord *output_alias = reinterpret_cast(&output); + ShuffleWord *input_alias = reinterpret_cast(&input); + + unsigned int shuffle_word; + asm volatile("shfl.idx.b32 %0, %1, %2, %3;" + : "=r"(shuffle_word) : "r"((unsigned int) input_alias[0]), "r"(src_lane), "r"(logical_warp_threads - 1)); + output_alias[0] = shuffle_word; + + #pragma unroll + for (int WORD = 1; WORD < WORDS; ++WORD) + { + asm volatile("shfl.idx.b32 %0, %1, %2, %3;" + : "=r"(shuffle_word) : "r"((unsigned int) input_alias[WORD]), "r"(src_lane), "r"(logical_warp_threads - 1)); + output_alias[WORD] = shuffle_word; + } + +// ShuffleIdx(input_alias, output_alias, src_lane, logical_warp_threads - 1, Int2Type()); + + return output; +} + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + + /** + * \brief Shuffle-broadcast for any data type. Each warp-lanei obtains the value \p input contributed by warp-lanesrc_lane. For \p src_lane < 0 or \p src_lane >= WARP_THREADS, then the thread's own \p input is returned to the thread. ![](shfl_broadcast_logo.png) + * \ingroup WarpModule + * + * \par + * - Available only for SM3.0 or newer + * + * \par Snippet + * The code snippet below illustrates each thread obtaining a \p double value from warp-lane0. + * + * \par + * \code + * #include // or equivalently + * + * __global__ void ExampleKernel(...) + * { + * // Obtain one input item per thread + * double thread_data = ... + * + * // Obtain item from thread 0 + * double peer_data = ShuffleIndex(thread_data, 0); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the first warp of threads is {1.0, 2.0, 3.0, 4.0, 5.0, ..., 32.0}. + * The corresponding output \p peer_data will be {1.0, 1.0, 1.0, 1.0, 1.0, ..., 1.0}. + * + */ +template +__device__ __forceinline__ T ShuffleIndex( + T input, ///< [in] The value to broadcast + int src_lane) ///< [in] Which warp lane is to do the broadcasting +{ + return ShuffleIndex(input, src_lane, CUB_PTX_WARP_THREADS); +} + + + + + +/** + * \brief Portable implementation of __all + * \ingroup WarpModule + */ +__device__ __forceinline__ int WarpAll(int cond) +{ +#if CUB_PTX_ARCH < 120 + + __shared__ volatile int warp_signals[CUB_PTX_MAX_SM_THREADS / CUB_PTX_WARP_THREADS]; + + if (LaneId() == 0) + warp_signals[WarpId()] = 1; + + if (cond == 0) + warp_signals[WarpId()] = 0; + + return warp_signals[WarpId()]; + +#else + + return __all(cond); + +#endif +} + + +/** + * \brief Portable implementation of __any + * \ingroup WarpModule + */ +__device__ __forceinline__ int WarpAny(int cond) +{ +#if CUB_PTX_ARCH < 120 + + __shared__ volatile int warp_signals[CUB_PTX_MAX_SM_THREADS / CUB_PTX_WARP_THREADS]; + + if (LaneId() == 0) + warp_signals[WarpId()] = 0; + + if (cond) + warp_signals[WarpId()] = 1; + + return warp_signals[WarpId()]; + +#else + + return __any(cond); + +#endif +} + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/util_type.cuh b/3rdparty/cub/cub/util_type.cuh new file mode 100644 index 00000000000..75b2d3ff240 --- /dev/null +++ b/3rdparty/cub/cub/util_type.cuh @@ -0,0 +1,1011 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * Common type manipulation (metaprogramming) utilities + */ + +#pragma once + +#include +#include + +#include "util_macro.cuh" +#include "util_arch.cuh" +#include "util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup UtilModule + * @{ + */ + + + +/****************************************************************************** + * Type equality + ******************************************************************************/ + +/** + * \brief Type selection (IF ? ThenType : ElseType) + */ +template +struct If +{ + /// Conditional type result + typedef ThenType Type; // true +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +template +struct If +{ + typedef ElseType Type; // false +}; + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + + +/****************************************************************************** + * Conditional types + ******************************************************************************/ + +/** + * \brief Type equality test + */ +template +struct Equals +{ + enum { + VALUE = 0, + NEGATE = 1 + }; +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +template +struct Equals +{ + enum { + VALUE = 1, + NEGATE = 0 + }; +}; + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + +/****************************************************************************** + * Marker types + ******************************************************************************/ + +/** + * \brief A simple "NULL" marker type + */ +struct NullType +{ +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + template + __host__ __device__ __forceinline__ NullType& operator =(const T& b) { return *this; } + + __host__ __device__ __forceinline__ bool operator ==(const NullType& b) { return true; } + + __host__ __device__ __forceinline__ bool operator !=(const NullType& b) { return false; } + +#endif // DOXYGEN_SHOULD_SKIP_THIS +}; + + +/** + * \brief Allows for the treatment of an integral constant as a type at compile-time (e.g., to achieve static call dispatch based on constant integral values) + */ +template +struct Int2Type +{ + enum {VALUE = A}; +}; + + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + +/****************************************************************************** + * Size and alignment + ******************************************************************************/ + +/// Structure alignment +template +struct AlignBytes +{ + struct Pad + { + T val; + char byte; + }; + + enum + { + /// The alignment of T in bytes + ALIGN_BYTES = sizeof(Pad) - sizeof(T) + }; +}; + +// Specializations where host C++ compilers (e.g., Windows) may disagree with device C++ compilers (EDG) + +template <> struct AlignBytes { enum { ALIGN_BYTES = 8 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 8 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 8 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 8 }; }; +#ifdef _WIN32 + template <> struct AlignBytes { enum { ALIGN_BYTES = 8 }; }; + template <> struct AlignBytes { enum { ALIGN_BYTES = 8 }; }; +#endif +template <> struct AlignBytes { enum { ALIGN_BYTES = 8 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 8 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 8 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 8 }; }; + +template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; +#ifndef _WIN32 + template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; + template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; +#endif +template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; +template <> struct AlignBytes { enum { ALIGN_BYTES = 16 }; }; + + +/// Unit-words of data movement +template +struct UnitWord +{ + enum { + ALIGN_BYTES = AlignBytes::ALIGN_BYTES + }; + + template + struct IsMultiple + { + enum { + UNIT_ALIGN_BYTES = AlignBytes::ALIGN_BYTES, + IS_MULTIPLE = (sizeof(T) % sizeof(Unit) == 0) && (ALIGN_BYTES % UNIT_ALIGN_BYTES == 0) + }; + }; + + /// Biggest shuffle word that T is a whole multiple of and is not larger than the alignment of T + typedef typename If::IS_MULTIPLE, + unsigned int, + typename If::IS_MULTIPLE, + unsigned short, + unsigned char>::Type>::Type ShuffleWord; + + /// Biggest volatile word that T is a whole multiple of and is not larger than the alignment of T + typedef typename If::IS_MULTIPLE, + unsigned long long, + ShuffleWord>::Type VolatileWord; + + /// Biggest memory-access word that T is a whole multiple of and is not larger than the alignment of T + typedef typename If::IS_MULTIPLE, + ulonglong2, + VolatileWord>::Type DeviceWord; + + /// Biggest texture reference word that T is a whole multiple of and is not larger than the alignment of T + typedef typename If::IS_MULTIPLE, + uint4, + typename If::IS_MULTIPLE, + uint2, + ShuffleWord>::Type>::Type TextureWord; +}; + + +// float2 specialization workaround (for SM10-SM13) +template <> +struct UnitWord +{ + typedef int ShuffleWord; +#if (CUB_PTX_ARCH > 0) && (CUB_PTX_ARCH <= 130) + typedef float VolatileWord; + typedef uint2 DeviceWord; +#else + typedef unsigned long long VolatileWord; + typedef unsigned long long DeviceWord; +#endif + typedef float2 TextureWord; +}; + +// float4 specialization workaround (for SM10-SM13) +template <> +struct UnitWord +{ + typedef int ShuffleWord; +#if (CUB_PTX_ARCH > 0) && (CUB_PTX_ARCH <= 130) + typedef float VolatileWord; + typedef uint4 DeviceWord; +#else + typedef unsigned long long VolatileWord; + typedef ulonglong2 DeviceWord; +#endif + typedef float4 TextureWord; +}; + + +// char2 specialization workaround (for SM10-SM13) +template <> +struct UnitWord +{ + typedef unsigned short ShuffleWord; +#if (CUB_PTX_ARCH > 0) && (CUB_PTX_ARCH <= 130) + typedef unsigned short VolatileWord; + typedef short DeviceWord; +#else + typedef unsigned short VolatileWord; + typedef unsigned short DeviceWord; +#endif + typedef unsigned short TextureWord; +}; + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + + +/****************************************************************************** + * Vector type inference utilities. + ******************************************************************************/ + +/** + * \brief Exposes a member typedef \p Type that names the corresponding CUDA vector type if one exists. Otherwise \p Type refers to the CubVector structure itself, which will wrap the corresponding \p x, \p y, etc. vector fields. + */ +template struct CubVector; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +enum +{ + /// The maximum number of elements in CUDA vector types + MAX_VEC_ELEMENTS = 4, +}; + + +/** + * Generic vector-1 type + */ +template +struct CubVector +{ + T x; + + typedef T BaseType; + typedef CubVector Type; +}; + +/** + * Generic vector-2 type + */ +template +struct CubVector +{ + T x; + T y; + + typedef T BaseType; + typedef CubVector Type; +}; + +/** + * Generic vector-3 type + */ +template +struct CubVector +{ + T x; + T y; + T z; + + typedef T BaseType; + typedef CubVector Type; +}; + +/** + * Generic vector-4 type + */ +template +struct CubVector +{ + T x; + T y; + T z; + T w; + + typedef T BaseType; + typedef CubVector Type; +}; + + +/** + * Macro for expanding partially-specialized built-in vector types + */ +#define CUB_DEFINE_VECTOR_TYPE(base_type,short_type) \ + \ + template<> struct CubVector : short_type##1 \ + { \ + typedef base_type BaseType; \ + typedef short_type##1 Type; \ + __host__ __device__ __forceinline__ CubVector operator+(const CubVector &other) const { \ + CubVector retval; \ + retval.x = x + other.x; \ + return retval; \ + } \ + __host__ __device__ __forceinline__ CubVector operator-(const CubVector &other) const { \ + CubVector retval; \ + retval.x = x - other.x; \ + return retval; \ + } \ + }; \ + \ + template<> struct CubVector : short_type##2 \ + { \ + typedef base_type BaseType; \ + typedef short_type##2 Type; \ + __host__ __device__ __forceinline__ CubVector operator+(const CubVector &other) const { \ + CubVector retval; \ + retval.x = x + other.x; \ + retval.y = y + other.y; \ + return retval; \ + } \ + __host__ __device__ __forceinline__ CubVector operator-(const CubVector &other) const { \ + CubVector retval; \ + retval.x = x - other.x; \ + retval.y = y - other.y; \ + return retval; \ + } \ + }; \ + \ + template<> struct CubVector : short_type##3 \ + { \ + typedef base_type BaseType; \ + typedef short_type##3 Type; \ + __host__ __device__ __forceinline__ CubVector operator+(const CubVector &other) const { \ + CubVector retval; \ + retval.x = x + other.x; \ + retval.y = y + other.y; \ + retval.z = z + other.z; \ + return retval; \ + } \ + __host__ __device__ __forceinline__ CubVector operator-(const CubVector &other) const { \ + CubVector retval; \ + retval.x = x - other.x; \ + retval.y = y - other.y; \ + retval.z = z - other.z; \ + return retval; \ + } \ + }; \ + \ + template<> struct CubVector : short_type##4 \ + { \ + typedef base_type BaseType; \ + typedef short_type##4 Type; \ + __host__ __device__ __forceinline__ CubVector operator+(const CubVector &other) const { \ + CubVector retval; \ + retval.x = x + other.x; \ + retval.y = y + other.y; \ + retval.z = z + other.z; \ + retval.w = w + other.w; \ + return retval; \ + } \ + __host__ __device__ __forceinline__ CubVector operator-(const CubVector &other) const { \ + CubVector retval; \ + retval.x = x - other.x; \ + retval.y = y - other.y; \ + retval.z = z - other.z; \ + retval.w = w - other.w; \ + return retval; \ + } \ + }; + + + +// Expand CUDA vector types for built-in primitives +CUB_DEFINE_VECTOR_TYPE(char, char) +CUB_DEFINE_VECTOR_TYPE(signed char, char) +CUB_DEFINE_VECTOR_TYPE(short, short) +CUB_DEFINE_VECTOR_TYPE(int, int) +CUB_DEFINE_VECTOR_TYPE(long, long) +CUB_DEFINE_VECTOR_TYPE(long long, longlong) +CUB_DEFINE_VECTOR_TYPE(unsigned char, uchar) +CUB_DEFINE_VECTOR_TYPE(unsigned short, ushort) +CUB_DEFINE_VECTOR_TYPE(unsigned int, uint) +CUB_DEFINE_VECTOR_TYPE(unsigned long, ulong) +CUB_DEFINE_VECTOR_TYPE(unsigned long long, ulonglong) +CUB_DEFINE_VECTOR_TYPE(float, float) +CUB_DEFINE_VECTOR_TYPE(double, double) +CUB_DEFINE_VECTOR_TYPE(bool, uchar) + +// Undefine macros +#undef CUB_DEFINE_VECTOR_TYPE + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + + +/****************************************************************************** + * Wrapper types + ******************************************************************************/ + +/** + * \brief A storage-backing wrapper that allows types with non-trivial constructors to be aliased in unions + */ +template +struct Uninitialized +{ + /// Biggest memory-access word that T is a whole multiple of and is not larger than the alignment of T + typedef typename UnitWord::DeviceWord DeviceWord; + + enum + { + WORDS = sizeof(T) / sizeof(DeviceWord) + }; + + /// Backing storage + DeviceWord storage[WORDS]; + + /// Alias + __host__ __device__ __forceinline__ T& Alias() + { + return reinterpret_cast(*this); + } +}; + + +/** + * \brief A key identifier paired with a corresponding value + */ +template +struct KeyValuePair +{ + typedef _Key Key; ///< Key data type + typedef _Value Value; ///< Value data type + +#if (CUB_PTX_ARCH == 0) + union + { + Key key; ///< Item key + typename UnitWord::DeviceWord align0; ///< Alignment/padding (for Win32 consistency between host/device) + }; +#else + Key key; ///< Item key +#endif + + Value value; ///< Item value + + /// Inequality operator + __host__ __device__ __forceinline__ bool operator !=(const KeyValuePair &b) + { + return (value != b.value) || (key != b.key); + } + +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + +/** + * Workaround for inability for SM1.x compiler to properly zero-initialize POD structures when it's supposed to + */ +template +__host__ __device__ __forceinline__ T ZeroInitialize() +{ +#if (CUB_PTX_ARCH > 0) && (CUB_PTX_ARCH <= 130) + + typedef typename UnitWord::ShuffleWord ShuffleWord; + const int MULTIPLE = sizeof(T) / sizeof(ShuffleWord); + ShuffleWord words[MULTIPLE]; + #pragma unroll + for (int i = 0; i < MULTIPLE; ++i) + words[i] = 0; + return *reinterpret_cast(words); + +#else + + return T(); + +#endif +} + + +/** + * \brief A wrapper for passing simple static arrays as kernel parameters + */ +template +struct ArrayWrapper +{ + + /// Statically-sized array of type \p T + T array[COUNT]; + + /// Constructor + __host__ __device__ __forceinline__ ArrayWrapper() {} +}; + +#endif // DOXYGEN_SHOULD_SKIP_THIS + +/** + * \brief Double-buffer storage wrapper for multi-pass stream transformations that require more than one storage array for streaming intermediate results back and forth. + * + * Many multi-pass computations require a pair of "ping-pong" storage + * buffers (e.g., one for reading from and the other for writing to, and then + * vice-versa for the subsequent pass). This structure wraps a set of device + * buffers and a "selector" member to track which is "current". + */ +template +struct DoubleBuffer +{ + /// Pair of device buffer pointers + T *d_buffers[2]; + + /// Selector into \p d_buffers (i.e., the active/valid buffer) + int selector; + + /// \brief Constructor + __host__ __device__ __forceinline__ DoubleBuffer() + { + selector = 0; + d_buffers[0] = NULL; + d_buffers[1] = NULL; + } + + /// \brief Constructor + __host__ __device__ __forceinline__ DoubleBuffer( + T *d_current, ///< The currently valid buffer + T *d_alternate) ///< Alternate storage buffer of the same size as \p d_current + { + selector = 0; + d_buffers[0] = d_current; + d_buffers[1] = d_alternate; + } + + /// \brief Return pointer to the currently valid buffer + __host__ __device__ __forceinline__ T* Current() { return d_buffers[selector]; } + + /// \brief Return pointer to the currently invalid buffer + __host__ __device__ __forceinline__ T* Alternate() { return d_buffers[selector ^ 1]; } + +}; + + + +/****************************************************************************** + * Static math + ******************************************************************************/ + +/** + * \brief Statically determine log2(N), rounded up. + * + * For example: + * Log2<8>::VALUE // 3 + * Log2<3>::VALUE // 2 + */ +template +struct Log2 +{ + /// Static logarithm value + enum { VALUE = Log2> 1), COUNT + 1>::VALUE }; // Inductive case +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +template +struct Log2 +{ + enum {VALUE = (1 << (COUNT - 1) < N) ? // Base case + COUNT : + COUNT - 1 }; +}; + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + +/** + * \brief Statically determine if N is a power-of-two + */ +template +struct PowerOfTwo +{ + enum { VALUE = ((N & (N - 1)) == 0) }; +}; + + + +/****************************************************************************** + * Pointer vs. iterator detection + ******************************************************************************/ + +/** + * \brief Pointer vs. iterator + */ +template +struct IsPointer +{ + enum { VALUE = 0 }; +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +template +struct IsPointer +{ + enum { VALUE = 1 }; +}; + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + + +/****************************************************************************** + * Qualifier detection + ******************************************************************************/ + +/** + * \brief Volatile modifier test + */ +template +struct IsVolatile +{ + enum { VALUE = 0 }; +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +template +struct IsVolatile +{ + enum { VALUE = 1 }; +}; + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + +/****************************************************************************** + * Qualifier removal + ******************************************************************************/ + +/** + * \brief Removes \p const and \p volatile qualifiers from type \p Tp. + * + * For example: + * typename RemoveQualifiers::Type // int; + */ +template +struct RemoveQualifiers +{ + /// Type without \p const and \p volatile qualifiers + typedef Up Type; +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + +template +struct RemoveQualifiers +{ + typedef Up Type; +}; + +template +struct RemoveQualifiers +{ + typedef Up Type; +}; + +template +struct RemoveQualifiers +{ + typedef Up Type; +}; + + + +/****************************************************************************** + * Typedef-detection + ******************************************************************************/ + + +/** + * \brief Defines a structure \p detector_name that is templated on type \p T. The \p detector_name struct exposes a constant member \p VALUE indicating whether or not parameter \p T exposes a nested type \p nested_type_name + */ +#define CUB_DEFINE_DETECT_NESTED_TYPE(detector_name, nested_type_name) \ + template \ + struct detector_name \ + { \ + template \ + static char& test(typename C::nested_type_name*); \ + template \ + static int& test(...); \ + enum \ + { \ + VALUE = sizeof(test(0)) < sizeof(int) \ + }; \ + }; + + + +/****************************************************************************** + * Simple enable-if (similar to Boost) + ******************************************************************************/ + +/** + * \brief Simple enable-if (similar to Boost) + */ +template +struct EnableIf +{ + /// Enable-if type for SFINAE dummy variables + typedef T Type; +}; + + +template +struct EnableIf {}; + + + +/****************************************************************************** + * Typedef-detection + ******************************************************************************/ + +/** + * \brief Determine whether or not BinaryOp's functor is of the form bool operator()(const T& a, const T&b) or bool operator()(const T& a, const T&b, unsigned int idx) + */ +template +struct BinaryOpHasIdxParam +{ +private: +/* + template struct SFINAE1 {}; + template struct SFINAE2 {}; + template struct SFINAE3 {}; + template struct SFINAE4 {}; +*/ + template struct SFINAE5 {}; + template struct SFINAE6 {}; + template struct SFINAE7 {}; + template struct SFINAE8 {}; +/* + template static char Test(SFINAE1 *); + template static char Test(SFINAE2 *); + template static char Test(SFINAE3 *); + template static char Test(SFINAE4 *); +*/ + template static char Test(SFINAE5 *); + template static char Test(SFINAE6 *); + template static char Test(SFINAE7 *); + template static char Test(SFINAE8 *); + + template static int Test(...); + +public: + + /// Whether the functor BinaryOp has a third unsigned int index param + static const bool HAS_PARAM = sizeof(Test(NULL)) == sizeof(char); +}; + + + + +/****************************************************************************** + * Simple type traits utilities. + * + * For example: + * Traits::CATEGORY // SIGNED_INTEGER + * Traits::NULL_TYPE // true + * Traits::CATEGORY // NOT_A_NUMBER + * Traits::PRIMITIVE; // false + * + ******************************************************************************/ + +/** + * \brief Basic type traits categories + */ +enum Category +{ + NOT_A_NUMBER, + SIGNED_INTEGER, + UNSIGNED_INTEGER, + FLOATING_POINT +}; + + +/** + * \brief Basic type traits + */ +template +struct BaseTraits +{ + /// Category + static const Category CATEGORY = _CATEGORY; + enum + { + PRIMITIVE = _PRIMITIVE, + NULL_TYPE = _NULL_TYPE, + }; +}; + + +/** + * Basic type traits (unsigned primitive specialization) + */ +template +struct BaseTraits +{ + typedef _UnsignedBits UnsignedBits; + + static const Category CATEGORY = UNSIGNED_INTEGER; + static const UnsignedBits MIN_KEY = UnsignedBits(0); + static const UnsignedBits MAX_KEY = UnsignedBits(-1); + + enum + { + PRIMITIVE = true, + NULL_TYPE = false, + }; + + + static __device__ __forceinline__ UnsignedBits TwiddleIn(UnsignedBits key) + { + return key; + } + + static __device__ __forceinline__ UnsignedBits TwiddleOut(UnsignedBits key) + { + return key; + } +}; + + +/** + * Basic type traits (signed primitive specialization) + */ +template +struct BaseTraits +{ + typedef _UnsignedBits UnsignedBits; + + static const Category CATEGORY = SIGNED_INTEGER; + static const UnsignedBits HIGH_BIT = UnsignedBits(1) << ((sizeof(UnsignedBits) * 8) - 1); + static const UnsignedBits MIN_KEY = HIGH_BIT; + static const UnsignedBits MAX_KEY = UnsignedBits(-1) ^ HIGH_BIT; + + enum + { + PRIMITIVE = true, + NULL_TYPE = false, + }; + + static __device__ __forceinline__ UnsignedBits TwiddleIn(UnsignedBits key) + { + return key ^ HIGH_BIT; + }; + + static __device__ __forceinline__ UnsignedBits TwiddleOut(UnsignedBits key) + { + return key ^ HIGH_BIT; + }; + +}; + + +/** + * Basic type traits (fp primitive specialization) + */ +template +struct BaseTraits +{ + typedef _UnsignedBits UnsignedBits; + + static const Category CATEGORY = FLOATING_POINT; + static const UnsignedBits HIGH_BIT = UnsignedBits(1) << ((sizeof(UnsignedBits) * 8) - 1); + static const UnsignedBits MIN_KEY = UnsignedBits(-1); + static const UnsignedBits MAX_KEY = UnsignedBits(-1) ^ HIGH_BIT; + + static __device__ __forceinline__ UnsignedBits TwiddleIn(UnsignedBits key) + { + UnsignedBits mask = (key & HIGH_BIT) ? UnsignedBits(-1) : HIGH_BIT; + return key ^ mask; + }; + + static __device__ __forceinline__ UnsignedBits TwiddleOut(UnsignedBits key) + { + UnsignedBits mask = (key & HIGH_BIT) ? HIGH_BIT : UnsignedBits(-1); + return key ^ mask; + }; + + enum + { + PRIMITIVE = true, + NULL_TYPE = false, + }; +}; + + +/** + * \brief Numeric type traits + */ +template struct NumericTraits : BaseTraits {}; + +template <> struct NumericTraits : BaseTraits {}; + +template <> struct NumericTraits : BaseTraits<(std::numeric_limits::is_signed) ? SIGNED_INTEGER : UNSIGNED_INTEGER, true, false, unsigned char> {}; +template <> struct NumericTraits : BaseTraits {}; +template <> struct NumericTraits : BaseTraits {}; +template <> struct NumericTraits : BaseTraits {}; +template <> struct NumericTraits : BaseTraits {}; +template <> struct NumericTraits : BaseTraits {}; + +template <> struct NumericTraits : BaseTraits {}; +template <> struct NumericTraits : BaseTraits {}; +template <> struct NumericTraits : BaseTraits {}; +template <> struct NumericTraits : BaseTraits {}; +template <> struct NumericTraits : BaseTraits {}; + +template <> struct NumericTraits : BaseTraits {}; +template <> struct NumericTraits : BaseTraits {}; + +template <> struct NumericTraits : BaseTraits::VolatileWord > {}; + + + +/** + * \brief Type traits + */ +template +struct Traits : NumericTraits::Type> {}; + + +#endif // DOXYGEN_SHOULD_SKIP_THIS + + +/** @} */ // end group UtilModule + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/warp/specializations/warp_reduce_shfl.cuh b/3rdparty/cub/cub/warp/specializations/warp_reduce_shfl.cuh new file mode 100644 index 00000000000..fe00b001f26 --- /dev/null +++ b/3rdparty/cub/cub/warp/specializations/warp_reduce_shfl.cuh @@ -0,0 +1,473 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::WarpReduceShfl provides SHFL-based variants of parallel reduction of items partitioned across a CUDA thread warp. + */ + +#pragma once + +#include "../../thread/thread_operators.cuh" +#include "../../util_ptx.cuh" +#include "../../util_type.cuh" +#include "../../util_macro.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \brief WarpReduceShfl provides SHFL-based variants of parallel reduction of items partitioned across a CUDA thread warp. + */ +template < + typename T, ///< Data type being reduced + int LOGICAL_WARP_THREADS, ///< Number of threads per logical warp + int PTX_ARCH> ///< The PTX compute capability for which to to specialize this collective +struct WarpReduceShfl +{ + //--------------------------------------------------------------------- + // Constants and type definitions + //--------------------------------------------------------------------- + + enum + { + /// Whether the logical warp size and the PTX warp size coincide + IS_ARCH_WARP = (LOGICAL_WARP_THREADS == CUB_WARP_THREADS(PTX_ARCH)), + + /// The number of warp reduction steps + STEPS = Log2::VALUE, + + /// Number of logical warps in a PTX warp + LOGICAL_WARPS = CUB_WARP_THREADS(PTX_ARCH) / LOGICAL_WARP_THREADS, + }; + + template + struct IsInteger + { + enum { + ///Whether the data type is a small (32b or less) integer for which we can use a single SFHL instruction per exchange + IS_SMALL_UNSIGNED = (Traits::CATEGORY == UNSIGNED_INTEGER) && (sizeof(S) <= sizeof(unsigned int)) + }; + }; + + + // Creates a mask where the last thread in each logical warp is set + template + struct LastLaneMask + { + enum { + BASE_MASK = 1 << (LOGICAL_WARP_THREADS - 1), + MASK = (LastLaneMask::MASK << LOGICAL_WARP_THREADS) | BASE_MASK, + }; + }; + + // Creates a mask where the last thread in each logical warp is set + template + struct LastLaneMask + { + enum { + MASK = 1 << (LOGICAL_WARP_THREADS - 1), + }; + }; + + + + /// Shared memory storage layout type + typedef NullType TempStorage; + + + //--------------------------------------------------------------------- + // Thread fields + //--------------------------------------------------------------------- + + int lane_id; + + + //--------------------------------------------------------------------- + // Construction + //--------------------------------------------------------------------- + + /// Constructor + __device__ __forceinline__ WarpReduceShfl( + TempStorage &temp_storage) + : + lane_id(LaneId()) + {} + + + //--------------------------------------------------------------------- + // Reduction steps + //--------------------------------------------------------------------- + + /// Reduction (specialized for summation across uint32 types) + __device__ __forceinline__ unsigned int ReduceStep( + unsigned int input, ///< [in] Calling thread's input item. + cub::Sum reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + int offset) ///< [in] Up-offset to pull from + { + unsigned int output; + + // Use predicate set from SHFL to guard against invalid peers + asm( + "{" + " .reg .u32 r0;" + " .reg .pred p;" + " shfl.down.b32 r0|p, %1, %2, %3;" + " @p add.u32 r0, r0, %4;" + " mov.u32 %0, r0;" + "}" + : "=r"(output) : "r"(input), "r"(offset), "r"(last_lane), "r"(input)); + + return output; + } + + + /// Reduction (specialized for summation across fp32 types) + __device__ __forceinline__ float ReduceStep( + float input, ///< [in] Calling thread's input item. + cub::Sum reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + int offset) ///< [in] Up-offset to pull from + { + float output; + + // Use predicate set from SHFL to guard against invalid peers + asm( + "{" + " .reg .f32 r0;" + " .reg .pred p;" + " shfl.down.b32 r0|p, %1, %2, %3;" + " @p add.f32 r0, r0, %4;" + " mov.f32 %0, r0;" + "}" + : "=f"(output) : "f"(input), "r"(offset), "r"(last_lane), "f"(input)); + + return output; + } + + + /// Reduction (specialized for summation across unsigned long long types) + __device__ __forceinline__ unsigned long long ReduceStep( + unsigned long long input, ///< [in] Calling thread's input item. + cub::Sum reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + int offset) ///< [in] Up-offset to pull from + { + unsigned long long output; + + asm( + "{" + " .reg .u32 lo;" + " .reg .u32 hi;" + " .reg .pred p;" + " mov.b64 {lo, hi}, %1;" + " shfl.down.b32 lo|p, lo, %2, %3;" + " shfl.down.b32 hi|p, hi, %2, %3;" + " mov.b64 %0, {lo, hi};" + " @p add.u64 %0, %0, %1;" + "}" + : "=l"(output) : "l"(input), "r"(offset), "r"(last_lane)); + + return output; + } + + + /// Reduction (specialized for summation across long long types) + __device__ __forceinline__ long long ReduceStep( + long long input, ///< [in] Calling thread's input item. + cub::Sum reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + int offset) ///< [in] Up-offset to pull from + { + long long output; + + // Use predicate set from SHFL to guard against invalid peers + asm( + "{" + " .reg .u32 lo;" + " .reg .u32 hi;" + " .reg .pred p;" + " mov.b64 {lo, hi}, %1;" + " shfl.down.b32 lo|p, lo, %2, %3;" + " shfl.down.b32 hi|p, hi, %2, %3;" + " mov.b64 %0, {lo, hi};" + " @p add.s64 %0, %0, %1;" + "}" + : "=l"(output) : "l"(input), "r"(offset), "r"(last_lane)); + + return output; + } + + + /// Reduction (specialized for summation across double types) + __device__ __forceinline__ double ReduceStep( + double input, ///< [in] Calling thread's input item. + cub::Sum reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + int offset) ///< [in] Up-offset to pull from + { + double output; + + // Use predicate set from SHFL to guard against invalid peers + asm( + "{" + " .reg .u32 lo;" + " .reg .u32 hi;" + " .reg .pred p;" + " .reg .f64 r0;" + " mov.b64 %0, %1;" + " mov.b64 {lo, hi}, %1;" + " shfl.down.b32 lo|p, lo, %2, %3;" + " shfl.down.b32 hi|p, hi, %2, %3;" + " mov.b64 r0, {lo, hi};" + " @p add.f64 %0, %0, r0;" + "}" + : "=d"(output) : "d"(input), "r"(offset), "r"(last_lane)); + + return output; + } + + + /// Reduction (specialized for swizzled ReduceByKeyOp across KeyValuePair types) + template + __device__ __forceinline__ KeyValuePair ReduceStep( + KeyValuePair input, ///< [in] Calling thread's input item. + SwizzleScanOp > reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + int offset) ///< [in] Up-offset to pull from + { + KeyValuePair output; + + KeyT other_key = ShuffleDown(input.key, offset, last_lane); + + output.key = input.key; + output.value = ReduceStep( + input.value, + cub::Sum(), + last_lane, + offset, + Int2Type::IS_SMALL_UNSIGNED>()); + + if (input.key != other_key) + output.value = input.value; + + return output; + } + + + + /// Reduction (specialized for swizzled ReduceBySegmentOp across KeyValuePair types) + template + __device__ __forceinline__ KeyValuePair ReduceStep( + KeyValuePair input, ///< [in] Calling thread's input item. + SwizzleScanOp > reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + int offset) ///< [in] Up-offset to pull from + { + KeyValuePair output; + + output.value = ReduceStep(input.value, cub::Sum(), last_lane, offset, Int2Type::IS_SMALL_UNSIGNED>()); + output.key = ReduceStep(input.key, cub::Sum(), last_lane, offset, Int2Type::IS_SMALL_UNSIGNED>()); + + if (input.key > 0) + output.value = input.value; + + return output; + } + + + /// Reduction step (generic) + template + __device__ __forceinline__ _T ReduceStep( + _T input, ///< [in] Calling thread's input item. + ReductionOp reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + int offset) ///< [in] Up-offset to pull from + { + _T output = input; + + _T temp = ShuffleDown(output, offset); + + // Perform reduction op if valid + if (offset <= last_lane - lane_id) + output = reduction_op(input, temp); + + return output; + } + + + /// Reduction step (specialized for small unsigned integers size 32b or less) + template + __device__ __forceinline__ _T ReduceStep( + _T input, ///< [in] Calling thread's input item. + ReductionOp reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + int offset, ///< [in] Up-offset to pull from + Int2Type is_small_unsigned) ///< [in] Marker type indicating whether T is a small unsigned integer + { + // Recast as uint32 to take advantage of any specializations + unsigned int temp = reinterpret_cast(input); + temp = ReduceStep(temp, reduction_op, last_lane, offset); + return reinterpret_cast<_T&>(temp); + } + + + /// Reduction step (specialized for types other than small unsigned integers size 32b or less) + template + __device__ __forceinline__ _T ReduceStep( + _T input, ///< [in] Calling thread's input item. + ReductionOp reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + int offset, ///< [in] Up-offset to pull from + Int2Type is_small_unsigned) ///< [in] Marker type indicating whether T is a small unsigned integer + { + return ReduceStep(input, reduction_op, last_lane, offset); + } + + + //--------------------------------------------------------------------- + // Templated inclusive scan iteration + //--------------------------------------------------------------------- + + template + __device__ __forceinline__ void ReduceStep( + T& input, ///< [in] Calling thread's input item. + ReductionOp reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + Int2Type step) + { + input = ReduceStep(input, reduction_op, last_lane, 1 << STEP, Int2Type::IS_SMALL_UNSIGNED>()); + + ReduceStep(input, reduction_op, last_lane, Int2Type()); + } + + template + __device__ __forceinline__ void ReduceStep( + T& input, ///< [in] Calling thread's input item. + ReductionOp reduction_op, ///< [in] Binary reduction operator + int last_lane, ///< [in] Index of last lane in segment + Int2Type step) + {} + + + //--------------------------------------------------------------------- + // Reduction operations + //--------------------------------------------------------------------- + + /// Reduction + template < + bool ALL_LANES_VALID, ///< Whether all lanes in each warp are contributing a valid fold of items + int FOLDED_ITEMS_PER_LANE, ///< Number of items folded into each lane + typename ReductionOp> + __device__ __forceinline__ T Reduce( + T input, ///< [in] Calling thread's input + int folded_items_per_warp, ///< [in] Total number of valid items folded into each logical warp + ReductionOp reduction_op) ///< [in] Binary reduction operator + { + // Get the last thread in the logical warp + int first_warp_thread = 0; + int last_warp_thread = LOGICAL_WARP_THREADS - 1; + if (!IS_ARCH_WARP) + { + first_warp_thread = lane_id & (~(LOGICAL_WARP_THREADS - 1)); + last_warp_thread |= lane_id; + } + + // Common case is FOLDED_ITEMS_PER_LANE = 1 (or a multiple of 32) + int lanes_with_valid_data = (folded_items_per_warp - 1) / FOLDED_ITEMS_PER_LANE; + + // Get the last valid lane + int last_lane = (ALL_LANES_VALID) ? + last_warp_thread : + CUB_MIN(last_warp_thread, first_warp_thread + lanes_with_valid_data); + + T output = input; + +/* + // Iterate reduction steps + #pragma unroll + for (int STEP = 0; STEP < STEPS; STEP++) + { + output = ReduceStep(output, reduction_op, last_lane, 1 << STEP, Int2Type::IS_SMALL_UNSIGNED>()); + } +*/ + ReduceStep(output, reduction_op, last_lane, Int2Type<0>()); + + return output; + } + + + /// Segmented reduction + template < + bool HEAD_SEGMENTED, ///< Whether flags indicate a segment-head or a segment-tail + typename FlagT, + typename ReductionOp> + __device__ __forceinline__ T SegmentedReduce( + T input, ///< [in] Calling thread's input + FlagT flag, ///< [in] Whether or not the current lane is a segment head/tail + ReductionOp reduction_op) ///< [in] Binary reduction operator + { + // Get the start flags for each thread in the warp. + int warp_flags = __ballot(flag); + + if (HEAD_SEGMENTED) + warp_flags >>= 1; + + // Mask in the last lanes of each logical warp + warp_flags |= LastLaneMask<1, LOGICAL_WARPS>::MASK; + + // Mask out the bits below the current thread + warp_flags &= LaneMaskGe(); + + // Find the next set flag + int last_lane = __clz(__brev(warp_flags)); + + T output = input; +/* + // Iterate reduction steps + #pragma unroll + for (int STEP = 0; STEP < STEPS; STEP++) + { + output = ReduceStep(output, reduction_op, last_lane, 1 << STEP, Int2Type::IS_SMALL_UNSIGNED>()); + } +*/ + ReduceStep(output, reduction_op, last_lane, Int2Type<0>()); + + return output; + } +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/warp/specializations/warp_reduce_smem.cuh b/3rdparty/cub/cub/warp/specializations/warp_reduce_smem.cuh new file mode 100644 index 00000000000..31d08f7c338 --- /dev/null +++ b/3rdparty/cub/cub/warp/specializations/warp_reduce_smem.cuh @@ -0,0 +1,357 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::WarpReduceSmem provides smem-based variants of parallel reduction of items partitioned across a CUDA thread warp. + */ + +#pragma once + +#include "../../thread/thread_operators.cuh" +#include "../../thread/thread_load.cuh" +#include "../../thread/thread_store.cuh" +#include "../../util_type.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \brief WarpReduceSmem provides smem-based variants of parallel reduction of items partitioned across a CUDA thread warp. + */ +template < + typename T, ///< Data type being reduced + int LOGICAL_WARP_THREADS, ///< Number of threads per logical warp + int PTX_ARCH> ///< The PTX compute capability for which to to specialize this collective +struct WarpReduceSmem +{ + /****************************************************************************** + * Constants and type definitions + ******************************************************************************/ + + enum + { + /// Whether the logical warp size and the PTX warp size coincide + IS_ARCH_WARP = (LOGICAL_WARP_THREADS == CUB_WARP_THREADS(PTX_ARCH)), + + /// Whether the logical warp size is a power-of-two + IS_POW_OF_TWO = ((LOGICAL_WARP_THREADS & (LOGICAL_WARP_THREADS - 1)) == 0), + + /// The number of warp scan steps + STEPS = Log2::VALUE, + + /// The number of threads in half a warp + HALF_WARP_THREADS = 1 << (STEPS - 1), + + /// The number of shared memory elements per warp + WARP_SMEM_ELEMENTS = LOGICAL_WARP_THREADS + HALF_WARP_THREADS, + + /// FlagT status (when not using ballot) + UNSET = 0x0, // Is initially unset + SET = 0x1, // Is initially set + SEEN = 0x2, // Has seen another head flag from a successor peer + }; + + /// Shared memory flag type + typedef unsigned char SmemFlag; + + /// Shared memory storage layout type (1.5 warps-worth of elements for each warp) + struct _TempStorage + { + T reduce[WARP_SMEM_ELEMENTS]; + SmemFlag flags[WARP_SMEM_ELEMENTS]; + }; + + // Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + _TempStorage &temp_storage; + int lane_id; + + + /****************************************************************************** + * Construction + ******************************************************************************/ + + /// Constructor + __device__ __forceinline__ WarpReduceSmem( + TempStorage &temp_storage) + : + temp_storage(temp_storage.Alias()), + lane_id(IS_ARCH_WARP ? + LaneId() : + LaneId() % LOGICAL_WARP_THREADS) + {} + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + //--------------------------------------------------------------------- + // Regular reduction + //--------------------------------------------------------------------- + + /** + * Reduction step + */ + template < + bool ALL_LANES_VALID, ///< Whether all lanes in each warp are contributing a valid fold of items + int FOLDED_ITEMS_PER_LANE, ///< Number of items folded into each lane + typename ReductionOp, + int STEP> + __device__ __forceinline__ T ReduceStep( + T input, ///< [in] Calling thread's input + int folded_items_per_warp, ///< [in] Total number of valid items folded into each logical warp + ReductionOp reduction_op, ///< [in] Reduction operator + Int2Type step) + { + const int OFFSET = 1 << STEP; + + // Share input through buffer + ThreadStore(&temp_storage.reduce[lane_id], input); + + // Update input if peer_addend is in range + if ((ALL_LANES_VALID && IS_POW_OF_TWO) || ((lane_id + OFFSET) * FOLDED_ITEMS_PER_LANE < folded_items_per_warp)) + { + T peer_addend = ThreadLoad(&temp_storage.reduce[lane_id + OFFSET]); + input = reduction_op(input, peer_addend); + } + + return ReduceStep(input, folded_items_per_warp, reduction_op, Int2Type()); + } + + + /** + * Reduction step (terminate) + */ + template < + bool ALL_LANES_VALID, ///< Whether all lanes in each warp are contributing a valid fold of items + int FOLDED_ITEMS_PER_LANE, ///< Number of items folded into each lane + typename ReductionOp> + __device__ __forceinline__ T ReduceStep( + T input, ///< [in] Calling thread's input + int folded_items_per_warp, ///< [in] Total number of valid items folded into each logical warp + ReductionOp reduction_op, ///< [in] Reduction operator + Int2Type step) + { + return input; + } + + + //--------------------------------------------------------------------- + // Segmented reduction + //--------------------------------------------------------------------- + + + /** + * Ballot-based segmented reduce + */ + template < + bool HEAD_SEGMENTED, ///< Whether flags indicate a segment-head or a segment-tail + typename FlagT, + typename ReductionOp> + __device__ __forceinline__ T SegmentedReduce( + T input, ///< [in] Calling thread's input + FlagT flag, ///< [in] Whether or not the current lane is a segment head/tail + ReductionOp reduction_op, ///< [in] Reduction operator + Int2Type has_ballot) ///< [in] Marker type for whether the target arch has ballot functionality + { + // Get the start flags for each thread in the warp. + int warp_flags = __ballot(flag); + + if (!HEAD_SEGMENTED) + warp_flags <<= 1; + + // Keep bits above the current thread. + warp_flags &= LaneMaskGt(); + + // Accommodate packing of multiple logical warps in a single physical warp + if (!IS_ARCH_WARP) + { + warp_flags >>= (LaneId() / LOGICAL_WARP_THREADS) * LOGICAL_WARP_THREADS; + } + + // Find next flag + int next_flag = __clz(__brev(warp_flags)); + + // Clip the next segment at the warp boundary if necessary + if (LOGICAL_WARP_THREADS != 32) + next_flag = CUB_MIN(next_flag, LOGICAL_WARP_THREADS); + + #pragma unroll + for (int STEP = 0; STEP < STEPS; STEP++) + { + const int OFFSET = 1 << STEP; + + // Share input into buffer + ThreadStore(&temp_storage.reduce[lane_id], input); + + // Update input if peer_addend is in range + if (OFFSET < next_flag - lane_id) + { + T peer_addend = ThreadLoad(&temp_storage.reduce[lane_id + OFFSET]); + input = reduction_op(input, peer_addend); + } + } + + return input; + } + + + /** + * Smem-based segmented reduce + */ + template < + bool HEAD_SEGMENTED, ///< Whether flags indicate a segment-head or a segment-tail + typename FlagT, + typename ReductionOp> + __device__ __forceinline__ T SegmentedReduce( + T input, ///< [in] Calling thread's input + FlagT flag, ///< [in] Whether or not the current lane is a segment head/tail + ReductionOp reduction_op, ///< [in] Reduction operator + Int2Type has_ballot) ///< [in] Marker type for whether the target arch has ballot functionality + { + enum + { + UNSET = 0x0, // Is initially unset + SET = 0x1, // Is initially set + SEEN = 0x2, // Has seen another head flag from a successor peer + }; + + // Alias flags onto shared data storage + volatile SmemFlag *flag_storage = temp_storage.flags; + + SmemFlag flag_status = (flag) ? SET : UNSET; + + for (int STEP = 0; STEP < STEPS; STEP++) + { + const int OFFSET = 1 << STEP; + + // Share input through buffer + ThreadStore(&temp_storage.reduce[lane_id], input); + + // Get peer from buffer + T peer_addend = ThreadLoad(&temp_storage.reduce[lane_id + OFFSET]); + + // Share flag through buffer + flag_storage[lane_id] = flag_status; + + // Get peer flag from buffer + SmemFlag peer_flag_status = flag_storage[lane_id + OFFSET]; + + // Update input if peer was in range + if (lane_id < LOGICAL_WARP_THREADS - OFFSET) + { + if (HEAD_SEGMENTED) + { + // Head-segmented + if ((flag_status & SEEN) == 0) + { + // Has not seen a more distant head flag + if (peer_flag_status & SET) + { + // Has now seen a head flag + flag_status |= SEEN; + } + else + { + // Peer is not a head flag: grab its count + input = reduction_op(input, peer_addend); + } + + // Update seen status to include that of peer + flag_status |= (peer_flag_status & SEEN); + } + } + else + { + // Tail-segmented. Simply propagate flag status + if (!flag_status) + { + input = reduction_op(input, peer_addend); + flag_status |= peer_flag_status; + } + + } + } + } + + return input; + } + + + /****************************************************************************** + * Interface + ******************************************************************************/ + + /** + * Reduction + */ + template < + bool ALL_LANES_VALID, ///< Whether all lanes in each warp are contributing a valid fold of items + int FOLDED_ITEMS_PER_LANE, ///< Number of items folded into each lane + typename ReductionOp> + __device__ __forceinline__ T Reduce( + T input, ///< [in] Calling thread's input + int folded_items_per_warp, ///< [in] Total number of valid items folded into each logical warp + ReductionOp reduction_op) ///< [in] Reduction operator + { + return ReduceStep(input, folded_items_per_warp, reduction_op, Int2Type<0>()); + } + + + /** + * Segmented reduction + */ + template < + bool HEAD_SEGMENTED, ///< Whether flags indicate a segment-head or a segment-tail + typename FlagT, + typename ReductionOp> + __device__ __forceinline__ T SegmentedReduce( + T input, ///< [in] Calling thread's input + FlagT flag, ///< [in] Whether or not the current lane is a segment head/tail + ReductionOp reduction_op) ///< [in] Reduction operator + { + return SegmentedReduce(input, flag, reduction_op, Int2Type<(PTX_ARCH >= 200)>()); + } + + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/warp/specializations/warp_scan_shfl.cuh b/3rdparty/cub/cub/warp/specializations/warp_scan_shfl.cuh new file mode 100644 index 00000000000..305c5572285 --- /dev/null +++ b/3rdparty/cub/cub/warp/specializations/warp_scan_shfl.cuh @@ -0,0 +1,597 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::WarpScanShfl provides SHFL-based variants of parallel prefix scan of items partitioned across a CUDA thread warp. + */ + +#pragma once + +#include "../../thread/thread_operators.cuh" +#include "../../util_type.cuh" +#include "../../util_ptx.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \brief WarpScanShfl provides SHFL-based variants of parallel prefix scan of items partitioned across a CUDA thread warp. + */ +template < + typename T, ///< Data type being scanned + int LOGICAL_WARP_THREADS, ///< Number of threads per logical warp + int PTX_ARCH> ///< The PTX compute capability for which to to specialize this collective +struct WarpScanShfl +{ + //--------------------------------------------------------------------- + // Constants and type definitions + //--------------------------------------------------------------------- + + enum + { + /// Whether the logical warp size and the PTX warp size coincide + IS_ARCH_WARP = (LOGICAL_WARP_THREADS == CUB_WARP_THREADS(PTX_ARCH)), + + /// The number of warp scan steps + STEPS = Log2::VALUE, + + /// The 5-bit SHFL mask for logically splitting warps into sub-segments starts 8-bits up + SHFL_C = ((-1 << STEPS) & 31) << 8, + }; + + template + struct IsInteger + { + enum { + /// Whether the data type is a primitive integer + IS_INTEGER = (Traits::CATEGORY == UNSIGNED_INTEGER) || (Traits::CATEGORY == SIGNED_INTEGER), + + ///Whether the data type is a small (32b or less) integer for which we can use a single SFHL instruction per exchange + IS_SMALL_UNSIGNED = (Traits::CATEGORY == UNSIGNED_INTEGER) && (sizeof(S) <= sizeof(unsigned int)) + }; + }; + + /// Shared memory storage layout type + typedef NullType TempStorage; + + + //--------------------------------------------------------------------- + // Thread fields + //--------------------------------------------------------------------- + + int lane_id; + + //--------------------------------------------------------------------- + // Construction + //--------------------------------------------------------------------- + + /// Constructor + __device__ __forceinline__ WarpScanShfl( + TempStorage &temp_storage) + : + lane_id(IS_ARCH_WARP ? + LaneId() : + LaneId() % LOGICAL_WARP_THREADS) + {} + + + //--------------------------------------------------------------------- + // Inclusive scan steps + //--------------------------------------------------------------------- + + /// Inclusive prefix scan step (specialized for summation across uint32 types) + __device__ __forceinline__ unsigned int InclusiveScanStep( + unsigned int input, ///< [in] Calling thread's input item. + cub::Sum scan_op, ///< [in] Binary scan operator + int first_lane, ///< [in] Index of first lane in segment + int offset) ///< [in] Up-offset to pull from + { + unsigned int output; + + // Use predicate set from SHFL to guard against invalid peers + asm( + "{" + " .reg .u32 r0;" + " .reg .pred p;" + " shfl.up.b32 r0|p, %1, %2, %3;" + " @p add.u32 r0, r0, %4;" + " mov.u32 %0, r0;" + "}" + : "=r"(output) : "r"(input), "r"(offset), "r"(first_lane), "r"(input)); + + return output; + } + + + /// Inclusive prefix scan step (specialized for summation across fp32 types) + __device__ __forceinline__ float InclusiveScanStep( + float input, ///< [in] Calling thread's input item. + cub::Sum scan_op, ///< [in] Binary scan operator + int first_lane, ///< [in] Index of first lane in segment + int offset) ///< [in] Up-offset to pull from + { + float output; + + // Use predicate set from SHFL to guard against invalid peers + asm( + "{" + " .reg .f32 r0;" + " .reg .pred p;" + " shfl.up.b32 r0|p, %1, %2, %3;" + " @p add.f32 r0, r0, %4;" + " mov.f32 %0, r0;" + "}" + : "=f"(output) : "f"(input), "r"(offset), "r"(first_lane), "f"(input)); + + return output; + } + + + /// Inclusive prefix scan step (specialized for summation across unsigned long long types) + __device__ __forceinline__ unsigned long long InclusiveScanStep( + unsigned long long input, ///< [in] Calling thread's input item. + cub::Sum scan_op, ///< [in] Binary scan operator + int first_lane, ///< [in] Index of first lane in segment + int offset) ///< [in] Up-offset to pull from + { + unsigned long long output; + + // Use predicate set from SHFL to guard against invalid peers + asm( + "{" + " .reg .u64 r0;" + " .reg .u32 lo;" + " .reg .u32 hi;" + " .reg .pred p;" + " mov.b64 {lo, hi}, %1;" + " shfl.up.b32 lo|p, lo, %2, %3;" + " shfl.up.b32 hi|p, hi, %2, %3;" + " mov.b64 r0, {lo, hi};" + " @p add.u64 r0, r0, %4;" + " mov.u64 %0, r0;" + "}" + : "=l"(output) : "l"(input), "r"(offset), "r"(first_lane), "l"(input)); + + return output; + } + + + /// Inclusive prefix scan step (specialized for summation across long long types) + __device__ __forceinline__ long long InclusiveScanStep( + long long input, ///< [in] Calling thread's input item. + cub::Sum scan_op, ///< [in] Binary scan operator + int first_lane, ///< [in] Index of first lane in segment + int offset) ///< [in] Up-offset to pull from + { + long long output; + + // Use predicate set from SHFL to guard against invalid peers + asm( + "{" + " .reg .s64 r0;" + " .reg .u32 lo;" + " .reg .u32 hi;" + " .reg .pred p;" + " mov.b64 {lo, hi}, %1;" + " shfl.up.b32 lo|p, lo, %2, %3;" + " shfl.up.b32 hi|p, hi, %2, %3;" + " mov.b64 r0, {lo, hi};" + " @p add.s64 r0, r0, %4;" + " mov.s64 %0, r0;" + "}" + : "=l"(output) : "l"(input), "r"(offset), "r"(first_lane), "l"(input)); + + return output; + } + + + /// Inclusive prefix scan step (specialized for summation across fp64 types) + __device__ __forceinline__ double InclusiveScanStep( + double input, ///< [in] Calling thread's input item. + cub::Sum scan_op, ///< [in] Binary scan operator + int first_lane, ///< [in] Index of first lane in segment + int offset) ///< [in] Up-offset to pull from + { + double output; +/* + // Use predicate set from SHFL to guard against invalid peers + asm( + "{" + " .reg .u32 lo;" + " .reg .u32 hi;" + " .reg .pred p;" + " .reg .f64 r0;" + " mov.b64 %0, %1;" + " mov.b64 {lo, hi}, %1;" + " shfl.up.b32 lo|p, lo, %2, %3;" + " shfl.up.b32 hi|p, hi, %2, %3;" + " mov.b64 r0, {lo, hi};" + " @p add.f64 %0, %0, r0;" + "}" + : "=d"(output) : "d"(input), "r"(offset), "r"(first_lane)); +*/ + + // Use predicate set from SHFL to guard against invalid peers + asm( + "{" + " .reg .f64 r0;" + " .reg .pred p;" + " {" + " .reg .u32 lo;" + " .reg .u32 hi;" + " mov.b64 {lo, hi}, %1;" + " shfl.up.b32 lo|p, lo, %2, %3;" + " shfl.up.b32 hi|p, hi, %2, %3;" + " mov.b64 r0, {lo, hi};" + " }" + " @p add.f64 r0, r0, %4;" + " mov.f64 %0, r0;" + "}" + : "=d"(output) : "d"(input), "r"(offset), "r"(first_lane), "d"(input), "d"(0.0)); + + return output; + } + + +/* + /// Inclusive prefix scan (specialized for ReduceBySegmentOp across KeyValuePair types) + template + __device__ __forceinline__ KeyValuePairInclusiveScanStep( + KeyValuePair input, ///< [in] Calling thread's input item. + ReduceBySegmentOp scan_op, ///< [in] Binary scan operator + int first_lane, ///< [in] Index of first lane in segment + int offset) ///< [in] Up-offset to pull from + { + KeyValuePair output; + + output.value = InclusiveScanStep(input.value, cub::Sum(), first_lane, offset, Int2Type::IS_SMALL_UNSIGNED>()); + output.key = InclusiveScanStep(input.offset, cub::Sum(), first_lane, offset, Int2Type::IS_SMALL_UNSIGNED>()); + + if (input.key > 0) + output.value = input.value; + + return output; + } +*/ + + /// Inclusive prefix scan step (generic) + template + __device__ __forceinline__ _T InclusiveScanStep( + _T input, ///< [in] Calling thread's input item. + ScanOp scan_op, ///< [in] Binary scan operator + int first_lane, ///< [in] Index of first lane in segment + int offset) ///< [in] Up-offset to pull from + { + _T output = input; + + _T temp = ShuffleUp(output, offset, first_lane); + + // Perform scan op if from a valid peer + if (lane_id >= offset) + output = scan_op(temp, output); + + return output; + } + + + /// Inclusive prefix scan step (specialized for small integers size 32b or less) + template + __device__ __forceinline__ _T InclusiveScanStep( + _T input, ///< [in] Calling thread's input item. + ScanOp scan_op, ///< [in] Binary scan operator + int first_lane, ///< [in] Index of first lane in segment + int offset, ///< [in] Up-offset to pull from + Int2Type is_small_unsigned) ///< [in] Marker type indicating whether T is a small integer + { + unsigned int temp = reinterpret_cast(input); + + temp = InclusiveScanStep(temp, scan_op, first_lane, offset); + + return reinterpret_cast<_T&>(temp); + } + + + /// Inclusive prefix scan step (specialized for types other than small integers size 32b or less) + template + __device__ __forceinline__ _T InclusiveScanStep( + _T input, ///< [in] Calling thread's input item. + ScanOp scan_op, ///< [in] Binary scan operator + int first_lane, ///< [in] Index of first lane in segment + int offset, ///< [in] Up-offset to pull from + Int2Type is_small_unsigned) ///< [in] Marker type indicating whether T is a small integer + { + return InclusiveScanStep(input, scan_op, first_lane, offset); + } + + //--------------------------------------------------------------------- + // Templated inclusive scan iteration + //--------------------------------------------------------------------- + + template + __device__ __forceinline__ void InclusiveScanStep( + _T& input, ///< [in] Calling thread's input item. + ScanOp scan_op, ///< [in] Binary scan operator + int first_lane, ///< [in] Index of first lane in segment + Int2Type step) ///< [in] Marker type indicating scan step + { + input = InclusiveScanStep(input, scan_op, first_lane, 1 << STEP, Int2Type::IS_SMALL_UNSIGNED>()); + + InclusiveScanStep(input, scan_op, first_lane, Int2Type()); + } + + template + __device__ __forceinline__ void InclusiveScanStep( + _T& input, ///< [in] Calling thread's input item. + ScanOp scan_op, ///< [in] Binary scan operator + int first_lane, ///< [in] Index of first lane in segment + Int2Type step) ///< [in] Marker type indicating scan step + {} + + + //--------------------------------------------------------------------- + // Get exclusive from inclusive + //--------------------------------------------------------------------- + + /// Get exclusive from inclusive (specialized for summation of integer types) + __device__ __forceinline__ T GetExclusive( + T input, + T inclusive, + cub::Sum scan_op, + Int2Type is_integer) + { + return inclusive - input; + } + + + /// Get exclusive from inclusive (specialized for scans other than summation of integer types) + template + __device__ __forceinline__ T GetExclusive( + T input, + T inclusive, + ScanOp scan_op, + Int2Type<_IS_INTEGER> is_integer) + { + return ShuffleUp(inclusive, 1); + } + + /// Get exclusive from inclusive (specialized for summation of integer types) + __device__ __forceinline__ T GetExclusive( + T input, + T inclusive, + T identity, + cub::Sum scan_op, + Int2Type is_integer) + { + return inclusive - input; + } + + + /// Get exclusive from inclusive (specialized for scans other than summation of integer types) + template + __device__ __forceinline__ T GetExclusive( + T input, + T inclusive, + T identity, + ScanOp scan_op, + Int2Type<_IS_INTEGER> is_integer) + { + T exclusive = ShuffleUp(inclusive, 1); + return (lane_id == 0) ? identity : exclusive; + } + + //--------------------------------------------------------------------- + // Broadcast + //--------------------------------------------------------------------- + + /// Broadcast + __device__ __forceinline__ T Broadcast( + T input, ///< [in] The value to broadcast + int src_lane) ///< [in] Which warp lane is to do the broadcasting + { + return ShuffleIndex(input, src_lane, LOGICAL_WARP_THREADS); + } + + //--------------------------------------------------------------------- + // Inclusive operations + //--------------------------------------------------------------------- + + /// Inclusive scan + template + __device__ __forceinline__ void InclusiveScan( + _T input, ///< [in] Calling thread's input item. + _T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op) ///< [in] Binary scan operator + { + output = input; + + // Iterate scan steps + InclusiveScanStep(output, scan_op, SHFL_C, Int2Type<0>()); +/* + // Iterate scan steps + #pragma unroll + for (int STEP = 0; STEP < STEPS; STEP++) + { + output = InclusiveScanStep(output, scan_op, SHFL_C, 1 << STEP, Int2Type::IS_SMALL_UNSIGNED>()); + } +*/ + } + + /// Inclusive scan, specialized for reduce-value-by-key + template + __device__ __forceinline__ void InclusiveScan( + KeyValuePair input, ///< [in] Calling thread's input item. + KeyValuePair& output, ///< [out] Calling thread's output item. May be aliased with \p input. + ReduceByKeyOp scan_op) ///< [in] Binary scan operator + { + output = input; + + KeyT pred_key = ShuffleUp(output.key, 1); + + unsigned int ballot = __ballot((pred_key != output.key)); + + // Mask away all lanes greater than ours + ballot = ballot & LaneMaskLe(); + + // Find index of first set bit + int first_lane = CUB_MAX(0, 31 - __clz(ballot)); + + // Iterate scan steps + InclusiveScanStep(output.value, scan_op.op, first_lane | SHFL_C, Int2Type<0>()); + +/* + // Iterate scan steps + #pragma unroll + for (int STEP = 0; STEP < STEPS; STEP++) + { + output.value = InclusiveScanStep(output.value, scan_op.op, first_lane | SHFL_C, 1 << STEP, Int2Type::IS_SMALL_UNSIGNED>()); + } +*/ + } + + /// Inclusive scan with aggregate + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op, ///< [in] Binary scan operator + T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items. + { + InclusiveScan(input, output, scan_op); + + // Grab aggregate from last warp lane + warp_aggregate = ShuffleIndex(output, LOGICAL_WARP_THREADS - 1, LOGICAL_WARP_THREADS); + } + + + //--------------------------------------------------------------------- + // Combo (inclusive & exclusive) operations + //--------------------------------------------------------------------- + + /// Combination scan without identity + template + __device__ __forceinline__ void Scan( + T input, ///< [in] Calling thread's input item. + T &inclusive_output, ///< [out] Calling thread's inclusive-scan output item. + T &exclusive_output, ///< [out] Calling thread's exclusive-scan output item. + ScanOp scan_op) ///< [in] Binary scan operator + { + // Compute inclusive scan + InclusiveScan(input, inclusive_output, scan_op); + + // Grab result from predecessor + exclusive_output = GetExclusive(input, inclusive_output, scan_op, Int2Type::IS_INTEGER>()); + } + + /// Combination scan with identity + template + __device__ __forceinline__ void Scan( + T input, ///< [in] Calling thread's input item. + T &inclusive_output, ///< [out] Calling thread's inclusive-scan output item. + T &exclusive_output, ///< [out] Calling thread's exclusive-scan output item. + T identity, ///< [in] Identity value + ScanOp scan_op) ///< [in] Binary scan operator + { + // Compute inclusive scan + InclusiveScan(input, inclusive_output, scan_op); + + // Grab result from predecessor + exclusive_output = GetExclusive(input, inclusive_output, identity, scan_op, Int2Type::IS_INTEGER>()); + } + + + //--------------------------------------------------------------------- + // Exclusive operations + //--------------------------------------------------------------------- + + /// Exclusive scan with aggregate + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + T identity, ///< [in] Identity value + ScanOp scan_op) ///< [in] Binary scan operator + { + T inclusive_output; + Scan(input, inclusive_output, output, identity, scan_op); + } + + + /// Exclusive scan with aggregate, without identity + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op) ///< [in] Binary scan operator + { + T inclusive_output; + Scan(input, inclusive_output, output, scan_op); + } + + + /// Exclusive scan with aggregate + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + T identity, ///< [in] Identity value + ScanOp scan_op, ///< [in] Binary scan operator + T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items. + { + T inclusive_output; + Scan(input, inclusive_output, output, identity, scan_op); + + // Grab aggregate from last warp lane + warp_aggregate = ShuffleIndex(inclusive_output, LOGICAL_WARP_THREADS - 1, LOGICAL_WARP_THREADS); + } + + + /// Exclusive scan with aggregate, without identity + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op, ///< [in] Binary scan operator + T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items. + { + T inclusive_output; + Scan(input, inclusive_output, output, scan_op); + + // Grab aggregate from last warp lane + warp_aggregate = ShuffleIndex(inclusive_output, LOGICAL_WARP_THREADS - 1, LOGICAL_WARP_THREADS); + } + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/warp/specializations/warp_scan_smem.cuh b/3rdparty/cub/cub/warp/specializations/warp_scan_smem.cuh new file mode 100644 index 00000000000..4a8fb7d8e41 --- /dev/null +++ b/3rdparty/cub/cub/warp/specializations/warp_scan_smem.cuh @@ -0,0 +1,403 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * cub::WarpScanSmem provides smem-based variants of parallel prefix scan of items partitioned across a CUDA thread warp. + */ + +#pragma once + +#include "../../thread/thread_operators.cuh" +#include "../../thread/thread_load.cuh" +#include "../../thread/thread_store.cuh" +#include "../../util_type.cuh" +#include "../../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \brief WarpScanSmem provides smem-based variants of parallel prefix scan of items partitioned across a CUDA thread warp. + */ +template < + typename T, ///< Data type being scanned + int LOGICAL_WARP_THREADS, ///< Number of threads per logical warp + int PTX_ARCH> ///< The PTX compute capability for which to to specialize this collective +struct WarpScanSmem +{ + /****************************************************************************** + * Constants and type definitions + ******************************************************************************/ + + enum + { + /// Whether the logical warp size and the PTX warp size coincide + IS_ARCH_WARP = (LOGICAL_WARP_THREADS == CUB_WARP_THREADS(PTX_ARCH)), + + /// The number of warp scan steps + STEPS = Log2::VALUE, + + /// The number of threads in half a warp + HALF_WARP_THREADS = 1 << (STEPS - 1), + + /// The number of shared memory elements per warp + WARP_SMEM_ELEMENTS = LOGICAL_WARP_THREADS + HALF_WARP_THREADS, + + /// Whether the data type is a primitive integer + IS_INTEGER = (Traits::CATEGORY == UNSIGNED_INTEGER) || (Traits::CATEGORY == SIGNED_INTEGER), + + }; + + /// Storage cell type (workaround for SM1x compiler bugs with custom-ops like Max() on signed chars) + typedef typename If<((Equals::VALUE || Equals::VALUE) && (PTX_ARCH < 200)), int, T>::Type CellT; + + /// Shared memory storage layout type (1.5 warps-worth of elements for each warp) + typedef CellT _TempStorage[WARP_SMEM_ELEMENTS]; + + // Alias wrapper allowing storage to be unioned + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + _TempStorage &temp_storage; + unsigned int lane_id; + + + /****************************************************************************** + * Construction + ******************************************************************************/ + + /// Constructor + __device__ __forceinline__ WarpScanSmem( + TempStorage &temp_storage) + : + temp_storage(temp_storage.Alias()), + lane_id(IS_ARCH_WARP ? + LaneId() : + LaneId() % LOGICAL_WARP_THREADS) + {} + + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + + /// Basic inclusive scan iteration (template unrolled, inductive-case specialization) + template < + bool HAS_IDENTITY, + int STEP, + typename ScanOp> + __device__ __forceinline__ void ScanStep( + T &partial, + ScanOp scan_op, + Int2Type step) + { + const int OFFSET = 1 << STEP; + + // Share partial into buffer + ThreadStore(&temp_storage[HALF_WARP_THREADS + lane_id], (CellT) partial); + + // Update partial if addend is in range + if (HAS_IDENTITY || (lane_id >= OFFSET)) + { + T addend = (T) ThreadLoad(&temp_storage[HALF_WARP_THREADS + lane_id - OFFSET]); + partial = scan_op(addend, partial); + } + + ScanStep(partial, scan_op, Int2Type()); + } + + + /// Basic inclusive scan iteration(template unrolled, base-case specialization) + template < + bool HAS_IDENTITY, + typename ScanOp> + __device__ __forceinline__ void ScanStep( + T &partial, + ScanOp scan_op, + Int2Type step) + {} + + + /// Inclusive prefix scan with identity + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + T identity, ///< [in] Identity value + ScanOp scan_op) ///< [in] Binary scan operator + { + ThreadStore(&temp_storage[lane_id], (CellT) identity); + + // Iterate scan steps + output = input; + ScanStep(output, scan_op, Int2Type<0>()); + } + + + /// Inclusive prefix scan (specialized for summation across primitive types) + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + Sum scan_op, ///< [in] Binary scan operator + Int2Type is_primitive) ///< [in] Marker type indicating whether T is primitive type + { + T identity = ZeroInitialize(); + InclusiveScan(input, output, identity, scan_op); + } + + + /// Inclusive prefix scan + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op, ///< [in] Binary scan operator + Int2Type is_primitive) ///< [in] Marker type indicating whether T is primitive type + { + // Iterate scan steps + output = input; + ScanStep(output, scan_op, Int2Type<0>()); + } + + + /// Get exclusive from inclusive (specialized for summation of integer types) + __device__ __forceinline__ T GetExclusive( + T input, + T inclusive, + Sum scan_op, + Int2Type is_integer) + { + return inclusive - input; + } + + + /// Get exclusive from inclusive (specialized for scans other than summation of integer types) + template + __device__ __forceinline__ T GetExclusive( + T input, + T inclusive, + ScanOp scan_op, + Int2Type<_IS_INTEGER> is_integer) + { + ThreadStore(&temp_storage[HALF_WARP_THREADS + lane_id], (CellT) inclusive); + return (T) ThreadLoad(&temp_storage[HALF_WARP_THREADS + lane_id - 1]); + } + + + /// Get exclusive from inclusive (specialized for summation of integer types) + __device__ __forceinline__ T GetExclusive( + T input, + T inclusive, + Sum scan_op, + T &warp_aggregate, + Int2Type is_integer) + { + ThreadStore(&temp_storage[HALF_WARP_THREADS + lane_id], (CellT) inclusive); + warp_aggregate = (T) ThreadLoad(&temp_storage[WARP_SMEM_ELEMENTS - 1]); + + return inclusive - input; + } + + + /// Get exclusive from inclusive (specialized for scans other than summation of integer types) + template + __device__ __forceinline__ T GetExclusive( + T input, + T inclusive, + ScanOp scan_op, + T &warp_aggregate, + Int2Type<_IS_INTEGER> is_integer) + { + ThreadStore(&temp_storage[HALF_WARP_THREADS + lane_id], (CellT) inclusive); + warp_aggregate = (T) ThreadLoad(&temp_storage[WARP_SMEM_ELEMENTS - 1]); + + return (T) ThreadLoad(&temp_storage[HALF_WARP_THREADS + lane_id - 1]); + } + + + /****************************************************************************** + * Interface + ******************************************************************************/ + + /// Broadcast + __device__ __forceinline__ T Broadcast( + T input, ///< [in] The value to broadcast + unsigned int src_lane) ///< [in] Which warp lane is to do the broadcasting + { + if (lane_id == src_lane) + { + ThreadStore(temp_storage, (CellT) input); + } + + return (T) ThreadLoad(temp_storage); + } + + + //--------------------------------------------------------------------- + // Inclusive operations + //--------------------------------------------------------------------- + + /// Inclusive scan + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op) ///< [in] Binary scan operator + { + InclusiveScan(input, output, scan_op, Int2Type::PRIMITIVE>()); + } + + + /// Inclusive scan with aggregate + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op, ///< [in] Binary scan operator + T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items. + { + InclusiveScan(input, output, scan_op); + + // Retrieve aggregate + ThreadStore(&temp_storage[HALF_WARP_THREADS + lane_id], (CellT) output); + warp_aggregate = (T) ThreadLoad(&temp_storage[WARP_SMEM_ELEMENTS - 1]); + } + + + //--------------------------------------------------------------------- + // Combo (inclusive & exclusive) operations + //--------------------------------------------------------------------- + + /// Combination scan without identity + template + __device__ __forceinline__ void Scan( + T input, ///< [in] Calling thread's input item. + T &inclusive_output, ///< [out] Calling thread's inclusive-scan output item. + T &exclusive_output, ///< [out] Calling thread's exclusive-scan output item. + ScanOp scan_op) ///< [in] Binary scan operator + { + // Compute inclusive scan + InclusiveScan(input, inclusive_output, scan_op); + + // Grab result from predecessor + exclusive_output = GetExclusive(input, inclusive_output, scan_op, Int2Type()); + } + + /// Combination scan with identity + template + __device__ __forceinline__ void Scan( + T input, ///< [in] Calling thread's input item. + T &inclusive_output, ///< [out] Calling thread's inclusive-scan output item. + T &exclusive_output, ///< [out] Calling thread's exclusive-scan output item. + T identity, ///< [in] Identity value + ScanOp scan_op) ///< [in] Binary scan operator + { + // Compute inclusive scan + InclusiveScan(input, inclusive_output, identity, scan_op); + + // Grab result from predecessor + exclusive_output = GetExclusive(input, inclusive_output, scan_op, Int2Type()); + } + + + //--------------------------------------------------------------------- + // Exclusive operations + //--------------------------------------------------------------------- + + /// Exclusive scan + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + T identity, ///< [in] Identity value + ScanOp scan_op) ///< [in] Binary scan operator + { + T inclusive_output; + Scan(input, inclusive_output, output, identity, scan_op); + } + + + /// Exclusive scan without identity + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op) ///< [in] Binary scan operator + { + T inclusive_output; + Scan(input, inclusive_output, output, scan_op); + } + + /// Exclusive scan with aggregate + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + T identity, ///< [in] Identity value + ScanOp scan_op, ///< [in] Binary scan operator + T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items. + { + // Compute inclusive scan + T inclusive_output; + InclusiveScan(input, inclusive_output, identity, scan_op); + + // Grab result from predecessor + output = GetExclusive(input, inclusive_output, scan_op, warp_aggregate, Int2Type()); + } + + + /// Exclusive scan with aggregate, without identity + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op, ///< [in] Binary scan operator + T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items. + { + // Compute inclusive scan + T inclusive_output; + InclusiveScan(input, inclusive_output, scan_op); + + // Grab result from predecessor + output = GetExclusive(input, inclusive_output, scan_op, warp_aggregate, Int2Type()); + } + + +}; + + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/warp/warp_reduce.cuh b/3rdparty/cub/cub/warp/warp_reduce.cuh new file mode 100644 index 00000000000..59a813b6538 --- /dev/null +++ b/3rdparty/cub/cub/warp/warp_reduce.cuh @@ -0,0 +1,612 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * The cub::WarpReduce class provides [collective](index.html#sec0) methods for computing a parallel reduction of items partitioned across a CUDA thread warp. + */ + +#pragma once + +#include "specializations/warp_reduce_shfl.cuh" +#include "specializations/warp_reduce_smem.cuh" +#include "../thread/thread_operators.cuh" +#include "../util_arch.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + + +/** + * \addtogroup WarpModule + * @{ + */ + +/** + * \brief The WarpReduce class provides [collective](index.html#sec0) methods for computing a parallel reduction of items partitioned across a CUDA thread warp. ![](warp_reduce_logo.png) + * + * \tparam T The reduction input/output element type + * \tparam LOGICAL_WARP_THREADS [optional] The number of threads per "logical" warp (may be less than the number of hardware warp threads). Default is the warp size of the targeted CUDA compute-capability (e.g., 32 threads for SM20). + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * - A reduction (or fold) + * uses a binary combining operator to compute a single aggregate from a list of input elements. + * - Supports "logical" warps smaller than the physical warp size (e.g., logical warps of 8 threads) + * - The number of entrant threads must be an multiple of \p LOGICAL_WARP_THREADS + * + * \par Performance Considerations + * - Uses special instructions when applicable (e.g., warp \p SHFL instructions) + * - Uses synchronization-free communication between warp lanes when applicable + * - Incurs zero bank conflicts for most types + * - Computation is slightly more efficient (i.e., having lower instruction overhead) for: + * - Summation (vs. generic reduction) + * - The architecture's warp size is a whole multiple of \p LOGICAL_WARP_THREADS + * + * \par Simple Examples + * \warpcollective{WarpReduce} + * \par + * The code snippet below illustrates four concurrent warp sum reductions within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpReduce for type int + * typedef cub::WarpReduce WarpReduce; + * + * // Allocate WarpReduce shared memory for 4 warps + * __shared__ typename WarpReduce::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Return the warp-wide sums to each lane0 (threads 0, 32, 64, and 96) + * int warp_id = threadIdx.x / 32; + * int aggregate = WarpReduce(temp_storage[warp_id]).Sum(thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, 1, 2, 3, ..., 127}. + * The corresponding output \p aggregate in threads 0, 32, 64, and 96 will \p 496, \p 1520, + * \p 2544, and \p 3568, respectively (and is undefined in other threads). + * + * \par + * The code snippet below illustrates a single warp sum reduction within a block of + * 128 threads. + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpReduce for type int + * typedef cub::WarpReduce WarpReduce; + * + * // Allocate WarpReduce shared memory for one warp + * __shared__ typename WarpReduce::TempStorage temp_storage; + * ... + * + * // Only the first warp performs a reduction + * if (threadIdx.x < 32) + * { + * // Obtain one input item per thread + * int thread_data = ... + * + * // Return the warp-wide sum to lane0 + * int aggregate = WarpReduce(temp_storage).Sum(thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the warp of threads is {0, 1, 2, 3, ..., 31}. + * The corresponding output \p aggregate in thread0 will be \p 496 (and is undefined in other threads). + * + */ +template < + typename T, + int LOGICAL_WARP_THREADS = CUB_PTX_WARP_THREADS, + int PTX_ARCH = CUB_PTX_ARCH> +class WarpReduce +{ +private: + + /****************************************************************************** + * Constants and type definitions + ******************************************************************************/ + + enum + { + /// Whether the logical warp size and the PTX warp size coincide + IS_ARCH_WARP = (LOGICAL_WARP_THREADS == CUB_WARP_THREADS(PTX_ARCH)), + + /// Whether the logical warp size is a power-of-two + IS_POW_OF_TWO = PowerOfTwo::VALUE, + }; + +public: + + #ifndef DOXYGEN_SHOULD_SKIP_THIS // Do not document + + /// Internal specialization. Use SHFL-based reduction if (architecture is >= SM30) and (LOGICAL_WARP_THREADS is a power-of-two) + typedef typename If<(PTX_ARCH >= 300) && (IS_POW_OF_TWO), + WarpReduceShfl, + WarpReduceSmem >::Type InternalWarpReduce; + + #endif // DOXYGEN_SHOULD_SKIP_THIS + + +private: + + /// Shared memory storage layout type for WarpReduce + typedef typename InternalWarpReduce::TempStorage _TempStorage; + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Shared storage reference + _TempStorage &temp_storage; + + + /****************************************************************************** + * Utility methods + ******************************************************************************/ + +public: + + /// \smemstorage{WarpReduce} + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. Logical warp and lane identifiers are constructed from threadIdx.x. + */ + __device__ __forceinline__ WarpReduce( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()) + {} + + + //@} end member group + /******************************************************************//** + * \name Summation reductions + *********************************************************************/ + //@{ + + + /** + * \brief Computes a warp-wide sum in the calling warp. The output is valid in warp lane0. + * + * \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp sum reductions within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpReduce for type int + * typedef cub::WarpReduce WarpReduce; + * + * // Allocate WarpReduce shared memory for 4 warps + * __shared__ typename WarpReduce::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Return the warp-wide sums to each lane0 + * int warp_id = threadIdx.x / 32; + * int aggregate = WarpReduce(temp_storage[warp_id]).Sum(thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, 1, 2, 3, ..., 127}. + * The corresponding output \p aggregate in threads 0, 32, 64, and 96 will \p 496, \p 1520, + * \p 2544, and \p 3568, respectively (and is undefined in other threads). + * + */ + __device__ __forceinline__ T Sum( + T input) ///< [in] Calling thread's input + { + return InternalWarpReduce(temp_storage).Reduce(input, LOGICAL_WARP_THREADS, cub::Sum()); + } + + /** + * \brief Computes a partially-full warp-wide sum in the calling warp. The output is valid in warp lane0. + * + * All threads across the calling warp must agree on the same value for \p valid_items. Otherwise the result is undefined. + * + * \smemreuse + * + * \par Snippet + * The code snippet below illustrates a sum reduction within a single, partially-full + * block of 32 threads (one warp). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(int *d_data, int valid_items) + * { + * // Specialize WarpReduce for type int + * typedef cub::WarpReduce WarpReduce; + * + * // Allocate WarpReduce shared memory for one warp + * __shared__ typename WarpReduce::TempStorage temp_storage; + * + * // Obtain one input item per thread if in range + * int thread_data; + * if (threadIdx.x < valid_items) + * thread_data = d_data[threadIdx.x]; + * + * // Return the warp-wide sums to each lane0 + * int aggregate = WarpReduce(temp_storage).Sum( + * thread_data, valid_items); + * + * \endcode + * \par + * Suppose the input \p d_data is {0, 1, 2, 3, 4, ... and \p valid_items + * is \p 4. The corresponding output \p aggregate in thread0 is \p 6 (and is + * undefined in other threads). + * + */ + __device__ __forceinline__ T Sum( + T input, ///< [in] Calling thread's input + int valid_items) ///< [in] Total number of valid items in the calling thread's logical warp (may be less than \p LOGICAL_WARP_THREADS) + { + // Determine if we don't need bounds checking + return InternalWarpReduce(temp_storage).Reduce(input, valid_items, cub::Sum()); + } + + + /** + * \brief Computes a segmented sum in the calling warp where segments are defined by head-flags. The sum of each segment is returned to the first lane in that segment (which always includes lane0). + * + * \smemreuse + * + * \par Snippet + * The code snippet below illustrates a head-segmented warp sum + * reduction within a block of 32 threads (one warp). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpReduce for type int + * typedef cub::WarpReduce WarpReduce; + * + * // Allocate WarpReduce shared memory for one warp + * __shared__ typename WarpReduce::TempStorage temp_storage; + * + * // Obtain one input item and flag per thread + * int thread_data = ... + * int head_flag = ... + * + * // Return the warp-wide sums to each lane0 + * int aggregate = WarpReduce(temp_storage).HeadSegmentedSum( + * thread_data, head_flag); + * + * \endcode + * \par + * Suppose the set of input \p thread_data and \p head_flag across the block of threads + * is {0, 1, 2, 3, ..., 31 and is {1, 0, 0, 0, 1, 0, 0, 0, ..., 1, 0, 0, 0, + * respectively. The corresponding output \p aggregate in threads 0, 4, 8, etc. will be + * \p 6, \p 22, \p 38, etc. (and is undefined in other threads). + * + * \tparam ReductionOp [inferred] Binary reduction operator type having member T operator()(const T &a, const T &b) + * + */ + template < + typename FlagT> + __device__ __forceinline__ T HeadSegmentedSum( + T input, ///< [in] Calling thread's input + FlagT head_flag) ///< [in] Head flag denoting whether or not \p input is the start of a new segment + { + return HeadSegmentedReduce(input, head_flag, cub::Sum()); + } + + + /** + * \brief Computes a segmented sum in the calling warp where segments are defined by tail-flags. The sum of each segment is returned to the first lane in that segment (which always includes lane0). + * + * \smemreuse + * + * \par Snippet + * The code snippet below illustrates a tail-segmented warp sum + * reduction within a block of 32 threads (one warp). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpReduce for type int + * typedef cub::WarpReduce WarpReduce; + * + * // Allocate WarpReduce shared memory for one warp + * __shared__ typename WarpReduce::TempStorage temp_storage; + * + * // Obtain one input item and flag per thread + * int thread_data = ... + * int tail_flag = ... + * + * // Return the warp-wide sums to each lane0 + * int aggregate = WarpReduce(temp_storage).TailSegmentedSum( + * thread_data, tail_flag); + * + * \endcode + * \par + * Suppose the set of input \p thread_data and \p tail_flag across the block of threads + * is {0, 1, 2, 3, ..., 31 and is {0, 0, 0, 1, 0, 0, 0, 1, ..., 0, 0, 0, 1, + * respectively. The corresponding output \p aggregate in threads 0, 4, 8, etc. will be + * \p 6, \p 22, \p 38, etc. (and is undefined in other threads). + * + * \tparam ReductionOp [inferred] Binary reduction operator type having member T operator()(const T &a, const T &b) + */ + template < + typename FlagT> + __device__ __forceinline__ T TailSegmentedSum( + T input, ///< [in] Calling thread's input + FlagT tail_flag) ///< [in] Head flag denoting whether or not \p input is the start of a new segment + { + return TailSegmentedReduce(input, tail_flag, cub::Sum()); + } + + + + //@} end member group + /******************************************************************//** + * \name Generic reductions + *********************************************************************/ + //@{ + + /** + * \brief Computes a warp-wide reduction in the calling warp using the specified binary reduction functor. The output is valid in warp lane0. + * + * Supports non-commutative reduction operators + * + * \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp max reductions within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpReduce for type int + * typedef cub::WarpReduce WarpReduce; + * + * // Allocate WarpReduce shared memory for 4 warps + * __shared__ typename WarpReduce::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Return the warp-wide reductions to each lane0 + * int warp_id = threadIdx.x / 32; + * int aggregate = WarpReduce(temp_storage[warp_id]).Reduce( + * thread_data, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, 1, 2, 3, ..., 127}. + * The corresponding output \p aggregate in threads 0, 32, 64, and 96 will \p 31, \p 63, + * \p 95, and \p 127, respectively (and is undefined in other threads). + * + * \tparam ReductionOp [inferred] Binary reduction operator type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ T Reduce( + T input, ///< [in] Calling thread's input + ReductionOp reduction_op) ///< [in] Binary reduction operator + { + return InternalWarpReduce(temp_storage).Reduce(input, LOGICAL_WARP_THREADS, reduction_op); + } + + /** + * \brief Computes a partially-full warp-wide reduction in the calling warp using the specified binary reduction functor. The output is valid in warp lane0. + * + * All threads across the calling warp must agree on the same value for \p valid_items. Otherwise the result is undefined. + * + * Supports non-commutative reduction operators + * + * \smemreuse + * + * \par Snippet + * The code snippet below illustrates a max reduction within a single, partially-full + * block of 32 threads (one warp). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(int *d_data, int valid_items) + * { + * // Specialize WarpReduce for type int + * typedef cub::WarpReduce WarpReduce; + * + * // Allocate WarpReduce shared memory for one warp + * __shared__ typename WarpReduce::TempStorage temp_storage; + * + * // Obtain one input item per thread if in range + * int thread_data; + * if (threadIdx.x < valid_items) + * thread_data = d_data[threadIdx.x]; + * + * // Return the warp-wide reductions to each lane0 + * int aggregate = WarpReduce(temp_storage).Reduce( + * thread_data, cub::Max(), valid_items); + * + * \endcode + * \par + * Suppose the input \p d_data is {0, 1, 2, 3, 4, ... and \p valid_items + * is \p 4. The corresponding output \p aggregate in thread0 is \p 3 (and is + * undefined in other threads). + * + * \tparam ReductionOp [inferred] Binary reduction operator type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ T Reduce( + T input, ///< [in] Calling thread's input + ReductionOp reduction_op, ///< [in] Binary reduction operator + int valid_items) ///< [in] Total number of valid items in the calling thread's logical warp (may be less than \p LOGICAL_WARP_THREADS) + { + return InternalWarpReduce(temp_storage).Reduce(input, valid_items, reduction_op); + } + + + /** + * \brief Computes a segmented reduction in the calling warp where segments are defined by head-flags. The reduction of each segment is returned to the first lane in that segment (which always includes lane0). + * + * Supports non-commutative reduction operators + * + * \smemreuse + * + * \par Snippet + * The code snippet below illustrates a head-segmented warp max + * reduction within a block of 32 threads (one warp). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpReduce for type int + * typedef cub::WarpReduce WarpReduce; + * + * // Allocate WarpReduce shared memory for one warp + * __shared__ typename WarpReduce::TempStorage temp_storage; + * + * // Obtain one input item and flag per thread + * int thread_data = ... + * int head_flag = ... + * + * // Return the warp-wide reductions to each lane0 + * int aggregate = WarpReduce(temp_storage).HeadSegmentedReduce( + * thread_data, head_flag, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data and \p head_flag across the block of threads + * is {0, 1, 2, 3, ..., 31 and is {1, 0, 0, 0, 1, 0, 0, 0, ..., 1, 0, 0, 0, + * respectively. The corresponding output \p aggregate in threads 0, 4, 8, etc. will be + * \p 3, \p 7, \p 11, etc. (and is undefined in other threads). + * + * \tparam ReductionOp [inferred] Binary reduction operator type having member T operator()(const T &a, const T &b) + */ + template < + typename ReductionOp, + typename FlagT> + __device__ __forceinline__ T HeadSegmentedReduce( + T input, ///< [in] Calling thread's input + FlagT head_flag, ///< [in] Head flag denoting whether or not \p input is the start of a new segment + ReductionOp reduction_op) ///< [in] Reduction operator + { + return InternalWarpReduce(temp_storage).template SegmentedReduce(input, head_flag, reduction_op); + } + + + /** + * \brief Computes a segmented reduction in the calling warp where segments are defined by tail-flags. The reduction of each segment is returned to the first lane in that segment (which always includes lane0). + * + * Supports non-commutative reduction operators + * + * \smemreuse + * + * \par Snippet + * The code snippet below illustrates a tail-segmented warp max + * reduction within a block of 32 threads (one warp). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpReduce for type int + * typedef cub::WarpReduce WarpReduce; + * + * // Allocate WarpReduce shared memory for one warp + * __shared__ typename WarpReduce::TempStorage temp_storage; + * + * // Obtain one input item and flag per thread + * int thread_data = ... + * int tail_flag = ... + * + * // Return the warp-wide reductions to each lane0 + * int aggregate = WarpReduce(temp_storage).TailSegmentedReduce( + * thread_data, tail_flag, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data and \p tail_flag across the block of threads + * is {0, 1, 2, 3, ..., 31 and is {0, 0, 0, 1, 0, 0, 0, 1, ..., 0, 0, 0, 1, + * respectively. The corresponding output \p aggregate in threads 0, 4, 8, etc. will be + * \p 3, \p 7, \p 11, etc. (and is undefined in other threads). + * + * \tparam ReductionOp [inferred] Binary reduction operator type having member T operator()(const T &a, const T &b) + */ + template < + typename ReductionOp, + typename FlagT> + __device__ __forceinline__ T TailSegmentedReduce( + T input, ///< [in] Calling thread's input + FlagT tail_flag, ///< [in] Tail flag denoting whether or not \p input is the end of the current segment + ReductionOp reduction_op) ///< [in] Reduction operator + { + return InternalWarpReduce(temp_storage).template SegmentedReduce(input, tail_flag, reduction_op); + } + + + + //@} end member group +}; + +/** @} */ // end group WarpModule + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/3rdparty/cub/cub/warp/warp_scan.cuh b/3rdparty/cub/cub/warp/warp_scan.cuh new file mode 100644 index 00000000000..6d7621ee6b4 --- /dev/null +++ b/3rdparty/cub/cub/warp/warp_scan.cuh @@ -0,0 +1,924 @@ +/****************************************************************************** + * Copyright (c) 2011, Duane Merrill. All rights reserved. + * Copyright (c) 2011-2015, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the NVIDIA CORPORATION nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ******************************************************************************/ + +/** + * \file + * The cub::WarpScan class provides [collective](index.html#sec0) methods for computing a parallel prefix scan of items partitioned across a CUDA thread warp. + */ + +#pragma once + +#include "specializations/warp_scan_shfl.cuh" +#include "specializations/warp_scan_smem.cuh" +#include "../thread/thread_operators.cuh" +#include "../util_arch.cuh" +#include "../util_type.cuh" +#include "../util_namespace.cuh" + +/// Optional outer namespace(s) +CUB_NS_PREFIX + +/// CUB namespace +namespace cub { + +/** + * \addtogroup WarpModule + * @{ + */ + +/** + * \brief The WarpScan class provides [collective](index.html#sec0) methods for computing a parallel prefix scan of items partitioned across a CUDA thread warp. ![](warp_scan_logo.png) + * + * \tparam T The scan input/output element type + * \tparam LOGICAL_WARP_THREADS [optional] The number of threads per "logical" warp (may be less than the number of hardware warp threads). Default is the warp size associated with the CUDA Compute Capability targeted by the compiler (e.g., 32 threads for SM20). + * \tparam PTX_ARCH [optional] \ptxversion + * + * \par Overview + * - Given a list of input elements and a binary reduction operator, a [prefix scan](http://en.wikipedia.org/wiki/Prefix_sum) + * produces an output list where each element is computed to be the reduction + * of the elements occurring earlier in the input list. Prefix sum + * connotes a prefix scan with the addition operator. The term \em inclusive indicates + * that the ith output reduction incorporates the ith input. + * The term \em exclusive indicates the ith input is not incorporated into + * the ith output reduction. + * - Supports non-commutative scan operators + * - Supports "logical" warps smaller than the physical warp size (e.g., a logical warp of 8 threads) + * - The number of entrant threads must be an multiple of \p LOGICAL_WARP_THREADS + * + * \par Performance Considerations + * - Uses special instructions when applicable (e.g., warp \p SHFL) + * - Uses synchronization-free communication between warp lanes when applicable + * - Incurs zero bank conflicts for most types + * - Computation is slightly more efficient (i.e., having lower instruction overhead) for: + * - Summation (vs. generic scan) + * - The architecture's warp size is a whole multiple of \p LOGICAL_WARP_THREADS + * + * \par Simple Examples + * \warpcollective{WarpScan} + * \par + * The code snippet below illustrates four concurrent warp prefix sums within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute warp-wide prefix sums + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).ExclusiveSum(thread_data, thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {1, 1, 1, 1, ...}. + * The corresponding output \p thread_data in each of the four warps of threads will be + * 0, 1, 2, 3, ..., 31}. + * + * \par + * The code snippet below illustrates a single warp prefix sum within a block of + * 128 threads. + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for one warp + * __shared__ typename WarpScan::TempStorage temp_storage; + * ... + * + * // Only the first warp performs a prefix sum + * if (threadIdx.x < 32) + * { + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute warp-wide prefix sums + * WarpScan(temp_storage).ExclusiveSum(thread_data, thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the warp of threads is {1, 1, 1, 1, ...}. + * The corresponding output \p thread_data will be {0, 1, 2, 3, ..., 31}. + * + */ +template < + typename T, + int LOGICAL_WARP_THREADS = CUB_PTX_WARP_THREADS, + int PTX_ARCH = CUB_PTX_ARCH> +class WarpScan +{ +private: + + /****************************************************************************** + * Constants and type definitions + ******************************************************************************/ + + enum + { + /// Whether the logical warp size and the PTX warp size coincide + IS_ARCH_WARP = (LOGICAL_WARP_THREADS == CUB_WARP_THREADS(PTX_ARCH)), + + /// Whether the logical warp size is a power-of-two + IS_POW_OF_TWO = ((LOGICAL_WARP_THREADS & (LOGICAL_WARP_THREADS - 1)) == 0), + + /// Whether the data type is an integer (which has fully-associative addition) + IS_INTEGER = ((Traits::CATEGORY == SIGNED_INTEGER) || (Traits::CATEGORY == UNSIGNED_INTEGER)) + }; + + /// Internal specialization. Use SHFL-based scan if (architecture is >= SM30) and (LOGICAL_WARP_THREADS is a power-of-two) + typedef typename If<(PTX_ARCH >= 300) && (IS_POW_OF_TWO), + WarpScanShfl, + WarpScanSmem >::Type InternalWarpScan; + + /// Shared memory storage layout type for WarpScan + typedef typename InternalWarpScan::TempStorage _TempStorage; + + + /****************************************************************************** + * Thread fields + ******************************************************************************/ + + /// Shared storage reference + _TempStorage &temp_storage; + int lane_id; + + + + /****************************************************************************** + * Public types + ******************************************************************************/ + +public: + + /// \smemstorage{WarpScan} + struct TempStorage : Uninitialized<_TempStorage> {}; + + + /******************************************************************//** + * \name Collective constructors + *********************************************************************/ + //@{ + + /** + * \brief Collective constructor using the specified memory allocation as temporary storage. Logical warp and lane identifiers are constructed from threadIdx.x. + */ + __device__ __forceinline__ WarpScan( + TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage + : + temp_storage(temp_storage.Alias()), + lane_id(IS_ARCH_WARP ? + LaneId() : + LaneId() % LOGICAL_WARP_THREADS) + {} + + + //@} end member group + /******************************************************************//** + * \name Inclusive prefix sums + *********************************************************************/ + //@{ + + + /** + * \brief Computes an inclusive prefix sum across the calling warp. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide inclusive prefix sums within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute inclusive warp-wide prefix sums + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).InclusiveSum(thread_data, thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {1, 1, 1, 1, ...}. + * The corresponding output \p thread_data in each of the four warps of threads will be + * 1, 2, 3, ..., 32}. + */ + __device__ __forceinline__ void InclusiveSum( + T input, ///< [in] Calling thread's input item. + T &output) ///< [out] Calling thread's output item. May be aliased with \p input. + { + InternalWarpScan(temp_storage).InclusiveScan(input, output, cub::Sum()); + } + + + /** + * \brief Computes an inclusive prefix sum across the calling warp. Also provides every thread with the warp-wide \p warp_aggregate of all inputs. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide inclusive prefix sums within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute inclusive warp-wide prefix sums + * int warp_aggregate; + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).InclusiveSum(thread_data, thread_data, warp_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {1, 1, 1, 1, ...}. + * The corresponding output \p thread_data in each of the four warps of threads will be + * 1, 2, 3, ..., 32}. Furthermore, \p warp_aggregate for all threads in all warps will be \p 32. + */ + __device__ __forceinline__ void InclusiveSum( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items. + { + InternalWarpScan(temp_storage).InclusiveScan(input, output, cub::Sum(), warp_aggregate); + } + + + //@} end member group + /******************************************************************//** + * \name Exclusive prefix sums + *********************************************************************/ + //@{ + + + /** + * \brief Computes an exclusive prefix sum across the calling warp. + * + * \par + * - \identityzero + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide exclusive prefix sums within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute exclusive warp-wide prefix sums + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).ExclusiveSum(thread_data, thread_data); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {1, 1, 1, 1, ...}. + * The corresponding output \p thread_data in each of the four warps of threads will be + * 0, 1, 2, ..., 31}. + * + */ + __device__ __forceinline__ void ExclusiveSum( + T input, ///< [in] Calling thread's input item. + T &output) ///< [out] Calling thread's output item. May be aliased with \p input. + { + InternalWarpScan(temp_storage).ExclusiveScan(input, output, ZeroInitialize(), cub::Sum()); + } + + + /** + * \brief Computes an exclusive prefix sum across the calling warp. Also provides every thread with the warp-wide \p warp_aggregate of all inputs. + * + * \par + * - \identityzero + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide exclusive prefix sums within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute exclusive warp-wide prefix sums + * int warp_aggregate; + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).ExclusiveSum(thread_data, thread_data, warp_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {1, 1, 1, 1, ...}. + * The corresponding output \p thread_data in each of the four warps of threads will be + * 0, 1, 2, ..., 31}. Furthermore, \p warp_aggregate for all threads in all warps will be \p 32. + */ + __device__ __forceinline__ void ExclusiveSum( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items. + { + InternalWarpScan(temp_storage).ExclusiveScan(input, output, ZeroInitialize(), cub::Sum(), warp_aggregate); + } + + + //@} end member group + /******************************************************************//** + * \name Inclusive prefix scans + *********************************************************************/ + //@{ + + /** + * \brief Computes an inclusive prefix scan using the specified binary scan functor across the calling warp. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide inclusive prefix max scans within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute inclusive warp-wide prefix max scans + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).InclusiveScan(thread_data, thread_data, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, -1, 2, -3, ..., 126, -127}. + * The corresponding output \p thread_data in the first warp would be + * 0, 0, 2, 2, ..., 30, 30, the output for the second warp would be 32, 32, 34, 34, ..., 62, 62, etc. + * + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op) ///< [in] Binary scan operator + { + InternalWarpScan(temp_storage).InclusiveScan(input, output, scan_op); + } + + + /** + * \brief Computes an inclusive prefix scan using the specified binary scan functor across the calling warp. Also provides every thread with the warp-wide \p warp_aggregate of all inputs. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide inclusive prefix max scans within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute inclusive warp-wide prefix max scans + * int warp_aggregate; + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).InclusiveScan( + * thread_data, thread_data, cub::Max(), warp_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, -1, 2, -3, ..., 126, -127}. + * The corresponding output \p thread_data in the first warp would be + * 0, 0, 2, 2, ..., 30, 30, the output for the second warp would be 32, 32, 34, 34, ..., 62, 62, etc. + * Furthermore, \p warp_aggregate would be assigned \p 30 for threads in the first warp, \p 62 for threads + * in the second warp, etc. + * + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void InclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op, ///< [in] Binary scan operator + T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items. + { + InternalWarpScan(temp_storage).InclusiveScan(input, output, scan_op, warp_aggregate); + } + + + //@} end member group + /******************************************************************//** + * \name Exclusive prefix scans + *********************************************************************/ + //@{ + + /** + * \brief Computes an exclusive prefix scan using the specified binary scan functor across the calling warp. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide exclusive prefix max scans within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute exclusive warp-wide prefix max scans + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).ExclusiveScan(thread_data, thread_data, INT_MIN, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, -1, 2, -3, ..., 126, -127}. + * The corresponding output \p thread_data in the first warp would be + * INT_MIN, 0, 0, 2, ..., 28, 30, the output for the second warp would be 30, 32, 32, 34, ..., 60, 62, etc. + * + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + T identity, ///< [in] Identity value + ScanOp scan_op) ///< [in] Binary scan operator + { + InternalWarpScan(temp_storage).ExclusiveScan(input, output, identity, scan_op); + } + + + /** + * \brief Computes an exclusive prefix scan using the specified binary scan functor across the calling warp. Also provides every thread with the warp-wide \p warp_aggregate of all inputs. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide exclusive prefix max scans within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute exclusive warp-wide prefix max scans + * int warp_aggregate; + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).ExclusiveScan(thread_data, thread_data, INT_MIN, cub::Max(), warp_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, -1, 2, -3, ..., 126, -127}. + * The corresponding output \p thread_data in the first warp would be + * INT_MIN, 0, 0, 2, ..., 28, 30, the output for the second warp would be 30, 32, 32, 34, ..., 60, 62, etc. + * Furthermore, \p warp_aggregate would be assigned \p 30 for threads in the first warp, \p 62 for threads + * in the second warp, etc. + * + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + T identity, ///< [in] Identity value + ScanOp scan_op, ///< [in] Binary scan operator + T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items. + { + InternalWarpScan(temp_storage).ExclusiveScan(input, output, identity, scan_op, warp_aggregate); + } + + + //@} end member group + /******************************************************************//** + * \name Identityless exclusive prefix scans + *********************************************************************/ + //@{ + + + /** + * \brief Computes an exclusive prefix scan using the specified binary scan functor across the calling warp. Because no identity value is supplied, the \p output computed for warp-lane0 is undefined. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide exclusive prefix max scans within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute exclusive warp-wide prefix max scans + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).ExclusiveScan(thread_data, thread_data, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, -1, 2, -3, ..., 126, -127}. + * The corresponding output \p thread_data in the first warp would be + * ?, 0, 0, 2, ..., 28, 30, the output for the second warp would be ?, 32, 32, 34, ..., 60, 62, etc. + * (The output \p thread_data in warp lane0 is undefined.) + * + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op) ///< [in] Binary scan operator + { + InternalWarpScan(temp_storage).ExclusiveScan(input, output, scan_op); + } + + + /** + * \brief Computes an exclusive prefix scan using the specified binary scan functor across the calling warp. Because no identity value is supplied, the \p output computed for warp-lane0 is undefined. Also provides every thread with the warp-wide \p warp_aggregate of all inputs. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide exclusive prefix max scans within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute exclusive warp-wide prefix max scans + * int warp_aggregate; + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).ExclusiveScan(thread_data, thread_data, cub::Max(), warp_aggregate); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, -1, 2, -3, ..., 126, -127}. + * The corresponding output \p thread_data in the first warp would be + * ?, 0, 0, 2, ..., 28, 30, the output for the second warp would be ?, 32, 32, 34, ..., 60, 62, etc. + * (The output \p thread_data in warp lane0 is undefined.) Furthermore, \p warp_aggregate would be assigned \p 30 for threads in the first warp, \p 62 for threads + * in the second warp, etc. + * + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void ExclusiveScan( + T input, ///< [in] Calling thread's input item. + T &output, ///< [out] Calling thread's output item. May be aliased with \p input. + ScanOp scan_op, ///< [in] Binary scan operator + T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items. + { + InternalWarpScan(temp_storage).ExclusiveScan(input, output, scan_op, warp_aggregate); + } + + + + //@} end member group + /******************************************************************//** + * \name Combination (inclusive & exclusive) prefix scans + *********************************************************************/ + //@{ + + /** + * \brief Computes both inclusive and exclusive prefix sums across the calling warp. + * + * \par + * - \identityzero + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide prefix sums within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute in|exclusive warp-wide prefix sums + * int inclusive_partial, exclusive_partial; + * int warp_id = threadIdx.x / 32; + * WarpScan(temp_storage[warp_id]).Sum(thread_data, inclusive_partial, exclusive_partial); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {1, 1, 1, 1, ...}. + * The corresponding output \p inclusive_partial in each of the four warps of threads will be + * 1, 2, 3, ..., 32}. + * The corresponding output \p exclusive_partial in each of the four warps of threads will be + * 0, 1, 2, ..., 31}. + * + */ + __device__ __forceinline__ void Sum( + T input, ///< [in] Calling thread's input item. + T &inclusive_output, ///< [out] Calling thread's inclusive-scan output item. + T &exclusive_output) ///< [out] Calling thread's exclusive-scan output item. + { + InternalWarpScan(temp_storage).Scan(input, inclusive_output, exclusive_output, ZeroInitialize(), cub::Sum()); + } + + + /** + * \brief Computes both inclusive and exclusive prefix scans using the specified binary scan functor across the calling warp. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide prefix max scans within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute inclusive warp-wide prefix max scans + * int warp_id = threadIdx.x / 32; + * int inclusive_partial, exclusive_partial; + * WarpScan(temp_storage[warp_id]).Scan(thread_data, inclusive_partial, exclusive_partial, INT_MIN, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, -1, 2, -3, ..., 126, -127}. + * The corresponding output \p inclusive_partial in the first warp would be + * 0, 0, 2, 2, ..., 30, 30, the output for the second warp would be 32, 32, 34, 34, ..., 62, 62, etc. + * The corresponding output \p exclusive_partial in the first warp would be + * INT_MIN, 0, 0, 2, ..., 28, 30, the output for the second warp would be 30, 32, 32, 34, ..., 60, 62, etc. + * + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void Scan( + T input, ///< [in] Calling thread's input item. + T &inclusive_output, ///< [out] Calling thread's inclusive-scan output item. + T &exclusive_output, ///< [out] Calling thread's exclusive-scan output item. + T identity, ///< [in] Identity value + ScanOp scan_op) ///< [in] Binary scan operator + { + InternalWarpScan(temp_storage).Scan(input, inclusive_output, exclusive_output, identity, scan_op); + } + + + /** + * \brief Computes both inclusive and exclusive prefix scans using the specified binary scan functor across the calling warp. Because no identity value is supplied, the \p exclusive_output computed for warp-lane0 is undefined. + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates four concurrent warp-wide exclusive prefix max scans within a block of + * 128 threads (one per each of the 32-thread warps). + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Compute exclusive warp-wide prefix max scans + * int inclusive_partial, exclusive_partial; + * WarpScan(temp_storage[warp_id]).Scan(thread_data, inclusive_partial, exclusive_partial, cub::Max()); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, -1, 2, -3, ..., 126, -127}. + * The corresponding output \p inclusive_partial in the first warp would be + * 0, 0, 2, 2, ..., 30, 30, the output for the second warp would be 32, 32, 34, 34, ..., 62, 62, etc. + * The corresponding output \p exclusive_partial in the first warp would be + * ?, 0, 0, 2, ..., 28, 30, the output for the second warp would be ?, 32, 32, 34, ..., 60, 62, etc. + * (The output \p thread_data in warp lane0 is undefined.) + * + * \tparam ScanOp [inferred] Binary scan operator type having member T operator()(const T &a, const T &b) + */ + template + __device__ __forceinline__ void Scan( + T input, ///< [in] Calling thread's input item. + T &inclusive_output, ///< [out] Calling thread's inclusive-scan output item. + T &exclusive_output, ///< [out] Calling thread's exclusive-scan output item. + ScanOp scan_op) ///< [in] Binary scan operator + { + InternalWarpScan(temp_storage).Scan(input, inclusive_output, exclusive_output, scan_op); + } + + //@} end member group + /******************************************************************//** + * \name Data exchange + *********************************************************************/ + //@{ + + /** + * \brief Broadcast the value \p input from warp-lanesrc_lane to all lanes in the warp + * + * \par + * - \smemreuse + * + * \par Snippet + * The code snippet below illustrates the warp-wide broadcasts of values from + * lanes0 in each of four warps to all other threads in those warps. + * \par + * \code + * #include + * + * __global__ void ExampleKernel(...) + * { + * // Specialize WarpScan for type int + * typedef cub::WarpScan WarpScan; + * + * // Allocate WarpScan shared memory for 4 warps + * __shared__ typename WarpScan::TempStorage temp_storage[4]; + * + * // Obtain one input item per thread + * int thread_data = ... + * + * // Broadcast from lane0 in each warp to all other threads in the warp + * int warp_id = threadIdx.x / 32; + * thread_data = WarpScan(temp_storage[warp_id]).Broadcast(thread_data, 0); + * + * \endcode + * \par + * Suppose the set of input \p thread_data across the block of threads is {0, 1, 2, 3, ..., 127}. + * The corresponding output \p thread_data will be + * {0, 0, ..., 0} in warp0, + * {32, 32, ..., 32} in warp1, + * {64, 64, ..., 64} in warp2, etc. + */ + __device__ __forceinline__ T Broadcast( + T input, ///< [in] The value to broadcast + unsigned int src_lane) ///< [in] Which warp lane is to do the broadcasting + { + return InternalWarpScan(temp_storage).Broadcast(input, src_lane); + } + + //@} end member group + +}; + +/** @} */ // end group WarpModule + +} // CUB namespace +CUB_NS_POSTFIX // Optional outer namespace(s) diff --git a/Makefile b/Makefile index 47274fd9f48..d36854e6c62 100644 --- a/Makefile +++ b/Makefile @@ -10,14 +10,6 @@ include $(CONFIG_FILE) # Rectify input parameters ifeq ($(CPU_ONLY),1) USE_CUDNN=0 - USE_CNMEM=0 -endif - -ifeq ($(USE_CUDNN),1) -# CNMEM is ON by default in CUDNN is ON - ifeq ($(USE_CNMEM),) - USE_CNMEM=1 - endif endif PROJECT_DIR=$(PWD) @@ -40,7 +32,6 @@ else endif THIRDPARTY_DIR=$(PROJECT_DIR)/3rdparty -THIRDPARTY=$(BUILD_DIR)/.3rdparty_done # All of the directories containing code. SRC_DIRS := $(shell find * -type d -exec bash -c "find {} -maxdepth 1 \ @@ -189,7 +180,7 @@ ifneq ("$(wildcard $(CUDA_DIR)/lib64)","") endif CUDA_LIB_DIR += $(CUDA_DIR)/lib -INCLUDE_DIRS += $(BUILD_INCLUDE_DIR) ./src ./include +INCLUDE_DIRS += $(BUILD_INCLUDE_DIR) ./src ./include $(THIRDPARTY_DIR) ifneq ($(CPU_ONLY), 1) INCLUDE_DIRS += $(CUDA_INCLUDE_DIR) LIBRARY_DIRS += $(CUDA_LIB_DIR) @@ -334,16 +325,6 @@ ifeq ($(USE_CUDNN), 1) COMMON_FLAGS += -DUSE_CUDNN endif -# CNMEM integration -ifeq ($(USE_CNMEM), 1) - THIRDPARTY_TARGETS+=cnmem - LIBRARIES += cnmem - CNMEM_DIR=${THIRDPARTY_DIR}/cnmem - LIBRARY_DIRS += ${CNMEM_DIR}/build - INCLUDE_DIRS += ${CNMEM_DIR}/include - COMMON_FLAGS += -DUSE_CNMEM -endif - # configure IO libraries ifeq ($(USE_OPENCV), 1) COMMON_FLAGS += -DUSE_OPENCV @@ -368,6 +349,14 @@ ifeq ($(CPU_ONLY), 1) COMMON_FLAGS += -DCPU_ONLY endif +# Benchmarks +ifeq ($(BENCHMARK_DATA), 1) + COMMON_FLAGS += -DBENCHMARK_DATA +endif +ifeq ($(BENCHMARK_SOLVER), 1) + COMMON_FLAGS += -DBENCHMARK_SOLVER +endif + # Python layer support ifeq ($(WITH_PYTHON_LAYER), 1) COMMON_FLAGS += -DWITH_PYTHON_LAYER @@ -417,6 +406,7 @@ LIBRARY_DIRS += $(LIB_BUILD_DIR) CXXFLAGS += -MMD -MP # Complete build flags. + COMMON_FLAGS += $(foreach includedir,$(INCLUDE_DIRS),-I$(includedir)) CXXFLAGS += -pthread -fPIC $(COMMON_FLAGS) $(WARNINGS) NVCCFLAGS += -ccbin=$(CXX) -Xcompiler -fPIC $(COMMON_FLAGS) @@ -463,14 +453,6 @@ all: lib tools examples lib: $(STATIC_NAME) $(DYNAMIC_NAME) -$(THIRDPARTY): Makefile Makefile.config | $(LIB_BUILD_DIR) -ifneq ($(THIRDPARTY_TARGETS),) - echo "Building third-party libraries ..." - @$(MAKE) -C $(THIRDPARTY_DIR) DEBUG=$(DEBUG) INSTALLDIR=$(BUILD_DIR) $(THIRDPARTY_TARGETS) -endif - @touch $(THIRDPARTY) - - everything: $(EVERYTHING_TARGETS) linecount: @@ -583,13 +565,13 @@ $(BUILD_DIR)/.linked: $(ALL_BUILD_DIRS): | $(BUILD_DIR_LINK) @ mkdir -p $@ -$(DYNAMIC_NAME): $(THIRDPARTY) $(OBJS)| $(LIB_BUILD_DIR) +$(DYNAMIC_NAME): $(OBJS)| $(LIB_BUILD_DIR) @ echo LD -o $@ $(Q)$(CXX) -shared -o $@ $(OBJS) $(VERSIONFLAGS) $(LINKFLAGS) $(LDFLAGS) $(DYNAMIC_FLAGS) @ cd $(BUILD_DIR)/lib; rm -f $(DYNAMIC_SONAME_SHORT); ln -s $(DYNAMIC_VERSIONED_NAME_SHORT) $(DYNAMIC_SONAME_SHORT) @ cd $(BUILD_DIR)/lib; rm -f $(DYNAMIC_NAME_SHORT); ln -s $(DYNAMIC_SONAME_SHORT) $(DYNAMIC_NAME_SHORT) -$(STATIC_NAME): $(THIRDPARTY) $(OBJS) | $(LIB_BUILD_DIR) +$(STATIC_NAME): $(OBJS) | $(LIB_BUILD_DIR) @ echo AR -o $@ $(Q)ar rcs $@ $(OBJS) diff --git a/include/caffe/util/gpu_memory.hpp b/include/caffe/util/gpu_memory.hpp index 1e92d6f6632..d09bed2d810 100644 --- a/include/caffe/util/gpu_memory.hpp +++ b/include/caffe/util/gpu_memory.hpp @@ -8,7 +8,20 @@ namespace caffe { class gpu_memory { public: - enum PoolMode { NoPool, CnMemPool, CubPool }; + enum PoolMode { + NoPool, // Straight CUDA malllc/free. May be very expensive + CnMemPool, // CNMEM arena allocator + CubPool, // CUB caching allocator +#ifdef CPU_ONLY + DefaultPool = NoPool +#else +# if (USE_CNMEM) && !defined (__arm__) + DefaultPool = CnMemPool // CNMEM pool only uses dedicated video memory. +# else + DefaultPool = CubPool // CUB pool is able to use unified memory properly +# endif +#endif + }; static const char* getPoolName(); static bool usingPool() { @@ -17,8 +30,9 @@ class gpu_memory { class arena { public: - arena(const std::vector& gpus, PoolMode m = CnMemPool) { - init(gpus, m); + arena(const std::vector& gpus, + PoolMode m = DefaultPool, bool debug = false) { + init(gpus, m, debug); } ~arena() { destroy(); @@ -26,12 +40,13 @@ class gpu_memory { }; private: - static void init(const std::vector&, PoolMode); + static void init(const std::vector&, PoolMode, bool); static void destroy(); - static bool initialized_; + static bool initialized_; static PoolMode mode_; - + static size_t poolsize_; + static bool debug_; #ifndef CPU_ONLY public: @@ -42,7 +57,8 @@ class gpu_memory { static void getInfo(size_t *free_mem, size_t *used_mem); private: - static void initCNMEM(const std::vector& gpus); + static void initMEM(const std::vector& gpus, PoolMode m); + #endif }; diff --git a/src/caffe/util/gpu_memory.cpp b/src/caffe/util/gpu_memory.cpp index 31db2ddc0dd..dd33e4b2729 100644 --- a/src/caffe/util/gpu_memory.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -1,3 +1,4 @@ +#include #include #include "caffe/common.hpp" @@ -9,13 +10,20 @@ #include "cnmem.h" #endif +#ifndef CPU_ONLY +#include "cub/cub/util_allocator.cuh" +#endif + namespace caffe { - gpu_memory::PoolMode gpu_memory::mode_ = gpu_memory::NoPool; + static cub::CachingDeviceAllocator* cubAlloc = 0; + + gpu_memory::PoolMode gpu_memory::mode_ = gpu_memory::NoPool; + size_t gpu_memory::poolsize_ = 0; + bool gpu_memory::debug_ = false; #ifdef CPU_ONLY // CPU-only Caffe. - void gpu_memory::init(const std::vector& gpus, - PoolMode m) {} + void gpu_memory::init(const std::vector&, PoolMode, bool) {} void gpu_memory::destroy() {} const char* gpu_memory::getPoolName() { @@ -23,23 +31,25 @@ namespace caffe { } #else void gpu_memory::init(const std::vector& gpus, - PoolMode m) { + PoolMode m, bool debug) { + debug_ = debug; if (gpus.size() <= 0) { // should we report an error here ? m = gpu_memory::NoPool; } switch (m) { + case CubPool: case CnMemPool: - initCNMEM(gpus); + initMEM(gpus, m); break; - case CubPool: default: break; } - - std::cout << "gpu_memory initialized with " - << getPoolName() << std::endl; + if (debug) + std::cout << "gpu_memory initialized with " + << getPoolName() << ". Poolsize = " + << (1.0*poolsize_)/(1024.0*1024.0*1024.0) << " G." << std::endl; } void gpu_memory::destroy() { @@ -48,6 +58,9 @@ namespace caffe { CNMEM_CHECK(cnmemFinalize()); break; case CubPool: + delete cubAlloc; + cubAlloc = NULL; + break; default: break; } @@ -62,6 +75,8 @@ namespace caffe { CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); break; case CubPool: + CUDA_CHECK(cubAlloc->DeviceAllocate(ptr, size, stream)); + break; default: CUDA_CHECK(cudaMalloc(ptr, size)); break; @@ -77,6 +92,8 @@ namespace caffe { CNMEM_CHECK(cnmemFree(ptr, stream)); break; case CubPool: + CUDA_CHECK(cubAlloc->DeviceFree(ptr)); + break; default: CUDA_CHECK(cudaFree(ptr)); break; @@ -94,25 +111,72 @@ namespace caffe { } } - void gpu_memory::initCNMEM(const std::vector& gpus) { -#ifdef USE_CNMEM - cnmemDevice_t* devs = new cnmemDevice_t[gpus.size()]; + void gpu_memory::initMEM(const std::vector& gpus, PoolMode m) { + mode_ = m; int initial_device; +#if USE_CNMEM + cnmemDevice_t* devs = new cnmemDevice_t[gpus.size()]; +#endif + CUDA_CHECK(cudaGetDevice(&initial_device)); for (int i = 0; i < gpus.size(); i++) { CUDA_CHECK(cudaSetDevice(gpus[i])); + size_t free_mem, total_mem; + cudaDeviceProp props; + CUDA_CHECK(cudaGetDeviceProperties(&props, gpus[i])); + CUDA_CHECK(cudaMemGetInfo(&free_mem, &total_mem)); + + if (debug_) { + std::cout << "cudaGetDeviceProperties: Mem = " + << props.totalGlobalMem < Date: Tue, 3 Nov 2015 14:36:53 -0800 Subject: [PATCH 293/331] Revert "Mark v0.14.0-rc.1" This reverts commit 4486988031611b38a5fdb18fbb72c9f40582f3cb. Not ready yet. --- CMakeLists.txt | 2 +- Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9e9695c71e1..4185a343a2b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8.7) project(Caffe C CXX) # ---[ Caffe version -set(CAFFE_TARGET_VERSION "0.14.0-rc.1") +set(CAFFE_TARGET_VERSION "0.14.0-beta.1") set(CAFFE_TARGET_SOVERSION "0.14") add_definitions(-DCAFFE_VERSION=${CAFFE_TARGET_VERSION}) diff --git a/Makefile b/Makefile index b47c1ce01d9..d36854e6c62 100644 --- a/Makefile +++ b/Makefile @@ -43,7 +43,7 @@ LIB_BUILD_DIR := $(BUILD_DIR)/lib STATIC_NAME := $(LIB_BUILD_DIR)/lib$(LIBRARY_NAME).a DYNAMIC_VERSION_MAJOR := 0 DYNAMIC_VERSION_MINOR := 14 -DYNAMIC_VERSION_REVISION := 0-rc.1 +DYNAMIC_VERSION_REVISION := 0-beta.1 DYNAMIC_NAME_SHORT := lib$(LIBRARY_NAME).so DYNAMIC_SONAME_SHORT := $(DYNAMIC_NAME_SHORT).$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR) DYNAMIC_VERSIONED_NAME_SHORT := $(DYNAMIC_SONAME_SHORT).$(DYNAMIC_VERSION_REVISION) From 1fafd7f04183037afd28b5238887b27730eab80e Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Tue, 3 Nov 2015 14:42:24 -0800 Subject: [PATCH 294/331] TravisCI: wget cmake with --no-check-certificate ``` --2015-11-03 22:31:11-- http://www.cmake.org/files/v3.2/cmake-3.2.3-Linux-x86_64.sh Resolving www.cmake.org (www.cmake.org)... 66.194.253.19 Connecting to www.cmake.org (www.cmake.org)|66.194.253.19|:80... connected. HTTP request sent, awaiting response... 301 Moved Permanently Location: http://cmake.org/files/v3.2/cmake-3.2.3-Linux-x86_64.sh [following] --2015-11-03 22:31:11-- http://cmake.org/files/v3.2/cmake-3.2.3-Linux-x86_64.sh Resolving cmake.org (cmake.org)... 66.194.253.19 Connecting to cmake.org (cmake.org)|66.194.253.19|:80... connected. HTTP request sent, awaiting response... 301 Moved Permanently Location: https://cmake.org/files/v3.2/cmake-3.2.3-Linux-x86_64.sh [following] --2015-11-03 22:31:11-- https://cmake.org/files/v3.2/cmake-3.2.3-Linux-x86_64.sh Connecting to cmake.org (cmake.org)|66.194.253.19|:443... connected. ERROR: no certificate subject alternative name matches requested host name `cmake.org'. To connect to cmake.org insecurely, use `--no-check-certificate'. ``` --- scripts/travis/travis_install.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/travis/travis_install.sh b/scripts/travis/travis_install.sh index d6c6e228b58..d78c4d2f7b2 100755 --- a/scripts/travis/travis_install.sh +++ b/scripts/travis/travis_install.sh @@ -23,7 +23,7 @@ apt-get install \ # Caffe requires a minimum CMake version of 2.8.8. if $WITH_CMAKE; then # cmake 3 will make sure that the python interpreter and libraries match - wget http://www.cmake.org/files/v3.2/cmake-3.2.3-Linux-x86_64.sh -O cmake3.sh + wget --no-check-certificate http://www.cmake.org/files/v3.2/cmake-3.2.3-Linux-x86_64.sh -O cmake3.sh chmod +x cmake3.sh ./cmake3.sh --prefix=/usr/ --skip-license --exclude-subdir fi From c2aae00e844e2bf2cdaccfbe12f92e0070ed06c3 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 3 Nov 2015 14:25:15 -0800 Subject: [PATCH 295/331] Fixing CMake build --- CMakeLists.txt | 3 ++- scripts/travis/travis_build_and_test.sh | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 4185a343a2b..83caab641cf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -57,7 +57,8 @@ configure_file(cmake/Templates/caffe_config.h.in "${PROJECT_BINARY_DIR}/caffe_co # ---[ Includes set(Caffe_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/include) -include_directories(${Caffe_INCLUDE_DIR} ${PROJECT_BINARY_DIR}) +set(THIRDPARTY_DIR ${PROJECT_SOURCE_DIR}/3rdparty) +include_directories(${Caffe_INCLUDE_DIR} ${PROJECT_BINARY_DIR} ${THIRDPARTY_DIR}) include_directories(BEFORE src) # This is needed for gtest. # ---[ Subdirectories diff --git a/scripts/travis/travis_build_and_test.sh b/scripts/travis/travis_build_and_test.sh index 7f97fc632ab..f5db15536e7 100755 --- a/scripts/travis/travis_build_and_test.sh +++ b/scripts/travis/travis_build_and_test.sh @@ -6,7 +6,7 @@ set -e MAKE="make --jobs=$NUM_THREADS --keep-going" if $WITH_CMAKE; then - mkdir build + mkdir -p build cd build CPU_ONLY=" -DCPU_ONLY=ON" if ! $WITH_CUDA; then From 560d270a95d58ba1c84f42b54af2a2f53b7555aa Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 3 Nov 2015 16:50:43 -0800 Subject: [PATCH 296/331] Restored missed CNMEM switches --- CMakeLists.txt | 5 +++++ Makefile | 6 ++++++ 2 files changed, 11 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 83caab641cf..b59e40b5b37 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -42,6 +42,11 @@ if(UNIX OR APPLE) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -Wall") endif() +if(USE_CNMEM) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_CNMEM -lcnmem") + message("-- Info: Using CNMEM memory pool configuration") +endif() + if(USE_libstdcpp) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libstdc++") message("-- Warning: forcing libstdc++ (controlled by USE_libstdcpp option in cmake)") diff --git a/Makefile b/Makefile index d36854e6c62..b768e74c7a3 100644 --- a/Makefile +++ b/Makefile @@ -325,6 +325,12 @@ ifeq ($(USE_CUDNN), 1) COMMON_FLAGS += -DUSE_CUDNN endif +# CNMEM integration +ifeq ($(USE_CNMEM), 1) + LIBRARIES += cnmem + COMMON_FLAGS += -DUSE_CNMEM +endif + # configure IO libraries ifeq ($(USE_OPENCV), 1) COMMON_FLAGS += -DUSE_OPENCV From 5dcaa09069e03c75a52374042f8f4e344c03fbb3 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 3 Nov 2015 15:18:21 -0800 Subject: [PATCH 297/331] Added gpu_memory::buffer class to help in no-pool config --- include/caffe/util/gpu_memory.hpp | 62 ++++++++++++++++++++++++--- include/caffe/vision_layers.hpp | 13 +++--- src/caffe/layers/cudnn_conv_layer.cpp | 7 --- src/caffe/layers/cudnn_conv_layer.cu | 32 +++++++------- src/caffe/layers/cudnn_lcn_layer.cpp | 6 +-- src/caffe/layers/cudnn_lcn_layer.cu | 23 +++++----- 6 files changed, 92 insertions(+), 51 deletions(-) diff --git a/include/caffe/util/gpu_memory.hpp b/include/caffe/util/gpu_memory.hpp index d09bed2d810..84b84649457 100644 --- a/include/caffe/util/gpu_memory.hpp +++ b/include/caffe/util/gpu_memory.hpp @@ -39,20 +39,68 @@ class gpu_memory { } }; +#ifndef CPU_ONLY + class buffer { + public: + // Construction/destruction + buffer(): ptr_(NULL), stream_(), size_(0) {} + buffer(size_t size, cudaStream_t s = cudaStreamDefault): stream_(s) { + reserve(size); + } + ~buffer() { gpu_memory::deallocate(ptr_, stream_); } + + // Accessors + void* data() const { return ptr_; } + size_t size() const { return size_; } + + // Memory allocation/release + void reserve(size_t size) { + if (size > size_) { + if (ptr_) + gpu_memory::deallocate(ptr_, stream_); + gpu_memory::allocate(&ptr_, size, stream_); + size_ = size; + } + } + + /* + * This method behaves differently depending on pool availability: + * If pool is available, it returns memory to the pool and sets ptr to NULL + * If pool is not available, it does nothing (retaining memory) + */ + void release() { + if (gpu_memory::usingPool()) { + gpu_memory::deallocate(ptr_, stream_); + ptr_ = NULL; + size_ = 0; + } + // otherwise (no pool) - we retain memory in the buffer + } + + private: + void* ptr_; + cudaStream_t stream_; + size_t size_; + }; +# endif + private: static void init(const std::vector&, PoolMode, bool); - static void destroy(); + static void destroy(); - static bool initialized_; - static PoolMode mode_; - static size_t poolsize_; - static bool debug_; + static bool initialized_; + static PoolMode mode_; + static size_t poolsize_; + static bool debug_; #ifndef CPU_ONLY public: - static void allocate(void **ptr, size_t size, + typedef void* pointer; + + static void allocate(pointer* ptr, size_t size, cudaStream_t stream = cudaStreamDefault); - static void deallocate(void *ptr, cudaStream_t = cudaStreamDefault); + static void deallocate(pointer ptr, cudaStream_t = cudaStreamDefault); + static void registerStream(cudaStream_t stream); static void getInfo(size_t *free_mem, size_t *used_mem); diff --git a/include/caffe/vision_layers.hpp b/include/caffe/vision_layers.hpp index 41c3d426bf2..fb1ca214afa 100644 --- a/include/caffe/vision_layers.hpp +++ b/include/caffe/vision_layers.hpp @@ -13,6 +13,9 @@ #include "caffe/loss_layers.hpp" #include "caffe/neuron_layers.hpp" #include "caffe/proto/caffe.pb.h" +#ifndef CPU_ONLY +#include "caffe/util/gpu_memory.hpp" +#endif namespace caffe { @@ -318,8 +321,7 @@ class CuDNNConvolutionLayer : public ConvolutionLayer { size_t *workspace_fwd_sizes_; size_t *workspace_bwd_data_sizes_; size_t *workspace_bwd_filter_sizes_; - size_t workspaceSizeInBytes; // size of underlying storage - void *workspaceData; // underlying storage + gpu_memory::buffer workspace; }; #endif @@ -482,8 +484,7 @@ template class CuDNNLCNLayer : public LRNLayer { public: explicit CuDNNLCNLayer(const LayerParameter& param) - : LRNLayer(param), handles_setup_(false), tempDataSize(0), - tempData1(NULL), tempData2(NULL) {} + : LRNLayer(param), handles_setup_(false), tempDataSize_(0) {} virtual void LayerSetUp(const vector*>& bottom, const vector*>& top); virtual void Reshape(const vector*>& bottom, @@ -503,8 +504,8 @@ class CuDNNLCNLayer : public LRNLayer { int size_, pre_pad_; Dtype alpha_, beta_, k_; - size_t tempDataSize; - void *tempData1, *tempData2; + size_t tempDataSize_; + gpu_memory::buffer temp1_, temp2_; }; #endif diff --git a/src/caffe/layers/cudnn_conv_layer.cpp b/src/caffe/layers/cudnn_conv_layer.cpp index 68b70e23f29..ecdd2b78ac3 100644 --- a/src/caffe/layers/cudnn_conv_layer.cpp +++ b/src/caffe/layers/cudnn_conv_layer.cpp @@ -31,10 +31,6 @@ void CuDNNConvolutionLayer::LayerSetUp( workspace_bwd_filter_sizes_ = new size_t[bottom.size()]; workspace_bwd_data_sizes_ = new size_t[bottom.size()]; - // workspace data - workspaceSizeInBytes = 0; - workspaceData = NULL; - for (size_t i = 0; i < bottom.size(); ++i) { // initialize all to default algorithms fwd_algo_[i] = (cudnnConvolutionFwdAlgo_t)0; @@ -196,9 +192,6 @@ CuDNNConvolutionLayer::~CuDNNConvolutionLayer() { delete [] workspace_fwd_sizes_; delete [] workspace_bwd_data_sizes_; delete [] workspace_bwd_filter_sizes_; - - gpu_memory::deallocate(this->workspaceData); - this->workspaceData = NULL; } INSTANTIATE_CLASS(CuDNNConvolutionLayer); diff --git a/src/caffe/layers/cudnn_conv_layer.cu b/src/caffe/layers/cudnn_conv_layer.cu index f112e0692a6..8dbbb6aa606 100644 --- a/src/caffe/layers/cudnn_conv_layer.cu +++ b/src/caffe/layers/cudnn_conv_layer.cu @@ -31,7 +31,7 @@ namespace caffe { // Forward through cuDNN in parallel over groups. for (int g = 0; g < this->group_; g++) { - gpu_memory::allocate(&workspaceData, workspace_fwd_sizes_[i]); + workspace.reserve(workspace_fwd_sizes_[i]); // Filters. CUDNN_CHECK(cudnnConvFwd(Caffe::cudnn_handle(), cudnn::dataType::one, @@ -40,14 +40,15 @@ namespace caffe { filter_desc_, weight + this->weight_offset_ * g, conv_descs_[i], - fwd_algo_[i], workspaceData, - workspace_fwd_sizes_[i], + fwd_algo_[i], + workspace.data(), + workspace.size(), cudnn::dataType::zero, top_descs_[i], top_data + top_offset_ * g)); - gpu_memory::deallocate(workspaceData); - workspaceData = NULL; + workspace.release(); + // Bias. if (this->bias_term_) { const Dtype* bias_data = this->blobs_[1]->gpu_data(); @@ -105,8 +106,7 @@ namespace caffe { // Gradient w.r.t. weights. if (this->param_propagate_down_[0]) { - gpu_memory::allocate(&workspaceData, - workspace_bwd_filter_sizes_[i]); + workspace.reserve(workspace_bwd_filter_sizes_[i]); const Dtype* bottom_data = bottom[i]->gpu_data(); CUDNN_CHECK(cudnnConvBwdFilter(Caffe::cudnn_handle(), cudnn::dataType::one, @@ -116,13 +116,12 @@ namespace caffe { top_diff + top_offset_ * g, conv_descs_[i], bwd_filter_algo_[i], - workspaceData, - workspace_bwd_filter_sizes_[i], + workspace.data(), + workspace.size(), cudnn::dataType::one, filter_desc_, weight_diff + weight_offset_ * g)); - gpu_memory::deallocate(workspaceData); - workspaceData = NULL; + workspace.release(); } // Gradient w.r.t. bottom data. @@ -131,8 +130,7 @@ namespace caffe { weight = this->blobs_[0]->gpu_data(); } Dtype* bottom_diff = bottom[i]->mutable_gpu_diff(); - gpu_memory::allocate(&workspaceData, - workspace_bwd_data_sizes_[i]); + workspace.reserve(workspace_bwd_data_sizes_[i]); CUDNN_CHECK(cudnnConvBwdData(Caffe::cudnn_handle(), cudnn::dataType::one, filter_desc_, @@ -140,13 +138,13 @@ namespace caffe { top_descs_[i], top_diff + top_offset_ * g, conv_descs_[i], - bwd_data_algo_[i], workspaceData, - workspace_bwd_data_sizes_[i], + bwd_data_algo_[i], + workspace.data(), + workspace.size(), cudnn::dataType::zero, bottom_descs_[i], bottom_diff + bottom_offset_ * g)); - gpu_memory::deallocate(workspaceData); - workspaceData = NULL; + workspace.release(); } } diff --git a/src/caffe/layers/cudnn_lcn_layer.cpp b/src/caffe/layers/cudnn_lcn_layer.cpp index d4301dc1a8a..56e5fe1e083 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cpp +++ b/src/caffe/layers/cudnn_lcn_layer.cpp @@ -38,9 +38,9 @@ void CuDNNLCNLayer::Reshape(const vector*>& bottom, this->channels_, this->height_, this->width_); CUDNN_CHECK(cudnnSetLRNDescriptor(norm_desc_, size_, alpha_, beta_, k_)); - // size for tempData buffers - tempDataSize = sizeof(Dtype)*bottom[0]->num()* \ - this->channels_*this->height_*this->width_; + // size for temp buffers + tempDataSize_ = sizeof(Dtype)*bottom[0]->num()* \ + this->channels_*this->height_*this->width_; } template diff --git a/src/caffe/layers/cudnn_lcn_layer.cu b/src/caffe/layers/cudnn_lcn_layer.cu index 94cb017cbc8..895602dc85f 100644 --- a/src/caffe/layers/cudnn_lcn_layer.cu +++ b/src/caffe/layers/cudnn_lcn_layer.cu @@ -15,20 +15,20 @@ void CuDNNLCNLayer::Forward_gpu(const vector*>& bottom, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* top_data = top[0]->mutable_gpu_data(); - gpu_memory::allocate(&this->tempData1, this->tempDataSize); - gpu_memory::allocate(&this->tempData2, this->tempDataSize); + temp1_.reserve(tempDataSize_); + temp2_.reserve(tempDataSize_); CUDNN_CHECK(cudnnDivisiveNormalizationForward( Caffe::cudnn_handle(), norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, cudnn::dataType::one, bottom_desc_, bottom_data, NULL, // srcMeansData - this->tempData1, this->tempData2, + temp1_.data(), temp2_.data(), cudnn::dataType::zero, top_desc_, top_data) ); - gpu_memory::deallocate(this->tempData1); - gpu_memory::deallocate(this->tempData2); + temp1_.release(); + temp2_.release(); } template @@ -39,21 +39,22 @@ void CuDNNLCNLayer::Backward_gpu(const vector*>& top, const Dtype* bottom_data = bottom[0]->gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); - gpu_memory::allocate(&this->tempData1, this->tempDataSize); - gpu_memory::allocate(&this->tempData2, this->tempDataSize); + temp1_.reserve(tempDataSize_); + temp2_.reserve(tempDataSize_); CUDNN_CHECK(cudnnDivisiveNormalizationBackward( - Caffe::cudnn_handle(), norm_desc_, CUDNN_DIVNORM_PRECOMPUTED_MEANS, + Caffe::cudnn_handle(), norm_desc_, + CUDNN_DIVNORM_PRECOMPUTED_MEANS, cudnn::dataType::one, bottom_desc_, bottom_data, NULL, top_diff, // NULL - srcMeansData - this->tempData1, this->tempData2, + temp1_.data(), temp2_.data(), cudnn::dataType::zero, bottom_desc_, bottom_diff, NULL) ); - gpu_memory::deallocate(this->tempData1); - gpu_memory::deallocate(this->tempData2); + temp1_.release(); + temp2_.release(); } INSTANTIATE_LAYER_GPU_FUNCS(CuDNNLCNLayer); From 6ef51a4ba58fbce2833d0ba9335b2269488a30bc Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 3 Nov 2015 18:39:59 -0800 Subject: [PATCH 298/331] restored 95% of memory grabbed by CNMEM --- src/caffe/util/gpu_memory.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/caffe/util/gpu_memory.cpp b/src/caffe/util/gpu_memory.cpp index 96b3e355fe4..acbf60c4233 100644 --- a/src/caffe/util/gpu_memory.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -136,15 +136,15 @@ namespace caffe { << " Total= " << total_mem << std::endl; } - // just in case, make sure total mem reported is not less than free + // make sure we don't ask for more that total device memory free_mem = std::min(total_mem, free_mem); - free_mem = size_t(0.8*std::min(props.totalGlobalMem, free_mem)); + free_mem = size_t(0.95*std::min(props.totalGlobalMem, free_mem)); // find out the smallest GPU size if (poolsize_ == 0 || poolsize_ > free_mem) poolsize_ = free_mem; #if USE_CNMEM devs[i].device = gpus[i]; - devs[i].size = poolsize_; + devs[i].size = free_mem; devs[i].numStreams = 0; devs[i].streams = NULL; #endif From 680402906e96fe9f4d64839cf90adacbb75e67d2 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Tue, 3 Nov 2015 19:39:01 -0800 Subject: [PATCH 299/331] Mark v0.14.0-rc.1 --- CMakeLists.txt | 2 +- Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b59e40b5b37..b3fd3464657 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8.7) project(Caffe C CXX) # ---[ Caffe version -set(CAFFE_TARGET_VERSION "0.14.0-beta.1") +set(CAFFE_TARGET_VERSION "0.14.0-rc.1") set(CAFFE_TARGET_SOVERSION "0.14") add_definitions(-DCAFFE_VERSION=${CAFFE_TARGET_VERSION}) diff --git a/Makefile b/Makefile index b768e74c7a3..737bb491baa 100644 --- a/Makefile +++ b/Makefile @@ -43,7 +43,7 @@ LIB_BUILD_DIR := $(BUILD_DIR)/lib STATIC_NAME := $(LIB_BUILD_DIR)/lib$(LIBRARY_NAME).a DYNAMIC_VERSION_MAJOR := 0 DYNAMIC_VERSION_MINOR := 14 -DYNAMIC_VERSION_REVISION := 0-beta.1 +DYNAMIC_VERSION_REVISION := 0-rc.1 DYNAMIC_NAME_SHORT := lib$(LIBRARY_NAME).so DYNAMIC_SONAME_SHORT := $(DYNAMIC_NAME_SHORT).$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR) DYNAMIC_VERSIONED_NAME_SHORT := $(DYNAMIC_SONAME_SHORT).$(DYNAMIC_VERSION_REVISION) From 4f02a0be191c3c47d2298d8356279a98b496977a Mon Sep 17 00:00:00 2001 From: Jonathan L Long Date: Wed, 4 Nov 2015 22:10:25 -0800 Subject: [PATCH 300/331] [travis] fix boost/python3 conda conflict --- scripts/travis/travis_install.sh | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/scripts/travis/travis_install.sh b/scripts/travis/travis_install.sh index d78c4d2f7b2..432c81dc6ec 100755 --- a/scripts/travis/travis_install.sh +++ b/scripts/travis/travis_install.sh @@ -70,6 +70,10 @@ if [ ! -d $CONDA_DIR ]; then ./miniconda.sh -b -p $CONDA_DIR conda update --yes conda + # The version of boost we're using for Python 3 depends on 3.4 for now. + if [ "$PYTHON_VERSION" -eq "3" ]; then + conda install --yes python=3.4 + fi conda install --yes numpy scipy matplotlib scikit-image pip # Let conda install boost (so that boost_python matches) conda install --yes -c https://conda.binstar.org/menpo boost=1.56.0 From 18fc26783fef833ec24a69106e5c3e6bf09972d1 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Mon, 9 Nov 2015 15:33:18 -0800 Subject: [PATCH 301/331] Adding out of memory handler, making arena bins more detailed --- 3rdparty/cub/cub/util_allocator.cuh | 326 ++++++++++++++-------------- src/caffe/util/gpu_memory.cpp | 6 +- 2 files changed, 171 insertions(+), 161 deletions(-) diff --git a/3rdparty/cub/cub/util_allocator.cuh b/3rdparty/cub/cub/util_allocator.cuh index 051f82198c3..7f6bebe7f74 100644 --- a/3rdparty/cub/cub/util_allocator.cuh +++ b/3rdparty/cub/cub/util_allocator.cuh @@ -269,9 +269,9 @@ struct CachingDeviceAllocator unsigned int max_bin, ///< Maximum bin size_t max_cached_bytes, ///< Maximum aggregate cached bytes per device bool skip_cleanup = false, ///< Whether or not to skip a call to \p FreeAllCached() when the destructor is called. - bool debug = false ///< Whether or not to print (de)allocation events to stdout - ) - : + bool debug = false ///< Whether or not to print (de)allocation events to stdout + ) + : spin_lock(0), bin_growth(bin_growth), min_bin(min_bin), @@ -302,8 +302,8 @@ struct CachingDeviceAllocator * sets a maximum of 6,291,455 cached bytes per device */ CachingDeviceAllocator( - bool skip_cleanup = false, - bool debug = false) + bool skip_cleanup = false, + bool debug = false) : spin_lock(0), bin_growth(8), @@ -368,106 +368,123 @@ struct CachingDeviceAllocator *d_ptr = NULL; - int entrypoint_device = INVALID_DEVICE_ORDINAL; + int entrypoint_device = INVALID_DEVICE_ORDINAL; cudaError_t error = cudaSuccess; - do { - - if (CubDebug(error = cudaGetDevice(&entrypoint_device))) break; - if (device == INVALID_DEVICE_ORDINAL) - device = entrypoint_device; - - // Round up to nearest bin size - unsigned int bin; - size_t bin_bytes; - NearestPowerOf(bin, bin_bytes, bin_growth, bytes); - if (bin < min_bin) { - bin = min_bin; - bin_bytes = min_bin_bytes; - } - - // Check if bin is greater than our maximum bin - if (bin > max_bin) - { - // Allocate the request exactly and give out-of-range bin - bin = (unsigned int) -1; - bin_bytes = bytes; - } - - BlockDescriptor search_key(bin_bytes, bin, device, active_stream); - - // Lock - Lock(&spin_lock); - - // Find the range of freed blocks big enough within the same bin on the same device - CachedBlocks::iterator block_itr = cached_blocks.lower_bound(search_key); - - // Look for freed blocks from the active stream or from other idle streams - bool found = false; - while ((block_itr != cached_blocks.end()) && - (block_itr->device == device) && - (block_itr->bin == search_key.bin)) - { - cudaStream_t prev_stream = block_itr->associated_stream; - if ((active_stream == prev_stream) || (cudaEventQuery(block_itr->ready_event) != cudaErrorNotReady)) - { - // Reuse existing cache block. Insert into live blocks. - found = true; - search_key = *block_itr; - search_key.associated_stream = active_stream; - live_blocks.insert(search_key); - - // Remove from free blocks - cached_blocks.erase(block_itr); - cached_bytes[device].free -= search_key.bytes; - cached_bytes[device].busy += search_key.bytes; - - if (debug) CubLog("\tdevice %d reused cached block at %p (%lld bytes) for stream %lld (previously associated with stream %lld).\n", - device, search_key.d_ptr, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) prev_stream); - - break; - } - - block_itr++; - } - + if (device == INVALID_DEVICE_ORDINAL) { + if (CubDebug(error = cudaGetDevice(&entrypoint_device))) + return error; + device = entrypoint_device; + } + + // Round up to nearest bin size + unsigned int bin; + size_t bin_bytes; + NearestPowerOf(bin, bin_bytes, bin_growth, bytes); + if (bin < min_bin) { + bin = min_bin; + bin_bytes = min_bin_bytes; + } - if (!found) - { - Unlock(&spin_lock); - // Set to specified device - if (device != entrypoint_device) { - if (CubDebug(error = cudaSetDevice(device))) break; - } - - // Allocate - if (CubDebug(error = cudaMalloc(&search_key.d_ptr, search_key.bytes))) break; - if (CubDebug(error = cudaEventCreateWithFlags(&search_key.ready_event, cudaEventDisableTiming))) break; - - - Lock(&spin_lock); - // Insert into live blocks - live_blocks.insert(search_key); - cached_bytes[device].busy += search_key.bytes; - - if (debug) CubLog("\tdevice %d allocated new device block at %p (%lld bytes associated with stream %lld).\n", - device, search_key.d_ptr, (long long) search_key.bytes, (long long) search_key.associated_stream); - } + // Check if bin is greater than our maximum bin + if (bin > max_bin) + { + // Allocate the request exactly and give out-of-range bin + bin = (unsigned int) -1; + bin_bytes = bytes; + } - // Copy device pointer to output parameter - *d_ptr = search_key.d_ptr; - if (debug) CubLog("\t\t%lld available blocks cached (%lld bytes), %lld live blocks outstanding(%lld bytes).\n", - (long long) cached_blocks.size(), (long long) cached_bytes[device].free, (long long) live_blocks.size(), (long long) cached_bytes[device].busy); - - } while(0); + BlockDescriptor search_key(bin_bytes, bin, device, active_stream); - Unlock(&spin_lock); + // Lock while we search + Lock(&spin_lock); - // Attempt to revert back to previous device if necessary - if ((entrypoint_device != INVALID_DEVICE_ORDINAL) && (entrypoint_device != device)) - { - if (CubDebug(error = cudaSetDevice(entrypoint_device))) return error; - } + // Find the range of freed blocks big enough within the same bin on the same device + CachedBlocks::iterator block_itr = cached_blocks.lower_bound(search_key); + + // Look for freed blocks from the active stream or from other idle streams + bool found = false; + while ( (block_itr != cached_blocks.end()) + && (block_itr->device == device) + && (block_itr->bin == search_key.bin)) { + cudaStream_t prev_stream = block_itr->associated_stream; + if ((active_stream == prev_stream) + || (cudaEventQuery(block_itr->ready_event) != cudaErrorNotReady)) { + // Reuse existing cache block. Insert into live blocks. + found = true; + search_key = *block_itr; + search_key.associated_stream = active_stream; + live_blocks.insert(search_key); + + // Remove from free blocks + cached_blocks.erase(block_itr); + cached_bytes[device].free -= search_key.bytes; + cached_bytes[device].busy += search_key.bytes; + + if (debug) CubLog("\tdevice %d reused cached block at %p (%lld bytes) for stream %lld (previously associated with stream %lld).\n", + device, search_key.d_ptr, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) prev_stream); + + break; + } + + block_itr++; + } + // done searching. Unlock. + + Unlock(&spin_lock); + + if (!found) + { + + // Set to specified device. Entrypoint may not be set. + if (device != entrypoint_device) { + if (CubDebug(error = cudaGetDevice(&entrypoint_device))) + return error; + if (CubDebug(error = cudaSetDevice(device))) return error; + } + + // Allocate + error = cudaMalloc(&search_key.d_ptr, search_key.bytes); + + if (error != cudaSuccess) { + if (debug) CubLog("\tdevice %d failed to allocate %lld bytes for stream %lld", + device, (long long) search_key.bytes, (long long) search_key.associated_stream); + + // if (search_key.bytes < cached_bytes[device]) { + // free all cached memory (for all devices), synchrionize and retry once + cudaDeviceSynchronize(); + cudaThreadSynchronize(); + FreeAllCached(); + cudaDeviceSynchronize(); + cudaThreadSynchronize(); + error = cudaMalloc(&search_key.d_ptr, search_key.bytes); + // } + } + if (CubDebug(error)) + return error; + if (CubDebug(error = cudaEventCreateWithFlags(&search_key.ready_event, cudaEventDisableTiming))) + return error; + + // Insert into live blocks + Lock(&spin_lock); + live_blocks.insert(search_key); + cached_bytes[device].busy += search_key.bytes; + Unlock(&spin_lock); + + if (debug) CubLog("\tdevice %d allocated new device block at %p (%lld bytes associated with stream %lld).\n", + device, search_key.d_ptr, (long long) search_key.bytes, (long long) search_key.associated_stream); + + // Attempt to revert back to previous device if necessary + if ((entrypoint_device != INVALID_DEVICE_ORDINAL) && (entrypoint_device != device)) + { + if (CubDebug(error = cudaSetDevice(entrypoint_device))) return error; + } + } + + // Copy device pointer to output parameter + *d_ptr = search_key.d_ptr; + if (debug) CubLog("\t\t%lld available blocks cached (%lld bytes), %lld live blocks outstanding(%lld bytes).\n", + (long long) cached_blocks.size(), (long long) cached_bytes[device].free, (long long) live_blocks.size(), (long long) cached_bytes[device].busy); return error; @@ -515,73 +532,66 @@ struct CachingDeviceAllocator int entrypoint_device = INVALID_DEVICE_ORDINAL; cudaError_t error = cudaSuccess; - if (CubDebug(error = cudaGetDevice(&entrypoint_device))) return error; + if (device == INVALID_DEVICE_ORDINAL) { + if (CubDebug(error = cudaGetDevice(&entrypoint_device))) + return error; + device = entrypoint_device; + } - if (device == INVALID_DEVICE_ORDINAL) - device = entrypoint_device; - BlockDescriptor search_key(d_ptr, device); - - do { - - // Set to specified device - if (device != entrypoint_device) { - if (CubDebug(error = cudaSetDevice(device))) break; - } - - // Lock - Lock(&spin_lock); - - // Find corresponding block descriptor - BusyBlocks::iterator block_itr = live_blocks.find(search_key); - if (block_itr == live_blocks.end()) - { - // Cannot find pointer - if (CubDebug(error = cudaErrorUnknown)) break; - } - else - { - // Remove from live blocks - search_key = *block_itr; - live_blocks.erase(block_itr); - - cached_bytes[device].busy -= search_key.bytes; - - // Check if we should keep the returned allocation - if (cached_bytes[device].free + search_key.bytes <= max_cached_bytes) - { - // Signal the event in the associated stream - if (CubDebug(error = cudaEventRecord(search_key.ready_event, search_key.associated_stream))) break; - - // Insert returned allocation into free blocks - cached_blocks.insert(search_key); - cached_bytes[device].free += search_key.bytes; - - if (debug) CubLog("\tdevice %d returned %lld bytes from associated stream %lld.\n\t\t %lld available blocks cached (%lld bytes), %lld live blocks outstanding. (%lld bytes)\n", - device, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) cached_blocks.size(), (long long) cached_bytes[device].free, (long long) live_blocks.size(), (long long) cached_bytes[device].busy); - } - else { - // This means : actually delete the block after we release the lock - d_ptr = 0; - } - } - } while (0); + bool recached = false; + // Lock + Lock(&spin_lock); + + // Find corresponding block descriptor + BusyBlocks::iterator block_itr = live_blocks.find(search_key); + if (block_itr != live_blocks.end()) { + // Remove from live blocks + search_key = *block_itr; + live_blocks.erase(block_itr); + cached_bytes[device].busy -= search_key.bytes; + + // Check if we should keep the returned allocation + if (cached_bytes[device].free + search_key.bytes <= max_cached_bytes) + { + // Insert returned allocation into free blocks + cached_blocks.insert(search_key); + cached_bytes[device].free += search_key.bytes; + recached = true; + if (debug) { + CubLog("\tdevice %d returned %lld bytes from associated stream %lld.\n\t\t %lld available blocks cached (%lld bytes), %lld live blocks outstanding. (%lld bytes)\n", + device, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) cached_blocks.size(), + (long long) cached_bytes[device].free, (long long) live_blocks.size(), (long long) cached_bytes[device].busy); + } + } + } + Unlock(&spin_lock); - if (!d_ptr) - { - // Free device memory + if (recached) { + // Signal the event in the associated stream + if (CubDebug(error = cudaEventRecord(search_key.ready_event, search_key.associated_stream))) + return error; + } else { + // Set to specified device. Entrypoint may not be set. + if (device != entrypoint_device) { + if (CubDebug(error = cudaGetDevice(&entrypoint_device))) + return error; + if (CubDebug(error = cudaSetDevice(device))) return error; + } + + // Actually free device memory if (CubDebug(error = cudaFree(d_ptr))) return error; if (CubDebug(error = cudaEventDestroy(search_key.ready_event))) return error; - + if (debug) CubLog("\tdevice %d freed %lld bytes from associated stream %lld.\n\t\t %lld available blocks cached (%lld bytes), %lld live blocks (%lld bytes) outstanding.\n", device, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) cached_blocks.size(), (long long) cached_bytes[device].free, (long long) live_blocks.size(), (long long) cached_bytes[device].busy); - } - - if ((entrypoint_device != INVALID_DEVICE_ORDINAL) && (entrypoint_device != device)) - { - if (CubDebug(error = cudaSetDevice(entrypoint_device))) return error; + + if ((entrypoint_device != INVALID_DEVICE_ORDINAL) && (entrypoint_device != device)) + { + if (CubDebug(error = cudaSetDevice(entrypoint_device))) return error; + } } return error; @@ -654,7 +664,7 @@ struct CachingDeviceAllocator if (debug) CubLog("\tdevice %d freed %lld bytes.\n\t\t %lld available blocks cached (%lld bytes), %lld live blocks (%lld bytes) outstanding.\n", current_device, (long long) begin->bytes, (long long) cached_blocks.size(), (long long) cached_bytes[current_device].free, (long long) live_blocks.size(), (long long) cached_bytes[current_device].free); } - + Unlock(&spin_lock); // Attempt to revert back to entry-point device if necessary diff --git a/src/caffe/util/gpu_memory.cpp b/src/caffe/util/gpu_memory.cpp index acbf60c4233..7a219418b61 100644 --- a/src/caffe/util/gpu_memory.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -162,9 +162,9 @@ namespace caffe { // if you are paranoid, that doesn't mean they are not after you :) delete cubAlloc; - cubAlloc = new cub::CachingDeviceAllocator( 8, // defaults - 3, - 7, + cubAlloc = new cub::CachingDeviceAllocator( 2, // defaults + 6, + 16, poolsize_, false, debug_); From a1fbccd050f4565abfa1ec55a14d64b921673db3 Mon Sep 17 00:00:00 2001 From: Michael Houston Date: Tue, 17 Nov 2015 16:04:42 -0800 Subject: [PATCH 302/331] Change multi-solver handling by dividing user batch by gpu count, which is the solver count currently --- include/caffe/parallel.hpp | 3 +++ src/caffe/net.cpp | 3 +++ src/caffe/parallel.cpp | 51 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 57 insertions(+) diff --git a/include/caffe/parallel.hpp b/include/caffe/parallel.hpp index a3eb960c7d7..006ea79b628 100644 --- a/include/caffe/parallel.hpp +++ b/include/caffe/parallel.hpp @@ -97,6 +97,9 @@ class P2PSync : public GPUParams, public Solver::Callback, void run(const vector& gpus); + // Divide the batch size by the number of solvers + static void divide_batch_size(NetParameter* net); + protected: void on_start(); void on_gradients_ready(); diff --git a/src/caffe/net.cpp b/src/caffe/net.cpp index 1ad93e6af5f..25239a82082 100644 --- a/src/caffe/net.cpp +++ b/src/caffe/net.cpp @@ -46,6 +46,9 @@ void Net::Init(const NetParameter& in_param) { // the current NetState. NetParameter filtered_param; FilterNet(in_param, &filtered_param); + if (phase_ == TRAIN) { + caffe::P2PSync::divide_batch_size(&filtered_param); + } LOG_IF(INFO, Caffe::root_solver()) << "Initializing net from parameters: " << std::endl << filtered_param.DebugString(); diff --git a/src/caffe/parallel.cpp b/src/caffe/parallel.cpp index c7e0f106ec4..34ad49edf8a 100644 --- a/src/caffe/parallel.cpp +++ b/src/caffe/parallel.cpp @@ -447,6 +447,57 @@ void P2PSync::run(const vector& gpus) { } } +template +void P2PSync::divide_batch_size(NetParameter* net) { + int solver_count = Caffe::solver_count(); + for (int i = 0; i < net->layer_size(); ++i) { + string m = "Batch size must be divisible by the number of solvers (GPUs)"; + if (net->layer(i).has_data_param()) { + if (net->layer(i).data_param().has_batch_size()) { + uint32_t total = net->layer(i).data_param().batch_size(); + uint32_t batch = total / solver_count; + CHECK(batch * solver_count == total) << m; + net->mutable_layer(i)->mutable_data_param()->set_batch_size(batch); + } + } + if (net->layer(i).has_hdf5_data_param()) { + if (net->layer(i).hdf5_data_param().has_batch_size()) { + uint32_t total = net->layer(i).hdf5_data_param().batch_size(); + uint32_t batch = total / solver_count; + CHECK(batch * solver_count == total) << m; + net->mutable_layer(i)->mutable_hdf5_data_param()->set_batch_size(batch); + } + } + if (net->layer(i).has_image_data_param()) { + if (net->layer(i).image_data_param().has_batch_size()) { + uint32_t total = net->layer(i).image_data_param().batch_size(); + uint32_t batch = total / solver_count; + CHECK(batch * solver_count == total) << m; + net->mutable_layer(i)->mutable_image_data_param()->set_batch_size( + batch); + } + } + if (net->layer(i).has_memory_data_param()) { + if (net->layer(i).memory_data_param().has_batch_size()) { + uint32_t total = net->layer(i).memory_data_param().batch_size(); + uint32_t batch = total / solver_count; + CHECK(batch * solver_count == total) << m; + net->mutable_layer(i)->mutable_memory_data_param()->set_batch_size( + batch); + } + } + if (net->layer(i).has_window_data_param()) { + if (net->layer(i).window_data_param().has_batch_size()) { + uint32_t total = net->layer(i).window_data_param().batch_size(); + uint32_t batch = total / solver_count; + CHECK(batch * solver_count == total) << m; + net->mutable_layer(i)->mutable_window_data_param()->set_batch_size( + batch); + } + } + } +} + INSTANTIATE_CLASS(Params); INSTANTIATE_CLASS(GPUParams); INSTANTIATE_CLASS(P2PSync); From 66d5580bfa8de1e84f36d457482e931c264d05a5 Mon Sep 17 00:00:00 2001 From: Kang Kim Date: Sat, 7 Nov 2015 12:49:15 +0900 Subject: [PATCH 303/331] Update computation of variance and global stats in BatchNormLayer --- src/caffe/layers/batch_norm_layer.cpp | 55 +++++++++++++------------- src/caffe/layers/batch_norm_layer.cu | 56 ++++++++++++++------------- 2 files changed, 57 insertions(+), 54 deletions(-) diff --git a/src/caffe/layers/batch_norm_layer.cpp b/src/caffe/layers/batch_norm_layer.cpp index 94c2b96b9cd..5eba25e9024 100644 --- a/src/caffe/layers/batch_norm_layer.cpp +++ b/src/caffe/layers/batch_norm_layer.cpp @@ -2,7 +2,6 @@ #include #include "caffe/common_layers.hpp" -#include "caffe/layer.hpp" #include "caffe/util/math_functions.hpp" namespace caffe { @@ -80,20 +79,21 @@ void BatchNormLayer::Forward_cpu(const vector*>& bottom, int num = bottom[0]->shape(0); int spatial_dim = bottom[0]->count()/(bottom[0]->shape(0)*channels_); - // elementwise square - caffe_powx(bottom[0]->count(), bottom_data, Dtype(2), - temp_.mutable_cpu_data()); + if (bottom[0] != top[0]) { + caffe_copy(bottom[0]->count(), bottom_data, top_data); + } if (use_global_stats_) { // use the stored mean/variance estimates. TODO(cdoersch): allow an option // to use an unbiased variance estimate, like the paper does. - const Dtype scale_factor = 1 / this->blobs_[2]->cpu_data()[0]; + const Dtype scale_factor = this->blobs_[2]->cpu_data()[0] == 0 ? + 0 : 1 / this->blobs_[2]->cpu_data()[0]; caffe_cpu_scale(variance_.count(), scale_factor, this->blobs_[0]->cpu_data(), mean_.mutable_cpu_data()); caffe_cpu_scale(variance_.count(), scale_factor, this->blobs_[1]->cpu_data(), variance_.mutable_cpu_data()); } else { - // computes variance using var(X) = E(X^2) - (EX)^2 + // compute mean caffe_cpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, 1. / (num * spatial_dim), bottom_data, spatial_sum_multiplier_.cpu_data(), 0., @@ -101,44 +101,45 @@ void BatchNormLayer::Forward_cpu(const vector*>& bottom, caffe_cpu_gemv(CblasTrans, num, channels_, 1., num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0., mean_.mutable_cpu_data()); + } + + // subtract mean + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, + batch_sum_multiplier_.cpu_data(), mean_.cpu_data(), 0., + num_by_chans_.mutable_cpu_data()); + caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, channels_ * num, + spatial_dim, 1, -1, num_by_chans_.cpu_data(), + spatial_sum_multiplier_.cpu_data(), 1., top_data); + + if (!use_global_stats_) { + // compute variance using var(X) = E((X-EX)^2) + caffe_powx(top[0]->count(), top_data, Dtype(2), + temp_.mutable_cpu_data()); // (X-EX)^2 caffe_cpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, 1. / (num * spatial_dim), temp_.cpu_data(), spatial_sum_multiplier_.cpu_data(), 0., num_by_chans_.mutable_cpu_data()); caffe_cpu_gemv(CblasTrans, num, channels_, 1., num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0., - variance_.mutable_cpu_data()); + variance_.mutable_cpu_data()); // E((X_EX)^2) + + // compute and save moving average this->blobs_[2]->mutable_cpu_data()[0] *= moving_average_fraction_; this->blobs_[2]->mutable_cpu_data()[0] += 1; caffe_cpu_axpby(mean_.count(), Dtype(1), mean_.cpu_data(), moving_average_fraction_, this->blobs_[0]->mutable_cpu_data()); - Dtype m = Dtype(bottom[0]->count()/channels_); - caffe_cpu_axpby(variance_.count(), m/(m-1), variance_.cpu_data(), - moving_average_fraction_, this->blobs_[1]->mutable_cpu_data()); + int m = bottom[0]->count()/channels_; + Dtype bias_correction_factor = m > 1 ? Dtype(m)/(m-1) : 1; + caffe_cpu_axpby(variance_.count(), bias_correction_factor, + variance_.cpu_data(), moving_average_fraction_, + this->blobs_[1]->mutable_cpu_data()); } - // elementwise square of mean - caffe_powx(mean_.count(), mean_.cpu_data(), Dtype(2), - temp_.mutable_cpu_data()); - - caffe_sub(mean_.count(), variance_.cpu_data(), temp_.cpu_data(), - variance_.mutable_cpu_data()); // variance // normalize variance caffe_add_scalar(variance_.count(), eps_, variance_.mutable_cpu_data()); caffe_powx(variance_.count(), variance_.cpu_data(), Dtype(0.5), variance_.mutable_cpu_data()); - // do mean and variance normalization - if (bottom[0] != top[0]) { - caffe_copy(bottom[0]->count(), bottom_data, top_data); - } - // subtract mean - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, - batch_sum_multiplier_.cpu_data(), mean_.cpu_data(), 0., - num_by_chans_.mutable_cpu_data()); - caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, channels_ * num, - spatial_dim, 1, -1, num_by_chans_.cpu_data(), - spatial_sum_multiplier_.cpu_data(), 1., top_data); // replicate variance to input size caffe_cpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, batch_sum_multiplier_.cpu_data(), variance_.cpu_data(), 0., diff --git a/src/caffe/layers/batch_norm_layer.cu b/src/caffe/layers/batch_norm_layer.cu index cd8924a451d..921a58f07a9 100644 --- a/src/caffe/layers/batch_norm_layer.cu +++ b/src/caffe/layers/batch_norm_layer.cu @@ -2,7 +2,6 @@ #include #include "caffe/common_layers.hpp" -#include "caffe/layer.hpp" #include "caffe/util/math_functions.hpp" namespace caffe { @@ -15,20 +14,22 @@ void BatchNormLayer::Forward_gpu(const vector*>& bottom, int num = bottom[0]->shape(0); int spatial_dim = bottom[0]->count()/(channels_*bottom[0]->shape(0)); - // elementwise square - caffe_gpu_powx(bottom[0]->count(), bottom_data, Dtype(2), - temp_.mutable_gpu_data()); + if (bottom[0] != top[0]) { + caffe_copy(bottom[0]->count(), bottom_data, top_data); + } + if (use_global_stats_) { // use the stored mean/variance estimates. TODO(cdoersch): allow an option // to use an unbiased variance estimate, like the paper does. - const Dtype scale_factor = 1 / this->blobs_[2]->cpu_data()[0]; + const Dtype scale_factor = this->blobs_[2]->cpu_data()[0] == 0 ? + 0 : 1 / this->blobs_[2]->cpu_data()[0]; caffe_gpu_scale(variance_.count(), scale_factor, this->blobs_[0]->gpu_data(), mean_.mutable_gpu_data()); caffe_gpu_scale(variance_.count(), scale_factor, this->blobs_[1]->gpu_data(), variance_.mutable_gpu_data()); } else { - // computes variance using var(X) = E(X^2) - (EX)^2 + // compute mean caffe_gpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, 1. / (num * spatial_dim), bottom_data, spatial_sum_multiplier_.gpu_data(), 0., @@ -36,44 +37,45 @@ void BatchNormLayer::Forward_gpu(const vector*>& bottom, caffe_gpu_gemv(CblasTrans, num, channels_, 1., num_by_chans_.gpu_data(), batch_sum_multiplier_.gpu_data(), 0., mean_.mutable_gpu_data()); + } + + // subtract mean + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, + batch_sum_multiplier_.gpu_data(), mean_.gpu_data(), 0., + num_by_chans_.mutable_gpu_data()); + caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, channels_ * num, + spatial_dim, 1, -1, num_by_chans_.gpu_data(), + spatial_sum_multiplier_.gpu_data(), 1., top_data); + + if (!use_global_stats_) { + // compute variance using var(X) = E((X-EX)^2) + caffe_gpu_powx(top[0]->count(), top_data, Dtype(2), + temp_.mutable_gpu_data()); // (X-EX)^2 caffe_gpu_gemv(CblasNoTrans, channels_ * num, spatial_dim, 1. / (num * spatial_dim), temp_.gpu_data(), spatial_sum_multiplier_.gpu_data(), 0., num_by_chans_.mutable_gpu_data()); caffe_gpu_gemv(CblasTrans, num, channels_, 1., num_by_chans_.gpu_data(), batch_sum_multiplier_.gpu_data(), 0., - variance_.mutable_gpu_data()); + variance_.mutable_gpu_data()); // E((X_EX)^2) + + // compute and save moving average this->blobs_[2]->mutable_cpu_data()[0] *= moving_average_fraction_; this->blobs_[2]->mutable_cpu_data()[0] += 1; caffe_gpu_axpby(mean_.count(), Dtype(1), mean_.gpu_data(), moving_average_fraction_, this->blobs_[0]->mutable_gpu_data()); - Dtype m = Dtype(bottom[0]->count()/channels_); - caffe_gpu_axpby(variance_.count(), m/(m-1), variance_.gpu_data(), - moving_average_fraction_, this->blobs_[1]->mutable_gpu_data()); + int m = bottom[0]->count()/channels_; + Dtype bias_correction_factor = m > 1 ? Dtype(m)/(m-1) : 1; + caffe_gpu_axpby(variance_.count(), bias_correction_factor, + variance_.gpu_data(), moving_average_fraction_, + this->blobs_[1]->mutable_gpu_data()); } - // elementwise square of mean - caffe_gpu_powx(mean_.count(), mean_.gpu_data(), Dtype(2), - temp_.mutable_gpu_data()); - - caffe_gpu_sub(mean_.count(), variance_.gpu_data(), temp_.gpu_data(), - variance_.mutable_gpu_data()); // variance // normalize variance caffe_gpu_add_scalar(variance_.count(), eps_, variance_.mutable_gpu_data()); caffe_gpu_powx(variance_.count(), variance_.gpu_data(), Dtype(0.5), variance_.mutable_gpu_data()); - // do mean and variance normalization - if (bottom[0] != top[0]) { - caffe_copy(bottom[0]->count(), bottom_data, top_data); - } - // subtract mean - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, - batch_sum_multiplier_.gpu_data(), mean_.gpu_data(), 0., - num_by_chans_.mutable_gpu_data()); - caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, channels_ * num, - spatial_dim, 1, -1, num_by_chans_.gpu_data(), - spatial_sum_multiplier_.gpu_data(), 1., top_data); // replicate variance to input size caffe_gpu_gemm(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1, batch_sum_multiplier_.gpu_data(), variance_.gpu_data(), 0., From f31002d9ef791a75166f91eccd919aec838866c8 Mon Sep 17 00:00:00 2001 From: Kang Kim Date: Fri, 13 Nov 2015 02:20:02 +0900 Subject: [PATCH 304/331] Make backward pass work when global stats is active for BatchNormLayer including minor code cleaning --- src/caffe/layers/batch_norm_layer.cpp | 10 ++++++---- src/caffe/layers/batch_norm_layer.cu | 10 ++++++---- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/src/caffe/layers/batch_norm_layer.cpp b/src/caffe/layers/batch_norm_layer.cpp index 5eba25e9024..b5c91b5e1b3 100644 --- a/src/caffe/layers/batch_norm_layer.cpp +++ b/src/caffe/layers/batch_norm_layer.cpp @@ -84,8 +84,7 @@ void BatchNormLayer::Forward_cpu(const vector*>& bottom, } if (use_global_stats_) { - // use the stored mean/variance estimates. TODO(cdoersch): allow an option - // to use an unbiased variance estimate, like the paper does. + // use the stored mean/variance estimates. const Dtype scale_factor = this->blobs_[2]->cpu_data()[0] == 0 ? 0 : 1 / this->blobs_[2]->cpu_data()[0]; caffe_cpu_scale(variance_.count(), scale_factor, @@ -158,7 +157,6 @@ template void BatchNormLayer::Backward_cpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { - CHECK(!use_global_stats_); const Dtype* top_diff; if (bottom[0] != top[0]) { top_diff = top[0]->cpu_diff(); @@ -166,8 +164,12 @@ void BatchNormLayer::Backward_cpu(const vector*>& top, caffe_copy(x_norm_.count(), top[0]->cpu_diff(), x_norm_.mutable_cpu_diff()); top_diff = x_norm_.cpu_diff(); } - const Dtype* top_data = x_norm_.cpu_data(); Dtype* bottom_diff = bottom[0]->mutable_cpu_diff(); + if (use_global_stats_) { + caffe_div(temp_.count(), top_diff, temp_.cpu_data(), bottom_diff); + return; + } + const Dtype* top_data = x_norm_.cpu_data(); int num = bottom[0]->shape()[0]; int spatial_dim = bottom[0]->count()/(bottom[0]->shape(0)*channels_); // if Y = (X-mean(X))/(sqrt(var(X)+eps)), then diff --git a/src/caffe/layers/batch_norm_layer.cu b/src/caffe/layers/batch_norm_layer.cu index 921a58f07a9..2a6cac54168 100644 --- a/src/caffe/layers/batch_norm_layer.cu +++ b/src/caffe/layers/batch_norm_layer.cu @@ -20,8 +20,7 @@ void BatchNormLayer::Forward_gpu(const vector*>& bottom, if (use_global_stats_) { - // use the stored mean/variance estimates. TODO(cdoersch): allow an option - // to use an unbiased variance estimate, like the paper does. + // use the stored mean/variance estimates. const Dtype scale_factor = this->blobs_[2]->cpu_data()[0] == 0 ? 0 : 1 / this->blobs_[2]->cpu_data()[0]; caffe_gpu_scale(variance_.count(), scale_factor, @@ -94,7 +93,6 @@ template void BatchNormLayer::Backward_gpu(const vector*>& top, const vector& propagate_down, const vector*>& bottom) { - CHECK(!use_global_stats_); const Dtype* top_diff; if (bottom[0] != top[0]) { top_diff = top[0]->gpu_diff(); @@ -102,8 +100,12 @@ void BatchNormLayer::Backward_gpu(const vector*>& top, caffe_copy(x_norm_.count(), top[0]->gpu_diff(), x_norm_.mutable_gpu_diff()); top_diff = x_norm_.gpu_diff(); } - const Dtype* top_data = x_norm_.gpu_data(); Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + if (use_global_stats_) { + caffe_gpu_div(temp_.count(), top_diff, temp_.gpu_data(), bottom_diff); + return; + } + const Dtype* top_data = x_norm_.gpu_data(); int num = bottom[0]->shape()[0]; int spatial_dim = bottom[0]->count()/(channels_*bottom[0]->shape(0)); // if Y = (X-mean(X))/(sqrt(var(X)+eps)), then From 54811d35c19e837c0317a56bf9114e07ddc86f61 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Fri, 13 Nov 2015 18:34:28 -0800 Subject: [PATCH 305/331] Removing CNMEM switches Removed CNMEM references --- 3rdparty/Makefile | 16 ---------- CMakeLists.txt | 6 ---- Makefile | 6 ---- Makefile.config.example | 3 -- cmake/ConfigGen.cmake | 6 ---- cmake/Cuda.cmake | 36 ---------------------- cmake/Summary.cmake | 5 --- cmake/Templates/CaffeConfig.cmake.in | 3 +- cmake/Templates/caffe_config.h.in | 4 --- include/caffe/util/device_alternate.hpp | 12 -------- include/caffe/util/gpu_memory.hpp | 5 --- src/caffe/util/gpu_memory.cpp | 41 ------------------------- 12 files changed, 1 insertion(+), 142 deletions(-) delete mode 100644 3rdparty/Makefile diff --git a/3rdparty/Makefile b/3rdparty/Makefile deleted file mode 100644 index b8f8d96dae8..00000000000 --- a/3rdparty/Makefile +++ /dev/null @@ -1,16 +0,0 @@ -# Makefile for all third party libraries - -# NVidia CNMEM, https://github.com/NVIDIA/cnmem.git - -.PHONY: cnmem - -all: - @echo No targets to build! 3rd party target must be defined. - -CNMEM_BUILD_DIR=./cnmem/build -cnmem: - -rm -fr $(CNMEM_BUILD_DIR) - mkdir -p $(CNMEM_BUILD_DIR) - (cd $(CNMEM_BUILD_DIR) && cmake ..) - $(MAKE) -C $(CNMEM_BUILD_DIR) DEBUG=$(DEBUG) - cp $(CNMEM_BUILD_DIR)/*.so* $(INSTALLDIR)/lib diff --git a/CMakeLists.txt b/CMakeLists.txt index b3fd3464657..19a5f9fec6b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -22,7 +22,6 @@ include(cmake/ConfigGen.cmake) # ---[ Options caffe_option(CPU_ONLY "Build Caffe without CUDA support" OFF) # TODO: rename to USE_CUDA caffe_option(USE_CUDNN "Build Caffe with cuDNN library support" ON IF NOT CPU_ONLY) -caffe_option(USE_CNMEM "Build Caffe with CNMeM memory pool support" OFF) caffe_option(BUILD_SHARED_LIBS "Build shared libraries" ON) caffe_option(BUILD_python "Build Python wrapper" ON) set(python_version "2" CACHE STRING "Specify which Python version to use") @@ -42,11 +41,6 @@ if(UNIX OR APPLE) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -Wall") endif() -if(USE_CNMEM) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_CNMEM -lcnmem") - message("-- Info: Using CNMEM memory pool configuration") -endif() - if(USE_libstdcpp) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libstdc++") message("-- Warning: forcing libstdc++ (controlled by USE_libstdcpp option in cmake)") diff --git a/Makefile b/Makefile index 737bb491baa..b47c1ce01d9 100644 --- a/Makefile +++ b/Makefile @@ -325,12 +325,6 @@ ifeq ($(USE_CUDNN), 1) COMMON_FLAGS += -DUSE_CUDNN endif -# CNMEM integration -ifeq ($(USE_CNMEM), 1) - LIBRARIES += cnmem - COMMON_FLAGS += -DUSE_CNMEM -endif - # configure IO libraries ifeq ($(USE_OPENCV), 1) COMMON_FLAGS += -DUSE_OPENCV diff --git a/Makefile.config.example b/Makefile.config.example index 156a1828dc6..e55c685b185 100644 --- a/Makefile.config.example +++ b/Makefile.config.example @@ -4,9 +4,6 @@ # cuDNN acceleration switch (uncomment to build with cuDNN). # USE_CUDNN := 1 -# CNMeM memory pool switch (experimental, may go away) -# USE_CNMEM := 1 - # CPU-only switch (uncomment to build without GPU support). # CPU_ONLY := 1 diff --git a/cmake/ConfigGen.cmake b/cmake/ConfigGen.cmake index f0bff4eba32..056371110b5 100644 --- a/cmake/ConfigGen.cmake +++ b/cmake/ConfigGen.cmake @@ -77,12 +77,6 @@ function(caffe_generate_export_configs) list(APPEND DEFINITIONS -DUSE_CUDNN) endif() - if(NOT HAVE_CNMEM) - set(HAVE_CNMEM FALSE) - else() - list(APPEND DEFINITIONS -DUSE_CNMEM) - endif() - if(BLAS STREQUAL "MKL" OR BLAS STREQUAL "mkl") list(APPEND Caffe_DEFINITIONS -DUSE_MKL) endif() diff --git a/cmake/Cuda.cmake b/cmake/Cuda.cmake index 74f7a211796..223abe445ce 100644 --- a/cmake/Cuda.cmake +++ b/cmake/Cuda.cmake @@ -188,33 +188,6 @@ function(detect_cuDNN) endif() endfunction() -################################################################################################ -# Short command for cuDNN detection. Believe it soon will be a part of CUDA toolkit distribution. -# That's why not FindcuDNN.cmake file, but just the macro -# Usage: -# detect_cuDNN() -function(detect_CNMeM) - set(CNMEM_ROOT "" CACHE PATH "CNMeM root folder") - - find_path(CNMEM_INCLUDE cnmem.h - PATHS ${CNMEM_ROOT} $ENV{CNMEM_ROOT} ${CUDA_TOOLKIT_INCLUDE} - DOC "Path to CNMeM include directory." ) - - get_filename_component(__libpath_hist ${CUDA_CUDART_LIBRARY} PATH) - find_library(CNMEM_LIBRARY NAMES libcnmem.so # libcudnn_static.a - PATHS ${CNMEM_ROOT} $ENV{CNMEM_ROOT} ${CNMEM_INCLUDE} ${__libpath_hist} - DOC "Path to CNMeM library.") - - if(CNMEM_INCLUDE AND CNMEM_LIBRARY) - set(HAVE_CNMEM TRUE PARENT_SCOPE) - set(CNMEM_FOUND TRUE PARENT_SCOPE) - - mark_as_advanced(CNMEM_INCLUDE CNMEM_LIBRARY CNMEM_ROOT) - message(STATUS "Found CNMeM (include: ${CNMEM_INCLUDE}, library: ${CNMEM_LIBRARY})") - endif() -endfunction() - - ################################################################################################ ### Non macro section ################################################################################################ @@ -242,15 +215,6 @@ if(USE_CUDNN) endif() endif() -if(USE_CNMEM) - detect_CNMeM() - if(HAVE_CNMEM) - add_definitions(-DUSE_CNMEM) - include_directories(SYSTEM ${CNMEM_INCLUDE}) - list(APPEND Caffe_LINKER_LIBS ${CNMEM_LIBRARY}) - endif() -endif() - # setting nvcc arch flags caffe_select_nvcc_arch_flags(NVCC_FLAGS_EXTRA) list(APPEND CUDA_NVCC_FLAGS ${NVCC_FLAGS_EXTRA}) diff --git a/cmake/Summary.cmake b/cmake/Summary.cmake index f9e4a498063..55d649c7a86 100644 --- a/cmake/Summary.cmake +++ b/cmake/Summary.cmake @@ -146,11 +146,6 @@ function(caffe_print_configuration_summary) else() caffe_status(" cuDNN : Disabled") endif() - if (USE_CNMEM) - caffe_status(" CNMeM : " HAVE_CNMEM THEN "Yes" ELSE "Not found") - else() - caffe_status(" CNMeM : Disabled") - endif() caffe_status("") endif() if(HAVE_PYTHON) diff --git a/cmake/Templates/CaffeConfig.cmake.in b/cmake/Templates/CaffeConfig.cmake.in index 8f42801c359..2bd429c2a97 100644 --- a/cmake/Templates/CaffeConfig.cmake.in +++ b/cmake/Templates/CaffeConfig.cmake.in @@ -15,7 +15,6 @@ # # Caffe_HAVE_CUDA - signals about CUDA support # Caffe_HAVE_CUDNN - signals about cuDNN support -# Caffe_HAVE_CNMEM - signals about CNMeM support # # # @@ -60,4 +59,4 @@ set(Caffe_DEFINITIONS "@Caffe_DEFINITIONS@") set(Caffe_CPU_ONLY @CPU_ONLY@) set(Caffe_HAVE_CUDA @HAVE_CUDA@) set(Caffe_HAVE_CUDNN @HAVE_CUDNN@) -set(Caffe_HAVE_CNMEM @HAVE_CNMEM@) + diff --git a/cmake/Templates/caffe_config.h.in b/cmake/Templates/caffe_config.h.in index 26526c2fe86..5e2bfa9b9e7 100644 --- a/cmake/Templates/caffe_config.h.in +++ b/cmake/Templates/caffe_config.h.in @@ -10,10 +10,6 @@ /* NVIDA cuDNN */ #cmakedefine HAVE_CUDNN #cmakedefine USE_CUDNN - -/* NVIDIA CNMeM */ -#cmakedefine HAVE_CNMEM -#cmakedefine USE_CNMEM /* NVIDA cuDNN */ #cmakedefine CPU_ONLY diff --git a/include/caffe/util/device_alternate.hpp b/include/caffe/util/device_alternate.hpp index 53b780768e0..6ea595dba2d 100644 --- a/include/caffe/util/device_alternate.hpp +++ b/include/caffe/util/device_alternate.hpp @@ -66,18 +66,6 @@ void classname::funcname##_##gpu(const vector*>& top, \ << caffe::curandGetErrorString(status); \ } while (0) -#ifdef USE_CNMEM - -#define CNMEM_CHECK(condition) \ - do { \ - cnmemStatus_t status = condition; \ - CHECK_EQ(status, CNMEM_STATUS_SUCCESS) << " " \ - << cnmemGetErrorString(status); \ - } while (0) -#else -#define CNMEM_CHECK(condition) -#endif - // CUDA: grid stride looping #define CUDA_KERNEL_LOOP(i, n) \ for (int i = blockIdx.x * blockDim.x + threadIdx.x; \ diff --git a/include/caffe/util/gpu_memory.hpp b/include/caffe/util/gpu_memory.hpp index 84b84649457..b1a6c919cf7 100644 --- a/include/caffe/util/gpu_memory.hpp +++ b/include/caffe/util/gpu_memory.hpp @@ -10,16 +10,11 @@ class gpu_memory { public: enum PoolMode { NoPool, // Straight CUDA malllc/free. May be very expensive - CnMemPool, // CNMEM arena allocator CubPool, // CUB caching allocator #ifdef CPU_ONLY DefaultPool = NoPool #else -# if (USE_CNMEM) && !defined (__arm__) - DefaultPool = CnMemPool // CNMEM pool only uses dedicated video memory. -# else DefaultPool = CubPool // CUB pool is able to use unified memory properly -# endif #endif }; diff --git a/src/caffe/util/gpu_memory.cpp b/src/caffe/util/gpu_memory.cpp index 7a219418b61..5dd312153cc 100644 --- a/src/caffe/util/gpu_memory.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -1,15 +1,9 @@ #include #include #include "caffe/common.hpp" - #include "caffe/util/gpu_memory.hpp" -#ifdef USE_CNMEM -// CNMEM integration -#include "cnmem.h" -#endif - #ifndef CPU_ONLY #include "cub/cub/util_allocator.cuh" #endif @@ -42,7 +36,6 @@ namespace caffe { switch (m) { case CubPool: - case CnMemPool: initMEM(gpus, m); break; default: @@ -56,9 +49,6 @@ namespace caffe { void gpu_memory::destroy() { switch (mode_) { - case CnMemPool: - CNMEM_CHECK(cnmemFinalize()); - break; case CubPool: delete cubAlloc; cubAlloc = NULL; @@ -73,9 +63,6 @@ namespace caffe { void gpu_memory::allocate(void **ptr, size_t size, cudaStream_t stream) { CHECK((ptr) != NULL); switch (mode_) { - case CnMemPool: - CNMEM_CHECK(cnmemMalloc(ptr, size, stream)); - break; case CubPool: CUDA_CHECK(cubAlloc->DeviceAllocate(ptr, size, stream)); break; @@ -90,9 +77,6 @@ namespace caffe { if (!ptr) return; switch (mode_) { - case CnMemPool: - CNMEM_CHECK(cnmemFree(ptr, stream)); - break; case CubPool: CUDA_CHECK(cubAlloc->DeviceFree(ptr)); break; @@ -104,9 +88,6 @@ namespace caffe { void gpu_memory::registerStream(cudaStream_t stream) { switch (mode_) { - case CnMemPool: - CNMEM_CHECK(cnmemRegisterStream(stream)); - break; case CubPool: default: break; @@ -116,9 +97,6 @@ namespace caffe { void gpu_memory::initMEM(const std::vector& gpus, PoolMode m) { mode_ = m; int initial_device; -#if USE_CNMEM - cnmemDevice_t* devs = new cnmemDevice_t[gpus.size()]; -#endif CUDA_CHECK(cudaGetDevice(&initial_device)); @@ -142,21 +120,10 @@ namespace caffe { // find out the smallest GPU size if (poolsize_ == 0 || poolsize_ > free_mem) poolsize_ = free_mem; -#if USE_CNMEM - devs[i].device = gpus[i]; - devs[i].size = free_mem; - devs[i].numStreams = 0; - devs[i].streams = NULL; -#endif } switch ( mode_ ) { - case CnMemPool: -#if USE_CNMEM - CNMEM_CHECK(cnmemInit(gpus.size(), devs, CNMEM_FLAGS_DEFAULT)); -#endif - break; case CubPool: try { // if you are paranoid, that doesn't mean they are not after you :) @@ -177,15 +144,10 @@ namespace caffe { } CUDA_CHECK(cudaSetDevice(initial_device)); -#if USE_CNMEM - delete [] devs; -#endif } const char* gpu_memory::getPoolName() { switch (mode_) { - case CnMemPool: - return "CNMEM Pool"; case CubPool: return "CUB Pool"; default: @@ -195,9 +157,6 @@ namespace caffe { void gpu_memory::getInfo(size_t *free_mem, size_t *total_mem) { switch (mode_) { - case CnMemPool: - CNMEM_CHECK(cnmemMemGetInfo(free_mem, total_mem, cudaStreamDefault)); - break; case CubPool: int cur_device; CUDA_CHECK(cudaGetDevice(&cur_device)); From e0e64327f4caad991a68e180cb9fd6736e594dc4 Mon Sep 17 00:00:00 2001 From: Michael Houston Date: Fri, 20 Nov 2015 22:15:43 -0800 Subject: [PATCH 306/331] Fix gradient test to handle batch size correctly now that we divide --- src/caffe/test/test_gradient_based_solver.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index 7ad7467f86f..b9752eba33d 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -467,7 +467,6 @@ class GradientBasedSolverTest : public MultiDeviceTest { void TestLeastSquaresUpdate(const Dtype learning_rate = 1.0, const Dtype weight_decay = 0.0, const Dtype momentum = 0.0, const int iter_to_check = 0) { - const int kNum = num_; const int kIterSize = 1; // Test over all numbers of devices. int available_devices = 1; @@ -475,11 +474,12 @@ class GradientBasedSolverTest : public MultiDeviceTest { if (Caffe::mode() == Caffe::GPU) { CUDA_CHECK(cudaGetDeviceCount(&available_devices)); } + const int kNum = num_; #endif for (int devices = 1; devices <= available_devices; ++devices) { // Configure batch size for single / multi device equivalence. // Constant data is needed for multi device as for accumulation. - num_ = kNum * devices; + num_ = kNum * devices * devices; // Initialize the solver and run K (= iter_to_check) solver iterations // (on single device). @@ -492,12 +492,15 @@ class GradientBasedSolverTest : public MultiDeviceTest { iter_to_check + 1, &updated_params); // Reinitialize the solver and run K+1 solver iterations. - num_ = kNum; + num_ = kNum * devices; RunLeastSquaresSolver(learning_rate, weight_decay, momentum, iter_to_check + 1, kIterSize, devices); // Check that the solver's solution matches ours. CheckLeastSquaresUpdate(updated_params); + + // Reset initial value of num_ + num_ = kNum; } } From e1680b00d86ea69e1f10bfa122ce72786ada3108 Mon Sep 17 00:00:00 2001 From: Michael Houston Date: Fri, 20 Nov 2015 22:15:43 -0800 Subject: [PATCH 307/331] Fix gradient test to handle batch size correctly now that we divide --- src/caffe/test/test_gradient_based_solver.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/caffe/test/test_gradient_based_solver.cpp b/src/caffe/test/test_gradient_based_solver.cpp index 7ad7467f86f..cae6ce1d27a 100644 --- a/src/caffe/test/test_gradient_based_solver.cpp +++ b/src/caffe/test/test_gradient_based_solver.cpp @@ -467,8 +467,8 @@ class GradientBasedSolverTest : public MultiDeviceTest { void TestLeastSquaresUpdate(const Dtype learning_rate = 1.0, const Dtype weight_decay = 0.0, const Dtype momentum = 0.0, const int iter_to_check = 0) { - const int kNum = num_; const int kIterSize = 1; + const int kNum = num_; // Test over all numbers of devices. int available_devices = 1; #ifndef CPU_ONLY @@ -479,7 +479,7 @@ class GradientBasedSolverTest : public MultiDeviceTest { for (int devices = 1; devices <= available_devices; ++devices) { // Configure batch size for single / multi device equivalence. // Constant data is needed for multi device as for accumulation. - num_ = kNum * devices; + num_ = kNum * devices * devices; // Initialize the solver and run K (= iter_to_check) solver iterations // (on single device). @@ -492,12 +492,15 @@ class GradientBasedSolverTest : public MultiDeviceTest { iter_to_check + 1, &updated_params); // Reinitialize the solver and run K+1 solver iterations. - num_ = kNum; + num_ = kNum * devices; RunLeastSquaresSolver(learning_rate, weight_decay, momentum, iter_to_check + 1, kIterSize, devices); // Check that the solver's solution matches ours. CheckLeastSquaresUpdate(updated_params); + + // Reset initial value of num_ + num_ = kNum; } } From 1664af418d8065a80e68d135606ca07f3bc6d4b2 Mon Sep 17 00:00:00 2001 From: Michael Houston Date: Mon, 23 Nov 2015 13:12:42 -0800 Subject: [PATCH 308/331] Cleanup docs to reflect multigpu batch change --- docs/multigpu.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/multigpu.md b/docs/multigpu.md index 01cfb8938b5..73244460fc7 100644 --- a/docs/multigpu.md +++ b/docs/multigpu.md @@ -8,7 +8,9 @@ Currently Multi-GPU is only supported via the C/C++ paths and only for training. The GPUs to be used for training can be set with the "-gpu" flag on the command line to the 'caffe' tool. e.g. "build/tools/caffe train --solver=models/bvlc_alexnet/solver.prototxt --gpu=0,1" will train on GPUs 0 and 1. -**NOTE**: each GPU runs the batchsize specified in your train_val.prototxt. So if you go from 1 GPU to 2 GPU, your effective batchsize will double. e.g. if your train_val.prototxt specified a batchsize of 256, if you run 2 GPUs your effective batch size is now 512. So you need to adjust the batchsize when running multiple GPUs and/or adjust your solver params, specifically learning rate. +**NOTE**: There is a difference between the Nvidia and BVLC branches. On BVLC Master each GPU runs the batchsize specified in your train_val.prototxt. So if you go from 1 GPU to 2 GPU, your effective batchsize will double. e.g. if your train_val.prototxt specified a batchsize of 256, if you run 2 GPUs your effective batch size is now 512. So you need to adjust the batchsize when running multiple GPUs and/or adjust your solver params, specifically learning rate. + +In contrast, this branch divides the batchsize in train_val.prototxt by the number of GPUs to keep the total batchsize the same as specified. # Hardware Configuration Assumptions @@ -17,7 +19,7 @@ updated model, 0\-\>2, and then 0\-\>1, 2\-\>3. For best performance, P2P DMA access between devices is needed. Without P2P access, for example crossing PCIe root complex, data is copied through host and effective exchange bandwidth is greatly reduced. -Current implementation has a "soft" assumption that the devices being used are homogeneous. In practice, any devices of the same general class should work together, but performance and total size is limited by the smallest device being used. e.g. if you combine a TitanX and a GTX980, peformance will be limited by the 980. Mixing vastly different levels of boards, e.g. Kepler and Fermi, is not supported. +Current implementation has a "soft" assumption that the devices being used are homogeneous. In practice, any devices of the same general class should work together, but performance and total size is limited by the smallest device being used. e.g. if you combine a TitanX and a GTX980, peformance will be limited by the 980. Mixing vastly different levels of boards, e.g. Kepler and Fermi, is not supported. Also, if you use different devices, the fast RDMA paths may fail to trigger. "nvidia-smi topo -m" will show you the connectivity matrix. You can do P2P through PCIe bridges, but not across socket level links at this time, e.g. across CPU sockets on a multi-socket motherboard. From ff3882473beacbf335b858210719c857374e3200 Mon Sep 17 00:00:00 2001 From: Andrei Pokrovsky Date: Mon, 23 Nov 2015 19:08:02 -0800 Subject: [PATCH 309/331] Add cudnn v4 batch normalization integration --- include/caffe/common_layers.hpp | 29 ++++++ src/caffe/layer_factory.cpp | 23 +++++ src/caffe/layers/batch_norm_layer.cpp | 1 - src/caffe/layers/cudnn_batch_norm_layer.cpp | 97 ++++++++++++++++++ src/caffe/layers/cudnn_batch_norm_layer.cu | 106 ++++++++++++++++++++ src/caffe/proto/caffe.proto | 8 ++ src/caffe/test/test_batch_norm_layer.cpp | 92 +++++++++++++++++ 7 files changed, 355 insertions(+), 1 deletion(-) create mode 100644 src/caffe/layers/cudnn_batch_norm_layer.cpp create mode 100644 src/caffe/layers/cudnn_batch_norm_layer.cu diff --git a/include/caffe/common_layers.hpp b/include/caffe/common_layers.hpp index 3277f1b6c2c..385615c71a5 100644 --- a/include/caffe/common_layers.hpp +++ b/include/caffe/common_layers.hpp @@ -145,6 +145,35 @@ class BatchNormLayer : public Layer { Blob spatial_sum_multiplier_; }; +#ifdef USE_CUDNN +template +class CuDNNBatchNormLayer : public BatchNormLayer { + public: + explicit CuDNNBatchNormLayer(const LayerParameter& param) + : BatchNormLayer(param), epsilon_(1e-4), handles_setup_(false) {} + virtual void LayerSetUp(const vector*>& bottom, + const vector*>& top); + virtual void Reshape(const vector*>& bottom, + const vector*>& top); + virtual ~CuDNNBatchNormLayer(); + + protected: + virtual void Forward_gpu(const vector*>& bottom, + const vector*>& top); + virtual void Backward_gpu(const vector*>& top, + const vector& propagate_down, const vector*>& bottom); + + // cuDNN descriptors / handles + cudnnTensorDescriptor_t bottom_desc_, top_desc_; + cudnnTensorDescriptor_t scale_bias_mean_var_desc_; + cudnnBatchNormMode_t mode_; + + double epsilon_; + Blob save_mean_, save_inv_var_; + bool handles_setup_; +}; +#endif + /** * @brief Takes at least two Blob%s and concatenates them along either the num * or channel dimension, outputting the result. diff --git a/src/caffe/layer_factory.cpp b/src/caffe/layer_factory.cpp index 989c348c1bb..0d1625602db 100644 --- a/src/caffe/layer_factory.cpp +++ b/src/caffe/layer_factory.cpp @@ -40,6 +40,29 @@ shared_ptr > GetConvolutionLayer( REGISTER_LAYER_CREATOR(Convolution, GetConvolutionLayer); +// Get BN layer according to engine. +template +shared_ptr > GetBatchNormLayer(const LayerParameter& param) { + BatchNormParameter_Engine engine = param.batch_norm_param().engine(); + if (engine == BatchNormParameter_Engine_DEFAULT) { + engine = BatchNormParameter_Engine_CAFFE; +#ifdef USE_CUDNN + engine = BatchNormParameter_Engine_CUDNN; +#endif + } + if (engine == BatchNormParameter_Engine_CAFFE) { + return shared_ptr >(new BatchNormLayer(param)); +#ifdef USE_CUDNN + } else if (engine == BatchNormParameter_Engine_CUDNN) { + return shared_ptr >(new CuDNNBatchNormLayer(param)); +#endif + } else { + LOG(FATAL) << "Layer " << param.name() << " has unknown engine."; + } +} + +REGISTER_LAYER_CREATOR(BatchNorm, GetBatchNormLayer); + // Get pooling layer according to engine. template shared_ptr > GetPoolingLayer(const LayerParameter& param) { diff --git a/src/caffe/layers/batch_norm_layer.cpp b/src/caffe/layers/batch_norm_layer.cpp index b5c91b5e1b3..64e3f4d77da 100644 --- a/src/caffe/layers/batch_norm_layer.cpp +++ b/src/caffe/layers/batch_norm_layer.cpp @@ -235,5 +235,4 @@ STUB_GPU(BatchNormLayer); #endif INSTANTIATE_CLASS(BatchNormLayer); -REGISTER_LAYER_CLASS(BatchNorm); } // namespace caffe diff --git a/src/caffe/layers/cudnn_batch_norm_layer.cpp b/src/caffe/layers/cudnn_batch_norm_layer.cpp new file mode 100644 index 00000000000..eec324e25d1 --- /dev/null +++ b/src/caffe/layers/cudnn_batch_norm_layer.cpp @@ -0,0 +1,97 @@ +#ifdef USE_CUDNN + +#include + +#include "caffe/filler.hpp" +#include "caffe/layer.hpp" +#include "caffe/util/im2col.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void CuDNNBatchNormLayer::LayerSetUp( + const vector*>& bottom, + const vector*>& top) { + BatchNormLayer::LayerSetUp(bottom, top); + + cudnn::createTensor4dDesc(&bottom_desc_); + cudnn::createTensor4dDesc(&top_desc_); + cudnn::createTensor4dDesc(&scale_bias_mean_var_desc_); + + // currently only SPATIAL mode is supported (most commonly used mode) + // If there's enough demand we can implement CUDNN_BATCHNORM_PER_ACTIVATION + // though it's not currently implemented for the CPU layer + mode_ = CUDNN_BATCHNORM_SPATIAL; + + if (this->blobs_.size() > 5) { + LOG(INFO) << "Skipping parameter initialization"; + } else { + this->blobs_.resize(5); + this->blobs_[0].reset(new Blob(1, bottom[0]->channels(), 1, 1)); + this->blobs_[1].reset(new Blob(1, bottom[0]->channels(), 1, 1)); + this->blobs_[2].reset(new Blob(1, 1, 1, 1)); + this->blobs_[3].reset(new Blob(1, bottom[0]->channels(), 1, 1)); + this->blobs_[4].reset(new Blob(1, bottom[0]->channels(), 1, 1)); + + shared_ptr > scale_filler( + GetFiller(this->layer_param_.batch_norm_param().scale_filler())); + scale_filler->Fill(this->blobs_[0].get()); + + shared_ptr > bias_filler( + GetFiller(this->layer_param_.batch_norm_param().bias_filler())); + bias_filler->Fill(this->blobs_[1].get()); + + for (int i = 2; i < 5; i++) { + caffe_set(this->blobs_[i]->count(), Dtype(0), + this->blobs_[i]->mutable_cpu_data()); + } + } + + handles_setup_ = true; +} + +template +void CuDNNBatchNormLayer::Reshape( + const vector*>& bottom, + const vector*>& top) { + BatchNormLayer::Reshape(bottom, top); + + // set up main tensors + cudnn::setTensor4dDesc( + &bottom_desc_, bottom[0]->num(), + bottom[0]->channels(), bottom[0]->height(), bottom[0]->width()); + cudnn::setTensor4dDesc( + &top_desc_, bottom[0]->num(), + bottom[0]->channels(), bottom[0]->height(), bottom[0]->width()); + + // aux tensors for caching mean & invVar from fwd to bwd pass + int C = bottom[0]->channels(); + int H = bottom[0]->height(); + int W = bottom[0]->width(); + if (mode_ == CUDNN_BATCHNORM_SPATIAL) { + save_mean_.Reshape(1, C, 1, 1); + save_inv_var_.Reshape(1, C, 1, 1); + } else if (mode_ == CUDNN_BATCHNORM_PER_ACTIVATION) { + save_mean_.Reshape(1, C, H, W); + save_inv_var_.Reshape(1, C, H, W); + } else { + LOG(FATAL) << "Unknown cudnnBatchNormMode_t"; + } + CUDNN_CHECK(cudnnDeriveBNTensorDescriptor(scale_bias_mean_var_desc_, + bottom_desc_, mode_)); +} + +template +CuDNNBatchNormLayer::~CuDNNBatchNormLayer() { + if (!handles_setup_) return; + + cudnnDestroyTensorDescriptor(bottom_desc_); + cudnnDestroyTensorDescriptor(top_desc_); + cudnnDestroyTensorDescriptor(scale_bias_mean_var_desc_); +} + +INSTANTIATE_CLASS(CuDNNBatchNormLayer); +} // namespace caffe +#endif diff --git a/src/caffe/layers/cudnn_batch_norm_layer.cu b/src/caffe/layers/cudnn_batch_norm_layer.cu new file mode 100644 index 00000000000..bc1ee25154d --- /dev/null +++ b/src/caffe/layers/cudnn_batch_norm_layer.cu @@ -0,0 +1,106 @@ +#ifdef USE_CUDNN +#include +#include +#include + +#include "thrust/device_vector.h" + +#include "caffe/layer.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/vision_layers.hpp" + +namespace caffe { + +template +void CuDNNBatchNormLayer::Forward_gpu( + const vector*>& bottom, + const vector*>& top) { + const Dtype* bottom_data = bottom[0]->gpu_data(); + const Dtype* scale_data = this->blobs_[0]->gpu_data(); + const Dtype* bias_data = this->blobs_[1]->gpu_data(); + + Dtype* top_data = top[0]->mutable_gpu_data(); + Dtype* save_mean = save_mean_.mutable_gpu_data(); + Dtype* save_inv_var = save_inv_var_.mutable_gpu_data(); + + if (this->phase_ == TRAIN) { + // Call Batch normalization forward + CUDNN_CHECK(cudnnBatchNormalizationForwardTraining( + Caffe::cudnn_handle(), + mode_, + cudnn::dataType::one, + cudnn::dataType::zero, + bottom_desc_, + bottom_data, + bottom_desc_, + top_data, + scale_bias_mean_var_desc_, + scale_data, + bias_data, + 1-this->moving_average_fraction_, + this->blobs_[3]->mutable_gpu_data(), // mean + this->blobs_[4]->mutable_gpu_data(), // variance + epsilon_, + save_mean, + save_inv_var)); + } else if (this->phase_ == TEST) { + CUDNN_CHECK(cudnnBatchNormalizationForwardInference( + Caffe::cudnn_handle(), + mode_, + cudnn::dataType::one, + cudnn::dataType::zero, + bottom_desc_, + bottom_data, + bottom_desc_, + top_data, + scale_bias_mean_var_desc_, + scale_data, + bias_data, + this->blobs_[3]->gpu_data(), // mean + this->blobs_[4]->gpu_data(), // variance + epsilon_)); + } else { + LOG(FATAL) << "Unknown phase"; + } +} + +template +void CuDNNBatchNormLayer::Backward_gpu( + const vector*>& top, + const vector& propagate_down, const vector*>& bottom) { + const Dtype* top_data = top[0]->gpu_data(); + const Dtype* top_diff = top[0]->gpu_diff(); + const Dtype* bottom_data = bottom[0]->gpu_data(); + const Dtype* save_mean = save_mean_.gpu_data(); + const Dtype* save_inv_var = save_inv_var_.gpu_data(); + + Dtype* bottom_diff = bottom[0]->mutable_gpu_diff(); + const Dtype* scale_data = this->blobs_[0]->gpu_data(); + Dtype* scale_diff = this->blobs_[0]->mutable_gpu_diff(); + Dtype* bias_diff = this->blobs_[1]->mutable_gpu_diff(); + + // call Batch Normalization Backward + CUDNN_CHECK(cudnnBatchNormalizationBackward( + Caffe::cudnn_handle(), + mode_, + cudnn::dataType::one, + cudnn::dataType::zero, + bottom_desc_, + bottom_data, + bottom_desc_, + top_diff, + bottom_desc_, + bottom_diff, + scale_bias_mean_var_desc_, + scale_data, + scale_diff, + bias_diff, + this->epsilon_, + save_mean, + save_inv_var)); +} + +INSTANTIATE_LAYER_GPU_FUNCS(CuDNNBatchNormLayer); + +} // namespace caffe +#endif diff --git a/src/caffe/proto/caffe.proto b/src/caffe/proto/caffe.proto index b81f39f90fa..98a10cbdae4 100644 --- a/src/caffe/proto/caffe.proto +++ b/src/caffe/proto/caffe.proto @@ -472,6 +472,14 @@ message BatchNormParameter { // Small value to add to the variance estimate so that we don't divide by // zero. optional float eps = 3 [default = 1e-5]; + optional FillerParameter scale_filler = 5; + optional FillerParameter bias_filler = 6; + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 15 [default = DEFAULT]; } message ContrastiveLossParameter { diff --git a/src/caffe/test/test_batch_norm_layer.cpp b/src/caffe/test/test_batch_norm_layer.cpp index 22b9667f31b..59bf9b6ed2a 100644 --- a/src/caffe/test/test_batch_norm_layer.cpp +++ b/src/caffe/test/test_batch_norm_layer.cpp @@ -130,4 +130,96 @@ namespace caffe { this->blob_top_vec_); } +#ifdef USE_CUDNN +template +class CuDNNBatchNormLayerTest : public GPUDeviceTest { + protected: + CuDNNBatchNormLayerTest() + : blob_bottom_(new Blob(2, 3, 4, 5)), + blob_top_(new Blob()) { + // fill the values + FillerParameter filler_param; + filler_param.set_mean(-10); + filler_param.set_std(5); + GaussianFiller filler(filler_param); + filler.Fill(this->blob_bottom_); + blob_bottom_vec_.push_back(blob_bottom_); + blob_top_vec_.push_back(blob_top_); + } + virtual ~CuDNNBatchNormLayerTest() { delete blob_bottom_; delete blob_top_; } + void checkMeanVar(const Blob *blob_bottom, int num, + int channels, int height, int width); + Blob* const blob_bottom_; + Blob* const blob_top_; + vector*> blob_bottom_vec_; + vector*> blob_top_vec_; +}; + +template +void CuDNNBatchNormLayerTest::checkMeanVar( + const Blob *top, + int num, int channels, int height, int width) { + typedef TypeParam Dtype; + + for (int j = 0; j < channels; ++j) { + Dtype mean = 0, var = 0; + for (int i = 0; i < num; ++i) { + for (int k = 0; k < height; ++k) { + for (int l = 0; l < width; ++l) { + Dtype data = top->data_at(i, j, k, l); + mean += data; + var += data * data; + } + } + } + mean /= num * height * width; + var /= num * height * width; + + const Dtype kErrorBound = 0.001; + EXPECT_NEAR(0, mean, kErrorBound); + EXPECT_NEAR(1, var, kErrorBound); + } +} + +TYPED_TEST_CASE(CuDNNBatchNormLayerTest, TestDtypes); + +TYPED_TEST(CuDNNBatchNormLayerTest, TestForward) { + Caffe::set_random_seed(1701); + typedef TypeParam Dtype; + LayerParameter layer_param; + BatchNormParameter* bn_param = layer_param.mutable_batch_norm_param(); + FillerParameter *scale_param = bn_param->mutable_scale_filler(); + scale_param->set_value(1); + + CuDNNBatchNormLayer layer(layer_param); + layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Reshape(this->blob_bottom_vec_, this->blob_top_vec_); + layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_); + + // Test mean + Dtype mean, var; + int num = this->blob_bottom_->num(); + int channels = this->blob_bottom_->channels(); + int height = this->blob_bottom_->height(); + int width = this->blob_bottom_->width(); + + this->checkMeanVar(this->blob_top_, num, channels, height, width); +} + +TYPED_TEST(CuDNNBatchNormLayerTest, TestGradient) { + typedef TypeParam Dtype; + LayerParameter layer_param; + BatchNormParameter* bn_param = layer_param.mutable_batch_norm_param(); + FillerParameter *scale_param = bn_param->mutable_scale_filler(); + scale_param->set_value(1); + FillerParameter *bias_param = bn_param->mutable_bias_filler(); + bias_param->set_value(0); + + CuDNNBatchNormLayer layer(layer_param); + GradientChecker checker(1e-2, 4e-4); + checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, + this->blob_top_vec_); +} +#endif + } // namespace caffe From 72760f20a11a9b17c8901a937d595c43d6b3a340 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Tue, 24 Nov 2015 14:50:08 -0800 Subject: [PATCH 310/331] Mark v0.14.0-rc.2 --- CMakeLists.txt | 2 +- Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 19a5f9fec6b..5db96196761 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8.7) project(Caffe C CXX) # ---[ Caffe version -set(CAFFE_TARGET_VERSION "0.14.0-rc.1") +set(CAFFE_TARGET_VERSION "0.14.0-rc.2") set(CAFFE_TARGET_SOVERSION "0.14") add_definitions(-DCAFFE_VERSION=${CAFFE_TARGET_VERSION}) diff --git a/Makefile b/Makefile index b47c1ce01d9..212488110d7 100644 --- a/Makefile +++ b/Makefile @@ -43,7 +43,7 @@ LIB_BUILD_DIR := $(BUILD_DIR)/lib STATIC_NAME := $(LIB_BUILD_DIR)/lib$(LIBRARY_NAME).a DYNAMIC_VERSION_MAJOR := 0 DYNAMIC_VERSION_MINOR := 14 -DYNAMIC_VERSION_REVISION := 0-rc.1 +DYNAMIC_VERSION_REVISION := 0-rc.2 DYNAMIC_NAME_SHORT := lib$(LIBRARY_NAME).so DYNAMIC_SONAME_SHORT := $(DYNAMIC_NAME_SHORT).$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR) DYNAMIC_VERSIONED_NAME_SHORT := $(DYNAMIC_SONAME_SHORT).$(DYNAMIC_VERSION_REVISION) From 155beaf171eb491d0a1733492e88e1f1a44d6071 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 1 Dec 2015 16:35:13 -0800 Subject: [PATCH 311/331] CUB allocator improvements: no guessing in get_info, infinite pool, limiting memory overuse for large blocks --- 3rdparty/cub/cub/util_allocator.cuh | 27 ++++++++------- src/caffe/util/gpu_memory.cpp | 51 ++++------------------------- tools/caffe.cpp | 1 + 3 files changed, 24 insertions(+), 55 deletions(-) diff --git a/3rdparty/cub/cub/util_allocator.cuh b/3rdparty/cub/cub/util_allocator.cuh index 7f6bebe7f74..a6b6f25022d 100644 --- a/3rdparty/cub/cub/util_allocator.cuh +++ b/3rdparty/cub/cub/util_allocator.cuh @@ -407,6 +407,11 @@ struct CachingDeviceAllocator while ( (block_itr != cached_blocks.end()) && (block_itr->device == device) && (block_itr->bin == search_key.bin)) { + + // use special rule for the last ("exact size") bin: set max memory overuse to 1/8th + if (search_key.bin == -1 && (block_itr->bytes - search_key.bytes)*8UL > search_key.bytes) + break; + cudaStream_t prev_stream = block_itr->associated_stream; if ((active_stream == prev_stream) || (cudaEventQuery(block_itr->ready_event) != cudaErrorNotReady)) { @@ -460,11 +465,11 @@ struct CachingDeviceAllocator error = cudaMalloc(&search_key.d_ptr, search_key.bytes); // } } - if (CubDebug(error)) + if (CubDebug(error)) return error; - if (CubDebug(error = cudaEventCreateWithFlags(&search_key.ready_event, cudaEventDisableTiming))) + if (CubDebug(error = cudaEventCreateWithFlags(&search_key.ready_event, cudaEventDisableTiming))) return error; - + // Insert into live blocks Lock(&spin_lock); live_blocks.insert(search_key); @@ -543,30 +548,30 @@ struct CachingDeviceAllocator // Lock Lock(&spin_lock); - + // Find corresponding block descriptor BusyBlocks::iterator block_itr = live_blocks.find(search_key); if (block_itr != live_blocks.end()) { // Remove from live blocks search_key = *block_itr; - live_blocks.erase(block_itr); + live_blocks.erase(block_itr); cached_bytes[device].busy -= search_key.bytes; - + // Check if we should keep the returned allocation if (cached_bytes[device].free + search_key.bytes <= max_cached_bytes) - { + { // Insert returned allocation into free blocks cached_blocks.insert(search_key); cached_bytes[device].free += search_key.bytes; recached = true; - if (debug) { + if (debug) { CubLog("\tdevice %d returned %lld bytes from associated stream %lld.\n\t\t %lld available blocks cached (%lld bytes), %lld live blocks outstanding. (%lld bytes)\n", - device, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) cached_blocks.size(), + device, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) cached_blocks.size(), (long long) cached_bytes[device].free, (long long) live_blocks.size(), (long long) cached_bytes[device].busy); } } } - + Unlock(&spin_lock); if (recached) { @@ -580,7 +585,7 @@ struct CachingDeviceAllocator return error; if (CubDebug(error = cudaSetDevice(device))) return error; } - + // Actually free device memory if (CubDebug(error = cudaFree(d_ptr))) return error; if (CubDebug(error = cudaEventDestroy(search_key.ready_event))) return error; diff --git a/src/caffe/util/gpu_memory.cpp b/src/caffe/util/gpu_memory.cpp index 5dd312153cc..95e6fdb8626 100644 --- a/src/caffe/util/gpu_memory.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -15,7 +15,8 @@ namespace caffe { #endif gpu_memory::PoolMode gpu_memory::mode_ = gpu_memory::NoPool; - size_t gpu_memory::poolsize_ = 0; + // default is to cache everything, no limit on pool size + size_t gpu_memory::poolsize_ = size_t(-1); bool gpu_memory::debug_ = false; #ifdef CPU_ONLY // CPU-only Caffe. @@ -86,50 +87,15 @@ namespace caffe { } } - void gpu_memory::registerStream(cudaStream_t stream) { - switch (mode_) { - case CubPool: - default: - break; - } - } - void gpu_memory::initMEM(const std::vector& gpus, PoolMode m) { mode_ = m; int initial_device; - CUDA_CHECK(cudaGetDevice(&initial_device)); - - for (int i = 0; i < gpus.size(); i++) { - CUDA_CHECK(cudaSetDevice(gpus[i])); - size_t free_mem, total_mem; - cudaDeviceProp props; - CUDA_CHECK(cudaGetDeviceProperties(&props, gpus[i])); - CUDA_CHECK(cudaMemGetInfo(&free_mem, &total_mem)); - - if (debug_) { - std::cout << "cudaGetDeviceProperties: Mem = " - << props.totalGlobalMem <device == device) && (block_itr->bin == search_key.bin)) { - - // use special rule for the last ("exact size") bin: set max memory overuse to 1/8th - if (search_key.bin == -1 && (block_itr->bytes - search_key.bytes)*8UL > search_key.bytes) - break; - cudaStream_t prev_stream = block_itr->associated_stream; if ((active_stream == prev_stream) || (cudaEventQuery(block_itr->ready_event) != cudaErrorNotReady)) { @@ -465,11 +460,11 @@ struct CachingDeviceAllocator error = cudaMalloc(&search_key.d_ptr, search_key.bytes); // } } - if (CubDebug(error)) + if (CubDebug(error)) return error; - if (CubDebug(error = cudaEventCreateWithFlags(&search_key.ready_event, cudaEventDisableTiming))) + if (CubDebug(error = cudaEventCreateWithFlags(&search_key.ready_event, cudaEventDisableTiming))) return error; - + // Insert into live blocks Lock(&spin_lock); live_blocks.insert(search_key); @@ -548,30 +543,30 @@ struct CachingDeviceAllocator // Lock Lock(&spin_lock); - + // Find corresponding block descriptor BusyBlocks::iterator block_itr = live_blocks.find(search_key); if (block_itr != live_blocks.end()) { // Remove from live blocks search_key = *block_itr; - live_blocks.erase(block_itr); + live_blocks.erase(block_itr); cached_bytes[device].busy -= search_key.bytes; - + // Check if we should keep the returned allocation if (cached_bytes[device].free + search_key.bytes <= max_cached_bytes) - { + { // Insert returned allocation into free blocks cached_blocks.insert(search_key); cached_bytes[device].free += search_key.bytes; recached = true; - if (debug) { + if (debug) { CubLog("\tdevice %d returned %lld bytes from associated stream %lld.\n\t\t %lld available blocks cached (%lld bytes), %lld live blocks outstanding. (%lld bytes)\n", - device, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) cached_blocks.size(), + device, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) cached_blocks.size(), (long long) cached_bytes[device].free, (long long) live_blocks.size(), (long long) cached_bytes[device].busy); } } } - + Unlock(&spin_lock); if (recached) { @@ -585,7 +580,7 @@ struct CachingDeviceAllocator return error; if (CubDebug(error = cudaSetDevice(device))) return error; } - + // Actually free device memory if (CubDebug(error = cudaFree(d_ptr))) return error; if (CubDebug(error = cudaEventDestroy(search_key.ready_event))) return error; diff --git a/src/caffe/util/gpu_memory.cpp b/src/caffe/util/gpu_memory.cpp index 95e6fdb8626..5dd312153cc 100644 --- a/src/caffe/util/gpu_memory.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -15,8 +15,7 @@ namespace caffe { #endif gpu_memory::PoolMode gpu_memory::mode_ = gpu_memory::NoPool; - // default is to cache everything, no limit on pool size - size_t gpu_memory::poolsize_ = size_t(-1); + size_t gpu_memory::poolsize_ = 0; bool gpu_memory::debug_ = false; #ifdef CPU_ONLY // CPU-only Caffe. @@ -87,15 +86,50 @@ namespace caffe { } } + void gpu_memory::registerStream(cudaStream_t stream) { + switch (mode_) { + case CubPool: + default: + break; + } + } + void gpu_memory::initMEM(const std::vector& gpus, PoolMode m) { mode_ = m; int initial_device; + CUDA_CHECK(cudaGetDevice(&initial_device)); + + for (int i = 0; i < gpus.size(); i++) { + CUDA_CHECK(cudaSetDevice(gpus[i])); + size_t free_mem, total_mem; + cudaDeviceProp props; + CUDA_CHECK(cudaGetDeviceProperties(&props, gpus[i])); + CUDA_CHECK(cudaMemGetInfo(&free_mem, &total_mem)); + + if (debug_) { + std::cout << "cudaGetDeviceProperties: Mem = " + << props.totalGlobalMem <bytes - search_key.bytes)*8UL > search_key.bytes) + break; + cudaStream_t prev_stream = block_itr->associated_stream; if ((active_stream == prev_stream) || (cudaEventQuery(block_itr->ready_event) != cudaErrorNotReady)) { @@ -460,11 +465,11 @@ struct CachingDeviceAllocator error = cudaMalloc(&search_key.d_ptr, search_key.bytes); // } } - if (CubDebug(error)) + if (CubDebug(error)) return error; - if (CubDebug(error = cudaEventCreateWithFlags(&search_key.ready_event, cudaEventDisableTiming))) + if (CubDebug(error = cudaEventCreateWithFlags(&search_key.ready_event, cudaEventDisableTiming))) return error; - + // Insert into live blocks Lock(&spin_lock); live_blocks.insert(search_key); @@ -543,30 +548,30 @@ struct CachingDeviceAllocator // Lock Lock(&spin_lock); - + // Find corresponding block descriptor BusyBlocks::iterator block_itr = live_blocks.find(search_key); if (block_itr != live_blocks.end()) { // Remove from live blocks search_key = *block_itr; - live_blocks.erase(block_itr); + live_blocks.erase(block_itr); cached_bytes[device].busy -= search_key.bytes; - + // Check if we should keep the returned allocation if (cached_bytes[device].free + search_key.bytes <= max_cached_bytes) - { + { // Insert returned allocation into free blocks cached_blocks.insert(search_key); cached_bytes[device].free += search_key.bytes; recached = true; - if (debug) { + if (debug) { CubLog("\tdevice %d returned %lld bytes from associated stream %lld.\n\t\t %lld available blocks cached (%lld bytes), %lld live blocks outstanding. (%lld bytes)\n", - device, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) cached_blocks.size(), + device, (long long) search_key.bytes, (long long) search_key.associated_stream, (long long) cached_blocks.size(), (long long) cached_bytes[device].free, (long long) live_blocks.size(), (long long) cached_bytes[device].busy); } } } - + Unlock(&spin_lock); if (recached) { @@ -580,7 +585,7 @@ struct CachingDeviceAllocator return error; if (CubDebug(error = cudaSetDevice(device))) return error; } - + // Actually free device memory if (CubDebug(error = cudaFree(d_ptr))) return error; if (CubDebug(error = cudaEventDestroy(search_key.ready_event))) return error; From b61ebf0eec6ab8c423d2cc00973886d14b776322 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Tue, 1 Dec 2015 23:42:00 -0800 Subject: [PATCH 315/331] Fixing GPU arena setup --- include/caffe/util/gpu_memory.hpp | 14 +++++++--- src/caffe/util/gpu_memory.cpp | 46 +++++++++++++++++-------------- 2 files changed, 36 insertions(+), 24 deletions(-) diff --git a/include/caffe/util/gpu_memory.hpp b/include/caffe/util/gpu_memory.hpp index b1a6c919cf7..c57d98a78be 100644 --- a/include/caffe/util/gpu_memory.hpp +++ b/include/caffe/util/gpu_memory.hpp @@ -83,11 +83,17 @@ class gpu_memory { static void init(const std::vector&, PoolMode, bool); static void destroy(); - static bool initialized_; - static PoolMode mode_; - static size_t poolsize_; - static bool debug_; + static bool initialized_; + static PoolMode mode_; + static bool debug_; + #ifndef CPU_ONLY + struct MemInfo { + size_t free; + size_t total; + }; + + static vector dev_info_; public: typedef void* pointer; diff --git a/src/caffe/util/gpu_memory.cpp b/src/caffe/util/gpu_memory.cpp index 5dd312153cc..30e404e5f1b 100644 --- a/src/caffe/util/gpu_memory.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -12,10 +12,10 @@ namespace caffe { #ifndef CPU_ONLY // CPU-only Caffe. static cub::CachingDeviceAllocator* cubAlloc = 0; + vector gpu_memory::dev_info_; #endif gpu_memory::PoolMode gpu_memory::mode_ = gpu_memory::NoPool; - size_t gpu_memory::poolsize_ = 0; bool gpu_memory::debug_ = false; #ifdef CPU_ONLY // CPU-only Caffe. @@ -43,8 +43,7 @@ namespace caffe { } if (debug) std::cout << "gpu_memory initialized with " - << getPoolName() << ". Poolsize = " - << (1.0*poolsize_)/(1024.0*1024.0*1024.0) << " G." << std::endl; + << getPoolName() << std::endl; } void gpu_memory::destroy() { @@ -100,39 +99,44 @@ namespace caffe { CUDA_CHECK(cudaGetDevice(&initial_device)); + for (int i = 0; i < gpus.size(); i++) { + int cur_device = gpus[i]; + if (cur_device+1 > dev_info_.size()) + dev_info_.resize(cur_device+1); + CUDA_CHECK(cudaSetDevice(gpus[i])); - size_t free_mem, total_mem; cudaDeviceProp props; - CUDA_CHECK(cudaGetDeviceProperties(&props, gpus[i])); - CUDA_CHECK(cudaMemGetInfo(&free_mem, &total_mem)); + CUDA_CHECK(cudaGetDeviceProperties(&props, cur_device)); + CUDA_CHECK(cudaMemGetInfo(&dev_info_[cur_device].free, + &dev_info_[cur_device].total)); if (debug_) { std::cout << "cudaGetDeviceProperties: Mem = " - << props.totalGlobalMem <bytes, (long long) cached_blocks.size(), (long long) cached_bytes[current_device].free, (long long) live_blocks.size(), (long long) cached_bytes[current_device].free); + current_device, (long long) begin->bytes, (long long) cached_blocks.size(), (long long) cached_bytes[current_device].free, (long long) live_blocks.size(), (long long) cached_bytes[current_device].busy); } Unlock(&spin_lock); From 1c678452b9034aa891850f749e00d6df6cb044b8 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Wed, 2 Dec 2015 15:23:03 -0800 Subject: [PATCH 317/331] d --- tools/caffe.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/caffe.cpp b/tools/caffe.cpp index f6dbb89ec2d..306a5a55d34 100644 --- a/tools/caffe.cpp +++ b/tools/caffe.cpp @@ -407,7 +407,7 @@ int main(int argc, char** argv) { // initialize gpu memory arena vector gpus; get_gpus(&gpus); - caffe::gpu_memory::arena arena(gpus, caffe::gpu_memory::DefaultPool, true); + caffe::gpu_memory::arena arena(gpus); if (argc == 2) { #ifdef WITH_PYTHON_LAYER From b52ab92e59e9efea5e8b58548f70558c1b26e41b Mon Sep 17 00:00:00 2001 From: thatguymike Date: Wed, 2 Dec 2015 20:27:18 -0800 Subject: [PATCH 318/331] Cross merge fixes from Boris --- 3rdparty/cub/cub/util_allocator.cuh | 7 ++++- include/caffe/util/gpu_memory.hpp | 14 ++++++--- src/caffe/util/gpu_memory.cpp | 49 +++++++++++++++-------------- tools/caffe.cpp | 2 +- 4 files changed, 42 insertions(+), 30 deletions(-) diff --git a/3rdparty/cub/cub/util_allocator.cuh b/3rdparty/cub/cub/util_allocator.cuh index 7f6bebe7f74..8de32cdbc47 100644 --- a/3rdparty/cub/cub/util_allocator.cuh +++ b/3rdparty/cub/cub/util_allocator.cuh @@ -407,6 +407,11 @@ struct CachingDeviceAllocator while ( (block_itr != cached_blocks.end()) && (block_itr->device == device) && (block_itr->bin == search_key.bin)) { + + // use special rule for the last ("exact size") bin: set max memory overuse to 1/8th + if (search_key.bin == (unsigned int) -1 && (block_itr->bytes - search_key.bytes)*8UL > search_key.bytes) + break; + cudaStream_t prev_stream = block_itr->associated_stream; if ((active_stream == prev_stream) || (cudaEventQuery(block_itr->ready_event) != cudaErrorNotReady)) { @@ -662,7 +667,7 @@ struct CachingDeviceAllocator cached_blocks.erase(begin); if (debug) CubLog("\tdevice %d freed %lld bytes.\n\t\t %lld available blocks cached (%lld bytes), %lld live blocks (%lld bytes) outstanding.\n", - current_device, (long long) begin->bytes, (long long) cached_blocks.size(), (long long) cached_bytes[current_device].free, (long long) live_blocks.size(), (long long) cached_bytes[current_device].free); + current_device, (long long) begin->bytes, (long long) cached_blocks.size(), (long long) cached_bytes[current_device].free, (long long) live_blocks.size(), (long long) cached_bytes[current_device].busy); } Unlock(&spin_lock); diff --git a/include/caffe/util/gpu_memory.hpp b/include/caffe/util/gpu_memory.hpp index b1a6c919cf7..c57d98a78be 100644 --- a/include/caffe/util/gpu_memory.hpp +++ b/include/caffe/util/gpu_memory.hpp @@ -83,11 +83,17 @@ class gpu_memory { static void init(const std::vector&, PoolMode, bool); static void destroy(); - static bool initialized_; - static PoolMode mode_; - static size_t poolsize_; - static bool debug_; + static bool initialized_; + static PoolMode mode_; + static bool debug_; + #ifndef CPU_ONLY + struct MemInfo { + size_t free; + size_t total; + }; + + static vector dev_info_; public: typedef void* pointer; diff --git a/src/caffe/util/gpu_memory.cpp b/src/caffe/util/gpu_memory.cpp index 65e9b1cc19c..8db4178530e 100644 --- a/src/caffe/util/gpu_memory.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -12,10 +12,10 @@ namespace caffe { #ifndef CPU_ONLY // CPU-only Caffe. static cub::CachingDeviceAllocator* cubAlloc = 0; + vector gpu_memory::dev_info_; #endif gpu_memory::PoolMode gpu_memory::mode_ = gpu_memory::NoPool; - size_t gpu_memory::poolsize_ = 0; bool gpu_memory::debug_ = false; #ifdef CPU_ONLY // CPU-only Caffe. @@ -43,8 +43,7 @@ namespace caffe { } if (debug) std::cout << "gpu_memory initialized with " - << getPoolName() << ". Poolsize = " - << (1.0*poolsize_)/(1024.0*1024.0*1024.0) << " G." << std::endl; + << getPoolName() << std::endl; } void gpu_memory::destroy() { @@ -101,42 +100,42 @@ namespace caffe { CUDA_CHECK(cudaGetDevice(&initial_device)); for (int i = 0; i < gpus.size(); i++) { + int cur_device = gpus[i]; + if (cur_device+1 > dev_info_.size()) + dev_info_.resize(cur_device+1); + CUDA_CHECK(cudaSetDevice(gpus[i])); - size_t free_mem, total_mem; cudaDeviceProp props; - CUDA_CHECK(cudaGetDeviceProperties(&props, gpus[i])); - CUDA_CHECK(cudaMemGetInfo(&free_mem, &total_mem)); + CUDA_CHECK(cudaGetDeviceProperties(&props, cur_device)); + CUDA_CHECK(cudaMemGetInfo(&dev_info_[cur_device].free, + &dev_info_[cur_device].total)); if (debug_) { std::cout << "cudaGetDeviceProperties: Mem = " - << props.totalGlobalMem <& gpus, PoolMode m, bool debug) { - debug_ = debug; + + bool debug_env = (getenv("DEBUG_GPU_MEM")!=0); + debug_ = debug || debug_env; + if (gpus.size() <= 0) { // should we report an error here ? m = gpu_memory::NoPool; From db610fdb7235f4d0750142bc290f5ac6c6eb5320 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 3 Dec 2015 13:28:36 -0800 Subject: [PATCH 320/331] Mark v0.14.0-rc.3 --- CMakeLists.txt | 2 +- Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 5db96196761..f932ef909fe 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8.7) project(Caffe C CXX) # ---[ Caffe version -set(CAFFE_TARGET_VERSION "0.14.0-rc.2") +set(CAFFE_TARGET_VERSION "0.14.0-rc.3") set(CAFFE_TARGET_SOVERSION "0.14") add_definitions(-DCAFFE_VERSION=${CAFFE_TARGET_VERSION}) diff --git a/Makefile b/Makefile index 212488110d7..e2538d577a7 100644 --- a/Makefile +++ b/Makefile @@ -43,7 +43,7 @@ LIB_BUILD_DIR := $(BUILD_DIR)/lib STATIC_NAME := $(LIB_BUILD_DIR)/lib$(LIBRARY_NAME).a DYNAMIC_VERSION_MAJOR := 0 DYNAMIC_VERSION_MINOR := 14 -DYNAMIC_VERSION_REVISION := 0-rc.2 +DYNAMIC_VERSION_REVISION := 0-rc.3 DYNAMIC_NAME_SHORT := lib$(LIBRARY_NAME).so DYNAMIC_SONAME_SHORT := $(DYNAMIC_NAME_SHORT).$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR) DYNAMIC_VERSIONED_NAME_SHORT := $(DYNAMIC_SONAME_SHORT).$(DYNAMIC_VERSION_REVISION) From 3fc98dd71c6ef13d4ae0995663f9f8a7023f6357 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 3 Dec 2015 13:28:36 -0800 Subject: [PATCH 321/331] Mark v0.14.0-rc.3 --- CMakeLists.txt | 2 +- Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 5db96196761..f932ef909fe 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8.7) project(Caffe C CXX) # ---[ Caffe version -set(CAFFE_TARGET_VERSION "0.14.0-rc.2") +set(CAFFE_TARGET_VERSION "0.14.0-rc.3") set(CAFFE_TARGET_SOVERSION "0.14") add_definitions(-DCAFFE_VERSION=${CAFFE_TARGET_VERSION}) diff --git a/Makefile b/Makefile index 212488110d7..e2538d577a7 100644 --- a/Makefile +++ b/Makefile @@ -43,7 +43,7 @@ LIB_BUILD_DIR := $(BUILD_DIR)/lib STATIC_NAME := $(LIB_BUILD_DIR)/lib$(LIBRARY_NAME).a DYNAMIC_VERSION_MAJOR := 0 DYNAMIC_VERSION_MINOR := 14 -DYNAMIC_VERSION_REVISION := 0-rc.2 +DYNAMIC_VERSION_REVISION := 0-rc.3 DYNAMIC_NAME_SHORT := lib$(LIBRARY_NAME).so DYNAMIC_SONAME_SHORT := $(DYNAMIC_NAME_SHORT).$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR) DYNAMIC_VERSIONED_NAME_SHORT := $(DYNAMIC_SONAME_SHORT).$(DYNAMIC_VERSION_REVISION) From 8a2ab8e098dc87ad0dd7fb2b76bf83bc3fdacda5 Mon Sep 17 00:00:00 2001 From: Boris Fomitchev Date: Wed, 13 Jan 2016 14:18:13 -0800 Subject: [PATCH 322/331] gpu_memory cleanup, fixes possible init issue --- 3rdparty/cub/cub/util_allocator.cuh | 10 --- Makefile | 2 +- include/caffe/util/gpu_memory.hpp | 11 +++- src/caffe/util/gpu_memory.cpp | 95 ++++++++++++++++++----------- 4 files changed, 68 insertions(+), 50 deletions(-) diff --git a/3rdparty/cub/cub/util_allocator.cuh b/3rdparty/cub/cub/util_allocator.cuh index ff19cad55ce..42b020c9b1c 100644 --- a/3rdparty/cub/cub/util_allocator.cuh +++ b/3rdparty/cub/cub/util_allocator.cuh @@ -454,16 +454,6 @@ struct CachingDeviceAllocator if (error != cudaSuccess) { if (debug) CubLog("\tdevice %d failed to allocate %lld bytes for stream %lld", device, (long long) search_key.bytes, (long long) search_key.associated_stream); - - // if (search_key.bytes < cached_bytes[device]) { - // free all cached memory (for all devices), synchrionize and retry once - cudaDeviceSynchronize(); - cudaThreadSynchronize(); - FreeAllCached(); - cudaDeviceSynchronize(); - cudaThreadSynchronize(); - error = cudaMalloc(&search_key.d_ptr, search_key.bytes); - // } } if (CubDebug(error)) return error; diff --git a/Makefile b/Makefile index e2538d577a7..65703758574 100644 --- a/Makefile +++ b/Makefile @@ -571,7 +571,7 @@ $(DYNAMIC_NAME): $(OBJS)| $(LIB_BUILD_DIR) @ cd $(BUILD_DIR)/lib; rm -f $(DYNAMIC_SONAME_SHORT); ln -s $(DYNAMIC_VERSIONED_NAME_SHORT) $(DYNAMIC_SONAME_SHORT) @ cd $(BUILD_DIR)/lib; rm -f $(DYNAMIC_NAME_SHORT); ln -s $(DYNAMIC_SONAME_SHORT) $(DYNAMIC_NAME_SHORT) -$(STATIC_NAME): $(OBJS) | $(LIB_BUILD_DIR) +$(STATIC_NAME): $(OBJS) | $(LIB_BUILD_DIR) @ echo AR -o $@ $(Q)ar rcs $@ $(OBJS) diff --git a/include/caffe/util/gpu_memory.hpp b/include/caffe/util/gpu_memory.hpp index c57d98a78be..4fdf2a465a8 100644 --- a/include/caffe/util/gpu_memory.hpp +++ b/include/caffe/util/gpu_memory.hpp @@ -77,6 +77,8 @@ class gpu_memory { cudaStream_t stream_; size_t size_; }; + static void update_dev_info(int device); + # endif private: @@ -89,8 +91,12 @@ class gpu_memory { #ifndef CPU_ONLY struct MemInfo { - size_t free; - size_t total; + MemInfo() { + free = total = flush_count = 0; + } + size_t free; + size_t total; + unsigned flush_count; }; static vector dev_info_; @@ -102,7 +108,6 @@ class gpu_memory { cudaStream_t stream = cudaStreamDefault); static void deallocate(pointer ptr, cudaStream_t = cudaStreamDefault); - static void registerStream(cudaStream_t stream); static void getInfo(size_t *free_mem, size_t *used_mem); private: diff --git a/src/caffe/util/gpu_memory.cpp b/src/caffe/util/gpu_memory.cpp index 5e35ef43059..70c8a31c5ed 100644 --- a/src/caffe/util/gpu_memory.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -67,7 +67,30 @@ namespace caffe { CHECK((ptr) != NULL); switch (mode_) { case CubPool: - CUDA_CHECK(cubAlloc->DeviceAllocate(ptr, size, stream)); + if (cubAlloc->DeviceAllocate(ptr, size, stream) != cudaSuccess) + { + int cur_device; + CUDA_CHECK(cudaGetDevice(&cur_device)); + // free all cached memory (for all devices), synchrionize + cudaDeviceSynchronize(); + cudaThreadSynchronize(); + cubAlloc->FreeAllCached(); + cudaDeviceSynchronize(); + cudaThreadSynchronize(); + + // Refresh per-device saved values. + for (int i = 0; i < dev_info_.size(); i++) { + // only query devices that were initialized + if (dev_info_[i].total) { + update_dev_info(i); + // record which device caused cache flush + if (i == cur_device) + dev_info_[i].flush_count++; + } + } + // retry once + CUDA_CHECK(cubAlloc->DeviceAllocate(ptr, size, stream)); + } break; default: CUDA_CHECK(cudaMalloc(ptr, size)); @@ -89,46 +112,43 @@ namespace caffe { } } - void gpu_memory::registerStream(cudaStream_t stream) { - switch (mode_) { - case CubPool: - default: - break; - } - } - void gpu_memory::initMEM(const std::vector& gpus, PoolMode m) { - mode_ = m; + void gpu_memory::update_dev_info(int device) { int initial_device; - CUDA_CHECK(cudaGetDevice(&initial_device)); + if (device+1 > dev_info_.size()) + dev_info_.resize(device+1); + + CUDA_CHECK(cudaSetDevice(device)); + cudaDeviceProp props; + CUDA_CHECK(cudaGetDeviceProperties(&props, device)); + CUDA_CHECK(cudaMemGetInfo(&dev_info_[device].free, + &dev_info_[device].total)); + + if (debug_) { + std::cout << "cudaGetDeviceProperties: Mem = " + << props.totalGlobalMem <DeviceAllocate(ptr, size, stream) != cudaSuccess) - { + if (cubAlloc->DeviceAllocate(ptr, size, stream) != cudaSuccess) { int cur_device; CUDA_CHECK(cudaGetDevice(&cur_device)); // free all cached memory (for all devices), synchrionize @@ -148,8 +146,6 @@ namespace caffe { void gpu_memory::initMEM(const std::vector& gpus, PoolMode m) { mode_ = m; - int initial_device; - switch ( mode_ ) { case CubPool: try { @@ -165,11 +161,9 @@ namespace caffe { } catch (...) {} CHECK(cubAlloc); - for (int i = 0; i < gpus.size(); i++) { update_dev_info(gpus[i]); } - break; default: break; From 569aa498d05a558727b7cf27648b6874f70d54c2 Mon Sep 17 00:00:00 2001 From: Sergei Nikolaev Date: Mon, 18 Jan 2016 15:27:40 -0800 Subject: [PATCH 324/331] cuDNN and pooling fixes --- src/caffe/layer_factory.cpp | 7 +++++++ src/caffe/layers/cudnn_batch_norm_layer.cu | 4 ++++ 2 files changed, 11 insertions(+) diff --git a/src/caffe/layer_factory.cpp b/src/caffe/layer_factory.cpp index 0d1625602db..2237175daa8 100644 --- a/src/caffe/layer_factory.cpp +++ b/src/caffe/layer_factory.cpp @@ -78,7 +78,14 @@ shared_ptr > GetPoolingLayer(const LayerParameter& param) { #ifdef USE_CUDNN } else if (engine == PoolingParameter_Engine_CUDNN) { PoolingParameter p_param = param.pooling_param(); + +// FIXME We assume that precision issue will be fixed in cuDNN v5.0 +#if CUDNN_VERSION >= 5000 return shared_ptr >(new CuDNNPoolingLayer(param)); +#else + return shared_ptr >(new PoolingLayer(param)); +#endif + #endif } else { LOG(FATAL) << "Layer " << param.name() << " has unknown engine."; diff --git a/src/caffe/layers/cudnn_batch_norm_layer.cu b/src/caffe/layers/cudnn_batch_norm_layer.cu index bc1ee25154d..bacb80e9b09 100644 --- a/src/caffe/layers/cudnn_batch_norm_layer.cu +++ b/src/caffe/layers/cudnn_batch_norm_layer.cu @@ -85,6 +85,10 @@ void CuDNNBatchNormLayer::Backward_gpu( mode_, cudnn::dataType::one, cudnn::dataType::zero, +#if CUDNN_VERSION >= 4005 + cudnn::dataType::one, + cudnn::dataType::zero, +#endif bottom_desc_, bottom_data, bottom_desc_, From 3724101655bf79b73e0bf8fcd801ac9c82d6d3c5 Mon Sep 17 00:00:00 2001 From: thatguymike Date: Tue, 19 Jan 2016 15:58:44 -0800 Subject: [PATCH 325/331] Cleaner workaround for max pool --- src/caffe/layer_factory.cpp | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/src/caffe/layer_factory.cpp b/src/caffe/layer_factory.cpp index 2237175daa8..33b128f4e7d 100644 --- a/src/caffe/layer_factory.cpp +++ b/src/caffe/layer_factory.cpp @@ -79,13 +79,14 @@ shared_ptr > GetPoolingLayer(const LayerParameter& param) { } else if (engine == PoolingParameter_Engine_CUDNN) { PoolingParameter p_param = param.pooling_param(); -// FIXME We assume that precision issue will be fixed in cuDNN v5.0 -#if CUDNN_VERSION >= 5000 - return shared_ptr >(new CuDNNPoolingLayer(param)); -#else - return shared_ptr >(new PoolingLayer(param)); -#endif - +// CuDNN handles tie breaks differently than Caffe for MaxPooling. +// Until there is a workaround in Caffe (index management) or cuDNN, +// use Caffe layer to max pooling + if (param.pooling_param().pool() == PoolingParameter_PoolMethod_MAX) { + return shared_ptr >(new PoolingLayer(param)); + } else { + return shared_ptr >(new CuDNNPoolingLayer(param)); + } #endif } else { LOG(FATAL) << "Layer " << param.name() << " has unknown engine."; From fc6dea9787c0406ab20497d15cbcb55589609682 Mon Sep 17 00:00:00 2001 From: thatguymike Date: Tue, 19 Jan 2016 16:51:52 -0800 Subject: [PATCH 326/331] Fix commentary --- src/caffe/layer_factory.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/caffe/layer_factory.cpp b/src/caffe/layer_factory.cpp index 33b128f4e7d..e2e99726872 100644 --- a/src/caffe/layer_factory.cpp +++ b/src/caffe/layer_factory.cpp @@ -79,9 +79,11 @@ shared_ptr > GetPoolingLayer(const LayerParameter& param) { } else if (engine == PoolingParameter_Engine_CUDNN) { PoolingParameter p_param = param.pooling_param(); -// CuDNN handles tie breaks differently than Caffe for MaxPooling. -// Until there is a workaround in Caffe (index management) or cuDNN, -// use Caffe layer to max pooling +// CuDNN assumes layers are not being modified in place, thus breaking +// our index tracking for updates in some cases in Caffe. Until there +// is a workaround in Caffe (index management) or cuDNN, use Caffe +// layer to max pooling, or don't use in place layers after max +// pooling layers if (param.pooling_param().pool() == PoolingParameter_PoolMethod_MAX) { return shared_ptr >(new PoolingLayer(param)); } else { From 2e4d2ae4820783c8af1d72e1e3c6f63027fc1f0a Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Wed, 20 Jan 2016 10:29:47 -0800 Subject: [PATCH 327/331] Mark v0.14.0 --- CMakeLists.txt | 2 +- Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f932ef909fe..5dfb8269591 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8.7) project(Caffe C CXX) # ---[ Caffe version -set(CAFFE_TARGET_VERSION "0.14.0-rc.3") +set(CAFFE_TARGET_VERSION "0.14.0") set(CAFFE_TARGET_SOVERSION "0.14") add_definitions(-DCAFFE_VERSION=${CAFFE_TARGET_VERSION}) diff --git a/Makefile b/Makefile index 65703758574..c9d2b69c2c2 100644 --- a/Makefile +++ b/Makefile @@ -43,7 +43,7 @@ LIB_BUILD_DIR := $(BUILD_DIR)/lib STATIC_NAME := $(LIB_BUILD_DIR)/lib$(LIBRARY_NAME).a DYNAMIC_VERSION_MAJOR := 0 DYNAMIC_VERSION_MINOR := 14 -DYNAMIC_VERSION_REVISION := 0-rc.3 +DYNAMIC_VERSION_REVISION := 0 DYNAMIC_NAME_SHORT := lib$(LIBRARY_NAME).so DYNAMIC_SONAME_SHORT := $(DYNAMIC_NAME_SHORT).$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR) DYNAMIC_VERSIONED_NAME_SHORT := $(DYNAMIC_SONAME_SHORT).$(DYNAMIC_VERSION_REVISION) From 444051357c11d113afcbb4e3579f734a3b67a24d Mon Sep 17 00:00:00 2001 From: Sergei Nikolaev Date: Thu, 21 Jan 2016 12:42:52 -0800 Subject: [PATCH 328/331] weight updates should be done with beta=1 --- src/caffe/layers/cudnn_batch_norm_layer.cu | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/caffe/layers/cudnn_batch_norm_layer.cu b/src/caffe/layers/cudnn_batch_norm_layer.cu index bacb80e9b09..cddfa7051aa 100644 --- a/src/caffe/layers/cudnn_batch_norm_layer.cu +++ b/src/caffe/layers/cudnn_batch_norm_layer.cu @@ -87,7 +87,7 @@ void CuDNNBatchNormLayer::Backward_gpu( cudnn::dataType::zero, #if CUDNN_VERSION >= 4005 cudnn::dataType::one, - cudnn::dataType::zero, + cudnn::dataType::one, #endif bottom_desc_, bottom_data, From c887de9b86715c35542e4239f09280b5cfd94bf1 Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 21 Jan 2016 13:40:35 -0800 Subject: [PATCH 329/331] Mark v0.14.1 --- CMakeLists.txt | 2 +- Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 5dfb8269591..ef88fa1f26d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8.7) project(Caffe C CXX) # ---[ Caffe version -set(CAFFE_TARGET_VERSION "0.14.0") +set(CAFFE_TARGET_VERSION "0.14.1") set(CAFFE_TARGET_SOVERSION "0.14") add_definitions(-DCAFFE_VERSION=${CAFFE_TARGET_VERSION}) diff --git a/Makefile b/Makefile index c9d2b69c2c2..cb1a6e17ddd 100644 --- a/Makefile +++ b/Makefile @@ -43,7 +43,7 @@ LIB_BUILD_DIR := $(BUILD_DIR)/lib STATIC_NAME := $(LIB_BUILD_DIR)/lib$(LIBRARY_NAME).a DYNAMIC_VERSION_MAJOR := 0 DYNAMIC_VERSION_MINOR := 14 -DYNAMIC_VERSION_REVISION := 0 +DYNAMIC_VERSION_REVISION := 1 DYNAMIC_NAME_SHORT := lib$(LIBRARY_NAME).so DYNAMIC_SONAME_SHORT := $(DYNAMIC_NAME_SHORT).$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR) DYNAMIC_VERSIONED_NAME_SHORT := $(DYNAMIC_SONAME_SHORT).$(DYNAMIC_VERSION_REVISION) From b0074e158b198c8b285993b382c2921d8d9a0728 Mon Sep 17 00:00:00 2001 From: Sergei Nikolaev Date: Thu, 28 Jan 2016 16:57:15 -0800 Subject: [PATCH 330/331] 200169109 fix --- src/caffe/util/gpu_memory.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/caffe/util/gpu_memory.cpp b/src/caffe/util/gpu_memory.cpp index da990b88af0..92f2a6764c8 100644 --- a/src/caffe/util/gpu_memory.cpp +++ b/src/caffe/util/gpu_memory.cpp @@ -88,6 +88,8 @@ namespace caffe { } // retry once CUDA_CHECK(cubAlloc->DeviceAllocate(ptr, size, stream)); + // If retry succeeds we need to clean up last error: + cudaGetLastError(); } break; default: From 29361c73ad56377a7121e7030d5b6b4dd842034d Mon Sep 17 00:00:00 2001 From: Luke Yeager Date: Thu, 28 Jan 2016 17:30:34 -0800 Subject: [PATCH 331/331] Mark v0.14.2 --- CMakeLists.txt | 2 +- Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index ef88fa1f26d..3b2760cf4f7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8.7) project(Caffe C CXX) # ---[ Caffe version -set(CAFFE_TARGET_VERSION "0.14.1") +set(CAFFE_TARGET_VERSION "0.14.2") set(CAFFE_TARGET_SOVERSION "0.14") add_definitions(-DCAFFE_VERSION=${CAFFE_TARGET_VERSION}) diff --git a/Makefile b/Makefile index cb1a6e17ddd..7cd5b3cf6e5 100644 --- a/Makefile +++ b/Makefile @@ -43,7 +43,7 @@ LIB_BUILD_DIR := $(BUILD_DIR)/lib STATIC_NAME := $(LIB_BUILD_DIR)/lib$(LIBRARY_NAME).a DYNAMIC_VERSION_MAJOR := 0 DYNAMIC_VERSION_MINOR := 14 -DYNAMIC_VERSION_REVISION := 1 +DYNAMIC_VERSION_REVISION := 2 DYNAMIC_NAME_SHORT := lib$(LIBRARY_NAME).so DYNAMIC_SONAME_SHORT := $(DYNAMIC_NAME_SHORT).$(DYNAMIC_VERSION_MAJOR).$(DYNAMIC_VERSION_MINOR) DYNAMIC_VERSIONED_NAME_SHORT := $(DYNAMIC_SONAME_SHORT).$(DYNAMIC_VERSION_REVISION)

    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�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